From f9bf1209d8aa0a34d0834813747c7708e4c50873 Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Tue, 21 Sep 2021 06:38:58 -0400
Subject: [PATCH 01/15] setting up environment for week 4 assignment

---
 .vscode/c_cpp_properties.json | 56 ++++++++++++++++++++++++-----------
 app/9_4.cpp                   |  0
 app/CMakeLists.txt            |  2 +-
 include/9_4.hpp               |  0
 include/lib.hpp               |  8 -----
 5 files changed, 40 insertions(+), 26 deletions(-)
 create mode 100644 app/9_4.cpp
 create mode 100644 include/9_4.hpp
 delete mode 100644 include/lib.hpp

diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json
index 7f19e678..fab88f23 100644
--- a/.vscode/c_cpp_properties.json
+++ b/.vscode/c_cpp_properties.json
@@ -6,28 +6,50 @@
                 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1",
                 "${workspaceRoot}/vendor/gtest/include",
                 "${workspaceRoot}/vendor/boost",
-                "/usr/include"
+                "/usr/include",
+                "${workspaceFolder}/include"
+            ],
+            "browse": {
+                "limitSymbolsToIncludedHeaders": true,
+                "databaseFilename": ""
+            },
+            "macFrameworkPath": [
+                "/System/Library/Frameworks",
+                "/Library/Frameworks"
             ],
-            "browse" : {
-                "limitSymbolsToIncludedHeaders" : true,
-                "databaseFilename" : ""
-            }
+            "intelliSenseMode": "macos-clang-x64",
+            "compilerPath": "/opt/homebrew/bin/gcc-11",
+            "cStandard": "gnu17",
+            "cppStandard": "gnu++17"
         },
         {
             "name": "Linux",
-            "includePath": ["/usr/include"],
-            "browse" : {
-                "limitSymbolsToIncludedHeaders" : true,
-                "databaseFilename" : ""
-            }
+            "includePath": [
+                "/usr/include"
+            ],
+            "browse": {
+                "limitSymbolsToIncludedHeaders": true,
+                "databaseFilename": ""
+            },
+            "intelliSenseMode": "linux-gcc-x64",
+            "compilerPath": "/opt/homebrew/bin/gcc-11",
+            "cStandard": "gnu17",
+            "cppStandard": "gnu++17"
         },
         {
             "name": "Win32",
-            "includePath": ["c:/Program Files (x86)/Microsoft Visual Studio 14.0/VC/include"],
-            "browse" : {
-                "limitSymbolsToIncludedHeaders" : true,
-                "databaseFilename" : ""
-            }
+            "includePath": [
+                "c:/Program Files (x86)/Microsoft Visual Studio 14.0/VC/include"
+            ],
+            "browse": {
+                "limitSymbolsToIncludedHeaders": true,
+                "databaseFilename": ""
+            },
+            "intelliSenseMode": "windows-msvc-x64",
+            "compilerPath": "/opt/homebrew/bin/gcc-11",
+            "cStandard": "gnu17",
+            "cppStandard": "gnu++17"
         }
-    ]
-}
+    ],
+    "version": 4
+}
\ No newline at end of file
diff --git a/app/9_4.cpp b/app/9_4.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt
index c2d13dbe..68fb4f28 100644
--- a/app/CMakeLists.txt
+++ b/app/CMakeLists.txt
@@ -1,4 +1,4 @@
-add_executable(shell-app main.cpp)
+add_executable(shell-app main.cpp 9_5.cpp)
 include_directories(
     ${CMAKE_SOURCE_DIR}/include
 )
diff --git a/include/9_4.hpp b/include/9_4.hpp
new file mode 100644
index 00000000..e69de29b
diff --git a/include/lib.hpp b/include/lib.hpp
deleted file mode 100644
index 45fd193f..00000000
--- a/include/lib.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-
-#include<iostream>
-
-void dummy()
-{
-    std::cout << "HI" << std::endl;
-}

From 12c9884619a2a8f8c7a94d8f686782d2eecf90a4 Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Tue, 21 Sep 2021 11:18:31 -0400
Subject: [PATCH 02/15] making directory changes

---
 app/softwareEng_9_4.cpp                     | 0
 include/softwareEng_9_4.hpp                 | 0
 softwareEng_9_4/app/CMakeLists.txt          | 4 ++++
 softwareEng_9_4/app/main.cpp                | 8 ++++++++
 softwareEng_9_4/app/softwareEng_9_4.cpp     | 0
 softwareEng_9_4/include/softwareEng_9_4.hpp | 0
 6 files changed, 12 insertions(+)
 create mode 100644 app/softwareEng_9_4.cpp
 create mode 100644 include/softwareEng_9_4.hpp
 create mode 100644 softwareEng_9_4/app/CMakeLists.txt
 create mode 100644 softwareEng_9_4/app/main.cpp
 create mode 100644 softwareEng_9_4/app/softwareEng_9_4.cpp
 create mode 100644 softwareEng_9_4/include/softwareEng_9_4.hpp

diff --git a/app/softwareEng_9_4.cpp b/app/softwareEng_9_4.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/include/softwareEng_9_4.hpp b/include/softwareEng_9_4.hpp
new file mode 100644
index 00000000..e69de29b
diff --git a/softwareEng_9_4/app/CMakeLists.txt b/softwareEng_9_4/app/CMakeLists.txt
new file mode 100644
index 00000000..68fb4f28
--- /dev/null
+++ b/softwareEng_9_4/app/CMakeLists.txt
@@ -0,0 +1,4 @@
+add_executable(shell-app main.cpp 9_5.cpp)
+include_directories(
+    ${CMAKE_SOURCE_DIR}/include
+)
diff --git a/softwareEng_9_4/app/main.cpp b/softwareEng_9_4/app/main.cpp
new file mode 100644
index 00000000..74232ade
--- /dev/null
+++ b/softwareEng_9_4/app/main.cpp
@@ -0,0 +1,8 @@
+#include <iostream>
+#include <lib.hpp>
+
+int main()
+{
+    dummy();
+    return 0;
+}
diff --git a/softwareEng_9_4/app/softwareEng_9_4.cpp b/softwareEng_9_4/app/softwareEng_9_4.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/softwareEng_9_4/include/softwareEng_9_4.hpp b/softwareEng_9_4/include/softwareEng_9_4.hpp
new file mode 100644
index 00000000..e69de29b

From fc3c75913fa81dea06924b0a6a9e2ca9da446107 Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Tue, 21 Sep 2021 15:57:13 -0400
Subject: [PATCH 03/15] uploading week 3 assignments into boiler repo.
 submitted source code on time via canvas

---
 .vscode/c_cpp_properties.json                 |  11 +-
 .vscode/launch.json                           |  21 ++
 .vscode/settings.json                         |  90 +++++++-
 .vscode/tasks.json                            |  28 +++
 app/9_4.cpp                                   |   0
 app/CMakeLists.txt                            |   2 +-
 include/9_4.hpp                               |   0
 week3/AcceleratedC++3-5/CMakeLists.txt        |  29 +++
 week3/AcceleratedC++3-5/UML/3_5_UML.jpg       | Bin 0 -> 309075 bytes
 .../app/AcceleratedC++3-5.cpp                 |  70 ++++++
 week3/AcceleratedC++3-5/app/CMakeLists.txt    |   5 +
 week3/AcceleratedC++3-5/app/main.cpp          |   8 +
 .../cmake/CodeCoverage.cmake                  | 203 ++++++++++++++++++
 .../include/AcceleratedC++3-5.hpp             |  40 ++++
 week3/AcceleratedC++3-5/include/lib.hpp       |   8 +
 week3/AcceleratedC++3-5/test/CMakeLists.txt   |  11 +
 week3/AcceleratedC++3-5/test/main.cpp         |   6 +
 week3/AcceleratedC++3-5/test/test.cpp         |   5 +
 week3/AcceleratedC++4-5/CMakeLists.txt        |  29 +++
 week3/AcceleratedC++4-5/UML/4_5_UML.jpg       | Bin 0 -> 264172 bytes
 .../app/AcceleratedC++4-5.cpp                 |  74 +++++++
 week3/AcceleratedC++4-5/app/CMakeLists.txt    |   5 +
 week3/AcceleratedC++4-5/app/main.cpp          |   8 +
 .../cmake/CodeCoverage.cmake                  | 203 ++++++++++++++++++
 .../include/AcceleratedC++4-5.hpp             |  40 ++++
 week3/AcceleratedC++4-5/include/lib.hpp       |   8 +
 week3/AcceleratedC++4-5/test/CMakeLists.txt   |  11 +
 week3/AcceleratedC++4-5/test/main.cpp         |   6 +
 week3/AcceleratedC++4-5/test/test.cpp         |   5 +
 week3/AcceleratedC++4-7/CMakeLists.txt        |  29 +++
 week3/AcceleratedC++4-7/UML/4_7_UML.jpeg      | Bin 0 -> 987504 bytes
 .../app/AcceleratedC++4-7.cpp                 |  41 ++++
 week3/AcceleratedC++4-7/app/CMakeLists.txt    |   5 +
 week3/AcceleratedC++4-7/app/main.cpp          |   8 +
 .../cmake/CodeCoverage.cmake                  | 203 ++++++++++++++++++
 .../include/AcceleratedC++4-7.hpp             |  28 +++
 week3/AcceleratedC++4-7/include/lib.hpp       |   8 +
 week3/AcceleratedC++4-7/test/CMakeLists.txt   |  11 +
 week3/AcceleratedC++4-7/test/main.cpp         |   6 +
 week3/AcceleratedC++4-7/test/test.cpp         |   5 +
 week3/AcceleratedC++6-9/CMakeLists.txt        |  29 +++
 week3/AcceleratedC++6-9/UML/6_9_UML.jpeg      | Bin 0 -> 601486 bytes
 .../app/AcceleratedC++6-9.cpp                 |  36 ++++
 week3/AcceleratedC++6-9/app/CMakeLists.txt    |   5 +
 week3/AcceleratedC++6-9/app/main.cpp          |   8 +
 .../cmake/CodeCoverage.cmake                  | 203 ++++++++++++++++++
 .../include/AcceleratedC++6-9.hpp             |  35 +++
 week3/AcceleratedC++6-9/include/lib.hpp       |   8 +
 week3/AcceleratedC++6-9/test/CMakeLists.txt   |  11 +
 week3/AcceleratedC++6-9/test/main.cpp         |   6 +
 week3/AcceleratedC++6-9/test/test.cpp         |   5 +
 week3/Ouput screenshots/3_10_output.png       | Bin 0 -> 1001177 bytes
 week3/Ouput screenshots/3_5_output.png        | Bin 0 -> 1240741 bytes
 week3/Ouput screenshots/4_5_output.png        | Bin 0 -> 1339124 bytes
 week3/Ouput screenshots/4_7_output.png        | Bin 0 -> 1226431 bytes
 week3/Ouput screenshots/6_9_output.png        | Bin 0 -> 1300650 bytes
 week3/SoftwareEngineering3-10/CMakeLists.txt  |  29 +++
 .../SoftwareEngineering3-10/UML/3_10_UML.jpg  | Bin 0 -> 241494 bytes
 .../app/CMakeLists.txt                        |   5 +
 .../app/SoftwareEngineering3-10.cpp           |  91 ++++++++
 week3/SoftwareEngineering3-10/app/main.cpp    |   8 +
 .../cmake/CodeCoverage.cmake                  | 203 ++++++++++++++++++
 .../include/SoftwareEngineering3-10.hpp       |  37 ++++
 week3/SoftwareEngineering3-10/include/lib.hpp |   8 +
 .../test/CMakeLists.txt                       |  11 +
 week3/SoftwareEngineering3-10/test/main.cpp   |   6 +
 week3/SoftwareEngineering3-10/test/test.cpp   |   5 +
 week3/sumedh_117386066_writing_assignment.pdf | Bin 0 -> 535852 bytes
 68 files changed, 2013 insertions(+), 6 deletions(-)
 create mode 100644 .vscode/launch.json
 create mode 100644 .vscode/tasks.json
 delete mode 100644 app/9_4.cpp
 delete mode 100644 include/9_4.hpp
 create mode 100644 week3/AcceleratedC++3-5/CMakeLists.txt
 create mode 100644 week3/AcceleratedC++3-5/UML/3_5_UML.jpg
 create mode 100644 week3/AcceleratedC++3-5/app/AcceleratedC++3-5.cpp
 create mode 100644 week3/AcceleratedC++3-5/app/CMakeLists.txt
 create mode 100644 week3/AcceleratedC++3-5/app/main.cpp
 create mode 100644 week3/AcceleratedC++3-5/cmake/CodeCoverage.cmake
 create mode 100644 week3/AcceleratedC++3-5/include/AcceleratedC++3-5.hpp
 create mode 100644 week3/AcceleratedC++3-5/include/lib.hpp
 create mode 100644 week3/AcceleratedC++3-5/test/CMakeLists.txt
 create mode 100644 week3/AcceleratedC++3-5/test/main.cpp
 create mode 100644 week3/AcceleratedC++3-5/test/test.cpp
 create mode 100644 week3/AcceleratedC++4-5/CMakeLists.txt
 create mode 100644 week3/AcceleratedC++4-5/UML/4_5_UML.jpg
 create mode 100644 week3/AcceleratedC++4-5/app/AcceleratedC++4-5.cpp
 create mode 100644 week3/AcceleratedC++4-5/app/CMakeLists.txt
 create mode 100644 week3/AcceleratedC++4-5/app/main.cpp
 create mode 100644 week3/AcceleratedC++4-5/cmake/CodeCoverage.cmake
 create mode 100644 week3/AcceleratedC++4-5/include/AcceleratedC++4-5.hpp
 create mode 100644 week3/AcceleratedC++4-5/include/lib.hpp
 create mode 100644 week3/AcceleratedC++4-5/test/CMakeLists.txt
 create mode 100644 week3/AcceleratedC++4-5/test/main.cpp
 create mode 100644 week3/AcceleratedC++4-5/test/test.cpp
 create mode 100644 week3/AcceleratedC++4-7/CMakeLists.txt
 create mode 100644 week3/AcceleratedC++4-7/UML/4_7_UML.jpeg
 create mode 100644 week3/AcceleratedC++4-7/app/AcceleratedC++4-7.cpp
 create mode 100644 week3/AcceleratedC++4-7/app/CMakeLists.txt
 create mode 100644 week3/AcceleratedC++4-7/app/main.cpp
 create mode 100644 week3/AcceleratedC++4-7/cmake/CodeCoverage.cmake
 create mode 100644 week3/AcceleratedC++4-7/include/AcceleratedC++4-7.hpp
 create mode 100644 week3/AcceleratedC++4-7/include/lib.hpp
 create mode 100644 week3/AcceleratedC++4-7/test/CMakeLists.txt
 create mode 100644 week3/AcceleratedC++4-7/test/main.cpp
 create mode 100644 week3/AcceleratedC++4-7/test/test.cpp
 create mode 100644 week3/AcceleratedC++6-9/CMakeLists.txt
 create mode 100644 week3/AcceleratedC++6-9/UML/6_9_UML.jpeg
 create mode 100644 week3/AcceleratedC++6-9/app/AcceleratedC++6-9.cpp
 create mode 100644 week3/AcceleratedC++6-9/app/CMakeLists.txt
 create mode 100644 week3/AcceleratedC++6-9/app/main.cpp
 create mode 100644 week3/AcceleratedC++6-9/cmake/CodeCoverage.cmake
 create mode 100644 week3/AcceleratedC++6-9/include/AcceleratedC++6-9.hpp
 create mode 100644 week3/AcceleratedC++6-9/include/lib.hpp
 create mode 100644 week3/AcceleratedC++6-9/test/CMakeLists.txt
 create mode 100644 week3/AcceleratedC++6-9/test/main.cpp
 create mode 100644 week3/AcceleratedC++6-9/test/test.cpp
 create mode 100644 week3/Ouput screenshots/3_10_output.png
 create mode 100644 week3/Ouput screenshots/3_5_output.png
 create mode 100644 week3/Ouput screenshots/4_5_output.png
 create mode 100644 week3/Ouput screenshots/4_7_output.png
 create mode 100644 week3/Ouput screenshots/6_9_output.png
 create mode 100644 week3/SoftwareEngineering3-10/CMakeLists.txt
 create mode 100644 week3/SoftwareEngineering3-10/UML/3_10_UML.jpg
 create mode 100644 week3/SoftwareEngineering3-10/app/CMakeLists.txt
 create mode 100644 week3/SoftwareEngineering3-10/app/SoftwareEngineering3-10.cpp
 create mode 100644 week3/SoftwareEngineering3-10/app/main.cpp
 create mode 100644 week3/SoftwareEngineering3-10/cmake/CodeCoverage.cmake
 create mode 100644 week3/SoftwareEngineering3-10/include/SoftwareEngineering3-10.hpp
 create mode 100644 week3/SoftwareEngineering3-10/include/lib.hpp
 create mode 100644 week3/SoftwareEngineering3-10/test/CMakeLists.txt
 create mode 100644 week3/SoftwareEngineering3-10/test/main.cpp
 create mode 100644 week3/SoftwareEngineering3-10/test/test.cpp
 create mode 100644 week3/sumedh_117386066_writing_assignment.pdf

diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json
index fab88f23..1232ff40 100644
--- a/.vscode/c_cpp_properties.json
+++ b/.vscode/c_cpp_properties.json
@@ -4,10 +4,13 @@
             "name": "Mac",
             "includePath": [
                 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1",
-                "${workspaceRoot}/vendor/gtest/include",
-                "${workspaceRoot}/vendor/boost",
-                "/usr/include",
-                "${workspaceFolder}/include"
+                "${workspaceFolder}/include",
+                "${workspaceFolder}/week3/AcceleratedC++3-5/include",
+                "${workspaceFolder}/week3/AcceleratedC++3-5/include",
+                "${workspaceFolder}/week3/SoftwareEngineering3-10/include",
+                "${workspaceFolder}/week3/AcceleratedC++6-9/include",
+                "${workspaceFolder}/week3/AcceleratedC++4-7/include",
+                "${workspaceFolder}/week3/AcceleratedC++4-5/include"
             ],
             "browse": {
                 "limitSymbolsToIncludedHeaders": true,
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 00000000..3d5e66ad
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,21 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+      {
+        "name": "clang++ - Build and debug active file",
+        "type": "cppdbg",
+        "request": "launch",
+        "program": "${fileDirname}/${fileBasenameNoExtension}",
+        "args": [],
+        "stopAtEntry": true,
+        "cwd": "${workspaceFolder}",
+        "environment": [],
+        "externalConsole": false,
+        "MIMode": "lldb",
+        "preLaunchTask": "clang++ build active file"
+      }
+    ]
+  }
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 95395d85..763eb90a 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -22,5 +22,93 @@
         "ms-vscode.cpptools",
         "RichardHe.you-complete-me",
         "vector-of-bool.cmake-tools"
-	]
+    ],
+    "files.associations": {
+        "__bit_reference": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__functional_base": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__nullptr": "cpp",
+        "__split_buffer": "cpp",
+        "__string": "cpp",
+        "__threading_support": "cpp",
+        "__tree": "cpp",
+        "__tuple": "cpp",
+        "algorithm": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "codecvt": "cpp",
+        "compare": "cpp",
+        "complex": "cpp",
+        "concepts": "cpp",
+        "condition_variable": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "exception": "cpp",
+        "forward_list": "cpp",
+        "fstream": "cpp",
+        "functional": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "iterator": "cpp",
+        "limits": "cpp",
+        "list": "cpp",
+        "locale": "cpp",
+        "map": "cpp",
+        "memory": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "queue": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "semaphore": "cpp",
+        "set": "cpp",
+        "sstream": "cpp",
+        "stack": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "thread": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "utility": "cpp",
+        "vector": "cpp",
+        "hash_map": "cpp",
+        "hash_set": "cpp",
+        "*.tcc": "cpp",
+        "memory_resource": "cpp",
+        "stop_token": "cpp",
+        "cinttypes": "cpp"
+    }
 }
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
new file mode 100644
index 00000000..b0148880
--- /dev/null
+++ b/.vscode/tasks.json
@@ -0,0 +1,28 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+      {
+        "type": "shell",
+        "label": "clang++ build active file",
+        "command": "/usr/bin/clang++",
+        "args": [
+          "-std=c++17",
+          "-stdlib=libc++",
+          "-g",
+          "${file}",
+          "-o",
+          "${fileDirname}/${fileBasenameNoExtension}"
+        ],
+        "options": {
+          "cwd": "${workspaceFolder}"
+        },
+        "problemMatcher": ["$gcc"],
+        "group": {
+          "kind": "build",
+          "isDefault": true
+        }
+      }
+    ]
+  }
\ No newline at end of file
diff --git a/app/9_4.cpp b/app/9_4.cpp
deleted file mode 100644
index e69de29b..00000000
diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt
index 68fb4f28..8ce2e095 100644
--- a/app/CMakeLists.txt
+++ b/app/CMakeLists.txt
@@ -1,4 +1,4 @@
-add_executable(shell-app main.cpp 9_5.cpp)
+add_executable(shell-app 9_5.cpp)
 include_directories(
     ${CMAKE_SOURCE_DIR}/include
 )
diff --git a/include/9_4.hpp b/include/9_4.hpp
deleted file mode 100644
index e69de29b..00000000
diff --git a/week3/AcceleratedC++3-5/CMakeLists.txt b/week3/AcceleratedC++3-5/CMakeLists.txt
new file mode 100644
index 00000000..ccddcaf2
--- /dev/null
+++ b/week3/AcceleratedC++3-5/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.2.1)
+project (scratch)
+
+# Add project cmake modules to path.
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake)
+
+# We probably don't want this to run on every build.
+option(COVERAGE "Generate Coverage Data" OFF)
+
+if (COVERAGE)
+    include(CodeCoverage)
+    set(LCOV_REMOVE_EXTRA "'vendor/*'")
+    setup_target_for_coverage(code_coverage test/cpp-test coverage)
+    set(COVERAGE_SRCS app/main.cpp include/lib.hpp)
+
+    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+    SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+    SET(CMAKE_EXE_LINKER_FLAGS "-fprofile-arcs -ftest-coverage")
+else()
+    set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wpedantic -g")
+endif()
+
+include(CMakeToolsHelpers OPTIONAL)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_CXX_STANDARD 14)
+
+add_subdirectory(app)
+add_subdirectory(test)
+add_subdirectory(vendor/googletest/googletest)
diff --git a/week3/AcceleratedC++3-5/UML/3_5_UML.jpg b/week3/AcceleratedC++3-5/UML/3_5_UML.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..45b94eeb8ab2f9b7c91af8018910798505c11158
GIT binary patch
literal 309075
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
J#{d2Pe*qlrI1B&)

literal 0
HcmV?d00001

diff --git a/week3/AcceleratedC++3-5/app/AcceleratedC++3-5.cpp b/week3/AcceleratedC++3-5/app/AcceleratedC++3-5.cpp
new file mode 100644
index 00000000..ad6ad2c3
--- /dev/null
+++ b/week3/AcceleratedC++3-5/app/AcceleratedC++3-5.cpp
@@ -0,0 +1,70 @@
+/**
+ *  @copyright (c) 2021 Sumedh Reddy
+ *  @file    AcceleratedC++3-5.cpp
+ *  @author  SumedhReddy
+ *
+ *  @brief solution
+ *
+ */
+
+#include "AcceleratedC++3-5.hpp"
+
+/**
+ * @brief grader method calculates the grades of the 
+ * students entered
+ */
+void student::grader() {
+    std::vector < int > temp;
+    int sum = 0;
+    for (int q = 0; q < student_data.grade.size(); q++) {
+      temp = student_data.grade[q];
+      sum = 0;
+      for (unsigned int m = 0; m < temp.size(); m++) {
+        sum = sum + temp[m];
+      }
+      student_data.finalGrade.push_back(sum);
+    }
+  }
+
+/**
+ * @brief display method displays the students data  
+ * with name and final/overall grade
+ */
+  void student::display() {
+    std::cout << "Displaying Student data:\n";
+    grader();
+    for (unsigned int i = 0; i < student_data.name.size(); i++) {
+      std::cout << "Student Name: " << student_data.name[i] << ", " << "Overall Grade:" << student_data.finalGrade[i] << std::endl;
+    }
+  }
+
+int main() {
+  student obj;   // object for student class
+  std::string stuName;   // variable to capture student name
+  // variable t is for number of students data to be inserted
+  // variable g is for number of grades to each student
+  int t, g, m;
+  std::vector < int > stuGrade;
+  std::cout << "Enter number of Students data to be inserted:";
+  std::cin >> t;
+  for (int k = 0; k < t; k++) {
+    std::cout << "Enter the name of the student:";
+    std::cin >> stuName;
+    // inserting student name into vector of struct data type student_data
+    obj.student_data.name.push_back(stuName);
+    std::cout << "Enter the number of grades to enter: ";
+    std::cin >> g;
+    stuGrade.clear();
+    // looping to get grades from user for a partiular student
+    for (int i = 0; i < g; i++) {
+      std::cout << "Enter the grade:" << i + 1 << " for the student:" << std::endl;
+      std::cin >> m;
+      stuGrade.push_back(m);
+    }
+    // pushing grades into vector named grade
+    obj.student_data.grade.push_back(stuGrade);
+  }
+
+  obj.display();    // display method to display student data with final grades
+  return 0;
+}
\ No newline at end of file
diff --git a/week3/AcceleratedC++3-5/app/CMakeLists.txt b/week3/AcceleratedC++3-5/app/CMakeLists.txt
new file mode 100644
index 00000000..31a9b14f
--- /dev/null
+++ b/week3/AcceleratedC++3-5/app/CMakeLists.txt
@@ -0,0 +1,5 @@
+
+add_executable(shell-app AcceleratedC++3-5.cpp)
+include_directories(
+    ${CMAKE_SOURCE_DIR}/include
+)
diff --git a/week3/AcceleratedC++3-5/app/main.cpp b/week3/AcceleratedC++3-5/app/main.cpp
new file mode 100644
index 00000000..74232ade
--- /dev/null
+++ b/week3/AcceleratedC++3-5/app/main.cpp
@@ -0,0 +1,8 @@
+#include <iostream>
+#include <lib.hpp>
+
+int main()
+{
+    dummy();
+    return 0;
+}
diff --git a/week3/AcceleratedC++3-5/cmake/CodeCoverage.cmake b/week3/AcceleratedC++3-5/cmake/CodeCoverage.cmake
new file mode 100644
index 00000000..50dffc7d
--- /dev/null
+++ b/week3/AcceleratedC++3-5/cmake/CodeCoverage.cmake
@@ -0,0 +1,203 @@
+# Copyright (c) 2012 - 2015, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. 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.
+#
+# 3. Neither the name of the copyright holder 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 HOLDER 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.
+#
+#
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# USAGE:
+
+# 0. (Mac only) If you use Xcode 5.1 make sure to patch geninfo as described here:
+#      http://stackoverflow.com/a/22404544/80480
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt:
+#      INCLUDE(CodeCoverage)
+#
+# 3. Set compiler flags to turn off optimization and enable coverage:
+#    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#	 SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#
+# 3. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target
+#    which runs your test executable and produces a lcov code coverage report:
+#    Example:
+#	 SETUP_TARGET_FOR_COVERAGE(
+#				my_coverage_target  # Name for custom target.
+#				test_driver         # Name of the test driver executable that runs the tests.
+#									# NOTE! This should always have a ZERO as exit code
+#									# otherwise the coverage generation will not complete.
+#				coverage            # Name of output directory.
+#				)
+#
+#    If you need to exclude additional directories from the report, specify them
+#    using the LCOV_REMOVE_EXTRA variable before calling SETUP_TARGET_FOR_COVERAGE.
+#    For example:
+#
+#    set(LCOV_REMOVE_EXTRA "'thirdparty/*'")
+#
+# 4. Build a Debug build:
+#	 cmake -DCMAKE_BUILD_TYPE=Debug ..
+#	 make
+#	 make my_coverage_target
+#
+#
+
+# Check prereqs
+FIND_PROGRAM( GCOV_PATH gcov )
+FIND_PROGRAM( LCOV_PATH lcov )
+FIND_PROGRAM( GENHTML_PATH genhtml )
+FIND_PROGRAM( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/tests)
+
+IF(NOT GCOV_PATH)
+	MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
+ENDIF() # NOT GCOV_PATH
+
+IF("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+	IF("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
+		MESSAGE(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+	ENDIF()
+ELSEIF(NOT CMAKE_COMPILER_IS_GNUCXX)
+	MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+ENDIF() # CHECK VALID COMPILER
+
+SET(CMAKE_CXX_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+SET(CMAKE_C_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+SET(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+SET(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+MARK_AS_ADVANCED(
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+IF ( NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "Coverage"))
+  MESSAGE( WARNING "Code coverage results with an optimized (non-Debug) build may be misleading" )
+ENDIF() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
+
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests.
+#						MUST return ZERO always, even on errors.
+#						If not, no coverage report will be created!
+# Param _outputname     lcov output is generated as _outputname.info
+#                       HTML report is generated in _outputname/index.html
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
+
+	IF(NOT LCOV_PATH)
+		MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
+	ENDIF() # NOT LCOV_PATH
+
+	IF(NOT GENHTML_PATH)
+		MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
+	ENDIF() # NOT GENHTML_PATH
+
+	SET(coverage_info "${CMAKE_BINARY_DIR}/${_outputname}.info")
+	SET(coverage_cleaned "${coverage_info}.cleaned")
+
+	SEPARATE_ARGUMENTS(test_command UNIX_COMMAND "${_testrunner}")
+
+	# Setup target
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Cleanup lcov
+		${LCOV_PATH} --directory . --zerocounters
+
+		# Run tests
+		COMMAND ${test_command} ${ARGV3}
+
+		# Capturing lcov counters and generating report
+		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${coverage_info}
+		COMMAND ${LCOV_PATH} --remove ${coverage_info} 'tests/*' '/usr/*' ${LCOV_REMOVE_EXTRA} --output-file ${coverage_cleaned}
+		COMMAND ${GENHTML_PATH} -o ${_outputname} ${coverage_cleaned}
+		COMMAND ${CMAKE_COMMAND} -E remove ${coverage_info} ${coverage_cleaned}
+
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests
+# Param _outputname     cobertura output is generated as _outputname.xml
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE_COBERTURA _targetname _testrunner _outputname)
+
+	IF(NOT PYTHON_EXECUTABLE)
+		MESSAGE(FATAL_ERROR "Python not found! Aborting...")
+	ENDIF() # NOT PYTHON_EXECUTABLE
+
+	IF(NOT GCOVR_PATH)
+		MESSAGE(FATAL_ERROR "gcovr not found! Aborting...")
+	ENDIF() # NOT GCOVR_PATH
+
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Run tests
+		${_testrunner} ${ARGV3}
+
+		# Running gcovr
+		COMMAND ${GCOVR_PATH} -x -r ${CMAKE_SOURCE_DIR} -e '${CMAKE_SOURCE_DIR}/tests/'  -o ${_outputname}.xml
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Running gcovr to produce Cobertura code coverage report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Cobertura code coverage report saved in ${_outputname}.xml."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE_COBERTURA
diff --git a/week3/AcceleratedC++3-5/include/AcceleratedC++3-5.hpp b/week3/AcceleratedC++3-5/include/AcceleratedC++3-5.hpp
new file mode 100644
index 00000000..a78d054c
--- /dev/null
+++ b/week3/AcceleratedC++3-5/include/AcceleratedC++3-5.hpp
@@ -0,0 +1,40 @@
+/**
+ *  @copyright (c) 2021 Sumedh Reddy Koppula
+ *  @file    AcceleratedC++4-7.hpp
+ *  @author  SumedhReddy 
+ *
+ *  @brief Header
+ *
+ */
+
+#pragma once
+
+#include <iostream>
+
+#include <string>
+
+#include <vector>
+
+#include <numeric>
+
+/**
+ * @brief data class has 2 methods, to grade and
+ * display students data. Here I stored input data into an 
+ * object using data struct. data is structure comprising students data
+ */
+struct data {
+      std::vector < std::string > name;
+      std::vector < std::vector < int > > grade;
+      std::vector < int > finalGrade;
+    };
+class student {
+ public:
+    data student_data;
+    void grader();
+    void display();
+    student();
+}; 
+
+student::student(void) {
+  
+}
diff --git a/week3/AcceleratedC++3-5/include/lib.hpp b/week3/AcceleratedC++3-5/include/lib.hpp
new file mode 100644
index 00000000..45fd193f
--- /dev/null
+++ b/week3/AcceleratedC++3-5/include/lib.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include<iostream>
+
+void dummy()
+{
+    std::cout << "HI" << std::endl;
+}
diff --git a/week3/AcceleratedC++3-5/test/CMakeLists.txt b/week3/AcceleratedC++3-5/test/CMakeLists.txt
new file mode 100644
index 00000000..2b1cd4cb
--- /dev/null
+++ b/week3/AcceleratedC++3-5/test/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(GTEST_SHUFFLE 1)
+
+add_executable(
+    cpp-test
+    main.cpp
+    test.cpp
+)
+
+target_include_directories(cpp-test PUBLIC ../vendor/googletest/googletest/include 
+                                           ${CMAKE_SOURCE_DIR}/include)
+target_link_libraries(cpp-test PUBLIC gtest)
diff --git a/week3/AcceleratedC++3-5/test/main.cpp b/week3/AcceleratedC++3-5/test/main.cpp
new file mode 100644
index 00000000..697a9d70
--- /dev/null
+++ b/week3/AcceleratedC++3-5/test/main.cpp
@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/week3/AcceleratedC++3-5/test/test.cpp b/week3/AcceleratedC++3-5/test/test.cpp
new file mode 100644
index 00000000..2c5cd069
--- /dev/null
+++ b/week3/AcceleratedC++3-5/test/test.cpp
@@ -0,0 +1,5 @@
+#include <gtest/gtest.h>
+
+TEST(dummy, should_pass) {
+  EXPECT_EQ(1, 1);
+}
diff --git a/week3/AcceleratedC++4-5/CMakeLists.txt b/week3/AcceleratedC++4-5/CMakeLists.txt
new file mode 100644
index 00000000..ccddcaf2
--- /dev/null
+++ b/week3/AcceleratedC++4-5/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.2.1)
+project (scratch)
+
+# Add project cmake modules to path.
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake)
+
+# We probably don't want this to run on every build.
+option(COVERAGE "Generate Coverage Data" OFF)
+
+if (COVERAGE)
+    include(CodeCoverage)
+    set(LCOV_REMOVE_EXTRA "'vendor/*'")
+    setup_target_for_coverage(code_coverage test/cpp-test coverage)
+    set(COVERAGE_SRCS app/main.cpp include/lib.hpp)
+
+    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+    SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+    SET(CMAKE_EXE_LINKER_FLAGS "-fprofile-arcs -ftest-coverage")
+else()
+    set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wpedantic -g")
+endif()
+
+include(CMakeToolsHelpers OPTIONAL)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_CXX_STANDARD 14)
+
+add_subdirectory(app)
+add_subdirectory(test)
+add_subdirectory(vendor/googletest/googletest)
diff --git a/week3/AcceleratedC++4-5/UML/4_5_UML.jpg b/week3/AcceleratedC++4-5/UML/4_5_UML.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..6655a45f5cb064c4c9c0f4bd75b4a5f15da83192
GIT binary patch
literal 264172
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%0D8`c
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
XsDW3_S?@h@B;$Is#aScj&#(UieL#MN

literal 0
HcmV?d00001

diff --git a/week3/AcceleratedC++4-5/app/AcceleratedC++4-5.cpp b/week3/AcceleratedC++4-5/app/AcceleratedC++4-5.cpp
new file mode 100644
index 00000000..330eb1e5
--- /dev/null
+++ b/week3/AcceleratedC++4-5/app/AcceleratedC++4-5.cpp
@@ -0,0 +1,74 @@
+/**
+ *  @copyright (c) 2021 Sumedh Reddy
+ *  @file    AcceleratedC++4-5.cpp
+ *  @author  SumedhReddy
+ *
+ *  @brief solution
+ *
+ */
+
+#include "AcceleratedC++4-5.hpp"
+
+/**
+ * @brief read method is used to read input string 
+ * words, count them and store in a vector
+ */
+
+  int Reader::read(std::string s) {
+    // using istringstream to stream the string into individual words
+    // copy all identified words into a vector named words
+    std::istringstream iss(s);
+    copy(std::istream_iterator < std::string > (iss),
+      std::istream_iterator < std::string > (),
+      back_inserter(words));
+    return words.size();
+  }
+
+/**
+ * @brief uniquewordscount method is used to 
+ * count unique words and store in a vector
+ */
+
+  int uniquewordscount(const std::vector < std::string > & words) {
+    // storing vector words into tempWords vector
+    std::vector < std::string > tmpWords = words;
+
+    typedef std::vector < std::string > ::size_type vec_sz;
+    const vec_sz numElements = tmpWords.size();
+
+    if (numElements == 0) return 0;
+    else if (numElements == 1) return 1;
+    // sorting temporary words
+    sort(tmpWords.begin(), tmpWords.end());
+    const vec_sz numLoops = numElements - 1;
+
+    vec_sz A = 0;
+    vec_sz B = 1;
+    int numUniqueWords = 1;
+    for (vec_sz i = 0; i != numLoops; ++i) {
+      if (tmpWords[B] != tmpWords[A])
+        ++numUniqueWords;
+      ++A;
+      ++B;
+    }
+
+    return numUniqueWords;
+  }
+
+int main() {
+// Creating an object for the class Reader
+  Reader readObj;
+  std::string s;
+  int output;
+  std::cout << "Enter the string:" << std::endl;
+  // feeding input string from the user
+  getline(std::cin, s);
+  // passing input string to read method in the class Reader
+  output = readObj.read(s);
+  // passing vector words, which contains all the words in the
+  // input string to uniquewordscount() method to calculate unique words
+  auto count = readObj.uniquewordscount(readObj.words);
+  std::cout << "Number of words in the input string: " << output << std::endl;
+  std::cout << "Number unique words in the string: " << count << std::endl;
+  return 0;
+}
\ No newline at end of file
diff --git a/week3/AcceleratedC++4-5/app/CMakeLists.txt b/week3/AcceleratedC++4-5/app/CMakeLists.txt
new file mode 100644
index 00000000..105fccc1
--- /dev/null
+++ b/week3/AcceleratedC++4-5/app/CMakeLists.txt
@@ -0,0 +1,5 @@
+
+add_executable(shell-app AcceleratedC++4-5.cpp)
+include_directories(
+    ${CMAKE_SOURCE_DIR}/include
+)
diff --git a/week3/AcceleratedC++4-5/app/main.cpp b/week3/AcceleratedC++4-5/app/main.cpp
new file mode 100644
index 00000000..74232ade
--- /dev/null
+++ b/week3/AcceleratedC++4-5/app/main.cpp
@@ -0,0 +1,8 @@
+#include <iostream>
+#include <lib.hpp>
+
+int main()
+{
+    dummy();
+    return 0;
+}
diff --git a/week3/AcceleratedC++4-5/cmake/CodeCoverage.cmake b/week3/AcceleratedC++4-5/cmake/CodeCoverage.cmake
new file mode 100644
index 00000000..50dffc7d
--- /dev/null
+++ b/week3/AcceleratedC++4-5/cmake/CodeCoverage.cmake
@@ -0,0 +1,203 @@
+# Copyright (c) 2012 - 2015, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. 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.
+#
+# 3. Neither the name of the copyright holder 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 HOLDER 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.
+#
+#
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# USAGE:
+
+# 0. (Mac only) If you use Xcode 5.1 make sure to patch geninfo as described here:
+#      http://stackoverflow.com/a/22404544/80480
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt:
+#      INCLUDE(CodeCoverage)
+#
+# 3. Set compiler flags to turn off optimization and enable coverage:
+#    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#	 SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#
+# 3. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target
+#    which runs your test executable and produces a lcov code coverage report:
+#    Example:
+#	 SETUP_TARGET_FOR_COVERAGE(
+#				my_coverage_target  # Name for custom target.
+#				test_driver         # Name of the test driver executable that runs the tests.
+#									# NOTE! This should always have a ZERO as exit code
+#									# otherwise the coverage generation will not complete.
+#				coverage            # Name of output directory.
+#				)
+#
+#    If you need to exclude additional directories from the report, specify them
+#    using the LCOV_REMOVE_EXTRA variable before calling SETUP_TARGET_FOR_COVERAGE.
+#    For example:
+#
+#    set(LCOV_REMOVE_EXTRA "'thirdparty/*'")
+#
+# 4. Build a Debug build:
+#	 cmake -DCMAKE_BUILD_TYPE=Debug ..
+#	 make
+#	 make my_coverage_target
+#
+#
+
+# Check prereqs
+FIND_PROGRAM( GCOV_PATH gcov )
+FIND_PROGRAM( LCOV_PATH lcov )
+FIND_PROGRAM( GENHTML_PATH genhtml )
+FIND_PROGRAM( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/tests)
+
+IF(NOT GCOV_PATH)
+	MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
+ENDIF() # NOT GCOV_PATH
+
+IF("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+	IF("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
+		MESSAGE(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+	ENDIF()
+ELSEIF(NOT CMAKE_COMPILER_IS_GNUCXX)
+	MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+ENDIF() # CHECK VALID COMPILER
+
+SET(CMAKE_CXX_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+SET(CMAKE_C_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+SET(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+SET(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+MARK_AS_ADVANCED(
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+IF ( NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "Coverage"))
+  MESSAGE( WARNING "Code coverage results with an optimized (non-Debug) build may be misleading" )
+ENDIF() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
+
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests.
+#						MUST return ZERO always, even on errors.
+#						If not, no coverage report will be created!
+# Param _outputname     lcov output is generated as _outputname.info
+#                       HTML report is generated in _outputname/index.html
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
+
+	IF(NOT LCOV_PATH)
+		MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
+	ENDIF() # NOT LCOV_PATH
+
+	IF(NOT GENHTML_PATH)
+		MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
+	ENDIF() # NOT GENHTML_PATH
+
+	SET(coverage_info "${CMAKE_BINARY_DIR}/${_outputname}.info")
+	SET(coverage_cleaned "${coverage_info}.cleaned")
+
+	SEPARATE_ARGUMENTS(test_command UNIX_COMMAND "${_testrunner}")
+
+	# Setup target
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Cleanup lcov
+		${LCOV_PATH} --directory . --zerocounters
+
+		# Run tests
+		COMMAND ${test_command} ${ARGV3}
+
+		# Capturing lcov counters and generating report
+		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${coverage_info}
+		COMMAND ${LCOV_PATH} --remove ${coverage_info} 'tests/*' '/usr/*' ${LCOV_REMOVE_EXTRA} --output-file ${coverage_cleaned}
+		COMMAND ${GENHTML_PATH} -o ${_outputname} ${coverage_cleaned}
+		COMMAND ${CMAKE_COMMAND} -E remove ${coverage_info} ${coverage_cleaned}
+
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests
+# Param _outputname     cobertura output is generated as _outputname.xml
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE_COBERTURA _targetname _testrunner _outputname)
+
+	IF(NOT PYTHON_EXECUTABLE)
+		MESSAGE(FATAL_ERROR "Python not found! Aborting...")
+	ENDIF() # NOT PYTHON_EXECUTABLE
+
+	IF(NOT GCOVR_PATH)
+		MESSAGE(FATAL_ERROR "gcovr not found! Aborting...")
+	ENDIF() # NOT GCOVR_PATH
+
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Run tests
+		${_testrunner} ${ARGV3}
+
+		# Running gcovr
+		COMMAND ${GCOVR_PATH} -x -r ${CMAKE_SOURCE_DIR} -e '${CMAKE_SOURCE_DIR}/tests/'  -o ${_outputname}.xml
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Running gcovr to produce Cobertura code coverage report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Cobertura code coverage report saved in ${_outputname}.xml."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE_COBERTURA
diff --git a/week3/AcceleratedC++4-5/include/AcceleratedC++4-5.hpp b/week3/AcceleratedC++4-5/include/AcceleratedC++4-5.hpp
new file mode 100644
index 00000000..e6a29155
--- /dev/null
+++ b/week3/AcceleratedC++4-5/include/AcceleratedC++4-5.hpp
@@ -0,0 +1,40 @@
+/**
+ *  @copyright (c) 2021 Sumedh Reddy Koppula
+ *  @file    AcceleratedC++4-5.hpp
+ *  @author  SumedhReddy 
+ *
+ *  @brief Header
+ *
+ */
+
+#pragma once
+
+#include <iostream>
+
+#include <string>
+
+#include <sstream>
+
+#include <algorithm>
+
+#include <iterator>
+
+#include <vector>
+
+/**
+ * @brief Reader class has Read and uniquewordscount methods, to read
+ * input string, count words and unique words stored
+ * in a vector of string type.
+ */
+class Reader {
+ public:
+    std::vector < std::string > readString;
+    std::vector < std::string > words;
+    Reader();
+    int read(std::string s);
+    int uniquewordscount(const std::vector < std::string > & words);
+};
+
+Reader::~Reader(void){
+
+}
\ No newline at end of file
diff --git a/week3/AcceleratedC++4-5/include/lib.hpp b/week3/AcceleratedC++4-5/include/lib.hpp
new file mode 100644
index 00000000..45fd193f
--- /dev/null
+++ b/week3/AcceleratedC++4-5/include/lib.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include<iostream>
+
+void dummy()
+{
+    std::cout << "HI" << std::endl;
+}
diff --git a/week3/AcceleratedC++4-5/test/CMakeLists.txt b/week3/AcceleratedC++4-5/test/CMakeLists.txt
new file mode 100644
index 00000000..2b1cd4cb
--- /dev/null
+++ b/week3/AcceleratedC++4-5/test/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(GTEST_SHUFFLE 1)
+
+add_executable(
+    cpp-test
+    main.cpp
+    test.cpp
+)
+
+target_include_directories(cpp-test PUBLIC ../vendor/googletest/googletest/include 
+                                           ${CMAKE_SOURCE_DIR}/include)
+target_link_libraries(cpp-test PUBLIC gtest)
diff --git a/week3/AcceleratedC++4-5/test/main.cpp b/week3/AcceleratedC++4-5/test/main.cpp
new file mode 100644
index 00000000..697a9d70
--- /dev/null
+++ b/week3/AcceleratedC++4-5/test/main.cpp
@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/week3/AcceleratedC++4-5/test/test.cpp b/week3/AcceleratedC++4-5/test/test.cpp
new file mode 100644
index 00000000..2c5cd069
--- /dev/null
+++ b/week3/AcceleratedC++4-5/test/test.cpp
@@ -0,0 +1,5 @@
+#include <gtest/gtest.h>
+
+TEST(dummy, should_pass) {
+  EXPECT_EQ(1, 1);
+}
diff --git a/week3/AcceleratedC++4-7/CMakeLists.txt b/week3/AcceleratedC++4-7/CMakeLists.txt
new file mode 100644
index 00000000..ccddcaf2
--- /dev/null
+++ b/week3/AcceleratedC++4-7/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.2.1)
+project (scratch)
+
+# Add project cmake modules to path.
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake)
+
+# We probably don't want this to run on every build.
+option(COVERAGE "Generate Coverage Data" OFF)
+
+if (COVERAGE)
+    include(CodeCoverage)
+    set(LCOV_REMOVE_EXTRA "'vendor/*'")
+    setup_target_for_coverage(code_coverage test/cpp-test coverage)
+    set(COVERAGE_SRCS app/main.cpp include/lib.hpp)
+
+    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+    SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+    SET(CMAKE_EXE_LINKER_FLAGS "-fprofile-arcs -ftest-coverage")
+else()
+    set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wpedantic -g")
+endif()
+
+include(CMakeToolsHelpers OPTIONAL)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_CXX_STANDARD 14)
+
+add_subdirectory(app)
+add_subdirectory(test)
+add_subdirectory(vendor/googletest/googletest)
diff --git a/week3/AcceleratedC++4-7/UML/4_7_UML.jpeg b/week3/AcceleratedC++4-7/UML/4_7_UML.jpeg
new file mode 100644
index 0000000000000000000000000000000000000000..70637cdecf61061ed6be9763d3fe4b3590bcf45e
GIT binary patch
literal 987504
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%0Aj2(DkLMM!9$
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%0DF%;JhSnLXI&K82dd6!$=mPR
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%0Ai!mCA2kNA~%+?;ZOlJ4r&yf}`*m$!&
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%0AFaG1tta_)0uVqT@~gyg3bZ
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

literal 0
HcmV?d00001

diff --git a/week3/AcceleratedC++4-7/app/AcceleratedC++4-7.cpp b/week3/AcceleratedC++4-7/app/AcceleratedC++4-7.cpp
new file mode 100644
index 00000000..f02735bb
--- /dev/null
+++ b/week3/AcceleratedC++4-7/app/AcceleratedC++4-7.cpp
@@ -0,0 +1,41 @@
+/**
+ *  @copyright (c) 2021 SumedhReddy
+ *  @file    AcceleratedC++4-7.cpp
+ *  @author  SumedhReddy
+ *
+ *  @brief solution
+ *
+ */
+
+#include "AcceleratedC++4-7.hpp"
+
+/**
+ * @brief calculateAverage method is used to calculate average 
+ * of vectors elements stored
+ */
+
+void vectorAverage::calculateAverage(){
+  double input, sum, avg;
+  int len;   // user input for length of the vector
+  std::vector < double > average;
+  std::cout << "Enter length of the vector:" << std::endl;
+  std::cin >> len;
+  std::cout << "Enter the numbers to store inside vector:" << std::endl;
+  for (int i = 0; i < len; i++) {
+    std::cin >> input;
+    average.push_back(input);
+  }
+  // looping to calculate the sum of elements present inside the vector
+  for (int j = 0; j < average.size(); j++) {
+    sum += average[j];
+  }
+  // calculating average of vector elements
+  avg = sum / average.size();
+  std::cout << "Average of vector elements: " << avg << std::endl;
+}
+
+int main() {
+  vectorAverage obj;
+  obj.calculateAverage();
+  return 0;
+}
\ No newline at end of file
diff --git a/week3/AcceleratedC++4-7/app/CMakeLists.txt b/week3/AcceleratedC++4-7/app/CMakeLists.txt
new file mode 100644
index 00000000..b2046d61
--- /dev/null
+++ b/week3/AcceleratedC++4-7/app/CMakeLists.txt
@@ -0,0 +1,5 @@
+
+add_executable(shell-app AcceleratedC++4-7.cpp)
+include_directories(
+    ${CMAKE_SOURCE_DIR}/include
+)
diff --git a/week3/AcceleratedC++4-7/app/main.cpp b/week3/AcceleratedC++4-7/app/main.cpp
new file mode 100644
index 00000000..74232ade
--- /dev/null
+++ b/week3/AcceleratedC++4-7/app/main.cpp
@@ -0,0 +1,8 @@
+#include <iostream>
+#include <lib.hpp>
+
+int main()
+{
+    dummy();
+    return 0;
+}
diff --git a/week3/AcceleratedC++4-7/cmake/CodeCoverage.cmake b/week3/AcceleratedC++4-7/cmake/CodeCoverage.cmake
new file mode 100644
index 00000000..50dffc7d
--- /dev/null
+++ b/week3/AcceleratedC++4-7/cmake/CodeCoverage.cmake
@@ -0,0 +1,203 @@
+# Copyright (c) 2012 - 2015, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. 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.
+#
+# 3. Neither the name of the copyright holder 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 HOLDER 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.
+#
+#
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# USAGE:
+
+# 0. (Mac only) If you use Xcode 5.1 make sure to patch geninfo as described here:
+#      http://stackoverflow.com/a/22404544/80480
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt:
+#      INCLUDE(CodeCoverage)
+#
+# 3. Set compiler flags to turn off optimization and enable coverage:
+#    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#	 SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#
+# 3. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target
+#    which runs your test executable and produces a lcov code coverage report:
+#    Example:
+#	 SETUP_TARGET_FOR_COVERAGE(
+#				my_coverage_target  # Name for custom target.
+#				test_driver         # Name of the test driver executable that runs the tests.
+#									# NOTE! This should always have a ZERO as exit code
+#									# otherwise the coverage generation will not complete.
+#				coverage            # Name of output directory.
+#				)
+#
+#    If you need to exclude additional directories from the report, specify them
+#    using the LCOV_REMOVE_EXTRA variable before calling SETUP_TARGET_FOR_COVERAGE.
+#    For example:
+#
+#    set(LCOV_REMOVE_EXTRA "'thirdparty/*'")
+#
+# 4. Build a Debug build:
+#	 cmake -DCMAKE_BUILD_TYPE=Debug ..
+#	 make
+#	 make my_coverage_target
+#
+#
+
+# Check prereqs
+FIND_PROGRAM( GCOV_PATH gcov )
+FIND_PROGRAM( LCOV_PATH lcov )
+FIND_PROGRAM( GENHTML_PATH genhtml )
+FIND_PROGRAM( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/tests)
+
+IF(NOT GCOV_PATH)
+	MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
+ENDIF() # NOT GCOV_PATH
+
+IF("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+	IF("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
+		MESSAGE(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+	ENDIF()
+ELSEIF(NOT CMAKE_COMPILER_IS_GNUCXX)
+	MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+ENDIF() # CHECK VALID COMPILER
+
+SET(CMAKE_CXX_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+SET(CMAKE_C_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+SET(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+SET(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+MARK_AS_ADVANCED(
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+IF ( NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "Coverage"))
+  MESSAGE( WARNING "Code coverage results with an optimized (non-Debug) build may be misleading" )
+ENDIF() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
+
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests.
+#						MUST return ZERO always, even on errors.
+#						If not, no coverage report will be created!
+# Param _outputname     lcov output is generated as _outputname.info
+#                       HTML report is generated in _outputname/index.html
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
+
+	IF(NOT LCOV_PATH)
+		MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
+	ENDIF() # NOT LCOV_PATH
+
+	IF(NOT GENHTML_PATH)
+		MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
+	ENDIF() # NOT GENHTML_PATH
+
+	SET(coverage_info "${CMAKE_BINARY_DIR}/${_outputname}.info")
+	SET(coverage_cleaned "${coverage_info}.cleaned")
+
+	SEPARATE_ARGUMENTS(test_command UNIX_COMMAND "${_testrunner}")
+
+	# Setup target
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Cleanup lcov
+		${LCOV_PATH} --directory . --zerocounters
+
+		# Run tests
+		COMMAND ${test_command} ${ARGV3}
+
+		# Capturing lcov counters and generating report
+		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${coverage_info}
+		COMMAND ${LCOV_PATH} --remove ${coverage_info} 'tests/*' '/usr/*' ${LCOV_REMOVE_EXTRA} --output-file ${coverage_cleaned}
+		COMMAND ${GENHTML_PATH} -o ${_outputname} ${coverage_cleaned}
+		COMMAND ${CMAKE_COMMAND} -E remove ${coverage_info} ${coverage_cleaned}
+
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests
+# Param _outputname     cobertura output is generated as _outputname.xml
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE_COBERTURA _targetname _testrunner _outputname)
+
+	IF(NOT PYTHON_EXECUTABLE)
+		MESSAGE(FATAL_ERROR "Python not found! Aborting...")
+	ENDIF() # NOT PYTHON_EXECUTABLE
+
+	IF(NOT GCOVR_PATH)
+		MESSAGE(FATAL_ERROR "gcovr not found! Aborting...")
+	ENDIF() # NOT GCOVR_PATH
+
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Run tests
+		${_testrunner} ${ARGV3}
+
+		# Running gcovr
+		COMMAND ${GCOVR_PATH} -x -r ${CMAKE_SOURCE_DIR} -e '${CMAKE_SOURCE_DIR}/tests/'  -o ${_outputname}.xml
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Running gcovr to produce Cobertura code coverage report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Cobertura code coverage report saved in ${_outputname}.xml."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE_COBERTURA
diff --git a/week3/AcceleratedC++4-7/include/AcceleratedC++4-7.hpp b/week3/AcceleratedC++4-7/include/AcceleratedC++4-7.hpp
new file mode 100644
index 00000000..b46a37b6
--- /dev/null
+++ b/week3/AcceleratedC++4-7/include/AcceleratedC++4-7.hpp
@@ -0,0 +1,28 @@
+/**
+ *  @copyright (c) 2021 Sumedh Reddy Koppula
+ *  @file    AcceleratedC++4-7.hpp
+ *  @author  SumedhReddy 
+ *
+ *  @brief Header
+ *
+ */
+
+#pragma once
+
+#include <iostream>
+
+#include <vector>
+
+/**
+ * @brief vectorAverage class has only methods, to calculate average
+ * of data elements stored in a vector of double type.
+ */
+class vectorAverage{
+ public:
+ ~vectorAverage();
+ void calculateAverage();
+};
+
+vectorAverage::~vectorAverage(void){
+
+}
\ No newline at end of file
diff --git a/week3/AcceleratedC++4-7/include/lib.hpp b/week3/AcceleratedC++4-7/include/lib.hpp
new file mode 100644
index 00000000..45fd193f
--- /dev/null
+++ b/week3/AcceleratedC++4-7/include/lib.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include<iostream>
+
+void dummy()
+{
+    std::cout << "HI" << std::endl;
+}
diff --git a/week3/AcceleratedC++4-7/test/CMakeLists.txt b/week3/AcceleratedC++4-7/test/CMakeLists.txt
new file mode 100644
index 00000000..2b1cd4cb
--- /dev/null
+++ b/week3/AcceleratedC++4-7/test/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(GTEST_SHUFFLE 1)
+
+add_executable(
+    cpp-test
+    main.cpp
+    test.cpp
+)
+
+target_include_directories(cpp-test PUBLIC ../vendor/googletest/googletest/include 
+                                           ${CMAKE_SOURCE_DIR}/include)
+target_link_libraries(cpp-test PUBLIC gtest)
diff --git a/week3/AcceleratedC++4-7/test/main.cpp b/week3/AcceleratedC++4-7/test/main.cpp
new file mode 100644
index 00000000..697a9d70
--- /dev/null
+++ b/week3/AcceleratedC++4-7/test/main.cpp
@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/week3/AcceleratedC++4-7/test/test.cpp b/week3/AcceleratedC++4-7/test/test.cpp
new file mode 100644
index 00000000..2c5cd069
--- /dev/null
+++ b/week3/AcceleratedC++4-7/test/test.cpp
@@ -0,0 +1,5 @@
+#include <gtest/gtest.h>
+
+TEST(dummy, should_pass) {
+  EXPECT_EQ(1, 1);
+}
diff --git a/week3/AcceleratedC++6-9/CMakeLists.txt b/week3/AcceleratedC++6-9/CMakeLists.txt
new file mode 100644
index 00000000..ccddcaf2
--- /dev/null
+++ b/week3/AcceleratedC++6-9/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.2.1)
+project (scratch)
+
+# Add project cmake modules to path.
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake)
+
+# We probably don't want this to run on every build.
+option(COVERAGE "Generate Coverage Data" OFF)
+
+if (COVERAGE)
+    include(CodeCoverage)
+    set(LCOV_REMOVE_EXTRA "'vendor/*'")
+    setup_target_for_coverage(code_coverage test/cpp-test coverage)
+    set(COVERAGE_SRCS app/main.cpp include/lib.hpp)
+
+    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+    SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+    SET(CMAKE_EXE_LINKER_FLAGS "-fprofile-arcs -ftest-coverage")
+else()
+    set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wpedantic -g")
+endif()
+
+include(CMakeToolsHelpers OPTIONAL)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_CXX_STANDARD 14)
+
+add_subdirectory(app)
+add_subdirectory(test)
+add_subdirectory(vendor/googletest/googletest)
diff --git a/week3/AcceleratedC++6-9/UML/6_9_UML.jpeg b/week3/AcceleratedC++6-9/UML/6_9_UML.jpeg
new file mode 100644
index 0000000000000000000000000000000000000000..88622d36ab836d96f00d780182af940150994bbc
GIT binary patch
literal 601486
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%0ABlX<P|DvtchCt_N
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%0DEY3l
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%0A@-$^8}|_BG{}L}UUh*@y<P@w$#)z;K~9mqOs+
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

literal 0
HcmV?d00001

diff --git a/week3/AcceleratedC++6-9/app/AcceleratedC++6-9.cpp b/week3/AcceleratedC++6-9/app/AcceleratedC++6-9.cpp
new file mode 100644
index 00000000..bb78d65a
--- /dev/null
+++ b/week3/AcceleratedC++6-9/app/AcceleratedC++6-9.cpp
@@ -0,0 +1,36 @@
+/**
+ *  @copyright (c) 2021 SumedhReddy
+ *  @file    AcceleratedC++6-9.cpp
+ *  @author  SumedhReddy
+ *  @brief solution
+ *
+ */
+
+#include "AcceleratedC++6-9.hpp"
+
+/**
+ * @brief Method to concatenate vector data into single string
+ */
+
+  std::string concatenator::concat_v(const std::vector < std::string > & stringVector) {
+  std::string s;   // accumates all elements of vector into single stream
+  s = accumulate(stringVector.begin(), stringVector.end(), std::string());
+  return s;
+}
+
+int main() {
+  concatenator obj;
+  std::string input, con;
+  std::vector < std::string > stringData;
+  std::cout << "Enter 10 random string data into vector:" << std::endl;
+  // loop to add 10 random strings into vector
+  for (int i = 0; i < 10; i++) {
+    std::cin >> input;
+    stringData.push_back(input);
+  }
+
+  con = obj.concat_v(stringData);
+  std::cout << "Concatenation:" << con << std::endl;
+
+  return 0;
+}
\ No newline at end of file
diff --git a/week3/AcceleratedC++6-9/app/CMakeLists.txt b/week3/AcceleratedC++6-9/app/CMakeLists.txt
new file mode 100644
index 00000000..c206f7f1
--- /dev/null
+++ b/week3/AcceleratedC++6-9/app/CMakeLists.txt
@@ -0,0 +1,5 @@
+
+add_executable(shell-app AcceleratedC++6-9.cpp)
+include_directories(
+    ${CMAKE_SOURCE_DIR}/include
+)
diff --git a/week3/AcceleratedC++6-9/app/main.cpp b/week3/AcceleratedC++6-9/app/main.cpp
new file mode 100644
index 00000000..74232ade
--- /dev/null
+++ b/week3/AcceleratedC++6-9/app/main.cpp
@@ -0,0 +1,8 @@
+#include <iostream>
+#include <lib.hpp>
+
+int main()
+{
+    dummy();
+    return 0;
+}
diff --git a/week3/AcceleratedC++6-9/cmake/CodeCoverage.cmake b/week3/AcceleratedC++6-9/cmake/CodeCoverage.cmake
new file mode 100644
index 00000000..50dffc7d
--- /dev/null
+++ b/week3/AcceleratedC++6-9/cmake/CodeCoverage.cmake
@@ -0,0 +1,203 @@
+# Copyright (c) 2012 - 2015, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. 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.
+#
+# 3. Neither the name of the copyright holder 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 HOLDER 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.
+#
+#
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# USAGE:
+
+# 0. (Mac only) If you use Xcode 5.1 make sure to patch geninfo as described here:
+#      http://stackoverflow.com/a/22404544/80480
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt:
+#      INCLUDE(CodeCoverage)
+#
+# 3. Set compiler flags to turn off optimization and enable coverage:
+#    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#	 SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#
+# 3. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target
+#    which runs your test executable and produces a lcov code coverage report:
+#    Example:
+#	 SETUP_TARGET_FOR_COVERAGE(
+#				my_coverage_target  # Name for custom target.
+#				test_driver         # Name of the test driver executable that runs the tests.
+#									# NOTE! This should always have a ZERO as exit code
+#									# otherwise the coverage generation will not complete.
+#				coverage            # Name of output directory.
+#				)
+#
+#    If you need to exclude additional directories from the report, specify them
+#    using the LCOV_REMOVE_EXTRA variable before calling SETUP_TARGET_FOR_COVERAGE.
+#    For example:
+#
+#    set(LCOV_REMOVE_EXTRA "'thirdparty/*'")
+#
+# 4. Build a Debug build:
+#	 cmake -DCMAKE_BUILD_TYPE=Debug ..
+#	 make
+#	 make my_coverage_target
+#
+#
+
+# Check prereqs
+FIND_PROGRAM( GCOV_PATH gcov )
+FIND_PROGRAM( LCOV_PATH lcov )
+FIND_PROGRAM( GENHTML_PATH genhtml )
+FIND_PROGRAM( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/tests)
+
+IF(NOT GCOV_PATH)
+	MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
+ENDIF() # NOT GCOV_PATH
+
+IF("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+	IF("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
+		MESSAGE(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+	ENDIF()
+ELSEIF(NOT CMAKE_COMPILER_IS_GNUCXX)
+	MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+ENDIF() # CHECK VALID COMPILER
+
+SET(CMAKE_CXX_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+SET(CMAKE_C_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+SET(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+SET(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+MARK_AS_ADVANCED(
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+IF ( NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "Coverage"))
+  MESSAGE( WARNING "Code coverage results with an optimized (non-Debug) build may be misleading" )
+ENDIF() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
+
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests.
+#						MUST return ZERO always, even on errors.
+#						If not, no coverage report will be created!
+# Param _outputname     lcov output is generated as _outputname.info
+#                       HTML report is generated in _outputname/index.html
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
+
+	IF(NOT LCOV_PATH)
+		MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
+	ENDIF() # NOT LCOV_PATH
+
+	IF(NOT GENHTML_PATH)
+		MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
+	ENDIF() # NOT GENHTML_PATH
+
+	SET(coverage_info "${CMAKE_BINARY_DIR}/${_outputname}.info")
+	SET(coverage_cleaned "${coverage_info}.cleaned")
+
+	SEPARATE_ARGUMENTS(test_command UNIX_COMMAND "${_testrunner}")
+
+	# Setup target
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Cleanup lcov
+		${LCOV_PATH} --directory . --zerocounters
+
+		# Run tests
+		COMMAND ${test_command} ${ARGV3}
+
+		# Capturing lcov counters and generating report
+		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${coverage_info}
+		COMMAND ${LCOV_PATH} --remove ${coverage_info} 'tests/*' '/usr/*' ${LCOV_REMOVE_EXTRA} --output-file ${coverage_cleaned}
+		COMMAND ${GENHTML_PATH} -o ${_outputname} ${coverage_cleaned}
+		COMMAND ${CMAKE_COMMAND} -E remove ${coverage_info} ${coverage_cleaned}
+
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests
+# Param _outputname     cobertura output is generated as _outputname.xml
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE_COBERTURA _targetname _testrunner _outputname)
+
+	IF(NOT PYTHON_EXECUTABLE)
+		MESSAGE(FATAL_ERROR "Python not found! Aborting...")
+	ENDIF() # NOT PYTHON_EXECUTABLE
+
+	IF(NOT GCOVR_PATH)
+		MESSAGE(FATAL_ERROR "gcovr not found! Aborting...")
+	ENDIF() # NOT GCOVR_PATH
+
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Run tests
+		${_testrunner} ${ARGV3}
+
+		# Running gcovr
+		COMMAND ${GCOVR_PATH} -x -r ${CMAKE_SOURCE_DIR} -e '${CMAKE_SOURCE_DIR}/tests/'  -o ${_outputname}.xml
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Running gcovr to produce Cobertura code coverage report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Cobertura code coverage report saved in ${_outputname}.xml."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE_COBERTURA
diff --git a/week3/AcceleratedC++6-9/include/AcceleratedC++6-9.hpp b/week3/AcceleratedC++6-9/include/AcceleratedC++6-9.hpp
new file mode 100644
index 00000000..98e40d87
--- /dev/null
+++ b/week3/AcceleratedC++6-9/include/AcceleratedC++6-9.hpp
@@ -0,0 +1,35 @@
+/**
+ *  @copyright (c) 2021 Sumedh Reddy Koppula
+ *  @file    AcceleratedC++6-9.hpp
+ *  @author  SumedhReddy 
+ *
+ *  @brief Header
+ *
+ */
+
+#pragma once
+
+#include <iostream>
+
+#include <vector>
+
+#include <algorithm>
+
+#include <string>
+
+#include <numeric>
+
+/**
+ * @brief concatenator class has only methods, to concatenate
+ * data elements stored in a vector of string type.
+ */
+class concatenator {
+  public:
+  std::string concat_v(const std::vector < std::string > & stringVector);
+  concatenator();
+  
+};
+
+concatenator::concatenator(void) {
+
+}
\ No newline at end of file
diff --git a/week3/AcceleratedC++6-9/include/lib.hpp b/week3/AcceleratedC++6-9/include/lib.hpp
new file mode 100644
index 00000000..45fd193f
--- /dev/null
+++ b/week3/AcceleratedC++6-9/include/lib.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include<iostream>
+
+void dummy()
+{
+    std::cout << "HI" << std::endl;
+}
diff --git a/week3/AcceleratedC++6-9/test/CMakeLists.txt b/week3/AcceleratedC++6-9/test/CMakeLists.txt
new file mode 100644
index 00000000..2b1cd4cb
--- /dev/null
+++ b/week3/AcceleratedC++6-9/test/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(GTEST_SHUFFLE 1)
+
+add_executable(
+    cpp-test
+    main.cpp
+    test.cpp
+)
+
+target_include_directories(cpp-test PUBLIC ../vendor/googletest/googletest/include 
+                                           ${CMAKE_SOURCE_DIR}/include)
+target_link_libraries(cpp-test PUBLIC gtest)
diff --git a/week3/AcceleratedC++6-9/test/main.cpp b/week3/AcceleratedC++6-9/test/main.cpp
new file mode 100644
index 00000000..697a9d70
--- /dev/null
+++ b/week3/AcceleratedC++6-9/test/main.cpp
@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/week3/AcceleratedC++6-9/test/test.cpp b/week3/AcceleratedC++6-9/test/test.cpp
new file mode 100644
index 00000000..2c5cd069
--- /dev/null
+++ b/week3/AcceleratedC++6-9/test/test.cpp
@@ -0,0 +1,5 @@
+#include <gtest/gtest.h>
+
+TEST(dummy, should_pass) {
+  EXPECT_EQ(1, 1);
+}
diff --git a/week3/Ouput screenshots/3_10_output.png b/week3/Ouput screenshots/3_10_output.png
new file mode 100644
index 0000000000000000000000000000000000000000..c54ab9ef841d930f9fdcb5c2eed347d395291f01
GIT binary patch
literal 1001177
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%0AlI7{?3<Of2mYKbW~^9mF^-T4W-y3=D?c
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%0D_)o)ELH;Ds
zTD{`#DNL2_OnM-%?em$ya=8`5yf8MENYAA_eRAMOaZba?*YqXM2K~ZYmQnx<)i?nX
z(8`|GsQvkOoiB}s>YW-O$)Cnz(U65_zwi@uQ#=DoOrOX^wbTg>El<q|*FwdrnVQ9C
zW}$I@kG@L$?03*bAFCfbAnDy)*k?|;qL&iZwz7LU*;U4Q#R(7$y3*vSH&TI()OgfI
zdIT;s5OFqw{f|PB08{`*(6Rk9<C8mtm}Sdj=@wFb`549J<j<_uBacPZ<|sIi?=OF>
zRjT>DrC2)Dtn|!^f2^}Jd0theCmj)tMl?oEBZIaT(G#{>8}qTx90&~{TQFP4_NZ}(
zXFcYrYd63cD!^H8g8D0;vY<Y+kt@Gmt`d~qbHOCY4ENMa&o#)y%?h+sc&KFC9m0cu
zX<f}yM6Nlfs|sKVPrMM^_!xk&^b9=Uf5KO5=lq_DjB4CUP&6>R=Vu_6#k3m6bJu~3
zbzU>G=4fTwjD8wQX5Ma>kHOF4<?zlCkESo5<w4PujogGkbClV(a$@ZcB&JG&xaM^i
zV42f3U~PwIc7v`JQZ{^#pa=_W+L;apk>-8}0gG*V%|7&BetsHrA_VDe*J%AN*o-Fe
zLYJLm63gwMDMkG`;HkgfUx%lhg&id<TKG|~e>b4B1Eb`WP^(vqhEoqt<5|WGIPU+j
zh^}fH74n?6IP}aRDY8Twx=*OYb=Li!c|`(d+{QkA&bSIai4dFnwP{S%fVprpBgJpZ
z2pQT4k9SlN7ryq^hiPzpI0_lQ7bu6PKq3_OTS%uKi)xKa?XqOeSg4;B`~g(>sG)P6
zNUfo}XjbtYl7@>=!LzLd{M$rU)@^|4+}|@G<iS+W?u5x2jLPhNLfwXI&wjh(%?;6{
z4R*zqQpi56gTM1Zzt>W)4*QVtj(Vr$LXR>i!k-b+4a>hS#2*UAoAe?S1<!o4hzbmA
z<BVGWshc<Y09*8St4ms+$s}KVg4$9<AEjBCSU6w4vy<BDrX#U<Bc5f}Ix9M?4?Gk-
zuP*2Rt;fNtWt@9~igCz&gTsZ6dn&KYT%*PiY4Ph`H3Nwd&=dDc=SiOP#mWoK6F*r}
zj%6#V3^v35GSeHirPclD<jc*jXN&egEB-iG>(WrP`j@qWtOu-QUf&QC<tJ+zlLdpn
ze;<4Iw%t)h?><J6@32`*({&eyX=L(=+2q}%K5rAPtI&|Vvv?&}1V`}oh_*^5emh<o
z{325TMX?~J?138S*|*(cFFhDxFSSjZ&oBuV<+-zog(JKPl*biKU&%7sHBl!*=I)A<
zg~GHw;`V>nd7LCmxa?VzMtcjX>cTHElxz-QoPHOay4YSqt;2*EN(2hykHNYX(fXHb
zXXEfFdp@<Jr#9H1Q`$!cDX8-E2&N61c=Mh#E%BunyN-FSym4RB%(&a9KKg>P)n!yG
z^R;r$kwda%fc6#2A6uP#JE>3FrKhXw5BA$PW=ETw*4|5<Z5Ia%c1^F+i7Nbg_tUp`
z?4iE+>gjVoBC}N}_GG&YOL-v+MotXw_iNM-9@WB)N&5nAS6HprJFKGq_s#p*4%pK~
z!;z^f>-HPel$2e2du&t^e)B}2bj8_D*dy^6Yq8mLJPtT@c9nACU5T<~N*{yFzr2E=
z$-nbN#pbVSN&4AujeQf!5L&GuQz`ahyU^=98fWO3LEhVS2_>xn!9c`kK?XEY0>aHt
zB3r_t%Hi9BFPp*<o;X2ov4ak@2B(ehIU>9=S4W3X_@|WiZ&?Tu9kq%ZKC8a+j&~%n
zpc<5jrRDFRL89Q|Bz7O2E!R};vm!hxVxshZH?#O=)QNQ}uCBFOE^vcj2ik#7zkObH
zfieWKvUkaL6EnyI+WN0U<DJSg-YeFU-7p!C>%BH95ELD>q6_cly5N!zEXGMPfBFHF
zlN_`Ym*2xJx>^A37RTnlJT`Yj+ZYqVE(7RXB{ZxG1E!?1KDayw(AqM7a?b^%->q0*
z>yq5Kq>I#gOg0c>hURgi5O3;d?Ypa9EZp)>E|u3A%|u^x*YDXTD1EGW1$+C9+{c<o
z0Fx>4N^?Cb)x(EI7##}=i8U#Oe7KUf@<y<0YvGl}y)b2YSC<y<#sL!w{A^Fyz`!UY
zTgW9Wg+|3m-RXn;ChE(8l`!6hkd&z%u2QLwivX#-r9BmICdo$`&lva?)xvso^Qi40
zwks*7e;lXJ4oJ(I(z{-V^~0XSz8Tm9so*DfNEn<;pk<g-U$|}jbD;@R>|^yeD?NAd
z;Ij7DH&C8)SGUFk!+5PwX#@jfc;a+?S@R_oMr&PK+$W&@v%HIR&^WbB6u#OqVdK_K
z{d<;VYm(?%+=_9b4Erd;#={e<goam;rka~lwv!cEB47}v7Z>^V=^_3JDCph6czG7*
z(_o*^0^;GLIb6A2R_l{lYa4TJ&ALOh{uK!cNjZUD+ekC9$-2=`kCM0P86A{Y%)Cet
zCAbHknu;-&z0s<QprML!r+(t)y(V3h`yGzvInZgP6=HUvz|cuwwYAvcO<AkJx>twa
zeSPp`16Yw*P7+o2ADg%t3ImH{qPxamnT12rsupJtW7rpx2;d%l?}rAD`PECQntIsV
z4vHtnp5b6v=E}nHv#;)~({RD>cj1_FCFzw_quB#oUHzLOnwfb(1bUByAhK8|sQtqQ
z3mPfKo>djN-B(z7&O-}K5OYIOS*(3gf4zWQ`&=W@K<b4obAY2uGh<!s;I#;w*bPzT
zQbo1V*E%60-{0J&!~3-elep+nB#ZqG@R4H@p5bOESe2hM^~~j=JDEL}Oi2CIkYz+U
z_ZQ*^n^6{c^7~tcfdM-Y8Q#EsWxUt&aC04j`4se?XDk#`iw1sS1x&F*g6;{TSHr~#
zYSFotJS<7u^G0<^1fEMaxf-lipL3vt{AhkbN%UzM^HeMAF4P_AmkrL}LtA3&bp7fg
z;IOTV=03y;52ZJ@lG7T{yHtsBXBC0)<7wM1qBi&Wnxil24kq_b$IDM+7M27W_Rdn;
zIIH*N^%8dR7)0x?{3zyZHR(JS?%B~5A9k8z__J-JMnwjM*@mTTqRew%zllx3Fx$Vj
zLT#yoEILT>tU&Js;Q-!SP}~s1vs#2Cu#(>)Ju=M!%B7t(4sv#1NcEpB;^sjB84^}@
zK!$G))ae~o4qTx()lx0_4ux>&kM!ahif{YlJN)wFrf^h;m5dW;WVV70mzi1l?ZCi*
z0~~-aVUX5B!IoKjg3+vl3`#-SLXb8}0Bsv>Hb_5;>`o67RcYim?Wg875%{^b^VPM6
z-NoYVeIUk-jx+c9h{Q{=>?5xMS9O29L3mIu`lRA90K#k#cpJV7;}*g16h#AzQJgxs
zW{Wo6W7_%aht}0AgljftSzlBshhttRj`^;M6BSaM9{_N;)Gofrx5S{JE!DNog~k8s
z)k$Bh_3pa56b_!>kj55?j-FoE3=lC<XBs@Vu!<bmM;O+&TcI+~idc!>mQ_dBX{(a2
zl%ItDJj?h{>x(=g19~7yvlCepZ<UDf7=aPvbx%L*QOP#Q%^RRy^m!l_^}c_JM#@4^
zvw(>_m6}>`dvM@5N3<j?wtJ+4x_<$tGI<X7Q@*wT1u#Hq-#cPI7!t5kP??w>zF2JO
z-c%<`H^DMZG>5M*imXr7m#w=KMeC`4tdA?eoJ$o*Y;+eX9g_ka{yseV%9(dhcl-Ls
zNkU5MH3pUV(JJ0T_#j^K=;>HiF{Xcl+w{Uuzc^Kdp><B<L&o!OwMSVGqy^qbzM`pK
z5mlU-rl(2?yF8A0T~@+(M+&zYDW414v+gh{SMAOYo*4BLe!sna^Rx+X&_^t&<R=-G
zm`4u=Nt3Q<u{kT?<HmtIu!p{J+Mt1BLCx~$V_wX{uIs9AZL(R?9#L)91MkhaipTV!
zxDQvTH(k7-5^IQ%@WG|1@%eKf@V3KGr3?7#B!9B##sFu<n!ZCDZnKSMWDT^#C-aU7
zrnDDrXTn8&ez*qm@mub(I6quuFtM-l=iJjcy~l!N7`Oa7G;y%7jprm(gS;QNa`I-c
zcoA@n>8|tb64qw%aC;y=DbW<(5NY-z-Y@J1D#cb!8RrqN=VU;dJ)Hctq5P#gCQaE%
zJQrtHIDb5O@(F+aVp$d#TffJ*Kc08|GkQe8Key_Sa_^zh(<S@M@l8uBuX}tuq<|Qk
zDFIVY4s)JVm)C#DL#o%zKN3hTXu=p`5lo%GKbu_?EJTm%PPBEdLePfq?PMVi$fF#F
zT&4jJo7Re|-A)tz6m*-GfL7eTz2rIbl>?g>3nnZ##g6{r<pso-J%_Fy1HYf$iGK~Y
z$Wduj*HHo)4I@I|1+EPiB%thcj2YgJt_n&6DZTAHZ{ZI&L`zS}j$C8%2SMQDmWQ;1
z7(0S((U#+(hv2(p?q<w7+~bM9V2ig&JVu}O3Tb;Z`$A5-gnr(y?s2|w(QSP(a6$dB
z%bs~>L7;*C)7fS%CYCh8sX(z-#GrSqKuBjPe@is{&`)XfGK)6is5PyL$HmnrhBH&}
znc-T$zXPLPoXDmtfzzX%^OhOzjn;Fq;#RW?Ub~%AUWy@Ye=Q?a`*5A^P@Bqh-&_0g
z9Qamua(p&AsdAWKhZSmQ4;G5+Ay&B^MDRNN5vI{ThGn@{Dlh`}dr-gMp=>Sg*7}c5
zlHc=>H8Hgf7z=#<fsyGA$x<oH7_y#o>|^k$<zg^5&R-m>b^ro_jHn|mSE(Gss6D&8
zyAF<pvAhUq!I_MM>J-53ri1!E;4u~Ou}+c}qsStWfP~j+F?$SuY*y1$;SJQQx<`~0
zMv<>_WbdK^2RL-tBKa44`NmweJ{q)y+*N%)!W%oe=6pKW&m6b|O;0VEzKA*nRO_+l
ze(_Y$a6w=4pOfaulz~)`pb?Dz)(36mYbpAct`V%}Ojk%MO!d!m70#;C_@Rn{#49$P
zB?Fg{yP`ZfoOJV+8|CYw?rMm2&jpSg%K8I$T$Bqs6rV9Ol%;ER`WcX<=0)2K8Omac
zOs|fGj5ecf?6dD_BIzvu2<#DP^cu0EZM(wUt@OP-P?ID0LV(=n71^Z&N-rGw;&s>|
z<=4HD4cZ6-*%i#O6k#1}s{0uM2r;qJ*L8D%N(|6=2&!B*=po`6lk@r;peB1tz1Q{|
zWB;BFoaEZitkc=mwR5zl5dAj%YK-jt9_x-2^x4*tGK)IkWCNUO@6FF@x9@dykM+u@
zqhGg*PJ0Fq2_XAiz!|<7s9<J4#GDa>PG^QK!eOLK>={3dMh<4a>ihJ$F1Sw?A8m9W
z7}#I!US_IF)OK2Xvcw{!8k@%DreVY;Zmszx#|3)ab-_a$0v^!M1zf3|uxW|+X~@l2
z9NpJR%gid-Twi}7Ed+M#QHn7f*AX){e_b+?-aLC|6uh-FZ?Wyj8RJfrwFYSm%~@vq
zfe;PyexU}=y=LarckJPgv}yuL{7imtXnx+9!N2{<5?_1PQFv~B@GTBI2d6&MNKT~c
zGH)Jpe*K<JCqtGq&s)evUJ4+q>YivfTEx&X(XszrJAQTZ<fcv4|92l8t2WKb<FdA*
z^G2^lAgW}AM3e6hQB}zSd^tFb8G4c7fv|R=Je(FdOuGEFn>YzxO%!5)`g2lFROuH&
z-5jZtT&ZqSZ3km;%=su~<|&GNAbu6yc0`+|cKGB5hO}QxUnJVu6DN^H%?U6AoP3>r
z)g%np+<2li64c?pa+CgNa3;H~MLY6w`W=wsdH$L!4KN{XPO>ESaI!v)U?CeEP|o^#
z>Pn}qK}8@+B;$K?L>KYy<$!DJ-QnEagMecXa%0AT1$&*J)Z0frMZotO?~v?>Ls}sN
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%0DD^(}3kzk1<IPhv|
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
E0A<G>%K!iX

literal 0
HcmV?d00001

diff --git a/week3/Ouput screenshots/3_5_output.png b/week3/Ouput screenshots/3_5_output.png
new file mode 100644
index 0000000000000000000000000000000000000000..b9584740ca6267d4406e047eb5235f18e6315450
GIT binary patch
literal 1240741
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%0Db(&F6PL{LW8|d+)$l7ay>*S
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
SqOQjbK;Y@>=d#Wzp$PzQW+8R}

literal 0
HcmV?d00001

diff --git a/week3/Ouput screenshots/4_5_output.png b/week3/Ouput screenshots/4_5_output.png
new file mode 100644
index 0000000000000000000000000000000000000000..f51988077af8b3a6a5fb674e95da2788003430a2
GIT binary patch
literal 1339124
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%0A@n#M
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%0DllbhTYKr9>g`pl485gzG-uZD1BQ
z?P(=<H<)x|sY6?j@FviV>8RETiyrGy)o><TBYW-MSZ~t3;gkvx)VF;<FO+D$X8f1|
z>yZg`VZvC)hbP4^;tIh^9vo#^d<S`GgD9)oD|tJoV6wU@DAyd-rJj#|A9rsL;t1mE
zEiGtf@bn(31JGD6{2Mx8DzR(ERg7_Wk$Ik5T5Hc{^kS`9Lra#OaYGj}P9h6K+Jw4o
z=IQOJPMyPSCw^&bQ=I)RYvvppHNi}+TsCatnuUxj{%Hf&$C>AFLQHlm7k=QKBK3ml
zY;HE)*dMlDMZbAqQQe~i*5E*KH56^<R_pT(Dp;gzAh>^5sR;R>^^Akjxk@36vcQ!J
z9EQr6v#3PZS^bG&id0lkQY(Cs>EmBLncSEaa?z5Ol3vwg(r}V_4Q(BeV&tb+o%0a-
zfh(CM1oL`iQtcYsr_DWkAK$PP$}E+}Zq*AR6(-E0Ne=$`9bV`G$LurnKjucjO31IB
z>HrC7kND9j`1*Bf$MCqg`^IW6=d&&_b9fePIxE%OfswDXd#RB@ieAKDaw2)8MOzrW
zBc#JRL+&P$04a03Dy>&MX-WMze3H5O+KzQdF%sPNR)e&jy^6hH%<T#BR@rlP{puzi
zL*Wj%KfiLFbt^lWSG>!6FG_}B@>R?NaOl+Z>)Qn)VWm!2A2Hca2%&=ozKL7ot$K(#
zz;8||ps`&}+U^~%b$N}SUp}iC7)A*8yRHU2QmSOlkwpwwAd{J!{=sfXK1g)=D_wl)
zYD9MQo=l6aeF>-LyWE`Z){7gxfhBhASBMuF`t{whhG;br2Bmm}uxtYKcdS|u)yzC6
z(mZ{6%h}^uDp6cmdz$=_t79PAEI|I&QSp!F59?&J@_vEB?POVR?-tQ0voZO39Q+_w
zAIPVmnU4eYatVzKkhui~hK!o%<K~nB!NG!+4LxtV=m)Xj;d)EO>pg9{!3)f=)$)bZ
z`3tlHSBe347dz5YRpL)P%AaJ4L>xc~=D((G`D+7iXwdrvJr<2=qGe*tde1-P4J!e(
zQ+gK}z^U!&_e+Xn<@yi&-3t6%vQH(a%u22RpjoR7zo2IuTzf+Z`JR)B0qzdbM*q$C
z1WaxwSOCuG%f*F$CT5WRI3@A)3YBWRq@Q3?&(O0VKJy@ZrtPQWo!1BE(xiV+L#CYd
zE!_j$PiEz!8iNy*NOnci3yiuV3y>DjK^RKzM4$A$clb+!bSfV?d8YWs)Ndb2{X?=9
z1Z=eA@}I}RGtO32x2FP3tz-;VHo1Rte9PnF7250+g#J=#Z~elU%u>Ydt}Y|qacbwn
z5#ty;K+*Y)av>`*hto#yQGpxYR+%32yE=ZtptA?ef%w2L5EXW0*7nxTwGHrP6~0Fn
z1c>-lZEUrJ!7@+Yom>G*PMtF|P>2_(!-5$9E{bq;`{faGC-5&CRT)N?EPXJaS25@i
z%3k<GO6%b*f7N2zHu~$j&fG7mc|NJC_l$=lp|Vxq`%Tl3rYX6s_|RQ+VKXZ7qreNH
zq=7h~x%Ti^t@@USCu?zB_R`;7T2Sl0D(2Q=#NZ9H_X~UcQo9ourB@UMPh<`5?%Y;0
z4hb;t4ra%iEg{-zr)RjZ-cDZ;Tm&SKAE=r9ES$Q25$X+Qx%M=uINy3*Xk6U<6vce9
znkGajwBVGK_}{45y@>KszVk0I2@c)S7Fp8L4^1OJ#gJ)vg$Q^buS?4&N~xE;EwIW$
zw3>jRO)hv})*(|Uf-Mn+Q}xu3?5#ert=qZQGg2gDSfsA^NcS943YPKYX?YIH7M(~x
za>D=4ZN!uE<qyq_<fd%z@?=&W#`fLwUdGx#m)b9f%x|$_MJHNC<?s$tFW-W7SN14*
zMaI_Gqut;ApiD%kN4T+DmA6?ZqY=xd#9fO2kIQhg5cNO1by6Ee!GgZjzQa|afq@iU
zDqub`m60dyhO+KiX)v`MdPXAGoeLue>zR`MjfkAu%S|s%0X0iP<A^DH#bWmWO`3}E
z?^&fU#!9Q&gVq88^=s%?b4d?|o9Fa%6XWumFB$<+WbX?clHksA?@!nm7*w)YIL};d
z9HM$G3C)Vy)lN;H;!UAJORm)Z7(|Q}HSm2CK)POI*^(<aDd|~JE11$I;2)+GsqMW2
z7@{<afv;a>ITu>&XNixSQ~AsLFU~r3OaQmX@neV@dsHi+NbVwWa@W2-nwz{0D<25(
zimFx$0rv;9;>%<5_<jWA{+PLmN5PkaR*$lvF&PVTq6l@P(hg~$Z{X)j<%fnWP5Ki}
zmVS2Ru{TrnWjPZPPusqUUn52T8h+s&UJQgaa2y7-jw7C@$GB$NGhAwbh(c-j>`8zC
zsCJ6ux8k-o?~7c<CQ5oSk6yICVwPGVy4z^jS^$!|EMzTGs}#rW!KBA@_PS0v&y&I;
zkER`@E86Jtuna2pqL3&3Qjsz8Ri&c+lJS0r25^DZJsQj)uj0G!z-@HFg9HocU$`RS
zvDK%6qk}8cJg47qrYFx5Ov$P8L@EuWN~T6~bS3YF?l{2q>w^TLmm*DpvDNHjQ6YaL
ztGdT0z2*#d($H1rI9pp`F|<-V;6Qupm6>;wDSt(Jp0=3CG9^>Ib+lU}B4xfCBY2A6
zuCu9Lkhg7UTsS7OW&hx5kC1X{oSe)rf)i#>?W@ZQ8Z@Qen10CY8qQ)KN{m`evouWv
zpBey-Fg+|k|FYz$NQ?S7R&b3m<C^Mz>;_6sj!L6ei3qJZkErLFV&1Q+0Yf#cnm(CQ
z9b-gt(c|T;(fq8@?@P1*Y~NK?uRLnoO9PhxzG^|uA7mo+pRc&@EO*6wa%{owhwC&v
zcSEr>3$|A;rz#gF9UDZ0OPhIFy~pje1unG`nCv>6U53B@D+fRqJp5zT)uWK-Y|J#h
zl?k5~;L}YmQHG?;uD}h05mF~vEs({tDaYYdqU*xM+yrqL$615iI6OUMO`taY@|w+X
zM2^{t@UmA1eq+_-_Yg@DN11ron2fDi{nQsuqbS_EfjY7A@xI?68E#br|34Q;qWgv$
z84Xfu{O0w}7{Wyf&b6b5R<MS#rnwDu0zE<lE1%7c_{w#^#Bns7oEQ%N2!3j@Y$T_p
z|5Q#L#C9!VOdi*!n6<O;(oVp&=@j+VeoB})fICrHekA8@vD}?CQ?#|t(bDJWAgqu3
zbwCd}LeWR8Csnf%>Y+qhX2KiRWNJvk%oXqyG38~T=SeH!plBI)b^n!@sVXR#*yXWf
z#Fyr_+97Mlr($%>g(Q>cIz~w)@U<xE`r#Yx3~vhg+L7={>h|PXHznM?;yd1K3x9F+
zrCB(#JyMVEO}DC0A_8&j#0lviA;TxuMK>Wm5O-L(qf_`cCjKZO-DDXgpo}t8E9{4w
z+`75&P(HhT6(@7th_`kY7o&s1s&X~wRFyTPPMTV$;hnE686ZR^gp+s&itf!-Nx1u0
z;PYi~qt`@02l<*|Zprx<lU*j-+sn!1F{5-QW1HuGL|_w(#sd03t;BP%crn}sS{hVh
zXprlIMa4^Y-uqW*n*krOsz0{}14QHGX}IUqtXoT*f){FYrz*y>+IcLO+i$A<tIy8>
z8Hv*Cb{TXqrA;X+rA^<#yIAWV(2mWwMwvIgwFyO@3swBOC&BIhPf0HV+<%&xn}3cp
zH#2gH)G^(Rl{vVBdDR*j{ddCTS^m1~<vwq4lkMW&FIHC^NKN%&?$f_Pckx@X+~Xkg
z#M^hEvKCs*S`>^s-0rh)`m9=jfpay+m$F+}5Odi&8P=R2%DD>%m;2W{%c*aLv%d7~
zek62a3I)%^79!tivIkzqkvaA%Z(lcG%Fe6RYR&GHr}Wx$*U5y7R$x{K*?ASPhn?z6
z>A6p`{HOFQ=a}0pjSULVd?6dVfLna2JC-dT{+drA0Z`@fZS^g(DVY*ube@w>x}h8T
z8YXNJ8|5J~1S8Wg?ms;qy^XQyb)H@<=TN|jC8B)PZnXd7&XWJ=PF@H_a22Y4$#R+v
zK7G7K0VeuJakb)Rc?VPyybqM`!zW2wLD3<;L9uiL`J{P(VKQmSCAn*2gG&Za5fI~8
ziJ@sC>Y3ZS_*{>KbiwB-FE3Cyh|0*;q{4UZj03%pF38{e*dg6sJQGH-&gBFxYPW$U
zasxEXy)MoE-doO`2dE)%hrEXFB}|Q<r6SZ-dyti!l@{&`1lajp9UV%6R%hyibsd{~
zd1z6jeJP9VA3;BSMZETFq+ruzg5Ix|C`UKCY`?m{hu!m0q<_H~3;OyZSPnY>C@a0>
zUgPS#)BpqPN%}oX-wX6pcs|@RsqtQi#KmT72Q$MOG&esZB$=LGsr#3kZ*JNtuU<4d
zc+Srw2e~*N<8L#bsuWn={8%=rczfK}9Hh!j>CeE;!DA`-w~^b_9u1-*tWNypHUp;g
zHW$7<jWY`S&o})4_QCvrX?p)Jfe%g5SBGmBybS&#M)pE3$TW_!xTF&BfYSdb02lT`
zlw$RSZ-;gCZSvu@ELyoWcCn<UhobnY#)TQooObZ(7cM+J0|c&7J{-|Ygltq99ufk<
zGN;ZDuaY>OPoJWsPJXD8QPimttpcDY^Q3Gkvy%CK?B1v3sd0@CpAk@6A^S*5zk_^u
zG;Zw=>+@_B(rXztiJ((!Eivn_9FZf0T+W5oguqI38xKfJi9va{j<tg3$&y1zBQE^1
zv10=eCkLF=d8&<y>US+6hG+`=30`A1xw@vwx&AAJN<YZvw1+-0p#1ZZc>SEzyG6u(
zR<br!$LZbC4U4ttvXsDY&Q5|w@V-=|tG2_eoxmrAo0IJ?d;hzW_kViF>l(#%#e~5Y
z__s69-Bh=8<Py+cNFmHs;K=HZ7EA-DiUFx(LgoJ#s^}kG?2j5Od}^%jlzd+NOfJbm
zFt|&W@?N{(xvkrJ_o5;ha;8jZ)?sV{F;((pDUv-EXc=KiNClTXh8Vld|LH;zCI|{Z
zo7@-cUXu6Wd0ZP``Bq#1&4-&-!DaD>mor}GEt!}#LC$le^)(VK&VRm2SzlY!V*)aV
z55K(aJ^vOC=QaOZ?2Z-ITjur&GJrl=$wvN45*gipIiH7Z?R^JY^9)>b#G)0Ecy?v^
zvWZ3afxNW`*%V$YoN<XGq7^#5IIh}Nq_H^@_MeimXF~)SI&4U;@*AY@DHNn6`e8C8
zyE5jy&-7AQLr2Qp1BDl?<?H-0g}8rl&n5Q#N$7mC;`rJ2t2;re^3!2A_V|>yfiSmf
zLfe1YA8qRkhjcg!@ZI-O7+>xkDNAc`$PDo*X`HV;P#>Oj7P;~B63S#FXCannb@yX*
zjKAoDeAcfkT~rOX-EGKiG`DrjNXT|_y(fxv#gPkS;~?z5cZ>tQQ(TjLdhXz*CUF=1
zJ;;lny>R!hgj*0l&I2O&9^XZ_>AIKht}y~XnUPh++gb6>Iq=2yO2MIZDAMy+4<{^(
zR+LP}en00(wIo~T3-_QHXesZbk|b}d|N4BRm|6UaV-AUoc1>mcpX;WrL#Nt>Mo_tM
z!@)I|tCm&LhRU?_<lxRPgOK;da<F!}89J6HShD(N8?LJgk}0HF#^LdPY*+Ggp9z{b
z&jPv;*J5p;GOhw{3PlS_3omMnl+;i^_*NdT(Ec5!NNtJ2OE>+STl<y0&bLi2)Djaj
zdMy#r=jzW0@SUlzV;~_>0pc?Ok4VPcKNSX@vzsnq=Oi8U+=tezZMmqcEGVmM90KFW
zBez&-XL#n}+3E@}44*aryK3rAQv?tU{4ALsR4#0?FvW6gr#T#`gnzZW$?$e8<F0F*
z*H5^@_Y$-<4QBlI^lTlNr}G`xn@%DG@M$?eE>}X0;|4W8m%eD=gTnW%Yqu@u)~#8m
zCM}i`A!~<ITfX4kb70JI{W##@<ldV<2GER@y#h~fbRb{oH=gLVdT)%mvH~!p!yCWw
zqoMQ<IM~~?vyexr$fwkRfPUDuNCgdxyZK*pABe**Z`SD42cEC<w4~CD-BBuT6o1qY
z8*ONLEsw8DKq~B7x$+lo=r{4O1QWqOYA`E!bf8Wa%W2)w|K|+R{^txG-1-l>q4{0^
z?CK5<5a=v}Xk=lrXWY@;)lSq)!OENc-PbLy%fwtD46o&14Lkm;`HbqPiw}=J2}5_(
zD9@!kdpb#3kfAd(@7O%^50Q!|F~)OOrl!_c#6f?9l*%APuRMp+Dj#gcia+J3P&#vF
zDi(fg^}^5T)#;1Zr<0IkXU}9)$!iy(lTh);LPQAtPV+PRGpt{g;hP6wYIBbKB_eU!
z)J3VJZu0czki}x?{I~7fIoA2c&c+KD2Ow1K2+Z_DgDR|R*wA7oSg)r>T%%<WaZu-f
zarRYVac*6c-O#wZ1Shz=yM`bkxLa_C#@z{?;L=D47Tnzf1aE@7yE_EQ^!dl0xtTfN
zT=pH$%igtWtzE0?^YO)R!G2}^VzSDfg><FiNxM$W>3Wf4iJo6<8i5m%$8Ooy=uIMK
zD3f9KPLn#>7<&{Z(J<GrTfBVouYds2?;05_a5qenX-2TxbP-Dh3-{&N;vRj68d6V}
zPq8t+?>+7?@BRC_X%R2Z4tsdt$rJIqp=@h0H~b&q2mS|)zGpHj80O8`uMXGnhkA|B
zOzm0ym2Ofh)!9aPU>)GA9DFuNIOQ%2g>~x9y5B(%scPe0rIg^u!fs)j>kPqDC||Lt
z$R=6~PQsrIbaKf)<;bSCAgl=g=)o}JcXUs~P%iIIaTb!L;ZHXAi*IGFp(;LRK6J6`
zf1hvzTRP*%D`}MCF{kr7t*+`RFeKd%l>@An46=<T1(u5ejxz>({v}G$FvEef<Kg1x
z6}xXbW%<c^a?aNx!~+;M^06Wob~ikcy|?5YAIq0C?yMv{U*v+Dm>{RRpo98d4nJ7_
z@y7E%LGsUr?}hOGgU|9mX+nqzVhB8}l35z~i@l2$vu%x^JV>{p!(^FC^UHTofsjNB
zOn?sbZu~6{g!>LY+&P{*^fD5e-Yh*AqC1@ZTFTzz%-9>_wWOC3@gSNmVB)(^E)Wxk
zd~6^p<C6GGLkuC6drN3$*N{F84SaY3%4%`*?jB65MxJpsRgQO+pGzoi|9#nSZwU~H
zcWe9%vkq3ELAQpY#jl#NJhtlCb0ZkM@Qt~9c^g6D#06;sZSY&h3r2YbtCraapo^=)
zU-Sx|J3zd3pp{+bsOp3OK2-|JPUAWLyMTgX*<kU^ZQBZ1eYgFP7VytGd;eeOY?FCZ
z=s&9V|KnTbFu+;UN@jyHPfl+7FX&*3Kw}ru)v5$-di$8pPW=d}K{h2QGlD)wif<!D
zdz_UW_mI-1mK(Tw-_-fHY73(bk~I6zuTI6%PmIDyI58kbML%q05cX&JFT^Ch4>N*W
zpQlwKoj4DLOiDNJAdax)nw6pcBJ`yn9QKKCFjG&Ihe^nDHDY12pul3}Dr0*m)ZevK
zIn)x<d1Aq5nhXx?$J|`)>C18gFUX7)y*A%%>3M{n7%*X(#InI9Ev+yNLpJb)k@TKc
zdf0Vq?douI`}eHzf8V+Nq#hjLlDLA%rOxL;yPA^9vckVz2fkJ)nB<Xr#UO|&?u}?$
zm7p*=IYfy7qMXI;vWT0Hq13$+QtYwm;&}ip?<P!<S#fAR1ZhysWuT6KvT0TblQ5;i
zJ#(wz0%pO18G~I!tx%z~$rj2n3AuLMV1Au}!Xc8Cw$2ESZsVap+9<rOKne~<r*c^b
zaE9mjC+qm(39F+<jj+9YY0A%iBp3R}ZXvz5ZK<ejPfz&ynXfrP$TKO=hJ|FS;=X3N
z#Zr_Vp?9~W4yJ6)$!$p2iCteo2ZhQL<_XA9Ybm2Urhjn$E$kclbo_8r{r~z#nLUfB
z(15x~mhh^eP#Q3*kryr`Ez&dL9W<53*CVEr871qlZ9dh>0hGjvN3_+7UWx^lDejT^
z4%(Spbl%3O_|)m~&|%cFs`?OW4C<o}H&>U<cs;?2WK{BFRP0{+WJAaO=Gi)+KA5A+
zcmS)}>mq{&%x@AU-@AyPmzrOp?34;{%$m#@-+^%y5t_gQE_&H^qvD4Z4V0;Pdfy1L
zHoufStt)p&41JMFa*s;Ill=~Zpf<p&+~jUB?Ez2Xy^t46d8afid%0UW<6{b}g2Bo=
z>?nQX=+5c*kLp>66<iaMKu7kb&z*g|)VI6!i?+$9rAj~StB8#EN0Rlc(#=CXT3y;<
zZt#o?nY+_ao_!(WwjUygM`gR<`=wPv(n?{I`;9q>6;-*uI-6H%lE$kVQ=pwbc?s!^
zr=1How$_WaPeN8^;*YxpGe*1Yf)X|Ye>;k>);3sz^aMH3XnwOG{TM7fexLo)6$oMY
z5x`w<gT9tDXW-%;)x>DuX*Bz_m+UDu%br6g3l>Vt)>v|SdIFO)&yo61+p7|{VMQ{8
zIGG|EiN!e0fA%bjRP{vaw2NRV|Mcm7=$sK7>I4A~g8um7T}zcx!XCfas}xWETbsn#
zpj=Ek8w}M|1R^=}>&flN*nIec4SSWyGj#_i4Tr!B8=}9@)mSc1XPBrFh@|le!v{<Z
z2;WR_n3?pi{WcU~aimY17o4kEyEi{Pz@vOON(8T5<n0$Q3H>r)*Sb<CsO=^Ae%dHw
z_Q-U^*V3eY^O&n+BA@Jud2#uR0Lufv1et6w1-<A0*|-8>?b5zSYW;umn1~!w&yb(f
zZHDtZSKO)MlV$qot)_n9RH0h<*A`J%67goNr=kEQC`M#u+qn4>x|x=F{nx@Wo@}`K
z>`}N}z&_L8ns{lp#M2div7d-r1%T&~)$RNySM_M^iTbY@sg{So*=qGakB{WuaNo=f
z6QuBz&bezKp1Q1}!mFXBBD(D|AE8U8N+H7@HGzn@B_Ej{{KXse{ktKd7k_`l-AE=i
zvPZG~Ub?PiwW1TkN-O0%WqP8)<TyX1zR3Ws-WD^?e++d3R*Ft1uvpSl&S!*<y|vMf
zZd-$;R|v@2lq3%ivsO&I)@@Dc^$NBm*h%%?=D^6;v7n{_s{Q0q3z;fXgpEK4aQzGH
z*2zD?OUV}Eyp@;d6z5A2)F|vUrj)a5wk>HFykq>_X0o_cDRkmqH`M6+X3>zKnNj@j
zs59l()HZ8k@|H`wf`jjX=+mpNqs2uFFA<AUH`WBm;M>E>-Xp0By+rzA-FM9`6GVBR
zH}W0`HdZYG$!{>jkAP}Vj1{#3VkfP8PC~8^zUXPo?<@F_G-xE3<0gDr;coOyfQ#L*
zJGmbL%dFbpRT}a6-)Q|W(5q)MKA26oe7nwM+2Yo()7LQ(h8+yQy2gCI(=c_2T_-T{
zEyEN+IjO*T*k%^J^t7ty2k$v@<#J1NFmyEOqiXr?q8lNLU%7H<6%7Fj^?^kaQ!>Qp
z=8q_TR_a0pE@U<zH&5%2d*Ldd2~x)mN+x~fgu-LEQ}ISqn-TsGzEAJ@P6$Rz`59$L
zV51eL5EsF?!$Vs}oVF<&PLLiSrgvx99TQ&uEc@8OLqWh|Xoc7)q3P*i|7hZmhB;E$
zYSy2-n|w0+1Y9siRBVtjcopY0zTkLA_xhWLeLiGWrdrzyp@2D#Q1lFOcaQ$>QVJv$
zRLP95{Z&khVp$i;s*T$~njQ2){$rbSGBvd*X34Y8yzXnkDwIiLc^LY|I}Q$v3#&!Q
z3WXQmoyD1F_ehKi3SX4zU@SVYp%3=R;CeiP8Mv`NzAU16e)XW0#d9pFp~zpb@X6cM
z0b%RH?{Pn*SU<6Jq*J~(lOV5mj<Qo9lhL`a^t{LByIwZTgQq<EQ)yhmwI+w-S{NT<
z$E@4H=|k^QpRt{Db#c3BRoYug%EVLreON0WQ)8(E`<Ld}!>~B-c$9?!)|32CD)%o~
zv9)4P8f2Dwq58CzO?-Jfk6BXTS$!;S45s)}3evV6$BYm8@mxK94Ex=SZ$l^QXJo7q
z>?w43s2-!io~9JMHs<g#7#7-eBlB*YB3-pIv9AGDU{|PA)0$4o>k#PK5)a!;K7^X(
z%`1m!JAISM{QYcFK5LeV0b3XOQauA(6+u6jS-d@Fz($SW6cR$|UU!DM2u)Be+<Tn9
zSkp-^Gc3A4KwTN8+!>(P^iW3;C^J5j^gPsFpx~Ai$_IP((6cSg_)~~m^TT0=ll2T!
zjZ!;o_77=<jgeRHv|1$Q(6?yLmqkkSO!J03tG2Issl;O9e3xUNYzV%rJKWaPrS%8-
zx5kLvd)0PoNVit}&YD$s$(MDAA4fU%fEnuu78hac9reSE)JkuTwNq($r}K`FbJna?
z^x=Hj=8`=_v~ljb?^gQBPOh7p{d|CJ{V7fiWKxu4+l^kV+Zwbm&QMm6Mvelcc9}ql
z1_VrS)a2y;N7XWi1V|@RZszTPHVN}L6aebeN%|f9VgfG7HGjZxRGK_hog`zy(TAkt
z=Fhg-iSdDjx~1-`C!o_xodY}j^mgNEOz*Q<eo07gkl}uSyZQMuoP-ya;h-iL{2Gn|
zEq;E#IhSS`wYU^|BAL;czGQ#TQu;b~x6-SBchyUFJZmO5Z#+@EC#&XOP=fS8B%^~>
zcpRNSZH4fWy<ood12TL6ZYg(Y*Pv1)n&$884>)(Dh3<KcCRJs`=yWp2POuI@i<x)(
zFcXs;83E@r3($8*A-SN}VsbC5r8|WW;b1qF>?odp=`@#)^&YGD$8sgg^#aV2s=g?i
zv|OsPhmc0TUJ=K4St-EjMDMCzN@Ptrs7YJwPqo%yebw^2>(eU-{ksNcEjr2OMH+b&
zXcjV*KTCr$77%ds%QEVpi=pw)#h6B8Df!Q)(blS_y8hZog~eF0lXo|21o;|Y@YiyE
zhF}qI9H%lxlI<SNBwR~J4Pzji)Ct)4^oVkzmqh9ebk}E_Osm&jG$>jzlw-z~{-x%X
zv{j$2n)fwl7V4l8Tnt)0WnRZNbYgQq7QVO07#+Q(cPnCM#?Py4uwmhAvqlNC61qyn
z7IcP%Ad9=m>5+eUdnOFWDXM-W$`sS=)bOJMUzh7fUqvvU*}saL<r|{Kw#b-~_B$w2
z6cH>lEG^*Hn^7l|fP#gIA-SM)=&ejUll&8`Q8nWRiwcF#Jb-pj0ZpFS-W?x*LSW7w
ztJODHF$xx>1JBmKShZ8zI!)}m8gtD)oSbpKv}Pil?Cg7f8J<-BD(+gNB>E0aK{nWX
zd%A@*S}A15_CELwmLgQ~LXQePN{;&4Ij#IWS6SOOn6j>dvL<Z?;jE57y6Z8WM_6@=
zs>EI5tFUqb03-qLWTiB%ypS9NgKrn&d-Y)bNFH6lV)H-s>hnMK>d>xhcz<i7w|<th
zUGECX{Nkd$zFor<Uf45g<|KcZuuoz%Wb!y`deT_$IU4c#qW+1Y#CL|9((ZAfTT7-f
zOCi2e<k%m4lykV9Jh*1;fAN6(jJYWZAP`@!EoZuG`KS|*8I%@mGAniY`Wx&m#x5)4
z)bd#LUBjBlV4VL)2jfYHJmSCYoG<i|bC7`g?<Q2E5a~Dt7$v<9zcPK%-}g`bbK*M1
z20ku6$*G?CQuN%R!^-p6daIwIR3N>vuedRWU{l1r&{u(Bqd4AZo#_^Q8cjin5V>DI
zuP|C4qdq$3m?=>?m}QA*fHod9ONyxkJ(^UZ{27+euV70fIlh=kA(+VYGr@_X${2+`
zg~{Lp@flYCQ)9xEIJbSo=I$N8okL!A=Sq&1Wl=4h`;Rorii(O)HpMa;f!Z)^kHq95
z5ypQ{os=Qlk8I|*9->?oYhD&YUzA!hSZ_CAMxNAa;4blE+i1f%{@D{nJ^;z)g!3hH
zcrs^jddK?MA92W*aOm{3H_(z`Z5@G#A}0v!=-1l$bLn?(c`+hf171Qt5h=^LfSu_v
z`S`#YN(XF3Tnh9Y2=XECbfOQ?h;+Ts&kk#&Qt~gpS#c7Wa+vv0j;~%er*1V5Qla<F
z+l2wA-tY7PG#GH^!t#6ra;x^T{n^<mI@05hiaB|nC_ai~)E=?nqZzcMR+=~8T|b*w
z9OBsIlEg7sxdsHHPER3wA3zIoN6Q&^1ZwL1@s2Zjo3h1HCQmNkiLI;qVyc*duPl_q
zJ2GY|3XPY33M`X2q%IsJ+3Tux`Ma(m2Il?Fk&25CzbqekyXE_)s8NM~hIPZWGRpsW
zCHK*%{i~b!zhF|Z{qb$&oMHg^r2-cZw*|dq`Hl5^&ElY6e}%yq?P7?uT<97wJSS1z
zoq~;zgUWX&KaUJB&s;5xIdE^bCg>)qW+o<N#wL)x^s@JJix`#+xX|&P7Vzv_0ZQD)
zpD6^sZo+0+&Yw^hSTvKWIg?8HE=bl}&=`<dLB>fvFdqSYf0g~~Pr#*D+Z96ygN@qq
zzOblCXA^>v-{a=3t$;yn0zv+1<xIxs_ADYJh%Iyi+ZVGtbHu)Z#l>^fg+wWsBAQy^
z-kwq~$V(w%B`c@`;CQyWHbGjx?V5qo$L`HIg=pdG-B$>uowlKgbWm65Ecp5yIoa~p
zS246HA?A8q?m4QDZM%{rQOEMiJz;n<J0<U)NrF-}u&JqGvfkuMqw}%mz=4BuOlO}f
z!#;1ecQ?$#!PhQUKqFWiw_P=46$4UNKQt6BU5t;I3OK#ys!W>yLaF^jE8**^3U@JJ
z{CYRaq<UVyTu%W42X6c*SGHvOmAdG_Dmj$b;MOH<8Z(>_=<6~+!t&3J?op$L9W1p1
zhUFztjxwQV{X8y*!98LFY95yUFM$VytgW(1%CKd#p4s8TevU=D!BhT3QNbEl$~TV#
zcto`|4{wwadE-*LWZCOOIXvGlREVl!QQb}DtUW{n$lv!3$sQyvf7Z>9cQYfwa(V$K
zdTL*`s7~FD(d5rgSKxhlfU{zMC1)RmYuS4M?yk^2PYxM)=djd=>|Ux3l_*^Eoeghp
z@;DJs<GDWX=~yVX=`*skSy(W{w(qjvWe){#c*hT2f0ZjY_E|X+%8e)NSG^ni?L@2N
zSU4E@`3QY2uHJh%Ieq+J5x|Q`TtN=Fe~fue@;~O2W3oIh$_0I(lX+s49Abh|`9pt{
zMK=t&NQWOFn??w3ttAYeAw96f_Phz!E3YkB()`2Xg0?Z+$q0g07@d+q^=x-k&?gGy
zR;6NXIs^L!^Gnm%u-)Zjj1jV23)|Mny-&8n5Zl=!=}s%#6b0Tw6-dFba&y(v3YqHC
z`nw^ng}@KrUPdVF!wYJ;r&oXnA)uVzcY-uT&}j>sM&2gUT4G(~$aj~w)9;QOg$=^k
zlvAD^c+t?umO)v}x0%&UGWIV!)=w=C!gmb;%3-07U20yRs?5h5n<*Ulo|P&s9Qhbm
z1B;q8;lQy&OB%MrQtNM$0F@KJdVe~3PEx2+;iJ&v6g{8Z*P+49s)$TBjixx|YDBG$
z-g~QM!l6$OrSewFdX)(4RF!aHv@P2etd@Q=WT#0V|MqiEIKC<5zn`;*s?_;^U?C)(
z0d~$t>yz1#K>i`FvKr?WtQ!Mz``kyfV*crSMEcfn8p>eRHjMC?^#aY6!LW~LPw~C(
z<ytXE>N0eaYCOO{!tw!<75=fu&RfMw!Bu~i4G^ze4GS+$Jf3hYx9frhP)hs|lRx8E
zO{yb1J8xgEPS$k5cIY;ogu--~fms-e3dv?2{h))4H7PkdN$VJ0Sb~p#S^yrR31jHb
z2lV1^6o$7cQ0DZDT|3}0Lettl%CEnUH}r;bLh}Ej^lhZeZ@{7xHQz=wTd#59<=?-5
z`oIKrT6Ju5VT;r)gK?s@e>jn^88cA$;5K{O&ZjA7U}TLMFTY$-P8#`9OS%Ep7i?yL
zhgvF0YKCJM3M}?^8ZtpDNGc@?rHHBcMkOX`B>)I4!=6Ql4rS>r?cW?Pxc!g8+RT-7
zGe3f6T|QJc?qjmF&XM-J!|c13*8b?QSsI{@K(z-7xU!7j{25**^o03Cu=T!vSr-qL
zYCW1Y^|OD?C-cj)h(e3(N9)In+*6UdPULEF#?4}JsQN@~6f@eivb7`np10Z3ZST+^
zf~mE2RI^)^T)y0#Uff<eFj6V_jIYH$%{_csDnVQ7XuW^mQVn*}t?eOsS#_he$QWq`
zmKepAI!A)6z^t-g%xiyP8rgD-J)|^^B5}V>4B3o7>9XOg7(c^QJ*9fwZM~-UkW|YT
zC9_f79A~#8T_<2dxbILIsjPSI!Ul&etID7EkYElCEgAf4Khl{b&kH{=7F6ICWILkH
z9Q99_zqI`&0RHj76Gz%DmnZdqBlzU}={DF>M`VBFWCuUIhvlE{<2qk6ujILJ@2+pa
z7;nWN(WP!4bX$_!&3l)UFRo_)Eb7qo5Z6PacDQ}vgZau=UC6A*&^Lvak@56qEOMpA
zVMVg2CVt(y;lr)+W~F_e>DY3l^%K?t%;CiAk^Z*=$mX`9wEtX<hKoCqarp@$+x}D5
zfL-fnnmoO=aH;8JfA+4($4kBETLX&|BAC~fU!Iwz0_cFJGmsR)PYL=ZiIQiV8g#=>
z>ZgbQ7}RpY^`+yF)r#?n2gB#fN0t`Rt$u|NGSWxZ*C&XW=t8v=9}etkL;0M0vGrdy
zQ3-S|6tJiY;qqQ7JbhT$97$X6y36cwaJo22kebeZ8OT;3;!wLeR=P3Lp)9h~d{H@6
zoG@VwA8tSTzo3p2sK1MEa6Z*VXD!{>NZ_}&d1(DbqGQcezq3wm&DybYPB5@$l*IUl
zQvF=>NaG!6$Dm|)?P%kukZ6EQd9Ulj@$x9r6VDA5dhv_Y=gBTEo0B^-%)#4Qk7!f^
zZQBXv&PB2tK<xM7s|LX*gds>4ornN8=aF(i@q+`Hd8KRE%^~8K@w&LvlXn8;a*m_8
zjL4a@i@(sFp`UZqd!5}bA=n&d+oR<rMHIJCSu>7`<c|6mNZz_SM!Pb`zbh{0Yq~+&
zbH(qx*;Wa$Ai4z}$CY6$rt~2s6RJo~gd@eDXo;~*3*)4AMPzmDFws;0kFm4<!vM$#
z?BtZ02D*EFWA<3<7CyDEMkU~*?C?#w$y-}>K5HHRf)=8q411$a4*pRB@43E>MnkNV
zSEBw?+PIzpAu%dGoXk;h$p?RtrSH!O1$Qgz)2``qRdS4&z^E48u{^6QN;=^yYO)kY
z;ebSb();b}PJnN(t^dV@fntjtqr@X^lb6nAaFcD?@5A2St&>mvY>5n}{4Kv1f3);#
z5Axl8m=dof)JDQOiYSo{4mA5z(h%ay?$TEzvbi4?as(`z|5Qy6!6fY<SWg*($H`Ya
z^!&2=uSQ@S1h|4KK;f-KbE{8-u$kZC<f?Jv;W)b9ZV<#6*8K4wY{Ss4I`)+aFW*R2
zIN(`GrBydVpCUUGX1+X+gZ2mK#^)fKi!E!@)b4{*CMwm5%PL_q_w2c|8D*Hz>J7r-
zQ7PC~OFI@$uV7BHpb!5*Nd-6GWb@^%+>1X-jy=pe)zy*felb0Sucx;E^7q=58<w-P
zv-M=q+|4G0!Z>gAiMyhp?a$l`r@t%DCCRJ$$RtXeRNUzKN8i0XE6y<GA_<ldy~=ac
zEDLuIJMnq0l#Q_+>q4#2xiRiXA$Z<9CRvTZJ<lIojftT=e~<(-+#jN&N*pJ`a8FK8
z8xuJ84`Ac7xd+%E#fK`3>4qh19$k_lNqkA&ch&`2CH;{K*Pg<m9$b~*hxKNbW`EKA
zi@DsFnNy1xFnWO^XbR?zGGY>l^_jPv@!YX6iGynNteFLa-URpFtn!d*I8Xc*rjyF#
zExi;g*lD4{YbNhFx8Eh5ZpusvK=lt4-V|sDr4PY73ywvxGJLH<6i&(EuUAPqS}kcD
z&JKulyOG|Q{RaWwrX9tSbw4A}M#oQ5Q6y61fN94#{G7V;Ozwm)JnMg*7rXwQAocW&
zEv?O!D7uqmAb)0J^|~hE2%Y&Q*WpMn_V@1z#5#RNKC8&t_q>zo{6Ma3R&(^j$MVyY
z^i>mKle?TuNUkkQ;|#Zo^Jx3c+S6EP2y4xcudKpfXcp1Q>bUWcLBX*AY(VaPml1Jt
zkbG0p(5x>Ry$)GkPGVnKnd$z7z=F!DS+j_=9Q99>@1(@0mbZ0ky@3cS`Etc5T<D7m
zCtf3CoKv!`(+W}8H<xB7#E#thn>8Y4xK1lHr3pX|T1ckA3F2Dmbdf>7I9+}GP20&|
zPCvQwW$FuNxTS=7`ai<oCVyBrp`igC>Zd?x^`^vnQQES1wa&sj@F5hGxM1OJUs6Mc
zFLQ?n7af3x$m0ru7E`l945F|x-m%b+Wjq9$)#VLz;-MSn#0!H_*!<aVtem>4Ot!+{
z)3*D=CVCM+cSR+HL|NUzVzLOcQZzMkQc00jROSRlxk8UrX|-L*Q@5C3YjS&hYdtp%
z+5ZH@EzMm@MVT2U#vgy$2}2VrY>wD&g%$+m%Ov~qKbmgu1n#JN81HyhF`TP_<0u4}
z^ptp4Ount&OxbuYHt(JyKAFqk^{=Q-SzG#TY#}_b`j#0X{%s_2T{G>j=uKFZ5$$UG
zF#=C&rCM;^KHk^VYnfRVVN>$W2tAWVSrV4ysbOEII#seqLvK*NMdfUoz4h#gH?Jr9
z7I*5hLPqog_hm_{JB)C-?W0<rusb=gVb!9!#@u>uMB5_Py<7>`F8^jjYm8H6jB^vq
zf(4~vjyqx)g~f;El`8g_adG``(>|Y|G5q8BR@#Mxs;h#ds+FUiN`fo&bMF@?b3$I`
zsGG~jeMfF7mZ|3x3!`QX`=iXHu|#MeEB%w`mJkJ^9Ayrumk>QZ+?p;6E}auxA9=@p
z4%p*7eEe`KiDXB8Lv{(wQEaEbQ>&K~TWB(HSPuIlD6W@#-9mP<?JABTkWoJc34&>J
z46D2s=5}2xEPeT6bGHX-*PS%xDJE$RiJVG?$NWge!t@0lf8NogO%=SRJmc&~&~6P^
ze*~5VYf3Ux5hS51B7BGYzx~YB2oWF;ZekoX^?&nrE$p(h%v(Vi`&{YKL{QQ|+5d09
zm;4raJRpC7g`dla*p2_Ot85MT{QTE@SHr~fM35j`kAsjR!s{%)cO~FpyE;ZKO~2zn
zOdQ!}V^fOl_Mpsv$e%M-*l4Cau27=!0iPk#nuPvXBRyZ62L&;Y*SKSZFsx1-^iE!%
zN8T!QvWd81j!IsBp4e$F%X^PzW`zmIrb<$#H1mdyHw{|_X!Pu~!+(%M^nB1vvZr1=
z%~N2#`LMzwGhL{`ORErm%rlI@uD%Lqc{y@5(7bIikkQXa)IGC)6ezSZajAJ*t)D2|
zEc~keo>)y}W>dvAcrKHi)348^y)*jZQ2*U8v!A?I@%khr!V)^fX43?mVJ)Q>sC>QW
zWJ=%sw+9XZx=_3i+<GXI)9S+5H#lh<X9U3?%fi9ji64s!1P@g%2=Q)T9`dS10F_gE
zJ`SJ_EWz3in-H^wpKC8-_*YuRdJH)Q{C$)h5fz&_sDl0u_oHYTx7jt{Mhn#$H#zP{
z7KT0W^A$(_B2Vp<HfsY>BqeO;6MHpcWdKkvxM=<bJ~23dE1Q!*T~_^vc*|VtI%ftz
zC61nWXmo_t<u#J(WROhVhoPeb{G2spaTA&y(O=tpl|kk#5ZQ$J-aVTWvQw}Mt@yQg
zvA_D5K3{my&{N^EVxe|R%<2k-6F%uLY&$XW8hAK?=QXAreZlzrae$Gd&dR$&=g-(z
z;QoO(uJs8iZ=bS?uEd-0$`w=Geqo2>&u>|TMc&$;gqOibyBN@{QEg!&t!!CAOp7A}
zW}KQ6l=vc)Ju!xrFxzi2nNQx6ljjlz^JmD^cu&yoU2c%8!7q6d3N-WAnlOLs)uPj$
z7|`8x9paMk0-Dhq)oN9{wd1xJ+fXmlT#iaP-(b(>DJ<X(xiJRU^rL12q>%XFx=|Vw
zv>Vun1f8N6r#yty)Zn1ocTW6I8&|A#xx{<^C)bN(;a(`!32i4;^XlbAUxq8qx^o6R
z8;c|tMo^zMgS<@&%-*)mnn$dk$|gyAEvP=UEdJaxCRt>@=eoT@5N&axkIT%5R7U7g
zBmb=bl0O)D{CY>>$!%F75XA_Y;lj&wB)&bP_7)|&wiubTti3*dE9vmoO_a*Puv{mJ
zsV4UY_agz^;R%R`Y2-_YZPyt89V7txX+?LZEgV9>fXw@*kyVlCNVPq}xANz9aop3B
z)_42xAfe$MFfDQ3-XA~Lk;?s7-bA3)#PJM{=UxW_+{ieEnK66q{EtE-RrmIo2mVFL
zZ^BMQM<daam|lVjOo<5l4k|W29V^ub(0#Er<(^1Dn8*oY-!J&kSBxsPrnol-a&Jf2
zipcNES|>~+=68Qe&&0M&794EmQ&b?lIH5J#ksNj`B%prOLR3Iye3Zn(`Cwb;o-NAG
ziUf(~ERTaEtXLHwG@H&ah^{(Onfx#n$lSivS7_st4WKeasz63EY;hS$tXW27gX~~*
zyyL%Kn7<Hj(Ae{75s=k85ASu5A1jWKBCAJNUEK9tVRbX%GEnCvGxOu`n<V7ksKbpQ
zb;F<-{l4L2mlXCdfeZ$7Aw*R@YABLOMp8N1;?;tZ`#*$`iEL;w?0z0+v17P|lf(z7
zM8G%Xp7({rH$V`Dx0*AIO9^UHSBv4n@KWjU>>}flHVK7v2dn@qu2Lsxfb>`&jz0Q`
z$?MdVsZs`z#OBl6;DayTI<gvB{3^Cbr<mhjON?_iAUQ#O%#R^Kd<e$Wfbsh>R5SnR
z{sgRXhW8brO;L1M$AV-6uk=Tvwm;fB`VWyTkR@6AH^VQ_8J@+;#2d3@ICa^|w7qqu
z^$dV)(~fAOi&8D()0vnc8r~*Owm;$J^)=N*o_b<kHS`@T<=4r<*GcS9U$k`%1wqPD
zlu|v{MbdPjl&wls!X%rp_&xG__pB}AfKcfl6Up{|rKQ4_9j{Tlv#09K=NB4dmlv9i
zx&3b2&UWvBsMkNoPD!rhI_D-Fzh5uf^D(Nff&$4vLCAvMt026Jjvj14DIqr_;rn0M
z6E;w@vsOf46WYC02~r>&$XEbUq%u>eCnf&n(+fDw>9UW`Va9mt;txEO{|H}}lk{hV
z7n}?66Qh$8P2LENmc#GQ83_pvP8>Q#=`HZa*FVI*VDGK_A(eb1>?l$B_H|-wy_+E?
z!{Hs^58t|%^V!koHy}7ua4J5z@8$_p4%1MW%fP20lh0OU>wsv#;N&X7BSVSV5>S5L
z_XdFUA*o#>Z1;Kt%g8kT<e2yXx57iE_gxa#St(Z&%e^N6N{ZOX^=n9Z-%>z>L@y4r
zZQ&2jRg|j}mpo&AMBfC)Cl;gc9<gI&n*&d^I5(ZRXO0zS9O;s^<I4DPH<g|~GN&2B
zfP4#3{_VxI*0P;Nu#rfZ>K?~}a@CgeJH#4nWEgO|hf#gov@~qH09uLWR5!`bACM~1
zB88~FT0zqW@^x}TmT%wImDw*$oNXDmeip6n-y$Ysni%Q(oOL$ZBpA9zyob`JAUBA%
zmSOO-c8n!z%i+CXy`EZOPIm-Mi{quIrmBlUN%9YTE){Pg8`G1$`MJNzyg6ay?{Q48
z%|oKOaPJ@kSXT`X9c^*B(@++Pyx94x1O=0u(3dYz(^XRcv};ztfo-JlhFsBABfyO5
zY3~e>z(Z%Z%m=n(#KiliQw^KP#!}2dWWjR>#0{1=Q+z(C(*+1{i{UDjeU<4i#<|-m
z;{21AtNdX{N7;%5cdmKCwr$!v`B&)#fD)X29f-@Dy;pqG_9;aHQywyY7C0vne?kn=
zv4;<AI<D@tYA!igACM*ev;e|C0f=kOEjEx-E2{+6#^_Und)FY2MEg|nf`?(AI>8Wo
z?;JcTuT~t|V1NDzH7m{9D>60t3~PkVHCDrL6tVO}m#%cPe64s%!PWG4znM?p2QQt7
zwCfIO<|Ih~*Mu16Lyilmb*u5WZVS|s+NPOlGigiTZ+LghdfBP+cbEc}<dH=<>qAp(
z;3@r<YB=pDPens6fbc>O7bCrQ<}{quyPYdFGQmOyKN}lGJy90tTLwts_9?1~xTG)N
zQzI3)x9MLK^N_c2Cdw`~P)uiV@r>P3gn>}C5K(VXh!Sr(bx&%1rK6u#Td*501-Bnl
z?lt>JB&(6-k!;!!dEaQ^*9)DXBndA|HWgSbdwi6UU^j`em{UmivU@8$4WG*c&H^ff
zuKhs0^#SmaV9tA&)iLxM^3;zDD*Kmokh*Ibyyr_2Suy^xtTs-U^<8EU=^eHdpT8gN
zy$G6ZHh0(zt0VkE>hu*7TpzXm6%qU|n%Gm%d_fNnb*giv;VG455ed)m@OR#?$x6K!
zQ7TsXLY{JN10rMVu>&f^qJP`!%+1u3x@F}+R4*PwuZ*xuKL2WObI}<`_8so89cl+D
zz}L?5Ehdx;z_un8o4&f`(d<3z^WX;t(6Dg)NIe|cK?;(6yd*oyVKx-0Qm^zfl!x4z
z-i7&K1;sjV^JV62KlsLv#;rprC)_(IF5iz8rD>Ij+vNzWJmO#Q(2B{+Gf?H^ut{~@
z++8|$XA<Bpf5%&k?x`;}*d|ex91G7uQDID&{6;qIj5coyRA4dXH40UzgzKKB*8k49
zk7kRZ;hMN<UCba+mk`BFVNggbEaoc_-+bd@Fl6_+7Tl%r<Kz8Mi?K&{>3g9WMTono
zTpVTM6eGv3A1Yv6ksuVVnjD}a;1u5rEE$SA&`jd^i{gkQY^Q^)_5D5Lr8JH4frQr&
zH-s81{G>(9SQd}~`O3Gq6>LkGz61D5po;rzkUyoHou*bG*FThT9MW^=9Kj-+e~eB}
zE<+d&w&ni&Zl$d?_5~~_EY+P+eDO>FE#O5_Z|7HfF`yb(RDg8Br};PCtQ{9;*2iF9
zQiP;8+*!5jbeeJ-b@C;uu6WRGIm_R{cSV(Jc+6>l8$8fQUu+N@Nr4?_X386WwkJ`<
zY$WZzQeZbcTCVV)xZF-Zd!#buh_k_+t6a^~H^N4RC5ct<1mCJ{t{x(Xd>}GPJG8Q|
z>)CGTmGoLAgjg(tH5~29L9vGocI47L-}>!RKUnx6J&y66>?DJ}v@>GG)#!GHr=rN?
zR^0h*XXJJvcb8!(Y`*_~*!1iT@Qnc6M1i8nFYfQ5tmj)!=2%au^mepXl{K#9g(cX$
zSevIS@>Ml**xV5iw|IMIxG&+m4J0vmw=?bFUJQ#&m)bHDsiq_vVm+zMs=9#Ce)-T|
zda&uaGbguDm;tzTf<G~Au^Kga&9U~c_1hNmj3K|+63$)Dp5JRSVT%%;BYhF+$7+I0
z``_NwaiCXM!CAbZHhsLmh`I&M#lplUzid$Y&jN_1Uj^4t@H}Uy`I<9i%ha{=*Q(|)
z!{`QIi!i3o#Njt^7nVAdE(AUs=@X*eZxcyeNTDo$$-JnXKco^p{svzI4<vfh>k}hZ
zPM<Ai@n}^nS;uu^uv7f~*dnvBD5<-2y5p0nek@NOVgUDxNX=)H_&49vM1aFt9!N3~
zQey<($u-UxfHPa?xf8zu3$9sFRzVL6hr4p)g@4LW2&cm&2w}2q!Ol&{GU-d;)4dn?
z^K4iE#^}REuWe}eNxJ<gf+kAb`MhswOe~OR_u>lJ{w}zi?SxM0*OZn4017WZoz2Ei
zK^YE3L2dWxc>Fe<;g;>PWGL6HJs<$`yKhMx5VG!hs-iYKLWD>Er!mHRl0nE<8|Y{u
z1NgULegzw-a)~JafXZfGLy5AaFiESh!o*1;@>F?RzBrAl+}W=NVok6sEJi9{a2<6|
zMrl4-${#f&qq&PzfPRMo1#<p~E6>oTvTS8TnD3a$cfENyW8=bladC242rB~G4zHzj
z6a;l+0UC%{t`e=tx=#mdWPH3IiZt%Aym%JIt_*tt!7i+l0AExd_PzzsdHF57r##r7
z9u&ZC6AanUbP$dbHR?q3<zTg9OLN5F^`X4kWebINIL<yvBme2t-F$ifv)6<F!vTdx
z^(+c3@=c8}oB~7o#Yl4r)K*rGuIqoP&{(1VFCo-98BT%@a9Y>KMV_HemLKtS9c(44
ze}x|EaDvA3hTECeEvWBuQ5jx&6X0k{_~BCDuts;cc%$p?5U{!>BGuJS4LGH_U`5|J
z3QtoB&!#m_zgp{%P0mzG&QvuR8&tI*!Bde%pkgBinN__VL4}!Vd7XB4m9~%HSMW}k
zB^xDULY=3nFXkMMS>W^KqC)|O2*{OiwamfguY`aGZdH7I%OOgv*BIL^k8XWqNd8>m
z1ocR?nOmU8v-i=%c}twI9K_<;z-VHs_UOLQqja6pXmrz8S(WHI9t2P!vc4#KiMDO!
zv#S2pKgMK;+iSfm0qNz$=5&wxGljC)b4ZUh`sbl9udMBfEzKS(ljoe>ZW-y049J4s
zglu1bcRJ!HJ1TbSeb6wPOrG~Ql&;+0xv~qe8@@d6H;HnOVKVQ~zYb>iw*cr1N_GbV
z8s<z3^}GNSd05k~4AZ)Js7!R~?7vmmmv<r*JVeQyudiQc4-lYIJ-sqSErRLR7QW}I
zAxs0Y3yU1z6kTKlbGlefHyV-h2^8M3Rh)5(@>p~6?G7n{LGY`S_h*h&t!fN5!t?JK
z4)z^G67yi4W8%DmYQPs%Y`0>TvR>Kf5xdZSGqVO-DI1_99@X?EtKgQ3bfSw^EaX)`
zp3|&w)MgO46c_AIo|8`pc=12&-MQ$;5sOv)^_k8DzF+^94Vb?;$umxUls!0UWdWjo
ziF+V;!4M;B<A+T6je(}9<CucA1mZgI_%Yuf+%F&%pgA;tm1MeBJK4K;$=>*sP*uJi
z@*)o%7N`lIwiajTDVHjJCO~a10p?5e;jVsy@AOD<D}V4jWuH4BGdLhw;DZd!oG`2?
zU>epq6{;`&q&%;*;M0-Jen|-#R9cu;vvJ4SSM5v`67G-mZAVoMV5kjS<?c1<TM_Ha
zvvMa^tt!^ZwgkJAWQV_fA1;uH`44`cf3zRc8<X3+IQ$5rmLVT_v0oTH+cqwXIEu!c
zuObL-x%RfULREK%9~{A2Q2GG?<H_9Zo~oWLAC6}12a4HqNG_{xzP=KA#`?4wVIdQU
zAg9(Vo1*UTe{(5}zPejKsA-QsUdhu-dvt~OTlEJNZp&cfm6_H9f*<pLT5Ue2CY7ge
zI7I*L<bUOV<DFnB`7Zl~sqdDguL&h|#UMN})<Fj*A;+OAy*A}P>)$_Dz~Kd}w>6K5
zAEN*oaDQ3JGm`a)5bc#kq2O3mmDNhTOrGL;9=fO^n7R9LNr*%URpVR_;?`H<U!-S~
zw3*}m+C%9YMHkk$$3_FQzmAK5r}^)aOqK^#>w??qnu0$5CKcD@zRucgx?F=nDqZO9
z7B!B~RTLc433w-A4ASS;6Z*c1W~m77bz7V8-VOXve4%#aRSvkZt(x3TA{19i27YC7
zC`JVhjVijd+sX6|_+#%jsGEpC+i_v&MOBT!#}ZwZVo^dcsLVIL;eKT*e;)b>PXae2
z*4DplNO9-mV|+nc^Qi*clzpq(i(7YFOfk&YW{l8oFDxoVn%eP={+bM-w@QVF!T~g5
z$<(6{58Xoi<h#4*dH1oFVP{js6H4e@0Mh0;7l6EZ`q9T4%~n`r-E_GbSM#q!giA|t
z#MlzOXN+S7HK=_#a<qOXBjNYohkbVbYjWNS_60H3F`UT6-$HB7`@YkG`Y;Woqj)}x
z_8a9>`F-Hps3!3SG~Zq-Hq#v+30^z{Px<i}x94U%flsLUUpMj+sc_ERu;)>foPGxy
zXob3Aj+`eHd%Y34dEXoo$se9&fOM|>Pj2@5t_VTxcprxEa~_HQA;9QIe8?gFxW6pP
z{}@Ti0dANg=(Kz0;j#6RNAI%|$tV!rvA*bW^%w5FNhemz1f|akQBeH-H9$!s)cXDM
z<IJtbvEK)!7q^<WBmMG1N=<)G>5yK6{6%@>tb|E02cBeue2XX#sVp#q1SizY8D02|
zSa_b}7Dm^{RI8rm$A13xCCZ+u9P96K+um~pIGDc`W`x@)j@ra@OZNY8!$|J?S&KSm
zkJhN&LAsgs<lTYudGcU>-JBZllFeIRY%J`N<M|Ko&I)uHY1Q_p5RK4hPXlM}#BK$r
zD2RcdJbX7|U3@^uqQ!*1T5w&<@9>fH8(Om&;`Vdf{xA^uzW{BfVvr?bY?!i%&Rp;>
z2k64Z5JB>`ymcrmT`EyZ!V&z6>Pb&Y{b-t!a8Qm9%6hXF_#3Vh?gfkHkwf-TqqZT*
zPTvV>X^9sf_q)S_8FIZyHWz4RXHT(1i}8XA6p0&pH91A^O!yS(fCob-TSLme20)wN
zlMZ+63uBn!hN=%@8ej*p_?lH&0B;C;eZa~HFBIB>{TUJ#)l<_L_~zCQ)qa-U4Xo)T
zP*>V$#|S<keAxgzxB_l+vJ)Cpol!njZI!R`HnCuUk=>3Qr^f~_xYA^R{<!9x#uh{-
zYb~D}l@STnz+SiF(wXlwKC^BlPrD;$Bio$?B+6Q$dBud=p?vdP$isOth0KjvWDl$I
zT0q;YKFtUw<a99ugvC&MacGby#_-Y$12ROIR$79{j}PDe22H-9WqEpQ7A`aDy+1R_
zxlh`=`~WPwd8vg5m%RrpsVKMuLxUs%5U2iGmT=c**VLqA3ffwc6&)GrD*d)#q!%<@
zy^iow4}ikq`L8|x3y&Dp?%VBzg+!rn3bD_^u}>&0tGV!TWLQ_5@4_#9lTJr1=Aa?j
zKss{yFVjq|j1xtM96+e{q2|g~*jIX~S^E3;>Br1%+E{HmlgN_x`1@8^R_1~JZd@@L
zt%(z7{J6uSReMW{Q#d|UIe#6UT0&h}<#Hb0s(Ni|NA$o}IC1FL7z9n`mka8nY6W-u
z&pBE)6wnL=1Zq_;d>h57zE8H}%Xh~rdRqavU-01B<kA2*RJ4Jrr8ipu8!X@fHLKzJ
zn|n{!#NJpK%V)pL*nv>ohae*Id%8L=mgMRq3hDZ5=tj3(EXEP01;PuQ(bq_M9kB9M
zyNg85^eYB0p2eDTo%9UxfX|$?FZ*YWD(G2$x#Tq*yro*{!0=zNB#ah5M`>S~6L0qG
z3AVubWn1^iNqM`KT+iMj&vvr1(t~K!sbk=|aQHpo@gus~S>n=*$6aA|iyUBy@M0tO
z8l13K+v?>9Z=eSU8|~O2<~(dQkPss77{3I*dE-zh)KpE;>-(jwS4k%*Hlhj^Esfd2
z7GA*S!V{4l@gzNcoWF=)1ts|I!>+jV<`>_=r%691SJnS$)>xvo0UJJrRZ&f-<mr&*
zyN{W(8s^9Q7GAAYyq6)~1h7$AZUQRjj|h-#MC!pY>*l@%+8ga@j$PGuR0nR*?~0$^
zSvBpzXDt3o*QfC-bMddbG_q@6*EyQTNrKkK5hMC@yv->=V&w_6ADV9fCr)s_ujYh1
zVzF|?TH6t;jH}Dh+-TI<Ab^KjD18n}-TW@2j1Y%4tGVyp_Na+{?^1R7m4YIuqpSbw
z=qtm#i=niUL}M3H(F_L?LD_9t;jF%vk}0|*rJ&^XrxJ8Hf5L<bI8*TqsWFLf^(5{+
zcwgxO<5E0tAE1@Y6O$ue6D62OS2K?cL*?DGhYYDYqY%*m(cPNd%jV%LwLg{Y`v?2M
z97jW#P-U|heIdzM$G61h_t;I4u=#!2U#iX4#q^5jCwNWe-;_quSO?L_<M`W35v(?^
zTXCq7s%_K1EUw9g^fc;H2*spxcf0}`+7`FAR6oeNhKh#?N@WqiG4!GM1_j^^%VIKx
zCTSTT_`C!mgVpVQ*3>H30AjtEZwi#FBdifUMU}wv4h_CB8XFHbR!b;-6sm1IQ_48P
z!c3kd5Urz&IO$)jo1E@}@XE@a6G5oxJfA+L0g_0;gDhMa{;?aeg69VdQ(W9vqkVr)
z!1p|FQ2L<=Iyu>qV7`+YT8&DVF8<z0>Sb1lyGpo%oX?Py4=|kzKdzRLRZX`+YQL8r
z=0x=bmn8HdG(Smu)MLw62w83sYff#F8NtTR0wC#Pi!<#crX7j0lT7mbbg#Ff@;lQ|
zvv(qMjni0dbIx9U#dm0V(3rG2&#5!KJY3Zyl>M0jsjNo^)y5k>-?9l_WL2>r47?Lm
zuDPV*ihsJnN+q)W6d3@g1-iRhWR3xcRV971iw*lrfQcI%D1N!F56~ZW$=@HZ0m{Rh
zNllVTUt-~Sk=8^n+hBuV6+#orBC*rb*JXNUqQtK;t{#n6et?nj@fvnrseZGNdwqQ2
zf;H(Go}8;6_a;H<D3T?13v^>lh@E_x_4~A}@-z?Q%2<PQ;$5wGY85!>6W5XL7BM{=
zEs7g%nBDrG{X8S4*AwXricS`diwc({9Dr)X;412p*j|ZSdsd{dhhLDv(k2y#t!yyO
z1arPul+!>ke8>jsMD7b6;i0bRY-^wU7gWh>;i_0FLgPUW_KsLvk;YLIxq_4)qc*sG
zO7H<PV?BEbPr}2@Bz6P(Ms-jaFQoZzNAeJ1^`*pKT=7(9KF=b~MN6$RvZt^q!}Hj6
zMMx+5=J$06Tz`7-XcTRkw2JHDcr&6Br4;M^PfH0FfC{#bHQvOy`19R2HCLsz?#6`p
zPBN!i#9tnR?|)~Jfk_h0-vK799WE}UpfC1d;&l$}1@dp-Yb8g0_w**KQ4SDq19k-N
zlE$=a23|GPdnV$X&T+ZVqNzxL@bz~5;|iD@sKMd{?ptp8Xey1--6qQe5LpzxyIoQS
z*7>cQzBdLxmB!*H`#>k{7>0VIX4O5xz^byNFm~>r2Pm9FFP_i-2?0=fg!!QSFdpDB
zImP=_oC3Qw1Jc7IN1}W#iTJIMOj6#T*Qj7j*)Y|P_LC6D1<5~mr2Kc~Eym5gq!+ls
z2~<7k0!7Qm3-9<`+DHAq<Rf(lPGZ4e-|?tB)z(60J4#?{(3$<BmyCyS^-u1`BZX1b
z;$%7b%`xvuRE(({67YcY9Mb0mckd)3WrHVWbLZD;*+~ysI|OyBrJs;DwT>%cSt1hr
zlKPizGwgx7XZpV;kDgX`1ZR_Q!Tj8@2gH$9x!R#KaCY=-g@CEP3u{Gs>1V<)K>l(l
z+tw3D?F&X1!-Tfoi0C%%Rkh}ZiCTybrX&lr`p<8jn(t(o;t!7IeZ9^EyxOB>MJbt-
z*Vc8<)34g){xfbf!h@DD{&nkD^T!Th2u)&P!r~TH3bZ3Fz+t)ZPN|p2=i^6fossD>
zM_FB|mPV#+IU!*gdwd;^%@dD`IaedKM;(ZUQLgav=0m@;`O;=}zw?o3;-4H=zDEPd
zzDtJ-Lm|%_wJjNGC;hf?+lQ^!TjHOA<|*-`u|4=e8v*inw*=rH2o89POk67ME+m0d
z31h;-lB7mlaP#4s(u5g^d?|R@;2d@uwU}@3GPW$yoiPDy`qeI>{Jo0ll3q#dp**qS
ztjfqXJf-`|EpiM8Zz1{F;Z!CKhVn>|hd$Rac}NQ{U%2si+`rVH*@O=X7SooMDb$`k
zL4D#mfnJz6QHXOVRdCkE!*<Y;<n_Z{<bAKH!{oy~74Wsi)A>xsoajKxA(-<yusuPu
zRjo!BzJ3+ci!of#_MxaHxoqGt+TM&I8t|^!NP%DP=W6!Tf~xkR;;_Y>9YYT8Ail;A
zjsfHjZxn+!rSmnhm>QNl+;ObS%4Q52{ed2mrGd&7Hks_k*3|d}S6eq90rh5Wvcj2t
zIoUikRC0bwHpu(g3gj(^cdhlw;)s&RB%M~4sCUTCPcsd%`IrTC6Ar&Q;o<?_ObX4T
zm2aCgEFIjIm3|+cTapbr`$L2`&4>9<JQuOAaX^hYcU#nIdw;`2f~gbRow8lT$m!mL
zOI5TGOL18Jg{(*Lv@OgVK=}+HpOHLg4uDu!l`St~lgFD5FnX@ZYq)9;?Zc?aH^Z@w
zr%*gvKlJlFF@)x>kdZ&@K9J?!EPynMFQyMUPA5Omhob3aA0a>8^{@{qdRZ7s_cwb~
zZ%Ck({_YUUf(W5QOx~A)gQ`D!rfpb>d_J!VNSxKg)vJ<BpB`VsI@l12;IL|}@x*Hh
z+%~A7yZ=I!p)UrYOC8DGnk)zAzhOKo!O46gPkW*0a9)-y=?MATRv+`!+P7f)y5W0%
zTWxB#+YHLD)Fp!{db@uJN;+$TPnIXlh3jBaF~gp3iR|mE+|_01zj1+%L(ztz1&A!H
z+E{Tfu>8>=Q<lb<ziUbsVJ|ARYFPKj8quELqt~{A2k-_Ae<qH)vyWl_ly8^DZV#Q6
zMfi-ndhG+L#vya!5>)y=h&wU!E$DT@Qk)i089bf<U-MXj!5%t(UsZ+Uz-|s<QdL4C
zw~Gf9v4M(EB>zU{gC$3sykr3FJ}db7;C1Bq-rm43l<5-#wFmo+-=-zISLKV9i0ly!
zv`A09G~f7d$UxIV%=tVK)lhZ))d4q33kiv09_YxDe=mJ;?@4$+?23yIcQ0>V(sFl)
zPG17V(GQWSu+*!#6yu+y$ZWAN@$R~1FCY;>7h?m;RDTMA*VYg}KZJ^U4lRny4zs$x
zeNVHHV81c@u*52$XBcKqgz7>c(69tl+)Az-p-n9q@Fc!py`di;;`_=4I2C{fZ0rep
zqDZd8W^~9?z(3aFEv*R4^ZYdsCo>Hh7b5_a$jAj#zl9BO5P(Q^MZFxhops+%lksj6
zAP%(1_BLuJR&fzJ5T>}Q4?5`S$ab0nmD*>5=05rekMZ<`N&(&e-)f!zrRBM3Kz&XD
zG>jhoH_E;$D$aImvb%A2cL);Pf;1j1IE3IX0fI~8lEy>u5Zob1aCawIu*Tip-EH{J
z{PWM6xtMe2>b-b-^+m7esor~6)vo*jSj{?sZ7~z!TM7LG<8nSq9P?}OIkXV8QLSTM
z%lOqSOE3re3?HtMKep}Xm$~YUM%f%65+>6oxh6#Y9u~lcomJgqrMj42Tw0eDSrQ~o
zvXV8o8gp`_=yOAhE)%>^%?ZN2sJk=#{mCI`N~6>@LsLXYnfY{^>GUtas`Jhoe>Rch
zV2XcdeRtFGw9^3(57V!hsX|woEpO;CNi1$F^SWMlOKwo@Ky60LpdG2WT+>lol_dAs
z=VR;sW!&H5jj5i;+0lWm-&Yh-Vvh{@6wlzt{E>^o(SeU~?NgqZeeENF8bIY<%nr?@
zpb%WS0+ybbLVwverKWTOW;<yrSG`HQhssRQBTP5hbpD`k5uakV268~}^NALa{$^I|
ztK8~tDx7#RYItrSw1Nj&<q$om5}>(GO57}cSn5FCm}%x^*F_NI2`_aHc%x?dbwnk1
z0#4SJ(vq<C_Q@0UHj=yTDf8W;A%}6a+uwMaPV#gDbr%z#^E=f1bULe<V_IqK?dBp3
zQqWbq03LDo(IWg9y=gSkk}km&1f&NMc(kYvkqWjXi$f62r_MC`hMVMO)@v5jNBhy@
z8%E9q<3zM2uIFN7Q)nrKf<)VxL7=?`Kkp)+Or7<FZ$eE=FqRV(k<Jbb+s1>hLm63|
zE2h(7AQqv0BgxrAhGLS?F@^y8=+sp}I8wMJ=OeyjwXIrkP(UFAVwv7&=d1gO3h<4d
zyo#A1H{@ThhA%;0VMS6r6++&uh-0X7vf_o0wtn{scTp59VmQa(V_;gKXnXH+j3l_w
zo)1FgS*REszF-4dfj%lXNk>Ir_BotDkLz1y;-h|G9BzYK{E4Y<IPM=GZ)*k8n1Q>J
zY#Cb%3#j6$5t>bTUMBCFjA2P6js$&|heD^Rh!yzlvUwkSpPI0Ak<?j+WmjR`NuM7O
zxf>1Mq-tzR#h~PRFTiU>*WXdWi5tBi`kQ+2hYDG|d~Lx8DQx>zo*7`3`#=PrWp=wH
zJQEAJywPe`2kfGklNczF*LC!vQa=^HUBgZn;Cp%_yBIhB_Z2#S|29Fay!+aX+qrc!
z<PKvk-4HvmH+^UHanVyc2KVe^L#slP!972#hpj;HK_Q_AU>+L#1;_)RCH8fPm#_uG
zx7{5Hr20PTsdFUKAO~*S3RI?S-8T@0pX<390O8hF!d;&Edi!MbJ&o(7p#nsxDBxh#
zNB~G%zgw*eks%0{XP@|_0D}2^7&j5x$655viG8jH!7Lcz9@n)q&ey-DS9OdPM@kr8
zd%GbsC1Md4j&Tu><5L5U`pTEFsDGVMdmo5CEPLt~U&ijCX3Zc|QIrzx%!#3bIqjyp
zdfP%g8YV1yBQgDt5ovZ!Yu{TQAmVNj$}1s8iR7%Dbpdu`2&e>$cX2qM%TvEB4o;4(
zpJQHJldmYS8v)c63Y=1s75$DWx{9fCR8P2IPCn#fE$!0LzXzfHxO|#7m2qZ9@^4VM
zaT#vzID4Mge}AJe0ke^LQkCIRS84x3ZlMR*Sy*7!8;m{^KMc6{0xsjfUtvS1C*t*i
zSqGtj%Lg-n*TFsmaF?NO7jUEnu;NeaW;n)%E>i<qWdTh&ZZ$p5jf$=PA7~c~v0euc
z6OF-L5(rR3<Cn>4hu4p30d_gu-vE4DT>FjwUn0i;hQ)srkHT{P{3K99Oc)3{9Xo)-
zS!>LSF?9NNF{9^!9jGPr#e;77dUBrP{WyG<j-j~(L5GXp+g!D@tW@}4!JV=HaMwlu
z;;y}3x$6!jz@>lFUo>q$Eu(GaXVEX9=rglG@JnT^*m|h$Q*`OgFR#h7eP+=E=hx<V
z$9wYjOrZ9cOf2M4YgaU*Xr$m6<xFpgOYo_J&~>;kbN_b34D0LfE0u&)^71mGm3|f+
zW-}zKfE2e2n@zy56*;#2Irq_}DY`xQE@l7iq`b5(y-iCY=TXO6etU%jDaAWZk5z^t
zPJSY2_XlIT_DJV!=#wdtMn3&llI~O_aWsM;yc!b3aI_3#^f4W<#KT@&iBe92!us|w
zd}nFO`lJUg^t?oOfA^Oaq_5(A;^xa$Hc^HNg^kg2&r>a{{X}vFr#a)F&7Mb7<o3HQ
z-uJzj-&d9-@@Ko-ED6h?XzkxFO>*EiOI_a|1rzGRv61XjLf}(uBKfWxGRa8668Bw6
znHZ}Z7nD-F@bftehLz%0$pF<z)hf+VCsrfsj!y@8*4f==K47Q{$G7u{M_O{Wzl{5m
zm&mh?yDdc2{Zu>?zTByO?kh(ocA3;m(5$a-pe|y1S%WncJoDg?D=^=lb$aOp%8#gN
zw{j$&3$7qL$=m%`W3wP2t2*Kfo&LLbcz;603V7=J0P0-P@|7Wx!u660mNEfTG+pd2
z31I6vP}_4K`|*iptR<sThs5h&ZUn)q;Iuqbl>JZ9L;{IaO1IoyHDOQU^IH<PeI`7}
z!XUO+@fH5=;Z_=3rm3$-95*p`*LDGUhM|8w0rZvE7N|X?$$#W=yy%^l=GPMPw~BLv
z_bq_3uT9FY3~hpjq}D1p`K7T+y-*_ODT}5wY<F%PgR^Y+X;d{qu&C9~tcZcP!ur7p
zb7*Z%u6V`C=*&UU3&wQ>0ywDb8(niMTt~!RaW5?6cdkCk!l>dxPGcTq7$De->sK_J
zyK_mv<>fjtR5aHU|21!PbcBP}I=}hknZO(s9nm_9Qh-v0l7`O0miVg3%B|Pf`+%mx
z*Ey>1h0@Z)k#^N-4Zm7)=pJPNtXQ!x6%s<YkFoYsUpoJjbd|Pj*|N-U5%C8(_{(BY
zR&XA-zaelMOiXiPdfA-V7rbB*5{MO^))MvYn+F+1ywVftIXZQVlUO7hs9Uf}QRQ05
zkO^>9n56)?e_6r>KsGwwK8`)eB4la3$9x?6*!is!eZ^L*LhG1mraZJ+cHN6xDio`d
z)YU>H%f`*diu!S=qdHz^2&p8A@TuMcF7@yszZi05VQiS_D_~`ZjI`L`@fT~S(7$Wx
zVfMqPvl_tVE6ON=V9hE(akLxD^kwAYDO53o-;$J!w1yVMPP(g>nn=}d9d0w?jh}iA
zxd$(_2*|c5c>-ICSgvz#qRCnQ1FiJ`l*k;E{!fu1Z&AvBi40TDYD_jCu+Kyb7EYKk
zVY;BGE}-t{VMZ5leuQ=ZUn)Z`b#J%S4re%tlwN@ni;>Zx6CeJPoq|)P{mXu$)9?)T
zK(7=G>pLUp=#im{QwZT=5Hy`<i*yCgm4IE{3Ra*NnWXZM#83ml@GXGt8@)f<@6aSv
z&h*QNUjevKN`4g${@P0AeNO>HHbI^DPo)XuiFjsH4(sY{?{o&w8YhjgzABG!$QN$>
zx#{-8Y7fI-FaxA8p3Y!G-8$qdjK4=U**_qMI0qOr0<GR-Z1pP0(`3<z7rQds+gFF1
zG_We#87)eL4K5AVs%2O24H7Ra0(6;Zbdv}*SMUSEsf_J=1JTx4y?T5fHwIm8j|gcN
z8H_%e+C?sdN_$M0Wvu?!E`U%3&`A5UEvlM2(Uy&SMP){(dot!n5tfJ%ri4Ve+ow?b
zhER;fmj#huMMDDZj)ZI9@TeY=Xj?yZWVSE#800^(yOAXKY;;Hw%l+ypbe;X}<gu1%
z^k>hLL)2ihYq@mo7y~r8plD#YpDj-&SsF$`14>xZB?6Nz-EJpVw5)b>5b;*H6*c%q
zZn?|P{>Dk-8ebEn?CvT-63et~inKteZ_kHYb&G#HdE}@Ze7a|emULrn^5K}aIkg)r
zHAub4x26{ICKBFhJN<Kh%8Xf4Yxty}j1$z5<-p`rrlN(o!-0M5ckJ6qp88$nhJjC4
zBz0Qpa2dC}3ERTA9?9(EwcKTop9$QjU1rza60kllw@2`?9r(PiDb5wjey0VK1<Xf5
zgQGHNF}L1^j8%lH)yowuBD(!}z3~PJsy-S5@erur_w?&;wEy(0k<|)RJUkt=k1|5S
z40wwS`5#En^i_x!Mq-qA8TcK3x>kHiRRq9fl7C0;NAixoxL3a3M<ftzz*>FJ^0x?U
zY!9e{C$0lmIrENO9eoouzWqH-eMmd~U<)7ekIP--t?2(!G(KX&C|uAjPLQ;}E3Sp>
z7-lx3=(j(!r5nEXszZ9dy$ygK;CxL$V?Vi{Cp#!QAG##;wMWyM?4Xq9I|R#b(zrsY
zlad-hfx4CmpXE9%^7yokfdFN{NGX0*X7YD+66g!NlT2I#_3zrL<M9BzG-^-0v^?z_
zuA`BeI$C4w4y)}a_Ap>m;pN*T?eF35IyUrr7spTbPHlVs?lLnYOaW8W=0kK8WeFYc
z9#OkOn5|R4b}3uqX(jv8C_%3nNs!TOAdp4+7-s6-ikUFtrNTfrx-?tbCY<z4J+{13
zg1HdXARC2J%KZoiBKyB=U`aGB(=}AKpMF`_uk{)O*jOk>+cZDytB}Hsspx8>yK6f8
zBtnUL__)MZar5_MIsp*q^%_5sFS@mj=}RwZddOV4ah8tqtN=@Q!;2*+v2m@=+9z=<
z79VBCPCb5FcD#H8$(myN#illY?=alDhO_~{K4Pe0r!(xk!Za=TF!QPJi1qk$>R&&<
zal@*{#wZ>ZZ4_O6q+R7a=u1m%=aX$9(45h-$<gES+fevjgT6OHx-;e1hU6_DSKbB~
z<Ms7BTDug2N-IF(a%x|i9+IqJ*n4m^mD}JfYpv>DW%LIv&&aXxMh`&yqYgZdBoaLc
zmO2U$FMlNj#Bia?nlV{;UZGzWZ5fWy;&3c@Bp}ClnG=}h>CmRgqiCQK*sxfrw35d?
zUt5}1OS(>GwQca}vWR^asZ`GI-&s!nyIMQ7czbFA2Qzm=29sTRB}F3k-05@-gFN`g
z_jCX-Q|x1yUBH;g`w>%bvLV#8(g@%#zm3B{Z9J-QJE$BU`W%A^Lyaj^Etegek#+c{
z``$PHDeEWrJ=>{q*G9V{p;oac=gj7}Fp|kk6{hRetrzpVffcL-p}Q?(AoHq7W6Qw$
z{z+);`5C^epX*)R78XTDAN|yM-`OUeYPSS}wQuNFAKv6ys0(=%4*lf0?2J}~kfF7{
zvQ*9`VvtW{IU|5AZ7TnDD!w2Ci@!k@=iz3Ypanch@tUws^StEIW%vFT5Le;Af!1*m
zxP8&mIkry_-&4>%ZU+I57y%+GfO}Kk=r%ysOI=85I>_4A=XEd~GW|h(Ddcw}r|3N-
zII53M+g+=&KCbtrWX!J7GEk%iI)P^Y_*_EB5YTJ%<O%2PDpJE@$vJq{Onxjb8`|OU
z8pwV$jEnomplAt5R|BvA%Oog)kUby8$m51pxyP=-cqli1bVEgpM_Xw+IX^=jtzNDh
zLcDIAJH{%UO})J$(l>d&aXxH|`L!j*;*McIs2dSN$UiTfl#aEYi&e0zI1IU|KQ{Gl
z524yO1dBhMIZ%z!=+5*WyTeEFRW&FOb=i6c(X742GDsuh$mo%uji}Cr|Nff`&^lGs
z!BY>77v%7({eZM0gRt`Ki*{4jVDL+aR2Q^%4Im^6yxn4?@p#AfrmZdb>WZ~2G3jr{
z)u043r{*dEig~;0I)`0@d;Jq|sW&CCtO=O6wt%8iJT8ssfW<gyx1HD13J{daBbs03
z4cVGWPdoVE9CfP$m3hL28o9aSaqrV{i|m?i#%t?GQdc%CC$-?j>mzUi%80nA(!0wO
zmWF=DbZ#GURL0KtS{JJr-^qR0JF_Ss^F)Din7pbdcXsmECJ192ZiqlIy@t_)9XUYF
zGPq~8FuD>Sb1hsu&R@*?_I}&7B!7Yl6`*Uj7CaekWrc8JbW5y$O=&wP#^dsb6li53
z4*Rnj`An)HAtrixXr{W-YvjPQ0asp5TT#TA<|?73_kyaN{``)x)ne$nEGwoxTC9Yz
z!f^ea0g(i2OOR38S0XM2r1{Ov*nZnpo32W44wjhX2A{{CHqeCm-W@>tbu5Ra#`@?`
zowVkR-QYg%wDKjePhR#j9^FJJd`>EDR*<80S&;ef5Q=Lg`6E&I+<W5_k$(;F>Zl1f
zL?5G!tBoXOO#+4wyge69>re=6r%_c?{LMi>pPxv|h$QwNW~M9URlPI-Cw-s-sW+{J
zV3|HLVruH=)Cj&LVopv9i;kJMSR!qy{fl}%48Z+^p{&@?r&D7l=;9nKfJ>x0ZV7kL
z5Pa;36IEE-MqI<<>)e!0nWLprnpKwKmUYrU1ZZkxu+-hk%VQ4n^&bCyzYAtr34Zn>
z`iB6&HzZd>yIGhfyv7sMA9jzi;>H8<yA~ESLp1<f60e*MmC5ymv-^pO-N_zB78R0s
zcor;eV8D0#PufaY;S6GXTp1#K#+5Lm>n^upDOVQsg-2sqENm5{X}-P*{$MU2JY+?y
zjH1F#{?+PX3;92`(Jfme_{jt2KW{Y`bo|#mE~#YefnVbG^3L9l^UaKOwdC5Zt%au1
ztMV_)Gr~iOQM<&sI_T+9bgqF=c*v0%{WE$97r<`qK}by*I?^?)W1ARt(yr)J&u^UW
z+NQTRUh+Xfv~c)_CC@AFM91)l$&TJq&Sr0W8ET6uAVqdZ9o_o(MtP24?mqyC?;1uM
z*E3~JIV37*YKnNZgZEve#>@IHZu@J6&(&Zj`paLyrFQsP2qkE?2(Y2T<=TOqAj*MQ
z{tm!Ko`oWQVDnH&h^h#u<ld5qPzD2%Lf$|ge3EofyX25|)xIEo4w&(ti-JH!r-ODG
z`bGjf*K=%a@hck%q#k9O7U;+N>76#_MX$#R5NJJ}62DT+bU=-TBQB`YI-O^~34&>N
z@N^#g-o4imX|iJ<8*`ZVAM7N(hu}VTYdy>saTz=e30qkB-1bCJMwy^B>j}O=X)@pS
z(<(vZSIOsfz#%=}TML(UeBMCQMkV1iT6k|S7W^`JueHa`wn}%EMz>fF6zQ5!Yw128
zWEFcVJV#RYSHHmVxkQk#1=>3-(eG;XCB{>;LK+@d5_jR1c6Pr$?@=C?SX9b=_~2@e
z54e2vK3V-V8E{i0_i0?G2j~^OKn8X}wA}W+6<%fp81!Jlm-DN;PBvJ`@4L2AR5lQu
zJPD)oOZ<9t=dWx_=@P3l=voQY>sojAC?=p5cc|<b$-*li{9Ykh4*0b1dgU~ZjwFJ<
z@b2f|*I!UTj0*0GlK(;>iGd<3Q)TkCtDNS-_|a(`&?AZwdb1-e*6cKp`Z;xE)h3`O
zIGe0(FB)f!i)*4eO4k!<WvtV)eBKzJlSWpi6XFra#%)bbWrzV-n!L;6;xGvr>B~&Z
zker<r_r39cQ?1t^nZ(zf3h6yN1^0IFgYgbLV#wan<}{8TtU!HVnTygYLDF<G(jGZa
z%FHw)i+q1lW<4Vl{?@Ps$j1@f9DFRIKivSFPX$F;)lw#}p>;iu=<OLKUGoZSe@m$<
z5|p|1x{;L-Q%MxnlTgc7#~a;o>T9wTo?@R6f#O=Rq==rP_rz$~$n1T|y+v^y@j^2d
z8FDn;S$Pa=maqB3ZZV=yIE0J3@Oom@=^8*Qd%Oo1;0x|Z`aO0vyT~gd9gf;Ly=+x<
zKh5l8q5S5y#9V+X_qlb1(tv5}=Orjw4T+RQH$7wwA3g8{&Jqz3b5Z!31EU@=|M)<<
zt~pQtd<lu0qrY4vYPF!y=<4uJ=C(%@*)91xG<K^4v_drfqKN*7w&G!~hbhMb)GV|x
ztMVF{PNMu#>DaptC3k69)F2IWUD*fM601O?XUazCd*Fp=dVmdU?iw5&UGBOac<j53
zA_bp#qAo^I0vHY5LTuYqRKJbb+*k|kt{FZH1<{D*X0N5RE~ZidWQ;k&87R{q6}>nF
zljz$OTaw3-vJeZoVKQ*irx<ef8R@>u>;t~a_d0tI=@r!YMKcS?ZnDB2ZmuhnSxpi#
z7wPM`#`tb|!+(z?Jx3sY4<2p*BU!~z;2xq_ECcWYD~qgz)7b83SJp*Q*zaKVuz!40
zD2r~)qmwK%Ox68^ss1p?L0k3*;PQzGUi^fh>2=7I+P%}c2PIGgJLvUX2m{Aw$XeKE
zV%QT<#(6$e{1qQ@i`G$jbLz96{g&}RFY!L1w#We>r3MmZKi0ird`g^bysYCFOAI`<
z=e~)-D|golT#+~@EnbfttJY{d4yc;%J4QeageT$f$OeQYK`08*p50tZG|S~~D6(iD
zbUUWNeyB56YKevFLmaQdh}5DE7GTy_E?4Vc<mQibnAJ!e->G~^1_e=`qp$`-^D>f-
zB!au%YM?V~Kb)rZ^(ju5PZvjNeWl7gSTkab|7!Ip5gfO0=NS3VE1o+&Hs5g%*QVP~
zgX9$M<2P}2Mx|!XO<==Pm2^?T=Ud1a!{m>Rx9c+pnBqdMhJT2171z+4?($XH2rDHl
zJ4~N~JyDCfBgJarrO-3D03t-taPe;H_DJr|0}&7g0jP?@%;SPQOWG#atRybR;}CuQ
z3|m=c&v*~7O4~@%S!@`Y8B9D5Jn0FDF>QocVZvjJxsY1!Haz+lL}->lUv6AU_u4SV
zZbnQJj4$`rMF0L~eZC-_XeJ`g+j68MK3hAK$L67FB27Wb$6h>qw;PejW}M1CF7zAG
zjm2vgnY{gFPlxr^71?4YW?pGc?Br8r#)&ey^e+?R_Yl5-Osbz)!c{HbNO`LC@x>kv
zS+}KI_cY84$1(@~w1t%)Gu=@nYngBFv2L7f(vKpIHLtQ7)8WM#5taXpX7<f(af+r-
zPw1o^N919Wf*jXUB4@dBrD=u;;e-w8ntFtB#TNe@J;?c_?~jw{xz#Ymkz?Y+Qi(D4
zAS?jLqFK;jj(XW=MgzT1YltE;BGb%FuLEEfPSv0tIVWF1zaBM(_QzLqr&wmM0}G(k
z#8OQ`b!<N+SnQreLWhh!<v7<sVVz?^<5MkU)u=Jzn=8E5nFA9c-<fZe{e4SY*oSqw
z(;L;N*Q$@-m_BG<mb2o+>5cCYP6@_U-IzIFxX^&eVZtC2uK5x7>Y$Y=A}A1%vI*?o
z3?VH$Z(2%5))}AGS(%l)8@~&OSX+qeJ`0&6e=;(OQO}uvbNe?Gh@Owff5VJi_AVs5
z+Nk5b2Vy&+@?^h>_Z3-5fqSLyNp3zy$1$Pu6w9rn6Df`_PWm6Jy-%%00N4Ws|7Bfu
zONPqE1c6wKe&6JM{jB`Ss(o$XdB2kO4X?zB`mLiUiOV$~YwcH4Mo))BfPpP8)Pg$H
zg>r0fP#ZnyG^!fp%NTt12V8d{cr0mQw(Igjc38ogG<byEQDoN%)0V6q@slWx{yRvM
z6_5P7B3H|*I1IaO4n&kY0%sU7#@l~wl?q?S(oh$>(-==e@A1(W_TVc6NJ-ZVShfi2
z2DW&cP@;+A1sstV-O)ZbO713ddi$Dhik_MJ*`vCM(rrf)(4U@i@T)hBLfH^LFuW<N
zg*DDwcLhX>WT|24fYG#&yTaM4rmaG|DYpHtR=erRN}j-c4rL~hnB(qbaGTPok#vE{
z%0n4UJUUVax2*G_u}@hJ4u>0lMG?GmPrVYqTK`H=Ws-RqB3YF#gIa?-qtwLMGto@`
zO4M)rgd8;mExa8oYu4v0_d}#BA!J$9yskWi-(H}wrDyJUv8<_e3(5uhTvqEShKUb9
zDS@^Ged6&kH(C(6J35Z8O#IwP3-(%kX>3<p6;XuTk2j7D5ww`Q43@(O6KPKmn)_Gu
z``F=Tk0Az*LBhA|zEp5CV1YTH7up_k^j1IqBBc=F?t8nv`ddJGlz!x@;DUSYQXZK^
zG}aE{2EJX;-@B7|gUskdum9YN=g+V0pNR{_97o??y!7k=g0+Tm#PdCWWLUhLEMGYJ
z;f)8Y>erW7CnKdoL9%L2)&bw?DLS~_jnv0)HCM6E@uaXi`IJs+4yBh2Eix|?xl3Cp
zS&STFI}-->?^;t+vt?O`hz<K#PHtV&Qe+9WW~}3~ZR1G>o|sknh?%{4BSLo0d<v-@
zxJkYu{5~}PmLiuRc{7v$lfM?CI9lt^z(b}=-m|*fRbrph^9!r7TrZWO>s7no@L7G#
zBELq}&i?o%-TID?#_g-^WTurxX&tB+s6>gSiDo$C0@$+RV`CZZh1QH@>RTwg1!^0+
zHzYmyltYC@mf$X|U>FWI<v}15G=KY|h3A}U9lDPidZ1HOq}{jthl(0Y*@Grw0LTws
zYmHfkwxG3PP!?l)rpnmeoZ`+7xo$AL{Yp-*aZ?Z}+qU5k{fdSb$37xQujNQ1HXQJm
z$<ryVw?7dr6n!hYE>}neaEm{j<ee2nBGxG^Is|=9qa<3tkWj=KN=6aDcI3op&FIif
zKdv3XubZp0x5ayQ#`$#jQ+XIZ9xgc(70TB=(qGL5P?`;cX>5G~?$QIrC!WRyXoFsf
z%KSTHArWEGKlMOs`1J7`{>p)$H~eUd(kniKM|bq(v{ipI#er-NxDe2#^E~#2-dZI}
zq6*~+qk;Zx7rgDFU9BnyPEiSOY#D|sqy8N;(kt-g-5;V`BR@w0jRPW-smO!mx`9N5
zEf^8V(B<aVaK*9!hP`ge7c3;Rf|YKUL3Q?nT6R9Sb9b+8?92zy1STD!_e!>|{93tO
zmRZ!=`kVrC%4;alQ!;dup-juGU(s+C`IogT{1+un54Iqk$V2t9yxFZNGp~Ev0L_5j
zNHWOPQs0$Npz;t~#xHO9XcUT>Vk=k3Zp5w?xnXY}S|WCJUAEk#e==zL)UHiZ+ucWh
zkClsfslCJWO~}eHmhl(Hv!|((iWGU;Zr@4buxGsVAcKi-Dy@Sy2FQb$7Rb9=v24H8
zR<Fv24iuv2@GlXOBt4KZZ?1_;)B0LXDLlbaRAiXkX1BgA+wASpIx@e4@0)k|s?pht
z-d<hpCFwiNpmb@fot)CZu@LWxK*%%tJ~<Lnl?~CF=G)l6ZrRU6=d%%++ymHEu~)os
z23J=y38#=Z{T34gWVxp>7}lA6gSR+49;XFDWK0rIazC1cz=L4%*%)3d6lK03_DDL@
zqHg`>fTN$N;xj+}a>j7|mslW4z0Ej6k0E@d@$mBK^B?MOJIo3{L+X<`8z|hGKnD-f
zm*KBl?HDU{k8(L1Go!;U*8P~+Cw+*`s&TY$8nK;m8|Y#4pJS%?UmeDX2HA6U=n;JG
zsZ#gsple;SXf1yBjPq_uXkA@(G;j0_1|mO!^gi2}c<6&9JjVAwZx7ijsicT@g9X7h
zLXPtznlKwR9#CsZ`#_yp<pMUA_bL}=R`KVU4@9TKnj}Jbbs(eY2p=Z%T(jDRsBpis
zaFaiEl1f5wHM3H#Y4&;HkZ<<WF7|cRUI_JjB`vY+W|_%sMZ%%v6zH0a=}8;f#_fma
z5n(WQqK9VBCc<iwGu`psDiK$yCkjxje&6%iT_zD!6Y7{A?+-FeGm0`9agflSc;7zt
zhdp}KC%4!Z3kx?1xj;x!*bjqZvdDFD-n<tl11?3_OBg6Nl97?^(h@7~>2Fv3T~E*u
zZ4bZ(@CjX#OLVywf>XYJivh!hF4F;gPY{5x-_BS^#z7B}PmW4>xtbIY!A@>*?^7Sl
z-=E~pzb?o6|5$#b<<E}-wZF0U+4;%XzeopA;(6P~Sk5Ww6P+v;d0+W9jT7q#R;oih
z_^neBF#qRE*YKPbXNR(-r3s=&4%{UTOc?QP3VfDJJgFjUy|}uJiO-v~95mj{zs@ay
zUt81!9_j=hc>vyM&G$sYFwC@+Obw}cSMc-qI~^NODbL!j0ffSKDy~5^lB=MtqHwX_
zv+CuqlgBt{Be=bZ{Hnf5`08e}K-Z9s|L)<}dFbqh2d3-u!1;Q;Ko}ap>jOadMi&SJ
zmr-O}1{C`L7W5FY@PKGQn57SGKO=ii6JT#Zv3w`<MP>v_2Y{{V9knZgg5!MKK=sy%
zu~Ka&<_aq_P>V-du&`-9KN6JCZolxtC23?7-r}ABELKjN{DDrVaN@3UaB_`<qo;1f
zHgt}n=R60i{Rx4h`5jz|Zz@ezK^`0=qQe3ykL9MKHoiwAA8C}gksBg8UEOU`%OfJN
z##=mBa=0^VOYD>hR1YdBg0Fu$i{@n}Wm%_6@B7pbP5w(*<^A??#YVcs0*tr%M4X1E
zB6~K{N0ijH1l^k_bbi3wLNN+-RUVc-9V3D-7NOIwKgP8!-WZg}CakM}@g2Y<q7W#5
z-oiXC*{)FjQOI=u(?wta=vBTWzB{ComVB{#VU=1Iui@ju7Jh^-WFVD}X<>=6;pGLN
zJ+BzHY+R!gtV-lb|LPdRB%nqwo(ePj0}_LSZ&4m3u9+y-%IwZrUr^N-A~w(|fU{*E
zqz>>x(pY1Cu)ecI_)Cd?|99u?T|#>la~2>GG44lM=#4$6&@Ljmu2hGt>ZoK)nc<&%
zYurX31UB%an<w0Co{(ea@#T61w`ehW>6y|Kds<3q3ni<u=ayMOA6)~QQI2Z=YI6>f
zt|d8Dn$fFxjLG@R0sVBY2i(~;F7;L1=5(ymBe@e!-Qz3sw}wH?W!wvy8Pwuo1Ux#F
zh!)LjZ^+fwK>ZRCVI}=0D#XIDIeh6o+?EL-0~U>t)#ECM6xfLn&K8x$|J}1|T#bk#
z3d2j=BaU7Eo0&PMRkoVhsp|7<l22SiA9aW@4>CE`tN^mJt{vBH01-jVt$qx959Aw>
zW>vQ#Nv=I;U=j1Vu~AyJ?$0&ok{7<i74q|D2nM_Xt&IZmmEf4!a!MB9T^54cP&_Am
z=k^VtpFf3&-VhyHP7@&QrX#YLP+-d9XTx+9J@=RodAlUBYe!wRp0VyK#8t58g%OJL
zfetsQxN}o*NV{BsQkqR`&W~DJ=o8tVe}w&lN@PH#!Yg4e8CC=9`h2?;b}lQQu46td
ziw6K6?F0Qk;62<m@Nt~ZNQehyAmyHm2ahaTlp=$(^!QBlE57a{_o4jscItGHn(cKP
zyyCww316@eQd4kWx4^Tb%zanpQr<1zX+ik_;eEEKjxewY-K~1br<1ZX!%i;T(O(Qs
z3h&@v$nV&W&rRtAheUkf(5mRBt~$~uSkQPsX<Pl5%Yl<e6&6{z5_w}OlH{gmVlvq*
z0Y6w__qH>^=XQeb!(tIG{z$xIT+~1qX<#+-2IaLv@BEi53ow_9NQ3AJ8-nL?W!K1q
zmIx6;!Yn;(VXbX;1pf>R%)(gIx3J>^2U};#@*^z9FtkVw<2p5?-<9e&S?^}OCi0w9
zUkLf2Fm1;JZrA*k@mYVR90!`8k+x!P#%aLxJvj?$Cx8L$&XY%y4!rjfpSEn?cM5Ed
zaOKpAIPFWTp)rPa{EJgJg2G)gxY96<tmd&(ASlva8h>E4r|h<i{TSI-u$kF+r1%{F
zZ?}v67uB=c!+fd^g0UBqP4Eg;CEI>~sP=HrrGJq;U~h|F6H;l5!%6mjHS{H)RK0HI
z@m~z=U_c0;GU*+cDd^bqZLsy>&zoY#c1b)@4{A(dVp?`V@l$>^^1#)Al?5ag28hG5
zCARZ>UWTJQj06$sq$s*X<`pRiMs2%uTKeY=?dk?p$r1A7nK!9^caY_E*Z{=U%Vl{K
zRPaBhD|wDR{TUxs6)$yk2JW9&7Vam17d2_zUsqwio*V=hzS`teN@vYbzqjVlpGY*k
z6GqCM3Ck)CH^~jcr#MEHZbHZH@^Z>b*QWHRX?mG^oY1E<LC2bbMzu7i+p(8Na8J0^
z8{y90SO8!xyVcdk)P?J)GB~MX(twaC&-*U_3m)~a1>qdMcgg7lz@22pE|F2>K#LDC
zq4tZ1Qs17IElJ%Y2Z9@eu|*#u*b^~%z^U}a$j7(aY=u)r4R`eFWe(ewOO#`B$p^{;
zK~LybSYXa4oP&IqmCHT)G#$r{?zf;g$cN|suY56u6D0So)!(Gq1PVrTlZV%$Ur8W(
zA9Y6fH}mNs6x2>X2ufmv@H-ZJT(mQ))&kVnGA%swOBf%yv5$Z7HL;KT-oFw+*xcMx
zkEPAC3{n@8=`fSo=#{Vd;{7n`^}oz@eANxoeWNvwKIGP`Io_*_%{$4o%MsxzZ~hrm
zJUy`1=|c9>^}2rR@V8~*6=tjT&a51+FY_&w=EU!wM~*szfgdZorx`Km!1nuh$6QF+
zX_wP)IqfH8c+|UKOA}ia9cEMAy+Z)6E<0MgA%Qrkl>+?Y?$De~y;^B)Oo5P9sT{u^
zUy0W6lmgOj!IuWbSF0rxta?g*750mM^=}8RN(AOAp`pW`o1*N>q#rQeI`SbNvnq(C
z7(!?_PNRLelL!&?Ns0g3`MDQR6Dsk}g~t+Q_S&T1NaFX$PTdKlKsxA!u=@h?tVNwY
zog^n%q2tqOqikp>(2C5PAcxVVixU?UCJWqU23lQ92&)U!I+FU~IZZ9z2-o2@$nNsE
z!+>KcApL@gZ=O%Lo*u|%(aK9UH@o*KvSFAoJ6EUgF4gHXFaRwLnA02Ovk*DDHTCM-
zs4W@_UlcRVB1qIo8I8_>NumULd|-{T^}GFokyV;Q!RVO810ocfee)$mwuoFXaQDsl
zoq_(+JcE@tK%7NSWp$n~fZu~uEnrrGvMV1x`dv_D^AWT46}rh63dHHRRw!nvHZ!}}
zN}-4E(dMR!AyZ@`oC`ZR*MCUN{~Wx5<7I8h_=2dEpTj)9mVkvV12kM%aKxH!Sh+s)
z<yKKmz!uZ;gH%vjR8z5!vcAt?vhbz6wS)Kfv{&y~@k`yQCQY#e&n2qQ4%$%<Lz`*I
z?hk%2b=op^C<DA?5VA^hTtzIhsxO=XUWco~liZO+*=FT~VLeGy>V8Pk?s#dm*tkC8
zQUa|KvgeTOfT<_ikMRj0|A`hI5?(OfgOMBjqH>z4te~>2BhiDkW^NP-+$_sFT)ybq
zfpswZ9}>`P4=F`6iYkwlaf=wkbh2Y>;l%J&a&&b14?2A+q6HKVA>wo4N%n$DNx=Pr
zEC5!-u5QmWqH_RAD_hqCYo5gG%4coHji{4~KH{o2L<2z=khZ7?@>8cfw|x_QOF>cI
zgHzoZt4TF>!r0C0k}c2SjVopS171Y5Xf&{?_YyiXgl>JaMR<3vXl`ZSsg3=w?I@g^
zcqwElKm8qPb2DV${`|2k)M4=$t-!}|{|?)huJb~HOvo2e$%EX(J^6SxMf8V_aNBnZ
z^WBu=^SQI<9~6Ak)xKhK9W5cO53aN$|LB5VMwh(>dY#heG74NqBFTw6spYH4KMO`q
zq<U_oi@C2Hla02W2}H!%4tyVi4~vl5N%J1nnyM$W!XA>MZvWA-UzDn{RkR|aMWBlC
z38*3dZyr$!{u}UFaOD2H63Yx7Ckr3TvJLu$FZgw6UpJ~t2%+#j2+EhIu6+HorNe-7
zaBVg8$H5<ylqKX5#3w|O*#ZaL#k`|S7Uu0YnT9WEp00}S{rDp|NN4~NK~TPUXyGwo
z-fAKyBsZ}x6i_3r!&%iJhxEnpjlT5YcgyH$=B!%fq7EI6RVlzOR$>{(AzXMB29^a5
zOthr$V^mvgl;5mLl~vC>l#sQD83mYBRX2;`y;CfbU$SxBXh%`)r@0bA>?g-3##{`Z
zpK-B@udy!|zD0P~ICpc6m7YU=%mG(%cjgd02Yh2v0aTARDisC4Pj`Gtb?vM|jBw&9
zr%!uqNLILMa99SXyAcP}=+0gYAl)E4xFEZaK^h4k4Q-Hb*0<@vJm2YDq9wh=Fzh_0
zr$02eLei9JTWh5Hx&S}yyYS$R`KIeoHXS{@2(OwV04ibtwuf=iot-?L7MBsYb^);!
z8i87qw9LJ%eu~4-6g#XPy?9;tq3G>yf+N{Wo^YMqRdd{wKX+T^XsDHpEi60<seB+9
zEDCQ~uY@4GwiWyu2sWwSx8-6bYuj|7&+9?`G(&+jU4Au}7gqvlU<b}3yJI6Y`;!YI
zCtrI1O#SQ)qeiIM^8<zO5J)MYC!FZVZ2=m@#$MxeYv-WhAqI03qW0^ID%7)niNkxC
zP#-jsY1H{Q58ux%j9;vjyX_unLyUP<Ex5I{1u|iv-$CC*?{`D%p9l^OdZ7yyH)7kc
z=LzaxNB4VFNpuYB&JA@=?Ju)D9e5Jfyg^Q^BS%(L*;quHspLNBZhlhQtaoDr+}n@A
zVP#hpCl;J>tSFhLbXPn0-XRy;c2IP^OD1)g{k9UzXt~h%QnmECOF)T|-+A*;j7az(
zHs@>^f`AOho5Zb$w6BD##&8m)vji^sKep^89`r+_eo<gPjay-FmX86O#<o;B4VG62
zH+lw6v{1#x?5N)DT)e?W(~40p;39LSmDkcIG7-f(L3*@bCaU1KjjM18z0MPPUzTS}
zXyZP;r>!p&na;$JuAiy7zlT92l}yblbQ>h8=7Br|UO*6SahqKW!72=r&TSDp$F{Pa
zlt2770sk;Xj`)-=N-1O_>VXt%j<pIX$5Cm^+z32|rX$X~{zSIpoBfj46D3IL5Ce0@
z7X{yA>Ux6vaTz|BlciiQ#Qod|<NnHFVhWlLB$P1iYCew{CT2(pHgvfJ@-Lad9bz2a
zR4KO*dU^WjJ-K_F%rGv_Wrur*&os#Bk$c^NpbOVdaouuk`aiG^`jl~jqL<Cdv2ifg
zdyMJK;{kG$EQzH}oHmEr3{^I7ZExR?M*D-jhS|EIpWU0;j`f6#8$c}@I|^a;{uN*F
z=rdGwyU9@A&PXR(iW%8T!7nFd=O-cfX6;1{RcS9Bi+kz2d}DTmVDD?JG9h6Yo*X9h
zYZ{AqjIOTv2De-ye-!cru5I^>4S0L+;fSt^1T~l{+=H_hGz*50&dzUmq9@L!rv*PR
z+@bWIZ^@@QRxFMRe<5{T$gyevG@ylYdfvq0g}xaA9qBQ&N89^Nx#`<(^|yN&+#X*2
zwR~YsRD$u#`!<ZW%~&(v8Y8Y&i0Vbvj5lwGH_IH>W(v(ifCl}t(dputNfY6XoG0+p
z*7Jg3)keInVza1oD+;$!y9U+6oI;&~QI_rXuhAJ#4gn`R(eYqTzn?eXeWzP1+FMm{
z<+@6)KirWwMa;ASu3~%x=P+(Cn!8mJTd(sbqNgY+i=A7muQ|Xd0*ww~Hubw}1u^!=
z>QzQpcgFK^BPo-{9ii&{_34KX6mAS(DtQd@25VS3WM;nX?ar*J+9+)sP@Ohx-Fqat
zFt4oMheXVGZp?LG4OEb^Z>yJ&%cUO!r~U40+^idzvrr2`MbLlyC|CUlyA2*GH@5gy
zoIL8pVA@7sLRLVHe*+Lcrwa&P=q32Pkkn~RUza+>nYKwC{93F3c=rapDt0a+%iy1|
zmFUC&b6}HZt&4j8j+-MNXG9rb9XHJ$zVi3BQc*uQkMbj97#;f<Lq>e%b1rHc7lJY-
zbi2}=Liy1Wy^ZqIsHjh){iPW>dvPzIvUORPQ7qJxN}jLrJ@ae0C48zmsyG$?;I50~
zk;lL;pP|`Hl}g{k%)DUa4V=){^QE)t@!x^xPas%JzlUIr=QqhjMs@9saJu)QHEw=*
zdGDjxZ6UdDpp2(zsb?SKy0_>~i6nn+4Y8}xQLZD@#7fu3^pR4WqQ*B-i<$v8^W=rn
zZYSYjLG0uZgD6EO<hz3tGZVf5>93edT}?*5$~!wpTAPo;KV=qCDEu%>+tRwQ+IcJm
z8D{L4`sTd|Gc6V%G6@*RHEFS<?Jt;R6DarHo|q^nIqJq16!j-Zt23F0Yu9|CfsFcF
z^pE73%5-uCyEUQ81E8qW=UxdW)})Ny$DdRuL%6gw+AljRB7XwWJAY1swny^La^3e1
zi4Jq?(k0nhx-;<ZZEtq7`b|a-ATo<=*rraoq{-cn<M@8(ejt|!qopC*%;IsS6je0;
z%2`EHbuNCw$3+L8*DQu|_+K+N5M268MWkJ_l_seep#TNHrhsW1ZG!@D(@JTiFPKVH
zVJ7?Iw4p6X+Xn};hAW*fPhSY@QLM29@Sn~F!3tm9{U!VGV%A0V=quV~>N`y1Vn(3&
zqtK{)2pX%4m|ugQWZSrB>BGgEi2h8P2!e;pF$1wI_0Xtc%sAe->^^LuI;+FZfMh=S
zK`WBIR0(8wPRt3~RBovJ2XNu~TY*9~{jVFr5@X~GIPsjuFm4K)u`*a6-ZhC?Rw{>%
z3sb1BumbMCczyYg5BY!J1GQBFpp|<5hz3w&^_D=u1dvjuv#A|r{$8mg#+9pou)-`5
z0j&2!q&V<gbwy1y&MVbNF;el*fQKxb%H&O<6@zy;V1?=nZR?kvLelL%sg@@l?RF&r
zqRky-e14ppV7+3+wr<C259AMgdx}9}x1&j|VSFhn7B&g8IJai#;u8oQin~8YObe`W
z`y}|65I5ekvU0#MBH3ZBxG4~e<+(ZOwoi2Z@{E5I-<$|PBZI;O(P}a>a{}p*VjXt)
z1#DfTy4@#yV`DORZv-%mf(;8Opl-0Mv9;u$p>@{f7h_7UuVleUHx>2LJ3FlD5_@&G
z%xRgC3EaOL;#ME>!Y6Kfun0L%Y;w=1*cOeJdNS)%W`7k|r4{;A!ka22o{q%pJYGC-
z4K-T#FSP`xy4Rg8JOq71gTR@$sB-(?DG)ivieCs#hz`LtRD{LyF5;7Du1O)@tmday
zY=P}Q>D{^H6!*L9B$>)<=UamM`rl06u1PMc)QkRpLxF+>DI0R}xS8TWR&;RrcEe{N
zxFJ_kGPJSolXfQftNBlTl#Ns3FEh`|pu=s#wQce?!*bJNCd{~?BT1S+midnMTw!EH
z>)Id2w#J;P@mGJg4*W5QJq`%;LO42-ZFn$7dRZx@rQDnq#k8c_f*pkK5IOpHkChL>
za}rQA`RKZSF6aJY<b+jh<E{BXc|7(xMyOiEBUEZ!jzFLUdTEW%Z$;E;$?q+H{`KG-
z9J3tpcu;v0rZ4#`apOQ(jIwMlZiWf)WbS*YnxQwVFinO$mYx_RwA6a{f`d0&e<($B
zTySN*<jhkGrli2p(<=T?(D%O&<||IOG@`zK|F*rJT{3fpk$)UqmJS-yfIdRjjUA?B
zDJF0u5g|)<P6;p=x;q=@SX~IXY_q$V%zSU&h?AxM+1d|fz#Lw#=^#f#nyWgH)_?qc
zUQhO`a|V_<ijo3I3YT>Ee$~B1(1^Z^_Tc@Kec*}yZji~ooKB00R*$HDHStYJ=J-f8
zP<+(bn!(>j3uOpnf41QY;7!s*g(tq#zgP~zMY3W{k0c^ezdiQ;@~f3%Qj5yOg(sBb
zdcJ@15R~pWP0ttZq9FIUDue&l67FuH*h8x07Okr@xrw|KK5K((=v711!do_s$VKMl
z;^6{bbpCd0Ul1nW_HC#alhU5x^hz1do1iHNPXtq{p?!GR_)CWI#e4XRMZx!!VEI7I
z21PAuz|-kADWz>fg?zzI0>{v8bwnm<?~UG>fp5Ub)NB5$i?(k?q--;R?N4te7j2JZ
zb7XfS|JS_dsCb15h)}c%m{gqA7_0l3R(R=174G<?C!M0CDkF1D#H(N^do6kSh>>$x
z8RX*fR$oZv*6X{t>$kqhj$*}y-&$%chhxLSq3tW|#v+z*Fp*-&lPrNpHNGm~et14(
zp7h^#N&i<P<v)?z;RJ#yCx+@LX7<|EWfu%T&auXv#&Qqn3;35MkvQv&e_Km^r{hGd
zlB3%}g|UptS1j4|5qIG%sq#x=;IU%@mwt3EJx^@+R@L+2ZkIWjIFZJ8<jzuwJgjZS
zW<pg>j$9A>=|)MF8W+<fAtVDxdhjk)3DR7?Vm)#8lxH)YZH?*pu$z~LX>;{qMiOw!
zw7H5E_m}*jTk;xv$J;76%&Lm)v$>|?Q06-y+BqwyDq+0S8lTWJMQ6OFH<@Wv<HK*#
zB5o(Q!h-Tw!;W}IdZR`s@@xM}WujAYV3`r`9MN5fz+u9s3BDcY!YlZm>413|xx|!Y
zt*Dk{_d@j8wqu76vriY5VL89?3|~`b|L~fI!RO<e1hv97fTbtp5p3<YRGDVR4zG;n
zO}tv{C|?e0;9!modp{2YqZw<E*Gw2&0}r-H=S#0yT>U72Z)^_3rANX^aQxs(I9QF8
zZw-;jjr<swb$064*-1u@1iV&-g?^gEpz1USMjp8K(#6~L(d{0dbx@&lQy!eSPaI9U
zX(o^nI9VLm30b`(EgaixUNonysZNMOW#_*@zr{J_F@Sn{^w4YA`yWEmEzqXqDO~f5
z&&gNZMcGC5dg5d=iTpK-gLP}eyyEU%x3*ui&<4NENc)N)2hUO_>|9{`<zKKn6qkH(
zcA27sU)n~<Q>OTS#h#)m;`x1NI05>oDI!S;?+f3Ooba;nMaQkYyJ~OJprl5P&Vx;w
zN;Gly?8-=Em6at6aH+HGrR)Cxf9Oh}z~GzFEumIcm67zIFkewBpv4T@yMcpfYEmQW
z6#^44vX2SQL6MLjY|cOGV^`Ac$)+sgc_#prUw@{>j53dcvUQNibnA37fy1~6Nlu(1
zaED%%&%Qb;v>z1F9}La~uV{0x)-VvQtas^C>2j^&EZ4ss2Z|2-&c|ylOK(%b>oLp~
ze{TG|Q}9v*a)5$pxZSG5sC_mM@u7S_mrm21tR6&dZnJ~B2{=+tq@2|wbH97y0e3~o
zrf2~3H>YnXuDjQ2y@$y2I?u`zBNbxe05yzYGaxM7MeWUdcu_X3CGK<hEQKvpW;Reh
zyiW5HrB_gb_hIEk0ey}BExZMV!6Wi;)2~o$4sCx`{Mb$2oLIm*#Lw*td5#d})9V5}
zAuZWt>e53Zl?8r7%|vx9@pfCdcdh>_r2BqBL9o6zHH5kUS#kZp;r(>_Z3UH2La!L6
z4<GgAAPDBK3JUu@c#4E)ULS%!EBd-qEcd;C@d7Ub>n9g0o}oTob`BB&Cx3=j)~ssB
z5kfJB2>nsFN`iu26X@rRS-MNx%FmL3CXIp0KkO~B*s>NkTvXfiLnL!e5-Wkq-AaIY
zx0K_0o83=5F^#X|k<=V<*hv>}<VWAK=QALTiqa8UXCQxrW=*X;;c0@;hgva%9x~Dy
zmF>bgit$HQkObyI`}_^_-CAx0)^m)HIrmm{!qL>m<8W1SyRj$3UG{zQqhe6O<bqV{
zWKRkIfRgu+SMCgx5B_P<*I9bvP%FA$X}6z$h)6J0+p?Wf>2Sn27WBmlrQ4~zx+I8D
z`CHZmXnD{+<l`pg(K-I<TNdQ@0i@e4K&I^Y$gKE^APuG2x^}R)4Fln1-W!}P6DAyV
zbsG9mk(Q1-ABZm|>`0J2d%+%C0(|V1*3#gL3VFvqrq%>CO}6iVFIs^A&FD^)yHcFS
z0(fGcnrwMR-c>tIao}#f=Yh?_Ywh>%23r3oR2vq6`mn@}0-^ymp99|FCn9j8UTs5V
zhd2fTYEd{W2T6EQ_#ggp{2(H;q5+iJB3^VR$tN)S2L?Wzfn<gDaM_@4Mh%UIeWoxe
zekV^t;wA$Y$KOa;K&wRAEX#3Ah`*a>>(I<#?5wY%C0QghfbH+zW&YdKULdT>AH6}C
z_C4c(VYSbnX<lf>fMt#CI#v8Kb|Hh0^V}~nYf+LF*3?@Dqu2M3hd`K{q~gU0E#Sz}
zbL~0^CxS61EnQleRD5U&0f|h!8t(bv&E(-$3}TD8>wy*j!6>5mgJe)9+^MGkIS9O4
zi=v`c%|!GXXmZymvtzk;G9hMa<S|uD0QH;tZteGanosLqna#_Ermfng|9!Uq(@s<G
zpH8#&8JYIX)5F)~k_~!CeYulQ=h8tYRlkxA2LT?5CUg5|E`j))ZD+^iX<yKRR@-!d
zns7i(M+_VY2A7YAt-Fpaz{Wndq&W=A7XdcO;eDsPl#AtRi{q^6mUAxMF%uYEojl<k
zv%zmD`^<JA_ImWQ#QRTrZE2A+7o50XUEr<X4@woyERAi{G-oF|UAi3UEg2RciF?SN
ziG!(zEOBl52Kq>-BE)nZ&Uv<yKI1J3d?Y*fqV@SX%1K%3U#bxb-J(0^pG&!q8c&Xp
zy_;iEJj*G+@+P*=QQ3C4^2B#K?-Q_OF`uNwbC`t=xFvbyQ#XHP7;|I~V>sU-Z4`j~
zSvC@1<vhCoGVwKq0gJ=jAHH+P9GB-e=X-m@|3TSbMz!5V-@<4D!68_&LZC>Y6m6kM
zkRU}`tcpv4V#Oi21-BwC#VtUQ7I$|jP+W>Tgg|i*{-)>L^Woe(#(kgvM?Ph+_iyht
z_gr($X>(t^<M*?Vzl$0>V;lnZMpghF@L*TH2URBnTY7twn)@vEfZsJ=BPj&z)ES}?
zQSedOhPgaFcrL;zw}XUrA%~H#YV&%Y5ej4cVN}aWEYoTi{LBygy}RrE11h#NW3%f2
z!>|9H|C;8%SCetmd<MWnU}XmURzCzU4(ifi8yQHgtpl*|k0&p8`fQ=G-rL2h%NfbD
zcKJH#n!{T0k*-N3d(}77Sz8H}{-@*pnW`U0E}KPUCH)Ir-ry~g;<2qzm|Nsg9C*ag
zA!@)2tl>p~Dza-RDN<586f)n>ISC^N@G(RkiPo#Hi$d@2-%fW)2rjXR4YVN!a~@Rs
zCXEz{9;(Wk->@#vfRc#E3Np{GAsImg`J@QfgAUY3`?L=nA(#_Ms&c`vK)L>f$G__h
z)+5b!z`)HgzzCDw1F8?+nFMx*?rG}&>9#TpRViAWhTfMVOoLg(p2eIgr;mTq0t}SO
zM->a5^)rSEM5O(<nKkb5S^Ek;PyGMf5gAHAJY=R4UsU1$v?L&jB^z<@L5r}&{gVnw
zaW|@`XBXZMUr^Zh$Sb^|1e`C*pyT6XLJ&?5fsCKuR*FK+%TnA(AIM>a2oBUKfSEFj
zI$OO<G>dbAus}qnJp2PdztVSLYW7J8ilJ<pL+IkZ`cx1L(Y+Yz*;dth{Oe~coficy
zoby$46ZTFs?><h0$IDHb25-&&+8&8^GwayL`G<>%i|*2Q3(*LZG2qktaE-H6+f*>1
ztd)c#v)y83%20q^mv)y3CZxe4MN<|Qt#NEvn1o#t!Q3JW5=o|K`H-*joSj1fqG?PG
zZ6vjNZ5E|2qbJlsXBBAw9(g58Tv?LqffcZ4IvA4CjY=+aZVYs7jN&)mR8N$rJHe-=
z@coun>fDSoQu@|lP!GEdi=24(5WcB3H8t=5UwRP#_m%zc#uuZRCYM&JkHO6(BP<4-
zINCArsnEDr6Q?l&)EfRAHPifdA#A(<Y6{U9ax68m9**Ih|IUaKB3g|GEWXC){2|3c
zRg3Q+;?HUHmWA4vLs?SY^6n`rB_!ow#rvHRwKSVwC?#j2n!-Iq#;YTGx^y^JZ@EmO
zNcm!jjV9&;=SG0rE2ZKjS!ts#*OF+bW?S3$o$k(UK+QKHQU`JX%NQUwMbNqsD&B<v
zj2Pg`P<z{r@7Ajj?2HR?1AOk+1Wd~QTL93%1)#3UuKD-Z|Ia`9|F4iO3qN*915^bv
zCHJodcA_}%6h?-h21ESA<c##F$S#FjcB+=)5-U-`eHrzm`3xI~p$Sc<Jm-<9*_Q%#
zf3COBFCCuN_pEdwrzAu|=f>;Q{`Fbb?uk(XF6E&za~s1>Z83#rX`g#|b_187Pn4@(
zAU)Df`dUK(6|%}){^p&KRBR^$ZQRCzl+=~}DXjz?zMB2?-d&%y@wU^fa#r|dRYl%w
zi5>d2)6QjMTvfPyLh2>h*|;e1VbZ~C=yB(B#%gE!50f!MOt%%dikHc7&X&F@LaCzA
znHJ8JAGLjk8&WuJHMmt+mvdjSroEf?p4+)Cq7E8mHd>7jcAWmt!{k{{`Ykn8rf2$C
zwKxbD{$>wGj?@{vQKM{c(e5iF0z+XE-8VY?AE?*}fCk8`qn;|-2R$xprt(K(^)G;%
zapQ(6nt1R0MOCn8e5q*nNAc_b*%rvqh)EGMaRGME@Kz%8mJg{vaklL^H1O5wOl+PL
zipAl^{g^AtmNiv#n+W~krkTX~+5E@vQ$7+q*RKzqFNog6v2Tw`R!)7=GtOY9VE?dC
zEZUp9i_|UFz1V_b>n|XU9>BM%H-aXNsFrv-&DdR3HToL2_c6eBTaIb+>(&Wy<ZLqT
z?+Y>|@QkZV@D)UTqo)kg37{T~hC6Ic07k%a{ru!j{*UAitvINj3_RT0*s;tq_>I(l
z^nvHCLj9y%B3ZeBQQm@uUkTu3W+`MA2U|SEAXuKl2U-(2Dfd7ABnRLAD<v8a0zNo_
zpSq3w`1O+P^Z)Szm{F)1K%J6ED#gx(q$;eq=6u$5#mz{f6Jlu!lzAGhIfIYvhK#Q`
zQDvX$Y&8^v8=~-M|3I5S$no0;4b}L}Ql3F?ew=LB3fg{od=NmKCI;Ypw?p_X-LmU@
z+`%;76rjpAKz=K9XNNxP*<p`0M=mf-2}RnzTF!pdjxp~8%&eJRCB6_H{oJ`LM8w4=
z?R?n>XYbhxN33K!dW&47qF(Rx^s}dK9LD{)dnKbIoT9v_7_}1PBS&5-G&ExFh;=FK
zj;;}1(*v9!L;ZX3ERv)Q)O&%mD|uH{0?}b&u;IMeFn0>L@MzZY@uDk!un8W@oM5nI
z_uA&WXH%?&eKF36g?*}3)IV|({tstu&GYN>{Ey3ZWog?X&WJIHs?xzr{$7a&oh7;P
zreLx-*JXMh3WqPkbrWFFZ`=Mt1nTQc)Z!jAG+Z@xPkHFY<&aa1t8V{|9eKJUH6Qf(
z6@405X*B2U$;JlfZ`9Guk_>kHmua|>0O4To1wfUU7S_*i)=ueFId!>WDu!ZNin!b_
z=~APJneYDc%({KTxdOepu&(Ky*sCoc<GkBaGDJcE(VLjx;&=dI0c8g)#wW%px9aM?
z@PLNJHip_g41JjumcA<)L37q*ygPHa5tW9$``ASbMP6b*G<6y5A=Hq8^Bp}QKDfo_
zcbD`9$rEAp5w&_)uaK2)O*%f0Y3ZoA&d$YQSxmERm%J=U%C64+%5rJ#NI?cWA6Ja<
ztPIEB=W5)@IC?(2ikO2S1Y+gd)}9mYv@h5qU)g81C(?51R#T6z@zOpX<^;Pp88UML
zF$;*&x#x`wvgI@KmHB#yyms%4EB{~nD*p=}H_iO-(~rL##j$*ZA(S}B`W}VMv1D8Q
zBx$ybbZ(Fvr}P}z&VK!yFd$@P;@*5a;G(X@tmN+lz#xl0r%;dNWjYqDKy~AZ=k@8h
zUM=jqe(6WOD#a>gqVkL1;$_JDQxhQh(92ouWk3&dU_&Q91jikvC(IS6j@0qGk58Hy
zB~gy(eacYgItHBm&XO<Ex})Dcr+suE*hk$RwQby!c|BESJrVudXU9pk?uBTyDDToY
zw}Nz6%%hvK*|^guD>>du7o^7)bIhX2@S~Nbl#tU9#|)7^)f>hBPMRE4&KUWc+J?p7
zo>Qre9SNU|`DXq)b*$6LR&XcvbFq}Ri5=3fj<D<&W>2P+2es9aaxFn`nxhm$UA`+T
zM)YiXBurteT|#Zfq`|*Ej>93A$;>N06q)Mo{B=bcDPVFjPmlx_i!Jbpe&a};iT*T=
zY96#oW7?xvTG#%i|Cg!7!<bU#kY3xRZq(St`VsA9`Q<W;cK_ao!aqu=E-}0M^M@x)
zI$Z-Dp-C|q$00}Zs3Uyo#os2C`n7uuOA}YW#_RT*w9~)mAQ;P^Goc0ej72t|S5yq%
z6oqM=r%eBFG2+!z%l*&T?qK$wm^xr~g=2W*>}VXhyU5#CSybu2(SpK<yyPEag(B<<
ziMfDQM!bFX<4(bQF1iz0_U*%L%BAC+*ZOAKWa*y4JPikeQ8F>bnj{_eTi>xiU4vbf
zx1moS*{l(;8%_aQJDX7oz|GeUth5q1u{4O9cq!rn5&A<y#2z)mJSNE$EA70PF*871
zuW+=7g3K*U!!X*Xnv~UYKnajGG3tIwkhS`xu|r)>%dccC)_Sc!sEb|v#mE1kMxn^L
zwRKVCP=}#WT67hE5Yv0<^P1O|uA|QGl!TniF5u-Y+L7EG=lTVuLRk3h5i64{$J@j*
zr&9uLLUF<Ow?aoV@2{<DKS%wPw9IVTq5z~Tv&$%L5=#7jC<l2LLGG}9ytF!WCO>a|
z@>;B%QP|_B18ahQ`%$i6ckXk-eKDB)LqCGnmfCQyi{Fe3j(fT1O!<uJXJ5%Z7nHv`
zxREtH($Xz>CNUYt)6-Ku2Y`Qi9K|EbZz{gip?XN^<RyOXTNqLufpxQQE`EmlU++%C
za-1IQNJa7A7G+{=_V_`_YEWt_Ez|B{Xdmy{XbH`zt!NQ%5tQ1Ac52hLS(UIMfS+|!
zx)pc(-|oa{Eq4Je=ia*$GL!e2;&Ny}$r(R(7O@D-MKSt!QzOf*F6nJVtamQlZ_1cE
zmvgYs${40EN{4DKdFJLb8H`+?sG&nWU6s~P!J^x{^*VkI#S<OiCo7@9#X-6n8y5NB
z#s&p&ZB+)otW~EEJfEGq&I(|+wxu3@B%v=tBiwFo2e7QPNkftW)C%_ujhK)c07L@o
zWI7YAG?kL4Iez$a`a?n1Fjt!R0b1gE948zTha`97h-mUIK@-TnK5%pGkDkige=tYu
zAIzDz^-AL-3Brzv+=`gX`|3MM$>b!ob4id*=yUUqjf(F=9=y2(p~h(K;^(HV)z3iY
z0>=G7Ppo8ZsY?~0{7%~9n(SJh3CXxx;7!a`4`V;rImf3Y$D=&T7ymf%l=jUyX2Sz#
zC7o~n>aUx785Wsy&wCE*Kg<^ZX?(n|vL)Ekx*1Sv&^cA>y18SZ5G}emXfd>9#!d`S
zi(PO+7<TEmg}*Zk1&=(u_9^vGzg%}btw33M{@1O3=b!j~Sr|CtuYJF~d;0)yEuruj
zxfD3QE899%&XjR=!#|jFv71nkKB32yB|!#67Q#Q5V0okpiNHL+9GX{vl+>vY4LCQy
zg$--`qJV3G{cA~@PXo7|Rt~@KvkG3kl9cd^o1N$!x+&1lrFD&PYzX(xz(piffUY$G
zy29Vb(?W+L;IBSM93QJvjUpK{WTWI0(dD((QF31%z`Xz|k6UQsa7OIA%_kLq;{0rT
z@(2qA-afAh0XaD*Js|g%7HDF=-8g`$=i{ooes=0TfbG!#*>;^~OlUTefCufKjO->i
z*5|MLZ3LpEyMryS**1pnaL{aq`V7~QKdZF9m5YjlwPB3=-Yk{3U~j$F?!`r1?>Cml
zXbQlfapJO~V3Ojezc{PR59U3CJo!RHcb4C0=UEs#)r~t~uyM)t&X|iR9gf)U&Qib7
zKel+t;f^zjpV1{U_ZBfvOL%`B+H1`d3io6Bd&nJ~1KG<Cx;6etUNgnF^XLimq*BXv
zoQ(_Zqz_YCu|=`P#NB5exv3w4GWPWG#K{Z2`H$#&ne>rE3c%9u^HNemNe5jxm7N{6
z<(~FZBOZdb*5b{uLqk_ngi!~P5;=X3td`}Ko){YR9iskZcjer{m#bDEYQ}glCk{h8
zZ&djbvu$R7dDS|uQ23_<u_A4RFn?o6QsydHvbnnKN!K4&@9h*P8Ejnkd#~L4*B9uE
zJaxKOZfAbSt7d+Gn;&#@f~xF)Mz9^k7kKJ;09&SzsN+h?t|IiPW$9D(cBgg6`$O)V
zb8(I~%>2>joSA*sN|cH)@P_+4Xr=GFQe)2-%`8mJW>?=>)~<KL@*p{<ohMF)U&7JU
zUQZiH;{~@uvL?E#dWsl0=kk+^p3Ed`bH?kybVYc;xk<`ae_brSW*9#IefHZv$@kk3
zZ>qOHGv8gz6mXXL?<`9+yL2t$<I{+H>6uc^_$e2p5#2aXFYf<775Vti#nI1~krR8`
zLyC)R-(k=G+AAzQ%2l|7<qZ!)#Bk(Ex8PLa+DZJa(ioqeuyrax3cEnrly#x5+{4x$
z@C&n#5pZcc*W$)Z(Yp#>@>WBRH;IlOC<|?DisIW#zK9FR^%H72SX0n`lN&C#1|<Hf
zwP$iqe*Wiati*(=irud?@4C~Y_C&kJrW?oePn%AJxt<z(%|jtyu^NC2cW7Z&K6U~H
z?}DmVjqXz>`Ff^D+JV_UquX~97HBc?!YlvDf9$}2c@F#2z5aLHTeL~bbImZ~s|B6A
zU5KS*=xH7vb7K?e%LSRfH2nM`sz%9urt<)i<oGqQ@NA1}aQ`j8z(NrrIkC6o=4@<*
z%xJ~pmO1nF?#8)+Ut_3ieT0pOO4VpEW<XNz@SgWA5>JPui?^&=fMWGrpcYT!yuqLf
z&&KZAD5v{EJ}`Nc>!7k{yLSF(x;ovg+WlbjnpZriQA<JTacqH4tHQ~@kH81&Mt*_#
zm&+5bE!zaGspGUM>f=(e5CCj{duP=D$V}_q$s_CgFn()no=<{EfPzK43d+qpKX2RP
zCI9K<J9P)7SgE>puIHGUn_%0MCs-WTAuabB=eDWjg=Z;dnUnC|3f_lLSOe5Ba#<+M
ztx#cI2<t-7-|Jkrt=RMK(&Y~dj>5(gZOt<4GX8t!HU4WyuiK&zKr6(K^vLH_DwU2L
zrmXHnES~d06uAV2@oD6KOndnTgE{Ydjjbg@<?8*R{#|<vK)1}IjySpI^(UrD84W>h
zeEDdRCcRc!&cyEgKMEL=NX)3$aTxTa`^jl$Sxs~FvuN$t6`w!-U{|Um1jP|vUK3Vy
zmLP_oo_g^~PmIkZG|=kp&<qgl1jg;s?;hh*5-F|Z@YLq$)iPHR@JnN$QlN>8*j=Rj
zIWkfm3-faV@C_PL=Q)KpGm^B+I&o{~A_4o2*M=-O@SC%Uxmx)5HQZ*>^NB6t8Tpx^
z{9jNtyCph2B&4Wvj#?fefM=4y%yh%~@_qD4JM*8Tf<-PSe(;Q83`^E4CSQ@IKYRyS
znTNC4F$)hu$NLj;-`oM%Kp%a)U$>pp7QtkFKK&)(XDgR^CH1%ay?4l)Td=Q>J@xq!
zO#*9eTZNK}fHg~PRJul(%U7R8+ueOE>zM_1`KyCgiCQC=(9t+!b~{uEjX6C&bSFJX
z&^P=#G0k1pXF9ytJ?%?g`*1DD=ks>?+{&s*Jl#Vl7`N06<9yHKQ*eqwjRt%<l9sC)
zJa#HY<M8^JaQ=%GZ+<7nGWp`btbeMuro2W=A^JkNKwt^*BvXVq9{hKn^UbYgDN4{-
z-FoTh0S&xu@W^_HaAd7AcUZ$`i+A{^&Q%Jj(Bwvcwr+9o{p~+H#~y8K<@%Yq(yT4;
zRnxF%Izz{5dvnF$2>5$@=Ed@2cRQ?O_y-CgEtM0zE;x6{JN!8ru9I}!LS}XRbxIUx
z4E5i3b>iLd<HSILI1T}r*M`zHyu;l0tE(UdWGi48zm|ZR$B)HE>DoKpcJolbZ}-8a
zk`%7zuga1gj<MAic9*^KH2Ki)3(s%<qcHiMzfftL6%Mj_RFLgh=zz=AVH{)KwlBP^
z8^}^~>2QHbx7e(h=Xy17U9+6WXz^{S0raT^N+fl>meW<P_#&^e5;3;g%e!0&7_svm
zb|UC)c#>YLuf*O@`QFWSgbR?KVx%biO#ZlBZ2p>=XQ}%mhq?U&K~T2%*wa>6&Hd}M
z#R8pU=~lEjUdhJ!Qy^067T~}2K)3qw(YD(w4v@i*cf5&PLajNLxI;}i`M3y?Ov7{k
zQu#Cl>qa8cH}dW?D6V9xS>>|<&q_&g(Ze1V@7<>Jz}~MLRu@U$=lMd_)#*s3Cj;cx
zcDg3NMYqV7dHLpHQJpcm_B|p)BT6XKBc|HB558k2$pf>FSE1WVz>OZkp3&6;1<kfP
zW>?Aa=pJzk6;cVt4dWw5|NW1Q?j8FFp!s}M3eS#T6rk$fUXUog?4xHf&)NKwzq9xf
z$R>^Pzl8fP4!+;KR;_EpA=s&D=DT|gxT&$Rvd#Y|VzK-8h^XjL_q&&|$@V6kKH+T;
zft1e#5n;`2(9Oq9JW-Ykv6u3X)|H+<4=OX1vAY32O=ha;H+ZK<8*;HOH{?{n-gT90
z#XFGJ<EErO+}f#G5+M<29ma`17^jgNYUXXh9PMi_%ycmC>-`N9=oW|G*ZZ|vzyBfp
z9Ev6i`8BPho#$#x5I>&}Qk^>VC<!r;D<<G#p<7etN_5yAb5RYIba+4Mp7SeowT-Fi
zR?Ng(=Dd+G&ou(RvDnr*C^5~uW1KkmU4$qCnv@wxezn3qP|oMvXN65S2|ETZa6y1q
zO-rA&UO%=s6?LZ5%atm6ulL9W{J*XcsapmR)xNR+x!02N#IlX~LHA!=n|ntEj-u?E
zLudG3!UR@VgU_EZ0_0E{GbL)?3DytBH?@!Inu#!-bWc*XyW*3%2NVMcDZ#EMk1Z!f
zMwvjPq)o#vK4~o8Av>%9T}vy`>)U%-cl`qvK)N?iR2}cY%IH>LXzZtQQ5Q3UMlZMW
z*8|I}#(w@~F)phlRH2ct1dZ&zuf0~K-pn9V**}3Y7twv;9t}=E-v|2<zIJ6xQ|os0
zfPS7Si0KjBFTHRIArRCZ#QzzOb3VmpXaBAIEi36D(jP`@<c;4yPUKxh-)@p7U_f|)
ze=)|Xu$vC@?T_dDI|#0g+Hqy7DeU$>BgR}UFfpSD9}2N}6$(nr`nb8@S9xpfUAMy-
zG~d%%4Q+R6*-VZsH&vi`4XlEA|JoFe?WZ|dUI9<m@7vcBswz=yH#mUNd24lTYaA=p
zEN^D3iC;FRx_|3i8*k=x{S-3?20u4(9LSW2!H$KXnau2Zq(um92wC?pV#%Lupzl*G
z^N+XtdNIaSJe)^e@F*2{-mR~cee_qRs_X-m3@Q<gVZB)of@xWg?n_uC5M`h}^r6Xj
zI}iG!QxvW}ngfbCf&0_<YU5a@OjfBzI@D`E8|+DVfxcU-D%FQ*Ag)v<mi}w+GtCE2
zof@!9gh!c{N8<b$Uj~FU`zvxm7P~a`dAtHKf*UYsdtXHSLQ0r-Ll%^#cWpSGYxT8G
z@q7!suqNs}HcWfKi>L@R{_6K29uc|a#pqRlO)WW#&!LH-{_^qu3h2&+H*@Kt%e#kL
zQ7cVP=Gj6<_f0(?K$tAN3s1MrS^$zQCA>w6wtx+muZ}wlKeA@KT2@)NY<vIco@L9p
z<dsB3&GG<`gE_$R^(+Q!gwe$A;94jCYk6<2c37;LsMeVtx8dwEA7v^(q{@Q`;rK#+
zuK9-B*zc2spM;iGsML%jD(&OlecVph&o>u(+@utezb%tG9r6HGlpAIn*-{#-S@djg
zRX|AgB=Gsl9tC{5|6tufuI9J#3OO0;-BYuS^eQallWv>)>^&BRju&I~6&j1u>PGY#
zy}a2g6dN5(tD$wK^}1Y`M|*iqhmHjF(or9wQK(!FoCgzi9wZEBCe5vLGA+MYJu>vW
zW{6$fi8AoF0F2KiAH1>&;_tT__-=8yhr)Yq5G2atqYkK!f=rnOB);&rFmAg_#Iajw
zjXZ5uTTcZ&-1??x=PZ`fJ4S&p#2T(ErtnwGE?$YHG+OT7(lOgCwC~qMxIY&>UB0)z
zD!gG)y6m;@7v@ZqS2&N7cfbpl4I*FE$C?r&h8k8$=ZowpcdiMT%_kiSwUuhxSCW!&
z2~<{FSD&k$qej^B;z;VmY7rjbn|t|swg~bqb?NBHE9XRT?de}|#Ebw@p4}?v@eDhl
z(a-ZWV3tu=@#AGr5Ip~IeCBCd^|R}hegOxI#PmgX)5V}B?=TbdOX9`WLuy{7OXZJ#
zDq$zgzOC<nv5(b&^I297B+V@r*^6K?@gD))4JR*$x0n~oCDN&&V3_A3387euay6{o
z^$dwy)!BVBlPV|K5QIur0ac7Ak$G-%s&U!0=$B;}teYtbDJ`D@Yn&PDnj7UE>ORS$
z#<-SUR3~F~yvtWnk?{z`F8sln^OYh7$LujP=Qq_y)8o&R*>k)dVJZ$y!H>`XJg8k8
zV_UiWLC^nOyok2AvKS5d!6os`bql%h=^hb39Z?!Oc?dtztMop?T!~m<VWjkc>9BAc
z_<ifBx#4AO(`aC(LpAI{$!~RcLdBdV#V1Bxe|-W5y=aOmJDb-4fZYut;2bUIH#M!}
zjY-`3x#@2E$wF;DmU))ld?|uqjkk4}Au|2sh-CwfaQXOZhuYN#-*+pZ#6dnmiylQ~
zXrOLAq-b~J;9M=iz?|Ic)1UmeRe>dczbM~xc6JtnK{`*XSgaaM14{q~(0I{qyrmVz
z(1WJT7F1<ApUwW>ir>P}if{ZJ|C7kzcc7&VSGK-0I+bVZk3q;>cG<w8ouJL_Rrf)U
z$T`J<d?oN~scHV0<bTzoi2dt>4vpqa1S@;qUvW=asy8_}(#r&lt24ZaKd2Ius_i;W
z#+NDfoC!g03GyMT1?X3mTWaDGVidCve~8OXL+**N#A4?t2sTY;W2%$#c^n=CHuK-V
zmHCiNDkh2VLuP3smys}D85{%L3cUCo>Q%@I`jQC}gXwXvoh4yhd3v@7D}orwRP}{w
zvm6*}7Gv~N54Z-;(c&TfWL;AH<3Y(ypKo0UeC{U`ll$*=@-h5^bXPhHFP}f+it}YT
zSjfpq-o-`+H<j%_gUYC+PpkaG5hOGmO}BmgsuLk!w{Ny}t#6yH_WPsLrc2IXs<am1
zQf;YYR{Gydg#RC=h!~s1r8CGNGQ8YM*=GAXwKZmzL}6(}D8=QK($MMMo6>#s`ymHA
zF6cM;tKOaE?NEiC_>@Vh)OwWrORIe8>6Pft73$FShu+Q}U=on(4SxgHcuIuQY*_DP
zq@X;M4=eafr!3^MgZ3K7;0G~n@uvz%%ekJjz>^l(!c<2p(FzZeIEt7QV?Ve+>%&ke
z^4POylzlhM5^z1=rvRULz=;wllwH|v>a{@0%Eks%<fY3yd|!-Q(c1Mh)vGJznwAbj
zJDOHM<<L2k;Ab>#Z<xQ`)KH&}i8@Bl9TKmY7}W-;+A-FDB2s7=cO?RQ5#e8r$klnV
zbpPdV`QGmm!tS_}sZNYAwC<JSZr}Y8iJ3%MYe%?KSeE2y<}f;zhkwdE<zh;Y7+lr=
zMEgREXz?$X_Ciar(b8O3vv+rZTC=}SP~1|NlPBd;Qtnz+WB5y7l3-m*52yup+Ju5a
zTP6U4ldxt0&9FB)ZO;d})Rrl3ua8-?B0XRO%nQC}I2wvuztW<OMVQ;~8N``_nr=>X
z_C$!N>5jGg?;X&zFYKn^+8TYfTjch3_rZ@eK4TWx*qqhxR?L;pH@TY5%@XR6ZfJ1U
zE<GK@IonjW5f@bvaBW~G*aBp*tuqpr6G%!x|M!bUeQ?L|_O#d*`c3Q08t!vb8MIl;
zM=OdQ0l_;ctD)Cj#W~pVYb|h-`}(gUs2?6F@b=iIBq+)|oWdc_Zgs~%pm{P7eq~4f
zXb4q&b+aH63ZbsG-ijKglVzQ>eGKWTk5oxIJf)b?>z*816atP+ZEOlMTXpm&DxNd%
zt{T^b404{^lS>GfQFqGCN5(tg4!!~U-8eD23DK;3WLQJ%{XDXh@-voNq(ey@J4Obn
z{>I;DUe`J24;5bP=XCrHgE97e%g6Kcz%68CAVIWf<#oazMT<inTU+n-JeA;mPGrzH
zU5*?tI-GyC(klXA&f~<%LeI#`rqvns?^WF){`_Zv!4!y-PlPyA6o0&TO?uszgaSw{
z*CIt)<HJ2-#b6Tp!fmXvT+t&^DFO8t?VP{uH%zqOp&k_)h(<Zn_c+;bBInU=&ID_b
z@>P*6OY_$)8(>Tke9;LKWdoEDCTFbkNs?*}P&SDu8RiXqn~DF<F1q7>#6w=@a!p>O
z=D<;^Kza_3f^TP`Gsh(VTBY~>vtAAqp(J05>;3oeP0&J?bCm-*^al=Caa%Ih))i?6
zVv8A>(aOfU<&IndA>;Qe?O+9xGi_RUGAb=!6TeC6>}>&&L{g)<yQjD#l8)3Z4tT5Z
zMrS8&3=}_|*2zo`81!m!1KXPaKT5vk_x~ED{Xbt!y<<x{-16XUJqAO97Q&{qiZk+z
zq<c+k5AuK`L^vaKf|<I%YKH|V@=z2CK@y$tn5eoG?=~|Hy@q;M*0xVfhG(;<XC&~j
z;+%=SEdAN%#^?Lm{UvLKCL~^D0XdV;H>u%A>ALNwZoV%OQ~t@TEU|N5v{?Ie?PRd=
zPiOMrW(iFHLTX(qAKTPn8+CJ7?lG)`INf52T>5$O0pJcjDK$USpVh}Wm=P$?Q$L1f
zMn1ch`Vi1ju@1l|d1EiP2bHvWsIDIlEM(<WEe(UMip<B7WeW|u0_DhpCuMsU;&70n
zvlCD!T)GYZWiB4)q{DY#mM{d9LX36qEs>JQPM4j>v=;oUjOYX`lyBF&WYnxB1sLS_
zmolzAs@*+`ar`oOswhTa;mlYos#%^eJhq$CTmqq#Lw)WXeX-am7$bJ{NctKw>B_t+
zWH(H@)->P61!!q<ILr-=5m3I~+1)*Fpj=h?O1RJ-7qnx6N&MK;7Piz0#;)$<Yfk-E
zY!Cz|aP~d3b8rcH;PO3w-n>Iti!7bBJ;6*P`Jp9GXevB((Ylhp<>MiBM^q>#AVff&
z7&Kcr@5XoFnoU^(0B-yr3VBm*fp<-S1=cl4)>5|8AOF+CGFjPzmJHzI;&K1(63n`C
z064V)Z_jyQO!xu`#2dcWZWawDD*00w)Xfl$%PXP4p=3Oiljb81UlV0PNQ*qjHAXE*
z{?!f}V;V2Gt}iXYrnR%9H-%N(>!G#C)G-|-qVYXcz^fxnExq$kFukvn|7@jCruPv=
zEkjFtqV6+S^@AV_2P@X7%mw8SLrTq)SZmj~9xX4mb+3u1(BRy9Zg1;{QMn%oT2`T&
zQ=tI3|5b2|jE`^x3Fvz_k>_JM#DdbY*GL|<8wpJdpkM26?>7(qKbsqaHB*==%Q2c1
zfoa`lAf{FQKff)+u~l(#MRel<t-z8@68i|T<if+d$)8gz8@;6_BAf`9s1PL_8Bt<}
ziI*NOuF}q44VoD2jPyRAL1mLqE?2;ZS^<e<re90uyGG_7qzALs0~JJmw?}F(8`pCX
zTQ3}DzFk$Ir2H<q@&!*NfBI6{g+kydA`LN4qC<mgG?M~r2R529V^O}O@}G;SBdG>m
z5z^9tlm%@J3`maioY`Wkfv{@p`84%ZU#<Haz$M=zW)_aE=I*)wc*P2*h(HGf;Dl+Y
z*$eX4k*)*f^~kK|@RYrQFi|%LY#^XF_Ct9eNnOMf5(^7R*1osZMP<^rorEf&r)y4S
zig*+%;AUMQzS+`vz)uAV3H(#~if>#k0aACiSukH@_R8vAtf@uGuP{q*alobAyuZVi
z!1O|MAgpM2**LtD{nWrAG=Vbpg0*Bobwx=?0a+8W<adj=x3`zw#n@RRffwqBhu+{{
zQJNC?FsY?vdt+*|SF*Y-nWc+Uj+6O2R+T@WWoLx6v=hI%Fr8TmkKxOY$qjLCfTx9E
zU@xicK{DR8dkcx5HDl(|E$O*yO_}@wHbbEUmE65EK;ykOTkFUwB2#fDYO_CI13{A5
z;*7xe)JO<#S%Gk_Rg?xH9;_?B5wA##krpxQ7PjWWG`^)$=Xv3kL_X$Ucd*pEv(Up*
z+yB{Zgz~EXT<5RqQwG@vDUI@}3pm@$sb#{vdOz%Z;bKI~?{rPv_h)j$)JcQohV{CP
zW@plL=P1ue!BQJKEyAG#UVgsZ1K3gwYZSg_t2@GrQD^?g8DY<{PJqB`{cBS$M^^z0
za>oV{x2_ojTCT^pKY^PbZn%x)%&WJ*n57pAO)FpaSXjfHb)^;!yb~N9k_5zIkt9c(
zf~-e3PXQ<IUGKRM$0=3DcG|Zr{whv?ypT$SX_SW(X11e(Iec&J?v?vO$fX-&yi&#I
ztxjI&rn&|pPU0^>zK)CGGK~SlExJ7m#cU$(Oj=jWuCt{7oEeuq&vE!4GAUzy$E&L?
z#ATNHs-G+iMTN?Eg)Ms`r0#BZl39pAf(l3}8t{X@RzV4GPsluY{#WiBhGaPgMtI+1
zuF$z*PH2O!oW@RaL&1M*?OVwDkAq~qK2D5UMSC-@5f=DnJ~XQBvkw;j{>3vwqEbwj
z9J5elP~6^UZ*R;X70>cV*Kn5lixFe5TM-zNZDr1GH@b@1S#^65T4p-{i+$PFeIn&c
zQfN`pi*ou*{p-5hny~wAg81vg_WcUDN5awSmN<`3p{7DAd$OxI)V5jwc~;w((A2@o
zvheEYpNQPHaNx+B2Ed4tZ0&HR52=!b;@f}cSU;rs7jNnTn!7*R`i**mO@bOP^{}A`
zN<HCR7~rwf=Ph{G=WPhTutH@rV-sJTGA3d=ftL!^-s9ukfSWvfY|s*x#bZjuDh^uH
z#=vsr>KZtG$qf2UuFQ@&S<wTKbvHM{%(2lb*AZ3>>ZJtP4>L<vQP~gVP0RsH;Uq~q
z*MyO;$@$lKCJ3Q-9&shb84UXMM|`TI+>^~$Tpuf~F<%8ScJj;_TNDfX>WFj!Tp7P0
zlrm$>!V-l(C!pD&{l5R3<oR|53^l9`RWE)W;|y_UWW<caZlfDPft5jqdM)DaY%I&G
z*Lc^fFPXyI`I)_MyyllY!z51mk9Oc^lH+}V5t^NP+E~NOhb34W0Rl%b>wAx|yUSIQ
z`NctPq+4Y4Jix#$zjXCiROX7)SY+-bSFbrKV6f3<iiy^|bopxEkGkLZQ{v6N`VLOJ
zgjqP3$j}hZvL|H}zlr14ToU*sw&a#b0={@Vn8T~75|xN^3*m2JIt+diA4XlHX5#T!
z6*Hp}>WI@0iAHo7E_*acSwzs-pdZ6Y>>gPAm-`gzA9t-`+bX1LYpW*2t=<CRR&I1N
zS0E>$heeZh26(P}XCoUVskEV8pN{c9msKmB3V6TArm5u$`?>_q8Nccd6xdsxybnS0
z7<`<~+t8SsGXx`Az8<X^p!t7$f#U4V9a9gg-OI@JfoBaGD>#r0zl&nwJbgYJUthXH
z(682?lt^;UdcWf3zcwJ)3ui_xV$86Hs6*UHBb>uh_d^ZAxFmUthQ;6bDgv}#>hv4~
z&WMid{a7c}W5NcB>2@Jy08~M1Gub@|>Ge%eSay?Qs`1L9Ce?fEeLFb4g2hY)Zkw+n
zGMrz*CB5|8iuh0cf0IiU;Be*qqw5WPOUYoz5>b)t6~sc^g3g&sLzkdbK5EvKnUO4N
zND7sB-J(VgBQ|%KS;=mflA&r%h)hW*9%Bb<P1Y-sM{sR&0U-G^<YZy46_y(j1)7D|
z_`Umb$NdMPY_u{9d93O=Zz{$@O<s^7_NwQCeqQiJ7!P{Bhafe~-Tu5WlJkEHlwm<3
zC1*;W6j;lVQrP%SR+HwcQJ``AEp#RGb{*zgwcEB=js)j97|`};iR7U!uhIHGzo$3j
z?VFw4XQfXrnB#|U>#qD-Ew2=zF)ev>^(hLK?-k9+w3xO)wrsi#srmzH{`2Zs^(tTl
z9z}AsvfO8ozovz4!mdr}tNiQ8ioV6FF^udQ8@yj*vip-#(mUcwC_(sekrqD!h5*00
zKm0#;MallerE)KBiHkvl*@HMBfdYmXl<5cpWjenY6JI(ObT)ku-9b9z6ouQ=tA_KX
z=~<tkM(ku4h1l*no-vbl*%pR>8!IK^!7N^}m^_&Xu-=Ag4@q5zBiHe>)ROi6@i0^@
zl!%NTSZ2PElQW6mO;1l<Wpgm8)s#r*O&@vr)7qfS@fnfn#V(7?yWpW3#_9D=?+bC!
zCF~h|w!YAx)Oa9J_f>saBJ0YMW`Av|wMD+|StzH%9vSe@$IHk31~(QsBeME?J`pBo
z(I|jV>$=>MGjqSQ*1?*6Q%pa1gLiEtJscanHe?HV5SR`>G8^9gfU{@^j$X|yZ}1_w
zD{lzA3Z4a0%*+xFAI3<unLc_FL*i_8jgcco6Po1cu!X4sTq}bH<sc6OMrd#bqRi=R
z?Q&?1GEUr`VT*}Lzh2}!X@DXJ&|dret4=9pSoILUS6F1KLxzC$%W5cAEM+ij{b*#X
zQBG?!2Rx-kAj5^_q-49GG~O3|QuB+wYs`GVB26RF`30v=*ihQBP{u&pZxz@xh;rnb
zDr^5pmuV&WLSI{T4ZW064%l1}*w+S}(EX84$-3vYZq)rJ`9TX^cBB_;<lPO5-)>j4
z_$IQnM%$k5>)Y`<?=@)2_oli@EZ5}>0`MI|yc0}fd^39nVGVM}czTcSDSi{EqaAzQ
zaSabSJ6-->cnvj*zBx3<C$E4fqC<Sg8{#F+a;(e#+v!Vl{6|*vwN=CwrHTpk+b4hb
z#l2vDBm+qn_mXNwAL*q9Zl@jjXs2Z|7`60~5i0G+?8BdAvUZ{Ap~@sw;>)69j^TS_
z2D7qZv;D6>7}zzasCWbwdl@*!<~@n)>0cj6&B*~{_;hYTC3_>i%I^5-@BAyX{}nQv
z?U(lW$r&_V&oZZX-?_fz30%oPH+DUHeCu@&Fj(0oI3vcT^JM5wVcSIz))*Ujm-6(i
zl!gy0NvsQ%Cof^>k*K?M^w={xFKXD=FugH<qWMCeL9I?l@?GQ#vAEHGW^{x_&kUUo
zaPy`jebXMRBYo$~r;k+-fVtav9@+m*w{xssPZPa6YX+3EIvw+i{(ah|GUZE=)C7k7
z-lNyT0@eT%2~^fdqzp$e=0yDaTc!%G*<Z+n&e_0cJ7$sc4kviWu-rcH#RqIF907~;
zl3>`^Lj~T<JNz*a4emwE>&G;XjVS>_PovxfhFDjNjQ3a2(+hf?w4pq+)>P135_lYW
z|J7dE^lTy!*%})BfjWB7h#Jun+4^zIP_LFH2oG`gt5pNw3A}Uq;=%#AIn4K~25cHI
zhwZkp$-RYD0k({I!{tvl{2l!HGA*DCfRq%^A>)<RR+Hf6quOhu9K*WMyYmg)`94}+
z?JE0)C(f9Hb>gAYYaafGa&;lYuZ9=_DFXMs6CI)fCmOAeki@T)?tk%4plY#eO6agS
z&C+;<d~a$-IOf)!Cv-4k7jTnS5yjz3kWCBlaa_bl4rBA;Z8EO@C{i+lkR&@72DX$4
zPSC=t@5D-flKgd9Amkpz@cSl*&&8_bkcLtj6P&Hfq7>h#LRb$1h1I@h2c-)nZay;T
zG%xp;OSc;-YC3Ebq49D7z;Rj|HstFJ+PPRtS80KpWQL3xkSf0y0O(4$#0_7-zRoqw
z4TNBZ3Pr{>i-sS=5w{m^=7PJQOwSAF-0QyN$h)u<E8kb)nR0M>jIj5tEI=jS_LJI`
zSNga0p53CB4?eyXyBm_A7`c?P8MT6j-nmHh+&Ew(`_7aMISjl<QLNWHYbqizv@y=e
z6R=lJQZ!`^m=zn@WH4-ODiL|tQXT2#^=zWv$HvdC(gj}f-vH&$wk^$n!jybHZY(Z#
zzy>_B0xla+&AiwVsP@^+?I`)<agJxpI~exX3p2SLCJ<=?)miDYCuG7+t-RFEr1+^L
zH{!j}xX9+kb+fV5cWW1dEq&%49-d75I(`t|rSDHq%ML#_?z$ReR%dYL2OgI*=K)<Y
zgkmi3Eik6jEu)`Q1mgNBGNfMxL7bhgV&0TZGqXlUp9mi|Yy#BW#9a{5$Yn=9tkPfq
zrL{QrQF;K!b9bcRQUT+xt@Hvi5Ojw1igl<@13YYAoM%uzIH6C?V_UdhQ^<jnGe`q-
zvTEo^iY;KOuecx%2L9a82O5-s48_j?L1ISGOCjyKAIMj>+5NlTgag<Hg1XvIxD(|R
zzfVx^iFntHm*@rwo9csEG*jEc?<_U3>WNcl8+I7g7r=ZMJL4amPw_6_`rQr$8>2M{
zf7`L(n9(4jRqyB%^Z)M_i5uO+4BnIjN0$Gu7D;6Kj?}fUH4FghCRi+e#SXaHuhnu)
zd~i$usv5Y7>K6grM6WplPRy>yy%L}7+h^4r61h63YCm+;jZMFJGLF>PY<;WPY!<j1
zCI8{dluF7tetdV$k*50{TZr{BcbZ1%6UIYq058E;bKE~EVj_v<dXG$bjJla)D&;Ce
zH?nZmhWd9Dh89=92tpF&fgJU)U-G`saipII9!Vf#^T~~B18lG+$@cpnTuK9^YO0@%
z&TEm#cx{y!v@a3LEMb$U;~*b<>0xUpAy^+tbEh<6%ngvkg!20u<p6a<W_YmR;4b70
zy1Z92QuKb>gDq02QDOe~yDvYeUgf_T=A9Dy`E&HYXs7-S%DSijd#*$O{Aqgs&#^!c
zC=)r4zYxFw7l)Vx@C-lXVF0c=u;O91cO%+n38slzEBFz<f0E<GapB)rr=Ch5M@0VI
z*B?)FdT8uteSACN1Lg#)h;Q`2eC8s00V<Kkp#Gx_9EQ2;*U{PJcX4%-0@Q-Pr$2rm
z_^he-EVXFxR%G@G4PvphZ|mA;7GPOO-R)pW7~R??f715)<}=%D&y5&Xyx_WMF(8}s
z11pzweEh+nn|I10ahSlZm%y)!+<t_h6g#-9(&0gYoy~nzHMnA+8zepV3`c*EKQ!`-
zb8x*mvqdv`LN4G$Rw|?6dC!~tegY%G5amzcA0L^Hx#^6XiH{g#Vh1<A{D8l*ZcPp|
zgw}s%<bib^4VZmzHs+|?@A2^wBY=F{%A5P^4B#+gl5WTfO>@~ptKF;L*Rqzd)Uq>)
z0-RuX&OUy7(qIPj)a@w%-roxFJCZLN;9EhX(+O)t4`(d=upBy>4b_H^tA(N0a5)pw
zN6XQ856AaxkBJHl4e-0sE3$)iH7l}Q4ApgCoj=pCBwFFd84(h~FaRyJd?0r>-DvE*
z;(B-o4ie%xpl;MnuzyS6zrt)XbJuZ}@eh&B_a{l53)H1Wug$efSkmsV!R!|EkL?z5
z6t{BvS0$Cdmn?VuzWd(kOrb@Pnf*-&Ji>n>g)WzLBZB$vKQ@;#d&hju#cT^}%kLI(
zP3ftEQR}*n=t$io)ulMGc^ZKiP>vnd&YoA$$A!W~?@zWQpryYRj#bx>%2vP7PAC~7
zgUU}y)bLb2vRxXN;7eTj@F=VRPmbVAgd)+xuP1cJ#^RGomHKUonF~F|gE*QqldGTu
zTig+qx(fQ9Rs$FI>7wQT#R^8@)Xe1MUSbBJvt3xJ$>KCy32!*=i4G33G65IP{;lJ>
zyAW;$UiHdiO9^JWJx`RVtJaf`vqdA#Yzj&Gepu<ZI6}1E80v4^=OoQkLXgfNRQK-8
zu43=Le<md4nmJ$yG)g@x_@>E~lQ3V&W0$nS<4y&A_$D_Z4Y3!5sf~2mne-}fnwy<-
z;V8cSZ&F0;SkDB{KjA7t>r5Rc{nyqJ0+HRlK=gf@Yih*y*|O7!OfNcXi&5!0XB&s#
z8^4uoec@iJ7UaUlxfla5H8bq8<3I;V-FhfE;1n3g*Kw+OEBxzArjIXrOGNCaz}@i}
zhtiQrmi~QhvuP%JwO<WP8Jb-0mp?ytSOuKK!Bd|zpr}iwl8rVBYju3R3tpIQe6`Qy
z3YUhZQ3qDYSaA7s=ZA7p(A^cqflT}7FKyBG>Yq7Tl2h*|xe!=)REKIZF^q#G&2A^C
zGLsfR#aPjy#{i=ppBPUmHg#@2gETxPiHIL@I=b(nGSiqsxr`G`Qp`Vb%<N_+6+cre
zVzw3`6|})T%5?l}><Wg8pZx)Pw$^c-TvY)_)D4psm>Tq4bA9tWt%c8ZZbh!f#?8Kd
zbE;f^@SVMUOITg`r(5sn!Iroc>HlsBcC~-~00Hv*J;w3-=G@9?S1JkWb@9?Budg{&
zY+cH_a;~(J9jRuL9o3y{I7jF1J?Fws>1z1SU5Ez<iNOSNDUXl+i<%-|K8cJ{CBl>2
z<Lii9h+8Zho+`44hMXwHst&L-OKG6d{n}v)hj!UOrF><2c$|8>EM|P4jp4{-=8&-1
z6W?f`rd;pwfqy;1DQ>SBzFX|tKt0tP2ShS1{$C`;EtaG>#gY`hVG>dN{wOrAAEbl>
zctDfJ1-Kb^OZ?)rQSPzbN+>hFTk9$e*ah>mCS9^>np+$k2SX)6$U988MO|fOpyV*C
zni2w?ij^OftV-<PQK+nd<&u{^SfBF)H;JD{<8h$<!sEAurC-`0wS2;sd|jw(iI9`-
z(OVS0_&CZ~#$)!>Xw_*f<~Us=wtw+g>Avl%p+B1YAMK%aaC6=g9xOvLRJ`=T`CR%o
z>4$MTL^RrBH9QXeUQ|{mGZfrzNRD$&f_ELJKsc`ym=qlnOE@+&(_@h*?Z4>>dDtLl
zaYj7-_}xLlbT*H$L`GT1*`%pt3;avsBj$jMBlK|yW|cD<H3Mq#;*+(v#i^;?TW(jR
z&5Up8tpaBx{Ui6eL+-YJ(zR>i`Q2<kwxdKWu9n{l6QC=}WT+*<9A6A|+yBf6`hGP>
z2fqZ~U2JjM*=dD<QLC!E?ZUv@^HxV19xL*pT9NWvQ{0hr;`#gV;226t7>wF9|4TtN
z#1xbvuf8aBe5w6oGM4M4Nh>?my*T`-|JhHxYPXTq$`66(T~Dco+xeU&y>b(>|0|H|
zfAm4D^~U)^U7$bC`Jx1sLllok*s7YP^xefd$jDDv&9pYm?E0ZhRU28lIZgFEep9rF
zx%t<y9(lq8#`K9CrRf=k=qGJoG$pR>;`*PxS|yw&W22T5ZS6et%BX8~u_6_Xr8K?J
zLt5(Wue-r67D^^wEzIVwe4!3c#sl^0h|Q|i5$Ssoz6>WC1Gh$L7XD%XR8oj7*QNj7
zR%}r+F9XJzpQ-tNg7gTt4&-ZB+Mquss1_8(H@T;&_`}84+J|Be?9NgS4u*H*#Jyf)
znuEBv1be9wh<I=SfL8V4$v*X8?hBR_)rVlb-iV&6%kV>Ti=*ky$=^L8+Ge^Bh1@|;
z`tf7q8m{|@GPu-99-#Ks8&&cLM4;Dz#g*`}l;c{NQCt!*jlF0iL=jC17bz;qJug^a
zc{!x&&AwHMJ5s~~6xEt0AgE1M?<sA=_5izIe-UMAr^tTG4K+N{E*`TjH_Tl#OQcBq
zQ@uij)8{C6klb9@lqCisUr+`SDvVw5#}(%oa;Xl|=lGlwiNBCm&wxpOp=bh@qGYyR
zkEdfhBb)Osg9aP;9Few1zk+)xbnbb&>Z(WDIj%)sE*lH**ITXput<tNwU{-G+^cpu
zt1@X2Nv9-B+I1-JNnFy%3s(0nYE0_{t=5oRP3j_t?LxPbGTQV~hdxUM`0E$PJ$5*w
zad5hGJJx3ZOqU#fM1Mp*O+BI>z1^eg#N?{iR9>3Xpq0J$D5hr;<L;>%VXA|L974ZU
zEp)lkt$ZZ4l)hFf=Mo-L9vzQd)YoDCH_$k)zin~60t{N}<07w`L#K*l+>@c+bZBZv
zZ-Hdl*7`^o)%U^EHD$g#3TH~uAs1<O`ddQ3g~uk%`fK%>Q@CeLc86>uLZTMzKh*IN
zC5>+!Fj@}LLp`ttUtp!7w0o(~=i-6KEu5;2JVU!p=9JF0H826kNqN7_W!tFp?1gZW
zlunw^PNz35VJyvVctXrL*@b>>vqQMv3S8L1S^X=WwwC>8Q*K%xm|HNRb&`z;ql|6#
z>6u?#Mz>^cZZ&0t;MXon-=;Pn@(vnypD*5U(&Fy;G~f7@wXg%=$^2d8gw)6uVWChK
z0g;u5-j{t-cWuoJwmTIBuIUGr{Zh6P%0_oU{_gZ7yK6ED23(or#X#`*+bx<VuU+=E
znEEFMcck6dfB%^sJG^kx*GUnrnq*^lvGNc282HgSUwmP_+4*vSd{3&;$2?T6ypvNF
zCy4)>YO$O(r2ITNRO$K8$M?d14)99jR?K%U%y&I=BR@VEE-Ak`n*MlIJ(JJy`2sTR
z+}6GC7n2HWq7ZTgGhS!qgwkH^m-a?#=-qYmFfnbMvfhh+Koj{vT!9Pg&<-dT!>3L#
z*E^Zn|M@;*TDoZ2dNijGO%Sb{D6Q7}uvk<v23B+Ok)vUvo#w;R!>H|k?(3sY-lruZ
z#7o#flfgBCcp#*7H=+FH1_x$8ijR>1edh>6Oe4buq<x~5BpynliQbqsjOoPXM6+12
z_{Bqzp#|=n?wLA0>A7OJs1)2=LrA7yb)ZsHjhoKhWf&R+SxI!(@jlsenU9c&wX-v|
zU&29VYHpDadRau<o--R%X~kVHt|M57la?akR0Y)D(vP*ujeeTuPsse}_Ts*ZMAPTB
zVx#Vw|7&AX|0&)^y9M{G&T=K0T&o>mmO6~>+iGLqtItii^`bx|LqintUvH(q&Szy+
z-?Gc8mLin`ei7+@Hdt6^#6#@CL&PM%or@b(^>UE)z7X#fiQt}(RUHf49}FV6cc25X
z6t%#2>358WM#N;a|8aZJ=u5rwiXNN-u7AN#bg*C}QeI#GVvW5;dkjge{~C{<5Yf`(
zHbGm|<7Xrbz4~)@Xu6|uwpd9e94lZDBpw8`Yr&B9boBC$yoh~UpmgyD_S{W~L3RZd
z>FWrK`*M$;KR<e;=>;JLpC}1;MS6bq(;MNw%XRelLnw1#X0*MSPg^)&4_pF0ZJL^U
z{Wau<y!$I-V|~2_V3T!s2hV{<?~1uyg#k6XP8jnkH-swxXo!XO71y^hb|xt2=M}1a
zwd1Amj&zJ=ZKOfQmW5X!#IK@r(cV4*)hi~$1CT2He<*vasJ6Q{%sUAd+@-ivT#HL6
z?uAl{yB3Gw7NmtjaVwrefeP;K?$YA!?yi&Pop0uwH7D;gXRIvF_W$1dw(EEG%N3bW
z1M~sjQfri1RZmZieX`)WB<fsc)7@1ks$0=u`X1qZ!wP66U=Jc5-gPIYJMhVcKV6~J
zGi<bVChy!lbTZPtD~b3P<#|Bq0LGmRdANGTI6a}5FVgL+i>l@FE3yTW`s&YBWS`WW
z#q9^%YLUB0E3XQ7!f!}xYt0;M^<V`({IDyGE+yfp6Sr11ybMzlk8{A^M~s1w)S_zk
z7;dCuj4j$EydYW3X^V(_5M>+PHD^jM)CnxXzuY5@{?SJKscb|&3d=#*B%V}T%j+j7
zRT;=a_XYtad7zFh*nOg0^LnMhvpo>^zgPeP=a2q6N+>rQUVX4-yTuPEjtz!_zoy_J
zmAS1y9Wfw5Qu$d<pzp}cgu4PdQ>1vfE?}iBhBvzpO@1#&Mya5RK`q52qczG~X30F>
zJf7IQ`9X{?DLTSij>mo;uSyBtNUR&S6*snanY(<^-4%LCoU@wfPtiDGvwrJ*eXSmZ
zX@~__l#RpPu(RZ^1wRFT*+;e~y`!*Au00uE60Bh(PV&v{>2D8KZei@8+=zq!c8>+@
zSVxa^QYLwE2;aaZUA3NO{b(kBrb(d^Jw?bo>7MLL6E{)<co{Edw_)JmLPxxX-C<YL
z#rwK6gWhLWggKza`uOqbhACz&Intl37h&sb+5x1kb=9BbywDdHpHtQU#$o}QC!;&5
zd|~$WuO6lw?HKiX9$A9g&O_Dw2ir-KT`8AN0z#IqPol)UTqG8x;ZHUWM-o+(a1~C_
zm_OI&rM8JVZddk77;f&ny2g9&ihE>=kK*%h;M!NX;%7w!GU5r+W3!(MZ^^0=UA#-+
zuhMXsbxxNrb%oKl&<A|Rwx8wZtF(Md|2PDy3mYKU{Jt4{+fY9J$@Z=jT&dyCk9^Y;
zK>1ggAPeA|k;TShwg|pA7D^$w=|02@2}R8gxFw7Aio8h)$n5wW7#SKfe&m89w0rkd
zdfXf50WCWpMy1M&x+$3JrbCm|9rf19Io`Mp_)7(kYEl<pMOm;6I&PIvG;J4x__(8G
z+%x%S9m56A+Gz^epUg>UmQ^h{d0?eA(c5AQH?_x+-cuKCy}=CjnVhTZMQBR6uSx{p
zY+S}|H&+e>qaGU5IN~JPySHUy(I&Z;OoUJUONQ02ws-F#OYzEIP3GFp`#1N|;0$2q
zRNEpl-jSiL$Kn&8L-M&~8E?t}#@i>(_=qu-bS(T;tJN3|emNH4POvMiWOA%Z?J8cJ
zA6u34Z4ce@HQraAw#ulI5gh7m#F{wm;2%PnOzzgurlP?jLm3{juCFDNP6V1DNUiYx
z{?QTFhw8a^&Q6@q%VnS-LO@j$nHL@wQL1)OSc%o=mkDW%6(S)R(5^^XbfU4fMTHx^
zgGB`3#EBLpJ%~L*8$$@tcOrXOcF4#QBCwFu#V;ymx#nH6oOBrdiGBV#tK6wOhg!-=
zg!*p`(`NO61gWO6(_7MgV`mWv=E4V{9<nUh6a$%4sKGaydjQ>>`iSP6x3=uZx4&w4
z6ov4FBwjOehr%7n+D8KJW|vG!{r=}gmJb>`|6sUqXN3f}z+~5D*r|FA6A@dGDXj`W
z&OV%!t~dj+*t!O8nTF$`K{is#-1Y_CTuJ%zIRC`#EZl5LdK%-yuFeA!>bw$<GLYeK
zoj_xm$|2Xd^;ek(->agmL@6a@Tq|K6(y3+Cz>z+XmQY3A={XZ4sSKr=+(tS>g>BqR
zn<iI_V<CziB8(p{A8zsrnf_onUVueJI?=<XoM_$oqpBOjAnVjv=#kM~xB6Tkj8pUI
zg6(3)emNd~t5C!94WG2uM*lQ;RLNBlB~~n8^KK=X$c3Qgyqgg0vX=@T4aiw0e{owO
zE1%h8HM2pB++k8JUMeG+Y`l?=SWi>YcUXHk!0y4@3^irTYEzE6KEj`Ob|&oh$G=CO
zEgTtjJI;W$fNJ$0Gg3EP^F0UKsD$pzrpw(PbIM6h*L0p^e<WX@?n}gAU2(5>qDje2
zO?P|Wzef(rS#{rYe<?U{-rkR9MS9<yY0laoz6F~e4Wta75^mL)mXsA#9ILxUF$(ZH
z@%g62vL)zYl~bm$Q`a7TT!OjCOBL<zby9g9^l8%+EoL#OcWKq);oBHfk^Sa221h5w
zv)_WgVNdH48U5I7Cri#Fe(cq?OJ9#&j0hDW8j_ray{_IPcpo|FSQhMz^Ff%68a@N>
z6ly)bTiLPHK&H(20tuo>wg%$vY8%kj`EcMRp=Kpb{>-Qg+O{xM`Bcs`vj%Tw5NCDM
z=AWb(<E?KGzh#hY5}N5vmR7g$0^uxU7g?9Cl6sYzjV~(*J!401%836yf5=6u;`Szt
z+I=UkYy7&Sy<O|RH61jT!5K4h#bLqgj!m=JA_vHdX-qyAeticX1w-B|AbW>G>(q-^
zp9U~U0<drPbIdK4QQ`Zjf|sZy`09~3_BXb?U#bc_j}MGMPwyyQ$bU~MW~+EV-6M0w
zv`f4+dviy5J3vkS_r{{P-&2x#B=)+!?v1;w?@L+JET;oZO(7ES;*~Jp!#HXVv3EmN
zs6)6n8RGVrIC@bztV<d);FwL$<qT+d$?Uy#l^D5l)IPoJq!O3-VOl6AKRm?8&t4je
zL`(U^2wWz5T3zJO`Eh)50%pSL^ViwW8}dwgQcvVJCK9<R?x*qpZgg1rgoZShn1%{^
z7-#907L>mI7IFPuIBR;^xyYP%LpA}4mu(Y6QtZRztv<{j)WxAuJ)(K-FTYnIL#kop
zvYv%jmvyq1g@12xF!^W_tL&|P@RctnixO{JZEent{Q2P&R8c~W)B1!%ac~`=M?)`l
zarO{t{yEh1`RIwh<W!9N&o6jC&97{}=s6fa`Nup(SIBWRM^=}FM7D|8%uE(w44bsH
z6U&W~$5l!>{M;4IPfpb1y|<%~ci`ZVB*(2>AnAy{!SugvLEpF%e?`k-vO=OtEEKW7
zZ2;N|Esx&OD^*1KuQFN1>#g>0Vc$~MEdO%1{!6#qev4OtA1@5K7hz~Bi!x7Q+B}R$
z{~&Nf9clO`Xa1vS+>2d>upbJU*fY{C<HKni-9Y`2|G6-rX-JySLgD{e2;Ocu1sTl@
zp~gv9@M$(~S>7Wk;v$zEqx|vw1N8n)FeV6ooN--*I+SlKh-TmFPYl-yQGFMn^EFlq
zcX_VdXIBF!4~c!cdv~}uL)M%wa=|TzyJR}Pzd-m`@FdUV)uON3h=uwXUxELEb)g{V
zpg+(uFJR&O>w<?b7WJBQ@h_Y!MCaW;g!XrowBEWL(6B#U-0TjNE21`3)#$R$j{Mc4
z{;j%TKOm|C`C#{}U9ESJ)0MI*{%RL>v17a)Kl{9=4q*XGu-GfwRNvr3NUZwsUA^*8
zZ0fOP)4HEc&Q>f90YawwXO{^;!0fPA?KD$4({RO1R3{Fo+FUvKMri)BIwU{YYN5F?
z;%f#@sey?_kl!{Xi|xKYP8aD8B4_*d8|#QOTEr><eLgn(q)D=?1i*CIf>PkmttnDR
zFH5TbdW^5FW1Bo(9n7hMui6{e(%coVhpeic@xy^~<(AY+n+<9o!%64P64m(p@tU57
z>b7N0<`LG$|C1^_7G}fuQISv4`x8U$2PR7YJLLRrl%(I#ZA@nTdRNj}3Z<e__sCmK
zLNwf{AC(6(;b=>?$nnVnuX%+)Tp`Ap`hokn1}`0_$5#Jr9pKu%K`HqGO5Eoh-v0!E
zzT8;5u3Nx0rtU!saSNlFM~1WCa|Q;Dzeo)aSU&!qx_$D27ojyMH%8po7vn}!a$b}6
zgNpc77x;Gve+GnwHv+1rR{6=%9A?|Tw~fk3(w?oVqeeCb#Eh-|p=1OH5_%myk%shI
zbVappcJ9zU=_<FqFlrxNZd4OmV#bIK45bn!lUfx}v|2jf4xLO~^O~aKAl!NMPKK~%
z{Si69mDIqKR<GSyhe;p9Bc*dnTEcY1LYcV}_|D`+`K6vn47!=w^04mz1aSg5r#VYa
zG_ZolFe<_pobghOBga=~I*++xlvBtivODQ)7=IqSGlw~s8EvTILS4C`$ii8;lwfI=
zP1A^N<trH^g4T?D6<652$ezugQqzU`ZsS10puj82j7>gaIwS>oLV#CyylT;UPxZBH
zblV<zYhoxZbO`NPCw2S9GbPjnhuN8)r=%_G85bwX*PIeAl%X1CCrhuQtLqJW*KoKL
z;TwPAI>(x__z>-DIgS4M{yjcaApRgAaxqVV5X}}7=2^FMv7cX3ZdJs&(B?)T{Si)z
zPlIMLU<#;zd#VsOUN)GfKO^|p@!%*R*a&oDkh%KJH#ciL`Brm!xDxrBfqM1kHh)s=
z$U<OReTYY~kl#*6lqRjZsd!9mDN`BAcAwi5V13ocYM7GY(ljT#(y(f_c6K=RbhAVl
z>NUPmy|8^`5$w2U8pM{Ryf#v7^}0o~=q?j{zOi%OZY5w_X~h1gGE7Q>%e-=i-f%P^
zQ8w@;;P3(!ox}#chvnqlUURB*wDNC%dj&OU0XU^pl89q7wS(V5?P^Lf@2&dd>*ej<
zDo`+1_>t^hAGp-|L=L!%kh!K(#~m$wNkU3muHJWR9O?V@JY6dC@_y$c9jbf{KUSez
zA)}pM?tC&^5{5{zy1P)>sGay2Mx4b@chii_HF-8X@D`~xhc^kTD+j6uJ^t&&l~`wm
z4>*RC=97HvXlVyp_DD<f9~NtC`F7Ox<K0rH&y7<rSxvf^J4uT0nqOA1L<Y+^i%+iw
z)#$4NCQ5kX@g@g#942qjrOypc*74S!8dtykEm$$}l<-FXrIa42lQgaEYP$g9etZ|K
z0)iO)`2C16g$g?yW$CVN*S-H(Ocg{jx@2K=!muQkyZf?aF}HE?lDMd-m{z{+HQ5TU
zf&kVXh!AYru8H4Nw%J1~B<;?Sl>cCpkeP3PmhPYQsPi>R)(KM4z7TORp`NFE&-|=j
z!&lPm*&sNTZHFwD8!(z4ShKFwY`x#qe){QEXii$oEVqhYnyldODZ$U&Z;c0Y<~c|F
zpxuH(5)F0ZyAJLaQFs?5*#Xy-#G;3y;Wnv02^B_PcPDfPmrVD)_>yne5oo2q4KtgY
zKsbx2@a~uG7&<xIy(vH3GTE1m<MT4VT~Y|EHXk^~p!Bt0{u+4g_U*_``9xR;l9~im
ze_ZTjTRahV+am^=v6ykPWC<7{n|sTwN`x7qG~9h8AuYQ}Y*ggF$Mc}cEf0Vl2iAsn
z;Fp%)uvJ|1)ji{C)`fFAJnrFRXhh)=w(}M?ofK9mPSW|_E@HXnGJh}$2<;$jFmU!7
zyJW;~e#EJm-j%JJ=z!~YB|bM>7-ok<uP?@^gw(@3E_|`-JsM;P`Q~m9Yx|@|CfgI?
zBcEBfxUY&P7TyKF*MtEC6vR<0?2sU6NSO`Y3|}{{!BBK6d?JJgfXk7aQtg{tNzvP^
z3kj_|&0NGN*!)FS3s@XKq#QG<&Py!HGGf8<F@pb%wyQQB2W#b<q3Y$Yhhj(gF55%I
zOu>1(zoc59yX%cUHj@CdBDh!Y?vOw=NZuGZZf{hHV+~k8B)9uLjDYdWB>bOV;h@XY
z;71aZK_xR$;WA<LA_ndL-)}F=g(0IzW3NDCl>SM&-OU--@rY%ozMzoTKBTz2eHp2m
z;#le?pR5{UH!aDfhND*wNl#BsWe$i$;=;4`VzR<rop2ZkMoe9UafXy$&*H1^%WfOx
zT;wTG;dK1Y)6a9i7`HfhCjt)-J^lqPkzlVAN5}DP3jWAA*n7OfG;&6;D$yb4bn-CM
zDQ$+CBeC3;f(^--Bdo*Wq)ls%WeS<8C8T3SrxpWKT#LT?LlGX9|2YQr{p_~mq}eq$
zG@?Mpvpkvs=WD{s74r)2GK8x<L=5u<2bfWXXQuu5+PGDA=1+f3pG%t-+UcrA%{-3e
zEW2s#RC;FN1V-l1o*a1&S8UABOor=8+IH${#A|S=7bX2a--8#XcDW3te^$gEKD?#W
zR(W|U7GU1QS<WROY<Q45o-axmySBt<G{4(LwT>k&&7BpYCx;fK`T{!t<DI>*IEQH=
zqxy(M5_mr+pm`u|mk~<2IwWyGh+ota52hu&XdC_6Y{(#*?KOxzKX`MlhuBKtv+20G
zCBJ0id0dnkFH!f}EDv58B{&cO3`=IS_Uo0`JF1S|kO7Q@099h-y%Tq@I3~*<=U&D#
zADcYa8}$nAJM0ZgW^__9^H6sxcxgpU0vnpjLy<;m&NEYHH_`ErR@>?TR6w_WWVEC1
zGF7xgum%Rp=x6It{__*8-A^faZqa2UFElZHKx453-b2BzHv7Kn63~B%;`;$|jt8Zp
z!vdo$|Ni;`N>v9^z*6!97IWSynps)FgS&^ai96?*?Z6DT9aVufz6-!P^&>`rA2peM
zZ|(Kqc4Z8)?QDDMx|6z5Q(bzeA5C-UX0qH|y*s%@iw4bDvC6?lewjtcsI{Fjp@v(W
zP*38hwMT^y^-#5->)?XCy+=iRZZwMm-<-e_bW@gqrDilH)5=wysM04P7)5-v&1V1n
zAz0htE}q?e-&*V$|5&2DkMw4i-0F3lmT9mj+I&Xi&4GrAsk3|R<omZW4LsQnp?2dM
zMXHr+SGTEW6-G}E#fRQ!KHqW1v{%<U^O4}2uM5QBv6ICLS}M957Z<h8+ysJ>yU2(#
z3FjtPk1=Ia5_01G@hAWqw&3%C<(J9k-@1@{?v87o+ZX({l%(rtf{>y+Xpj~|&urGe
zA8XC)n7)#_eLxFo@ijH>^E62$+7Ju?-7-!GK(V+$YNO9N;eAr{lrjbOkXk7gv(%kE
z`jjAF(sIT{!a)tq`I*kj(qBJt=}7>bC1Hae7b+<J*Yi{xLi<qImd8G3JE1b2hdppQ
zs2r=cFnVv>#8p2k;NaMG;QWrAV5zj=Q;!acaUSR_OA-x&76b;Uq3swo#3INO<nz0w
z8gpueenEFBt`g0??UcLVEK@Y2i(T(Ih6hp8Aj>Bmi6bH24^+8*_Xmm51Q>s7T+f31
zjyypj1Ywsq_&9Q_bcXu}$v;t!cagXY`OX*yUhvJlm1)%5e7T4tO0+}7thzF>i^0(L
zGdY2>j*vF_!*%V5)2jlWf~`#7pL0K6lr@Q2i-1$)J2Y=H52V~lJ_hEzVOPK%$C}1S
zh-DeLXb$^~{sFPR{u%w)?SiM-O>JJ4{_H*>^l-sAg;n;wS<2_o<0i_ip;DbKwdwV7
z*slADMs19zMrO#U*Nvx(Y0@OqZkc~zK{rs@X`NXO;_=7&b~k%r1pwY-o>N?g01Q&+
zd+|rLjQ0jDn)u*$3D>ag#W$#e^&o4um)r0!T#Mg+Hv=2QahVibxEjRo5q}F3E^YNW
zD1}IlK^3fxzX+1O1#j)ig&t1H*Z+ORwUtOzr*SuLTvPtNQ;+dSR_bouZSxWI#Gf?v
zJpRyai5WZ`h?0YtLyYLqYb8ZtPoTMKNr^HkAVF0~9%oYuuw_56Nv?&O=iqelB{ZpF
zQ;0j?ZHwX$O8bL1wT&ceY~n^;=wiID`y)K+8Gmp)#?6)>hwle8c)CM=_sd=JmT{=N
zJNd+|U4M*%yBRGM?1peyw5uD@Oli9J-o~xDTgLeeoX7tRp|Wveb!4#Gt)P5YuuPC@
zRd9T9(u8v+7KIlWH{Ax?Hu@=dZ51;jq$c0I@qk-qd|HM^UE`h;DlBSLUt$w8vxdB4
ztsj_8h%Xf!u*Y@{IA0mIDKlk^S-8y5EqHZReIy9n0X-cTz7uD~$ID?aEI|<2{=22x
zKg)8p-(lF?Bi!9TR3&o^F(|gz{Ule{5!unNw!d0!sPIWU@|ba=*-@`S8<f<j<E%~5
zZND4RkBI73e`LoW0V;4oynw~i{VXPI^R|ONrp3+6BfT*!^C*GTr!?GD9UZ$oQ%*%I
zp|RAoiArbrVnA{b5uamuon#Kyw$>7%`HiK>wxW6BABSg4#~QPWXQuf>kXme|j=H~P
z(Qb-f3##FkC)ehdIId)Ck+Ek@<tC#E7xK}?SmbhN>M>UcYdD$@Vjj0W<6RLvr%APF
z9q#g}s_m3-cp|-cxc6%itFv=$?Qjr6L<ejQlQ-_5L-wbHc21sb5!XQhRh;eUEIV?p
zAx9JF4Rx^!qt~vw%wIat4<A3vaTqbYNxgcpZQ~mGbhq!QZe{Z7ZE0%*Z$)N4@(1u;
z-R{*6)4}>`{q9;DX8n>l{*t!)Z$*w9^izD>Zw$+w&-K9_l49C#0iqZ-wV!OBudsnT
z9mwAC&@3<~H~sZB4Sgl0>_Yj+sSzOc(`p3V6Kv)RYawZ$)54Yz{UG^pDHtQTM{=?a
zN6O>>ax=`daCdx-uZG9vd&e}OaaDGi!~@+m-00QOPW{!!^bT>m@c>NNK0-2K4BvEd
zTS;3q$Oz3TJ-}~tzz`ZdoaA;f@v*0oTS>czudaW9cikTvcBYOsis-s)j7RVAZGw*E
z%oYk0owmXGukkf%2cW@$^MD=FzsA@9Y^u%wZ2O+0G-psCO86riw=}G8wlp!^sAH1v
z#w@sG{dlQ0<}Xhihw}>TXzsauu?y8`_SL^K^!v}(_p43(hJ!p4MRK0@LJnyR$D-+F
zQBD&c!9naoy!WmPYw5?We$>j*14atgEg2)%U-?-iYCf4;A15}vsqJF~tYyE@?z&7q
zoVvk_6CG;TGrTu&wnGn6uC*n$SbBYgf0rc6OLo`|TuG0b#}~Qj4y~~lDoAQp@dW#T
zBj$v-4A+$&V+z@Qa^96zLPZe$V+WlhpGQ^kDWkcLE_`<e`LZ;{S!UNvr}1!CU9ZZV
zd0F%Eo}Ka9g-&sEW$Svev;a@TZRC#RI)*8C9@1sI-c)~GoIEj`e(G}0Lr=lO?#J^@
z^75k4eusfce?98P=w5N-v-16YbE@yu2`LAOhdNBEe}`Pn*&OW6e+j*irM0T6sq`PJ
zWvTS$54LMzu1K!!68qiaDYDV@%1&*>o;7qwJjht7f#7cP{L6L@Wp51zicH`4iau+S
zo1-Ltn{eUon-}ee-$dTgwt1CuZ)tRWEnRe?2>s2Uz?(4wfFJ&tLKhc_R+BrBI3LvO
zoHZEU?ZmBQKt$^aGCE<LenWl4CB<M}pha|<Hr`?kQJE0cuvsDf>udzqPvcMmKd2_C
zLU7(Rp?Xk)bBnQZ*Hi3#*L7;(bL^K_i+oDc>WW%xLE@)W;&erX770C{EA-K*HEa?v
zNUwO^4ZNFNX&4?3&e7f!|2f$>br%n+`h3VD_JedEYEBs5a6XZl@3E8~@O?4;{1kzz
zf4{yq#mxzDbb|4->?}+WIGr`b`iSlv284eoj%q%|@Q40x;v5-;4le|pVcj?0u8)kC
zauoZg@h)3pof@b>Q`IMmXJg;!qGI5E*}|Tb7E&y=0k{6{vKziG1YGQVL_njuf>+FO
zc60n;2m0XI6FPmr@S7vAduS;Z?FBs`-72IrcIJ}F@HzDwPv!h>@e%d!wx9QtBVlp~
zh_`g%k8fMPX4~$0Csi~987^J=cLwW~d+dl8<K-T2O5yJu;W}{p4^g;4QeAe$b}>gw
zr(9VqSBs=*HfjJgX;b3zV=!0yI^E*O-L^S+Mo><cuibK#!#Ziod$0f8-6vWo-*a{a
z7?KE20rv?_xMw0Y)4MNvFX@c>A6FUCI`dC?ZHSe`8g0b`B8QvBpS1VPS{)54S_K%Q
z|8=EpP}oLvC!k$eR*1~T{S&Dw>ZC$y<D(zQ2jhZmzXPCrs%C^N%amaQe}|L<TJ+2r
zGLC}pkhQ;zRzqh>{F<NmDlH#fR*W{2jrQkvI{5X&X@z6oBf-}Cpbb)m@)NQJ3RBX$
z?;(&a96M2mkvMGnn0J4X#73C2HXjb|c{mwgISBvGLLNcVA&#TBr5<|ReWv#IQ{{w2
zsWFQOzRckIWsN}fAg2e><AJwRI${0K{7mjeW}Dr7`P^n?U<ebZNrWod;4CRm+MPk0
zz~dKWRO`m7UsRP+ne;;PSw$8<h4z`|ZbCXdMaB|eSW*aFWkwxidZ)#cO`VCGiZC{x
z1$MR#2S+5m9TH&yoP_;N5``LUFbyPdn{Kmj@^0f|(pn|^Z)7Ii-SyWhNp#&Bn!5iC
ze^81OK&~SxGa8ZMw)vIJgOb(n3jV^m8RwtxKSAx;LhydzBKK}?v&^Fw{=tsoHt|k(
zn>fmRB3Xc<yJnUqQe%WarF|RSrC?i_VEm620G|I9`O>nTmhoDzJ%)GQzH~T-2+%M}
z$Q2*GHiaZ=Ze-H)T2P6?9^t|ejsyf8-so_>Cx>n6*$j;4pWnBQYFUZA9mSfunr!sZ
zbjA2k$_?`@j0))ZN}*A6a&oTlk}8SiEi@-}EA0i<ye*Ag?bd@j5S}m5y9bcq9;7g7
ztpZdPcXgqQrWy1^qaB;FQpvh~4G$ICrcV&xR!|hh9fzNv*CIe_kL@F)I-hWAan((T
z;x~y>Bz5J@c|rBd^Xj*t6Li2K9f0a9U~E~95+1&c1jE@NiMth}fJwggd&a{Jx(@)_
zE>i-AM}k3PS9-aF>?N?y!;k!UAyUc!Q9@Z-j;!*2uN6Iy#O(2iJkUJUjQjmq31TN4
zS6KO^$T_2uz*}M-(e0FI`0(pLX-$&^hAz@!$10v%6gp!lB_7|-X)5}YX$K9PJl9hM
z@fSK7;XCV3Qf@9Oq1&-FWv*}9`8!58pSlA_n<Wn6ul}7mLh$b&FzkR4Zf<q}=Sl^v
z7}d03W-Vp^5_4rw0Pp7?X;UqrW_S7Y`f4LxNDfs<VfP{VCjl@fi%5oGyTzbz@@bzY
zn2VROjg9uVNXq<HY^s3Yq9m0+`pHPQP#gO<vsvpCHLmX*S<L72KVOW!O2H<CSGO4l
zhZUMa)5XySPh}<uU%p?lIBiejtKBzBx<W3ZqIZ*T*#5i!oeOlQ+>D}?jXUYa&pkdG
z!*Un-1VXC)S#J9>T@i2CFl-XZ--~4)8BB6AT}6ySYN`vf26}Ygip1xsBRA$_qsXV!
zB-BkTby#B*Ef#rdatmO?vvsT1R2GqSQ{Ae5`UU>(sX_y@6uBwiH~M7H!0TZ>xv5p5
zJl_*yVBK2O6d#TzRMiKVr1vNoWjQYK;PbFEEy)546Mn5v@xpH_GX*o9VYUUw_<(fL
zIv<Cq%jC1qIHg)9BDGr{Ql$Y0cZ&7cwrZaQ*tTW5?5!s*-KGqsa>2Ls5#7S`b;~T8
z8YnrV;Xe)vPuHSe7tTu;>&w;7O9;)eqV3H7d?lhe0?g4U5Jvh|oZ5JvW987%$19(}
z9kqPBBB(Rv*7K+*OLLN6Zb;@?H?dNw9m10Qr~U5UH7kcRy2#Uvq^WG9>oRwm2H{R&
zwmyr~ax?k9@0e(X+<?=xHnjK{*J!TvfXNF59`qwp>c};f8kQ|A?S~#Jn-JB<S-diJ
z=)v*b9~?b^oP!HKl<LIE%86Cx{Id)1J$89`6D0orC58!Ni-W?>Feudoa>NxGd!;E>
zl=pXoG(su_;)H#QB9%gdZnAZb2WY4p<^Dnn8grYP1p2auFK9@~`o0QFvOya*5`{cJ
z;r-RYTO}2Nh;66{M%<{0nmu28;i<Sl`X;$GeJa9>3#qh~LuszN#{M8Am_Grn;gssQ
zO_}3#Uq8ED(2AW(?#}4t9jX&s^^I7!MmuFqKWI`>dEVR|z=u7M)Tz#x1raSWX6-5Q
z{|vY41~7C1Pyy=By=vkjtF<~3H#)jyp98it7WOZ~icrY=9jCl6p|4R)4z<hP?!()0
zoJIq`HVhEh&i-34)J-tP4Bqy`Sp{g!i9F;^2K21I5ZYEO8S)c^j~T``R!oK5Kzt)0
z3)5Md4UMjFy?O-@2!4+ak{smi`J4LYciBg$(mK?{y$mtqA-jxMBUP$4+qX9$OiWcr
z!yhcFx!>6V&|4UUZ!rWV8{y5NVyZ`Ly8dVA3j?yf#2S`F>hte{?IbsZDzH{b@-*U>
zxA;HrjLk0nC5e&zADIbBJtqUH&nzqDZ98s97mYGVT=R~!_b6m3j~yQ{csS58|8VRF
zd|(~<t0u~+(sToow*0_qhwTSVVh-bQngDh*g1A-gs6btpTJzuIb-`&jGQikd`8Q|y
zESA8ad<hwJ6|Zsa5en{M7|NTJ8_pW5k3;F&ZzfzPyWb8lxKxG#=amMSJmT(9J4m41
zm(^q>={%<rdB7Z&UPY=+aeQxskUw@$8Zoc7Q3i#!8VBG1Ed4H2dhc_{u$g?P_>x9Y
zjUp1MYBQY+XG}V5f!8}zGOzNpcaIdpn<+{qDk6-*<{-=Qm(ZR7>XJgUI_D_5GeU_L
zb#uha2el43S*7AAwG@dKHKJ$jdy^S<YlCL@gTK@A{%14G+US+Wlr@EF#ar5&rbExI
z$;bbl?!6c6M;SeQ;2#++%E?+D+_SO~Gf+R1$d0x&&()ocP;1E`?ZGQnM>81pI-R9y
z?OMIUr?h0F5+^)-u-SdOw8wxvUy?tOu^RdU=1RW1hTt&NLs)jas7-kZA#P2vJ>y(0
zPrjIb3a_e!mA6Y@^|<#YfJ+wJI}Qb$nmc1&mqrdhALGYl6A43LZ)uSez($Qx2hn6s
z3kT-9tl0oKf8FyS*+M9);PbW&5%s3#u^U?$Z!4ojpsbFY?$d5S7eCj{{;1~sTyJ7)
zlIF1j9x>p~7i<4F_Qjx__|u}`8O19XINospuucYw(UjIXY*NCove}n3+A6!-FL~u9
z@+cSJ`CQ2~na}3pK@@k)7)a{cmBKv|jHdb9ecP%~L-cv_STc|%T1f;~WXEo16%gi2
zF{~9n8Sa9Y1ij*}>%f4RxFFeH{pU$D^hMb~<6;SFilnb?ib#eM?LUmDpv`b6y(kxM
zY=@81$b5K3gmXT_HFfg6L-RW8+igta&T+j8cPYu6e@B>J`tZ-X<If-dEmernvJMge
z3z_MdQ6rCB;#-rPOhSe_M9wy24-y@zrEGAbeX+$2W`2^}te7Sh;RWlO(f5DTHw@!I
z-_-A|>%YVwbF5ya!=h5@23Iuf>MSs{sU|9bN;-kkwom9^_tEcmpsLfB<;j-m9T+tf
z8?liaNnn=Gjb*9a#mG}6!ZmVbIs-39dO&>`SmKPT>?>tulmyd&zn>hFt^nux_pbF8
zYs$W$d*!81j|jC1)mJFfk=|~)uhNSb??Yg#YxIlTuHB0b<8m>Ti&5A~oW5ky8maR!
zEW2}dk%4DIxR61~TYmpYq8PHMI#PsQG_HJSHs8JKj~vVjcm6M6?2nqMD>~?_3VDKO
z4uU$ScZSX1(zYk)!r|I=s|O|E(KGzjO{`D*!F4b@WX1sr7*DbJxs!h~{#<b)#WRl9
zPPzVjQEpVYqxrPVfX$O?0J^w4tMnc%!h*V%$@@obRcW0;#(BK{)h<2PX5tCkW%A8(
zVE`k|xZG=*5z;A{6&sO4WMtesI|6d$4!O=T9G@xR=xSw1olI$IDFbzEPPJb{vDQyh
zclX2t6OV?&je!?{DwG)v&ZjjVpesxK!HuAc*t5^jCvv~uKCXOhKyz1qc+K(ztf2hs
zr{uX8B3c6Ig;yFi^9n<V;Emz7W*wqWmpMF}+a2PopjXe!F)okEnRm)j#1UN{nPQp~
zm=K_l|5{9AP+2qTNfRs7x;PLj1ZZ(NhWgFSE+C{I#8<Vrt1F+6Rz7<E3QTMou{W|4
za>uGn&fIKq;X^1dwc?|0{jC7D^XPLl5MlCs4~ar%vfA73nF6^0OvfefeyL~EZ5xBf
zN(8#S4-;TS3J^5|?79PY?lHZ$X%bHw=Y($_35l{PziF?M(%mo-s?qrb0DseP(y#2o
zZx?G{N-Xw{oD0s4gaP5CPRy={zBKDPFDRbtKR#H06mrwyfV^MWB(`)aDDxEpU!j&=
zH#)}!K_lFv-%>+I>-r9qceRM?2ry0zI=hdd>SAj+H^O((K|oI@P$GWRgK@n2ZQ1m?
zZ4H8tGjW;5Ky%Mm9S$wymZl<xwID~s<^H3ZTG3*s)sUx*9;M0l2TFxJm@#(Iur~Q;
zZyuv#J(SA@I;=rx(gJ@D)3}lQQ}3Vp9Ps&%8hx;<cKJ_u|JRPl$rL-SKRoPq(+UMH
z@eL5Ni`=vd2dWr#ydEP`?}$4N?sC=JqjPHH;)QMIWN;)oI46b@@Jz{gz6Q+E`AC`}
zFG`laskda=`QCSUR=;dJ?(d3L5|7lMZ-pG9X_kS_!`ZgvJ;Rc`AQ<tjlZKBY*IjWb
zvcSFAlcHEYap7Ge0GhK>B+Qh!xRR5kwh%4n>RL|H@}}lAs4{63^+U={fzFf^Lx%y<
z>vjU?^lVt<nbb3~DD~K^?p01!2?}*apQ_dX!&vF}c?JghhOg^&i(yJWmXAYj8f$4Y
zS^)G!UzhH?p^h}8hh7e=a{;#fA@T4blL5pFtCi9)tKa8|&gI09UneubdMR+)OxTh<
zueu_yf~LX}92=do<uYz^K~n5pGREiv;gS#8TynH~>7x?ofAAnjI<A5v*qb4&lcDtP
za9@5-eUGbG`Ky#X8&@Nfnw<hVBI{(A9DGi=!Vhp1Hrivk#K%S+A(7>w#9+wiAE%ss
zP63V;eeXP`1!Q$J(kw_j@j9|``sxkyN?d=r>3!nG_Ud`+_Y^A;C?#gL?<HOE_z?Pe
zBtb1EgQI|^IGK>fW_M;>4Ot}kKx$vMY_eLtX<hHD2Frj{6mS1Ew1)+!a$WE0E}+Az
zaUSjFf)F%j5KcD9mt`psTdu-4*goZ7V^!0m(kmL$uYz+WXG5wGLk#e36FX9r#~%w^
zY>&qwUupuqM}-B-Ow@Jo-c;BlNAuS`IYl`62N2QFz}t6`_4y>ixIxa==;dE<F)=xz
z=RV?hCK)fOPon5rB8MI+mu?HOoV#R_T4&`PYa{g&P2?%#*FH1iseg>qzcT&vi}rbz
zfhe2w4co+c%E-j{JZ_mw)a{Zri}jz5r&@&{RDxrNm6Ld2`mckuMAzdrt<fW9Km$a7
zb3z`4bIw?!#eFGGIX#-~M3i{tR-H$60lvuB5J%<z!ssOfp2FJG5E}5sFmuT$-(qi6
zOO&w<>!`8;aHmpx-0|PV#sAsNXfr8=VY?tIGEM*$I-TrDFDW_&U`|O!nD-;0kPQ+f
zv6mmO`~)90@QS=rI9TgGECD4fJC^%RQQIH&*j~_S9~Or8BG>dA-wR50w~@4Dd$1fK
zvXT+<6$hGCZyB0Gty352mQslSQEi4TA<RjDJkz7aX~<_t9buqehm0XhkI%u$NrwkE
zqyz+H;|R*L!w&S?mz<BqNHlD(VT722FPg6DfIEf*c-w;7_B8GeBET?>ZV@2P|Cd9#
zO}b^(E{;GOmi0wW<I4*Sn0M82EPXg`^uU3BMky7~H@s89HV&1ZnU(XAQopZG*O@eK
z-N??E8)_K<7t=F~3!P=Gf;S|?K~0p~jjuC6nK!*ohqs2rFiE-zlmKnOUEK+e2A~8&
zS^ifbMaod#oE6j>o>!2`M=vjbR+hN3mPE8uasCG4a}Ll5s*Re!pX3Ex&;xfk*6eWS
z?j4anhzcht6rjh&13J|So873Bv&3;)*3aVbJiL(Ki#q~#77kGiTi4}<h2@*Yc_y*z
zzP4VdF+MvrNA?_14;Y|OO8m|>-b?4jNR$@oWzWme4*vZMAhu?$jAJZx^-}09F-~TD
zIPirXbI=u(F*QFOkpQKnjJf^S%klsG2>uysG&y1ng^p?o-TK=BZ94`)5Wmip{fZ<H
z)yY~-6YCb{VpSat>t0WMTasEsjh7J+HoEH9>?W^cM@G(1srWi=Ij~~u6!}{K;|cPq
z0H~D(Maeh9-A#`$+Yw<PPVp8CK;lSXsG*ZaP~}!Um%WO|0%38r={5@~m;&CFvbmgM
zG`#{`@ZRV_i2<TJubr4eaV49gP!OfuIHtC@(^tIK^OfSyVzW*(Li1938IEPS^LS@I
z^BPQ+a+&f{&3sC!m?>7M5|uGMAb+=q&u(+Gl#QBdLIaTj3+2%^4ml)!vPln2VA=Xs
zzX++IGbT^LD_+|R-mU0q^=VnYXWjJ5jY>6c-AV&n$r`{|K!}5d2P`nytu!bVG{z#}
zSvRY6(vcIx;Nyq>`7iRClDZ21*~#2Sa@)D50OQx8_&3e^@wD#vekP>jKPqKj14P+z
z#-0_wiX3eb5vpPBkRM_w+kEW3Y&`JRelx$M;8XjhgR3y%$2qwLeiJJuOb};Ghzfk8
z@Ph;ewuKlP*&$)g?AlT$zwxb!I+L7a#T|Eyl4(Rm$Y1NQ5R&|W7y8nJ|Mvm@*AqVx
zWOGRd*wO%Z$bdT#0okQKJ~bjjEwdOz*^>Cz-PfP2ae+*<$1>^xTtN7V&LQ;|DvTQH
zhmhyYD6%YOBVN!2WVn$N>Ew%V)8BW^i$6Q%W5f<dd3)kNm2I9m0H-(3K7|#d8FjLV
zHV3-vgCE41;}}t)0V5rYzg~^)dnhr-Q!y^stbCYItypdgb4x1w2r`}=Q`gb6tOJva
zGRH)BNJe*SPw+$#1P8g1iLjH9bV}#=Twp;RJ$Ddh&X`1XmVhb`K8iPKA8Ug3C?cwB
zNB7*tpS;EE$u@qap~0mZ6wr1yhyrVzT_&LiQML_c6@0T!&Nc3d328j@JhwLqhlK<c
zYZ{3n&2HipDZL>%+&#BG`u^i`Pd~1gj(|^$fQxepBuK1p)gRKw7uJV1weWZCcCT2_
zsh7oO`??=IQQ$TWh8u{5W0t?E_U$OCqevPvxXx{uxKx>oP0wFdWKj+KeiV(j0frwv
zaSz#A;aPNbD6p2)_D7SRRS#(SeIs^K?JTPqn(52latj_yH1n||`0^g1G4mhsvXV%I
z8=gc=^<R>)lGWQn6z!O~0wi9+k=g^iGWSWxh)U>kolIpc{2wz|uFnWan@Pf_G4ua=
z?Em+7(&T|L<G+IF8i+!|>7_SPDkGRWPU5BA-1of9kWtvE$G%iev$QRE!DS@tP}13a
z`<U^aJPDjgxa|6bLvf4<mFDaHjhza=F~p`ma+QW3ydkWPmLM0diT11Frj(~8u_6yd
zGK>Wq;EEb;2?_AK7$B@DRec#c`tl^7QIUl8aJbF(@TIL;d)vD8_R?CC%pj(EaK~|k
z!gbbZpxr}g{l1^50nLr$d8I23?`nn#HBrZC7+rX;b9^6x&Hbj!kvn|$;SGv$L7M?C
zgu4V$q65ZQjZIVTe+F1&L^6D*?-c*aPMVrgbLxZ}EdNyRZQ+`(i4GE1Rt=7irSVwH
zJIF+)KuMX$LSn#BoZGgIXaU4LP@J9@0hpQG51`R$dMA|}h!10yC_oG6t?<&9t1Fz-
zLa9I}z>egiU63kZZlLpS8WsM}9%JFOM61E{avb6?o`qkFAsxsf0P=OIJ&!>V9ka!&
zv#kN44|yQ+u*`dsZGR_gK|ogXe+H7x=0Mz_=IFd=Q89GO!chq=FT^pnS!p5=V1p9`
z`Z$O{|F>9y|NLigtr{=`H`Bye2Ovt0ZSEryDoc;ix@=EtdmI+Me~F45d~Yl8$@bz_
z!D6CiNcosv>Lpy@899l1B1^B$f_w3MmL)ZcGD+RIoX`%JQ3m^{=NEhn+BBFDK?T6-
zDDe>_bWP5Q#2w{cm8d>xQSn7ytbp!59QpgAWqPi9$KRpCRmKYr)Oh#XsL3i6V}2t<
zL#kuu2sTQ&U0l7A8=UuD#GIT#17N{o=14t?JiNP2cD1rIHD2-_8?b0AU`wJjsWhb#
z%I1;{S|)|z5I&gb>Ox);iE^`6HqSb&ot(r?8?G;S$K;eO<$0CCnh3)4h?&clZ%5j<
z3p|c+!i6E>hJD4>r{9Dj+~0?~O&9+ZyhvX!j5}p~6(a+i-j@+3kYOZO5J-X0l7;jh
z(t*`ZQcy@6eJ~YkqFnfh{qA@3lfF$leKQ=%)93o8!=5*9mvOOWVQ?4mS~Y`)!@yf_
zE{Nd%i~k|gHX;AM&cf``dT(~^qPqN9vMKlGR;4pwhnpE7AnmjSJ*3@CVQ@&9G@h%U
zAf1-2HlI}(=Cr}zjZmQocmd1>Tx3F=1K$C6XcXKL{ZLA(SH$mD*w_&|k#|lKoQ?ku
z*7g5~e4CX{n>q4Fq?#K6y?@T00NvD;H`?2f65b4ULA{HE^<~Pn$k=Sl=S8vEWR_xL
z9eSF!9d;ZmWg%-*j{|*Y^8EO+astYE#G&B@lfQw<FUIS{yp-P&YQQXmV^DNR3T?dF
zoWB?}{{1BTF$b>(GW=+rVOlM$?DrLo>c=kqAtQ{6S&VgL#He&I$wD$n2{Pe@-{#2^
z^q&j?NE%CXv;llQ^~vv|%)bTid{v9D8VR`L8b0P;_?avCNay!Q-{u(V#eBqcdz<wH
zG0_kjHIOnI?FQe<wXZRVp|(hIFHxYtNvDxvEgHUJc3g)01%lG9ETm%#R+bKbjgYfs
zR$pq_m8WRXk*l@QfXM;+^1@#+<9p`@&)IyJJXvK5Ctv3q%GN`}%%38Je*M}+mUvNa
zI?xrwh+97vy?@TA;l!hq5ny9Q-<$d3VErJgcYPQ~tR;ZlkHAca837q&5QSg@nxl*l
z1ptmT?1S%7;D>jgjWHmj>^`ph|3v+qn7?#g2c}|CPuY{C7{?>YRbcDqJx>%z9Q`%e
zPf}DNG;8GdQ}KN$@oKMlf4nQd^r22hN;5V0EN<q(U;K&S43Pdp7+;XGwOapMder~k
zLOCH}H{}g^kC+WjREtz9%EzBnWW)>wzV2EDXJw+moV>=J@I##N1CI!0nE?{%ZNs5X
zxQibaLvrl4*iOp12L!;cFc&zaAvQ>ggbB>!4scswhQedZ?D3iJDjwP{>aamtNrn~K
z`HXa<1;Exdk)%(LGB?ZcPQn;T7<c!L<4FORQC8Yiociz@)*-XM1hd7<v5LeKC@pcg
zh2r#HD5z&hM%5<EiF@Ue5LWQ^(vS>SufRAwW)k^ZKPCn;!u~N6(%@V0PtZ%Auh7(u
zpH}|8-+GXusS7}V6zWGfc<EJUg*o!f7#dNt7}Bvg0Q4#0C`$rDwdl)!1m{^^f$9Z(
zx_!lCKv8RX3E^E&htO8fW({g*=V!@5eCL;1+17cVUO&NTq4?DwK2N*MgR;{i`eTJi
z#GEm~BxL$-!VK4GaF$5ZZi(jmjVu0%szKh=+@#J25hGOC(*|x3F96y)C4@6pc@?LX
zowa4?=D_v4`LND&f0X7Y;G)T#v=-rw9s9jm6|Eg7SV7*QTlklyIHYjqb!)eM1ZmqK
zvs2v2M}EkA-&RZ@O`)%;LhifW+~rk?BL%ix<~+pNm;PhBX;Rvf-thk%`pYGt_vo-I
ze9xGz3NW6rXT6b&pTr4)dCJ%^w2v%-G56bk#7UWJ`PPISpx(efx1l_mPTDqz-f6`K
z*X)Ck(RZq_uif?a&Jb%?KhGBsJzAS_YXMq|u1AZGQKt^&;BVb*HT{M-izF<pr#)X-
zTq+@d)cHcG3pf`Dbk#|tHtnxh%`?Zt28phB)N4bv$|D5nY+d6#@vO-SH&Uvwo?lWj
z*ULP)KOi${h)|c)8Y<(dJJR}SU|Gc~OlkZBu{A)4oX;^B3gbdrLk*okkU<n)I{R&)
zLA*>`yD3iy)DwSK6(`LBC)m{1E%*$S7{+p1M7&?A7t|fpHLiD1<=4#BzRfqV8R8n^
z6iIji!($w@lkTCs<N?MUhGbB*>)mECXR?$RrDrb%xZNws6?GyERR@@a5SxiX*LXp9
zo!c{kEuobFTcvi?43>`~)o%cINsOtUp`fwU8oMe}L^18sO@#O{^3{xifuRo^+P;3u
zK&IT*YomG$4+(4yRrZ3Fh%1`(tgOgXu!CELB7_UoFx-f$q84=}e^pk=T=;PcWLQ<*
zSU@r|j0Gz@_KWEilp2vvP_)1&w~WZ@vjVnx3u}swx0<V$)+IlG|H}ole=@qDL=06C
zsf_FOiMCD~j_%}{?eiBY$Mjuivai9Ld?#`psD^@NeD&hNiQ!Ob5*sV-c55VRl>jiX
z;U=caz#e|)fYup^8*B+OE?B1*KTNtVe4xOmCfT+g?;u>my5wpQ)WEjfWgLF&R3~+6
zc@rI(#&B*Y+)D-qNTjybDPnT(K>3XdxM9_GYJ;vz`j{m+M)0)oVxPuE`FH>{kM3BW
z*t8|Web1S7R0ROZL0Qy)2{SAuP!DZH%+;Uu?fSbnPF#`@qFCd$aGJ#&;F$Sl;2Ff)
z)F=#|><?nM7m8Eg#={6l4;$+V(8BZcIXj`bnsw78IhYfc7TQOK<3<xgo8?(-L&n|S
zriJHlQmH3Dp@8&UHTJ#S?qAqdXtA_!+exIsv0X3$j|!kMv0i|!SixTyHyZr#rZ@FG
zUkhz#ea`R?0u98i>@)n2r`(d@KUO32`WL^Z6bgvW7)VUo=kCJ$P$?A!S|QaHQQVPg
zlx}SKgJcK;YRZ;Z90gOS;|LW)kA>;@>L=C7KeG8v(c7a>A;ldC@-D+4?l0>pOB~;}
z`!GmSf@1O`X!c`RY^Oa>`i+5&54;fH!9<1Z!I#x3O8*b3UR?slOy=^#*#u}TECYds
z{3P>fI*||a2S>?Zr!fsqNN)?7h<s~oDUH%vJS!304dPw@_E)+$h!Inmv#cWVXw*qm
zF^b*2b}sG*G$MxlNByz`VG%WjjkPQ6=vBJQRXCV1hNP{2-@}ZSYux=-1(eVdMVT+G
z=x3`%tjM&ocG{UG4(XfY)2_Ca3eIjst~Dqo*}D`K=^MOVx>e4e(cgKCVaNk;%(^I4
ze$@_m68-1GUeq-l40Hzgc14M0E3Wqx-$P->aQ7xOu6nbk9@EgSfCfpSy;pzi-x=RP
zm)1XW5A7hc{Vx`P5WBm(x89RmswjdQIJ!7&u_4bQMAct9??~7~t@`%P7;v$KFL~Q(
zQZ_u!$d6_#hK>SvWLio==#HILR6a-`Cb28I2;<(nT!WRvzGXQZvr=vxsX|f=5%Nsm
zAK`A{xa~OHHoU7~lbDf9tO2sI@%kx>Z-XsIrz@Miv<V2gYQXh#n_FM7>Y<b-n|SXr
zuKkQ1G*+RNF-ILZcF>Bp1EyN-^rru#(0qo4+j{eg`p|hr$uI2eqaH-XWZ|Rknc$Su
z6Yhd)*h$Q}`yZ9qlVc6f)9>2hWwR^>n+bgnBt$Y7+qT{@uW>&jolLGS@b7%3(PhiR
z7nOPU#A$0;9P)491sgUVTuBw=TYm)Tly-G%XpZ1v9B)?Qb+<%?KXL@hYfpSckyHKN
zS@k51BTs5){hpgU6FFWX)3s*#h^)|dm9m?+LF1)9%!->TXH#wihF5`1`prszfWVs>
zFkH3ptxWGKLk$M69+jR-*rg|{I<v0@>+&B0)eO_J5y0tC)9Nw{oSyR@2Gz`48X_L+
z^tD{a%1@{(1xp}lc7Wr?bP!^LI~5uB^o=`*v+cS{QZ-iR00CPZ*Eq5;qq8zK+20cE
zcaFgl6cSm25cFd?E&7on(9<}DgTg#H>d(Ck^iBg+5vfgvluYd&?v+*~=hc<YcvA8s
z1y_7pVeAsGM=yPo)qPNi&hBk%$(f`0&og$IHVIq|<f9J|JdUjGMoQj^&IqBE7d>Xv
zrn%SU<W!|OmTW?L=u;P))*g4Uq7aSzx-nwJeV`pU{0|>?iT<DaAd37P^qT<8NuT{F
zw(&Y}0V*NW=o6-aJ7?RVrTZ<<eNIgN`yK0tzY^j_mvP5f8c9>bqicX>Wwf2xvNoF)
z*+<Nt<#v-UU;}5&Kq`;$j1BXDJh8V!efx5@I&a8R-s<^7qaofwxEd`_*x85dfB<xZ
zV{DSoUHk#<g#E%!i^iKCYmlmnSgoI5M$f1y1vHFtoy%;~lmG3P@vF`L9imF$JkjIh
zbD#yTR;GZC@BE>{%$Q#IbXjUEOQHJ_EEcx4jSq+ddyl+N<h9ohiIlSgb*{pSaAlk<
z2e|+<<n`QT12lqpk`$3@Fy~Gah1)!lB7DQbV@5!7n8$xN%O%pSFKvkgJa5q<y|-+`
z3fDW5(tAMZZAo!SsgTb}uwYwl<sG5lL$ITfykOT@>M`BwMW?*U{aluU-{PJ_XEAA4
zdPUzh*n5gP6l@XYeJY3)3!+lJp;ZN(eP3LFJ(DdSvx^V&3}5UkCJ4g=h$3h*(dUbd
zt>|Oy3J3|mAyg@Z&}+$OSr{_-KNx$<pf(@ySu_cuxVu}i;!-47kRmM&rGgZ9N^yc)
zu;Nfkac!}-w79!Nakt>^?gY5$f6l!#=gd7bzfT!HCcN(>yZh{ha6dE-8cRXF8~heL
z6h7y*40rvyceUu>>5GQhZ=rKBu%Ss2p7eWm&b_Cs4sHfELN0-slxE+PxK6wP)_>K=
z<$Pti05WzVcm|s21c~*jezYWGiSIRfJx>zlz<Mv4&L~0`y0{tAy}HrPfmN-x*bg6=
zj-_$x%`#!a7&K*hvjLan8$!es6?l^f{M~(iKuMw>*5zQlJ=<(7v(lMyoOMlH7iwg8
zIehkKsa489Hoci>aiKVFNUptLou3e0S}2)m@$=()j{;^fg6q?)pGHpqaM#Ss*JhEJ
z`yhcjT)J6-++WKR;*ggd4>%n87y-8mhy99+qn!P`uj#o&K=Z9$;{k7%X$Xl<8es1|
z4C`|d54&VaZ?yhXa5DPaIw%Jef}sM$HhvFxX{sDK@RtYQo?X>W>`((B&$X?uQEPt*
zFVEu!x=3=&D*6MT*sdauN^9h?K*1?Ev{So$?ND3*pOZ9WQaBqDX%`T8O*laINvh5L
z_W}Z#i-k_$f=9TG%}8ecrLiwn1JtPiW=H;vZP!{2rpX3ap-uFnKRLNkhFTH)YI(-v
z$b$AI);<j9z6BenBrQo#Up?-1Hk6j)>ymr)Z+PVYz;6%CNI5TMW>T4xML(8+;Y%=L
za1?lB-eIP4C&4slPvmn?>|@B}!0K0nE!TX}f=l=8dMNDZGxX1ZGC^lsfKvef8WDEW
z_`u82uNH(pRef$~OQw7bxWf*>u3NZvnyE&b1!W%F=t_y4H4Pdr^A*j1Cg(89Ca_#k
zLIf+8ptSKA`)8J#Pceo1*L3XOp&u5i>fi01+b#_x!8uNAS0z-N82Vw%6+`WQfcob#
zrBNL0SN&K;%IvYuwGla_R+U?h!QAng=iG+rLlg5ncgzB$KlR{McMdv)QYEkMo<7OL
zKpo}~D=)wEK`mh9O7o3p-BWsp(s`&>BUx3>7>PzVNnif_6N_=2zNbKx<^$MJe0tmI
zyDe@MfW{XntaI_WzoQpT)_Tid=mGM-P(>~5ua=$whkw2$uXZRVM#SiT%5Q91UsHE^
z)4bSyS<Uvg&{f!v4Flr+cYr47UDE-@h9>=Q3%zDJXx{5h=bp=EM#kNzu;DiEzZdq}
z#vcUc0;n5CZ~!mk$L;GwEE_?bMqS-wk&d3yTViz7a9Zk9A`Coul|(2@z#iq|NYcnQ
zoL~OMN0R$ViW)({`(QZ&c_i1~UrR|Gqjahv*_h*beh9RlgK!uGEkMIBt+8aGechgb
zn|ll=#NbSLV<K8{YUS^^gW|Oi5jS3FG1N;23~1eezDsSTPs=xIwT>+FSBWvwac=#5
zdiMgjHB@@%qXOKTnlw)0G(q<P4LxhMfB#FHfA~x!a%h=wcqD1bg*Ci#o&5E&Ac{U^
z=Nq1A);x6wF!jy(8FH(-_eWyn^rAra+YjF+n$aG-k?%Z43}HrVVJvC2;qK96E<_8B
zM$12RTCAceu1tBZLN61EUEh{o4;+?OHb?(ipnhkzrOqG&1P7{tEpXXrmOhGF_<KyR
zmw&|kV~>}>&jh~)_)25H+SzDnM7xc1`PdS5XR~K$i@f|2Uo=0e%pa=G@D!Rg#_|;D
zS|M4l8cMVvx+P1JTp9#hw3qcDYq@ZN8Y6-*8b=2Sl{Wx2Bn5AFE~R{^t4BYSsRxl6
zUl5_Qu!Sq*IX?kZWV@x)6F-d0SB@y9IX3o(2(!}jpPzf7u$^$Z<O&aIzrJj)oh9@A
zjVpP@7SPAHPQ={yv(zX3d4!peu3t=cety#uE@>ZlBFAv9bMr?c<MLwG-iq4KLFqNy
z!~zm5c{mfY>p5qKu;;qxr<_WLD0T=w2c+VMRU}*OqICA4^Js=a{{2a*kF2=Lm-tSm
zW0g3|!cf9unO$<TI~m&-T{ySYNmE7R?VVx?oAhYcg=;pov`wAH36)T}=`g~v@@P*-
zLcW~?<uJAh3{+{C2H%==!l}Y2wGaV~3BTO0iey-%-3U{7OnPP%+gN)X0PAH5p9jox
z3}>#PHc-DOK*x?L?=@x?gRA3knPo#<E4lFZ#?Fzmr-q#KALMiC`_tqIJGaXYT%5qZ
z1$|Y<X~!yPYHCJ>@Aq!#X5QCOwgn_g{ulpPXbL>nVBTjk-X-13Lsy{QU>zcKzEs;W
za{M~BtMoQ0uX>GaiAWE~l=K~=kH!8fk#anJ?9;g})=2pXjruvgi}9cM&97@|_$3U}
zhV60b$qgIx-&y)plK`35j%Bi=MQBfD(KSFAhpPqVteIMn{i*czJj|xQ?))l9SC9VE
zlcATwai>g75>27}f56fI$qD@L<v{=UKV*S06hlW}ovqDXe`SL=+ofP^)%$0hXDHkA
zh_Ui<HRDb0G4VK^7^hRrJjBq-8Se}6MIIb51GY!Xphum-f?C~&$sL^Tt0(<d3)<&(
zKHcvMkRoG*onO$Lk~8IoNio4^Zh99>ODR>FwRx>ZerP2Gimcl@Ss||hqpgj8RJ9*Z
z6`0*9y>P@vTc@0eTqf@q7}Y!1J0WB-5F5{|yQ^ap;cK5vq@c|>XpZ)@Ja%wsWzDKl
z$?_TJxfdDUua*Z))~%62S^t{QLq@-t*UQ6m<7=NJ$NuuiV!rHqanjhx=5vBYhu|QF
zQm>gOSEf~V!wxMfD^~w%Dx&?*xpzZ+w9viZd`kU)djH#h<y`z1CX|ynTDc@0mw7KK
zv=S&U*XB1GAV_3E5`4v+92WO{|E=b{XP2Kku>PGw0)6d`7M4obT{UkaRnc<6n}W?n
z<KpR-oMRcK_{ggQWN>;YrqA_6)-lSM$P;&pR&Q`*WSSN&3hA=3!I=sSR**@2-?#zX
z=^QFaSnQ(e<RHYUWF(UHi(<>r|DRK60+Q6<4y8HD)WRj$#aUx~$1Jmlrv4>H^0j3_
z(eo<Pe49=^Vjp0L<qxTZ`J32e`GdxBuDa@$rKI7^{Pv4`4^qkoZCwO!asDte%5)h%
zjs2rc^-i{AD3l2o>W#v~e!S4`%o;#M`ceYzt95cMviJ3c^@%h(&)POnwL{x+_2#w*
z6Y*+aWbz|b78O#$Mvv&m-T`!fM6gE6Q&av~o}W}HtmLPej!Hpo<e)?tY{}Q2Zh7{~
zg&aNLfbvKy&I^cN%$Y*^YBD2O$WF-aU0a`S#L^k0DDMD5ue+yz(wpQ=eu7Rrh!Q_{
ztC7Zj6sX#r(?hy77=pt}#^_fy5b$+E%+;*%I!H}4Q-PnN`;RSk?GGZB*KLNN3Y5j8
zdBTFuUrC-#T1WFR0xZ|I;j+FW{BIVa$f1u?5xadKe&@4EPx*v7b5P$)x1SDxJ{3;j
zV#(5%HSSFRAo4T}i($-tjWbu@7;zp#O^I#98PuP3i7Th!FTirb=>MBL-kI{~eP;7}
z^-XJUvNRP7A3Zwe#ke&5p!U9-GE@q+Y)zVS?<RCN8^O=A?!+7O>TwkBSd6M3nVZAp
zmQr(d<bV%mYzk~7cQsg!c!gJyoA-4r-8OSs`T$2uU5)OlW_8f}1lps8%9qUdG*;u>
z$V-78J`C_$fNzSN2VY)I)N3lO4(R&#PQ+MLB`tlaQJ4L<h;A$b`ls0N@+&h9;)7S8
zE{C!G>Nc#J4BKXG74NCePiK<kR4HO?#utDZ!U4>?r0!&nmNHf1mnH8Gj0>59#mPIQ
zB7<)|?<cWiseZkz(j|J=HtEbxJE(Vtwp9Gz%f$cfuNL;#|E2~IPo!RX=wa1WV2?1E
zwU5iS#KcOMDtGu^TA<P+t=BD_?Wo*09Wlb6s-c!_#|eE28&QjY;>0Afed2rg`7i@a
z3irN>iTd=+R8@>oi0?k!X~KtiLB2o2{HHucjWv2V6XRnBoFxO!5CR2M%m6q?eNSXY
zjCMn|1w6?0G+D*@p)Q{cFndUJ)V03asAOn=YRKZweO-?*wzurR{R}u0H}VZsxHpEF
zuEGCY&!(qh0~-IS1D*hUfqZU4y68`#x{pQZs(Ez5{XY}HxO~gZG67k|84FE5MzKrB
zNRG^^v`z9e$fehoak^?jX+x&`^h~Sq0}Cz|78sz%C04+-9w}1y#2bCYl-uq|e2jpW
zl0aJWOFs`T&+GMt)y;C*`^f_;LoufKlq8;9uC5Es-3c?w`bO=e_@8Is+H@@^9+{iF
zf}jFq2sbtcd{*ie?8QNry3mIJEAQB&v_@PpoP0(idB1*BZg(s>?}tqtjiZ_yv%s&e
zU%N^0(^2Z$+kg!3PMVsr>GqL(qY|fzkWlz0e}y+$w~l8|KJs^sK&aN|m;9?;E5eDU
zLLJwyn3jTS;&t+zWHy4_3Y`$omw9Zd+>iOj{<>STMdkU(k)vU!N#eivUq0JYK71`~
zotbMpY`P(hB_z_cXs*EkHs$E_EVSMd-SeOgSs&vzcgZi~_|<E-b8vqM9gB7Jz^M(n
zEK$xzxd|i4f$y$aj8)zD{F)=0+GD?6LO?NuuNyT=jU)~L`;NycE&np9BPv7E(3#Xd
zm^e*09mnZIEZ<XW&fOxc#WGErYl035iLk$k;lGvjco|Ei<)1Z`B|(fg4WlxXLy9Xf
ziz#Yfyln{x4h1;meG<r`#AbCLS*oQqmnteEF5;B%k?H+Vw#8`ssN%WgHCqoNr=xx!
z_W~Q&|GJ@Lb&Gt^SIqwK;#fa6w<KL{>8=u-Xtweerm8*r-cc`yPo=nT@98brHDyqd
z(1#1Y_H$hYoSo4?R7+Y@^`%SBw;_;XGOw>Siy^a{ug+KM=d<L4@s(hH`+kF%2!R7T
zvRwY<LT4t-wl2m=cAD7LSyNmda2%DQec;^6FJ9_0=zT-=->;@mLH(YfY43M?lUq%^
zF_TKUYVmBHKL_oNj9T7{MbI-;vh|O3t`2Ct8#jF%vp&yp5**Lu;Pe@RZ^*1P?-nZQ
zIwNd9_UysvFr=iz`$OJn!5gtsKZR++x(N3fH-kD%xDHI5p?sBvN_pVPb3HweOoyd0
z+*Qo>t9m+kdO;+-SXU*w2&e)+;`zg$N}oKM9|=cFe2?U*z}L4BK`-j)0r@|W)k}dC
zg7l1ig3Vtq&rYt_UN8K;zA94Eks$a7vR9JVkOL}wbK*v@7X@@k?6jt3?JrUs3@mJx
zOV$B*@y*^?czE0*^JQxm%%J#@$BO*uz&5IyzZIBJD;J(eunWhxK}dBR-WX4iLSKN7
ziHzj<<5P_LIPC?Hte)}tGYPpY{t9cf+)LXC6$dzLs{JXo$pg_%`qigOltOsT3-H>w
zvTeM}^p(xnL{W~cc_cT=Xrtlb-v1wXSS>OYXbq?0(AmnX|J4%02Fhl;cqd^Q%|JqQ
z%K}uw0SGMCMZfI`c(sc2Yp>a-T$c^ohjh+Y%`eHPx}71kos;ly;gz*r9Mn3BzYkt{
zJ_3~L-45SspS4dM*&dmgq%mQdeDT9mN&9^r`;-mWJ26cO6rLEKH#pAw2Yw?qF*DH(
zc1r!$Mw))>>};s&EhLQGKN6#kubCRr^a5~0^)H5+sA}Yw?J^SWru<g#N9^5Eh)!3Y
zch9JW*vuX6^@<D1&5S86;if}K>y?&V6xsQXiq6oQW2j@P0~Bk1MK&V($&*}BtYEoD
zaFFj=IRR1T_fd%sZFsFLtA`{LKQ3ay2JeT4qm&DVT&*inAqk9SVn(@K*W5tLI!ec{
zZRDp8;qFiRFGWupqBV}wOYWQHW;)3r_r1y14$PsBCv3m-w2$OtV#W>#ck*Purcr#w
zF1tuK@c{Ly1}o}Bjy<iZjNBZO%^4G1HhRygZG;CL_)zA-c)fj*o=bN79P&wDI#8WA
zj2h@5cRVK_S~Q+OTD6sqI=5%IeTn7OL_Oc|=IZ(m^Y@W%zb-dvvYm0kg36zv$f@m+
zqyeUj=wX|x(ndYyOu>D8#6~6k3uBXWi2Z2mb$bW#y?k0KiCYm#Nxt6kG&@wRV1t%4
zC4Z7V|Di%S+of!d{%Vz6eqXQv3r{E})_!yb4ia}LVy60zl$`H)0S=Lq+F8oBAoxm6
z%zQA~S!eMGo7g;2IZhBWTLhe~?IhBEVLNUuVbpC>8sQ5uWD<_vNXAf<@muNj^?+E6
zr}07HWKZ12aHJZ8&uu|+x*NuXmw<P5qDi|9<jHDT?>z!Z7Mf8y8l?O7lSgYpt*b##
z#NM;L4Fy55KC1;EFL}}bEWujMm(aPyVRSj-XZW7cFHS;W%10LB-*IZ01e*+H_enim
zvR1vc1ZHbvL*=sdDy@zl%H0|7o#@>Y{o`F?dH^_qxj*Rn^iI6&&`FyYLybcR^IlV)
zm0Bh2n*GK~)PQ&w*rlJ$n36Fu_iK>q-E)w)WnF#U&Aa5CpAL;}gY)#ge}ue7$TRZh
zbuJu*fxx|bq=jLu{c1Wsv18O{Tc;C+(ob@>XPQ>DlZjuzCEFeQ>`V4JQ2405SQ-~;
z_5#n;XYR>3hq6W!I&)eb4W)7a|9T50!HB8Oc)WDMb!FRxj*s^^Q7!(3D@}xHXb4E{
z<3(<lBp9l$?7Q<bC&Z8<C_lQjF@L&D?-9qeuT23AD|TQ*n@?u-REPLs^r;!?^YYb}
zJbxB3wZxd`bJ7po|KbGgQ+&Mn+y7<N*-thZ4(utP!RPlqrAbm;U{@TJcO7)BW%7Fk
zm?hr2&qE8`1v*Qc(42$L`cx#E(`$K=izfJozNG9$lh{<u`e3tL3N}}L^5}^$jz{p`
z3TTUCk2Jvn@L<3huBBO|hm~iHpdG!RJFy>x56hOJZQ1uL(g2^i#U?pshEhVs0{?~&
z6s|b_i{@*&f48Lxp7s-iHDtb`SkhBah7XyQ<9&h=@lqx8yK4vXQw<RGf!ykg?Bkp2
zSA)f?<!Mun<*(#R4-sr0xOja`%lHfqMwbhU<vv)=^?rD}*Q}7e6#_m($Zi+f{cUB!
z<<OLUMe$ej2gEqq5XxQ)`<^s+Z%lJ`A2udL753g`>*7hx8+%f?3=QEhQpSd%29c0L
zfkO4;zm9qI9BE|6Qysm#E@oo}(GMLom375+;N>%(oDVL)5uckE0&Y<%Q%a%aH}+S$
zB|3c?mjv2oXF8+z>!*1sw%lZtrbwCJ4w{kTdDvM{ntXj#dx>^5o^OA)VHMLYt+&)p
zz{$`P<wmt_F3#y+w=KMvgW-)hSkhFu;J$z6>vOo#0Zy#&D+r-ozOiiz#+N^+UnlIv
zpz2xxYi%W?nisMoE93cl#1Bo(3c^0ZLkHuvtELU$aaDA%cC(_UHypzY#xv~Q13K$0
zeG!hl0qf;frOHbe1llx>HaJ;xJu6xPh`X?C!KBp_VFSip>H`yu40|f?Xck&iJ0Gqd
zd|%EijChaJKTmlv`NAj;n9=#zOjX!-lY~h*iUqxCw*XOwwnaT-&w^E#!nSZqcKzn+
zP`w%2g9+~+1d?h&2YU^C;H?uGdi+<mW2F${R#Y$dZw?<1zTtpMgYL>`=>v+?o=S@{
zQ039ca_Z1ehazQSdAfBycSnZ;L~$?N<?u+de}(nxz=Y;>*e<m}oMCu39l(4!YX+Ov
zmz~U^Hk52cNFGuLoIDbqk@joW?0y9F4Fy6~aG<xuG}Vr~Cme1&!5d~TR9`P<<!_T~
z9Nio)+Om$78B5d$n)if@XLwE`pWN?z5!5rJ38i>&Q07WWBJt|tZ}${+W)3QFVzg=D
z7R4l=ipD7FUK*zo?lUONuHeppV?RTbYpwk~I2xPBu-V1>uaJbaHYQ=<5NT<Hc)(^3
za`jQRov5a(GyQ-(8*}@s32Je&qF4BB=D$PO_&^tN^JF4pKy94;(GpAE!3jpD0k18n
zIX&xU6#jxnf6U`Bn&IrJb(?a#F38GN;g}$+h#Tyo)Y(V33wNE=H%1Xhg<HNz;P*6Q
z)#!T)3hf~YO9gckLdz}7>|sx$8#04Kn-|?l#V$2s^U0EfxwHDT=Nv%8k>Kn_bj;EU
zJs05Y&e$-9DH#A~m5iKP@M3Z~ec?FzPGf2F!=Ca<)KsW|zg%5`zlo?u{G*+1jeEnv
zX(SuK_gG{Nhgfp!y9_Wpc8BLZlN(~8sXm%N$$-fzTaUIqG(_#bXAq-}4lDJLlatYp
z6HA@;v`I7<)<&aWHuIcIv7M+GU1sDOHoTspCo&I7iqBX<EX#7fP>)$uf+2{hi5@O?
z&QAOyue1RYTaspOaq%c(M&|b+X~#z&yy>foB$<O%9QpUQELU^DTm|_KHazTSLu>=G
zBivSx8r?{e%3q4|!51^UDM)1dyy&!tvyuA)?}<DiPux=_$8n4)KMc(>re-|#+`2nJ
zXJJl*{Le*T*?Qgn4hPGIm1>vzMQtm3N?hk6zw=11xZbf;)`mCxxZsGF>%N`Q+?z2g
zsTnf<upuf7X%4I?4B42Z0*fE6*o4303(#>|W*A$Zw9G5#mwd(9`Wo0scgK>e;UP$$
zgmJcz%wNYHxb#!fM_LL|UmxjUuix>fkztQS+99Tqx9~&mn~xr=b5c4u(Ij^F1ohtH
zXt+37UnNnH)Ct%s$BckoRbQ}wTk^hoqSvLB^HSX4B8U&Bvkl6O%Icb#xD?uDAcfz7
zYf*NnA^YfV2Dc8`9|L5K`Gb$+m-CP=th5Tkq#gLn=a2ieJM6w;h(A578p$?u`8jEN
zXOlDi_zKBVqdv8!<&H>P!{cPvx%-fA7`B{cM8pEizC6f72U8ieK!EG429bOylCCbf
zdieTvyIR%|p|5O?TFglS_5DY-&si-y*Dexd?k0Bq&U#!+&69XFy0&CD7IcCkm3BTK
z=!l}!iWs`&CofbzU;t6h@%xp=XX!D+aZNSR8R~>tbA?N8KSgRCWFy~S<&gVReaAcd
zJft9YwiTSI+I8Gj*r$UpY{WzJ6_*`lR}k<raLQoe_OnW)3;avBfkbtbBonduf)$S7
zgXCD7ax@u5vN%jO-g90{cHyL(cSo99m0`){F;fw5dM;f=SE+|r!nVs&1A8Ry`OPIA
z``ia&Eh>N)f7D`nju|RDytsMRScV~I@GrT`HnX3k_@|tAot#DvBpX$xs>%Mc2d&-9
zv|g3C_lN5s`||WzefYsfR;b)pOlkYzZ3shNpIa32b2qR!`Q7EM^-~EPMA5L+%4dTQ
zr0R#?dQVuw?lERu9#^0J`LE3A(3=1%w1jHdmXk8fnVth$&MMwLW=sE^?G1F;6AI9+
z$~hihI;R)Iine|~U1%<pU#l6&Q|NVP5~JzV{}P=Q6_sG<`;9BMI$QTowpQ<`AWwT-
zjcl~T_oM5%OI=J83<g5FR%`L@d5IV$jBLh%Uysiu@5k(`N4|5%*kT5wjpx%vF%5|U
zUaV<2lLr`M8=IhZ$6?p9WgZ2F-^p%S1lzX&c>j;J#Ya%iu~U!T`7F~!Kt;R!a3Vo(
zuDqx`N%(!s$J(P8<e9XHg}=*@Lrq;98FqE$GPsDuD3&ARwODI+xt#polta!sbj1iI
zCSGEGfYRDvW*4L~3@M}YhDQw0W6}?hKo(lTEcYSvc`>5p@i!@SfL=ko-s@PHECA9V
z1a1chl7Y={UB`v1YXhGFQz8&4Lpx!&x!bqjV#ox?VZ_tGg7zRsbIhODL_$n(V+!rz
z$6KfmpNO(z$R{Tkl-r&nWNx*|anowl#rJH}d@Fzq-&HU!3btB&nt5({0cW8)_-9MK
z_W@{=(ye)j7>?BQ67S9B7!-LSI^WLdg|7q>d9^#`-~BSM74u@du85{?wJH1!Jne4c
zeez(1?p*B+)!agD==mfd4=dd#+M4Nl=om2Ux@PARCV)zXb*iC68$zA#81Fr{N$t&D
z9&OF%-3rPC;Iw6ShTuJfP5dCkn-|c9y#%BZ7utPd-l6q7xzW=(dsE-0&6Oxp)8*$H
zP;&EF9lBub$aso($h=L%x^TsFvDI)F8Vx$oLY|zRW(0M1Q8?)PJ!UoeJ)m5gd_?Bw
zHfoZ7=RSx{m9$7YpXrhSaf@_av#}$eRjg2@?{gjas3#%Ry7OXX+y}qek1rzE7tyxQ
zx3~7I25H`eyQl6^trAw<$MnJr#CK{=8UEq3v;DJR*mR%Opz+g#PM#QCuYo7B1?9Jv
zA<&w1hYq3e!U549m$o~u{vT2Mr<mDE82z#PdNuV4?M&OuzK5EGqg}xv%#@p?S2I$P
z@Jx=QjCti!oz?_rrt6}VS+!eA{Ls>pieQ>U?Bg5C3mrc{?*dCicR$dqs&Q;RP({Bs
zgN%6=M*ZG$<psXI5pn6vGu~iZ2?w5ReXf-U{l6xS&$-e7XFImo4;7Z7^;0dI{)^@f
zW}>9hvJ5S90#QrWQ%Btb)lMpatut<3_J*r>-@{2<AN-Rp9W&y2@HgEsUKK<l`l5|n
zLM4!kGt>dsB~(t$bS(J;&zOCO?Y_Ty!WLh=vH`=aKPRN^&&l*ehMuS{{@*aj|C8xB
zy5l-x1r8hPo{J<e^=6ZJNZMN!(48Va*??r}`1|QM_epFiuV8>}<%01270NFC5m&!+
z5Gt<51XpTn%sRr%+byOrl<Y%$`VZaZoifjuG5f{UFc+%RQyehJu-#nsD-~e&uM-#1
zDyv+yu(sPioFls&2P$qI_@;PjWWDz{?c0F({1ze5u&{C8gM`h;lMarSh6h7sH47bg
z(*B_V6StJSqY~zB-45WaLpwfjt9lEN0qfRLo8jugzV+?i{yX!95Ey3;l}*?fT{-kO
z2MmA8YlwqN9&`(tegq5~`9qu#`7%wS&P2Vu*In}NVpa9%pPGfCssCunbA$0spV~dc
zKxex*XD?BT94<8NhG9_)T>!=mi+}$s07?H-0Q_)URNY4$@xwbQI!sNJwu5)pgSmK;
z9$LeSTK<5nes7d!{LOilk0-o5b1%Dmn@a^*?pAY9yD@^pE3b(2%#MCOz0htn>)`R1
z4-s)|=6WP_F|<67w@F+juGx5w<5osjGsE~zeF@$XYPS7OO?!Ip<A`=jmM<07*3*WE
z8?59@R}<v5hT$gVeX4^=y(G}hE)#7k&P0mH?3Cjhqp2+q8fv}|JeZT}!NLA}cd&&e
zAySSo;un$grqM@jh_rn{_LRsOdOt6mUIk{Sam`Q(m7mc4?qu_ra;KZ`wL^7JxX$%Z
z6|`*SqLf#yoNo5y(D@Rku2&QcUQ+~ETS)L*6+#Gj==bufxMBAblh;PYflkdKv>!B`
za2AM!PiOIB#X+0d*e}-K%*`8g`!CG14bO_6oGp#qZu;KxNLhXHW-ZrA313}JAWlR_
zkiTIMGwAfnk5I1-c_P0B0d9!-?-2uZ(|?BgY(d~Jc`|w#fc+wwmqr<!E$TX1f_vFx
z@`=OnaKh0EOT6{>WRi6uN!w=z1w3bPkfZ>FdvgIwU7BK%7|Z1+yb0}>zudCHSogxC
z800PPsak-RE_4}Y6fMD#iE#Sokxs}V9K=Q}wAsS}=#nW5sh)CjkP6i}HAuV+rFt7V
z@RH%XPNv2((_#uI^I=F9;VhetPJ&P4qU_6qsn(Qh#$u`>dA!6?jsx?utIITsIo@**
z4Xv8S-#N$B2DL#tCN$57Q;=*WLYzUW_+>sRV*_OYgrIr)gJYC`{nvJaL;<jslMP4M
zqB?L(0~1lCPM=LR>W4ba0|K`o_ebl5_EWly@jN=FUj7+2W3`PD4>gYga16T$spO5J
z4$Kz9q@Y)ox%2xbH<C0V2g@H_Ncw~6ZQspuZQ|9yE#hOgcoqBCZray{ou5DaH}@el
zmG8;(uMF@j46ry5%U_>@YfpX<WcY=eJu|D>1IJ5FBKJgVRyLAXl?-VKT}$*9f;xA*
z_I|n?IZ6Af8`mK>dh5?4TF*jOMMP;`vXQpg?|8mxPUm32iH<!0hQ+7E#UECu>!HIK
zbyO2IZI13X<D$#7)=^47>h$@^q7I}FZAY)(23Tn=B?GojyRItmXJ~zn;T5xB%a_BR
zi`$;U61HOM8%G!Mz+rT_Yq2yCFu<NHnVglW+fmPiqAz!ee6)7kkK1faGKZCYTJJc`
zgaIXs5(8KhmZT958#p2E7tlI=1V=*-;c)l+@8k$st?ToZe+&lcKL#V-G9RtZiqn^k
zR+5fLo-(b;elBOOZtOU`<SY|HUsZL|LpE+3S-AJ&(QNG%G2M|0j$i0fNev0XkeSmp
zL5G2&$8)3XUW-V3QPYw~Up&so@j;UuCznm~V$I<hS_IdGOsd<Uc@v{c!N)h~wtky@
z>Sp{Gl?XU{>7%v9I+ltp0H_c_p)a;wt_HaC(NHYfEZZJ1tm}5>o#}Z+Dkp+YGUp3Z
zgl`PrZ!9bMeKe6|L}!^p5(V9Nj2u5LogfbitrHxU9}Me*&J|K3RpN%k5t?*uBO-9o
zd#d!9D@Q^qoV_$a1%}zw2VN4yeJ9<f6NDC#^RDZ&oQ|kOL5YJbIfJJ0G+(w+{U<w!
zkALYKrBBQysuy3&=3^%YnKZ!&*{4##?4$w!{9A`}r9rFM?z`G4#h^RXKXJRs0oh>F
z&~d7et^{}Mic%D8w6MUkG#%e~<YP!|yarOHt$kiLBg@;GG?0Jd7yPUJXlX{aZKVCM
zItrY%`4wx>@iO>}j;hk}hAFWN5R0D8Nr=fYFsNhfY2x&g3EJszeU34N?d)|;)l90x
zF6ezSLuGd2nc3YV;Fk2gGUukjw?HORUNIuxA}~zg@o}NMr4z@2WmA=4?jzTG>ocyP
zQx>b8%R))pjptYJ!Wev>z|K}2qBvqL920>ql&ZHae8UpSX*uJgl<3)b(mnx39FQUg
z&CEgp=Xt#LZ$0RNTM68N{T;ER?Ig6#<`cqUS=25$;{Hw>oc+-aKfX@~c8w319sRXZ
zy{Hb@qAWIpxg@ByiAni`r2tUxYcu^+vbTeSDnfK+Y{o3PgW-Th{e_MJgG3h0Y^K+*
z&)EJ8Qvjv7lBE!oY!A|-DM-3hsWt_yu0*7Z#mM_JwGNh2R3q(__|QDssv%ZT2B0jB
z2Y9P*=<&hFtWsxW+le>vp|%#XX)Uc#K0qN|OM$f|YqI&g92A*m=AzF%zK=(Y*m(X+
zbp69r;iuDb0rIC^ai8cncaQaTT@#u{(NlYH2GL@{Z)uxqy%c^&`l49bmr?!9Ug4+Z
z5NKM&)<rJ2;~t;_TNs!nX=TEjed;F&v_5qq`z#hKm;yMJFe9Iy<3|5#XpsU4diuD}
zSK8Q1#$K7e<8X{&2%NpSk<_2;_f`)B(R4L~)(k}#4{+q{T24>(wSCf}z01G=z%>BY
z3M98CqtvO_)eqNe6C<d(MY-CT6pb%t=yOBN?8~Q+Ol@2!Q|y7)yMJ5$^}qWBwbQpZ
zV0e@3h>0lqhWc9pAJF`W)A%-Cy9(!cSQgQb0byJ^_qd^?&vuR%yE)kHoQ-=pQv8e=
z-L+#(rYudtg11I2vR5}aO7*|Zrt6=bT@AlyI0{H1s*gj2zMwiEvHvPr?;a@v-`3Ha
zZc74NxHAFJq3eW?(K-d;aHHIhC1T>oi%9||GHK5ehVU6`bVvhL*{6<fLbA++1Ql|R
zIQJ;*mj$HI*Hp|4a6|ccz?uJCO=Ma~F9zUjWe1G#>pT$zcu_nY%|5Z5HxR9ER;o&F
zH6SgpXe%SaGiz&E^&|Lm0Je3I160ZF{Z{d}T>tGv$Fc>MN4k^?@pj|PKGHv$Ri<{E
zwHECxt^H(M`zhl!#<en*1*kg%3t={?J*ezH8Yi)I$+~vR+<QX35z7VSPoX&L{dn)V
zN<Fe)6QfWX>|npQY~K_keK@fe&Zi}15bfz3o2~&!-c<47@7fH^vV->QLW7OZf4tP*
zQh(%L#_p4nLkB-yatWI|JOyR1UUiZqissRNeMX5`)BDoW=tI#P@^9-#%^7P-0W3Ro
z$Z59UzV-4d7b<JJ*3;cJ-NM8B-^OXP9SV5h64C2$FjLW09Gq}usgd#tfvwmLe4UY&
zxUP?CjY#iQC;RloQw3+jbOew+l?6r^CQG2*%vRz-!;})~{8f!WB}HJr61J=gN)_xI
zhMjK5;H1Di-?$AZdHMOa%Z(<*CiGwkWwN*IEK_H^!}#A`!&jJ@@&Q3h<w~c5M>F7W
z%?@ZPee+5WVmCLiu)s(g-Sth1Y)N<2INnJ(bp%_T`$N3(>ZWkNF!LF2qUs7E-{mON
zg~V6;kg?S~PlD*As}$&PJMd4cge_-b81ACDr8HZn)SAxMj>o*&fFZ0PK_644J}!@R
zz)C2V+haaoT8fkp5RalJEzB6b05T9%<H>;Lt4VO$z)&ox{Pp(Z<ZhZu_Y)Ezu^8?f
zz|H<G;jnO|V#9R*bI70mIeJjG|A|Zg0AGsG-H$2`fI-g)FclFeT6Ak-B!GU4-dzhd
zz6RWMe?@Az6f0|l6&+FPFvPo=KJFVSe`8)%r9qa)Scr?FCjW<_F$tdmm;X8=Sz~g1
zpyfz<6q~Uc^XzscD|s~YQ@Vhu(N->ZtUP^2cb8y=Z7!bup}x^ao!gUM%l$(o$?u=d
zp(BUNW7~^Jey_^fz{mDue#6rVT&~&Zd?qO~oTYwLY-=IWfoOgN=zOyWWq?<~B;<P^
zdVMvxq@Noha<sGrHtSclA^VnCIhW?==9NDQI_z^ZG!S4}Pw7JDi<X#-GUPj6cWg|^
zEgu}n%-O`gf(R;J8;84GQ7&l^BVc()vEXdGKYTvU+jJO+q9gfsKsKLAZoJj;Mj?~g
zh@8@oBbB`k^tIr3Yom_-QHK&*qE&`N2qXb{HT1E18(^@qqPb$tduQENSNimK`n45A
z+S|zuMFD&_2AusAXGRk#QgD3y(JIbu{8jU*x9#3St9An81w@0pqczPtbqW>NVd~PR
zQlrDX1^-&q2hV}sWMG$tO?Scl?5m^8v`lH9h;7aGrz}RprW{@E$7t%FQETge<2;Am
zfYNKAR;I;6k=Z~6ZxXymBt)S?WX>i+q6!6CUF(t6PBL%03>H4FV^i}oS42Bjg_bYp
z_yycHhCNE*&$pAMQSO-y%BgwQy(;bJULA;B=QpS(n!NP|+(e6~V9Dc|cGmY;o?hKq
zlDU6e8M{k1cGXP6PTa&qWGc?i1ObNKw*hw+7A+`G4?MHd+U+^|bx$1BDpDlb$xTzQ
z`9r$6Q;c7kkLxuXcAmDQ8-J7$@9=e#QTN0y&D`A2C0I@*sVkE+s8o)$dv3d2BJE^F
z#(`#k6g~dHz3!(vxdC@ifm=74SX;DyFF3dLF!_r&oZB|c{Z6ijH=Wq1jiowJVaEb1
zPA!L~bOTHSb?~|(;>1Os1Ogq|H~ZgbX{gVa{~p{3U4N_pZyY?jUEpHENC6DEAte<R
z=DB`mW<fkCt*jN;*{grOBpuWZhGwl=mnK(e1kB!gL|hwI5fO6rsRyY^G&nE?XC5R>
zqi>Eh=(897HYsx72n8ymuS%o4qGB8{5sbrpf-i|zGqO<V1K-YVdAXv2cHq{}S6E``
z!@kkeP=;(A25Q3Lc#PPM$e+2_wJF`V*EW_tkNt_7=$_w4O#o-dk7}yWoh|8v6IEwR
zgkP;(O~7AARQBvyb3eP(Y_Qbzfg{?4_3&AI0WJ#qPip;Dp`3`zmni3<bxMmLXwHtm
zAN`m_Pa;HudjNbf%)jZl@5WgBIx_N7_2Zc{xH!$eFitl(s1NRE*s0GIrp;!jb3>tz
z930l1#B)czgRDbJt!J2nliMeJFlTINg6wH33Fp1HXOUY(F%^HiF`(5MB97pNj-N9W
zC>y@09<E3!?fXDv{bkAEVa(_oh=-o7CTPj31YP&3iuqYB(Fs>~=r`|hMfr3DP%&Q*
zaM-hwh=-vQdHE!;p$|iOkvf~dcfSCJDT$b#tR%n8=&Ub(z{k6n^{JIJ=JZCpM=?nD
z(SI**?n*JIXHu>bvYl(sD$;K!2)ugfcYTf{hr!r^USSVV#ig{aX0;FO5g~L}`+xB5
z6L9d6mV!yLL0JtKlpE3pI_~!f^$W3k&Z!QqQ$4`^rdGquuI1gAylVZG64>xWyByF!
z5mfi6Q8l8yIB9T@f3le*z&fz#U0_kIwEUDa16=~Y!8e>W;g|7V-K*w_kSr>C@ag){
z`kB*qi6G^+HEN+2yRlNQ$Iz%dV;{t?h1J7Qi7mDxgZ8smpsF!iaTNCbrb=EO`9cR5
zS=!Z5L=kbdKS4ivnvUPH`+}BZ834Gup-oiOdW;R-OqP47oVh}8F_g-IWAeO%>__F*
zRHdp|*0zgXlQ2U6nf>9$>mP3_Qx@9wj3hpdpU_Tzk@carG1e(wiq*b!WJ5wT$S{Lr
znPUH7ca!Nz`V($`F>Ki8$~NReKYrp(1Hc=!SJERt?^*;t0k%Ro_DU)725a!zc849}
zm>27h8(yU{UfvT<@VFFL6;8Ojm;RS%{xfie6nNG9vh}L{vf%K)zHR6^RzeK`|Ew(U
z;^NY^Z&}m!;g8m>tb@U-7N*}@+;n2V&0o>xAvq?=Ik3&Z-N`)=0Ab(+yi|D&;ZHT*
zzsDm(FlqqN>ztvqa{^Ph9xz*AEI`1&2k7-{I$+=u0~*=oOoExMVe<jq0CP9`kMm#X
zv+=<Mq&105U%+K@3+?u`;s}HJ!nQYL!{80u<AsGFPBrwsan@7u+-BndsdNSNZIC4?
zkoPu%`mIZi&(oj`{kuG8`h>g~dP2zZ4HZdPQ|P)X^`VLjwQJcGQ(#4>CUt3NmI;S(
z_v;7Nodg0OSkm;L_wn(ln=WTn11AP?se#LNIYvO8MP%!WY!Ewy$sg_)GFbOgRIJ&!
zX}<GaTZL|&wmarQZX{aLDx_}=fW3&l6o$q_*AbV_f;zS)7k8a%*W|KZb_Coi3={Pa
z(F2WAH42>T^sV~G9EnVl%BZw6(QVtkln@>iP;1QP>U<P?;hw*#0VO^+hiv6<Zh4=`
zOkae_n>(~}r@h$LP(Xk@I4r5;1i%UEa~`9>KQsy~kB)t?2JIgi8Q#%Wm(}+;vj<Zy
zTcycJI(?RXc#}@37iarG;4Mjp*pL}9fsn`rX%G3TLZ@QPcUhn0)%Q0`izWN-w}!<7
zB!SSm&p7u|TVb}V;)Sl$OTuqtDkNG@xjm1AMrAfCF$oLsWc>l9uK+GW5EB(2@VD*z
zT~^+KhOKJaALxkiUM<IGXV#<JNn~VTor{^rmt9*V<NHF<D{pN}J(nE2ONFW0yB#><
zN-8yLlmU?V?x{~XWskcRh|@|cBJB@FhpSGm?K<Sb&AtZ_v|8ii6$}k~BBRCiEkq-q
zp}G@zTTeMUzIrw<vY=Puzi&y4%k<M(1!Wee6@-kk&EOQ(*mf?ZxFF<fF-F!-cR0e*
zWX-Nd5-1)ZZfMYoTb%Zt&O62U#HjjXjox<lfcowmG7QqJ!1*(b&D>9!nnrZI{zb<0
zKNFs&v!g{?Pzo8C_0<rMcMS|s#~!cf$smOcA!q0}@>~}k>@v_{*wpObIC6m7`&k0&
z<~tmU$6xIsOG|pf0pZNAW$R>+d?f^4!Aog9Q@?r=lP^OaIj5Uz?%|J6YNE{{{u@o~
z*pHk37%<zHpkr2={7p5^Oph;>0L|aNMRUe2rGVkX!7L`c-@JtA>zyrx$l(w;mC3bG
zWe6#k8B|1A7jjJ~0VP8uww?-MMVd%TbMb5wqxZ)ET(lY-8!8ng@7Ze>ylr`s%J1|E
z;|xY=<a6^>?9kTbRVH!hGT`orUMkgSLo@OA+UW?l%>Ci+b9UsvrSX5ktoM(NW>!vG
z8CBWp=(~E6vO2df&F_7v*1g$55aW57zdxrceuBDl{s~2X)t`|Nf`;XJZ~LgV%4?i0
z=<2U$Nr+E$i`^SG`)p{mA_*3Tg;&ZSpsyxF#SO&Ksn$!emo`6i-{{EP3RyOo1wZ#!
z{^@~bw1(`dxY@Jn!{rKXUA(JDgDG`50w&WEU&7x7HXoXX7~B2wC;D^3QFLHyQvO>0
zr?^5atPZA4?iY$l0=c{Jg3}g_c-DA#(9En@`H*q0UmAJG!v@Tz@v_)nWZ(2PJ`p~r
zl%HZj>pP|G0++O`QhB->V#c=FQSZ}##C12GH?K@Ca7=EG>Q$q|uOi=^>-yBxh0%E9
z%=aH|y=_DTKgfB(y(T;zn83=W)oPe<bbYmK`+OsTexa)-P3ZDj7Uz~PAyd&Glg`C}
zf_rz{J^d^RsLS`^9@9`ckBFEqCbOq;ZFH?q_T~-ddgt026*4`i70p^u?pMpl!Ni1*
zmny54trv1n?MW_oFy1yZfl`NnKADgu+<jM)Hg|90lQB$*=Ypw^W=K9pwzyFkE%F=J
ziz$umhc526ePCLmy^JfY)MQ62a3t8e-jHAy{ImiyWgfRmSuYLdrPb6LbX0B-hh&a_
zY#Wmm__iPjf(1?n|E}LBoX^AjU1_Wikfw|^+wU&}QVN`1N;rwcKDalArG;FOY`T+<
zcXXPCgD3gZyJ<jURw>;Cfj$23hgQ)c*qDzGQqEVc{nzV3!wp!Js^E6b{^Im}MGs<!
zP;W>0ZcS-vsMIy2iq5xALc~?Lv~^ehF+E~RVd&@)L;CJ`o~#0r;#>RGlS#{<t7mmY
zAIqaO`0ZD^>?tI*0-D;fG`M2cXCBK+NCi!N#?*vGOs|~IxB#>38Bm+&VmoYD{ON=&
z2j!;2wnDz(tU|c2y_@FY`S9AQQJUu*#dL<(lZS@IwjG}Twn9qC{+l=X3iInECON(#
z^VEoFl>aF{k9^1_&@~CCE;VN`{!a^IXi%;H$+c#-+k+z``Vi0$fPl$x17zyM++|;3
zZG~f;q1{LLKiC0=Q<!J~c8J9l+fBsSUt#5Lu|gobnp&PWeQWB-XILbL0zm)5Q?(kx
zU1|AOMnBW2!5tS3e|ugi=1%Y6v@se&cl7Bu<#5|(|11wS8$9!Cgjz?&zsM{D=}aG&
zLo!P0GaNl@DX3KI2x#r3<(o(t@>TBmGdORzMC+)BIo>uAWu6Gj1&ew`9~uA?@gULf
zXDI3Pb}Q0VKNx@e{En$>Mfy3`yA*(H#o|#T=b;c48k`YYaZCz<Rl9}Kxos5Bw}r}0
z`d-5*94C5I6mqousBT%gAxv5F!s=9Sy$Lg%DYYH;Oa&GN>9dV8yOn{G``F4_*l+Ji
zBY~V+w^=z_3!PbRSD*JX+ta8PR7NK{J$8xE3Cv5Tm9f94xtQ?5kUwI975oC<83U7G
zbr)lK66BfPD=TTLUO2Sk&EE<S#rP>x;imR)Ze?4|6uP5nXAS7;%pkM{Q%Co^hh~Gw
z0QOV8J#&YZa)qRlgEcR)A^P;?EMr$o!e+^*!3E_(0!=scyY*5%!We00khMTq+qY-^
z0u3STfz2NSfcinS&Yd#kbgpkZSdtDJ-BbYl#PkOa-$r?tynY6N7`_u>299ROJ4?IK
zZcZ(9I*-SW8<RC^5mraIvNZu2;^`Rb#+@a9Dpy<8fMfSbbo2{KxQCAK{$DSE&-z{H
zphlt9gPgSH2-d!l3@;`E^!;B$fe@KdOGvG*60heO`Uzq}ELhiCUr4E7ome!uS|$J>
z0h7H1Z?~2FLIH5s4jctTh<-Pvlb;`>NYSIYa{(uZDRB1g87i;7((2LukFAohYD-j@
z6vSFfglnpB`s3KTr@6)A*h^~tr4{16Aks&9kv-aOC5Cj_9->)9;isqtYW{KXXJ1*+
zZYl9=c?g~N*3F!)>78N9I;ORE3XzH2LX;G-TU3fwLlXb8#lnw)?SLt!4Nv>FzWzmJ
z3hg3?)eA#R<h+m#I2}`m@Kd0U{&SXPca~`fx}u(m!7z*1+kHYXhF|}X5=j|>u^B^;
zIo_3dVa!Wd*Vm>NKY!>-dD()J5D&BS6KG3=VoO8#$21D_j_?$_7x7Tvf|;eN(Dx3u
zHL-NRe60Yp5@{BkVa7g$eLuMtGA@~yslRJJ$x%XhR6o;6C-@qDx$0KG#QE0#uv)Ok
z>NAhF(;tY^1T8{9EcDH`pkLjR61IV@{YEL9D`I<ZM&B_!6TT^{qP_2Vh`sDbm?kBO
zx;=G7h@r9JUYVuwbS&9!Y=ZnhuRa(TKj&&3xKSvj@W@=NzAyZ5mn57o0^-pdDX)d-
z(_bxpdH>VGM}Y79eLFopN&ENj9nag%7qHSfy}O06?Sub%ZukMscnLuweq+EJkbHEq
zkhke*&CA$ke_wuIbk~Rfc|L^pPP|^Rg1<(tzTO2<=@R`AP0%|Tgd;N1F0ydMfmZz|
zjEWQitW(87(TvQ?%d~5|jaAY6+qAnO4YbkRyF>=}k#Es`0V>$;SH6rMxxaCel!7hB
z53{E@bQEjyU)g@2VNL(ASL^>q;0zCK?6b9ZyFmKT0JKi)R?LP(EUDxFwE)4?+Pw6g
zGdR8m>)vjWz25m6`NKBpbG@#D0X-9rRw>QYQO;{<QxrC4UAp7dyrV~YR|k1o%Sp##
z7kE7s)Jw*=H|Y&tmy{2&=s;L$AYf?ahAbI9Jno#>{(@wb;5{~!a9g-HrNp3UQivMo
z3PwHNcfms0-LFq8ug!GPCG)kszQ(IsU9iFqktd*0&I}vSr{wmd{b=Q{eB=@3cr3t0
zS$@?(9`IBmmdH>_@n3lHu78&pLzKgaP_<7-;Nni0Q{WQq2KHG~{pSv!9*w!L<<Sg=
z9=<F!wv-ZB@9?orwREf?K^!~;=e(mS*Bei5%N*X&uoJ7v@Bn0-He4kXY!^4<q6SyU
zO}1x<8DeH0&K!k<=!L#|N!#Y=E<USuq|obR&@VW({pNy($u9v4$A*jarhml=K3`2d
zHi(cxrBnF-i!JUm=4=jVUaXCbc1~I1VSw|2TkK4f*j`9fq9BQ@IJ|YA-lh&a6$eoQ
zhs7Rv;YJtA8to!QEtwB&Rpr(ASX<E?Y$o&pExZho0>&)Q-B+{8NRluy^5?JU;utH*
zg53m$m#f3A4_}x&@4ms>!U5QodM-P@o*Jg7d{ZDu70%X)0|h3jSFC0+H+DUiy5Pa;
zPurmsmRe+1ymBv>R5(|am1}a7X*YB`;8TxP2f(Emc*Wr+)vt{fJ~sZXqJ%|Bn}AkL
z8tUm=O{ejQve@Z)wZ&4hP3N#$H{I~|-{YkC&?E`349~OU^OEJ~9y%x@){X5yFyb8(
z!!YT?>Lgg&!pv-~S@v(Op`rWFDbn<GZOLtFUUb`YmlI8TCVq%zYO;=i&7-eMf|Btd
z)A?cfd-ZsqjsCFK*9JuEhY!wUtVxaOWRf5f)o2NezK{@vmI%kU_(&sYV8c&O-f_e~
zw~;JWJfl1F<{G>9@#bmw(rTC4_~^SQnkhAUjBTiEITPi)5*U535nNTjcXcMY>@1k8
zh?tNUw}x0EyLH^YzRGT|1Pt#|&~>%y8cKyN{+?O>A9^XR#(*Y=(V#=2H`L#NzGb9n
z_0s5Y$!$J{g%gAK^wg+e`k)GpW~_q_5~Lh!@?xS>U@63{Ro^s@40b3TOnyy@kn_sC
z`;X2!0h|AnkwZprqBSWb!f_kGfV2D0yYfpH%YcfS;E18wHF}y);%M6^GWLrLVL`wa
ziX5@Aglc;JrZQME4K!R2&X#*P`-mz5RHPl0&<8)TV3-g^Lh<dHeB=XDz#^u>5EQt)
z1|t5AF!9NbFh};&wUfz#_Y|Ezm<jLW?So{_I()xw&kOvKGhfMCtTYq@yw~60<6TuI
zF3?dB)W}i+VT>3Z`H6D&SzKJN-{+Wl9RMn(uvB;hj`Zob$4G+7(53~YGZJGhte&Df
zX3{@$n)F%@ru4YRI!ooJMiw*~4@T4`WdtffCx4VAz5p_#Uvy0S^4DO1+RJ1(c&*tU
zTUAtndq2rkHNzwJCy{V2_KFD-YuL`sadkJkdNdJ3ww!l0cv;k;;>+JfN-PkRtx_q!
z#Yh3OFn4SB&#($Zg`D*C4zX`3_1!r7l5>3|#1?+d`X(T#N?R~Z5<hVXdxg#wsYPI#
zxSo&%2&cjA2@Vqwxi`<#LmD-RPW6?&H1;4yT;M=#Te`4f>mR((<rqx|(E_)KGpeZ^
z56(P03}kdpjIv)1E_waYaD00+6E&1zoH}U6PuuOiO_F}cTC~^@vu_GS8y?1Z0^4h6
zVi9ryDdY^vIl*NZz+l~KgA)dsm5wq)h6&n?92fD@Hv?wzgAeZlkBIQZRKWa;+_~S?
z7u9jg<+}#LZ3dl!0B3|3xM^2A2Qs#)fC{HeaFH*!Qv9aS3*uY#;Fc#yQoPnt!-7v<
zY%g?XKYeotYM~7+Z>IiNq%S>#Bl~m)NzGls=a_yoz65CR5RNlAh_9WpIqkVM(VzZE
z@b8AKqa%(}J36C1^3VSdXKxu4R~O~)cB75EyAz}#KyYb1I3z)XLy#ar8iKn8m*DOp
zAvnR^wHrxrch}(Z?|1IKGgG(fPQ7!#o=@FX=j^@q+Ru7^W%VVGvO}n1*#R3M`ILmn
zQF9Se>8!1Vow_OXOf$H2u0fqB$ybh++2NHEtWOv$qCkz9hOKWFIHZ|LvGe7%YxFc<
zn9@p#K1ZC^q&~XuHNOWr<25@>e}84UH{WXXed<L^IH8&Ei|_r|`Y8%=ap2i9W~*Jk
zHfnb!Y4SxTXU(?<9ua;Gp`vV5R#DoE^Dit?9ea@iqo~e$f?ftDByl88;E!|ng1+DD
zg;SrZvyImMAldwd5&)({%j0gP6D=tvVrX?1j7_r$*xqKP+15XylqD{E+z9re(_g!)
zQtdN`BH<C$Tr(<J+tKNACf+kl#L_a{lP>*<+QJmPj+`ySKR<~{t7Oc`4)6uI@|RON
zi&_v>;Z^%!3QNR)Nu{|8Z=6;zTMZ8mI7c$-r}DwQJp`NWBaEVS2RhTi*Q6d2&9)|O
z=}b=Jd_<}>S)QlTA3@%wp*){Rsu#>e@JjV#mpp`&Q~$aXnJm6AtDR<D99NNivU02Z
zw<su^@;|l4`*KSP>KX$c#V70y`dB7s@oC=SwVU)YzI8o@u@xIq7VJb6eFptT)=Y>k
zcDLZL<N>kfe1}wQErv>u6z7J!aP)-yrARy28ANB6!}i{jN7`8BfpD`HIItj0{i*y(
zWSu;<`ctzB0s{w1Ah?d0(hWb-lJ|``QEBDp^Mo)DVG3<N53Y>|rTJd{@E(0?l58iP
zu>5aDU5#{Rfw;nS!=431w{o5@cIL3HX*m^i#HNOw2h^u#ch>c?)Q<Hl#!x_19F%i3
zeEsA11q2D?Twm6{k_!&CV?6&c6Hmm%;b}%fbh3G}ED|gjw*13`Z*y8=oGu?P-xj*4
zVjgWK6%O!UA+FMFTOY?c-=f=;P1{qmvK>8-;9&zYc>Ch!5tr7T#_l`#0EbM$j4(a)
zkR-Hzt6DR}gC&0IJT<doEpNj#tHOz!A?I!H3qB%{Ibn|(`Ys)904aQUy`a`0qQc!4
zDIFNZ4b`u$IirCC$83Tf+&5Ihv%-O8(2Ni78b|*+{)#jRj$xI`F_lj8_9A%podei#
zj#Oov1ijf-cvz=9Q}OVR>`mH?&w7!Kvj-VGgYqzk@I55_M14Y(T2WD^g}D`ZS(f;b
z1hZ>g!3@&$QOW8E%kRSwfRNKn?;htXkCFVII;nSyufRT!7mjx#U+Dlym3173TZw+G
z2RNp0aBL2)$$A|={{T+lA={&mn@y*IilU(`as7f9tCU?vZJh`swu?C3m1B%apx1H$
z+71Xi45K-!rJ-?9eJ7I~rn`<LW}~ac2G3X+A*3%a{6hn$`J2XnbJlQ8b2V&46yny{
zbSH<83zYW$&|PnTkEX5;a$<V@ZBkmUda1lXCGU-@JskkiTeo9@?>SE>r6e_?aJ;%V
z!qXtOAdlLx!}_fd<2X3&J_;3X3rPuf(w}QMPPti9{FZzKov{zw62;xlpHfOot9M^y
zd9CV^3SPdHm4wqJ-f`hRqZsaeJ#gn!b4NGR|6{F0ZZ<Pv(|MyGF49%LL{w^e)kdoo
zxaHmbG07uMQfOm6_}3CU|2bsA>JDQ-D8pu?r#%6;33Oj)xYo0mc=^U8XXEP^;wd{k
zz5cMQEx})&H>MIHZkh_I$MD~@^=W=9R4W=#Pj@j1=rv0#H<182s&C$0!)kpRS@6ry
zRqbpW-j#WF*W`FXx=}V3w+vjQUfl5B4ORhFUGIL2RHbmAf>dkrbO3Y3tc%}|sXQi8
zqg0k$wglcM3*2*L6n`hDNgB~z22-v(ex4Zd`1h9MDkeW*?XIaG@)6O)TtdFvJ5StI
zIj%$KY;KqMZv-K0h0cR`9HTv8Ysug5eVYmR)fG%hJJ8?Z<J?*#M(ts~Zf+#e{ixq1
zpU5KR1%1z*0;3&yDZPJBFa$)IN{@Bw96BHOqm4Uo_cZ$TQuU4qWsglcJAn^8Q?k*#
z$vIN2HJVn*^kQmM_m<%MkTzDYk^Ut8mU{ci;dBqvRyrO<LAWeO_}Ru7oE`66_FZax
zyU$_umrN+#7Mjs$_(NyEl1#|%kSNhLoeQ6I>iBVVrc_l^TFSR54a0JaWQE*3$xq=Q
zX2*7RBa%Mdc&6tH?cH!SH0LU6I4yWZ{M*HDpuAI(UYuep{+dtyx#}mR8XT*EfpzVR
zA~s;X)Fm9VghbuI$g4_kuo@;g@Q~5x5G(ulB|niO@9x$tK7&bY?oirS$RKS+7&k(m
zQjLMPw$3rvtpHjS2WEx7T~DLB783yz7YwCk>Hc(abIWiamK0g;tLFHkC=gFSQ_V+H
zQ@KKy-{qW7nq5wb+&@-r%Q*nXnayy<@P4_iR~B8NFLK2aCZFgC9~{k$?ozVgpc+{1
zSG~?-VSP`X$q45*OzCm}#mUdkj<fp+FeFpiI-`8-1oDe$^tYo4G*XS+yfDEc=FWXD
zqRv`*6g@Nck`qf;^JqTE#(A{j*XITD6BVxV&I7!Q)*-!3CpiDAwF&#jU3d}2o7{d~
z(%7?k40|m4<r0wz1m|$lWM-59+&YVyg)k8HTB@~4wQ^LlP}4dt<@%cXIXaGQP+*~l
zANf&PrMy8fQ{$Lp%H5bv{?p9vw-BIBf~Ts`FB-$<8wyNx>bz18wVM8~(KzdI=mAz1
zDneq`9%u=mrNcK+Klk&I;27IVwE;nJ4_G0D3E9zUD&|cmiJvn(w7O40ptfFx{)aRu
z5Z+4^NO(;m<;-JD3owB2xf|~aP^<QW3Qkqpv}7uOLyFaQE%#?1cd_GjLbifVBc{m0
zV4S8H`N~KJO-Mk>Zeb0i$l2K!&M3$s<{(!CQ79f;xeWT))7RE&!j$U!y)e~MsZ=9Y
z@~T>`qw}bA8muPdah;m#R*@#Irjc<w!c|*sZ}D7jecGew6$*O%9nwZsQLwmD`zb2u
z!`u;nw$XCs=z0dqa_Y1LF!%vF&BAPHy)&r33%3c!=*C7hwj&s4&|}i%%f!(Gam@E%
zz0Qu>cu<tqYk9SJ+wfzsl5B$Bhu>V(P<k2tAarc9FM@_kX(!<Ng|1+wq#BAolY6rv
zZOQvZ-eP3_%~$$EhsMIPP*X!Si@hb0#v=y-uzzs(7>)fW=pOrRkS_0Az>=gfu-i?i
zJ5fEQ48k!Ojv{1;>s}N3;H5{;&K7T9xhxZ0kxkQWVwBRhk@F3~NcQmAJ@aQKIb`NK
zHm-pZUrMbR<C#gwB-qClaTBr4F?3CW7mlochH$V^Z(%|uS>E08sS3~Q%9tQ>o&Vp|
z`TuOp5dVq9h7sT%|KqIBswu-EqO}Kc?7(rOBAIsmY|ACkIXsMApv5OdjZbFNq^R(E
zF&7zFS?w_OTJczEG@|#LRvP*m?j~ZYjCAh<n@Aywu28Zt2T9FGYALc{7GQRtnZY_g
z&_+Zd;NzN~*QS5Q7{flI&n3Y*uxN{<><WG<MfiOHkT-;_6c6*_t|%ITx|Ug?SiN;}
zWziAC@kOwKuP`9|YJ$KDRQ4Tt6hB(`=BgwO%yXZ>3@QOS%J>h77R-KY3BAIv8#RHs
zp+<zqL+TbhBCw&~ZZDnk4x$T{oSN!9)2&oHANEmin4FnnrE|qWo|0m2AhyYVw+xbV
zQvrfnxYLMwh6?1`s`g7v435mY_D0TSF4_A)3#2?4RqKKoy3Oq_d#h!;5Uy0-WufGX
z)TSArPB>Ocz9nuUed4tFO%r;N-dp}CkDcIL3r9z1sT#VGABsTuwOa;=;nqq(&^{nm
z6oR*heY5Mt8^;o>)UGVcAx-(ar|Ti0s(KWkfK4)}Krkp>M>OS;S9%hnDTuG&WJOWU
zo^9<5eco`H>RS^3SkIcVE~<F!qUtowa2(o2+?@|dWEfA}b1u8d_GTv>9d2k`tec%`
z>s;Fc=51lk$2fh&RjKTVl<UMa*%STlE!LP*#$>`~KgvX#{hlabzUM<XlS-wj;9k$3
zDQ%kpE?LK%H0uH{Ks^2avT>EwhepId%%mBN60ay`(*38N@B3|qvxBuj(CWTz$&_rV
zx~Ojo$86&}xmOE<R|^<ucd5G3k7uShzToV3x3Ykb2@W**z9xyQtNJMe6z)a4hPzIu
zu^{X#4w7lmb}Ih|Vm@d>`8C`1u)YrIkKl@CGdcBAf}A*d;=e90yxh5V&qeHOUBANe
zYqaIA+)-l~^Bo9=A3=aSD~vG$F{Ur<gq2{XuTI@!!-dJ*jIN>A=?CPZD#YPP2Z>N8
zE))X?M1-OHyl~Ix_Ei^&3S)al_j$`9`TXwY?Ozt+PsirEG<kSRH+&t{F6)6~JK>qN
zq`}Uj+BH6y_x9?sUaQMnDq*Y70sJ@3SzjkB2tz7rXq_0loYD3^4+e+bIyq<AihP+#
z31{^@O`1z}Y|fd#-DHe!NzO(s?CA8#9$h7Fc&q-fY7YnB(<2KiC+Tc3FDIA$ZydY-
zp|n^H*Icy(!hs%zwE~RT<eC*lYI&>1nLkc-YUnY;x3(yH+B~}nL9^llrc19wj)zfF
zsbU1BKLn=t38=1q5as8m4J=-8$Uyr;DL#(4xgB+O7h^D?>~p3z(&G^^&MIV~#R$?O
zFK4Dn{gC`d|EPVX0nR(wPvUuGnFG?F`l>};IG`F{ZSXUCBFQ!Wx=m2`<U=#}uY@(g
z5hEKLpe_WcMzFQa?63~troT+HJ#;QM=A;ml!l6NRI!=6~IyLTJ$5jjPe!cqM6adU|
z*hC4TaJd=e>SL@rdsuVN!GGoE$_8hA)*3Sm4+i}G2XGIyhz<`+br5|!!`biFb4J0G
z<Cug^mi=qsp>}G)00EW9k6ZFhms=I-KYLb_2umXt%8*5LQ@j)3>79GUbin1|G*C1-
zmP!RIMH#?qikL{jLclz30fJjO!w91K!wXwr-u3BisfoqKm7o_CN>h{X3&m$1iawMF
z=AqX8>KO^+t8NX_OM{me_j|K^YfgWal^vSTj|0USP&T2Q(8G>$mG<C9Id*B#;v&2$
z$JWXey_Ym7OlsTtfSe~==E>E5#k!5b%N8z%68+g}V;t=6k~|<R9d*IKl;9hZI#rvc
z1V!896~ix7n|7h_@w6pd&;UWaCvBOR{gA()(skWYi?-++K3kIAj<I%`f-PQ(1^0?o
zGS$oEEh|C{uAXhFn!MdC^r6-qp*NY843axrPh9ifBIVDoVETqSjZ;b?WEQV;ahdS9
zihw#2RAQKuK+3<fFTS5P{uFnw*ur=>HJ0@lQN5@e5C1C;6U&uBH1L|Ro1x@fhba0A
z>oP{N4y6HYDq`#oy0d2HY(4$4qYUV~qBMDx`E?VJxFmERER4~1K|KF>2S_MQL=4w2
zaH^IkF~C6wc^py;0_?ff;=1fzJK<O0voRHw4J4*!Cvlwnn<$<+0*lY%X__}s4aO`F
zuI{xv_e+R)*ZeioaN%a?hERxqBJa8jYmZgT@dnPc@KD~AW%#|4`a@1ELVoH^s8gu@
zFC{Pk>4CYK;B-m^*tCqOT#T{P#Iz~2gXF}iFNfyp8@;?~Xj4h{pv1=KFOg-2n0i)|
z{Xz`SB*-tR;I2vI!w8eyDc=MgvQ^3q66AB!x=-7(U@TT>ql_5PCa^g4BC#=q#6`Fl
zYEPGyaxl2EDg2VY@ZuuP^n6x9H7%Y``a|$bbAy;DzAeQmoD53J)7k+GVL_?^{urhv
zbmR9~ISwe5o{V>@9ih1`IHVEme7XVK1?OlFT%DH@fLiKLpOc&!>A9sn81U4nxuGq`
zCnPqDuK^1rf}O`!&WI5U(q1bv+bl9($i8tyjC-~tEP8+}k`i#KN$=$H20FyAlSh_%
z2wo})-6Fy_=!vTAM1Y(Z{~V-aR#fOW6-!N9U||>l-@q8T(Qnge00}o*K{G?8(05mo
zocbTb5F-=&2v+rkA|~HW^g^~qsneQ&5IYV5EUps=lsL2lA(;c|HtDUY{nO&!HOUHk
zLASRa_O!fnW`1B@+DO^!YGH_2nhYKi0a8BaMMNk__8QYhJF>CGNTK>qn9okyY;oVd
zITN+CFlpa<8MBO|Ae_ZuyLMuc9jayPo5@ziF!bed2eFB<;f~{KM5w5aTDbe+TEkpe
zle0VTwn+{h9i+N342IdeHk~5JVU=b%rYBAM;958feup1c`cE!CsC-5J{mMGM#E`i)
zSM2IMDzmPPo`Gp;iC*X3$qB>faK~}PWFx6{_32sW>ug*~TsU{LpviOP!r)RxfmltC
zL}ve?#tKAWE1=RB9cSFV**Af=mOCW<T8AL>y34w<5JsVbDl>H?xX@=x{S<<C=IPE%
z`QgylkEl;f{@woJ=uIK0@+V_Ep)?0Kr*@rYqc)_rTRou%rY?{FWhzVm)yIN%KceCm
z{X+*g_~C6V0FHwMKlqj`?7GiI^PNmKVnCmaQv1+oahs1Ang@2B!x*QHpO<vNq-DP*
zWlKFf?ep|Q8u`RRkd0Sm<kBfx<O*#G7`DRAG_eAi3&FQssO`I7wO(R6{mPB2fSr-&
zd!&5wgNfbvJ~Nw%(|5usd>xSB$xEc7F<&lj3x`*ddT+S~5G*6t{$A7nvV25PF`b3~
z5N36u@XDAUMk9YfA=}uxAG-UPDmEPpf8;MnINPK^GgY&N1+hlCx<b-pgdPSq_c!$d
z^H8l)V4F7>ja+AG?_wJjG#bU{gqr#-J9v{^(ww}D?y-9myoBi513a~8J$RSStCQ(#
zc|(wBRCw1()6^Na>REH6HeO8)z#>d9_>H3msLGhA9Zs{RHgI&Dy<BU&T7_R@?TeI*
z)K|?CyQ~|l&FVW2?J>N!EFGyUih<V$Y_*~sUelDbRs2T!G(v-k0&We1zzfR4$V~n(
z(wjVL-}TKq;O+@CGgXkiJ9;WYpN;V7l*T0WUfToe>TJU=bmzI5mTj+c4FU5i0MW>%
zsf!3Shts;+Z>dp@*=70fPN>24q~iwFC^!JGJ?uaO9$z2MOf-ORoMQutXso2TCd!Cq
zNsN!DlEt_Z2ey4kv9lGE_^LgrYZ$C&<K{`q*AuW?rlSL%F~wsL<PZNn12z@hRw!x+
z)>$)ChZF5s2bM7HiEx$Y$ct{vO=igR=XPz4WDZ*XuyN7{)ii1lA41=|!*Ue%RikID
z*-G`hey%J-o=8(0$vs!!=kyKp@HqK{fQratV>F9T*@u;<qUw!1*43AIWcab?oT9Ec
z^*<Q}Pn;<tov43whzDzq26c@~yu;wI{^O~hlpSk|Sv~cFt0OgNWM1ZWM1_5M)Qo3@
zIXo%tb_kUjq>k=@iZ}uJp8PQS>MC)$cTSzAVX@XW1qzvE7+jLuItCvbmgO7loD*Hs
z<jFckd(RfVbxS2GMj|6!{Zb|SXPf{&ZgyY}+-hS*n~spbt6swgJh~49^0FtjsH&Ii
zRiIVlX7}sh$oJDf#zbX~UbP-#BHH_|Uy>{r0eNk->BTpe00HY=cvmYz?X1M);&{-e
zWPO*$i~tqWLS{z3|8I{<h%ZWYbp<1yQ;75AL)Meo`#^Iea19TN<3DUzXH;<~1~89~
zXP$Uph!suzVeo~tw`pl8<m=KiKDtd(^H%jWY#ply*j$MVM*}?K0Bxp#88{Epr*mID
zR)C^WFsaA8YQ+42t6Vp5uXIA3R!88%2$$ByYVZsp6X&92dq7+eOVo#eX!3lQ#6^BH
z9@}g00uY{#la(*OaiW-10it2W$z{k;ed;`w*}>164iZQKzwq~&qYs>#SI?SPw+~6!
z#!7z{0=<e}FJyxaj%d9e*_iE0F{Mt%RL~()Ls=*Sh6sSDT7PsD5v9}hcNJM3zP@W8
z$eAW*c}y}o#^&U=jAY#rbd>qIDrv~9VX@%CHE!$c(a<B(*$s77Gjdh9Rf3_)>fwOl
zzB#<}4_!r`Q*D?*-0`%^i>%w<FPJsLSL<-$i_1OZY>OIz=EVZ03mM8E9mb(BG05YA
z$~UY1!G`tIQNH%Lb*DMeL0_-n09Vpt7rG;`wV{X)h#O|QSNICqlGf2!cFQ=>Ep63T
zIPh(UfoufiuagDMZ||1b_9eOcQ5J!3No?6N=VQ8{=oW%sCk4qv=8qTDsi9Q}LC}!v
z^j0CSkG*%4kQljp*l8)3VMSrs;uiN;!N_tfBd8u;^pJ5}YB)*2UVY2zWz$-W2j~s@
zDsDJ|GCG0DIw9R7DaTA-R|eo(hbm^CX@91{Nb$M@f*FB)2?WgF8v$%YA=a}M9Dqlp
ztrpgQdpY>u^mQIC{|NtGeqO%TUX|BbRYZXd;4HXQoBeY&SVB0(jj?rt4Oy8}s8qJQ
zsQ^Tj)DU4_-U8rt`_{`bSx|+m7Ters*|A0fYb~+Xe0IX9k%%x1KZE_<8I1O0QmqQY
zf&)B|4bf>yaBYlJ*%X;9Gil$UDuC7wedz&B871%Yh{QBT2rYI^UEuHSpzPJ!k)zNB
z*%=cgIBlvgCIk<Gu(rfl)vAFq&fM<$Yf#@L=Em1bcnn#4Jx&7QC6tO;dDguc%_?lW
z>)=0oE?L|}5cCT+zTmkn?a^K%#JroZyh&3{sDr4KkgfHi_b_(#EXHU{K}5FF#$qMe
zn){{Z%>m0-Axd^P^V9KOr)_I3xozaEqBS`&U75#olCKRI#53Keqs&!TQ36>hf;G>+
z6kFN28OJOkpq1QvUb*lc@Kt-GO6ex1fvTau@C#Twl)6kvz3af*b99*=pqBS6I)VsB
zb$zb+D6II|aY@FvWpD@|xh^A#%2k08lw%;xz9u*QmOehauU_g?Vf@A$3TS|Oj>_7@
zz{?OK<7OKoloKe(ELC%9X#I+firs!1&cXmbhG~!pQ^}<CR#nF$dO@qk>0R9moFEht
zexA=%zr~;h?W*kJ-j*`mZ;j;e{9Y2%1CIW7_9?OE@GjjVyQ@=s@}cjZ1&riF_iYeX
zv=cYD?d5OaUEd&7t@z)zQ~zt@K7EJT`WjHzr+kc%xj3>!BpgIgC#HqZ+alT3PjpT@
z5pH3g$%w|EA>dO0ok!Lone5xHD}^40yCsZ5tIwcJ!8OMa0V<5metPQIv;x{_jS3NB
zSM~li`b_IJw;0~G9K)WExxC(lFdO<G^-({5rK>CT_=!drsaJ~Zs!eV<DS5Fvt2%xm
z<9GaWJ#ybL$2LPfIjB>?aDDsjKzY7><nc>8r7<n4Itsvn*y<xkvKgUX6&=+m^4P}c
z^|n&^Ydm2{CP08Qbea-ld(Ve~^x78zzal}zOf4*~P16K)%<ns7(Pv>&_mor(bm$Nb
zbMm+oEXkPjE}u+VTl=E3M0%XLh|>#1(VK`S`gpg8pQVS0kLXg3k9ny2V(>EDr8wF=
z*_3Z>l3*#<s2#Kh6JR8uD*)y!lod4Ae?bIXys>+&cXukWKy556t|fXFh97lLkT>-+
z%7oV4@9fmS$vgVCSYY=vFMXr#k9P^M6fL{DiH+qR;d<)l$FNk=0LgWf?40bry(xZ>
zi0JOoBBcIL-?#@Y*dO1z_qIt_Vfzowq1AbKc5beYUsP~5Do=N*Rn_^3YlsMj)=Fcf
zS4F6g7^-e>T(T>Z2gb6Hm)0c}_iW^WO^QJ)m?o#tEXy+-->o6myQ3xWjeCgM1M#}G
zwbQXL@a$;!YsPN<U0Bpz5pIo7Q?^s6FZo65_#d~;PbALw88m-DG+EDE0)*=oi#F!7
z`-Gj=J7F}`7&@g%$1Rex7&;50-t5cEU4Nw<^Q#83QSuNK#@Vn`5q{?13qvflzm#Dy
z4z#IVM=*~E_a3Lg90kPR>3yz}h{uiZTMLO(pFW#`or%)+ii^}?=&d~D8W9UpNHO^s
zwBLQ1%0tfqp_YS%4!d{{Lh-u3B@rq1mOU@@d>e58nxt#+8|`B#ZL@t6Uc=xD?ZAb&
z%pFY+!xFsd_y63z{QrQmVH!Xpe96Y-GtXdIv6}kCIM*gae9~j#pqQ+}1w~ftk06dJ
zr_wnKFD`*2W|eK09yVUSISQrcG{A}Gs;T2vTaiiU8U{NKbisEziu)Md$1*nh!V|}g
z|6V{S`Dd_c9bf=`<DlL)QSXSH{+HBt;M5WCCT}I1t&``F4KIyE#nZAQTr+V%#b=pb
z*W;Qu8-0=?SLMOTMJ2}Ny}B&@_Nz&YfXUYOB56ka8w2R+osojim>0TliQ@5v)(lC>
zNy}m`MmU|K@xiOy4x|BeNbO+_i0U(Q==&hzJEb%~({^7|J6aoB>vkc$2S)(HW=8mC
z54H8;3HDN~!A9X~V~!756@Ay-FAgWW$A+Gc7y_^n%t8aSSp(pR0l$_wL@CjGY7Y=F
zvKYvkI|~+rXiPe~-mYPe)2kvxNfZGqT|5cy={TM^#q-htQONZoyN{!o;RdN_J>eB!
z3%mBd4S`>Z5?>O%iL!YANMiv%N{Q@ig(dpbNUer&25uKcq-d&&NnE5-CSkaA=BaT?
zm38`=wiq&WZtyvNtr#^=ji6K=K7okqHu6BNb>=DP5$AeH<YpXxAZPeERv^8zV+Zvc
z_fg!jzHpI?yq&~-?#AAh^1?|7K^{MMfFAe~i@wmCn|rOO{1DWTKdV$5L(O2m(jQNg
z-KI<}7)PbTX@vcqW%1z=Z5VZYJVPXuSbEd-L{Z-uF=3d`0}wd4_M;M0lJ3xw_f8G)
zD+$cz7Rvg<Y|H?lAp<lcMhAS!0|cie_8VT>lkUFD9@y5^f5&;ah}h$A5oth5h$8Oo
z>Z|uSq`Q3kEvWYXJzkKVeb$qoD;AG0neK7l>oSH8hUz95;+jhu$@An6;4J$;IpX;C
zU(0G>-{3anm5K)=k+u-&#Ni#&18tgPydNefQcqZFHJq4TUfeK^JKEQ(fpy^}uKu->
zrln8%%4-RBKH&|R5P$TEOX7b=J^yzn?kWZ`{;5uP*O3xxULVOEk(2Z<LKL{eOiP%n
zE4{j85a6=6&$C-zH7lc!!E-&szEP1#++Fw(O>WWlug$E|luS*$w20KIK!9~Z(ahS%
zx!y4p!ITT;v@<tKiJ)PWJPKXrBcVL|2@PREXG_vfgUJ^jVURy+H9>!6k{E*@GSMBS
zJaG{XwvUqd&0~@r`h0TO`9-<T!Z_dNx(~2gxuq*CcACIJtBK>RUHjmZjp~^#&y}qw
zFUw<rR&h*fJV2Y%vW*!^Kni9xUOy$>imq;J21}ZD_oDYo*KMFg(pwgFtU&2ZSlC=K
z@v`5JcG1*J9i3(gWt{560RfR<l5~DClmK-Y*ZR@5<dYUMJhkJN8WlO9gy|57ZZpKg
z4+3yImWzoY0INqz#4zE$n$;Io*KYBL7Y#`dbJlZQ&`QJ%{|0g%H;TniT&agO&^kZV
z1J@J33g=4&?t}$05A}IkRgJ)<IvGvhp1?f!mR1?Q9(bZDUA=kT%X>w7WqlKylxHJ~
zvF&vlfA0*b;Cwc#vOH2@46dlJ;3=+<^`IO+$cy0YLgnK$YiEPCu=2D2)pCzm?7{He
zQnstQjb$PrxJFKNDCK9h#EMVtpZiZMnXmYB=tpX}N2I^9Czt~gWOuSQ7D_R3km%W8
zD$#ejvJ|xZ;9Q(1xm#}TsD%kKx$U=3JjZX1BE#?1;p(42z@WXiQ?+^q#t@F}pg8(Z
z!8!v6oIhquE?i?xo!h4Psbg|!WmD~jk??3@EKb@3d!x~v@dE8~IQy)EDpq`Nnhz8<
z3gOvdOB=n1s@bKX$bFQ7_RFvWV^Ml**T!oKnxPT**`%n~M#^i$FeE4a=Gl9Dnk|Q*
zab%>Mfx*?Y_#NtexbZ-cI$H#Mof!OlKxpK~ZL?w|?a<PB;T)l3=K>Re{W^=75lKC2
z5Vc9hFnzy^$ql&NVy^JP4;w(WtVo>$Rnxn?96bmkFnN#i^TfIuF-3iSSpkI5869lo
z4*kQF=~%m{|Bz$g)1zMv6(X>#D-2Iag9=*9-t;npM?$Vz+>C2QnsaKC;MM||nJA?O
z2v>>rt=q<b)l&a*`?1yw>{+cnEb;Nv0@{e-NH0l}9fl+pV-E^IGms$fhj=`()n6N?
zg%%SL$$PFiTw}-29W!fKvHe!uon5QxQH1EPZjO4*IcbuHTTU5e9BiK>XOPB%nlWTv
z<ejhmb<0HV@if>cP`_Pc_TX;DX^OUo$;3J#@n97#<s(DerUm!80CiEg@RA<_6e2QH
zNq3k|h9g4yD+IN^Co_t(>VZ{F>Qh}A$s0)h&WsxZ<nY-F{)ek07rGp)=U%h-BXj?R
zK0jK#AcF;vH3&mGt_w{}y}X_dska7}h(6Ne!sAdOBV*R<fJaOKoT$_|l_vmT<RY6-
z-)&6x;5dKXvJ1E0h#QTMZ3qT8hvdHhOG(+s`29DUa>&;Oyz<<bLbK{7Gv~>CA<~|1
zb8H44{|L$t0-PTXw}!vL`=5CM+~ZSc9w7@<UCZ2gI$(2)ANGwJSU&fcfa8rE>TMru
z+JKxvGhyj_0<{T@yZV^~bq{=+ll+8*uCdI_*|Fbn#tHSeCp&MbC&-b=QWC`Jx*oa#
z#<{^xZh)WSG%-Ss7lt3F2t+YHi$@fH&Wg@BFBm#OA7i!utvxMRtJfx9)u_O>2p32s
zBWk>i5(e%H^7*%iuVb$58qhfiVlzjoPzn&rv;0gafQ_A{z2GeO3xSnZUoNQ7yT(1u
z8@>C(Kf7de?n9(|{%Dk(2LccLiJ!<zY#{v%2jsm?-Do_=YNvCre(Dh0ts^J6x<W#F
z!M4brU!B?W$4yk4f4F=pAulNjwXO<i?fP;T!q^RZud>-0@f=N$+(MJ{4)aWihe=S)
zbTL&i>Y(j<08v#P#D9F!oau2DxoJ);)eP7{U7B)eeQxfK7RIh|K6E=b=8|S7)MHtx
zJ>8^Ea-qHQ{B#U|Y+6>Roi?LPX(xzwIiIrz-^o5`1Mb2#^&9g49SQ$mU&Sd02R&Eb
z*PcoqE`S=7oW`Jaz&H{`)J6>ul9WmCR=8zK;Y!*jtr|n@;wTMJQympj$}JF`34qh)
zW-CM>e|10DbsM5bT{Nr|mQ5;KrR0KYP(z3CCobVKS1>YM=WO+$iP3Vkif<aV3S#<=
zuQ}|6-+W#W$g<0H92GnlH?}$;<!zZMrZA6D)vD;OkHu%5V*Y!0WfLh}LRCN2;~*+B
z_OZN0-_f}lRWc)FUY{;X-h-uCiwH_PMf}_R70?Y>7mk)U2Aeip|8vM^SoIUFb!q46
zi|nr|Ii$~GO_I(zq=s^<j?Q&CjTTsz+~AlR+PMb58I(?aTW)K)z_;iKIcg&wH;t-z
zEStps{l=7M_4#J~eVhmctE$1@Rcsbz1;q6M32sp|>FRO455s`KXmYlGduTYQqvfgj
z;=S9>L`L7u=0aSn&<R8EJU2EQG|Fa%1{P$*78yS2mF@u?j)@$uk8qb4F(g{rP9s#D
z*h9!^UQ>i1zi;Tyw8ObIC;3hJ>4_#V|9<zZgyXN2A(y(8{nHCM3$3ios~+pUyz~{B
z^kdkq0U6Fy9=7My4iAn$Hub|<1Ydn8Qg(q6sO96Xw#ux*Siw8TydG_h+3B8z8_DGk
zK13~mF@F>&MIMq#@MhdO6DL6M<8RV=dk}f-GEB)bQwX4FpR($LIU==Pt?qq;EX6vT
zCA-bjpgI4oa5Ab}D7Ci_uaw|DsEe<rAd@@qd`yk_gy`M!asHeoau<#C<pXhwq<Ea>
zbmY@G+D9sp!=KtXJ0E^g@uq;lqT9-rzXNcP&WFkM$x#J`Leq2G0&lYDfW+{zt!lTV
zojF<~*F7W&N&>JOVG3zv^Av;lSbrd7w4xAD_j9Im-+x)wtrD-Ogg}(8XE7PjwTl)h
zq@$Tf1a+*8vf9{;;AlyO*a=t)MBDp1md?oPQo0B#w0Q2llgRD8d>_^NBwSV#Hat&z
z?5|}mu>jlTdd$Ktt=LA_3fN(!TGuK0R6XUgI21t4Ml+e6^EjxGgE9G<_Iz=VAG3O7
za8Qzo`rf`O&SRXmjp>=5#LtEau>moEQUC9S*ni$l{m&0`qL7FbPEQY_Fd<@(#y6!l
zP;%VPZ7AU~O~DLrcCwKlp69EUmujl3{hM@0At|k!VJH)JMAWpip}9_QoA@Lf0pVR7
zc(GaO=qkO28PkEqhPWVjhjn4*$E$c4zieAi%=Clj4HE`<#3B9@QPtem+2mKJc|hdI
z9F4#alI|WO7jbpbHv`xM+g8bFxwl;B3z_|brISiMySygs<USfc?g^)EX|H&fvQP_t
zEi{Uc$)M&P3w#$K=PrEDNqEJY+Iw_m>%_)2g>v%Mf{nhGIFnogbB${%glSQTiKI{*
zSd02M(VS~Us-IH|iyZs`Nj}Q^YBP(s9WKSwhEypI;6A+|0A%38PmI0kY=hvHhHJ^s
zb%4wMM+ccEq&GQ;WoviNw4PtNk3=CtXlw5lg(hpDO32j)p6=;dsob!HOCDn07)@(5
z`C$2q+SQsMO5RCwFUVU{*4Z0J9tkcVRPxheyb<hAoL|N=PAA9ldazcjd%TTi+(b6%
z+Vghkj$xP+8S;#8PCFmg*VP}%7CHNda^x8b975&EDir;W;;s994L;}876?b#BAaZ4
zgl|v3L6H>8?)!XQ^|v&0aCs#E4GqEQue0z4oM$M~l+^ky-^PZI+vNe2apilVHcR7J
z7%&sl{-&y0PI2*0hs4OZ1sUo3$^$!LWF&$|ZZ8bh-}5bI(u!crJZi#_b?}o}unql$
z(Ji6qZ`SOrCdmOU!2JAAv%f2dle#h__kPPHt9xC8i~!qp`4H`zGk9!)<(-SepPd`G
z?ta|}z?DyimX&eiPv2T+)&|nd&WgoS4?w~k{lSckg&RrnUuyRmgKxSZLp#qt;`mNt
z85lJ97k_eOQWvH|ByrBxBm=oJa=Mn!`W@FqJP*>1xCjIjqVW~3`~TxCa?8ORXo%O*
zUWJenWQ{_H1+bW(>Ej(Ml@M%iRgB}PIX>Iz$?ND<6ggI1Qsycy#|a$d09L@LCkid8
zx{P6bXt;m}W;e{;%8blaM1Ner@XR7VT9p;qK-S{!;X??aEwb0I#1Vqd`85|N2)oxH
z^elN1Oqt9WxSs-qgcH5(ch4lDB-wV4UueWT_@?oP&w;wLtxW>nhFhyrNmL$7<wkjF
z%jng8KBf#ja)}La!}#k(WAw);isQ5hGYb>o>u@!!7vNJcP+s|vNw37}{Cp$!Qs1$r
zH+U;f3{pDv()g<)O&;56ZL&}>!P-ifX@sRRaJTZ)14*b48ZHxGh|pm8=Bs>Xs!v%h
z(153CT(|~0;zspTYe#7Ck?OC{yKZs=b5n?p*E<SNJ7+#hmI!*_u72}T*n@@eckgcm
z0n38|nvR#zuM;<{cP+UEHSl8x#RIo_$60p4i$C(Knh+z+EJ(#i7X6LtCMbcMh=Y!L
zIEJU-$ZShP-|dfYu84I><EyWd$<IkWXQn#gm{2@p#UMZ(9m>AYmDA1!&gM+!Zrsu7
zXvrS@f%FZTOvF8g08xPPtqp3^Jxkra#btPF<Sykg2xZm6Qrl88a??C*LKo%AvyB!-
z7Do))|Ff_)Vc>Y>m)3Gcf$Zm<>JenNrGD93j3O`_zWVL1pPG;_*aj^UpPmM)1>4lR
z$yhzpNr;`bhwASgQ|D~(IUC-}<D(<&-56?B1j(=IuPD3rZ|M`Ak;?k0|413hn*9vX
zN&PEX#hcm^fLh@}JTXFspB*=4wuDictI5e!v-#fE2FDw^aXhWLz{zl}Mw(26h9t13
zpoUY|8idIktx<r?{lJ#sJK4^Q=`U2|>@OU7BL4;vxk$EWV`KDhy&C_yf{!O6g?Cxc
z@!UQjaxHOl$(Aj#EAVfrkl=67vU7mqDs4ZzAMitHiR=;C)>T*Gr$jpcWLp;{Fr-sD
zho`6>_s}-+1rZ^MFAP3?L9QuZkxf#kN~Lq$nHVM+%p$Rs+l2^7M42*U;7wJvwE79}
zo^zSjr;X#>jW((|HBB+6zO5wx3mTZ}_i7nK`&dj(lQ&~VaTQNb#Vnsy{1aRW)Vc3|
z`6tS8`smM>k!yoj*cl{sA4$HBd|)j+AwPgieeX<Sck%)V*u8*ccRH2=AsVaJo)UmO
zPuJH)R)`*SHNfTv@ZIsTB`y#yp^y-Pd=MhJvG9po0}XPGAsLHdG5_GG=XoKyw7$BH
zjFMNFW|X5a3(HFz#{G0CkBH&?CeT5nM2c?17N~`Ah^UILQvLzuJ5nOlhOcDoR!ZpN
z7f}QokqNrLVMX*Ky}kui3J%X2A<i^PG<h1=;vUBDQ^m0bJ>EF?uC#Vq9Iel3Lpa~}
z{?V0xS3`3*XRyjlPTf=&Jy?gQ<&V=QgF*E?EBm1V!z{v9)R8!<2O~2)c47#WIP#)7
zJbV>Pc+G`>3zew@#r(Lz?wjLQ^=Dta-%FH0n*b%g*$C%uHC`zfvq<oW_z6hE`ym>w
z_M(|pQ}nQ5Vvsn#qh9^AaTLUb1gAGW(qP~t>+XIJtvzn2x_^<K)4*Y)QvAT+QL=-d
zjm0DZvrAnVH#AX9U&#eQ6lFj;xr!cwVK#}p9`MEX&;`1`VygaHvP>qcS1Qo-iYd?R
z3A@GUb=daVOb1UmLV?>sJ+OB;Gx_l7%v&=vV#-POX<{5WMRsQV-b^PBEY`_mS^aty
zzZONf4K&gNKu7*?!_Tspv^i70Vu7B~WzOv$pWYcD4J~aV^J(lHWdLhn(}t5s3XntR
z6q<g^XLhBQ8q`mH-70dZ9kVl==M<t_mV3kwa5-;uk^CV)-b29Des9C~Teo(~`aY=Z
zM`f1B<iI*Iha~j;PTXk$IFlDlOJ}YvDhs`u^3P^Is#UFhjfShR=RNm~DK^LWVZKhe
zEgUhMNaN@)IU)$v|F?TYP6HAT5x~JUX^-G$PWCA*cC4Epb5wlYqaa`qiFsjnooi7&
zcN|Wt{`tMgFNC6O@a3yB6@i@{K9txGel3|kG##nyr_C6Ua14&AqWDpbQa$OyiO#eQ
z*LKa2Q&)UP6M&=DhtJJzXk5z<3G$34%%WE<)SrLq#{9jL(LxTOy%IK-V{g_OByc%q
zBF3ax_^$I~^KLOh4Muf9j5uvL<TkdF)5qQ#mHyU5w~>{2yb$<jJ9uOgg{XY!zzUF*
zEa8@IXG<N*N)p+9aah$wTV>`Y8G2pOE}i)o9T!e?qu*&=i0d*HFAZH5PDF?`o312x
za>YE~T6=PQ(wjR3J1*a3t^pj#(n2VmvwS<!K5bU^IV}>S+W_-Agtq|_>CZO@XBz^y
zPg+xKD;KQXLZ|$QVWBL)Ss#AHhbJtw5el1E;Oq!=sSe3@!E=+rRv_pc*bmDkcsYca
zOYZ@Plxx?eE123zC<2;+UwlQZ$R8n%I}hrH(_*T{^pyrVrAYnSsJ3un+2|6+-IFR!
zYX#T(?;*)bY*BBUlVd0pJ7N7{IO<|l+-+ckEnG7zqPz@4rJ^hhd;*=dhYG-3J$&Yx
z1qvL6$k*%Yz4D%;mx#G~ylmyn5mzI_StkqY4F$@#xM-BZ5<Vn15vR3W*7W^`?(h#G
zx-k{gN9}9P;)G5a@cNz&%bo}-3cOjpkNGS6R0p9;z#juxr88aqgfo2(pNF|G=dm+Z
z%a|AZG#hhke32Y#B++ff(F3c|7sx;@Fn^;zx%cox3pkN)-T$qW?l2rUIQ*l7)SMPb
zFCKLp`Z<16LUgh<kR!O+kvMbk{PVgz7pXUhbVhu#8nxBik<`@;ZT|H0FfK-~UBR2>
z?)iPPSuV?}1)6-nj|Qn<!T*m7fV$zqgU}0il=0OCkt+J4UR60St__v{0=H@SUh(F&
zihs{&?Wm0A;ySJcD?wL%G5dC5$U@8p$I-Z?av$IE%2K~Vd!&O^{5OA%&Px4Eva?DQ
zu33V}kZKPz+_%P@1#W2F$()TjC-gn`<SUBK9!RJClW7}gjg&jcweB<~i=3uO*AZwM
z%VZbeGhg=ngLnT5kqb;!3QWZaAT^y+mQ>8j*=i#$d!7yO6sDK8>CaLpv+IVDI)}0<
zG9QmyjDLz2N&G1$-eEbp9PTiPpN>08Ixg&(q*%~3Zc1;VLfSn#dZ=D%bI@K`muy;3
z3@l?g5VSKB*1$tw=Ng;f80T5c^I@Cv3Msq|w2zCHaD5l28W(!tlt@&QK*o0!>;zXD
z$$UtJEGPcWjwYBXlPB?bgE}q=XoCRm5M;xKf?SB<S0st|p2+c0T43m{1~{)B0Dp^;
zSIL1O)T})$)?>6Czjr&5_xUjSlLYt)qT3*!I`!el!lg674Q4{0R@F+#O)XVZAa>cN
zdp2BBZ=mOHH@g8;a*Q;gD-vNpwIOY))~neZOEaQU-!3wc;P<IP?f-G9bQ=AS-7Okv
ze?1II5UEgIH%+}NdbD0(*7h)e(aeA;iiq|TihA>t7}^K4TQ^OMs@K;xy%;lH>}DS6
zX6r~PJZ*6lxu{>}O*A>m*QV@o7GjRE$}VLAP-a{_8pQtgE#~I#o34)Yeg8mXOG7M4
z2_t)MhIUn5h66}G^`-xsi8I4`kKG?0EuN*mle8g=;&(IHXyM~k;eg#VI^!S6Kr}!3
zN0b~2_M5+dTN>N6JD1){RD^Rp2Dc}N8@cxqIve`<VqEx9y-CI)zL59nwx`ehdjiOd
zY3B)^ASWlYa>rxKb;3z=Eax7dZ&mP!60R10B(Ne9iBp*ZK8P*_C)*B6KKY=p9RAi^
z>v^Rn=U!khs`c+ioz?aKdA}q-ltC{Lu~R=g%K-41U4Vm3UH^(KlCpUB8smyex@xYE
zV5wx9<gK_T%j98EvKV@3DIPK$3Qjf`mC~S=A9JGw2rw}xmQf%~nKXGg0D}VQD~w&_
zzo_&=j4Hc;HWl<;4LmVO)Wx#p_>eQv?_$-G%v{=Mo<d#WM!yv5y!7CJiC3yZbkURN
z{$b<ek|9UFvtdRhSB?d;;Y-W#u<97~Mpf=rQfs5;*8CZIwzgoGGF8pyaE0r%i<6D0
zyLYY#hT~n$p3Hx=y~O`X&%#qGAj**e#__~BopY4<I3gNH1xurA7phch@3Cv4&{(kn
z&^sx`pUqJV^|a?n*hJ_HiC-1h0TPPnyPp%z0SR|F;~g<P2%7*<pT{x*n*t?gNu8&A
zlzi27Aid3$mcN>L*@zi`d8Kc7Ov=<v15uKm-$;CaGb&?NErJ6P+P7ZNE$Gf>7-b29
zhTwMgxu3T29Ir3CpOK*DVN6ru!fRi9mq+~OhXz!v)7=X4ao1MfvwNm1hZx~Ym8>(g
z`o4^0zo)H_aj?7~DX$}Ehl?$L=AS77Tr!dT=J|Jp?<%SeqEk$Evug7jA+-9|S%!#M
z?TIA1&|<#2$vfCw7`hzV`GS<Rmjp|iDFj^p{(+d|3{z`vl)`%Off^w(;(#D*!~y+k
zz`S(6hfbi^GrJlwe{3eT*!;%HF+0MxBd$jFs<R7vR{w^;ZjO{=>_i!j`=i0yCEBWm
z@}8z}v<DoAuFH4fo1JhX9!h|fGN5IxS52`&nkw6iqL@oM{3A{BIQh~EuUDoa0qj5<
zxVuwaRH2A?agE*n;cABY0|JUr2t=}>!dITFE>%WCR$jCvySA?ucK@P<6&^E1tLC~C
z@~oRr##S+qOUCW>t(Y>b_V%4g!M`1@7yhKpsL*eHn%8)_b=*^b|ML7++sF8r@d6*f
zy%%+O>a_t)mI&u1GDPH7PS-^I^&<QI^cj%M6CptAO-*`jC!A{BS!t3hgMwPVa)<oq
z3h{%aaVOqt%Tnk6%s~N<_MXB{dhx5FRmzC`cup)x<|8^!{<CEyh2`ugP#tHhai(7J
zy=!`4!iqt;V~Ki{xfyFLUS&yq-PFscD<gY*vQv4t0Q>9B_If1v%J=VnW&f_R%Y)b_
znE(#?S|v+;FZuX9lkPI3HzciJv=&CEt58e{B=v~#*$R`J!W~@JL4ssz&e(rO&3&Y3
zGb~<{o+tK?3KYEhGj`aeN<KVct}j$Apl_hVb1@{|t*_39J%X*14im^q-m*Vm()3V?
zouE=>B}@8{-ln(xN^o4Mf4HeNnYEm$COug2B5K%O!hBh_2R!%X@iy9btDsQwdLZqS
z&-&BgwJaaf8}7^zTi)n?(IVPlf(DB}dwIs&q?acY+N)myyED=JGXUFMrP)WURg~!Y
z^{Q@yDl;oHOx;QhKsGOru_LVYrTA=>4=pBOEJ_xz+pyxDdjXRaSP5ns-xh0X+Nx;@
z2O!47qUaWkHX1SH#{Chi(F$II7-ige3UXb3+2Ue$KVIqrnWfhyC`ek$?4uA3&R&3G
zE;On!g(%|q*WQESivok6`G$7+6MKOj806~UK#PIh`@3&|%j@Fu3f+I+!B_wB4l;pp
zOJec;`7NMaIWk<E0d|J6wePyO_h}=yM9Jwaq2oC&SUf}K>x+kS%)dg4xBR=KSAyRC
zwRopY@gTC(Gbj~q_o+QLtuXZNQKKr;Xy9lYzi-)DAWK39&2ny**15^Y^n&8bEGc`M
z*5I)Gij8KT%#Z{jf;mOL{Q4U~KQgazRh{K0MB!BoN?mvz$<FV@JXsi4VnTA6zp20d
zcSQvM_f8ag$p?-NM3U;wkF>Jko2Z!8Gh5Pdq1Q}f`ofEnNP|R9a|(WOe;Ix3S?C>V
zr+!C%5Z-k)3EQOlxm*A7+s>aMlIvBq{#9mwD_7CR*q3NOe*vi%7S)N$OVF5Nc`%sm
zcUXPGFw#-EyQh$;1_~OpAVa~%coyBZ1*yD2d`rrv`pXMV#-HO>>RW6k%S#75V;D#7
zB+vpR);(&8In8W11MPve_vI?S-Y~rme^J!Z6+6g8zYm%)_x(rdhGl_mDpwk|BaMbX
zkkWT%MqH=87EW++wSDmtGfJDRKc9ZV9UE|j7ruo&iA-T;=>z7KgL>2fUhZ0eU7?o}
z*#h9fA+@7ZEs{K4NBc(v9sl#QzdHaz7ha6V^EqWX3QX9Pzyk0+IOsq`5l;f|PyiVQ
z6o^oHTI9SIZBa6Rjg($%gxs-h=7zxRGB$2+p2-#k1eIr$_Fx_k1=KyH;oQ+c-{VY=
ze3+&}Nf$++2TZ*t0Oa^z@LR$Vx^kwcG;9$gzeP~AKb<@RQkK;=Dn+1Tt&#tfEk%k;
zC~ik!DZ?(}^|BXPQmG1zs@LZ4G(Wh9hzaRn+@(w~1IA4H`Hiy<SHt2}4LhmArd;vH
zm*V0%NuAnWV(HqDc6hi_N~@4iHAwbtFOv#-TfB>rtch_D#}i*>Zv_jr9&%#cAe=~t
ze0*uKHAYsorkNEjD=%JkBzH`%HS}y<GOprv_puv|<b7~wb%3VUi>|H;WXjW0SG7&r
zRr~8Jw#>+fXRn4MH#C}IEl9hIdJ%QHiy56(^&D@CmJ<q&UX4Z^Ww+ObHg9`nluxaa
zr#;po7<0E@MBlEfm}p(99tHOE=4}d=tn(<Yp>o28S2KI2DY&*joUa{%`NU4M;<9&+
zpK$fd)g^7>@4WF%2bTI`JB&z+(F)2&#G(eVrT^v;rJk~UFK)S68phR8cI&Cmio+J>
zr(>Np6c^m~@+nVB%JvZxJ31^Q7bSO)*@qY8a7)_XtO4ErB;jdpcEv^gb)CC~1adt^
z9Ko!9pbKiftecPF;**qwoblzsx;$wX(P`h1UYJGJS+rz>VNpQJkn;~x>XCci2=&UP
zrICktD;OQAJSquYew@=YZ))Xp6go^o1lHfi3agfkJBS$2-sfofC@JSst+9DM_~hif
zNG9^j0?d?f`6ziEJQG<56N_d|eH3oz(Ge+KG6sK=hxcDZyH0zHe?LUOF`S+h9<Rw0
zw<(BSqUDH@gvmO}j$?h~u7DXURNmjfzqFVWdwzShdrE21#tHp=Lfz5HjFdZ5lsO{*
zVEAX_L#Hob>I?pId#@xqP2K_3!r<nQ#uf5>u8HKuf?dtZhKa+=m;k~|o*?+Nr(p)}
z`ph2fVYcWKls_(p@r10rLtHO$LoCHEc}5{~WM&?@4t?9X-szbJ%7OnVBW`lz6E&0C
zM1(sM54esPiEt;C)Z2UvxVPCdY909Y=oP#p8mFXj%su^LFbeKS<0|%$gZtOvDe1mT
zsX3El&*b0r6g;#^(s+ZyP2z%KNiZHvz|m%!CA}vu*nd{oo-_!i6Kk#XXeq^-yQM;*
zo9Hb1BwcDO$L&gIVMhlH>N~apxi>^@2+0*-ptx2g0BU-m%B1Rv8-}v6Gjk$2M4LA`
z(NV92(fC&(Y4VGuBF|MSxbYjp-T#NNw~T75?b=0?;O<r&T4*Wm?(S630>#~fLvSnF
z;!v!#P>MSgcZyqa3$DT4_IjRo?ERhd<LvW}kw5vBF><eat~sxH2?pjhtC_Y(oJf>g
zHS6~GpzVrj+5B-qP;OsUYyz$7=1?9-qG6)@f}rH{!3(|Ay{$5A)((N>(ATRxSBVR}
z?RIe@E(+u9+FE)`AH^b=5gPT%W;Ji-oWEW&q5A>J3~_JuD2J%jB!3%~yDb*ml^8#L
zbwE+a2yE@-8t_j@xm8Dvve<drIQ=OUrx9>G$AE-D1!eWt(zYn&3jML0i&0LqU*}x3
zhX8rAiIZOYS+r)K0M>Z}hZbSEG?!FK9^fK6JUpt!vW4x{(VICY1;<ev0H`;a`y=Y8
zIS-py_KPd>^%I-J@tTMZh{B4fps+%r#7H3zmLyRcg-~<F^_L0-GC1~$!b^NpA6vXz
zGZ7w)V}*!L4029l@<NSNfk*UMbb}Z)wa#ZaxdtIW48m&PhS%zZ)UGhJpFQLn16#9^
zxnF1h8N!w@)7qLM-gNj~F_d3ZK?a3ZF?#TGj3pTe6u5Wf`iCPm45*X+5Pu=LYzOH2
zU(%G=))dgxM+4d&D}$QW2hrsxubtBq&ME@STOZM;xtscl;_NFO=tsso#zZa2%1qe#
zW97=jj?2A$E;1;lqGu}8S2|-&iS(pP6{4eQyCM~~oo_lxp8LmemN_ZQpde{vBv_Ht
zdsr^<d(_;KB)wkH1$@7<Txs;){1}b^sg;ecF{@@tX54*=W8$JjryGi^j?VoRrpM`H
zzyHq8w|@&^QlHVs6x7d>*Vnaa1GbJ3LDASy8<J)45}7bJV2LQ7)~+;Ur=Sz7bam{F
zR`g0~e=tZhU9Bkh$hxZy;fQwFn78yDM8vcoO2ilSv$7WureS))8L8|ks@9hl>1Fri
z`p!rTV=Dw73B!PP#>Qy@?$L+;iPc4nN01DQ9_~goVrdmH6hUUV``s#Gc%{qZMa0E3
zT3kisGdw-?1Lb)(4yk!B!G623s8<puYuZ@F1|%DlqP-p*qvdodg^X!YxA-T&v9D)`
z-)eAYVgu$swtO_BkUEUOa&4cN1k1^=&hO=%b3Y2va(@VzhAr$X@MgEGipE4^l)JPF
zM=oEAP){lIK?O%&c1I|LPO;rMm}6P^z27@)$iOqR$A#?DAgq!Gf!~SsA=rxZ+VJQ`
zQ$ExtN>;{L2xCE5KI`Z6i76r*y0dn<lR?)QHf3Mypll^AX*NQ<b08o4>`f1s33jep
z=|EGE34R>r_HZLv)O~Fd;a|Kpi^(xM+USO*s~GMQH)Gdrb6MvzEF2=?QStdT+^01}
z^=#+nBfX}R3-V`mS?3GW-~~+1;FUNK{9Lge0}Y7;Rn&tToPCq<YjnLU4h0i{ZvdjK
zPiuG#Xm7a-1f_Mn<Pl%l`L<loKyt<9i!+Kr*>Q?{v0B@j#j!qZM3gQ}Z&5Z*pYE7u
zVZ;Bd-JpYjA+&(<07<EE-08EbfY<@?i=Fl$S?>N@y;X9)Ia;>$OWU~ZJJ5?vyr5jX
z@*foD?fXA_BOj&T*Nw|0A2&|jHy{+^gJEy}yKYTK?O%RUlV3Jyw9nX>7&MQ#>>^U{
zki(xxd~3u}vpnFn`{Gg~Rj%gfrAV&d>lbFTMUF9SgKGHfftO`x>U32z0iJe%iGmH%
z-=c&HPAg8UUaqj@o``>4%;!o<UN3`XU}CH;ZZ>QLf=+c8^K2MIzSHB-OCf!z8|PG1
zb)n)tJn3er!04;X>dWoq5{PTT&|tDqRh;jve1jCYb@`qAYhIeQ3w39+dod2TQ_Uc}
znO}MymqV?1@pRN?%0*IVm%lFxIf)d_7Ra?}m4H}j>}}KOvR$N_Zr<Z&+@ITU>KBav
zoKhQ{(^(}3xJ*P}8FLal5DG!nc;Q{~qb`1b&~i%eK<7hiy#I-{<7DS|+0RG<Zix|c
z<t(w0@0l1<poj1hDl!1HvbNz;5HM)r2?<NCG`WSmn!-W_u?bv<xI#cJO?Z;!0i&Sv
zggys4P*b#ktOPZxx1UBm`YU2dPC!g?%8T|W)Sy9Lpv_{!rcjaJ)lYFVj*lku2qG5%
z91ny-ZrE<`|L!i_?+|2A_$F4M6qsD~UUzjQ&n+S6P_)R9_c}-MQ=vCP_UI6{X2H)G
zf3w8h-fPi;#1QY(v~!VFn$Qi3`)OZ7#*ySJotL-ufGINDcJDVZz^}glXF6vVxm}yG
za|_2`J3<UeL*SZ`KdGqosLevf*m#w1s&N3!7+IqQO3oCxOYo9kGIdiB-u0@vl2=A&
zj{g&-Ktl0lLM0nL{-?EhYy$#+Na)p($?G<m{+i%tSr&F;!h&d9m*5?M2kX(@0!_UL
z`?za9KKw{i+~j!@v4qLL*T-l&rzb}^`IhWty&e`EhMroyVpjM&?o_ZHx3XcX3Kp|U
zVzsJnM%LKEQIWmSeW;9u5*#<7Z#9z<&=Zw`7;M#p6z~Y<WOwk!+s&GUL^v>iE0Qnt
zmrPyIW(-k=+u4(N9^=d;S`}V6d+USdcQdV!FVJ+AnNHxuA^jPd*XuLJa7X@V7Lg5V
z^kZsS7H<NlmPeH#G;}9YaruIZU=0tu+1#auF#O^biP)m4%rs`rR;mj+c|~m+aqQi=
zC9BL5Cl|9FQMC9UA-YFy2PA-bgMmGb;8(8D5Vtf9L%Ia&zNFN$9{Ve0gT)=T6ME_L
zx3blhpIX-V5rC@ttrNMX(A?jnALQe+eyi{eB&7JjLv`k*&?WTa4*B5Nm9z-XvJg%#
zT6;hD97#8a&=isG$9LpM?6RDrXI%<2#x9s-Gv==sDqWBEYtvnSY4y@b&1H(bKbR7>
zc4oGI1N$z@24XAg;}=K&L`Wqrk=o19u_D(NyUN<=C+<gZwaPy#hjrCQ7Cqk69M!R9
zSaP^=+^33`Y05b2@q2XJ%Gn-r7RAZV?5{}hu1+OX#O~GjDdBsGgTK4YBm4G=as6Sa
zm{4wU+*@FA_?(m-KJgAD5f5E8xlG9nqu-Nxy>>8z?A02XS!eD>!S&N6Uh<6W3Ul_k
zxv^D1JK)$+$N0y`D_wX<+4Euq!J=JPeQjMFR6Ad}zvhiJ#$$4CiHfcl(JcSl`kYPF
z3gfx2ny39;8aN}1FzY({y01la8cXfB^4T*C<<$YgD~Vt{Q>1Qm=c5`n@;8GogB-VL
z7@<qy&k0>QhtnfMz1xLkLxRxjot!=<`xn>d(HaF`=!`}rtX)9@X7<=N$k8=z2#B|3
z1OY;q&Ix-w*KmV|^H&L1pIx;7u7ea@$81&wygo#th2obE^D|x2dfy_a{fVFZ!>;dO
zI^S*I1QFqJD{ICKv|JaYDg@S=ZA;%VG_yb_V}ViBP+1R@d#cl_bWWbWs2+bkNfW2%
z0|(huPDQ}rH=C8ZfN!<UMZY25cjhyUI-`_HiJJ~Ija^+Xuj1eX*J%xc(M>gBW~mP?
z47atyeaj7w+!11y?8#GI>~Xt_%9?O|i?$C&wAEp*66liE!M(p<P*h~;$zn{O;4}(T
zyf#}3EvMvCv5m(ay-+0;dq$}Dp#(`S)sJ_u(k+{QSO&+_#+J^k$fHaroC58`NT(D7
z+S7%B15%*lIJROh^JY#;b#Xfu7+}#hyZ%;A|M-2Y5G`Q%C~UI!xYG@pD$P)JeNP<Z
zzX-nVa3v&>YEJ<{Uw&zy=n(+Y*+!?9)p29mFn{#Dn^(hqzFp<3Yupm6Uu*xJ0>}v@
zIM@7~8JqmH!31#RX1Kt)3f!&_k*8h?8gYnmq0K~qfJzL4Hh!uVmCDK+1`#dBymJ|7
zv<?)-8(E|=N&n3k6D}5BXZFc5hG2Q<CZr>?DJ&P`$+=t(V;pv>5&GlVJr}1W44ilM
z6y>%QIWn5>0nXn;ExB-*HJ}id7O=?M)&^>(<D0!t|I|zp9m#oWLci}ghkYUh2Q<M|
zpHaGZ=!9wWI5<SOHjP3Lc}2FqQG1kNT0IM_o9#N7jgmQ~TF%li3(u{{bk2__Xe01A
zCx0EypJgTjwL8>BLXOS~&6w+8Owj$Y;8;`@B%MMbg4u-p+4m=Q*0EQ9Xfg%~VM&~V
z6_>;l?phfxq(>tmZ{f5a;H3kJEHSIjppy<#{bV)2>gupV+vxU!OoBfp>*p5FcgLs?
zmt|WU!ZoI^Dzu7@L~51k(ifoLvVBuWYTh;|Hq7$<BxG8Wsq9FSKgh*J#}&aqZQ4=Z
zr(IO|@wsOP+BibsCHg@fD{$F<(qu--S;U3rh|RE<>W(IRgmhs_4)Ho~nP6W-P?$8M
z6B5FjU&rz_cC@n2ld{cVt^<=g;Yab|xoQWkKiS!dUbC27pN%it#RU7nFs3qe1flof
zSHT$)xe{^1c|=)CT~cb)Cl4dbJmmVdf(6*?Ic6(3{uWaR0T1=cq+y~ZphukvFZ~*~
zsu46S+6`<@CrW6HYl$O4GEQ=?Av-Gg8u^8`T;R^SB4CX4$|<{=-3e3~NExk#dRuF&
z+tQ>Iaf+$E`}+ez;}*0v?hm{KM$YD`l}%k(KIIspn+?dNwdhJlZErh9=kg)p$c&>G
z>{R*3;r2SB5~a*NHCDIaN!IT`)tL8R6%6{^owDxl$=bIQ>kTtaf1*xmvd<TJhz#`;
z%rX7gnUH%l&7^&k(C2LGNbUYI2Q-#y_3fGt+-+}oP&HbiQ()Oc3SI{9U=44zp}?kV
z`=Dm&*!!~eXH3-{$Kib-6rP6mKA3cH+%(qqc7iL{rVb3JDg8bQ#4BQVpR+1Vt1E}D
zcIU-<SO*%N0j6!@b?<2ze>2K-KawlTsT_Y3(=I=9IfWe`N;TAH(2a^4K-M!@?Q-wY
z5%!81i4F6`LGm-G#Zev~133-$S%a@Leeb$*L{O8!Ol6fpr$5aM{}CTB|KYCdM2R>1
zaeA8NkNCUM3FSy9;ZAhGaNG+No76xp3Z6UZH-d}nxEYjJmC2>6K4HsCeq)~A^h(SJ
zpf3=^1+NQdLp7RI2Ksx|MtSC4;ZwEcD=&_XANg|s-Ac&F1jUF6q`#PL$eZlqt+s8&
zbyw;7L6KZ+^5DIo*y~%~ew!qZ$S*jno4P59j)UC2&owIo2mJvR=#9olGh=S`w0Sd5
zjJ3$c0kS`k-$LSU*-Y=Hg8L02-5U#nu<Zh_gr)tw#<#S8{Zdxkv90IeP=cBQJ+j7n
zf*VvqJ1Ws{hWOqQTzyIM$UmB(dXCe|FReTj8*m76l&fIc#8}?JfGYXGJ1(r(2K~j>
zTdHNaM;7w85U!EFH*A*Uw$lv*V6asj7^M@n#?Va6_Flc!lT&8rov;)V<1>w@1>QNK
z@m?vTcA1w3gjv(+LNyB246oY~Px${RFIe+h$4oI1-CAdl14yEG5s4<q=jk~1d1qiq
ztGJQuWc7AJc7}}TXWp-EMth9+X~|BtJG#A;8gVvB)xHLy)_d|(p$%kbaV{04NIfLi
zdXLmdxxT8CqJ9AAr`V3E&=SZWAj|E}6u%YN%CTy~a+VL`UAG@&DtH$`>u!LpW{2&s
zKxOv&?VN<loM$-cOoNmIW&SN`3E!jLwu#xE7Z!MTTMMX$G%S0<|E_>Ik;;LuF+4$F
zDZ=qR6DtnkmdKZEAG*3q#)JOE7R-UqKMKjsOv#_bAdO)sxn^}i?P+w#tk5TW;ht!4
zs}1}1={y?$q;yPcNgez82!am#HX#KI`NleQ2rk8JU5M)??JTQ3oN2-C=JI<8a}W%A
zs>ZrLU`I>1T1)r-hVj!)A2@fVkK53N=z%2Z%=2Wf#mTu`Q>yYPkkO0AExN7Ul{K)w
z8Bjy&oJiE`IHzXWf>|O+cO&~gtFppl2WOnwr9GD(3&3wy=I7ci!&W)Kz2ekAmJqLy
z^@e})MX>W2m84)~R`K{Zd?f|7EaguJ&A71p<F<WJXWX>Tt$9GHb6sdKw3JWa>UbD?
zF;p<Jei$aC+LY<6{S;TbgaH~}<rBua3lXh5qg@q^-`|H>p6(nF^cr?C@l<VyAirS)
zOK*N<=86y)<vK%G{#o(_&P;dr`?H?DE;_3Hy=9d3bxef^L7n?qP-G?^mY<(4ey)gD
zQiA`dr*Gmgk4eLHEBzdT#nUmmOb(L>x-0$kkH>)o8`*S0+GHu@vxjiM9v`%1j~v_<
zKPu^;vodKO?9@HJg9Ng(EbL2-@qe>K!879AL%FUEqCy~t^LMM30qkFlx_|6)il<d}
z3RtgRwosQ??$3T}st&BF+@<)C76)%hr#pJZM|`x>dstcm2mX}J5GoDgZOgUmznO2-
zOgN>iJTr4$Fa)@v)Cj^;ca#L>o)f0{Cch&#2jBsTUnzfI$>Ps|=r?y_0-cjUx@o_c
zMCzfNT3up)yamG2MM5L@8H36k&~JZoEL<GQqd7qOCxQc<p)VxAfS@c<Gb^p3VSzYr
zH~BWI<3YK2(XWmu0&U#oE88D#k8LrPAY+>go|Tn`?PPz!RZIDxTXUDf6@UaV)N?Yr
zy{LGSU0tmvR@A4qr**)?mcbF84#k#eC6@D&jcsj=PA(Ol8H_M5>lX)6cbA(|3zyCu
z|51bNGLlWCrl3C(eXUE;WJ@|3Kja<|bz}d~7#M1WYz#x0QzghTN4Mr_Fct1O><)%1
zZTm;F?~02|HlIAsSf0be@DQh=KchqIH@_BRwX->{K*JE669JMskh!kJE7z*}+h70P
z^36)_pKZAZK<<#Aq$0wmOjl>q&alFCWX<L3`1p#uR3RkK$1xWF6cn_Z1n;$H&SXLi
zi3y8(?tWc-mE7}e4*5HVBo^!9Cb_biz~E3hm6K2a1<dk$vipMd)Gld+Wqqn<RW!&2
zh@A*u9}-i?8;hDpuC%y=NUB^K-KeJ|Up(t|`l?+{oRD7`>prC*oRu<HSzq6GB9&U%
zq8WTAUriGPBq@~%N~2l7c|9ciqCQ&wM<jcn??Gs37w;(HY?BgW0VYl!=E6P|{l2LO
ze-J3>h<>T?M`Tekc>xB9O%>X>C|77^`+}}Ma1<grv(GEc04?1-U^$kCj3r9_0dh*~
zX#*3t>V<p2^Nxa&#z2s@kFbfXZ2z!>YlsK{-xy6sedgb(aZjy*zk-ZykFe1bn&@xH
zfQ~!3t#)E}wBTxH{tx1(%|$hPq1I?i{viD?qL~)1qN>;Fai+*Gy1};`ITJyMNB+ZY
zH6WvGolCDzsXXz9c}1;`C!IYff};Tm%6kx=xr^NU1(sgFMBp^5F8!Qez6D*@(Yp8H
zXS~=fr96-YG|mL%ih=+<*sPOdRQqSj*9Bydd<eh1s)U&R0hg*Jb=|4h>_U%~!NcPO
zfMSwSxWD+9J8)1hG6lYEQb#E^S8yIL;-vvJP{iWGh12x{JF1v9_hk6kXf8INs7rWo
zB~=VMOtCr?oOybZq)z&&sO`%?e#+hT-p2L0&w3JGkewuy_SwRbMaTA~6d3<`2sbK?
z5T#BQ8K&BcL1&*J{p-BW*B!tQx&>}^?cdRa;pHA$0Uq6Q{_z+6Hdn)pNw-1(W_T_4
z3&JaK@+Y?3nPU*$uujKkDA2@(!;Ib^+}7Y4hugx&TmKlIb@0qF8T~KemZdZMf`YvY
z!F)}%&|Xbiu4lf4tg-M^#DEQWEZqe&h*;`)3R^slW=zQoPXOT;l|01GjXauZ#zCv8
zYQp0FS-n%og`HQv=En2D0s+{4S#;i!3UBwKAU|P%p|3k@N440?)_v+?N>ORwj0t(0
zyKt*0lK;6z`JjKxRnP)`WP8GBy!XHNF7Lg`uIyq@SC}QeIL(s@epUSCGu=e!OrmHT
zgCiDoLy>nX9{Tmz_jioP13n~~VpHToOP23EqrnMmG^yDQBn#;6XMrfs)kp|dv%jaU
z5uvp@Q>w!bEplzBj+!e2Z6IZFS$DH91n&#&Gw)777s*|B8=#tVgA#Ot=f=85y{?_n
z^@b$SxzU?z$7~Rch}WREUutIiV{o7wgtob3-OMRp4s9oyZ4&I`xf2pmwll~>aBmsq
zINn8ySe$Qv$l{(R7uDPn?$#3`UiaVa^k(f@^vYVWA;!GUDX(rwv^$>V@iFuW-UNfF
z=|N(_g@!$`3z-cq!;d;4_}t}xg3SF)a^BV?QgI^f32lV1e0G>%{?>30%>Y4@Ks7ip
zVat_kpO6a<v#en42q<mE-R><-U;Iio^Ui35@&4=C`C<6v2Qs;AAYKGI5sfFU8lqjk
zD&fd|oFc4Y+^l-M5+=YZB!5hHlH>XMrS83;=O*D+u(s;V3`K%gyFw;g=YHtkuBF3$
zzKD1Gy1byGWR6rJS8KQ^bRb1m*f00*T2~37VV-9+biR!DbKc1N?81l+s1U#Yf5|L4
zVBv%#;k9AXzRZbl!&Kd80I`Nk6>3q@NboRdaJkt>uG>IAFeNhQRy0Vc_^aV(th-Ph
zIp|bTi4;g_e2E*+0|9Fa?wxb%56T|#s9e1bL>(WCmo~<I+~Z#G6#op_GK&%t=8iDi
zm^(nuy@_8)d`NZZPs?=<S$r-Ev!r4A$vRd=49ud?H#FD{)Y4-}aeow-?C)FEkiLpa
zSqxT0$OgaC(mTBo?Gti{EU+Soc@D=2wRY|ust?cSRUov${=83c+}O35NhMSD=E+%f
zSXd}6t2T%<>jz~Rw!$Bu$UclH9u)wh{IvSD${{EhZ79uPy}`><Lhk3EAl&h_--8yG
zZwgdu{~5bqgCsT9=i`^})j|5~ij2~di=)<sG*L_#k{pbr8mH1OT*-n<4PN8ADAt>z
zZ;bdk=Nsssc?Lb8V=pT{U(1`>|MqUkEaWqJvTKk4uNnGsLlM9Zy4!9G?03E5{AjfP
zSNW<OTl{X&-JUQI(K-M;K(986ei*{M()2&lwev4w^t}JD*weG*)crE!7vHB62V6E`
z3B2B#)k4biE3Mwp+z7zHMSJF>$$+n~8RazCY3oi)N~3AG8ds8XBm(*McPPd=xeZaa
zHmjlfKNCWblUBRE^J~z9brdqHIcKH_vXeQfOJ|x}6aniHw4&v=+VPjGz3UgkWDz)^
zXI9jKOjEB`^Rvc&Ov0rEU2%)%a!mMl+6f)Ge~i&QR&~A9R=_0VXpIPs-VLhC;cn_<
zYPGy$U0|{vT&)8yfDi7tD(t`ASA)hRy8Lp{bS@c#2a$8H_5hITWe*}NOypENg?#C5
z6w6<5Vd45bI$)KiV-=D&QucaSvd7aIc1s0w`|Q}V&Z_O?AAHxe-=LCPH6?*5s9}5e
zb7m5pyWhWHiJx=F#?F-JCGoW*tzzq_?H1FsN(kxP@{~ziC{Xs4&?w*`r-InswCqj@
zvk_<-BS`p#(KQUaHCBAc&S17W4RNO4Xe(nR4HYX=0v$Tc!5w--BZhJlT~k`I8lUsd
zE)^(IO5QI-(9J0no$u_DQqpcU+$+j<HV9Jp_;qSr&nZQ?6vVB`pt;PjjUNi>6q%Ll
zDwIvj=MAHwe$Uu^CoGtS9hs`9wWErFhXCQO{9e?}aX0O<+$MU+HCx_PQS#34PS#OC
zLf81-{%G^qccOH^7K7V<`r;4R+U>!GCjPaP(YIyXultBx*@%sRHl5y<H+?0=!+_OP
zaL?Rxn72EPTef)kzGp=%;3lW1g5Obe*1${D>13%;AuxD-?gklz+Krs95j5z15+If_
zg<+%?B3)a2!S{*9?R}c<EM0oG6x)|3DxVI_)Vur-Qs2<9Xs7OXqtzA}G_&$~F3tV7
z^xF>08v_bALH^$CF)QpbaC_~O?Y2@lpst`mSeZS4pb!A>Aj6>U>Dwpd*)1do2U{n9
zj3|Zd`a!uIOrqCvfp}@ZEbiNY!w(NFNaZ*aY&@xZ5hC9h8Ndk2vP#%lOP;A9uQDsD
zmx{Q7Jo=VOSvj0N0#2^?Zc4T_fp{m*frxA5t1hGN2jpoA^uuRoMl%lIBqKtyfbrbp
z^=v++cgV$|n4n3Un*GDS5BmSZ$m#zmME>9P&&U-eG%?Zj`a<wp^u})<2<6>1*_uN?
zV9x<lVPy(1fW-3rQNn2^Y`kaf@>YJiT|3)%j?&=S4;|YMX-ulm(V9udbRAY{blxaY
z)QIdP6;~u0V|@ubzm^Hjr$%*VrTRX5iv6brBVn-+tENPQD$@a1da8<sRPQQseHbF8
zVt6a&b|4?PWfU>zf+f_|zyomI&vc64mnF~X%Mf&qN;UX{EqN}--_P4oB{~+{kk<^H
ze0HeAFp55_j_<97Na8g<(hMv5Qe}R@t`*P8#4e0U6?@sqH*dq)%`$$H?!Gp=@V(!s
z=SB}uL4EqVG($!hD9(PhF~!UAXMIKd+RsZIi0rOB0s(HmK2Hp(eEmusWP1rA^GNzX
zL=0(gN0{+rUtlbaNsILpPdD2L3XR#4;b)L7A|t~zL&&bO4szPRy1MZ?QbBme_F9a}
z3F7_``HkccNNvN~RJOT<uTEAv#MM3Qj5+3<mg!?3$k291A5UL^cS;o?V-fL#=I=F5
zSq9^coY8i4leC!bg(`TySg58pkmhTCk}Ck5=!_z89SxiCkdBCbf>6#w26<g$TpTH%
z(j^ErzV(?6i)^`A8lpmjXf~WW_4UG9l7nhzyh?g#`6l(ya$Agq`^Sehls~gWfs|dX
zH#^XOapr6#aP@E=z_XMy?^F2@{{Tmxh>k|Tn;W;`QIV^SjK$8Ez)1f6CH1p%D+}oS
z`(aO@Xf&RdFltWQHI^_qo}k<>Sou|S8%YTHot5+9#UT1Z=FhTwjHWr9MZ0)SO9KF}
zRGCS}DOOsDX&n$nh6Qg7Hk{5!K<VoKnW(9Cj^KF6r~-R^Sz+mo5G7Tj*@qJYiH?$T
ztOZ1Xi^%J1-jz;|N$7E{x8>@m`xwwU@8c*#)@PBX>wU5SAPduQ16gw83bCV6@in`v
zoGcwyR3F0O<R`D_LMehxQ!GaDq<S?cNd3dOtMMEHd$=WLc=_>Rnzo`2;5E+$<h5$N
zR2P1a_J#IiRQo~1TRz?0cMpB#ZJkU0g?qRy@j-N>)zM!27siCwH1uz-$<sSA#pfKp
zndd0nF1D?jiU!-Y-a((W#y>T?lX;%XK^y+$!DsgYN4rq0)JHri4UUxX8Ld}~d{ntd
zIu1}qqi(-j263-DHerm(%_bca`Ol=b-+7x{D{wyr_856J69}To>9PdCAD4OpN-dn*
zhFG6}Jvv@Qix%sp6nSgw%`iE|5r;PtRw0R>nZzP>z=A-$t9<L2H_$56(x=L-O8Ix4
zi_mJ1{*FwcPN{va^XJJ&y1=<2a!XUGA>_Hj(^>dd2wLWNM8dmw>eu&v<TA`~M@tgV
z`s(YPSk!5jQA|md^G2+<Z<U(QMhHj3N)?j?b~LlQ0?IQ%rCP==@9J;4MAV!g<{7s9
zMBijyVfU>`SPCOAbVUxc!QW(jbZZVH$R7>}$kG&Es<RVi0_3~9c#M*ox2N{#PgNg-
zI|6R+P#rPI{m_%Lfx=pFf9?G}h#tK2bmL0qNzO~RF9J&zyG_Vq2RVS?Zb-AwNc>Jc
zA#mUK#0@!L9^^qgP~o8BBX*OZtIwJ#Bg=CTSlg2HwDOEk@Y*1T01N>X+@~Y$AP_Hg
zZYuk_baz;NDRQpLi~9vJVM({gp21Y_d-B!sg|!O?AUeDlswxoeEs@mvtNoJw(e11w
zyYCQwA(iU)JI(mJucz?F>Qbo#Xv%nL@jH*m=;ku|1#@$o=&jd|!2fs+{NEfnju~Fl
z`F#a^2)NZbfTnSvq00tX)s+mzsB~##rFUc041E$$NIk+4uyzf|&l4)J{6X<qkO_;|
zuObI+&{<S2{N3eX8tZq!gy52ARv{<{uR*~KTjN8)W{%{DjG2}TjDNai6ieA(wyCRZ
zs>&zbN|mWnAu|0nr>dpJ@3boA7u_cF>bZK;%yCoNh+<-wB>u0ZLTlDj@tU>vv#`~`
z;or{L^jA9g4w-4wgkItwzS~yORxNb;#l^*xXN=WN$;8$F+wFlRjej7W^HLY#vbX=~
z5pR_A_8Z1ZI_5z;_YEfzMcc*@xx1H=WpKH+=>pW9&=68)Yf27zB4lw7SE`l~Tz?zb
zNq;%s@Qr^npVKm=?RcyGfsFDt?t2vz$gp7FtyoLon;<KxeB>B-hFyT_jNN2$Dn|Hl
z-yI}*mPw5i_y{q8njMUpICoEVCN3PA8^;I0CLR(ujafk%5@_1;4V)zY|7^Bzh`(tS
z3~Xf^klRcalW7&>`}M!qa^#k_u>LV=LKU(jr`x4c5wT_B7LoHVyf7nRw&<g#Uf<6u
zi0>|q{h_Fa$D`&6+P2LAP$-eW67X0XnG7*${fpab@VZ8RC3`*qn3RV@PJKm_h`Hv+
z#NmMkvnM9)=_28ZqTx3^f_~HN^S;F|$v({%1L}6)Vh(o-AWj@C+4R*2`CiK_i(Zh`
zQMRjkYSW>+N2>l@;9W7vq7A2-7G0FUNFhN5|7YX2AbS{56I%i09%n6{VXlb%w)(t9
z!7%_!JdyJl$v+|P<8s%<{IqvW3oYt6kOMu!1C&8Ns86oh?$1FF_4@&QpdHqQJh4$$
zzo;C_z;maqZhD{X{;T+-NIOK&E@*6OsxmPB?CFz5@ZeFSQ{H={j<x`q+<MJ$==QGO
zNSo>;v0?ApX&d4BIh?yywv-o~OHJOy{xJx29^qu%fr2_Eq;DawGg*|PHSnO6)3Z1n
z($?h&ewY`SE$F&h@ra%+%ETR0h(GK&Sh?v%U;v)aH#UGacM&ZY>qWNC0*O6QAUjXz
z?+y=GCO$NETPp_-?;0DfSShmPd?TI4fd4pek30$8z#;JS;1U`5&iuS1AOgGta~uZc
z;<R6+1D>Q&Ucy=3wO1(><j-5PjeFRs3nb=kO%B^l^ta9^;(8=n<sTko1nUvwQNnoO
z+~`YALafvs_M@&lg3Hf4y7w!_2WuV$jtzVooFCAx{!$x<3Nk)PsAzl5^WEQ+?_XOM
zhZ^qjfF1BaJ4s|mXm&d~D%Yds+znX{xoSAxKWVGKa)ZPGoX*Opg8$d`^%<L=OyNG}
z=y)7(%n3|hkL=(bK)_G1*V@Nx`{auq2r~xlU`lN}d2uj<vRdgtHAGGnASl68Yv)}u
zQ2tZ_)9QBQ+$XyWPLRXE3%tJPY?%OA|L_8pi)8(%)1G(|nt-dT|C5sr-aC`oP~YdK
z2j1xuoq_WIH~Zn$O&v*Hp;r;c7Jkd-J8`Yq{Gf-^;!@vS%&*yyLSPiyd3=17z)Z`E
zDb;8VNcs@5%|o4gn5L(?4h9VidAVf{dHRWM;f#dls%fTGyEPc0>af-LN<6!vs}<5`
zT%R0Q>JxCWj&jO$d1_J^a*bSoSwAQ+r@c;SV@A|kOW|wVpIT&j$SW%XR{Rn?!d<h*
zdhkjdb&&Oqt(5^)Zd*GOc!vhOV=@{8`FxaJBf8h1_z=MngH$sWE<7GI3Xh@(+}?cH
zgPq6Z+8V*P7u+nWM@B3uTK4DTboYz(-aEI=puwqlbP103y<;v@h4$#9wwQDTY^s=G
zQMXUfm-=#^sRT+=6EkF;%Ul`+8PoWcHd6i%?AiVYpdtHLv0E+-Kq5G>1J<b4kfpb~
zpzBUL6^);zT4yDzHA<!^eSd&<yr8719QW96Cn%v5J(RBAaAy3&D(*Yk`u^1xnqNo)
ztImvs$M^~d`AaW>SWf9u53>C*Ha~Suk0W|bZSYQ^XP`K?B-%;b8B+#u&}Sph5F{*k
z;IT6mCeTC1=5vq_Mw^ct#w3D0V<CspV6j8r?p|?w?<A5!;g+xFH`DAg4Bb9p>cagL
zTAT&W4$UR{jL)voS3!Pd#<Chb(<_NnP;ASa+5g_IKgDjAjW59os)@iJ7m}7VSj7te
z{8g|0<{i2dPhPm^)Qfi?qzmSyqt5EXRsZ%>^AJX@c82MFUzE8Xw40@W=}QW-z5*8J
z(V%nSP<mm_Z~~C9rbSLs=+m`6XlJYS?e(9&O?XiujwIUg{w@Zn#X-<iLIUJ7>KyoZ
zmCOR(NdQac6e87t#@?g0-aFRH7oK7Gun!!21_%8S4*-p8f_Bk6wj*hya^vIH`L9c{
zZx8t?b_{ww%48GTVzO)_G=-__Y5(r}={je9`|rSMj>><<?XijN+ZgzzpmP<!+}geJ
zW{4GOV4YwZp}^`aTJB0N67-Fug{y$?a}b+V7jiJ^ShWP**nDb$%x~U|qOKkm!!52}
zH9Wj*Ofui^X+$&`%@U&>=Vs0)<|It!qBqc;i;o>>lX2?8w@O<XC4;lXPv}Ezh!LV$
zy*FqgHhf2`5=~2%epZl`y9L2F3VO?ns1|hpS{bf^mP#+s7cz=QY0G*-ZpHVOfE2z_
z#{Fm95G%>;waP?wW7uzwCRLI9t~39(BR#Bwi#jfpz{$;^=%UV+(CXkkI#Vt@KO+$r
z+ydl6Mt#0a_(xxqWJ|J(JZc98Vt*Hy`V;wO`w+(8=jIw#qD@q2^|AX5q3X;CsZ91I
zRi5RImk-X*7gD|Lo$n4*PgGNd0Q-WKNE^)gP~~UC;=c`pSwh*oGBSEVi)iFio}B$K
zT!S0&gDeQEf2X;|KU+7<aVWvRl}23?AZ`)Kaxp3S&`^rPk-uT-B*dU_Zoi@gY)^2j
zwWlcTU$~LS)t*Jlqbn-hk=GZ`Hn&B8D2wzdjv@_OWrq)SOui8Hdbg?W;3Fy=Ka&~|
zcQZw}rY^z2PS#mQP_iy=J52hU5w)zb)47s*ySk3^8C288bB@2Clcz^u7I?dP0uiIN
zDdXW;fY}3paWo+)8uBGNTzzocjA}X;7CKUmVe%2v4hQ&KrDAXwAZO1o)frfuJ)O%x
zBTym8tQYT{Ul!J$2Ows=%j;t)==B!*d_drjcbHGS??Xy!!zBFOkvyyC{H+Yg7K}|)
zUvR*)1jO4#vw~&9R?Ils09IBe6f;}F2X0(JjJN*liapEWXuYkqQ3Gv<5cw|^w{_e*
zVTQ_R!TS4v-Q$CvA1ChbqKVL~Ddpqjh6*`WLj*WX2DD`SF9Is1>d*F*X}GhPiPw%t
z#Qyl!xv=pwFXS2_1!sRk<?31u`MwfGr$MlgHZpox=TesJg-b%|ApD7EtbEc!o}%;8
zuyZ)3^i0lF&~uj|<qL36OP;Cs1sMK;JC?=yWjf4*6W@+^_}Q`qT`lYNHddf;S+Wom
zt^#>Kq@GkN)m-<NS%TkEaHpLXyB-c9h%twI`1(N7M{K39--u2`j#ynDw4V=9_FKAL
zA6=ko7ZtfM>25UKatS1M-_4M6ZBusEdE*&033Y*mov;}B>qAv`K`@H#i+AO#S2Ld2
ztM$F|{E40vJwVsb=}wahc-f_faZwGkh~L}^JC5^-^xff6c;r)o#+2gW!2Oumy_P5S
zbX9{2Ma=nfZ$DhNjp9lg>}0nIQuamY6ehTyYd(g938&7Y_ds(B2_5PI$n=QqA2yIN
z;4_R#ovS96O$(?kLB9d!0ifu60U6_ij6GFOcgs7V*DqkyPl7q_)WqW{r7WGIkeee<
zjJwwZbNpo~Cv)8mpfIMI9Jnyb{EA7gWAXz_BYQw@@!kU757>VhzP-})uQDxPsdy6c
zJ?a&Ocq{G1RLzo|o1dAvxn8Z%*MeOp3hp@xlj{<G5emsu*u4Og@yyXUYhwB7+(%@a
zU>3Oompp%j7OP1k?oIq;!~=~FulyQXgCHr}ej>wH-TH+W99E2s+dKuHB2>}4&ak*Y
zgR7Z|mMXZ@9h_-=B__iTG3Ex`NXB8_MA|Ox54+ryWyyNx7XFZI0iny6`-!&{?!0v+
z0q=tPbXKRpJ4({#MW>JCCsK#NYs~z1<IFt#A4z1_3Kq!WN`w;-tzMP2#M$6Fp9ymh
zY@iD0#p%q2)VuB;8Xw5uI%9ocIWGNhumx>oj~zT4<MwN6JMFULwiHbJ*eZ1G1+`f(
za5bOEw-QY|+|Z*@<y*n1Xl_GaA@@0}c0t;(Du&+<1(`1MqC}=-#`;-Fk8rPdY+d)>
zfAmv0*_3|)IyZhg{jm!&JTg%P%}Bqza!xNX<-TYVr!~@E9=s<4`D`Su?>)kS^h#>d
z*Jz6mQnHCkp}|tuLZBmeA+L3^Ls`9SGNd!KJUPv8`a^kRwG38j`RfvR3imj(%~57e
z%)VCi*9UaGYdz;lWKKhk1ogOMbFa<#CcC$92yCf^w5g`z8!Eln1F>ESu!lQDjxCj_
zwA;L%>D+$pUc&VtiigyHa76ZNWS!T3bDU!tqWl^fv>aG!kTrBH3#ij1K7SCd1~g7T
zA@T1dpCP*7l9b1IubxxCV!p3@rOMV8e*O-7a=G=hMP84(Mh;?B-Z!`{iocMI9Sr}9
zov?P~RJ<%(nkHppMS>#j)YzNmIG#A&CqwB|#N@RE6^d2mS?^}Z%1Pzy0+k3bIH2;r
zKOVls%?fUDuFfL35aM#0qq|S-D)mE|v!w`eOg}{bP4s$A{(pM`Tus#0ceJ<WfBK3G
zTJk8M_<4;xqLI_(#2!vSVNvOGMzpwM&}SH2^@3)b`4y=_66l(n6hkuLx>wY6n$W}X
zDI0YD48f}bu^6shXmLC4g~e?a5yQkLgMp0ToVHs+PacY-S=gSgsC_{XSJv-PJEsRK
zw?}cm#`ucN7QoOU?yCjr`0k3S5Jlf8!vZ<~^vTJv6MEg&`1djY&e1@$lj|2BT2BpF
z<>un{1L92KxUl-FkYw(KxH?|Tf|Qd<ft8+^Lacp+!t9^rz8s7`N3Mp$h*$RU+>&pq
z+8fYQFhB0WCBUjOkTld5#ZT2`Gf{!j4if}H){uhtkb*{0@T4miWimZamaNOoaI|hD
zCwgsTtZP}I2LCTzHlidZe9`YTX3=ET*s2e^zGTkg*w@i^vrJz1ilBLtE);<Ap;qO;
z*fFgGbZu&Gk<v#ybF3XiLpC9T3wt`~NgQ(2f-_4}uQL1ER$i|g6`6f~GApJe^-ZI5
z#%%k|A1}0Q1|ZSskW3JCnow3Va3vid#-lR2XGxI*YmHhEX)b7>b+!NDCByZ6D|IJB
zO;cDYsZqQ4>Cp_U-h-mV1w9Go0<tE%@`Xqies-M@daT2cGzKP$U8<SM#ZkcTFI{h2
zVtT&+l1h;|U$IX*&7|!W+$}v&e6&xyDNH{^ef>Qu)0D`|I^X7_i?Lmd+))^bh=Ldm
z(LZE>iA9}<|69E~eyYC8cKTvqm9i}*3xfO0`sievk4G}dHKuIo4G&F<G@UUcQqwig
z&<-v~&VT*T(h!LvlzYRV$C|htaV2g#iuIhE@f&wB%O8g7A>aK!((OyWF01T;E52p_
z-j;u{lxAVf2EWy7&DKc(n?IIw3B=Wxdfuhf-N_YN%BdEqKRbAI+GG}wnq?C@%UB#?
zX|j5C3XU~wL5_dOLocCg%R&q0zyI+13jyO-dzZx;bXDJO*~k^eYc;uP0(B`~PITJ%
zZn~6Xw?whDl(@@}&grU5A^5S0&-rfDICDlBWveGd4#xSrU0v_wHsV!Y5@RCYT6+<z
z(JM2KgM43;J~}H#>bD<?pQXSP!V4j$nI&$;3*9C+=pAV`+g1~i(7SOOR|UC+grd<~
zn>Q%zz={k<(swthsX^EZX)HRrTGR#Qz#X)ul!q+6=^0=}*Zh)5BEj`#j?$sa<F;y!
z{)*AIxt!kNb0KfBJE#?3ko6MwB5k5feO%&OlsxyzIgWJG_^dMM7m2>C-KycxYzISG
z%5?Uw#Afw?ubXVu=0ZU^XrWzK9sou2k>|kvVBDkvQ1$B&1zui5I73`yiCzs21FYV#
zrP0i2K>odk&o0GXCsRYll((bR)`KXG|7_=5!S_M7OaBG2D^4~@DZcVK0k>rWrxHVC
zawGb(E;c-(nEv~$h1cdd{bRFM&&nYo^4@Vc35Kbqcnoa|LDy0Vt%`YyDfUEO+Y8)N
z9KTz4f}EpT=Qc%womYV-W9<3H%k35CAj^~2!c<#*wkHP?fFp)SDOBk{5cEF=24qEy
zAjZ5cSyUc7fotbvSz+ryYBts9A$STjuiI%@(d}-%h-mPkcKCrKwDk3Nk$5I3kTyn0
zTRH09)}~C6%`HJp30=l5!Sojlza-(_3jfdmdPM{BiAs;n?X>vYiupV2+EdcU3gce&
z+Kz}T8d~-{Xw+6n!9tqY`!ie6PJsXpqcc`9RQxehpxk7{Hn;VG>oQ*8*rF($5!I8c
zAkKlR?(MGXkRXq4xa`A(T-sroc)f)v1@wT=o_TZsniA4bZHbc{8_;<P7jDhnKjO+V
z&f*s{wp7e~G`Dba20wPkySO<LJejyhY94`d?l0oKoEzeiXhhV4D+&TA2HiZ5#}|&w
zUd;wyt<qMwy#zr?(7Gr(ZzZfg&Wpk-r^4lCFB3T=db;wFIy0bhO!o&D!-BXIPLJ3E
zJBp%{w~V;)hM<fE*@#{HEz)J!dZBLg9p~gd_U0Pum2q5LJx-0a*)naV|A?8S(Z{ry
zT+0#x(U9L~+`+M9DyM7f6JqfC4l)K<D5KW*buHF{-Owy-qR@i<vYZOuE4gw#h1w78
zBU&WJ2lZU&FP!(67IaM#mPL^er^vYh)p|e9xN`{1DX%BGXjRvqA-xT_MR05H{yY@Z
z@7r1)zX8>x=2q?N-pioM>53)MmYCUb#E+^#`wN<`=3wq|WXEYyg*>_~?pXCz^v&BG
z`ES|RJg?jua_q*!GWr5JhCD8?%Q!5&n}<x6?eiL8c<~-oAfEtydCuBUgJ`AuyUfsb
zG&R46O;Vb}<O(Utw(cwT@IG@Po08>*ID>T1a@BzK@r%*&Cs##KD-6;ua@xuX;>{|@
zaiS`Yrnq10dI7mY4w<1fjqrgD(G9dPg(&G-+>MGU3Boo((8}Pa*1rm2+mn>VdL`y&
zX*fKbQ++hC<o6Tb_5;fFJG4G;o41avl0n7}s0-zE4HN&Tvi*N#0Q{%wwPMDEjDG9%
zUaiKGZUc^65WnMtDX9z0^XzOvKi{xV+Y!q@KSJ-)mQu|E{(=r?gosCn1H2~ra%dc%
zRan4N#NnN5#14@yZs@nrTpR8Ir<gC{_m+!CXA4~0e||%x=NBP`e+Rs&oW#Bnyumv=
zJLBE_G`l~w?@mQU1!P&SXW=ccopZ){d=gx%A7Z@xH5g}p^S~MX+?N>Vh7nqJIloeX
z;z!zo*7^6uH?BPrqBygFb3p1b%UENxy?tc>40(h1r$7JN)-BW+Ry-DBevl3#!wmG;
z7ken0*mPOCK^#X7o`n2l-s$Naz=mDt*H=nLaL}5(brJO7a29PkC>ar4Ir%c;S|5-V
z`@6@jf3r_VD2oS`AV)os_NzD-BJS(v+3bB0#>mc;tjKm{^TzfchRaoZq@_P2kP%f%
zFOO6=?e(XT_(WBWf^5~qQhbFi8gNq9q1gRr&^clYe2XKjM@Z@dtoo`1|0toBB_Zw$
zV+V!Hkk0$REpWrl@C;MiM$N;>^%9Mwx#d6^>_cEY!<YMVyubK}iye5qOKGwNW&3s^
z<QU^ZPE(SNPH-t-8or?pBBoF$VFC1dM36NoDhyehtn+#k0*@*QdzYjod@%C3x-WBY
z(qf7P3?o=kC=kZiCijOKVRA?4cWBfe>jzS<;<E2zM%*Lh{3;FmR!Zw#bX`HH^<Pcu
zM;_cl!C>nZI5V_L#M#Qw7O-ddu`v<${-4b)5F(3`%kf2CA1&tb9E~7`nOtvxegS$g
zYsTPxvr4AON|%jJaC_KgJyX#pbG7{;yR63I9c8mXwc6=YU>?!?8zcGW*F#;B#hQLN
z>0tp1n*1@e*KP7mb@5M1?KOMpJ;NeEKB#r5*9ol_YsvaLRen&WSe>uNx3s?Ym1<>U
z9MF<vBpnm|)qz@Y8|~V&j`_J|ri>pBzqb(|n?A^YmU1_&3t$bvB$)hIPA2D(|BjJZ
zbsIjC#8X9J0*gyLRXDm2R3B!%J`HFm2-?%YeLY*uhY`TzqsI_C7w#_Q9M9M1vDwtX
zRsZRUPJOEX1bk<Fa_mfbweLSAswYdh_Rb$oqNOp|+n6A$B_Q|hg+FEB^5OGUtd*Ym
zMNF7Ca|rRi*YWYytl(m&&R^Vtd}R2z0ESOnP|k8|tlek+;93b2yQl1RkRd=Txuhp-
z8nH?-UbXZfJ?ddOcE>$-KBDJ86GC*c@A)GF>gYqTdsSqs(Y^IKDe-o^4B9PYKkj%!
zb5#W1FLUYa;2UQkQ@o;yAM+QG<IF&vQ_@Im_rS>!XUT&{eSB0CmMpw);1iaQy?7da
z5T(H{bBGnK=yWmPB6G2e!X2CWl6F=pQrxA`(B>u%QZsNu%%G=`RbS8H=~PnvXgfRM
zkHf{h_R7JXdw(h3wcf-$`eKb!tzVzU6rzO~yy06kp}ZrDrU|`sU-YerP(ZG&-$7r#
zszzW%FP7{1RS?U4GnTQ*8d+inojXP(cyr2Wii89xNcwQ`%K8S7-Pzj(z-GI-e7z{R
z;^*eDmmB%wUyQ^jUCr{3!fB@mz1}fkk7P8YJz^nAP8!mR>d21fz#78eXCPh2*Hw&?
zy?d(aO0}ALD~<AfnO7yn)5znuD=0&X;K^(zI*y_nO@J^B&-ePn<c11o@F>Y|ae?n>
zU)i4-3McZ+=1qDoW+w-DT;@Ffi^Tr_r9n5B{o5Cgp#W?x4s4KGq!&L|7mYy(zv2gG
zkRd~k<#A@CAWy`)5;-*R(z#UuJL#Hj)K33?_(<n;xI|_>N5AKBgy{SD=iMCS+z6;H
zf=H1DKNxYfVQ|{dZ(_^$i}%?=sMLC;J%6;bpgk==PDa9}tI*c^53Vu7U}(6b_WZrL
zZf#Z`+Pyjj^INh+i6XK#n|j}g*Zb(OXCfHrZ20xF&rs&N+)~eQl_QSButg*!z=yVZ
zahPpr$;vNk77k}Foc|s^l45?K2eBm_-$+(qb^l)246Z^ni1<yoGM-kVF8$d`t@e8A
zYSR6X9wKMpS)R(=>^EH7wj(T*bJCIc!jN}~&3G@sQ8@i^b}_o3spjMlW_-DT-oVYT
zKiiK*d>RT_w1xSO9&axsvLyHnT~jvHQw|Z64rNP-k5&Mj+vXqMQp$*J5bAhS`vm07
zVhEhS5DvYYqJ;OP)16->hBll|_~hUwsn{w0FzrX)xnG2bU0sv+yrDobn$-YXL&&1i
zQNB-TnSVpwlPA8)Jo|~u6I!=E#KNg{NN0FX7>)5;BI2Z)0?X-#S_-_cV!RXnAaj3$
z9O!t$#OY~=>NHLbbTAR<6BH)`#ud@qL1fXM6S^@Jx^~Hxl?Gh_4}jXJuUV<``4tt#
z1%_!2Fjm7rqX>zvl0)^Wbv*?Dh}8Z875Yz~SOWBk8q<CF$6xSljpQRg-EoK%rztY!
z>&x&6V2t&;Fm}ECE>94TaDX5G4E2eK%e5~=Z)XlDm;Z7ZiC4M7$7*;-qWz83@$xay
zb{EvPfF>LycfX2INIUW5oWEh~SaJ8$-i0gLC-o&pNSPxmhrllR37!urlR1Qx{W|F;
z)YgUtQixkKQRYnk^(4!w^o+{aj*g9@=`fS-yI|3$mX2f;em1()t8fI9<*dOmJ36Wi
zI0v=WQ=4a<Hh0MBM&+zBnas4ch)Y(q#K%9~qb*9z_7N<s#(w^zKdvO$8vJAPs#5v*
zieJhjpzYIoCq3rHvjIO{1XuT<mHga3Y6pB7cOX_2L9*XpP0jlmeIQtUApIPt+51kW
z<j1vXZd<J5895#npGccHb>b#UhfA$3EhFS-oS&c6YFpf9I^X^I$g{1v-u;bM**s{d
z`=$LG0JE2XBAumMEE;~0oaoQ<JzjVV@+nr5ocYl0=Yeyy@>>a%rPgvf6M7t938c?(
zW1qpZaA$T&nj33Ey#uI&=9y<joxwX9IGOrV@>+$m5hTqLv{JqH`C4-_Q5?*;1_!RT
z{g)gI38cneveGWsw{qvvIrKWqeGj&@VY?5a^do1Km4-iWzDXN-4Hc}X#olnLkipqa
zrtUJKlKft*r6uEe0-x&h*}TX*9yT3O?kwt(Ehx#ovvWnx)>H|dhI$huk;J6;@H{vm
zxfHP@{vwIPs|bVQ2KmCx8(7%p-<_&O`E2zz|2h{tQJOfG(2p2x1F#FtLP<YVyR%pK
zvVn8$=xo0`$p+ORo5<#K)hevXTm0S5Y{O@HZ}ZHqXBtL*?k7#q7SuS587dF6)Ye-B
zQoKa<6p6kdj!{PC^J3pbfNNP9|44>XR?{P+;k@(ktfc>V>4JrZjY+MsLLRuK@;ZKW
z?PgCQLyR&^HE~qW==lz)&BuQZHRx@vOwx_$sa4Yl4D8j*lV`d`?ql|6UMc&lHWtr+
z=lF2zo@LdS!+qxC=h%(^7iVu36leQxeKw7|J2WoAEw~1PdkF4Mg44J)4#6b>f?G&J
zaB18%I0ScxH15vy`~T+Kv!|wZ%{z0}UDXGD@YMZW_gd@vEykIjx91rv@iSt7T%v7D
z!#>nU_?4j^=*Sx*ZF<b1rzxD3`9_)v{=Qvd@xT3>uRIvsTRT1E9psF1(h*GfF#tt*
zch=2S5fB88VZep=dpS=fi$U_<>Vv48Uh*n2g!8AbALE5w85}lD#wGvu5j?L&5pRpT
z{aW!woFl&rF74=n8Gi-{<dvbhcC-<_S*9v9{Yh(9v6VD#!8H4>;a$kyG<CVu|2<Lm
zKYfGzGyBp<$7zI(AK%6TrBUtCQqfq<r|J!)H+7+-7MKV@++UT(>8awa26Mx(gJjPq
zo)(64Qv<{E{lRX|0_;fnVmxSXva)F~1{$*gLywUo!IJOdtR%d~%MqJpZkiu=l~E?f
zU3?JTLb!JB92#ZcF<<}v?Q(@eKJ1)6eK0aIe)Bj+3SAhM>==5T^(e0}J%JGNLCXKK
zzF5JEf_?}Zc*b#FW4u7}L$6x9YB=$&)peB)_gR)s9<vtR?E*u&-QYd{xO|&M`T$jS
zVBZtdi(`N4716Yj1*#ZOpAzX8;vdM;bg77Xhr+b3GxX8H?}@099&pbI%5le0qi?yE
z%M7Za`8J@zJY4Yfr`JQ-Pji5(MKI_lOsKk5)Fm%}6L<uexE2xrocNBf%riwjxRLO1
zqoix^737wqHuaGOHF4C7MfK;7`saewE(fR5pzMU^vTUb(i5>9spUaC28_q`KMA9nT
z+KACBlYlp<`%mRo(#v^yRUYcYB0mNQNjyLLiBg%81C9Wq$<`DXbLmOS`q5Zy`#Q?=
z3#3VfU6c`x=)aM(lSpK2*i)DQIo+E9L^<XpxGlr>SPL^Po#U<Ri7a_LTjxQd#)e2`
zYRiUb8&M}!>|mOf;vk>sj(K>6*GMRxvA;jg2^Y#~8D5bm2KFOVV_{T!t@qrBzmfmr
zhMg_pT@S_c@BndulDEAK_ww+4v<XJsJ?G^oTnon+6k8jQR*LaQBZPgsFUq9<VTi8B
zU?}z&f!OL0f<jasKavILS1)~Xlvah({Zjl2xTGE#?RWE!gx~I5PlBss5P=ie-Qy;{
zWR|j9d`|J0AI?KnNlJI|rZOoT1NZij5)~AQo=Gtx7#<5U!dV)^X*xV&om;WDPhJ?j
z4$L2`B&2^x{eTRpPFLRwlAvD(HHwFo_=H=Sno4#?-U6uhdVV0pLL532^w!1zM?qoq
zUy|4-GVi+d=4~H}#H~r?Yu891UceDm{seO$bp9X6#w;9dc%?nn2eL`MEgW=vgXR-&
zio77&&nkyR*KUakmA;`lsY>)T=+Tj+$+>qS*aRICvgwxBC=5i8ReJs3RiaG2aIZ?Q
zupN2*8s9qjp&+=r0Do+=RaCac)~k}RKO=l*29Knpt9jwiZ023A<14S2pMY#`-Cqb>
z6mXqT_sdcEEkKj|z!k`erO4|j7%!$$2NEWqpW$<)xMUzw0pc(kId*Y#p83fwocUdc
zC{1a4y=$R0cT2BpTWQ6c*~PIGsU@$ik|xk2)I=@!4%Kn(s>y{-Y<}s5${%SRdSGvy
zxj3G>C_cdZ(0aMp_7{mGbpU(iiv-+blrHa5bPK85!dZU|+Yw$_;LLCg<Ex`IdA_>c
zlxhBRj@Jq$Aiq_h4p*jxd(scEc#7HK>4*2~LEPQRWHsWFv$m-|-dxg}c}EUY6|(Jz
z<oN3=JH9VxVdB)aS>do4fd6exl!<-G0;r>1aNvoehixvV8kN`$crqo^y09G!YHvh$
zBj--MSiPQ`UlwBqtdxAKF$+X$LoXUX%@|}p?Z+xOiAJV*odm)1&86Z62KD9-8W)6D
zLW=`{P2wjM?--ATkn<%1Do)?pqV2PsZPk<M5+LN3gWA#f@IOsZuSuFM1&GWrrH!uZ
ze89Yx_DEyjsJy|c_8iIm;PW_KeazUD;&;av^I+>nKDVdcn8lmC;mf!FoXj<dWH+|c
zByn?Hm07l#q<+{oL5w&NLI3=~Onua3w)v|p5jT5NapLHlqR;9l`<^iL49veWI#cj3
zrG{CI);PEZQ(Uc-uiu`EduO6Tl@{?TddkAr)2mNV<?nAHouD$l{rf`(R=7E|VlPx}
zwp`HTPO5axMp^VjI~-8gIqu(QLZNZxFqru!8n31+S6yLyZo4HX9fo?#Iad7RS3n*q
zYqJSw^$2J*vsllJJGhnuzI}Mt3;u%g?eKH0hO;JF4c*2T9c;Q_L;bZk8ZIo`T4cj@
z@Of;({(Na>lFqjY-*&GS4X?s^+NN&Ou~7XT$DMA@I`n%|-^q_hPRC-N(3+LNT^ARr
zi?rs<@HQiXV^I#8$^8$I%qA?Db)l)#slPiR=U0EFHi5PvjMip=fK&*M@3}R}JD-Oq
zF?|CgX%3PNRIA}Tb52s=9g28zHoDz3jZvrRy(daOHQta_i&XkBv7`86Unxy+$kvLL
zk5Y~qmP0B-#>Bll&5ueFNCLgQu;m>|&dVkU>8r?}PsqPc;N3-R4Nq1}n{<j+%;Z-o
z{eSB@{Hl>1FLlvD#jF5}52i^2sdNxr23v992Oo}R?#Q#Uj-gGzXrX8Yh1(BBp&d&$
z=||wjmWyNYRio3bbV*Ti0`POkvmC&$)AM+2^7BOE3t7R1Ndn;VWcW4!ss`S}g4jx-
zh6|u!5YYg#UTA*(zV~^Zdj|zhjB|YE`u?Ac3n6@$_de!a-18f;#f@aGi+PY>h?oZs
z;OS})Uh}~W7^S=rkiYwbWp;~91rW{D@2sC`L2`WHxyZ}c`LQm;kInzJPi)Q(kJ;S6
z?hH8rO`eAE6ESE1^cDb|k(eB?N@ZsMc%w*_KY(B_+K#h@25)}vj~7Zl^S0QQly9$#
z@}B{@JF#5;-Wsn_cd_LC+?BW+S>=bk?C*-(5+Sba7?$T{Y%M0FfM;_$|Hwg|@h-fk
zNQ;rI>(DN2nXE=)y1YQU#N+Y|@lelw{+o(ZM3>zj6Zew&^Qq^^H~o$~1CFXAn%5Fl
z@}8kJ55glZTjP{j^Iiz{{xEdoD7)mZzJ!=a)h<juiumG!@N&wf_kaE>I1b?BVRQD#
zl8I?Pq~T102f6B8Rrd^(B-w{Z5$AZ*jk}K)IAjdEe+1z0qNuf7vrZ*1_XH-}T)I=n
zbRix?O#)i;22AUHrxMcII@2*jur`NYk1&%~eNm_HAw{%68CDVo?Sq$#NJhOf5qwbR
zha?IgobdaOqmO^rbk4AZaZ_V;U;bc3B>cjsuN;wVbHXWuka!nbILuY{H4e{Z61#bn
zlpNIWH9&znNIHBwO_!4j+v`X=t;XaIW_-(XgmlcsQbmSKZ+oKmW+aE8>zd&CG9OYN
ziYQ%MN%E=79i6At)(-8F#g$zRl8INhwvI`DZTXH(keu3uzM<DNRNisiWo2Nji}(5N
zdo1;vos`x91M8ZyicB3KbT4%oB&v^!wwT)S#mlqBpw!3@-~SGyUGn?Z_t^-aR1KP(
z5VWr6CMFI-^B^%Dg-X-D6QSSpuj-kXU|v7$UL<g&AM)JWwL4gV6Y8tXX1Wnu1{|8>
zLi>MPJ3$Wgf2J=LN5uvS_uHjVq`mJ5IMQ-i)@iy?GbQ76vGWLo(;?BKmAnD3`>#}s
ze@vGfsr*@xPCMR4KAw}>gSWSZ<L8-JcSc0CbWt=1WL~)}y}!05l>Xp`jHyNAOo1$L
zF!uZq*gWcS*R=DVL#|aHL^X}w7Ai$`T4HkaxV5Fq`&9DpB1JztGyn1Q19cyU%+Rmr
zedF5}<$+pt_5_Ubs+-XqnpJ%+hMqwk3&N{%iECB61hvso1V}}QNJa3KWhI@p{mBUj
zl1ZJ}V>sbSh+hAQNty~RLPWVoBdF+Tit6W^B!l&RX;ut&JleV4j6jV2<<g?skyOvV
z<dI!auS9e9z}YNA5blvhP;T3rJpDDwADHzL4vr(hFL}2f|J)^z;z4I&dT$b6#y03V
zGiH*N?G4&jiK=@v<KYJMTaE_}tbpdgbHMT}0A_55Th|gnO+k%KdlwT1uGdj0@0JRR
zI-Ec-nue8j5+h8woWJ`a{Ghg3^DeIc6%S0^8(|SHjyhAF%E2x;l+eg7#yq_URlS=s
z1-c9J1JBPmsFs%0$9|0|i9T(pS4CCw-yWiE9P(EuR!(~by_}*^;(DF#*ddAF#Dcdh
zjZunJjBQMaxhcH++I&RpaKtigw=r%?jhE51d>C3A4bKan9uz~f<?vYmZSMXEKUnD~
zLV1XR6N%S9S!byL_jSxHCRIy-%X0F|{cY$SBfwBlYYee@#CM+aY08l3<&4x|8G{`V
z`19cAmVqMvRKC?b-N&^GzS#NX&tVb^Cy#~9DZ%y9j+ND*CxE?78hZD6fjYgXT6aB2
zbj|A^)bK>*MjoMez9?MjvS!9ygE)Z4sTM&H+cMM%J5eZ<7GY3lB9V6KowL~CqeM5A
z{AQgpYx0C`S<n6oK1{}Lk(D9j3525W`3ZdORG?g{FIgt4^qbdeWQ|^xW4sn?ivDtb
z8*xt#@+E%`3-6*D^IN`D9DqhMEMTyKQCO9&-+q;j=7axX|99Ea6%vMozKs@cugX2f
zur6y*<#x|Kat7&2abQE1Kwfqf=WO2bkYi87_bhvUaRi$-NhzBBl6GKdjW<q<3v=mV
zP)Cm!t5MM^t-mOF=QMYLtoJ?!LzWnedWUvJI@dTtXtP!bbYUybT8746Uc8n=7b;bV
z$1(FJ=b=1;fI8YJF50U>PVkG9vAjptw{1f6H2#)PmXeYUEfV0?&-Q=u&B&tJ8-A^A
z4}Zcj;{sbt<#7*)U<3}N>g$DR9guWwqEY{nWih;O^gR!?WKCWyl(?c&-WG+fs(d$Y
z9%GvnX$lNUt=~S_;U&mtuBHv~4C&sPNN!UMG@=%zo!kFA61aJ&x1b&db2W1hMtTBI
z?^Yi}6WI^$KXI%3Ns9htIlW#|QG96LcM6C<YNLAA+_yRjXHEa^i)%)4XX78b3~DhB
z8%T3Z+}d2T`_r0DT2JEdVv)|{j-h&ja}YGLsZxZ;PHn}_E!&R7HbcI!x+N)L=li2A
zhs^h+dK_D7$|7{`@QZ4$-j2Npw^EKz@tN^Kp*HN4>|kLa%HOaV<|C)kj#leQH$iRP
zUZduoJ;b|MAnR2wzvo%OJ(o-eqr>xyreNmCeJ##19NzZUMJ8qCVz7|kGwrlPc<8|=
z&g($cWcO{s@E+Cl_|?(T$-<JE{i(36c}QN{GSWUHXydbtX$El?*5mehh-UO05RtC?
zKmx>HLQ?5ON=0+*b)fn0I3_wFZpfxg08#nr+>#N3j=AvL_-{5XvJdtR4g~5XXw9oX
ztb{r~UZm8<kUzAPKzcoc-f_&t9zOn&W|mE@_8~yII6qxVj9P<i`+rSu`{oyZ!|-td
zb}D9F-tA%`%|oywl&b{rQ;gb?4B1BLc=y{|YEs|0*eIUOy(LQ^`Y(Of=oEse<H;xa
zq7Y*)mYjA=XEzkOAVdOyp>fv5o%jVg!EC~0_19o+Zm#)Vs6`O<j*wml_8ZJzPP3WN
z<!i1z>a=~<Q5W45Gg>k^qxO~=3f4*ZwNjQ@tuhZ-DF9g6ilI_^TNU7eP$op;=Hx_v
zChWAlGcBMYEn<+P@n_7=8aaQ3a9u7jMvGM6I})y7CW4$Tp1MdHXbuYuf8opB;vm>l
z+Osfr<DQrTB|)MWfl^9<eLTw_0$-dt>4~>c@4OJ=-4Q5T-V(8KQi{5XQ1$dshG*7L
z=j&D2OvH{^7PUn0vZ_%w0b-C@*le4Rfzp)VL{nP8Q^yNm>{7B4pjkzD{eH>A$D0>o
z7J<e%;day!XxM{LP`V>j+sF?a80YXp*Rb1vId?-g169R>Nj8DF3<pz&*@*B~#s78P
zZN?ZEsDSrwr5tQi(b>PIUOp?XAKM*z9TO~`ak#O7^`BQ+Wj?%#C%7f&uN73HYa65G
zAjXnOiF8#Lc?pIJ-Ys9~%w0x&{R19#hW!NO*`QfH+!pq`;D_(pcMPQSI+CU4*?D9q
zInzeGzb3kz_O4O%Ut|q<!pnL<ek_?9sMg&1`aj7w|Id;@(+~g9a~AR5u>}1&pXbur
zZX3kGJ_u#xC`x4J-!MnY)Q_yHeVfX7ouX_-l`1c~nK4p7!AxXgPvqz-Os-!2qRx%|
zlOjCE=uo0br51D@M-fXW&9gwOcvxVN5Cy0w0}kbla!)Mxhh!ZTj<`6H&^d5pe-h`g
z8ccMQ__~MH$D=%wW&d-!)c12$I#Bb*AgC>EYe2Z>D^Q*A_i?S>nr>>p_Tka=dPB*)
z*pIy3w|s4CwcpwNQK=_**vwJzzlG>UN4~NAz4(osc!(Vd%?!6GCtkM)^a-)9Dt|{l
zGbc4c{Q~C6)X^X+-SNi`1}%I1=k2**_Sr<i1{EsdG3-9DqUIqbqoI+Pdy+7$$z^F7
z<s9(@4oR@MTcn3qKI7QhPB(n~lKqLGiFWwa?IGJ9YrxNodE5m(_hh#^WE|YYvx8DI
zOW20s?<nFrO6sL2U#iFKRhQ#NBZ|r|*BWlYwHFeZZia_LjU%5ioy?2@oZVRPw%ay%
zy#a?&G~;xJk&#XM>Y@9R%3k{i{1&6b#Z1Bb(N#1o#p={_6S)T~@F(@sYCck#0h)m@
zFOqt#Po!(Y<uhn9d8xTr(l?WvqjtFoQ!bT}r+GE9NJi9;yRo7ef!rj{rPX8?>l7_=
zYx89r9YMMSMON|)RaAN&@VLnl#{CZJ>ESc~$l|d`z0W-(+?$+IOfYmqznmgYozw!8
zrM;RSIDh+5%>PqG$RVg*K}f<uc#v-AxFdFMS_E!@pVqMD11_OU9w;;!t*t_at-Fz`
z1r!hVg1v5ObDFk+?ncjE5&Mh({L-C`mTntNl8D4H!rVLQ-wTt?;#NQbn=s>1$I*+_
zLb5P<AAKS!mX6q-@9&sFhs4!tw@vrm`X4&7&p(#`$36WY7GD4RbMAvr<dX@o=ce0}
z&XDGhmtnd>{_6xDqNyGj@d0$XLMq0B_!2-t6yArO;Ti;d4$`Ew8%^7J(to}IhK?ka
z2RyTKuuA7Cx$l%x+k8K5)n1yiL2AKVY!v9d99TAHew90Nq}`xuJ-sYaM%on^7Md{B
z8aezO!gcrG`eCptD3iLtzEWe>E+`Oj#WruZ@UXsdC|Cc0i1RKZ=*xI(vGI>eRZ<@1
z<<hn(hF9@=P5Gl}pHQxA3Xu%}2AazSOfMjlZ^(lwkJctrlOu@`!3#nh*?)#Tco=C|
z#^n@f@s?wRdwl)4#k;CeTtVy#(6aa?7LwgnGkx^ZA0)bE7u7@7?{hv)9;YT{Fdy=R
zChs^Yi6D>X^EYPI1oecWuVX~dQm<j)=B%gQ$7*+$Z^NEe0p0ps*~iYYwQ<{Bm_*zp
zmKq&xo{;gEN91cL?qtd5$0SlygRy6^A7N#MMxkQIx|1u>cF6hut-yr+&Fd%N1Tb*=
zO604Ydl2~nm?-l*Sj<cz8PBI)TQ;85*IANq!x2c_)l0QmjaGw?sKyZeFv|G52n#P`
z=Zs8b>9N{O12G?lBJ<qG=*$sy2A$*Jz}ub|Gxt7az(oiKnqT^ZsEE&I)Tv)?{3xTC
zpemlFNp!F!7b*))KLFfiKYfkUuN-`xhaqj2|GCR~xy>S+obz*z25tXwhwt~rgfP-y
zyu1d@bpuIbt8vc1Pe`@OUw8Si3999O(MO|XG8NQTMM2S*NsXry#F$TP3Vi-8(j%RO
z(DLSF_5d(u|I1X5LNYNgUW45spgjuTv|TY{=WZbfsYNZl{b(R1O@xAvFAiUKlwg?2
zl~FCuMenaZ!u>nqd|;%&2>BUHydnD_010IX%P`JVTw;tmQ=EA`))h}uswIfm_ZN=e
z{#?$^e2^XD?T2k0!2JjCoHqPPUw^GB?PtsjJZxeL&r-o>oYy6<Yu>LCD`&2JFqKbI
zIpM11B^*X*==ja_c(6(*cuVkogp|?Asj3wPHO9H{U&={;G0=oq9RgU_4r~JaSZT`}
z3H==ce29k_HL2nVv?Y0wh}Rq6!{((u1PJA6<>u2lk^lpUqO6#ZEn@wzXuX=oVj^jG
z-;}21Yf^w9Qm>y42vz~i-L0GhBa>d4Uf7!G?5Q*aK5$3$C?GRYso{-wrR=HxZ{D_T
zp8eJU9Xk<}6age+eIsz)#>Wa+fmZP!GyM|vSVxPJFvIo`92tAHpPk<2|L`GOD2F^c
z)yMBg?;M7QV+1Y3yOQ>t#3_5OjE41_8Xyr7zP+2gZ~W^*?3fAqc+zY%o^Q91A|*?i
zy$V8sdFe<1$>8ReZmZf-X5pfDgc`L}?B15i)d$Bl*N?Rk>cKgW!j$P|WAm@}N3>9F
zy&R9>o8@%}{P%^%Y*u!5G+D3~{TDyN9V(~4z9uCj*P_m6d)OMo;+eh)&3omx8mW}y
zGk}Q%Nz-8XTJ-1-Fa|q6o#=1!xGxR`)3$XOD;fT+bXXEW-KBBO=n?BT@#_kReHExT
zKhe{8a9tkZh;qU`=dEeLzIN2HXZVLblJ47uEZ$a$tpThPA^Zbf$i$jOK}bh{Nw1wh
zXTW>wKchrVy!m3_j#l{6t$pn+aqH+~)0NMn9CH4+-r#B9&;p0m!J_Bmz8%!fi7B3y
z5*sKZr9y#C<~bwL-E}Ye{FoTr*FVc!;0qMiFv^@%Lun~StICSrju&D4k`i4y&nXw)
zSz4z+hCK7}^`tOYL2Gs5@1Tf1*Tex1jYXH_Uqr)AzKB0QW7+NjqvcpAAq`tTwc%6O
zybUj4$azp$^m8p>Wvx)V`R~V4h|mbk-4>;K0g3MdsemckJQ%gU2tyfJUbZ3Jao0B^
zny$5`cc)OX*LTn1k7iKaz|M#7LQz<UO%w-2kamiddL6i9?1N2||G-ZcE}W&bd0Z~?
zYg8_IH<sLeLbX+Buoh&tT}R=$%AHW1#lE%bhNyt;1?XQ2UzQMn4^IDY$%Owi*VVd=
zfd*rC2oT1WY}wMomVV%HgD`u``xt2FX?nEK0qRgEb?}0K1KsE7fR%!?M945u+~4Us
zd6`y^UwpIXP&R|MMtU$Ri-}KGBAfu6NaF1f#7!t{*zo?jRX~g=rkVQds|HlBcI`+G
zb|tFsOhZ0-wy`#RBq;>7`1(jSZ|4w7RRXbg_uk9`U7#?e{Mf^;rV>CM=hx?(9JW(s
z#0i2(p6!@5%4__5u@APAF-?8s9OWGJqqv(EqHhcd+AQ+s-Fes7$hsV5JLx;Hd2^-v
zk58(1`fnzNwCz&A0S2chr)lhBMLR&l8`dGI#KIZISB@jko`S!xnB|v8t1fD}&&E8T
z8H3@>WKtw!E}g<P2uUWj=%C<VH7Xj?s`{qbo)y_`T#Q!p`VEHgSET)=B}0pYtG?G@
zPe9!}g&tDKMro~!ct~FpBLO%K^K^HMj-Gel%MleWa_BVWXEAn1Jqb3)6P%ah3ud|L
z{Ia>7a_OS{?GBA5Nc}+e2M>&|J|1z}<?qIUl35Av37qd_X`=h-6ejdKRj3}|Y?`=9
zQZNk*SGNK+C4;N{mwQVSKj@EpYHmC!ga&5IeQu(8h^M-b=m7Rboz66D9O<kebG?S2
zrU6Y@W+Mpsa}^t5dCT34?ik4`2ou<-kk$E4yO&Gkh6ayxK>ot}w}LT;M#G8(kOU^=
zZo8t0c-n(SAPU0x2juu8iL?gy`CuIzhOhw+p&h=x_1iC~d$!4U8~zzBys>u+bfG~G
zKGpshf{u*w_ne}f1kKEYZBGM;X+#iEx<;@R3vxg;QmD%C;IA?BGeb0HMD(AyH2H%U
zd$$n$2v3pj1>x~;Nj?`OQ|zy-r&^&ip9TZ(@%qZ?*<PbipdEQ3D<SN&<C(<5J+qKG
zSvYuRF%e9kkTqvpH6lHq35g+FIyP;Hm45;)jdK#k5<8yISU`0KKw-9jpURqOT0vrO
zq1ylU-g%-I;&y7F>?Pbt3dd)pxEQ!mIJ>hxZdPgFM4i@DNp1La9-kTdLBE(*-2I4c
zP3#=mz8XXxI+tu_{Nzyj7S*Bh6_y5OL>q=lc9gLcl3AyMaXd;j;`Q#TL(jH%tsEOL
z6^7mkHzYjLcVgsiJ3n5?Nl=>Ft{#3iS}uT<klg=*kY87&JI4lF{QN+W0Gemb?&E76
z8HZgI4d=G7-+dY-PMG&^bB%!0J<1*=W<!3Nr1uwrD1sw<mL)@%wHvCw)^K*e182JA
ziN>)Q$j{dYb+~Xd48z0RrmTR)6>2;C?}*$Yd4)EA7r4C*$kl^?dd;ODT!)N@t*oPS
zvv{ylz)SlSQaaa1R4HPtu_o;^I%zHJRSKzn=>4{VZX{>sVH4tAjAjo)8p=?tSHa>r
zo5Q3Ww6MG^b(XwmAIEBsz3e}*>WCHe>5EsNFoiC@n!^|<hVqPwsAywnuUj?2EhYk4
zYJYx$`MA>D0x}eG0pK5+GPR4n5PVuMIrJXI>?3%};ufz3ycZ0m-@{(v^t(^dt}KJ|
z=zl<kj|ij%5iR5_U-hEvFcLmeU&{K?;AMnvo-xY`?F*W`{rEoZ)B7}Z>GXJE!^zh^
zc2W@T=0VED&avrE;Y2F+S|7rgUNuE-WZ6~o#nvtX(N-VaAH+8$L*yYmiB?>s=8Oq?
zRAUF`bGD4?ITfBxtBu0S3Kyw<7tDMV=iO#2GB4{lr(b3_j=pTr<v*#Vz_Z@p<x6FH
zDCKyl<oT#&q6Z>|Oa$A~x%IR5Xc%%MsYUSxHEj{|7q;DcBQ!*=V|CLA(C+llcq~<3
zAz2;PgeI&<2CDmuNPHTc;-E*T2|2|0E2g0Tl5VmMEgR2xxkHZH-Q&5~@K@xPPr9To
zF#EA?UKC<@$LJm_!@?l=wRu#KB0|vbaO%xhs$&b^pbF9V#EseT8?~7_w~66@kWh09
z2o6HE)Yg1HNy+Cj^34wm&%0u@l08EniLJ}zrv{}_wk=`IEhiuNl}+#V=JwDgIp6=w
zwgWQ+iw(wj+z2TT@}{!_KywhU*425~6mc=DZ~t8c7TtaoA|l}<L9O-=y=X|4t8Kh|
z-dgP-3$o?ueN#4|&w2>yLj#bmm*0bmra)IzuE@A%K@xXVyy&2ARHgw&tfL}eExyR)
zZM!~}L)^OshvsbiHwP}!)+<ajEqO@W=gldUclyN%n`Ja2_<ke#S<lznMO&jHG}y@N
zg4^;v-4DzE)WeTM!fx;V{L<T;E3(TLFO!}#B2xZ|?`c|`paO6mYKKeo%#28{rA6qd
zEafdu#N+-XLW`z-wfI29;tG?*Z28+Fh7EEX)_@}B_v<A{`8Lp|{a=r{k$;zc`ApR1
z9zy$YR}e!(EMJ_@y7Azp$7*PX(zC1@^lo7|NQg+PY7cMdNd@jwF=HC<7uRb8RQ6)*
zUzD(yLvO=U^D@SABzWB{t=YKkRu2f?NvSKW)PG}%L*F)D+Ue;iinV9BzQuVI7mi7B
zg+O%6;+akI%4R4mR{1ve=zs2r=EN^~7019HIsAl&$lFr@mqR3eWF?zd3izMo(4`gd
zHrxoUZvc|3(w&&Tl}m3*m7-QCTK;gorkmTSAb%s&0JMVFWcSUjR~K6AJ{_;#t49?{
z<^;98zWfd2!I5lO$&+Y3b3+X(awmqgOAEdkjEv%GT^>a5M<q{YQY&--G>>l;&3&I2
z+Muww0$F6aq;F?$oed2Bl;#^`W%Enn*Z!y&YB$JQW-b_exg?Zil0ZvYS@br&r!u%L
zX6uTeIOY`GdEdH7j>b7+aa?qhoXv~>LEN%EYQAy6N>XU`)D_6?a}fAQA86Vjsz%&c
z{LfRZ&0}KxFOTy7hKTY}Bf?`=pSnGLi=4l;O@@r5J~cQ~T$cE!R%u#BN#;CGmcmZ3
z*v{*A1D$0My>E~;0!@%m`y21K0~XB8k(38mQ9!H4X`^&dxsskeX3SyssHEWUw`m>^
zgD1}PZ@%3hue>hS)>;x!EG8h`HBE%2ViT3x#bPm)h4`5WzX=I8zfg~OgAn-^;CF|z
z@pr-HePX^y=V+G7@-fdaXx<Yq^4)JS(Vw-42__W}d6;l^r)Q1t>+Xfri<KSlt>3GE
z2%g7WuGNbJ_+7Dk!Z7tQsjxuuzAgjHmt*2mJC(z=z*g7OM6aVDDe8O?uIsZ+04Jbs
zzIO@l^3}G#Ht?dlYb|wy9O-cOxkeT`Mq25u8&S$FmK%#LvP7@y9-R`42=Di-wZi9i
z?smsNiXo(+o@|ag-{=2bWcPA4c#GpWV6hQ6;7MLNdHL+Vr=~$uxiuZM<Vhf86|275
zis9eub;m})@If3LdVM}#NLg$AD6!0IImE4V7j0g>thyaZOKQ6mpNRv0GADWZ!|6jH
zw4pMAEt+&|`a#M*eUjV7QYQ#aW8-7Sk@$vPmubhsD%|mXT(R}(X>FP&_I1N|>41ht
z+zHR?(uRs>8ZycAI0b!bYYP+?KhB?jv_(6&uE6R{f_<Kk93EmW#|4!}9w_)YqhxwJ
z)76s6F^}w5JW(CLIHNX=vLV4Q5eM3kkkct~lAv?RO$Sjnl9PgJ@96Rea3xn<*p)a<
zapBsbX6kFW=%}IdPtC{gBL07?yZm3$Ovs$>KZAr^(itf+B%$w(zTsCHdVC4w<g)h&
z$x++n2luMizvlP{@9>lb5l`<J(B!vHqv!?v>m54{{G^X=ngwr{opmPj-_=GPTG8`s
zs87k2YL&8s@vk1~fJlky>9u%!4i;U-SRs`=HyakoRi3fNw7x<VJPn3OmHs%73<<+P
z>co8xC;377h^@7spfAwGhzO$ik57VNP7X^RpIyMphb!g;vxQ)71vd!SXJu<jYQ+Fc
zI%?k|BA-_X`^lOks*%#Ad*23<jW&WKdOgg|`9i0zsvpsF2KtbFuFtHm3G6-d?GW;E
zq~JpB8(?F?XFJ59$8m(z711WlMo-s)yq;46gIuoP7%JsQN9p&&D2h2YuG&l?dGHkj
ztfsg){*<D*gM}}bHIu!snkY8RD%gW@PLG@)Jmwopt?4{rlU)zL;pB-w7ljM5?4d#S
zI6b|dw>94AZsUZ8pDWPX8Ip|Z3a33ff*?W1m_GY}qmQ8O>2fojKD)0KaAFG|xoNZC
z11V2OO(;zen0h$&Rk%-Rb!t@1AGSlfn|0jz)z$vC9-Q;I6u+RD5NfQ=s!c8ZWIRf8
z68c*7-nm`;1b{9KuRe#t@mVBsQzmsz(iD~3q|x|wYc$8W)!E(&zj9o~TnVZ@HI;=+
zON4TD7(y5e3KoE@>WqP-0sgvZ(S|=hC&~t+|8!FRcX{q#eDi4{hAVjcnye62<`8=h
zRYJWtL)KS+uLLdD=tArdKCi0ej?;GU^+8UnyBzpTjPt`{gvGb1TaHN7)Q67HidCbw
z{dir%;Gj5>jF5bZN?D#}gF%@91v^sPLBfc^Yb?j~164tX7s=u#%Qkhu*V8((U@tMt
zpTDhS07^Aqx)Wk}?Ms&;2F@9BM`)$-{N*ZKx2K|!h?v$uuxSUObp{4fHJc-Gqbs)N
zQ3}6uihTo>eK9O4?2rDxpqfg|&=L&<3eWCklXDlK1m^sT^WwLpniZ2Toa%o})NfEZ
zYT`hY`Ny@UIEX(wr-lQsO)IXs;q*qr43_Jy&RVMLl<>c8!XllQ3w$Z*h{#JX9&g1w
z;9D}CrsV18*^kJNpBYv1vXIauz58d>s46EN+PJ^B|8eidOv_RKg72!uMSDCdeNKs*
zmlLs4?#1sFV(-0d@SDU#+{62PNb@?8;p)J~^@BrCyKvhGK;T4x>>jwU@P+5=6GFh*
z$5WKlRyyR;KR%L0MM0Qhy68{8QR0d;Hp))Ar|te=Qvd8w(+1oFuf&6nhmi;l1ZJH_
z=s(9ne8jS-Q-2t77kWJowxiRep?<H=o5R){dyCkWi8bYYLR;T$(I2Il#<f#d=u8?r
z_;Q7R4jULes-O6EbyT)+nJH?pbkV<Us0i@0K^X3MM3{=z3U7`QAN#}#s@EKyo7eoA
zZ{S?i$LHsW1fS;H*^!AL&lPDi0slV^r*tEPbYDuE_U||orWDY72S2j>9t+ys0tEVy
zP5c9MUiK398b~UT2$RzKmZN)Q+nr6I+j{PDvdKWd8cjm@08cHtan7;G<Y&HHcG1?4
zkoj)$c%q(d0P4QZ$L}<tu9FL^jeBf4OLTwgSgxsLIp8L}$!{8bzvC$b(az1GmIeFN
zj6uI6(MvyS0X8Q0H>jsmtzNdyIHr}j5tcFP$;{dw!^;V*_^*MZNWj3uu2qzJE4P+k
z%Ew7nUehRzYQu80>(I>6pbooq?kl1T-H^%$0oS9Y9bzrf<(}_r@S6Erkv9nW8_DPV
zBg1lSi}^6m)PxzNE`x?|a|$7(Ac)s#(;kBK1%c}(nFNkp3#mv~785!ZXNQ@B<9J`D
z$*EDAYbyUJ!e<jyXYbsy9Aj&yCear7>$tQuaXb$tpXDkT8L*!ke}p<s#^@5#(0V$B
zyhx~+9FKF(+$)yC8QMZ>?3wGS*ynSafYM5i7X)gEC7XC6|E%V7Fai5`R`^2o&($H?
zUa{_T9=@6d<FuB%yg|c5EupAe!&v^3TuZJ(?WA12#G9L@6&DtS{mT#6Sdi<)`Knh%
zt}Z<&`4=s%8+y%Nbr~LQVr6U7!9yf>c(z3IkBMv2ALt^hpa@|D##tt&b>xAwW!1xR
z^pvVi6ckK?KPdtQ<(bF#OVf)~z5_M%;OA56$71-$f2$Jx*DouJfLw&ak^x!>_TDcU
zG8FjVb~kWY)?ZTt7Iw+{dM|q~wez=~Yn2iEvHi%d@l7(`(h`@-6t1B}wZxN%ex?{D
zKxZV(#j%;L>K52%Wc)+NXuKvB`c|kf0_H;d=Ejy+@rr<!WLK%N%CAZK`WGrY9{sdD
zTGkN7EMoZoW&y}{E)*}-O3&xWQ}1-sB|t%4{D&4nL93>_>+1jp%3nd^W~sggK~i0R
z1(6`f(@i3Hmbf<|kQ}Hr4^<MkWfPyq-)-qNaPV%Op@>Vm(7r&jD)Z5~atXmoO`yJU
ziRmw+|Ab9C46$?62jJK;e+i;S0>FJ(A5^~EFBf$&h;YFqdOXBFFE^~^aXV!kb;9FZ
zk_O3Z*dxTeNm}A#&WdNp=mh5tJ>K1rZ;N?_^u*prPpxNCwP1H&cWSX|x52@L^hJbw
zYbym)DHL6#9&?hOc?|JMn_EkjQ@D6*e?S_rDflel1j^Dtb%}wHd$H~7dGr1{>U_5n
zS^7B)Y81umBT4FooKN%a**esCqSZ?-wJ)no&bG;J<d$NJjQmRMuptCr8Ea(I;)yD?
z3ylX;R~#c)AY57?df$;M=Cg>rgYSj{@>Lsy<5Li6Uk;n-6aIa=U_J?8(Ml+Lb8Zhm
zCkE2y%A-9TE`%3JT!V+@zb`o!IXg@8$;g+=Sztl<Z`&6crg68u54wA-r-uMAMU0RO
zU0cc<=FyKf<<ZNfxV`}-T0eND^B;^gdObe)Ju~`NQB)yt%c}i<e&qhK&mM`$Q1h7d
z$b-)i_R&IzMD)9a;TVm$+=1OL`R<77XCMkD&8*YR1RD+hdkT7i)X2PFNq~uzd#A7T
z1OO1&zk$4zytwBaeQ>#aQs9gSb^0S+OF)je*4H=z5tgy^bI0_3+Z8X%FK%vuU#zF-
z42^S2aDa;G9;kyy&M68ocrajbc-tME{Y~u3_wG|{{hzkEWK$SBy!1@I5GjKN!QL(Y
zczVZI8m)Pa;bSjypGot~_r;wnL(lLxbS<s6wMwQ#-OHO;z%E)f$`&xhS-NxItHp`C
z=%o#W(K-vb^hTyh3~Sk=me<G%UKO35MyhD#sJU_)4qUt^9qq8czZ6tUOsu^5379w*
z#6g$2k@X;xC*3HZtYgWrfFi{;(9v=xi=Gd(BnC2gu=<jg?wF=iQn)x`K{rM>wi7jv
zzR%J6d__f*q^y^?{d)Kpa(Z#0`j2Jw&7wvNpYf4Wo{jKrhLFAkP*qIYtV)n&8pCgX
z2fHQ2y**AoHA%p`9&CE1meLg&6P5g~OO;~iW7%K@6Is&^6O~!_^+|j8*^~H(Q94ma
zm@(Io+kQym9}imMx3nZx8++1>0Cr`eeI2Z`J9vzGQor6LO)#PAP6?+k5R|o?yN4NI
zR<YZBSyl>3Tq!~#)lDkgx|^!!d6Y-2SHRVpAKI|jqi6t<P@-A$E3Oa&L}S38CfrJ-
z0r$z+(t0oq=?*`INay5#XZrltDF#m!R6sgwQ~IO0MFB^(q1!Ggr*}OK{52WFpI|jr
zme&oZP+@u%+{-rG`0RzjkUVsNKWB|fO~6TSw3;s6F2iYcPj0gMhiaA^ZDh%7FwO7?
z-kStM4Ss_!q@eCu*>ig!4dyS7X=4u~?k-zY2&nKqdy($%qOVf@_7k$=ASg`tht8mS
z=H9N#W%ixu@t8!jv`YK4dGy5V4aXlesfSr~BElj0HkAG=6%r=vFy|JVbQVCp!`JIe
z&;|b!v-Sbfqjj;L$+hvCV;N#y`55eK4bJ1E;cBzV`+Tg#htr%e96Sm3&Wzp7%f2{n
zf^j{M^u(Tf;_C=8>`iSZ#N)0oX>dtesrPTGG<9&Zx%jominpvcq-~~|&(Dd>W!`ag
zOj9k>5cbsWEE{JpB)ZIPUpHnpiZ1D?sDp>S_wr`ObNEEWrRHjF#{TXZZ<`{c?oXF9
zEQ?!v17-OmWmx02c(55VLM@ogZ>_=$7*6#qR>_c}K^~EkZhoN2N#A*=({JwwzQ5Zs
z!!PRRrOu1xS+u!!)r=|~w<lR8%e8|~S^=-I&9LOn$%o+*c2V96T*9W10j-a5-aL9T
zf5XWFM~+Q$`Xc5%UYJ!kd4}`FY+P@#Z1sL1O*o~usG{4n2^;)mo7^N4ODSar*>R$K
zi5k}maD{9wL-MbL+;TlHzM%04LRwKMWvRYO3jWlN<{(rw!Q$`!8SBiOc(qo+@bW!;
zSI9lP-4)X_k`3S@kkGlzHwBbli>6)wSXf;fGUbJXn#JiALQjWeie$$>*zS+{V+Sb(
zT^{qiQT*OI2LL{xL;;G^oRyrx(=g)-Dx?3h&FQ~i8OZd^sRF(n@I4nIPIO13J33BW
z-4X?eBVIb<EqaA9qe(CZa12>ZGHRLc5GKv99#4CsaW_G7?RjWRrS0rfq^f!YGf!(z
zvjlryNz>2Os)<DCxg)&28*1%iGOVGFmgV2r=8~~ZnIe?tBNdl2BS>IqX2#Ixl!odI
z^*GhR4!>BXAEj|G(GDx8*vKO`o5DdL-$AI~cA(M|*8;mz>(}UHoDT-mup;<c<KFSd
zn~|6P%MGQ9v3on(le;?!Sb*v4!+@0w(+{uSeVdb_l={&><aeAQCT?`hXf`yQBf={V
zPpf<v8Op2#)Rhg?!busacwjVH_DBobnB+VyUZi|%Q8~)?(-?+2xj({_T*qp0fy8(j
zPUeg_<4F1OUg){DpjA_1kQeu9YnPpOED^-(a|Trc;)K-mozt)KV*E{quHC`fk}fj9
zlSXh?KNKFY(#8f}t|DneNzQg(+$c9(NoO>k<GP<DsHiT<uPy^zZcXJ2B1oLguhmJQ
zQpH8Swc+tEXG{qv)J3z@Aziv(bwc*OL4<mbHK#DakTLT+b>M~~jfq#Swgl^@eHITm
z0_P5Fhij{?*ijwVYfNSljCo{?fEv8W$f^dt8bfPi7v+MZL!6^RZ7<7-lCC4taZ3=w
zyOnOqJ#4Oq16Uo4mJf=0P<u)F79_aC@v7b^hRdSyqD7qv2WWojKY&cOwW0`+1@u(J
z8)o;CWwWcI1hmsKWRO$Y_~FUttO(X?TDsttKd*;2+z{*DG?8#lZc8HFPSN4lo0Buh
ze-@gwBqhQ=PCLf*^O4X)7vTTTUh02;=KiN^Y6!d5x(&P+NRE|LhuCL`_<s*Yz_VtY
ziHb-rO&GBK`0}6t^H^QOd!SUt*xT2;dA(T>RmRSiym{J2r1a21`OU2PrnPs1L<G%Q
zo`O4UZ+B;QfLbc+Bu%J1Q7qU`!aJ}_hB4>hVcW0eE~otD@#`48Eq35bb_VTmli$$k
zFL0^paT?2KG3&H`b~w1ca6+-uHmnZ6$S@KVD?5#HEx&oMnr@#dL~zw#T$8wnA0yE$
zMoB=-Zz+dcU>6n)atqiM(3_5-KBJO{yR6c3l)V`AL@~7dgbKpj&<#6ps7clA!Z!ZR
zQZ%hjTf(Lr`jvdvKntz$8ea}z;$SJ(XX~Xk9t~mtH%*5aV39DcOSRnmI-b1s>;fs|
zk)k2^iF6xHTF+26sbsnsLtF?MD>SiP5#y``OLsL(R(yC+PISwg&GXHKXWhQ5WZ`tX
z6iCJ~!FiJ49pCrDhOB|(ylc(XvO?M01Y4M13j7}uEYwd75GA!^0HayHRMp%gj#NE_
zT5oyi{Pw?Xo#@n>KG5B-o~iH&-H5Fnh$9{;)jNBxXX0Sl^cu&MR7~?g+?m1=oR#YH
zdd7PYpUm@U9cOAVH3Wv|7O7;IJo1thBK)Gjo&0&cx%DJ|{SynaNuUQNZ|?O9=y{7B
zqn>EaMcL!;&8K+h_uctulU1)@*0e|kD`BemU#8LjaiIf9;k42xlkY!$e*(F4fqFR7
zm?Y~#_w8igbBK=VHD^u!x@pdJ;jJ8$+DIZmBu)Cq{ur#4uf5%AoaPqGUIjsOoh9uq
zs7p*00DjVdW{rJs>&ds=Z!m+ZS^r$NvBM)+Z&NNPWb{p%{ZEaUb3lFd4{=7p0i4?D
zNHcH8K}UATr=)~(4gpOoPU7ujBJU306dQZJmI*SIk4ni)nhu9aAjyp?l4KgyHr@@t
z74>gOdYBtO0JJ4;Ed#K-71EVQrp=+`phZW&*3jMB_F{#jk3@TS^x>+t!-K1;Tm85_
zJcjQbpYAcYk7<gOOIIp@6X_{Nq(L=66kNZa;<5{40uS%KgHtLQp24l$5ZV>PESxfN
z!M31WN^x#kaTZigurjiaSFCWWo;2rLO&AuJFNt`Qc6vq`oCnxD^_E+wQ^n3=I8PdK
zlT)PyZJ}hVe;~sX$Bs;?5@*PGBDe>GE2f;GJrASSo1=(y#ZyAAu(9zfGQp(sXUb1^
z*pDzR;+Cti?M?2%c`E>zFDzdu{QJ&ZzGd0+)&&2&7n~bh!LuX;;S%;*$QL^_?#&-Y
z`b}qft_<Y;M!Dmf?5hK7Qp-I(mZMEC9kk7oHy?cF2_sk{cOr;_`lUa|4N3n(h0Tkw
zuE#C{L>jPjGsv*^d7seEM04r0Pi#8%>t|((R>Jb{^gN$}EOR<~GEKc?Y?1rUmcufj
zQ3x$3Y=VCF*JP(X?s<i~-unEb|FN(Bn~MKG9!I1a|5STjpZZtMjk|n2yqn#ki|@ge
zV&Hq*1L}D4@)yM2zKXp|>KVpfm_E#(j!2KpDzINB=`bjB&5?W@QP3`(rqkGd%K@^@
z1quAMW?nSOQXw#vNo70z$?CcTxNJ<agH(3{ffo`>cE;Xq{0a_s65h>5{Q|;=>My&p
zrMY%6sq*%*bJCgN9Lcs7E`Wr@6ILY{>fJ1<KDvDM?Lvfo++Zx{BuFxEb~xu`chC98
zK=SyyNmO`idN{9K$iU3Isn&hj58ssxn;7C1(b8S;k2o-Xyn_8k@>x2X>#IdLeDWo~
z49FJm9oGe2^Zc#0nEX(nom{cLV7_7OVA_aXRU46a8f%^;6J^BiNS8u?t29w=RN^lX
zQkXmtPOd>;-4HiY&q(58NCw}Dz2^+suJrgWfNG9=nXZh|McG3WPJW3mK<)N`vM*?G
zgRpX8kSHx0zdice`U^uw4y-U|c&n?DhW4f^T2SVIeQTVn{&VxGN)ZHbCyx3{KO7H?
za^?#<xp<^5K@`KjTnK_rSB+cMP0N>Q%G*RaZ-<M1jKCR}LYZ+zze%_Xbb;@8twA>{
zZGF3VHeNDuc}Q{ABfY81`*|fr91Gw*V=)P1<R8QBcL;UZ9~$+J=;v~ejUX(sM}Rgs
z9rK2l5-FvAyy=lkk{ES=mdS-^Eqw%j%F!W_?Wdwe;o(@59ae?*U1F`8G2pE(4fJq7
z<HJzlA!D<a?Pd2~ghj$`N9IWHeL&9Tl@`3VA^;f%H%wMc#OZt=Eixv_Iqc|fhf+v`
znjeFGPvCJmPa?DnXkOKEnK1icy57MZF$dG5&$O9Ml?L%kgF(MnQ{ZAk05Q}Es`M{q
z-Vm2U$naVmuF1RZg91P|5XWBwu;rq?3N;wm78;*WUEHN<6)>fW(Xvl9)~ZkNsvdE1
zMhVRn7~zrHC-?(%Gv(KlV<qdGDu*5wdeb}-Kj~6us`i7%_bv{HRujcemcx}+?fw_Y
zt!|L*YDmi-ZvGShBNyuWyMJ{KI9CWD)%OaqfZCG^c$K!$R*Ah}q2-RPajs<^bL~~^
z;jBC^-`Q=A5!mf$?Cz<1Uu2rTI5uY`*0%d^xkBeS$4yqLo9~*oj@^&J(16Le2=;m<
zWz=kdz>w!n*L@Y*WK|1aCzMyB;`iugQ>=H7e_X8QUlnSzTH3KBS~j7d&1d&djhWp!
z{*>`H>d{!|r>5Ih#f#&DK8aEz9Gr{LlYQtfisrJ$SI<B*@)WrCn16(F5<%JQQ{|7%
z`0|IVfTvSCA|ppCV;M;8*xj??iVDm6z_}1PtjRtON==jz1Zpp6V)b2=MB4S=q;JzU
z&=W_Mt8_NkY9J`K(?cLqlTDd)pDb~l_EAP&L3zEXvCLa+e>TgWgzfub`UJ-rUC0D=
z7*nOdE5H-c-NDasOm>dp&DRlJ17Ha8x2N!rG)4wo)`;*Kaq*|n#ExbtCz;3DCzhrz
z9z!8FYRr!>pfW8?s6z0Yw${Y8WANlD_r@{22E;fY_2u~_X}EkVRU0)b5n;l;kcUk;
zO-9royVZntYT-?-Rwr|g7yIG+bsNP<ZbXJtl8VvFO+D|uBsox)*)xM64txxldK&N`
z3(w!0#M9j^LVG~5r<soFnC<3WVv8@OGF>&t(zQf}rW4$bL&*bXDmHIuTsF&A2ypHo
zn!!8c7ej5N1=Dwr^+K*<l)VZTDCyODVI2=J-s7FGNtzKVf-q+OIo^Le2b%IC8wWZ4
zS70pm%m{2j5~4%Z4p~FVZ^5p?{!D?epK=5s{Y{W0iI6WggYx%50WE5?@%lRPPy%{3
zmx!*W$15e}l1M{EH9@_Y=q>3J>k5q+eGp(<952!>TR5JmoIjo&^^O0}h}lyDJsh7&
zu(}YY+YjpVDs9?I^&dpGW+^>?xR0@_6MNZovr{9jk{GtDF&3inel`f2hKa${5J!&h
z?RJEhw$!DD=bm=Pya#duR@|E+uHz2emrF{coJH(l8eAJ=-cQ`)e?^+I#df(~e1a;R
zOI4bs)Fa1rU4(+YZJ<<{74VD6?-?9oh@@F?4<%D{D<oouIN)?r?H5N09$XfD><a<4
zw7MK`nfqe~Ki}eeUB}v=UZx)}bEjhQqiJMRKvf(#YCqmFZfFeeRd;E4MR)z$N0Rtk
zU{bPmG=`wOguD&?h_o%*9kCdk{%V}Cn9zzZw$~kH*n0|0jor1!V$Y`A0(P)7qc~&>
z!=o=6{|$R!Jtopx{+RzBCUQKR{z^6dJ#y}Q1W+(Yp55;$+y;^AE7i>u^<w+gV2ETm
z_+_ee$G38(4<cQ9xx2Zll2@Ox*Om>Z&}iuZRa)H`_c`DM_k<88{ClE2Z<Eibp9KGw
z&|lLy6-ZCC$pf1&ey2h<mmTRc+hekz&q5r0r`8SUVrj8ax9M9vk;ygzw__&7qs$)?
zpGmJ11>F+s96}}ztWyZz9#fLg`1!`~?JNt~^K3$6cg>@7mpM#BivgFh&8a>Cycu2A
zbA|<w#1IQCWeYuH3HdarFRLV{rVPUV(9=(NQ4dJ;+rJz$J5&D=2yH~jy+ig6Hr^vn
zR3O&n$w$FkIR8S2gutQ#GR4F=2x$EKER=L>F+-#?6!uiR>voAvu|lhLrAHF?pVl_N
z4%*gU`*5X)DSflM>L<X)LHthg_j}q0*3ZiJP%~(|u9MPbhn^06C6C4H7vkUZ6g!PJ
zvO!N>QN+lcE8~n0RLh^4#=o?%nz3}$y05sgm<dTC=N|}sBtLx%JUs=LA3Xe{yI;H(
zYPF!C8nf_nKtE~gh>VCpvQNOGaLCP)Z$pVZVxT%X-i#d=tn$~FPfbU4J84nnQ_aN$
zE5wbJ@VxZL9R*QhW%8(nZ4iWu`~M$|eN|9g4YwukZXsxJcXuZN8VK&LL4&)yL$Jo(
z-KEjs4k5U^yZiL_&z-87hdcLs>8kVIXPvc|?5*ca$n|$IM9Sd}A-RwKxJkG@%O0-L
z14`@>oRj+W2M9_NH|7>E(ZhCqvEnuCi<+^B#;G8|N$?xKjy*o*Hwk}NX>aWw=RT<~
z@2SZDXED)IV)hpl4)Aeul?_ifSdKJS?=w8<&aN|kKR5*>h&A!5_@VVad4A$lB_AdT
z%czOpyyo>hm(6Flt07GvIz%dAA`4Ftga*GiIvV_eO1<-`ACYH4#5QhUOBZ87Fv_1r
zu~FDGhe#m=&}(}wmMHqf!g`@PXs&u&!6UB(f+ss)?9BBS;+X!;RKp<O*;rb94-Z9S
zdkE?h57c`}*5d;3d9a!CJSm!cZlmLdxBY$D?dABF@Q^Q%rx3(zK`55Bz_71Sgr9Xe
zh}d)VGn9rEgi+_qL}1PRR3MfOvwX~n#9S$GdEi+?ZB-8`*SFtPVk`5`_$D`z*6sU@
z)>qn|)_o%sc66&5o_QZs`b>Jk3#j2S%@#C$*YQ8c^*=w@%D?4NQGP-!A7WhXwJ628
z*tsA*2ix$FO7%eET}uqf2d53*r(i9bsLk5AH7z!r>G?dre2GL)?$3)?Z_vj!tN2jk
zUQg^HLSm1Lb9ftdDDXa<>3WSz@t?z;KpT?egC<cDKajyySgS}0FHo;ZAS4}XcFC+@
z*H+Q2Koc4pl#o2l$4?-Odp?Keh~(ugZpxDF)|eOk;^dstW{^hIGkZBKllUAJoDNr;
z;x2|;oOWN|7bX%N$a${cU(&v0?aCh?-F@?4#DET5)T>@G@3gWNUs}ykR<WqL4m<U;
zQxt6uV?Ob9J)5!T2#<!12JqSWWDefQ+;hpDJ+%6qvR6_)IqZ0%gd|=|RnU&111H~a
z>(Ly&<A5{%XEZZKOUFMug|#b#yt3W3r2Ts>@=cOLD7PI7KdIMdUhYhYCbKk`KQ2rl
zxsKYFl%QI%?ba=Aa^q%<%bi}HQBEa!hyHrL4oTbnWUe<j)j%`1Ly0}w`(~0;LH&np
zf5_I7wbr=DP)!6no-y(Hn#iG9zB$V7HYV07`*QX2x}&*uN?K6gR7c=6Qp}UWq2-~G
z=q>NxB8b!XO&5q<=m3P255N2MAd%RU$v?tbPLq}pl3&D>lS+B(&2%`jYdJ2)&kxq#
z&fG0*;sl$`Mn;XP69Ojrh8|X}bc3m(WWK}nbyMal9jVW$%uQ6cPYJp06^mKlth?bi
z6MluUoV#+gN*VdXOv4{TLI8-xgM8-G)m847liH-h$khrMmsR1ioY9EOk(6aAIml`3
z&_6$YYA-B!$)k^)%N;Q9{Cium9-Cd=QZjIGbXSt9aZ<)~L~qsE#jMz^Q1kHU*d9FM
zt5{Q#Dgq+v+}ElZvcK4Eq8_tmwz!&mDZAIf%2h0WCO-&=@PV=&Wuq=m=GU`(l)zD=
zg=LUBJruZ_Zcl0(Od4-L!z;&)RObvuLly{25qwjm-be>7|0r_azEw%jXEn{sEPzUj
zQN*EmN~!-M1=Mc{5^gClHKjTi95c+{HK{K<Q=-0JjA_&ZuPKRUiIoj3el@YFSuav8
z1fQPSSZ_EjsHA|=$Auyn&2cEchdqR;?w0WQYa-6m5My2yOHb(FjGCa4ocEslZD?wi
ze>O*lDYE{x{c0K6g&O@MA%Y@HvuER!M(E>{>!Q`e`Xj;X7LKn^$gi7P{|moI26YZ_
zPhZwrP$u>sexJ?jh+<sIyjC=Ut#-k<WMMphX8{MmbEQ`o!B{k35M*UbB*`flW^E%w
z^l-TWdIm4FGIcI`yb#BL98Fe09{B4EyElqA-+W;N%KVx_Q^n_F46aA_pJ#Tk6}mH)
z{UmA-CJlUj7#C~%!@1o}CDbfgeMX)Eip#PhA&g-z2RMod3RXbaI#F*Tbp|=p2D?ef
z0|ofJyPpws0600f<DxS}cEN!Sn%W%^g~*qGyY?MycUFuE+wKdGe$9~t&VqtXE%6v4
z@P7&O2qp!|OSsC+tx8**N)Ndt&Pr?I`$hdWfogmX%LuIG2oybJACoa*!xA0eDQuLB
za9uUAK7#`ljDE@Jj;oSIvu<i8Ga}u;O#GOjp`?zA*>GA7hkFZGIaKhZGj7p#Z`2a2
z9&`feCukz@Y{+gauZ~p=^h+BZM-5@PG*fSAuk?F12f|ljjwW5BqvHwZI>2B9<H9aS
zD$yIn?wySaYUKiW#qZ7UIh88hrnetHyO^Op=~=BZna~&v8eDv;(=XJWAa@C3XDHH1
z<q4Oh4IewDG6~&-1xlVZ{>+0MID*q@{S>vhZ!y&Ajoh|hxcXKjLoE=u5M|2f?^Yv?
z=>VJ_#hE@+xkQKAy7Itu6WCNaNH?}`P?xf^AUv@Ncj)F8b&>p>4Q>EKX-2#xAn|Ug
zt(1)09As?(U#5>Zm1s5U>JkrL3Ik9GW4Z48&Ej%SCMOe3@D~Er^)(c_hE{(%`E-ZW
zbHJV(2VHX#hSL7>5uQF)W#85LeIOujv%ncKa<_Nonegpe2=C5>tl#Od7^7;}IdZn-
zEKK;TIk$JM=MFH+<Ep`fK~S*9nvlttL<d6#76a|li<Pj9A5e~|pAqqDCa67@I}8zE
z#5;oXQy{-XJXCQ1%$V3?bVe<58$Rd2Q|_7`CfFYX14>*J0RfWi%YX9_aD(lh3}Xq(
zaVh4&N$!KBfb<*}E!9sX3s#%wNg1uA<>(`h>Nz(m`YhGYEVVzVfEOT&v*7oR4p+J2
z_paz%E>(!nUL3l%rl;0B=xH>+!`@#u*<PwGHODvqS$K{sCBZ;^)8)$-D9)+vfLy^D
z+$Q&myMdsmp`7cWJ(?SINfRMo=gy-&^sy-`na=l_rdFQvz~|}9M@P?hr88wP2rcZi
z(+cUui9DTLtq6F$ja-A@cfg@p4h7Whm~ZIhvdG<1&#pxA2VWq`BAwL=z7ij1v7%P$
z@B8qw#5eU%6Z9%<ARIphEnRa&NV1>YkeInshK($uLv*53tZ$8B&&SZJ*HXLqX*GXL
zXo5V8Y`#La45=<b?nutz2)WtkX?zS|u&n{=T_}d<+n7OdW$j9o`7#|oeDa@v)o(q!
z4PSBan}AyqU!vpwm}tJ3t$MhVW<1#@@dJj;gMiv`e+umF6#W%c{F{}73ssL0d-~TA
z+m|-BW+sJR7ZhMmY{ng(e>!o-rtKmLcRg|F=1U$`Zya<Z<H!sNql^<-ls87n)Y5-$
zom~{Odmyab<NjIlM?7zBML<M$SXJgPz~FwIoJ7HdE_o0I+b$?N-lZ&9H_H<s(>OPr
ztNaL=F<`rD&gX&4<!$M%4!L}u7RK^U$2_$2=u!{o<OJ>axaGAvR{sfl9l|*`*j@zd
z3U{^Rss;EEgF*jFlJ*<gyIG}=-&Q9vO}WAiZlqrTSn}PM>Qp@V*NG+<k}<z)w}I5g
zZvS)_LTXviw+n_-yjW_{3`XX~Q_N!ODI?)J0GU7}rI+(1-{0;To72Klwx{+5y8I>g
z;I(bMb90X2zl5QxT_3Kz{ktBoKen5h0A|e`e2Yc>t^$OjSFg{4cKw0+vLn>NHpIfT
zWm_*{u#r2^oV220O%PcKU;3quA*C(gJMo0W>5R_8K&>FH9-cYKqQ`=ZzX#N!98XK*
zaK^%<MLX`%`Q7MIWZ9qQ<lxNAn%9);=1!TTBMtzxQ+N!mAhmw!G<NpxoyNw}sX<$6
zIRxYerPt>It?_3M6al_s!H4O5U0Z5o7L_73tae$U^Z5$e^Y53F$(IssaY$ON5{O7c
zVyn?!?mi7y_<Lr_5Vl;xr9g-Y%47A0P-W)038)8(h0O59%nMHisK%w^O$jCz;{@;w
zj*Bk4rXWnIQgz2$%4x%`vGY<HYs@?}6*b~(nv5~|HZ9(|bQG3#bj{#o^t$5mDIXwj
zptmPce~+Osx~GsTyTaX99Q>e!o~#U8f!?CDJM>M29lm=b2=*&_vl09gy-Ek6t?Dv#
zvHb&ZTOKh3m2ml03Go6hd*pn?{=Y?p{~Id=u>*J{{A1-2r$dHd4mn{h;k~x2l>Dn3
zVx?gYE!s0pi&B9-Aqdl?#Tx_+i1Vhv+HyE;H3t$D8pJmE?Nd{a&P+VdyH@5Oo*qJa
zEF}xGvv(EQHA8n5`tOGCGjH=Nvp4^F!8?L921M0_NdZcJM|&<FUk^yKYYqUTOQb8<
z#dpu`f<gw}BsOmKUHS@OK*;dT(pQL6WN}mH^L$F2*SHC*L?C6ov$ZK<-8B1j0{E1;
zHGqu)`8>ek*QJw53DKUY)W4x8351H;C}^(}@nI;iOBBo2O5#cDcry7sr~9=(X*OX*
zm+U9?KiD7&#)g~F7^ue7K>NLSVw|+D^dg8VY-O4aGP<#=v1r*$jT#k$lF7yC3bqwf
zv)F10D$1#?w<nxGI3Zbh@PcTc#FLP0lX_Mr*!ck}XFwmEsI<mo61L<N#0sv_<YX6|
z`VGU*S_#ZF<Lzm*Q~`k2k{seMnc6L_@u}{x(gJ9MD-Kg&vv)g$Pcqak4NjO(I2!j%
zxy|PNJ#}+AV4Fl>>+&b5MK#$u5!vb+=F>L4u+GYWXOW$$Yh3G)Keja1-Res#j+}9b
zW1UG4%-S~dz%V^MV2SuUcx^w5YcBG|CK-JUqp#tpODw7*8u}+HQTs-^;bl6zp_I$s
zJ!|02(&n*E{*ozyLs8IR_=_SRKb9eZBV|Nw5t7#qL*@B;Z@0+eV36`!yxdteWyjV7
z8)?=6NQPQLN1!y-^}C(=cVj`jsnd{&Wa;6PUhnvrU)n30KDS(np>DM^Bn8ij_|vbG
z6DQy9>@e>+V)zI|*$*Y6>AIyO*_~40iG{zECDkS{><pdpy8?Mvi!N;n7>REM(jHGj
z*Tk<<5l1idko$Oyt?sKp?u{-T5VrX?w#^PgzHAY#jF;}-wa?qT+XFN=uU&tvcjmM7
zsFPH(_q;kM{+cE0uNE&FRI4OiphllW)fzg4uw@`@6)<?;UA`zb4TkYCnQHs|g$LL)
zgDp~KeJ>K;P{8c|9cXZO*Z#+exsDg&&I^=tG}J9oiiu!O41vxh!;kjJHLHv<_9qWO
zS=x&&6}C=Ev}eOW@HrX3I*+$aVf?n2^OBJN0;gz5zI{}u!>zP=^ZJ2sa9{Y(4|5xN
zVQ2cCu@x=B(K)59PQ?w`qt$_Iso~kL4*bIpKBnd*PGa!Y0@jCf){nE=xEUSu-vT2R
z0U_ru)0A;o4;7tmdb~@mWI*76u`*Zm&o4In-q{UM4<b{vXP6HZM5r7NtAW93Odn~h
zuTN(vB<E*eEiNSPMEzs8HtZf*r%c}oYPO)XY?8}|dH4Yq7OmW{&LtTJ%w9sykyJaH
zpm!K?fOa>58^vA&$3S|>{nCVX(7`XLx7ckNNFkMryydjauT1)+zBOYT|9^t<UvT2C
z3{~?B!qx;LL15Bz2I6E0->NheQo=M8U`2AT2`NE0v+vk5zDdq?do0h%;c?G8#-DL=
zK`_g0=NCoR=Vx38WXqm9_<RpdIqNXb*M_e@Cy{uPtVJ_-REw<mIk?AKd{Z3OvP<BB
z^01(MROWXjUUU;{RqE_^CCS2p`Tq<*n7O!7iBI5><|p{JlL5J?0prJw{hO%2f_H87
zus4iv&1bZgnL+H?mCr7OIJq3ORR?wN5{Pq^2-CCCrn(4%O#fiVmu41GMXX%tNiu>H
z>!dT<;6H=bY)4vDt!O|rLBmMvnyEr%q=xd|zccn07B&aCX}0yDw4yA=)a-HSpZ+BM
zD7a*gnHwuK%PEq;@kv?%G=yNO2i0;I%?s0;Oxx!z6XvV0N%OsE*x+zqnG{6{s%X$a
zQ%SLo@VLS*Y&>(p>SJRii{t|Ruppm5wf<IJ(foiMee!yIeYah;2(+!6O49ql+Q;(^
zVF0Xm9_dRoydr!!96+A4_3DfyNhD_Qtk^_jgQ8n%eEOaB(Xrl8B?`NmI%8vyrZ~*b
zg|UmWCMjRRWmmp1yPCkSNt9zr-_ZX9A9uscZqQL>Qm<#pI9SbavN{`v94#RNd)!tg
z)VlE1%Kdu3L8<$!J2t=d->@nKwEgXjB#jnN4%)IlaO4DQcsitj0w4gT{(y8@PvZ$$
zkuhnJBQthJpFk7`LVob*vY!z}L#Vxnu#@h-H*_~VP<6S%3P<W_zW7ge)#W8wWZcoF
z5mE=@d$16Z+cI!XNVI!aJjT(7+u%1h)#98ZJe9tNmE!%toDX=i2ylmUpl(aOSnYd8
zgu1<D)6@kJp-q~Yafg32{l+;~K+W;13tiDMGo=;fiS=o?S$4bW#7rBw24Hk+*OK)x
zUQ9GGO4$~>YAn$j_Ndy9ekjRyFQi(q?hy28EcGjJ$8FRs)D2R)xS;I3y;+DqZj4`f
zT5LO21k%SnO=`oT*K<`WEmonXX-+!3!sqZj0k4I250vXBrYI_~vkhU$?pqUB-3&=w
zm2B82vg=0I$P$0G<>a|z$;pTen67_PseXUXP+MJNHi=sB^C8_0j!qrfEE}-ajA*;8
zD+yL;3;%eNKy$kW5QvQXkQP4sTI87$_nuyxRZ@DpZ%n;es$Z=^BTa_D)eG%|TRW5~
z>AjA>;~suliIhL?uY6raA3Xyc%?Ebk<<?9NUDepb)^6@uIOK&-tO<5)3~wnV&|Ltg
z&(l1r7vIujVjOJO@I(@s4h5h9#SbP4?5`+^I|cdzg3-O)sI)RI%d~YF&E&9mx-snS
z#}2_cM`z4bcCu${kRm5@2ZMD7ULS^g=>Lj`5RqNdBTlQ&nb-$IaeDEpb+%_{y73qj
zkHiPCL(jJWwLVTv-Qz><-06+fMrPi$gN&4!`~M(+e;4yT!7ORnyzxx_HS#5$+Do3R
zu6h_ftPe7o>95(ELzuEl$*ffOSUmCkNa?z`T1_K8kqjzyle`-I#t$bQl)CM9t3yX2
zwd%ef78j-F^K%VoB~zEwb~<mvUtpLcd*r@|Ry-7yXA0R(H)Vc3u$}>0leGNt_0TRA
zDtirbjK%AliZBUl7|qa^VW}xmycp_z9l6SC)a&f>ojb`=UB7ki%=Q%m4>efNq!2qQ
zay8E570h3!{=C$*9bYAm&WsUf4iykNKOMVEzlws#H2LRkeJTGg-uo$wv16e@b)zKZ
zOeNpmD^T>UMa9gg*AX53E99xtS<{7c+rMeiizXTeG~R%0-SBZtDDh1MFh<2~x_g@%
z_$zEzWi$Y2T?6XM@!6Idr!HWF$fU-6GpbZ801Oiax@Gy_FO-29-ol-(IZD*)yV_8f
zwXpVqSVo+jLxgiD-#m#m>+Nrx+QLceZT75@z9jn+lC5X76N=<3tqi<r$Bk5~IfEC2
zE^W7blRooFy!3{;HJ*mCzjHEec(@FUK^ahb*I}#gIZpff<w_1ImF<;Y2{N7V@f397
zAd(@KY=Gf4j{ultXid@{tf^)pKeEhgdxC9lsAyHoSCvc4AfXzx`DMe#p_O{(c8VjH
ze7JUqK9kcP&_xT$&!Nzhnv0PAZD%$OGILGO+wDO|aQO5~Ul{yET?RVYuW!`qm*-9B
zb@=!ctFKs~G*BYUA-j~03PxQiR<EBlWENd_Q_Xkg>a7!-&lxe?Qd-3s8IKqNbemU)
z?A7}3_#EeC-g_U?%pVwjt5ptd1rdvJ-FcJ1{B&QHepik&K0LH9B-a#D9zv5R47;3c
z0U6^UTh4S@Ra>?^kZpJemoUE4(HK)?Ia79Owye=X@%@J13)EE<R_@#b5yxvD!XLRY
z&Di#zvua}9`U5#6cvtcHKNC@@+Fw!Fl>Xd>{r(1SVA1XN$bUtgP)6)-%Np`wE(u4w
zd!M3%^duQ0<2W5)I<+~t+_1(KWORw%QO}W~E+)BY!&b?C`dnD;Fc3KVH;6oAV7$Yr
ze5)hp2-QQeFO)!{+N7DyXBoTq4*<Wr9aGeBb@2HC{VG22acw?42Jv2ofadZD)-oBw
z@N4EpU&}_@@3$7RwPmTI_#umvayH04lXK*5{ObTMoTwuN-z#+(BkaWXi?yMGGr=yV
zhbQ06)1gKPArmvG`vR_WdlG}hC2kdH{=t{|@vtA>7s~$JsL5DUUVKq8j5dI(1DC-t
zQ|4k67@#EyayzXA2xB*h{gd0m-;4Y?<+5ot(?_jZJxlV9!p7>!3_%`_YUn4b|3=>U
ze}<XQkZ0Y*zG`>3R^HEQh&{5mY5`)O*cMmy-4_cg*9Zd#&N+{@Rf}|L)GUbSxos+0
zV<wn?ONn`Yy8=3h)M^u-CMTZ224->_hAW2N9dOOdpvH)5W1m=zSC+6hOiB}{9?$&U
zy8eB1aDD4f-=@cDja$9Kaoi{vP+O<ppl!tZ*(+kou8)&|Rh8E23mpzpWh5cRr2awG
z=}2R*e+D(Q-SQc?nI&<L3+An9hCP1(GIlPmJ2t8&Rc|)q>9MSVTAB~5AoC>2xQgG=
zH5zi`*HmCMagvksc|fa|^Rw0-v7R<@&icm)QKx}tThLSDj=&F)r^j3Qf<Rfv(UGUn
zo9Fd&BGoN?cX_3-?eyNE+3mY^wdZT0<E^8hiI)`7UhbI25Cv3Yv3Fg~e;Cj~lM8nD
zCJ;zqwf~9IH;h9#Op!^)2hw!;IQ-9KJf^n^)fgBDgL~Q#z{CkoShj}R8b84uCAEeM
z6Vb~s&+rF346kqK6+_TSKVFf|*>V})cRJjJ5q8{ERIcSvLwD(?n$=U8!0tJlpfzbN
z*2eJuQySpi%FoXt*MrWV{MOBl%b5a_lhHApPz)#D5kr2%`5JE9Hp|br_5@q5=aR@P
z3&laaA@2JK@z!@2wE`eLTVhd>;;m}iEw)hJpi))nUgP9^7FTp0XL<Yvd?I^c-wFS?
z6dK-ie!X(S{Ak6Jw9FhR(8<}_0$-$Vf}>S(^-kY1hB@TFPT|aV`Up;TC+bEpXRWT;
za@+8W11)8edAiZ%uw&!bJ*us?UOluDHJenw;3DxciQa6e${`)?BKi8>_>4EOH8)*y
zMec#67bJ&(`e)Pc=-Q{3FBWV94`kcbWce{7WPQ758`Ym`wQVo_GS+pr%Jczv!sABd
zj*K|{NM@@~z|`x8EW{lg&86R<H7h0WYBG&7lNL=LWlv-ql%ijYb3B3A-ME$k?)OrN
z(}@o<NjZcJJk{Gsu!p$VDnr(4-gR^Rc!bbIUG=ASq*8BM<4P#LLscXsxK|nWZVmz}
zU!&mXW?#B#L|Go)g_}tXT{yxvY@2J<1=1zo@tvE!HS(LXek|)#JzmdEhRJcK|B+4M
zzIsE6Lg#Q0SvNrJ<**{Z+3^uvEp*o<B_F!o>+73Ep6+-DHVX@24-Jtr6Glv&k3-vB
z>|U+dp8NUOf6O^3*XCF}SmgM!#%Z~c_T9ZKE>3QPuQ|ZJjJTA-9wxWZzMsL>oH#(o
zb#=!H5CZ(G(c?|(?-Eg{qvqUu_6s1gq8}4blv~l+6Ec4LOpln_>}x&f06Z<QUgzyF
zPdfHV)SfWFT-Ee{Qat|y2|bBe)9))=3qP*3;tX0LCbE@;5<Z6>z#LxJo`;GFSRHcH
zmma9cJQt@GS%1HiGT|4*LmF0Sf#)tE<OcN}^0k4Z_$#L97ee<4qtEy)ESBMa*IZRb
zl4>3KT38_bDAD%()EosYRU;4UnWwE<DDdSRLFSwcR7s92!&M@|9)G_^x^!7BuB~yw
z9Nre;^x+YgCKHxwJgL+u{>h6e+D*l9zk*@b^*66Njri)L=`ZAvC&5vinnSV>b$sNx
z0-s;4Z+z`pyK1T%HQ@Pt+p6#N&+mHmJZ$m7iG$wy?fqnW^})$P&>f9Rl6y6r&ni6m
zwP{zj@Mo{rhn>BnyVz_wy=rE#$rI=2*-o->bC)vbSuW=#<3BISe69v_7-jOI+cM5m
z60sk1MWO~Z`8kB}LjGO3X7E!V&5h0^t(rM<08fTL!n8%EpM>CT-=|z6-V+n{Dp+W$
zE9KgPW#o)LSdA|*IYW@$LFCQ_;jhaS)Z2IoMU^GW`UW*(KFSqSwuCBbLI@me?mzZ4
z08k_p+E39??sx_`Z}?ubkB5U?FjexZq^~@#^(U<xBzXW2Z%*awFFG6*Q`bJcQ}m)W
zn>!ic>o_IIW0Ur+S@4h8*oH0X*kUu=vVEA(!BDp-?;Zgo!&$_ydl@W0?cLz{&PC&H
zvbJ)zWUbIXY7Ij{Eiv}pFGLS+&9xJFV@)N3KA$K=d6eoWDViQxG$TSU6AsAQlfxdn
zTh6zbYx>a0(DO(Di|$?3#!ts0D*moJ*O%7Rm+Kr@xuoh$_)B=KIoiD?7wi3d2r6A(
zxX~|6f8DFx=0=uDX+xJ+f3``~qDQi-y+_Zjc|A^8!J&^$%u4OPvB!S&9bfn2ruQ1t
zM=E}TZk5E$U_z!f)^M-~MV>iEA$AD;^@45`fWCE)Rb{{X?!&{|H9Vrqgwf3ksZB*9
z5Dyr<I``7}$wd4+zY6}-%MHC!rTvZ1Pj|lwZ&p*M_Dyc|Ez;DwhKxQxZ>guuvSlt3
z9Sgq?6M%oV#PZzNgDs&-+r7&J@6?5tqfg}{#wD8P(v<i;>;quu!clS+EpiWU@yJT&
zZxBPVJqQ>{bgMO8l~Vh@qqmv|z5(mvAKe~~hN{RUN;q=$9<lhkMYInj64otP?C68B
zrsBTnH0TY!ilEKv86su8d5zo3r|lfr^X*>i=if8uB0`w{N7dwkdgJ$fJcc~COTP5K
z8pqYgR^-IrkVuQQZ6Z)^4We6O7N$gg1oCHx8*?A`DaZeq>BBn);I($^82%O{)T~wV
zNBOr3MA(2uQ!K&4@0;6`0p#gQZ1ky~NlyVPGQyWp)jfSss4LZ&vlXGSliVd71q#3E
zBFc#tW2K2wr(=1#X)?sxNh9!doZn?0x#HQG)a(aW_k`-9SdB$eh39D_U#9evtoJ#m
zHNc@7e+;&OF69RY<*_zh*y}uj*UKpxUexE|o2QQQW$|Bm{0jH?OGdoviJiQuV`k3$
z#3rA?1co`V2NrpnzUX9E47p)e{8Gjmz#<}44c1JPzvaVG-4XK;G4iBUJV+>lQNRrF
z&+p3I^T@5YQ1w{G`nuNao%fq(?Yn6t!gP9chwwjwL{18jk>wv|#G4I%Q-_?Ea%5)~
z`f)5vqLg)~Cz*YKgUjZD4hAx*>Y7>l&2}*=jHndJw|#szxlJyg+5m7BPu!zP#EOre
zE!`0sN9bW|s5v|+EkY0(BN0D;;@u!$kjp-;s69iexk@;<^k(Q85ZSX7ZF2C?1^b2B
z_(BU*5nOjHF{ymH_^vB7x+e&AJM;}Cz-s#;0DJfX&YcgqT9XIULoSoN^1&W*zMDn7
ze1m+Bs`)TRnAY;WI&U-Iig^2jQTXAYKqYBUnzkX>o@kL>9)+1Z^4AsdsK{>sH*$=W
z*FI0p*Z;%m1@jztbi5XJHgv8t6t?#gmr?gggE367HPn8|ED0~y7GHoiQ`!Ih4zy55
zbl*Eqf72@okIG;2hHa-Dx(4;!w6bXY`{9#-lnuv|E}56C&5Lf8jZ!ttVNqHHL}x9H
z=qK5Z>So|?Imq_$F!C5?Dr4DcJ^imfqe~Xg)&CH9S%33<_DrA*)#VI)s)Ng594D}E
zBIRgr5+f_o6^L#(_(tIBWajN65_Tt!jrx04(LcKg;%$cUS1dEZ!@08m<j$BQDd;RQ
zyy9lk?vE}B3_0fbfOu=lHTg)eiNKyg6qY}(54B`PiKGIRs8`kDoZMoE6r?9bSPlJ@
znE(2L$kNAW8rXCA)sHj5ciqFYZiD1PKj2E>28`c(0$K2fYeT?XXW<DnB!93UNIC(e
zF{EKoxs3*U$V7c1;?M`{@+#=ckO)sikL#uAk5<<!7kJ%{m76Nz>JBH5G_4Z~@wU{C
zFn#<hLG1tMC;k`Vc6a<o?mKga$B3*=)oV!&P_GOlthX>29oIvej?oT4oaUCCb^7@t
zae9^Ia`eik!xVbMd;Gw5=u9Wd!6{QD!7;J4b@jW?Obz{F!V$5L<iwO14O+i@fy-1z
zZQuXL%$_ltY_!6}gi@^f$fOz^|DMw5c@HNE8G$1H39h47fhR*kWN+W?5v0UO5`-Qt
z&h(xzudcqtxcX{xMyYbC8tQ)h%^>5~B5iAn1i#v@@&2~gxEI0v9-&h=I>!f889l@!
zg_2o>ze<D}P16NzsTyW+OHQ0abL`l0Redn0GP!Zu>Y+SwJ#tK<iaBWdFJ66x^&Z+d
z^G@i&8*jL`l{B7nCyFeUEhPshSK$9Zy5IaYO-&8M63vjywd1S~ukWkOg5UjK?D@r&
zSFfiZwP1zVO(u!Pjr8l6Bp6GnZDV-MT$Yq>8$ASsfQ7JszOz|l5%`vMrGIrA94NSo
z4SBXv3G9FHD$p$}w6Ui2jQ?RL7w*wBkmAbet!iR-Oh!xfawWU1?DU$sDcI7|)p>_;
znvp}OPqy<ftJg=GLE`|?ALGpwWNH)h9<lLbUbg`g)-2@K+3k6Glq%TjnrkC!Xh+Y5
zsYfFr&Z7Jx$F6vNvnqR6S9?f(A4wkSwNyQBR*lkGH@}j11!nNP<K1*&iid1asJQ!2
zxuPLY`*v7-B%q^{Y<{fk4ZMl(u|ayiUrYM?jyY#S_<Z(zm^2&b1zFnpgxEL`R#dT#
zLci%fAL8<m$Oo^fyOB4ykYcaIG5gH}kEO@N5&7|uHkSb~$V#K_!ma^kpN$rO6wKI=
zYgCcxR2!B2747PUCo4f5@C<r^I*-E3-3f*0#AzniU6X239awlmV?UD-Z(A37<KLIS
z5>^u{S&?d+mx%h+;wj0#yzz0^1)&ELz|8HYN3Rt~o~|5I`2+eDNnw*)=jZ|{$Huci
zff}tXFE~1%u*H2Ggy|_O$n6y$4STiTM5|JoLA%}+6^2u3;0u`^$PRnRLMOVh#%Pj(
zUVK~vZ+x+%gx<oaF0g9HlMfhD2!8z*(i#4u7w);JM~K}P<}Ip0r%^kCbKE43iq4R<
z2pY=iehd7!k{J0vk{F~S{tY6vpx0}X$IBt12nwy0T0)JoU~^i$=>;fO6hg1!GezjQ
zCb6r;&-0e$(;tnY>UB0modScNrYvTrvJ*jgL8<I~Kst1IV;PgKauptiIz9rfKlu$H
z(9fq#_m`lS=*{$|myF?aQ>BU|I%xrntTc{!hEtn*DBm8@446Jp2P?;A@r<Q$>Pg%<
zpfp?0f9!<kPbm{U!q<^iK!M%dX9y{=C3Cm>*l(~mv>M;%o;Z%uT>w6j>z(RZ#D7yX
zhxDXCYuvjBrtBm94#}%9{6W;E<y|xJK9}sP;RuJAi_vBrC^FWZ1cQ#(Cli!kpl;a?
z^pIO;8x*je(OD`M7RE@k-Bved#}wm8D+{O)Fmor+sPKj_^AW=#-tr^H?!liwcRlcf
z&pJniCuZI6Av<?vhKn!wBXgtwXBPmb19^b$`d_olw>2X60qP|BhhX7#54U|90}+Dk
zp%{klUHJ<$$us@n#cS?E{HwvnIPHdz^YCA-6bSG-PoCpU?U}@?K;W9CIgs9q5bO_h
z7eaKZSj$Ijfhnb1)(_r3k-p@=MDIquC~o$I8@?}miTW+I@@WqdiKY+3gox9z6`BC1
z?TZZsGE;ivo%xHpc2Fq%8Kx`%O~kI&V}CP7$zOr;@&PB8sY?F!;bG%5l(Q7_bn%y8
zR~7CTXNqhW#N^)}iCu4G{fjHDvc4Yw>E3kY3`bvkm@X6Sx3?29g>sH?WB{cbBh_LV
zNhIJh>OXw|FHZ;Ot`<u1T%a0ZDORBNRlrB*vnswVTa}7DD^^|z|6WKYVbA*H49gL+
zXqq=IOQt3>J;Iupm?lm9u)K9ZWxN%Ha+fQnXHBIqF#xABzv9EW_^V^K$Y#p)P~Gnr
zl274QZ<nYy38W_)Lxb3BO@(@^fQ$G00D+x-a^2V<27S@fVXk(<KOFWF%wcQsSt<1O
zzjCJz`Blzcg#+SFH)fJaNmn-fs6<N=8Xt0D4(G68_THd?hUkfeM``%N?}ms`V#waf
z#5f$V-fc>~1&)Mj&EXep6KkgECJBhMejj8aV>URobfO~sdEP7_Iyol&0om1<xHT&0
zF{#%JQm58L>(2`-CK^#Ay*I~0f*`V&+XBAvHafhT^&z;T?T<;<x+T?|Uqk@Gk=2c*
zG~R~?c4m*EpB5yB);wVw_D!|w8Xo)3O<BH+&<&btDu~mH%%T-x8s<@`Xu`qQwO-sj
zq=S4}Xpcg6lCS!~oy@^Pj8l`&HpMP(E64m5<T~X>0tOP*3R_(~#(^z$gx7Na;?s%&
zr6{?XjFr14rW>gjm?JYyPwC8SI+cCO)x2Cut})ivZ&eF(!g*Gy^FvD>f0^l&Ysm;<
zy0aK7mkuM9R<uEX@Si}BLm8#AGq~=Q#NLp6ry=`YUBcITqVz+qNO`ao3%G{z)$^dQ
zWz$e-a=DWUX&M%MEL#(Q+{Il8r9HeBUX_Y^C5^M{7-R0)1de%vQO|^BQc1!}J-;E5
zZf2CjS~aq=+Z?KCcH*y<TF%f~;TPKm0Ti+J6`NdnnRdO&JQ+l7TaDx_g_68}buJXG
zoF$X26xm<g4=bl!9^*bPxg%dn?(SUffx28Ni3ax60jawF^G(ZBDZ8(YCAX$mkA=Ue
zUrG|onl3BHW~{-=*6ZoQ4ROo*yVi=(kG7y4zV;Gu(BRp#Y^cSpYiD||TtmiR7_hVb
z4h~9gFOH>zfDxhdAIWO{rmTxFeG`oeQ>Q&b@^6sG*Ayr#yp4@zGjV$pmVk$j6%W37
zHvu1nFmsGsmP_+%_CJs!>u60z#~QRjb{uqzs1~=j66BdYRRt@fTk2hbHcjJR)9hBn
z#SiRFEi<I}P=~!rdeIPT%_U&XDXb_>>UBpJBTor0&i54s-EHA#jZkjwD{$1Kc5LX?
ztUj2|-=G%?_RyePC@#D$_)MU?0Aj*<d4B||ac;scpS-&tw^{i;%o&**Y1;4gU1!yV
zVe1!GuDmy^VWcs&11{;>E7g97kGo^{fWo~n>><BnG3RfNk6?x?T46+6qeacW3%`yS
z5RP5OE5WJ;Vz*(r?Ja$^-Up2?nn2z32hzZAz1No@TR~cmnblw7{2s6(eg{5<dU`-N
z->9=wiC4CT!d!k##W=p*1Hp(3n&#=|>wus>^N_?fy|%|42R_V8rPc>f+T@AYux;2>
z?|C^eW!0|f@k@ZCRabPDBk>9DD2Uiqen4nN#0$)rpI{CvoFHGPDgY?w^H-_e{~@Eq
zNYimNXo>{Vk~?gbtF567Mgl3J0;Sj9ulsh04^de=Qd^0Z=NBI;NYhqA))1+GlwQx^
z8-NZ83&-@$%{Pzj;He^NE&l2mU+XD;h<NB)m+0eFA4f(G{%OVSr{7K^%ptCX|9e`=
z?<o-Z`_zN1zuh_F!z_F~4Y!K_`(uF_qq2?bnP5LR?BRwTY4`-|y_;gv`zDsu4_}4K
zjiGj|A`W63PU`)u2Bc{`YG_`dI))i}ukqiwv|4zjZfJd^DRp0Jmo#>LlLt$wcT?*#
znH|*P<(9PmwQa6BGjjjuZ}`VLV@G{S4*$;hlGs$k%GGoIBz_9HIHa$$29PDGtFB-A
zkvm_Vw`?4b?Io`sF`*7O-nb}tIn0fjJ7<K>FNCr*dsI8rE;Z`IooZshd0zKkls3Y_
zwiIgl{7bB?wi68-_C%A>Jo@0qV-a7{^M?l>S_yWOF|^wJNAj2%u#F{bfzVky^tICS
zSyiOG#JEX#@x{U>7ID58f!Ky2G5g6x1#wPdUaz4<HF<U1fx`<)Ehr|iVRolrdVHE<
z-ou4f6g?fc(F)fDWR(VSl9IGr35Wc&=q*+~_1t5ZsPu!vL_f+UWo2dM6t~Tsk*0ec
z08a6e@?U5l`snToHBKjp&@|P`qU^sU1mQI;@qykGRdPB6^;)afgjB<`?_g>aJ&9<T
zN*;V10q}&G+0_dRa)Q2@2Lfn%)t+kki~egWaddi`oeJ}_a!|KM!Ys%3n7IZxKbB&_
zdB_@pf2?}1&^fol2nb?5aAFoKH>;)w!gfnOKL#srOaR^B(Y_V~X?y1<T7d$dU*R_$
zB3R6{4=QD02IjkNsm}V??o-v;5xh<c>T<NuBm{6gmG^BA4g9HZVZ;PxYW$2C8R~BD
z8aCBy7F>UX5@=If-JWnxIhxZ$iZh|6%}4{-Y#lXccnYRKrUM8_E;Z56spaC=gv%)R
zs9uk=a4BtER5d>QW5y|7hyQL6QOTAM4x%=CYUXz5Y3rU+(?4?PDimKSrb_>OaJ!mA
zH`w+yhX(;-?9yI4mMk3YuIYt+Uwp>fmupYo;kh|v{j1qRc+ps3kM|^zawc63FYI<I
zbT&4{Tt6+5fSmGQZR!ST5dSRr1?+vnj#x1uPn?C~jEg{=tvkf+@HxX~gsBW~>5?jH
z9KA^$;-50`%I$)#V9tGv7i|hQKlu?gnnI#{ZQ=I4iVPIOAGyPt?({klMq%S}cJ+*b
z_!u9{iYTy~hj13WA*PjnkUtfM%OxDYIIezKu&s2FH^y`he|L`DKLrjA(!H-h|DbSq
zG^hb#;B#KBX;iefsQspAiKma#%L2Fv(;TS!Fax*HrQ-G50~rv}*B|ETiZw2uI*F#_
zpmDQPx#gGHLhSGSC1o~jD5u<@_H2dy%Ur?^f6Ti2edI{_qZu1<M|QvXkIcjhr$3My
zW<lMi7LmBFSiRu6zU-Mq`VeURb!70Bltw-M?%(AV2ywOrUGP}Mpef^i6=ewBr~Uck
zsgL>Glpv{h=&<bJ0j7UF%1X@sYi7ja#cD@jQ7!7xATzx;!rfB4Z2oy(-`!&&ih}TW
zox<9;sFr*i(P`<c^*0$Tm$o>R2MtuPfLU=q@w&zPXNI+UXcdUayQxmLBwJ|FV!0<v
zoTeN??gPETMg7@%v5JtVOfjg=;a_=N2mvLO|I7twgh3IsA}^omcMdAbTj>8HS-LL0
z)cp8XwiIE=3svzec7i&ZvGT;YHetj#pj?hbh4tKxU)r(px9PSwL&#3RF&EHC3~!zS
zmO@DaU{}AOft~8cQCa*ok1v&>w33o?2~?I5co#3^#7(Pka3eL}+m4ZAV627qSC%i-
z-bK^iHe_rsR0O}@zw-qTJdKkqlkPt!C7m(HC0q&`6W@hL%oO;_oncm@k^0D<zvP<z
zo#k`Sgbv+PjntwR)nGkuo-ukWko8yhP5+g{Bq+?KNzBaa6ENal1C32Ao{Y6t^r**(
zmnUiYd0iKZr48cEltvmvq&+=nEw8xn`+O(=+!VF5OJ6bdrnobE;E0lBs(oE%k2sqd
zj0Oas9$FBlKMm<OGlH$F6Dd)c!<+0WnLiagzr?Rc1-?mVegig7GqXWH+o7cy-&kUu
zdGNUPo>UNuafHaY8A8sabr;Z{^m@gDY!E>~8&z}PIcR=99hZD-8$w8WM=si?@J_HN
zlxZj@{Nm!|r}-+xn+cYzGJf6^3q-n~vJY&;)qbnvo-vT9=m^je$XF~@{k|RJGPUc!
zh8enGE*@Ss*-4TZY7HPcSD>QE=wP(}Rrq=(aKTpQfnvSIGOS$sPOmcH+BuM6w|;vg
z7VxX23Bj(J#^`Fj-|-sjU4}}DVv0HIJs3U>b=4Z>JI~OftQM7;!2nI_K|+1X^x8W*
zwb}*;%wd&X{P`g&Bjv$Wi$(#06R8`ickJ9azuiK6X|zYsMW@2d3xTkfmJyUaeD$+I
zTBVo8F9<zlbjHfd=TugX4{(MU%YDHhqzM!Szk*(?K72!TKaGF+y3*ktk0Cle1P_m+
zYCG{#$`z?uf&TsN2a06@Y_nBXl}g^4_wc5pvgCbzMFs1CC7fy4I1|!}nm4$1F=331
z8d)La6L9vw5#f}C+Z(`6#uw?=_E~iGZ|{5+S7e*iYPl=eMyRZ|-n*oi(s(Nkqj7B^
zU0)Qe9uK~9LsrO6MRRR&t;+@<@2rb~S|I!dn%fGVlHg0V52`H-PzQwwgrFf+1t|SW
zh_*reOny@%l0R&7k>~ortlko<XqjDE=-NAZG83gGO!+(zh77#9^j!4}W|BSgTT~iZ
zU)6|wJ0_d^^INcbO8O_qkDvmz!RIPaYiB~AMlvLO)(Ga2W7a#XILBBkKX%W?1d5@(
z#?_OXPAf=9EL7Y*QM}c&=H^3)L>8gtOV8Q3UR!i>A?bz33M)_f<GC0ddRkJ>S#4g~
zY}_Is9Tk#SWF*XNf}rc;o$Q=`rh`LVYH64#Ti&0$moQgQgeR^o{?izs&lPofSc7nQ
z!Gqb|X8|ZXZA31X;piEL-u5h*_nb*Um}2nn^l`ZVNOrEZ?=g4&WCjSr7XB{Owv`9-
z_~x@>U-12TaLj8}lE@o#l-U!_X~od#@K?0lN&+nhE1{VVT%%$3w!q<8bAb~}a_LP=
zp`1S8U8TYa26GN+^)R{h-$Ba*(%eSS1k7Hg(ohmWYU`#BUS)YYMjBb5awTvg=ytEA
z^$l2untWK<Z(gzz^wW5dR-~nAayo;6%8G+1DW_BHetoQ4r-?o^i=MHM|6yq4EeC9#
z>APgirXiuir_0Y1nl)I?TT5#<(t|cG2ww_zEz}gN;jj}6nA9`as_(_lx{(Bw*F%2g
zCQniKWypcwdx?Yh4yeX*8}%S&3-<ftH(&LHC#?l9EOCla0cohlV|p#D+#HxC#rkN3
zX%R$qI#sY3#}f}0<4SUzu@mi>Y^1FA<YQu(v^`q-GVtD~BTYmIlaSMpY)mTte1qbU
zOU1l`%pRn-3PG`}N=~S7zK7|VZMiuf&qCOEpC&i|^Z|JzEWrHm5vc9)se8kSMP!n5
z9dyOE9m_nJ(OvZTg0P|ff+JayA3#@_PG{ck4oz&n@RfPpG99Q)v^lZ=`sx)9q9fqx
zHYvZr>tf<e>tCgQ5gss+9qRaD>&A2#n`W7*+dIS~BE38@-?Z`(n|12rt$(OIpJg)z
zcFDl9J9EjO$5g8IZ*H#OUEY4ZoomFVPa$o5`|^B1N+RIUDL6?idF3|1<8Sg^q8cbx
zr&QuRVrsIun7%lqV-VT*Ca;<fyGqCP-B50i0$S<^s|+83*5F-oTrI{uIoqOW&A{Ic
z<273Qp8j1p`$DJF_tF_Np6`r?HmJS3n!k0uA#-%~L`Rpt^7tVSIO4?}`)~pw&VI5`
z;AZv3+@gpV3wnaO*FNPg=%5K3extzE>3P8csMsABCxc4Wo!liM+xhc*PRxJ1NXk?<
zeB&edIp6(zxf(C`q@&J4x`qMPUef_M^g_py-;9>tamBJw0oX7by%`>#A6FRN)OTNl
z)P$!(k=-CSSnBOuh8Q@y@rIeaA!Ji7O%px4`mPxV6Mw0bkUPC>&F!Grd6Dk@rPq3F
zzm{xxT|3i84XpuwL=)peFN)msEU&981ke>37K2IU7I_LyLOS)eY{sOW2Ug!j|K4@U
z)P;>saNP6)!S~LUs9{%NeE++#>|=p8saZ7-fuj&oqg1gXj~Bo}{p7l#_c+3k8*^}q
zS>^q%KE$hHbbdQ2jsa(u?hfrKUQ*~$NxWs{Z&-<jbe?tr>qbBGo}0<yr`8;H$aF_8
z7Dl9ZrPWs7h=?<Q(K(KXg7qWW20K=A^5gl<a~d<rknVU~NGYm0(sTw+?nUMo(G^-(
zFY*S>Y{acuIkeFOAsbs9VD|V)Ix1ZHsj<zl`h&dit`e4;H7nWCt#YQ~gfZRc!7w`b
zke}C+<vX?%3w!Je!nu)B7&n^noIFdO-N7v9-+xcdDH(tEf&|}S7WMKL?pNmc_L%uC
zO&h<3aFKpKzRK<UDFCaDrf09^f9xjx<0WL127sscd*04(aM%c~K`1ni_3sq{cdz_#
zl|!<WSf^CHgH}AD97_JKtUgQQ&(2g(E2^95d!|$p8sG%yqL+2*kKu9>MtnH}a>s_>
z?E|i#n~hNI{2<<!GD250SDs0pCe&<f*_P5|CTA?CF>;A3Ppq5xaSD(t70oWP<rXl)
zizb`&G7_OUPui1JmY8l@({Upw&F3rX6|@njEA5lS5Cj<lkTG*bfF9PB%$A9xiXxnr
z0qTnUbY)soe)Afg;Q9t>PM5)(@9$!ToDX-8cHoF-dvYLN$=zy+PZnOai^sEzXBV@<
z)WS|2i`(<n(Ot2D3*YRXA`6dDbxKa9T+@#~{(YK~Su~irB|r4WTfyX|Pp=u=?&>-D
z3I?&+sj_78Yz~aDuwQmPe?qimVw3a*pd+JliOw#2a1D_czu_OLVoWMQpH+c|&Db@~
zt{u{@bKdcso>TOb+i+yk(upFNP4<pi=tvr(^0zHcCuyR(lf+qHEUp^ds=tTZ<o~?r
zt{s5cfyY4}^MWcAmTibxBll2`FP?sxAqx59pZZjbw=M}<%2I+rL!NblS99g+S2ZZ!
zb%moZZ;tj(7#V-CHwhY9PR4AbnPd>H@PZgUYlhIx*6Q!$(9CBP!p<!%YX=xdnKcEs
zE0LnD*j$049JlbWL*0IsEQ{xHBtuNpi{|}3lcB)!o5G0Lh;2x2jG9$Tx5?3?zH6@Q
z3xo0VX^gycT#Dy^p+?$F`SLqY4zS%RgUA)?0T1#r4t0pqqiLc|Y<@B^ey$hjKv`&o
zvVM1492I88%3a7f9%CS-f24JzwlieT?8n*(mO#UXTXoy9=od6)kg_}=l3Jnu-C0wc
z1!_r!5W>ur$CK@Ibwn*>%h43)$C3JN8y1IEC;QG_QL$txzqZ#0pPg|`-R#!Y#|`@!
zvyU)Wc2ha^;N-XW$r<}$$f{`7#=@8_u`SE|darIiLr}q0XHRZYnHGJ={BLYw*aB0k
z8~>yKfOXi~I9!bPCip0;Th_~}1&?}xI;2h;`}=KaV2tC?x489%dk+P9obCeeoElwl
z{Y$}U(Fo4R{MKWK)%e$Cs|MK=R#%5XKR<Tq9Nm$M9k&kArAkMZj3gUjo*|JdYh5}j
zjr&JgHPgCYtrRbIZ`*|}(!-oLUItD>w}rTKbJK$Os}`(fN_FhYS>EGV%0=onSqHJk
z3eS}oTFVIhH)uQ1l<6MH3O;YE!AxV$%u>>w{l-8aHdgV3It{56Y&`V_dUZdYI%tcF
zO)q^&aF^>(f#&KSS6vFz))XLpy_m8ZZVuSLe@(6stFiA96Gm5?Na1tvCRPMRi$>+R
zxcStYb<kG~M+j3YXK!C-A?Lq;zeKPxVz-ppVMipZM4G_2(MRlfc=g7&%l$7SKR48u
zvWU|t;<7M1l|fFQ?=<Ka%T{UYkp4=t@gaQ*a*@U<sM4L>GwG~e8GDwxmn~P0PxBQ#
zd_cKs>&q6-xI;P_WkirxsidjTTd`riiKH7xiB>jlWMZ|*CHdPN?O&Ib1*MV%UwPxq
zhA=Xq|AQE1nBdD0e=DY!Fe-=T5NTwNHK=?+E0MwO(Z9eItSuz2KtO{tx|VsOTkUrp
zirq;MaG0&4klJdw41eH@EAT?OK7NR4DT;hlRGSGcHq)!ve;9&>SlnvgW)DR4v-O?o
z*A>Y`NmF9)Hp0w|JK>-2Zp{=#z^l)|_3mtDFVA<G9jm92c5q*^|1iHK3c_c`LbMs2
z2k1Ew{|{~y#?ZCc74O4A3sbI1@B(o5f%nS=bUcNpR{JqIeT1e2)x?lAMTgRuPj_m&
z*HW@x5)?A`w@e*YPBc)?w7fwBay+z)Xod{lA&yOvFI5OOr)Wo6R7g8GHVqXb<Z^8M
zUwc(Ya>K%gU@ha6!%)d?FCAa};?%%17-YLNBtL|rCE7wt4aM<cZ_)=;$Tj!*_vUd9
zEe%xjuhB2g#794I{1S<J*IBkF-vj_YOu6GM-o%}d6m3gml&kp4h}5hNUd39n6=GpQ
z2bm8@r+>=6(lu(EI69vTyOw*{Z~`j<5x1?q#>l-}TH@s6Z*pwJt5fy1=8HoeWfx~(
zR2F*{Dy(sAA7CtZ4(W8gun>l7OhU=;lQCw0(vf6@>fQ2l{Uy{I{ey?H=7e*#0{HnJ
ziZ}xpE~d?}R)kTh5P~UjLmZiARL5eY?C@q4Wn1L5$y;E_6XLwltySZWqv7qCx@it!
zdHiAo8syX^8Fsf9$(*Ex%7dj8=g<rf#<=@ml>Jpy8(bGP3I_=8PH}g4_d<(1#jQxO
zLJ2NK3luLDhaknhxD_i<JV0^x;2K;``k((BXPlcep7$<{kzBC%UTe=i*IaY8Y}A=#
zgpFB2<iMQ9IT$M6&4$}>lgd)l3ncC2uiORA9|ajcq$6H2amlvhzG@mg#%Vth*AEu1
zRufn@r`c3f(Wsxf)A<vTo+ZykbNx<9P4YCAttst%t`F`^*`#M^%w0?~sDQx9g7gM?
z8BNsZ7nfc70MXxtC&S24|0)CJ5HQt}TB^BCfmdU*ci?$Qe022w&^y4Xc^thpMP6&2
z72~_Ly*;(0BTWiU;UJAVrXYUG->_C%ouEj%kC%>{VHMIQKX0@)JO#I(TL@$8_Jq70
z@4nz^WJs<LP8~6diSJl3;G5Stw|Aqy#s;y!s)Q4)kBNXW7K@IdpS`N_(Rx@Pn8Hz4
zqS`9A|Jcw*a!;?S7O@L^{hVhPsa>JY=VO}9I#!##E<g5zH$zveB0O;?7l>SXZr?3b
zCKqVh&|m(C{$>QavjVgZ6~u;Qn2Ovi$3pti^1i^2Xe)K9*&-t{-mRMlBk<dej1Uno
zk+9!ny<2W~^K9j$!;ObpZqz@2DGxyo8mArc_`+ga;xnfGsAlhQB#wMr?V~1bI1Y<M
z)7cbn#A=M~J6T=cPp50Y$149+D;@Vr*r92jg5!`cXSsN6|4YtA!}lHul550@fJoPh
zp?l%kId_(O_IF=9m&yarfW2RQq~2%P%(@#ZS4Ee)*w7{}x^@i!DyZj>7qR3j>QL9X
z{YAh3-!Ow9@8c1ZtY-Ke(#EY3?pBG>sUY2rq)9eOVaZ_0NRTP(?Du13<deQbs-uUE
zvgEFr>%RdoD{oMG)Sx{$Vd#2-poM1bw5;lw>Wle_R^*&A>2^A!tjw2fd1iPygl^up
z5dKu`_ySZ6mVWwCo}%mRlN&wAS3J~)Z|%o<+BmQERfp44drRhfp2|jz$xxvww{{{|
zq0V01Od?x7Pc)w2y|(n2>31Vl{M0JHPHGwF6sNIH{+&f>rq@5M_$${&QVhR-KeqcW
z64gPsds8_mXvMsk$p&hJyB92cnzJo|`X9K~hP#7BI=J*GgjAqN%)OsvSmp2Mhv$0~
z*W8<bGcE}`O08}?o;XT$gm|7ar}wn;CbSbpvz=ZHe8={^A+!~XWSJRIw34`q7CH1f
zA)K~8CX%1IL;3hqSuN)HlDTWC>QV_DTIwEj^Gi|VxP3^CghU_bW@6}PI&+ol)Y$sU
zW$D<Hz2B$8XyH~iVTLW}Sb*Dl@Jjx5T0m>O*}@P1B?FOTg=;1Lrk2>Opv$~iZW>X&
zg@e|1QnQLCC#&Il$E0K33t<|?Qu=hHF_O7u5^rx_W;EBCc$A4O6}HoYG2rr0Qfb&u
z(7XA~#o}T2UUe_8R2%*1{sC|ApVW1n%p?^slY>P=uGSe}Y3f0u9B|Oz%5f^1pq2$L
zgG8O`Zz-A-1Cq^Tye?UB6e`%o9XGzQrW@;SfA5KM7U-9IF3W~t^Xc@XB!?Y}qHci~
z`f&`yFlpWP46^aEdwxMa^u;$ccE*j$(Gv%L>tB;sbZ!)!CG(AcU+#bPE1j}F@QtCN
z4umNVk}+@A>QW_4j34IUew@GWXiu{oQ+@s`=dw2HQ9kwaiCbl9*_&gcNF2<t8jIb^
zHRET#LT1v6?KzfX{;RE&v-VO{()Gf!m0f>fAVxh&XKpZR&QACIJw}kfg{8rvJ4I&U
zW>28@sQ_leTX(G?KqvJpFQP~U@s84K!#U*-O&9e_orW$^ExzWgNpp9yl|zE|JE1by
zzJ+tihX1K{VhZ^8bZDwI9~$su(x;KO&Y9GL;iwM1(??uL-#ofOB?BdgCe+xeOjR!b
zPVbz@G4dAFl3M(!F)62Q#3WfE&aQt`=x1}>^lJWZe(>l$t^S(bZbwMD>9*HV`L8HX
ze;kWMm;o00uzfm-nN1EM!%&NQ<kEzngusZUu}8%?nB1Sy*6daPZji-H*w5UU2Zz5a
z^*Dw@bB>>@h<?mGm-?1Jt3J7TRN@F(gWqM$fh$W6(pt>Hp3MVw=G{W{SpiaL9Z85+
ziqAr;BPF^0NYS_FikrHIk~X^yXOdFVoo(lI-O+wscXO-s2h$tp8<t%(;F99(hR)<-
z8S~-y5A?D!8oQogdc>>4pf5YO|AY|Q|3W*bA%efMFYP_KE7}k%VMw5cs1K4I-+Ke5
zL)gB$jzg8c7T2y;*<Y=^sJY^#(qBc;k18b}U+-f4|FvEJO<;Za=3nJ%VzUM~0TRcC
zm4D$w%3Z&*QT$*WJ)p!2G1sY&`_yoN-l%U=OE{hXfCbT>YRD?6&yZ74aWEh#_&(Aa
zh;Yl`&LCL&ZAq?B=lxHQ5xlanx*ti)%atjRN+JmN9^^f4Bg}6Fja1wTZ2RlqKgX>Y
z{LK55x=}>N76kIqRH2;htsx2i?8wUF=f5YF%d%k6ufgNJdR+ITlRlob2HX_TX)(R$
zZT#C{MBCFE<CRIoe1`e1=T9e?K-=G-#hj!aa1@;G(F}h}LVyTQjoEMi0Vn(ny(!lA
ziMl$^QWc6uV|^VqU5&e<o;SgEnEEpppzhf`r0?vbjLXzpDv@fgGiwGKYoVjW|9=1f
zVZ`zOTHKJi@7;%tvJyEOKtu%5d5S9X%A@l+>ZtC6E8dv}$E#9DtCco_?C&!r1UdQ_
zmx(Ya!)(P8<<XEZk<f1Q!sTf&+c>j;zlQBp{n*A26H(#cdpLx7S+K8lro5T_a0X1V
zY6^@xhEa5Y;cw4fIK5ByK-U%CJtF&$6tmx8q`QI8^UQ$lk84O`V4wEZe5;5$-ys+u
z-y{|!qe1p$!uGi2;IuhG3JhLL$3rB9SMNr?(*pm~ef)pEwqEjoH}zEzt9&x38L(_3
z3$g0kK<o5E+S=$&w=Zs}MB#|AW0}r!Q3-BZ#Ijm&&K#wftfRn=B;!Lij`&*EvkT%o
z7E?4@jKzuA?a32)t0zPx3yYDnA;NlC!C8cr(<%ESS}6om>!ecu^xk!Ej?<{1Lx-Sf
z-@*9t&wM1`FcK&sg?P2cNrznp9rRrFjGEXm?UfVBJWG4{8?VpEpKftD@EJ~Iq=<E{
z!X@_iZ!Joaqrsp~uwUyX_1x8S4k+8+W$y>9c;xexyZ-9?Eap;NdnVZgCWQO9=TD3y
z(SWC9%kT34<OWFp)JQ0~AhGxVDRupybK(Pcg=a!oJcQ9_sL6Mh_l$<ySMWG8a*;Mu
z=WCC{hk7P`Z!SV1ME-!;Z=c*RzW>^n-kSU}#knMYMf6!}L6b?rB>lQlatz<rafhRH
zqqcEKh}AeDom$;DMW9kGMOeF>+QW!Rr-G)j`kN~3UWpE_Kr!V-nDL<{%0zpPLm?bt
zJAV1wmkW^EA9#E#+;n5Uoptb|NRuS5WKP>wT~ng$@BaRT$ypBfi_zf3?j?wch9m*E
z#&^~$R|Z_?UOixgpN9*MjCnMHcNF~KSt5aVA$rooHC%@v;hlH?+i|h|{|Vlt!MOV%
z@&kQrk~G}$H;ak6mxtckL$0b97b76|p<f+(KuVm!Xa5rO8j8~_upcU1k0+V}c+&lN
za&*x+Uy=4Vv>~^85cU{m$Yl<8u%n2{)gOO*2?KR@?ms~;OG*xRU;$D=Q=j1N6c>(C
zLN0#4sONU14-c=dL9LO^Wh1HZCd^H13wRUeyXT*t@Xa)*fgk=Z={=oz#s3`M|6<*o
z`ybt2Mc|AS0!aB&hSENWtNH%RcrJR?6!$@q<nYeVB($eb+NquRh@_h9y+8*~=z)59
z(Hxi{Vs)Uwt)f{>DiGe*UY#c66WEFDF!q|}<?0q8(*8j;tz=HxMS@<|Nrm)*9q~%=
z^UQ4s*oK6H^C+m-*}K=VS<aKH$DCI5Ou$;uk`({wIe%^-Z>~RYNu(_n0;Zm38g7Bd
z^hXqUnS3qwl2e)Oe~N3K-0liaS&0t0+vGGXhqy;(#|U_nJkK-1H?CjwK<+oeK`|%b
zZ(x?8A>)8f2Rq|GIjb~6f&4Dc9r1%DEYdPh?rM5(%ucSZOGYF<$bdat;e6O2?E31e
z{#ujg=0}aD&M$aER=F%O(*Qz0{2Kn$)O&!_N1YqNK^ZAR8Q!-Q-tV|uLb<aihxufO
zemsREz9X6051%qtty35W-Y2j%{YT=5!L$0u0pHX@BE<hCEyH&LeyIgY(@gCP{;eRV
z3_(Nmn1k3rHfO7NlGaRLcbY3VF9n{{+Q!JQGqJ$Wc|PHf*UKMz4An^y?g4)V!C_((
z*J-=ebJEoTOkc4F6k@5E;WCAEDw58Yj$g9yljJmCjvxNYE{noI6Buuak^5Uxa+0xw
z&g<=l`!PC1&7Zn~O_CJC=2DQfpy=sAc>Ia@X@jhzaze~ahD^xC>YyR+6tjI~0O*LZ
zpz_P0U6lI#h3?A=wO<_0eU9{fC;pe^YhRT5mGPVW$R&^N{hx0B$`lc$F7e7zSjJQh
z!^^JzXr85eO9#H!?`8w3(9<goo=w)n$E>y*|J*RV#E~^EMOI%9X=k|vSe!|H@O)=g
ze{O6`|B%OL<jVX0%|q*2<b;wT+#6<#*$Hm9MEgG+9nqNX3T|1{y&7$w6Ybz<c_6f2
zqiOVWA-ZWIAh7RjT@TJ1Ea=D7MwaC49YHUON7A`1;1p?~UuW{bgz-z|9n1HJj^e}P
z!;35TTtPD)@2LuS0oY@8N5lB#3<S?Z(=9DsuY+fgz6XDd%-O8>es;OlxrEzly7@{H
zCAy@5xgO$}2euHDQu35LF^uo@Q%-{7?oWh`$MEl;JlK1fT?d`R1mG=$V$ti)Xd$%}
zt~?Q%9NzAtc>&Av0)|Sqo~Sc9?Cd+z;zZvj1m^pe$9HVQ_X^)I=A7Nf3%?=56(?&N
zX8pKbdp>8T=ao6yyL*ytU-+{cFP+}<+-D<dU_%p#udW?V-8i|tpeSYXx>a=BvwGBy
zaIGZBXV<<p8@C6r<}oJDj@#U7N)<PY*7>a0!{eX_gpvY{g&F>bm4*j5<v(cbC7y!@
zBx`}Xk?jp_6s9E`^DY+}+aWc|qwIWom7}p2Cz0@}TYjAr@grQbo!#*8L;mzF@Be$L
z1;dhy4|g=+V)y+|8pbES8iob$!27w0K<HjHtZak;!7p_5y?c*yLNBp};`U<u<5bd@
z!IB?a_)3Ap<4@f8X5T|c8;oLdEZ*FY##9%YnJV0^iV)>_=N1B7A~{IpkE+DNS!Ev-
zG+LHP-f^n^ZghiFyt$3+nG{Q`HG6fJwO{<o{Hqo14EaN#sHgO;*|O|>p(A|qC1Qe8
zMZ|R9{iK|A+ssP<PdnVha5xNu%cVrKf@f&LoxE@+RpE}3E4A1ZrBW>kQ%cmWE7F<R
zGu_=ld(PN(7)R7-Bz{~hUv*mI%PxY-A(P&r4ajfLIm+$2nz}t4-cDnk6#YNsj(@>0
zuD)(dkXNO~r}wR%Jmt3}St(ghnB15lK}kP9I&DL{<XO1QfKQi^Lc2LUmDtmRZY-JZ
z{%JzPx{=W#A18%%_9s#<aj^Za-Xbq0r%HUd?<pQo!i+w@g<emXpXP;6KWB39Rh~}|
zi@WA>YfelrU$x}QNIe<t!Gq#{x@LMwdqh)Hq9dOB^oK3ndm!5w9;$sno)fq{isgu_
znyj*?c^zz~^mxG;Fd3ZGB6%_gsW~k$V=K^pf8d@#@KXR-?};|T8fGpOc5uyYyhHw_
zkFVzNGFMe#&DmfciTXs9jJu19M3{*8d`y7aM05r9)ERL#kJwz5IBtxS`pF$L0{etT
z<f$@x^hA%~JYn@U<MHc1nf-aj{U?ruu;EqGhDpGd6>g^i>X<d^6NzqZYiG=)+Qi7a
z+0RD*Ak@#?R|`D<Q(D18Bvt*l>Ye61--do5FeVS>O*&A96jG`%$vCA={qCyrD&dnR
zzgoBq0C$dF!X67Ila7a@@O-GyO!EL$j7G!$kzYQX>nG3{Z~p-sC+3)+{Mbk3aKb*F
zA<mn@hjxBm+>(izfVW`<b)P~l23<b;Ep7;bd|9{(;b7u#Tj9AmV#5lsVh+9DW@>ZC
zt@YwYQ&Se`0IL@0I{-)6U+<xfTPT5Maht(&Tcu+^b~wq~ZzliPY4J3%iY-}T|FFyl
zxSY5atg(_=gEWQy{A{tRGqS3$_yMK9Kj!}ORHFaw=6cXJQeb=2Yn04W;&D@<m0Xxv
zVGz&P|5cqBk97#jqJ+`%(`TnYQtX9;W<HBm>eal2%K~p1WrAq(Td+@d6;iW$4suY2
zef7(!Q^Lo<Ec{?!%Ey~->*k(;o93}0!^rPCtr=jC#|8@Byc3T6wivI*!3iX0Q~&ha
zk*%hMyP^rDNz)gPUhMcU$vY3n(rt0vC~8~OW!AAuJf>+o5{TUMt-n-;n|Rs$FIxK|
zZf)KF@Wl0*M=l)}&QV%IXreo+G!Ip;;9x}+#Q)y#f5L@uzDf~j&Ws?AhqgXdq>7RQ
zR}SmF5@Zd7W0;A^?g&hXiuiOv1&IYL|DRI$hanuxU--3|YmUjdX6Dvd!1&?zV(?bk
zeZK&B9qw-bZhEV&V;=@@pB>3C*VL5R*H81GdfeaFH2%eX)3P%o`OnC#8NRpYTW~85
z>G<Io@bydm4fTmTrTy&b{*c%n0*aUx7Cn=3>ieN@eT%bxVE>o7)7JK9%2|~rTO)oZ
zJ3KM<aj}VIT`4jQAOjgNu`;#0XB1>;2rjR#R(e^zQ~?+V-=L5M*1K^90_J{mW}Ejm
zd}02w!r8Ou^8VwByim^T_SYr8$w<4hM8;!yPn#qw`7sVc{!k7the}<zyxgO{y~kyQ
z_1GR#es*Ic!m(k7a83X;D5O_xAhoi7{V`mKDERadF+f`&V3wXdn$tjLO~I=jabqSR
z0ALK5!`L|Gr9U;_tP?<1wnB#aU`SMWrd&kog7AV!1}_*<fAD@)SD=#8XtD2ed%fcJ
zz*#$gRqhq0L3ONy)88pcAcE=OiCsH7(2{FtHn9s4xKIyK+8Dn_G_Ec*;)J-g2QMoj
z%$Ook$!|P`#1n5e$%#Dfv8?C1^|{Unj77ztwX~4o=bkh{sv%riF7Fn3v?|CCnB?a)
zeONaWcP_SAX%V0_%J!|KWx;x~?6ky*7;lh&AnG9e$3HuqF|wHfiyLmV<Z<N$16%HT
z?BCPWHH<9Ey36#}8<Fx}tHy>b71EyIR)GK~(Vjx#2WX^UX{-c3-zrziP;-8szuxGI
zyYUCbMb2$OGc{j=oRezAe}0PG^psWoOJ_AC2R<q8rG{B<Xvcrnx1cdN^*7keI(Mfu
zdx7q4-E18vRLeX+o>c(za4XzDb*Tc3HP2mmQTH~wSOHMBcU8eSOjie4tfw^$o;f&>
z1#uKVR4fgiqwH=d6tFVpGD+7KZV;0@;Kze?^7@^WS4)6tbB=<Q6K<oaoM$L}N}=X&
z?6oDrbeukib?IZ?c}`v<>{?_qH;qWEM*IhtsqcO~amS}EHSZOW{gD6qcf5|pHlAnh
zi+VmHFb!ge?H3YE{_xv7i<J~=y~4acc7M}u9qapTN^F39|K8cV4<AO?LK)1V7^iLw
zMQ7rm<h?%@Z)5;;Ciky4N-hHbbf&EafBu3qM~%$P(7KmPHX<62Z%tjkFO%sUiFn~n
zz}l}GUcclZB1py_K3)=*{v2g_8%tpa$|qieP#IGZA_G@G6fCjkfBVBw|4oTa`*r8I
z@HXGj&egwNpPnZ9$;?xa*eea*s#*oc%wQ*3_CYw@JDl==pLdLjZI+o5Nrip(sS<d%
zZmk5s6kvypeohez-jG_+2-^}y`fSW4C<YQh*#(l?@l0k|3Hn>v4IpwjLSdP#Un^0h
z>_S9)GKb7m|Ci(R2H9L6c|dJ#V-7(s6<@&nwBpN$L1e|U84R1>dtL81NqjoZ8`lG*
z6O;<iAHC^SQ!qM;F|tJgf$whk&?HdagRh=iVk2Edo`W9mOFtpsOIpfp%4C+xSIqTV
z3d?`Y>nqK5{UOeUD$xr87S2Tc?e)o{O#8fOt_-;@H9$N&B(&QnY=L^VL!0(f7wH>V
zgGWMS!4WYBP|pBLo6dn#@HNcgA$G)fesAlv|Nl93i;CxFwc&gCZI9f`$%LTKyLVG>
z3w7J#FIG`>IM@UaK+)HukPqqHec^tvFF0*GR1GS`g6tr=*;Y&J0ZVrit0st9OO~=!
zXN)7i98_2x)mnaXc{*7^+gefwDtsJvb3`D?_v;>13!gkyH(Z67llak@wmCyicvZ1b
z9I+DI@#qew2>I0X4wx*{h4%3;jw(xpd26tITeM2`S0(ts$ms4@H<K<huDFGM6dlx}
zdwc6y*YuM4A=F&G<G$h|(|4^^ZXE~muOJz%N`J&BL%&%1-gb&?WYzY?bKY3U`_;&;
zM244*@%mG`4R!#x{K!%^SzU_iRNdOrnU^c+K+>eWj~_|U-3}*L))W|Y6<Y;m?Ja}H
z55mXn!|ZzzUAp2A22d_cUNJV2m!{%Km?j7%)vy!=1M@Uhd|THHRT1##Z9=DoLgxRz
z299DZ!<;Ayw_4!U%oS+%aGyR%gLQzcca_aFGo$;*2)aQI!dtW1v{&d~{pS}SsoPtL
z2#yiTSq9u=4k`2PAAq5gV0vp2D-|Q<`kx6O3B-Qm^2<n`IQp_v$Qh{oZz<00D>2z+
zK%|8xMlgwGW3XWVlxy<zA&rdv16!)GfjYZe0Y)}0K;7XC%}651pC~GD`JpZp*W}~l
z(=7}d^mjs;k{X0UMYX8LYtoNPwFCX(xKWWrQYcOwIy>2~j){Lq7u?5JAi8?vLsPQj
z8Bn=(9~II8@1~Ht5;to=mzi_&6g&(^b;52S=X#C}cKH5_G0D9l*4=0@kje?v&=DCJ
z)DqCRs?Y|XVqah{fd46g4__qm#<y~f_!^yy&Nl}K1&Pi#B1t~bQLVOPiOHFpJ}O>+
zec#jw5n?ACi#z*AviH=q7zsqABt?~Df)4s*s6_y{GS20mFi3w?tyL~YV?c#gE+{oO
z$N}17jfZ6AN5)Q>E#2LvJksL(kpI?8goAIiR-+4z%B2Yb$2kQ87i7W0IFszDi53ew
z2+-vqD%dB~a-)kni6XKakmNI<SH|oM%Vw~?Nu)f>h(UdVK~;on;}@lTl^feOW>T@-
zzx}>vwN&Sl2Jg%Te_xFE%6teL(fX0vyD#>-<bXYs3q=;sbQ(&QDxbEe5eU#_4Ufj<
z?xENfHCvOH%I&>A<_~E`7)0T4&Idf&mj?bpD=7+Bq7Q@dcqc9uV_rez=EcL|jGLAB
zm3Dg&X8#z`R0egXnYi}SvRmC)FZ|+k``IxijBvmxT#a`DH=tYKF1eHp(syJ+fEpGt
z?YK+EAR3EfQp9qni;6U|3!%h<w45g+Eckf42e8BJ&;o1zxVJ>8*au(d$I=u&U1S0=
zC0E5bIXe?d^+UQYG>Ot1*DFBC4~^ILdZ!UC{xpE&>mD^_2Z=pPSEn=tj;wdB*J1|A
zOYc77Xi4&6I=I*5MNHQR&o8s2+pJGhWLA`t7@U{DL}z_FCC$61F_ZO39?_5+#HEm|
zBc@wWa9q+t3eAWP%mmvC@1FYX#1dF_f|&l7JN+z_SQJY-#w_}V1zEOhUEzDbDzdo~
zvIbhPbcHkvwFIFIPB7JH8CUomVgIYk^BZN0!NUZZuFnz%k*46@$VIPa!lWTI=Hi0%
zSoLmYW&Nx%jW?4&#APvWjTCJi1QEN5@tOhQ$jfeiq<p~%D6mOcZrWLV;0ja2ykeE{
zYvJU+)p6=ge{@E#tx^*7_jn}QXv36JzaC%|R1fdIL<WA=%V#mOsPtY$aKLu)Y6K=a
zdr>@^6RH_InpWg#kTuA9cZugTy)OB@fPjuJ`vQ=S4B|)3Q%4MTO+bKpB0`K%2=T(b
ze_LYruV;XniPq#e++#FGL4MVfF4J$K#08PE(g1ahaaJq|Q_oEY0JD*8^gH3)f-csh
zFch+EFS28j^dr0ZFpb_0x_Q%BMx>2HA94wc)52OqxvV`A-%T5C#NgTPZTDU=iZ4=@
zVG%gfN&+kA>IP(-z>`Yyt1MzYZ!fL+A-dOl+r}UMzML+-LXdi`0L`!+d;Wy4!LyR<
zJ*Tzs*6MTp7nP7aFYx^*h1VNhk6mkp$-9d0kn^PIPHNiX4_pbdMA%vF_Vvn%7u&6h
zuS3K{iYEw8oKkBq_c1;l>gz3f&D#M1Qn*=-kr&^cSY7dgHEy(=9P%dX)w*bM1u#MB
z!hNU32K!jE(o1l#THqHmEZXs4e4!}q^9itsNxC#maoN4cRB6CP`|u?GV2`lFjsz5E
z5#WzGGzN$8Z|ZaFgp}xaJ7f0|`%uuKoQ!=Cc?C)B`L0LkS(WCo5OenGOKn<Bo{olP
z(Ue@1CkSX`fH;HT_YDV<hPQ1yZq_*fyE*T43wFg&-qCGg^<xF*s-s|<V(B$x20+NI
zqx_Is1l4Ifvbyibcxp3J09S0zooUr7cJ0Y>hJ0!*v7$DWdAe2W;3cLb{;den!fn>)
zDWS5;+W!n;YeEnSf`hQhji?Lsf-&9zGU>6<XER*vT0*IbgK|x>`~PCmd>UllfcaSp
zPn%6xGTv5-1%rjW^DX1@JnlS*2&B0>RjEebGUDQtzCRBFn!(V`C)FFLmFgE{xedFY
zPpG|wy=&{*qPNWnikw4e)iH+?2fd-e)F`4dY!FHAgST^}hdEvVV<+0j54b%$?l$xe
zA?lhX$KnW3734b|Y$3#|Dh*UK1n{)qjWp6g9c#&>J|g5t;6^BuVC4GJ=@fz=q8;I2
zm@9eClxNBfnrzK)Z4NJVpugo6fm&8>v49V5&NfxUh-8Uz_!t(b{A!~2psDY~*#<IR
z_~)`Fb*w<$;n&=WBq3)FB-*s^?<+en=}89LEqd5%yGE$~*ZHSMVg3p+Jqi$_l<*w0
z5+XL}N3J?G$`?^J_DAOej`kjn^d$xFomxy3sY8nuWp|FaV-6!C0?!%u`(Hsde3O7h
z>{EHN5%6e_<38S-UtfD25r^L6&Kzj}Z~$5^S!3zsBQ>y;Mwb0lnir3T9oiC2GnDA`
zJ4BA-%UQBT3DBTg%3?=PRMRyZ$miRIiIFe@I=i3XGuyBIPk5sBGF>4se6$L0f2%Ar
zC5N84j0kCzB1wanmiSRW1TKRz@8OB*xgtODNWxvTFf6E#G@ng`b{X8UI{wj|Wd8{V
zNlWoX8#-_jwpR(rTbPp!k00?xgix>p%*x&Z?yqi0<0VFa=Iyi;i+rlI62=LOzvQ#q
zghbJOcvBh(v2TjN5wBtv2ie&cV0w;<Jq=!S3K5~!MDz*8{JE;(wH2{+zx{}k&3Lv?
z{m|u(Xusw|N~cRY@O$r%orrtUywZU*z!-S7Z&`P{4x8xiC!;d)M~(BNUYZde9<@H_
z=lnX3+JA*&*Q<NGvw*k!$Le90bY4XTaBu6-HEpg;K{e1PF!Jsy>pcFuM~F4`iw8s4
zcV`9cSaER^vExC8Lze%Z@z*`I)&&tD#^hDxASLLB0~R$yWyaM%5Ix?&O_{c=a;ySN
zeE$HHRlC$RI-0K(W5O`sR#EC67RPr3e>(IF$qTOi1kDL|o!(CY*I9m%?!@dt*ZU6F
z|Bn{{`}80CLvcIFnWR7>ThJ1h9bRz~9k|iyx3?e$k!r%k@@wY5LCxwO@^<wl8CilL
zf2#46v==f>%HW`saAkyr^M`Zc%?_Dy{?+H)W1yz;H3Jdm)|4i<)!j0I^)wLW$vj=H
z7iNSdY5filFy84e@pzrC-`bo<dV7-OsW&)|Pq}h<jV9lW_6Lt_VYzoWjyT}uSYQ4<
z8!O0Cf6NdU=Tqg@q+^1o)cw=#B@M8{uqv`j=GoL)W<76-;*+H?I|RS!FBx*JhaXAK
zf*dU<lx@2+{RdLR%5O|`p<_>D2NC#W*%8*1ucd#<9U2~>+3(n|?WffcA-!zVh#qb@
ztCuu*!MVkU%_x3FYU_c7JAsIhxzoH%?!p?f1;Yg%s8ZQv?Mv!6Xgv?eUy=jn3O&-T
z6|Jgm&jbZ?=PP>e+LiT2|MqYT-x(@|l$kpbS^lE=bw|4!L=qymq<CU6r}a*iKKZy%
z1MU8Hq{UgI6dF}C`RNmrxtIZY4)r`U`VXZlwAbhiB%kIVL4>Vw^yIj1*#-@EtSCGI
zs=&O@s#39B+t2RAzKBB^*`;fpHW7|9nt+EoK*P8^9=9w&JbY&jPiIaf>5gK=tnl*V
z5X$uLLIejYsvqivm}p#nwLVEM<{Z|rF2lr~Yitx=P=dkXE&VW8ZWtUUeae)_(u2cE
z$|Zf}=BG|B6vFpO%dQ2+n?hlvJ{}O%mk4AZW;3^TQSN$+;u>dyU~Xw!+HQ|h$rv(Z
z2C2x)r#rp9tJH!s${!{j(OYF4WR?_D(cf`y3<`0?`G#KAs<(qA?SkKO6DuceIYcL6
z92-jO$eAW!x%uz$b)8`<x?qIvOlY(JI7^5nMp|Oz2Fqa9{Oair=1F?<(WYos`IiT1
znUwx3KnAIhzRHrH2zu{nhq3S0L6PTgu|2$h#7+QLcN|}o|5ZVR)TpQqZ~bR(WZhHe
zUsT!IHNh68YO_8Fmx@fDsaE`S3zQ$03LSxS8{8V&e`r6z9K6Wie4iqlq8-%~9va=-
z2@D-K?j2K#!A41rK(SWJ1Yb{<rb6%~30?^yNK)M8uqw-rhjtPw+1O<fdezV<R9g%)
zet;TT`%)1HHGPBOTY7eyS{n%>5$wh{@{9E{gDJW$a91r#bT_|C&CZbrlOW}c{|H<7
z(9?T?D18r`aNm7=)jNS8zL9~>0-JF_h3O;9DkYJ67jomY_4{;7R&{Pudpja1eSP_j
z#$t}{U6I5@dHdU`a8g$MdvDcY^Vx#MukL|i6yq5Z6e_;FXqUfrI)PI66J#KR80o8>
z+spH7EF-b2<ENdtIhr(vRWSU<`&dL+_F2Uf3+zT=$s+f+(5WD**2)yejO~z>Fu2;F
zqEyfrgm99lF0R_*hADKSzfJ9{F++ha8xw_2g|+%YbPrutbG-Ms5c6kr{NM_wV+Pf>
zD<(j^u<2B51j^N(mdGn|NW|-4Fj;;cKu(6Bo0v>M$Z60<a)Um!H=Lcw>v!neBueM}
z`Y_a<?yJB{D_TWk*zosLG_paO&Duw2iMhp<T19Al=l0;HtpJ48`Y@q6(P$`d@l^qX
z&tHWRE5QBeX|W|W62v<f3E*<oSAz&i=B3E|LyZ(XivbW9PdNKV8j}VDn2{quDtysp
zX&k$fpY@&U6i(wH2#b+JOr({<@r?_N>_doC?cw<&Qg%L&Y4jDO(+fsZI*$AWX5$6P
zZ!fFNtY-3^>UmFZx*qG|RS_Wxx_*M1lLr|QeFtB{#*ac0QC(5u=dohrZ4Gd+QAg<z
zpg~<@*W+}gYf8Vg<a2un$Kc@*qTTY95aES#yi8+)ii`kEpFFYAz6eCpVLt1*L!-ok
zEVROiy^{UscSKDM9@<I#4jh|&$b5Pa@oKaY14u@KjjtCw>Rd#$HYJP3e1|(@TJp||
zGew|YtM4fma8zpYl^Advv9zY4z6u(7#v6}z^IPh|6R*u5GDk(HHcd167?nv*()Y?V
z?AL|5F$fFe$6}=omJH*55o-5yMox|$UzcW!AO4j<w3FciRMn1)OYONm_J!z9$gpA=
zv(6nH$xzK4gZU;7&dG0;(JE$;32`l!IQYXb=C+nw0^MZ44s_?yYJV0udQ=EYir*1r
zFX5)2Y8yLz0xoNZ9^fFQx)Ja6vOhOa5BlX}<n!7z-qrNVymMR4qxo*5zcSv)sXV%@
zEPjOpa?qMUsT%(rAe#f*mI{kv75N#Yq(qnQn?YHtet^xl>u6;ajHs#YFn@iFBf!;w
z>Ol3u2m8gLP$bi8<Ey+k{vWMMg0_<4f*71|>g9xZ@l5q2LM)$JsPAgU_~}9Pgbbql
zsQn$x4pqIl0q+%g{E^bkRnm@@FFyL(4h@`1a~ziD>3%^twC6YR4T8>yb&d>m$GpKx
z=4KdAXNT%>+&Z?$b`lhBwWbAu@z0J3J?+j|wIX*{WCyj|;eFy4qKdu-?v&P#;?T9t
z1fxw+a&^0%jdKxSyc?QGQB4r9yFcm5Y8;mIVcjpRwm~hPahlW#;a53>k}|)~&v13d
zP5{^_iL8Ie@@e=PODDG8ciFDtyG-r*g4WoEwvuB0Gp^PNF_a78oAAEXmn<PYP56bu
z@*Y9^>z*Z#b={efL-$7Hl2Y}6Ls<O7ei9qu#8<_@zxEcuZ^(6=fPHeY`lm-~lmKZW
zD-;i_d4cyUjRC2SKOyrf07yX7Vxg`_*uwe}3?IO?4CeA86=ULB9BaF$G!&IFap2v{
z3n^UxrIG>UOP9o!q5wq*ckkeqO(Y)_As!S_X7<NA$}*ERd-<nCKfQLKA4$QG<oWlg
z4GNnu9>hDDrWv-9HAwk%1#go!K*d$km|yV{SJv2E?ytXHFT~}Qk{FBp0}|M|bhLtT
z&r%>v6f{gSSi>yjc7DZTz9vZ6RE`P8{F|y3;(-6ew;p!JT__?v*L>DrVzEBp-JG~+
zyRBR{4o%k1k~+?(aRHw{xVumrRKKg4kb4xA`1eX}=i8VKzLhLj6Ix?Pw`4>sU`on6
zlb>;!L+{?zW=l&NA;fTuMaZhdD0zUt0ydB6^4`aEQ?{uA{18H3;Z|~oI)n+gIWH-B
zp~6ft8Ur#cnasX%A!taVwL@c|1|F=ZOp~01AcKwfZGwluPI*+_UI|C>uX_u~H~@!J
zYod`Zi|{xA=x&J=Rn`d_UVZZ$&lJb<&Ys($UH|BLNBk!+Z)6Nr^rxfRw(s&8*A&9N
z%pQ7Lqmhib(Arx`AcRD4flySIBK^6Kgc(5fJHvuN(D2|*fL9z2go(&eINc_}J($_y
zLyj>VI#GDo&r8O-wqHi-zlQ?2035H@t|cY*r_+k?y8kXnx@p|v`3nF`EO3i-mD^1j
zfMyEGIC~0INJQDfqVk}aCIZtVL#>qwtCuzRwrWFJ?o))kh3UC{Q4=^mc6W^H)=lnH
zbpxRUfhnvW0QXiDjh`asCWPsv5is}@V`Qx?8Up#^{HneX3{vn1)m#_UDsUhuhE3lN
znU(DEB>tJJ6*v9TM>sHu8J_(hX4-ZB(Yc7=4}p&}mh$){jy)EkZdyhoedvc6c{EQ(
z!;)Nip%*HzdjEf1<-h!hiR7~$Iw25ki<5{@LA`iTO)EPo5c%rEQE0Nr1~V5$o=E}2
zjdasiMHFfM8v!JxC)S0bLn0yyD@U1L$<$hwVDxq>ZU#C{!~%?(svHgM9TkH8QF4ME
zPA{hp1IlPqA7g+q{4rV&H`j9&Sq07If3S56bRv9sy}ImCu34Eq=#+nX3$(N6ru{un
z?X)97ZAfW&Im!(=D!+hYVP)5i(QoH=TSF2OR}eWiEQ=<(OZ+IS@{zeNk%NT0ug=&%
z-5@|vpH{Xbrllr66{MewZ#46hXC>Bp&2I=64#>6<O)Ur=rSZ>K3+kgitX})}oT7<x
zgokn2VFqxczPz!K{i76|{`B6XCO%|5c3u)mms5cZ^T^|l-t(ZAW`*K|b%W^o*=yeY
zy7kaVx%c7QHI=)yhNTs4-mNqU14|2}1y(c#(x}W-c0O-RVuE@Ib7?<P8KFoz4|*I~
zc)m9-_)I1CJeX35SK!)Q#;~_D^gi|2ywB^q2miP|A|am|vgA9j{rOyGp|7jGcO42N
zcjTwvFNB`?qKzbeQ&}||DO9BNYP1E{5PJURC=B8oHqEyQj>qo7dk{{rSyVsf+}grh
z_oQmIe$^h$nNawJXs~9{Eckxi2l%_Pk#5_2bBu|mV>D{|%})At?3@@2Qt**5kW*>?
zHFzugr#Tx#a+FQiRL?b}-?tQhWL$bw60FmTF?A$i6uRhHC*@5Sv`zm%yv+1<WqCha
zi#_@g1yFZ=o&+=`Y1QjWG7!oHkQ8lrRFaG(0Fxd5P7Y<zf;#mXT!gnT<uJt`xsBAU
z-W1ZxjJ<N<&g5}aEcSYaVzaMvqA_n^tb7nkcgdX~H2T6z_meP{1OTcxkgJ*2-ms%m
z_Y5a&fXD|=REdLIr^Spb_bwugip?WRC9qv}ORPw!3S#={!M2n7#&G6Gx4PR2Qx;Qs
zLmI*1^Y4Vqw27_Fofx0P3npN?dFKQ)D(T_!@al~ZPz00I0iWxeO7YoP*RTGYHS@kI
zj^@NY1urU83v4=QWXN#B;i1jCZ^zT^lTZ8kzk=Re8fLH;esFQJb#t8jPb_jNg~Qq&
zhsJJe{>h9unuZv)S6Z*74PQ4Zc?+96FLuzvaI)tI1_Q}0m;h3a#QjhvpH?*G6xTuf
z;tg8bLPCRtz~avicyH*?%y{sEPw++sE+h~kO1i{3I-w^c9Hm9|(8P`-8swh%CFth%
zx^LOeuf|@il#i(8m!g;i)hF3R`{>{ANJ7(Jd{a(>f#$#H(K<3^nMZ~Q5hiW8ICVF+
zl@<2n;tX!}G4>QS2GMB0KJBOT_icm2Kd;8LHdkt85+6P8F#mKC(`yG3p{u_-_M3s#
zuH_m0Em>>s<s%&E{Rpg8Zt?NQ-l<}|7C9^>BBON!Ah0d7cn@yrTIQfJ-1ji~^u_8p
zITt9E23(47?CNDzXkk`_p)BzM-z8+k*s*f82?qIP!Pdp*n)<{Ed#6}1YZo3$&D%pZ
zl`zUg^M}c2*25>Empz>gfR~gUS##`THIj<YD{@}RF2nlq7y5%!TGfxsL|XIv#NtK9
z3a;VfU-r+`T2@AbcueIoT4k@OHhQatYSlluSDZaMlU}l(k|r7t6=ph7i^fSevr|>j
zqRYxCaTDKe-L7L=TU({pGHpnU?|Z|i8U930nIGugY1P!!<+3ue?XIuax60GT6cVSR
z*|4FhuTNWd(#OT5`oiUwflTC7GV&8w&H`<3w=kSP>(8mFLh-VkiUh92G?7_6|Mc7D
zsPAz?N48t64JxIO{HCc5F)OenAg>UZ=LzH&)3g%CEc&h_@$^cVu;P|pyH^9|pjZ=O
zjf{uRwV8t{(@$ijq3RhYC#g>q>2)O-z@x*uzrU<H+orz-W4@DW5@>(NCX`rca_Zp4
z6>PDgsD5L62t>?fwd>PXgf<+~LtJ+QlC6BR6Fh<#3sRlfQa*{)rX_3%j|?>p1n-v~
z=aK{qzq6@DmHr(-8=Rm(>~PS2yA*f$PQ65X_jdy_LVyGw7UyQ~0+>MwZ7t^^8*g9y
zm)aS*vI=~bK|)-JcK*8WZ?qI1pV2e^zR|?bme6Uc_NARh1-|@`=^;iRdX`#4-=CPH
zIwaxCeLU;kNmt|)Ri<5vOpE~3CfSe|j`hP*Kf~5(ctpEOUFb8`26F^!%w{q%zSHd3
zDwj(>boGk8`!UIn#$t!iB!Ia5`?}G?{Lp)0U5LZ&&;&kGyX99;>8DO?kG;M5c=B6S
zi9hc@-5zRSn;fMTdhIo4b2)kY;^k%zT6c#w=YaIMNzdmF*{G8NdA<!ONpxXt{$}Y3
zEqGQk9v++`glEKP@DF7-?l5EGR=qDzSsCPLKkO;Y&@R1a<TA_mUyFg*as5`_MYYX*
zk^~O>mT3u5HRA6n%<yCU^+?-UX7$pVTLNPOsy1jUuwvJ5JYHh>WRP&s__74c58M36
z=;u=#UCu-=GA7-Zhj`EOR*@t5f;?&+6qRsAieH^wp6{TmiIUZU|3G#!suw_1bG7Qu
zo5tSjoGZKM+l2nWyd|utGd{qdugys0KF}sJ_BpuCCkOr;*|~iZvyzC*Mjsb}b-nb8
zwUtw!mka&>UNY=fE$y~CGt#r@ph22Ywy+QcRBZ`}5Y}HA$A!|=CuU8a-KoV)R6=h@
z?WIC(DyQp=IxtY7+$;I2z@&_zw24t9-sHi_#6809pYsNs)@D}l>+(|Xd|8##kFdU$
z-@jcnm&7dJzgOQF;Je9}bDv-ta4VTJF_RTg%$SR6eCKQgfCOGRJ!udskfSw{_h!F^
zS6*heKiw0H(gE%{CpdErl+orHKAx7djQ62(ZNUcDXaZmITn51IXzO8@)GJ_{Td0im
z@BU^UYe#XE61Y`K!hZQ3;9b%207VB$O}ILaEb2yhQ(av|#mlcRJTDg_y-^R43P6Jr
z6=?#)V2jznQtXn`V-URld0BYc?`I7O5~Iw^VFy$>=_jqeovcd?7RV>1qQfaks15=p
z)+ZND;{SCNKrHDYTKuk)bjUX&Nr$qr?UhLie>XS8f6=O1MN+jy`6ZCH9;>+j%bpg<
zl}=gAcsluHA}UU}sVzu<@wEka<Hq0v>CQ}z_S>TZ`N*^QTEd{zh}vrTNRzM`K$fzs
zjsl3COG8i8YLeG)WdDnkAHlCzA_bQySLkHN0V=e28YH%Dd_TVq8WU+06Dh^)zirGI
zQ;Z`nb}0$7?1Ddrq}0sC8^<;KMA))%d^;8>XP<w5Sten54dNE`Lnq>D6_a6bu1}Md
z>O<F6M^Xq5-g?+uk6ExXynwp3KRL1WO6bq@8@g>8%UddJXjv46(IM&61M{Ae4d(CB
z1z*+Hd2ng^L=Q^S0=Cb4+ee$CjnJtkJ#zrF_a#ffbg{P-7pB>`gu&+TiLydxcg0nJ
z)yYeq8mp|R8(b#gI~M6XH)`%v3(CF{(T$&NwWCDzSfO-jKWsj*83y5CxariKQS$Qs
z`AvS&^UCfs?xi=*&rQ?q9W}FXU3&|))k`Mv+UYn+byBG0N?4W}Q=gDVxfB!N2`Zfj
zB~!G*=us9~DPrPrUKB2GUt+br{DZe#fj`TDt0EG}H~zD(pRqs&!;%n;8Fi{}Oq3I|
zRpa(1_jeIlm@FDb7TT?e7;`(7n!6%Vhmk$dHS%PRT%yMsDc{aI4>Zbc$j*wVG*;9#
zsKG6V*BYj?2B?pi<Lk{J;iCE=MHto3-D~gMllwxz*2X169&Anzc%tsHk_hOO67&gd
zr($t4a?KO}aoP6WGnSLVlDvC**OR3yf=4X%B&8fR1hx0mB5)?!?}DH>-QYu#TV0*<
z-eSPFlQ!EFQI-RD99vp4XGMypRTPy*L08C*xB}`~-^g18NV|Gy8A|BVvr&goSL|Dq
zyL1!((z#1XgWg-DS+HBf+^gOc5nw_SmclVc(>IRWX+O%th;lzOzI26-cnkSa5%`GD
z@IX&4z5P7XZ5kmA(D;dibH}w(2EoYJ^q3pAIMF8Iu09Rnkd<A$9a4E&LSZ`@{>kHo
zEz1E)Fd<zURZt1C2IA^tJ*Ho*d<{SGtZQ*>);T%3A8Kz5Ca6Yuvr>4_nG8PNHNpb{
zB^!;$oq1=oOWfxvC|j&P*r*0)dW8|A<K*Sk5B(4nb8_jQH4*{+%V_tA!@1DT>t;?o
zF*DDD#xiYc+9!h{CgtkGMIPROm0n<TBf{~)dFO!ja{D80Ke8+;>PYn1Z(dT6^(0?-
z*_`znH{BrME5V+u)anx1tunJar!Wd85r>eet(gZFgg>K7QU)!58n)1XIYtp}^(}<V
zUJckJ_W8vzt4H72#!7gN)CTuOR^L8YF66RcSI$43Om7`S!;+a1ks$WWjr-jnq9hJN
z*<xBG>d3*p{OM*AIqZ5;2;alu5}Wh;a@KQE<1P0iZon}MKq^{H=7E^u+QfGCBk$Im
zZ#zX1g#rmCBQjC@K9cta_@42o=OJNpuTi<xbTC7=aoT_muiin5E<vsIO*ORrK`j=}
zdENf_UM#B~=Xw7V9%nNA$LS&(8)QiG<A@{RpNri@sWamC?X7H{t0i<4(2|8qG+?j^
zaFqK{yVBBft=sn)l~*!Z%tTE5>GwNur<V0bOeEp056(gLz8l29mt1^v6!LPO-^Lq7
ztk&SeTv{8X@bequ4-y&cC09eq&!3g5KXmBcu@n1*V01JAt`hf?Q9-;pCb@kqFB2c#
zo~L|oZvl&nX{$8LV2iwqk_HDpt#aYpvDAY_ujBT^+pU*70bxVojG!!}GB-b|U4Cls
z!7QrS)~#l1HN&*?J>|6+9t&!~Vm=~dk=ZJI%xoKdU(cWMTn#9M9*NPt>Oy!D)vKOB
zN~kn0h$b6TnnAFV=k&L8djEo+0TAduDP|S}%o{wW15hJjRr5O6dDKSk)9$-N`louM
z!!@KLiP{X=DeaXAk>n?j#WN$Q^qQ*kG8b8RuZ{o>^0(@A9d<>9c^|(3aLru()rMAC
z&iJ=~ygg;qQcLr%P{pkX;Z9Pk`SmnGMdSt5&}fTTIeHf(&+?k9aJbTyV;P}MEQ_dj
zHv16`64l)}v=c0KP_jgCM*0AnUm3G}uy7}u&Zf**aZ|hFeM-ioV%(SYbHXml;mm<7
z%yGH4r0usz9?S8{v+T<eMjT5z0y7rXkk_`tRaEDCg+q#l&56ZJNUabdzt~u^7bSa6
z2y{$r#gzy#C<yE}-P_@UnFLCCRgvkhrGw2zM9Cn68SxEsJirydB)<GchUoMk()~}G
zvQ0h0g~<gGc}*fpd#>W1P1ntdYZ^A-lgaOoe9`ANWgLb<#>j#wh!f%MoYYPJQF&=g
zScMtMe(sqBv=ktp>KQUO`8So>c}Sm=G$6fVx8YSC{}MCF9GMwpspOT~Mo)%OZ(ASA
z=Apk@y~3YwHt{VmT{CxF%FzBX!>kXaejVC`XO|z^gQV{rXkMxcJUlwUa=$71mZr6P
z8>HveaOQo+>YPkE5RMDph|E#fs594NqL_zah0*)1pbY0ov)l5Kyil~aN-b~0SeA$|
zzDDdL$+B3yAdYvO^C6fc_e`xNPDrBzo}@_-u>|+43)9W|=bW0++foxx`2mA`F+=;f
zwcY1ep|%vTP3C8BTdE4+Jo4WKLrzcwjBXt~*t#>4zTwF<zoIX9U~*1%l#2FzVLV$@
z*bq(I5jJz>!0+I#GS4}yElJShp#!)IiZouDux6GF179u@{GHR9f1&oz2&{CgEW_G&
zJ2vfAbR+pl0F6sO;7#f3H?YQ%6{uCBJ3F*o8jxnhJL)qsq0TfQ@b-CH;M#_IjU9rm
zS@gy|(``2%)qva(<iH2aqv9s_@5dP%;uB47{Npl?4q|TP*d4i-3G~e37$##N^Ad@c
z$i%=z8ETHTtgGMY$g)ea5pIE*@kj264JNP6mC<F}nfG{U8a9x4%&wi70=&3FB-rdM
z@hthZ10!6>(I4FJda;U+!oLZaykV}t4V6=p5HgQM-$q4}&i-uk^(mD0a}2F#UAWUZ
z!Syh(F9TiP=BEcWL9a6;zFG7mKo?}z*%YTAf9`HKU;6c_Hd_l4DKep9HEu6otGjz^
z(GAOyY{Co=^reDM8LhmpD|;GICWRSPL^sM)^v~Wtl9f3YGI;ygy^0AESgj+0SPO@|
zv?leaq~ffZ?mX|Ow6snVOkMNOr)tbq?lCFH;B48Nny{>^rAw&)@%!U3PZN&^@mjZz
z8q_#@d8o*0A%riWWmCK5gBc)GV@D=q+gEvT4<*d6^l8`&;}Gj;q56|+f3RTEQ&{sW
zEY_`-?yL%(wb8q>96aItPq_&}5*zM?B*k=ts^)N<-^-~-@kh_cd`4_yGw@B0jJhMl
z8lase!nm2M$o-%7$Z!FvFtP?Aytm;4%OMA`PX>{wKHy4wBR;fNjh_n<x8+RanO`#4
z9r=A}(0yWL{Y{#Jf#zW3BQqDt1ovk0%T2SW_XgIq;S!X;<b_ULo(l%Mx2NQyr#0Qc
z@Y*_1f82O^M0XM~M0dM5f6ixFSN5dhfYnY6uF0Ih<d)zXqx=v!_nIOU;PyF_M2c#4
z^qI}4QyIYlk>)*XTe!)UQgKi5bk@*j=!%9`LRnuGBT=~OQr@)XJ)pR_<kBlw!&wLs
zZ97OK2Pq4lTst*l6=TPzOrR&nOl}mRLcHh|gQ%DrCSe(Qyt<W`k=t};m=bZ6#>nFG
z1Wi@UTMnrlu_^TFzR&>jw18~Gh<!dmgSJ%-AHF*~G}m4*3SU#SB_Ht%VUoF70~)LT
z%{SJQ-K3?e0;P8<fY8l7(U>o;QGU%}w`AO85Zq_Yvon6LAWDg0e~cz{93=9QM1|Fb
zS!<pHB9wtM>Y|ip^mI0kTz4iHjsO7Bbb1j+#0lyQag&?nQs9tg69$Ek12?ed(>KFt
z8$@yVXs`Bb=gaWY$E{AY7(+xU5Kjq%b8V?&v0;>sjYPx_OqYW;q@GsBw}>m0bJvM$
zwo<@#Q~MC(|BJG>j%xGUqD7Ms9D=(`f#U8GDB2>W&_b~yMT$#`OK>Q~N{dS<MOwVL
zJG8}uyIUyk4mZDZ-y84UJMOsWoWH(*@{Nq~?Y;Jzd#<_G#A4x9)(6ZgSVvX_FpgGM
zN|=KgE_!y4e#Cg?3`I@6W!yFn!&<WjDQT+dP;2lPJ_nvFkn9yv1U~`|<QW%65K1*B
zN5yF~*G?Ij&NRX5cD+;-tYvasJ<xpdNPq_Cd~`qzn8nl(Z)EUuyR~eWCaxTzV<vWL
z_jK3rb#q{?Lzp72dVvW2j`!XAp|5x2F^ZvucZr+8+X4{zW!W~NLtp-aedUh`&dkSD
zvF?#~n{I5TYNl?i^m5qlc@^W%Uti^h2IPnGcKmrI7iwSiK^DUx-K$(-7z;XFPd@$U
z4O^C3&yuI!G{1;z_}cfOKPB89IV88IYoW|~A`@Om8#OzI&(IXY@2L@=?ZX!M_d|Ml
zNs&<EzT@jfiKxOl*J5Z<vS3}RCxm99WCA&oY*nQQ$O5-G$VN7;vddRzk^{16u`Gy4
z!9=P@7T>V-WTG9s$}Hu+KtC+|1aN`!l)!FON1MlUscw*!??Ewd{|@~EHcqnu_Cl68
zp@%u7(84*_4ZIImPW~zUmhl~KASeUz_yiJDb~&SK^j0Ry@VbKPAx_g1<3asZ{bEbp
zbmTXmpKrd4=t;FJ)!DZ7MZ+_+hgcmjZc;Kjv{kQ#z0&^vcx4MG4W5zR`BF|+?^H9g
zE>=BaV}mVJON(P)<uas}bvcpAn5<1<P`+<2X4WmwSt};(%cCk$z-H#}FQjaqc@jK9
z=-A_NnVmd<R@gK|cf7d0&pR;#!%Wwwyed=vtU+$v;sOlVpXtJE;x3%enTQtU`WgT?
zsuA!zPucj40rEs9_rSO3mePN%qyj^><i=~gDsp(2u^6(+-kXi}-NkJ8j^FoK?TVzg
z46UK&<rGwp8JOT4!2`=7fSZSg6Z}+<9TF#Y-9Oex8*%W<v`0@gJ5OKrs$UC|ovq$U
zG#_$ly?r%RK{LE+pXiGtV^jGNh|&N;$3|uccWJHy*jH(81De8Om7Yzs727b9oan3s
z$%U-S5D<(V)4tm{8*yYm)QSW&%@8OAdzKFp5Cu7AdeD$7?K!RqZxy9kV%`wYJ{3vQ
zN}eI59VPW0haA885BoLH=OZ^JJK*kxSV~EW{_=MUZzrG~kdqb{$(v*Rf&np{X&jNZ
zKP*k^wFW%={xaaV1bMqfeB7H@RWb>e5@Ps0+bidJ#guo2*xw-F>&M9?CY}n)=M}?h
z#&Y*d*iH|}AY@o24k1pI8ZT{DVnTKnqyd)uUTURcjAqsnt}6q#fj+M`Q(@5|ZZuL0
zeXbG1?3*%ofvb@zSX?;y288@U5P8p%sM4+c%*!f|2SmmIdI^|y2SCZ>X@nPi>&%$R
zn<HO6*753>HYIBs&X=PokeW)}Zq$q%KXiw_Zxb^{HGik-U<D^OGQg$_f4l>=XM_#C
z2;0$ESK#|qER>e(;l0eBN}hfpSlSe;-Q*jW@i`dzJZD)m1L_tI*LBXic{YXo7V44n
zdqWJy{$AUgxQY5X1H!=p-9xgq4dCmgoivbC_cL`JR$0zw9^cEg%8h;g$w=H(i_V(-
z;y5ZOMNvl$kN~Joi5r19rG1~r^v`EO3&f4OJo2BRnxCqnl(U(2Nhx%RI{RB%0XPhY
zMSxS*W-@UCcNHuzq?obAAwD(}AqJ^0VWag}e)YhewKxiy?efEUrVq21=so#WvHr3=
zdIbY=*f0FetH)L(PqCDM5~g8ug7&^)N8WN9KF%z^Y?uADp8U}farDT1bZN}bnxt8*
zsQjpruI`;%5N%n;1^u{43yrA@jGl*(AkeMBmN?U!hzugP>6V05uW>6f1RxI}j)`&U
zaM@K%xyNgm=Xd@*2YxISX$95Rk+jiEWx5=)1tON73@io<-97HG1|ffQdrBFQ#|#N~
zIIP~J5=9;{>6uce-(3E^39^bccZ~~uH%Dy)ol_Z5wK*(SiM#6(6?X}Ujs=_g)5$fS
zEaFQlXg4MS5yijk^A5G{X=8!`i(dJHCC+PAJLmyVS-Oe`wSOzLrWV>shqCW5H|4N2
z(bu^Y8VqE!&AYCs2+E`V@MlpoMW*{Q>oIQg{PFOmkxH`XHm@OlU=EHY)%N+w@^gw8
zu*Lh&9g4;qn<8gkiMmStA4vo2@MB2Kith+Sf6|}?hY)&0kJ1Sn!6K>LdOujx%18O?
zqcib(<A$n^8VUpjHLcEzp$Fys-pg#rrXZ_Os0(A=P5?QD$Z0Jx@EuWLKrbG;5<TIN
zVOZ#KBE5xgT}mNs48|v@zFv?DnVyB5Pp(c6ze+IADO%X0%%n%E$S!-V&XaB_fDt^!
zJmBwDm#^SmPv}g4u^DEbF4wsTq7poIV;x}3Tg_JCXTQ99#R5%+X#;}%0qI*5I}#+g
z%UN|>f=+aupN!Np(<J5d$Id*@nDfE_8Mw85UxEIYuL#H}htxbLE9i9An6||`&M|Bc
z*Z`;1Svd#gRt^H8!{>&Kq1D-TET}R&+yXNAximda<1Tn%TWOCO$7y40Ks#@{`uUa#
z|CfF%PJ;pmKMX0*+E)&*ji9etzrXw!jbfQ4AglX>!(wl3fkmc(38c3c^fRl~-!We4
zPCgFzNXvIMcE@V_+W#QE_V~Q^$JhupqQXAyVWOmU#rECMNs1lZJ~g3)ZJc4lROg$4
zE9=|+wtI|z7v9mknf72!07v<iQtmZ<lrh-VWyz?A>Ap>2W#~-C?h74Ch~ekoUr(cZ
z8<}1{v%B?APK+$Q^df+E6%l{*PNPR0U?Nm}-3U7{_<{(q^3p%e?jQePuI?`g&t`_j
zJ0}m)*71;|a7<OAk&2=GAxe{59D91=31CD#9%m;I=isND7?y}BqZG~P4o)MPAj!Gk
z*B%@!{Jy6v$8zRBj<Q|VcNI9p!pH<w9G>@yBz38$xCup&;OIvRRl2PBKbwx-|H!cN
z;pt%`XJ%oJ`vo4S?+3Hpcu2^r(7(0CQqwuo7UaaRlpErkVp637wr{QtjL5>5<9aUQ
z?YnOo#CEsNq<z81vwWaY%^Ch7LOzDeGZ?EV@sCM5oaCLNQf{^zg{=H0!p?w4ou2mq
zRwk1WPREG+nixvG_P#n=SnYn5nD;y^kMXp=)s@&<t`VI1T5Qsa02;XsXhEa;yg)y~
zi2%^5HKJ5n*5l_~VX>pJq?gw=Z@+k+);Hfh$=TcE7X4)!@&v$XUXO?rh#*}u()Cxo
z6qET__4E7~x3sAq%jl`!Wmr!d3ymB-y#rubDi~R}kmEFhTD|w=xT_x=3NC%bl0$b0
zL&d5;P%uhk4f6*=IhR@d^99i2y(6u~;9R~B{kAD9qZ7Jj4>F|N3?(GId><U*sd2tX
z;cQ+irW9f#sE&rhb1XY&BgBtv_iY*8kbIu!G~uQ!m3qp#j21_$9cH|fW~(E;oVr*t
z7fXXiP@oR|lC}yBadcKw#=>T0+)P@|#U@E_qQ)v)+y{2Xe*=*3$zeiawt+D!Idmzd
zbapA?hiXGv2ZB)rDv3AE_amDrdo^JV`Afv`TJzQihAg<jOKeo^PfCnCQOgw-|I1Cx
z0l)3zg~vh(g~50%3+Hl)60}&7ugz=gEl?Y|pYNkf*SYVTzjUfr-fP~O+SYdM#+h^M
zc14P4Ym#(tcIPmQ0}X8yqp0Y($im7zeeI6T5MAP=L*oHv^g*a+^QxHd_fpNJ4ouU(
zod|DX%Fw~ghF0Iqi2wY+aNaITspNTU=?(~}`WR%kVAaNK!Uw|Af}F=_@b-jU-hCn)
zgD}v-GMwG-N7q}y%?d`6BP;_BtId5H&zlScgqF9(fm@>YX?v`gSajC~6@n|BE?cO;
z`Lg9dZFR1ZQ#W#yFYZ}D<|fN*Z{i7|#c_LaB-6L&>>S(E3rif+nFy;YKnBqe8FI!C
z{1p3W$k<~%07pb|JD}`BO2lqAN>tbqeQ*zaK04CjAQ2O3>g(mMy%3RI6d!Kll(T?r
z8fOmENWBsJyNx&4kTPK(+O@4XzJ-=Z+S*w$(Kh}$$alZ&+anP7AP~+y*NJ)^|CjgS
z%YWXs>e`7%kCmhHk`XK)uZXh6L^z4lDdi^kc7NB$t1;ROi#OXh<37CRI!p&4{g<_g
zhkGNNT}&iHm+tNrD(Yo*ir~wuQS|;6a^|9`cz{Hr&YRUpL^hn9h*h&!h7y?rh@}8x
zlK!D2;aFA6V^J>(ls7xUZ2sx5TL)q3mEm!?Y<sw~oo}rTQO#9FROC%+?7kd7QtUqg
zA-1IoDIcB!kzSZ&eX0pPcELT0fZ6S^e(T^td-j2ja+LWTKUHdDYY409xjk6Q*fE|l
zn5@HbzN>4V@1*B}6^NoLKZ;ohMS0;>@4i({c@L%)Ik>Tkl#@m`9fFJKoEl4hGL4Sj
z@`s*U^7wy)DSA4X$EXOh08q@Pc|71$uTO?;+L3ljD)A-|IQy`YIwqnNX2ctGBZmiz
z*3Q2v!fjMTm;aeGfarp+kzJAqz-t%Oxx#D{falo7{ii|FeTM#g43_S4WK>kwwFzOS
z&j^cbFQ}=Be99j^N9XemKi1$+<+xo%yYorArK?hT>av>_v-ll{KbT@L+yy5h#kFuV
zyqB@PVMcH_UHa$TRKn0c>qrsvoIT=~lu67<l%HDTKe$72d^CjgfeeTe^Urc%Tci$7
z1;NGZ7asu_dR%N@tAUV9{ucriaBYvT(?UA!e;?BD)F13$NGkUoT;11q9ifAJTwfs^
zwaW>6?6t}_#wYq==dx>0t3<d74p&k0(W@S?uYhld>j?HO_gkB&<O^aU(gNDm55E9T
z`&_a+GW#F_dB4oRQrf?L(?pb}e=#Qo<Eg9Ei9B#g-D5Umkb*AF)yB*BL4t~{#BqVp
zVO3SY=_wG9#Z&QSFQq~U&^Wz~=xs0HU_puB=%yr%+(=m_)^@<5$ar-9RcLR#{mr7H
zcvhEf)BAPuMu^U!)sRcCj^iWP_Wb>nF-?h$Dx9xGJJo+olI&znfoeDEwb;OiQOj4K
z`NQfiamp1;PDTy}pVBm3ir1zct=fE#{4|McY>tJdYlB2EsCTUW?*_%452zBq7Sveb
zy>|p$3s(61gfL46Z=A_Y7d$yr@W^V~iiWRs@Y0aPd890THG^Qr?Q)R*CXin!ws6?p
z_5aqKP#HVR-9N`9WyYDI;|tBiKE~4SztNCev1JP#)by_*fqM!wdxXTzK2zlJ2TzH`
z%66R5-?x71^-WHDS09tuc5`>#uk+sk2vy8LO~9<izJtB}(=Qgbwvodw+nt>M^sO(e
z=`QO7kX8xjEW?*f++p71Jg%)r?$w!HfIV-9Bk6B4MIDx53kTgZF)qtVOAlE1&pf#8
zWIZM1o9|C<O##EE(%)*g`Dg9KU#4t8f(|^lN4XK?lUlN=l<yYagR^_O-eK^a589BG
zQ1+WP1svVQm|%hI5%_=q{=vFGTng$eb*R&|y55EW)q&OuzmLD|9kE-t2t$w;^d)w-
zjq{_r1}>r`sx=*()m>}vJ5<qAw8+<=#RPo&z}*pN*&6jU_F#M2Z(!i?V)yLzqB`LE
z^|%b-+y@T>>}S6s+cQKC1;v`Xo>D<O+T<*0s&`Pyqg?yem3~!G?geL>+DY-#6IQLC
z0H;>qPjA|k(alWPBeB-*u>h2MH+rk-6dFpml$WuosEzW9u#KZurN7br{JkA1(+GzT
zKQ;WRi4czYlHsRr-4FYSY4)XCNq!idytUZHZt7&3$s|n!wPquB8W$|qkco$^jJwA_
z{&LDuzh@J73L7Y;&@Cs$D@Q&SuZ!dXTPIxv|0IRi{vQ<(u^KUptAN~vc2@q(J1NU^
z;C#by;-AvB{%#AvY;a6OMiCkOel3fyWCQ2Iy}t_pa|{GS+j3=b;Msj@;0QJjEZV&{
ziqcGdl+k0WM9F;@nSxzFhM^`3(OI^N79XbRz~R5~0eK@rp_nXoZFA8ZQB-5{szr0L
z6@nrfZ9Py~8>e5NdDN+R)CHM^`>*UOC)9T2K}PdA6+ynusV0Vqyc%38nAA9)%B@fS
z#}Lb|0h-QbX9ml#)ffW1OIWco_D(IHgaZ)(wV@#qC}9gPUg|9U!tPlmwmxz0eVBWS
z(q4E+`qlZp{?=}An#Z;QDg1oJ3N!(Nm(9}vkp>^+*uxhtlXzDdwMn+823$|FyS9F^
zDWT+1)vWF3wKU!jGge6JmOsnU^q!-SO5WQ48dn8eCtYhQXuMpP{%`2dYLEg4V9!;O
zI97Gy$%no*e^q0jkx0(|6m*7!kb7?f?cC_C$S*bE#z)?U1g@&md(xr&nE^?F(;yPK
zSti>w4}A*JXP;iGN+O`lg)hi+zeoY3P106p1QT|sMWO{ab57F5q;N{t?|`q$Xp)YX
zK8LU~tN$%4z=;Fk^y&>E7Dlce=%>Hf2ZMVQtTFUjAqRu_jEeYlmO*-E1bDqUVO;d~
zDQX;D%RrRna#mQJ>vZhAH}BLs4Sn2_l+pBSi>HXxEZ1T`k1CcCFZWTE769oiNe`<b
z-z&3Kcy1IX{ez1H-6-%E7P^m^+5b8Gk-mFE{th*oGgpW1>2rRO{ajH2fK)6ny68p8
zJC6xsUg!12DrW2-<dfscyxyJXLS)K61{jU&VW68(m=uL%fZSFAOoIdq0uq0VD4CKn
zv%YUq5Sr@eF>1ET07V#Rb_kA(cDHo7Ad(ykEKrzIDW}(s{bTe91+}_DSGZ@-&<Jo=
zt!|qCvppr9!2z>|+6!QKEu^g2H-l&rDLjVT;KuQbm!d{?-((K@Y1u6HB-Nm&a(pX#
zWw&#f7=NhCwxVNjSu({9Fjx`uw57u*0_(#FW}Y^FaY3+Rc{pj6+W6ncupf1m&j8oP
zAY}B@HFZEgI)^#wk#h{|R1#-*3lxe~z*g&h&m2k~U661N82ijOZ>wMEG9Y4~rQ!}R
zQ*Cv+^7!m7Ueg=@b}Es;<`VSYRg77b#?8n9zyzb-5W^?M&krwlrt|@g-#~R>1O=5+
z@FNr13l_^-`OJplgaJH2V_Y+T#NoJ$(1FK_Q$M#+KH=@vITix~A3LsRwXryIt|=-l
zd}(B5CM18wi)*V7f;5s&(_y2`?uy(>As+QutiLkYWtTWI{T@1ApQliCJbWS&PGeJz
zB{uy6iey2Tho1<Fn~St}@PD;_o?Y)k5>VPM|G8Xjn`;Ofmi+6v(scF^l5pr*I8XKS
zS=3=WLt2mJuZWx*W9o5-%Uf04mpvbQJjQSgBLpASC1_e7)#+n2b?&Ffz$>(}HKZlb
z`U&&eY&56Xy3m>B4fOkX&!b?`hJ2k_A!ukG3_-SKjdjhI$-b1b&%Yf01@y&@0pc%K
zq6edH9w|tOgoV=C%Pbj`hJGZgv;#1iWp{rI_c$*V+vO0xl&N~TJ3-W3A|()P*`dr1
z_d)^WtpB-@7oNCd<s3*<n98M2&A*4E<(A|u7>X_+q%jQMs?@hL-UYA&4dX3j6E^Eq
zr&9}d`l%*mBSa1!FF@#;J+U+mwOpxdDp1p&1kJn#xEc7!EaIS_<Iu(q0vg9TrjtOc
zk|zKE0{0&B;@zeKs>2Hk%*qW)o#k`X@<zOqfAl-$gI)w%ak+8>P)vV|i--)=9_|mf
z$L`OWvF(lyJ)ww>w`>3g*Ol9RiNmHPGLz@%fidQP3m3M$WmYzMO|tvHaF5k&CH7N2
z=USh*cn|zR96>4g9sUh_HF9Y9Z@XW+Ee^3U=1(!&g2$UgOeQ;5R;-7XHLsW5rN@KE
zw$N?HC&GM<vCbpXA!DFw@AGid?`N-#7up~04ir{<FTe;~vKl4;G(Oj@a?maLrjAZA
zb<GlT5o$07yiPFs!Itp~bLI?WUr1NoqbT`>xw`N7g|8CsuFjq+VJtU;cmGTBw7BNq
zpO-;24Mfe7`ll!V^wAFM4JL6t%e2BfeI=qdAcMn|_VU6u%M-RQSE7p1I7wvmzIvP9
zXs`}<Jsz4GS^8k9VEY{Y8z)rnqYnY)wggK1Hv%qgdMdLvvSuMhEyeVg4=Z(n11pVS
zgbg)j^;|J>&Rsn@1`SN~py<w>Wb}URB9VIrn2p5*A(;U!p6?l=^?@&ylJ`Q#Ol@=V
ze+KDdB8GJ!xD}M+XP+M1Xh~Kt=3RJRx7DOdGP$ZPyK9bJ`7r7ZVGK89Ja2q7zZg%3
zSLbS?fE_;pPyN|-rG!=Y^U=3{mDAbruPPU2jpvipu3iV~KEeRl7;(g6AW2ms&8__i
z<^^-?V8$CuwuaaVoA~zQBOCD#lTQGdL!DrRf;?5I!IQqjFT*%cvg}d?didmP4vV9E
z0{mR&KpH2g4&a(;s@zhn2f+k{l1+!NK4Gs9>!%8g&@iT&94J)(HihnlOw|2)s2ms@
z4ktQjxELvST06<8bK^`>$x`ydRlu+rnn<be-<(RlNEKXY3Gv^D{Hrl1@kGXndISkt
zlncVu^`J}dE{rOaIE>fKLhM?B{IZRw&_?F8?-}ja@50dj2WbkgY!Gg<xbrf+IFco<
zC)e*Jj%Q_<i3b&CKX2n@{iaOhdR3`sKSq%b%qmH;tnFG)Z&w-*e=|&0!U%Iaqr`Z;
zttEe>N=zAkq2Am#9k+EDkRNjjM3oB7BC1p>1h;z*hGte6CoAvoq$kfk4BrtX1mXM&
z)W;$mrfOjeQL$;f+@tfX$I>wvs-GtTv=o7m3N^_%jax^NJLqK31m9m1>nq1L7XhNY
z_=hbb%&Vj-gC&6|oi(*~n=A}&uDeNc#dp~`G7i%u2-pu5!CQ07<IjNVuM;9;AEVbI
zFvb))Sqa9;_fYJIjuV21$wM;}Mhuuk;Xkb#qo<6Ei0#V1KbHyh#+8>qvkMA<xjr?{
zH|Pldj|Vmp{Oc4Dl%gOmFa!&5U2-@4Gw?|v4pfK-4<xR*<rS7Kk_85Q1lk!OV?EFt
zLl=meY0@6msTxkSI)-W~F4{%uj}SJVz1rqBQc8Xt<^c=or@|{b1bQUx51WF*Ei;7d
zcms8V6s8;SpfO8VG1oG=V4wsYE}LNqr6g|ebu%dNy#2uT+Dk%DZmz`3^y?WcF7TC_
zgKiEQ_oV?~F^3;J8)eZIOj^u|(3cYQp;F}(fB<FT(hgAQ1V+XfZh4<-idkb29ZtQ-
zhELA^=-E>ml>+ASNm@HxTQ@UFKQQ?(&Ss<v2q~by$W-d8((hpi)<kvJe}#y|FG^%>
zN4DrzsOAh6cTp{jFq+a`mFh2ldHzqJI;(~b;yWCE#DfZi-@rVFEbh_)h%~|#;^`6)
zauG8O=V>uoGk=Nh2Q?zZSV7I(*Y=oS+=9n4FIv`q3raqU4I=(FNMr&#d!Xs`WGHAf
z(B<1(eiKc4o+@Pty{w)(7<uFiZ%v(FsLCV&EFgVzQz->iw$_M-2GE5&8h+0<Mb@ft
z<FI#QuyV>7kqFq`6f(`Qdz<<*BtAb<I(L9Ee&g_~ooRC!F6YK;f7d_~#Q=(p(l!f;
zn&=GJiy`8HjfrPjela)jN<1SEu<DeK5Yva%DLo9sMh%mOBfiNOxa_!d;^f$;s?wJc
z$%jJ?&r$^?a<%RS&R?MSF0&L)yDHq5pSm}ajE{QO&7|Q>ZgNcHn@oTxj)KGc;Kb0=
zv<soFQD)>V<@W(<_@>Z^#q5D`d&9<s;NCb3vi`#hi<rH>5`4!tj`Fq^mILf*>}n$t
z;&)-msg(u8y98iEI)ZPq90GxcjcT_;@W-Jz&DC8y)og$B$!h1&{*;nfWXU$hFq%{Y
z7J}wJzpxCYc<!xlyl#j(sMWbe1PxW7&mw-CZse)+mor9IQjxs59~OJF9Ft@!j-$E8
z^^GwqBWW`N{;6@J+m~7jovO7LlMseP{Q5)}))CZKwrk7-6;<F@))>r%VjA^Xk`7Jq
ztqSkB-Gf<8X8h0%iG@@Rb~4+~{pSWl;RJuU1Zxz9!jsNcdj1}>3f91T5QGO!_9%l7
zmpifSuU=%vcq|O%X4H=)OFKJ5nb-TS@bOd6P$Z>~bpO~KZD`|WsMvr>Z;-EPKJVme
z%Qrtn#4iVuT}_BN;@R5T)Tqab=*d0;phaRW6XAk$`?3oaoN}+GwRWF8=^S>#syS*E
z)q6Xcu0(OuT+SsbT~x`JogkvXn|N#bU#OA4>n-=8M=ULL^y6t@nz3POQvmK<7y9b=
zT8Q$PTJJ;KXn-RiQZ!wG54gU~uew}sLjhU@`(v|P{ecm+a|{&Ti*s{otZA&5ntis?
zc{O1k0&P3Q`g_M6{^e?3qQH_LP!=ZW39ufJi|!uzlaE6tevh;KI*){C^C}@HkyRQr
zp7nC)|D6R8BV8aqb>sz<q*JD~QjJgD9@=!5A}R1QWv5qyv1&%z6*k6B-@i_-nb4X5
zUSE6FJ=dmU0zu<16vMBIeF=!Bzh7$eD)>KidFHt=-XHKB00P#LDvkDpKq`g~vb^7*
zj0GT--lOSKRl{mcpQS>4fwAbRV(ZVSeZw-+dY6k4DS&z$`NjMqy71qi;qw#o=&in_
zc+nQSPS;V|WyRC)Tf7e><$u9P+mU}F_ml$pDZKaoMQdl6ICyrU(l`NoJ#>1R7u6r8
zTPq{p3Kw>M!j7m6yJ@ZfCre?wTS(1^7nrqYInb$-{wl#0JQ`{8dDlvz=tQf6ALBvW
z`b!OLU0QF~9QsNuc(|6Q$Sx%H%{8$_Kk-l}71z4NkydTAWbnv}Vsc{F@&OTcAUbz5
zP;wbDf$n`m+ERp`RESS6sOHtj7)Q(PCO_p$fbDU?ZY6}7KgK;cH%fa+!)VKpKB<tJ
z3*Ha08?l+6m!#0LvB4)O_XnkP=-C&28n>aO>oEDIP!d@=tPZgV;_6!bRD7+Ksm^HH
z*N)|Z;b-IguN>s`#R8{II=}nk9t`#oPf{S`9t5&}7`z1dw(YTY`BIMMQU|uKhep2F
zEDMS)9fvp@%yJQ$3Qi9ZpPKdh#l*ls&K)Lq5)6R`st{y27J5{GW8CYI4kpV*rtXY5
zVb~t~<l4^kko8Oi=&AM1j#K7|%*xLj3l^^8^77ml{Z>u0Pp*21k<Hj6KVIAQmLVzK
zmMnz3emjZ=5_Q<ozHJgC1kG9dw<UI&wFc8};V{Go?^&pb?)EjgXtQkAbSM`s^oopX
zr|b}jtlh5tm4Ah+wME@7vFWc-=^=w3qR2FqlhK(u73Ny_(WVl<(<J-q?@Q*axkpd=
z_Jem{k@-8biMBwV{+9g!6B=^opO@w0>~>$2mEq?6<xYF?S%kS{P~AW23=t$Y?pMPH
zI<X%5P9(q)iM{`eKABb9pM1Nc-MqWJd~Z$rXBfH0U866Nm!QsSM4q2EUnZjf2i0aJ
zwfpkdQe3Ulj}AMJ9oOw)EgVHo?(Iy`r0rW5EQ=QtJoSMA7+&Z2)2qw|v`N2oaG^V>
zZl|NLqBe#U3}5flfb~CO>pt>tAA-&oPo8~R)4cHe<L5G)vCSA0%!w1S?oL=UYCpW_
z5r0aAY8y2On2=y#VA#vAZ)8n2S<LSsWegRP+iRNre9`)Jm~KYO2`Seq6q+Uh&n|gN
zMsuZX^Y-n=LBQ8V#V_wi_s>T5M@KS-i%jJ+eoD92C0fThl;pewzJyXd$3&yo|NFyx
z5swRS*Gw^Ss~?=A7d%A@PsSReI%g3|lLaFlutCUv%IS+R;%Y+qDLO*^ZbgR&Kt_h~
z^unB4rJ-t)Hu6a;dCHmNFCQ+5|8a<qxm0Z06$pAVELn_~z=enbA}~WJ(d8)zFak5o
za|COccTE;UmFz>DtM}h%UWTCp4nYZtXRgdoaHKz&3#uEYYnKnK{Z7K*xp;L{9CR<%
zdVNZ#j|24@c7-RW+)_fXT)9WvlX=6SpFi<RLYMm^T{w4IodMPKRT^QI^kM4$xj2?!
zgcWQ#2J;Tb*GHcCf!Y&S-T)Qxx^RqTxCU$C;BCFVTWD+4H^8Y%(GQ;=pdal!MQ{+3
zsQi7Q1fJJh%Gc+%&L+{UVH|iD2W)L`+7<KSIavCH4ifLxX^-AX-xqYH#!n*4H{5PA
z_;xpNwT@p&dS5yRLZ9U`ZK;a7;Z~&tMqfoyrQ8ImmNv&MZAyOp6ohrKcuV~H4b@s{
zJnntjYK%S8jb)y{EXg-mBhKh`h&mQdmG9kdB#B+@uw~%A>Dy3nY{r|>2`{=g<moU=
z=c+E%DYP@xnrbZK8~%b2Lo8?cYFC{?w`Kxc=<Y4P`_08+p;AgkS&f2$Io9H(TD`1T
zXpkW-EAsbB((wJqrY5P~Dz<5QKSOS5+`dgAnF~froO`oaf@QjKoWA|s=_0cGZ)5_p
zyAP_%7#%D3l-z?L=dtg#P}dV>RxU#6$Ax<R^=@YvyzZwTqdPc!OEF5wcR1RB3`uk_
zM){%%q`CQ5<}xcU5M+sT^JmQEc8!YW)eUOXCD(AV&%Pxd%{>HkSZn5Qxq8^p;;J#W
zEW|SbkaT=ZX$v%()|5w#ic{a2mw(J#0M>!8aG?fjEcKzVdhNlr-d$dXSh~Y0g`Vp&
zLg*Bs<6lBemP~Sn&7(zq>UTQWgMT4^2w-zoOJ!o8<lAxty{T8s3HB9nLr1B88MxOQ
z(;>VYvvs0QZd<9T?6FYcO5jO7Ax-6lR2<~{hMDe#GvV_ePLq5D2!ct|h+z(iCA7o3
z9!%=|WPbJit{qi{s@Kkg?+(C=2;~~EDlI2Fyylj@by6=%(iQs)ZQBu9HbX&98}{ej
zkt_nEI;8`_(iSOLn{+ncJv1xtiFVX=q)Q*~HxU@H&A#Fl$tl*wYKK5hSZ;Z?4B{bc
z&Sn^`NAUe63jM!Y{(8I2OVYSdzYxdJ7iecv?PV%_{|MN5Ma%1U#^D}}kZUch21rwh
z2v!TF5k|Ekmd3qc@Y(m*yhmv#YI^dZV}j(36a8Rm23P}RW#?@KWQK)`BTH*s(g?{}
zhug;FO3ngoD0QT!=sy|w(!R=@RjH7gYvoH+BjZ)Up*`{icrJbZ!KRMr-c2MZC{ufu
zAhn((zw4?#)Fe@Rfx>LgQH{>uCV_8w@mf**TJb+QRnP}dFw-~C5;_-qo-EYl9GKzu
zMGM)tE!9aX{)DHaPo-r`ipyXCa##(FUr*sxW(7FCfx+)N`+>9em)W}%uEi7R@fh7h
z+K>x_smeMpxNoSy3GT<Johr9LaXk=4FJ@!Bd{!-1SPtLe%xuo?94IvYTp;%At%ff^
zk<62F%Qk1K|2wvPU~S=Q7$qJinq?J|(@F?qj*wJR%LA*`FD5;5Si*wew*|!tD4<8V
z8lcMn+Dh2AGQG1N@o|dhkC%2IdD4`KX%E#XqN>_aQ<QMZ4b&xSHFgy3!;Gnf6F~-E
zWK-`B1*aHN!CL5Gf5FzruvRuneGdQ5+(iM_$AAEmANJWl;M|AO+z7yFm&1bM^w^39
ztC&zQ&lFX{$HPFwS>@8yzD={(p?rF|P-Yjd#GX@7idt3_tghalXlYTvGDo{IM6gvl
zK4~-_pY@Ab?}UQ_r?;$X^Q8+x?Ob2ZGhE5Ms!LqOF)+)Y&V?n53`j3eR<2vWd|CBa
z(pRgamjlG8J9GY+8N*b@dRWI9n1rBb*(xE+>v<1C$KXxlvL}|7=lUPC41U1>z}S&8
zqv)fsx~41-fDiuTqaEoJW@V(DRP3Y9(J}fC_M!F`_(yoBSi}<=vGBX}YyLms#xUxk
z6>-x*{46~PasVH^8k$S<?dJh)!sQ^Z=?9EV0k%?NXNC*UgnpN0fntYgt`tI(S+7G`
zkDf$LUh{WHPP_#osTYLbMRV88u=$iqo$jSjt@N7wY=UL&Sq}z|2j$e*D8k%;G&OeN
z!R4-u)V#U<7vnKu@d}O=yPGb`Ozskjb`SI+aU7pobSgbuFVKTqK!~2R>9zc_N}2&3
zUJH)IUS(uVR6JWq1rzG?qUb`g8a?o>p!tG+T}9FjsSJ2oB7;qzD0pt|eE>_&U=^-f
z-pWbTQvVjQw8u@>cuJp<%Q=!o-_g`-w9kt*UDIm+*xDp#a5?lN(YBD9z|2y6R%yVk
zO=-l<Mp=Vue3{<NkOgAhT=MBJ>0lla+`o$EOK9K85U4dpV|x5s(Jc9k87K4d=e;d8
zvbEj|DY1FgU*aQOPmcTx_WZrwrRukYf?R0{a6nT(z)2UCzuTi-P=G9#955owSz#Ww
zl>M9I=>7{YWtz^kVv5_V80K!YbCBs|&vhVf&;Utq+3T&s{<Tm}VpZ`k-CumNjWt5n
z<T-!ID5$@PKx@cfWZx)ot<5!Ka^f@HK~oCB2nK$v;hzM7@%XyE^!0|b;^kTV3)yqy
z?|wOiHjRA4D*~anFXG=l+IhaWU*JL`yDZYxwT|V|>BMM-qZ9KhLP1X)UZ4+xn3qr>
z3jJp{$E&G?FN2>*x;X8bhn5XHIM8t=bAMcAK5WO*WVQ{?l3@rzX7Qs7A4oR9;KnK*
zpT?yP9Zddh)}TLr#O6%^hU%QF=o^zU;H+)CZ9JwDndA9QOBe^Qmz|p*<+N0W#@e5a
zM~zp5mBE9g$+2#7Iq&QSA&ghULV$D#^34Z~Y9OKsOyt<Nm6Vo=$)97=b?tfj)pR*5
z?=%z}F?OOpLg*s?+jkW?-Bg?bPV&}c`+VH|@ya9{p!h+O^@!c{>;>#<vtl6(VG922
z8y5PZhgIBbJ6%0ecH~NZhb=2-BMHq|e$93+{^yIeCxY;xOz+$_IkDf#h2)RCr4)Jg
z40cY)ykBCajyyy#Yq##wk<b!`v8mgx9ZE@~sHSj8HY;nVlp98x5^k2$tnbWhi~ulJ
z`PgUp61dZl<;VVi+6%e&YhD~G3wt{}jv)rl-PO2M=m=iJ?}%1B;tLNzNEXFNLPvl9
z7VMn9RX_keyo>}MM<Sckb+$pLe&g%9uArFP96A>!f5K24v~y~0SU{J`0=QZGP11bF
z>b%qxyJrcsK6jEihkW$#piUGtwdX{&4_s$kCm3WZ2FP!_#7XbUczlkb&B`O%XX!I9
z*E)Cm0V|W^X^_Q@ORo%zX7BIQ)h);yn0r!Z9#Xev7Khm7kT*8&D<Fhs<Z-$(q(g=M
zFvh@@<?N_G&km;*r|YLI6v`@f4AW6|t`P0c>HF&~SX99i&qV%KCw$m@KQh>jY3Ex@
zN`q}9c@hZms?D(Xv{LySR>!|@P2VoBA9Y7w7`n_|vKugS%}LAZ<WsV9%f=d7l8{Be
z<0ZY<iVVT2j28%;`RKXkp~6tAjhX+4zxMcIyWT`8I__6w@0_j1vC`HRu23JRZ3Wcz
za<7`{w@_C1MO~%a^G;izMj?seGBw<Lw)f7Udz*q$@OfTp3>L~rJ9gfLeOY*Ai!!Ij
zK9(DU(cW-S2q$4nHR-v_lKcVFr}%h4m6ho7$?J@`h26S?%}P^e^A`E#t22OH?P(Ip
zYZEh(#-UM1N{=+I0wwuw@9c!%y-`D}S$`PCai9;|)PO+?6GKCZPRBxy0^w8*mC9d$
z-fAfb<)_2<DSgkmUsk5gN!%>Gi$_WlR?9TcD+G!5cOMSbh`z`Mre|dIZr__(MX?S8
zwf>X%{huMuNpUF;L{Z0PQ`*gM<TqHS9k6cPB|(v<am+t7&^e#~RWKC@+9na;;fVHx
zBx~!7I}ufP2&yxvRD6ANlUJyQD7`e%z}Uj~xU__*-A?KOkUs-j77;rlS*_x=sM}^$
zt~@wLWRSCmy0e?_zU!=g?Vwj>4HdN!Vk=S7$<0p+7My0vPcu6Ejy^jplUCyrVmz7n
z-kNS_c-Aa#;&GX`wu4MG{gK<{78DM#WoZk}Y=OPS$HEBH=uBn3ZEoge7L9zC{p%Rh
zA2s5hCN=~@^hZLFwiw9xq06^}GfQ!QrviO~^xu3cEV=k818tI`_knk1-~;4REEhca
zvEa$MeOdgF*GzG2=z&kWzo|z_1Xwa4xq?b6V8m42Q?LWIit?WJ3SE5JSGAH{z$qJe
zwC7)+SGE8h=?YJ|fY?%hF&Ffnz$Uat72k7{DT<=le%d!+#PIBU&v)5DnH!CI6`kXm
zEeJOz;X^$zuYhs>z~}uvL}|<=eetebctk5kw&j}j$@?`J0^Pade_Bh`=*==-o~y_(
zvpLUu>(Fy#z0CqY#*ml(i#45tDBk~VHWgiS6%PMv2)e{66Ss#w;SiKg)_okZYpc5A
z@nXw4x+4Ir>z9`Y7nq6X{Bzq97Cqy|;Dt*{wzz>If0qz{rt>XZjsR)(rkCn#v0(qY
zO+wCTY`(b_jgU%2)ZfEY>PHJ~%YV>7HDJB!Q<nyx$tR-zzV<c%2F60KR(i`<lA8_F
zM$Ue9zHu$&T%wfk`S%5REXt=o-v#Q9@Fslg4>}MrEIB5<WdQojE&9(R`7*E?H9pi=
z9*y&zul-d^{r7e4b1?N}UKEB_q2+!|F<~!xh~L@Q4qt~8*}boWTcKU_^_th`1oo%u
z^1D<0b^-%^T2Yf4hF+ReYe!K&BTlbtT}T@DNI{f^%Uzc0x@JGtKR2FY6Tfw}$*ib|
z^d*qy6TK?YXW?Cvs#|8w9s@gLePaxOT@=Jr8e|8pzeupfP(qFhP+)ICLNzmB;>kN^
zKV|<uWaq@&*&kal9+ym7RM^LCdBto^y}N&HKU%FOE1~2V8sa~BT;(iV@|IudOn6m_
zrSGNX%~&8nu-_9_Ek5ip>B%AmVGN6zsu=$+`T7~$amV%H>+jIPjptgQcES!NLe1B9
zFK+6c+9p=TMkIohn@>f*|3|6zpHR(w0iBl7=qo&q`)zrwtsUM)7WKlgwNPWkj$A}U
zWc~a$f{Fa{H58@26)ZMB_O^KLpJZgkg@&MHAY_Xf5n%|~&5cjV=#fu=71<m(mxlsE
zr5&YcW{wYDa6WqEoi}(Ohani#UqvY0KfY(v^*GL%UV8SnL24tXopJR3ctNIat>38?
zcz~QJ?vt3qXj~w?{A98@CvdkB-W(|~+Jh;ro>C96puFNGu5NbJ;aCgHv2}armK}uu
z>+K7ZNd8X$;D^K0TYz0~<3?&6)Yf6RoD{Hk9KI4`L$dMwn9Plpw}s=W%uUhD4Dfry
zph>y2l}`$e-`fR*KZ<owm$xg1#j(OPKB|RAVN06GwU9T(l5#iu?C-w9ef*vr9+;ZF
z#T%ncEh;GHl)S&csfp;4D*o&EFB&9U1Bi)W(vj!v&@U7Sapet;jus_t9*)4#`!p9G
zW4@1=Q!dt3{&LZFcgMY8?xXNIaJ*{Ki>chZG5O!ap#K#q{WD_1?eO&nFUm_tjFDkH
zD0Zk~x=q1HjOx^bYCD@e2vT50BUi=u5ry{(pgPzp)+-tFw|w*;aj4&-xVSe@LWQf~
zak*x`q8}}`-AtKDnfb=Ov^b8ui}N1hIdA32SA4n$u($K*+3U=l9!w*+-Ha-&hJXe7
zL!XcIXv*Jghftn|23a+x$D$-9Sc&Dt%WOaj@v4x{VFXzk*;#T-nGIrYKJ|+9CuQWe
zc058XvNQRM_uEyxy#lhd_F)zpei`LDF=-`i>p!ZVtQo!5(uxB70~Vg1v?F%wvNMpa
z9872m+MDCiH?6N}H?pM<KJcoRyfNNS>#W<So|7g`lO-Fg06F>-!vNW#iX6f5F_rmg
zABBVOZZ-uxc`46d2|}k78Y#~IYMthnc`t7f9Nta$xQ^0{sMPhEOGYTmMsq1H2u3cR
zH>kQ2W`yMw!-5JhL?idhs=b|&jYF9`@hy>k#%SdPlMbipvw!ZS!D^4udpwU^+Qb<I
zryk$P-T4k5CRi2*TJI`Leq`fku-*pD*|w*hwp_#D6ducC0dalv8D$0k4&MH+>x#b4
z;c+n!WPe-Jqw|)R3wQ-E%FM&;{Or$5*-jg-FaQ4_-sLY?2&Zkw_H$7HLyqR^ULOq3
zNFbT%))bqSCFg&3##d76!kQ!CF6p9F7M3ta-)oeaYm7Edt}@BNRHyW^VT$B|U@pM;
zPF=m-C0JRgSQT9vAHZ;q+g;Av-S=e497vH>!MV}<#2k)af1!DM>p7uM*f7pEqi*PP
zUoatFu%TvGE7n&D2ESlxf58${{wYlkVI9c2+{WSCi0b>Anw8c&ItnT?Z3_7vJ-}9S
zqXR;|3AiTY_5(q^BtKPsl)GyLB85+@`|Abq+xhor`5}ILmf>k9_T4PA-yhT?o^9QE
zD1Qi0mT*nO`+C1#CxS0bHDycWk|69~uRyKHPO2iyn0NEYLJ-2Lu$pk1^$PRs2LLIS
z%|w4}Hk5_W+C~nqHKxcy^Ka-6>WF7ZB!_Wwc;YCvJ^7y_mjCaUt|q~2%T)s@2ZbHB
zH#b!vWZy;cKMd&d&CBI*4CLgBky+=K4Bnh*;U0~@KTki4;pX(*Tzgf`<VYKq{>Bsu
zov4Co*jiF_9~NTg49mSiuB6Oqd9u!{0?j;V*E!JV>`W8{=gjSu1?T3wkwe9mv2Ctm
zl$+Ii=u@8(3MNup2n(r(U=1X~(bpPE<sJ7Zz3TSrWQSaEu6h@bGjcs+B=^RnR1Ay8
zVEu#kE~V+TfRt`otYO4{F8=!zVo`=*Q|+}+)DUa}9EMMi-|a9n6xkLOx}IzjniyrO
ziDwA!Bh~O29!^~Wv)qL*nQHgXCu{Euw-oFfTC(!t<6F9<*eKx2D%B=n@34L4Td0@d
zM?=;>()s<K?f7kKe?L0+-|_qIVa*O=*`G<LgIDL|l6|~U(t$9p_$v)&kGh#RsZZFu
zaVj_s;}t`O&FV0^7_)kL9zjx`tEgo5ZDTF6xynhxTK(OZua7?D15Verzd8IXVI6W|
zqEFn<N{uG}AuII%qocj0|9Mw>0mk!kIkKP~AMHWJ71@Oq$OIXkh3;ywpEtEv5zaFP
zS92Dxy#v?*Kiu5OpA#L|d)S5pPNl``Jkc<iV0WI?-{|`|0S+Jkz^7(2Y5B-z_3pc0
z><hm*Oj9*ug=m<V>FC(VyqGCrq&Dw6wWwCq9tG!Oesl6v;~Kg1DHrVx?1^sqNq3{N
zj1YxZj;fV%pkZWCAzMxRc&|^oHnP%?8rY~5Lk5%n(tUi)$}b>rbU-?~&2AdI?KsdV
znPz4HNS8)#zg~Bh`X-M{7jNq70}hO1qmO0L@Rd`7%cJtTE-db1BVl*@wcEWWPfA~?
z)=WZcMjq8`+d6M@;-IaNoP%dEofRIRhq^!t>ovy~X7<ASo-Iq!tMF<8q)DOOYV5wE
z(7G|jV*Z=Q>38}l$;G`l<j1!NyUkD#lJgAd@~=RUE&T_Dmby1){kN$K9f7X@EJeM1
zqdtZAOY(mb5}-i5-aorY9O+nY8&oIs0zWUgl&@sm%(>iUi|3>#-hfszXj%;$wa&(X
zkU`(sx40)IY7eid-q2h&OxTYdHH7=d4h_F|3v#AG8OHS-TriUovVA$Vl-_IaTqjN`
zj7)thjk?@bhQ|%B((dNQls}`-(edc>w9wIV!fBMCCi7&-TcpXIrMHkFnxFBsa#)J?
z_ldHvd1kPj?1n+vZo+K$SjUh)CKM<VtISG_jbeI0nGOsOvqEj{+)Cur7$MO9N_l7L
zV#c>~2Sarp)yML!w|*XQ&-(4t-TatZ3^UuQ&p#ztZ|Og<$$dc|R;t|x5$K^dMRR>o
zq9?@Q0^CGDe~4tC96_VlxX%#%I$lX0f1`Gel!zSLrUX5_7YVDXjXzu0hdSsm$316{
z04wfr?eL+tWNn$uTS4+v_yajxCQW_K*ccdnL~2`ay@hXV?+XB@BF~Cw{za>plRrnB
zV1fTldFKC6!CAIMzj<v5n=pA9oT3#>g#$H)m*Tk7!{nYJ#-LSq3s~6#c<|(i=gV7!
zox>NeUb*eeHTB{eWoFNnLbx|*SGL3(7qZ=|&aawb#^+YTYkdP@_%TTsyf$ivnXb$f
zZXM51uQSt_lC?2LK=L_Xx=9+x^2lKC;a@T_c5e8UkdWQYNG|fZq6ryZgQZ;o>QfeS
z2#cz>1Xo2>Uu;_1<6BgVm+RH>qqidOq+em{>}@syU_Rwx{HC#(C4pxEyPZ@p^c>3y
z+-Hi@;8Sv2zCZ<#{;&(f8%e+}3#9APrW?c(vtghH%<i!1GbyznD7A|~(e{umUhs4P
zG8+Lr2ngj^K|$<c+xy7M*FPpR`(aU@B+v`*mP1S>Sb#Q^`Ak_>-Fy+Z4~qCpX%tIp
zKf%3I7j07<1FU-p^v{XcCd5R<S0i=)XWYd66E`uwjivv6+_<))-_0qH<=4eDdxU8w
z3E-RFmil-gBsd!qp;PX~DCvYTI{E5_>149-!!O{h4mPU00fHRG!9&~CSH-m5Zg`Z;
zzj@O7{9BhhL#a()z5LW=!`SwSE-ftZe6&*H!}k)pXCiEk^6?e2gqposu*3JAYL~Cu
zSH|E~pNBvnHj?~n3(nir0M(KPa~?j*x4dO-3~r&$@fCX1tLL?37hX6@2eF9)p06h(
zf)S?t$t=IttgpIpXLX*-e9>MV?W6~ytef4|xP{ZkbvHN1x`1}Yi`tauBWG^Afcp46
z-=CXvOM4;o!w0Jjh^+b23}O$0qwh4`RzPJrIcaH(!8khYy2ukr22y|i-8^mLhIw`z
zojWzx&TZUw3Qbbscym@Q*BLS8_#FZ)HiBE0$sOWsd4|klirw8;x@@vefXyd;@7{2Q
z7;>w?v-KulCM;Lc1rXrMPw`kc`bs>11Y7#X=2Iur?rMiIUTd^8tPeyTsM#*Wpckt7
z`k%7p->FK*-2Zmj+GBLld?Zy~)Ba0}%T@~Xe1K}n9ixf^w}G?u6(+t)=v>m}?$ywU
zxVm5179+MJZpkOc^GGHL^x`H!G{dQ+)M=S0=oaiiml2lL1iNz@p=gX#)iUvx3H#P}
z=!@IeyL~N7)0zJcyKI=KLR75R@lUuN^8GO)F2D~U&qO({ImC?6+9o1ebk2;owlYV(
zu!_2AdNSWH<>t~KKG;IC@PiI)JBPZ!UGg<dw!=xZn}#Amvm9h@yaIfyeN4@fGcz=0
zPuiy*Ggo{&0iYl|v1Q#RU6V5<&b5-JPbNwITJo-C{aRZVUtcj`BTP$Vs2I|7T%^GW
zHa8HmN}VH5JrcK!jPc-n-P>o#`vz6V&9&+Iyx_(wZP`bS%Z4Lzjwli>H)d7za?%cE
ztoL)OVn9LU=+6Zm*L8WmRA>PjXW8d>k2`v-<%1H=NL4ZcF!uE)NR@BC(<<dN&?+;P
zd?VEwZQ{mfMZT`Jy{{hg-@m~`2$)$dg#NQ|jQ=d0?|2ns{(rr27v=E5X@;CXe!f?M
zzTC~3(9ir+V@Gz7LVW&sBJC7xS6c4TdPH0V20^2fw~1Al60mFYck7;l5R}47&niqh
zY=v0mu?1efCS{>Y(qIP*;{2|^$WI^B%oh_q73gl$5MY#X7C?Q;jmOAWx1tk69cY3$
zzx4eSD*CpyA|8VL?ZJTPar5%>V&dT`zFaMKNm$zo41!}Rjw`h)W20){nScW+r<T5#
zP#J6m7gt%CtS!Cm3`fNCxAGU4xYK+7?6CE?t;LDN-?Kh%^kmZ{NsViQGCdHScH=gR
zbiWFW5|}cnZ`$bI+y{hPMiRsNMWbF!;xHie(!hl*;`3&_1H-FbOb@@{$Pv5lfvWR6
zNkDZ=fmqFh+z$c2xR&gfLGea`?mRnlJs8N%kL(HbVG^IdW_Xe6B?&3}oVbx$d5*@;
zgp1D((n35>iYATh$W%Fuoj*NsHs1#*jYtaX(NtwIfrqaoHs3U9B>1>c<-615`!ekb
zxugfPcUDphZwp!`0zhUU6kEvX9(TH!v}OuU1zG*UsV@o=Nlk#csPHW7z$F{q*OfEb
z$cavE-Zc~n*y$`xo^SufA^ux6!vCJ`vU5P<9$x<32U{CA+uLYh@BD`N-i~(B9IZ$o
z0x9ED&m16cf7ZuVxP08$c$c0MK^Qc>_X%??2R<yH6S?7rSYUKd!;HX<+B@==ERStz
zk#qkLyT$o&^BZ2XC0?^2zz9ZuZcs5c2HkZte?2K<<UE!`sqeq&d+zTibJO%?iUg3w
z47i)TkvNKfI3=q0xBe~a`cp#V%AcgJwFRy7m!F)J(B=9(eRzsXCZWr#Kiv+a30{Fp
z(nH1RIz~U@y9k`&LNPpOs2JeGaX6L0E$qV+7J$>Rgp9&j`~q>ttN0$aYk$LmB;sn(
z4?VL0FHhC_mc8!1_xK_Fln!<^z5^2<I5cc={s(1W6%cj!Z974CcY}y@NjE5<grI_S
zcXtil4bmbEh=kJJ-92=7cX!?K+<PAG%RT@5I*-5k_V?|*)?RBZ;{_3^@BaCN+VpU(
zs9oQru(SS#uPVN?8Hz07rkEK1)o%K)nhgcv{PdGK{3PTa<s?Iwm0GZS=`nhw1t3`3
zQQ*rp-3(m;5y^o5Hwq&PbfmF#`(}x;3Guu+So6h<OHgw2@@GUJ9{@un3m>hyouBQ9
zvp*Ihc-7S2A>AN9L^C(2d66n2iBYpjBU;43-H1ny0Y7!*9`~%$wL!;OYp7AFcgHg0
zf!26wPukF3mq<hjxZ8Ol^ZI|kvN``=*&M%y`v2dm_hYt?0rA<nK|IMIHLc<-fFo2H
z+z*PK#1ZX#VhC9pCAK*M_w8isw8*y0O+jCnBXsTbS9jD3t-ihE;w4<EdT-QcLPWdm
z+89mmQaRVv(}N^fu`ek5r}E!?hzNx7%XgsZvk=+`jm~FPVD`<g99eo!LcE$ol@ZBm
zD6&SuStfVWu2{aeolpn(9kBIb3h?L3asmJYNn(f6-#&>k;QI_IAv$b~lThnY>N|7<
z<77ZZk8?IE2I=E298TwiAXd#60CRLwQ!FX|bkzLwG~dul0q-)Rr2yFiKG|<`l<Ug1
z-gV8u_W_g9Mh?)fk`(q%2O%}tU$h8&wm+3#aq<gCv#2MZO>5cd)1`Agl<)WYCwUd#
zPKm#e{Ttc`yn@=ui2ydq)E(=g<RZ7%OZ2tVWe20WP~<axJ=qHeGppybD>mfacKE%3
zkhW&uNgYG`J#!=ab$EX&vVnMP1fT}c=Di$-RP=&;TB+l1d*EEZwiYc<=OFM4*b}w6
zH|4}c7&$9uo+b5UzKQYL4)VN7k&%~^8Z-9Bb5<(%+xzBenVco*^s?s3l%Hn5LW&cc
z3yI%;1>C=TQ~K}~4$Y`5!htuvYO<*fmH&Aq>Hoe2+%*WwJR1HF+Tscj3eb1_(UXST
zATEqK$WMj=vzmdG9KwThz7MCr<0j=9yng}?t9zMFn!jH9g&cT>ifm5qXIrf~J2xj;
ztmdU*Jmpvb;>ZBOU8Wh$EXUfgWdt!>;D0)yHO+O?-L)rndW2U6uk~{owu6vFtM>qK
z9#HZGukz`$($)vJMLivU6=INR%I>3fY3-03P&+3mEdO;=UCnOCa5wI9{brkShc}8V
zl(pO9R-?{t9ftJls2rCZ<9*y--=}J<x;^%zEBk%dAETg&AI5EF>t&_`f=E7MSke=0
zX&%;uNVl7r_$x&XWerp9lG)Lwl|~gP!Mg$qAH9LuM$Q5;y>xYuJ3OEJvCvd#x<Bte
zmIJTpQ<E#8Dwlh)odop911vF`3kh@gmvqwyn1@#juEc9F510VVV@IPMN@J8f;OAEB
z4(l)5nbS6zKj-6_yiA7=gSV)FCuSm|pRF@2TiW^Mkuvp2Z&DoI*{bR8r>k=>wdzoe
zbnIPqDgu`KuO+{E2A0Gk8SgxhT+NeQHi*RDKic{q<vUHBz$+cD$A*J&2cKs=fB#qA
z|7Q&H|AyFBN<qEtW^<JgaZIs=6)2&fYXa%{yYF#-=4Qh3QUb+7nu+d<g#vtt^YSOc
zWI!Rk_|ikVrFQO;8oqM;iVnVc9QpF9RHZW?-<L<yDe@x*P5)!C%~(!5fad83N$ZsL
zi<(Y0usI~?k+gv5$}>C7`WfV~DfXQ3an2I<h@cDyfKC9gC0pbqOUj#*()E>>Q&c{_
z+PPVbXr7aHpLo{`Ht-wdK(XHwsM?ustFQU*>%?~2zKlo9wS9_pRT;h%c(l&41GWxR
z7az~LCs~2N?0a9lUNKSOT$N%zekY=EvzC?4$$KFR6xYJJ1mn#6Elt}7hqJ#$s%sVQ
zs7-I%LCBtQ3t>w6YfbWS>i%uS94F0sKw?oh7Wv~x^xK8jXTkhPYl-gmZxY9$V3;hj
z1&j3?+nG?&nUa(ovKp(Nfi-h)c;}b<l+kwP9@L(CT9)$3y-Rs^(xvJF{dRLL4#B?)
zQDT%a110L-T%}d5F%m1%%wWju=-a?nFb9qdE2004{B9D!x&BMnHW0X*SDibdC^t?0
z`*R&S)g|1hoyCP`vz`%aY{el(%u1a@AO6(mze_n-Qq&hiwR0r$Hzry${wb|_N?~#u
z5NI~w-Zr988RYs#mP9Ppv^*pe!>FC@i08?<<X#7k7wLNcLmjRTzQum}|3!~hyO~bm
z5nWgf0*xYKKVDItTZf$G2+~RJ;-+yDXDEY#)X|?T3gjq80?KW2z62tWQK_Vg%Xb{2
zBCu)uOTap;EdDJfRQ^}<pH+;6B&JqEPXYt!wW9ZEvOqKKd}}4OgsI7))vf5ZOwe3h
zL2N%;UNZRBWA76D;ytY7u%K^6FV85Q`5_<xk8n69aa&;muJ8RJv1N}vi%b{Q&UB^U
zbiy;QzVZB~#wRy!-!Jai1gaT7BrP7n>DHv~cEm=`&Aij5r&!2+C@o@-rw$KWkbtHA
zCjOI3++TnUJnl4p-Ah-TX~Ah?NtsfuzP&=3{fT=0_!`BxZmT=viVN#{(43+HzH}jJ
z{8}}N6?Lq5I=s7E<8ggQ{H+pfOb)@(ut^tC<yXXBhZ_3e(Rn8O3#IEdPR^hkBS=6P
z^NTCir!5bd@za%cb}P@7y%HeXoM5h=K*|Sn6b<IJ{7R81TrdT<mk-m-x{t^3XshmR
z(vTN@#`z9{xw7?t-3^++4-!rc;1COjb%{vr$p_(cfnfg9fFHJ_fqecuAfa3~-s_rA
zOY>5V+V7yh8^1hNzDf>Mn_x#`b0?Wx!*t)3P^8gXwR%GbM*hw7_V5~()9BthA-f_I
zC7OSs=(@h@va$0PAKkvydMCsNLs+MZB#3J_V?I`3P*_8(6<HUF+g%{3LMTI9d7yu{
zMmHzg=Rq*#VoqkdSWgv^!j}K1Sf;F4rZR?@V~ht@wa2rFz-V!RFzM#T_S?NYmex>u
z7C&rau;6GNRr>mlJ*8NN1iV4Xux*&SP=h-WxQqB8NTbR@(%e27tfT<_Deis^_HCqa
z3yL&7A*|gX;bJ4=8oxvb=9k5?-el08xUj`QR84&w1NqDx;*y9{jb%~*fg7qQoLO8!
zNDuxtiKG})ru3Imk=GK02O_8CqS0s1hc4w`D6J;b$xgN)MeYM#5XwU>o)v-6&u2mc
z`-+Xhe1XqDiU?fgd7BZ?1W0c8&yjF0&+jJqLlXR<NuIHz3E&WmbFn+T#4{7-fQ5~B
zG$gz;PWD4PLNQcd*O|m^#5P+gW-bPQCnvxAPwLCv0Sy8LTt*6iSgQOts1X1zEkey2
zHLc6;nzmvam(L&w{xtw|YRasH6$d}|l)-QHt#IwL*zsa>>{Bzi3YBT{KrwL_z{*)Q
zy7NwGuX7xNVu$DVynBy>P6|?E;J|Qp|Hesv>dG0>3EA!t)4S#urZ3vkyq!pSwKzxf
zO=mx6Z2dqrAPDsJgCou|jvqahgMrULEcr*=$6Hg76Mj&$wSHWB6siE(-+4dS`I6@m
z^Ykrc$K=h;{q0O?)2(N>zjnz7zZ84A94Uss3>os{s6sMs7W}4W`KQkhC#(BguM`wu
z-Fy^2h5$|XkMgm9Ijo9%?`DLE`rXVavO?`|DeQ4CA<tMa5c>nJ7($9s&^K_9f1g#`
z&T+O@;i|qj@|Gi|%e27^^E@f?+Ex<|T|Yuz%Ii29f_+M7$?+I_FY>PerNPA_lDkMk
zMJ5}_PhfxOmOi0hP2r;B{WTs0YqT}IZ&HNrO(st^4$xSrfcm|4{}gAQ(_L8BM1i^_
zOKZq@#^|S&CCNwzZ|KY}&#M|ztbF9>FBIWh@?B>5VXsgF#so91nOLG$(Ij)WB}tR2
zDgIi6nYYAfA9n~y->1&4ZM$^pM;xYKg!N?D^E;Wt*nD?%Dc{!E^d@v}1qZ_1nbIY$
zdwB6CxPnM`*UoTA_FM{-Npl~BG588ZRvf7~f_!{T2<(G9PID{6l)B=#y~lYhbJ7;1
zyjvq29r`Y`<Jgd!&X}YwDz!NR+@of+D`U_`EAM?WZgjC&oX&ZlmM>KR_g)E_ZkL}B
zi=LHP#Uk&5-QqC?;>>-*ElrU1h|*{6GN{k5VAdS&*`1U|P<yJ+e-NA8EQp*OmILPu
zoXNE-`@Q;zrq#rIO%1RG#~ZJR-`juSNQOBX6XElSxAU&8Ble=rSKC0ov*_nfbGL2s
zTq9)$&QE*9DfXWATv-@D9%gf!v*<Bxqz?c*NS`+?z6aiTtCJ+8F)i08zaL+cwJ{=p
zxI<H$eNI+J{vbLm=A3S()<zjd6PMbh%^Zf!EnO$12yr>_n^8vpDwcmL|9%3DND<bx
zo~rw;3nTlv8&}rNAnSm-c7OKomG1Y0J4u79f7r(V*zBBYvgq?T!>RjB-4<wO#6rbC
z1S31}!m9WuRTJ}Rr|N1j+`0M{>BXmg7b<v&yS7hiQLN_4?YS%v_JE9hyMJKk5DU1R
zp2osDf7c*hdppC4Q&sktR!Ck++5N1ig4|9Qw5;Q(&rMsk*3ST|yrT!O^~y1l=2}u0
zF0etoTVuq1b-MSJu&<I6Y|Gf)n{|!!IO<W%=MSz>R<XF^?N|4IQByZ3t%`M~_TS@T
z_CKd)Kl<*{h~za_Et!9$Qk{;5P`?}{<Li|Ol-JD3WKZV3^?|l!lgmpb#G@<~qDU(%
zDz5fivD7)5kbX=d!inwGV+MFSqeyH>0e5NW!Vyf9QP^Ljj-TdjyTq(I;|vugmNzzp
z8<txFVLJi5pg0*E#aCQzCO^nRacP3~$*y3pf2y-2mDjddNmy>kF%e#YKcGoyC2iRw
zu3qNh_UTIP-wTH+4&&J3?YalyO5UinM*5_b#Lx#QgPw%$yP*5##4{=_4}$QBbGSxw
zPbx*8=AwrJ4<RcDRa|FJpb9BtDWeA~!S8i@)HWmVIa<W=#;PEtp=UT&u?wFOST8Vy
zv}Z}YfXSi5@9i8FJ8HstH4QS@ru~`wz*M|#e{zBL!7HQlvG`~aRFuap$7;;!BpPh~
zqohgO_!#l$HJJ;qn`41BQCX{+si1JO^hpBoC2H(P^%q*^)tDaK)C_4)+Q_tzlI|gx
zlWND=RcXEL>`U*+9oGd`&B~M?dkBATC&=ZyLyJ=4ULc6M(RhDdkkFfH0LpM}_qxW-
zdD7fFGlNnNEOD@%R1DIFt|yZl5(%CNCIbFpZ`2xT;@+nL6(;lAg`{jbB?i<*w2Ib>
zD3%$YkhC~(+B~%ibI}_1!&_^9U8T!2VSsbMjj@oFY*#zqq-=9V#Dd;4k(=90d53-&
zci@b!!uJPgWV^gNXX|6^H>IG{kPGzXmE(0iHP<rLzv5d@w;t5dKamZFhK*0hVmS=h
zyCnX=U26Kb&Q6d;t=~eq?FZg;Lf&!lXLOA&r^(DuNGIhSS|1UeVaopPhf=GUQ__Ho
ze^M~B_KmT9XIRw1U@n|$#9-VC!`0qcJifh1-Wht_JsieGdUOV1MO4;qz)(}^@2eh?
z;nvw=2imrzXKnL(lT$l>NX}HY*JGYNPaaYZL38=dLipXj;=+FUU%OAlmpYELF%fG>
zk9cBVTz*<ynI-IDBrn&6v!FgxaT>N(e`@os*Xmd@+<8@>sn^>uW~BC?Osg%0e#0<I
zXeNBFI3dQAi1hf&DWatGN@GPZLg<BOJKr?Z<cFo2z@zMdZJmUMt$+-vf6_^RA0b)_
zLw~2+ZzXQ2@9!zrYF8?^8wFQL1gMUkoCSo6DGC9h6(tPFt%G6;K8v9#ok$;j*87=F
z61byKM6vFaK3pGh4R)7}2@wGaLWdfajhHoNhTY7z1?p${qTULBH(G--7*HS&DW9K)
z_I*?(p9_7Q>*rJsJs2=m?V*+3OmvKDxmaFU{*Ygq1LA;3>`nYE-ew@4+G5y}p{d*0
z6R3M+y@<6N{MfIp;M0K8`x+nq>M!?io%X+m!b7c-O3dDYN(mD`zJ;64*UsyJ341nh
zSx4&5p0Bu;zuB*z6BtCE_M_kwj;&?po*78DA7JYQyk05cKP~iK$ftKgPfCtl<<Vgg
zgw&>U+`NkDnwBA(ZP(ZLOOk92FDq3(oeOp=2|2r=HYpb&rb}h{dlpMvZ9#*T?`lNb
z+pJEt8d=TNq6@YyzAUd?*@#=UIqnT-T7q^1h44^mh2wj2y9MDeSrosmwlre`pNU2`
zR_pza-bSHvtK>f}N|K~7N;b)4CgD(d92dsE#bX0aqZ;Pdqkf?7UqQ<1)$KrX9`*Xy
z3MAqa(G8{jU`&-q-i;e2Llash&HBuS>$mJ~4G?+{@O);bv^6SPvBj5uu5NJlE15<O
zP98I_!mK+>6zDgyx@l5}yCSPj685!G`hv&iOpG~3>AuI1_HH?}hWL0BAAP{Z6f(o|
zZ2I$nj}Wq#$3HJ!+7P-w!mhbR7D(Z)tK}VTRsc6_t6Pf>{+7%DQsG#m5z0+h0t27F
zA*{`z25r~|>3rp_xh}sySzxlR__=tH0QDV5b!^8+r5DL~7xkbp`U(g7E5V5yG?Nu$
zd(3`*<EjLNO}qMsV{o77zB3hzF#a9wknjJfNtwZ}lZCH=u;IL|40CAy)^!b?`J~Np
z)<BwLRx}QkWL&yT`U2-p)GIWvvNAvUOPHgb9maB!o*T_oN4Q=9;FkHAOGzE9lo=Dt
zTy#^)Duvtj>BqnCM)s2R?!|q&)}5UFe6aC>G%7FO59~Ia9Q<rsX(BIW_f}6~8UiTd
z4=@L$ji5)19`a!$#-whqNQ90D!6L|oaM3X{;ECx?@fI<HL?pP1CoJ5Vz-|m4hf9@3
ziv>eO@{a&t(!cMpzn406GUiIb+Q`u$hBPzUE-mNqIDp@Y-OL)O#kxg}I<a|RInpV-
zUhS_J9O@CN+honrDPA8vG_v{HkQaM3wAA$Z9hQutoZ_%i@>4E(3z_E?*>jz4yJ_x)
z!oz34eIjhfC&|+d{t28A#}WS%fTQhWuHWz|C3L>+VsGyq7{)Hu4!TE6WbNN_9lz}{
zl30^m@eF05sRXq50Fn;+(ouol$e|LI*7W)nr%5_3y~V^@NaPs#pi{)#me^F?+9m10
z?E<O8V0@sX{j}J-KwB&Q^O`}}$+@ulrF$O--cbBw5Nec3=jr_t5+9MAXJ4zXm!Dd-
zk;E2?EMbySywUe76Oa5cX|@$!fD_GnU@u3np+8L3RvyH$;4+r~CuMWz%qvbOtn$&;
zNg;WT0abdRCab!D#=cr&6y)lr#f!Y|%J*o)J?*ROg{X@L&}3(ncl4)H=KJPF_S1X(
zuJ-~$0BA0+4_<kB#;$9u_|Ur(;txfqc&^vABHJ;Bjs_BBB$VPnp6AlRi>Yp7PjkU#
zD-GX{y!#Pt=_rRL!{2*_ElCl-I1~oF9BhCWS4cZ{cI-PPK@kQGzsBF|k$pyIPexK8
zi=!2y6uO>5VL1<O?H%hN|LF5L+WNCYcqS(-6jiK(OVH78+sYLzHqeDvE#p@0RZnYc
z6LmIc^P_$Xso)Elwivh4G;TmtxeP*@b4MLqSpBr@WoKaNIG)&zl-0@r(4hq^2_j^@
z0(C37de5%J?hi5tHgAtXyoP(zKRgp-OMHA%QEsJ{+{cZO(ctG2vU!Nd5ajxeKi@9o
zKV(Qs*bwX!N?n2d?&q<#L)T|iR#s&ivfrv#pn2ySwpt;Pd?5<PdXte?20~DN5(DCm
zUwLQ}gL8*L!a|X-L)oxVz4xAc5&DVzIzo^e%LntrWoaYdQD=-0X;%ir&xds|()z|=
zpB(+R-AocoyhX>c@TCpHd~=~7o;E}G**_kS_rk2$!rVTt+P^0__s6|slv3#3cQG;~
z_lHf4w>#h=L*_fz4m+(S8~W9ciGUVo_QlgmOa<)>X-C>{nVwiVZWKEKG}+Ra=VcuN
zB`^%>OODgiIswtkJrZ7muKQmtb6ZON10}>O#@5%Qoc3>`gKK};Us=vRY_JiiU8^u-
zlS0nRShisCKW0kOh2--4WXi)Is<jPr{KslO8$6wMPzsX@_P8!mn}kMw-bfrC)H@a*
zPmYm26map{J@cdt>ok^~H?$b6qb^0J3UH-5mKDlWo18bWDOaQ%JMx}PX*f*Rj|b))
z%@QY>YD^&h!yFOA?(t0aoG<+QWm7z;0~2oBwzy_4rP2CUv332LTCaD@RwPSD58?}3
z8&aTE4(u`;A5(Q7Ps-YmX9_o3vsC)mHrS9F?@S#oqGLJtPC8Q_*v{|1LNt#JPlPE+
z3U#oNCge=mX-E87JC-mlzjX;^xE3ly^gQJ#byn#@)BU}k`Ry$%fvrt~;RtBoTCaqQ
zj^LM;dxahWK(Q?o$2p3AWJtN(cli0!PL|xw6CV}{$vu;ig*pwI9fV5VY~xm0eF??c
z@^<3&!L4gL{om7V%cy7S69Du?6GP0YOgw%h&tap7o1F`0UDF&$7kjiZg{J0F+&}sS
z`=D7w(Z9o42-@IGsm=q0kgPjt)Q7#CUjc1*v>3~dEN*Uo0nG2l2Dc1bqn|kW7fx{x
zs(PvW80>G)@D?PIt{QH^smeb3Mv)xedqBiWB9;I40=S4{r4ml>T_BzL?y3&l?M?ou
z{^dVuiFC_Ae8T^SvVo_ov2m6H12HED`I{lg$LM31;bjqJuR4lIXf&52$wy=q2=9)i
zm%S*2IE3$1yQN3u+BTF5L)X=!qXtRB|C9m0n|K4`SspNRAP_o*%<!I!#r&cf+CjR{
zYdS$jd-378DQ5l3fSr9{t&t>Nf|}2-^sTxfH^@+}3LLKh{th&@T@*oT`OCFseX->D
z<~2PLHm3U#`gu1G_PbOH1NY5agiFTnM&E&T=*G10&~mnkQ?A3e_Lcta8hl_0ui&j5
zF^C5Pj(hA@%9EU+Cqlv7KcJd_EmO;z{J-^KM*%;7I+n|eJjA{tuku!nyS{am1@LCP
zfBg?8(bduFwG(^JaPT{JMfJfU5}W0~)82|S>EQMEi?!{S59n)KX<F*M66DX=nPu{b
z8L(V6yR!rj|2*ClzP(T<1i`)r^syz9=?Zc7;$noXUU?2f1tdNOGGm7EmaPMpc3?fK
zF=~}D@0$bmE>T(^Im5A+!#3t~IlntoYz&x^dof2RRfUXyo6?lFCJwz#23$gI>&q$x
zW&V75>j7V=OQwyIiLf>77id35DACpE2&MM%n@h9!EdCm}%S~Ptljcj|C#Loe`^mkD
zimGA#PjJN&oJ3MJ;9m5Th=$-&qjchDO3+btQqY1=vit`|(9pW^(1y8w><CN?ibx9V
zVf~b2EEgDE`>jLij1JE)Wa*pP^OQZ6(;dRj9jTLjP!M<N<2X`B%t9ofH%`};dYspz
z6>ALoHUNgEjD3C*Y2R_#v|Ez$7LT<JWlMt6c)Nz^BMBpJy={=bAT!K2*bQqV)yy*D
z$w<d%v(<WM@&KUhI8*jfI<+(oZSTekbf)@E8AlZoSaP1-&pK|WBk9TL=Ufm)6k5^x
zu)wxCV-;7@X3)BhI>ImLgB^g6`g`SP_5lx=U-K=fJ?i*Jz04;E1UnnVsjEdek@Rmf
zf+Kt~NnZPDi!Q*QYF}?r(!&M&!HZ&`WmqYL1Kthdr94}Px04=LE!GF0Kj|D=*QgZ!
zR98J{xZ(_B5D@gARfve0RFT2+K}zNP9wiW0SE^on(dS)0JfcY~%74Jn=@)yTu?%KF
z38vxA*vcr%8Ou_3uMZ{))cs5De6YNQ0tluOQmofSoq>^xHSop?+$6{$<HmT-s%+G(
z_lPsFE?NK5VISK{Kk9nI+YcsMD%7|cg|>MF2zj}{-68I$inRo}$@@O$e@>059PL6G
z3(Yei&Y>#R5$Y=~rOx_hD`Jw>D}8g0$5!>eMD92H#(7d}r^2j%_`aRWo1?WAY$=l9
zozr$L{`m8%PpvO@eP_?k=~Wi-u)Tg`p(4oXX0zg=E20dABSIih(veTsdm>+?zI*Ui
z5x8qsoP-X_$~9Wo2Lvtz)8usNH0i~V{D$rDU~NR&TO$<mV6U1W!X=4&GhL`I`KOh&
zd7MWZXGNukR<(YuoU3npcS<97cUmn0RSTVflusy<wP1sL5A55;^n6#gJKPfoyiqn%
z)K|N&qejdO{R`5k_%t)9=8ODxUMf?jPQD=T_Wq&Jk^PUL&@(g&WN0ogU##2o<u9N)
zzk#l=T$X{qCn^&9(9n$;=>D?N8~ljIYu(<FTzKvml_oKqj9Qo_u^w@l_a}d}?$t?g
zO8DQXxKtXiKASD4M)^+~KeN;9c<}?oheYm5l*aw+E1J6S%r#~^fGd=dot2o<wF3JE
z5Td#{^50xpZS#-pCF4tsE1_I=hS3yDOW5Km=v_yfUR3_+CiQ?x`W662{9L@_2VHj1
z5)~QgfRJ>BYlXIItjF};7dF2tz>JvChmXyD&~6<nhun@&5n9!C;%;P*MuOJr)(L6P
z7xOHq^FWxR$w2oy`hz?0)!Bb<I0VTi3-|^lCB1#Te|f?@E-w1P6row{@7*#~f~!Dq
z%R_*s@5mfoTN-tC1Git5d(Y3!r+O@HCRMM$C6&mcu3db%mvM#kJR0kEmSTtcB}IoM
zDln|u5aBP_+8kw(>Nx`m?g)|G%GlnZ`X|UdE3&ra_G}}a>v3K7&5$zEEYsPma$Znx
z-lJtq<rL*wmQa^Xz-a5sK%nq}QCN;ksjRF-1N1$LME<z5)2mtH$anTv=XgHP7qOh;
z{8lj=Ccv!FqICZ{VLU!(*+=JK2m;ELLJFV%dp!hQp_{z#Z&)j`F$D#GLL3reR^J^G
z?QJTAeND~EnYmD%3CaiKA|!mC<nh-K+PLq<tU6C;!tI-9bE*S4WO?URG|xs8`kA%?
zaiiP1OpKQa0iOOg0q%6_oaQBXRXXj<>dt=229zSsY*D#5X=!U$qB5;z??ZRdbe6&|
zy;M&bOXw1#Xfn4OmOvk@w9E-U^c1^y=|{d6SEguUCsAlWm?f_XNk>uc!p%8wWE%RI
zuc*FX>|NyB<9$?<IZhh8QxCuP>pAlGQb&}C13`<~OdT^TGC|YX+1F@fT8*!P=6b0!
zM+6l!6?M<G8t%P{hmc1?G`HPTg@+y`<q|U_V^$@jvy){hkxr|<RX%1b!J?&KUY;#(
z+u<kn4gxs7fOd@b9hRo!ybXi_Zwyviz(@?Wg`Cu|;+Gn<*}GUw*BX>J50znT#^sj@
z77Y1P_GJkSLFcK3gM^}n!Yg)sur~xKxy1GoarJ6hUd}5(JI2Vv2Rj<C@R50WWD;q^
zUrP$e(KeH*fGcyD=~K$5rUWCH3}TXDN=8{EFnfex>+O#}fXhOixn+CMTDZyY35%gu
zdo+WgzY^rxHIaPlM5BUC^w4Yseh6;fxSp|<wk|=Q2$8c;i-ZjOOq0*@;F`kr^am2;
zZjhMOPzP~(w_fwx=z^SxXf5Bi?PDT7!2ra@AO!?fQHo=xR2f)rJjW~owU}8Y<{@`S
zU4U9`aD<3Vg||rB?`Bt?)7N1r886=4UE>lVYKG#8p9&`A^C74M4t;^#;5$z?r25IR
zZ5T48>(3VSrVlUjR1K(7cx~5S-Y9Yz+}QZq9W^ctO3&U%i7v&EAFLA+LI%C#6CfC<
zqCxa9c4AF@+rap$AkZ?foz?k**xj+qNg-zD;OxSO8qPtK_+RGKQ-%8PQ&Gj$0UH-p
z;b{OAQ{AthJm(V0!tz>HS@C!frgC((JBbUD{~Lcxe<(+o`-CF4%EQ!aw1sb&*7V5L
zG5nAweXKlbU|%2|=~;6N?oI&h*KCxewEH*?QO!O0-Mm@e`0<1T7nt7e_NH(W8-&*!
z=fst+9yEa8u@e)!63<X`ujY^Lgn1SYdgdYxtrzI#ip?pn^1S~!wkfHUyTh<rS@33*
zI)iZ(^*L<9*binwwIa!{|GFBhLOcPjuD~PcDU@}4!r(D6=lIssX0f3;au@=Bm+54)
z&jOUQk($~P3T-s>*d(YO)y%I$=b=%Ec{^l=Ozj(lE1D~EF2eLQPaE4h?9|LIp33Q|
zT~l4V15ajH7%jM&<xQSDxjkTk<dMHEKOYv7y?wJLCR@xTijr8h|26Xhg7FKpf`T?#
za>VX=w2Ru~_K`0!OMTiRz2OV#njKV~9b2{t1qUbDj8FHsgP3q$-VPV>&00unh;DO;
zc#(Q}H+9Y?B&mV)Y|&aZ7B7_3>a$S-1Lw$_8MccxCZg|9gduX841;SUH=K=Kf^9+V
zxs@T#{P%>dFV5(-PHzd^i>r&ZZ#iN^J^IfOW>L{jLkqJgu%RBqSIoWiPfP(r8Cat#
z`<95RB7Lh}$l_rCjXhRX49&rq!pF0sVBtf4LP5uIqgOl~a(=*eNo|8ND3p1#b{4s?
z;>oaHI5w$2p~!e@2MqY(?`Icvz1yVMW5=g8Ym2d#Pc@!7@K)HkwQS-z_2BnN!jjO+
zAL1F*Gg-;fM<1He`@<Wzq3W)S*ss?G7bo%`iVpruf%8967p0Y;b1}K`vp+|-5Km8d
z#Qp0{Spodl@J;%h%BDHei>F_Rcjs3T2HGMJ|BcNDF!D+~8UY()1WCLiEqHUyONZ;~
z^86{P?iDtQu=;iXvweNkJp1aU-wC<UFkic&gW)lLUGmM|P{2t}P<T}pCw?ah+9PXI
z<l_}KWwOcJSmjmg7G-X~8i98gIz&sq9w1yyr&R)9(J5@+Yp0x_ch5*Hqkk1N6s^6f
zgn&HJjcu}Qw&_`O>*TfaN+9n#p2E{B8Gt32)@&y~H<t=L#F?*5U(TAThTq4gNDq|A
z6P6LWzkyp6xS-Ww@2^c<0L?v6TPhr>Tko&z${c-%dHt?5@f+*GV0hyV7wK?{CUiHd
z_uf*A@2>7A_R6rJT(I^>G{mKJI!d0KRI;v4z074WKi9q(Wqh7*M<<b|`Lt^G2Y{_-
zy8x)tfZoY%7<G<Lf84|xl*s=YP?t7~BkoBb^|F^T(SxX|iT!2)74RcEZ0G>4WKKF=
zIvNIwJ$FQE6&h_~3m9`}lsBE@{ghTUtB~))SCK-Zg`=E7t#=1d0|$fU#3u&8@DZ8L
z0m&BPE&cdKk?bJw2S31nn6%%~0q&ASOn$CU&_0Pl+sk0uy*D+{o26(b4}#TafCi@W
z97-zdLH=$ON*!EWLL1|v!t$aU3=twh99~nDU<tdkp3epZ5sSLTT8H!q5L9CLBA!_>
ztloQ{n^F80C0tO-H0YeN+53`NFZ;tc^OI{T%7wk(X-zWu#=y*RXOg@H0~c_{2h3tJ
zFXCeXDf|l*Mkxds%HDOP`LW%vmUL;h+F14l%KES3&mMF;#eudH7QbzEr5!UTs>s(+
zB&mt&J6FRyW)RZUu;W&;d8n59pvNLr*Bj>zdvQuPW&!#}9SZ)|L}}Q|^mT{tZZQD!
zq!I1ux@}!o7$v?0A(fxI?@R60R+Xq+KpxH6pCpumcJjC`DsND3ZgGy6Wxbt<-Naw@
zeHSJ-aKMc^&&!L~9MC^ILTER8UpcnbAkX<%1s@Q~N$y{xoAK$~HTaZ*z6ZrHzr@(#
zXy*+`LVEwZw0CS952D-cEF;gZq)_M?Z_c6Rt3&SwDS_rbD<2FuPrT3K-pG4%D0F>B
zpNjQ;BV)##gWVh#B)B8GAQ1ox|Jng8;IX&0PruF0e4beKL${?*j6866hiUs`YEq<M
z$?Ku(WULF2I5o9JCv%Bk9TgUS7cQ%59?tdk+MnWIRjrX)RwfiUD3A)*%U1+z2Jaj>
z?|b6Ahq~x|9^3Zr-1-Q~>x5fkm;%e6uhABA4S;&yPsBw>xL7-ZR#vPuf|S)p7pXe8
z04Hl{;y|p9*69&XMWjIjaeDoRV2((|L#N%}3E}b7P1tz}PIWC1um;xP=3hHBk8nx-
z2<&!@CR*)1xAM{H{74_TW?$H?{PTzrRNw3(EU~)6g;QKMmD2_3vq<tEW1>o2q&XbF
zD_m8VsNKaCt1Qih?&o&V&A%Sj6&#u-4?ZHIY=EOPWtup5bRG<Cuh(OnPkR8p;$p*e
z+h^-})Uik&$2j_cA;Z1#1^q=@sp?U8ZQ<Krvpv92jqjV+jJGtcLH%8<B}&Ge{m(9P
zK4m1+cl4cDLKu)kgyrofT%umRtW!#W=5ZiG=+m1nyh9@fQ~PlGD&t#eIX`i=x}HN8
zXL5@85c=1fCkBm<@Y-LHn9T#kUSS8KL~pRm#=(uMFitdZkq7lmI8}=SlRN=y|F)`n
zQL#==PGy7G2N1gCPv~gHoy#Z!T?6TVeX)n;uvjPkV2az{%n3=N0Bs|4^~Vz}`xxQD
zfl=m>=WwWmh%(;fpow*<oq<tnK+-gd$u%(MHF3M49t3nThu|~db!08lw!?@{p`_yV
zI*``t3X9T*6viNk$4>1w*ta!!JJ?LeM>5QQWjcihPI;uTpwH|uW{w$T9c1toK|Sjw
z;*j;mIjveSc=5||+H@CjtFfBhh-Hm+#d1BBO-0~#8XV#Yf--o-+I=})X_@OD5DToi
zwQrM@z)JX9nvHTJ+I{ervfEH3jCX<euDOqP)GO#n3o~;g7gU4x71Ehi2<{mCE=9q{
zBrL2<nNT+(lxB=mFhkAYd?+*dN>Uw6K)SUogz@vB(pD%*bYH6j>WINtNXaZ2>P8F|
z<-u@o=1cFO@INQ8@PSJE6s^mVFL7OaLY8U69&JM!CI{dy4m}PUnbh>D1`=fyquPmp
zimI_~&#fAr%#<l+SGS9%7_x6>(8>Yo)sYYJ?sy64A5(Y2$Ob#Tua}r_pVYwVQxiuc
z8d{&l9oDbAxCU`WeXieQtT_-D>e(4tK_7Oo&7&*byj)FV-_GnKQv+eZCa&cjb9zdM
z=FP98OM}cE>qXf<A30)6u}12{W5d8J&(fX-L!94Lt>NELKBCJrke2Njm$~Gq<*QN9
zMkpa~KYH0ei>PHgzxvMvUIMcJ6s$#bE6VVwubW7utU&xX#w$%|z9JE}NjWtWun<IU
z>+JNC_rW|A6LqFCNM^IS{wmcmJ(BTuI7__l8Sey=H(7*%8NtdMu2OUp<}hg|T5*l{
z{vlqJEwVZON*N)(Y%O4NXG;k2q(piM8yGZ}jAYv38^n?r{+2M`V(>Bcoq;aMa1hEs
z{+;iX+bqol^oE>qoM6ds7-aG>bKRCLv;2IngR$7f#OvX07$o`X6)LOE$w$7jYfGXu
zUk2*WZlPs0{j#Q(s)$&GaD^HS=m{5rwa8GfE;nxgcrnZN6+xxQ2v{Uv+X<qPP$kSx
zpR2i^;{lgjZ%XUGVPEkQ*M`gB+@=u=mkT@#p5~Vh-0HpDJlvk^QggM0VF#lgdsq-F
z-_9Xr=|oKm90S<O{=kJX5^i&K)eDezr4-TF9RC~JpwrgJ9mFQ@x1M+qQ>G9Ldkg|a
z`@raT3AiM+wfDC#Vi#)%g!;a%eN7FErI8$E(tQ>2(cSb26;D0D`;+Hm;<~Cj{g|yS
zP?o$p+<Yn$j#!*AMk(zMC}%Nere#f#(c%ihLp8^D@jjVPtMJCGD)N#>(~Wqkw)WhO
zl1mAYz4K%amt!)IBi$)e<jj$xuSRo3Hu-{57)Czt7tbW#mG=#3KF%*k&+AS4nc7DJ
zd6yKt6)h}yi3T0FNCof$e=3C@N2ghZDRAJtA34`N_zrGVX3G7LBH*gMh{~S6RfeO@
zL1XKUP<&1v1g-tFG%ML?C@eM4Hkgy=_#h6-`i$<(R0A}pmi+06*u7wd<i~D(vH0p6
z9mag+4RX;_h-p68Q{_$kPlh@O65uF;VKtqO#FZ`jfco?{opAAC#|~A37*&z$`_L?h
zFb-Xpz*)jge0HSXc(uH_2XXC7s;tj~rLXc|iL&rA$IJ7t#wiJ@dZwWTva4H_iUfi~
zvPm%q<IjSq*7Ej!exD|0NdtJqLRlpb$$bffy=FVMd)-v(lmQvu&0Lg=Pk&g)KL#Z(
z51o?P{<^;U#~s8Qkw*yZybuD9-heEI-}1U$mp$7MCRH4U&b%;4o{|?i?c<=2OD47R
zu)NgxcW4gR34ZS$yQKJc-~=P?@JzS#gMvS2i3&xN?Pz%T2xp>b3TfkZsag!_Wy(&D
zB6kG}BV^q;*p-@OwQUr>tcs^^<Ti?Dq--3PA~xYR)aG%uw?*-DjN*h?=hU6Ol6~4W
z7<D1V6$AKkcD6<Pkk+28bgE^xf6G9V?4`04?TCo4mj-x-0IJCMXtF;b6$%Jpbj-b|
z7i}M}yVaxdVddDyUZS5H5ltkhpRFy3w@U>qOr4woGgfy50{jzJNWCd=LJdHf8Si5N
zt2^JsXS<F*pd*5O#$V!}xv0H8e1AVUniI`!VkGC8aw>){2t4EiJqj2*Y_((WIF~IC
zvsG`&w7MxFgOGCs{n&hXz*=**hfGB)P2Z316{YD_Yuoi3J>TF)k=VaY@~*czK(Ck7
zKHcsG{ui<fTrAqJw`|vFEVuj(8@6#ZNq{<gcd`V0yD>>OGWGAkj$DfIaPdzVb9N^;
zg}cI!B%U0!tGhH)4+M?D30N>JVt-$|h?0J%)clJ(1-fW?tj~mNq6(Rq3ZG~nVw$l|
z)Zq!(?<=B(AG{D;$&r|SapG<y2$rFDIiVt2VF#tqQF0&>N3i>`4C)3W9Z&&h{JH{C
z{A9B|(^bsuOR*;Ui6V<57nM>Sow4uF9)^CGm5PLQtP=viPD(n0u$!xEd5d08vuetf
z=WY{(%r7&HR#JAC#9+aF_FY*`&{gTlDweG2ZIciUfo}!><08O3paH8PzSq!Us64hJ
zHGEAq(L`U6V*Nc^V^Rxn>3gHi_1K>C)0AevL;=z5vqWD4H3s1D{r8c}lv14@)ec4b
z8$c2S_|l--^Q7AAH+OxsOlw0z+063?!Io7~-+%QCAyBZ}Md$nDCwlJ#-H&ZsB7C<+
zr};}rj?R_Imxu6G+({8+hPWUX7X7=0N)?5%@I`4{iV8b1vl?Wq$&jGVW}|%>bwJGV
zStC9cOwD(6BUhL|V+C&ar*4Xux_t%R^uS%+V%;fl8R3Ct>zZga^-7=#g{6355R{>M
zIDNx@4$tLIZFB?=I&j!Vxz??Ko}p7@$0^0;FUTyJ7m_99aO^sF4&nLviQ(4<pY4kY
zW}&nH^7=cKq>*DM#bhjOfcf-J`Z4!nAl32P4D*Y}l&oMT9c&1OAISxB_cX9Hp&9gS
zlpn)}wByn%#y|?Oe?kk~H$3FOpg646v~Emi;wL>Fx;KZ7Now~uVqD_zpVE#d?07Sb
zekB@K_>W*$d3X>wU>8T$FvI-@lkA}TZlp+3Anio@7E59=L6rMZpnV0nf{W3IbWO%a
zMydACT=zgYhGk*mG503i`E(hNm-|b9^6&2-zUsKx-FWX+=dJ9RY-9gO%lF85TRC0i
zab&f>%%0Ef_)1#U8Gzz<8h*J9N<ERmV?c@j&ZPS5Lqy#7a0EJfdRLjB0`WTwD{404
z==8hg%t7xH0?|4u>i-m2^%%#nyh=YKC&pu_WTjuW;6DDsvR%$)HYK6@m1WC-iiODS
zR&+`6+Hwxp{SXCG3NW{_hbnSQ?A7vf`Sr=4bn22(f7ngK2UG#0F#%8MFSi-V>eIz{
z%m7&90_j%^Z3VReU{-IB7vQo~Zx;ybJ+R~^9};1VZm$r(z@SDyWN!AY&wAN-sn2Dp
z75V@=2m)rsu9<;flYpx{#4P;8kg|&X&-kJV(#SH@FpIt35fg*&^`7%dbwr3OSH+&o
zGucd<{T(p@!%oQSBLLV(EuANLToMbCpD9j_uAL^7I9m1ClL?W=&jFMC>hUqk=WJxO
zY*A6;;9L=4-m$O{=;pd{<|7(2F|*X#3vM>$y1{_W9+W{vJ-}7f8)bik%g?d&S2_=g
zu(h@-D3KLA<NAPQN-dFC{=Hh-_WOy?wmh8PDBtwi8GTl1#Z7XbfZ!tm<L@pM2%RUU
zs|}cPsI#9CWR`lB)Y}WpYfjwBV~sAneQSWb@Gk=UC<>TASwpd-1jASWFj5J&+NLqo
z;1I^d)O5Nz{|mPrGD-q4d-mKVPz76&<tOj9OWUHWQg^Y-Ai##ZZay*8_i_WgK%rr<
z+=8M{-b-iy8R3+PkL$NR#_hYdnFWibXZ??NihkN{alOcn!ye$e$FBh1JeiliB18$O
z2Nhk38f?6Eaq?Le+wa(4i-b@XkfjImqe7;-u-5Q9i@qsSvzu1RU}?U1E5P0LI9lM#
z`n!(5*wj<65PHah%((>g;Ul%gN{H|AaPPAU#n#6Gc-nIz0+wE@H~y+#S^Q)gu0(z0
zO#E#i^=HmTCz<zN)IFXvFM914-IY!zxj!Cy<De{jX+QlW!og2AK6-uj6`%RL23?V6
zcfgeniW&KVs9#(jZuk>*M*c1eAQ<1ZK-YZr4sNc1=2;z;7ax=u5<fWF6m2HmVN~86
zHGLoi^nOMfKVe2=OqgWQO*8ZIlt3sFBUJyKnbG@Hh+iqFEjh9$nOk<m9;c1#IQ>O)
z3$na0gOxYT?G2?K-^_CK>omjY-)In!Bu8XAbOW-I@o;zxV!JLO*;wI|+f7*9r|M>z
z&WlDBywab7#2ZIlnx)FQ0pb^!sbDdP_-zB1USTH8TzTQ)J4xqn3HzVqy=IeJ;glm7
z@I<z1FZ1U(Z@(K;XJvU(EnI9QUatk`K%k-k_>zrRTsW{feVOl~P{43YLU11UHt$wt
zR7TWCCE-b06Tp7$^6@gk6*w!;p1pJo!tw$JdRx9(Y|b@&TRd8>eKLV8EC`=6J#*G_
zd{OF_#B+$ZiQZBHd2Ma~s&&4P3U2c3y9dj@ekh}T9V&PHreEtx#;TG3@`PnUv;PJ!
zvk6!-6(0FRE_$z?HfrLSG53!vfG%>tXv9{y^BmzlA$BO|(75enZFSB4A6qlmDu3=8
z=O2E208V-Do~%r|NJ!iOgHeANQo*n9el1rO#6qc_7k2@CHGr>9Y&Mg1&%l7z`|+p|
z4DgXF%f4aW(jpj#9W3Yu_!~%ziOG=kt3l>>dd^=3r4tU5YS)=2YoVdp=yJc_Uu_k$
z5zQqyXL}PDkqjtQhWstAp9{6Hk+LYYKV}&JLEal>ke9$v*=wf+E+X=J+XS>IG-g}z
zy8^8W2OMnd07gzm2(0sJK=V2!4Gt#=B`FVl6VHgjqs7tnlTq8uh#{7j^H;4Q^*pJV
zpO<L@7@cAm(}|#kMRq3XU+XC#7>N(1?a*YWeDmdEY7dA(V$64eR`49m+-yCbCNSsg
z<fOM2iwVBzy}Eb)2F@%w_YySmzrFEqC12#K<I+a{iL8HJWl;Tt{m4MKci)<kc(p+s
zhmNZ4)VQTr;3R<_pDgyyd0M$O2;=!?`s4iOH=cqEV7UN7K{0Nu2+`jAnYigL?zG<-
zKPL|*J|$4yrw%u$O?1T><!@lUkpk^790*Xv-)9h-xZYgJ0(K81o;B`OO+}-#MaUv8
z3_YbPFFA;REpEX1Ou~02<&MM}TkO3VGqThK$Zn~dks!TgoeuMilC<iF^~)P92@br<
zoessj@<}`Ww<~Y><dF2maRS9??tn3ksBZ7JD0cdHzPz0)ed8-f2Shq5AES*n`T&i%
zOKNL6qBpe}=?5LTH2C2PNo)0;r6N+5P8f)LXnS*gzqUI>nZ+%m*OzUJ@uLI^gIp2*
zpFj8`zgvAkka!>|jZ}>OjQRE#eV1&AkpaykyPmlN8z6+zdbn8it4$BakEr4XQm;sc
zRSaCF;0F?ZlgHB6_&nCXNYS|!FpN-5Jrt5@$}mUOLeZJc*hm^AlGHjW<`XFWsVxzF
z5&@UAubZg>LP&t8LrQ=rl3ckJ5LS5457<o#1;D%$izsuPPthaCOWDN$ek~IMq<HfZ
zu&mdjfO}QlmxmW`3<)DYEFd>$flZs)1*dE61i%?ProqggFIuHm$4r#PbItnG3k%><
zd8C)keZX%t50{6pa@k3F!49x1gaaEcMU?P@OY`hR`2aRbBvSf{zRG|q><5D?Uj>H`
zGT1Uq@x%JgNeU$Hbb@7_o@Hc6K;7ZYw`u&LUBs7?N|#T%(DY_ZoTWbrf)ig63))h%
zJ5#Skus)>BaCNDudV7_E+Q63|oIO*Zx<8+(o~wc8Vbl@z$f2fhZxhtHBx2tHs#bS@
zPqFK&Sl|Qhdusj$$7uTuC^LlawJA8n7||~`%fEhA`W_!Jo30A@#!L{azh|v7EtcQW
zllM0*O0!KcZ?b!Xf*fliFAjzy_lgjj`Q_z{0zD7A1fxX0xS=kR+TTx}&u9MHPT$2b
z0S(COGK{jkXO%l#>|m56wJ$Brg<Bun485?A>jc5ypm3X46+tbN;^&LEfZZavx1T6}
z^#r#HcJsXmqoqP&4CYkrc*7ac)Xr=Ol(i8E(e=<E6tmm<ARp|E-NoZqEiClQpC?f0
z;Tmv+Ow=o`t>*fs7}8(W9b2jXLZumY;!3%sGF0xTj~caOG(meu@%F22F;i`tif3W8
z|2Uuw%lh!ms}XX5P>C^Uw+^A|W{wTrk6qmcaNoFOrMy2OcYAshf6A5H-X1if;K4bU
zT;*aE%)l}K8B9cmc8<&|SU|CQs%XU^m<?5k22D5y9>g+7SqQFMs=5~BfKWAcG^u=P
z7&)F)PH0V{cM}o|zNxU=OsIJmMIYvs5NQqQA08<(STPkDzch_xdXf9hWVf$FlLjG_
zfcyL()PTgJqBxX_-`L5eR)Qb9{jsJLfANq(J*6)sYDbY~`n@!!?B>KjlFqCC=l~=0
zZ?gm1p9OWkK~yFj@Xm#*YW*f>YV53X<g}D_3IkQ<PpI)aG++IEU`QdX)@)1k+y`A(
z0d|Y|%42@cT%K0>@G0ZP=Kp=1Hk)5u8IP8d-lCuX)57Cd$Kz@1s7?R;qbax5!e)oW
zujC+(gRMj5`lu`Yhe2y5_RgmD@wl7b#Cx&GBQo@&z|B0Ii_6%9v^`u;IuF8`m8qWP
z2KKZkdAiUEhIM;*gEn|CKaUPGiw**Ph~G@5d&3-@HcgW2P4TKXYfHDKNRf5KYc|#C
zC{FbYxBFGD1{;=9*m3gLT#@OmB+;e$9nb0QAJm&d0(>QD?O7u?@!q=3yH6jrH0Rmg
zV1CgS_fF$!D?{%~@XD{%+q~ZeerYNHy?_nOQifKrmn<yL1`+ib-sdCMM04v<L#j#+
zw2F9coOsu;e^O*-{cHyg$K+l@GduH+j^d)KN*06#b$Z#Y&yy)^sk3Ud%HtwA(i)fn
z)9QkuyDeIrXMseAzvd(PMY7W3>y{Z%-(rz9d3zHYdFsxvFoxWe#_?0oliFxT=5RgX
z`3ZN4F7C|mRZBJTr8E4Yibwc}C!LDM|5RiYS@h^KT{<fwCVrxae$hRBdijg!9_%TY
znBO6*^m2aJVrwk-XsG5i)o53-j%_VGUaFp%KFN#f;J=R5k0a>a^mSY*LztN3Mg;su
zw3hSN+;6SGnC}(&Ky$n<h4FqE%|!<C?+`!g-}~<~9)7UYI%$s1B$>Uqand{l8XQ0r
z4RY=H$dhTCPUDX5ypXd-9VxV<__i2T*0!0wJDR^wvoPeihqc2{cI3ZsU_02VMc&`y
z$1EKEs(YnQp5QBz3H$U5yG}eHKD`TpcU~7c*^OqGJA7u&P_Z6O9<4fgV7P`XvC#@}
zn=Xsal<`7+pu5(x(dA?CA3h8J^>FxP;ntxeQg^nCkQ0qQK3`U@U1P{t%r@H@oxhht
z!^9p4orLZ2O({ehS0hiSU2zqf-!_1IKtgi(T451Uh-9zw>Ap;1yuaVPK>jBFd8d+J
zV*$wF-uEr#F87s{Nm^dbCM}M0t(t0%W(_86r3b4z<*qrR?FODtrW!AZWUHJW;+0=l
zj!F)g#|9{puHqx@vcIZHNdacPz-x8-$5h=HE{PNClL?Z^;;Dm3Bv$a{JHW25dv>ly
zoA3mccl)!okNk$*L5Cv+N!G>v%5y29j;5`lR?KJ9M=F2~nes*12krEbKFe9p=wb`|
zMjeS@VWeGp>n>Ya9dSY8>6b@6E(z#SBf122=je^ZE<Hwf=wFc1;_TsWts4gH0mGA@
zWcB8gp@<Y%*pIR}79+uL#SRENd3;n<R94hnaBc<ui27fYy;W3{aT_oC4g&*7DM+V+
zBHdkss0h;C-Q67nC>=^SLw9$hl=RRYij;K2Ah74#XP>k7IyZZN_j559@A^N_^UJTy
z{AP2L|2%z!9gMnfQl?$Sk^7G8fc+e{)*CFj&;A@1&}WWBJRHfA;CFy5$|jm<9rp%Q
zKm>YuiYC@RhJn4ZvHO&gb}KHU@yQ9x7Wj>^p7k?q$5fn2x>tp#R34mQ&B&#3qmV9B
zSir?c(N)g{fcK;>_=!@s`0XeqfKUaFw1R`)w>7FKH39JI6}4CTXh&y5@@Y=03TrY$
zHxAC4n2G7TN)~$Af**QiFl0)?`zWX^-xJsJ2t=B{3svmFvK?2RuDSu-U*5}(;n`eW
zK4Xne{UhE{@$anaiYM_6W^h2qQ0Ac_7#7>NMVVcTi-_WI;RYgEA9?7m#<D?em^Ag7
z${V$soX|K(jhRD9TVpxpv1Q`-UB5@Os}MzhsFCWiXuj4HEb0skZ+~gq`EoJ(^Lxh{
z1Ajii-lF%Nm}tQa&V;p5@D*34hQFnuz+(r&^Y@E40_=ZtQNS5|LIME93i=H}gT9>l
z54Z6ypV}7`L0P!!=8B4}Xzao_54p~-@BpzW^J#red)FAV;AoF|%ChHpAe;k?n%T#L
z4#LeIn^e_y;LDz(1_+L$_~zM0hP?{M&>nW?@%q8$W9<5@t*76&#5}T4%scv?dM&qd
zZMM|~6`$@rVY3D67f0)-kZX-B+sNM8;;#~U-@8gwPMujVE&1NPU61zEJ^Y}MQ*2u%
zgya?V0kMc{mj6{(A7KbhTpl)3bC}zm;Ab8-e(pd;)hs=FLk6G<mvf!=z=hMFkmm#0
zbD#J&MB(Fz&q#>jJX+|H03@p6juJV&#iFB7te%&%?7?Wwu~R!f{x_z6n&K?&{F>gr
zc-{@~jexww?8lBc&f&Jq0Hm&4DU}$aUG_32Rt71;^`Fz_*y?Ey@l!u1HOE-DEyu&Z
zXJemWUqzO{qSe$GwKw>nSoYo4{v4~e<Bt(b>kaLm^_DR9uXH=%r4r`Q6HNe7`!87n
zG@w6U3>(Ur4b?d)m+DbrBsmG1sTd#atoXJO^zuu$6I*v-_mM^e_`<QS(^T1Lo?#Hc
z)(G(jU4le?YZ+)8bS~s=nOzJMzEA0MD!q!xQHP%S<mX$=%hVZa(bJ0oKH^&{9Ub}i
ztI-cmEY-TVMM-KKJ!CYI;NjT5iviK3*KO)-h6c049txi>m~hd3*Do3XE983B$=B_H
z1Z0@yT_T#ALHiFMGy@KG0@#Io{L7(YQKNyev0UNp5r(?Mv2X5=lkSdD{}PF#@Z_yQ
z>Sy~Qi6pj(7r&D1ae(#WNukxsGif5(Xp<S5y=h%3{Z_zuy}hF_13+kRJ0f<R;?oq(
zd2Ta1eY?|zx{kARuEm%CU6cR~7{Oscle8*wt6m1LZF!ij+S*^FoCP*#?OOf&j5)T_
z%Om@e3U|-%EC2J8`vOp#HS7$kqRP5cX^8~gwwG0{&&@d)<m8L4l^S!1iyMMYE6<Y(
z5a8kJv_oqNGv9{*kd=wgQ6>o{eH+;uv^=6}Ti-V8cs)F<qufVoj2_Id0lv@3+H~iK
z3w3q)cd-4xPd&TFe=YOf=PU5+go)yb^8;jdf}VyUXihPYcgLYQRz1gT#eb<^e-x4N
zMR?o6$XlT??DOSA$UuPke>F1to^k%mN>dQef#k#)2JWM}a08;Bd=oEgZhNC@Q}Y9i
z{$>DTUzQ>AYa(;*_!op6hwp0VY#V<QgT3$rBil`@YIVtMi7vloFX7rUJC73h(1gUt
zl6yo@)QC0yRyZ0b{jh;i1WjTFYXP`GT@nrf>2=>Ri-BEw^<ln4G-wJ4BG>yY0-Y=8
za{u>_ZvmGH$=hLKxH=i%ZDCSi>U2x6_<2n>2!1O`Ysj|y`0r8U^7JxYFOlNPDBz5H
z*P0c95-x9o$NZA5{YE!YdlwJz*SRq%@6SmTX&%z?ku&$)Rr$kSEj~{UhWI*{WJXRU
z<lE#f_g1Q-o!dqGL`Pej&%0KeXyep^QA_DD=spw;6;7BWT=J!ryz_EyKRrFOrfDY%
za4T=l8f5YLeM{!uGM|}!vuXNpvkD+kUEBE&R<gN3t@9k{1Mr^As>--i#N=dMYwWi(
zyR0#t7Ot;>z}+%{=$RN;m@Uyz%XNb$O&wg~2lhTEjV4fPTPodnQCLQ)ZayL}S3|(x
zE@qM1b=kZO@b2)u>ggO}x*P*R<0gQZn>{NdJBU;D(YnS}8wg&jRu>niCqAslSj&CZ
z<Y5p7vwR(avQ=R|Q?$^0n(u|>djk6E-}Daq3H*++m6Xkhy{PYB$@s$##`tN|aE{-T
zukDqq`m9^YFRq=%5vXZ^2NmHe_f<`x&^ws_U2Z&@Om-IFiU$biKWXZ_3W_LK{dM{*
z=HcSy)~f%LW{1)`$<`Cav*E)`eql<TA=DI|?&d`OX9~d0`Vdut9h571`S^zn20?L7
z?Wc^uWi=Rjhnz+IZWG3aXKn`|o$+fp{Hs~QlO%+KLBfTnJX~LXFyNSbs6&3rIwBlQ
zdBt43ICB{j^{6m)=<}z-z7c{Cj|TT)Q}1W#!j0;)hs~;%G0jZUQ4m%l76MLT>R|E_
z%wx$1>@8Qb0S*58-AQ0VTdk`(S_3uTd0K(j8r6(&EkB(Q(`swhzmu6&Wsu!}5B#A@
z6L1oej|`{oTMFI9b{<kWDF8L)_I5I>Az>3PRRBSzFBO2~lYh5#Rv1Xof(zh<w;OX0
zq^^ADy4{qRT{)?Fm^PDM8%SQeJ1}JfLo8c^9B)Hg#l_=fJaxLY=!AZ~shqV9oT|)n
zhc2<x9p)c?F9t(36P;t2`5r#8;o|NV*NRcA&s~PGXu2f?z(Ae4WUYl*{)armfe$<B
zpS<|ikna}nO@Z`(w(}@`Dapm(dQ!e;uRXM@roY(hb2KJlXdKHI(f=x37ys~bTaovv
zpi&t!`-+<dDK<o94QxNhj-fA2wNO#+@!Gz0Dl>vqqrysmK3!*&64ft3Q#RShfH%ku
zdWukYZW{T`00^G+2-HecZ4>1SUtg=TX<S&Y#%Gzt)bbE5H0(fBOOo<$m49mc;{C|8
zw9=5vt*D@g1LN<h0tIp@KAxq0hLrSu>ufB|x{sf;p)!Pc6n)mpz=1|__$~R>nvLV&
zkA=x?2jJ_vahGBrC2hxxXL)X^kL+BAWoVD?Tw<o@`;);<r4rIH$pT$xN}=sV6DiY6
zKh+X<&TU287`ht09nw+G{fgdRjZI~c6(crLc9$|65d65=`t>)kk7^F<>oSMx!QAU7
zFE(Eeu!@CX1Td6oZfXrh-QEGa$=dkD>?8w3$jjDnlQ6#3wiVrRydxgPjA}*9$t^Am
zB;B<X&3jP=!ek%Mr~x%jPX5x#aNUG3?b#7vON4<|)Aw3tz|Qdi-Tg|lYp9dV$zAlf
z`d5xeIYop_A$6F*uruu(4$jI*S!GOy$kK~0$j55!dCe;xcwmxQuny5ej(ijU-GyvG
z<$Py=<I7nveBuK0vO=WN<u$7NF4N}4o%<Z@eh1&^Kv4&BW@u1gxNB##e^#dfI;keC
z9`%nv!*4zAWBg8<BgMdp>s&1ajW?sh68>G3{hX`BIj%K@$%tUW1_vh~6!#g4x#Ir;
zNc#UlO+6{^HfZQpDE);jPH8UwWdR6!r?)5GAFQlW#p$_(%`%5iLKP~+AkiLo9WL~W
zT!5Q{wL1GkebA8hZHG7?8Bw*e_u5ZYosRkJ|KL}<?>9<OZC`PEJrSc$`w^od$2MVP
zW9`;I6)535H3rlmg6fKjJ%Ptl5jNvsekGMwwOJZ)3^A|^rpR&<gy;TB{3`P|g;ZCE
ztdOccEa;P(=HSV>46p?HXJ=rjU%LBv-;8&EcwXmXj@d&zR}Ae5hQ}RF6mf}V$5JlS
z(DlQ;>PsmADPFe{*J;Vle|mb4dySG~(P384710ow9Tt?@p64Z|f#V<sz4hI{t0Oe}
zh9WA--=|5y-^C%h`IAr0CpMv-$^o%jzy)PBxIr#jj2rOpI9eZYC4gBZrVvgZVZFli
zTUQtYg%R1N4JPtB8C_z?fg=T+-jU+(V4Zv)!x)rm^%mH|8WmLlcj^v4KeaG0eRhnd
z;szqeA5{)8@vfrZ$ZsF<C0jbNe|J2@HVuLMZiKLi=Jg<=0K_>(s=}M+U@Bp|Qq_K|
z%+^XB55-x%i1SSRC$AR70!VvwB(r2S3di*MWMShZnWN6=3xH%b`%Zz7c=oOvCQN}n
z+UB&I^$jkdk6iX7fKr+kh;T=fdqblf35@b9tnaQh6Fbv1vXPf#O+q=f>+;5K4?<8^
zi7UiCB{K#5R%Z+J!IDQp3F}<3>pqh(^~V2;IW8iRwp&dt;P^Y;ttKVh_f9}CxbnPk
zCuqrvR!p}H1Y7mv$cH44Pjc`;bq9uwfnCWg|FGC{aQF^E%3fk!)~lt>X`=<A)kTS}
zFG3#~T*72F$Uj;CZhdiineYl*Z|--S{#s>OP~`bf`QW!XOz-2^gg@_|!Oqx$kGiyu
zrurPZp^LtByPlL%l(2`;Q~twro{EK@uSMhIOwYs<89h}C?;DamK_ca5Lv_2|6Xgdf
z{RQ*lLNKI$>{mjv5KEG^9(2C~wNpjr?P=s2(phCMHI8gUwNZUl>n)BYne{ntxM@(=
z=!^UJL}_=R5l2+t^zN3W;Ut-iXjRtZhO5SfK~Ytu$h&M7PG-Y@C^YWbz0DII7guT8
zfU9RkdKEt^pc&nFMActE3RZa*eI&GX+@IPaXy~Xfv_~p!NpI#DtE!R}PFVYRsT^n0
zs_1D~8v1J5w(sk3Ek8c}JsDLh%#BLQ08-a!m`5T?krO$FlT*~H?g_RD&u2G!g0saQ
zd0@v<{q=z}1|IJN(Pl>58F@wTZP^Nb`*68^s{GA%zr7Ui5N~A+{Y3S>W4-r5IDe6+
z8x4kUbF`sKT>mK<gwz-+l$uC<9ZGt!?K*)rXL4J_+^1Yz#f|-zt-k(9LCX~63;y2H
zv6@NMf4$hHi;Qaw9&T{onUL49*v5YRCOSs()%}C+BKHaRENzMC6hlY{_D36<LHJ=O
zC#toqn2%iOtFLcA8hrf~wspP>qw@qXcGObz5#oQ>&n4GmKbw-$(A8K?;7V<uqd_O}
z3eeeh6<erjwe-FHk-DwIfcJG~VJm=H-{Fm+ZOOa68nlS2JFO8MvOyMT>43?<9&B)P
zFY(NYk}PRX8bT26;}s~i*IDuK!?{K|mtc@mv3s?w?-@1Ph2q{Aj|}cQJ9Xl4Pm8;`
zcG$}}=KXJ*;;z**Mq*tn2Y0BQU*scGLtnwT66ja=sPA)|<jYBE+qSN(c@hDE!5!@$
zZuJS{vRI=shY@Y2-Bm??chh3KSFCPY3SZwf-PWcCh>f`DnERidraL%nH4e3^Bd2hf
zB3zUYwoHlAslsi!wl%uDJtu5?tW4Qa(WRJ@VFWE<!vbwKsgxW=4*3HqzP@c)m3#To
zy3#>k4N{Ni&A3aR%I9H9b+me(yDCx=xCRb%`emi^r|aVmsiD#Rl9FcIs>5L8IIPL6
z^H>;~ofa8JHdLQ0R#Ph!AW^`_yx)&%oF#Rpl*w+riM`kScI8R#x1f5W^rFDCDAJE*
z^vXuZ=dUU!A6tThM0;EPUAWhYTVU;-E0#!q(T;#@u&hg<c!awz>p<;Jv6ykUU1gQE
zHAnHtm)NVr;g^iPR*!c7&1KQ`6x6$xw)dx=yja5GOhNoVw*|WKvQoF`PZ>Nzk8r9%
zGI-EA>&D`jz8R;m?c*Rby+c{`J2kj~xz62S(Vy$PQaQtSZ&cMlT*bez4u??eNRR<~
zz-Pd%+W1_RTa^F#e7z?g0s<4C`n%K?aM$k11}vF<A_IIRvQ*PRF5pJU&pNW68jk=C
z<gF_kTWmWqUdzu0CmoVq)AM@rpKfG_EE7fFIy$EjwBo}`uUkt-K52Ci-+a0k!)XYz
z!9%wvFR)%1^`Vl$bz0(qsy?AgHFoRCZ#FoZA6Xd9);*Xu`e6w|{4)(=8{FXGU<KOr
zBoO$}AD5Tl`z_a$WP#Yk3F66R&r16UqjXt7mw}M$6%mS|3GO}{j-sHX_QnEM4=NcK
zjy;9^HGvDyR{6lV9CI+Dv(uu&;pikdFTb8bRHX0?iF*QiE_gKmvO))j;FF7@9{r_2
z8wiG7-Llw_dcuqyOVY=U@_DZ2??B<w;;-chu}{LHCW?Yv_edvY^774gapE~LfxK*|
zZk6+p^gD9SbR7CqU&v1k=!g-GC?2yI@<}Rzik00vdI^8fQ*u{V)A#Ch$6FIVbamPV
zV9pUqs`zs$9WTo#y~1=?g&E8hN7jJ^<@zD9nH*&|7hj9kQ@^X>{c|}_f70yH*a@Oi
zbN~7NM>u6d+n{_rrUl~lm5pH_%4gyIp|qB+hBkD&)4$TcuKGYDhJU;#z)z6+oz&ZO
z{DNuHZ!G-y;j7j4j#oo5*r!*IEx8ATuWhcRGp1hP#~FUBeG${;HiuSwpTw6WFr{;g
zD<!~*svAz|701{wpYy1iD%x3uJc<8F9QpDp8_}buGCg7X*z4ALd$&K#YOW6H32|;N
zW+Ve)Vs?gbpTDTulG+JtEedO`a$W(8HnPZ9W$AsYt!eLYu-iY-9iPy6QB2q~w-%Gh
z><KM&9F-K?ZbBWf0yuCYaOJcB{CUyUmwKs4MAhtEHA{QSoJDOp;m#R>^Vwv!H1H6z
zCJvYACamR>mlG>ajO(&~pih#0zgnT<Oveq!;pvSO<oaA?s3BaRo8_aO_PU0VWcRiI
z;$5|992nYNF-dp-<1i2tW-y1jIHwQH0f@DQasZK!yu{td0`4b^X;CeK=>ZNRoJC5H
z`y_PtQO>5}YhB03jdz-7ES`JQAb3P6rtjgXgiUtW1<r$Q8L7ra^}J>yx|4Of-&y1B
ze4&<!f$I5V$)eZCsI~%^2Qt{z?oWYo8DO_LN2Giay=c`3^t6GA{`=v|t;)6=fUl$N
zK0FV~j96Asr#@mD&&rviD*8197+KYq;iBYQax%>ToW~Q`{m^bnaRg{kHX#jC<3PIs
zxQJ;~*Z>2+gN?69es|IG68ciZYr?00!T~73?pO*VAITqa^UF~FQNO!UPaT;%6c`jw
z@<Ivp(KJ2dMXL>6UId)T>gppNIM`Lv!F`D#C7w6P-K+bf35hfFOsynQqKK}qzyW)Y
zt0!II(6`TP9beUkXA3wQi!Q05GlX<D=id)wLu|k9t>c1zN{H~3?3qEGNwq}%<3B{5
zf4j8ugjJU_tdPhqnTlO~{QbuCf&WuSbD&T88EQB%K2MO~D}3Lx^(eZj1UHy66xW%*
ztPH*qZ2Bo#|JqSdArFBIxT$rM9scZ3u?!RkK|Qq<yo_{kSa&q13o2%1ksF|qJ+{M(
zZu~EIzbUA4W*S<<V%zz8x;PU?zD#Cw>~}CEL4-`@)ISprwX?;?j?ENC>+*CLH_E9W
zAGW)bVeOkEou==NabQ>JvY)h0{b^G2Bmt{DRLH3!&d+rKfyqEdL(N<HXFWqeps~qt
zjvw`Xa==W+Eitk2JOL}_r<o!vFLGa$2Wk)7GD#<qZVS2~_d*zXF*^Q@M}<(pgH@4#
z<q0tWI1A>I1gfs_vvn6v-wSr<|2GTZgbbjl4_V*IpL(jEPUt_!JwWtg^0EUAUC*N)
z+am<rmLTvkW0U{t&e+I(#(D4`xJd%_SQ7=?Lx=xhhnB32q*eyOy_-IK&I}W)0+B~c
z5Q1Q_rPEerEp?KOw^eziFAAazI-*l^_T6pmN{3vVG4lITQx;#J*Zc=tn!^$$29Pfy
zRzxSJ;0CVU^u1ktHD62Ct8tcnMa2W!db{ZwF<e+zXKktH<Ao-hDXdD(mYIap&^%ha
zD_}l7vmjT9XA40&;o<J_<9&oq$`2^wIxPpqKM&HmJ#$@J($GIP9NO!CbdY9&`qLaJ
z(Af1FR9}k&OLi67($j*M8<x>pm~1C)RqUf-m+KGCvK;B(uT!NZB_??qHl=`Fzg8)s
z(<*U8k(oh(K4H!p+!=ejIg}^m87_kBK!pji9TpU^&9wjTN53VXsOSX%2v=J)UiN`@
ztLwXc0bYi1bJ$g&Eo7I`1AY%BH3K6&Jt~M=X2IbQ+<0MMWq<noC(7}Z4nYb}UNN^-
zW>1piw1k|kbn0P2Q+|iaexfbusLyrDExeL~rB(ai7<KYE)e8Jk7c`D%gAEVMyK~~v
zf<Aiz3MQ(Xvhss`!aM!KT8P7SL-lQo53l0sX=r~Q2GJQ}K#5pKG8Y8+3Wjpnn8n{!
z$Yub2*7mEc#u8@wM7=14>-|LEADfiM>jyq_O-@Eq{2Ax4=Tzj%411cqa@<d_nfA<K
zX2w_gS~ER%Z#SpuepbdeNvx_lh*hiP;sLH$uwX8P+ZA9Es};*5T=dW{ndQs!LSp03
znlFprc-I*$!Co#W+e#&3Pcp`kYTzi&`*GVH1%zAM#wgGm<$~aMTvA~K9y1I5vR*>P
ze(9;SXp67oW!YWi<UY^j^y#$Z%nl#VC$*}p5iQ)uB2H|N4SWZx!(pIMLCg+@v(Ggy
zS9q=+1m`^JXrrw^%@@+~+szc3(rv!}Q(aooWQxHM#-w{+R4~hU6B&2g^k7$Y3c0Ft
zd`H9fgFR4gt&0f{|5c;lVN!F*<T<j=++++SG2L)aSFC0t7gb+vO@(8Nt5iiG$d3E;
zFn`sv*~O+=hIKCw>s16j%?o4n)EZ^B5{*TM2m&cb57ivN_DF-GI2J{AKWsyG6HxEW
zgl}~jN{o?_VXHG9Z}$^rd4Of7?xRBVs0h&DI~Q|2u4G9vPnMAH_Ewta{z?<@Y0^?R
z$v~J@wc*$c3c+y_@Q3dpd836aj4Nt<Ut*W3u7+Ea&$bp-YLns-+U<~w!W<<V4_G;f
zIZoskG6;m&W{*ebI)AUkK&3`|Es8xJr4`P=7_Xf#dF~2*K`^AY8d=xc!M@H5w|`F_
zZ>iu~Xn_0kR{-wMUVr2wx=e*%>&0FYUd8#VLx4r%c}ZiHD$pkGYGC3(aF-N~B*sA!
zZ+lJx67|&`dFxsjT7w67lQzoDIPwAK@1Ndfpdl;=kQZ?PA^_OEW^-!2!2p(kamx?L
zi%*1vD~iuyMcO91^xw$tzE=l;^Hjx#V0}SPBU(b}|BV-ZqnE>IEUPjDu586NZ;Ug#
zTsq5M8X-MmuASCJgWrphyewj9X_dRm5vfoUt*GDB$`#tbay+)}R#J}*X?N(_-4xa>
z2TSe@vlhqPr*)mJZaye;kak`MOaTqk@)D`s#QxuEAe+zdPRU}w%ql*Lk9T&J<5Vaz
zwezmaR2&}I(i_g=N8bLG8oi2ZQ@{H6-@q^%VH80L8}*9=rX<Ib6YEW&C8Fpzi4>v7
zdm-kqTw|&sIqJR-m%rI@b3fhFt3Da{oh;b@TMy=gVE;kPjX(P47}Qg5jEifyXrrb+
zbWo--Ts{eW4vqR>uOw=LVFF*w@xN-5_@_0(Qa)$og>O^_t7=uLnle(_Ufxn;CCM$Q
z)aA$#nYm?3DT3&0Eb8ay9fKx#Rgxzcfd~}%Q~F*+HE6iCPHigi5p3R7ZHiZT<kW5|
zyXFHhq!IY<b3G4OS)ehg6aD?2tn&lXA35};<za7UQztXRB;vOz)xZUApE)1_etYis
z4;6Z#zx(&hMpILRz}>ucq{m0P(WV!fY4zL-;>7v`_HP44u_SD!=j6<`x?1wWv}Y?u
zp3vQNKb$+d-6oVXA1wkGagDixYYvn!@z~Ey)&w<#lp0>YgJ1R%MKa{Us3cnjxhl^W
z8!%HLW4B&ba4XqrfwN|HgS&T0oowonaRkuo(O@7)W+QG7{tsZ#9}U8UbxXr?v%A7y
z(%(P%#`^3`Lw$M3>i&Ltc%9uC<WC57AV9yBMb%4_e~t`JJl_p;pn;MtyP{*o#p+#o
zBu!Ci9sg#+xZ^x$thw59Swb3(p{4yw-U@&9T%sP{XZ3NYt4?Pz(;+Zbqc!~A$4G97
zd^lHPT3RGxmZGN`(xb-I2tp$O`m+9}y6o<WLK~#RUThnZO|>@P5#v*rIN9rN9mWr9
zv9vF|6#LflLq^;((R=^BxwyWH2i{L1PX^MgNiJYFs8sy2)dkoB-r05t5SWFEEq&@R
zRRuo@O>G`R+8@~7JCYN7z?vdpS*VtU2hl~#V$uyELiMMvHg<2yltk%hWn}a;u!V=-
zLEvR`>Jv$7OH4*q{pfhN(r>p^vryQ*a<AhOWig6h{juN@2FXj8pL16mv$<Ugz2fwp
zTUdwu{r5tlwD0ryM0ZuhccH=#<9@Es1AYwNRK`*LCd<MMFM3E5CJxd3DigxNH?rN0
zI?KJ`0s1KNJ22mWg^7p<&5c7&5fkQcE4`)Ifu<yk!csDyH0@CuA_2JDr)4wY>GuHz
zL)_52aVsA$9f@w}+Zg)d7~8;^rK2_t&XXNl7bCB?o3Khp8wV#P30me6_4OIUD!n-s
z;mVgo;qrv0Em+PSS(E3aYcuE;f4UB68#1&fbF7wKkFfC+A9P$xQv(R~UQX^MKWqwz
z&e>%bP=IUF_j9CA{{$E9Jc4>%l`Lb$)tNl)U><u2p2CP<+MTzf<apjKJ6iWy4#!o0
zr%iNy4Ox^U>$G6GK}w%(&Cow~DfW_?VwQLifq30LYH<Z>ap!G@r%8&0AW!u4_OtK-
zzH1CTyPx``I|?W!6`Tz6;dY_BzN%|#y1qP8P^HwetsElDT6M-n-20%Q6xd<Y-x1(S
z_YV0rl4rS?<&)?$@I{L`%|kKI1$}x_`}QyW@oUo%XU8p?3&-l!6D4lekF;zyK?q4Y
zvv>(pF1+dE)ZJbRJ@(!6Pt9(o?QlL5gASbJx<{at{zB?QvE{-9NFO(8_I2(-oaVI7
zQnk*$(bZ*&!Zr?T#mv9~WgMCz*qrf4Pq)7^VbO20Z-tVYlG=pD4_@AypM2Gm7R14l
zIhj7d1v%SEXiCV1ZHdhZhvv1rX}1HlW3eKoz(x}X7ZVuz*qiz3yM{I`2)e$)Y?E=<
zXX>;py<Y6-g%1eld45=O(TwuB{tRmCbqQuL95sbKT(bJhCZ7+j&$+pZRLhsSBq{`+
z3?*$_x=I{C&Mv1I&)bCz_UMV8B8#14<i=_VMAJo9R4cU*?Ucm!h%lZ6_pCo7ZTRG7
z?!qeDQ9ZD@KE~)t_UQ?ags;0Xwtk#NIoZV%zB5zE9m=H@(>pK4MXIL0+7XQPI{O5`
z?tWMYc`DI)=a|52J{RdI?rRt@^>NLX@p#O3+eZ{YDlLMU(}A5knJJufOp*hmubVt_
zX!^8+AHuIz<FF}~!HgV9N@Wc15j&%r4Hzp~JDGeZ=Thm7n@Np1hyR5Nv?op+ZJh-W
z21dS8eVYIf4g)J>5?rcL&S}FB6mO~HLW@a>BN%-N`36{VLw31e5}WZ@=q{<<^Pvfz
z-{AvpeD(RVL6JM*YC4tE^q(Y<tB#l(($9mAF@Sshf#qOvtLHQpFooi4_uFB0Hnw#W
zM4)Dx9R3ZtzbN2VsKR5Kmn`IM_cJ7BvC`5a)5l{eq7s{k1#k3plNZ3t`>|0j<(r7v
z-KH`%sCkauAG~YpoK_0^wvbN`etS)4MHELvhT*p%tb$eI9Kc=CY(PHO?<%vu!vO9d
z?SFc}bz(=iOM~TqohG>!BPV^VFEUlQMbB0}iwYTUe$#pYnu=D{5Qqc`!?5kGyr5B*
z+g#8I8xISWQ$g}q>(79D_p5Gu*n_Y#@@l6RMGcc(!zhZGB4}jMy6~0DO!RU;2YJz-
znOwMj%i3~tQZNZ|n6FPfSyQtQ)J<Bo=aV&ehm+tRmy*Vj{`)wAuLvD~I=5U~Fpxv}
zqk^h&gAg2WHHw7%hR^tt!);tOzr<wL!Ct9v*m^zPKmAC1^Cj&VU^S(uxZT5%#l3y*
zP+{b;HhX5t;C;Y%+>tMkLphzpu~>a$*8PDb;V*c@IYI3=Z#Xu|od<EoR+aWd#Z>c?
z<ih!e4DpKOd(w&0K(rPX6}2c2pRHB<t>%os$QmhCmCiuWhCS~GO9W$gj``WQ*WP_l
z*z9Wb6?<h_qL|XESkX-d2#)#ulXs2aG(=#JuCAM^BFg#?K{{XK9s^0U7j4sl358J;
zh8xck7>;R~01I;;sadiUX8k(nmu(&Aj*gqmQBo5f;Y07(4_D?R_xiVob6OvG`tD^<
z<NN}VJ|q&2%*ESltm_ZqfEm6U;b(xk9Tt!UAtr9wJ!9GTd3Y!ONXgy@fz$FiZ9@<t
zhXGIbMYgX$D~9099b}fzYjQ8x?~~wO5mT+@2kc&3JisOL-ub<&MFnf@2*sc&7=$Mv
z=9vB>=lF|^;*C^Dft`+Yr<J0M$*wB%NLjFrhb~4^hIwImLs*u9ubX3UHa@U=f}h}Y
z)?x9X=rZa{>hCb?N`w0Zhr=q{(n$=hfCjNWr&mDF4j=0KzWRdwD$Cn`{RRy1eziD6
zHD8JdRvDeSkEvp8Wlgq;qGnL13pU`c=v{>=k4YXLoA?1TvD<HHIPcYxk9at4OfZ1J
z2Feb|)J^`Rq|<)fYrILuFWZOJ&bzxx<Wr0(hM8(SQL^5OCYg9pamDT~63%&((peg4
zxHu;pwBKN>l`nPfbD0)Jfv0q8zH_~#us&sYZM#%K9(SRsxQ#=Y5+#d%aSZkoB1CV%
z1JtiT_eC|suWM-;Yc|753w{g3-@eUPc=>vkq~@(75OpN=gG9I|Wrd&vWgoCGk$!Si
ztpi**%BbnEUCs6W!XN&nX#M{Xw*(E#D%*eK9qcVGv`fo*iQgP$WIqM`Ejkn*x1vd5
z&2RJmraRaXH%LiulWlY!^K_q}VP)=rZk;&$N@qkP?ikMT%_N;Ha=);@B@Yd^yS8Aq
zvVy&q`fhMp5(9@{D<p(T%+pvW!5{xs)belv50dA;ln=UEow8vjj15`h+hD;~O=LQ$
z5eIc`JYfjs<#{?~Yl=$k(W4FUqpTrYNIERf7RE!(i(m|BHzCUJz*QXBX@ZglvDsZy
z%iTMmXEsoxs9xZ#<-wQ>ZiU%<##pX{re`1>qSrA^fHx3Nk($~J?B-lfd-A{pfQw6N
z<`=azZ1tJD;s2BG6^f6+x7E3|dq2{*4?*}Iv3y)Hh<B`Zv}n_@D{YKbMvj@fGO%BG
zyI+0f*gX@vAN0{KSCbLSu3#{9WopK+6xnb^fv5<oxV6tk(wjbat*Lp^c$I!_v9E-x
z@#aeHnkN1^B0X4pL^JxeqUywZD#C>LIT;b2u=3=DJL~;`u<L-@42SJNDnPiHC5b*M
zGc%)SJ%m9~fq|X^Ju(hcC=irQP<uPSk4HRAyv2ECY1KT!P|v%hbw5<%ptN0O4t3!F
zJ@d=h{@Z=r|Ak55f8%zYIMCKPP%TO`_UPGfOlrSatm2NYI3&)#Df*>H_L!Zn*}`FM
z591Q^1hQALe&r2GLahXdVW2EZzWwV}lHV)^A$WorZ-Znr#!SU`)~=Q%7N6bJzUzU&
z70Kb}x1uNKWf~ea&8HoMfM-ZuYtoY@Ub-Osjqr(`S?F-_;t)JL%XN3QpI%l0tk323
z*G%c24CQ-adBbY3?mJV9Fb~3Vs7SupiQ@{ZR97oAGO|Up1R*E8v=hjwER-WZulOY!
z?ri_|*(`jqvGb-dgIsj*!OzVNSBz)H{`&;v?_WuTz7dD1L}%mlWKNZ!yEi$RPkDvt
z_9vbaTZ-|3VKd6R`uY9IH%99?q&XO{?8%c8Iw$!B2t1IrvWMQT7!R6*pPVbW;)3z}
ztpCHGX4U}!k;vZ+SScma11kzK@k9VB47F4>pi64+*7u};&phCM9tB4$)b+iT!p7r3
zyFi0t2Ac&M`=O7_8e`(P;8Aj4ZT_>-DeSB(BNkQ~G@6)yED0N31WW$AmwClL%90MW
z*`RrucC8px8GY!YU2#z=TLJOX<Q<X=ilEi36k}bzkIQf`RFlq{TKl37?aIoFOl8PO
zmLUX$i3b6({2Na5gAjFht%ted1)-pnb{Na}$9KQJy|@GgGY*DJuPC-#JPArAn*qT=
zWz}l~EfHIjrvKq#eOU^vMq>)eMR;nmqFRJ-y{2Bs6ey`J0-LFH^~)8c+avVJB-vzp
z<nUsm$TnFQYP3?|1Fg}St4NTImt%YIGm4SF4^vgc*1{QmOI5sQUwe0?A8aXM0e#>e
zNs<bd|H;FWSb~J({;*V)G~^6e=wLjz%|TnHalTzYU(_G?>&V(|tm?e+O1|IJN2s=1
z%I-W6qhO4BATiTRzxP@5Ymt-^ZYN#Zsbq&_+Y3CA3$CDTx<`Uok#x`I>pcMBu1Q$s
zW{{8?w=O7B`NC0tHYTn?%HzE8?R#rjH;G%0wQrW52yW`Gd&6RKl??-zn><Nx#L%xu
zXMe8OTjZUmqrng{6b$}=yV71(o|<?q<Hog{fBF6gHP%$eDly%N@Kxk?=!eUZAt?-z
zc9aCV+uGYvx*bS#$0XMD+oYfs&QIaco6&;5m_Ksl8l?c*Dpq?zWsr`l#qY+QLUW1D
zjg^X3{zXX_RZ|ze`#lrv*U$+%|EuEk7$H8y4duWYO2cFSgL5?}ef~@TJnyV@cXxnH
z|38X5j{N0=ZpiE9qi6H(u^_OJ?@ugGXMa~3C$T@mhM1wEV^O;2+=f`?2SCy03*6gY
zwW!@VFXBz)uF!8UEB?d@Qg>fl#f;Wu{(aEpH>ZogpX$>Ul~;>8Dld+@9-PWcbX$v}
zqnCc=|3#;JIQS^%IEwjvPovQ<?XKuBGr7eg@O#63D$1Pd)d|_4j@zf5s0&!7P`93I
zXh@o;!2B3tFTmKfr@A^{%`H=^ws7hqMf@^thC!!stn(X2Ea4|jC=K*zZ?a&`FPniy
zQ)+P^KrF*n`q{S+*QTi0yH~nCzm|^oxnGowWf^TRFDGlOM+%1JwmVY@i90Ku<(Fdp
z9=Ncb>m3y5Srm|;>pkF5O&_I>WX?<nl#ZrFreTYh@#6omtR7#$Jb%K56V7$WaQBOA
z%kVihACJ!US9{3xK_~VZ=XVNpqX~PiLQ>##a`|0SQo_HUyp67=F^8jjI<1w_xkW-%
zCNd^m1c2D{DI8SbkGI?mBd}YftpKx;%xCJn#Feq@sw%T>Zfwk$-)Rl?_^UNA#t-rq
z8FQAsUid_~0XnU!ug#+A^b2(Inw3^rx%sC(jsu1!Fr<$BUDp_Cb4P<c{K!!F_v1hs
z^Ue~|bC<$_5CFrvPPvwwBho0OT=t^S&m%m~=`|cw<zKz)_7CqeUFfYfvBPeVXlJNa
z7YsYjp&^Bhqavs93_trGzlgaW<Rw05+Ou3Is%F3csq*FToBlcvmj;d%o`TW?mBKNe
zyYum?&cLJt&Hn~r>WS@<qDNI}!8;|jk{^_BOFFDu-qK@>8dV&_!Pjqz)vD*qy_lH-
z-=J6Tn6VPbJUNKuf?gBgv5;YD%~s<9`k0@Oek`<XK-$@Qc{NHx7aKlv7I9ld)nd?}
zp7(+&guW(lQSqRH^R!gLPBS3C)p#oYV2EFE)|i^{TW|*oaMcf_c^#U)_&0lFOt$?u
zra8?!dKWQjDL(jJbilwqRfZ?+G?&ChxPDYAyp~^lebm;VJ*WkhsLnj=;Z^NT)-_o}
zv~7&y9J;L0v!4L>|9)bGo~9jTLOZ8-e`Pp{E?ldhi}_(+KbRz&D-?y1!{zg9>gz4Z
z;S%i^txdO!&<SGT^Qib!)BGWseHB)c8M2c#p8pulra|Z@MtVFUD+4c=Lg3v1RQ2uc
z3F14@A@vHPK7C69$22c&E>F#+WKPzx;YQd{d{yenXGm@_#w|@qq^F_5vI6R@$tW8r
zKTf26U|YDwNB5Ti<kJjcfAw1P3uCGt&RTWnHONQT`%5C<M~-PSjGl$6M7|5bRcYrH
z5-OSxlw~@*CBJ-6&#MqneyR;Zdz=q^z^nPLPJI27?ALvA|A-C6asQ=rfbd#(af-7`
z;4)-)deU3C8s)=sTNzWffl|a}8qhIr@RCx0HhB5@mQq?k20ILsTKHvRo>eo9a&({3
z?N<{(TfI^w=kfe&>K|Ov#MC{OOYsa3G-T7KokD$ZAEe`m;{1XL>2=Ozai{NB#YmAn
z7$rt<^QUGpueX24gtWskFTn!NTHm!6PJ8pSXUVMzS5%Ji0NB@W5B-)lwMN}j1jf-b
z_T6Rm=G5}BHWhQ&a5fzT$L>vyr_CWG8Hc{OFB4rD14SVg2g{zOM#6qDw?bin{Po07
zvZmdDEPozI=JXV*hCqFRwN$>{HYf;v(2cvj;gTAbP2%L1!k<yKst*VY5ds%$N<>D!
zzIZ)tAB)EiY=uk0^i9dP&zaepg6<u>idBtUI9^{x(b}V<@Ty6V&fc+@Y+9vfs>h4<
zy^$@HWtIAx9vqc;gd?&Im=b?f$1XZEFX%)3Rb^v3Fy2s3op)u}Xn0&;MwgoJz_-Uc
zN`Gy9L!KQo=jhH#r-e3I55`($$gR(}8Q;HM$iWBniMBN~Wx@BZux<_;VVWr;%d94U
zsd*3n#bUK*uo63PmoJE_m*J|fR=9bY7{1Xa+faQik571gl$vN5u<b23w&G<ep+*5m
zCUnL($(V`4CsuNm`A;smu#PV9hlm3->ZKBpg<Q%k`Im*)4Ry`AufR~@JK|V!)l2eD
zet}$LPlL+Cb(1oKI+R&W12_D#qbT(CMLiGGE3LuRB!Y$}Pu=+uHsZLJxz7`5J{*4=
zzhKCRWjs+6FG3rQ$p%rl-oAKhAt;>xEkb~AUZP|t?^UaAJG7rgXToA3%wD|}Ur5Zj
ztm%S@WKR>Z__esH!iBHcoiIbzkPhC;@6yrI%E)DCcO$wj-am4Wv8^3XOGIXgS%S8C
zI9J+HlY3}KthB-rSceJaz{liWU@ML95AUceHplJV;~&8t;1&K~E;YWHf#?4o3fb5W
zlN0%SZuSyRxIk8zMHZf3Ke-hik&EJZz=;DYV0#9)XT)E%?Y%^ga8sqh#43M}WZ)<{
zmg(#(V?Ku4lF(X12ZVwVVyo@oB9u77*nlQtztNjn25_l1&>pbLoW5KNs`Es0(8P}h
zpDK@WtuOQRRjW?!XbLoRs3IWmys!oDM_yOc?sFqhohcF8o(a!Ws+!b`;-+5*u_MAT
zy!`aeLtb<y7Q|_=?&{+r1UzJi5tufaIxQ0EN`7V}s;)U}6nn$VZ}vh)blX~^xYEt%
zb`8^AvmPt8sDxxh>7C8o1Pe8DG7hpx_m-D1HUb=%$p&tL*z(-mfHGWpYiCY4wr9jJ
zX&Oqi8k)esrKuz}@Yz2=rCz3D;gE2L1<En|eoiPhrm+(v{rEiWD6`sqe7<S!BlJye
z4h^rEJ+Sl(0>2vM<Nu04MODRM5d2|2u*vX!=(f{n?C-p|SFK*p`FLr&z2ZGK*eM*=
z+V<1?jN=o7a>5&<*l>E>35C%a2wC9H`!bT2C5GRtGr~r9Ns-dh-%7^E<E#>W?@De}
z>OUmCMwV(Ldy4GKjl3NYmX4>???N_v>NMB8UtY2NA8pM4+l68zy<z*VCpshbe`<xA
z2NV>=G9vRJdAxEP&0H8Sxn6}bKL2rY(AxWlx+jHfye~K;OP}Ebbgby%jTB*{4fQyO
zEr?O7^s`EhpTFclKx(&Eq41kcP9yeExzJCN=;)L)X3@F9fB1B(bdqGG<D=QoUS#|&
zfJ`26C#!v?UK%E;%(?sJ_cFTJdqvD^5$g*od&4eN{{oGpJtFFMkyT_OwH#C-^-*)o
zPpFR_e|zsZPPe8$LN{j1k{d&du1`NfDw6xPHQWmP5%ZQ6tdb(Do`h;G-=v?l0h1)4
z^7dJ8?5R8?(#^&BfTec}nLTs$m&d)2LNuR_$L>#VyT%RWvV*OE{xg<nnrX=vGl%iZ
z-n^~-4Dyjb4m|mWsw1sT7zGe_dztRP)2=bO-jj!%{Z3RxMTJ;7#|IsfU8w?FrknNF
zRB?g)h@49v&fwd{mY;3X3apCy_Qr>@JVrjGu-EJ_><UWJPb8U3lp+1SFV>{#Ev(w;
zrDj0RWH@UwI2X@6B+7HQk1-&2^PcT(Z2|DO>QBx5!oypU8p&Tk`1If4NX!IYUT75b
z8P9Zr&z+^j?C9v9EXXQv0KWe-n1gnAAmQC_uR!YK_09Rg2}X%t2s|$T%q<5so%RME
zPbF3})qxSW4}M%djD&1*(nXj!fkRW)w)i3tEQeBy;ZE?P=t0MQe4*&21i5aL2!GZ0
z{>1UFXG!(%(=G$MibhpPTB2F&!yFR#4pzZ%q7Yzb%Us<7T%ylZ`n5~5?7q~opc5@n
z;8_i5S9(#sX!UP`06#`a%FJRK%rC31sd^ppV4y*6SIIa2i}uQF=|ywisdbEecRsdU
zmunWm5OQ^v*0UfvP;DY7P#fHp9Lpa_aMND)sSqEw%LFB&o5g-geu9yNWt4aoe-c{Q
z!omNa2n)Wa=)6_>8m%pbpS0nc4*ZkLu3$Vjx!ZydBZYI%K5XV<bpAUSp}>nLYra2T
zlHu47VU>B6+`68cB)w=@ZR6mj)}1Y+1aHlc6Tg3|<RNX1oNS~gSl-lZaC~dJNy>+P
z)BZGfShl(1ekI$*jEyu#NP{LGM`o00!^tv%@~pz)4_86FmCHK%8#cM&(mxgB>>VYg
z@5o@DQisSc4HsftZ~f>Y^<n5?N@*z6<f|li+=?@99S;R<>XfZz5$^$}@Ti_@)z>*@
zVx2NFxc_%;yy5}(fW%>p*yyG9?rt3DdX?$x>u8&nKv~kA9RRU-^;_Oy?z-^_pf8NR
zfoIa9ps;(ekQ(Z*e#?@Bkd}bJSx7kd@Nii&Ih|7x{l98dvR}{ZGQU((H>#GLns|Zz
zVIjPeEVb9{OMAPw`*}(t(~(u_iu%z-Ko^JL_LtTNRmo67?OdmiL*lp%e!reM=K<_b
zk5!~b%)5h0P`58n?~6-MmcLKS-GMW)rdRX1OOl+Q$Ap<8r;P%~zfq-6-|0!sySQI5
zk*}J;eeWePWb`7xHT)S2hz{10N_EKDS)%l8ZuM}m=1`rgWFFY%H~i}+&-bP24ECMx
zs#Pc<Zep7Tp5AkiHA6`X0n~1zFT{!Mnfsda(T+t#H~hz%%!8^=`=c5S<yCaB&fQrn
zc2p~HEDX=h74V*>n24(F(S2j0nl_rL-Xj~-ZY(GlXmYcyE@5L9NMtjZe;>ictP!nf
zYYaezAny!8N?o#fb`-sWhU0$fl6Zlfd4hAu7laCyf=&OZCbi=UZQKOgGA9hUZxZfP
z)1(yeL<G0%g*rX6O!<3jWuHdFZ~y%Hj{8(L_L~>wd`5zJJlfLI(odT>SCgF2K@^5=
z)L&N(=}%d7kIUBh4k0p)L!U_myNZF7L45hQw(sY!{x0oYi1+1X_Pmjh;46q|k(R2e
zbMd{q1|z6MH10y={Y-q&HobF5@>UeVZpVkDNtI5tBVC)e{KGZ3pz-#FnbK|L(mm$u
zmb5lvL_&tiJyqlYFDHNQw;Jh$F!EWUHSv{7>oC{jeYt_PgOhhck1vr!q8?}YP5dQ2
zwFyiTWIrVumBJX!$m=Wz!!F8q!gxuGsy<rivrt;!@5{=JFtDskTp}mqFrn?UTcYVX
zvP?two$Vid`%?Ut4|=1M4vgg1t^>>NhySlqGycDEb7S#L5L-Osl_-{<I3%yz9uWT7
z^3lePP)1Q=(;8GBUvg_FMM+8DunAWnmw{O_=cSjbSZk?dfCswcvA~#Q*A$V`Y;Rg|
z|JcDSdB~e4zzwTkh<Qydyw_5SmI^>Aj2jdQKfgtD4r##&ZaSzo1)70!ydKf?Xl+;n
zPS4`UuyicyF;SEgz?&avc*b_y>0m4B$f9e~(bB6`FKxfg2Q)-=<I!)Tk`W2HsjHg_
zgr?JY5@b0YY~>~f(5atbz;X#nR7P6Jk~lv_D<{kHjTo((_>G`E7k<-NqV52a;SaJV
zMvw+9ntgq-zj^JSwZ0C9`vZsw4wPc7=$#<rK1wb7aC2nnW_!uc`118@V3(Er2{8ql
z>1TdM3qus`-XTr8o!Q2@iP8WxBgqB%A-gpH{4jk6YWxTT_$7D}E_bN}t*AIHxTY3C
zYq|cl6pW_Mm)@CYcbU9YPy&mU+t|ZfEV9#^o%W}^c%N@OhyHTLRo=&n8wk%NB~>|8
zG?8TvB!;U;UJVB~)0=7aS&^9nPoLGj+qNveoX+X07>cM}Yok=%X9C)c$l<ygQl1?g
zatE{|*PHieH9OMYIe1VB*2wk4<NqX3#9SvlHqi7C_C1K7tTYgACgNar!Pid<r;VdL
zs#8(e(&WHwux#r7*sZT0e&Ak4w{&0wX!m$>yhgKMR*Tyof4^uTb};1~95eGakLfao
z9nJ8{`nAEd@~h%4N=gzxOG2`Mo1Rqbk`UP<3lO;>rl`0I>osHi@)VMjHU*_q(#%f7
z3@_+zyI>!3r_}i#sV|5TDk3Hm-H$_ovFq<l1#jSxBdKk5#?ZmL9Fl&Vj=F7LE-lAm
zUE&p3kj5}~Nli<swx!opJ*_c3{XU2RAG^dV?=DshLZm_n>C-{UG<)<oX?7ccz@i1d
zYb+HNBCPVD>}zMy*h;JenJTl#%pK!&wMRW(zAV0|V^AMyN!}Fg#x<-gtS43a(7xyA
zGSbUkz8MFDuO-}_3fN$;tK3XTPxH}GP1R@g!+b~arg`<xhb|cj>YtRK95}hkdz6)r
zMrj+83{bxCX1vQ0?w8-5;o)b`d!dy(C7!8?V;WK@N%n~1f7jwlZNJ}qB5WhuAn~2E
z-E9y+4dxjA`OQ~V{`u)-ncs0Urs&95p3#|@J`{x~CZT(KK`+4-WBpUF)os{qDS?1|
z3%NeSok%&k+q~ZQq0Mn*y05CKUSp+Zir`n&Yqf;MfP8eOnR0>)S-HSyo+=6>TNufn
zL!XE#1e|Q~l-zxNHTU;|F(NEVlZ~EgI;P$W@D|BLw@nmvpzN|Mbq@i;6ty+;K7q{!
z#ptBh8WpZ#Q+i>Stk-N9oy|HkAA&e+wZ`@Ba{T`S{}jk!o(^g}VC5KB!{^%@yH2XE
z3tMYN`VG;Yfx6>+SJY42_rLd0hFdcbPe-Xb%PX}q_KYQlZ7%x-nX21wjASU}SA9sc
z!C%?bU*s=xBJAWm@`zoru>Gl_xVO@(y+qagfl_4HvJTm+qud;+=FQpu=ON?-r`iud
zOwQB{4EY3Fd>s~tbrqe(M)|VZ=G37#{a{v2{#4vJ<fFHaDTfj%XGZsCy%JeX#O_5C
zm-RDDrA4TTmT=x7#@fg*1KO3<qfAZ2vgYqZ`0T-hlqajCSVMJe;5-SQAEah4eh**i
z&I;UcAHW1XGg+fn`AB}>4F9<}V$4V_85wqY;AMqnb4<W8LVlG%5}e242KavLFbcAx
z9T2Ey?S`9sa1pDGyxLmK#)Dp$lfijDwBN&q%)2;ESJ50WcQQ-k(PqYLXKr)`d2kw-
zqiS$-bWb^Fp&v=AR4aehG3s)8_k?BN%%VI<JDgA)9#JQ;olt8>YPE<xifJB0gC@?%
z4Ee{h&A)xG7bKScizFn}n{G%LbW99T@AU#=v9MxGm`B^Fmztw!!*qd-UGZz__E9ng
z0`w~SH=|p!HeBp~rQDWC3v?`B=6wx{<Kpu)0^{}B8EpZu`qDSrMN{6`OiCc%hA8Ln
zpn>3g)IP)+3yJsORM0@nUNf^BAC<_2Q!tP4NKn?-YgcJ!6O=64*2YEu;v7#2=Hi9y
z>iP<8)qKjB;LBM@v%6Bh6^rm1TF4r6>sS*{7UAK^6Q9eqO&&p_KXpsXi2=1~*!Eh!
zyy4m(S*UzA_n+J)M~a|g2vk=PhjDB^jSRD)XtPzZTijq^{`OuIgeW@YAutVi*!QKi
zA}4YyeP?}2SX6C73{cRMBHdLLRx(qW<aBs8L0LKOd;L84vPP;V>D+?@b#_7HgD3S|
zP)gW$A9;EU@?1q=3U}iQzPnjzR<1>m-*%kDeheBPgjj(^bmNGW8p!(`n%bCotO9Jy
z^RKI^_m(QF`2PoGUl|o;+jf1;3@|iEcL)xsG)Tt?NSAs`NH<6g-7pA(C?O!-f}nzQ
zN)6p5(lvB<_cuQ4{nq#X`=0yfwbraPKhE<!Vjuh1yGngkz7<>@X*P$Pz9%55X7w!A
zK5BT_w12RFvvzIZ<&+m%LsWfZ8zcA;U2G=yq@!dNBlt1rBh9tjd9`9X7=0*>85HPJ
zG)>P>V>TV=_c-osaX28P5G0eIsdhIW*S?m#^kBo$#nVjhi63D2-orqNoaxN9S1Nb@
z;349O{G$D=#U=j~zk~>Jpeg;#v7kb)BH|OtnuD6(dc^Zfsgu66`$(<EsRX(t-fE|q
zNNrJ~MJdh?r+eGDGt8iAz&}uu>9z;?lj&VtFkOm7K~Rlx@YE~8%(2RNLP{adz1Gyg
zbCfO#GOANSNXnZDl|ZI6sre75>BFC{aSR*df`Sly&_v#N5m{ozsqG)aOkbDF`v4<Y
zPMCW}4%WjpOM=;B&$^=c5N+ptTKJ-|iXl1rGq?Q~j>4Q;c{N8`W5C!(p#u5C1|c_2
zCyspjUXhCU-XHM0)7_l{OUJy57d6JM!8A$a@W~k5Q<F!OLnQ7D;I^ub;6#4KJzl$f
z`TH7_<pLrjBq;_NHGbK&L@?c^g{P58W$Nq{KG8prWfD`pj_WUD8APH$Hg;Q}BDr7{
z!n9FbmQz2;Tr6}cWTIx4tKfw?M77S1lp&FvX4)9DKOq#lZ2$>&EWYvdUHT_6nRUxY
zjUf1jju48J?H+@@tefpFa7J4gANO{jwh<>xI_Y29a1dm@u8s|l+AR#5Cs}9C{B7cg
zrSD|$T}z9#(S)zj-gJ70^rKJtH$M!^{xsoK#ha@~k>(3CMWo_|;b4~(z~|@aEDyQY
zSMe2mur|~3d7A)BbQO5dzwHrZU;a;gZDsth6%(52XulLa9!Q7G6BtO;K#dz?9H13p
zD<v)WhzN;*-A-f-WHbLo6tm4(J2hPKC)mXIDKlpG3{=H9QFdkioEy9u6{9x?Wv3S+
zt+suE45&kmTkanGwgv3V`gD3N+Tw&v(giv`N9lQ`*`MfSg8I&mu6{mo*tI$i2rV<I
z#Q2fqSC7gyv7r)m<-(==Uk+P~E<y!xq@f)i!*3YD1R|+zC0f5bG;p#SJ{(*P{ZMiC
z(HpZPz=gv0KEAQC2TJI!oVz-!XuqZSzgwtR4&1>o^PyD0tb{aUTdU>by}gm-QuYJf
zhr27ikHeJt_)27GFWn!#1zwV1@xMuY{Hv_KIFf7Cb6~vg;&i4r<y5pqOkBlY;bj}=
zho|E3ruS#!H8KwO#>sYm^OR1R`Hp?}_@{;V#y`y`)Oq(E=#O!lstr3T(dlbNm1g_i
zt-B}ZZ>WKc*w^Q3*DsR_?11?_C+&)Eev7C~wkYN>i3qVqO={}c54BT|3h9r$pWAKE
zx3sE8&D=fz*Dy}${lAlio9q%ZNHD&_7u=7Z3R>{!lz%*scrtVZl4LRuCuGr^o>9m$
zlh0RJ^m#Ae9<2+*dvA}l6r_c?25-hH+>n>$$`g0^_0^CpX-X0vQG<<$!HT{_tzChN
z5zOOyM#KMra6&cA98T|R3S^F&S`tp!hy29xIi-2|xOX2Udv@{NwP*g6M()uc`h@NE
zJL^5E`lYVlj|X`ja?kd$o*GAujv8_oi@92PM&}OySZj(`C}2!4pOR`wnT`21_1T=V
zAz0CeJSN6!*FT0gMhVPbfJ@4G==&=Cz1P9E|2-1W>fY@B0=!>54NEP3U-%#Jn7`ln
zn8?YQ>09zJK{r|)ZOo8a8y&r>>hEIBq~?qP>2aN!E$^n%sjAL1u&pHI+DHy&f8%OZ
z;k-h-Q=TgWL&ejyhb=HQUFna<{R+(BAw1E~l*R~T#~-trB|}j^|D%4!THmuq$$&#b
z<Kyv?A1%S;Zq$#tHqXnZTGg3j7#fcaje2^1KE?<VkaW7(Nj>WI8g&tV)+z9I04qDX
zWl%DsW63Y6^ISGLjy}C`AHrOfBFH!;H$f{1n$3U!K46)p-YYai6#r91(-h0~Ork_I
z^w3unJ|Fl&hh^yrim{Mzp)I4OCkng%jaXd!GK9v*(px#;bVCsbX=H3H7g(ksTV;w5
zzq^s?W^O!xy?HJ$f$i4fb$j;9R6B4rSw{LhgG9zR;#GgQHn2UCcPmE^YP{G4{wDfe
zD>9G`n*tfYcEJO;nyW_aw=RZZWl=(ps5A8UH$NoK53))6MF8twUau6k060zB^|rqs
zNc`kd9c{qS8cfGj@!PwP6;bN8K((>te(dM5cr?}x%6iojBdVR>4n%~3Dv1s*KQS57
z&HHan##s&v%De_)XBoc~2g<S$#8IuPE|eODE8Dth!B;QlXA>~)pmt49Km$hQHJOeA
z(#$SFj6jc@h8fbX^@i@2rkyz?SafXkK}l9Si1VY2n}jYN;kX&~(G)=vta(5Q$B8<~
z^)c1q@aWk}6G*FNqLcXtz&fp7!wNx!NH}t3fGZ;A*$`MvzOT5-AZqxeR3F`f`9Ml>
z2cjlslBZDzgtIvHA9bi1vBxg9>047@q4~D=PgHHlZ_&|9ByX<!BYz!OkxR~BHhz?@
zM8~Rx8A+07>_eS63AyicL3diy(%Z@%DX`yd<V$R3-yo_TJaeJ5-}<|bGm5&B=F=ID
zk&RvCYkTd=v%x_et^Bu7Sz<qvF1A3f)dA0S97g>Gsy>tt8^T+oEe_#;Qy=;24;NT^
z$jeR9P)V4^b@Yg|vBe=mpX5#y-Mle&D{W~#OpN?dO4A!O!c(zi_w~#9G}7dU9;ukD
z9wOfAmd8YAu(QV|%5{iPctsJ%$QS|clu23!ZHPaw$HTEqC2f9Ox-Sy#tQl%1cif4Q
zC9IeTc!T7xJ_!@^z^e(*Ndsq$;yrBQ+IOP9CVNuc_oE6lx5z9w5#PGYClhe@yOM6H
z+hyb&N_Q(qaMzEW{Jb{W8QWy)@PI@-i2MXM<zVlp=<QRE#0cdN;~;?~yJjK0K%E6A
zj>gfj;t?~MshR+P1D(Ru5`<*aeGzSf!%W9T<{SmX+PfXL+9tjDI%H-+G2XEYzr9fC
z7HFpn_6-`f(bC_`^dvd3t$E({IxNeP*G7@V?6uTnYYr%~b3VfPm?QGl@ip{uLU*ZY
zbw`b~LXEJ*P|j4k^NWmi)2SfqEQ)NO3RZ#IA}<;5;H(IFil`x=d@D)6u4X=5YkE56
z=j!~A=MjprXVlp)5sD1{i%)uD2;3e_>?B_s&J-6v93L)fjAXmLiS*?O+WLWYwPk_j
zk1}Z8+ISz}>JYxDCxDmuj$K~O)G^1^{gZS}!1sG=Pa1E30^@r$6$cyxYkuZIhl8$f
zH?tr8{|uloR@Vpxd;@ksJZjHIpq(osZ2v~2QI!SQcK7om!8wW-Xw-a5JDg-Nvz%In
z)_+_N`aIvsYKS|p16!z4lhY2cTw3^<5-C+LMmv9GafpZD19I-kw49N#fj!SNjq```
z#6Rra`qkf58}20gu<`MKXhpoAw;Vc{gl4JjC;7ZPn0-Sy|KQoVKWh*DVlTY9d2jhZ
z%3qqtFXjh9+_&tYug`@WojiuBS$m52+|>NYHeQ%q{pO4Ouz2+u)W~&+KA$Q2wd(iQ
zN&T7h{y<)nd5u8ic{-VzujIbOEKWqWR>ptAuNMi(W@f3zlpHCq0nU18L|#C3{${Q2
zjJYe(IN-7Vw8X0Fp$9?n>|6mIwar`~7B)WOA0uP;<q>+*i+z=U9F0Eon2C8Y^0Jyk
z;N<m7iG?$-Iq9z4-ogNfnJ><BeN1Uj32%Dw!c7EWv;f$gK$4t_uM_!*2Ks)mmHLmN
z8sDIY-^F1g@4PfaS3@V05fKT?*GYb=!w>*hTIbQT!bT-}PV}L;QSvQEW~;~T2WRpn
z?0Xn9rYMh@x-0nY0TF0jIcS8)#}e%0ZN_J7MMids@kNlYotwhL&YDm8WBvL$?y@?r
z>q{CEF0V2Ekpb1m%M2l5jM4}~kmEi`B^YxN>XX6v@TR-~9OQsXqe1M+R&Q+N(xmlW
zsSwGJ!@{{ln0Cw?t-l_?Xd%k?UtMB(in~YK3$HIWb<G+Qu5SktBqwZpm@<NWE@|9S
zT<rAz8<%t>=6}<|!PI!jsAfq{JkBJ29B^X;Ri6$>h&s{K1UqWjtB_`z9wEtxVy#i*
zOV${43xX}l5%Yt;O+1@v9)Z=r4UK)+jCIe7SCaYbbMhn>voJ`F5Pc)`nwfR8gJ&+~
zBl#pgVKM*@dk!5T0x^v^i^-cmY-7|R87xmPm8Woeja~g7Ri((mJd$Cp-b%SbEg0J)
zw#snTR=;iMPJR+B)5D$H{`AJ4{z~~<>dtzwuf;D9A}2hLU~#o)mvWR|@4zy)z?7(U
zGO^1bmxbtW!;XF&aCL+)Bk+qv|6G`1aaYER>+a_6O2qs4{Gs+MRB|EFTFq<K*W5Lo
z&EG#--h0cl;NG`YKzo6Hqb6N<FJa4$|NCcvVJVcT`72k54i$aAHAIGO06wT_YO@5W
z(+w9k!&N~yIF3$O84zea5F(A0h4*ZPwm51$N@nhO`6|EB&!2>6Nb?F=b&ztXFo>K^
zLzf{l1t$p&GDc#9KiW!XCT@)jFAv@>C(53!ac&>h9<t#I0>?5a(4~kQvZxs}^~A&t
zeNR~VvL});Jdt&<c_Qr}3dXE3gN-l5LmbM-+KZIPfX4!v{tvur7J>=JU(*OS>HO(}
z5=lEC?3hS*xNkoA`Mky`|7&Q&LF;jqVm_e-LM5@3A8TG1u;O=`a$U7;YKoSafBhC%
z_G)w3>{#iqOF+>03zm?;{pNY)6>PmW8CgSBlLwM>Zx42k^6Z~1m_%8#7<wGMmVI;o
zzjM~n!X9`9YOT(~F4qsx99+6^ps8nI?ZKsKD#so6(j~K%Z3ZPO>R41S(c(mxl*DyR
zn}Vpx9j&r#A5OP<kR{}qvWjKW%nc=Xc<M5lEbJ&gsh@E%0c@beLz08n#A#oWn@F^h
z5l6r$A<&BBtYvd7HXoxL9k@%bzBB>xWGScPLJS?gy0y`oJPGf2bL{XuHWk$wxe$9B
zaIYrM)zzUcvMe<A5&OPB{Q$_`N}PfSppO~_O7I-XkWm~tI1yIHlU7whmNgE3Xeudq
z-IH(N;sTTe2yQNg+}M*ek{Db+kX#atY3Ko^c<lSV+Z(Y?J#@M|eK%8gr}U#TMTp)3
z^0XR|txoYespzDJd}QCJL%(>)L2nl|g9G?)xv23Jw^@{8>3gaP5W~U|ZNH>iFKDkq
zFzlZ-6kbZ_YEdS5$Yv+vNbu<znx<F;=e%#6y!=*J+tz;fWMv?y(Jy*%wo`O&L%CtD
zWh?B;>WgxVY?D@>GAu3@3zp^bozpF_(fjDv%<ZzAo<U(!0K+XBOUM}s18%T^bqDZJ
z^Rh(oiD@JC8CWuXs!4L(d8z$3O)+r%@mGdo1bApI``6fa{BPjBFMq?*$DAMjFECdm
zvk}Z1E`i5I)!*tY&E>tZ$Q)+i9on9!?ms%F8R%6B{qLgA{v0PCfpqyuXV4&3h_oG$
zf^^AF;_qV$G7*;;SxMUM!b0MaK>?vG)3<$o<q{wpR0q><A{#;+i4{(@*DrxA=uONY
z4{>Cu;r@HMxOrv3zQY@8Is7|ps2u95Q#?*hjS^x^&=XGo#)kOFG*FK{hZ^moR%jr^
zyj967<TsLxYQi)IS1)OxZPIGm=<uENc{_1hs-6{t|JRWxS8zq!#;+Mg!?QSmeM#_!
zANU3r{zi^`Q4(acxlkwFgFmO`ME6Ao^J28nvXG%8_;!U%eZDu}f~~_Z@A|Qh!PO;c
zKQ&`KxF9b_<LgQu5+>;c-?QD`^u4{_x!uO|5{%Zf&x?X5AUP;;uhm-s%a99Z;qZW4
zXKc~s$mO3R!w<djlx=GzWvq1YAsjc@HG`Pj+m2Xh-%Ga-tMd1bLv{zi<K~W?Y|PBB
zM~;^0Q+=BDdINs)o@Lf{99--!HA;H#_KZ0y(jfv)>l=fT7&(a7);?3<>nVRFPcr#Z
zR`rW3^KQ}F<*4J8-s{&`H0gOlf(t8v5c%r{);PShELtn~YTLJhymz)ojEP~uF`O~W
zm<O#dS^ymDlj;@xjTL9InEHMGqv@Ci#>f(-sTIU`3tLKcHuGDdy1hlWjPPhLknEFa
z(P8ox{J*gv(ZUX(`&;My((3B!7_~&a)5C+5m`|^RrI6-jGVHkO)K=%;!8jfOf2Y~=
za0Rx-D|6dL?yn|EmNZciSQM>Eir<0_MT}7$9_b|>#&fs*t7@#uS9Woi1BI0gw`s-=
zw_hd<b)l^6YW;BPH?qC<kYpLh?&}zTAqgdO7JE@qL6T-$$9$)hPVZg%8d}=q#I+5f
z{zIC<>%w6F#ZbqQZC*Kw6#*IY@@K1(9=bR(YIdCi7DLQGP>(6jyTL=-)J_1-93f#`
zD;kh-xc0;9+kTK7#CGWNJmB<#<FGpLOvGhrwX(b4RY<3Jt><YaESgCwX8vyBu{Vz5
zI?v)%5_?KyRE2&T7sf$dO{w0QJiKQ4h*s~lTGyjdy7T|51#qIuUmGCCBQnOQ_Z^T8
zHS{MdU?3}riSArd1Z-r7o5KJhotOKeuya3LDH4#;*+q|Mp@&WDZo}|q?~$Qqqwho<
zR8z|P*JxtH4HK+U&iakU2RHu#ixHf+!dI9?sx!6{9e6=7IicIR97f4<9(!ja%7ol)
z2Bnbm2al%4C5mOxN3)#rrAtZM+QnC|4CK88e6%BvrgebJ>x%J|SD5l-_5~*Cc-l!;
ziu`xM;D6P?)QTX2;Q_~=OGnqIg^XF$)E`~0PBBV4N1)^F)*Xz9OteFj4ANC#VWBiA
zW69a&-SZN^duhSmcHEedFq|9F%BPQAtw=tmD+vOAvHEK6(RY+o`~vatKVU6>5Kzq4
zU_|0)uK$`_RMdB_otDNS{1KuD|C$}JA!r+bl$}n*4v_PVGiiVf3zF4kT0#zf0YV%}
z(rF3Ro*paHPEB!FBuw2${SM#9>Ae^Qwx>Zd;|o}`@4iYp%!qX($a<{E%XF2y4`pSw
z6B%kNw!1D}478~j^@`Zp34m0Mz7A}kO{{+94+RVWJSQ^e;dMl~Bk<TqRD4`NV|)8#
zc`}Mavr5vt3cGVHJ!5;<b0w=IyjL)e?WzxtpQv-qj}^LREjw`UVf+Ud?4hH`EuEFI
zpY&xlS_%?2nasKq`aj=um-C+ON`DHx4hxKx@jIyeQ*D<d3W95XuJmDE^=^=oAU^u8
zNoW1{(2RZ_iD?6ues1Hh|8r<B{~nr?TBYK@KQy@@z5QhF#RJK6`{+SBq><szF5bY4
zAZKJzkf6P=FYwtAB2#W?alC%c5E<IMk3B61U2m)jE{QN#)|GEXP)0CM%I47@*ZnTo
zxhMEpKAY=#$$Rr^ZZ=VP+`*<t9q`R=@z-uU4TZzIM+hAJG<u-FaeuXPXv^8ZJgZRM
z^>^um4DL@7nF9$9OM$q6!;x^Ry7%F6tt0^WuhsdMmDgEsFVyX12+=v1)6Q>U@AGrO
zUJs8rh$X73@H0bk851KbYYL0mEh%@0+UwcyI2>74XpkE=LO3+yh@g(BWVbNg6@Hpy
zQ_!CI{Y}-nEmg`-M=<1CK9I>Qb!Oo^*q*DT_(pde(vnC1ghO0*;`=|czmqF0Ty2p<
z%E~aZva&MvOuy@Fg9abHghZ<0j*6Yd8Ew$I*wbTDd`{qJV$gru!2BE}cql(7C*cbw
z>;B6_=zENa0c^zKfrlHfTJLEWaF>KKZd5d1fL;hY4j$m@%9R8!d<sg2u!s}3{)ut>
zh4{eqj-3Gts5kOagvNXW0+_mR)l6+BAa8Jy;>jSI$ZO=6&R~#1cIV=W)Dp1MLNs+2
zs_?~zaNiA!^aQKILj2bHTos-Yx+c#UBCcqY*-!0iQ-Ys&?=I4WOkzDp(&A%QJub?@
z{9IfR*M0<dXRpqNU~#FBq$`z?y~F`B-G}nv(}E-n`mwcP?+}S9<Q?eozO^M$Gj<4|
z62}tR@MYW9I4s>(&K%;8<NYS{?c)lOAI;o-!}~-vX%0+ffnh`z48g;A!%M?m5xt}r
z6VgO$#i&}ykiy&UO1_4HRrk{Io@H?%&vvyG>cjqc>$oYiJmC1n{{-WvOZr;pqm<fn
z=j5qn#VTo7gd_Dp@1XFCXW+RClavpbrZ%ekn;k<U9&>dHR<<ETA(b9agq!2L{C%EU
zdxM^@A)hfa8q0Any4nxIS*3AA)@yQO`DaS_mpT|)*ac8n=wILBG98WS)KP=(ns3hk
zl;Y=V?{z<=bZ?273?_fVeUQxY7VlBAy!Qr$!MB$anprd7mR<GqjEp|p0hxGkUS8g8
zLt@m{dQ1Ql6NYpa$SevU_b9n<u?RRkkx>h*5s^?%p15$9*uaz$Y`$tm#6ybgV$~4r
ztU-03pSqZQJIDVQ&g;bar!ME;-X?@8MU4{R_9*UCd;D8blgsNylC!l&x73Uv|MK`;
z_7|mq5>AyU*0t(s6iXQ>05nB57fJdF=VRA-qsXVRfN`MdJK?!JA}mI<U&lE>Qs@&8
zt69R6meOf#Tz`O%4(0eLlN5Rq!*9Xj)K&54V_rc>G6ep*ZR-NYJYw1VFr32-mJTH!
z7gjT{?)?Z_6b6Jh(FsU_k<qFtn5OANHs?QfaI;)f|7`-$n^RAv653BDec>w1Cj#>*
zW|c>4ST}NYe#dnfIK$1JB-?V;T5P*udRNu8*c@237>m(;>+nTic=Krhj_k_m)ILbh
zlb+{yyM=S`68RH<*m1wdR6vPr%V<ajo=LfJpY;ObWy!6m2=)LqQuw{prDL+WL0gF7
z&cZ*G^v!XEr=p^ZQjRS`Q@d(CsqBK2UakB0HLMsOay3Z<{Q^mQ=q%X0f1oClq#wIx
zrX%=mk?D)(TrB-dkAlau8tArd)+ll;div&NvQG9m6)_<8A{^oq1ybpN0&c`t$}>vN
zYFKKjlu6Z!=d>bj`4XQL2t<U@YuX%$V2|g<)N$m^)<v)^oQlT$0yi?pK{r1Q>(~x#
z@np50MOoVYqfmo}GFE!}trwijlV1}<Fxy8vctB)N;c6!(JTf|@`&_MaCwGZ0nV2NW
zPqZU90#9#Iw-j?N-zvXooz}smgX-eiv2TA{fV{sgK<d(u222a^U)OX0`K4$eHrKLv
z-OAaqWX3$%^#gfYgm3=5M+*w4D}CP)%i5P)^9!Fgcd;c=mnu48=l-z-zFO2UDYAu}
zRD=*If<yifxQVClACe4V&@%CZmtZ*2(W?v&38j+c?KzW0uzJ@Z#A#xJ2)=CpzyWC|
zPA|yVY~IQQCbODxJ|X=yz-y(Y+4sKna8tqoLTCK}Z$w0PqJx{(k`5utl)!^rZs1Ut
zO?=V#S+G8Dn2ER-D*=y3(HsQn3OEuawy7P*J0x0gk(!oi65%^3yJt_bV6&QUifIqj
z3sM~*kF7r_Lwv{;zQUe^rzSE-$AP&kj9+)L0dKayGeks?NKA2>q}S#5NeV)E%XZvg
z>4gK<F!S0ER4p)+`E!Pe{LRWUyA}&`kRH85eDlfiYty16+l)!Cxtg>tG9c@t3@Oqo
zC}XWTvi8AXrbD;Ld;o`LhIBBwE78E9p=&Uy-)=KeisP_b@UHnN&X&2cn6iS{Bs%W{
z=)H#dtKi`9{$>lR*8VQ#_m7EbLTfO}!D2(5L@Ntc9;J&}Vf5dk{bj$UVS!QNHOh?8
z6_Afc9^ZFR2@KJHczBUkSj5#$2_LL>oa5sevaOLD5x!e7#X;UeMd5d=cHbMo$f_lw
z0+B7R(Nc#_KXLlOEwG(B1u_HQB|rino|$?2y8JJqrH{X#9U!`VAI6jL`+rq=|9x`H
z|BB)|?-PiIWD-RX6zvs));Uek@+l>|ZSJ%hEsmXnQ9W3}8y0Gwrn0?q%q&7R%`6i;
zSRL;qT<AKou{^7pM?;7^utFG7ogwaciV}RL5Au}~ZCd(6yz$gLw|Gp|yYEXeM&oIZ
zjC#oj>$H(~M9DW3d|~*-$NU|7@)aKsIpSszMYEr%(d+ioY8p>r<drxw0<!wa0Ra-A
zhuWY5+bw}VN_M(<r|w|d@_JH~9nR7p!lK{eig7PfcbKnct2D+0cks$*Ia{_+7F1ax
zC#sM>E19kj3R(e#y8~*11y0NwGu)yo<e#jr7%HO2!!4yIp#d}#j^bM74vzH9$C2=g
z&?6nREHD(e)n<VB+{UEuP3&Yz?|Lm<Ged|BWN)^Y<b7k5ONG2WKGIwcyc?bGicB3>
zyZ%@kO=0<)PbNKUZ#IxKnpq}hEp-~_?Jme?x0cDo(hof_(_9+nPr&W^wRyYER@)Nz
zu&Uk`{#nEsF@hx$tE@Rh%RDzE?dazlJV~GNNzimnUf>=^Xgw(k5~=}1q$xLF)ZXtn
z!8i@;85_qL@JKZ9N1xi?a@zDZ)R8PV-C~ANiN<L%fD{tqro@=F2HpJ0^cc9&UK#88
zi(xWqqa^=ezKNqtJk<ZY2J!!e9&|kgi+LwsUFFOircVH^d$q)<@k93~OoIutB-W!5
z4Dpf-$+e6qi+DJ{)SnI$i~=yjl|N0s4=QXSVjD&CB<`~sE0LEM`_&*lkfs>RlMB3%
z01{1m@BwlBDn~*B+iIeyd!a?MR`lp1-t6bN3P1UmHR-gHQBT})A%83`zTLY64H37t
zQHB<MccXCZM3@D<4vQ=QD4M`1{OQT`q(co3EQ&P)?#|$kQDeVQ%)#t0o_>YoTZCeg
zr<cPe2_L<~nslu)cnGUljM#!>(r9(bTim+b00-RZW(<3&+-WOrN530;@q7S43QRvE
z+W4R@RTwP%#A?!BV#%s^NqRO{kBROcUz*?zTu@Day=E5bwwq(z2)*Icpc^m_as_1t
zHu_8(JX>|?q?Ez_9BjAs>{T8fEFac+G&~Yfzm70@x@r4MS<;CZJoN7Cmuo`cc>Z>?
zcxCnH)~YO#i-xMWN7%)ce<5JwY2oB)%p~LeVNlTfa=Z4AojTB4qg;C*Qot@b^U09}
zE|ivYHIdKe1_+FFq>FG*<2`^yRywRkwpLBhzjr@urB6o*%A|c}P%{aapTS)9P}o1}
zo@*F@YP`s?3nwjed`!E~8Gm=E*drig$3+Pje#gd`1%i)PZzVA_WHqQ+y-T-9mJo8t
z<nGU_-cX~qCZE7fHCdgpAtW^bt<ydmu+{;s9}OGYy~5xUo|=Dgi3a{rrtkl@h&CX^
z?waK9b6jh-_VpVB+{BGPzw6aukME`zO&&7jB<!?A1UT1F1Z&{bPbc1+VhBeyCtJO7
zB<FK_b$WVcN%29+*;c)*y(|}_*BPej5@x~=w@k|Jh<jKP?A&@x6o$;J<F?f%$*paA
zJi4>SIhXj(#R$JW!lF!xV0;AxH#tq6Suo*Cctcs@#_ZD`i=z;Qr`zeMvpJgQhEgJH
zV~WICWq9(yPd%Kdh7b^w3`(*tl@aI1;L{aCAH<V82nhm6&8+zP*afir*lAU2xHS*?
zxmm5on&F7#eGy1+N=m=R;q*}-bvT*D>N(W1oN%mN=xM)VuelW02v%<DHg@NEx66c6
zRV4FEVzwt~b>KAuI8<l%_^sGMN(n}!+G@K}IA%~m|A~WG++y_S!HRks63}`y2#$ed
zMa@5Y{p9YoUBa24n!>rRe;AF%X{hrwalFjfqMN9V?*6`JX4V|GFW79`L?TM}Nr>aQ
zuV6XXw4=7PgM<_3abk&()9bBs2G2zx>w*>6;f#@WIj!Hy!rS(Fk#W--^qNX7XSc;+
z<)u*O`tBJBxLKi|SMpZ`t$X{=Rhwf@y!zhw?O!BH?_m~jtoN{B1@rNDy7Aw)QuTZI
zpW4lnW?!Sd1AH;ZUsb{KSVu+(5Zr>XD|N0aedg)F8|i4Aj=x8!L(40tnLGa3!-3gg
zF@bQQ&%mgGtM-r#SO+u2FhX7k24XHdR|cTQD6&F~rrYtD{{3C&Yh(38=peJI*K!Y8
zgjw$jLyfGcLT65>9(!1ln)u=`xyeae)oJXeb)ZB6*PHvmmvQ672hBG9`%R?@)<+Lp
zEo`2ozel1uybPx#xOq+L<s->~F;=arFN;i4wf45sC)O;tFG|1#*5CT6K-ZhD>}s92
zrVQ*>2_$ZlGzJ?oKBm@lkG>{~8{nDA%IrEl&G@rLv|&a@)3Te!tYK0i%^~0Oiel`+
zR2w~wc!>wcK_4YF%^;WrwT8RBQo0#Tu1S-y)6tkt&bnBeshn?Vn$7k2v8s#rO)SRx
z=Uu&pKw8BjZ1zA(R4n23?9FYXGxGMZ8U*ZAUgbF`9LBj-Kbty8W;ohcqVnZSbo8iC
ziq9VfrKqF@Vn$`xopAlXhqV_9zMhp?{-J*Bob&YGriH&iqlWrlFyh@|()=KEwUiwo
z{*trzcYJDWccS`T7ydbrfhR!zCQ3f%w;hBJ2hn#Pv!_C#G0@;4cY1n?m6UCvO4&_u
z@RXLAAyaMv$+|p7>b->L+12<Z6Cx_?nfl6hTN0u<8~XhX!@jF5{=34U4BNIh7jol_
zUCmE5eWYg+$Z1D9N~aT^XU;5X{X)Dg3i{|~id*oMvc?9#o*EGPKK;;+AjN|U*?2=B
z3a1Ay#cP*re=&<|g(Q2&?d|BSbjMkDQ2N|uJyJ&wXKXd&WDpM_0#7kBfo6cTLPjV~
z9)L4zloej#0z|$idKiloWnKjWKV-jKpoVzVGJ%-hYlBatqm+706|i<Qkgb{3m&<H_
zQ=gW>w0&;iX4I)E{?gHK4htEO%{cN@%tryVp5tSX%Z8oB``gAw|8Hi_FT~&wGAqL)
zRR#a{2^m;m^N<1QJ*&C(Rm5kj3`r=y^QWkO#6M9%H;=iCRU{YQL&vSCvr4Dgytb7o
z8V4K4;}mjO_x0aR+Knx1S{{-GEgjkLEfC}&6HMu(n23nB6fcLbp{PmE1@z1WhTFHP
zWy5tq!;ndi2Mn1IAB3~;(l$4Wgj^JG+~Qglc304ju^tjPOU62FyW0{ID6T(ccEIr>
zf{c^)SX-quM=4f_JnMg-Q@VxQ=?@=`i0&`}2u@?T*aNUOlx%S7R+G%1*`%7LIKDVV
zku2&t;aZjtY)pK)-tZ2CpXVBK;ckSY1^uHhI`d{>cgqaDe15RY7F0k4;h^#-gQ$ws
zoBb=fIG)p3AKg{^K(VpB%=gs}R_V*n{A>nDb317?DohQp2Sq#Ry1yA}4dC+q>bIT(
zou}JQo;K(DKab!)QOIL^J*<}&t2zBN|3JCKd0X^s&7I%8l{KTHb5&6PPwU;e%u$rL
z6jowzEpcepnYUrvclt_UcZLL$A~uF8yZ0v2SLQ{`xl%=$T!B9XFYkqs`?M&h`Z@J}
zmpncioz6?8_}DVVw;|y}(Wcfh$~0vWHmxk4I%tH;Dp;WuO5QA{A6+XMF`*&O^X}{0
znOiYn-T0<*rv4c~w_!!^raSWZOcWU+CsiE%ibM(`?Ftqb{gxb06Ov8x!(F$<lMq)O
zm?Hc|`zI?q&wXTI{}(P#RF<Jz2r=!qWb)@ci7_v}vlCGIQ9XLWL&=`n+l(jvj*`Bl
zD(t7!h`zefWKb=ZJv~QG-TZ7Y<Tx;{IN&T&=!|aB0}b@wMGbc=O!7?JcaV(kuZ<&{
zIG-epll=pl`r+NEk3l_j0)HC*MLih*q8^?dFMR(shK4AmV7cnx``f94$UWVB$B2hC
ze#h90LDxl1;m_ykQR%f%PLW6L@n6`{1Ck*Zn+S|W#IYq|(Wh&+ARW3QvOgbNS)OdR
z5t6S%@EsXZk+lA5)MSh7U&uayYuLVhblvtLMDu@pfvjUf88KT1Ic$^U&NHe|u)L{?
zmG%7s<7RzD0_OoO$kRE<?*me2DMfDdJScnSl}qIF*4T#}F*pw45I2S7n+zuwTiKv{
zsA`QzFv#au)3&{&`)&eTN(?9RS{!-`!Eyt9DGU!}%c(42pVjA_m2jyn%LACo=e+LY
zM7}LGr}u}CtxERvC%m+w&T>4SUiF;z-;ZMahh^ltPjMn)Wdt;>{4BEZW*3N>M)WKA
z|KW`{uQQeYc#5c>8qKi1>fOv{D!;%D&e_P5lx-l4*s7E6D7Kr5=`p{~qMdHxgWn}3
zj6W<^9dqhE$bug6moWYb-jIyYtP4HOo~>t^aD3D6`sZT`c|;yh6{9xCVK$Ytv@$jG
zk`ivpg;-RTrhVALOUw?%dxmjHg&E_w-|(dd?RiwsyRQ*#!<u8J(l)6NNtWIj8l(a(
zF%MVe`)kIlN=N~Brg6<xk#WkNCHE+8<*sO2#<@p8zeX8(ImjQc#iBDKqhtEWLqe=M
z@}X_)f+&!pXD<m&#8{`WQe#>gWaCA%yDMvdb+`73Ty_11M0(MmE%nLSX(+B?{G&p&
zJ|blI#6VE&9&Dw*t+|Z6aOZJdOI66z{UdO+$vg1QE;+(a<LisqLCdcOJgQ&SfM0|x
z;shc#YCP;KnymYad9$}?p1Tm_t;|a5{Cv!60C^k>U?aijdNMIw;a`&PP%pLm%$I!v
zOL&fHko^VVqY&Xb^9s0RXdnOa7n@IifowXv@J-Ms`j;ime~KT35B?_-3rt-j?ew><
z5i+#Lvv=u*Q_nLoB<28Fy>@z#U9wG!y7d}D!8K)Eljlo?grve$5G6wN2zHa_eg$5Q
zJ7=xRYqCkvfo38aLzn@<?qsf@28y#AHOQF=N7Svhgo|*suc&G93fzl*P^dPPu)|KL
zG*LCZtqL{a2I(g(<eI~b@ojZGXq=6TnNhvpQXO0Y*K#80U`ifu@_pon8UVwXReBKV
zw<>@$Fg<!#Qqaopw0KhP=B=@SP9&<G5~u)tH{ANF_)2z9pAL!=u2Bo(NDF82>Y61e
zM`GX@SE722KnbG3Ki0^N7ekI!oqI&N#965emM23`#RcP{88~V+qj~|PL}${X52G<%
z-P5`<1{q{M!{a<Q+`cNP<CKZw^SkSsm-JO^G2zL=rIOQ)GvJ<9(NZR(E4B!3caJQ_
z>PF^udzzOKg2j}1OKZ7X$nnS11H#S`L<aqhd|7JOPT;LCOTyl|p`fB*Vx)^}x^a)P
zz*3T3+BgwL_?m$?j%u7adMW(<vB^-~S*|TZZS)q$$%1=)n>!`snis*t?9pOXKS+dJ
zMJJn#qF=S~MUoKbcgD3MeWcZ_%ct!}js@Y|TZ_mT&cTH8!vkyP?)lqU<L;j%PDvl%
zkx$uTX()v}!;`IZG?pyvKz|@48QV9U81+Pxsps2_x3h!BZSv?@8fuZlMpbP1>ta;F
z&#Fr^G*x^Schg$lkQQwsOoI1-_p2QEkDccD>PhEBvk0piqCNaQ*NU#01Mdb8`<WZ#
zH7bMS$s4~1SE{*Z6c1%2IraF}OJyuqhmF{KKsk`_drcw;q@oCz<7_Mr2}~Q`NJ;Bs
zg0i%}f2A8{66_U7ftx{&3DSWI2EIT3MRoq4tGr)D!NT0dSC<aW+&R#L47sTa7j+{Q
zY1cirJtUXV`ZzQyYm2OlxZTA5;xhUl1{|A{!O~wP9O-5l7M3v#63FWBgTxCxs9w+0
zd2w9mZoQi&tX@TTVvA5~FO7}YjqX0lU>NE#4D>SYDf_VsXY#%)Gr%{Sgon^f_lt>U
zc|5H$cTbi+ZwP4Z8lTun@)>znL84UwN*$IaCKw@4c%Vd&y{|G8vs3kn`-z!2U1b%z
zUX8D==Ci`ow+%tVSXvwe5@ynS{cscMGcnIMQ$pK$OD1HM<Zz~Z<Guj&U((<T(A&^B
z<jy&4O<c$N5GF~)4FU@YTiBqowM9!m)(l>W=N4jL!H;Ug+|4BvhBft_U<r>%aU$Bh
zb5`c}ytG@^$dg}$a_9=@&sO?gJLLwyl#VWQU<@xI%ttP!Sl~*lsW>-QghL0;hFBC;
zA&2Cf4i|w8u0)MtuIL~QbjXkxj0!GNNLcK?j=Gkl24DB1wt~i)ip9j?Bb5Fg1`aZl
zR7N_=MrZW_3ioI|O8Effoi8>#?pA~P<>Bz4^yfQ5;IcK^i4JNh&YfwAmS6c*5*9|_
z2EgkuqiG&9i48h{t^ioXL3*&qsHxxpLZ<6pX(dOrRpiu<d0E6?1zz=^0a<scGZ%*v
z8&7;{_@Fg<Z<Wnlel~I@O5HO^4O?4V+Bsl<CzWPZE+J~lko63-F2_G;tqEFB+!(mJ
zf8K6h#jEOrQ7JH%T%{f=wH12tw=kgmTNpIN5WdUtLUyR=N|Ts2QyUw%gc%)KvnJe+
zQiNRJdq2K|h)E9PzGFeT2K(oEHM|yz|5ptp=8B@~a*>w%R@GEq8S@!W0LE6&*=_^v
z`+O4Zi8BC3glt~{XPx_>7l>x;!s#6VmPa6HvcQ+6mr_Hfl|Gbf5rgS|<7%;3Rx|A9
zron_Wi3TwmC_KDYMsfKJ1YxHsUq#6Ci&-DZr~6O9uG*;TT?AM>8fd%k@ZQ9ATy$qK
z)yteoH7NyI;FOl|ob)z-OJFuB2Wecs@)?wk=S(iY;(0Vf7HjFxkF1j%|KV|9cuRUB
zAL&{SG8~42N3imf!%k?R#-A6m9h5Zisr)g|xsjA+S6FI0>_O8f5CwxA1Kbc^#UR(T
z214$B`H9SGg{+ecig%iDsb2UYn|FMuukIn6#d79RXJ{>=@y((zflxAc^yi2-wiK#e
zsVE*udP&X!a?s+AR&yee=MPph-e%bit9|!N50IJbH>;!4L1(@n3<}`60A@c(&;736
zU*D)l$hB6zh@e3{I6gQ-0|A1hewr%`5ME|UC)zNFs$fg<vOHJ8Ek!%_bj>Wy82DOu
zWvhp%aus9=pEKEg5+#Z=$KeLDo~B_~QehNcdecF>mi&4A!L;=u>j1ECFCncaf*IzQ
zWd8Ypav@x5_3=ulM>AeYDgr5%hth;oxNA0|@#TF>m)%>bMT^_yS5(a>j7)6^2NE7I
zz^Fvpg>TC7K`q*$t?<P}W(4Fn^kHysEJV;4t_6Fy440S;@$<S$xL&(E)HyuhsAi9E
zA;L#>X!yB~ruAgk>hitEQV!Nc$W4WhR!ti4oi_)qz{$O$<oRqSs)PL>5sBxK8Y$gK
z^W<tMHePH-U9&M{HC=7`9+V!2<jOcvkw-b^J<yxn0jA6)qJ-=E`F6@9lVF7Ry)pnH
zikDEEf?+WSN~E;1mr=!aJ7nCW2(_>rkyNXCk=yrv&9H@1S6Awtv4<Zgx|q&)ubw?8
z<3ALyZ{X_&8HOK_<AP9LGEG&<moa|X?7i{z%LknXZ;$M01eZyj2KU8v+jZg;e!?Uq
z+-<84tcWsx;~l^Hz3Khm(tZ91&7IT3=DHK9tMvOHBv+hc@|`MDtlZ=+4rqi1UzAN;
zgrp(CjaayuHj-UOFX0~;$+@tp$p}A-VJKfsGbf9+IHY>(iTCM^r@*0s-fJT)hSWGy
ztRW}DjvwI^6SAn*Z()U|_lXb_%J*fGl=hYU$03|kI70@CVt+RcC|G*SYIHvv@IaJk
zqK3~KXCdr;Xkg9?&F`)Pse+ZL)=Z-MlqBJ`jeD)@Pd@CO3Ie9j-i-cb$dZSlZ12y3
zu6wR=8lPQ+1mgWu&SeqrF-`3WYznF*rSA4V<jcMXfhpzy$Ri-hl!YF|GQiL1g<&Ic
z+cIvemj5!BevZiexTOOEQ3nfgP6UJO3G?h~-+fr974J_umf)tXW5kfCf&GfD(});u
zRvXzm!sp2L5Eok9(<v|6LHjxo(m5p}UrKY<>WDw`T~ef=Ku@wbOfw57j%j0pV|6XT
zvW&Pq__9`WDA9+U(~5S)1I=*sX@mV6)id!C#{}!wgJy3%N(`1(?KRPoOEmVgg~6<E
z15)Cu7!)+W^hGJZW0s6|t-29T(eEgg9BcL{?N{q%-iEXmMsbPQu$|<^@D*Q$&k5dG
zXc&o{8W29ljSa8(zV%ZaK25A8H^NWe%p69BJ)0(0b?<4}#^45A%Mwe;vg&AM>N(?r
zJbNesgyOtE+OcQ;dNVLiQ~E{;|6Q7MP~Q2TEBf8D#7ztt&G>FX|AGS;@@#70V582J
z=Isd|a83Pg@$v*FF@wb>sO++gMqK9)kEF9mg~@@|zt^w*$^nk?4#O68BV!YUm^i7l
z@nd`0A4F{>H4zwbL@1uCOK&RYPkz4X{~@GrxZv{zeQ(uWB}p|nj9o~{Ou5jb+jWJK
ziKasrWuh&8Qrd#o#J*Z~{i&5tJNKC&k}S?GKN=mhY@>Lw|Afi8k|J%l^nT~wLN=7L
zUO8PR*FWX-MvEl`I#WVkNcxfEz(lY^AlZmyTx1rBM-3GZIY82@a~!~#+wXH26ogoT
zx&<&y=(lpxi5SrGu|+2XRm+bt`Mmc!!v?V`-&sC-EB^NK?~Xy%T1l>(y|Pw6t*Tni
zn)>vb+G!g7W`qsz<iDiW{jbT1|8vw~VEMH7{v=c86JQ7JyEk)4<ow$k0;89uv5yXt
zc{+L`!FM&~&tf9}wXBMDvIPvclI=wracBiQ&plwr`&9I5I<X(>X@cJF?&-ld2s!#q
z0^*CxXOHIwVm-9lNk4HKyaf?;0xuQK+%jRhQ_$;~1dWDACk^UiUbnht*^LH`_3Y1T
zl=YR8SHBA(`>ZgNwcu%?%81r?$p|jP!b#x(KW5@ClaNJpI2F}lUW89Wq-co>P>N^4
zLFW82YKLSi*$t}jlZ~db#nJ~T5hql%Ko!d5F`FVV!iO@S-LfNYqla`*bF)0h?^R7r
zCxMl1&!&-2q*<;_<DlGGh~I30-9YnR@6DO;)duQ7BDFu|(L5b+GugAl&x=OG6lN2&
zN(pCY4uqyUG$|Idr9{HTJ<Q7|E3mSjs&tDAB-m9K^%&pG-aX2^y%yFM_=i1RBRTbC
z;_Y0VQj}`lY|PG%;l-h+aktFfcwkJJC$ox|(sA-Ym6pKyJg2OfF$bd0flqJWT)3bX
z_6c2chzlpdAQ?TLju<2(I#HUUUzM|zC$Y#VPUiNbzRQV=UfH>&Chnzsi`PVlN*d#&
z&ptfh>dx;03G<!`qsZGU@#JXLRvlCMxL7@&-kw2`eN{<VR1-&fKg9d^fwt4mabJUo
z?;WE~pR)78i|2<TMXDPv*pIu(V!N5J$vPqRp;`KIQ*nmghpF7(oy<ll@UMp9XUasw
z=Vz~jaJ3(b$3N@lrpzq^lcs#c70y(#g96(irU+m5RA**0=a-j<4|01|SfdM=9$##p
zWwIHnP8k+Dwp|7v;re~kfv(5JlRPU)d14g1*z(q(p%J#irCoM<+U8JcQ5@AyDQz@O
z-r5q!MU}xt#eT1&{-r-V)VJ;saMk!3DbuKR9i6_W;h3E9{NM5pYS!`l-VWM7j=qq(
zah@*6$y&n7N-Uzq7)A``fC#67H34}L?8-=I%2yMBM}Ms-<4N|TwF*PXh6W4D4OyiQ
zhBceL`k_A<@q7l{_|h}hb_1kD+}VuJTI{Te<ED1DKw5=!4Dl5i4M8B7iF-KnOOFVN
zhcdW$shibd5eja$OrR{7t_o)giyOUytAG7yhGQG3UecLK;kCGwNUB5bM*zu#O5?%L
znv}bgu6duWtjS@UKz<x%<!%Ep*ji`Uxia^YT_kB;1fAeYd}kgdkzM>cTCiy0!spG1
zx}mjt^Ya&|n;@PNj^;lQcc86t5QSG;{@F`Dbq6Vr?~mEib-X#>c!&r9gen98A<$FR
zd|h3{t{0ud5{LM-obN6B#oEX)dRiR6*w8TkZoldJo!{xj;PPhW;~LwexYXHI@$Y{;
zpJZq+vVPaLbGe&?T-;C__cY!1-ti7HkL)s$v*~1}fdGdNQkfbIRIzBJj}K>-5ze;Z
z0kVn>;*D=7)oaU)V*4<zI1-p~&3^Xv?YMF85{Iu08FH0T-t+3S=+_UQi;8<Xm<?lo
zgIR{=^8V~P^@udheQxOdDdJ+G!NaS(ax`dhaT#0470JF4(blfQ^=nrk0_p`{AI&BH
zbk*JDq^u6I$@zFIYKZ-%_ANW_PgP6v=VL`J8w><^DQCMXlxKsxR7~g7*HTQeZL-Sv
zUej_HF3OKAB|#NG%FgP1U-(BrFQ};KjtAGy8o)!mO-!<-h4Q}(%HChBE|E~@lAh(B
zTsJaoZ}*h@>%8{AHl-L$8NW05<@4&1ZeQYtR15y7!^LI5D~~q~A}MP|bK+73|F)$?
z#84)+G?J6<i0)5<hpma=BcNX;YJAlu2GK;o&IutWwQH<NsL$^LDQL3DCj;;2X%t!J
z$X;hrQ4WB(e8=q(OiL0+ayHD>xmqtca$`btKJ-)3ICBpRmN`Fah<GOFr7}%7NFJsv
zAGYd2Z57VRk&Ixc!lsD4kp?YHF)?I?p&#zUylN!sjEp67*E*fey!2g-7E9j;r5V=S
zPCujXqRQJJI~PT+9pKJj9}1=NDPsNEW|0<nC?mgfAafF#!;Mv@Y?D;VA{yz(jT{Yb
zrg8X?GxPqOlb4~Degnj>h!-RmhPs)u5Hb-2In-0U4*fRhm$g!27?!~rZuOBYIM|Jg
z3dd$H(WoF?$UH}t!YcM&jr>wb#FgPoZCtM0FzLz^_2bqj1H<)2dK{hIJ09#IBC#(C
z2oU7~gGZ6XAsspEyjSvuUpO<bKojaH`X%sC>NuSYorZA`0T^!n4B%xrI)b{zdU8Sp
znH~Eg>D$x-rrZQ$F!J&32CpCXa>(52N?)zyANCsG$|mR}e0l>uIDq*@zXknP50opr
z@YBD&nGa-Zy6e|D+}Ybxa?gKsPc0S%Fus55JBIZ*?$s7eZE%Rw{!7NJd3gQHz8{$S
z!));hS+>%P*o_K`UfLs7=}>xB-D)@4jO6tLn%gcmO`r6rKWFr-l%zsmZx*7u3;7>)
zV_t)kapF7r-m?0Pc(>ni2m<uctop?%1+f07r;O`%*!qQ0uM+<+wqOOhDkhKISNVg2
zU}lO?|Ba;+s&t6XHIH^S>(szKSmZ6H-_`m%1=m6mWJsl<ehkfEX#U^3c2XZI6YH0G
zulY_+P9@$H@fz00n-NxDx!EdH6$fyswuf+qiM0P**rA-?={kLimMjjGHrNjuTm6@l
zbPPwARMztU4N}Rp9KClwSm0BNN=xAQF<pX`)bg!s2zyE@AF$e+J43hG;HFM2$zBEt
zstAbOL_sy7-!@Q%?P!Od<u^zNae;7{l&KLeBRi@;r=i#Maq(svha0&;>G}wpfHGeb
zIC}Jjh5$0>;UIu4hL+ITm;G}{i|Syt1%EE8^eKa8C37v1Z4Tx!RB*BzelCAymwaBS
zqJeLlGzxmdM2kC>=#&3gB9b`5wo^3mvk-bmSIGW%2uM|s5RKa(6AtEc41Vl`ukk^0
zN|xB^3?><Qi2Hz~gL8a2Ye^`A8APR6`k;8dCH&XaF8<ZZV&(kvHcGN}ERC_*Ao;B6
z7FnhePqol>^ZYI4%Fx@k*cV2PTzK`)epok8g(12)CQ*$SN+L-5C!OzD!PdJ*br{Y%
zbJnobXKGQ4BZK^<o;jm_V3nS}H@5fda9E73FaGQ2(Fzb)KtEFz;tXe59qG@Pgm}dz
z-}?POv7V>?Awr@f2v3GII<?ozb$b1~3a>nJuoVklaO%d&T|jSl*o}b=jc+?;!U&FW
z-rt;u^jYIQ{Z4gQ**Q`cSSAs~NoCeylXMrR>x}-DAz5>$6mS!GSKxPZ<z%_lUFF6v
z=KQR^7qBT9<9BH)Rl(2#OGENsU<QU9UGLjL*(JfR)RenTH5PcaZl^M!Sy0{56;Ha=
z#McCS_WK8y;Uk0#oJ^vzV%<M^yQbE*Ui>mp&|h2(@gX~@T0t*V&3Kz*(4iV_koH|S
zZ*C1u+&^oL$HLVs3+YvVPTz(hvoyUXTH3m;e|8J`q!^Bt{R4UqT+TM)wrGIN{jdo}
z9vyabbMesv7`HZw$+?+0DNh<;D9IN?s5PwP{`fVd5Er!0c(J*gvHcHbfv&okbSM2^
zB0L<AF?&mbl+pi}BZBW#Q&i}nR8_*_Tq8)1V>O%mDYEXM<nixmsLeD#BOQ2ur`oU^
zsn%GJt7x7(57C;2!c(zk=%HBZq0w2TBwjU8=n^q{?Gb7v-RI>O<a-gSgDQJ?S4bE=
z;KA(3oK#lKmB^l{LMMgGR)_Ghy7;PwZ+V|PYuO()I7qT-pHT=T4YaN#x#O_7_kV8n
zh%dKQMm<TnSa0(i+U)XAO1TIgj`4F#gQ5BkC1pF5?EVjDZy6M4*K~~zZV4XT-Q9H(
zEV#Q{aCdhI!QCymyEDPvA-D%;aF;;N<ay6q-}&`D_kDg+HC5E!SNH1G-K%?py&H5n
zU$q!<XEtH8YsC(h!(1BVhu`Y_5sW-2NK#m`3-h3|MSz0s(>MFJLrviP1$Y2)%7;4m
z72COi=KOJ-RqFcaD!o^whQVu$S4zhjny*tfMHlWnFMMpfb2X$R2O)x(eQiXVB>3}a
zBFphA^rqRl$FMo!2YcX(h18#5V!%vjzA?j!buafS=h-Z2Y2{x*q^KdtuB=-OAaIl%
z=41$jHvF3Y)ku1+{pNlql{f6d*4vCXiQsg!ux&f(DS7>IyW@AnpWDOh*)ueAD=TFc
ztpcNS0keZi3tEX&c`2igVOU&#xzO}u5gkGzr+2|lh_P#DEw&C9W37gMjNNZ(e^?&6
z1L%aSB)10$05eju#;tY}YT;JmWZ%?>B@yZ)M9=tETva3O;Ikpx1f|-WbydK#=bczW
zQ|K>82?O1vwLJaQg_JHMztn+)#0S8^0?DgFuIN^>Pp6jt&(|H2X%`6+{^&0#iFzQW
z{g`0A4vZl%8IhGo17=XaE4?3C_2dRGY`&LjIF+B3gvOs!+(cHX!Sc-nRH9wd0JMjb
zkd+jfbitL5;~2l9a&L%|vi`3Ew>}iNBTxyuQZ|XPp{<LKG@y&D-BK|VtvhX_THj0O
zrf6jt6Kew09`>Q#7hIy&ke;OjQ5&@~Z;9A#qj5~ji3-5!9~mzW{aZYzLDpJyaJLCM
zd^*d3nOW&d)>x!YVkMm6AqvuE?{nls&+Dm1^Z4bj`pMHrNNg)4i!)yvA^xUV#$XN!
zL5Y2HDE1Ep8(U0|a0WSBATgoT-j`|ae29#71hwZ_HYK<y8*kfkYd{l<7E7E4FDGQ4
zW5=p*+OCbRvCD)8DW1=SD8<H+X|sYyxnC=Fhbl+HJNW0Bfgw+&qiuNq6$MeD3n2CQ
zvwWa{_)KQ(6d)6cW%|I>r@=9Yrf?Y!c7n$Xkevl+^nh}QD9<b>?;C7`SNzi3I5wfy
z@TH!rMB%pEpj*uafLjPN^2?nl)kkfo1JDsxso<Wr2E8eijdc7D$3PK2%g=nd3B`=O
zlYDHOC!}Fu_nIy$4B#q=2e@xA94*`FM798Vg-I`#ar&cAt-fxGP!nDqXoelBx=j(`
zNTC$%$jgkV(59I{&PrdSawqu%pCQ2emw+we2iH?L^hNi3DsOZ6_-5($=21JZ2#knw
zXn;5NPkfZo>tgDsmBYL-1k#P<m`XyGnjZcSxMtav*hjw6StEgcbU%Upjdw&iKI9K2
z-g2w9H12XHk}z_BP@R`_E$?*1hll(9+5X|{4PKA^@hyL9!D)~B4p{2#fZaEt4|jEy
z^Tz4bUrT8rvcL%b5MkXSd5at3#D(;_t1Uo}Hyuf$C64=p0-M!jTJf+&B?Rb)!Gzz;
zsQ0SI#`edrpYrsQ?wS*e98F>47$dyA5vI*A&i}+igvuj1c8d3FrLe$VH=Kgca)~JB
z^a0Ld-((*LiH66R+rUfSQJ#L1S{jUQ$7g3bkWy;G#PheR*L~KaI=~WmRsY!TY~+Sk
zt6uHS?5n2ZyQ@I1+ji&kx{Hod<m?uRGvu{=$E^}-JBcunpx0n<-XE&Ko;Qwca-Sq6
z>~vFHh0QOdm)_;(lVzlq4%Iup5J_gpHO(d3M(fNC=oKiM{MQMkr|#c`vWjziPjc9v
zl>lHDw1H^Up&r=fYM}t#LX9qmYnho$;O_)|c87!&@?zuhG6!!q?$WN-7dQ&jBS^wW
zf@W*<F7V=$2(wk-z}|Iw?Y?)(y3ibF4U$$H3|(eChcTE!FF7eN9!U<1#ePQ!%A$o9
zIXCeNwk(M*$^PfUm!+OnA(|Pvh@*F#26-W1uC=WoT{o0`*X9N8J9JkXGJW`EB7}hn
z0pEf5;grcJNBCYyz$8|)j(0%o4iVASa%s>!_wMLD8!5T%r%^MJMr}TwLVXf|6<SXd
zLM(mmgpAWuLlK~e^BsZ+QJxRmjKm87$jOD~J^+S(BYFDuusUZ4eRMAzIqOGYC;gGu
zK$f{FPw#kDXYl7?hhvN6A9@P@37YkCd|r}>dWpORsMRAM9MLJbz&G1{p1Q7WNwZSK
zAJ=@3?2&AQSWzgR--b9Au&bJny;P^e$#6|d1RE_v{0zPx^sgqwDwGd~eXr_Sxm}H6
zZ16YN*I3dpQZ^U}%Nl?KBifC%LsLSp-J)w~T@E4BU;$@YD^CYcwshWU`pdn1tBD<^
zT(|9stPc*Yd~aF3dF)>7t&}opp?iIM#p&gFkzm_9+uRb7f}mxEfh;*L_i6Zk{zQlu
zmG!g9^x7@fhXd5O-Mq<fA0YgB)!fBI0%B@p?>~a*3<i~0##6wuDhyv><B&Pxjvv<4
zt<E-wE55_5RNRpNaz)&MKyy)c7d8(7`E4bW3QNpt%ZqG-$G}awjpf++6ALrXz*>MR
zAd_(f05mj6x%>0zLSJi6y|9(~v5;YbxUKQLwJ7R?>P8162uGvb>%K(vBX5ib+$QiZ
zmj`y`ebQh$?HOQ*bXC4iQD>549F?Jt6pg0fI5<HT%8Gts8v0Q88s22>c{g!Gyi(gz
zJh%k)-tFy){#|2>^1qYP1vM%`I^+GP?we1LG9f=8hw-zyomfK{TqG?38s^A+!;&ap
z-}gfJ^xN&dvC1mDoqh9mPuJjX0#v@{cAuP-`6Z|Up)M8Zf_Z6|%|r>1?CTRAnALBG
zIZCaWVg}5@CdmSVumI^H=p4tUMx?uek+Xo^5;=H|eZDyut>0#~_C)DORHd|+?D)XN
z-i}~jlfV<26Mmo%UV5$)m$?OhbZOzOHGc$85p~#oVx!p_+P35?titR%E8u*pw>%@B
zYkEFqRZ2fJbL9<tRpHQ@pcS*uzF-R8Q&K?R#WreWS^!PQjtm|{8}KIsu1S8X5n=d5
z_%iN|j^g-NaM5;8&J+$6JnGL_;WdTBLr)60#d31pxF1OgOQ|ySFzEseFx{*h3X0av
zG_k~xQQ5?IC$}@hcw9^=MwyZBOJHK)w7ylVK8#fB3`y{eY2Ev(@rPqIKY?t#wW=MZ
zAQzbY71&MecR0!!L<*4k^sE~TXkep(-s=I3hcVO=ZfrQU<^%zvH{9h7fzc5%kveBa
zG*z89SvVm(!G1)`nVvR~_lO@+z>-5I?>t?k3q*>=UGIhAUqT5+uf(mBfo8<>T{i<6
zDC$h&Wapvn@dGS_r`H~vPVDfFG2y(TbJ6cn$u3NN%qh=+t5d6<KDN`-gVV$$253pX
z6O!ZpaQW5ohpmvJ4(u7!aTwqut%?<WYNOT)7Vr6VFA6Q{&AS(Ur?r>I!R3?^!J&$(
zeiu=Hw3?&issTnDm3E!vn6<!y7iO>fTC}2#0UK790II>}=qgqyNDzGw5MVf7kkEdb
zM=Ng1Omc;--NCyZID0?KtLgh2`a(l@Zqr7(^uPoI4oBDMLkeU!Ow$Jl18e#KGTPsX
z!-bwvs37B?a&Qbb(3ROm%fs6eGtF%n3N4DLi3VkIRr*}NbEt+0?z4{|i*^NW^y=6b
z4*t0S_<tk@so3dodD_%*%(nvFpfbQMx{)$}R>B8hOB!y}(5zQ2R2>e>jC30gWJYVb
zjSUO+ycc5Etvd{WlN|4PzyKHpuAq~XU%rET-YLV#NnqzQtP@L*9(;!wZ>MlO+GQs2
zDrFz@nmWcFCRv`1A3i_B{wGr<6z-uPa0)``X<lXMX`fvCnj+&lpe*29I^O{@6=o)+
z>M{UaU~)B(M)(dDg!N{ex$NvsaLEx;m%Ue*FL>bqS_+7Yt~ubfWxfb0`r#o0rQ*Ms
z7egLy8`6&V#dD5Dm`NA{9F;}oST5X~-}DkYD&?4tJ8fIP_974l=5hiuBf`n$OOuA4
z+L1NBp}Q8&_LmmMP7?*TVza;kgw4a4%Q+MWbl7PQ+u5aQjy>l=OkGOrav~_eEQ+30
zapU6iZFof^^N$=cnw7gH^2JVAkTyRfGVol=(bVY|XEjj!l8h^mZ5I(a>6?GSR2ugs
z_H>3nFn&dPt%;4#7&5vl`l81iBt1819fwMjVqZ!rTovoc4(0WTo`@=sLyXr7wu)PB
zEDUZOe|NKMv>VdMDQb6L{+Sk=EeS4n0U0=b<YdqZf$Acm8sk7u48DQk`sd-c0n#K_
zp*|Zr_{}}__h0;a*~|SuV_)RdQQ_be{XUkbucj(GI*p2gdmk6j%6cZEp``z!g~O6Z
z1BiK+@ftPMO*l1yug!!ALK4{{sV*75sS(|L(FzBZG?9p=p6vRq_<voHcdN2|Cf}HA
zs_3zyyL<+?Y9m94+Vy^-+L&jKd?kZVcV`5+ks$_0lQVaEVN|p%+><b*=2FnOu3u{d
zAL>%iAYN9JMYetWv-J$@#d@kW49ktk_931|#V`D7Jq2mo^_0y`Q~u?Rv{IkPkne%*
z1Hu2h3xIG!@Q|~E_Ex$OA`<&|ouJKc(74EfQwP1bRkHA?1MCQF9FG+6954`ddji@`
zuRo_J49BldeLlwB_opQ5*~E3xaBR_O3|=tIFM)Yh2slArj32+i6GX)tIiCc>*#^Tk
zp^l>R4MWJhSyIq0JCtcjVHD@imrujQZIbg&E1xD6kyv1)R<)R<W1r$7QvmwK+J@{f
z9_E2FEYX@ac6{oZS(d%ad}@ukY-6_lUS5r>fDxh8L0?H{KsNDZDr}h;pQ2~x-K9|P
zF?Mz#q@S4?$g}nf@FkW~cw81rsHVp_^R=_v&uII+MoMbGel~)@6OfoA{_Z!>KxJD5
zzbZB`Gj>6Ao3Yof=d(Kiy=%To#toc-AF(^;G&5zhq(L1glF&`Xm?@suz6D6%Jigs|
zC)|gFy3m~2R%5eTAUdV-7quhL@U_xkccDUx)lQwzeI8w$a|x3MO2k4Zz0)5Zr)jc=
zmJyR!1H<^)>!R6dVSVMu&||Vjp?*)Gq`M!6=DlD4Y|)niT=qZ)7P{SBUPzxc%4g7@
z#JIyC@*k<z>FirNoo>bRT(w=nr=!1Uz27mJBQpB_9fN1qPG`u4!Z=+(bT>Wq^dsLY
z;o1@>T>k8N5MV6U)J+P9QHdx}kzljqFE1wZLaep=N(J?&q*!fKh5&V@>r>nmChZ>g
zY}cP>t<af-XMcTxHd?DpAzy8rT$I91txwM2DCc9vT3MdB7uTB~TzThXHwcbdsQvtR
z2eb`sPC5Xt!@xT6kHWNd9ZU)R>xhs13BAZQOzZjWnKs3N2*n~~^A;*TZIp38mXl7t
zNEr=%Yrj(`p1Y~&0W+dc?o+pWYs(M<%xX&pk&NLsUVWS|T@~GPjnz$~y2r(|$dnT1
zXkqi~E9yeG0%BkQGY{_p8@7<qu;*{x8_C8!le0g+tEJ-XJ>S8N4%K~kJ<RxtR`F;G
zAJzJt9%tgYuTW1h4o<t2O8va*M>82h{Pbole}5v(l+6*x<IuXJll3o4JdgoRMn??D
zHjS~XG8mY}Y;1<{#EHH40eJAsvY}tLlh$lt0?(z*))Bs<?5dCwZQ(@|T_>J_0UWVp
z?D~nSZ01z+7G5G`7(-MkCP`~IJ%1p|F8Q){1Ymm26iT2Q65hOB1{)`ge#-l*=!OnJ
zhF5F>jH6fW3eWnki3p17KzdL#67{@x=1(OY2m)I6jlt&FoYjo#hK|}|-m%r$56zEe
z+|5)A;J`VA`i7Qy<=#0)r^m&&iUJ6~av+TKb0M{fNF_uB?WZ=<oAN!m){-x{58p1d
ztWovF@$pSF%?<AGOwLGc=~T0%vka%#QqO5e=C3>A0XmGyp+aH&Nl>5J65+bm&pwwb
zC(SI2wh*OuHmN1LX3pG<M8kloqNI=7w@AM$8V64Mxdrl2Ub_2dqX1qZ^6~@7s>abS
zPFuutb{}#3(NNqTovgltoN)xv1L<$up>VDijTxMe7)4}k6Mk<!Ve*)sm~AIy!C9=Z
z<F1@u>C#ky5Icg@UV>5}ui`R|;~%^5e6bQq!35HBl2=YYbJ3@rz3@>}A#yB!n%*|K
zdpXfq_k*KZ<KvbS+^My%($HB`2Ti4CSFRA9?>(kWL@%VJqv|we0htoobwiVI!IY^Q
ze_p7(rVVgXt*J_*js){Qx_SHNQq~u;WEVVar~X#@@fgsZC>7^Xgle*!)2$tA*2lG5
zM3tzWeBIoj_op#&K&<BUcbt!kPaW&skdh>R)sTQXAoG3CdJh7ofd2e@(O?OzbrZMr
zBv$D!#K03Boz$i0x!UvbkU!v{)2&)*Tq+9x2b=#)sUT{6rb%6bh=rfMB{64fTysT|
zSCfQSyniNX<j5jYB<fX+^i6Na|1gL*F(!l2OA|DN?6c5M((nk4_@!zyhsFRIsx)NL
zWYSM|-S1#x`LKV$AvtF=QrM|zh88f<R96AnjhFb|cylzh{u26l41Z;$)qHs~?c#?Q
z!<vu$@voI|^d|U!88#qme`KM?CnxP;IF&D*18wmgTDgR&#ib=Lxx_efq1$v5eM{&v
zTn$XFdNR@{HUa0;2QZI3uq-UdJhOKK4f<Ocv{*@CQhg{yq6FH9JlXeOzKQW+$4MC-
zzEiX~5}E(GQagY|)TjuV=`EAf%7l!xd(#A1EPvknMwZLQF;3w);qq=`sWg(|*D(n(
zpIjX6`Gjkvq`{tP`zcJXVc+b#(2C>5382N7Ayw1+sC~I!J1XNfEwoDRCz^e2V3v8^
zWa?lvh3HG~k2?T&qiw43aOyEWUu<YeyE&T<x<)WQQ*-H)-AJ|=<+4{(ocWBBdvrqt
zU@9VTuKcIdeqBH$tQ`AnX}&$1>epS7W}|K^wsCL2XxvtUDTAOJxO^}2$?z4y#H*zF
zHp$pfE0#`9k2g0cOI?;IV~m4f)ce?<7HH{18dke)&5&1a&f8ph&IfO6brYF)?pj2f
zej+^+tsf1mU72)-h|?~ba>`*YyS7;Rtdc0UCSeiL!sVA%WP@WN6_{~R6yTp@!_7p-
zwDH8gJHoEIUynjkCJ~Swa<$#b5w%D_sXC4c?G6grRtD#rG<v{NuI(#4YWcM8ub^iX
z3*<zDt@u6@6`XH&S3ABhk5Td~erieX?^)(qNO)%ApM0)Aule_Uq|#0PdE%!1Z1mCo
zRT=Xlv23(I;91iB;uKnIpnsf^xjF!7o_Pz>BugBVsp>*TIQmu<5NIPD(n@e@C+&iQ
z+N%f<<GrkV=W%aVOtp`;R9yG2)u@#Ad=u(CNeWQB({dhj#gKNBkcigdn-e2)NmARL
zq#M7!O54zooJN@5Em<x6^gKS?(7eVLC3Z=hhE&gWur`QhX5LOmTD|juGpEA$PlQiH
z`}>}p0Ir-xSPx%LZjFDJ=R&mg&<yB+3MjOZgRB3U7=yg#zF%aHvE_#g1uV^u4vIyB
z>`~%qB<{!HLx5DSov=J%eAmuK8beAGnFjXe4gKHI39`if2%r(ndO4x<g{oz@n;TTx
z)&m?(YuLw)is;JxfqS-x_brx7>Q71}rb(Z7#c>pIw*KKu0uzsfmw`lY8s}v1?5#6E
z)yd!Dww%;>XuDn{?&IkyNdL!@D)tM<$_AzRG*SA^qw#mtfb>rXYs22Qi)kr7Z3?0M
z!EEvlD0Nr&q4Inyt7bRAXT1i<lc$i~V!6zz`{;o~x3#D<H@`spkO@gebfS23y2NBP
z8p@QxuA-+71ghqT9;9~E!eQXkkmsv-C-Z`S&!{JJa2(;by55&Ay@b;k-3DJ9iJGk`
z8J>_O@t+;P9sugs2XRBxnUI}fU%z4vpOm6ztMcZJPd%(%Keh_0tep^azs&16U@II@
zX>>5jlCq3N1Zc;9-AbhW^Sk&ID$xFRyU8YUus;`^%Wzrv0nxbF44dWfN%lkg@0Er<
zTu0LTtIQ-xLUdPMZ$}RjDJ(~t>Cg7~_On)1=tMllceaMPuLt}%$Xq)V(JvEk4NtSo
zPfqxdUQWAx<nQm;EL*AO6Xi=T^7vf$ds(%HP(Z`JN=E>23l0E+L;nE<Ac*e#|ABdO
zK~VspU|{A=dG_8Tlqwdg#K4_Cy0fX%_gJU`L6&#Dj&iL>B2#t?E!4<MgE8Q=0colt
zubEWIYU*YkdA%jSX-VbIO5`q`|D^t0&@)4@-XsbcN+CF#&FDKwqY6du4sR6q(^&)F
zJQHUYEmps_S$Tb)X1e#xwAbmKCH8r<Jl#oP4j|x6>m^ah<d^?)EVCAS?4`TC7dq*{
zx#|j;8(F)dwJSY7<XC<_yjd}WBt(oi^TLq*PDS<o3$YQ{KNxx=hc5|2x4ALyNj%wc
z%Vet#zUPXZT09}cei~`4oG_TUF_EiMil0b%Pw&7qGFF^y=2A}?`KewNKL1MQE4raM
zMlT}~MOWjj{Y;^+AB-U`Mi`}=iLpM8ee(YEp%v0y=JjJ<cPi+@qZkRf9<oO;;c7O7
zSCtGqQkD*0(}M30OF#p3#9=g5l4lB%=I0hY{2n+zqFzS1Uu~?aZL|@>SJnt~o*F4<
zf(Ub~7a0=prOklth<nI@Vj3e3A25JvTvnpp;ClPim+av}Bq3)*fM}n6h;jm0P)6na
z0dUT1W<^fB#2}2%{jh(oiDvFn%3|jRF^m!Ke+ddf9%@0Y5D4u>p$0H=qN|X+g9g$N
zeDr0CY*mM-+&)7EqDHNG^se<>tw`gE%_!8Gwzvk~@1W{m{OtV{U93h=fMB^r*aw(W
zM>z7h6<DwbwL>4G0<oxR#4Y-SnE9yfL*{Ft?W&1*vV?QDrmlL+L?N;&w~`jD9h9d-
z3fmv;M@u42cWduhq5Gv&wLk`PxXF%O+`kSeZ9{0U;0?G&X=rVqljg!sk=A~-pY7fH
zGE{aF+xz(Q<T^zxke<&%5ww*F0H>v2ThJil-;Yi}Pe@-jMU#FMch1u?5{1uLs4Y9*
ze{XylA$kQYT{xRUQk8IgZ%clJ<qSe6jvb^*RFEZ#osTpVH>tl&;HuaAI0q(F(UKec
zRL|_c3nU4sr|*p0=Fq<x@VJtBzgPG0D`8@oDD=DIvRfjitRz%s>}+?zZKvf6`VC*U
zJJx;!wu4^6n73qV>dUWlDDmHioedtf3@kva%Q6DBpn26mpg$kOl^#60tHd><1bvl}
zC<=nRR$T;bYd>Ou);nQMZv;0hp)kTHRK0vOq4faK(`QjoI07|2;MG~8u>3pKIIo$P
zxv~i4RLQPI&!>^6XXoSglPT_`Hwy1|^>vc>@5WVF#EY?4Q|^0P)}QQUTOL-2UZ2zz
zo>?8jav@s-{$2X~NY7x@-o3)yU3z%+o9A6mAi8;I-E<rxeiysHm)FYP`sQXT&n93R
zxSe4x)x#s+Pe&L}1pe}sEEjJQFvB@Y+#%Lz_g3ey-QI@9={3yuMt~~CrgdBDm0|dI
z4=^lbC)j&prb5dVA-H_n)?u~yZBJyGJPd#x)I<Lj-@1<`Bq{JwuG)?q0$f2E#N>XS
zP#D?^d+$#l8x#(6c_X9<?}!C&@h#;eE0s_RA_V#4F)m%`bmBkNQ-L*ciq+(zU>-3g
zM~5SV7%6KRVnQl}{5n_{yfuZ2gzS`94Z=B3CjX3XW(f@^Y*=(UOy20F(+0aVu28O=
zF3u#bClZlh^PcN_9)nJEc-=kE!YG^SG-EFfw`2MrZknkA64&QSy)4UhPlC*NX(z;>
zAPLHa4+A*A0uulQO@<WQeM-~Fag&`yn>SG*gFfwbBk^wfk)1nHg1bFZG2q9y$*?YR
z-HXjm;U%4H`{nfO)7>kHaANEq%u1A#t9B$+3s4?>Uwa17yZljz<Y`V>?2X<)ABr@Q
zm0E3v{d|4g)p&$7VXG97r-R74W&x`CAzdQEj!r<};UQ*9jX~vi4Z4El35w24N&3lN
z1h+ewzWG5a=-d7$-5mdtu{d%OuIR=__E2Fa!_VK7rzukkXABMxV>eLZL<5hM@JI*)
z5GQKMnwx_VqVTD-C0~~<e;++w`i*Lklfi}tqN7890wN+p{kK2(^kJU|E!@mHBd2vj
zMJfQq$YE@pobym^b#*;#1E<Hq^iq_t3T#1GWWWmwvaG-ieT5vnt~9nvtVH=q+tO@n
zTIE(7d&Q+SWd(<$DL23QlQRi@L&8PS8-cE?-^SMFwL8`j%0}-QC7Z^>Dref#_y&n9
z%DJUsYp0Z$ceB0x^qte0r6TUKMGg2&)z+tR)vz%O@Sb*1ro?AeFM`miapMTdYsc|v
z2NjiagtgCe2C25;3#qyFl9h+L64PG%`e%wX)`Cy<wQuRstQh$oqWn0zfuke4czGE^
z&4h>S!uVmDNHd+d2q)O_vXxr8dOa5bKBTgh^w>{B`9D0W=ABSxG~&==N6`CJo#gbt
z$Mc<r<y=T`GraeWW5DkobOk#zgiM5}7p1CvuEtiLa=|8uJ5}C#8AcW(5Cp+`zG`PE
z*t<B9MP|96($ue}qi#Gk{8AsDO{$i}im@iXbAB(6imeR8@bDb#qmnNkxEaBPpsq#F
z=M$nlAW8pe_|w-X;!D1T!x*Ov%N=RkO7Yh(_=7~nhj-jXk57&2Wd(Y>Bl_o`L_F?y
zn6kqD@pnasE{*R=!p;xrC8MFC5x~~e(1;)3S0GpBry_UcK>7-pyfL{CyenT-yxmZ&
zn7zxxh0?iM7O{Un$F;OCSNWi)c9tUml{q@C(HS+GLN5Nx^lNDF*T*VH!Loj=nO=Nu
zFE4H-`u+Hob)bO!RdRz>`>H2XUpeATr(p?B78=eWog@wI)tHS1n+OSff5Of(h;Q|d
z0(1w<lbYsq)6dUTYoYW@x^&9FDoGeG+`}1u2Lnx#0`8}aHj{5xnC*98I`)~9`yK^+
zb}o|sqbItxJ5H-5sLq@Xdv?FBF*E&=#)Czb<&Ly%e`LBeT{#-j#}AMVF-7d;j=_+_
zfwo4Kx85}P)<xRH`sJ46jQCEZW-h|VdxLO&3BroCr3#0FL<iqB9CPvTs*JEbwfF5^
zg!`VJB51Xs{8yLxKc1z)97IbG^Z^+RnAD?=n<Xmpu%sw3Yx1*^JI+B~-h=WM)ovkO
zR@P4qIggT&w`ldD=5%l<^_|af9i9-J0l%OH*G^Wtao>2m@Z4|i%LyK_+>bpNl*@nF
z@fmh*{n0KOQtgT&Y}TUr^tzaprS@v+hLz7O7ub>)3~O0AkI>1wiP1q54uja1@nO9z
zf5kFzr%1?vGi)P`nMV-IQ&^6`zGv=pVZ5}dpEi=wzCtEjmcXJk?2)je&S{;NzN1eU
zqNMMo3bMxW^s~;Ea^-@NiPeV%XQY*PSc!~oWiD>(y&D<`SZeCloVBcRN%RwU0x~NE
zCn*Q9(*?wS>*isDUqS|VLO0Gr*A7pM&UEZ>T%q$*+H0vS&kL2S3sP&pmx%xV(wWrK
zDeKZ8gDA8FD;_8^a@?AKBYf!C+dEB?mbB&N&Zv6Wp1Z)@#cO%vQu-02!=SQ2XXlV`
z{>OsHkyAh}Nl~kc<Uati|Ib%}|NB+ej^^o*ROJ_}KaABTN+Ti$(TV|KkM#K*P^R=H
zlse0FzN~M)g~C}bs4pOF<mq>a)Qznh>bpc-t}~bYmf*fS!5@FV04;*g4xSA5A9Nk;
zrQD*Bspp9@+<j$WEwgA5H9Zpx11Qq*-TQ3H$<t&CwalEU!)Aw|CYiJ5Q8dX=YnNi<
z8w0Ib!UkW!pNp^Qu=M)h-FzLV0Fq*CtJc<R`r$0Evls-3@X=cf(qS<KJr!VuooRrA
zz01E*z@12@%<YIVjz~iA`<{{v`qn?xtn;5@`u|)-P(OxeBJ}N!H(fI%9Ppt+E9wV|
zOnf}0p1EHoU@Azvb#H7dZMCWQ(#2l<(BY!5n6{MFx&(f|@j-CWrdca%XzlFe+X2qq
z^|o(BPuE5)OX(V?cm6oI`s{w&9b{0uFz$0TGh94=++MS_CekMPAa=23f;r*_GGN|K
zVJOASS4;xfJ;3ioPAdhX8Z(TkfpwsC$8AQ;km<Nq%ZQZ%-Ia>&hf2^<U)V9X5x;*T
z7=K7jkULPKnCTGVALhb^dQJz5G=E7xwvF)Mirvxtf|2u$;%JwS>#$$&X9bS(G*!I8
z>cFo_t_H%CSU~kwBU&x9E(9Q#V*(*4q@3XPkK*6|F`HNgh<y}tCgX(mGy=EFk!SKT
zD$SRqf))%dJfIZQ*ji4gL1-?-AV1cfB|XKot$G88qjTVeR8;rc%2*s7Fe_7iSs=-N
zsLRhsbR$|r-@mil2XV%_(_R*|85JSIqFxd(=jOA9uyo}A74V+Vm)tWv89+Q>23wcX
zsO3|)jFEPOosVDVlRtWl(l6@TLa7obMPP}`snuS&I{JMCiyZnkh|L}s8TL0GA>jp6
zZFMz89;>Z`ATg^q^z8`v5IrlF{HV2Wf97IgBd$T6St;;K!($%}j)*jQ7CMx-hf0G6
zB2hNvZV)V}ssBwNf!w1IG89HWX;^CV2k2>*pi&B8w~%}D?ud@%fIGG&&2RVH&KmwT
zEXzrw_tFl6{B51uQ9TE9-d?(AYyQTz>`SVz%1Lhkt`A!+A#TDq?k?SvYprJ{`bxOV
zhi%P#>vtJ3Q<eVq-K(!*_WlpmpymVj+qYY%dzteGnTuIVr*3ywtBs0wQg0B$(yxG0
zdMF)OOFwtT#oxCmGbbBn1%Veqf+V4gN5@5?Yjy`7yW3t?3t&t2Z)FGLBea!eDOoT6
zZ|_>jWFZGhhXe;Z8jA6MYa0=P_kW%bPabZqSA<%1@JWuGd%rXiPfrzpfH-I_UXX=O
zpvG8k;+F?3x7LLpXSn)a%Vz5$ve1wjv`zyyzlct-J4mIq_#j8%x9sG@ZUy+^z&lPd
zYM24oN)IeVikgS^2{h!Z8GZ^AW8Sh3nLOXd&HA80lKSj&SsvqF8Tln-&ayF##;J*G
z&z=$jA=w8>OkU4$mLVl!OU;AE5erk`tb&<mPzSAz8_e=H8?2i!XF-?UkNk%!Izov1
zFGoQ>yiY>H-M>A!WWJ%V2J;z>hz*7g#69X$S3hlAVR|w^-!g8%TAFX19i&*}*KY8%
zoN)X+Z_##JbmL8z&{ywPO$;b+uc<xU=(4guZf@OhH1q=5KdAW4<(CH<oSrGRy0*33
zOD!#)fz3gnR{ui+efQR<&Ekj6Yr3;C4R1eAYj>S<9tV+t&gPBp0QuraB*d8tRgL8w
z`!>IiZNe;`M9DSuktDV%QZm||8Xt?}#fnuViZ>-e+*-P@M;}RO&5yk>@&)riP0xaP
z&0Tw)4uisqVu!+G-9NirLM;8oF0@s7AoREn7h>5D6qMk9=@CSKQATQ)wmGb)@zY<l
z5O7*~2PT7Vs+ecwUGDn`Yq@`+?QYpFDfk87k#$M&VrxB`rFLz0JOm{4m}oDxFk@HV
zZcuyZt?MA`Fxh|K()fb~^nj!PJ>ZAt@y4RZ;#I8z8rsYxEhSJDv6<h<!;?<*1p_&3
z=cXNv9+;*)YN5o09nY+$T(gLfm@g4{-tDX~1wNDv6yYB!rv0?tP7MhfE<Pt{Zrdlh
zUbQa=V%&5of8)R%tUw;2@6X|LvDmzve$9~lwT<CfVL?!8F7iKMKD0r=Zdi~ebkp+&
zNG8x-Ag6A{mbPGR4gul@Btbo@xcMoFooRn6k}{itHZ0{!7wU$Db2zF4bu6`TUqITd
zVANx0;au-H5O-(ys<un3a|gG+&h*{$#>s8%{Jtyb&F;1KfyKghb{I5SfC6mo^mu&(
z-P$aL>(s#A_<<ijD82lQ@~&B=hw7M>4|Ipst80&aL6JI}M2=WPQ#8XXaK!63MuR4y
z#Y<j$;`D4n)BVMIoW)%N#8sXssn1vzr_mHIXGMaTa>SL7_nLU1zxS#6^rvmFzcKd4
zeJIYo>jc5Rb7S+V_r;P~+U~D+<3guS9l{5sdJX+4s9CW6K3nESb#%DDKI-&OZcK_Y
z-^}7ws=3I}21)1j$B#d8$f-_zMAt9Ng~n+RXDUbctblH6w%N3vU6k9lLWb<)kY;Q@
z$jwaisI_A$)}1fD)2ro8<7EXqcjS6?8f<oE*Y8^)%~WjVkleaC`s8d5wd*Wl<gdwV
z>HY5WVuEhMtT=N-p!gasPe$;b?A*TJ%Bn!+kaZ*LMfuC!l-d3k&+;iwn;x(_TjGlw
zez_WaxeAuK%#1ZAR7c3pz$-QMZKNRe967n8H3TdDtQF5p`PqbjX-%4A{>><fLIW4R
zMD&ja6=sW$t2V9xK^hWKE*bwQ;dE4jew}NqDD;==&H`+h;YDHQQ^%j=n-yoH^J&8>
zd<AS+^qdb3+a9@(AL$%0=wvT~-7xF5jTi1F!4O)3Q?J~oXTS=+?jROk0=w~ZFRlI5
zt6kckxXIb~sCCjCE`6wd`2NhdJpIO8(Nu3+?;2<ASd!(l*Y3qy5o8CoDh(y@$cLFv
zypDpEN2wg0mjk3Sil|H!Z`SJ3sR;g5?BBDibk??mqLQB*-Dg@`kgF%olhSA15boQ)
zVkHH81oO+cZxCWKeLdzLpSJmF{(6}2HJZ~A1dyRK)i9u^`5|DEcY^{%HT<uPwa4Wz
z-#GjY9p4{dk0_)Lr4y5@)L^5ibxzRq<u@%PQJiI-N8a!eUdn2ou_3Cg*GQR#9QsDj
z!NH9euW6!KO>l_hVYSxFuNDpz0g^3a?ofj~-0EP<FAVJpDA2;@#2v=CW*_G747TNn
zY!^q$FsY6>E2xEV4q*J5oPm+x8&6e+#NP7MFG;wS?+JSMRmd|k%axoMohv^z_r;8b
zTnJzNNhKx21z#1Yc$Da{^V&`0Q6cHkr7gN;GeH^qtV#?`iZtS>R1XsnOuG0`NxKFC
zQBQv)Eju0>V5g!qv}+jB%(dUsZ-Ytaz5gC~NMZut{3<dl%LBCA6%Rzmj9vMN;%To%
z2rTHCVHKc*N-2SHhG)JVx1k2r%hvVxJC^s18*7_B=1rCcJhdBsKDE3rc1zT5{GhHS
zr!xbE6b;?mMU96PgY*5*;CqBaK|d#b)dw-wEO7Jtl#c3F@U<jAsHhcnQA5^y+-P(&
z(Z9LzV4I*Y$G_f35NdUhHM?h5CJ+b8`%>t%rD!T9g%|!=??U5XMgQ=w10za803lwk
zM43T7cOxVr7jiF--;sWTx&4Rs_{;Y4VQdv{cRnAIa6&Z#s{P3vxCnAcCrEE<ioO0q
ziZV1$=c^jhjJ*HBC>88KaGoG3awDAlg$wP4j<<I2>Htz3)1GKK$ejx5!YUL)-Vue<
znfv*x+G~YwMR(0-!KUy*hF0B%y|s1lw@ho{68IHtE-ZTPEZI3s4y+`}ic=*GYhQY{
zB<Tdi&@fHS(*Psbq_-9|rYP83znXDG*@9wDf}m5G9iJ&K(I!<^-<t@{0Xx%s$Mg$x
zC=|6o9?r4*DT5}vX+Maq{RwDW*TOzi&G0w53dG42dlR6k#{NyXuz>j*m1KF-9B?}D
zI@y8qPQN<y1GX0_V;9hNnsv?w5N9+x5fn7>NMgUCE{|FAGJeJ#r(5uH_|)-Cay<}|
zii#YhD&Aw=c;ol<jvBa@QL%mBf9~FMydx^Yb5dq5Q-(8Erq1YV5{x)gdUTyEhVd7l
z{;w6U%Vnh7@o8&|FIVjW+OH%U(#aG+(ffG{L3HS0g>6Xjf;CS6Y;U;Y@i9bBM`+Q!
zIlXcT!cY8IF+4<HzZ*`md6&GDwx*}~_?!kbH#XVJJFv@;RyDt+PS#E`r>7x26xw99
zAMd|DxyJR+RnH1%_ZH6iD7&}>OpL#pFKl+6UCfv<DM3CvmjHCrs~R;hLJ+zMlsGul
zg_*`V@^iK9^d;0{aBTHM{@<MGD?r$jpV%6bu!|Wd$^6CMU<l`cFi|2+{$uE-HQw-<
zOKv$>7|-6$Z{AMC7pyfV{Qb!;xvelUVDH%JTA~hgPa@b{Zm89hxE^k2lAtSe3as~B
zQPQ@*?J=JAsTi>H2_ff?9T#84{;yZ}ztNzYC><S-%#i`^D2L*#e^6I`fazL?M0uOL
zb$$(eZsOq3Sz|Tvpd+d!!<-?TnTD`7f5)Add)eh9tZy)_4pJB`B?I2<z*sgZ#zCIP
zfZaxoqr{9dVmJ@3oTQo&54OsO+oK0A-E)Wi%&6<@P3BTGd*|N`ql`O0du>%UQA=Jt
z7v=Sl)I%YY3JCTHnfMQDllmLHXCH+fniV?$XGjxd0&mn4l45NKx<F9fSJEy09vIZq
ziYv1-AKja-93_4O@=I7mqHciQ@88C5ojZsKMlP3R3|?H7>OaTjn;x;V3gud65W6f4
zKJM8P^&i?;nqg^qKk%q{EJ*~4AZwK~{#TFP=Kl}<^8U47mnR6VC=uunLBelM{7^c7
z#+piZ32JYh6_>g5N)004n9uAJ>u@rB#wF?XWiML0&+Ti`bPQ021Tt2;x^&lG!LDrX
zK3lQJB>2rfgE5*Ry6X5K$+Vy2lCK5<G5b0DchCJ(cW<|EXp6BO3Tlw(pTE=8<AjWv
zzfkzA`kd`k0v%1M3F4Dp-6DhUPnVEkY2_o}S5Nbs*+usV!c>h9baoVJ(k52SQE~-y
z2{Ey{e3($rMoU%6|B3deQji$+ia2`j4^68d=<YR)L1Y5$+7pKhVk}Eryj&}GW3r%^
zx(3F+_!s5Hbm2gMGV*{PW(BUbQKGIB5lj4TmUTqnUv|Dh9kW3)(_|<+h~>Fefj!!o
zF0A_SUu}*I7WMD{?{`Yl`LwM~d8r0xNiee}Qv+R^qgXw9533iWo;EY?y;)hXROY4V
z$<y+X8l%#&Xi$CMT5Let)TQmo!<x0m&6)*gxgiSrWAN0=-H}bh-=@AWXX7djvTgEI
zfwOeWX@VGBC(=ym$H4GGsHlba4s6kn%WQqdqQ4ac_1t%b**(8_Tlfw$I$I^lR;vNo
zK|!tpAu+aagD10)eeN&EHIVF@m7~GnFZNtoLTX%_acR#qO>D+L;Ub0+;)Y@JhT(X-
z8P9m`^hY~8G+^#@QnrG;lE*(_k8%Gz`E6h(?^oKmWssY4_V<q4C>#-{$WNS1$J)cb
zFo*ca1t_HQwSlp7<1F?&68uHBU}FsfTd>N~=qKmXeGlQgl=E9|MUY)kmOBi^>9s{M
z9WnCbLKPYQNgb00ngW;=IPx8xuNXG>8{oBp9_rb+!Qu~3<HYyYjHRqJH-10Vl=!N}
zyHLYIaR==*-^X<(9<aF0D^x|8=?1CGONXKNCQsJ%TIUu^JxCIC)NE6=IPTpIdVRmR
zB>Ngu-r)_(1)n|h`9QZTf4We-kV;!}Q6Hl#)aBBdyL09L%j1p>;?yV_5&(9}NHZUC
zZCO%)?%7G+;V%C#hshXux7@%uLX(s(n;cJHfzU>3#<7ajkTZ&6JG>Rn-T0MgO?$nJ
zO!ucrLrR22$i{K_IAQqog&5sw_^?EMROikjjQp9#`$=z%eG{k*IgBuh`K1$iE>s+H
zzkI)2TnOvU3;%1l5O~dn!0SuB>Q<;bP4o~tNq6AYC=#Th#YS*PzU|&)zk`KkEwQHx
z{>-w~e?7-=&TNq|p{`*5>rxswpIL)8@AFQ`{Fks{mBMTTsRBuIkQL(bOOD+N3v6i5
z6&5<w^J9ig)PIXmWRM>>iUD7IUT-vH;pAJ4b1S!o86xMt2-=gLt?W<>LkchqL0HVd
z2XQT!S{$>75IdIEMq<+#OpgUd=11#<CB1;!*9>rZ(XXiiG#OKlR3F))%1!40`g>EU
zS9{Ji>xLSuswLSCkUh$*4$(RBv=I`hNLSNkA@y%E+9@*Ck37@iAJ=N{<!CQLvO(Ew
zKn>(|g}yCE&+i=Gln-|2V4o#*?f27y^aj$rWL6hecl}1X5NAS`s+f?VAlwF37UHsy
z1@z17M5ovv&0LW!3_US8RVmY>`Oux$3j80{R8=<!lR3-2q}Ki5ic@r$HnkFtkt+_9
zQQcA(@)eyP)2Lj4FP-ld6=@Svb`-+Pj^VOipqP{U!NQw4<d+}TU&hpx=jhFsJ`NLs
zIXG^WT=^k+q-b-{MEQZ#?9|zF+rwwuiElf<YvPaB{K7A^-|yebZ+?7_HfitaRZq^)
z)--KiU2b8V2+}nO&E{!)f{mIQ5U|8iG6A{PN2`ElkJFxP%ly`e$vv|b79CVA9SZdz
zFGmu-6g~IdIxzm(DbN-xGysO3?K5(#bqu#}ki=<@E-APX$ss=oJnAeoH_g~C&RX(l
z53jaMJn&^&a`WL;D*-c{TgEDcul17#rDOe<Hw@Z-qZ(x4a4`xU@VxW{kkzj)+*QOc
z&f2HWlwm6~;_!RMj0=4|+udf@BKBX-HsD+Dx+ivj+eLnvy#M*yC?n{=TbcYeZpn7l
z)w_2?qZocg8S!32eVX*JN1&yj(v&-P&xJs0<h6zFJ8$O6F(r}ZFnFX7{9S*#u~tG&
z*8F~$PjLvu`(ULS@;>Buzq`J|^65H4dxeb{v20~YEOnf>`U3S*P>_eDU*&w+g=-_T
zezyx#(Uhqbk4$z-`u1jb0QbB27ndsmv@n6Y)jJi0<iVZuTSIpE02)hP{^g+8G7qoI
zt%?qzWpT(%RuX-!YHiwZ)$`2jsgmugZ}%l%rrUYe@a(n|*H5ST`RyX)8zEOu*kx9?
zjjY(x(FYl^W>uqrF<-^S=T+sqxG|SHsknxpSosS8d6ZhLhPwoWfb+T=3)D*QEqBjL
z8LA$d+DZ+H99;t&bAMFVAv+yob1w_N8Dpz`EL-1Q%CFt-___ITcQMmSdWKT&?ZM7d
zct<NW>PoD8GkfiJY6~xIYc~F|+P0|6p7P7DX2%D2t52ufZVTIPVANic&ac~^=vUeh
z^7p?)KzYYPE2Ij6b|K*IO(PHYM9KS)7XRfNK^4{CD&zl^g#LALmrsAoY7t#ok5v+u
zkd!eg>J#dX8YUkUbkkMT>&K20-g@iRMd;{3{Wl&Ny#40O%BZ`jR_~llu*RK1^w#ft
zhhtXI8rWcRqvihI$oA~6@I~;zo_YaoA@RIbXVFhp!rN!I_EzJjfdTZ#tY%{^WV1n&
z&^y4pv%PE6zG_JqVd?(9M0XaFIWKS<%URb9*rWh9imHs9w2jc{=y%(s)`gBCMb_Js
z);k%7`o5j*F3OJ6Ntvb9Tt<vA%+E=|il74j<60~GG`>Y#NczjDU?m5k{D<if2t^Zp
za(5uAIYLS24?xZHF(ugjIM!+Nkg&Pj=Ufr~X|4Yyh<)IfF^!n&C*~T{rw~Ka^Ii&(
zjVcQ5xuFe6=f2988`csRx_~}9TEGA6aAf2`DV<r`)!G7;#`XS`u-V$lq1_;!q{*)5
z{yOX@4H0saD;O#joAlC|^nFlpW|jL`^f}T%KUN!?K<t$xp0P}%J#{<7tcLXP0(J{W
zWx63K?oJNbYSA1kXLO%f%;<<)Zm{Iic|8K7wj=JBu&!{JyBBKZD0NqB-M8X*)Y>(?
zHpQq9h(ZZzY#5Qd3tI0DbO~j(1v7Eb!h?M&B8Gc^aIK_JA!qn#$yaaBiz7#V^2!&E
znv|XPz^lLHn~KTl73cbv9_7X?1b;6o#qZnvd30{IPc1)KhCL_?EgdgchFnpsVfFZK
z=TF0OVX_!&kEl@44hr^sjt2G;a<WZ^0m&gZ(PeK9?6f3&Odka@;mv2}iNf?LS2Jh7
zwJ&ZGJBWH@N%WzT5j!XdJKOvk58*N>4p+WhW4d%nHtzeV-^%6H#<08SJz%g`3N6q@
z{^0n|lJn`}pC`RF()QUUJB>4zC5e?2g$`l>$w&e>WR7`Xv`a;$b4yKl9P~tUEaH_C
z?@=57Xl|2cnmi#2K|yvpv)YMx6(#QHhnVjzITY44581?HI;%&OpG@UYfFfQIyL+BF
z5#xsF#-5{}g;L!^R0QLSQ?taJY>=!<TGQGB++vz`_P3loBc_dx2Gh3Rd(TW%x$fyz
zI)whJAw?C8YnPC2?fOV^Gs5KeO@%>Px_k1)SmUs$$TiCJoxQ<U!l>2bF1v_R*kSNe
zI6+fwZvLFoaBnFH8*48=mQod1{k>-KP5QN~*VW|$-AixpN-hy0F5<AcA0|1EAF&`+
zS1gjkk-WXH^he!>N^$?ZXUVv-=l#R}tl<N!C3XLe_c!q!QNfTN@$BJGqwBSM?zx<q
zQ!z4d+&`wHY@+CD?8#e)cE>9Hp0`N|doP=15f!ewI`}{LPTRzOYMSh=Y#g(RgkiUl
zNiPwvnKGf4CV!ri$4(t_tCSwycwAS;?3^SFi&*juRUEsD3*WwWLWilHmt-I2p;KGx
zcYL&!d#nB4(0=a-l_@IbHg`zB+{wo<F!noun=gMV2y@JQ>4Mb_o8v$6_P-Plrb+*n
zq`F;Lq<;HidX~T)<(`!LuhbOHZW1)FW5rE^7Z&|Tf0or+6WPw~BgleReIELkOIb<}
zU-$0>7MvYepHnui4M<Lh4P*sv2+wXW0v<XbI8tdZ%?dsn@&>s%+WomY@*eWFcoK%S
zd{bHLGqlfRf%1+Yls1H95=D9B$9a&x<@A3VNd6_+JM^K`z9hJ;d4r^&Ut(pTFobR&
zQnYjCUvC;8R#I^l#(J<C8$I_|B?fZfeu}=}<6La?)?S#`Cv(7x`^8;df^vRW>jcKK
z5xZI6gVW!)JJnx_aE$sq_P(mG%i_KZ`bkjm=ml>vG_@nknkTiMJ9tofVPb5D${Qtb
zyYO=Ze_!tck)ob4Jz8=5S_!cbo4`&^+5CtDK~<T=mSeUhL5u?w`ZTCmm%TaQ-5mCd
z1p1b**jx~+Q+R|@t9y{@yz}wx?B&rmiGE?dP+Q95xda2xKkNDq`v=FY__D@u$Ry@<
zbcQ>p`O+k|S!+^x;~9nRorJBD>#OCt2#(5e?0~)%<JA&snqaKao)Aq$iIcf4ULm$y
z4wZ4ifWAeCL%Ffoj}K-Xu7noQR(ta|kNZ*qJvjpciA|J@QbKnSSp}Axp_th-W{F{5
z=&)(QZM)1)BXnh2<dj^v`z4>PkVq7D$n_$Ot>3-RSU)2jCw<2zTi_~PvLIz`(kPSa
zwAf|15O!xL%&vfPi=2@C5`9sP@^Z0fwieJmWX>T0+I|h?;V25v>y8jHCc1Ay$1Ij-
z-%>W&neHOXPMhXMgO1-NpJ+N>5WPT4KdhNQqVJiwYU4Lv`vAOveu0v`o3cOZG#Q_C
z5Wl2y&gh~7wWw;WrYL8V6+W+wZgT#GQhu(Ocgk?0`6{cTbJT5$@9Dd|kCrC{(3IHW
zVyL;a+}m+=3q8V_<&)N#bEiUarX-^;XiD2&>Qp+2mlsH|G_@wrD2AsatJM>JGV9pK
zYxd6r$txLTRVvNQID@8eVIQv7wZugRi=1V4PJ|umrRYlX!dOK@3bd(#m8Ke2{W9t1
zNcV+<sJ!F!KN}vDm-n2QSo4#~8Qq9-&`^Jno{C)K6{m~HlVIoXQeLVMxL>Zbd8VJ0
zsX2}HV}mQLP(SBy=jutbA+;}`4P$t@Kli>8Ij`d6>-(25N~Nz0eOq4OL{w1XILKEa
zG<QasUs{t3&=^*pW@pYlr0UKFdb32x=zv_}!~zdSY1w?(pfC8er=rQ7Q)?+nS{#Z*
zc{2nyY}r17<VQC)O1KR3zk;rnAPf1#eLDkSjZ4B52h!iBrla~6ksI*+-BWbrQbZ|w
z#GKQt{|V_BC4-bnM)}a@P{=Rakc2)!J*U)H4mnWL>sU&=x57XQCkNHfX&D_Y1|&?S
zV4HgF3wdhfO6jHZ1&&(wv2yolW^d7Ojw)H3AT5Ul7njbCuJbsSCEcw`rzTB^P9Qg0
z<8IEN_;&Wh|Ni;A%@K~b?z7=>HE8ZRMY&>lyvv~VyY9@mjQDn8XD4*iE~NVP5PPNV
z3F$X9I;IxIK~5lq0!g0zAGNRJvImc34TlGBb|2SaO+U}0JT55u$4#Htl55+2UvKF@
zxg;0yBf+f+K(YwePp|q7RX*71`QRbj*8Pb*sq^T$18r-Cv+nK@)^axzmz@UQu;UWG
z#PnlyizZ#Ly)w%brFsc0l89CRd1#tdd$l$EQ?<|M4=OOwO$!GFK>YCGeTlCemV6^k
z$2&IZhyqu^HzX3f2#>whFKvx?j!@6P9+@^XzMM32N8L5AX_;YOgxKP@x5Ux+S+HY9
z?u03Si&@~F*m(VLfH|IC*%V(+IE)dK-P`W6#3qQ{i*G?-WO6GsxLwVm)XKik!zRP;
z9UR;W=d{Mq!gK!X5Mmm+UJ1~*Ugx!uCquN@Q5kaC%i`?=KKg5HLfDh0hhL0KVf8a#
zL`SL<k0o>0Vg`&mA#AGvEaxBF3#M<-%di?Sr*TrPvs)bvF7FpR+%AbeZK*A6a3hV(
zB30Ha`78&u%I};4efuYDn{8Se{Qod^)?ZNu+_#4jBovSkqy?nAJEUW1>5}f29!k1J
zK!zNU66pr%E(vL*hHe;g=(*#2*Zt+*wZ8BD2WHJ0c+PXqKA*i0VX-Q2O~CY6Xc)Jw
zEhF^PjD|{}e0Nj0w8WH>R^m99dux4s0$xx&+x8l^^`FLouaC{4lM4oYj7+Xeqf9Pr
zdCJ_41F5@>Y2RC2pP#%+DJ<~f%W!D-y4M@3V&^vhH5PF73NqIdzWyifO~5`&8!9<j
z>Sb95PAXW-w2GCArD3V(u;jCUvQlr{#Sg2D=oP=t>lc$|(!OkHj@DGOs<E4%aBy~x
zOnd*O&-uA}hpg}tz;;t$Bnw_0WQ%)iHQ+lTT2Ot<sZmY&-YJ!~J;i>lpH{n@dGV*+
zM{>eR(LsE9F8TMJ)gcu|lGX>@^mbGVIkc6^u8sE$P+c*GaSP<J+QiqX!v$Ygq$9ot
z6e!{UrLrLKAm>nc-q7=0GHmEGpz_XsU`Lc};ur3m#FlL;aUNwpO|$$s9q8LWOz(5`
zh5r!pAepFAP1{tV@q}aiGraP~=h__^AIHMakJ^;)bmvRbc!WuL&KB2;CY`;s3#r~e
zG>oREW-R>PI@}N;grpBM*nVnOUGFf3+PcNeyXlDMM<#C(Q@0Urz6si-XHdcz{yOiH
zdv7q5XPD=t_I`;nj*d@dU!pux(1~_b7SZqHO6Qe657IfKLfgR9{08xVwmS~#C#ej7
zWnXEz-3x&}g$aY&4EyER>p{;b&H-QkYr$}{0vP56&P1|Zu3P!vp<Uh{LYm&ZEciC&
z$x7&(Dr>KuM2Ot|V20YpB0K(PC8H1MR?*G0QjUt56Kd}b(ltEW8}tl2d6X#)Lu^Je
zBkZl!r9*J<nZ>sVhirNDi{(-*zb|()&~N!d@f5gtMB_tB(8;Iou!*pAQ&Mr5h$%r@
zF;2h|#~J2MF7~94kn4hMxscW4BljVcY0O#6_6pq9m%=wpuB)#|;dNs6Z7xfy5}!Lv
zx2Z>@>kU5K<^N|jvi7f>EZjD6<zE7dD-p~bIh5TAFrE=2`C!<ILi6KCO1YqV9`$q_
zjkcWTXkNi5B9aN&vsgF>q0H&}z2p-SWL#UrN|;_JH*z0YON#dlE#6SKM9-T&QP@c9
z-tctF#18kJRx#9QX#ncUy&1}$w@C>7eLa$Y$fR?wDEOD@^z3RIXN*?j$}2l5;!GEc
z>d<nVh!O}#0bJ_YibXdO>SrR@Pbww4s0Hd2XENFj+rvx$c-}m08@ycns<?8GkG#?V
z?RBCg_u}ky9Q38wb$=Ww%h`mHxSR{^oJGyzloK(piZHxN%IQz5<FpVs>iZFhRoZ9r
za8!di31ka;1Ux+Pu#`zE*sK!^P_fZKw#7r7(K>3%-UJ>y-vHW}1cSqS4%o}to${q<
z3{;ifydycg<#yCmVo6-SeRhsHXNp4bQxe%TLdn|`UlD?$2AIi6c50rMsOjqZF1Me{
zZLe3Nh;N0~JvjP9%k<5l?a@BimQ^bs9o%set{{2U-@4>KdsMr=B&?c%QPxLnVXPH}
z|0de0CB)2C*jt`|MMfz%lrB|PAHEgVnhF)vWWF#R7}<h$$)OF}aC_Lt#;j)ztvpF=
z&x;NfAN~-qBuc8H74ssUp0`=A-A#VHv>mEgR^Twn?;8nVz%{PsU0>R+I}7@u=;!zB
zN-O{3LWUFdj-EkEJA`W6OXF9<#t0+u=hHJD$E+Xx;2)GCNze>VIx&fGeYP0?9V%T!
zm+a-N&LpYADAm>#ubjD9wA7av=<mDAojTx-u9h&Tg+l6}dxqGA<ra@{Jriv80k>8K
zLYv~8r=^KMePnq_+q2s-GC|5f95rQ^o}Qr}7`Jgtri@O%b)K74+t9oD{YcfI{aeXH
zu2hkR{F1c0r2o327;9=u5|2IV-`AU0o+mo8<2aUEfM5bv#+vI@+oADfMhv3*zqrb0
zVw_auDa(#_S{<AW*lpv#B@r4{ktD0UND(+{UWe!hdwWt31^W5D9QN$a`O2ziSNQB}
z1?bVs;tmh=CmPnDhY*_1>i8MTVzpi8HioEmNXEwfmKeG}qtgR$Xccn$PKpu!D$nGs
zF52{g%oKD>58Cv9DKm!t`*B0^>}*i*Z1k4rn+VpN0u7Vb|HI1A^m`lrpDcj?OV)?_
zG2|5)jCHk@zuR4z+dp^Up#3D7z=$w}K%QC*KyyeSQu6kKE`SIyDEFTgoDX4M0^VJa
z@HZ_f+XJ&f&hSdDGQu1m4o3?4K+l%$3J0Yo*VK6x|G+AeyEGSbcuQq)^;EmSC&>n$
z@}>PWF4KLFyXGtJi@Q~is_>v$$@xdVQ}y|I>wu*MvR|v?$G-|&!Z~hXEtOZ*Tl;E&
zPsj{!7H$s3;nbuJiPd36f|vc@!7V~+!=Y2s88KG<1dZo9sg40}Bt=E?@A^MUKuF#f
z<NKR9FD$A>9KXA0P_R?bG(X@coM8cKl)-8ySu)gx$<;jxQ2zqWOzwd+UKs0`3Ei&~
zy|wU<fg^QinrF)Gj)J4Wxx!B=D^mPf7MWCpn5+%Qp@1D?YlD9pN*J=D2ISaYE!rPr
zP9m#PIN%e-d{`VM>RrHTkTj})*#3k#s)($n|IQr*dVXte99N|!(H=(~bSeY#cg<n$
zadt>5u@n(N&D`K(1Ikgghm%+F)GX>nIbSjAt1tHkkfX=;QWRR|3pqCQj(3acN`w}y
zK;imjp=2#(-TJMnQN($J#jx=YgdKmeCE9L{K#h&@azP3<nN-;01w`4L(7V}r?wy?s
z<6C@P9Z6v>=L)J~s6VMK_`}0C2^i)yLBkJcW#jg{wJDBI_?c$k-$oLb-TV89#LZmj
zGl@7bS#>QK2)KMflxMr{?L?zOBUE?8td&Kt{F~yp%~_W?2>px%5pUm1<?GNXZ@($<
z?UaqKDeVwizhGP~@(6@(i=#U{{E@;5(%zpaU$YUZ^u+W=#9^xD_V$f#5_uCY+(CnR
z#eG6IYB3sb;(#Gf&oQ7iL3dF<oH*Xr^aU8Lu??)<V58eHoO6KEH?DXD1ev6w#x2gr
z=D|H#a@Q$HJ)<q!N#do^B@g-xXE({a&Mi(P_DeF{KokqycKMm&>dt*8q)d9x6Is=P
zlT;O|yJ13<vD)4}bEU<P9RL-f<=y3eJa}~)Em(cqo%F?|ElI4Zf(*%S>zbM!{H?uU
zB*(pU<X&tVvoiCtZ^$Ri!$B2!wa(vkX1SFv(S5f}b`E5AZ7`T0`*67D6+2f4ZYByT
z>WJ^dkSy#H8<hBQZ;cDoo~l?u#hA{R6>lI5pEDo%6HZ)~G|2rNaYK*20f|}~>vQh6
z-4+laq)&~tvL)ScH|<_%Xu^-KZa)fO(#%^k)OtpKVaNBugGbK3>@P{bc`I4-0#w{I
z;@%zBMxLG6QwJ_Px%L)?iLfINrj)#D?z`Y2S8)0n?k^I$4GD@}27M(EydNt|tT}Ca
z@~v2$@ft)0vylEWf9l?J1Jw6ZMv4o?!TObe!S1QMg&`Gdns%M7@jbc;%rm;Vc!FY^
z({KDA`NM6cVRv7dcrrjSSd&N{@g`N}J#vZgKZ+Vc3;;v$)%_zlJNqd5w}VLvBGPpC
zlw!pCYD;ARoBOhVbN$rerWJ6dkXCvgld7Vk@?Zj>WK{YrQOxVnY;);%1aVwn6hi{W
zZt+FmUI}5L<$gyQGYdJr$(z@WAa=l!HGG);d@^pGFlB7UNxl@I@+;6X!BnIir2_u+
z!!uBfR*HN}?JEjpf-m%^_QxNy8di6v38hgOSu?Y;SUvkz2Nc>jdsqt#YMaSRn)liO
zz7(`u-#v@`5T{UD?=-BQ<;(j2jqG9HD7uMmlc`5*J#kSli9h#whwJktNfFM2<8KsF
zY$uJ?k!zyh7ss4==tz|Rf-*T8-jQUhl}>{$kTr^`7o8MaGH6)@oGqX66Q9jsQp!KZ
z3~1!p{=0M0wZ0>T+7vPVvOnWVNt~x}_)){6%ql~q^c|Ut<cP$5R{FfO6n^!>4b>-Z
z`l)@Wm!e;+{h?~CZGuAz76fFaDkwC4kjFOo9?KgyyN1;#?z>5W{&DK&M9Blq<vxrE
zx$rzWc=kKC>y6xmUT37rE*M3;HezRvBIu4Tb__oMWka}<t7c{cMl0ZlPvY7Zrm`F5
z#@`V-b#C&oC3?Dko%7o1>_uH0vZ<}P8f26T5V6=@fT6efU*Q1J*<mH%>@33`#!>=;
zZ5F~$hYuK8WT$~lW9N@r^n*JRuBpf!6^Z;HY+RNUmjMTHPyjz$ykik)>C{^4=Or3o
zO8IHlekTXK&4Rf+QNLr7LVO;sXT1`N7;zL5<PMYUfXXztB(_2x;<2XUng?Z<KJA8*
z1DkAku3(pX?&el#kT|FOw5(p_fmFby9QI@i(ABgA{9wW$wf4TUD;WBHw7k+*?}3Ll
z9YGx)DUJCzDCuC%nQb*w#)i()IEMJ@67%XE7UwBV+k>(8v(lTz{)v|H3Ff)C=zo-M
z6pF$6zk{td&x$1;II$;zy5ri!Ni3*$6YJZz^)3&Br~FiJYkJ_A)0u;74`gktEDoLs
zPGqUNa^Wfx_P|Pk+*2SlE2B4#5qP%^I#wQ=Zn!4hGg+>hNZR}KfK&6kV$LYnVg?*%
zps?fAgaYOjIXnc38XOI7R^k2Qf6Smu&GqNko-N>VlqiK$BP2Jxci?_rw9|&=oK~6M
zRGVLU2vn<-qTX+JPSsS@XB+e!&cVqp#jBZxHQ9lZl10)fgL=n+eh9!ep;@q?-r2o-
z9bUreiP9%5R1U0t>J9d4-hILD!N?yMCU(1ciUqqcTY16UttXx@^Z4@TbBVk4#N78s
z=Qu(p6xogEoy<~eg+jS9`FUs$q-Z6keKSU`U5Cv1575qJqwjCqO+Vgw?)G_S9Pw!H
zj*8gNNCGB6znWDxG0ck4?dVYNUSm)8MkAYAvQrg8>fhR+5){>BBk`O<Pt%#(^$Brh
z&`D0p(<7x?NaNjx8*XP;{f@h-8AZ6Js>N;8!*WYqEQ>-tAJf1^csD;!%+RPSjfX%a
zj0@ungV5X0fKLudXm$#A6rsb8LIEzst|r)Lo^M0>gK))sxsuf9$`-a7-lqIlOGaq#
ztI3`t(bKlD;D^EBBfk8t-IoyB&X$&#EJ0U`z(C4$4wHiitf*d0w3$=kkO26}`YGb+
zw5GXv!C-ZNz)N@3Og$t-BI(hy?xs8)36cO9WxZ+8s0c$#IHY`nO4r1Nj^EmM8$8m^
zfc=fAI+ocxCV+8+?T=ui+56eUtEU9(_J*d$l9L0nfrs_r)0L!d@k_(`06ruvaapzk
zw_Qy#U2U&7EL-Beo<2;d>1cAQpENpY*D|{Ns`(QR|9I%&Dz6kM;Xf)*nWi#l127Ns
z$m;J$+w0m?4@s0~mU9c%jm>5uJ^mAJnaf?4rp46%nkw__`QIpqsKJ#&F~frFud2Ms
zE-4<^)SQn*DM(a#ZoY;f<fa+c^=kTnql=dh*YyXhg!Vwarv7)6ULNFa$6Gz-Nf4Vq
zf5Yd8<+1V2)il^2v1<J)ctDpQqsbqfQ@7}t6iduLC$~8sAjj{ISJQ0M*FST7T7o#K
zs%MWa65UWbNR?Sq%w?mpfguz?E99=!PRC=2-M0GrjQAXjO42bdvNl1(l;RmGIR=?f
z0dOH6gGpI4+=Z7p*!fw%6{@hrb%!o@rCY!x##$d2NJawf;lY?a9qd2sVMO#d)pr)3
zJ}F-&X(1fB?0RMs$|w*vblY@`_na4a)6lJL+Fb!bkU>^5dLKWeVRf6X;sMP!j;xLE
zm%WU$ak$5Xx{09bXLYU!vL*?WzUPvbq+J0l#g>G5jzn+RO=ZFHpzCE4cNbqYl4XPD
zOkt;;Iz<xCAw4j5wmNOfnrv;V!q+fcWznx6F>0s`LyEx<X@3AtMRE`4n|NmipDj3D
zf3c)Gg}#-K;@sFSGwZ4EjDXH1)pYpbNt%sX776#gS8!clUU=6bF`8$|pom!Sg)>QU
zTDB}ocU(kRu79j24VUkXk1L?_4S0v4VvgDgq5xd-5hj^YhqmW*?VNTf;KL<SGK^A(
zUNgq#5asofAY8*0dNBV=79(z%i6vW-j^uw`1Ul95J}&Y<SNA1YALfM(Mlng>L$|~u
zBASSF>5mMV&qPcp?5uaE-+^Txq7YV7m(Q$fUG!;9P%{ygHj6j7=zGFW<+X_fd22T!
za@He*M0s&#7m6-&<~o4OETBa3g3(<(*5o1i&^H@qsm|zq!78siduB%ASJkri89YbV
z3Dv)v)}e$^c(`Wqnn&bzur@1V$?jTZ6Lrt56#HIFpjyze$Y=N1u2~%<5tr&|@ZkmM
zmom**w|*9r?VJWH@eS$k`=ev>@F3K?I3OyAmRNC~Dyl!PW|8mmV^^a*b2vo7?f~0H
z0>P5fG(EKXppJY!$Y)*$6n)pqka0WTrwFZygW)A;M&fnN`blHl58c1JLc=51ZpwM$
zDq4G;n%)`3mt-0E9tU|2*EW%a$-`{mGGUZr5-fYN<AcNk9XgFq600>!eA0(4ED_lx
zuQH2=0*P{mA2=$gL1{<{>OJ<*Ssf+>(sOgzHZCpjp|Mdz)mCFPU1Mxl_+!E@V?WU;
zPO*_TjEZRbN&=5jYH3EQdpP}7JJ;v4bZ5KQ1o{u%QA4XLT(7g?Q7iB=x{-^buRock
z220{Vka91AJUBsK1ulbwFCFY26paqPUfD_Utj!`iiyLx(i)P~T|ABl{#D);tARZ<V
z6o^Z8L^ymkpo&hM)j;=AbAN(meR0@LR#dw=RqSxHQ?K)EfIR0*mTS;OR&y{S2<aht
z43aA@c`pSSd}<-i9rHvku?9%L24aV9(!2$HqE<K_x(v6pEFf^ZXMCKUF>);ba~J?{
z53b0m3i$3?MX#e=HGh10S1?K%aKOH=Ckp?wmTSO;EOeT^3j)5znPC!Y?enW1r)fW{
z(&HQbgHLrPmL*Nhj^Ro#CX=H{DxcG9GJMxL01_6V1y(D?)BsnlN3xeTH#Rp7l8*U&
zFSIMjd9DiTEq6D&O+JMjSSu?zvMLtwD4yeQAX$2KOC(mLvNDn?Z~LZl?;RlZ6eL3=
z3IdYVYZ6#k6eoW#>GSCba3=b~22^y?-Wo!_|GgDLD#ei_+kTQuagt}axgA4dP5R)g
zSOarTSK6lLP>fS&+IFoI&`-*177rXb{1$)I8eYwpI1TF_8a&KrcPFOl&ZZX?KMC@t
z^$~V2g#Z0sOII_e)5NfDUXj>IE3{s1qGv|*L_5UECSz~gyC;UfyGMvx0*#9<Uz6d{
z5)|2`P0)BblD53Yeg2X3`K4qU5<HEv^tn-hk_KVfa%T7LRwbA(n8=@WI~R9Vnuh{D
zH4b-cbl~@aqXV9L41kHhxR2Cngb}1cXUAq*A*NEFAxbNw&~?#(=Z%@@d%QG)9Q@$C
z%(f`%WwZYFPx-t<h0Y0FH`g!6x!&LZzstH(E8|#*=^E1pU6nbDM2w22pasRpxeY?r
zg9qHQACj+?^NMhgalSR#f2DtZkPRi^bG7!)!DW?#P*WA7<b*XeM?-?oxli5^3{ADo
z04}2m^2`cRDD7x!uL#RsS9&LOJ@xHzdI=u^<4Fmdj=Z2YeQWg2$H#!?-gld5hldv@
zm#TDJ4+7&!@f)n0ehaZI_IG&86Cz(J|M<`M3d5A+JX7b_9ixGe-WkW<2MWX9fzzjw
zl;6hX=NCn+A4M$FU$yk1?X6?>j3+Tef+G8~;9pd&ZUcX#>a5~7Z|c2zlOb=#hKq;c
zqA&WabVeQZVOR=ll9*oV0*j8uRv|<!=%!Ny@W~Ksay=I%p|45P25>o$nL>jsgsu<V
zr%H}LCLS>e^LCS!wL);sdit`=w&)f|m{uM+iDuunPRTWcrvi2cMlo^GnM--NvjFvE
z?`i|cxLn;;4u6zL$huhKW~mr4?f8c3_kdUi*uL+YDY#k1?@zNY_)^dO(48!=6>l`)
zbkPhkg+kDj+nOrU{7(Cljs)saRPpa$96<>3PM<K)_ly?)7Dk&LnT8OX?#>yYm6-MY
zCRq&`RCPyO2fuCgjT;=CIhT(Po3Rm=viY`aL;R!&#+n3KM36xS>Krw7TYj1OXz{=m
zgze%0mw)lT<lD6iq<=@D%yS)ocet+tZV?y_-^ZbI4>;pxaJjhKY6)Dhsu^U~;LZ2n
z8TsRDqk^|I*0EHN;_P$b+a?23PcYv*c==EOJZPK~ea4;z`UR8`7tc4AjVOKHKZ}zp
z=+S1oEh5ov=_Z2wUmy#G|7LAth~)N<fX6N3umvILwoaTwf*!B0tnre1d=gJf7KI`w
zbTm||BtL{u9cBG*!0msYO(l@CDe@I1`Oqr~g&=MrXRe5ASIp;O(ft<99^2RhgM;pe
zbL`9Q0VIBr3BF=f4`XW&IF)9diJf<4od@sUldBicTu+}}sT+#CK@Ft3-?ce2;EY2F
z<SN!u#>|%eXX4e>sK0S|P&Rx#U%Dwe4>ChFB$`87r*iVVuq;(vgLl5l3$G+rTCXM@
zm?H|C;Bz=GYs_45<)3=LI!@9}=kEVJE+nZ}t$w^0UHY?hb#`EFS$Us7e^9V^DCB=X
zOYbH63*AzpS%-S;W5yG`iRo2s5n)~qFa%fP32jd?L`#+?hCr^R;R8B)F*TLb_dI|g
zHS!AO<cF6Mg8M{ZzRXc`IujZ9D8*{MGI`Obk0`w<n!ZOMW1;D=>0zR8DX+IiFpeio
zkEvbSF(;o3mWcuaU=-VJ_9NT{snr0A{y`tZFr~<T9ESa~nw5Q?h>yh~tuq3}=}jp=
zv>8}<tZN3|oe~$_wTFN2&7ss$X*W6oW^P$_ajMctzZaHxuQVgqTPM|GA9SIQW(RkB
znXJe0mS;mQq%?ZWICMiBy(rt<zqHR&-c)<JD*yMPDHh+sWBJ<j&k`Q2&;kM^rTGI*
z-8-;s<waHi*yCQf%`JiU@;BE2vzC7ag`1|M){HZZH#IDdOqb}8%2%8inDimpD5saR
z^Ww$wlhfG@a$2l28_al%zPEEfBvFe}F)oTUn@2q>|BlHe&VP{fc571#l|*t{9JTU=
zyGz)bsky@`0Wpb0*TW9Wjt~lKg;T!?1AZO`x?LKIiO3felMNrsFL1(L?oZosm|9=F
z4dybsS|gACirn%hq{qx1H$u8cH(}aesM<XuNq-*>f%^I^8KkJyLOPaT=iROZ!X*O$
zm#-q$$T>BbI0|4;5+*0Me8sHnO;n#8k+6;f(x3_LTy~v5ADT*18=S{cD4yOJKM4_*
z6(F4-Zs&hJ&P6;inCO-qDaac~9#@O<5cuchK)_C*W?j2>NTo)|cm}#1{hiT-dtN$0
zURCe$2pQnA#~FK)qInPe{pkL6_<%1bkz@B?;91=|s`5U&1ZCd1)$^<AM7)zdQd!Q`
zk34)B;x12k=VeWadLg+TAlY0SRKNM@>Rn}asU->y+#yRq#Kc5*08KM3Xi7EuTo8jm
z_`#S2+BK1f@r`)G(gXE2;<Zyy?J(co_x)8>WVnI(==1-oAnBmhbKNJnf}XA2%{9Ra
zsFA$V?U?JN)45U~aAD+pIJQU&EB{q+6*1-~t-RSopH;sSIwj;&$isp0@0m386_`L;
z0Z4a&{xoQ~|8fOT9SkuA_{1%hlmZ4=+nwfaF0W0s!!p-QH;~T9L&r0H&cnycYsWU8
z7k`oFW)D{hU$OS9U+t@8SITgis#%4)d3W%A+2PflbNQd+qXv_zc~2A5hKoXUI}y}s
z?h3&ypaqAfbg}Pbv<5u~#;bTaZa;Ghnqcy|-?Sc1w(bR=*|zh;ROLl!8hJgFk12jh
zVk|AaSBXKXP&6>VNa_*4!v<MSV{*$)>}y~1rkpd4r3>zA?pPx6*)$tPtRYF+Kjr8u
z&Iw8}_QjN1@s;O+HWx7bbE4y87Q^IPwW5Koy@D7HVo~iMD-zdnG0mI_p9ox6To~)<
z%c|$U0tJ?Pmbu?awJK~NK}-D5AJ1~n2}WYx>7J(f<{Uni`EVkBAX+)$?E~OX_SPQ1
zRt_V3dt1Viel(qFmt3HB4G!_8DylAWukA&v%&7?%+tg+!DD4wF!U<zVKTzmkH?f#;
zx~rM1U-iBkH(0ffqJu`Rj6HJUPK`{L$eVgIj4Y|frl~$nPC=!@$f!NnEMm(=US_Bf
zBgrTAxm%&9Ri;1V5mKO+mLydl?|u`FCq}&54VW+0GR^|Ba+D-j)z=tcb6d}ak`xQ?
zSy)m@B2KDc`#IK5e1Dm8z6w^Uh2Sc1T6|}fGIK$mx-rQ?$w4kldWj?Y{VG#X9=Fpc
zEQY?xZ(O&6*VIDhq-Jb$?;hT%>xDmS6mlCNmk+mZPKGkc_iz`>V66Y3|B{QqqAFh-
zydUP7Q*K=w6thS5ZxKfG*;36W&+41EWrxk`!lLljdRJzx*|gt``-nLsD+_6mdN3)8
zf&%PXF)?h47&bbXjgqsc5;C^|%f*@`=dWikzyuoSe|Zo9;FB8~o#r>6GYgQUYbaVX
zQ(uVwCfM|A?|ZMu`Eh5A1iA$+I2u&I&og^Nls8Y<HZT6n_JN?-)p$FFa%yPhfdjGy
zW1iX<8QEUxhqtf6S<DyJ@c*jsd;g%5ZUty6Hvw-F)OyKryQqJ9eJ!6~L*SpP?=Z#l
znzxmr@0I1C*;RFhA1nuJhI9<eIu`4Y#2-#rSoU~C4Zi*jI-$Q#hYL|sL25den-B!w
z^*TafnA%B{o<B-X-@5M#5H`(gvTM({2o3T5zAq|!6R??tk9qM}eI?0M?uEYBmV`CV
z`Buy;LyV)>dQDpQOkd;;p2}{ZFKWKp<0iC4a6ig<kvPx!;3AdK)psUE$;lLZLJXr4
z(|V6fQgYM%W^j<Hq$y*rJyNWyeH$VH6;ow4S(7Y%euuUv`3u!GUcJ=d3FY<{-D!nA
zFLgOEq?mn(u?T1?ciDqEU{;$y+?^k{hIq9YfR*d{ls(_xM)8OHhSOMP%jxA=29HB&
zLm)w(->NU7_+))XQrSBw(%F47=NHL`M_rR|$X)qAI{trX9=d2S?aXztCK2bHh|dlU
zBWvj}A8SWP<TxaOy!wWqJZ*<lJ#BD40fMh>gCjL1T72!II|<k6R%gBO^YBm~xj+2b
ztqFD^hFsNRPA09RDW*t6vG9fP0iRCiQ%q2u@1YpM&MlsY<NQlHqMVoB1(fZ4`Zi7U
z1zT#{&eajQOimnCqc|r%FuR!`FX0soPb|yU)g-^N$|9qE=Xu9ZSnbws?Jo1i4z``~
z1iwJ)zEtJH3%^zyJu43nuRmd}jON_yDYbx%dFVB{Q2*Yd5#-@<QpBNDOzhSP`Lvou
z%cg>!Ve|QYVBt%{V4%Mgf<|*0xLuP`(@0>sMiW$|42ND3X<z7mSs!!qW0f1u(EAnV
z@##}|2Nt?1_Emxfal=n#nd^%`2b*p;%c&tO<yp4a7MWOow&{k+1SF?lMh(8owDPzi
zWi^(-7@;rzao$b{^FXtp^+GzLZ9ie2&2wtb)b?iN*VlLS_w})y@0;{BuaXCZY;}G9
znw0ToANw93oJhw-y!949vP_g;q1%BtB%<^r-O}Y*XwH(UP&>;UUJ4rdk`E@QqNZn+
z_`B+0zGxHn-H$ZQ2{+=3V(NvMOK~&#=LGks<<z_H=~4JwL2af~VJb0uN6#c}Q|(Mf
zNi_cgX*vh)M(G*cc<jGXN(|+{q)2BI(?!~FBz4;u^W44k%)@%Oi&F=~jTzGK+NolH
zslkF7(gZZvxpQVH!#p3zif`+~$)|;91b1MYh$l*yH50km=f>M;6vOVH^36i1AV?Pt
zRoll~arC`bBoz62S;Y(8PPAVG{z6DJ2=~-Dr|%1Y3{p4s1P*i<I9Zg<A(V>y-b<89
z(f1k(bA^Z5Q3w?Gh)BOl%;_%jtok@(5+?Y_T26nmUcze6w&lZkSBSn><R7nY;rn`*
z!3H)+0>Bg`Y`!0!Kx#-ErbXzRheOzAcEr8YX8jS#_#lqj2wfLkNl7KZB|{bNJ!xz$
z=f{IFJ*YQ{X7k0ft#sydm$Um4+4qJCt2Id;QnRelNKLxKo0!89P>P3`$0tCxLVG=A
zr)ISUZhf4V=L1HtJMhyZRP<=j*{L#}iRzT2@g&f>3|>W+-FNCPIvsVa7BumbvAOSd
z_vPo!x;FvtnQ%sO#lXV8jfpQ~{F<d6ebfxE^4LTlBRDm`?no8Sp3-z)V$BirFuA?T
z$YjGE3+uUV;C0g{Sh#y^x-E<o-g?n?8e`fGa}4eYHC(nmAz`XoleaL>k@m|Sen~X4
zZcV2w))_n8^b~z>|2^X^JS{5+ZBKemNfUhjFcSy%Kg5x!tyHA?32DL|=q1~#QKuF1
z+6Mc2<K8DD{?bVKoHQ|EU)0d+GGdGg$4e%<QLMVtJ4NA(j&_@sqJ3L?L|eQkfA;yj
z5k;IgA*O0Mgwy4{<s%#zpKJS75Ph#=1tT7L4m6vp1BmMXlF;=_V1#=8Ed-w2(mI~{
zk|Ee<a6&kW;g$ax4)&x>bmF##_4&g_EAYyuMLF#mj$e`>mw_)^+klg|#ADyEV?wXg
z-v(vdw^`U_dgqP*Ae#SDwUEuvW03qK>G~-cImE0g`Cea?#tOPDcP-Z0o>d|4s&3Zt
zf}{V*IycjjkJ=AMwvxRSMok)3^ZS{FXWbaop9sF|L=SquSuz))^-7feXN$lowPqK~
z+C^>yu^K)Q1Ju)y`|#Ecz0P{Q+N|5A;sJk?B1Tx|=%I)FV>i8t(byF+GFjwt{}J4D
zVE8L-)f;J#oHTkqf9O3{<b6HLlt1biYA`=-2>p22ULk6>|Mi!de9Y?C)zz}a;x2<-
z>NsSz1S_ss`chQALp7vd^8<ew+S(nRzh$~}SN_E!!yCnr@+B^YzVMU_RYd1I<FW0C
zTe$Q&my>{LCo^(h*SzL8UGtWB68C-1k$K&LS+q-*LY&U*Q^;$l%Ph*>-3$*B>dMd-
z93zr4uHot-VP1YIyzXhUe_{BgN?w$C@Qg|B>xa8HXm&5?GiY9#b;e7@*HRFUm!(Ds
z>i%TnqOTop9@RA|V!9x_3<*uvW$b4P{vyV_nw><;)n_H0o+c>^n~oODQ^lT406jMt
z@i}a&wbO6IG|RE(u_Q7t7VvmQ4_DZiQ&K&^z|Z8XkdIIb7q+5yqHX$C!dEnveanno
zxvOh>JXA2t7JvSo?yOOB#DHGg=};|KRyhSpOU;!#Hzn{Z?$QGXEq)}Z2Qo$>{~nCH
z#$w628Z!<08FwyCnxC{GIM5IRhj^JfFzB(Y*;gR(u;%rLxs%Nm#O<3V>USC%*11SG
zJVLD=g%T6e3)|A;9=)8?Glt}+wj?1ucTrCmcz@J0^Z$}x$I^UBB^k$Q7Ed!}I7o}W
z7r<&5vLp5Cg|%&Qm;W;GGyRZmyK>E!HEp7SB{%Kp9c{Eo4rtM+t3_r^_4*NKO@}+4
zq^YvGge~Te9lD??z@-I0N*SCWrPB6no1~b_VwCP5olrTkNld>en+AdFa!UX41ZO<b
za=cV<n=R<DJ>9frL}rU*^M3uj1|oIQn^QDhRU_Mx`;98?y~byJCWxP74iLhCEf}g$
zqKeePQ1;8ozrp@7(-Z4Dmdylf#jyL3m|;-C4X4G!0QH4wQRLlna9*`Y(gz-F$Ax!N
z+F#U5WQ>Ec3aTFQF@%Ia4nIZ49Qaf>^ue`?Ln7~ToiC^&;pD{17Xpm%(Nm2?jSU|z
z?X=sKwT-tm<AfYH=q^ncjL%nF1#j^J*-g!UR`yeErm%2a+}{%vSDI{jHAnnbKt!-5
z38oaGnEU};{`;D5b_GA(%`=rR_uRG9V<U(j{ah{2fIXD0-QLCA-noxI*v%h(PHF3!
zd*1D%$epmhX}M;EMKKQ+2gh&RvA^39NS;Vtz>~P`#<#>i_w(qCjhV0N-eu2kycWMM
zV3o2R`qOi{SHt?IwfJj`pUl@M9E`757tr>|1C^+#Grm{>3>!W$${&}X;rmRW0#1sA
zUDVTp-=_-gZAiL6th(iPb!WE({c1c=D+}%z>FX2`hBcPU%Sr3ck(f;4t6PV~z!w}&
zL73?nh&AS*5&H}8S}o;%$(5GNLP0cuFro<korGHcP|3;<a{bj<F9eUjg?UfguTz|h
zeIacK^>&~qRaWPdIALD8=2p994t#(m<FB|tKV!VHf|Wqehm)7eWh%(3y+wrt7v3+f
z5XyXEo+Ffz@MY6kJ*<42z8%s6B9ya!Kl<OZ8lbPxL{>vR@O}lSvK{VpHXydmp6H+M
zst{!V88uf<gGhq!n}Xx2K-;W0t)2Ix4;v(%dqd-f{<_i?naF&+J}jYPmV<}V(*M)S
z4I*h@e1LjrR}4X(k3-b}+2-aCNMcQ7C(Cj9hhGCwtMXH<)&bp>4r1RcZxg+$`O%y;
z=rwVpm$gade6CC9efOeXZI%C;p^0a;X;pcR3AIiY1Q{hGxsthpcXCX5MMmK}>)7vG
zv@}0h^y2W!zop3p4s`v){!bV>Je;}%T{V-@e{x2CnzCzLGRn#x<|M9C$d2U*Byox!
zz-LX1#>_wQ_F-cb6UNQp&46b_rgSIiqhVZtqS{@oTYN)Um`!M_e5M$_-{*zh#`=TT
zpxH1_%%Z@Tyg-cdJMg$TdTJ;y+qlTCzFX3%%<kR$Q;_=QD&=EUDxZZrIvD(>c!(EB
z1D?Vt`s$EuN^rl9)yhp^>%pTyHs0P8b2(Dbu-3^*-+99j$#uR%A1*KMHvd&jAa=k=
zhbV<8VjBH}2dG>endJRUsUWQ4l2e$e@@4`^D@NKgDMU}p64zoK%W2Obc%kJgaI@;l
zo6#aQ>|gNQF=X4+R%`tYx`zr`0!4pQ12zkNkg_nCnEZ^}ga@r8#Y4+GY&cn|d}W-b
zv)_7TI+WKP7;K+8{KcDrgh6AG<t?NDy1e0cakn0$l}Ua9Yx|~QY;4nGgPo;9^wU7T
zIOU&gkmAXa3sm=2&zq7EhV~XeRdj90mL2y`{-!q$yr(n<pRWTiEDLu|q4%B5NfX3c
zl()C_ZH_pof8Tef*>@M1^*K3Vy2{zx6Yrd5Em3c%Sr86CpEiE9<r29SHl~0KkZ*GM
zvb<;xK8$LvJMU5qsbmchi~qtIJ-m)0=B-@P@-DWB;G9UG9JA{rx9<kVX4>I~MK=y$
zJCy7vAj}JH$sN=(hu<eLvP*HMevm$88c-PDyi1$sqO9-9YK@th6ASA66*~L%wb$UA
z$c<gM?IWG+xMnV!629!_fLgRYoWDf^X}%z2_5sB5+~akcUmD6-p}9mv-Un!d%L~ox
z_K=~LCj1<UxCN%F#|;xFZq&O4w7oP@qPz@9Ss~QZOvcv<kgS1yJjL_Xv+2v4Vl^jA
zX!?0w%CojM&E{S@qCFM6ZP)MLmZU;^><g|Cb#R;RWMg>Cu3lQh=?m{X)XP;XLFQ!I
z?TE(8!WywgpkE7KPz!!g#v7wTnM7F15ynzHEG#Uj8bZXYPRNaqn`Fjt(#K_SlHll<
zB5UwX$<RV@@#yu+Li%5L`;KUa*H3KpJXF4)p)Qw_N^e==zt@JvGWPCrIBz3gtdTa`
zTVOnE^9f^~OVxC=E<P8yZQIJ-@~F}f%N^V*dUIN*vT(PD*mPfhpFbnrKm|o*rTT_K
zx!%6484!&vcQj@+pS+})r&R!=v=X^kgvfw#N~CF&e+@6`-|opsto`V-z?+UV>l$hh
z#HYgP(nf@guJw&nV1RHxA|b|@-B5#@lAz~*T1dEp67N;;TiedpzL*|iPTJ@03gAIz
zIq3ZN%c6m2$7Dh0Ob%3sOy?Dp3C|-eY%$f+fTy;WpXHMYxFFBsK&=>uOnOIC$-Z-C
z3T55(D96}!?^kd5j8PdZv?W~hVnL>?`KFq|a-!?87dIT8Awyz^kyvU=`n?-#!Jn5O
z(bl@APkG8l(i0eMcDSA{Bu51kVa9eV3ij6chtw6coyr}bHkRT|1rRiv2xkZ1MIpLG
z=%T@I&^|V~eZ7WpbK*k}t(K1`)2^S3?*fWTt_43iK-T8=`D+Zw8kHER5XBj7z|WX-
z^XT@)&D1U<_lY9y)gs&-u^I@vsgBkW2ue}=Z(VD6*Cv4mVy<Faf7XW!Wv2;Qk<S!@
zFBN>@D?Vqd0jC)o7wH|B^q@ndH6Cq9nrvBcJ?3NcQu=nH+P?<Xk(_P%$s8H8Fm5#W
z7ELX-3k!Sl!PKBVa=zY+eN6qZQvA&vIENrF*G!!{yO*p}yQ^WYT+US7#8o|MzE@mx
zo~!__J~2-|H(l{KISn^5b+vVqWMgPA3Yczkt!c^`&%8|k?Jv+C`s{L+Htg`wdEW57
z>)lBkhF}3QK7raa<fK9q&F+qK@wHWol2XV?4zUbk>#P|+;pdI)^T(nKAZ<CWQ*ZA&
zCi<R1pXsjwt4?<zO0nrOA{QQDmyuC%U&{OTgGgR)+|@tKXpEbwh0IbU#LSrPIl_#D
zc{14osOpmn_K|>3;-fQruSX_8;-dZR^vY$2@@AsXL~AT3VYkeS@jO`E(Zk4_mE|Ng
zXY1Ipej|OLF_7JI)LD(#fdX-!j;eW=N@>95>ju-}<3*Kf{=*--nLpCNTn2e)Im|qP
z8INo!H{k5$WnSToLra2EAF=ViPS0pHO*L;8P0_G~EG#P|B<qWg_@NP+0!%85&@S0J
zqDrtlic7~Q_3Sk%7V60DJIE0`UlcIgKcQb@vLIo=C-bD;W6x_#?wjg#e%o$r{k3h4
zC~vnz`Zi{`xPRh=u1V26(&JOwd7g}t(X@L!kNGsUQ#aBJ8pIu1L=N081O<XU7Bw|^
zEPf!J15_;IC2rQr^}JBGnnakkFQ5MW9GGh&b%Xdq2FLc53qq)P!nA8Q==uVT%?~wv
z#Q%1(I?!pn*45*`{=uZ`0MCVF`g}zKyKsHN+}jGfO5OjJQ%Ozprx%C&L<Ibze{<dY
zHaIOJ;o#BoXOu-z`X2$8lsPCSyN)lwPUOg~<J1wFMG!+XG1Cv-k&msf`4$!X);C0?
zHC@8s-*$+#SP_Z+2~juiwEKylnWlkG-0xpuqun;5jucXCU#QcFU84h|p85W18i^D;
zy!q&kGfG-~UDwBQ#Y0|Ns9E_<^P`E&MGgMQ0_O%`?JI0MhT^DS?g2XB6}wD6bne&K
z0}7gj+JTM;OgoSSy=K!Z)rS{zgg$4FvlLV;+~8VoHj$)@-OiBPWTu^L``8?i+F#|j
z!vS)=+&%uF?C)?=;Pc}*{JP1@ZDG`0sCRRBB3e7%GyYVabuA1ZZ_M6*x)vL6<9V*&
zh(k{OAYO}inm-io5qXrEqY_h}9vm0{J-WHFZhefMEyyDsE=)hd!|eM&AYawq9VzTm
zdqXt)5^^hW>!iWJDr!9mt<R9B$OKE<^+nh`aeP${F{RJ~T#nd+PRt3a0%PF|koRD$
zjRKI$=h5x~IVJ3&#do7g6FjN{(r*6D!=8p*J<(V1er8Ep&{fi}hTT$3S`<`u$=!Sx
zi}HPH$tF5lRQ%c9WK?fxJoh?`^;0f@?X=+!HYAStOY@nGRmP>!dYyDZX>NBaO5hkU
zBoTPVPTashGsDY8zvR&<)tzw_8vL@m^o3i%VRhQ<#XP0cvY`}5@}}2B_{E-Z`1q4L
zNR3oZs5(a14~IDoH;4WE@PL{(9$}IKCvP_x=kL(W9~+UIzX&OLMyV2=Dd9C)d~l@C
zMjS)Z&4*VUG8cJVCf{GJLd^stA*K5>(K!aWa4ZQ&t{4fGVX!0D1Fyn{LB&gj5bq1p
zKY{_M9m!m65~h9Z5|C~1gA4W?C`%z4=g&B>&c%G?@2af3_3J}K<IvVIn?C!cm(3v|
z_Re&4`vXf)UFx@j)LcL3k`t%z^>Q6zyX4zE5bIlALV-O;n224nuoK9pP*LLUfIoK>
z`MXtoFmSb|hT+ho(+@^LH$A-`MhtFl83;?d1%27X`Zj!AJyzHtKM7!>Bp+;(vXg~x
zc7yTt%>1!B&z_UJym8b=z!4;Zm1|v+YvY^mk%>VaJt_Yzg8!o&0egd%`nD`Mb@Mu_
z^Y%Z2!?ZKtlJlX56I?ne=(@_cZ95vVDVdO^wruJ2ftZvGRmc11;VE3@*rAOIne%41
zU@a#NUBD7U2k<4eSl%A%z)u-huVt4KZ<k8Dd<D5fy$8Gn3+LyJ#y2W=r{fN{D@t1*
z8@=0FjeUs4Z9cZ=?EAN_EVfdYZ;J@s4S2I`xzyL?_GSh*U6l%dLSHrcQ%QXjadEw}
zZ5&2de!O23aJJ;wvTAch);Q7fX!ol`#)rG%L)qAep2l}laVRU|?72foFmUpZBau)l
z${5;SE=s#BYG!ExeTRp*RJWfMLH8muFcN2`@k9$coM&iZSjXF=w+J!ErnP=WU6g0|
zydNi47#LDn2(~lcIh@7=g{N-F(?%QT%Gu2%e959U;t88o&tNgR=oa<)rj*!=42@DF
zb#w0wtD}SUw*-l-t0jGn`H<O=;*pD^%J70Xeg1~!_T|^n*QuVV={}-VBNO$|=1L)(
zRd9i<%xxmUhtQa@ES1zP9%b*X&kp9~!41xKfBMeU;=zDVzNsEM<{4Fr>RgM-%;U_l
z+}>eF84e=yHLe`dr79fQ?tbNuFw`kLCYzL)Qy_(M$n|aJ&{}ic^0N^SqCD2uBL<P(
zwJ|iH^_N9Vcoyq`pIF$DlHaA;KNJoP-q|%-Cc7ge+@JtHLTQ8C_0m`0xt~yFNI9?e
zc|3?(vHJxaS~31goNboQvJCCkEqCxJ7cD7;B*;On+q)tuZ8u>7lumZiw>48zltgYa
z1#dDsqBB~Qj5G1N-gmoihfzaMjstFdi=xLsmT-UD-N@V+Zo?3PY+#?4syUxX9INek
zMvwa|>o+*q0}VWf%>pB@=lWMs1{mquBrCX45v}_AMtkq1>ZTeK-csdsZ`Y-B5mI+!
zo>~SCI4m6j;oCC#CQ3W1$_Wi#PDSZ%0k;z0w3y#Hs-`Xh2b+@2<Kflm9Hu>N>3HYw
z$97>|>xn(PpWa%fwt!yS7el`t>da;6Y}Kmh8$F=J8I|dO>;->6{Ed%pr$a6Zy^eoN
z)GoCiK&;0&$c6v0m)7Nve0QCx<(=EKR3&NT#OwfwE5Y~<b@dc;l2igleRUvOi_-qy
zJYBklm+RTuRvD)1Z<-N#6&Ji|u%j0P_C?9;M*|I9jwNs#1ytNK`-uf2DDf106Zv@^
zdr}Ac+*=T0_8q97+Y;V2)Vzq&y}eWSf*y1wsE~C(?eJl-xwLCQEj5t@DJu{|%)!uQ
zsh8debToxsZvX3-fErA4PA>XIplCHmgTO?Uym0q`T9f92p_GGPjD^Qs+gj7#N8}Uz
zR)|1~H!yB+w9q~*<_~V?B2$lx>v>IHxPy0c?XAL)D;sS(8<)MI3H)Ix@^hW&IbdzZ
zo!EU2zvI<}QErMec6~*p1GxXO>a}k<$Vm2xN5?j{!zg$HZBxCb@r!im{?I|yYtbfK
zIIwH<kezR3LWYvic72WEXFQo)hwA5hg9ZPgO>;x<afcxrj$pLhE4sVZ6|_C32-msv
zeBRAy9`-dtcTa@h%ZCa7AuV+QFNu=kFTuVLoK6A1q~F?Ksg_asCADvuI|BwLcp?I@
z>C$h--dwywUleSidK%MJE2j%Md=A;2(|}&+RP=3Q{)UF-`h1@6_?uLR9}5G?^QO}c
zGEl>u%Hg-)h&q0UC7^jSv2h|1?Evh_8o%)Izzo2pPTOtWCfJVC@-~Vn59wuG3)bi%
zfY22Y0{&YWb^8DqY1fiG2&i`jZIb)$=J+&XO}e(7Jzw=dWMA$GT*_7$V?4jmEXA|+
zJ081&H^9UeNKpNSep|CkL*HRWqo^Jj{+>2N^<kCZPY`6dPzZcqZlkez8Flh??q>CL
zJiZ<O8RU`}L;mo}n^>;{(!#&0czj?pLOpxsk~$av2&m7Ld8}_<W5>pDSkw8Ov8X*Q
zq)83oXH@t}$D`-`RD1p1HS6F$aCX07YOt!wk$qM&N?0`bs#xFhlB^MLzvc3SczL>>
z*?1g^Dz#M6ni8O1q9s=`I2f7fc^nDe5sVv(<J1nx4H+FfEK8OZ_aX0ZkSipaV~%Gs
zfM}_PGxzXLrv|5@w1-48i)!6@$wFh1jFol>t`=^YW}mT1fmn)-|HtHB3?g`H+lJc(
z{|R?|Cl3xad;RqQPiz^p6Nj#59dFLXk#HZlTr3;SE+Pl;!tClKQDYMO*ZTL=y-V&h
zkuFP3i_14=QEKb0CJS6CX?iYJHzRl0X2KJ!zkJ+{wrzbhg>bd<NV^}>nS*Z+hRiw>
zj-&xG3D1?~92<{2ac+u5{sXm<Xd15eOjXc&7=8O;>3PfaKIyHuL}HyJNfC>|z)t6?
z_2SkSb{?8ctchZjW9PT<GiQdE9sx!~_o=6S<M{b(f}#rcEaCf}?DZa`VmG_=*fV~U
z@5vQq>c1tg4XSrRg?HEa-{dA*IDG?1jJCksVwAp<7S1~|y`I6c4P&K}zagkHz@A*k
z9Mwh+`EDI)6tT)7RF|!Z`x?j`JiPj!uFs-t@`rCHa{3jQ@oZaq!UO0Hv|v|J%(3Hd
zr9(M-w$>=n*VKa_@K4ywEgB}J)lAAueoO=ES1QqVPynbS9hSS?q*UFhYf_W>g=zxl
zOy9l?f189p(sX^;vJoFkMdn2$8}>en9W*H3?HO>S5em&1t^-@}95w6l=elzrrzaT9
z)ER|gJ#DjFdE!;~Y@fIkSNFfu^D3=hu(K9KHQeSuU1hGR9r*-327Kzy`$8IsHT{Q4
zf`q-tbg}O$;$Gi|mW@+o##c_eOrDP?%+uCv04=QSu>~QOIXon(TC2wCa}W@A)$SM{
zGpF4wB%G9?|58(6;LI(ng2j6L7iCrgH})j1aRN`MNK^EwNoS%cFmwE@nC~VxY9-11
zv_=3U!t7KIZJ?M7S-V_WBQ7iOG#2#bW`TT--@GDi@xgx2g0LS^2LTY$Z`Czjg8VRN
z!UJGKD>(Z|5)Uy%VNusc%|o+jt~ask^lr8sc8r~xKxiQGk_SJ~;q#OoL4O2X(_*s}
zl+5G!kt+Fx<cp-F{;WGahQmtQoUMz<)0Z3RW?@S!QkIVa#o)}*$d7nA-9u^V87!tU
z&f6FiokPz_L4?ve;t9O7OM)Zv#za91woEjGx8*$ntzYw))0@cKO7w0TBeh}yeCbB_
zFSq$p^8DJ^jlL)$?+WIBq|Vvq9^7!EkQ2_e5K~vmmEz}PG3a3aJlLUTF7*EWx6<*3
zpOw)KD1m8MlbtBR3sPR&gG9wI?EGwQAG&uLN7fsOC(fqG2%|`RgVv<EGq{?nC=6#y
zKiFiY?CQsRA(s8nm<|HOo@<jdBU1Cotp$ijE6*3hCp5Qki+Xk?ww8pLxT>}_IQDpD
zjxSxr^r>6Yq=4>ChO+FP@{vtn)XUEeWcj@<Yn%S!3y>`Z-iDpc3|dwma0ekBxk_gX
zuOa5==WpokBsQy2v%==v)-|*OQh0<?GUM79YiUfcIUr?V2~*aS$LDxy0GAtIQ@6kx
z6(A!7%3GC`fVj~mx`Lb2E1}*Aq_ngG>g9Un>lRO9&c>(<qBBP|y=}J5o02VacKtGH
zKP4MGt4dhvYN*mz-=a>`STlS%RSaq5?!On?-~{35Rhjf~b{@$$KcGOKHiHKlA<NzB
zf<N_lxfL1zC#c{*_ky55&{8dnf^cc2%1$r+)#f#u*hZ<-LasOO?!z|fke%<{k9uoA
z8aEHLTmY(}V-@!2t8F{HsNA{RsZ_JlYoGR(07&`1e@FYkVZ+}3<Asr6C9$ii^7{|8
z?kQ^vf_^Cu+$|$SvBGLfUD?`ILkFH2&L*8+%aWm+SH$-UK9WAgtm}&dH`-yzB?p7u
zeSBB^zjE&LUBLeA{*p6XopTClqx{S@eC??pZX7(a63pItB3_&6l$KdKdbS^UW*s`0
zxz2n2W*IC!CUa;7@_EAQrYP&toR13{;ISbG{t6XIKLzDg=PmCguQ;1L#T^`i2Zcqj
zCfzh`UbL8Nh`ezr`O3g-F<=R9?VE4Dr`8i{oFm-ux8d**M;$pNO;b+qqc!u)WvAkc
zanir%HC8?_uFb+q?%k1Gegyq5%Dyrv&MxZ~It{@I9y}qqyL*s88h3}_PH@)%0Rkkr
z)402PfDqh*y9I6Bo%>|IdFQLTx9-e4Rs7-)&FOQttiASHi**MqqJWXS1))gLSRNqF
z)v1wlM+bfrYUU9}Hv*7xMOI5z={VWO$49{O8kEK2N7v1s7but5DRTN)Q7<G5EZc=M
z*qIS_T!ltWlS7h5Ib^=hP*z+7Idc<8V*BBKn`1T8&y)C2^7<y$lv+Grsqc*FDmc?0
zuIvYez<yjZ8V!sh=;9f%&MYaSLDtAjqJr|fydwNe6IpBiZpwDkTyo{O4_w`2J+|q?
z(Apl(iM}SRv<HP)+}h$kZ};cPcRKG1l3o=qi+1D)_`?lTDyIqr7HS_Q{#<ia|8{$|
zplgqxoJMfiFO51T^|hkOTzsvsiFK>IdWa4|=)PAn_s~?)Xq+}#r#Y6!@cO|aGLj>Y
zGyH@P<py!WOk+;bgenLe+xwo+rE6}^Fkrh2k4p487Mim6;MUjHPM8T_sB%-}tyszC
zYjS{;atB`r-nl+!WNv#z*%}=-<nMDfO6*)Ta6O>zQ4BwvlcQ9(Gq(JQ<wj;>#36&+
z*lFGvaBJ34CUh|21*+xu9LTj1UC)K=u%{hYlesD<*v87lS{B#wAHDIGcWz7yUi`ps
zo4n4l*@?|i;hD-qnP1AUrEn`~BeCjuHec0UwC8f+Z7Iw^Uk_2tSJW%7HiF-rq|d}t
zo0?HS_wYMw^g&{?T^Zem)Jb11cQ3=q)~QCoK8U->96X;X7zm|k2)gJ<ynE@&KHSh_
zo(pQwD0pSfoRuL+>TvS%!8d=nnx31;l7mfXP)b})59>@0#9i&6(ud~$0D)2y0P|v-
z{jpMxH8<Rm9qXhh@QJ4h&c*$+`w1GJk6uowREH_kcF$dJSA$H9IFdw18eTO%+Y4)w
zZ{iC^jGjR2K3HVgmk*zB$5H{i&d!Y$jhugw-9#sgm^*o?s$IEe*0y!#D11Ru_&BdP
z3S-1fu#Vj{G$x#zDj}GMurgB)9dHtT+AuujB7S^{VON=uYYs7LlMS&F+|+oRP9D!x
z9u#AlKGY~uuJ{8x@I5k0B~=tnO#=Np7kiD-d9g=#y28_%n2mllmp%LEWN@Qg7l^3L
z8fMy!vbS4Y=8sc`?zDMM55iOhXN}i5#UZqRX#u#!T}1n&0jiNDrcHiw?df74t&Y9b
zo+?dT77#2lJHk&No}}2W;7_S|Ms2M{;@nFm_7OKXJi}l`F7+#G!_!8BEQ`2<Q@)kn
z?r3`oul4b_R&W=M$Uw0JH)hCz8!N(luc_V&$0alD&7ME*_XPEtoW9cFP)q4m0hUN1
z$vQHyJ0?HTj9YhpXN(1)s>sS9&`Ln$<MqMKjBj0fc&=&p<KFA5i)1jwL!Y}J+GG92
z&-Y-t3Sx^m)BO`iKEGUGcIW$VqjU<3vth&wP-f(N#+72(xTDgax+5~*me4~px0{+s
z27}Gz-vj&BDWm-)+$4f5*Wn@BAv3aKAM@N5rq#{k-&@?WZ|OfFmg^^X5>Lp~@*Dxw
z@H@<p8(S3WbE`Q}SlCju_|N}rCc*mxexgj78Lz{_T@`emF5oug0SpXZOdBT`0jM-F
zXF8uROP!7Zc*mFyd+zfKcM7n)qJMsQNqg|}G`jC#NrBD=pd?AKJG^vfBDc_<mSN!2
z*4#ERSafpVrRH-ZTlF0xZ`MV0@S>JZS@hvJ!q0aiqW-pe_8w6$j8MG*Gw7<tuAtXN
z8qIg-F#IA*pzw11K9fO(LDk?~S;9^uSwcMvy{}MKpm*+?s;aZ!%+bl-h_i7G#cw`N
zc`*ma;Wqj7Crj$E{ey>hu?l+?He;Ev2t!fNy;;gcyg!uQ3x&2!7MU9*)zxlB{_Pj*
zUFT`Usl=(`8s8EHPiar%+uqCklB%{%*Ye(!<-1|N#!;7cvw3O|Cq8%5p=RmDG06rE
z7Icbl<i`fm1iHC_Y0NTVKA-ZV!;JfIZjyUL$o|6}E|gBB2-h4%0z<Y>)<56HQeP#q
zI>uSEpmE(nk>sOSlTFPRs}K-ofo+E;nO<W^X5d91_`^0ul1~@~G6zRPxqWt}d_bsL
zXyinjN-R>35M(?Tt%q`>j#%d%)27nMG_CZBw%<852G^A0#mFq$IsrwJS8^bJUSYgn
zQ}m=>zQix~oQ>MD1!_@0j~H=1^j*xjLT>=nIgQ7LzS&;qy~<4bB?r&%g9JZc9%UQ|
zI=^{=U@`p=S3>sqOyxD8furtABV>4`JQNW{0qmEAp^CXD@8}t8n|usH9xXA=@D=Q!
z>ugGHBx+*q#8s*Ah?-I%wDD~XS+v5yQ_r(;a-c{D0<n<>sE}Z-N+!+Ygnnd5o^5F+
zf>uSU=prT1yy>gBl@s0|s#|4i#&_-J5bw=TD9#<-eCy{KaJE8z^hUK(e3dj&WFMc6
z?yPfj53o<RC5&!i<jFT^Vjedo3}0XG!^Bw~F=EYqvCMOPTYtBQDu;m14-gjRl=HXP
zGDm7Q37H^H4GpMcWaN3*I!`=~fQCwZX^!grV4qJy^iBVPmxjN(-;8i~I(8<YO1g(K
zw&$+<GT9HF#rH-|HzRsA{DImLQ>6Rpx*)Z&snV3XpS&rcn_~##s`u~l!B^mrKYHS8
zRf30HVQ@Z+KTN&ES51%vNkO&Tp>-lHET}>`d50H2EUYy*^NPwDrmeawYLYSxG@Pwm
zsYGTP$z29Un5csZ;q!+jKR}#Nl@xO|3xAC!ITrh>&KJd}ND`)0S6vv}jxScu*Dp&7
zb?qOKG^v1&7@@!hmk9d6C|7=%+9@9{t(y8Th~*%)9NV1aO;1sj9M$E=sXg~S+`7R<
zjnQk)pDYGB$6U+l<$z(-lvnmG{`2_LJYUsYome^_NnB-b^qVby`Vve-29vc9vMDjp
zi|Q1ojscs4Hbgsg7Y{ep!M4PPtr?x2giLywQwv)7`Qf;3=pRI}Y&3rD@=C#9ePP38
zl{nPtH~oFA(`QI1z`3z7BQnlO;xZ7ZD4$>t-cnbg;$r_cF3C2SELoEz^)XUr6rtT}
zDS!E9co)N^?2K!}W^wG08j)<jF%7Hzr?+oZ_94=U?r9gnYRNhWWT`~4T|MzN>{(Dz
zoIKBjP;%wmI>T>NVqEAERn@HwibsA7L%hWuo>!&q5qDy`Wp-2_FT&2tEd%2Lmz>X2
zM@y2o!Z2(p8W?o&usUwS1~GOfdD8o^gyZ;@sPE|<A7KZKO^jYiG@mCR3aT9(G}*@r
zUt>#qxZ#bh8l1hIY3XD9ozyild9W)@BP!7K+TE<rMfhF$`L5=ZFyOzS+b*R^F?68J
zNW(g?Ws*%p{1RM1k>t%5BKl>w1ae-wDNAcpr361g?s2vy6x3g74BsdOVX!|T(#(My
z4gob?#3W;TE5m=I5Iu7HMLV9@e`-gKcb0O_jyKbLZcdXEB8QMP3f|(tCbo=^K!{^d
zQ%y3|5h(&K9XUh+hO0YE@ce0zs!N6Mqf!xK#|Nkob$O1S`d_~vdbq;Jzo9ld9;!j^
z7CsX^lBVjoowVgK37QD84c)CAdeInTDgalwn`6N%Y=S|w<{K$RQu{T9{?n}nE05J%
zhZC>aMlaN-t`J|;RPPOxZN-^J=l_KFyaGqbit?%LN%LvM!1<`A^tQBac8`a#ArO^R
zfbu7g4GplN(G4~x*5Zaq;0!N#?Jz&vpR_zlU(`0OQx+f)S1GAgwBFUV=m~;P5#m+d
zS^8@bt?{_b_;Z{7QP*(Z1kJ^9&$^|B@lS5yW7BBU*M~#-XVzg|dq0c9lRDzg2Q3DO
z3}Cv<TXd8(O0u?WYmTS~;zStv94)l(1RDL*MfN&Uy2IEF_zv=t_*@Q9k)q^XuuCpn
z%O2_|EiRH%5BGD6SBJ^t>EC4)zT0K#xP6f<Ff$IZ`7SM{ZTtSn<%tHCyDwK2a-nJ6
zIxjMHv9;$@y*1fUb|L__puQ^t0|Lxc@Y<Pl-G}55|1G}#@bAZ?-8`-#bls4kC@0M}
zl(wE3Ck^&OJV3MD3C-SIXblC}r<;(QWA6x9>;e_r=qeV-l<2eg#*JX1eCOc^JBHxq
z#KwW2E#N%b;C6-3i=Mr(-GU9$y{hK=)GRe@tXT2YT<8O}a_>(p0piXfE*6`3kh-4(
z`ED>8AO*vTE}-k%PMz*z7i&2)+#FfKQIN(@+`FH+h4uM3@A5t7Hv`BAr!W`A{LbCI
z*Ks8pWh{-PAzobqSiRQ-EF6T>2yPw-n^WKfk-;|&l3{6Hrj=L`sgWYtXGRbMQzA}-
z_Z^pypkJ8bv{T;4>4cq&8fN_^!Rx~<5H!fErt(kLcAuYbg-gBQ7YW^|C3usAYn6<9
zd;GwaOAtYCp!z8#C#|+yH=)0Rn<j5|{Ka~r)C-a;wzcFdF7EXr0uNs<_Zhad)<+Tt
zk9`|MMalFTQ(vYC%8Awpy8P|p39F<#=g%%c@I}&OFS$Y6TX!n<#8*qF6xE>#9_;>!
z`7Pq}iHFaCUT}+^RJr!sx&yO^7m}2`;d52U;IEP%8_yW+g?=c+O4`IJY{?N#>kl5a
z{jq!HN$pnPYXfl-V=4QSrKWek7kOfr0<~rw)dX~}Q`nViRH}W=w+a=}F+u+KB>aCk
z<+&CC*j2>Xgn)j0`rf~K<XtA|IgZzr<N>i*P@3|hd^WukSHFio><?}u1-&|<MZsEm
zn?>@d4b!R@UU&CaXbUc^<FVOQqnHbQxPotR;zE)SWwDwiH_E5#&qB{mq}3wQo0XWX
zQ2dH{c<mO{o1aZTALKfWQjMtDI9{c-4s3E%o8zYA=Yeriw<u>bZqj~aL*}o852C0|
z4Xll=0IT!p06SuiY_F4hvH9K5GiJd!X36pkSZ0$Uw^w3*hesu&1Dno@K#)_fy4eja
zEMw_3sBjV(J}kckTeQ_Q+b@Zpe--A{6K*T=B6GG^@?9s36&ZX7wg5;4j5ffb9)Jng
zzl$MQ%+jgzbvg8!(GIjDJ<Yzvq19t0DRoJSqaTLFv)e_OS1k3z6g=u&CY?%X1+QP`
z4RfhFl9ZD%rH&k$Pzd4drR#@(#}z~`p!#V^86^t0TqN^polN45shvm=7xhM7!YQq}
zR;I&U8%&9%&TS>1$e%TGYVG6q1G_3_qj~y?d>uJ58W^D)W#H<Zj0DZY=Sa4;jP>L7
zD}rzNL%I!4BF4h`?4hfyM34jpXbfYPrU}1`U`W*rvm)<hr-Dpb!hqq18Mami3@`t>
z_;v<5JD)%Li<X;~$H^CE?3>I$MH!PSkBVkXvY2bhPYHv8@^MxQg8ZS~@t3jwIE&Hb
z^Z`v>x69G1t=Q0QtS@tldb-&T!#{R6v1Jj+T4Dpw-O+MbAWr;OW%U7Fj-Ut;nKv!^
zb%)Qq-o()L%7`wNx@W2*k1mhXf;QkkNj)4R(g~eW=i7PhJuYrNRQ24MP^n1x23!6P
z1BF{=Wa7bY1%|j-hq`g#J(D;Uo|-4g7lACpXx@-GdQdgGG1P}v9)-v{;#HOI5_IvY
z--~2LVyu|@>p<!H$bb-ILG0{03@JR+d!uWFX)x&@mbXTZLT!MY0N%ELs9#5@6orGp
zwZG<SYK$x(zGz=j4IlS65=4k3kaUc`2|iw&M~qs*tTa(agM0u2Ooz8ggt(z5IKvuV
zTg?WYnpcB1zV^*W_fcKLY#3*2Rv{faV79>#&?F|4o#$(@mdsOM&R!U&Z>o{}<Tm&t
zh8b~Ff8ga-Vf)Fm?&rzNX4R%O`dQ$<Pjiz*+R0#&`>vVJA7;;UlooVl;=>Y$715&l
zog8|o>7)^j%w_ZC<_xE$Jn!ZSxmBPyS{G`?b=^j+G7|yXW;i-LBH}I&@b{bSx^d78
zERq(u;hCicS~1}!u*HDW3Gaw*nmDKE$v4ZkU>n3i<b31=n4Vemqv%{bin%|<&h?xU
zxQ*%M4Hxb&!cuDMzC<<OeKCG(A+d6E*|Odx34xjqC}Ws6+S`y_=$+G7TT*W_V$-)R
zvU*$_?wIY1HSF5~2o|QC-N?^lsoGQs=nUkmmJRnRN4u>fV=A$OhppeMVaQFB$7RDH
z*dyiHjrYjJ_%^_hbmKGN^sAc=VZY223Z0F^+%Wc-oUmlPcSqfguhxnnRmZGqN?P8>
z?7}&v5bVk|(T|QK8Xd;>s9gRSOv|dkDzwrItBscosNUUEsQ;><DC!crnz?mzf5W?2
z&X3YSM^=&hO-4!4m=sSnY|y;R(1ByWjL7l57WHy0AtBcs(vL%^&9Lf97d@=`)wb6I
zHU$SfcwdVX6@iifmDV)*<<h!uFfAVk-ol14zb{u9#g*~q2AX3kBWergYkd_b1HOo3
zUf947`~e-UfeAI$!O|yPvhYP;iF`V%1uNPLrZ){qT|b{OeDf69Vt=?so=rZs0YIhD
zXGl>uYp5;B*EWiQTbsR31wD7_ZK_gKYT~|cLS^egQR_kv*H?9Z5fq|V6JJN~ux91_
z?Km|XGS0(VSE5ALc9}<!yt5dROoDO;jg7uMPXbpg`$A8bbf_j}k$+c5XudCByTsqz
z7RORMjQ!m$ycX!O4_H3@rX{8rHs0Uk;;t`-Hs1@yag)7Dw9fuz*?2lz;x~fNIm<fT
zzfBZm&+nPgLQTv*W$itP0u$W*H%naq^k*mGfuF#EQ5v`3Y^DAgpdBB!9IdxqEq6C`
zJlM7ZS{Lqj2Mr&$M@Vluz2Cd{cJm)T#2p;Si^gZ}IrCwJk6LLy>>L@RQxW|^cfWH;
zu9|>%WB?t@oCEdS`K}4GvZAdbzEXLG<<!y)CqMxzOl!jH>LnGslYTymM!I}ln=daN
ztJD^YiZ`)Xx@A6k3YHv|kQ3Q^heJk=#<0WVRbe!{8jhv?i><oLA|4x3XM6Wv=ff{_
z&RoS7>fwc(*cOx;qF$KgAIL7H&}~tMTpGxSkCDDyQwrwPKx*rA?d}XEmx6vVVKRvk
zhopB=Z}x;{LYtbv3e3Hnlf`@n_Lz8N*6*S@@*H9#$R>ho4}#=BO;fd9IferqY`U0v
zU0jB@kVaR`yO5ku#w;q}jU;}NpqB{z225`)%Rfo9hdUlX^V6`=79r2fDCR7Xg!6y%
z4-l$`Q&FD9(P1``vCQCXdg^jh&rm1j4uW?!RfEMZ`;p*)>yg>zD%+$_%^FI#84bv&
zfim8q9YQfNcqX89;z7v$wrAR=LBad{#7s8O+PW~$c7G{7y}`Q~y9XV?{cR)EF;~oq
z%x)zx4c)Z?(wmo8U27jsYnw?tXp8Nv8uoA@sC`0<624r$xaQQX8g#>V*+`>3tarCB
z5q5}BGMQeTv4;JYN|*6rmK}Z#rlxq=^uidW1Cu#ltK?!nNkSnAZ#YHvXxQ+926@sJ
z661S-om~S-%O^2qCCyO7f!W}>R>X*?wGGGZqBZ#Wk@D4%%Q`R<mXiA*xq&U>d2Ki9
z=E^@lK<+eLlC5Zd*%cqKrKeQe>|Ihj!s1G9_%A#U`V(f11~s;hUKl1X%vtox?~bpT
z-Exek+aCD1KUtjQFXxu76c#qn9Sf>$!;lFIkj5Ml$wT}fgLE#`3Z6tohWO<-TDb*|
z$mO|*KHj*CICSOgfrJ<4J&r8gh+a*>Bvok@@aef!-E$NZACV0n3#w>CoFRJwfuoA|
z0zdIEx+`neu&FN1>iR+$iX|Vva-XG@N<A#OrGR%5JjebHGm{NxY-O<Mai-(Z<-R}j
zz8?erR%hiF|8S+l{#Nz&uGM&1Zf+4S;L%Yf_BOQcd~rpiJS`R@D{cku9U(4g6fR&}
z)89_T-8yUQG7CSim6xrXbNsB*E09*@s|B|<1X6$EvVj5i#?_`%;{|?b5mGCr)z=-Q
z$(Gg54j>Dz7-(M>gbSw|Z0)T5L!^RYOq#T%sYh{Z=_ekCIIXCNxW{NYhGS&LhR^wJ
zAlBTpV#IM!9qxfa+?ItnsGhNtgCx!Bd9Yz4Svt7v>U-QoQ_#gdzU*Mb*t~XNs%2mK
z9#B3qVM)ShgI-0w^;ci7j-UfHRLrSgs3BKE($tUx@!0J-FWN1|y)NRDB#=ip18G(R
z2FF9Puv@ITaGNsb0}T2XwW4L$FK20e6=|1rB~xU6g^8o*J&Tz1I@sQb1V-^+Q~5PW
zOL@d`&wA;^&$t!=GL7=G(O$+dE>!DrlW}hjee%>&)yXu0W@7%i#sxSe(hzPrOa`Tg
zO!k3_^VFl%=cmb*#6=aDmAJ=F`W4!f`^y}2I?-s)WRM)dZ4@qzP7xfn4#q|yhN$K*
zrmfItX=hdbupa!`%*9Li^T*W7%`N@`O!cn@gA}ng4rI*sPF<v?D0la?;<0gAId<-C
zCMDCuU|SdT-x}4kjo-v4j#EL-ztOfi!XaPsCG_e5<tQnw@CyXkcYYP&2x7uq{21E8
z2gN|=!G2FY)UmVA5YKVh?XeFJ^Xr#t=_6Y#j4bi^X<6UXCHKV0dYt1Ujod%?Dp@G3
z3Vu}+PXD6<%|Ezlxl|$se`~p<FvkM)02yQ;S79iho(-=jJvQ`)@h7Fl--_!2z8^0&
zd^a^*@t{wun2&I%sHniAn%mlbP1|F&N)7#*RwRrdb84IVt!5m}Hgx+9=v-LQwEBfR
z3bG&-sMa*zCH7OxBh0rxIYVjG?RX8Jq1H1ZEF<oQ)dl0Q3h+jW`u<a5M!U>N-9|qX
z73buYeiCudzQs$Wj_2^v5vODZWpaF;UOcS#JDu&4d^s0>E4&xu+G6SPHers-ZNq53
z=X3N4bolhh+G_0shBiv)D*c6ZHXtt9fwCdQv>Qe$3zR5VniODE8V4nX6kJ3BO~s2G
z#dn0`cC<4U6~v3k@nh&J{>;oiAzRbzg1FEnV5QsosorTOY{auvIAmGsJkFN*P=4An
z&1}7dubu~h=!P9VJ|K@->EJFd#U;>HNo6a2iDcKC-VTU`mbLZ(`qt|~+L&`}S>voK
zNFM4O0g6-`^kKKFpuD;a^_)O;sz`6{Nc4<nbAmmPft!n<iXE&w&ubZ=?EU%0w8wgQ
zMB~c>=|00rGCGy&Gn6w5warn9HP`fYsq`6Zy>!f5?O9u&ZenwlZRiXt4bFs~yj{bH
z^OiShBt7{anK_3bHL*@>(I@MMOrLy_1#~qH&E9$SNRFi1l21<n=iM>BKhjLC#{+HT
z$duoFtmnCuK4u=f<VJIHap{&4UX<*yOLc~e`|M}YylehamxWo)yfS^ik@ID%dSng3
z@bMXz*Mf%u1<g^~>_Nj+-0XeD&8aYo6?}u(@=rjXK})(b3c0yL9jiGG^*>#b#HIVN
zeQFq9>q1~v<7-=8x@Ywit{W|n=1XE${pH2%KeT`Szm2y5QY4-ljO@yQAh7fcK$Zl{
z!6fECiw!=*-bu6olqp`-7MRon_pyZ%bgrVzT1_l&*ayzgfp3;ssFy7&$BOD?^FlZr
zw`{lL6Ma4%hKL}{f}>l|+ttV}5Uw$*uzGKT%NFhd^hbw!2s^zjgzw1~eQx-JyMT2(
z0c%3<r!8zd!PzeDYJc%>fi*GrlPypW5*O+r^<=P~LU~TQeo)TWprBu-gJ!JA^Ups?
zuK@y$fvz0LDRkqtoMq??mX!;1yJJL!n>e)0OA^+xAm>9))UouSf<7y!>a?KOKYG`Z
z5blp(U<nQ3?55OV<GA4TZ9C4&mdrG$<ZfmNCbaT@dIKB~(hCJ|Jcx{X*yZc+aWdI{
zi01UnT}Dg3c4w86WYD$&)##_+y?BLJi{Fi?UmnXv8vbFAlYQ(`(=?HNz)!Hl`?gRl
z;wcI7sK<s%vtGq(UALnD7H*GR1ei8u)B}0aEX*pw-&p~KK?ssk;HM|+pMc+6(2=%@
z^yjyQh{+h--gU%3Sv9=&VOCW}+Ch=NYC+0>GmeB^!VI2n%aO<aEQUEeJ^C~gp!sfe
zjJ|g}1>X+J9mqW$8v?RT>ZaQ!ub^=&{fX)O0WWwN18@M3b&dI0zA}Y_dehXyxKmH3
z;%8IxdzV$wDcOl|M2l8o*v=gMpwasX2yVK`ZA~bH3$#DnHm-kE#LWf2A|v&C-tNnv
zUB0}@`FkeSCFuh7PAikH<V!-b&db&^@v2L?J88`7m5uSey%9Rsodpb<^L@@S(0I7A
zU-DiuV^hPDwZC9KGGl_&)M7kzVgl>*$etsRK<+eV>KS%qZCmeE|MPZrry!7XPwBag
zKbY%A-oqudEN5KBi)xBbRwzq{<TfZ{Z1@i_4$`A5X}FmOG;3PKz2iA>Y%|}P%dSBJ
z^M98!V}vHJLm&z!#&;F9OIAsyI_8e{k^P<YlG-Zse!FX<uR-U>$z(@FQ*~SZ=A55q
zBPNg(g0YV0ZeA2rbS_=xOJa3oyno#g^Yb=cFdSKyHtoV>L=p??#zIASSBeF^DJ_Po
z*d>Dt-Tcg9c~=D!7yy(CGJuCXgP!_|AMLyn1TJQxV=|{iAhLghW6_9g@loCOYM5u`
z#~-y%w-q0PKZ*_Q4+r)ekvz-a7wkJC1>6pkPD{ND+!m?McMf)s2%PyY3q(skYKKhQ
z|K`d#F-(@8_*x{s>Ws}R2CvQ6um{tm`n5N5>r4W2PG5OO&@`v+jJsT;u@){r=9u>a
z0$(q==AQ8Dtm0`A?|vwc4kGmoi5=^<a7oF|ksi4@HwHSRhJB7=CkSChPNATPg-$)D
z;Bj`mv;)3Q>wd0RbtpM3$ju{^JKR(jSKwHvF)*X+V$~HUW4~CAf@||3w=LYNPl9_O
z1QsU&LIq&quq<EiCUxFkssVf;Q0)Prmbc(08G;Cq{)FIuCljmA;38P$FZ5Onzsd$%
zJUxPHWhv}UV*8j1syrFox<Iw0hu>JUHO$tcS?4Ni!}in>QzP)=s)wZ$k#J6o&bmYh
zyM8ci*!&)o*j>gBx7PYy&7{f@t*@Jp5@7TvA|`Q~>iuUp`(OQ8z#7ijdg*CV`$?qz
zKD}ti#k5X7oUNw=>66v97lpMTV}S3C7E?*^_R_7azdCjv;I5p<c!nAfOXE-ts+G^#
z^DJM&T<G7aEjToJ5G$GRbie!1mX&@s<=#zKeQKrbe>qGC@0kXw4T_jmgR+l|Mz42x
zZxZ=#t>bQ*^DK^Z(_q*qhIx6N@n$+>JJ+lBd=RG+qZy*ykxU0KDOP~%W1z%S6nk@E
zdSZTL{%1K#lBvBjr#ItBJ;`7p<Rf0momC{vmZzyc(u8#VNEjXCl0+=1mM1ZwM4b(%
zvdp;BOu2QE#s_nz)~mOu*I9jDZTX@yMP+nCXF$7zs|?U#lEZ@Douqv?2b6H&ZpU~m
zgSxlP-XMuA!Y3v_wi-OEcMX#H9Zz2j$z~~l6>21P@ti;KU!xq@(WHrq#LjCO1InrD
z)`bb$7SouO8gWqcXq=4C&qLB9rNT`C@5+3B;vf4P3gq6Hrt+^VMF72>D|1Sxf6LMT
zza&uPV*rG4XQ9C!kXn|(pJZMDX!r!Q?10pnIB2v2&bA>-6jnh<80vQj2r(O<+s6O4
zK^{vSjo$FP*&N-7z=i5zpg5&HRW7k2Sk&3p3CDx=%DI38K3dW>!*<5DMy9S#umWP0
z9JScCqD*=ApS$k&MI1khdfTY0PBsuR7OEG!y{axV_J|Y<ZCi+e)_Lm=+PQ#tOx>$3
z8?8+lnigu)nW&`+pjR>YTu$wmNyOiP`AbGXcP21sU*iz^##Jp`Q==3*+}V!ezhY10
z{!lm9mpx_j2KBL0DDV%qM)D0<n3o3AM*JO1-oI{l25SJIa&6@nau6Z3_Exa21duDA
z#Q)>IJu9_pg0LeTHa*Y4)OA?0VJq<Y;kj#hgA}Ynw5ka&y%HEC<3h_wjBEUYLFY#g
zdjzzi3MpZ|{7dc)w&-_1FA6VqDR<CfHOZ+_8rvI#$rp8d);$sHv~h;>!&&QMpsA2R
zb>xxwi%^TanN`C;Cl+LWe`+d=-acG!oHGZ+bx5FV*K%ZF-2k*0VJDJG#otv4FeDDC
zi*8P1Y;Sx0V9BH1_OV_*q?9>b+A>KU<Q#-N=GrLE{PM7y#__72F_SD2IFRV~hjcpf
zdfBZ}2hZ(hvxr_h5K@V!J{0V`o45gx$2$OUG_M>pN&J7jCjP(tWp_KIbJW^_*xR2x
z?E!#f*Yl(HJ7!>;PssajVdW>WeQQ9&vL`A%y!LQTI?IxuouN?h^LYbbtE)+ek{+In
zqhAdZZ&b1K#xJ%qx}L@80S4HH8Xy{4(JT6g<qS)_OGA*Yeba;Rfv){<<r{n6F*8uL
z-y_jtT)+Y@bSipJzmYYp!S_N<#edoUpu63Y)Wipf!K%Q4c0A3o3oFTt6$K`Pmwt0n
zq18-FwZ(D8LaiY|c4xhPC6qh-+OFNQfo7n3uTvWX?AlP7F<It%-bqJf4*2FQ@D2pK
zTzeCYutSYtkqV6O)4wV>G$V~EyeKc#{^J<&$Af27?c-qQf98<9_~-E*qhakNnopTi
z_5E2+=YQNEeY6RMd$?S%->4ZC=GfkKYrho{c^m3$<yzN)HYIjIEo}W-8@!{UvhVn6
z^mRaig#RJ(fNaau+q=Zj3@62;=?wvE3%7hXbL*U+_{4kwzgpsWpR2LUxO8W-zAPCy
zovOF~WS5b<v@n=Lpgx2h*^@5p%D&w2<C{?Wo*g@E=e7_)n_{e~%nrLYR%Yx{3eUFX
z8B;|E3$iE1;TVz)27&zm22O@N@OQ`P;pdlat4y%!lP<8+Tc9rR&bQAtT-eaRaHEPd
zbtWh^*I@q<niiBVW&z^Lx5NYBU>xRwEafvVs~RQ!pJ)RAn?NQ+MI&kgMB&Uw(%5>;
zI#!}9d=9M5*3aD9&q%$mT2^}gh;^rKJRTlBVvze@XC*W1GACBGwtn$!6JAwMM`RzJ
zX4`SxKeAr)s02Prjaq$mgE%zvy9$*k2hRK=&q2@S(avG!MVgS(bc#as5o28hoL(MW
zx|`x@q>{hzRW+SxgSPENo7!?2HniiW#Na!@+{}{FC)2j5$4A!bf*9yv9ra<k`SF7e
zLt_@e$CV(E#ZB`NEbiKRJ{bWClrPIpP?Q;CFvG4LFU*omZjwhP`o`8+Fw#ky`Du_m
zVC|G0c^-pGbeq6FyQvCEfg9beY>4>$5L7$eTPLwBpsq*uY_qm^rww5T5eIq@1Gn_d
zYd;fU9l8Fl76aO7dAdI$YnGh@Mt{eQ@_&NcF$4#YMAzuJRlDyoxDTddFL^bf%N&}Q
zNA(Xe%w@kPpZk%cdko(V9^YqKib%ql(akEvZb!>K<WDE$#veb9o3Nts>?enK1PW9P
zR&|Kb3d4YHT!l)g$%OdoXR!P`f8Typ1F!g2ZlebBNLdqgJ$qs6#zd^LVC}Y6u2MiL
z14qtmYDT4n+{V@dzL_*ryzq@EgOR5F1RxUIGpd_5Ni5{(xBZdCHr~qTL1qjShaQ<f
z;7UZNCq_1~yol0*N>t@j{=N;hn2JStsfcJSdu@=+n3Nus7_r3-$U?Gr?PYSH{Rgsg
zLlReN6O9^VTr%Iltu5@<8%6*u;m44iUT@o=<^L`-kyg9%(R#}#V06pz7BLrbvYE)1
zN_2r%w8f|q-HGhRr4_&~g!PxJx&9nA%b%mRpBwo0UmW#5_E`I`iii1%wTj2RisKFP
zr<XGo2GV)TV#1j`n_H^%!E<w35IMQdjgwbIk?R*T2BDpzBma<Lc00=0)i~IO2(`pz
zJPOTh&aTXKof!g2ub@NF6f^j{KJeMN5q3s9Ny&`0tJPi0z&j1Tn`+)CA6Ni;h|kYS
zMfOv*pKevLor~tbFGZrYOT*vB_E1i%AmF}-cpOrSHR#B3%4)?W!<EHAb#zKtQ3!ce
zu{o)Bnny8pOh^v<J$T=~spNRwqO^KH=oWC!?>&W*wxB=mkOp#&06D9GcY-o(6l{dm
zwp{ryyy6~k77kBJXSdH@kwvEvzo(v{ji>LeF`5hi<336n;Mw+*pL$e-d`f<|>P*;(
z!;m-4!9&-9FWuod+NaxYgCToXG%_+p`vS$Pjy`-7(F&b=cD_u-KE2XOi}~oJam|^(
zkxbx7qL@$}XIP3f(h85uv2^+-ZDL<&@SvWb@IQA5|GT{CjtkE;^vCl7(8fNQ@q3uL
zUg&tx0SAexIJW~DvD7p)e>7rMoYj?UW&Iz!Meg6WUd~&)!^#?lC@nT!E?V@W=kp=N
z!ti=g4-aA|T9^@VLf((nQm-9!|6Km|pB9E{{jlzR-?2A{xBT5&qcf2&>$hN0hrT;s
z$X^~(;+OnbBic+Bq#}xkBNcw)YwX&<4X*Px?v6j(aMy+RoaLzqDy<Mf_GHug-uqtW
zUXe=7z8JXmNL+H%>e$ZkQ(xl2OS0vieR-vn7SzHGt-iH^Y_qck@N$Z{qRB)Dw27;)
zc|!?jN}KjR5HXSq`F6DH%a0b!l=Q-k@IEYw>tRE=3UOd1*17VXLlAtCsy25=Vhr&8
zOLB4!p317KF!8MG-`v#J_#pAsCh9ROrQ5vw68(5*dI93h*EV+U&tCtak$Mpp^1^V?
zJX5EC4AJHSloG5)87s4BF#INcMGxFSXg8||5AIU>QgR^?h~z+O=Y?9YjyLrIzv(yP
zuU$rNc2isi^s@(?TbXs$>i8fa*Z=R=^H+-eze?5rNeZiBSU~VfwQmpWxF78JA@aB(
zl0r8|zohlx-lpHE%glkLohM#$<Q)(9Fje7;m!<d)yhEeT9;#Et-22#$pYi+-fD5C_
zhM2$^)PIVLiHKdIF`;o6H(qVy@iUhYw=ZN#%X&|jgm(xQUm$OsqmaiS!u9k#)|fyB
zjj}HW@1TY%_#cwa97;RQR)uOA0M(f_wb+U-P{K;$s$$p5O6I;Rje){&Lx9VYFWP`T
zSh)?99i>^rxjp%VLDV?JovIeZ_P^w*MFeQAnv#C^k^Izi^%GdpGn+Mz)0bD6hD~o=
zR3eR~jLBS0z17Kc^bBq@Wc{x0sY1O~SEttAoa^wb&-4yBury`RUUJTy35sLG$rPP{
zVroSHurHWG2{IJ<h746j*R@*#d4A)ndv2&EV9KYoro7EpBr@{ca9ubP{(5ok9K5>0
zp>0DM)qnCr+!r&=8=nmaYHQ1BP1RmT5dh&2h_9pk)x<skiCtz;yp2;z=*IfnUlRa#
z)v}g=caFTb1qx3iYxigp2icP7BJZw_jIFIv%||nO?(YRb@QC~;(lYK>hfBb`y>IiR
zv19^>bL6<0e-0q}y;cGah(=+R4hQNMUeWTJ{q1MIPN@?~m!TN$J5Ng|!$gC&O@Dfw
z--Td{A9SJ|@bjc(IiDtVf`C`MRndC-4*r()!zpu1&30i<X+tVlulPfl%-Bq#iW&C#
zx>*L#h7^xwb&p05&j2KF#4fw~5pMW5JxLQM$pyX78^@{zy7xLJ=&}=t<1h0Smt$kD
z1mT3Tp0zH~kvn}9Dyyil=WN?Jj1S^UmBWVKxu^dIG(8n!+HG`zif}?=^&EA~PFMl_
z;>#yCHsZIms{w7(tK<*9*B>^HiMSfyUwvEDT+s7Bq<r^0$2ciTB=lP&Ih#5Bfh<;-
z1Xf-OJRtjz;Qcb})FUrN@^nqe#+JJ3n|-$8g#87toOvWk#DByh;enL(k0+y$;(wYn
zIeLA~+kPAjY+{efepLgmsrQH(A-@)Ls^#dK!z?7ol|S8rlc>*x{dy-ST9H0}$Z#wJ
z^&<C5ds^h3=$*xb50fC~rKCSuE={-i>fCDwday;AD5h0SP)}td94WBd_MzDjU}cq`
z1I*~7htbgtxUy(1DzQYE+~R^E_IVkXcXQki?ds3jvVmJ4Q}8@!keg$4rI@P1xnrS`
z-uO{cq=-0lQ*xT7jPnBPXIb_G6r!+oUM_&-pdhC-5CHVF4qagR4!GeovldK!l!22f
zI6=E-2acr7_DE|*XGpj6NNV_B=jPw~*S8qCNnw!^_uepUzd)T^?PJdRI^VT!MK)Lb
zjQa?wE9c|Ta5ROXs-i(l<d0kaL;Hkp^xTyzPHV`SplXl5PVGO(qYQD-0O`Vk^uZof
zAWw)xXxO=IM~f~?J(@$LufmuHI+*`gWfa}!ZW1JJXaUYZ0R-;QOYAB>t(JHGLMN|}
zOUM{oOs_=$QvThOCv(}6D<1A3JB=e78!Ce7_CwZx8s@!r5A+?Qw(kMa5%UEzGOtyc
za(gdqXDo6R|Hs#oJ9)z-#dZ1dU^$X9sdyj+O(uc$^mRlT>JZJ<sl+r^f0t~Rp;`1K
zX1ew+3i%G}47cbM;Iw#6l-`^>3Xv_uQ>js_){k587&*<Yq5#`ExiN>=0N(0zKV%y5
zC&b8u3iSQWp3zH*c02GU-3|$7w#>^Bdw)~<0;~_X&x)2d`|EyigP%V{>pE62w)ud@
zq8s+wkm0q@6Gr`XLuE!q&g|+fIwt7kBP6}!lY3v3g9p~lZ+>CDcg7ql+~nj9B1&l^
zPBKxlf4?VK!&YRDy&Vs<=~&3Ur@qM9-p$OH&=zXj7DIPiF|mFA20ED6Q8DQBr{M2Q
z8qgJAwWI_*D>VGccw)cB)8^FbGKqHh`nKxWb+@yT_Wr4m!Ya}_TE2B(*_W{+^9Nr5
zHaUaz$SELBzq(<dRj2RAo2*w)0=I#rg`b<(z=x*vQ&NDOuO!@~L_WhkkPx(!Gz0JP
zEfw^zLvGnz?dfJm71jKC;2V{s=6m*^Ir2ZOQE?O82%zZpagh@v#vj<DO15<!rhd7*
zKj2T#V85H1r>&cuNFi<C;guTE?{;5|<~Wp7<sfc6nd6_vL73$0JrlpW;SK#w`**wX
z?<ZIQ@;0CS*qREfTc};y5@;7nWV%R9W+tEdXLxlS0o-E~zxN}J;mphr6fJ4Z!6Xb(
zcMR7nWkL1)upoW?X!C`XC4$L_i;EJV;p?9%h#q?7yyg^VLrn`(LF7iaAlB#QX@3LX
zY=83BXY$UYFc^dNOl*1~6Wo@>xc<`-<%k2>(}N@0sx82*TRBMkf`}+yoCP^W94O;m
zr|DUfRxNmRn6(6^HcH)o(enu9-Yq#+X>GD6oiC-9C(gF4*fl8H^H9Qj+Dr7ZO9E>Z
zos7gl3R>m+W2BvfU}63W<LMd?0s&MrvN62af(2%djBJG>y-OmCZ!C<01USRT00B@E
z)HU%^e>35LR35Sqwj2@c+m?dQw_`}M|BDbB<&ST1fq&~$CM`E{_WsEPX{UPkub#3$
z?wgGo655~15n#pxAY$KSfXAxH1?YF(I9;y?>x0fWKt~-XLWlgWI)|*VDVeb=RqXQv
zAR?v#!4H*+0a+XQCjeC_<+8?UO1U@@9z;s=qG&Z*&=bc+0u|oH0(Q!<p@mZ~z=|yM
zmfzq7Vxn=;02|PTIAH%7uGRv}YFn%4YLG9XAL;ZZ1QNT371S%^nc?+$=3Rv&CI@U@
z;(cOr#LCIR(oHVylv28#?#0dHVW&Nw%X7sJW>~=e+j$+R(gJX(##n?)NR_((xx6S5
zA<NASj*|E%Nv5U-yqtboTJG-|XfNG(K-4hpz@w!3X11!hbF-9C?bKm73mckV87U70
zu-0U_C3Y$UYcil*Yl)^4y}HynnjOFG)->?LK36XO1cL-V&Md$Hk8kI)pOicK07N5M
z0rcDmsxc+BOv@nUlH&vh2kyy;-*|?^PcVlADQDPeWt3CJ!;-*>7C{;_%TmL%IsHrw
zT$xdt1<*U;^so>U09Oe2&-`H=R7)cm0-z++0-+y;<BY4F5HlACpqf0a>^z7SCCECS
zgn8lU$j11c?~qtBEIai-D4#1FrO1po*(smX@qhfS_%ER1U)lEG<PAdu(7edMpon%}
zQ^eQDlYb@+DHOIE(4`S+4Z*fu?axch17uqMu6#!3Am`7>V;MV?Iv%yd(_~im`n)1h
zD>-lv{CA-To_9X8RBoAmNw5;01==ZM0Avtptcg-cRMs?40g|lU+4V3=hRj&qK0XSA
zo8pRQAV(d%Miclgz<x*F;Ui)Ioja+{Iu-(-S5OHA%zEF5O8<P3?nM}z^Lps{FI=e8
z^*IKy#hf><(+!%qKKIakBjCyxusO}y8t|%o1SG{5+#+HMI@iY55}r{#fAbrMNlvTj
z??0(Oe^(A%>-Vo}PeG->za1%{8;e&7eqI)L%Rbe#VCU27^7TmP4l=2cwgyCq&He5)
zXv6DWtth%GI<=@9c;~oB9>m#@!;^;%^*c&5@Xdu=T9CI#mA>KJzu5KJH8`rL+%dtL
z(fD=!Iu@GPa9TK>qK?h^nv)&@h^~d@EZJ4pgkJz~uO8hM*mUVG<Qd<!9xUYOUNwAP
zzDz#c%wxk;>GY70q;Jo2UF;>G`<ei)fvwV(P!Iz+GV<r9b0NTgJo*d(1~BPGpR*k)
zWCLK~LIRwS%SRM3g=b~MceJ>~nzoq%BDmP_w;qiSzhC~{2>yr3_WTv}q3d5=3tZt4
z1vo?bPuIdgAseSAe&8B#BLRG$05auz3%2kfn@(klqZM3P7+Sjn9?mD3v63(f+07Kb
z_a#biYm_BCHeSm%hy*fKVerJ_lHSkJ(ZcF5h(^;-=0ow}wSzp(fZhlbU#|dzBQ5UK
zr?N%Rp)dr`#?Yvy#KS|bmdJt!W-&EjF<ES(3L~*AqWc8|pkopoU@Sxq&;O5i!~uV+
z`;JP~{CIa5?bJmed*WlGo?PvOb>SrXZ{0H_$!_-(2<oLWikq(|fi=wX_w|r+{J<q&
z`@rw9zke+5`p5tYHavic?0?#XQJ5A*uMZJY+7~#XkCFIgUFLbn4atl)7%mc8PKFB=
zVqT_qUzRA>M%X>=nD+Ki<Y>@K=9-bmayXC-yb;J${PW{xwKS<jpAKjA*>RwEi3{~Q
z(j+f0Juz$A^|77N-xpCl8nXrX-J0N)=pfWs%$HI33=<9L3<9QOaAlEH*L&!^bapAq
z1-E5lZmRNaKEqysuh&{$;>2bRPEOtW<5~8SU8gLtOAbHJgghpYMLPHra2R1@7@UI-
zWkJ-iL0q1F2`H~D`eLGm4!ke8U!={_hh(K`OH#E3e_#*QF0#_+T6%BcP{+;)kP(Y$
z{wMjlS>Sf=mL$EzTvIOn>?#b{8U6|RS(_hoY_~ad%0MjwXm33K3i&^8FQ<F2D(k<A
z1%PU&N@0_k@{a!hCRF{u&G?wK=$-XnUBKZp8uH-p98#+i2s;_9UNN9^LJ8(JkekUb
ztIct`?*t=}YgfS7lIYG;WGYuTFTfO~yGiz;DxClKM<eR3w|yI|GbPhCY4oo(d|NLr
zj(#kQf3z?Es$suk83m{pz~sEoUj;nD435?g9rHKx8Km1J;XM&{Q$?h#AK<;?iPF%+
z$4S?;B8EIQoqq9PU_reW6$XLTLl>E1{y~hEiRYo2GP$K9_Zv0G(U4c)ag`fZ7O<en
zmy5J2?()zWZE+(X<heYmxCyPv)MC?Q{gtnG^uF_E-}_-pq?et$_1zX4<BS?gL(_^C
ztb7-2+?H<ayYok(gWDm!gBJqBNie<X-05Yh8tu1CiQ6YN1{;;d!nru0w-km>ytEyj
z?!E$Rr>CAaJRVVr9=<b56?M(qsr>e&t<<D;&quZNTL4Ey+|rv#rh_oO&^r=<0~n1D
zO%LFOO)(@TeO@1sAaxBNb}Lu0F{^fJPu;f(!p?iE!t%k9@e^tlC^j1hH;?=ubxcY2
zPvOm1v48*N0Km%XIo8;twx6G(_jEUfXlDCq;u}xje>|Oju!U;^Yl(#T`yQCWeO>r>
zq6$fEz1NoGZoT*OeFr0~mH2}-+;0x7aSKkFY4&qS0fTLSyVRneRv-Vo9TqL*v1#qn
zmCSOp69W<5uJk(Hr=4eh?VN;N_C7}VEb^hlrb8D#m7f=)o7$h*H*)06Kl=IlV6ez*
zEzHP_kqbjspY9(?7xiVG<Qb9|0M#KX(E{NIp2-=q?*>KRdvJHsmo6RW`Sha4&vuQL
zj&Q$_O<I}J5b6@n0TV79?nGICR~e9V;?#-n3wZ4_?(0qjf}ZW~`&?iebF43+Yk4I5
zhHW2s(WdRK^wkPD$Fjjo#iok$+M;{Yey=*}1C_rOZC$jLBe$jZ?k}WQ^0gvCez4u#
z@JUFeJIo{tx260Df+3r54{WKq&Xx(h!2)k>zsMx+`TYg6^Xt^t58L|1Tn+B6$dn>Y
zLAbC))f9C4xJcUc7ca5lyUG2%Owh7Ukff;T#2W?#dlSE|^iibSWGkyPp}CKK{<NBz
zzUD0^(Ixmi!o%dS%%NQnB@f?9+TQP6QySn80flZivFS$4SyIxMjXl2UhB{6%{f^)Z
zu4x(@MJ1~u*=Y;|XOcJO6-I)Gy@XfP#mVT4*EXcEFp%oFaFHu@wAxPf*Z(Rplc2&M
z5MKUMSLjwVT!I_OJ3!rs3yn7^>Ct!}zVMpU8cUt9a^E>PmtcYIDGR}ZVBa_a?jWmg
z)+8I6Pz87w`Z<dPJUz5De7y7hwOG*o*zC+4)!@6!?t6LvxoIc*km|U@=L-Lj#dPh&
zW7UBlqh-MMY+*sNu?k*VK-x+@ye1`U@|Z#;YJESM!~M>>?En@m;+^#4>7-5PdLO7D
zi@wa+R-Q>CkI4YS>r)8VNu|4XpW(`qg`xq>piH@eP=8kM&2dz^<o&?*i;T1ok-j)B
zY1A@)(``?@3wo7=c&K@!<_udKu18!f=GXQI9F(yVg?IkyE_vu7Gtb>@z*T1|NnW;O
zRZ6nZO|{&kvh@k_(ho4B<v0*#$s2(jEb#U=6a4KL@&I`Fc}1BPVU{$qXLfGSdg5Ie
z+n(6C?aE$%%YDHFIzQ926|6FL{X}s*lGfR`_%eT#eYaIh^pH9Du7}B{d`gM2kYf>X
z)B^1r0W*a#are8lNbFNOn}^@bJ@>fPH{A4bmI~Qk!e9%S*62@sHSYXhC7Fue*f<0g
zMvUU{&5tjFC;9CdO)8U_&#+2Og<)Jbg62-(WL}ZTsxVINUWC820N7d`s6zbPe(>-A
z)tM`5T$F@HD*R+~dBk2fdbV~-aoX?V-Td{Z+13e>XWEaZSN~;au!cRBVf0sU!Axu`
zl|v$-3BbXF#wX?SQ|)P|b1jlqBMMB!!7V*B9snKYZu>(ze%@Vga%NKoJ&yL79pK39
zAEob!a3~L|&A1wv8`lF|+u>7W`lYd<Ea*sM4OJ<nAGU_T*=zpG!M%H-^H*#OkI#Rc
zz+p_%>S@n~Hq@})cb_tRj%xkX;CI9Bdw9Q7f8lrh3Sgdc3+q61aKn_<4in%Wa+VNw
zNH>ilXG=)V(eoONN?M)yc2B3e+iq0nIG7rMJpBNXU#~$L!*}TxK#~3}`N?d=c)trR
z@Qu;HsGtIjZ}QBV);xxmGQwhVztStaQXqv@8&+sK^G#3dEnWKCnmH-!o$=f+w%hSX
zq~v1v^B!OHlfM5*es#Z0zwZ$~>Zbnj3<*$K+6;WtH>ub0yxl(toqO`qGhKirBr}qc
z0>}4D)U?vv{Ese?m98z)Q$r&Ai%&7GUS71B@;E@bnR)q3^~#+)pB;^Qqvp`zI2oA8
zu=0nT)FiTr!}Dt!NYT{<>qKbTn9BaC+BgAmRlBUtIG+}d@Y!qLkv0d6lNZEpxk<<A
zi(TCpf{u99CtmBHqoNEG><^HL@Y>7Pxv^oe#ttp1;@KTxJ>i2~lc)c#*J%XT7EJ#&
zv0AH6tV0gipgh(^9YdfJ1#sbriWE?7@v(DW0XFn$2GE_Xs99O@X-?_(dvL&Vn?8NW
z!MwluW%8oqVxCby4JCC@6B+pKldae1QO{mJJ<WNI9=)p;kUNSzUw)Q+Otu-Zq&CGl
zOwC8)*!S8zuRD3_xespi$exAU6M5OWn0Ax>uWzo>=8fHi%yXP__2zDgEbgiAa<7C{
zjv^(#<0+~Y(&G-?2Qo^8w0zuX!ul5Q(`n`NCya!=UoQk~eKO3lfqaLHfmx0QZgFE>
zxbZ@B-UezP_4E1%#?7Bku1|XH@{h#V4Y<%qu$A$h!UcHedE8g_HlJ~E?vDmjlSIl5
zfPhMidT?123;b;`>KKy+H;#=k@sMlv*R^1vg4Ra%q1N>7cEI$*2^hDO2=Q^aaTj(i
zw!p=v?b%k8wNd(2qUe}^zD@3*45}?^4>6<5ix`jOk6>#tG+S?(%8$t=wor#z@OaI@
zCb&!cKZN%02HEFgzMYYJL4@ADTiIEzW>jSVx~(?YYxI>UN4uIrs0Q-MZHGQN;&Nir
zzEyRX<Vo|<9%t7x=IeBi$)w5V>v4W|Ye`ORz1k?ecC8mjJZ7nQ>d`^SzepD7G<A}Q
zN^pPLMHJ1WbJDx0o}oK8n^AYOpUhak5gCZbt(r5);W^Hj%MvY`wpULrOx&|zi_}55
zzgi~xZmZS4bo425A$54MLMv~wc(@6>?A)~`%r)od1J^iIVlMm3&DepRxf?sb0MKJ)
zlHSoQI90q2S=#*+x_iQ$h>9^VW@qo8P8qW1l)PqHpvXc{S*2%2<c6Fsg&Z%7kSvZq
zg;?=!7(=0uyedrQJXjD(TXsi1;@#<^w$XDO;mJxt8j9D;L3<v#8u(uq<=-gT<V^Bj
zhMbv9CD#2{S9~>|%8=Lpt~a#D+!!EcXw)a?t&78%zY*<ao}g0cN;MiKw9>Mlf9K4d
zAVN>5S(jCH@8CtI(%S9|@NtCTJ#ho(Na0h~Q<Y*-A^yU${>+ownxm>og0rhwFE2z|
zw>JuW<QYQV+Fk!2%Dyrz$~N9}80jwQP?VDH?ot?9Lb^jzx*0&aM7m2rq`SL&kZzFf
z?%Kz*XZPCOv)8%a_k$n!;57_$&;9)Wza)zY--H2Gqu<`uoYsWn5gnjW%xWr16l+|#
z6EuZqWM8(Qb>U@<;s)`zN%&q9_#g6;DdkgVp~0|P<u!KpZ|Zz6>EQT_%F1vuLciw%
zpfbYF4b`F=wJ4A4TXFB2bV@`n<7GqUmd#(oxk2mmW11Qh9!4IqxIfG$=tLK!pxmp?
zs};yF+2#TzvSi8CMNedO#ZJn6h*c5$Bj1Npcj5s7S0%_><uW$3rL}-6Ut}{?!ovgH
ziR`MMYT6c7dP$4M_IGY9$n2NZ$uhRyq%~kb*pjM6N5GFHgF}I4;5H8*+!v)XhsIHs
z{!JkA&(>8H3hbBd9$?Dyy{0Hlrq?^ye6g+!@$w|oW0}ZEB>bi?YhYXvVw51xhIKG&
z<t>v{8~lK*fcc6Q-$bh=oPI(*UAI74S}0N6g(-4mfp{{7yPn4Vn8N6eVdng%7?Pxx
z&Rvg3)6YF<`mu^Q-^To#R)1E~uN|;UQ|?jIA~%WTO1vR_aKK4piT#O>b?r%3oFG8p
z>GfAJ#ahP#`K#1G{%UE%W>s~hIBnNCHL#GKZ{9x0sg5xy+=%0#%SW@l%$Ok+VBnn_
z@7S{M9E?KRvL#PfN1O6M8_~i!lm+j8#62Hsb~)#Aa<gL<XtqZ%MwaR%+B<I_Q@|yd
zLXl8Q;)!?3^(PQW+^D3t?w;r;`1P~0uIH4TIpaA-HuPU@ZYK^nvjAR~QfMjRCM*bq
zjctAwD2&ABMe*YR>?rcOA!?}M+3~ylXn6_gyX1z`-?pMo&7<S@TxLWxn_Hg@;pTD3
zOvLFBcG8^zly2qmgxwZMhh4_H=FN6}=8wLASTjO>KGJY}pU7YD;|}h66aZJ_o+dpk
z8n7Et<IUK0j*8-Q^O#DvO6w^G2<O<#@PvwPGmED$AlDtU>$1Jz(0}{9{R8d!KEO^H
z>az`yb{xR#-1E_h9;3kaZhj4L{W$gt+1mPq1|#QevH@JL7UzU~a_|<^7w)SO3c1Hj
z)S}THhlq^**=l-{KHe1CJjtMR#$4mejxDS%0nYBX>)a`Y)HIUYN=2ub<``WBX@LS8
zQm;Cl_vuX%rj=w(FW&B8#!g2rOykv*;fBodb<Pn=-~8tER~GQ9<+Ljyshsi=dhO2o
zef=`c%LVQ(1T|S#Z&v)pPU>#ghJawLEy@DrlEi1>P)Kd0?4|ODV*JEIi1!uZ8fn-o
zkJilHa+3qrE?N3ds{Y0;5EuL`jqjTG?;`mT&Q2Bx$NTP`cz<*l7F<IXDsr`_o1^Oh
zV|S5tF#7Lno|uLH*NLUMdTcl-d5&T8>no{ZCRFc*sy?8oF5Po2JF1zZB~1Lx`81GS
zp4@xY0`HJ26*pwvwH2zhiLAoD@BX(=)%~|%WaZ@JZ#X;F2r(B;WEroMvy`oHvM91f
zc^6Qj&6`+RW4|#f;;><lz86y+om+u3l#-kTVgO+&lh>A7U%g~7C{Q-#1fH{|2-SIM
z>he)l<Cji}j8Q`Jzc__{JpKSYZYRkxB!=o&1%c8$l1t2Chhp5iDQeH*<ap-l^0{kR
zFI%>^97YfvTC!jzHq|xTR%BV%bxewctsXef(jU{`ju0_JBu~nGfXgt_A;NTwe_1~R
zpn55NE<tm$NGtXHf#VjUEUhDw-Rdo2omV8a$G!>`Wq~K%K$iF$h%-i~xZ%l9ApcHE
zn+M6&94C94@T7)d^>e`&4$H3R+tq!0#M1SZ2YZ5*v@o(+FAb=kD%gqT(-&WGHM6M3
zuX1*{yHo!=Oc~U`&$GF|6px;G7o&dpVU;#boOlpJ9OK}3bY09Z#o#TRmk?G-lB5rM
zd2q;x0sCKBqBJ;iQGR2FpxoIGEuLL9M*<H*Vm8Q{r&m<sXXb-YLngq9pCoRL(oRlp
z`m2ysfp8)))iMsRh_081eu*YY6hf~ha-3P5#})n}WhuH{6MlV#EJturdUu)XT^@6a
zAANlnrb}sm?x@L>r|+z!L!MjC8KnlAHt+D;$4{sOaOfC3uu=2!n|sqA31>gKX5F*B
zbx`(53b2VWJ4A#6``w6MbkS%k=N=4q@8QR0?vreqExYnV%$U_;R*E|$E4)^<^(9P_
zRNj8K*mQhftk&NmmpqSR-XFYbL4>J|mcEGS0LjtI<4u=WvgKCh&kQrXlc_?!_%yDg
zFJUSW?o}Ef-G>;yfTh?S04qn^av|;sMEH?dThZ`QjBSShNYvzs_^-(ZJuA~9anOmI
zBYg?6U;!aD{lj7N2JwT}1uVOMu{2lNF6-l_P%IDTB?LAFIk+$loEp6U)rFWk1rDF<
z?slyyFIl0~a<-lMfj(lRb%6Zk<kO#>r2(CP&glXJfSWf!e?H#TmXIZ5&nm7`11lkg
z(^$|PUNVMr9?uH4Y2;>a^_N$@UdHoEwv@~>nz`X!;OaNS@D@UkRdsg2)m7$W|3MMT
zJ*ccrn8aA0QE0!&iYhQZE8}j?yWzi5_#FrC4KVP*R(z~b*DLhEPAw|pY~(U#&Qao<
z1^91Ckt5S(ESwPi#KPiRzh!`1+H70GoRX8~v*FXf7C2|3z~t;}*XvVZC%!A`&;=gH
zYEVmxI~|-BVHUkXfh|yt3M7|HJRm;f1C-r#bh{95q+i(zP;P*Ipzeb5(<Ue8j*O35
zbSy9V>>w!jn5;R#xY_KU{%C4^m<i|;&W)>5hGII*vFgB;ZkuR*c@yB^5O{V@a>hXV
zb4!7W&MM9&xt)yoH(q2Pvucnne#KLtR2-^Vk_?Md=as=*Svda3Gz5#VP#B{<R!{#r
zxbp?X^RQQW?!CcU?Aza@FLkShg`ek|>mGTSv+cSApiFWJ?{?kMlHG8oNZjlYAq29K
z5O>=+0sC$vBA;U$Z{Ja%%9d1Hvo%$Qc_ABg7(_cA-HK*HS=Dtsm|fWrdAm~fs%98}
zr!>0K8GYM_9jz=n=VnBppV{_x#gcf<z}wF*tSIFph^6RV+ve^Krl^x&7`-wKy<KoE
zS5`gShn#k(MB5-Gubuz7w&g#-(UY^k2X@mEtuPduR~~H6EXt7F&=iYrP4+YY^6f_O
z_VqL`qu?>hcyQgmJn8q7r$Z6~4p|74n<J2`9e8$$x;n!()<vHSpumnHSEN(F`&_xv
zZhS?w`vTma+8=1slgLljk8LAX|70nybYo|oPhqxt+Muewc)hg3tmLEDc5iOYvLcf)
zP<|-=LO~z2wq_Zjcgyep!nm9rVcz5@bkg%)qi-1h<D}s(f#GhP!IAo@L6N`jT@HNN
z(ET@1$&J@w_0;p`^|@OXttbP1dS~`Px5*^e54&fS$VjPrhL^KRAe*<Y$J-5c&r3Z`
zRTOm@r-5Beu62A5*>aJUEwLb*%Q?eZ)wH<(*kC*qp;0Xpcv<AK&{9(Hg&@Mt+t@^=
z@>}V(s7NYKAxu)dEUQ#kr6JbchHk5Ag;0K=<zyDAt|`j)P2}QTWd=xhUP1M&<l?&`
z<wECP3Y&86k;Kg)x;Xx~fGhmZ1Dxuu@3SZEySUtOymJfQil$m$WG4R<#Oa#6HebzS
zUDT`(UNi#l%Rv-J*~jC#4wgcrd5M56gHA{h)8LH7d<~1^FgaZql|frmpE3KJVTw~z
zB43#=OL>;d5d8HClvy;`2$H}wnp;oO_ooD0`N0Lk#&9LZJJ9O;F62}Wf3%3N_+g7e
z<y;DXPtQ$r#Ze?VsBcO9>AdWlZWburBKxD^FGf|f^bO)h)~>IXw0HgplXweBp1v3Z
zn_xGj?h3zY8M2&Vej%_TvnWS)+95Fo#%tW8EbZY}w>^UF48$AZy7_UGo<SLUo1Ywl
z&3sesT$PN8|J6eBmz&*|X+Igiik@28p1N48aM*~GwB!ztzIxCSmBj_K1hvnhz#8{|
z?J^&B<v1!z15h>ApkemaF1*E1DTq9+1+fV@$Hb}kW=j|FJ8cKlqQ`b&ScDTdu0R6R
zqKe1!0qv8Z0C8{I(;9j!AMtn{8_={_5^$`a*=sTxEM4M1d525z`~dg8==^6qYTOe^
z^MDq12!`>+Z-E_35hP!IbWEDIcOkmeDm5t<(^g8m<0N*&3eozBKe+O%NA1i`QpdK|
z9FtD$o<6&{KL5f69_|nnm~T?w<5aO83zy>3ViAzSu%ZIK@JEL6C-d9~1661lAh>!X
z)eyaB8oaFFwGFO3E<B43TdFo`xVvRU**TiwDC}c~7swIOT}GDKIBn4$!d;TaXhbuR
z0T<u{Nc?S2p6)?1H^mkA{ljE9b@g84dfwV&LDm53$R5=02W8hvlF_GTLTl!%^4iGA
z9@NkIATN$Yn1~BMxZ2FI<4-6R`$Y8IF=o4MDb;P?0)8akd-H{#<;Hz)knkpcB?pmb
z5VzlELOKpVE4_chO-4!$>C>hoz_J_bwnSaY81Kjck=Jx8CrNyvj=D{CH^FoEc1>AA
z3%A35+|H>#A$%;){yK8qCjOZ@7&7o;+aeBpfqp$B`82^&-^N>u3khJpZuKngU=@tr
z#z{pnGRlusV2(s;OY6JxLTpycz3dP89>@{~?b!}?{FaX1d&erc7Nnc&)W#YOP`9C%
zh=X^xxfKDT@Y!;*(5(i7Kdz?2@^Btvgn%vqsHpzvIpFgz&tNkh_`b)yW-PbcT;eOR
zZAjIG9mpUH`hv}=MD;^;kFI{0Qj1P-FSDgIHKDXiljPcdIR6>BO9Apu^=3qW-Keo;
z`-RcQT)?=a)n+f@5tzW>8moYRw4(amkrF7dzXRX%IT;0`=~evI2BkTzxC|<+$AeI$
znJsV)8jrg|Q%i7ccsotoZ(Fi&RE3)s-+yp&hZBMMTAI%euz$%Q(F>%G+fFOf6DYm6
zdEHRkkNuG}$c&|nGW4_x0qvC0=W^GdS@e0Ia`cb3su0}5Pj^MA-fSXhq?XO{Cp(-+
z8^}ft1=e&pxiH`EX)SQTnS0t}bTC2JXHn2{wW2NIy_Zh)cTut6j@&JU93=oc>2G?l
zIAmB{;+j7Pe^2-3HJxa5*E(0nug&pyEL3d@aCckY_;~KsTmqX0loOlxbIDl&>daBx
z0<@gk&992ZG@Fg>Z<kIGe?g$5uj^tAl-L9WI5P!t)T^2dt}fmTN4->CLGQ?)`gY?+
zG1r6d;2zeL0V_m>nc0D&{JvZ$2D5ojjsDmKtNVCU4%~816u6HF)4cn{A>b|_jKc@W
z!uvK1%U)mhvBczmYfk^1tHbAZtZ{aZhXNxY<dhKsf&oXLL%uiGgdK{MFY?hmZwcC?
zi)cY>S;gkr1OsNRk*n+~M&v#T-UNHTces~r8uA=RYg{$qiGFLab)Ef&+aIt*70i|<
zpblEe9YDTGdNqU@DWpTq^vZB9bWO$Y-h(<s(Mlkwp<{&fqUOrQPD&d3R_3ff^?$qt
zX2SL%=6^?V)zBKaeZKDtI`ML21YcPB^7q5F_QH=ULDki*0r;&LekZI8lVP*vq{nsD
z1bhJp=h2KM^1RHav+nk6Z(ap`-mY>UwtIOs=JRKa<Aw0U(xsse*~R{Xm!$Hk@7<*!
zpm4-0jm#Ze?(7ZFp4Dj%@BaNFE=jP_msQ&aAkB9u)4MOUk8`5I`GMzqHSZikF@CHU
zHG*tv1Xx|xY%U^M)wr;`Kj#NMKg>}zyI?#&Vws&pro(^EJrF4~J@tLCgu9+Ozbn=Q
zR|h#5y<E_L#BmNwA9X;OmJS%gU~8$ntU`r(`rmgrL^c+l3FxB!pb{m0KWYv1Y~$K9
zl?V2%W#)r~*h3Av;hF+MM@HVtE-<`bQUhOb?_Cl!nk^eQ8<t0dVf|UEOzh(=y`C7R
zhB9$8l`oiiRKpjj<5b)^-*M$G^y1Z2B-0;X?eOMQ;SB4zc7*Z&X%^Y!4*OZx$m$NZ
zkB)c^JC@Y{cE%NJry;!3edUm#U`IZprM<E;aoc<lfgRQEdL)Rq`$$CmE9*mr)6opW
zd*;pTwBLO<W3w!x`ZxP*yclqIPmb7Ghu%9A2s=2uHjsQ_Kah<&_yWd>I2y=y54ge|
zh2ZYQ0CbI(pF@9G)+~`w-N!Y!mx_q5&vB{i$E68bpc`VS+91qbFCgXR=zHX~^EX}r
z{-m~^FKbLvW(L@$cF6`0ye@c^pR1#!;ddse7&ia8M+*?pwx=o>wA~bI{@m^QQ^f|b
zIjKIi{ikh%@S~E@)<IzApPs?aqEvZ`A~1}WBNAQ&1%0y`=CQSqcBoFVoiF~$mkzm2
z>u#U2>lpgD=~CcYrMi$#iMiJ1<4U3-(<#k%$E$B+^hP_c{J|+E#;4$=gc#wZCPpT6
z!Kuiz3*4<N+Dd~Ux_)ZTlDTjD^cmT^K*p5Il-7(>365ksRjpOyUk9)a1o$M-p_8XF
z6CsX%bM(O#;vOWqW<EUxJ?b^TumsxystN|F&-o^<mkZw0!m<2X?@h;gV@-13^X1$-
zz$u#*s!y1OQc0xWL9(x^=MM6$XnrGl{n^-_d%oxA`j>TDUHu6UezUqJSBevc_rPKU
zbcug))9?5CoAq1B=A1mEdw__rLwvz8wM1S%{<}a)C+AhFj#%=CgFH^^)mj8I4Uu9@
z4r_J2u^#+0t1lnV@zayBOOi(*78*Ph`M=qNYA1Zs*uBb=<Dm!X8Kx?ypnPV}waX->
z5f#Z&c7TLVg80|*(n~u&yJ(XhI#BeCV7vtq$~VVQOx9oOeJZ}|Fv>Le)z`s=E%h8(
z6oTG>T?s54kkt;Eh4*ENm+X`b>ZxQfMlngv=W~(tpj39ZCsi7*l@&?BW$_BPdNV~}
z&^<4YM5Ggy`Lf1BpJHWd-TM3zFUzq%PS8F|m<A~C4f2G1!7$nbr_yG2JU(B579dbF
z{g>4l&~L>KckrC4;q?2jZ-U<tJ!+vp2{Tkn6JL4(Apj_9`2wy?2U)Av?S#f!)v4~V
zLvYwWeX(zCM-&)gaxMe?QaDx&eutxjS>WZrlHl<`p=)SIl%$>KYXCB9*N*Z!_+}oL
zR{&0{&e}7F>9SG+dfh$qh=x9X^@XaWVsUo5KIV`R$jKr7%uKkLt4id4uZs%nYGk!I
zSYK4aem>iet?xcv>!8~{c_>JJvZfC3eQuKaac-(ZnVY0B*ZV-|D+#0$rxQ$kO7`-a
zTs1(g7Qqc%pv;-v%)8K$HnM@+)RA71rWS2VGMX0=^b2K}QT}0av!+8L7ELbleDwDE
zCBM=EIgQqHFiVnk`VO@=DcH%!5rHA|0W&b~9=IF}IZ9m2S$Ro^BX0X5GoAj1+r4qS
zI+ubT)%clVsWztt+F78EqpbtgB?c8rqc$4jzkVncAnO9xx~&E4TmuB9KZ=T^LH-Bj
zq6B@6WWbi`J@JT~)hp204N<4DHxZFb$Ns)^G3zLP<nBoUaKOKpx8%Mcx;>h~KB()=
zNd1rbOB=xi&+{6kg*gQ!C6v8Bec!!=wIWucNnCwn!nSEGm8g9<dbF!=K_xt0<V@~M
zF-wASKPSxSdkqOEM;qZy#l++)1w}i|)9#I+L2yxJ2yWh4PikCh-JVVleAPl9^icWl
z!}v4-Pm3wKW@S;zp)|y33GG_)@8bF*x-RmMM%_2v+0JQc@;qGEZjX6DW-vCAWj7q|
zXMu8g_?F_Q$$k&5T<tUiqsZUqXRTNj`xGC6<iT$cUdAo?o(XL>W^7hC*W;ox{ec<j
z!lY?X?|xN={F}Cnj_DT8u)<#%Dn1u=2Zb8?$DihHtE$Aei$B}n_0f6$x0aj#Dh9GA
zfJfK2f4(Wdv4(_$ya|}z-UHE3!R^V&FbyLOkGa;1Ij5;PR%6$wf%?+}#w8&YiE!a!
zxnq>cUXorKfj>HSEKNQ1hIN2!FB&^5lF1zD8h&S+UXXN?)L0k#^oYxyoW{TTu2V1U
zO$B?j5%Wmb-rnhbZ{vNRSvZ1vY5-grH;uS<GTDN7<iOaWnZ!!(589!5x)0aJ_Gf~>
zO6iVFOG2c&Zf;#^C|-*aM%vpZ(KEe+^SE7Kp#WZPi@kfhYvO+2ebPKP-pxrM+|x0N
zMW$p<s%RmI1_dVb+S~9PklKpb<b1Tk=$I1m>kq73qa^cRkei$B9IDkd-wyO(8BccQ
zANf(L>`{}C__;xCgVO6OSb!J5(wXyP+6f0bO;LPh87X%nIc5Q|dJ%5yHDVD9=(?W>
z{HSn&AZM{Pp?T|tw=nc6uKw99GM%x$@eB2l&27D+pc3nVj{~-<uQN*PtFo~`?S3X(
zBb$mauPcM^&Wax|+n2Vbo*P~jZxOt+N~N<)RANjv*pD{4SsDt7VDHhA%Z)J+Ki1HG
zZ%1&6ufG|Z3W%EySzFp>gE$87Nf35gad-p|<v*@Ns-NCPLUMx4f-9})B2L_EM}Cre
zud#n#pdWrVO9nf>tSQBM+J!@fRUu1qP7-X#<l2+#Gjn`N2{yfK=jcBxQ*dZNx$5OV
z8~QTrohE6Po0#P7pclPPKa?5P9;In_e!3VYwMvOh#o9im*W|-=7Km~Ov#fz_E#Uv!
zCBvJoi!qnUG-{0UxU?L5F8FmQL0YK)15h#}hY$bDqj)k5kN#}`Jd2%y6)gqzF<VrD
zV)Jr<%hEvJ)oy0PT$5S>=61p_yO$%<$0fiQfWbm2C%mgyUQrS1V~$Ih3~JGbGEZxV
zm>1DarS>W)a9**(IltQZI#UWSzUmkc0+u1mFDTwM)U$M=iIwzWF;jT)o{NL;$oXeQ
zppE9(srh0N(b0S0iyB}zaRsKVMAD>n&CvdPysS($D7V(8Jwv(<)K(dq&$wHq9P~r^
zT^Aal;H&o2N%!TR1;03n&<k=kz+e7`rBH`vRul+yUzy1_pR?}PFIZLufb(`dh^K~8
z1@OG0{!H@=@Ci17Y$mtrE11aq?6z?4l9@$tM{+Y1{wz~+$LP?D7tZu@xi4Pzjm{hh
z3RC(|1bBR}T$qqN9n+^0s0(##mWsK_nl1T6#>yvw93jQ}q=1g8{UT7nvA^VPjDj-Q
z839Ldtb6kmJ12lflV8mwVS+AiFz%y(g)%;u_QFq&sk(CYuRWB#AcUR%BuXDgl0z>{
zZ8>)uX%6{1tDuo%DT8K8W>>;3EpXtJ4Wn<0WP-C*@+0yn9o(IucmQ{G9gou7AXST$
zSZybF72g`FCk}<FL!G*WjW^2fCj4|Vh3<QiCGTg=sLIs_Y}PqCK~Hb{z}X`<%EgDM
znkoqpi-dHL>$v5K7K577hwZsS+Hlmiu6_CZZ<H4onR2=cDj~=)+HC6me>LI(kgo$c
z=taG+m!=nYK5&K{N-OiR-R6+ffS6=1m*nO2O6#fT8eNp*a=NC1?MwWvuFB=p&<>&D
zUWXTVPu+jEp5S+^R)Sdghi72N^bJ8E?@;i?(^`i*PFwxUK5(BR2c)O@W_J^A*r6Cv
z0@@0Ynu3Ka1`M`2Qx@gSV|~Ny$xP*ZX^kLVRQ-;FTSqKl$#rSP1K6)~Nbko0W>MAE
zVLQfS8c~5TQ%$<>#AMfX(XHc0Sh;x-1WUSEzO3^-bbU$O)BJ+^@~$^+E*dB>5(JAT
zWEf&GA;9;|gGxtj@F41hj7O}23q*^LZ|sAq?3G(<_{doohFL8kNv0%Dx!=W^s(QQE
zG4R&`oEObPrTyTi#kwk)f*f>uxCQ>;#2S6uR}eEXH|Qd>Rs2qjY@v{QFg~C!Z;mdg
z=^i^H%xJ4cto{IFqqQ+|SRAZ<O7l)$pll!X(B&PX8`8OQ>=zI^Mu1xEffVNwdEEmJ
z+{K?34$ZYZ%X$U|kyu0cgO{2x$&&nCaRxi>2lZ^|l1<k40hK{L2@kG-2;8(GMi}Ia
zr*!DT_Bc=PJ*#nM(<LIc6-Q$;adI+Au}bp-7maw|#QViLQI|K-M%kg#kE>tOjV3;f
z)4p#1X&xJBxpSat;%Gno)(MZa@_H$!RrChq_vih>gOSexcCrQq@XldrUmU|g-ruDY
zod4Cj3Fz4Q{2u>Q&CAOF=QyS~sy2-eW+C<CAjqO5FqujdqAk2GEC2|cl`e~rs=f~p
z;NUb?WTe<3!!pL{(N&>WebO)>80Wy$g*C)?0EjmMUu-jc5~{de{ya^0CAof{+d&T3
zK&wu=xzxgg<haK?ytxrN==nQ-Ar5N+$g6LUo67Vx2ha3gb=&Gf)lp#j)&Qs*%S)VW
zflI)xQGRiHPsb<>&D8`%=pX#r^7nz0U2kYPq|(ME5KxYUxQ2X$3@asvBLTqM>`$Yt
zkM0;XIwbKr#3NdcE8a);$zyi&;)SzZf<dB_p%&#|&0a^xr_yiWsd+zpUeCuKs&W9{
zOIbtrw;|(Y*B!R`FfT{A+Zyz<9_G)%l7=IDCctW%CPCy~q^}5N9$}(t%P<2wp}mZ6
zwyx~N!F<Kb6|!oN?e`5&AsT_;Wx`5fuG+wxri9+!%)0SPH=H~WxtUS*SXyv{#9V`I
z4oKc|zB`IhUUplGM%*sHLY}_q8(sDwf6aU`55mqjX3;S!!2>bcc+*q)YOW$?(NsFs
zx_8uZv6d8Ab^84|Nu?^^rn|l>BFat^fTRC9iQcUCQ~fK72$1}X{*6b0(x#&NX@va8
z*pmb*ksArd*pyg}u-+*R3lnA~nqOYKMN*$n=WQmX7O(pVu3kVG+u@WhZ9$_%*uf;+
z`OX<Wg|I`42UI`#YIe3vE!y7F-rD<cLNnXyXkYDvtKZqNb>RO7bJ9d-^up9SbC!b7
zW0iHGt-=KS<*5Py5T=3xYca9Xg>GR{i?aAWXyYdwb?LFfTLk!)AqUtcmNfdps+T>2
zw~tFEv`cB5k48AjE?)Tmd@Fj4<m8eG<kSu8rJpyaCYP|zr9m=G`5UG>Ikh+f^=cxv
zc_$VH4r%x!QJ<AJ)OM?E=Brr@SU-JYDIir3CRQNbhndVfw2Hx{8eLT#=&Sab`%Re!
zbMzaV{dVS1tVrE$d^dNO-No_6y9z_S07IcIl75K1deF4G-lwJ4>6-hKB~8AWw&5jj
za@I&iq)|iO3~@lr@QzE01yEAHMN)o!X?)UBheKlDsirN(l-$v)f{>@vbgkf5D*Lc`
zH^sl#!=HkmruNeZDF`Ig4!=VT!;-l@A`9Dxgp9s$)?GZZcV(*Hf7j3y>Je%)y($Ry
zq%j-o)UNer`b+L<aTk%r{VPRmGyGql6$**iuUGJTAU_VgEN4p?t9djZjF3t+8jvld
zf-gV_7W|<fvo7b;R8asY7z^ehHFXh!BLw#`IQ0wTK}cuc$H&<@Rb`f^twE4k4uyBR
zIn(hhIeC>q%KbC_wFv1sh35K^x-wzbHZFp9Yp6}`!$>nS42id87Z2d5_RK{UXSoFq
zAjK}%lE&eomdDY2r3&F^oUz3W&T;fgKsv5JW!1ngqxws(iuJ))K|r>E>1QWD@VPA6
zIZrZnx*G%ucLY1jxDj;d!WHv;fo76~+Y)b)`%ySGm!Di+Wp79UIMj(PfqG+imS#wh
zD{Mv=!UJYfMs>$y(Izhru~f_JOZL4$sy^pOVHVe(nR7w6z1%+wB$Iq5YpKj+Vx$7(
zHL(7z+pVu80vxB;KM5z=_UV7Moj({mw;x?~Y&vudov+w(oR8ofbgLC*egAOI2Td=W
zjVZeQP0^=H)@V)jKMl+Oy{^EIC+@G5z@lr&u<Z-{C=j=hbC2&i&?eN<d6FI3z1p%%
zYn2#0!&8lMDP#9;rYW==@Gb_W^u32ZUD<-GD+=cP+GD^@70aFKr9nm|mc<@96*GoX
zjH}QY+wnTj=`)Ik^JPOy%^s^dqgOkNOKlY}?5s<83)=#2u5sw79V2B7$i~_<0?WaN
zmv(A(MSJDOpRIP8lv3HyJNx(VWTGK_&5`_$E#p7M-ZHau3!1_$AVA302I?<pM5D&m
zUJa9iJ=dUol@>o~7{P~9v`k<I)|)Z=9cbYe)m8P|&5XW}zyrK#Ow@Av)PMh@Y{})_
z<kSJlS0*Qn<sJOHpvRLN^1BY_1u3V!R61&c3h!fP*#Z11_4qWF0PNW}S)W>18-mtI
zH&cm9gXgFVp_AryN?J?OHJ#>{1^1U0c1Q(RmfN?q*b*iOxYE77tO6wBj3xm?dJ^td
z2;r2zAw4}@jQI2Ydv;%WYX;wU{P!Qn|2Dp{0FXq%A!Sk9MA2@SF<$J8`2R^gfm5Vi
zUc+ZF`0?mKT{u2Cp}v`E#b^V%pZcs8FU%t0cRJb~5uT{f7Vw5C+h&5{E#^1gA@H{~
zyb)zt4ro#G&+CvB?Q&ganocrA9`3EK0GJ=dPz`SY*)3Z3_XIm#%;R_F8r}$cg;bHu
z9F6zQ6eiM%+P$v&-aS}?eijM@5vd8u+e^O*(Mb;CvG8kYj@ok}Aw@IAuZm_X<IGn}
zNxI|3@9gIZUUTA9ZmolMdXOYrBTenCdCrUrnv`O@QT+YtQ{d-C#NxWWhhica)*>3z
zavF@QE6+EF*F=km+Zw;XAYcZB`Y5T^m`OrDnz{<DY8{Y-;8sQA(8a^*aa&IMBn?>c
z^!Pg--X-B&9(ut$H;THC#vb)^LIEc|IFLtskeNyOX%W`9mLbQ2?v0H^HL|U15l*a5
ziP)r;QznRFq!B+n{DFM+yy=e_0ye<dyq=<;@Q?D$R^zGuFPY*m%e+eQRp1W8$tvq*
zo?y>?RgO3JVDI2q7KJs&vr!%3;KydlxFjHM997Y~{2d_G_5qGM7eC7zKxvAxhSA}Z
zK|)dCWl)ee?znq&dxv5p5Vb)AJl=BhW=R2c0_8J7AYcv|*2tk0A$q_(7Z!XzsaF2;
z<y<Wvh*Plz+JOD`B6<O7C(g}wt@h(y(A44AH-7?_wkIbtnYOxS4m!wPQt<0On@)zS
z;ZHbo{xYYxwPY1ID8CgdSK;KSVX&AX`I(??!4=`z-*I;=uMC=D#GkUZN2D)FZnAhO
z2efWm*e|$v+R5L(g;z)gE{g(r%|VecsF_Q<WayNUYsaW(_L2a+_6><3j!0(=BS|ts
zF@R#=H@?~aB%$n9P)fzh9dW|irtRIr(|n<x|FEcD>4<TugBXA4j6Yo)qdl0DP?9m8
ziXSByL7Q<qhzg^@YI{Or^EeV*emt#XrKstwxTIcjs`3}ucel1SRqoGMrc+b;tg=CH
z{v0}n@=5t0dEHqU{*INua#Og!Zg&|2WZblRoCk_uAD$Z%ATdgkUGdcP=GYQsygmey
z`6h^3u9g+RPOdylZf39Se}Ht0>&oMcvNb&+zjxN>MB2E}RUc4fFXl^#vTn9(jtM!T
zP57D5U5Tlhv&?&WbcOTQzmq`q5qZ(eGeE|fEEHhwQ0UrPi-5<aM|FuAw^)^yL1ohH
zxM3a3;3-mp9^CJ}tcjznr9a*(J)1*+k#Y_kw?_mEVNXj)ca5f@<E%lImf_mI|72C*
zo<UxPs%pU}<Lv<c!6^cg<~~6|d)+Dog8T!mhL(}RL-%KuXHJ)h-~95Nq!=Fu@gby)
z(FpxZyM|%WDaKb(T{!n};$0F%MD*FJI>0Zc+>XgqCDVuPvEQ`Q#u~bVpQojPRO9uM
z=_#Y#PVQ1)`C^4>eor1X@2xCkT46~~><dT09iH<dUv(EphL;+G#R%?Kv&`;`Jh_|k
z6}`UlvWVZbZQZ{Qn{Mo1M^8b>e_>53yJmApGdBTN;s1($0dMv{YX<&T(xRIza8Zj;
z^Ugt#n~mW0PywOXFnaoCdB4}<Ltml=GE5H@_NED3eMG;r+Xu{TP5Z{c#5P7PdlQ_h
zt+{%mMwXvT@o)i*1;!amdkk~8qv|-%F+iO-_@Wiw0u^=}=;_uBYSG^C!wSljN7|rA
z%KP>cey8>=@S+{tH2~~37QR88*cGm#3eIWFdna?sHZ@+hL>?;VE9$jpb;~C3y+?c%
zgX&}+4F=IJ_<~%}7i`byFA777?t)9y9e|kuf0Fq;`5!>ng)Ko06E|i}Ya>UpfuqN&
z;b5r<wkT{L+P4W!Pj6t%r-6(xo-O(~Tap$+Q1-}Q;%@jLuN%_<doy}gALH`NtTBvi
zyNKV8Oaa{`Tyb+1<z43*Ri`!xN60#cB3_UXX^z0fN0x7?`Vt<65wcg*drG%S#%kgE
zpWx;Rg614CITA<L%AR`=ByHT^`rK!-`tA!0ul#zgx7RW!PGOg^`u3aJ|NH0v|3XG5
zK=2gY-AhZlLSUJf20owY5rd06&l8LY)-9jovE@FXFT2d-^!T~l-?ON}T+)|2Ri6lB
zb$f-lucl(v79kD<B)$P?(O3nE2MP?(PoV;a{#;s7?el0k=rYq;I}%{}U3JT&1)dIh
zsfzDdfUkg@<mx41md%01S`aO^q%~uheLq(85+)C|MeqWKRq7b&t(0{S&lg9waLHPi
zpUy;zSR7;&BK|LOkpumaJ*`jNb;=ub%C)uat0($tYVEJ5QU8PrzVnK(B7e78lm5e?
zH2IMAQ+l}yZrv<7q?en6O*?cQa%iX8Yr`>Bt0$JLBH8q5+tIcxcg2T>mM}~0_CU1D
zJM~cb$+6>e)mbFis|ch|5A)noz29!t29~!G+2nh3?^$6_#ra<ZEe?=cJw9%vp=zSO
ztYz+Y)cwtmE>QuST-r!O27|mz#z{6Ct7qQ>91{b2xthqsO414DBT==c1hp^{I(Uc=
ze79D{)_-JT0C5mBVg2uMMuutBm)n9DWmDLN7ec_*BZL8VUidF&3g%vC1<m)G_m40c
zJf7o+oeqwkUeu=)3le0k5YVcQrK?jA3ZRvD;bMu4Bq)?bnKg790~?{;`3O3q@+Ch~
z<vN$yCYO<Op`!$K`LT7`l{hAOZ2&)Q%IABP03DA%$46hRevzRq#BaK}>+u~z3^Z(h
z8>8@!b77pg<q&z6WfJO;kha}{=9-G=;u|fdJuk<H1!+HO|6DgHKqv~>Mv7e^ejN2E
zUxwJ)%?!18#Hk6nc{Rl=QQ~9ew+N({SDXjT^*R=P+T#1sC^`R0%Ef<m!FpJ5g)3ps
zvLfQ0YHblDekOX~Afd`Ey8TZJbZ)5XW<b##o2_EKTjUvxWh>G?0zpG@KK~~6kDdeK
zt2I=>mTEPX=D;exstE=h23R^<`pKTYI~vB9!TXN^8QhJ&y=<A$gjQGyeL_3b2boQ&
zAR$0jpaibg@^)#DZfm)+2UouqUC|$+R4q#Myt*ZaySo#H)0(QM7437y%X;~O18$o;
zAyX8}-G9YPdg$&Ya5c^G{;<T?zBPM*j<`wUG<V8I`RzE}ce>r6&Tw>=G~l_)Le_Ag
z1c;7i;@bCFL{(KdJy$Vqa7ZzfbzIsfE!bM-FbMI|)3*>0;-!Azoyq`aD&7{LonE|M
zF<Hy1)7DY+TyoVZ1-oKXNx`ly29VQyQDr?0e!~iWUVSTQ=yRpSSf`3F^&;H^ZbSt)
z9;gc5Jjzay&s{#q@us7?-vDz`tB17^5MC2DAiJ6n>E)9OG}whl{x0zl+^1`Zzh|({
zO4AYZ8~Yybg~@c}Syq<qv8C#7MTszjc5)H<8XK)^SG7;nQscv7oR;<!K1m>ToT^oS
zsZAwWe6h9Q>t9r9afTB1@WD7ld`OCK^JjYU6U9C?s!0^7Z=9B8<3FS3eI$!_z>`O<
z8#Cs8C5mOLyrS3hM`TIN<@E=+6x7-Q)X49R=1#Z)D;|k9Qp!#4NP(LO#SeZqRo`cN
zR+vB0t*z`~bqcX#uDnNo$_Ay0l`6s!>xK<+(MZ$c^^dW9xBL#FyH|IK^NqZJjpq3S
z%kMn*1mm*nrGX4w9d1%`@94Y}ogWXXWkN+%=REg*k`$Bb(%ds92A%-3rjGrE6po+>
z!n3`|;%nJ{7gSgYI|<}7OI~C7sYjF!igJzu1-)phuJCMU*9khtE6#BwMUevCxE%So
zcv7xONBWPoiJzk39pv06XW_&jxeXtrvo%57yzYnBOZBL(uqXwe<OS~W$_q9%f&N;T
z^P4y~#nZ;_^{}xwZIz*u;uKTE9hffxd*%>+*0u}$4xrn2RR9tHqv*ud%h$kx-=9cu
zcq_iD48N=i*Vv;`KC{T|<_vcyfRFnT%=vs$TCB@YT=l{a7&U#ND>^w}^%ob7R2+8O
z9}3cy9FD{Pk4Nf@CT~sXG~krdvHc6p-b0|R;p;%tpKi7*qo??}pYA~_uiLQaK4qGn
z1vU_cA>rCf34kN(h~Jig5&L8w`|n^wZPG}W+lYO1-7faJM%$)y>*6%o3RO>ouyr2S
zVE}leX0y7sZf^|h)46Bqs<h~pQXk%&RB%j|*M&$k18vDL$abJ~;nWhAxm$wKE;3jd
zbyGMx!>d>sacb7EctT}&jQZn*T%5Rw7=44^=lGnR?2v<4G?*-;rgM)p(Deqfd7RDd
z!G%|cdvGjH`BH`tD4#R_?GR<OPlCE%M=x%d^U>hU-kY`~xo|}GTOC608fC+%1D(o!
zNx1+WxQPAZpD#^a#{DY(deZb25f`0QvdP8FqSqIuk+^P2&dHlsvB=R?%wi(@?YAD=
zviYPOC`}Wea}u<rzN|~c)qTnY`W)t8<2}$HGX{aklaFLf=pyHV9#H*7Nf+V5f*4nb
ziP4w#E}l{J)@vd7J~t){N4io*gIyl9er8k8-z?OYRSd`)j6tvlwj0DQ`&%1`pIKOS
zM)8tdw=IF=PwSFbZH<1zUjF_96E(>eONYNOk$mbAjYF1`#0?n1sR0YBKGR9)r3Hp{
zYPj4pWqHbr5pSFwlOgOsHRd7H>Y$s0<BLubGJiX3<j2ImwMYbm3OXU}bk(?lWd5aM
z3;flRlW0EWJf+sBF;5g&3Bk2_o}2vZ6%npNw8`b4q?jyYSovS~<>k=Ybj`I~+)4A~
zQHOYDlD?)(<qqBoCM;+DuyIID>fOP*^_(xK)UpJU+Cr&Be1q9k2e<eNhRy_AUE=#<
z(qwGi$wLJ!Gwi0)9X#HQEF*;<196;pw5lH9i{B#3(AG;(T_uzC`TRe={4f7r{`*rI
z4xHkvy#Fbp+uif&4&BsWkDdUMe8};(N%t?+*{1VxE1O1q;5-iQTvylkrv&0MBPai~
z0P-`iQ_P><zi5Xp4}!~(=N*=(v&S9#RqdplC%i`4QkY-X3%youkLN5v^Vvq+_u!&<
zpe{w{_jYWuwI|vqptDnGHmT9PbmrRb>T71?74MxUB_J7oEzxq)_#wOREf7rK|KOw!
zfEG^mvW39F-0Tjo2h@~O&wn;cq8FN{7fGe3cUd4&wY<kpZ~R)m5~1Xcf`A&wLs<2m
z74B*^D}$J>(m|joy|Zi%UbU`-wyp8be4Oyq=$)o`(Mb>rjD`o#BY98`F$RriHJtSm
zp|*uG4HJ#(&v-hDy7;eqeoG5|tE=cFh0*j>b~!qGIpeGu10L0Y(6(q>Mxe)3wlddF
zx%sMNaTJVEi;#)4KwjH4hme}+91+!Jw(e+riiSFj_MVX)hhO_ZC{LTNdcKctcGPHf
z(6qkUtorvk1aVn9PgAOD;L4oOO!)fKA=h9fJ-&LPvhnw7l|+F%j+W5Nq%56>7dOfH
zWT*+*r*4j<aV=>0-c69Md^#(a8zQKVWRnxp-yWjdUNpQc%iYd{P!+_C&K*}<r6+S#
zhf84xv~x`l-<VEYg>Aztjtch;cK_Iboy;%opVy8_NVW0P=x<e(rWs`kD4`6Uqp6SN
zlU3U9y>6%{V(XMln`%>Jp_t0hs8=584qok1W_r}z=U%WpN79vyKLH%Lq6UKKCFwFx
zPnj|Lni6Iu{-5>eH_c}65OJC>xW!{3wiHI%wX((g{O@*A-T4i$zG5e3JqYiZvO6Jd
zMp73)oV_qPD$eQlsOF+%d}6zym0@)<4#BMpB2itovJ6{zc>I9!+e`qjE1Beo66>sa
z;I->EnoG5g47Z+Ci3QQ!J;KiMYeDkBku<U3Z87>$N1>QCJ~ip8K@SG^#ot>(`R!l#
zb25JEj*&lj_iXH#x0EVDGdfltE{Qtd8?7ZihalB$JHhdP5^&SKD8;;`|1ay;|9}2}
z2l#65)NF+coBk4fc3(j)!N!X1LUf|Ou9={v`xiG~z!!R-#*Qb>75scs&W_l}0gWkP
zyj^u{#*7?P?;{Ef%~c;r6xcbg`TqLN0SatB3S^TFaZU*^vM~CSF*V33POVos*(ejT
zS@0=QCcfnB27h3#S!|i~wmJ1=`WEoDwfr4l36M!{vB=F&;ET2C9}pC@i8LfOx1)DC
zVho*;)c6y?8WLQ0EWgl#GnkmjihXHFqa$6A<dF+Rv}(hfUAxo#(QAjrhub%#{<M20
z-n<d4)YhgW{N+VqFki|f`pG%O?%V>j*<_(aR-(?2Z;It0)Bq~UXiI9|4{aw;{gGyE
zTIuSK(#%J5;}}0%4FZXRK1hmve0K{NP;6%dR8JJW!u@MWDelQW4<KpY|G{+7rq{hW
z)Vilf)R#8c5R@)cY`3MS@;$z$vu4Z^C2m!pq5INg_(iGFnZdm^;<E$bfur`mkHS50
z7v{TTe&uv(j@*5>TC*&}ArO4i!iQg*OtzFKDTlMThprlBqjI-oB6R*UA=QE_W9<BU
z3}}f*0NRQpJJa))TR3O7ZCUQuv^9mMVDSQW&lW?jef|E=9=q4~1~^uk)=CbgSwkP~
zJgxC#>RSC?ZJOx6lBme^=fF!jw}MDBa}3NM1PHN*wNJ7lmh~9yZG3yUQDh9>w`N;w
z9NzvIn>jF~2XEe>C_`9tDEMeJxG{wo_(eb>R^o(>+H<wnl($8mlUqc}=L^oM_9xUH
z{Aezu#oSn;htWFCXb@RG?=S8B5Z}=sJ51DZO{+viVi$)+_}|~0TyiN#mKkhPK0`0k
zxqv)Req+XUD;?nwzac@aCik~(&Cw4kU~1XPk$knX;J>L7bu8r+Ow)i^KrUoufVH6^
zzpm`_0&q*WiEfaojvn&W9`k>9rFaF<^$+}bz2PRt*(Re=>6loV0q*`94Vmga*oC*+
zfxX-A$FC-8%GMw9K0Mqsndn5XkFq=wU)!;)>J>&hE#0KA15=dhKSD3C!DY-qq=5cX
zZEOnAy@AaO+~n`@vMyzhkn@5xKL21Lo#^!=I*;7lW&@&DmJa>Ry%3FOu2Eo&Iw<uV
zY$8ur^K{IZ6cDISf_G+u=)K?|AcJ^zwE}!|9^Sl3Id%R$SiXQ?MAvN)5OU_3^&@$r
zR?n-XW0AL_>Qalg0p2BQwRg93$JcKLHHJI|DRe`8D2g-VdSi<<3O{~>(8P>wXA3jn
z+;IXcw_<E*9MfN2rljcK;^@pRFCI_2@he}#ju@0~8oDHIo|xuKoSrpPVWdfzg$nXi
zY;-c`u!&Br^mv_`Xp@>u@c2OR{Rcpkp+05-S+8YPo?SB&=aDi=ShBh1H*&s>B9y20
z_3T@V@FDf<pfh?yU5zHEd4Gc^TSS`mJ+jmrL~x7&-<QvJr%qWsD}8pZ|E8@GYLu+P
zh?m6`n_Spyb`(y&rg^K7?qJ<Ch4(XAy;#!P{DPe-@mcQXUeLZ)M9TS|nVYgW=NqHa
zohg`eKc}K}&*qI*oh)LpdAOa|F40(;;smPa0uk8h`4)vHHPz77Noj;Nx&HS~XtN+<
zY!6&`?Dwjf&W$bJ-}>HR7fYr;5>X*iG>TzE8KGYye4hCQaqv>K^|R|6{U^OB^6>YI
zb@XD>RhkHwLs8J%Tq8g1LHzU{lTb$G-Y>Fbr5UZO{NPr8U*}P;Sk=2>9yW%Nfn`JO
z$&j$Y#ToSEx*RAXUD51~m3L`c>{H!w9xT9yu$G$KxuIy=K4C6yBSkIAVs!75u*ndb
zf-;^hc4NLGy>j~+U8gcTeg%fGGo0>>3L_cLW|J)SP2HxA9%zWt`izm9S)z(u&|JLN
z`PE(xOU4?0t;{<;be6fkL=OK(qvB4cc0tRqz#9t{mQ9cPIL|(4HKchzAsAaW0qM2f
z5pUyHoMd4#3-^ds4DKt5axd^!yHB;Yzl?n2@g$_v%o}m6yVbb+((C5>c>U;*x|sc?
z(3qn*;y+_~{bs^}<+e=2b8sBlZymXL4qP1!zL<>y3GvDfs6VbX)Ba7c$fSo$S$~v>
z@%^~+haoNevH)8iD|P7}&1Y~-NG(aklafL^ED^=>1su{OAS<`irWUm`6#n$vJXKRe
zZHcTWghv^wepa<`D9uaOdve0stXGy%ZtcZ)WbR6k8R_(yTFA~;#b-VyOO52h5)(kn
zX>{rTCJXa~0>2yZ<Ac|X0mg8<z!MKLyK;RQ%Llmlfx%1_#^qT988+6uYm>YT9q2NB
zrb=Px?jS)Esd_$V>h0o>40+D5pL;PMtFF8Dno#Y0ksrI9`DY=5PwSN5w6z0K7Y=80
zfb|IYq7no8(DD?yevupOyb`srMGQ_7d7+WIrQ+Nrr9bRF=C*Y+^p&)t3vae@_@D7^
z?gLIVDeOfUX7!dO>1E(jEZg_=n+o6lLF^lQmM3lkUjza<J?gwV<dbKR&aGp#ckZ($
zx!(?4zN1|0f5<Mcj3^nirD`IQ;hV_8KQQ?145TA`2<y`~7H<qX`>lZ=yAE-&&FXdf
zvz!$*gF4d=x?Ax<Q=pt^j)mCgXEi@<bB3M%${FQ0{9QHF18*S^TSi~F5C<wYIn$%R
z>IYq45+In%_9w}Fu|XMX(_cIHNxckt?dF5a@!X?E!!h&i>A<yrSy$4dMpn5=11p>b
zar<NjyMZ<A)Xu}t16<Vh07@1x(W~t2{dkhyc0=Kx>oYqa4#|!(z86aYJ3G_PHE3XI
zvkso$pf<D7W>)Yhn*|T$JrA2~_n=Ez)t>voTO{!Ga-Q7T;3p7hu5fK=oC)MOl{I&X
za8;%Etp^V6%jhRPBlcmZH~7aSp-n6^#Z7OWHtG9Bd7k6{b|3$!=(a?*oC*0yj1Mq?
zd%>gkSv_k$rt8U5QWUj0zYA4CFdO`f(icgsM!@e3J#bWgccC;tB=L>(S@fU{Tn@|t
zjeOKE%K$x+yCF$?8uchB13vAixtf?@_?-qx;<ozu_D+}E9|GR=)0t5oCld_H!w$_N
zBY%VQ9!r3<=WvE%phuu;Uk<>zx%9KVlx9>fCOdw{wM`I3Oc*ITWG5+*=gj4$8BQ3S
z&(SZY9T7%N>`Jl{NxsD$2Qq#L&`<-xpKInV$<9KDoRqj#b|+=uE4;;hpQrM^VB)8G
zJjl@_0HAXE)Mfw1(vJXJQ8gg;5?G(&AoSgh(#dMS<A689flqT)Qe5hq*Kqx|AY1V!
z6IVu&Td)LVQyFY<KGyz{#5Bboomn_mlYU8yQMTSxegu<-^4_qb#?UoiDQqPh^yq1l
zYz;U>YPSl=1Ut8n!-?GP5xsCItM6#$O@)W>&weI4JS0k$BuR1+%H-;Zhts!sqD%`>
z5Ujv2O03A(yP-Zx5X=^<eXK&6L?xbNkeUo9PQZ~#pO`XAHk=y4<M6;A*M+-V#J=m*
zbYTiV)ZV9~rGH3CFGqTT3_(8=iBmFLZjAmj_)Z0@R@tbpOFiKEOV38&fRJpcC&`4b
zcj%vTtR-0rrc3o`Ee*w@qr<jqC)>62!Z+BW1s}M9cz$nRxT4IrNvp*f&y3}FUG^O0
zi#%k3cI`;!umP6}R`LdO(bPlC*=D#W0(J3%6VNWwx#rUnJAwy|Ns)&RQQxqlnL$<J
zx0_WU%qH<$WF4Im15@(h-cdlyF;ypi7Hu0IIEB9W`5Z}yMFDOe18KqVK;}5xjvFz!
zrPJwzWFgBhAGh-w!;Ez7r7QIESJ$MTgo`as__G`7Tp<2rO8N`%h3hJ1Wp3)DIAPX|
z$ddGzs)v3TPClw~cxD6Z&!{V{Y+<{n$Wm5eJ1;Xxhcb;$m%SgJ!Z8?o(S%<6>Mw2N
z{xji5`@Yy;<3`jD-RT^5Ho#5@&Fe({8F_2p3$FHmq6?jd@lw=`PH-+7!re8U9Lhn}
zsrOJ|b|Q?TzO5-;&vzXpM`fFtW_{+ZBknYnk37ebYj<>;NL`#}C4m3O7l5Gp8jU(A
zWue@-S?A}jr|ihEd;p5_8U$B|@49<?18iwYuk1r)-#Q&ZxcPF>FYvn<4=6qK*LIAo
zuR72xSR}bKK?byo$TzCg0&mF<7Z||+&}r_rG-GtwUP%~3_pS_k2dmxc4t?rSK(j?C
z+KcM`{p*W*?{omnD#lOKjmxBG!D{LGx{c%ZfGIn=H$v4?7yPqN4iI@9rUL*kGs4cw
z>pplBkCr$cavge*j2k$6*Xl$HY1PQ1@{^UaiaN^ROVrLd=ny?BjNu_slsZ--S4-fP
zM=F`}v=lXp;%jz-fYkI23uRU8((Ebg-)&4epO&N}ah>^U{5}hZOSec>)YD#2^lg6F
z2ITxJ5d0XNBL=*_!TakNeFi0HZ5P2&fUm>%&=E+VZE<eOs<yxpwbIr(HzgDC9t34p
z$nONG%zM5e154QEdjOrM8lPk+2F2{$>a<GOdyY0<Y$Wo0t4|f99@=)1!7iNzQ85nj
z5czi*2Td)@ZK`8k@1e8Lk(GPUWd=mZI`$8b81Ft(Z>-DOs$UYB3-u=Vr^`IlwMlFp
zv7-)fe~w>1HlZ;mN?7FsvUko{?&w(xDxMgqMS(Qc|3TST2UYoZ`vTG_t)!xCI;6Wn
zg-uI05}QW4LqMdZ*&wj#?(XjHF6r*B`}m&o-aGfqoqK-gAOG5;<IH;2cdhj)_cbzT
zd#C)0q)|3yoVD+F4x}CFq}_#&=SS83kQrLr5=;H_3~GWId*Fxz7>Nnq7^+s*2xq}H
z{TwP`qqP>S??^=*ZO94s_<t^<{}nE5C6xhqHr&;_o2@IX|32s#qZG7s?spsoE>8|`
z=pvj9n@5n7(}0BqTH@gjkElgfZkQhkU<>qo@{}BdogO!H7W5*|+GwL++g@<Q0y=Gx
z0;Kx)WqLlkwHTy&G}a~v7t8u5^GOr;4yA%PES@g&v^}#&CzaA18wJe`MN5b~#7rUu
z8{4<Hu10Lozyfb%d$F{a**Q5tgc0zqcwwzxy3xkr>>+ipClM^mjFi~Yef|qplt%n(
z`Z(q%Pg%`yli~xeJnZ*r8XuvH0wJ@p3<Tj!I~&`I1J>y=2K3*urt!<H2=qPG=(qyM
zgr)Q9N`GDgdd_&8GZ@&a+LdnOhrzYP>d6O{d2;`u-OX7Xl;~ilIONJ{P=63_a0f8J
zCW~YY8Eqtgl%&?QP|cQa_^#cOx_M*Z?0yq*zW6qLsk9Ef^MzKV#Pg?^2QKswA%C+Q
zpVj+;9tCkHjd5?mLj56Up_eIpY<!TlO!sQ_)dToVxUOBAmi)V?oFrOiYK0<)QLaPO
zQDPd_N403%TGC#ROX`4C9{K=gW2<%OjlNEO5i;K;UScf$L=owZQfBqX5oHi%_v%dV
z*s{bo*VmgaB(WZ06n4t;Bh`V1sDs)8IV<q-R%lt5gp5yaLE1o@Funj%@}AA*eTJ9U
z%N<PReVi10um^Y0MwM40+9&(S-imnRKf#kG1}!XllR>A@yUw@TUa)5KSvl}KqOTB6
zvVnJsukh*{Q1D<Ye%$7w{HJBiB0V-+3Sfb|Fh-J1`=P!6@A&X7)0IsnqT6y(sr#R9
zgKz$BgKbjL^ccQ5Z){BfqqcorxU#p+SK+M*&xVLQ8lg@0>OROw5Mi&YI3U}ayp=DW
zcAdBe58x6|COnseUmduipLbLx?m4g96nC?dUXrQ1r~`V>-zhJXwe;Hm1hz;$VG#pC
zcevUb8luec{H=$DAOw%c+u7Myg{lProLz<sz^dV_S+u~&PVxC)s~)B6cY#U;L53v#
z2yGGlE8xyRh01dbOQ{d6Dmi*n6U+B2^kH<XXOPvsd+p~V_4f_})1LkvqWIFQ(;kl(
zy?ilL9y~Q_6-sW7dXoAZWZlJK9o9@R)@yil3!Gmv*>pr|4!j!nVQtIT#He9mhAuyx
z%p5O&!C8Ij?ZhDp9;HxU^sGm<x@K#d9pTs>rPYRK!Otem-QFs_oGXdc(h|#B7CpCR
zEAPXO?!pO){!<w^UZ#gO#rTd5Ro;O>l_^j)>QcKU?B)+q@Z7jEwFzkzSNH$9q)*cm
zd4I#7yM6y^HMF=3D~xW+cULjg+xv%|Gx;2gkmOMt{h1ag`Y>~FPX=l--~qmF7Cb=x
z{`tb4_LQe#N}|Z27AaJal1xin{AAdJJaSGH^Eb`0CSH<vJ@7za#jvYz&@%;hlN`KQ
z-|^mdN0q%<J1>TnmwnG#VJvIncN6@+4b<ws0h8gq-wKtz&Ffnuj4Hd4mjIV|dX(3n
zCEQ@o-E$Op`GkShhX)_FWQ!?pc<^z>gst|+))oydBQup3LkM2LrY;)FzUM=XG=Xy~
z`-iYGN`QP9Iz8P(n}24_0Pp4<IJhojK){PXVD*13Yt#C2C954R-jvQZECy9$lFg3g
z^MZyE<)8i`LQ4G?Fp?R6sf6{`wjWVf8s6<VAxv0`k|6Usj`Di<#0f_pup|`(`z+(b
zRNyM3ien`N$N~5AxA2<l->LMH$Va9wPQSSe_dP5}o^F4}ImP97{i3KFNC>QNjZV}=
z2UvpeiH6SQ@h&otuR%mH0B?6i!Kb+*8m>wB+o7Vnk}>6$^}$Gj4fwkM!<LY?c|3I<
z;?5P6T7+S&Rw)lQ<{}j2+Z`!<IBSwIxMn9BG#3T;SV=&+EQh!g2<;^Us$4GcKNq{f
zaed>vV&?~&mt-UodX&@)4=)Nm@6gUjNg-#V{hy?~#>;_@AMr#j*75Gu@7#1PL#6XT
z%Cp;J2>krUD-(p12Gnq{{zdtVEmbnDRBxZfJ-qxXJ`yI-T{(rx@q2AQVF?$@-<#88
zw}6cz&f%wGb}jpy>*Y82%duZoBGW&WQFCf3Iq&x`Hd_oOeoWv_B2Lh-xLbCr(PFB~
zV5Ckw3;2$Lx7*}gA^$!d@6!!EO#dbjRYIyW2%n~z^)<DJ>Bj)WOMtf06tI^UA)hS8
zj%1R3l~~03&9Xe;mL22xhV0LEj=^3|Lg<4tK~ZXk`d+#yn%jy#?9-5hSw@g>oG7_e
z2>#WofQNl*`;e(#&KlZY-uA59147pqx#)&V(-BX{WP?BN;p=<2@?y+qE*Sr;JR>eA
z5dIif{xUsN`e=+7OK_d4RQEhAK=i!zf~QfIpanEyI`D}_O>u}J>~5n?s*nGsi1G~w
zu>@<B1aQ8udUgqDmnJ$?MQJMb?dihYo<#VQ`t)nF5x8ju&_^tk<H2U2jg|&{mDAzZ
z2F}yJ9v@k%oHnW#a^q1N!;WYVzFy;c*^r#4BI`qdsY3oaU=bhWqsCa;z4hTVgR)h4
z&A;vxb+gL2@YxAtbI8}$%WZiZc(c9rPZvvFy4ONI{Tr^gPbVn-SFJ!N8^_PDM<`p`
zE2N3%-bGc*gIK8l5#!|zVlh3?xl8sUBc0HE&#6y_h+wzDmLrQ+gFtLm&})ZS_$Gc#
zJQ&S47A~+4AhVXl+}1fxn&c*cq4Z6gtA#zpuBcOd_G#vUzk^iAvxpR6NcMG0t2dzg
zjeUapDLGZl5y0P(;Q%6=ZB*raAhQc#BTxZ$L!Jj{cAa9;?j%<`IJ9p@sJKi6%9_G1
zGFH+mtNOz=!35UqyEP-%E()|<35N%hJw_|mNKJAWI@zFzW}U8$-#<7X#HYFa`W6-;
zU-9|9Z$g7wEg%kG#@SNc@Al>bM+`l{TzuKIBF{+QC)g9*BF613UM#fSJA>Fu(w3Ey
zr)qW3TdG&BT(+M`+VapOzEW47u~Z@MJj~OR6y_8JwP8z-m?R8&zMAbTDoClA?e$6(
ztK>z@cr1?N5WF0-QU|{#Xui`T;7&<X$b>7R_YK-tcB<y56H-1o<hae45q+DOH(EVP
zj%fXi*qn<)F~ANo5jHivVkd|O4^CeNw=5g-DEdsh@vyn_@&&A-tccrkp?dRVq4n=S
zKj8&b(LX<~1z0#?vp*m56J#=h^S!{|TnO`MctPZ9y;<Bm)_VzOb0d~HwAgm$XSL;D
zbpz45r+YC0$e9ae6~{U~QoE<WBnD1)EU9nAlL9{@40DT!^_DpG#AU(Ykm*C(?Uaa*
zZc&EmMMp!e&s?fk;O>IpWW0BW!?AIuZk)o<StFH=%&(w%3`(lIWkis$gOa7Z{vqXa
zG{OatX9{9KF@5>8Gg9?<ai;_^<}SN!AS9TnfK1UD7GxR=b&!AsoEgD~T;K2rHe3%D
zs;a9?{5rk?p(Ze{3_<jY<G0qrwE-=+bC_bE)~AFY-{}f?1$~SeoS478AfowRNdM2!
z8r#jk;h>w?K^&h@wNZU#h+y(~!Lf_5AJP3-(&WiJg)EfeRfv#y`!^!qXYX#hbFQ2C
z9^!zYg`n#{&1=#&x4W{P8|z%IDVKsWDyKCOz+;94`J>v2^`rSJ|8#Q&XdYQPr9?8U
zinW6Gr=!<@Dti=JgvoI5VEplMa7F&>hGn1DOiJK{ELR$yjA|Cv&Tl#1YT>~~BAS6}
z?@==UTkS6YQSA?}?QWF(V*7fF8%|`GyE;1>Z0q?T+07!Hr|7rI<X>bsgNH%E<+|!n
zHw(6tA;Qb}7#VxW<o!-4B08z%dZ~-BueTd6@Ua_wFp9jt6INK%mZ}>!{8&JArxV=O
zBwEg1SUB-Wj+jl%dS3K$@bUe)-U;tF&!Ei($fY)c70qh!Qpc=kaOt{et@h_hr<5an
zn7au}=rG;vZwi-1k7jYKOGDo%OTWV$IIED3qvw}G!ON!$qObT!KRurw(_ywqWKD}#
z$l4P*sV^1^b76%H`Rj59SQq^?X&UCE9o0mzl{$Lkajfj}K%}0Sni1#neaMu7HVb3k
zUHZb?j7;u+qmBk+G#~rLpe~3;UO?ie8ZYp0hkJbXZt7UkrR}RKXB%0H)CRxzk5LZ-
zUGIRt<<FVTx>Dbm!Zgd;)=l24(G+@I*-LdCWcIp3)gW7Txm&q*{4{Is$L^?161d3)
zuw+w&3zlXnFS?<c_)@g1H<pn|h{ufjdm}_^L3YV|_8X}<z~?Rf+VjN<Guu$-q5Sjj
z@0Fx+R~TQoRLd?Gu+XmrN>+V5J&3-hdWgZhk)`D^k2G=0`V0%r!Qf;+FXMilzeGV@
zGEBd@XAa(%+(>B>F#sU{Lp&1B=Ao`me;W$tBw@?~9kT<=cM+c7GD4*kANj?xwi!f7
zEpaLQ0RNVi?h)^1pVAK@vCog!F1I@YAdwswtKR>*>-`s==)d<v+ls%{UJ;&i0QhhQ
zw`QS@CZf9=0s(YAI}^bbIV>drI7h7a&Wn_N<u(l{PrDzNMgoHHcTIw5qv(cpbCT(!
ztF@j46XM&-n><b29uO=PQ((~gTJdIh#?779t8oZ`@}F;c0<ykHTI5hYY5F{IcEzc!
zSi;v2NVH2(`P$Vza3zdb=|li-V*=RGLGz#Z!oZ-6FpH}BI;-{4V1htoy>BJm+}{8Q
z6-1#jNAuQ}6U~Di5hC<>qR|Dz)5D6fyIsfX!fm*OQ$){8yCR{lBNx!5dlOq?@wsD<
zGEE2QC||YBoONDg$+vD{wc)pfsCNbi=o3Cl6OB-myn`~QcgM~@>^e@}?d2UIV@nZF
z02*US8^wc1u1164VS-QmG2R2am?VVM&rvmVXd&!By^@r^ZAB2sI4cyejk#`|s>o<M
zu@<>La0N_h+1B4f6jiM^q6zGiAgVGuTv3oI+8n$3g===CJFbW}s&2}`jw47~^Ck6O
z9b$egh)*Y5F6rHcl__q5D^5yjbd-}6K8#!FtI~xvg2M=2`lq2or0$oYn)+2Ix9Qqq
zf$feZJy%+OrEbKlCyKwYS?B62zYk`NC@e0EWXMJ~Sgf@<wi6}zI9~~oc`&n8+kqvS
zGlquUbYdlB`{uVu*PDkFJBt)wJ(1J%vqWmjr)h4~*<<JQ0LEKF$_o#y?!6nsm|I>P
zC<Rr)i<I7e?dOCW)pYDhw00wcBDP+5k&-x!TcCU`{#?`Z-1vm$rL|jmt=U2E1|Eb1
zxS2n<&3A-d*Y6|vCn{udc|dhfVq~ZHVD}@nUuhybbHiy_zYRlBrdxR$qrdqdgQFPa
z5ra<yh=B{0zwHag$Zv>8-ko2Gf3UQF+0mqc(k$d=yXam*bIHTsx*RhjR5W5|SaCS1
zmR-p|cOmXL%K99UG=eo#d~Ljt@hRoo$T>1}z%Wt8hTnzhLj;fn;IVLO+q*hV%+}V^
z`^W^9Fv;sZ|8xv-Sw?V3cmTk&o#$Z-08rTzR`&6FK+xOf`!qGYZpjmfFP;DI59Gi3
zj(E6%PMk_Aod-M?W(e_sNQTnAwS|r0t-4vY`RMabp*+skUdyFniE+ZrrXFC{br2p=
zB5&mme7Exed$K@d5+C*vxPd&ZKduN%V?{*;cF8|D+@vJe&Ich8rCUD?b$nQ)uuoQZ
zs%%|G+|5}mdA@bwhEGI_eJDK0Xzyl=1I+ur%*px)1t0G`jO~sQ{r0*m2Ud%-^YL*!
zI|82K_LrE*Wwo`av50_Y%q=-CF7T3MO}+;X@TZ8@%>Y90L2Ff>5k6-gFlU){07)Mt
z>6#@|cBK<RnNP|k9CvBfm8e(vI&Pa}Xn|7Xgp<6y`np}8V<Nt?t#HpkkEMYI^?H_y
z>Me`O3+<e!j`0wyO!gR>d!5Qz(VQ+h^JF=Bcg@LEiEv?(8AzV5VXm)$wjz&M&1$$@
zn=o*yoyl+vW_y)acD1nMND^Z-kZY`_sQ&nZe%ERe=d;fb-}dr89CrwX@2&i5h-~X2
zXPaS~$Z{5|&XO4WBk$&vaV9sEOWWizUjWH;<)CIYtecMKn(ozgt*muTfsxLWLy<t7
z*Q_?t%~yiF^O8!$of(8mUet_`&z+GP5?e8}`zuz$(cxi!>toxzqj{#I{p>+JvWhPD
zerCOr=;NzeS}|}|IdFoq@OSU}YbR{oX?NzCELTJt)t;Mou6xslxLr1;6O<k~>FN3#
zjnSuyB54n}1(4(zL^?hVgEOy&M-1**gnu{>`pezP#KftUKIXiqpA&LrE#o6Hl|CnH
zJbe?9M@ZBFo%w~(PGivRe9b3&B>!S6nQ0?MNYs_R%i@y`3pU6vqK%!?cQ)`mrnzsT
z)#y++uqR`{-dD*bWCmlwz)8N<a=+a~R}w0A*UzH%ORvu!qfwVUri3omJ-Y{bCV=ML
ziS@1`)m6XF>WMYEVWxsjXR+JCnqhC3$@1ac`|Y#C8xdzdf)OU5jek91Vl2f(a(E)`
z+NwUO&38vA=@lA@r5K6j!tXvOxaQVPuWat{w*Nx6xBug*3uAPj0H$|<KKdCKwsM00
zYw91Z2eyuXa~&Nc!YaY2ziE7B2w-)jiF1wjJ+@XQ*fahtVm?Rng%CE$AwhSH3Cd>?
z86OJtIb=-49kfu8h_~G5?dK=U7c5-C+pc8GwZ;6(LJxYWa_bpp&(Qr@1`%MAidL6a
zbB^c~QJ}RfgdjKsp^e7bl)~v0sh(c!Dl?hg4#EI%iz{NT&<Go{+b8WY(E_Q0nm!O>
z2Yx$V7Hn2srUr6^=E&6^4iGLxPS|rf#G4a!WlSrT&eC#CM-iEIKgLAFOwL$Ljivca
zrX}QLmXp$KlB1}`{SCtNX&oYlP05a8CUw9&x8meXpz$AvF-N3|9lURp!(Utqjbm->
zs!<>qAY7(lP_SX^jU~zDc0JDgWmeA1v8z#ZT>YAEq23?|wtLO@((!{}wW6pYdx&9P
zsA@|9{S1q-Ozu?D?=7YqxZ9);9r{jfkdXGH)bBPP6h|+G&+Deeq>x!9>$*5LHA$uh
z`GQGD6b6jPjO@<Zh<Px>qvr_y-kre<d}S99g6CPpmX$b~!iShV`P-RG0=Agcgfx~v
z=K2l;R{R*+4?k)w8&62gdDZ-|Ztz!)?Mat#ow4-cmWr&a_Z$2QBBF6d?&;b{>k({2
z-1&@{O~-;FURtgkKL-$Ct<z`3azww?l}gTC^U^~R>AQkKH8|lgdI`~4K`FBv!QlEB
z$47z+9c(rjqAYIX2wy$ck@L5ZKj$RUS_K5T7z7m>kG!5}THj;BiI)Ry*x>YX{kftm
zYP=i7KGeaI-8;^0Ms-n;&QEGqa!O@`ni_s+8j|*vKtCm0o_OSJ9AmU{a$<}aVK&#M
znvH<ZvJs2;K=eU%%J2NleZjPtEJbOFChgptOT~B*Vf1Od=+8@%)il!CPQ@1QQ9u&h
z386Z}uqAzIH*Sf~jW~gV0aBo#&eUEm#jzBbJE?*=3Twc1%r+k3T;i3SFt66sIyhR)
zBYJlgY_@g8(?bT{8m2nGefK3HU#CQ|bNMn}Rt^*$2wEdCHN3!Fz+0<~9+CDSIAWkn
zVsi@2`*Ud-e8#@Ho6I;eMKsU(i1n_a@elq_j|ZUzkyE~Bf~rF+Bene8ZAV2nTdv<1
z3;HTS>&~|OPvj2=-isXxRX;ac9$)ARxrGZKas0}4*sMEv|Fc~CAKj~FLVb>m56SnN
zr+3s{b)?fdPHpDdfa|(#6RLJF+@k^jMm<$93+%5~v`-ucJnrvLQGi1!;udH`yf0qd
z(3p&>b*F1WpUn_1PyqT^Rt49USU)fj=Y2)mdApsF#QG8jwM>4EI!d1``?xWqXRyir
z9Q=rI@oRmJGn^uRZ1>S3FDr0{M_Zm+q~@L+JsY_hFIkVLI^?lkF<s?7o-bb5)QuGq
zgkgduwy-cfAgW>B1EuN7xIVReHyc2#$a5;<_!{7v7{Yn|N|A4+Z((@hU;bnzM@2-9
z(w;cFG#2nSPkSbfzcl6ub}b^w66BH-?iiVuqx&n7xumf@M}ouxf+Fr$-JO3hTV!6G
zsE68?M*p0W`y5Nxlr1!22{kV;+U7zUvStdh1chZyk+DgFuFsgwFOhK*YKuH6dm5#J
zCsaXV_MRbVPV8BdBu!ZT!&XjgyH^afCT!~7WxgE8RVtdr4qi4}t?wazLE~kHYqsoT
z@hkifJ++bAu~$o`?bfO7`FOGm1hOh9WU;>mJh-OIa?ij|oC|bc?hUre%I0r>chy=|
zWv&z{H!_{vd>JcLrZwTKp)aYnDtE0K7AE44KvNFJ+S3Z7Tl54eI73^PtSXSRpEM6*
zBIn{jo9oumJt~CkxtS)_b9<Su_BRsH);Ln9p37hqUHADEN8)PaYAK}2Ab#8`s7Rrc
z80nY&1R^UF{sW;SVf<gN)=<bS_N!d6jZtbpu6+nSwu%>sxXQCAyyiKJPYAjwbo7qe
zfOOxQGl5IT*p5@U;%?2!X+fr$OL)OzyZLIC;z%u{my7F54=n{sVmGMEkF9p9?Xir$
z47#7sU6DI%Pmh$CoKMiB3N3eyF6U2P^OBD>NPZADX0*=c;qU7*e~;4@^#CngHf3`z
z8KBu~4hzlGN}9YK(?_@WE3ezLZ56$*d8s_3B1n;<hCTh&pkZ=7T-thiJku4kmNz4+
zz)Ya#OtOCvOSV|;*+ao^@0H1yo=#D;Bw>@Js5O)x)v1h3%PC%PRf{rB3389DW21xN
z3tf;CtW?R8Td|c(q40QepP)5Xq$r-$@;Gw^+1{u9QGn=prAPj0B!YFfDE;i-yZvlE
z=jK2Kcc0glnLj9v@gK?cS{>h&s(GkdsZG=uaPk3i!g_KYvl1Ywt5yPDvnfT>rgtCb
zE>t=EQrPQQPp`z8)|HHLCJQoV$G?`S2)NOH_~f%?F&zt=-yZpsfb!gPk6%mtRg666
zlBv;1dTm8e+JIMu-<Xu8dRA;Qpv9Hv$AU-Gg<{7ygi5Lm>k~lzrzbz5zAWoAy@^OI
zQu1_1OaM!5Q_5?f{L<&m7nV`Y)9>!!_UvZ9yT*w<({Kb>XXM9L7AnC8jGLoU@EoEU
z`3W?Zjex~WHaEF(cozxc*sav~$6|S?_@!|+kM`FI+kmfNzDvMy2v8)CN{eI^Di0|9
zoY!w(LyqR*PS932Ldb9{<*So5WoUC!)Mfi1Ix)y07qZmOAsanSlo9#om1Krn@eiUd
zMrv4-20}JoC9Sa{q+Cg&QpubRV29H2%0y?(LzJZ~<LKVA9cl(?*i<K19M;7=ZQ-(>
zc$sHj<c;eVVe3W^fEr@f=dn`!nEK-zMAP>?IL{NmAfyCPQDS{^p!c)W#5<_d3(Vms
zTET>$$CiKNe|l@?->&PDfDEQNA5B{+{xHNFpbZL9+jnI`(!_@e!r!c8Xbby)z`@U)
z!`(aa4Jsv&mYKuk(zSXU&j2j9cebc(Y5+&71NGGsxSFEpBDvw_Nxmg;?gPdFzg~K2
z)sG&Jf)Nw82sY($hA9&I1I{$pr@*Oq=l^Ja0?w;gf6uE!X;DAWeQT&}KO<a-4_T52
z*NKlg9xvxQuyJ18f9zv+mq|UekEi>_l;ekRK?MRNguFeSJhA0mpNMpSy3rCvSRhnF
z`z)lWMbC2vW7;Ls`cCI`n><P#-H}fGWaRmK#7`NHa`ZbTHr|d*6c=?$G{^mR`lF0K
z`h3Ia7i%dS9qC?4<PLTmC}A=PLvV1t<t>as2ra5vI-aPpviWQ>{9&%_MF(*0xVrU7
zfI@wfgS@&774PW?&><W*B&Xc30A%e2Bu9Po0->^AUg0V0<{-rjPTqqg<rfZiwnvf*
zLYDOKq_q}UXTx<N1F;B?!(x|kBjp)wvy;eNB|9<InS*YE5=*Kd=7r-if$OsFbtA@H
zJ@84fE{tC9L(BO+=LUC3uH$5tH#+ToaBebN`=6{{p4Z!+>_2T6F=|r#;)#wd8u}#q
zsiYS)GIif8NUJ6s^dB}tw_9um*xn*ap(SWr&$cVN^gIaQ(1~5|<yzaoelt>~s^qoq
zA?DcbU$=7#_SsR~czP7)#wo(yXvxJX=3Ux;*0azY8E0132n?#uaCceCiQTpQBRJOY
z{!-cNwo&Z)wWi3aLBsS{1f~f$t%F=e17N!{YoW)T(cfyCUi)*W3KAl1dk%l)(&*Y^
zRil}!GCP*h6{AjZ#J;i>o~vU5aIb8`&|ZD<uOv+ia$S77aaY$)=r(+Laz2;4R76!#
z7P`6eh&(Vr>Y}noHDXHqPtCiFx&Kzx^=b4phVKO4%@z=W_Q~qBY8d#m!3sWC^26ts
z{T|d8#c+b8r>iYXAxb`1AFO^M;85>y<Az4?zf?;TiWSq!FuGvWX=Bmdx<TKm2U$D4
z4$0FEN!IcV3LAMs+KeSG<w|6&V(BqzECyJ)lHa90v61}}l9K$SzXK3ooi_Ha1IZM<
zp7$`YSIJ!0o*N&t;li%Rd0Iwt2w_+tl+bBbvN2x&BQH2T4+LhMO(FJ?NiJj4;MPM>
zM1dQ%;L3tEYh@l*yy8eP)$<<=^w9<2SY}aD$bHIrj-9P|zxw)IN$#qH{0lI088PTN
z+E~KMliRM2X+_u%Ph=4xFRr^FrgmN&{yR-*h~0Hq5w9=ss>1O#?L73dz(C;7@`jUL
z?;(dmiGt;Z0bcUX!>~#o8ms%GEm-cY0Df2JZ~QoGq^zv?-lCjHX@#4TT=ro&_xGsJ
zO<Jh3%Ck6%lPu>?_g#2)7Q6%lo*bI-_9n{@h!9?xe_1`L1^Ddo8vK}`TzBsF1eYoQ
zvGStn{I1Glh2`{83m`-1lhK<6{v+DaaFEZD;UW3IOfbgE&KdywbvCT;$|HGbN@2iX
zaO~4c2&`;vDdtI|)HE;nz!0ksc~iWcfwg!rIx#KUE9fAR?08Zp&kb>i!J@IDQLn7x
z{Mi+EZNVFXh^XRI@{u`nj1e}K2e&GpLqp&eUb6t1D(L-i>v~?H2dl3~WKbrQjd65V
z>6uZ%in3Nwy585=eiB6+B?s}7lxQGS#`eWCXCp8exZ2s_VWa0uyQ%JuNc*UojSiVa
zqt%(>4*(3LYh`f3NhLyMAFl7*Geu)G#!qIscKj<vuPx3|<}@8SnC_~@WQB@@rWASy
z{Hr0I1UG&Np|irGG%Suq(L)XA%XTFt*pn-P+_p#TrzdMzYeMwrJV%Fp&X@_#$zaaP
zec8znaIdV&=mzJ=s`KGCBNJ;~W9bjj%ftx%t27)Z3zV!WMEYI&k$s9#IUIqB54DX_
zv-hvFPqWLe0twC*jM}i0XO2>`hLo<h{wCaPQE1Jv0|2Uj>n)ywO(|=uQCUZ~>FcSt
zW9yaWFXHz$<|P~2OtZ*Rmu{+)&{u}ryeazroBPtg&rr5QXa|I;Q^jN;p?xZVZaDLx
zFLT~9hS&_G=-$2H88t|^55cRnG9>vR>!a(xw7yv|f2avI>$K>2k)5<mV*j=O*nh>$
zH=s!njQLWT>KqnVk<70q>Z2N7?j*jA68rSqrm{>CvZ_-3gQhPZBwpZDorJ|9jbx-J
z*l|_zOc-`)oNYlLq&!vXeY}zdXEjR*8>+4$9*^L6lMekUL6ulr*e$K;b$3C>1|9rX
zK(3y>r&wN|FaD^`NHl34qXb1LdJjZR6r@UJeA8cAHv#s4vSe;Or*gQWVb5$gcbc`t
z2WEabMk;~Nk=+C5WojP_VkD?f@nScy`x~?Cbr=SldH7Ww3@oi-I(-mBhk`zH@PTdH
zd$$l3YRMW7(YgVSs|p-srr5bXoOi7FZIk!7*^1{R!<h<meeY^iB%pmqVd#42%LlLp
z1B7BH@>EZmI1$vNI{sH$m<Crw$9`c5(_WA0&{%<f@B(Kow9?&zB2t5;JEyiu8@a@*
z?)yan0!ibFLpVWjZ!Fz3$Vs}a_V6IIy=(}ax7gc&b<BJ4FltdVnok#`)wcjj&;~y^
z<~msP%Mb-`(Jv}uc{;`KVE5PTTX8TP=(loMR}DNi^Lc5<UoLoHtJgILaXUtTrhc$s
zIOn+<HAZ<E>$8$y_U==aAGR#5<976#`QMOub8;NBzu)dZB+vZ)nQws@!0;-td!I=z
zwrYr`{S97IZJ2}I3MVLI>zK~&;Ny#2vUKB}cDz)Hn-1Z?RHam!SJ^Jx;}YD&n++dI
z$R|W;td+l0T=T6us;|Nzrr82klSM1y)%JuE+v15?Lwg^x>%{R(Me)ldUfVTHb}D86
zxD><RmBy%2Rl{#w0DCi=M)fv(gl^b)2TV`%6%q)?hP&8~ZtwPN>IbcF@9ghhV#*Xy
zn-{0Rc`hMBQbz(`H=Ago4bY=$de+h3YM_nipl@a=p#@2ZC2=qAM+*aXacqEX%{QQK
zI^99YKepFe&gmYa&rbqqCp7oL-g3$wx{`N&_<+e82Pwh#LtUP9`~#k`kK8To4m$!Q
zj?%rzIHAR_c^a8rUT_v`Nf@wq$)P-WWdA5A=xDw2Uu|gmIU0k4J3YfdT=vKl){Z^G
zX<bsmAaw0=Xo2Hmy3o5%G?(!eRmj6<r;@l#0k;TD!s6W&bU_kb^7_=W)LkD#?u{LT
ze}M3L`(&~Hdc6EE*GSR4W$}u~`us;qOwirP#;c3BtdxP?R6ZiJXgLe%W&2h65F)l-
z8>2csUXFPW<HrY%fq+Uo>ym(EwMkDX|Fp`u9pR-%xY+`)k?y7oOF^3CX~V)-Fn2_%
zJ)=)=$7e*)i<4T$(uJXz$v&mNi9_VXEUF0VTdS>Kx<xQen8Og~%FBf(&)7WscK|n~
zE-fbbA5NM7{@EfeaO7Ue?V#g-hZz3e_8ou+=aGLgyJlmBh*^c?rEl31q@YkL);9#M
z-f&o2r-JIBQ1m^ca>!4!%!(LT2H5{fA<90tQx$#m<LBWQEO)EZ5vN(sq)xWvO<f<Y
zWc0jdZ&t66FP-%;Ms;GK!HMY?jd3<_dNL>YCQKVDA8Orm3ocBvg-rDX#MTB@(xc~n
z1ESI+>55QLnhtI9QTG0pQ4Nf8U>_t>p!P0d$OO?(bZ}_sEdjdOgcWEYzjIqI=Y`{`
z3O!+AQIVP1sPxb27LPzg>}Md<cujlR>8KB(G9bye<3sh&-kKOVLGdzj)(jsx$Jbp$
z)CV3zh&v91f+57JdZ;NuXcX?vx`Gw${t(bx?gTSSv^J7jEVa=W-U-G@uQyb=6#6zQ
z-|tXZ89wIoc%{-Bkq&}0!VMlqDBcK2rp+fv@hA0ch2Tj;LHmkIHl*Yrk{Z`!?t;DZ
zBx;g{p6-`-t7{@YSKDLKStlM5fF_N7YMxN?V))h3!zGVpH;L2JA%js0O(esWLI#1C
zEv(k^>s|#7+_A)~ug)1KJ-xHm-vgA&eXk3xE2M#Zx0&(T8~P9s(%ER>@mn@xQCf)4
zlGHIYna>RjRmHP!nUE?`-u~A6_TGaupa=nd4wT6G?hctPk-Xyo$L6g7vCj*ugh@Vd
zAO-55!W<Qv0))SFatgKLEHgV&N>8b$`aRB3<e)3}UtcQj-^L98gU$pGypzSG@Jns;
z{70untLAPFg#s*_-=JXnSBihtF~#`40I@WcsEoOQ95k(zzpu=5d25iQ<8QOZ{HKNj
zAkdS3%H{Ye%i&vO5)Be7C<{=kOw8FZe46gQ*GgwvEo{50T=9#z4>@FB5w`bkTdViG
z?J%pFww_xWdvbG%rz{6oY2g~67G6!P$u>!vl};a}$$nGF5-$LBp_>i}TJp^>fg9AY
zO=6L^I2F=nf)G`UeX^&0+b8p*w?q7m!Ao^BvOd+CMVfyq@M39bXaK${VS`CUUf=Lu
z$mITIx^9UDf&-UKUi3iBE6+s0TYW--&m9_#1mS16?0Bswaj<?&#md=tVY-Z=`MDBZ
zFQfJpoqxm$fE20uczQAovN4tSs?@b0#51F`F$xSH0%i{aEi6ffeK4?TCIS{TzC;6r
z{c0eS4GLtkC2EbAz}{VV>KogYlRn*k8+^VLL~j$CZ7_yOj@7}Z$b-|4*m3K$4Ic?y
zp^)F2%xO_JDaB8bSPSjAE;cLT4nn;~_R{m4jH*IfQo(csvF14Be)uNx1d$CN79aP~
zW@R}upU#0{n*UQ)L+-TH^`|8?msBjIH7#us7cT#sOk5%kT7FaL;^4+M2>+grgVYUd
zQaq`+Xx;j$OyH>r=Vi)8s~-nn7eW*%r`@q~wo@za1r;m#_oaE!l2U;2gtt$SbN+ex
zb7;&kv7!1ypViGfqDpRV1({7n#uKmEiuQvuz>Mo1&u3`E!21U^AnWL}fqT{uyETWI
zZB#C3;~Stu>Ah6XQ~gJ0&;MPgt(-J}FE9;u2{(lyfS5_|+>dGKSqlF~3S-nW+slbu
z?u}TU%@xs~YvJ!KLP+@T4zI#M{efWfrS*NYKSvh!*O!59XqEDqTjg!u_wvkEv1@LA
z@*TTN!MYLHjNUp9&VBp4OGA(ecatM11(!{!HZk<_)?AZX_`06l0U}4lHB)-qRifx}
ziTU`2q}z=U#PsMY|9F3W^ox#s`N@$ZJTOMcdfE{mmMljTlUe9RCD1Y%kd3%4mC^QI
zqueOsZ7g<?|MnqpA!d8c^jecic<8U#mo~X+5NK(Bu|L*G^duet;USzLd{V%5P&bz*
zR5%@g<l{9cOo<O7`A<Se-tdqIbd5_ioCG5{;KqKBMR4#L0IgkA{Pr{JDk96@<?J6J
zr7gBf)1^(7R^UoFU{(K)x}4bBl*+6y@0b?P0$YHT`2|AFdcanu5kI^F+wGO9Nlbs;
z@U=;7u<c<vdBEOy#);y~L1QSP5&Cz<(P$$~8@eC`X@!Gg$FbcC?%(Wi&)}C6lz|3E
zF@XF@CNtIQE6rTid%^mqCB*%pSAV>nC?o0m7ga$rreDU-vF*^N<d);Vur<|<Ji;=;
zWAhXt24@pExWNl+xy7*hD!-{5$*YMSMIWa&@(h2^h=Z?OH@}f4tCiL7A~=myp$JRY
zO4Z?O!y`5w>&8jVUf&<iu%q&@l~14&hbH%~gMV;n)-KDM+v$<^5Op6v^juBKJ8BQN
zf9Y@L1@_~W-^qopkElB~aSBXoBiMVCfBqiK-~2Oj5%9CtHK1Dx{SFx<MBol<rA8aY
zfwU<GXE`+Jg*B-+)*lqe3{CEi8kgJmSO<pvvENwxh&s&JP8!_0=U{eLL0=Hlw8r<b
zQn5r^uhFIl8NWlLLtgWA$uZFWcK5P#AICl9$lBP3*K-<jyH;8K`bo)t(uT9>G1tsX
z0l}d{RrEu$gvl*$l=mIh9zog=fwOFKarN+#>aty?%rCcv3$rFo&t@QZDe8Iuf}fSu
zYG$vh&9Y%u4V%_iBWR$$wJ>utM?Td&{j5~wqqkDf2s=AFYJiw64;iFpL4j_B{#2vP
zsZM*IjhcfnL=rIZdXI+|GXOpo>;lS??oE?uBoJg?c8rM#X~2Ue)x$MO!1IM^b`738
zkQC2yd=IGrqAlyo9udRHqEi@%TBU$+HWcUH0sFKdFNOg*lmblz2kO|Y4K30|XSrDv
zzb>?l=<?%3o})(>JZpK%EYkvT`tWI^QcyP$dY`U~p{@jRBbcK&?c@f@Zh-DRK2vp;
zdppq;3zs@APXp~sd4-ox`eg9a`>gD*S440lg6^79d_SLo2b?w6!nDQ)jZ4o{^{6fx
zec$85Z~z@9e&Kq;bHTz%K*Cky6JAyoxh1ojLcik1Q4~v(0qY6(^S)E4t!y_Z5Yti7
zuBa>KD(JiUk$Pi-sWo#JW%bSdju>3UHQnzS4E6g>cB8m{T24XR5juD`Tx&IyE@7{L
z2L|-fK5Tl<ccDbneHOwl$3*zq<UbLmAs}U!+XAdiH5o_+lW9hEY8p71(su%5^zDtS
zfcS){zqm)TEN|ciu}p8#DIeYS7$lGVU<pTB|FC=_@@L_3%A@0Ax?6>R&-z$maSEX(
z6CgnOpREz%e*s%sA}AfAHJPsrF^q7`uYSMFR<*o@!~v=?=isnEntf}5iAdMA6ky{<
z1m8a@=Zy;L2T4^BB1`A*1-{NqY|MwYYs&7$;{~Cxo$d?rmWunm?wIRHCvtlO_n%$>
z@|v9U8@9`^<c?jzr15I!$qV1h3wno|{Y#E18!QB3h1R`mT4tyD9k$!L#1X2Rsvi&N
zS?yUpJ4*VM7g(&P+YdipV3FkAtyUL@z!lMO<U4H7&1ul$)-N2I8=emjhsPmU<=B>N
zMTCWkdaCA)NQdicX^E$`Ug*ZnwD^B)ZA<}JrJTX`kGAD-R@+w(w%tUmS7XjV^F#|w
zz7BB0D{7x1h@cY@UJ#>R`O!z=&qNTIy6ro+D9Uh3He?tc)NRsAl5NC~qt^N&LOzS#
zG*WLxB!J4JLfZh{T_)N~exBEF2rHUDd?)$C;=N3Y{1%^5OWMx;_vBaQOdt|vAE#T~
zgov+K_ZTO&(DBAA%sRCNb$4CSw*?N%?3iF*?pI8ufe$AvfGI_$I*CL3E?b9@5e-@_
zu)8bzRJW3TfXRJxIbUfOJG;eZ1Dh64U0QfMCrN?S*|GQ?7{VKb^?U~A(tkZr+p$yw
z)@L32CLC)Hwv<lt5ddcQp*rgVZ?g(9u9=xC)zX}h)RH2hY5fJWaBzDtdbRf@AsY)u
zugan=7%&-b?mDbeeCQxv)HT!-tD=7S-TjH#um&Naq3izZ+YsXCO8-eEY|LS)ZOq=x
zoi1Efz&xKdQh*1)ZR0lvmpI|3noO^CX5?b#YDuy%a&}oDZes}|B*j8hx~Gc~X-6#)
zPA4Czw{IUmnG4Ay<g=^1c{!RtxP7h}n15cVw+9d)|A`gizbbt3Jwm;Em2)9N|K!Dv
z`mHViaYC87ew~9(V?A*Z)B;)wiD8Z!N3fR#aC<V22^~szQER_NUwb~;VgZ-_pix!Q
z)yr0r&{o1!e^W+mHCp6`85{;1TOwxeBs%=WAq8&1r*ZnRsOVdbuv-gO`I0A}`KAVs
zN{#so+bvk)+QpMOkM~G=B$~BGe3>4%Si`r1r0dm>Xd`};pD)obvGEbL!uUwC5c+q?
zL8I2`jaA_$CMdLV`j#IaHKyupGWb3=y}he!mi2tvxq$F`-U1Y#%My8nN@>XCL~>70
z5A?x8GVhBRbNs}3h6-M#biC^Ki^<8DxUF1&Q)+fPc;J5^3$iZwYQG5d-)|1f9&>#N
z9Gk{GYp=9KcGhwTV5ZP|OaCqfiJbb-KOm%?lGKdfjOF%7$FHqfjMr#wh{3EZ??;W>
z-5NU17w~-M*k9y~AVstcBkmxeYkfv0j32d16~c8Y*>S)Ah&y{nX!*ET1`^pG0G#w2
zxy$eaP3gmfj+Z~$hVFJ(5q_b?Y`IaUs6(vr1Zi9H+bHDQ|Ln2~>}o5U8g$R77r!tt
z;j5%(^Bs+$RCZ?EA!b*<?fME5p@}TH8YMd|0&c&`OX8@1rLoFqrJTQR4`ht!-siCC
ze6h$V;s<V0PVM>;N<QIhNAk3JTC_jdgZS>F`dW~<52AZ8MomDU7HDkVI`RKpSo!mz
zWaISDamw4FON%9;`HUexd~rGtT|_Vi<v|&pe+*nx>$-VyT76mjFd}$TuP8%XL1PJ|
zTVf!w+!F9+WWXnN#r<G5`eB_7X-A;H%5Qtqwdy$24Ty+)FIMis0t^Y)<G)7!d65Fz
z{=e5fmA;NnQ=Pv_g)VXBUr@D;5oR=fRQ0djAShLHiWlxO1;*xKzOM>@cLLcu_j1IH
zZ7&bnXcuuo`FFJKd9L6+PUZI;W_TR2`k*v=Tm>2LEjM$`cv#@!D=(5tBi5$<&p0M|
zEBC?Q3|B6!%Vy4Xy<ZiVc#;gO9gf=kc_?KNIu2Kvx3BRlj!LCluhzoiC?E`u=Z#V3
z&&`1vCCMU8(GNBWMW^n%Szu923uhLO@Q3a%Z;`9WvDlB_iNnuBI9vCOBS;szu4)yd
z?EVA2ua%~dPZgSaZ_+ds7#0g7Ko8(()A&4`Z~Dtkr6~$F6@dpEirHz>Wic#E;8HdI
z^0=_Dp!o=(L^1(Fg<hU1K)7bmIe99h2m|~Krp3?QWkAA~vxSSgU{JwcR+lVAUG-y7
znOY==w%mD?yX@Sb1`+w)iy|_&OE!{NWcR4DjsQ<guAJoEJ}}dfszM*ZSU%^~(uCZ6
zgDAp<_4ujY-sc{@cO9LZ+I122L_aNk?5V<MorNWg#?idJv8sm11@3i7phNS}YG(&`
zmoQQ=xY2~_BKcoeLzA=+=IH47r%fa!7Pj1R5^DxZ$B|MspXTd|*E|mJcelK#qt&QX
ziEx5QfmPubuMr{9fZ~A&w*|lb5C^bKdj;4QmIEGdyk7B-V;dK(cqFC(EwR0cl9@Yt
zdIBv5kN5oyoj9>8773%RzaQ#S@^|5_?*rY~!n=%ksU=D=%&>U@7v1K9M<7Z;C$jnV
z0xtZW3E9UvjDJ3iE@QzjB`@$#2W*c4;a$gD3B9WRt&%Tmfl5v@X*6#ytyZgtD+np~
z(;*)w_t-m5Y`d2s?@Y(&cJRK&GCwPI%tN-o(~lT%2cd_@{5Gg+)vxG~NSoTQRjjT0
z@OersG7^+w#*L(D_31Ge>zk!Q-l%!umYJW>vQ;nc`K8jm>T9#zeU*<}$JUS$h?<wG
zmErigh^p#b;crzoK>8|#v_k>>>Fq{um5^7t<R*K+Xj82ZIS<V1{8C?4gynTS*O@1r
z|ERh^fq8#ruSb3_bC60xaNwIa^@u%TSW*plc<S;pqNi$RvLIx@aE-U)T+H)ZzLDwU
z$K-d?CQ9j5(xIw!qtYI7IZ*AyPmu8oA&GZ@!+iuCZ%!YusXG#}!_Ns~e?0h#K3elK
z8KZr(=FH6^T_^2LlCF3x+Fq<>WP8bLkZBA#Ex0jjV~p8UVeu18H*;suAM)au1`vfP
zr!0_nzq@v!_-)LpuFcAqp19+F+!I}@W&Vj>l=s{a#f(W*W6H$G!jA0p*z@O!|BI(1
z5_-#y^A*!y%lXO1_8;Rp6I`Dw+67;CY+NskJ4|D>#E!Eo7o|Qgkc>0LJl7>*$}bDQ
zI&3UKe%TBhs-ByBEz*MiP$o=1cqGk;2G01_2Og5g_*nb9yOBkwdi6?JU>sz{)3T4b
z?e0^ZeIB~m@@yaaN<b42Oe74!TgXnVH&be0ALch|-#R{ciXk|>L7W-10*RoM+C~KC
zBy^m6!+L>#2RX^XL+F0_s((A=y?!Ylw4B1<hAng#$M8h*rfDfZU87LpyGaj4Hvjby
zkUD4IK?<bKh3Ks;;q@oIw)AT5ngpb*fywd2b31~LA#hD7KRg5?0o54|Rn-6BaR>Z9
z5wC(r%(D|I2vaZ30IBHLXdJQCdEDAGfVWpQWn*-wIJVS~A)$RJ^>M6vMork0mat4-
zbgcElG_i1pp-tm{tx;!Aqd=>#+k7^e`&Vqld@y}3%Y;_u7S@lnox<!(y9Nxsh>P2d
zeVpxU=rVXgW2s4F=*Z(zV@NqFD=K43KBTW|2sx}7yGktf%F<sWOQXQbV!x^GX)w%;
zNk~JRGG^l1`FT=5r{pik*(7%3;QW^L!w2}5l@eL4BGudwFq5)gBGXy%lzFEtG-;n!
zbiR0)1>4+<Ilg0SD;oe}&c9udQH=V;fjt3gqHK!lxC2NW3h3i{B(bF@tvM1COFbhO
z>I&=SiC`#9?6YD7EH)kdWj<x@6(>@D;Hxdd$)XBzQDoWR(J3;doj7<Y(s*E4oEv};
zR!4fCV#XSgFeSz>y^uPYyIRyw7qL8j=fV)aAe<7|vmkl7%TAz6U0S6nUe{SLYUvl>
ze$sh;#9ow0<+MiFU$BtK`dj8~-aA@!iS*{HQ6TOM{2?Z68b)Rugo>{TcMuX?VH*}G
z=Z4;){$>cH9Y45<O9{C~L;t)~*~j;KhD0M$zGnZsGjq6>a2<xtubT9!c-rFkfbp;-
z-OQgVw%T{Ez>6T^t9j|2@UPzy9B8fmDyj?7mIm~ct(VQpf8v7T<KY)3ezFC*9cf{|
zB9XLwIHMb98KC7Bv>ocQ-QKQQy>d`|+KZeXPA&q`6SnK~TY<fB7V83fG5I+{RYt*C
zr+@V5>{!kd%6sQHF1g_u_kaKJX*1fq9r?1Y4p(;n4J4p!?flB%-~(Fy;^;7WY`b;&
zSpwf})6jkebR@kN+A&<g*bl9DV!V}gp#w}o;=e!6TYo{^VQ|~QY{Y>sKBPFeZkf<v
zddXDE@H&t*ww&<GJkzv~6{(f{TqQNJWNu#T#0lB+=sV`W<Sh81+mJ7)=0Kt%Bz|Ug
zGdY5_mzR=U_~j#RbI^BB?m1C^n{>$3%|qHUqP>Q*kX6k_{69s5YHbnf?SU~EV<ZFc
zZ)bV1?M3!)4Z!`|=;34GE_)uAT8=2|++Uo^5`T?gymIrU_jX9m$&;m~w)m4rQc*3m
z!1FRyC8{jNWY7wdG}lt}*ihj;w+}k<n$=SsnjF|K`ZC_BpW<5%BXJ1&vsyoI_(U?D
z7CWV;5Hdxj%1+ycqn&*vg`WjQw;Ii+<FG6C(v~X_+CQ9Y;H~=XIePucCV3gXNYw3Z
zI7;W#xWQ-7GC&Rm?&H)QLxiwXD>#0jJJkTt!?LK<DGzF4hU~pY5>y)<tHP~3Givdg
z1uNNbppWzO^J^khCYHoea(zO$F!-|UwQPn2>1I}L#B6_^EPk^bcoHVxx~bTcwEeB7
z&)*SLP#|Hd+d=<&?o&%2#4=4${o`qujpDrSN4gaWnJ%=JA$^!-7lHAyB__LYW5j4J
z*7P2T-hyBKo-IHuPA&Ew=CcQx{YvWhiD|LRzONhcw69906zQAO`Ui$7q#Ugm>I5S&
ztkGB7=Fkv(nozsJJ2U8?yiW0Uvk1n6kj))+Ul4I?<Km<{Ba|la<yu*0B<91kKeUsO
z1FfF&jliLA&o4=aA^+tPr(a9V7Ie-1*KBj4^N;yDN9`Yox_E%(GlH6>B`LwS$H(Aw
z&VVDQh#5mx|4|)^Br{^FG<uRe%s8()Y2UhVsTGVB!`}!ORyQ5U9C7gqFxzDHqO<z-
zHhuo3^}^>zS7z?^X~RJODMZ~T<}fn+iYeTQV>2839it`tH!!|^1@#&?SL?3!ldcyh
zJ-2gTCyFJfXg*`@g`wy;UF4Z!fc53m5{%Ft;({I=n{j;ySoU48n{mRMM=ZkP^~Ch!
zfyS<O{)IKc&*Qy*U?Py?TQhrG6fgd?OF27cMk?#H$~(vIWZU!IR$}X=>#=zDRFA=W
zg};XD7+Ip^<@Aqd5o6QW0Uo4S%QbS`Cstgx?L>)^tJ5^LwKt)9H-aQ}oEtYwS|!zT
zYGE<|csB%`qIFL-4!<8+k#hkPcOr$6S@p{|zNEAw1?z4KFco{pzTK0oe19QKX>9*x
z9o$5V{e25gESg$8i^-=29h({wPoUb$t0AS@Nh5k4^vKkgXKs%j8yk<8=2I0Xr4Rak
z_x<*<29Iv|*Cik5N%sF#=$=1~H}E_5?f~1-4;}b<%LPtxY_k#9K|8)=07BOsFDFqe
zP!aIF`y!(W48J-)P7O<_$bJf6fy!s;UH>7P&IWkFj!L@}&+O9@pqD78100F)<y#j1
zD!?&GGIkbn*|YYa1S(kk_egwD2o#X+25l2|4`X;bvF^~()oVy5|4}sCjG#TXOxNZ?
zf!7?c;#Ncre{)u}0A{>;yJMjs!u;-%Do{Go8R?@>dNoR<hP3Js6<cbHh!eG+cJsjb
zVJHGufO6tsX+3!iRL2%^v9ylNHc%j@n%1@s%zE9Q3j*YKQBhM;@Kbz9rOnCT)n7hA
zSxs8-{g&p%cKc)qrpJ3t68sM_-`K_n4OEDRhOq}Ut9`WQ43W;3{v4Z(IE&kAw42`d
zWo2CIwTT|;H}p}1qmq#r$r|<6Vd==Av6#>I;JPc<)zq-|-Mx;<PwAB@?R%8ty)=9~
z2_7+RF>s#o?bU=!lSJnHu0~KLos!c84RTvMZ?OsR5f{hkthT5VXOL|6$M|ykXN?~P
zQmv4zlY`Ut*Bjp=T-VT9gQnUxlpUdGR;W!xB~{W`RhGD2hXUrVAkiAAn3rb6$#*Ap
z#2pL-cku#30F$Rs_v7rY!S?vsdV!EF6xu#1`{uU6TgvQ^Fu!r6QoeB{6bO|gfZblb
zY}RP&me`SVB-|u^W;xrB_$9}sSl}Rs*4}Ri?xJk)>%A8?>3QkpY3dc^w#TcaMg3)9
zNO}5Q*S}HN|L)4%difq$@-GFf$Iai`sv@Xq`v`eB|1dmWoyhHVztQ|SBG}xVc2gKX
z(W&n#Ruad4sSz05p`FVzqiXP0P+pTbJdpb8OZH5QY2j2xQOU@p#d3wQXPmCl2$kpb
z&W%yHTUJIaIj6S+Mxbng<Hvn|b?aYnLz(8XJ|^QwKt^$_Kyg$`ENT&raO!*Ef~HA#
zLONVIPgOC8|3%tc2E`e6+k!xFcb5c$B{;#|gS)#E+zAdLxP{<u!J%=dAwUQOcXxuj
zG|=e0eCOVpI#YA%W@>%`)eS|z&wjS7z4uxbGn2n<^`1E>X{iDA7RgcTJ7C<8-#Yz^
z{YJ&M;TzOu_Lc&5XM|p7wa!NVTU6f)6zNxZR_TZ<<(6q}E#1Gin3M4IONr!@RvE2w
z?liAuj&p6pgB|iB$fMXo`M#XDn||)aO!I!S(IyP^(8m`>BVm5@-1W{tY2o^yj~}m$
zUoYKc*U)WJ>@G;qGwel=ljhtzdD=bhV29G)=ok5gqdAc&FA0=yq`J#7=Em9QtPP(Z
z%D#N(ZXjR4;s+sa)s{VayI9(o{#J2fh=)Y%XqDJcmFGyoPYWeYuRq4|Rkl`Sk2@k+
zmvWwiJI$Rx>iFfGTL-SRZjIqEu_Z#V+X+wKNdQ`-0VOn*Yyh<TP5p~oGC@WMeqKL-
z6mv+>#MF*GT19{7O01aiQ0Uh$`s_uf@Kwno!LKg#K?`RaSA8+_4(#|fTEU0~mN{X$
zC&_s=@R(fxv%`fbCjahP+WFJsp?jmowP*J3+gQob%}0o9Ca~+ZebMEpPxNA<war9%
zNEGD?+^N?>Hnj-1g8Si|9MOA^SkT{J1rLUvsk-#3asd)Rl<_0<0^B^JF0}SUWoYPH
zK^bn|6u}4E$^2d09M#Ep|5jKAUsC4@X#4iJ<#O?-!0%laut1Q5y_DCbQO4Vbe#iz|
zo0L_{P{`>Y<{=BFi74m@cesLc3Y)4~=jMd9f@aYuIA#w?9Cz2VB(wy=b!8lOOQG}*
z7gvWE@OzjDHZ%wcUaX=#q!>)h%x_YMvK!P-En4N$jSLLFt~ko@XU~2wn`zOiFx<OF
zikwN37_%QWvZ)`fx&YAfJ37stW)iw$rlp6i8YE8yn_UnL2CXRPMtg?&-6bMvD3fjI
zyT#b+Crlh44<}ykv`Ta<PqiM**FH|<!7fzGlyn*uFayHd>wY<m14{!=JKq+{3$+4z
zj}PIlERd(xD6AJ*`gXWO)#!fAxgpT$bIN+t#M^oX_JF!KO<r^dL(-nKG~|Oo9R|`a
zoI}9J8Pi|&h$Wnt2!JP?fBFOSAcjQl$SFYJOy#5KZY%Ydr*8gE9hIUU$s9jVLLufl
zBZ>{eAixtV$jYclw&0SdxZg1>xp&NzScAtv`@U4&=)|4TSv?5T76|oU=~nhEFDi53
zcoM4sl8zq=D`lE0iq?!VZjajDNv$FjsP*W0DPqW3WWkvLzrrfA!X`H-*XrnfLSK&(
zMwS&TLZRHiDQ7Ks#iS&cE^$-9rYze2^ye?{kc1m;kW+mb1e$Kvt~WPer|IFoH)V0^
z`FW%~$*EH|U#b<{8%N7?u0{ZGpZsz05bgrQ2(_^)jYjkcox>!q-Q#4PAZEM|j2_(4
zMc510ad44Yk68(u`E6HxhkGnXO3<m8zanUdRXX80*znH@?&3=&SYBl7qv1DOA{ErR
z*srEX4<AS4%m{ZCGT+<z-K)`J%)g3EQ_EfIGn?@~%YAsr_6_S?$(1Wm+$HU97=W`n
zSDhn;cWY|p(lzW3K7B`;Bb~08d-4&{QAwVeBb%=CLPN4!Y`<#Q4qu`OSTr8nFLp25
z^SC#z_H6UP0tG(!gj^~0g&T{$UCw9X`WVy%zJ#}-eW1fd3F}KSK808YoP8FI=-<*i
z00#JWz21%jwBUA0+F$>`6#_9wmn?9YjiYTouOMP3JHNj{m+tM29@mq~i{{}9&cvyM
zm#H@X2hPXYgWBGn+H?mKHV_?(XZpL<vbhPXP4mP8(~?4CU+ZPIW{D|M!V-*8nC30E
z-n_{n0gB=SS2Fx|eXclt8kBbF3xGi0MQ7tomr?Y3JpaRrDXCL^{`b;9Q68C<l}pDa
zU%30VXobI5g(XmXS64N58QF9bMw&eU4b~Web^FS~gi%wwqA<B&#`7pX^)lZi>LmzW
z#x|W4>qW`o44@I)pAO@XhMp}A*_TgZ4BL$oRhR#~^W@$tqL{p_XhcBCS!`Kxe?_Jy
zKx4u9r1-{p3&G}<FDtSA(ZISC17VoRdT3_0XI94Wu&;Rg7e`C71$)AwCCk4<RsP{d
zhx4W$-TUWn$T6t_P{Fd9onm!Z!vONO0N&PUi-4|ScXEJ8?jylLDL4OOqt6sb8-QZ7
zDYdOO4^YPsh7u_dhy7S;ebb`G{wRg6#bN{)Uka%CTp6UheI)%S$v<H5njL80b`pcs
zDzIB@;X$!5RZlV18l54%Mt$2g+qM|s;qGnQKh7W{rM1BqYZ|XLvUi8fg(9I{^|gr#
z;`>3q_@MafRqNzZQsja<jO6D2+?<@-#P%yv;io|+dzts#Fv+M4o^K&xegM;kY28|p
zg{=ud-i4XT!N=k_E>-Bv8&g}$KKR2bNshMk?Op|2>0j&Iu@YK#`b1e~SUp(_4>=GK
zA5Z~FP5KjgRQN^(b0oz^&VYh#?6o4x>FwKjKH56WrA_PoSYOsK#APv8!Qko<5{i?h
z6^&=-YLg81W)3c@24ouTDc2YV(?a0)(&$9nvmEfB&k$S{B3ETSRm+S<jVRV^bbZuO
zmi=He{#;2DEkD7Sahf9|q$@bptC}_Sp15{TT80;Fa(Ln{-TLswTLe7cRLC{*wDz1K
zd`XLf;#{5Q^u<vSdd8?QPKMCG^~|%G9WVc@GHhL&JwR=2HYkKJHj05K2-(H;5c->b
z5IC`Rqy5~bUX5fDPMV3vEsT}^+3{-04-L_23o+VI9!vYv#!-H+5_3|(0!o?TdpqFA
z=F7Ir{BDcz2||m0e#q=s?w@rSo}P!?`t8)<yH(S0a>xEnl$tFPdVSsF4m%#`iVf+O
z_uU(~DYUe^Z)4E|G>;`~c^L|M4t4qc`0g|Uk5|y*FGiUZfuB2@?0`{1KfG5<K4<#7
zig<Z51l<m`Q$c+cW-<))xrUmH{MK%J35v}L<}yX^^z6O7KDhX+*xxSMgidUl^}n6%
zx0@Z-mMb+n4Y79flv7jCE$I{iU#n7J&9lsSM`<6K7&cCo;}Jh=Iy>)%FQqE~YcpZ}
zKeD1JFqR%~oE87G!}kqkJSrYwMSXs}Z}<W-GO93#zgo2nXQpBl=HSz5@2Z$V|C?co
z13sC6_Tuhd$~x>SHnH2Uoh8~%Je4&&ZFS#aj`I1v4{?<_7xK&QHlP*tx_K*V+yLWH
ztFvB^R|LQJ=Z|dZuWd|qM+j^G*5VyY3L}bCW35(&sjn~DJA^hJCXViFc-SjuGJ3cx
zeYlRR86@h|#7~tISUcERs6B@q!K-t%64km=?cXE=XksD#-uUXVhU`c4Gb|?gwp{=x
z9*kCb2Rs~)agY`T=JMICe}v+t(N?j|;=xbpglQ7;kltS(ZWcM}@TIWu@?t$%nO0@L
z!U-#cD>&==l+KXZG%beU`*N!9tpo&UFX6b8j8|+YtmsI;OO`5_7AyKQe?#^m0!GM(
zEt!EljFUfl;4$3UhhmSg$>#3b#9dX=vxRZ!QlL;qwmC;!s6DFZH|Mmg?uR9R&(~zr
z)~<2AgipvP&dA*=>3w(~MFQjG!oG7xUoq&ua-8q2M_z#vd(!u<969N(kzVYRW@L|p
zV8Ep)<J@joKsK0^B~WwWfS{FgLx&e?DmOK<iCSLf(PWO-XcjrvSZN&imGVP)*P2F<
zmUs(A(>nP>bRedaJ*p$U0LDo`SMy+IDSbeQt1CgP1_I>Z=@(=!bM4Wj0fE7f^-M22
zINpie1^S4ezW_V&gH#dPnlO7^@_kX%)GhN~eKrRTvt#WG9Ix@3xOawY)2x>&*fL)h
zDMLXg`Qv!uUrW7z8>CwAK;Da+Tdlnl0B2BAyvLH4O`>DQ+3(PM4FT$vGZth6H&{Jo
z81ltey~+}PC8?1}c2u-`2OjaWUegbzXrtG%GhXxD(z~&<{Pz84iSOzIZQZNtm8mM7
zcxC+g+p_;-b|BhQpb=(lBgdx2IP?w{5DYjNIw{AH0~Xh;A*~~l-O&JjY3Ikb(}I(H
z7@_N9gs;UCNw`pKYrea3&8h>g_xO2U-}L3pk8u*U5>tU{+LLsH7>(w^87C)*r0HD|
z3u?T6bveVXGVe2^DM^gdXSy_o`xRN<BL|IKu=pp=XoJpvNzF&2YnHfB`>jl+^&PZv
z!ebw|mTY7x#%~uR7>_=ge=dz~e-o|ee>`xg%=;!R9@M020{Qhh-u2DN$<Hr@a>=B&
zv2=R)I-goxz4667H8QNMF_9Pw9fc%pt&ys~d;Bd|m<Nl|rz4LSB2D#@;GHQ5|Gdf#
zL{**-G1?#i`dN$q0$uMIRx+3X)S-J^x}qa=a5h(^ILKfW*k5QZ9mT5mqKrGIqG4l?
z(-Dk!^d=$edM20hWKmyZ5R&VIk-ES2j|sfMYY{y9mU@e%(M(0ts43Ritzp9qdxu%v
zHF8Q&LNZgul$f%_cD}6bWWc8Si~9-+UXZn;_6&gHEY*hSHU8OcQdNEK_zxww74PRq
zofR?n!v~PTGt%H(d`-QoWKoNVOSS+Xam-PR$@PW9dkZpOtek<j%VI`dN~6}_FZ1ec
zGxx_3PH58Uw7>a3!D)7e{^%u@Mz9H4==*xiu9GFqyJ7_z!_+KdW{z#2p&pu8nOk~e
z{%?f`U~eh^$pXv&cORA6bm%~Q9T&v_1=gqK`IY9jBK(3W#X%yd<0$nGGq*i(q<eZ_
zzEc*OXeZM8%d{%s=5lm#R18{AWqjSS!A|j3l#J1`R6ECx-Ib_m=v}sfvaS|U<oEpQ
z&AhJ`$#<2%tRcGo?8bkAy8C|x+X7g^)R0dpM)PTDWs|uh#g8|G6De1p10bZDABH@V
z>XWbz6&%T#uSSb8GE}S}s&PMB9FAtwBp1vwERnKjWvdEc9NE-=0b=ATWm*32g9ODP
zP2-zw)MnuN5C$^pU@}(G`g%B;JjTGfLb$Ga&HjRbIhYcWFSVif$WR4jZeSjXoJF+P
zCTyZ7$r|KjT@H#=hC5aw%4TVoESoo=ZOK?UlQB!{Yz)dP!IJqz;vH3_tcCVb{Y=B_
zYvKv&+_nWitk2cQV}iUun80Nub8~``D-MqL@})cSHaFyK?Y}p2{66BOeHzFvDJ@B@
zxikx1vqVsw<;qTl5pv6g`yjA$%e;rrtukbvpH$#(P`F`-+PxFqBfyRlT^l65$(ht_
z{2H7tQKdn}C-dUh*0vOMo7&Q1D9!Zhv8)FBmFTpQ90PmoYJ!b6sZ{e@{Ig&jYNQ$5
z0m9J$wAv*%XCL&Wp1Fy4w5or!$89h8rX)d_WH*0eJh?(9FZ=P^6ORg<Rf4$r=uI#J
z!Wk#sA{4w$Pv}&P9tq?G-ut<s<eHKZ-7oX|%ntlxY4MZig$;2n%beNwZiEgv==^@;
zIm@_IxbTXcs)s*C$}H^5*OmeNb^_tsGbK}#ns<}!gn6uq2b!x*0PG3f%j$GM#8W3{
zPC`qUEBi9Ce@`V+svYFcK%pjh<ay`k0S;iM>dIgu09d_jUSb^O%8eKtm|igMT;SB4
z$waKQNOGD6es5w1OCgi5A2ZOMeCiY&ZZnP^7^_B$S473U`)wE?zJpna&B#X^$4ZA$
zgysMJV`EXhm{ml4^PGs`?WB#z{6t?f^63%Q237oP{J{$cMEUurO*edv9?lhuklifY
zJnQ*5r?s%THHr6^T!Zgo{VYk6#a|gp5XYS{e?1K#a_quM+1V|n%P~2O<Tpm6DR|06
z1sqi>ICDLi^9jbB>Ji<MbuA<DX|0qt4mWQmBq*Wh7TtcLOVq>`_S{=wIE-AbB2b*M
zHcYLF7du6fCFN2LbR8@dp|WNmUXiw>IJ~-snYc-I&n{k%#nwvvwY52_XX_bhp^<*T
za;bDiGH6v<q4*z>u+bOMgk34M17N@>^S>r6$Ih{iL!Lj{borN5c-$HI>&fu(8|MnA
zUGjWZy>u1=)A`3vd;<S{s(r_$vvqa>yyIR2{aQ1Rbxp*}I3XdjzB>OMuPw8GXJ^7x
zvxKqv^R0>h9eMVoiQaBa;QmwF^t9}dCJK-m-BHjjfinT6tEwcvDB$1V`74-rZqIfh
zV_5gVx1TevO~e=ou-yce8aMF3haZJux1a-)%UxA4Rjb46c`y|H!y&#Aw~EfGDJlxI
zXBJfv8nw_n=q5+pskf6lZk|l!2@$Y;EL`{_AoSul%~2(rC9k%0^_ZkZyWHz1;-@k`
zh2`^~<ExSv@m-=W<_L{+U2|Exv@e_}6ismN<ez))a;Y<!3beM#@X)n%9;2O=pCe>v
zOrz!%<VTrJ53zC!Tat-ol{%S#1$5m$RQ)~7hiH+h#eKJ`LUo_eU-i}s_Dbi9D1c0e
zpOr~nd$;|@lFnz0>-N3bcYBTcixBR+&%hno^L{_|j~VOf%TqdyYOt3<HemS=70gz9
zZDAWjJ5lJ}t2UPH*e7;>_fFv|$%PHJwD!O_;i77Gejx+j(-PCNjgsD!!zB^>!0Qwd
z=;g)|-zRY4?Bwp@;h}G}a;}G8jj(^*s2^LE+kDs6`mB;3sO12z!Bjhldnu{(O>g_l
zZEmMyS;7OZUh&KR-Z8vQ$OL8~ZP5BW@y_XJ&*@RmH=kewS0s4>uD|8SWF7}Ec_J?$
z{TG}9bA0h(+~C<5Kkq+*v}k%-i!H5?jej*H@Q%ew*eIwkP3$_lOUm>ZVUVD6=BF@H
z|7|=@8nFyhj!bh$OzfJvf)>g|WqyB>%TFxr2jSl$P!t17P~uByMp`Q4hGT0LmNeO+
z#LKfb<$9a&90jQsk;tEyDrEo2%iU^i8vjV}MSUtQ?X*B!zi+nsIeU9{d_BZjJCOLd
zCCd0a_C*BiBjJM6XN(RUfy$A!yv|GF%&}S3(IiZQEUtn62M)e|#=JnXoLX;5I-!~?
zPZgtkFVvX|h6Lq$MwIdX^+c)vc7V?!zNZV6{T?7Y;cPd_Q4$li;!>Lh*Kd|ixqMWk
zTyqa!piY;TV;)xb<R#2b`dS5&k+`z#udP3D@b9vX9sD-SM}t98!+-O|X~9IZN-zJw
zsG_`L#tTgQKh8~`y#ko&9$&4?s=hfx$GJs89+%6gIvyGwu?2YodMCW^+eV;DgPAU?
z2fDG7ztsvc3;RMmNXvZ6^7+Y%Vv9nyPgoB}m{v>k&reOo=1Yx}8;{U7@4onTb>8<^
zUmhaHkRzqWYy~(A7si0*K7L~28q91ycw+adP3Y}#oSyBV3O}^_E0|_f^hM1S-X?kq
z&UzdHCl4b-*-aLHuS8aV@r8$x=|$Nq97yN2u|Xyxi~LJ$!uUZYDLtb{_}p{N*z&0f
zEIG`zYVbCfGr;YBWa;QccXfL<HVj%_WOzNqu991+D*c{Ps`L~NaW#O%v7ZvR`Po`X
z{BqTZ#1c3IoV@#fM$wy}M*98N5E0dy9BF=isr>1d%toKP^@z?8n`i91QC|~A&}&Z!
z4eEG|q~VUf(h1hw6u>b2iy*Y?9=DC<8TE;+tKQ!KtHKfHERknIob^ptZ`%Dv_aPw}
zm4>sF_u2`-+8xxGBEwf7swNz*7U^|!6Mx?g8PNLYw5t@p!O6=R6i}jlxYIgg8~UBW
zfg5E2TAD@Mh0W^#SHd8w{$+*8uaU4a)C5BctwyhAW*>_vuhFE!&L-)Dq={kTXvv(%
z(~f)c;>U?4Du9t9{LkSo4ca(_P_w&O_B2;%?ocuPq?)+@vBoc!I^6rPd>B9DGBecr
zvJE6PHGO!;aMiXt6tYh(YR6w90D#`^Q29f^fU_t7?<!IZ<Ivb^>(+y3Bi7;%Q^g$M
zjuc&L=~?rk`D@iN@Ap2^Q9Tn~oV=0UP9Sn~08ZhI0oLbkjZt*1`&tWSVYpM*F7l@t
zg?P;~HR7r_1*I2mS^IO`uStrdlO&Zo5nzHF-M`xXr_svKow-11GZ(~kaSW+r({^AR
zu(SK)1kGOH8+83o2#3ax^p_*l60&U?6a8L#a908CD?}5Qzwgfw<Qb};NcLxTA{KpE
zEm{7@JMsFzzY=f&j|q&w7{}x0HX;LvzcQG|^7)0=O-VCo7AG!#Nr?I6;5h7c)y%w=
z<}9|O2MU+AcjhI@A^+M0WWP!}AY0jK0&?KN%u99{?nb<%)b>MPs1p>v%lk<`)=%2s
zcHg=E_jTg*ea-T3PxE~f@H<T)vPmjA=>pqK=B&&wJOoWIxAZey!^}qL$W)k(9oZey
z5{~Nx`HH@ns~4X9A>&aIiD?QCCV{`ai*#5l^7u}iAd~1WqbU6dT!SXcI1Mre1MD5g
zGDuP)$Os>{Exi<Zd_>Sf@gK`iU3$QY*RO`uJ&Uhfz>l`TR2>slon_2%y>)9dnp+y#
z9@+PKtbwU&+MARH$>>k|y7>uVjh(kJmuFx#-`gB#3*JodX_h08$Ipg{Xr0uvi28yl
z8yXs>&ySCeUT2Ox>M#@;0rw!s?ZuD^07GKGs7GUQLJm%0X^`yQbFA$)QZn_j#93Nu
zpI1o!#&{z0BxJrN4{zfZZVP*-CIr_omn&uZBm&S2n7J^8+qdEPESTAa_VEQfKO>-b
zK;R7GD1JFTDoX=OuwXC;zzO(s>d{WJt$ku9Q<Ro3e7m|!+ROukmRmP8oTo?iww*Qq
zez1B2OH0KFiZ^K&J1~&$2hY9sKH@6A@Og%E-tKU|^NIc!QAxt6ma2)nHJ7fCzq90;
zSVJJP|E{jJDaoPn6UBLvx5cNU)Ke^dTI%NRH8&Kn6Bw(yOGSi*Aky1TDDb)EAX)f~
zioO|f{kZLG+??>=fJ^qts;)O=?Xi$;_{qqQvJW>Xv0F!N5ASb#AC&4LI2^SCI>z%-
z{5dOu(XnOo653Ga9<!?FGM>%S=HY2uKbv5uX1=R0nc=gv|4K*k_2-|LwF6hJ@9M~c
zL+}BcaPF^;Wf2Uj#tty~KJjH6kHrp5#gfMOxTD1;?Qj_`rjaeh(wbM)x<AYoHm9jW
z+CUTY#@S{$B0iDQ7;VeF`YKQlN4G<{02_rJANMvEQ=m=i-l`Qg^C_5f@5_qiRJz3z
zK1!Ac?4nhD_qN(3_R0@&oP*Dn{~0QHAb#0$`~cgA18qgXA%M146TI=lnEi{WcJ5GV
zPgj#Vn6E-4J92|7B7G|K$S)Pd%?TWO7gAv9*U3fWZ+cIZwSByyE5BbU5X#WoKczA-
zDCa#lit#d$%|BhoN3beTC+~oZ+^|nZjj1Q6LO@UWw)+T7z}!8;o+kc+#mr`5<5HZc
z;m0QezksIthpumWP|D1TPs>1SZ&W>q@@pdGbmajnYUBo6S>xLn&#+Zy*Mw3-HPwm)
zpxl6_(|X7HE0suf{Tml`%6pvFMnG`4<6Qn0P70ssIpXTTFlt2?7%dnQ{&Q6d*D!b*
z(tJt1X#BtfzqIU32%>HdAbWq4@@-LR_H>mBdQ^87u(J7e#x{IJ3`b9BQfDw<i+K*g
zCLvFGGWEO6KVDsz7tg^v{UZkZ^EGl-0nEr+uO>qc%_f>%%$<y9J)K=?<A}a{fMKV1
zh1?7urqhHaX=}zMNo(d*<{akixDIy{nS8jLkWF<Qi?!0sVVk3QphuMV(;h7;*PiPL
zGkLZxd1|W%;MOH`vLV3577-A7;|q{L|EyOMh2O(N9mi*=;-)v~WP_VflHSM4Z=Zoh
zq7muWP9=tVV;%mXo(!#j{22u}EKVb|aaK0CD_`WMMU|y?In^|rXzP@OW!Zc^%V~3E
z)@5dG?BdVMTnAxA0|P_GfzuHk3YRShN8$C5-H5B}eCwn-*8r5-Y7rTrtnx;MXxb5L
z&9Qy)XU)5Tyg&2d7+`%!NGKiwFa)5cI%{Dt9($n29rCKJPmtu6SV)Jf;S@v-d}hTy
zv6uQ#7d*L&uGI-ejBK0_`0>f#kA>yy#$j6oXo!jpm$PW2>RH_Lk%c?O^B^H}CL{y$
ztfL-ZP<h(p;Vl%X0jnpZGjLfMI#DMhBH0p+MRJ>>qBKhFc}n^HFq45$-j7Y8(K>X-
zaaSS|Q^!_Q!<9s1sE7vPQ}l{V0EP3#0|b#le6EgxE>&gttuED2&heC%SJ?1>h)e!k
zviSe{gHkY%=$F74X5hn>h^}iO*pQAxB#LvKhx2&?rg;Ju=b)MOhsV;)JNRJG5DA~h
zV8{+Xb%W}lj@ow2B1G--dZ)3MnZmHVb?3L9n_{?>nVaH{$BHM7q0>y6Pe6-^`>6E&
z?+j2$0_bLRezjD!nhbJ?Zz%4>KIS1zz#3PLWc`xG4I+;#MZ!2pLy~3zbs4$5A`-y4
zj|u`K`^t2p`p1;>%T+NC%TcSrm|ul7b<_`I&e~&VFbJT0@qUpBeigrkdUeSKsYNq=
z8+C&)y~0gcS*W}CLP!4Se{{5`F?R1EBo?*VWB$tDgN(?dvYg&?0CB2mZVSWRUMjCA
zi_63PAu|r>mNXskH#t2JA?)-0U}V)kGIW-%e$C;GvO*NLQRhT0(2qPRZv~q{eO<AI
z9QK~UF))1k-Hmxb&Q?QER1rbWEPF$aZ(>4ul{0>)7@a3lh1YJvd{pKyQzWcu4CQ|B
z2Jjiu*Ts-C4aYZKT%ob)2yYo5v~3AAK4EGP#S|E5dJV`Z#=jG-@O6EE)Ct?N7#N1^
z?T*oI+I&RaddB>{R!VLg1>e<vs>eMSE60Yok%Ok%O`nl~CvrK~zs}ot;MC)5TiEz2
z5%n6e+U4^P6`^o=8VjOp8Vf29`0sT8Jw^GSOZEU{;GqX13o*Wj&w0txa`UPKfDKd$
zirK*s!bqwn5LQ!y^6qSz&l4N0-tN?amxHlM;JneEYj~dnxKEJh`Wx$TF^r*ULu(j}
zgIn204-O%Rml*A^Ihg}=jjfY^UcM2%jQfJsu3M=!>Hz67ktgEsXUP{*fNg7txH{qQ
z%#Am9W9?r;9n6Zc)mKe$n22~dx(dUN@hmLj`m(CTlQr|<yIu7B!lD?HDhIVly@I;;
z7U8A>`WwKftdt_`$wQFGH%=H3_K2e*HQy4G2&R5icP@rGwv);8#b;4QNm+LIVLmmV
zmR0hxgOzeg-vpxYdR{2(gh*!n96v!H9DH>Bj-!lvFhb>9j%c1aF>{E2&D?B){;hEY
z6&@@<c5Obnu^E&=Zl3*bJ^54<VT<@NGUTeqDpsBNiM*_l(Z1@4I&(N3-b&gpi~=-(
z{6(UxfOk38nE?gAnK;=8VF4at&z7>t4;Pxvj9(wqIb3Vh*ka<M0_WwuaqVm3#kSbk
zhvemsopApC?6Wr|9q3JSebCCthYOM%Cx*PNv4U?Ag$4t2hr#u+!=p6wTw$Z<Z=@ZX
z^1hq>+WCuUc>-`M0$4f{4u#+Ag#L{D*FwHn&=m)KT^e&69>u1gY=YTcbnWtc6qZz)
zMA%)Ar}MfUAuHLqb$@9R|Fx}u%l;B1%vF;4Lw_pA|11M0Z24Jd4(ckuo85{WmlDG{
z&`3G>j{g`+zf6<g_Y2qONc~XFGi~kWKflIWxGK#Db_7YK&MiUOMoXq3cN^X`{k@;b
znM&l+me`ws0*DX2Tfdr&Z{|B_w}n5`j&m?$3V3V&;mo0J09$-*cJ=GsXN_M1(Np3Z
zJwWw`rRM811lX9+?Bw?s8_WE;08qV_v><3@VtCSr%C_Ta$&Ckp6yOh|8<&ISS1TAN
zS?l?$2B&|{WSfjTn9LCsvuDuQX6hk@?f6OJ*#t}POOp6d`vCn-O=oTRXO4J-R`EX`
z&!b|0rkIQuSOaIN#iL;yIw{HV^VXz*WtqX%x8<Qs<xLDso>cwW6k6|3DeUAf48_gP
z`PIneV=NRBc(lvc+-8|5b<)<R_`jq?&fy&GeeE|a4p4@syE-$bZVC3+5`QW2Cr>$G
ziFzL>?h4`N)}9*pOTx8ygG&8~7X!0`7C#m@yhu2dbg25>fn~LR5eg$3`^Ck(g5~w;
zh=2TFI;jH%SXzRxwoi*9PRkU|p{#GlxuUK&0P?kf97U<w#EpQ{H}&k{$4kbX9G9f1
zmck#_ZNf(agYQL#AF`1pLx!tIg{ZQg7{(;H)fT0SlB(o~lU*~KE(j;dF6Z0)6E8jR
zz29jjeRROOFlt8%9z{cLfb>v7dXFvJV*B&)cWrT!sf+fPQHPjKtbIt+vkeC~sYQ7_
ziYot46LSBH13&9Un?#wQ>jMjX4r#DDFuI1X9*;U8F*8{~Xfz^z;_|_r@6yvSUTF?G
z4A+nVa?98qD~9p^zGX}PDI_VqnWg%ZP0l+*)<Xwd&}C+GI$$y^z6MXdOTbc(Is6`w
z!vou=(5&AEK$Voo;(!WNNrWg_{;)nG->dpx1-?bEPEGj4C~*&G`c=Re=W21i+P?6c
zteFRAh~zuPYL1bJ8r>r`N0y(j^z(?0DGYgeX5&iZT`g@Baoq6cV~7}XIB=Pf!aAEv
zHKR&v{T#deK;s>cx>OP`VMzsToQMS22SV-P#@Fg9NE&kadlEiE5jLf0+MFT9M<(HE
zM|oZ(8`VbcMvK~e12(rr6xcv^?_Pr7(g@wWnI;WV2Y>pJWxZfHIK?h4<N1@6{KuOt
zG0R<f3opXjW~tgXViWj%_S+@jabd!$)FF_%npJ?Zoq$0A&ruU<|25`ex{Qw-ito_7
z?{0NCt-4qyQyaSW_&F5IB`L6yi2aN}y>aZqR>w(e^DAK?tN%LN>6>0W1&!!?)4RQU
z&l!zawc7-^tEZ>Za4hm*oX>@?V#HSvsK!i7!a15_N#6bazO*QkV<}y1v~~XDV7GuT
zr+#D!!}@B*2mZKe6^4Aq;|Jk$=-)fI?~$me2yQ5N$hrWs{%`A|@qoJ5UOzm2-`Ag<
z((6e8EBk>+^?O)7MJpUFP7O0hH%teV4{Din=qS>ubC8V7{bQ_Lk$^waE3p@M48zC!
zk5l_?TwqZAz<@OqiMIwwS{4i`y(V39N0X@{;o{!qn2guw*quA%?^<OAgPKK{3<1%E
zB)Apqys8+ve(j9+>{7)gFS%(+oB=65fG)-0^4<e14nn(PY>QDj6R-`9QrONq8!r3|
z#Xjpb?7|LJKTBII8FX8dl=Hu@{2aX|v?BDxVf9|Or;tM09&&s2rUCJ&CQ0+xGA@mz
zHZh~#+T#brk5x%x5K-u{q*7mb)pK^}o40Tctwfm!Hr3TZ%gecph^()ZJzQeg?l}9?
zLR}*5<SbY$R0fMxSX_r)Or}rPEXvze-&cC_*ypev+1k6tl-HGN5o>lt*fOr&N}Ju(
zzdkG+HZc9MkK6B1bYNm(Au{C6D8MtQdC^c|S6NT_xbPcE7)nf4NT<ywJ;bCv>}u~y
zUg6);MYhvh@7z(ruots_bb(-EZD^ZYsl`=JHc=KG69y_!uXw%3MbNr{V<s$YvwowJ
zWaWJsd)>|bnS9+G@!g=un{Jy?1nE-Y77;CJd#_s)^LtDlT1RP@W}vn&SL#eCl19;!
zO4RCCFQ*!tz#`YNfA`(Dq0^X!70QO|$yeWZnZ2#?!|Oa3>pF_*AGK`-#a{9au{5=0
z>|2x<ATT()u<<Jr2|QMLp6V0B8{K4%xpI9@Tl*ix&=^{p`0w-?mlSI`j`^y}ml>*C
zF8k7PJG5>AV31q-jh<7W4iKXb@~OqTL#o-UWr94_eqh7uUHWIZ0ovkp4xi)!Hm`bx
zbtrb;3bLf$xX^NZ%Is@6&(1zEgfL;Va@FF>ZJye8aL7WD&|A5fL9%_Bh9ZPl$Btha
zm4$6MQr8p#KIhj)V^2+1u#3kduX&)SA6eGAPn04Pe)U!QU*GG*{o5@8E)&2Vj*~}~
zo1KIYH-;Om4(wg+bx1ZR-yJ@VTVTv+_I<L;!F*SP)U1<1T})DxaY;oO9B)^m+RWlG
z?Ny^lBbT`vaPfdOTGq_nT#UTW+$NP>nBXWZoUQJvu=BsU0E|lx)!GOR?^^uskg2qc
zcBfFA9cAXKmpDrfk9VLh(8l?yMO8R=8epBdEDwNNIDeHiu)tlZ!!eHlVZeFk#o_9u
zk2d-I)rlWND;a{l8&e7Ph|emId9BZwr^7&<{k}lM65f!0i2b5+&N5t`AYj~rWsG6s
z;7NSVT(ESnzDDuIp~?b(8b|k^=zRYZUVgp?<bb=yQ@;Mxr8`qV9@jIPIEW^6_vqhq
zuir5nEor7AtnyIA%As0~mkua=+_{hrFfZeiF;{fra+)frBaDqbj>X;Cnu2<?t+Kj3
z_HR%54IifuWnS)kUOnwU?6`wh1VvbYsTeD@lCA(xc$>J<yH~^=q&m~ce{Fo%+xHZY
zG<Amph^I&k70T;4R_IM?7fl-Z4kC{8raww=%V8v!JGWuU66W~ASsMohoV4FY!eIl-
zc<TQ@KBx0LxT_*e>7Zg!n}v9oDk<H1(vqnWioDD8W-5FuO%kx-?i_@iFvufr2RB?D
z0BJ5_Nn_Oj%-$ai(&wI=|2TK=&+A3g_t7bd2W_;?^K!XVd(Onscy5lN%#GwP@VSpi
zpdP}7S>9Og&>hbaC`8Lp&xvQ!?j9%aeGDQaP99guR9Y?xtlpm?LV-%H_d+|Us#+?{
zmoa>0c@^-+?G>vCjjphz+|;o-(zy@#OAUO>&YweK=50fXbnBR3Cot!$6fm*8WThU!
zl^zoPj1PRt`~(z=bkr{}@;@dPF9;F0&cJtU-XY*St5e&2T{JL%Pc5M{#+&BaAD2|k
zhN&XtpB4?ov8uw#E0@^SJbb02^n6$lYzV}fq+u6n;TkA0O4tKu5o{_}Fe(I)GncT!
zhcGh1h!sUaa_q6<fL=~#&_M_szdp&#{7&%7RyZei*vhAnqAZ!lB-4er??TDt`ri55
z_=9q#S+lJ&4>Bx+-(!oFx*?l(QRKU#hh9+<^0<ApkSl3*yIE?Q&+<#_!HVyXwfV;3
z+Zb_W1lMX$>3#id?y>gtN=TWNwB^aqCZ>^IWHaFC?$oQ_tsOvH-IgHn9_zsKsr61D
zM|HY?y~xrDlPVD2bJ6u}#XyonRV@EC)^b|ppSFL^@;~RiWch-SCi25eg>`rMy-}hA
zP)Za`75@ABmYH!-j62xzgu!r>>20QzmEkHACfT;fNGyJ~a!JOGWOK>VL_!LrO%((@
z;mpIC`=ZOk$BDxo&)BO(W(woLLRyJ&?zkm`9TRz<=NLh0zT`2$&L*KF{rQ(9OJq>2
z5;DGWAb)(FebF`62IFwk+`9sWdpHIoH{CHPFfMV$EnlN<*57<vSQV?)kdQ(M6*jBm
zWl;9@*>E_NvS=ZCiip3khb@}suRHYmwh*QIW2Eq#K=Buv13`V+m`V&Xal;T|pKU|;
zM&5~ZaImC3tg+IGsYm!kT_9ZI2wo_SVAyIWra|X=aC<{^YqgW9<tIEc{CUp!MgN2P
zn2BFA8oqgA&p$AY44Fy59Z%KYA2gEuw&aHTsCXaeA<sWo1ZetzJs=tiXcDFbaEWaM
z@Um)JZ*?hAyKT2J$?Nn>|JE~{JG?qjWBTW^3mb0ig~cFutuvJ-uoF0(k*C?ss@eYG
zf;uH_J~Hpdw2HZmxe<vyU7*+BNhX*P|MyIlTkQj@8(;SG>#h(8*%I0D-i35q?OQl^
zH{-0?#d>B@PM^;|sDd|cun)*28bUTJQo}UT69T<bY6Sez%H~lyd>K)P`+Q!nWl(-0
z6rd4lH@WfnImI6=I`&#Gyln&EcaT8o`$er5t(~Bg-fP4ZZBTxzV`x#kXzJ0j;oiP+
z<GpU0WLwgUm^mW8k}S}R1Y4erD~BLAoBqKyMkkvkNwv0Z{Yq*b(uVDttnz+4VP2Mc
zXe)0lw$R@QjYh|pxQY+Gx<4|g@asDoozvr@!)=XpnVbG3_#@H7pS+{s8((zymhsF7
za)D^|+k3C2w6y_Y!qhFag_b{<sr}I=A0)M6_Oe%`gj1zBw59SZ1!`ImGn*+!Q=*9}
z_kWKWUG{3v_Z-Jpn>soY*rCH_3zO=&(Hf|m7f{MB4t<<_BmJrxKVi98W$fc*znh50
z$R9jjOjDQcEy(L>+@L8nX}(q7)emGp+8=w1soI~Yn!Kz*z!<qTNIr1-6~F)>)Av64
zAM=)%`1l(*RR7=n8kjQ3<PtBru6)BJ10JXCjw%2wZ8u6s8BJNb3%lL9EHy^hYx%`q
z_{h#x+Sv}rD{&oyrAZ7k6I?&<n`G1f39Lah)JmN?<Oj;7!yRbI1=X?@Xm_1kvt$(n
z6;_DgPMy2=5c%E&QgK?(TBILrM6G0zs}zeWWuX-wylOxZY=>(g^&l5umOzdL$2*@g
z^f)NB2q}P)RYs2sh>ay(Jt*7jIX^m`0_r1LGT$2JN%j|3x(CKWBI0snO6&1*@`y(7
zcq<E%48(o5Ip3!2)_}i@vz!ARsgdn)&hg0EI7f6WNI`o&0#4JG+tNnOJKgpmac-$U
z++izyB$bs8CO(`YS@i@H8*}XAb5YU9pQdr`TF$qHn5yh)RLkB3?q#V7R-QGw7y55<
z+_m?nA^%ogH0+(5E3R#6iY6aQqVx_Da)4dz6GAVjDxum1bp$nuk~Ae(*Mi$(PUkM>
z<tQ9D^bOw3Kfc;K`PBEGh*+p0>E}`NO-)l<s8G}|_Y&m~3xdosZ-u%)PCB&s#rbQ@
z_Z_o3nR{3s5}(kQU*9TdQ88V6x?g*3ZSx@FxLYK&oMX(UYSn%#r#2Ftp6H+Rm`(vK
zqHxhKZt6v<Sm2o*(-0_Rg6O3FXY}p=`O0TUpw;rY><K2nb(01}jy+rQWA=-BqfR#P
z&3}+<%K=Uji#7dFNS4Gfnx$fB&jV~&a_DjSU<!qJx(V?c&XqI+MQ>!*3KY2M`Wv<s
z(w{fA@$+Pe#paZNfz9>~M2)(uJg<ZWwS+t;PTZ?^9FZSrnBCm<vuk|xH{#*|U@RhK
z1NK&*x@M|-Zp@hhmcRa*aZ|p2-bm>U8LQyr>zeubuqmv-777ZXS9|-%zf_#i^u&|g
zC@`D)kjDv6<df?>+2fC{Nj-@i&0RhrG$%P9AIgjkb@jEL3wJE!20M7c8b5ELEoU3_
zn3aG1%J+dS{*T#ZL6H|ao>OPI8%<RU_OhgvH)7!PAy10{o<yCT%Uwd8xMjd1Tm#3v
z{sbp?@O!Gx=v8N&xcx3u2P@Lt5zCqmec=maCQqzaj50Wph-~9qVTIp&e~ZUVR4;hp
z|JJ<PNmSqt<XNUjWfz_eG42}uIKALu@HnKYpjc%R4F~={ko(u7Hq^xB%FNjeUgWts
z+Q#E;?fJQkPDWPW@n-~mk(zGcXzBlKGED=LM7n!@C0^+NH~#dGnaS8ox}N(eoJ4~S
z2gv8~!?`2Th)$7D<K#7}_=>=>(KMF-`6zOt(qL#cS~izCl#XC1;m^J6G(99_4_fbh
zx02;}6k7WO72ublt<(fM#%Xh8v>)Po@AK^hL0PK-R|d`H%?Elw2i|Q3wCc!G0)Qfi
z9^l7Y*Vrtd`$yNtM|@hp6Xlr<$)H&#CAR>r7wo@O6OF;z>)TRxh0K@L%uE?NBk`G4
zL~VHy8WCgBZwa}NZ=^q6^Bxc}2zdsU!Z=(?ZlK2JJ2@j)gO}qwxux+&9XP*VQEKt1
zMU;?0b+d`^i?SVA?YBQLMd}_oI+;f$#0}-YK{tS6?~cW8x;kNWUg4&6KEivQDs3&A
zq1v7AL`)OPd{gscy_2CkyJlrEH)DvvyeDn4qCX!K@elP?ub9tAe%KQ}u74vs^|bSx
z?aWJYruwD1=J_%m$gwy+&&Tit*8L&e3oE(g`2E}WtlJI~b)4PrX}5$%v`ZPbt#1K4
zkLXm$8}_ch^w~lqH`f3-I1&HHw{aTqd-P(e2mj8%w(k8RDt$RQ<(f4n0G#C^ji_CW
z53ddT&7Ql&h~wY643Mt<?0%b;5YO&Z&-sQ={1TR7qGP_dh)4OTWe(3Sw;s<0S98T7
zXX+Gm1OP)<1N`__lxTJzU4elKcac_TIzirz?A#!U2CDvmBQpo?)rUe+B2^EzK__{t
z0vZX(z!;`LAv+J8%-U&gKT)2hl;`I{unk4$mx<Z{1HN79`HWvXJ?L5~TD3K8;Z>h0
zTi;#s1C#m^&iX^n$=u(De$+PUhk`xeX`G%h@$k$)*HT0z%_bP!Ax<T#-_Bvo;>hO@
z;8m)LG&4Eh3amSHeN8w=>F~0|rU5H`uGH7b&F-;&J_P7ThvrR)|1#Z-n7MJPH4)|4
zU>RW*nNs>al1hJS>9LvavnOpep!{QxBb8Ft9h?&ElI44PL%ipl&jaQ2BrG|*Ic=(~
zF$@DD11_`&R=P<V2P#=$B-~r4S%HQbU){NK>e9Vm(+$F&0h(N>3_ETgOXiJoh6p?a
z<B4GPq##Yap9PJ0sNay;$5dvoM$%+5C*W<{l%VB^!WiWu8Ku5bI{B(8)Y9XZtd_FO
z89`siz`wY0Q~)Ey9)!hmk6ljdd|x4;qq`t2j`CMZZbnzr3Db9<bdaz=@?d0p$OC1G
z$&3sqqyKD3#6VoT=F8vM!+DLZuMm1ygo42uu%IUcSbIK)71s>k1?{NsZB#4MCJ6^?
zEmG@9UjVZ77v}|U`{gn5?qK&KGD8{~EKqKL7ao21<6}qQac7|PK#%N8(8rbgE(3rS
zdWqj!|201cEOq^bwK9O0=Fc1WQMlkKoIC*%*bLO{C>Vd0I3Xrgu9Cgwk+O0!_rdN(
z%!6MeOF)a(Ys+OR_UboouMQQ<Fuq$ki?zip<4%@z+;26STwzDBX6o#r56Diyv3=A!
z=g^h^(b+rOY;=La#l0MKY;yYHU}D*w&#*nAUbV@}J`Y`|=tw7c#`3>9^_-;Nib|x{
zE78W~8mcr=87!}fQG76p1pBkW6qruLt2I#%3N9(Hv>z$5D2;<W>qtfP?)zOfR=n63
zsd|DuC>LT84BBfWpxYF0-Q;vMw{m0k7!MaIl3Xg1JTFT%$_I#!k+0*-A6Br~`2{1`
zonTe<$!9JQQy5hPq1F0n>1#hJ5w_YSF~}Z{L-yKkIb-6`H@8{n+X|CP{rM_chc_~x
zA4!UfQ);wIsm(7r)!ec8eecdD<wN!kBdOOd+-=cjmR&Iygl5}0LbkWL6j<J?wg;gi
z?Cr6`UAabac({}MKN@~^p+*kmii;I!uBq#Y3+0XPBN1!y#a|H;BHoWK5IRCg=<R7j
z{ljeEm%=W<7n=;BINJ6W-0sKAV+JAHKjB<md#yuK{hU*;*&uz)l`O|>7mZ}sHb_2n
zbS+?{SI2K8ALSlE1zPhGZ)(5J^jR*OJpbYd&|wgb&!Xx_a&kAzn~5BDgo85mWBYQG
z8OzviBN7s6oge$*e6qWhgn%619!@k5At8~ZHo^$GpO6PY13SVJo{$Y<aE*#gvKi+X
zc<a~H(R7UTdQ;c>5^53IuMXt@+Jv&63telao*yfaAEFpJ9Gf=O8MAiyz*Y&z-6x;c
z;K^@}YN5e_fx$|R=S^x*Kzju3j`saWBE#Z-09&~-7xj&c267d0uTJuRt}wCT;uQd3
zRYsZ)0RVSja9)}=Mc-z+{_`NK6{d@f3SLlF!f6X(40&vkv@lK{$!B0RY33DNgFZ02
zXX8zJXssNy!>9E=f6xY;j4Oem&p^z1z^16JaT)33lRQ~IvjGn_7he8Z+8;_?jSvHO
z>^dRi7}M+Oijv-_jANY9ckLRrX}4jqVhZUtJC$6UhhKd-)+e^9=&tu6s8CP5og2Ym
zsw_ElE#t$jQEknRc5J{<TJISX`RQy-<U>rtzdn#p=xXNWMo^#Y9|=vT9j29wNF`pG
zC(Lsein?^_3<*B*bZ6sm{t8#wz7(7dAy|f9(x<h`L^i2NOyUO3%tfDc!ggFAyuM=;
z^*!e1b?}t#wo>>jjyv-UZkBNO{CGqcwHD>AJSIHQL<dO8SjM)fn(OCTWG46?;KJ^f
zobyW%_4&inPdf|uz|q^4ShLPVVGNWvHw}dXHZngI_qe5vi=7?H2oe^J`VRhLFfoBl
zJcXjcG1=N-TJDK!$yjSrPA$m&S8FxgoUvm&96GC9?|)&qYAMqnC8V->g0Q+Cy^&XY
z5JAu9>chkK<|~Vc#;31Yz@C^P{th-Sdc+i&6J-mB1gPUh05e#qltI_%mJ$>u5hi;@
zUM+~_1Z|xCM@m=k<RD?Ep-Um@9=|I1{ol0h@eilqH=?;t$b+x+f<|fdiSlk#WJk;`
zT`;tPt!Ssd0fM*+N-7^a^^d=ITp(moLraxQ$|wQO*wtOa5v4S-;3e(a4_zTk_<4`u
z!WWPF9Ev>t`_pZjJP^(4T6P=KkjKY9^$(f;d+l|m^WsXG?A1OZ3%bE8$p!`FJ6;1Q
zwe4h&vx6~vK-!tzUy+Pv%PvYoH*jrnC4b*?fO_%$eUUnVnSEa@o^$UEAAvjph@j7v
zr}>Hwzm9at!3V?9c^Vq2ZT4NB)Tsxq=AFs%j@B^gxLznJ*P(l1meK_C=@?d+54Y2z
zF%j${{7#bASQgB2@vwnxUebG-RIU85?6a=`P3Pq2svhD_+X4L~=y1jN#uz!4=m!>>
z6Ar|B&P9Oya_IA5k}Q>aP!n%q4OE)V-I4tC*$OUu^#ktO0}<hg;?`jix*3Y}j^*PH
z=h$Ar37Ov>amG*i)8~wdD1T(9wJ$4bV#RLgMP`U;cjUEDT?74(rp#MblDooJ@#tG4
zH=~6kyW+OC1em@A6s#Tv-xhu!89zrt|9B5uS43!&oG;>tvEhq)rBVe{zuKnmv!tgn
zlR=!AAo+a@quZD2a#PRBfL(3IZW&Top&PUs?XaH6M<s_JZ|v=WZ`jSjR4XuVp!c(?
z6{FIc5h;AE&^nLGsbe}yOB*(_kMGElzBXq|7=CG-OYjSWl!NgmH+Rc%G?|@FOfmyX
zbHODF%D7uJpM5xMfqx5?h_8?wJ8$?rn8g0KXKf-9>I^Q8m~{e>>QF}0L^B)##ScB=
zS+`}K4DL;5XLxe5!&`<K>u5gIsrHzTV~ItfV9?Vl-b|+4c6>}_CBj~Jq|3tv7Hh$K
z1F4H0o_Rf^KDF|&&n)qJ?6LM?{Wz=z2evXT&jjeP?i+&$0tQfw<@*PH=edO4fM(Ce
z^=+lNgkSGKflwi<R9(<=Y#a{iI99nxw$-Dq#ieBq8Ww5p?~lnvy@2Tn4@;`Wy^Kws
z+gn8ce@Fp-0v`0guyE@{V3g-byJ|awRw5hJZsZi$Vp1hfF2ple;YI@CQH${~m)+HL
z%Pyaa@qrN1Y?nUlxLT>Uwl>%*&n+2TICuW`%yvwgVr+YOdVmF{&GPlC(8e2I;p7?O
z!usT{s%K|&!7gr_{rEdcc<~1x*A73+&IrD3aijR`(B!R6g<`C3+`1fy@{xx~`87C2
za^ytJ#2MzqxrIekn-Vb1wk1<6<DU6YoQEB4f16r+^Yg9eU&GlX%d3p$@}aN+>yn?y
z#0I-}&km{sgF8zxa-hnp49T?<*ZfkJWQZ5d-*nRZ`gzQBlzi50Ea7)*jXEw#X{fYO
zTfDf!P-*z%AI;F?Y~kJqJ|m+gx}_;;)~Z|lvZ=sRDxomKDm2o!9oQv_U08rKKJ-S9
z$J#h<_Qk1mFoPyO|2kUHU0!X<Tb#wt3ujQgu>jHJe%#z~BwI(_nk*$d=^;#UGU|U=
z<|uBGAMkFQ;J?HCE!}oLYlCuPfW8*!@v0teNoR!DBoZ_4bdrqt1hVC4Lb5+k{sbNK
zP175At?nRp4^T{M%gxg^ubzwf0qT4C9gzaLMtxU*IS4lielT(gtVkMFQ1>&8ad{yb
z;79hq)GZa5Ep>;t7uCk58PvCQG#tC-<N`DA?4KN4_>KGLfBiXNPJJg6)fWb%C<a|)
zDd<b?{@o?qvpLOla-vz2ZJuS@gk+?ioM!JLwT_IQuZ(hfie3mz|9T#9yP~V)9CsiS
z#TNmiAuiH;Pn*9{33-?q_<SaKT<Y$qxcRAg-7RS(gHpuK7+#zrzTS6j<cAL^I`)30
zLw!ic9ZD^5ewWBpP4AE1s_qCOIFVrbPu+c@3_Y5edSeniLb2`@%hDpG)Oi}}^yW{|
zx4*A!LjCsb;|YYnp+*xq2Eqi-zP4||mGdQIuu>Z!s#tfZQ}{m@%}SC$et>8CT|s<3
zo&GElJC7>0VD?iyk$q#%%s|=YVQwl!t4j3nn17|?spfGS8tWIEVS671aoKF(GX&tS
z{5gn0b73=;k&~l#>QsMK{M<(#*8L2!{hhnm<q`eigm&OJXbW?%n~!)3^_Q@a9r35g
z(hA`B>X63~Gu8F@-QXHHC18Ch_G7v1SB<1<|Asp4!97r{Ab(v>GEBA^t4&=Icf4o0
zJT`M0dBGSRSe0InPh9lE+c?paPoy5eU4?hqNVK$t{&{{tp7OF{&;Ai)!0U`lzOXy^
zJGQ{r9j-d?jMAsqa-LqKXVr)>aa4OFQu544nS2IJ;CFpaQCYO?91D)_3?}TDt&MaQ
zj2r7xDBQ!`YQ$ot-uq~p33omD7Qr61QJ+uCDIeLf@n`4ru$U$Z|18Y*fg^fM{6^JU
z#}`j!#Qnp-zR78HP_?Q;M9k*0Z&$yH6WN_SnzLTid~G8KwFhj@EuiO4<Q$SvlFB{#
zk*M;_GtT4|Vr=?@HR2M)Xfd~Y{^$Q<?5%?03cEGorfJ;WJ-EBOB{(F(-3h_n8+Qu?
z32q^{1$T#Fjk~+M+uz^R`K#t)&YZdEi@xZt+Pn6C*ILhdq~2?kg+8%N+XU%`azQoF
zvk>-NpP~1ccAm8_+Vr%~Lg`=1p6$-7%~p{&YSQU|-lb6<v5XO8uSVYwyv#J}%QQRw
z|LHCSWiS4#yQsjeS-xWOrVG2w;HSZz^5A@*O-;+g^yg3Mb`MkUK4ezsmaCV-T9IcA
z1>QXP!3c%1zrE1@{;kzy6az58h#!qud}C`8GVFb5PMR$vq?o;iayQ|SA&lkkP_SUV
z<eotBR9sDiUDa##2$6D0G$wI=%{ai-IBhBbGA4Gln7E)Lf6{8JovG7zBL^=m$X<$@
zivabIK{^uuQTZV|8G5+V)6zcTLMMF-Qp7;39PsQ2LXvJ67V*Y1^SH3u$SKv`;|GoC
zWrpkQz(#Z~Bp7V9^%}bix2sbQ_IH?51DL<t@Lb194{yt|-z({l?jx<-o3wkY7Z4`-
zM8Z(cjY1~Ur83vK8}@%g$8xDCjF(|(9Q=QgWB$8U*T#qclnx}?VH!}jA9Oo5|6EOV
z#dq8mM&~<4LEz?Prp==e1z4qY{&={IQ1%!Fu#3seIhtC;$(@Gg&?M-m%b#TU3>C3D
zx?hLismSr#-*y`i<c=`>o@d-$lk;W{onhPk`BB`P%}C-;@oO@iH9Pwky8|+kL6S}%
zgw;TiZ;fw3xAmec3`$+obHO<V=skK%y{oF7z4mKJ6a5~LsVym^H@dAdl7}6-P!hRR
zpJxpAg4ry|tLQL*Us7T^|Ft{v-{jw`F<~bjz1z+`CXHO!e^F9&G41?bn;zz(5rwgb
z{O$=@lvTIOikOf$6I%eHLJQ$k%WP7W$f0`TTt3GU>o2G-)7%f<jFI(C*n}e1BqHG`
zoeu!0I}ZYL(vThN_OXw!_Uh&(M|l4#(8`>&y}hEzH!wct#OXOl%))$+wLC=+lhhxo
zFgcMTUhd}ni;li^I?{e{!EMS_VC67KDC)x;S<#Nmwa8Q3EV3JoU5Z<RfeaZh$Ih)X
zb&dl5jRLd>IMsRSZXm{+89$icrdUfJ9&dHq22x4H^H56&CuzT@0dGX*)+|GgSXVb*
zrH(!iBdd-8bO+bFANmB=1PP>!La=@_oAdLB+6KIrvVC{psP*`bA5_F9k@NTM8Ev@7
z3=>LZ;LH^rl!czhDnjd~Rh?eld%ITlGqBO2808<fd@-3PjJtgw<k~vrNfD1+5-=*g
zMB3sJyU#XUq(VVV&7@I_3R#CVnh(LXdao6}lt<M0W~YRnW04AB4sQ?FXdf)+y1N>v
zCEh7ptV%d?8n&Cz&^qF}jb7FdNMiEmuT-P1);H<`R=THN+@-;L(ow#wC@1z5BHft!
zhV1$(mBQuKB}@+kKfZ-JG%@a~vt0xZvaDzR7|qqTmPz0{<DLB+=PpNwae>Bu>Ubqm
zv)8D$CF;QRS*GS8S(;5x&r94J-C*CS&-VS5i(+ND_m2J@1IlXOT2_dPu-cLGOp$9P
z{U6$*jlusot;K)RI>HBvlL4Uupr>ky6@W!V-QX@nf<%0qEKX+S<2-fkxL*@rR#l?3
z1HV7%3}Z{!UbENn<#UDY4DIM~%PVx3|67kY)nB`1t&&EPV$XcXnuS+aBrc;y-22n{
zBot@;eEa0zHT5d6sMKyW_6Fqs2(nf_cHOtq0%yyf9G@pH6=Evu%#ug+EMtdEn*|ps
z*ie$l+ow7!3<NnBk*rm2($h$^{-+x%l?T6#RXq_prBS2Oa7?V2fcCPu8fu?bgnqBH
zibZLV9gt8A>U9Rd8g!5%$0Rfe5%e|+S5((yY{eS2f!%Z9(uEtn$YIW|3B00q)jFP$
z=Jw_<S4%1G#;MvKTSpFV_7Ym}_*p)yz1bH;jMZXPs<AIIgv7_Y7qrsEU>Yr-{gyPZ
z&^^wV{lgul;EN<Y{~lD*`uX7s3=kC)in){sOpF@&v!oc4-5wEYn`0J*^|RAx!j!w<
z1XWxpd}6!b=#_YXz=!kXQ}^d#6aKF<mDTL}3k>?guovFo2=>sdP#a`O&c@mfT}re%
zC_4cl%3T-eriiE#wJnW<b8vhr<IxujPI^{XpsvG_{%(Um!pu2Ze#yII9T<(3J9tMU
zK|wE}*YvJw1xmb2nr%&GntA@W@*EE}XmaX3SbbCRTrwJ1cy#f6Kc$NKt7WV>ZtUcY
z{r<Agsx;<6Eo;(hjR&KP<)fQ~2vLo`S+tf19n?+6V+bQhkBv;U@`0WnAFt&wPVPvz
z`0c6daSNKXr4REQ!aTK6CYIfWF&5xdJusH4^n>_^o||Hqhbk*gJOrclw+{GaU$m3U
zvpLpZIQtrPWr$#w;&jF07ObW}vY!U|`@Gh@4}Q}-@=HO?R0B6$Q6ULe5uCz8@hG4W
z{L|zTu^dNN<HEwDXp61{W9pW`{<3|8RZTrlc)xJ;!txUAx{b4OTXPe>R8s)3_xuHW
z67igDUQEu{26_6rbz$*yRftzq5^oOy1U28ylXQQ*6O<zyxLWldLMGPK*r6vW<j^7Q
zAN5S9j0E$4R|<A<%R)OUtI}3;tI#epDEQcdWUxKR^P2SQ&hhpMhP$yOS$EP4!(KoE
z+^}pH!*mQ@?)_N);!+Y(szL&XAV*)P%gD|5t@P{H<VL1{7IG>UGeuH)Lw^cncV>+`
zzNpUI5kJpczc#s=trOFd8-VR+Mjy&<OJm$`f7mZtm(&zCW=!8Vo;h?FEw$xBIni*M
z1T;7B1~INh)L)08JIG8O7;mpItXv1`=6_lVy`QuOVCBK4)k*v2v0UG%qNRkQ6+%sa
z6i@`NP0~|K=w+%eyc7_M@yFc<^v>&lev1uw^%zwh-^hTDzPK(khfXI%=9ix_59GvY
zo;#i$QYSYp%p0rTf_6(}eOu3D7=?nO&pU$s75>?!yFD1t3baUl<iNh}Db6wRcgMLd
z!GCxfych^q$Q>_uSY59c;*LJH{o2R)^)ITS6qGVNet&(tELn_9CvO&H3jdxN!$a^r
zKK~a~T{>pO;pc#?1x>0kqk$!Kp~rH@O|bZ|wR1+dHQfjmJA#E3m$lcKX|yi6x2`~j
zPj1p+a#vbt<DpU-(k8g2Uomutv!J8fx61BdY{M8BtAWx(qe=(78QtNU`^T5;ryj!C
z?BRZIQr$_GWd|eE)+U!qc<5~fWBdL6Zk4u=i#%D6-OTzg0)@VN*H0T6aJDJvKpD9|
ztaA-hX9ec$80pAhF^0yVFyTA8V<S5QhH}i-tGIryc6JY4=%Y92pdFbHLl&%gs__NG
zooeBlOKw2^a!!$q(7K}gpY?1_sE+>g3!NqY9OH6oVhQ{)l*4QIKHUM#s<<2P0E}U{
z$QA#+41`814oCbzU$8qe90W4Iv+#-$cK=E4H-$+jr8(uk@|reRzn5X@b+&h_+Ntgx
zNJ!!9V9UQ8KwPu9?8w#K6jfK3{lk*4R(e5&w|!Pt(qZK*3w?CkU{#x*@rA2;&kSWI
z&`eM63rO#6<erKnJRM*n$vR9nA#QIWc;bzVg#Ylx9^}KI1X+)6z$gQof8d96mpS_B
zWT|M?pE3Q1yM9K(>!TaeP4i*jID`9k;IEbsTVlSoAdAiVB@Os1fQav72j#(QyB@G_
z_pn9?A{7J>KAymCf`Q4k)d3$r;mnt}p7-)DpIa_*il3nNSdDMwBy~w?E#9ys%*Sfz
zHCXfMs)YGyr#MyHq3>@2`2|_`4=(TQ4RoCYw|Z?xE2AO?0=Ebv%bVv1auY@VO(#T!
z`yG<rq5}sLy#8|(&tnINXT^X2M-_*-7qka_-)a5mu7)Ur1r$eu(S5Ge)!~e87J99=
z{Qh>SIPc2EC)C)C?_wkUV3!Qpjq#O3i!JIE{9=d_OV+s_8#j*F(n51^YA36wN4Uum
zkaq90kxy75W6jHW*(@<Bm^Ds?HDT<+95?&ZuDs&Z#LO@C@bOu*aMHW|;5FdJkZ>6)
z3UadUKxjVByk{0Rm7K5Q7cGx@Gq#CPTzP#3dcXRM{&xMTDhsZR090UQExnweKr(Q1
zD_ng}tAz+(bwm@?3dp-^v^E8i6gP&EA$-WA<MubP${S?JL$9oO3k2eWOf=X2SFiZ^
z{9JB=o7z+ZQtJQaf?<$n#NT^Itgj2PI-j5o<M`G9UBcZ>!F5k7AqiQJ?W?`(v&$d6
z`5LLq+v|YUu2ElPAKVB%xdEr$UJnS~P=WVxm3BtfU_BmvRGy^1=e{!P-NU51u1uhM
z_4)X@3HNw7_cs_BpC_lYTLMg{59%$$?#0DWPl?TJ#HZ+_>MzLJau@|Of{+mg`^Q+>
zl@@oLx@bM^34x8ntS*%E0B~Xl<x>=tiljYIUn1J)jxuIua0}=2r%TI|-UEBcQZldr
zFRMUR0c@BLKr^pM<`oqa`?D21aV*U-6=yw<*wRW(c(#}DvD|d8tn4I*Yi^|~KRW0E
z!9i`R@Qd$lfKmSr51jQsB3GU}dbj$*8yj(*c9*&l?T;D~{PIs<fPX6pg7@Vvqs8@Q
zGMHm4RNpku&-Gd@z7r4J`nNJ&6(J;^nV=f^lk~<g2%U_p?d>JpJtwR!cioM#GxSVs
z?tQ~2AwqtO|MKq7&E>-av@!%YIKJo*dd*VEC|WW1BvQWE^S33ZXB|E1Dir)M>>VFR
z-y>A_i&tOAP+@XziF!H12%B8&4#$@Af6$)W%>|9=(V|o#>|*!tD*+E5@bB)h7golo
z`hDo#j#kBA(KVk?*`ooks2*!HCoNDRFyL55CqNg-;{ftx-w7Gp1xpJSw{@}<d7gju
z9D;SA7t$Pdbw?CY0;^nbkD~<K!?{8gwccJi;t-v{g0|?fepxY=ZvOcT^4gw*eRmIV
zPA@u0$~O(lig(HJkF41J`6TVlgzRee6o~|}UJ+kdCHIsf*JgcbQ$5ei+}HDZNcg<F
zz%KXXY5qS8!E+@ge7+&<A9;A!+h^+$8OVG}=DRif`yY@)<TG?&v-A*E`XN{Xu$wXa
z(+$noPDF1vB*>ox2r)u#ZyWQfs?bE+S*;zmk1czXy`k3ELl7otM#aCM3ZhdkVL(@r
z?B9T_TtGW?N5v{9y4vUc9mA*9W~UbJ4e?{B&T`-FRP2A=#OI<^V!fEtSXWkwV||2D
zA!qf}c@hdumGc7p>|3_u+vnR8t-@(p@SM3yfd3ub0oqYL0!=<IcjE#>u2?tJ*a7{o
zcCa-C>0nXLYYecOLi8t5p&81<(*X6JmV4qC^>syG5O`lUcJfOFA3_!5*M%=UJHId<
zzhU$vAlJN~Y8XVUzMZgZn}ZJZmMu<ngf~yU@d|Ko9{P6;Z$h~k2JN|eZa#>0G=wb9
z0;3}GrIGqN{V-OOX;|*xf)-AwJM?dI=lH@#C_2LPRD^@{=Bs&yV^tl>P5s+7*yjbE
z(W~C~$XpSSt5@Do`VTE(ymNb_*LJjqiZq(i55rg?VFdEh7paW=>n(Bp>9i{bBe}Q-
z{aqxT18NQcvpJuk@`>%FW9BryysmBr2ouNmF$I$!TDAjLdrn&F`2h6_CX)g@QQV;_
z-v_oQYKsLcv7V<D)Q+?fQ;P{T;Um%E=ufdzh5f5Awhy$<hrJE~<WLqu;BmkUF8Ak=
zh_9zZms{J_e=-c?LZg08b_o-fT;j!Klk|{OU4GpzB1{o~MZ8vIRN9o4d3w6+UiM8W
z`Ws0?;TK7S3}J3&n&ROpFD2(QtaN%;)jmI&0iMyVd~`Gd8p>Ukr6ef-R%d8=_;*Eq
zqa3qog}WyFqGR6qh@kn~3aWVqkMY1ckuW+9mc@kV)p?oRyXX5jg4jE~kg`nZ%WJ&k
z#_DrdIFVcHLGNeE->-ijXq}e_QLy6v6U-h^)eLw=fr+<!|6w4{@}8ObA01UzTgPP^
zqC7+p5}3j;;pcC1qaNh`?CbbNL&7xfp4+yGcQCy5?!kCIaM<+zLci#NG%~+49OK)C
z;jpsP67<&I4yBNK@%jr^Bs()$+!HSPBh)PLxo?ZGdycV`MDGzn`6u>gO3|xuWrM1b
zGyRQNjx5P23@1hE<E0Y=u=BM3_EQ48^$GWj>f++kf|gTAdm{y3HmsNnZp()A#q=KU
z5HbeQ!czn6#Sr^z<fc2=N;HW~+B7!yzgB{s!$wdi*F}0}3^>mp$&&RR-9aRS&C}c9
zSO+hgwpH0!EjdxG+nrj5x@?WgzVI@_!<9YD4_aqNeF#>Rpt3r&yg-$kw#kumIGvNV
zw!j_Jm>gJNZV5?I#J&kxF_<q4%6Z9oB4uJU_Z|bL1;)pY^YOjIW({S2)fw?LJ{tlL
zI(dMVoEfJJD%g00amTdhiC1O|;vD8=#@S#cce%9s%enz6zS&x#Y@TB?o_p8ek=N2V
zedE`dGy4M238h2hGF(-7OljNvrw@<6Gl1u|$xS6qPV3F9-3aa{zP53GIYli5YB{_0
z3h91Qafi5G_>U5x=a8JmT#=He$$s0o;CbSVS+oEnexb*%6nb+>n^zz6IaA*Z8T@9M
zZLvJv4Yv<?^s3{>+ol2g$J^m{E=o;A_34e&q~bbvwCjZ%SG83O>%I)Z;e9F_3rvps
zMM<}pUoAy>1s*8FQ=hvL41!OrI=X+qy_UQQp~+QQ`8<;S>|AJq22j$#y0Lya_36>K
zeBMQkZ?`PrR>wFlIW~#Ky0w*UsCc3p=1<v~ZJ!Ff2K$vF>v^HM!^5&Da;At>@bR({
zed?4+@#1apB-yM_GDDIT`;tG!<eQ-IiV&;@p5i+fk0$L56<I$~51>)s7O^Im-V64;
zI=-Di&_Y@9XP2UiqZebyP`-#|{Ys+m8yp?%Kvumx%dbcNITYicdD75{Jx$K$f)<o+
zf8HkVd_la01pnAYvi_34HdHvkJ2ErqMinYW7pwHcg`C|%_*iLnQv1}t7WHyzJ3MuL
zGfU;R0XR$02LFd!LDrD1#6=`jpG(D3P>xj-<C^?K5qZpZ^HE&a?&n+2V+`r#@=}p1
zv=dd2W5K^2F9DaEHsURp7$5LEyRF`vf{VPelT!F(<c)eCG2RiL!kYD;$eZhZ(%RfG
zYG%m_iC8<nZMqGO@V8$qVcU5)otzoJ?y-L0^GGPW<X#$?*lpnR^u-c5rTUAS*?X~k
zPD5PNh5t+#xyz_Dc6#N)J6KSuE<qRVi7FU(`8_+Q?nv>o-?vN;bO*qiHG)@y1><;4
z|E1|}ubYU<EgeFuH~5nQ|3kCE-o86qk`&X=Z8v2D0?!v;W2Oc2yy`JqPG~6lG5fQ$
z)9AT<wZXX8=~ur69vv?`XBkh2ZvJT*udxl@s$B9?js3_L^s7MF+dCw;tP+kRZ>ppn
zX>g=>XDJ(}@3&j8?pIeA{fo8!G27;+bM8`A7T(*2NbHeX!?g+FR~7d<p#c6wRV%d}
z0B7e=5Y$@WNO!nn5Bi^$r6}&NVp;TmI_&w$qW?!>VHXZ<u4sL*OWi~HJXBVme^A6l
zb@2r$6H1S%+15~g#VmY7R|%IjyDdn4YOWAm@8*(c=l@5xHm4tN$nDIZGNYO^mb8YE
zwX{%q-*~y5viAE9YS4SUG;6#3%qZIFZvosNzt3+KjzYAs#t0a#>YQ8s#2G9;QxaX`
zmh<UnX9U!nJH4~;XOzVbitNtA_8YlHczr$DN^5J7t&y^N*qYR*S8G3WhQeT<{JWCJ
zrkh`asZJoFaItJT6>bU_FM}xYV_xK|L3!RoH!~lzx;HHhgzNY~rp_pUK?)*-c(!B=
zdRaZdzfWE{rYW5j6bAci0}GxMhGf5QbPFg&xI=gQ@kY6ip53YAfwU#WH2F-;T^3c{
zpI3`Gj4fu?*#4rSZV_~fhvQozXHdM;!yV|XSjudiIww$%0G`6aoOVyuUAcg+PG`iL
z`+H7)VuAIdC==xzEeu>nZyWmuNU57?k0f)95&@j5>iJOV{o3!17b2t3_Ub&)0isYC
zz2oD24C$%33fTQK_zifufGm~)$5qLu)b_;mw7g<%CUe+#McVQ7jkqQgqjECG#JCW}
z0UdwiU)A<qV^Ug1yc0#;A7Rww)nxDnsGmH_{*a|$Cv`=H038uB$)tZxVP<B6K966k
zt+>L^eY79*W8%wVX&oM7TZqY(J=8pJzDC8QuE*9LVraT^#HG=8rb))?Yw!w(3LSAP
zJiNVjmbKqcs?v-WdQW@cLY~4d%kG6Izo|k~k;=4<LHp_LOxSJi!sW@9o~L797)Kxp
zLZ8~BQ8JqJ4nq4Wx;;C|;!J^x_m<VoIx_hyVVZI${>S$Y`JMFx5t~LAKlfZ7yy+qd
zW!W;8|4jsQ6<w2-pJ_fY*khpIZ~XHjSb_6**KZ9T1Hn}{q&}A3XtvF$CNkH=oQplD
zV0CXVj5bn<xYj-?!XXQNu#KQ8cDM1SBN2NB@`QenYsLtXJ~)Y|9^yCF_EKrm?`Wai
zt-;&;H*R7@a|eJC3Zk@V&&J0nkk=!*7j9$MpeC07Ge@IWiZDb?WvF<K^g(m4y1pj%
zYxZ+V3&WEVdMu5HF6h9Lr2()zSn1OCCih76kxHO0b|IDfBkTEGLGao=>Q6$e_!+o`
zN`ASGE8N8Fj?mF7Vp<8>I$kBA41Po_MfMj_g9!Bc?)7oED({Vm`)yn-luJ7~RRalU
zFIXpk|2@W&G85|+SZ0`nAb$p+(K;otJqyt-bTd+|yj-zLfn!W#Ygx|Q4XNZO+6T>P
zTyCPgh1JLn3HH!^m=G@!P2^S;ih?5fM@(>0j48D`fs2>T{;h$mg6g$^R`pvyS=6MS
zuRvJOMF*yJQPVzRJvY~P0%~6iNic?C3(@P>$jaF5g%bHdJJLb&_+W=HYa#R^GNH}G
zBgy4m0!Eb<HD#7+mR)fl5?RCA@4HqF@j(KM$qZjC&A4&7=c`3CB<vd>CE+#aMAUog
zFIZ97C^}K<@AI=JH=lhNWA-00`|j7xXc{7+E5w|e6Mieq>^pQQBtbbdtw5z-R|wFz
z{IK8~Hi+H3hWqSiha%XKm7lETAa>ESJRLmF&ql?yAXze_!k7Z23$<<yz8CdE9#r_a
z>n9VcQTl{CVpl=se=p=!>eS7zY<?%cSbhTQgYxofaNuPNV5@>FIh2hWZ(Bb&G0WOf
ztVv%JworvyDsR0hty#X8)6^?l`s#&=a)m%BJKx(OaT4KG&^B@4^0P8!^WUKQ3A#kx
zmCBK%TiazA)2P6)^?2g|;TEI3!hg%zp!GHNvV{#A9R9)7)nSLim_J4_RW81@6!ukD
z%EZHa*WjM2(7`SHV~L#}hKUUH2Z4@EHh*E}&xpIrVLyCvKn`Cp2`|)DV$GgOqP95K
z_;tM@Q&VvSY-%cQSFH#Cup8!}B)V)F>WVX`>^DCs9}2~4nFPv<94tyDC1s^$SzRbf
zIF>tJ;OH?(_V;^1x8D>Pwli~Z!bX`F>wVh7-tv{Gutw_MJC=ts@canaa+895LmbSn
zntpbblRGa+eKUjCi=IyF6dj&m{5S2ZErn9)ZiJxI0Z!>qzlp!gt)~I9Pw4RX8_}9+
zF{<u=CNbv?t`}Z6wROX5ZA%|pd)L=kxA$tl@aSG1=5IocF$3QhR<xaYF48lcUFqw}
zByJazdJ~Xq!P(UZ7(194fekkVjmc!@L+3A#-XF+>mKgNcpE16x7!I}{l6|+oHcTh`
zyz5syE0>r0UeSG6%S(>Cd0UtUg@AL({|baB=Cp@rCt}GwRLd}o-WAy4rVUdy$~p;$
z@`SEai?@DdFXlfpIo`{8=-U2(|F~g5U2zWZ0#br8*AKWZ?y3X~+b&MlHXeV<ukZnU
zs&UA0GlF5n9=eX@1e=3){>?{>DVtuAQ^+l-V_;o8Kmq(MhsxZHdA5%7kk?{4E%M=d
z#&QE&5$om#y{-0U`_v3U9sMj3RYR%$3l6r9MPzY`(uIsIE6LErDuk9z+s)oMHp7Bw
zCozGZ=a5IAwC6i~KCkxS%U;uWK|;;G>(ze<WWwQ-uUpIqq{JJ&M@Of4CrMLmwXH~E
zJVOV|BC0(!>TyZD<$jk&3uzg>?!V?)J6?;tzC~>E30FzBp_iO<^4>x|rq8>%vAetn
zmo_Jt|BsM%5{;vpuV(#R@RtK)yx+}G;6JW)<^w3354yGewDM3=T4Rpy>xNEaB)#dE
z05FKZ>7^J9l4Ngb$rlL7qi|^VBR4Z!eQ`>}>a%|SO|&XF^3e)T4l;%9;`ScSfhVaj
zGHowcbLE+J!R?)fU4ZkF=<V%|X5{OS;Bn4jYV#do*gUR>C*X^1ZFsDxJt|8DIe%5U
z%i%UJ%Cykx=%Bt~V}7U=p5G^B@70C11&r5oX*g>+pSmjq9V@j@stS;VLmMa#|MUq3
z5=-v-q_=6;35I!deE%1noSTn}@#A=iBmWSYHboSft_ZnGAUW(ilavK7ijO7Hr8yG!
z@+qR*{bp(>i8Kn_N`3tM+k4$T`B|d=e)ImapcN0Xpcxn`jkM1MlQA)0=F^<vW6ga0
z`B{CA!FqtwalOU5PkX+(jw$|h%+N5bu_Y#nbuJEZmP=npF)^I61lWXUCt~}vxvJYA
zq2i+omr|8H|Mh2+-8bwri(enVAYt09Ucdth#U&xVJuYKQERt~onus5*{sD2FnE*G7
z(7>^rMkLz{JFy|7Zuw~9<da~5w-pQ2TOr7*c3!I`DuyQaM{^L1F^%z5^yM@N?B;6M
z_6$Fln&N2J9$M;yo5bE0)(wsX+~9rCBDfs4lY-SFI}m&$i;2J6FsCpmcflHcyA;wi
z!~32V-?cm)u1J4)^Q{sqMq8fgQ$%o_KU|N2p6mX~x8z(#*~AGfp0#ppFlJXMvV?g2
zrajI{BoUApYZMD##V*+Hn>bdb122#fE@=7_+H@Gktr)5VLej?tZ(NT)n0S01$--VT
zNw}7&!*ah1508x@5E(6!b(PU8CUcn$izb4}IZ6L66d2y7Bd=|U7#*OSt5x1ngtI=*
z7@Cgc)GbJ&yI#F-?QB}9CtNLyrQbL?>M1e<^)n%@bb6C@8zWzq2CH2&koB@pb3&cP
zM2EJ2beaAEn`dAAsEne{I@mgf`>rE|CE!IA?8m00OT#c2+;lYz)Z{;OI1r5Mm^2Y_
zsX?)~BTgjIIvgS!2o^BN7xrAyd4rhj?z=>U{unYZfjZysoqb8)eNkk(xPgTLn`l6?
zT8c*Ws~K><vV(dB{lhME469>}8|9!xDh|(FSRNRw*u=^-SEkz~B!@|_zyFM@i7P1Z
z5MwKw;hCxap=ZOwBb9$cYLTTd=Em;@KC9I}I0E`oMOXqFqCWwiHl+(Zuq94JBjb=-
zwsP`ttZZP*91Ll0@J)m_dA~hh*rEa{EjIooQpL1!!58F3jH!yrJ#`~<IRPOc7+!dx
zc<c+;*f`7$Tj^5EAa7kMThq}N*&o%Pa%&7%B&ejiT)ok}EKN&(KECn^7V};$DG4kr
z$%20^0y9aU^*|?sm!*zq_~|GON3OGDINz1Znc~JHo0X+nK|ACK0OftX&9v_~m}?|N
zq0wEH9tnVk5h*n<AJTE-PfldGj#gCIa;DxtHyooVIW|wo993gb4$?%Fs;_tVOArP{
zLuq-uM9bz*+XgUy?TSVQzUuUr^Nw-Nt6sD;*2X=we~3cb#BH_O8n>0L29kwTxPGqJ
zMoQO3RA}+LaOZFwnm7@N`BX|rqrK%x`IlHOWW1hsv+|hcLCLY{+M2)H1Yu;843X>$
z?@X<1_?Bi})RkOJ*ClGV5pWQ+WLq?dCNa&s@=?Iu8Du6dD3_oSzY=WGBCC~Kf7vqr
z%83}R9W>j++V(4kiaP*h5ie+_hIr5(0~RuFxLInq@8uY6-w28zN@#d_aw{aSUj5;}
zh9O})CU#(e>L|<?F?sG*r);y}ZsxjNDaD>y<K^%txpijd|MvnYuB%j;@cDpd^0i^&
z;noK<6{^QJ@sm_M@>vir#zSMU+dmFvLCi-46@o`K;7UthxMZwniHZc{LDQ{*BKgWN
zxBf(!UPKBrDe3Bz>2)ZD0VF45${-2p!-*IO;dad4{@^4&q7`Z11WXn;7Qg!&F?gl9
zPaIryK1e9$mbuN|3bd@!Cty27yORvsWZV3$M3|n=*7Y6s5aL&^ZxNPYjF=&t&5o$n
ziU8se9<NcO2s9wrw1EFmR~5y=%qq1R%QYyt30FSh8+D+Nu$ZR6fE@017C0&Tku_)k
zNuHByE-(%qo*dD`tU*1nt=8$Pqb<yoE97R17rqpW(9lv(dAcGK?l0j^?qstGhEncx
zp9?5q5HiTZpn|aMP?vu*tt&XTd$Lfg(lcac%ib9t+kb3_aDa!OFC3JOL*R7iU>LZr
zCv!O<PQ~SdR_DS9ggnFY+>Nkt{dw5*`VRPu_|X+dtTVz){8jG;&AltVefZj$II@KV
zEejSMUQ*|vuYBLDUe>XRv{f$QiQF>n(voIevxNXmP8RfY8$lR0Gt(bO!PU;l>zY8j
z*#}4QM9U`e(tM(@9<$cHGot%*@#TrFv~fA?k2*=Awrk%V^NrwDNqVb0Vd-c!H)NtU
z6jmcIgw1}7?+nH*fKsoQ(JWLZ0r>YJq?oK6YQppIF$UiiB9Tw@FA6nrreOim)#;dN
zj*wR`a+J<TTB+%2L~a1hpzVZo5;k}{EGf`<_2d~H=UFe?(T^?|F<2Iv6leGo6D3{(
z@<+Hrpax6{_>08<`D=$E+?O!>bA318HStuy&Abnb`JqN&)#pHZphV8WFO6*U5_Cwb
z#P{dCMC64tpO6{%(R^a2kF7>&tIqE0^{I>ZUaiLUZ?Cr}DP?c94zHqmSB{UZw#c4~
zec`^ny#}6Vq1$Off-(dLDsU0@SP~!UuC;YzjP2}_Dzk~C#^B(>DjoJ+@hT@Zg=AVq
z-Cf;VCI=B53tZ)IA3=az+6(>s=WF=i=an117!PV3L*bh}u}K!^LY8IAovj8KouBV*
z-y2VF-ABA0JZ_U(?yTYlJHE}vA6*p^Bva3z#5}dPtf)L5VZ7waF62?cSbzOR&-b6p
zgq5&8v@hq!@jW<@#4y-+Iv^EX7;~Ksfpew)D)Jno+1pVeKsarZK<UipOHq~xJR9&0
zDfYR1)e1+Fu&TaWYeif$8hF*m$pAt3fmlG!?!8(@fJwAXm#xyI;TMgMDBv{A)1eP4
ze(yd9_jcXwDqW^tSQMkF)r(g+Kuq+WR{=3|>EaPcSi9~?CaCsS>DAsT4G|CmH4S6K
zCrEJ;?&&xpTSkyz#{|=jX3@NCko}&%W*9djl~0W=SqjcE6(t<F{hIsz#?({eBmm4&
zgM_}BLN`u;dV*P*TEs&}EbW2xv0`&vf&8)@F$5EE^MUQ{0!}Gr(ga<H@bHRd#mH7T
z#r~A-^T?oD)Jk5k8xsHaYxN|OQx&YMV|&P#L3N=gw2c!i@uwG1M#!DWej{jV%KYD@
zE-48V*KhWx$a6$5`Asr+Mnx*<flnj7O6dBdK3BRC@mmREgs6LbwL2Dfx{8!%mO!tw
zPiOAR$GHgIeXpBX)Q!-jQCzjSjWdc$jtknDTWl%~4~mw!%-*2`N)=S?4G)Mz!hD=}
zsLfpTF=Ca&*0^1dHy!-Ch^mz&LHC~`RXnQ`l97-smyp9)F<121?LKY-2vh->)e(#a
z6w~^R^N~;FqV6S6`k#@JLI0`k$jUozl!%j}@Ajn1u&OA4^$B&=5N}_)=Z8?w4?PhF
z?Nxt}Tzs$myrlzg#L8YbfX4>vZil<gSYVh5duTku8TW%q8kNw~ej0ng6+8cg%nX3o
zEuj~v@)uNkUa^<F5h*Xs6_9QFpGv%)&xy6+8rS3F3ZP-Xm8_yty9>ua>YXx3M}OgM
zL5%)nd)+(Zg-bTt#pOASq%0a)-zY}QKqeQ7Y4CafgRuf6Wxjdsy1lxE=MUs(8<gFZ
zOhve~;TFMB845169V!rrusmCpv-cviY1!7ivYT4k$UDBeK=PD-p7iQd8H&HyCJr1O
z<M}5DKg9#5Z?zx2QI<|=z!cht8nB*g#%1D9CaGB$K5r8q-BsaeY0=uz_d0di;(8wk
zR7!Q$Yx76Bh&Q$^k)i(#W1)qp8%0K|Hf;OH%o?*jHNJaQv3PR{{`k|h&98Ysc#*^M
zQDn$wn9tBB!VFBxdzv~-sc#iBYHFfM=Ww~5DC^n)IfJM!>a4QElwa}1gyvsl3<RpV
z{>XzHh2SM;oxRL8>s+xbkrzGaST~(TSF;Vo4CfKxA@bp;9cO?S6_oEGSiH9^3XdE;
zqbnRPX6SitQpG_!x3@jgP1C|NNU8)Q<(J;AZGjrKeP%t^frR{v-=ln-M2WuKuy9<I
zXkrg$J%8iul|i2BvT&UlPzhhJMEMNrNrwsKu;7%MUxb|bH<nsRjS=<Rw5oVmp*Jq!
zz|8OgL=^zu$k{N$-#)d#43@|WC~OG##-N1M=(+YaEDTHF81A}hH@OpFhXj^|9K>qc
zhr`hc$!4^LxCkTux%Yv%{YCRf=)?sm1D<!OS{xeHP+6H&W`~P#2Z>gc$US^i>4jA9
zq^fqEnmouB`)5yIaZW?Kepex!6<BQ+)m3_c)x66j=&#+9lPrKEqikD+isJF{1sS=e
zou9PM@ya_cIW?|BZjM0~=_TezC+eseSV44O9A>dEiWFTr+q<6^IPyVN(o{Y3kt|$z
zmIn*`Z{MOHAKq5sa#gplqE|t686h3>O%owDL=h>Lt?Vg+?$a))yUtU$897?#`3X#v
zTIUuUOHN8{52P(mE7h}JZ32~R+NxCS<4ExEYo6%_7M`S<W>_D6WBR6eEbS|)@yDD+
z7(P%?GrSqN-c%b1D&8m+Gy9}ePORKpjtu#)z{$U>H?_li#-gTaXLXOZY6-3x$R~n5
z4c3QUrk&z;RW^4N_aU>&5u)7jJ@90q^9O}%=G7A5z(7BmgCdlg-UJZeTF=r+y&d4!
z;8%VH&nIlQw_98NoNhFfDjL3L#zCtx5%NWL$36UQD|jw#gHfsN@X&4&xpovW;3Q3|
zQP6y^#L2<)=nPl<qXkS$bQe5)%9pE?ZS|g8!Ju<jeXVDtV7ev14J{Dzjt70sFOCZ!
zJBRok9U(Fwlo~DIKSF4|MuuGYCrC8?fJNU)^NJX18Sk9nNq(KU5*2^`8(Q6ADBky+
z<V5P{guRCkOSAR}H`j>?7K^tc`U9CAR$^f0Pt-Q&Bg)>M3Q5rmle}BUipdlPmazq{
ztj=S#2M}PSaDV*W{}><ObC@Z!ADNRIU<%ys6-sL$^b~jp9LmHEjv*J6h2P5#PA=}t
zT7mZ;F6=}+UyU%^eC{Oxx|vCCcj~Bdv73t{1qUuTO7SZ_Ot5m|Tb{yyyYFb}|NFB4
zzcmF9x_D~Mf7`ELH|m~rfDohOyo69ixDHLY4*+Ga<%m8>p|VcQE@-yOQ=48`)`ltN
z2Hk^5%z3Btuknd?WK095uUO~~ro4oMA_hluh@2<@p`=Y|&lXAk1{mvhN%?RdoE6vT
zGjl;$SpR-eZ|ewvB*m&}1)b2!EFR@qR-^s)nSl^t|087!C27u`!}*!J=!=ShJ+!L7
zuCVTJuFt9-Ev+*E?3UcYbV{_v(8kVzA5dYU>-k&qOdJIv&?F;CEh}*R5G@g1EM{lr
z2apNri%b_9f{HFs_6bn#|GU*v!Cfyr9H|_RfTWm)Jn)wcp-xZz&md%MGN_BQ5pj8l
zO}kQ~68+AkWXt^%lD^Iuh$AGLtT77HF^h3M8pNxyN!ub#z?td@i5w4i*+<gD^j&On
zi@uP-wN+BgT6J<2DTg{=>TDdI4Gt~3fHINJ?boE}TH==TsDJR11eRm<KRR4}B=82R
zNDYHZLwm_0nK!!@jG6ZJP0?za^|X!RO&DcAPA-NACZ$4TFA55HV)eh1@e|ZVSQ4$}
zd-SdggUzg<2LU*g*M%Zu(`_Y<o@Y9@%ypfx<=LB)dIJa#UI?Md0Z<_E5`4yLc^ISq
zi$B0Z7Ka1!3JtFB^uSCaP&G;D(gy!_*X;R$pnNNpdAL%H6}9KcEyobJF&O%JWzd`W
zTB{h#tmP>vmC|Azpc3biUo{OAoed$@3;ENjG~Y0~$8?KkW=|FOK=-*9Cym3W<>%kk
zSJ+p=bGN)+lUzO0>BRj*d<FR>$6E07B6<&-64k{2s{CI<)pYiqZf-m_M+vhWm@~9n
z+`{KkdgehYrJ#%oGI_|zsff^ABsp-FuVveoIAp?k6d6;+)H_TKhbp_~S{h`<G_>9-
z*+d@`>I!=p1(8=B3gK9q5v+8OJl9OvK#T8HLcPQeq)J)$`}mj$A^z=9VazJ`F+4R|
z-u4uMEbm=^UGx=j^S1qo^4IA&6;PB;1zVfDOACcMM+5|3>wJ>VSzJ4GFPmN5xWf4(
z;tV2VW6kWR6{?0l$jmSY;Wyq-V%DA~yaRw0D9P>W=u?`Vg}Hrz%>63mk7GPwyWPd~
z#%ZA62~fzh@<go1)|yU=ezJ9l#h&A1*l1QA3ZGE-(||W3&eW|Jb97&ppt+z5J7z=0
z{Nb4`mA2CUN+q{E(ap33D>dMNGXI_sBsJuwSP)(mK7WR?9_TQGQQQcI@9u~d9&we!
zPoR)I`VDqA2r)hkIiW4rW}7nbNWyga)Qqv%+zY{(;=7-e^+w#Tik<x00A6@Lr@1zU
zTl_HbzE$YcRY+B6=Q#D4e2msEfLvA=xYC147KRiG&+Y29=f41S#QuFErV4;a-rM&0
zr1w)&dmvs<@wOXW83LYUg}x&kEGcjZw8!<edljY!(zRw&J*@VnWG`YVwZShT_3|Bs
z*dUqB3(Rrp9X9-{i4M(W3AE2BgC&RlvPI}HSus`Ha<Jy0$zKQX7o^IsSwp^cYs0Cq
zzeKIzTE};XPUH9}>lu!8|7$L-n=-^LC~Fb=37I0|9e8!a>Y$S`P=r)8O7Ppoee#U;
z_2jxJKyz>L!DxRXg)yz2Dbq^S)8A?;0{8qLGP@9*MhA$7UFKwm_&~xe>B4}pfm``m
z<@S!>HK-7o04^=D(@46-V~mymW=Z3@O^(`=#<9R9R>*G!qJ$mhQgzjV>~K(SG?*1&
zjRD)1at7h_Mw(pixz!~_h~Ih={g^N}F43U-@Yy^y<q$q|&n@d!!YrgdfN(W6Co~+h
zvmaCT=lt`*DV|XJ^kGx~HXdbDz_+MZ@F~BVJZ(eN?0P_74JYj2KM_Na_cM|cI_ixb
z?1?4tL>YJ@V(7}NI*liUA8nS@6(D3JSK0Nvq@mv2$of@~Tm$GTexB`9rC{{pj{p|)
zL!apQsAcOx^!T$iLaZq`RIgD`r2x81=vHn}=QfzU6>`5@5!y5-Ax_~&#1s*G=7Po7
zC#4uO$g8`84MAKeKBQcwMEri9Ept9|FMwW`x9pA43?b9^Ii{0BHN>au6go0F7gn}1
zvgCo#)qLIcFDB$sHzoOw<?4af%Y8@sG=RYI3DW-aSMO+*;o#8;X)q2_gkG5O*$X**
zvC4Lj;wZ$l$o4wc11rl1yuoCmXQ@<kZy<F(`B}i<>BsgzmhQzy%zTpD!ShvV>!N?<
z9Hc&RIsK6o9daLko%PJx;PzZ=|DpnsD|6}rVS$7f+Epopm_3(F1}!8XQe<mOCbDG(
zJb%-;?)Skdy`EHI9_)xtU3F4%dXVuK7ex3|{b?ltzln4D#@wUt3EXFN|7sMMJAk=G
zlS>?*vRm5-jg(wd$yRJ6wkYH${Lmv2*PbLdKTKF`Mp}^FU)1Rj&xQgkhbR$VEWQro
zeQ*N@gwSIiFysoThVQrLY>gMYjHdLX3Oq?>PmG%#g^SZsu7*(EFn=Fi?HbbyDJyWj
zn`>GSA2+=z>Ky3O=J$??{?mVEb~mku%Cgg3N=y0{Z+ZZXU)}-0d;j}$rR#XE)!BDN
z1^7FMoy&duNl8h0lfFvXWM$%cd{^Aq-W$HNqc*Jh_GN7~<-F+sI?exAS>Lc#GiHBa
zi6Y4Py5aS%4=w7wFbT2>a2-@|*@ytq`cpuK5KQC!SCOdCdG!-wDYondZ*LdSXes>4
zyni1^W$u-3I=+aV8mSr_IbLWPNE<k-=Ka&VeP+G6@pjtm0gY#pbq{~0xxn0E#{H+A
zKQj3<{@g5Z+@<6Ty4P>DO3eqgIE)XWJ}!zPKX>jTampM;aaAC6ExAIZ_${1*j^_Co
zsW}!c1}&1&f2$99$c&M+S6Z4wZ0Gl|@@V$YH2*9Y+j~4;SF)Va&f>hqDIIMI8~xe!
zee*5OJnf$`ovEKW)!@H?oIZ>q`;g|+0xC+cW%kw$0lGu7*7FjnvSs0iJ?UJT2~nE8
z;pcj;mW9_wtVTO+Sxepl%d1!!2{=4-K=Gd8_{t#o;Hk_;-4OrMW_Lln9=P}e-{MJ5
z-oL{GVh({>hd;+$wfPVMsfWiuuko`Wp(w8Hnnlml2HQGX*=Iqz1(ExNJrXN93PQ08
zk?0eyX|^Jxt0yM|XCyEmu$?K(&96Nrro9PEU9l>Y6Bx0szG0>1yW}mJ+7(yQy_6H|
z(-m=lrgh(9{ry;}-ie%rGh*@E1^;mF@WI;6tNE2BL(M*Tw<w*jMPon8)sDADq<9bs
zCC`A&fXvoHNPkMQrojT7c(@ZfT@njJX$kj&|2C4(CZss;nHlApMbnqa%&&&Gi}mNr
zziVvrMl7K`&E%7=5?M&T&UpUERW3Xllkc!1u6eWdh+@;HbxNg0Cbi7F&7>iXi0(FC
z<X?^*=E_#IfM?}KnXSycQbseX@~_H#XYoG|TUb}b?ZNIOzwDFK#j;0sNy=5Ns4p)2
zcjpiTY(`n)(NpY&?>lv5sj|KvS)_P>KRm!4I{k}C_A_}4R28zwc3-fF2~kJW5du5d
z+=dh#m{wS13}b6=yAvF_o)n-|37o+<a7QO`;7<2tG%ma$4HY`K(M^_odG^{RP#o3m
z^7cG^S^)>b#s|G<e3bw~;*lky??zk@Cb;EVo}YjQgv7_e%Ss8HV&Uc@VO~;x!}6#y
z>hTjf%lbkR=fcz>LcFL7wHWcn8$PLrrlqnp{$!847BW`Tu1xqUeZ*<4NbOlZ<ZF`r
z6RF1x{ZiVmVB@QAVU(0)Vy%7WAn9i$QQbMB(Z69sv2L|LLj1kX*1lbmj=EGfmr-<l
zCfGdMyq&@{=TJt>W2R!GmyqcRr=cPA-4)3+@aEySI($%&aOWF7Wyl@AKAXd@qHP<n
zMcw+<t!#VMrvC?<(2~r@UHLi!@OO;}-0Tt6t%E8dWJR-^A@$$~&oegdl;W4ShWRY{
z@C!yd%Zj~cbpk-q%M^7CGFZ3T=u*%{dRyA!#dCG3$G~y-O9x#2A)y;XUM(lOadu0r
z?EcikGLNXCVZbWg<vBLXc^pVM&0p5Gr$_1t_k<{XZ<^4pBx(@C<Oi}A>{uw>Bl?&u
z=gb{A7BU2uw&r2ZG*@Iu@$}pB(+D+-n8Ode>Q=w;y>As^L%sU8A}=}fjubqKh>FbG
zsNI+{?}!FlC;%vE6*(^;ys7W6ndqH11LnrZZ4XVTV4=_D%0T!;RRND|Fy`=Ic+=F)
zY!weiPO;`q(ega8KG4NIcQ`E+z(S-!xzB`3iXPA6hO$S734xAn=+k)mF^Uzg4W}J1
zq${GX1C^K|MTU8{qxjfVg`;<e=6kVuTI>w3g)QzV%^O_U*Pucqumk7l$i`uy?F;HM
z2JDx(49HL@9ze(~=d_ps{_E(5NuyI{zdKD_%`&V*I0c!14zS**Pdg-TjkFL8asM)Q
zdN#v;^w<>*qYlG-(UN@M(}VylrU+;uu$Nk$WbPa|TGi9mwRlBk!GuAl7LXjQ`8%Z|
z0FNsPoa?422yiAXR;{g1)pB}Y#i$;j973g9skN3yt>kPPfQB2B!y~q23-xZN>-3!(
zwFg4lX=$6P<>uYn`^S_Rs5dGGE(uJwiJ##H-=$P5n!`741#ig2qg>eIA>9H&v+J)Y
zb5_4=<Qg}BnE}s+JNqE&ZxzO+Fn0Dx+z!}|9i8A0gCk!t&l))>FAlsiUp7Z_CwWFQ
z9BAAFNWkcOO%5UiZp!(`HyBM>P*Bbyd|F|D+x15`;1e#F>tB@tqC$q1Bcd+MI7-!G
zcPEF7bo(CTp+O`G3^JtL&prrnEgb7ly}ad!R&UgSCPyO~oOgI}l3r`Z;k!+`F$S{7
z3t8l3U^>kAB+fX5tq8vd@fx|ogHXx|K^@B<lM9<fmUqdiZz<{Z-w#SVMy?mp^k1zL
ziJCpd|ImIE_aZNT3j({Q;y=x<(=<DhOxK~}8#^*5+NAj=jS5}R#AF)pWpa~7Tb(ll
zZcNZ2*x)tM-&a}x9m@T`jk}&2$bU$e*B<>ZbY59t4(Q#I&D%8s#SLJPB+e(*D0xkv
zJ_D@Dh9zKEGX~>tw!)!myy@cf?1ts&Z?X1cuD%_9K1f<s5HuUwaRh(61F!c2?;5yM
z8;|H@+za0!As$jSfVKMBgC|DJ3!6eJz53aCfQK|p*|BRPzRlLGhWm(ZsyBmYo8GGX
z?GeFp#x)%GZBSliz23XK)6vs13TX@3a|#ZH9?*YBTB8D#`_(Ob=w%sALL6(@yy$-c
z`5O|@$^6v<#+uWblII%-7o=;z31gqsmWU|Rr26Tg>o8YO%;c{(xuDRtgZ+0dJkhMf
z!`eq4W#}ym;DJm2q}Jd83OvVr`2ew;Wz8i-$5x_aXr&{KJ@ge82wEe^4lY|pwKMr;
z?2LKLzda<6ICkYhBDuUqfV70(Wc;12Knme9_VGiM>%+Qm9IrRf5mmW+(!xZ|G~~9N
z`e9r|@`zYBjID`Yj^l1S36-gYQuvjVECVTxEjk9RkfXEb<`3X+_cF?0AFWUimtHR@
zxG;^=<gwA!(=dW7&4$2}XYz5~<w&p}tF<6LkkeJu@NG3_D}vRuQ5ORSG7}m%_;kb)
zxJX;>+axz=CN$|BaQCg?BzsQg&m@{^E<(W|ooDA%d|oB`!^ugN@r6d@qCNI#CT2W`
z9w@M9fsXo;)Oj@KnuBmzta46FNJ3niBWt5&wpxxuG-`n-s}zZ}5mAxvID`%<lc|b{
z>S_WzYq?aM4dAT=lWRu~PdMfqGxI9jM-C~uk0vd=CwrEM&y7dJ2A@&uW=QR1VQ9ZI
zIUnM~&dI<L-vyhv8u~_dHD&2=?5RbS8_V7VbCA{EH>mo+mFQ70oVsv-S#wvgQq9L{
zX}-tJDna15iGlqyfaM+h?8Pp_;TO%;vn;RQ3t+7fAh_1{aPM80MR+r8DaLWV_lPK`
zbp_FP=$Q?~$e1IQjYx_#HHKZt;lq*BVA0$Q{3ZiD&DiMs*Wla@aN+wuzZ>6<la<pQ
z4<+9x?kg0{FgjwtaR)@308c-g=^R`!H+k%$n^LuyLcL5%^LX8QH$<Z=6U8zGtYnzE
z;}7329iU4t45XHr)P@862};u7bZ=oI0r^1}*z@83S0OWCT2`0zHk8m97q@wET_Dn^
z7R>*KWjpPGxkAZuDil~5{f^d)BP}pTl5cx&pzrr83fd21AsMAI-JNso5qH9(f7=R>
zf5)t=-&yb8d#P`L<$=WlSyy;))G1F0LIHY{6VNiCPEIE#zqc+<18Ei*{9KE)!*>9h
zI5rc)mt;zmisY!BTK9+>+y>>oGsDZJp%p!e{kWcYx@9F#+I{Hoe|xOhP=`5?YzVgs
zkScaPCD!y;Z1-3S{-cVp-=%XS{vKdrJQQuxi?>6BdNJ8rr;T=L)vJD!B@iDS@M!R$
zud^feN-tw&Z|WYY12dKHR-Mx{n8vvw4_%jHPqcMOOdJ8p+uqo}6L<)oSyL6?;aJ$*
zDbaAlEfN*>0@BZYtw4VEh93EiH3R;amr6j}$f>&@&UF6|3%Wv}Q7VvWu)(7eIPtuX
z4Ss8h3u4h?x`5_r$-r2T<)QbU7CVIp50!EpeQveO*L;1#+W*G*t>iiSF@L@P%2KFM
z$UrkQ|M+_1t<lQyWC4(6d8=)*G|#`@7P{P+0>$pAQ&}19CyqX8mbdD?Sv5*n7wzJF
zRd;u&qOcl|`TrPu%djZhwrh9>hVJeXq`RA;MM^-rK|*O6LUL%4R74sE5RmTfmL8-V
zqy|ap=9}w&-uHX|J=gv7+~&`m$8qkx_O;fN88V++!3)0Ewhv-VS3dpWJc8qyd^OJ%
z+NIFG+t+DakC_YbjrNvk1$*AjWla$9wV`SrOgB8(Kb`tF#>>8glzsu6%W`!7O+fzl
zf#)e?FOd^T?P3(<Qw>1a+<vdk(d%xVfiiMpH*&5lA{qb8gl^?s1Zr^fCTB~0MbzGX
z8Y`qkJnNWFIpB`wGYEFYpeW$Wg1I(HFjuX966ZTPnWN$&6uZ7ekcdZ)MbxrRN!JZ0
zm=GF~Cn<<11%-ya;3h}ta?LiLUFqOHu1j1e5CTMqRGi>wa+b^|#d(Q`ei2ih+3+GQ
z%ZP9Mwtm)BBb_<QtV%vcO8}sw<aviAdVVpqZ-(G=5Fv~6&rytsF!1QZUCrH%4$zUz
z`7(}J@<{88rMcqC*xd`h=cJ8>UR)sdLsHnel9*roFDgm0fm1hECK-wa^n!&VZ(3MR
zROwuJ`MC=k6e$r8kkDPG8a#FtNeJ)8DR&|5-AwX*EU*<9M1<E4#o|Qsf7{uqYS4;W
z6|Pm^Qh!Mv^|E=m4982j0aet;fB(`0ITKO7T8jT0bgdeP>uY5nV?<o==G$P@l>}AK
zQt{>P`<ig{T7!dc)jlKiBmkMAuBn`CXupoi>A>BKHA@A-*UB7c?otb;XY$7kbWr*(
z#FZq>rJ(9@XVBS_iS!Kgi7YQwYga}Q(FO+ibz!x75EUS>Lm4J>rC;uPG-y{Y%EqBN
zo85rl=A?<&Mv^Y^C^}vABBUbmR~zw34yJ`gs~^etn>z`h<UXZ!&9i%HxqW?QG@#(}
zQ6!7C-@@Q6d`j+P{$M10>TP&?|JmPDTGzHfv@;whBR)4KANC(Xi6&9OjX2<(u5F4;
z{$z52Gr1=+t|_5;#(OhD$gyIQqoJhu?Ko^Vt#c4D%|S~CG*dwz`JO5faWtWT<;4>>
zuHZX^SF4GUQuGmWB5MCQ$5$QTgZ}q7`AZXu^Gj=AKb1XJnaJ@D*A^S8A856Gi5qj1
zJLclkG%n=gQn>7c_Eq=jz{A$YYEoN3-7%^Ba<J89C~vHUTRvq=G{Ms*wE;!Xc@lXD
zrplvJn8P_reA}%L2$qF8jWB8pu%&^nZZ(|F|4CaIP#~P!2<xSRPVGkZ?uKQ}sh9SS
zZ1!A&!Ar1QPrq!S!iZ36ryt&AJ*H4-)x!_A$iW>zAkkpZZ6o5au`Agx32-hF@ZOGS
z--$!nRNwMwc~>g|ADq)yTY1r4Qy*Di`9u=p89KDU+P!tSxfYBbIPo9@MBv97RZJ~B
zipmD;;w$V!+#9n7yQYoJZWrD*Y0`Y`yn3<;yd@`R9*x&^#Hev}QRKg|?12w)NS}qd
z8l{&S-H-7RrDw|$LhV1%(=*dJL$t5_(wh6b&Xk{r>4q3{zLyR@XdMrzU_Vv;uZ9i2
zENHJ;-Hrp~uFHbH0nVA#xDCHx-y5@^<Pbw$bLJNl)>D;?)nZDUL^zIb%nYTO_2{{R
zE^N296bDuxwK8SoLJWf;Ashw|pf5P79qk{3pDy&5GmPb%dq|r#X71UOva1pz2n-YG
z82Yq>y{Xu=;)p*r2zfc7xZNL7yRM|}DypDhH}|BlTLj`3A5?wmFzI4JQ6lfG``TP6
z<IwW<uj$>><!LKf-G~lw=dizFM9*Ns{Oj?e`teOrtGHKSJ;Y0*x&{Pe_;M1B1Ua6Q
zBv}}6BfYq^9rg>rZ7B+z4vEJs82LdVTZ%549}lR*H^u8oh!FpkK{IT`F8{Me<3~+3
zs<#Xso+=6)gF&@j2)w(<an0(-?>+#g3_@bJR$17Mz?xI2yYqx9!ThV}Npd$I*LSgN
zu&+6~j1*dIZ7G8e1?88t5RLD_SpbNdI4;97w1HY#n9F0!p!Z_{u@Y1F-!cGGLQQrG
zhBbVf&_4%S_JeIfAsN1Fm_|<pJ)%|`Y^GSJyX@JF$)$ZO^|~l!X+5_^%uk!(fSF=F
z=Rp4Ht>m439%e@nT`>mHYpf#C#!D3VME8On*mF}7h_F*SDojjBCRnD6o5abAGl^&D
z_vs8)0K(|TgfEzo`{DRZC@CAH^1o;|wgvAT3qD~B%?cas%46>xSfrxZx)WS5^Dh8P
zQ^4#S=l12p#;6y%pZP+=qd}*+cwdtwra$2cdq<BS9tM~Jgy}kv6_h;}@Jg<u2++63
z4zyADX=&&825{>r2Xtf*9%GqZZ5qCvL;PMsiK|K;T9yHI{stU|_qHvg!{k^1bPj;>
zxDe*>FLITE@BRT_C7nzH{m%V^LTA;=Is-8QV>B}5<AC-d5DAlG%nWh{4=?utw1+8*
zkGJ?q;o<Vl_w5h^9Yd!*&zQ;r@c`%Wp?u#<G@SErf48U8U~8{i`Y+)*a!ZHdwN35-
z*(jhSfFLKeN68HjA2s(L65^t3HHe|vb0Zcr{U;D47eMj3fQ&^Q67GH8D-!@*$={@;
z#Y3tTgSAhMi|&a+Dwc2;7l5z_6*MS*#|@4o8V(>mEnSkb@BVl2Zc7%WpoMbKwxn#p
znP{kb^`(q>qdw^Iqohj569EV&gLvB>wLEMA@Vm-R=lFuT_$zwxD5O0<hESMpf6wIj
z@~Ue^1XMYJ%_o1PdrrTzc0*7m>kBn14Ec=@y=$U{p#dJm5PJeWM0Y%NrInjg`%K}?
z3t@dS=dH*j7mL+0sGQ>4EGK!;40@6+uENk<pC!d2AmDhrGyf<E1umvz))_&t#tNXD
zRoo3gM`hFAOv|B-P}DBE6<dm5;es4!ouxCfmPdpf9_<SFep!ETLaoAv->wC#!EXrx
zCdTTI%>Pw7q^%p$zFs?z|JN8T`)cAj;DIIKYndtMNfF110}8nD^IRB1NN_UUYX*f<
z%tMDcGPc_Ca&iXV)Ba{H#f0Z{Nmfp2=f)#%YRvSD7Hn#~fGWY>4}7<UVSCvLIq6-~
z3;E)n8$VFEDtXJTcV=lTg4{`RlQB&|o+iujVMV<i6zYxUFfUNhZB$E|-vzf;W?I+!
z3%Oy4ZmZXW?9plf^bV;_Y4vW8Pl%(nsXgB&DIJs*A(3+W?(Hk52Fp0|tj~z+nV?CJ
zPfv%$<1V?=ID?OV`cyMAdUD6yjSmr=L-9vTTp!awFrR6^JU3*er?j1tto~2V^!a~s
zraDR%$34+^A^qEt$yHf#X(FTcI4dG65Ch?E+ua`(sRKKlD}f{&eK?x^Xtx~icxkmw
z*8lo`HGf$&MSDeun<uMzcW-y8Z2P`<oi;LMedk2|0q*qv<Ku?y8%5>U7n|<57gmTG
znne|CC%3@R^MKT&49(DdR`N;|_*zKm(nr4l@_t9sVnX1`0aMy*6HVuO%nfp^Q(}Zm
zgEO|(p9hq#^O1uXqaAHDSRe?tl0XFY2Aw+&$ms(R2nhO(?{=5@Bx3XvPF<xxKvj!&
z@aGE#bQD)#XKDlu+E-5wXBFFz%FjNAD}L+~BhpU(Y&$?LFm8BEG~FWtp`1-W<d@8>
zx|XT(&E#+8=9i$oA4f|{I?gf?j=|a@ci4lp$G_oEc<(3o^Hv;)$mciy^dbQ1355Q#
zW`$k3HMd}3Omsc~>HyIf{3dkRZ}#^O?5o`PT3TBsXI6lfy`ZRyp2zCwH{2g*`WcT_
z%m+-k%bVm3JJZcDVt%^mV<2*qlCS~gBS=`*;}Zg)Id{ef1QXCxb)`DcUyOZNZf^)T
zs-t5+S-?iSUSu@O$<L6G_wT8zx5vl~(-S{!H=GnY2ve<%R7uC5Q@3Uzfh5^yxVlQ@
zP6}8#yulr`$b?42oVN}wty~xYGW-gFMfYSYAt0jB)z+>V4;<5}gqgJjI1k<p?7TVy
zI<Dr|qW(%Vh3?rSB5d0yal@VilDu%uH%Y{Amj&j}X<nG$F&O2v$K6=r55+E8((?gU
zRx|;!w=_s=b$=M3?$JR{35ZZbjtAtqn}7Tly^}=jfQtXrA{`6?26F0vThD^8axc*y
z%gC;^LEsp+ittP<v5Xt;<-X}XauU6gjProK>nwb~^lYjZ;C;3APb4%?Y$r?JN{=<d
zb$sjnpOaMiM_=~__O^$!G!WV>uB`_U#$0{-{5xzis&E3{MetA(@G6I_k;3I^|2Z!I
zz;b(Dc1U$li^kikhMu}LPl$B7F<7vpGJAr&^(>BEM<)vG8?&^;^02(#Hh}T7C#&4d
zdeObGn0LyfT%+g*w)x-m@cimc?3Gp4i_mJllgo_D%2xNV+Yb)ShkPAKs2wCvL|~;k
ziNI^Dhe};*t?nO-D<n&~Q2WRJO8>|HAgySQb&?2Nl@@2>6C1|V&)~YrorsZrdDtLo
zX<_Ir`k*ll7D((R#95lM?7pFa4GYW=uq7<XB|L!N6d!A~HKWJB^zP?!hl0bpU`eEH
zmABudjGDu`Gbxvw7IQ77;XvaUIbFn_&OWk`StrPj$kz+=+oFCyGV*a8-kb`nlzfzJ
z+PQ3`4vPVt1KMa4651taz0*5xt(Ta@4OAn#whYrq0gKZZ$1EfMapN-s(l!hM(9tl)
z_mHm@U-4Ht^>zW$McImjju-(eYOjB{UHK;QBXkw8-o0+@SwD>M{7o#$+A`@`7w^Xz
zyS=uo;Kz$%o!zzuTqJ_$65Wx0$Q>yIz#^EBfJrKY{zS~&5R^-Ag1puuiibcT#K#XV
z@4oP(z{xWgYU7>cdg#HDq}C_u`Ev(L)exa!%9(Fe2Gh-#;`Py4Srx@}iReCp_V0%-
z?C&h&_#3iqz+G2c$zH`R%OmTseX%`sI*ubLSAPJ4K^mhqhjq;<SjpRisv1K=@^vWy
z0lZ`B__dfTa@i#$p@HFu0^fP|o8duTf_?#Sm4xoSG(HDj0xA^WMGBnK8H)<}dR61U
zR8$R(<3e^{g!0968<S^E9{6wLb2lkbu`Es$rsn%3vofX#W_5nzP|ks3R#v_JMVG96
zTGo$FdgnG2F)S^L$naz67g<qJ1+i9-BZ<t}NNMA3Wzyw24MSd;$RNwrGrP`UN~oxO
zisfqnV*MQT4L%6gKW4uKZ2G4}S@#u-_bt*vE+=wz-hsGqtf#N)S``}=H|?bul;*0>
z#P7}+@=8?+#{T%f;9VYgczgNTo%nf+nwW4F++@Pm>JNAJ%?(wPhKJG`5^6*SXbCC2
zBE8Ld!oZCM@!PaUD<H^agEl1%zEQG|4c}1UJdUi>x6~)Jp9bd#&&M4Nv_cx>`jFgh
zc(bQQf`s39uhBA}Zc0aCuT*R=a~4u6H^;f}7%P(xi}ApBY`j)~_#Uy%fjqI@!Fqt5
z3?HgGLOyzf-pecd@fFA~Hz}~sl*B6egUA;Uta63ro^C9-`<CG8J`NSWk9*iqpD<UD
zlNGsC7jo_Y^zmZP)F}3KB4?eD&)fegGYGQ^b8h6txX1Ll9}5qK>Bj34r4mmZ7Jj>_
zLojz^F$_T)LXI(f7j6s$$L;ql|5b93pa)F0U6L{k*?sWD0?TP_+ZpSIxEcHh&3ur(
z801%(S9N%E#Qd=0gE5p_QNUaOboS`g7aiL%5HPc`b=FLu0+f-(xJ8w{4x|^)#77|s
zXmVvSQru;s%R;LMxd=-NP!N<Fg_#UJ_FO$!d8ck5Y|^;b{!|Hy+>tX>oB{ng69QNh
zsI$_Sro2O<zTKsL@}Aq2R6+7q_|a;JY53;%swJ`G4c`c!ma)-{z)W84Z@ja76$MxI
z=yxTSbUe*<4&x|J(`(i#&DCIJN|~@0N>gF)iQ35cpfshwHQb|Y3PwXway5i8nN?^I
zOf0TN7c?~5KJ|9+owff4@Bk5XJUP=e$XDmswrfZBi@T-@p&(c%HGl`5=p8FI&ze&|
zWgLIq%oLX86Q*RQ$~93w>H+!@$?fusWW>_VHMEs&<&gyt_!FtQQLN$=66j0%u;%{_
zTI$Z-5rJ-Q<aE2qZ=~riIji%j+~y*T?2W+`wpDBWbATeVb67qi@Gn}Ee>vRHKGD)#
z1(C#mx{rqTUH@1Fzc}j(+nc)5yIV#ew3;D@1z;xceQS$SGxCC)LPw*qySaCE?WtWw
zb=Sx?2W2__X$v#tk2JDswFDZ}M)!u8{?lmj$#uwkStSv=y|$`i&(wk^+UT?hEEtrW
zoJ?V2r|UUAw#STggEn$6trw*E#apj$@17I@9X<HK6ed}#Am)|fu>fNp`*~W|`4ylq
z<_P+I5K1b3PmO)5aN7hsp|Ey8;hItZEp?-hM7+`$eqk)fYMx=1nu)4PC(42nA!<zK
zm^)$SGMVtc1QPB;!QL`U6>D?aHT^dRHFxn#NcgA%{DJH!0kG1WQ%6_sP|NOo&}_L_
zahki(NDCd0{P5J;7`TY#xk?Ov5ENCklgz@2vRze?Y_&R)L6ggxj>`4`%!n(v{nKG)
z?}pHD#{>MRxZz^(m<})-3O$ZvkLG%Fs4j0bZpdZdK;-+*rZf&lLs*QTaoe?2$hwK*
zve*%NFK6;2)>D8Nz~psd$n*c#<;@qEwiRl+yj{W+?1KFStfwy?;V+2BjT6M}QTi=h
z@;+`0jmo|P?<71$&dY?><Z{y`bK$bE_BiiFb)T8zX3NGnSZ2VuM6FN6f<xfQiPt9`
zf?X_#`Mn#c`p%=yiHc0&-Z1El$Y4hin|+n#o*QbjHve3s<1*OFYCb;xRO$tfMejdg
z5B8>;?epoTrlkjjq#u?;&?5!n&pUAKb>+vk&d7{LEW5$iRmfDwhqf6?BKN=rYN2HB
z=)eQ7eR@XBMVt5W_M(vnYGH0C$4{%g7JVjNu@*6rEPpf={DyxNZ<KfY^NU6y6vT>c
z72Z8&Z;_TDNeacz|8!=N9c&5=RQT@%hTm;J98SWC-oS1ebE%(Z6%0KtqYFP?CMNxN
z8BjU)0a}i-^6#_%GeN4nc=fZV0L8Kt<p~SmC~LI%?$<^$T7q(zYXTNCkS!90_uS{C
zJ1+(%xZ#krQ1(4;<`kIxZ9KH+?JJ-QJ`hI6ehXF1_YySs)MkTZIw4qB-h4Xn`+DRg
zA^C-f+u%n`7Lvfh>hFgM)9u}doGZSrntDIFy700%b7Uf9+>`-v8>hJ8Pr2BR$S1+M
z(U5q#*Sd!Dp)VK`yh<Fe6i^Ss9CL9I{qw`1l$|VQo~5l_<?0VvA-_euJ(1nwA5!x}
zPA{DhcXSfi^`&B4l*1BP&G4bihc`&bt;ZlRy<+A4?G72T(;-&bT&9EEA@P;`=gANR
zlbgcrgDIfaLb)&!@|TXg5_!~$*6>D`ahPkmVM4rrn`l+#^d7|SBS0_$60=x&uc~wW
z+_PV2C%8>klM&+I=3v&88@>(LE|2)#J66ct#YDHO`*J>+$_iny>~Uo58`b9CBKk_b
z!uDZ`u_l)#jGV?SC(Oiyj}hu07QOvRq|{O1Rh3rCUwcKsysJ2A*Cleu4yq!l{aIdN
zwQ2Dseh5uCO~TG8W@#w7-mk~~&HH|%R^yWD%$>_i=i{7Nd8_33UXotQry+sVLpzqr
zM!EvM4Ngvp>U#%_ML!29V4qZy^-jQj9D7<9vojbc?Z%4~XL(lgD#X2}z=1HtlVanj
zD8I&<Oc{vZ*{S57Y9%gat?rQ>ND8=J-^>?Uv|^Fo-$Oi;UW)3lKv`S~f{1HW{UY-#
z{U*;uF>w2i@XBqJnN*8u%s-|iTfSIS$ZJ=Wh;q5)%m}lbl<s0U2$J18+Tj+pGW>v9
zX|vtVDA+xE8T4a`8Q@qgmyht@lW6io+-G$Z*F~KiYHlg}!!n24haPE2b^03Vpcc&Q
zW0!lhbp7yB3QESV*;a3LV3*jAF1u?Dp6ebXz;Eue(24dXoM%29Jz?n2v7ExY`1pYt
zeBb*paSv}4MMW7zUVfwbT4+T!+kIQKuXEP;AW>P=vyX1}iB|qxwPV3qQ~5wR?uV23
z+R8^t#leK%qsBeA$s*isclfgmqqfZIQSa@gerM|lp<JO0osUx537-<=USM1QMfrm#
z7MF$v*3Rnf&#??0{MNk_^%VPa)P=i(EOEHD(kYhz1KT?F2ee)`?Tv%lm8x0tY9um$
zdt4I@%4<5Xk$ulcnNHhVYzxVl7~L2TZi}0_JBV41q|R*HrBkpveO4HBu6KU1Z#~f#
z*SB1>1b{>aCR2UpHkhY`xbQnpmVAY81^Q?0vSwRcOFbD_oxD#Yf@o%TM;ls(P7Lk;
zZVy&IU-eqf(qz;sy1$%8PYtxCz%qNn^Sd2&FAPc;{e@@t1VP*Iy5zb{@P?mX-t6Y0
z-t%C<!lVft?~1QJWZuRwkdV%S8*fb|{nvWVH9*zAX-C)SsglUukONgp2@leuaYD!O
z)xmbl2jcEtfa7y;RQ#SRMa!L(6`Ml^7pu-sdqS<RiMt}}j3NwQ41)fBjSD&84v|ws
z&aj`<PKS~UP}ZpbgY=r2@rJr8_Vr9^OMl<2J6mto94;ZaZfstl)0sK;;aJVe!S_|%
zEiI>RG55>d^R%()ijr?J^b&XGchk3aoXvHb$;~~hj>PZ9=44*>UDWPrKDx9mexS+y
z)#mTCC3wp#yCv-(LI`1CSloY=psLg2g&OCWN*Liw$!&3mqldHb@Cf^zTrka0HysD4
z>nO#T)pM{$96ST8D8*fTJ%-=7G8d9BR=71HP&?O%w}07bN>C2_(=mYF-3Y?e5c%UD
z(zHHg1YFZ#M|dE0flRrm`gHZ_rFuXCM)%4DC*GpgcX6EME%JXViqQ^vv^}8T0Ck)*
zBpJxkG+K?1>l<?YEnD!Pad{Ka5xsF?%F%u^HS2le-~kO8K1<)vqqnKZRA*j?H0&i_
zY=?z77S64T|2o5Ro=_7OPYZ{k9?j1&b9ry3ro*4h-lxt9{UY$zRs`Y$wyb3JWoBJB
zY~-0TrC=?sJa3Qa>)(Ol<Dje=U{Y%sl~LbEu@Gut!+{BXGB;he$P)M{;<!ufcT}%A
z<41<xf%9iIr5WsYPL9HLAnHT@`B;7_swyLn{Hkv@5_Wd;twK99CdQU*%c?2@w~HL}
zQYP%Y=J`pUi52DH5n^1+Yc7P<n%rDHjvB6%NNyr6d}~BMkx`b{7P)<*xrO4FSMCKb
zcHcMw;&XxL7MZVtDkJv@+bNZ{#?em&$Z#pf=MxB^vxF=&#BHLfqg8@NQ#SQy+u<1|
z-rio_$3?X+7_Sy^ZTB{vjPO*dEkt2|Al(AXc=`J3lw$o9_2X0Kjq+lSs6y+wxVd+~
zsnEpd^pBVuiIos9Q`h~DtYy$fhhs&0_F8u%D6oDmS-;~UOtlzTWMiW5r5#~eA7=bj
zo^>au{OeL~%^M)u2QWivo_(~2SO$@2GZA!Ov1fIDh;M6-H4{!ynZidp*$E-G1p>(p
zY(gvY_&pG8D(1si(_RD;m?D&NJ9#*h+d!r2opj<X9rBuUunhd1^d%@fP2`7JL2EVU
zPcoCBxT$;;xTLxm?vW58KkRHFMZ5QSLBZ~ZnpnNoDBDv0nGVdhC7O4F_wuvW{2t`+
za`x54^D5bqvmVw;j$02<e9quaPH;~A4%usmN4&`en$+wSSeS%V!72g81V`8e;n%G6
zzH9!KOg$kZWb+f*Z1O}zG@pII)uJ1`p}4c2>m&5L5;Mw3>wlN&7Yf9CJhrm>^Q`fV
z7BzqqKCs$z8;iuRouMb_uQ5jQY4z;Qp1I*Mef=W6W`|X1m_F*S3|`c#YQGZpONib4
znI=o=#PzZLX#!Jot?%B1s5sM4mNW##z*lA5_8_@)5HMkDZkogYYMs0y*q0*LPIBn%
zm=f=?+&U(hPv^;~&HrQPHUKHN_0WfQ1vifEIG>}W+*fG)3*?+MM(+6I_c&2~O{bst
zkGDnq8ljYy{1}ogSn_!Z8_*tr2`HZwfb~zu1fesU`FUW6Wtmp7I1pKw^)R@G6U83M
zSsrq7uKm*}`QO$}|MP3trVjWa<8rn6&vjccFCB~_VW)<)xGU+^Iu;5XCBQYQiu1Z8
z+kNp>Xkvbx<T12%2|LgjVDh!7s5N!$Rj+Rm8lQ&u<~)=kOO~$;@^X=LXYX6z*NPcI
z6Omg`1Ev7~^I~^-1At@8vzQMw(*+4%T5|t<z8!UtJv%szI6U>Srl!sH|4LqeLHNl~
z4s7e<(rPBp<$OH(NGAo8t}nR^nD7fn1~SXFIfA8vU8{q`-AlL0nHY`$B(Wf#q{pE~
zj$y(n%@fg)cK{Zq33Ta|g@%Y`qtv3UqEofJtp`j=wNgniV!;accmgiM^|G<71b9*C
zKDuf-IZn>*<{h*WG&Sqxla@8pn3HxK2;l`H%(Jq$q>x3M+J)W9e~Py6UBUQ(7MWR+
zO&q*(v;L92eU-UuEJzC$c+ODgML)kH*ppe4?d9jV(6F#VN=CxWX&el#o!B|2j{;|n
z_DOt?g|Q5nS?}H=G1#DW8cK%`te|t6AKy2d#3+<Cpw7<xW@p7n-}i76rL&7*>HB~p
zE6GNXNzk>TTB@mub0dNhY>4@Oyqqz`k=T)Z^JGQM$y@%I`n%~qqu&IH(zzglPaQ0r
zoaZl8TLMQjF%sP$g$OpZ!e;nSDmCEz^n*J#<lA2XU!v#zFxBz3i5L&Uf@5K|9ST21
zL*EOA2{QGnC^l7_7?B=p;wm>x3G1FYS7v}-H$RT28Y*7v?uQ0C5<aZSsQXT$Xg&{r
zZ-ZLAO*>2llqLRQADK4Hx?+YyR=8&aG~snPCvx8jGLuDbG^!jp)qDG<SE9wZwlh`A
z>a4Xnju)m?w2j<p!YO@Go{VrU4NXj-fRZmt3s<kbtAhl4dv~pAA{vTN1Emepb*cX@
z`4Hl`Ju?x=+t?33-l8nCpjj!y;z;@QgKW=$`$!DI>2h?^EwzXfRvr8D4f%o<=3jq^
z@Tw!~cB|LvY9wJDAV6w72xHY+E_0Pz=$xhchA|Q)>o*#J=e&%lu7YCthvA30?%oQG
z1YB@T23<>_DK~!$7E(4o{qJ}Fc^SxOx`-Gg_1hqxqetgbB6jNk<pN+fq=yS+9$mC0
zl+Kkb&vCExk1SiRCcWER-%k%ec9c`;+_mj;CC(MAc=lk0w`~*S+Icu8>_gBU{P(%<
zZI*j#iq5AB#%m^^8yY4B5JkqFK?>veg;?9ebX8hW>oN7qjOPmFplNg2rg`s78Lbv2
zvE&Oyw*U=5x=Y&vfu$;-DBgcvbS}}{QV~gZB|a|tHUH5$_)T`_<Q@`HBbvAvg?~8{
zy=wuUu);7)$D0-sP%^-T7cK0XLcGKXzxtdUqY3LZrbi^*VUx>d4cLbtzFHcSg<vOD
zwtYI1<>HPoWmie5s>uXP_V1I>HI@e{Y^qM=I)no;9$1l>St3$=xX%(kJgtPrWQl0o
z#P_to^JLPfg}yD``Hj8@I(b$3kPmJaGw8>JMvv2kyduEQ<#MqBwGI<}WbH5eX()xS
zhVSq4*J#0$XK^UCVEuQR!oIu$^AA-RDjSyq@Gf;DsUU)p<0p*SogJdFX&pig?KCAA
zz`W33JMZ|HWo~c)C3DcP)f+Ev%?al21Kk;uuwcQV)6AN9U0L;?>4(~fY`E!wWd!Aa
z_ylMmK7SW!kv*|9G55nA>Sv%sf*eExcc>!5#;sbQsk<<0Xlr|oIT9`)7@yCV4PE)F
zd^?aak2}u%<sIzR)|zX{v#PK|@#i%%5XIdfqA<21_nUePBa>1in2@KVAGLse+3=iF
z@O1a2Pvq`kXYcwC2Ig-Wkgk7*ZyjOC<Y*(v4ND{MtWO&*ClFt4ji+(oHi>cd*&eLl
zJnjT-CCJ*;LmXV?3ccEtcoaSAeB_g^@F7C>-b!VciG(5RvnGT5K{nWxk16V@2QJ;T
z9iIwXr><u(Mw$k#PNT-3qGDKrKmRMOz(4t@>TB>e;nnz6*u)<Pq;Jdn`Cg>BD<=d+
z8w8b=$8dZmAk|fd-BH4pNeA{-g<bZ3Ur~M8db}8O0IP3xN{oN|OJM%3bKcry-|J4A
z33`SBeunS+PRboG!?V-KQ@d&zF~T!Ghcd9g*1Rjf=9Vp4YSg=a<hy)bnV*q%aqqJT
z7ECEsy-qy2WpnI9{4D!cPF`2LdYO?mv4nFFAiM5kM}sh%8@nAhgXWfM8yAyrp#EK&
zGqSv|6{K%j;kLXVFl;sYYXLyL=Y}}~75A|er!FhhD2rXIo~3fHZ%W0aTBtF7MSo9L
z&AW2gus^?Q<E2fI?Z)?gxTgJ2$VdaGtcb64J*#Y=&#%d07W(Poy$k~+T79kVca1C(
zDzW}ne|--F)~}omXB#B+%O~<{|7;6Fc>z*J?Il4l0uGBkW523d@qSf)rifu;zwOA+
ztQyyCfbzbM(6zx>!~NYb=n|7gzx2l}mUq4Q4m@oSe?MYmF63yHS6tHzfy4De=xm_f
zDt((M@i+MagFuk!QWCOefBN}0*0m)IzgtKkbkYzL7k}wvs~zSwukFQ{_UCll$ghHf
zU!=M$TBY$e?C}QcSuFv)Es&O5RCjb|{soC6yN2Y;c3_B+eazb#ryqrT-`X0WX6%u;
zbg#LV)~jY6BgR#%zN8tqk)XPJ`&)ZZTk+$(vRp=~iZwA0aaIrK@XTcwrT7B+uD@&N
z_0+`AWS!KBk!`C7GVsR|%CKtKgO~jcDi{I-Z+my<5bOTi^xeilR_sA@g>n<-*aORW
zqN71Tqb(dOCPqGXIOyYPGwpE*b%EwquQkgNNJ2Z;<Q>e|(0_Oi>0lXOWn)038B(z@
zGPog;4emJ$om_8wlI_N^VE>?TeExuzQ6UKLw0WeMxDLpv!HvGb1k_0bX^GPrTu|Op
z#3D^gE;LwWIEBj+>}AOs`3-DP9kTf@V`WT)^8Cv9l)-b1IzmJA{dfhIP4q?#(~p?f
zpb$AI?+^S$^zF#vdLk#%A@Rz|d$rf-1HJH~bzK_f{QIT(ieW62%;&&5K~}Nakl%~A
zf?WHMBVJ;0ug7Qr<l8neza3%es%FZ$JW3{8<h(4_<9<KiG|Yktv8E(aq(eKrl25Ks
z0r?#i0}u{V`(zh-7e0%WHKzNu$8A=4=8_gaLDnK8mj3MVl16SqmJ={GJ}&wua$#kn
z!7F_(&jXk6`;~W-^&5BLBrY8idB_}<d+)v`Z=}sV@OQTa_p*7Py|jAO{OF@ZWPCKm
zq*M?{QF^W^(?qyfEeSY-7uq9|?ZhcDK-ijzNdLp;u3dD|7#xCJ&z3Z|VT6w3`R}sJ
z?>WF_q(ie^aSjY-wMyEDJT+^(_vulEW3#bRAs>w1A3qZf4y1vShmeHd+{Ih16VEX)
zaUT%xpP8utvM3^%dodZ>FA;W_cBk`k)QZ`cVWgIzifV}kt`7ZB)cP?f?>VL%K=sKJ
zk&)U{J%##7@y;MW&n!dPlB18_YID4kxkfl@#*xgpr~eQcog8)eP)YCe!|yHSkLOt;
z?+#B|D19}>0+>S_i*j7_M;g9G=bOMtq$k4a6=>tmaT_;f3oFN%vuhO90e<VBfe7)7
ztu+DetSVou?1bztMDr#@_A0FK;XKj7N};?9kdFSzxcpZzDhYme=Wg{$hNVq1%qtuK
z36cYh!AP?LiB$^=Px5oJY{5Zvi^&A@-|SB^N|{C{Lo8&@TyZ!Y{xwyGB72f2sbsGt
z`r19oeE&nyVoPpG&PH~PPUag55Wdm{H2#+Rdk~Z4*F%&*&yc;C5b4c8c-Y~@*BJc4
zI#MGAyy)X)Vk%At-#CZT6b+)o?Pl`T<|7-7Aw-*ca@HAzu27S`j^DDI&i4`{`_dMa
zg9Eu|x5>ZKISPj?%)m)nZc%f!<{KS;K6c^<KC*Cce=Axl+rUwVvEnqXyoR<W^PJO}
zBe^KotH;x;;GIGeal*G{BIJLe)u?|JP#bp)J-C{pm-fl}&P?H0Vk#Sq?WUW%ol6$4
zP~bUyQ#n(W$PufjB=vjKe?o>^EsC}rfCr@*^F8tVI)B7RH7-pdYsZXUJh8BbOk}A%
zrWqP35ia)W=MD}?35PuyN#w}sh;W8X(uObDMXgOk)uyb-KS|QDVJ%|;OtgI*Ye_^i
z$mmg!bRUWRabzr_qE$6I3WYx;7lSfPhmIPM*K8Prx`u`Erk&t2MD|=(5s*4wwn)D6
z3JY7cf|oFn48QgF<9b(pZms0rmn95SZHjK|7Kyu?g_pYyr(LFPIgWzvH9Es2zDta4
zw9hb8l{{)yiY$^Dog00^MsQ4@7_(HcUi-9S{WZmuC(&YcTr7Ky`OP(t&?2|`UFP^G
zT4*#<#q7yo@4z(`wb%WUWSn*<$ZH-sE(dF~Eqc*F<IPu4!ESDmvl?vrhGGXYJp~Oo
z_^x4T{EhKdPBD!6?h?HHb4>&u-%~KHiWcLCT5Ar_e6)N1uqLK;B<Ql_0h+hZ=T<7i
z<0UEEWW}+*OWidQ$YP9YO|CUszgOtRYhl58A=XL%e3@SPZ9cdu>+Z*C>K$l?@YUQB
zmaHDdla4~R3}k*=CN~>i3RN13#uU7AqX&RX4@)u*-zCORk-aH&%YOlF2d`HfEa)F?
za9;gs!U6Bc<pig^9zl}38GZ^+I0XGk>;ADDn^Cx9?2NQkrn(T$eS?so{7RgPp()V2
z539l|I+_E78Sx~mE>f{cE%s0A67vjD2i<dmcN+y#_0ioOc%icp4n9^&BXxc$_hDtW
z1H7_!j?BV6Z>^vDUg<%;3^~he<>dq_PtPF<`0ITf4aYVhoa3O6lv!P8b@}!hUAtN)
zVKG1)RCk|*Jh%5KAwiOF{ONF;n50KL7E5Y74Qtq0dS6sd*fQ6Jp1i|dz^&BdHg>|}
zceKH#3sdEPAA7W9&YQY02r<<cE>ZsaMdG{f_<{|f+UY&Ov>v1@w$`<Cib5B=|1+f@
zy(Vj^#p<tix14x<u9~EakEHc4LBJ2Kxyxq>wu(_D4LO7Dm`)d>zcwUBmreRrG|o*g
zak6UzYzH?O)<r>W?yYoHsbkJXxPtIg6Sa>m78*<xrq(MyL<Hr}sJB0S9{+2Db2;)|
z<ior+CNqJC&G|Ho*Is0=Jv9133A%xTuD$$_fC_Nb?OCQbTmzx=1vAK2;(yy3{8=%E
zT;LDUME9eWj(&6p0LIooPh^;E2LjGnQyOy=tloeIJEwqpT=5qPt4t?!N;P$8)?0jk
zsv*Q?a*v9V6Rnd@=?<L^{8w?xeayuT^uu1^Rv#!r&Pg1w3JGAfVVk%@$$3se9H#Pu
zC1FEvd*L7CsBai|5CFRLY-R2>1#8RRsp>3BX$X$o2inSZ$!^%a^r_EUZx}LT5K98{
z2c`1nG+v#G{Z~lRYfj`I&+q?#kEb%P%*=rEWVfIz2MFK+Ej;o2K5aH#9tSA-fAsrv
z)w*4WAYXQ#;Ya-X-Kt2QdE{Z0$RDN-#nnhDX_6}~EiO2!=y=e)i+NZ+*<cj93g?Y7
z$;kSqy+m+S0*U1!yI$7=pe~UeOxHf0DbAFb_Rn}5I0iTF)((K9BwMp04SshsU&U$v
zXf(=kPg_d6<gN^8)LXW`IOc|1n3?Bz#(gescF}rs19h`w4wI@2e(VjvFV#>jC8;o}
z%h07*E4B=*Ex!s{n8}&BxI~@&Efjc0s_M3fTy4F0vqKCG5^NbUL9YIW6lsSPF+j;T
z8F4ak;eY68z9)Uhz*l%po)1(J%6%n?6iO*m4y`nEfmsaY8-HSMPV0JBtNzBRXYAWi
zqb!4;RGB-;=+s^_K57l9hMiR)+ff8FGr9Js5ZpOzf$z(n^b~yR?-%~9DPbg`5l(zz
zmDCLUVfq~tDFWK9VCAL`t+5NO`7rME^4YgulL+_F*>uc|U!Ui@QdX7b4JHKp5>w@q
zKj~GuN0k5CNS6PK*Rm#B(qpdAqr?5PVd!sDd{t*WVcw(ye-fk3QhlnA0OXa+BvS*&
zET7@tcdkqe0#<L49)T4N#}pu_hsVe{;l+5~<j3v3&~b1G=T)i2cM`$QMJlPJ`B{F`
zn0W%`dN@+<IOr8F@AT^<5^A!ZEJ$fNMH7!m&{blcjof4K<?2~;HJA2Oz=jMMAPl?G
z5KLCl<+LkdNq&u_Eh#Sbw^{bq=sP$_SqXM#_7=18@h==}_^wN(R`A8}<(|-<3>X!9
zvU=bTFe6m@GW_*dqS`}+LbSifio}FS6Jz!nz0BNhkd&lRP{m8C+P>*E1(WD?j1<|b
zKg?;4?ps$J$fkDcPo0?+t9S0NYj3h(Ccm#rQD|Pi;^bqgk>=G9G|-nW@hu@@OPlp=
zIglRMD%E{YBbM|sJI_&2B|Bi-qu|VfA$^xjFYE!o@U0L~f_}68)1Cc0?{d`KfjkUL
z{P)5Vz8cqbuf5970u>8>em5RoQO<4@S$(eWO0U{V)_{NU{M%lSzcl@F=exnu8ACTF
zwwGrj27bfU8eZc%v)tR%_5p`mOsX+xtQ2;Btot+{T>s!*oas8O`xu@PN;796XTw9s
z71m{KcW9SK&WwYvO&g>nbi!=%YOgu2mNqtg0s|$&w!A5ug(qCHQKKyNdGz6Dequk)
zy09`v^wpn<owc^U)S4}=pIIZiUieNeOIoWzw{!7ryWZe+@y2rOpAfLy-&c7)-A9E+
zuG=kstnb8*$esrg@D+ZT*w{_}YzLCt|KzX1zq7{pI@CkvL)x8<B0XxO?T$C?a=dZY
z{vQ+l=(BrgJv`B2NvTHD$Phe9Z0GRLR&H1y=;t_TD5*x<w9HFrHOd?LbC--d4PGZ`
zv@D8fr)A8&<QS~GeI5Jum}={N<_=K*qR9cqUMVJFME|l=qq1S)L-xsIZox*%jYL*L
zM55;N#Gz{XMK9gE*P=b&eXsqj3K4GH;Z6r%)L7r1$$Fl5O?cr{difAIYXo>p#?}iT
z<)`e@7J3?<3eX?3*t8MsoVHbII3IMQ>$o!HkfqLN;<?q1Q<3^6RIC;5-wF7mXyl0X
zR_qF?%0|r7)8z4g=onCJU0q1*+xc7bct8gooc(D#5`#_F&R{nZk?#9+zi&ZVGtzXE
z@RWrGZ>&}?mYKR-&LyrtM3w7Z@YK6rDGl-+VOoATA!rKpBo}K~fM((i+YzGt?^3`a
zgX%E-00V#Bsq~ZOM^2RUO&RhUFQyZ5EZR~)drq0zok(jz_MzO++p`2+Sp9bWb`!@V
zxGcz-)&XVGjnzzi%~q8yY5CwDSUSu*UCJq_F63G-(^zH^T>7YTXG74E-C#WCzk_co
zHuCp!Z-Dx6+mR1^SJy!25_M(X>C%12-5H$OlugXV&Rg8o`hqiIKSQm}M=CVJ{J9wy
z)|~)0ybd=VMR@A`jqm9{;>o9@b_vKg%G5%U!vij2r_3dER5M+t<stIAMhTY`qc};#
zN}K7FdWpDeJoKeiv8EQV#Qa+jmr@(vi&g@9vA;#XD*f0Ll2223mmSyfOQSwcl>;25
z_ri`{$&=uUY#pDce<)B7gh=vt{{BW`y^jQbc1Jb!F?rezc5X%z@OI-@>9!U0v+j?;
z6O^g&R(NnokEadJ$g#Pia}W;N%dG7wZ$+8E7#i5V+#vRWQgjxTPh0k3#2X9ZF@pZ(
z)xZePS|99+&yD;&)5p8Kf7O^p6OJDT?~Gd8KZ?^R!Li(^AXQ$1n*O&uqx@+1DN|Ib
zn<Li;58571-eegXg<1_*Q#@QFKmJY8T>2SOxlHa^Vht6Odk+?E3?NX}y~Cb+uHS@?
z#ODu+Q0*t`CgEJ;{GxWtoY`-4JEwES50e9_*|#xjDT80N6V~Ee-5ZiP!s}eQH55xq
zEURCenY6xGUe*l!9(Xx9;?(Nq3VT%XtPyy>1+jhD32<pSjPu9&e%Ry^tXf{lvucsu
zn<B?3TdF+$j#ECC7?N93`kZ@p`Q_$AtInt^MOxJxdnc;ouDN-Ovx3LS%kI3f+4yt=
z9-jWPKogh3Z^(K8l7#Sx`v?d$+p_EY=fXu%iY%c9g+l$3tj&w5!#{qB?C}b%oPJ~;
z`Z>d?M~9;^uPG2$ZDg>Qs*&?Xo5G;bhB{7zOMh=7;KdIawv*i4;kvPx&3!Beyc2I$
zr1h-Sg)gShA}(V+`c|`B8j->efAG^tjW9DQQ6z<uBGU+6?DH!7wLEGw6=lckwrKV6
zQ>WbysZ@3&cGv0NckN*_k(l-VQH}X15NBCHSo(xCw4yBN`0w9df`F(gU}bIBo4=$q
zhW%ZDfJeI_Jcr{CxE7B*=&Dlu%K|ayw;};Ik8?&@YoM@SG-^|yzWBi>dsl+dd-?9^
zSXCuY+Rk`uOwX=2EqC}^iRIHzg|gmK{i}Ad00~^Wes=D1%fZEj7{+kcoj8UQGWcS>
zm=u;g`~KuAFHG-K3Q&0-S7P)Uj}*2NU^mwd@zA)JDJi)iD^F{nUN8Kr$M80X2Sr$Z
z28K{GG~D007}r8SUWr>j(gIR>8(Nm|Gqnu;Wi&cORYnpyiMV_qf{9qLUFrW{dqE0v
znS-=C0S^$mgd__Sq<G;i(U()KkR)}mn^({LB#u<l^@@yhtPN*=;%KgtQ!O?Zx2&Ax
zKoo~+t&Um%{?Lqw^UA#ZyO^Q-vTv7Jhg-9+Ub2Gdv!ScAX!%#%Z89>H2SQ!0oJ@4u
zH6CQ!_Tp&>>5tiaG44{QRR@8QC#T3cy&qNXx<&b1^uxZ=L%kw_!xcaJc>AXgUM`iA
z#?Oo9gDGM@)g4@OGrbHv3!(qJ9j$j`I%b>fm$FJXc76gpSZUaCFu4<BWdeY=@>Pz*
z2i<l{B8XeFWXvB*yU#KQXtVc(*TqQaQZJ3W0&G4_W)`P4EbgRdR3<noREXZu=QlRD
zH7G67j13L^{5%zRk#SbP*C2Mpli09%>$LP+HKnn7J@A{H@Qv}3Z8<lmrKzF1WJ_yO
zzrRmUQ+<{yr<+Q35AQdpV%0_LtB!ZAb3rW5IUPQDYEaqOA&)jTlyi?)DS_BPCU<Hq
zq~TB}{Mjr;YPBXLlsg+^W_qLeWklKR5=tuuVoFcp7$zh|-`<)G%8Il%e^D*?DsS&k
zGuevsqU@NFZY)35TJY&@6!QfM3Lc7|KZC}jI%aHE|AGSs5#p@p4P4Bx!s?i~O>4NH
zlsH$}dF7tebVMEVurN`B0>4=c!f!%b<#%6Y%C5)Uy?%lFELyte=9Fn<#QNWZk^Dcw
zXvuKu@OP~!4>A~uqts|JoxH)!)CIO+*LGkg5W`wyNn!1&r^ePL-*OF4&#(w#UiLWW
zNBD>`d;~5!D_3d7ZwW`yD$yQ6L-l*P9F^zE;QB7iXD${l5&mopoq%%1v~3>21;=k#
zD#t6U-DBm_#1cZ-cFBO1vT%bQ)XGJ(LyU{dJyaYq)>PHV_Ys2=d0`7KA(Jod1*JXy
z@v0tMHHt_nSS=1D3BLATNT9|HF;YxABzX)wBnJS@iok+b05Tui5t52PNjNZR1{9{F
z-x2;^G{g)-6CKBxS1bR<`wM&WGy@<Q#r^vy1*E*4+hJ(;18z$stH6gKP{^a!e3?P2
z=ATNw5_vGF_=MWqaHl%x4BcB%s-C|3)BCKS68|D)E?)hQj(K&I3O3SuI6`cRU=wKL
zhRNrCayku*gn=UR-km#9rL`A6`X~@G@<1RR>vM3%$&wmFVVeOZ=O|CbDMiWU3=K_3
zk@VrSV;Qu!{`nFMloIc$`5~8Gf)6MfAvy>bEkx|SohF{kKKn-V7d2Q@eeC_c54)<*
z6~#NG0<|8{CDw5YgY7tLt)Xq;?xb;_ru0xT3L6bkv-$!kiIhcGl;~pz@2YzNO{%A5
zU)1S3_B&loFudtNO7RqI29g19eQ!oqBcO!hGXK1c%;2fov=RuxCU1Pn^v~f3IZUOM
z@h`G_O1e0|czKgH)bOX2p>rlzmp8BHIJ3YEKSBw8TRJJ{Ch+FRv2)SaFR%C6w2(}`
zCz2k$&OY7S9$hv9y^exl%ey5^n(t?l9Mw90vRO*3^s2IhN{$w6WQT6*avnjtf&U`=
ztHuKR;8b2|^4s&Slm)q*$;@s?j6$HYZiMFee5;|gp}aqc9k}=^eC})i4X>vrH2Yl8
zBMk+@GyL-IGm<r28>wHoSUdhE@~su^<w$3w-4^#bC)%Q;Yq_7|ufkFDpSfQ@<yQI8
zER-_jlA2gk^egk@H!FX0Ei0iKSp2s5=L$()TS5%OV;zm+0Iw|$#JwW-H^zDY4D58S
zy<LhN%AHodEI`H%adhOj%Yb@b<eP&0hWjzJKmEJ#A{Z0%KcdH7By4a_*-|98tM^~y
z407OYGz0xYE}`!mP`ol!b^?Sj!K3bRZ7piGY`v5?+&S%j`=`gO{xe{O5XJ{_La8Hb
zd9Mg{RRPakoh$Y2suV!TS#|vH`Qx%9Hh-D&UulB}AEUhd3f=4R+x86749t1RUJVJp
zb@ZfPpvi&NbwFQAM!u9?Yk>sbzW}y$S4W?n>|M?rS5IZ&@UNt8mrsKb8k*1!Eudt&
zfDTkt;CXRJpo<Sig06aX#*!1a$4LavyQK{b!Y3~MVYn%Tzm-RWSE$bUg-Q-7(u8wJ
z-!3E|;{Y;zBTwrAQ*QA#8t~xwVR-i6BJTe^9^~P!{PT&f3>v;;0|}!P89*C2fs2{F
z5xgWpQrm;yQ&5DHl1j-~*%<Nx<vw0r;^O!t*R@qSfmDSRz(XV20R2<X=F#sC-fCu}
zxlOep2ltKa6)Vbb{qd4t|6V_RSHeLmX8#tw#$IsEp(W7ErG6(q9cLO1!Kqie+xrr_
z+H+w={y7p*9{#?b%f;szSPV<{f*E<s7g4V`8A0J)SWHMIcPt4)Z8ZU83jGrQE2-Z9
zxmoD{9srSV7(#;dK?o8L%I|~<>(wOU2Edl=wlZO3&CfG`mR>pB=w^%vZ_UbQyyNaS
zzO&^-GkMO&1zdD^iwRHi0#b_r({(*;eFKIj#^@YdOFC;(BgbWp#@kUwwmhrO<9iUN
zbY?0UHj5qwMph^gB3gM4BIS_Zo<SF)pU&2DX;&t{1z`Sd)+sBTU!LER)p7}W2%H&s
zt&IDFS~GR690xv!PXwz^t{ZElQ*jY(cX5e|V_uT(y0~&OC*%jVaAUzW?FU7kAtU4G
zl!t#J<02+9GA_m=Hp>%`kujyx+5Ephh^c?{y{EjS3q%#x*-_XmpcQ0oW0@|u)ng`a
zQOb3TX;A7uqd=H}w^_wn8ooR~u;85f%>oB8jbmbU#usxBWAAWi1v;y(?oKtUQ%d(P
z;8bz^mkGVzH!enl<9b1t3U1YO%Z2GSfu-BToDtF_Fr3T^*q4dCudz&>0x`=M+OJkE
zDtS<o9amZy>Vs-&54Ydt7~qu7WN-<u{^%5ba>=Rm1_P;ILh&8`9+eYTxY-kpr+?<6
zc3N^;$!qXivUXl*YpBD7YqGOJw$8EOf0k`+n!7<^{rK$**!c?}nF+Tn3p!ACQZjL+
z2x~QkFWzZ7_jVeKrM&`@0!xKJpPR1IvK`GJ1JAXRgj|todyBqifm`<m8+%*Nct1*k
zl?x|?K^=KU4C+Tk&Dof6xv@>&dh&lMK>wer`uZRdQmkdrBdI>TYf5Dugb6SIDNNLG
z(cUs$wz`m08uwOk^|8)R^*MNn9qd15Y=#ir$SUU5(1jYj9oEN&UtxDH-o`yNXf_-*
zS1Uaz3;EZJW$cTnq)#n}4&k;>p-ufX7Pq+N;SQUEpUI?uTU@*_w8N^s_u3Ft1*V@C
zlzjcdZ~WM^^Q>l0PRZJqXvVoPo3Pv^x4HB3p;3Fzuqh?1A$P#Z{~^7$xjhol4kv_F
zy4VvAnIr}>0!_Gnc;Bbf$i5H9Zejs5sO=7oi3g(8)nqR4cOQi<hygMxX|yacxbeAg
zRYXmoEk}avh50{K!hRkeKBH5EB@WGj5Eyb{Im-fmsWN-G_^YKYlS1Oqn2CgLr!l71
z6P|`yF#(Ek=JW+O@G1Y@XD?)6TpyIA;ZN4LWt&M<LuYblKsxv}jKtCZ{=~tUb%aQr
zdbG$`><~ST^<qMp6Gs`cx!4MBl`|(Hev4}w7m<!s_ge~I(?UA5m!GTMol)w(<ixFn
z@h9X&J^ZHO$56qa{vn~0l%r0Hq=PX1{$}BeQTaEHqY7sKeNWO^2c2lwd<Co)2}ep{
z{rjJLx6}k&;C&4Z=xR9|*b>K{Xy||qEH=_dG?u@r4V}flT)+K+ymzGpxBGKU_#fKo
zTB1-ol_-X9@fPBKk?RQDuDy#_&;}8Zqi8z29fx$(=a>rS`ug~5$;$3_@lP6xvM#H6
z<Lja0%TbTjL~ZAb#*l@y`+!XnXI{Qdd-jAZ<o7@5b1{^yP4iFownP-zc0mNZ{rmqh
z_SSDvM%~{iEsemCLkI{mbUAb=r8v?O(m6<XcXvpGv@}R}cQYW}-Q5jme7@(L_xy0K
z_j&(>`@Z(xYpqYM^Y~J%|8)}o*Teq*+p$_V{(D6lBl9Pv&?zKW{n5vcJ{~^hMHR`4
z$BVoXO9hEJfl*9Y5gRQ$M#iR=rya|_ntiMQFa279w@{50NIM5l!W<b5C_}fBvw^VA
z-Mz_L$I}``shR=_i!0Fy=mPeTqEPtbJq4zjle}h2n2gY00{JCvDvOs9r0Hd6#xr$`
z4;GOFQ%qB?BELGC>OR)jx>O@*E$q>}nB@ND*}dMI{s!Lyn``5~kuUA7GH_s=1QHPp
z8ts@8L`hshPVGX>nUlCn-f=qeFX8e@!zhi*WDX$ZYJ$5BJ%bEQ2$Stmd$Jv`sa7~$
ze!ERCWOCn+P0a-D?MRL5jnD~t5v`59Nw^sd-g;Yj9dn)#@$?%$Zal?`Jc`zz!`G$j
z8dm<7vFiW(dqwr&r}o7kuT}Z!o#d)A=GZ=(F*k8CLRtqrK9e}}>OO_V{E#~E=&sGj
z=n!dm*>bmZ6!~2WK^ikX=Ddt2+jeHQk%KFFl7+1!ed<TfTEEA6Ex@sRz~5trQY)E|
z8t1LRk0r_7^HlS-XP;0^#KqyMVT@wXFezg7nLpuX^!%qqL>C_be^U_PA$eBg9f!5;
zCJIQ!*m5cDKkzdh(14fQva^lSYZ<NRa#o@gY=q%b=|3a~M<F`w+jFE@omG>%+x%LF
z+V%u<{g~I=e-yoO(`6CA_ciVxS-Z6CQtkzgD2vfl2O65=#n=-iPcXQP?qPkpeuwfM
zeukEi#HCLDy_gTQKT-YLL*8X7!QzNtK^(bR*gT~TqeSmMA>~34i9BgsqfaE>wf<CW
zmzEHF<u`@O3^e<0VXRgWqz?{}VDWR0^x}4waElrFpMLFsSJnAO{<SJ2(yIFmDA)f%
zhO%zlH+TiV`Yf@_A0#pCoAUmCa+!C%8Zi+?C~}&r|Gq4PIPVmUfWyGT8wBRO)izUI
zkTZzbHZ<7m-%HrSVHg|*CrRb4Ip107QSxK849FDzon;9m2azyp8WS)=xeIJH<?iN8
z?5x!%e72OC?CCQkJq@Vf;fdJ*O{tnV=yx9aU1JyW;_4~6jk!hm1Z>5YZ&BYMB#nJ9
zg=9~BvWyK6N$n!zwhclbD<Z8i_)W=Zsb(RQx=3y10rfgDg`n*E2}PRi!>=})21z(2
zbd8Es`Ub8tPNN!x3B3!$0L0Q58sPt?{Sk-hs@<l&8(~Dsq`}x-_j(1JrmD}ZM)TVd
zKz2@yOd9GR0-99`LPeuINK&E*Wh`&aRZ?A1a=iU5AV>7CRV?aqI1GSKCbM`x065mc
zgV?f!73+naz9x%e3@I?ad3|qAJTPT_L>3nHoeLe2Kz=0>#~Nky&FSIE*wVpA-aj-g
z@5548O7)@4+Apa=<plo+#j!QfdmC8WTC}n^W&co|j+if#&BO6p84W&`q_ZLQ(TZi{
zBb0hhH_glnqstLG)&R$!7w_j&J{CWzl!R29-XSAhD!*fBQ5lSoOsSSr@t$5d9D8up
zr4q*5!LsUD<Q+9N+gd48;3SfEbwdv5POr?;tDMz6z-~7YO#+nuO#k*2y1?A8`GV3D
z!LLlfDKi0yuv{@;@Z?D!X<3HeZQITVrViO{R=}U@V3meCcxx&NuPGtxYSQVRh~LvR
zTuGOZt+AWKBeO8<aqIP*E)es6Ze7(yD4S3f9<jcqBa<05CKYZmFKfR%dlU#QwEh}y
z3`EsNb|i(!5UYG1N6o9;BHNs?^>WFilUyT}N}BuBxn|R8Tz9r?<UNq-*XsCmeyjq@
z>UL9QgH`j&?nB&Hxl(kw6i1C6>`gs=B51iF1*6;1!wK@4g(b&fu5^h;uD>E~Xrd;N
zfUy&12ORHPzh_PUg3%<(&~{z@g*3Az#3PKv@h5a0Idzn<=M1|kvZYEEwHHt52K1~I
z#!u+!HGE}3rbhb4s>~f=8bYC#KmoLUOGuWGY^3z9VB{s;%N`O3Wy+q@HzKG*b_DV#
zVRKZL3rsy`#nG*x{7n|p2Yti6@NnKricBm#`;>dmcv@e;rF;b`P<8mXq#CVh>idRC
z!BG&Z(V%<4kMIC@sylnkIn8uU8Ah<PryP!9!t2`(_%(j+==c1~41atH`5(>we@~>|
z1?vTjKsQtaF+<Nt34QI{d-)=8%BXH^zQH`uNN+Xut}82m3-Kx!HekLjZk<3FpIki@
ztEGxCAsxD!df0nP&po)up|a8xc#8y_JNqDsvfJk&BE-6&DmRVhEX8K98S#SSM<;^4
zE0WFVg__~%3^W_kgI|mUanKgvzZ_;C1NzLnz|yk+8{4U%Vw!7s?aYYOM<@1*9AgaU
zgDRnR{9{p|+tp0hftt?!>iNE~!$u`1;(Rf^SRK}wh5l)apgHr0|3RH|evRA#UJE`#
zyhN~uZc%3$*g3C?Z^i~UX*J+wENoFWdW*el|18JA9F5rOre&zgGq;6uQ^hi~+>s=A
zjDTt2_Sx3r%FX0VeZls?5f6QghCvMaS`W$oIvT~q;wneyz3x1Ii_>TP%o8J9iW8wH
zq-xW`9?L$#zA>BaZ}!+60Wd4yo?k}DAzGm@=Ghhx;J}d<W_8?IspV|r!`_3c!m@_3
zK=n_bFN_D8V}gNtc7m(dTs1AE(&m0MZ*y02VC!9xNy%0MYe#!s{Q*C)aZz7q793Wj
z9QfMBKQR4{k$qd<)D$FyYD9Q~qml@u8dOk09#WH`BgD}Uy79e=c)jiSLn8K2CQSpZ
zSY6=&)77;`C+U6KJ*f0s=DL)b9i_)#!J)0TCouzRs9`9vjixYa-;KTJ^S)r0>o6Oj
z6MVpNoZ;o9F3r?E`nWTTYH5XFu;ggpSjv$a@m|C=bT$A27}#a_2m~gzRYk6{<r>Wk
z+2^-8jgf&|)ZI@VZuInR0e(-yyZhx`M!6-pj(BpM!o<yfQ&W_hI@_MZttUG~D<2G@
zsHq1uEF}`<z>&;u0%eHo?h&H>t9u(qV{~MXXL9MLWZO7xj72~`w~g&w=k+`-*l$5?
zY2Z!5pNnR>_pNo2TuSKGgzy(7Eg0fO4S$5&qDJ?U^9?qb(i*VXMDQ+KCSl8<%3!Ug
z$j$G;FeGz?<V3k_YRBqtQG(_O(=$=WB(RE(RNUMnjec`9d@ZPWVZEz>v#sCqG-9k3
z;FyM*Ff*cHTOZwHFwn_Nfsy2)6{j~{Q^82CPX=C@4SLuGN&efxRucaQTgLyt99kj&
zp<+zNoB!Z$3f_M}W%=sfDh?YjQiHME7otH9hw5<U4}d@rH{H0op$KTsP#?U+Onv_9
z&S=?&`TgEsuVZLADq2JGeeHMElHVJQhg_T~e+@jJHR5s>uI3h1+&V8e@H3NVO}PyI
zHGsSs(Fh}#mMxO6suqxPzBN*q2ves|-cGQKao<OER+K`Kv|vn#uB5m@gSy6z`mPvf
z@Bp`^%;3t@JeGsN<jRU-9gI&9X<T-08i7Df*`T5U*xL>epF5kqz3rSk>G+nz?@oYP
z5{ecmflA)L_RJNY<|GgaU1<(K8@IGSur05^m&nS_F&VKp0)rVzuoyWC8<ewOj~ISR
zQ^5Gk!0>@PU~c$s4*eXSv8bcn>BQ@&wjksE47MM&oJHPYRKeS5_?*{wXTf3XhDJx2
zcjraZ;J4W*^HZZ^s)5p<))jDtc$tyh4O?mOrxJ|KXuCrIR)y6!ev_JhAHKHZ<r8wI
zH*Bv0`lLFyo8?R3SBA4M@@;@qf<Ms28V5_&O3%ds3mAe#z%+e2mc{0rlm>`F-q@uk
z?;hsMEn_3uvP32<P{$}5y6Yw;Naby4(Q<Ffl%ASc*__H5>Iy_-cX-+G$X5Qu)#36=
zu)`sAHcSmq(N~r@X3D93m%Q(^o6qz4oKNaOh=T}oEI#?MBxiHf%_<ktAyCt2&>$1z
zMp<<ML=W8fREZlvO@8WOlD74gM*f}kJ*vsoVP`LDvug5OL6<q#*>es#@bo!Hab~VP
zM{zi-{nL{@UBk1_D2`<;?}z1w;c|ZS@}&9})0i0#{A3;_Ev!X0Ui(R{9iM9(Boa6T
zjY1XIC;v8We56+u`Sfd)?s*zU5(H%K@yMy~r20BaIT}_3lO&`1<?VWG*Um2z7*nT%
zx)6|6e$P*U6*iml^{lG(bT!o#<;(u?p|C&97~JLu%S2P2?PnEfiqPb9U^>x=LYR}Y
zCxkcb5_rwZ8vhMCq2h#JS87iAxnHmOvi<`VuKYwO%@v)w6Pk^>pI1~iJ0_bHazL))
zf;X6INIa-@+tx6&`DGJXuvFwPOY;i;j0soaSY;dzTuA%b;7Vubq_W=<PRrci#TN2H
z6~@K*&`+g{Qk!Kj;fMDWD<~x`bf+!1#1zO%m+s0=v-?3~Pg&oGm1ZH?<u)Ynelx4O
zN@^jWP3eUF8+-IQ0Uq`ZWaXmQr{{*S5;#;yGF__WjmwQFaDz;cSz`-=o_UJ1BElDW
zKj^t0USxQ}=U*wx@*CMVr=3HmTm!TE+gb(X5g!lH)(-&s$Ce7&1~NQ^_lLsBr`JxM
zhQ|7~?nDi0NXaM@C=ry_m)IT04(-NJ0c%d*%WLwVS#Jm+IHT_vCGF&HglimdwHKCl
zGk$e{vC`?)C7Fnu`9oJx6A>>AhWldIupyc6R{PYV5EDMa<JBb1tt4NElEiR3wf8i_
zqv<&I!|3X20-32j!g_LFJCf2Tar5iiUbP?DX3bc@kyEyK5V4be2d_|oWg8iCg2iv&
zq1$!#y7Kx2NebcJbW@VdL`E?sgzHGXb7))dZ6;ohniQxtK!X`WLeczC@2qoSDIhCE
zo6jD@kfgQqzLTI;GnB4AQFMK=B<%C^vjU{~l(si1n9p!Y{5_@7ydBCKpOMrq2%I<f
z^%0jKgtl(W$4$4o*Q{U&g|KILvv&QPROLsqzjMe|`P6=XRBA)`j?7-D%wf#8mi&=N
zB|$;QWZ`LKJuA(FZ%s51vw&5zOQHH@CSr5@S(75cqp~Dujf@g~(-rPp%q$9)I*ZJD
z>@(+gHWCq=7Br`sD6%aGUq2_0AD8nloxTznUvudCQPXLuz{Qh66AFq``XE7z&w?5|
zYhe3?jN^)xAu4ow`$$TT+kT=K>J|UvVw`c>`6TR+-V8@9-Tco1a{OZ!G5l&}oeIBa
z4nue<z?&K%$eg<`nGPP&UAw?qXfKq~=rN4M+1tn2Ieu8YEja7HmSuz=d%0bo82$gc
zUs*{CUSjeOy+7Lov`4+QE<v&vPOksf>H&v_YjVHOOzxL$Q!<G?m=|zK#;ae?X9Mi6
zr4I}&ta#o5>7-?OYbSoee&o>|9LXk0k1BdUQ?iJ2+XsS>YeI&%geLHmIDZqD(cJYk
z0a8fRJ=+%rv1fAI;PD=4#z6=2HjPC;Ws)h<TJE6$Fp0Nj!d`Ldpj?YsipgS$g&F@;
z>WxNbgS&x53rCMa?pQ5@SQx_6TX)m{H1%@~Y1WrtGjDoGl3HhUzTlN^`!f2sNkTBj
zF7We&1a*%DkX2VW+{Kq5y2Cl78ov=JrJ0QL5RSH*5oZPKf0g#5v@!l|DvryT!Pi-m
z04KPMA<hqYPa>efAe=ULT&`L!n}0llSJw&t1ce5ZF|yz2bl)c9H$So{{ba^RX}ib%
zVmAb5M8y}!2K@KKNK?tXhe%2|6d0PXI{K2Ds(ioYN%S%UEFkVHCf;9RC=SaS=k%Ck
zt%x$CiJY8d?O_{|%5-M8=Pm3Ub>%@vws`J<N<0R!8PwgMUPu#VZGPk0f@s{TNl7ii
zZJH}R0!knp712g%2J7pdA=1-tYhmsYW9Jmlw@1VY9}82k|134tU`aqT5iIvVyxhLk
zHblDS2rwQR#gR}+wDIr+0@rwKhj-Yx@fX_d_Y?=hA%$3oY-P?@4awmi8+7KZtQ+4M
zqdtuzhBe{&bl5<2gu=AtF#g;+p|i5C<}d@*LguqBe(qdyEI$X}9m@dfUM~3)NWl2R
zK>6yswPUKj)m`*ao!ubmx}ff>s0uF8D645jbVUKHGCvg(7a}Clxb{7g%w&}^=(%YS
ziO(9<znB|VVm`(X8e}b2Oz(Vd32JApH+u<Agxwk*-YDZyyMk-2&jn6CK;;k&a$0ux
zIXXuHFSpmk#%1g@^({d>?33#rwb#`na3W|Ge}as4Y~fejCsvMyIfU{!X;1b5#XNbp
zNXzA7V91(O6OKwoENq=9^u~rQQJk}koMt+4k_>Wa)Q#pBk&*29Z1sNHRaaNp<*Q<8
zd7Zbdh}OYYR@^q98>-21jtY;1Cs)KT*bADVlBY|0s>NZU4^EUlL`d~(b`eotZ1IsH
zH)BOzuzqc@Z3qqnjtXhAv87QCQ`Jxx^qI|>@#dzDr+xAgJA0;#rh;4_xr7PRWr_&V
zO`zW}I*LI7qLjX+3M}Q!id=a=xzkz{l<WX5;vxkpQ58t%<x*{l?{}ornuEa!`?`1P
zt@@4EOGQXv5#8*j@y_1wXke-hFf;wP3_x9eD{Qi1(wgE9Prcj;%Wr?cx4BdW>k!OU
z1c(l+y1}#^sQB<s^s0e$X!MRD-|vc}YgTu_lTVE*A$7%N(8X3+*w7G*u|hi3R6Qhz
zh5Ep1O}MYyE#iY!fL$~UEfLnWJ)TwXK)Ck?_@%@sdTXbVoav55a+B2Myv9*`a@kn@
z+q%%rh+XI4q;c)b=3VSsMaj8)#f93LbE<L<d?=Qx-FMUCj4w#jp|{M(Bvh@dqA<_g
z+O{#q1Mi#54;3{jhdc~PPM(`X`Uv+|`FkY$#h{xuo6i=M6g$sfeoUu%fItkcU<L&p
z)?&zH8F9Up0|fzDoZT;xa$yHtYxQNn5lfO8BP)T;Lbwj_XNzw6&QIGv%Oe3DmT&uL
zG2PDQ-HfiQvYvHUZ4~CGt2ilOEADJjkjO3esWLye!P5QPPiT^1J7H58X42j}VKF$`
z*Ybn8ucL}>t36LFmh?P?=}z!ftf+@zP#qERMCU&Y${PYASO+8f&ujjELX$2gZ@-8i
z2`C6-o+fh-1qLMZa1B68p@`r5{H`WD+F^8rqEY6XKX}i$!&$ibk&A?&=D5q!lQr36
zRf)c~B0bBW2|h_RXiaHg!%)&<W{Re;!n!b;CUC>zcbZ+*%B)=yI_CK!Mxif0I5cUy
zT|tkLHt^B6z||6CX0Wp=I+yD_MH$w%JP$1nhzN%?TTZ!TZMfw9iB(LWaSv>nEf?A2
zDN9~g&`Oysle^+g`QFe#Qu@&5x1+>tM)u!k3pi(G`%leb8x;`;K^KxidMD<sGFA8l
z7*;)k_FV6E6_>D<j(jsKyg7!G{Puc(&6Y?qYevkN!8a?;Is9$^1X>U0^E{~NgRsD3
z#H7B_F3&RuHCHM1ua*U0!K3f8KUuQSG}%*b3F>5$<4*IgW3_X*VARHtF^t#>%E}pR
zM36jV7VfKKTfK4HVFvJS%P%iTy-(dnx<aZul5unM61>q^?RT|9^CBw67>mJPZo%)Y
z8NsH7c#l4NqwGHUy1%F$C7napxxAF8HS8bP(nS@O-bAkr5b}LRvR}2;@~%xO_`CTY
z(bWg(l8p;Q2dkptLlQsz8s0vPva5LtwpCyd&QD@6$&#QX4VX9y?25^^C-`7)keh&z
zHXo81ok!8tHQ^c6xD&j`gZLezg*~$`Mtpmax}3kQzk3VG5sNY|i-FVCn4;{(7T`&z
z6fXL}tzt}KV^<e!UFe4a`z88*@UCljOtRv6Jfqy*3ExTI$p0daS^2wQnL~~&nW8;Y
z5#TdL+<VtigZ1Gz%g!;M2O2CEAD`Z-{lYRR9m9cj-(Zc=Au^-=)Ophgj>0PosHlw1
zS2g%3{qi<2!wcEq33r$j8Z)cb{*Y0s>uC|iMR>D>CMNe|epRGPVw<!1?w;c@5XD!=
zGjb}xXjr-u9m*JX=GogsNsmkaW3GWxMo)?Gy*6V0`jxbKCG&%shKqSVs7(IR_RMoZ
z@B&lnm7w)F$wx~!GU}&0hHY`zO^{d=1Wy4T;Ou1cYG(N<?n+xa8do`RppxOstHvNk
z*S1G)?EA~z#Rqah=Av{BwdEow1+SHjc@?>208$V>-xCs#(PuxxKe%{E5GN<W(lHVl
zz&J(ugEJl%KzD$JrjpWC4Dq|iaVjIn{Ww3*@aBW8ebdpY8gn`DXYkQ6{J74BILfSW
z*FPSz8j(|7e;Ruaq2Z&H+8siDJCozCt(@Ty5n9}B4gRi(WPb8xqnzVT^t~7I-qo9R
zK}pPzl*_%qIZ*_t7rT3ombIhZyeue%OFw{CUxZl77>XKlWzjvGBNo}&Iv-FAr2lcg
zM#>OH64`-YkA`%5>DazqqmZZax0nFJ?H-9vS2I9G2d>3mfn-ImaR<CdxH&}#fO<w&
ziMV1m84t!ff|n=vW@kC6%0e27A`BWze*RS|*+HunY5U6QN^*x3uoeg_$Y(S?x9^&p
z!8%c+b_>Y_>=_C(HclVl>j_VjU(Ff_&pMxr2~Rpmxm49rYq4v3cbR>lZ|!sd1&}u}
zp8qs@XY}P2s!b&*ufAmrsb~02XPAv)&dra0F$~pwC_50B+ATuYfF-XB4@aI9R)OC=
zk~)ifq$}7*#Sv$2;n+1jBBgF#y{TtKQHvWvpYcitpllbX<n(bib;AblxDp<U+d~0N
zJy-8oUWsb|0+%Q5Whu-2n3nWO{#YFYbC0J8*f1x)gOC}?OziKyZ30Rhj@E4!j)oDy
z!g>kA()-$XgX{`Op31Ph^k-=J+hmgC1)O!G7vAcGj$AH-2uSKF6QI|`Q8414dR)bd
z;OodvZZ7ZEizRmvy)O1+{BP-^@q7ekKy*)muuW4^`;fWSFC&Z80AxQqbW3pWf!in+
zw;)#t`#Vq#`RW@&W*9r28&@HhLfh+wbsP9*+?oOH&jhc^kSVu*O!v(9XmgFqo;L33
zMUliUvbuLN<+^z0$E-T>%TGJu2r?S>y>9)eAS9u#HiOsJ2Hb%)u5DkOF87kVjn4M;
zsvw;yKacG+J&_9?CJ9hSxNoO_T%B9V40~*3R#k7~U#ze7p`5-r&1y}rvLbJRwfX(A
z6m-8Ui^d#TpB{Og{rOsAj1yyJ6%d#|Hz6Ymq&VmMJ}Z{}Q|?@IUYD+IVOCwskgopg
zp@O35Ek$u;wvSNXT80ajj}IGm<41Fr=&tYmk(h4Qdj`mqR_{>Fr|t-WGQ`)jtI#vH
z?Y35*v{hU;rcD2%!vNt^mJ>aeS3qvZ^Hzf$PK6<8PBG)@BgjQNU_?<$^{N8kiu?a$
z0f--#R%49`ovr%jn2|1VKT>fDgd&u=L<QZvrfWl1o;6SghuAygRMZsDYHRgk!fMpQ
z`|iuLY&^*4tQD`KbD*VPP%$UywV6wArn;u%Z~nWg<(C+olgnuLqm?8;it>T0V%`_j
zWMto*f&XXfQ28-BlXvHrRfn~Gc2OR#<L_{Y1X)ghI;smda^l5rczS;xHlv3<`T=&y
z`CeI*k`c96k18e5X`Mo;4~f<6C@NuHZ*vA3qtg_|r85L5dOvaJ>1o##URpY{=vt*6
zWbN#WRLz9v6-kWP=%O2GwFz%ue?(^bRd(>XvbDgA0^)25(~@=SdOuG03|#ZHBw<?C
zF9D`zdDgZM4{ta5?Je<xmO4K=bCaA~^4A~E&<||&LJ*rF>GHbT$VoQI-){*SFCdxj
z(Ovdp-mU&rZp4LFBJI70NT|C)wOnir{J09<>D|CKH#Dv3x3peQ!YapXt5Wq6pZk}7
zy%-yK*7LVPd{RKxkUFJ-EZinCm3T|(h90p2RV!+#7kNBw=X8vaWY$H`7jc%wr5-L+
z6DL-^h8m$)gqcBZETo^@dw*~9Kkk{54lOvubdGaJE@N5g*>(q!v@rJ{v23(N?Qk>=
zPYR!#+^T=&a+PLhS%T^Pw4Er^(G!46%x6|!u(nVB=(5644y3rCb^#A(GE)KcVNsQn
zw`NHxhh3=?{JREbx0@@i9g9*JXOUr~0^FYv=aJn!fh*4kIu#sEp>J;DizZRQ>;Xw<
ziC$qLA4rVtc|o?YjTTsZKcyL=ZVG)YKFz5g#xFR3gW=>jn`F9oqC!Bb#F^}DR@<<)
z2Mh`;Y&l-!>e+&S(>Iwv9fv-BC*m*GBmzRsP70INsYScxM$w_iaLKG6tTW#Ul}<^u
z^oeB5C6C$<maH&vsC(sC2I@kK+1ZgU#K$h?2Km?{EEnR3x4cKJ0!5rAX6Q#{a93Dh
zj`52iCnYt@bWCuIpuxnn6l)rj{+Jo2aN&RZL6QiPB%TobgbGSpR)hNG3p1>pKlSd!
zEe~Is40c>2pziM})Vq0<+W=)eRSG-4#dm)<EVBFw!!PPXXAn3U4Fr8Zx7$%bA0whC
zz6f2t!JC=o69PDTbOFkR!J&g!JGV?Yy|y%8)!h@XX1k9gzJ+!vgto_3h0QC45d<eE
z2?_XQ>9j~uQSB;*F+!8HHSGW1{pK0k!5}PyQo8wppbgK*Nczmc+13#${iZp;cSOu(
zyya`Og#Jg6-r6}zcLtk|iM60IZtqbxl3g)6Y7G6eFst%jZ64pl4qAgV`A<7g{+_kt
zWbM$dL!A5=fl@^aW(eb-xQqT{a|OQbooa$eP&Elx)OT-V)A|Oy<vmWwV`R(yZN#TV
zE&cC28LSkLeq#>^Q%$0Njm+GrbnWZZ2i!BF&`I-t6&7l^{`-mPTdFY1Tv0h6=rud5
z!Cpq&hf6k?#yso@PIWLEUqZUP97#9Y4!8JoHyWCHs*i-inaENH{z@@ClZTtXE&4J&
z3Olm0RQj|c1<u|4=Ae1kq8xH&X-h#R0YgpC@X)@t?Cdpi7bupWXFby#?V0QD)|2Y1
zkI42!2YTHCDtb^V<MmMP(a!#EiCjA4^anUGhMdq=6G_GiryI^9D+GRYVd&y9qaUPJ
zjPiTegO^+sHvFe!hvT&BC0W@1mc#T3b1%Z|_EL^F*}u8VD!94zc<wiWALVJJPVeNx
z3yy~evGdI{k=vJ<)2n#&Y!~qFWOw|Q4M0?1<C@WZW6Vs5D`rX2`Hlf&uFCB%H<B-^
zW%_0ogq#d*JDBsa=1(r;1KMh?I?rXKdg9%C=@z767%XM+F<TdP`LPji=T7@d6epPh
z1xjYK+RYJ78SW9K5$Kh!V6j7fzh%3!%6D-X*x2=}j%SaoJEk)~XqtjTmqUs?$c?Eq
zpx5GuEbe~OC?;tku!~xJ`$!=_jO+Hlf{S=0f=v}E$v7hy3b}5H$pSjTXX!OA0m8$J
zJ%^ObU7bN;8?M~^d~T*0Wlx?m>r*_6YhSw!Fu?Z4;y&9R>r|`ff&T}JzRz&fiO@yu
zxBSP|7(zby7_Yf1BzU|9t9UQ2n(H<l^i=Vxc<0&miu!u$I}=EGsolJnws{+y?K<gf
zp)di(<k_TE^sr3Ttqd*-{vpddZNeM6urtGh!8UY*BMd=xdrmA@^aeX!pS`lZdA6+K
zOyKVEpIm~iNPFHflt2`?&!tV?$B~}JS8?x|?P3dLxKUm&<D-^<%dRpo2{Xbf(ozu8
z+AjE+*5nTk@0}k^gUol@eMh!{bU|OMbe67Bb~y+$?N~9!9{P6Lr&IeLmVLnq6NAzs
zrt&YL2wLJchc9rt&R#3LLSgbM!z&)?68#sOFr<+$Ad^0?MZvqZ<87;j<3njq`G$Sf
z*$3XOEKHdS`L75}3C<rl=0<kO1D7^*8$lC<Se)HpP^$cE#wwr<Jy>MSS~QC{hameE
z2L$n+#LEd$s}`W2@l0h_by44{(W#Q)%d-;&Vg7KB<ZAvyLd1=_81TF7M5R0*y3eF^
zai8SRC$cFS1;Y(W)-nRJ7I5kP-R8)wsv4ebGt%@r5tqTodndNgBsI?e^yL@X)kb_e
z4uH1U`K3#J(MWZvDAwgGaD0|j^Qru*#UDifRtMakfV)<FBht0VLYRz2ggG$(Gh*i9
z%(O)J9J`$}vvwg$M@v6ci#C}3S=7?0G&p#Nmhd-RKtDAiE6r(w<d?YIyID>G6Cg>l
zZ1BGkP48Qj*&K7Nj#p#|Xh+89yF#i~97tmLktt!C#quMQMV<9P_hk1Y?3Vk~4I8ql
zDdh`e<xNO>9+X%*0fvL|ChU^|Cw6-M8kzm3o!UOI&&~Nb_qL1-owQ<J)a^=OIcQe<
z9#xQ)F}i^jZh4{~sV}w1N3w*yK{p~m5^V_@d~F4eh4C1F7wm81tVscB$31mxHe<`c
zG8N-1@<jjyG#`nR{Sx5m`R8EP48aXIxH~#T0h^U<&LnszJ>&c-IB}rlvANBIC?pr>
zkdu-(u_Sexfn6z48rH!p5_}ALCkn-aB;(Q$E{lT|bU$*t>16twmMgl~<bjf;Du&+9
z597kz=x>w^YZN<qnuGwBO{-+aR<GDAv;+SENK^iMknGTp+8#d@%}3zy5fezT4~qLu
zftfJY!#bkeW&$=^DUHT}Lz2V=Tr&7;?^_8z(1V^3rBRyCZsmnjmQK-u+X8o8(dO#!
z<5a|p5uUJa-?{37B^2~J9Ygnq;Tu8~7aosewq(D?wStz(XWhhUIsn&Ge6ju)S0g;n
zQ%Y>STt{;oCm&YEUZW+I3y&@MvGD?plV|(HIU^yqgsIG5>RpV8%>d#CEHZN|cqa`c
zYrw2u<f~vT42eX?XgwG=y-3jB9fg5CpXpvtPrq#h)HEm?Dn;ouJ=M#j!yuAcAMRtW
zjO4s}?t-}{0H{kcr@*GEtkpS@5&2TcukvM{jccjl@9SN%@rBo!eIT)nAgBHTXetK`
zzj78^;Wm;c^>?_I9xWL7YcJ_gQ}*I6sBj5%J*hCLl+C-KjtgXA(wps@+?K`M_tQo(
z-e12tN5&Wflza6+r$;gWnqk%a-tX53U{@LE2vHNZHH~{@We~7Obsbr~)={&VluKhj
z6z*FIicH>FGhnK>3RZLtfW;0SN(Q%B#0?%kb&l*vQc<h21Fs$8?-r}zyE45(8QstZ
zh?`cA$UE<Lpd11pF;Wy;v~-Mf{7C=03C_;VNd)5{Pfz>KE=SNMFw?Cpdq?En+W5J$
zO(+3Gf=0t$ykiEme*rb6^bUwc+-|;<jK;iAH1TRx2Ca(mHjXxX+j+fYjE@MA?Yyx2
zlWbdij0c47V2{GrxLo2YD6+9AY2xX{4)lXO6Q=~7MbS_1ffr|P{6Hq12VwAWIZ4bG
zBP|3{hW83}cf4xH#<2i9pDlc870EH_XG@g~NOTmIR}>&jN~Y&@;6g54ZnuN`lamq?
z7i|8kF&N8ATi=wM{(6=|QSbxGO!9ASV*{Ub&@Ec;n5Y1DA_xiY$ULZPh076vi*)YG
z9)#lDu+???Wj_}4RZb_uan?K^B{epcZ*<t&uO6F%Ybrw|3<<wfH9H0TXrksy5&{&w
zVmENt#}*Ym@TqGK7%`(Zh{=AA(4`W*5lW)2#CQ4f-`GF6?40(W>|B6U5kPZF`p-{V
z>aTsJqop7(3NtmpQ!%jkQG;W_r|5mHZZ=>Rjx|BNb@1#8*X+hd#BAFe5Pcn<svQ&2
zv5*VtID9q7$A|dv<%Hwuj>5|yYMT7{%Bx9Kc`nK!S!*ya!HVvFuPw74jK$nk11`{6
zY{(#}i!~q_@AVv{O!VqGuFkK=;htDhCYXMfXC*SzG9>|TN4GrV4`zMCl;U~y9d-EH
zwst0`p`jOEX4;@Bw6V)3y_$RxPFDWb5lakk>I22)f2a=(EUC~pbf*w`Zz>9dn@NCT
z3B;U@3*QDxv?eIyZJgulj`1yzI7RdMyKByVWMil0Z#xh@@XWQgQo}*8slZ8o7?htB
zO`PxC#Wv#AKi-xxmYUaYxND$)_E!6)X=m(f2mjsONrepJJ$Wo{ovE+A*H`anNehtx
z;!&Mct&S-U;9HI>+f5e2s30WL>;1KgbGD)FcSPHH|Ma<t^DDGsFyY?_7IdmF$-Erz
z|Au7T1j!d+j6qW2&V#su>87$yLu*c-rW47~LGjxN`10`&?pMdqBoFwAuzOsFH8%0&
zd_b@@WcXSKt{A8ZKE1&lD^fmu*1{NrDR~?Jys{hZ2}BTnhg983*F{GMC$V=Om9HMk
z!Xi5FN6R|`XHZ0Ys^0cgoe*V$6b^8VXBQ#iM?jw_jAY8Kqxp?R+1#ibJs^V{W<fdr
z+~E~HO5IKLc7)ml|H7BEYT4qqUS)|$Y(Xu;GBps*ClH<hvMBWkgvsc9e|CZ7)+Ism
za9=06wJE$`D)OV1)+5i|{pzp!@X-*<OIgksUgGY-S2Oq;vmZVP+cv>9XIj5^7y90+
z3`R}yIhKvkwl+rqj284`_FBQAJ&;ixA>J+&?Q3*=Wu!~4k99c!-LQiF@JAM))Xi4n
z8uf|qLSOou^@Z7n+HS*5Ekni+34=0&SMt6_1eH;rht1nbH8!CJJW6hsW9gLkQZn<?
zh<Ts>L%Qc(=9OQa^#w0!eGpRokiOR+gd-p`&oCHm+7iRt3(`o4PHG$QUvrR1Fo3ui
z3sVSNE9D(}=wUjNOqB7K{p{lMongGNoEox`_xAL|SP(8(XGA-((7m~)xZX}SZ^qBL
z)smVr$)~XNpZZLeup(WFFG5XZ4`4eg|9<D*Z8t5OwXnA5pBORVinL^IKjkCKyCsV}
z17q@W3`06%0w<LVw!QAeZBsQ&GPXFTmW08Uy`w_fWQPPQ7tCgFUE?2&k>AVgalq4P
z@wUulCIhq>Nb_gWBRXyVv~0zN)Kge<ExBzTse)cl<Z3@rgak;Mj}$?9b77vaF+k=!
zj)6cE$}ZeE1C39mfAlrd-W3aek_I&}DWpeeeIuy;kWrA!v_mK~8ds?C$}bES>9I5Z
zej;c*k;UD8u>)QYVDjxMNY%Vio9pixq}XZgzvXHdZ>*N)dg3YlcDM%(Sa}BA(w+qH
z-rQ;q9f<Y)euOWjem>keRa~!2{@8zFZv8~Wkj#zW+_}*c*tA3fyAW8tTTqg)G$SfL
zc_E6KW6cx1aBe^%{iVxvJ0>QsTc@bYuB5wjreAbNrIb}yTbs<%9Mob+90J%nhosyT
z3URrovvGQ8rZog*w3PbeQuE%8mOK6Q>VwWJXf`IHz;hAyGoFXhynvq$7zH()TO00#
z8wLTVe6X2jBKjqCS7WxdyO&e5+eOgtw&#_KCerSYk7S-@B2grs7Zd`5wx5>n&=>6L
zD(cH4S^!2yGboJ=qXzfTvi6hFe=)7K$L@a2I<b2UO37wde2ijIX-&aUsY`2RUKi~r
zA~UBy27A+7j<t6!KE4edy>{iX5yZ@>hIPKfOV?dvPhYUpy@(T6C_V-Who&)mNts-;
zC8!cUVjuX&;@sUs>z7FK$M-^W$RClXEj=B?;7$8zyWmAezfquO5l3F4^#hFh+^wCK
z_DAS0#E!RW4bJrV$F9(XHgDI?xLAFebhG@CZ?Q+=XSJ{Dyxr;Yc#JCAI9ROqe3@ar
zffjHP&oX^8pRu`6_h#aMA4Bj@doN4;k2jw_i~fu5(<k}Q|FPdU)@ZVDX_;Cx<;l?E
z6!~3ZVAOOrqZqL7ic}r{Sz3e@@jg5Op|pE-n)>*9ro^hiqw)IqnQGqn<fNX{k6nO)
z_u$T;EktWvfUONDj35!`@ht75-GTg|QFK^9jCynAB(Im4gPA%gq~?#)l<gyb#yKwG
z=&fJ%Q|CcBj$GIJxgt+_t!3crTR*O*Z8qDd;gPoN>IN|k#t+G{jcdYN7GB~Dlb&}6
zCyQ1oU*4ncVx#Wre)W#zc+b4>$y;TC-_+{L<FVWeZnF&OlZ7YBZsOB50TSWlhcjIM
z<DjA_YjfQ}><ni<-Zp|}_ylIZInqbbqBdeT<;ews>Lk_=8#OUlmulD!NAiU8kOT3d
z*#-$*O7R%uMGsDXF-#Kiw$j=Teao(1F5Vk<I*9Y59+%UoyKODXgqegot#TE5Yu*UL
zaLBCjP1?tGZp^W`;6FXc9H>%ff6cge4|K1<JFg9B7rC19qv8*1{F|0LsDxgGP_u`L
zk6T}8h)+Z`kuLR+E?-eAdTZ-_r?r~-o|!Erb&}aU`y`adXx{P^iZv=U^z^L5;pBvB
zcE_}SgyDO$G4&~r+bvn2@1AKCa<y(XTA_#0^!$7YN2CtFV^qKqDdmufw$t|XmEO9S
zdsUX<KeYWGxlH?yW87r!1Uc-_XoP;0&b{u5peQWold`ZRorU7hi?19QO2Ow$D4wMM
zL`4wqX`sd9;Z0RVD0P>4+$x7W0$e$s($PS+!?#Fj`3s{QKMZa_Iz(}wPt2PvoKRw-
zpzIoB_d<gvQso|5MQeWlxI0Y+<SI1g6;N{v8h6=ye;X*c>S+0<swQx%O&+2hk)>#a
zhluz-Lw`3j$afXZR_|KO+6Wm#rnLuY>n|n{tk_<MhPKvrODp7Y__?Dx+};GoEThz>
zK?n$NkQbxuI@Mq=pFyP?T+{f(^x;~?f9q2P6kVja>MSO5<&`~L6?YNiN6enVe+~$2
zh)OUxGe9-TX?ivNd~q0{hajFvQSF{H`*<sexdxC>lEiE*qKYef0GW!u&}MjP0`y!c
z&%S?ua*oNaWpIRxGnB-rPP`@SI(ZI=O1xUzCs)ydZbV`$4a<y5Fep>b{c#V|))hz9
zcz!<AyV6cH@YVe|$?nIx3?$Yz%x@Q;^XN}#2$m(Cc_C-XmGE3`>^8z&ZuQ@akV!UW
z7fr@Eyr`TLlD1VFn-0xJzqt9A#8g0L?E8doVDu^AfKngj#a-!id3C>SoW>8P@~BVV
z>B-%bZB3u})q;ix9T<X@#Ng&k{y4D^VHM@#Q1+p&GB*LrTxYOEX~D+wb^GZC>MlO!
z7&2r+PIo5^hTqZ>&IrsfPR7I)iJA}UW#p^U)1i*7u;Vpto^Cb9w2uDC1(UnE<wHFk
zsyTSu_Do4I^kp_J=gn8dW=v#3@SY#^=f_hXV1baq2T+ANVP=k#^Yia1C$($xb^G#h
zY8cQVT(J4n!7;09NGEo_MRpXL&5QX1b4{pq0dl3CGdntY`c)g*CY^g9qX8#KKn#zE
zRMVh2VWqRb;dAq2BT?@m!Jp^0m%y5)g<#;^fubrNTD}LzxAow~#z?-Nlkhc)M$qfF
zOX`fE2@0uQxtDjfGm62pAc-j0>Nzv68m3v&!>UIKJi66FWC1Gk==sBN{$Z?&)b(x!
zzOgCj!_fP;s(;om@LD%7u8iqy8nwLBvk=n!L>yl^J>OEPST4c014)IcgO&fJ0S`R_
zB2evxXa*Zt!k0hWLtdn@VZS=;cD{_gBeuCf#vFCp2C-GyAl;f<riz^mW7We03$x0i
zq~APBht9r2HTl9y_Rv;Nvx&kc+wFYP5W)O%y#ohdHtkq5yv=Zev89A3Hs{K#l*J+y
zT??IWZ;0S`Z`VF9;J=XwtDt|qzmk3V?}Cr3H2<tFm}SCb4L?r7a64W^e9FYb#T9Oz
z*HvUYmnT)^MOo*h@M2@owzG&VNZ$ZoJ<mD**b_s`5DU#xYKGD8{;svttEkm-_g#9B
zgEQJ_`|Dv@IXhq}UGAsXb9Yt>Y8hKm8L0(%$&phmItByR_wRYjb)N4vZc?`uQxHb%
zn^O>4VtnAv$IN`ke{2E}%4Z~yV~1(UP;xUI-o7+q`3Llh<7dp$Aa_g*t(JfcV#?=0
zSF9a{`Z~4P!#k1S{zWavm)0T6T@dFY-TY&_xECA=Dn;29`|9m^l=fw}!YKN7UmLM8
z;q}uE%*IpPTYJ9eYLk@kxc6+R4kSOz9jtwaJp{-vt28@GYX-XBVE4lJY)9}STPJn_
z#6&v(8W3de%&hmP&f>K6pd@O+{>+5+zg1-16)LEtpi?rq-8w)%1+LFNp4*jh#Mq`U
zRZ4RKhCmU84_P0iV}i9(5{v%n2ixHi*>G(q#5*%;eLJ6ze3F^3B{PebQKV<k8}q#)
zF&HRYU+WI;jADvBBR8?*DQIRR2y=0V>%91egluWSDQ&3QFM~?MKmLY2-M>9v2?Q~4
zKCK^+?sH}FUa@u-W8F?T9fF0D%-_B|wQsP5Vfl#vGs1}?eisHP3|CcF_&On^d6J+t
z%?hzl_w^E>PEoM_9pyfCa+pLhsr?><vMWAXHSv%@@ESCD9hJ2MkEKN3f^-S}O&tQn
zf(HK-OBgV$;6`P=T&b?@86o#f;)D(i&E7f!2j1kWk2=X$A9?v@A4R{~J}0mhgwUjK
zaEtK`-97ltEg;YIyVN6r>oq?d2MrW>>33y+%Zo}y+U4U83~6g=|9wue&MRW1&y6}k
zKbYxu^wsOS&SiEsiYW7It7rXav;XJ-0^#&rCNp{W-!{%Q7ZH^EhB%G`w<>$Q4!5(Z
z@3f9P2(iDCOPVj2N50e6n%XJTDA6|wNGD%EFx%>_S8#fTbso~Hh^Rx?Ib%&4B$!j@
z6RwIB)Lu0UdytC4Ma^))0mHuYgs01wC3lZhziDB18CT!HZ?8*3FR$iZbpPf;_w2n*
z4IT&LJyGZ$VCE>#A#{(%d`VaFeZYoHA*Aq^{tq9;(tA<45Y1xUmK4?(5%_qP%^)V&
zjM{DG8M>PW7jzpbo;(r!){x1T@~TGga7;q7_ZBb%bcj9$Jm^U3m-!+AeGAy#!3@Su
zZMO^oHt!C5)eU`_)f8qr7*3K)ck;P|cAdNm(=yg-%;`XBssyoPaMC6jBJ7V3{)7w+
zE`3VBf^QPyY#Ef;>c!s?R_~(<Wx=I7IM%jDb>$p`UD}5pYo!5#l6lN?TQxo%>+{wJ
ze`Cm9X=#ZZN#j!#lDb^*n#_bUHI83k2D1I?VLp*}{=>ofnDHC~^HPvtg>}B?>G-{A
zsWvMpb~=GqUNs8+BpkbvZ+tp<5~yp$b@ABtNLO2@mbmtUAxya8d`w~F3Rbz@re5jV
zKSJ$RZ>7lKcZt(IF=9ted}fxqqg;FZ^g3Y7!ToIIrGICWo*}N73Jn)?EC<?W<Cye$
zv*V!tTy(kT{K%!7adU<6lXh_nZe(j1dh_iH$KcLs)sq?Is5KJyawjg5U-f~TEdI6`
z%Rc8|IE?S+=Eb`M{~96sk+9QFhx(Iut^HSS#QPNklY4A7*+jkmKL*#a?D*e}Hv(ym
zpx5AUOolFxwv2|!5;`nXFRj+y3LGx?tK{|m6=w>~?!8I}7Bu!3ge<J3tJ^A6O%Z{C
z(j{zG|J{ztXY<d=XA>lW`4)u=%ZKodSTQv@-ZObo-el8*AK1aV!ELA5>6$RJMVdhj
zZUQ&Y`cH;Oqlb${V*}D<D^(Iq)7Qaw$p$ZNE2`$u>@J$7smZ5*ggr*55!b*ZMp3E+
zBx)9~`ookc=oNileafpl<ej&5dw3L;??Z78J^84=OX(R9_v8W#y1O2Ro=nafDnhQW
zrg#WTucWxQ;mYZMFnt8dt_STyk8=`dJc5?xTd~wR54b^E6nlia?HKN`%&JpBKkHZ)
z4joP2N!p#o3mSr8q&P)$5t4lYpebip$(aA%?a2I)eh$FUHw%V&3`hv)i5x4O@-3P>
zTer)Jc|Q}O?joS>qNDB-F%WAn=(@f^HAyog&r#}vCu?Y9$ID-1cgc;roA#qC(Tq;E
zq8>_we%c3(g>#OdjO=hO_V_oa0fS3eH|8I~U`NKN3JsTBkz(Z++n#Xc>Ap!zda<_P
zEZJ-7@<;mGL}D8U{z!SvpwI^7=T=ULh+7C!6|PU`*TX-<8!#RDbIb+#YwhmtVMfm<
zW8TMJKGdwTaxS@;h(2y@BXZq7j(e$I>$8B*_Q^{9D^FO2FWYB5wD8U0GBR-=(1pnV
z*|(*=r_Tb14V9qMB(Bm@V{4OLF*vkcXokfa0K7GQ-$x$TMtD>e4|H>)mgwqtp<jdD
z>+~x24$*D#omDDKbCmkWzNTRId=S3tDmismzm>Lk*O0{Q9SnrRZs0`IBPDC<@op!|
z;C7}g+bk5RfL{E9Bgnl{Oz%|pV^PO2R8A%X&4B9uT;O^;vHbFxwR<}0`hYYWVZ>kC
zb2)_-bm;kvaed5YU{xHvhzCIPDnTd>8F{vm>1)BiFFsIvUd6p8b}~D!N@y;Y_)$lY
z3%ks=3LF?y03YAYoRsr^8K`2AslyyA>zJ_m;BaF4)qD9i5XqLqV|ORhHSe!rFQ)*1
z#LTi#SfL&-JUc69d8vE-kY$?pBl?li>o3O916+H_plWpyX#C(lVe3_@?neFn!<yc`
z#m?rN#@-Q*RJ%`B6^XdlqcJ;RTh76S@q7D(6-gO$4u{*F3p#?#{65Y*ryX58g_4$Y
z&g)~Ab9MSC$l<DsZCmkfAJ&*S>5I`jV6<e#Sx3H5+jO+7BI6&j9*Dq+L08!jATwwY
zBB(9KQ0=?bcCH?e(`GLu>M?&eu#=JodsY+_HCUkE{CmYMZgt{2=S7?b4dS?O#A{R}
z1$wP|9#_NT7QQeU{K0v|HPJ7VATB0yOvQ2Jow%Em&$Y59<%UX+%~%9hb-vxrRoA@R
zfF`Bt^hwo*cE@Dj-^5OkHQw1+6F=>w_k4L-L#-di_kTY1(sdFJDZj89<8-BhX&w9I
zRKiKA7rlFXB;eM}SO?nctL|MQ&4<353c{Lp_p`Q4D_c@%5Lf|wxn1?;@9QWt{VJwc
zZoqwav}Ncsp%m=v>bYe4MU&I%)XNiFY}yVm`|<;#>*g>*o?Bvce*a@no4fCnIu&)T
zp-KcMF7Ey#xLx>C2u<ffhm#Ax-T#5<ui46atW#U>zPqqqV`nd!H}dk?P?GC|R~EvN
zl-wFDm{p7ajo5*f_~H2Wd+anfTv(ex09!`POzZvtgTFJ&;0aT+@r`frkvS))JFrmV
zr!dnIZ!n)4*mH(+ZuTOAL^cT7GZ7=t6u04)O>vJ0Nck=LMem4zo|paq09;7tgO80F
ze75k|8a`sA{O@qk*|z?5`D)spCB(Tjj+_y68szwu!;(O?O|lmEsME?qd*~x;PEADN
zj~ZOB*Wha|qy0HvT{1zus>IJ)VCX@@9abAbH8UhqL*n*8G^^egYx^am<;K(UuzA9r
zdh-_|!LVU$TC8Cq5sOAbANO^5uZEIR)i<}U$)~O3XQ*3o?e%hm(#9J%i@8eMFZ+ul
zxWi-;qjw@Fh`1QuhVR}t&F!94%(Z_$ae?iiP@rerxLnvIC687sRivHc6sR8-)X(Lf
z>|&t6T860k`!urc<tS6Pkc!AK@tB<y8lLD)7tE^jr=sSMbhO<PtT<=q<lQD(He9Es
zTK7(-ihq8bo2u#wb>n0Z)6vLPPVRDC_RU5gOUt}J_E<q5i^CIZXy2#yb$g@`YPJ;q
zz)r#T4noWw0FAfqyZEJ5%nMrPjRR<n<|OH^FF)4xTb8^@73f5|d~(qIiq}Cb9O&d_
zOWuWuygvjfT3l@Z*c`4rg2*Su$wSZ)fMuCv3#@-?5;Ztp1``h=pN>%E>kfDSc-Qp1
z?Gazacy8)e3b|$sTejteh5^ljbi_UIc3tbSjCmnx<u^}n2Y!mg?&d2#PO@G%x`Toq
zlCyE@6J0i`bYv0^0e=5F7zckjpz8?6Zs181Sz3hU2tMb#+oq>5P~FJ6Mj<>TR8w1&
zV(GB|=qSBhkf>YqE_!4dBq^A@DBOe6?!?jaXW2r-DcUG|)2{~UrzBkpF?DkmNAJ5F
zYalnI=Y{x-o!zY~IHU$?>pkXJU-INlSOzZ5{+~CFX2crI8fvg_3OsyzXV_JOHwX;U
z$;Qbm?SoD_`o|pv#&tuG-=19KpZ#cG(0!2Mjq?)+V#?lwu^><|;5B-XvvANFmtvA;
zhPZ9&x<+2F@*RSvUp@y9Bhn>e{wy=++##i*?U9S;HMYT{0~UDzD~snPtK^5Np>~dD
z?%1T~yR(F($1NR3PqsIuAsI5^xxWRu{R;8CK8-sfY#RrT{{dvWl$EJYabGTHsSo97
z&r2BF5Si(W(vfT^Rk($MN)|_T<l6NIbvNVyhEtB~05p(?$iV3&lD$3B8t<~SHB+#d
z335-3%0~y=$c(}g?^fRJc8<k9HX2(~QiC#19NwD9yB8a>5J59WCD~G5LDXI94q#1Y
zt3xtO#7?cL7q*6T<zaN9TaKn@8?$vbaXSDT{ee`SpZ+$(NN9EE@b5Xf3Zcte?zqG-
zRKOP_a7u}i_qN^i^1AN26ZOI>_G7F8sSr^h_a~Y-TURam`O3aPQyN$s0JGx%qU<fB
z;_Q}g(a^y)xI=&dO>lP)5ZqlG4^D7*5<Cg+?hxGF-GVkw(BSTJo_u=mxMz=d-`_9>
z-HTeas%Fialb~8w7u<j6k!ewZIsE&WC<9pE4n8r=2w9QtdWsOX0y+MOYLSWimTBs4
z1#^E%0JrxB^@=CK?}4|WBNDW21`n|gN^irEsD-s;7H}=VsZjNQ4hCJ)oaFzc3kFjQ
zA3k!N8(3ebi+x3!oc6=bwj>=GKEZgCbtgD!S>0)~$xc9R`DI!fh7Z=wfrJV>mS@B^
z3RP>N)rfcr1K6#~%P><U9$6FjhxbBdC7^vH`1HE<S+PT;Q&r@7<mD?z>|(<cc{jT^
zx`jd`o&E%s%S8t}q}4xU_`zn6pf44l-IC^b<KX2P$ymEUt>bBeK#(;Y8<U#Bun+&`
z9KW1GFYJrTjaPZL>S@}olw788Km#+Uk=*$2bH97?q?U1uPda0L<_)g|ySA=kzb}Ey
z^?C|lhC^N4T)sEm99ov|rnUwTVLZR4DL`QP^h5#;8M)ocrBCv!oN70iy}?20vlAkI
zIb2iqM>lFblQP9?hO?}cB949Ffsan_D{e5H&p6Px$%Cxdsi>f#A%7~UxM)^Kt4K8e
zu4SUgb;f`kq7l?i%kSlNBhe3N*8E=uRRE2u|N04u4^Rb>KbgGa!~snNc4EHC;&&5o
zuxas&X0P4WZ|+%~6x96Fc#l)(%MY`tA~9&t6#_vJ5?~MB6s1k!d|oJowe*?fE{t-@
zvuK?soO@^Cqkpy7)EfRZ|BVeHFZ!;ou*Lla9f7S}@-{|qde9F#^@g!K>Vj&YJK`BI
z^&*ja5|2+q>q_7OLxW9iC&!1T-*uUttOD|MgJnpA`rC8K-WrVTa49QpHP$;s)0rF_
zsnu7jqG9Rjs=U8A$2}I^2YOc>vEeKW{8nPN&nh$%9O9Ams>+c1!jUBLe&Wr?gg=+q
zSLLeN{z$37U*lC2UbUhC>SF7e!MI{Q18Rw4@=!DPRoHt#w#9--b(B$ohA-6UN@9bE
zAc+3sQ2%bgEab~j$+($o={U!p3?x-LXk^g7y!zov-IXvS+xb^s(vp{}@CGJt8SGvQ
zN@I8JX1E(FJHEld7Hl6&CX9iBa7jNJwLfvvq4}rIPZoTa!z4eSH=G3Azja!<ym_`@
z6d6cP<Ml*RW#4pv3B+|RXf$}ZWnXS-=>8yrU4mo(D9%nmO5Q^#V>yKws}CI%`=qs>
zp-tbb6us8>ONGR6<@a}#=-;H&BC1KQ+w~BzYNU;d_a-YReM6o>URM8B*Ol3F2X925
z8S?la<n#WoG$NTi?BXz<uqK%N)D$wR5=0-k?BrMG-6zWM=_2zIs@ki+rZ(VJRwsW5
zA9Bk-@oLRHz5LeqkP5I;5rCTN*~T9jSRW&*-UpFIKG5moscPvgi!h8|8Vnc1TYQAw
zdv5<gW_^OnCCso&2TNzC@Z^kYE)IV{?iYTkLS}a1=uY#6^-f$kvJN)E?}qvZ4mL^?
zpKy;YgCTy_T7dmv`2LRk*8Kc;t(>e>yVU%)x^)Yc8c`%}#qWt?_H7%#V5irqV5e7&
z(TQH#LC#-6wJ(IolNqAy`>BSXK$rJdIK(9J*X7M!rt_Y2h*hG{FeeMg!v%0Zl!s!S
zty6C#J4yPK-QzVe4$HhoVr6|(lswnx;kX5!c<O5*`Qj4-$rfS_4B|owkOORM<pW8j
z$8F@!*;&i0HLs|mU6aA(j-fnj<cte#oY?q`dqG*4dk&ju0prYi*u5F^bfn=n&J(Ej
z#NG(ANa+^__A&(wfo#$1L)PG_Doj)fXps##GHU=nrnvXOg!nAVgJCsupxoL?YxSem
zpNVbSo>|ctv>Q~4U`4%dsNu7&FVpFF+iT&P08zrB$qC4g;9DE!9(_aO3Yo<3!^F_6
z6Mdlxen;0!m|@+9(>wd0#w|EqKxcLa1l0uUZ_``6a2fx(A8E-&<BKOxc&m&eF@PMN
z?OhrG%j~V`cXjK@`rDm*XgJy-O}+$xoE;2dnm?JE2u2XQDk829g1t9j3|``<UQ_V2
z+VE^yAh%DTpiDQ?+YDAZp1|Araz;eW^30Ih*+21p8_@;EN&lTv{)Hrtj|f156XN+=
zjUu+rir9(+x{NMgdY-DiX_$V3+asbJe?N}Ff3^XIjDlgBhchYpL)J-`TzBP(wY|J2
zwla{?bLFhKntcEQk!#x-yVjSOszs}S@sPc3b(x~AUtpFy-kULUFfK#qaGv&ahso56
z%YqkEOWw{z)`oK9M8`lJziY+Oxze(l{-!I&e!sriFCArSkqfC^Nl|L33jmnTU927*
z+10C`W^D80WhL3>r8(HsM;Ow<r0ApBo1w<wWbw-^6u0taSb3i8eDGftbv9kSjCoZ~
zWs3w)BlU{wh2=1y{?(BU%A^v=8A+W63!hFTQRUE1uy3ZTzA`uQe5L}P>jw)wCLwX(
zotwg2qufD$uVj7Cir)q~;ih56uXiyVp5bhLkwSD0S*wyRVqM;iSUs`8_w&B25W?C@
zY}tPnip4vjMgv1B5u-D@2lv1QQcnbkJnLBtwyY(l2SmgsI7)Q+TB~fw`b|;sS0q?2
zu0DdlbjcGEvrdolC!IHJKLp_gqs)JYU|l!dOdrm*mr+zIzq^TU53MS~*rjxwVNboi
zZ;`MuwPis|Gn?O2ZWR)DEU1k_Skv!2|3y;|#>4O2vehNX2A|B*(z5Vz_<x%~Y8d<Q
z6ciSX^9gzBrmB@>z|D=9Q9u&ro>9&rv+T?zOHFLbQYwfW6D2<Sz3P?fQiPVSPS;_Z
zi;bOXc+U1zr4+;*bQv~1eanlTCDlk?9D*|~1a0iLr5J%vi5EZ~LbG9B8yFtuJ1)<w
zN{8&fyHWb^y-;Y{tk35!82ati3RW+P?`j8)g2~&ht|Y2rq{)a<!gn=hN1hzKU`hCX
zOjM<B=qfp;Jt6rB)(eZ_R3pv{V);4Li*xr|-7Y*Nh_Il=<TyDRWz*(DRBu-fUPxu=
z2EQZffUhH_t0r7AeI_em<6zt=yPQ9o@g9z_)UN}r+dV#&8*XJtpmkezM()a~9C;5Q
zmk?yp>A$}?KUg{7e?=_ERIs=7;A0}Z3V+RK<a{O|z#EoqcuKg^AG|&x{D~UYUQKye
z5Q+rI7S=1nDps{(B<tCZ8E;PbN$!seu*t<S;a*q7+ZvGsL<ozyr)1`fJH~M(vc6yv
z>k55ko%Oi67{MY5xY=4l%p~bP{p4#vqrrN^yhgz*3yD=flJ~zxO}S0~O>c^um@4CM
z=d*eOfhY-DXwm71z9C8JoMa&;j6yfIeCyBBXIA>Xc#N0J;G;czpHD1Zt)q>N#kX;l
zXr?ny#?w3MiJ3)Yua&(bd)Z*~6I4445>fI)QDMU%2PryF1+*@k@$6Pt+#xR~t-FLz
zlh$_`n{yN*FOO0-YF!nQBZhB%{LqQr07anV+l*R^LY}U@&?&yi&SE-XhUQ<tTXmNh
zQ@8njHRqL2=h;F9nDa;*aZ>gOcJKG*JCO^_p-B&49jAr+!->Va<X=A~b$1J=2m?5s
z;WyZAKA!r1L+W1Af_!#5A4mSI?V?!Uwc*<EE8~c%u}$c<2QxTnl6=Q-@*sGii%f0b
zhTvN`1*WbURkc}JncX>*Ed(|*_ZmMCgL0N%U%x_u?1DSV^l9R&<O*W1-^59bnW>ol
z`SMk+bn&Xenj}kYNXcwO-EZreuLlGTKGDnjF5b_(4_`GUSx)<3qNRnbGYAd0IsHft
zpC*KjeO<}max6K$j7*kJwPDAfb>-4iyYeFh3XL1iuKb>HckEZiQ}ES_xnWX((4Uk?
zp42>pR&+peE*D_}tM2=)1Kl1G2p-Nl25zfFNt}ElmVde3UN$6FbxyFjd?3=n79j@7
zS!dp*z7U(J`l8N0cbYyN!|tWG1Yl*4*)1%?xc4Z#*9vDe$iZX8q{A{3-^w*q`kd(M
zJ<k?uwGO~K8d%zlK-nvOy%RKE(0YnIy;L+~tuDKmxA&WuYuqOm+1~$CIu~0n`l}vU
zM2cA)^M;26Bqio=S5Lj6&s%?Wp|cxfQ|{3sTkGJ=T)2x~N}RNE{szXgFe#lI(5*ic
zjP;_qj4UBXj$&el>u_A4QS5O%$70xkBtTo<n(f&95FTgFs&z-XLRhPkU6Gf6G{byg
zs<>7P>qH9|=?}Z8#F$_yc1;@kN><mMk)5(^4CPkV_4B{KCJM<)yB6QcfSV1TlXSB<
zQfqkH>2&-F{B4~l%jTMWyFdCTGrm_$xiJmVR@RO_yg((mi%|(Mx%SOc%HD~%op~Ej
zJ<*Dk)<o~p$1X-`Ajsi`H{&6bm{Xq@dF=nrja043QKmbMDULa;ZktMe_tLgr`p%q&
zlArWc<-CR{`Aw#@)r!WhC8hd7%Z1O;U7d3dXXcz(-T2J!>-$A-?0oZaW;~g}so$1L
zUzO;5WYV1Y%PN(9xr*WOb<*h`>Tl#-q%vjAz%#SpA}z?y`N|c<1Gn19xPBTxc*QEX
zF2S7p67JmvPV1unc<REN-os0F^+ixceAvS*<qx`H7S8ipRSnbX`Zf9N90N(F<hkqI
zk2Q@7Q$3c|-Bt}fM~+=xnyDc<><3osb!%JaSD(>Ca=sV)!h9%*-dMq4hAga!Y+q}B
zWv(z{LPOqs&mQB3!eq$E-W4mR&Naf+NzW<2>@SX=MSFUY8NAM(=Xeu)prs#9(f5#0
z(4vf5Q5^anPDZ;AtGW;Qy<DpL4doSW&>MG+zo<Dt&JYyP+CZ1U6!Z-p%Ar855lxMX
zqCn0^j`h-=r?Q`u+jl!}HxHODAu3f<8r-1^tA^>>C#lDlw%JaRi#U#<*M!}B{ZruD
z+=%6z-Oh^0#P5m>PBUKXkyJRdq$p|P+++m4!U8TNN`m3p1E#poRCdd{L<qjjL0-;e
zE9ho}91`;;pLmdI9P&r@`nvLmSJ^{**OocR8s|B7faT%_AN(ruTl+H|9F(_r=X{XX
z8bQtbWe7etk^CSx#lh<_kru3GQFS$x$pPUc<=1MQ?c13=1BWV}v$Ir%Hu<#$;t<2s
z_3q4FyMFkS3==G+ij$wna&th8)6*croR*mtjv^dUXwLFHFWhZ{GPz&8Y7{&)x{EF(
zzHqm@Wzjy;^Um$%Ehx?mfeQ0OH`#FYV<fkl@`y5rqK%Q0H731HBPVymP_WzZBnP9q
zer<pmk=)^3XxmzndpYr)g)x=VE(`TpO+^oWU5{Occ(foFa0=g}Qho^zlrxHu=k7go
zFOyR@SNK9@YTJ_~?G9dLx3t|Q>ia8H%(YA?x*>&~#3@a9ZK-^h-YxOKuL*5a=BjS{
ziWoaXySD8%dQOwz`#^`)Fi%%-(KO2b6_X1O=t{cw)?dLxv!W@MaWbGR%srA8IEyB_
zx(m^?Rq4YNu|S)i$vEqzCMqaZMIFwUcMqB6y8rM}Gy#VqkSp9d*z!Uvxll6{e1|?!
zMfq8dPoeKX>%|yu#~jYY{<JA^Xa;)j$bsVMKK&Bj+wIo)IQITGCl?OS#R-dxIZ;LC
zNKTUvcH+xOMV0%3uda>8#4`=g7bc_AD8K%hKhkNLd84hqXoipTYbF_JnCAk*^oy~z
zVQBEo#(U|0{k_2dz^V|<0nPBkW%&yV_P~Gx-|%WG_{{H`*{`d6g<2k`;sP7vl#1hm
zOTlNbcb|^CyYD5W_o?FS54k<$lW$8ZZ3Q-&rGXz_lC7)Ot;Nm_k(UF}>d*}<pI{(+
zA$^hRR{Q<hGcF4E3FXj)<Sb96wbFd*_j#fU?$r2+oqfWziQX%s4sr+WKZyAe36cMz
zX#O7(SEuaX@;Pz+tu$^(Cp#dC18b@7rXS}+0;8jA@YJ}<S?en~>nEpPLgFM}7f1Oe
zKfE$G9EIwq2FUp%wFo`cH{r`;oSKUQeJih4C${MrBjd%Yczu3;fw<eG#$j@NG#r0j
zacjtHILnJpg0d-TtuN868>R8T=GFD1)vD>XxDpn|u0fHHU73#6Ewg{z=bH>vZM!$b
zgNh3iP7%{KD6~k9$0b}>xx=;N8Z?!b3?u}rR`IfyYH-2Fel`7hy)u|+!&77L{cbgj
z7lx}>p(od=uLrcpRRM`fo+qv1`Sjm+259&0yKMK)fXBrLW?)Q-on^?Q0(h3cVNv2>
zmtb{0=UII?MMLGIYu9^5q_4SgG|P>Ql6q%Lv;?|517`Mpirx+?r*{e6Lr>ZT64Ujb
zz59wPs@fWe0zZK66$3kqj`JbePMCMhdFquI`s=jekwXF<G|j`x>Z$ORve7bR84u)1
zxx}b)fzE4J5`b~zL@DB?bTH6RA{~Pi{aqTh^~nUb-^U>-;Wo)iWb89)ln!D4p?dh(
zMS1Z0mDq!JZC!?s<zMhl+<^_T!X7357FnY`Maq*d8krc5GcK(3hZ5Ze5%i;s;4^VD
z-_p8UxK*|ctCA1xX-_Uvy?r-vzCUS8*ywLiy&Y?mH~YXU9vHKvSL+Cx{DUQZSu!0h
z0~t4=XZL)($9T&P4JB4rQDNhjd7|@}iPE<z9-OYlm>Z`&(lEcLHFZdu*Xc<H@okUl
z*x164hShkvBvo<K{ALkRWEKA)!V6^;5Usjkyd40C>EM0W{C%29rbJReFz(5bspEgV
z9JX>pQ;MQ7TmwV%E4sQNd<qkJQ5-W^kc%f7d8O>sOW7QkKH{SBX-uD?oCa*pHlNrw
znxy}DEU{YRC|)yclCAZLWNgtFwe?IKmS)+3zlppwLhE)@K;@$N+IP=I2~>;KT*!Jq
zP2R;l`fg*ZVezig(~MZ#Md(}Zz4cRW#k{Z25O&t|$YaL9#WcTQ)R3W`@oSijwvn|@
zpxZec(4B2Yko+|&z^z^jo5$n@WXWo5?7B^=Z&N$ovW{dZ4ntrmv3YKSVw2KHB;&$X
z?N*)SXBoD4ZEdQ#zg^98mNAr94MgD>3#^3;>}DQiwNs}Ukqdk|?emk`xP={$#(Q&G
z<(NkI<*JEs)VKDd<7$7fr2#@KnS3ZXWe9HO_=UD??Fnzbu_J5|thebmVY<uS2<-BW
z4O1TbUJ^5`HAh8pm>s=W<f*}EKbvQH9v3!_y9r@UZT8da((HJ`ionoFel8<At~(}I
zq!qb{j7$rBnGrTVpFw5HfLyf9F#LSpztL(Pv#!b`qVk09xnTtru6EybJa7|`viGFl
z3mVrLx*$!$&z??hd`Zp>!dp#Dc_b-|^DxXQE=z&c38LK)d~Qe*;1A+9ut<+}bJ%`)
zBG+nkL<sYNwR}y?mqJ3}{v;In0o+bJ3<lOzV$JPYp?v2@@G%qD3o@VnC++-8{180`
zxKdvRG-U8VQemAa_*uB9g3MYkq=pA}>bWy2#y1LU<Ph0B-{4m(YSNm`R;7v4WNYln
z*h&7TwXB3(9Iywsgh^DnEXuB2S_EGCSaDY_Nd{JVB(}y4os!RlNecCAN`)-S7FJfd
zX$TMUbHV9P2}|rz+klu0%h=GUCe=aR+N7zNYS2(28uIx2s^Xz79otFY1x-2yiJ9a^
zjof$o+R0`*Hgeb~9ISe4gg%+qk#06ss{ZZG!KD#|HfE?`jik$a0;EY&YQghz4VQh?
zAFrN1s(oqy`@N#IxK3FBU{p9Vdem#^KikZ5GO<XxO6STWeC+MyZzn9oM#}Bl14h*?
zkQ<DiT{q)F)u8OSzD2g_Op~RLs&m6z@uU5Dj}}K8E;Ab*?eTzSu4U;(NLx^_<a#~>
zK?<3qX%3P_XDIx1+(;OsskyND{i-+r_ogSkGQmwEqiZR;4+bB;N|*KE>s2QG`ncQ_
zF|$m>W=$wm!Y(@ByGpT;8W^P_v?Q+56PexZ#L$)|K{pm`A+9^vc8M-FKzVxWRFuzM
z>5^Vt9kB$?qc56`d=%O+$6z|V>RQ@zgW+1&R;VNqs&K-%JmF*EYifhJRg^Qi?}>2u
zLOdvZn<71avCt~7?cS2dSpIAhWz|tsVOe<xIa8o;x5A1gCkdL?mDpKD%iB%BEX2_p
zW+$EFMV#2;kzC~~9%HUxqqu(-nEPo*(UKjpp_uw=toe|=h(nvI&pQ5Nss4xpH;DrC
zV@ZHGNBGC!p?ZifwQ<iFLZ)w2-<?YtPVr|?pHsQBmc;3ggxp=i)#D}abP7au1sq}&
zjrYpuIX9NonxjU$1rmgG^BXh%><s1R{|Hk5b#wYauJp~VXRc8S;)y<D$aF?vu4Nu;
z7=)up1~(Rbyzm_;cMOJehcd*{OjHT(H@pz#;KA(`?02cZ&KsNt%Pf>jFARtP)@lt_
zz<+B2tRLXJlcIKVe+<y3E>QJXSe;;_c1NDtaBO|JCI}6r0mS;=wUPGhn4^Y$fG3=d
zK=dM0ZnMJ~!EqR>{;4H&5s>*B$5U|NIY8{hy75x-4Uog|ldW-*PJXAZG3R_mEO^;D
zVfEa>fp68|SRjC0T)ZI2HnjIKXuqR>U3t6OecLqe_{YAf!}l8J^Mi@aa$Cs54fpra
za~-#_w`@*ig}#?e-R+ce^yHAuYcsuPPxR7KPw{{gT9MS{%}R_%0_@$1-(wj4>s&TQ
ze=uGGw~4u{8l^Lgf<g!R34~wpd{5`?jle2_j+<^;O;d~_x=G7NWIkwQnFwS(ctmhq
zZ@=a%fh)POE9VosR0VztTl~6YQHZWWNS-~o-S2pWzi1$PJ7SW@=k|w0&d$#56jV@P
zar$g6PQWqXA^ZsIgt2ovW=v*H_w)>HN@)Ezq<5VEO7A$wM9l!wJF=jPZ?BGwJ+(rF
zZG@9w*=}K6Nft2aN=5g$9)cKxVpCp~V`X!~=p+VbZY%RfR?lGEKdKtnVr7-;qJYQr
zC2XC@&|LM)^8S#fK72)<<SfukwTaVf<w`n|vHZ5-0Z5$QdtfIXxnQzXVt!@)I=BEH
z?{EUa=o0opN4_%t2P(If(caoJ7utpAKQx9jcqXdXycgJ((z`NIVdC-$+Yy<+j|?-<
z%a#xuG?CC*N+D7cmTHBQkL66bUGm&&ql72ui~iadd2&`_3yZi>RMd%Hd&?<YW;kD<
zFhjesEG%kB?l2?>(#~=$kXjoZ)Q9WuWCZ^jlf0nEyM2WAbbXwXiz{|exto3t>INIZ
zi-U0j%|MP(PXUUV0n>9-rQZTy-o(ZZtdRu!sd1{=ylrXqkD35~9%p)sU8-t%%=J6U
zmHf3K?K(eKz;|vsO8Bv&0=lm>SaSB`xx+Y?xX>~p9-S4Tj4yK9j7-^;O<_k5pK!2c
zJ{A}g6BrGjdca0Usbu8s*)S<r>x;8yh_R~Xzp^z7<RF&ONvg6L%8iqwbaadO%?zjh
zv*Y5-r1H%3tV@tLpepn6RXe8daeRVOq%8$&q9|*A@F(QiJJ9@C&JX(RY}cV8BI!^t
zkCU*kJG^h5LC7}kkB=4RN#^pHP_j_^-xj1kBJnv}04Q>U_g#xAD`~E;--2F*o=g9=
znPbrRKNG7gl;UxAUwR0(tJrXUEVO>cB`#gkV%AnhL3`^AfgjI`_%s(6hvK1jE=T|K
zLa1BqlNV3$`XwU69Hopk_xB9L?j1%NBKx}F^A+3r59-vnp?;_6fvTA9L7!$W9BtO1
zB6jqpNR#0fAvrFbnjh*$y$~>3xCH86mD_2_J-G51U8yQqq;QJ&LL3o{P!xN(@gy(H
zLb|Q6tTR_2#_lAXt7RqeY&V=^&S#W2iAYfI9o7d03TIDLV3rw}O*Zh$UfAN>30wFb
zd~BQUY%PX7<@uZ<Cc#CwNv1f&2j(JE>2xmGVOGS5;F;b2t-B3k7b{zt#dpuj$ZppF
zK(*7w5K$<De-*;4nscytFWd1H2jZAGyC)Fa5Y-bP_Fpp)^)w@_x<Ug`E|TGI!V|(m
zVuFcXTN#12rxr=gw|J{hgxjlcx1amgAZPcu-cLiw)%}ig-T=d8|B-Msl7&^k70u1>
zg1pM%hzM`9%qux6DY=X!x&3R6un&39rU4H<hEh0tS4tFawa4s2z)jHJ8_5_1Nb%3N
zzT4bdZ9cDSE|7X>cjLIcg<%$rkh=ExvVHIjZvPPDRC!2`8%lcGVwP5ckX<rpv)KuF
zT#*M1g+sFVU%!Ui+fFrfqZZK(QazpU_CK9ufp3Zo8Q_e~!x?|jK(i6RF->_K)rNgE
zzeO#944`@6d>PTwpNuVQ!AR{BhMC`ralC%?c<k}YCEzMI**tg&Bc8Wk-)zxl=)HRQ
zaO25F^KXD!Sbsq+GQ#4-H}3VY(ZR3EPktQNA3mYgc|{8qfRgIW?qWREr)Nu>19%zK
zgGtr(2pl(iYQ&R}{(zhdZzq|gnH>r#Td?IeAPeKIua|nYwbbs}{TjJapy_O88Ke*`
z!;_+p_t{^u9E0?w=b>hf9wub7@%&)sRS_!OgN5|hjn2oJ8Lvo3HZ(Qy>R|T>09%@e
zcOs>mdGK|2g@m;x!?2bBu_ko2Mqdhc&tgPX#tYDNy6t=?&W{agqrfQZ=Q}Zz4kwfQ
zW!kW;KHI(x37Q(-`iQRzK04$|S24>CC)utQ%Pz}b7qq(ig3EXj+!>3t=Le`u-KyT_
zb=uVHK(pb!hO=f4v%!2kE?5xcNtj_XI3d4LrhH6U)_{aIjhTH;HG-v4B@N_hnKTV7
zmjNmn;@VkK0K&zZ5+zqaRq`M2bG+FB&C!YM(g|zcPG)EDXPi%MN@MJ1Gc$uOdoYR1
ze3MpU5z_?vVYQHhRGG|Q3c$DHkh9#1Z%O(R-=j<ylx60PvX*TCsSINDZtn8l8Buox
z{mLdr?-|YAO1>~~@A*YeS7_Y!yXhZ^Clocc0W)k8JM}y^wR}(!Hbe_&g09%jQ*^kE
zQyrr!Re>ETP1ShiVyhpvkXW|sUwri^eRLlWhDJQ=W_HsE>k<3<*mvp5qLs|+yN=ni
z$0wT1^^uZz=K_%0GgoqWh{cmxe_p}oYxwqSd-!-nI|}z}#~?AQ&Kw;*DQ!D7$&l57
zBqnCndw-5!a0akV8z0EY+M|785Gl2{E^&N)g5Wyb#f1=?O}f168KMF}`Mch>T1I4F
zDV@(q9yjIouAxb=wv<w<7>kS)DQMwqbqvVFTkaP^)v~Ph0qYhXRX4G%F63-p;tr_f
zQbwMUzt3LjQ6LcatFY|c<j|m<|DGfI(a=sY!I{@!1y*I63oXRUYErE1X5|PROs$|`
z!3>!OQtQw|)+}1-2z=@nmrW1#NM+Mqr>}gV?HRoD5$<m~S?>IqQcZhL86fABZ6dI-
zSCZ>^+$FH@pO(6HCw;b7w)0K2?!#0^G+W0&aq#Dt+MwS8v5kIGFrKcYca(iTG6%ji
z?{(!|m~>6sl5X{k7oDQk=x3>a<+$v<5ZUywc&&E#_Q|^MlCK(z6BXnbK2&Hmc@k>=
zWPMuW2?^kS=9U9WbBE@@oom2R(*A{fr-B_RWq?C-^J+ZK1%dkV^o-ot{T`Mk`VJGd
z(v3Pp_p$f45P^Gnf$|8Wk=Gg5PRAYmK?MCr<xXbx%Zq~tq{+yjU9<HsUPeSy(<jE3
z`vjq1NPs@nc2*bXg!4)V6P|0b5?-O(e7O7j-RsyAW;c|{0FzUNC*05iMH5dxf2FTC
z6uvtpBfWzs<LhVJ)2zs661^urVOI||0B8S~3tQpXk)U0|+leR>awUJE2*Y;vua-`5
z^qGL%g)2%X15Rbyep3M1J!T@>KVdumZ*G16nhW?ongWu#)o=DpV46cKYkpy6O(^-J
zH^5mk(#Q)7>`OVKA0^IxC0a{2B1;cFI5O<!@(4JuNfd6^<q(yM(48JlS<OUuli}5|
zclP><7y3hx$c!c;pG!%*IqX-IqEZB-n*)!(>@Ha`xh6FKN|2_|1$nZs{?$rTQS`+F
z@}!FlvZS>C@rQ@yH9&cH`TGbwKp)vt1wAo~(2GV=(o##gbxwpLC@kC^uAkp-#6)+?
zW>4u`n3Q?Lm+E@t)!<aW=jHkce)~OJPqQFt01Mr7xVkynoZlT;JjgdK5*U#~fmydI
zh(mL~Ax#F@YjLDfLK@t8v%Hy0;E@PAEyC`HpYEhXuJG}V2`rOY5ahvJ-nwL?cEkC(
z0q%no@JjI<o1U}#tkZ1zAK=n#<5lA%G=Q0zDH<@Pd|SHnRuw3IjlNrXt7n3J8mUr5
zcHSde^{d-JHqKIqIUbx~N7c~me>hANo9q;)p!?hUWHou&cLAYros>9xbnFSa1^TUX
z@PuN26c~pSXSx9%LskSwa+%j?U4jC=dAneNvY>RfhOlbuTn#Ifg^^_hnQs_iBU+uX
zp_X~=!bUF`1>um<EnA$qISvY-^FE|6rB2WZq;RLp^O9=9usJooS%f~w>e3W)=$Xh=
z|8TCMKZskJS6&!aw%ZkQt#>-|x5~=0b5-@GNgVv+=pLF}dBDLQrE41la<)M$URpb*
z5;@qNeKS#tM5B=S&3Mrv1LVcj7mAm!|Cuy(b4ek(1yl=deju&!x|`FYUSSkTJdcZ6
z!Py_6BJf?AP`co#Z*LD<{)IQZT+ei=E3SO2&?cFk5Y<|C03P73bo9aYC`hvAR72|=
zZAFlR$K=WXiBXNnmcG~@O34{MCr39ifXbpeO4hn(f_06TAgm%iEyq7`L?eHqxx33d
zW`xYr<)I@hDRj~0al7n+WB)?N8s6qKqP-<gB`5kq*SCX|mbTNBqTSgRBiyyPjKvoB
zNO)Y1Mk5tGv}}P%#2-DRicLTOVdI%#Ep1*M%1z2a?2!57xgmr%__k?m#^Gm^muK;&
zB_*K0?DT?`lPenOv7@}|>rZSrZfrumTH|fq((+P2*U*^b@L`;aEqlK!?+Aw3rXL<v
zy`X;AgT$I9F3LpU*n?+8^P66JU(^X+Rb6(kt8aJnmxaCGXdn7xOuYHRS%fi2UHKXC
z@;|HkGFd1MpX(Sl#l-8bK_bw|RkW|aDb1bews5MvP;^eMX4dQ~tncF6oZ{j;9AI>G
zjiuf=xYR_VwLwI7t<DYpS*`(-23Xm`6yj0gq&P)IY6S`p?@RB4`QP<~OAo4*!?`L!
zkeKUgw;=_*d&Nm$`AGrBGYM21i=>HT%I8NoKejwBR*Tlq&~rBzrt0u=n`xBVoJB3n
zoh-KiR{2F&Gh*GYS?s{vmvtSF_ob_wDM_C!$|mZUvd0}w_?mC<V*m279Z9c*q1c!O
z=sFkH(nSDAx{XILtV&*!`RKcpHsj#3K*3VjtG3riaBYBR7hFK%7+~o)=>~gm=x=UM
zXr$xC68SwD=>sK<JD8ZS3{UGQPE1~o+BSjCY>orkq%)jju<*f~KlA|w$)+$O#m03~
zH34z*J(5-^DM$`iLl8CzD(;`&UDnrCyIz207J*|{<84O7KrVN6g3J%#J4O8glEh}J
zG+4T~7WK;YoTadznK~_e80nIbwy!?J)lsU(CHv~;%0tTzsI3%RS#$tN>T7Ogv06Sb
znXWopjmB3E$=q&J%{t$z(Rcdsm(4GPc1mG?TxD8pM6!Mbs{0Up9ltNyK3L8K4KG(%
zWk?UE<#Drd>`mM+BhYInsgpL62X}=exsEzRb;8)VvAs)q=R(5j@5ySFikgXr0+y~G
zwEcd{5Z3h1tjQRJt*^*7%y}fd)bp}&u5J~K%12wR$tQ40ai+S3nn#5#$79_{NUunc
z;d3P^wYV!?MQ%wI5GlsQ4kUSdV5rE|VL@4HQ{=zX8hYscX>ABizZf3B81AbOmJ?AZ
zbg%ebPd9U3Is_xmEfo>5)&ZWkB1I&v3{6=sO3-!%JPcFa<Y!X{z6)ydJf@^a$ov=x
zTB>kbx_>6J-TLs!z{D(XW?XGoMd$33rV_u$;FNh#pLp_Wms9v|!PEzs6n+Rx6QPzM
z`kE=h=1Jp}k<4v(MZ3uPHL{FZ_#DFVuDI(Ci}@K5H-WlX3;ycYm`o}G+M2j7Cqf$a
zc_sF5LDp~36S2v-6+;2C_ySirZ^i}5EVE|NQ2#qSuFpnn^&=zahXUO0(aDi|Uj?kT
zH0f2UCu)=x>iuP!O7v-03h{+|Yy_m*mdPe)3#lhwguaRMWz7B<ovmIOxdCP8+3a{g
zOonSzXM3b6(g!~3m%evw@1KxrFDFiG^*%VPdpDGK%D{HWn5}0uJ22?fV|t^ybHf5j
zn->r^oUO~T<F#q-{5%-Et5!GIPn?Vs+u~txmZ7Q%=Z02(G0XoM3p?={Z9Idh&x^{D
zqv3dCbIm)HxFNB!ANDB?z0z8r5EJxIh^WK=8@ZqqIgwK3cD=I#xcK)|!d*fx2C+nO
zm&+I+=b(-x&G=VsgRpz_<k{`K9kOC;FDrB_Co_+)VfV!Nfl+m2iLZ`&MY*32wrfH0
zpCd>|rqPwhJzy=%7l!}v9&{P8&8!PxDOrAqtwf+&(hL#Ao`HT$WUmd@8i=+o&!OOt
zF)Ns{UwBwcjsjXTY;gA*z{{{<(tOMlD2mblTJAotte&GG+Wp5lAvuGyUzHm_^8v6T
z)KMm-u+In^{R(FG^|$07!e;K+`4-eY^QCcXoK;ZR8fIj`v?kb`lAuXsgSRH&&d^X|
zpUev-hgWZHZCV(_PowV61q+_<2|wNXly<kC$iw?*fNs;4CTFcn%C9wQ>7uIrP<sPf
z8LRRSOfkUi^Dj69CMPXUedF#5YXD$E(MXewtO-N9qz~1pk7bI7>L$9=SH&&X2dX;1
zj&iZHmUNGn8{aoeJ*vlZ06GHCb6+YI4g6;}O*|9hh4EBtr#9y<_ZZuTrLNSEQWp)c
zUh}9Pmr%Q&5L?VQ%W^BXJkh0`#S1=kSZMOy9a4z^d@ryo;-uG{-&XJ(3<NK^-qgCx
zM~)ii{`+Odz+Yq-W4Ia(AiWvD{YQN?ooq}RtEWy>IBO2`WKp0?=HQ&H1}#fWuGJR(
zsU@mD<e}$$gH+)qc*S5+U9DG|Jd|2{u^>|3c{wK&f;QV|*>UFy44cUP04Pap{S1kq
zOpeH0takR3i4IHZml;`bVRHEB93>jf)e-{joAy&a&?Zx(-~qUd5puSP@R2pjFa+)d
z3Dx&ee&h!;91OqppMk+MU?j1j$co9@S#xP&vzpnLY1hlrp>A~S{o?bp9p{VWd%Az>
zhu0ziG<*#uvy1`OfCy9(3T!zNupibpYL}lT@?Tx(FSY-Pci@9FWXjiG?4lru?tokB
zCFDUEfLy`RiRvyq{oJ=|Y4E4=U8b`xwTnJDL~a1QRa-uj*Uf4Z%-i*RTk*Yoc0LB|
z23#(D?Aap>^|gCv`%uxbvRpj=Ox5bhlDrd{*K&)E`t#kub;*X-k1&J(?^X%_XJ{5c
zZ1$1KdV$*$5_Dj;YyfO_Mc2)0#Ii6D36AWNo`4Bl*c$&}KRAK!Jrv8z?5cbOU6%#+
z<q~$=^13OuJ>u{;7S~UEiiR#z-{X#F{ht_0gG`6Ao&CkWsF8~6j~L8v4|n|7lOKq5
zWn~+yl*JedB|=VG3grIDbPLcAkNXQ^#>GU>$Ri5y|0TxE#b#cuupK^*E|!kg`})rM
z1s|oC_L^U@A7{YsF~OuH`?t}%hPRbqkzSN?;fEiKG9oSdox3!CDM*4nD*Sqo^)d?Q
zH9zb2yQuB`T@%#kmnKZU8p+)iuj#SR7f&0^aT$2L0wyw^!&A!+W#-T}kaHx`WXKo5
z7S($heffMG^_c{NT7;NRWC@@xZk)HS0lN^bVI$YTJ>1g-g8Am)yI|TAV7uYaC{rx9
zuKw1@`PK+MvWHtJat})34!^=u%}pMJysx>|LTtui1&71M{k_qN9I$oY!ZuSwk=yaZ
zebsjUP(*~63UO;*M|*&<tGbU<E4|10M#ri2b4dFX;B$ihpDvXDmvnmi<1h3=E$E;E
zG(o|z21T#Rk$THcoiMX{06N$`Hu5BnkCQxoN`NR2?L;RRO99fPc>{)IAqIRZsbp-j
zSmia!IoV^B4qTlvOq3N;s16}KV}R#`ag1;_qaL?5bH7`cQGL%SAHir@k8e=Iy_`>@
zidb%v1Y@EYb*u<)edMoU2018CS^+%6gJy^N?;hB_@)cN1Y7zXAf&_wgMg7Z61-I}e
zi{v1huvb2Bl6U#_VfS`Nbn5|BN#q6i?9F~LN07s0V0<L1K8ypZfQJc+LYm9~FH?zs
zO#>`Bu6m3cDmAI<UN~nW2;;C)2g}MRSX)9t9c#1THm=(`?Y|C#|CAa<5L?TDUeQ-O
zCT&I+QGhT2A5adC$(YyE()XV$U8WyAjy|av-M?_--%%eqN_-_4m|TfH_P)jG=#jdC
zyRFHMJ<ZUbNa@q*gsCWW{{tX0H2raio8{HW!Y8djaTcgP&Ns$;JLfhHKs}q0IV(Xc
zh&3~~SmiKjt)@$Aw$Nm(U^ajc&L)-_WMN8x_ocz)_;^XOP4cce(vvTAzyGy=cTJV@
zG*+f<9ah;G(WrB=yr4RiG2rBSCIUtEmP@Cs@rDOf+b(2wI5+7zJAisLXsZtA6YV)$
zSb8Jl|5Fy^jIxIE2ylJy5e>N*fs-`^SZ2)?=)2h`k^ecEdkcG?=s$%T6cS}l>Z-MZ
zo)rIRV|<`_6|dkkQlbgfsvpe=l(7NpinNVxS@^;%-R;kHn3_)f^T8qp2muATGdZ~)
zl#^mobR8EvtCZstG{016&-i$}@wwn>_-_Bp8sAGX3vaVhaqf&|&iJL7i79OT^hq}#
zM_tFO@-qGX*8C&RcPHLK`-`u&ka4n-VOIo6jL3v@?9fU{)mzBTX;i!lljKOh9;UV~
zm(45hVl2+yBENUi47j9WC`%l(^dB(~4Y{uQzO=uhr%CE%QF8XTEJ$9VD?OiK-oMYP
z=(wP7hA(8~KM5bVLi>AiBT6R{{&SG_1x?H>Lk2%+Gmsje!~wR*GjGC#39yvwOBQEF
z{C~M||03EhQGgu#u>En^7ct-qwtF_H)^5eMs9MKX7wgcj&jsMb#@LQ6rLPiMTsv9&
zgx90XqCqU+@IzN_PnUrOWPLe*JCw=hZ>9D*4Ise_^<tOjX{B@a2V^dug{ad#)HHlw
zF_?P-eIrS*D&jF&E$%l%AOGI%wd`h3^7oF=JlMmZM|D!J1y|7xvPZ?LD@KyZ#WOnr
z(y-$%Z=(0yb^TZAis~q}IU2|Iuip>fFz1r#f@CBJQeBe3qQYvv$It@b*4jW$n8kkB
zJyc&8GfYi<_Jv^rrDa9`WB7{&lk!|>cRuW13a}H+)zYJ*1iRNmNxuy=Hm4<j361Lf
zzt`;jB>oGH`4>m@|3!2R7=b+6p);U+eLYJ(*#N3d2RUyMB2A|Mu9(^gq~kywx&72Q
z-i|QRdE0KGSfe3PuJ-|QhOT1xg2zb%_-k7dqsbf`CB&&4f1a<jXtn;yrD8!CUjRd6
zx8}7m;DD;wV_Mf`loQ!Dp(JaQ#o>oLd&SG~Yss?GPH=XiWiG?hc_tQA+hyF>Hpbv9
z4|6|kOjH$#**7eNH0dSlTSf;|EO-UG&EF6wCvY2V<N%xb{|feH@dZxIEDV?uoPVqa
z{wIV)*8ZkDdyMkKq&It%4)5SB+d{|cv#l*@`A-z)*Xj)TYxQiUU0xsHWW5|SU}sS=
z`Kz#Pesj}2)>D>Wp?chpsK?)mm?Ad4zmV3VRp?=LLC1UXZ&#YPu1gYUtqS?|+cpjm
zSunSOqe)n63)5&?nI_YSxu$6hTttbNu|@m<5qzdO#K}5ZeI@5Ar73v%-IFWe{Js^i
z6yn;Q8Z5lj_A>OMubpTVr8ZzkdpOomz|N`=`rtn&VeTW|ws7?ap{?W!kciU9%EA!4
zTrT(vcPWj8{(TOe{yv9yFn}2ZE$EUR{(av+SxWscLt=6sNX*9vJ@ovvu&#)gb+1TW
zH5?rmLM&)Rh?5&hhyt%>bSnXKO(Mb&==M?o^sXQ+nySV-6LiUFw84j(Y&$#wtQg?`
zf;%}5!@#UsqOT#LhU1=n5uh--#VG^yqo-K4RvzXH4MuZQ7RAg=$m;qIiY^4f;V1lu
zR03{{h1WqK=UC8X+ZYKD_Ar`>YzsnfVVd3O+gg^?uZ5_9p5*m5oILQ%|8FM`eBc&w
z&m#VJpv&yv@!kKtFZSP&zsLUfprA1EE0`dJH|`Xm%ceb#u`qS9Q{SHBnK^#_tl8Ks
zw*g)21L>)Itsvuy9zF2|^}Y}YH{2ctBg~>w1*=SByIXAA)k1OScxpnN4M#T{2i(Jf
za8NqZBuycLWQ47~N1DpAf%xya`67mu01q$1ewBK0U%U9F7HEdMrCm+oUIs1)>%y_<
ztZ*69<g-a31m!UE<BI9MOPkgt?B1_K{GtI(IuUlMX4SxBx|j9)N@G&cWrZ8SfC<M{
z)xBITZ}n}xY=fpxr{qkWr2k~DI4XQ6a=>G-2lQIZI2|^6f3FFktK&>gI=Wj)58NSy
z!D^&`>y`eGbGi=&%4Z)Zu$feFr#RAOI^e}e*#Im<VrMZI!R|Tr@Q}GG`~K`Ytp#yR
zN275el$p@3dvDqsk@BMFLd7r^7SNKGG`J_b?*-~Ro(N|1wHLzalB~9)w{=SFE9|{1
z9hMF1+~Dw3xuMF{UYxA_?)O-S-!bJyju}g#Ms52pY9<lj)jLq#7#v3_HQppe@CjXq
zl=PhB(ll6vyB2nj!Pm#ED*ctMh&1e8^yadky@da9hsk@dcd)^o5flJ86|wPLZKn?K
z4zC8K+y4FFaL4>xqF~OLrHZZJVe^21$(U)W1x$m;o|9`~eZeJ-=#8-|Hw!;@mU#4k
zZ2dIsN;**f4wUidDw;7lOeiXUAoyL;wG%u=9^mqbleX&%d$8UMlj9ha;es2ot^Kb3
zk<p6&#>iF!@~eJnwPIkwU|#4*+aS|gB#QDgoOx0%_G#t|D~Wh43s~DLCaJtTBejTn
zPC2C|aKE2~2>LE1-k5$xhgqd<fBlNPZPSYHK#e=a(H^)w>d2E3guOK_Am>t^C-*v(
z`H??e9bN*LaEl{ut>4~T;VeXPy|yvnA9Yn7(DQg`{kvA&`f<edZ|-pWdnFz)ed`~9
z+)=Ylm;e7GcdY%*9VeUgUbL{zARk5%ghN}H`@>2gb)>owWUBbX!&w5{%*{^N(al20
zxrB45e#Mxitp86trX1%BCyq_)N`h1t*N>y2(Kn03Ui~fM-bGn@g>rhi3#e<a%BCy2
zu!x|-$<2VBM&<_}YZ$cf$w3<bLY%BroQimFA2+IqH9h_Ax_neDUd$}7XuY+l@K-Bt
zU*h;pCyC^e80Bg;ZHf2QIg;WGEp##A2S$K*v6JHObNQ|F`coC~wf_Xfulzga+W%RG
ztt<WIRDrefl_(sx5J_NQbXcci{aS2WR*G9ruBjIIH313q0-{HptO;~hn0p%>T7dt-
z#Q{<IGa*BuQQ_5V(w29v!6!*9$Ny8Cv`9-IyyR1qYTGh<T!sT@sYJ$+h~j`(4=KlU
z+uF6D6S7V<eVX|Rmaa0c&mHtsXH@Y2GXbAl;yr*~dthm&1}VqA)eLOX$$4Y2R{k{p
z`v?e$qo|UnqMF0^FUMsTrw1nqjwaM!)K>jJ$1m-8UkOWSqj|EnZI(B+yzF0G(cODm
zwZ^}a573wOua^eZqW|IT0IV3&0?6-oX4K7t`^<w@HUmPs_WM=f>pmmhSz*scFZE<=
zN^k-A0qfto!5HDu>-Z<oYGY@WG5s4oz<*}pPI?KT%G2C;7#VNxhP~JDuLq=k7fN`r
zUDi*=(SL9G6LV2<AnDYE#`8YD192plE8#G3M}bw4%eeTjmdDw@ZvXmN&wd594y~8>
zIfejC+(R1NP2{!%Ib1Ne7W15X>8g-=twTnS@#MbQc8a9T27k}^`QOvgQ(8huP~L<e
zUfwyX;{cRkmi2}xRXMU%*z4dd<yq&$=OU&W@?uVG8lEIGD-=)k6aeM@;RqkWbD&0%
zyIVs}9RoEi<sm(X*ucbpj^8cA`eU|7)0rCA1>Yd-zqiGbHV2<l1-GRtZL>o(sOecT
zd|YStw`eJ(1+vm~jTi1b4p6EI>{n0xPf_x}5AnY!+5{N?Vh0InWwfvcOn=*QjZa<W
z+0;u%@7-3WTL$)yT*~WE3|2Zv`-${$vJ^2E&l)V?@Ad<yNApzcRBEJx@+Ox!fxQ*9
zVosvC2y1Vjq>sfK>JKKy$r>_~`&X5{yDNP36v-;CZN*_j2+dHvuEF~^uU}B#gHvQ0
zG&Wq71^HJ;Bp6Ey2qSSi1H{S$bW3IY4f+^qM0Q7L=Cc1<ZXbG1$*u{u>(|^wIx|(k
z?(xOeQNws*6zuYC6roJQ$6~|F!ft%Ur!^<3<UrQS(3kY)4-%-rIP>sQzz+&abV3Zm
z-fX<htwH1+2Cv+srbdi3*62&LPC8W_YU@h^3EbTi2sdHD7EMQapjqh4WqM%v_rq=a
zZ-f46XvkA+eVg)cjXR|EWmc_kNR%Fs0~$wf-l$84uq&6UgKB}j(=P^7n%wqoI}N`g
zXWv_ukE>rvxVjuByekV=tF9tK*Z1FXRZAxjSSeYv%fD_n0nqtk&rh5->Z-G~UU#lf
z{Io=1VS1-#HT$=!B^&+WSXuK97K{^@7VOk!m|6TDS4$7M%pxsd5ey?E_gDB#lIvA-
z-;z>$uJ7^Yu;B{gG|3kIv)7{Mscr_=L%VSL7KS$6PkOjn_82JL?x@N}R|n#w*tn8F
zj6p!R^hF#1k}R(}A%R0S0kd`?v&I3?UdM76yiDN~PL2|4wfAOQ5u8Hem&^8zOiBCp
zbvhf){I^zfM7E#M8k*6=bSk2C^23dzCn&wuqq-M%@+;th4r<?Fc>KT1rGMDM2Y$_A
z5O@KEOgmLt-|$ev8Z-jx(MyGHYR-^`mf$(GGKHyzz(196eqQf`FR1K3=(+Ngt66|g
ztgxIb)=TjV$<xx$=7@dh?@QaY4(b@OOEL8s=2nk!a^&q9m!2C;61cWI?`!eBd(RnJ
zQ`wwPKI;?PYUbufr(mu$$=M6K?$k|}(Xrr`xY(EhM$bvz_7%44tCC?@^&xt?pxTna
z@jqGnm*e(ArfAastGtNJmt)F+N02c4)B@n%gh(@yHZYj=I;a2*$HcnP(Fcj1_>*+t
zu|N>;rsYwbgmgMlPu_qyw#^7^92(mYC3;Q~S{;_|NX%6Mn^@cu-WezBuLGM&x+9dy
z<<1w}i+hR>>lh&{tk@DP>!IngN)g9|YHK9aTR)J>1hq^(KAC<JN%ZpG&xki@RtCbj
zS)2wJ5A^RQf_1pRVGP%uD321b`!UNNZjWaA)j`yI8jyLb@Mga?m4RHS;3*XRhYLJX
zgtNDrJwLNTXy5UN^hCddR`kx}ov@o`c0<OBlUu(h+^$rVHU0a$WP3H>HblOQb>21k
zq^JLJV{-|K!7ee`-4?=^i#W-j_Ha7(9Y1U7E=$1=Cm^hbfEZ<S%K<y#GuDV3nUQUX
z^rW<O;3_Yt1h7?1VISOiK{NRR2=2z9GBrNIe4vHLM803Ihpy+q+PXCv6<Y*cl5ow<
zJNPh#jhPldydfa9nZ}YdwM4XFiZpq97}%utp++YNIbv1b9a#Usgx+##oG`z|lck^n
zIdjYYMVS8qiu>OL+G_l_lIufnJUphCT@OK-eE2>uxVaOpRAvEp(r|fPyK=S1!wn_n
zlh}o6fWiM_>ux&}6tM|G^{`3P-p-T>uuCkhD8jE}U-g~l|H<5N(Ol!tWma)p#=M}L
zA=LJC561McU~k*LjJ}C0jS;GTOh?<Z-ov#XnMkweVBLa7MyX-0joEJui-9!pP!>jK
zAY9d6p0j2?6O+38o22s1bEMlve@B=9Rh3=0E&b8bTP4E^0J1}AP5-OdKJ-+2L_cSO
zT=oG>G_5zE?A~_Ng{N{SR#nqUPcG6?f-Wia=~T+zxN`(N<7cS{))13*U`(C8ZMEZ%
zj3=_;!cXfG<&nc(Kz90S|5I4ZpRD)KMJ{3^D%ie^GINMh-@MyN-=b`FMu`azELx}x
zj_ZVy2G+JOk379cnq<B?i(UL@VY&a#4yWD#a{T1&F)|0#-;|SypxQvFQMXf_@|XEJ
zQ{-BhUCCv4H@<EhOMDv|s-)NQFwF`GI)56Qe=I$e&^O*Y`{<P~^ExZ~@xofpX;-)=
z60D>Y9R*!$Fb)V)#bzcy>)EP^7+?POW(b-vpLcYk3kuP~O{NUWrjsI87jvGNeDCO%
zqu}H={CvVUj}7DLCpqD@KZT#=Lb)%%(Va~#n%T977@LJatb=tq{KQ*U-d~wvgymeE
zBmMaSQ1^oqT&3^x3mQT$9Yat2@;S2yrlqe}5=Ks;uyw5{UWw8C8*|+EVNU4RPUOT1
zv@fwE$?}y+sI9IugcGGfIez6j62*G6i<SfoT%kX8jaZ4BP?^O!J5)Y20RmxKV)a_$
zA@h07KO@bVtZzCu9J+VwyCACb@8&n2Du+VJ<3A(i>*2xuOe_@CvTf8l0rxAA4S12a
z2Z&l=HjR)&%&vug+Nf3OZwNJcmlfiY(Vrx$+cD?Y>x$-g1vUvr^z<F^uDdQ6&0cFC
zNupg@5#koq?NsyP$a*XOAIjb`D(>dl7RKEnxCABy*AUzxLjnN;1a}GU?k>S0fe_qv
z7+ePp5(or$cXxNVzx>a6&Urt)cRjfuVa=M=(_LL%wQJWd83(?~i<62zWy!2e^z$}2
zn-$|ALY#WSY<Rx?W}4TLsv1;!*P(?g4!kRD1E6PK32-9f@Sdd9a>z3`cRHdmP)UGV
zAzY7gp(T^6w<S^*p>^k5G<1;U1gK^B3Vf-e`TOfAjQi*L{!i)Ycom(J3m6yXZ|N><
z^QJfin%|V9u0lbSx<`}-Ef5s0Ln%Prcei^PtkMaOg(7UPT`aDG#`EC|N<P_aKmxX#
zO1AdOuxH~fq^>c>@BDW6tJa#XXl2TTkl~P}2%#%@&W_qkr(9-eFXLbj`Bc>l5(_CQ
zvAEAYw*J6fO^_-7Ub|o(D;HS+BRBOIt1U;*NzxoeLw$x!ok^CzMew_KSuJzQO-p4s
zwL_OeKC+4;xZfd@$_UQsJtc{7HeZ1`r6W|g<4J(*%GP(;z=DLm(@rsfO%P5dEyXJx
zmD+1lzJl^KYwA0aZdRi9gyKNq3v*5(g9>E)byw3EMMG;7Jp497>Lz^Ck4l5qbhWM&
zk&)UByo!c1<X!6_Dx?&#bh1h_X7zPQX7o7fr|<a(0RP9mk`Vpcn|4}+2qoQhTK;!;
z`G(TlQbVg9oNwxr4t8v@(sdmy!J<_{SUv3)Q8CeL9nNT-_zc#jda!7W68eIIpOY1$
zZm4p=i0J8pDBT*G=i)<3{$(IzGV$$ckEm!A2RdcxS1sW}>f^42Z`BxI!6c7yhYZ|J
zkj9K9u<SFb)V`D}4G(tVY3u(Cn(@+@`3%yu3@od|0t}!A{k#Qk0L<9@qXIrGxp>HX
zqguM!)*on)T0Ykd_I`=ff7WX)ChH$#j!-lAQF?cgs*A6#5|BWe0yHepgK%xJ7l$VH
zuA1{{emQ+a+6Do`rj-BQt|*lNyP_FE1Wgbi41E`0!WfqIQ(_usel~1UM7vwP+)+fq
z5bFJ%^cb}6(r&@qF01&3gUF4ExJ11y`_b7--K$NgWYZbzpz&6+g=I(X5QMx}eLf|!
zYHyd^gt>d9RW8);qPR#lS8Y>PQ5};_kM5A>)m9zx630PAUf6WC+A)e5yDzdvx_%6q
z)%GQ4)0eJ^5T41epCW#lvO`8KnB?6Oa!HDknjtTCRL<#P`d(X>7XSiDF^Wm<<$+{Q
z6(^XARpEt-M=Btt#25HAxA~9-ops62zc!JS_d8NL+XPR*^{=m4s-rdNYHnz)+dSZ(
zJ@%f0vM1A0n#p6)yZcZjltppV3zSU~<Lk>-eEB6by}KRy_lnpC?H>YzqF;Z^aZI0z
zi$}k>U?%*QJgx&#`pm0k$jKrxn-d<a#<E4S#@J(8DJ&LtWLs)z0Ybd(=4?P+j>^c@
z5DA!yMdc!QZ2x`wzWEo~jruR3E5;jB?hLcR(G7FYp#VmaOS&Tq%#xqnRI>+dfCu<O
zjknkhyn93N`%y4b<r+>eY*;H+q)>eM=|JBFJqXr7h@_V(Oy1Ro==EkiJl_QeY9<d<
zO9%D3J618Mt%>4(tG^zMh`<60c?>`p;S7v&zLHyH=;$OB^$3U_VMSBjjE@FP36R>n
z+jm(fCW(8O7q^UE-kxVhKGdwpebLyF;PG-xy`-da{BR6xhpo5i07O}vxePA<-of!t
z=&<}h{T1i|BvQ-WXv0BUub0%`we9+$LYQF~bI|@B6&DjAiYhE2GEdwuJq;qOh=}X|
zOdB!$6`us$X&Z$!kLH<XKWkH=2?$NfCm_oc;oX>7hkq@J+4Yh8aJW#_3cWmEoVoke
zBLdmZZCX5j{B(eyck%4XS}JqI_W(L}7|MgMCHMZLMR>$BRC<%*Hgc6ps|yt7M2ypJ
z?$u<3$+}k>5gQd1iQS$#!R}=-lA6%MF0(|^1;Gq2-r~gO)V&rrU#q!v0#~oZbP^!&
zl{k@HYW4<3vE+ZrI;i0HM#G9SaR2gd*bozNRdJu_PA~Q#?*j)d5l+6M5~*B=U}ncN
z{cgS?j)_L)vQ^AUR^&Vo7(_vQ^AU)WzVGS`+0lM2He%Zea&yM8ds-#<NoV@~TN!P2
zWq8Po5K%d}!)+{-Tv|#Bo*!!OjJ+P=d6To6Gs<#IE;?WF1fd-ns{G)QrI5ScT(dhd
zu%*(r&iYW*U~q!fv3Fw7YZW+Vx$5#BKQ$ckBb<;FO_R&g7~yhOxb^x>URZ;fE?NRB
zjX&l})EhBqkiap?FBV$ML;YQ`L*d5_Y9Zn=x$<Wv6TM{pE}ua;wHD5hK?7?`1Ur2!
zkTnaag+C1G2%q8&#@r%WXpB5)yW~e=Yq<R2-Tf{(@zksFAF9<vWPflT_*)0$ZN@<z
z(l`9ua8({WeE^IUUA=4lT$wE=K@LP1OPjp<z^x6g)R`i;ugze+-4Z4Qs;Dvf`{6)R
z_Ltr(Oi|ozMNog@=sbmG>dcade5SfmesAXb*y^P=@FmNd1n!0iHJb-@Av2x$SxobF
z-Fl`HDgoA<-)nGUJ3mXrl64YUga+zKH?ueB^77lLX|Ms+cWHdBg=wDbB$s)Q^4_sU
z8}w$c*Nc}?mnSot6>IJ;<+)tj-<z6zuN>1O_nVihPY2T`Q^Sa|<s^1%T~yR%vgjr1
z0mY=@TEUVDatuJqcQf*H{wW}ep3!R@R6LYShrEN*RBd<oQf%+br9|pveG_14F=)dg
zJ;!J<t!W4~2*rbfptNi*tl!Pi#o=)5()AzYOP3=R4~>190)!Pi`v|%DzUy#mpm1^f
zP}*^gc+eRI*z5_e0zJ8|c7!Z*9tq#wwahxIi<MSgK7F#ZKvH6VS`16#TxZI4zKGTE
z;taFeQ_XvykR-!ybi4jy(IdKeG@5_1^%l#?ZOg%_I=F@j3wMh~h%3~M{lo4cbY)Y<
zuVY~jQ-hT^-juva;@4txn1Fkm3jFv6Ir8>0BmI`#cLC~d?J-rJHM#54DgEWchZnqi
zL1@(K7aoL4c8K|V`gEzxhI4Kyzh?9(&+?Vz+1DodrYb9H!Uu$rO^^6HULCDmpK~sz
z7kB9C^hB4Jt^VlXRXZal4J0HLy5f!Da(SvTBWt`6@V-Bxn%DhIJH*R0!La^E6y5g)
z015#FMxn8zAT(@gPABGw55veRwKyohojweiH&;_!vnsP^B`kuO@q19bir#*TWUPWu
z!uWhxC;^0Ef+<xTe`##M$0&IN6izg4ti(<<Npjx!i|*&rZeRv<f{u-lwzmaLuPinr
z3g~x@O3R3k1~3+Njl_twG}9`}-wvp%dfKy~!``98&{MnN!Y0~3niD?yT`pFO#O&!z
zc?+7sMW?~jajOXM_f=VY^v^9Wnu(@aZFc^CO0^mcHn!8QYJuAP`clgJg)UrtJ#7R&
zy;B$hQ4d2%L88aYzNwS`2yLF!oe1feaBDem;*w>4@}N|c4Z1g5BdM7q<*FmS(3ESj
z)Om)k<rC1fLJhfr%o{hCm~3=Lmqb8dV=lPm`di!Nn~jvr<waS6fJ>d;%`7RrE{4iN
z%43F1&)%v~%bJoZeTyf`MW>fE!%%ug$h3LJvUww>&wTnSSp(zaNAODimPtmC!k(w6
zRayDjg<2xS`1^|bg0?Pk1G!E`lSkIN%P!KcguiV*oQO31ZR4ShNdnx%51vg@s6Yqd
z`8#BDNE32hr~_6s?uwZhnRp~y)P$ngkB&}(_eWioRQ<=lU+2tgGfHf&d^%rKIFE`Z
z3SPs}N2ug@3QXJ~^RCY5P%A+nY-ePT#$98u)02!83673^3cdM7=G~O|)3qQRKSNX0
zHGBinylUTQr|pr@iSU(sMP|3_m!r23=<#u=u4bT)N(?U3v^UkU^L%@+JI$hdKK@}B
zN~_P2)bIB;##|FIKjSL{;})h4rEDDnLb=z}`1nAHXdoUh605Vb?^-k6o1!5HrBsh)
zN?0xTPFPp3mm{n&DgnE_zM-UM4`HG{h2d>WNImrv<p~{kLdZ0v`mfJhhPXspBG~lw
zjcVCZ3Vp%-{*uf4e`*W-@UzH~Q22nKa4;{#V^7i%(F{rUM6(wjLX_;d!qE~)*Ld1N
zk#x?^sM=@M)AO@GP};Ir+Z&Vwnh?D^K#_1h9pd>ywEw)y|C;yjrT`Ty7a#Xe4w6~Y
z%fK9)Kv%gl^<U6WB!i_LDP#E_>IbAPl*C!8tufX*v&<(+Ph`292I`VER9Tq1ahW#G
z9y?+x{soKLJYO%6mGXDQN!B|`(1n?mGy?Txq9batx5=^ltVBxgxD_XK#<*b0pDac0
zGnFi&Q!I5YV-KAq{7n=5d~1d2&23e%CQ_CaUKWD6rOhUCEmc0pL2uRX?uWMJqs^Nw
z^CP?SqZ@sTvl?>y-uUyX2&A5O6J_0q2Sr5eTSyyw@p-aG=RzjJ*?X9A>eL*zQa`am
z!`k8c6e*LZclQDz4<1o^)a@MlcEMteF+xYa{yX6wtS`yplX3Aswy^qQ_@r-BsN*N;
zONa5rY?Ju?JYAQ<7=BmUgAlbmuL$o62s7@zu4x2K-}HEW&vgIXG)HFrf?Re(jOCkM
zQeQPuQMyhcjcmf1N4ou4IL-xU*uVr5#0^g5fy#X+1k7)=*YI?B=gwalB7iZB-6`wu
ziyY)*V}BU7Vp?Nq_dKj6`px`Zj|@=~2^Y<vfmm@FJarAW-p>g>-*6?2;h>p!UG?9N
zySs4ITnR$<{6mZyUh#)6E~+&<Cr+V&;~rOIpW4sY3Diixz5W8tp+l!Ve*Xva;zFni
z8Ci$gHi)qE@Se>6^s4<R9R5B9*K*?~n#xw}{)a11J#Q|g8vf9lsB+_-by>NwElZ4u
zsJ{^mL4W(~J<>L&&$Y?v-}}lmZuo;cRa=)Xvoke-rgZuvegzm(NWc$*zXktz$Cbmv
z(o*{^=am2T<@F1!o%$>ZCmwn@2-g{Mw&uG5HMtDBa@wO^8(JxBC87`)9&-^$$972Y
zpvSx*M*6dq#MdiEr+A19h3tHG(Uq3b=4HCclQ!qbdgXG36OM^k(0VKs-M1{iG`X1W
z)n`jGE_7Um1Z|>9R5q2<%hI%=KJ?;d^a##u!iC@bP5=n$l55rrk$x!yLgXl9pC60A
z^y*H-hd+8^!-dtZ2QMO@ELk)BQt`5iYqYZPPBn_F>U55ydMW6&_hn%$*P9Wy#F5e5
zO&l7aQB?v)f=HC*cbl4OekNV{G~%U^mi99piZ!`Ll&2}`u8BU%H?ktoKG<_)6cBix
z&W6!HY0BdqligH^+W8>i%;UA<q)b%P6j%6m`($Q#Hsy``CmgrObJ3SH=J1|r2<MQf
z>G_aQXOzW#c<URRQZ~`9EgJ98;xHDCNCy!MRQQ__0cT`Bzei&B*bAdx!T<(}9@`hH
zp9%Dzn;WmI6-G>BAo(OTY!xzz`+W}oh0Gc+r-8K1AT*Nas{7w&;<??|5ypQlof5P(
zn%!zmH$?G;((Z$M&rhCw^FrKc8>($;a<ClSF?bVib`_EO%qvR6PB`x5#TEJ1jWi+r
ztuPH$a_Zm5a9h#hGeNIJU#nSEUzd&nmQtU~aE6c2!*Ki?Z5SgQ7Ps@n>|;!STlMjw
z$o(0IZ$2gTWEU&9`8o1lX~*QeqKnY$))Veih#c-vPRU+L@L^AHse-ENy<T{qCh_G>
zr^YKkW|ijMd^4r=^8XzFZVp%yX`9?YLEz2^eR#8XD2eQ5W}tUS`}0xh@?!m&hTf7?
z@QCzRQzC2Yw12b!ly1K3*aYYSYWg4i4|~cJ;Hb2_&HV03zb>iziyn_$?SaLRw=?fI
zJ!(|!W4uqPi5bP07T>>;tRcwr!az7z#M}Umzm;Dg)~+u7?KP8(eoM&XqXHHZ)ZF>i
zt>dC(<(v{;)&fzMHZ#(8F*7ij1PizB2T62$ayYG>oPnDY@+-Ht?)iNJVqUswp^E2U
zud>q-&H*cj_Z)u44uH(@JOoT%XVMgDGcgU#9N=+9TcW$WU997-ez>js{O+Wi2yPE~
z4n#_8NZUPB;AioRG2&Jvu%EVBx!ut?rO)fCW17CEYAgv{E8x}%+m2T=lfd7W_VzdY
z{e9Pw24DpJuH2VS#0ZKC%amw<V0Vq0xr?q;`b1;co7q`<dichic;Z}_qn~v-lC)A+
z#a26~S~oB~sH0PBncqB=t2HBJk-GlEVUKC1@wqTb0R+sHhcTz+vz;hntIz{2{D}__
zBR&`#XaiV;f=$dIF*okh>Y(^csi=G5kcmW>(nD#o8-X|3B)y`CCeVPH-MvuA19Fru
zb=O=u>at?l%4HLcfu#|3<S${#lC!?4H30W;XX1Aw1BfB|tZ2h4ic9&+_Z71K)CNfA
zQgJbK_gu)^VU&F1=rUXM&9`eT+qSD-rk^nG_V&KdMHq{%g-r1Im$l+FA4`I)D_!0<
z--(*ObVk}%0{i=twXi9yo4$<8?@c>|AqgRh-qBT0>wW*R1+*;rzK#kirH~Iwa#%BK
z>$2BJyj8w(sHhAcD!i<yOD)xbVodcpqx_nN?+~KxGIDs)ih8s=NKcQ%&I=SV+sff=
zbhcW4DAZtc(fLAfAIh*_T=LmpJ(5q>=e|87Do)yBllE_&K5|QL`TJW~C<j!N$2Qn<
z(F3aKj(?*M%LMQund>SO5z8;q>B_FDvMi13FvuOql66x#iNTsD`C;?TpB^OD^B-k}
zHdDHtq43U+E2bN7hhRsuE~-|#B~~<tBfSE)BC6U*+ge15d{0Jb!v(!VQb{8VyAp*y
zg`_tg-{Ldf+SJ$0<QH~rgP<oEp*>;8n~I(zMwo^hV~U(l_Bdlg4*Ol)M5SaQ$=KH4
zDC_kK=0;u#O0HbLaduz(?0aIys$&0WDiVGX2)Ce#m*rR5C&CphCd4XELMQ!n>G6#O
zd3%O!J{;@E6kinI617AUU+4md*w3_GH>ThL6U0(%bxt19&wRd<;i3Dy1&{ao-=PFq
z`qF04Bd@1uK$HrgaaZitN#dy57jbj?-9bZkYb*QY->#f0>Try%YwPWc`TUjkkZ>lq
zj#t$Czw0i_q@6m4{xn>)T&sPKOM$%YEgHtdcBa$v{qrqS92D=G`cIut03LQRD(?&^
z53(VgU-8rD7ytb^NoLssk)bYMm@+XP67{>~-#~-tj}pyE0#ldP7!jSO0uN|ni+W7f
znafb32=Q6p8*pJ*Y69xmr$njk(LU~Uw~r#a1$(JIQyZH$Z+vpm{dVhMr6tjW<B87M
zgHt=Xbuf7s-Sp9XncC9ducr74fj`PeW&H=&t14iu_OBZZ+~%BL&t%XAoc$@W6wsYI
z=`)n!@Gq;yXBHMz!b(A641Z2Edfw=)bM+9sbj+xCH-kxPUftR1K_V3C)F9FlurYv0
zX|gZub!I;|*1MVZ`Df~guf;YX-D;-<lnmio0EKE_OO*PgPGtC5f`%wLW5hr5yWa08
zy>CQ$ztwZ5?*~`=zzvCrMd0{F;ODpf?EB3s>Q@nxu0xUX(>E$Ro*mHn2xh5_@zPf`
zas{}zUR=`3%~&(K6`E)EbfMNS!_8SEO>P_1(d9MjB(r?~)Lnd#%~=$2gznjNw<%i!
z28sCuS^Ga9aU-0sznpZ#$ub(A>USa`fQR{(BUf?%eMqg40ff{HLmxef5VqpmL-4Ym
z@#hbS02Ixlpj?jNZ(qW#_P4#M_8N5b_TLEkej8O#y%J0^RKmO|I7~L9?lCXxVd9k%
z;I39G+sdymH6R-2$+@_O=~ZSLv7~FK*hTx|OtH9rFg7l;Q`j>V)XxXFz#j))y$+Gh
zBN2%q6ajVA=lYG|8G~@13qo)Af#;11?5ih~+&h$?YvAD645#JEZg`)c#KklG`@}U~
zY`XitgSXCg?X#J6?<c~FPXewl<d|k7Lo?u;eZK%ryJah`MVMuSw9SuWEZaC*ak?oT
zk3R)B-M&l@xx*=Pz&vN|&kAVjwgsv0HxPd-*cpq?02$MWC9RhyetrFXFG`sGMz=cW
zIEi?hQ+RyF*2#^T%J-$Z=Yzdd>4*>R7p9n63rxXDNtI32K?8W7wmwpOq$1wD$NDx+
zPPc;ht^VuhuEZEd4q*R@0?efRH`6JO-mt2%)JI_q`C%g)-U!a7GKv?H;4SF()H~fx
z&qtn_#>Pe-zhr>eI+wamQ+hA|G7akNutM#x(tPYcxy?C5vr+hV<~chWaF~r>g9NAV
zjI(m!GM~BBx#^o@Kc(Cn);PVDjy6nkcl~Ss?>TV%x(KtGkol6K9o5<9+S6Ay^h&eW
zH#N-wFxH@fGzj)TY{;HZ3?x#ChA4Zel2?4u!D*{O^KmXNDZdjaxmbBT4=G#6Oq!)B
zgE-2z5W6`GvAs-6No66%boN<L@}TluoLFPV2~jULbZJ!BaY-2U?5UZ^O(;-jo)UnC
zvKJ+m_tUgYwCw0HqY+c=l7p)RKaB&`VBRDqu)nJu(zXo9&oX~Y*S~JsyMkYEWMnQp
zb;u<*-so^~U&<QFeR}3fls)}R+Ls;C6iGRf%GQr11qL3TTMC2Z9&B4<ws)t3gjhDo
z8ifhxBpuB#A|r*a_eEP;H*K52@UQ_2ne#|7V~<nXR!v2thjzK*a>9qT-0Mn$yg$y_
zizJe@ttI)VXB2*+O+u6A<JTq8p;N{Vnzpd+Vh``?1BsGsTo7Mo4>0xpmV(XPpv(E9
zwLgH*JfV{+hO*ff9Hy7iebD9;n4Apg`v?u25N8#d3S<gP*0~~i*&4dn;BqV-cV;eh
zjFMz>kDj5tl%igz5ajaq!18G!!b{abYhYq6*-IcGt!C=FRI6-rM~%dkYY?IN0sfqw
zy+IFj9R!F!03x0BjmT<`0p@OkhV?>*`EXQdb-8P!{8~)nsAK(~59|ybxq_h&q^C1H
z+%s6p7C&uVJy&e4!-m!*bJ@^Y%9&74UJ#Hi;vVl>I^8T=SW8vplZoic+i&H3=1??p
z@}Y9lcG&OczCA2vALPf++FRx9qx&y<+`p#jz{mLM5oU8C^C{hC>BR822{;j0Afyb0
z04KmFzfS7b3<8{vOeXqmAXIK(-no@H3O8wwQdg?}f9)bhFeg!D`&Lk~mJnWRjDPN+
z8<_ntJc-}6;XspiL;8)uw6eA_?5$wzi*#7wN!4si!im<%=uC9{3H-ThZEpSuW?SSc
z4R<f4HK^_ZPcBmX+B3q!?p0YcZ|F;Pf|Fky6}2^iI}1FQ1ngj08?cu?hi#Scw(N7)
zr&reO)!rPDEqP%ZQ1c_Rn>~=ZYqx`a?1mhKwf^~vrIgdrr}OhmqlS9)0|{JV1+Zf6
zDHo=wc$|DsoGj<)?kPb*n@9WSX{CMBpyR9aRj^_6?oDtNcEuga@W4riUm2!^8Bu((
zT?MQm5FKNN%PVdzI;*K3RjMV;Z5TIm3`Zz;X^Z<E<$jrw-3c{uW2;xcl643$=8JqQ
z^W1|AeY_2B09D!@+1W$*7&UeILfO0k>j0A{ySSPJTaSXKWEy<>JSuSjF_=ziU0JEi
zh-*KT@a<Uuv7MC|IR(P@x#>!k37%p>T;C}?rs%k#i|6tw-;X1gQ$rHjkr66uw%>+M
zR;UystT+kMx-uNV$!{C<{cBI;|JsE6E>ew*dgDY#wFe6@@>7hG8{l<W{>P=5Aepz0
zPvt<i{cA&}tGFS%eoIL)!#XiVrCvNN_2AZ4xLqy5s%m<>5<A)5+l@<@q=QKJ+d;wl
z=10ev-CQ31zF;s6*6b>74l1az)i>9<kaB_^9&OK;gf1~<%Zxmv3XN=R-uK<oiKp(Q
z$=^0(4l|QickixFDf8o_O&jKWQ)1FQe`CSkNf@y>Kjz_}0~tUsoWu6>S9;gzBETr7
zJ+Vf9e;Z{@Fq21cM;b5K!2`<XtwCaZX%>%tM2m0sV*4Y`PHDvWe(>C$1gJlqbtu?1
z+7V-Zht*hC{o5Sl>uO<Yx#uaHK?picV-)@b8~4-<ItiIJX+fiS6UIo)<SsGzYJ?}G
zId_I#Yf&{AVAD@NuW4TEO?aQ;XdJY5cn8W;4<?Ohg6=3eV%~lspxatKcWkjP&#8f7
zu4y)!1`ck;z3Yz8nI~Pl?Vx1QG?QE%6G+aRG7I_R5OAnv^|Vv8M_zIJ*VR2oz+s{3
zvp?4QwHH2spe_0<j6PvHO+pY~g10Up{eVq4ZK>NgVk&9Vx2C2pyL=%sOaDzA?;+L1
z>w;sNa*G{lqIcl<#ksj|6dKo=*cW(1r?)Elk4`Is6j&&jcCjrjB6@9WLw(wBCjY)M
z126<5gxR_OaSP!mvWT?y{|OiQiDUqZ2!e*7R<|XIguj}T8p8QVYvCYN?`otmf5LBz
zN+jZNX+EBvZ%ciW1b+7Ymi6eCp1&vsD|gAC*mOA@U6=x)h9bZK6Bd@xJMZtm(1FSp
z15PvxzV$XDY?>4Lt~oEo_zRUEfyzAZd~SwZT&3N;qRYJ~$PL;1yOf9tKJF2yraIh5
zbi9(vkjP8)ea;~b^AT+f^@-7jEYfzQOS4Jc-{+cXZ14vUs<ySq){7BvK6O2^U=oC-
zuy&yRZc5O0UG>}ugiw>xs%8LjNz8SM)jH&|`Uc}T+&0ZWiEizW|0;(a6(|*-8k^FO
z@6nBOR^Z@_v?aBcjM0}?ayLn`?O0a%T#n0#hqPD=+Wr|;x6DNYlR1D<je8PmG^N)1
zo<}3ksbo*JPU#Nzaf&yIh5?XgzygVA0YEne0CbZvsp}Og0O^#93_BvwTJ)h1X;<H0
zt>6`CMJWCFy4fB^ne~K);wyTa*iV$R0r~te;vRv2MAovn61uSBFH>8qjfsCSA)-W!
zz?1tMQgoTj^Jd$Gpx7CMDfD(|6KCmyQe?Ti?-~595fw)=^zU;AGdXcDmqhLVhFK0O
zzl?;mUja;i=K#IhXs5StCxeIL;dJA|`w7_whc#sK;h-2%91&BIoQ}*YpWbM0k(Zp_
z5N5q1%7W5~?{zw(Xya!M!NITq3l-NTDDs1cvE$AqvjM01N{R#V?}<<L@aP{ShAeNH
zp&<ZN2;hwF{-63Jv)(QPnB!g)9JB)=2}EH909#yvRuiK@KmVq_i@cA7koP!bZ>POq
z3yr;&C49)!7nVL^JR`*((U~9f{$k)=`XnKXE2L*4*IZ%4Ap)CpM|0xWtI=xD#89@p
z5<j9)W>*91I#_}14!I`^3=H+o)tQ>Cb!ItJE6=_3cER1C23jAi0n`){fKN-0P(!v?
zoCj2Vp8e+j4D9$2+#fn|K#+H!9Kc0JGL%*Sd*dA!fj?MMwH;WkR)~bty($c1t%yMv
zc0#C8wyIUrUVIfiR~2V9K1?ERLkua`;nUlo{-}l7LhtaM>X}zjnVqGct-3BWr&Cgb
z4PHyeQ#1w+Dmc0~GR7F=*#({|(lfL0d4|M7u{R5I`J}ngs^^yM_NjPwN+iLH2!8hW
zw)H3gv0=NBsRD%RTM%&g4^(4?jdZ}Td8xaj{ja(u{}8PMJV75$*CTRLWUW?anxDbL
z7GqjVw>0VOc@dl$K;mcl-HTf7{kK+7^3D5PE&HMzMM$mIf^2L#hr1xO|3WP(DP%|a
zonhgN({G_A88QRDk%VI~XN#QINX8<T9uN}KD0Mx355);6rG8?<l*-`_zt;qWx&DLC
zZk6Mq!)27m?uGgg4Aw#`Zf4-3`5ZqBGLvQsnBG_(n=#ON@nHx^w9B?~y-uwFL~=b@
zHunGFd^q3_dj98p+O`5pOCQn48{u?6T0;2pb4$7ne6q)OltWfy*u_e3h>`Vdp1%Do
z9xR$UB10Rtd}k@rU7V71+v|K$(x>X84{O#rZD^qrQ)%AM)dG5li4w<#fF+$L_kRYK
zG|m9n(cW2uC{#5Z?xChvw(b96ouK~!?EmEibz{x^OLsJB|Li|1NPO%YlpZCM$h-PG
zgu|S&fisxcH8TFtg%{aSBxqEjvUOzj-G!k@40YDHl|>I}IpsT;#)m$BPf@L2QDJ?N
zoRJ~J!R}{7VO;W3xUS~f3wznC486mkU22-8alEW*fY8A{y-?S~_l2C{kE0`$VW#@i
zLmBl4K_(M9UUHbB6Zey`9|c(Z@PC&q2bg{FzeHlGH$BlT1cI@biujt&=>Ur$1yvcd
zYnE@);@d|mQ#mGO2Nz$}d=LTsKs~>Bv5Q5Id0vkg(0Y(rfZ{2dZ{3nB!!s&_K3pQ#
zqOefH^FBI#SI_FBpjsWZ($)1f7@*H(j982Vi{xSKCk1v|81oOql{n_~7gPyp`>QdN
z$lrJEe0V})?l!B{N}T*pEav=>iCfiiOaIRWaMAcJLS8dzQp>AdrV8mQN*<!vps#G0
z{-D3y2ffHpl9-wbv=^{R39wcBE!s@2yHr%vGZCLvs}Eh}f{?>}iZk?zEYg%+xt7ca
z<~s@5KSF294~rVuWa@Zvi^d92!oE!GiG0-QD=JfmxarEheucFC9`IJ$bmB=G8HWI!
zps-&X46uFw18?ZI^;}w%0{*m6LiP6FMGXF_7-s3An?IE~S`lZu0P}@CMKDcthY$iV
z*~O;>r9%b1fGtzbvq+hgMVTa79Nn#<)v-XTu6SWe0+R3pGzFuJP`H4lmfS0Gi2Uf8
zC<hi=SC$V3{H4;oVmYvwF=IB+pS${}{i*C|&1)0_T#USMS-<~>JMij1zVyHEz>ryB
zDRdEC2MzwVBF>7E7_`i_Mw5g!JF0NfK!yP&&X&um+$o~wldLKx`|8;&tEwLUtJ_;e
z+SEsat+smGwcxfOz}YR|wcBx_MK6hZYTPR1gH4pm;n4QmE0q{Hn?ni3w_AHPBbkG>
z+i{ch>@dBHx`tWhgWb_n=KcqA1m~9w_*ny`3PJ#`XF-^B0%U4Me<T*B_Tqg6_kiBZ
z9s5MRzef>@6cJ{}{t4$`qC@bS6V(#SftbUgblSw8wOSC|3?<)1WOLBr8Gd|bWPeeu
zC>wibGaM8}Z9isHGfl0ynUy)|s?P=IXh+Y*#t9oxD+HPwf$;rZx-W2`V`l82Kk-TC
zpZy<NyRA{92l{L1SRR0X{$m3Fn|b{Il5#%8{^t^i{&NXLGT^HU%tG1)@Um(TOX8-K
zjUc#Tt>QcLU&M9xWv|SMgXJ#z!Igu|w$UdpP0G@r(v=7TAzQ^g94=~U;>DU4x}K)6
zf{|G2LcyyFU!6_k!ya>sO~;S8-6@_$tCREk@lwU#^vabKr`TnpCI#|Q3aA$J%xLOc
z%X;+1?>SQYJ9ewuCzeAOY{t@mT@wA#;)tmD#0dPHe~R0R-VVS6$gjNf;qQHu;L9u#
zSRYi=dlHzTy>~4gmp>r__-zP|gVH_QEllhEBuPir2OYNa2sr4Q4d(C9!Y%ba#XM6j
zadq)oC`TJsbsyvenq<j3lCpu*FJk#)5)&)lyODsfmiuR@D{g6q+H^V&zcttTE3Owg
z4kju)qidgg_TE{hn<1!$Ve-b(_+}EawNl0@7`w4VXt0J5F$|{V>Z_r$@^T1^@}&gr
zgEGO^W|;>BZ`V(Icf}-PY<2k>iBk!QlW=j$3CsMS^%lg>ql2V;yPh8<8dF<976#5L
z@bzK|B@|J5UsTk4`3La}RK=!j8Ad-&I8-*?AG>>-uOqfm*MFVjqRw>2D(+>+!O5A9
z{1o?A48&lGt?&iVXZR-=_`jITasyJ$(f{PC4#lz}wDyl^Y0+>C4kEZ<!^uDgGC56m
zwynggbL8Ur!RzC4N(;@YiHGeP4~Q5~sp=5pR6x#|hf~Y$B`kwFUpUjK#Rz#p4tjc8
zIN<5MAbDkNeX+fHJ5k%mG$41zlDHk7^wK0sJ!ZeuY8QXtY~%)((WtYv2Q4e#BeM``
z&L}L?eY{@iz>Rb2UFQx#8@3IH(*-;Cc>(soZBM2E1Vk`;ARt<xo-M56#LtQio1oqf
zs^3FB=0hD`)|7l%6%{>0Pq`n8SwC>AaPHpn4tgfrJ~A9Aeng6bnsRc>`6P;Vv>J(P
z%2{0z#`#q7cKmxo_Xrxq4zA@P-F>H9&E1Lix8LP!HR7qt_};Z;GOjG>;&VziDRWBm
zH(Sq8PftWjeT2h%J9wWKb8y-063ERyxYU7$;q|xJ&M%NoB=wO#+phKxnN>DaMUs*!
zhx_IvEzDuroiW1hQ0*TaaXp(-hnF``(4hu)x0&Bl)4SC%l}bZK701gz{(FneaVf!Y
zhR(($tLR=0AQZ5xNw-&qia?_0&+aYiwJoK^Ha#gQ4U>R+f<0z%d8Z(@<$Hik&#*Ru
z`x}4uoZ`)b8*@D%FL<?mZwti9Z9QO9KpUmK8|a`u?-tZE69KY?ST`g}`Of33w&<Ui
zraU(Vaf_KhP9HR->n;`E_}2+GhoFt)gdw`_!8=BYrwhlSjrRz7_LOf}?nv72)9bX2
zhPv6B8Z0fedp)i39*R!4^GcES;JD;JeyeUL+YW5o^N5PNSZ3hhUx~6=h5!Vgv9W#)
zzZ8U;Zk))(5ucW*-MRf0sdj-psk^9#G=t+$zGDMlLoq~aS{eE)Znal-8$vfnT(O$B
zr7sOAF#TZB!<{a9K)r_dy-Zf>))=tm2R|r=W|kw$*ZQy8+Q&PeS$9=`Ha%ZzjonjD
z&*Z(<x*ZWcB@gWhJz3R&OP6;wQ6{6bW;HO|Rrx(Q_=nGvp#1L*o>_t7`PZdYs#=&s
zn^3gjXUit)XgZt-W*~95MMiIOcMW&8Q5IjdqHd#yk!<2m{ZTHzMgkp+eV78PmGn1A
zE}cckN>F`P#vb-=cJ8%ucWyVJ7NXyb`d8gIJQBBzYhKSLP8Ij5=2@$1ea}{cURO^x
z_nq-FYei(|T---eRrM$<WE*+Rml(dU{g^ybHV&&Xt{Gd~)B7lGVf;xaa**}h$WnuK
z0>6mG3P6%E?9CbgAnO0(+72E?-39&7{64(#&yW#>MGZ85qTGKI(~v2mm#L`Szc`Gm
zA4}c_55I*lx<Vf_gf{L)5ODjBU$pG-E9S78tA&j56z8p;J7MmFe8WoS8*gJAzdLjC
zv9qXYIfvWn*4?$2=FIie%@zD}cn0e`hw5Gi^*xn-cQ|yBR{UsN@d_zVFS%XpJKjMG
z(PK8{%(v}K0ixh(xKC-kl(PfLdF4%u(5WB}JR}$1RbLE6M&@`eQ(p=q6tOV$go&ww
z>)^!}5N&?RzfcjA{-k40)ezM$cKZw*rp2|ZBkk#iTz^z<;9!9`a*QJx&v<D>_F`P(
zOVVHD<Hs5Z^yOuYUBxy3^`y{5sxYGkILR&RU=FL+vEow`J70wPC2B#9Y}S+B80+eR
zGP_GcTaSyW$K@iMH@$PumBcRGy9F75`ZcxUQ2+aEVY}RD;&hjmHH=~8m)(YPHkcM5
z)jpO3Qc9O6&!2SSRs<w|z%g};g;pT|kKrI{z%5DE#6Ti8Zxf;d9|&6Vxq-I;O001+
z^kwLIlEU*u+12M663i-cjbjhfEB1{m&Q)Sfi4Ph-Y~9bktvzYxjWOjBIOL65m~5wg
zVmXu_?7@HXtp);X_xsXAVt$IAl}nFh2V1(NJf4O|_0JvN<b}c29+c6br<ej9aF*+m
zjH4NX+*JYI>@?fGizB%cKXq}W?p`=hw~9>4g%b?@>99ADX<RW7Q8%DiAs`gqwlLGR
z58f}PripBUCwAjV;lMRIPsit{R4RRXIGWD<E@RFRW^(U5gcUi4nc7B`K}?h4Y15mJ
zgO@TdZX~1?muaON&2g!DMr2w($YO;k7}j&r!Lcaq2YDthM|0eq(y?@OU|`Flw|sM*
zySKiMuua_(leBoF9(Cz4()h&1TX?iqo;he}X+eV?{`-LlC(HR?k+}<ntn~@tjX4U_
zn!Ji4<j+K?$p(>#nEIL&A(6D63I<litQ25x8Npt>B{`E@wL4MiQNAz=yOlIMx4q{n
z*`4m}PVl%_hQVAtGP>begvw_51c%RFVRovjCNn}IAG7W_6!IEIo&nnQkiARK2hW9#
znljD#U4(R9N(C9y$(h>vf*Y!mqW);9QVW_AwRl?mEEa>b6`<GL3{5{2coMS8(8gQf
zYz(F4`V6W45VZugN4h>Y_|{YCC4I@ZsmROi1*=z9R|m~Zpk2}x=f>J)(=g2M7Z&GI
z{U`v}APFBg?pHwWGIdarohebXb*;<G4eZ3Cd{T^l{T^A+9oPBe^4D2;F~V`gy1nS<
z7%Vzeq7)0<Qz-ce_D+5ls{#&0%S3_q3E+N4w!|YiiiNVrt`;5%$Kohr#Sc9OhJ-VD
zHxhJO^5;ImglEEuy@c!#cuHM0_7$deaQKDO@;pDk__B<Mh!S?HZ>fkZL*>%fyGo2o
zf69f`e9HUtmcoAQ0`4R+%>Am9>^)}{f4QXl{Y1}zmi#tFTg;U28E>c{>oLbYHbmv>
zB-4$LtC|`SF+ps?sU`*|g7wY628iO}{+Daa^@6Ja7>}PNH*F$=ro)f0rRC4twcz~=
zS5zKei|QR4qZLg9kFOH{BuVd=cB{T}A70XDE>HQ$ljd1HOv%gnv0^~2mQPXJUyY_o
zbQketlt;GKImW{f%mFJW5Ob=H0G{J#oP+j&F4n8yr{3%vy=qQ!W>C&7)nrF4OOmPc
zM5*UiS|DdO`xi=mn^H?@y=KguP~Wd&j)%&ONEz}77aZb39-7BLmWZUc#8I_UC|2AW
zmvfO0E^n55!T!UnlT&IAZmzf#Ug%@tS%<W&6(fUAw}Iwpby+RdWIw={J2gKn)?UX>
zeHTXFw*ID+Cp9;%m)tXWDC%nD(KUAA0#5)x>+DJNRjmn?dAEAuAgJG_@cKP%e7W#Y
zxbRTr`&GDb^E7H_n6sOfwbrzTwXKHkK*ia-Gps74Xmuwc(Z%L>?(@F0-$sTBC)R;J
zMUO^ryT2l5r}$;J?;5<&wWFZ4<;cC&TCv>?E5DLCW?5Nk^mlfTA2CS6#}2_<+u)8u
zOP!TTIg|aV(px}N4ptkys=SMW;Y1SZwV|@v=z-->x5Pb^vDX|(Cf8RG(at-`LPUBz
zUf^xb=b)koe-!{5se?2O%<^1FmI|rMG2v-w#FxFw@LJN_*3M>FbD<3Qm@@d0^!V?%
z)0tYAO1&EZb&~!yNhyC^;fj_>o&ELRCrsl_?x^d*%ad*Rxk9{mMQFzbZCul_6DxtK
zPPW$Th`4%}zZj^;MZg&cXBjUwgxHPEE70w94L!ZEj~-&@8tx1b=bGWelf`F*sqA@|
z+OKO3n;*_>dDiPVPZsq#UF=ZCR#;uX%II^j@<w#v@L8vYjqL?2tZ@!<xp*j#Y*jZ;
z_2tFW_YirQ5C{*A+u%*dY<)|Q?_H3fNecjLq}!NNZc7hATGsJ957Xz+I7;J<GrqJ6
zifft}alLQ@y*+bZkD6mLrte;}ygI%8RW#7miTakbHpQwI*1Vs(RRVibDHLOflYbc(
z6FQ@hKt??!OexIf9^)ulhBDYcu$Jek_7ypIlcp<vTIu4Z!XH*vQWcRD($letUO`1;
za6;~vYL+n5?=i!qq<zy`eH@rJbetAL^PEb3%}Fc~dI+)it>EAriuA{IrB-K&g@jnC
z_o%keIFhZ2SUWjpF5$(^(@!;=JiZ=+7)2=7^`ly`s_|{ui3vwX3lCj;h3-|%L^(yF
z5^D}JeEs~Kx}d8x26O65@yP_j;UsNM)DvY=5A1leSF}PXtgYql*`XrTD0a(rwUSVs
z*c0=XL%$Q(?+z2I&U7WklSJ+-?s0v%2>6Ry#h-fczhpT8io^teF!v8&_>kwE--^dC
zhBOF}uqGWq`f<SU$MK$hnKs$XXS;Ym^HX5b_2U*!Vm&NVbdHTAPEEVc4ztepC1(S<
zN$RHOrE@#pJ^>Rqp7)OBKlPZPEJR|m>>H^lllWOKPcV(GJ?BQD7PG@jeqSza8kDa&
z?K6zX(k;$j#z+g0c<!XrPT&RceApz1@lC{z@>kdJm9k@sHMl(!ZJ2uKyFC9Rz2aG#
zY5oF(kr;gDq|A7N%=qKO{M%q0M$-H&odUv12#%sWI-6?*$XRWl$ReTkYr(O^la}5e
zu=4qbCj=hQ$?QEEr;(GH-zz|)MczUkrX%W}DzsdgzZ@}OWM&Kvg@eA}7n;XrL%Y<G
z)V9LY4WOjFF_CyFlI5QKaf)m)Qj^KqRE0?Piq{@5+DI$|F})Aw2_U2AD>ZjsD?8rL
zu+uxuZMPaX+=!Srzs&Vgzo%^$4g2rZ%WY`WOC`0QqHL06#m-8`$%?>LHf_X*;gp!e
zJK<7SuP>dqFD@MWMIFuas>aU`6E<BShfA5t`bwI|N1EJ9Cp>I<qF6-V#oRh#B%`Ja
zxJI7tUm9sjeK$?<<?pSre;t(13{lp7b7N}ziFw0t*}1!Nv}Ssa?Y1((hXQZ{o;&;D
zzmu)_Rz{7al{)gw8PtAfVHI<FdMo(tXrbr#z96-AUWHE<n&t{7%7`Gp|KksZD4gS#
zsa?Z!*D^lEcZq>}i?=VoF>G?yS48hble*$W@uh{}vTEG4OM0nOl<6Hx_}SsHN#K$<
zdvmaiyiP5c_ws*;W-I;8YGCMqsRBWrj#0xblihVeN*S4%3*Vc%<C>ldz68q-zojKx
zL`}CXeVNLrDReyg{L}7*4CZjzG8}oBZ&bg!=Slw-oQymA)AfT)!;=C2UNI$(<$Sru
zf-gV$+{)3Rq<s-ZK-u%$5f=1WWunYnBA+XKP2JAJAOYzqruxF`r1<Wk&tvK4q}%z&
z!u|!VrlNV^@L3tA=H#AU$sHjgI?TQs>7-A2j?W`{N4Y1(8Wp)bBRkm2?QT)Z>~*x=
z%UrUzF5okgh@}fi7zMYMclU#ulFxFc_wAVr1wyVT$uD0XRkpcE*D>*LF>#=BWII%l
zEbz_ZZy%HS)ou`$(nz{HkU?nV={nYuX)&v}tnAD~nzoq9y;4U;zpmV#ecnIjcpaH~
zMAfS3PHBBf`DRy_vUGq}y3)(d6gOP=LX-(}f>@N(;G(X5Y9_o6@?gGg@lvs`H|lFC
z|H~VBxD&Lc&Tqo^1L%E2+8TGx#3LIm9WB<;o#$P4G#5?3R(DtLTuC4J%FbxhMUhew
zk3FvOkdM+P?s&hVowPjSSzSGaM|UGzALQHPiQSS!I#78cuc?O}LuhW7<;qs~#9Cv2
z-8p@a-N0KtDv@bxX0>I(7#1sp8(2zI@dJjZWCEi)0bWk$SLJ_)-d>}db3h#-|5YtZ
zA<Y*@OY=eigytZMy0vkTH|npTqcS10&1~p(|K)0MdsxJ*;9)hTtLOdIyqB^&qukNy
z%B>bNDUeqGJ)`vUv5mv?jK-eT>+bzg!)2KnSjg_41^TdOhNTtSFd4?M8W1=BNIQLO
zB+0_WUtsLzj7VJ?+72KJFvbU4y=T6WN|#}{XO1eQBT_y@zg<!O^3eqM#GO*<*}D<z
zxU}PAn9#FN!>hJnLXg7c6?YX42ym8VMt&Svo+PsGd}TSLJ~-bXpw-m=*!$f{HYd(Z
zoc~+;GQn*faK7y$e~PE3T}luV>NXO#17Dy|Z=I}rY{x>}_=*!Dif%UUd#C7|77$4M
zRRpwqQ%cGT)l(*Hc(&_pO|fpCd$jJ-Y`1T4ycOAofSm5Y&$lh#D9fG0IY*<s$v0}Z
z@(}l^eTWn}fY>TmGZopKCd5k!B&mH$t3jv_s`18+bStcAYt^PV+FjhomO6HB3)yUy
z+urT(FqAX$lV9NTkGE}!y6!J(W0!5YL32cp_)al4ot7f)Y!$XenoG`?#sLp|?kWi5
z^fbmhy1%j_HFtXMX@_&-)2dGzGQD|5w`?eF2F9%8s=D|wDad=c)cyN6MysZ*5z9(e
z-du2922PY7MZ19?re~_Id0u-doj4?n_{_VPiELKJ+yy_f+N$BffJ%-+NqXXL<Q;r-
zC1y*IuKR`>Nhl-x9ocKm=)yoJNYTLz&zy{;NkibqjjFekUE%=<?aU|jg$nunv2wdD
zS#$78C3UlX{xgw-C{t+8GnE&L+%S7qn>YMhW=kGXHPV&!6*|DXvGoDT{6Z!wq~m}Q
zX8VAl{&V)^>ms%ZpXqVo(>2Cb0VCQOZd&JwOY|KDDrkrgE1JvEi7y3}V#P-Jl)K3!
zRR{cr#WZh|sCy&vnYGU=2_-koaQ=S#QG}XIrHm&0X5rv?zZMMrNUD`^%{&jPnp5|g
z=BSdRg5dq-bw*qUx5-Me?z2p9sXe9)$OMA36z<%yhQP0(4cu3xPn4!lZ5$Osm3_up
z)T|>%c*c9?hXH=;sx{F{S*>Yn_0f5i^+j|duj+V~7-aX=MvB>PNNI#Mvf<<_?;|}N
zXVz#zv1zNn%tx>XjxVvYEs9VN)(&*Sl4Qb0GRM+DN9om3k7)yZ_H0C1L9`h2a^LUP
zZ1%<GS?BwGpYGgUj@{XBVapa?)ajk-T(|R_g0PeuD8l_u_>3%KUx;`{n_^XzDV1jC
z&!6>A;k7eNtSaZYD&u0ipB!pCH`_uh_l&QT+(Jhz7k=LBKLzjD6&@ehlBaqzZjEpN
z(oiHw+cXbzsifxeov%-1Se5;K{pg|^ZRmUZ<^DBC0azi*2(zjGlo4*<?a2Dj+WVrV
z0WWSkeir7a9oKpJEu(Tvje+)W_BUv}vi)KcW>q1)rA2ixs;j<446pnQ`I}e;OC=3`
zxPjXK4RH8mz=e7Dj4IEoO;u(N_6lJ;-3ej8^m1+Tjore*k=Gg4RyFKSlTb(xM|riN
zer(wkv~f>h$9;H1FZvRuQ~!s1T&xdvVXav~y#ctzL?Cepn%OQSb;IQrX|M^-rcx=-
zz9zdC3U3Ue=6B=*D{6NPx{{*S2q?_<s5)kJkHo~Z>dku^qDk-}=Z5JU`dA>V%)Q(H
z>Ac-q=v7*p0Ql{-khjrd?lJmy8S~u_e%?XAaLIl9g>#jR(a3BRrkk2`EQ9-vt&u~s
zE?DAFr4-Zdpe#aaLe`&n?~lvT^Di&~2PG>>9C$N^Xahv<(hvkg3c=9w?EI0?&2`F-
zIpA$27Ah}~%9@=W2|aNDi{^hP*GwzqZ0WSZ%oTr?QWL>l-m2VXw4t$E5Ha$}sagHQ
zO=F?!g3ztI=)s@F_@#BNio)iRc+(teQmRsD>g~$GBdvEd`*r$N+;kfMH@F1=lwJs;
zmW>li0Om+nRYvvtV(n0ND?NS3r-g;ZXRk$0x88|%uwX`^q{@WG=h!UrVx&fCy#J*h
zeYE$0zcGLk(+1>8_^H+XAw?UO$c^vQI#_d&7)UFHGgg_rs@fR(5zgr`hWR*snc#XZ
zadJ<&S5NQB)p#W}X3Sp9rD5ZUHk%C58;E7SXrk!&?MZ-chWTa*LQ1yRVWr+;?)tK_
zx*|LsipC2f%cBx)&=wq?-0aC`Urar+Ui}f~#`z}Roj2i4@6VIKmhDgLTS*=?lYOXE
zmzPHT2Ep5iE`*!sKgPxba72l?#?9W?+EEeGEc`rQCoj0HnwBTWRjAS5?S%4W^i10m
zqUd_{Dm7%Jt$T_6u5S#(^>(Q-Hfbglf%4X9)>ZVGj~_k8&hfK~Q_wk8JaLEm9@{l|
zGkqozxni1BSoV9|LOL9<eN}L-gxgzuM*)UEI+7WR)e|?)G^&jm7o};{z&O*yl&#9L
z|BZU66KxB=!~qEk_4oEidH!Y?sv-lw-t4q+%|t!S!d2+oQZu7?V>x&;p*L;AwZGUn
z@OH>53SsbWEKd-(YCjCW(+w1bC10tfyL9gIy99X~n4rdow|@nyt&Z;c`I3I^b;SN%
zR9b17pR0yQLOI!tfEVCexv3UbrTpIw_WW{6ICD5TVpM+x60FB@(v@)5gAdtJ{Y@q1
zZ`<aG-okeyS{YU;BogkEL9wC=<{$bHX!}We%NG2Z+LexCq3c#AQ$<HlB4JO?$=hG4
z%j<6BW)>4*1tQf81;2O4ZE_OYoq0A`PL`ntHlo=vO|ZtKoW!on?A{N@7~VaS5em7s
zGWR=N8s?MCZr*~s9Dn((V6&p1ko66Es-0)VicN(HsfXvCQ!wvVr7XN4fryrL-E<27
zlLVH2ON9RYA-(h6wLH?(y@=_N;&OF9|2HWanV3zJ2o5QK>IO$_vB!nfZM%0re4lVN
z(%k)@QX&j8l$!r8#S-}c5WXJPz4Jrx_&JaU^Wk)>yyP-(C)-uI-CY_V6Eq5I9jykZ
zHe~FqBHO?Zj*Yf<hx)PFKwiK$sLi2RKN(--0y$NyAAj9XzhpDCT^?LMZevk6Y~zs*
zZoSpC)}&N}^npD*zIhH66<8%Y^?P;4l<>ktp#_qyZ;-Z`Ma`1=0dX$c7xixSYnxDB
zq%^X9<+n3>b6vCSpn4@<!C!BOi6cab!Rvcu<XsT4)(Bn>kl4}#9*dLHwJTfrK+xA`
zsg_h;kb2A*wFt>IANM;KT;XtR@5i24#usdcLGf1@OXm8JldC?rY8O1+&NcU)B(XPk
zgrG_J2QsTyW7qC0aB^O;grcoe%cB}-I_7`SomAXdS~?W1rV$ZeLMjPVEoG<A`;@>y
zSAcJfgfcQR6U8E>;7+RPys<*?sgKdfgJpao-+rmfJU#h+iV~QNjQ59?@PQe<7=_!*
zO#z*G0B`CMa*f&K;?cQfOL1T1xnqc*P4D_YjD2NTl<(I43>`9*l$3%3(%msMf`W>4
zgM@Sp-Q6WBAPfv3BHi8HFm$)T&|O3Q=e*~<*Y*GOp5LeE^E`7ud+&R#wbvTwVF0rM
z8!RKnGF%F0p?6|A3#umWX7v3KbjE$dJQgo1-_h8Q1B)_<!y{tDj5fN^6}fEDio$>6
zzN*s6UrTN!yT@_am(pacHV`OwM{nxH<~s%=P4+3wVSP7&e%Tjqh%dVCw)-jFTL)tc
zvABDbp{GCN;<*oc4G!iUe@!R3u$~vs-2hvi_;`#S#|v$lw7RoRak`NMlh|>Gak_xo
zW{Thq36FydPX4Wq**k>#+ZDa8?Lpk4T>Y4+rMMb$dQSJh`Axse>dCq}8Q)VZey~LM
zvAd_VxSjEzjAaTbJ6U5+xpT`nNYak2zh0H44l4nz#jY%OIOY)?et%P>#<iLxrl-BQ
z+1QeWFTsfJaih3Fx#yCDPmQuw&?AC5(4#2eE<NV?u#%1WwAN0KR>F;)(K0cA`o~dh
z7mu<sqdHBR7Q^F*9um0?1b3L<J>IhhTcr}8;NwMc!J{LFh9sHgf$E0W!nG`G!tY*q
z26uQr%@2tJ8TbydUt*OMQVb_!^B_lX%x_qxA0OQJ)rJ_WIwNM|y+0Pe1jien3ki+!
zugbdl(~gB=+Ae1Ns%ni4UcwlET57i(CiBuNO&~^JH1KnZj9Ud#yc$z<b+;w3hHa_t
zyrA$oJH1Lkix;kMt$5jH4dn@v&2}ks+gC937-MsHm3zh=H&}|wxax?gM)C&WofLE0
z+J45=zOifdYV?IZvfBj*GMlKI3HI=d6c-{U)H6AOWSb-;&Kl7vs>kDl2A^H#S*mKI
z9G`-zV}rR&k7FOv?->m!&yS@er@XJD7#_yO89nm8voGTiGNv}tPz{Xn#b~$08bsZd
z*X^|JcG|9q7@Heum7@NQ`=|HAF|QvE{EZ*leear|bJKIEQV-t{#TN%AZryq=8?~$X
zojvnHi;;P}IGTF^KJZX)cp91MOSIVj1Mx*5<G<vH1wqPb|5n#4g?xRD!HE&bM+_?^
zV+7l@Yeu);WFI57?KaEmy<gfcwYI=^ly%EEdMLKA7v*2nUhlZS&L`M3mDSMy<jm&$
z>9@TD1jhJ$&y|cVd2c7?<74+__nou5mrQq%X$5<PR_(;i??qXXgbb}O9&Qdr?`kK}
zcOrM~%9}n7|3OJ+>~rJuO0?Duf9m9SIwy5xjA$j!U9U;lp%o4e^qF%;0_+%Eb^Fga
z!4oC0fK_=jMZ#Ah)QFv9SZB>hgiqo1<srk58Chm(-1&i0nOdQo;zsJ^%vQO%*OAxf
zLbHY@FC`Rs7lk4}sO<?us{u<A&Qx5@_oU}6K(DW8=dvhW;B@&9zrAqON<ln1%5>er
zL$8<ebq($Y^h=NKu(3H`=*t`zB)WZ_#-}e^=ISvi&&)qfH~ZRhds&7gs^2VPQ{J_d
zpon4mBS$|iU_<>Q2}&K9m3xgg-HOD<M0gIwy-^6*3f8zZ#PBMCZEw=IZA8A{IrCOn
zg0@{+(C{b-miR#FQI=}04@M3qMGJTf`@ZapnccTWMW)V)iBal0C4*>%OF%O5B@+|=
zjV9<(F+emN`((aVJpKh<L148*xj=15{Lzt#pG2H+=JP>a=u-h|IG<<$#flfux1Gkv
z#mL0m8t7l&7+!zC?$E98D0;AZAi9$Ctt*M@7v)X^Q91PLotxw$H+M--eduz}6ZR{~
z?v5_B2OEZ%Zgi>rc4GaOx%ic)iD=brpr+Jy_H%9jVWrMJ>|b_Q*{+U&8Na({C9#-J
zIVRM^QT?b0CljEqyz^z2&0kT&>rDsl`8@@Pzv#9@i@iruIvsyM{yLvg+H}HT^wujn
zu%e;wK{#ZFmx=@*-^Z6ri9{FcNQSgyH=XK3r$+qs*-r0NUUmN&{<3w(UvNjQa^Y=?
zcK-cC%>4ofKSY}-tu?qgpQ>m{NAWX9%v;u8r`IG4lg(wwO1|MQPKIB$v~EYQOVA(-
z<_cF^6e641d)jw<$+M~Y(lLp7d{jar3CSes{+{^u{&*&mM0HZ#;Y1W0N=&b>1wmOi
z1As8UX+mbq<6$+a-sLWa4!v(xW_M|$hZZ3S6@<^GM%5EcPw2|8RSEwNv??b_jBvw_
zKCVaia~={`%Psn+<*hw=^x|!&9U%H|fAz1gLWcVVPG0D%a7OtsMZR1Sn)}(RP1!y-
z9`!IdbDXo%9IA4l<6-d-v)O-pJqR@zvVB>gTIwuwUu+ZFxzLV{UShV7G;cbY=GL`a
zn7unDOnGoaGb;L3Mj{EtW*t2HD)HZel?!R`ZP0f;4)L^FltQPMCs{*04P!(#faxd*
zRwQZ0?sr~<iKu}2oJ;3FP5Zu*Eh#F#tD#d`p)bah>-K76_K$}0PswJ^+6j)>^v(@R
zw(&jI*kZA1s@w-xe}SHv?rvO!JwMkH6f3K6&qu-mIxSQ2&}EcNPo6Z$5z}ls>J_kl
z=j!cp;5`2)%kSAc722nTDH9F3BU(o0qos2rme(4n{dgNu%W?^nq3SENS0o;3qQo?H
zVJ$71G45w714-W6KU3Owc^Reof)*m>gKC8FJ6xalvGfHW91DL`D&}CQXbq<gGl+YQ
zfArMQk`o;NG2mfJjfFRNEgi+(J_Xf3`GAcQgZWhf4)CfvRy@g|2huS$FV`w8%7{l8
zQ#S>c4+7L9!!?!DZ(eRzq0@w1mer&79iZHoRJnYqS?5~V+mVJrIPjlcIkhV~s5}H&
zE&nI=eNTQo+~8g&Cnv1qejD}{Hs-rqnt|W%>K$WJI{EAnMwCdlZLy9vD!G21Ib#G9
zl3^gSrk{+jaLb%QshZp^;~AJ3C+JQpW?Ak;=XreWa9Xd8>^}tjR=PdbvmGj4yHqBj
zCgw0MxMjx<k}#n3y<locbGBM;k{xp)e>}@fOZog1(bNrMmQ}f>ZaVfdIIc^nQSZ_`
z()t19th#hxn<un~1!os+tXZa*VQfpSEcg1ve8{Ity`C>NysH&L$6<0mUc7A~1^~c-
zH*(USrXFwAe7r4jNz*&sOpxUKm!Q>g8>yb*!h`D%YB>4dyMz9XmAq<VHMwOnyh%1P
ztLlxrgkDj-d!T#Rm=JhdEEf-JXUC^^tgL~VgvcDVHU)sw$Ra}*A~;Kp-FE;d_b;7w
zE&vM8<}j|*7xSKHXsvC>dqC3x5+8|RzU@zCP!Wzx*o5V(PItzQNO5sfJPjSx`=&dR
zyZZig+?y@szEkLF*$m4>;T5i(yR$td6;tU9OUyP=+5@)CMCEMyi_%X-ha-Dd&GX?Z
zQdWSkF<bYC%;}FL^bCDGL9NKNQ8cX?z`WrdkFLV}*m!xk@KL_yqX+dZp-`d)K~k?l
z_3w>WG(|nwudp*Z;na`RUg7g&8+YXW!><=_y|DHM#X=oOmDDXpUs8pNq^?TQZM?nY
zX;qsP%I42;zk6nQd%(prj?2&a$gG)1x2k4jx4x#k$S=`C$nN8CeP?Bj&oDb3ZG20K
zyj^hGz@vYQ!)3aAf5mfS3?hwrXgaIIS^K^G>c8^uD9VEJU-HE7IphD975}JIz|q%7
zvt$R`IO;+K{H<*N>QVakdywssCFy>fZceE+|4=vklPdJLuDFHn#h;{CJhO|5f+)N1
z^ZeeiZc((V!%=pny(&6|QdI*h0bGOMH4Trl9hG!t6{n;Jdt>KMtOfk^C32d4#E0%R
zYG<;mOG<5$PcMM4xfUY;!wJ@!$(V;&sJOBc*FPD~4>u?YM!m(FmVe{g>B-)<SmT%&
zZ`243-R{Pf#<pa2x%m~lL;9zeR%E85pzsM`ZM;$Fh>ZrPQyYuV9V<j3GRNPY6}3U8
zhFST90YmlMzdQ62K@8KpH?0BGj?y0UZW@DOj7TO6=kn4lBCohl%;y-1ZuN!WeLgA$
zurdHT{7#`zqRo(BqfTY~ijvvucm#$TbK<e@8}Z=n8FY|~umplp)19-?^45xv5ic`>
zNvMO5UjvbwMr|`~4li|X7(tpxCc&rsH)JrbHRz)s`hD!15UCp?!lRM3;BX%H_rJwa
z7?)t%)?WAZuu0R|(Tt<(AL8X;?h0%t$@dAe+2`P7r_9Y$FP3`2j?{TYza0?Mp+wi?
z{n|68AJ;8rAzQ|ZY@7zPZEav`<b0DAsBU#j7T=A``6ppPy)TM{d1fLqD`UIPx7c__
z<bM~H_?z?{&J&4vYN3YX#u?~wn9%Xs;|1p7qCq=a>^adZGuO=R4Iy91vJb&bDP*;n
zXCSw!)jJ-QfrAfM9<q}=nk8sL+Tg(r1gmVD<EOsh!81{|zrX(y;4_k35oF(nmu7j^
z5f~Dh?>uF+atLDqhbKlUB+f1=+WJzTG~-Ns+n@@)`7;xV3s0s>L<-HU;dYguZLXAG
z8Doh>zv;THhWSk*!p~X?0ZXFufh8xD<Bh1891n`y3F_{vNRnZ6oF{~4$68VWt)bhf
zfdEG;y&L%{gs`NlW8qO;x7Qo~m`yg<hqd)^EaJwjMMax_H5j_1w`zMJzcDp~j|S<@
zMfVyXOcDD4)P?#BdWe-|A0S)JR`EtJ20<A5chGhR2V4ic(-%Fya&AII%Q{^T<n#q|
zzaoYm$lqHU9;`6$ijIY3oa}jA82Lx8akBlKc~Af%B_GaTVIrm|2iXkC6@FNToRp{}
zA9tuZn0&4xv@?`K`+-6e!?iP@9g6fm(fM=l_D`GQrRLU(DV5y*`@k)}@UM<j6W?0&
zF!$nL&J(-vUHo+N#A*k<TeD&7z!@JeD>W^DR^928*!VYt8=vxArI4MI<4q80r@~vQ
z*FfF)ywHvLy=hX<bL963n4zwf<f4(Qw?s*aLq`18dlSECKrvxAmBT11qYFqC6q`qc
zi)8ikro?Sv)QZ4peoJNMYL0Ky7=r;-;;~-3ie$0e*f|PGV|XvC0#IdZr4wrkmlGc;
zP1&ZhS7&fz6jy%wk(h{9Q-OW6wS%7u%HPT2l`p*4ON85tXGB`MNLM`ir<A9bHFe=Y
zzU?TmcewPs<x}~K?~A))(-XKgxJQg8U*sy*JoTULbT5=v8k(YKKAteXeOGK8{MC5A
z`-CcYUOuxoV^%ThK!#Pu`h!)4h=e0n(6MuzA9ZVo1XZuSaGbV`Z?{;omAaAVQRsr%
zQ0K6h8(BZGn`*GBx;uT3p*N7@snYT4sCH^bPcJ^U_Plye7|FPSqleFXG}LOlfbchr
zZUzO{(cekwgr4%*5qwb$ttL&5Z}B4jh7<iUL&=k+6awsR70Vu(8X82oC#?ge=%uZ^
zF&Fd}d?H?T><N{Aj|1FED}TQCwYo%a=_2V^u<_uo3??w#m?Bd$QsYAAqcVj~;#S=$
zV2xvQ)rvgoxNswess`N{VVj897EY9n&K=56;5E4PKL0t`;bTBtSRo^8W*QD$2<tW2
zNH#t*dmo#Abq(t2Q}M0K8G&#Q>7K&z?tIR<@~p?fUnuSbC}r#Y;xmh1!ENei0w5ph
zlDxAo79Stm_39-^v(v3kuVKt3AHUZAgWG|%Tuu@p*J(z(M?OdEaOjo1azITF3s}uB
z?AG1#gx=`TSdvO^V^*cksTsZ1JCZo?YWig6@r-Tp#*LuRr-1!qdP`$5HAk{hyQ>0f
zT$*}mE4GITL>^}0z!g5P)1iJ#(-}yif!1mTDK<?BL=t8ePsRZZ>eMSy(`#VQ;0zJX
zzO=f~Q7<Ktc&GOdTi*U#3e<(_E6lwvEY?m=vnFvinz1vXPlU8Ii4+#jeOfx>u|m~7
zEwzFgt7$H$d6ncQm*!85R#34C7jEZ(*BoG}#h{P7E^xGSBCM6)fTaN!i#5^^I^KfQ
zUnH=FReG;f)Do7L!?B+4r52Sm(q{i%2^k&br>phd&405ZPv!Q;JWSG)$Y9YM7|84Q
zorG`!X96=JBz%57kfSiJuz^{P!Kp0#GXyhh*wc1o*x22SbWMrmjcbzE-$Imax`SU}
zmMYs%N}yLL+PSxp0}tAH5-yyLFX<`l$mAnFT(Q+IK0WgDKUpL&N1K-_T-=R7sa@p)
zI9-xZBJnYt|5@R9uZLgx;CSCJiBa;@&gSCok5A?5-Jgaj^Q{~5i7i_@%}OU}g`&g1
z5tCV<f?X?7T{%v&A3wj_d>bfmgVc|(3$TAqQ5ozlZOG7ln`O_VH>wytb_Y6;@mB_n
zZr+%Pn7@ex6sKkmU#{c8cNclO^zuq^-yM8&!cu_Gt;?jjqK_SD_zWt+3u7>7b6h{*
z*<SzB#y3h_j;TSh4<2?;r2oH7cbboff>od;Ij+I*`DQEgbLYH?k<!4?&Yy$N$rjAN
z)sq!*aGCuyLT_p4F6G(wK|CWf6coz&DR`M(TuEW}EzMgrjrd%>uBK9kDef3+;jK^X
zCX}6=LkKQuOb(lQ4OSOE-0y_rb7jY_h#s!oJ-fA0sjH;vw9xj=5?;+Jn&dsj^IGtw
zyej&*s?#myP-^PQ_b~zcV42AyEu50Jk}#*!0AX$UO|+H()WTI+&Tp$+cDRp5@Vu+V
zm#{KPH$bx|EcU~K-fK`SER9$&{PySA^54+#l9*5%rLfwv?wg^q;Zr2&k|YM=4hb0O
z(BDKA3X1;}3SJDv;h`WNTt|4l@moKgDRfM;7Bn7l`X#X`bnJ?HfoPvf-Wz39)Iv0#
z#i5X6(19e+sVY!0ho*D?3l{)K0S>~u$3n+YV>8)O3uVpYZwBz_Mkd?qBCFup5OsX`
zh7k72!U`y-_C@g0=#jCfJ*|49&OTGL5Yulr5#_cy3`P@0(pkI{zks8K7QIn3+agk~
z^R2aa^4z^Ft!#z2vvI$i5^9cHIzp$HIrUMr*E03^F{fXoXH=5~5Lqh^L^=pyAhxmr
z_gpBaneQokip=se6n+;rG3Rw-6i6IuzN?d4wIAH|G=jxS%(1shh0!aboh)Z1Ov~8S
zg6&I_fV`F7J=M0^tCK)ZOT3d<GFv}S>a2PVn*Fl}t`Bxa8ASl!P=-rjjU?(_-N&+r
zF6G3>8^(Ix7NKO$Vxg95Y~r!BR;K(XSg#te)7BiU1H-S19u&Bq{q!hN*e>Tgk<?^5
zG;{XC7ZYPjtjCxhY}Pzi|M56>wA_(f!@fxP7?azNeZ5yJma_DhR7`_Q%pu6&`2QcI
zv5*T+dwBGIPdL`wQTLm!d!4tu4OgI}*nfz=2P&WFRR6C-o0N#rmlqf#|4NFSN@NMw
zeo*b*e1oEfPja&^$gw!%@}wr&e<1KgZ$mH<rwkY1ZW<_iXxB8=CV7wH7t^h<+^8u5
zi1L-?ui;Mdj{(0q6SKHk(IB`dsr&jgK;4ZG+cb=Xg71IrW#LRtgq;}rb-P(psKhAO
zHZ+C0D&WR)kC%VcC~zfP>Se4Uk5Z^nJ&%oF4?k*(0C6!=`J*hM)J9g*F4)(Be)qTd
zQr&&WfD-O!hH&}%<V4_<mhS?dg;eWDvBvnNDS7d`ExIl8>2ey?7ejxB$ra)+F~!Ct
zh2tJt=wi+VvYW@y8{f$%XpUhfMWA&27t7n)i^^soA^5ZdIZTKJe7oAnAD8CP64^qI
z|MSPPC4b{<A7Qed^*G}C@fCrX!|mlBD}Pc$yrJhcg29j1j^yftPhleQU>icOu+p=_
z{ny-A*KiWY1lCPi1+$@#Q5BDm`_LVK>R#v;{o<80py^2c>8rV~YOiZH7|Wq=nE2*K
z52NoH-7mW>m{fV)O!Xq|bXp+lO-JZ2!Rsx7zIb5bmn_N^MbYP_c4du)g$0F~to#L2
zD_#Qw6=6Y;Rzvx_Eh8Q=5e?S>!*@iNHN^8w`n(=dGh<6(oTaJ9{KbE!Tqy^*Kb<PU
zr(7=%1=!h3jNKSxX**&IIM1OQk^;}e<pRwL0|0PB0Bi?vaK!k0j;h1a1{l^wZc)0_
zjYJB%;YiuEz}G=efF5B{QC-Id2|`)kpvD=?@|ODO&#CCjad!A3+KxaN;jYu<@)-uW
zR@k1ABDHIL_;r_H&eTd3^L?WQ_ZL7zCJ4TNRc2Ii(Qp2CC8hWK1=@5R8m!nbMW4o2
z-Vy2UPbr%x5qdEC&<}yc8D_aa?pU_<3`nhYvH4_z(S^^J(}X1!gDR&9{!VK;-b9Nm
zW-RqE-3mpfN1{`RBWUS6s2|;kbD;alMLvq}tFXYMmUqWb4BAp%Xs<iv*=Wk&`8@cy
zw8v80Xm43ndn~ce_WQ~2&CNJnLc}D6zXv+mH17g@?-S7ZrPa}9ie)XeOIFN^MnlUx
zYG*Ujy67Ky!o{M+2sOAAE?wT*cZ?d2>=GZltZD;BjH$&9LbR}bSaLgN8<3dU?pwqL
z!wjTS!spp|-~}%tO8T}w2SpJ|&OicDmm`w9IK=^!suj)~V^3LZU`0j$3!NWmH9fi|
zg(9WmLvg`UEX^gqk;r^>csEhHF9ibdPU|>17NWb-b?0v=|IN`S<DvlBUC?SzaM>p2
zgqxKpSVj0dVZpFH$uVHsnT2Q`VHMgrfn{VP)|92{C(KfoM-T1nbkxaaDZRritZi)<
zG8!>4-;B7-&cKd=Ql_M|iTPi@Lh3rR7(L=dyW4M^rDBjXDBhFgZ$D*ZA91VG9bKQC
zb85QUGr@?xYw@|vOlc5_EZp<-bD%%JpU`?~^8x&n2vZLDUmmlisB?BZm0<T_^)Ku3
zTL2>RvQoprhyWy%u*zuoFby;(7_yGh#MDwhZfpLy>!GNTDQP$-`_-l%;k-kg#c33r
zG;LY92?K+x5%8@u+L2Nbg)=`6BUg<njtuSMi;F!z+V7>Tz3q_L)2WWVZ8Jv>dx5Hf
zKrORfQXXyE{7GoaUj8Q~GnW<39Pw(f0h^Z{yx%%+!CfNuZ0}pOs|164gf||*fOIqU
zLBbDE^;Jbgdcnl$8c{MGTLKi74rhl18Ooa4#J(S9g~CYRZ&_nIeGgASDgnIW0Q|H7
zy)bTMG+{wWZ?N3A=yHNZ-3Z37{B5?3{1ekrEs3giPn<qmv@m^>2xoKQDPqQ<To8p%
zNrm83FvDjK1NiEL&JP8DOsmhnA)OUWeXqo~bjh2S=WaaXN!KhJPZhw#j>!zo!wx&1
z&&55j(KU(VV4zy+Sy#X-X9rr^u%SUQs+f^$CAKeQu@N`@Khe(>S}-r+7+7J*6J+#@
z5JUp4Ub-wqEG{;N49kH{G(3#hk!&q$se>ur_s#ZB_k~9_C&raWgdod@xMDOk@CtoE
z&B?>+fut;;0W${!=GobEUQJbG2N%gSt`z(wAckI69j5_AxHOZcAc{)Yiyii#w{R_&
z+p$~(;REg+1+EtXaO)l{Ot2y@7`2K6sOo>SjSzg2N!x+_xQBUO`}F<Y1KyUy$i_y$
z@K&u2p8|~mKFur!wrFqI@qh!DN!3DB$wAuePlK-Bl~A7Qp9LTQn}+RQ33N(vzL=|r
z?Lx{On9BL0#?VR$5bp9ul+B%3Q*tKw@uUPh1A?LTa74D)(hmHX>g;+P%o?0mNYPx{
zBn@aFI0F58uWQtv`MB{6gbv@;=?MAJGC}FLvBD!c8H9f+ro^tc{^-lAgIP)T6WIoI
zR3MG95IxhqF4vvC$_nPrayl~RYT$$hFR6pWW{A@=I+1@lKk8KjEeeXPc~Y9VwRcWc
z0zA)+dX1}J5w+Y=x#56&Yv|C7CAR<&roji}UY!soFP>|BRmHCh9pjm;FS%P{AO$gK
z&~^>~rRlNw)tg$PXLhn>F4%LiuZHe-p1E0eyyrL$y!h4iz!M#KVO>#SC?Xr}e7hCH
zL|#~kT$pfOb4UDzwSopUy0%+;lOONVe^>||>VSg#NBz8|!kASzX8b+AqZ5)u_}?fF
zE&c4$V$&&Fb_W16&*mhDY9ycV+%L4YM%cSQt3P^-2wiYLj=$mm;pTTvIuQRsdOZp)
zJAmamUc~?TVAcc<-yay+^looe3xhLfEuK?c^1WY81;Ul}Fo&kcW*R1cCfI#!QKdWD
zaJC`d^(kukAdp+Iy+kuVTgp6>!b3PYvI6jQ_1w)BhqQQkNI>J3gk|ma9Q}rQeqPz!
zNZJ8(@qb@@swn)516b0RLNV|gxZpzMM~*qA+7`pA*rvGl2l6JkbP7X5P$}oAvEOSv
z0q^S%54MWa*XRI*sUyZl>m3J{7!>i&KYDh6U9z<$)V$$7bzizcEZ%s%T5F8-&vT;s
zC|6NF|GOnDayMMl>s}tE1jGUA4z<;1?0xE8G{Uid$eNXk0ko<lBWuWJR7ti_0mwgM
zK8d|t?^FQ^SESV;^ZZS%ck@KRqxNYgxX{ky{1;8$k#QavZi4oH(cN>e-WI<i9ws4o
zB6*;q=}~dWkS~-7W1xj4AF={|nhUy3bRQAKfZW%{m4KH+qV|5i1eN#;+V6-@LFYNi
zpg36x`}9kqzlNEed6}xF)+YFWO$rkF6XyqkA68S?o&(PBfmVfLI9j(mtN`DFN;%7I
zyCHoo!1;&?KvXyi6f~{@5Upecobx=|-+fz`asf1$$AEfT!&{R8c@A`;OJ9ogTSI5P
zQqXU391Fs!?!jm3oaYf$@w<R`UP+)DLrCVcw%nE0ARe@#tmBu^ugNEKgeGrEja4_J
zo3JkPgaLyxIJ4HZ#2lQRDJl%3#JK(G=vgM96y*J@7|74D8YhCZiL+}&n%yN8Z<8B(
zjGHLSZ6lAH8)YkUiRuXk4xXA{>`t1?b*Tem%A84SP;hV0=*60m)V_3|($%6`OV3i;
zU>)6vF<&Pgv_H()pT1|MDa2*tMH9)qyw{g}Jg|}2UsM4fSP~gX<@5`83aWN+E6yns
ziH?^<($(e(S*xB56FOm-nQ&{FSVpHMuoIN1=rkb7mDB5GC9>vlhHKiy#3Nd+3<KHv
zq^VReU?K^2_tT)SYy0ibc)f5^CfaYlp~0Aq-7Sf3ww%cV;!3s>UOg|wj+v%sOB<(m
zz(%|sC#ZD537oj6^r|J)R3TYo)AGDmiEuDaR5^3r>Dk|>1K+ZhGAg}a+CVw&eOco{
zhYRF6lhQU9(+Q>VK5}Fy$mb`>Cc5fzqP*m3j?Xg`A9Ejv14E_H8(U>f69MO$bB|EN
zQb{)c;8_Jd9E(v5h0&O`PJb$s##rN>Bq@`v>8JK`(X&1<*;-VDc-G@NRntZI6`W$I
z)8|&IoZk~WQ}smbxDAMdoff?x`G0=Y|NGs8-vNhP4~&F@N4<;yR$m0N+fFoAQ_<nd
zqM=OF<jor1_`dwYixIVtzSW?q`W-XTro@#GJP<rz{n9-VL<}ep-y0he<Xy5ybA?`y
zeV|kf&81GA8mUZ<_mgeWvNag-YBQ`GSzF!|e_CwF7(QBhCQ_%lv-hfy{!ep<mdS34
zUskEpmDkH%xX+dsXG4l8gUfpmJl7dlfqJREDTHw!gY>iKE?znYKvWLk6#+QEDY1J>
z2DrcB-=bhtDie`>4e)|>#$|MAMR2~`IGU*`CmJCxD{EVkh<Zp~ZYQGMQcXKzXyFZ(
z@-Gj_t;0WjP@$yT>Cnp?EVB?iS=yxM=Bo{JYzX+2xWXD-j-=)Nwi9XT5dPW`$e2gR
z1!$Ht?iRXZQc!3--m)V8{g<_*z<H>|B#m=&rvf@N7FCkS({xuDjX3>m(r~6#q&i9z
zz{#*i(*`eW%|@@G$g@*dav0h;o$?%FpQvw;>+6~za9AnC__c7-BS+jbi&t{D$@)8Q
zrcAyK5!lqH{)p9wD<9aKhZ?4?uwn1w$Y;?QF<`+d2xiCBrS^{DFGZyeS_a0Iu4u#S
zcpY<saU&q99x;6G-`REEzT|spjRIvSCmM5n!*6I{^r{b*1YkX%PRGj!tiTMzD);UW
zZ-&hd!V6~&bQA<f=iVxtKe$z%(Cwm2EnY~lOf#axX<jPGPz1IZ#@ww7yiK?69Bk(w
zYBbS*bfcT7)YFdmoWSC&Nf3_C*-Drdr&$*xl2Y?6`h@d$O-vaCv>Hmd+;I)V&k6k^
zC*ru5Gy22PQnFn#IJ8oxD#vF136tSpKxwkrm<dyp&$i8Clb{|ZEU$B)dRCV5+4ji_
zv>VWF8fVpZ3dQvCVhrkLp(oJ?o;w>)bNRUfEft$6%j`{TtRGqcRUF)aBRH3nR};li
zCRaO&UdN`?1F1Vxa(Tbkhu{(ry8_yp1^qsd&__1Jz4+DVjt_s`C;BXBkFpsn=O)k}
z`v6{Cu^kp_41U`x`^!*855d4sRsB2*O5t|u)OTi`ln)2dj^Q37IyLxc>uK&DrSqC?
z{I_nl6a}82=wX)>h!in!p8Jrk;frg9aPI2|PmlTGK8LpqEoCvs2i&|)(~UW_84rGt
zW>KI~ErDjIC^XZOo)2J`TR<lqL~BJ$6*yt85b8VX!ye_q9;z=r+%_Jyx{6Qfd1eHk
z>TdBmbg>=vi7tIW1*M(oO%;5x=d`%AgwmFp_?Qy4-h^V8>_2O{omk;{V|gb3pnX98
zGt=`*t7INEDfw<#9&fd_hCjRq*7Qp`f!FNrns?hCax&llRC|8=zhC_S)$rR!KLUqy
zQN4b(-jf4xK3WmkC!a}#nL!0GFxTIE=@9HbrB|ICLSS5flWW3}fo0=rfSB|$${Syc
zy^D*=Qb%lf8H`F>LU43v#bBh1F3s4S^sYa>3N~=Sh1oW3Ix{M=WWMd9zudBr*uVYe
zrf4Q>rt^t80T9_}%SKmmpjC%x`uzO*ar?}4=wZ7$;)%}K7oCl#n>KY1op?WlO#8}G
z1=m;!$!}lK!fqGr5Rv|Yed|vpZ%nAq(gt?po~Ye&iyC>*=b!_drYiz$Q&b}}-<gQ)
z$PVsYaq~__sTe?F7q_0CXD)XA)vv?D6iS{z?Eg|f!;F!z0C>Hc3A%J)UwMyHT5b27
zKBLpWlE!^+lci&%&`Np+A#8Xv%r&;b)+TzRRWt!SiSEX$kQCK#Jp(G>f(gGJGE`Q_
zI5074$9^sZL<VxsYBrc(p2ORnf@C?}Jnqy`F%L`TMdPe|9|{Iu`pX59=C_Ta2Uv^-
zNbO?H=RHIGDUe)#p4B^6X>~>#z{!r9|J#Od3_{$k4wO&TE(nzGDA|`;jc2Eqqb70;
z>k>LH_t|R%Yl&5N1D{*WO1!vk?19rc=ZsP-zGw;U*BhLjEm)e_N%ChP2g1?{$A&;T
z(8||!##cAS<;2?NPua3QS<X;9R(q_va^_GnuZlJX{k4x##C<+dT&E;-B7^d3sF#Uz
z#fd91%E@hv=3EzJd9_vM^PNwys956`B{4fnr!N`dLwFsa*NM|4)IJb@w5cUBe8)hQ
z7ktvv{dYHz1A_aI@dEOs-dKUA{AK~ev=j1%Gv~chR(kB|-J8F>o}#0Y%k&M3*f1N4
zHJtH!uMpLmJTJ$cD(vDPXr_bIcgqK+u0p*)ZT^6oxwYfERYI?w2O35DL-Oh5T1T_y
zkfu`n;L?^Dbw=qXqPJ~CC{T%Bu&gOVrolL9?nu$9j2=CmYJJF&?e076=Oe$^1tDt?
zTz$`cnJYd0MGp4%vJY{mFX#Cu!GyWxp6Y(uvc@nxgI{{yqE1^KIM@kuV<z(*3bX+&
zej(^p{Zs8;BJpF9FMN&%1+Sw_7H^JPO?EHYE#~GTD(q1O2m44GC@dyx)e6UIOl~^_
z9dSiI!DHndv~sF$pV|%gZ;Mst3_@Huln>UBFTiqKD)J2rK?{;~*urPs3tYs<<_~kP
zE~7g_x<puPg*yE{&~<-$Hg|w=+Rwfe;aQ9%-c1BrT@-U`X1TIe*VbJ_*R*=qw*X0S
zZlC5Cko0m``f~d`1;$sA=VjU@u!Pa9Z*f@(BhN>bg&G=Hw*VbPv{hn?>V1k@xJ)b0
zVNIB>@tf}@9xmEsv5x}@{iWN|;%1|b#)-Yjsoily9N1iUju$7w<D$7<a3jJEhM$qF
zNJAuLux*#mia8uZ=Ha~K?|Puz%}&8LqbK4s<$Rqjju+yrnVA){DYMvW+e8gUUbGx`
zezU?h$|7X4to;oftTRUd;DJ2^`YbewFY}wGWOvWG>*96b)mH+LwK1qccXFZ>DJ&C=
z6W1JkQm)!0(cwmK&}B()&`k?ML?27$WbhoevH%*$@B&bmIls`r_rx{%@nvrTNQWez
zAqU!~(M2gP5!U~5kNHml)cv0d_n(2M_-B!P;6`2>9}qTLm08?^RRrwc?auOJ`%^QO
zeP!c~ECns0e|8OsgEvhRU#;&D_|iea;d}Qv)1n3(elD!O=Z@CCzeMCYeuJ9**)O~<
zq<IdZMmgfx6G9_;_zqafgt-eUCF+8i4qP&fUwm!+qk3wV3vwsoCcL?BT{*>zh^(9f
zrh~*AFHX>58VkHc`d@-;y@OzOVyag^S6L2C?JS<zpi(U7R2dbt%tH(K*SHADk<4iD
zk!k6Wo|Vr0_UD|{6M>u+5mJx$oYTC1RT+;&o%g_|{mdMfQ+=|S4Bd!NfkjM3VKgI2
zK-df(5Mppmpr8|%+*GM_z!r}7L0J(Eeue=XW~qu<4K=#|305KuqrnwcrjjG|{Oo+e
zw#t8rRfw&M&10>FmKgd44W7*7=}tTd`TRHLxFQ0LSu-$+5Il3(sz92hSV(43Nv41X
z&-fu&<?>uP0sv7l!Q5HmSTu+-i5@BV{xR^qHSrCa{}~y#5`brRId1I44?}#2t0BbW
zGrmd)-1OzZ0F#jPj38u8fPYn>BS~-TgkUi>)|l_7U)3$rWqutaz`h`5_sD@6n}i_y
zejlUh!0x?EaLTai2nosOw8}PH<s5w_#$<+l{r8~8yZgu?;(<G65^5DC=bwQUX2<1d
za4Z#klL_g%1;sHzNuU}xK>d{>MzywY!|UJE2@4N&xFD8!-AD#n=Ickw<V-wpS`kR*
zuV0m`yYcxD0Lv>Fak7Auq-V@~@<wisG+7y=)+MB#FQTZ#>;d_5YpXLQc6@4fKeRE2
zJ~(H|<G_d7YeAd-Mx52NW9-h5!Wr`~ZYDJ?r*Olqap_AFBP6*?(wPP}B40ps>DiDY
zQWv2h5zxM-s-J=b;{!WZg9)PLGg{;XI9POXDk>h~NAYIfepLQ9@ixME0h;zB3fO}J
zl3}&}XC$KE%+6-~+t>dZ_*DLA*FB41+XUEI2S&qOdu<qxuP{x@Q*a2=jQPhn^dyo_
zcz&m=WTk)@TN;86_GsYc<nnQGt*=HVog7W}{<_ZTHo|$GK!I8IBWR|<OXf0>_fWiB
zMKDR^CRvfcQ`+-Wa%WEv*4RBv5eqg|+kvNODWq#8693}?B)o*B4Q-;=TPka?Ez9?2
zvn1`eC2msPE;!&<+&-E-eYek9^qhCphQI1w4xnp*<B#7IGSC>lx_wbQX1+-Fi%;-q
z^1BRO=#!&4`P~mEZKkDdOC&jT(J7A;!@W3Qw)YE|YBR4P&3AO7;R<l#vW`8|TS00Q
z{(?NaX@khCI8%(qLUrw%HMXMR5i`cG3Q?o@*fyHgn0!7GW|U3WdNG$b$Jw#ybeg|U
zk_Y+f8Y$&9&3m=4jAj#vi_qamsLo3q@W2N|h+)9oF#=jzJ)A%N6ZBK~W8nR2Wz?@r
zf#by{asX0^YBPZ4c#-Y+3DBy=crxI0xlj&s@XzLIVYjX}<N14D+APmv#zXTwp>t0N
z8g0o{yzU;P`g%D3e5^D7B5~_!xLH9$jw!7rpy8$g#Hu~9Ee(K_>u2w!0|iT=j?rFO
zT!Ryus~$l3@W|)}#II)J#xoi)$!fo(-!{+#B1!+zFn4{F<$50psA3cjSj~6m79{GR
zUfN^P1R~xPnd8zEi_;YZ_ev22Y<;>w&vQI%Hp=1pEN6V69)kPKf8_NHMWK2L`r(KP
zgt(6G;B13zlzn_JJ?i0<#u{)QPWj<^je85obVVM$OL73%00g&Q?>z%Z7)NUX5lYzs
z?9zYGRYDy<iG=lyGaTyIhvnuH*j5;V-o5dEp12=@)~okFHKUC?ty4N-m@sbwSIoqU
zVolj!kuXr1bTQYiBj2egOg-Y&SC;K0rM!uVp31(zb8N8AQf7GAVb+U~AkcLzWMk+h
z@$&C8&ism~e%$bd-~{Ir{?8vGh8P>FLvLcAx_xabEsLa?$`iFORs<k^KNCX>kZf@O
z<L8co24AT#LmiENo7oWoMah#V_GTNrDf$nTXkl7yzo;)0kj;LWZp;e?fAMaKqi5%`
z^|%82(D4_F+Pf}i$5pJ{(CpDlRfV!l(^5xz{=Vhga|L)kL;~QyeER3G;3|&S7w$;n
zD)aK&C4!=%Vl!UdF2Ss$TdrMio4;*A<RRbmcmn6vmdP(O(;da$mQ@TI_HQPrFefT^
zq4b%NbN#Q1N)C+qbk^9(1j*YK0~%;84L<<{Zu#s<uU(lJb+ae9S{oq}s-%$NTFA*;
zkvc|o94?f}RX&C$0|rb3mmMR|00=pUtS(0TB91OztgZ$Kq5~27VaHy?dbk~ZVI&QA
zB3**D$HUtY7sEyA^hd{B$18M|slYikt-}f7$7L~$w<5>Z2fQ6;>eu_^mRqv}pRn5x
z2txR@3somC1w~CW55n^rzn4`s<AKtOtKM7eJ4;3{+GFf+V_UF0n7U`!PeUqNSA2W_
z{yyW$@^x?!GDrxvb+_+8VmQ1jpq&CBV!4hm!G&JtcP*+AquucC0k7s0^p7fg5Fsv7
zR;dERBLZ-mhWxT+e=i6P9{QEg4fOK-qU!l9RDq{F_JZw9sc3)NwUS#%RNUP)=e`<O
zxasedki(1WhA`+RKQE7fZQK*#y(z?#j;XQ0=}1YC>XWv^E%)F9Si)j1Ujs1Inax$O
zZH3OPHA!{CzeV2i;GmZuCO-uw7<o_MI$D}l>`zH+$8mgnbNlywf)w=6AiIin^c7%4
zxQshAG|in@XT>6|7*5;hMHMTh@qRh_GRrCbamu^e?-D6RoY5FPYJXZA!Pl}_D#6eD
z@&1dHmm0LYd&NH@%ME=o+P`yt($2>@I2d0L=QCeUj&*%vyzM_jYufxUF#?uL!)&9`
zn6&~eF~FIHEv<#B(ItkzRt8UN3vSv`0xY%GicPiw>!Kb%j<98^Pj=p5h(sRarK{(&
zHYbj}Fxd*pPU0IH(GxX%D}DC~PeSus*hV-BKPJuh2V;*)+jprn^LF1_-IR{#qh`-_
zwS@3pB~7t>cJzZ10aXS7MCZ6fZo&pSxKOZh<)%J(WRzS~suzLEbgG^rD3bpQ@!NuI
zpccuY$gv;H05EE)BT4(s?W)w3WLUV2N3k6`rl`E%UH`kcBgD^4b<!LQZ-v37q%Uhw
zd;{N+Pr!p9{yf8D8+l-6>q><23w@Uial8P-5n_GOD>{X+d8hK&iTH2|?YKSmUW;ZL
zMHD>%31HGbq;IcxmwGO~DesUG=YhfzMXQ4^tR_A!lVScQ!~K+tSXN#QRWH$^J)^5O
zq$?JD^_}JT6PfT0074LPh9!fb+flT!!51fIq=9Tz&(oH{-)V|${MbSK>?gx*A+}d_
zV5n#gO$}wKF%wtlwW<u}91R3@<U<1OE{M`=#uO*Pjvq~a?x#8d<m;9G@YVz$&tqke
z3A^DaTD&QM{?dy8z=w_0f?`5q-?>rjOVYCoieB<Y9p(u3mShD(wuWDQcxzwTJVy3Y
z>H)7pXdaDwp{PvvW>0s3Aq}<X`z4?S>om=lQ(GM3t||T{!x6&yPRMLiVR3PQvK^d&
z3jCSb$xSK_{_@Sn@gQGD<o?GQ-uc@X$^8>=>c4>DYeA27M1GdS)iPuapc+vVfpJey
z=CCLJS{wCvKYQtEN1CSnKZ523DGYwz__|DR%-V0dC(ghoSIa!U?Mxc7JoO;Z34(w5
z#kcsIyc@3-%JkcHe(g*|<T&t)j>g-8Kvf9;)>U)LaQTWkcurY6edVJ%r{OU3*VX0#
z`@X5}Km0ke6$8C$Wz+4*wcONe@%L+I0R@fv(geSY+w8L{`OjkP^MOx2O%HeLvphdE
zq^uoKN{`mN7pgW>2zM&DxzN!YW%NukNLy%{6HI7)@yv~Js94ZGD&X{7`Ea3>Y>aLY
zRCo}%$uhCjFi*}a@>G5CciS+BssEcN1Gp<Acf#Cq^;~It#!c-o<)OWGK!QHMG(f2E
z^VWTFMuTCg#jXiq1LBju%!`^qZ;Ky?TM$;^3ab2yXFJLxXE*m{MC*d(k}*?Ji$)c}
z3+AFe$>TgvXYEh(8P@dJ&W;@ctb6VKqOcq<PGw80=|)!5+<9I^!a*77!&TtB0GLk<
zx@L-GF-_+lMTeI_nc?>m!T9KgkA#&-`}aaM1W95TmPgUYZVm7bKT9_kOc#1JV$OKY
zy-$NqWmQrZYCG-D^EBfA2?vt|X|b(uZ1o4`8a1ogRU${R>oKqqMCb8N!<V^$&lhv8
zl<a<#1`t*$ftcErOfX8*KdqH%dUD8bZ)ZWQI-S09l~;dN^UP`ug=FY7oi6xyTa}X1
zHX1z__ob#M<<Hbz#*FQzzxUi+X8!*Ezi_?(LkF*RvB7Ry@AoXWEt|POaOM_~KFkbb
z%nT8LK`z<l@}YI^)Zm+H8lS;Gm*<JQYr8gQ_a@jIGwb`eh50zXEsU2Jv87Z2_TLnf
zv;A7Od@iA<PPV&+*54Gv`L~xpm27nqE=sZ9w;$7c*EdvQyVPr$K!)ba@25U(eOr*1
z`HCVjRciAn+{6J0rftiH3fE8?1h?Yu$fyg%FYbYV+mhpk6b(jU1`(k3BbCiD@Gz?a
zs94jk7`B9^&IyFzUi}h|^^tGqZc=>4Do;sc$9>IZ>`_EP-?A1c)*4CwaEkdm???Gp
zp7wExpmHIpF5_hU;BM-O;-S^kE1ML9*c@;~-<YHvHsXp$CcHaYpHFFu7Dkc8=@HIp
z^7$9FLyU&;JG<3e|A#i`B8IncW}Px3r5E3Xeeg<sj<Fh=Jhhn~mHT|c01)EWGA}wQ
z{A07|2o++Jl<ZJov3rOPf->dB%U|i|taxE-t|<|;8rKq9n;+ou?AdK^v{tu);EDG7
zR}m#I8tlTFj)@>Sb2}2r%7Ln>bKKdGWvIb?7CvM+@q5T~|65O^vuaqgL<l*3pcQ5z
zD`myU=f8f)h*C-0hJ&ioc)F4>&Ss&j#ed~E(7>60cE3e?D&T218yrKLqp|`u?@ame
z(QmbkeEmo(@lCqOKKXVWQjaQaF{;@-_qF>JOg0%1z<cX^_iZk(7;T%0jRty;18v1I
zs>SDIv!v58>Kdm|iQwoid}KXt(ug0U3z`y&170Sr_%w&|LFKq_Zphe&ii{=Hr9Z}2
z`25M;dP}=Y-+Qgs+D?fLj?@0}KB8oO{y>9$%tV}O`-sL;`48xL416QI$&vV96$z+Q
z8kkv%_VaO}b-K;vOc#L2bP!8qLseLDMgWq11&buS_`X%GJ2;}qIYKiU%S0f+=hJn@
zf!@8r2HhV$so<8Zoyy7Jc>Nu%AKoWdypxL7Z!R*hzNO^|T-xwZk4%Yfwlg5$&1ZDt
zMV|{fMGYs`WE%;Z&u;|y4cW@wYBUuKJ&(lNA6yW76BjU-u^rb6S<G2{I1fYwawytF
z{$Xaqkk_6lvIq^%Bnn>W0(!ObtGV9ZV8b-@=C|(_7Xl;w@b?F9Jgrdx!2C_Bs;{k|
z6jg$^4B&j9$@iV?Hr(GD$H8b<CQTyr_+U>v)u3%@ilyTOO*!37&zJA5xoY$~?1rW@
z8ek02=U5Z)Fd+C_sySw-U;b?`ULQ8r*zNc&Wp2{h4Vdyf3pAzlt#iS(ogCk*6xn-(
z--*E!SMTE>vu7t$RChC*B15*s8KAeuj<z_hO_RZHTI6EtGX<L|`W7N?Q@=K)s|e#(
zbKMOU^Tg0mljc+^3MHVDdn<tx+Z;NUsH#uX*ZyOvt@!B3)ZUNQM(oQ=s|oEFi&nfO
zB?>=B5=2yOjIs-JT7<->wm6tcF*6F#nCSyFfAJZZ6^G30L$Y%RnQpcVNcSZ|HM#X)
zhl@kqlOR1Da4M}OTvn_G=W*3Z+w$@Jq}9sMk|NhURdnokECD6j>@YC%G|dFLaD_}g
zB%`Vk)q}5W1xQ%%?pQEm$QvldW=nT*OxCLiYm`X}Ynh0bXB9%o8}~{2Pcg{2MGVTY
z^mbzG1G7@Vsj8^RB4@2FN$9KuI!%K6iF}<df~n<!cKz&3yOBzoHQkr<Xve~ms09AH
zs@9WdIaT@<X*+a*Z5F3DVN<q8_H1;D*^%^Y7v;n!9}`2ckxNV{>SOWrjOKk^eMH|R
z+0gLtdSmy?>ABiu`G0cTB*LUC3fLOGEKO@i)n34P@WnUE?6$LlHa-m4>o?FR_N%2{
zg<-|~Z3Y}G@%Ss~@q7Ij1n)BCx4kBHJNf=|mS3aJa>&2WavBh!fZVz}G~hL$gB~uI
zKg%MZy|@u*@M!`dJ}v=KUyj0(<U#Q^UBFh=85Se0qF&>eI}#J(?g2N8e@?B_UAzbJ
zGxUEuGOByci~&|FCPIUd2s7cF4s=f-?5aBx_2pTg^>ldAh`mv*9C>{>=&34|p)Jd6
z(_!IBWY>)Daa$}|CB_%Agd|s)aH*>ylAa_AaKB~%?npL?e%^e!fZ=CBP7FFS6;i?e
zqQ(}4&IMa?kW;$>)%>tHN#@$(sg!;`HXS?i0MxG&4txM%FQy87cB?6`BA4a=u=eT9
z@Ooa9+u7|YT_=dQR<ef#h+tFs5~3n4JU?P;{D;1@l}N5HL(#_^b4&?ijnZUWJY0>)
zw&>{u_ph16h~BaasH_am%cYLbzCr(*7|(G_nk*f^pn;{($2Pw)zX#%%_T$E{gpULg
z+5Sc|2un_k>7J#}My~?E)v88@m&t{_!&a?M9Krb5!{5*PTr855<way~XDy$+5T0*8
z#xQknk+*fD5-X(oywT09TcS9;XnS?4>$U2#0Jm6@=ArIgw;<uUoS--75kq&Zj>}HE
zzp2b?7@OD$PA>C!RTBl>Ddm<DVg{V&;IMu92W8Q(2G2^>@lh9jbl3(6^RF3}<GjOQ
z`HyDnJ8PE;uXbmXvI@buV8{6n$!s!*kU~bUqvH>>&W^<{Ht7c8G%+)MH-9#&uaQ<c
zG_l3OBD*P~pL%UTGrbqOy%V>DD92@qk_*`kBSjll!->PhQ0uNjJAqwn2o~E!acy7n
z#yY_FSAg1D+ZhN<{g#uGo!07TrwxC*ah1`rkxwYNSU^+?wUDMHh3f3Z7fEQaWCV?3
z!UFNWOz$cN64}5rzoF1)6Z~OG=*E|Y;;fHoe>t@^47GA#Z`)vkcfNK<z0EVb2`&S}
zJ)A&V51!QcCZaiBJ3Wg+A$(jhu+}8bu`N7Xh0Slu^Wo}W(~2iKsij4nY0oP8uFn?)
zh8%w3vMj9G?#L~)X&2Kp`&Hf0a8naNoO9KyojnB7j4RU;<_tTK)oMI^V$n7sb+r}b
zDf`kGq76Lal3~jkZjc+h<Jq0n0);U6a_gr7#^%bfrQAJjU45o9Xq(0USR1hcM+G@%
zTrf(BMIWx~<u||rI6qUT`1p0B2)vZKY?{T_ysPdMmTLQxvk?<6{*X8N#5q0J6VJT%
zT5s){FuuRP5SlNi@V%z!U7_e&fbdi;hofM^5QwA@g=0v@|JB710Y$M%<naYl3P+57
zc4{j?wkwG0xF`hiW0M!8;?SA%q!e+_Ejo_BUf5f630T659uIH$OZws0$2a@GqWdKC
zyu=3tRG$5#G4Ks*8NH9@_J`Zy)yicG0P@Xr$X^aTaUINz*MMSZ<i#s%fTl~8B6?pn
zrH_X0yZH#C!8b>HcaR6K;!f&-V$c}RInr2F^ap6F9272O`f0EaXG$RW`>jiNA4Mt#
zwhd_ZNm1C|BB-QLL_-b6oA3K%lQ-$Oo7KIrw@~L(Er`j_)_d4f3m+ovPFuX=IB~cJ
zxs|bYvhk<BP)CPFW5C{_fsfSpb{yyk0S&ap2ON}A-Ct_hQ281oCTwq0g37>$V;&(n
zp@PEK8X#D8E%r8NTvqoF*{wsNSzW_U$TwPMnO<M6rntBO%&c>QE+Nh1rMFM^#Okdx
z1dXtpB(}#E);i~=ag<Nq>EHXIaB)vfoU-<{@aA0l186fP^%q6=MtZ}%?{T5x+Cwki
z0Yn=d(FfT~7IlSStG2R_T^L>sz6iHh33K|Lv86}w8_~dD{RE0O%wD}cxD4(vW`s<1
z(sSMyR{xK*w+xE2>AFVo;BJ8+!QB$vhM>U-0S33=8r(Iw6I=%f65QS08C-$|2@b&>
z&c*Y+-+Ru_`?*imRmH!dx_isod#&9K?;nNxJKI_)^5zO%JxSxMH(mH&MX41FgWBnz
z6Z3&{(d0>aA>&K1wT)%=;3y6*seCZVA4Y|xHK1<K3QX5njm>Jro5wbd5W@ZqG=bdg
z(abr62hxrpWn<2<g6H0F{*i07pxGQmn{_=Wi>v(=7Lw>tonZ~M8$=c_?;9%=VRi?~
zinizhjzviu_B%a{^bT@sn=bOj{W_`xi0nQPDPVWoi15}8e{amBH<_pE9jO>y+E0<A
z=M=M{LT?2Jk$+-NAbd9;0&JMO+cHwdREEEN1a9Rp=H7;Pv}W&=O0EwU*z*oj1h#w1
zoQog*Y*_O}98SD0CZ+h(HW;N<>t?8nNq^ocH4)+ANJuv2lPEAu+ths+V9=6^V|mY+
zVUbdwJ9Vx)Cb^yCZ&t@PonQCauj=zRe=GRwM6}YgQ7$fh_y)^Dji1gRo7^YzJ%TM4
zXMQiOwujb5TJBUJQG~0Y(Y6*5B0A6W9DA?+QO-=qoTqGk`u)?S;A!rBN0t$st6JvZ
zSMPbmF>RxsR9Nv6-+Dly-R7IMOX_Yy8H%J%MiGUv6Wc0Z1ex}vt`~k73%&;%x(cjg
zco=X`<+HU1TGK^*$)c~}`+b3EK+j;!+F#5TD99Mle@hZ(Q(eg__-OCoVO5c+>PN)2
zu&AK1vRTZTQ1d1;)yCzOkgWjcG|IR<Jzw74@#($(@FWf!fi%;1ajFr@?@>FOPRp3x
zLm6{z31gImQPkqR&AI;Wizy)?l(jvu^!|7enk#k*3=j4Ol2xFPLmk{yC!`j}W~m*y
z*}UQ3<Ac>phZ#JpM-b}FC|g&l?rGUUttHfxkM19!i(k+!^nAnT!3;m`1T%A4Bb9gs
zo%ND?q=e<=OOCbc4jBHtn>~;*;|etkA0!~>{aHTD7{Tz@ixE(?ovTqycv>L%`K(&W
z48NEb)~8N`g3X#9jEJ6bpBx84o~pI-yYOPsK@l^5#pU6+^vA&uToYaHbw0a+XNjBt
zMAGmgcUYE#9n1M&1>>5W7z!R@bjVBmEuwGtYMaQ7vGi-;FBT{__`{S`s*|NaM?8jV
zP}^l);@fCL^Ub{aET26GL~Upu7>1qe@a+$p0S3Ir8a%UKnzB*8#6vP>*><Z3&gh==
zE#sdXqm=AiRO)5T0{D`ET$N(~NhCxCtCZ#@2nqPl$Iq!)x-l@&5d80cX>b$5FsuZ$
zFRW!JrwRyW*Z7ml#79m<KOaS=58-eB8Jqb(TQKn9g@ItIT(U#TzHEnq4&=(_$L4kl
z6S&dAT%-b8>?Ckc`)sBseg*8G{jxw#tYgMlje+S@vdEn4G~>Mm&ux{z9LYVWR*Y5)
zf4k0qR^q~Ladqv)JGj;J@7izs_Yi&SsKa<tW`6LeT-IaPQ54KnzRgK5$z&@vt@-(9
zUlvAdMY&|Be9bB1TQ*uBZYDTl&=if^Os%<wZsY5r6xD<E+xE5~d6sb8OoO<Q&d<X=
zGWJX6kdiqOWG!8#OVoYC%aP@lsh)Xl*5Or(L=A35>ffuJbve@qou-+Wr+@6p^edc&
z9>sr*m*~_+B<Avgtm3jJ0c>hU)0&|Uz-Gk^;5@S%nY?p}Xkaez5;eGp{v%ue!D4d>
z0|OiJau>iqL)U;fqrmUa_*KRKusPq<+I7Y!Wc_#G{M5s(cAY!!FqGBp$ReHXPbgz`
zMs^I)+X@|j`LfkL8pE192bN-k%ZU|W3NN@Blg$dz2pe9hHzZR~WISQF=3u(Py>0Yn
zwQpRuUns4_@u}A&`CAjl29-jjJI^CT{H!sITCARpgpfHx5Szd0D3AzpaD5e)X+uMu
zE^{OiE7u#lQy3fRxWA5{nNw55V7B`y?iiZb);h~Sqe=3{Q6V*CQo3(a6n#u!|DyQ8
zl7HXL(T&w*^F&WXRzEQY4sxp>$F?Aq4(n1uW-7>?y#4b<SE`z<qsRbQ8~tZkScsB&
zpGeLKF3cUIa-V{7)YOr?61>I2c*s0L^<NoeuAe&S+~$7%|G)yR5;`lD^&7^&EHJyz
zSTHcp&-jes!T)<j!(rQX_U54b@jW(W%FuX|=b56;QMr28V*Gry_jr}ab>V%39z}?!
zwPt-lTfB>_!+yp)N4UXrLR=K5>mTD8uijZhPzgHJ81M&Q*-4T|dM^cA$H_<>&G@%j
zHQ3lSw%hACEQv(G+s?OG?R>k4znnTiHK1^r!YEuu*$Yw;iBm?I;ZLlewe1QgsoY=$
z?q!4WiUf9@GNQ-C7#o-)H|ZcrQK7uUm9DWFl&%pql?z-9=uM6}RIAh8kI}GiATD+S
zM%iJTy>hP#ZBC+O(5ga%%zyZsm%!HOiRUQy9$#VB&(Bx3)CWA=;qKpSLoH2q3s8h}
z7x&!jFu$u^eo9|sv-RX_&+M>CmhQE|5zQj)b#yi2lh$iry$w8u#1JXgdC5JcvZ84T
z1xT>@n}5KfSGs<UUCDx0r$uHt5rrV*haj`wgHo%-6;df*B+QHJM(Y2CE6m>?R&Zf;
zmArU%|5xtC#Vwd6*qX;`z6#8eJ86F5<gLk%O9}fAKL2a#^*yAP>-}r@ZOjvHoSnYS
zue$=5<|oprIUm;_P>QS?v_+LG=9Su%<0@gaP;70gO3*nhDH6KKk3_(q=nDY$0jbiS
zPYFy)$m99D^*rkrO5rfwGtH^G1d<>%l0xs8hrp{mJLI3gQPAb}B%gQj??R*zEGgoL
z8u9hSn<hWxvr#N+kP?!N@$8>*N<LbLqb|iO$#EUARnUK!t3}QQ_8zBqW+0T(c2}nV
z{f`ZSPnHzlJtBy;QB))Pgs$p&syeCy9_u7O*Q={coOI(qt1I+!nZl<bhf#Mg{Y*Cc
zGqX_Aklau<dPV7U#OQY%a2iMU3Fa}5o3BI;j>g^+fx%CNyH+@r0}<L~N*hCo)%>#M
z|KJNi5F*pN7Gd$aTE+*xTAY-GOAhO7LWZ0~Aez&*Tn5!kW1k~5{hp2<UHpFJf-v>l
zet0D_n27yNxnQKgJjxCk|Av`K{^FEVN)<xnlgfpH9?|4E0lJbRl^`FBdYGg69?JVA
zmG@c#X;jv>;W;|0B1sGxvxWI0@i|;KMM&Vp24N^LB@=DSCOcZTJd9c^pdMg;%Wjt;
z(aTgz9j$(!k`lsm!DEyb<o1Ixb<RLNg5k)<(8`%Wa0G3zVl=0!A<Vo6Nw-wda+u0V
z!$wdi!$UCt;Og>$tfLaqoc#yhup?Rh^#?a@mu|Om#nd+xm-AIHtR@AByFGqcsT7D%
zv*5JXaWE(se6Xkx&sKk>Mi2Z4B>#Bn*jKtVAh>_>iNUROn>kB033oZVDZx6$lIhae
zry^g}!Ytv<cwlS{*$Ou_hzev-pQ?RWPa>BTBoU{{l&rNQ-kY?znD7eluX=qE6G@pg
z8Y-h9tx!AASIkJ5&HA}-zs91O%P8?<5sWO<YhjMnuYMw=`&RK|=SONd@ltX6O_C`T
zveX~Z5}zfeKIKZ)eOoERI4ola-k~NKJ{U3o(*R{7@+$xb*7uUse%UBoO#Cg011h1?
z{6thE30u1&v~v>zx9j+AqV%I5f=4(EB2;)bqfqZPs!w3(5cOan+duF-z&HIVfqe@U
z+NJW>qqTpF0F_3G?RnCpb~9RW6{f&E(Igg;T|ZbfQs0ZnF$KqinB)9K`20s3!Cvim
zC=OJ9(Pl`!R9{KP>faJ(Q=6ydG7^?dB;CnKOf1!C*xFGLicnw+-NUxQoB4wI*jW`Y
zomQ&QfoG2;w)yCC&Bd*{KzL;yD0SUzXXzsgS-xT2OK_!`+!7L$tigG2kqX4A%oELG
zmsMIbr-H;i+cVpewfMg9>9S`uxGv=cnT|NHf(H7Q>OaT+O2vb~+>OS)69-mAP78u{
zis3nAREr2$qXeHJp8;jsKk+3QN*O=6-51}3XrL&=tjtzNb1cPeGW~Xxn}*_+OxRQ%
zzd53iba+5=0Nz1+?@add$xwxK0E+GG)MS~nijCGs<)xl$=6gOf)E?r9eI+8lU>$OS
z-)Z|`-)Jx3!y}7c#;=~U$vME}B>xR+Q{q4TMChV!8mFHnu6Z@~h#|p5D<NNn#9Ht)
zTUg_cX#dbW;neLE9grjVv>NC7B#sCzVD^jNVeq?3$-2yf+pVD+e*o6ykq8`q+fsF*
zDm!raI{)_YpWt?F2`ZS|G0<!TyBA%pg0Z4b2EIF_Q2Fp&GEjN<$V9G5m~J55^;f)o
z`@x);v6dUY0PM{p$ymlB((t7s{G@PFZRVIsV3n#)r1aBUQSDf=Gu2b9-pd}oSNj#H
zc?i?>YUViN%n?u(&dbueH1l~tu)<r_z!j1k3MsLwfG({`&AiWv802HAJ)Rkw7%Z2f
z`TR?f@4nVf^bWGV$Xtlm)AGCML&>}0d9>d@XuP%o@5hWfe~^Q{aGx?;1zf#N0ysZC
z%dzPSG{g?E{w<s>F(Q;$n1AqrV*LuG4^~Uo_7VkK=OyTiBodl&m%dWN;x>Lp7*~KP
zV_?j&0a<&(B0z`F9JRx;jX&1b1abtM#b!2z9PV=ecr^eSm^M!VP2<O1yw>)*@<_tv
zeZ{jzmVn{P7;6&&ois<_yf&U4W;ia*sbr(t?JF#@V|)8)AxOO<lwg;TYKl;=n#{0f
zXLHL37tUPJreUS6eSLdpFh@;~47Qd$SpW*>1i77<5`(?aoHEsWS*-laVr^HxSC9gW
zE%>h%3u^eQnaMAIbBL0|=!aRI7lFWr=kJIES|jy@s&A-E|1FlNi{6^WYpwUbzRx*C
zHj4@0L2>JOOV&WL%i{h$k38xv7e{pOjP8%#J4Z`<q^ePvTJtwYp_n5zS1gm(N9D<-
z=|`~s)n*fX_~RPHo~JXbn0V-J9Bl@CqP4#3Gz%Yx`QJ9%n#ZTGdDbf2>PxpZMx2e~
zGL_U6u?S0AxnfA=VUBT;`8R)`!ST&>YP;HBuyJv3u4*+RQ(QsW3fdbVM5}m6Ku9Bm
zwCrU}a3Vr?dNP~hfiyt=k_IXilxn1aG_d#Ir2!y;x<e)5+GPFU%r&gbSVS8Vw#};k
zE+3Qnb2?z8GGoQQX-1`<W#8EOhMX<A&m3+xZ&1~1Z_@Ji@>r~^8gJe2Iqo!oK011*
z;NWuH;5`lpg;35zYfO0<hFMLplsiS@ktF^OMGhNb&M!|=s1@xm+}gRa4_EQ$*NR93
z1fcuAi)m-f<{IE7!X-;hXfK>o1|b9}NX9?HUMyCbD!v@L0^}MIYT2D59zzmJYZUq#
zDfcWsHO<rfENn0WTvjkDwv}JvFq<&TJtJRQV{yinMy@o(CC*8MK^E*YW8D=sUH^q@
zUZQOkl+UuqL+i~yE1bOh!{;`d;Rd7rwL8Mg`u|DJq`{^Eg6vC<g_a<UOTu{j9;#}`
zY-suszP9zN*g@6)hKaE6;1*9TnpN^}iNtl{rGbABMXSIc%i1=xu}A&MoK3};l>HrE
z75bgO>dsmQ#hE@j+({;Ytm-R0QK1i6gZB)<yePUPCchv`BfY?>K;cZ>(c0}a|DM#}
z4fnkgZ;36jI2Sxq{+Rt^)Zvl}<%~znxp6L|F(fA-EjYVMNazWWcVIcYqTc+WPQ*fl
z+L=13n=$%{Fi(w!Ajm-GQ7&3x1aK2SO1&A9#}wb}*`*kK`(1{THsDVRavJp*E+D0M
zadF{j(dyN!!ZCNCUWpmqbw<a+GOQL2*6B_SL4<P_EEUj-65gV1yS-I7JWPaq!q;?C
zvIgufJx(Y9NU8q>`oiKO<NkFDT=BdVY;y>?P9s)OqmtE)^!QKc(LoULfUU)y*UCkx
z?;SQMvBR&LBpuX!elzsDB((pXA9<j;-%;0uhKOglenXkC*w@BAEM!Q}X)AIL!Usk6
zgfAyF>-3uxd}0Ep-So@nda}nBb*k#bHgZsPc+;}b;XguG`p>X+bsC|EHdLQVD4EVq
zLj45F*ZJS9F^~VcV#-?fFqne7_@$hA=Z*?dBIA4q!1)^)<coITO}5Y^sRCb^O^pGL
z_X{DBLL3E>z?DgbhG0ob(TK}BHKB}^o_;-6=ot_jxQuxvVT2=7yNK`NsfsYIuUPu4
zI5Opjb@Iby+zGS~tlaLr2&}XvQ6ccH9wTC~PIh(lR^tE25a|^l+Bc<BBL5T1L@e&)
zV-UupJDboTiC)__-3x!+C%oU&N&hCTXYmHRsjjY@55I!PlNl8PIc(tl2&s6Rwof!N
zp;Ei#pjh8?c8DCEnSh0ymDr$)Pw#hsU1|Tj_7Gy&RdaSIJ0Xfr(P+E&YivH^Kyyyr
zmO#oR4{X6P$#Rn0+T=HN=9sWUkqb2Aix@id&X7j6c`I<w3gqn_Wv5&i1<Dme?afc*
zUHMF4wNN0JZU|L6ZzdZw11@lXKS=;!!#kHRl^7+qQ(FGT!M{pepjSV76L)Zh>d?WK
z84hdLSo}a5h@Bw~)iAB9sd6cT(c+Eg;ChsyRjt3_w{@C8{XC#zw@M;ode8Zu+h4vE
zC66OQ_v6XXGC9w+6_+EQ*HeL!etlHHnn6U|e}#?zHz=+zBS2;QH&FbAVXeVS8)8`5
z*ULcp=t-Z?ivm$2**7Nnnqp+aA>e`0L@ElBP125`yT=Zr>s=P!qRtUAv}4GtY|x+(
zUBDqg4M8iM4m+9cxkSm|5$t(Y{_FY*_u}yp{yx${QeuZ}HYi0C59dNe_Mm3L_mq3T
zdLGRaO3E$Ga+L49uv#+6hyp3AM`V?Py)fLJ7>)se5Y?F13lPc#ouEN5Qni1?j{e|y
zpC(3Co~LU=l{A`TcScwJlgFWs|Im(%%`e(q;Js#$c#M?c;Ddzgs`P<VL?}3Au4b2%
zq(4zxBUbLc-`Eb7-)iT`C8~?;nBoFCU+y~ZLg;^$VgXDhM(z{`s=#f;hch?H2HTMR
zcHG(Z2L8q4(jG&JUy>U*^{oWG9W`V2;TBmHn-Eh{HU>&w*xvoI5Z1I<1gi=A<Z-~a
zhwcC~_Fex*TcNcNHK@e0BUfjS5AcFI$s<GEmu~YH?-`XP4r!&96lTuT2ib+iHAOIP
zB~X8bqGIKXdXPTCZ`;dm4xnX=G6{=jys2F>f?Xm24OqY~(Ry47qCzIJ_#J6rad#Eq
zgxUSn-vx)-qNQw7`OG=vfJS<mXGH_5(y=&Z3XLm8Lb|Vh!<ln;g%AGHw8S)-P<r_2
zKTSd9ff{#196TUpe?QJKrS<xD(QE;@Yr?WiBIgN{SwkncT(ZlqvTE>O79_TC=7^ue
zv=XxV@H&HQS#?J<-|00fMwU~a*za!7CcV-2z*nexdh<F>?5;mqCMp8i!{CjU5ZXvQ
zcDyFNDE(JPTLVGag*Sw(o|m7WfNM{1X0gBLFB_}ufNv$aac&kU@=cCsG%)&yk?R;u
zEQbqMtrxQk7K3T&6A~@iJCskGA6DMIg8O!mKfInWS)8c6s4Ho4%a3Y=vb3Zn@wpUq
zkhD0&0m|Ftqaw{VyYWh?Nsgyb!~_6(QN{@X(9gFgmS3u~kQck`vB}rV38xYi3L6s4
zHni^SR5r%!%cMqt{@#Uc0Dn`wcsu8cVQd`O=r{%%9W}mPWVS9nF{oITnnjgpyubvY
zy@Cw+i%I<xJPU(@00b4X7yNs{<nKrXVy<k5&gQ=%><yl9CE5J@PIldEreM6TFRhY5
zsfQ#3<n@4evGxFq8~84F<YRc)W)Z88dhTZBx@O`9Bzp^=DfsB{p(-MGV~@&7k=6;_
z1OweH?~IcpcFN@S4FeY^*+(2n=C8H5;w5AFUmaDSX37Y|>yp|s?xk|VW*_OUzF1t#
zj>VtrIy>k7{Iqm>B&r*dwc{_)NUo<$8xUP9UpvOcl#aH51M8&r4Z1YWRI8=Q!Wk|p
zbvvKvNXb00CdYnwHT?UiX9vr%p_i*p5)DdT?f6R-#@lu`l@lcv1l-vOa|aYimM%DA
zLV}UYTe^`^U%q-nLe(uu*|S)UjcY=~<u{rOrQ4v+FHnc-UqT%b0azzFr*}!nKEJ3k
zCJRsAayx4vyuUUG)pqKS-ZoQNXTq@sGdvs<X15)0fSuI|v!*{Pe4F4z-^nE&c}+al
z$3aE43yUMVgRAmGlDG^3`c)SJimRsy;gRf|j{Ptz*{6!H8Z2mncMyb>bWH-D;H{*U
zYduL$XNcg_Ldh5GHq`JqWQ=XwXuP*?YYq44nsv|bN}AoD9JDj^-9rgSi<tzw!EH6*
zBz9Y{<sJWMyUBFmGwV4%=GzBS07nC>pRJ}*jyCc3Mkp$~t(g)~Le!Xzzj-mz??A+&
zVDd}4_m$9lL;7Z5H_DTkEcO;ZN#)nC-syS4h2^pjWokKugS+`JX~gPZV(ax~L}-?|
zI_%ZA3hAz6Oi!@e$wT^7mBg%eOg|(>NAh@_f?C*zRLT??hZ@o3QWGVn=NIhnn&dcA
zsB3US-|*{q@3*D|%A;uh_8e&HkVaFJ&d1_LOzi8(_l^hS3P)^!UF!cXj8xDDscfrk
zTWV1S6UI3zh$MQTr5nL|xU>W(AMC64>8Y^rc$!?JZQ*l#W;u0&d-K<I^Jk_&;m6da
zDAfHRR(y>t!{^Bg=yFQPq&27kvz+xrN>oY^Np;sn1?I@5-f>k0#(Ny2^YCTof?sxy
z!7sWOXOe4|f^4A9vw<VUqHDoD`r!|fUb$K&^Eov)*;#=^+mzvp@zMNS<70xYC0Q5+
z<C?B<7~wT=GQjO_{Z-?1ej}}2ic);u9@<#aCoEQdvd!qIi?#Op6F#$<P(cnmUSHrI
z{?k*9*m9;!*gC(FTr6vyM2puxl_ihlI?J=<;bDT<_d!|gvTiyI-O>+$8{;X3d7P=?
z$+chz5uBc%5Xpj<%kyZ|b4eBW4~PaC4T``UjIbHcwiwI08bWGjiK0t{OQvLrQJU7m
zPXxts6Obc2@d^z|nxljPx!#EK;p>7iw4I>6Z`b2|A}egD5MiyImX5!0=1tMmTIi>Z
z{_;{pa@&MVeW)atbiJ{6jM@m!9;K~32E3mN^|Lk7o3_ImxA~vpGKrA?$iWfCzic<1
z-&`)ECWaAy&!%ysx7{1fw(zqDRqF~n1B*2YJw4omz851c`Tt?0m<zmUuUdjCyMp=d
zB2nkP=Lkg`w9U<4<tVI(TmBJon7+myi4Ok@{z$mJiHZPV#umH-rcT4(-A0?{pAkmC
zl3km9y7Beph&&0y)<Q{5ylGmp&SA*i&UC=*(~?_Gvf0zr^a6fBQ#0&XX&;CVyWiW+
zrdQAtBzGNpy7ztHW9Ew8sy}r(E;7qOUE11)e{DOHb?Lr})uz`UKMeZbMuj)4RdfQ3
zLp;5eJ&&2xaYMy-`N5LLKCJ$cA=nZP4b<i&xpb7(;94$6#_Y>J)8#b7PwU5{T@ac@
z6}qz#N+*Fcel&`r;{@v@p%lh_je{PuWq+@ZD^(JZzazJ>$Ob7bEozy+846VO)~~66
z8B5Y^Sm~h8o^HwCO_Fv=)9KhRwj3HK-CSkG2nLEBJ_R^@kZ%f%meK|FODfwGZ}b!n
z2G{t_7P41WwMUWRh-zT6DSu5Hb2GJ2{YxsL@GsL@j1-Jb7&i3t#_ui*8oNj0*EnMI
zAq5cnY9nt=6nMemLHKUdd|II|Xd!43*=qO-5uKryjr?)F6CK2zM=Dhyn}}@Ists$y
z3L~Qi>u{K*4+^Ec%!V~g5p1WQjD(v-%Z!DHdcbp?p~yLoVGJ8o#nHp=b=$P7Q?_Jl
z;V^f}6KLSYpAn4$U<z8w`ovV1$nqZLHft1zK_xt9sH~ffx&)}XF0^~Y7(e@ou&m5P
zLX96WooL$)&O9;t`zJm!=U_PVhSPC(*Hc8O1r8|2$jJde+gl{STE4tuQPaA@#>l22
z;6vTl>Lf_t#(S!-G^!sjFidbFQaG+%RZ7&A;}4p?{t1?u<^DmPB=Z)y21-J{6v}%I
zElRA?;5y>`lhJ}*Ll28<4<LZYb^x=rTZEd0#Koxz^-DW8@_!a<sf|ijBCKj>JjYMf
z{~5&L@ih;Cx5fVzy!9(YJpA8w8D$~RE>jH55DRyT>+GYqKZY}>HRG2p*%&m85vh1T
z;zE4886=F_^ix_Th8CNwCCvZc*MH`Q9=fSHiP{fgVWVgc!o@(#Qp@O(n9ws!fM{fD
zoJzeyfB5U6E-|WtW2m)2gctNHKN#$1n`2mSqv9lonj4<GpMNnXD?~<g>cmuTXvz?M
zqW^Jo&c2)QL!smwU<4zjJal_kx`g|or$@IHT#~~?h^=sXlF);>-=drBdIzFyKKK!x
z*tcI#+r4iI+n2br@N~7NtnVHK&cj@BVpa4EYd56mKm08`yvAIan~MNdAIU}B<^3xh
zp-Q9+!@6%KQHy`qUtoXqbj`t?)SJ>Cy+6l9F09jg=JE7}Rm_U2F*@4lVVI`<CeLc{
zHNjTLBiS6028X`2;q!&OBE{q~)u0sm<EDoFQ3QqIdm=I09jw6$_TMe}Ts){_)EkrO
z0OwZvKWBIev7mg%7d)Bn$|*oR0RBQS+r}#7T^FR_J|r2IJ@L@?{oOtv(0LI1{$CY$
zFT}?mj^8!(-wI#^2BX<<8|4w$+F-Q0)Twlp<Vl0=BCI4;mLns!x0jJOR9!ipu9f26
zw1+2w?Q9~r#c26NoX}`V2tlrBLGY(5ZdsDXYK_*i0~gA0Ltu$g;RXo=n_SAI>;r{M
z(=duI#R5TX+JHI91EDF3fos!GH>*ylSiNZ%Mc{99`7p)k#W(D{RyWV&N1Kxlh%J2u
ztN~Y$o4wmtiWc5xMN}(_JK)(Lh-E7hCdQbgF+O3#8>+ih0#jCM+UrM!1TZ*G-#9(L
zMxR}4B?3MCfpaHaH`rR8iQy0C#lCOgH7E>BO^IFUesS!3f<3NCN=A%OJWjS)#H24o
zCUulHmon3DhSo$oD^)uC*`E+2CiFK?+k?t18(p(q4j5sbNb=@S*1ME^>DU#`iFIx@
ztj9V!+4b=&83;F;06?yT4urmrLKv;mBk2qDJL!S1N5=~2Cci>YIzIR~!cQd2Eim$A
zBoDGlooBf*0vLemzvK8A{4ifg43ET@zQ!5?4@)dYi?Bt`&dHImZ({x9mDI0*#MdB+
zBzdJVA<%Q(1oi=Gph;M1gJ5N{pEiSb=bJOt!e+#77iG~%M{I{Bv0M*?k5yZx5s*dv
z^KZi+YAnKZH+$p>no-=~_Cw7D@QhBIL~YiOzu@|Mc3`>oR@<<Uh<#2CPqO*i;IBVM
za9Rd-&&1<&%CTO2x}p#jo<9H~zIldUEe{DVub!;q0R|BlQXk>N9b*hxg{6N~((lx|
z;)=QExyWrCXS~z%ZV8&u;~Rjh-P7_Tlv_n%<6p1hA9?H}0+p;Xv11UU^iBsFp}6Bt
zH;8mKf(<AvD)L&J0tRA|D_g&EB|!kqqAxAnZcYldpB{GA<t;J<<EL*wA;|Znq=OLF
z3E@!=AC$e#-Q6m)uKVIXK5)A-pIMISr8v1nf<3S4Vx!bmvOL3&E-_e+dE+WH>tXJ6
zZ}sc#0r%04{I42!5Wr~wqHS00rFtg3A6AY}x#~pN;BA-CLV)f~9)uR$Ny4mPqQ>gx
zRL(CLMof_To(!(spJoKcPGc?O5VyPy5ERuJaB!se3oijM_Q3a>`-!{LTPG6uAqL!F
zJX76L5ntxH><-=H^_)Z3GYooRUX<;>Sb~TsTYK5pUcgRJb*obyo4Qj3&1x`=ib`$Y
z`sTIOpz3}iL~)|`X7@1%2u<WcS|>d(*xFaKRS222tYT{e7YX11a;wE8NV5Kz(SNQx
zH$rKi^FxO>T6^fJkA}I!^SV4&;*6_NzPY+y(9!Ag`WfX_7hSI@m9Nu3?jy-kGa~oe
z1HDQDF4dZ3Na78rc!NG0REu!blq^aXWwyArSJ?)V!_qsFm{0nZc!&jeh=%KDBRF2;
z>sDG)vfxq~on<1b>^)-G{D-o{u2`_&lRN@cV?dR7<sNA}iq?ysUD}$^@{<Y*`}WWY
zzVgo*XzZP98{4TNB{9I{t+%0gy@4}NB^}hE%Kb@{|D~QXdl`z*FM5lg_ekYu%Lb`!
ziI#S}Usx^~hWV-97wewx6;R?h$d|G!UiwVZKM-PnB87Wu3d^jNZRqGts$Iu3{AaQz
z^4c~7jo2SRjd`*ERS^AuJ7gbFAw3^-l%_UrJ&*14zD+PUFm|U0vl(?wS^>xI_=EnW
zdk|gh-6x|*O$4ZJnER<@4xWs_mecs6Scbii`7`Ak8n+FQN7pnN<JaU4fzL@0`Vick
zh+mpsZ{c=J#5pe_kb&oHOz<XnEpMbGqMwB|y8rm(QOk(L=8)0qC=7KDRWfVyLL6mL
zDz&4S_Jb7giLwo@fBA+q@q`p1^IqD<DzZG=Ns}CPUd4Leep}I#n9y$`LxUz+!3rn>
zCH0SYtNP@ywcdRT-M_)j6pwk|Q<^={HpRb2nv*ivRBXh71M~>wpad!)-WI`Mo*b75
z(D{?qK8@!IEc^3en2lTES|+2^&%JI@`yyI>?kub<>%6|;&Z(p@7cXLXqtv^(%#xHe
z;w}SyIEy@tvC`c7j<BPA4KSdC1>S9QL3Q4{C)sE+-1>5umXXy(uYtrVk|H5M7trZ~
zF}5U9uTFS+h807*DpF5s@uOmu0QO>S{i=*nhxaPZTCGaIPTB6WgnnZLE8|3-zG!#%
z2A#`~r&+AhXHSTcGQbOC`>zs#1UD<`94pOPg3aI4F-z?ZVn!Ot>rD|8!d`$JUnf4Y
z3h9p;%jw}-Xe(%v_0;M=aXh*QeUB!2bzg97<W-Bsi!^Lb<ofq)k!p_jTIJKG4WQrw
z;s!hAzhs#Km4Oy_TE4VO1TA)YYf#RKchJlNE2l|D00YE^IdH|}wNmT>ihrAwD1_n|
zp*HYahF)#?mj`Uc8;I&mpASB-@I3V)`|;!xv5%W@AiL>QqhMC2On>F(p_+W_QgH;q
zE|<?^GtHdMLFN~%&!Aixt(+~g#2Uw8#p$O_q)#8s_hZ26HesRFjSp|qJD!PVlJqIn
zE5vxm6f>YWh|sr`$qVl82vG7bv;NdFTT+}H&J^EOsT<#siIrAG<ZDz^z1+fFg`iuS
zT2HWhU5Bs&aEOk8FAKvuVGwA;w7n|f3)#M<eYnFaSzsVJ!|i94AD7>JD#MAyEW}AX
zU}Cc4-8Fh!r#q6Ds^7amCDiWuKBg~<YFHij=OlCE-ClB|hZ@2dJjoqivECV6h+2q6
zxV^mv4tx6(rd&kJ0x}xJ*j*bY6JR}dPXB7)gFM^5dE)Y6!L<S1%%q#VQ09?K_(z%i
zPcosz0-1@)pZW{q<n{)^zlxIk;?E1f`Rqwwd{l5pE(i|8>+URd^@!u}m#W7RsF1kC
zjfp#)vGU+iA`LO>RxpIz>w=;(xn|OcP6U0jrPC?sm4J@i#lLNAzD0zREy!*aZbd}P
zYZ6MhD)B#MwNO_&D|re6gyZ`S^Uwu4PG>CY>?etD-{ws$E{niES5wN(`a25|1y><%
zw^=~A=nS(Eg!d_@ZahFeBqJvT&1&;pClEROnCK+Zn5Obm{N42h)p!vI=a()k^)NuQ
z>7a$`6>9Hg#0kx8;uWlqbg$~~S{b<~EryD=?xmAwtYI`IL;Pz9ujK|sxOs!dLWL?z
z1-JOv5~Kb+4lBsDi*KN3gx*iRviDPUoL}5wPv<T^T}2q}uAw-KSVeAQU3dtVMlY@t
z4)<QH^vDfX$T13}Vx=jn!sqEV-JLdr*R>!HO@%?#0%6GrcWol1Vy5%T2R|&wV)^bg
z#{N-Ov>-3toY3X3rLA=L>(H%oBex&=EJ7pPx;p(OYfmIK=Plr(XewcEc+tC|!W7)o
zcj{Srl~w*hnRI6g156%mpFVswfe-T1MVNkl5#c;L(SB#8lP+WY{+VnzeZ-As?l&)*
znhM^W3UhL0gBqwwr>3kxD?}rv9UwdlW&Xpf`ov4v+7qiblpB5d0;4G|&SgrOB-0H|
zB=D?qU}slmta7YT|E9LsIetZ`H?+`@Ss}n)AhA&mCxr=bY~1McOcz{j)9b2d?CVH2
zp%K2o#&c-#O|+1&k4JFg2jdOK6#ajt?D}8S2bw^IB=Tutd{L*uaJ0w$$$ZV}a6N%d
zk&(1L+xH2Qf_l-*We9tbvtc$1zl_)ZV_ww0d7#V9)^EK$55~nak^PNN$c0od+(q*I
z)J;1e4pXA>MuP%f#{VP|7Lc#7Mt^^MbqMh?X2Jx!2H$4hMi}_xMY0NKKX@_0WQXGM
zm26E6_M%=e9i05H4^AM2BRou+-R(b_iKf*J@Y@IBlCVxhk&Z&G89>8c{!#$rXU^-$
z)jMh(BDt~bs0bK$*Vi4l+svb3+gsHaJ%Jiy>4vTd(1yRW0OVHIDR1+ACSqxIiz@Ua
ztS@1$oi)hIpX8zA@IJ?Tn4IwOOMQ#czt6jnk=}QbWoJ-E95UyN_m0<gW5Cyo41S5t
z#rOKz*vAEa?J$y>+Z|r?F+1CciWzPvq@#OdWd6pqJv6F1NQTRFXOc<7keiBXW87dj
z7#HMgvNPRrhGxy$+UqOAZeY<sM-b07Bxx4ozbbk2$MTE?VB;9EZ}<?PC|_O$bGUD!
z1_wJ1O7+2YaG`q-&e^K>qCU~NG`Rlt_^MP2lt7Rd{-}3!?CTd}qbgrd*q}^ZmJyvo
z<$FH8-w>d_w)nTP;-#9F6T-mAV)e1rHa9^68c;yGf=Ac6e^a##fM84$kD{Bo%L{}S
z7kXsA4BN@DgDmu80q=q9Yb=4Ct-&j2r6xv-g($54)4~R>8!v$<ZR)S+KXP4CE{*W8
zG?<KFn*%~d2oCYnvh;p^%sa3H|0RR6$nkX`XNE6UC8~apVN)kP@H|*>zx2d6rRdi2
ziVg)=&r&tB24LnK4fA{L?rdf82^8Rh(pd+VY^aE&-@j$Dwl!0P5FtQ&sQlUi@WM{l
zV8{e}(b3Vn+>P05a1JOot|eh~d+$2<;dbc(uB})$mx?EvCOBv3c>PZ%=}k!o{#%1u
zzeN3K`agQ(8{3K)zv>vMs>C97TLLGZ&y+Y8&8XTg?7->zJ-*}H5G?%xrKcUD6!L1Q
z*X0`6{S;SUbglc$<#kjjo%&He^I$sJQ4*VmEFm>OT?hDlG_!g_^tsLT>&t9La4LUy
z(iiydL}D}+L8g-qdJkuw?=*)K)fX#Yh#f(S{rK(+>erh&uF3j+^BGbGHB$5NAWv?s
zy6tTO33Os3eu2b~RK-Jbw3n!9QAovOglShWZf@~yTXF#N#r-eUSkM}{-K3&>793E+
z{Qz()V?L|jc;w2rIPw5mqtv84*xFy*KhBS8>pZ*X_itWhQtlVwtzlp<JHy>SJ&En;
zP?Alw;3=ZSaNjzb(D+vzZ~wjhOtQ%jzt>oBk!ZA7=dT|o38wYQ`c<3*Vd-g}Y@0c3
zySXJSY{Sd3udg{DKr<=aL4l;_>ux3MLpZLn6V3GV+FIDU=};lwU||n?enhBI)3Qvb
z%vFw^6Rzs~iGdMcFp4q3cA1*j^%z&u+_|#W_8-rB?E$z8g#kFHQol?6P?)<#E1^|a
zL}+|LQWnVT;=a-Qn(pa%BABz3i1S&0&A|ODhE){La1!ptz$74$KG1)_&PzpdNPqU9
zZIXP*9>AH2|9<n7?H$a#$@pU=g2ATD*w%vdKpQcE*(8BUEn%2@h9oW0<~8~&1n4tU
zQUOpNooIeU0$O2w1TTm{gut4@CKrHf=~@4>%-dn}Q#TNPv`MDBRbKsVZ|LeuL+fW-
zuN{i6MD6`N5trre_vIO(){QW!C_B;o#t*b02W3?m+@oI$+X<;;p4@imZYGEAI`s#I
zB=(@pkbTzFRUB+SZJ>|8(O)C&Ed2iQ2RcSGL%f=|p7q?{j_j?|FLeQr@nOwi$qU|w
zP9KjaF-XcQ)Ty6^+3{oYiG44Wq-GT&^nUF@urx}N*eFb0kS0DkbH1G%YvM@r$E5>G
zh{n?}T<x}&U-UFwZOH!Ub+Qsnna6h>!6uchf@5P35A<tOCz>(u(sqxq*=^^lTph9Y
zsc$CNHP_;I<#6W0f<aqb6u-yYe%(;`3i(_0AThOg7KPb2(IpozswaKoCJv*Sf)9jR
zX`8b>zS0x+4fB06r2rn>=r3RE8y&^BmA^FP!;`FC0p&FYwM8M8vXrfFFC+16ONLr9
z2a4gi`(Djzq`dw_2x0W|=}<Q@$K@jhdMVi$J9<MwKrJTsFFW`UGeqDCw*~y8JRT1+
z@9al{sp)IOA4rhbL*I!&E#bOKjR&rTYipu^m7FQwK+!`GM{xNvXE;|WdIEpaJl!c$
z*rE^ERDE5sHm<PTh(peP-qs|qA?1GGtEAa<)nM<D6R<Qso^Ahrtqk+?Cs~*kOBs=T
zGW<UjhW7`)Vvf#)!C!tJE(G(k3sy+rgF;Yr$*;F@K_RT7YXl<`C{+)wLB*lh6ryPZ
zXLsb`faqNJ1g%xW%G^7Yc)HPNhwy2C=b96r-RPX?`4H^4T2uLRRCc7mtWXl>(HKD3
zIItJQ<v=(cCofJU*~k5H@1XWOJzpVVp4`yT5LUlqq0f{*+->c>)Ih=4&HncVbV!`>
za+E*0p@dZz<NH*4LO#)bv)-k^>#bwUKq}F1f!p=%nQN_v$sFi*(WQM6{IA1d1B@!%
z`)*n$IK+;weyV?mT>hiO;hV$j4}R;}t!dJwW@FUAkKHRsap4>QP74n9x;RZIet0mG
zQCjuS8VtwfWSh$d3Q`vtK^%HocHuRex^!*&P>Sv_5+{$o1jlid=NI|l4O@U2Jv=+D
zfi-0?h2F$^#NK<6*HOlNHVZ~uWuNer=B#dP^8-$jm=;EPp}3rdM!3Us*MA@Xqcm{|
z|3#oQKIqFS5LG|xr^X6tyg?v+zEmn=?~st^np6Apil-tdfRXuat)o<(wYE;qIXQy`
zy9w;l55!&gFB40fXUGsW{r&m}AvQp-QT31ksE61qo2#Q|GvmQNwxO5XfpA-{e~J;H
zckjzr+Jds59$=+5XssX5vMX;MxXF*x7E1Yqb>x(&MDA#9*V@85?rUJtE!|t6j$FZ7
z;DLI42yU~rmZ?H{h0t&!s!IgM4D0KWNQ8|r{HZ+}uBNwNUKMcg^G9p*O2<~a#Q8pv
zvW&8AV#ztQp|4@XUQ9^9lo{J^69G*vqKPXY#d_`(b5a6OW)BxQPp8`}t^JoiSHiyx
zfXP}gj|EayPGrv1NX8p@=!~$nhtyKCGc8imFh>VAnLuMpX?6PdovgvN{J`4z-`rL!
z54~1px9uZBI#csO8mDFa$#ebX@!wBwsPI1-&^haL@J8y+1-Tzg+rJfBsg)k`C>Mtx
zSv45=csEa>y}5&34qR76bmm#p$K2{Dn6eAoUX&u}%P$1qpZH4H>>(OOAvwt{u43BR
z;euRgpn$J6=?YzMV}n9iMAsT4hJMrZ=Lwc??`Q%(=P5KYp*Jm29cr%H=&^(M&^OW1
z2`&g2K6xS-Vb|ZpvU0Xg+Va4T*o(WtruzA-@o9+rVOC!;S04d-{>&J#t>KumQemi3
z+Ndpyz&f8q_uC{kVD|kaVTZaz2%Q}nad7j)5{CksRw>r$va?Q;`zz7AnhB27pHy7;
zcJZrL5BD`pOsQ6l&(j@!b(~dhZNRmF+FoJ$LQB05rieD~oV`9Mz3;b8P~7W4Y+@&<
zm&JX;F9-J`ZNGSZ{R#8s;J*LMg99>`2q9Rhj^3lIlWs%ooh2kohDyZw6?OJA_b1~9
zi5vR4Y)SduL1Y`&3OrW)H5ZpBr+Akh!~j=*FIc<e>~L$K)QsLVhpp3QL4jt6ZCpvf
zWh)l^1ul~P{>a%YL8)m|U#Vxlaq5BC;iHQ`QtmuM^2u%_aKpq4EDRrXdNHL~uwUW1
zR1xFaf2lzT=|gx=rB2rOVyMl{H|SDjsBMcEAF_A#H2vz$VeceTePoP?^kK>b%#ycv
zQok;DSW@P&h<3Pz&6-S{IX=22WqZ3>4B6sOXD|0>KU9eJC;sNiMeFGAKhX4gEcUDO
zQe~O2qB2s<RX^!jNVK|{RO;xh1)I*PxA*+%enUQPYvf!K8P1rT82WuPtVl<XZoiL<
zWIt^VH<T8AtD5RC8qAPvX@nu{FJq1Vo%eWsMD!WQ^iH8y!zV0pp8d2U29<%v%>F>>
z`IW8i>rR_i3Fk}hr_F1}6m9m-$Uex@BunySX@s){j;1RXsn4t%Fp6Sd{4(XE)+(IL
z2Sil5f6D;m6M`bf0gFctON7xH&7X^ZO;d1UG)e%{#x{KWJ}mFB=uTj*JkZ{wd}IFf
zs^_--$)B_$@6DCb!ae-9>hFwae|tTrZ3_wRACi3h@9+n(DopH^SenMs`{SZ5iqdUL
zBP!4KObL{F&(1d!nXbZ(;+j^}AU&AgqR;D5+sMd}mb}3#8G)QSg#>jyBS{ueGEo+l
zI-?j7GqkV@P(_e@UK1TdWA}?DHj3l-KODp_U%p3I-PDw)cTxVO*|m8B{O}Trrq9)6
z-!?<YWJ$x{J^cs9awRj4xeRe{JG2TyfGkl5#Lp{)tadE(Ic5X)o6=O^Eb`7D?T96{
z5kdLFhld)<cm&n^J1TiWmQ{Xbea`sdbj2Q`Q;+<kIzv?7rzT71Cb>*l@D8TEse!uu
zgz(OY7JS~(cXr6)b6*_#!5Z#+_9H?=xzfgYTy<+kWgro|dS#P#LbAA@?9b4)M1rkr
z+S1U{MC3G5zylXwLZ`L6{?+n}dV}&`syEoa!7NSBxh%4Y@Yqd<=46dhapoaFMa3;2
z3c%QNlb@&z*~NK@)?SO)ue3L4Fuh=t@deLcyx5Gy<D%OXe3RaV3<dX70=AKKU+uWw
zCS|LpkcU#6n45>nIEVwTu~7WG!I5^<j$65iXVM&1SQM65c<qRSZyQbE(G9k%2K6=S
zJnPn+#D{WeEubf4g#(%p^?#cy+os~m<r~tWcP8E7Nsj<PW|#}~fd3;3pf-v$w)S|F
z?adk1E&=aZQ&Cw5h!h*-1~n9i&uU(2YbL}{y%P#N{UzENm9BBRmq;U3%{BL)^}W@-
zc|vkkYvnh)4!r~`4RPx;!hTaz`|Ez>{*Y>;N!<{gC8IE1kEWlcTz1CZhOjZd_Xu(a
z+*?r}(MNT<h(sI1N~ki%i3N-tI4xP7z29$hl~Hz7eY*`=Gq5!zIB!w-94YpNo_u{j
z>foj;kWoGcnMk#?CY=Cm3j1s1-0kU-7YqjXXw^l<w|?$=K{M6>5#(Lp%I<0V5=3MF
zWe{y+^;6uA&1j0LV)qHIMTVrSBe0t6%}mcWm+k+Lj@85e<b=Y_?9jVGd4V4XeW!4T
z!s&x#9uAGM0A1hGd9uc*M$x$LsNclZUsni4E0|BuO)+Bn&d&3;nd<v6aHxOHRrc)N
z+CH!UJ!>k2hubwsfIofDPcbXO_mc$_0n_~cnm8C-mJhRJF{1bA$&UavCVoxYxgu!M
zyF|bun%+0}hdlf&zSBZefM+UD24k&%=7M0kg**Hs&YMDG2gy|T88kVtu1<H4=%}&D
zF9~Yy$mInD+m+_vy)Yc~%ludci5x4|+A-YyL{@7SwvC|^eFKx4Xd@?dZ`F5he;1u~
zQb|7ePJuo+&1;R|TR|lg&JV!)n!N`*=irqENj(+;-V5~Hy|0mq<G_p62Ps)^x<SJr
z9jn|G?1<?SG`HIjX|T>xr>TP87Y@(5foeS(`>!uY^Yzyss-(yl#m>LxUXUS5B;`}b
zJbiFZtScciiTA|M8+NfIEwIx8VE^N-IUFX}pWfS*Bijfr!mGNJhtids6q#AtNs3~z
z3i~PK(VMGoxT1~m{dGAh$c)Y@Wjytg`8P%-;cKHw9L!1C=L9&aJd*GCXg81h5=vda
zoQNwv>kNp3_1Hl>ttXp>g_295`#1^e`bM`MPdJjaer$)-cjSbSw$E!ON@&oN4|^9q
zfLFbzQjw_T+xY5kK}i~fgqQf?b(9DE@L(0OvS^}0L_cKUoeZ7opb4%_e<DP)KVDsx
zg-t`5H6rnk_hJNJQ~rPf4esEVDVbprHp0x=I(!ukhhGvS#d%skA&nXmYP~}WtgzIn
z68atAl=^X|-&eJl7r&ivH|e&XQ!e?e!jz=^-D5ZwMvl*1<)ik-cD1b#V=SF|!K5Wb
zuMAR~EM2E1t`-$h*t`AN;GGKYE)GzMUCW4Psc-{<FM#gfl>i_tG{|O=2{0_^<A<UF
zvx1MfMT!UwIq>tAtY!DZ+>dx{pTt3bg@=l8;&2m!t3vdBSQdd_1iNSF9ix{(YIkPU
zH?U1qxP431m=PX(1K=x`1Z%8nm8nE><wjRc+70G~^S6#NO<wFRiat+STP>T0uMTGh
zB6bjzpK`mt?eYLc6RI4QpE@BV@3u`97ZhRs+0rtsPn)&;ZB_(zvHZG&pd%cS9*p-N
ziIlf5vtnMvzz~sW<gWn|V1UqI<iC?t{D0U$G>EXUZNp$g%Uhw_3U>KpfyMV5MInHS
zUgi)P(w2~k{OVi#lf_Qw)4{zn7e8?Yvll%$*>CAm2ph);QC(bLAY7>*?`DXeU;7~=
z;-J3My#t88yazY4Iye=)RttD?&`YTXMl1GrywBppmLc|!-g?sC4)9NQFEEKfo`euA
zJ5F}N=ThXxOb2(fR*yH!%xKU8R=;S<I61)OuqRV*fIoC8sVG2>lLi4&&=^RZQe`+0
zAr1d+)g6Ke<-`G9zvXtMz*~DJ{n2k5N^9bk0&|D#Z7a=i=z=v*jomu(n<AKssSsCm
zjaXs52GAznXdz7-p=j*|x-!%0+0CBX*9BA%4KFO%$&g9hvF-@$xvxy0qR^gXT)>yO
zmFJC2D7{_Z;lq@x02n3~LP$hSi~;@`l+^j-a5A6g(2^&+#WM>c6jmg;3mBI(F{h=q
z;W_`mcL5~D0qKD2rMTs)o$6zx2B26y<%?ynN`bOIP^CS>nQ)nbA_nEE@{!V<NAxTT
zJ%b<(`7>xcbw!xMuLE(Wv8P#U(+QbO@JxF=+Zu^1Z_Axy6H|-?j28KvG!0~|cnrB&
zW)9BI%1X)m{%3R^0cEg_k1DY2Epsz1mq4ux8iwXkxhC(?iRE^QqAgJX%#Om!Sf{%x
zZxkM15(Pe$ig-UP#?WVpet#azTO<-Lb`9fBcMNz->nS6o-0HJ0Tx|KVufC;4Dq*DJ
z6?2iX%u6;YDi*#;W4V8=Fkl$kMV`lcZtSjCq{i|-{nf_|P=(twP4hARQ0WDI>I53f
zV#ZwcR{JORq8(xPejL&dtsSkR8{)=|%SQ(^q?ad~bo><I2S-`O^TWlRr$wc1q~CW`
z_B!g2<X>YYo-)h%jQpANL}<N_O2eZ6&NVm8XJyC5E+yB$n09-0ucXnz*&C|$IX<*e
zbfY1iE-kV7(R<$gBJX=PulLsc5Xx9ORkP`Y<7eNn5+5Rh#L$b>(9xcyq-AC+h0n5Q
zWIrQ?$1~r%9c6m8AWc6jC%X!_-9H?OJKo7`=q}wq?2U$q#;ZRU6$3MI(zDB@htl%v
zItb9~e)8Hx<oWajioUhmjofqE@4OuDr>j4*ZAbtj%q;FR(1MnL5%y8_S&tqhB4=6?
zcQ`y#HK}P}6Wtaeo<Onhd<M0~hJ0_%&Z0w+$LKpvZm7AjW-^J$uHnM5`G{!NaBwr9
zj3}g8W>f=}XqtQ6B9*@`a(JUg(Ln6OKLg*eg!yCh)dePu?l*WYGbxL0+N9@u3Y9d^
zWm>=EZ-PImfd)eSD-bJr96Q2BEsXakgSB^LsE{>0;=u2Kp1%|4r8Iy;Z^NPmb=hH~
zy+F)MLO7gTF`byV@6x)r+C+NuSQE?|RF+B&I;Nx^b01=#lPoi4EU42ZJdBW=VBrIY
zNJc*qj8u#;9CBkl=4}2rYjfKxGSkOtLeJ-LvLa^0`7MEVUvxAmH=s>7ynVcL9HHTn
z6#6n4%|;4K>oF5=u_YCs(oD<TQm1g(wjgPk7ZAT3A*nxbM1{TH$_Pcx;6=25^9v_z
zNX{&k<*pZb^nx2lnTKS-tvckvlz>}hd2l0hr+RM)A+k&40%L%ald3~<))MTg4l-;B
z4o)btB2z5%BH9+<&v)p(Q{8Rh3b5A4*GzyeR2Z04g&VC3Nuc{&Dg0ShiXV(B;G|{#
zc{Oxmslq7L%a$27?DG28gllET@v{Ebqm(T@2=q0kH>hQKfL`=tmtW8$ksw3!^;ZWU
z{Xy9q5=jr5sL7T<8QN{hqbS{khT(<9@5u=zucWfB$NYY?Q^GoTgbh8K8n8r#{iLbp
zcgNGV$#t{i{*tl6Vz{kvO>v9av&Z{-j~6~(5tUKAeMEV+nj2LuA*rFNK}8_h$LZ{x
zuA-e{$Jv4FoX-7JKa!FLsfNp^kdrG;LMl?6xY>)|lxMOy!GxUd@mLMzb|qMN2PH;?
zeyv>5SNM4CI;(?>_y1w*Eu-S<qGi$U27(25ch}%fW5L~>;I6@)gy0g~ogl&8U4j$b
zA-Fq@G;;aQdH20P?|+Z6dyGBznpJaE)$AvY3$(eoDd8eJzuJGL|9x=u@jd>+)91hV
z3vZxQ1iib(r_lenM=_=I`xLgg0Y%R1+i8c}hNtmH&@C&-S{*S@o#1^GSkD5sqIDce
zwU*OhF7rWbUnaqRZUeUUEr%I8(v|DK#=iyMwh4j61~KL(r<u^`bEE05Jnx|{ft0}w
z9gS7T21(8SxfS!5Q_A;OKJ}JweAN}AtC`s<bdB+|h*W{u6@vfTPB!*VI9&WTvQiQo
zXldrCSg=!#O^>=?n{|TT^;TtvdO?tS(OQ^yhv3J(TFe5#lg<Nv`hSJx_l_T+^j?>!
zu<!Um{C$KN=jj#^%DtM9s`ILu(m`(Q8Z}eONU5wYDZO#CkU4YBY=>`3z=Dw)e+?5;
z7rlUuOmSdSd!}g7G-adu2|yyfse!u~z#c9+Cw_G#aLpujnzT|HxwjK%6LlB$a5{?r
z6lR96sQq_5l^xm;-dXu$9Zf0wN1cfoemDcNFQq_=6Ta#c6SD91w_L7)vV#lWCZFT^
zpQK|Zr?W2Rb*_e|r+Ia%J)?Rsq1(d+Nh-ub@=Kp;VX5n!F{skJXza=G(IyjmLR*z4
z>t>`6iqDOk_Iz3c2f1nu*v8s5<xI<tNiK|~OU60LK5z98p+MoEzoJTT60AK@!W7c<
z4R2O{@htoPlCg$7j>a^x7kBqXNV#(3{i~XG-N5c~u@6g;0Z-kT$w(UWp8t`@xD!a}
z+UU!{4=DQsGw99IlW(Oa6CG!wGwSaDdB1QF$+CN6Xi^T&wsH)nzAwr(J4=l}fr>+G
zGjk|Ui0xy;E?n;!$Viy!ixV_D2XA9$whwgp`j5JRQmH1Ftq$z|JAA%+v8Gd};eyRn
zC3zJQJ^ar_r5*>>{S~ugKze=UH>VMQKc|Q+(T~-bbNGjulmCw6=;BBI;PbI<sxx1h
zx%W%f5~q*{=&(k+*CKp}o95R=Trmm;8_mT@+tOFyo<gS}s`t6?6y}{MS-9iW9%rJ<
zZ>Mx@8F_VvoQ2*TNz;iswPh`i$O?Cp25wMK5m2JWj72HJEPnXJ{&PsBTZb$a=ilyc
zK8*FT$Q_G!JZ-vHER;w>5hU{HA)J14-Fe_dm*_C{%k_W1qkw}STH^0xjML<*IV1v8
z@Jv!N-FzhKua5P{+Df6v$+by}yb{jSjj+(EoXq#&3~O>rSrDD%|1^(b5%++_uc5ui
zzc&&$?15j!Y2UQZP4~kBqfU3}tfdO9$1qXhc}rjo1uW?PV8FfW%G(XOuf*g>!-`U|
zYj0|p=iNPpg1bAC2V=fGQmRP)m3rI{3@8bvBjSDz$p7Bxuj{DLg&;I~>|XQHkiea!
zT+Vy@3g#nqFnF3ZEb!2>zym`!fo{f@vikva)BOmKZJA51#Sj6|TbAN`i~$`cT0K!P
zyvM~*%;CR#mxEwY{~Jh<V?7Zo2E8X-5WQ=UyxQd__Nl_}=mrxO(d%A5xY8H?tTuHQ
zV}3gqOzGI5719))8!#NRHls2%{%zF%bR%?aN}x!fD#8}!;8fXN2b<52n>T#1k3Oqk
zI)1i<n}=+wd1QuVK#*Qk5z9sYLLQl4#2mvY8ech{tm-!$aH+N7gouuDg80`S^~Lnj
z$@cTg=kIJM$`FUKz%V3*jf9P`T&=~>@JIN>DmZJDzy26rrzy3qEKF>gA}M59^Y>J-
zG^hVoC1gst4}E=0S5j(1VFJD0E?GUI)9?-i_&?Jqv6uhEV$w|PH*FP(1ok%?u<a}i
zTeZHz=94m&p%L-E_e-Rwuqz?PMl-0}1~&MQw>n_BmgJ|70yEg^eR@PZt38lW;Q-Xz
z57sw*kP=oV77Rm^-|B?p`rj7x&czyp)*>bcFfyq3Jh>&9^^ZT*>Iv`b(8m68JN|)?
z=gBbsQiHr5u9K>T?=I;-xe0Ye5}e9i-D3@Q(jljy)WBdFwg|0SGU?W-<7F4I&#%=E
zxIyNFR6m$r@slPeCk*z8t)WxdshSVeT`YA{c>mj!^jGRka~64jp}D+<lP9}HImU6q
zP6^&1%1^trb!o3%Lds+JK|j|)$574FgTYcMO@d+ezw!R9)&;tF@};g3q1|NvTm29J
zKh+O9Ej6&JyWSlz)b&<tR(T57&hfKyJV38`H%QlMJ1SoiZ@e4kP*Db$Ww*W~+*Sef
z6!7ME>Ym5ONfh1=opu#h1YKbwqX2q}Y2UE;jGs=J{7KrxRImO9i0#!R;L(THV0A$+
zzHIMg3GI%59J(^$h#)gewrGDc^+<BB{ROG)*n2duj9k=rKTSpJDi0tR=2h+%G1||s
zBd$m#`y2J;qW@pVv;A8N0!;?@DVxynbM+f=u+@sa9OrPtk~}8S^_`BWQOBjC!c7nF
z3@`ncL$HN$=nrfdXEC2F9>YwpmHhar7E;E1U7Fg#^(bjRa*{GmMHnM6s`*$jA!J~U
z`;!fwE4`ZlQxwCKd9nNfa$<kYp{2i1^^19NA&E@s#C<tRst4I2V&MdE(OR;_i}0V`
zcjLG&kUXVWQ@Y;tNQ?Q6(T=RxKZzGv$IGzy)#zrLtwr#t{6rUa&fn(NkYsR6huF+t
zG3}9KpX}UJ+i0m{31m(1iIU^TAI!Ly>v5d<)zY!+*gHQGO@<cyzSmM7!<dnol#!%Z
z1%rUoQtn!&smxJAuLtSaSwLY)0{e#_>>P=GinY&pWg2^-D=4STsj5Fg#D2%ZF>0k;
z^PDxeC(+?M!}Z~V14wl`T{e-)s1`4+v?&v!v5M=e7Tz}_%(PuulE%5uX>GL;*LtML
z@+iB=WXo`_VuUZ-26T8ZGJfpeUiB04v3u8a42<4$RQ~N13VHCHIJE{EMql3>F^Jf&
zy&or~IhS9A;^fYjUPqk~4irT`PiFdI)48Jm+_Y;jCuYE?ME!U&&5ZR}jKm1%osvpC
zX$QI60A>7d<6(WzQkWxRt2Ck0h>JR>K1g)TA7eNbvOyyA^||nW;|H9Y-u*`a3@e^U
zdIG->|99s5ZWN7pI_iO7MqS@>qsg=F^KVTh_Ko1|&oUrUZ%qId$)M4P9IGHUgUUpw
zMQ2p9eUaC@n=g+L+X{K#T+!mk%l0NW$<&i^nNjzY{s}TPN(Lt7^T6iF&OuO<yy<tT
z&b^T{@&AaPI2R1E7^p;P%i!I5n75$+m7jUd-J(_c75xN7!$@GgK>=fVPU>r7R%=Wd
z*$c~)<@splmW}S-!lA-;$H%qsu31rMrSG9VUtH?Rgs?AbT-{Su2TzoxU3{5?p;)qh
zJjs1&e!$WuI9=P_)M_Lz#*h#e@0%)0c^cx39BRycT-IDUHXW|!fq-631S{kpH_rmV
zd2h|wCWbNIIrF3XM>?J7dC~la%a5Nh$d2}Vb1O6-vsT+zXU;ocYdShyzu&)KYei(m
zy|=BKf0G9PSq|gCQ^<K1^C*(rGM45?b5~z((RSm1?m4Pcn#PXI`2Dn$P1(~QoSa0p
z)Q(zWBJB$Kp3y$Y(SLYChAofpe>g@HA1);&!;*+751V$!VOuP`JE*reG$ev#Ix^Qp
zJa4wiq;g3_4D&8o+HqiQlys)f!M<|BUF^b_WVFn`_Q85g2Jv{Tv2|=Fg+rxGEt$W$
zV5r<j1PQ3F)x*unyP0xJYL&Mxv5_vJv0sb-pk3%Sf5xzq9~Wtse5^>xSGRaeYYMLt
z<1{Bu-uzj>k<w(bKK4V$yLQrg;wp;fGzrhP$XF7Ka!8f!;7`51zR@35w!P9luxRXA
z2;zkZ>Y-ER-e8;3hTfVwnzNcHd9II`XvW9?r;bst|EG>0UbA@JId?nCGKUa}$0QAO
zyXR265m{J=IWU|?k^lbcNGkocd%(>S7zmvBU-ta2IshAA^is1{vLE*~4enuk80loC
zHke!lz9DMg{=WqrdPKG-QhTsyHknE3qwo=2!e075#y`eG{)Y=8tuoX8p59J5Ucqht
zx>uePhbj77AjhwrRO<ZYIWF*}!#JRm^yzxzK-o&<x#~<2c-x*J@aCNTZU#HnIIr2W
zno>lbKG-y31|s^=2g|brX~|h~OOnujY}$n%Z=;p}qp;rhfEM`UmFXTs{(cNC>(c?e
zkDw`f<{BkUZC>sf4g|T?-%94MuTE>5y7tu%$xA;c@pq=sBKn^y7z5mm$z<^Mz!hh8
z!kr}bToLeHI6fz{784)7sfKeG!bEV5hO?<$CuofGIZ-r4=lv>ZucdQ&Sm*Ulw4m+*
z^V3*Jz#q23a=-J+fn`BdeZMWM>y&rczX>{wR(fwOpYzgD-o4mUSpS{be!ahne;$$b
zJj{RkhysZy{>wK*8KP7)%U(elpF8-p!bmz9>E&IGYwzZJ#8|tOK>&VR;`(91-}6@l
z$JqaBxv`OuQtNkK)@J|03ZaL`&C>6*QtoV;)i!aXV~Ka^?S%BZd(g?v#&vxV3T5ZZ
z9%>Xc1?n1^uRS=zw2#s3{$>fseTd0?qEyBLy5}O4R{ODnj=hK)TT!qj!JS>}l4aZU
zQfI|N7LSTlzaj=b(l4W=Amw`Es?0~_M}eyWmKaR!pBl$YnAIyb5=(haxS4CWHq?5v
z6@{I{4_8oAu}`jCFiJm@oLqST?m8$;5$h>z7A4s!t}-b%&V+vOUCk%tjfgPBh3jYk
z>}QaY@8gwo=dw-NU2c+^cARv4&8A7lBCu#RDpzwSHQ_4D+)tq?=%P*(&ouS#VqHj7
zB=8Ioch*ELtM0h{QdC6jvK+P4UzJ0meOwV>A8$~I=xv0_?V+v(w3YitU-&>rGrmxu
z24DMB!8agfjfvA+-HBM!RF}v0k*RJaUK{sdx3?RDMtTj3q{vN+9#k!h!bE}E$Og~P
zq?bS6m4}ZRQbd99Bg&rSeZ%LEyaa-+S;Joc!qQrqr}yZQoG9-~;p#pabRwCpoSif{
z)V#G=%uows+z}xv&bVp8TFa1O7d6GdW0c9JG+i9U8IEG1n7Zw9*o!{nM(NL5xag!a
zI4=SXn)+HN9(?Vhq!b9+X9Sv8C`YLd-m<!S(;C7GqZaq-^QYTZ^(rBxcg$@55)o%G
zncua=zs|D}=gb^v&X#sj5aWE1Uq>!B^3gYXz~~LAr1UpT*VkT!H>N|1*5lB=o*1IJ
zC`I_^UKBQi-^KY|LvECU4M)@SeOYaih0589{wVcgrY?qv>-t>r$KEHt#YVX)%RHmV
z6rVKPJC?GN<NLPr06Pkt`rQnhr5DMS;hhRE8RN!kEKS;fza^g_o*0<YhIT1!`=KRz
zDVl?BGW1&sT`wWu3{GaIGy)*D80#<UNcM3Aj9qPz&WD8Ry7HoH#qzeXyLGh}NqR(F
z8`xG>nhwHl%9$@3A{ktf>s^lBwxfInD<^!JZCy&&0{l-tIJT~pdNacctq_Nt@<5-R
z3l~NgnYF?(ieNZBXt;}nVaea5Sy79J_*$Wu+uQh#AgYvSGw!rd#*~9G`aj5g<zx*-
zAcuBiZq;OH2Ih>r6NE1<$wg)8GL1Ec=B56xhQIVv$(or)`|3`*o}uKEo;vf+;#|x5
zdUsKrR8e*5i70LxTUl4ZkdwTYg!-bdVU;iUYuTqYhR}gzNF(&uEk$xJVc3~x)S7rX
zp6Z-DKg5e>$Lb(pJ4w~B`Z(a%m^<*OopCBWX}Jq+#6ABhmxe?u(XU95s^F=8uD8pm
z7&Ybg?~a2<>@X>>UR`-qPD(136-UdR)Q3;C_ic}7xYtCQbFksXL%^~E&L51V((A^W
z4s9(+WD-kH_cZPj&d^p{dG(>_{VzM0S9vlRSrG5H$I+3?B+K)aSWZ-?tQk)}r#f#^
z&yC%wusyxhqtrD{@)zY8c-M>MPk*||B6Hi$S<>NuyR@+Gr1)Sc8kPxrie6sSbD$-8
zyDKPmohsTg-OzJ8E?lFe;}O>;B;G0x&c(ML)b8)u5^ML_jfm!`-RL&66fxU=Obrnm
zyDN0!`@y8n@e7wR?Zt;kuuj0ru&<P0)1?Zl-FWHd%Ml)8a^9T2ZfDAstl?<3>dKh(
zab_Y%St`!&>yDzQ2>))#WZ;%t>~1lSyR!O?im!<E)XDnQVs;pz?j!5L3cjoB#Zf&(
zb)9u<p7Yc9dX~*@8NZ2awBOKliW?1XY2>xQv#Y-j%@yNQ=I7?4j7*UF%yIsTrt;xW
z`%WG#0)dkTH9HXbyR3}y^2auW$Mplg`RqC3t!b9IT<&yFE)Ajd#4>$%{l>BUDSg+O
z&gxF@*L?_@&1_LcK+$;_OM0pd564szp2*o_<G43<+REvpy;L-@tmxMq?KO{|5aH9u
zMwTfd+-(Tvg?3kJs3UjHT|4(FD^9I37De`bXGnQi2DJ2GsK~Rkj5hUl-M1m5z3kxO
zhhJa`#N#DydmsCL{jL1OaCB>YHOsq;c8W4m+LJ)RQ^Y<n7d;J)34H7=o0GdIpy9^!
z=(5nIvU=TNI(4Gq!<ZJm2YIffJS#n>coAHB#Z;<Fv=;ZTrV!foUh`#5pirrDAm`5N
zT{<X~p)v2`=#G897SZBWz#g;x%GaytqIzaJWwrOD?MCN>T2W=s&~o$gqao_WG}0%)
zBV(L(Fmpwd@BQ`Ndr!Pp4f<}V?UYpPlniBluL!8Pw*PI>LOm8POsC~g`1B+72WM^*
zG&H+=mUQx7h9fn)DWBUsfUX10*HPPj?(|CQ+HH8X&5zA}*MHw1gRDIej#H>BNPS(~
zq9W)24pqE-GhXO*{GbG{51YK%1MZaXr_X2MYH5o#)kXa+UjzbQ4KmG5#HAO(ubrfx
zua=v5%G-~cRh$RVh@Hty>aMjw6z>lU1=s%PI+*Isoa~ge5aY9g8j9}Xa5w_)X6rFq
z;^XC7HMO0(mf{#Hx?AA_LNC!%U()8n<(&nWeW!d>XsnXchUMmgnYiSKdx`GckHrUr
zoV&iVcbzTAZrpFaE(G5~e=mxjX&!c5jBLz^3NDuhRGl*%_~v>J>AD97c3*^PZa#IN
zc3L@6={8lh9tlfDUaJun*BMwo9+#iHvA4jC4?gcaa=>J@w)6lF*3OTwSu1D$$QM~l
zQK@AetoP>0Gg$ojI!|4$RwVg>%EP`MqBrHU=tY|C;iV4MUUs{6Xb&9PnBlv5B!*fa
z6*6F5H!2)m1v7k_j6A)uT@Wqq%smYpCQVtNZN#hU=!z}j=Jt%W<c;wmofL37qu!P(
zU$enxn|Tf6N5ot2k#LJ_#tKBT@w@&Je8ul9?C(O;^|`0M9+wZ|Y3Nbv=TaAJK6dGO
ze*haqY7H5Ql11)NXSw_gIBdTm6FebKj3;#*k`lFs)@gkeDHcv}OWW{W?>33Mly5Z$
zMg6vfFaZuT$*|bdzL?>CQFRHyI6n|5`PVgP5cpJh13k~3^4if|{0lX>xFiTVh*Jsd
z8hazV15V!~0G^GzamR%LhaWNrwLEEd>(_4%MUF^nE_5$$Cj*Qxggeo4JYLVCU#T5r
zGTldK_gr8_o|aDm;6)zNf0w4;{tAx&nG&#axTsqTW*J@cb;10u5||Xs`>rp<O#@6<
zcTdo5^4SE-B0ux%Z%v_r!<;LI6+wrt|DGCThx++SGkZKgVP)s=Vi@;-k0s4KJ%^M5
z8iw&`!JG~=_4StS4(Z=NWu?yhXMLur&#g``G^@6O5Bh>B%PANZ65MR5*Gfm*-W^u(
zb&wd-ATgQGo}ue^rw!;Cb)!|*_hZxWm~nm;4-R+4iCbxH*o1h-79;S*s(V)<#s4!&
zTxOOdn=e8hs)AyAG+b%nkf#B!FQ}Av?3YX)R_tF9KUMI_$1O0e`96nac{z8zd$o0>
zZl3Ihi}<vBaJ4n9t>vaCSYDacs(d+eS<pGD^ei~21-9k$EJog0k?iDmMP}R}d2;%`
z(xyB{W4#G&g)hHNB3m;Uu!t*QuvWwJ<dvtX_suM?b{b@-q=G7fWX{N3ct9TeWEK<u
zSViM@FUjly{>{9YoFlp**ydJRK*T7j8&WFvX#7C$t70%Vg4}Ecar#Wa@+ojT`G)Tk
zzecmLOSmfq>|-DGPJzjkH??d43fwI%p#8d*!9sOvzrz%n!cEOCtskmO6i)9(zWvF}
z8+IE5%P@^Lo!WBW@>@gkIm``}SbriC`m@o9P@tqfsQ~#u6T6m@9uc%KNBY4I5iCvu
zMtqvx-Fe}Bh80-FjG*y54)FHtPyW0l?^cAQk~sB!p&q@w3**+$L`Aw};grZvF_I7L
zs6%>UVCF64`+G^o@lq(>{ix**>4Ef{s``@I)huK95LScLQpMUX@xxfJ`a)33@Bp5!
z*^C$ng--&=vZ6s>POLEwjNlpkCSV7@*z1*Ml)2|uV2QMalUwFbtS*+<=4O4}PE+5m
z90(iWchzf@6p-G=Z-oh<i10|R^j_6iDXoB+q%J+jE^_i(ft?3%MP<VEoKq#TZAZf~
z9|n49Vo(rpA`VGdGS~vKpt@DvMgkltPj2g2wZmw+NeXwDf9yqmXQ%~3{svbGDK(5i
zu&m=U_=Bw0Q}O+UKp)Mqu&{&j*Rk;{u+Z%yhYnP&I+AnFXGL%lnINgob5{=?RXdRA
z2$*14Mw;`Th%z<Xc_LZ_u)b8wW{9!gZK7V4^|dcfeZ5qj=ZK9JQIV3Qf?viC^EB&i
zB75Xn`NQ-FCF>+zX#F^UgH^2g71ep%WW`x*z4;$n8*0nKESQ~1@i_s`J7uu()>)y%
z6V3}ovmtM?Ye}H%re7`Wjlux4p_SjjOOR~?5EcEpiO+b5K@2%qAb|V|eMb})yvl51
zSAoR`yT%5HK%1iSJ1ZvLsEtjmAO8Jhm+7m|gdV<Z5g?KmxSx)fJ~sTu2Njyk<b95w
z-Q{KspBClRAPHwcpbR2#raRo*VCoSgL$@xtnx^#5&l!W6Ntsx%oJhiVdx-=1Gc_TA
zg-N((Rn=J1zPWi<^HcQFaTEQTvNkHIj>n#<U?-aq^(0GH`01@GZ3{Eu4Wigjtx2aP
zur9A>UFMJHL?6&8R!%xJUOuRRAGc|_vhV&0Gew3{2T?_#k<gusej*UV&%=87h>B`J
zIo&+)p!K#kcc82MU`qWV>&~9l7WX1vAx(Tb_)h6WH|TNbTU>=wH*UimdCeL8q|(rX
zU3P7wqOUUvyoL`SsGRgHAB)6)qqK>8!w2wnDbTbo5L+>OHx^(fieO$ONn*J8>Bc0&
zeQWM+UO>wCEW<=Z{=HP8f7+<gD;+Kn9op2nLcf(WOw-v)++12a^p(6Z-#Dk+r7tP2
zpR<>*&ozdn)9qW~^H-RKf+VtkW}2WPC4SteD)sI2(XkL_J|#(ine-`r9KWH{M>8k0
z$<EG*O5bZtOP4dVIuU4$OdK~b-Pq8gTqBJ@_t-eyK!TbZc(k%mRDVDHIyY_*x9TlK
zDfsQC#twl;c@KXzx@e$PH_!bv2MF*PcnM|0<Pl5gQ|F}M><&5`5V0ZpN3@I~2RNOa
z$-am%n_~7$>I*Pcu1V*{Sr)BWly(;p?DKNhUkoE5JY34>T*|MrTYrh!-?Ut{TDfAt
z0%%0TfVCk|pfx15N;vB_-K+k4wwF0i4(CDJNp&iBWKk;h$>K~HV!KD`a$xe|1rM-U
zifvltC=!x6B=@%C4l{k6T3%E1vOVKl(Y@CD{F2p3&=@yM7_eeiBbvzf$0zj##y8;=
zE%1v{3tP!qGpl{~-@qaWfp+_BVBhTlq3oF4`1P+Evxu_6BtVaU@{4NfSzYgI7&KwH
zE3DD;92vU!)#@#y2C5xU{lX+$U%VC(+HC14ojz=9d4UaB(ISd8^)0U5xul>jDMKCh
z`qth!Eh~S?*rd-d-5sFEQ7i$0$5+aB7`9RLEZal`yPY+StF2Kl_uEw$ewR)ofcNWF
zD#bahKMj@FeX<xP^>|7#yC1MLvwZEhIaL{wh#gdez%AkcTpMn}!q$I7GM7x3>7oyq
z?|-&_uarK>_s84`-CbVl!+xQOBncOm)i(*9`9OXCZ*1#F+F=aW4Tf)yHbNCr#|;PC
z=aL%f)E2g-V%0Na3&C1BhJSZ0Ax@zXzO~aeyr)=X(rkC*e~RtU%3}&B_j12Kl%+DT
zj%ud@2H7(UB9wn79F4{1P-v?F44#e-!*w$Y^>@N8?Mf;%Ub^r+58IL6zWL;bPJK%H
zPg=lX^W2OCWjin}10_8aE_TeP-IvYjdc1ipC#QR;Q!(|K-{+0+xzCd%h;-g@2A^Pz
z@8|(eJlkDrr}7|dx}_wL^P)6xF9*-zEg^1*q`Gj$DfrWw@vtTD$hi+&?0PTZU=Gcn
zXFS;ignk_-l~DBvB9HD7Vh`7%7pG-=k%70*7OvhO{LHSXIEIp=opD5!t<s|HyHQY^
zk-HPtaeEvyO)r$bsDJA>|I_XNlyBgx91!OHyzStB9{ilqlhx2A8qDU7@rL!{7TKtJ
z5?oLHJ5b<6Hs?`0;GC*Qw>i+G`>ayup!)oPAal{?J)mrww7p~VP13`W+&)2L)ZmGI
z#OE8^H-7p7AKW1_hQP1&eSC?B06RnEZr*m}Q=4tFZmX-`qv!obhg^T=7Z)9;@Q+4X
z78}QM6|A!9HrU_9GF*C<uE?!oYv^{T%Gq(B$O67=_Ho(}1!iPhW|3&Z4;|>f3XXf)
zqnzq4git|zq|T*13U>m(^(K;!!3Lc>9gW<)!@zcy%LBN)<#?XuKhXWE^tqC^i6Sl0
z-lIBkTBW|e0aoSHkj|Ip%Z5!|!Hyf+^j(O{F;O~r>dF7!?HtQY&7Q*v!?|_h&5p14
zmv`l`8K~jSrP?GXUYG45ee6hBfG)4H%>S!$={>ISN%qju#mS5RgWEUw)4<#uXt)+P
zqw9=g#@aWsiPz@0eqtxlL6v@&rMLawexs*kU);7^M1cR%zAp{ge^{?bmkvI=p{EG$
z74Cnq9v1rbXH{>Ic}A2zer1fCD1I+PO@k%o-zM3G1s8BG5Dc%97{QX>8tUzKAOUVP
zSx@3211emk$H4TYd?4D%3o3@IuWPfl#2gy<t<1L(`*^2{Ds@!uzI2zVeBsKQ3F!Xj
z=`=(7?aXDLX?btyptkjU`iu2s5dhURrl9OBb$k}S$CqRnvb-a?&=R)A2mW^*J)+WR
zX%pLn54f8pll{I{g$f)098ns<I+31U9NyX#J}Wb7vq_Tnt+E{DR1naxNgXt-)n&jj
zLfxL8EvybQ-B_|u3qcmwV^0Fpph6#so?)#+N4`P`R<QrY+hT<N#;|5{++#NJ(LwK7
zY)$wgO`m5MzZqIQEfwFTq;kGB%#v8VyJJ*Fw)<6Y2GoQ*Etj@xOszmXtdE%23<U3s
z$qrfd%F%fp-{d7w24x0$lFHP<O3JKFi*!tXeZ>a@gJ)a0_eHW+2Z#~g{{DcCFK&=h
zVu-{r+8-nr3ol=O!KHzIfnzyv)_(QmBTok8-B8IMraHPbnz%N+eal7KH))<s$G|6i
zrOj$_{qaLRsGF(u8cRhPgAcK==hRWUIL8^(<7wbd9Nr#>;5XB4uO5xFOA&-g5tNw0
zQ@?1s4>2UyZJL6QQ#mL+lQ7WFD?FwP<4h`o%d4kflljsB%QXX&7wink!?{JtH}Dg$
zX@n5hym@a3`J>JqgNR|y{(bt(kLh%tkoGM^X+?S~C0w$La<~!uC95X^Ew2S-dgBkS
zLO{E@2TyQ5+;=xQhoNF=U@0}D&=>>!WtI!z%kQ?qs|-Jg<O?66S=@xX=1os|C~!}B
zDtS0!=<blbFa$a&5o^nK={>_7&}C0Cpo0U*cvZ0t!Ld1IC|y_mikq|)1dAo(5bQXV
z2hZ;XWRLI;E`|+hiNiRLn#-*46*J4(;f}+Ohex-F#zqX+Rt52k<Yxn{O#w@sc5+-M
zq%;2UNDaS#N%ZH+WT$R5gQHHdXe{TLlQxhfqtOP3)010t+p#`H@FAjwsm;L!eR$|0
zfYCulkaRAHam_^Q;S$H}MeOmj@!uqN1db>6{A2v*Nw_y7I`jdoKS)3MH&*)z&tx)b
zi0LM}4#(biRQt1Y<xlC#IPd}RIE9AB89mMA#XPku=pR}%pHnnZ5NdJox+6<nED*CK
zw#;CG3kr`!&+!WmGHq4#xrDz^)2w5Lb(Q)O`*N7O6_*X*W}a~u{>neG6vqUV^j~Qz
z<1A^8CE5?~a(z&UK$9E)sfY6N;|c?oPmUEUFF){CiOLS<1EsrwW0Ynd1w!F&9OH@J
z7m3^hVjZlLrFI82bWEBkrx$1i%4I{4-O8;r+ht6WnDBhLW(B`#him~mq4eHwslX`^
zHpiO~omfe{CnnvRs-R!{WMHL>$WzB(n7r&eZro459vb>qf<wtI{AmOk5Kb+Owg?&J
z*xOR6zSvm%y90BuPcV2wdw$_>d4>m^$NE;vhY;Gq(I}zw_2V)CQ;@d_v_(BJb*oIP
zJ1lOT-`8lNX(*lk3LdB(TTwLh^-3RQT1;;E%hO7dz@@`0QI0^Vk0}V8a5F)&*L`|~
z_%96l?_1Ozu27@K(72qk=%N_`yz#38Ohj9(_r({K6R;QF+){U2Bl%68``S>1J~xkX
zZzQn;%@cYjb;2`SajZxeU&U2Q$jN`1%#!D`^mrFzQpY+Q8zF&>U9%p7XeH8ZPEno)
zeZgB5+(et_`Rt0**-;)q1by*LwL6;xuy!{HfY79Hg@*klxX}Ym8JNfBO^TntWC$Rv
zlSm~N{3`IiAbQ`(E^G!}?$~Aw6=irSFxxWBN1@0Jt>n?Z92iayeiGp!9Le_KEABC~
z%($~VBLX`b&+Z1S@pxC6b+7SgVy;NnZvFu7@WO!I{Fy4IjPq{~+^a6oiMWTmdQ_k4
z6+d0Z(ZQ;OuBYopWHh#a$<*nP75(!iN>j(me=T)x6akVML_7dHv-oSgvU{Rt6H?pF
zP&1kEfb_uFC{$K6wtrQlU0!coZEu~;lF9t?`v*(@i=Eom1>wmF*OrK3?{YWjv@X!0
zCh*SvzFJxWs%_N)hYk*(_>!9Vhey7k8nZj;`B!&NjYu<rC*6{wQUN2B_%tVS2spdV
zM~b@i-4IQt-b+1??JRbkcF;9D3{=T7*{}7+Ab^;l=IeR(4;K-@M=TiGh72A%MU>Iu
z2bz~7?OR-6Cbcnd)tC^{bm8XwH0d<tY0bi%YWW<SC)|)a!YZIxoUKm{2FMIjm47bq
z=pn^({`gqM$oX%XkDc3N>?xMtTvR{{&iVvTyi#~bh~78lMa&WiCLz+Xox^N*{jHzP
zPDc8Z{XN`^L>8o*Zf6s3UC~PQ$3JEj$|&k|(Z%tbuLm8vq?J8YV=QRWt=Z#g2b@jW
zUKdL&Fs^!a$nh{K7^I_ezxE;0PrVx*?kF12US(^XT2V8lG7*8+G0wNF)JXs*a7A=`
zs^R{~T5OLR{T1?!J`;}r!}5kR(!f-|5ZEXbC;Ue^;MyMo_l85~UOasGVs~lxW)HZv
zIQw-KjrA-9a)=NcNKT8Xrq3Vn8q(@vh1j|UJDgU_4PZAdJN<mfFaMy4`Kgijvh{VG
zX~jw8`PYuj7Rj=sD;&wtN3b!Z%eGK3Ay@illJB&+_n*f<ZIOk(t&bk7u5%R|yLtfT
z+-JAVCnY8MB{#H+N4lmEz=+=;X61fJyawcOSmKll_x*~ffO_7_Q4IqPm%dNWHc^!M
zxnHQH9G&_#_38zOTBruTrg|Xo$!bw3VD>}^(Z28@4E~c=^L*8%y2mlmS~qF)@H<J3
zq%W+f*0yd}7vVT}KTE3SJJ62pmJQh3o5CBP!{*V4^qgbmQo$zB?e9bbt&9+Un(#IX
z#5u)&-+{&14oY7nu+rToWV_iM`Jkb&p#?7E?5fd5UC!K<<zh+P)s{Bt#ZZ~|8aViI
zAu_PC-Jg>wM9ac%6YTjLZUX_}Us4G0$E9D>pX5$|U)j>gU(Gf%K!=Y!42#iG`th^q
z!%C5(f5<;5Fu3su2+$j@6U&=LU3qLfZ_c?Is;?@9^4~9&5VM8My8VdG<HvT`M=YSm
zPTThPO%j7Tl-Q!u$5B9~S$eeQgcJOgFG6oBJbm!|bD^zW_xB_Xo<jGjv3;rUE`m^)
z`nTPj5fB(J@TJ`b$j*>BJ!aW*?|h!=TelFq6URo{d>>Jt!w=xPpJfCyaeCElWzB0<
zU*BT^o-~`zcb5`z(;9lZ)sUZ$fY#z|UXtO+fE2N3o5H0bZyd!5Oqo_Y4s{VuLt|-z
z-LHTZBBg%~M%*`1oclZXfHHlW`nzHO`gRlrS(_26*m(%Z&GcZRa^uqt{WXhMv%;D4
z)U%({;%QAVju$V_@F>xF7S@*M<p+g#5+^+AXOY~Dz{Nr{amS`=8H2v-*A~X;Fk*kf
zU13{iSD72|arq8VP!E{%+(&!{vK3wyWByS_a3(7-`Fjz51|p*ZPSaBZxoA`?a*V+F
zJTd(dTh@+ITg-dGnJX$a2bWkK$>P(pt@h<oCi5W1K0`Ql2+ygkJ%hm9cnIU;VKPW}
zfYJJcO6J&G16+{@Dj?=~{)`P_4P?vf48}wJh>Tg4N4O3t+>$l1aO4(4lugPkijHd2
zLi@fefM7DL4H#C{&dA-%;y3QK#({XFnCOZ|E{{A?BlU<S*$Dm0+3Ny;FGPtLDg2%$
zS}&c#<Xfdx-y&J^$ESp{kN}y)Nz4Ei>HMdD=iGQI4J0ej=c;u@U2sDvNUKwYS4!jS
zKebAjHED8Td^MF0)S_M&RWJ_dujS2QEsb^XtBUZ){JAaV?Mvxi?;}Dbv%EPHhBtTY
z%c2%?1l8g^c)2C_supChv2xnI2yGt8J-~3QLUN=jjmj&w&f^=P4OA8qy`rWeLa#0c
zNM_TRP|}G5fzE<-zh&tw0K@Ms5kvrMKh4!w7>y8uaM=Zk%!<X}`~pdwBLJWLs%+p9
znWqYFGmz4_0-ey;{2^l$Cc%m9)0#-S<QRa^>oTrma{6;F>#2U?gAM8jWE^}66!(lS
ztgD?vVd^|o>}4ilC6oKn9ZAnL6Ja|y^h-hdyxdR49%*720!Y~B5~{!DwtPL&02uCO
zcSsB&+^x;S+#x?2*v5l=r5~1I^5!=aH-3b2z>(mhA#UaA#ni-~Azu^0`x(&LJyOU`
zHh$m%<uwB$lF_zlQ4Q8$L6ylt$;Fq*dB+s#<RJ1&ksYc0`@_fJk&C2>t|YK6;l&b6
z5K4Wsbv55K_lsIFX0cJ_05a5@p%$j<DTpyHhtr54N-d{4N9D6F;I^^F`$GK`1=|LV
zY+o@3EI1U&BAWYg2likEP4z>Wn}`_p8i>9%451@cHO9B?9QGh=ICfPW?~wuDhImI(
zGMx>V_eg4pDKg4-%52Ch=Czn(MbYF6U96S9i|+f2Vq(zR23gSBYBU)DJ}s<P=yNtN
zH3q$o;!EPuH(N&}>VmED7CAUXXF!HM0D^lH>)M$hx1#VF<+a+CMDfY`tsgGWDh11u
zz(P4#j%KbKwlDRe`}3B5q(Wq2FRgBI4&{kb<9Mw~M67J>xdej@mW~tVA4!tx0Z+U2
zpQQCc@!!e0=6Y8FuNDl}!g~)qDiUC(VmSZ<at7>SKk0t)2lk>-dt1ds4wDdmEgVpX
z1@_3HHc=cLE2kqMPkk`~Fzq(Jx;8Z-F$Xz<et;7<IY`$9aX4V2rnSem49Acc$Ef-#
z467zvRs}q{ZR~p3Wy^hhsdP<0xF(1damvd3V2hJiO_zO_>|PpN2gOkF6q7|s3U;dB
zm$YVM*zwJ*XqDr_*D)5Wt=vWn!gpwDiPob%Gx~y3%HcF;y@>VX9mLHOiNel}Vu>VE
zA9&FNxk&)$)ZX5xp5ok1{atl4xN%Mn;H=H`+4-W;KGGOw1r*iRmYusMh4Dw)Ew~O}
zkihix`?Mg3U0{`(z9rMM@}>!(HZyv`!atpAAk_hU$OVIG%5@7Z;Gasji@5#wKI|mA
zA0h%8=5CDNvE4H3Vy7ku9`Yc~sqq82g$(#+YiQ+I5owxl?k*D{vBVxhjp#rgE45Do
zoR-5hwKa{wcL@aQo<$8sC<4a=a$w<vc$RaU5ZeTM>>JfbhJfZJ6^5=Stg?X>{Hvn$
zVsX1{3&hJ5R59A;p^Yc90{X2{B%?yny>JNnC6usDf+kTK%$h%`6lavuFgNNX+$1~>
zy#R;5SDj-0SBRRciGpxD&hj^lYM2}YIPD5fsYV0s69)!f)#TP4O&u?=&p3lG#ey$E
z<yxu?v=Opk&Ddkk;ajw25Y@61j0rZ>CioZiG7maJ{HP0oZ%xR=tU23pJ=EshDaKzW
z-QO_c1?zKskLsBiuBG=B;tih41;&-^grS;<QoKR7`CA5``y1mMFd`zHe0)>vPtftl
zpID4{8i&RjceQyG(62PXaDd=scJJ?sMtdExLx^BxtuHw->Z+Cjz@A*oQeYGDD#tOn
z=>fACLYN719a7>e(@@<`$=(|8cc)2q2U=qu2DM1MUkvP6t@$gN&gV0V{v|EV_*HvR
zq=C<u@S@EzRa%i`rCgG{!L;X@6kgoqcg6!vA{RlnAE3gl8x8R(e$G-2rD2e8O8|Hb
zO0R105^@4!DjB38d?rv(<N~BCzF@<YbiAJIclooReU6FLa#2$Mr{QIxc{e^X;LEA<
z-6QP1`%#q{8axs8)?cTu#&#$WJ28zWb&AAal^x^ydvr<#rRqoWFMV)%c!0#(D_KCf
z-20;DOAyl5@Pk()yb`nW&+)K}7OA^0kjtry9im#zdTX<w5)F8-j3~3!{V~gzk^n(%
z2&3!;=XfI-^UT{auh%7v`IYg@qyh3N<7|6-%-*`Tw{;9@WgtqxNjoYy&X!kqaP8+%
z1c`&ju_^JodA8M5ZsZPJ9vR-%U!7dc7kxzXV<I`rSf8W&=mQkSPcj4s`qF5Z4X`9t
zw%sK4KZ(a)=V@yU*BujL$idt_A_5>!%y`ixIWhHyv1{llmN4}t6}k#_Z(d(lnbL=p
zx!O#PE&;}R5q9Nrsbc&Kv+Fq*jr@a|07<+1=&ge?+pOsR03u>1JpXw`9nddh39nx1
zkVwpwIwFhA8VSzqYx0O3>cqJW&bRT0t4z|A@xslqaEths+W1~&3DZfWE*a{}F~Oy-
zC1Y+)a)~YS&y)(^i#AH(p-GQUJKE3Tz7nH%PF~s7>ffBO-!980Jmlna-hN}8eR*z*
zHQtU42z)9DtF_%hm5a5?daOZq*h`F)dH+YO!Xh=vV!Kvum^;*`;5uClB2Zv+xwIU+
zX~Uhn5R1S&zI=xAKBHD{QtK2rCqKqteUp({LBII&V&u8#v=Q7K9hlx<D|K+enxXMS
zj_VEtfxVD8q*G2#fQ&tRBCM8<#^e_5;%l-$NB3)WZD~-eQ4&LRqgoQ};U<dfw7+E_
zw=O0Q7s1i8Tsk)P<l+WtHECc0+E6ZuTV5$X50_Z}dtn=KH8huyju*$$IdGwk|IME&
zeE_fAHkBp%^|ccnuzvsdTs`)H4(5~G<tNmKtavq5>AliE@fLaK=kRgcdyP-uvYbvy
zO}4n6lr9P`PKeLPPY8v&^u!4`#_wVAn#LC{HZ#^<$P~}6E?~V~OF=a{XvDug_XTF&
zFQ6T#JTLCvx0v6bFYiXv{fB~^>)~FX0k_WWg2C|v;|aP?Tk1i3K_grXh<#Z=aF`mv
zm3IOJxLv=eq6K|zy;~KouWxjM1XsVqo<V8A;iEoTCV!F*ZVcei@Mi3re?4*wH!v^k
zqBr;8{W)DrowwW5H*}bmgm8)TaSXx=c`sWBB%mb=Y&*^Eg~s_QJ|p<N97>qLJx;(e
z{$%T!|D0N+rQ7c>^9)eYBM_Okc2LR=Y8al<=6D$WDJuXBSH6!QcE!oKvx_jvT^tME
z+K3~x3cCI$vPGYql*ssbr{aXb8C^NkdTRh1kXKv;QG>G%#x?#0ut!8v@zIl0Afo?>
z16a}H<Jm!O7&`#iAcnX@mD+{;87)9n-~3gRPSQH-O@0AcW<-L7<vuzAwMa30ei!0m
zz)I%mX4V2P6$tm}!Ht!H_Aw+u=iSmi=OICA)Vkq7cXYla&}};4YY;gtcrO}z4bWE@
zoWih1l_x7Y3X&_;sFSWK08u3sT42T2=eTabs?lt7pT=r#iN;T&>xe&|!ekw&sXemw
z;BBcbxk_{UJQP8V?g58I-WOQd6{e+sFzi{U**tR#)=ZLrIqT?^vLBxQ46aaKGUioL
z6eht>q~sSX_$KW39rK?Qc3$xo9pDKTXMMt0HRRtja`f+%kZ!lwzRf#L!_A-GuT#Rm
z?R9$l*D1YD;h#qUD%AlA?4N=nwz04Wf{{^G0xNRSKc<5|>M5zI3ECuJY^~ah0xE;r
zhReUlSY>@(u+q@LQ?<+mSzf|~Xsby1JP}(!)RSwVjxxi*GkS3K(rXqH2p8vw?1bLg
zKHs2!2?t?@w)7pSp!_46{qPk}L2MvsCUn*#r!63=2S{$^n2k9I`wc0`)E!J*Rxw1N
z>~^8JDv8Q=rn(}wthIx(H^T$?3JX_{Eq7cq)AI<69YjnhS*#Z=<!=OpdV}xzaOiIz
zDMt?os|N*wBUu3`N#Y>`=V;MZ<nf8E1bJGZ(3>o$^qF(fJh1D4S2qvx);TW$8PI*`
zjEaA^)iXnNDqRywbY47FEui!q1e5<R8Ypqx_$54-a}P*uLGy;=vSGTb=GyDQTLgHt
zZfyJaF!uafH#iBMNnjHmNqtte7#`+#S^{sM(d?^(Q_%BJBjC^izHEr&98sQ~Px{se
z4UD<b8#l?$<;5Mq_Q9+tt5}PEzFUnFFhKxMee1u(4>Ujqmy!URO#Id!V1v?M)eA4M
zJ>92{78Ue7s({l<n*jQBNG8KVC8NqkqA`F&hQ}7f`J^fm4Z{tGNa~yCr#~LYeX85y
zFa!rCKM{MP1*(FC%S>=oz6Ds|*n6P?ZZ+V8VmUYGNiPa27TLpwRY4W>5di}(!8)jK
zOT`VW!2!xM-^=)%UuX|dr|Vzu{joo%pV-h(jO=(DIBXm;wyxaa&`5&&pGZgJq7Mv{
z^5jd6cy)~n0RmA$k<L;-R`!2Q6I4$=jS^D=_Hj+{cHC$ug%l_w0ffMhnt)zh6Lr9)
zO=LjT%oOl6x37~Vag#pXpP|$P>sQqZ;dN{5tWm3;FJ#gv*Aq*Xl@o0i*Y@Tg!s~$J
zF*nQ9+T%`vN1`3tR6?oy3GVco>^kw<Fe>?#V=8~X&v+ZQeBLE8`3nKi6`Zu~M7<Ae
zIsak?VPxhjxvHv$hlv@9sv-#^@q)6dpceP$8es=@MH(8JZVWCsV~VTJC}Ye4PO(Z`
zBtr30JRLcvNn|6U$bO}V0e`IY6jVgTeE=NhGqvvW1&g>&!n9oM8*|X&dhENEy*j~k
zw<S|Q19UKKE0N<n17cc#Jf0!qxO2s6TS%i45vB^ERbvk&ss}AC<$ESl2mD0;PU0gI
zVvlQGKN*QBXZIFPA_te*lF(DfuTN1disAGXkYPvE8<2=;@V3(kGpz>vFfJEw?RUm@
zL)$CT+E^<;Ul*czF4glFG$i+YgHfoV30f{Dg^2y7NwQf!Fv=`+kOg=>_ve2R{NlId
zG`p7i^R)T(_0s94^tPZwfvy^~e*VSyz(ZydbDVhz8>)l&uKx|kf;e#}AbryqPiu$q
z>Jw3gE}CKA@ho@CEko1hxyCm+o0ksai@5xcUz3qP|8$9bb$cPgepU<eg7T|>32bcb
zZ7H~x*9RjaVo;QKdf{}l)NH0=vO~F)%$U*8Olt9Z_{A+Eut&z#I7C5w<;broh4Cog
zPGOfl<$97j4W11V5g*_W^^-FeG#S9k=|l$7mOz?i!s%61C_JWTJ+(4|4sxmR#?HkJ
zby28AH?Zv`tyy+<%>jZ>LSs5~Gm2SF#9i-8Mx!EGJtzG!=&Pysig}7EkI{z#Amilb
zCZQmJ1;-ZHZWHwKj^swG-8$fF6hrPs{KY+-)ys3l%7+wONa;T%YDNoilXEszop)mL
z6?p~RaEh?`KJY^smjAX_*lFlq*Yrju>eTiKl@It%i7jB`qfITe(vlm0jQqb@05rE{
z!j+(g*_>di6?MpZHGkrIzOd~1<%|&nVBsU;9rElN(=(lNfC-tzUM*o_F1*yjA7Uu+
z$_*h7E^M^u+eWQh+(Wy)WAB+j91S*g;!^snfwWkHf9^A1zxtu3z}kPaKjsa0fKLkw
zn-%Y;*v}+%r&F5l<gwxpGjwk6K><1xz_ga0*AK6PngVKXYOd5s`?FEE)lww|vmc-V
zkNHL5&0m4K03QX&YAIB^*^teSw>8%-&<EY=^1IB_aIPnmO+Bc2*zyhPkeGN0iomzh
zWOf$4c<ng#Pu}X62_QY?eT*D(>~6*TI;q^4$=laKCwiDFXJD81a#1uLCz|acXvuOz
z)k4l%x8CyxC$nMhfTHSP4w=N1yIVqN%&MfXdrjjXC*qmaV>=A2U+J#naT4wk9e>pn
zN2x=@jAB?7Jvfj(9u`@8HVRNna9sLBrEns&aVcPYAH6u`HtEpvkPBVibE@vYxY$5H
zz|J0}qn7&DtP8bVLDFsMV}hriN4vOKLr#1VSa}k#Ev}w?jI-xOsj@r2GlW<Hy7jgN
zAio*ol{l43w=N%~ArwnMq{oJuZefw<_NXN%WAr$RFQZGN1ycID4c}k(2Ln?@W&?-$
z2H(@*t^y+?ndJOpyfHX?tD(<vpq-z)tbV~Pe7uM@Udal5Qhyk;{=bo;8o;OFv-xQK
z^(_m}UltxKOOH_3)ZDaW<u_hpJ>Ea`gL(6Q6}%A9A4Z&m{DCB|FM!=u!Jg?=BfhQ|
z=(H8wN8}KQ1nx-*z|7wvO4dU~cjVFkV%1Ck9=ToF=s~Ho`@U<V1YXSI;GV6k`l2N}
zP7jcw=<EWG@P1l<;|jYE<e+OOD%DD6d0um<-_Xv6o>H1Le09&D50(WAC_GL_fNonS
zp5!*zfqBNV^-8D$|D)kUZt8i5h5UfCtKsDu){NFremD5Nv?4MYo0qQT)eX)mRd@z9
zOky;VVj{eWyZg<;j32`Ta&ZjVt!4ow0|!8YTaLS-`j>zklCS@1^uGO%Mo+gIlw=ak
z&=a|1?F~f7fg3mwExV;VF2_S)N7A?+PK0d(RGfo!5R0G=iy_rve3#`CJ<-U1(I3Eq
z>CbLtY(R2!YC9Z7l)<Cn`_ZHlSkw8>5sFbI>Rk&kk__>6BX=@<4|BuGB>D6j0f?8#
z_$qm~U(X4Gwt}%;;0%t15-lNxQop0K?Xm5T4y4tFK2X|YJt%@=jiJaud}7;;mkO5k
zrq*CRZs6y#net9k`k-;6I3naxP<dxEfJ@G#>mez<6N9r^)a|MF6-|&98toe*Py?bR
z<%uAL)G_A&j%m_h(O9@|@O~&KkMnhE2a+>@VZhR=Sd*gQ2)G*SToE<UHTLe>uUs$9
z4PCNbJO{|)^P=LYyFnT&yN5Sm1@sh<Ck|Rap%)@UZ*f3xbh-ylHjBg%FvMOwC%(cg
zX^=brMQRUTO>1?*LWtz(C5n~@maA?3%t*rv*L$(rtLIOY!@y=Pn3f1y0xH9T3++R<
z2fc<O3|c{aLoi_Zzf8-YDI9VKLN|f12$zd8$0_A$=Mhhlal3Gj0Cd8-Ei2oYnb4rh
zbo5C}ITz7Dox0;`ln@y@YGD~&nrMNQx#J4i!XCl1g9pA+vNtVQahfIbi^f9g62Kgy
zTjHplof0~8)s!@Xq+)kiLMLDzE6Fuon{*uuJ31o_V7=ekC<sedQHO@~7jE(=0E!JP
zCmJITd%R%)sCA9MfW^I#q&f$SlERtx|4m6DZ`&dfrmnj*x`_8oq=Xo-bB;sbe`z#%
zv0Uwqj9VJm)UqfSD_a2WdKjsI^XQ;<#xC|#dUu`xcf4di*<{@el>*IqO$3p38ia;9
z#7+D5+2jnsF%htYcdF~6tD@<=b7KF8rnhit^6}ok?~MipBt#^Y8mM&V6p)Y(5kW$v
zB&BO?AT1>!-ICIcG}1Y`OJX41F$T}xpYQMa8}2ygT<3LNM_sTE<Q!l*_Lk`AT6He+
zwgQs^y=U??-mmT?RcGFlDd{;_7?;te8Fv06ED}7m^@jt}(;K{D9(n4>WP7(>l^k20
zN96Hs*mBnkW)~=}(&mg|0vuTBCPA5$TK6y)w7+=uZ(IpX>MckO2H9Bgi+$61pRkEy
z6rpYxGjSNAsr-<JK&|-T%Jh*t5_5gF#6$Dv@n&BCbyy(e@bzPo?C?{d@f9^K;ukJZ
ztMoqlIEo@<3^#I3D8I9zs)b?&Co%Tb=9uM)@Ru%<ME7cAVTpMm?N2bf(Ng7CF~kjc
zU-o0lp-z$4p0paMtGp$V&oa~f{A%7CpZ8`PldhW@(@T(1*!D_bdNy)KA{kEz#_9m#
zTKug8czzTqq{ePkA9mI24$(oHr0<M?>YSBl)ViPs?IPsyBz@*1=RWbZ_baT-#S_<P
zrh{uQB>aWfQq3CoeW-B>d;?^Ko2nk`Q5$qz$z`*CH&fN-`9tm*h=}o=_<?TIRdmdT
za$9(2w?g*7J1k8`3icI(zwm8Q?4aFwb>61qrVq#4%z8XXXZ!J691h;Xh<xsX0bi7_
zo3gk~0qHrZP(fS>kF-(REs;qxg^<YGt#7C5Ho@6YBfsaO_|FgfNOR%+q^f4Y*AJQ>
z^oqU(9?vN3WJF1&#UXfXS{bs}=URU@`vUKG0BRlJ1xkj^j~prD(u-MmmTakR)8?Xe
z&h{kKhEfBray<Sd{*7A4gIGgd|L5^0Ad6fR^wxAXr^q(ljS>3%`>sfxOte)sK9Hsy
zd#`3^p%t|=)6A;DV6$AD8}nMPaoz||bWZ%sdD(PpdL3qbx7<D^^V3BcbbS9-s6|lr
z=`-a?5yewnB-2c5?G61S6FWBRw^z5gp`AVIipW>A-rm7KB_vu+NjUMjQbHO%oCcSY
zY77SI=vXH7BTmb`wXgYwKQOnsA4wIFj#YZU`p_sq#({_Q2}%RXy>D!%hySF^Xyu0O
zJCGsNRL%bE<*Y+Y^!7YLA|ha@U>|JUT%tbM%D8R#VZn*r6uoT)&$@vuwv~#o+%tZ>
zaF7qTy6b?g_?y$<DZU%gpj~4Rbu(q^Bfk()bsHo`Do5Xo%}g<EbvC0eh#HghZq4!-
zx~;;cGKvKk&vW=!-{0FXJz@8*DLnbP98~VC3)<d9Uxp~YTE-Ab(4Z?3$=Pj^oWnu0
z4(3aiOUzjgb9zrWe}7`UE0(i4M^#%^;z08?7KIyui4@P1INTG-u({9bJZ|pfl}2cO
zSQL$kA@L;`cr!SuTI3}b+F4x2N@0`H9EC|?X@3zFmFL^x^C;7a7`PoO%d^Y=ve6#7
z2bY*VV)Nocl<hQQfwt7XJFL9elkP^{h#mC$U2R{099St9SSy|niW~nteq;L0w|#-l
zPwWa0xBB{Nfm|%J=bAR+Ed`PkzODOFl%2L;6TujT5&m~OnTGTK`llA`OLajV^i^(A
z^F}flFY<&7`+}Gbqm}prd!k@nUT)gZXRpX}jq3{kX+7Nx;CUACLS0KSnpmyG@VoM3
z<wq}H{P1)<a=!WY7J_36V%vA9ocbP6c{=N_nn)T?HruLov`uuvlue;hGx&kEtOr!O
z-6JCH20iO=K>Sl4+%9{56f}J$E{qbzNTL>lNbVNx5~ge5UFna@WtBP(ak<H$HW?yw
z*UC;(5rXwahV_$P4)iC#rz8$H(yyL|Xqgc78tKEBfF!xu`?&J9*<pX*Jx+MC`Gw;5
z+g6o%*oQ0k8<QE3vWbleN5J87A^+;^t;8%{6Hl6;HsRFs=ltmvmLk4!8D$?SOW#v?
zw)ddAj7~qUdk89WL@AM|ykANC>?gwp*c~9i59b#CR$H@=vwNOIHk?nwd;F?`{-kQv
zyFC+eDf^UiCRKfZ8vZA0e8sdG6<9}#`8znWdPwWxVl;PfaQEkM{&!g;(-z$Q;)*1g
z=~f<<#&i1{jdwn`yX@C5)kb!OA{)GhV`TCUxAfL>xbw@5ssNXZH#|q3uJ%ornC7n#
zdaNwvy?2zCt_p04OdiJ`{2$L|`{KVoh!h%o6tD&*RuO=#0I#&NhxO)isKn^zd=}&I
zplCmWSS5j0QM-;f0-N0uN<~rL5s0}_0pnfa??K#4hNiUG^GCK(G{&ZXC_lM_i2yjF
zlQSo#Bv)-)-LDfR)+-L30{ih(rN4bE%8uASVIl*BI2E{h#-s0g@T6bkWiA3C%IA4X
zzE)s=yR3Wq8YcJhwcn64z5M;KeJsI$#Qu-r?1QjZ{WMB#l|f>crX;}Q-iq)!M+Ix~
zdznI*TZ;boPXyNDJ5>54nGtCNfAPCGB?EJAri?8$Jy;4Z$v2c@1aNEXi5;AF@f>%R
zo*dRH8$N5hc){k7+vzXP)-hGKzUq&l(dBnR2$jY|FXk*69M`3x+{Ddn;B?*g;oltB
zOg)(^0(g^)QcH*OhWFRE8FJ|WFg^UhjLO!)wd&&QoazM%+`qXf%lY>JY?eTfX?JH!
z!&x)ka8S_xo<Q_7mDbF6t--yr++D)N-m3<-VRem%%7z3QcyWe(^ahCYQ5k9ofzxU@
zE)Ah#BxSVmwNKI*Tt}jS5zJh_5{d&2Zp?)#FmMcCL=Yf0eL&)WU6t8!P6@Z7UzO#B
z-L3#Up1sp6{w$E8RS&gVjmNQC;-O$RpzC%7*HK#Gp~k0t|4tREcs<T_Uovvs)0v41
zz{;nf?}})SprCw%z~it#bomQE?i%D@@h6ST!z8M;npe<U(27%OFAB&MfP|L7LIgf2
z$H580W3*@imt=G`aWofRch7QG=Y7QuW8BVkvXq^wK_$q=Y24Cqik|Btjklq1YJpU)
z;tqtg5U%E&#)Y@NKrn&v2ww3#Lq8%uCjlh3!*LQB_r_X*4zggd7>&d{&9czGr`ZHh
zDRH30XYcvLQ<<%bQw)yaN~97R0e>w457l`760EC)W^^3Xz*-Sw{Qbj*wckdGYtJ5(
ztBgh^ygd?m`+4&U9s}`zrIWPAG>%O{(43Ib9Js()yPS}bfa&!6_}b1**!Dipx}4?8
zybR^PZO7*te+{_M1L9^KI=sDAjMTM2VKRU`L7<J_eE&DI3mXu}G1LJg)Si!Jw1&_w
z^W}PJz8%VP`e6Do2tzx*_W2}eoJXUL;B@r*@%e=6z5-|T_cnj7pE==jZK+pwn=G4@
z*I&B-T!&%)7MGoVJSTi_?BM(LFB#G6k{5AoWE#mFD{Q$}OE?k`dB@$Ud;N<cQV)OX
zyyM+@SWWBdH|gQL_dH(IR}ZynWOH9KWkwZeXmyy0rY7b0IWJ;cmGiPvP153nW-g(t
zX8hu$IM2q+jxi6IkYB`MKa>8O)1)whxmM+F?SnDdb(#D~quW9*XzSPPMzA?_jS9-(
zmQz!gL{nE@S2Z)QtnzDqI}?X-*+{UenDU$TgnfkoW0W>%Zcb{ri4Wtqc|XoNX}Ma)
zTZJuDHU%k<M~j$ih+=@UyU8h8V$&9bmCNHW?)_^qYeI_II>$dKatj>&D&NP35$Dfl
zRgxsMy6hsYHlm54r3_pvINq|MneGV{EcKB=(DZCi#is>v{%4MHhxFbadns|DfZOMm
z5uD>)_Y3XfUwYNcLC>H~v_P_(NptdTTSb1}d%Q*?DPL$MA8$pREmmbh?o}2t#dzRt
z`QD=!z&z=XW?j!s_N0JqTaqaioXV?glE!ntu328VMS?P8iF8;pOqe7GQY?9X?LN)y
z^go5r+|H*iwlXfFe7^&d<#4<SB8xnwaQO!(EazpcPNciW1`K#xk^Hq#xN>+ROQ|#2
ze4$Eqkt*11x!@m;+g(VS%T&uz93#BlnD3&J;81gxg`DUedSK4Tzx1lPO2(uKv^C@#
z%{R&n%+~@|b42sMG$zD(0PKe<NJOG!+j8Hp8jlM9N<#P>qx8LSa&(~nCVEo0lp5Z*
zc86CWTd5n-AYB~rXJm_M;b7*$dDyu^oRywDB*M}%)#MjoTY{nXW*am*e?SewqD{Y!
zb^Zob-Br8sqD#);jOBN`I)q}bP8A7OcNLi;p=ZKh{9Q{v{5>hQd7HFUYBTJ;cjHu5
zHIl~08G#!aoUBl%1Nub(<%pSC0#JB2ENb534{Kt+8g@<28?OeNGNobqDkz-?>4dHm
za71$k?Leqnu}Xw<JE3DKc1R(j^2JkwQB=j-p94R28<Y{J^6~cGdcIRtSal64uKx6s
zhu^t8p3m81VbCp4iA=3ONj_GP9u}wDE39y7#0aVVeHr`3c&67t{(7~us47Yzz148R
ze#{pPZwp!bxqwTr`$}Nv<}uN+GHdUxU+d?nB1zk0uiy6}0W3P?8RluNI41qKg{O^N
zjz~DEx=PxWK2Uvqg=M@nFUs~8>x&oHeTOku7QoghMpEpCk8!tduzv6Vx|UZjC`pOF
z5jjV6GVgIjF*(E%YV%2mjeS1kQ95F*E4AMHq>9I8Nz6FY4@}=yntW6))?a2HO}(%@
z!cpNUM=PzUT1lBUk9xhTboTo!d7gDP51!VxIHP0RL~>k7Uws#GM^msaV?`ZHo_)$h
zY4*EA&$`tPxcmIZ7;rjyPV<L)rL+i;y1ss26W@Zb7f(|6ewnVPvGk1LQcJx=DyqOb
zXx-m{we)lP@SJNZu`TPUP}AkmJCp$H<K^FUHAMQ}tdCK``l!$x$SCs>{~ZIqrNL{C
zc=_g#*v|Z~7H&it6kz-mdIcgq>Mr4ekOwMHhI3V37MY&1&hWU3#fqrEHyHyvl;bUt
z1F!_z*K~dD!E~uw@47uj559=B|3N(0jz1CRmpj|K{ScdYLNos9sZFLdW%GH9{_Vh>
zwbrx@Gw;JHIu%uyee^C$B4eAO_e%btX+h-P?XHp1g%ZknfBrYe)D;G4gEo*JIG@MJ
zp(4KWoP9pbNxL9}+iul($F1%>lKdg{8$H#YL9ZTsdh8d=?w9VBR9W4c!+HYOX5S;D
z{Q0wdWGc!@dTKfEdWbfE?YZE!_r?8T%8SxdEKi4Un>$y%lK^EdpE4x+-2HDCX=&|;
z<@regI|kJ_<M7;}iF=6E!D{`~P!0b{%Sod?i#3_lgg7c;NZAk4Dhuo&ge%{xCCeri
zT=Lz$5v77yZbyq)N41}Otj5QY`SF%ykJ3PVv?z8zrHo}jeC)xhg`G{WduMYx-`}Po
zxQTVa-c9CoNZ2)j8V6MUKHtkyOceJah}XmJyN*trAyZDG_&qnS%$DO^gmy8^ph(4!
zXZq+DMWSdHm5J=tM{8PnVJe|WQk%FE`H1^x#qS&JizM}E4dU(f#8$Jkw`E=k^Cf7%
z-T}V{ziWjaJu=T)JfQN>4((-3d@lbUgw!fcI~$kg1|r4{!f?l(nta*h!THq<0FS|3
z6ONVA6WvG&l21O$+aI7yA3(H_uqIWY+D?X(lQSAa3xz;ofbQs9JY=a{-@I0uQ^$Sn
zwRD|hTyM?qpUJJn-!QKpGmjwmSUXnKA9(bvdZM}Q2t`}2+-vA^pZJYGxNKOF1=T$O
ztT^MCP%lib$peoK6++d_MkpsRG{7Fj(;W0LSMmFcig8_QV+wD6p!(#2|1enHws8GD
z2j9!J5gb6)e}n_94rZSPAoz%Fy`_^VyVL@P?p)vnIsVyHrS`w;FUE+wu9UyN2ULim
zr)yFcc^Z>PHH1buQ%tez$h$*qTz}vfH}v}gm}ZNCa==4+cd99$is(>K7OMrsJdr5*
zUFz7>%N2`X+&yV|Kh2o^|545qk!5a0kH|p3Ki6yfu>~OOmMlvFN7ywPRp!aUGv)6F
zz_qx*J?NjD1IPn1@>LFK+UqCB-I9J7{{HaaaLDn$aDtKFcf{NmH^*yom~J9w2@~hG
z&d<S!hj>({-kE`GX<wk*w9u4$ZFb%BI9I`b*#l{=%Z)+@kzbY`2_Y8lcjEZG$ou#3
z((48`Oz)y>o$k84aFCW0w@s02Rl}(JhLsy~^mV{>nz0b#wUq<n`XT?ZSYONK+IZd~
z<I0fDCIuMdI-t+6uumlD&LB=^ZfntH`vg&xSIbZ!L<ao96|MWWNwjhd>I1-;Ymj{+
z1ZkF)o8l{ZP&qpp!0>?_*uy=n@m;UW1%@s%J*v8|H+tYG0Ez3g#171TFrJ5ye}?6z
zk)qqEI0=a%*i#jBj=N+c?TRNhVP|K;ex{(pB`!yqi=5KVf>O-E<wF>;VOL_Tb@0RZ
zM@|T4G9exiMda<H{N}&I!D||STL&e5UO!X8vg|?I!%U}jfsb~CiKxhYW3o54se`Zg
zOm)dcK~z=Du_Vc+-u1v~zuvdEPlj<k^g7g*+tl3K#V=TwuFl$;qlZTZ{3UbdHi}Nk
zQ->01ce`sYG^9%ylk$PEB0!_v$dyty?vMg2d!6&0u=YoX9BTo4F>9R-K0|aqBgAO>
zc(+Y&HQ)i0nen=!i5UK1n7*USu>a9egjAacFrnRcX<ub@ELja#YVEm>VyI#cv_9v#
zfN#~A(Mt%jOPp%=kg7r|?0QKV7!Xs`K)%tauY}3X{o+3m4&v0o@|FS}7;u!1fr}G`
zl-V0^fFc11!R3Tk?p0Ph#^>_cUKsIlM}Cnb1@Cuum>t>1vN34s3bv_D!KAqI{i6$Y
z?vdpPXg{Yy?c-d?xd9vwe2R<>c@}*|9_`u4^Pp}XF0M|Gom8ywL(nx<@E13)z=z{B
z7iHl4FQV~HuK(UnJ{DqE4h(CE+8jIu+X$mF>rD&W7?<|xqV{}mLtth#KH-aG_h4_?
z=MF=SPHTJurCW*El#;WH)F_NUI&mSMiYQqz5WW|#U@~|fN0>}W!ED2tO%Eh1wbPYw
zFmeOUE8#sH2BhUv1ld;_Z%HeS6WOxXrXJVQ6FKg%mYe(i{AG9Z=<$d#_q#wxxZCpZ
zi8`=)^7bgL4El2*r<0rNo8FzcdKa;YDx%@$<jDWmRB6nzzpJepTAf0Y@%EI${3^@s
zAucPz>!HlZNBk77GS6?gOHU-`^zZ03uBYw;FWCUiP&p!)F0ge;Y_hyuuLdl3n^9aF
z0chap!EdDW^^~yyM6^z2wN4d!lRb;4Ayu>{1D?_gjLIFMv3;5<6P#g_Z<Rh?8vigX
z64+L@ZT^z>O*Gqo<YES1)axHXI4+pp(~Geox4xa$MeMT$MDVLc&Sj~6#3%Z}#8&>R
zDbFwCUw!xcVT--az&DRh828h<VWQi0p<9981{QamCoIGmAqvgsfT|2rFlKX~WrHV`
zEDMNQMz!<IM6rh0kZtd?jO@fE)T9JOU0j2#riU4ZM$AA~yCQy(W;M$}bX$Yd??(=4
zVnkamX?KJ%{dILC(is7H^oOj}fW7Yz3z&&L2*I66kM_YC2vUas8Z<WbF~Fnh{+6N}
zTViFO?L-NtJ%UJY1Sg{k!;!{UUES^P+<zz?ZV}|hGh0(STtlr>$^%-jREtka$8HmE
z{#Xj%ncpED?hNz%zwac}7cav{G!bq+N4lV`(P_P+7mgGxDVk<R)7;+Z-v@OU4;n*m
zUDtTRX(;}Dj?(2U{8U@mtAFw|{N+Y9ZGe}KSV@FNR~1u%OIW621krNB>o@?8#<~N$
zDs<#^;_<2V&b88b$!%lWpiR5pvkpa~?aQ(=;W|!7T74zD#YyMCv<kM3F4z11E91QT
z4?VsD)!bcQlpAR#aa<Y)f-tc*Ip<J)6eTz08R2WPiv!`WIVay9w%U@16TT=(o*lV!
zk8Sa!p^nzSx0op8>y7V-vR(K(!y<lnI{fP(0jA!lHwqiON=2t<nYB1J4Wq98jM1a3
zYxkS?YnPD+!7am5By*OB5wbj<%PY&?Or4Hv>eAAVhO%Ot<akL6t%-Z^o8UsbVoHQ0
zUyC%jquF~OH6r>C+l0_<F<gsbn~<y&A+gE-i9sdy|1}|uSYDd4Jp}SON?^bOpKZ%r
zXFp~XC_Ij1{JUQyS8H8CRKk?}(Vi)oJkk|}>=i9cT`!k9e(N6MtY(j0EeRukO5x9&
zUB)K><x%0D2H=>n$R`ftRM;(46EK(!RzS)5>QMYRwj-i%9>^G(1N<%3{n!wts5q<F
z=10{>lVm<k^oYEl{B3L7fFPPw`8(csePzB)n$p<jsGQk9^)gxaY$zvDW)VkNGQDj<
zG$SeuSFIsW04HD1Eg+lfLd>L+J_{G=4Ac^5N+^GUe&&WE{_fe5>&k$TtyDv+PsV9L
zm)3}e8XnGeB{a$xj9_zgM-*k`IQDrnFZ%Gs@oqS7ct5wYYel`l$^1gBjAhO1MXG}M
zTUVMPATu%~VZ;-1js6kWeWm;Fe){ynUX~b;|8nIfbwv(*mHbMug@?d}jtA8gd9rIn
zqn*Xt)culv;UFXbGC&pej?}J)1mj=8JZk@bkRVDu0zrxV%4yp?Iq#Yu5#k{BAv>xh
z)vuqZDYr-g$p^IaqM8!nB#76e+!1s7?L=~AGVE<|j~`=2IXdyIZ7hNGV&yq)eMUg2
zIJ5UjF`?@>iUsIFS98p4c7TiDS_bcr4r{72gs_$XYisOt>NZ2iNmsUK9KakIpjt3~
zSro2KwZsT6Z@?-h2gYcC@Fg*Fd0!y1f`zbN6$escgc1X}fRLV?uidd3CjgQ|bb;v>
zfC4~C^n_T|uiw3aj0sE}Uom2VmCio{C>}r&afHEs>YOvbn24Fv?u%m%rT3m>DxRRN
zoo@ow7GUFvs0dA*-VX@PHod0JxYWBNr2h_2ql3M~5WhOl&j_Li%!O|it9O(_8}t^g
z3V-BG@P~DxFDltv4RE^K#tE2Xv&%R%>EC4G)8<9>%W!0*Vp^FHks6#Pji078qiX>d
zZ*s&ij0Z@rsi$=Ywj6$jj|)oNVUayvYB;ti+}@ajR|-sP6Pap!8Tg*K6F<6_cA{%!
zgx&6xc<UJ$I}5jmT*X)TqHVf4+VoRCrBZ^m5(!wBQkR_771KYjC-DG7!s%~JZ;L&*
zo$UCe|F^c0n9n+buX@(I2l!c1Hd<$j{XXfT2DTFB|M0va+)e9{Xk|R*?vmb_{i3-m
znyFjTIH;{3_fJT@0a}T!&_qS}1j-R2>cuz%i8SO^-ypK78u}Vd&RrPidgKZYnen!E
z28z)rPDdlB)cR?&Hxl`pKYw(r6YS0^HqBi=?Bd%zC`usKV+||i^5f6MRVG-Gitdo=
z6U>+9_GH}uZ83eP=HCaS=)m{8jqEtV;?NM<x}ZJe@UnsiqO=A<TE3i()h-Nyxtd0!
zR<KLivRnlTUYv22o9UwD^;IuDjx{%2`cF$}07s1B8wv9hdWoGxsmXgQ7PxGE=O+vl
zaTS&q+YY;A4`q5H87F<|w#Wq7AB*$l8iN!;suzIbGn{w|FR7w=-y-CpF7aJ^MIWbM
zEan%NU_EuT*V<7r=9i=^VpXX~?|H6jm|O|%wMGDL1v~n+uH)EU#N)6wwwNa3nNxy-
z>L2<&#xc-&iSchzC-_Q|vbxx_p&bHdGD+R7(6jrk;MDWg)cmM^`YbuZjE_STb+o~V
z9`&h;iXf1cUmwt@+_tcwEze;o`PsLY=wUdj=3+)6n)eEKMdTN5tuWfMZF6VWdHsS{
z`KFe5oYhx*yW7)BW`gX!06`0QW2yJKba2$$!F#^ntSOjm2;`laTIKBtSN^3=kjVVr
zVMb?naoTdR9mXhb>HOW^gB!~4ius7zdl%2c#P|HTyaw?y&A<RCQxm%Q&qn=<Ub0P<
z^GfsfLwxmC)rGKTCpR<elGaN+Mk51G)~_+X$#ScL)DE~VGFKmzUa*oEYk^eTtm(VX
zz|_W%+>@7$EDl;7+fg?kPj5Gt;HYo6H6W{)W(9f<<%iUl((YezBQF%)LcEXO2&u@D
z(>2Zsyj4#r*Yfgh^DX&U$;u{Zh`03}m%%H|asu<q`zO|?xsO`NC}YBIPBQX!&S;q~
zbct-Sg?%AN>>|HPO-^wushv?dw;(kzrZs>`m<-%KaC_Sw4Bjt9=si!C3|muYT5}Hz
z82o3f*!il#?LdMPS#@Cxn$}+3n_B*PI%0U<^P{AEWzfc+%ymAZlXmL9!An!`Y2qYF
z^SikZB1@;@*o}?a-C;xBYPQ28s|0JxT&K4n86ObRr_8{*$h|yW%2~d(6M5~a3wWKL
zot<K|50rV%Z5MXtx?0Yv-Nk$#urWeLmDZS7*u|w-l8EV^^ojGpujxZmdy00al%9|F
zKi<6*8#!JM6{-dVznFDxsvq*yC5I5Mv`Tm+3gCTIp}x8%Uyj~e?^2&0WJ-!HYBZDF
zOXX-y`Oi?l)cw$d1vpi3cAs}Twvm;*w;|r@n%w{4I!({=Zl@(GHDWkrx7{=HnCebs
zo+@VOc~YkWJojdmBd%TF%sE9^wVf~dC^dH5x7`{wfniZ!$hk-th3{cn(1W+_Esw7w
zmzZpy-D7C;+`gShTcPT|2D_8G{yQ+bF+X^BJ@XCjPHJ(-aQO=_voE@o#`%-HH18~d
zO!6P&+wto2T0&p5@Z<d|s4L2<86JF~b--gOGwzn_IhH-gw!z!CbWX{eENKKMQ31B5
zmp5Y_QvVkbkow<BWdxMTX}x~*prCg!IX-1tm0jMkSU<r1wRtSF(%B;kW@r*rna-SF
zlgd})bOs(4)8XgYqTcqmmy>gQj{d-lC;7h!0LT9#0QheDqgaHW=L&!?r|o&)7D3i;
z>mA-$F=j=JvKEWqeDO(=LU^4CfF>Y%fCdUwkOnl-eP+Dbst2sdXwMn9x|laU=geSC
zC+JxCI6F=x(t{NPLgbn^ahWTc{GRRzv$=B8eJH($AM@MtBAFozE)KkJd?ox{YwTXv
zS9W?!>DQdkexm)tel*M6aIf^tE*B>q`_9^8d_&fv8<H`?clRZ^$&T;&_!PK^|I0uK
zi~x9e!%e=x^)Xv(4<0n7A|m$at9w=xu!a3ZxoS{gq#8mYw++@HOF_hCaRA^&=8U6g
zn<nLEl>&g&f*(M11r3<9&63JN&t4t~B8(H@&~ZAIPo20QqJG5*j)O#$eA0lQB*l@%
z$9;|QJk`E61l}u;{F)X;09Ihk)z~-Slm)9kK%)f8eXp=v4QM1W@*Zj9v!=%fO?;n$
z2D*2zJYgW_?3bBx{fqj*M#5qpH>8&QC12U+WHx0p=|Z4euyLuUy?Znun4*FT8)@XI
zlKL|+`JI!r{ab0ZtV=~UN}ZE`GnH4Vv5;)BF-qLwe8&9=!<pyC7g_wy0bs$CWIQW&
zpgP550xuI}W)Dxxt1jo;=po3f{>IhBC78;#Tg+P2&DW+o&W;icCK_l@@mSSctI}JV
zko4)!{m<VWv^~U>pod5YkT|N=#)c2qX{j|FK~^uLNukcTzzgUXLInPgaG-MdIZm}9
zOZI6PVCARyw(wnUnkE;i7odv0Nnw646L&*Inc}Q0j*i^1pmSso)~ewminj5%#tQV4
zAEs^bQlNcrFB|TvpuM-akUFhSWg4tWZuU(l9RtGt640tx9>dnIrH8<KsJDr@9Y5e)
zHwBpJUuIyO<n9faJzP@Qqr235i6lm6?=s<y<Nr(qg_B-Z=-n}Ag`yjcf$h{haN92+
z^Xm%|D9NX#XVD?vjDTv#^kcx~9p+d8bcqL8#k7jk>NFpDJOoPY|2;V(kJqIjlZE&w
z#Lf*=Iou=Im6k4seUj@7i{qD(eA<mI<l20m$|=*`F@<;tDftd=<sGfe^nvmyJBAYm
z^OOREs?hPU$7ta2h@&NeZ<G){vzyMD*?C6=h|9bN=KO5|<lc+8TTnrU`!nOh5~^jN
zW}up@)k<>Nn*`W;3b@E<sP%vlk%@xLEjUmd;@c%M=)f@krvsf={lF(49)Qm@Lk5#B
z7x80RW$|T&L{~GOPO;YajY8F4hJ3gOJ;uiIRR(}$SUCw>>%>~v%Cz|`Bi0G92UUFs
z4B&BE6Y4!vhYu7DS3^4A#bxj8-j~#*s7%;Y9AwPRW-y-d#41UyQO^2}eVA1A$q)$1
za_xCzn$k9fliBmBwc);VRt6(wa-P=g<9Nn*BWxzfr%9G;h)!BL?}sR#x1;H5mSND-
z`KUq<^1~#$47qZGe->*@-Vh{?omYX??-(B;;MB$#)w6?YK-$&!rf^%6UF;?i0VS@k
zE{)cX9~ygKNMNKsPR&>X{OYZ(CX{J;&4k0zTh+G`GKI-}&hDcs-wzoiVq}bVZXWnr
zTBeaTydtx_I&dWYMznj&LzsLQwWB;}ljs%y*+F#6XB0c^Tw{`M+{VBMY9viBu}5<+
z^;PpZ)yV9uxsM%}-5&$6R|u7rVkNbdwzDXe&wFO{<i?3Jrxfk)P?Y<q#RDw9Dy7KK
zXl%wap@t%c$UY*tx!%6fXZxCKBwAoHW=&h?C$1oVawrRb<kgoSOuC*vi=5tazK$o0
zFFS6}o4wh~V0XV$&^EXmswNSu%;&uF>lpcOG&>wYJA<Kjo(FsD{r~eqPtSv~M&b>i
znx=l1sq08o#%5~DLe+oFv}W;s?8xRIcP{_4`_E&cgPmgn7JkVJI-=PV=parD_aV%g
zY*hw<R(qQSPKH;ri1)o^VURBY-IxD<-J{-YIcc9>#^3yw@6+f1Yxz`&#7jzk_E}x9
zbB0K(k0H56SdivqQf;nm+49rqZ%@aj$bbn1*c^<br7yW>8b6LpnknfCqb;HK!?}|z
z&+Vo1Xrmsyx>9xO)AR{E<5#>*{QDM!=N=cWEK86V7Bzh!0%D#g^cz$3*Rljgzr-;9
zWT!rjE>u@SOZo}W73_*O1zot&2LyzbD;ej=t>h}Nei(i5nVL)Ycl<%De~K}&eH?kM
zpC#3TxSypu#P%kXQ$RLz^E@A-nnPNP-V<g%FvtTIn`h@95C^cE+z;U<pX)$sFHrjT
zgzAvjSKIvyroR40mGmYbOowBF3WnqZKjyUB!J1pC`2+>OIlgcKm}(qoMjrhPdi}8K
zrHLR>;v>-+0R_k=DWv$GPjUX>E(B@}LgeY>DIc2yd?;Q2cf{`zi3Etm$0;0csG*C3
z(@PGu?W0d-^`{;gWuMluKlr5w9;XL;pa;Jg{z>H~`MGVu`DP-u5Tsi1S(OIW#Ge-_
zMlehjBZ~*R);bEaf8ga&$1j%O5Uo|kZ3dI&cyhD^94{#k8n(Xv=+^wX7B2fed@Qhw
zzZR!cgRV6S9KC%(W7jwmXywlJS~C0e#FH4w4ZOhH>fr%p<^m-x=;JHb%iR%Q*wvSh
zQo`)D2(6?1H^Lg^zZjjEh&PX#!^8%~L7<+hHGkDNkoLgA>U=9dN6s1JTGoSEy_H*Y
z$&+p<Ahy8y<at*=$YcOBOamtchwEzVZQJkP@j``elrFq2b@(OmMO9lHRQep%5v&o9
ziZpR0r&|=W<tF&Mf(Zb52p8jo-QP&LZ`6)t75j5-*xV9*+_hy+;M)JByVtM#x#KHx
zIw&@HHZIL-WLdKyu5#RTN5y<#6)k=~eXxs_V&D8vilt4Jc_*Wo>4DUYiyIQNbvKfH
za!5>!q^V3<nmTK<p88K}9j3eDcMGME#e?P`|4rV6fvfQ{(Ny^uB_EO*N@eEe3c05w
zp^&InbEc|3Dbz%;8z=d%gn45Z32N^rWQPY6P8|z3UQ_-FX9^N|T2{$TWQT&(Zh-Ai
zwTv0q#P`vumwo*Io34sX)@HJbZHn_NWeLz#RrU%f3XAhnV5^NYUU9}@*zGo*C~<=C
zoHx{*?BIKGWOG(<kHRa7NxgjC?M>|d_?^5dsHPZhejfY8B=f;;-Rjvq-oV}kObAbF
zju*WwMm!g6%WI^&@p)cmO=t35WJ-;C2Rqcn;lgN={gvtn<<6T+)im@6Sy*|b-D5(}
zq0?X`r>jWS^I(R!q(WXDb2wf(-$S%rrVMb7udZ@L!wJp6R*X&WSDIXuAS)15!RNHc
zSo~t(ZM2hk=6M;GrLEDMlFsoT6+`QlEfWylzoFOF66hP+Mdfhr!|>yc&tC<}O^v~z
zaOjR51@nL<8#I0HN*$d$4re(XNg`utl-YBq0*f%kT=x3@Qtp`e5}U~T`A?`kmyu=?
zSNx_?1)LKEeFO561O%n;Dc9R%#J*}r4&3(dJO5k{EowYD6nLkhpTFqfE8sw(mHZkc
z9z}6BWj`K==;%2jw8W)&fz5K!Z@j~0jghkHc~E!W<Uo}7m;H-b`ye=o+v0H^o5Xcv
zvDi$v@IJb!>Xt7mI|R0aU-6OZg2|u@2DG`61CIU0w-GzxZ?@kP0hfNYQL|NImL{nC
zyOO%s@6gZO7|pjyPK`OC7ta#C|Af~RQlVQ5^fBZa#G&@{hUzDs1b~#8|4ZCaVPLo+
zW4@6!A-s@*;9QgCjOXH3!hITyJP~li=r>1xXuoN_CA%6GKe=m2gEBYg{PbB%k)NZ<
z=&!P4Y4iEE<34|}@F#rxK22SU%Tke?(445)=U9!{B#Sgl##`V{E1uXCu7^i|lYooQ
zovg=aj~-f7=;x7u2Vw^{3GV;%1z@>0FG*j<E7?!2v$(Zi<{YpT(qX=8{k!(o;hP3Y
zSU7$&Ut{o=gjp&Z%=J&DB84`2$kNxjlTad$d5a@<qM@0Tol2I%!!O}7;-(<0xIGrF
zHjbkRS5NO&hjhJo?WwPvMXwhxy%^1{ZDlqq{#rbMi}{L88{bY9pR6677#<3z-qrfK
zd1A2C;mQ%d(#rP?|FdU*9g=QF(v+j~AsUS|g4fq!^*B4_A2ap5!w2ji8%~$HaW|{u
z<taWjOcD_wc~T|#hF?Ngb_&j&gb#jnk}*WPV7VEf+{X4-$w1;gD)qn}wU}^qPz>QR
zp1jlk;??X1zb^mqhn5rSJxi$tyVSK~^-7TR6#fs84{yL*x(7%_fd&1VPoQQO?-v^k
zv@00@l%*}VT$Ty=@mX8{C00;<rb>iLaUbkQ-9_Bre-X08{5r7h1Hbg;r9NuS*WrRr
zymjmLR=)BbK~>hkzUAppbi+Q!ned9K+0&P0N<9#oH$m0IIoSLK0#)h;m|xev&;^sj
zrH#78-RgyC#sRDqw&*E#I=?Tp^(bA~PuBd6gCze*3kE*4nqwRhJZPnUMrf7d?8Xy`
zBVIDwywIZU){=E`F}yR}mF8PI+`~bPgbiKdXQ*KjxS7k?vh@GWYdZfAfg|`>@O!8@
zso|>H(*YD)5*f4p)zX5=GgT|c`XA&U;m><){1%_TUp(k-<dbLjy=q%P?={TM^2|~E
z)^i7%J}lb(2mVL>2mUKuP@^BmXTJg3UaXQ+Ah#8`EAAm1j#QvoIqy8@S~|pnY@NY#
z5W}BSn;<+{c1kzkA4e+%FRq{sMG8f+>zu4#3ZW8-R@-mS2zMRA@Y%Ne<+MBo7}CYo
zzeqM-XMfpg{1!Ew%suu11h1}Dldq1R<{0wsfysPfiU2N`U!m%(zxPh7_)7XKOSQ}5
zgL}qxET;(kj&><Ff(v8a-_(RBS>PnmO-IK@zYltRw&&s|ZHpmCBA+ejfa{gnd1B}<
z)!DNO&q>T7muEs|tvXxKtWEwy4bkQ|g*|SI>x79Um&56Qw_MxQ{CwlOse8Y^x}uDi
zt^)+ykpkBV-U<Xb&`9uUBQCV=aDu&*=bd?0{Jnn^U16T5>fl}j+~@|y&w58Z8$z7l
z8%`SltJVj-T=E;~$3_`&ll3oS7ck@Jd=45P$;lT$nP_FZ-y$o48P`n-C#vH8t~B_W
zLd%(Rd>OnaU^lE+9<lVn<Ra4)#*A_y$N_Ae;?Ly@J*AbP>F0)bc;!i2J@?t4v;81J
zL=vty;2i$)R3%120wITYZaByUT8`nHlAY8>k`-v^j!R>w>%$=y2^ryC?46plW@A2O
zW#Z}wGgM_Har=61KCA3em)}NF_c@{~tZ<@8OgX-+_yJb?RoA`p*L@Q&{CKq-n?-?=
zwl{wt?_|ZbZQ^x~wgO|M00sHFB%R_;bs}*8PG`>Fz3$+!NngZZ`Hg3_t+G%Y8K2I^
z!3pSC;UOwqIjF4EDGGQ!rL-&RF+iQUC+QmMX{Hm+=iY|M+bx{Z^ZOcVML^{xi%@Vk
zX{tJLydcKU_^)oC*NgV9`PeQ1LmPW}b)HftggJ>j>J=>?zJ0vQ4!Q?i>9{dxj#-D=
zVvBdMj{RYNs;9?Zq?v=m&4+l|#9%&g-HmrqnY*DWGn82O>Y$)%Y=ATfNw9{WSwmXI
z5msev@QFbU{2Kp6e|%jI7m8LA)KRk3<?^^8i6@@HUSB-xxa}6RdwlA|?8e*mJBZ<P
zymtQ1W<7%88uJ7ZnbON90YVqYYOqN>`4X1K%(k5rr6||q`=*ZMt>*a?BE5!4j0Ghk
zn-$1f_d-A8A~xNyfCB~QaAx2-K-nl~#vvbsOy~XFQbY~_4B&d{%a=s_Y_V(TB9tBP
z!g<rWy1_BMqi8eO<065RGJ-(G8VAj&!Lpn6Nq9xBkEzEf^Rrrx=|_O>h#E9HcLCb6
zqyKIazM<|N+4Y~GN<)xYa?Fj^V|%oCy%Qc9q&U}n0KAvb=c)=RUClb8Lwaa|4|;Sy
zN|Yw0CF~jNGvP(eG)sDW86(1YbW*}bx`u8PXbt+>tLn&B<X@ctk9_**Mq$|a*1gMX
zTOv59;%(8a@{_|^N`)uo^1|(*s)P7~EPUv0<M@z1PcVc=H0lUI>N-!HCq;LAq9mWP
zU6~VGEOJr1Y55*4&dAx-pqDLFC5azhcm#jpHv;A&y#Wi(d2SqvnnxE26_yy*!#Ugs
zh&8%tM9&+a+k=^^!6?j%F1buZnu1b@aT1$;n&)ZO=I9F@YApE18d7#^*UqZFz>B@M
zN2m7pR|@YAD=B|nuS|z1sel9hjAxDssm4<or}$pjCAng`;&;W$esuPO?%7!W^sri`
zg-=ac>mHW^dy05fvMZK)?M?Hlr8l1pu?teFD&UkJI92W}21l;(X2TvZV<`$0TZql@
zk2~guRKe+1H(=}B*)P_!%Cx;)Kri}PUFU$b$Ct*!x}|V_wSHBuSEGgeyE*poFpXEg
zOx^B6Wt30u*eFc8?OG$SbMgFTrCTgEZ3?wRklC|_I(n_>;z50$GS5qM!zp1H+E2S#
zLpObtpxvIS==4D->Vn&VSupVZb0mKf&8Fyb_mXw8OIVR?AWHygd6}YxHAvXzw(({5
zx3<kqf$n??Xd)d!n}tr<xH8pM&>5id`}W-quksa!h|ghCT;_KM%D-;)rtW_AKnf^R
z>XtAR&Hy|%-}eWs*lr8K!Kn)QlCO=88CoYMEwA*dO4FPQ6RzX`vc1%O_j2pwSu+qX
z`QG9rq4F$Y1Qz436pI`zwOcM$op64?^7OXR_fVf>l1#c0sODJD*HT^ZFkR-A9-Phf
z;C9vje@IqY1vYvVu*w%oDF_zwkNfbx!R}$}wG1Tp<Oy3`{tP0R0h(O!#~P@Rei2)O
z-tr!Waap?G<(znJ)h*(fKAdsiv3r6*xlCB{e`!r(c_zuIl}FPAunAoB{_B66j6ibz
z0TV9XF-XFXYzSJvTplz>k+qC8w`DEQ@sOvM+^IumHF?%NWY4aymhb+=Wh@E!c`aT-
z_Hx~J?rg~%_hC6FgPwW^2Wiu3Bob(!jV<T6rsgN%Dsjs<rgppRQPYe6jn}Sqmpix8
z-9NhpWCZuAm8ILqOEY)Z`To~l)ZwuMrvsoZjhLS`8;urUeES#Fs@h-dr5M9~Ki6Im
zmhy2lkgh<(Glv%lEWSLklYVbc>%eBYe|H+ayDY2y@%DGY*dLFB{mZET#_xHT|Hkjt
zmg7rm!lyuE9IuG9g6AXi&SP0nHyf2RRlQ^n8$NXJsDcTUX>jS14rLCr*71Juh$C?0
z)e@*+@qq4j8)vt=|Cy6U$yM=j|H;Am3sFZ_a?LQpRAb`c{h=~`()!c5HX33DDLgBJ
z()beWO_UCln$GX^N8kPL{2k&0WiU%kN+VkSya+C}+E0v_L1{d4HNDFY-4=U=E$Pr4
z(fVA7>mCnyH22a4D)D0wpVy#bW}V)T4;x!=z={mi8amUR!w;OrCM_gk>h2@*hNR+b
z9)^^L$rC>pR+^I1JbZV7+r`V&)-LEbKgpw6S`}uR@(>|CG`fR7`~rZ{FqdbIMKh4g
zv$eQtpjubCEsV+V5ld3Q^&{QrUV7z#0Y2w7b_{*j--wLLxbET=9O(COAddrBsSDvh
zwyeTc2V#g4-*7e)K%JQo$Q}VTqkED;B>EEj8B*WDa}~`a3o!x^ZP;xQP#x>|y+u_?
z6WE-6w+PM~*{2?QLTu+ck&+TdW&_WbBfQSK8IgXCB>Lq1_52v8KyC49CXf7{C^K0b
zGADybQ0coqrgy*+tb7l2iFvf5z^wl36Blccq{lZbsT@I>FJ}`*QIgaZf)juvD#_v}
zzo$9vqwKiw&G<Pd^BSdX39j9@<J#+K?R|H@u@W=SaL=W3llKHJ#;H$f^O^A+P`{H0
zY2VV0yN!*H`0|p&zW{T~L>|M6ralo3`}L;hzOwC}zdkBoZhvNwNjnSW)FkNbQ6R4#
zB4W@>+Bp*Wy|TC$^@{a$auC05+>eV3XcS_-|FV@76#mm549(H_UEM}c!h3v<gCu1}
zfk|kRL|)_3I=jK}=JM~jW4DCjpYrOuC}-H)i@GUmV^UjIzH8u|1j!K6_hye_-4AJK
zwk>+U3_i(j>$0Xo&&zO&L@eTcUqBR2{>dVZR%ejGLt;{@+u#)@4f_C7P-i$u&&}CK
z|MG#NI%!oPS6KC&hI1JF`g?&M<)d#U<Vm0@jL8Eixi{+)?|np{LK!aNN0lx*slHDm
z>8TVQzqPW&z%V!ZZ!yyg%90rJT0MSsM$Pst?Ny5cT5ld6F(ZufyBasE2}7Lqm!#8@
zcTa3ycC&2u=I!DZ(WofVUO1l{j2COpWaaMpO2m2m;Ih#emFxde^+ZAG`p7}eJczQy
z&J>ZgjdhOtjbWX~A*{e2{6MF(0&wvWMDO7NkD0Zo!Ntc*)7A=Cmt<_2;B=GudbG(i
z|5FO@tm$$Z9}DW{+?ihKtuor!LAi2shQq3Ob6CgQA%Z-Om!v7Q=K+1JcEQ(no~^d&
z%Cr=S>et>^<^=y`@obSL0GSe@{Yn(PWtc8d^_)cH)8nbvi&V7FinP|=h@$m$i|ZS@
zrNeJ?Fg84X3DSX!`+wMpfn2T@NB?G)#>H-$>XDbx%5Du5wfR<L%k3a+RSRe~*~vH-
zwv=+EPy%IYUkZ?tsnEiMs><3kvTlh2_Ilj2Zk^V?(f(@ksca@tjAfz(V7P!P9dFsE
zM7_KtgP&67+5_=}*G#+41>mumg0I7}C$VvLt>opCf(lW!D(BlCAS?Luj~&i{&rFrb
zTO~<QH@rRF)sBNrTpRCQO1bcbsy81QvlayBa#+&q1opQw9JQEn4!V4nr@>}la$z#^
zS|fS5Nk)M!IWy@TM}aB2x7~LDjM%Dd1YErEmph(F8*Iksll5=%DvSZONeP}TsYy;;
z=%(OB75~9=cV#LlXIf|b?;S$Mt+LY`m0k~J*El_Om4IevHuq1$cZC76=hHJV6+1Jp
z@L%xz`*p=*CAz$CbHPxaQtz)PdSJD{AWb~#PNBg6KMSCivD|eocdJQ5%i>0P)X-NF
z{_u_xy@(R7fZlR2{JBEu_FQq>i}2wevRGjl%v0lbiVeO$TBBvY{YG^nQ+|^Jqj(&)
ziD=QqLI~%<x8>5WuQb6Sqct_b#bXy+%ySZuCqlpF*p%5?xH~=;P;|P3F9|3oDK8E5
zT6F%3I`>89K<7>@os`mgutxt2(XY2<CzL%4BMmak*Z~$>$pdOSF8=3I<Gvh!yPtFH
zw>e_KB(DN~5-Fa<q~NV<FspPs&^8oK1bXv&%PcE4h^V&kb+`E4B^j5Q#$x8sWq4od
zwSO2eKG!Nvy(Db=kyPoXnBaW^xVKJSTk~&sk51(weM-jx_$p0V!Je(Xy|YfFe0ayO
zXN#$2#ZL6j4(EJ?4#;dIQYE5Dwop9$oI*^^jaz<D)FIEom}C9!*8aj2g#JD?om`^j
zd}h8sS^S@e|17`zYl2+AHAR{|ES>j3eZ$T51D0aDJiR}cbLC_$?z>-O{t_~vSA6am
zcKqgyr7f<WH~8=r?QuMkxPRlW>VtgoA|~YE(#-TWNG567^Jg)ir^<h@_kj*c(*xjo
z_@>7#Ool|%4FykX%a;lQ&5bYREW1W{l6L+W`r&gvVl1#7h0SNzli@4u+KDqs?r3xL
zuiO7(bh$LlgYR3$aD!Y6+}ZZE-)e4hfeR#@rl=G7E`2l;rTjylP4$DZ-)e|aXvmBo
z1%Ep4T(<S&Im68uO-rmytH<a4y8FIUQlb0C!O{iG^8gEp-wNu_P(C~QkfZ8u?auP?
z{0OA@Pd8NUYu2CNJjP8?Jh$Djg8|>qnv}P&dsqMY*QT_}ZXK{4#$??Q9R}Y|-S*+S
z#|3(wwyn>f68ewu{{pFam;Srk!$XkyN86d*6=PP#tFZm&(*vaW^3C~<7;s7~&J7^R
zfXuo&=R5?={k8v@hr_0g=p5GKX1o61SRah;ABwKaO~LyN`eBc$wruaGXxH-*=7AAr
zzTKXmpztf<p%Q(4wY|#NFUeMA6Q5zUfB4;OhN}#4Ea5~h=A9m@Yq_u#1Rkq>J#IAx
zuhPb~*)JvW^W9a5y;oSJ2xQ?f$z03v4{~}-FSKeB{Q-&>a<rBBuf9@Y29^1kIz=^k
zmdpZ_;lmy#-ULpLf)jk)f<!i()HJy%K+wYePTyxm!>SNz&IQ(2*t_BJLsNhJ#eNF9
z;82${uWSy!fWC{9<EM=h%fmgJCxreQY91{QmE-hNZCeV4z2nUMtK+<);{f^eN?ZHk
zbNwskSFOL2q~ek*5evZzb_CD2cRUxz`b0EHb6lJV$v0Lw2;}-68ssS(Prf$tzM|RB
z^&$k#q&uxN5<sVkZm%hoz>qIh*Ge7W$GIG0=W}e%<vgy>IaO7X1ev?WuvdgKZ^ont
zvrRVqIgUxltLf%ND;j+%<wHI9*UV#Iig^_2R`>r?Cq%xv`ao)8M^Fsk2uyi;*QE<s
zxe}k#6JswkfzEd7AjZF-WH0aj*kxuIeyvb9j&?GHn7oP`A?4!<kSdVK>G*CwDB{<(
z7ROrSr_A-bT7%X5ItM3CC%2Sjmo8QLUEAthu(g4|xT8)rv4evE0Gs^sw4C$ajNqG(
zT@eNaRT&x|F^mYQHv9C-=pI}PTW|9E558o9&o{TTUq~5MpEUi_C~FkxH(NLfiZlH9
zdt?AG_~z0<+%}~i$)8`8C$yEBf1!@z!pAwnPMOWbO^{5rm5t4OYs!45cD_E3+{H?<
z88QA`ikC5z=g5Lpg6x;q5Dmw0U&uxS3c=(GWx`Vd1x`tSnL|T&o}QRRx>j^s3I(%o
z(jK@&Xh}UpsAc(xO;-2tGs}b>!tX&3tYK&GO(bF8!YIFK3Z#4*Vg}sWn!dA;e|Rh7
z01^eH2|m80yuF+CKDZN&e71L?GW?Zx{T>+iD`Yn2#hcpV4?T-#&E5x57c#Kri>h1O
z>Q4v#N-=Djaf!fFl%UuMCjH+w?I8J2MKJ5j^7mlN-}$m<+S@vl&gtU>L?06Hs`NQ2
zTLi!Qn`}=o#tfq~(wdKLJ>33nS<kHwf0$b?UYrPe)#_5m#FGwSiY^E~m{gA2^}s~F
zqbBx(xO&iEZu}kzpUB3ot<5a#{JWIhI;x5JbTT1B*sA0z`G?QSgvyEC&6}|&6D5my
zD_0JW(F|3$T2D<>x#!Iq2~mqLAC7+xo8VgGiL;s(+0Jnmm-ZSwk2}*%%e)~9?iD~w
z?K-|4IJf6K5_tAGIN{wMQOB6>tIa_J>l~e}Sqb}K@dx4)prMFpUcP{m<bi>&Jj`0M
zRL>@v+t?>7ED6CbhU|Hd%r^Ds{ek9rEkvoj$DQ_!Lo=?GEa7obxPQfKLXD5_VX%=t
zOR9%e`t;W>7;Gxcny~O6GZWZxh84V`BqltA!#4!y|KsZ|gW3$Vu2G;ALW{c=f?IKS
z_u}sETHLjG(V)d$i@SSqhvM#TL4sU*zV|(IXYSnZ=abB2CX>C^UVCK=ezp>^2|1w)
z%0)sf7m)ZdA@ov!e~619UdjQB!Z_SBsthqAIDKm~JLzRX?Mqe=Zeh81v_XEfK^R_F
z(Y#SLw2?c`-mU}Q?3oDqoKve4CN47?U1*r2^eIu-0udi+1eEiqXwPTT!Vjllz8!<7
zb-1G&3~s5Do!ws(KB7tCie<3vt>>tf*@Te93ER73E|=JL@esUqGA;guUVDiztLmib
zJZ`Nqf1(A=6Ii&5J=K#~a_3z2w{0<Vl<F7RRgOK4mCusGqhpzpMV8$6_8Hu`KTT8n
zlj%j*vbgacrIHfm!r`v!v2u(*ISouE>fh1Ccq&oe8ReAmm*3&P1>1XL&-f*^-v~V*
z4D?aciMTUjlHjTpKuuRgIyWgqNTJFxc8uSNZBkb%c5$RqEpKPAxZx-%phr_l;yEZ~
z4781ARPbox57-<NnrwC^!`yb`nzYi|4RD-Y5;bhdRQ%Wx13<I0&oUmNk%GzpB)(+O
z`=5)+&?-61x6Ci`?5Q2-z~L?;_5)`UVv#Bh>Mx=UPDcesz}DACTwvSAI$DD@4CgaX
zHZ^sNc2r}&_WK6(u~P594LpK*rY;%<hg)FT*#TU!r1^$b(PjmXYHzEsWMC@sIkP!j
zaQeFF&`^D_1>7(~w?O7vNaBmtiF9BqoR<0l>bx+^$4OGTx#Md;{l-J*7%-ZfXm{NN
zZf}+IC&2W8vKXA?->+R+N$Acx;-4bIg1nPq4`*Wx^enR%?7vqz3mWi2YiIjBd1e_$
z_zd`+@Y+DeKkg$4HrRS9W@z+;wYaN@6&Mp6brasW+l)!>BDmwGe&Ij{^u2&O;9j0$
zCc3ypNXs0nb|H>YhgB~<hM-1Tow&QUG4JWuq~@@&R}z5<A8y#^c(m*zM)kLSv6zw6
zKT4IbUAumr(L0M;6DWd496t9}dd=;yFl?;I9^2BNAdd;Oz9tv*i*7&323tSnqQ<Lm
z%P)h!WH%}2T^v1WgmHpT?VfIq7CU+SI(HBgv++xVuK+tuoq<fw0mnsJqCYxlm-GgS
zxE#y)3&DXall}+KnajMbyHF7u#6^Mt)+VvJMD2)2UJs8Sh{y=0ilPWJ0IL!}*!8AM
z<A6OjbX0fwk8T^`0Cjx_(Fh-;xkv~c1skNOfYDze^f3w?J9D*pRs6x%3*n5qe%Qfb
z$ZgrcJG}S21tmUS2WLvPwU{gWv^F#hBSO;rQt@TUN91>|=3E$#EI{q+nhP{l6y($n
zn^3SdR^#D|wZw89tB_MuSk~gx*4FMFUzhKP1KIbDVK~Pc{O3J8i=W+E)?Am`Z#b8_
zZVGoVHb8@0zhUS8D&eF_+S<#k+;bit4`-6aHrF3iqvz;-w5)ocC=fmnKhN@psi$RR
zG9ol)B8c6|oDXU4GtBFSDL}sMGFg5Q7x6^S9_R*1OHmLF=J`oOoRt~(%uK4NJ<a!4
zpL~!p>=RAVJSfmS_yJRzLb#X`fj<W@QT&GknejTVlM#zagfvpfo4RN?aZr?szZ!=y
zV|A0Lz^C_w&<btDO~=>kQnHnEc2V75FpMsMb4{I2DmR_h3&v5X;FaDF6rus*orA@#
zOx^a*$Hnt#zQ`c|I+}Y9byjYr-)iC|qyMtzQD5OEl^8;3w%w5ZF@IWhp1M@v0o}Ne
zwsa=G4MU_uqYWYeDg}8g#X9d7+MtF;*P_5$=bt*uISqB>9H>w&BvBW^9;Y=WP!`yw
ziC6X7D<P9asFl`1tFI)qGD%n}BmL0zfr4(WgsM!&Z}j`rdr1M((d4>2k@@%;!wlP3
z6{~NQ)*8T~vVkkclF@+g9hR_Uy6yS#4v7+TUjIr&>_$8Y9Z{702R&XuH(gv6hNu!=
zum=%XbW=~r%DOzj7!8(9Pq9p`P+P<)0-=E?%6T0ZRt*qxbI}h(Z3VKmC55TBeDyV3
zMU@B(^2|SUxi3PONW#te%q?fAfGi`}ABu(@{(_1Y%kf>Vq$YI;CZCwaBB7CP*n=q^
zEcH>m<ZkE(>Uj^O&D~X~n6}3+;#N3>JmlBl6hhhctw$I6EH&$ow2Uyzn#ORi*}$S-
z9Job36hk5nKrU9~VB8C`jqOs@3+UIe*CZFTm0g5bLuIBCBPUM@gUFA{=S_F)pGpbv
zXVPBI@A&g^&p;RynBcUJ%3rA-edl<c*#T9$ipA|Yor+W6KeQ;_%r}U);RIv_K~-Ak
zw97)dUIAi;gjN0P+r<@i37UgMBoTEUE)^r;KR%^@0y7>N(kq$B{f;um5>T6FU_pd_
z8%Myn=2cVLn~q*>6aC{5e%6|%_!k;mstEo2;|u2J8uq2PUIbueq<dj&{$<6d_C$K2
z@}SbNfy+<*?H{nI=(IW5V&N1i2!zE4V?iHfPT^6FRH3zT&Xb^gm%WV9PYN_uemV!y
zP9lju8wpbi>(S=THATyO&E+2tqDjz6BHa7&Op{ne1dRwk#1+Y5a>12b6b#{&5MBnN
z-eLw!1ZNgEVehK6pX|<ukfV={@22)o2tf(?YM&H)nR%BEK_544s7Q+ADE9#OY!e5@
z;1U<8iwa6DR9NfrzFqpo#jk$(EL~71{44iN-k2%UTC11-FT6~gvSwVXdkj_%@7dAp
zJO)z7ajfV=5m8p_1Vn<wOIV-gOA^qNxj65Psh~iUIEpnS`?m_%t#gSv<VKVbo6TX;
z_y%^eaqV&|1Pz}YmNHUG282?5>C_C0uNb!2e=5nA;rU(ds8pa=b=NL=FY=s-k&}dI
ziaiI!jMl$M!3=>x8q#9~?O7Jni!US0HYrQI7(HdiNqFWH@%Eyb0_j>1ol)bPkLrpX
z$SLq8bPa>uLc#I~M`jeqwTD>Jl7;>}13~;DWPquUPYpK;0e(+z`8}kK7jrLkx)O69
zy}|TCbtD2j5zcA>jjoK0;>$nzXdQUmk16tg2#UO6TEye;osWP6cke%a7XmDAm-3Ul
z%HM3)_r2#NosPPiUwk!n6jSZXFVJF|8E8QW%XSNVn+w7M#<|3j)ty`6a{9e+A`vbp
z*kUaU9)*!G8b}0UE3PJQtV7<dZhcDYQHaK|UCe)Ayo5+y=Ll=8KtAtBHbrT(?tp|C
z7AiAgwFYyanekU#wo+kSZa_Ox_!t;N-kL=2A7}8F@yzOMoMvB7R;AJQj@ERjyG5kd
z`Hkh<iaU7hd@CDHrvyyGibzDf3PQiyJW-sU%cx*YR{sj^K0)7UL3P88@qpM#@`XX2
z(JmY{I~}8!{TQbO;~<N)Q3SF^z_@4{i`~fllrZxca|jn$@!#pthCQTx>9IO(3Ij~F
z3VcN4j^XD97l{T$&0Q;tV!6e>@}NL#4|$vIH#tY+xn|@)I`Jv2CT|`IWWJINKDh0A
z@1O<)BL-_k!7R0}+-UYBVdlPEe0d&x@J?($&wf-iIoawy@Q5zcPG}EkEjj4H<`e^k
zPISCUy7KLZAK1q|45^V2lAl`IGEDe3xqN7pY8>Faf4Iv1R95+6*wXXRK-3d{T?m`=
zE={%`aZMPAjp4-3p)ShM8EeXYxV}l^X@GZZb6%X?oFtL)$S%IPfLgN|P-3zx9|K{i
z+>+2QA(8+|VzLV-(6YXnt@V0vX`my(VlU+Or{V=oK9CS*lv?N_GYzI5J%`2sjgVPI
zS~^yEti50N^G+(+9LWu2E|JzbeYY*<t1BTJEX{;MLEP9&9hFe|NC!H?&YX?OB(3n=
z-#V;Qt(hP|O3V^}M)A(qImgsrT*l8i@}$uyAj0uGgww4nPWXZ<Vn~@Xh}Ib{tU@b=
z_Shq|&jnxHJMZb?IPODADoOxJbHj&WRibaHCelP?Lh$9$ba<0Q+qda<<FO?j*``@k
zy$=H#e`K&Jp49*kGMn>gX7{aM-j!dMxrC`@D~h=H2o^FJD?E%>#*}l%yx1?ZGpo()
zv|>c#{-Jqxl66A(kzKe=_XnXqpXxKgm=bf7WS8b3bhDyjP2M^uPZq=ehlW>huBKL?
z6jCnTkgi1LqgzL3iK*fBN<|`geb9HD>UFopf@z~)<ecUtqBH!2gu5HU`nwllP?meb
zRt2Xn`a`!|CUpY}l2|H=%tOYtcXq>vr^=x33=@C-yc@4hj?RkG&ChGTji#V`z^7)X
zzs2X%x8HD&^x}IW!^2}B?EHOP4$Ttp<X}@K1oziX-0Y_D_6a2((wsG&FE8BXDKzH$
zd?0q7L(O4)NquAiOyz!xnJN#f4G$hv%JPIFg%koi<tJI-ER`K_2*c9nkqDQ<uYc<V
z06tAKk5IYIav_UAYd2I(pv+1p&)N41sOyM8#!JH7@IJmYI8@_o!V^(>;D<5JBo^^!
zLWZL*4o1b?_(mVMs76D=CV49PeK>Ajht8xjaVYXAJ-Ot?zGW^VBsnV=5wDS<eCC$A
zcrFIVr5TvN2p`1b^K7`3z24PRJbS!3;kO;tA03YGU}tePM*I4YjeVdLy@hZ^ve%%1
z=cbR$>8=q|8qb0+QoHCZ-{3EKihrA^5}%0riD}8C<=HYCU2NBDu-eS7szMOMeT0cV
zlqr|2(ZgT|YJ3Vz5ex83ELsB&a9LWBmFqM)EiAeFJ7muDoZ%WQKIXnST=?QDrb|RI
zP-4cL3x0WHbwItoxwxFl%FiX^`k1(L#-zCxtCASI3npX>`yya|DtZv<X6@yE7iI``
z;Ww96l?MQS227>E1M!5y_x<Zi$18LBaB#(Fp`X44Pa}Tj#&4`od3bi5k(WwYZ*XnC
zq1)i$&8({I!*^@dDmIZAI5FJIs_+5xa%(qJj7@Crsk7}`P`I}>If`E07EOAReNW_L
z8a|YE^!^n0ac@WGfK4_)AZB#**>4?T>WcyBQ67{?lBk;*E2P;|_X_@WY=}2(@>ds=
zbag2Oy3$)86N}1h_X)x>EYfebK^hX{`bd@w)NsEZ3_rEgniL=c$6yC8!Uskv1T47y
zK#;sEnI9mekYE9PD+n_)1*ap51juV>0GZDIob8eICSXU8D+S-GD`~7U71RWJ;t>%f
z+wjDHjT==@F|+W-sdb5{-ug=%*xdgVX69n84M!4p=iLb8vwNRl<upxHGzq=*6pjQ@
zJiA#G4CE7_ob|cpeZw-4*f7rf`2(Uj0W|+jUt0njp*Vycdokn+9r1BoRwf5|G#tGo
z_PW;RW-9K($X_L%_wz$Phk+FSgPNKI?LprsnIa{*j^I7M|CmaU$*5o&E|&S-I(1Ok
zxwwFU0AF*{4C6wL6@Odk7mijUx;2GuG**x(&%<Hl5_F9urYbf45mS#XV-*+~s}*ia
z5nkJR)c-v?Vh{6kdY>H6V5$(M5h_Eo20Dr#A>YYkB#`e!#Ng-BzJvgkBz<)ysx?m^
zY~ukUKwAb8To;}P8?-e_U;VB#XRoq4gFD+ooy?RCX6HHa0>YI*<6X6i$XmH|{U;{E
z{$sI~5nZrc(QAf1L=gF;&mh#_VjWPsj-sUSA;wwaR^gK*AL0pgFY<322dL<putt(o
z?hj42jBJw~=jm;ao7HYa-&|C%a<!rJ_-Pj<|Ni8qXF3rnN-%9Wb+x0^ljp{p`QF>>
zq8o8+nuv@;K(ET~*gI;=x)rOO!ccasTE?6ESOII9PXb_`qwmh?PA(vxNzYHr0)}(r
zLyO~VB|-fT`K67t&AjWb=C#)BD)blt8ueiB=h|U|wJZzL(p3)<-UvYlXh!23UJ)2`
z{8#~<;rGA6-AR+kKk*?Uq#y&~Tme(&fft~=0y>2fEtx+kclmrsPHwiLe8Lfmf%kEN
zJTZ*K2~@JEm>fs3tn~ej2;7m|b+ke!g{?U;q8OezWkxiFSWk)*5n^*o>3q52X`cAi
zN_*ujun<0Zc}ZUJrC=9(>{Z}WKTUR@Gin)$ZV15WkYZdW$c}_)Bj9o-1a*d-ji+4~
zL<DrRv4l9w1uSrk+9_n0W#RH!narXJ6j2+9qAe?pG&kmJ8|Zi}7*eSrJ0}e2FZT>n
zIExWfp0(>tw|@Ska)H+XVzuSG^~2vIK@c{5riEocM$FLInVTl5I$3@_B_09Zx$0r@
zE7kCI^0Pu~L+3NV83QA>Zxdh@D6smSrmm(LAL|XaAB&=4vJ${Dcp~eye>;D|xFomE
znEqy7ofLUS{Ir`+tfVKVB#83URwy&<wAfdvVS-d^>@(UBof#qX7atM-0ByzGQrZKj
zGzd+u>x=7>MbDEZQdqn;q6iim&bopKP3iEyfn&X4Jo`m#{uivIQ9-%zD)sm~1ptx^
zIh@{K!Ij6jVh7I1@mX{{qU}stdkBfFShbGoIFocoY|}^!N9Jz26(hc3g`H=-;vxJf
zB%udL=T0f+?+YUq^?3$ar>%5eJ0pHg6-CsMs}J?K%HDr-F7XeP+r%>o7`ag+#0#Uq
zU!|C`VHD_DnwcvGwev^ByA15;bQ1tx1x{d<(aUF#FlY=hpE{go90s6&aS9i)6AWd|
zSk~j|wzAZb+nE;IWBjx2MJl2bNmK@V*ukz!-Y}T`-N(r#=P1YSd(^Lq*iEiwL4?4)
zuosqa(z1l`Iv$26IU=#6e5-nIvWJYu&M&3tz{a5E+|mevBa@5-$})MtkWlakO*T9m
z1o_}s%Q>#BkDvbP{jw)VZz39$&#$0TTqbH8^mRN$6sZnY3%JQakB*oKi1mibP?<%u
z!mL>dM|BpWc6SBPbE1Cb{_z4vg<ig0jJEqz+>g8SSqjvb54=wE*>lB5^>p=d3dyYY
z`c<=FfB%q|^mXzfFnHHc<f-cC=#;6d#Ec;n^FxmTP$<`0_tuy*$B+~9rT-N3E{MBQ
zltO+j-(lH(<cA4LcHoN}EezXUJG<XE<5-l*L5g=H8@s-=7^#wui@ZGOdq6nOaBct|
zv90j?jDFSeVX2r)CJJunCul!_az!ZGVhx#FV&f;CcMj6eY#1P%kmZfi8pcKc+CO1`
zbC!0~S1fPk%Y|)7^>bqLkIf)E$nF%zH#S|O%~YUgsGH<(HWM<42^1Z?yF?>2+s;H>
zc08(d+8rpXt#C+;8}(457ERh>ER*iTBiO51gaF-IU2?aJsuY$E>=GaYtfd?Uj5Jt4
z=CcME>{jaj&VKb)x0~T9SmJxE?Q#iN>tCfinZ_an-#(EXPdVk?TJiEQ$-R)0#^dRy
zitGB~U@~}y5%%+sFOs>28|vy+Dlsg>9-{4IK|$YL!r6%vv1A@Ti$S$5OKRo!CdVi`
z!F?cd|8j0Jw6*Hi{^DXV!DW0q>o+kKvu@~zOV!VZ4E7fLsHN4T6@L}5vfsLx@tXL$
zJGWO}oD*Cb10m%SLK!=L1{5e|1hHSoHyWssZh-FV4NUz)YJ@MihCHb_^`eWd-UfB<
zQjBVP-VgqKk5*{3XPy+r`~^d<mFXoo?<V1<B2KoQ(VBJnI(Gm?yX{1n&AzM-6ZXdB
z`^(?}z2Rz_nZP$A`KpYj_~TMXcJ51$6F&WfHuTfcP*pmR>o9x9euTBj-N)M+<`!?S
zoaZUaJWF!;bvH7tnCIuq!p}h`)2!Pzu#KOGm@muY7qKy;V{5c9#`lKIu@quc8gClH
z<!~3SdrDaIyd<Kv<!;YIDUSQ&BBXh$Qqiu2?Va6=xFZzD?Lr^8BjVBm`A1dBAM|$A
z&i;~PL+9lmaGck8ikIz2^}h=m6vYb8zH7Ph(5xGI8<gz%c7I-j=pTJPPQ*Kz!_cf%
zJY0al>>7ncu=*mi<v7KpPfKH8n2uP`l$$2EQt`0?FU?`#A&uMG>kgaS?2(POdr-sl
z;8qrQ^J{rN7Y~IQ=0T+*QJb-Im{Wp8s$oaDg-_vP{aGf){)J0Si`9O3&3w%VI;m!y
zG#q|oeU}vOM*2@v=6*Ho?;AFm=?k`z|2n(X0W@LtzryMh!>~~XF~}Tt*G2ZqSlY^m
zcD<=ci-yGH!knQDjTxg@@PmS5NpA&QbXQC{<aiIFAPyG{koSz_>p`F|ntQgW@no9(
zF(a`NKE(Is&<~s95FN;Z2gSm2<og@X#7%GYM(Dn2VGCTvkCVPrN$jea<KLhhBh2_^
zD#~DVu$Wld$W{1R4*&6xJj2ChUHxjllGFEmhxpE$;6@TP=gz%|`cF1b2m((BdDMBU
zkZluAO!p&|&`_!cL9!7xLFXGs46-n0H#W8@4&y5lb_WanZ5hU?)zCd7;lshJQ00T1
zzPxUH+Py#74Yf_jUdM1hg#Ym@TYZ;7hB$JmuX4v(A=NiPe6yF-@d{x|COpXTgBC^1
z*f-EX9TSHpJv5$$3;K1K!uFjW%>ireAo;0M^6<r{UBq7c^ZX#K(9^9b)*3c8dgnS+
zJhD}Wrm*iHfPIf0ntQLW)T>O`>7lAd819d!_#>$+wE@dRUk)tWT$Pr+WgpJ$Km9ZR
zO2~?-a?1Wt%eV8B)G#F$$*zPDj&CA%i-e_dop%=5DB$R(&PCJ&@cRV+&{7ki%jF6_
z9-HZC*Glze;T1YV(DN{7wnYrWhu!z1a1&{totL9nO-dcBtZ_URX2#u5VY|OC?1otZ
zGeoJ;CKfCXDN*5zKboWF;nEh$C|<HMSHP;N)4xlIUaBZ#{A*i(B+~o@%2XSZmnqv0
zj9jHZ=CLd3^Z|raLd0g$A46a%TEC6$6h!8o_7H`uP)iVNu&Hkc(DG3^bxXl3CIqLp
zL?(O>RUD$E*(}4@Gr}xaDM2rt(IYNsL5->Yrp6^<$J4gK^ocE)>wI3R=sUs`-k(Ci
zMy9=YfA7GKq!JZsj#AK#5L;Ak0edv9TOM&<McG4|xJ*JxloYC4l%yQCJ-RVwP#OaV
z{@yyqhR`Si#tSHsYirOIngeNzT?Q6ik5J?8fbvt9Oo09mDBn5J0Jn%SUoLb7edFs6
zWpkJ%3TpQe;fwsW6CPO0aDomh*E5x41rj01QJgZ@C-Q__6Lyi&?RO-=czOesamW=f
zrIcTXls1vPv~B|wv)0@&hqMmZf8qQ{A(3fE(Ax~ENEH*-$t>V6lb3}3h2PA1#QNd2
zsGpV^<4lOJ<(u#7EI~$RmP<$3IvRQ{4tp=xr*P4d#Znee&6_lUTDpl$zy$5Pe`nkZ
zn3DHP|EL3yXYNITcP?}Ml`@XBOpI-tW%@o1D|-w=hb5t--XaaR=H`=x1InNeSV8?T
zP?^wt9?#227XKC|N}ly`o7|3M7yYXO%|HT&D8a|~TaUu6N@hFCL<5cqzW~M-iUx~L
zY?CFVT5<>=AYOJ}MLGJO9d<p*0UIO%be|KAq>_)|+$s;)q6fNlpbjJwY6QvFsV3Zc
zgH-nICKk>e9eo?UdPRW8c18fAGM_b+NAj4PFxu_9XBf&dMZ_c1sE-?Z0Jyl^$gdRr
zRKw*|+>)cSX^jNS3N*|C0B9>a1*>cf=4BPpQ_6BRETnfE<d;0DP}_?L3sKxFpo{_a
zl<h4k4ov>?3*Ek>K6qMy&_$6zfi|$Pki07Om^9KUOGv3+sM%hvNFYGB@Y6KI6$8sA
zXfhCZ-q+xj+33zLC1f@+N+`Tq+<6y^{+HFjy1|ATT?98`%0D`ngoxx?7`&df>kd3n
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%0AHGzFady5M}MJgc67@+?7D`Vyw
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

literal 0
HcmV?d00001

diff --git a/week3/Ouput screenshots/4_7_output.png b/week3/Ouput screenshots/4_7_output.png
new file mode 100644
index 0000000000000000000000000000000000000000..632d9c2c2588e7234291d499300113e1f46aa495
GIT binary patch
literal 1226431
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%0DD23(xD&$}|kOlEKMRNFv
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%0ALfgsxl
z|KX@+?fV5aWbfX!`VScq!&q-SEHpK!Q-oYT;+R*+5^m&gN&{>tZ9$%xm~1^kueoVC
z^NIal`=W31@kMu2rzcog{ME1Dm8>6+T-zjBFw#HE;vUc#V$(L7TiBDzYe9E18W%cF
zOH&xujW<p?xNZ`j0CmfAQ@EIIjg1>``PEnF0@E)gmPkjmty;<3OmQpHwW}oCXwolF
z3EoxiV1QgN#8)i>hVgf+vN%+$Y(?a^EL2zD(RLpScdg|=I<4t~!~5K^0ZkrW!kUZh
zmRl~1h#gF7;h%HuKf`Q6dE?iT!R%wQw4ot>uK0EaCsG7gn$}%Psi7nu--S;xu2mBU
zcr2XL<X&cj%F$$527G1gckh>#c-w!oAfsyh!qA2pu*ipqyiWQfiNv@4@Nu=R^hzD^
zuLOEC8euS_pIPkB_DK2GTj6xs^~WE^g>6Yi84I{jbwZp-*!8od63l5%DfxDK=$7Ef
z))#GI!}IHMwG|@<+;nMY+XfsH!fA0mxApesdtd|Qe)YI-`w7(nIFP>e*1mOwU@$-1
zZ3ZH_(o;;sdEPNq{Iz%CQ0E=ptw_Tsm08@=gL0bxM4t5!kr9J$ruW&YlNj&{1P1Z7
z>kW5Kj|A7h{{g=Dashx&8-4CmJ_NHLSElSx`%1Q%HZ00i0)xp_ZCxeytApA$xNJ^)
zM=WTjiv%v8uWTUOD-yByRt-QN+>Gt@ou`1M`zxB4b*a(w-@2)(a3S#VwawxB;`1dR
zY~k|h02iU4e<7A<frk_z^}YYF0}jCsO%)8K;k1jdHW7RjxS#ETLU6`XW$EBg*;xI6
zw~wdn_e{BzV}CS}Rkz5L41XZ?0~rfI<WqE1VrNcL%EEG&fV^$ig=S){5)I62`3Ky;
zwVoeaHVS>K`2hWRe|MuIDEx64SHI;Fy*VNNnyXvVGkbY?@(}&^Bi-lAIbJFC%pn~m
z7Zb`D1Xo^V)+ky?68H29Jzb?O>(2ydDgS5!IhajOV(8=uvMiz1^{;h|QGB%^Qcs%T
zupy31vN$vhX-srA$|*V89|}G_kK*sjeSS9I;f<fjbPJm>^czg31=9Rn3W;$%UHg?m
z(};gFQ}Y<lJ)Xu5@xXZg)C-EinJ!N4@;sMr$Y1S$%6}$5<eAmjeTH>^pcn)yZj$9d
zUUP23-=CYs^b_wOBx8)`j-I6*vvRma+y%WMYT^^b@4j<(ce$aRG52eT^F42hKjKyv
zTONy4*(};>ic)JXYv!%$pb2YT>AHd7jL3;ARsNN4&Rd#6>L*|evq<1%UqX@e`=H3|
z9DWZZ4Ob=uea=l<|26m6bLv2Mxgs9^4s)K{OVjzH^%WgoNG|QQaTu^ut`8&q;h@W@
zqb63R1YkG%126#}k8t6~(;E+7)*MEy=QW{3g`;B)imDfA%38Nz1w;flFw1|y_N^qv
zXs#sGXTZx^u?SJ0s9AHLW}CB?jB(#}zeJ*u3ozef3&%l!xJO3{K;|Z9vHlrRyj263
zuonmH9b6d}A)P&YHw4__+rj{L@*^(dGoRyjlbE=^2xIC$9x&6L@w0Q@xp^4^8h2PJ
zx<|+9(Fp@N2*_L~gqGxNok-OOxwy-a2~2=3L|AT*tO~TLJ9}cn`%WA^Xe{3{@61t$
z*uo~-&|1)8Y0AcNp5L2p-kDd5?koZ<Qv3-jmT1Y|W!O$m54E6=shT@6gYWGf)RSKp
zT)k_cy7iPf&Va=P^simb<F<GSweVKpYg78bFuU9-iC4#KfS|KknbgJrQTOk1P%X1Q
z8*Ouxp?IHZt`GjJv>%%EXN^NQ%|niMab40Dqt7>QvFuHGf*E%$o1VA${_e^<i@7$t
z`S>2k#g#Wj#*I{jJJ+eLj9^C(5uB;oE|GkY`lwCGwr~L0hniJ$qkcCyc1%~h*F$zW
zriaR9rp*-~llm1^j(D-Riz?}{;$4}Ad{J`AIXNIu?h)ozyI*BpX|vrD=9REPQ;lBV
zd|v*6Z)%$#PYcsTeCc493z;2FMPssp9{G(CgBz;n@Ir98+E}5|exD``))e$-Ig;B_
z(WR7>Syj4v6w1^++Y>*$A7J^W^0Vt1p`50K8oMC+t;}y>_DNii00O-u5~U2g?O5c$
zD)R=`uNd9rT~<sen%bQJAP0JIM4>8wE6%T*f_{7!c?;A<{U_G(9DtXXz`(i?Dp@7L
zVp<oa>Da7me?*X!91r3U?>9?1#shMi^e$?5`$j=)3Cqq!7h#Q|v*0>L+Im1|g9`Kt
zvo!zc0bN~*4|YKGkq@=9$fp7}z>n~3yo%a&oKu0^#yh{e$T%_x4nq&0^swd(&UoVw
zRaAvshj8EO!CG!F7I8Fj{S<$mPIFS6PJ5`Nb)^f}lT38fbsr{}`-zXp@}AxUCdO12
zaq~MM`+5ICE6@7_u@J6p*%f&wKEN_fv)D;|spo&$a#=tX0JuEUz0`&-EOFwN2*5_h
zm-w>^V+w29okky?GarAmOF*_QUHJxnrdXsd0{U#qvvQ1o=UAk!ei<k_tUNt-Z&2@r
z>vk5Jvx|GRvY<jcM``^>79RV~2QO9)H(ELB-aqn8dk^1pGowK{d7Spy8?fM0jWi_C
zDdk#(I$T_XQD0>J;U5`^+&|1s6_Z&+Rl2~br2~Cr&JZSL8aB0zVfU^sH50IY`DhUs
z_jQ}m#9^(Uj4t_uXUtf<QBz}PKM7=L+y3JVVgKYnkVzvuAjoZ0bR{AcL$dWL!m<Ak
zU+|}{KduZ!mvl!@2=$d{3<witpNuk_$-#4PGI~jU_SakF?Y@WEups)}nJm%yr;kni
zVLDpA4`{*YD3G9$V-SDS8n$Is5k|txFn~My1nh}nO?p8b?ICE$tDNAgF^9;O>J-a4
zCH6*Uh<y={5|`nK@vGq!ZAPk-Or1vIcgIO74}nAVwf@RmKOi+?@Hi<(Q;{a?pULw+
zJmnQy0L8#IkzCgmq2$v*XaC<qrFrHL3yI6Mfc-<7pjet9xq?Ax_%*Dv>tWhfzqr@F
zIScIis2y*X)q8!b97mG>@%;2zN|#!)OFXKTw8_)$^WYLu$^Pr7gVW&9Lp^yiS01{{
zO}6LzPU*hsV&^Y@DNAIh>v^QLR$@#6`1vuL!+W4QAf9R9&;A>YB0}$8Z#l`EE}-u|
z_*EW-l7l!ni!ZFVpMS|7HOosJmGCija(moWTmoQnh_`P=E9=A_e~-Hv9TCH6^A36A
z(1{deVU2=LdrUuZaQ)Nd!{0%yN0n05rMLQvq!2wHsyM=k-<uXa;UGnxqYnq)T_i3s
z$;ipD81TLw)}&65cdw<v5ML9VeUzdY7?lD%yhA<>RA$+!3D*#@;1tgz;n(@10;1Xl
znjnTF8hH1!d6!0zn}8ibaZ;DowxQ9R@6<|nc&jPIJzMCJZTeIELl-AdZp7ehBbF2a
zxT6QQWXmTX4-`aqCPD8yaU%H6guLbzfU$|n=gx(QOSk_w&bb9hTJv^qhoEuf6blth
zor7yBDG$zanLKzC7QCeMWnRV$y#ZFt^NqrRe+<S<wKvzdkd9X;x-=DerwRat?$i`W
zOoqC2d<)Mp@7(7V7#CKsUBhwjv3U~G-%J-hB2adn-KXaAQe$xtBfR%1iNPzZlfgYj
zKoE!d?=y4UMv^Tp9JN~fos&-l1cu5wWSu!fx=Bo01{)nBMpQroD_l_$l(KH@pO8)Z
zO83y~`PU2Uy2UwXG*f8-;`msS<mk<KpcxJ89K(CMxFZtCnjb+)5D;;K(!|{OL0o>v
zpl8p%LEBWsTK=gLNT<@^hZg>>rHw^!et;yF3JXs<m0Cd}AHGeKfB5Go)_jsc&E}#I
zD!XV7_76N3GjY2;BRkN%ZG`XBl)F!0dZEZfXdo<#%S!iP?0r+yq%{Qr*e@3F90lrl
zKT)4Gwu19FWAu#NRa0hakgkQ7#dhE3s3dVgu$H40AZP+A#&uJH5q(cP?%7%NYUv!s
zrxtBdI9~vs-X4kgwq+BS$u^}X?$jfGwP?^To914DzmT}kp$YR(X!bqj;NuPDt=!QX
z7bM9%YNY%D;hH_&6s`@JJG=+&d#}IAJWhS$g*@~gvE)d+3H$Dq*weK(jQ;$v|AlJ1
z8U8}@>O8Kql(`t$4AY+88cr^rR3NDGruMkmR~>6Q)OS<&Gq6t*7gZo_;q=66u@%_2
zc{Khkp#I%3ce!l9VEh+bH<cVsTbt?75j`H(c{AH5GFVwthB*(cj97e?^iGvFC>$_o
zvT8;CsJG)+SK<G6W$u^F!pkQ^w^_%*sx%ENgCR+Q*n~n4Uj4V``^j;097t*DCswam
z4eG1)q%W1v)HBD<wHti{6PdT{&zmcL11PDDa-pwgQCu?<&r(4THhB6OB)d%Ri6L_D
z7b1%TFHS+J#<sxKOM2y%O=XG*7$NI<#{eK3_Qs0rk->1pj=|&Qi)YrOIr%w}lE?Qw
zKWSB#P`#<K=9Pe5Sb5M248xE`^g`_;JDBnG{cKQnw*c{~OeKsR37E@|iHHO=PT>Dh
zQ4Qhx+n@8aaG1u2l~G3{Z9*~G{-0WZMz{t>sv!Mwe@SLR#+C!%EXemj`6SS}u&ClJ
zy>OpP4lZHH3|BDdzy^qqk-|<knazT?YkEj8KmGk~_X)dQZ7<UoF?CLK1_b6ojRg&j
z?AD~0XzO~}VcRkshkABA?qW@Pmk*K31in(T*eRYa&xLDkbj=op&7v=NvPMX^{~KX%
z{niBhzx!`v!~{nwIZ_%y8b*r}N{R(YiIg-95EyKPqSB%?3`9T_3F%I07$x1cO}b;m
z+57Xk&iVfEz0Udk2fMawuh;8&Kkxf-_i{I$;L?=yX>vujf2@3Au{!W0Q2cdzd>Yy?
zz@vF86?=I4@u%0xJ;Z-pa+bgUW5&8&ttJ=J{v}pY*1$ucKI~~Qqu+Khqm-B#_ZI~+
zvjz1~H^*mct+!z8%t&*vZSqzNg&dW@<ihMwr@u+12tdV5-~ZD#Z@?x>9VznR)d>$<
zO2l){7N8jbKe>+hvRTNpzr%&!JANOh7nAjZX<#toegAyxdH#0u@{HEyfK^V(9>BDA
z|L|R6RWDAzF=C>>Da*u;!SnyDK|xlON=C81PX!Hqya1_aPMfWrKJ8@Ukd^gi2S-uf
z*ig61pM-g2?BDyfK*nIFI+Jh@)%JtHDo<kPcI&)l=Njt5s`RYQ?@i?c?!My~a`pL>
z6BFbGe@pKcLt^kQ7va&#Z88?QxL*Pbx))$?uAmr+D}2zs7wi+~5?72*w}Zn35gGk-
zd9d`>7wN67o3T4}s9oa8!YqruIc@3bg81cHG3sqy?3i)Z^6DZP?e#U^G5-AV&Ui;&
z5<~A`DuVvaWbXzG&K~6Wq_slZpbk2$ard+Bw*Fm?lpNR4n(&ECH8F-)zeDoNK=xsF
z_>h<RKIkGJ$mijjKs}DHkPQkI*A*^?Li23f+ZvL;&%rk!74(k#Zztpv7K*m$0)FY7
zh;Y4y=$U3szG9K)(tn<nQl;l1VbXE*fZX3xh(8@ib2i!dQip*Clj{4`gqP}gQ*Kz)
zu5}-r<oA{U95k-qr`I5<&p-U#yNVg<f{oQ<I*UH(Y`zb4nQ&IhVd&VTTX3d3U$s4{
zF$i2up&gD-HS-iIWG20_Fr5$&#vTj)YF!1yD(j*3{II}x*36GDw?-iM_z<fzb9th^
zKnctD(%;k7Y0;cj07p<m4a3-$%aDI<ILEYYg8xZ^XYZf=p1_THDtose32V7o8_{z&
zg5XXd1tlJ7{JKiMM#m_CK^X2$>A9>D+VDjr^D3&-_5xC-g7i5)Ql2-2wk|`tEYc?}
z-Gf>Ax@Ovs<k!2zcIzSUrn8){BsXyolt|QylF3u+);G!GrMcI}IB{|O&H6buzVX0&
zdCO0U>FEebkL=LD?kneb-+`mCJ6;DQ{QN710!Xm@E6XRL3FhEYY4&hI2wHxs@Y&tJ
z3<?Wt3HsVEo{;Y-J7gQssAEPBr)J4FI$6JaT-4Gw8o-odCsdQ(WJp<mo4TdL`jK0*
z6IX9Yb&K(_#Eki}k5PN#jMe0JHS2S3@$zw1-mad7kFDPD>|$vnwD`~=l;@Bogg7Z=
zKlg!`jXNuCi!2Kg_aN3Kz;2q5>DIDu44)OeZ4EzGiS69m_zeF}^(VNw95*2jq{ejO
zgSYPmMGjQ4-#?PKga2T($5q_q5L7^=wFEL$m32Fi!*i#{e>$;Hz6uU~;?_FXSjt4S
ziQ(`_FgTtSz&s=M!_W&c$IaWU$0tK<&nQA>4anYVr*W8a$M&ma)m)(w0~FgDqwbfz
z!bj2@KcC4Ny~u4N!oy6yclRbE5mqtt-x4muX%kdITmQX{*Y`WTJYyGoxZNn%aU@B<
zc)!irB{Brc3T!NhP+*{3F^xM;AP7@Vok}I5ZeQ?i3!dBj>YsN{2evjMs;y3h2Hwye
zT`w$a6<A!}go|vH7Y0%RH`_rN!Y8+OWts_|^UHJbV%tQ+C7ppEpCV4Ri%Kxb_6s_n
zE)24x9Ofs1#(O$LmFlh%L{172vV#aD3$|9=Wfl{>M1BZLK+iZdG^H-zS+HJP_5@8@
zp5Xf|`RJOuo$py+!HF6}?fs2LTFN_0iali8zZBu);|ie~SBSlUhM5bGCb_f!$!09B
z74i(Ej;db=Y?gF5eddDqzp{iM6eo-a9tAAp>rwt5SBr=+bGz;pcbs!#-<hRwpI|~;
zi+9<TV?m&QvRCT3lmN!^8ZklFVPM*Y%W~d)EB6lO440SQ)+tR)D{t65;<RtNnAY!E
zWD;0y)qa=#zgYl7-eu#)10#uKh^qTZ!k|Ip+MSb?xBdPGAo2fgxn_{8UGkv%3(qL`
z{fOYsksftSxZv%^G6xUsf<qg{XZrF5VqSo?wXoWc7pVs+tf~_g%H^!Yx_Zs_mr&)u
z(@`R%^|)+Bgt!l7!j1q=0r?Ny3cfBTsK6?oQhZi-8?KWm{oQ`dsCT#^u1Iw$N>J8i
z>e8d=zs#ITR{u5o*rH}AvhpF<EU%MX<ZqRZ$Ennl!~j!`qDuIahko}#gC@(yp~D<6
zGXVz;b-mB$2N*NyJr=z5NI{~fvH9d#3D1g#fT_Q7&p_-=r-C43ta0{R>oUfrxP9;U
zeRCZf&zjz<qwjQ$GzoAYpkw?H#<yudy>=G^Y`(wa;ml^cjeJLYxr(t4^}sl6s`1pl
zp`_hrd?Y|OdTVsb=iLd7s#9*=Atfrb6pZP|TyTX?HMSi4$;WSsO#luewwHfm2^7zf
z;YwG#Y73LIfe5?e>=|Ao1D$|>7ZSUZm`mUz<62nozI&<vw*1MW6X&#Psp|&DQUWl=
zxLUF!y)?7Yxxs`Ph2X_e7_HRiC(*Y?O9%SF5gcw@FFE#tw@gC4c<yHZ1e+6>YAZD;
zo$i|Bu8<RCe+;gxE1k@Wa<rY?rIJ^Jv_0H$BTircmh_;D;oFyOA!t4r%z$4}qkF*2
z{1?h2y>6PM{)0Sqs9;}2Lt8DwjGESuii$yppUSLY#3>=87X7nGJx<+>g_=tnQdAk&
zQ0E4WXEh6AZ${E8+@y3QwT3Zg*m1d+DwDfx4_<$=Aip-g>VDmzHFr$@2}JePtpaeu
z?>9L3<`-N$Kn7+9c}y{Tdxf<+!IbxV^+-7^i&a+`ie0YChxF9ZyRHztESg8OmrjHS
zzN-KNqBbR0bAJ{nL<D3048UO@CRwJzycw1t449)BnOP1P?isnh^6VoG!&lq<$mSZ*
zpbPcUu_AE5K{e&Ky0(?@!-h!2*I(S)T~<>GZJKx)J)P9eH;bC=g#+_^&l_G?UyW(q
z=Y+qKB4vms*}+-M5W!lS&~8RC3(H%DJ?aqxL~5r<D4b~@WuOdrHn?##GmX;)I@XXr
zZ-DEttmV}Bi87g1(Qrde&*dIFFe_4M(Bc_K)~`z=j>Dz}KSzof`J3|i@0iXhIg3^p
z__-j}xzxg|MG+eUoQ!v3{@RYH!JHJsdoY)FuG+;b(5?bXP-KvhMz@|oxsf&i`;W>K
zmozXG>)&LHD*NMH+OAsi(D6k&vU47DH`L(oq8W7cws*r6cjf3FL68!5p!wb+E%e29
zf@h^}=<kPWD{*tyB_CdFx8wPBv^mQ1)!3@GBn&7Fn8sKXO7B&@zPlPW!Vk=XD8!!r
zaJ2vUygses;QRg=1I~>WMo92>QL74j3h3%6p2RYgV9PGbC*{vN7!aG##gFBN6hDgR
zZHY@4^*w=)+G<fBdaJoEKYydXlL1REJNW4e{~`@5wh76?O4WeEKP2>FR_l+%i7pg_
zg><8pAk<1tYqvE6#gw2utI&>rE9m$kQoQ#!SCV?j>qtB1IAYZCxLHys^ublfGO~xr
zfa)w%PKc-cIAMc%^3}OvCVzEq8L>ZQ+jL*HkocqewCc~VY<IXKAgG48sOof(^I!J6
z|GNV8A`VnchhFQ|p+;}1N$=+r0AFvqQk=`8w=V4xI(JC9ytz4ZsncoazF{YzqxV6=
zK>ukMwoB@;M>6@pk6PIOIcl{c7MD{l^rz;018K|VN#40tk825g_?pReA5c~Tq>;{P
z3_mr!KrIKCi9Wa2EYA|XcH8)zqj6|`jbYy@LxIcqKB>0xt;Gs;`6GxwG}1gbu%zBR
zjybRRB`G2GUHq_*d5p7Bk2-fD(vVN4+h)5nPhmp^R)`;5`AvE%UE|nlG@i`vot26(
zwp@!_=>2XFA(Zm2@(;h&d#TpXTq-qM9NShHh(!92|H{!%{@G_^lP1evqPSUVH(}zZ
z0Cq<YcmXT@TKO*$6q5W1@V`Gsjk>)iyx^ejg2u1*(^fJU$PY}U60X*9oC7g$*%Up_
zrwwsrEOPXsu_WFv4Ek*l8!;}NL94h@*4bA1K>O%swydspSwmzUG<L|0w4f&6yWdHl
zL2L%4xpzFoCsyt5w1|w!?<3rD%IuPS3_8oWVOfGjvmG)Tr8RW3+0tomJpAaL)54P`
zcBA0IZ9}>Khvqj(X#ptdT*G2*&mO#u$uulIFT?Ow{if;lFBW|oqYLLlp;Ndnc<v%t
zU2b1dejeMheaJ0FQFUnOE<$pDMbmEu(n@n7KS*5tMMZY&w%WyBN&m)jE&gGHIYq8L
z_=IlZ=9S*Ixzt95zp9UJUTf+cYqMI$sgZnMQ-$Q}R#yu!<e~13*$m>zpDQg&JQrt9
zGcGeA>1IN5NBghhoo=ghMS%_$p`!&<$I*q=B9YRm71L%pP<fd^J-*vbx=4P4^*X0}
z!S|VW%P^{~OMB3+KaJt*>Bmr2bMlT>oe$p98T89Sj0(BlWwMV|X5aeTcdCp{VhwHB
zAD?l*RLr#Bf^<E;o2L*OhCtb}pYAIH1`ld|hYDnMaYO8wd#<=qZSZw@d~lCL{g37W
z&_cJ`)WS8YzqD*hE0(Zm+l_0-f+ZV%6>-7M7p(V;R{aVs(}lw*VV2>YVadT5w6Jq!
zS98*a7bp89w5JYD;PmJ_pF52+$ajUaqw3rgd-Dipuhj|h{BYaWhP`wabe`s}gYgN=
zSlRyVSsdhX-b0naX~Qh3?&cY$4CBu9rDTitWv*)o!3rQAupP+A_1^nOQp02VC!pcj
zZ7EuK!W4EEq`;7w89fOtHWn{(H*LPy6KP^Z5X^o8WbS7hxcKeXuoNL>ofH=<pUDvp
z3<YN@D2PoK9*>*tt1vNtBwr8%W<b8{SbPljsHS%EZhX=7m<(85o6lt#D<5axW8;)^
zdgGnO<G`xOv%r^tv-G0zT8D8Pq<B|jT96Pd0CN#ax{g{_AGy(6CmylV1I~Ur-DBAv
zwzxt05<XodZ{$7VNxT+f6`JoYtXjr+5_GmM<EvnXp7B?rc#$u?)t6s}DD>fb+`mUW
zA|c@GEiYo=Qu7~j6iEGM?$ZN9G+oOVHXCxil3VwCTGqcDQxZvt!>_9TD!s=plpqdz
zyYnE+?LM{cOZB4T{0-V+#7JeaA5bTQihc!imJGb0NvET$YsIYz((-$}WNB~YASv_1
z5w{L+s$|Y|+d7PFU7dublT(oVW}y-%#Hgr=W@5NP)I)WBr7njQe+ooDg`{?bqeH{H
zLv8<+f`stOl%J!EYdTgm$oGbW*{7*#^V+YUUka0<@#R)a4Ml!eaR2@uPKM_^3!Wbh
z@Z)NB3$(o{mje{((i<jh2A+3ghlW(c*SRLRk8hGeq&R%|1Vg|yuM}g6&R?$8*h1#=
zS@8$)GtWp9aeuAsOEkV>UhxXQukzoAa?ao3U;p>>_`l7ioY(5T0A|4h@(Cf!0a?Y9
zQ`0Z=Ra_=l5C=2p#)f4Y-0K)pplNxs*WTIPm3CG(aAH5_iqkTth3~*iUc0>Nm=vB1
zi<L)mlp#G{n>z26#g2$ZH#Anc;0DdNf<E20?>6{LR7$Sn=r?fsms91k%{ON=D{f=m
z>I&t`2;ybl24t)lr3Z6jb?;VG5E+{MC^~~)Mh`Lk;U5rEmZjV$WQuTQ%3CRyvw>aq
zOkKQ%{&HBIKe5dIPe?XzYxOOUMJq%#q8Qo5qg%}V=_3!_wOtE#t52m{n<r4GI*y*t
zbcp;G=D6udjvq(tP@9Ga<2oQ@VJ~$`yYPF7=r$8!Jyb3Fq&k8Ghsz%yeiQ6KS)+ef
zS9!-NR$TmkX_|aoz0|vIVYOEJp&WT1bJ=oHQ@E|G4PhKiM)l#aNoON>)bK|$;fBZC
zR>anlQFB805B$3|!sE$~B;%FHOBYh(!i%kYb8nckMZNWyHIzG^TIDUTj6BH`H7jzx
z-gcPLD3m{CLOQSQ_U}};s~w5w37Widj~Vdm=ZN@<`WUT$_fxKb#W>Z<>5@*Aq0ME7
zk6tu++`$LUH44t4t0=c0rcAmEkoEvp0aDKA=bsVK;D<?5J?tvs`w2~N(>XtE`zd6S
z+Ikfi!icyaQ9S>0@i6f()SSt0I0rWiEG9f8QxD9CR0oHg#x`}tUY%EYtOhV_4GV0q
z-iO;%oz}k`v;-EiSl_q>PD{?RU4n<~G-Xq-O6+2<4p_{;I8mb;eTfu}Cql6UM`Y*c
z#g{iDk1<l*A>({5+PDwLjqRPN%i=qVLm|t%SD`S_=={uV$C|It_ph6{+o-sKq-Bn;
zstfOm&26krSy`c)R!i^MK*A}**Ef;Dku)OS)%6IrFFbfcVK)z6X<Z4tNd4R*XZa3L
zm+(4f-A$Pu6f$Cqh!Yr;*L?OohK>(9%zAh2hG#&19HSy>G2ps;t`gi15g9;z`VH_f
z%$Q1ISN4nXXdCkScLNkjezyW~Rx~91C{+88>@$I9aT?hib`Ho8=#MHsuwI6vhZ>}7
zd0eb@SW7WDg4a<T`0(=kG>CJbcD&?*H}((_dFYzI4(tS1sP44&(|bQf@nk)Pko%s=
zY$FRyij_4IBkr)nl&#JY39F08a+Soz&LBz)GmC7Y5IJBL;d_6U2C!cW(b4~e@V&uV
zY};@sIst$n0b;A`M#-|OD1i9(WXjS+BvxoiIKy4KZlDUJdCi*5zAod!g+dZePyFq~
zB!BHq<8zII)h7TmvyWlc(mbsv9NM2w=v&sf*B3sZ`^jSjhA8FAxaf@FT3N_!uFp5E
zlhjWELjC6q`;srNAQ{mYh=|~OJD;HQpD+p(O??ECBf;OISaw_-ppW*qNgVetjdEz3
z(n!64U4Jv_H@#^Bz}HCRO-k&XS<T;zzxa2J__tR6{fRyWKyP?AIY(l&j9>XeT)X*;
z#y_SwKiUFiuwYK|xemaQHe=WyHt2tPmm{nHaLU#CVbQbDa?>MS3Yx=wmXe*!>q4=C
zZyMN0D&p^h7kNoa{<FRQwN!H2zAg5&cPqqt&KvjpKxw&ZaouB@>IBKq;Q~*tM+2Z1
zYxefU=JzdLT^C<chj@ZX`Umy-b|DqoU<cLk0TiZd*@5sfdivmRT`@mDcR@xKnR+4m
zmbrV4L!`IYC+pq*V#XaM$W7_Nd+7-y_bCV-R1{8DjQfaS+;?UmZI~g;#@|n9PR^Fm
zr1K&{jVjJdC@a;_4b${RRAY?m7%Jp?N;g){6v)WI8am$6nzVsB-#}%4U<{yNUmD&1
z#t3hsj_wCbs&#tp*4PltW0YIe(QNKn7M^jc5k%*|Ey#{XBs)jY1&o6A*^lREe*~mx
zo(o+Ei$wd@3Koq&oTH7+OU--q|IUPmlnIdnyqJJMH7|1s+5q;GGB5WK%*x+Ty@rY-
zwz5W4WX9e?lgeOKQbI;?ceiCRpj`c%1T)&;R_IQ}$*1p=OAmill523ih-`Cqz0<zB
z7#Uc*Tx(INxi<1z&R9^H_s*eXLPo5@`WX^Y`I7<9CzICgk!%93vV;XEsG8+D7~}%V
zZ)b-|ATs78p}m3E3(PSdLi?t*cZco9`g!Wp!ZXr*WKQJ@rxz>4B<4Bv8<%pWjn5Q+
z$2Rf<8hkYX<p(g1;Pkc#;wM|3x#Y#j@}G#0ykN6c>ZW|>>SIIDCnieEjf`>|a2`JK
z;8ZZVR#I1?Gz=Xp@vjH`&G&X(`(dp<Wzh^ZXs~IC8bzLEC{mior2&+my+!7|&tjh3
zydewEsDh}f`0Jq^+0BujR(X+MU(jCe-dd`f*ZB8<!B%+A@FS}WiU>|&=7>p`Xm&1s
zANPdh#(Cg-_Lb&MYTLw#!d%Tw&Gt4T{)p|GVr|_Qh`OJ`<1+bB51EkNZpf`Aa5FM|
zs!D!$r7k~^^!>^u**pRSl$$B5093*X2x3$Bfmx{N^QqKT5f`#SuzNm49d$9kYe_1T
zy0{`OSZ{*{`9YYA5q6R!l@_LS#wdo|yAiyOZEW7S3!dG$ImKW5+zeZM;V?;@5&8AC
z^3uCdr7l)!{ulRr<}`U$@#6k*8Gb{#8GHFp&33m%+WGs5z}*@DYb2HHz~O2Nlx2av
zgjI4~UYnnt%u{sDO*(Zx=+=$UVurE(;#pJ6vn?(ol?Lmxe-n96hWE^3!C>1p;5Y8>
z!QeWPVfkt5R(avL#GLK>p))E*V)1+2b6HA_3U;at?`L8FUW5Aci#C((!u!s1=7d2p
zXg&z-7Rl#n(qq_p@ruq?o<T=%I7JqZp4O;N;#;M<BQSvV0TC*cTc*Uacf?v8S%Kj}
zCDQG<;SWp#H(yro8UTh$5(sRLMpe)zW3DlM`8`B(Uay~9Srj6Mj!;4-1Cw+QR!^?h
zGKy^8g#z(=z~<fi^0^~qgElkgGJODX&>#&<U&;9rURU>*E&$)Iv;^4vQ=L>)vjotO
z!1dh$^an&A{dM-OvLu;Se8V$N5fr=M*h3zrF1!L_IiDH1{5H_`LJMS_DFXirp}tIH
zg&nW~yZ@>>tXPDQryt&;8XSTUI|5xyz<846&8+~0+l>1eu7CX*R`L}c%fo)>>XX6J
zIcMcXG?0{t`)8?f%j5I>CIgtK`05P}52!bn(i!10U@P5*ty^eN|9;WzDAuvP4)*1z
zTl(Ym3%B9IkwuQS57r1a6uB&Ut$5%4P%&j2b``2d8UR%D*DGu|vLNbM!~F*mgTOO+
zB_c;UpEQlwDbn7G_=C|>zd^gilw*(;z#T)3-CnyL;Z2a<2+kRAf>4Qu01_GRkO6<!
zg#hwUr9{QLOm}2PdB#Q)?${QtxJ`Fdk&%A<OiRLgv3z`;6plHy=;~H~Cq$O!4;z_O
zG+OcLQ>UnjDNAY5G4PCGo^5CKpK)G4!Us;X*5s$9<E#T?ywLCD>Cu(j&J2K;Th2#a
z9G$b{wZ^PNHi;KETK2#T%iF$BE(gXGMu$yDowI+NtVus)tGPb6ev-z45>Z~hb=a$Z
z1MY`K!pRBGlvydBmj)*#DS$YDczlKKIy{-m3!L);5?MDM!ZGD(Fz%euvVU3N`SYsL
z_lw<ETOuh5mr;AADhUYcCN4_LG0a;05BV}JqlGVIgO9Y9&qXn>q>42*`JMlUpaKA;
z4U-#HYP;434a?W_l}}FEIwgzE`{wNHNDPTaF6*t_&xZCW6Y(;aJ;ImEg}s!S0Ah-)
zy_+R%ik-ClX^LH-TaV4yR)fscFD{d!IbV~z3BxP4k0$n8e&tnCjvPp&9DEAw1Pofj
z)wLz&fN%|Mb7m{LXCD#4J)=fHt~WmaCxKgVU}c*zjA$0J;{0|3`cm;|>TZou^Gyx3
zRK|c-+6J-}$tWu+D1lFPba+a5o!auC_T62d(Y+|&a$^%=fUD^0wWu~2ifgEbJ-J#j
zqU(9oj&yO9J+OZX{-Z|bfm1D~e7eUOqetzuhmYJ~mpgY;ZOns8Yg*c14hiYke>QT<
ztg^@j2;wJ;*Q4gsTbZo>y#@IwM1nC~#fz7uF}TI4^`TX8=%`o=&9Q))KRop|!=vua
zuh(HvC&S}Ct=xA~)6QjgnOzcxUW^3(`Ahqwne{&oN1CMuNF6-LBY^k)tqw_j%56^&
z3}ThUodDAt-O`DJWK2y#YwgY!R`*+;7lu4=>jY(uN0S|-c@*(|HU{G9@4aLoCzWp0
z7aY_3A4~8U^jQTzz9%0<+myw)zfWn{9N$N1S5{D@A!P<}C*7D}^s8^-8CI8q8)B+0
z6x*A*ngA<N{Le&<ipT1i3!<&tmJa|^FkTiJ1Ii9l_#JUNwx7eECv~pho)KpB)R9>3
zK%=p_PpjOU8sX5)GK|Lx$P+%hR<;DsFnD(I!iuF|qc&+#SM?CkVnQ}JY^_lKq4y!>
zRtfWE32n=J=EgWm%UUm@rX{#~V0o*x+gSa<G=JeNmbb}5^GT>$m>fVQm_KS=UU{dS
zZK67<tn%R)WmxICz2Wb|ZU<e@k420!&fCG!Y~UFG;;iMpVMBSb&Q((A$N&l)q;Qc3
z9B?WK1Ip0}q~MvQI`j28|LL26+gY1WGqX0uyVRb)k2Hth1_X_*|7}?hmT9&mO&QKs
zK>Wp7`bDEX06+Q|z!)N8_DAF?CMg~#jcsW%?J}cikzB~Pj00pQ%JzhSPt#pLSt$|3
z`?nRl{qhxBLn(Cy$t)Fm{wxIzoCY~=ki`_mXHhF?PcTsaW5$Yf*}3A}8Lbgx>o;h!
znnnQ!qFWKzF)f7q|Bx$Yxlh_VP(GGYFS!u)rCqO3OIfvva#wq!d?H#68m#OJ`%ym!
zKtxga6rGFg5oB)4pN58LD#yw}s{67t6lqpDV0ABTLIE}WOv%{cn;F@75$UN{I7VAl
zYL2s$gH_f|$DF)J0J8ufv>%qC>A2PT-m2z<Bs7U5is2pM@sQ9Uxyyy*gES6RISZce
zi*J=WY*r!aO6$FjiTE|mJGDIT;)}T3g=gB5BrV`gvOf`5N;z-iM)av}(cMP`bChAQ
zeE$4z(HQi{oNIm=)?G^!oawCSHR?{*(7#rwckSSe<sL(0i|MR7zKqIBVliW=D93Pm
zDRrC08n8dQc9?Z&m7j_6sBIaS-iE20<?woHso@JTk|+P3N6i2uQ?j5C8r<w++<BzN
zJi{5fw&(U-fU{(zazvh0$Vg%+Btt@Eb@f%1=wWA2N|Qu~jb%+!@1Nz`iHGJeWk#Qq
zmkBYOuF(9s?=nLRveUeiGBYUC&SACU$E5Gvs^DB=alu!eguc^6d@}GY01Gf6V5^6{
z4->~<hmDK00DP6+QY^xc$fboX_utBpMot=#IyL_Eb?e&!D^AkLIdVV}Tp2?G5rs%}
zZe48LeBblq_#_{R-8{Er06w<&CaEN<=?t}Ve#!V=G5BiM?6c3C(?W(b&^}ktJFcrq
z9KvM2^+@g9ym01%BKDa`7n62i@L_ZViqs|$Chrt6@+Yt&%+RJ@aR2mc8++Yhx}@2N
zf}M!J>Y@(l!=0sZK^MVc0EQOde6nPaX;2^TowDz_>ta9)TPNeWg-6uxcya{$QUB3S
z>-xo1>Z-`jmDDC2>AtB|@>)4`mv)Ui%cWiy{W|}>Ann5-=wPL7k%Ia>6Q!dAV~V?C
zXoM$vj$K#-ZUxM?*r5x!NjDXmZL1p2$a8PW@}8~5XqjDMkZ4TbeJ01Y`J>&G$a$xZ
zwYEg*lClS#YgR79BscP-pOFn4+RFW506cRY0I_--fv!w<pI$=t1~gdRv&Wt$9vern
z$2)}{BPOB++f8Nq;~hyuozC&_%@!Yca7;hg(=KuRNj$WnX-*>`dfw?dGtGSYQS3nb
zovT%*mY|{+(|2u{DDmbl`v|n940O<CDd&)vPcD@2Q^o`^l}+(QaQkV-)>&*Pt3pq_
zYvu$Lzdl|6w6|_tkc@T0lvj?ut@T+#BIo88eWs_ZT_t9?@4W8@tM(s0hYkvZ8(>UZ
zAIT0x!CCG@x+&0Z-4)|6>zK_~6FieTA_j9f&xTq)2XIycu-$za7&IK)4S?<c*8mui
z(VzMk=Ucdd43@}<db!7^sOEV$pK<4A2Ab9bZT}di4b3K#SwHQFB~jA0H{j~bRt}Vo
z1V2cV6x#mZGAni5b<c0Pd-j}I&O}yj_pp*-`Cc``cIO<Xg(agbAtv<6{1OLdZV7L%
zHxvl938ausi{7%BFP;HTVdr(9V`KeMvsRWj{r=+*oP|Ub9?5FuZ+xI5D#vu~tPsV9
z(|p$b!XoQMw==ZnDQQtV)L75Yzl6E$J5HzXm%jU>bYCXjQcud`<1QFqI0Zd-X4hwW
z;EVFM9RGP<xdh7zyZS;`)U;fAwp})pPsx#`UGSe-?f6MWFv&ss|7XSge{j1H>PHI|
zfUH2Zw%*vI3zKb}ziAz6{ZjTK@c5`?pVdGmxf0cF&^`X|LiE)CPDG~3o<~4}+fH>`
z&2`-PNDIf<KqrU8)unH3OHMbutYgLYh~tI(9?YNug;IK}i(=VPNv`YmxtiH<-;);B
z6F%m$0#L$LeNXw+V4MvSEx@yb=2DVuraIs5e~Y2x;2`SB!Qr7SQ)F)TNF4K9@W;*~
zzRS7oo%^Rg?NkXT^-pR?T^W(VF`I$MMl&;78C#Z66jR6t)9UnawcnA5h=H$9bIs%U
zS{Iv{>E6Gi(|=s;o=Mkt^EC%swI7TI77%{lFMP14@5Z;AOUZSF@~qE~6hX|urC0Bp
z$+F*;kw7V5l&DaKwric3-5CNn*&n_4kHXSJ=<r1?m+Qo)hPEP)r`F0tCo8FU?T1e7
z4vO_>ELN!z5cs3ID@?=jSqxwAwsKQS{G2)Wq6Svvw@XrO?O*sOE$JNN^(Yx!AKsPg
z*hUsLl|C7iOd0(&uv~QdmvP#^*S{TqI4<f3Y)c;#BfHc=x@a&2Z5`6|9VFd0TYVg;
ze{bbtW*dh1=Q#4Wg5+XfYXF&9(1Mbf{a*|#i!*t){i$r}E|}20$6!{JV=6Z2T8ExV
z0R5<;fP-Dm$fgj|SD+EkZ)&Lyly5j}YMIZF;&=b)r8SSt-URkY?MwA43v(0GM+%at
zEcW}BZ>_RSev3%|M6!EfKE-Xj+<6+fjOa#FwJKPK`dZdTds%}!Z#TC%ga*grc`UwW
z7*_^@nIr_$@Xx%fQOAmvepD?b!&~lO<|e;!^1UQ^#x!qn?hOD2Q^0zF)Z?zdN;shU
z{4Kx*hEx%Ay=mWxk^B8c<kfz0sn?a{kMIaPj<L%>Hs2OJ=9@P*C3cjqR%zou?yH{t
zMYXNTH+9I*-z@2!<cKLtzX8~kQLye?4|_;)yYy+Vx}c}k#^EpE0|#H!+Je|MTev*-
zqqj6=ea$s;@7HICe+4XxZ|8SCvzWi1HJJ9%do7ClrUbp%>#9;u2j=^5oo9ripw?aY
z;yyOdM7^M99H(koM}%Fu7Z?l~n9M3{>jxr2=pIFqm;@SN%cWv}l4ABejbCzJSzU-a
zYQRCf@{fV4600~=ECJ}!2zZ%7x8{C-fwR*1#GaZw6C?P1;??^t9U9%xC(qQNt!<`v
zeS`Ziz~88^x8@a38i@jKH}h$97EtB6LAW0b4t=Lb+c&17g@CGwA49Hh3}}@c<dWZ^
zR)1zHVH@4-=DP3}1&>}S<m#nX4#8p#QBJ_YVXcGBee#owPtES{Z5U2&@1Gw=53roT
zzNiCtXLiFOgBJ9FR09I`%8v5%5I!f6d^rUuhXe%D@s-pcXi~du{bF!QM7V7|%ulc`
z>+L*_5E8$*6HTW<I5Gj|_D)PpQa<SQ1pk=70hsDM!_;>J>6~akfwRm{>4mT%KZkww
zE3KfF75T<iB<s3-fz2C9P4)R$f2ha$lYeja)|I{Z)KSfgchJ;4pvyAMHNa*lx}{=s
zFP=pBSk-=M16KE@^D+fEvf_CLW;hBxCzf_Rj!Lb;y3mE{GbbuHXmi<AG24UNi6O?s
z)rVg8x1eZ41OK=q542_WHDD}tUBo(aq5?W^uR=@ASCD2|4-8%GjCfMks8%CrU3QTv
z5}*Kipsi<QhTbtUS0{w2pPaC5GmxYZ@N{Vu7Bs65NafzMSsnR!)eXdR!eZN~N9>7J
zclv>YVpdoMz^$rog`HL@|CZ?&G-~rc3`m1y+NELHONv%uTDiu8(%XJ7|K+gE2L*he
znV0N!ZscA4d$-*1XCpia+3~UCl%tt=pv~bpkizEcj~QrM3?k_tR)SW)fC9`Fu;4U1
z-Qxc@#J#@wKe#l<fro-&2nzknf3B`ohOA`u37ylOrZ}z_W!OZ+z}SY(o%PA_lo@A?
zU4+z}yL)MD$uY-_TZEGTXyoqin3C8kpgmE!ZhFHSzuX`ZTozltYzLFHEIW?HaxftN
z?P0S42hQ+Ev9ik1?*9O{(Sh$vnxA}Ay8#G*Xw<%~GrC)R`B@#1|FP*ICEf)_<_FGn
zWLT_GgtL~NuVoJL)P_Hel<m$47Yv5A++!(aigm>qy{UX>R%8v=psm%`ZwR<2eoft_
znsD;@-rm@g_Q?>I-4#<=n2=n)Uc}1eXN5L9Lm*m?&MdiQ#!yvLZ1Zi^3040um<tuv
z<E+REJ<8sbW5p+m{hwn?>AuFt9C@Te9}DZvr%M6Znqs#?!Ok4uiZj<*jVDy<#ji?z
z1!Luadn*oHyg?rZwL%A?EPWpxwV$T^qT*TO$?no9?nVl6Uu_CJVCQe0bS-B$cyJew
z^k?fud0a1e=y^hzb?j0c?eR)@rH~<z|3YGDQ9O1w0^vAQ_z7aeDWzXquSEJqF1A+w
zn1A>%QO>A^*c*vc^%^t%4cyUsgjl|!8zIn%zx{~+?B{uPNm1!bNbPuUdg<uS|IQ(R
zo|NVg+^!+D&XOwEu2^46o9JjM?i3tQt@~|d*H=)_<>5tyjtk0~lB$=+>C7%;pEm|E
zT3yD4h5y5P;85o`o^GQeK-(kNwX`yS*`c$mg?cymp*Wi1aTIzQb>xtovMl{)U_R&I
z0NQxEDN-pH>FD>W)^9H9w0?1q?laHMzt21rn;-`>$E^D-o$oP~WaZ@5r)|c!?APd4
zxw}fju;9N^zHeg1Jr|N8uQ`j~)E^l`q0JrvWQpGU`AB<@W8*+Efa8t2Kb-&ipQ+$=
z>Q>S6H}4@*>_V{)1P{svFBo?Frg2t6fwEb;tmEoKy1tx**P$_4P7;(~hHUl;LA^HK
z&6T5zd|4Uqc^a5H_HNgzA5C>#+K+&fNq@x24eK^hY5QcXJyLrseku_so?@ekHfdwN
z7dr4GNj1N%Vo38tOcm+X|9oP@MBB4DlXiL7K@z?M9eVR=RlVYx*IV(|`tR-wufj%j
ztEV)or#2U**~zxO<!DnrXcqDDKe<T)ZG#3u@AJ-G5mc3`O}!5DzXT|$8Su*scf$^4
zRGB-L1QGQ<Wqqnsav7af-WH(*)n39gbe$+g$g03tV-K(P9jhrSMXMfERP**8?TG<n
zmih5DOyu|j62ASD#1;!BD??VDSEMUAzuxqU-yzHNC;b7gCP%M)f2gN_<m&hk=*a#p
z+Ip*u<|Tw#8R@_%xOj+5hy3Vb75uj8?Y+hdP1NsuTY^yP@tm~y%th5@=zx34bsZWk
zo8(7>meXh#l}=3XLK{>eN>Fk?u7cJ+m>z2#^PkdP800jvkyva+v=F=@fBaH&e6C$0
z);HmJMEM%K&#2u3Rf|u=bOc_H$s6;HKDKoB`%S%wJxy4aV)7sG$RyO_()gpnyyj?=
zZ4h^JW5RkV?Dv$nH1qL|;eE=i+{e4BpR#OsztDV=4%X9tF5u5)+VJdda9Wt(s!DQ`
zjsnD48_%S&Z=4EU6)USLEa>d<Zp`<t3<>M41F8oqpe4ONWCeCaqzE~<iHs14F<*)@
zXUJ|z9IZxtd6z&oXaTj~$y1O9PB;A#t&i}mESM#pH`tWLyv}j2%=R+%rntt66ecTq
zasD=${$CH;cdni`dP*Zcwn1PslIGrnl7_}}Czjyi5QdDiRr!f_ey-xl)-iVl@7A;L
zDzK2_{3llaBeQjvxrRA8!~=1Zc0r>D#@C2CB`DI*X)fQCd6iSexZYCDO2StOxe=O0
z`Q!iHw9?Ejx?=zwlz3S@mdG5u&3OSDz#R04bCHY0hFCo0QbMvXR2)zLn<Qm!yRD|I
zl;`2YF&NmK0!JWralES77UNL-kTOE-Xma^tndLcg(`Vl!^A6nh<-X(gTtvfkOg^l!
z!Hvt&y=uIZxS2c|xIwq+vp%9auR1kQ-2HjdVY)L~lXbh4BP&n<u=$kI@$<iggrwLf
zO1<va)QLh8Ezv1IyO6tl@WB3&ixmF4vbKShI-z2fmZLUTnSY261~0yj+?hS1I;>TJ
zA$mm}zlb<K#^2re$fMBk9*|FcOo^Ww?H|c-`eO3P{da;_1hhT;tA8%@di!FHsM{;3
zJ5y;cQzA-+vMCll(3bBwSW(Pg7iv8maatfXwE<R1AuC7d(W5QX|FmwS9tgJG0cE)Q
zKE6q{D`UL)xhERQ8vTg6|26F_UwU~*K^)xRnV&%<XF~va!7Aw>n)HvpY2yHYilZWw
zLlhYteQ73Y%x!U-_K|MI%3Gb7k~S&5SE9Y^NhM`k&vR67eP4`Fqt`%6LNF2H@%#pg
z7cLRdbbltl2}Rs3#K6GvPZTl(P{lrbC<}t#_q|3-W&dX3nil<o(tS@=bsWDhTGc=F
zyv)MoH`#A9wnLd1#;o}PW0D+!H9p_3mC?AnueQJ2ykJW^yUD=XH+Mp30)cN`A2Swp
zS)TJ#++bo$BwO?UbNIRVC*WWgtl~~m@ESs!TQNJFztM!rYwy6Z@=cfgA#Jkd@bvzB
z9FY*%wn`b7glTcmXX$F1?NP49VL{A7=T$H#4-WeDatrlxc`nFhC6&~?;0Xvh_wkSA
zr&3t}NN5A%-;&rB30G0M>kpqBcyT}3g=8WR*<F-P`2m{G@R^L_D5gdsi$@NLQ~<BM
zs0|5)1;^{4$G&9p^cM>fc;z4n2KBt1`<U)({p!qId0ARFfmYVSW0XZIxptRa^~~^!
ze8eO?4|D1Fs_EiJaG-o|2zB&_@_=eiUL${UuFI|Mr5-OD?=9ESvCPG!D-TLT3?s!7
z5xaX{AQ-CJ@nf?qIhER47a$DENJF^Y1Q@2LDKR!<sWoCazG;r6+pOf!d?ju0koG?q
z3tupDM?;7C1P<Ps7<z}LnM_X@BzZd}wy*&==GWr$6JG!9)ZkB#zg3wo0D!g5fOuL0
z$m+mZ-h7n!vA7+Z=1zyF@?W#F6+H?qw>&BnRC{H3gy08(IpL!?(rD3Um|-??kvb6n
z^9hsFpZS+Ho-CZ<csdnr!OiDAWL60~@ZM2qF%KDj3RyugkzmfaY~X>{bR-{h7(K&r
zm)|V@dkbM7>cK=}@r3~psRQK%q3JJd`_acuAYkL&6#wNt-ng|5kur@w@qh(x^(ya(
zm_EdT*pPqSCWoT81XYRNPSAwL*o>8C>A;?=#~OL)t}Z-G0>yHF@bCTQNx9xXi-2;4
zc(&~CrZGjq458ygnp*>vgoBLYgP~U$@s)<bzZJHW2GT~u#woLY9n*7Rt`g*_t}))x
zCs#=RJ=MIH!|<{0HgqRWU^sSA?2y|-RfSZ-{jcHjP#jj|{CyCTY<sV86-JgdTR7ix
zDhwB<ENT7_!x2r<G70)PeSKuML6q#}^P0kttWWY%B}XfVf9aQ8RLi_9)Nb0pxek5q
zfA)ox$!pDfR2k;|MlR}<bhVdY1?x902A;oCjCwXLUfqhYw6F6b@HKh|P<&T)s3-6G
z7U&bGW2Dltr^4K_@t3L<vBG)tv{4(kr3rKdwVq3UFqjv^E*-$^(#qncDPOu2RT;$}
zB^M<9cDgK-6Zy7H0qDoje$S6puO2<l?M2LTAruFb)D_kP3pzq-!SyObC5qM#TWlFe
zrWjFhJ^A4LqL{wy*y(@WF1;7sVwifYc%RV$obu(2jpCwulmI3TE|x~zZ+p;2de+O$
z^XLs?njFMX9NO=p$Fs9i4tqa%I%|zr-B}xe+ZO4o&9DV`C14xJ$(*|%p|x)wCgQ@!
zlA`;B_VqcNvwhv7#$yhmnxS{z?aQsl+ohvN3;TZk^Y=4Rw@>?tM~y@t(e;ASXP)Ot
z0bBy=YDCY}n16cSCh2{vsur->{7C}^MV5~_SVdJDOF<3fKVzO3^Y-l3DE|v&!^GxJ
zu<JqH|6o^5j|SnW)XT0kX3q5{#{XH|@lPZplvhTbaUN}!##S90a@x3}=$k7-OEfG4
zn_wjkvzC~R)Uss<E_utUfs(ee<EDQ|BK*kzs5ZCzWMlU->=}oZ10ruyx_SG^W*K00
zs&9}&<4$UoI@rBzJIt(qAJiCBuKv(hXDr{RePyiM<CO)_@n!z%_0RkMB(`rMI(@kE
zjzxpL{e*O%UF03FiU%dQ<|P~(EXTh1<ywT*AiXQpQoh&InK5JL86u7sa3N%vgyTjM
z*r~AMJf#ZcRdxEzU4r1O-tS+i5Y<aF^05FIFjv!gkcTG0g6F*c-ChqxYVME86#MZE
zGUGQke>5EBX$)TvAY?3S^;v37{+wYkU!U4g{#~NnV1e4$qyi9^G9(g#@J3(e>7D??
zMiw=jj{?4O=4+tUPc1>s*JBHxn<~UC5+cDA6Q1Kr!-}RZFIeYZyjz@=QbO2r!mAlZ
zEg7v}Mvf3ay=HKb%2yCC4QtfoZcFO6zC2dt%Ti~F@GuRsWyf-TCJc5IA>8B8{Y=AL
zM#L!QApmSf&Tsbw^E58dpxK^<$0egB8Z(?Leb?xGD~Ji>X6sNDVV`6$nyoPVDy1=Y
zZBlYz=K&UC<W3LZThZ56AxtS*HrB@(*Dikk4}||Sc@Qo%A)gE$HRLn8$%E8>W>kv2
zSvA#SWDWOi4CLkLy7Ts}Xk_7fP&JkFO~0z$_gjUhJ-YcEs4B2AAV5kD{EF8_d)$<(
z<)J)KPgpYZ&i1b|HH|x*TDMBxS=wD!GNkI*zZ6Y=P;8-DoTyp#_f~bchIDrC4)#)M
zPS7DfMfj^#(8mg^%hWJeImmhs>sWLCLf`Ga%bi$ynvokm>%|bexwb8>=ws7eE=~!p
zII^5aYHRx~cCW-KAw_gsNMEkQR&jXvRjmco<F#jH#MA4W0xk5l_{={`JN8t(!J##@
zYJYH7mnMTNbej%Vk{0U|`~ZsrrojT&ua*LO3B|jd;wzaz_dSM;(5u^P3f~vj`oXPR
z6e2%kji<67+WUih15W!|OxZ&VoU$sS$3~iX@MkQ}O5kB+{&jWpGwl2cmDOb@X6dM3
zMw}gMghbGy_SJ%80%^zN`88&gedu##Jkd8XBfLlfoxvJKMn16t;A`wQU2~3iS=8=J
z`Tzp2+oaSTQLSb}jyGZ86E;Hvw?1y!735Ux8yD=f(>X`rttRMq5X4y9Tcs>qA}p9P
z84r3qo7r^lMPNHa{5f=zAl9!t>_RbhR_;<(goVBq#O=gaeC@cO$w_WRaaE$!`npA#
zUIHPXTC}C^4o{^JkibGY|0HdqMq9A|7sYEN#m3REqnX|i)NZe?Duz6cdjr40kUsS*
z$9OY~&n<OnPogAc9<An*W$v7F@U5Nok(uKi%qfebIF4GKk>!}Ko`#V#PcuI)_P4mi
z;+xRaAz`((Bnu>T+Zq=PTs2lCd}7#^Jry4mxYgmCwY{>d5t;#JEe>Ym?dn=a-8N{I
z{Y(`<^lkP9QWx%Lm3H6jBN<W|^!3RuKJD7II#M|_6L1KTyvf?Ke=TJ9bwRWUCW$D{
z3=$5_v0=W;!8Fl5UV4hgmW319R6wgy5dd_lsi(}Ew2GDYRJb9#3*SenxOgnyZ7uK>
zJgQGB#Qx>aejKS**8^Rdp_5xLf$9Uk1&Y=Ogp{CubsqCo`USn~J<8)*WOVy1a`5r>
zs}H+uSB<IwSMn_=QL*dGYQo_w-^9akZ=J_gCzd8|-T>-e#eGGc+vgf&K+1K4qIc1h
z_f`Eou7bIDNjKwlwTwo_rx#ZBOF5dvW<+W6uF5Zc+?a2ePfgGExr^U(tU*B|?;9yV
z?eIdeHsZ}q?d8*H&&u0{=HUZMH=v*U%lh%&&G)*nA&m${95-WA<c$b2y^riS0Tx}R
z*pTI~(q74SoCCqi{UIzIE+oa&x8|+#eu*(-))y>9EME%$b>wTW1T}7OQ^h7oB?D(1
z5kcmo2~yZ^xFj7PO<~e{yA~;{CjSBr|NU&<GQK+}`Be7xm!LR1B|Y_2GUF+U`q(CR
zKzU1x?A+sYvY(pI>q*qFW_KqN`!chMuLSv^PB_jr|NeMDEyBD>G@S$O=BrKSop-lu
z$6qjUt(l|J^FoV#)rDQZRz2<bjTx*C$vOBU?O3(aR!pMKaB{%w2;?8iKAYI_XCt~P
zx<`=mT0gQcgk_X(Y1O+cE7~S(TQ=>6GSObfyDelrbL`^pwN8h*e3SPh@x+CoRR3lv
znT4|Wgk$7D#-Bi_!<BWA*h-2#Bl;q3RTTdlB{{t)FMc!N>;G`+ahQkr0nqj@v>Pl1
zXoGY{t;pwMG|W$j5_>tRTz<t?_CTGhKIrIFRW`V}ak|1V;wCqnkfj4vv26Td`4i>>
ztuS(XtK&Z<zxF#8Cveld<!u$QC1bSIhA}01<-xlmlvO3R-B4fm&J~LFfTO2MY8&fQ
zr73z<zm6?Sh=|g*PeDhgM{<F)s)m)c_{4GcAOC6L@GVeC!;S;9q?>GkgQ~!+X*s|}
zG60bX`wr&gjij=_8DCvXLkr6?PdkQ)4-#qwd=<mLODEAiV34EwZSu3tX=WUg1|6)J
zRpyz0XDT7E-WpkuIJJ1oB|~d3$2pyIE}~jK;;CHhmtyblKA}`EF5?D1kQ`e30Uw0E
zCOOdANAM8E77u%wrV*)Ml|HHAR}iZk<u6P%Z1^Kw;ez82K(9G|55DbPq~Yl(5x*Mp
zfy0J2{SWCyM5mvl9>`aKlz1i~5;!==dD7J}ftMv6BMHRcdpG`5Rm;bR+7J@XM4;%X
zaVk*BFUUVKdA5|^lhN#7b`RGZ(WO%Kb=W>aGJmpRcjPA(d7u!=CxRjgoaNWf8o6*i
zA9ZMgZKoW^-`UiLTWSP4Fvng7U!TO?V0^E{{$i6Z2r=^ThJq>}<6hKh%8M15PTf|y
zbWSDWAt{&Hs{16=B3xy_mNjl;n-ToU&;n}G43e$~`|*CDQ?@sM*lE^Er&3$V8a%ez
zE(7cNnygE2;FJV82#T<%rF0wq)$qW23F&oIQl5@X0}V2=!S9AII8fzSv>t4d#1MV@
zdH(nKYjlrw8Djj}>;}o}A10aBLXK*e==I)6TrsV7s%iQJesNXRfL`UAkjiVe6nX`=
zw@1eB`0Q(jE4GD5y6hXwO843pH+E051c&|GGI=#lji6HwLX1D|VZEgw_a{Zf&Gxht
zg+BcW{=Hm}BDK@vYfa2Ff-W2;-XLj7M&sr!gD?5?uXpJL1n+TT>OyMFF*d2v7PoRN
zy<EhhTHIo{w*D@$>8mJNz(H=x?PD2N%u3kImvuT_(kCs#O6t^rjAl|%<NU?GTFb9>
zh}d<`5y><0OPtjO!#uL;gVa0``VyZ95<Kq&#fO5lW(9<p1rN+czsBc!?@PlS_iNS^
z2Koiw=rG(?<Z2(51rcZEe1k=y!^jRED(A2w!Ke*ULqCRapR;qM8@25k1!nP+Wo?+0
z1bLs`E%=gU?^isuR)MN7R-^2LGAun30hI+h!hgXb(pn}OeJ`%@vf%(sVXJS+O!``c
zqgsprs}wvvUL?k7#%dZg7170{ZdU$j&#uI>whcH?PJhS3qRkWJz}adiW-irne{L~C
zIeR`k?M>bNotluDgli(8R^1_X*?%}nb#v_O<tw`GpTg~Vgw!oRFF6*tLoI}h;r$Wi
zsarpoTHPr$P|qYnI$5SFl0(Pnk3r&&JIPl}%CkZ`_y&#!x|M(VrLzonk7#-ftp1+c
zuR|c+w>}%s**Ch#>pPfqGkPxE&{0c<^7`BkIe84Qd8#OH{?j1AU!CqTw~^onzpKY!
z1J$wvIYpLGG~rAu0&B!**q#^m{f4DkYg(SIltT}_PP$ZyihYCAUq}NZ$7N!PUt>@Y
zAp5g)BB_F2LV;VVhOXnU#8<?RZC)Zf2^A)Jd+1~1A&BaA2JRK-wQ}Z{mw8FQ0(e(P
z+I|moU_~&a)%wq?1p>APozk*iWo*@b6};jizh^YQpfq`xDGBviCL>aG-b0IREPqyt
zQltDRrW~s<Vi+-ss`c&-G+zsdI^7Ti_dgTJ)BWfAvrE}O^S)EvyZUx)dJAsl@bDXS
zaFxyYVQqf^Z}2_b%R=|Qkz4a4xAu^}oP#`#+UqAF3Y$btJ=zGdiU)m3B=efl^MWR5
z?ccJw0YUvZg)d9oz_CRhN-zz@qs%&v&!j{X5h;(`(2_DzPaidWYGp`?wzuv5-CxUc
z%vY+eG8}vlpSXSa`{Faj=d0drluFEN!splD?VVjBQmX96?0^T8?>Jwq6m&;Z!OEE%
zySN$h3fHH<Ke(7%T44HjCHKELd+V^K|G$59<QOqxq_ij{B{@PEAs{g@>6Q?Q0VAYK
zLP{hhhm;BkN_R=u2&G$K6GnHQeePe~*L}{pzu$BIWbC@wUOeB=*E1f$$O7Z36jmeq
zKJvp~{bP^I3)<-UU@UeZpitjBaH67qbS2>7K9(NfaP8Da*nPo~y)Qd;N96&8rN+pr
zJM!dCScaTW!05AWZSknW=gZBRVP0NXfSD9~=gF@NNQ`ZY9?R*6x}4=58QPaW-+rw0
zl&q~}^Lf(U|5P!EzHIS1xaKxrdHH|bZ=DxNbd#RPG1<aS*+o@h<ivwF@lGjU+NC#5
zQi<%|v1uwU1Fr1O`Ymci9OV61R`Lk`gVXZ=?$+FP4`1tN&`m3G4CoE-&yz+D?G%JX
z?(;n$cMsmGZQaU#<;-~_FNbKdTFDIPiXQT+%O5Yy9csE2g!JCm3k*){avzp%HQKyb
zvFiS40*pNf{uWK=O>k$3IxvZA>+sRk@7q=bGOy>GE?Zuc6LQ653(8+HraI(S-;f<3
zu5BV+%V)U_H;*#{CjK-8C<Zy&Z{R1`e*w;E`IQ&`QUGUJT2gTXv8yo7(Pg)s?21y0
zd3G<!g@<qA0EeAa6I1tXPw9}enajy51H?3BX-)y!`~_{p+zl^$pM*P!W`a|e9azJp
zi#N^8@?X2BX8%PNzqJ2mCTgBx%r}p}GG1GeA6S?xL;H>E&xlj1&72epc@iWddaF&+
zSCZF@R{_G+$tdz=fW>V}i|}~e@Z11yxtP&2k#y9>yiP3Y_Ns-M23{5?Cn!a#cs&I!
z6+#3Sf;T)Lr;>l;Oez!P`!<-t>RowY3}Hx7nJ{7OufBMLS8-Wn!o$XZL&<WpH)>P9
z6bU=2*j@*2eQ?9mhTD~REO#9BHG-U@qVsTPhpXpRDTS0=xG)?N+=7?re0=?DvT1>_
z#v4OwR(l&0&qv$f5Bd1o&9p)Nb6#?fchCWIV*&+lu+0b}fJ?Yx|2G4|ZQJoi2*@H-
zcwdieVDoeS`Jem6UL)4_&0!5jfoyDC?^RY(0cfGuAg`IRJ;{qB2qgGhRAnI{+V#Os
zyti^q%3&sDh4Z7KyRwGi-w;<|0-+A}@I6Xbz%{d(1IR8S3)wBSR<Y+qGR?*f>X84F
zD?0HBaH!_RK>(u=^Ekatvhonnu#>Z#UcgDyTd-;Wp;A<`hHNrWdskeE@Bk{L3%v8c
zv;d+=xlf-AXfB)*wg8mVFI(vf%$HHD3-;LbH<o$#syn0FSuMCU&$(5wM#LC>>>gdz
zs<0D!?iK-hWSB7+580mJv~W+1A68OZ@0Su1achGKS$0H)&B$f2D)n?H0qahv#+&W|
zs)T;OSvXb5wNP9==(HW&XW>aK*c8|~5or;lobg273J)o1M9%#27^$`3sjYuYx04sP
zL>C&<n((oZ#nj^K-gSNG#myl@je!jJpv59`qG)_&h0650Z-<9t!z|!nN8kJkoRGW6
zp{p@QL;-vx8%vq0SQn>sc@PxF8WT=VVKMG`#CkcTr0}zo0W4=zR~%sBg%C?ouy|;H
z8|h+qvC4B;_d^@#EGJ{%7{0-ms|Ws>ac{p#Z9_fO%jz$m#EX}7NJyDv#lA^{3q<8X
zeAwa3&#p}(ZxgmrEzAVvcM0u?xjK>GkI*15bl$!D*?OC7Na;J4OfO9@kYe8+^g$+E
zQ93<C;DNVcBAe|{_D@)2Hn<OHe)MWeS5rrjeYrw0*DMnWDt8$_$^v)TsyGU(EC5p<
zD>Ts#qm|Q^G&9c8QZqYz3QnUgO*K$rh$N4s=>Vj3#$h*b!M0I}6vbY(B8dsVmAyae
z_EBV(J#_6PhJR<Q(0|bl_$@&2-fxfHI{;l(Oq$62BS3?$W#aGv;oOkfQG1tiOV<wh
z=dG#u=@$sXz=-vyQRp-2ZI`ja+UO&D;#;y)u!SC?@DIf<L$`;OVTp>HVg#%1ku6=}
z8LER8Y3;}F#NJf)`kRX8sqo>*v#m{#<~6C0WeYPs-;eA(#$Uz+I-qAC(j}Gq8Lbu<
zf?ZdUr_%OT{D>ve>;i8Oq*zcMhv9jYyq5#7<GQQDvU2drD}wc|t2e#JssM~9A$qNn
z5T$V>qrgy*`CwL|Mxn6h&4gi2NvV&Jb)@Ki7--;g8of_=<(wK>ghru1shW0+&C#i%
zhWC_u-mtp>xB|(Wc7C5F2Ndc@^C_p2b2o5__t|AE(NhpyOaAP4uKbX14?*eUhEY-D
zGd7zB9Ym^Dm9~GNory7inP*Leo^$Is?@xQ#LP3H4+eHuL>aSAFT<i}fZOD`GA=q7O
z7J&gb4n0Fx2wI+2`b+WkrzH)~a>%hp+Ag&VE!%dRk#@=YB1^wXPf72}lp`ozh8gL%
z(DxO!0p}*`v}UiUO(@+C;v#6*gX0f{HksLzY}NUSlj3^Ff)@fRsDsxpj{E+WNCEy<
z)HPj8gPnFgmdF-6JBgn`UJ+i<{%sE-{aH73T-oJSSEHIO8(i@0@6+RaQsQ^lD|DQH
z<UO*upg{ox-vc-P_O4yHI!6!+*o)J2a;{zlBoa|iiA03u@AvT^zfqzAG$`PAb)e9m
z)M99UQiy(ezx!O<`K=vgUap~nXo&psQPhO0oSk2m|Ky^#MJ13+7P=XnbW#i0)bLNm
zx#Q)**eL%jF9Ao9z0>yR>j58*nqd`LMDFio2e^&3VlT7Tt!23mWTV?|=<(`v!7eUL
zIspI35l+vV<wy~}(sD+?(E9}PNFr)zQTK#uV2NX@Pws}q<F`1=I5)?gc?0$De);|>
zn-*xVQ?$-_+`nRzW{@`#0VIQ#=1h2l6l+e5W=X>5TVoSAf+~+^d)TYz!CecjH$K<B
zx~B$n>IEe#uocB@`|~XtMsF4f|GG35`6tl}_PZF}b-{GD_aarbX4aqzoPL_N(HBUN
z!;YL1!>IEFiHwDf$!sNaCJot?>Tmh<8i^-5Wp4B(*9HUu#Ge<b$}KYooxNFr&%R&o
zKjH37;XLZ<>%2TO|JJ9Z`fUJym#KAtIMV&t=li#N<h|nX>g=z3jMJ{J^Eb{nZ$u+_
z{7ys_tchXc9ntKTTZeYV7g!PG8j1WEcA^#;!1(xhuZ0ES^cG?TJ;?e2y>+|E+}Kvb
zf}^BSIC(SaL4ii$O4W+Tvs2fa=8+#`j-zGT{evW?=2S3>Wf;cgoSZ!^C;@ONZWfAR
z`@^4aP+amyP8rp>_(^NyOH0_cPafHFzJS+fx+PKP(e}>~E(ubh;KXmcbn-J(A6Z}1
z!MQ4GzjwwLkh6Qn?~rYB0UW}~ek0`e?kQ<i_*PXM#Pskh4!M2x4Q<T(DL{n&fOUGM
z*~lDTPl*+y2g1$@OcG==U=ATL!Q%Mg!O?)P?>om^{j^RLL!Ydmq(&_^#4erkKm4Nw
zdByoTvi9xVNKlMI$e(#OdGoi9auu4|NJ>Bk7zJLWm-mpUJL?Ib0L5)xOLPXPZ7k9$
z*PNvhp}%Qn^_b>s8x!KW%sJyndyTEWQ9>iG72dmKt93;8f2C9!w2^5n4+wDy01g?}
zOJd$n%t(NFd#yKR<=dvQqSsc}Sp1B4oIBg))gJTwilK;ii?0@-AxdzWefX=tNQ@k;
zRm+RwC*@DNbYoMPAcJZsOr`BEjBxg`A`>N9T(zt)vbiGcHv4g{EQ8Nm#D^*=KlZco
zhQX7Ut%T?#macu}DMLHX-G^9X9iN9eGB}N$zWlP{=OL1^y`NL_D+SE*j5H%CJF&WL
zcY{+R;|Q{kjemUwdGxbK>A77R1YdAvzs7D0CFEvR=PkOR=Tl&t6eMv#D24-*2l3=0
zlri(B%DHo*6}?!ocn4v;a<u6%UijGbaM&)fWX~M8C$aG8G}NlY_Jg`yh}IES3dFEB
zT1soqE%dAA5tl^j?>FDL+M5ADsxvI3(22hrHl;YQMgGv431b)Mo086`^5Ii)`^JYQ
zdS$nUIMP$zUv~}Dgxwtv85bX`>CwIyX`A3p*MeB*ca#a`bqEsNQk2mFNUnUwQJS~^
zGO69=yxyV^>cSE~>cR4zY_D?eZ0yFu^26o#eA<QiOtKU?=Y$L%DUJw1P{^a1sjF^x
z7e=nSt9~Fs$y`*};bE_`T-!ANt!X@EKoXOxIr&6O_AJ@shhgiMlbzhXNag-1-HO4^
z6Mi?K^Z?=F8L7YeCgerxiD~DE4NJXw9Jm{KQ}{@7Z*;VhGdsRHJjIN-lk&}Vk~Qy6
z!Mgn2&LxS`H((7E68l?E#MhdoD-2hs-C<Sl4pB(1DD^gR>^MyqK@%>~$!$s+jWD+o
z`Nn1G&$ESNsKq#%TA(7{KJ!F9x~5mi7hT**2sUmDH-ARNtXI3D;AI}v8L|S=z({*;
zyLmz0q<TU4@iJ|SyMe#C|2WqOOz4bp#UzDLZ1Ma0v6bpk7Ax0UxeuEj6QILWJDm*V
zkc;NCTqr%}A+Mm+Hl5E|VN$-O7VHaL0(&hFb5`#vLEA#kmJ2<q3N%bhfrD)X<+9A;
zi+A!SJ|<_95M^Mem<AUn!<Iqm^=Yl{*KLA4LxM^yoR9wU*ZXm2oyJ_g=n!AAzCP`6
zYJ?*4pW@P8HlE}-2T(W1PY|?Bvb|8edsPGx;$&+SN_(P6O|922TRw7m1c7_*p9j>q
zKKR1)WD<-Cau9;QS^d1=))tz1LQpxEaRi?cSeF28bL3|K+%uV}al3@Su=u!F<X4xu
zHo0Ld^0YMUY<Slwp6ZoB2gk>s!1&I7rh_L75_cCkIA^J%8(BQNvvIL)qoeo6*X7@!
zj9>w^vBe44WE1Em!6NsGc!YhbcZi(ssnHBqqFD~))K8<!@#YVst88IzK}(JcDD706
z_0FEmth@a6ptjp#s#hJKv&^Q0#>_HP&eJ>DKMc<^m!q!P#H{{`;^;Svl5w?_vHdIq
zA$)BcL>Je0a5NGR154O`411nV{<*4^X}IaX8e~}65q4^wQyrFWb8iZ2{g`*jKH+4q
zfolu7$jBCUr-taV<n%PP-Z!mR%8-EyTGp6Mq!4ixI3bO88Yf;LtHYqW*?+tl!f-8_
zw)6LJeC5{jN~gm-xa~wGzIdbp_Ud{6+i5U|dv0oY{2}JC>p>tshX*XT+y=H7we)}d
zeI#lu?^L97^RFzYB%Up?5jboDabd4AFF_xbGBRSSv+dcS{{DxjnV!J`bB||nmRncu
z3PBU=xv=3Pj~|C^6*ez1MF*LewEXL$t3?v2AjkpK@4K9K>0&5f?ewOo|IA~y!dI@p
zF7pfnMeOGO^w`SX-7^Th#^~8U?YOnoC03m4Nk%_3U*vIc`tp$ZBjZg3vTMIcV(ZU3
zvYNQ=j5^=4(7@6f%l2KdFzKU!z0Z0emNq4RLqvYvgbJFG1y7sw{K50^J<03uA`ab&
ztfl(43G9h`saGaF7q*+HO-!BNj}vazXk$InP)Ya|vqHYSVRZKAjqm&b;iIVRxISC8
za=KviI-N<W29q;P#^li0^lOrOAR%lgLu?ey#iqQg`IYOHrJT|Wtb+!bLz^rnV4OI{
zAIWSzzdebOHsS?L%oyaFXLqXelkXgg7nK(yaKIJB@9y8_lc1;LB+=|!!}^r%Z}0xZ
z9HzxXT8a*E{RWv+0p@qcUwb08ogWz5SOm=H$BU6glGtJ619;-_WsCYdaN@}Ix}q27
z_9v}0vtuR>!($>e=Vc!q`-VE;u(lWg^BdR91RN4x=J5U~CxEdM!bZ&2B=;Vf-o!cw
zmAxcDFRn2JE4~lgXtXBoK=9dP?LKyNP^BKxWS{*o`Rv4iXL~SbJcUq$Zl6B|-Ekd@
zlY*$BwY__ta*qDUDr4#XA_)~Fu6G&s@eoGx5Oq{R!neThgOqfjj;NI<k6<d6!QAtx
z#&G@DYqzs~K(I7ub#t4%(}l<izOj5b_*{3qgkFqr9Kom9J~TVIHy%_Qm7Lgf5Of-}
zJKwysJBwqiDS=QkmXq(MUr-raosYTwEXJbcJ5Mt0Agm`pLlU2kLVV>u@Ktth$mc^v
zB8ybhulV26aL+G;*;8surWP1rM@}ow7UoK#4TSr{&D6p0I$9Tx_vSUBd<kSzoCJa9
z$mfy)Opggdo??A<qKpGQSm~;g7r+1EE8z}G@Ms{rvA>;OpRLZXW+*vwvR5Yf`!{rV
z&Wo@m>W4$df6IpW-%N?6U_v|^K^RpoB(3zitoe_{1#GkFKC^RKjC`e#pJmxlM=ZQD
zfeH9$G=%qZZrL}j;vm??p0r(=(+t>*L>!%8Ar133#mt<9m}CYXPq)LF#>?I{-yh?y
zR3iA@z;JnLA-`}@!xqTphb%CNbm0uom3JmI`9)q#AcA^6n5P%@xa}piU!X%)_dvW{
z_?>Iw>de>@SKoM=6=!&yY;&!}ieQZY)cr&~ZQ#Itb<<kX@H~?^ImfKfs+PvM-|HSw
zM_V7v^&Ph2fNy0Is_!l9V^0h>f4BPiCd9LHN?q67_{e89UnXT0a6G^R*|pYq0fk^R
z9;+`TQCxZK2y_srECuEnol02H1h+(d(FPIQu-$3LK5CRA{4vci;W1lUZX23{WT(*i
zIIPOyO*`)hUaJ;{)56go!J|b<KeYcg)Jb|`tB!qPv3ws@PXBt!F^nwrJHy|yx@U}=
z#@zc@H&t1i4z?rC$GWT?p}&7OSNHTFl3#STS(70qt%Xm@j$(^vZLMj?Wr`68eD|5n
z<k+uqW-mdo%=qY}_=j-LGZgem?9Gr;^E)o9-TiXR#3hcmrpEX4i!VbV4*`cZP?%o<
zRW3K+0e+klg{sewA8Kt?1!CyPr5cPxS~>{ihOygeYLn1!{%u<VOuIOXphz=0SS@p5
z-%GZrPv4rPNZ3{?w9*dviz6*A?{o?z$yz8!e*21ql{)>xK(#bGx(LWeX>PMLJdCLf
zY7PDC3*Ky9Sb~L+I}{u_zQ@Hr!3$TEgr^+8SYm8Q*_Rz$T}DnJr6hjR!gKgeO}U)y
z5{PQ#aEv{X-`OAF`-!guE%_G=!GRhQ>iM2U<aPNmWFptZGO|%?dO=IU<t_2KH;Xr+
zKx%{U%6z>UQ_Z>UE95@QdK$E`bu>p~Mjy7Dr#-=SpL-8}oepjEYJ2?23>&d*FQEQn
zs~G7v;h1@n<(n6sA$t&fwT*m9)}YGZ6HWO0Leo+(^ovPl)IGozT^Vxn#DJhAtMLjs
z7Vpsw3`K{LW>;Zd=GNL~xO1uJm$|Gft%Ur0mD`6!zAoZWRp#w3i4veaj=Y$EvBLYG
zBhV&J@}?6&6;g@%RsLN5s>keV`}_F5ZNqot9DLA1uh8-E2-)faoia>bw74>x3L5Mo
zr%n+lT^uFVZjD7Pi=S7tHucJw01anPz|z#UFe^8^)ZhYdvm)r9iPmiC3{N=K5O$uG
z1P&Q$wJIY^gQ1BF%oLQ1u2XL0w#Xbw33o??td5VVY2YInPut?ja71l2rX%5b8j18Y
zGnYKX^Ld*d*=SEs50XL+@6iz)R~tuAeJcCr)gpd3p27DWaL??=ufJPL=l=KT<+GRo
z4%U$?fHFXp9BlUPT9uLo9&=!T^hqKXE$0!}s9mK_rTwUtK3@Le{W5)rY!ygll7bi|
zpQZR~Ab^nT;wvUuI`L+k+flx>C;!V+y$__`LJ{bFx)0i~1_yyO>yiT(Oh6zqOAsI&
zCj3&)=HszxQJ-x#NAF>|xRmrsJw_9!Ey@)j6@4!kD65|zn$p@Fxs}iM)r<(QuWjQa
z$$$(qew-Vq6xE9#nq91BM%^J}QVI&+uM{p-D$9Rj$#>E_^n9+h0K|f1CmSBI+&)oM
zb?=UWtqM4X_vbF$ookw3=O(^09e+{8bid2T^n8L^qa?Pv)vwLx*<<HO+NNYYxW#<+
zSzo}j9sjVEBxfhrs>dadAMh1t>K4+px=~>Z#q5e+JM7r)&EM39ZarNWpnmf}Cm<*u
zb29#{&B|v9G5$*yqOty)(kv8Id+{cB{qS$L<A9L-N{7g}njcY<cV%Er%$wv%im5<N
zzG2hx!GVJg9=z@7&=_K`6YqYuvhlrW_aTXCBFnJQ9!o0Ihg0`2U=2^!*2}b=T_@p4
zxm?hn9Dl}`<<$c%A%G~*+?SO7(1dss!z(yG!ufhxK0j>d<-&W4MEYF6Q~2cIKF71o
zj7o6RnDV(H(`eX&1<4<0V|LWy;$@J<6OpyKK5vZ%1&I4GP`0A3XW9%}s9!t43IJX=
zo;IdYs=;+U)}>oa);a8k2wE6AMx5EdpSRG{>lXhz&qiCInP|sy#TT_|W7}4ji^1n^
z{#o_9?(iiO?8N&nLYuOk$Sc1Iw_~qOHrDiN0%O)X_DG*ypJ{lICX!eZO!HfNs3WbP
z=GHoLfEYuX)#4+D%z#_e%rc!V?)?CQ6J$POXKEWXC=yx>i*>rgHj^^9#C((?A8upj
ziU+J}e{oqFDc9=oVLHH+p=fi$v2Dd=OHvUqnu<C^wCJw;nY4d&tgIA27WX)c@zBWv
z9Y1odcP3Jr7h~xoQ5!vf(W-9mN7e3<Hi_MN=t&8iO{`WriMcad`g8hBV!`j_CtUEL
z9>Hhe2Muyqe%8q9bUfa1j=Wdk8yiz_M3R1)d`R2G-2%l^%F$_A;%V7|zmZn0amwY+
zvT_hgFQ}|f=x;3C9#}Re*uQvnPcXCOGyN=^148HhdX%Kxyh}%mvJd7NCSN{v)_Kxn
zli2%C#8L;H_0zzDRjC@*H>Lhva#u}Jx5^itkA{AGoAM>pp&csQ6u{-2F0C;rfyXvL
zpo64uc=|`U9Pa$Xqo3s>Jk>NE$O!Dv`Yy(mllvrAhKYyRRXp|!tD7A6G1_pppwpk~
zR|X{K%d5egZRY|;tTnDTzw_YtjuTI-k(8M~3B7m|+@pV0q`2`!PtPh9fb`{#(hq_R
z3CkHT_T{&I!8Q_ge2c#GLFS`OjB-JeXO)+S&!zVWNNij;h*|mYFC_tHGpdly;Xyzw
zUC3tHhNm1{B5#{UrIPYybzp7;eljfAKT^AkVKSnZ7V6nr{d?pt<+&5hK*N>W*1$)1
zn>bqq$s0dK+3JxB_!4vM><Tmdq!+nl*P;gWYDnBcAoN<|ybg}~Z=zS_X@l{*@=(lQ
z?SC+5h5MLcim$=rxD6hrT-!^IJ46N3zQXkTQWLB=3HG)XF=%@C5P^k%srYGu<Q6sA
zT%V9^552K@(WyPUdZBBB=?(Djcr~(3+3Z+;?Y`<*=d%!1yy}tzo^L^`E@Q?|Qjm3E
zCbX>)Dk1W)I4p{k>U63|Zn|YA?Bqgtn7Cuw;%mK}yT3t6>S-p6M#*1T62)_7$@~9e
z#P=V|wKi=ApK<~RtR!}HsJ?3fXC(x>>3B{U=dr7?!YesvH4+UKJDI{hc&~J9n8_~8
zE6(4b<t_afx_R>;Pq=jQ+}o8WA*BVuN-ABeSITLBgFy3<>DmwYf^Z#-q=jsz)r6)<
zC$G^X_g>fx(g-)M^-IcwCFdulRhO9j9>_^cw8b;A*<qTd;jAxUU*Owsku;=8J;tyx
zW-F{5y$~30SqY-%c96GqWe?_{+b@F5PRqg~X}H_!5phpJky!`>Z~c2|74S5))<GSI
z$4Z+vf6{Q%c-k1*1yJm(Nw}`|)S$P%Gson+UUI%cgxy^>QRU{b2oS7%i!RuOO-9kr
zC_vESoOsDZScUJhDQe(5fy0VeFfeC|QYEIAHpfT}N}DI~91t;EJtB}JOuV@TLt(tw
zhdRgwM_N=o{j#$w`G6>k6kyIv^2FD*V%78=9Y_|OKO^<c8_0BuATX%O7t{Ch6ii*r
zSv24w#-Zl_Za6{_+~82@<c=a^WjVE`4c{0e3pdoeKu(#>cO6(bq3TqrF5T2ppBP?e
zQ~KwC1y4Bhsy;kalz}PHXk7BLr=>yCbM6XBI(*tyNVp~cV-~slHxVj6hcquJakVWY
zH;{~GAw+*E<o~435%7B)XKyQ~J}_}esxT^MJ@Ax_I8w}5{<Ee+;N5sjHgzjC+E!k`
zq3#{K2bdif)ORzrz|3H$FlSUx0zet}=k~0=21VJCeXr7DyWD*Ky|aTa-brVuO&|lp
z9i4EGO_{6Re?-kt@oLu{1{ms>?T@Zt0fIaosU-JplVxHY=&>D-HtG&sy73oKdP2jo
zJKg|0uwJpj;2$-YkP{7pH>}<?lvG?TSu3%;q@m4t5eqqK8RH_8vy1$<MTaYbTx(fG
zwmgbz>-kXyAehEH*)B`2((^r*+@1H?9L8&;_6A>3A68xO6e?!0S(b)97j^l9PX6-W
z^H2V<b^c5kDS%J}98$8Qbh&)O$7UYTOB>1m{ZV0nn~%KPHe<&r`zG9T{k=%(kJxDo
zf{*nf-#VP-K1*LI*Ns;aue%@`R_WPo*urzLw|LMJ3Eu%5qq26IkyjEdk$tb@k25(}
zZOWi=lfn%?P1hZP>UO=u9B%2j+P|1*?wB>1V0XqGUxs0Gpeo^@nJdke1G&08Y0Kel
z_A=qmv#;o^E>@HnyTWsA6R4C~kxH9lbAS6EsD!@WeJ+TA+)2W-UfwDE&S;Li&t}%P
z@MFjKqGcu?{e<zQ?76~d4$YtU+v6OeDYSB?eua~pl1v2gSK)?9>CNH^Y7;TA;&7Mz
z5Yy^7yN$Y3*D7|Bc^_;)>mx|-0eHzV75!D_eYuypJeyKyv;-Tq@*vy=@3{#pXCe#X
zU@cJ8jVplj1Dpi}ZC}h05FtpCh+QPe;KE$#n%uC{->ZE5TX`N_>>naaOYp|iWgWNJ
z6J+$~XJC~&Ox}d)VG=b(a(J000cTr<xG5EK3YibcRJ(H{CMp(FtC|$zY@k`_!rkN?
zmroThP_M<=(`QR9+9f|26uIF}?2JU^_~+{*JCfL)Ts=oIzSH&Wsz}ASLEv~4{H>0+
zD0WU7Xn!b+$$!c%mfblcT8s9K5Ie%N9z-R;3#6tPx<T)B*u6}p8vZdCZ!|ysWB;m%
zOTks{V2^BqTeO7eN?t&=`N|=%DuAO#KD-pW*IN@el!ILn#=Z8umymryTqn~X{-^;{
zg{#3KH&Y_KR7ec3vygl;P=}t?RlaO=_MqnGakqlR&PTSviS19bTL_xO<frQgvi8M<
zXuiRdlPx3(YO#`X^3Q*eqjsN=oDOQGxf}En)k5PA&KehSc>+Yhvv_<{fVfY;wB#?a
zkrmK8wBi2|rx`f>BQW8^Viy#ZxYnW(dBp)-^TJF7EfBGZMr>!0{|iZ$|IjR0x+rY(
zql8sfhPRpbu)-o?xiS(7Q<n_T0IP;>n)iRHFzH*tJ*z7GFx0P2yNyqELxxXXGV~Y7
zI27p**m3guY`it>rcz&;i6S%aZMANFw<&&vC{a5Z_sRqp7qLoZJ7Z4gUcVrF;gV-D
z7ZK(%M9S?DMswJv?DMf=<vmT6y(1{chjbejuD?Ezjlz*lVK-k?I+O;*D0@+vH<bF$
z*b~7_=BvEyaRr}TiGmps)2b&s%pVR|e%dJiG(~3L)tvsc-fR>0wSX_$ra^(@R7KIp
z6p3Q!*@go>BgU5}CVNcOm!lvuW?mP#TY`<5{9}*g40xvAIB{M07|3rwCWq+>+O8!j
zd)v4=F}9qN1%qP&4sf*MA0%$xH$;E;mT{rNtwOnmvh4-2kUknckNK{BwsZ>>r<nw-
z57oRD%RO%o{vFAoP0m`$88`RyOT?&|qFkohx?|{a1g2`U$VMT7#`|14+Y>}@P($AP
zU}4$QkvD2IawMxmQ7*S_rTA$P5fV50G<g!Q@3Ec7Jv^|&l^x3+_!hi%;P#U)@Km)_
z+iuGF@Rlw8<o?v@kcjU$u_6$R56jGczh8{B6ynS$-vkPVPMae^*#=m$=8rww-X{1w
zP9}PCZVn}b@#z50<u-lE!b}sl=fc(5Tp+<-bVb`zj-Txh_z!#=_1=A6&vc5^m9R1)
zzj{UjFU1!ye5t$5<aiV06TwEQ@BdD@@IO-L|9K~Zl4OAvFw<=zyz5Cx+DblBscdvn
zw^~l^a5Z(eVv_1%$n?N2e5hUH#6EH$0bD#r518WI<w~Ml4J(vn9Dn>XOflS_!)H#U
zA$(@?$MYP+ptG+5bV_efM>j3b`@hIh+7y|j%T0WZcQ4B$GYuC7GHI%UKdXp=$>dMu
zk)a|RXzl_9eq5XG?g(mg>pjdWmj;<YQ*|#fB<LL+okyH4{vezxE>XTHV7gC}M)MCZ
z0c!I#_2|gAP7T0}ynArXinqS^?CA7@V{v;+D2tUxm)5LL<I#}UDiXRy)7@hPMh~V*
zcm$`urbV348H0OhVtVeU#B=MsPcgjH9GK9k2_^Ix%Z}Rpk@U(9U2kmKNb-qyAaJmY
z+#crRg}xnZBw`(Di!yco^pLL7?=m?4P4g;y5#X=@o_{Glhj2%PEEmbk&I0)k%t`eP
zQ<7aOuS7_*NpHyZ-(3g+?>EJDJ&N=jub#GV+p%K9!;wY2$t){%T9k>|s^;A59w5H6
zACgQnjyX@hLVt{5c*)OT$mL+3uc5I9&K{Rv52i}>`z;))j5m-2vZy_9QZnNF>j_@M
zpoU((yFkttTe6|rLwLEB*sIR^+W8^|93vh22IbUF7D(p{wb^~fpQc|mkGxOc<3Srg
zyl2wZEddW2e3dZd6%}Se`oQhN8Pe;LKOmj_*haw#;2Qx(Pr?-0j(`dJX2q&_9dVO~
z3}6xL37JQXhc^@M)<G;0_|6;GPt&ZurNvEr|M0+bULFeE#Y^TsrF#<gF9z}dd%_6&
zPdacR6!~p_6tI&=mDQlWqfekZMpwGenPJORi6Nf(lbfA-`mQd5?=oXv`3K$&yC>mx
zhYSV;UB98mXW}NEbe92*tcAP$Mtn^t4kh71z7-L!IriUE%JW|EE$NWG00;(hV>HAv
z;OO~F>4+}jI!A^&;szu$G87CLl~fqN$U-$ELwOPW=)8KelKR?Ml<GI{ud;+_YO#O#
z81=n?L;k(+Zgv;^R5A3=GrB~58bvKN@PTQnV%{`dIMT5&)am=%nO@n`CYTPMF<Ho*
zweql#%cI{ZH!c2`GKJ)N)ij}4D>85PG8n!-ug>a8IMFN}vXqvCcp-oH6Fi*J{=O(4
zj%AjAk2u|+X7^Nt{gd~MXlq3$DM|v*{G&wvgSz5J-}Ut?9`QQze{!_1xw#PY75~^X
zN!gF^n&EXy;=bMb`tLN_{}qSlAH)Fl1{fon?z`Isu!4nWkXyvg6bgz@YNmAlwwH;{
z+T;=(`urm0#sn&mEbd3{-m%AAZ`q(k4nYjX*vrdRlbF*>chboXy7YIX%S9z6vs^;G
zQO(RU^6?r$EtE*bzd~+bw;@Q8-zJ7bFWl^<VuD&)L#ngKdO^kjhfp;B>}MNGnCWXz
zWR)d!k)hj=P_MgPAm2V@s5It}*2N3$o@nA}H)jK00u1B$@Zmx0viWe_{%hBHts$sI
zcSEM%7Q0_2PV^Yuz?%u2nZ@=AR-9J=(F8M)yn%0%P^}+H&N6ujIc11@TK}@RSr$pX
zLar_UlE6WYw!u6&JFM&B%nPi7^*<uJp93={lRs>!a3yt2@TI*s)a0U*T(W(-`@<If
zEnnOFY{i(d<m4UyPR*eE>G8lPLbT`r-~7qdKi=~@27%e$PWYX~4jX#2<liY;|4-)q
zAKhDHQ5!zuUdElkj7=CRiv3st$TTPC>@@bD<GU6OBzg*}{VDWZ1XBbds}EI1g05FH
zPxsG->{htLv19>bT@mjV@36Urx<o+^YoN-mOPMKb*{G7w;~?XedtATX2Q?=`kbJEq
z^wL&a9--S~AYV<gnan&0@-~q-7kMYd@&kw=9)JmRL!!+3#t6>2*-?|~V6;5}jPscq
z+VQn48O$3mzczd;Sdp2*EK?u<l|jla-X%5w-}8fenj-H8>XW`5uQqrYejvr&BEUG)
zzxZKzRusHH{DuHcr^k0WE>NJ@@D7nh#PE01VSD}iUO~L$cR$0!o>?}I8gGK|=@!vT
z2aZ4srlUwbeWQ_leKyo|)ojk5z_~61^d7#~P`qa=YF9@Nvl#UM_3Ynj3;yc~XWm1!
z01kUMCa<~P`uS*K5Kba~jW|*1QoC}_!1E~^Uw_lcHrMPW*IWP+PvFJ8a`zM=U7}aD
zH8p~-23^S1?yXfDb&Qx3hL-O@{b_g=1zmb(UF4P1Se;APe}d%f<&?{3;OGbVSYu<X
z#TyP+r+PTxrr_wi%+1mfI*VL1YN8(sAcvIPDxv6Q`XpQ)ZB=$lqI!M;xbsWd16VGg
zs`W`|@whm9MVX-qFxq_I`KSKQ^1y1c?)vzj2DVqOthrJm)W`?;^22+|0N~rIu(4}K
zfbpQYdM5hn_p`dNz|$wRK0JZrSJSq!f|s<Dx9}E>=&$)^&Yv<|^T)S1jcpR3SIIK+
zmZwd-YN`mxoYyfcrdH13w;#q6{95DK!kpBv4tm;26f_6yWd3AO=C-5>WY3x1*-?7Y
zT0&@Fg3mbiB|8r(@P9QXH9v#n-zixCbDIAr_d~xB?uY_#NR&FJmNQcwfmOwu7ZI-#
z6V?DQtOiAUtv7qcr`!Y%2?N3Hs}|m}x&Y&E!pqSRWaYR-HtJ@tT`n7SFxCHD-xYZ*
zt9$}Fe2(sS{iMx@;l7DAX8ER=kk?raRSturb3P92zJnme)cG842>2XW6}OWsc>uob
zE$*}n@NxHT=~wpJNqEf#4ds}cbwU_52v$OLxS85Mu83D<9Di}>-{HXwht7$B0}<A_
z1ec?Uw2^PXKbR}7uqTF`Sh@0lhW=SPc#6DU(c*<y4Iz5RB>uJU^Z&>D?Z1C<={b3p
zD4?18Q}t~}RZr>D^RF0A@0*xqFU_l8WYW|tECU2`>VTR3`_f9Tbivn3f#*boXo;fL
z?>HC#DTWb3q~ey`k0Gy6kzXc;eZLUi_#_)x5&a8C$F741TryBR9RM}x@j195T%5}-
z_2)ukz{56t7@G5Nl-U;}V(|e)<cDzXc~Pixtuw&aeux<LfEblc->FrZt(V%eDs?gY
z_)A5NygJ7Zuk9)Hk(E8ZmLi17FGu@W`Z)Le?Tr8JY+v|KXcTUlfDQhN0X?U5cS{^g
zDcxya`=2GZlWjQMT&BJq8~8$KU;NMeig6Dqjqo9qUXsE4|0{%||DgfT(%`N!v;12n
zh^DIzwv7w?d0~Q$rA(Q}2xRO0S<O4z@R7C8HvlxS-?a!juLr?e|B|~xf@@Z9!_jdy
zYs6Q2)RS&{SttsraZtlZ03qc#-K}}`Y5XOGrt<Ao$`^#A%_y@X)`)e1PCJ8z0r(~(
zG?9?WL=Gt^J5JER2S5r?>lJ&(<CVSvRru|DBTZH(zDL~PYA}C-uWdvM@B(5My-p7*
z)dT<mc4Llhi>f4S5!7(kEQu+f<)fqEKnk1|L$lW`TfS}US+?sK8^V_`>y<ruL}n$3
zsvqOM=^!(6nM_bpZeEJyUD_vIqVid?hOUcmSx>o&H&gCpYoC;i7i#<qfc^ii(l;h=
z;sI36>+14n2vkm*XKP;cKC+xyP$aj4&a`?@(Xe;Ix`<KsG%ZNh98B_>O9K#QZw^3>
z5Fr({!mi-xk~jEFx3*UaWHp@sg3=Z99RW4WDwjXx!;5o|fM#_09PAT<gU8>7DAkRC
zd_fDE<lr<Qd^@SjE0}`_jTe4qlZDNGuMB6Gm)ik7kZT)Gh{kC+NlT~<&)GLR%fj$R
zp!WjJbMaM8+P<$DK0xXm{!xD#bw6|(&j%b%|1HT2YQ-<$CGZP)4QPs*``2hI57y~O
zYW;zA7~3s2Qs3d2rUU45oG7<DmYOE&bQu>A=7p90@mf~0KhCCWglw>b2b<LrdgxD|
z_jyFYb*kJNy?{545%604g5<ns<oo{rV<}Z!)Fw{?GdVq&B|yy*qe?_nT0n&8G$m;Q
zOuMDSkJ^s;K!j9S>m`<YS2b{Epph6h>qf_iu`5pKnZ0{CUdwu_o`nLbO=3i(U-}YP
ztS})r@hy?lrz8j;hH4x%gYgvO8l1aJ95+SZRGGG{JKP3|9eq56f2Q%AI0FMtRBI)<
zMLn5o@gtEl1i;uG-f-c}<SZY*%Jx72FrQCU^^_ge)6sH-mqlsy>^lm@UyTUmf5zRR
zc3UiWwFxj1bjM~Czn51IYJuu)cptZs6|iDwnl?tt7)h17aqcbLu>s-aX`-}PU%Y)^
zDe~jnTcp1>3~#zxKUIAX0p}yH#rxzF2yPA|H5bk))Sf7x$}6dQoGAW2ZFw<dkZ^a7
z0)PztHtEt*TrY=^eernKKe*akaK1+?m7@SZ!22&Z^?wc6|6H@SeGx#w0f!nz_@M%S
zO<6E?(QD|8g5vOkE2k?_HE=RgVRTOQgOMVx+0TMa74JSLCL7aB7R+cl)lx(P3yK#l
zADUu%u(uI|g&Mu5TL|RCq+~&rH+C!WJt_XM<DtqF0A0(_ib^c886zKN0|SZh8pZzu
z-a)EDl)1u{{cnAn5F-3&>(lWFihVyXvY~HMA9=lf>++X)lfr^lB>(G8rNsEerDx-F
zdtZ^W89NgG(j!U!RZO4~8G68sGGK<HQ$B-mMiHj8_zs^RS{Xhb-Nt|aT@Jisz@gv!
zzT$K>{EhN>&>PAhNxM|(a%;JZ(ylctY~Ys~w$@wUY+j{VT&?y&pmbnllH2-YKMR0E
z<Z{?}X7B)Ou*_13i~>+^-y{6V<2z3uBFXg@?(bd<R+@|c=Og^@j`x55u8ja+ap8kk
zZz&Ew`g};;3-7LcbIzB$8adewMgx=m!cq)E+R9n~T<`t_HH>aA@4-Pgnt<~KM~>OI
zxBgN!C?sT|BEuBf|MWYI5g2EofYZ9n)pVvS#JXe+tYjUunGxQ0EZdsoaJiQ!jtYTS
z_x0!0QS+gVv+VeCakdr&qb7r$;K2a%D(?L~_W%L?p^k`uPH909u}9#b$OEO6OKDi%
zd$Z)$xV*B(8Zl15cf-auA&IF$W2+v!9;31B%hQ6DaOfM6k(09~M57sH4~S1Yo+#kZ
z&+Kr<8QH*I)#yKrO~_pnd9sY(rQTj!AARLkcN=lKo>*5O`#Q)sWvw{^7jz0t=1|m-
zRf08s0aSfHX#t><?yk-2oxF_o{8u{W{{?3gQu%x-3xJv3YUaEA(KE6gAbY#o%f2;W
z&f)6q5ai-S1hEUd&$vyK^M&pcEf9lA(OZg!L+ERkS%EI*AG`5{&WrXxJamV~nF)}8
z;`Wz6mG|%c(|V}#4n8;mDgg%>sSqR;?!y}KgI?G6&-6lk4swdrm&%kKAn55M!VHya
zK!bW?2GuEl)&SDB#<M2LP2a+AvqTAZu*HKz;Bdzc>4qNU2+!b}w{o?5_(oROx48nJ
z2~EXFL=*tHC5iA(iXi^bm%MKc6++*SL<SpJIuOOXP+iUN?w={-xV(5=>IELMid=p>
z4pHI1)l(G?q2T!`)-+7O7A8G&BrbTyP9I~tm7MXp)_469a-8%tFC>s!Mi6lIV6aLi
z>IWgZ2ZEaihODu72M3+2-f_Jmx&4LfGCMb~-jDP3q6;dcoI^AZqS1VT&55e`_Aj)l
z{%e>cy2-P60J<V})cPD@-y(}AyA8Ki)i*_*a;93DuG@)Dh|rot-0mO2Xrv+|bKf67
zmT2m4@Kw<+g7d$d^00()Paj8f@6F9{8GNCY2}e`^?gBN$XF!!>?%h_lb_?C6V;0Xw
zVF@4fmUS8xLXfRt+}Vs59GvG!Ct|Za_AA9XWS|$7?=HG8Q86}B?FQ8n$%gpJd!gW0
z%U**QDlq`eyudUm{huDP?cw946(Tf;oD7imU00$}hPpWI-MX!Z_#vz)b9kd3pyHB#
z)+Dp;qADu;Hqeya@RYJ`16(T_4#*v)`*O#wh$o6T0C8aS6B+D9Il3bWHF*dwv<9=9
zyrI9RD~aU|NX|P9(e_Vx@y|xb2+Y*(6GZ0H%9I1hb@dBhj*%KhcGw#!s?X?scoG3)
zUS!zqOe5PH^@8oT46YhuYJkj#r9A8rtnhNqh}^Y%ZA!T@JwKAa$L<l_3WEc$yx8aM
zSexZqy-yVaxU}{M``xj}ZDhoj6<L0lF3cQ?+T(ks){=iJt60E5hGS-U?erSpp`sD1
zVqIvgg#wu#RBK5o4)cW6!(w<G*A&u`z4+<JkGJZ!QE(Gd$^KXosw#@-iX*kB*SAOd
zUc6*u8^j<k29ZALc4<G`r9Q@Yw;&IxA4Mi@Tr5X-F$Z;*o7kVKQZ5xHBW+F^ESbgM
zr_4fQbXtvUe2^aHMh%AdW&c`ynWS7?3(542De-I5iz8*P>Sw6>tQ{jUxr^(Z=-MSt
zZ{;>0w^@&@YoWeyZhJt&b57EMr7zlmrhnR}+-yBHNS1~UP>DKIy|QH+BA~ZoHjn6h
z&5||W-B&k2+ZmW9a;SS~{Jf#}APKxrH2m2{1YBc5TE2PE$@+n@I7S2*+wbNcRaQGb
z)C4ZT=#Pl6mr5wCYiC=z?P8Sya)d!AOqk>xE5EV`yJl@F?8}{GckVsQj}Fh!II&BS
zfxA*rr#Bve8Nu97k;`%EzI9)|EUz?XW2{;@#W}`uo+NxLczOsJNNV@Deh?EekMLM}
z6uDMA@0dUO=|Yj!I2ybB{ech(-(2@JfQ|Iv1Cb}uGELKy?k~*_0>4r|_KWxVRR4AG
zNX?hteB>dTqY!Zdu@LG!M5q%a8@asxoD3C9@7dA|n|Kt-=dw_8+wFIr6-C^fh;cQk
zoPX{%^+Ua3ho$ACu>0L%CjvFB9KWfGpUI>?C65wW9sNpQ=2Ioy4CZfhC)EJ7=rb=r
zBNmyYX?A?u$Lua9eh|IfI2|FDIaqaMBJ~^6oj)x8vj#OHhdopulA|O0KJ5FlhIswU
zU=^2ub>{e{mdVqHl~1e}q-38G&bBr0OTi=gvchG0k*7v7g$ojg1onX+YShOzQC@5;
zaaPVu*}h#F^?CA7hMepRoyj_wXdk5Wri!LzW@I{l{+ZvmDY3A2+nDM%?Wo(cd9Z`^
zH!*YZ3!<Qb`<YfnUFX^Afdf7<Yq+i`EaSi3$%J_8hu}2~YZ^HUCAKkL+sM>-Z=<QZ
z_JK3@nfD?uB^0S0JZ^cp1*?C++w!5BN52qd53K;M(t`G<@uk`%K@xTJaAGE$ZaW8p
z%#V|jQ(iO^O~;qzjnAuQACR>P4g^2#I++4Zr@|+28<-85WouwrOm+dGp5_itUrzo_
zX*=94Y~>cO{`G#-eWKbM7SOPWsmB0Eg3AtP0QocS0qA^^EY{L=g24CAWPKpM^!~QL
z*@bUxmk0&^xqdr75R-L&=NFFwsi`PJ<sbNfG)d^jcUjqeSoIPYr{&m!Ib<~>SD*F@
zS*Q!LsCAfizK0o!7-;0H-X7#s<)ViP4sWD*v7Dvw_2MT%PjUI`u%p|;c<kk%ZdgT*
z>pJfz3Q$2B8S$jY)cIu3=Wh%;pIs7mJjkn9H5{xMB`nNCCKr`)qh=G6(vKH#bT6uN
zV&Y)LIe!#XJR~$twRj}EjsSTMgkOn<BgRD5&{F~N{WD;#k$wl-skGu>dyo=z8u2mq
z8HcH%x{qQQMu+kmN}$e3V6n^6^b1z<Ue(!#;nxv+vWz1}61s#=Q-1j>r|p2wS|?%r
z(fbdmAg<+&N;m3kab;bV>MM?qTHqJNjyfB1H8*RD?HD0@Uv5o@yF_r6cP=gC;db^k
ztqL)_l-zK_Cb(j+3AR^)y(Aw=qb4NHH^yC12)zC%ThMyS++N2Nw(pUnO*57fA+ITn
zwcDa1$H=PHcJJ13<Tw3@o`ZnD3F&}eS|To(LO+1{*yqAPKa1DzKQuV$dZY4F7#w=K
z&bsA<vo4lW>r^(Jmj?z}(?%C+H`%>I3zmZjF+)Pi2%vE`WuBc3-8cjCT@s+G$&aSx
zu$at!QH{Sj%8-{TDE!<9Pn!@+c2;j}ik>-EeO77mnKm3p6Q0twY^``&{+(^m`tL2}
zU1fqU*PypE!@LAfRKD^w&yPL~Uk_5r#^~($s%!dE$&X0u^TjI7Z2;Kse#Y%Au3i|h
zRKH*&0?xM6C_iNi+0IEW_IxI@{V8=;y-W~sjUlvi>b_}`1qiP_B_-5pPdk6_D@0Ql
z*U1Ss^rZxq*M8QB-kS<+^U+Tbx5BjFj4b%I_PMd!HCSx06_4wjywp*Tr~IV$n366<
zsIR1F^Wva7xA6ive=+_|XtC$jj&Y5X5#6IcYhLAGGDvXWmtv3M`W^3vVxWX-@ExwG
z<ld)veD(8R&lhDq8_17xPMGr~NtO=YARJTK^{b=`!sMegR>;)ddl|nH9?b)Xcbqpk
z|9({I1QQl<L(ettD?A|3Lvg-{C$|*)!4sY_88alFkV1cAMbQ^G8@27kLl5V{V~8tn
zsW0B~w{HdMwK8xBePT9h?}*d=c^k{q6EcRTuD(+6U(JVlh6KCu#NuiLdw$HTe4Vi4
zV|B~Ipgf2zIc0$(y->nVC;4+S!%f2jG98(I0s4;2D3L|jOFvet`2J*3x&<W#0bJ>8
z9z=q!<?*IR1p-iXIi^zV5%D!BVoeednXP|+@{2=?+$^ifrCzwqZ<<(I72vG$iNGOM
zP8%AeWNHqKb&@{}FM2MN@<J*>D~IO}F<yPQAp|N<Rsfw*!J-29GIB4hFg8VeBAqf`
zgxAXPRhD<RhHc8!F-j0hx^uf(MrMu19QA-zh5~7Witi>bBlEZSIwFca2Gi$xcHy}p
z-Y?0_6Np|=Y}N%|zAjxoBYV<VGG%s3^WBo{qjkQA5PSUU(pjK<9`9M%IC*-evws|y
z47CD*E@#yakfN7QoZw@y4vd!z@*dPn{F3m$|IuQdxP=CQqz-8Ta?iDDa^jnAGT7@^
zOil+b#?;*mq?pz~tR8jnHm+VwIqlW9al#mJGh6qV3*GWd+J{!5>w#WES{J++tq(HN
z5bmm1p)b}d^~bXcKf&REzLnH`cTWEnApc3r8iWJy;RqtQ!UhNtV3eB0lT3v0pYPI*
zcee|OdiD3&Eh{e6+y<?FI=S;L*Xk<c8Paa6yy{8gX|;%@<p3%)u|di$AonBD?&6-M
zDnZon_NVvnZ1|EjYP2K-men&GsXKXyUpx;d?YyU{c6%x+CGocD(W8yGL0M9(*Cu!I
z1~T=Z%gixX#mgD{HoIAjWltz)%l(57$q9Z55<Ktduzup;@K_4Cl+M;ZMZt&qMS}{u
zaW2?#;fCOMTY0w0j233Oz?!}LQ-mCbO~hc(w!kY2MrP+sq+1e~RWq|Hw;I|zkm-#|
zO11dnqKxLfSB}qV!P4hs%J77anVmbPTBixS62ND8n&|8CBIAK#{diaJ*x|i3;(nIU
zF9}4!E}#lSqOwk^fhnky>Rh}P;gmFy@|ugrPw8^1jOyD~d(aab>b*1PKdJ&VuR!)E
zI^V+8>XpS3=sx>jv#eW%eX5AJi_YfVlx!O#EtPU_B~}|8F3?rU`E`0r+(cO|?E`=J
z!0lr{h`0Hp&5Dd;Z=SLW(tHqU7>TqWXW6!5-5lfl5cL%H`;&`}5$qY?RBfgD<x<Nx
z>4jPzcVu%gI}^Ksl*unD#oT1bP^0Zn`Tmy{fb^`_=W6G4;ladN#81FH!6L58k-GgB
zlqjZ$x-w-+Y9Q?1-{g|EN!B&uyu;`8Hkq0v-jDlVf|3q=^;d1)<b>HcWE~B3CL%hb
z%>7bOCvxvfEsn0v3vrpDHh+N?w8vGiHy%F{vawHu`ABwFmssu&=ecf=Sn=t*Ji#Ge
zvRiHcg6Q6@D9OK{=H)`Ne5fw)PRpO*3`08RM?2H<s#@`7#x}|MXF%1Hp-W_VF0OMh
z%+i@tK944L(yRZm>5f~j(FkiHF*k;RK3yZjv*3xHVZ`IpNK&`8F+dZT;pBezFp*n0
zk3fO=n+((d|EQ4Zr(d<VVQ2B&^|f6ICy&2)t2$?f`Mo56YTv!Qx+f^KVr=zjz33gd
zQkW4Qhjx|qV)~A=brM;4sF1PldEd%-k>xb^Qk(L7{z08HXl=>4>0$;rWi%TGC9cC}
z(W9q8tqD!BiS+`e4Jw^TH--bH8yP2I5gt4N|7+EE30QEeZ4z15o!tR{Q!k#)I*b!~
zrCQ=U!rb1VlDO}L?ATSrW_8%OI1C;~y1qb0LY@+d8xbNb7Fp^~$c>mSdl(Xocv~-B
zc2yd-^+)xhCW6<tFm&>GkKqneP&E47%n3&u_2S%$B`{)XpRyZXx8zQ{%k<mUxS2)6
zp4GUjgegg0vpgsmb1q&Zb6d0c)dQxBuQfD>C!MmAG0PNsR+dOIk^hUbuZn83;nob0
z0>Ry#BE>20!CQ*9xI4i;I0P@nN@*!hC@s+9#a)X_fa317xJ!`9cg{aE>&(Uc=UnD4
zS?hgw_I@-AM}>Dm6unO*^K@vRipk~o^!Q6SiPE2KEn?G#q?;|CFE7!+B^l9Jm{(6t
zyHlw$GoqUF4&GO~_^D6aeGxraFME!2!rNm|;U$HwP<^H%`exrYw59pOYv+jh{pcn8
z$aXDU*Q^2~woCD_q?`E1ja{;jvx*V}|8~^<mqEz6KG|tq<@2F`C;I7idipNm`;>K`
z$AQCxUm<Lj0{HQN<YQJbBECt{?(8q0H(?1g1|y8Lj`A3Wg9#T~>rFMN;1cSkU2J#=
zhx}?kd_=47XaW)&oF`!oYpc&)7P|{g4(q?57m=s*L|L??fcbuoc|W`ix067bo;BjO
z{spFA&G=%T^Xir9Qqd4-l$0C5i7&qqurQr&RU`X?i4^#c81y}kJ0DVWtB}jcCGyL(
z=Fh72*@0(q&zXOY(AH`YsFuQ}xnkTYws|E&ra>rNsan%CG!HfSkCio6aS6eGoQlSr
zpp?JYS!L@12F>4L<A*VR+1gCZ+z!5^5}7JTSYU1uiY|*#8f%&K3}{y=Cv$7nykN4*
zsV^CAPqQvi1ayj@p!H?!M^u@5wcGQEZzICi85{NsatE1DQ3G|W2q6KlO6rynimIx>
zg6rE7-7aO-oc|>FY9f3C9b@~%F6NU<-C&PS)n*<2CAa6W!~mprl&`ybQ#q&x_oAw+
zlE3D^1<g<JsB;IfWiaEtig%7YE*Mo&{DEIbjHNxqRP96Bn8-9?g`RiA2P(<`z9=0?
zGI}EK&prY)0ns1E=%^9343C#DJpK4Ws#<M@J<8;%PnJS(cwQew-CjmN124)~17Qql
zm};`3y&T6LxqtoXeN#vYhWckO*UaQ-cLUfDHr+SqgXKg#n<iZyKYY8MKgWA~Q(cMF
z(Ecqx_=-zoQW$?A>Ybhnr8=KfVy*t^Tj6Fex#uNPH9ym|M-Q`1lK}_|MMkM8C%tDi
zkXb&&Xm;|16D{u-^X<=0*dddarLR5j8>OEwbTI{=E4+T$V5+fDtwC3$sECcIq~E>j
zauw<LYUS{XCgs(Q%)YCu<(lN$8q>_1datNlP}-bOWgyb>w-U&*?|nRpKHtfFIJ;BM
z5@A*twhC?qE*Y@#>d^A)FR~xu!A&>kYG3?(q)SpD{2@cf*fVQ?zfq-9IEjR}h4)EW
zTb<`_nSS~K9XW@p&GCd(e~cgY*>j6;pNHi50JnV}1SD!=4vp>13Oml6Pg6N@k>UrN
zl7}VXu=;@)>C&x9v+G#>BsFp_nTJyks!!lkQNF&1Lp2{J3y+E}jLg{2TNAldAHRD>
z!Rscvyl7&U?ZbZ=sa97;_T>0E_G;!&Kqr67M7`N@5Rg>B&eU$znX@g5#M77&?6D5Q
z_73ucD!lEj?$^bBIP}BYb-mgM)TIeQh>v!WA8+(Dgws13bAI(6{s6ViM35VAJ2J+0
z?<s|W<5U7aZErt<J?x&WsgwGik?l{e6v+hQ?QCDurnJTH$vukH9hI_b71zy^%oGA)
zAw{bakCapyc$QEIR&76e`9q({Y}2b3=5#}sIt<P$urM!@Nnx9;xhj_0Un|xABof9|
zCc=8Ox4l+ZvuhVsGHT^k_lX9TeFtx=M>zGG`;TM*w<Ku06)Xa3tUeJd#Pdqol_4xN
zitHxJwcqV-&gJJ=5=>3ODKmR1oUSvHG{t@Gm@^%K;AxVjgPLv!#}IpJVH031udE@a
zgQefZ$8x*A#Dgb1cb8^Bu}IDjmu?vWc=*zh9m6lP+obVgGh*&Wl%WK1%qfLN=6!W<
zJ!*p99^i~1exOTHha8i-EVb1Ug5#lSzV?=x2UD+(tLgE@-)ZZUygk@wNww|+B~8Ow
zm|Us9R;`rBDAq>rkCISWv=46N9thNLh>w+45$`j!M4gb@_y<m7stQH4npD_?*pQy(
zb6H1k^q+71u=0}mF9Y=7EtX;L{+USt*d=the_b@U;bIO0&Oc5xm34^L)an=7-Zy3)
z(gieIe}CpYPPc4IFphE~JXI$3F-k{ugr4O=`+zyj`|=Q`HdWGdhTk`I!gS6iOZi+%
zEGTaGUJV&vRRe^#Q*CixDWEpp>pRkG6bjfUL?Npt!c&fhr=C;zQa7?~o;`dEiGko!
zq_jP|xUzCfU^3uMJh-t_>H>YmZu%q%&m>WarR0k!T9zfn^c6%;*Wp=AWct7fX3DW3
zQ&&SrsP3gID0djVQrz9->@}CfZ~dMyJW~JOXin+*3ui}tSeJ04B$lPDC#am1;aqE4
zdn~H*V$jug+IsbmAela+x}pR2Edl)TY1!BT&w71Y%2EQ!Yu<eG8SOyzN`HT%HgBOC
z$w@w162Lio*Q;kV$$Jp)-vW4e-QIsd=ZVc$z7&Xl72@Vvd7<aw3q10F+0kqx@g<?_
zLXwWw_B-9flCI6)Ul*A;P|j>$7K0r3Flt^TTdr@B)-+NO1>F1E9+J?g*J<-!ZA+(N
zF}o)Eeyv{Yuig+artL4|V`{F7-?WcOb2yA0con}VaLcbrLRWYnhzj|bXIH34RaiGI
zFei-%VeUFO&K5p1{46g+uN3U~<j)k*PkD2pO-GwTJ;QHr6y4eJhQ@6MUv|xk*q4h<
z43-o%ronl_-BL%MVBs&AL+w3?JD^6W%fR#ICji0<gwzu+&UODarmFggZf6J6-sZWZ
z%#F&RXUqIfsQs>#h1k|%ghdMc7t88Yvs1{MU|M!QY=O3BpN|0@9x!4}6R~`+Hw$7w
za$u*|+th@H!RXL-f|IuLJ-p8IB+w@|jy3T-HfhnP{X$1VOjIP5D_dXAo>c)59F8z{
zfQ&F^tcc?KVEpe}CH+y*_pCn4uZg#zIc$}(z_GW~2gXEk3&I*lMEz`>CS~-loeT^x
zdvl!3iX2kmY&pWLF|4d-YW^7)5%g-OapJsVE$q7U`Bmx@rm{FkznPLF{W+3N-(Hk=
zY=J5Xa^d8`oRx%?d!Wi{8>iM6FqvrKGDOM?G7$RXpWqB4f&AOo#9LmUD%~S5@@BG1
zjjk$MRrgN&T3`P~!hd>M+|nHfW$s^hY;g8&2ypLDqQmS%d~;&L0x`X{v^rrjN-Nh=
z`@G8?PL)wEQsA}Q8NpyD3WK)o=<>G2t+2<HStCQGkG@S{LrNT0DW>f1-RegyOx68k
z?iDMnC|du=`uN$ouguwbv{;(V9$Q#cbcB{)`4jZ*>75yudzbC0GNh%Xi$RA$nqR`4
zFom?#6;{5=-yMXlLl?Vx&BLjErReAYh$4Pc*n?zD?<_N`V&wI_^mIjg^3oK(66tXI
z!FvG~=NdAvl6894kTlC0!2L*gb>+Oo&xq%7&`&o-vjGK4q<*gmb6m-iNG;?ot+5lL
z=yN_-9rHiFJ5Y`ou34!^&Pr@<5(+3dpM9Uh6y9<zZATJ74WL9Lr`~7S(%xeee}g{^
zA>kEeOqa`Al>vK^1OWP>T}UPBDPHHXw+IH^@B3S+uP9kv5lkO?EwED4jLlsd#aJ;0
z(S(ymrf1qy61erP^FPo_`9<kuJsNo8rOz~q|Lxv9OP314S!tZb^7E$6a(~3#-l04h
z)u(QD9B&(X`QN;(|1~WU8mnh$@DO2e>i2t201wz?nQp0FDsWMJF{s@SSyLZ;6e1Yx
z?jYG_d9}p)s2`1H+?`)$hGwXhozFX{N|Y|<@QbVAZaDpl6?2!B+y5<P>p}2aW!b6H
zJp0yI4TRJH3q{1U7L9)-JWFD+*lvf(oeMuEL-n663dxhcAYq4Sl%bPrAk^$n$Fqa7
z=6LIuOO`h}@7}pJ(uswvAY1BtA{l?Z@4bLViq(BXyX|~-zb2OgIA@f#xxq*MgpSXw
zXsFI_X+W9a6|q-#%-BvxO$C9SVD!|DZxpNJrirjGRFjtss0PX=N!!0N^o&?_6w2$!
ziFS>$F~Zib+1t6Ftaw8Llhu!jk|b9nEgQ0-3Osz4zEsnyQo-C_6@JXJ_d+-QEji+f
zu-kWyT0HikGBXnB=vR4<*}3W3RqRUcBYSc)>47(IDGJod4-xT^c}vH<BB`qGSpQMG
zxF(7nYuqmea|taoP$Y|!<m*yEERpkjB9=9sp;@XJiw5ixtwek4l)@=jCCb!Ag6V;#
zhBl^;CF}h{H1jqf!BZfeuhl#96;H?v1366Jq!oeG>J*{xKs+JUn0mI~8X5@}*Qkh=
z{3~3@ts7Nw53C)tV5f2km#<E=_Mly;s385V=_iR>lZ=KK^_22?$2(tIUx_@Vd7kz1
zw_1xmQ~P&q5(+&oNVuC{IdP^QTMZ_z%QC>qK`zGe5B+iD+8@^A(zPiQkz_B~#HaZS
zO4%{9R8}J{1mDy^zg|;ED^Tm5qZPiX#MiXiT@*N&>}t3-*=~8qlejp=RUx5kuTVa@
zn-xHO8A{0$LvP&t`4VlH2p^&L?h}V4eGqk0C}VaK6aE-2HnG=8Ou_IMWsDkPwM5G8
z2Wo#UIsAeQip^bjM+b8STd9GhFVlTEU@1sj9rd&$x_K8v;_{q!)QnXrr5a891#9JP
zk$}ggu#fR})dTn8k=cA0h?p|S{?Lsr00J<!vXqywI<4ZBxzbCA47ziy$V=3{vu(g7
z5OZ9Oj$kTjlFHlJ6cR|Mfhb!j3jRzmd`pj(-rT9)Fx3;tIyid>o7{>STAB%;r?;0G
zO0R?_=D57!S>Y^OmI5v~;;(E7zPHOE?*FTkjnw}2_)$xlULP_H3>QJ{8Q#x!&6IqR
zJ<UwxHaIra{S$-jnb-Z@y$w*5SU|`7!1~2c78SZ)wkJWWu^aVSE4T04QEsfp*wyl#
zR1}4~bx1{oZup+TE%v#2$KsG2xIMXDFh5M$dP{M!L4MLVYNmTIG&GdJdnK5fp#mop
zQS!ol)aFJLIL=wNUuxl6r@=)pwd2wD$GrvbbL31Vt=vYS+v=qPS&Cs*bswrnmfL@w
zKNmxJ6jIh6vpeCt*wpr})eQQ<QY$eA68l?{^H&EJPMrkrq1YbbN6BJ*XmLhtjEKef
zk9>U_2H?8|VI%Gf4B;UQu%#O&WiDeR$})V(|47{Vgl2NmC0W`*;B>0J2ho6~Sh&D>
zz`NQl=4R!<8sU}Gm$^(BiNuM~vRFL@UieylU3mmSQO}0I4&aaVeUazMw`Yd6jy)?k
zY%G2O(x;C!&wrKQo5TJX3w55)Nn{6k(x@m$^*)4I9-hr6O}%FZhWLK~oUaLQdjAig
z#pmH#YG8B(5bg?u*IqvG0b276`vCXr)TY~rvG${LNAQ;FO;W6p`xvm5PaVN+#q(s6
zp42B?>}&L<5umpVxWq|9r3TbVd;&t>2b=Xzl=hkwM<x23G*)L^fzOupUjdpv_fX!W
z5(6#HNz#xUC_ph-|DUaM0}X;EYI5g&9N?P1&;2Fm)!OJf!}=c*@^ndbdujgfpXLMy
z(W67q-RkKl?|~iIYWyqgob)5`4)4$N4tnsg)g#mdJb^W<ct(cdEpxOfz(0EwI+6cs
z)rc4f>OaIOsG{gy6TEJ}C7->$(5Bc1vAeTeTYZFcGb@C;(G)UY&sB5^+D6tjhN~q|
ztdpZx#yyv77jtx^sZYp`_~iimMY4W{cyXIW9`Rc`dHUKikET1$JujxySRVS|N|Pl<
zw8Dg!87dBZ)IozJP7)6NCP)7)OEX<kT%<62{RDrk#0opE($e(T*E76M&uwmc);ex*
zs?gYlSZE_c&>9!yyoU`KF^$pCHlR#dFzuVpYVLP)kZPnGEv&YVNXPj^PjCe2btn>e
zF8P)?4>!bqK2nEWSmV6}0~-^Kf&kUi7n$I<Gfx{|Utm*}2m|3&q%RyA@pFU~=dfA4
zF37iA<WmKbcVZg0nIKDIzxL{nI;p9^d8`S6UIC1-q~ml0Z#jpx?0Z?4eJU&cMKGHt
zleZOyk;07ig7O@O@XhV^ssz%^(5z-FZJFh`If^O&L?H=wZX*aD^Tk6zGxvFaWR+Ur
z&Nc>6QXjU1Wfy=|bF`Fc;S%Q-p-H{YU2|&&+Pkn>mu`rtth9_UpzNzowu<ZCDjjBp
zv^*el#D16l<N89s9R#i7vg3`X^q*N~f8gawk);61ti~fn^f8M9EogJn%<^;e@CArf
zcxZl-u)cy3P43_iaA}E;)<uP;Gp=gp)U!u%Z+3aMXX%^SewCtH_^0<DwpZNOuW$=$
zjosI)R0^8LUqG@eM7WBvH@L|H%U1?2EpcqLLhwbs8Oo*}qx*B58$6|YlLW1iSZg_L
zu*sE2QE9$948I4to<kD#wp6fm_b5hS*RIfx=UTHxbm|bL+ntP*-eQm0d|s-=_V=|N
zZ%WUT*s;z%*MhcNnh6u`S$59cB{8W;@t?&OY2nYdHHj9MqnK~Kd(tX4?yu^rD2Jh5
z4On1{Ljc0ufcR6EurjGYn;_%X<>Af){I?;6T4KtyuTa^M{Vv3u(xXA`8(9b`Tvvi>
zMqGM>L*Q&!d_g?zSH+{n{^-gt`vl*XM|AtP3(8|c>eb=)cfaRFT9DH;iTmH(kbRoy
zYTeK9a#`T_tTbz7j%4Ncz|MskNz7gUPq5mffP`F$NRGB~!V<~wrTVbg*<1G4pF{_-
zM)Jy1o1J|~CdYCk<cU>I%i5XW-ZQ894Gv!vj~m(0!q_~}Y&Ht~tp_oKQjK_8;t~^i
zd6a&<r3}2dl<(}nvimn|#(%j`+tfk9vH%}Bd_;B=;7E0C?y`;MnqhUJ*<?Pe9(mir
zxyW6$+}Ap@Wa77;MX*e))$`Zc$qH6@(|@poe_l<G;ZuTf19kX^0|`_@$+n=3H}k5Y
zC*sq7v%uD&wYnY0h)_Sa2>SU9C*fBj(W3DIzUqiAbgls+HK`#08jfNkdZKo#uh-_t
zmU%f=;emO8kKc*>LbFAwLS=}{-_~*Non;$$QLDT(%w2Puyqy9dTyE@q%WnvUWLkU$
zqPlNS05!|o;jX(+M@B^xOuU7q94Z^K<*UjgoM$m2>t2GBRZ#Lc&=e65l-nN5L^}=g
zuB~=jP<hASd`3k1@y`q$2+YW@=y}+$BX1g6Ibtrql1^IQDeM#{<I)DDoEu?TsuVTs
z?Grd1i5HN_<Sc7@#pF+VQj5-8YaJjY$JloqZxJ3ep<2MRc8kf|eM3|BQ#D-rQ(B>(
zLLQedxtc=MpDBEoJ163d9Lf1YW^@Fr_{jta;`^j$C4}@(bJh#hzs1r|i?51N{F2Kd
zEr-uyo{~sY{D{FJQ!B$!$C!+%Hf%y4O-<{9^z<vWWNmC>SabOK^O1q<?{oS>lrkgp
z90KQeLX|gjb4(%C7+|c5U)V|2LR}|ch}iNyNvIh5c6)?#Z*F<mW6LT<t2ukGD%;di
z?MW)>Ih4<DNYu8Tb8T@APD#?VJP_^emA$e1axr(oldaf|t$rGLN^!Xy6e;0epbo3U
z_2PzCC3Xv+YluTKE^l8$Y^RA^Ze^bbd7>j!6f&xTS?&1oL*U9A*Ua`KpN{Qdmik9C
zpd(0aPsW>Gdwv=1o7_HZLJIipj9P}Quo}40C+I(l;me({TWbJ<RTT8AM0c%?J_Wn<
z{U*dVma?1~on&fD$oVB=JBOx7<&STU27Z)~E3#?{A^*0^0{tusvW_47r9@;R@BfLZ
z?x<_1QXEuazXE<%^S0GD;`Y0OL;12CAugC(R};OGG^fsIcksz<E0lBaWoF;2mIu-t
zi=ct{jc`P1FEBBV;xG^|vF9iqi5}rhy!qkgUSl;F$9Q<k7~&Jv3tFVX$Ly-FQI$fc
zqN3{^-p9t2HcmGYmUrjbxOG0VwDYBu=eqHhA!)ByBt#YqBcg^!1#_*=$8sY4{EKbi
zb;fvz(|Pl6WETdwyc$y~MYIPK>^Oc8poRL1_1i>F1!8EN&g?2xD=f~P=#F0aOT{(q
zS24F$F8rPRuPK+uMWDOfE>ix)D)#8gvyw0t=`h;n?~<yF#|XSow8$b5&*R)1D(mI~
zKBaM<Eu)GoGj4B(JfOCwRLwX}WH*K#Z$j^3SfyJq%x~HF*P&*U(9A!mT>0H~$u6s9
zcF>VKaZ?C={9XX`TEYo%#N)He_$}!YWe}yqC@q@gSOp=3-FDilQ;DciE-SM)ZPT_)
zn-%gBKVgX$kGyAwy@5Rh_{<xq!A*RNbZlC_r(XA~*r3sv$@j=Nk^2-PUB|JS*PIY9
z7f9@;nhU$s0<l^g0T2Vz0t@esEcb_%rEkueg89hR2E>0TXV(8ZnRoUlGh;G!u+Ms>
z-In&n@&4d3oHye4E81_#`$ey9;NKU}st2NEaSx^saJc5gaZKIICloFKrLtr(!Ce0>
zKKEY}@c5g?sy7fG{q5zV%l+<o1{y;6=`%-I-2|Y_?|d?fC&uG&89SHyYP|vkwpicj
z)+C&-h&9u4f9Pv$lXO=}^Pe$Khp!kXS~`kFV}}E+A}GW<pS)*NM~HZ)db*SQqLXFn
zlFfU?)q5%jptvamK8s#e)R{>A%IvWE9||J&1#0ul1ArG~YC3XN+85ptd!tIX2ws)!
z!<B9RuKs2!#f-4hiHM2DjNp~Sv&Y?z!4CfP#;{o#!$&-hXUv&1|4u=j1lATN_~Sol
zTZEVhEZ>`^MorMA{gnAR?UUbR7}9-=o!9ZCW&$_&_1Nt0#G0<~*JNM@<|R@Nf!otJ
z!W^Vtt~=PFBrraa@zSgQ)`FD<H?r|krIZEsr`NJ;gAJ<&Ag0mdpj^fnl~0PB7c<Q(
zsZWblch9T}RWacq-5zG}D(G*Jss(UMdqz8Fc{kHED5wC6*C7oB9sWVX%Vq1&0@<8d
zR51IBMg0I!{6hwWPZh}vK~bsqnEAtGrzr(0>&tD=YBVGAhrO&ZEs(tf1OQjZ2@2Yk
zU$-Rrt4l<eua&=gvvrNJedN~D{Yw`Rvl1ZA{3#&navSB{AncUubxvhTTsmq=JU`Uz
z+g|RT(4*-3jxpv3*nI#qj4bw|I#O1HDRz-NtF6ZxhB-ADJ5As!K)?~&uk}ooCppeB
zc2^F-$ec<?l%=ChQR)!q=QElzIbs+)Yy}PexNig4o#O)>uz#HQr`(#Q-(SoR$zX!|
z{YBrwL`N)FuPk8It*}&T*j$`4oMNqd`W?n%!l(E+eX1)7$E-I`9S!Gl>u_qcNMUY7
zEC;@tODpM-u`16L#2+ZU1ff*38t`<x9oXpaRtnu8!rFU~1a_b+JbDgt5IHySoR*;z
z6*bwe+I{#0^mH2KJGm82Gk{higU}G`L7%i~We`#hYYbV;K2m6eyc?MKL-KF)r9@uB
z4uJNFQG+=QHA4%WOZOJD8IJ(QU@Deb?!Of@+u_wz4R@cZY-4voJ0!`U1OA~`vDp$3
z1fjT*-l+}#8AwCJ?z{E}TBu=cD$t$#FW~nyhhXqFN$%~#lf#N=dZ0Cg0voe>1ai&=
z;V21u6vhcEj#??wKoV@bKOx@mZAd2o?7pGI28TT%c!M(__Q0WVCRX{=<mN5)%`(le
z(21S{%bob~SG$aP9RiPIU4Lr88mC56H*#qdLRJp$-{QdHXps6k46u9K>6?f?ZXkRK
zfjPRdnEZezOPIJKY}W@FeDILfJUb5!;D)@{PwWs2qNWVJ=55Gf`@Qo>k@AZVkkiY_
zlPcFiRsT4^v3NX7-p}!xlX6zm3zzWvHi&jPKtG|3rRo|tYUa?=yP_+J_ya_iA|?3Q
z|7d;?fr85cH4S>t*rUG$?ID*nW|xu3pb4ZUWBQ@|;8n+J!4P9uSQsyAbIR4%69yk)
zAnM{mFofHSuJpP9_cQ#t4~D3n>58uO@+$DOVP<9_y?al_Izp2|u>Etdl(0P3Mu4s}
zP&VpE9J4Uj6I~%4T~;Z`{$ey&YE)g>YMBFC`PFprT~(~W{+P$zR%k=(!5_PjBVWJp
z<nngh!kL8@iIT0#8GT+|NzV-f%{*Up6faOp`g!F)u0S2q_ki=FCvaXWLAG%sz_}VF
zj3J#0rn~~?u9IiA#mK*8Qr9m*5eUUtLw)<7BQSLneaS{Mm=i)nh@6xO)>c{*_ce+2
zE`U6&7*qj+1a_>^O9m^dfp&!7A_QvxHcT@B?tw1%#?V_6B|$nBr&yTVCEB(gl*Fa}
z2ZRiCO0w%(r!LHRh6IH?2m%lxK=?s2F|5vi3Zha01?(ONW8Ofv+P>v$kEg5S`dB;?
zv1^T5x$wZ4=VR#EpZrclA8aHeS;J;wRwxdV!d51ITR2$LH~}9Kx#Xi}z=0ixF+kfH
zF%<K#0KDbC{u&c#@b;@dLNK9*&GjiB-tBW7TK58?1?4LLG24(9?FHfd`oGlXgcLf@
z^yZl1s+Ty`RW!y0Pts)hZ>8_C@ovYD_F^kmo)jr##sBEqU=6pmC0%gNGHhxMU&0>g
zjaqs(7TWXD^y<6SsYbW=wiH#icz6{UBhwf!zj>(C#A*}Q?zgxCIIFLAL@s)bqn#l3
z8~W7f7*TUjBEV<HWs$euF$r)Hk}#aKc84nc%^){@yeTP74cy&%zztsqsFGoS=@ec2
z%fHffImoB>H6Uv~1aNyEAbn#t-_85vsjNSF+=z(Mb9}NNt>u`ie${&X1$xAm9t1{R
zn^S6(*R5FKJPyD;*}e(`NBcePKB`O@S1-ld#P@NaqkhRFA-ikSo8QW^hLGSFAB|&X
z-OSbdgd&}_swo!}kU%mim0b9oLlNBhh~<1<s|wkG24Oh+%<p7b9P4rAcf{0E70FWI
z59Xe~35zinT^vwMuXavUEvLFlR&C?{AH7oF)c*NPRvum7t^znUi?s%VT?ln$0aihb
zcg$$JNNTvn^*S1&b>56)*OcYBg<)t-BNI;P7(u}Hj;`&qB8In<h?DRlxlYnVcI_!M
zSsb=c%Sp-hN~G7Hvi;R6zq8k<xU`hu&fI?h5S$w4S_952Mme`>Wa#vh`{+0`pVM7>
zjjJ5Jwtoh}-2ev@%DDo7yE4qiXhQK2Hu_euQOiFBXv0k;1YwLm#u3GT1j@3wHfvZb
zC0&5i#@eWWrq<e+O2FZ4uB@cTRiECkuV}XqTlw15a}uLZ7B;DR&DY=Z71BHxTakZe
zuA(P|ThJHx@CTD7>Y&a%L)D&lKKvk)m)8IiV;79q%`b}|uNoe>i?JyxN@NaiOoty8
z-JoDS7a%-#H5+w+f7bNTm^^BGiE++8ks`?zjl@W~TA?*Z`wrsyi|(Q69l}3pS~kLZ
z+DqH-5h6kJjr$wY{nMxrurH&cL*$SpDqAU<wZWy$3+vB?IP;6#nWM1$-aoOve{oFT
z+*750pFC~;&vU~I8>Qi21h}63K)f|oHsAco3E2I6FJ{*1Y5mcd3W5&3BrFK)NbZDD
zqJn5lMKNjyG5<!RYoG{3Qk|!%FO?wjquU_Wv%msfF4F!ocsU5X6-bfPX$52#=fcNt
z3p(<8^sAE+^{e8yer?ich1UY)K!fDv!QG%CD**Z;w0Z1ScZ%HVl|!0OL+%A+ZIP>L
z@1gUHp^eaR<JMTBz5T1TV`Hn=C>TZM>~vkys|(;Ni;G+pj~PWmun1Y92jsSOGdf@N
z+op+_Dg|C>bqn6h%*sFwMY@<mD5c_sCsl>+7|8LK8_Ut=Z6X^($l1_qn_p%1_x9{q
zTg&Jo^wlwH{^P<B(Y9;u{o8u6%WUK8V2=$pJqk+N-UDF9#6xz(s)8=Ko_C^z2us{M
zhl{4Qg995j=yjcrcxJMooR|Zak><u#v#*oBABXxr@AA$CZH99FMnHUP_OqJn99lv4
zCHT<Kv?1lP4c9Y{B3;(nigUJoFm<}`*9=|qT@67xz;5cVUZ0R|7DpzsH#&3`DzmDi
zHv1BpS$!aL=Og&fdf39za>t=$*?d6PydM2L4&&YxTlT|pGPWJJ<?KCW&*utK82cUV
zs9&3!9ZBIyh0XPEp7P)viW?Q|q4sOP%(squvPhe0D_Zn-S1BuPaaR@&8LnsI>mOWQ
z<urCE1^oZg<z7Do%=!rSSUgGrDcvkZ3>E$|YxJt3?Q&QNeI<Gv(Lyb_FBHA;|6rjZ
zaHNv!tuizC*Y611K`SttcL$G3UKi|#!)Jy|ub}0BXmJQX_Qq35DqA9BcN$uCq8cAo
z5A4eGa#ZgqJ#LY53Ub~P2M>5B%`=_{DwJeLzqRZbr9{;`<ou{9!_HY22{OywA3nO;
z&H!>;@VljN=@Z`3<ykI`RIFXfJ>o5#`Moa|md|)#)x2v5KEy`uJ}uLIcR2Hfc*9+`
zBKf+yEo@(U{l}K|f5Aik9b<3N0F-3}%=>*HE9-x~I7`yC#wUOruyo~rJiKc)zzRNp
zpk1OJ%t6}c_{lmYU=rXV4goHtJ8;y+(=y)HUMT>6oWd<aK|s0r4Obz_dncY1S60)0
zV?eWRK76Pcl;nC$*?4X}T64T6AT?!!wSbP0WoXUA1o$k$H?uB^Iq<R0hQDNaZ~5x#
zlwym!aARxU<nS7qlOgr!gS+O@3aK~QrGZNfSLt!!Bd)q`)$?8gZsk4Wo64g;*asx)
z<CDkcQ5?~^erKpD^|$zaLve)4-!m$h`q($u%6hPomYVmEMl9^dzYyY_Dg5|6ZKlqi
zmqmd44-M6ovHnd_X}RySKJ2*E;(U~()lC95EJ4+;X5gHKmBB&uR_Je^e0aU&W)}9N
zc5@ku>SHmdP|bZN3`E0^I_?#`UYrzYj;^}K#4qsu{o5Ns<y&bS!KqwVb>B;YHtj<R
zcP?q9;Z^V6IF>`|Wkw}x8&F_NyIJns%WOtQkMesTWv=)8F$CsoXMnJ8{{;!N15E#c
zgwcm+-@23OsQYPD#8TYM7U7ViL5%I`CkxWAN1ulOm9}<oTSog)eX@;#w#zWPD7Mz!
zq5H|w8=JPhA#T{opV8$o^Z<=Bqzl7<Nl`lxi?-dAiHafeePtbF?#cP^889aI5l2=8
zz&q+srdIr05`vGpdou$;blX;SyIgh28&2;*yAOU6rA;Xo6&L6*L2}<Q(JZKVd|qfK
zR{pXH?!G1Ci7cSX7E&<6Ww~2+2ExU3)-gpd1I&1n1BQ0%*PdeUd-aXKC?f%eGG?@5
zCkKf5EE`4it;A};Mh-$M1FRxfJp<cKo55v(WEqEc+>#-H*{9XuD8M<29R3O1ODwWt
zlnh_PjWS;ld|Lj9V}y=)qR?#yFizwH-#Y+{LE@xvK2rDtDr3iH7KwzYw7u*IM3WLb
zVj+F$Gj>L%vb`N)XGw7XIWKaq_pJSxn=>knXwIHCjhFE|KfPkzmBir{Q(3z(C8a1)
z@R7_{MgUlG;PxwChopFX#}<dBu%7nvwcqp+O60CqlP}jl-uzgL!~0pRTWz5_FXsum
zVkoeM!Ji(}@ENndC^zTUhkhbRa$ma6^F*aWm}xl0#n0=ZvAM>&-U!mZ2@ZNKRp@0u
zu9Y;qi;O2oi2qUI_Fh<{5A?NSrDKFPYE#kCcqvP|u57WGIHJ?Q<3V*LKcfjWbt}jE
z^C=$U3IK`j#r?EK*17E6aCeU@%x^#xwnv^6qf~r<UY{>i2Le83gHL=H8^{%&&bt!6
z*g5mh>*^SYZ#XY-So5l^K8}5SOBB8uy+vj{fTW#B-XF}TOvXWBNp8@O=?89)$+=P8
zrr>Rvsyt!UBioc=-KGLbYRr7kVEk@}v5h~Uiwv<q-`Y>#>@S+L07f>3{Lq9}ZgH<;
z@jSLIl${P}mP4HJJ9BjFOVd+7NZ{u-MR4>y{1ke<Hm`-PZP9(_MRD>M5Pr8K7`Tm>
z>%WX;V}tAb_&{j-h`Oq0cewI^vy3<!$8YM`aM&t}eoLnXn0?zEX9+#ZO6*O!+&^YH
zZTxR*+fmc6<Fi=!7&)vBYZxlnsfBKRL_VogdJHID%FFljuB~rlc)x&@6<m-31QJ~i
zcq8VJ%$8r5e+t<!+=<{LC~y4z8|h+8@kyvC6h-9*ZKqJNSTt5slfQfL$@V~nYW<%W
zT|;8)^XuDVSEL>mopwXo3(s`=fFrcMjBaelS4ZVGyy<@wvTD4z{j00gBMojx^=ep5
z1oWK{!jcaqqd!|0gX*h;BrZ-5*Yf)6OX?R-u8v%t>&c!1LikhU(i})&q2QO;U?sbV
z0jKEZJPNRoYphG5u4>i~ES_Q3;$Iu>%1A4|SS3#7c>37B?Zsq1P10W3u3712Ur|<J
zNrjiL1Xkwd6K#fyIr??xCRZJaO=DPU_y=z6q_MIy#BS@iB3&^5_LrqOiqQt3*3Hx6
zPuGSUd#cO%$dK6JqoG__gk{3(B8U5Fq6QnRC}^s0%kZs6$uqse)?4<!W%IT$W7YU?
zF<5qQV17$CJz6wjw{o9fq9Ygy!Op`W0s%#9XA%MjC5kUA1AKEWg+@kiFsg;hJ^{a#
zVN?r`7<+aZ!JkRWYX{P<8B*AZDig-$h4SgGy$Sgagfo)8ndxypPVVsDq85*F5h#Yv
zGQSLuu}@&l)Xg7WVVP}-TaESH?EZGY(thX_IRDO!GB?J%2UNlvWBmL@ssMhg)XU$4
z`|qC?TUs&cRke=qHkgkueSfE)bD;iRlSvCO3pMP8d<b1*DV0T^JyG7Qt0yv1n@As)
zG}^gP&RXe<{^az)a7Je8<L`7@U-irTn6<r64Hs<)O}r2Ykil(jOxUa~*O9C>P-f%U
zUa?q5L^yHt);+xO&>*zlMbDo%#tEue0mn>lurSX^j{L#t8i)zE^5-`#oSQ|Dw5R>W
z)OkEJlQPFbHTqU!8uu}T41n6E3nospJ6Qk_#<e*BdMNt*y;}p1B$Z>d+YI*2_9fBc
za!<}4_iP+)0n+hs2#D^0j^O<8Vx&E0ag^)yhU>>7A?F36*&Z?w8Yk*cxW7&G<76uY
zkjd_x_I_Rhv=H}sZFk3SAwpQmo#?fhk|>>Wj(}VIYSjmiqQ)@HWudVSh<*9V3bbS6
z*gheH7&bj3Q1lYdOcE`TD|+~@;{Ae|a@vm0r>2-+jz{TPOGRy<tObDLhUB}oUp9dA
zml3ma+tAC&!{*W3+Njor`u8B>-}WeH<XpI-T-PW=l+#!?`+kOEK+cMyqBn~Qtik{M
zR@;s)V)~-CoH^)2hC#$z)1X*P2+hw%i}j`?j!!us_D$WNVH0p?3*6YRN?rLH(v?=s
zU4fh`n5t-%!z;ZMI|ja>q;YSe)o?%Qk2!<uvM=bu7^j8@pHS|N44l28qNau=tGHJ;
zJ<*fVx|RrsM7_T?e~WOz9#_KjoUVU<b#S7I(p9x)G`wv*dZ46<pAv|EEW_ZmXl{%5
zXaHYl^nG6LbH1I#&Tff1;}0WeP({0Fe$29a>?8)z;Go42c1iK#^{>Rt4B6Ok(C7||
z){yS#@Sn}LUJ|}tYz%KUkro@<_xq-Ee64%gEfavo(T+5Wn5Cim(ynN~AxhzPz@$#p
zJeZU)LLn7!1~w3SRh#Rpv1z1{uk($$d0t`1D>LYP7a;r?76I^C{r$xBVU1i|o%-qW
zUC`l<M(F_s<codA>AccTc7*HxlZ0H^$TO|0ZbOr9R4PH4$r%uCR5$vD>gKP7HDoc8
zdD8VG<agUB)aG*z@u0{ws2hNH$W0}yF?o)=V>uI@67a||+jt>Q3FEtzw>zMz;txH;
z%kHI{m<bEtop5ylg1U=_77fO&Pv{a4l8uYDZfIyb*ejHOMon{n((H@Rooh94AfsVL
zyO1?J5WQYvry`TSbSxRO6MDOq#ff9qn*Hw<(En#!MgCv<uA`I**z9*qh*7b0u(vcv
zdFD|b;#G$=8fyEnVSDhfj^+HPys$c#rt^DCnpnjW65!JZ7@_saHY&9MAi^$!X8=n}
zX@~8v@_9mgY0FC17T4<KF3tu*xkEjyu&YB&95P04%MUEKh-a?8xBG{woZQQ`2q(;i
zA6{LlBWCJJud~Dqs(xl|XPXI$1tce-N!Fgr{$1lu_fLKO3in*KC^Aa!c09!|@Qgkn
zmH!fVd-dS{=5l0peWM($=_Plr0QhXXMHA1Aw`fcfrKVbu^NgOyj1DCV9~U$YbRsEG
z>^kpj3T$y&3G=MU0)BO(OG6bUuK3%aWi1HW&Qi%_s~#c-KLJgD19gK#cIBk-noTgw
zWRk2o<H~M;&vlG3B#@Cw{ff?#r@A&p1D>{2A>D50SmKL~wF@ch{pvZC)+4+h*FjGy
z4N|O;AJnQ9qv6C`Pf7jNLB;C!yQU0=t<Z*BkV3pBFy9P4*63@h@VAMHXQ37~P#Q33
z*{GFb*0nV9mvmW*aEr<r=SRq?^x$Wi!ZPIM)PIUCK6T2!ccqife6!PwtuZw*n`@!+
zboergo=Xil41DM0<G)5D19Hy;MK)3W$l#<nR3Umv6ud$ApAuU_$wDQWRnO&}Sl`>{
zx4l@a3~trtyNE9ujhXM5>+cADmSiDSwwKXX%rsrEszSsg+dwqFT3Ogl_9;!x3UI+F
zQ%=>5=VLN@bOAjOs}P@XX;$601u8`R%~`5!Lub~}O&AnGd@|u}f|)}HQEJu1J=-%7
zJWaTgW!*Rvpjb%JW<tT;E*7pv9lb<0<Big=y*$=eF81@H+u+X&pPN$fyvNAQ79(y|
zG!$nZ#p}7id3-n6`dIw~F_&MJM1sT6*<WoVVC-mNW(J1ZP!4Eh=Em=L*q)=z1i;6w
z@1r|YGBjUiM2VZo6>~*b4}UQ519*AL(Sv_iR=*p6@nROTZNa@iJh5>$zUUS+q?{yH
z6?;)H*Kr9Y2)aOfuO9u_MNTywReu#4d$&yg^zt<)d1DBTT<4b2H8!8rY&os22{75w
z?T`w7g$+KF?3KogyfQ)`wxO~_GUJW@X=Y@iT$blkP36hAEDIqJeFXU%UOFkIG;;%X
znqROFavCT};C0cY|62X@YSBJ3Rm|cbGc{mD|9fWo4k$E~<lcdg`1jLwqn5#~BSNrL
zZ0~BNJ%X#8xiR<?;GE#p2>o36=C7H96)lx*E1RhaK8q((&lWnP%_)o>%qZjjdKc4h
z6gcZx$RN2fkJYoHB-#)joFBs_m0O#oH;s?JWLl%anNFz%v;svX%W09;=7Gfz+P*RE
z{USN7;^aj{X=g>{)t2U|aGVQ6OUQ%|b|^vU-okK-#KFZjjtaalE8i7(iIqi(RfTC(
zxjxx&ER%%2%Fv2yj7xI=YLvDA_0*rkYQL^S5K5fN|G+j@Uv~U^Sp|Bg7<`Pv5`fpV
zysT@-pa%QA?*2b#;=WdNP(7+>smFu^6N6-QL`}P*Riw>1dT;v)C6%NgW(5~P$#<M5
z2h$k{oRQr}+-6+d*}e3HAerkPul;^$e;P%tN22c3ZmK`8(Es?BhWTRz?Mc0;Ebz(b
zYo51^T;7iUl*3c=4xOm|okH;Ec8!bC#@PNHl*orO#|6qRAmB$#8Fr1IImKPfcPG>p
zKO@*qr6@hnD}NA^=(=#6y3#fK-BCT^FYGtEC^p!Ax#=Y!bLVC6vj)uv0IN`{xX1#m
zsV4fOe!1sxQ1lBm+dKu7Cj&_nW3Of7lvKBKOS67-9|iEGgeBSe>{oU+4UN}qo8MAs
zOo$r3^V5b~1^Ye_bjjE8{$i&Ap7`2ljxG_*VnP1!6{VQ9gu6UVpxYDAIA%>9944S&
zo}{9e3$MsMh&32VBJx}5>Al4)cc&yCJfA;djUS-=e@6NL|D(kOP*xRS46c)rtPDy$
zX9as7mCL%@#{W6NKp1n%pzb^^44*4|S3eU5Ah^9grQ`8z9!Fo)zxs^0aG*-|&SFe!
zEzWcKVCQ@}5dHDWd1!WaM8W+ln;L6Jq-x&B0~Vi_xC*zObmN(Io@srjV|%x`@bOOh
zyL!sQkg%hya(9jsxn;v%GXi`*_UPC0YdK#qz#Jg3m_nAoMCtbp1gi5dP^>X%>t<Y{
z>F9i0>fz>O>vAU*B@u(mUd{Z&QWA6i79Icr0&U4CbJIKe;iTKK=<s+mK%h5i{jzb-
zrRE(ms>GD%8AL;f1nSxOlE~$H9Xs2t%W8}0CV?nz8Hc$oXGKhAIV_Cfyu4R_XsiDP
zim?#x490`$gC_aVI1+Oe-|o?HdU4(^)w{Dc(QQ}m0>7XfwQ$H5GWk7h-YJ$@0DGnq
z>p>@TbS{OdUS&16Pm9O2sPoNT8YkRO$|^4dyz-v3Tvj3ShHPDI279~c{YZ5In$`T6
z&8-&zvE(fiEwDSG#{Xc9yj{x@2PNkKd_riWb%D4*VH;s(oG)*(_e5?C^6L=dM;uT8
zbPfwI=-S1(&T_4%h_eKs+xph|amnz6nB)E97%Pk@Q!f^v?wqivsTvlnJU`>y?7PlE
z5j58VdK84`vhz?!O@^l3Xc?yAdfrXHdZK_G-mjnQ-^Y_)+Z4rir@nTNoEKGp^;h7I
z63Ytu!;u}o;DcIKs!|Gob1cZwOYe{4bI}F(*SMOIK>c?rDTW1h(o+XNzIyswGRP={
zg#cHeh_8Qf!Y~v$IfOWOAUW>GEygyhKXwhL$#h;8r5MK%-|<4rp#;XvPr?<9!<8Kh
zIxBKG;LflwKfBLPs9w|7VEFwN3IEHY@e`C(3HGnGsWR}A<(0DVl=#OU7Qf|W8ukvp
zW}YPK9MK<0sqQ9KpOVA0_v|Yrs%gQEwf5DdfYsvR({e?IJhWSn>71RYU*u}@d1ZV_
z>GBvyFkG~>PhUQ&oNx0gT|UP);DLzut!3We@bGOfn-(Sb6H?Ewl-Ma`aPi}XNY_(m
zMb62?O$VS)eW+meZ@!#?U2`L+<l;gV)-Y`_YOiUyGN_oHXj(w+PA(jlmBh0?!iau%
zmd106Q|9t`L{ORhgjsrO>zm`;(3lGaLOZK)dY*{>p69^Cxp8$;*tn3&ZYT{qY1Q6D
zEfRq6rpKu9_Mj8>rg+x`*qhN-XLIzk4=RF!SH#d-e*sd%!NE@S<H~4GlTI2)@vUK1
z_UI-;weF{7SE;~D4oJCM0YxJU4pL4*>hW%4&!|eAVy*?ZxgiAj*lV8w=r!8v!UY?!
z$`C(8^*_|8IHXFm8_H$56d1`(1%}#JO)}*wiCi)yZb*>rg^DAk#f4P;^(<IjTI2o2
zBU(B4w96B4>Q5RvuliNw(kQ=}|FvXD@9x+-vht9It+inr&zY4j87s47+hvRkxSX9C
z$|gPt&j0AcvT}*lZb6RCX2{vY?8Pt((I-2o&n<2%s4`?CjnKRJq@>U}yRi9D@JrY|
zp$mT*%Lx5u$1`NA_}I3D+X^QgM;qGXZ=S*%r0uwea8Zs3R3L$=TN9t0;fO0I+DOvU
zE8yj|s`lKq$cJnPF=NGY1n(?LK|sEp6xZawk5_2n|9$e=xOPKl5@2t3{w-_HdLzNe
zxylu1un^@e2u9C{=?h_}sCtHnsF!;RFjF*Ni}hTk2HI<`pW8vxp90JcEmo^2<ezt^
z2>b9E#@ZV>s0a!u2(&dsY)<7_A}_HTT0f}rJTvCQO|EtX^0h~G#OVMRHHwYGzL?NT
z>%Zp2NtGSav{{#+RsB}g02=3TJg{%3TUl0#*|E%daB6*fQ(Q&ZEqsc%t(ntxl}BI+
zV+z`g%(JlyMQh)<a$^fRn97gdeDgn&{_?w`=WzpgJDv)HwCkmOEf`z=wk<xY0}xnR
z$<lv#`8`&;C($fIt~E}w_rCwo>-VNY5l~R|+(@?-z*3fP;O`I%3?E8Z;j^17bT|h}
zUC)ipR)V4`AzRO{MAuRn$`0`HYQrLBT~6xCsenyEk-ltuJ?;@Z;=qe%sKH)zyxD;4
zzpZd(!v<HZqJ%+NECsqGhFpD)*d~ET52$Rs!2)D&<X}El<qC4$E#PACyFpv)%+)rj
z-I!I*!UP~hJaufN5d}lMZ;D__cxSJe3QCd{O2Ay+rR+ms*vmaYn>9Lq=&|9wQDRR~
z{;qqF{)*5)egjwfxb|8lle3lYJco`WYAZ6idoc@7kMj(eXQ0?{76d@3l~Fk1mNm0y
z(v3JNn5tfBtG@5=(WHRp#p(A+aslf^!|D@eok*Tc;Oh-=OIL1gViD%SP~StgdJGCW
zq1D=b^DV--hTbXH8$~D+kzFKBNWKKj>kxkV7-ti}5$_+fYV-!?4<z5?6^88UI-$}s
zTdA^`Z6R#hX<yc)sQaK#lTD)mS#5*_^|*?3wcTHSc+|Wje~Rtq+B5iqoEFRBbKXJd
zqg9&*3dPAQQE=usmPGISP1S3W9^?Hn#@rVB+RYOAspJLkktZ4Y^xGrz>;IhvP-1g`
zO%|0!P6MT3dErjW@m2DLP05Us$ureBE7gusWsEU-lQKzTUmED7aOPn-3H0f1!>jiJ
zjCA@=iNMPofm=)z@%QCo3WOmAay$nn8|nQDaEWiaF;1e`;I!JOhvKcf+epj_@n2nP
zQ3Xv!>7n8pWR&}7w9<{RT3`N3dJVMC+UJC!*E7F>d4L)Z#D4&>vv{Eb+7ll~H-?_~
z-czkZ@k~H;B#Q_8v4(OxCFJ9rY!KaL#k*;C#y7=jG!TaLn8yy3>S54Q3T_<)7enAU
zuiiw3BNt1F*GDE6E!ebQ4V8z3o1H1_kBG8EDK!u^Ge1Kh)gh2tCFZ{%g{yHMjfMIY
zij7^a2rNuU?rY+o`jz(x(yul6Inh%>fK+9SvZNi}oHvv@b*6S12+u(3=vmB(PI@vS
zqdIxl&{$3^Ue}>+0j%7pk-ny_{Fg?3lDg0Gb?o|Tox)daVkV>s5(_ay&e(BMnrDr^
z-biIy&2!}@g8;W<QrmW^PFOh5-`{mFS|m4$pGX^!?daej-kZFG)0u#oo085Mt~mNq
z<o%7NnnnM*lwPamI|M^TLxk0m&9<TAF|K+iNKlJtK$-5MqDW}Y@dM_%d{+_h<FBu}
zSrDcx`6Ek)@RymtKq-?d<x^D;@dR9p^P=9aB0mxuVXwVXeb2ex4N#Sh2Bv*xfF^Ym
z=!nccgR2we^zPuejwP~3?ccC|j>>Tl$$or$x*lqb>7QT*e(d2X98DT$&?IUY9pw{2
z3nI0x(AO^61jUg`U*^RW=0sTUSfD(T_vvWHrCK1~k=eAWBkS{XWz)cj7-z~M5hOEo
zr(*5iqAkAc6VqP7?niHbi|gh>Hn2OWV=XTt?2xV{5)Ill-f2tLCv~=Y!uQv?di3D?
z&Kzisud6;Ra(5e(<qv!Q>LCszHEg@Ftr!>c3e-@T8y#j%!s>G7qR+M`jK3oS{ZM>T
z|IyVvI#U0Si~hAH{uiUKC-=2^)_#nz(Fvb&VImKXP3hpZX9}a;9&^G1PB+N8&AQL;
zqAqanxVU)=CV`DNw88gbEHxhVxXw>{UauSKlDb_I)#XMx+rF#YrG~nBbh}te_2zr%
z;v91C>8Bnz6r`<*62n&vd$)sTh!^l#wGeq43n?!*=)!&XQS^uR^(d+N^}IZAg&7bM
z1af!#RGB3){hratxb44_`tpDF@#~*#$KNpFxacqn%-y&%dO(v<_W47Oy%j1zIZrP7
zRj{-)uc!Eap4m#LlX%$mf!2NS&y@&9Q@XBwz=3mi6Xq^?kC#SvHg)*SmUI)}GMK!Z
zD*h!iHqI}d)#Ke^SV3#l!1UPoig`2|8^r&OnfeSV``yUt8@e_m&Vv-%Zf<x}{atMm
zT3|HM>mO%nmEPPpW?MacB&gkazGtnewxuyxfWDEMXZfJ*Bo+fsYfJ23ohi1eCuz@I
zG$xJ0QskIULkjYf1d^xRBILD9o;t{c)`&XUbv+YSAz>KsZrQoj`Ld42{dn#kZ?*ji
zlRI`B+8q}99<0b%AKj7k1<&`BX#EKG;R6Fe_@c}ug5dt(RMF)#&|ldyVzm}|4m!V}
zwGtw-{qo&+<DTi@LyhiopY8RZEA`Q5q}PytG)EBjFw>*A6z>6K3(7(VCn^QRfn5mp
zdF6vPK&cA(@Q6~MVG||yM6X7ArOI)+t^${8LwRpC&b-HnCSh<vO`7D0M=@^A(Ka!M
zu<;Midr7Go2iVYnXmO^pR}lRP)kx|MJ5FER54my=hCpYOCLELk!gzkru$>RM(;@*7
z5bZmE(_!MI3-lwu$+7J#<hC3^YM^?$>qF3JtU`dXj^5C-+LZRKO}r;m^QFXr-}LI$
znS}orWp5c2XSZ#QLI-zu2@u>NxO;%c-CcsaOXI;IxLa_y;10pvA-KD{ef^$$cb!|e
z>g;cyKV8+;Kf3!_YtAv|7<0|lR4+Eg5pJ9x%4^%RR;shX!Kobt8)gKLR&ri^H8)L+
zEh6%(ODoTnD@oYM9`VUAQPC7~o+x_eVfk}XT3oq%V%I@1rc{dol)yYcta_QaLOv4&
zvF8ICL`N6CjKJCKZ@+Y>7x<xP!!6E3c<1uDU@t-_0zQa)rUx>a0$#||IY*UNZtv;d
zsf)0e?eBPJ2n{ptiU=VdC`#fyZ_Br)$|dkPC(lL>7$6dou+nN&-g^d>sqQr^EVx!q
zxGk%v)*f^h%jSu?gvB*Jntn`RdV3*6r6*1iXDbi+A0)<hD1QNd>bi6|x%v)6u6ppC
zCM&mCGf&t754a~_z$F8jHPdoNA}<%2CDX<JAuc58_&n4|i%na$*|L;Uad;<+frYQv
z9t`qyTd?kfBCx)4I};3o3)9s-rtZRv2-n1bei_t<XxsdxKV}?xJ67qJTs<=#o>&;@
zSl6dxN@w%s>&dqyZFfN1Yji(>Pmw7L`Z+<M=73zjhc+Tf4#!VVOXjd3rn65|01})%
zy6dSnIN`QW4c6?aZdS8!aOvTVT0-f+%&aLzpQTrB``oqGzlvbS*b7=Zdu80=3q-_2
zCc;3HC>Y+3fnC(Mn)KBAGMz4Z9+H$=+qrathOAjM3X0MM`}%r7wWG!kQS>htQ&}}h
zq1czm%jn7NFV&MFkgZAkLzE}(EFV1t(Yv%%vu(Ws?Usw*D*xX(T9<e*FalrAbPQP>
zzG8`XF^XPuq>sx!;pMqiSwB%><gu^~xKYnetXO_mFOk|L$>=^^JTRQukAJ#c{AN=@
zo>)fVuN&>-f%&Lwc3XGzhc+gdHM~}<YS1Dmd$6@k?sMjbfy_QPo#f9VM`W8>F{pu^
zZ^T+%B?`O*^I?_^ok*ljeUonvOP*)lO1M^ELB&u0P_{wD6YRKoR?}bo&ZvJd=nc+D
z!e8lo=YC18-v5ToFW)|Eu}O>{xVrN>uCmxRbC8kGlk;&^Z&-@wxDRKWj}VT@_A|E0
zS{JIJokMJa{XX<qR%U->u`AJ<5u$9@8#WHEh9kYUMDV@K|8|y)*FQpa!^M{i#+yI4
z0mn`5<t?(acTp1^liv5`LCfAcT^~y?uS=^P0~c$Jf5YzjUpWYJ+aPYyP7_`rz7EEn
z+YTdvI~qRaIw!#d(xN!ao?zP_5Pys)_}K2rO@n5k=%XEsj{#FetxZ$?X<8`ECvHSq
zQiGwIXX_PeCsDgd98!Wp@4bIlg1hcu_|KrZ(~X`7%CfY0A#O)zO+%P=y1FhMAzWJ7
z{b4~=hcrl2#1OpgkeGRLwpm<ntAh`1Dcbhd=N~Pa2X95NNe1@%(Dvkr+#T|=Re@Br
zm1@+Ghx*((SK#9*7o^RiX2xr`Jv$FOyWoi}x0u446@#%0Y+*DC_G|s?`f%2@bjq-s
zb8m|;H5X;@I0P`EQ(QI&EORoV3cOemIDu%$+;Y+=XCyCg5SFzf+uY~xJeGafbb*Tv
zeak%j_lL6-HJX;*>)KLo>=7N&{MS%l&aK&emWUH?MxjtB!7XcIMz2bO*o>d~Lb&xV
zbMT6=*C7#Yi(wcUE4)PW=+epHzc-fbGGdxn%&shdQA`E)*ZxitCD##=O*Ov5!6Ob<
zhCg{)GhZ6>Dv^*vs-5KLIs}!5K(QS`-S<lWf`3gSY-sT7d87fi`iN3m=%N47Z=4q9
zs|s<`GcqbvYFDLl$viNrG?^9f`?I1`&fTScjHEdItzyfdF@{QmW08z*#m_?AQGUH*
z##p;ZB5e^8+0E37)WsBoz3wJAH0u`brTiA^!(*a)CIUq?E6IiT>u*bQ+lamIyj3Y7
zWcTmbYGhGIUKDfSdlxyTvBu8OeLrI(uy(P)q$uwB%}4UfKdN8oYKs`_<mJ_-yyTkU
zSk)r`MGfsqONVk#3unQb#n54P(6REV#uYtKvMK*LdgFcOW+#MOdBE+D&!Ih^(IDqf
zm2jw8wCy)lQOS}1G{k@ZU;uGsE1FPQ1mc4CE(^)ZP~RpRZCQaHY10{Y3p}8v%WAAA
ziO!z%d@D9xr9eB1kxL)tfP3RC^Qo9M2S#4UAAML{2;}UJoPX`$>Uc=o>j<)jSQF;^
zx%O4I-gI)}&(9k(?D8Ms@ZYgl-hvutU<c@aJ+UC1eKRq}YZFu8T&)cVmC9?c9+A25
zEn0W3x8qUeKv09m8oT%zT`|^v&vTIN&3?mkVf3?MdYjU}k(3TzYj_rcyGh!pd090_
z+jDTxi8bJ;ha*`w;KcZu$-q>(Mn!gzLu<^(ppf;3Jvu$daNJ5yvXNBnybI&BzNEGw
zvkY^*59nLDx8s#IRPn`%eO38n!SQ=z6#SN4(dohnG{QE60f~yYRf=^6>;<CMA|vO3
z7$x{(n`Vo$KE{LzLf3QDkPm{8dC6$o+p6bz{YCuu^62LLW6o+s!I8IPpF%wQIpxrd
zmCo|#wOxyOaOaFRaw?r;5z3AJR}CZW)`<dNq_P-%Te5X#@1=lv=}X{a(Ljt7StL?I
z?5L@SL$t=2hi~0Ak@J(039&27^y<jXTtAd$fp!Exp%;Qn_{m6N<E~8-OQ+uWl6g<}
zga}v-AM+YPLE-RIFTtTftjC;myCM#3@Awe3%i(X=jXef^H`Um!<Sd_<d(sXV?B*Og
zb*qb8K6iLaI=j0d3Y+hfhheH3?D=IszuepXJI~HS;Kyec7ZP0mYew*-GE>1Pp&Gvr
z7(Tg_I73)F+nE)Ehz(BMQ~iOUm)@9tx-DHk`}ud44!!weUd%uAL{~+LX2fRRWo6GO
zJ8lAZY+BxzSwe$_H@=VR%+ROf-(T;$`~tmEQ)(n>`McK6NdS`iH~>*$I5<eM&rrc2
zG_?QmjYlP1W*&sxM7mn8-{Fk^y|RCKPGnQIJ$(JD&~eko!v6AG?ECxq;@pN#<b^>8
z75ph~?pXlIJH#OA!Eeq=sKbvVSo_U0U-+rECdbsNHt%fex3^_oqK~7L*>AfU&F_C$
zo>P;5$^A{C^5?F+hFvmt%6gd(?Awrr4;0c?iI|$nMb&KSzz*tqLhIT04JJTMt4iIS
ztatUncHaKTe1?HObVtF;wJ(7>6awB1juAs@6C2R}j_MDZRMg?KhD;X%sQg8Pd<Kbv
z=j?|=__Ejph5rnxgkAgesrmjK?%6xYp{~Qq-FZo?C~-6HX4b$k{3t$w5W8}xZ=#L*
zQI?WLW!*_!l*q~#DL|gEeF17!@RM>Oik$Eve6gqCpgfZ>X-x)I1nz<%7x@l)R6Ay1
z<A71EP>#4ysI)WDaob}sRNE(YT4wkFY7Fqt2>&tR0YfRgx&<FR#oil(pV-C^4E&|x
zx;d8*u|#K2j;~;t{6H=pF(xBnQ;LFvwaniM!Q0jg_q^snFA}-^*%qjJ{oNGvRQKn|
z=X9pL?ij0Mb@{G(eg_lgtw?g=uHX==Himyz)FThx#+9g6bLlFGjbFlVK0H^+!U9CK
zXQqQ&k<B&je#BPw@yM20gk16VTwUw-fr7(T{tb6t?fEP9-SBY4<rK8;>v>mi3z^Ua
zAt`wqcewxixEOzCYyjj6P%lOLKiE0{wWm(eJRqSgDe0QV&GiJ=r`3N4A2MEP`TOhG
ztn;G0-DUMzSu@90YvcrpO|o5;b(@l#z=ru`HBW5Cw>|u_)x$&C+3@dT6h1kbP7yrX
zIln6fZ>YT#m2X$D{SQ@9#<{cAm7P7};z^RpYr22-3o?-6%P7A3ps!E(6^TQq*8I9Q
zBh85dy4C%jao{*WtJnx^5=6A12xw!afA>1plbKt*BK2nh-xS;DjkAuEo00^vCa?bW
zTn4lNWm$Bnl}hwrD&i~4w;~fE2ozm0h#3*w;JZ-oagI&B32pr%d_h}Z??Dc@C7Vk_
zvt)VMIzT%UE69R_`TP3RDX{r?PFeQ!C5$phf;_(4t2IFP$)z9iQvw7sC+TaD5mLtn
zVpvDO>n>4*Cspyw{M413Th)+*=B)*Vu#V^7_i%Xe(6_@glWjw)@D?G4&w@ET%7JTk
zlGjaW+;ouWxv?_G75geh_3-9YO}x55g+^B5pDA~hHPeIcGKH<2bR}%)Y?E{21O?3V
z0wR&MO)wOD3{)p8r|Oz%zpT{ZGmdcrhzkf@saBMi$`)wEobi*YS|0SbujD$Ss((Pd
zu_dRU*8h_iHle8u9WI{<0{TuQYQnxR?9)ZORw$07c*^a$E(!&1F1fQf7-8WuXH1Wb
zZT1Mg3nY{9iwAD#VVxBFHmYsdU)J|OO0?fhKd|7jcGur}i(8Ovxjz`EZZNRT>g+X*
ze);$L=f5+P8{7|w4shs*0YUqC6?EUV<me!uH~c?-CPQ@SXil(cIZ$eeCyN=7T3joy
zA0hH??ZnMl&0yvxLA+IRNwLn&%Y&-0ZiXlq;&s#i{Mk(*if@kC-1LNk{j+s}zt7Sn
z!U*m4(AoG<EO1(xBt3QhOhF|)**C2@*jEDivA4ydyM7e}eOS0_0zZ`wAqUCl=T8r*
z4Ry%5z4&N=o{LKB!=cJYY1uX#B0SV*RKs)1Zm~w{va%Vsz2`$T5NIW)Jtg@~$TUgH
zKdn!j9e<tRT*8AJ)Wbz1rs1slWQy{{5OzS)3=*y;e9OYh#VlqJRssHcLe{XyZQbYq
zDRRx~>zvS3NwU5a<6)E&g=WH%=l4#_s_gUg{<9e-WcGcY;KA#5osvfs@L%f|LT-5J
z1eGS}R&(CdO}GZ0L|;;<Qi8o)T4EG9Fgrexq=EK>8{Mt)bJHutgWnsx`hmKlsYSuc
z_m{~U^jK2jPeIME<MeQCPrjpnb83d;ozHC((MRduw5a}XnDMVQt4ZljL!6?6Zf;D%
zs<=q+nR@3qyINdzK2`8pm&RD{(tT-Rg1^wOvf?D0gtAmQfJl(77K5K+lmpq>@4Tu5
zZuuyPpY6WKqAt`ue%MtQS_#x2+!Y9>9o}zQ*gxzT$7<+^<L0s#Qg!;;Vil~3V7rfP
z{aviRzNEKd;uocA?N?ea2U=WH%yESVj9!pW3BVz$<VF|${?<|N>pI35k%FD7!;_lf
znW{|*w8grbY`VVW7KnwPikM7^gh!ZSPo2TYRioqDlPf@%K$r@D$;of!h1IBqqsPo`
z<eFDs@o?wtxLcI>Y%uVc@o9Cb`dN&cp$c#@p@&@AZtOALiR)k!a0ieJlZIxxE($L%
znVOH3ro{po1Pm9FWw<Lf6nCa(UWJx+GaZz5SbIsrKf8Dmi69I?>JaT|0wSBXhcxsY
zVsyn#H}T=8B<bHQP+$A>@ZQ$B`8%n~>Jz?AO4PC$2r~`r?2%+YvM79$#_{KXC(;9%
zi#~-o2Ezoxg{52W{rs_(F5<)*4y+nTysj_J8>gzaCR!5_82JK~EiMdoNR9sUA>_XZ
zz-B2N-s|fl+YdB8t(=z$j@zi)9y5*}bEN`?%k>}Nmmox$VahN2LQ;tjkBGB`-zc45
zb>A6yxyvRW%qzu8xlY5z$IhH@GugU=hMeXyM@p&Xg|HdZwEi=!*o3BZa04`$!xDT=
zxp$myVWbdv_sZDz%X5=zUITBHryf9qrw#}Os2d~)4(hp4vu1m3z-^Z$weST~+vGmR
zqe55apIaZ}hf%3_Z{sh)AD2On?Lrs}$<xr5cLnPYRk23DW+Sayemsuw?{_{^7|XH)
zqsE<nJd{ysJhwfwI2;kXAY}zH&p`7f7-07&W0Z0u`BW;0%EWRi>bo`jrhl<DlsOsG
z#^`Ec1vf_h_;~CKKRYYWQuMK-fqdS<=hv3`{!*x~0&t=I19j*v1IosR)TX%c`k(*<
z#GZYP;%A5MEhjR(`|bfK%R9{Xcc??L<o!`sZ78)w1n6Ho-?38Li<IZHQ=QFs-5A|G
zUihXS)@h(ke?wc>4>8%ZWkr9Vl@w~<Ntt4Ow1Kh=nuo7%!`!+;0s6ENa;m`BDx6aY
zVoH$D3&#`lnPLDYBS6b1K?N3|0t)dduG7GA;UhmcnD9Nke0nu3r?PkaC6Uijo0OEo
zuxJR^+G)~?pzL|5LmPdlLkl&*y7gJg&w$&b>%>NQNN~98djnv&y4Vdz*!eV3JAAR%
zDBdnxmOW>BCNlrPXgBhgEz>B|&z`3Ge##i7|7KoB<0Q_I_HTLRzj6eaes)KSZUUhW
zNA>I*R%Yrja=#PW<BwOKjm`aTu1FgqpndZs%wYO@g62xr+A(o9?`W$tdSriycv)+_
z&M4f3nVZpuk-G}Gm1yr^hSY|i`Z%dBV&%yB+xWZSgNK!fUlBB+rv2EnT5x!y6Bkis
zWD)}}`|ut-_a}milfFkQe9SEtHDE&DB|3AkMka7St`R(`Ia(WfKo@8E5yp7bnI*0A
zFw5gprvvT>r-_?Dh=CtZIrv+)U@;&6Sn6~yJhU?kPl73f`7$0d4J)Kq6NIf2{M72+
zoWAy;w<V8d-Al4=mA#_3O;=vZto+kOn)K6J1-TqT9x`49jAlooEG48D^RI(j@FNHk
zAsizTU0IKP-!f`{8Fxgw3)?j8Sj(C8yPWZ9)H3bXMk2hqX?_~?*3^t5AGd70UN5?+
z9YE%!2A-n?FVz~~zJ0C;Wy?1h`^<qW#XBoJOYBnwXc*oJ>+psnHX)1B+p3u_WWe!%
zgR4!0nl1L65S-rhJB{0gCUY<aQ0b$d>AeA&enAKvhpy?08+nqH7UC`7$_y2%L4WO;
z#+Tehz?^w`gL^zFq2Bqio>>5qC0aEkF5;@i7bK05I|=bD+b)fsYp~s$pojZUMbRDy
zHTJ4$A2zTRN<ZZ7Rg9@lC0s5)r44YY|8qgMM4OORF1!4Nj?%4Rf81AWK<Gaw1NvwH
z3mReir^YM@Uv+@Xv|Uihwf^BYp92ddc%q^JR*!-20a4YJ<HM~XW8}xf9|UvGx;6vB
z>y4c?{nt}3Ql|UI1~b9plE<z$FG<3MyO+gKwA%SvURP9WXH@j898tjzuJ0?RwY~c;
z1tx}2CiZ@q@ttI;PuhjLqP(pU{m(zCgmrA(kn}we<KLB<Um+PNM<3^-c|2@jUMDw5
z2fcOR=bmHy8#8-9?v5BpDoq<wR^X>#u<~V>+Hc_L=-C~xB5G92eYzN#PDZm;K}GBB
zjb$AtYaQ=Y(1)#XQ@lUfy|Eyl4R70^4<9-?0`daTGAkzL5Mnqv+~B83HwIqOp)E00
z)@`%I4m06QURx7-U7=5Ga%ReTY*Q@@R#7!RKED#9hyy(5QhnMyoRKpSX?Iny2u6VJ
zJ0!;zo6~OUIgwfDqDCH*Sr+6SsBaw-b2Q2FA71FSPe_R>bno>OG9)?BkO{M&5UbaE
zdRU$(YpdE$O8zXw>nV`8isSRDNJSo<#yFtm-Mn48w`|rWDaKHGWHTrxny>Kkk!B^8
zFavJuOR%fYc_l!8uA}NP!2b*f{<|pUCJA6i&#h*G)Q-HHhdvy<Z3~iE>ca?qAZ=yZ
zJ+5y0jWd@}Fn^OiA6VB1>AeBhTJ7_Rq==3yosV|l;3e>}X@jT_o2unJo2`&QU4;^1
zbTBgNmWSaGnLCeU{&r6k@bPkC9#6Y)wMFQA$vKnSdd13#Q=~Ljq*$KlZl7H`1~g?$
z+d_8Db>9WN0zq!g{5053nmOLVbNh63!0&ZSL~svC`OcP^#!F`X<?65d_x$ag6z^dd
zQQK#E9fPj+j6oj<e=v#`X@xPnsDv?1?R?R}RH}Cy%ci9_8DednGOJ#n$=mG~L@kxI
zVQ6`hTDc%EV40T%VVekb_-RP6D@7b67|cN_8#D}Ayc+EghRRedmyqLbbxAgQ#N5Q4
z=u#f2EEu~>wYMvp7Ji_B^CJm#ik~68D9$ChaoN4YnV*>dL$|D;R31pxlR=DCa7MLM
z0kokvjnmPQaIyLnY2f(n<c@rj0Y>rU#c@~4)f9%ijc@wu9y{1O3r>4MNjK8?_(txF
zI>HKXEVVkRC$;IH#Y|Aoac~;#L1!lmOqE*??v|$}WA4vkl|XZCve_&hb3PkEu68|O
zq#G-0YrKRVWlR!b`6*4DL`c#{MIaJ*FO1V)s*rTTO)0<w&HpP){NF{0{{{<vPk;rr
zuywMnPJ=JM|E-~|BCc)Dmzm>>lS2162)!n4rG1v_ssN?it~)t|Dc^LK68jxpdkFul
zb2z3e$B$o;b1w!$6E}pB(ys>_lVtI<o6os~G22w;cD{j+D;VjnMfGe?kGaDWSe6FO
zm`nz7$|+$p&XCi4T39pEw)ja9XSXm@(_B$oql@wEu$Rj&0LUg}|GP7EJNjmeM$}Zx
zH}|Gg8)92(ofCkIxh;C6|Fb~dP3%|572Q%B=3?iCG}|u6AyTO<12FnSbV4vkLilQu
z)r_;H8nR{366hFmW;6(rz&4p$5%X7PSiv2^SViTi9o-xQHEff9lHYNj)Knf->%96k
zhryr|MCG<k!pAnP)r$IWbh|u)D@Vc>cy|6zYlk2AYEZlkHHF3TI=X{n9Sq9TS#F{m
zxSm*mV!3X^x?V%0GG`44y_D9p%Q5Scpse6@VBkcOQgzc5+p=NZb-T-TrcI)vG-aHY
zw6O_WfNuM*!bDP^B!ROIUmss`VWA0eeV$AZ+*DY7y!(HO^Z$~W0u~dx)8M93+L)T^
zeUsQrnorD6)$vb<{Jrl)-j;Vt^PlOTiM)({8*nu=)ittG;sachAbdd(mCQWT^%TN6
zMVA%T2L5wk!Dq}QdbqS;g2?8{RUFqMPL{fXc+Dt}dD>4kzi`0HqPsjPd<v&E(KRvc
z^>2w9hv$r?GFws7PZwA($%%s9(|*&Dz^Vzf_v5~;YV=%ZFK#X%3`HVD$K}AqJ=~O+
z<I(ob`+@hv?UjWWt&-fTSN+?_)`^nyZ$*0!!#JqJ!2rQQ4RC}){q7laaU-;GD{6bu
zb6Ba|q=hTcUw&X-sK`?*h|;1XOQ6kHEwztK4a>TD(a6gtWW-6;WztOJwslW6tfgV~
zw5aoVbGSq8-PjWT5+}u&(7ip*VZ+2?#;Yb$IVO*jsV9W#p6oMYU_Q}pLVVP7h|1hU
zxcS86je69=!7zE1svJ#SDZGvgpr-D&PVBJ^oj)mpA`Y$QgYf72xMvB-QcL_qWvNm>
zaT8fUn~3q<G?^>jNGeA+zxU>%`R-%4t!m*PuIJ#Rw*b~MPLyYyGXEoK@V}!nxLXOn
z-34&llb`*5?6+F;_KXRAXiW#%YJeH$`lKie^0R=#O#_$dpa~^aU4^8$>baN^k4Yc9
z4CpmTSbk1QGys<x;4AduQ;Vng$W4thXrg$#Bw5xwneQAk35EFZP;y``h{FUmG!*75
z<nu}=)L|I7_`jzsdMXj$U4x&Z#?HM{UN(?XU={{vTSD44C8ow{rlg}5Ot9vLwwsuP
zY%cT~@cB867Y(V|u)yd04E@LZz_Hm^dTCP(X$I!Ocpz>bTY`cP;qTDi%NPSu*x9`o
zKK7C?#;LC!$h8Bye2!ipe#Cbz0fW}J<SYw8&O-QMqk3ZJ<*VQ1s*QX*Vsy_d*j!`1
zAlNp_#k(yFFHf&}@o!n6R}gWlYdPKE6tmE{8$PAaBa}UnM}#Bs-ThMB<!D#7W(|0=
zq5T2j`}@`4cV#5RTU}D>Y4yL6WB)(T{9oY&Np@KQp9z*W3r~<+YewqSKDca(V~?wH
znMTfcfBwea&stp7L{UImf9XVVbT@XibqCxw+V`w34}SeaOsRpJ%d7-i7m%~vy}a>0
zN!{CVEShFQ74#|~#Pm^3U=kMc;)ZvB#i?lFm@8L1A3aLdlEj>4JwuTLO@uL-Y`?Y)
zg7rN<Ax(S4DR$r=)dVVG_D;_F)*3L1O=24seJgVQt0%Z3y83ZQS(tKoPq;$*GAid^
zHCYIbVLbu+YyaqEj9g@_Tw8MClbY<C0=OyIPh6?|EK6Qf?A)M}ix{I^X1HRET-0ph
z5+z|KWgLC&ehvThfop9H=!KhOqZ`tjI}1u-LLdqrgGew{tHZki3hPyCRDZF1T&nh<
zd3%7UlKrQcmYup(G!Ftmlow}uTIfWKggPH-TCm+$R`3{Cs8U3@>d$vD$EVGz^lCiH
zqGBBlC))R43HdraB|w4#$<=-7;vhd_8Lb$l|1F6Df29S3un^NwnTFe3%e{eD;LXIz
znb=>(ArhCV=a*;iwgGKDkQ-`Lek`D&x||dlVd{B-+6(ZANF{uMn`_Th)X={_T$tFo
zQtZVqgtmkcw`$zj*%_8F%Q8UPtNKG={yB!%xer@}!Uqy}BKBgrQ(GT1R}FAmsn!5(
ziD4mvM=NZxh{O6ZU>~2A5h##?3;A5qZ7}@=PF&4~$W*v{uS_oYcU#9gVuwdpeG|?@
zPM4>a^9Yv71xvbGJ#VWwn#<qBc=`rMlY~que3nn|`j)xi{EI(j1@K!fBjH^9i4RY1
zaC7s|@On(Y?=)dy1&beH)k2^EcZ!;{vTqw%66R^83oSS!Njp`Z7jC<0XdX%b2vu|`
z=SQR&a8t#TstYv#sRsBjsA>NTH6ae_9D}lyvs$;OxiBfU5NlFZz0H<RIl1rZv?w~G
ze&H$*KWvo&x$$g~;E8=S+V{#rwhnWBl};}Q*SSq$s5rSo*@L^vUfypCH-k@*Lhr{x
zM!JN5DTT}L#wDi9OpPp6v&~(lvYQHnB{Faiq<A?XpPvmKChJfWA$)b<r_M~R<v{yF
zG9dlOZTF!Gp+LrR#3|m7dpeg+#^mGkVMEKwrjNTU&y@>$Nbkvp#^*Jic&I~x;EB_4
zFmC2@r5drU7`k(BAvbTju!JPnpO-K5A#$BqUg=gRMhyKzq)D<?OuIlT6qp~jtnEH@
z=rQK%F{;edD$h$T%~!WOJ+^d;k|O}}>$5Y+6B0pE)e#bum?3Dl+Ep$XTl_SsP{Bb5
zRO5riL4$gL(AHK2gs&*5uK9nRTSm~i*&(${17gFgUoHi4A-&=Nw>nt4ZM4EFD+Pec
zvjLtYup0VoY_Frb;BL#CJ}9)NH+Y&%Q_<x&H#jYi`hM!f^@ne5g`8S%L#e5JlIzcz
zfB%_+i|1`h!(bR8j~pmF#=P-BQf3$lBq<4gK$-dv)L<v$ltY+y87B3VbLo{ylh#US
zOtPp$XsemVhRfP)E&>~iMsbmTJOO@AVJWkn5lSBxth05Y6#94#(txq7Hjx9YTU=(s
zm&7<z(Vuc62HMeQs@E?lO<5`m?5CHgTG8yv($t6<hEuT3yFUc_PP9F<*-qHh_HMcK
z8nN~+m*q~x#0(n~7e0^r<*dKA8*^qDIWKLQb~x$)YtkRnLhKvUPr0>e3lvK~t65!o
z7{npe>rIZswT`jWds~+(iq`5%X&v8<x>yZ&A_Qo}fTnxpPf)o2GSQ1N>3h%Lkta*l
zYD%d23jJDH5e8kXZZ+Z?u{WVN9NXBBdhU8g#}t-pd*25(G*|254@3T!2J^4I|Np1U
z4r~C6FTw^3o$PDqxvK_w$0FTc#+MT}1;o2MHzx+;Wu((3Z?@DJ<xrONBX$Ci&pNB{
zQ_sm%t#7ahQ!O&Yghy;nuL1Ym34?YbDH|x03tS`MrCK}}d#QOC+ulO`u?9JKe}Bj2
z3aKp%+IO;2qVP8wt6(CE0~4}Bq4T|puh$(36J2jsvXRT{d{QsVkbD&#c@4Kz{z&%S
zh8*3;dnpf`N!9eTH&kGnaYN;|vI@2>@F%KRc&kt-mPmsa%>u`t?^eI7r=DlVkT(+b
z&Aef;Wtg2YZ1@-XziIF4fdwcxFpzt3AwRuHLxD3f2AQV;99#fy5~$}C)N?Ln{{_@E
z7>EbQyR|zgNcm%?SClQj_jC>c#{|DZReOkI7v*Ny>^o@iKx%Rm%}YQXiNl1(l>O0$
zCv4B=j<QR^-e2F*^Y7vDnYe#{tWnn|vNnA6&iVW(4PccKYkEKKiA2TTvBIA_qWz`P
z1ASdm#~v|SUo$uC@>+%k&FUNF>KrlJAu8|!asL1f5C#_81H_2nF9{1=@#>|0o?f)Z
zn2O@}C>IxIgL<s(jZ7N|amjJSGs}qgANE7A%4&JWCMvewxlA;dXgYTnQ-ThMtp6<m
zYe#_6cZOVne(0uouJ%O~OoA9^_H*TN7gYeAUv)L?wNs=DJ)x0c=6+8o$2uHaNrn*M
zg4f|hb#4@ud|52+%0(P|cJ}SOKj8~}et&qFC>C1v#Deq+8(4m)1l%rP3q38kLmf_7
z7r-G0Z@RK?4d&;x!P@6(4Xc3Gg`HSK2fU?C^TDz<P(~jcAVm#c)oHEaf2x6MX+{=J
zBbHV}XYWnqHY2tLML9_&+FhlpTK3#)34=)Kwd$H696q~eeooD(R|ZA8{N7)SfC?6!
z)EX=6p1CrLEE94vzLK)4QaS}qIT%dL&`K0W9!^UxR>#K^KKb7St_{aTdx7C~!=l6z
zb%Lj}GTw*^Pt^f~CN-AuLw-%r>TV;IHy$!{PpN~d^X{*-8ZUKYofM&V@Ka=5nUaY7
z3>mo@z0Ty}-Uf0;PCPNC%9y3Nl+zD9keq2+)I^EBX}hN!thOqY&Nx=9cb8YKCFiTi
zaG?}<EgtYYkn~KPi*Yf7S2v|!iZIO1bUl1p4qSw(*P^Bo3WmesLY@$J1n?p}ruru7
zz+;C;$f~fMv2r!QsBzOsuCAa165M~Xs%bWKaW!mU4kp#VCj*fe*(<T=N*msDR4h_g
z!W4JDvX0)(J?xBWc+{Poq+N8LcGto!iLSu`+oQRd#4o3lc*okCUhVz83EfHU$S1tf
zMg<{Txpo8lF2X9~Lp*OFN!D@(Hr~zg9}eo6AMW-vZ%xU-(epp04zREb1F#?$HaPMM
z64JX0Yh$EvlZsl4JiS`H%elHA@p@)|Tgz%ZtUh!;ZC5b?xR}vHdVv598ko6vPXSlw
z5SY1P4p)?DxjB+9>tr<#%yOX4dYB}LN=w>%FTm|9ZkL#wEQnJHiQ8x9>Fl86<L+(p
zj)UaBbtF+8e#%uEw4jtV4Q6~6Q15e`<ymVr%|ta}9W|cB+RydN4Ii0nZ9P;HQRXcm
znJRJV!a%yPjD^XC4(Abe@PCSt0lOCkKYu=9{R45aUWP2thBeXoCLTz*oz5ss&IIAi
z{^3i1k)(1<$qf7k<d)Bje_t~5@%9Sp@^6IaHU=Dzuwf)-9Yh;7cQCbY%m)@K_pcqv
zF$_cw)r1wj(+-?ocB3EmLO_qWd+QzEl-&^vHkL`uITP&}vxh6-)N9Jr_fcC2HF^^l
zAj7cF+IaG7PzS=LTMsc+eI}4KDf+h6<YlG9`}%qEnm8z2xm69bJIIb+H_=y4oixF>
z0~mbYtv;@TmDT%IVtP>t<mTZ6=Zcy;Y2OE}gEOy-lf(E+3w2am@_xs{_r>pB4Ldg)
zhkC3^9_jie)!yK;V0J;=jWN`NE%r_Z6W@<ii5Yj9L>-NuQ_(OiL?tW6vlEQ>WrYsU
z^nB(m+3zu#cLWM<z5*v5DQBdy-CF<`Rm@y#6u!&=h`+DdL!;C8<h}xU9yfAG!E$(I
za>l;qB2b4rc`1ee^UeW(;vo;E4-ctbt1R?M@O`%SePqXJ<2Qr=cW8h$sSTwtyPl18
z{FU8D0Kg>%-h}X#l}$sP$Ao$4SH`x~5;1DRT<a${51V}fXQ5w@ukKBYENyAC`WniO
z!<NEcu8=o5AL^L7m304jtO9@aoBrVh1eA6x`1s<Mq0=^|QekJEG-0H=3DQ6AsM4dU
z2!MOmrOiJ7xDMRt0U8FN{SMqhF2>~<yO4R~faU&!_9jK*3Z&Dyxr!vEy&;ScWn#78
ztg#B2DbiKu<-|Bl_KgmnzYUIsKJiK7r*q7e0sR>hl}ep_b$iNJc*7yyJkC6@4Omn8
zj9hd@KK7a}*C(rbtfNidaQ&m_+nQ=?v?L<xHcnWzJX7s%A40F*`92+jCxvBa_j;8D
zw*4V_3?lLQI!3lCtL5Y4jGthwg}~34_<K`R*RPo`)Y0#AU`~`5%OMAuL5by=coOOT
zeG_L{LJCIiK>_@$kzi2B9Br(NQA3|4vT@wt&Du%UAxk|2b#YBI#$Y9oczUFK#fex~
zM~%E;8okGoIl*ZIiOi73BnHqRGvZ4OZR!3w>U`@a^#}K56@9o9T|mypYQJekGxf4h
zSkbfH&b%CmbGf7D`I%)Mw>x%{Z_^rw#S=Vf#+r64iSS$b&@GNo%B8M)_*C(G?QZHp
zIouQ<$8E?fxLkY|B^eEOJ2qWh#I)7M5o8A#Fbg-OYE&y6KO2i%df?%9z6j{zIqgJT
zq5nh#cc`5F*!{OPQ~>VJZbUL+p|q&?f|_SGw+EM{lePn%M|(Zcy&~v*11I-Mhd`s$
z$Cy(1<MeqGY{t({^S>XR!<aukvdNod+4;D%5Mt_`pRH-s-2_Dwy=TKu@d0kDpezxl
z(w3$9wLt6od)Y!RLOLm<5AB}6sIizDp$<d82$O~{)@MkA-LJv>mZ~)BLJ{~Mw*I0g
z!q={=ixYb91tdBvLIzw-?bKkyN(rw08qg3xT#3ZV{Z~J@wf7RX-C;G2$y|l)>#VS~
z=htiNZ(lG{bw<esOcy&;USK`S`;gshFa=Tih%T45+*XWCESTzRVN4i9kWviN4=%@n
zp{hsK)nz1ffZO$zt1>}MNNwij1bA&efJ+>pftXAT+8Hr%I04%9yKM4ZY@AMp^#ad~
zL?K8u@5g`(cAC?h3!lmlk7C@4docYaAp(;nX4LvwSZ@aiOkcrQk2yFg$}na-rmbl!
z0>V=UHN}JKXWbb;?lot%vk}%w4fI^>c3cl$^OnwTDVH%lzU8~SRKlcziBvGCTj)a6
zdH!1v$>ss4VAw%chqq52Z7<V*u}NK0A$*-#Lq1-w$f;6hCfgmd2Vj_x9<MY=QMOhL
z4ZZJVzz1!oz!vFNK|0tMF$CO_W9Ir7Pzvj?DaiakD<lqD585g811nOpdOmeG|F}uQ
zQ2M@*D<d&DOwDhQF34`=Shqd4^*s{sE9Xu<Gn;Rc<|u?G*3En=qKV<<-qe3)`=HuZ
z!-O9o0(&4t?daR>s4L{DZIXFUqoI_ik@?%3e%x8YNUSK{b<lg7WrIW9Rbu#;13RXh
zEfCqYb<32vR;!YwwBLb(UZOm}ydw&RvQ;Jz1h}xE-#b<}_RwkI(mrM3d#!2VcW6DW
zar%Xo5KbJDsJu~<Hxaz)BsjhoN#lr>s_iS=$hE?qFA8#9fw!OfL!cu<OS0E4p^7h8
zHY2U3Tt2*Sp8p;96g+n2577f<tc%PUY?J+U@BV!^?tSmpnep}$4X@Oo<5nMhGsE}(
zk6Xn40}F0|9Pv{GK|oQc6<Or#K2?(n2tmx&{@?_!@u9C9%Z+_`>6DW@i&GOxw>eR)
zMOUP1#uVdavAVC@h$4y#k>PY`(_z_=i_p+kO|hJ1IyDPV#>zt8j5jT}kx}>omPR;Z
zt7`vhKFe&(*0e@iGvuwUbjCEpRn-c4_sO7gIMFi!+if8zcN7URqd>b*<X}eF4_J5r
zM_@jm7Ijx3;@R5!<=G}L6eDF%7~hhhxqZ5KuM)0i&50)y*!_@8z1=tO4CFTlxY#*D
z6V@V`-^l%Hc%Bmu*~=JBQZyu1`FZcwVs*m)UHaLM>X@$uRlOd*V*4+w8|Gf;qP4Ch
zqroo4V)5BvXB|s=+An)|Cr^rYDmR9`x)!>d+q8v??YIZds)VrLt`n*)opdu#_l~6m
zU8Jj>^Q2El($JPcO3_T+*R|RndaQjSBsgxTDhJ+?X3Hhcs*va2EixpD%cD@G@&h=r
zH{yG(zQO$VT2wgKE|>gHrM{o}jBV|^ra$v7;9~ravo0S#2*HS8Sj6bEw{+xb>l;83
z!ST>+c@-oT75H@cu<Fp0Ey0m8P>hJr;5<j`D#N)1!%=RA<pBhjmPB6zX2EIcw*YPi
z;ZU*4<DD`({S(Y-1yR|0*))bKF=NUIzt9PTefB|H=gpGfuY}h;!PA6Ff}@@R&WRqU
z+Vbb&GeYDtzdFH%^0Vj4<6_>yInTOAxggG&pilA(XSr)oO&Mo}U5IaFxa%h{Qn_@S
z=cZVZ;pBB#IkLOcB{U@1zhscF6$`xsj}j*qi<Y4a%0CtO0y(?J*f`W#Mqd)<Epe3G
z5a@3ZrUfmUR*;hqvfWH3$!Y`>B16s^gYNomDGknERf#ou*icV2EB|mtB1I78F&J3a
zt?`nDRi2e!vuJ6N{59`h2#i0I<y~BlX$2hZ6)795wUpmXjiOk&VUD)y&W-Sldi{}&
z;3R(WSpy&1Zam$}yRTf+zj~hJUD&pia9y||@U*<kJTNF6_VSE4tMPlQugz|oZ}cf&
zQ?e~uKcBPuD>y1<?M`!IeKwK3v&ocY&R3xq=0R9{7m{&YQt=i`DA>-KdHURX;gCJ8
zvT%dBUR}beJ+FXxQao-H)@NthHe@YOz1ZRs@*vROw6lIOcd$c(aDuO+UB7}Nv{7Om
zI9OPvpi{8!fOzavc`aBzgnkzx;o3EDpmUZyZ5*^bFp;gxbZGN^akKsTTmPGTja-A~
z5>5&4#IqhFPJ@zt!wcgXL4A3qr=IFb-HoQNAgr$Z`pFf^c**ZcYvag==06iRc=*>l
zu(*%>oiQKxO-+suMyiA&JIh~$%kLvTuGW<VtX_I~R}>dT1i_6v|CW?-%K^YXkb75;
zJ>RMUR=L!tuBkNv;=8t~%8RF`y`%HO`3-M_O`HaNx31PK2mx_OF9SeBx^Mn!SdP9o
zKcqHpE-9nMz5Q*Who7G;sIyZRq|OI!jRa5S$;JM3Cnn?Nx&;SlkpDfd#XLDUDj_wO
zZU3^Y{zPADcrmA6{an{ROj>_Z`A>5s^zGjqa8msnKMDixF!GRqZ+`}S9Z*alB<Vuc
z`y>)Eils_xuxyjqnR<B2qGm)tL58mPK>(SqoF)Z7)q&Mdqe5tfrE|v8+~>d@1*bDh
z^Mw;^A4*Kd7Z4}6y8mi8It~_aLeG0=MT)wk_=_K?6F!DR_d{-E=m{BXdv-}TwdeIr
zYoYCn>b^(NsB(4C{OTwB4V@n)@kWxZ=n)>8gEZBOmQ^V~hoo@Payo;eB}QycXiYiz
zLUN34^jKP|^Q}#xQr1!X7NU&zb_|T1{Yc;mo@|w-p`-@!dQ<$OCP;+5Y*lCm%pD&7
zAmwLZu@R@x@Edd&+UH13Dx%s@Wm90)b{L^Ti^>F*%Bfx_Cek*~6OKeklh?9@FK@iV
zoH!$XOUl3kJY6r!M_`%(Bbuv(A>ymxU|{$**_DtCazuOtLWeDp!w1JUJLoyURdjPZ
zoVe&A;g8%t3-MeMDc<D%@lvb>j2Aw(Q@!`YNqH*EGwfVi^rX7SZ5Y0qs-hYZe9kTf
zEY;rBXW?bV4_em2T~N<NU4)0DZ-2<=@r60_H1cBf?9Z#@BXUeDSw)gbY+eK>S6C!9
z38z*?6_ss8;aB=DQh;Vb^q$Wr36X$bVQebhVtL^JlMYQA#L>iDD=hJzRvd+2EF3Kn
zA(}XZSa5gSEQ-8bTA6Uq?RaPK`OLc_u+T2352NBC<@$_dDQ3KO{LxbM_!SnbFG}-5
z`L+QX#4@jXzK5vXm!aiw6onO1_*DVJB|+%8<cW=IiIq_m7D<3nXZC2m8|jK7S~F)o
z89)B$qhElAG^e7zGbxMi*jgrLuUC}EQ**iQU+^&)lPOqIu$pqFEZFqM2~MrN8#?<5
zNhh2NGOnjj!oy>cot-F1!M=wNOK3IMI$@H~PonsQ;Rpn;NQ6I@l&Z06Iol%C5H9Gk
zW%8Lwd7oiemeBh>yYTfAr8ro#Tt}?)Pk~yDB3JF-depFuDifu6Isznq>*Q2p*QBeh
ztlL4Z1VmPrP(g2uX(<`M5q`$(irywVv82ry*nj55*}(@oFN;5gBmbGjuAfE<N*h#&
z_ipBj@^jl)yqg_;{%-bWqqsh?$NqzACRIz?DC<Bv^e&sGVR+kcFhP;a6YA2f3DMVY
zow-IOBEi`62cRk-OOp-DL2VGibr<`ZhHCLEi9tnztvq{gj$MxXxGhU*3<I^0L8MKa
zJK_}jNHYB_tDB5vH{NZ%a}2S5a(JQE7DxD*q>X)BtzOq0E~_eZ(ic*skSXG8lP{;@
zVHpKhaiwWk=~&(M_`flyxswxk#>|%BLqvDK1I?4eD5h|xHqLE&8z^&`2M~v9qE!oQ
zEioq{@iGsQUatPMporUGF><M+nen*@>4`-xQgIMJ_^hF;JX{}=$L2ATlo9{NTN(~0
z7M3~Xj+2R#;*T6Q#lJ$}Bh3_TIX<g#dvmU_1D83ipANzOycTVJI?(r>JD!p}99i<l
zAqUHIk|Y_P`lOEw6OJ?lQ@r<CGJF-CNQGal%@0rsKiKOUOX$%vKT0RqUznWFqOCu&
z!60BQF?l#S+hU+}-PXF$?3s0Vd?M;z9KDF(sxWY}Tgg%348`xNw<`2LHcN^nVLhYq
zpuUwSf`sI1l)2I97PcJT{pWhiJvACbDs^e8e`J?`A9p7;2FJ5&-ma<Q9nI$xE(<?i
zf18+G^BALpA>kad+pXJ;->7W-a<4pQ3)T$1tY)gtVC68>f^nh1-KeE=?>4;E;PW5C
zPk6@<Hzd)cPE`mOsC8d67wP=m)N3}+$ReHzC$&L#IZcxD@j+QVW2dSm=NjqAY^V!x
z|C$BhCSyz;;AQfWc6GaJ2LEr#dT_TLpt=%5?;xedtf<iwY^RDndZ_{$p3gEi0&m(@
z!tFkiA<kCEBMsCKu5Q{0fie>po^Q<xiGN@Ci)-b%1Y7?`hci87j|(yh-ymAO$Nkjb
zO1aJXNQR$6b@Tw-E>x$i#Jcu3F@C*R?ysWuj`g&7@2EZ@Z-bj^o65S%As5bZgdE!c
z2NBHR{tFR46(syj$IL_FN>HTDPqeC0Cb_zc>g`KpxA)B6-d%*B0zNvoZo-E(s7lkT
z_%LFXM0fgmba38!I+YZefK>rDi-B3v9|8Gg(~`?+fsTXytA`{6BJQYrMhGEPN!-PA
z1?ouveT>F!a!w0U!{^v0G(Byxc>DRJ8uOFQZ!8DX?t8wsNT|yDbxIC}sTIAS8ojj<
z%39>G)Xyn+KhW48sL=~tih_5GT+z%w+*v*L*gBt-n2E+EfFElchDYamHZ02;g(q|(
zt70v!4;lX9J=1WKL|iRZ)t6xg>wmT}R6KG*AS%O^fP$vVg~>jLzkr9iEGN!=r10c3
zTT<>C5Xnw3Ev0;#`kH-N^K|)t5AOTl_IZJHr9X4hY;+eS@}~EUWXSk9f@$yF96h@V
z0aE7B<+6m2ZynspoU#fAKVX^ipco_K1jyQ7?jc%jfVWv`e|S|0F9_SVkUcIF$hx&B
zwqm(7Xfn*=bI%IxeY+rRnawYcaGgDxfzoNDk511<B+a%YtrEESeUDp7pS?26R4j2Q
z3C`rG{L@u?E1xIlg4Yy9c++|dwA{X!VZ1qopV-&F@nK(8Wf^`iZYF_)nI^n8YM%{a
zq7>C0OWafAGLQ)aTH4OZd{a8r){HTtjUQ0%i~*_@qMhWFd`rw%Grc65aP_>b6vmHH
zM}F8r-X%Cy6y=!}OH+`IvSB0Z5RLa@57(Jx(4e~5cZ-Y-bKpB39mL61>!nO+5g-{U
zBSxo!@@4_1@$H(@@gy*X2Q83F)RrAL$IS+>O3}kJ6e1*&Eh~W*fBnw&YIhoEn^u#f
z8foDyjt%ri!wu`jGgWqsBW$W=u+nkD4Qls1Pn}velL|53zpbPNIvW&e3YF>Jt3n^v
z5Zb4zu&DHAGT|w)X`&m!qE!bS2(>hfV1;rm*4Cg8rj+wASkR~Yyavw-^DR_=NI`1Q
zE}m*`nS?<itff3Z4&5phONW=1-Kj|DV71WBTg>1yFtHEwB=?CXe_zl6Pql6KZG^H^
z>jG%E#cRv6KV=-`tq#19^8Ixy3T5|QTcP=!_HBFXmbXj8s)^9+&8qmczAq>z-=2#v
zqbA#(J$!vsT&uusqC7?bsL6z_G*l;7@a@fkQH-?{+##xwROS0~c<kk?R1N7)2QY$o
z=iTWxxY~}<Fyi`|uG-t{<vR<llE9C=b+pbmbuL~;U_*9VPp=gbmx`K=D$QQ@rjOcS
zei0{Xwn_Uv(u4SKkIUAPo5&PTgloF3<nUGrH>{ycAB(~03~QbWoMqlR;&a~bQi;hc
zKhhS3xq5BfVaWY5FC6j`h$ZK~LHMNDvhZ<UzFMm~FPTau4;SL`5$!g*71y{Dt@K>x
z%vyyt#;|h2PCD~>(KN0sW#c;Wn5Nxl=gawf43;G58Qkq~Hx6QMRF?>BH98m=HzaJ_
z@h%yS4x(GOYD!U@)?hc7#%afHj|wr>F^*U*HYOlU(J`(aUsKGihF{4B;Sp@|jH>$O
zBuF2>3aSxj%g|Jt&J0yB8ifOH&cX;a_aBBmvn%!$QAH0n2KHnH9*42r=<4S#En^CT
zFRA7SCKctm_+BsHM`!4Iz$tv?FPq?tDamZ)aHW&oq5?Ja>C_a9B(<00nP}=6tJK(5
zOHYZ%Z)_VvD@oIg_AuuL7Mu}^0VNt$z-^XAGK8&pi$eqWoP|-{Rc#Efj#gqlenl;X
zQ97>lyxGp~BAMDd+rPE_K0`f5f03ei@ZcwiAnIb)D6kYf8FpwnapF7C@FjdzO?bDS
zNJySNu&&n4(Loj~R{(dC_MDI^``{VML_7yn34reuyw!)~9c+j|Mv=;x4b5Fxbo)7&
z<;y#)eQVa(=!>j@8m4%LatUikMR%5+2=RvM{`Bduxz4G2Im>m<*fC&V@B_K7KB30k
z2?)U}4?R7)vuWb{6Qa^@YEwbxm9-j$BB8M&F&p^WBU^N!09NY{CUt*<t^V$E>CGhE
z+$4<NL|{UiC~@^NRRnxxD5Si9@b{(^wCgmqiZKd8As|To0ZAr1uYWj0joplnLgh1K
z6+|X6<_{KP_pfnM0`!2}a?enrvl8G0iKf`%w16XYN|z(#*5?x~FPx`w4yx>;xMHZ4
z+*?Z%-twkV86&?>CpmsG{nrSE3PqH>UM;U}hXVfC8bYbU+}$ptd)`AVY5X|M1y%^%
z^Ummy5x!YuMLc%$#^*aZCZ1LiIk2fyR)<1q5CS>*WQQU1X92OLr6~5evuskHF;P3c
zVVFRCd5ZU9gU^COeP{FWi-P_v<G<tfSncvNnL#2w+ABLG#ya5@GV152XOi}$lydKj
z;}dX3q?6JnL8UX${mF|g?k{BfI3}sG^YKjfYxT45oGb#<=WaJkeTT<e*Fjl_g=mZT
z#`*cz#Unuc7+Z2)fylHL8au}QnjWl~*|by!1X!<D(dK(|Qr<J<xqWkVIgP8SrD0P~
zu1=w)z-Z%x1NX<L5a}3czaO(V#R_1zuse4Bv>#1~o@<+b0WU$Wg)x*%IlDL)?{;(B
z0nSfms?ZEU4GY-yBdPY!t$j4<-W7yV3k^$#9LcS?PqP<OFsLPhXs-a73NWe6tDv;5
z;<<~RY#*Z>C)27X(Ss8^UXpO82a!VMMYFPkmd~xlj8!X&&o9?kY1hEUnt4={c-?MZ
zbb62vOqSc89biai2a@flyY_s;y_k4_xiW%+OQX}2RdSKvtC1h((W?k*nfhA<X-9RT
zK8kIl$fUq}^(yfV#Hmfh!jlSG8~(NFDA?+eWrSeIq|q-Ke|nrao|<@e!`&cmty9oH
zSvRU_=yYvM#b&=iW7EpZGBUSsl4LD1z3U3ZY<*@Ok%zE%XIXBOh#{oyr_C)QG*8X4
zb8%&9;X2GkLQ4E8{rANRAz{=J-1nqhq<YjT@5l7O(z7tRyQ>Ipe1GHAt+7xlWO+LR
z6l(e%<g$qpA{U9WOSCBFeH~-7q8`2YBAjDEaHi&te{V%1JN<Pbb&0qbw3eHCiWrtg
zWYY^uGybAdE7aB$Q!1CuT-FDAN6%X2UKf8KqqtXUC&VM}rP+IpJm(z)elb`YvV<>|
zD1vIE`6y$%(Rw5~IXIRC<V>i9%GXBk5oiP9)M$I;seZwpQ8h20YrdU9Z9lZOgj7Op
zODs$?Ox|F4eoY1GZa!epW`CkAlFqT5S#872u9mA`cNCqkh70w~nKdmA{(_l~`xBbV
zz8<*L(mNSLQ=rG-pFR427<<d0w&HhPG`PDLcPK8!C3uSjE$$Te65N7Qw3OoRrFbds
z1St;1-60frhm-%lb7$_IIcM+lEo)}YBrBObzgHevEKwM(a&4eAeBL4hgWe$mCcIfJ
z%?=yr|6GbebvAWCC2uap334w<$B8VJ@_Oi)%}nuZO4E4N_prXRd~Ch>z`{5|pUfDS
z)QR8e%^df&AiUvmI^9TZBd9v$PFJU4XyEe&*dp$D2#>pY^FLdNG|N3@LXYpA0_IA^
zMA<c(EVl50>D4zSp2*fvpSJZ7^l7)t?{UeCh;zPD#6GU&@{VLYl=O}$291fgsp+*j
zyA9vw`DVZD%OCTK6O)gEVrJ-#CD)@0@<|HBx<t5$c_(DmG_PC?e5-ceGc)FZ77VJ(
zcbQWi5zWs1YU@0y{4%n2#aBT8Y(D#y(XPWv=+@r;@*q=kwHi!8%Mc@K#;ZVMZR`9u
z=<bln+F>@;xg8h~jx`(dvm&{Orq=RDg7UR-=EWud-lD<5o=L(S0hg1Bt-2Re0uZ^U
zAeKA}Ht<O1Yt}86uD>E5N-Zgr0W#Ybb;a{!Aau8C&caxA*vXV$>6w{9O<tyC^B4Vx
zjsoM*Lp`^3ZJV^V5tkB;UtDCP;pY3;4oVVTna~st^*L<Makj(83%X>cku>htY3=bU
zS>60?)l93`^+?L1xai)SDx2JUU8IEJWV3j3CUNEMWqxE#<_Bew$L6c#i+|{n(neU4
zspSkS&}_dyJ|w5uU?YlWW+JmaAEKqTNX<b8U3PALDq&N>LilewjkCA-K3vGKoX{l#
zw_D7~^)+T-Q!tx|DrC)I{@~ejiG6a=U|o*o>u(fT_JfIDavpqb4BvLaPsbzZJ_C^B
zLA<2+)eg@0rEEmDyA&YJCy`@hjQG7H!ECCzA%;6YUBQf2^8sV%=e%tE5cfY<<{8P6
z@^Si<5n|6b0RbeeO{?!U3syzVQ>3Z(nj%jENfJLMz-7xJ^~{r%J5ztEi~0xWtsG*t
zXp|)-_p9>-%w>LvB^qz>!bKNvh1AJ&b5*E@mtxN~5XOv+;p{`j>zJ;eC!}iM(^xlX
zAJOH~xHtc0(KN?r>9<|7&y|+dDlhWN8C1A{p*>7vljhM@Ir~Y0K51Jn#>u7l=@9R$
z3BG`P!s@QE?;U$@NTr^squBEX-f+#wv=E(idQbYFFpQf~h8ER@E|dj_?LIc0MTgq|
zTngkz@N=<Jm#qm|77(k>f4wmBIklZnzoQs@;CXpd;q7W=Q6DoSmGsl(&+(32a>|D>
zuhL__s>K7XFCoOo=>ZE<6tb+l3!u_Izih>~_Nu`pykv>|V;)I}<1_qoZ1MvYRN2{<
zInYH@(+>@%(#+zewqCq^t;r0UU*+oB*rc1@sv;+p)wU4!{~g67)l1e_Zj4x&F8BFo
z8uyJNId?EU^SFtBHVxWP#{Qe<4O@u-!TA_23oHM%&u8urUz(yNq=jG)*Np%*3m9t=
z=^b0Il+PbzW6$iiZ-v)^&NGfb(lSbwdj!Y)yJB*QSJoFvtye3RC@b`L&R^WQBYf8w
zQ$^L4^w6q1_~Hm^5JGksgbK6n_9G<LYaDie*3c@(G|kbW`a|zdu0dc82uKa&9_YTZ
z)mljMEHH6HxJ0X1k7T2S9!A{K>B}DKf~Fl;L>c|-sMHcAX5l+M`+iFR!qx4qR^)H<
zl}s6-l)h6MdA^PztF807M%{{7Z!$J$@Pd8uf_`yxTlE*eTfJ%h-JtzURcYa@jS@i{
zOTSNFE<C=-HvU6go+G$D*>=yR=0V8JF=v-;l?x<4KHm<bPvuCt-9?#`d1D&;y+gor
zc=<a&bd!!d?!pjStfHQIE&c|2$_C>hWq;9x(1?1q@DHV5eEzC+{-=dcRo=MSPILZ(
z*hND(OGOLfVqkHL$|v?Wv5tmzyiQv|GN(I-Qd^Y{PP{D-4E-tIJ&pn0Z;?V<^JLZp
zF~iBcS?O^k4Zr-KrgI!#y^vv8k_hd)Tu|fuvjOlF1#|DOV-ACrqq`|N_UTyfHbdUM
z>1KBi1Ux-${Y|M)x6IR0o(5VjLbWd5UJ7p4!{~}^Fz+<WKbm))bzgf454A(~>qcn%
z{%A-?vL__yYiCA38(~H#-aX4DTzdpxH#G;;Mn$<*&&Sf@A*EW9(!SagB&&)_!JY#D
zJqP_o9F#C?O5SdG==U4&Dj-R;$f0I*;g|FkRau;RubEP0Xe>G(YwAz!(n!g1=+{>8
zk8DCR7!U|$B)58QJz|Ic5xk5#D*lDfW1ft$WgUduR4<^<6R{yYh=|VnDD_StDxyK8
zQ)_4>dtaVt-j%m)YU1~<YrAOoW%Q$hy}R|h$cb%|N{ty^uGIMQrd&{}b|TsOv16}s
zVRNt}hV~(amykIt0n3NHod6T_<pm}@yhHW%Gd3mO%Pp>85>gf|X~T_%*yDTU&eijt
zzHtJYD2i3nM(x?Rdy6g7DYj+IC;LM2R;i9g=y;at$G6_x+H{`3u;+9ayja|Ai=xM3
z2)MGM=Kt_=C)Ps=*1cKM>RM@_uIzA)RsFCGwI*l@_tbb_>@1lNPs~uYBj^erFID&)
z?g@^3bj-M}M-B1{Ty6SQ7T|aBnDVjl_WWDOd}j^;H`N0=*%2qPE~BvqW+Jk2djelc
z7UP@m_4dWW?9bfQ?mO`!r5P_&>+>=&cD(TVOAnk|`pJ=T-qX(5ODh>;9BcDGPQN<L
zy0OKZt85S36F>C^qV@acUY-UQWl^L2T6o&tPw(ssm#+Grw8O@v4C(YsflIW%hZ}tu
z4SFFtSuyC_PxLY2Ub4W5H-Ea|4Z16m0jDo49(mJR{X0Q?`K{aU_hr8#rzqB#s>l2F
z`lDAhZ%^j~I^}fi-4(7<`1@bfg`ZZ%g`&NsM54X~iMRG7XyNU{=TkQV@Ersru9wAG
zuXVs<*}4@gH?7}cB7RPLRNm`$TC;FNwWr;bc(tTtuz~D<&(HpkA{~8FFC9>IjLNM2
z&RNo_jOTEoLHIr~ceqkoI$ntxsCNhL^tYo5oA<_;G;Ud{IOnDf@^c1|-9vZn)h3kl
zCF8H*(gWHI^oC?O?=_w7Z-pxJ!_hpP5WHx`0;EmJf7uRhGli*?KTPi6oxyMQ#h83s
zt~E3v#q!zHODo8NFom#CJ**+fxa?e?lawH~|Lf4F{1;t@tNLt*6DdKz^{AogTTWpQ
zo5RK#A{d*x{qp*6^?aLBPUhtQkassI@P9DvYv#VZGaPEMt-T?0Pl1origkL4Pq<Cn
ze^hPtgrP+bZnGM!a@1B5`lSC`d1ZN!zH1_<I<#Ke<NP@l)qHu5!#T#yXjWM$J5-~f
zX*krQ8`EK@1>QYd_Dq0jxn^u0b;RV}zKCOkuB-~J2pY!Fn(q%M>P7{}B$9;=QF(|s
z(I!RRsmVHD8NuNWyj(AmLbQQjD9!kKgsCO05DZrZDA|TS|L`uYjTC1jhb89Mutu9^
zng^v(q@pI{`6i}+DNA}^Ot7j-pY)b4*;cDm`Nn$7EdwJHXZYI*zCwKn_tkaO)H)fk
z&oyd(CcI!^$~FCW*471IsmegQQ@Z(*bLt4`<x`FPRFdWlyv<Kpey2@MhT_dJ?a9u|
z$3#~38RKKBZBlQ|mrxf7Mn7t4uPu8^N(J%vmhfu-<7f*4%t;sQ=J@ZMEqS|QKcCFY
z_f{o8Vu_XpY47aSmG_O?d2+C)a|U0r?CM}eShJW+a1FXK>K1<OtFve8MeQYsgPZG&
zliOrh)G+p6UhHdsPtL&nDK!hrb4uU<8f8m0%M#nS1>TM46D0VBKxb<#Q_DxQDxvq8
zOL*I<<SSuy+<2Yu{yYFJu10Fu7_`Xaf2ryW7iPji8h`?0p(?>XQRTMy_N5AIC;cZ|
z!lwy5Gg1NR+cWfk?}qok>yRuTZ%@s6Jq72QLUgZt&|T@m*OD~jBB`6V-WR2gY)mgA
z+puGjIS|i_4tx)>FI)rSugVcmBMBMTF>B_3eT<Fb8!e9i(ZWCuCwzcd7Z+zX<b@;F
z4_y<?|JXu!dO!qO?g6de`Von29l27Ymhpo1q{nah?ERyEIf#a}5$9hc!={Py*%vQb
z-ExOUT$7YUNy_dzLzGn6)$3h;>}Xb`eVHdN?()y&2X{ngEZ3*od^;s(Ufhu)c(hlU
zG5@74f@f#>ispJ_C+ix4@w-B~Z`b!XNVBo$p?qA47Ny(0@dND{V{yjyNre${COe!o
zy87pU^<)mW{Rt5sPux0hxb4k$sh=+r5SFy!NUW7b%<^2oJHS4fh&)POQ6<1GRN6p!
z{Gd>f&2T&`9Lc+3E#~7#GUP*OR?SC}dR@`$QP(r$oZLU2z;0nICXF2V+MA_sJ{V0N
z)MePmurEH<*BEcs>L$(54ED{wUWq;#CA2httyxGi&;9V^@aY}%$!%PmmBd!x@(K1^
z;^$z`;ABgGgnpLg3V0Va?am@Xd9>tt{4d1<`*935>S}j<R7R}7pYhdn%hzn%*Hthx
z{g*3%+OA5@C+XO#WNl`t^4RMz9lp?FXkz^HuuR!~J9u=Yq1{)67MpIZ6zV%r=W&M2
zb-qq!X`7-Mb4V}Fz4-UfrQcbFKk>6@@6t)}GJJIAUG1UH0n9sk@Ox@4Y4nF54c}Vl
z%?*}1)^5<rh^J>IRmjA#!zEbOC@v(1_P?rFFA81eGLIixhu%sUtReAIw|DzPjlX!t
zdMeGvA3vP`MzhKHak?t>4nRMB-Qn^Q+<YE>knGz_J0A)o);?1)6blTa9vKySw@z36
zy7A@#Nv(O$)zZ^}psQKsLo0;?E70tur>oT^RDi6X^;I6>;RLhBpq+cZnc9dPN}S!L
z)YCFyq;OoJUUz0r)0M|%-m()S${Ts9hkCY8dtESM*u8YxHG_OuGpD@3cGjJ4PDAsi
zuLN(sESjp@+Lfy19)%!3uW{5m=)dVf;QUrQ#F{3+aVbEunHlJ@u*edOulK9r!NC+x
zAERUjUb^3Y-^PPdKGiXo;mCA6<}f~WtRG4BGN@<5KU(A9v2?DWxP%bPwuX&HVq4jV
z7v4)eZ(&{{M^??BSGEmp2PqNrS`gif`q&{~`j@Y>^YdtlgGJ1oO}P>AU2Sv;cktq(
zs(8Plp}`pgPLq)yDJRW_xIdXew`diMvgPUvY>y>Js-(I+vwmuVcU&DQSHNZp(53q)
zA#Ni=IMz4N<wqU}ElRQt($M=KzAAF~oi>QLaIwe#O@K4jYMK=wYZGem@;&lfb>40-
zMZr-oGNqlQL19-{H~|ljX!@pcryq=0x&#Fj?!QsLY#x$7znEE?Gey$`#Bi2;R}c22
zjP;nR+MV@!S{e5jc};$$2@F%+=XerkvhD0+?FtT0Q4>~uIkh|+whp)~GG%$sWBG9U
zf~w+uYRRZxSM$?lGQ)iFmejB7KJ9x^`rrNLFTKO?1C(dh3zP|P-g@AYs9_5LX{1vg
z4D<n*r@kVYGNbFM{9&1nc4es@*ZK1?CXs_OV0?mKVL0&$D#B+le{7}YMC%vj=awW_
zjK@1AuvPZHZ#-%iOqwB&NvT?IY!qwZ3lEl(NEAdFzQ90HZn(DPgCn{!<i>o`QMR*t
z=g`3jvbJwj_-&idh0}sNvpcWQ+6jgznEWmH$|f4xPnOX;Mt`7Z**x-TRgLS{9Ke+~
z^yU0gM2Y@3^Ic2;e@L(o{vf0BU;pq;s~B%w77R51!SwLMLGRXowR%|1qGSB;HMST;
zOgseBk9phRN)Yz-Q*5Jj<m{efp8fM^%S#64n$bCg!>v_cmct<O^4_m%TZyVpfxsl!
z<lahdW$9S{#g6eZvixOgyIyJnRpUZ8&>B%BvbLmv>LjN*v(akm`m9$a+^sezka&!<
z8E$Y20d0^q&GTj06&!uapsqJAYYv#+fdXBTX-!Y%@`^&1o&;0pgwBU-#3}Tg*LTjk
z_fD<;+Mr8!ZbWwF4nk{6^D+Q|35fqlJctcgmS2e?Mn13vSE$=@u|!ik(Z^l*1fS_5
z6IfAjc$dN%0_Tt4ldU)}lU3iIFZ9VDPj!Cv%KagKp5iY62cr;w33W@Osd2^9ZNqj+
zay<#|R(w0+GuRw<sV**QotYm(tGZ`4dI40w_d&9e(#hXd0HZPI3S=)u+_NFd5>!vq
zWxclZp8VXajiBu7P*UoHL06||Amliez{YD-gIe#T%wbt#d0n?o4xl6iqotA;CW?Z#
z?0O+S8<W<T51*HSs$_p$j{SMYwsH%gva*0ryQzFn_NApi`EhIKSNueJFP{Ssncnpk
z(lJoTygp46upea-<tI744P})uqy0P+Mu;+9%|(MG0fPRG^Xh!I=!j!ZKtI!&=3BPN
zV(mWMMqjp|?X3A$jl~||mrSk1c6NGVzIAnO$Oj~77z}guJ`<;4fxhky@Y7UUClxnW
zv##dqiaXheZ=;|2jS<kSm7vf%@zDqPCQ<up`TThx<;XjF3VPe9lzA_BqNgw54APe%
zn2QA&w@wa%eZ92)xph15o~N>{3y{;1?!qXRo-v6QGKgu4-e>bPC6B1b#`Nrb0tha5
zsW9Gcni-b>#z1lcxA-|`gU7R&g-%Gz$zpjrT43RU^|nx&V4|KeaeZIGsNg#%A{FZd
zjb3D!@EWW)&!h_4m*gIFZpH=_$hHilPQOsYZA0Km{;qV^qrMJxYeqTTv85{iMAH?J
z-mk?B@Sm_YZe5DXd&a^;OhI;eS+#BUwxvj3LCdYqUO2hJvAlc6bKkW@lY))qx3(5z
zOnT=UApQ<p#wql0L)Me_iKR}=juuRXTWt;6=7B7785xe?kx4gN|ATi__XqUsB)~Ij
zmv<@tnLNGztKUPk*D2hu5iJ-la?vqMOa(mCOROSgK2^H9hr(T0_6%RG;F(B7&Ozg}
zq_)Dd6XQJVf^!E0N@?PJJ%g+E1OKVjPa06{6pWtBm|!!*PmKU)i;Jv`(5jxv(izL8
z@%r>Dhq~=I6<1OzC(}M~r3h{m5<*JxV4p$?z*#6OY0O5G`%v0MGL}*LLG0M86pt^b
zb;^$SnEfZS3=1K~cjc0znjLbFe~7=QXcXD`!rlY}0#aDo=o6*nbi|8ObXkYF-hs<h
z|0C!LnPxQKtldqRBv0m;mxol3Yd;wbuC@>tmKT|rIp^|9NT!LjH>8zUpa^=n{}(-#
zO-Xj+cu4ynZ<${0gpV2n@Dy!@#;`5y@1K;s7h*|C)P?j>s;u@99(Jm#s{P!rNAsl0
zf*}vAuL<RYAY_lOnZCUVsob7nt<R3Wvlf%6>u1ZvC9g`D1N2vvFMoF0dDwZ^d;f|h
zhq43lvNHfx3DB^UDTMaRq6(4V0wQQGsw#2K9POBuyF1bJp|AY3!uMF!kxyD4b)#VU
z(uco;TfxU|L1yYas5Kp7SZSzkfeVrO<<Tp{gu0|cXXZj*KBmBi{5NFF3#*Do!D=Zt
z0S+M(kFmGm6L5VI9g3Z}Y$WC$DVsbq)}OZoYOmc*4LM@c>)$UZiZ2u@1xnuGp~V?l
z?&H-U<0EQ+JRLQU+=6{7_|lgOj~aljY2vci5NaIrsr`PAdaTnX%7-sNk7-1suwJG8
zPw$!M-OYX1uGX?H)_RS;6|!j-zxSQ~dvoQLmvcWUV0#<9RR3r_p1YcRoH2LwJIV2j
z!<XXsp#b#6i?vU>ey3w=J{ezrD(jHIol%t(sfhXWV#!V;ea|nRw@^cdg~bKW4jkSW
z$AXuuk5Hcu{3_@Eng6ZWY}A3>Q1`56VIjK|rI#i9j<`3Ytf_$w&r><V-Xg&8PMj<w
zuN7byPEndJw*RJ)Cgc4U77qp^Vy)7Pi4O5iTGWuQtXeQl%qh){4zXpia;A{$TQU75
z$8YGu@j4f}!NoCxaCczDHl?BYMe+j6Fv_seL~kC?zZC7!eQ|&o=v^qpA%Bu?Y}SwC
zcOwV|`(@1l&A5ST&t<~08sn+)qA105vv~QPJl&ja?_nx=PIl2#2YtA`m=V^W4(bJ0
ziSmk#Ql$H{0|9amN_SEOT%G*nGaX_9FeNF>#6(2!aFv_^@VvH*dnc%Xd`cu?CEA%r
zpKt6?fnJ47eW8tz<*ZhF9~Uv+Y@kYXmCNiSt<GgQUk>@p5*mt}-^GYZ`~yRosLvGt
z06!mWBxV{2X#LoEq3_&Csf|4D-ALI{6z{biW6`#Xzgto2Q5WF3VS;$G9fUi_^O;wn
zC7kKqTPX)O%Hu}RgqW)k6lm-EF%C&YsPU|#1$ocX8TTq`bmDmR%{iqr)zh@3suh4^
z?ZiAAZ2Y=?j3XB3VUFW7adffSpdtsWpRvH^X6ru4BjGh@{`Y3medR$JAl84eJa+Lo
zUcz0{Sz@!V9|Uct|3`_oDe+N+0pQHAaCEQ@{LURZwnp`sgYk4e2hX)BA9ya#K;L|F
zVPunBJnX(jMKAwMH=O5Mxv?pRhR=6uh@=YoNv&%SL$0<Jx1H>9-igC_+iL3J7Et|u
zRo>TE**8~tgz-3F<wbeBSPU%>=>cT1HAA=7HY_w*VVN6V*Fe*UBnz#enk1UQOtZzk
zDqQx+9U$pFZt0Z}F^z3{Ed1y<j&FI;-*->&bhdBn=C^?0Ar#>tv`$WUV+Z+ABt<dG
zqQ8O*Q^A;-Ke2r1k$8DjLg3s#a>D{-nqT0JpEu3DhnQcOtoS!a@J?qd$u+$US+rl*
z*H|o=MOnXyA^c;0x-mtpuoiZLrn#LMlLg(B((KKUN<BnTg1@eHV~)sZQT!+kEh$3F
z+3$+1KVt2a9$&|nqr5xjIdRj)cuD>97<@9d`{nBACdHfHa__bNav6^C3R`?5(;l7|
zXB<3{KeEJCtd8suZ^<~DHA?gYBfANgA0BQX?pS?6sDWWj+aq7%I8WDmlww3JgmQ=u
z@GTw5SIqz2Wk?bGStx>ClHEDdVNk(!{Xdz<Bkv=b!({|mlg0WbfGa_VDxXIZ7Z_ZZ
z*&Y0H`Nn4M8(Pjr$*R!eY4>_i*fh_LxHrONFZ{$n0gS2dviiNS0$`~~;LkyrJV=15
zx#^N|7svozkVddq&uH2gsn$0b8}9=!Cq?kl>2g5QZOKv!qrFM36%|--;uYP46Y#<4
z9uLNw=+B&TSdh|qGJZ;L4G>D+?m@2qij6bIbLqfF<ZOGyN%U4kGWLHx+{O;^<f6F6
zaRD@dn*qTN14!Fy{sGWx@|I6dg;osI6*&@otquO`toiO4Z^6%p+H8d=Az1w%9))i^
z<yzgm+XHKGST2pE)07zlzdzBul+nO|Uqv2I_M>1eUT0*8_lvNYh`0HI8+FF+;T^2W
z%-mWVE#=Y~adJNkcd`Oa1o-MajqtFCAqEugPCwB^0GjocPa{G~<(PZs#tsxXxls62
z0AlaYnt%&T6ZY%%;UUAngGd2_l7+s3Z$&VGc&33x7(gQOIecPMlL4_D>{E7tpa~d5
zI<|{y8y_^>D{0tw&L61+0O!R5ev{5=p*F!Ho5@ufn1H{9cq<2jf=aZsy3Zt<^cqr~
z0S{CNx`i^aO=Rd!LR5}M=4E5Y3KP6NA6wNsZHlujBnA*l5Fso~N*3_s3HdXSNdHZI
zPH#C4kEzG>J1vzvF>OUS=t;%AYO<goHOM!!B}6QGR)%ZqmtnbP&NKBgo>fERYL>Ox
zSgnwMgr@HS7bLuWO_AQ`(m-598oj+eH~v|NMuXW->8q=1QV7Z_Yzuq?hZRnq5(Q>w
zM%WwC+{J9C?FGtZLGBQie82F3oZaS$)**QC#h^b~;29AcuKE~T!f;bESCrWtn;4@s
zB5a~XKj?x}x;`-_Pgg4u2iSHcVzMkBIuX{zpde1kB{*zWzk<WxvEI4VbCp_qZH_vk
zb|x}|O4Ib$V?n)P3b#W}#H8&U`hm!47mU<yD``OglxDXVtIU}FBM>>ioHC>z*O{Q;
zaV8!&U)<9%=T-#)NLv!nk8Y<`wkajO)+Sq<Jw75PwXCONU5vr^ZF5CH2g_j2I`vco
zJFlvwPEiT0xlQXzdm|CBo?@7sgA0`;KlIvo=0j2~r0(b#m3imu^w|bkJq^v(gARz6
zmq&!0oF*(Elv?)@ABi+h#3j(=1OBk!FPx)uD*g4F4#*9Tl2a6ILskxHz-o#jGsWPk
ztE;8hpGO7-m$9hXw@t}`peG+49Bruxbt$ufnK!3{?FOY;_qS}FWGlE$BbP^MiOXj8
z#kB~)yn((0nSgyy>BxYi!D2b|YE<{van$7|5wro~q^<lKDj7RI^9rVuL)H}wO$w^X
zB{V)?3uNi%MPwEcqAx7D^2|m+MT*+mrot3eYz16$ef@>*C~pQZfj2wgDq~toY{!F_
z4K4CzkL=dX^=&xYw6O-jj^hCt@Jwa~jn0FviJ-fN0j_FJ2I_RryZM4h_Q$<8Z1qIR
zd1?AiUk}M*!me1v9jZRtUU>><mtq(Ozk-uM(=sTK&f8G{tfR)PI^};0TK|7Yn@|oR
zLj>j>O3a_(lAf-loWWGA%3GR`0V^xVUudi5CEB)^;rfS;&P{-`y$H}OkP;Vha#=d2
zf_Kh-aH6vqa1~4pxPmyQWg<dcM1iq5vgIa#t6t)(Y(yiusNctvfBpT{wwD{nkBx3j
zUHYfRssjyn=uC`Y7bSi&fZuLGxp{d?oQjU6X>`r2E^!G7vLZ5AXYc?V)?{`<h!h32
zH76XWx?eEg16nCpiT0;@*rz24A!}Xvznzl+;4C^3ZU9&5-VMA;>0$v?i8BDI;NW75
z0le+eF<M50bjIb@yq2*50&@UYWZ<uzVJZC^+!|^n$B-p3P2fKFX8h{`|B+uS>Fdes
zz(9w%KAeUjF`uc`QKDp}?AtaGM$^kDXC;}w13r^<L8|=6|F#9YaFeY!OVg>^*}_Ty
z^qxCj#3WoLyzWgvA*Nzm@`P*{xcQ_&+?*8^20my2EMdyz>KlJyY$g~$MQBQiC+|I%
z;74{;IUcfSK12yVLCvS6TiO@a<5jc$Gw}VQ$~In6_AmfeIg1fNBt#ge6G+y*1jygd
z0$fR$DCG$QB&RH(B-(`6#+Z5BtaYhuZ)-13D)8qS(A(a`fB|DR7k@}$38PqA*mNz{
zWInbkh4O$0VJd*QT9oT%%yav%OBmp{8A5*4s$p|7SR#Shox>Q&+vPocm@SFkfQit|
zuoW(Q>51e3zM&z+om2x}+h2S{oGgrUM#BKQI?{I@qps(5uBOAkWH~T-@ar#HNgJ`$
zno34;kR^Tn>dBE5N32gnoZlBD9sN@hC9rH_ViV4>lBBOe)jJueL0%*}U2xX;Dvc*X
z79MHssF-lk1@wd7{Au>DZuac1Q%(yP#u(-`vaJ+SKw$erX2pT#HYBWo6<fsTB1Q1l
zXB_am4xS0b1fVt-ALZ2P9r=q(YuH4ze9rX1@f82pJY;-NNiSG<-0Wx&_LWi+Jkd0H
z-u3<cSttHBw*67fBzu4-b4(TQqYMR~Hc$Ww1oJZlT=m_{JYAJB!WujjLl3=0-QtiY
zEI;<?ligtUPIVamVY`L7eG4OTqQ*=QAOu{g!+#3e8-#pXQ8g8SUrlAw;s0DG=oyEQ
zp#rg1?RZzP6Fb>Ps;(!{AT)#Bj>iB&bfEZIeQYnn(wcJdh3FtzUsr2aM1%&E*=v3v
z&Agz*1j!;uLWVI2D+t_4v`uaK@9cOI7g+HHSV4>iW9AIHL1XIL0)ShL_XM{%-k+5W
zkKkv6SW!_?^QRA(0D++t3<xkHVr@lccoB0{4o{k626Wi=`1C4c0GqIw9_n(=JeJNb
zrC&u`+YbDiE)vnz*ZZ!s92c;Q^8gSGG&|Onq8h6UwBWF{AflCnb$X#-q`W|h#Oqmo
zB2`klG=zkL3Uc4mU}m}_nY@1!@23M#i`Lf%{*~qeu7r8rUZ~cdHt9yMJx8Cn*Da3M
zB$4gf(zw6aQgIzU>rLH`y@tQgxB9=Sp|AHNqCG(ZR>bX3@c>|5?U+#^E_0ZGKuQ%v
z$arH|E<+FrINNgN-*xx=hh~p_qQF&dFd_OcijNv;m~7Sp;3&1)iS%Mh7s4rdQUef9
z-VnjJF*pBs^KVlK;<i!;v|H!M^8R<6J9P)<4DU@i_L6L9Mc#a1Adh1toM8A6Eta!)
zo_!*z$5sR^Y;DgY;?cgBkP`<uk20Sh?8kz);;f1qkE5H-GH(zm_A}uK2hV#=8IR~O
z<ymWy9n_(|{Oq9XzO_06|BG{Hjl@=4h^ah``K)Hj^AYrPtzlV2BI!lMUQde&Nh6-Z
z^tq_=V~5y+0=;9;tq;nc0uby-dWJPq>u-7dHg!pA1H2P(hX_V@9HOTreZ1{vpyMD~
zZeuFwS2>*E02HGFUMYQ$6`#Av;PUpKBa()v04<#OG2Ud-%0MVk4~F1w$NEqp$Rr8;
zxYo6E&LQ8t4m{<QSun))07G&eJ@8#kte^;fp`fi%TY*)XZOx~DGU(IbUt}l060Q8>
z{Z4OwNs0!dTJa1cESWP#zc1U8!V7X6K#T%dxQ<yx&WoBYpn64|yh+Z(okX6%`1>#;
zS}A<_XxbX%mPO<_^1-`sFyRz0g!>PBKtK)>xlnR6KGRrJxW8^5vUQ@CnR;Qs?02uw
z-NVmhtykc>lKKn6k$D`=&V?I^`Fwt0NnL)^a+I(=_N4RHv#m9T3@(dL_hU`JeSedG
z#pK>%XHZ>&f!I-$FW#S7^&g!M>3FDkXq>gH?edcP>j@=;1edcrbWf{F`@Xo?e#<J}
zuVBRB_J)vhASQdNlHbi+8CTEVInlTwQ?yQDjVSJ{J|*GQb2rI?QHigPLXNESxb@T<
zr=ErHCV%v^qMh+d#&`mxGs_&APD<{&rd+6-y1v;K>FW~tc(qJQF7&@-(LOslimxc%
zWGuYsifSu}m0*9xsP7_7C?@!@lVllO(k-P9x(d7iN4Ve;i~Iz=?Vx^xMSV7bv!x_W
zsg%YS`zP-uuEl@k4!*d$*6|N^K2_zF{A?qYiFD;KgtL6coGm*4B`;77Px~_#?F$rV
zrLF19yEPT<v7n5WBDBtWSGTW5Xr1CoQDRgYRQabT2Y{+jTQ~INbw9GQNT=o>ISNj`
zD6eNxA0_lv*>8)X|5$>wb<5ukyN)=}lw*rniIU_+#ap@V?il{JozDMLG}Ib}q`}W#
zkmVt(=DF4Vbok9SjhTxG(C7frfdh=aML}%cbNx+zoR0*i1aJklt9fAd0}Jy5q|{<=
zmYdwIpI+^G+`G_QUh;o9DN?s)D=uJf_0M?O0Va{#4!$yk`b6~JvPIWm0Up-TfznQ5
zz$Vjk!5b~Fwc9SQRU`4nxu#S~c9*I^iRUf2IvHRRXn{M4C^+tpxujM8ZpfbFm}gJB
zW*+J!BnMgii}0{>0fg5PWhHSR;2qq85j;!|4%nyP+|LZ*(03>|9Kk(#GBwY84-HO~
z0!f~Xy-;p>2%jHB;T=4X`6A{QY@geRkksD0VhFWO#U~~iZk^Mj+wO7o<1{JWwIC>W
z$!I)C=X-Y}n%y*EvONz)3Ft2u%9TD>p#q+_HBlg@Pie1chqot|j0SQ)f9#!$iJ+Q6
zC)<$oqdLfE0wQNFaNzg2cthsEwKW{@K5^SISOKs^u5cFiij{TiVnN?b1{i}W)R+{7
z%$Y-a>>&M?J9!kOSvcH@L^<IF&r)dZE&`R=9~871kiWD1Xe8-DH7Ow57bb|?!RN8p
zm?by=MZPd7$o{Mv6+7tZw{a^@5k&&3AZ2lmKZ!6XZnQ*qaY~9ZVnhekis;Jt(XyH*
z4ewK!N&zzI3K~&>-UV`IvY%TKfa}V-_)ekq$8R!@T$=qA`PQ7FO=2+`1nrM^b8kw+
z*yYjR?Hb{!AETYr2YlXGm0}gyae()}-HHh4UBN?mJUQ0$C+`3-cG;ICA-dG}lvZ=S
zhqo3_qf7%Ue%N}#N$||OwhZ#U!tlG6!Q`_^E2N*At>KPTu+#I+EIq#|6}sQ;f+H8S
zy{z<zuA$1dlj%;pA{YY%ch4{Eb6Lu$+D&`B9i%-+xDeCDj92&@xuZaWpx=P>GQ2tY
zkAgj5cauab@Rq$n1Q`yH!(4#60p-t&WayabN8AeJtbN~{TY+WsdPB(H8&tOE=V{Vr
zbmfVa+(9QI^uz|v;jGYhAHaj%^>y>EBa4=TiIo!V$h=Y7<CHp@T_uls{O(~95TOEG
z7uXqsWThi^CmtZ;X_JkFCkO-8FsdI0BLEMt42>INF5V2D(zsX%sj~X&h74oO>KQ&?
ztl8-OTQ<@Qr+N27cR%I9i%C*GK*=r&2OhhFoW<%#<x|sy>MR7>@J|uIWUB4=5?OYN
z8bdA#d@f4=<p125C#S6C{uF}ri^ioCe;q+NPhY&!vh9yF*QQoj>aABJq(K>l1owi#
z>V4+Q;UyQpy2SGNBL_liy`5=9j3FN5qqvR0tE%Ecj*!T+i_d}T+QB}6y9~oiAb7fR
zl3FrXKD&A{iz7UAzL3f(Sy51p)u#0J!)^RC_lFX`dOtVw!9|OJ+x475NNl~!N^4}v
zqsrYg7*i$bA}H#_FxVL2$9xK@d&Gv151*b)D4kl^s-JHieSBQ0+fbc6ZwpTU86oFC
z`*`!lI+#;;-S<;V-~waeG(3LZ@bjkio(v0d?!$e8GK#+7M{|-}vTy1zv(r|IAMXrd
z*ot=V98#w+sSh#oE`_g^8#Z-bzptjRCXF!v-+-80NR1G{nI0f1m>{zWSQUW$+)Dqe
zQ3ih*tDUn9M-)g9>1Oe^q;kMA01RC;H2#_S+CNXaOqHKU4bMMp<e`C(k|=Z!yzA8P
zqX;#u(p|}m&HnqJmL-i5-m-{tS*!l1Wm$u_EQW}a{%LVx^UCmvN?s(ixZ{-Jq4Qjr
zocx$Ry8*H_N9+<DK;($!2o~lps1$j!&z~dc<|PRFNznSISd%_LvqYt&WuLHh{qB~W
z{FE`EIr=jUq4N&<u5zr3L3?LIJSCpjN?MGCd;98fJ#4}x#Os>2?p+{~@PQ9SwBZ53
zC!+g8q5V7=tCmt0{b{qy{P~5N6YcW-j;BNuo@waP_UY@p2Q()b=PSk3{h>eNq{buq
zOt#GFB8Sg*&06R($ZmhS3%d7gly0&oc%oKjw0X?7a(RRGHlF597zJDxD*2oPJGf-8
z9uG>y;3j(fdQEt7AlQ4DrQa?c%Z#`^f}Bpog|Da3B-N{6(?*?3Ber_u!v{>S&zew>
z65h1qiemZufsX{2p}7{~3%U;q7LBdi*@Wah{|(fF57F%4UHXLUUl}jP1iJFt(F9v5
zcTj)SSHHPC)?BnhLo6L+ag_YW91rkWgxi@3ouGo716sF(hyRp-#LzFRUdI7+`U>)w
zgCKGNi`MYB=R!5_-L*W;A!0$74m^IUB*diqb&Ui)*Y61^MMD$Ep1o}<#*ZNV(@}LU
ztZNi=P}4CB8$aq;<Z-=AYuUq(xcDS^&fy!#$TgY-8mxD^RSbj23aP<K33JmUUqZac
zM#TO_DT}l<Qq}Qz7iya+TDlN$%xt@~hts_y^(_=p&`KAx;6#vFHUYEH(m?g2P|_;x
zbp$Ysvv4eeVsZCp7$(}Qh|q~AJ{VS!enKo@b^BQLQItHS_SX{jwfjX1&`8Z%ku2v&
zjWN|gz8s1_m}FBUJRy&wvUr$nb`~F0TRkp?nC#LnX$PrG@9W5_e?**QFndC>8pc*L
z^S03-+1Pmo$lPN8<xFJOWXqiGIH$kz!2sCx7o?d>k6br#U#z)Q(slicyB<S#iNHdy
zHO3;>g>9bQTE+=D1{S5Ui63rPEyq7JgZ6zgcTX{Ss3207fs#@HuHiHSYUBi-Z0g>x
z+OY{v_~+4VX2@?v(WT8u-8c$BsqXQ*NRp?{hyfo{RFE+_{(KGC<z^+$yiPbaK81-4
z_`EjfCqlcuY(DI2E@gD~qB5wipOO;lN0X&k`e|J^=vY}PN`_xP_Fu}8d)aTQXePQL
z=T$P7D-obHy369FOokQR#;Y22n9Ake-f4-O`}PIQW*+gj7zFtn`?!ARh89u>HHV_C
zsi(r2s94jgwLJ2Z2g5>=EaH6QMXJ>4DC4(oZ$ohggLGHsR?mx<HkEFDarOT-+FR^U
zT(GxlU9M5>(h=%*=`l#OCKTQ15pU!k$K5%@^;a-%+J{Fmc<_QO*(r&az@x-0p{+zT
zBaJ@vA^^}t6J9rtz*0Ek@hL;zS8I7nfG=7&_%q42q@R!6bTnu6rh1cH`tpV<B{M>C
zJ<a(`<@90xKHWP_v)O*QlaiPw+2Le!+vcVdi>*5C7=j<Wb>y7F{<+8V-TAGbXg*u~
zE}qoj=<~Z3oZUKwkpL33CSTMCzWaD#cbC7h6>G?!D=OgK(>@;>OtH@W3fCOw=(;_c
zj%DVJ@|BVIS-s1w`}tl3v(m_N0I$D4<F<^t=?ArSHJ{tir)~58Y8sIv)CC=?87P8}
zQI;l?R?EKFWnV)0P|g1^5r^YmnobBAHZV5rEn380meg*^zRY7oBXv-4KSJh-9VX!U
zLEH^|ds%W@<Q*GO_m(Q(-@SEYD&}b+PYEFzPwe2s04r7L%R#3bgat6>L?BwEHJhYQ
zggZ$~Cn}8+$d7^(vOF*srZu-TH=H<kk$lnCu)dv#g9aPM@_>-?P$UmAVMgQt?zRsC
zOdaDCI|DpKi0O>}QwFvo=c|KMD3amx{MsgXux~2hYK?h&qk$0OGOu*SjuGrTuu1hy
zk2;av6A>$<KTGel@=ToNQ4b&9+ViV5iOMFTw#5eqveMUa@_Ps%CtHSxp{up9nA6^4
zM2_e5r&K7WJ5cJsT&e5l<wEyJH?gZ|=hjAG84_XIH8@b?WqH{2Ynn?#6K}_NSx#rx
zKcXQg0(x%O`=|K0<BY+#Wav^)h__|3(Qa*XK{S%Krh^fuo$+fftsMi>1A9=%N5G^@
z=vyn8m<LJC^X?<qw6tjBNc!DY8)Y}Cj5>-PNjFBpcp$x<Z2sGK1+Iv~EMiQVumrZ3
zBapZ;waXps>q5URwTV>7%nEfSH;S8oM|hQzc4KT5f^2a%g2KdhT=?La4RxguM}fm;
zEliem+Z~3*%am4EM+l!<7U>fdkE!5$Ax#?Ut5B@8wng@v6Vl6ys}-#se<w_@AV}az
z#hAKKhx|f>&`7ZZGRe7hbo&>t$11|eH|`9fbC^QHP~>}L5fz^#m^q{Cy~I*LxYjhg
zfg^*?yqepC6WW7Qcm|`<0%rd?-Pb-;YR-Dj!BIOg^S@Ios^)){-MTdT{wjXkt@+U`
z-xOe_j@iCUdJ?@(j9*tUIM0K}HeZ5MWyyixe?7)I_d_YgSBn%>I?D56r6J?m2>o}+
zihnZDgc|QQEh<(^)2+-Ka&JdNAUpn%q{p^ZZ3!K^$lhj@LXVvb1s6l?7TqKOnHsL~
z=WXq#*y?eXGqyeKCYU6MBf@08`f(&*D-SF_H}eVpks(12VwFTb`lh+U43KO{MEacs
zTCYAKPz8&hRh?j7-7{6geQ8zcLg>&eKcW0-LE?7=l)`HVo9#iHLWCctV$yL0i3l&U
z<mK<Nh4s)6Jh~N2tD|NQ2F^5SBPGBmbF4`W<PU@X2&1)<L=a($Zj;Rjq)Da9nnBe3
zl#7y(c)x4hc=J*9{g1X7t(I>DIAk~@r}Zbk_bk5=6l=XE3h<n|o~wK-m-dA&XWTqV
z(6`-W(&V4iaVREg77-|Q;v9swb^s7__G8jv+4;-)7=luXypS+e;1`cOyKLb5^zde=
zPGQHKDr!0GMKd?=wi0WOLGWI%G&Kyopk`%>aw_rvdI88yg*oS^x|PTv<tZqT?eGgR
zP!T6_HHboK>!{~4MDb%h4IwZ4BKgsvnTRn@CseCu%2E2h44Qvn(Noyj)`~uvU(0Id
zLN|-&y}2f2Gr|M}Wu3)!JP>sK>}in?jS%+da+|M5uj01)QZFE}F^af32PrKZyMWs}
zez?-}3D)ocLeeqh4r-#MVn2?CTa;-_Q5Uo=oVx$qoMR%`9VMBUDg{-1C|<0l2@De6
z?5+xH>%uEC3#Kk(eQMqslF34^>oDu3I>i`i=PBU;?+ay^yT?$x3#k2J5D8UzA87?v
z+s`LZnXd!D`hTQuBm1alQVlc(fl0$?=45XU=Sou-$A6iTT0Pe`PYLtI)pU7d*eV^9
z&qNXAnuy^;8o^hEmrwKPHr`v$=kRPCu7ImYc8PQhi&$`=A~w?}6C%*~Q`u8$XB(`x
zvqxF)iXi*tVV;j4CZEV1jU8;(`BK)VZ@eZO_s~VvReb_#G5+>H4)#seP)x}IV|f<$
zVRaX;2*VAg1rqjMy2MfI@Y!z_=>qB?-`P?VF`8W=a-yk76IH(YsT+jU_QPer1LQ>f
zz;Xmy;&~D#{Y5|ewvqJ>GQe2?Ho3c_V%m8o3c?3mNlWL4>9Q3SYcpLF0G`<qU=i?=
znk#z-F$7@7S(?ar`GwkX`}dxSiHTtH)O$1-kv0ifkh5TY#!bd-%;;-HG?_5}e=Sr)
zlC?J~P=NKf(9RgQJ#7pngO^1~6Bv~^R+l!Kx-Uuwd5%>YA$mUsh|q`Vt6l?!AN$YP
z?G!5v;aU&NT7UDyO!=~j5CU(~YgOWDJoNF1<Ui-l{I3pNdcTrK8p&vqk@IiI5#w93
z@UKX~@p*$S!s-OT(k4?&gp4y5i(wId12KnQK#l@htX`N_09MbT8C@p@P!W<+N<;H1
zhOm#-d=~HSvl@OrM?=>_BF~hqq$!8CcA||bxN=aFPn9vS71h<dG|DMtW&H^g*?QLG
zEWx<1{PYFiq{BvEKsaeNd+;d${ro!(JobAftc>qsNujg`Sw$8wnRki<oOW*|SZB_D
zS-YK57_@VI;r`sCz&Q~?kO+4J7-svF{Kp9ewxvoY6UvGM1iQw+af~2Z2Sv&AP!k5$
zR(Sky8K+m(INY?sNQwix-Qpo~z9WqExIaK&S`Wc(!>oQwpQ=GDT)GuLZpsg6U5}@Y
zBj3~{!C02ZkG4)?a9bRYn62PsEs^-PNHvF1!OVd=17D}+k^@%VIB&I^JiuPmENn}f
zg|Q3>y-@{Jp&1MaEpI+k*<~v4CKdR5Kr_BU$_KE!CgMG|!J@aBljXxjviaWczA1!5
zXve-`ydLCB%uuG&wle%J$3Ed1sLiGOIx)CCr+xS##QQPrtDFnHJhtp)P#&2rXxjQ)
zLb*u_ld?f*ZUN$m1wsmDUel#QYs{q|CUTYh3^G9jDV`t3dKce6nY@&*K?(RqnUjL6
z=0qr=`VO*gezJcQ#Zri{8#MOO(awViMhRJ@;9H^Wj)PxgVjIT?P`5Iyv}a`9LxtY2
z7~$F|Oh1up)pWsr2fAuaSEghd(Ms;Gb1R*=lVYK(r0P71ttNMS5Cm>djKc~7WGjkr
z{hoSe#La%hU!1f_#t{>&vT<nuh;FuCgIhBUQIbDA36~ONfU%u=sn3#6JH%h*iQBv3
z%H1(DTv8*Oyw<D88>8;KZf0RZbY|gSak+&6E1I2ule3+;%ew|nAj|JsT@I5;y{zb9
zxdVseSh?di56Lz=*cwm>R$eN$4jE$jI*f?w^im!vG4rKVGW=cZ{<8HsE}!1c(G3&r
zlh{^b-RUmhue;eKCRnGKK-3}*Vji-Kob&!i+WJmZbe&l9-wT^Zb};vr5#+?wgcCK%
zMtzE3$g1q<t9d;)iIbAc=k~Y&jM5nA-9x*3!;c3Ae=`?PuQqx=@u05y`Mk9!t~cOR
zz(O8B5Oc2W-L0*~O}F@IlVof*_>Fv025k*+*fZ{?b$nJ7BJ~{fWIlr$oCCZYC8nv4
zI5Q~j%RpIjoEz6^A6-{3?fQGdxw>j!tSxk!!6|+#8a6m!gK4lvn}`b(78LY-I*ZF4
zSdiygld!f5<YH_gmG|KY!C6a_zj0jf=3nG=^E(0ug9@7O03i)rD_A;Tg*<7nAg1Vb
zVxK2dgKNq5JKYf&pPgI}Wp)lmgKRVFO_}a}tij#$%Mk);ihL_j8IDZeP&L5Ai4^Xn
zUm0FPh(Nl;Y?yb=!p5xoS7_KfWDz8V^kWT)j7@V{T%Qjyo#-a>2U1<)wK))?4x;_D
zfy7`)eX<m`V=8{0KV<!7o7Ja#k+b(Gv4g5(V3j>h<$o@YE6TgE5b`Iyb9ZZs0yNLj
zAuiAQZ)=wa<s60ixyInjSC5wG<~g|edDZsE1=RdOFTiBgakt$FLMsj=cXfD6?^X_{
zZ0C42@6NgFyTo}n>k;o()0Wb{7%bY#w>LM@b?tyovj6a5A59I-?&R%;txOo}9BJJG
zV*WjU$0nd7uk-kDIgM5wYBAq#hi13=Bq1%GsL$!Oz$88WyaHaQq^91DRfi|Rt83U}
z0Q2(G`QO4vD(31aonnCBuzP&NJs>qgk$nTQ3<m$QaS#|=ty=}K^wCs_n_vLjWTE#9
z6>>ORsT+^`%S}vrs$3tC%xDw*gXA3Fg>Px4)+?@8DcXFp--@4abi##!>I30b#phv<
z7x%A*5z~dS<c5+2%)j*Rq%nY}Ilgb>F&x6sbYI!T25aCPPjZu0p@m~b{sM<B-#%py
z@I05I<}jyKEYicCbW7NzA<!M6+5x?i;;EMC=V{5b$?X}P*mHO~*BcrRjX_1xx7M=Z
zUr!l-3r0lvYontu{2@~1B=Rc0rs1SchKW1|Ud6{-MFWafwG@)v9Qm>sDzg<os@&So
z8>C}1`&8u7|8kQ<$k!tcbKcbv(Ybiai93Dro)qTZ66mqmuE$!v`S&r^w-4W1Z143B
z4Vg5Rfb}XPc#G;}4DQE5uPK6BZ(8nSE)^!*2_fFzbUH>uCE3)9cZ(<;DI8KQQ^>(=
zHAJum?a~xcy5}M(m_^p&MBbwVmtoD7^u&7dNo4wjVN6Se2CTIPJn+1G1zr!9nBDJh
z6k_p^SmA5M=XbSB)G)1X1L1KW&$CRyA8${-^ollgdvPXY*tdR-(niNTYha;bc{h`J
zl6&-c>$Wk7Y+@nqgi8K9JeY#3L+QiUzxU}bLnX4Q8WKJG8i?L=7*J+Ph&_iM2(#TW
z`4l}?RitLbvH?2J+^tA9P6WD~?lGKvdY43toHpOI)htEU^O>m(;$WRB-4J;lizL%_
z(742Lg5-iE!6GRLCLmeJ{!#z#AN>jQy=o?RmXZE8Aj2QLg`E=5iumKFry}_%E@F~P
zHqDh~H}q+0@;r6FI_C0M^+g?pA7O@xi65~5`{-)!;EEq{J=5HF%BnX@L+WwLPzX&I
zW!fP6TH6BZnSt@hD(o_W@X(Hrrkg*<M7l`sMp0R3CJh1N@|!~pDM$CfZ*}l0?|9c!
z1U*k1FGq{thoD`!ND(NR)Q8yv)a*<<xS+Q3r~kfCg(~VDi==o;$KrQ%_ky410pDW<
zqD*In|IEYUWvxCuICKQ9sEfE+?xY__Di?)~ck?R@E)>8ef*n+MqyFE>&$w+$wEjsf
z$G;i*PkNt3(ncH_rT#7;15WN48U)HSGbTLcxfSZc_tU_eO(QaY-l-mc!n%Ha-Z-Ns
zGQR%L9fn({iq5;4DcAbfADc&G@>!0m^sd}2YgK0aDaFR9GzK3OMD-y*6f&IsrDA3I
zLqE>l8fDo#VY2$Vtht;frq(RB+C??gPJUcFye-HRU{ihI0x#RHr%LO@^!Uce`8R}%
zt+qln8@D+MSBL5J@w*>R2!r4leiL{yf(nccSUP|O{C>ftrTcChtt4PUK66xG8_%5r
zr@f3wpuPE$3T_K<+eDWs5|){e;d{vi#pO`+nbV>ji1_AhRZ_fZ411fZzDBOWMW(se
z!PQF8{nrGy)M(4KrtU4~+_or?$Laj7zSI~l+3F88KEb~cDrKv%tqy`pvTIB<{PQQ0
z#y=!ENJ2!s8>;lben+mqY~kJ@<<I(Ifpy0v`2NPuuWiMlg>m~_d6N6O5}q?7W-T;(
zU|o7pHrMx1$kR{)SpjyN5`nm8uLrm8HY@QVOA@^Tw`Ub*rh|b}ZOn_bM3-2@|0ho0
z|Cb&Ek_{n42MXL{E^-EKxO5QXuhZg9AVR9&-0^>Nk)P|~yD|$ja)+#;{`#l}Xhl25
zofO76c-mK=<84#qh)<(ay%Ig6?V3vDcpfhU{V&emGAPb~$rc_6ZeehD0>KIHgA*JQ
z+#$HTI|R1`cMb0D?!nz126wkR@4I`y-LGoz-S=+QQ#JEre$DiBpYA^A^q4%L1(Jb-
zAMJWy69qX(M)P3`X|VuK;a#C;^e7<H!wWVJj$nk0@6i~2qtfN7O=w~Fq(SxwpHKL#
zAIas(Kt<mQ<uAq4#i1udCXcIHiBSD;&i<g1Nu_us*u_auuFCgo5Z)Gj()9>SQg|sv
zKPlzt?&$p^b4CMM{Cl}$Jsbfh1Ei;Vy3Di6nP~o+u&q5Jv;i^fT<$PX$h5yl(fWbm
zOmn2BhZ|H!$dX3MC2-}SV&@P+W+<OvJ#YrK5Sfz^v+;BU?3U#&w8DdM*bvY=zW$kp
zA(R=qdcY#jCdv>U-XS8ia?_B`grM$GMElw~^yFi|VON684yBu@JNs1o7--?+rP~s<
znxMGAA&Gr-&CJ2+3|KKl45S62r?@L$#+y5vMNj5#A@)CAB)X)9i8Oq<e`+nM6+)IK
zzvS#`Eoy3X4@jg(*TS&7=RaTyo1XeNUvuzY$k`EGk+`*+^u&tKBC(3R5jxqZkOxAE
zq++|x&PZ90ZLg2HTUigd^iyV&?s-_PIc0YAJRpE(9v2R1(4`*a3V}rkP~bgthL_6?
zbaj3P0HgBb9HJ&~Vyboq%$&Acdx%Zw9b9;GCA1S^1@58#n1j8y;LijsMRwk)t=gRt
z7E=^M9(BFNF1YToF+&~ukGS?J*6Gt7g{19h0-tWb_D?<j-lI}Id}^xosvBPch<k(Y
z(6cFvHslmHq!slFags^ayb;I8&Y-giC6UOKMTcg0>}V@`p#eAQ;J1>((nhmA3+$dX
ztM?jwDsFX0w!{IVwI<5uD<;6CnKSLFEve~8Ud!=pS(bZ(47UY@z|+0H73urhr&$al
zHuW`dK8fj5Iuf^KA&JKk<CPH`(coA!t!geLXj9P3Gi_4aa5^Jw>N0{xh)uXrG?T^N
zTgN+Gg3*?pWaTeA&=Do8feM&S)bZMRzv-{*51JmO-3aN3iO~2Ur;Nb&ypxi&YXt{v
z!u3+{=SU6P93p9&ku@)~$mW07HM@Fv;ZLwg;j>}eKCMb;MA{}_-m-e@{MCa$=6~dA
zpd`wVMKBEByH14$AuHI9!|d7Rdg`MKa0<X#8vOY7)vF<KfS_BU;H4Nfaygvo&-ru{
zygaJG(w;L+FCqgX`g1-=gCk=E(Y`h1ZHk2X3E|`^#fNXS@aLjVz1Y1)V!b|ln1%(q
z)U<U*6+`KCrm#`nw0-hs#zMdX-;xM!Z4*~}K~tuXg8rE~B&%EVrd$=Q!XsFwA_#l(
zOTXgn3iR7@bmh)~D*xDd{b8t%Jh+0P+d(XwR`LA(VVHu5dusRR{p_6-eej1b8DPG}
z%*-tPR%v)MTn8t=Kfljp0rXoahS0JbG(s_&dcO<c0BcRmXNB-93TV5<38O?8vD*xY
zN@dj_xySC9WnIk*Na}QMX7=e*9H>LP-FSZ!`!r(i=rG;1jM)(&W`_H~!CzoI;OAqo
zjt9l|$&v*!q9I|pp3JM%{j&dO@*Xc<Jy^YEfOjp|r^Xt@T4}XQqjWufxw_8BMxWrb
zPzMK{6BB_pKr|9h+E%WQt3AT<ZHyN_15oM=q)Se}UIhatW=fs1qcI8g|8n4P5xo|2
zFGf9b4`KX{+`j(!NO&R*Z4Qf$^NK5YedD@yqE$F`s@zSqdH#z?*1?**_gTv*I^^dL
z?|ET+2DfVt>4%q$MQdfCx(T87?q7_uk6Y~Us8t<Kd=cq~RFQ<FR~>a2lHmuR>qdJ#
z)5EP(OMeIQj>n*vopqtZBeawgC6D+>CbAV+t+xjT_oG6FY{VAu*>kE5gc*3;&N$~U
zH#)L6wQHek0|T?(FLw$v$-0P+KLMP^rw0k6|1A>t`@R{9)P@dtO5X;Iso^u$Xt)nM
z#?za%8w0DlT+GBrH|*1LZjC)VA#BEk#;p^4PzDn@QvJ{xgmi@r4>jq<_J$Dz`8{39
z0PW@1Z-_R4NvDQ=rx9s%dFq#lN+$ioTA@0q$rau+Vx!je)6v!#46XZU`)BU0In{k+
zYlwywd<rK5fL3>R5%yCR%!&a-s6FyC0m=)X3;YtqbrG6M|0X#N`a{@SuU1!Yhfrop
z4l0uvlWdD8Fa~Am;mI?-*TzMOE{dqQEnhN#*GO2uzaGSX#T>EZ%@jy0jjfi3(ASx3
zq4kIXEtfs(XLq@#PJZ{wxK=PLvL3vT_;N5jh+LQsrNC`qm1ByZI!9x$8CB%t9v+1g
z6ZTuHM=N1Prv0AJs<|3w`k$G?=s`^AFAfAZyzt3b2z*I0?gSww2)mQ7wk}a<Ug^uJ
zpz*JlI?OGyUja|qMCkJV5_hPllWFBJlw&M**?Eb^Vw51(t!SC9dTCP$R%7qP85dk+
zYX2yVXpDP%UW@4|6-$R6{c2#%fk4K+eNFs`x3>K!8b7taRN(#eJWDd-0(#VgY1NV-
z(LV#={YzDmx9yi8*-(Knqu?|~)L|vKHDPzvcDi6B{{gY|Lw)V?bsKsnd(}M;*|CSd
zTRg<B8oeA<(9#!ar^N9f5!xR$Wapn`9gP=r{G@wdD77s)!JB_%iZpyL97Qt#tZYb+
zBEV`{{N0~Ql(80MT}KU73WIHbO|OTr>1eBT%<(fUz_J!BDF!AhCNq<Azh0l!Rf#t2
z&^F?z_DVJJStReR5)}wXlf#VTCB|WXiNQ^Cq@UeFS4`j_%-GN6d8wo`ASzFJuUO31
z5>wYrK)LdlJCxyl|C~urXQeO-lXLCVGG3*_$O;W~EOn!mFBy>VI9*0s+4!=JA22g^
z({N|0a9^vb3Wx6C0-((Lee&t3`xs*(A7hB@SUz)n`;z^3_ZA^kaaIFJFnH*ej)nsz
zc$_R*R@DR4(zec+s0!bqzNN+BAFbZVFrsFd8CLNd7%)1ZSLoxPVto(BZ21MZ5AVJ)
z(2N+FSO-JJ6T6-E+ay_9W3{t7yQ`CamUpQIJx-fC^g--x+Boqt#a%}tuCqrVe&v`U
zjROjZT<9!f^=JY$d!&x@@Yf>O%!E~4G+xNqv-ah4r!`Ad8N58bPO!%Kh!+}TRk|_W
zVAvXI!ZrJ}?cNZO?RqLZUvIa7HZ2#GiED(5UM;gCe|t4%cv3m=R;_N>q#>`T@B7$O
z%I5Vq`5Ww}37<iZk3!Wkg%y>3&<cON!esPG!+62!Tw-rwoU&$gnar?Q%p-15Op`r_
z+AkHcd+qrko#6%BMnalGnBRHE?c_JMJCX3R5z&eTc5e!Fk3DSyv_j&ogDqFHx6TWG
zTd%k1r=~jQ?+<@<=;*vh*pI!cm)`0}FJ>Q?t?*QOywd`eP;!a?9JkRP@a~70^%7b~
z<AGQCh2Vv;7WYGIme(sXzw@p7WX-TCgqLmb?8}5x0>m|9x7=yTG|dw~G_1hAt<#(#
zstT6kX(-f{l`)W5)rmoTismRxSBI{+a)^kF#PQ4RRX;F3M{nabrld%y-Q&r9u4z`T
zZO3H2NEx&WTC+55Bf|P+>dPsKd&ltnDHoGgWX4|S<iM`xz4r@Uiy*XW1$`|=m2AAb
zf`K<se$jYpV{0>*XrlHWK%1$yniSbaLi5}}G;3(kDLz41Zni+5PR^`w|0w(OgC=(%
zLfV0jaDn3#&=)4pbbQlOs5u-;4XVGDRDY{m)a!vIpg>W+n6xJO?3WzVf2EQ6&v-f?
zdQfo_7J71fa6xs1)Z4tAd)M^Xx#w(0>yiWkbZx902J$xsaf5tow*X`2^RU^P2OAJR
zjIVtMd?By(NXtC_K3Mr-^qHLD3VtPtJksuIj5Oo8%PqusW0wd9gbdp+;|K+MAN`IO
z0U3Wl2}O{OzyjLKxIqe{l0zcBNkiN4Z-Jto9d*p-f|^!qd;_ODy3PPiz#PP^mud3Q
zNz*^OAK4v>j)+<c@I+f8@R;2DVKTQ53G`L+A*HK!ZU9#lP2PGuNzIGZ%EDjTtNdH(
z<(`Uv7nV-(^d*%ZJ8)#wuEp&a(Ter#@0q*ro(PIRnM+VjFw<@Rgk8ksWbQ=NPz10B
zaCm)QDbZ2Dtdy8IJmb-6?zd3(BZGQ5Ar?DHuW9XayzEz}lff12z(4SG$IpkR`QumQ
z%Nw9A(ZlJ&YjyaLs@`O|hv5Gs{%XFd)y%z<%V7YXasyB6VHz(1!vUh4W6nf|@f(VP
zQ2OVfv!fu#Lck<vAtB7C)?VgJfa-RU_Vhd%6NG9hEaX!AeppSYY-=X&RtdK@cw$ao
zDP;P3fj}~xS|{IV{V4fzR^DuBfQLfPuJpfCYq+DKbF<_YWxI+b<TB(hPp;|w>cOuV
zeVi)>x3~IbqtUK#U^6-O(<fZ|<TY6`sZB=Dc=-qWY5JJ|Pma*#_#I?)<~QyQ_1kpt
zGVuO+Yfh~CrO>zkBv4}&5eHqi(KAnIuy6R=*Z)?6r6&!miw^LXcRy`J-EUZjKKrQ|
z#21Wk`*e0o6Njn7>lBXwuL&nHMGpY4lc$=X`|Xd)0wrEJ1NzsH0F1geC5Yk?H-F5n
zftz&$=Dak-%qK8iF(kjE<oR{d2Noql@~s6vlIle<TR{d+DG()MnmMn%UARF`gPn!4
zcDL$&wFrQ>o%@4;&iQP?j_&=|OoOAsR@S$I4|PY_&VDX-BS-%JP|$7?RKLIOF$=TQ
zfezyHU?3tZ@p>9kM>l{bx)%%q7|Z<n(ZH2Y|6q2Z$6T`M7gCah5@|4Bv|SL!xb>U^
zRLT#csawD=m}{79cd@tEFx*^a#}dQx55(SUO;5|TpIT7CrEuulYh6O#BwZ&GnkhDQ
zb60|_J^N@ljUV5pYVioq`d4~QP?}-nTGY_R%waF}(IZ@Kw%&R^+59XCmEJaDuHJ2-
zq|>jeS$DQOy0>9wx&z)-IvyQ6k84)pcej)2FeY66378u@^b6rxEM5s#QbS#~N=NHn
zwWW;SV=ufYkXgP)fj|w-y5BH;L7qANC<4#)JsID)anJC<7wVNrAzsiYL5rhA)D)}k
zDo*fojs$K3#NVRomN4Z#J>eVpPG}JBXS6?s{IWwao)<Lj@IKGa=z=hqyrC&ZX#dHt
z??R-_&P6U8(f^r%R<$N^NALC?Zu<BPu#S>(@@;6+1|K+X6fO8U?z3NAa=)GWpx1h>
zk6$!vHCg{htMAWT3e77i#PDis;862XsI8}4WXaj<Doufvqdh#zE2<XVOCxi#ql|~P
zQs)0C`un$pc5(FiVh%Q&r{C(U?9{SQ015Qu__~37f|VN#=%d5P@_G6drk@M#j29BZ
z6RqE+u=uudXr(MKt>lnd>I|t53vMsnn!&KOL#n2{%4o5R(Ws;P^X|PA^O(qlIR*#w
zP|vLjZ1!9_ol28nE8-?9DylF<7XuGgXZQ&@O~FuTi2IEl8TYIZ5yQ`ipdPLB+yFu$
zU)!G3lqWxP>Rwqv3`rxa(~$L+t8|dJ)udk1Hs>7;7sjSjiE3gmM3ke!2Jn)nf6YP!
zFb;_XESUu4tm{U~p>3@-4%k;~MZHa9>=)u*biR8)EgWD<riv_YU(y3^9;8Uu@vHUw
z<R(2r+6d(P%h{$-(`?#EFblVIwR&!a-te>5b$SN7=|oZr=@0mF6ZHz9V?OIUcx>Tw
z2Uf?~wDH-9!W%B8Hj8fhd?2lu)S&x3l7=)s&V-WD8Z;b-rhQf<oVDC@gIcYJe!tB@
zbv4nb?c)pp57x+5aQ}o*HUxjVT`B%E57`AE71c=;$+<jOeUfddt2#cCIv5$cY;Gx<
z?zXDWEuBG)$w8A8{A=2QC#WNBNUfx}X&UC8p>Hx&^zUko&4O<r%kzNdXAHP!em5gB
zWEI}f<E(K*bH?1i0T+f=9J;(IKLY;!!~YivDCYM~YN%|5i*U5a5?G#M#VHHLT;#fD
zTLc}5QV^k>Ej4HA2+WOe)57?$UxfRcnA5Ecrr_|%WA)+-VB&NkmVN;|qS@m_6`_!X
zxhRW62vKrGDho#7Wn?V~Jpz{Y+`)$>MdW4lel;1wfEfyY>fRM@aO^uWphd(~@|J!d
z(lJ~Y^c(sEk~};;4Zfscfi;?hkO7)a!nhIQJv9lUbW@9R(31+(3puWW41n^fnX%dZ
zKsoMFmz6C$Jo3~~kAhGKreH6onD61vMI!fZ8FA5*&Sr7KtTGP*zl5Wi?1_vnP>v$a
z3M1`YZy`2o8rs}zF<c=Tc=h`R!wg$zy|6E&Fxj?5K)-ncS(as;Dn16V9oT@YBuvY;
z5#dt^{8@*6<jvwGguJFLYWc9%x!zYFLYVw@E|!jjmwq=|*`J1v3<^vmP38K4@fq@t
zS;=HXCJwUV)-{Ly&Wkx~g6jdfmnaDC^BYC^0521vfp(PMT{4~$Us6wzb*;Rp{n3E&
zSC2zUkh;=et1fTdLx>wx(*NF&cXcBb^?Oh61_iU_yZ?PDuN85OGJ{*v25#dT^Pq$E
zUw2jiTh8d_A@&0j^dzcgV^2~%waDbpOdlsYzzuCACtslj7o9D&x66ld7e3Z`1M#dG
zltK-7;x#Xh{8yNvHbN-D^oxHedE1<*i~laUlCNg%1b>+aOVp!}ZEdNl`saxAj`l+%
z6~p8r&n&*&e55U75|Mn+phUB3eL6q{m8Jsf=Iy-5UbD3^<;MiG6rdodo$M?!Q&UB#
zFnGXKgAHMBFm+Vh=)SxeXwBO4_Wn5Nb%5-Cy&Ofilf^()2#g_fj_x=e2GkWj(t-bS
zs<(ODd1PEXM}|MM9l>Ne;{VuYrP?uv^<!FKAL-D9FvAbOqR|bJr|kPsH;@xBvRf(E
zY0ejWU{i|#>yIvVVT+w%SpEv$pxthdaShsgEXI&TK>5hwR9w-Kj5BP%^TPocB_t6f
zE$bzEooWSU(JycuO8a;_R*#PQANrBG*KGT#We}FeI9{&ucvdwd$weMglA09IQA-JU
z1EFwQ!{iSo)KN9@`gvevdy4x@_xQgo@#oqH%+1c}*Y^C#xq~B)Y%y73FsyWJ5)(Jm
z265_vzNmmIK$14nT9pykW(L{Mof)Ss!GmdTXad*%jWGKRD-xNdJ>4Y10o<fp39|V8
z7}q9Q@uPFh@(@8lC->=IN>(Q%xA?rJj<WruX;$`c$5J%sv5cRJmT&xU@Vqu+3(GlW
zYiz0<g*0*!_=oMYmH6*uy%_S?zm&r%2HcMk|E8q=Kj(=5KLq{<HyDxr;@5}C^2VUk
zrc0mWkEPM!6`0QP-&Mc}C+^Jcum_VcYufEj{tdJhvN#=mCsl+~=bT3A=uTWY{H<T%
zF@^cc-I|wjeeSvUMghF%aSX;PQ5TNE=#KvE`X%b!pBOa`D0#|0g(H|s4*_q!0nA#2
z3MsWh#|66P>xFXbs*wcr4og-x4+h*dA7@6AUdKB&p62b#-5TyOwfdG5KirhUf%u5f
zP*6~4(d+C2D!#ot@s<N7RG{~Yza#mBKpKtSa|&;tAb(m*r+9%(6cF;NT6q&$s|VcX
z4bN7M`6API@LM|dOFGCdYJB~Yfx7`fmqB6@l96pkJm>Vmk175^ryyj0Gbru@JyFA#
zm;y?)V}r~YQ&O5_B3)jVtbqq9_zq8L<gDJHxpZO^6~v@6D42QG7<f=bA0mP#R8Av&
zfEfaW-zSI?jkft}t6(@QzUg_1hGUv^xpD}z-wQiwrHk)YeQ*nuRxKX0duYQGoQs))
zBK`Ej>7-GdMfQ92^N-(Y$y&>OAq$P@bog5tM3V0y+;J!M$x$eJIJEG|Vhcq~AEqC_
zL;FS5wUIaPdgT~w3c5c<n@?Wzb3U}Za{HR28wKj#ETLTB!HSjp|3vpJh!>>;4$kkx
znW%|87;=W+;>}D1$sl-4ta=*IL&i8g`AIZBP!Lx56Kp7x!smZ_3fw9C1>SupAVx`-
z8~N%g^ILb+f11uXn>}R3o<%32_Sp`gQyt0vd>8yB$4qc`#AjF6aK!mv7;gQiVD#Vl
zd{F?Ctu=Y_HeH03-SE8<bbQ<Ea)+edTex|47SeqL(H%1q3y*oA@~cw9AqqbuE-poC
z21G~UraudhqcT0&$KC^UTT=cG#+VoQb~@HKoZmh^JQ6@|D?&}G<eLu?P~5a((0C0e
z)jrlFS0uU7xQ-#;o3;o_nx0eI9}v*xkZp;yv|R<C@8l%h;S9Yzkib`(6EB3DdY-H5
zc31%FQf;;%q-UE(LQzrC3pf4|hh}Y6qAdCZB!9UNUs6z1RaMDWvtiL00f)W+0M8Ny
zg&PNU0QMa1B*Knvs3tG824p%kw4prBP)cBwf%WGRex?~S^^fgyD6MILx)%ALT+xQn
z<44Acj^$z2QSc_v9VD%QY)1rJ>bO6m>5u>yEWoUjmh)3L@@p+6G{PM>${h@k7(j<r
z+;Pc4HVGuyI7A@FSLYK1ye5~m`9vVAZqUkSob^w1Ecr)!K(moTtdWXUyh!LM(*=sO
z9Y^fY_^Y{FC;29$=y5$*=8wg2SG4#JFmTI7>XRit*Z)ijmU}t-&Di%H4W;9eS6<;}
z6SWeFnEh-bwyI)sPInB7<kli?^D9AjIU~PUm0w5%xh(v3sIhaA<tmu;bg;4069;#Y
zAFPsKutl6R)S%ELhRk*5z#1aL8=wL`%XL<vZ^7|1N)~qMmzWyK=o@a62=pYgqL=&8
zK?Owrnbo>`74-iWL;sP%+IErJasf96D%QfTp8oYt2Gn3xS8fA5qF|#R7&=C#2A59k
zWZyCR2!3^WluJP6^cO}e)~VBM8v5^@BI45*TBO?!E;PV!HJs}<d#>G8N8PTBZWrx$
zjK!>7vNxVr%jK)liU=w`md;wx#yyMzi5M`6u+Ana5c+tC(e!t=ti?>v@~XHYm!(u>
z08fYdC+)YmmiJPb+_xQDDj%|MJp_VwY5|E5EJU839qiI?sN|nvIlFGtNSQT34{%~9
zP-#G9d14WUEYXw>5AWT-0Ll&WKdB=$xJKV$_%-zA8fhsFXQv}h^``)CG~pft2t3jV
zRSQw&WANb^w^p?S&?dxx)G)jf40L}ns6Nu?s39)dJ>*T#c61^brd`Y9A=@%n)T$qc
z&M5fsN-5xWeky#EOfMzi22yh+1M`H)cftyttcox-`Sd_)@-W@v%Nkg~5%yrf>tRZf
z<VYRx{_-5s#M&ARICvgE*D50%T!CmT_#A<SgS?mJ!l>G}L^!yC>d40EpAiP1Fi?gl
zNG9}Mcs`bwVw!F|!i}Tw*a^4$Yf}82Nc^%W`%Tkg>#BuC7T2n>8phiRi0oMUuvaf9
zYpbd>{lLo26H5BtuaSN<E8O@c#EdKeeu@sm8B-SR<E?{X?grd99)E<DuIJj)2Yt@q
zdiAg7qFEh3hAA_H|4}Y+N=CT#RAC|Ft(yHv*`)uAOUi!)&wnu=VwU!=WC!R}E+}%O
zKxKWr>t=NVZaO;M3X7WR)@zDR%8BE7@L6Kn-2<DSA=U&TI_&I?9B<a73>}|CtVkCg
z8roMQ!Bc}qE2O8(t5;^t_EMfNd`XSJ7kC?Pm-vZY(Z?t1EnpK2p~7yl%QoJy!h+3b
zMGcCsHO#Q?5AJ?*PP89L%CxNw((;})zrWGzaR8RBIO#7SA>_rNmz#_D(5y&HmR68R
z5VeiQ=yxzSCMQM#?8n!%5|WLD{0+W)Jb6RvpCx`VzG_U`hff{|Ak1HLRcG<RqL+~R
z$UQ%QNTNLt%)jm4cj(%o0hCh$GQ!A{7%4LL&_6&=a^h~8Lr<D`%h~(M(|ilc!VC?b
zUafS32#01Fu~9fbu2itfMm}G@$^^L~vuZ!jc$fXDD~f54-h!g>S;iMJI1Yj`W2F_b
z4)WCp9CTj7jo+r&<I9AWS8R5^n4`L?enY4B@J&twHIMj3cMEGj%@a1Uob(xsA{3O%
zd0q6=omG57ANfEXz07jR?ah7gF^1;Y?iOWp#M5?1HVd)v`XjoYR`0tj-_K?iE$cw+
zjx&;UUf=MQF>X^-@{ShBoyf{>O{{vLrhUoxU38zfBvaP?60-Mxj=z|(Z!?<sIpHa1
z>%@3?C%p-ylz1-ln_+SW_CCP(+uwk*N>fF{5AzmFnH@pHl=8|DES8m@`lTXC=O3u-
zgokS8A8YIXB4Ga8#MO1Jx(N$4X*wJOT%~ksC5-ZJNZJVS(^7QIz|%??AIHuE!Uarp
zII3-u;03Sk1g={tZJJhB`mHs@EYU=j4{4>j>ZltTc+TB%8Q<?$uUI~wPW9w5^SN4Q
z8Xx$StDHXDGSe4s`5MZNc59Y>OMDauO!jNT4PW3;M6fNk+~Qxs<kZ8sawL>E$X+uH
zzL;$VZvUmIOC*%xW9q0608m3sd%)5O=ro_gnW6TC-7mpHu^`(u!?GZoxm#FBLnVB4
zRNZ>u2hq;%Tz38V0$gPfZQ@5BG~I$>T+Qj{tk*2}n}Bp~{vg01JEPS{AVlMj5EorF
zIs=%@fcCpv)}KFv$vy<g0eESMvd7TWVF7D<*}wVM=6A?<XWV}@MY)VsaqCnq-BhK3
z0XpN9BvItRQL>DoJat+jRr<RQqOFCB;L=iDqa<ddnu+ky0o43J!iT+sV|C`0ErENE
zbP^W<On|0%td`M*p`91t-1nSlV2uN8+S%1}g7M}~7u-LD39?Cu1Jn}+Vg^2(#V~Ju
z4?&vW(^A(^@2)KTm5hq5RKf|chze(P(dlo=5B9Yyf&$&+v7~eamhVx&yhh>u38dCs
zv@~#d+&ZQK2y6{1FcIjF!(9&B+HO95hyJEvLrDA`00v4z9ZtMQ9u{MJRjKxvsEWdy
ze^_1f#^d!wJb*iOTfvpEaYXffU%_8ZkDw4vO(SYRVfOz=?n3+`{AsKCAHC+mr+WUl
z|7q^3426cMpm2EWSr$#pQ~bQe&AR_Wx0O5Sr0iBM@BMT(!-#$p?g{c{;S-ny-~Kqf
zfw`F-Asyz0)m4$&lKB3TMaxQQ)3?UoZG=0kUfu5ToQ4rq)6{OGrX4e$mtJzKXLR~I
z+ERQe;Fg3DIaaZ3S1;<Uww}%+;Y*2=&-g%IsC5}x2YbxT%ZKkqKrjNa#e=KERy9n$
z`0GQnE;eMYJq8gc+Pjhv5d{HqO6N+TIpG6^`(c-*Hg(I+!C=1!ChaU(qV}4a05OW3
zlZ~M)P7N0Z$h0>EkLKYP(lP?hqpF(Lz<7rRAJ}!$o&R22!0pL~qD?B5l^4Vg&o24k
z8Pu$7Uhw67TTqOYRQ$Ui$IOOCtdnYO<p?pgV8Dj;i~flzMGYp&V8*<nzV!^vp00|T
z=7H=mW4JbWVhq%X=j&V5wY2+fO_W2AU%;&o9O<OqoPfFkaL^QMXxNPRgX_kjXd`D-
ze~e&n20Z=4kJ3oH29<^T4!nfrksDWolfPtdR|lpn+e4Jzuav8uouPWn2~|vHJ37LE
z4LGN0lpQ+aYz5b2mbkXyu5F69GY^z+Y3{H@3#qFt&4cz&R-|u9=dL+2*n_j@f&*jE
zN?thEJv>wZFdJUOL0sD%kVH_ur?VoyI>jP?Vf$2gu<w}Lx8#GbcLRd86=vrHX`{Wh
z1+qVqBKJd$OMyBQKObx)8uKd5+MtBT#VI0R%dCCS!P!>#Hr!iNa_=8ypIJK>7o(eP
zYFU(LyJ5XxPGDc}v1{`N&e@=)l;8o%+&`?in*A)80%lJ;CB2W|YB9eKyc8%wbnJSm
zW%0Na|I?g^`1v0VC*#P8J(;Suucf6-#A&;xR>K1Ooq73&pa^7cKvuU7Kv$h@^{$$f
zo1344jVQ#FXvOphgyOYXuyCG4x5193fB!}Syr@;j$&y3zfS+9Rc^h!}U}sa{pEYuH
z>P@)PnB*$9xadCkXYle8C$gQm)6cx|9p*xt@`sjiK~JYLVu1)r@OS7#JM_aY-f6;8
zT8RMA7g*=8vkB;{^@PyG=<=YtM6Cm>a$7x{jmr9VZ|~>J9;mxHJHL6%RNH1gS65e2
zhC=1feTJ<40-BI{sH-^_)N)6MATMAAYm<j0h8_~LIT22)IPQ*$km@XaMC85l8w&h$
zr)K!@XVPT#=s{4gSfeSHB4b}%cEt6vGR&|TkRt(3GtVErP6MA!Y5a%c=S0QgYEJW|
zKgk&^DX;(?IJ%%sN{!tb@kIE<J5A4w#phIZ33#YopU6n(ox<~nEhS@?*C}iM<fXnq
zH+&A$dp6kYC^VsT?*se&?=)}w906O+=sx$y%yvc=m@<z9U)t&d12j!T=4T_q*giaD
zy&Ix@_`?8A>Koa5pL7{=ivfM;LW~9vLZ;O=B~jddP3y#y=wuB}5b}=XyYG3R-Sv+;
zJAn`oB-ChDdz0+%WVzmYk1f=H3BQc`w)$Is<gET%l47YaFO2)SQGg8=#pPpq`)@qr
zvjNY-4Deh*ta{48>^85@1Qg&{siky=d~IzlFpM6T1+uwMZ$(gH@bg?a+j<j0m?<Vu
z?l(>B6QG0$<uYrA5)>36QK*0}Ws~?nD$5YU1$|)`J;Wwrb$K{PAbPCf;9$JHpVMCK
z16sv}Ww89Db1f`yBfLZ-sVXV42Qd>~KQHgC#UWg|5}6rAH(h`mRRZ?CDG5!Y7W$0~
zZ$l@C^0fLop`Xo3PJZz#OZDMYi=>_=JiAciLWC2)1Nu6w(6wgp3ftB}iC-3koG%00
zGHnv8&=-pa8~4#R2Wt(wM#Buzz=AeK^XrAn%SuV({At1Q`0i<=o@EvdaVILM^p+07
z(J({#w;KKV*-H=sV!mfmJUBZW56w#Ir22ap2I9R97>9P4H)9WfuJz0A&jMrzi`K2#
zNSc}!UVXj;UfSB&&|T8}{@RcIlzsi5#&NWxba+-w+%3;rH!Yj?W(M<^b!9)|!V0VE
zff8Rb#jF25{h6OUSwg7)Ihb&b1khplu2^cBJzuNCYG%MXecG%kl8R+g?Z)!3?qdws
z`Y}4QmfNv~(DyYFTla_kHRNV)d0$okb?;%I?+yE>7VC#UT>ggKe!g!%fLRkkRXAhh
z;*EzcF?)B8C!J*hV;d1?Y_^*{P4Gg5vbhB7eH*V&TkjL=o<fqpGF>w_uGRr6u;+xQ
zYbb?0Z0y_0xnk1V;TW#<u1KdJJ?-tE)pYvAPkzb^_nX%{VAX53?4g+c+`VbKgIiaF
z+G}q=DDPVdmIkbWZP+KH-uBTm9-p{`%;|)^t{}`>Urf4(iqxK+#0J1Av311A`*T(}
z;B?&Rw!IgaeVSQ)>Z1?_$mmtp@{1-__d82*!-Uue0bZj~{r|%GP(j~FHmWW|-(W&(
z3E3oRxP-!_zmYsV|6$?bh_uxS)1TH8b#??ILr#~@1+ph9U%8vw=St?DX0<yJeCrjK
zbwj4LF57&PbhWo+@^|M+4yFlx3gO;!QNzmqm<B$cB83Gn>~K3WfAxcr`j;Ox`ORb)
z@TfIo1tUu1K?x%d;|KxY<S<8r<_eCTYxx>qDXfvbZ!1p1YH7JyxOJRnn4er)=okf0
z@1bA+-cPw8)wDsHo^qMo241lrSdhy=#ITyE`98CtnuemHNsIEU<p^C{g&$d7I;Evy
z=6_;RQ?DA~m#dc(v*yyNrfbRRWippVsYN3IYZy>1pP`*(d{XI_?O0<ZiWk>yz6NQ^
z$oUYUhEA`Mj6JvxqQkF$e=Z;3Ossf4Im&C5a2+Wsq5yGeI;-nCKxv9QLBNBUg2Kny
z{yn=P9?AppZ_&ZwCuP2~Jh?y2sWnSOr%<=b`wqk?{2`9>4eV>dL-E-FYiI|lVH)H~
z3$h3?MzpROwn#-PhQXB(KLy?J*y~zVx}4arlv!hxX_eXYRYUEfVx}S3Oj=)a%W>nv
zN0H&ho8PEJ>RL<}XSLuM!|Zf1HLm^QvTo0wo`15qZCSV3yJNg>S)dn+f-Kl#ysE>0
zwZu|Q*Nu{bCU-!yD&mw$eOEn1f*l+&zE5^Q*F^D#Bnt&*;nLEj@F6hOxbN+86ECoD
zA)QT%d19yY#Sk%T%v4FGwScB&V%hLx*FI5Cip-aHUssYsXz_gCS3#TA<nEY*5_MG^
z=LLr<gh|fEwx($|M(7*7x9wI+yoP-Hdz$mDnY6SAT6}RghwW-$c6%JTn1Wt!0`iB4
z2(BZ$g89ph_d854Cr@Jf?V`pdm$8Vj9Ws4K*i9r<11|@>jh7lR_cPbtZ^INx<N7Al
z!D1a@B{~%oiU^pLz`hs1!s_6;VC=U0DHNND!r1s74UQ}mW;at>P^W$uO`RvwB+X5i
zL*u_5ppZ{yrgR}<XQR&DDPiqe^J@;QDD<h^CYY^Y;a7iN!AQbp1ZFZ~ylS9GgzeK^
z={ygj<E~uQ9%&5^SST4&G!WEW`Q#Oax5!RN?cvKvI;ooL*tT9wNgt%GxL#>V=f}TJ
zI=HkJrxuQ2E;TSp(hIj}ikDI#<qu6tGuBB{S+<6oln>Y_>@VG#;{U~S@f5l_Avqn$
zLv1IOh&qc`Iy8pd>YOa2;0Y0{BP1b_;3l#u%#b(L3Q{$e4uIUMHms&?65mhcl#X>N
zy_UgA$dV1uZfRRh%$a*M6AVEmFq8Zv==<iSm8m*?v%hZwdG&4^Dwy|#o1fW8IwlW&
z89692UeMdMlU%>=hB0fFCnAZ<&O?xnKlh(P?-9`DrW&a&P!i2k25E?a(-9`;QpJy2
zw$SZ2PK$Dt|B_dygE)1pBtvaF^Dc-y4<q^}efPh}%fPJK%DS-vU0iNWT-#`&G<9LB
zn^>JJkZj+(&o`&DKNQYn85+Cb_&%mFu4*tkk4{M6HSla+aZ?{P6UtkDsP`h-D<Lj0
zfiWtixd_?l48QhfbTbj`T@7@9d60*@-|10YtJwXMy)Iy0Usj}64o*w%)7p4~V~TFF
z@32Eoqi}w|wZ&|z{iM`D-O|8@Cq8k(qs`3~D&(yNv#1PB`Z`)^|LTI#h~ynAr_cZk
zKGX&FSNaBdx*lBqZbrgka~RV&Mfe!0|1zD{<WK^?K_Z`1(-GPEcEE?h<B9p%d1aQX
zm}yy-hyyA@rz1u9$9+eRPn)wdk*P#4-o?<f%os1yBZagfr<yfMGd$lUJ@e;90@xpo
z^Q^U1KVv%72VZ`s2RbkiN_z2s29e&TID8q%19*!KD&-FJZU<}Wk|2o%UM*2>B>wtk
zEBSeMm#y?OGbiyBzwWR>ByQiTfaujJ50u-QD)-4ibls6L`^eY$tE(v5Bm5%mV;^}p
z>ieYMpP(?v{<VkO26~VRq=&I471r}iUk!(6O)XHIIZ$+Tu6Iw?UMw|iefhn-pfU09
z6nd5ll@aln`heNT83EP%GpD3O{3B;qorKckV-32ciJ@BcNd8lebDQU)g;Uh}k2S@F
zMcQ)-yZ8blKjVwr%_F8Uu$QOhBg#HEKQ$43_nyCA;z=h^W*#`XU8Hlp?<mm@Y@(an
zqgzmq2k0arw9Y57Lqp($ZN#{=mntxOPIGvIPH%W3++3>)cSl9sQ}s*T$Tv%B(FKe8
z2BPv@P-SIhBPFQROQmC>2Vv4v$^ES@5NQ%8?gt}<sz<LtX!Ou!bSUj!f+HxGhimVl
z#Avl>G)B7@C(bv@mFB2ucSfqbf~-A3LQ}lZTmJX_zEd|bLeIf{w%WkGbpByRL?zeH
zjzeT_KCG^Dv6&*O`HL9Rzu`lKgVU<OCFN86T%l0}oUl+^RD+ijtd86EMtja>vCVGy
z<Yumj&UT%y6BFwLb}EmK(2`8u8&rvlfqpy>V(i@m5<_E-Ku>d;wm{6LyVmo~ksk=Q
ziwlandi@GQ8hyCP=2lq2zgNYyDU>;m8F#-q-=IZpmmo|geF}8TV+~n7qIkRfjlHV*
zId9Rao0Pccraz*IVecGmS5aM~XXEwy;9=~Qf-}_{Pk@UW`o=h&G*-v`0)L;BVe8=D
zAz3a0<rv98-wMXI(-C;^T#iRC(6!ym^RmaBWGvWxr+wE!*XoiImPb~_IR7jvfQJV(
z_on)JO-YUttmD8qg#1a>c_YC{GYJ>d0wOA~F>o<K{HWHzf|+Et6Z{l6I)Q`?3(n)_
zkzdEd%8mgiYxZ8HaQH9InrlC-MO^SWO8H(1Rq;FnN{0y?sC}SMys2huTT$O~YVlsC
z?^*brNqSlN0(5s$I&{^=soz*tP0u#>3z0)BO=l~qA;9I?hzT(k@UK4nkUWo-Jtu#T
zW2SOu1612PtH<L&&2iNV^2t9ac~Y+6v*b#;Tz+4%X<RGF3|5YcdXjMG(=$E1tC_!b
zem`|NeL3@S{w@FN5{+W8TgPE-ZdmtaB=XU@ktJe4(`%mXu%dl!d4^Z&e|rH;kd)?O
zWizfoqL_M1UvG2!)&p{IY&kA*u0@e{b3B9ZRBF@{wG`H@b0bDK45@5h+OL7``j#~U
z!+3PhLCa6I$MGu#eBsQYq*Cr@kPzHDGA(ZrfRQ!Z*oi(}5SV4;je*D;qz}rMX%x+O
zrRE<Ug?XAR4ZX4^*UW`bgomuk$TR+uX}S48J$*$8z!-KriE_0!Zh_w*4b5w-j(mR}
zWP5lpAdpt_QH>fkyp{fOESSzK6ejdGL(h#}l6`gQ+2rjBCzM%g$g{RqJNJ1(R3Ck3
zChy^HVUT5;iR|@}rs>`ewo}tQ_vCc2FM-Sc@&@2zIvb$>jp}HLgQ4GX5o@W8f!Um!
zm?E=4CfPUHpK>(@xsw@~tss73EJ-9qbFuXo2ZuA*eiTu!2^SLsyLDqj#MT`#f-T}9
z<o>|ku{gS>ob)$tJir@UZ6N)kY|OyY`9l_SQk80~)M*7E*Bf#{ic%?`5f;nDW_!L}
z`~~a+cOB+%?|u6f-fvG*r0eXe2Q&WJxeUHg!h>b?Sa|5zZ;(98<O<`fT*qEE*_75!
z7~@~YzUmrkk-Q+Eif~0=B1pvUWWOE7e1&=njn3gfir687o6zgl@^wHJc121%e?>ob
zwb3WnO~9pT5!#40Q?2Y`IckKf1u#zCQ<67{1XgijfL?qJ5ASR*OS3ixwpUG_uW#JW
zdMW|(@^Sw%cHRWRKv1X0xi|QwdUf$jM4M;hve5nI>tRzLaZVE>oGSr7vCN<G<!?lZ
zB0B3fWC_c;HS%=}Ed$Zxk?XB*)(aMm3rl><DYZ@>6JHNSj9!04dq&RKwCMS`zIzsa
zU!hSL4+SvBl|Z6XOx0%?#*8|qRBA#xXg)40i%N)|gqN-kBV(=sBe!(U!gDQJtV2QF
zTEcJr*~(*mH4u67C>?uviK(Y{6g6q$qc1ItUKeuK#OJB51cdVK;!%6+S*6POUCRx&
zA=4TPp#w!o%ZB;rkOkP7XeEqU?xclUK0=TZJ1|IZ=JpqQe$$BbL|S~9dxqS=L=)1g
zFk~z|M;!QWb(W2wXp}6-6)p7G{#91`b+@o{Ac`;IVb}{lti<k^cmVu>zTUzfInyhA
z(`t<n+C|6IjIc{RJ4#VGUbcnXsSR4j7}!1c{%|mXvQ4aqX7Ih5NyM_)#{V0^;$$rN
zPK657p1;YHv{CHOo0AgEVi~3!FuSl37R*&Big2J@l_+juxm=Kdiss(fv&@jE@zu!K
z9Ckq{r8{a#?(dJ1p~TM}0=&(-xu_9yaB01;h1#yVF_<=m#AvPQ@TW02#0feSRca*;
zrwK|GoQjr1rk?la9zQ%G*SLlhvx@v_L8Mb#b$3Ht{IX=c&Tt35_ZVJhD8ESG*&0mF
zjRclJx`LKXCz4$h6L3&Xo<BG5;8vJ}gF_~A-=ogSah%CCUwIl#1pffqNd@<R|La+h
z!yl6xWJ$d>%xld>vnEeJ(kiZ>CqdKW;Odz%{d&UH!L)EoN)I}g_AGN2%CL7iIGH*@
zuel>M?R=p@b-!@=3DCiX(#$=Bi-8=#Q%WTj^a}m)<uN~l_m=~<v4@8T0c3X_CYDQ_
zqFEl%zl}`X`EOtoo=A9CO;D1t^-W}u?`ZrZ6X-alxKvS0rjYOqq!>iX+(rRv74NGH
z^E0mx{Q+s!<PayDQNkZ{#d6ETc750>%Kuq^Ba#WOw&>&7>4st69=R-=I)91km{e4P
z+PUC$v`z%$(w|s(r(!l<kI)UrF*pTZp+6qX+fy!ywah{?*rBDQ9|=Bb7gq(U{*aEu
z{+spRzm;2!^w?I?yT)^-3VJBtOb6^N7=E&O3!;QVojMK?H*1L0SItEuy}n7(53P8z
zLTYI6p<vsdECpH5mGV@$VJ~!yO7cSZknt~dP2FD8M%)X1jwsZyWsMR~ajWCO!v=si
zzS^e`7uEw)460%!E{K@)+8Bhbsw4XJ9Td;CKlL^ujRZ3#mC%-0VNnFZ1_teFL0!j`
zpwZVU3Wt_9+HEI3>hRV!JPKx{rDfpNUW?7#R9V8FkGgQq_oUF(KhL@1x)jyRE2lb4
zbGi-Is+2t)ZBDa3-D2w$=8zM=GNf~<t6G+*vk9wj;pxZ<Y;s7G3Zln6N19#^>$lw-
zLP1+HMs`ccLle4^J~|!kIg=s<E*KLP2b=Y_-)=eZID<ZQM26YEnY!zO`$P9|hZwaB
z0qx9eIR6iIm(kw{n9Yo;ZBt(_3{-Eyt^J;jZ9wTO#M(R)(k!Ht`@E)8A<f&|l4-N>
zd5Xuge9opQkvDbsOjV+@<zDic99u<a&89KBskQLz(m96L_57(N@lUg3jPqz<S-tX&
z*;@>OvxHlG{ougaU5ss^LX1oN4{~i>jge5mDeo1+B;A+m<z)hg=2a3;mm3YpvM4Yx
z@U&<KGS`TCpMkXIR?QSt(B&$*zAGovcfYNHFSCy;9bD{te{DIJf9dAwCe??(luf+$
zrakKlETuCwy$ZYWbKY=Unn^iby4B1kqGnmbQE+Hl*~GQ$go+8+X&%uQ)Ka)6#Z`{f
zFM~6qe&I2?;PMM{Q3#MUSz{b(2id6zQPw!A^chFo9NIN6E7i5@YP6o%MZBy=Z?9nZ
zpvF;MbGRes{G9Bft$6D|n9LK@X4t@GwZ?wm@gZ^4nzP==aBlrH<s&og+dz9vKu00Y
zsYTIH4-5YKvbmwxmr@kzea*%Y7W#ULQ>A1T2F+Nh#V(eQWiG&cEn`eatG3&OSao1H
z9~D%*klbZS3DP=oz>GiEJrj=er|l6Ce%LD@w$(C8^ps+Zk?_IR(z<f!wLmM@u0JlT
zT1>x6IS=GQ7hzwH$c)v?y&MscJ3~clW>w!!2sSAX2p3zJ7#=15+zj78<KRob5M^3Z
zv99|H1A&3OKL^|`T|GAu-FL-5#T{LLe#8lI(5kRa=6}sgoh#)+g9WRdC)*EDfuR4T
z=i&(HW(;E{db%cau~wXas#1X#UQyeso#5o)EZ|MXN6l+GQD0$V^Hx-&lpT@Kke3*}
zSxSFIz+28YZ+`uxf9qVXrsZc74p{S>Gmk@<WLnhbWQ!D)^W-PFxw#2-!WQ@S6*{44
zG^y1nlA2`h&7}|u5h0HgAzWNsG?VmG#n34J?vXQN1OvtmzenIz6Zs{kbl(I#LG7Ut
zsnOGB4jJ+JJ8dyPS(X?}ACIn}qPUEMLOQbxi(MSn!eVEEw9o-bCb1t(*|H3+A-(YJ
z3e{OzBFWn6eY#)x$r4UB4P=)0y(;K$<wozRmgB=hFoA0AlTEX!rOB_Z9CSBt7&BmU
zx!^-D1eKpl=5xVxdJGE-cCHGN5}~^1(6U9`)~l>0%NbD4y*^slyBS=I1CI{-!63YL
z@-Ql9=45WFmX2@=Yku;tFkormoEJvQERO0zL+nVRV%acTFR<OrftIEpiZ=)F$}M#j
zh3vvrRza4oE7a!0tSwJtg@$dfeRh2HvRIb1r#+mbOq(4$oTpqda?EtZ1rx#_E8`8k
z4fGbEIPs*isrFJH;o=6MK1%ozjSQp4U)3bq+QyRYtVPVhM&wD3n^$^OwCujr<>vnI
zai5zxyB$LIyoy3U^0HRlqs|YA%n}z&h`Xe}QjT__22Pigkn-EW2UOr#$+_o9>2`cp
zv!E@#eh34O%^l<tLkxkT+`EUUnbGR$uz?LKKb+kkB|nu7@H~wQj~(++fJSAMpj96p
zH_?7>{jy!O8y&@Tao4XdHlj>F;&^lkRVFErMcOkgmQieMI4AYK8Y3csX+!0Ki#2t7
zl+^vJ2t2f&R(RIpJ))isH;+el$8vCBj>FBIHCSpd;)^DdeB2wO%g|VMG#imAJKCdj
zpRzueXl*q>`&YY^*sdH5ZXBqm8Zkdr&z!f=GMrbgoj|0PmJSO`)gaeINSI&U=|#>n
zGSa5e9d(QurIrY|Do0&27&+}PEGhp!loz<axdWePQ{vs;?L0T7e3exV>sp44iF0Ai
zLVC#^iYggFF_DoVaqSA38(nJNHk61ti{MnFYW2ROBf9TcU|ESEf;e5>T@k1!@o9nZ
zj((S)xKmrg+HEdqriD*-pUlK(i^U3FlO(7EEiCX|P1P=T6d<Dw)kU1aJKJkR=~>8B
zqZ6;;<hBT*O%S>+Gza4IzJ(4q-~qge$kr_Hg+T4bMp6<j?22uM2G03AtnBhLGNNu^
z7y)UIdLLX?-ct0DZt?u?wYp%0xSR7s?<p>ihc^y;#AhqUF$$869?gbmuYRi%k~yFc
z>yDz|dQ7Q@VMF)XaR{FaRNRz#q+ATeGO53w?v*|7ZgFif)uS^OCn=fWJGx`m#E^SZ
zP&m(eRgl<h($lvC`^%5(1Cz6{UeY5G!WfSl@fttW&W&yx-vj1S;MEgs$%YbIL_u2G
zAF3WJ4fQRMa5tiQm^YeYTe9MDXNeFZKX&6Hew}rEJSq93^mUwq)fKlkYaQgp82zi}
z*B;Rwnw)->P*6nmr`38QRowaNmbh+-mT>LnDW9|T_rsab*YOj#ISAw4<}g!LUgNd{
zadF4`_SC^aZR(2g#|7&G*5=o_xVP@FM9_6}j1>;dFV%=QS*_u3VXTm^k_3f&uYeI4
zU5X#?cr3*v&^0}#fUc)2-lB-RwL-RspwPv2hl&y%v-#Hz*2WX_*q$a8M<_SYAw6I^
zMwIGk6{$uh%fR{!Y9GRpvt(<XxQ<#Ty_F-SNNY7N-&e#f*74ygLRuY|BHU+w0@V2a
zs{<uBYJ|3J=(=dY;uJKm7V#T=QdrddGh$1Nt)uVro~y})lU7M*`vA*9is$LyyxM{z
zr^3JGnS$-Do$}Gk%f6Ws?XM4lHlHLJK`T}m#>y~8*v1;-eyY%QzoPXT#1SVoeN<QK
zHBW=(<DhSl`#oVY2%(*<ejp@mH2WbJKG}2r5Y0NcJaB2Jg?4fPHj*&ykP7Mc_RhTs
z224h*!-|5AhzWX@8Y@Dv4!fkbpc;0m{j%1^49!cQz&?!!vJ4d8H9T4PS^X+~ji5iQ
z(;+oNs2nc@6@!F}bYRb=%<`14&><q5x4>*-hjw@B+zQ+{!A>#T`W$MYc}6Cgh-e`d
zoh5Sj714AUBta*UMtAvz&IqDB9b*(WhFf)n=883x(+y9Z#a#*BjBs&8M&0!UQqa-6
z0`-!T*g2)8a4cdvNr^_L_*>*@LFZ%3h7gBh)3}W1KU1#z1aLHeSh%s!mF5|Lm53dw
zWT`S@d-Hsb^T9>WYL0^Md_p0ND5aHF8e;%urTVFjYjuhRpbco#R&4aWbiS$m^}R$i
znJ<;vYwh<aH6^;c;9~W;MfEyu#l$EkTKr{;O>4XhasMS>e1&RS^8r?;QK-<w>9zzf
zee?-W2%$KZ$p@$M!EAsvWM%s<#`BSZp4e%Gi0%!TP#(2@b>U{Z7-7v#dSa&3pl9ll
zC$b8!S9XaIuZx7~ZLPxU4kqXuRgx4hjgIb|NRgcIUt)<BB(ya*>un!1O9d;l#Qiu0
z4~RPi-3(39iG>2IuT9YjBgr@IyBL|R>h+SXhq=D7%M8)%$GKe)T7_nJ)R8fN_=9}a
zlaFvRg^ZB#&L*qN9b>6RaKSgCo|-^A(Vw{b+Y94z<s+m$)shK1SS6-{j0na<7OESn
z!UHar*rpo=BD32jS-FWMx>S-}5O;&FEovg$R#%$-b!1B<;GZPocXrZ1o+S`LwsI(H
zZ5~#x)xXBq*jf<B>o#Uu{Jy)MrEOHHLF&CeGd@%Felw`np{p5P41`)nDipK!oC0RA
z=-Iau8*AuLN&oc0Pm;)+ihe5VGp%2<>R3eg#md$jsNFQ*&+nt4U!`~#gUiLxn2QNr
zfs1K>)-^w?*1+9Tqym?JN4qA3{ShO_@cp_j6m;m{NkdB!k9y{TgB{n~;NTozs=)hh
z{LU!vMnz|4D+@!b^?@TSU6(;RenJ|#zQuha<&%Fe&BZdp<o}}VEra4}yKT`%g9Hc!
z*U*IEkOX&YJh*#+5Zv7x3l=O`5*$Ks8h4jKaBtk*t#P^Q-TR(h_uM*l>ivH8YHAe)
zYfTw*%rWQV42yp;D&4ISpE(sJRr&>O$?^F^K06r9VSJ&r6}Pyc5B)NQTP&F)q|mKN
z)H3x(8M($A1@WbsATOs>FI}xC*3lMZmam-6`^wbJow)E?0O-=h_a)9N2j9wVp2Tj9
zUCJVPJ1p@WzetO(d+WJ{#U8LJl+)szk!KMX3zJXWBs{wjAO~|bA+w`CO9P|B%nrMZ
z6{=6nH@Xu`t2b_j!JCh-f(T4zUQ&iEva5#WE3M!2j&v*<bnGcVu_R|QiWzsoTRo6a
z{M-_^M8(%ug$G4+Ak1u7wPuvUX6oO)_n$Y{qE;H;3r`>U(k>UpNdr3pS>6YYMbI|8
zS-nuFI}3tpgP-%V6np}9rN~3h^Ke+%9FAU&>9)*lNRNoo{4UGrn7jb}M&G3P0L=ds
z-u9VG6~vgi@du*ehiLOw%F2G)y?;rka6ELk(y-^Xt_u(=uFqbO3WTkCv<9yhs(!s7
z{K)12Zmkb-eIF~YdBgygeI`9Z`x+nSV|(7my7Z^?2|-aZ2+LyZog#mSx>Gpdu##SP
zk0HPldgD;e!x@#dnJ7Cf?AWs;W^0S8Zec#S@O;bv5>Kbqhs4Gz;==IAKck$_hkpEu
z>8rBxx{a}LXngsCv6g60=iu|Dw)l3_W=BV^61jheu>mOVXo(6$q6oG9_pvF+f{K}C
zj|n!S4bm0|>kHm<UhaFvrNQHx5_hWDqrGwnbLv#&iveF(ToK;lNXI4OyF<shQUdz(
zQ#*a|H18g>^(UN7dC5;cer%$xR0=>V+5P1|K=!<~m?D}gaOcIBVI%Q?Sd{oZN@x8$
zjM1&FrtvS=WJeU8Gojc!`!#e1X_C@l`Q<c4Q#vUmZ<5NFN!b}-JFsY`xaV!t_j*r!
z?PZL12cp@lD7=c>6%nmup7_5JTn>n?m$-EAsga7jJ{>Q_^>ttpZd8?6-||(>+<tU2
zXz$zPSWSOAWWn(ICL0cFab7>g&th1*t^`>2QJN&it}FV^bCR}>?Y4%nni_KJODD*P
zQP-yEeH~bqcSYx3u>07smm#z4qhA&6dj~vIly_-Bd-%)}73D!Z#1H(K8{}O99n``)
zg<$Q2T^-&`DaZ=a2@FIza<9I?pcUZx8h?tEMt<B=4l#^HeNA)Lz((N8!-Sv5t04*&
zb0CUWjnC86*!dR8YM3Ol(SvMa(s@d0F<6B;O02JP9Siop#WA?P^msj2iMKRq(Z{ja
z(bZHnqob@qXoKI4vW}tbheJ1!%jbh@`TBTuI`$DW%HzmHLBfZ(b9)}3Vhz1e9E`C$
zm-V{W9Q;EXMnt=U@AhSryjQ|~^Ze3a4;^Tzw)->JJx@_dshRzC2C}GL_}d=rTFPyZ
z+t#3}6pnSD<(97#6$C%4+S*$vcu(<w-olczy@i|ozh|W=@dM2WvN--O!=((~J~A}T
zm3Holw(c9GPk$J^5ooy^xjf{Mn;!Z^xR_vXq9j^0SCef`#&%f-b3t4uGaM*uZ~MG)
zjrGp((V9zYFlI@IQ3x5r8Z|9inncrcnaHe$vYV<WVwb$t8i=#@OB+#rg??g;dfOX#
zyvzbE4y`9C>av#0hqxf<QV%nGkD?5Il_p0vT0@NNcB24YzK$&N>v9q#tkE!fv0{hM
zC$AQG!%r2q@v-MuMnoWQTEEO=lXY_@$te5zP=#r;#o}iT$$Y>(A(-;I!1?O`Fhc+S
z`0X1>&I0>|4w7Tz-nBu3GbwzZeKvl)*QVtYnE7xtE}H@i&H`-+d-6!-5ntPx*YzOs
zg+5qJneJez{njTSm_CB^;Ujx!=~v(2h@RMtzjbdBO#y-Nsx;`#qLSW60wTUo*%0^P
zzVGjOW3m0)C`8({Tl3n(RFpALQ1H8NCBmidF+4YKv_p3EM4~ntWtUh4a$Iot2`cIr
z$~!jC+xL@1K8XfrgCxeNA!a5QJrZZpct)rX?lbz}PXmt@YjP#*C1$FxPj86ui#NTQ
zqLBPNk9mbtL3VC<9mKxabR@8qIgerR&Ij7lj@SzSE1u*v{$JRdUYH6QhG`Fux3G`b
zol?y=hb||2(-pT-G^U7Y9M<k)MlX7SiyP6dLIskOO^(0CBn@}<v_TgKL-XPJQuk%g
zOx)7{w1?Vwp2xO@%D#;q&kqQVp3hvF{(v5#k+&a`3t9{f#{AdF)Cz+#7sU2F(JNo;
zjfu`CQ=3v$<7fDA8f-#OOzY5XKiw`<2Fl|-+2SUxaU-DZa9AT+wA4YeXm-V?Y~A*c
zS<Q?7k6D>rlxV!HvBX`>OZUH+PUt7nCPLD~98I=Enmel8-7=t|1q?<8BULgUgqbFb
z46scy&|00vasltr`Q_L`mzNkm6y@E=bPW|TVf#|Av1?wsJ*q%?Xq4iA;7c4|q&OWl
zJ>loB`$MorWo`q*d)f$f-A!KN6q*pH4Yhoq7-1HRHTIK4-NB3yYYDlbd7w`gd7{MD
z=l-Q&jY<(@X56`Re4k00y3_M(9c3d~q~}hwDKxYJa#yG;irr-$*2DhZl`rIRRs1=g
zjMUGV$mdjI)x9X0hQsI1xU)m3TAx$iaW)0c<EhWcCTE)x^Uk*k>#m%5uI}R_>46nu
zW4hn+O-6Ny<7Z2<hZvkS8-42=2dlvbOV@@=y;w`+Cod#k-pu9x_&z3NeoKaC`Sf}L
zr7iYvvG(av9XfusgXykzo0#us+`rD)c`|`NB+GT^)h;&3((bm*Jy~sLyr0@W-fS_{
z*Xc+sdDXIsDH{q!a~QK_*LXc^yP=2x`RyZBntEyLA<brrU!>o?FMC{39wRBub-N0a
zUAQ4NURdn>^SQw$fNhw1=3bpN^=D_(v69JaRt}vKzb|>S{P%mGkrg6Lwf)}wd#Omw
zmv)6$Vk}m*HEe<&#SOR0Csa<llDlR3E}7Lw;SG(y8#0H(8^7pzI3tqd;Z}>YbF)Wd
zwd~1T(s+N`n$T92o{CD%^<Ov~V%0U~c3lE1IW4=(qKExOTaEHnuY?3{q<vfpMMTnb
zEhpdR4?XN$96f&hmVQIvp_Mbvgfxe2F^YyY`g3Wl3=j>lImAc<srd{;1u8;`G`EG-
zNkl360d<5k0m)O3-*#w0##cD7#+T}5Z=wjsan&G=H0SGk|Lxr?<o)^jvtXK!mVL<Z
z&Sg5MD*=(#){v<hgE}2s`&Q-KS+pIN>p2gZ4IzWhLD74nWP9Jhqz@>wk>2jLv~O?U
zNVh%)goCJh61U9=lSR6GM2Y0|P(LG@?{<FFJ=8qs;iJT@7qa(!ol_-~Bl!&6vO`7Q
zGvi6a{viziTqCf$Z`y<SbRu(P?a_b$Z5QHf9>4t7mS={3uV&!Ty6)<>+3^liM7`U)
z8<jvxgKN?UhX}WR4QqQO^*CZ(O_*Yyc9y3Q{kl1eYUwjVcFoWhR#*%_NrFY2zOt5d
zVhNPbh8Ben;P~n4YoK~^82CrTP~l|%Y>q}4KZt&RS~FY7U<2C-E&|-zNM@&g3a90p
zqc!-`q47Hp3v{UnSHqsm8<$J+visdO$$-p)b-YLN)T^>}b^M>a1a>YhD4lzR?-m*G
z8~t_;5naHEx|>{)H^{Y>M1(A1zyg5R|AFi%<HHImnk7DREt>IzMF1P>zLgD`7<R3I
z@q@|JX%stLn6yR^Ty9^wzgu0loDOr2rZjwXMXp{_+<ZqNO!~C<FxB$&N*#0bu#%1-
z>nb(ucU5YTYR<MDamJ99i>N?p@068dfQ1N}rQ)_HTn}2?n9FD<3@MEhSi+<_+p$-m
zrb~`?hYghaC+f?`txEg@2E%09SN8)M-bd@%6U~l1l9xuOhQV(X783}-hhP?wd=MMH
zb14slP#{L9-+H+8Jt>yf7_+U3lRJLI5LcyU#7U9V-;|$!I~Zh;<_4KxljZKTotXRX
ziu%%^_z~$GJ>u}#KM`jxyucKBw8i(z)P=S>lNmo8y%icl6S{7qF+Kf*Q?i}fr#Yow
ziZM#(V0vBrgt?w?3Kk0p>O9N$JZ6xG8XXg7O*v2!v)H=Ri#4qz)5M04cF3Z}$G`ik
ze7U~n%5f`H*|sY+xTM=Y;?EQ10~Xuf?3jI#rAfjQ5qAXbqK8Lbte!_yQ(%~U`~<S#
zP&P4r{Z-r;1qVON!v8^k0ifM(<%x=Cy9m586`}6Z!?ccD&%QU_6Stn(Kld}ic21Q`
zgm7tbzVz@K$$Jq19nu%=oa++&uFsUaAy5TGsWk->HB0-Y9+{^@hVM;+QQt09gOzXb
z1C0O;WWd=m&}+53e3D#S>b<__AI=nJ=>70-bJwdt66qBkG)t;g&$gC{&PsN8XZdt^
zO<eH=)v8vViVY&gxk{~gqA}yqrg0c<W%&5Z*HC%nSHd)#Air{3o<&uFv2xj|Yp(mP
zx_(pdVIs}1WrnGvM2}kc%VK9HvE$dyzVmue_Yj7$IM_!Ao@#3sUl)PFc)KZ_i%n4n
z53(y`sjk_8?~7F&|NO<415G?0pv`V!tkEg{joN8PGoH|BjT<qGu&LG1p_h^lTyMr)
z?_M}Z5dYAV<{|4{^TsXoC3Ev~jQd!@V4V%J6G>yxfY#1HjI@FRK=B<S&vAR+z9;WE
zQ6WXC00r4&+fIS82#CDg?5R2NHgCP+I_EwYvWeOpFK;<_F?G5qb49MI?wav2i?-~<
zdg7nznk0!-Vovp99W8$ESx_Tj0rYw;LXLa`E?A=}>}!WMxSrO<^><Nt<!?B62|sOH
z-+d@E8qWQx`%+aP%Crzk;aUi7$4}>7>c4HzD-i^~1Ui_aYc`?qwCS*M075h_EGz*Z
zO=y;yIr<*f!i&inLyr$a4S%X)3cQzuk0zo$PUd{z8V!V5nMW9{1#{d_801~Yoy4SG
zs*;p8Z85jRxBXZ1F5yihS)XGm_kH>JFyq?)(yPb~XWy?_SkhZ4A1S#X&bmlLweaoi
z*z22VQNh9C7hm2HR&*GR&^9zf6(a~JMy6B>tkJ4%PP9eDfuN5u#mgm&y6obx-jC-G
z&8EdRzz&G*UfjPvM9`O%ZPvEA^(-8n?&ijTTKF>KKw|`jvxh;;$6w&v@dYCyA)QE&
zJ3zF8h97;4e>uDA!ZpUY86U||0i5AJ-btPeAJ<Xn_cE^QT#c_as)P8rcha16kl^Mr
z5J(3EkiMfA30rW~-LoWiK3fwfC|01*F_Ql%zOfA{3h^xs?P~G`w0EaAq))t0WVs0~
zq*V_D4Wav<PZo6*d?|0GT6tokTDG6xCoFeuY+`$E8$Ppb2)kZ$coHNAfb{2vz%?Wk
zjiwwDBPfUsw$@*Fu4AXQuJHAzV)cf;_s_Gc{Q+<4fS(nK|Ms2AuEb$9Zy;A!q&y>X
ztPv@mrL0abgTd4LCZzEIh=(Dq<RM>oR3f;UUaDkeVe>TJqA=JXQ0j9qsJ;CiuDsm2
zBVOlohEdd7W=FkvR?xi=+aMKIMF7+r0wqe=Y2qXY?5Pd<zhj|di+d8Y#1P482B*`e
zQc~R6`KH=$g>=RuKfsG}LhcI;1fEkETr6H(l{S`tZxK2f%1|D#sLbn}QiwlwG<d_l
z<L9CndrQQoCwid)CK2X?fy2*CdL?v2tkJFYf(%KCo%F}|!+uwyrmhRImaE&c!u2tD
z0Zc)Moxg?nkDgeqf#b_!4WLHyU0c|+b2MFr>cON`Q6`SB!j0Ncj1&}G?Q%l~Ka;2G
z6VUq!M+|+!-8CR;@Wt#gC8LiIQaCfG#5H~)Oh-pbP0>DC5BW-sk;S_bGVo?(1guEH
zY4w^1;u@1*K|Mm3{%(#Wk|^T4fn=VZgN%}B^FZ&5tY9+-lY5FM66t*KcgK6In;zwp
zC1nRw6Q0(5kR3v~Q~2cWd$Tvu@#7<?8Q~>#pATe)C<-0<sW{;km)TW7dE!9;#D75p
zdxq{n>0%?PTqBtpcGKI{z=?b?{9iQ=|Es_F?3LqJK>9+Q%&6znLo$6njTNPvaJch)
zk-o9je%Y|d*)1Blj8-jfGRk-N@b|E`!29E#-&|GGG`;@0#zWAhOliMW@O+AY3o%jm
z)_e4@QD#Q4uF808j7cmtqFG>9Iyca{0l7vbLgCd)@5+jb4}5xBD}JDb-E>V(=;uE#
zxdD@l-rF*lc1*|o!JBo2QA}TB!vde*&ji)`*^7vfw}eUI4Fos*EtQP%nd&+tTJf;7
z!4Y~tdll&P>kGY>k_`#R|E@3Ji3orFJNlfN!sBH24qm}k6#_`XfA$r!_3>|%D};O^
zVO7NUJLjKdIb)^6E8i+UE<oGaM1T$AX}^BOTUAIwf5%TQ0r1SvtP9LJ`{X~JPv!9?
zr_igN_a{TF+4~#V<A2hmAMJ&TF?2roeQ$OqPM8Sh<KB>A{TNn7e`g#QK9-uQW2}y!
z3$Lh5?y$}Yv8`y$hnDP$Jn21@eGCq`#(5sFDf;)6ta~>@pAojyE+hJYip^PEiFej1
zAsHi9OpBkW$z`tkby2b$4e+B)UZ+DmSPnc@YVS6--02Q`kUhVgDZXfbT*)W^I#p&A
z?%KKQ1j3nxf5577ZeVksrwap6@EWvdFIbeaGpiZ8deyf?R2xT9;Y+UyQ5xocxEnpM
zGQ;~1%!A&s1iAY3p+i3Kh}c>%f%h?S;U>6Jb;LkF#p7&<AMpF5$w~fL{r&LKbggu@
zsj`Wtr9Jjzr9*0~W35GDio&A|_o(izj6o~m+IX0PTba?Z2zBG{cm51{ckj*+2LhYY
zu>y;`#@jo@jor=Dh{P=Lw-5-lmamimY3?t^=w}U?#NU7_IE()|kOm?c#E|9!W!-Qa
zO1T%lC+*Z0o&h`Ht*_d*V&pfr3uJR1FnoTNZ%xOi^o_7kFrT@QZT^Hb2(RMn0M@9C
zhj?xk%;}82x_fN8wkBoZM+a)-j!EJW>D~*z(=nQZykX!V(`j);L&3laH7O*D3vk2>
zEoCE=`c>*i%{`AoSp#aR)eLsHVEz63_9SV79g?OQG1(j%jYFsA0-WMo*zgO?tsN~p
zwD#OX$s>PoJ}mH5y!kZR<vS_PE1i*?pYmp!m=h7K-x{zgL*GZ9sWZb>zNMf&kC+*}
zD4!tqyyc+v-W+-7^~hD0_7}AKtp0T3s@&6odiNUyMvUL0%aJo1X9@3@u0uC*`U-Zx
zRW!ICrjdi}zd#NZ?BiJO2&V8TuceeJdv#vtxpF3hAC7n>M2ITS^vT{Ya`2YCaxd$W
zx(sAjf%ee}$LwN~srh_pfb`g=qsk4N1<&FnYM<r1{y=R24OhBS7*65?P_X~Y9>8~?
z{^CKJWx08eHTp%M<Y}->YK<Weu|$S&wM#FCD-&e7377iU)uLT83`x|@v)S(xoHufI
z{bn3>i+EuH)FF24M5i$WssIb+H`&ck4ZLYN`V()A(K86`@})_Ip1GaP6DnOWDW4yv
zp9y}J4R#*`+{uMKx*p;#C5UCK06s5b;GjFJnxK#<_rQp^#FIu}aO64fD`Wr2QW0A7
zq4edAZfNY{Z0k9O6Ih8BYt)BEI@Lq=_0Ip0@1`w0Toasq3|bWx$r7z92@J9%lp@c3
zRa3(|D0BcA3y7j=IaCuVltd{z{5^fa%6A8j4c;adihyQ~e7nsH(?3P_68=P#>T*@_
zvqT|)o{I%&ixUJ2{g5OIE)Q*sIAuvWojS(tnlNY&Zo8u;c35clZjCUQdQpS&Unrjd
z^G4&jdWN!!&LiRR!-h-5AA>*-OM<Ro69Y2q&c!}a^IxCo#eDE7V%FAb-d#vhmYYNF
zmu9*<JBioy(LT|eUO1u2dVI-Wp?Ttw9x-m8;y`pB_nEA3ZOfLG(&-aqyoZl(J;(a-
z3vyteqn2Pf{362Vno@e{5m)**!#e_-b|WGtUw`6VPXaV63(ASNLbNd1QD=j?<nqgo
zJ6TrNSB7@kUNgwmxg=W0TuR1`z-bpNRB05+W;JKDpIhq#+wL}5fi4Gtq5UG>r~F&6
zVZ`|VilVG*%ysE|`U2)ucQLA^W0-vwa^`>Rf7jpjZjyOl$CZzRm|e(>)GbX`YLgaB
z=TS=!aPu)Nn`rzp4BuU}$^Dbyd0?Bb_q}&FaUUPy?|KD<8o$L6f4{w3Ku=}yPbpwu
z20QbZ-c5|^d-cTqPlRCuBFsNj!rK3rN^r(Z^F`A0i`4&EGyBn_pO<$gy*v_?YG+sS
zX+swx1wATc%l)pjvSf-L;fl`|fvoQ^shSi%tXNE;l>+gI?taVj?yIcI#-umFrY+V!
z1=Fu8f}z?aF~ywgS`vEEV#dn(LuEaPC18Qe*sMIUX$<(lXxckRpsD!=XllMjwj0H1
z>cV0nCorjx^ft$yx)<X4e6+IqER(LaIz~c$cxZ+RGW>+}C4a=kc`|k>PC3MnBMl6B
zW=1<xs;MzSQLy2{sGU0Ai@sNws*~hze}5^$^UYsJ3QFxGjpXh04l}j)S!{1$oPKq{
zO>IJc)TAxZTW34Zw6h#2iM^NVs9JHBR#}$H4&>`}%HJhIV}r6OvcSavbie$vwL$IW
zKPTNF<YDqO;&r{D(nYEJs<xEyMUQuFTH*q*EmIPc7QCeyG6=)4=|NEVVeq?a;mXW2
zALtMm?pqZjtr%m&9c^ue88Peg{cfj`63)G`cV@k1f<0PE!}G+S*5FGPaKYfP>S~NL
zePg`VLBe|)OT)gl^bH^BwkQ76$iGipKKOh*NP2Sb4hx{~S=d^vS8HB6>24ozBa{SP
z3L7-@pN5mIC(_?vnNF&>4L<Bry7;8?T>YBgcTS&1xV9=C8&PoMGK=j$4z9c29+sJG
zmHuN*vHkG*#t)@#el9=wjq}~+ANG#fwSieWuo#>knG4NwXq#^ukoN}*^u9(S;EO<2
zY6X?{e89UGHt}o$TSPuT#16ryCKVsG32v*1kf)7G@<jS!Ks{tl-D8R`7oW;<(oRe&
zZv6CWIQ>WxrkvJmK-pu9ep=m^zUh5;BPpt1O|Dt}%g?IGuW;P(u_#lLFzZS%XwPc=
zO=k(jDaKIjlPh`dL~b}PWR9SEf_<bAfy~U0pTYaTBp)9YUf&j3TM%ajGb5iqDpY+U
z$l}dwePX`N|Lu6X$Y?Nx!`k+w-o3q5u4x<b3wB%CK^NqHu||^<!1&b!?w3e_=d^w+
zX<PE9X?XoX#$QT-)gHg!2cMKLG@Hf2%+Z?Q!OtJ{-aURImC=4dYAq^&IQyQO7y=!Z
zojkY%bBO625WExM34C<v^e}y1(MlZxvGthS<jwhvhWIAC+kg`R7LDy*V@-A#0h1|b
zFW7dF|AaamP>@p6bpLQ_sQX3Yc-Nv_-dZ17xxhv4IPkUwBR0Kf65bk^LEYYX>+*>h
z*d+z|rTn|!u-$ISpU=B&Z6PV@`p9G0lq*j1C@ORPXh{G1W(akQC(;n{<6n*i0k`py
z|JP)Y{T;JBR4Yn1WU8sGd*O&&&*hzSlR6c?b{+iT=l<>)11z&8Z>(<2=s46%NLVx-
zCNp8xB9rb7R7q5t1D1sfSL7p%6Lbejdlxf?#R+Z8$qlVa`?uak0;L0)iLm`bclkgb
zRLf!r)crkj^%t*h8-O-{p4RmbZLWjNU<}m)7s}*}OVc+V@tIaoqrL{idUv4{hk;#h
z;tlkPFgNtVz9rdgQj+)J*xJ20aTJMg9YV2iC4UG8i^Yb$z?m^ARQNQnrwE4dzE-RD
zzkR0^uT=`&in&bv@lA+7oXbyQ_!ZV@tY930)xuG-Mb|$XHz7dd#vUPXRNnD9DgW<h
zlxT0VXnCcOJ7laMLd=^*X%yqbn_+Z}XVnnjOCTTi^WV<o(Qez)M?2GoxvHTqL{55y
ztX_I;8l*Td;=8p~Hv~EZb3bXh(i`UdaC1rvOOSoU<Uvh;gVA5Q^lx5?kcEH)D9k%s
z(SOXP{U~{zAg28g(Q!z8+B~Ft-REX32g^<z$<eXTnI`^Yo=LCg+mx=b_pHmYkc4rr
zS0l$8+gU+yttk?j4eYAO*YCt;F69dAb0W$j4g;7k@Zn`6{z?D93+I47dbP74NQ0kp
zoX-6Fa1>mJ7p;~bVwz+pHc^XuD9;G^o0!L1J=kMLNt@}6dqNc~PFi3xqZ2w^i<wW#
z3$0#wygdCgeftr|wmo+L0du7YMZPe@w4v`P*%PT9i;>8EFp{V&`gEijJH6Z9w>!CS
z>$XSv0m}1df{ygTHD5sZC}p{Dti`+xU{#X6rW^0&ZW=T8@|m8v^>B3N@Ux_>otT^g
z{|~SUOmhi&%f<agmMa_zv3EOKPpP$*s_u7s&0F`j>bu16t;FzRvz=(j+of&knY-)0
z=B>-WtY|w4-iMBDvMZLDIx7(w5*rINEB6iW?w1<CX+QXVPdM5-OMS3);$@c`Zikok
zV%*&+qyKf9w?OU%iy2ebzYd@$esB{+c4Zhp^_MTXd7;~wljo-A_H^o1=V_ZbK*EqJ
zXq)f0-=ctE6<j;(*cWa6&Cab{RF$$tM#eUHm%qR7yV$?*<d3+Z7Ab5g%a_}6y0}Mp
zZuuJ88y#!6y__E#C(eq-7zHb%84_j<y@+L01O`~dTu2FC1-?{X*}xv{cLhXpuJW#i
z9BJ$k$Sip11lL~2c}%K$^o{nK;QB3kX8Tg6c%$@jr8yr%f*;!4{tKq|9I81}=b`?8
zJPjtav%lhJ8HeU}^JfSl@3opqIbO5=fjzuaQVuz#e=<y*rdeTVYmW6f*JljBHxOjv
z{h8naYLNMt$%`SaorP9xzm3TTA%)#|JG0|kwPjkCKXCOj%Prup)MKQpV3w?{$vofR
zqPXcx{CM8hdp2g9v3hm;>bJ+4Ww3KZ^Wej=w(|MASPOfHvi#n$^9jVzP2)oI5)9zM
zISbd7)uAGfX6<AEwoiNhPhb%t>)kb<#l{-t7>HjHGU7nqt0QB%_gg1zxNv*kv+&(=
zQCg%T#CZ9`M<&|%{k$)ahFb{Jt`_=#H(2>9aGk-C75O61KLQvH%47q2?KO-xkLwk~
zyk_Hw!A-$X-6`pm{oBUOMdb3bu|-plGSww3hl?4jsoD2`;8wzw4Kj4bBR(E>bomJm
z)x6lljUMNX6R@KWq1K}j%R(EszTKPMv!mNaqx^I)^hUp{`mNhWjk@X0^!sUd)SWMo
z;7_QQL%aWbZe|qA?9RPiyNp1-h%y_<kXt!LWj!0>6secQkC1i<Ceh{Um$EfyVbuI8
zdmigBqV^wnxfB$+I&Mm$irCwYl7nr<J;cCF0lo|~s9UD8np=>d(UR1hUUzjyc&1a<
zAoQ?COW*9V;b#HHikNkz1cLtOy*=_Imc=dT&?b@iGEUP3Qt=Ral;%{DO{=a<v8rU1
zo<xhDc#B$sYr+`v5F?;jf`0`8O9>93qT5GmP=6(;t<t|%wfrM&S;L@=1qnMg*dZ5V
zjLOqY>XrX4mim|u1RVpI;O3uXrBtcUi%YDyz&kP+fxsu$cYGIN#93~7GJ4ayN`k<D
z$9pwT1~16pp0I+s3~~!{Q`ec>=lM+BP2g8Y6L5>Vq^3XYU#1JByB8TTEL-O7@1MHj
z7{b);CzsQK0QU=ICnm5J095FB(8{#Kavz`71FFD$U{CqdTLTeZTlZpvmtawNQ~}X9
zMtW^kC3=;a{v5rM>SLdD&V>bz3Ba=$(t#(C;2(nL@dS($u`6E!UBQ1Tp9gL`*#ins
zwqBK}I=xBmsD1(CDXu+hJJtNgiLHq>O@gec1wo<4t4~)(<orKV8q&+!5|)P_fhWV)
z=*Q4jC56;@r$eb7iCp~#Hmt=`g3EExiea!Setp}!5{28o{1PZLfToB-^|rTM$hKl)
zf<hmRgSM(VM2$IEFE{kF`jv-{&5x9jj9Pw3|7F99qu@u6nK_pVJqk;$BCsimDw`a{
zx}kY;WP*cu)*-_4(5Y+Jt#kKVMH-I|+xU;>g3%JV3X7)7Urm(+OZX7Lv!7pZnnl5*
zpgr~}4rq>DtIqAa@%yT+^jWIR*;>gi<#Q0pVd0vB^C@=tFT-KYFv&9fh(4nc3dG*t
zz0k$}DCw2l6JSULw8_V>#gM!iaQ*`Y%YQKjjvtUO=-+KZ-XsG9$ZY8bcH3n90(tX0
z-dpz%{WamXTE2pZh~y*Pt4}3Y!`%BV={${fO2bE`>3-C|9*3!2^%s@$-KYQy+(NAH
z9kX&?RaJdJ6b^7NGhmKwU3weEg01#(-2zLbiXny@JjDY*PnaH@YA3_Q8yg7%ntgid
z0pO>|>jRpmkoFZ)<oFjtBAI>d;Aiu8&H?Ifn<e&BQdsQSx{A5qze}Di<@c4AX6abw
zXw9#Gf=dbw%z@YSq|kAmy&#XG<s+45TuboMmC`87E^iG*EVI9=NfWPFl6WZWQLa(f
z;tLW-l}5)W-<5KGixDuxWLkJ&QyOH=9(=GzymkeTTkOl#h<Dl>spPbkM2=<ncz&}Q
zc}Y7%lYFiM+4+naIz_+1^Iq1DTZO&wrGW@%r}*_B>0d^m)i?u}P|9&m7B!AA---z9
z!_)QV0yQ8)M;`n=NI|~%D^#|?@~>kO5U2w!0Om|@#*GltQlme%m_8BM3g|eN3mbd}
z7LLW|c8q{$E}iez02IpSw{i%#h6b8+*xke?VHS6MLep=M9i@KM5K1v8mh$pz@OBxP
zi|@IySkB;_)D$e@fEDamIvxk@bFP_5153go6vNro+_94nBM_*OumLb6CnC9F5!OpL
zRv?LS@k~kyw`;i=Q1d3Fv(1#4Z)o#Y+*06YrDP~VYx`Pt7LBfN!8?MYUo&XQ=st!G
zG(6}<K%n+D8i~7HYE=X8l?eVK-pk*3--#3-6ER$2t!7ZsBl*02KGMgSv+hTlanU)}
zM|XFE^eqar8xFZ1DdrqT_9!7)J<rD{dubvH&hclD=(fO%H;@G<*kl_BXK*GUU#MoV
z!5(!0mFa_7pYXpg4gRSP43K;2#I6)jEiq$@=)`QYFI7=L;wMjz|6O*-uc`i2RyeVE
zI2dFv<HrN%y-gx>_c)PFIvPG6%&E#F-%BifxvQD7<3DJX8@g5DL*3Z>Ft>Zw0{7N1
zEb<w%5_S<TW9O{{68I)iC0sdJOipgb&ehbqu*N!%5>|Y}&*C0i*H?$~%*+eDo9QBX
zLCGK5x{HsRLmQvD*<Wa`I#8OOxFq3U4E3I3?sUW}xkR@ea?{}4?<*<E{@$N6W|@66
ziU0kI|B?VPYkJi#`l6$K>fObK&uVSTC?iq40-@?4p(+qt`ej2FJgJi;G|QMGN|qYB
zFL&z&=eMvs$;hNXF@K2|psi1L`?L*@Qzlf23!m0<00mYcT?c8^>jUfScmqRY*JVqw
zuy^;$-Rpd`KD3kpO3Jn}nMcHe1J)>P+iBbA-z(&R_;R2OMRrY%)^g-#?82HvE+3vU
zb(9(6k*}7tBu;hn&u^(PFRKe^yBm_cDv;U9Xd9lY8QedbOCJ+NH1<wC{FvXp-2w{z
z&AYmZby9Acnp|K5ev2!RdG~B<JE<uH9X1R@dVk|nVRlkfM=a_~a5n|s&!KGaPRGwP
zM{XR12y<biVvJ7r6IkC2)sh;P%JTAX*y1)pEVSZtitWT3RBeR1-qls-z8CCLz4+Su
z)|>v#SOHss-Jf`4W!i>s;_SK-{Kg3dlWtr9`_VJ;b7a2C`2w<%DHQd%i}6NjfT}X>
zPiGkCOqv2M!<ajpe?+y9H&#W&t1r^#%^Pn%`-_Bie;_x<Z{5EmAMMo4(V0)f<-51%
zTc~uOm13?V=lEK^N1)jhX{{=^Aiq@Gv6T?sMoqLhhu$O!als5)G}<ta_}o=s%rd3&
zS6d~;a=|)9|IjC@I_c4n7B6jl>2rdUT_wjMMUn;qON(l8wkq3zC$|Q++oTP_tap=7
znGrQ0;xf)K>-f>^`OlS*S<L@E)jHV;YyPiY0RO)`Ppt9zsFA$Iz+zF;zrkY1iDn+y
zpBMQX-95^X%Us+qYt_|{{%IzNe7sBYIE!W*dvNDXrgSN@hZmOo7t;93mYcEUU|6KT
zUv0F%bjboo4B9LzZ6DkJ14N>UeYW?O+^MN@X@(T*CR#kK$?f#hks~Ns)Jzp#tEHd~
zXJNaiVB{ObqybsOZHa$1Qi<00avvl111%x`k7?a+J0qC*ncMO8eiRMSsLba46N`Yr
z_KQhX?WpXKoa+u@KYe^08<LLS`U$EZ#wB5%9s2GjU%&3Ge^G8x88~W?A!zi66+{{(
zTrOb90KK@5Ko+(=w?0+Zv;AAAoz2Zec=1*2=Z&L%nd41`9SUsISKq|lI0K*2u+vq%
ziigp6SM^Xqi#<pyCh*g|88GzOV)KAW`mG1WPYQ|}*0GIyOXV}&0mL!DnN=Tfz(Nbb
z83iOpZMj2bx@=kBmLS$v3YRPq&O?~Tliw$!s`qb#ac9!OLB$29IP`2JD)RL7bM6GG
zoN^mHQ3a9Li<a`=?fLze9;v(8W3w!NJwwVwv9B|H?PgNAv8zXxWGfw$ccQNZewQgj
z%Qjw9?JI4&c-KFfjSrCamW;DwEMh=;%i<WvC-omCCOUcmV&E<4IZp(Ym5u-9t*!1W
z9zb}vxi>cFj{UH4w<gv9!$+7!&sa>5l`4p8$%|%rKI=?qg*A%XaS)atKwiO{2olE4
z#4D$Z_BJ8@u^Fb*MvI^I5{-*WoKF%T^-CE2Hz!H(`w_Vi%ZLzzWYUuuj5J}3m3^F7
zlu3<Aim$hm<CZ_v(uwo-yqUgA?WNIfz-4uhkQRn!d$7|AFiX^M2hM3>4O~_A*=zlx
zp+`)sq=f(Bj<7UfDmb)=vOG9Cmf6@dmxSWxt3>xYIfQ{0D-|?sjA?F%FV_$1zN}Od
zS3I`0wr{oIyyjFSl)_qW39mo+RxlDsjT)A_BMJ{Yfxb<)S)f&`lnObN&U<wLWKG$R
zyHRW!kXNzIUPu*xNx?0|^@eN03ZA>aAwRSTT#Ah(tBk&_$8}G)X#Ub3mvzuoVbU9`
z#K?{C|8So=5w3LE9!zdq6b%XEL3P^A*CWuf`lMa=qOB?L!WuU;h_Y+W=zO_FW{{s8
zaNyW4oHAbgKnKU4KL*7@{67NDXD|5PAl*98gVlk>G&$TKBNQ9cr}+;z*zr|Tj`DLN
zj4Zhpj&$>DInDE22G>2T3)qBXh7YUvYzyC~k0Uawd9Hw^IsUF*42!elZc}>OdqRt4
z>f?WBi(4Dgw_sPzO*MON$M_y_PVecPbaw%n*yffcvb|Y@>U02-AiI2!!y2`xrTOCF
zNR9$uk{a0whXfGI)inlM-=e=);M8eriZK<>fm|uc|1ybq&#DIN(v@PXf;t0Y7p<HZ
z^Ia#1*pB)2;9i!oP#b+lTUKygE%W%{7sxAOCOzr*#!gMRO+8HU2@e>`I3|1g+fo>~
z9gBTPn)vAhVum@?`g#QT{3%I~QX5I(e@<sv&kFlHZh3KbBLBP)a-sH9Zy}{2krS*7
zZNU4CpTanBBk|HLisVv^#&jFq@kqbRaXvD<?db=`=zcf@IV0ha&#xm)f+^wgsL=~1
z2m_duvZ6DvvTs<Qpg|Wbs?7@Kg@3e?|Fq?c`D5yR2{;+gf0H?f4hc0*OgQ1sA2ro_
zV0*)5`ve7KL<iO0f@<gjYutrGhtNr&hSr0iSav%f{q4gcCq^%20UJj)sWNSXea@U~
z=Mi=X4I<YA^65w#so@8i?NCpJ03g3+Gbw9m=K3d1bA<)H<VXI;OhE6${v%}MnFrWZ
za#vo>Ld#@xx{P{?sBZbvto2nb^@zdv?lR-<FF}35`5l9F_^x(}tFs1GI$#SmW#+_5
zZmnf-COE%z^djP`bNaGXzKiSKA;JvRQd4rMiA}7|9pFgcAz$#c&>5;iFENf8eI+MI
zeeZrkpwwRmXgxyCn2S;~UzMWnJkuxGoPFkTz=|xnzC*Pi+@&hcCQOIyihfhAj=Dq5
zL=ni#iVz|wt^Wz3t$1~IPVgR^g)z_N89^c&4=-zs(M1OJpPS<}0xNjfXXa?>hDhlF
z_OTeda=lIRqNo!CRs3k)3U@O_FnC*qnOF6t_^nlPt)l?fml=)cX4}mKs|}GG!Q7wV
zkOOue6^Dk8=a;X9mZB<bRA=^eUyEE*Ml==cEL(=Zwxf0s3__fM(3cy+XA1fjlp<JL
z3c<oKx`y9dOz^gu6|JTPx!3(Jnh=|-b`T&veFF}*_r!8xEGaR2R6^g?P)D_-xkmw;
zWRhH>u!l5T5o)h{UN0f@Y|~@8vM^R6K*Nt?WT-*!^C{}$e;W2mH^-<cf>rO#ADsu$
zIbvUtetR502dltLwi12~=DTLCpK*QAy_&@YLV~-y?adw#;UD&>IETNZ%C0zK>e#x^
zq*HsQ^LQEA_76C@{c_PHEOsl<o}3&AHi-EKz5j+pVZi=O0*N<`$7`5_WOK8JxpIn_
zS?HCF*IPbfOre)Z#fwP!^VqPi$Sgy@C^eiyU!2gNr_rig%S)M7ak-YCY6hN+S3+ct
zWS&HQ9OkItZh2O%??#Xys9RpI#DfUs6cg!Zo%?IYlbkiRG__zx#on4Q&4=u}%&D+j
zm7}EeMR(vdQSUfAx#_+i-9oYNl*Leg`w!z7K%smXsIU9aT57|?>(52Dk6e!UNBljQ
zKYU@D3sY;5MrTIuYKX9KlQGIP?r_whh3Tu3m<fEE?$;Ws@2E1LycPJcn$}eTH4ALB
z#jf}JTKpv^Qu<zA>cr^JaY+i9OKI`&^JE4>$OpQP+pIODI%G@R?>(P7=Vw`gCB@y|
z8IPx1DMPF?Gs`z{;FlovBFCUnV)GF@vaaZ~|L;FINwE)fKm|RNNLM?}^`g{XI{KL@
z`1nwu)xzg6s#}&GAFi+R4f9(bR^6lNvOBCFF8Ca8ua7SuFWqLA58E!i4iLuo{uj-c
z{+E99S3cKwr^=V{6m2x3kE_!%@T_2;`aS$i+ySeA%}1+)szdA`nj<UN3JHpsgCOW4
z+b&~*;Tco}HA}FJ7qpXwlx4#M5=H{Glv&TR1T-th$B596;Pk~JUu=yV+I?2_X21Id
zdg0cal~Y&`j{kYNM>hGx0^pO+^w9h2tOK9$gpp%eol-bhJxFIfeyQgkUoeu-tDinT
zm!H%n!jc}Fc@{^hT|!q@yUG{&M|1P|E0bW&@2O1zc;$KDy2z1C3R!q8=!FLghVi~y
z(E886VzE);UKt~chAHk>LT8~5ksi021HWs|!YK5b+DbGDv)VvnG>keP);nQz*7Dhx
zLcC>b2a&|T`<Xu@HF%Iyk8gI8-v?OCm&z*VqlqyHe&1kKEa0juDV&$uoZfdN{d0*K
zTJAURD1nlKG|YSU^I^y@k3pV!+B6cE9CS<h5`CW8*IT_o4zx36msD)u@MGh7O)WFO
zH+AT4oZd^RDJ?kH<Gfet2w_dAlhWs!UfqeChic;MGmxwNP@+W<M`1Ey!c<<#v}mS^
zd-C?L>U_ml>Dv_t5|_sZS!(te0TxcICxqC1pbPcq8zt_5ajfV&AQ?0Mb}UkF`CD#e
zHJfac`)j0k;^%;d#&4#4k{wp#Vl>ZuRTVq7p+?sVg;Mdi7eu!MyJ<&p+~$7gHy5y0
zt(SZZF03ac_JJR(<%Xz)_v~<YLLKGwH@}Ib4cmy+S=~&wCDswvWq!~Y<3ZF)Bhp2X
zIcs@cGv9?b)KpeB`OJB~@z_wSF4U!JdDyeUvQ)9s{40d$@Rd6cy-gv9-C)D0hc^WQ
zQ$C?&U5Uyk+$S3YbrLu{cNj1n+*@B(wss~~#rD<BDpq*lX#16I@+a`GHJqFW$?6lR
z<kg!Bk-WbVQV&NHZbK!$4NjZej#0x*RR3q!_#a;}jzFUX&AqolS*STR^s&7MJR%AD
z-yXpaa_s`+g8XziAJs&GFL60GTJ>f+hp^@tWY<^;@j3(j;-YN_Bx)3~Wn&HgI(p@|
zg`ha;^LA+SlHF7aO@UTlj^$UOur{<lciDKzhl)43!)dDa_C}isw<&pZyWF(Tci9Y6
zMB1;Im8;e5Nanb2gWb_uDD>_?qaL=JyC0~`!Jr-4Dgw!La!(hX3P$Fks;i`QgYkpl
z$}_Uy^Nf#9PB8n-pu*4Gcqn35pk(Ci5IQ5T1;LVY%MmIN^pa_5ZybH)r1RL`8qpCs
zUcjjxJ0jGmS}u(v=+>%EvP`A*+TfXNYxcp+x8xL6J7%g(XKs|c0uF>5H)zMbERU~j
z{GjrUJyD{5sV?t2R`*7<2lv65d+I&2&2AlU67>j+ehl*@9C$<-=XQlBr`u@`H{lXB
z9Pw(dJ2?Ww3|yYn<${@GGaPTKdE$vWXOsI^FiW;<Z;5o<DIC-=q|QDC6nmr7VbwD;
zD=IN^wv|nxfdYyj>s8DgRL?4rvI=eFveqTgLEhuYSy3<4aX}A6L~$-NoHbAsvCKmL
zwuWa_$iXKTW8c@<s!xyDrmBjIH2dcuc8+(jH^|#2=DN2;_Df(Mm1KGssZg!O{c~or
znFI?5W2E|8J2b}G7W7=ggLm>BjN)&CsTJN`%Z0Yeyp8;utXepgSZZ7BJ>4I3ktsWy
z{R%!oDP@<CRc3c&k^80p&6P$S$GsfMjh&uFq5x(Q_8n923wifMvx<-h)jh5k=j(&3
z3<@&py>aZWJr`ZWjSERa(B7P*_=wla(zM^c@D0GNk%FERX*zfm8?}iPEMeeUZv_&k
zOe6AZ8n;*ixN-N3D;n2%V`iqz5+fz=<a?+!*rUOp&G*}l1AcgH(>-%-)gi{{O^`<b
zVp0WJc&^t}6xzeBk>2|5-phwm-XUN6KT^J@N;n?eyE5B;Sa6oxiz<FaR+8#k$>r5<
zqVBIpjgt%GMS<8Ut|COEMDTBsyI=h;p%sA_zo)d)ugjOYy8P5(y{7?p^e&B$C%iSD
z>HFT5XoGytrW=|qZ|90K4HlDAJUWc;FTU6>>Z|`$syrqIEv82@PA-(RE2%EkG<iE(
zsEIxdH6MK-q7p@XQWv!OzdB-|!w<ApRnP?q(%P3AypGvkJChW7v+J8E`R?dtyBD)d
zw^1@xbvCvpFj30M+JK5!$BX0Bn%Fk`yYNfu-nRK|(c7knA(8#lmdwkhmL;vA$DDNB
zI!j;cv{NT{!Di~a1V5=*k>OM0!{b41{eh09UeWTvT#%jq{>`Hs$TC4cj<DdcOWyE?
z8gv0F8nC}HK%3<Gt)T;gwj#vxrh?oJkTk;A+B@x>n*x*12IdNrYibnHuIM+S5iARY
zswG}1XgkekQN<WUBtHfp&LYe4f?G+J?KMBbN_v);DnL61R?k4>AAe|+S1c*HwfXD*
zb)Sqbo?u3K9_yE^?*79ivq0YIP`1YB-v1^?{6^v)&FIuSns+vV#Ld#!hBu*LXs=~u
z!ictX*LYbR$y>9bzih=fhLv4emOVh8jRchSgmZ~u%lwc}(GPkJ%k$7Eq;6~Ez!dZ8
zaz>j6WeK{T_KNL^v^ypiaIP~xZRKKJ3XwrCb6!y$@WW!_e@Pqt8XVw{emH2Io^9(#
z-J3og5OCHWPJs;|XXqpZQMJgEfxN#vBeXPsWWM?S(Qts1f_W3ibA8pzPIZ6kTwaai
z<<R_`^bcRe1QTc{O@4}FdH}Y6ONF)r8yH`XIR~;(T`py&I|;k8L|J?J9QugWg#$a|
z+7Qe6DXdyV>IvMIR~gZHQ><faKKmxod_L*oxS;hd>_cIhl}A+0X}HnxOae@6s`Qk5
z2+5kr)7UaZT+S#lNHPK!QS;_P&jTXt<kH;B;e#luRoG{g`i#h*&DlEpwEgj%)8+^h
z*TpM$&(dm~`<7Vln0S_*xGyFij(Vta#BUDvY?f-B<319Dw35oFi#@`wvL-PL+^-(7
zHg&Yn^M-o^2Z69Nl|1k__6Rh}P&bQt>3IJK-z;?JDqrAkGFa`@GONJ5umJD#+4a66
zi{OZ{!oFuWqs0k*-<?l06`Cbs3@n7KxFGQne7ILhn5DjFl^rm;t?6j<5^aZQD4(VO
z<gwMsRR4!Kuw+rBVs_a2S?|-K{+a8;Y85l?HlHyJjT%pk&Q;v3jtGl6O*U?f{g-EZ
z?sNt_qUAd0R!@k0rV+LoLG}##=p8l4pZb5tgE$pH<fLH=|HD-$JZtAtf9b&qdaU16
zwV_56^J$?*3uc5O;eNU1c<~mL{R}!9+@GqdZAWPp`_~vn#*PkAtGTR-BQ>)pZJ4?x
zI$1Gze94aogE_gy-aVYmQTU`$LhUJMp)sHNg<ubVMb1}$kY^qsdIOe?o7!$a9<S5b
zg1kLsj-U#Ud>@&t?T610`t3+rIMDqhQSPkYE}+o@dV0MeEL2t7B|U8~JFQ(GbSSW|
zR7!C)*xH1ZJ|zC{K>8GWVI%KA0ooyYAL(M5*!RGFjQU|E-Az|<#NL+V$kfC@T{fr%
z=6a8!zk8iL&d6?|@Zm!Db)3TLk&;{UBLT{~3HR|(QDb?|U4W6ccXm9%>8^$M9I;R}
zJ1Chja+HL<;K4xtp-XU1oZo9r+f0u_p%|IF+3f?ykqOBA;`o-R5^3j|1xW0f-jp@c
zXbaX2Z?!)%XwD3@bL6tu95>#lfDRo7@NUId6fx0KX5Z+2;nnZHh3te``k<p!qKKU8
z*4C0WXRTtF_EEG9aY9~6VE2&W0ey=LB)<I%51do)@e{g=K<wN$$^ItX4SU%i)VNB*
z+S8h4?4PM@6uY}$kAao_ENE?;-BF??W^Wtayw2~r;jDJrRi*LhMUsjy!gJy5MM%e!
z?vD8w$IN23vIfj0O+cKuU;%|+r~!WJmUJ?k(TkKdGM%wJncL8O=p0s7bk(nLI~?Gx
z>lC0j(01>j*X$<A$yl^i)Js0@uos<n+h|)}iDo`4;)Y&V!!PoC(?GFq!SGXN_%1{6
zFX$5E9$x0~{-YZHtCbgyXYmi<Ii7+jzfx}xzTc1aGMn;>H3F@FykUIaflaAI*w754
zp`Di9pwG_Hk261R2;LjjKgc0G>UIvb=ccyuSdU|^+-XZktcta)q8@(|D>JeOxMWIu
z|3n;1H)GimBUWWN8|&gGur?)~zsRry?kQU()Jt=?J*f(Pl*j5grH~mUSFA2@ImwaM
zlk{ej(8@577Hw<!eYZbFM+S;H*zol#Lh}ublTehaiR&mF!TVseJc?rbQ`&I8eyz8D
zJ)in&f2keSuPI2irW;uR4|QjGX?)F8e0Ti!)bH;H$PD^}1783HGWgk|zGnUDGTN%H
zYGj&5q>I1_7s0K!@)tPQqUagi^gdC)utPk$^#LUs7veVcAU69$7jW|O`16kcy-xcd
zF#6w>+_g<*J1;VzEhR3or(@~uFu1$oK<?`eTR)`pYXDc*iTEe3`_Le_MGGH1;MNHW
zNvuzh)V-Z=eC3`~@VnOI_2g`liZWhNV(E~zeawjuMmPZ<#)~;tbjLCzfs_FX<_#7-
zNm|=@xwE{yG%fAQ`xu_-M=QJ$`$O-OSU;k${X=D$<F4A{F88`RA-)+pk(u5)ZDG4i
z;WyPo<DiuK`v<Cn<7d76mrb+7z%mOyP_<po_9YxCOR-c2iGMCnrMDO~x~*#Ufq8te
zyW3t--yAfH(A6AgVYa{mwSjzAd2T?L53Omn@>WD!DK)B~5^>r&^N(U2qcpEpc+UEo
z1Q}3L4O%g>G*Z!SV_GM2vtUJTgozVoEP8c>iHe#|OhI7TZ3>RUJi%XE>AFb`U!KwA
z)wFu@x%wB$Z=Mk}uWDE4OA0#}s8OIC4~gj$X_V63+iUGlNX07}IY!8kys0%<3el5R
zfj<7_mx6X+)8tOxf0P>-m}gFkL5hEVl#29dX`JHSdPNX94UO+{N>ZuLsMl1nugQMc
zIg??^RXP|i8>2z~*~F}Od#Fg51x$A2Vj+a3kObn@egy#A`9i+PFl9(+;XRVYQJ`7U
zwKn)&u%|hU{6)segZ=txsc={3R!}&_K*Id3MuH5Zu>?nh`>Gk0kxPo`Sd2{|h?>hv
zT%kG-JCil1(MaP^6>(<MnCT!4iZ&MO*P=~4QKw?FR_Z3gA-F&qJh<}Om}7o<SMlq^
zo7}>@Z_bQOBF*&}ubgho7+ZLXbA<~(_rL3GMWT7ZWk?UFE<Yz;amf?=+S%yLuV!GO
z`uO|!lfjUa$N5Rc6M-mDwHuojrr-ah0?pOV?m}ZFK?0Z{Dvf^4iOJ`0y=rrER7pj)
zUb!RXx!Vv`YHDz&!ivk~K+%3o7N>9|uNa*%q^#KQ>m1in4`~9R3vIRVm}NdwEx_hY
zV>s{Dz-sgRxeiBeEC+KHLH`e7U*Q#1{Ox;Yh7gcYN*aTfE|Hi)2?a*FyBkEh2N6+H
zrF-aR=o(T4q#L9`q)Vg+hI#zfU2m<s)_d>1|KaSj_xF<|%6RW)aN}TN_)1<l%=6$e
z&5E$aeTGkp$$;|lK~R9!>NbH>)Rjm>t;5Q9whYzmFZ%`>f*E5Y%vK_a>_r)&>Gr0p
z+q9=MHDR|SI52mMRstAQ;XlfilpU@AcBYD>OaALj6~4v#0ql$xZMwhb{|S}+w-J0}
z10qE9n5Z(;-c$o8t8QdtW)NwH{I0jpkWU<}nKFn@a}=iM=SvPU<L3<00Az?CfQ%NZ
zRaX=l5M#|#_p1P4o5$9`78vkQI6ls^%`}|ofA^-T4AkO)=wuxfgFEdnUi7v_bnR9{
zMW-1nT(4aqqh~tgOgmp$_Obg3s`Ddl3JgB={IfSfZ_}}m*>=g>5lh*`-HsT8^$Ky`
zpXeCQCF!!WF;MsXH#~k|^T5dtovK4h(fkb`QE_}ts7DAe-AU9Mfm}r|>iT*bd;T2A
z;HT*1;IT|1MEsg5`*Zmwx<xooFF-ND|2!efX!^H`wiN*ZK*~ubuz>Bco-6@X9mjDG
zJ=O1c>vih(x+m)$)5hu_sJKHJA4<1PO|R{h%I6TT)3$LAANl<P+k`Zuv6D?YYu#j4
z4@f9s0P&B2cj&WP&2F7vwzeEO7iNXSxQm?MuLG6`8;K_d43fbb{nJDQv*)VJ!+pJr
zyburX5(eP;6rEb*b8FC|W&<KkSEb)?<(0-I!Ti<a$NQ%%kq?{1NK$b_(&e#9S|#07
zbbF&=-XlEp^Xl6h&b!ZbX&mtq-!2>3BJ<@xlWb1Sv1r=*>(|wJMq_zc&#A2Y**Ur<
zvn-TtPlXLT)@8RNSrK<+<(ZNs)qMzD$eY%etjC$__%*$wh|#^ODIY;DzA}zQ-PAPI
z22EM&T&+h&nl`~#AiMrvI6_x=ePX#ntNQgA40exo%k0Uc<u|XnRmQUP$IH3iqt%Q8
zecXI~y+RQqpYt%yno483#Nanqe<hy`nq>!sFnHCA)oKqF!)E#T3loNPwb_1KM7E7J
z*t-E+90~0E_d3ZAfRgIfqVHps;GlM?N!r*nKj3LQI=aNXJkKEi{d1|Hz?wGlisYrI
zp8d4(;*({7v;MRD@lZ3WUiip^SXZqc^*c*X7+|C@uh5%InvjTT3k{E}pY#+&6CYPy
zwI&q&5}ZqEq$ce)h|-DW)?Ifhg*rYgvQ^}l1q>SzZl3?3{?s!$d0&@v=^-kst^2QU
zbem|-Cw|n4V!M`~-wU2g=LDj}M@NDy!C%WL9n%YQFiB*8R)Ty+{#vBLzMRE*Q)WeG
zz`Y`d==az7kZNo7%;%`c@R9waK1G2SocGm6m2DEG!5u%fEZ;v68|+T+d-r^04L}^g
z0hm8^dD7|ZkT1NPg7Y?!H^y{>IXkhINkP7CFxU`HkoPZF=1^Pc1(YzWMjLW>-rXFE
zn%X=bCl@-kB=l+i2oAhgH%OZM!WF}PMSP~vDs%6Y=LNKH_j7UNd7GnE(kmojoN7Eu
zeCQpwZoFQGu@bs9&tKPN6MGKA<_H(%c752BhZR{ro0?a2s*XO@PIna0551E&Z^2R%
zoY2lV(i~%Hy?TcEL;i7gxxBI0igHf#bK5UIeW^!zqhxPYCNi9*gsqrzjE>iP0#oRN
z7o2*@aKBIlO2Q+_M2Od6&uB+d#HSTX4vLnx)>=4YmRj4(nog^QS}vR^9@u4~NlQ(f
zi<P=XHqR9(9d;g!hgCEN{nAhJuE~Qg>CZS76gXEbTWREcMmqm0AaCotG35ScZq{`|
z_-pyvme<xw_3AChO=PR8cKeyC9kN^PSs4Yj$e_F34y@kcAPEqtAwB;b`lu^Hbx1wa
z5VLGJ#l5a1z1#`ah)q>f7IiKqiMx$XcGX0|=bNpg1t({hhum3y>x-u_)Qd5A4Y^0n
z#l*(RP0hEG!+OvDq-JTQcI?lyB?+C(1~QIV#whx_Ou?}~6g4tqiDAO51%%Wy$Sl9%
z8rt8O0G*W7Dzca=I4<USm3_?1FW=e8e|~)@8uAU#6n_ZY^VdDypJ7=+SJt1M1pn|U
zC;;i333sl~Oo=9~2wz)8@1P5$SLnp&!~T9XQpB6TfS(aLW+{B+b7wNNLJ6Ffn$4~v
zZBii6t9Ly?T|@4--Q1sSX5%)a{EsYD#e<elvg$e4{K^ZsD;-m=#IXg!&2f*#d=@-?
zieha7en#={IWhR(zjnCfr^L9FRP?3Nbh=(p<&LJNrN-~<Xu7(?ayuUdVsn<VR+;!!
zv$FQ#O!MnaC^bd;k&r-f@`O_Rt7n<U6&o2;mU<y)o;$J$C$9^FT+|xKt`9pG)9Zs$
zAV*Sad@^(9$3_Z$c(wseT(n7Cv`$rZ-N)uh1G=MGqWcK-K(dKMkqMdyICGjcabJl-
z8MF3x8GCS2sD<I!+^66u=s9LK%eHp5-L{TS+v0&Qru?}LX1n0fy1MoO)M+kX@zNX(
zy(h3wpK_#vw#oFKAV~46a;$Di_DXqI{1&Xq=gGH$G`dA@myTc5@)Tr<UDcqqGue%1
ztwwp`i<WB(+55h)&G9n;<QnW%tT$a!9E`meoz8RTX0`gfftyqFf2O)y+16QzV9@q=
zqU)=I>$1j5cn^p=ZG7FArBn-geSDS+ZoWlR1XIKw@ojYWq-mEftN*zamzjN9c-}Rw
z9y96g?i_s+b_6YO5phDxON*}?2n9`En0i0n9nn8Y%QR}I-|w5AZd(@I?+ZfvwzOs0
zxA*OckME0H+CMGGG{mjt^^Q0?n_>ThNUgfH^{ZZ>G}}x?Fg&#*lOr(BBDK+>npcJ}
zTys21wA$<)N%-ld{$cO0rIU3D^0j*pm%=RWO&kgwMop>?n_a)nXnR?wr;{KPS)AoL
zQEcNjQQ-GjU4H2LP2(yqN-VnRhC*g)vx_$QdCXyvE>DS$7{j3=V;AEpGCdmiTTk|&
zu9z$DRk938Oz-pC0zK)a*NgkKq9UVZ-U^qQCO7ne-2~ZDR-a10>8^na12*}R-IDwk
zkpFL2#{Y$~37B~L*9h1e*yrEVhwxlMg6q}W?$C>W3?DSZ^d*Lx=Ubwgq+_uAZ+Ck*
zJ_f|>+nR=B-7Q-KTWx^-)%CwVcU^=)X5;neAZgR!{r7w^XGNtv#drc9pF)Co$|XZj
z2{J|EA`b%7_6$OAY|N7TI0?dr@M_fs`mB|UV74B(rS~$J;|BsK&7!ZXYmSSuJHk;v
zj8?~XYulNYci!p^FMV%A_ayf2y9WgO^9v_C@^*l2s@hp98iHgldMn5lFkic!TnjpH
zYsI!6d-*b(G6H_fJ1!kkrW)qsr43PSc?A_N^2v6#ZRsF)_PLZFbyOL}R|<3~N6wk9
z?0d)V+);r=zsJ)f^4w4i5~~wWVMKhBZoeT+JGis~6=K3asHa6z=$u&w$9`L%ofn)a
zGEaxULniFpDT6KkicLho+AJwG$rUj38r6Bh?K0i<q#8=FatFv{+|s$v$~L<?W+IB3
z8tJW*sVX>KhqK3lcmnYJYI`QV9)j*xmG4}C<94)8=y$oCpPM?~AW`A#p>ns@GF8kz
z--r+@`c6-6Dm=C=+h-r!d0svq^J3q52aIspUtf?^p3~b1as?YeJY4s|yiY>d_%+0C
zS5X0CdU`zdV(2b#OaN0if^R+tAr&VVevfZVe)tE>3<y&rAK&ftR6swwnR+;l4tYnT
zm8?H~ku{SbFE}6nOOV!6V^?B6D*^wh8s43!Zx&yeH+}|kH{QrVj+1S_Iyms6RUYk6
z0$xJCRKI4l^yKmB^-Aj9oF46zRqQG=Z_bm$7!t0EEQa7aTgu#T2=0nwQ(!<c+ib;`
z!U_O%H)U#_0~jUhUK8{zd;tqSPzVkW`ic()q<up1L?~d1cHjH%Z>i}ek7FDRBEx#D
zFiB4%+CL330vNY$E5FYj++V%$4f(mI{NDs_`b~{zYD^*qWtJX!g?t_0v9f(IGdK95
zz*R-#uv#c}O>&P!=QGQ;MoYL?J}%wQURbkM_aO`p5xGsS_O<p@*gi@#NXeLbB>PF;
zu|6%+6B!x>nVA$6$s0g5a8{yA!l2g%juR98S|AD1gl_d0&YP3(E)OS{rpgXFlEtPu
zJa*%V$}7fXKJr1NVt4+X^OraxNno+IcrcNr`w)T>%El@MGwLrw0^?^fDb^$0!tSPV
z?bztVLYw$p{t!w3ev3W4s5_q+UO$<f8!KtM5fk+Vx{^5JO-yF6Q@qw~Faj3ovhY4X
z7FmVQ)A4>j4fc-jc&ajVf}~4Td*2!KGm=_8Yd(M7mO*y$j2H%CbD}!kRJHL87A&M@
ze3f$Zqbu?>#)AEF|8r0*Q3tZjV9n2(Gv~<{J(p-RzK$)uZ*7E?a(H%wHI`ai#|CdU
zJ-o%j4`*v*TCGEl+&t^qPx@b#Vv1GobqqduD|ZWRgGL&7DX9P6FS3aAW>lXUPf71N
z;CHZTEuuy|K|eEsZ8Dqc^%XRJ^o`wnJ(dNA#kv_Y!%)t^Zw*0If`<t?4Y2{ASVdQd
z1v!5wXGp^>kq7^9@*<C0{7Y{rSP{uTyR4K&q$f$-vRaTi#T~zCU?N^vV=xG@c7F=d
zlpgp^q(E)wqHAjS!u90G<OE}N2RS79_tHB1tL#@R-#}Ako8Q__Ornobn<srf1RYHd
z8Oxq{2m+P)#qq+L4lYBNx(2zYKgFG7jj6$Rr|UXyypwngxI|+d&znd3Ge;~)YE&P0
zY|ifL<{BACh>Dh$2E!I7i$fMYwIlEY1x&{Ss$5RB&sC&P6sBg!^O6)a910ePh93NF
z%h{%<6SB)fnK-E{y6YYElbw#s3lJXCOzs-UxPrd;x~8j$$$Bb2m|*>atZdGa*y%3c
zE6^z|$o0GfI~Nr$sA{$gc`0E^dH-YW$jNe`Kc0w7eDSg`oUhE0ne9yE6zw<YN>?O=
z=kzPnZn`O^vAKu?PVg#EB|D)mgk|unsKwW(l9s#L<@Y?yb|Q@{@}es-OiVgR*+>mg
zQV9=U0sR+BLwO7JI=Wx>EE{5H28ITcPdm<h+zd(2*X!zcx12P^Ww{`~3fO*#Cg;%*
z%soDqOZe3HLahAKL)QCFfg$8MG_t!tU{#W*UG^<;vFh(3F3-G5TSF}-xA&ue4P~@~
zyg@jn?i?MWe&e51qGA66y^c$_XrVXHui0UrW&E7oU#@?%heqMPpMzXoD!E~D&W5U4
z7~heWSBpEqTrK!nV|XLsuarPxJUcDW$5|u8$*Li#!w<EGEPUFvdbQGt#f9;XB1-J_
zVyDUP;A$1-OLU|F>9f|?Uo=xy9=R*;8a#PsZ*8f&9=NiPbW$~LAJhh)f;>4ixjZ%a
zUh<mP$&=<CY!El}$yN4UNr)l&B}W>UwL)xZ-X1(n0-Sv`{Tr-j9Lr@r6;z;~!Vuq$
z!A-Q&@BD(fQ4(OvSSi!!@-0OQ&X3RSO}R^w487!|xKbzu9<SZsAL<C0K7Qd(Y-AYp
zo~0f`ncX<|ZHRuAse*$}N0{6odDGps@Sc@f0*UOprq!YTpmzLXj%gjP18q;)`c>!j
zi~1o(jnYg?Cb}YK9&dC{yEX#X9+-ux)X_*3Tb?Xd<Ru^=@BX&)irwRDRTST@g!$d@
zBSy-L`qzC<AL(`<I?k*t34xfmEr~}9f={per<8p^+-KT>%bz%0RY+OYG<pVWyKhGj
zpV-r1RyE4?D^>_NTi2L0!U(E>AUA8-(i4V*KMl2QP(Duws8h5A%Ust*RtVNFXe;>d
zCZ50_p`KV8&#bd2#+G-t2d`PAT_;Qf<*+%9t|2!J9mSUcIwTiIRn&Njh#MB|<&m;w
zD*`kfTA-5*L{htG889E^Ccfkt>#59AQc}1}4)s8yw$^4_Odnh<o<!%=;+U)wcAdya
z2?Y*ewIo?_OfLCWrw}+@hKt~S$h;q|1KpM`%UaRqRp02W#rx-+EZ4om1a#&))3tAd
z4JK;rqft7(P>0&%pt;F{Hg(c7j?=jgz94he2}dn1T5R5%rP$x>hSajswf2``5<@Dy
zyYAq_q-pV(Nq%ntM6~AJI74f)H38$_H>SL*){edj_$n8uTxav1I>65pA?CJTN`Pbt
z8pL~=!m5j+Zc#}4z`yh)+2ZQ!F}#q6$kz3L(7*iW-0ILZ{|}r~5^lK~t=bDR^^fe@
zA6%hWOCt0aYcquYi=7?T35x0M+SyZaIMK*j@^RPN9PutLmaqsJww}z0?pGP&>=Sge
zWZhWAepSt-ckY^yWgmFS36^{OkWQfa3(77a;PoMHyW(ImL-9x;*WxP?$yuFtBE!r(
zpYG^GMbyNNR{+md&=3=|F})#k!^jbKztw3)-xePxEOBrq{JAIZgZiXrB5D~-1~|_z
zOhPrf#k{%a&fi;P1OkGb;yJ+f!<EixaD;lcyFRhFiVy>5YF|<GURlIMR>=>mICUWj
zQDA7L6<?>Wq2#ptUPn3mN-`Yy^KH5Zs3%64X5%5fRLUU~>~-(Qv!b|!qm>+7!jTaW
ztB$rR4xIIPk4okxi0m;!C>sw(62wLPiSqE(I~>dot?~xY;9W}A_G0#VKijh}-Eqru
zS73SR8)Lu)EcrjsYyBe?JaIPT9O-JmA4Lp6UattSGkb~0XY>^f{xFVq6rp^{%zodY
zLr}hh%#|{(2N>mDaE;^0%>a*%c!0X?2)57F#vLMxeQzlsC)La$ZEE$QtV<u`CToI2
zX}A(HIdF9`5||I#FXII({)v~(_sdmEp~Gi8;J~lk_RKb@1Ad4>MnC#_2wJM<L1$Hl
z=TI|X7pU`#r({~nO^`u301YNE5{c#7|INo8=sBrZ3J8bgr<X{?BU51ESAG=(4J@~T
zBlMh_IX!9M7NVTtriLmuXxtdwxGN$%m1;SiAU)tNK)SN`FLxu7*iwiXxucK~Wmeg&
zt|wYSf*)X-j1Z!lM_(CId*%X-0jApt)X^x$H(D|?FJ!vnZo$;t=xwl;XI#QVVzUK>
zl9l0*hn`+z>>wrIsP_r7YluUy9sPJ!+d45{-L>Frqf&R}M{OU)LS%fA@T1|#ohD3k
zGr?8JOYlh(T+#(|T#)4W-gR0_zcF`e+ds9@eHpw@`lV&}Fsb3v`P8&EM?84EeDt8K
z2Y1x&creXdj@)yc^n^<?K`IV{j@wIu8?|3%t4d7U`W@<ui%5nOAL@c&hDdxR2TmRX
zB?t3KZ{I`<xVmTq`_$ZY*_+AZKs>Ve9v6ooo7dvBy9Vp23?wr{f>H{C$)DfmexwIA
ziUQ_TcGdWm4WZbyK+!N_5`%QZu|wBF&|~qlbLc(`BtUL*B4OMSbyoZs@o()%W8${t
zqMJ8&=BMpNke`JD=wbqYB_T)X!vAWo7qn$ohdjqg<@+DQ`cJr&&YWd7gy3Ev?>u;y
zG%sep^tET0aX&xJw)ofxD`E=L=%_^%nrV!0EV^DJA<cT#^M~6Z@5E5a|Ds(O<g3Ca
zS9R~L^jDSpcgORN_pPXeIvBC=+_#Q9jp_#?4i^%zuXJ&|caUxsE#)t;oTCpw3wHbM
zND?N&K=G>L(IpyyV^+Xx!QtVn?jlnIVh=QD-h{1@$-vIBTR%0>bRzKT^Z{D>U{jb7
ziB3Dsbt&#^&8^ZF@<EC$Fp`f|h-k^R7Ck(4wyCR41tCpl?qd5G1=co}X6KIG&aY~h
zRSnxCXp*-zs_}#0ZC4L-TsPM`#=oAxNMLb-uS_(%&w=^Hn>>PM!;>!E`6&XR)o(Mz
zhDNzr`{8I#oxE%7bZ!XM{5sP4*#TL^I5RK{aG%-)SUArY8qcladGfttk8WjDT7-2U
zX17Sj6~>YQw_WT7GbnNgie);!Jhvv!`uk6tBP0CoXv?$gH-toR0}YXp1F8B$_EIE&
zM~<zUEzpVIcy>xp)}PP+jF*Q7d}%Y{j?&;2cruk94Mc2>IOpoMJA_oz0dS<Ym2zqQ
zlQK}7G!g0Fg*L21tl#esl~1$dRVjQEZdxTN<lJVY#M!qP1uC^zf4yUd36;)E03FXe
zGo-G{i$5rY&rQX?@Rc+x0Z9#6lv2->64c83GOC?)tyd=kdm|PS!neAK3C=b8?ms~*
zB|(Vgn`aKKCtZW3xq^jsy>mi4GxF8857ay!qVOr7$ud1-es(l?{_*e~s7@4=b$;ey
z4+sQ)5wf>o>~%1NA4fo!6xbT;zY<bF$~aamLYnQsd;z!51a#lWKO7{XTr>B;-hLo&
z$vY*IPjv%0RaK}vWM0~Y`BtoT(gWq7y{4GZjo<O7JjR>)fS<A$<b&6JIXUS=xu$2s
z!sBWt;vmBlPw__FBWLRMcdnnGzKxG8UTbN-#W)!e2QChX^@nQ9dV!>O0^rd0x)Og_
zFhQpDP4k}yh<X&u0o$E^bU9JAK!QMGpPj9iS~M{_>kFM~G;-@SN+!+c7r8h_{-Ksu
zoU=3H7m=|;>}UmOF{OggIr=ol3ar;49$yfckqWjVxMK<$uS0X)j#SY5xN9r=PZ)2a
zGEfm4fWbmlclq{jh_Mj=cF5!LKH*bg8dnWnjuE2M<40|yR$O+R!wge?;4Pm_F9<Jj
zQ~jiY>G&gA2-N?}m|pX$EgUv<{8X3!P&?ZSHLS^enBH|`C3(4bOc%|o7QR(Dhh@6$
zhlc|=K;N?sr%^Z;7}cwyGRmBHYF|;2K;Nl)u{VKPRY;^@4aP)-8Us5z(uFKhIKj?7
zKB}4XpBm<uW8k24M5-#0pQ#n2O;V6%uRWx<%qtT?xT8z5|C$AH-Ch4_t{h{n<$Sbm
z69Cj5XFRvG!OL7!)UpzTe<9m{-R+`!#?!BVnpW1qV|Mi{qTLu)4#JpH=Nv{daN-^B
zNy&UUx|LRhVuEy7-e7~w`98Gm3U+S^tQ9?^OqcB`BHOX!0VTdR4LL$<2VVE;4-Hdx
z#JE1=1)L|xv0rWKyc%||*Mmq;RwMgXCgfmI>Ikt0TdID?D1Ms64H3eQfVHKF4c&ng
zQT2c~o)2sPrdAjojH7jrg4=kdlOL6m^C#Tvk@_ALmwH#Ct(CM%dB7kwb%roFb^5}|
zt37?_B@9W}SyUV%OB(C3yRP0NH22+VGP~}f@XP4u>TH#$#sNuPJJn4M>vbF2TWM_C
zxlTgC&A8>fX%y6xNAy|ISVJ&!ETpKSnMEM+d1=;-jfr<bMDz`^_0ke|e;q%FDJI(|
z);YB(ceOP~jEKtc(O+>@FZ$B<vtQT@>i?&V_`guA5Z90RnIr)AMK87E#S-khjs5ii
zj1uP<;ClToAPRTkHQhswb#J`+t7&;!b$CTsKN5T`6&_wY!#I!2=8^Hc?vf^LVKiF_
zep~r+`Rc~nxam29SOkF&JK;mRvulq3`SERIbHc!KwBZX!E4{!8jajUIl!Hey(U}d<
zCB_<-xuio%p8Kj7s7|w_{fd_i*+F}{D;#2P>TL>iUzsbF7{mk?B|DqqRy~=pR?9O-
zrVLk1%$r+&S81&c#x7@vSKSw3sI#-_qDPL-dh@s1=cxl-^4(|Xy96$`yE+7(HA6^<
zsONQc;Emf%{HNBh<j7*btNmm)N8oRH)@Rb#ltDb!UoWMLVp7L#yqLS!<P#EU>q4q0
zXdqkYUUt2`+~CXhjpwgcf8wdKPDK#Amo}@ti_A6qZT-H(ul~Z8(7MAw#<_U8LP}4u
zHJS(>KlA1;BK5N=|EQa*5*BsNImTrDHkda5Spa#2_LR{*Sjur(j=_7Oc><;98;t%Y
zX2evf8eJ+P0jL3uoZ;n`+`T^~I*HNmXelRD-ie>qmRQDvyh#%AKG<X~{hQ#t=Q0xs
zOcdb-)|T;#2OYtIt%s9)VC{n2SQXmOTN1R#Gz;Q!gn+9yyNdhTasQxof+)g04C1F|
z^N^w&7%j&N(#>v4Bm4J_*(KecH|i>P`xCNN-tS~9^`=cQ#G`mAU*_^}^Z9`I2srVP
z#7=Ua#hLKYfh^r{ZCte22O-P*j!B<&a{Jrx@oHX54ye}3j-2bXodUJ;v&kN39SSOb
z{>fVl^KM)V3lVd?5vN6B9F7y*1uUd62FxUar~tYi{z;(n+cs36PDo|;Ueqc<P;`Sw
z(ba-)z6GCrKP5MywVc80Q2rL_dlo=~i5k9DXT^%;aV)R}?@)Wj+*W0aD@=XM%UtKs
zHZdHhr>wVT9c6-D1O0!G$l7;`Uh=i$vW1TE9*q&WhBwdRL_JMg3LKXi)Rn=UE;nNP
zzpAH040k#_zE&tJAz`zb;0{wXsu+50bZlv9AS;O4*^y=fq%&&f*n&k0*jek;T0(0F
zyQCg(iejekIAr+dLoxZ|6O`$$hSt}~W2@!55etvaOq(919(Tq6txs7nnRA4>0P$zH
zq9h33*|90dz9WhK0tAsOdS=YQ&@~zDpZbW^o?CJ5WGJw=5qFKRKB!WgO)=kngWX5O
z6xGnndv#elfd|S__MQP6l$xcO0Gek+b^SH^YTR0{jG4GvuPtKdLM7)?QzyB(^UoLd
zIR_L^b8n>a#Rf2cH-!FD6URRDGz`Y<0b63&i*7H{QR82)-BAcP?`O1&oGZRCF|aEi
z={POu{ZcaFC~y~hj44P|!-?GtSYafzxxGOe?wQkxANXQDilNkM4uv`UO4=kHE54sn
zoQ0wvyv-y1$wBsshO-<jVsk1J^p+WVAy8=+Dn*Nq^DEU>@^vtHaq1zVJ1+Faote$h
zBU_?Sc?>`jadqe-2HZI_vu-2S!*bFY1bCyQ?;6p_t}ZY*YO)}<83LKBot?H00z2kz
ziL>~%kLrK(T$^NZPYI0-*!&Sq<cBgo-d~%q-vq;$@FvUiY7B<K*&631Xu#uy!%&@!
z`OQ}eywl+-N#Rtzeuw)4(&!;~w~uE5)6GG5U{FhJbzbMlEvSo+IM9afSCLq6KEj^q
z3*}!RkfwIWT*R;1>Z>b6%v5`nk&j2WUVVr^K*%00nh?mKN?Qn@IDtlAHjffXwHS|k
z-J{;2Mod5YB1{p>ad+WYqK2|sgtKjJTjCg@r9J$R$N%u+#Xkzp*@?{2(#^}rxmq7x
z?t~J9V)_IR<ddbQREvko#Ztg0W4(03yx|=JI%yqeu5Adcjv8pz?JAnb3;<I25V+<D
z34;^KCsNkUY?;(^!eyH`Y?*~AzsW|u^km-~hO6ab4_FWB+nkqJgp@Yb(>9oZ^w%a@
z@-Ht&8r5{mwLC2G)o7@H3+p?z`zy7ZFQKD^Tv$4bT}=ee@_5pRxJ`@f$np<Mc#yF8
z%_q#0W|V<ET6?`LgZAHq(tb<yW!$rOL@4VbKfi--OSUYZ%K3^9Q#P7%JBDmF+YN`}
z9wp)hLl8!@qf*@1UA!}f;F^~}thzFpZ~;xOt1IF_OP58d9TZIvS(3|oCBu3Xka;dg
zY(|(>MWSNd>1xHbNy?)JD@x4`SYFDN-8*s+m-V#L`3Xi97L)Ia=%Zx=d`UuN@nq`I
z19&aqdPoaAhcTT{q$W-Nj^A}SXfLZg$k|W*Hs3cEa^2=s0SPvS1&S#mP$2$>$}oNv
z3O<k#_VtpD{U%4xrbz3HO3;XzIWFjp;miV_7~RyG0P>wMB3Kw!pFoFb>m&(zdY*MF
z<GoS^A^Felvx+?Eu&MPW0s3oWDe>-8o!z-loGV54B_Kb|{a%sC=WjbyvPFq3OG5YX
zgX+wV$HqXDA@;kVeJ`~?8N*J<T4F{=X-DRYuRs*NekmemqK8Ea4|aUN1Lw=^Yw`{8
zXN<FrN2yiO`9czV5hWCH!2;jCu>|aRR#+)?#ZQmxNHTU@37FX<wZq!RL_qXxaoXI>
zg{BWU8guozT;XlM!48v-ihv!|`b=tIDoWA!=Y{BG+&FnfPQc;Z=y--3oY%%9d{BQI
z`-y;D7P!$1A0E4D7pB*qaFIWE1=;XfiH2ePWur_pLRiQ?to_P0glzckk`^bho(YX;
z)$5H_AGNoT(2u5CL6j~Xxqk<{j(mOH6;(ItDkSS&xFb%N?-gK1n4(l+{G@~9b$h5+
z@yGT|_Gg@gTdj%+=Nzt_Y_9;Bz><aQ^nwTHmr*zK5sR67P&?ZxR|if{&5^mZQw4Fv
zg-L?hAl+nWO|$Yw&M8FE{hA1B9DH#x_6CcsJ*1t!vra2Ko{Z>?@d^;7?!u#SN&43@
za-7QE_*WAwM5EKUV>1_~xdh`h?@{63UU*e#(*EJFkj%zrCSITLBY(D(DutH7RK@gk
z5rJe%=+Cn4C4X^IvHJIqa4}+QgM9$Zv~>;@e8nBe;HvL_-YeSIxX~)1)!hI}G4$*E
z7B{I(yKNgk?RhTFvfJ4zAHDAVQ)KK8g)76}R9%DV_)h_lU`V>xwyrd5rA7HqY5LVW
zLQ5Iwjt7d7iscoaysIy9o2sr`r4Z!30SapYfil{5T*OBe_SOsuYg>-fLa5B>6IpPf
zFZna;Dhc#|95MeBb=X#W>tUhS+*dt?ez!ZLCwUxTH_#ghm6D^PF83l3M;S3q#@?LC
z$7i8=S(^>YvjgI%_fEJ&?SN6(;H_F!xT^lvmUT<)`v>L?C^(nX)oqEzOoSUmtH&}w
zu+ycDYcn5jm`1Sn^wOU0ng&&*i5J!qc<7nG$50s6qi}zlV}hy=*Dg@eSh84mk5=r^
z(v>4Vvd__;3&w!|*!FUccLf;jg}aDYsgcN9ON=h$n^~|R6zs>qNV=Tm`K3u6wn)se
zl!G~)w))%U7pGWz)y*Se>1}l6>n9KbxnwnGhJB5k(%0(a=2xW156y$(@`)w?I}5;u
zFP!+_w|6RU^J&#HZO1QDhFu|}DwU_LOWjsnlrDMim&{+-KTcDerDwBdr{hsEktwU(
z1v|YBzq^vIwH)c32=?#|PznpXOFY^krr<k^c#-!Ce%Bo<U8KYgr+3n@XAt~m9PoH2
zy2*FkB)Go7*;Qp980DhMUCVqg#YwH>=)&FxqI^}@qG+)Byu_uOjs0FvVu}baWDIED
zPyW2y_>BgT&e2lULg$q)cPFLRwh|z`ATOPA_jF{-OFAy6*+GvRS#qBZFgDgaqj@Gw
z5^x3DS}Sn47<lkkaVD%ZukoBqJ8R?8?=BD+aQ=9iL8dF(&sEd0&`$x-RgZ|!Wlt~_
z21M-lZ{=^Fy4wOxRrsm8ag(1?N3e2`B>vsGNWu7ynOcwIK;GzB`!T#fK(G^~2qpOM
z>(jyyj4cu8E}(+~-a9Wp-|G&?nS|={?I!5jd#kBu_~N|tq?r|^6U`pFqI0BYrUF;L
z@wG`IM~B}}FXIkV+mD-=f#i*yj6w)fT~q`fx!BV9EKAZuyH(d@-1}x?fb(TR-Sq&j
zpxaPfq=w+G-`zpGc%Bgmh=7?M3!^yYTVnZcWqU{dQEfiFMKN!ZjB%dKiJl}bkrCcY
zZ>CL8J>9L(e$u;9hqq-t$wjKd@SCY?&lNf6BP>AU5WxPRhDqSzYlqD{fsw8B5goNz
zjwE^dS$d;;7CP?0OM;)$Y26|>Fdk0nte2wb*;owEcGfYlU&Dv=pqe&udij}jYVAss
z6PxqEpy!iVP#^$<u(n7>fw?;VEc$bfq+aC-HYDWiJ1))^>@UlCQoiLQH`9iEsHH;s
z&oclX@qV?{MfwNlv6>QaNU2jb+)y#iB*<LtrCZW{t4lq7<B9gcczshSr{*r>l~N0q
z^Qa9=tkh!C|L^8Oukx;YOq~+Tx_V@q$I23gtS#c9tBH%Yt(`6dqNFr_@z?VeHnjzs
zO4U5B?4>0aq(s*6)i&-=HD+;9I~wJtx`2wdonsy0JpATbm-}F|#DNG+|95lP!X(nj
z`!hm-_MV*^D;2q{3qy;c%c$#Z=H^yz#pS^DhHTaN@<QR)OdBlv9_mG!eBi}c)Iqjh
z6Buyr|EC^VF7@0Y#Jk1OU#zaNvZy%WsoC>>oFQWRE0z6E(oq6fHA$nNs|sb2MX<@Q
z7emQW_iXJ(6ph!CF82XM&<4gDb7V^hJC{=r%FLK1#xACv+9;>|b>#!nz~klPrddNS
z4n`L*df1leS#R#(jygHq=?yEmTVJY$;ls#xEo@)y&*Rx5<pSNm19^yT1$^j&3WWj+
zKh4<X5oy4~LUI@6LYvVjcY=Ewh5~+S*I25*%&_9i7H^)p$K(D5R#Uqk=8OzjktRw0
zBb`km|3i<t9iQq_63lN?)Zj6p-ck>m5^D`)lAjctGy~C-;NdM~>5u(zP#0#?QYA%f
zatIKJQ$C)L^t};Av`cofch3=ej&T-)Hx%oYn&I{3L>2DL?P?DPqG;cWC@GZaKu7Qn
zZxQ_KrGie^_V?>_*pK{!{$|SU3eA+5RRMvAO7X&RQXF{raIg<G5g$=61LB0I3-2TN
zw>3whNL6D+ET})Js$2i*#^NN?lJ0oB0xPMQa_op*;(3k#uc3}!b~TPyvLX<c!+j^7
zBw6b?LBacX^wo~LX6~&^qyM+G{o6X0M(zA8^?=gDF<^lf)jXzZr<C(oBH+#AqRn=y
z<#@D)-J~j&scvzWe`lkCBwA#Fc_xyH^zGR(gQlO^oM^x?$me?S)G-Z%|Cd&|$oB24
z&7V0QY(1Vxo1oa0$GK|lABV&xf&{*)iLY!$ZvKpsQ%*=r9v{>&$f65d66Q_{cXp7O
z-~S#~|79s^Q%z=QJIl2q=RMX6e``zz0wbJi)}7vaf;?hW`o34AL9Q1vQqbzZ8>SP#
zDV`7rd_j-??czye|1J@g<uY-q`%&HBn<v#6sajnTOQY0rM1WA>O_PB?eNj)_qv@sg
zu$<yc9DZtWI^9BiZhNuf<JKWepS+pPWFSrj{clAOsO3Odh{)P*s-<DaIAvWXM^0yb
z-;2L%PTOc&%H@xLqE=WVkGh*ZO8>+R+%7D7yC^Q0w1zE*Mw*Puk5Y>K)D45yx@E4{
z>dz1~v_6^8KQc5xKRk{eb}BY4gCsF_Yh4WG#u0$<vKXMlk`pNx=0a9_XRKQmZ}lEq
zS^E_?@v%fqlK*YjJZY!7Ln8>{W$yWC@euWVtt0caxj<JL&)}ZbPfup4-jOXFJ<LZV
zbh5p@2@Ip(m^Cm!qT;6D7$V0gx_$fy$_}n$)Yb1(PR)C^Y5L60422@#_l(YpI;tkl
z(#Wpzo&C;@RGj^bOrVY7FD_GMUd^a?$TYg&mOR&{S3s{vLo!#_wwL*7?0Y9J+If5C
z_M${=GQ0X;y?kp*a!8vo=v~Wxhhi1KYoKw-=IiBGQRMP0o6vfmXbi?3qX%2=bN%Rc
zr{dul{OzP8YWsInUPV6fJL+kVV@mM)oma+uF2_r>kNuffuEShfZxlE}z<AoYqnFXk
zDP7RjfuHnNz?S0-fJ8xv4)2+rui6gw4(@ajp5&HZludpaHl>?fzG-B^DZbr0yg^nO
z3S;bw-&`p{+3c#l?{4o02gAFVtbFwYkO@cnt-*13`Sj<Wu<jnXW1DYUNiJ%T&*jb5
zTDeFNZAS@QFhxNwrHfqM6KwDWNHz(+vlN7!x@tH*#+_R(idmMB<ELgW+-AZ3|DY{Y
zFL(qW(N>KDoOwXvE>m|0m><=}wgvhJT9#w?1>N%o-|wUBf5Mm<$Mdd5299nI9oyjN
zzpQbgt-Wj0^X-SlB-YWpGyGfmN#P!+b6@UrO57SPI3Z6dWrJ1MEF=4EqO0$5K~uEE
zxNM^Rjw|GU?SEyauzsXP9(~^f;qgO|D)t);cuebevf-^L`hngfz7J<qQI@7M8gRCq
zCxfw5QC68`GzkmDo_UJ5v83i#t%uw{K4OZU9g>+_yJ2Ru4Gzt<m40e`1!nPQIwRWK
zUA+nc*Fs?P)4qJcx0gZVESyc062kfQ+ncda?&NUWY0_uEg*1Nj41B5fozciE$x)iR
z^G<-fz_wX0!o1^q(UVK{=zm8u1EPBN3MmRgl*;pY5=$@S%N3fp_ieSm{Fbu$-C?^@
zgtuw_yFYJdQJBji1gJl<KIIO6-4rBeP8-G!vA<HQBNxpkmgnAcMs7P#`Zxmkl88GG
z29>xDyHJ-e(?hAIn6*rK#Xn%KmiU6c?JmQxf}?W<6^E^PPmuCH?r+i%q>&RHszoJw
zH%w->w8`d?L?;GB)`5U+1W5T8;K4yWx(Pz(^|!hu09`fs_p~fpXwJLvuHOuCdRwA|
ztUtCC9O?E3&ZQ(~yH~b9|Bo5I20TjIz6&ZlVz9nEBO^`UeVG4zVxyEi9z@1ySi$M8
z6A`uiC3X8Y|B?R=1P{5haFyfNex5ZIT*1IL@On!3aC?JAW^Cb4OMk7R=p0%aMh_vp
zvPa7qR+GM}G0x>(cs#FkF6tS$8LWwWg;JQasjKtS&AQnQPgV4+ih8tG&-3PsX4agd
z$=FtGP+2_{*P<<srCj<#FDsxP!R`J}0x}xC*~#$8Q)D~da4ux-C;h}k0v=xkB*Axm
zUQkv}JD&a63i*&px<4s}aVNjlRX%r5*<cMmx5~s)oT!Q531qU$v{&cvd{sUq3y%JI
zQdw7gKcY<H%v7=5g(<&Q#f_3p^?iv?d+~Utt{qRqn~d4-e75eUz`+T=1#s_Eu!Ae*
z+i(BMz}J3TYfscTy~dydC3R^hl6T+RomY^_#_0fCMVK5HGoK1dwW>FvLARL;x=KYs
zkazB`3ZS=jZ%QuitT5MKA4S5v^CCvFJ*4qpUG-rI5Rj7MyvjGVwL1&lB+s+{?R-D0
zeuv0{vOwM_SdX62kzq(j?)-c3Mey6sRMRj!7T#`{y-&R38p&A)wo(g+KR+<Ws0LBd
z<`(m1?0(utbDH{<$_HN4nN8eBa9LYu%@10Hy5z?18}6ftodNJt)<hsiR`{2ouCSL#
zppcm~|0tKY*?V_yAE;=(bR)~I-N?<zHfZa~N`~T?fx5Ws$UCeAm4>?JqG11~x@WH5
z&73H#l6B;A@WV#Z^vMmqQfCo$R=#xB6gd3$Bbr9hTZ24Qu?)=~`kRzN#*cg+yH4GP
zM&Qc+&7r&@2s3B^_1`7UnVk&6RQ;#hI{4PcR6@&s<%UeZicieIVe;|MK*+~<(${~L
z?gR7`m%~qp6M)eQ9X5kC%&MJQc6o#h<Y~HInVq$G4j${;?o7BRbN+X^v7$rBH#is{
z^d>F&4uoIv{%v*gTN(0;dgJM5o%57YhEYdPofSi-!#|2f-QSy1Gcm*yY=fqZJu!2%
zjzoNrULsV>h~oIR!^pbAdT&%a-hrox9`|plxo375eBunNn*l}x=?ThCY=LE(nUmg>
z7EfvIo#RALskq|a4^{tSLR5>6(=RMuv!T_i*}t5)KCfSwmA%HMk@x|u$vx*zX71vL
zBJ74L2!!%PY-#dZM#{3JPHtwOD{^T`WmFmGYrOSoN0Mj>+7t_2GM;V>xvL&pe$2Ni
zyIvi4_Pbjdd!Y#XyB9^1ICFw>j|O5ab^ocD8W)xM<p2d%WEgZQ+@bURL<6Tc7~0d%
zY5u$2$YwASM-M{bIU>*6tb2Yu%iSN@kITCCp&~+^7dA<Bhc#IOb}H__iZhw<uPHKy
zP`jp9iRWI>*@KdwjQ-J3dfkDm6U;@TD;PNGQS|ilPe+W}rD`P+->ozo&%pYtzl-=b
z=}6>SZ`Rl*U#hp2yD>?!7tve)6RSrDxWPXC;Lc2WxMFSGZd&G$xZf7h?LzzJF6=z#
ziHg7F^<P`@0?#Bbt5m|a%211P4h3kQ_Hq@%XlZ2gFaIR}S~zV90fOKc+uPqmyP-SL
z2mQj(;{1Hi*7j<15c=eK*^!!~ROmTInlewWRluSr)_>s*F^qxwWFtla*+K3{ME0^6
zQ!{^Dn+A)j4NH*DqzwK6t}`XDVRY~+&aXwv&&6eBPd-mHZ|Sm@<Ii+&8mGO7&GFi~
zwBES{K-n2#66Kn%L2$%R5lfDOR)G=KnNi;iSJK@nyO2FIIxJ>5l^I!PxR@XO^;tg4
z8)32!(kjps`bVsxLnd`ex@AFQS3ubWXPxWHNHk6~Xi~X==;ODiP=kD^=Hs~qDf=r`
zh7ks=K(Gb}DdX{dHA<zkEh!Ky^f~PlprVA(+g9{*^R>vD*%QgmLkhdNM~zO&h!0w7
zNf2M2x0^E!q!+5JQncn!=d)wCxu6O2_LDr|WE;~pav(hDyRDk}4{OoY!l0HYJ2_b%
zC32!TD5*dg!dm=*4p!+=Zlv*9<=yU`uCl`IWg8#Ghm<gC&%eZn@A64^XgoJxVV`YB
zf4%HjS2)66BTRzN*}&C4?RstHr`x{RZN9))0kM7bl`mO~W;naD4rh1{TgsMxR6Lr<
za&U9fX>Y-Q(wgRQ+l;<F-tLc|fEh2jIS~f73`tT~^asAq4pSqgL2qwB2zS+%it>@A
znZZSSY*2O1C8-ed$?*2?DH$wQ)$h*T61(kl7DL3Ttun)-Vmzj}N&^Cn=Vkc}=qqLO
zebrJC>9t$4Ij_5||Np3NT0xE9iiWUiRcQ}pYLY>}75UHJ?yXJd+H}Gy$WJ$pA1`9i
z-lk)b{A8sy!o>zmbv9I4P+Wk<tz0S7MqRW-c+?STdsP&^SsPq60%<na=!j$SFsoby
zBZu6gAJtwu`${-6od@3>bI|CucFU!Mp6=&Li9|VNd`AS>xa~uR30MBDZts!O2e<!e
zC+wYFzWIB76<!lt6P(#=(p$AZsC!GOMgI%H-I@W9>u}p6F3d95RK#CFS_@A{A9Qph
z##N2H)K5S`b1ypE-uKUmsr@?Iy!w2VHLK*FT_ktvS=<YZ?iVT0f|6~MMBPZjwzNZ`
zQs#n`EX=oM#pa;VuLAad&>JItD!7i$>k$Xa7pl)b)bv+%=<DAa%iEs<&ew^rbz_@(
zBkF^4-zl38#QNpNQq3!5*Jp^Fo5a&cM#d?j^6P%$S$*{wUM}dqbuT8d3kW~Y?sK2<
zJmSE~w_=Mzb%JuQFF5>g=iZ{wG?|<guK?Fi96`h-zJIAnaa-*ruAIeut*A$F3x_z&
zN1H;O^K<b{`wgk(v2Jgi_vuOQnf7H^H6_cgYI`s;OcX$EG)x7bMl4;w7AGFBp~v;&
zDw+%%YBiR$`--x_|9bpPG|tm-)W5)Hf+xk?Bw5?7rYXniI-of#xg#zG?#tnO9VOXs
zqEA3oc`qUuV2y8fe1t^uW`qnBtX;mwZ;|i>5Xuz`jk#7cBnO2+=kk0MW19(^JwC?|
z1ajili$U1;KzBDIxxcgp;1`VnO2<};dh!y&v3J+ldoS4e!jYdrNXwmAf4eoJ2ylfk
zaN<^3q4S$r_f<$+>X>3_9;^Xm7ym8z+9Kj)LR+ixwOjQ2b>2y?nKA@d((gW<)6DiF
z5=0vRm9F-%&55e_gdgz4dDzV?!xqo?g&V{wa{`~rp7aY{neNH<GwUxP;?)bW+oZ7H
z5OtXY+4U<7tL$6O^rZ_Q19D*8CPabwO5Eu`q|usRX&s-gU@0^Q@TC>7BYkkRyF-vc
zgJ}EoeNz(a|Ia-u7-QF*%}5H<TXL3~Swwixm`afUYAPK4hu1;hu_mPU7({AoKVn;c
zMF^Y-&!FHtGy1^jZT8ZeI!t{$S~y$(efYtoIyrmppd^0-CkT)}zQo%}PfPWvqwx7v
z*4|35c^A2Nridszrsf61#0`NH3Iwagh@&QFYz1g3L4DlGt{RQ-HR_}R6C0f5CK;+9
zC}7WrliAg`aV@aF@|uwfe3Y*`+(mx(BX9Iz_EkAy7B6RK>uaElnwtLPuy3lm-`Rkz
zs32cU{c|0q_qjUQ2gv6Xxh$0(r)yV1lBQFGnt%qwCn@qGtd2O0b!2|uExw58;-?El
z?%%SQ?5^jHOKLm20OFWgYV#~Cb84CLDq119m`)(*?<1u?UfI?a<A#p5;I^6=hX7Ag
z^Ql?}6U2g;anR}`0IB-YFftK*IMPcGv^Et^EG6XwaMnJGl+Yzmk?XMw5B%-;xPk0M
zg0nU0UKH<cl<`zOu<)Q=2p&<jotqd38O`H?**6xJ!co~GQV8fBl*o0bD-dD(^OF^C
z;(I>28Q|TrUz4hI3(LV^jHAoF%4qKaU$gzteJLW+J;<49bI^W!@R?`B4jOeb#taIe
zd}|5*b^z$1SgZiMc+>PK>Q*dvM=qs4Uu5~`QvvPCCndA7g77s==8-Ad_!$=vcn=@v
z?dN^e<%<R3Pob^u>D7Q;=z|(dYqU`<9&ZAxq~&#h^zD}qpi+h#ftl|FcTEHBN2?V-
zz`_{y*<1?jgNa~EbM}*wn44prwZ>RT*8aQ<7vOw=j)sLqW(c+>ER2%%&)}5I<`=Co
zkP}L=ZFI_ww!b2}qRkGR5wNptG>PfQ$N+Ez(;9K>NUIUU+GBVz&1n`C<t}xu+iIU6
zY>yp~o^)3asYpYVPwQOoeWJc2pk}C*slwTw`qS}|a$qmZllei6=7o86yc3Y@wKty|
zi*f8Ymp~kyCyI+I62wySa-0Q6=Mt(J#ClWw9AC_1q08S@dUF`8grq$^UPV;Cr3^&N
zz$Pn_+m?GCXb2WA2MD3i%JSB3FVe1P9ic3R`{KSY1zFuOGgel<(OVz?F!vuG*WfL!
zdyucMo(`dYZ_9k`j&%;8IizKG`EY)!$8(xvoTTV4A_7x;=y0qKJx7BAOgVwwxcwf#
zcD)%PrPbXNrv8>*hRE~;Z6jvPLm4mwKl!#RF3AxX#k+(rOz)gjyF9(ms<_-%mAu)<
zDet{=?Ojn)>Z{vVmuBE2kROaOgS)3$QM~|R!f2nLxT5ZHCg@M|<8H^)xrfqCW8FCJ
zJ%7x%e_z_p$(P5>NCKy>Sib1n8MHU+J}HI0=&ayr4k%Z|ZHEi8InV`SVp+D%hI|({
z>3xj!jjV=uXI6Gyw|DZz0#Rrr=65<iZ27vM3i&dfmhJlHp|NGUCsMp@I>Xm`v*5Jz
z%JL-lXS$sEuS2E{?u_pLF{0r%p$uNz;f{}V2F@ct+TV4TW|pfzuMF=RwCdcZz2ZDm
zk7YTs-yJ%Wjn`d+n``8dZbPqo#XYt)vRXL54+~VD@#Frb$l#oaFIdYhK%&e9I?i^#
z_WXUW`AtHq5*Sh*x$n6UB$)br4necD-=$bIhyPe?l`O<<vMkS#P9le@#MLbVG4HOW
z&ZwmVM{*5CV!EV4>h|2H!odrQ;xZ3@NIjds2@l1dHw0hoM3Ie>al5)Gf-uRV?MtZJ
zli_skYH!4b;6%M;&rW^5PL@sGB_i(KGqaxUtjfJ<?zw&xclf{6g^YA!&d!w0<5k-e
zB6QYjNe^DuZSF<(>x`Gu;{SO~C*dO*C@aljVbg80`5GNXvJKyZ-iu2qJikj(rqs@j
zzU^;#lk4P2^|)O~zGqX*^42`mxXMuMH=q2W4MUDYR`4Z(IfYTnI5`%Gz*F9&%<(s(
z>_xl?%p&gnj+<WJIO=KTWhfM>^(<*|IqUgH8U2ZsQp7lp1L3CBS^>@ZaViKLZ>Ab5
zWRn5ShfSc-4H=6a#)FAd7SoCDF)vau))$aSWKnVS@`A4oSeI}3iWlXyg=@Gccz;MG
zO3b^rEdO~V)$VXd2RASydi#q)-6e=W(dvs4D8wI6T$b;<g@Ex~a%kW-`0i2g_s@oe
z&qP?aeToB(m&tD*kAMdS+k9$)4e+#@nws?2yD~@(d^$W@C`4<$B=Pl26P==LfVA<v
zL6=gA=yWKJGV$Fuw!b3Z$l>5tVYAqkS0ok@(dkL@^O^(JRRcy^a*BD88IRhL7w^wY
zBTCTyakDw#XLf4QkS`3LMh!EC6hVS?vP5)jD`{COJ2I6RJXy!4K($2z-zcFyZ%XTZ
z0EWZ#+$V0p`(l<<_~C1Y{?YA@tnVmT`uO6|p9LaD7iPk}Mi6L3`D?U^eCf0o@k$4D
zh;R%-t7-SldlZ}n=!7!fin9&chiMQlva3?=Bx<Aph7a&4yS4P`YJ3Qq1pXIaXC2g5
zz_j}$1a~Mdfl}Pv9ZCf)?pE9(xCL*EwzRlYTnokBJp^|z?(T4T?|k?EbHDG-WX_q%
z%$dwdCcAr{efGCmjO-TO%p}DTD6oL<CSTLBm$(5JGP;<e`24y6J{r2#zNRnFVA#_m
zLA$;U#H$*h-mbQHx=?YIH5?5ghfEC1ybXlc*AObaEFYATdnJn6kboCNqWh{v@I)O~
zvN%8HKKOH>%P~`HV%I2=USMOPFCbFO)`J2ju-&j+a)d|_U>xzDzUUActQKoh(Gvp(
zm#$Nh%Sb<zVcz&mGJC4Fa&C}}|H9t9t%!PUkso^IZYnFR!HnH>_v^NU5D6B2-As(c
zLtZJ2KHJ<P2ir+`+SW1JKpnj3J#J!0c0u}(3W%{=)+FL3dpxK;H5Oocd}HVT)jeO#
zj|u3R)BhxcYhw9sq*>i@BB3<rD7hyC`5>7U1R`dct<EP1B1H?Aa24hT_yees1lq<+
zmbq-Ncwr-e<Ul?XHw%cDtau&pL*0H&V#Jgah!K!SGJE7%m^Lb55Q`1)@4VYQ1OJiz
z@i>1OqV3Z!fd7_1nTD*2ktmK&z}d;%=5L<_7)NHU611S%PzBxsm_7TYoyn>#+1ofh
zzM~WGibXvHsjjD<rrE;UpZzA7){a<9Afow_DXQ^6MYRvlYJvfz?HAXXpyRa&Uflb&
z7_Am8z!JpiW^MDOSFD}`1G>fonzlK!+83y2kTa%M9ix3zH50bWbT++NPa9OV@~ev6
zf95G6rsEUhfe4PCAM9H9FR3->SnhoOP1gFhpf=R0#{Lq&)E-R=!4AfVGN49=UD<t(
zP{g&v2Kb0=kC%^5Mr<3FNBa;)od!(u|NagyY+X?{lz#tQm&v&Y9ITZe>&r82#&KSz
zm{Z52SppOU{%!xPUI2nEI~1ICT?4ZsnFKuXXV0%brhkUh455A4n*hi7W9_slA{M_U
z5Z<@-j>*DCii|*gfQ7b|&Lm&vij{!c73HL-l_&WdwHN<MEaw&9?#cnG#^dRR?$2TL
zn_TJzpegETAM?Eu$Fi>Y=O|26zvjLlYu#ac{Byd+{0Ei~?dT(Juk|G+dJFv9tkWhH
zVCtow8YFLDByDYUki%L7bD5pHsk|pFd>gHONHc1XHz>JK+$pYM<mIT2q7tyK;-StV
zN#_4rywTZRNAfmesF82-w{u=0)kJM7OnE+|cibxjv=;YzfZ=xE`*37s(m%NS>G(Qf
zKtP5j9he1-UwPTo!`gzC<fmSDRBpR;7Kq(+X-GNl`Mj}DZc7LFyiNz$vw2+CGIG;@
z-xF>${);vJF4pOWh@*V3<@uBwV>~h?kNOpx<o2iE=?9eB#xt1BGcCMTv}NpjB$6%C
z#7UZYMSW8t3r>Hx{~u)0<AvaPqwGmkk>1r3)xlL5u4Qvig-MbGRa^kr`>LJVKgd>o
zPBFRkLrv~6mGKLf_Ww^edP$ulmF>p#fF)QAg{%}qO~p`+Ri2c)ekNJ0p!vJ4bKak7
zV#@P|8m2}8m%&dXO*8M0r!nFTrr9UspV|U_j6I!3t<4FMr_u>oOb(1A6N4sHnX*16
z-d|onuPL=SJCHJod?R0I3^*Ny>{hGv{)G*y73n+?XglGC@E`pJ(wO512-uNoSC^VR
zE}_1OQhO)kdoUZlF$-`rr?_%>ct|Q6ak)x-#O<qFSy`Iz2WB~#i?6i3Bu&4=z`JS)
z2yv)*lCSzTDxO$kRn&_d;{9z&?*)%1KR4$-vJC&h@Kllv^Zz#x`(Ry8C@=77q}D*V
zKqolpb}(2#wbtNG-si6aHH;jJ&P|J^J&o~u{w)gGs|hUEjGEx~{w<H7M(QgO6|o=H
z<A2(V{$reAM9xBABqh~i{ZLoLMHmt=KI1F)yQkc?NfGweXJikvY`b`#izRra{_DR9
z%@+=wgku{+z>em9-oDRm;N$h4RLh9_bD;I*k;2_Yf*PJ^8o5NP)rN1J<olYmw(^gG
z&za~P7pw`l$>ZjkJ6*Vzf9q9eS4RG(Qum;impmUnV<K;RU?WR>^4_9rxsFufZ~7Ns
za{EFk)xIXm+Rk`^ItL!GN(H)xV<4ixUX{DO<OQ|dL@Yq`I+e-(_#?BDN`*BRzz6xn
zGk#zn8`gs1-0?iR>?_&#{hw|IXU#NvnRGC~;=6pp!I3SyRleue)wIXRRe+BELfgTC
z<MDyx_OPXWL6eo9mb>RJ3vtbhtB#O4PH*M>OB6T`zyx>&tZG$5wtV|JG@{Q9pPCvH
zXk-fHp1&=Yr+xzv_uD9A04SNv%BXso;(VlR_f|m4+O7Q{r1ZE+bfEyy{>4qyYh$1X
zxRCk+_)E0xN-VfrE>N8?O~taX7a_95P%>485>A4~HCdYB0Jw7n(B`1<f~5=QjJy<8
zI|1MLVYWY&OTc~0&f`?<$?cMYz)r*V4qE99DLG-q%sy{rvZuF698j&!nK_IzB`#>i
z1I7+3q1HRIyHkQKbA6rH*~x4CMR~|)&<6BIhwLB9c>OwEvLNGPbZC8nI{VJ{-F82K
zk7_Uwp&g!#xVr}*QzQOx_n;2sph$@#WaIY9JDN;Ei0oM`t=-vMR1o65Xu4*s+UR!U
z4wdLJC=2&j+s`hcA@=kD1x|x@o&KQ6OQPRstrR$|dQWy+O{QC!ki{LDg1o3p-&n4?
zw2t&N)FYfFpolFyT{#dj_j1eOI8vjoCs&Jl)YVW}jO|Os^W;N)jV`4^2s3&EIAqkh
zzM=r{HxCD5#tO}fzTI9tt99d$)=2ULBctcE3d=<pCe$TIfHMhhoI~QcfjblxggWMp
zSNM&!GrRAUuKUb*SB~P8pY>RC)#l8^Gk??Fp=@mke@+h6$3Z9|8W+@LuDC1ekXH}c
zxkbAKbSEb-p<L17&K5u2nbR+1iE)@rA6037YfZMZ$u#Ot7Y*=De*$OgQrCT;RPBUi
zP~O3L#W$|E%LQMx%UNx6h={fc#HdLyV*exIx7uD&%;Qd<74PmSG-g2iXM0HkL<BZe
zD+8c`CzoXAEiDwZ+9z|Y1Q_cF)|}y@{-n^<HPaRSpz2&^@sFV}x6mv?=;Lx$#t?Jx
zCKSMcn%|+d5Cj~>mO2Kn^PgmFr+vDW43FKgU~{XCY$c89G1QZwWT@P?YRLxNOLACp
z+X+R~g<Y544t;jvHg-n<TL>kamp>M`G1`M6c9S%+v(cq1tsl$!f&DfjF^+FePR&pv
zp>o>Z2leN=`>iL70KWY->gg^hEZ}*F-hrmGda}!nTovxOx}iuYE>4=W@o-y+gwJ?S
zJH>`QOgL!TqWTXOVvpl;mB-P|OBvcOfOaW@78mFN(7R;B8=O9>AWT|yUvWk-r{6vY
zF3+_i)j~95gNx0l0%$i21D-%|d7V)+A{!CL=b>CBCO~5cluDd_*Vg@ZmuoSCJ9t-;
z+zru@ahOrDC4^QEBf_!zdLehRT;mA+)2f26n32oer@f0Y9eLNDy-Y3s3~8iR#vg=M
zjf|6Y;8u8?1jrUVqsDSo|Awpg_`Fc3t0acb7B4fYtyv{KeNP;jLRf;HR{U#%Bhr|q
zq(|<W!524|;MFJ`*%7AGI;*)hjoHqKO!!*I>xEJKMHXda_OcV@`la7}Tk=o7liQf$
z<stxo;08(f>4u;v_jrfvuetX5PV%E=y{$*#0ia6grtmvn6+AucO12V@8*WLHBub#p
zqoPx*<n884ta%zQs;(EL!WAa3Me(Jot#-;DM2|z7lws71TDK0x$F%`m^k7om%ptE|
zKw(cKlFJ?Gs1&oG(;`E^c-M8pKv~aA3qlhErp1(eO^Sd!?YelK(zkd*o-Yn9_qAgu
z=MzU)?6&*B)=A3W+BYT^|3s}6DvtP+5O-E2AD}5l6M!92V+uga^W~71n$#;iWI5n}
zb21V@Rz?Sui6m-TJ*hRFM{iu7Tz$ksmJ}p+&-fbn@Ha`wAvbK|M>0BQ5`_WdRu;_q
z$W(~zm;^4pkOS4yeA#5#7C=3-EL71kc%HU*el((x_T&B|+i+QyGFO2kqSY6~Q*Jtn
zyO`A^rH}T2g>}7}er?p3XSYF0PDO)I?Hn0}tX?JJo~~Y*E02(_aKgkF`0`RnigPsR
zc1oA|Z3Ep2MIo1Mw(08K$x)JFQs?hB$o2Y;A)a*nQO41iTAx!W=7a58mel&t0ZX6u
z<=W5y{yArmt^rL`-qWzyNKU^8=NrS6`)W;1KNX$5w1j$iVr8BpFj+}C_X7z-u9)On
zWyLNdA)7Ml0p*P;UA@B=-{Q*(W@hJ?HM2hYPu*cO6vn*^iyo~s(9X`rwv>UK4}wEH
zvGgl6kxVC@ukZkOx<G49$z)Tv`c(|@T0Uz=1h1XYF39E@k=?&9^~KTOT?EmyZG|66
zUkTqG{DpZ@@)r%Tl#!x<oHeD<_MHLn_(I58z(JSNPX%1igAhp0QzW>6EMtY0rso=T
zslc~@yN@F8RyrSsQ#>U3kBk`XNQTQ<N$dTvogO(Wx||B^PMw}{*;X3Dgd6wi&kqGz
zmS~q&@TDQfwXso`roj^*ufwQLQdkSOb~8v9<m@d7StIv#jNTLE57N9RF-6AT^~*+A
z4#W#uHWe|r9&;$AkcGk{eZGuqqNBX|p+{;L+B?Z6a2`r*{yzA9sP5q5n2kz4q23C%
z)V|43f$^{#26SnTa{)!GaJx$+6Lac7Y_A~PffFD;1<oo^2EeF~&(<1Qqu&N#LPqlb
zB(d03R(*G>wa~gWqN49iX|M-2yr$(biZe}X!2EaW^1%UwXlp0|ScA^64&>>#$AH$5
z0K|(jG>WrK_M$BBHk93;`!C?a0$LyPkPtxREq>t6M{w4!^J^C*1TQ$t3QdaBuM7ay
zKvGfYf`%y(aw-0H;nnIU&lJ4UCr=~7xMYzoB3KI9Whg`W?A+&rshWqx9Hfn0=qNr8
z+~JJZEUndVt3xfn6B!l|qErs`qYiDM#9H@!z2nh2<Pbp8=6l$ks`FGup`*9ZZN<wx
z%ov&Cd-wFmL2|&YR8kP&H3+btGX9)1Q5207)$9nqc_6zQL!RFVjYYb9gwA5QrbfW8
zVpxDPBVb2Ky)JvU5K`8%E0>}I)c@R)1ptu?J`cR`VZ0Lp(D1f}){tgj99+RtuF}*h
zG||9>cNYHT!a0O73;Nr2kjsbtvinXqBt&ThKR^##&il&8izD~MOk#9mY-xaJ^SmDa
zv;p7D2<?PyW%O)o!xLiY>VL&@W|Q!Tj337QmAUpf9#!lZLj3Y0Ij_0*p|}nL(|Lu&
z?2)pjq~gD$<M7b}{J%1tYNg#D0<sj8-#4a|aa?_u<CX#3qH6C3+jE$0Qd2$XCQ9(Q
zzka7Z1IfIm(HUA>E7Miva576ctp7aq!jX>E!ksxRY?{2y<)jB3+Jg`;r9eg1Qg==f
zd)ZkwV299NP&{xzVh_LX)USil3tnn+?w(^+NuphjvwrZ7)Su0b8vajJInS$Y+wEQ?
zlT%35#x#I%pIf5t^Ar|d-#w)h0I{JRemZ2FA>EeAtK{dAiX<+q%BLo~{^H0MzMT1{
zTc$+y(GBlg#Yd$0SR~k!1tILI3kZM?+2{dwaxE=|jsB<b*eZ?T7Xq-pY=p(}u30iF
z8BwOap6%J)Uc_O2W?Qrj`sLpy5De1-wOH~NXla*Hw%M6D5}x_%Eq{TAxf~4&M@8Z0
z2L8sy_Q>E+<S@HBWy?PrrNRGrgtI=dm|a_Onj^cS`7F4I-#K><rt-?@s7CVBwd!17
z<gtW|n4cZJ5tvzkSKpU5O>2Bf5g8$Q<{!t?>}?t*QIQvkBHC&HSs<$--6B`erS?7j
zJAdbxb%V^l%XoT?CvsWYPFt;)<t2;#_4wk62B6W%9JTnX`h<wdCMLeFQ8Nf6)#f$Q
z7Q>su=GUPDL)i20H58=f!AZ&o*?)w*KpROkS{NdkXfP<1fWWNGm%$Wwfn@edyqrIJ
z_78NbvNZEY=yZ5E*(HMDx}q<4C=0r2DLx4&!LE23{8J^L^k1T}(Q@-5B3fBl)^8K?
z1Z-)6j-@;^c2frgjkfCib~E2%wyB`Z5;nY<6XZTUe-3?;4%SUxdCh$(Eb%n-DuI|_
z<RP~m4;4fw=)4v291U{@BjvZfmKCg!d_H1jD|NOETCL-TZt^VO_HZpm(<?qr1oo|`
zi|XV>Yv-4eH)!3UI+?7BJ`;t|K{25L!3UirH>&`^{J-X4X=JJAdkQqfFICj6HnUa+
zK)Rj6fyNExY&Uac%NUx-j-M#cWHd10t0M?SLWCt{NdBjrZev%zkQ9y5jE1thO2G(a
zK?>Y8<<=mfZDy|A17$V#EtvxKib__as1(xx3W@Zd&sU@@G#2~bU7rtV%o)S9N?$~}
zg4BeSA?cjsy76-E@{Gk~1@VUSKx-?B=vayL>}q3zA^QnZ96Qt=S4k=Ns+V#ZLI4w(
zlYzF=3wfsFL<!_?hV(&OeXDqLIA6(+GNteBAnx)7qd&341m?<a=3;k}ewNLc`O|=W
zW}US_{9#w=;qFSLYlBAc+gL^u&iHoWf;+$muzk1NECjcDDGW3H-fqi_0Bu*tfJAjm
z6f!XN>DX)X)pS?tse;--;_WddyH%Y_u~Hm`QR4-`1)|$KDlENzQD>8;hqR*^Ozm_Q
zQ24q)c=RpTpx?D@aN^*1w?hsp;mj_ePw_6`@iU-N-3>;4Hf3U%(LH{KBB8@<MmsUA
zhM`zn{IHT8G|-|fGZfGA?6f|i#7mWx>vgzC`W9pfW!U}$zrQ)&=1F=lUa)b<0Z5tX
zTNok-h<~iy8`2=MQ$fm#2GgUJp(u(_QJVC0<VbfmnO2aj0jTWgXe)(shB|$m>0+*(
zD%MZ+h;1Y&4zIKYK%$+Dz@6<9!O19OEjdw9t^jY4RhK}NmR6k3O1l$v0oQ<Ec3tG8
ze^;sKg0iBC*j}fd0G#G6Y#AW+>*L<(n$_K{y}(rqzQ?5<4PUl)8)VD`PaKGfg5>_H
z?gtc{K8;d5OuYY&j7~6xU=MI1M0KqTY1|!5UhJ+oa<FdSYdy_7uOC?NGl8V{IboT=
zR$UxCeq0}7Ke)Gq%5MaGNVH8_+&O;9EYR1G^(>KV@&({ajh+cV6{#$FqrS$!e@Zc$
z(WXfJE5?-lIq><C`eGJ+Ya&Q{b7)l9cZ}tjnX%!ZmGh0a@jHQI%zM!wNDZ~)?p(7q
zvW)1<gztu#Xw)s;!FA>0*jMp`Y|+0I0&uxsNf~b{DY~rw5NPSamzp$vUy6Dvt98Xs
zY8S=#tR2&WNtxe<RoYsI9=d_jcaN%@`k0+m=|XM+GDumRd^>;Jx`2)4OEaR*EaRF(
z$JARJIL&SjfEJGFw)1M84Vv%1_ME=KMh{t;?$Dq^TF`#1Fx}fIhgv^br)>{UPs$?d
z>9Yp9VEid~L$9BssF_6I(VfaDZaHA>7zk%-5Ar*fKQFZUbTgsUl3v;4lakRgZ+4Bc
zX6|d2BMHmI;Wrt|JKY}Lb`E6D8+rA^saDn_F*f&aYEtHnvh<MVLDRNAiUT6u=aZ(P
z9V(x1${+EsxI`1VlEw%t01@wyCsU|VO8o_{hgsYxsiA#c<z7KD&?;fT-Ucbt%&+we
zbDbv~T-mc7`8reWY)>~&N_%Gu5ZAT$x$55Z^kQRi)AV6vB~vyw{^;!ZnJC_K>tyT`
z`bYiIX^=-vS~Bi7phXp@OV9_Kgwu25cqN}%)`tr65IgF!4aXp6#kS|q%w06}->JVK
zM$PkBW86SaGA~I%x;XTw%2N7*6>GBIw9<Er4=LA!&~XdKKA%P)FQ(3oA8n2nr}{kS
z-5E?4BrDh=$t6qk(`Co^hr25OH<kT=mHQd$L4?4piVFkBtF}UA{+gZ4g>;^Um5UY6
zXFE!ZgQ?b5UndWSAEkK}+|MjoUvYhq1TNnCk?y=^YERUWXv0<Zs9iV!+sy)<)J(GW
zF8&m%Z2AoIk}}%hHXouE#KzDsVa2aC?S39#jZ9@LfWR4ez^FV>WqzY*ek3ujMR7)3
zN5qDi=lFZZe<6YgVX?~PziZW0k4nW<eAvT2O$*`T`VI>Jg|lsbQ@Wq<Df`g=ePVq4
zv_>z#ghiC9ZkCp8TVoKD)rIYktSkQj+`hHYRFE4<o2DuNM7ZYaF!z}4r0&bVVG4uy
z;*M4sy1|G6^Kl2=638$K?%mkyZZ@bbB2??@f@SmTnw>?$bD@f+aayM!pGs8Q0~1Et
zTVyaSKmwqrsne_Y$}&K(M1b7X+Osg8vrz&6a$zip|J9GQRv(e@XgMR#P_gK*fnS7P
zG8+f^N(!A6>=s+`VO`Q3rcS2d7AWU>h6%5C&EzmUEoeT`bkGqDCZByUMiYn_i)=Ho
zOXzzx66US2<6`n>ZpZ}Xt-NM>Y|9Sp4~bc9v(37QfQWUji%?xZth^MVZQ><B1n=|t
zbN6`qf{yacAI(ovDcC`4f?Q|*AVjVjmcB&q^y2nQNSrwWIP3-wlv8FI_bogJ0sguX
z+O<8e{Bhl8$e+1F$|4h6SYyD!s3e$nLx_*bdMe>&+KEX(WWLihqRV=Efbp=K)@ml)
z|0ovH$evh;$5=GVj4GCyu*0R1EHG_}l~a#g5H?GB4P~e@V&$U2a5zoZ2?6+Tr^TiT
z6CC4DO-B3tnaFL5yaXK{o3h4t;r2h8J!kS91-LK)fGV=obylQ_<y|(8)XKlf6V#w&
zjzH42)@mVz)$1lh`Xscohs~|m1+LrGWVByBA|?xL{QPJ}C*T+VR$i2UKN?sYSzVXm
z;Oc~m)oC2y0$#MeAS=w`Rp)p{Rg!Ud>N|b80m^#(j)N6LI868MBE>r$Py&=<l}d?p
z<?+N{rhDNE+p+aQ!G^8pXzCyJ>*LScm+*T%mk*>T_1-?fUlD6n*Bj%s&k%LuI?Cys
z|2jDUTrj;20V@dOy$2%NGDitaw3I7Kvr8S5b`*UqrGjRuLL)wYS@MnAmFEY*TKIyP
z;D#DArhV4Y%G2Piz>jhIz^41)GQGn42e)@p?oRLa*1ovY-v`-KzH!=S@}}6=Nn`|Q
z*Hh%CQ#VhH8dfngS=}lOF_+@w@leWMhkN$3vpYZN?qg5Q$y7FkAUVJ@`x*+7NZ7eQ
zquD>Dz-wd8Z}T&XpL@T>z?BV}<y1vJEU^xO8wF2Tkr92^s&{dx%hy~>CQ>7xEvxqe
zahf6=7o@SOjt`>0;yv`6r(dpPp@uJ-wbYMo^%o%_w)p^e>?#;NuYxpj(7gMBlq{JC
zJu@jLyucknr?d{V4$GNAJ}a5oc1YqvyQLlB&j9}~Sx}<r+xNq)sy@*)l7<mAo0YdE
z$Y!3a`W3ilaWn!6`G5LPo|}t11DCVe?lJs!qMME}IjLb<4!+g4T_>aPX4ATHi>0k~
znsP1%_+{>lVT7ne0dP0aVAzzSY=-ra<iQWXrw;>L<RY01&1`nm<qA)ttv(->5Q*sx
z(F`5MR85Z-4ZbJgaFOcJ(ZFUh5zf{xbA<&o547Tgu8{l-=nZwtl?0$3?yC>-<gQ@0
zoe{R|_9Bs20EcRQm#&gQC4#n=HuxQkSMubonnk)PR+`W!@zP(onlXia?!QL&x!6xy
zU1$BCUR0zEI!cLYdfO}wV}RsA0T9Cq?QUlX8K?A}Y5HNlL3M>*USQv<u41MCr4i#j
zJozbb6)<?us{if?kms2gO9w#Ax0CZ)rT=a3X!XTB9=~L<;#|!VbFCO5)17y_d|v^1
zyfyoEYhP_5GiARmO2U}QextDM8Hk85u_9FyiTCt$ZMQ(kUwbYy7DHQ9^1pu;)=y@9
z)m;B|HxEmI7iyMI89~KiR#i!5X70N)&J=LgX4Ikj<yh1)Ab75+`evz%eYp3!LVI3)
zwGeROM+>kzmIomoZz7KGSBIR|<DZWS7u%{s4UyP<g{`-H>(Hb;*YCSZGqn;=QUjaA
zS^$5)WuvcU<EQx^`_>EX_3d9VzuDeCeSQi6dKOHmcvCO?hZP6*^pbIw@(ov3dZ->p
z4AO6@lbaUiOt48b;r`(NpL3G(chCv|kYdP}#xONd#4pQ1=p%y@<#EfsNYpOH_vIZd
zi-#5%F;S${Wxa*TF$JuM_0gWlI>ME*Q@xNtx4H5)E%1#B%VcPLKjZ4Hp=ExcI*K1|
znV4SXY0a+mTBq#zrucEOb-5L(OW+(iC^@bs-I2;N7z5j5XPQS?W7?}#(Fhl+BBZyo
zu&sVp`1}e`W?*!ytxdzXp;w|M6vjhE<_cAyX>NIUy(iqrGh8|@&Y>n1>~#B$$Q?9g
zQx3H?S~!Z`LiZlDG~i3Bs=1u2wFB@?{MiI3%{czwXRFPq92nDyEej3c!VQG*tqQW$
zNLt16pyh+&i&IHp`3k5hIjtT&T9n#5Bgn3W4kE|J3q;qjK~i;$up^yqNd31Ur)Ng2
z^h3G>?&$G5B)`i<&Pt({cb*$OEGg!s3qzEP)^7MRW#{yc0wFBMThlu}+eb~|%XLq@
z;qbBOS~rwm(Y`llxS1v{uE4oZRGOf8;u)I8UgN$n$m1)jHI`D$XSsL#Zhq3JEmKOI
zR6XT{I<4R8o{so$gro2FAWxiZOD#PDZos18=<Oq^pIKK8kVge9oLhw9EvrC*!~zK{
zydi{hhcoAS+`ah{(kjm=Cj)>ydX_G>eC=~fBW~RNQe3mVKrt!$hDZ0HQfTMz`-qFy
z4#x{@sC79!9iJpK0_~DtsGmDt+TI44*Arr%(0)S+-1@l|XZvYX2CTl@NxHlL7Po*8
zLjEPIE)}QHv~x^LWV%TD#~=PuB^C2;>hD(4hfE&<Ts8`mM*TA$fcc)H5u(ByXW_5>
z5}X#E;<3A<GPXap(*yaRrYn6+&X}C}f+5B@G;&<W?{E<00Frh*_Xl`%z(qqb6I{{M
zML1@3ot|ymj=j>vs%m}_==B<jbRT=&H`n9F&Rfi<K9mf!jTwfK?T(|T$$NI<t=VC&
zB>`#F;nVOHA6@xqdxgW|I2qE1az@EbG@=YS2$D#nKwI11Hbm2KtAE^NqvoXN8gfl!
zu+9dn#r_=W`*0ZbA_FGcQIa}G`A}<x=OQ7XHUAz}kYsjEd}17r1sC6oBr%-mHzG-_
zv!TgvVG_D~MEr!~Kdg$KyNE}6gAlPKFI~nvETA-|jQ)^Lf!k4LzIqZvdnrIPzU$+4
zpHZ5r#M2dN`fiD?;&MjEB#){7yuDTnGz~)4MJnBGw~S>Aj+FFn4k~gNnc<Bk(Xph!
z_@Qx|=Fk7R&xA2aePeZp9j>gobv*B?BUO_eM;<zm%y0k>q{OH(YkT+I|8?5Kx7)bt
zQ11umJmj~VH$ak<w)?Hst%_u7Pi_J1K4OINRm|i2QGF*SEB)yyI<RPye?5M`4NhTT
zL)*83ORUR(Y{sE)*h4pbe{JlC(Vo<Tjm@Y(9?0H3Qc80zTg6zYJz7&1=3iXskRPyr
z;*Bc0Sf?TXCAq8WNJlF9(gyG>_sHq`B$Wog;f3Bk+CusqH3Qvom`$c4JwtS{bsoEx
zUb5T3_*AB8$zXLd(FN|5a%FD(jQ8yz>D%2eONoYgAx>C<87ig>x|UD>GD?rrm$^3Z
zdzwgcz9eDJ{+2zDa>Xf-Jx}2t|5te%=~K;>lWMYOm-v>8;BO9VUHBWSI>~jD&^Zl!
zWXmcHel_pK92%2a-B&a=#Xr$AG{4i+7M-ol{CRmcYeoa4SVTHtQCQ`;ih8%Ojq<}q
z3KU6M_MSer3=dO;8+8Q`1`i0AmL5{;jFtDCgAg9LR4~zSuR!co-w<peA-wHseN3<J
zRyhB1#2ICCequbw%iO^S1$WHG^GF?wm2w=Z>d~LO^X|6en&KqMb4QUm&j-RHS`%|i
z8KEJd(UjMEO(t3IV5zr9b;SYsMPV$A#f}p(<}EJ2ed^(7`DemI3sbCgq}ce>D`pbg
zfGAv&iQ#Sf=>i`KZT|yeoL)~J$6`ohyFf!R$;Azy`jzS>B(i#FG>GMqbRTmq!fKbN
zbYAItn|tJHg)Kcap3=#L$IZm-O>j1EZnKlHOGk!`qZ?scQ+57mWycp%p@X9{7cW5L
z6o*xte?=@W)(KWv8N2--_Lc#k<dOD7GaJJ`(@f5kW1ItO@&@QQdSe7q14<)eg-`}}
z0T3XVsb*_2@>Qat@k>LI=Hfp<20ac`EtV-F;r%9KHN-zn`aJz*>$sc0hnyhwYl-SF
z*KPAzU1C<f%&au&DCCwj|Az&z8FXlqntsiJ!=iavnapvqNswMB%+yD4Bp+IhYuM;4
zgt{}wE?7z{5^GG|z4G)IqUMI;*7p1=_K0Ks>Md{|SyNmDkBq##yKbdp^DC31oO(Ye
zn>FB~OdJQ{Q;U9qYx?i-+S!FI)Kj*kpD^iZdqrvE=+#0vo4##0_0r8-|60diqGxFm
zc%7RYtLqsOV4?l|(e4g;O0K5Xs;`sNPrRT5G^y5apqFeygYo76Jvp<y62gD!GuIsf
z%4EC!ZaX9xrsj$+yREAVm33;A7K+^mY$;NnNf+k$|GJ$6S9TwU6CcEZtmT*Y+!FmU
z@D2$%f4{LYrax|FppPveLSwe18v-R?`BI}$Yp2XPD*NUzN6BB(=SO0!*MB^&+aK>J
zLbLAYUI?@n>FFwhZBp*;$*O;R?6RNck$6FK%dN&I^G3b6gDt-}6-t*{oZGHM?9-Q0
zLfn$KnHL+s?)9eN7Y4K*W?e5WtFGCWzuHrO)J2%|K||8J_!|KlH@d5szr92v!;qC}
zh1z0L-Jqf$3S-<F_bcsGRm!M3>iiw#vu}Iire{a$`RKCJ*U$kDh0v-@kW^;rldH!|
z(c$I(pRP<j&>F|_oI!0vqw4wyUvcw*LcvGPXRs>eWjX*ohde$s^z}BL*gYneadUrB
zlQ8c$Z=|6*$<D!l=4@kzeCgS~zmk!tgcm--PST5h$a<XNOGkiBk!tf~H%>BdMWYN_
zL-z&KoTn1GugC6ne1yKf><&Mu@#tK57P({KSbw0%b)M0#JRN(EmKWiXOk0w9y}?*1
z7PA~V<FWy1RS>F&bsh$G&p&dyTz8<XKP>IF1-C{zt=D8W_Z1BQoz6IQ8lDGUB<duk
z6YdLx<{-hR$Jm`_#fYlD=h6sIU!r|5sHOm2Acw-wam>=fI`M5;wUQGL;oTOd9|_fr
z0aRZ-@F@$DUCt%4Q$O7W%&wKe(2uXH<ZAj>kua#^qy#L>Kt`jOM+2M)F|N7PEud74
zeyo2hTpNbQ7=~X-vi5G&)H{F(vbfyc?Bf=Qk+Ae%RtG0evvBoRCp=JpO~_}k^Iqu2
z$IwcQhZ3$)rk7QB^)FI+>E|<B<?qLfq`i2I$1bI#<`(pCxxT2f6ciS0Tk|^9LB5V?
zk(g3TG+hy-wN8csgTGzgh)fIqs8@JrmmK3Iyk*Y7M|HVleZ-)%O<!-!X6hk4@}NC#
zkb@mKwgK{vN$F+~Y13<2N})SZsQ@EvSj={xD1*9`7F7}}l?ydHcIN4XRV>8_sfl1l
zOn4dMZ^dy-x=sNI*n~6M@##iOInVGMSmJl&YL_OCW1)^oHlgJ)0*?Vrs%>hN$3W41
z?@CteCIztbm71in*hWNcqQlb`J06@cJydG7Bz<v->x|b(L4t(*bK<?9pB;K^a>UI0
zWKHx^Z&4KV*Wss2ri`7?Vk1Mn9x<z$l=(NWh8|RTxes?f?9lP`phNHkEYNSaPvabW
zPW^ZzAjGN;48ND&qkfR7l`ha6ijTI%-=E{5-4{XC7<-h!lbHdazQG&!q3di+RxXAV
z1`)ABC#_msA8J<C_OK&BqN3=w*I}nE_@baoG0XhKnjpezC<PoAqVo_6_vx&6NvI?=
z&(J{9MSBPs1d_4#$*m{b<A}uh;=77E_jZX?sCD#e0e8)QsfvF8C<?5np{f!7*db~T
zeZxp9>1IU`Uy4fo&-M!;#$rR^1NEMGhzqD><*=;N=-o#A!bh;y9AgjPAT#XK5`}k?
z$R|`$cC=7BQqtUb3DgsVOJW`6@%oVmVX9HHmVS|`fgte~f1#3qV+QNY4M33S1b9K1
zCIlS#VXnG(6LA}9LUup>(7|=5Af%cVkCWcPV-I$Oj8vF1By@bL1qo=QExHn;fPT<6
z<~Ax3%~rX5=9#2dSEw4n*N>eXdtUN4_ImldB)BjzQJjb*q3)vCna{o7{66$6j=3br
zD(%<kfJm<BH@oeou|pI3KVnLZYosrVw23r&&FEP(;BVM9ZE786E*s-Y+dFeCb>L9!
z7TTcWIyI^rJ%zH6pFQe@`<gyUvWh=6M;X80U>*V7@k)NV%=?BfujH!>&g*_x*YZ>o
zPZGpoHJybk?Wpc!amhpyWBVg*dLM}{iG3m$;lWYvbeFx38m{It%IMjHy?N^vd&j5#
z)s97SDi2<r=`-O4Hm%NIe1CUNl4cc*I(UZ6ShO7}>V4|(M(y3)R&yk>)|wK90ddNc
zJ-_Hd7wC&dLle3g{);$}j!Pzv*vqWUHeYp0p^t_ElDX|C>l_7ZOPd=ffWK3lA*_=j
zwD8Ik<u=r{w>T7-Zb_T=EY~|;5MC6Tqxd?Nsr(JE*42AFi>(~X^05rgN#1bn5rYkd
zBnJMaW<huG2%7%*>_0``%!e=$_DYA2!N-#>Hw|%nSubaR)rvnMNw27j_>TzwnxF;a
zVY46A3L}47z8Ag7SDV3%g_iBRu)bk2%2augUZ6hra+8?20w~K$pse&Mhcun^W#(y%
zAe@dZ%nwK3k1IlQY0XU|c(aSJxBZ4``EiZkKxF6%+ZXFkU$qK2OWg2rr}a#r<G}G@
z#{ggJD&pbR6W9583}xC|Wwbb`jm>UwAo=<DYIBT-bcmuEDlZv=dE6Sw+f^FkVAsz9
zU$4G)GPiW3Lf;$J&u9Ceaw-i*nk}+29!zVMSJbnfbansgqo041k3+VIMKr&I)zf(?
z;4j9gZF#3T>$&{P2Pj>vcAB7y(3yJtt=`~Gly2##z9A_1%3jSH&Dq*vv-1<P>S;^v
zS%XvUuQt<Lx#%wkx>m-H#t^aN0Fsz&wbnP>xy^rJiwcme#`;;TL{oC@$pF*)P^+{L
z&-T<=5`SY9g3<kwcf9u(DzCAvTXg6>R5v9aF^h*-7a}Bf#pazJB3v|;DfQ~Xb-(t3
zEA5Dy81=w&i`+SRMm~@EEgNw{IzHD}WvAnbJd+>ln_C|QL@*G{<>F5Z+=$kioUw<T
z{l*sc{S!+SzjN6IX~2#{y7F1-i;u9VHBJAeH)=$W+)4)cyF5K%HKBS42GM+{hQ=Do
zSj7RL7Swa#baN~9*>?m~pQ_a=T~yVv!JVmEsS?N~Q*xie+omQziazDnK+t59=af%F
z8}Y~}&Ao7-x`I2fhM4<Utv|%M`h>hu<nvc7Y#^!Q%x}b=oU}XpJHnpGi7Ub?fMg@X
zBAd_VtWa8|*Qq6VEbi@FrbgMKHp#c<ht-_l4Rqxb+Vw`J`ZiYHtUiz%-CqgIbz%P`
zKBjGH4fiUA5iALcw`}uU*Edyv`|v<(DRDzY3=!}BkP~eGJ*%_<b&OZr<%zLPN~Mir
z`GBOqOwrWV7HNQ8bOB+7N8JkJbuzGc7(Ds?3h=o5^kS<kxI8Ie>r@F0r`B`x!L0jk
zoZ7MY8EasKJs}9=TLWJe<!4<QQhB2<3s*B%zN`y3P{RcegUE50GNb@E>Y88gyU_v`
zjhX4-bA}mznE+$&>lr5BM|5;>KyQ`Mrfxp@nG<G8z9TRb4gjCLKNa4odjUa__KuDU
zp$q)FIg@~s*}KlZ)?9!m^9j+^8ZjjGCHp3zwf!!^;X{+cg-`&>L=!we)eS)bRMC~K
zEEB(?rN;dmFUu`HmX_=Y4J3QkqM=#tE|=o2R(@x6&8?=38rt4*rOsnzpe<wR7!4D$
z+M(srP<?M%Bkf!0$t7+d+Fx5$FB;$e>6?_qd9RBo8TIe`YDYo*0|DW#(3RIWS9!{y
zcf(!#6z|^fCe6L}dRx#ULIrT^sS-GBaNSgQZ<wNxky3IPW!?`&$gT<|cHSGinjGyB
ze`@B&yInQHxqy1E&(~CwzRbS-$B$@#ACV_!ofA;%Be8#3d+ccd`1`9pg>gJ~%u$3D
zR~YZJL}uoK$<j~ye?6#<5vbqG9kB@Hnh;9bUVHp*_xRM~?pMk&?ab#>p39#fEiC5R
zc*Bq-W>z>+SLw1YLny#OYMqlx)8e7M#ENQizQH%AQ#21?+v7liE}PwIozk&Ce+mel
z++h7)v8Ys2SS-+*v<;Jxnlb_b)`JRXU!fj<FyH*|`*Q}fQcj5g%Dw}JY=x~+@*w^a
z#^3;)Vy}HRQ%%m;>?YT6UVZj)em;4$8cPN?i@GlPce+8@)CrkhKA6Vko0T8pRP=GM
z3-=;Kmn5bgz#NZ`Q6j7<vQ}co(lG$GmS^3-Pb#+4Yuvega)O&T3=->7iOjWvRn0M7
zA-adc-8zy6Egclp9m<VYo)M>44O~8&w;$fbeb}y)tE`t|RE!Y(V%`3Aj3!lkm_$96
zguBOgi%+^pj>5~nd&^r=$%Dk|9nCQD#k%ceIF0m-MtOfLU2o83LRec9Su96ee0e{#
z@J*6mEY9@=cqI|--mzwB)_&w6AiVv;GigP3izk72oic9p0Zw5W^XOgk1EcM?^yzJJ
zfH~9$3GJ%Tm7w>M8WniYL$J^C{7Of;J~p1qOd)jlLxeH!G5+LUbwo+hy5ei}a8pt#
z2sLc_mmAm9lQqODht6yHSSBJ`Rqypckj8M=WcvHuk$2m__X`ubvTA-P@YfDsxsc<I
zgF6?T3`SFF2EBhdSQSjf#KpE}cjZqdIaWYAjsmbk)9Me*Zs`F}1214O`@|ArjX$OH
zlx!vR3CMXx_l1{S`wa0BhwQlUSOTvLow0sr6L7~3<vqC_pHXGi5yrhZ=~@=Less0*
z@MyL2`&FC;Lkhj%B%z}Sq(Gtg%s!it)Ga(5M*efx+DIJEW$LO<HRe^|go{f^-+61M
z`iZexTa3n^-uV$_>hV~k{JzU`!yURPySXUZp5)_vG^v6;0b+Wbt94iftE}3E$Pnd8
zP3Rmkz;F_Uo!R;3^Mt$S+sew(X?zWw{<ID=HW)9yR&!brCzXoH+SnUvPQsfv&P`(p
znXiQWC@(AHm2W#Z#53FA(%kqj=Ka)Lzw{7ISFmF8*zOZnt@cjwQ1fLRQtjlU%vAP5
z8KP?{kRNoxP?EY!++j!fNQ$$7zvf@mt&43X%qsokx);TY9t~McsOw>~cr(t(tg+m2
zomb?fe9Hsrst;MpsqUlb>3OvTQ~)hh(g$`QNpX|J_2?RKKj>MoV`D6uu^s7QwY%)d
zm|iv4Yq8ugMCO^GUHkW{Q|-9A{2k+KD^3&pX2@~c^&jeTnwI+TSs#ocd#A#Gbtk%g
z@?B{r-742sGRM5vm5uc=q9v44|MnyZ0OBnj>;2LR>0OWY4~H|(mWYt2UUCfE)md5i
zr}!=LIWj4QKwOS0D$#ibZTF8@c1nP|D<BTy$^;dZhHtm-2WbsliYSZ@p*$M<lfm2D
z?G^Zbyq}@(&LQ#;CZrHV92F#9cF^M!T-N$@I^?zQ6d3c7kczZs__eS%?(>}r#P)iN
zbboB(^ykdCzkc}ty@m3n(P|P4VgyMU=OFQYPa@{BgH`wfUsm|u4PibS*Erm#wkpII
z@_T6ep3qyDspZP5Mmy^A8&IQ-H-xAwSLH70!B1n=`w~8qpOoecYI4}>)st)H25Rox
zPJJ<Ey}7~`Rd(7v3cv4N5Q!UpWPzsk2R@+}+d)4IbP9lMsb(I=^_-3ndMn$W>^N!P
zY9h9qu2Ag#Y_b#1247<s`}dxg@ve_JN5vv-j8IKEJxqjXu4pPS%n-dQGqG;f5nM?3
zlO7njn-!L5O71asQd)ykijK#(YpGFv>`U7co>y^@Go7(=W0XzU%5L)D*4hJS7Avao
z8XqhOQ>Ffjp{;86`cD(}G-ZfP9;miDrLj7Nnl+`AfumwC%Va%ZOOIBZHZGICLr$jf
z696sj6!^pvt^jraHuk6_{l&KUm<NcqiMRK9@gSS^XJ&im`wr(&y`QorDH+qBUB=6z
zaQ=R0^0{kVE09g&7maw6jkvG&n^QPZY5Cyj#NArj@G_76s1EP886Sy3YfiTs^FKmq
zj8GVp6&hE`8XWA1u?+jAwOg(~FZWU}_}>BZC7Q#cdo)Lo>n%@DZj?cOggXUpTE{zF
z(&941;OyaH>5Ke{GgaXxX|!7o0ZWL<9URHNv{#MBS+fWqkrkg^U<Wcx40xM3;6_TD
zw0VtJPP?f0`klr<*ig!^qlxT~&ccIVrX}9`-ML}IGBR~1I#=KYgQqdu$Ch5&0Z~D2
zEMg=euy6_V*w&fl7=>W=vsnJq1!}1>?<gUThGU9~QOf3@&H8-Gkhu)45KIi+SD5m(
zo4YSOvin)W-(T@^<QrrrYDVO>RSKf<KDB(o2$}*feZd4TD0fw1r$F&wS7R=7GX3F~
zsGOC<sIeZyzok`+)fCNK(xo<Xm4+RX)y|+MJF@`myf$Q`K-eWwx-<H^;Tt?scioF1
zD$3B3lO-LouL`)kGRmm;{KywmM3t7=)1e(Z%}X=*?LtekO=uOurJ-_UY!MefNONR4
zGOdPsD6_qSM=6+Jz6gVOjw5n3R|A^S?-NOQ8O2?>lt2BB>>+Qxm5^|FsTR@gN-m0c
z#0Nvw1PE^Ye#CewsZK*R03uxv-v1H6BVIbXN?MH4=>Q+muKJe{s~imFVkov-gB^kH
zh0j7oF@I~m#PTJ7qpedmts{xwT{c^GfULPu0(y<)7~Vr6q3#2jB^i@B<$?e=s%exC
z!Qio>p^_vzKam05-|NU!_7&Ae+-`%OZKDdL-$Pi@sIVi1k((nCwR^@{h+>X%-pmpK
z8QRoriVYEBbDPC%^ITWK$pktO0tbY6vc?4t;&FHik8RX+<m`!ge6rqDY=SsvfkxXJ
z%Hf&aNH`|5G~9W`@GBqr*h#e~af23Vm5(vBba)Ufv$&%gSvARUKP~WFpqZK`M(%Gc
zWR{-SAN0{n5p!opt{9QvU|z7nR94D{j^cqJPgC$tUha1E8XihWC^i`|H7u(rWkj*0
z$qTXxivex?Q4~MM3pL1h^N%@k6V0@+45(`a?U)Ay`bQyY$TVvc9Q>`q_~(blbZ(^e
zq4?ofdmpPXn;Tb{-p`V%XywU4uxXSfTF3$Jfti2Tf}fol3L1+seNqMSPUSPr+iTax
zDHe%F`ab;gMDo8@>L#4&@(Mm82*_o2#CKKYddsT@8}BHj$Gzc=sSjiWucS|UEZCe^
zCn$qzpiMMovyvMm$l-d;_8VXq_Z$jYD$3?|4d)_Xku}r0rD18c;&e6n;E=vE@ZeWE
zbJpbU@x|9xUNlT9?|7|nsl911(us7QQC$K`F+;!!qO$_0XBn1ePl&-Lay(u3KMvnJ
zdMycXw>O$`|5XkQCs!1Sm!gFRlS=T0X2SvD1`JzHSK2%)O_W-4i)_`36N<GkzdxP#
z5~(8gk$E$T+@tq{BRcqY&BTPJb`V1=-`N6@epepiH<a+^Y=ciF&7387ZySj84QWL>
z67V@V%)cVpK7}2I_CYhXy}O{}yYmSTwp(b`yusgFar~}rA-zqr;cse_Oq!hn_(M>k
zI>uQvMO%QN>9sx$+|)TI`<XN0i2{YGZ3$?TFd(73dQVRaNpGL1wg*G_m3NztiFkk;
zeFzaeG~4z}%X`AMSoUu!dGU|x&aOF7PCDCh+Ue(<c#GvBD>co;YLLb;2Dx9kJy&2)
zQX4gQ;K*2*PqayMv9AY5-<0FLV`8f<;BRBD>I|KPap5&?lV!Q7FmzrA>5urIo(@uE
z94xVz`%-c*^KB`(@)cE-A!RR@RsYU5jjg0r!=IDo&t^}byC`cg_8}4!_EjT1L&>}^
z=wt5m!t5RK7kAQyNJa4N#0VLEXGj;R@I;6mN#~AfDk>WZcI}ErrZ16zh682X7AQPe
z|H~-Hy7BWVG0qDVMoHm5i1*QJL*L3J;d=2)3y|^nJ4^HA9!7$&`p)D(9!GY!-b`^M
zBO*XqS^?+AlJOH3iLjS#p+wkhuISBFn_qZStahAb!x{yj?teSM@W0;_n!-q<0Vo;H
z0*f9C?uP3r83ARmIdai5QQ^F$DGtnXoT}XC0~%4|vO@e?Q(Pfqj>^biR2w3fC4JKO
zbz~6pA!@4)k58U`PYJ4|SJmc~p`w4g?7or?s>c_e_H=Y?+n`j^r7fKb?Rd6|VT7AN
z#D~u1FVE@Gy@nO}N39H`&(GVv>LONJ;e{oMFOYP;)6MU~q!tmnM1qjfjV=2$bxSv&
zS;Y`e)Y~d0cZ1sWtM;j_m;;50gsYuHF=fC`x^3FxwKf&Z!)<Wx-J2Zr=7xr^enw&(
z${ckA$?`$k`a#+d*fbCswcz_D!6)aYCFp&XvyZ;=$gs42Kr7bu^g20BW3%)%yU5)1
zP};aerh-|?7nTkU&py0hU@(3R3uQiwRd(UY5>1d6vJ@*`_(X#5&J!_)5SpJw+(J@r
z^*@v?v^RNZPR$=80SMH*d|O4mo$(oD?LK5V6u8;y0ib|A#v1Q$x}R%q3SCrlxPc!5
zg`0X(3%`;V`xsc32q<r*63F@RID-)8LAg8=n(rtozU7!-WEyiwRQ^4zf4ZBhQ-Ha4
z=K2Hv8_ehZJLvsvv%j-vo3uiOi?ZEfg!QD7QwM=n%6q&sV}@oY8Dd#`R&9K4$?oYp
z^Tk^;jD6OxhHI5QWyY};iSUUTGHRf;$g>CDi3`DxD&5HvD-gmhl=S&Rp%gC03K;2X
zm5!8{5(;7nj&iyhGaPa9J)6>w1e@-djQE|-X@Ji4(`fqNTaDvLmdE<6noH=U7%^nk
zg%J_B42m1DJ3<Qjk0|5<+hfpu_1vIO&N1+0==X(W$*A}RN@xidG%Im+1}yz(6nyvc
z5~%JBKno@4_HM?6O~-1$eueeD1pzxJXt9~TdF>E<Fc~R#rj<BPKr7jFO?#Vhl*jrN
zi($97Y|+jWB%eaavcD3PMVPp#D^ku<pb{J#`q4v_lbrjhQDW+`L-AU>k!HNCAr|(}
z`b$h9ST*f;BfI-v--Qk>-fa&KASJ=i*^M|TsFGqPS2GEN%#Z&)?3+p2QG3ZCuN4Uz
zD!0INEQgG9>m-H%VG+Yg{-g=BD1&%SJI-nB5o~0)CpM++=3rz@1`Ui>KmOex1~6_*
z%p&`WU^$n~Km-P7xkRgGCjxY$IkpEH=;3ivjKe?TIkE!`l1&V4=uNsGT9iG9Z&{@K
z<8Wu-r%!`-wid2oI8F4WsSlLS|9YaiImK!Swy5#*Y31tG%q2btv~rC_Dnn4k^5VIQ
z*xp+iyFY7lWtVkGGli;eq%t?Y?W=spcvX+Wb3{Bk*fGt~c<B+oqc=a&0RjqwLdl5u
z>}>Jg{tmJGj?<>EPxgZTFiVbEbJN%SJ>=8K!p_$okA!SQ5&PPV4%$-LzOQ7?qfaMh
zGdbHdYFAoxwu>Q$pu#aJ9SWg_3^6*rR?f(D!>mj?eW3h|S3q~%`622B=&QiGVK4g5
z8tkQ*8Brp*^JR#v*^kx;cVe53c7hrw?W7uR;zSD6-+ZM~Xe%Dmqa?Ci1)u+obR2Lw
zZOSPt?31$dcfP|<V64xF^<ZjzqAbgcSTi0pFHE>VoZdV`7E3>^&l^fZ7>aitje6dM
z!Q1~JF~9O&HGP$3zXNa_{crkj^3t~={@_M*zbYh{mPtAY-dyU`h(>+Q+@8VZG1>E1
z^MY@pru#eSYv_j=cQ`1n=PY2?r~9Gjo$3b}f5k+udkT$4tm-nvuDf%u2*0XSPnZeQ
zxmU*NoML`uW$jlY9K6MfW--r3(o?6GxmHf+_Riqp<{vglS=FJ1u^PA}UNU9N>#M(?
zm?r)gXKx)9*VnX(Htz0DLU0f6F2UV3xLf1y5CViGxHS;m9U6CnHtrT6G{J-W^zWOw
zbMLHq-|x<R|D8T-^;+lbvv*ZJRZl%71J|IUFD$f%CRN#I$D)ev53VW|1Tp3fTM2i$
z;VLejX+K;JQ3J9N8uFUHufah}=4vN*epS;?c+&g|&h#G}f&0iZK0nTsDp(e`pxn|Y
zuF(%E2*}|f`T^@pj6py~h5U_5{HC^aldw3uGI@iMTRF0VU5Efg^%s_$`;gAFH!)W)
zUXWv=yLW4tWP&51iL;3#cwRGg&<?*w^WmnI9sfLZ^hW9PDFmF?LFWz2l9S$TD=@Ah
z90ce*@7hw+`Bmg$2yVAzOn*$ccgnm!!n2bwIG`0@=y%;zHA)ez@tO1K;4N!b9>Ds2
zIOGq1PwC$GXizno(m@1w?>T`EJyBO@ih`cwBFBI|Y-yvY7l+KSm6{sK9m?RACTQAK
zvZfsn^JzFB;le+CX(=;yceaoEE-7=yfRwgLA7H$899wRld}(=vsD;ZIjNC}EwySCk
zC|2gSS#X%3X^BMU?=JfCTXksCQI+pQhsS-h6eboT?r%wK#x+yEO_D}7oO(<Yth&xC
zWM#@uynzE66{`U8c=o)~<(g0NJj3qWhH)-`c=V@mt4{k-QLbXT^s1k~8k-M{ofv22
z84klbsVGhWO)KM%tSG}dut^5be;-L{th-X~(8qC3f0=KEj!H3c?=7%bJa;y5{HxOP
zf7F|MnYFhG0T88>o2frHn+DIm`#O!UADy?bOVwJpVIDRX-Zsd0Il40Fr|4k%JGh0N
zpHps=&ntoxsKCeb-^9TK)LgB>14+9oKq1~a7kD7;46z!Kq1{2Ir?jJ~ozp8!EAydd
zj$eP?(naLhKwzeR=-9?CH8IJ<g#1{=^*qS?BxtoHILXab0O*F%{T##&$T{F!p~|VB
zohC`df|m!96g^+&Q@dG;OSLjD9LnogQ_b+G{Rrj1c1_<{{wY{P6{mL;v|lC^kbuxs
zu=q2m`wy&c<DNHAkY0?xfw^!EL&>nRdhb#}ZzYc85hvi8613p!gGv>IcSZ+2XkaZB
zN<RfCmetkdupBxYGtbfs^dwFCVQS}?zBO$bp#HOa)ri;c5#*pcI#k#zh&`%R%dt?n
zO5iO#=n%#NmxwhLQvZS0F<~dQ+m`l2LNCUX0szVwU!61ZouDGWX4?!N=z3!2O0Qw9
zDVgFqLceWPG?$$PFEZi~rYyJbT=w^iBO*atfp&4KS}HaUoN{u4cKKy=J-kI*`fn9A
z)ROP24s*RE=u!8mzs{VeSw_SXcqVqyP#)&*?`N|}qlH`4Q0iIK_24#2$nrLth8&jB
zD)1XvxT|t^p!zGF)cQQ4-eQQ6O`Wyj4N+lGwp{vS^NHWQtyBC1V8;0C#JkDC!-drG
z?CfbPOE5Oe_UQ-ZNB}nhdi2|HO=-Qo7`|I0l%4UqkqWrT=p4_lRfUS~qh)4nKw)4T
z>gNX6OGBvI$N|@+&^L~oz`0Z*RWFDhcB;=^#)!#8(Ows-U|H88`P6|t($WFcpxhus
z59~PQhsblce&EfbZz}x=T-$YMwpyV5=&fGfAYP3d#11(W9uKIS0O*X$oABDn?_d2y
zcwVeP1~N1vmS$h@-2{Hs8@bG8@vWM!*8A-OM&`*S1VAlBOj1R#>Md57>)7)qm>9J-
znA`e*%@shK0OS+knKif=mA!n++fK4ebj?5i!rw6IgPf7!%h>!o-HIZ6)Bu$LY9oy6
zPL(fn{(DbDM>Yoh6a^fu-@shz+%hW$XUqy~EUbCxI~GY~g_l*TUK%y-Uo=zHPFBd9
zf4{&<*Yo3#6a7AWd#TcGSu_m9D0!?;y-ppwMRL^t<<*_I#+MQE%y!TAMm3_M82OTG
z02`NBuV#-yc*zmtjTaw6)bE>dcSn_J^hd_`_g~W_$o70*T+z#gCK^?QGDE15#4o{B
z6S!lCCi}l)$hT{9@G_^B5x@WKOzH&7r+o<4Oyw`o8)j6Dn~|cLzjoaJ6n*0`HT>sE
z4~!(D^J3Yxqmz`@#I|sT1TNv*R3Gb13X<wcg1`KpQk|6|c#}M^NMV~sLh<POJ<n|O
z+x&Ie6=b6+Q^LT!{J?YpdHj9;_wu5Gy?T=<y(t6zi>HwE#A`JkF<lWgW$k?*lcMpG
zygVbA5Tw>&d#LEuldGK|H8`t-?DU3@JGKtHHa&sTT{bT3+@P<lY#}(0N>#6@d&h&^
zeIiQN1u?Z&N3;pJFGi~_reiuI+(|z?^EaIu^GJ-{)F7EBzXCi_u+QUa$9vtz<$}7V
zmmx0Hg7--&KX^=;)oA*um@ITtMw;!mV$)`+%xCjCQlq>#6DeaWp<UG5CWuKX+UD5)
znk!QGns{zN_1th{dLHm0Rbau{^G`@ws<*d<Rj`)Et(^DSe!K4HD<2BGe2bpS>_}QM
zXPWlRf;`V`JCQH9(83TZ=0(%tXGzZ6s${Y}FlVKxjV0xkXMZ3LD}?1p$lF#V-&pC7
zc<tY%n#ZRPC9Fj)PAgNT6=pXYq!a~8eA)_Gr+@taw2!X@E!C@#FQ^H@_{i|01~}}&
z&5z%}jCIsD{^NBVob?kY`lmR?ujQGTsYhU$=4`?2FtEgGhPqC+a!)!_>Gkh>AquIK
zTm0vCi&k0~8gz6^U(IBo-^~B3lFoipUHP74JV8TpBPavMkH+0kaE<Vc-fU4uEsdbE
zB2tGiLn4)+ry^20=M7`JrSMF+(f*9EU1i;0Lv<>Gk`-(oZaeJlMw{-515sV83S7S)
zo9u~cDTgXo%YBP3{6s$d_ALIuFTzMXrTmxCtDLyj9clhL3zm*`sad&AV_vB&o#u@k
zT58Kg*FpV#82)*7uW$(!>z6{|E{<+rrVEb+F6zV^8{vv=jmtcTW8v+HMrVm6Cdon#
zj(yk}jN{Jgr?!uW67CMSHhMMUcx2aK#7fRKMo?~dGxoPVQ|0KhPrs__{X2BHO~~S2
z2moSK*`!aL7Iz)Z-37m@X)cgea}I}?6e;7zp6;qFN95;Tdys2`J0ZGb)n=aO(V1CB
z&N$^AyXUz(WEQTM@1}#+Z(fF5f1?>4IGDSgE<J1*xUJO*NDrf3O}A{|bWcT2^@xO>
z06(4wSz5hq`(c~4F_8wP{?b=_=Jt`L1pG)S_`nAbIYxzz{0d@b9#7EU)<prCcNTie
z!#GQKB`oKY08nn$qs1AN_H7UvbXQq03+J?hm&Kp=6NTcS0QY2{?%~@$LN~&YDd5b9
zr4Kz3D|dg5x<<9NnOF}bk#roeRgDo#2oOO+!5(Suso4D|fm!K3MF0q=%j}0iSZelP
zXaIz3mxc{(AQ|8Bsh9}I=D*tGYK}Af-h34h?Y<>#UHoJ)9>+aeuFM<%<zI8pXwi==
zd*cC+^bSs^!3ONbiVLW4Z`E+gQ34z<g$I8NMNiA?X7?1_^`N<P3I0^{<lQ|P4Tr4h
z>i2x?eWpSaQ=y7i2a9vFDL-FPqZz)!mF|M(z{~OQqe*~K55<uS#f^NKx9y4Y+NpX+
z_YJh=tOp}Vk5OZ%l35l_DxHF1((;0%wCHJa0Fk<SF0sb8G#j~Z@5YZ;fXVkg9qF~h
zk1P+vM<EF(lyjQ>kpjwe#4vtBp-k93E_Hcdp-R|0bq1h!J^-5D<{p;FD)5m|tsaj#
zB%L7aySJW6GfvA_50>|gkIr7yXwgBPi^uVEJH9KIq$WArPV#BAzu`vYCkK{_?r#r0
zAD$Z)=4v*Vh}4q1d=8$z#&;zIJkYD~#y9-yg>zRTszXBFA$uZbU_d@kIARd=QocJE
zpxNmgKw=~LGg?vp+4|p?8(^bewu=!#M8X{u&MRFdz*cwo_vyuPmv|U(_7W1g?kPj{
zcv+g-{VeV!RCgQ5zTUzk059Xi<!(!y!MT=#=G7<9?SM<n>aE1<7Oazlt)#jT$^X8@
z18cWiG+}y-+}frDr8zF!aHZ0Z*8{4e>l$-7YeGW;RE2B1GomQ~$Rsd0UILc(k0($s
z{3muSRr)7EA+GD$bCm*PBNnSmw*&swj)PSQ=9w(6Z+kZau?7(EI{CgwGB?IdiwAsO
z84~mi@-F%P_+9Sbbz{qhr%Q!v10*F9R089SPC!1GMmQgY;8`H;@U_ix37QxoKKya<
zbqH6C45X7ZSe2H$^VQqeoPmJN8?5T*TSSnX{qyF3y!+ka*>J#G%*|!%w{e$_vo~Li
zdjxu#7H=iCy0^W&^u?U_Yh9${wZzw%wwG{zwY8c_w^%C_yY6tFFmhopN+g>5x3x6Y
z3J9D%;G#fHJ#&^n!N?K}T{#B-kR`bPsfP^VUpaMC!W4yV!|DD0%}P-G2wV9bu|gCz
zVxur<ic}%@j=ynqUwQkfJSSP3_+S6&pHpmxjbx??0K;{(N5Eu4M5+)$GJ+&N{flLN
zRoe%!^~pZQ&Ulu}$f3?)BL-_$mj7xe<*mDj_Hfm?*B>j$+mJ3YS#AI36IWl^T^Qnu
zG<y^16}UEi@+d(S#$Paerw2uRW|BvNK2o%G==JN(BzdX|Nw(&Lh<HvCE-C?#4sU<5
zMc6BnX?^&`1pD@!k^gj)W0nI0elfumw?AOS$N%eH|1bHg|MO-JHj)}*SoeHzdjaio
zX?Q~-!-^B2aqa6#^3)&WR0JRbwilUHHay7X?%sg(Kw8b<&lS6?`*FbI&Sco_U@6t!
z20=;-R`tT~bc7{1<tB`zc#1mjWcMFkBn*|R$#QGl=zcW^tr~{eat?nP9OE;zYFxG!
zk$8JZk2>_%qz=T6Vm7M<j|q}W;?ca}A$*Og0H7KQNIyXlFN{Oi8(`#6K5KdKadf4n
zy?Ojw2nh-_O@;A64yIp_YOeOr5vcw0&oW5I-@|jj?vl_p<VgS9jr=dI@qfQ*#)70q
z7^Vks6>;j&?xKT(q@hc<z;pO6^8o_bWJhe^A!Yeo0M%BzZ<E-@uVigocW9IYBo=xc
z5WUAKWjE>7sP=I=okr&G2WLg+3;7zRxiVcwaE_fxJ{On~%czItJ!dOYA`N00rUx@2
z@7AjT_6b<uJYcE}iyn5(Vb*=&g#bv*L+xHE08(q+FeVod!$xRKur3y~xEK6<EdVrK
z@Z#N{f6tuy7Zm0H@rloyncUw3u55%Qo%HA4xvX)opRl^T4!INZx15<Va!kl%!}OZ~
z4@#wQk|LHBFkO!{q^6J(lEWuwPe{BlZn(=Hyy#LWX5f}#1{+Y7Kf9IFIJijFGtzY-
z(UI(08oPM^1L5ft*}@R>ychGla`DDvWwVdx%9o$C8Tk#HA#EN8N3zvasFFP0-dJH%
zPB67tcu0I_BA^NDcMEVMSE(A}GuYZba*E?EwK^qA@f`u!Y!<m<8L@E|w&1XW_a!J;
z6CD-sT=+fh@*luhSrZ0Zq5yQ7vuiX!aA$y${eNju{<5Br!9&!LB-aw!W-SM%r{%ba
z-vU$*_F_E4#H9eM#~A&>?#M|z`a9j{{LWO*j|Xp&B$gb30W}~q=E8>hsQ$h5GB#0J
z?_jv=<HgNgqcG3Q(o(?mT9_9Buj|QHNN2t4F$e*I1=dp^CIWQDtg#|F^TXLAeXkTt
z>_Q52{d0>R)F}+$^(xgf%g|S4iT#7XxLOetsjWh#OagSVG}J{PwqDWewQlL1fWuc}
zV69lSNOG)}+6|a-Fs8r1QPr0OK-~hc{ko4x01x+9U%UQwu<@Vld06PSy`aA>3unLK
zZ)n+YqLH&YEXN)5WZ%>mJ-j*Dbw#!CV)7lM$x}@a09>9y1dRXz<m3R=vbOf1;Hl|q
z0@Bi12{KFNCXyuOvtDi=tfV|VgW#QwM^Y!CNR9p&FsvrbTw_BCq;lTQ8%mS<GrNqQ
z|Fc*&?ZJ&>f+&A?Q<P(fL-o<f@q(p-!JkUxPp9i89D@-t3o$=4VBM>$C}I3bT-a{P
z^1F7(Zn9;W4b_N?t(8~$*bqLCFjog3Epsz6fKlH#1M39vy+EdJZtq_`n~jUAup0QF
zYHW5ga$Rsej~n^Q&5zmNytzvsz50LO47l<QB#Jh(zsaoy>1ZNo{D;3UhHa^@IC%>H
zXl^L5ujv0*3`jQ`dQJeqNI8n%a}j`r<*YaI<9g2#4x$GSQAL58=Op}cj;kw#2c=ee
zdaWS48B=`DznVTFAQhoJ5A+(jc{aA-#L)&7FQ7YZk+p5!G3OMeqe;YC__X=NmM{8s
zB^nW3zwa9}$~+njRYua`Vg8;*UEudPT~^KM`1l31iow+SYlgb^#`}3b(Az#?cIpTc
z@=*{G1XFtPgX;meep(wx8pQA+WYxp6ca;l&q=;>$w>o;ac0d9E(~mJf|7}2k*j5tQ
zmeLTHlJLh85IZ5*YR3<;C1?pJI@bRnDv$ijG6CdkX|wS5x72q%^})#9PoOONvRiLl
zR-dCc##Rdyd9mfF*vsCw*dT^dOF^9EK;TbW{PFjR@UueLP(h@GpC4maPNT>7WtY`6
zy3FMHGv(iy%cki5DfoKkK(tYB-fA{Jn{1A8f9JKnMD<dS@pl#p=Gm0ftr^KJVZozL
zh*0}~$-_w_slldZYNzHdAK&;O@m1P9>hETU2f5T%vX8;7$^nF}Ik%N!v3dlT!nxrg
zW2%O5khR`w;$!}THIogGw^k^-=^OdT=eEv#g_ejAqXTAV#M4gk<rvQ1%f;y((hOQ<
z2S!rWFMbDwqsqfQnw7X=9A5`3S*Wx0Ql6}z#>eNF)?etxl;`XT|AJ+jJc5pbCOJ`R
zj!=#l`cTX6S3-iT^U2%^!txy9A+2eb%WQ%gehh%sxQvvL>M)$Ax7ZLArAz5hzZE$9
z%2tA@)A4hkn*o~Z-W{DLC-mq$e62a0lmxdz69<bC!Fbb$Ea#|F(`R?zD>~j)9Jf&!
zzm_N^Tde!$$I&4@v{_<J7H6EMWujiz9%(xl16(NC@MyDJ5#vV%-xuQ9O0T;;P5kj}
z%6SiT;sjPqV|UDF1k*N;J|sK(@XYBm3kOStBgAE|>Fl5?R#nQq!n7Fj@1C?$p(Z4?
ze>AWwW?uI1{gUTjgAMy7YW%v_cVLFwvveyVsS5^(j68($|4ZM`2gwW_cFs*Z(tW~w
z0!`PxooCJ&EdroR!mywu10Iwc6+O;~EXjJevML04%p8X`zlbe&#QK_ltuN`D)|Jjg
z1hLYycMq%oX~Z{{-Pu%N;uMz_t4|Vs16}+$T8Gl>`T}_{mH1T#X!;2Yz%ot&!A`|t
zlTR%OKvuP<kM8qpDj>X+8{mfj{OK8tEW5b-W6{hNu!<OHkJ~+Si%Uu>)0VJZnZ0bE
zI@Obnp{TMcW$TUBZXE;QIYPIc*309YSy}%TwlIgJ52Wnwwv<%}*kJ&;z@aewI7rES
zB|R)Ad#8WNWDQ*pi5s$R@wA8{@F^uQOUB>;>#VsDCkb%j`Rd|noz4>JC`DCy84^Mb
za@ln?c|<I3qqcoSaNXTO3dM0(zlr~LV*g!V&OhLr>06a+{Y|^hAri#DC<LriV`yCU
z_(O`cAif3bl%pt=IpDh3<m8&)mwa7}UCs&pycJ3`a{Q3=@aG<0+`^47Y!E$m94k~%
zvKk7_RR@g*cvNaAl!HU5tUP@CsoUdbc)ISUyg5aSNl&|8$!u-Y>ZLKD$1f2l@sVQ$
zS>Kwn)n?(q;dAw&tZJY<wON#-ZpI9|t==HiZwMT%7~yd^KH5YJ-$S|#^S&J4%%s(d
zJQWR{ri#FHq4YUE^ekfF10I}G_2EhWE%obPpz8nO=)%)A!nI-Tya@H`#u5e&SiWm8
zACD%fkPT?s0c`kmN<qo96Xz(7kTsmET0`7IgxtIQ0igm4U<;Za?2*i+ZE`TciPkZy
z<+0I>uCq+i<yv9MZl3{cRbH~o#4axHzXQi|iKD6Rh9Ae{W1p-Ji{Y=S(1P@&D&`>V
zM(sxG!<TmpUApT=;-q1&!yl((@mvrzoz1uWVLnD=L9qRdlM_(wNdgBQMTNK8QmA`n
zi=grmG+kdW0~slTa<WDi|FYrFX^##Ql;P&_eaio-RBC5OlA9lkCmu*0e(Kux<ho3S
z-dkPN&>VI=Yo213BNfCPDgEFMXd2py-dIYs*XNX1c$itEl8QUH5Uj4tB&sr%X3l?O
z-SKJgi7-uXk-I%brjJ_A?+ObOOV*>FCqX^{sa4!RF1lE7wi)@8{2M15s%qQ;f<w83
zJ1oo_WbRY-g0BXB2l=WWL+HcdlgpcKLKitX$-{iOK866Vus;5p9EYCkS{go3UhK=Q
zn=-#mTgkWP7lN+~h=r_?3^ii_;cI_z2VcI?OS4kMf5#y5tdcN9RPgOeF!zUuyH$jP
zj?(rf<856hp@`(I9s137?gVv4RW6kJcxa(DW~X&OrTZFbkvNSzy_`;W^BV*uwt0)w
z-1qJ=_mZMh6&3}#|DyRd3)3EnviFSpuUMGQS@h1Y0AM7bY22s)0Z3izoyP@mVZc>1
zSY8!CTso47vbsVywHHCt4)C>MLlR!99BWVA=GibN@^^SopyeEyeiY5dQV!$4Qx`sM
zYwK8zXR%hf>aNMgWz$p>G(~%`0h)@@Bu9J@AkpZ#p8nl8OijNUb`$ES8)*Z{0UKp~
z$FzfgN(pL_^G;D!y1QXm6J}m86@Y|&7ce<0aTyd-R#@nG+<?09m(3S#@8cNS19dJa
zJw>^(Dm6o7(kEj>Q*gj;`;1E78i=~7h^p5xEkC0L0J`pTDzdB4b!SM4>ju<ZaT)qy
zcaUsaFoF&AudaQqen><phPiX(E>^?*;9%Q4np1kh=!pK8jE>m*X!>={-ex=8VExcf
z@m>gifm|rcAF=aaFX%-5n!@f?kPdyEEX=<B{3ZV*6m!?DCpMl()8yQZwpB2C>-C7l
zkE{7pwQ%3z0T{jcG65Mx1lw_2%YvIvE3Gp$Yy<rFZU&iIgXVUg1}YHM(EK55?-@m*
z&l=0I1>%g(&G3r{dWRvCO>|r}>)H7>^?rdn$KY@;E7%-d3Si+>?auC2(C3llbX+>g
zTH3$6CMszFl)Nh|zbDM@M*$MNW*5un=Pk>f8Q#-k$2h8sDA;BhDIcoDO@l!PX_oFb
zCs?cEN)vykb7zmxPF=^&E)yfkS%FVN=B)-_Lo^Tn_sdc1+0k@CP@MPG%Yb#>i3#UN
z&c+3_1Xj@GJg(<Oo*w(#%+WU^WYqISRH9}I8_7bEh~9M%Z|lm?5XaEw{hw|4ykxJp
z>C6YcyUx8bjtP6Q8142h<eqa3BO4vwEon~KXjoH}d#>{IV~`v(Gm7Gg33<hjqu9l{
zaJJ&OmXh)Rc53D|;Bb_~-W+$eWKC5lAGLFQX1u>`C)Bt`M!8}R9-!=;{Ak5IqRDJ+
z;Fe|>ns*aX7(kMtPRVu@&b5xsV{*-|myPu9J$-eRa<^X%<{OcO|Gka%f2INczxeT7
z>pu`<YTo#yuR1b(M~@zIS!LMojRcRJ?u|QL7u~Ie7d3duPB6e8V%gqIdR188hq`Fs
zHsbeBK8Lbx6I1fpwI0vMr;lG0Zh9>g;oux8!$r;2t-Idk)QB}*<ELAJ9&OyuGu!@Y
zJrYwpG}mL3@2tQs9Z3fV{Gr;HxIbfT<_~G8?)cXBL#6(*Yu97}E&YLGFV)YV!;Bv<
zF)Z;n;J{(#8^vpERG?jdkxwv@YZh`Nax%1`FkOw|KR36z#x2t|-DrR=<K%Bffx2+^
z#I)e*bd5>3!Y>&!IiPPmjibdZWyT`gahS9B_wY}^kQ-#^?D5BT>tS7geRh~U0DBD=
zWgj;tX7cvKf)pkYSDb0^@LlfU-vH$DD)?qU{)kzhQi?Q3;*u*~{0l+qxx+Sc(mqJG
z#K3)gW82JD7-L6Rbav=)B+9otXYt6?c~=F;Z<Fd}9W;@4!xyKwt`<Rq$s9-MALo+K
zOU;8n#U`iMf55%F_g_s%2xFicc|ECHaXH705a51JXoqL9k+!Ug$s@vOybIX*(;Z&#
z6@2&8n*t818+3O>f*={154ieAt6QMeqxh&B#}he45%5kbLWs#|rX}anPt?w*Li+&Y
zxYoP!wES|U-TUYm99TGFmHf?<n4bF^EgXLQsL-xB7MF4ZlVO_mNwaebRQ~qQshxMN
z+2l*tw3B`-9CTsD4oC78|GKr7_`*vW4o=dI`ArCoEbM|tmOf^ONmauk5aMvsSGE?p
ziH*TFQ3#?xNB@DFjKU=lN)zr!NO63QVJtHpsr$N~u9ca?)t1yZXElVTPCP2-vAg>I
z=_r1&TS9a~VO90;UTXRxfn+g-2SP@wm<o>3`bZRSk3ICX>CxvUQFqWK)gDbo*a@Yi
z?Av>cwb1Z#_P%tBW9OvJD0>?Sna7z9>@i<F5%U!*#%qNiKILvx4+_ugL%VXXa$amz
z_|+VQyASn7Ot*DETVyHR0Y19Hb5@3Mo`j_M#h_7jSwTZDWtN>WsS}^$CRRm%ll(fC
zNZ>rlYxS+da;NB6zNHbzXf?%BcR_9+C9j#LuN!_&2S25Eu7&>OBko`%#6?F%ih`Gh
zD+tq&WTO2~es1q;Z$|?l3aFB;=K3w6;!0`k7Poc?kRt5Q2F*Y}`ls_8IQw=roc28s
zuRG$fHjT`Nn5^U9zTKMNv!j>$CiLHaP*Itx@Byp6+CcMX-k;KP^614XQiupkLS$1p
z-%(@|7B~bnpVs<p`LtZEFFtaQyK%PaUfleBI)|~%W-)#;w6=5=oS5PQu388=uLf8#
zB;6`jtM)ZH-9U9xlJ=J291x&^&Wyv<X}F6$X#c573;*rc&Dt{-bsX3;&mXyTxnt(_
zoh#BzeRi@;vBNbr9Lx%(Vm<oc{6mR}zl|-D5jc!(zt3l1fd{W56d{7eL?uHSa4A4a
zvB3MR{{LtJQ1s1k^crE&?e>I6xBEZ2$9hLKl%2bTb}d|vf!+%joC$v}nBng98crxM
z;{*Q1ic0_Ov7?@jDv5$yfaMv^;r{hoN!qhP>=48gq;s)tgD)&;-!>Ieszs})%l1Ya
z#6!8{fDdlCP5$_lJ3VtY4-)XgyIAlK@)C(jHNZko#1qcNCML+O)|6t-b*;`n0AsZy
zvml2kZc%uXm+1nh)89GbtJI`v7DO6zjGv_5W!AG@|DF?)RIb^4Pn4`s8{Hg<oe5l=
z8q#JWgkrD0qpV((v@3kfl~TAB1jl+Z?#*(0wFfjyZd@uB9~PGXiC9$y1XR)F=e!3M
zWez`A&KVddykUpiBa&V~D&KtjwVlBc$RMWJHH42~>bLwTbxale8!za5$g*wH+xm1}
zR!3OfAQU`mL7F!ZEsf?Oedg^tZE*rh5JYffA=4qX`1bZnuc86zJ~u`<yV}<NyD0yu
zU3-;u%_i0@1fsq)y_-B|>ER^N-om6_5C#C{OE<mtSE2$QJQ6t*sfdo3a=6xT`gYH^
zGsclyH4%gwD*$pg<;=2HmF$33nm`x|WuA<}XE>k*<8&nybYpkg8cH#PBiyDrKhDsE
zVglI1KX+~kk3jsd=txznIBwWK%?QaZ@r=%4U8l33TqH_cg^gKn_<(BC&A%WtulGH^
z2(A+-c>KLBwOC}pd%Osx6ZImgoIyWJd^~HLR-!uW{LUSc2<MCpp7mU}w7|{Ha*(}a
zLNY9hA#Z%u`9!&8{fQ}+g<Zgrne?cbW7>53=DLd{Os~)OfV6Y~%O)5h?u9D+(5dbG
zg!idCgV)jNIk4P2=+H-PK<rPL%ekPu#ESq>=nzEtz=J>T%jGQ)p~(9>dvdW!<#;Q?
zumlK5?%MhzkW3!T<aT%dTx@fbJ#jOD$&NC4)zIq7P5+-9@c-@jpEt0ae+1Ysl^|R(
zfI5&mm7qB~)Pv?U99xSWI~(JzW<L11i!*Sm;C(<BP1q(1vP4_o2H)vs!Q}m#`C0zv
z`t-@!p{!l~+_OJ^RzVRYF(+#5Gz8lB{g>st->&%1sQB(RJT8?~#9(8Gsvl&xB-G~Y
zWO5Gs94s$}^U~w?T)DSCE51Pz6hWI6e!g9S04OdM2qSI|4txhIs8lb|JO?V*RTBrh
ze}I#eDEpa^aan-?!M9(lnoEQU{u2Ok7qk$(ZAi4Gj6to6Q`3lc{@~MY!XG|<0RS)-
zlhA`a_x++VDZ}<W=WRhRAlAuOZwF&A#WL$rEA{bB-?%3{j}mx{U{{Mb<1~BftQei@
zJV1f_VbPA1`s$;sd5mg`bP=&s818i{&FRM(5~;6lkH)yod!VKL=tsyJDfQo9ZN`bN
z6mJ}5@ODyd*6%KnCZ-?p*aW`llO7UoAn4;rHCUMmYphym&E*=&Yn189h9B;Jb4ox(
zjL5)H1o@D`3Jfg@07y8SrQ;ftXs|0K70<x3;+yxuBu?R6dRn5y%|vOZmcZL9i%~0?
zbU7R)Y_e9}DQ62h!rs|+_{DyYcgmu9t8;LW_gI!}ySM?5IfB6x02jXadu88xH4vNG
zlJrkdYF<5e$X4VFM+B`rSZ<ucKJ6P*>9c`37Obm{@w<SuJRrdSBVm4ycfnSHym*Ry
zd9PR8f!rG+d7l$(J^e+Gaeb+zq<EBaU$L(a?QUnjH|y{ql;M$!zEF`5bpz;Fru`I%
zRrH`DE$a?DecW>tk9{9>|8_D2#w1MzA<V--#TpcMCvGHiy25gp3Yt%@C^uSc_`&n4
z%b*OIircc~A9}#E_H}K|ulH2M&n9N8Bc}dDKgOlLBfvDXpa|&n#7@kxi;-MZEn6Z!
z;VOi4%$$L+$xoWPq)aXr99fdQ`8GW!Qr+LJ0Lu97TJf1gX1`vPOTs_jVjlF8CWW5!
zKODc$SmdDnW86EmBB*DD4|%o#O(ZFOMQExy0f;>b_Zf@36xV>*ge2Ye{PMq^YV}w<
zB)c_Xb2?j<LM10%=%JESp;FlMo~#JqPE3A^p~1&kOGrsd+Y8BH`T?HWyuY~U1KHj|
z`8@J_Z#~xI$Y=LkkE-p{uz`t-FQ3-FM^wD`aIT8p$-bZ)qyT<$o&Ove&_0eaqdk^n
z9kDppE89gDP>r6J$1Ru~8m<<Lo;21P$7xCexSAIB`f;=f@R~+^*aRUorApCLNI>8M
zuoINg2ETE3AT(VGARz~2tpleR2gOzseAT)Anh5)<-8d}6;qs1}o~J!0*gpOLIQ{>{
zCiGSo^<uz*a0tR&-_&Lk?y#asx@mnKtD!DS&WTJ@Q*zXo_%1)b*%-^!xCb>s<*?ix
zZe^-^R4m~G?FQToxJe)U#cc`t(&oH3SLO`i&H@1acNqS}D|VPIHs?>lWX<itKPu)8
z;)u@E1E<l#N&;I==pt9E!nKs`L^bm|;A^P?lSjpd#oR&Prn;katPwvS3aiW#C2E2B
zdZYj!ro3|3xy{SxuG>s3%aBb$e85zlrs)Br;pCumQLPvHL3qQ6S`?t(cMAJ+XoQ_L
zW^L#L@`DIjXMG6S(WTd&B}+uAdks>$_-eWae0LM{D#`NihB_D2qbPO?!a$@g>RXoi
zI|NqlsOfEmj(CDU>7*`I_aiE7aWR-l#J-$z2p(cO(*r6`^xjaL4P2Rr4*p_$WAxRM
zEECOBh7&CIEa=~#APx@+025abDS<8K2-<U`=(-}dD{xv%(ohFWQpzhVZayD-gsCA0
z-Q9%1)n{SV^wE(*j|Q#P2|k&iCbYT{T&dA&aB*1-Cc;IG1dEwM`RDGxx+hqtFfqEb
zJL!E%thNe1#n#hXsw3o}&D6&Sc!9DXa_^7XuZ*C1J?BIb2^ej4ISRBF?h%SLMIGJO
zr1HaJcUK$O&~d!=r(J(Gj$zz1-+su^(9XBr^8jH>{c&iLs;^^9KrR5trvM1BArf%=
z+t&CFd;<rGwvMqNqoQ1SAFYGB((7`!#P9B;nt&YsIdZ;3p6aJv)Ap|ol6!1`*bMUb
z$5sFoADtZ_93QY4+q^)_p$ur64KLsktqs70x=hg#{N4GB6*11e=<*Kn?E2T0L%%}>
z<=0!zId1NxM?_F!*MNknMDpub0LWKhQad>08qVI~coutA!|5=jqVP!MQ6<{MbLL<)
z8ICcL#dMF=W-ozH$1(Zz@CJ24nBLBWk4o1Y=#Wl1wSPR~l*)pB|Mn=bE%G5xI3$_?
zJ`6_jY3>tKI6!4!*os{$l=8hGo~@TNxl*Xl8p8{91r2li<R(F|96F!yN!rKYqx;4K
ze{pTT+@T8d2@P_-P_bgdXMIY;{VB$AB}<;q<u|g7*5yR#n3QjGkF+_!pYfp}%JJUg
z=+(rdsj3$~@)6g>PCR@@rHjtoqY6l~BT3%Q%d;dp{dU(+c@wFqkwPr?G2@;#dHpZe
zUjG}ggn;HtG@IqV5<8(VhO?L}CN)jeh*j)(S%l^WwS-c*Zv#W4JtQS4*cR?36;*HP
zQqfw7zgV2}#PA{FYF)_YU7bld_L+m<)}yaqC;!!0w~Wtq3~V7~13szGdLcD}mOCtI
z#F2}nu)S@`qy2Dq?6HMx@q`ppE`+4YXD{;9Z@t8|`HuL^td2t|P{fLg?cUQzil<IU
z)7j+hfG0e)Di@8HhIZvK-rwYV4gioxV$NR}W0ym1@!HR^g1i#iD44lvf2W_mVi$fj
zkpE9X#{Xh(!ZfxGna`yGP`VCEQ0w-=4II^R@$#Y;dt5+1{;V&)MpZFF(}^WE1d*m?
z9D(RKyI!pQekWxvo6j|L+Mz%EJ-C?#?JL>l9XoHNLIKD))r7q`ZG%}At-nk+#W+*`
z=_$03G{ddyWD$&3oO_=^yUDcm%50c^Rp?vFTN#9=D9|ys%BIxXBg6iu6w8F7WYe&s
zOC~$#{$-`3#P_U?H*o9fX74x3AxW}}1c0gt0eFZ8d(fLBT1=&JI3rjB)#WBayvq~N
zl*Z*HmdLWx@lmaToI%6R66_NpJt>T*S1yzCVUH(}#UJbXBU~{emG5C+Rg1TD`4T}7
zt;)l9K$D6K-8OGj_=RTY>jkOF1Lds1OL*!ElF97>p3+=q`nB7&KMsG#-nqTKkSulJ
zD;=1K!XkbnT1!u1lP|(Cy1e3m^X;B-e{(8Zgg-k~t{9YpeDLT@1vCee@(H10u|b%!
z;`n~a&GvjE0uL{KhmQ4w9N4L6XnD$2u;vn_S^L&n(cMs0!MTz|Egh-od7g!+cOqID
zF>a|oOILD#6GM_w2JflOSu%C|!ih0<ho9gMO_lDCdEdr9YClqcUmDug)$PtPHwtCe
z``OBI#liQeB<(oA)!I;EE$GTz6t@(jwoJhUgN|_!Iyn0!9(Yi?enOlfc7anJj$3{U
z9wx_I-i|o?xEf#U=CMSUT+rcS#`GIXr2+uOcSKO^$iu}?X2)bq+uG@mF6=S91rO52
zipy+L2QCPntK7m8H`HaDY&%V{Lac6Zkj;8c7%I_hW5=>CakZeU!wzlvur!LFm1=?k
zpI99C-~hHb48%f^am~rpk(NQ}TuEr{HC2dzJaJ$1SRe9w*Oip5e`?9xyIbo$AS4TT
zDE%|NkE=|i0g~HS#<Cal>+96<GV=#yo#R74R`O(7`U+Xp&t98WMw`*~K`3Q($hK23
z-cl!931!H=59F%*G{bnDE)213EUMi?3XDb1vW+=CLc2?s0hUcjzxN9EyBkpUMi-r#
z`UmQGe%N*5$uTVw^t_|G$_!5$^mmp$%%D^m$ft`Mq5okQwb(PFdmGWCp9L=P%^zNt
zl@J$p`Up}(73g`wgSF!${yl!Aq2Pj$SIN}OOBUF0X*<<@-Q_`PRKS&WrX-aOGJ0e7
z9zcHbqFBBlwNzkbp-a_lg3l)$zVw5(%``byJ#Y}mSly<f4<h!dTN6i(x^<wY^38Oh
z&nJ#`3V(6dzbg>Fd4$IBzS?MA*))W<5dXw*ZOoEiXpetCW^u|-Qzaq+x{8JxpWa<l
zVCrZ&74RFPa$TnMWJz^tNtc_*oYX(71)A#|dtK>~<Sr6%&HLx3UdEMVRPTYpNrI@q
z{Y->pU%P|J?j~qUCjuy=onH#zB5;^!m)^gOMVuC(<viUX_#LZez;C^2;!QX^W2|eq
z$U)$uUY6pP`M<L_Ea%d2&=#Hx2Awrw7Bp4ApcNy>+bm-zmp&{U0EC|^(F|<~S8$U9
zN2kth7<Tw$71Z1o+n&Wr4@p^<C<<=W@WWo<v%1mxQGyIRaja|74?{AP-?RczR>ni$
zKssf)BJ*5MLo(DtP=j9)=aC~YaNtVm1&YygixOI2!^a-p#`A-_JvY@H&LG70onoQ4
zAxb<nt-UvYvuS>q13kVo-wI1&00NA6^lt_#ktLmYJ8df{m~0vpQP2bhuDRMfU}>z%
zw;;w+ugoYKfuo_cM>lS{rG5)!)naT0H;E=<VP4Pp2W@zWrwhsVv;opg%Kj0W0E_gY
zx`*ejdcm%^#|v`)cNE+CY+rYaGu_Vx)q<|5Mfs6{-IqYa$~UwAS%66R=i&~<M)Ug@
zHPrCW*eobi843X&r|)u;k8CE)unVTT9rn8L%E%q6f-m`~7}D#%xX_yIcylmTmFY>>
z7L8X_#cRd8PB@BSCZS;_VQ)_g1X{Yv<K11H8DtsuKa&QpLVJZ?rVdDHc{jfG#A^vh
zmdi4#?z0JsPBfkEV<DEf_A5Z_#P#Gfm#{|8g+60??<VfBG!5aNns!ANr;;vSvWz-E
zpHqq_^qJ8ysKD(>kKdhk7*5pgrMNB6Tvq|0%`Euy)xPry>Qm<?WpdoXFYk$e!y9~9
zNTGWt#}HL2iy#LU6=+toN5xP6e6#(HAc_ma(&T<kmkk#&c{Zh;390xzuZYV>W>+{d
zr9N_@1I7gHx%P#PBO2=wL+oHk9>p=Y@(w}c`6>KS?m<WSR&Z1Hhe)o9l@0khoZq|c
z=XF}}l{ew<vq**jrZ#M;0jooniMMjGr^>#Ib>yi96@Q{*lZsHvLtkH>_sUtigCzf<
zO{M`D5Iz&Lnmns5yHIh>3T;WE8aY{jK8Pvbg=F?2N+C<X!}}nPt@!o9O6WT|9j`4T
zr5Xt`$~v^EE>s%*P?6M2dmL5%E2zL}Jo*`KCUl4g5zy6h@uPziL1Z2|19jzSfuSt3
z88o+<fM-h%onI{Yu<;JJC+RUBpI-^z!n|0<4{n9c^k&?KYo?FEf~Ebdawat<q{5ra
zeWH4YRPyIV{r7OthxASIjj{24%1>XdgiIAHkDYFB!trq{T&vyq$w6=O4XtqTt#0pB
zdM%hEM#*h?HI&v%_M}Z&3r#-KV)gZlhVPB>e__i#m=J{s#ZATIaEt%x50qi%B@hpK
zKA_0R!)bwcekbVT=72SI-`VRlZXc^u8LP!ir5{)>-y9aeEVV6=j4n0&AR{HuQM)K(
z1O3R439c<{^OtyIQlsGko%YbI6#v<kdrkBn_?4r{)R1EKrv3A9uL?URwpMn#D4cvO
z$;|~1<WKuRxf9c{UPkWQ5fwD8JjBh)GEMfLaL4j6M~sQhKpk}ndZgOJf}M8D(}wrB
zGE3yOA9hL07b@kDmAC@cxJR~9k(Yl=w>3So2I~uevGe;O85oQxS(vh)tX}@G>FML6
za$Bgl9!gK|y?f|lz+B;Bidpj5uY5GfN`BiH#<RJ2n|gEqMoebhU;O8f-IOW0!|tt!
z$6NN735NXSJgxIOlLAZHw~=<F)@3_3#g4>i5aN_EUB71+zVE=dFPJD$Jq9>i`tAD)
zK4Z{MOB3dlX2qUH6K`sbzbzrt-z;@T|87s37Ab$S@4^I4dPyg3`9@q{J{Q%XOMD0p
zi?MPW=4fr8oJV^}Ye4({7c<X_Mkg5R&B!;K;JDP1G<yMcaW!Mqq8Z)&2G&m#ejGOv
zA3J(C5YpKH;-&n0bBpuJ9GQ2}T>XklIk7swa9)tH+UraknK(gUJ*w$lFy}IGXNl3I
ziX6RZ*o%ySKX=TUfO8f4cq=Om;ByY%CG|h@CB1-h#~h7TP3_c@JZIdN8cS*6n3z3Q
z;?4aZB&+}5II;&F$qXJ~H2WdokTJEo)$p-&ZR_;4z4>Y}$bsEq69F4yl}lRh=nH^W
z|7q1*-+cM~`Q%JMLew+h^{??<5VPu?;miUC-y6*5dS8$S_Bof~jQDa}&Ij6#me0Tb
z68_;ypZScmmbz@B@i`}IN(3(Q+cl{OKkL@hLcq@rS-zH-UlY1IOTRVM<socJoR(`M
zoo?F3jlO^U*Wr^zT|?e<0n`8CJcYJX^ygl~{{n__h=(IwO(i{DmFi{x9r834lzeT{
znBG~_#}3mwSmBIHNkGKw>Pb@4#Tn?eW|ae%N1oaNIlh5nj4UG|Q<&+>v}8Ycvhq0h
zlau=PnqEZ#MrRRYK2=DPp*LoXY>8MC&(BV5Dx8*YWB`VRjUf$+yfs)G16G31KSiL;
z^PrqZ@}JglUVjK6hSh=_-=yi<V=%VV=`t3idHxcMKKtYV<u#Ry-7l1|iK>wpB}5P#
zSrSO$oF%knw-_}#q;BGg9TD?<EaK9feyq#3fhnGg==^qfmmtMfEce-=k)a`Y0+ERE
zRRb;na4SLZ0+F->(I64FuvU73GCOT|cZ3Kq??xd*t%EIglP{`oj^^X2)o_$8b#xt$
zgxRHKN}X)|RQIr~@1QvRpp05hc9m3~8J&F)76!%#=lPSmzjxC?H^j+3@C*I=s2m*I
z{hrj}gQsC%sNU=Y3-yf3AKOs!yOnV}Df=cR@<#p|A)!5@U46#-wYyY}I7@JD+7%%O
zzr#}?`q3ZW*jn!0akW&3VrCx}I~;Vz1t1)y9NHCeAI*14LIt94hzM@(hyE7ZekVVI
zqgVUmV!$W_Hqh<^Kse#t*98y&UNAFBSo@}Q#27B#K89#~OB<t>HzZk05E=C{Y1EP;
z6%Q2s3^{Q!Ff|#HewXa0nT!l)?}ia3F8N%|9#5lQ`A?_eTzMwo$In?f{d_E2Iw~kD
zAG{TEgq|9dkO&!zjgA_P3O6k6!HQ_Z_{9C{x~Oq3oC7T5a~`zF+5pr^L<c-Ls1KX(
z2YlUaM8Y<v8IHv+n%*gN>cJ<D=wXmSvD{_IRsP1lEu`ApJR!+|-v*?_u}BK14fku>
zP!}lf<7gDNcjofJ?6*1TvtUGU`b>$VNK02gjJz@CwSvmepN6X<zcap<!lt`6O=-M}
z*OL0P17dSFoKgU{+|-F88(hXkTH^30b`whby&9>*Y&6@3(6duLs<e&f4I4h2imOPG
zlH}Xu0iKwGrO;UJTBMQd+mv0w*XgZEs{kQv&w3mWWZNM`F1{8x15yoZAODPIsbN6L
z4YpoGkQu6}JpU~6mxTN0q$3w9-o=m%l+EbyaE#Sq@_Z&oChob2J#ftdAKL<>)1Kz<
zV8PZ9lJ-Pz>sch}h1qKdhBh(D?R(w{HJorQ`X*uINOCf^;SDD}d|>|X2CbVgFrrq2
z=~vd#nwKyYzv%0Ev`h)QcbbcRH|M?Fg5feW`BJwq8Ps+;qTGBk?oTT2)O}9oZ`+!}
zEDApzNB-bWe-yGI=smvuc$X`{1?98S=mXST^O=A<(YGAQhsYZf&O5ng-vrpNCpMOT
z#>AzgeZFOdsSCs=2mGKWMQNGFL4v7^rF{YC9Ozd|gL0+nqnwV`XrHH7Zeyz+bFOr_
z3?yyp`hK|=j?BfXHDab20S*mFTS-2m(*HOzVEKwIfe@BP8IjugTO@PR`iV4WQye_P
zvm5_mQiW!|=_^AUrTp8vu->lhxEiFCu_aOqCKuyAek;9X0&~##0vZaOx&OB%u63aC
z!Sal2l+@gw_g6VfD<ldpeLS-QuRx|ql~c`dan3SRe|4l<%zqM)Qz1$tdw7EE?`@sF
zBz@CY`m|JhW}H+>25iH%du=ZceSAa-ZFx+=zQuhodqfRZql)<>kb-u9zM(_Nn$jOx
zDQcah;t*{jfO-~(au%{3Q;^xeu1``A#+Cf?EM&z?qrLiQ3B(@ozS35~^!+uN=WRP-
zG^`)m6?r(s)IiC3c7{ZwU4Ccue--P~>q-J3)iEh%Ur$)pzGc%;3w5<m-P{__A%d!N
zHE^iHZK0%1u*5-wu&;~7fmO=3WY7con6kFUUz<+RY{%dgi`5nK0!hBygsOqqg60k%
zz18dTw4?&c44D;)1mVynG#$5;spQ@4+ks`{BNzRiU=y5~9U*wg><gD+D*)6=@p~xP
z?-~H5goDz)cM^|sotWMET&HpShSUVe=L12iMv^38`5BG2k1x48`ZgO>S<{RoR?09l
zBa<%6KcX!n`RWYF5=^cl=%OnUe9ZQO@~1*NAL;x1-kp9QL4A9@eWDE<euv2K^}>%&
z&j*a1!kdEhYG+A1ibc?rw!IPyY(D)Gq+At!pS}vXBFxP!qNj&5g4e~@kSCW`@D(LG
zVcmZpk*LZej8;k+u*<~85+T~!6BTL+r~izY#U{fJ2v|Pq3ws-mjkQ6HCBOI0@<$1W
zg})`<(lZ&NHhv#Srqq}6+gY%5EI&`@wGg2|27CyA(zRf6tnz4+Pg!*l^u&96{s-pd
zyPnr^e_<Xsi!R$(|ML|9M444+aDvX=ugmXJhcicBm|;##gt##9208cWtKlAo5aB2K
zel1;IRIM{)&;k-#Shq@Bl126&V8b@005X#}_x{sMU*rO-5Ta`h_~7Ff94K}bd-4xv
z{}zn3T71b*RUy#A-`15j?>k=5cssxyfL&x&Bq*>6m)xv&_j#3ldUsVo-?-N&YHIVI
zA-tX#5Da-}6?i8u8Vz474p6=IY0pdg8nE1fdgDNdIa?uJ%~Mnqh{_<`pQS7wF^+-&
zvO#A@;DllO)`HS}I65jS+17bTWmX*&eUzS5@+~DO|Ch>BbIo5afDvqVYc>wH<Yfqh
z{&^1XZSO95?8vEX{)b3xzHnLO*CvHtRbj@tA-;|Xceb!h_b+gAhI`BU%3Pk6qm!ar
zfinlxea5v^@;Dz3JgxEQg_npI_&1f&<SH_l!*=a{>Vk8O72bMM!6Cn&`Y{G9+w|0P
z5jhc##omF&np^x(h<uswcfPYdFJ(Q-Fdsifs%_17lK^a}1B_NYfw~kfWh7{lkFQE2
zuYss28Iy0jXa>J0eK&lUgBc=p<yO}Qw$!PD@MiDkb$+#SH*;BS;i-+lUYYd7EQYcp
z$FRR8-X>)p2z)z&w3<!?oAD<-{W7Y^Xzx`TV+9U0xc?LSF?xk5tv^cN%lJV#Vhjp$
zv8aniKo<U$<#144kbNVi6j{@Ejek9<i#N?;d2_Y9?6xJ@V~pekM4uV52?}M8NTo$M
z|AC%KCgVWeyS)?Ad7DXsja(QVDwv#lsJo7(hdX&fC$>)+%FNEiQ#ZI_75+gcL$o8D
z4Pi9`C_G)C{46&X0(gkO3R<StR43a=BU7oIg$iyiO1VMs8w7alhvBk|Fw{y3s4C!_
z4h<0zD%%7no#`mFK(#vWEbbft_6}k;<NGE{Lg)&wOb-n5hrH`(-_+!8t&lf9u+Qz?
zuQPeBtB3jTu)IawN2sJwEM4waMT$gJvpOFLRd_uI1n6RXNiPrmw1e+$E3_?CvRiL|
zWyCAU!B%A^Z@<G~TcU?+69bQpbFb4;+gaul44acn2blC)7`8((CLtdp+OvB#zdJJ<
zNX&kNDAOJ+(jD5ck!+B8?|3&EI_#c|y?dRYcyUG;+Ku1;^su|=w#29{L@Fv6J|h!(
zH%UTmn-y>MN1}W9>6!j+<*<Yv4@ZNSpHmolYhVx&fjU_ir1E(2OvCXpU^rPZRf+|r
z@;AU3KjHt7F7n?a@J>Y}GuW`@W$z#RtqjFysb=rpx&l}4fm|Pa7T5fl+3#(Yupz=W
zM0(zEBRP&ww!m}*-Z{0i@444Tmo1C}63*&wHTC&So3GCd3~!#b6sPPM#bHReX>~?*
z#NcwuwpH9i!pkXPx$TO6tUD0$`<KT1p%xuSM|PzERyZiPpjjYFKx?{|Se;aN#zaxp
zrxpP8?*u*X$AZO&z>s6}lQ-8*>02i5f%o|tw%Etd*br`E$#fqf$+M>Eyw%pVz-jT*
zEc<+t9I4<RZ=VSPK;=&)FS`q{X)L(l5FEo28#jDC-7IIw+9cvNA<&(522MEo<J-?l
zd1i6mU{o+lJ{F+*Bx2UHZ6EM_5lbzMJyNHH@_WcZm}|so*>64DKQsI(jv#MFv-9HK
zunkM@`{7_`H)Vgd;7&Nlf1~UzgW`z4cEQ0lxCRRj!QEki00}M$5D4zUVQ?EfcyNay
z1b27W;O?%2yW7tHz4z|!m)-l`k5koEQ`OzS)8{<r5stBTH$**T(#z>P-OgawEu0pn
z{L8EdSY|WD&0LgfGxGVPy>eF`W1-6l3nD7hdNfXJ5h>&VD#Pf1KDlWJ5@CZ*l;nIX
z{$P)TYCLp~Mch@KKy{IBVC-v7spSeck=qkU!k2jPRS_8K<HX$<o@h<Xr6RZMwF&>n
z1ML%6w@he%E|qW4#iTywVfDmh5s#$Y$W{_9!*tH@jN*71LTL!=77GR}(yaHG+$bgd
zUA_e(kb_+ohhZm|K~S8NA6caWV|9emP#r(A*!*{ahQ(k<Q0IFJk-+b!hM^%?6SOcP
zR}4JFY{jo>3Eg_W>rlyjxU7EZP`ZKrnGpq&$9J%13zD37A*aRPc7Gd%!*rR=8Duqf
zvBO&TaU;GG7v98WC>n&}ig`Cz_b)@R%|ApI<snIfdD9{|007cMZp*{RTd_J*?bN)b
z?r|Jm-KC@X_X6Bo(^NeahW=c~ZW#>{w?_Ke{r4aGz?Yx&qV;$jlPLhmo&0UM%9l+!
zP}esy5{R_6%BUCr)0wgthb%Joq;0C*c2W8-#(BqVL#XVR%g54s@|>DQUi4jVI_K5=
zp?<DMRMDvyr$X#iVR5;?KA$b{QFlHv4JuBM9MFx}UZ)=*XBrGlT`IB4%~#1=3VmDk
zE?+<ZQuP4FHC%iV%$f&f<43q-zfk`$^-*fREgn(jk5En2ie;nQ9H0GNWCP#GO>uUF
zWlkd)B;fl*-5SjhIc#9$<BM#t9@9f?i-Ih+&^VQnNlI22Iy49&vqedeZ!QyQt&Gmf
zx$;Ddnn)f*I-^1b*WcXc_WTCcbUr;@VpfB+Ili2Z9I~&eC{Ix9Oo>H08KZ5sG{j=@
zlzfUm=WnRsUxt`^F+l+ww(H`)$U4ZPA6%jqd6%$e@&XVKxznZSW8S+IC!rUr5BHxA
z)S_TtqV3g6I=x#SRkSe3TvQT+-iinYgx&QY*tJD(2)yB2!=Ti-XeVK9uT7yxEM#O9
z&eN~mIm!JjF&wi$f|Qrts*W*m7wA6?1Lk--B*OIN5H1&4P@SHg4}9NSS2-O$$U6N?
zwpxK^lXot6NMJG|ETRi=bo#A_9t|S}#d-03A4HvIiIhgP4|O~pr8aNhc))25p3S4r
z=xBlS17YC!KDUc6;;EGE)53U~fsx-o@`AkTxlQ7xR|DI{8JkyKK}(pN#UAYm7=!ku
zxZ>>*^acQpSKf-;OY>lLFVS}Zw(tK*_@R`;rik%E7K7I9QFHX++@SoH-%%|;_cenC
z{NstnionxEhX4CA-T3zMt+WDBt&qj=ydDnfFC9-(+Yi3R^KPi1t?lkaHg~WhX*MGB
zh&QZ56Pt4(AaQp%8ookheT=mT`F+wEHk#|<c(OF7R<upByl37S6ou1>=KA`Q^A;6j
z$VEtf_eS-}qT=l%oMmtk@#AR?3FGIN2O-+XybtAX2V^6ck2*$aNr3?~>7#VMX#YK`
z-~X)Lf6-f20Xp!Wd2jU}Dl%12G^{P!Y>ks$#Nfg8R#tnx$tO{5SO#A8wR)p_p(h8U
zdAET*PaXSJK={CKKbgdOCbC~LPRBzJUakIIrSE)g&`7&^f0)Sa)NVz`{tWl+jlA{-
zo#0(NbkFr?X+bY>&rlZig0dfCphbd9;X}1Hytu1;jb`37$@CW<K3B&>ks0X{#K^zf
zD>698>*Fs2ReGy?0n5X0y}XhPLV7KGCLYhbcBpQ182=#%{;oI<)gl68u};BxqNm=F
z#JAx`L&!3RK5=S01(*~+B2z~?m4iJqnNPp@aNb}^;KL|EqL?NQ-UMfUqR7OX>oYg@
z8|k{e@BAopKxMNMb~i5A8QR<dJmGfNlZ$s{>sbLB*>bOk$*3b0TbkNY#kQ!SYr>)8
zQbU;!oRMiCzn)_Kg%xwBS9os)wfkyUl1EvGTOKqBdyZ2&WOfVB4w>vTvxw0hrEGQs
z3ce2mD0SAd?>CMw@>>zCC2X;=oKR!)-Bw^78QZ>O2Y8wmQqeA9Qalea;V=!+{rNnJ
zG~Uq~VC9Et6d=~u92-4sB6zDt2EP5t4O_8imHnwj3bLgT)QA)yv+8{*NojII@$Ke}
zEv87yvDgN*2@cFG@ge<Ge{_*LEw{sN_0e;1Ni&?q|5Y?~Alx4Cp}{Zv)G?<Oi*JA#
z6Z38(UITPH(m(;(KLAkBtG4!3G{E7Pg*|zKJ?H;0?|dHM9KKttMq|Q`e7F6=0i7!P
zM<Z|8z6;1KrF{e=)Yj?+93pm%hz)S@3P%b=3r(s(l$Eu*Cx-CK^)kA*<Wnkr-aQ~w
zC>{WO&L8hivr;^{k@S54o*k4^4~0Qtl18g0a+|fqh86d}%?!I#;3p7wchH;X(@!d0
zyo`95jf&)SdYUYA)BQ<=BL&g&xqm4N0?+23JEnMPO-T~AT%)({V+AIxOQnb(P`W2&
zeqiobB_)HGUxJl8n(atzEI50CJ#LSDmH)QRpYk_gvz#127=s7IVEzGm*kk>|4&pWW
zT%HxmQ5&TDkET0M3Fv|WKHYn{zqcl-#($-^Nsiz!5$D99l6;%}5!Oj@MvwW+ND&ZO
z%{xFSLx-kL+(53h%YaP6t!;jZv-a|$dyeB^yYkATX`X+vZA?@W7D_Sjx*eCl3@KPs
zD!kpX;7ohyt-ByZ&tU{WqSTNDN2#68XyQN{qiQ`N&B^SOXWc`XIOUQwBf;N-%6;W5
z4!$Lzx=s;z)mT0(|4(Yc=B-d%n0N3qE!=V0jc@8Yw+!)_eLPgm3EtxEi3~bHUnvRj
zd^z<+u{>Cmi^f_jd5ZP}Z^jxaHh+b3%a3)&uqYuL2gMq6gvlWPd2z@d7ReC2;~3aD
zWXg5F63qn9J2Dmni|IoB7rE{`Lx0F)Jb_UPUYD60Pi)o?hPAW5(*QH+nb`cFL}bdH
zxgAcK`lHFah_k7>K3m{M?VfSE-BG?eaDjz{gCt^{9K;0f%xkE$xI485s&dzWp|)+f
zdst+vS*y@vQ0L+-9LqqeCtr<W!htB|a;GdOxXuhY3n}-U=QnkmOIuY`7BV<#@<cD+
z7}zuDsOWpitXE4)_q#Rfhaoa7dF)pZ>AAM~?|>qzq%LPD#jT-DMyfiVbK~2-M3+Pj
z*xi58ShPR~Ya%eTpUW@?LfI5};OC9B?$i9OX0$j&a-rW3<7^X`Tw+X5X>@Ds?Eyja
zY?OKo7_fCJA$NY1oTul1>vBXQ6!>rb1-tQwJXHG4|Nc43fF8g$-;z_^7Q$8EV=v*_
zv-HdOcDTd%bq(Hp+ND=M#=Cn-)Ul7_e@nXle{gIme}h1H4mbeYgI}Eiv&6lz$5Gx)
z;QHq+`O2EFuI-69hx~xDyyZgMVK`5lVYoDoL_a+6T9K7~U;5RZPg~7q=9!sy6^j5D
zTgx2|W`RVoEPOH{Xq0B6wPgmCEm@t5ASwTM%c~o2k2pgPeL{VcYG9()gNibvl^De!
z=w*8%rBv1OFL8Vex>c`vTlB|yjunxZrAHcS2&R#}u&G#O$CHK4Y)#GEiBL@Xp87HX
z<PQK<A^`^u0D3DRaMGd2%-qtldv$gk0w~Isaeff>$_g@biqw@|%3pOo{qg(|7Hi14
z^KIcb3#r40rs)e-yEyfYCasDKfy@ut%m6l_x1yF!QqmqF_(7jr;e-<6DrJi`sxw<d
zzPQld&o)<|p2(DCe@jmW`ohng`8twkHj}F-!{7?LFz~zI)3~Z>-WarslRnid5q2iH
zqw*xyhz1<54k!`rtZ|6HPNZ`MuNH+G4@4Ilp9Bz-y&LQEW%GI>{yA6lESm(?G|LwZ
zaGHC6`J~ZGna;4_`N-+}h+0~VS*)>g+TBeF@T?pNZyzEzz2Sz3QqSZ`Rq#it2NkVW
zC>dF~AZ)gxH?MJ#d%WRedW@WZ&5w;ibg&f<Q#Bqwu)pfet2e|*#PBfP0-du0^70YN
zH!YBWPiQ~{B;@Qu7i7zaafm>t%}Kzh*e44q7UUKW`M>j3?l;`a1tE}I#1+I|38CSc
zgP?GZw+HS$BA9VOovZH=(cIy?#cUqSoewwc97vT?C|wDrD$OmQ0kwaK*Dj1&?~o{z
z`Gjnq@4uC_oiY6Ub&4~eZq59li(-BE0a>LjtV^62xz3||MYJFic_$9HH=i9h$e^Df
zP@BdB{#E7c+i50#cJ|l*h$%3^Nh~g{cgsdD3zKJcT@WVPmilnfcexlKDL&m15@#+!
zDZqq^CwjZ_umtQWMyaFaq_sgWaX|E7k0q%}@w0)%2M<<T98me3nh{m8>V^2UP(W^O
z!Gv{TS4wM;AqZ~0g0V7<x!z?388UEw8-{<*eGwt-fsu0#&qIs2sbHqMA^2x*=X3TQ
z36emC>50<X{71yl2fva*0wQ5}FD~zU9P!6w9;ne=;PI}6@xdA|dj%2h=Mxu1yNa92
zYzb^|ePfHE=GdQFuD}~Fw}W$XNtuA!Z-@?214akAPn-xp2{2`U>A#UtI1wKdk9KCB
ztUlGjPsAm8&v9~Z2Rj4!$tc1OH0|lC*fY7NIzowy;K(rLM<H=&)Um~#*@xi1<xscR
z1Ds~)-}I(O+CMq0ngr6SX`>`g6Kz8AeaBIBpEpg8uQZ_50y+AvOHSeKoHB0b&^5=2
zVfZ0&*e$!+MlYkFK<sWo8^7c1kyUYHB&X0xA@n{hBl?{i;rCIJanBObG5P{86`p%h
zH2i@aT?TpT!n4#)k4Xg$I9xX}WSUQVmy;`ab3ih3NXO6qO1Qabh4=?kYD9}90l1)d
z613z_AcpzL{UqKIYG#Dk@wAS*))6zyH1KCE9>$^{9-;SXW+r$RaJ)H7uIdIfiq<6a
z3ck*{wxOKCJoK+}$d;DS_g?ScJ~*6F29l8to{+7#v7S5@|A%?ZbCQB(bbT)9d-cF6
zoX7>^1Tex}cpLFcE=f(-1)nyF8&X*Qk4WipEHJ+B>bu%?QjaILyZ>rD6YC4y+LOsr
zE>qc^(sF1y$vrTN%U@S@7hZoT51^g1<}`v(`0_s`_4TlkNYyuCm(4?;Cu?0K#l7K|
zUeQSOe7s4QtMp)=9(C?GeZlF4h<mCrWx1&Z2n)Bbw(L!B_w_6bi*L8314_<Cu>PtY
z4Ol@4{Y4K;K>A`Zi4DU9DX8@o3L4~UvlS%)H>ASAcqbZDTiIkcg3xu}bU-Dp*p1AN
z6icJ81z~#~B6lCUyt<Bik%XlXw1`Ay5-jB;ZTDXF=k-KRH1PNgs{y>Q5X?~}k8;pb
z^*+vt`1%x|gp#bstH5*fz_9oMCzB0L+s|(_Chvy(f`u#t5BPi_0zEAR@;}i_DU>u;
z7fZ)?&KHfRz-M7O>_u5GXzO%7h=BSq6;xB+mFGBSyxx;HE13<R`h9Wm<N&Om&EyI=
z6ZY8<X?RF6<|~s^oPw)l8&k_8N)(aA@kerp2xea_B)WkWXtbB#cSt8LwnzC`D<;EY
z*eBw0P2*4R)PG^Tq<XAG5g|@ne(p?15JMas_m(YCw0<|#SAnaq-%Fn#ZJ==KJY*ve
z$L%s$t31dyP#6K*!!5)42nD43iN^Fj0Hog0haa<i<3>(abw&$POU<afZV%bKfXfhD
zMAP64>U^l!yt3em$z@|4QCTw`y8TJu23r=w!m6!h;MraBTaynr_2<%7-Vo+mcsl}8
zYl*B*BffBiwyMcc)8?7Yb8_aRWL4p|Ds8M<u|gcSbxYYM!g#;R@(%DMf7Oc@S^K~=
z^A(yi(=u^F(S0$G-D9REO?f#fll~n!qepe9gp(m3=Za(d@>*Du1&wL{f!DM0kshoi
z%zu#0qyn>efl#3UomsoZRq}TEex3yP*aZ~CLw*P;$xZN?$|H(Wm{hvy=m2=jT!Rs=
z<Fi95Cf=){0~M%4KWf|1Ldjl9r1@#FSk7qEwY%q?OSFF#EUe3aW(g!glN50;kBaj9
zMO}i7FiZApfarWy9Vg<SO$*fu0<Z%)CTrs-)ayR*>YghlM52Y*)F<JbJ1@$vQW_D$
zc(K^Q-6@+bxfS}>yR}OCLyyHMsyq*cMFJmu`p3)p3OPLX>0E__8eggY$ul@mIvM8g
zlM5B$!Aum5z8{sKZfgdU2RaO4zFH+4@Box#GvO3Imf^lHL)PJYqF&R@E65#X{2R*a
z4_Z-I{m66m^^$3xcf?zA&}}5b?ac~LSsE^ESi+E2Q?_xNkEEGga84IUOF3}khbVZ;
zX?#9CeY_8N8FE3~_Yw3H83VG&dLDn|ZVqLM1Qk${_a0SX|Cv{p<pGiTn^CcII<QxE
z4OZ@}W?_Q!O{yoc;+@G?eGo{fE;^@egL_KBA>TDWrXo&VF#U<;LkyHGt-vjgv4F<u
z6-4XqPrnAnl^Y-lw-#*roULyfIVe^fi<oNJZ*(_IgB)YTK;AS0Siqw#_p1f2R%Omb
z#Si=rn<Ae`?~@^94vu6S`|bwH1yFyr$PPC|;qRyyS8oDyr>or=*|s(klkkuy6p=|<
ziI~VU;juR#^pfF8*NH#*DCj*$PzhH8`)50HWHX!+zZV14l}xD*`r8Y>XO90Vj;4Ux
zNVtEX%TtHWL5Ofo2rT$yijXEW*6$4}eof>l!Uru`mu5d4*iA*G7+v0X&ebuk1ipWe
zBCHY}82H!>Q7C`#H1CMh(fkKcv8D1PHN1aJ*P9TS)_%M|p7WM8_caP3ME1-5F8u}l
zS0w%KabmTdz^T`1nf?vJCL?m%P=@oxGltDM2Aqf280}Vph@(yPfJM2Glv9b#-rD~o
zRe(Zirvd<|z%g{&j+l^t+itj)w$!o`U9P*X;Ot5cDT@Jt*V>*>qio04Up?Poz7Gu@
z>uGDL)D4qdKac5Zd*pIX(u3kSkf=1n$*g~^w**{X5+o?*vW@5IIQ+0)96hAFFE@fI
zE%-XWwrp2MS1Pw08O`QoDM1t~%c}W94=?q2r>Zh{QCG!UZT{z9=se9Q=O0+Ib-`V=
z0H7pr&?%UP$u$vs{TzQhksNXagC2iw0$zF_#YzYf0WXnomfd8vG9gtp*ryi)T-=9U
zVUki6O7PtgSE!}sUBrqsN$j}rvG|s=z&rt5PD`oz&k*&b>AK{io~JhVvn$7i+3%k^
z-bCP_^eY9l4yFBIOdknRgh0WoJ<cC6TOn419%0GU^mg8WFQgT$7%Padh{#KJPgcG{
zq7JDPz%_j~vde%zKv=f(p?eialLil98|>_WSs?z$x%NU0MjwV<@>j~bu@Z5I&n|M3
zw5CEMLRnb80AaY%(*-W)4_w-2!=%Jc|Ir#ZZyx9AdRk94N3Rd-hhfZfr95PGp-kK`
zf>~>`08K=bVm!k-3~)Uk<iaOraEQCSi~vW`KAyEq0kT+FH)mV8$dMjx^xN|c4wBrB
zI{dD%1l5}-0$i#uodocdHVYjS5A&}wYIQ76mZOxu?_S@~{j%ljfk%-g>3!dhfkodn
zq5uN?4ZJe0_UA3*{C3Ih?@4<3&K%|UKkTn(hw=nGyZVEXnvu86ImI|x>3V-zjFArB
zQ{W#gy!7u^<c?4NHMyt%1l{oV;gZ(s`ba^v8&q!{G#2sOnt~H&<reF9V+4`9+=;wq
zJ|9<!rw6$22y(&iJY<=e6b3I7+fCw%23r>46TwTM6m{q@Abv7K62AnAmBPw10<gwD
zA>dPFl5%sYml4-gSp&%@e>l^UP0UL}g9Sb;MoFcA|DkNFxKXwXTZ=IRR*}<fqtzlK
zJ7OdQM%NCN=u9H+J(+`c*(#fMd6$v%+Iq4L-SHE~=!q@_0;aBXA=mr>vG9gyDw&3Q
z@a3Vvc_@)1pXR5^$~)g{rqyM@HL5HW@UqxJDc2w#wE(jjEHHO4YYVy=xq^d;2rEr!
zapaKX@tl@s|E8`Pb|^4I7g=>2a9<~remgR09iac+c!MGg9H&k9asgP9p3QRy$6aKF
zYvNHo?A1)<X4@}~7pjAa{#J#IbXG|VJTju(!cVBx=WH@vW3gZ<06;Why6Y%vniIH>
zHPaB>2N;YJ=hdkA@0b8l*;bU;<zp6h9szoj=oV=+-L%iWM?xUNM4Yh`h%-WV{UU}_
zm@9nyB}k9Z%5;tx=lY4Og<R4ykkh8<bAd%bX&;_^;>VvY8Ix3^`2`4&#5pw*l=jYz
zDh={+j}0d#)nE3IjPZudg$86^?jpa5X|xs8_*{g<UfuzpH)73vJ7dqLpyJ&+BEZST
z5^3W-_FsCyW6Sq@t)-1R#odq}e&{}O(c4je;_&fli(0R@9hERinoDlLS0iibbh+EO
z+M_NwsB24FhW<6T#%$*XfFVO3bhu2K_7yR=?wRaYmTGN#tZdx~0IX>C^jx|}!xVCA
zEcCn6jH+gnBvbHd?*jsL8EDzuGW>6-6iS;UN_ytDU-#I9HeRsk(>Hl7YfjYKSV^1N
z&{T!_${ku!l|s>$6P&fVZ~Yf7KL*70;URv0DF6_9EEPS#6Kg&Y=Djz*@9A;=Oz8aI
z(pCSj5kD&rzJeEEJDuP#lh?Jstw&Oimr(NUV5G0X{ApcZg0sypgzll-qeZ-aPhom0
z!m*uIt2y=Z_TFm(lhS|bFhI&;Wm*4kT3+(@!wr3JxliEXkWb;2BNK}{`pIZ`!%=|(
zBSq{-S+cKfxs?>Y2*O$hWC?31^a2mYRcT?lt^6@VBZM=?lI`GR{c=00?WZJr`=4IY
z>FH|{ZFNT(9Y-uyFfE`?zPgFOvWZ`+&Ol}zIYq`-CUk(OLao*%jL(qG2UrzXnvs=)
z*NcZ1<gQ!Gc}<$cOJ<?bW=EQ^#Yu8&<!^Ik`k)~)@hZ};F#%JtKO`0zbIk=u+hL2}
zkD?wUIs~r!1tzA_D;69sFezY76D?#YcYpP%gccVfpVCr>83uzv#Y_*Ssk(scu$VQu
ziZZOWGwV-DS`NNyApuoXp=+M_Yn1paitBpHAzUqK-Lmpd-+4N>PP+yj;XA`I<u&|z
zmZtE^%lK65F^&F*yc!4G{_FmbroBn&SIGf{cIAkK^ss+YzggQNpwaI^*r*@xkIt>*
zYMY?f3|32hz{t{jJdkW;KAMQug8j#@yk0CoO;qZ1YD-1pJ{vWsMwt3>y&s%jxr3a!
zM<Y3cOQgJW7w|5Q#e|+rGI|5_ga3=gPF5SBmLvL|w7`rx{$ptnKTO!%3xaZsNnYxM
znkh&qj=<sI+oe3Js_L{}<0h*9HR{%fG1O+ZV^@TT&oT#0pOeRIs8KxlLTrjcRQuqA
z<xygGFK&>#K^2-*A&a}+i(mNs&)>mQ&Tn2#HkI4Z%!qy(I2S+*C)q50Two{DzTU?f
zpL$SJlg;|@HOR+FV;*ULQebj@+22vD2Jw@3qq`Yg2^Z<%oHUf;eJ7d4kIKP#)V0P>
za;GjMvQWGe!<HJ~v)sdRbDZ0OSa}VV`cD1C<^9_G2Ux@#OsfgteFEksoyNIpTZJv{
z(~pcB1{hnWf`5|dD84gGBt#YtZ_b1%uAUcf4UEDVksx_bp|Mz7v?(dx*!mIZZG9!b
zY|njnBRZ3Z?86z}feATvLnnCdNo7yWGbToJQhxL&x6Y5*(k;Jiz$(Un(I5OH;J!5F
zb>M^b`^&x}ZBB`AT;M9vXe<oAU>oiHLIh?5V~k*^*!yHy0d56Y)&!1~Ct@&t0bH*L
zb32+R8Ck(i6sv)*alzsuk`_CNaSd<rSQA%+J7_Ro#wvS<If|vZ{{pB!5x7lZu{<h>
zqG9mAya1%1!VH$j>gh?h=tX#Jt~WFNgoD^Ma8pYpXz)H86?It%A=kVE5lwFRcv*#;
zAa(!2?+`;`L`a{B(8A5o?GG-Z<KZD65qf5HJs^HKv;sh1@u^H~j4>-b_$r5|KUd&_
z^}lz$>~aRENv$A4t`H#@dEDc)Qai1te~%flIaE-9B`4dQQLjA6F&VvN6>fiqX{3{|
zx@Dr%|5lCU)+fiXe{g*p$5hS;w9i~Sk5&RSucN!&Si?^UIJ}}TJ8-Qn>7`D|oZp&a
zfPG&KqA$q9Y3>sdf$Lr90|j4@FWNHld{%{J#|$ss-VoT$!IPn{2p11zjgIk>VL2;%
zb_y>vfsZSJ=j3mI9@-v3ML=_ezx>oXTEb5@y$-gC;++ZpBDS}&*fA|#Qro}iA5(GA
zj~XgJwT*G4lO#a<n;PUeXY2$0zm=dth6!{mLGMAJLLC5zIZ-Cep>?Kj<~>N<p3`!?
zA*e;-M?W3{_B<-kf)W6sM}cxh!gLm+XE5zH1McgqiuMP9PYrCxUR@vfH;(E5h#!pd
zZG#@Bg*!VWGHbcBEwI5~OC*oYtG?4c;9H&}w|Y@RvHVttG)ZwXw|VtNK-R{y+Zlur
zx0Y|0ST<UhFH~jkDZ#T6kkK%g=zFHGuRK5t-&LH23mx~Cy4!agMEf{|dUC?9)J!s8
z@@?mZ=d=C;UR|ds@4IGKr&nbk5yJWJ_TR^d{Z8SuV>&SO?r?HGm|+0dG&m?E(!aHH
zGFYlLyTR2B{v^9k${3_%LQHYv@3I%FvS=2w9v_*zYavp{0mE9`Em=yx_LG53AQ9Pj
zq;NvvyecQFe`T7Bk8O2iEkCVB<J#AYeec|KPuSS#gn;wVLWcQ42$zED*JY#PZ~pfe
zD+I8e83zJz_`t4oCe6?ll-uG*(ALI&-EwehF(cL0iH=mk+!R?ftBci77@%b&ygzEl
zm(uffLD{_-h00eL2oMhLY<L6Po0IZ@!Xgt<X>e$Mt2dGfW2z2&(8H+q(d^U)RxlL+
zg5g+~Bl*+$f7CkKbL}!94_t{6VjOGGA7@o3oZF4x^I&!<R2SwBP@vXFf15m=cbQ)T
z)mLH$Py7rWjYt~;TQzNao&ZoJ_=%t<9v!F+0?3oHyNHL@ffSYdzMMPnM!38JUZ(CH
z!uHgK2pYb%;nb9m+F|Je>C6!*S^+usQl+coeP?DOD~(kV)o%dQG2`KwBJy3!#;5l`
zg+Eyw1ZXcNW3<G*%f+Gd#$(<v??sR<aK;9l=;lgin!vlNP$@^ca=SFZef;8etNQLA
zQf-!8P4~>PHA|zL5Av%^fRzizwH=473O7abe3UOwtdlTEt3+{>P4alts(Z;}MZty3
z)`wW%q)jZQNFYTscgh95EfBFFx;Q8A=w!x?xT>-;x-I}-NrB@>E+d!VOiYiDFer_{
z^6OFI6jF7Zfyv`N$?3}2pW-T`t&?r&aiMfOsBSmX$0W7VImAt=jzVt@m)v)o*Ym_l
zJI)P9kNSg;8^T2zVP@(2)33*QO)bZ#CGMDPs{s#T93;G5=KnnSTo{pw4hWbu%n^A7
zkn<zcX_L@tDqbvMo6u%Sw=aDFTEf)k8X0aCryn`+0Y0e8--s6TD$sx&oBXQ}w0SSN
zn{u^?fk~!AzL=A6kJEl$6m8}KGs&+KtgD$_NPf6*$O06lpYPn71zWItJT7@iM#<Cd
zy@REo;@$qdFcErH!{_--c;S7z<IvZr?O1*o)(@<p0D#AA;3x77!~kpuz{>cs`Ya`j
zWygR_tTsef@pc=L<?<j$$D~Ck!7)KOz}##XAUb^?H_f2u<Tp7Q{FJOx=6F8(4v(;)
zdxyl!lZL~xhg@cRq)Yb=aX}5a#AhQ}4g(=U0NaU3_NpRQGf;(__8$&IzbMqrrBk-V
zfF5D_vWN+fjQW$*5h}7YYS5ow^jG8qj;uF>(|SL#|8FqiVrhcq32Skd?0@)m)Z<^h
zme`Sj_ikMF640A};?$5E1Sh?W%v?Y(6w4B%=_zQKGV>JbFg?eM>JhH}z5_gK^w5OT
zGoQ(VN9O{v-~BAoBY|2t=Qu+JGsuTqjugl{Lb>`_X=A^VK`WALf*^sP^Z$xRP1Mc(
zY8NLfrSLTOG#dV>^xLXs^Z2wkHkaH&pjx{_EO77<*?5)#{dpNJjeaNY%O}nG*w2;O
zbkD7;FP~cmXr@7uR^pLWJtp_h0)f!4+`x<U4#U?qQM;=pbcH}|wg02W)%OPd`6CPq
z)p5ImIq+(I!$yHvEB5I0#oCF9OU#TW%pyWcyu(__P?Odi8-{K}+orKc)&xxM=rYrG
z`>_hq#K~Z4IF~!a<)WsjTe~?0-*Tx9j$~Q?vGFFdH=tOx6q8y2S<|4a&oY&c@>jwo
zwSN?CoRmT+w&R>L$oM-!Wp~L8)Ln<N0GWSq!pGMB(Z8cTN<M$sJgtVwfsMR8opVr<
z*6RRWHbQXFU`ryuSb(J;vYM1j3<AV$wz7>;-An%J&R!WXv5eQoOXa%?;Pr2gwj&W`
zG^F9Q;T+D<ob;(6lA~^pz9%=B;AyMw)e&X2fy|;hA#~9(UT2CqMBepu671mx=#I;&
zhObKdnowAE*X6BDQ|EjXGq_xSoRneQ$?<Kzb9IGCR|M;qfdkIDMR26bJ%pu0V<8dG
zI&>;`U+`y$M3l3fy6DDfJdcP1;Na<+kf(wWeVaeS2y)u1l$cq9UpiCI?T(4mso{lv
z^EE0sgX>&y*o75iVwxvTc=6>KRLcyrWkMfhGnt1-wd0IB@UvQi>*_d@@RWE*+Mpty
zMC|G4(cOBc-PVmwDY8sT00k>a3l%B`74m>(`CoK=feVlC?M4b>izmM|yOEr(QDWZW
z<yXEpQf0|Ws8W_1eLyrqd-J(RIBHZ0-F^q#F$cO>s7UmWlS}(az*%xTc<%Oiz7Jqi
zY|6A4vh`z<-WMR#%M@{VB#Eg?>wV5^K^-U_T!j8zT@KBq)q|dJOBT?9*@F!op8AfF
z)vLZ8wnR4tqtaB-WJ)B?3@W)>!DoqM%X$iLa27$N-qqO<G)=J1q1lZ6r6+D?CpY@9
z3aa*J*lnH~<n_bdRvXQQIV4Zl4d)!cJwL)S)v#ubE1dFlzt@4d8SN|C%uIcftPnoX
zQY^aVE_~#JVedIJhaxQHXj%Z(uEK=+yL8+JVdMH<x%l-IQdNsaXjVRU6VvjhK1nQm
zj`iG`@23|@KY*Kk*#{iuzz{EZ@asXuaqK!wW1$8Bk=aat7dAS|1}3i}#;`BKL$pXi
zzekdEUuvZ+LdKR*(i6e8QKaJGR`<yPzht*T2IIM^MG(ag#kYf4FR@Bj>b{!}f}BD^
zi%Sg$2UfktRmn~g1}n-i7=jIn>Cn)`KtT9H966Oazr!gIYx{oy5vKKog9EsN$r@cS
z4wKtGKIU?iU}=Udd)2Rw(K18vq@OqbQDRsVcz{gV5CG`IVCM(nBq|bc67F++%Vwr%
zB=+kKMfV&1jQtyK3D5MsFIQ;dz2pG#I2KGg0I8AK1Y|b9{0DNVBZt7GjqhBJ!2W>x
zqw4}rS56?`vj*Un!)uS6d?E2P#;LnG5V{Pi&jc0eIPCYx5xq%xojt4#x)j)o1F7W#
z49BX{DG~#1zsKcf>}6V)FJeF0b{tbRWSd(IoM~6v#F#G1*Gui&?U76V9uzuuMrXnS
z{9~YZ5%>bt;%>PVDmeW}5Yg|GRctTthNVG~J=f8_^88-BdDwz398&Rmq(A~S6eyO<
zKKeJ7y;jlMC-wFuccnUIx?fb1dw<cPu6bwv`|;4Ebj6^T7=zj7((QKBzvJxNKI<&$
zH@@(3lSBJXJio&?SK-$6cwHyYtVChHl88(lVO;2O*9K>{*rQj<8kMP>gzI0Pebu4<
z-@k&Gt51#7?I%&sc&LTPERsK=Gp~(LAFxgbE>4yto$C@pLJj)QbqOGH%Upkb{$fn{
zy;0EvLyNQ5`%UT**}HfiMIzT4!{_xaP`2;MPoD?gBFtPl7e)yjoj9HI*6Js<vH}1;
zxBH0<-2Qc&JBUzpt(!L_ZDx*=H|c+47WOP};)Qh5F(%NyY?C1DU6bGnTnm&FY`Zhg
zmo)p2o2pyuSbaaxo5)jZ@WF?ir>@IJ+dLf~C2Q)hQa#{v;{)A~PVC&}pHg0?8MQM^
zrg*Xgw~Mz0vk@=9-`Hf8(}k2cJ!nXz=(SaHl|5b7eR;mM5VPd4HF<2iV*-wE!ij{3
zC@*v6wX3EQ!Ak*AQQ@dRAO?YPaQ;7k2)ZGT1q1ZT(>hQLShfDPdAd|opBhG>|LZ@w
zucIa=Lz{@fg;@8^FcdT93;S6*P6y<Fzd5N{Jjt!(M|>J26y)fDXNmuD6uI~F!F$)*
zo9ZHp-ZY5{BKXEP^0fSzJWu%0&}8Vs`@AVZ9}e8xBy+e{>Rg>2;D~)_UZ4$me#IJY
zkAcVE4{sqO2)Hj^lHUw%u+!HsX%}`p7LD+X1eCQWRGfG=YWjo;m+#p|J`8;?JGQhb
zz=IX%Y7KheviC<eEj&n!<kMGTgCB4@Mw|Ny6okB50HXXF-O>yJE}^y&j?Ef^@7vxo
z&PmJ{E7h;>Z2&+2aN1N$Z@;=`ryERM5sv<RQkP8@xOU=3@~!f-L3`K7H_imtY3#;R
zwTOl-13<w~DwFRt!$xb%MG<i*B!GIeM~F%+GtUu@>loHA;zC-@b}vj*LXy64Z9aV6
z%El973K03>fC67RjZ$NtN|W)0I_~2Ktv}?(&Rv_Ju3_GvjJp;Q-|5v$lCDS+ZF<Jd
zqMx}hP>~4ptBUUV!r9sVM3%>^nRkh_*V<nXtxpT_ioR!Y06k)-%9BiJT+;pxUx>yp
zmsU2V2p@pDN9XlLKo`2Z93{;utfN|%`*B?PXBXct58$gkW^okqT3v^>?b_MXOMe{?
z=6wB}`}qs^7rWTVDDL`1E9ZpaRJvr;nioYf)&*v#N*`a2K4+1|!@C;!7n%Iy{c3`h
z?|vD^${|}J@*#7B>tpM1%E=g%j4?6qIJNQ)q=fsUsbzXGN>yrl+`^rl>4!dGCGCSC
zQ5E<Cgf)sy5r;SV2i^&MWEGOw^YOXD95#$%OeyZ<GWpE;8bY6#T@yx$+~F0g_^;B!
zWUpWF6~{(-+H^DBSSol5V4mp3-}KeS=Eu+axD#X-Uk4Ji6{+7FiIL6?#H9tt({2uT
zOCx>)iz|aQJJxN_5xpjOJP6ywB(JNa(=#*C)k$69H~B_X{&N4leu`f;H)F(2{5zE3
zzBXX8$>v(D-Fdnu?uuuYFLR_zwdFTS^b6oKMf#KvU;8N2wGJm4J{sTA>E42(Rf|I4
z!wgj6FiGmbPx$#`i(fwB6xtX$tRZ0%Dvu(IZb02C5_q>i$2G8{<`SHkod6hZHazUy
znBjXqH}H*~Eaw)*I5TnCqki=kh<vck&&mENXbq<`dp3<^DdwL>QCjJYi)e|I9M-2;
zf5Wp_-zGNLz+|aty?18j6Q$!f11X1pEsNXaQL@1|(kC8XHW%~^Jzuf+>um5m*I8}~
z%xpq>zR6zJUfLj||H^gC&oC2heEbNrz?nrAP9bl<nOv{BHY9ZuaB2<ZdkZOhex1AL
z|IiXR4&NF%+g72y!9(WdMX+df`yF%rE118igX{s*wC-wg=w$0E&NJkqdmPKV%Pt?u
z?Xrx3Lj0cjlL#wPriqOOib#5i_U1CPrhxRqN-oame!~z%yyLyMG>6gs=o?v}iDaa<
zgskx{%kv2b%#gWK<KYK?7pIr(CUkTEuxbDNaolU;BdgJ=-<yPX6U?UX$)lHPUfj2E
z=4l5BdgZ9!Q3SBv(*3FUK0DFFcebuDD|PnDY`K#_*5HYv|AC==xNjVHldNLxDIk+h
zARZRu8h86}rx-SGT{Yq}vurn0!}HcZp-_qZ@K*Mte<u<5`EvdkQ6GK#^-Q97MOq)0
zLltvif2~fz<uOWp&pPIG{p2wHuclHuzvj$EQID+0-VYiQYX9}&vg0)%^p3c)*NJBR
z@~kfZr>W+DqpZRT?nWe9Mk=5zdKt$|g%)_Ud}I(diw{fLwDz9WRYPQfubobl3+0JP
ze>s(h2dUBnHOy4QBoEX1d<vC#$L2Zqh#e>H^U6ly@H-0m)JQa@G9GCf+A;BW1r+8#
z*oe_qa`7o%Ar~K!$qC5^gq0EQq(0lMeMeT04cwbinmx;FCk~p9Q6Kowcj(LDciVk<
zJ!7w)&YrhDcv_xQ*%H0AX8sLaUakpof8K?U$79AzVp2_FzGkjcZ78)K(90Bb&D!<G
zfYTwg$Y9|sCmgrpBe}X+CK;9i&*5f1ND%9S#htyU0RQ>C0HeUD6EXM@X1)d&h_z|P
zmK8vfaeC{Uq0cHrII_@!Cq0q*m`HqplUgGFFQBa@YGO$gKdxsXACQRy*Bq_GqT;Io
zrz7T)mZ~Tko|ThrTwQ~}@z|iMSh_KtN;(qi`ap!_dY<#U^t;H!v`|?3@rK|AdpFq&
z0hx&Ny@Lz!@TB}7=ByMzS+5ax^FYPcgTXU8{);PSueglmCiUz2!+Z0&NYlgkv0V=w
z$g0E551Dz4j$i@9K>9~&bzSVry2e2FAb3uy`x}c_3mn~NrQlVa>ayG^QU&_uVwV1U
z-Ca%}7rF%D2lGf{_Au7zAbisBX>aMi-gJr1g<sevOCRyPxBCjR*-RW$?NuSe)|a5p
zX*W_6jW+ieGi>rjPV?7mp*^Zn6E2-kL2>3ioyw*R?NPncdva$V?sm;8=zBg_#!q`P
z^<6*7%e9C2WOa`S?0OWU9jjV$FE65%Ae^)XLQjr*Hh=;eIm?s(qIH$mrf1h{9dANn
z`<}G5b@~DmnOy%ow|t|TNmcdEmV3i~<-k<AHs*GqN{wo{KjttnO0`EAEQ$upC$L@F
z8_fFuW*Utaw`@=5bl*m5eJ<IbINj1kYJax3k!TDIuJbuQy*eRXQK9chXFGPVZs_Wd
zwtXbi{`2IGp@0=!jeItUuM8Gv+`majpO}qT6DZC|?wlZ0d_G@ye{(V}zDJ{Bi8)`-
zwl_A<q^MEhN^u{b71eSG+q$gq6F@Z(8u@!FVY2rss<|-9?fKC$m4Y-N_gtklm_;M-
ze)op8^lAA1=uDz7P>yB6i1c56%sg`%L;C-|lliY6Cqo+Ef*r`hAgf<_L6MMkThvqR
zJ?icLFiFQkbAtxY+kq(deB*L+bbMH-*(}dx+?|waRiX2{LY1N!U11-<J2b{nB5%3v
zX+p)|l*TM)jU_N(SFW|ywVCr7t!0pRMm-7bGkFQeR~5cW@BX-MQxhk)0rUE!!kiJr
zN<4gd1%iy>rpQ;B*7nSR!uIFgOJn2gfa~{8*3(R~58;Lkp$Eo|j-35m6loPDRr=ue
zHW*2s>$q1@QP@l>Eh|N*;lwRtCcRvJmdRcL{@N|*fx?X#?ok9jVKw+aP24wl8Xy%T
zup|_RA>r!#z=1_|ON2>8*q6Pi<mf#J>%!asq8hPh8&b-DYzw(xzK4}0z?uBRR8Pnz
zC0WG_qyuJy-oxr@+0eGG%#W9I*VgE;ETdMg-h@{tR0RdMl(m-VyiZtY`6ME3$(##f
zk^6FwIDm?Z-3}vvdz}aFjBazC-A~T$#_+Yx6Ks}bt&tb=Z%D~<FYaA8IF1a3udjht
zqCZeIhBS*$zVv*@m^eHmAj?>tpYXUc*gU%I`u6-jH8XU<oi}Cy>y2m=!8cX2I8MVw
z<mRvRBi2zzQKdEA^3P&?8@9#Ujq&y#rK0D$Vk(Sy+lXdw>ww%EY`uAd{`+0ZR$iSD
zG3l-csu-Bhf4_N#AKX*Rq}$1RS*Fh_h!6e0%3Qo(UwuZ#j}2q~STrAeO6PU$ue*ck
z2gobhd=PpRQQbn$OnmGpseHd!dGffL;+<~Z`Zmz7C+u%7&8$x-zN=^ITKFdrCAhhz
z%OSePKXfUE>gt-)Qi33E4S%~JZBx#^dFJL;S*`H}r#!)8>&AtGLf}m$Qr`$ASV8Rr
zcSMWd1DR%iGR`Io&(tF8`cQXAL}E(0cJX+T3r=P{$HtOKhwR&Ls<j<yx;aYYTlS;x
zxf$84e+;+M^_dF1L=Y^GuHX)QKArhRLFf35J$N#DR5Zcj9Q$=Hh|nSDpaM5MAC6~a
zjcv)+$$wZ--7EJq6*oseUlg=_+3d@=U?J~^A-w-x-~T@*0)J<j4KF%iORDQgMN@kY
zz;=(tb5v2U{zj!++!cTB6ju+dSrpg|u>IV<e^^U7NkZt=M@28o0w>&26ExCoOHfa&
z79Q+k)qGp`DntmuAb{|Rm=RLpH<8Q2-{B5?jL3QqhYQJmufwd3it2wx>VFmrQ0h`~
z30JSED>%;g^*&ae<ME)-vn7CB4Szni-CQ$96j5B85&3!XJ+Cn9djk2un5jI_^#0>W
zokjdmu(1ou#$g&ztAJ{o!n<AJ)aZ4RyT1M|c5v@^{)ueImp7|m1qDQC{Mc3lE+m!O
z`d#;7d!&E4TC1=)n37RsMTQ7>x8_2YJ2c^+0<IG(g}#LBGg5+vwRXxIe8e)jM&*hC
z<`W|WP%C<RRw%lhMPgvalw*y2U7D*EEYWetM>%5iLDsoZh$KY}k=gZe@yiqviitm)
zW_wfrPDri~qQ62#_rcaa=cCHs9)*SFFPv<d*#f3&h882NBA5gTOhcx+a(CYlD_*G1
zT{wdU?zpBzuq%bzqTL0{1xEfNeIKX44`nyGuVbnF>Gf;nkwboS`WU1t8!}~QR`_e>
z_Vx=y<tv_To7lORwBpTb_uA#hxF@xjn(u>sYM+lkWGmCCB;_$|Hs~w}kf+|?1)yje
z2xQoCh}vPm;)>SPWhc1!!&vMMLI)_#F3+A8^fJ2o_2JMinapT+@Z?N6q7@(i(J||`
zojBa-bx-6;wqARq2>&RxcA<z>#mqq*4;zjdyYQ`TV&*PLs;a3B=MdNJ8PdTd{quFz
z^#~=tj>3E%k)dL}Q{?UTeg30@L#bc*gNWNjHWk}Om--Gf>cn_-L0`Z1+;SAq0{ame
zW#WK^R`o~!>lj0O+FGBiwq65DV3{pu)~12+`Or7fJ7W>iIl=m~)&8|TBIC#f<xg(0
zYngH|BHE|oAe$_!vGeYEiC}-N^{&odCS>7=%ANaua30bp*W2GazVr(o29_p_<izxr
z@0!j(@=H93NVU4s3h^AP=zzuJuZ9e2h+NC-Q9Q=ayT?sjnpbwVC3Phv)+O$R0wgJ|
z?`c126>#yigjP0VC-4k1nEbL0een2lKtYNnUjOZ)(V7HdejR8KO3{<|^!b?c`<o<*
zbxYL#*@hy&aw@BDyNfkRV6LL<n<R0@E(y`=E&W^)e`O{MwTG(Fc66PPYbWO-E_qh>
zu7KYt-B05DO9R?^?m#yQz3%Iu*9jC~ej*J8{r?Q@|F3brQ;5NV9nmr{X0x8eAd_s^
z+SqPa<{#g#HWKI2@+B3Y=2J<PJifEe71UwRv1UDR{l}46aS}Cf-p@p{Y_f2nP?hip
zMQybBLPa~)(>b5^x5paB&TBJYkK(P)pKM(9;`=7_1Zp(wTo+9w%QCLkxDR!5gY4_l
z%y`8j877T0R9UeA3i%D}hNK%rC=NbELyiteCiv}U-F#x4xg(qi?s0j-tNQ5|;KkHK
z-U<duc>AH%wgbwt=oL9N4C@zcymOG(6C{fk$qcLap=KaeFxJle@2#tWYk7j4&+>lO
zGCA77XqvzBp|cv=iNMi6SXm<<=Oah){{nnS#a4ZP9R2}h8de{^(A%hkmDPR6E^?&B
z+`Nb7Vw~NK!eJvF^MfmV?Z4v<zQf#S0kHpC2??gF(L^7jc?;?LGOwHL$Kjmci*oGk
zzslMOMHhYy=&(kAlGL-9brmy$TiQAZtvULps7KMyv3A~>xZIok_Cjq=$!^T|ZH^x5
zNyFep{3hFkZg5A^-0!(zYca((V=?|NJ#?z{P#~q?bEXP)vXPV{byo+P)aOcCQ|K#2
zbb|-$dmB9!d2qS+E1wp}aToE%k%>ictX*TPvhUb~hnYP0o208B+C^RmO?_REcI_{l
z`q#7CM_SR7+Tvsy0i?@~L<5MQF?wzwW$n|0D`gD^Kl-G&Yg%QB^Po(9tdgp0zG|w1
zO>U(hHrW-n<6Sn-!Vimm)g;r5wduLF*388%@ScsdmmgJsR(9uxDvp@=8j7v??VaI4
zxU^8j!YMyL<(QF~71{97m*c)GxjFl4B#*2DhlBoi&yNNM-KJWUdwDUOUi*~3ZwKgo
zW3b`HS)~2txn|djTQ>#WHgxn99C+}C_4?12E${bueifC)K+=y~JUa&Lh<&`~{_LJS
zs`l_#T>YndQ5yyZ@hi74-dDJ;b}xPlDLz4YqpUQo$KSe}XIGK5_US>9Kl&$TS)j)!
zK?7gZ*7{YVik$Srj|KGxWqvDE(A089^^LdpjvexEA@Tfx9c<sd{W>R^lvRXEm-djg
zu#(0LDT!vU=ff9_%9d7#I=2hab2oSXASvN!cbai86r`sqBB|$$k>_#71??X)8CLss
zPZ0gmFbXcF>Zb>hv^zE8U9;Iq<CuMpL|ak6L{0LGihn~`7zEX;Sn><cm^olmODbmc
zdCviGym*S@Ie%&(G`%%I%kPCDWJ$qc+~=2)J_^<7v58}{{XgS6MndOL!=|zS-Gfax
z(G3ssXVz_ky~c^~yzwK~h|mzrs$yjgirKLkqhlw3Geh#zd0&*LK_%bK<6NNOEE0v-
zA4LIc_CYO+5V21P-MuDE7ZE!@Ofi}gp9WW+$k20Ug<GH`?0mos)rz1!;+Yze3uHK9
zJwnKl0H1@e7F_dZk7ZW0i5tu8hgw*@CU5%61RL-o@GO1cn$rMBpl*E2z~Meq9dVJy
zHe1UhQt)_QmxieYE5n!aGdkQT#`~mjM0MtH^(xG%@A)T}D^zz0W>=ujRk7f;Q~n>P
zMW_?gZbX$ih?b`b_Ekr+uurveVJ6u<4ko6t@$pCDOqqq-j_$SB_ortTxW>gtlYyRl
zd_8-p-P8R3SwM;Y05}kj%%XKJaD=7kw+apJx~w2?=*^2QYp;8h`A4*_x})ixKMwQ3
z<%U#tkuiT()1;hUFpiIH4Wk|No}xlFCY6eGiy2><2e>>v@a#LB(J~e5S08pbw9~Ts
z+D<TC<N89z`(fuk*X_OKEB-*?pC8H;)WCEjE3y##Yqmyj<pqqp-%+g8wapP<6P8OP
z!`71E+?zutWQ3NDqp7*>xZ;*eKIbt@@f-1fzi)_l#wp+6TnbH{Bg5=gE}1nhD%@=b
zv^`Hw6GMDHKHS~sB=`!$dg=NEha=2dT0#EswN1*%Yp==8hCn-}-wHINwHFghL_}2O
zhR!VEpPLbd59P4ZO33Cqol}}U-gS8Fb0fDAXq<V2<?c?m1HGsj;<d)7W4-*+gAdV#
zrI;jmvXll4ji;KLDAuwZuUEYZ+e}whcm3y0s2}jumt%06uTa8IrnU0{6iQ!_yj;CG
zzo(F_3I&`N?N5kt2aS~jp2bmY4wqQDC^Dz)L$aTGDJ2kCFtoiYJFl;OOy%Eav?WhI
zZJkZbp6sS$wtsT6e(z>qVPqkaFQBR--=Olx8U#PTmIfZKjyWgxGw;45ucz^#<Bt0C
zRwGeC7#)gaS>fAPtZ+4$lOY%k@Y%^42jwij2lt7EPb$Q_UnOfmYx}B(pY|_D$nCCP
zoBEy#F#lVaHV%B5^oAlLluS(EV>@s*()QJ<z0}XF!h0o6Q<dJ=efUws$VTrAxSSaB
z!~|@?!k7q2)iwB)#-HSDvt6PgCh_XFAZLI0Z`>^ZOX5@lsG77rSv${_&)0wP$4pbI
z*1+HI_e($XnYdmQt3Ij<50$UUJ(k?5E$9eZ7CSzpD7-J2@nkT}rURA;&yezj^Td%*
z`4O=^@oE-wZ{5o~;X=}@M6WzxeX)>Jkt(b&CZeBsgs;WJ$~>=g;|z8o$;^avFEbak
z)f~!K*5+fd<$kFB$^@-;7RQ(4lKBS`2x`g`JC>dHgg<mtf$2HV>Y<F=%alp#x9+x!
zOzbT$l~(kY52)2myvB-AquhDd_mcF9%SKh)bqP-`soJNNs=jmh5Cug%4)uUB&P+jn
z%mK8dWQ)+DempjB@UHL5`o7U&b<r;xja;5miGPC5A((zOT{ae>ef(l<FORzRTwMgH
zc7Bl)Q<&n-RQ>8qW%CBsflF&crY0gH?^W08wI4>-pF8!|1FE@gm_4{t`N*OmogLQl
zX5rcV$yw1Q-}x-_nDBGs2lK1RwSpxXY61?5iT*Fj-ZH4Jb?Fv{6<mWuu;3Eh-CY9&
zcXxMpx8Uv;+}+&*EC}xI?#{RN`QH1UQ}<S#+PiB0oK?W2pV2)=kM1WF-X$lpjug_q
zxEf1c&OhVV_ni<yc?V}9L*j~wJrm-_tcuYLE9Hj}RLD&srXZe&Ddwk6kd`VexM39X
zfZ6_6t&3*VdD%i+bG3f6m^b37z!o6G6f;6FxZose=X=UmqEY%m1`)lGIB_<QX01(a
zp6aC>DI?=Y$6(HpB1eKEO(I;YlgD@N(D)p>`Q?$QN~b$$qZ36Ww<TPh@D&#MT%o6E
zu{DchD3ecFGj`>W=gP{4q+r55S{;voV<kW)df#+0ueU7cf~k6(gX~?l5RI{r68`{^
z#|ziLD@Tg@zLD`NH3ye_<44citaP@_>x<6YgzoPf=6Ly<f*91fC-ss2+o|yV+dh;{
z&HPiIls#|l<e0hyfq8}n*;k%)-WpGy%UZOi!Ax<N*zg@mXXGthr1aO7dd_MdIrxP5
zv)%nGCdi!dahYz_{@P|F=MBmmoskb@q9*+PgWw!bpZ)Hmv&ttLz9aYYX2R@sRR()=
zFn;gw@cB|&ucw142JZHVXeX5L9X>tzHX_CBznQ0)iM|4E6;crm{S3cBnmyotAPpZP
zrdG0Pd)PpNw~63#Rzn;blM8Hk5Q=sI+S#y&bv1!3dGmxM0wrazK#a<~XUMWETI%kv
z$~r-emWgG_bI21Xb6hC7C$L#-pd@5EtYZOcX5}`*c=1D+L3e<6h4@&(^db><$jmq3
z?+_*5P<beGFRmaO`WWX>0b{XpY32BpltY2*=Y!w<+^3ExRWR95)=N4@pyB%+EtAT{
zP;)i+WU}u$W}ycGwhxq0HeKO)I#_h-1We{Gu)ZH2Xwn(>Z(sOrx3|n=<(gjDAY|-Z
zqDVOI;I-1e^vRbf)`((Vjd~L9yx%g-D;W<YMN{`fl6*b58_i}w+q)Hn81e~IxW{vE
zO~Gd&wtT$ZF{i0GZQ8{p&Zgm~lKoraF;;9(8Vqm&Bp*vxp_`u=F9hzIe%hVZ-Toqt
ze9xBr17alsEw{XJUbU*s3e{Jcq_NAML+1?<kAz+S<{2m7%8(dc6c<CGSo{m&taZb)
zR?J*&=?<%<OkzEgd9<X;maLKLdBNqSVPd~!Xv_!De)fh_$ZtJ7?PnEQF7lc0cEA`c
zl`8Wcwd0&4H7t-~#uF14RKe3wO5^`k!4ty#Rl!5Z6(2G^%^tb*nwUya_|`JN-W~c&
z{xUAE*-x!W(|fkaX8d&wd(u)ub4OFaSUGP}-($STjPr*}X_Uo*v#T`lr7<0w8gM(E
zB6~uoOo;9>-~_#OoGK!p0-fTK_MC~Zv(?FJbvEEM-AyIY<ZSPC5i6sOZ1VU_Z}_<9
z+q)})t8>dE<Y9^F`)&sHM_QlPoX2++@y2uNq66^r=GkaUCb*=$6Dw<nKKGBUu&X_I
z+8Zs8#`^H257cq?lEoCXd~#kQ`G4<@{*Ou$DZcqaB%piJF9M8a(q)W_e_odM=5%2w
z`~B<b`1%;IHnWdqRy?YzPuK;g`taH6-9-wh(lxKr$<=KCqQQCK9MI>IHe9W9kg<eJ
z)WsIs_ssGe7g;~zM){ZmU;fR5pj&Dndo5-M#G>pyIYV|J%y!xz6U>#HIOP23YR=NL
zj^g;biZiR(led=8K7&6mF{gY134&&_fJ%CS=6!eW@&Z)w=ZcXW>rV0s*o02}cQ$q?
z584`Z=0%NVF_w6dWLY%uXRE2H`f}~JXrqvl|DmrXpGfwgC4yA0o;p9P2+IHuFo!m@
zrmD0R|G54Y&+S*1>+OAiw%~I+Z4qp^^<rsB@HhHhD#AqMW)DmZnCSo3$5Z+G7eOU?
zS^~2u^Y+$6F^Jw9T4)<eX`ir6TCCVz5{3mLf`r*ei}hNaQ{|+&%Bht#3D34W(!-{4
z`kp`BW2A>{5iRJbvpy3q1T6PnvQ$s4T0%q#LgamkH4~5nCf#C;4G5}qP~ViWV(~3_
z%Frx~xM&1IQ^B%4WB|8U2WN}vmfxg)TPOk=(f|$G5Qkq<OnHd_xAo+7cd+0@z%o!1
z(PobM1!O{mI4tSETTK}|uufQl`j#-6h1B&@tR+I8HjOruG-k@9ne(#q6N(QUK(6-a
zTG~JL!>%0)%YgFwqRoyb(y1vv^#g)BjyRhWoU>XUvlaFWx4CAPjoK42oDyHSB44bG
z;F~Y3d=vTKL;;~qug@Hy)(BSE=oSbL@aG^7x7pEisR&5N*b+aj*+pvwcUpc2;T-}0
zZ#sUZB|HX8OrQ2*ojV^lN(=|eLZ#Pj+D}SE@Cn%h-frzm^rdhM#!c|l;mg~bDO*S}
zOCbeNymx8Oc65P?Tron#0a{kb>f|BD^Tm0C{dVSLZ}5EuE(<BVa(?Ta5`HQGCoXA)
z9c-%ApDY%G_?lZ=7$7m)!~s(p)PjXSRxAOfi%JOrh(i^ga`}r?5kDUft0JSnCqsh&
z?`xX|s2reB6`Mj_3%15I&VXDBd@4v%H+&O(Pg_3!1###j<J9tf^1x3~`&PdG*NPV6
z0@gVBuGH&v#mKT2<#!Ic45}xnHa+|ffTbrrOK1k5?r!AUSFBhDYj@b-PQ=uN7ofvY
z+gUm_PbsgnXR@^%I+dQ~yIc#`ORB?exuz$BIyEMxuBk#)$j^;*XiA<8X-M9yC7qET
z6}ldw6b(y@F+tc&u30)8nXQ%IPDM+9V1PsKiM8K^jjet&PRZ$3ytB^#s;$+M{RZAf
z2@B*ZsecuRIIJ(EcZLUrn$%yRR#g9V8!HM5wJ9}=|4?%Nn@i*0uhC)pU!;L$l}Kvx
za0rK_TGE&&`?czDwu`<e7&<sn4=>22j8QUqFRg-{JV}H-^V}W{V3ipi#zrpeH6Mr4
zyX^b=vI>4Cs7^aTEpz8HSnF>~cq81)diunTwuz&&{*xpLDdU605v?@WTdcd7HlL=g
z)k<+zCdgaPFxAZYGt^Zboe{0AbV~O@z7Qq#`gJ5>o%wObdo1ua@DtHY6!2%_Y*zDn
zP%s?Cf!cxxR~4BXY~f(uK2y;RGJh-g{YQz<feSFD7Qmgit_M`K_dD|-87+@}F?{R2
z9vk}YGfy#wZk;s`;L_q;J-yjvUwBCcJ2L?|Df_VnX%)omL$Oq<7GXZgOO8&ZLz0(3
zC;P*;*mQ}4dqmMOkR(z;up>PqNmNZ4UPST}b@M?dwNy}nx94>o%UG-5cs0%zvth_$
z8l_2DAAJ$r975hY#VLaWHU?00$BTwL@4GI<WxW6ffp9-1`?ctV3LxIpo?1)gcD#-t
zPXG;But3Jwt$8LJ`r#ThW+LxIur-+dS;wS$_1+@XT=;k}ZwnWBOJNWLz*MJF{Yx3g
z1<B;ywx+M`_|-7Ljp&?H+P{OX|2{VYFbxF$$r!o#=(*fEKf$!=-_x^f%zACqLaTbb
z&%|q75b@oW6XD&_>&y$235l+!`15-p%(x+~>m|)QqvPw2?DK1>JMA4iyNI#&$H>hp
zHe7Fp?e3$6>zDLrC=Cf2(eImns&_=c?gONzwG$Vc3dXD#@9fX=!K~|+8QSrO+tG7v
zX~j_@(&8rZ<G|LwA0C;4aDlhnw6O@JBSbXJl7MuCa!~SWo13~!;N=7T?KJX#7YF}s
zWNLYYm@ERb)}vKL)K+3$deUoURK{6&>6J=X2B{W++v;jY@U}mQ-=$3Ou6rl%xXX${
zgLDo59Eaegd7sJnb|I`>VsMC8_b<;ITg@^|mY_*ooPDi-{k-%-Sb(PyICPC${wr~%
z<<$P{mr5`GtirD!7D~C$O`|DWxnO6Pkhz?hh-VBY5m&rM>{!m=Z8e=?icAI-Ts$^5
zK$IKuB)18c)3mH0I)M$JC@|}=-(sQ@i_v?-(R1(A|AK>IA`cT#3*E=$R}nD?^E5I+
zM}*cVAm?%`9PBN~U&{VJg8$!V{=XQwdV(o{GXSU1Z?Ol@tA91-(!$4kbry?tf<ZCZ
zGzqS@`c6V0V8s%(c#H>m2;DQIoodjYm_sGNZuNEsX{LQ!jIDDI<=;iMNGagy0i}O~
zx0Y?d74BsO-C8M%o_vu%VxGQ@SXnxON5r!*UkdAthYp$t$u(_8d+e_yTh$5Ie@KNm
z+y`Bl%aZ7|8wCRtH{eVNCKkwnbt(Pv7qun*3UGqYo-J{cAQs>kZBcCad#vK$U}#4K
zn+d{?&V!Ki0cxVhUt4<S#$%t&qDc<}pT^e36dM>-^A}GV(1BZ%J0>}y0H^9~Fl%Z|
zY%(n#En`P+3&dZtKW6eKOw>HZx7@Z&?HIr{9NqPsmXTA2$&S_#PkA3H9KOZsEoldH
zqE#p4eA{DFT|q~l;L3=wSr)_!#Mjwfd3FMCvp$78^)Emx1(7SdVx=~)th9H8!AmYk
zvwevLX`t*L;RXR)g`A&HGr2&<&q?!D+3<DfX!gkzdlqO*YU!xEiSg*OyPZS`vrofm
zF`|BaO0SBopie<70?L?}TxnCA-$5A@>Sqz$|E9u!2mODIgiRq7GfwdIv=JwdZvdyC
zut0WY!0jEMj7tj@KbGEe6M*GUjI0X<=w|Uvk0Y!aP-oAocIFcsd$!$t<*~dqoxwvn
za-42j2rs_B%E-L6s)Bch_s&l6&T-WQcTH;kzQEAdpTX1nZ`D21OV#ir6UIr>R;smO
zUS>E);yHOWok0$K{ea`3OW{3ss?ldFXB^1G_-rr`AT%eJ!ve{TMEt6_rz+X008S@a
zN}PX1{bUFz>P`FK^5;R-zbLQcjLkp(o6S);paD*uMwUk4sz?iJjx`N+g`BW$I5DU{
z@n!swxNcge5BjRB9(EK<aH+wU3l(FjB-s&4KKshLVEwkvszH?Pb$&x!YzvJ=iI%>t
zxRI!oGrYLr&#z&F*W^T&t!`F4$=f{<zGH8wis#er9s%o5+yjX2;?dOHA{3kr#crMA
z`%8{4hYna_+-r&H+oGifYmV5`=Av(ibEf!MJ$W=b-zmomY?PQa>A7S8Zmr>f<BUN&
zpx@b=TMloz6ZWI`>6f+oQs=p@qNqQheaR+Z?Z9s^Z>}<F)KnA{5~iXW$0#7uI|myE
zwsvg#I7*NM1C&oL`Fn)rKl6f?7l4*l02)sj{8=N1P9S4kG_|`33=s}U4hP(?(pL+q
z61Z_CaK9ffiU7;n&=K2zFQE)&*JDl5uS&?wDFo9ll+nsvMDWG3+L`MAa>~z@*0#K?
z=s-A_MV3e@MA8NAB@NytbEPr5z^rNC;pz$Ls$#Gx4Kma1icSl`i~8B*B~XPDLj?7t
zp@Nu;%$07-7%2SrsF-Wfa!o?ljsm7G{8#q;*79pf3}U7_7)cW(gNV%wnS%Gvf0k4T
zu%Q9|Atp}3`#XLW_=YZaZEMJK**g<hTF}E<tt>h0Qt8JA2VC$-1M{wgPDul^W=zVX
zS`&orx6q;>JJ};h=l@kX(6AFQ5uP~_UC|$#Kj;HI4V(aj15#q>j}~uAo%JQlFYF#r
zQ1PiQYjP%{B9ocgf1PmItEBTgnj){yH~7hEmRpn<TKRKZ9xB-@M9A$*&)E9rSOip0
zC_3YbCTAT?6-;2Szj<Ih%%g^p%8u--voDl?pc}Jd53)?D&J(;^R<I{yzmz^n0azei
zc)^$HV1ZDDraYiF8qTMbV^AV6QwMoKnomo;siDaMw?{SUG+sNA1@LR$!YwX_0O3I1
z!`%$w%t4s3xKK46tsZe*Yd!OC#r!2~{GQoWm`hUsxCBFn&`|MfQUFc8-n1<53{+P;
z?>MADyD&S!YGCCiL3m5JRjJyzdmNicud+ci*BLX<IECEowIv~%#_!EYxG>x;nfmLL
z)IOWT0LxC9aMKH1@y9<cp{@)z9ZzuQhpSXMYRG!DTdn?)q3U3pZK{@InQ|0<!&VdX
z$1qYq=#Qp^JY-$fjU-8)|M|^K8C*m4_g#LpK~#FwlSbzptYK$uhYvSOE+Vxlw+%12
zhPLtS9qTui;*Jb!BsD9QR92ng4&6gl`*5nbK^`d?Y5LtdN~4=h`Z<V?dR`Lw7MG+<
z^QQhSr#`GrUZrpO*c;+pSz-Z%kC_pfDT1K<MIi(_j1&P^o=Rabz!L5`OjU}^ELG6Z
zeK=tkPr#NAVFQnEC`Hpxc>bQg0MHvGRGJ`4`4!^7r0jpEwtv0G@$r`dyK*Mro3LmV
z_xIB;DeRN@kE75ls?vF@R*YDi#bDk=EB?CLXZwqYDT4@Y-A-T3&*zcRJ#a&c)#rE`
z#ls!!{dWN0tf=#v+Lx8_V~3cm6LaSt&BLb}rPOmQl(HT2Q4?aF>stfU&WNDiQ-6GC
zNwVqeoy$*0>PU-R{y|%SlWyu=Dg=u>p9Iz!11;kxXTsW)M=YQUZ-tFh#GX?f5`AoP
z+^h<4iW^;y2h)Z=L?G9c_fyFMgQux-SzLzRw7Li==|psC{`7^P@)%9m#K42EHS~5J
zis^-jw4ZTTaVc3QhQ(ZFvVn=y(GF~?lOx2BB=B}sbx}im__qzFXKCBOBXi4pq169H
zk^V5cI7j8*jL9=Nn`85L{RsJnJM^acM@?P5Uxz2ajwR+hY4nef?hSd>LMyU=@X`O3
zQ8SeQwBH0Q_ld1E2vXWX78Gv#%9T$!YkeY07L8JVDzLyIAkFiaeQWE^>`$7oG5dAT
z+R?H|PNxy16%jw`YQJQ+flYY)$iU|Du1g#x$FWvAo6%G=FSaOMUti{*yI<I!!=%Pc
z*>?(oZDAZEd6-WG>+~1Ll`Q7hq@;=j)1E4yE7lbEQ(0)kF)4?~bp3qaq|?$Kx_N%+
zPqA47c2)rgl<}l1q~f_Cu5XSQ0NpTOUM_JVeuo5IwBsS91w^x*>0nrT2J*87Eckd~
zWYLlHZ@l5oV`16bGDl_=!T_;uXQk?=i2UcVa@})S%{x*w^c@%V>NWKB+q#Nfd$w=H
zTm2OI0`U^=5{>{lMCmraR<UG?nwPBX+%xesZ{;*ShATsEO7Fih<?+Wl1xyj+mCNZ@
zVye*tocbmCO@<(JKa3H&Uc2qi6zP3tJA+>*5#Dc0s_kq|@IBLrH?|cYUVUY#>Oj^X
z@PBk9TCgD|wft1RY&WZ-Am}&O2G!Y6Vo{y!Gpy?mRu>1fOkW66C~0f6l`$u}I>WZ9
zU$RCpPik9tG3n15L`6?f@07_@m>|@u<y2tg(^p$*zBSt<b?q+R|6u3Qe~CzadxS7k
zj@6OX#{C9gW?g3eon1GhqF7x?Piil6F}wt%zy<KHFZG?OgrGJhX@QKo7G=GqtxIC|
z6DQ-bOTwtRh!!BQ!3R$_z^B|*@VZCP4sCXYS<fYuYsSUQNb1XOi@~teNs^i=fY2Tj
z{Ru~FVEb%2z`hVCmHbmx;joe=HR~2}WqN5Lv=mEhdVhqN*Au?|1Xpd9o;cnd6<zaa
zaZfF%hnXCB4Pe<bPCd2r@PfH_%B9^59PT|}XphfxkDZ|SE@Sl-56MuUB<9Vn>IxzC
z?6&013?7P+XFBlS4;slP?|eNv(1TqZD*TPt>NkCT2jw<PZau9_J1ThFRRv+TQg_1y
z$iWv-yYPXbIuzhG_yQAtXa2gNOR)X!1%q>sj{fn)z^M*O-2WF|{r6%tAJt49JU!wQ
z?*UK9C(I7ct=^kAz9=WRt!AYeT7_f<D&T~0eW_-~Uog*pv5}bjN)w-hn*m&%9BOQA
z70!1)>!HqIsa{B-eo8~52G^+9<In0hpp00NM)7*ILmqEeC)d#|%?<<8-dPPmt0Wf4
zV4?Wkgv8M<hLY)l^uF%X(kVmH_`PvTsb~l#;{WUdaG5lXo5FO@*c7c^ayvV4w;ql|
zqSyD`$AmnLo=4A><x#1JUl#!DB+<6ha2&C&`bw}Q&Y^BH9Eyq7rFqFr9qMHNFUk9y
z!p3bGaENm*R<nj2yN1M0W(Kmst3}#>ZS$jDm%pGpHT2~F<97Wc6u}aj%hS{TZvS%|
z*P<X<f*7Z+A6z8gXZ0k|%ok5b<XtOSkPylMNDVT2>P%HaF8u-!R%N&<@a<1h;Mb|y
z5Odl?dEW`-T-99+^tevhFxZHU6hu<|M<=O^;;&=G7g3+LlWZw;b>tKr_;$#V^2Fs7
zF{w>}mVHvc^8`+xje9Imy)c>N{{B7imk7Div9*P$br;t(&qjm0BY5bbsbT2;b=2OR
zeZ8BP+4^EvYv#VYVSDja-n9j^%2JKHx3#OV&;GqhG|?2MmFUc)hdp$2^1YoUXYiRC
z3MR9ze6^1H1`EragT+&!4}TI^<z&hKRJ-;q*~J#d_f((FFhHElrEkUsqs!mkNfx1J
zWvk@%x26zZh?f@{=ytqtJJjGz920Rc6KNC;bNJRn%>0uKiL>GFh2AALB$cc+fuEE#
zD`k3JTF!tnJVR02KgDB)%L|2ZK(Xt_1fih|!tzN1x0TmJ9E;GY9Y0Q0zqRv_@=jbi
zT4+xT@U626G>AhRtyV@qzm=fVd9L_cj(l};9<1n_TynUPVx`2~0*NA~&0{XX<;8P@
zSTgYE!kd!pFRTs7N`CKG-TD?m0MJs(!-QX>9{&jEJ_E4Q1f=1B$3cmymzne!TlFbv
z0PDUxA7mef^-**)_S1Bn-~PpCBSEU#0c;Q_`?YzSU&f=|8y(+(Ew2VJK&$%cQ>d%f
zy6^l@-ip@4g!QN-6C){9U#A1KK;(4vmi)YWpay-6B)Ql{h;z9DH9sRnDjXUfF&$bu
zCcA7y9^$Y7hxeoi3-p0hlW;IMz*aw17g(DC@IUdjc%dIlo9`N|NLWo0*LI4=(TR>O
zK}B|_<Q<5n)|Zb^xHvO%r5H1&!>22c_EA%Dg?e#C8g!ZLW?j$znu>&E3q`Z(hL%e~
zLyCkdH`z9oY)s0*jQ9xlB1p5+xv1B#Q<P~^({KDfxlc~s$d@9<HW+m51a;*E&gmmI
zcktV4s|krdQx5BufIHLW4rh<AgFkr*g*0X2YeE>w;9GnH?2YIhXLE0_%VU7f;%}Lm
z*fWv@Ig+?<^*4c^T$*)lOI9XbG?$>(ajA1WlGVRLH<1;H45&p|o2<+dWr_siQ^?3H
zH!b1IY!~AlkwTXb$zhy&^>#`JBRmcLlrct;{N=JJw<!wFlrZB?imJZrrt<@L?6go{
zaadrTF9(f|e408YT?ZL=Yy-9^e>+~3Elq$cfh+}Zt(;APA5wt@*a#9hfd{JaDy$#b
z6D{uf2R`IDa3N>>f%e_t=%`}yN)r_kqJRZzqvyVC8WVea*~hGe)+SJsl-kfe=MEj$
zYwnt|#|quuSX5NnIBki86cs19xeFOG0o}pf3=HsR_wj`=8qnYyA<em}4|3*@DA3RR
zheU}E!QYWw;G4T3V#yzs#4oB#ZT6mx4I;Iz5@{2~7+Z}g4C{M6vE%`%$MCt_o57*5
zCDgFXB9iIJB;|!2!-OOlZKz1riI!1!$H(uC%a$}{zu6xLER=5ogxgtZe@&=R$nn}X
z6qtMc@+lCAxsx>1VO6HxK`s(Yh)+v;tWZEIT1BYG2$zYeE{)yUvcUHBZ3$kQAl=46
z3zn7&k}|NWlE(LG<ebGUR~m{h2Kn4n&Wa!oiKmpw{zZ$#3p|gd=|O$S_<rje*QmU+
zYg{v2>_C3A;I(9vXUDMZ8&n}=g0Efp`2ynz9-+vSRX%Wa9XY4;O!yk3J&@?KI;m^@
zcF(JqkczA95hKe;Oo=|x<*!Z@{X-KxFisEpyZh)+p&meCg{6xcWrzc&lQFV1w=cq!
z4O0V3F6)=jTbGJooj5mvi$g-FrJabU6+C^%%j72P@r#iMPSfMtM|v;SdU|#+?8AYF
zCr<wBOuwZTCmBRp8~i7N#nseT`ex|%wi{3}SEe~R{BWyvg?h3@J)Yr%R2CT9RfQ&}
z!((bQXl%g@wdtG~qSs97550b)*E*K+4m`})wl;+<g_bYsiHDOW6dcL%yD+F{GAyl3
zug`^sk18PCyB5?>KvoCVab1rn%EVgn3|wC$ozv72Xuj;Yi@JVZSMPg1Cf`r)gE=co
zMIL_%oBLE>4z11m*5Y9d^T}H<t6;qN3Olh!)}9N4EQQvp`nRFCA?`Rgl}J2BHU-|0
zVXT4*oWBWxmR_K|3dM^Kh+S=4@>+4Fp0CByJ2xMGeq{;sOjT}zg|fmc>32R0X%?F-
zW^|9zr`i73)Q{Qc+^3*k=w{Rlc8k@B9A%IphF@^v=6I=&SU}g~W`mLSwEt!~Wl`5X
z?Bmgn02z~nSb&`*!Tq0tYo@?B98k&^RCG{dd}qc0?lf=j`+=IvZ`kJ+!rzO0HDqe0
zQ#Ql4=|qKC_X&=NYh3P*0@WLfZGKg;vRSN;E?&b>EvgwuA&2)*7!z2T$tVvso_)bu
z*hiY1z_)lwrH=o6;C|bv?PMSJQfeO_J~hTTmNX`DFuoXFT+`7RderE>suN-0m{ZzJ
z2H&h~-jG;)GR6qUBE|PTK8kDzGkRyg(SsXQ0|YsVIsOI0OBXU4=h*@WH&T8CAuE+k
zsU(!7Sf8~s`scOD1w!K!jlF9W*zWHi`uiXbU(bor@<~R%KhkRk)<DwruAPf&LN`yG
z8`#=ogs<`P!nP&S|KQW4$fls+j}^R)irIO}=?J)*rgKVTva7oht1`+ro0!5tJBfV4
zbC9v1L#GtUux3zC{AxWnD3lR>@<-oD_z&m;#GZu*wwgMOPjA+#Jlde)sS-8bC@k_7
z#?MZDeb+4Ox4&OU2VFnwdix~}lC7pM^_rwoUF;Lw>Shnb`rM$lY0LP$Z+lnBPVLOA
zpqO7Ugy?#~qwVy!%qSFptvrV(LthLPQF=&M3<)rV@WlO=+U`skIj*S|x%YV-KLxz9
zu7Gus2R+VnXqulT?As16dSho|du!%4=Px=_L(Q<t4MTS#FIH2rr48MkIqR{$(U*=%
z={qfb@o*u!Nr(gdQ>zNaf$ZU9D6&I00&_=Pnss{w`KTT7>R7{uDP&7JXf*EL#7FMj
zkqw+8V#t#LzNtMX(Q{>)sVaR#_6Uwxq6gVeUGh91b-fR1e*yZ0sjBxn?WN0Y-o>@7
zi&#Bzs;1HMyClE~1WFf_#I+qkiv$;p9lb@Vw-vtY@G{;eG`=yCPn_$q5neh9t}!aO
zpsvVPR9!-Lnyty<m(CDe+Yh9KHzXM&zW(!V;nxF-akl~X<X<QG7}e2eBO@07Fy?8c
zH?1HJ&vDyq%L{eyHm=Gd^7`10;f54<Dp;y`)yfoemFt)haTva12sYz%qUVWotzjQt
z=JIa}wl6@Y^iM*l!IOzcJLHP_2k@IH!)p$+l^sRou4>gQs5-mfSdc-mAvoVSCp?ok
zJ{^l#cPaJ|2`*DUe8(S(IBqG;<a$xhnMFfW*2p&)6ogejE)gKA`CfP_&dHEAN&MSr
zC3+28MF^JWY@oI^MUX>5gu47*X}ex3sw#6zSoxTYP=X?KLG`#QrKY@nRtzLG2-_E<
zfzE}?PhDKCPP9Y!CufLMBP&yS7$qCf))8$H)q~nQGx$<crTi7~tz!a#-0n{*xM&Fl
z<0B#l5`)-zR_1~2o-kE@xN=y3{BQJ0n^iw=tO`Vx_AX%;na%%bts`_Cld&PEbItR0
zK&|e)frH{sEADWBuC27DIa9i<huS<!6L6LPY`FI2w3X7h%H7H~xE5!E#LzM@Wq4-P
zbJ@%jJ*^VM>uF0hRd;a!iJQi#!bYug?b5yT@Xq|Z<Zv+YpaFSJ6SA(5Dli26g$)%q
z^6|9bB~@3FB*Ml?+X6EeixRZS>@#-%F0ya<Rj*5w0ZQ;8<~jYK8$Cm>0rFSiTzFo%
zPKzvK;laEATq~qk*XKbfZYexoN}{!By$?!q9Ulxs;WKQ9(}K)Z!)3=*e7c#Dt93;^
zIF~pfN19|)b)QElF=rj&EEP2>vEgQnYT|7&iqmWx2(AEZyxV>S1QM<XvgG}g%R2+~
z6?1<1HP$F?g2AbEJ=6x~(24dxFxF@K{MC7fmr53dBI2P~pR&;NNy^n;uL;$1SNXbi
zdwlje;$9955{iU2?LpmbzDlsQz;bqI;PfOCiT&JG(1YO|XJi&e#1jisIHkeX=X;V4
z{-HFD9NMPBLy-Qz!zX)8Mn<5v+KHXn5wqZXPwq>Bxuy95R?dukxn7C?8?;Y=;$04;
zZ`A$Gx!ZsDO*l*;CT0BQJJ-q>UYsDz#zK{AQ`CXzPSU{NqHb9xPM)-f1rmQ&&V@^+
z5Mx)6Qb2n}8;J!i(eozu%Yfr-^Tl(c1)Z8GZpfA$a~N|<S}Qf@iR|YE%)c}}YkYTH
z?lNYJk<YX=mD1c~P(r}+huXj@OUP764<lY>z|-TZ+=~~BnK+-t%!7y}wf)vtr41sP
z3~6Kq+XfbvQjp_w5G7w)%A!4xtE($ez}t@Svip}J=>?Q>g`roy(GI=uK&H8eej8(o
zsNYZy?Yczy5Qj?)O4)06PC6mYw%BLF+BF*WBjWp10^)IDHSED;J<gx(8tu7F35r$;
z;`5Bhrpm+Us!8y}a}@pVdkXLLF0aYR>AC}SY%$YT2=xqoz+KsH!pss=UUK>$_fR_C
zd6eR%^{rla&}e?sY`?oeDO3i+&Q0l`&V1GBKJsI&^?$kez+gsBsmY`x8FO+;NE&yS
zcf5Wt0VLH!!U4}dC1&dO4j3Wp;7=9c>GU34_=KdjdRt+&Ps<UtgSxWB0$2fPsUA1%
z*k{iA40mK`^#@neS)Wz<JG!|74!@-J%&F@33V7n2ZTT8F+C%xiTfoC-gp&k|B#42p
zE=Rv#Np_4uoa)0(+-J4J(9>^Ep0drmB#baHHjRi_MIX%s2Sk@vXB}?cN2un+jxM_L
z56t%w+t}6>h^-^GS0nQV?xcF0Q*(EqZ$|q>Pk^T69{0W^-)k{IjyPIiUv$hN>6#-W
zzh6^f9?aLq&HZ$R+B*3%ym<&?vw9l3(Ga_s)oozzf~i|US|fP0+7g@9A6vq56o3M1
zYLJ32_cpw^KrGc77?eTxy0ABRp^$eH26%|=+@yw25ig-LO>2wX_bqPYQWIaX%$)WV
z0rEA?LA~%NtFjVFW-B>%?y5^yeNFaP>rU)1UwWbsLhoK&Z|_4>bFzC&PQ&V(T(!hA
z_Z^IN{*eFxqQ5Pa5R+nl=dF{cd}~_MSsS17et$QNCY!hsH=G;aE+Y}Oz$}^x{3Z!B
zmI4}UyE!r4&GoYUXwEAA^=hv%kqGfrFl{|6vl>%0Q^i=Qqg*c)ph9m~-7;MEW^qIn
z0;T?RDTi2&8^PSf>V{Xrl8mj%(!2+JZbSUBST8lK!f(MnC?7r7;o<C6t0tCx{k^FN
zLY<t7oJlH(?yxi>4KL*e<K~qRI_Xu0oIEQ+BNtgLBYj2hH|`3~&i)z5C#F`ZdQkH{
zzsH<i!LFfydow(KD-F$z47}|iDFW>5JHToFbM679K<G~?HN6|e-Zkc+`*4&+kn?NF
z%?|;x-6)`R&_!yNx8M@O+pfKy@}MuQg7yd&7@o!8Fq-(D#&w=voyCzrB=9Zo!Pu#t
zS;G5?qGD>2*`71>dle$v1*sT)?9N0^46&Jh#1+LyV9}BLD*RrprkP<M^MdY|y=VP~
zwELRpE!~<&GXi81(NmKrSXRqt@89_qf^5GA<lxiWaVO7lQ(Jh#nstp89ZYZ^-XGaP
zlc@$|3y>cJJCKKQ1kh01Ir_H7n1rkA#?)TP#LXDiZwc5wSJqK??e>FA(TmG?>n}#I
z_1|77uX8iJMVO1sCtTCQe;YoIX7s~YFj{%NQzai@GUCb^vMX=$B{f5&QVOPQ8F2C*
zcC+N&9A8oD_zpd<^4QoK*JjP;Dm>o1#O6PYAv16-h8!%j$1Uj$gnl?8*Jqd*Q3=G#
zAcD+65w1Sa%^#PHv7Q*X?q7|Y`YmjQ7e0$#Eck}?x-fIye}rd|IcI9Btx6pZ+ikm7
zX6dDU1`PjYOaz^T$(IOZoo+1ePdY7`GBxtd_WY`1{`e#nE)<zQE@Ju=Y&luPPQ)Pd
zIKV|n-|7YtV{|NV?22MDpb`XvPeG*z0=OG93?Wx38$FK$97D_6hgTR|O;-~Tr@4+N
z)j8YKw@jEMr{4z-)c=xq{;L}K?@aLjzve$rY-a*!s9K}$P31v0sx!f8a(_2_Oi~0*
z09dptdfkzl8CDEzr1z-=h{8@|QlsBeCcaio?-hMi#7-zPtDjXvvC2cY2}ba>i8@Q)
z2{XhL*toy#UO_p%sUZFdIraW=1<f-@2bDE;ZlO(vgDa!V%R$E~`k;=LE8Tz&FBP!Q
zAx_26A1)+0_X8zMIXohmF0A}|j^(2~vDl&lVR%ASbwO-mWkKZ!#jFR26qRO9ybfaJ
z;zKMzsZMdU>3V=X9iQyDD6bEi<04l@oss~z1<s`RH!>_Xp}dQcO>rn{G?2S&C2`T`
zL|F>#QAixz!<$HMR0qZiV<ENObrB+zK~_AyA~RZNH<yddb6*9zgKSj4gwwANFW-Xf
zAv8^jI^?9t3VzuGE8XoOa^iSf-5)5@vHNze&3<Q5)lKgdb9e2HccO5!Y-(8q99eQL
z+H4$d2})VqEK*%23k=VpZCBTkK59yuZkOxOsh;S4#E@n=*)>`l*+USATQ=NK2009+
z?oht1jgf<Ai9V_4=k~YjuaM;8%U2e9uxVMM9WM(wGV~!-G}rGl5dEj;!JQ|NGE8w#
zDg2lH32S{>4}5*61!NUQX?hcK*ogg-9jF+C%j=W3Q&)sLGe(3yOiBKnbphRP4_K+{
z-@Y#2<AqTAbl)TsR-LkSJ-=-*iVNBVI+IBq6O<4!xWVpJe|$j;)X`#GD;VL8bmdnj
zcHNbTYtM^jB7u;T1a<z<Aj}ey@Hy~gmYSKDQXZJrJsgi{;M`qisc)k3k&t=(=^9)c
z3Yv$Z#Tor)mswnz7S)LohxoX^v#bfqxtmNLn1GmTPD(%EmILz82J|l#9PRjrF`G<g
zCkD7hT$3y<{PwN$jze^hl=c4hposYGn2W`-Tw=ORhm1wlXAIr_+jSM=Jk~GjvizDj
zDC-8PYV91x<V+_#5B+Bw=yW^h`_G>WWDLD;S`-)TS=ns0`E5@P!`6oEac++7k`Sz;
zaG)xuzKyCgPJfg~E02n4M#o1#NmUMM-Dntgby*MpkE3yT%iUxgq`Sxl#!&UiMYQ$e
z+J5&V@E;!EbyY$S-UZ~#(5$y{M?boti=rhA@g^PzXv_GTQuvLKN0dTbL+VV=gVC((
zx4hc8t<1>y#eA*nigqFmF~}|*EW_$G4@n4GPm~HH=wX07Y<}M(=gNW=;d>`hDK@pI
z_|c=19>B5?D?=stOx~6y8N~07JdR#?5hS(9-rT?72<!d!hD`{Uo8geUB4!UX5KlA6
z`%{@$P!P8GOnlz)0$xn$!w$YY#~Be*nzMav_L=`sN0_c7>VYqHs9;dLhJKI;T;t}x
zf9c^19Tm|N2Kf~Q`&FzffA4P=w6ruf-MchoiR^*$w!k@lum?ZtW<q{n$w1yF|EYKO
zaqUr(Q{NcanPFJqv5j#+wJji!zB6!i3oQHLH&J7&-@`jsWLnW>+^{`RAPp5zLIIkY
zfCV%hI~g04Al}Q=U(@0r8>1QX{Y-rH>!V<sRElV7-MTmx+rYj!(pg{Ii3|%_%ri76
z<c^DaH@cI}W|i~3&wfh=MHjQ`gXLcp#OfLTWur3*a6U3`3tY?72Al5>Uw$+H!0Rmn
zpLUpmHT{Z~-*1oy_3J<C=wM~`Jc#+J97v|*miGVpaQas4aZT;xSWm2!#;;~!)-i-r
zT`^sxXBfxFw^&fuV$a`c<1K3JzOx)+!kXyeR$QAs)Y`A<yFzwXIa~51znA({%`}J$
zRe%va9^Ja%IOHXaGW;847C}fg?ReaV2U2e>05t6&-eKW@frc<n9D1${wVZ@P2BtXe
z$e`wQpjGlwUOK*t?Pn7Vmb4XNDtvMBxI8~oXuP$Wc09XQDrH7@mRej<I%Sk|Id2U)
zRF4FkXJ2m_n(Tp$k8401CC4!T8%Z*iz{dJ0Gm!@D%v&4STXI)6D6Fbw=(pyp5OI+A
z4$EbD2#$O0dJwt;CC`k}+R@aU!IuTWxzs2Gro6<#mnExu$8C3JB%pm}yTb$M1o#aA
zw{(df^O<0k?rA-157eT2M6Xh?z*5B59poInXKpwkrmnB3U-t1Zy-r;Z!A8%4l%LL|
z;X^H;fy<HHEeY%mgp=gz-J5CEa6o2|*8AL-j3_S*0-yxYL#c9pupXmxtJCIxp8IJ{
zO`N(Txcv|JA{>P#buGxwKCFwJKKJR{1~mhVJAU>1sccjO)_*c6Yw{DqH$vUi3XFfO
z5JUWBrO63N$OC>^QJGaYJkpQ5e`I9^Z?&Nij$)IljyhojVqqJ9(Zo54)wHp4U47o)
z8@eySS3PFe(2tUDe=u)Ws;j5tIhjyyJal}1Y+;Hb;VzXeS(BS10o>X*<eXiDC{KC$
zB*erYXwxZ>vyft%bs5PuBN|H`^GO7|6v!0ct|<{zFoH!3)Y7iuVp*(s85wp((Owhb
zlA2C~ohFYyD#R@2O@Rm5Iw&zRFgDO8r@{dZk<Q-_6#=)lx-*c6iw749cG;Gnb3@a>
zv{4Gt!n}pRJ#5gL3wUepqqZ9fbp>^Ck!`)9;wourLT19ywHVq%r@0rSv2<^RrLDK7
zJqh*Rr(LD}_@w-NK0d(#rQ1g?L%y5!>AO7iuHO;U$wqHx5xQ-S)~#K52c?NitBoe3
z(6X$F%55vl`ZYm@Y~p)=N}<2oHeGN85|=+dc6ayON`c2U9WeYtE!nv4Pg)yN1>I1x
zUz}3g+lET!?46p1z!yHP>Kh#1%cfP&E9B*kbn)&@04f1#$$qe9A*Fc_ftdDt6~JlF
z=N#@f*D(tA5#I)3sW~p(YUeyq*6NI@Hs|0r(fxJm@zfXOKl1b8VNO^Yo0Ot^m+KBW
z`F|y+2Gl>0hs7JzvGhOY;r=N`9HjR=fc60$Tm67AGn7@1He(}=sdtXvlWoVXccP6Y
zNFQf!Vrt^I>8#CS+`oS=ZalL@8^V;`*`a1gX1AVP3M@1&INfPh_QbV}u0&2zQ+HTC
zo1F&@7l>ai(RDupoPtwE34#V4VY}Y#opf>htIP2*;s1z4nxiYqd@F{@S}g#}V(zs%
z;DQ6Xh~u@6K=m=l{#-;NN}<hD<2j<{-+Ij?y(LcqTPuJE^1n|=AG#EOei_yW%~ceB
zEWm5&V&q~8wV)9OdfMUfdz%6}tI+SeULhjUOKdB}Y7_2yPul}($4T5?D0nY1Tp4fP
zL)F}*0Jo=7=<4OT>1%M+;|Pvau|H`1Ge={YRu~=35%|3w!31d|?xy$$XI6<#`ptus
z(8tr%Dk&|CQHSX!|5BR({Ld5L4)6AUcD{knA5aEWm(<`GVqr<yoll}T$-cp$k$`us
z)(5UmqP{<uc&4tg5P^*AyJHMKPby&R1~4ER0lROiQj<*eRVQCy*u@1w*5G)KopIJ&
z)OP#ZDc#f-y>7MP)`#hZ?CMI(h2sX+OBV_$_<06p_%h8({KAlAI{BG>!hXZ3_xVkx
zXU;)p_Pgc7zGOyI^8~Lo8hh>9qO*Z?(|vGZi|tqN&tSC|2i#yjVBql@R^f@iu)?F$
zHn?tZ^mx23(_H5hSkta?3GT$bDAnHTKIekHf#%fDYvExm01coDb^Q8msXb>|xd>dF
z#MJJ(GiUQQ3>OPgm$=Cb`Qz~l@0@PH{e2xinv7Hc@OPg}Av6vLa1F_tFN1-FOv+Vt
zp~yB%?ldm3U7k?NRbuPB1_c$$%7jj~Df32UHV^1!F0NVBE7e(LN@v^$s&`oz?aK@8
zBi+in$_w-27-eE*ib>^nZ|llA_e~bEbLR_=uIi>Qlg@K0NtP$+VA^GgqGEHs+fB1U
zKjvaCLd7>*V1U4tTxRFqb?%V!Qq`>^Lce}vOjwOBzC9l5A}`))^<B-Zb(+%nc=!r>
ziMm53ROTE*Q*RvZS{}Go+f-T)7{F~#7#Kb}I2T9)+Xjs{SDep6m}Q-?49UgdMS$@(
zD+nzy1G>ZZDMF(eFi_RHKEO1miQ}L7ByF<>G&j5vNqEJun{9~NI{a|!Gt}0kNVJ*8
zn!Dl3Yr`A{qkc3=qw=wWKO-Wzs^)1v;$_@8wsigM5fciHSc3Qc;2@{(q65?;_4Zi@
zVVPcS5hgPd*5;jhLQ)hDT?Ss<_u0zmUDeaqaI^<Oa%P8@eZstec@`hO8Y_~#O;sA%
z_{bu)nA%2mgsrf_N-tUHf0?&0-jVVH+_Gcj?iFKTZ{0o+akvu*c4L6AQP-`+gYk9-
ze`oQoKwU`#d;7)g?=q)`l}oYlBArQax0!$SWn22;DwdG<GdPzR__G3xy8Pdc0|5X%
zwm+7T-+Zct!&yCg?gO`t22;cR46E$wa{#rf`f%m*5ak%eJS)~0j5~H^IM%K*Ub}3M
zPpt9<D^*7OLoLw}`}d_tvc}b%f`&sw@2t!jxH~Ks$|w8x1PqhwF45pfZYNe7tyOKM
z4%S(KhJ1&Hi(xT8Oi4I~{?oHS$45LZ?|wVyR*<bqp8-eIjV<hv#uV=fNmaC?+Dy@j
zkJexf)djOlh^ZmM=#>*Qm(XfcEFU>}lVkn;9{t&yD^b<t^9F)GW4d^U(I>0GL)^pO
zV0bxfMWWT0hYfunwtzt|dL9aLQHJCJb5G3DazZ_44}t|@2eg0>2)XVDJ~03$!ns$-
z;S7S0CvQOTgv?o>`Auw}?=d$A=W?_wG~4$Gx~;(2b3;BF9#48by9Q+2Y{ve0_?`8O
zY6E@7h|2s=^PAXm+HFx+adZe8%?h%%hW1nemoAt~@q&*BdX%;#X*7}O)+xK^j2&<9
zn%F1JJ$256qZ7`*D@{L-A1koBZ{E8ay0O5N_&^6IRoC$F$A0_6SYg`15C+EUZUXRq
z){Z03f(*KlGqiMu$1NqU<KmX7@^Nx~Vc;_Jr^D|%Zk%G|Z;m>W&_OL77k`1=Jspnd
z87C63JWx0jL+$JscNciKUkKWBJiLnl)7BEQ;0{`epKQk%9~;bGJ^#AEWPIi!W}A3Z
zyLw4_V3;7+<*BGjH_ng2NpGnd1XVvf{?tP#@bL)ysO?A6=$9n{<BDat7;#{sN?U1}
ziuJN142rm6`F4w0h(oH(M-^>9pE;*b;h-%I-ljev-*&<0x@-suzrXwFFaX3!1fVA^
z&!uD|K+8ll-REu%WF3}XP|u1~T6`;2iiVb|AJ(rD8CGwDGu|GW=A_aK*f4+alaaHx
zyRupR_;qiQJMZ)B%qB;5=es8>chf>SYa`)=b0hGo%Ea78r(P%N7iQUZu7mQ&r7LUt
z7h|kmG4Z+luH`Nj+e%pAo>XZZn6)wBwm*))etCyPz%qx4_m+4H2j3@^R}i!}bo1~y
zWNjy4$t1Yf%1@`Ty{u3WiwR}7N%iNthOmPn;?e+8#9&!iYo+|%Lcn_kYOX1!z4lBD
z{5er(%O$m#_%q|_bT2LJ@iL|=3%HhPz~~SEHR>Z^`Ay5!)&(Pbb9AEt*m?=AfViju
zUPn|dTEE*x0M7g=myORWj)|#iZ8~eN*<JsND<H66n1gvKQZE)B6NQ}YXFGXr3X}eB
z0kfJ;%ywkE!)_bYRWi9iB*U46XzutyTxGgZcVR3hoaSUcO}w*_Atds-jG?(G#DNI7
zxwpKmAD{bv5Df4W_Hiw7JyE<<6O5V>TcAXGx>1^J?q}WJp<~qZRqcUe69jw7mr3tG
zJ8zAAq^C|=uz0@U8r)OI7VL@G6B>P8g-4NKXV-Vc3@&hM!~!o7<s$?AsXB6B@unmI
zz9>Zwu)+C-C!pKSJv_E*)HfM-^XSK2IWoknNH-KXxv^=G7I}CtpV}FK2f>Z;LN3ZS
zW-!4upC^fvsY=UB46jh~LGaiA%X=N+5-}3&?OfNu;&-4bEqX4YX!PCRO?{vwc}a}s
zb`EKVXj5V!0q*e;3sP?0T5E2PP&oJi4F>t3F8a)pSB=|?{v9iXnWwNH=0ugoSRQ5g
zfI3R9<JGSb4|8<KLEZy0)@`)T6RY^B<>2f*!A##1QZGyt_mXPjj=GSgGhzcyNuuOu
zozm{_<x@nC5Ac#S$<JyywH@=_xSjoqANR0M>U9zuanDK4r3*x+M}iBR<_HK#1_r=L
zog73qly+H<)-xd+N=htd%3V@-XJ^Rzg$sRWlHjvC<VpX@v$(4!(MK0#gU7xM7?(6)
zR%<Z6WZ(O-AON@4%etACIKCa4-hlG3w>6t`j60*n!5TKN5He)F{*VxEdk#%3)e+^l
zcDsMlo~%{4TBbj#t!CR6^8L<0DGI{<UEf7*zd7T`G*w<=%vUsbzoaC}stF18ho3M&
zTRoBcQM@%U2Tr3ql^?t0C}<H59r<D6$u(Ua5l2giR$}oZ5%TJ_Q2L1==B0%8=uawu
zJmNEewKEb)S?Zb|R8%;HIWsaK6js60b9@YCqKX!Fy1Sc@8@}Te*Yk(O?iKRz`DxCe
zzW3;+&ju?`eI^s1j=rN;u;mPjV;p7o54YNi6iJ*+o}vU%!l<5Rm!oLlr~7k#w^cfb
zGh;O;GNT(v^j)!_y09vbdPK|;EV*_Z0+7g4O4%n3zX&H@n?_AiDLFfQC<+2D=z1T+
z1XnY-9osi-r5ztFmo;$<>o47}XS}Ov@FWyRTOF}`3V8o4pCb7epyUR|gVEBT)gIn8
z>~}^u;_I8bcix`7Ym%`vqbAKsEW4a~JHri9FR81ZnQhdTiCNsKB7S-KBjKP@L_657
zoF6^Cs-xYh+i18R_$lusZKkYyIeWf+dzn$UK+w~?d|^Rbai>(BdsyKvYp;EU8N4lF
za=L<$A6(<*c9a$aN=deuIaOqq6(^7Vi%7`a@vf2@)%Zsw@xJkH4v&<m^_zLPvj%EC
zDe;Q6-3yt!hAyT#M~D_%<d3`ngI47W^Vt;Cl{*i~T)Jek#+K=BkXTTveq5i1r-*8y
zHLXc1G6$JK{&o3xP1vi|&$pQd5!r)EwtHHTwG3lJknP)O`OiWX^NlWECLKXF34^A!
zKal0>$c|M0igbZ$ZDE;K<@Zdfq*-fp`2}+j&8>bG3W{oEbF8YU*(%Lep%^+Pg)}KQ
z5`(CXZzB=v6-BMbh$g9(DjeGJ$J7^?31O3Um0Z@`Mc$nB21Y8eZp)$Bwf3OYYJBVY
zjdJw`FrB3Qo8oJqoASNvB<4(4>J&^UP5fwul`iadCpa6KK<p;;#(jT*wBCM#rkW-a
z2_40()|p$Ro%V?2adY9QiKB#xXbXCr;z`w8KNc(xEnryJj}4ZZGex5Ay(b*y_V#g;
z>1dA}A;D|GngPd&;m6IdM3&lCQubt0g-I*oFR(kk+n{AyoD@!o{Tpk6c{<!)a<qaP
za_-mKmHb2^?QsP(Z;B(*5l%Es(G#?imhxkWC=M~nxrc^#AavshRmyf^u!9p$c?X!v
z-*2r6zzkO6yuNh%2Cpz%E>0%x)%P+#?ff*tMg0o?cON$tnD2g7_(g9RtI0j99Es5;
z^Z{U%*0tmU7uD{+X71nCyBlgRHa2A^@`o<)q~=_cFKp!hH>RG=I2`7yB?S)9)p^76
zloH$?-WE`5A}M|DK2^x^_uPFa$eZnt7WWqR%jV$?;(u#`zJDd}dj0_IpEZ|^q*J~M
zJJ)qASc-<Yr?_;00jjik`P{}@64&F>70B7#F6M|UqaKyF(prh<r)tI!#iih~X@R?W
z@j<j}U$z~yi_O|@18tlr$0p#^ja;`SM4CURWN;8mN=~QXGBuopt}T3inR+xxQuOob
z*fG8!5T2TKwSV4)>2j{4K6s)$*UA~H<3Z8mP7`2>6H&AIJ-RD3e9nCB7PJ`gcWV+*
z^%8^ZPlA#=1vRPKc)RTZXn<0psyS;LdoOzF_5GbZv4sm?rs??pyjZ!rYZB@qO5)JE
zWZf;hR9(TS*JzkMWH(WGP+av#VS0O(?~y>Tow2Jb4jWN2YW_Yq8@jXIcG$<+DrFf7
zwEp;^ygtQZfy<{|vpIQ=((|Qxna4sBv}!2+_E+<vp0lQ2gA@~;Zm1lHE98+J1hvC{
z_gj|@9H-~--=P<<EUqVQ&6ud+JY~?7`TT){`r7ePPApVb*o<`zSxD;Msg~T}L94uO
z6d-$IIlF**ngI)(^N8>+r6hLJdBz~C)V49AlwN&dZ(U#X-HGW+1epu)KNWOBH)T^r
zWu*>qr-(7m9E1q+ktEHM!%e@W=Hv`tbZPV&n3dQ^zq;+zVZi<b``b^?jkq7c=`6Kj
zg##3h+6kT-xXX`5a}S2iV3o>d)Zg0?X1khH^{N*5eF09A5N5oPheOkR5&s`$Z~Yc!
z*tH7-l7b+hbTf2|bR*q@beACA-Q6i5or*AY*U%}_4Bd@%3?1L?^X~Wf_HWzgIOY$S
z>$=yq@;uMQ^Kx8TEZdnIZO>+Wzjd7ReZ+-*cE}jjm&z$kYy<6{LpSW|!yeo`S3Giz
zQ8Wxp6o=clC}n*FpZ)yNt%oxsQo)06IYgPb&Vh(I!hdf~#P>7XMFfyToa`OMVD6Pc
zP%p7I4{w3B<Sz>bY(vYlM7jLP<<S9UR&p#F-NgUmfX>QmGKhQ5NpR(%=#5FSDFF`-
z_lJ2Ja?`e7+K*VSX=%WllPgL{Y)q6*^OfljWev(OaQxJH0`Z1}b6(t4HrNVc>O9?M
zh1XXC)LX$IA#2;xq{}i$#?;Kr!n1m2DTnB8-4RPY7gXFf(8^K86Jk)WQU0lN)V-b@
z#lDg#pQ|7hPTvkBsw-h;jNn2C?a?lV^X1Lr8x}(Z-RfI}LG6MUPlB`!r9A2W$Nf`9
zR-?eIzaET?r;}7ImY;fJuz!k@k=z_K0|{v;3B><-ikQ$=L{OFh><@R{YoAyx!0&f_
zz$j{V7ee$1X5#=_c-9Gv6yK^Qx+rC&3xBMGV6cJ`&H%Zy3^(;Z`zye+c?hGmxggZh
z3ecA~)PK^X&=I$TgyJNoXqQ=+;*?|8^^}IJ{NQDN!6ju$0+aGK*ZHYlzhVhps+tL?
z&j?1eOu2mEMX2LWSjZjy0=+DEhZgvXWZus%jcZ`p%GPT@7Oi!yt*&+2bX{RIT;kRe
zFUPZE;yz~sS~?E9Wk4o55D$m6x9P5syG`~nz%SK>kNcnP8ZeN~Xqh!j#JxO_=&*bw
z1SQaVzY?W>k9oB+TmgFeB}D`5RdSm`P&T6u@zR8`^fhX$=~_m$jg%}jZgx5n6aR48
z-wESZH{lu+JFy!0b5Va)SziQO66(;HTF4FVU+!r0t<<rt<51TJUpl7#SuDBg@C7g4
z&m!&NT;h>_gIgZmVV|WJC8xC=l|%qJWC2b>cvSj&|AZI`kj(f>o%HWE42RY>hZxrk
z$PrjAu4YIpM0UxcY8;Fp$0DhBXkOT&w*7jt9i1|8SZk7|5VdYCI#M=O6L5#+9~^l@
ztxEe<VdWXpEL=BSmtVL>{UG$BC(_%e!@yq?b{>@h{+i(5zm_uq(>{8O1Tc0}H~+i8
z_7gEqDgaXkp>D1QC9+Ey{RfU!%D2Tg>BNa6<>z-Xj6>QFYyIG66<vFpw~cAw859WE
z(=6OtF$0o`4$HCf<M=A@a(a-I^egWYvj)0V|J|Lz=qvb^2|bu<Ey?AI@E@^qvSPiF
zpHe<9xh?<ml8owz$d)5na`@q2jw_Qgpnw2dl?6`WCyVtky9BV54RJ|Y{|hGpheo1{
z@Fs72-0iO4O5bV$^T81(ubx!xe!e};wsonYz-4>Dc6FxNRx&nE$_BjT9*S_;u7wFn
z_@4mq*Hpg(rfTYClsjSfF~AN5JbPgLp2#}%yDHkkbtK!r<_LeYiNLhz&I#0UG1-9B
z*%h;m$8{z}jW4z38Ys|dT@5ho?sJV(VWC`*9ZW+WhFl843DG?u)y-?+in>0Iw=%T<
zxuY&S{;P84{98R<sef(u!bF^BMqli?mp#LBYghdblsGW5RU3~}zInN`c>T(R@tD>9
z({YI%UR|Srr3+N<Km(Za$0AxX;pSyBW4Q++T&|z**!(?V+TX|MZIj!V1DvqfiaT@N
zso5%Y$P6b`JRbr-`|s_AzoA?x5Fg<5?A=U5=kWn@HLYUwm-3-bX*yABK`u8rS&f%9
zI<tSsue_G7j*c*i^y?=-7r{NUABSs7!{421Inx67w5bUAzcb->W$zPu(MH_*d7IN)
zpZabs<}e%X#gzc-|DqHHPM6b(PAPiw*6Cp2JDCUb?SNu%L-RPVgKMZp<hbHQ(`J>h
zow$=UkGA^7k%sH{Pqr%3RL=4?c9&BnezC65c2g=YJ?nO_V2z7AUaOV3kM3wtn5WKW
zef*SMz%hxKZ33g_0qpEkiISuaPxDW=qmx*OZG&B<?UA|l5@6J&>_DamHLg?(5VqOK
zibs@LYr@Hc^VN$#tes~AKxujmqKy}8ME`~RYl}fNaDZ>A7;FeJ_&!tmLA%m_1!>Rg
z_(FJSEOwdK@;N6Pu3WLKdNJ3+v^E3A^0B#o+N#!FHnvp9y<x9xcBUTD67a`GnErr2
zUgzA6`D+5ne@(zsFBfV6m;fC>n9oM}Z@&AQIp~xGbzIIJdP-i@+d!V7k>mtvV|dLI
zrb_MhvfJuS%Ga_P-4ocYx(Kv_%g}jC17BP9f(M;=WSY19QT0)M_|C^F=V}sich<Ez
z?cLCz7CX(C%XqT2G+)sr#$`{I<|P1aNg*hg%OK^)BjYlZzKFZ6dz?YsbNY?}kwl4J
zd|3z`pN~8U7X?g*Qgr7Ha40q;z=^Q+8T(lY$ilaf(je`*k?H*xVKOi+5xA9x!j;$l
z#O)P0$+{-hIKGRa1~12><cWXlGaa>EskORurAk5#V*lRQ*hKlq0Ac>CtaRWjdtd`!
zxh-zDc7+)D${~NhvIn;{KLNASw<Y*Fo6mExU%p;2fEtnq&Cy4|FbmG>GZJ-+Ix&m0
zo<DV6n-gM&qg2g=lC0TcvQG~sBxB1v2LI~zI)RO*?-5+q^xpDMgl*?urRiuQ*m#%Y
zB<eo?Int3GE`<<Dm%F!v&#<gCD>XAU%iS8RPbwEmv~?DzEN3nAr1*Zeo8$bvRmb9T
zdek3TnQw=vTPvQaK4frN^<)x%%B@T}EYm3^6lj!A0lQ_xO7$S%t5SVmeZ|TKwfYqn
zaci{k?{X!ne;a)+=o6G|z^$0AWyJxvGWXZ^ZLp3w=Q)5|(fZG=+*vQwx4_TjpxqR=
z$9Ib2hml+Wpizf|Ul`)n6B%XTio@KehXH2^i0SK{9G(dtju7Wc0wbA9<Ex&r*E(8a
zHF}bPqVc<dyZ?GYf}99!ZE*Vc*&bu@eR5So5t)A+R9d}!hp~=rW>*aB)oK~?8yQYj
z1MKp??Ebi+H+Yi=rQ5spErxr1AS1RT{F{JC0%jKN+7{<!4V-}-u(Kn<oF^UqfCiK?
zs?!B!4qlwjkZabO{MMU?LSilLrLyJlq23KTYI}#+uE}Sin5^{9?Zz1PANURz&-ZXl
z*E<QobfNg^lUI$gVbhEbPQ%K=EAWS;s%0lN7rx*vyyPmwrWZr6X#XY23)~I(8)v#M
z>T}(%Usk@NiY50?(JJ#p*C?=w&McibRI$6Vr{$epwBD|#QD;3^K+Q%Qvbz6tD^^?I
zAkE@x6JIe=%VB8Us<WteqJ1*Epj>Vs|7*s|T35?{=H^;#5xQ{f^+BJSQODNbRFtq<
zTh)3lqtP}aPD2N1s?@qW=dUP_R7y?Yd_VA}y)SraUFhOsGhK@KXSqBb4uZaf&8iw8
zEPj)f0T_hV-)B;Wxy!jq2;5=B|2`9~2i()_2TsI09|EV5!YUTDal=s)XCa+?>%0rO
zr+J%!GeUKH@_^?1cR{AXfUf&*{?Ed9!1|C%D*Z&nz0F!M)-rCeGwRHmz#cB9#pqt1
za;3@6=2%sAQ_%b5D)L`(DgPKlju3OK;af&hQ;t@c_DXY?-L2~vFlUB!3#v;+^7KmU
z@#N@dq{a>8wvL!9XN3<}t=gqBivh*kY-L+by3iT7*?am4?RsxL_?G@64%=FLTS)s1
zvo-59U+EbXPc1+LWboh)IH@O&Ei$0C6C_8B>wqiQ*CRAy&oFApFy>A-dOz4=V8(MR
zt;v$F`a54`kUE<sUxlAuUL)2tWXL3Ro_UiH_AZX>U5s9v`qs1gn`oprPTFsxB)|R&
z;B^`JBMIN~=m3~9pmR2(FiLUQ6@BWFz1I+~q7YhD^SWD!8R*kli_U8Mu=7eXo*Z?L
zN5J3tU=X{1evM^6JDIyZ4O4B4SxI(?c|z(R&F)>aAM(d_`|JQa@r#r+PNatj%FeO%
zb?qqqQ)UTp#!r1-j=PdJuX99q6`--6mzE-KhpjE)*dC<Ht0mZd8&f=Mr0k-n)Oqz2
zapP_e=0BTRdbr-Nv->atyP7FKvQcRAUTfICgR{EVxu2N%**v*asUd4xQcW4lV;;c-
zufwJJ2z>%S+LeP-t+cp|0Qn68#`NYwm@wGtS)l(*!zUQ*LzyKH_*&Zt;Zj&7E-wP%
z5?gfl>)#-l)LD(6=PK2_RMWZR(nEe2HoF@(Wfi(yFf@+57sc>Z?I1#`@SCABRjMGx
zeI0ikp$6dq@m}cILEx%+aF0pI$JXCJzp5~PPE@j?#?kq}+#c*v5#+P);cEk=G33hs
zaT3ss70b}BKcPc5A$<wSmAaVeE|}lNWgoe&%6<svZ2tLM8nWv$S1oQMY79}Q$>b-n
ziMApY!SE-~mVE0q-{ieTYft{S0>eiQVXPibAKx9UD00IN^yABLzUme@=<nH<&-(wc
zd)fACRTHfrg*>aD_m71g*BU&j&L$VF%HvnZWoA1Y<pB?6`G6U}RR1}wi;)q_234AD
z0S#ah0Nt9Mx0&Tf+S6x`b4UbkuiO8#+Axnw(x=#@(b8;wmu)J>q#rtXxY9ZOqxgWc
z<fH<c&X(AZmzcZ|VMJ+!Q+Lm`H~V9hICaqVfRZdkoC{RjvdtMEjLd31lrKj_;wZsG
z$hAEvjbrgEM)*Etgi|&F^Au>~PI0Bch>aEK?NJ2{E>IOLI!bV=n?(;CAW8v7z9|NT
zU}<Z``xTkVmU-ml9`xvCH1G&jcR4n4uv;I?vm@KE;)`46sB~VZbQeWSR=i;+7^`d>
z-mP5=LKR<@1OM-;Z!lQ?wt&Wv{Jjg#*%8QTUi`wUgNrARXWrQ1vfHY$%bZPKRUlz_
zsAEeCnFVddXfkPW`y^7;^vUJrzL^x_T8oNpl5+_3C<tm2@SRcBAwNLjM?lszKF!Qy
z;?S{IA>!EZE8LnfgT|tMVn%v1ry7W)ne)3aP<6Mj!vAUkj96QQ_3#VqVQ4gC^|J9e
zG=U@+Sr?&AGf9X(pPUDa-K%N|-&PRHoH{B7t&FH)Mxag!^I0qaD~mfp``4aFpRt<(
zv9y?2JT(?|LrsP}J(<~l`97S%-7ODjKiHovh8y3eoq}28mYG6V0GXy)Op>lG#z_H#
z|ENG&7{B?AlR%PG_R#dVG@?%30Vv~udYn2(tQl`uSyg%TBJ#Wqu7Vp6$+D1Bvi#dS
zJ*_#qL^*twGOfHu*tA{5S<`mMi)GU)#8t7?If~Kj#4-KPZ?8q3Fo=QeIl}>x^SM?G
zv3iV=5+K^e!ksUL)JzMZV1o+7?T)t#0}63vSF0LF_7+Dct3CXq*}8qM|5jcF_E0;3
z5H9CCZ>>fqY$IA0lxy!H86rB2!J7ApwO6WK*$3H$f(8(rZ0OH=ay9aI%BHoMk<%#8
zZ41I3e~SAxO==l6FB-j|X&DElVw<~5pFIccz=)Q>G+txd3c{78^M|CG!@p3AG)(E0
zj;?*(rw_9$(4VC$u@y7WtCB}ey-yIU%Gg4*ar4A?Fg#M`^Pc93(#P@9Sz}xvyv_CI
z!h9AQ72-1-wwxmALDtQr*o96q(Sr2CZwvvyGZxW#hMy-{!O6Rx)Vs6hfWM@~beTkC
zjomf5LKE~oA5Q)=*~Ccf3q(uBw)asO`{DLR7(&a!m(7gq>K8IJZV97XG~3#^RFXN#
z$(o8!(Y93Ca+EpcqIv^=d)~`_ynmyrWx4D*zXa9Qt8Sh<MlUIVt_T|1_oK7n#xDFQ
z!H_9ITN5;Q&SJyLV&wS+H_}6@0>H^3V5_w%`C>id7ISbg?jMoK+wRG^;eMa9EgM_z
zDQDuG(~9Qqot^o;kTfLla^Tc^kC?D`C{eJi|E0L@=T9z5F4wL-``kTdI1}8>Vc97M
zb6Vf}x*xeDs0HfJvV@lRa`{7z8ec3!3FOY`Q&S62L!s9#7nRXhx2{x12a=t~2PfT3
z7TKp-a&rdry)#l6Ob73z<Rpyu3uIfv&n6d9jLr?kS9=MwTHnVQjkDBL>shO-IbBGh
z8n5$RtXpUqYKf_uZHf;Z?=y=LWK~k|3dhyjqlxf^Rj1oF@An|i%7~Eo#TWe<ZmxMP
z?dMIl9(w<+!%hCm9bKCvPab-=+XeN1`Iz>M0r7?Gm6pkR`5_Ui;a_U-EMX=Wc@Lx2
zeidbWA0F$ix#e6Pq5_Kk^h2v>n!m!=Nl)!(Z<@n(a^-6s18Jp(W(;uML6G~+oBmZ_
zEaBY4%{yrs=CQRdags<?Hk-#)@#n}XUU$}rHPOZg#a;XfgI>GF2PCau6om6q+$j~L
zxlWW}PC9l8*usq>5Y`JDQE#cvoMF{$K}Av3`dBIKossiZgfAZ%w<KM5V|~KUZg)uj
zDZ4ope9ij~z6Eb?n%yvEZvn07mbmJjeS8Vr@=`f6TwkFYlbs2#3A_$&d**;t!>u;j
zc&i8&peYFwNj+c?JwbLJ93F$fv7iNKpc*Gi2o_IK1j!Pn>(u0-ik#;QF|ThYU=8zp
zQ|cv<g)5_}i@WNvOPy{zrJ8h<1weQS$L}56yA%%P5J2NfYd7fQNiL<0@*BmZPX@C2
zDH5}#MO7KLb{=<hAj!Iy?so8Jr|<}MN;pNYFq>Lm5M+@^H_jqx8WV?_DVPn~_9i#$
z{Hitk-EEZE@D>}kg&bF~)R~y%JnPsR7>wX@e+{TE3dG-Kpyqv!2k~M7ae$7)<(LXk
zBiqA?oM+uATcPmR9(4WKtRmrOLAoDHjLM>5x-&!7t?Sq<wZI~(90_+MX5WcbTdP^)
zYsyY1GO)1BbhBL9(Y>+cb(B$h(ei837dfXS*W~c`8&-Y#o-e<Q%?(s@Xi}DUTsk*g
zx~cXj!%9)dhP<iZR{J5V{*kdX^EoC+S1S}@Z0$i4lp<0`gx|IWNEhb%XEbmovPs;w
zymJ%Zuf?S9m3<d?2k{^Le%DZo)nh8wb^%P6^u4w~V!Z8y0}E0JiyX3TsV-Y}-2KTQ
z`IGQ_j$c4%ZqLtKa+yJDEi!G@&y4tO&;!kV=ESobp<u-?onQ7h8oKdXM2%TFG1^Lr
z1_n+a`BFtMM-gfwnb)p5>4zpYz-l;Y+dHqbv+y;Kjh<>(O^&(*8$b;F$+LE#>K-0H
zG&;Z2Spq)3FyX0pF@3xZYU<6A5_Bb#Nncrb5(!3Vzp7FerB+b9_s6=pPQyl{1I23F
zNuKe<9ZVA#2;hF8aU%D>315w96E<Ajp(1&w{2Efsy8aOFA0%4old<C;czUV6)bzGr
zqv0NqmG-LrK!CUg^I%`&>Csc9eyfd}?=PK$sKV!_jNlOyPm=jhQ;|-2>Hjk>&`<Ug
zK(wT}DU~ovdA;QMsctpQI;raY^on{1MD{mJN|SR;csaOeD|p8qIxGE=zbd1gb4bfp
zv$nlDxco>%cj^q>$Y@723A@{Q;yK85$#17&87=j{e<**nVbi=XzG`)T{@S!mRKL>E
z{5<mbk!4{ub5pL=v^-vrQ5P6C0X;bI;xEKKH?#1Dt2Xp;{$PEww=2QNWIRea2?HIP
z@3hhlN@&o3T+7Y~ymuHokl@cmjq*d33OoBno*lZHDt&xxk@V0Qbf0LVNakt4lf5X3
zz{VeF$|fq0S4{AmJwnd{`*z+4VDFU$FE0jnhGf|bBD-wkSK-bZ2FwtWj%x?+VP39H
zGl*n`2__9kQz=MSrzE|xluc%h{#GocDp8!)To+yHg#ETzWBeD*!=)C`S#Bg(`kTN0
zncYbWI>-$;>AmLg@OoK1=CS^+I8n<Zz=J--gDO~0+wM)RTbBv0{|uQVe_IsF><{ea
zh`b_wS9$T)AsVzJOr9)ErZ(T?y^K3y1Tg{R-?P|;ZDGpf9|Fik{ITuZk3$yUBucEa
zRdMjd*F(R_j0$Ucu@+c(yxuJSE$W1cPX2@gzCJOfHjtP<{xH^y7NdZ%w)7M0#j*zP
z?{jxiC3)01V{4(Hl<%)KW*Vwn(xn8KbN0$Of4Rm&quaYESoO$ydbM~E42VgPZ{?}7
zB^cXdM`9JrD#LQ=wOf*}HY*N*v}^1)7C7P;StTi^>|DcTdu00=kjkWGUUX00{HaFV
zllQm|w|ITXLfLxrwj1jQhe&ITmR@+&7sU2;$CwU39Jdby0zA*!-&T7cZ+QziSU9zD
z^Vk494G)2c|4Zt2RF_C?W`7tTH(pxR+cXI~wbvEv!+ZPJrd86DMLZ{)E8*nEu1a>Q
zi4nV{C%_0X|EP3uNr<Xz_!av(D3>T4sA-9bdz(3_jx97CpMj#5qa&s+3)tX@Q2PD7
zQwa#iX~~(YOx|(vRnr0oyC?D*QA<oD?xx3e3`)Bbsx{Bk3+D^;ruv+;XAMip4b{JN
z6yR}qM-g*?9@qZBF;~c9yyVoHdS7-!w5pxJu=@SuDi)sq!I3Vk)PENc$-lb${3RT&
z-0R@#p$vQn&ME!Q_}p>=JIlDq=;6k<deL}QYf$mn3bYuiRZ|XN<>jB`VV_IY!FBc1
z1V4`y>+!)Q8Wn|b%l*6bnmGXcDTGgr&FkLVaXp0$+kb0f_u?XAu&|S-fpcyM?;9fI
z{skz$XqGUDfS-$DD5#R!C~Y9y@DUC?h2<dhRXSp0&`w8>Hn3RkZ;Z)qsspJ~>n%U-
ziMYbU=b}AzBP2~cB3VNEn5cGsMx^O~BjV}N7?CO6e`!+v=AAlZFk^u$QqTXB#0t~f
zkIZtVwo0RCCL-47&X2!}oQVyVT!A++5C;SoEKxI)Y|sxZNYJ{we^jDc55WOiAyH<}
z1Jqi}w<=`NjcC4x(92si=fNnrqcukLGx5Pxv=g;BNe1KMq-6aG7=AQRbNqVdnMK@*
zjaJA#QM)zn*#`sOYolAT%~2Ng=g+&;jvIXDrKY&~^w%cZ<O)xX93D?xdUsERO&F9m
zeh<$kM^{{eT4Pk&_1*Kh5)SMEL)CC$D4@^<HiTMPJC_8PYXuXOM3!bW6VAX_w-&lZ
z$IFqUw*{DzkhiS<_)@gt?1Ds{Du(!8G-4|Z%FW|%xB2O?rJ0#!&xtugdSq>^hbBvG
zq-$IrD-(--$v8ZeI=OFl2_OzQC+!v?Vu+^)@sy(R25rm;mwbpVG>YC*I63xyfy9Oi
zrluc8efzOptcQmEuXd?q(u{SU=xh}IBP%P)jeV)vcEuF~{0eDBm9uhtEob@Vh-V#6
zc%1Z(mj<k~?EE;fx`fVwhM7QcbW)ZrE3@&_Y)9vL_M+Besx$cFlhFLVHLa+<jroFb
zmDGtWuhcVw>8{eoQKLk_N_rQx<DLfZ<TnMS?A(T)$jtDhP+Uc_e^4#{=w^7@!yW^h
z@w&(}TBF@^7qIQVY#Q-&fG8^VALktgDhPj7k8DArOkEn09ni4TI~iN^%H~!!KQ2Fu
zq*@#s;@fU2jQ1f+{qf}^P)vATupNDK?Cq7y&lE7CS-s&%tlA53(9X?~c$L-6lAU_F
zABJ58IJ7??78*Axgp;sPv2!^IX}2#e&XBSF>2>lgkE2tpT%FBTP`#D*dMB0ieI?^;
zNK6!nKQ*s$&p2_59q54*<;aIit$E_-_4%cOR0ISA;bU_6;sXO-!6#bRth+9?*T+Cr
z5EOz|V2=4fGY%PFcFp1Me60!2w$8n4#TO^gfK3T0nmzKotwCM1y(oOjJXBpiCAG$h
zGT6t8_)Lo=Q&&Ldhco>zr0|d@axgy9-c=9KUe88xv1@)Jlo%VDb$pUODfI6|JeZM=
z7+LK-IvAeQil<~N*-t6e6CvK>U$6<#PD%l9Bh(DNm%BANDs6++--aR7MbxDkChL+V
zaW=u&p3yHFPvj;YF!z&mE4Jyd1)b3<pZ2^@Th#^)?g_b1{6Yns(Ik@1=LMO75+<KC
z>CK^2=ek?Z?sYyJ{r<QRt89GQNe7TOom0Jt{@upF)69jNO-%@L;{W=Jc21vrj?``L
z$Vq=M#Sb#su^60VfbYY~c}Q#gZH$UEnu-~1j!B+4iJ3IbY(EAhFHcnesWIdfbH&gZ
z21u+_M#K3c7#z@w=ROE&*!hLdhY}P-GX8R6*(LTS-CTXNCm?a6`1btzER^l+UYXp;
zoR47uifIpoI00xl<*;HAe&yOPl;_CMbn~L~^RJ{Icoaq%FtU7KRX(M;uQ`LNoMF3K
z9nPfJ_&72|N-6<Q83S3%|7essEPw`ho_U8=Pz`Sd3uPl~TLa?uqq|?@T-l?_>ZIA?
z;)z{jtJGuD>f!ABxP$TxaO*4M5-XUR&;gD2ZplgFLgmhqm67^5iD9gJ=R;{rHN4fg
zRQ45ustF}7d!<6WjFZ^Fh1HP4Kl48=8#K{LaeaV^uCVy7VD<s&#gNr^Mv+lXc`8Yj
z01cP8jmKvEynHkPuQ`a=jnt@#<xk?`J23mUsaCTHT~G{2Y~UN>^24D@fL*~F0vZW7
z&_>4smW5Q<@djIfCZ@w>{mJlr(J}?pw}zeK8Z(TziSlOUoh;RHl;po)Q<}~#%t^d&
z3HE3J6}Wu&Ty~oqxYGVD4VWV1-$@Vuhxnxzv<L^y@=XuP_Jsp!5_b!$CXX{|O+t{^
za?1)x5A|$&I-HQ78%~<xPytbMINOtfJW)<x+)_$HWsBL4@MTVWjONpMM?qt2$e+ht
zYM&EEyOnqo&dK&{uR<i`Ox&DfRsaCQ!8;e*<(FF|E+Aoo7pdF+e4EW%0H|d)b%Zqc
zp^^be$sctw9-jM`=l+RZ*;HuPZq(zmEVE%kdk5E4Ywlf}?43Wr@z@5sJ>9{tmYPYs
z7e2p~onPq|^T&Zo`)~OB>jT7^lxQl^`0f(Ju8ocd5v^v&7xEJYSqF8B?43dnL}BeP
z5t_3WbkiSW33|<8$|7yS-$Ok<1hnhP2apk-bc=4Qfp$7Ni#rlIc0RaH=<ebuy+Bpa
z@0R3a4J4cBu<#EY@iyG(FK4kylLn&v!q$GcwaV5>BuAU;uNU^7xWtVjT@MdbcEiaE
z-9AY}xc*Y}f&YZ=GI)<5%`D2KhlOwC$`3nmF4R|BQs1`9y1GuK*JGQN*w(?KAscSt
zF3_=M7(Lpodvox(t9C&@B}F3&KI2FFQeW};W1&^#SX4;q)C%;*JH&!({kUJbuI#g#
zu7k?1bUk>M$x;8v-Ma4TNv=-g2zof;<SMEoV4xgOkxIj*gz}#}8*k}@zSk3y<x%aA
z;4ZV!z6m7zD)L}D(3f!wab>QM%Ne5MCGA8P5n8cXVcs`+Sg`w^AsHi{|FOpMV*?N5
zG1))XShOva8-|!epAaG?aH>6!=L^WxlV7+MgIe8Mjl_^c_izeyb+s_QW6Qs_(v<x}
zWXf}o@0bo0pC5r-X7q!_ad4L-+J{}k9$k@k)Jk)7-RCpTvX%C*c_>Ch@+-<F$l`~Y
zzxK$@6*xOar-HURu={)pk9RymsfL|Tpp?!Tv7(mdu-@^M0&0^_x;R{=diO|Ev5aZT
zsmJN1yGVmjYcQFmh{tK;7X3h7GO8iq<77Y}$Q74}EkYZNH+S)|mwc%Y(kg#50;9*1
z2&(AVYEgO0VJF!BfkxP4lHA}X>+j~hb_p{v0!7sB-m#Bc2i3L&4+hid-NF=?axsnh
zbjxKI%VTeM<P8l2+5_BI$wSIpf|?DVFqj(cOjthlD;cyNb9HiEG9o|k`2(u(v5t%C
zMVb|x$*WdD7Y$h`^+4)OCHl-2CMAe!i8kSExKX>hoHBhNvnlumS4n7(&y~=^|I$B#
zf)#Dy;2C`)9elI#>s>);;I3-GOr{O{oNp4|alk4~Zn70-GeEs`ArfegT0*@Ti6@l)
zN3^C#`+smxZoKa&w7eOxwQn1|`<8V$%gs%V{bQv(TYgE~efgbzQCA6`fc_jgQhgii
z&h<2flLz&Y;}!M*V!WWw^ILM7_a~&4kd6$^`jaKHKI61oMR*<3C~7}{z{rq(<{;XF
zX~c57)&f9cD2(->Jt)eBmLa;Sscur9Gm=c_Dvy6}^C(<)7qe4r{Z*4&>j*M<2(GXw
z`A?m)Jwv#O8_K={+1Xd0^Y7(7n`M!L8nPT*grL5<E6G{zA0evM5m{HfUfR%f(4$H(
zY4S%9#VzB0-JLkztpd(`8ERmXi;g8IdnO5|oYm8%P4IY`p&&sLN3~u!DbJw%&BwuL
zf+RUA>c`33cTsP{ZQNgfD5jMx^CX4;KlGhD_=@nTh&N`rBxLhSoO(O&N+r|TDn@ig
z^Qm6QzbhQtNw~Ffi27t!aa2q4Le`oM|AKzYtgT3JMVM|FhxTXnPBfxS-e3GAHKL_5
zn@<n^_$+>>N2AhKF9;`*OQIXQIg*B9*Pc&5Lys%6+TH_Ie?y($iD@p<W^E-4H1vzl
zKuKWr;o&LE$LQ~574>h?>5?i&uxxL-1*F1{Jq%4T2U?G!NkR6@of{hP)iGDL9!awR
zvuogVA)SCR@&2Yq<UwjOeV0<0Bg$b=Y8q+pLgYzSF@XE`Gs5~lIO#p}>}TEdtJpFc
zUSi{SnO5gDZc9gQ0uO(mi%?v3wE=eCc7`0{-rV64z_MY9x?M)7(~I1H<)runZCnE&
z%y#CZjr+-dB}3nM;A_@qrI_WDp%7#OR=e1(tvtSB-Yu2+nsXdFJd2mdmNg)7g4L;^
z-F+zXNHPrY;XwQSLqS(Osi@<@l_qQ1&vA*7WWZt_aW5E=a0!i|v^(1P^9R*B{k@R~
z<g;7w&Eb@G8M8ETTlx8MsQ>w^tlJ6y56=N_bM`7<r#A<UJ+sHlRGc)w$y*d*{#R&&
z2O(P9YlKUK{HweV-yc!SAUUT4e^QP0PM$)Z?INd@c~8iyTdE(u-3qxX8j4D>RurHG
zP<wY>^-_tg&-%5xV9DAFTQMlO`}2T~n1$_uM_uC-rdqjep_XktPT|LLP0R3NDg+DJ
zA~`_2b4U8(X#;h9!9rR-2#;ZQJ+!gWQ1wZPVy`hzx+C(F8EGR8nwNf39;eAR-nE})
zE^5`NW$@@^C~Nv|?-oHAGQ!^3!g|dg<2TE69kr1+cS6i8w(C1VsKYy~F$TP`l%84M
zDiY@LP(A!CF2|+>DK86@bq9>w8Zz2=a*Z@%vevg6!Ak}o<)~{Rapl|hTH4E<hh92K
zr085jV|#~T<?b(oKlC)QuS@&Klj2e5RlZUA9Vtj)Fwp<t%Ul^&MSx8xU@asXkb@7e
zlZ2!QIgQU97&pRKx*9Az#LaB-*Uxk(t`34%4<}!F!ln9!VPx_X9a1yKU7NrbnFqm@
z^7xSSve=@U2!}&fg37V}7O1uXZArLCRQLs5V7KeN<lX^m&)4Pth2Jj#wdIg0$s!4b
zvOfv{e`k&On}mJii=H^dsH7)P!_kv`hXPtXva~5oAmLU+`J3Sks0Ym0v2to{dHp(&
z%o7QC5)%mv+q$D&lZszO&TJ3aP{LTWCZ^IJGj=mZ=RDAs$cUVU5pVo<L(yB--$Qd5
z=1KyIV7cUr>;<oy1`Vr7Fl39GnUbQ{S~vOHz8WSLkQsy-KM@;{H;~hOOcA0pB7Sgg
zMiz{8U*+sh$m)UpZ%c9ay&}%)<K&{0(WRes?^Q9iC{}C)T=wHD94b-&yGYb=`6C3E
z>#a<{_ZxD-FOWWJz8r7GLQa$YH`-c`JOJRU?{SJisJm))>$zU8FY-IGoBoMh>XA0S
zykfX`^Jw6WJXe|cwZtvfs(vA+R|6?~Ig@y1zIwh25~`!N37r)v_WTLQ;$<P5WDjf>
z!X_W;j;0o65?rtVQUqOzmOxG_7oZ`Qhq=?utwHwN*q19Np(upb`Fn<_-p6IKdq_@#
zrQ6*)nv#*Is!TC$5EWUgga&tK*{tvZO=94OIqlZi(C_T+UU||`&VcAuNDP`R>mhV|
zD{*IAr@*QC>Zd!Th)%w{2E>&nM<oHke+jw77C^G&Qr|{Yb7QH<bNYXEw+X)UBOT5s
zjWEQ>uEoDv<HH6^pZ+n!N0!8VM|3%<Jc+fPEAE6ol+vnYpw$aYXR(oh(f<i1u#^vY
zaxWXJ+;CfpOtL`T++{Ut8ViJ1Lrots*XwY?iY7j{bd-Hr2g5KroMynlx-3|=eY3s@
za*I#>#1dauiI?!TZl?Z=Y_6V8pB{biH<@T6Q&%Yuo8LAv2m=WK07@ElJPGcIRG1EJ
zeEHiRgLoQ->2d#iZf>fGNcwNqSyhToo8i<RL}H1A#Ry1ysvi|rvwHeJla$E44K+QV
z&j$uj6n_U$<LUQC4tm|=x3i}+@oe4J^W8K44;bLaN@F)JY92YE{c<?zWH{0&JPD6f
zI<2{_NFq#GE4PJh@@BN(yHfUmKH4&?i@SWfB#J3typ6bO<_BFZ!}-!>GrXuGY{j9J
zv=zk6DOyu4<650{CxP_??DggWYEushpN1~mw1X5U_~sk#1|Ax1KblXiUDlo~kw>JS
zPN5Wj=Lg+ao0H9MbqJS+rXIh;+b0JAvyB9j=vW%;{(9>g#zQCU`RE)q`?YSvhupmb
zp6-^Xu?PjjE_}^Y?4j!(0hn5hQtT$I_DrYddbi%}gwM<@pkT}5!)*A<RGQ-%+p}Dp
zI^o@XN8iljV=^RmCAlj8;q~UO^7>KZHj%3Zp5fCnTeU|kYmoJ9UHo;@fzPdgK`Wtl
z<?Qg=4wte)T=}hd1-{1%uZuH^f207kjU&bZN{6_-n!{J>Lqq4o<}WtjJKVSt&1rs@
z&geLnhkrVpRjU`+LoM+d`ed7FXq$Gm`Q=f)(%weuNE+I3-hWu?TBvqmd*U$yu&e)E
zeDPM-O^U3)-r0G-BVeg#E3j}6Z7fq?`KIymk2&nt?V_wcVdJh1b|=N=367uDsbs5f
zC~mKai}IQ+v5Q^TxmROT@zLFE+$mQHIPUcY9kAuVl^ahc<(0F~3!cI-^ZY+0<+Um%
zAwuGcKvb(O^|Z3%Lm8qEMP9Edx+?`omqpmaaMM;gZyfN$$~itwEmCbrV9T0G=1mlW
zN=COY@!Z^^wBkM2$VhrJ{k;f32qir=`rr!WD>C<&4u11-Kvt%BeQ7Fa6!4uQG6dau
z?knPUtOPb+Eq+Bi?%uwmQ5jR9o+Y87-^1IT9iA#0jv2n>7qpsic4_Fob}tS;zmPM>
zu7(Kh5%EPDbPxvP$#xnTc9Q$Kqc{(1d#-uILFnktj_-lq;~1qYjAu?q*=W?`r3QAE
zVdi;PdGzq+zP*vFF&b78tA<O@nn-YdHFn#r98U|2Cn$BNnsi=_o~gT`6~%WGchBkT
zn#@wykLky!etv-Q^wCsr1{2*7beaSVk{=!57pQizuR8&nr0=&k@H$F!-ymmj2l=+3
zJ{z^6GAVC-W+6Ijgv;A}MvU|$oz_?t41v}K$R0UB>Nt{4_}iw;&PU;&dV@Tw-@Tpd
zLoCz|nw)*YJ7{e0J=(Xmk#s&HC2MvAu!FqcgO^uz<-K!Aum*AIeNb;m9jv;YDZ_oN
zP!`WaVjMuMyFsK9roa{?&mvB~qAAa<ULDp?<qmGH#+FWSJ=73_KWUeim9NM$WooDt
zi*W@a<eyJ}I3ymVI_On|CTW}1@|kf;7S&3=kxN-H6!@c@CcWYH8yP?e8}>(%KfIEn
z^Jcefipp+gy1CTMHFb1T-!gX$b2Zqzq(;s0d{Ozh6^?qj^Rf9EJ>=L5;R3JVJ7tsd
z<69|Z<+bzMH;fZse9o}QW&T_R1L6qdo*9pZkNbuc<J8Ku&DYL0D-f#3p1HYSb=dE`
zXpM>QoMYs1t_1wee$p8GGsw;XuwI33yMs1wNjsA1{cRl`yVrH!Vx9U}1{8(q%$ozN
zD6U#UJT3s}|G(%#IQ&K<0k$MNLPO@m?iM<IIxD}v;?zK^Rb*+X9>+;pjMu2u_jYtv
zgsKJDCG4%07|%wPa_K`N6`AHClX^ekmL(i*@C_6I7BI;Ioi>~5$ZId<w#aI1a#qAf
zl_i5da$(Pa&~4kIZPUjh*?j)s4<Utc$h5R)VIcna%Wp>WEunjp2zH}(ChAG3&g@YE
zAH(vKk|iuS-+d=T{QlT_Vkng>Z<b9=ZtQDE#={d8K`dcF=7EG;EOj;`DVtIuQT^0s
z@hw-oGkb&tC(N#?$nRn6^-2qcs=F1byYLOx?<L*dq&cd{sE-ZOzhaR+ncIp^hJ?3)
zI?w%8)E4vku-R*Sg*P8#SvN2I?_Yc->#fqp%(GTq%#lZJVH#Y%BN_6*#2)(!vS{Tv
zmdzv3?OJBDH+J;I&HREbx74#Ie8x&kcXxIbNmVxgYUybMc?XYLOFlF2fT(M{nTJDo
zulK7pQc0|*&%>GTZ|1N>JW9!A+Z(FDv}_=7g`<z_)U;ExtK;S=!%}GG`GQb*xZwF4
zGy|@bsptz_6az;4=|wvb4Ow4~lcH$v;$geI7NRp8xFv_MDYvnAwcKKxT<|#D_v3KS
zY!2f8qSurl;QF>z^4iJPD3!@eR&=zu)~PU6k9aVloav$PbslvDemRgKb`E-ojLPer
z8C4eXMn7OA>P$`8N_>bd+Nrl?uB5}3ms7o9olv)^`sJD+Gxb3%tK)rCq@zfXfo#AG
znaan(s0WgPov>5_K(bgc#Z)Lu0;Def<EE}QM<7nw6t;)B$76+Xc{9x(md!cH>Kn=?
zazhHxa1(xOs(d|=uRRdF8`J9r`(F_W&e-;L-0;nS#2%i+5gcQ>`K~_1<OqfG7~rN3
zp){S1JqPu9b4Cm;(|cl{Dvml62(lr-;-3hFRzT;CezcDrbD9C%O|(V_&+z@M3hUV?
zEk;9Z8#5wLIP#6h#`4MI)&qr4Uq1OipGbeQsOd4f=sAKJiP~Y-?Vk_YR~k#lU1-$A
z)LpHw0TtoDWO{2_|Ith-1eZj@(sW9n*XD7obVUZ-8y58oy}%QnvKj4T-Br+`AE4mt
zepIVGp^jc|rcdF%tLoinIme{sDGB=CG4{IpzBxO*a%z@#4GW`EVzqj&YM$MWzsyWe
zUeEkYbnCD#C(@mvudoodHrLVTg!h_F1lm7uXNe1cj!Y9l4bBNnZw<A{zLepkb#F9u
zTXOxBYbU1)+@uh7kA@RsMY!yHLY2#adu-KameFxm6)sa|6g?>SBUmbC_p>5d^|eRz
z>%p86c@|0~V>aT>kOZkEDOX%6rrOubj4x3452Ko_ZAE4{kT`55+@7yia|?tY<Rf$=
zRie@-69{kxUO#zY_?aSP=K9hH{UWgokB<1-mUPMtqZ=slLo`_C))0Ow2c3?r17ntW
z`m{{B%dmwJ8mVj<@*3roQZi&|xQ0&8EMBgVleYChuExm4jweKCPHbj;uXR4h8d@_f
z7{7|P0nP_)Coqjrb;4reK+$S<{|41(3GRic=qi2g?s=Zbv*FdA-UMQ`R6;Xx^qZ|;
z2xMi46uNlLzqsJ8PtCE5UU*z9pxyN{3O~c%{vNHMW_I*h*qprm{~sN4CRS<%E+9|f
z__-HOjg@vkuXb)Of<hyy_daa)v(t_7iBN2N9)9tC)VMst^W_MijZJ@I60pTgs8Xad
zSDqFq`~QN01>vgGT``-&4Z2QSMfwJZjAQN^1Lj`*_Jz^R?4)APr+(c`D%x6TF>=*f
zhiQELC5v+&wDj}MVu?_8{`Y9I2Dr!X5jEIm7-Se7SEWlocLs_$sZGiRwZ-kc=9c7S
zqFj;BvZYjOi{4wyj!4Q{rB*h(HLH2=|5j?=*~bm!k8oeb%v-gWprm?tqM_F>JB?H5
z4j>>HA}6#x$98BKv?}D~7AV3``K{o+#6vbe`oD=->1)$7WL@<RP;c&HwI>U3Ki4Jr
zdN5Yvth6WT;CFgpXtaN2TV{)&_zts&=m9q-rz4=TeF|OIlMub*$(wn#Jvim)WlieG
zCh7LzMD(<?g+`?wYfR(aov|txQ(zKmPafEO-%8-SEx7W?7VJQ{B}?CNOOt9pIO3Mc
z(7Qc1or6#1|6a3xc>V=ud>3H=mjk>hF5T%$pD<#~N1N4W#0w|W^)&e}WdokW%alH4
zd`SO9J0W2Rq{hv&j<fFBvc0XaDtThEkk>kXfYz=kMb<~<{VAVOXH#DxI?2N;4KLL^
ziN&54_4W(3)%b~d-_Fyw9sJ|Vr584mrR|h@P9r}n3!_!Ix~#7>P={gOpkH2@yd38z
zsQYA=iITJ8hY^!4ZrDiZ`@^-U=b*{c_bn4upJn`_pQ@rbTT<-zYjuSjvM#KZtIl++
z^_@z;@cH{_tyGD&5E(C9wrsT|{9pq9?=-9(aREZn(@?A`{zpKePEedM4TO&gJm1KZ
zhf`*+GFb_cM=rc=?9E0h8k-%^diBTWWhvhxZ9}}k1?Kzx5ZW-l!_QiZ=UR@C!;U_5
zMQ%a@%(Y2tvTyGwmmZ<g9u6WgNZ5JHxPTi#mJ0VWiaY6K`~r2;M5-P!U%I^%k<>Hj
z-%vt3YonEzALsNUvS`0}p#W$m>EuXpw*`T(3$>zmtZ<T)dL3#{K*%Vqj{7mFYe^Ko
zFhh~P!^@X55*kS=!tF9^-~U7Cb~2~H7vYC25#&$Vjk0$hoqTXOC-H&+V%2F03z+Ly
zK}D|pHGr&u6_0evHov@uQ_o(~<((+j587o1irB#=lI~1wo9_~SUoWiHEkdBsSN6}c
zh%MO!ZYOz7xc!d;OsJs;yRb=)+aiGZBa#5Ll02vFCEs^${0HPAX_no+KV`tH$Z*K4
zOx;c>E=bA4k+RjX`59k<wwY#_MEbKg#LZNUIZIsDB7A;73_O66IfdLD6j11mps%(n
z?U08aJnFgC?cC(*ikx|XeKaHSrbc$FfhSRM2;ejR@wHe>zhmeJgq{Ac?w#FqhP|Ez
zpIJ}vo{%fruKxorq8AhUfBJX8V%sG9yUuxr%WM9L;^_Rg+E^Nv5>ICo<7SV+Epk8j
zd>VuUQV0RTVK;bJ=u}5urp(5~+Lsti?4($)mXJwTdTth{<frVd-)iu#+swUZg@z}e
zFS|<SWxeF+mz@<JY!dR`W^{4h*0^~rkz~3+pa6SUI*9j<{(ED{E@sjYf?Svw0VG4q
zhwP+H1Wwl+t@ioSnR&G(R7I|$_~pW?267X!VPB`fGbuH$5J97F=;a?SpYu#&t&I2?
zyY`E?VKq^|QveFW6N<gspoj8{&*=`c+nO@5n~7fAdyPy0rE)cn>>h7&xY2R9XVt_N
zfWBod$(Z~}CVn#L>6}JtyBpXY-%gS^_Rcl(_QWPmq^fBln+vL>VD}@UGfWTo&=}OK
zXe)3HAlXwXFh-*Z5_<P%pDzVle4T78Dk&PMHis-Y(iLR+o0mSNeI-6?FrfnPZe7ga
zEJG*Wc}lMlJmQV!h{Th32t@exAd74IMJ_hlZEmK6@Cuc^%qyjK1pdis02~?dzj&+K
zK<E10>;v(dtDf?^w>oGwRuIxcMs+I3T3zqjnGCC+{M-URJwHu-exdHr+4@J*esx|R
zdVEx7#qT|>TRIuuXoc3#V&H8tDaSuxU2m0}53Mj*VPHMkpFOPbn$i8qMI+kSkjE8d
zRhUwj3RU$rO7Vc?8djK#0;(N-7e7-C1Oe3!n|&kK=q&*UsgNbOA7L0(DH~e;?9njj
zYYku|yydu<p*kfe>?7EXEX&^j>xfKFDtjnSGhezyZog?9W2Y`SX^9Zs_)*tE#vp1P
zbV(rvXd7O|v*r!ZGI%`SS~Dw;ZG3JDQPDvBQbI0Njy8$^y6QXj<DsS&j@aF2tq^lx
z{H3nsJ#vE1-YP+a_F>HMdDOy*pwg9>nLPo=$M4)`@Ek5yg}X0>Xhd^y;O`V=ZH|Lm
zwSpj7VfjQ|{pT<AZkO@Dc~*tR#vCetJS63nTuSc_J$Xb^$|ZR-LCYW;pluWVGg;jv
zsS6<+Rl|*V%{juMju+@i(=~}eLf)>|TsZibWE0NHtbN1beL`?~d;s$h7`@Nj7BmYp
zK(tJ&#D{Oj{;rE?Y3TSi-Gg9i7%gOz5PKzxK7}T+p8k1ccF41L8p)qRrFE!im}b+K
z&6JL)-$|y3x7qr;i9<K#CM-TCZ@4_1se=kexs(}g;w*4cKYB2BFc1sOzY>8K&}d=%
zkKh$%9=_(Vbz<Jg{91f$0-}&H)6~p@%LEjO!B8c_ZE^U}8=^^Ko@x$};Plq$2swI(
zKHjL~NQSJ(&DjZ_8M?8ugaf)v`Jz1ot^e@nKAk)1<H%Fxj{Ji8U<w>?YIU45VS50*
z`=lWBxG6)mfOZ}EfH=^vDlfe%?X4Z;A^XZ-xD4+ISxU6ctohgk-<4?Fe?0*GotPaq
zqS5+Ff^21ZQ|tE19+FRFVpiferWleX?3&gH1!EK4{eVSkXqPRn4*U}14VGw2+#YRC
zN=(}cFQp|tlx9aY)90w%@Pw1Br|-X|$5N&4`vMA#G}w91MAXUDsDJQ{80o6Bxe7r%
z^?YW!zwv^7gyjZ@cd0nsk%(*E+1>rI6CE&uNZ&#}j1Gu-gpV0NWS<xr`4GTcz~kLw
zn5hwBr_iJeq$FS3He-?spqrZG_N909+$}RX>HVjY1+?;E6*5qL>RpEo-PQiiUeuQD
zj0vl+W5o|Vd0FuVSvfsBOF~O`Tm0g~#P#o=M~9`=(m=}b{?fn;y;;|VM+Ael9u*Mx
zGTqOHOpuw*Hl5HF1cWR8k#bmvN|Fz!uZ&b?FV~9Ns+(wQYX$z~Int`IusotOT$)eR
zJ};K+<kpe#$_@Xxw(JhN=zgVI?=4W8F-qpGYej=n@Ab{7%^L(Y99bw;qk-X-yTQ&a
z7)0HVHFxnWVevS5@>I42%=}tQ8U*DTeO&;q-U9&Qjc)BuB|X@rZ0)kwOmHnVLn72Y
z%e-o|B-_<K`6*N(%bwT5Iw%n?*`E|}^EeM~HVj32E@$87O;LR#xZ?nTO5P$~Zy{8?
zbpFrQ%)knFQ!qW+L<WVB3T|G9J{TWc_D@<dzN3(d)F^|~Wx6K2Aj#Jd5g|d1TMczr
zDz{8PK2jag@|hLh>jwZ}dVyOg<RBAO*bJg7pbS4M=lU%hwbK3YGL<_y;=3!oI_Vy;
z6fH%h1bw_PH9G^2R1uHnvHF8zNmSdXMCnmBw)K@=o~kyI?jNU0{)#K{o?3GN&lmNt
zJWd5&o(?E+<*!~-V-MrIx}NP&9$wVOWjG7IARjLjYu)|lk(G4zM#m-Xhjn3(plb%X
zH?G<ZCi4dpD_<dwj44G|gBEk~C9s)(13K_m8i59!;UxN~0-2}{MTFj07*&-VHkc@g
z+jFV1QC?N~>Bmpk936bT%<X=$?@2|hx0(CmJZ(PHmloE35qd2xjkT;tM>jE>DeCTk
zqC^=Dg)!H-(3FQKxo8}Tu8Q)Q1X3{)D_1r5N0JWn*_huxtfv^Qx*9}AZy*JKg<HUq
zMz9pYVtcz|hjI2Mbj+f%(BA}ydh>-0ECWgzQ_M+6I9|`!(H?Mg+hGdZ$K_|PG!p1R
zQ$j%;7wvuev*udWYT>s+{zeqv)MDIi=L3c^#^wg%$^KFC&6TqM_W)P4Hgksa*jfXu
z(7H7C+hMFkIry&c$_Y8S{TSJ6JdIH(US3?BI_P<eCTzkP8x4kVko2PhwevCFGaDRD
z`%6kG<Fk$2XB4n<juEx;z+PB;+DYyUwY}CmZ;Ut>)A!sXDSS;%gK3;De^%Bx*&~l-
zsRN#rV{%D5MQ@p=(RH)tW@4?Ha3Lk!6$Gl=uGL}L-v>PWp3%z$vj=KCM|Xx>U$|9*
zC04aB^;!bghZwR5mGi+uF<uPes$RGPV0rpkYSc-tteIuFv4frb-IQ74ft17Iy{BJe
zd<;8+QsMhMtCAettuOgqo<~Pa(h>ITpM1W-@drpedtOfFKm5tWKU=isaCy6PdPHu&
zu_DyYQ|Vy-7UIx;6Qovx8WHgS{$(K`41fas!1>Z&n4?EU%4T)7pSaiV%$c~&pYg_!
zCW${9EW}przu2_^P}_@>lwSnMlpPKmw$MUsvBK+|^ES!T)=AyfI#4nmE6!iM&3K0i
zJ{hy`pP3#EEaLHN9Q=WW$UXG+(A@YAd?rF2fT;>cng(}A(L(*p(-m=iCu8~KK~Q3M
z7d1O~$^}}eOPTgyurN4zn?4+U5%iERpO3OA^_tiN1)nXq?_}jf)O(-rc;x|O3Tubm
zu$0=CX!ZG)6=jd)5${7!1>D{0iY;m$XYOiIr)NK1Ku+F^I;Mo3$*V^CfE?qFeM*V2
z(RF-shy5G770$6A)sVIrI%^~w&5@*2K%R!YSKvfNA=$7$I5T&Ad5mAwFz>~sH^D({
z!PO1?G9~G!urW#nU%ACm=9ygK{%kf2j>fNIqmhO8hvsdt342GsHr&l^`$S!!clIUf
z3%C4zd@7bZbwWX*k+8Jp%=^$-BuzMINS~oB1Ga|{YL*{-9d;AV`21A(L<!pEb@4bh
z8Wnad1(7lZ&ITyO3$5NN<+wuqQ`8%tUCpZMc3^dlVp*}a)WDuY5bK!GhrRuyE(d><
z&?$~6-hG$hnP4CLpUwr6<#PE3Ug%)?;kl*X<6QMoRM`f~Q-%K@WnTeQSJ!L_1b24{
z5G=S|+=2y%;BLX)-Q6L$ySuw<aJP%QyX)NVy*E-*^XmVn>J-H(IJfGa-o3hacki{t
zAWT0Ug#N=3jW&F!9iwlEEp`WdfAeT(7&<;7kq>xGN{2xZIhPkge1EpWe7@z%-re&v
z55+*{l*sMGAnH)XIJax+^BDht{|}G6VCbTim)2g>%6(;Q*4plcqdbP-^>zIdkMl>F
zo6~^|M>`PVIqx|2vA`^Ga{RAs!~H!uekr+{mM~X$fMxXLyydQ==NjDC1I~E9fW4Jy
zT#~Tu%arcpgxit>mA|Y3L{$|ERkJhPfAS0+|4jY5J<BI}c!3Xh)MmKdU-0tTuV-6~
zHeEuUV$W=w5Qz&`bV-_AI%r<{_DcnfZzkyDt=RF?+qeA@P}?MnV<P(<33}W~!EVaL
zIATeZSd>4xJerTBeMy-v%v79lcy3aeKQA<8nAb<3e5SPh7hN5rtX7zP9dXcul79DA
z2R?s??21lBeY0IA<&GueC@(hDIAoi7^l)pyT^n9Zr}x={{t(9A2}3f|^@h*Z$v*R&
zz2ler1@Wi51A0#fA7Uw}Dy<t~-771O)$o7AA3;8w;R-R#;CrC^GYX;&F5%sxU0}1o
zGEB4g9`WJk?OG<P?#8;{{4(}VAHww3!~<B}zAnSj{GXn9Zyqy$z}Eb#y+3h1aom6M
zdfR=uy*l%vX?6iDuqx1O`ea);!4y=KrU7@PwH8l)G>6Se&&Z}?Gz>g7M+s^jaP5C~
zOPZW=EPF+poJw+K+K7=~!UB~n!*qQ(gE!>yr}#e+4ve$5X2kq1JTYUY{Z_PANW-Nf
zVGA{i(~pB_;G;JO_3C`ja7YZ}AP%dOqZBjI1X0)_r%6(7M2J&?Fi_J-Ax8pQCeKx1
z?#@U)z*G_7liS;iiz2S<tkC_KrmMlK_D{pc`7pghENLC?2wg9>K-sn`S)Vr=V=ss!
z7v}lxoT~-;-z-=KuhqXY<|86HF*7Y0w?8u5Q&PR62hZ`>-zRt8qBghI)L<AONxn9}
zLHfL$k{RPPAFrO+)<Ikz<it_qmtsK4clgj^=FV3{4?)bUK<XGmREL12k&P%ZicwBY
zdu8>F+JY(MdstkTsvhy`Y7HK|Kod{d%s{nGqe_zz?oN5jG963m+t#3zGQj5<D#%lb
zgR`$&9`mP7S%2+p3`$I7V_6~N{M>_)vovFFz=)#&Z}?>U33h&%n*iHDsfRh51?GMx
z&GX{GQTzTRwf53ItfsYWu6;gmh%bIZ{W7W3OVIt|qQwo28tZ)>;q~&35onEhm0OJ6
zodO@Nxkm#BDLwt`i*p|`S_15y^7ESnSH<fm|A2Q`g<U9sgf_4dVx|9v&#xZ1mnFX>
zQ%6KDY>BOKiQTl^GV{9gh~GeAO_5#~Ju{&X!vDLBaw{31L%`DPRkHhTt=+`_gjr1T
z`DW90^fI?*`m9)XlcDk1Wj}Fta=VAObG~Kc!AEC9RLyQpCD4;&HjAn{>v#rBFysh~
zDE`ZxH=B5y&kfY{fyV0L8!vw#2PIi3!QtVtxSB@8<WwQa{+nek%n!%bh#0-MH>kCz
zBO>X$5Hy{49>78N)&)6(Vpp1Q^o5t$3n7Z?)_mRwwmXxp^$it<;Ab$z5h;8Q2MF%d
zy(8NrQiH*`r|s|#8Du-;!T6R{eq4;n)zq~Fix-lLz))U2+#}#x7WbdjS6`i7(_O6T
z_KQ`Ltm6pu?9DS-XV8;^%7C5K#0C$49q6p~h30<D(`X<<ohB6TnE}*ySWb{7F*8re
zA;`ASIo}~nm$q36qsW9FXQ|KSN_`G~#|l^Z;!{a+QY1(j@lzdBYS`i1;M@zM_M)DO
z<%QyHI}C8Hu*950a<=A8x-Wdslo~TiP;2hP!)50;mj%xK1KCdG;0@U!zsRQ3dd#o{
zhuvD%GvuG3H(r-wo<4{Khu=)pQbB^G@4@Bi6*uegXlX7>FJ<yo|2pLV12L2k!_>Z%
zL)u0)#X+?mRhEMo7aDt;j6QO%9h&R#7FLW+3;j(hy!ANUOF8s*7OM$ZupA+7W*l|u
zVCM@q*46hTXRel=iwZhb!!r-vw2npc^9}c9usNC9Fs5)hoem!J9#lGDM4?|%3wBLE
zsV6~msx!IBk%JuaY?D(y`M0;X$-8eI!+fYlK14@Ed?8Ywcf^!b?#r8$C#^E$eA>gS
z#^6v4w7L%Auv}*z!@1OHV<|DRTkpxoV0^cPE_3~%NHRO`KCS+7N??<HY)z_3%*_gY
z&g|gdhM0I)V=R_d(MB0|KYV<GSHw?KXpwR(PW*La-%W{KmUe7^#kbsCOfhq9__5AF
zaq~@WPoA5NSHj5W+}=+Q;Jxi=Fuv><{l><rZLRfNU>lq?;#a0tt5Cg#-ODzliXYl>
zhvR`F7oQP_6zM_z$M%_r$r6H~@G1kB^Uj-q?zadjTMouO)PFwIlM2^yKeaSH9Oj<V
z8L;r|=2@>bprLY^URe#Z|8IqZo?~)bI*20<=*<cakq#wjP3CGL3#d+=to3?|2T0fF
zqJbjhq*cPt#ioOMYlk;Gow1O__Uop3f{^Azn;EfHErO*Co3Zo7p_MzAL10UA<2%f2
zv%XBfg(NXIHRI&^?IcQ&fuoz_i8ACqm=|?-J~iht#F1bLlHUj_^l-54`8k@SLP|S3
zPe3CDw?MT?++;W5p-Buok?a@!0pRO2A8$}C>#pl=A6W1U4=Mt*KK4=75~0$q1+|s5
zp||&!=58o|KJpeJa7Um23=7xWh+R4i`drB(U)cg#lNq+YkjKjI#kG22+|qToYxLS@
zMbD9jx2u0_lT_97MvPZ}_PyN^cIn9FtZ_w`S}fT)8$g=0K^*P98(b9O{~$DhjQff7
zmvcQA$HeY2#;138INenRPsF7j%-ua{x0IX+U(o!{gwsc#@Un9u+SvpNLDy5Z_z;U%
zno9nXu<v;chnXJ`8h3%qz2j)i&dPt(bjfM7*PK+t_sKCXpxv|HN>oumBma-JbA&)v
z)`r~-@r9iB)<740b)%+$sD#T<0cYE^cupdcYs#&!Ca7hCnp%;;y!EtUSd=ew?^bR)
z$kY1ok$U8Ksu~OohDt(2Na_CsbicVDTWV0#i>b?f4L)TJ+^hXiBi4aV3=cc&NtUZk
zCctLR^h-EPtLUg2O&=-1=)r19z_X5sVI-odWvbO$_9>>=EFei2W7vj#v*}<n4OSJ;
z8sDzlPa{gXrGzm)>P8GBiqB_1Imz5Qov8U`xu$5R=y!RVhnsc9Yqg8F7C1=G>nIj-
z+M^=c@NfZD5GButDQGNt6}9rP_DK)hqFi&ibY9^lY_ShHIKBh$I?co8Un+%xOF%4W
zql$iBi@J}etmJSyQaz=o?~SA@!<u>4n@E5&LqwZ<b%jtt&)c6r0pAqP%#ZKR#Ka#A
zDyt2KkN9{Hlt<8Q+Se#c)^x-~yU_Xg!1L8Y*gvXu)ePK#h1YuDMQRTnE#pqc%-}I5
z3X<Xf_%=c%UkP9QN4&LV;sN{W==9ZbVA5btBG=0i(T4ryHiqilk!%g%hxXv|ey(4T
zr+y~w6IJ+Z;wmWQ%%5T4qlk+~Ft~?1oM|qu$rfpw6Rpu0xORZvba1JkHSA);9MKpF
zIX!H*SvD09a`K~iHyzoNl5f5b*?9lU+sBo7W#tK41LGdOWBmLe+Yp*->+et>yWA!p
zcQY3k5@;dFzW!TRHLM>7g>Tb%g<g}ooW)#woo+Djr{*mQa8=_Ks>xbLbGD60^CT*t
zri#?mc*9yR)8FVe+m5j+l`lN&v=`Mpm+6F*+dh?X4vEKdu`>PT4Y0~#rPf=&GAo*N
zA_|%L9byeS1-V9hv;^&UJNQNGditt!!J5^xT})5pgy-6PmtZq#^XDR(HG^pMfuYFy
zh3u(!x`UMuU=w~DiSct-h66bpGP7;Y);HQ^2rZi6kkKnTtw#b!kbvVrkSSP=E<8G#
z=`#HLO)BANAxk7)#++wZC!OyZ2W~hSeoTI6J`$X@AzFBLz=8L{`enjaLfy#W@z2hF
zN6zrc4P^LuBF<ELOaw=Nh9!BsNJWQ)XlFRbTHetc^R#H^q6~<OaADH1j~i6c2|C8T
z2)aW<|6yVo=N{PpRSbmzYHwsa!~-sU&zvX%r>LnI1Jal?XXv0GSVkgf#vOPu$5R|x
z?vTB<nuffk7m&l6LQW>>?^rd8d1I`@=!LIY$JO*`!W}c&Zp3J8*>Vf^;QLz8ZqWk$
zU6P5}Km9)HCi7R({K&t31qU&p@Iz@!fSn73{Vxbe*=&2_PuptOH-}~Z_`tLS$kW?G
z#W{i({%Uk$|M!3%v^VIX{Q&})%`o>`?%5;_@apRC7)5KLsRVVucW(&c6?k!lsPTn4
zn_l<5nXpZC5?)L$6cLGF6~37f=0>U6%XyABmAqBXowr`d3(7n$YP2F2Ywa`znwN&c
zcPqz>+nH3Jgy(Iy^d0#sAZao?-3nIfrIG^-`E7YU3|+6$V7~eC3qCZMWVnLgnF)Y%
z^P{2qDGGy@yrRSRm_0$zk~d5OTb&Z7`R}pp|HQBV_}!HVjxYl3<zy=z$*2<RRU_5v
z7Vavr)p?5KSPqZ0I;x)jncT9BYgFtq%48|*Nv}h5&O!D;gT*b{PPOoAg&BFO7Seyn
zs=OR${r$_)#i_W99OEhv&rDL}9CP9(XQocReqg`j0X!5Mn{1^R=R^#e0D+xS;?AMu
zf>5cJXsudqyg3@zZdcl0JrBcxP4?f5OY%7g6~e{J3GlF7Mv&?pxUlSy3(g4#uK2I*
zeMjs4Y@MkLE}vGUq1Fj3+4uNyI)m%zE{1L^(!gpN;LU-jrgbx5lKV%xcT|LPqfX+N
zh9F02O}LyGxQ;d~a5PRQNYGn!D!!xQ`wD^wR|?;UTX{)H5y5}=(h-NC`T=Iuqd9Z>
z5x)gzbe<(Jn$7JF?%1E3>c8*K1Q~dIWT}-EZx!0$@^y9NuMN(hb+4l{f*;~?B&+Se
zel|3cqea-m8F-UtJ#mTP9Oa-<-k#ntT}+87S#@Q>wkeh6{2V^?w1!zZr$4i-ByX?v
zUt5Hh<S|QluKdlawaO`Oazu7AgtuBs*5hmmG`4WRb{uDr7@M2j@L?G5Dm5{92>dGp
z-qbZ=Z9SaCaR_v6Z?rS^HQv0FLa|gj_9u#jLcNS6AE(H;=W>TY7bM|xxTl67v*m{S
z3FgH;bt>ni1ag|clK;66`gaOc|M@>1(U8%?VDFz`U|^r0YB5sm|C2uFtTV)eKsBq-
zE0!EQ7P2=(l$l1{r1^}vxgEIf9Fm!7V(db7{$Y4K&H>~hD$1`1u1DA9Q5;D7<9&nu
zGxE%XBgib6KtBfGbVo}7`F*|ZUIi8YenYYCW0l;kX71SWM8=D{WB)d&ml{d5HYOjz
z&`!$7>?*5yCqbiD!_9+|+H;M*xnpmgrqOI3Ra+fto>SQwkS)Au`eV@`WJU3di#BW7
z3I29vxv-HFyA}hLv<d+WH^QtNhVDxrZTuX0{FlSSh)eTEhm#nU>tF0j=a}T3#7tL4
zbR9QAF7XU7^$ZC43{Zv)LDDRK=jTj-#Q-&3^`W5~vL=;-xHYW+ezYLcct4?H#)RTZ
zCoc6yoigAGL*cmsVcRQ*?oKYPRb1w?WW4Eny91_x+1SF+=4!W3C?Iq7hU+8wuTkzl
zG}!9;4fvxG$saI+U(+YZ;(q?<l%o1iQ9c*BugSYEp_b4m+T5g9Mvxskj4v-Q@bO3}
zD285M?_<Vp1;ao~fRc&|_98PTJSlOE!0ah4?SDP}<Nww>{cnZ5)+BojYIE}P@|eg7
zk;zk~H@Ii`i1TQ1auRJdW3_44${yeG&(2?MDpl=dC&;@r!QE9m=oxaU1<Tv61+cT`
z6uQ_`bBot3ZCmv0Rr@b0#f^k%dAr11JJ<tHf+vji_wPfC>_aJ@cRY9#MZaf?|EWei
zKSZQIqSNJKaJ2DahXYOD_L^>ul?14FN^`48LobiJFVjOWFSMtg%HU~+m2O{Q|F8hJ
ztYR>5SczF)MgOBoFk<V<AjI`8-am`1Ho79>v@iv0NlnwnY6Xh*Rb?cjZJ^b&Yqmjy
zYrh`*a5l+#+Id}I(3*=(FuC4S?VU_efbOPF3nYF>%nkv%G1t8NsEUD|etixH>&y<h
zgZpn^73}}(FRp}eyqMr^F>uq8PU~n^Hp1SjzUu<L-ZIXr1?vLJwKg_*tDgIF=b2(r
zz)aa!rG#u{Ne2}h!6D0_zq<kLxtX&L2pvdBB_%g3iOWG5z2Qn5p-Pj!Y=Z}E0rsq(
zMrNGls<NFef>=)_fhLV-{!im58hj7-3M|bhsx;Fl_2_xe0*DEDNEBQeo#}WeRxEq^
zizfOrg{{+&EZ0nAx$G76^rS6JA(ex81wX)X=iqQtxJy;Tracy&lcnrBBN~A`N(4HD
zDxfK08TAawQ=TL3^dFkLJ8T-8)|uhL^P2_`Y^QW^(=gy(di@~vIK2`hA<*jL-GKz%
z3~*fW>F}ZDJbu9fcNai8#(?<u7ar(sUU8zk7C@QGlq>)$iq_5FS6|PIX}@<#LQdjE
zju1>tbA8uy^w_>)@10u<8eKJZH8<C5;-WdmkInHQj5bMm$`H*codPx3$yE?&%6-w(
zP);7;r-QDI=Facxd=2opQ&Nzv>W{W-@V6T9^w@v>F^>9m4GUOQLDRS<-^&(pGy*@a
zWZ%mN3Z|J&s}~75kn$K^sBdwI`l=|8+H13Lq2(Z?ACi8cfxnRUC5wUtGp~Mv0`N=R
zYR03N5$M!=j2h(8J8yy9|DO_f&+gAH0#d<ESwRMpDyy$Di=A`V`*Rj>{mmGjjdaG!
z`~hikM&MlK7{O)koTn*IYpYN=P^J;}f5HZk3vMYX`A=gfr)i8&98@|v^OGJb7BoE=
zak6dDvRo+V`7t+9(qw6+rcj`TnekRlr~5~yj3s9%y^tvj;-ti4mp6J;^uSN+F_v|*
zgaIvxL{MhX;sM}uM(7P12j2G0yV@1n&-1I(>n@cIH#B2o3q^Aq5kS%qM+Qwv-zFxj
zbXw~5FH~P4?!JgKAYelL*g~TK-H^BGU(T6_fpwBpfc(hqXZHW6uI+G~FYL5Ole<DB
z!%2&z=j8GI2=hJHl%q-hFpQ=)j26;)iM3_O`fj0>rC7MLBU_dz%V3~E_>`pk#xWa@
zn~C7H@bgx{z(HR^8n{+kw`bdpy)$<HZ&NR3tW^Vsq95rrKMw0@1^`Q_S{Xx&eTaFU
zayC^za3Tbg_3<6~bzRRBZjnH3OA7GS9dvMa7XrRzIS??YZPc;-gA&^RphO$+!Mg&)
zkn>vlUnt=>?B}~NU?CWS0g`1=cGju9H4`JSP!KVs0X)(Jw7NbCU8Ah(`xMmS+C^bJ
z7>1}AC~CR}Pc8YuPc#>fWv1~eYIrKIR5bNwjZjgn$*^U}{!G?iU$0k1y`Txh<PRd3
zx0hWdeD|;>NEIO@*#3t8w*GsHk+PXV#N^;CV@cf)zB(eRWA0~&N?dp_!fjEvQHqUr
zFAQ5jjn{b%S4Bx#L(Pl_K69g&A>6m8bS$5?KeGSUGL3=s3t<$zY;>jBDyw?akxqqq
zE8Mzt{>Xe*i$UB!jO>NY1R_{yQ)S!}*)BEqN}}OY^4xUfCg`6y1am+u?>IzXmc8&8
zot5ryDAOSqnR`u3CL+<ot{C;tzcr7yv&vityp$Iy^f{7(8deRGfdG~h^=v8f>`1a&
zEJ0H{Xno1)>wSqmz>@y>Z@rw~S_~SORdbX6@a4I*n!xpA_<WZ;v&90=95%16`Ra*m
zMk^O(Gxoyo#hk+zo?OOu5n$SVPpF$9Yzn<Hn)wH)e*FVf1%N{@T|5v_kz@ZCP{n)!
zuP?^GNYZI&cDJpfhqHvTI}X5;p0XkvKb1gkoyu$jEcDJz`!*?3&7863Q}9Jp7Gila
z)qwka_0CTAv58np{hs5(me-h%J;l2pq)F1-XA*EVRbk*x8zEo!cJd*cT%AR46gamO
z8BBhtperMriYB6pV{2sj1)<k<+x@et@RV;F4=6u36V!$9Zky7--0^_DSWH#Z5GTgz
zy=455S=B?%oH@C7@L(mXC`B}x@$hSLv+u0%RPC->k3CLY3GqnWfM-nd{~4D4FER8U
zVT>FsPm0xxcq=I~%jXFunSjnYB<JSa^5^;UhK@hk6M#M1GQAr>eqJjMRu_P?%v`^Q
zGj^28_Peme3pf?O#cB24f!DgM&$Y0+jsCAhSSz*@J%-M@FzUWuBg<-e|A&~bcqt*)
z9$#L5N777l9ktLm*gLzK3x`WBK^j*ww9lFCHZrez4$?IIS$GQ~Ej+I}N6_FBCDKR~
z>h1U@NRZNClmuytboRvu2mHm4JQ)h4J$e<24uV^>^_oYsMiAVhsQee)@*+c8vLlsT
zaD|Y2vAec1f?sJoOz5KM>3#G4iebgI$M15IrXt7OO!UsEBj{33#8;{x-pcwkAx?{X
zEq-x(b7^(WEkzMoC3{C~F<35O9=KE!^p}HwXk>y5(eif<{#?~)_m2HNHvBm8(<*ZQ
zXRFDy7L=>1z~IZ-H-1871LyNGNK;0~BI5Z+;{IdRsU9OF{r7%dJ)_@X4t|(`{FpGX
ziEoyf8{i1>HQG8<*;k2T=7v~*O(Efi989{t!D*V@fS4GBHC17<ymAQ^F#mqZ_JaK!
zz!Zaks}N-!+%)LgIY|5)^zTU8U&)YP$wMA(tbTO-(TwOTZ;MmwXf1-Prl5Bg@99)D
zU8U!iY3_95w~~HN81zmQ$uRnDKRc2xlju|fc<7nDGx1Pn9iNmuio)J=g8tpuU^1y<
z>(Xc-h0q}?&rtc7zJClv6Mz$ZPGUFa35u)IowvDaaqD^E<VQ}zQ+<fv6KJLgbW*?l
z*+voxxDBP3AqNQfuMM$Cmwvljkyemr#CA&W9<*;fZ%hYj?Wm_ol`r<rM_`!EooUAc
zI`NA@R9L<nQit1~*x)bQw#kM682#v<7&`+jdUS{a8C_2Ge;ZxIx2sw6*&A+}+W`x4
zQntZ`B+u0YR%Z^NBJhE5Fhs@NQ8fTO!-;5qkvu}Qx^gBIy9^??Rco%X+joL29<Hs6
z6Ae5bj1ewojSVQo=z0)7^6DZ$-lg<c-56ZG`=$bz+q<G5YeAnus`3x@-dj1G(Z~<s
zaIO8C_v!T2H+4ZxpNE&2jU<FmY*FD~f@#mL6lf%N_MF4%mAd#(cIs7z%TkZh9JGm)
zfaL<{Fji`oVZ$%aq7$jz)~|dx52=5eG>tDezSH4QwHQ5F9RdY*9&Qsy7alg>>lO66
zoC5KSI+eaV^2ZB)Zwp&)BiUXN`j!ftiBj1Y8;bcS=U&%UyrRXonpW^qNwM7e*y}P+
z8Nv~e9Fzq&jV<BJKz_gFF6!%TTVW*e4=Aoe5_^Gbcx^NF=&|)$viDoE^p1!bpR|W$
zF%l6N?9aX-_lc>_xCYBDEi>L6t>8}R)!r&l7%xjhryw@JHp#Eb-9-KvFN~8eLXD_f
zV;egx>D;8~n(#;fMabr?|4IT}31LBU-ZsrQ?`SzrOv-G1E4IiX9%<Koc&v2SMp|yS
z<dHG2wU|@neZ{6;`o#`R&&x0-R$uUA8hQ*O$ymIw;u4LD1P<e*eg3}bsy#KE6ilii
zbe`j;#bgaUXJ`43bwuyGd=N!^;b0p3b|!x&MV6DQf{eReCJ<N@&zM^dV*R<07*H*`
zx`4sJ&0ZIb?6$e?HJ<&q68tSqnXO#dX|G0c_-6G6NK^Bc*RSSY`(e|sl&f?3G|W7=
ziQ~EywB@n{-6lzW;#TfPY!-i~UdqIlHKTim_DnR5$PocJirF$1xw)J%X~(`0E=IfS
zg_uh=&D~dKQyn}cW5x`p>-0Hn1}<Ie3MY#CPZ!ziafNsd&kZ*V?a}VB4B29oZ9z{%
zWO-8YuyUIsfEF+ZZYW`ZrsT;+VrYXso3{(FTeFw(qaX>SpN+%nE^i1juzZ0L*FOe6
zfh2YV*D%>jMntfb#VI@OxKe7{YS7Rxp0+HSu8<OsjiMvPMKo}yiInGTw24nAB<A!w
zzXBcp*kbNCqW4Ata?EUGS)#Wp!D`akI0Jn3s3DYhl8=QvBAzIHKrs|lsr=u86fNiS
zT&3#~qTxkZFeZFexJ2NA<LKgQ$MYQGm!Db3?V(VlY&EImGgskzs4Z}T#@mNU!>Xp$
z%F|yNJM|}Qst5$$WOdfiJ*Ojx??MGA3{zhWb+Je_v%VgR6Md+M$hft0io?v^<-4GS
zJTn}4xLY$d!u_wcsa>_;cpo4d+CGyC;WCUy^(M~)R+hk3U+tDVDw#Age0veOdxG{3
z{}^=K7M-)D$yeN4TsFf_r_pGo=@mCu_}1xEaxygklUTIp&lj&hI~P&Q%Ac&`wH50Y
zGGYJ8si)acLL|pd89bPG`j$kMivX1)HIPD(Q2g!P7V3x>>j<Rx01_iZ$(4gV3IWr`
zrhyFXA(z;i!O5ABwsq_|E)~(Xpf4+5v(=#UOz6Z?3HefFiMyOOG<t&$T_miAMDbu{
zQeXe)I3^P_r_;2GrQa$awXs@J*Z6KQ&@4S_Q+a1vG`VIda3rplg04D9)OTa}bmjyN
zyv@_2&JT>h62B4|K7d&5%o)JO)HgB&?asd~R*j#|Ldw@ae=lu-5N3*5Yl~R=yJ#9w
z*`$uutN|JjLd0MKJu*<!+0=WyBd=e{<4u?hP87dFgjG^<&9uN5aOUhQ7r)IeLKfgi
zDw#lY>1iLmvE#pT5!l&>OslvRCAKJ9F8)2*G2=e8)cwk#Obx|JTjebLZy}`z)R}T4
zQ#uk;5l7tAe(WqT*YH^dP{fqxio7K%$v|Y1C>&Z(te=!DS&vughiHk+uqi>zD;^ut
z+jFcuBON(qG(wIh%2F5hn=aVZ|2@^xZ&;Qd{xsLMju;DB&5Ckz>NHOae&u%x3#G#G
z_Y&L#{qc|%S$#{Jq1fN*gH8&EG?bg^t)76B8fs!^+Hq|1W(0*YO8gbJ*$Pk^rBosQ
zYr!z2MJ2J_Q+2Eu%nX#e@B6Kr`_oTBSN%>>0sbj{13iNC>eMkQNtH6vO(aB@B*K|0
z+?Ft3&Y`a6LzUsoT6R`JK=9YPLKH2kF!lh%4p?W-SE<F3yaZ)!jr*4jFT#*KO*G?=
zQSRLF^Cd(!e9ueEnsXhKg9bUq$HGd+z>Vci+TU1R^x9v1WEmXV=6~yG1z)f1bs>h%
zojPuZ5R2Y{Biz!{sg3WXQ3<QfPi$ZdEtFYw)=TT}<!YJLAI(pfvNGa4FS;GR7uZzp
zv%AYW8bj>?z$=)!nsP5?z8_({ikQxg_wu}oJPPgRy9DrZ;x#y&YMj|<#`&uP${1HW
zZ>elc0ZTizrs%-Jd--oR>L`3M^dH9hwd(Q;`T+r2^mH*Hgkw8|Z_MNqb@LCfHnkm`
z0uI1~@kFLJ?ir5?tm=;vG@X8I%FQQSa*ji$nz&wb|3l<}pig6<yt2_37m}-jo==<M
zMrsBRO^=z^H5A*DnP}nTG1!Ty?WhRv$SDV&+R)jJ8W^ABjy`Bb23-mQ*%f%1sRi%S
zH0ILX@3pnzu7Q^x4<R5)73{2!@9J_{-DPx4afZLx%SKQ2l!m)RiJJGyqJfw(&qn~V
z+{!-hA+X<z#jY9nR#=u`x-bz75UkybCHp4Ju~NmVhrb$aY7bfwrwGu9t9b=(I^wpt
zlq6Pysw#+~zoF^sijws?&==Fl4sGf@5yY=(58sC2IeVoX{(%Lon9`=|@gXv(WnkIf
za@Mt;=&`xvHPs_@P7w$9H-z1fUFvxmqtmA2iMUp6^^V*!E>WRw+2_fJq^S@^#q=Ho
z{B^(#c}3nX#39(8tTuc*cVXh<4Z1!@^k3uX?jRTVST5KNlj=N`kO@LEmHYX6^K1kU
z+K&eQ%d~J!00KqZSEV_<A>H-lR!IBVwemB^ETTW0B9Tgpgv~3M!*2Ej+0lrvV&c7K
z!KHWGYIlMK<uVm7ZmgW3t=(x&bEwKzi_ksdssfs%<`;~Ns*XzTz-*6~=-Khgv)V`Q
zd^c;0T4!ck39xMNCL&<o0F#!Fnn8pE6=|Hbjw$%)4D6=Y2-j_H{^$0V6ps~!<X>R>
z98PjFqt)?^`?|HqMW!r;AT9W+-nNV<j!mDBI{My4-~JrmH&88sFOWtQ6rr!wFkJ7T
zOeKY(slM}C&o?S5log;#{GBn#js2NBWBjuhJzdP!=~)o;A$7fb1vMu1IC~}$W|z$n
zji)6drlX!%#7Z2C{bsWL4SZ2ZNgTWwKlE4?Vk@j4iFScaw-OL{AM}(EcizO)>NG{l
zwKIaW_|X}@)r~<>$ka57-`HrMW6<@Z`>Z`Jz=31^YMJSMXGdf|PDM!-F3p4TkKN{*
zIr7?Bp#u+@UV4ox#_37L(itj=e!6q)?;5)TJ*IEh>{`w+L&P@<V>zN*_i>xZ5{g^d
z^7FA5)A(IAk#qNL5zJ4@<+pR5$`3i*m18E{0<odt@2})4^jLqw#X4N*SWV|ZQS=m9
zH}Kz+m6e~@SgqyIX7m*KMJdrhFaAn!R8G;)vrJn#aHrSmy}8335=*YF6}6k2=^JZz
zZg_C)T~b0x4zbVAG$0S!^h}y%uXgLBt%tq&%TfNpMMock8vPAkm3H+6pC|#-LN=$U
z5$2q)@@k<q)j&?2vo-pNyE<`)d*E)pBU-XQ^OaC@%n-MOKcr_=rIc{NwjV;u2!q#(
zYTM#eMA3q;tSl3=h35T$reK%@RXwZsWZCH^tKVLaKp(#Pu}E>L)?Enz$k`pYYgqJ{
zPT2GfGB_;y`#08`pe&O&=GX5f1@}!2?EoKF{5gly6dfr&auv3ii7fLLP4}6NlipUq
zq7`kZ6p1`<7EmN*$x9+D0-V5;{+{#3kp%y{Qw?K`o|iXNwv1>E?yo$`Y7UyY6Y3$4
zQ?Dcb+3-abM*J45bpT(GB7EZUH;QR$K$7YfN!mb$50N6Ko$&QeR;{kDY~RrPc08?u
zB^9D6x6<GDKslmmR{9i{=OKR**154KPqxrPcFAk4kBblGl1c41g-_&T5Hk^<RpQa#
z7aFKxrUonFUpAuTr(0|e+J6*o5cTvO;aMFlQq*L={>1B;R^VScwz6GP$<HLz(6E>m
zL0))snU&<)7|AEijwBbG>`kP2GErq_Yx7II=R{xQk}5o#*PZfVjEa_g!XHVb=?0Nn
zUe)qawc@whe4i2M!s}yc9$wBNxs4#L7`_Q5SPtDrfIMn!_}&bSWaY%^)C6@;{Gn6B
z61BgArA36K@2B-h)XYt=RE{qb@_IEe#+Wyl9^iFAL?;6x4%|i>hkhW@<)O{lbrYSs
zl@w=u`8*)R=f>AN{D~2t4VUcy%$dZ{9adNhM`u-l#&C|Z`o=9qggCida(X2AiJ?=~
z44!+9<i1I%)BxyFsEpPmMxX&WFQ<U0cBqT0QNGp?3T8k%QtI-`(&D$x*ghCNwfLy)
zW9t`O5wa=^*%YS8^ltR+LZ;G-s1()k+NT~?xAp<T1|(ly)cNRImFYb1h#^>6VZU#j
z+>PAkPq@Htd?YIXw}kSI2(KF@5VbM~%zfpCYwi_YDMJq3M>_q+_FO0doOW)su2oW`
zf1yt#DEy0`fj?E)34wyP&X|fmZrO+3>VfE717pspnKKj6G?k{8=Yv5cSz?)d{#S)d
z%sedNV+e3`zx+RTs#-Qrkt{26@Uw8K?QUK2wE&9fJ>4I1_k&}}wf|PN`^f+TMFs@N
z3T$X<?SHkZnoN}$NviKHc5S>ElkP+z8omp6vPd_KG8s)DSp<~tvYmOZwapY+UufoL
zY-WT*%?@nTK_#LrE}EFs0W0L69ryRoCaWvO&3>x8@pSH!NWOyxgdkjkFFmOv6}%Al
zzORjsnxJDs0Nf01@Y8oyWB1zqIO32>MTFA33Z*M8@2e_DywG#%r7h;tK{;c@n-D0W
ze-Xk+-v0-8OVIzpT?$tP4aZ+6H#93#zPyT569Akwq|B0<!)?iNJ%@8Wa1B+-1~yz}
z?h<zm(Uq(m!@dST|KE)`^dTBsb-!#7A{Bgf1_vY&dw(kY{GNWQ2?U*x`jDae2XEzR
z27;ko)7tHhj#*1AZ2UrKYMd>Y@726~rc4q&#}jr^NQ6GAjjMEvpV|W_s1+5?Gi@8*
zP_5qAIbR{6#*ZMaKQ3ZY2#AGa>-0Mkw8~jo<L2EUWW;56)@Z4=>mX}CdKqh&9KR?=
zC<Gcv0|2VM3jOo5#Np0X=OyJJ3dlMZ@H8iVQ6)Z>FeFJ&OE6}R@YX4qnjPICl?;25
z!Y%`o{dAa(Du<)jnN3CfhrUK9B(5Uf>O#JetL5q(I`jOs%FzktcfKzBRR29DXd4iP
zQT(5*b`o~0^&|d`ur^8(#S$6;oLM(@m_)XW$*)+(WtMuF;FR-|h*1VsPDFN#q?wF>
zE!(FydEhG{J_?bTR7Cn|?=5~|zqCO*Tt9dbHP4Y5N%1m~sOXy)BxUv1?qkSyw)&wH
zWqL;1Iulo#>m-k~@vs8$$KSd9KQS`Wi$>OU=)5aEtgVfaBRgMJOoo_1U#?LwmS(Z+
z+5~P`ySo&l7_Dp4nb7B$=ZHruf*1qJbaXOeo7VtON0pg!dE8NxwYqjTjy~|cJ|$CQ
z=zfNM945tf%tF7u8GM27(6*quD7FI;5bJfj^aU3e?(4`k+{u_P#snXc>&pVw^f7r-
zDlLeuw)d1nI7LJGr8b&QYmI}N-vzLB7Y5zHE-z`KQ62W9DGO(Vt0=)Fb-Z&Tm@eWA
zc}kZ0(3U;A-%qqaN<otI>i)-=gYBX-UbaakL&`&yC7$gEruP(@5wR*=XA88CFfPxR
zYs8^L0IH;dAU%d~H@Aw@H#3Mkgd;ws2=W7VH3zsSaxr_Rz6mRf!)_NbasuQ);pH1e
z%xtxug>ClnN+!NkB=}{_(BblkS7D-P-i5G9WJYr$&sjh7ik^Ui*kGAfw)9Bm_mmyh
zn3!A(2kEwh!=KpOnIcy3_0scA9%b_VUgedY$nPO#3cCH@T!+ld8|(|E4p}4$)EBv9
z9<R%JA56Za07v!HhnIyQ?vAz~paDpsYJ4STmZB!Ae6mF4Vuf*k-XI@mu0^$S!T5A3
z1y2#*kOtTMqc`|FuJUh99mUXEZ(znFqqlan2oa>|`D;L(SRP<Xq_kf;5~mhB_J9gB
z^Xo&m{=)&gbY%f5SwLsz#*i3V)@9E96CCe*0N~0G0~UFrrdOOW6915^+<#a=F<FM|
z!h&EqgQV|{>Qdj%9v_@ibokE+XKjAnE+TU0-IOWcTC{t7cPw`|TJF}=?m$6TL~QAd
z<qwcj$p|4qsI&tK(Y>LU6~f7UVsp}o-5GV(ix9bGE0^@!1I`u772z;Qiuc!R3^<ky
z)y&hpzzt`KP{=uc9>UV~b~^|4o5^Ja*u;<4Y}c9j^%yGMX9kV(`Wl(8u%K(SHzUr#
z)W+Z2F14M~k3J0WJI(;kTfkzUcCQyh_XOry<&XY2nWBqw`kO{M)mNPFUjG*2wirTe
z!h>t9Gbv}b1*x7n3z!LC>~*S1))G1eP>zACo3KZA&{*wC6@H{>^HU0>x6p04?-@KW
zNZfk3Bo`7xwE>%NOD)w}uPS6*#ySe0ozc@40*#EYpwAJ3&+;kOa=LbCh2Sn4Sy@=W
zV*W1dKdY@(f;An8qwUiUCP&BM9(ZZ}TA3<n$$9s&DHS(s7^?H^0C@V)c&KEu?oogL
zEeX*uNC7v!UqP(Y4Lgkz-asb~3+pGI*+b4KSZ;&J4X>6EOqbA$2n|2|wqx`-&$M1c
zvS9tC><{a*j)0o4if)agWoBWQFjiM~f|uJg-kCIdWl(bybVz%rt-Rn`T2W66dJp;>
zV)Nxu+{I>AC+M`{I}pUP_|BUH`Gb;N70|pp9iM55+XJ0NAXLyy{&OJy&H2)IV+eC^
zm7C3Ru`i*}miLZ3X(*V9x&Ck9x_Qc)T;Bc>bH*olc5uGo$r-S_=dDL(9A+*dKEgab
zHxFs?1!vm5faEZ{+>f0v<XYeZ`lFYWE`(J&;a)+6H|*tt9FwP==JiH`hZZBWqVg;5
zZ+NS4iK_~6Q7ifr9#^C!ogYU-Ks925p}jZkAHeT3N=|8DURe-#0y!YmjIzUPt0A#K
zP*l^@`0Z|isxTVn=0LGOKzBC8PI*w(C+EhIVcVzV2C-2jMtIUt+bfD3Hx1a4R*_W<
zT(BdKD8@)^R4%dEVYU5%k@9-v1n;-2wjoWPR{7iC5$B{$cIzmpn8uDZ&f5aBwudYU
zy9w2Zr7AVbgf>0pXl({AnF~^Ti)b80n*nZGNJsb=U6rM{C@{j5*Ath|i-A){nj>r9
z&4xbo9JV>)FOsGc6)!)E`KkR+C@SXrUZC1<zQqyNhsG(xlTjJCX(G%V#;v0nF~aij
z-j+uHYYPm_$R%ciQ8H`e{)7Vno5IhFdx|*timh3Xe%y3Kz0|n=*0Pss8o_dC8t#@8
z{AtG>I`=kD&h?aF`o^ehI0nPSJUWWGju{9Zf(cw|ro$zgq+gIEx)KJR-#RW}r^Pj|
zMkQcQD&XkG8T9n+z91wt=5tvmmqE`jv`()NotJ%hxn07G1>-Pxr529+w3o{^POVE6
ze~|uyV2cmd^+X$vX4@^`Kqd(C{v6;vz@dhMp;=6)m6srGoiq_m=Lv>=T#C3vHgNRB
zijang{+$S>9rl9FD9gWXs8J8Kf;u<f`YDc!k+BV6tr2o|swBwFT&OW>M#FCl`+FT!
zCt^j}tywm`yb(D!^^jY>5XQYuDICth%--&|5Cv(#^(BUj0=->N{`fTBP)%EHnDZ2G
zl!#6+CJLGf)1_Z)DRhoEn&*VRM6%Mr!46K9UpFVTGpz9(Gf#q2IX+ZO*`!n--9Z4k
zo^<fBYiiGF^g+t!9fLA>=*sP@a;z^((Kw`CCJ{DOd{XL}wZnqqR~um~aUA#VIpN-n
z;dPJC;2=h<oT;s2)t8aX!@Ly>wcR#ZxhJ&MJw`&xED}x75r-G1vtV}1%{L;&3>yPS
zcMKuoFCd*iI;bNb(P0J3Db*_BW_Iw;#;Fw72_=_NAf6)8ca6!sB0riXcIkK>qQQ~u
z&EY;w0*7l(iPY{Qu!&+-UxSX+z9!%)84Q4vxt>{qii_6+7kQ3yk+Hjf;9a7khCi-=
zyK45QXfqldWNfHN?wTw2gOPTe4N<p8=F<i(=e(Yf!;vr~we9CIdQ4Q%NY}X<fYrmw
zQ@LJ9ib|H(1)qo>d7kOn)6g0|+mkn#<`X|p>mYyO>`VooMdV-hHGEN@4$xgqAsT+<
z6<|9ND71?!9yFchsu1SOH1iB+NnC8@H_>f;7mtp)l4gBZS6xRGAEsG8r4~|MyuJoC
zA+^32Z}mARtI}mGtS_z0S~4UjHQp=rFOUn%NVl=vDqNhPji1!x8_z3V(R9q8Z?E4^
z)RTP=<jyA+m`IisQ><o-U#=s}{Z-bupQvmzbv2u!NlC5Cs2pNIR38RwKp+)L7pb2v
zF}=cG^pzQEwTG=N)Bka1`Mh<)z}Yn^hVif>v4NFHAQY@p!L8*I)Y{kjsB`?M&rbvq
z(*>s8RT)mE0~Ieq&=!;1G#hv_kJu-TPLzVI&t4D~vwur8KP6&HyHCdfMFStXZbg~$
zto9P5!2iRWB2@lH=bIOC!&(T(KX`ivO0B29a8qIM(_p`PnjYQv8IO^T4uM@yQx<M=
z21&wCKLA{LVsc-PO_sq(k$3w@P;tA1%T*6+G4=A=_L=ZsWOwh%r}E3l#`hLKBNDey
zaZ@*p^Xh&9?`m8<wvOGfDlz}aJ+NxCvxQr9`ye=w&n-*VUzfb1W|!QuXuP`Ho<U-y
z-O{SHxWkR@DuU=(i#VnA=QbiwqRBb$2I5QXDfBg5%jIKEISy*;>a<&QMlLaOKB-n;
zxvAT$$eNk^299F3Nr;R_Z&-e4O8;e7?loZTSB?|n#}KDR{lRjYBfcz()`1??MHksd
z4fsM3%7O+^K+Unxza<tnlw*9!z9`yg4qZU`_!1$!#9Z5x0QCG)(Pc8@eg`?J!x<_0
zioICfsfpTXVoXDDP_Ade9T1$gd&J`c$&Ll=VSzg8m7)MoI~B^Eo3X`|IrQ;An51k_
zW+ZRs3i@loQ9IIR!{P?8s5qDliI&H`6ura<(JxHtdb#$gBj#Z01dZ#yIVJXWg0e$S
z=LT@9vgSC=tigSk>Rsq~Z*d5`K$<`g4UcJ$0=P}DzAq-<1Gk$Q4IQUr;*i3VCfoi&
z+f(r`Wk4Wx1Ak1Ha3ZI^<_`lm@JlbYh?x}`%VNZlRGM-Rt%Mbanj-&D(LS}koBqNh
zV;Nt5XHW$+!!B>JCW>pc(J=qEMIw$J)o_-x@U|(7lJ`-IkGB<R{PWo`axJBIzYsI2
z?=?O^y|j9{v|Lff_k$stq|j9hCx~Vs@IVfRnYS)d0UoFy0Hb`aeRNXUuSlg;GqA{X
zGf9Dn^2FSdWWcw8fvy!)Oip-Vn8x)!%k=nO8HL-FI+A6O*EFLL796dT;aNm7aY08I
zv9wK+J$S0R$XtubNJu65r^!`gW??h>60|MTD5u_*jWIN{Ctey}+Cmwi2~sR_=2lpc
z7rst5zhCA3Twf2&{_&*Z-3_K~7_N7dNqhC$Tw`e=C~8O)pWP|#9qprkQxC0RW22|>
zWOhf$6{*^#8Bw<OU2MaX$nXmW?#ie^)Ss(NM{YpDbn45r;~nPY=Xty>5Ktoq?rygg
zfsq5GUJ`g8MVogg4~=Hsem<aBYherC-)Ea0QgLmc+BzB&DEOKg^!HPfpKa%Rl{QGq
zKH=Jv6#PX?$oGPGHK?hK;&+nUhsUE_kmD0n(Ko8`3ERf55$La8oOT;94&kM1Ht*;k
zxk4AkW+IL<gWpctWqh-AXfi*;6C8&$Mo)*QJ@39ve%@gcXjI&?-Cpk5eyPVC6|Uu3
z&yF|*xA72oVR(aFuf#eU)6qAKM0>jkFpIo;Ql!92ZzXI9${<t=S=`8Xy`aLG_F0Y^
zLKJ<O5$gB|p~WTC9Rm2&zkJ`^LDmRI{I{m#de+fhk02V#o}!O5G$L*^4fl6lR3EmO
zC2hO3i-$^wiB0H{f2SH7m7e++-?CLGPq6v8Ju2AHjZ8^$GvH(?%h(VNQ6wtoPq)7o
z%VV);yBAchkEVBfT9!2TjU<P0%s=BQwWG=M|5*{EY5OXo7^srzerA{E^T$)kku#2#
zchbv=CyGK6mXv>$FKGl@<fw1pM9vPNJeDcsAz=Q+Mm=N}%!+|R=+s^`>??MPFo^3i
zgRFtS1=5Rb^qUwZ%T2fa=<3_*74Y8TetM(Z(w#jEMbtP=At`2IQ3ySU-5%vb8}bNd
zN-K#P)DFv+0QJb*v2qrg5xj9quKE_H16I@E8&reiBA90E9l^`}m@pV`J<SL58#hD2
zI(<C;WBN++IcO3-eh|KVY}^95$d?j*q+r$(bR-54&B3JHa1W`G{lbNxo|2XR4hyW$
z-i=2IX1+ApsoH?CS;D*X{w$WBX78zegMp-~+8J$xg7>fefj2pXVd{BvIn#%EEc?h*
zjbhER^1$*IU;cBS-ZO8~j*aix#nif5sN66GuC%|!%`TRvlQxtpH79LXG`Lr&_68Pz
zvMV^45=Db<3C)NryVEEB*R8q405BcwU0}w!1)KjJNhIaO{hcwHndd+}#lVGS;)}Li
z>U_>2JEp*`2I-*Eyw=7~zdtn7#uydYg%!rJvPH2HiYW*8iL#e|y|ezH(H%^(PiSRp
z%3|bqfr@CY{;g%`rh6;QP9OiK4dM*mv;b1xs9u+iV4vT4wjk57$}9~*<MNr<?iD7_
zEcaM+M7hvFCP5yl!zW_Sc4|}2eBPjJm9zIW+#&y9{enxN-g{!+VjGpbq&Tl4@sLq<
zI7rf?nd)c#(p|&vO~e7CT8kc<WOG!#+^y@&KdT+Jn*=3tP;_0~EXK^#75%lESrNJ}
zZ_l%&8wtmIIsn=PeP%3M-`y3PL`J+;jI^=skTCjgVQZh?JleA5=Aasei3wdW_7Dge
zq}>x{9DXg={Q}ADB{(>aMHfA>b)QZuU5WkJYk+?5aAf9^$HU_ng(vWF2TpOi!t_W|
zbazt<Zk~?k=!vZu?e9t{te=VGBNf-w4&g`+Wr{&q3&zmt_9Z}AngW>u&48tOQY+wL
z1Hk)fcwsmRiLT1ud$)zipAv2m&2qnVI^QkO4slnzfuG@6`L&ia<Z;Bo))EPPbQR88
z)j^bx`$gk=?QyxLCr<Efl|mY6VkaPs$v9xImr6F3UaUn+OZUs?grqHr%r)*da@sD7
zBQ$H7rl#G~@h#`tZ*d!IbRkN#&x2|N+@iqhkFa{Bg}l05$d?y_D-IJ&+ackW=fiYd
z63u}-WB;%vbz(WX2ss0$`ZzG3eP0GV+6<gLUT2meNnGvBqeA(QlNkK%`Xc7{Uh2L$
z#PRh^+cp_#Z)8uioBE;oBl82UEx5a1U%l_$aK58Qv^)Ttnb~@N->M-KoVa!dTwFjM
z&4DyGdi#gaX-PidZ>1x%^vdjQBantyeiqba9uMMt5X(&Peo}l!PJjd<?(!wFKKs5I
zh7{+6H0fNH@>lFJW>&^p-X4Zi@E%#MQswelT-`G6@@hXZWxYRXl(?H}y!LU_@Lve?
zSv8k`GPSPW5;b^(?7{Dp--r^D<rXzeLhv=khU|=F@bZ&4IQRH#p$BMmKyN8Q;$Jtl
zVEt^UK^<S;$?Gnoq&}Ohoygo$oQEM|c(zWaTHSS2#%}`UuZL@T`*~NHpm8<L_LP$f
z^eiF(-=GO=2LrjeTmGClS8g!6BgMW+@&YW(peco*rt247nd+0cZKQon+Qfpv{6E$H
zGl(irEh|B&B&6+$JNYK8%aJ$C6CHMyB4+1FJJDd3cq1B4l9&6Zg_R|MR{Uy0OA5Jy
zro|dAfyk>h)L#z$J&W9t6&YOvrZzLHZ|(Qg(e#&_AVEwm{*Rmwf3VD5daVf9>HRn2
z-~a6V|2(LwW5@6Vq^Ile{bvgBshNnfKrEJD70!qabqfco*($lsN`lcm=M;hRR7?w@
zBALSlpeVAX2O3G;tOT22q~Zn;mX`%o=i_uqdS~}Rpyz^#75T$jmNWnv(cO?Yh&S(Y
zK^p0sKR`bYb3g9)Ib3j4axCm!^=f(a>NWKM1i6QeK`-7pLqLl*`MFPYPkw@vdsS*M
zoqm{0tzkl_7D6aN)iH?%-p5DG6dFnb#$U0oggBcd1t}e(akEe^!)Aou$CuRdKm{ys
zl-$zOmb>F`*f?Zw2ipeuvkshZou7V5(fISm)nr{P!DyqUeu4_i^X68iXTI&H?Il*W
z`4g-|r;+JTPjcCM&YoT0cFwVKKK=Gvw`D#Wr>Sq}T&!!l(x@vF)gENyk|^mSRqSn<
zDVD552FJZI@UF?k#nlN*{EJ%&h~)TCn&YFWDZRrI<7ivFS$(a9aZV=R85^9MbGv6^
z_RvKy1v=!e-LVx$TT*!mChWa!mbmUdLpxRpOTxRv_22B7!B?k1Wp}o_?B3MuuATyS
z{=X(W+JVNy%*_LV$C<xPFsK^x^KuC$4rvTL>S`)Kx?-hYS4<rC+6J$6i-EL)x`MhP
z2;w)pu(DG-OPAw%dgk>bn#09p$Lps0vk&zGTrk%BoRo|TPg%X192~VNl^<yk4cxT#
z*EZ>rzTWViYgt|gM&FiHuC^Poq^E4i<0i=@^aVr}_$0#kg!Fazu1zmhLFyX(?hVA%
z8NcgXOrb76Zt$&<>GZ?$967~-M8pktd|98*>J1*ZOo-Y8ycnaKL@Psgt4lKT2RPcq
z7VJbsM?Tl0gvU4X-!ixD*a9}Yn8VUB2tw=oj?t$MHe`8USJes2=6Xd*J+pW}9lgF_
zNE03)!;?QsMD&C6#3&bM*6|aFlta&*l**e+$m$ZAzsBS)n22@jBU{WlJWaV!?>e*_
zaRqgD!68v)<)vKo2R%^Vlq0ylx^U1GRU1T|8F*~hcHGFC%s?IiI$m~-*_826an%lN
z$lR4!M1g_Se+)U8x!9r}tE%<Qxpd5P<aK`4ZjP{-i;uA$39S05X4m$jr4A43c1HC2
z(Tv~xMNFrNd*5nx3E8LwTX%nhggOFn-ruIY{}0CAvMUOBix&o@5s;3dq>&b+OFD)|
zKsuzPrMp2|q#LA5x?|{u8M-@#fuTE|Ip;q2^*vvJHO#EF|9k&(24wz%3MT5|<s;Ls
zo(%Y#qG|1aV+@(r4s)MjLI)cU$pujLu8uR_@-Rra=yzUKTc4ClnxE3yDI537!OAZu
z6rDTWh(uJ#)mMB_nfx!v0Ve9-4!q3Wc0V}0MXqT(c@D>f3_Q=ztd3o-*&d!$4w5~h
z19D=vZeefDJ-x9%WIf(Yyoow!U!KRI2-v4z&NwL@nKbVc4~fo=Gq?1oRBzmXIY{2q
z{||gVdJvl8W<D0=$USD>Z$z}MH&()4@7hSLQ(OD~tn>1l%{5~zP`1J*tl|+v;0T9j
zq$J}#@MZ<mr}-y%Iam<|c9oJoP`&^po7&^bs~U{rIU%yX)KfE^>YD^)ea}kg7gSdC
z-j7x3BI-A{_YzzVQKZqL%~$MFRR5uJMr4kp9*6;%ImQ51mXc84QdpYRH*E_OebBC{
z)T7YN+DzFhx}VJ?FLCJF*W{*eUU+9jF|fbMBwsz*o21gCCZEWP$lRH139@L1<|^tx
zoT^nVx0^>v-K4<jAdc#Ydj+^SO5qhNMR`hY=*pYN9EZ}*+SCNe%q-d_9HW@>2VZi#
zhq16|s^hm{O0cP{+oNy^xdoSfEJuSY91Nxa{%3(C%)>HEC!mTlweO5j+Z*p8r0CN&
zN!IxK7VzX>*d+t?Zx%><ZMHA{k2*2!Kk7tC(;k9wWwLUqoiM7gtuT3pUupT@z&Xp{
zso{W<``jr##QF;2eP8tAs%Tw`u29^KuJG2fFaE|{-5M*nu-aVBC;Q%n8=`MWeRojY
zfPqy{bZ6dz@<-k{(2dkxhr(`nKv*|(VwBuGp6<eB+GT!mCQFa_3(Oh@lc=&FfXlpA
z^nu@1pgKEO#Edw?zBOsvHG8r(BEBfOPdA)|F;<vJHmGm_6vvM+29Rm*<k+E%`0!Ee
z@f$wYCBWD>>o^_RuJUtOHPQ96ochW#QuV?coiJ?6I<7Neg6e4#cdc%tFCo5ms0j(L
z{i_qKE#9JmKhq^I>R$m>5l4`J4-`|aws*VAjH;?^AIo$<)u>(Sr+4|JNZx_+B6~dz
zGa~C|bg+=Fo@h18C`+b%p%giuCoGt&U$|tM?T6CTz_L~U8g5V&Fh+r*P3<NXSD$nB
zWG!FZ?jksL65|=ufPn40>KPk&3Vs~uit?)AqnF^P;6@fqh|llP%kQsKOH+$$L6_qG
zn1<N0cPZ88Hom9<Ee&z^T6+tGd2=@l`G1-a-Q-jXs;e=;H@a%(3h!%3`yZBxgEK_}
z9PQpWQ1yR!Ohw|htIvn6U*5+dtij;aQE{F*{`Cr|D>74xRd=WH2V3>;QdWrM`Ca<L
zB+2hmdxF%O?&qVbAY~wm*5t{;zuCDm{Ja$w2~ePz(F%1K{;1VirubueVY}fkiTi4N
zorUo5zwTMjQ!@gq*0P#sj430R%_MI~vvp)S01`Ud`At<s6IH+s2j_yn%c$+KAUr4P
zFZz?;zC@lnEHcvyH#2ezio_aseTvOYR5V!VS(^@zE6J4$&|#SLA;!zh?Q=Ay9-@)4
zL*)o4`_)D#K@ID+t#-?6Z$xUHps%L8sPP{ESzT@N?}F&<TH2uTP&0S)<TsajrB0lq
zD5NVFcz7&}guV&x<M~KHS44h~%{ce7*KrpXWa#V)H^XEMjyB)E2Hgi`>aLEO370hi
za@*#7@s+_(aPE&&$WG^7_A3Q-R|&F}o0vM%6+8s`b^K&Ywo375PMaQZI9H#uieJXW
z5F6}bwRE-x%J1qyew?Pp!sg*HyfJ6ky@wCK@3#LIHw(~CRGAT%qwD{k2O~TWHN%@t
z8?}G!IdV$Wf5rf(YV%b(FL*B2Y@jQNg=?`z#hM@|=w4tAcs9EJ`yW<5#P?3(7$Vw8
zt~vadAAz!CEuCBo)ceX$OeU927yfA|Ud0&Y=TEOGDg?hhWUVb7Y`Rq()72}z*)2si
z2VxGbG?sDWzvP#!t8BHV9VHblRchoUCS~w+ye~b)_&!~q!^4`crfh4jM+OVgh~t<n
zDQ_VHoA}d(;f;b9_G!;9!@q^{&uSh`)&1XbH;fVWnmV6%)np~sIQjklNPQY!1y(y}
zQ;F>teD}nBm3hoXzmrrLeLaOaWhsu3&!@0un5hD25$@zG7Wn3viw+^Lig<j9CCT%m
zIKBdE)~9W{YEW&y0I)7m*%NmUcgpRyeO8E4tnv-Mg;Y$BAbW^?7Xm6UQ*nxX5Oj;+
ze*ifYxuUYVYBQ2)w?U@Ag>h$^D6Zo3Nv(L$ORPR$M4QEiA*stKV*}iGP2;LA!ab3X
z@#=I^e*Je;%Kv9n669UW3g@D3g*5*qj_^5FGyQqVeN6{9whla5qUzhx-!QxXXJIV=
z@50F6mfzf%S62&QXHv=QD#DxdJ&K8q<@ooUEQARm#)M4jrMYHuMR1zggd$yK66P_b
zV%8P*%#0u}q)yFm#MZ0on*3BT-Si0P7eP71Uc=M!$n9>`QSGzGHaqEijV{Uub2p}S
z%jz<O^5r!hh{U}@OYE{BQKP;HgS>kJij`%vJ<7Eg>B_s?F1pzigOG@Y8mRFH`UJ~c
z3`jskI4aKv?U&H&bJiBuf%t)<6$ZMB3N${p#z&K?qk_`W{+S)avpFv;)n(I1O(Uc-
z7$as><aTW$QUk8n{CmC!r8~60+ZT;rq}e;IA17Zw+m_%~rKr}5`k+vQt_3Yiv@tgr
zTu?;k5L6$(x^~<Jq#+o_hOa(m{iT=S{A%hX8kw?Vbx!E@NrP>Ir$`Kd!Sheo@YeYp
z%{6_P79W26+IS<s;ZMuzZ1d~ZGPY1V_sOWPXO{42UYsJL-uLML`n2E25HlX8^wC!R
z@UQslXVY6U%ywd4`_=9!e0Ond6OJwTg6OI)!l$G4@#Nv%GVZ7CRdwnN+qBVa1)8DR
z1LkV`f+=RR1m()=zkTBEQG3Z;^XVy+=56&yyoe9-#@I%uN(h8`8&B5=1o3asFEWHa
zD<rm#SfBpuo~agtW3{Yl9UbzB5C1*3*Od?-ki7LN565E6%q@vQ@Z7F&t91HFaxRaI
zfQi!MqwW!yc=V|ys}QY}Zgw8?^AzS_N*&jt$l0g)0+=+KkY1VqbUzW>vt!@uq*~~D
z!Me6rV=LH@B!ou<o=pY;c_$9hqZ~>bfuE}>BS0>Q&)FPVwLo*1lxxrEk#&mdq)X1n
z1t%SNX^pM8pmhF<g1UIP!H1BR^-#~BBVCDfY2?`hav`>9Msc)84-=AewH-Wd`X-KM
z@Y7x8Nf!f>fZ{udd>D){VH^CIgW&gnNNT{BantQ)(B`>FU^04Qk7g7j%3*P$weJzN
zm%)NsV3#c7osbwCy$D+C1pF(@h0JOo8bb~FtWEl2B&9-4Y`#Qe^OUDQ{Ux{L<<;B5
z=^DAj2Ux;Qgg+o~l1H$CN?5x*;uY)YT(!vCU`;bVx%a%(Q1o9+qewNi)a6v7!0U{r
zQ~E;f(<I2;c@x!=<ubyoSui2VF-;PLpXW1mzpILg0V&BghjSL&xWGWFKM2{Ik|0GJ
zG!9AB|F^&$Zt~iEj|YbfU7b4{0e%B3qRYzEu?o)6&o)xc)CK!%!c8>d2QI@pTAw!-
zv3y*p4U{{%bncj`D)hH}lZkz!&pMj9sx-=<^e46@e_Z4!q_xNfEtyGBQxiR0&KOY?
zp;t*;GKdd(y%7Q02+DKQWDVEmMw)b#4XYF8-0R{3^PB!}7J&YG(JdEB`MgDNChU7!
zegp86VbaH*X-muyUy746v$y8HItq}m>v`=iwR8>eOS7Rw5hm<#eA(4k=UdDJ#qUf+
zyKx+vkHVo>tLQb9-wf~MPekz>%u3t-=+?A%HvDLeAWe<pT-{{l&<k29*0?<3l#A6w
za%D`-zbXtFurLi?i<?kqlY9|-hqU1eH$K$xOmw2Ilat_3Z<}wraF54N(6w|KdVag_
zym59zMN2)9vUeef%RQ1P`V@4x`>ArA(=00%pRa2=_Fwx(sJHE>w+@P`_HLd>q1Y+A
zsNv!dSr@~Y!6G`P@Hm>>zswn0{7ruzp$d0dWV*zhbS=9>%9!eiije=9OPsh6;i!g6
zAfK)%SNn>ZzD{h8J7Y_6GmEo|iJJxG=TR{3VS~?^Y-hX_oFl^hufHjVsH%qFKtfZM
zIxeRyY>29F{|<o<-dHp_sHV>7y8i=Jw<0}b{ZVvwUKk>c=w!Q3F6MvvAu%=@iMJA)
zs}=lTcK-P@E=3#BIOrLRP1VtK;OuQV&h_RK3TGvm_~6T(@fj|T`KK%y`aP4dBm}=W
zq$^u%yKRqzy<0pZ(msKMwZ+0pZ?#mV+A52;k;8mV3yXnlvScYU+yN;8qG!a?eIO}6
zQ9u*>YtWyqF9xkb@dJA+kv&Hbfg^2hqGyx=C=-Sekg22~7NYLyL(=)wRJ^$UC6n21
zi<Zq|uJwmq6fJFfle1S6f~sn`It-pv?c#`hXkK!*8~>pGr6=4pb))BDoL+lTjqXQg
zIC-lpMQcCm_HJ$CK*<@sL+*(8yGi|s6Oue1y^})~E<|r{RM3k_84a|&8h*m>7_<Io
zDGKY~PKgCaM-C9?S-}zzstz>MV))SD`e9E$s##CN(!UM)(>tNj3PV)Q*k7m|GUb1*
zn33)jM7IcZg~6i}Yre<By93DTx|f_tBfK-tvg_wc>q}|{dyuyV+{PW~nVT#zK}3rk
zjitw;QS;tdaf>AHveNq;*YglWohuOh=7supyog^%LjQwklX=EnUC{^U6Ixz264odS
zK-VQ*z3`|({4raRUn=`AewJz%p}B@fG3G?%NNh|=dF~1FXPu)MJe~-XQf2kJibO!{
z_gOg=t<KIL%5jzDRJWcs#6~tg^VQs}gVdio!^?=GKo$!m-ulN2K%;d|3I6(?V9png
zCT59%tM`eE2RB%d^}m;dd9V32679j&FuXigcu+PTCS-!J_P~)&BKObFXHEwAS%GqB
z%YgR?chwy=6N#4VJwmR>!H^ZBNP-kZyL-8FV_2-2r+4RBe;y~n{#bM372F5^|5l-I
zW=d|>;^ozMz!KFjoQSBSy$>m}lJe~5V!6)LAs@n&FsAi9q8AOWoExWvVS6*ltGn6f
zM<GVlAtR-7R-M?@S*87^)C8qi7cMC*lS{qWld;y}NUkZ7CilSzRYzu<zV5|xJ`||4
zt>dLtT>0U&4P&EnaT?`(KRS+@1U8;z@%iCjgg}#F%jc}UwTjN;0_5%Ang(fBR&MTM
zgs3jRpJ&SQz1R75w%r(Iz04-!?O)&Z(&fHyZbB$1XR5UsNQxdKS68-wF+<c#)?_Q|
zp!g(<e7Mc$y%+$xhd;{lH=pjDpaRr>4wEM4-Wk102x9=>BzF-v)x<ovaLmJTY-^}>
z-@R2jueH_1Wp{*bR=R0lC_T~?8Xdy%$u*ak>b8>yPuFcBc2oZc4$uqt;Lt(s=%u2T
zFe&UFrx3YFan{3qXIu$fFp?N<@np}Ys=S%l%DgXSth3sBK$L<M*3BOdcg-7r3Dn-e
zy8`xI^^TNy&fXgwR>r9(=@0dD4b&olO3ogWz26NMEW*9{0TpoWBsBtOKEq$@=83}I
zZ%x394O`QfyddBi>q*L7_v?nVK*k@nk<g{$8Efx->M8e9)a+9*-lg%-kRucm;w8o4
znxZm$n>|>jW1QClkb;iBN;xq^S<FP2mOA#26acYtVz-W98w0DuyuBiazXcg29@S?2
zh~@mBTrkJH7m59w>DV~gZ58@_j-O?6$B++&2q?xt@Vd0CJ=;sQJ<8Rx@UOrh_QGLt
za432r``Y?rJRFe!nVD-e^fXJ+)Td7W`{<vz+gV-LkpC0U>|A}%(UW5>U-781Z2xT7
zzSS$go=vEGo0yzy+@Cu@DmQ;Edh+`$R*b%6N-O8PqJYnu?PzZQ#Cf=zk`OwrgD0Ka
zeyu+ASCnivA=lh2ymt3)x&hhx)6)E!H{xf#e(3-^4redbMZGCiJq7vB_C9@0;e0Wk
z|IZLwVTGg?p^L$n0I>gCWyjQhxgRrv5cpNgWaLL40a!%vxF=6Z%X(^8vQ1Oc{!<>Y
z(gcox-7@8IDjCI9>{?_4syZn>Z<r3Iw%$-Arq*zIJ6+V_=VKG*XLB$C*tNTlt9C0e
zua!Sp@9<rw{ef`en0~iL4R}b39Jx#gCUvZ`X<<^BwfNN~>3F`850B`&0^K1IB(gdY
z!qLanOWuSCY;405;4C9pmWMo;-vht#An}9x<J-8ag`J`uZvnI8mY0S1Z?V};e~3mk
z{>0C7bK-CQbNSC|YGZGZ;8Z5`;Q4OiI0K<7q@oC$QdK;j&M?_?y8h?k6UEE%wKL{4
zz~c%zZ4LPlr{hKsP0zp%=y(0$2}}KLF(9qQFvLnlXbWg>ww(y(=HrdeA7IvQ;wcKp
ze4HYqxUTV3&3}|9@xP;OHn$|As|E$t_F%-+<@bAEq)@sBAQp8+uu8o0=rN-&SiMLh
zK70^+xTM*)M6#pLBgb59HJtN0r2qq7DX+0*byGca0PQhKsrRDaq!=W``;ZR{JTK7f
zYYs@b&f8zRMG{L>`}FV|6IM>%f;nG%_qZaLAINB5D(>=rN&8hGRMk_NhY&JKyh7iC
z>1>OT55e38_<689q54Ix!s1S9KN9~a2Sx)AtLhr(M|A(k9>T;;siJFPCl}~jtpm#J
zbv2P!CtS6IYzmM^*{$$Oov_RZ+W#;dCD2zj|Bpon&(Wh#I#zS-WUwN$Bh2PbF0)Bs
zs49R5mF~ACYfNKyDb$Dfrj3L2j?|iTJgk3D|6uc1o#a@U)hF=h>3Y6geD68WPr238
zp*$T5dVNFcj+(yf-=w#^=?9PxDKvmm8XB%!sQ6=A$3;(;466Ffsw?*btNY)vRGI{w
zhHcq@LU2Z>$~6@r+>CO#91LfJ-Kc}9=@MgFwQnO}^95Z0R07IW0e)kOP(!BcuSFsU
z^$Op1R?s;witl4VG_3*{E*~(YijxGYh#pX2dn@XFKJ8n2VRP*8st_xeuL^-LNL{#Q
zv;2mEmIkDb<I7ur?F*4z31b`iX34eR8SD3M22x|O0=eO_wqUr0neQ;>OR0^u1bD>V
zvr?g-No?q08{bk=WHKH4Lemz(F2T=*cQJmOBL)AFhL|N(qY$2Hn%dcRR+Qm~ZS@BU
z*8hmfzcik?eOzlC4c1%3-_HLO1N{5GTb4u7-=E8B4Gjc?55nA5_!*9SZNH2l*T+4Z
z{Y-6r{9W2(jZmXPs^#gF;cn^OhZMz2Jt@(DgP0zVHm+S~s@5kL`E%Z6c$ogwr+9fT
zNqlY(AGAEOKf`WciQU{RqlO%5N2HgDW-hq|D-W;U(l$B0$?fvNei_;8bxxgNJzoqP
zo%|0O5+Ff9pk=!aGj}=qz~Rp|jy!kWTl@7T+gLwZe*>l+*i>8kol!1V28PRQ#;>PV
zd&76^Oqpw(+qbQOZezs1cfnz_*^vJiCZh5TC7NBZFim^F)()>$3pDCa`Ag|`@ItcO
zwgTBWJa7Xm8$7K&rscmIM=((A`!4t;EcEDwTD`%+CGW!nRWL#7`T1kt*`wg{Y-~84
zmD7#YMo{y|sJq73h@zefQn*oq#xqkIs{c6&n+0<Ml@8Efr(UTJwk#myJKed~{aBEb
zqN$=wkSFZ)RD?xnBPw8-#(~}r@-nZZ8D*S(IILVfO}0LP^<NUQ3;PK!4z|3$1#iY?
zW~PC)dR*?<9(-)i`U-4F`L)mHs~ydpz7g3PSa$FR=)b-<xV!)AI=^c|)v25I`rpg+
zgT1e6Ne*qltxLfOdVSb&Z=q@QQcSt5e}K3fK4q--RoW9F@AKXB3J+<9M&wZ7J%CQa
zLoLuhVY?QMX`BarVw@}8i&GWLt8Hp^CDO{6E?$T-i${k`Try{&_4!(?A<K*WIfC^Z
zX!!15H~zY(6@JLh@uFg#I{c6NuK)bbpa(i*OWhe{Ii^VEi7@W`n?gW~tN3`WY%Oq3
z7^eXQL8xT>-4Gq0PZ?2X-M3&^-;JODILHNx&4=p*ti}i_k-pq=nwi;Q^Ea>6@bPVp
zVEI{Bn9@ae3xwSWb_6&l;0LtSh>m7@9gTnD5_)vHljrYx?dv-u3rP!r#gkG~^u?Nx
zvwAGjUT$GPteg*v0`|NbP?f`37jxQT;@6*IFz&JB3BIWuY`NR-dF>c%b*LYk*S#Ea
zVjaW+-XK;weCgfvZiCk^{wSr9P<=gr?d$DUW^>r9$<`X8%Z1Ll6Q7X4VF}ME%a)%f
zOROk}-tKL{K)%_!{1a}zLV+-*7XXU2?K@UruMv5R5wN$*98oVj_oP&OHeQnx6f7me
z$%ic7Kf23h1nLMq9}u?9`xEyyF$`2vdma{K)nmXHqV=(FBb!;u1;e<m-5K+LME(NM
zeUDMB!(<fNGJyJVWlnVAvd+uByB0dwY_Xz118+<|M^;BOGOq$z<9Bgm2dr1AM0y+&
z6?;^R$>FSsZIJV-UIz)yMk2oYIJn;)kr-@}IRYMOPy{b!t0)^Ev5uG1Td$i-#tsD+
zOt@3n*A?X2Op7r}0(23-pf$!31R)zyulAd~|H5YYE3YxweH5<zX4V53BI{CU-L-pk
zM&-_B?B;<>@bt5Ljy5BJF@T_;>4f)qoapNoGB6hVTl0HmZu^`S>;-waaAoYwG~i(n
z3nG$Z)6jidCS_qOo{`yk=rG)u^w!kh6;lZd7>u*lM{k{-&fj}dTKY{xHxrjn6SK@h
zyf^bbvR9(`P2eAS>NbQm_{y<&0NGX1^n}M!nNpY3JvpMm?@iDjgsK8HOQ+tQ3MqY6
zrgGMc8aov;)|#l=F!bQ9SvvMj_@{VnAx6~O$?sBTMSKuA0&50}%?9>;Dv)Qx-rUwF
zyd5M-pB%SE2?<f{EaUvyBg*-LTxFN^Z_K!V@a`47?jz9Zyr-XmwqBq{yw}NDXDxl7
zqG$B%ZFHN-UrRvHUW?cM2%b<Ghjyg%^Vk=r*p@MTl2IVE_kyWQeChEq0V~s}BSbO$
zre#PdG7gt6Z1uX_PnG!i+4pv}+7`u{eQ9wpbb9R2=lZp9aV4B;j6KfMTyoeK@!o&}
zI{`$~aK--j*^f*=Q*IBOoqkf|9GZ=F=zks{2Xi7p%}n{VmfI5x^6T5(!|o^WmHktw
z&zr#l(lc!mVxD#`B%}W|R{ZN{$*+k+#k~S_NR<efHSJ*yWQE_Dj&%E4nD&I-^<w!(
zSQv=Ukzvx%+_#@8d)sQ|eBWGMSMdGq($cHq=lhHlF27&L!H!S4Q{p|+Cznq+gkJ|w
zZa4ZK#*uPibxGo#yMhSf1chMGBf!<oc{isIw}$`mi$b80@}-C{MCjq|<nyTqVJ*88
z)UP+xTCtCRzE%oPIGd&Di5y5=m#1azae<MtZ~K7I>Ke>4S1wiIpFLJByN)&?=IMuB
znOM!25`RMX!?j;MPy?!4!8>tOrU!4sIbh*3c7oA#b%ldE_?5_fs6WRsCT(@jZU5_s
ze4{pcjKFIU#{cPm?ZLKYG_aAfv&hlZ&Etfpsd;j@Mnpg{g&_90aNOeOL6W&DKKWdA
zsuGh$JqQ5h4oc90UsIL?Fc=W^8pnn&>CxgTiQ_oF4S!4)Q40Dk*`_GW@moq$l@qQK
zM<kG<GWek>U83+(9iZ21uY6Y|^dOA^aWu^k;q+RX`ca=^wR}hm#(Ar9wY32I(T_y3
zv9VBXc0WljrvG#MSMEU9fxpcAPCU+L)L+X>aD$y!5YiQ*@OLDyL~n84yl9MRo%KJS
zVw>Guca*;VD6d7d5{YQS$e(bG`ggUM*1NU?g}nkZsn>d+R*6&MHPCBk+~BG8A-^Z=
zpT@~BcXPH6VqvEKawF*g(;FO9vo_q<t9Fitv|in(nS(TVXFz6zHsMMe_x*(hQ0*$m
zPC(ks15UK@#<yQ0LO&J>jRp*r=DaONWgNae?_fIHhvmwovW71<iks}6vUM4#n(;iD
zj2wvPB0Og?O5mzo{aFx=r%&7fdA({@*6m0o<qlPrp=g7>Tvd$vi#E8H*8Bqts$U42
z(x77P`1_stWQ^?h&$KzOYbgF=_nnsouc;$2{+hPTe)Vajg0R~XQ^q0CH8o@`j`m~;
zjHlP(u8K%LsC{#iz3q2ICh`jJ7Ea`k>EnE*gJ~{sgGLW>;Npw;hlRZ5DNuPe=0Rf|
zJNqG7ZvWWp9qK~{Rt=|rU~DUyuj?%W>*MY5FZH%~0TFELZDs^)BX>6L{)EWz+GfgL
zb^0J)T+M*?a@#Pr{|$_kqdTj|f^2wLUI*Jf*Ktf99bfDCb(ZS`GU|t^Usoxn)1``q
zeToIxF5s}0|L*0icLmllQ4*jCW8Cd{w)p#JT~<97&5Sbr*{HO8sp=4gNk+_xrxRl(
zYi%1ripINLt-lh&V$C1vvD_KO9u0_NJcQ0Bzr7huv$OpKNPGJ7p~L@I4+*RK>f%oq
z`B}ofqw?Im57)`KZrjL;$EuYa)oSe(eQ9YQQ^ZzHzc0E;>zvYnxY49`f33ve(tp+|
z;Ak#<(pdhJ>)3c#naau_aWD!;MdVDAky&Qo_xA`%-duZfHY%I@q5-hN7AAemC4<9Q
z(@gAvhim8T`48LfRP-;swZFhpLa$_g-)UW~CeqBPrt_}WGHqh<oYiwl8obVqg?WrS
zw0q}2xp{pU5Y&1sRN;sm$6Ir=KX0g9@XwRUkUef|{F7wT@Ynx=$>ML9pD7w65e${!
zs>$zEPjOq~5&M^~h;Md6(x?O_#CSs-U(OJ<(**zumrMOqBU6q!GPkq!Y5seHu5P<q
zKm8)Jg^lOn|ApWvvd;=(2Kd?W5I{L}<%BZ<?N2X!N=2`t^?wvMx82ttt$z>IY@5s7
zp7Wm{RQE&+h<+(!G3bB>tx$B|OmNnAa>buu7q4h!jAv%ov}L64uVXhCpqH2?Dx3=I
z8ZJrQaT$r#Qh$)BDAdF)g0PbM9lT2129nsPgYk^=Yn~TYbd5!K>&fCbJ_e_Z@I%D?
z$PRMJg24?Ti{l`ZlR=#fgiaEB`Vbw6#|u)9U-nA29J=o%33PnI%tBdIim&gKX(&=D
z&D$Z0@=F01^ce-PTgD(!Ev?2|6Jh}7^)`O-*j<cx*?;HM5?bU~ZEkBr+4H7Y@_-pd
zIIUp}R<s@`ri;yO^2#bS0a(Pg#8a9TlP9lK=4y?A@QcKx8k0*l$8T@nxWV%>x9asD
zb#V`$u5RV35JW}SVwKo2NTn#q_Ad3)(w7FHM&#TTxD$N^q?C?BSO?iPGB?h*&$cZ-
zwr@Oe>d@0OOdNCjckdmZW{zX6N2z~2E-c@ypb?r@#X>y=;zs_NcHDobZnMMd_gu4b
zfNOmpjJ}7JER7vp;CQYvru9b1hZiIX%s{z@aYp#~pWgWS1{n1^m7s{GdqFuWw?Tdl
zLG5FBMd5unp%@U7$=l8J8v%k^kMEwc>|(q)F(#oR#%-Hn*}osg<&3vZPuy0Qz%-|)
zfv-<k0{m0q&9aN>cP0Spmuh{WL$U67>2YNN-sufu%*TYsIh}~5bOP%bcC)?7AF&A7
zT^@E_Vllw$ovLOu$U?umL(0;Yi}Ra>gSp4|LAry|ugS21CQE^FLEYY!pAmG6LLX?f
zud-<+95?qr<C)s>WIV`n@y*2=!x;oA<P{xI-_shlK~Z44n{F=DP!S(Sp4oc|^2>zX
z(<WBG23Otxwr(E}DDeFC?|?WjqL@iBcL8F^7I2OyEXH;L*NhZI)|&SZvmR0v@cK_;
zo4evg!=6bh*Scca{Z;;aeep?zOW?dwbzbg2HSjScble-KzngeusJ7=iVu0DWDvJ(D
zySr2Dxw%olV6S*o=g>;<*X}H!3l(eqe$uzL9i!!c6<54oTkTn=5_WxO9hChXO~G=^
zi?M8C_T$sQ)%&P_j?Xg|u4=$|-+MW>jqJX;3Hm15TY{N6zq#1?_4mN8EBx>Wzr#8x
zZBuRU<B>93_32iiy=P6uBMl6Jh3<b+`b5w<?W0(KqAAfZi;AVJ!8QtyMrx?AN3bl3
zN8$|&JlaT}bA0)t>9<|q^{<fGVCm0<R(aWYQWG^yXI<^_kItV*(5yf_R;gdIh$!T=
z8<c*tCE1J>i^Bs=(MVsjCgx9j@inIl()Yy<8xxmLsZdMSv5W_3xQvgw``Nc<={fGg
z4ivX12jkx@8SSc7dHhOi52p=~H~^QAUzIm#Z#?!N|1<mjSLKkMxwCxN$`2n=kLmof
zOY9!0VNwo*T2`Qe{!qcygBxSn81g%hpCq-mvoSvV4ddsMG_j%Puh;ex)muGAEZaON
z%crj0E6||1;YngB;V(r-7K$^<ab*6?3Pc<S59gnb6=72TmwknLC2@MYHG50I-+So|
zLsyka<gzX0q92GLrQaNik-S%N1fYEGzMC(ERXuT(ON6(PPP$G~Z>HCkNJ&oz+d1nD
zzT+;u+zIZdKefn}Ni%G=r)f;!4VtP@zVCbP1?H=!5|k?gO&h$)x4r?^iU~3Q(c{o6
z&<mh8KM;~@X%tLgwBs``;s}qGO_I#IFTQ2U5c1)A=(XToVO}5ah_4Dm@vS8u8qCKx
zO8VsxGO!hlKfj8T6Ee{M+*&4&_aW2LXPA{->f?ad>7T!mK*`NYf;$Uzh%et}eQ40F
zXh@JM*3-tyYS2xBi}j^?;N;);?lsXXtVvk7i5*O(>fCp$#oux=9uZ)4z`lluhpF}T
zn8?p)c3&|Kc<RxisI{u5Y=0ectUU1%+itd_5DdrqjsSt}FndPdxSb~yeu@DazOHBD
zM}R(%W1_&sCaB5_smjkhDRBrgofb-WPUL=SR6&rZbX~5cE4SbX2{^^i2`ED|1b+BL
zdLf|K9@!ZGN*4wK=q@R5{VG_}Qe}*qx7@IBjZ@xvQcAS8=g#+R2-P(K1Z7KMc77$)
zYOCr~@|eK|XiBr6uL!Jug)8j%Bzvq|+u+YaYGSEy3FLkiHpMeL(J*63*bC6@s14jy
zNn@GiO9P~t2?@l;eZC+)3aXc9alJ9F@vnfRv;+;khh}JP30P_V&nS1oi~GYA!qfI<
zKG{gF;rMPd@5tN3Av_|;)z9z35eUAFTwbc4nwfv<KVZV#ns{SP;ZI;_o=8gV7(CQ#
z1-_P{I62v79zOt4!0h?N#4pIk=eE%_+U40n5%0$Apcd~U=fv{KDg7_92N&-z?}j#V
zhU9JW!}e6UJdXKZhDZRwzJ>dLIx?bm=~H~X@>>^fS>g+^Hj3#t{fINh{54%(Kb6HQ
zET9g&Hy-dpVYytMaOMqu9r3p4B^gYpLY%ePdH3!~zQj^=^Ey;2zBy1}rp99)DQ!cQ
z&djxM5B7OOjfun9<af;$dab_kM+MK;EQG4bzR{~i?YD+hl0KP$b>5W>`E9NYMzj}7
zQ@4VijnJT4oI5)k(q_waldhn6(8|z-iiQtWqc~jElbI&AAeEn$TQrL}U*TEor3~<H
zn_B-q6v!HPcf<GB{|BHR%V$whO~bu8FW(X0e23EW`40j1fB-SbaBzR{J<`)7n=<ia
zF^>PKP=oFKOi~DEEzs1B?A7=S{Lx|~vr|4KKOE$#2AVYF;tMkD8Qh^ORiL3GYd*Cn
zY*bWf3y^nm{qp*59+?|LlOpvbLUPJ30bVueV~;vP6x+#MrEoK?q^|A|jO!t$TlK+$
zLTaK^yVeFpHXOe<WbV)$P9Ibk1t1ZCUf9FiDM=LrLPF*QJ3QPdF9D|P3@tZ?Rbp>|
zG`H~F$l96Ev9|#5h{=)M*d{uokuX|w?8wkYNBkzHuttqxt-!{ujsI(;oU`jY8B|KH
zdn2ihE3b~L6%GMRTirX@Yh><$KCqmFCPV$T$t1Ys5x>po0dyy3KajVh-_KvYQ;+Ll
zV*l08DEkas44#85#vjx*_(m5W`jg88?NPrSo$_PC+BznzTktL;+u98^t<WFfA@=Yt
zQ;Ahz+f9jR)py-=`UN5b?6}l-b=u|dfC7vHqNbnNC}lm3o!{n{1>j48jo=2SpksLq
zi1C_!Am3S6#heF5A}|BC>9?5OF+zW8QON<_;Ue6+#GmQdG3~!`|F!E;_I7JNApYa>
zGxRAShxU<c-LC>Gc5$c|4W{|cxF4#X!*X`(<NskTzI|wN=RV*GEepUTK7)xva=O_W
z@QmbP$zKcBLKGVq`QKEixnbP|EE31$l`7J&3bMx4oX0EI3lAsX1?A2e&CN!&^u;>}
zK-=%8c4}HOS%`!h8?ug&t^ERCdaHHHI_KF_nrvhg_dXP{@?6V&=g%swcE7AuG-x!M
zD5pPEVXW!=c+?|<3GtiIzGMDe!6J`n8aE=n!HxK^toRlYCsJ?exgW97@JKZgjrl}<
zsagwoAHB@TU_!!dTTF*2y#U+Z94r|=sq7x_f3NvT-VbzfTuW})_T%AtCSDU%3Hw{E
zGsb`@WULZc+(H9S5G~HVy8ed;U+637*Yym=?v{mE@ZJ`5E`@9FP?>#Z+~CIWhMPz+
zUK9;(0;zL~_zIl}^jHM50!#^G3Hg4z7~A$v^?nYL#E1|qHkp|?39(mc@H}ySH?Eh_
zR@-d~V#$-nZK|nnjSM4evJ&sr`W%I~#}67g4XVn|j4W9rEm~cjTMw1x53}XL+Wq|#
z>YTfDyja*@;~)^<)a8xnoeF>LcW$WO8u_DE8SQ(Z{N1sR7;%6y<NZtuSM=cZ_;?Q!
zbZu_s+Fz7CasmW^YGWrPv=aNiMBrJ?&;$&_dWO}|gqZ(&-jOw^X^(4Keq`xs>kOeC
zqrz|A=)1_`kYF7MQuw`2d?yq!wKNx&pTigxuOdLoXt^m^nEtT^e8c9PJF)f-=blbv
z%`QE(JDtht2IX+tZ*ka)i)W9uK7AV(#ah)Ipee>;q7mpY?m+9@5HE-s_9%zpUTV^2
znsY0=tkpW|B2z{MfYD(a?hqc3b1jm}ag+D<LWSJl5S}oLAKy;YKMcb23U5aL`*aO|
zGvP@L(nl@kdU&$9YuDfUSZrEMkvd^1@KFX6E(q|7DtC&nllnqlH4hNbZHoiHUSV6b
z*_SdQ83K71nLoDY$iS}Z3D<MXgKOh8uBn3SH#X-%FIb7zRyDc9bpCc?-?2ZYQE+|y
zG`}Vk({#>ycz94RRf1*|pA8l(!ZDC(Doe9MYp_#PN)pp;jao}asjLija!q5-UBrc3
z)SiREOjOC9&u@ifnbVCZq?ND+`q>zkf#j`h!kI;yP+y{=82R%S+YB%d8dv432Xx%G
zfI-4hQ;aWd)u~xMIL8yku%O`ZpRI({8<0nBobShAEw;dpAQ4fDufx9rh0pPjqBk}j
z1Bwtji3`<6;>_kzn~LDA-K3hvoIT)!o_$n+feKFyqaw&Rjut&uh7ll>HVvDcz^!er
zi!qEEaULC-o53Z?LxV%T;gJb^K+;=N*20>E8a0Z>ydD|B`9Uj7O{%hjHx%%u-!RI<
zzu*-7P|XgKgII0GmA0w*v4geL$@8x@L~nAC44}ir(M5}qu`JWI^hM4jzHgpuNNBm(
zePv8Nir6G7aGWj0upYSY#tBjH*#u|5N%2_dM5k}e+*78KL6#r?{4)Q*8#XflBd%?b
zR!_u-z2C5n3f+ms%R}S3-Up<S-t1(#QQw$h9%JxK%dnE)Wu0ygD>IrSe!URcZZt4l
z?d7jWtmIA*95{GFdZp~$cCe82BH;jW{S0zol&vQy3KN<6iuuns-eQT2+p58tumXoy
z0F$)F!OY5r==EZVVO7t>N(pJCB2GpYE2~Sk`0^$%pyrKc!Nj4RThHH@Q;P_NYd^Xn
zoKze4rqzwbp6zS0%D*RYd5j$L20Z<|NLO5#yF4x~B$at9u4yw}WpwC0<^}b7Z#KM<
zOa>F3$D)fjSuDUooZ<G;(bTSnh|?WP1JE6O3}}r^FB0wl+HiFub)x>k(UDT}vVY}}
zoN7oS9-xd(ao$t<d)o_UZEsRC^7f;gkNgm`)6CgK|IIJqj@XkTveh=e_|7-Q+?s)>
ze%}xuFi{R)(fsKAtoi?T|Bm0Lv9Wj%03Ea}ex0@4K1f+Ow8q*hvR%wa=-_RS+I-1p
z3_6JJ5GRE~-*Vx+wr=EEeItD1$LDG2Rak&mxYOaNwmg}cKD_D~m)rhU?;=3X>7T7~
zpppLi-1>o#@|+C<@V7^EeV2{9)0Urg9ykaUSB}uUWXUWCtSlh$v%r+i|03b$MF2?j
zON+X>d}K7~EWFFu)VBf6(RlNbtu09Pbv)Ev@e%Q&5-X#6Su^*`?GED=oQU~%3)=Fj
z#PAD~fr8h1sb8J2n-7}tEUOzEj0}wax0GuF0)ZK%2D5bj^n^MMp+esU-xq9w=f0=s
zxe?>9?0Tb{=eWS4+)dsWw_c|;Gq)ZM=M&YJeE+_RjJVs1HK&d)gBEw53YO|pWAGkd
zE|CuEYRlqIuV*`Dm4j^C4<X=g%`oy`K&G>AE1`Lty<T<LNqL3*N%t3~`IND_N>0vF
zW!Y=Fpb>kr;yH)O_h%<)^7fN`ijmz(!fU#fS@AcCRBx!}&ISJsl^Ju`i*l5t$OO)p
zJ#|#8#v@d@Xuv+cL0RP+WlAJ;(&wJH5B$`(+b)BH*V!6x$oN?<-L<li+VE-WwhP8O
zKoU}xEsh?)xwj$q29&5UXbg&<Xl3wi&Xk*;iRc;w4W6k{GwMYV7P8!asEro~W;TEc
zBI3Z*TP8l)e}*V=D!QU4&<S4CmhDW+Gb?H-?VrsLPyY2fslHhzrvRGiU`#(r@6P-@
ztulR_{8S0EstvwOqCP@76vc#av@ioyK<B958Q5p`zA*>{vtpU?CZbvoWy@>ap_9=t
zv%-Z4)*J@<wEnvYa7yDh{$!2=n}3oE5W%Z!b(7N{`Ag>SzeIfy#DpYKjdu*S>1Cw*
zcZLn0+_JnGx5a?ytB<Y&oo%l?xToR|rsl#`s?#rcVfsfRZ&60Y$)rQ{7c<&Fzc(jP
zYR6zyybzPRd+6NiTKJ5K9#rzHdx<1ZX{3NJ`DuMvg;1q<SabM?*CI<;wor!(!Rmb;
zBeFfpHabsh&9BJ!3G!S)Vqt~9eLM}}p9Y()CG**uI!8jkfYKjI<5m;V9{sq8HNbNI
z9Qb&vd6V;>_a_(*u#JUq*ASutHg9nMJg@S=of_sDoUboBlnnRK93`sn(?-FP_JxoE
z91OvRMV&P3j?fjIgPL}-a%Ia;8W5h_0yih5#OnGkBV5hj>3SU^Axo-V-IGVM$`MsN
z^Q8wIQK=l_(5gi1Q!-hY6RzG<(jUVou|d!aHj3gf@Q?Bk?mb0)RQHiGw4P3v=AD#?
z5mk?DWPnMO!!7B9kvGAFGNXWGE?ozAydYyPs#F`ZpYQIGV91hG>(|I3I?@)Wgl%Uu
z25CAw#?g{iLOC${`Rane5i$suFSc(O*@)*@yu4y#`+JG&SmC^XRJ!Kw)Zp%S*13Jc
zTU?II^&OeoJ)*dp1Ub!%H&H*0ccMY;Cg!4A4mkIHsQTvozR#(P>h|xlMeVJ(OW)%}
z$Pj2@5zg>LO40uT{#?`hwhi?_cYtmFEG`w(i12qnwWTBQLYop6_({S%>Hav)eCiv4
ztvHsuu|72DFPb{-*J58vFA;yuZ$jUWqZXbWE1XbVvp)ANBJ%{y)F-frVUo?#H%8c!
zdaEgr=V_3kB?^4CxA{D@SjxDpa@BSxnsks_YygPcb`t;jt>>qR=1VMLrTq#Ix*c@;
z11Qx&eV^lGWBfTiV@(dPZQ@Np!5bB{#5%7`{tLg1d>V3`Q&Sf=5}xKIJjVzP0Uws>
zf3u7g)nwS61W6Kpo_}+}HCykx9$dptL?yKdxaMxn&}2?<vV79P&#|Zi9+vMa8+LR%
z+2`(R0#dqk?u3M=0`Bp>S2_<ZmfOPWTmo~&>sLZJUMTmPKDvpLNqJhumu)I#IEfff
z%$V#S%nkP2M(rMiLpC<TU$oJL`3OSsQ(7I5n1`qIFwu!KSRzTLtPXzA1gcg$m|BD=
zfb7~{ItQ$`Zr|w8Eeox1iH*!&=2$lTt{QUKWr_?ImGh6Jq%^fM$Bk~*sqGqYwPsXj
zx)U8dJd)hVqXv0LX2-;E+ZlDnUMGvPY5o#pi=N>7ahveCX#&Urm`l2R485=LsO<oj
zwaW%_oHuy3Z=QNn6_|^9?$i-A-QoOw-oqLPSD7;<%T?m58?+f`z02!763P)H`t63~
z`fG2EWb@#_><FcJjpUB%VI|_Jt3LQ0xPG?w_wBDH(+1!(>Wc~->AaLb<=md<k6v7f
zyZ8zh>cHv8S6SR@IsJX1s1C<ddf(ynPHTrkEeG`lOX{f;2KSUZavxi0C{Yaek`c%;
zdD+g{qxQ{U{jx_(k2B++X0`odDgzS@&)^GJ5qpWZeoq`}QuWR$lzInaCj!jkw}%Ht
z+XX_dEke1beuQ~)?Vi-%H?2jWho%}EJIoT*lV<-C<7?|XM&k<Ska)$Lef=*QaPuE~
z^?~S){X`q&8c#X5FUD5fa(FqO%$^%oW<zAxe$9^C6h@EF$E3%N1?QW>alOs}SZ&S{
zTGfGAM8d@X6iarOkDLRS+uwbgjTciiX0vgcJsHhZJigvD?`i7z8nA_%|FxLdf_Y`J
zT>yI7YTUQP*KPWF0vIrVZ1SuqU72}Wt4K7f_(f62Qc>78`qS|!RwL(^u<IosBDI5w
zvJM5#rDc<z0Wo-45L2;G_L-)%Rw900YOoDEq8<jM9qsA;U&{@}OQkPm;;a!>oSp{K
ztlD2x2#Cw%`#p$jFHhutR!?xr9KK^@9Lw&&Ir5&HGi;OvWw@m_-fZqMz$ML*d+_kK
zD+~x`f?{w}-?p`cxju=|V><GhnJNAi-=D{o7B|~y1qhIE2XN6Pj<7%={w2@|9%&R>
zH~2ZG<0>x2TSP)ekYs%zdk$Ta`^|WhY*R_HnHriwIQs8sWA#y^!MQyy_dkR&_9ush
z%r5`J6s{gve)el=e1CT=?0j-*lqa92>;&3GH6ufd%OaWLxl2Piq>Q3fVN~VmId3Il
znwl9UTsR{)L;GBLqM-{^cWP?-A@72@oapC7a+~lC>1x!D1<{*-2Hj_jUM5{kBp@G!
z9XO0r&AvlJ+QUIG_jX+yM;x4=XDHax>%olAwxh(TT7BYl=TJA_nCT6zV?&-q3aW=^
zv>gzjbttm~-Jnvowsa!IbbFt%D&5frDAzNi34<4d6h|h%7T4~l(^6xenmb=3^l)i1
zewF%6AlwO+-x}(s*Q6DdS(H=~z=WDPutu5iYBIge4)Yiqae0T>mJ*2$X%tCv1)8VR
z6{=0!S_fxS;@D9*_uB2d2xx|XY4Z-k81{M@$Y5V)F}`s5_Knsx<G1Bcu*66kI3Yht
z<hzH@5=K-&Do@!0a<ROoS}d|8kXt#h=a>kwzUdQCjBiEodo+o52|%U!dvr3`tf<hK
zFI;)_eQrToc9dqQn3)i}T<E4B%~0HzqB8nZy)44&%qI%b5U_GOP2C9dA0R-*>hv;H
z;-9J;eSP^e;7%0Mb0C4WG9Yb0xabuf*&?WzfAnZFb+na8D_5_8mQYq<oE<T;9}=t3
zpn|)kp{MOeszvz^iDAgu6;512R_%gehq%Dm7gU|<zh<^P24c9^qCXGpzXX3cevcaw
zLg%tLta%J6UY5GoRSnYKw$(bPu~q!zMJd<HC#!h*QPa+&9WvYB#>_F3BtuIq$NXEC
z)(~9OUrQ@-DZK0S0|yUto_aN|j?REsB`WCyi*Bdf#}VFbyg9tEY^bOI61n;p(e@vN
z`0)`oE$;4S+<l|Bse`m*h3ACn<uE_KE|6y|_P2Budgpgm5fbcwj5jt0aJZoYLz7PM
zP9&4<4HSxR@=ARiPRN05!t;zfEYiKc%C$zc)0w8bx8C*9BdaQ`8Cme6%*&8xfo(!H
zC5-(eU%?CX<J%@r(}R^ogPAz*JfX!1uTN*fVMm3F=p}38afszJ+!k&|06JkK;Zc!$
zMmp8vtVF9U5%b;jDOG7_Gw=F2hn>fn327%*17FoMx?XTa8}XCx*(zZ`@`s5tSAq1y
zzrV+BrGTr&Q%Y>f)esS`*8=PD+mxZP1~aB2AMHUW`>L73hfOQ5SPhI*Kpb7duE_CZ
zsyLHMGbK9(!;s{AezNUHmdP9Z4yrSU>DJ3Oes1{bk9=$WvtYi);7@s$%9OQfU4u_x
z-6@xmS2X4O%BS{+G2B`q)vYu-ZIrtlft))w6PLd2>%Javdgd)T>jue&a4muLd%waW
z7HZ0~mt;#Xs+rRt7wLV29td)~`SQ6@47~dc(4rk(!1BFd({H9+LC;rVp_uc_;+HQY
zk+N_R;j)kIHo=R}5SzoQV7EV4U-Kuj`ki7$JDuBntx%R#Xic)lZB-j?`4lv8WWE0p
zwYn<eR=kU8@l)OpYVGD$HiPBH+6!S5j-uuQSL(l_x6{wFyUYtErzKC&(uCF+Ahyn@
zvbZ<gqvtH^XrzY*_Z>+>gPv1^aWy2yR+8?~coXf$Cb^WR;+=qgOoEX)Cdublzr>zt
zd3AsEK21%}TMr$`LYicT!nKmeshF1NhR53_#{Y@+k$dlCiDG@tqn#j5v(JLGn<4P_
z2aH~C$T+;JOkc@(4>q4njeU%A=ranAx_Cymz6N+qXc?(L_IiKEbgu1^uz4JDCxwh6
zAC5h982mvHUD|>#SP|QT<L77tur!3{Yefnlxkd%)@<D>@FE~DbK7Ya%S&tW|xVV+M
zHvdlB-CwX0AZ2&Y_qIowlz{t%x%8;)uhKJbMe&i_kkW&;QL#qZvRP5`p14fl-=6b&
zc9CqPhTfue16hGg9|+%*Na7AT_ZpSNjR`@(s~sNeG1~I4aVGIkx1ar}5rq~+V$O8}
zqJwalyzw_^I$A?j9Y5xCYHi}~OaL#)2X|e-f7;7_7Qc(o*vFlw_HB=zqf-<XE5?q)
z*<Rqh{WFoUTXVTk+t^Wz5fH>oP%)vcO!J4OFTWx4*QH_arabPt-xQ+U|IhLqP_rX?
zv&fSb?1_XAqMkoQXInSP+_%1>+A1BVZNzQSSXkxx;|igLJKgIXK)&PB4Iv+1!*%NQ
z6SBoQ*r4(JY2ov2C*qr39ESk6H%b+s?FLwwK3(S@tX`5r-OYQY5`3)4a(zEW-_QB=
zd&T?DW_3Lph%T`q`)ebC-XdmTT*OWsQb1*REO>D(1dmyaG`Yv}S2Ypcf1#V&JpW>W
zz!#20lT5*<2Q^_4?e*7S+n=F0H6vEp=ri;I7>V%Fuk#i8P>-tass*DIKvX1CFOz7P
zT&O=@eAw{8In&r6hC?y)#G29%l>qhxXy8-NGkSJh%x#YYG~d*WX+1KTYaE!$$^@Re
znFu(eJu0!@rGmIEyhLxl@oMThH=$coruv>;`b>ryi;v-~py;N8y4R0Bb{WQ-31?M3
z36Cc_Z<qJY*CMQ~9n0E2fd$MW!a2o^d-n&o5~s!^?8Bx;5Dtm`RRR6UI-D1e^aFeC
z0ev?|m<}g}H6%VY2TX}GxJol9F}Z*N@s7D@Vomgl06*$Wk9}uz{;;*fkh#m6iPVe#
zX<71ALlSRCsA`Zl4E2M^ipvWs`&&L}^{gSAFEFDVvhdy*2PXfM6nv4@EEPVi-PQl%
z<7E+>s$Z}6!KcH~%lu@_IV|})Ieo`IYi2%$KiO97e0ox=AT@lg1u}tLtqmYg?<y*W
z6Qa#c_`pDw&3VgU7L%pKUY9byztw`nwF#AuoS=D~Ja<hDLq#Nc>QmZ=J9gT!=3n}`
zAwg0Kfb?%g^oK$X-uAbiRklO7&@#B*nqWGH?+w(bIDk7$p*T0E`|G<reP#(<jlix&
zGHDeING^wo1$%#feLgnRvzivQTHvW;bAj-K2Sp|4<__R<C2AV6RbBT`{?a1{D7=S*
zgmE0WyJFCv3)+Ot;*qTSahh4T5L5%z$T!u%8~!(x#Hr1K-`t3uNBLz!)Q@*fH-Bx_
zJeq!Q3*D+6VwI>KTD2y9APScgI<H8e0M@b_XrAaU%l<06j6~9W0ahJSPz~@nb_J@a
zViu?0);8A2BML>7)>DUoyGD@hIR8J+-a4r2Hd-6rY#L<KpmYf;9nvW&DInb;-JP3F
zgGh-;!v+LIS{kHFq&Cvs-QDp1e9k%VIWylk^FE$`V3=Wu`(Eq1uT|G#<R5i2^+e4w
z&}&;pODH;#c`R&jcrL0SF&&%4<jMi;kT`3y)z+Tu7G0ShE$`>T46Kx2+{H#b4Mg;>
zYN4w?DdELdm$`bR`k>VU4NSq%Gyi7Bm|@cJG=aTRQDL=)PN?iF?JTQej7LLCj*a<2
zgj-Ns))R&&D&FaDzG=Df8Uaw#R7xj4aU7S|qXcJ=n&yB1Mv{r}>(w1SH4Y776y1}R
zreD)&vO7Et`GYI7Me0sz$QaP0tP1}PG?Hh;)Q7&437nCjJ9GVTBVFc8k&MXGQbrGg
z$Ei}}vgOAc<8c^!OM}z+V8sizySw`@P6BD*s<z#*;o-oVbCUElD`Q=6aAW1k<P46f
zSTBClTgw>qWEPwzr?ch{M@Lk*=TGkS6#WQ|Zm$&j`%BH3b;OH5&OU$=U*rF)0f1W!
zl)++<!JDlin}~N=)HT_Csi3`c+_q(#^=IW>WJnG3=%r3<j$i8p6I0|d?bp2?Tmq+)
zR@(p5riDsnjr{eMBYR}-hi7bh$O#Sg;T%)@)lPN#PbI+Q=uiAA$i`MT68$0M{n_tS
z#tR@h_skP|p2?}wC35xx8d+@OmS*URl^L?;Ya|4fM!8<)3Kg$WtTL8#{QU({tr(N^
z_)qI|k#OuYHkUbCDOok$v}^De7P<!xcq=N%(PYJ-mz_)KMDUwiUN_lhaVvW&YG@B_
z_yxhVUT2rDTF>ds<1NQ_*XSZSRL#SJmO(T6aaeaGABXVddr~3fpQu`gZQ-??jTDG4
zi#{dYo4dwpCr>|!S|Isw&tW`x*Ep7=4pr~b5o&iEO~%x_2)UG>2$Ky9aK$jUcoWaz
z=xAFm^b9Toqib|(IEr=9J<1P&Hw_KZ*0%(fSxQbWAI@zvc_OQqmqh1o?mM(4zV^uE
zUp*JQ$H8_bpInaJB6#MZdBEUe`2J5~X-!Z}84y&O_zmpw{T$9B;sDmv+zc$LCbwTn
zIOO#<?xo<!6ODNrBw{Ua9M<#>B|4*IbDujK&!BC)AfWsF7VHuGJtA*XbtMw$?}E~?
zb+A|AGd8008j+F-YgXx*J#!jOjc&q-F}22r2LxS&wCyf>mS|p*rEl7s0p$h)p)?5!
z%C7kJBWj-7sogzT<q5$xuqMsVh$3v0t<+y2HZdB`8>Du3@jGjAbQSMk!RJ@nKb?5r
zUN%_xwmeF`b~)=Cv&=`?w5tF~D)8wiv;-AdVnK}12}4AFa^LH`?qEVOX=-<g+9qKh
z16oO*XJ<%_sTJCJOGi8T<sh1-RbRX{c$>#IBj9jr6^`5@vJl~#0pVwrNw#7rI!VF(
za=6iGGCQYyDBDHxTT!}LaScstyQqJZ=R`^}W~fpvp<A)~Y1VtrE^7rscx>|x(N&YX
zcCuU%0epwaKN{-qPIc|#kLKm?t&t@U8%!dE+kXTZ#9lJ#L9YR_<Dgc!WPj+Pq*iri
zmeYeGyN@vwg*`bx+hxHK$f2G%7Tc<km5Oe59RaSYbO*7nI2zl*pRix^#bcH%4N(u7
z2yIF3ba`@)PJ~$c^(iVFj(2Wejm0rqPdpgknPDPkrWoA}uW@81WBTTwb{0*?(`Vln
zf={tft+>BOcO*kkSU<#im?7{(>9aZ|J{6X19Y0C7<Iomy68x&#n1fNm_6BzUsM6JT
z@+T2qq1Z5b;|n!;3}NCwYe!$OjS!B=;lpj&L;pl|=3CB$&oB|0gPd++H)Min;Y*I+
z+jo{dDZiy{Z+&k)FiP<P6)rvk7rAQJi$t|5<2`3hxp%JJ2p<Qua&VtA-G~Sxy_}9#
zb$|8pq%n!JZ%7f+`<6t<!$tVs6DBJ*m^<ObO9&TG#C@o2H(kOY<DIX)bTsRgk|#Hj
z^xyDD*cw;yCo}8?_nAmnCM<wlpHqaGMlk&r+r2r-HR33g_!rv0c;J_RfUD$3Jxf3a
zZw(II<l4Qifyu;~_gI#{XN45r*X?k%_Sos2|GRZBy|GzL%Q{1C3!S8n5RWWkbpyx`
zfpJ(HNg5-0fq>hV30L?GQI=RTj+r-m=%b0kPdmTf8W|Z#R(Gw4ZF?566g|;MB!FW-
zp<*I=Wq!sRWE23~J?CN(W<dWT!nqYbqQ?L}#gtMRcwe9ZD^-C~Ssqtr^bXy~sm-^z
z`Vyx#hDTUL$%$26={K9lJ`)#8y%`ohCzH9+J9L?VxTJzaqV_)F+7rd1_bnggVj>`Q
z*F8@6(Y1&fQ>l@2CL(u|!>xY&@u25>QnQqjn_rwne(!V;4-pUuDO`3~_5l}pV5%KC
zIiL7FLL}S_|E3BUXGXei*L#Z8us{OnTfO0ldYeCJ$7b<{B?MpBsH1<3T-#`&i>gfF
zHrz0&V4d(O&fQZ&VAo}m-x>A&Eb!jFV+6ag;_CR!qR7AclCVI3r_K)dcf#1SH{>ZN
z%pdD_<P9Zq>E*}?)IdopHFLDb(bMzG|G=14Zm#!KoP2n4EV7N6G#P9wt>r^3tJipW
zI*v4s+}ne*A6YzP#oJ+C*<n%H{*JHRH0Sa48`d>fTiPf^!6+}DXd<EGLfN<8ivG_c
zRGdt>XDouZ4-r?pj)?Jf82c4*&W!7Ab6xPA_$j7CBahPmpPB4kY8L;O7Qp{^LDixq
z&^j9%+wfQ~Kp-X{nPq^pwmv_ixyi%6P;TBzD(oR`IvnA)#9DV5{Fy8)u?5O?SN{oA
zk~sR}`Pi2Ut%s;h=Xm+Z-=)=2FRW^W6D_t$&Y~~mGE14ul2&b+AOX4mQPJ6JmrKK8
zWsA}rg0e(4Ha?%7m0w(!0S7vTZOK2)zi#$%_j#9icE-K7_RGe<=a<jmp;(x5Zt@UK
z)(4sfD5<YeQ|#$FxLCOSHRWyR7o%(!>9sxi5H@>NEzP{bG5d)DCqwo`P(}jECZT!2
zHu0b0&b-1{@6etiw1(qKpnrA4+fMy<(!xc9KOX4@8{W{;D#>|=kFt3omf2;IgVcQD
zXlC^vFB?!SM5mtb-gN<C*3?43E{zbvfsE4(50cMzwI^c2LPBrTandNIr>FLnHft1n
z0Vaan`u*g_LhB)%n!O4&E_d^!Eu3#ErpZM}nGl|o0#d4&<@<0_))Jge#qPu9iN7$@
zT74zCOYt=@sVF~(ASXpXD}tT?i#}eC?(Eq_-Zz^RVz9~!U~(jDl=;NGMge7WdWY`6
z%<mJw-SUJCsU6NhxzL=`<N$|l?tv3w!rQ1T7MCsl-xc&<mN6L;{PO$PcA85>_dP`H
z{PQ+UiaH=#39--1Wjth}=o1uae;$0m^p}bWFFAkC?C4y-WM?mHt4Du*2jM9^7#0qn
zcFbIGRYUa{?UQzX%-{K2AMd8E?wq1nMlybj1@FxP3SmD4mm+$vd`hW&RdRO~Pm&>B
zN|06SnnnMez`q%@T-+t_`i8oB(8%J=D3r%aaa?JJG9V9IFKS!<(qt<@0%vaV`3%?+
z^VklR!`;xAo}E7FoflvAe#rV?L*09{iu#1~t|S}N#M*IGeW33~qk27<$TBP#wE`ts
zNGr(Xmkx?J`*#^C+~XuzUdNZumj5~`+Ac~dA$m46+Wa*qukd>&_wCTvZ7ner%a0Kb
z{l**9zH;{c9jU#opUM<G#%!Kh4<;sjds_soiRHzI_r1wHOe&Csl`24~C}b_8koVT#
z2wZum^bVoNe!eX>Dxd}?Nw9^M08)<zkosdelFyfr=Br&alB61ZcopTw;kGoywzxs?
z@q2;C6!sjKY$jG!=m*WafkKtx2lF>zKs#(w@mTh@)a1kcw!tH}29CJK(8F~)(Z=TJ
zyb_G>RV|eF5{%+4(My?V`W~!whRQI*sQN`pKm3jk1269?3|l|a39*Nmy~$TJgEva!
z?WLGXn~%vl5<LxN3iy!wc5goQlRg*U!1Fva+YGJcnA~fNa3(pLBlbJrWBkk)8)uHi
zBikx7{8jDp{V2rc2OnwG`D`V1=pax9Zhb-vG{irtj}sfVjsO{8>;4l31AR%YTfjpq
znh|Y>5B^ug2M??w6qscIgEGJ_&TXtmiQ~ET;%bD9cgQ4nLiv_Xan-BLt}7XFK7S1F
zGjwc9(sPNej!q=Vv-nJEJFdz4mf%Ctcp+tVSE_qn=m_fe@sf7y2CrFFM~rKRvi`11
z_K0QZn7Q~z@Tvntlu#okP%!S&jq5nF@R}b}tyweEg!sG22qCQZzNV`b3J@#5KuWE!
z<NzwJ4uiH}Hy3}B&u<Cx?fiL5non|@zM*UatFOh#I(y155`eTapQXmJtBMfg4NG~^
z>c$nSo#S@z(3Y$MbX@0N4t)AM6Tj>8$tF2@XPMEiRGLUk>s;ETzHZm-I1>1Fcf(su
z9b8oyC*HO!+3ihr*Ky~yk;r)YUV_E%_z8){L^<Ai+?*2fX8kR%O!BH<#dFv)QbICN
z46$a7K=w%Gs6EZzY2SIgdu%*i0sA>lcYip=MRM_6g-^-U*bT3&c@n3EIke-7Tvy0~
zZ!(4+`L|VAfbrubBVQ`YeTGLw@LCdJijWDP%RTqqDe;F#o{ORPJa&Z!v-P6kYl)P0
z)QorohmZPslRtbaiWe76l3|ILP0bK8CjeV!06GSicUWTcCxie2FZhQky#^Mdj9@+<
zu*mnGF{#v9`c6I-ukGIKn;c2$hwYcCY>6LxEX0>kIhHJYL3XieVw3p&Uz!K-ZNh?q
z1-h{OjbbGx6hlA;mPJlrw%jwe!-xc4c%@4ER+4N%7FK#or<?Me`s;cg9ZJ&pw=S2f
z>$&aE)s*!>%j{VLi$(4^vb{<rj@I>D^5M+zh<R|Ijg+8PCtF^3ia3F1%B`OzbEITy
zNSCQb^hIh(aZ&%K(lD-`Yf$2es%??y(vNttD>6WcbVj$8gb==B%U#ZB%E5_x-ScNg
zg!8MYUxvyLko{uZxQvi+iNR(@vW!+E`rJ95S~lx!eedc<M$f0);@q2fl+CLFo=^*{
zp1a_><8~Au-94wy8ay!!V|S*Y4sA5=;6#aC=hd8<h&;tf=11_70_qlM9x2q4U`c4f
z*x%#{pQa=~2Tz;ODHwIjP*}(+6rEH4mn{ZLjMFF6psE7mfxD5zn-808{l)?Qm<Rq9
zL0ty<Tr&-b;fYuUcEy~sIV4XP^4<=b@!Agl2$J|fQXKoe$D(}T*d@GPA!=h_OXt`b
z3i!%`e|j)Gpd5Edg)g@&Q^MSp5Iq|YZ1QVxw@Q_VGf^xFMq3eV#qdGNV?E*<gD=o=
z_JrvVAhfi`UY$z8N>Od9j}N$FW%Zs!%fw&BXNuXzzEJr0H;(a-W=U&;)M6wa+`abP
z*#f%GqWOiAYSQ-;=#C_PPf`(&Hyh4iatB*uR@Euadd{w;xuaG3y_qZ5aoDiB`lZm=
z=OVjr{hvI_SblFhIHhn*uD41R0CZE?jc<Cf>T$eD`w7*E(Z+>(T?0YKwrFTO17YD?
zQ=7aX7yrbyUy6nP)lrFeHX)W8-%ItYtp@#clOKhC1l_$v-5hHy@5~{BkK_f5wPyL8
z6&PKt5CD5AK!_~(&jdDcaz(bsEPIEZwPx3*Ok~eyso2;}1Atl9w#V&}e~h5=z5+;M
za;Op2Qx0TUQ720|I+DsX%vl{x8?T}dzgcCXOOp6#da?8ir`SH!$#w`wU7ek+*$*E%
z1HxnZoD8UbZEtv1ko~0Ddq?JaK$D*zK0ML($;uU<mwv}271%YFTw<Ptm5tXBnV2W-
zcRawWnap9tGqq&5E3WroRY)l!TJ@6O*n;RsFMJNum^aP1GA-^=so6$1leWHYJC6M9
z&2wzUa|@noPZKLYB9S?0{^ZPJ1$U&%+?z?Ar&&WZ&UMkbXKC6-Gw^cCF2l>7ExBwX
zUT=V&fd9~wkfOuWDhYs|*uLW-yYh_H(M#!DgNv$g0a8o<Zyg%(|3Ow;SiqKgFb|)l
z&6JRbWj!aL-+mp3h`}q+y{yKsggNRzh~Zt6s*X|0aIIC@SdNpmq<y`-KafULv#3OZ
z6k%p4`Zmw*bee|~2D2*GSEle>d296!1rqIZTwR@85J<3%(7mNv>OJ{33j7F&TaN$Q
zz)P^(9vjnn?u{JMcWr#Q8MCKxq>L17TrOiyEE9q>9jh5Y-`%5MPC_`DZqN-~#8dSk
zkP~wd`?YAi>_({T+u(d3s>(C{TW-)l`Yzg@g@Q;G?lvoQCp?|TV)c6VmANP30$W&x
ztM>LYV_U26+8a8bX>zC1mmz-UxD$YkZt(LVc_dzbzjD6wwuRx~VH2^2TT!nJ%|j2+
z>TkI>Fj4KM(C7is0VbMxhW%z*x|F9Da)Z7q!$pnrPSF!aBUyaz`X#G9@u5wA=~WLm
zzDC66mk347={G-VvwG=>F=+_&JJ-8O9N4I6oRUYwE_kO!%3r$WRyU>XZCZTyAS9d9
zoG<#IOXkO!B+Z*B&R-t67fL=kIo-A`0g-)uro+)Tj0no#H*xduG%0Vyw2yYkpHgq&
zjl&<Jhn7cooC#@fI3L(`ms8^->Bc8)+5L%_?2HzA`~jUpF^3$rEIdF4?SEeL|Lcpx
zDnc(hl+7L-)%r#qM)3lD9H(>ToV(>2r)%_hGlX@sJWQA*u*lA6P?I$=RnzcjG05p1
zy8Xk*4s+I(v*e<4GGflOL#h#Z=(GW`V3+sI>Q(6*DUQ!($F2kcMlmJ;VOx@l=^aAd
z9(p;jiaAPE;ZUL9(4cMadj@8@U`|xui6$Z)U_>^Z!JfR`7LiH>Q3?cI(GtMVR)l{R
z0ek=>kGiEFaQqJA{5ZSdfo^4FD(<ye3W9ikuB}Hdw{Q;eJ5CjzcpS~i42V~nNIBWb
zr)1oC`Fy;-Lt_%AbR4B}b)uT}_MfT*q94?G20uASF-B2Z6yPd1q8i$wb=eVw%VIL9
zDOSE^eaR`2(%aA5h)l(oki4e}-G4@Ta)O>OzA=JnzKq|QU@fJt|ISp+4_OGx|BNZ^
z`_F=p7}Qd6=Kcc6JKrlHxY9r}NEz!ViANoWl_%bK&pd5C3*q+>P6oo)6kRD~8NIf8
zICkOj_SI7vcHzj7MjXw`_~R-YbL$0D+E_r6g&3Q@?IiYuLZg7tUG}Ap_WaiGm>rkN
zpB<h4(RpSkz%tM;9#oO$A0y8NzIYoYyv9g(2NHEzXUw-=Ln^=(_Nm+atEC$MGa}7|
zf-SXSHMDEzYOu^#vO2KA->_Rlr0aRA^5cuDLOSuJq#gE$3J(3L>>oxNz2E$qD`$s0
z<=#Cds^!yl&hCi>h~S5-J>6HfG2<3Asa>z)dWU9S&(6xx;0<z}0hfQKVVkIF!$#TS
zQBj3HL0QH&L|MlFu0;(=36_6pm3{MM#;_9&)hZEW51|HV9gn)HcfNQ2D4D&?<PYBD
zy%%7u{H)YgLU!?oQSnu;Kh_*b{YSc!8e^ZdAq@l3g1}}kU`6>?`l<g7km>S^ktA?;
z>RR375>Y~fhmwe14f0Aw3Z)55gggVV+017kk20of%>^}a;N6l|Nog^2l4{ZRM55Mc
z+4x0Cu~-GYapmLTMJ}^1b1_D-UN5hvY`Lw2PVfm;H;}FUDhRsNXhJ1{Ij=s<@4B`z
z%xtWhpJQiq4NBX0KDqP^Fcb3|ik8MMm0aM#&rmjfjX3X|5=)5c6!w1CQcM_$6%fE(
zQ$hByxxP_-eE1Ij9YY_T_ya@o8Vzs&w_uD2&>eQ&&)6d(X&CeaN8XFSg#K5Hig^4T
z;HpHh8*;ix!e-qmZ~DE&>hYxs`1Cn+ACt50M^3)i*sFIn4zkr>S2x;th4LFSys{Uf
z9T+8;#V%>$JAOmSYHJ8DeOP0favu!^Zu8YrP876|D%fs+W4A9R(!5C|{Wh*)^HoPn
zw@%A{41CH+2+!@SHHi!{`SnFdL)v+~Xw2~J8?zpe=vg}9VFCUl9{s1*xd42rApd#j
z!ir8;t5i`ouWhq4UqqJ+>N~xB*|Fx*ZjaXA#o{u>qt?q$xAg2|FVEX7iSxiu07L$}
z2aw+k1xkYC(=Mj*mY{UW(88X0(Z{4lo5bSmu6ZbHK=+w=qp;I6q-#3V&2w5T1RBw3
z{Mq}Wm^`62n=$L4!`?f2;tXvgt(N)u?GEdn=Ske(gGw#P4Jprz8~O@+hp6(!NWFsk
z+IU0_BNq2PfVG|^M?|dqzux-7N2Z;puQtah4m^Kdy~Wz*hV{M)iF}TzC_%L|^u?`6
z6w&~nI@kBS1dQM$R2V3t*%_t*ILKCxs}l=sNx)Qm|BvRJ@}Cg#xv}|~2qq9B#&&fQ
zYw~#D7;pYkcucX`1|xMMeJ(=1XYA{W!(F>xUP0Jy@(pHww&Loq0d(&CrMn0x0wrA}
z-ISlzSdOfc{%KUx=Nw=+popi;hq{T$iUhR8_Mh@SC9c$LT0UNiK{dX+Tmx&YRZV?c
zQ|ooP*%{CJT4p1yq{@~YP2|Ih_MuAXaQ_Q#0;NY?F(a#_K<ePizA{!oia<NyHEuOu
z^Tcd>#$O1QmN=-2#ed)R*Dt-EEgJuv@@d>Jz##8iv|V=Z8*w*RByyv>6ifsW+-%qd
z?6!6oYY&Lh^@JVAzaT)mjz8=j{0A+t0Bd4?X1<ODc#Q#Wp)!n$qSZJTrz8f<lFtCC
zN#gW9Q|M<eHM!!5qL)YfJ&&@CY8|2zSGgWaOke;0Sf74bl(8A`UC*{Dp_okOgVqs&
zprE!7Ie`^jO!?n0^%ml;*N&kYqLnrIP#wNvmEsmzf5@*vRx0f7nLRJ}$>25;p@c-7
zh<sOVoOe#1?4gbmrjr7{Y>rQ?3n!|3z6rh=E4JCSwjO0NKmB(1qH-<xE2$(<$DoZm
zycX7cxM!03e9)d60kFAG&qd}*@qq-{5VbA<lwzOKcbWcN{8wPu{!e1{8v3WqbE2wJ
zAfrvmR+pN(WNj5ZF&C3L@1STvAs&2$7oSFL;thppX_-z6-#TZi?C3r1`+xC?|Hjz=
zj51VY7Xi6E3+~^%Oz9$Ko6vK69=F&w;~G_%W~4KM;In&wBE|OmExl<qX5y^oQb7%!
z#NXRRMGATWu~<zILZ4K-<ZZXbDN)h}vf}ALk6fMENqG(=!N|Njo|t6;d;c?PCiC@U
zPUekV(o);LUW>OLqZbInoxZJ}k#SO&XBO)Gx@jHTNdd3i-jRGZ2j|<><j3?>1HQ9D
zcV%@3;EvU;x#K?os{E&7>sPbLoz!a=IOY&KW*Ruv`Of2*>o`D?GaQ^n&y~Wn+)Ke#
z@5^*b_QB%u)vd+Sy+>MNnT&lvi4eJv8S$0y$G&&*@6e0gQp@UvWpBRv500dW4V2M|
z2Rw{%r;2b)2@MPJh9)ie6Z=Q&OnwGhfNu?M*UphXBljMZiP!uqU5Wq6?o=oPvov7i
zq0^>1vZbV+?vAxYr2Zf6D=5N?C)5q-WP2Hvwz`M8-<Mi0NJtLxD{7J&e-~F#6@AW@
zWQ)KpW*=wGYBsWO^Q|swi2hbJ^sf8sLQF3NJ-;#ikQ+x=$rdP`);w-|L<qmg6=3*%
z<y*j4`O(MWY)}1c>{tJq$2hMRaS?Mt$v1)0Z?YL$oJkUF#2ri92E_qKqNcW$<!Yi_
zYx}e|l@fWj+ReY$uytqhe^)5qsH1F-{JgE&k%rw{d-n|kHp$<JGWY{Dpvq@l-nMj}
zQ{RNzEW<wQA(Z|pxrBu9(bVJP3j2^(v@DLY&X1csUzPcIR5s`#7HwboDj<{n@R%&I
zct7fw{L?aCp(p-5C7qvFL{k&Jl<Dg)WBI@~ARTY?NRWRPbMHm!@TzprAyKCH1>fV-
zwBec?P7e~x!;KwZ?a9c60x;0J^0&xnkCJHvAY=b8$ND6zbjt?gX{(?T+sAua^Fd{v
z1e!^)&x6L*xZpKrduzY_7SZE_fT|A3&WCy6$gd-8S}d@J2r1=Z9;V;tVl+L0l&1Oi
zi7&TF|9(DR!ENzJe3elx(Zf5G%?69-rg;``$qWsP_1H>E){3^dj$?(@$ww;aDcBa;
z){_osE1E&JqPXfy=0UkOM!k~2EV|`&RWl$9S7j(*UHj)@CHvE^sb|8`uz3D5r)em5
zJs+*kp11Cq#Eb!(_OU9>j}LPh_OrVAKm3xvHAyMP@;*+v-gO8WT8RG4NIgw9dY>0B
z{2~<liN`N_8Y<Dw`$5PnbQ20j7rA#S5QFEZr$Z4S{}x-hB`S|993_+My#=!`BQf*2
zEp+9=!D9L|ZMT}cP~x8+f6Z2&141eo2=#l{r%ZWv>rkVQCrw`4nWdQ&{`xWt?W<y?
zUkH#DdO*5afR1heBqod`xdeiRkX8yBzbGON*-1KcVfwM8j+Kd**hl<US1TnOq_pH6
zv^AuD8;~Op%bZbI4w%C<iva|bwWJKAH%e93?wFTdHT-?>&wOTo{DO?7RbQ=e^`z~O
zL7URQy~Z)fQecYX$D*rp!v>aZsHZ8E6XARv`541|hva%~UC7N2Xr&leJux=B&aF3u
zT_c_KvEix!oHg8%(f1!z+?W0XHN1}%9lZQ-tPbphChWsG6M_fUgDQJ*!=EGTnLf#G
z%J2nfM*=09Eg_kn9w*0W7sSjWIpIc5I(Je`o;Lnvj+JxU+EGsR0D2>5=xy7JS2swE
z@;%Ov)l~xdxe2N;5Es`(8fDDbh+uX83lh{#Hu7t_EYpBc@Tmqqyy$iBkG~5Q11n$s
z0rF4juF{MIwP&q-cQ5>qH<s*o!n&4*%}wW+#=GXXv3<(i8*Yn#ZJ9bGn&>y(^nO`C
z9$&eOiMr9ZcvLgZ+5Zr(YiG6mJ@s?2wI4rew+%;bby9(=a3ZtMTcqpEjo#c*Y{b~w
z=#NO?GN>f@%R_^K@c7}{%-nO_*g`kAu;I`-Dgco_2vlgOLk?u8fPE>{s6}sI0I6~I
zf97IX6`efVmppRn2XGn(LQJ`^i#nph25G(0rM=Xd`KN)Ny&5lL7x$c!x!B$#&C6nI
zsoKxa6w%9{DAJ~Kf;Dk}u<mVAJr<8bcVg1gSzy~|q2y2%>>X4G__vFw?)DWh68luV
z<x1soK1c-b=8*)jD`Mwh21s4?dDH()`6~c#WsmrWI(#OC??}&>?KkY{sTrSr*?52G
ztA99J|EdCJM~h3Zj+S9I)XwKcH6UVE?we+VVx`emIOrhF!$!USDX1VLob6DP%scj)
zLX$p^l6zWM^RkJ=%Z|uLn+>mbdEbGc%?ct9)s(Use2`ij+fc2pu+emsy|YfAz9+mP
z6Te6S^Tc7HSF{L*<DqW;%qWX1Xf@|et;-;1R-bccVIQY%QM>iEkjF&)$kYW_DG|V1
z!pCCk{~UWl=_n9)wX#RHrjWw3Gc6}Mf7w}Va~mlU!B5cm{YwsUm9p#GLh?_s=-Pa-
z5i*UqBnO~dN>+ZpSMh?>UFW;P=N>^AjNj$TOLK<7q**7^XpBpaRk?F@(W54y+V%5t
z^7r&Te4jqThuRr15f_c`Z5|O|1H@dV>1s$3=3)HoT;LU;=)5te)Ne0ypcQCG3jRxW
zlF0?O)P%9A!3I@<k6tyWF&%t7(dWZ`6dp~;^}_DDa|3IrLK;6=v0I68FM-p>>Kt<n
zlYc62&Zbg4WS8?uiu0$^(Uciqn+>ncUSz?^WG+gE9O;XWT0qBK9@R%WZ(?OV5qq{a
zy?LPtn`)wfx`07EZ7aDmcxE#5iVXdPFHSd8g43_{)KcBRrwUU4wk6Zl|GQz+{Rq(U
zC7LmyQZJ3Nnf0-TLIH?-D;58s#+jCidmLBC$nVI(3Tv!B5*|xUJRCq~X2y@h_hwib
z$;W0CNfyvEpA*=1I4~1SWd9?p#3+7)K9pV38v}WU<bzvFdS2lPkia`){+YhK3oX|N
zhHmJcBj@jxF7qWpI`YcP6;g#{10g9!Ba{aq&+xaQ6+KGk8>H*u%@=buax=Utn1Tmx
z$R%@D#$dOL)3U{*3tEL6i3I1JriF&Jk&qR1g3Ph!>0eb!iVO<3)d;FmhJS5qJY^}m
zJLahx(aDr_cQe^5)zHwe|C*|y^hSM-wr@w7L|A9v{K=STWktl#!58Drcg&Ct$DHz7
zOf$Ot-XUU(X;rG-SakecpgzsKT7_cOI03};xMAlNNkC{&L7#{P3|d}>5&+4w8&s>{
zDV*F~Wcxk)<aE2xiF7IRcT|BHAYRBwg!!`{srrXC9&k^$5I~@F@jV;;_m-%XXpW%x
zs`0?x;>*&Hz>7y7>SOT|p6yHFKXga6A_*0qsEgd42a8^v3e6hK%5bE}a(Qab<6o@M
z&it$S&i|&+>Hc6#HP|>Cd5LafMtbFR{0VP+pHy9@<$Or3D~2>98p-q5>2GMZ{fv~>
zOY{o1@7utquRFADw<E8A^$61vPE@beHT;6;`kw_*Br)3yIR7|?oUQQ?>Me9@*$d^l
zNODHyMxz$r-uZ_l?Y9z%20hOZOjM|UuWkfX8Hoo7Yk^EN)BZ=fV1N~Q$pdlb-5r?6
zSGdjCTFOiT`#M}`c$2H02#4lL6rIy28AVKl1(UuZ`z@tXIl0<T6iugc>Q0|$p-x;k
zpPIS%=j?!~nSnfLNo5{&$x4}-T@^KZtlImbuyQ9`67rq2$&HikdlMpHW}ZQ<K4AfQ
zn>pd#UsHuh#zSsQgt}Yoj-8>YAc?E{%lfzLJQAM;2A|e-snx%4?V~&;bFtv&;uT64
z$=z%?=Jjhb<CxOtNM_NMuQF8Dcx$bim!o#pv-g5^;=%ie(cb5kvqXWCR*@aE_#4b2
zn~mxG#GR6o`v=PdrO6e!LE8cKo91j-JA{Ct?xkKy&GbjRzKM@d7mm*K#WGVC1pByM
z{q2ibXFl#act#Bv)**F5-e#ZsXPvC6X*`1|5r8U=`W$k;anaM$sYuDlSTsAEvh;JP
ztZY%m^hNkT_Bu_A=R;&n2O1WHDpv;0PS;M}&OL-5_Z=+S^DJ$<q4|EWxfZD)yC$DO
zzv63|%;WnOE+~$>+Js=o5;yvKn_Bk*j-^kJN(6)Afc5}wkd-j8PvUkikltR*eq}Vg
z^G3vhv(KaRyK4v&MH3_9MNayVsiiM9dOg;!5{Pd4-ijbAmUxSfbwlv$OQwCZt9g;z
zt1PkBV|@zIbG@4`gHi5<rKuCr%hM>O;=Ruwd_#9M6y_D_aq_Ufg1^ClU;ghu>64<e
z;lW5S(N~MIH}DYE&M4Rs)zBE^M&4)4cpvc7hz$ZllJ{K-K9687%yQ+6-U|@$QPbgN
z1*PG+#V)O8H9c;OWonP^@SCE=4bbh4p&mTk>|Pco$Rcigc4+&BBVtm~k%g?3V%O`L
zq-@934Ry?+Rb9sndb~?@!h`;7_T1N;)CJl7F0<YH9x-@DH5#r2gO=mhmBX~eeVUvO
zqg@xW^$x`awh2`cBA96Lob;U<=sM@qgqsGE#$v;BIOuc-WF;s}2s=kziBKMt1T9`|
z;pIr+BKF8c;LYN{=g_VPgyriW)zpkIg64MNN+6#fVlIh0abSd_rVnt+DavH>#BWgF
zB58>K#iu$5mOcg`{(M&M_^M1wKm2q@T!p;DU)`w-BFiq$9AomxpmgWd*NJfh&-+lF
z!Ql=>h+VrB#el%)mjP{72vZ~#NUUFW#rR)#%?j#^U0T?2K%?_GXK9XfmT(U&WPY`D
z7#LAHJhmvGIhv-DUjg=lQx25n>fwN<*TgG7Nm|@J`95?HyIonxNt+K$1AUC@F|J(g
zS$p?bK#9DBI`=5nL2SPfQ`~duRA4dodNCjQ3)@B+42;+)tIz)m*vEuA5-QvXSzM?o
zy(GBR)ddTiFDdTB4c_jjpF*xA?@f`<cyEw0X()3f<rsqxPi@^U4P<%!VFQYkUAi+s
zV~~GLkzo{I;FScAl;=A~?^-&W8u^YY8zCXnI>I;GLUs;zwCXH03GDRhU$e(IA6@4<
zl2nGN{p~pe7Zcc*---%G^mGi-#o=@}Kd&+k7lOd{@uB;t4dQO#%sljng?l`1&j*a`
zNCCHZ*KYZi2acqJDaeR2x*%`3OYz6dsE~>t)+`IQhV(guS?oso!C%Pl>;j7)wQyZm
z;FyU$ea9SDfoogcq;Z~bz$Qzb7;JABa3bKM@&N0e=1W%-Mz0-F3b!f%Bh0uAd$Ir@
z?@=2w1OAu5s5jzBn+NFdjF7asHX_D?0;ijEBDzdAvKzf;=B|_MJa6nPESE89KP7ke
zFM|n8XhtVrJ#UOHu=Rdb>JEV+Pi8cbM1c`y%raYrf_Qp$vE*V`LbEL*(OC>Ni1~mp
zqlc5E%k?V=WZPggPi-^jFC6>-LcqkUz$hem!4^nKZpj^9QBofL0%Mw{@6yqAZ@49_
zkz4Y@N@?~4eOO76*5?G7#qX9hqJN%lc;_iI?P95b(sj|XS%HvTn=Yqzz$X@qAIL@<
zZ4SJS!VS_M#GY%giAbrRs4YF#n`(}p@nvUk9M2w=Pl~Ran9C64ip7qd)D>gWxL8#{
zV@fC~f;*QsM-&=oWK4EYc|~tzSB?B|WO;F9n`Ergys08bGTrXw{4|r7Jh(g4_+^Wb
zPqPUc%c+6mPCiX7{{yMq0HoeSLDPitG(6tqg<B~5{pEe*EX!+^IObf^pY$kse18i#
zyUN5em{vYYdbA=_9OSSDQfZ#*G|UenLytEgo!3CxoOlW13PMCP++1Bi?^{*|O^K*a
zfdQryp<A(sbMQjR#_-3$&>r`%Mx@maTK^k^RVZxr1&OCMc+NUh{YV$}H$kn;x+RFr
zyEzOqb!xa{q*21Uhz4!qfAc(aPv@$E;?~SaJC>B2m|(8cAEsk8#64<^e_w}x?kw+F
zTE^Qbm(=)EQwSxy(W(aX)y$E0mTZDZ`ts%Z(tdcy)b8=5E;5XSU+?~GT8W1l)qLyv
z$JN0D?AJA+SE^FoG^J$iuzxu0ghToy?TJm@+_gRBWYGyTBql$hc4Px4wjDg9lHn%c
z37o8`XYWf100ryvv7P~>160NSOTzX9ms5zcLp~?SP$0OhMYqSHAp-3NhqB1f>(y%%
z^$QN6gx26Iw)8QIOi`bhj3(h<C~&=%i~?reEC3t~+FrLHf_wFFj}EmS(D(b%of?nJ
zc59(g4<{FTUf(sK1}F^%e}TIH7p6;-!K7gE0FJxtz}z2L{53j>s$V_cPB_Cn+-5dC
zXLPhdM%Sdd1JV0i(hQ=v>I|O)V3)fDKiVEQpqO7i7z=zXtzJf4n_11#_i#@hATrSw
z?aE$D&s|!HhUg_2Du&HsTy?fVzQ#}XjtgpwSS<}J<7}zjV1QVcV!l`xC$Q#5WlV1h
zLaA4Wbj3Urzo)DZx_Nm#K6HipQci8e#$9!^z^fZ2`a@<Ou{+v6RN(6UHrbY)_^{`)
zs}f%4rEqnI!TTKKUo5jxt%kIDqNY2d3V_K@DS*!lxZ*cv&pVSuI~8Aq%?uL=c0Fpo
zx_${deTB;gMhszyAMCHcG2bY)_7o}g3I*OmchpS_5OqF=c)(@R0}k_vD2o;}7#WOs
zm^kn_bZb0rz;J8)D@O32z@g8HI*$#~t(!M&k%fJB=&E>q`I(x|`37C?$jHew%&8>7
zixnCFBfhc)#xB)8r?wax*33I7icF11Ic3(K(??j8aYfHsYxEb~fC_@PCTlTMw}A8d
zfeiE1eJ%rd)|a%)Q)$$lDaL6o_X~_de+Ciez}zYFRlhjYl|GsPS<g@WK(p|0c*3*>
z#H0M;RADt!^wn9H*(nzKq0_c^K?h0=uB_et_mtc}CreSgFzgN%pMfBh-C?3H5cMVX
zry!o4FCAN<LmLwOyQXt{Ihv)}V|KY6+Y`P8@+mJ3VE#J0)Az~=fSgCk?IFeIcN{dU
zz8AyM0Dp2a#QH%E;_(&VeZ$Y6`fJJQ$wN-BPXFu`ULily=DFaDdJ$nmW}1w$%Isw)
zCSFa0`xBW?q-*4UMJ6ZToY$5cEQZ1}t<VOTOHr_9Yzga(Uw|9Ia0;=ainKs-ag5;>
zXo#xJ#Igm3b)&cq@;7{Woil<DnvVShLIj+7y1~wuWVW*6X+d`Z4^S<n%_uf1C8NLh
z5-)TteLT=zoKz-eS8|Uz{r8oh@Vl9Lhp-xn=3IDLNnBIbU0U1+q*1)wGgL%Y@~hQu
z<o^4`A^eO+)FeJoc%OX;=dx&eI;IqL!ej-A>p}$LRpV+J;3EPF**f>*TkB!R5MRhV
z?NFjgeISo=8l=3}d3wnLIz3TD&hx<?P#%Is?s~1BSdDi>S|N5NR1RykOR-B@w$%xP
zLw643O`6D80~?dKLq@rE*En$lt;5CShm{mXl%ZC3>pg~MOm@&_o5sCOrH@+(NXH6b
z>Tw*Tmn+|q5fCjr$Pf`DX8W80X6s0i$w@Eccl4)k1z?MFflg|kn3qoiP%A$R`o`l`
zB~nBAGc=)>Cbb#;sce7lwhc=^0Hixji=NI#I%~*2>%e}4!zM-WT#<dDg8^w%$``x(
z6`Bg~`=3NMGFiDJPiJQ>g4bf{<MiA5?XWIB-(uvvpB+cz+Cpysjq_G_H^8eML+J}g
zWnGB*Y&51US>i5Lv+wt)CdDqNfPF(Jfh>*VZP1<IQ&!ORxuoBz5vKUiRmIy&qAd-;
zMY93+Iy$oVmy{iF&{mDNi+4zHOa?MM9*Ojta7aaEZQS+dP#g^gWe#@L40TT9cTm*I
zVHKzwd_-XoQ(PN_6K`yrRWbKeFsmn0yH$F_k{asH6t?!|!V0W^!Zkq$GRP-%L$0?W
z#d#$G1VRJz+Cd)u!M9Uaf)s<7?@H)y6yHSRdE^G!@J8=WPfXt3s*l!aE;&>$ZhMsY
zJ&HZofK_JP7S-VL1fYUgXSOhVkGI;lT)!e$v2LRJ8A3sVQZ#I#qxx9XcX7y+KPXo<
zwVcb-x*bZpB~VH#-GlOPo>7RR1R-^P#P_14bi)$h*?#$U8l^N;M07%0*_ialJx$ON
z!>ygB-=45;^o!#}$V_bR-b}rP3ZXiHoq^y9YS`x|bhC%3U<{^Z47A|GN?elno%mTg
z;yjzL>U?1q)ggOs#9c0-$fYm7j@kT7BnwHpa|*SLPnTaBcOf_e<rbN5Z5shw=Vm@E
zP)gBIv~?1hSZiTFbENl->)w_@(&?sEI;`jG2qqAn0ph$C85P5*j8Y5>Evn^&mV5Hq
zR1f;<3zbR#d)E5}_VXjV+Urydx61z&^u9!8LxDj#?&7{OKM2Y1tBD~cvSLk`2w>p~
zhvD`K0TL#@IN+(7y)#BR?5dP7deKnCak$*<I?wJcsiGobxjUTCCSLG!%gPBetSaM6
zhU3k}q3dIrae+m5Av{`;zt~!b(Ok6i^!W<XX0;vm!{v{Vf-T1PXKa*kRwXp+)FT{q
zvMUdLj}PwaVG=~a?CZ@RwV0|skBnY6#@=lh(cYZm|GM2>{q4k!o&FOVhrj^amykP<
zqbw(BAt7>2R&UB@!xlE@lw|Et;XT!Y2MbA*Fvhz_;oK3Er@{`<L*#xHbdJ4gNs-Fn
z9wU2W+cK{jWrQ+#!l5CSZD467YhG$pUGfMw%goV?oV`zkXg*`@l=;0O1xHf|c9PS{
z3N<~kJ5A~xxT{G?c)HlMWfa;4ZO{cEa!@aD2UpzpnKfuQ@^ydNZ0qP-Fh1lS%S(jf
zi$pjy<t%4Gs%%7}X-c9|Ri?H^rRV-pW=sDPe3lbr8Q=!)P0>+gG?NPxnax_{Zbbh*
z;#58~eo&z`QIe}mclx6?O1~5qERXFTBOY%UGMB)Aa4fQO`iGKAXY6z6-#=lQyTKE?
z*~waw$w6L-dI%gSSXexu-Y8Ek4G2JK(D-`{e}h_@4o-Rm<K;~BL={)qI=vR@cwI+I
zQ^zk5yE$-^?0=~)W$D<yh10%tj5k_sJl8RL%naL`Kt`AibC5#nFz-<?k7iSkmo{oU
z>bTcrTRYB78~gJ{c5;<#$4RFcp_RIAQNfHh160!n?K85M%k<12`0Zr8%iVYTCRNO+
zUmJ=aKx;!C5;!)_$!e(YNV>)x5mO6jC8SF(4H$A!mAUoLK=#becVg@!Ae_P^<p$~@
z#M~V%2`Q7aV=1l*ckIA{p|NF@GUBSzHOQmR)V!3`>15vi_O?Z=^GiX<oyr3fZ|0BI
ziBLAKvlE#E6c~iI+7A~u;7ChbQINCZPUYthzxNBmtR}&Gk^jKA0Fjp%$V!YZl40F}
zl~&-1bVzVZh>@tnR;}$O-)}dk!R0QQc_;7v3K37|Fh~GPs25$}sMO=(@~ld$x(^b%
zF%IMznmExmNL_wZDQ*x{K{39`@bBGGlu4tB`URj<uZq{~<CyF>C)tq<bQRCXqlrk8
zNDdEIW+DWzpNU+{7K{1^EtF}LCl*N7{rQ9bCfD*0vvLAjj?6))y;a1Pmad%fhRcm+
z_&9Hj9JV@OF|%xLO`=`}j&xUTv6u=_@rg-PuOL<MZxRq|1w~$Ts1fgH+Dqo8e)rsf
z@J5KoV>=SWWS3YaC$6Xt)^E(|*sEkx{H)h#iI_qMze~<~C6KcmN6YmXRwdz<qws6F
z9N7fU5ps*pOObQeI3}d5r$%7QTK=d0CXUzwK|?8J(5UM{vh--QbT^w%PTdu_zbl&`
zxzz^X=I}O8uDQw8#?y4{(KBBq{^YyMLe)QL-EwWEKI_=?q=bBF8I%s}!xdMU%PsmE
z4%4>^QvT_xtz93S5`wONC-Qb==JI++$!;$zn(!2eEs{{+35J9)Lnb?aPEZwpX&4UZ
z8olL~7|9BKISorZtFJdZ@+;V}u=NZbo+q{vG_xa3LliQxfpldV)K`Z0e&P~Z8>v|t
zD&G|9(P*pxu;kLQcht6W)V{Ii$(L>Aq4{AvGkE$s9mrnbHO$#$Pc1?-*w7oDTW6R*
z)_*G^hEcH#Y@z$aCmVI|iQRM0HdKGm!(`6~i!?+{#GAF8H7-1msAQFyy<CvVcAm58
ztfRWt`+Mj0dLXLf0O`_56MhlF9>&eB1h_r7h+1dRm|H{-zi9%-ycg_}wW0Rd=$U|m
zqyYPaK#%cCyr1sjAZXPewVxX$8eQmvlqobC-9S6@bg4UpGztZtOERhF;86jju|y`?
zUl`~`Rqx094-vpf4yT^QiYC&^y%m}4x<Bdp*>p)ZHrBJb&Yk|vFu#aeV6x3*YRB$y
z_THbruS3me?)>NuLp;jW(+Fv^<5&7a8E|_usmaO+qz=q$WS0IBOrO*@L>chf%ra9;
zq2M`+3^-=r@Y}mi_$(f*IoRlaFFZNgL-o2NfUc<`Iw?`~{TbtR#tWOV7vDq4E(!gU
zNDW)4m*g;z#L!J55(+DE3&j2G+XJexw$ISyQ9ye3?fz&8rAv0aKruXV{!PhN=9|Ox
z#FOd?nOsfDyf@2G5y7mm_%Fz(vM6xJew6rM0g>DHj8yiT@%h{@S`YhGIQ3qYjEhJ0
z1nBRWG8bk6u6XD`RCf<LZ5-b7j|Rg0qmR_c@Fda-iZwhq^vPK}o28$2Ppy$i+qwgZ
zcl(fg6CxV>YYUJ@{F}VrpL`T^S!*aVB4_c4fA@_Zd3v?v^wORRc_ZbVWb*~9_5@nI
zY{wZ6MygZxM64lCAfg>h4fg@X8H$!e=;V#;_C8;)YS;WJ4=D4gi;(k`1FMH%I4{(Z
zACWg07&p`vpo|PXj}oDyw{hM-SE~%h%7EM6PLRl-)JZ+vlemvD@6<N26Xm7uNCb;x
zznQWhQ)R{@neq#3Duad}cXPwzf^%PASZ-V2^34v&Bks$Ip&B698?X9F->8X77RjU?
z6X7sq9ut)jr0D_(LUMTUY-S7zp0^)C$b+=<hT>?HV%@RWm~pG)lPi!1qZH03JcR&%
zf^hA$$C$suOM8&d)xH1i@quXDULJ~Hm#|N@;5XrLy)&@STGFJxQO`lMc8^6Eq@ejV
z!=_@B%K_TDWdR5N3H>T9Xs$3<Rc^)jM1Z%}<H)=y!mjW&{|u%P5E|9rB<pE+W&k@_
z6jAVwf5Ae~rlY}JGvr?9T@$lquwYG$Z1M|C@dvG0gOr}{1u*fl81Pn^MUjlLVEChx
zlgrxJispEk&pk$BOGhnv`egcmv&s;?0r^Nhy1Ui|QX5oBa-}EAUdTVzl^F1I`n)Cw
zbQG`CIYWaZ$<AKLOSdB^yhn4cDu<(~VqXOm{cR5Y4<S#~Tm&OoE%_<QIY-n}m8}(l
zHdiG3bjiQGG^=SdPdg%v&|2o9vHI9zPg-D=l`eTZ*drG~&QmaQ-t%$wh42U9iPZFy
zeZA5lP(I>);<SFB6WrS4(2ih(CV4f4yhQQY$FVj>gNCY&Z?}z`$b3NQhNkYUmL-1P
z-QdWNFW|O20@V+Y{w#q;%_guT<Q+RYwpKGl8s6zWG`%3N*)Qua$jb#IWbpNS#kA02
zHES<z_-==Z2u`St9iUhjBov1=E|Y%uL6G<-yTh0bvv^{cwVpv#U<9rr=sFBXobL@c
zXj8ah?WJAQY^P((WE*rU7%_{rPC|Ov_KQd@fws<@s)16u2FcErOu8zHd~(V!Qa0Ae
z)U4%$4Ij+d29r<p7T;l(29fSWx1Y3PdV{df8F@}uSsz%CCDOhw1G!lNRn=O75M7d>
zQw6^>M=bG~YAG>||H!aLy}8@YF9e;Au?h{;|NWB-$NE8z%7zA07U9u0CxnqeCZs&=
z$1nJewIB;<$>>J?b7;Rl-0^@cr}#e{IAKJ_QX%4WDtzy0^n0I#kRH&uKg8mvwV(z(
zlR=x7eXL__9U1W;^V#Ibxjb{LZ3j-QcRAAqKIytD>!S;6q1Mffcysd}6Ik0s8>#CI
zN6R|emBRYR#XRH;P2>Ta_`xCe@{6;U+^Tz`j9?M|?UxPxSZHjowegQ@f10p+{6Kzl
z8*y@OWwrm#o_b;7-aeda02&MPC|IbVfZuI{?4#TVv$SwwB!Qin)3_=$VNy0!u6$c4
zB3s#jr~XQz^gA2l&4Bk=l`p%`tErH~n!OL$pjWljCcN{KTf-YDA8RXA_eb381EEDh
zx_P0&LFD(VU`^<;84G(?#iDYq!LQ{j-Oo$HPEwA>E-#eBEg?UiIWAot1VoJ`2>=al
zZeLqMsUL17`w5}l=Y*fmFDf$ab0>KXhSRFCe$CvtHQEs*L+G3RVj+l@_JJupwJzDO
z`L%~$mG9jO2Tx)LlgF@*QwY9|q3H@cSR=dtNqn7X09o{tv72uN`Jht`c8P(O|IHnz
zSA!2;f>=%8V^_6S8#IX5iWqvSW6RCn;S(ra;HBw=h<&7?-F+!%g5+v1r*~f6W_0Di
zM)DnquUtC3_{m*rF20NPbYRwb?{a1KPsRi{p&9jShqWmtStFGWALJ}pXRH3ouB(ll
zo%ZCvJa^@}oSU<0f6Z*e<oQXM8RTzg{X>hnj1j~t&5$@3Y3zbun3!dnqC7x7fG0j^
zzvS8C9rIF<Ny|H^cK$n0IOr4$dbL1Jw^d~NkoCYcp4Hr1d&LIXrZAPbaO0QU^tGsP
zx`9BiwX%#kw?Zs86uwMo9$h8)?|$}o>UK0c8n?e)Rrwt6v>tbJOMU3#PHkjiiI?6O
zYIHjQyvuk__uC8QN4u!aemdRIYHZn7+b_dK<HPpO9LVi*^8}#lBpJb@J(YN!fUp36
zwRVfrHhS~SFLP!!GBcI6!frUFK%t@FEpRL9SeKc5rJz$^%|)NO{|((e)cxamnN)(}
zX>Us4UEh;COZOP;kZWaWMYw<95X{Vk!^)n_TrPAJ;@ww*A9K(okdTf-X{4AobwWrr
zIlMQ_IyW5Y9%sP%NIBBsxQ$$CS0XX$qHOFQ&^<p&9J4M<^m4ISg>G$2hsV1wFHH}u
zIwr#TZVR6U{+AYjTmx7v>cq8HN47dy+S!+Qi^&LabtRCI<%uZBEmo*gl6jZZ!SRsq
zA~`p3X)l6Xz#GES6FUJBdxo*o$3c0*|KXUnYU*k6-k(a^H{{dukfDnicMzNjQ+$CA
zbayn1BnTFNIN>fXv6SdoR|g}g@nCFb2NR5-I~=4<#f<o4Dd$V3rT6n4d%m@YNdXlh
zUm8R97VeqHGfS3rY6649$RP(P`Hu4)xDU%JoTNK6RadsV&9hxCrP52O`rShh>t-wr
zjaFh0xOQUxVMCeb<?e5!`<7Pg+k6m9#$lOJmhvd-$e`&!{*~VUjF#wU%*9XoD~A?N
zN+eQK0dJZFQu_AH*;$S`K#til=VKV)cYn`(E?x)PB8g)UG083P8w(l6F`iqRjq{>e
zg>hxT8#e_FHog20l?UjdH|P=U^AdI*nD^QQ%8npN(u|YR)8G6bj6YoZYlwEY&F3z4
z(|yNn)fJf(Jb$-a&@>T2Wr6WprCESNs=tx)R2OFy8{G|RC>sMazrUjAxu{*T;oZDd
zoJ=;(!x1Bo=K^!*cYyNz^;fQ^pHxWn9j#P%=m|3hr`hgahTV*mXd+qZ#bDq4NCj0P
zv&90+%a1AmUXyfS;_*95X9)5wg;Mz11v|}G8lz|ys^A_D`9G}vWl&px^f!toSkPcC
zQi4<5-KBUbP@%Xx#UZ$b;tr+7C0L=wi%W5LYjF+Q;O?CKo_WsP7x#be%yZ_>WG0hW
z$)26>UTb}9O*E*3Y@KoZa!Fv1hnQ{Lx&T20G~9Y!?Sc4kr9H0wah{3U$g1`Jil@4+
zI%Zj$_D@Ajo_{#<{<J?RR;w}0_SU4Tran06ej!-N6dZJ3lTal{s!-A#{Mwq(J`*%I
z{Pk`5$9F&ey!#<MVJo(0OWTL)hi-Fs1*K3x(w5vO7gQ7K&GH}ZqG9>FK8YO=;25J#
z_~!q7=6H*#QPR;1nD~*0Uc2ds-KXz;0E-n$7+R6mbquJUUF?@`TQ-)V8KX;Us&;0!
zk!{-$cN8a>#>p5P2nZsoxMo5V5J}X11XSNFMrw?9QbqF@h9uHor3Ps;C{L~3x+dy;
zrXi2FFV`(gkZS{1(yZQGH^zUrk8nSYNj?^EPp~cuHTMODmG2Bx2F5LniHqOhLoQxq
zNwQ+qd`TYBRkp*kwy{ribiV^6)PE)<9A0rcv_+o`IS4tn4h^v_hZZ{c26({gt=b31
zOF^<~jwG|k&+<`CikaC9LNX(4DDIrkBff-zAM{;Co~}I=_*hUXsB}vmXscsM6Wo-$
zu@cg9?Ht4(lbK92<K`oX%`K8<Tg+pO)bPFshLS+DoGm9-?#U&CPVs}Dtblvg7}LX7
z)s3PF24{S4!k1mH3~av%3>;Nj__<S!|Gi8at9yGC#wRy$S77o;5~J!0(+1p@<9<Xh
zMcXO-k4$Ge7gALM?%Kak^riTJ^K^8v{_k9>*wHsIxjW9)??CermlQ-$+hFdA7!DQA
zB_&od0+eX1xL?`$ouR>KfMd8<tz{q3mP&z!z#@=VKCnF3!rqa=r|PbBqh|Ws0Z9a9
zyx9KadPc?gfj-W+5UEWOop*EI;X~U3=z*RMi!PVGp@l|E5k%K?FV75C(cqvPlq<5K
z{R2QB0#6Sr)-=_YSqhvqPCe6J`vjaojE!II-R~Elxno`I3%3Q{lNk8<d|eC>Tut$>
z5A*6<JLWXKS;2igb(WEx(owpdZWp13pBWYQYG=f7{E`LSvS7fEh+#Q>1VDI=&x}2R
zAZ4LFR*i*X%NHe&E55(8vnTV@kg1O%{?(X;-^pE&f6=yWSa^HS=++$aG<C&WYJ!VR
zWIFpafPPlApJTjGBft<EJSYyIdL`(rHu555n~vb&KT@2$6m>VqOP@Zf83A`owaqh3
z{!gd6{~m_kv$%$m0LO_YvIh|?AQ-&D<P8e%tY@sI_6Mx!4^%w(RXqW=grbaGeTB(0
z*XjZde3C|`oJg2|9i4O$<918%g-qOYDO~eti0r;)P{bCI#aamHA@EJB_!gZ#V%j|y
zt@BVDzqm4rElj3eKi^S9J!YsZooV(G*ER6aYtdE+3C&h#Y`B5+j*^!+l;?k2mT!L_
zUa%}^nA;nny^;KcB~G3EJt>6?p)yE;?3LC}Ng|9g_ZF>;o|v;wt9V|yKZ^*;HdY4O
ze#pnW^YZ}M7WBo5%8XCk%**fWFl6WEqEtqN67#s(xdu=ZX<WMY>JBv77BZK!N8G@Z
z2135AQo6Iur{Fjip5u=dA<$7toUA;t>-REU%XbYYvodO?U3xt+t1?~Nw>03i-~|fU
zGE#7&ocvw+pG1y^iGA_))9dvDfdJNLvZ5IZOneDVO_XIzIj^cR<xd8Ws@j^vc!c-T
zq<vxl=O)B3Pc!qo59qMR^A<GVZXXqG29_487xen?P9ABmBFS3NCT7bOF1-KG>l8{E
zREulK3E&E?05-)Z{_3YrQXB(U>j|{hkz4RKMEccmULKigbtnFE0$j%L+w_>i+L;?T
z%x(jk!2)ABn*v1Per{NudsHe*jWH^ph&y|jTJu;9jcMg<2}wQqYeiXx+q!2G0;y=C
zst-QOMD$cqI&fx{35Fa;HmM6!<=$IdiwHcSNyi}FYxI@4a^>uTNSjhM-_GkP-<gs>
z=wntG)1LcpxBbdhu)L@K2Yu756pqy|O15SMn2=1-Fag@iU*X-m3jucdc6JP|_(Ui>
zVkPXwWGbg_#Jt3JY+CRk#5tE|jjl)F$Kln$*gY45y74C*gK^`vm}TavZ`=pDKGHW|
zTriGM+ilhFw@gOpH2}9;?IgN^ZQ*}jp*Q(PfOlfQ?&Kt|7XkNB$s~0<rugJp4k40L
zJyni-(B06(xK47TzNrJh>yvTmF2hD}|G!GgRlNH%FUT%YTNGj7N&DKiAa&*0Q@mvM
zicCOO-!POQpm~w%z@Qi%$m??}plyV@Z)>g3-vVx1pSLgUq3G_qVNLhS|2GO2o63%t
z0Jt*YC;Y-X)(r$C-in8cpIN|`69p!i{*JrS`?_lSTm2#KB}ZD`^E~*-InB07DxQ?c
zGQ6AEdxH(bhK$(6P!8&gGdcL|ex1V5i6mNsTu!MgCe}cDRFX!uBX$+liF~pdS^BhN
zo=9z92NX+CqH7tHA*WX*=gQieo<!y^qS}A%ytH|FGv|<s@$t9IiwYd6a^s!>ha}%E
zUvCF_;%e`A$5L`Q1Vn6^;fivC+(DBgOP%*s0uIVH5wtXG>&Kq=1t*c{(1!8WTL|>x
zVme^aO0j}==SRmD3gt{urB<aEe*%)BtTCMgg!dcw_ve(J^$t5b+k08Lp!|q5LtH$s
z!wt=+S((l$OWMPWRr9A_c4<H3E~jdO)K%3;F_@A-_+C-w^$Aa4D5ki8L<24T@3!zt
z?diEet#`;Ob;hjyvlcOzyb$ZAXziGenrXty)ezgzorZ##PepPfP#MUI-N<rt1nt93
zLN&!vN5cb^L%Vl)kgwq@wyMZ)GI!3pdau{GbMo5G(4J0n?R6J9@(>rVhN?f5=Pwtw
z2-4fzRYL#&I?v(C#^ej9OT3*mqz@v%PVI5hT!Q1Qc^ZY1KFE2Ke83)GQGj~lRHyrd
zk}zW&Yzs$3#805fPd9yBTMb-2wh%V84GvQO>jJx4Xgp4erC=>S=^x1_z>1--!;vC2
zsBeq;SQc`F^jO$!Ft8Q*iNT6jvN_GV?^IA*6Ms7PVtof)luAexTef*u_h3^-z*tF;
zE?J$P$qAWxk_V_Q@4vhA*#p|5zH}r|;rn*=`5NQMxI)$1cz)7y-)zF}eXF0+*mwy0
z8lr*qy@>YldeDskCr>Efvax)!6LMUHeIUgik~AR*-+Cx#HcYZxy5$Sr3d7hoq=a&a
zl{s%Gam`H7g>k~$7pLX3(aHI#{8+z9l(cMM_ZH|HM$<u{c}C8sk~R_wS9^0af+@6R
zblc_dyVI*VeWTu^+|+lcW9EkixfWJFV419+UDE>_d()1E?p7{3Gok>7_TO>l!Dcvm
zco^j|sQDnP5)FmBSFY$t31Px3eR0~@pQh$LI}Y64twB7J(&S5!5!<VqyDWlyBYU@w
z_vE8wM~b4=J$H?w%iN7<GyTZW+1?wU1*4gt)X=$zNj}3Pi#XAFJ_%9y{N6=JcW`Ym
zU|fh$Q&=ySO{cjv=+NcZg^J5Fw#e9Mq50+2kt7*HltGfFa%9UA5}AZ_N=9c>^QY+;
zj~`)nw<GKsIKQ|Nc+dUFi+q9n7;~XIBxij)>DDN%7{ILD6+8}ZCU5-R`UqO?yHFp&
zhn!X=jAMv9BxLlGEiy_Y5Mus%PP5rG_1W~at@{lqDiF?9qchkAeqA|w`C(!5#o~0m
zuq0~Zmkz4kj%TGipj}P(wk0FRb|aH)i?NNZ_0lQ6Fum)yZ>Olm$fs#D$)nUzyfqQb
zT01kcNNHyTJ>5R{4El3WAT9l~GqOVA>HH$XQ#AB46O7Dj|9>i8Ycv1pM+0Oo5>={h
zTuibeK!go_0K>c8_|J{oWPZO1wrPOraav4e>0JQkDn=S+hq9#HK7^kVXKwfYz_7<-
z|8ps)-RZ4#=Qr!v7;E`wH6qecYcrhr0wP3PHkNKL@@(+~=f_-(w&jiW(|G7cBTS|G
zUY-oc;NN@=3h5mPO(z#q8WhPTJT-eEbF=8_>v<MY=5<1!2^+ugrLHpv7CF2qItNF$
zAWMq8COIK+19tdq33_M&^=}$l-q)>YGHT-5pS7_Zq#S>zNm!_@f<*?9YcbW!VCN%e
zkVrz$qlD<tI-kIkHJY_Fljg73J`40+6ngc^{ap}`1WFVgCJHdan#L2j-bIM@+;eT}
z<TBQvnv@XS=+H><GAElIZ%&O(r%)DhKKCoqrRD&1T5e3<=Xn;A>sg)!Fl`S!17s#D
z1CeTuhj=O7p!0l#;czvh>ka>_#0Wr0>pqky=rEGw40!o>_T=KIy>r_bU2z;j5~Fr~
zoxIp6=OR9m8gFceSIGA&vsjOy_d&h&{-0V|`O%tHMO=mrTGD((qpLk-u4Gn!*E0_@
zs$h+{vE!Ezhu=NP<83{+x7?n{04;@Q|EtEKz-GX$;a1ye6spE;#T-8eb$|hP#Cbn>
z-(Qicya5q2y=5Y*<t%?s{jD5*^Gd9QU30e~P>+aJAZX`emK29hFjGNry;A`uV5aqN
z&i9=n+jwy9Na&^cSSeG5r+5Xx=3{!~i6owxr!-7O>-NMDW6A!{I}M$x2Wp%5Vz%(!
zKdBcEq_zWtJNT1Y*k@k(kuL)r6gQ0x#zMiLKp!EJgKk(QFW5tg4373XaH3r+V)VG_
zr3rCO1H%NgFC+$JM)PW&Q_!6WP*@xmuBfC_<7Z$f%PSSGaN^A4PUX4LgOszzxYy0m
zzx(x8c4j*lJrI<AraO4|8*w0FgN#>M2fGTf6SOwA$wjkt=Q^DE9gjnoSc}u<%9W$!
zx*8d^>@MlgUAzPQQ(wtPe5J(`S$3({pL=3XFmH~>T5PHDGro)e2;YnA-cl5O-m?@!
z;eSZ;vlQgeZqGVnE9lx4OgCk6QPut;^W4lc`bsPg%d=AU>D=+p-@xfb_V4TePXx}I
z$A6<0D-#c8_%P8Xbw#o>njBS-DhHJ;w@J+9H5y506;Mw3{Tc7mC>@C=14UdHIT777
zA&XI-s(iBfw#?^#W}lJSuUH2hJOrHoQgej?4(($N#IA@Bke{5X>`;U7Mfdj6)Y=Q&
zpIiJxH|SmC(D>z5IiH|Kmwb<zpDv#I@YS=9lX+N9`ljf;1Eg5dVo`kVrtvKxL*L8K
zh!w!~66!kq2LLbT6Uy#*@T2#>6LJV>h<+oUz)vgP&QWZkX^Yl5*pg<V+ZFQd*)}#L
zqE)g*Tv5Er(cH#@)Fj}9WD!JN`#CvMW8B<oi<#_NP=XSVVPgmHEz9z@_;W#f%6(^t
zwah2~=mRLJ)s>+6S&aAfB!9|wawJF+-iZygZGQE4xP<Jgs^NDqxu&tXjZ6f?GLb<A
zZ+5zMVunFa2xwS0O^t#0ykm!nbtWHiJ|><Ma6&<qd8Z=civj1U(6Af&*>U&tzlPm@
zFn7Q4IZQg;sXinn;%$-%vm@OuD_GyLnQeHjr`rqAUqqj6g*FJaJ)g4srqly}F3_C9
z=)N-}yC@2vW&j*)(7k>vV1%Z^o%ec$!GG~u`@G&(7;7_~i5`qOWs7K(xY)foQRR7`
zCr)3AtKGikKt{QO$Co~vikRQpVz40DQSZjdWZY@h5I3tq`#TqftV+0Rvvqm#&=1_T
z?Xnkr)q+!Y4Ivmy)9U(X0}`F9$QumR2=L8iu34=)Lj8nX{3^!{fT}BQEa2h|r9|$*
zhG{`8+TD$yrBtpWgj$M5fEEhH02ztIY?P>XWQjHMduY-05q%<wa107HB?H-e?e5O`
z#1#|(p<($dB-TbZqWGE#va>ra1CH9UZgApSlv<z&aQB>E2JHi1k4+aOaa~#TO$erR
z1kznw1PC9-i1KQ0z6U@>H^L-#!%ByD@KI5hi;9v@6`$`r?>qve1O8aIbQjlfi{JVw
ze(-_5VXf^Z=2VyN`Dc6Q>KnC+q~O+haJzkQQADV?@h+76L1z9qn4i_)pGpXNtP?DJ
zJF!{2qmG#F->D;By0=6N^djGKzIwaF&1kS!FlJN3qGz~HcQ5cEtx$S6W?#nDT5d1b
zn#cZ0>rS18ZF{(V9B26Als0Yq?f-;It%-BE&;!oV#bskk_<t8jh9`r5_u=}i@w9I;
z8>DpB<fFKd-*u_f9bjkI7Ic{ReM8;ZT6f?_hn<a&?JtA+%#{adNwf{K{J!Yq(f35D
z8scM1wsgJo-ornL=_O*qrp{2IS4iD`n?>03ide&WFD&(G$zN`FyG=v<wZv9f-Y%cp
z{swGmCq^C^gemFh{(4ZDI?KRcbgm@j9mnQdF3Wd$2>0yVa{guOVZ~aGmrxw3s~75R
z6vgtKa;hL&2Jzk#z4%`7tl+jwXM^-$_xj&m_Ymt*c0!J<-z#882@zT&=LibT31jD8
z`vcJz(P_BUwGt?f>b=p#jui+lmXLn}SlBsZVBjh1#Vps_66;P?E;BwFQtjE>R+BMF
zo3;ZH6P#Hw7l#UcuR5sPYc!Pq{W^6UP38vBsvJQ?NP8X8O^<QC$2hXFJyX36hyeR8
zGyki50TTH7j-__ObLt_4+nKLRCKynhX=PwGCa7lG%rT)BGCeXy|I1J=q<@~-Y@!IP
zA%Y<DYK*L-71%5s7UVjdD4UMrG%2+ANB3y62+(OZd@J<F@?$VZ9_q~M<fn0~Go#L|
z-aG8$-5N;k_hRoNN8zfg!bk>c<KC~xx>*^EiF{DrAl-W}QtVqFN~wWKv%2sQ2hg7n
z68vh;sdUfo2&B=*X=slKuKA@#g0-dzzxXGu$hkX`-;7>S!7fA5u~AEEVj8IiWs|SO
zJsc`OqS8pf$$zPP2H6LnFAS3w8SFwpQ!kfPyg6AM{=qfooV6oEfW-VC#XywTyPSvF
zk<)VXA?btM`Zxc!u-@!<fA#ZCms5%lK^Kq&u0(k64T)2CEM?O{9Cj{oWOsze$zh(?
zy9(4%3>wP)H;T;+r|G>bBADHiC;aGJ^<^QNzzlC^@}dI7et`6}tH(PZbY*2sI0*M&
z>d{BpiaSUduPSJ(Wm@IU4Y8NVM5S=j`o89$=n;pG%aXAj3Loh^L^1wcGiP_MC0)Ek
zj|~Z`ofNZBOa%X}ruyJtzphY{t}JAPQmXn5KYgUKl7%1@`6CBg{KFv|0=fP)7Y@(w
z(uIE>?ExBfeiR{BwS$L0wnO}BH*lwKq_?`eNI*dp;E8=6%NMpo5A%yOD~e&{AX}7k
zL&`n(DA-VH=I?cUIC$da3S$m*ZTcHJylxfxPUv{~yI+@EKtuY}-2Yq)gO7C9rT`OP
z)Ty$lNk%-k`%UZ@ZOfWg!owY<=dqmogBGjjb1Ttu`h$0Yd=84Nd#XcNaECI+nSrNf
zsP!SK#(q<POJo7i%qB>%(~hf{==CwZ@Dt|E`-z>MVQr_YA+=Y*@Ef#g0Q@Dwb35)D
z)5Q|iACg*<9XIuoXN-y)5f8o8+N*j$X!UN?>MhUKWa+nHC2H`iDexgnM@{mHYG9nj
zFX;nB+k1du-GR#sJrn?Jf7I)5><hRxx17}aUsvUAk69rD;0k!r{LKxPHai|{q8-%V
z+i9#pdE9I7t7%<jD}<9YMcwWWS?F}hlIk8!7nEFDRVFuX$drZg!8EX<TwxS<%0_L1
zj@3ugoA;;GB;|<TeGS}MYK<W%O2mNGI(LDJl$Rwe%8vHCg(EcjW9vP8#L{CXZ~{yY
z61_!>99OJ5mq(jeq4`&8C+_#H%8MCre(f67TMMcVV|BW>OpzrvnlPSHbwEB~!HuTE
zt2oi+$h+EvK|b|K!!8}V-?#@5B*uu<wkX~W4)-)VUj73FpxqyHoQ6DUE0(_R_nwgS
zrI)L%4w%;`3>!?CU50KZPN?j1r~J<Q*3oiTGE2q=u<#teqkD(?LyX+g_kw~DbU~9x
zC))XPc2QEvh$7=S#f5+f7Fdt@vxXr4U;s5WUV>-hD(gD@Rio-|nFSdpJb_qIhq?d;
zi)>99RpPxnfozaET@PazU8(7sAmDqFm97qxaeC~9ntuKs63i<xde77HkvAcjZ(PE|
z6)ItU!DtgK960VuiP(3UH8L6UoPC|HcXnD{F}kY`dAiN~D!YSVlPlkTTvUG07QDA9
zc^fPT-gy1yGypq}IyzG*LucYV>^0;{YmFKY`fIm5_}61e#8osu708DAjk|U`!_hm@
zsgwj}jatLH#~+uO8d@W%fyK!w$RZiuQTYGF3wP9Mue}27-a%nxp?Z)6E50>DL?&kW
z9N`Ut>Fk`TV_h4{Ut`iYyLghZc=tw*?5y&63N8AYZ`BZPznz9vwFT|AGm(pBOXwGJ
z($g=WpVDk-C`Ki)d5IiSKz`hnjq)+_oO!m7?j)P8RI33{y9<)TyqM(bgnj$1_bX7M
z+ixPYQfLz!n@ca5W>6v*`#)kA^$*$8E)BaRjP4B4(*m6~^P1nsYddWOUUL|4|CP>R
zj7;?CK*-*#7tmNw8apFxk3<Ze1F0Ziib}Fc#d;=t!6Jq>;exe7fU^p;33*rU%}f-!
z&CtU96NR45z74h~l%0;E0n?&oJ!cdXi1KEL<^=^|?oAvO`DGOt$u;~6aS)FAlg)p+
z^;efojkZHBVwmW@n(|O4_?gjmz8UTP(yF2}t80hz$7tw?CZnd#-NP&DKYbU_(2oG$
zGT+w2;)_?}lGJ@85z|?UomK#)jW>-=+RAyd9V*QWl~Kx&!r!hMldVKuaT5F84STk?
z5dj(}8dqi-sw?8|`I^98M6|-;w=9~K4}*mg8Y`VH;aOxCN5<)5zY-*VHkhDPmW%e6
z0e*%;9h)Ef^8x3jU&ZEclhII4uiQ6BSI#_5V=ct#G3M*ZlnMpl#wok6Ua#jCgynP)
zV%g{KjAvDwFg8%5mUfs+6W~vcID6dAFIJbqf8?}}!*9sAn+N;??#D8J34;{8unE*^
zyf8DQOHFTDKlg8J02~Qz$dbHXNG(WTsYnl(QZ~(^rlUW%#S6~js%$2Y0UG)hsZRrf
z5&t8XGpiRIgAR||Q9x_JUNH|GvfxJCBt9gn&_u_TI9Jk064c0U$q`AwBt16FZw1xL
zE|26?5HSRY;933k6<nC`bW$OK_54s4Wdn}lRWD`6J3Pp;$oIt4i6!-{FjO#_?7-l~
z7vZOLy{epRVoTv&d}*-)##im?6X{PAdEEj=gj;qQl6}vPb(eCiY)E~#b#8<vI`5?t
z`(O9GUtD4hDhFH!R{E}+D@x2c!x=^9=0)<UdTg-jrfa%m`(<b<xx&#V(0}mUqYQ`S
z#uyp@F&>S~|G6PD0w6Zn>)t5p?|V{K<Yd#I2qJphAXW^`)Eez)I@Jv=A(h%^bK@f5
z)UxD|enX7!1*9rt+@@ddSau&@oRfrpl_r%S&NnOmC|{f+|0A(?%!%ygJ+()(Dy=<h
zfM^)Ug&J_TfrHz}jAd+;ue-_T^I8CHTwTD|o~9dk-0Qdi<dIQf!%*sJH623?+g~{u
zYi9A?lux=(@?=fFo5d7smYW_|8dt0lY(U#F1q2i4e!fAo$Xa;BPK<1~(rV653||fY
zj|0z|810Y{Y-}Q0ag4p#v)p0iXPyqdPySi|Rveq_sgyfKn;p?`{hL;Qx<8TabeLgy
zLNr8-mi(6z_HKW>1-$|xE1nk<C;U)sm*<7KQryrDaE=`m#Pl#$jMKDJNq;8ZxOd`o
z!-qUu*p`jZ|8`>=x3wCr0LLAS=x4cEYt*uqbIRMyd3(C;HYi0JG<+gxpd_7<^-~}A
zPhN~z3dh*5BxF{TOL9YYT%qtG54=Qel>V3@(X`vVNPj$0;<`<P2C=CY6`Sj(KId~x
zVR5EKhjxOwm~hUg?Zy^mBMz4T4zn-HtT6J+Sxh*5uqOCaFoqyb?9tWGtFUq9jMyMD
z((B7F{aT#~h+W?w=TGV_Ddwz-pZV~^MwqA@;o@RK?!os@<jU(8XVXv_!p(gUcRopc
zNPNmpRj<m>WWB@dQ-{JS<4)!`T9NV0^&9i;qW)$l8qk>qkk1Xo<1y1MzD0OOaa{)g
zX#IOzj1PB&VvF|pg~wmyS`DD@V=1KEgar$(`J<RGGV}Q~!ky}Hzl{jwqg)VKe4l0j
z?VenNB{`q=eZA!G`N7D74{{j3G2l5%K8TokTbgpJKwU}hRsmk*nfzs6XX0ol(l@U2
zLy|@B8lw2`n?ZaCcRbCfL$@0ubxgi1I;`B%nA3m2p}Xy`mjsB`FZCfieo+UY1m%pX
zw*G#~4$)nEzSwUG-N#e?{0|ZM(RUt#sO;)^&426(x@#ri@o8qGeTlMyf`gJ!-UYLI
zKc{-c7oLPH#wn-4lj@vdv8g;VE?}STcu~9>#HN|z0BhLPMand=uL9I}!)#@q>&!{Y
zX03;HP-RHyO<*lAqkZTm`1gYO)#z3=#Ug?`p;$Hbpe>6La&B$d?>*9o;QwUGDY=%D
zg)~BJiY)k!b@$m=Ny?Oz)^>Zgm>s%c1r^<EKm&vlJ`7EgZ_&vbXBzr5Q{>>&d*nVO
z17ZY6^_G8qglslvJy*oAym>!uog|P|m7_YZ|0}06m{*3=0C+i;ADB%6lb(5039`^_
zSE!yu$|hg54xf#QYU+Z``RQj9WD_rvJ$}s!j1!!|6P0R5AL9&<sLNX1vZlzB>^)o9
z4>*z7nz}7H(PZ7oA%o3sQL6dks-bUspZVA|7SN1WW9>r>b2m-X(k7jM@;!9ke452G
z9%tD0SQ$mfekq^U+MkZTHFpZd8vj_G>s0XR+#uaK$2nVnTC|T@D9Jv&I_uQG&Rpy!
z;wzq}dBJKgGNV?<Xqant@KUYfk6X|CNF_arSudKHT15W5?vRp9qGNT|lQB8rmtcLz
zzK(jWsYExCBT$ja0RPqq9f6(Z0dgp6_|MRQ-X7aQU*045>``e}s3kD%pf7B;vij5q
znHzGJGOPEOkY`-oJ*g`dNncsac(CjpkmyExAfjs0`awiqOiwvWJAjChqGt6X8j1XY
zTC*Oa6hz<mh;~=Coup#Cd2iWX*Oe}@MH6!{vUU$4fAf!p<Fji3!D(ytkvbFEd=!@W
zm@R})9LY0Uqlb9dK>-T`PO}r1X>tvhJs0+p^3FE~cj^%s0=E)ML1_=v?ava=3AcP1
z-Fsh;R*|<nRz0CC{2#C`{>~qnJvhg&RA#9*y{5MCV+>GfTK(ep%q}J_hUBap`CjKx
zZO-P4fBl@N=a&9ZZQN}@^kbD_X`Es_Lg9hgJ_ymh&obmOwHp$BLppv2K58%e5Kt1t
z+24b(I|+P!h}^o({}1H<-_Fke&s)b`aYq<ng77=-3$Hw8TMoj@vds5)D_S(KDPw+b
zT<8AP_puJJO#+qt!k07l3u{_|CzV%j_pd|uulKzvl8Hymf+sI4Q0fipO%)}?mx!ic
zeUAwzyk(Ma6G7eq7BX#UHCGLc(&vNM*X=-e0q%&7nbsd7keqUtSXY-arTd6W+8Z+~
zNBHo-_ihvAgkXdHTu*6GJK>R)WD||SOBvAK{AazBxnAo^ntky(Ufu2pCI7_9qZ0J<
zw_osXP-4Nbfr_Y~DD|z7*4i!lgmfDehmj<~%-Zhr*eG;-OU*BrCv>ex5UqmDzwV>u
zl~)2LJUfR-E}xRA_`Ay;8Fk?e|BvKxxN)9=ATZoI7gom;{gz2ZG$Ujv<K;799oNJ`
z^Y$ghFdo;6X;hoC`0abLGp$s0+WM0JnK2Q!xJWT=l)F1-krJUl&t*nffQPtX_<OTA
z({kcDE{wW7@Dw(S2StJ~|6vSQW76S8=aku9njW(J#*<{d&~E?ED>uU4ax~9N309r<
zc4I2;!NMP}q7q&I)8AH2C%w5|Z|jf=wf^Vx$>pu0XG7GdFe080wJn#Y43q1ZbZOY8
z=JcO;nGm=>*EBgiyhS2odNvtWuVBBPte<~FTbF4IYq+rz0jjK8qE#2>#vcTD<1lF<
zV{_kXCZ2d>E0RXZ6%YACzG5r=O_H+BQ_^)z1ihn!$huggo!Ft7e=y#b8wxq$eK4;3
zY~CC@O8)WL8S}M7b7iPIW_m&)3_b9TW=6$iZ$6|LFA0a|9`a^=L-3CjTE+$BEUALN
zW?J@}V?>Wt|IV}iTU+cTOQOLhy8KY;R)3%UwPBsfJViju9yZ05-J@~(!r!Xj@06Qt
z#V6H_HEOV7v__V9%G6(=e1ya#P&^_9qD3UrGZtC;U|Qf$rtxLeB6`E%4l7KFMS`zt
zWDKrDZc?LskcP?+bipcsb)0|V@&O1m%wIXb-fRZ`8g{dLhT};)qdWeo<STYN9|Mqq
zI`mBlj?6G)EGtq^wu9Kh#EC_4ie7e}^%uUb^3eQ?Xv|mGk~;_d)T85eC_hRbGYjYv
z!ve^(Eh;bf<w96Nce!K-tqa>_RyOQrz*#`Xhb9$Z4+c+Q^WJL#&NxEDeG)Q*hJqzA
z95|M^cfNA2unOs?DF_}ab$wuAQeO**Yu+TBtxQInKy%1a(oAn#>9%j384v3P<l`7$
zsoD*i2Ft=k&i$<?S#cvfnukbsPg?gx(t|Vz+b=?QT<h(=mM;IK{y`o)K7Kj;5{A84
zsa+JTpK_q{J>2m7pd1m&(Xqdff<z~6@FgTGk7I}uefv<EI1{&P*hWbDv-)G?B8&yK
zNB~&);($6KMxOocs8-UWa10u7=LLOC{2edg!0RgUp(2!dQG^iLoLUuwzw3fp6nI(i
zhI$H>;aXcz2KSU;ACF>XGSkcDi)0zPS6L*5S9CpHit)CMy8j-!WNy%VCD!j5dyM;1
zd@=0c^4OPX>!QQih!A_CN)l82SxJqtsX^-p1-Aa?F?+4#gM7{qPtiSjcGb~;1pAU~
zc|C4B-p^99Ympil^KBZ-LcyBK+!5mAspr7lhhuSRS3eTszafBe;&_2IpYFEYneXBt
z`jb}fSs%yzYFW-f;T~0^==U=0bF1(+hlug~z=7%kw^L*(gyoL(!@lN{CSB**%Z`ww
z<^$4W1MWMtKs-Qin|(h;b!V{t9{VMY4FSwpv|Rw<J=PeQjdBh+1~H53s#nZTttJM3
zp5dX)(%SKWJ6ws(r9@&$WvDd1vVO93ih2mC%0xFB*~xQ=_j$0T3VGfPg}ab4UxrCR
zdSs0#bpqoK9KHuLn3)GhSc%z5HwUyB%5%=*80Q-8?yyVB`8ZY4Zm+Ms+zV=glvS3K
zjq6-y8lOrI{`yTvv2>Vr2Vx0PA@)x36zpkBF`ORp?X=hk<e!kk!hn_~Wvk~nZ(ZOo
zX0y8$<q)U3(iKaZ#EEL0^f!Vr<sD>vj9NxJD;z36>0M6hf&=#?TzMm0yz&)mdXRuc
z*I+S@P>iAjDuBB-O<@92#ukj{a-R7!<W=_>gN~`@S9A#CLtrRl83%-dIb=ipW4)ZD
z$)(9xp8!k$Sc}^BW8n+?32<&w4oiE5(XU&N=w|vBaZ9B)IStiXD0$WeQ)ggeS*mvP
z?1q>@X9a%RYxfQ!WH%gA2HnyZTyQ=;G5m2@XL+i2d8N1Nor8xxNE&t#d>~Va-fwK8
zX;6V?B;Fc%?4SLRc;Lg{(W%k8LV05ul#EV>%Ogscxnq;p=Z8_6T@AK4rVn_zClgNM
zA7A}UctNJ%H=IVvBxlFJZWNiZ+IdHJDeApK3zE%k4J7#Gmd}G4_c$~8ES`ao{VV}#
zIc8FpK{i(g^;fMc0|41l10Hfn!DHxrWu_02O?y1LM7<c`^=)0N$&YFi#^Jr;Z$4}D
zTVUV${%E=`WbEdstw_1w*EU0g*R5Au58iw5V8fKzC9+Bhn+aOxVMk7uBa!sGVLlZZ
zKDw)Qj^q&;xx-KCSEN!i+5YvrJEpyIPjk&dn*jlGx0-(gep4q0q6*sox392O2G{U4
zz!xwQ-~LlD_Z=-8b>?uL$eio}T}~%1N9Y_Mtv*=Uq2K1ndIfrRL<N{os`WhA#$bMQ
zcxn3*wOu&--|=GJo49*k#?1n3cWRkfXC;i&s#V-iLGk-OyQSInbs^c0dAxlI)m)dF
z5_z3R-F^!i6Nq_HeXupQ#L`<Ej<(KlvwK`w!n(!*lsm(u@HV3!)l(R<{D;e_v(8f%
z4wIVb5;0tmzD3S1`U5o@Z4ZSRI;HdDgr4#Dqfb=GqCNI-jf`llcdEa_kov5|W5Q6A
z+bb8wV|$AcheqmeCK?u&DG=$Mv3n#V?-WE>>hF_LAW^n#)C9gjX)Hy!6!#Rw*P^h9
zb8-c<GI!o%9O3U+i`yKu<+%$iQ)XjuS-A6Y24pF)%IaD%#xYPAdhPY-FneF2++JaU
zXaN1&-O!9yh%J#uFHvU7Sv<<+iGl6%sw|xd*Mp9J*6}Zn<&@p&%TANFW5EtFgv)M~
zLW`wImMJqZY$hM)do#}X3s>G8X&X54bwvu}M3WvJOnv}1;SzG3o#pJ*)wLe>jCrS9
zH=_tIrPx_^XoG!=L{|&45W2=#HC2j3@!HfXq~mowcPdk+LvgJuKp&tda<;7ms_-Qi
z>+&3@dG1;@ewMQrpNn(?$6}AEO22AsVybe<tym5X!FhK5Ig|-|qY=L(6SP7%q5jtV
z$}Z`E_)P9!zS?g{C=-Tk+-Sc#z-J1B$nmO6BZR26b%6O8!MwJ~NN2LZvvK3~d=tlm
zHnp;$T)+lhHn+`iRd}@$-x)TC_U#rYAryxXlb}%*PRN3+(y}PX!JU{PicG&iupvRg
zszB^pECA_RjQ?jA5lqo-Sy0#729Xm*Ms>Uw=4WQe0$IoF4ly+CExxy_W2;d>TcrP4
zD7K6yQ4jO+w=DWHMLIP@o?fF-Px`MvChRfH-H;f5VDH1pq_P7^{2^cLr~RNdwY0j=
zT>}7uApY2%Y_XhS<2OE~81_TnmyMx@w=NIje1L%0Qg;}HV;Ha$Upee~%{38zE;=S8
z=J*Z3%+1yLc@sggcyqHynI~fd+W}UmNj;Y^uTv^=F)&AJfV6XnR?&MI@EZBCYe*rW
zcTg8AxvHWi8#1!;9F_t5n+%a-`};0MLhl*(2DD!|I-s};KsyCy5w#5&3!t%+hzmR5
zq87-s0=vy|y+9W&9Q{FBD-3Zfe_Q;(3xZVzp84_ygyfDySaw?Flvt+|eRg^_7k;=Y
z3J;qN%f}bxHQ1DskR<Qe;5_35r#$(<La4j$N3w8aTZrlJn~w{`6bdArFQ-_KzE;(#
zN5<8JjoiEBbnsT%FEfL1tIEW@WlO|(jGB6zs@?!<7g=1KJDdX=TV~vH(JkB9=yI98
z6|ij}g?{!%WoHkYvpQ6kt@wcR`Ps?_5L_>6&g6t>1Xty5@GQVQBSfmlaVpJ9t^#wv
zlF0j@UQG7&EfrPS4#pt+zF%G8L!rRG%~uo+GHVxfZ-~Bxyz0SR=oi)%Cs9AN5XHNj
zXLc8k0f63Ju(y6Mvr1fLvv`7cr_1VUY9=Kx%khEFeqoi3(j{3gU{v~UxbTQFEeckO
zI+F-ne25{labR^Kid`zFOGS9dVMSEyxN8H>?Z#&tq<Q*0U9RuL(I00B>Vsrr86X<~
zQ83ufoh(8+I4Huf*vIi}CzMmyqC?j+dy9Qm5pA!W@9hkVc=EMRdAO#tMmRQ#x-fMI
z6CcE*%cayL!0H-<zl1WL8;fB5-FJg2COMi#Z2glod-x)UJ@q+TfBb{V>}KHF=}cwy
zMj$d*8DM+4x|C%WW+({4J@#MXFgs|t6J1*ydck99@h5nsdfA!3veFFvi`^ZTHA1qH
zDE*r+GZMcr*<LI2SSpvw#WdYDm%p(sN3JOzeWG>s)Ga%=Vl%h|PaVuJb=?jAMfI|9
zm=XOMR`j5UVTaZwEzb8o>n;_pw1ZsND4P}*^q8K_`ad?ADghhB_2m0J5Hz@^Q9Bl;
z_$2v(2zAP6uN+U?CPt-N>rrdBpL4ycL2i)`VV9g!*@!R^r+}7Ns~nT)gwIVfhK(>X
z|C|~m?#_$)&jSP{lx-$yg(2rSbD)hcWFY(#f4mya0}CmuGgc7;EQO_Yx>2Rz2Rksv
z%4$k|+Ts`*EXAwh&F<y{vw_KA8R_~wtF=rHOV6mBrU%+YD=n*+VP8OF?oQjJ*ILu+
zPR9>2WyxUxy`Su_|6kP#4Ul2JDEo_mBJ=1CmTBe1ha95J7)gPRE@i}aYNv@n2T@5~
z!=i*fu>X=4*3!2qq`K{LZN~Yxq0{;<hPo?uHCic$%|#57`P)$tN1}%#VQ0W~s5*iB
zl1D%WeQi#oXKdS)oa26dIkxqM-2NN=S71a90|l-_1qGf=j)aA=ZFp_M_}@k8$WC7l
zUkQW1nuvmaa%1YYUH2&=Rpa>Pn+}82GoAmOXS0SM{*xXfe{|G=;9+mq@#M&<<NZT(
zjcOZ_UN=+X(qVgxgh{bYypx8Ea8F6VLCnO3^C9{O(Y9fFN$0!a_4#Qo4Rj-gunHbW
zG#)Uy$>#}magQ@@<^m_CMXFG`scUPl1ZbYq`R90OaD}Z0iXc?S8}olhmKAOKFT@Uw
zEwoe|x?R*VIa~~VDrlL^1ek9OZN;a7r-o@m>0svDrGjn-7|(FhqhgRPdWAuLXn+M5
zK}N}ePAqrAUcLmlQE5E5*o>Qq#xb%WIn}Ajm6k+6T2z8d%Q%DXE$a1AmM*6T*!+@N
z=Q~9>&l~yBkQ)ZRb^`%OMhk{-D~65*bpL|bK`D4`C=h3{6gppo$VroG;sp49;)~7{
z*<JZ(OB_q8Z2q}KOhZ$nUq00&D<~jM|GZnS@y9V|To-sa94@=;1{N}2BJoc7QPj&P
zq{1p8sLbM1PvuIu9*O=LjsdT!M1|0iG3pvyOJ_NX_hjC%PCT#uW09%Qr~y$g-d1Iv
z{K0W1G@Q!wGbZ%8LBKGvXSgX1^@=$Z;Pv;X|BnTQoc_r#2)bp8{8A)Fb`ZJ~nzYYn
zbpsnbSqU5h9H#Xmuq6X=<huyW6z42(<O-HJ#?Sg)Is^7JjXAW~i?|;_IOHdy1E_d}
zrkszCB0!4I<Dt3ahi>68>;P$;BB9snH0arxI8(`qHq`VJ6z=(I#m8MW{6C>7LJ%O^
z=dT87@m13TG_UeDXT|1<)J;{tzwi=m%067pqsYs{G1so89S`*C5O+vHHlE%6uQG_I
zNjy<_R@|CMNVK;<W%gUvX2Un`7*~@vn4%TK#7;BXGX;F=^Gg4tI2y?(x3K(BgKpg$
zQHNR{RI*v_`*AYrx727zl2g2ikITv+Z!f`U@1cYy#T<F)=?bZ`@-VQHacpoSkP~J)
z&nZ&i6je|v8WEj*{+pMcfJHp?6V=vtpd{|`HvEqbY#hMk#KPg}cm@djjmxiBZ&HRV
z*2lKX>ixPJ0M6hW@?d)n$UuKLXI!_dYgB-+pLDU?PNx5o2-L8nM+srUMp>8xn;jXz
z#6izFW#xgMQPt1wz@F}&P`#knp%?_Cx|LbdeSDO{@G*GuMI3yVEE@}NMvq&)7%Px~
zkNTJ-D~h{_w-YJHK4~MZ5AlCr@S#oggr7bK<g~2_Dfjz^`wvRONw#<EC`OU<93a)%
zDVgMiX=FS;MJdf@o~`Bz!0-|MXP^{!U{XCI_bhbny_(Z`kI%`l;GzYoWWL<vUW!0d
z8;Li<XQKeGF*Tz}bbx&%7{XRhyZL<rWpsa!#k|$59blc=cUGv!G{Ok}_x0{;UDk_%
z5A`*bCe8%1XDhOFRlJ?I>37yaz1`BPsdU=uR%{m$^55}Y*cn{tmox7$GT5PSR*hNK
zRtf_#;6)FuXT%`=DLbjBR#^C)C5wf>_O9ZL=I9)a8nx}OhvTsxY!z34R#AtyXmbAx
zn^RWad$!Ye>_Z<6zgvyYC0VWxDM#FW$KT&DO(C(tP4av0%CEuMt2YM8(n&_JT7(Gb
zKEswf`-w?@l+;RmCVpgXgjY=~tg5_gn)ndwpHrj7D-CWfB_T<%8RoB%jp+aD<U)j@
z>FvHYw>LgJoy}Bcgbv8Ka-^+!K)}L1Q^xY4m+I~l@<m;4n?eh;gr;8-YZD&6dom|X
z8B?}Ms9W$Z+tN4yeBGo!`-rdI?j9R|M+UGB`*sBpT=w2Tb)AH8<lPOa$5Tlbi^Zq+
zstn~>%1mBbU=gPLVOx};OoKKfGqNg$0qR8euaL90gIUKdLV&Sdp3u?9&m88L<YZ1&
z?frVh#w4(md8;;Zn6df87bFK#Cnf}36gX(A(v+~*a$^WXk9a>!?2Roq+shW<67cP8
zhjWZH1@8`jDhGsb<Id9=*gP?X<9mr-FVJejDY>u?k3+=`x#hB>(~4H@0xQq<r$eRq
zS-&3qkp>mLwwdj%58YACx*|_v1tq(wC`R?81WG{Ag%D-PdT8YXvpe0eL}SHoM=p`^
zE8a>q;-y>BA%TXt{Q@H}8Mph}z#x|(j)Ov$7u`&iCJi)LYuk0sS88K#UxwUb%oMj=
z?=2A26t9^DEsayA_dEo8MqPEbYWx*rtsT3YV+RpXpo8WKiOB<G==Yf`+bNArII_e_
z`rZGOtn#x))i^ck(iZ%n+otIe%|rv`l+#euaDJV;63&fqp?h)17DrO);}B6q$c`RL
zo%MWcbNuB#&A1sroUP_S)WF4sERn><jBQJd7X|I&#9tY;TA%u^xt>V>{;Ons*uOFl
zyJ#q<e_{MT>a-+LYSoNSi?WAA=Udcw0}Kf?R!N|lzvO4h_9MMuvxi?HdYK?t4JK}k
z&cJRUV$Xo;#w<M94n4sH+;0&f;|B4pl4H{L_pA*$_?yZH_n|-q{YqfLUp|+x_e^;X
ztN+$Gr-=#Y(GF7oFW9jn;lEri8Xk_bFcV8Ru=|yCmtb+5di~#Pk~?p}0<9V`#Wl77
zhF)qnD683*HlcmF=+0?A<F%GAE*OJkI<4^r{S7Ha<GLE@TT4;#y?tt}GPb|{XRbm)
z9Ds-Lt-e$ra2p_DlFfEKB8y$9C)K5eve}YkW|=-#tzl!92ZOdp&fAkD8CqeOW&x>H
zSh(kpDeHLdU*l!{VUl)mWDsC`*Nen3%5i$+4d$i(OO>hj)pJ<oXqvKC6*e)Rx)0UK
zZW=#;)_OuL_iT-N`t-9o1&)9i7!1b}Ps$kmI8a})UWaV>$>9q*nl?iRiQS3UL}ET1
zs#RGN2@$4(<Nc{7TYD96iq)0YBh$bWA20yUQ%%dWj&yf|ap=t=hm&>n3xymevc~_E
ztFOCpLIa?m3>&iQ(#J_Uzahw|LRB^Hcu6;gpI&W^0(M`vMYi?&pJ#~jp2|%m-jp=p
z47;*Bx%TQm(wppxV~_dEn+Eg1r#DO&iWdbtW0|O#Q-fq#bhc~Gzi7BYoh0FE&>H0q
zNhKEx>F6ejcM9nKW?52x0AE8q+GTzOhdU9S%YrgpriS}C4Jn2u?NKO~Wg^Tv=|c)q
z5BSaL72=W2Ri!{4l~@x;`j)M1T6M{#=h<<b*QmeW!FM&iG>;Lv=tgD$mC4V{4v-ua
zZ44;B*N4;IxZ7%!?1+)q!=<@`a-^#C_r6P^D=*e``8pdXnf<5GuoNvNmXigA%=c*>
z(lcROFVoTS9K12W+9B#0+$WykzyWZ%@Q$Zb072r31w-~zPva|ojSb(5ZqjMpuvB?L
zQPJO8%!}u%XD?%~PHOJR$7^aX7c455m#07eG5T1}{_U3v-)Ep$$X(#h3VI?PTNFS`
zOSGXyVXe<Sh{bs6>W;c>dB&r*2-b}R$RgTAwWa9A7(Yy7h%jw!-@&SNv!ox<Wl4QX
z_{jR!uG1b@ls#T)y=7z(gDh6A&=C$cJScyS;p*^M$idS8NoC_pR@}2#OI2$k_s;;w
z#pxib-URkkJSK6Ei<lq>>N6!Gww>LXJ37(SeHKdCHBN1~q#|Bp*0x!)LpzH4z+=aS
z?o=$c9>dP)UzmV9<iOlD2E}@>B3Qu#>F)#v$CCPP3~bJaPh)tNdDIo?vWFF<w)q;{
z9a$MRs-L^vVsNYnkFy+SpMKdxD*y`m#ho=%*KWxBljpvgK~?zPpepLl!3%)P88`S|
z_NC)PKr}!k+gOT3{0k9p16t&BkKGG&y*^A?&Gok23Tn8#`rn+X2$nCuPQ@PlGTMAN
zc*4pv92`C<0Rk%mlZ3Wdo>JAt40#5Dn9eh>qNKZ7d1s|Bfj>@eZ#W<NznSo;2zLjR
zIjcrJdIuy6BeMdJw@wem{Pd2!QCr*d0nkKG@ih2DVYczZpTa_D>nm#3jiqv{($_g2
zz~BOm`#0qzreE-eF}5m|csmiaE|=WLl0ZPV008<b{~uiQhUc58Q@pR@TF0qmdn~_`
z!IN5!aBADeP+1`h&R6_zY|2(X$Bb6!GZ6-A|92JuK%DoL_@$Ta4kd@BHnZhL1Ktd2
z)&kP%hr_#EoclR+>#_z4%?(S*fXsulcj-~2$LO_BYn2gL3p2!;K{E&$7PhKz#@ikY
zN5o~kmWxl&ufJc>Oc&;dz5gNScLHzfSOB(|T0e5*Mx{F1<b8Z;*Qint!QjImVtskE
zV}ne<=pWiZmisS~r#546xg4ab5z+)D207?UGM`j{T$dh(cub`a4tTRibQSA-umxB%
z7P$dn9YZ^*QXEY2-G2`sZ=tPM>C;o+WaSSs6b9#c<9oyJk|cGZM<<ysfCw|7MJJv`
zo^DzJcX?P|W-_PkQzD#(W}C6h`N6vr?cd40AMgC*J-_+3Bc-0wAHS_Z&RRNEZhZTw
z|GC?+j(MBCa=OofrKsrO0w(_L`h7>Q_0f2l7PA8{H5ntBPzjQSWnn2ftlK(5ye&i*
z#}VGcXA3j<@C)L@3k+T9UEqY|bd&2eQpoAoO|vBZY~bj~JJ;K~h{gAGtHNF$eZa~h
zLV*@#^WatTlw`LHTt_d=<J@#UX#I;u%iF?t{oNQDfZhJ$_g`8Doh@TYcbJ=m5hq4{
zf9^)UXmbl_bbpmar?9|T`u2mvC~_CA#`4b)M(w*1M+wPu?>P)uq1Eo{OJBry1mHY+
z(vkmlhio;c9|g@mv8-bs!S>BN8?P?jC>TX{_0OLcPT5#JTpGY)*oO|bwP!B4qL^7|
z|NG<d7;5MQoG<mSoYevyeU2}!j@%o5_d7Zd!vvr_sr$j6UM-y!N7?g>aCr56kIZcY
zp&+eVyxvi635e#32cCP&c363pAbL|AByauOYrop)9=dR*_jciNVFEot^=c5g;O;$p
zWVF5c2~ztT?|f`=@zA8vi#|yHDDd~uPWEih_S`tbBM{y9yv=vEW(P@o6!7n4=C|by
z=(6oB1pf&MsS5zvE)`{=pTlF@2fRSCPYnDmG5=k{5ey9s3j_kB_J9*HttG7~?*YEb
zZBMS~faZP8?253^RLDL`ebvSJA?iEc6dJ7UtosE|CT@<!uEF~h2;jku@&`a)G<z$I
z>cd1}R!Yfds8_u!kaHOL_T51kPZ#t!iuCl2lC`uc3db+S0m`E5`rMOt;D4}B=#M&S
zy`u!fF2Ap2^PBF~T}=Qe9Pe6;Af<n9v`wJz4FGD0Hw}^xG#)W`Lt!qT(Od$rrDO+b
z7!PzwCeY}vIgWZA4~R`q#d(f_ffv181M~~bOky%|es-@a4Bs7tJ9aaT2Hmr9wXTVo
zY<;c3aC)v%o#5Egk3N?N@%z$Ts&d)o=V2UsDq~hwkI9(nS@^Gi`LaGYzL$9~i{-Vo
zg6QUp;>3101KhrTU15TL+QarK4!Wrt;X2m^)X)CG{7m-x6Bz!bR%)TktelRjwWI<Q
z=CJeKXY#dauh3yZ@bsw{OtRIs93b<v)PhL)pbU5b^kELpioR<kjGqPGreSO&6oI<{
zryAhtAJ_`xCbAJWBnr5iDfdCw8v71ljuD;Zw|aQ=B&c!CdiZv<5zIGGdue9KSNF@~
zlk5kk4%C?FyT#ITsS^6Y%H`<M(Sw#e_?dU>>{O@)8}LBcK?Qd}?$r;@+AO|FH59vH
z@Ye+_z?R&_06s(g9v#$W{ho(wg6cP{lo8%j@^acb>!x1?lQhDbS_(g8|4d-@t3(HI
zA^x6q0cz_T&Jkj!LYP8;yJ8E`S#liFCQUy){P~&I9TD6={L<MeQAp7lgi9_SdLKH!
zbgTSLUL60HMO7F6O@QrM$Yb#ifB=x)_3{6r>pi2I3cIb*orHv5q)0ConuU&Z2qL|M
z3eu(b-fI9AmEJo<X(B?9j<hHO0s@iVJBHpn1a5rKxZ~XKe&_t#e=@Q&GM;CxIp>;l
zp}ga-lyf;wjLf7+UVX;(ZYm%0i}#jnOkUBgfP`r+KJS1sdt-u#e!pExFlr{9Z_-Ut
zV5u$>FD!dk2RnO(K$N7}+sSn}Bmi-d>{?Rf6ag1p+BNJN;CuZcRn}ljE=k2w;p89f
zO@~Eiu)t)$;SqR-PzAf{_>Jq@HA0ctZ!x5Z{zVwO+%I*y`nFmhEiE~(l``m+&dHd4
zeW@RFllV30cLkWO<IZZRUGi1g-2mI0;*^FbdS{Da%3J0>#bB4o;1{Rf5<pEFGlVU^
zG1!zAK{2HD)4lj9cURe@oEUReK-5+01easVUU6MwN?U@Yq1Hwy@$mutx+JVqP)55c
zFZVX^4jvu<iIn9!=7{N+&yzM8&~ELw-~6e+`F05^H!C&5!e8(HbbflXTGH#W;&zyM
z%3}$h8%qfiCX&bb3w*>tF4$im2o&mSu%NfoAh-7~MDq*qxfo=iD{05_U%c;4g@z6-
zpHp5pa|f6t3YJSh=Tib9l~E}E3gUse0({sh#c8*I!1aJ}mGVUi$lb<7C*EF|)_K4r
zGdZ)P;ekfMpId>!P1;vMf%c|<I^r(8rSVG=nG2S>*}a=z6!UZIXig~{lVX6i47k(`
z-x7%Y_#j6+s?UG}ZY%bd8X;wJAyyF@D;Vj)(6+g6Q)RVzO-2dVZ(TJ{UZ|rb@}K2K
zdrF}w){I(f*sN`i+ZBZ&I(09QbGzqbkaG(c1EsAoEn*LOV3IVYXE!G+En6JAK_(O>
zCuju%WdsofJA~2A=Md+1uSQDn1H9igWC`B-<HJ{M&gb4Ti?x_7arLn2r&76RrF9I@
z6I(1~2JrLK*{bOQZSMAL?sskX$(8-Uf!L&)07AL|IL98FJX&%zHZBVlFiEaSI3VAf
zKhV2OD_;~vI1I7X0V?@{oAsHhnqj>H13b6RKMC}ez!C(?;L7<c@pStyyV{qS#c~Od
zCG;KzvX+<H^S_7K|HJ~~TcqBjtXt+9VQ`&1*~rYGKg>SS|99p1S4f(@NKEi<rWO(1
zjw9~Jrv7H4(LPVMT>?OW3&<!aZ<hFiJrFw*5;*pC3P*D|7PK}`JQ=zhcha_J7-HFS
zy>gg8OWYFWda>#fznxor@_nwLzMzeJZRi<pV^Tdp>X^^VQ}kqwHEf@o%$KPFb+r=2
zD{LpZ(|jzH^Xqz*-R_`!+d}Muz7kuVy=9&q_K5Y-b<jn!87^Q7gn9n8_hJKB?H!sm
zoxoQ;|0Y^@d{{SV)zCN1p-AqL#X)&@70WZ<m2K?->*O`p`*7=rW?F<EY8s1xj2}+n
z#qw*c8j0U3&gE<^O1S~FUlk>`R9;^=E)JaA2qmTai{Iy@2WZmW-<rG(HUb6XoY>sy
z>MhOI_xg9vqCq?!Vx98Nj0mB~NLIH|j|9H%^XhN313vRXR}SW(8}2|2$T<ygex6kI
zzF=6l^mhDJ&60$gARBhHkGkW=y&#wGUUhlU2P+*LAwINIHaX>Szr?xbe#i^Q3A<hK
zGgn;~@|<~wt<Q2;sQQC3=Z<QwAxSAj$fLjcAQOL&FrxYCmy)&+IOL5P6ds|M7!@k%
zt>(nf3d9SG-)`NJU>tbmVND>=cCD~y!fi$R!-N*`T&AM5{U)-mSV7)J6yypK*q|L|
zgd)SL?f1`CGbP<`ddxek$;4btJ~QVASfRyi!67V$`|u(W{)}{4^E4I;7hV>%UU9kE
zlU%ZAp60#<IPt4S0l)>Jfjqf!Q0r0WvjcTi&8JgH(j(m02Hh+1@OA-*4(7?VMhB(C
zZdP_hA1z8tbG&g6j=6iA8pcNfc^u^*jv8p0t>#C_0N*z+hLU2yDz5i{SjdXxc49{|
zIl2<?rsY2T{n<b^%?<=38Lmf_D%S`*Qe58d+RW1zuox>J@c8_ka0n&l(eofX(E8~4
zyx;n9lE#3d%_Fsm8UBS+@?BC5-{#;_1s8z@&6bb@^#PDy`T?&_!4b99tXG=gh6F9J
zl^T7fO^?qXzqdM{5}U`o;lm=UEh)8;GW!mi!=5Q`$<_UIPyC1M=}o|r=2N1SbY>HF
zdSCqu+s)I}mHQN@W>S+0xV9t|fM}AT8gsg~l`WhBe&ta3gC3n+Jx__ejp6RE6E*-9
zgr=tXe|i`scf&B;$~?BSn!PQuNt|zSZKCi&sL0D=BmNs4zLjr=uH;WrhR)Qd_tAVt
z=Au+8Qx5yDy|rG0hSZ-;pu4}hV?^W$StXy6Ypqf>y0Zk=aWm5cx!-dIs+#UR%c&U?
zL$H9<YG;a@(vO$O5&G<iP6xlE`s$>g0bh@+!I<?+3P5K5(sk&hDolCX9AsK+x|%+q
z4n|seylalw_t6C;ErIcXrR9byIEQ)xU$z{5VP(_-U#2C<kbIu_<$;W9Q>C}eZ!fs%
z=+#&n%Y3tmy7mo3N<ua})p9}q*TWscsKZ+TMjsd&GZ4SgpGDdB{Z`%2arZ>@y8xCS
zcDzk7gu~&DI+W`BBp?aIaC@PZ_KcB~uBt$sA?_jCIIU)Bxg0MXqyIqHoB2LG)w3*g
zO56K&v=PI~kS=>!ASOHX(P776BS(ynu@e+{c<x9o^+PTM$nsdmGQJD<+gZeCvgN~W
z4+q=%kKCyM*~ZYgP46E1e_49cX?H$t+jL)QTfgM#(16fER{@F+5qhQZpdbw;GhNh6
zu<@E`oT&o05$~t8F~$%y_|5J)UsG_b4o{xf>Ml@olJjw;SGq)}^*BzZ<R`H}PfN*C
zamH@~9~iV#^AL5>#0G51gptjma=#Ukf-&+ep?8wcSvpR4tV}A6$tO+^xWd5%?+11L
zm*iM}(Y<P^<*81&?kG*GVc3xtp}>&9X)rzhfi?Rpoth}e=@j85F5Ay9gU9C2jz9E^
z!_PLTf%Lm`e?@?dOme-Eh+!hc5HKGZlFMsJwzS}qx8-qnV9<5?lr<dryAtEyz!?=o
zDMm!lvPwqN9v9Um<~kU9Bi#`kM}HKMjs4)gr1KfELiuS-5|VUWbFQ&`^M8U5|B8Si
zl#dXRcl}d3-v~bT3hVg(u>P?rEYB?HBEUG_rA}%Rf@9rei$tQ@8pC9FPVY43L;bfL
zf{2;KQMk#bFV`RZOm-qC^id^F=N70ap{bn`x9PlbIqjV?+&uUE(?FLW&27iBL5RKX
zzVoZ`2RLss7Q2&^<d^b}{72vRmP00I2zN@-DZ;{ng85Ccvr#SPX5M>k{kmNe@Ds(>
z6m1GbEA7OLVlG%Kyj}-H2$y3=#1*>lWd~^A^vDijPY@lIOo<Jmv~~*8uIqic^zG(*
z&7R@S2$RMDg`2k2NztW4Lur?nGYS*qk_pu4qU%;%EWbP+c<A0-&-ep@d+zZ2qn~3S
zPWkiGUxo_qrJUZrgM`zH$;0Ozd{iz)Ac2VLzjMR#SzZi?f_Q-z9>sPSb_ztCRxx>k
z1nFtDIQe`*Tp&U&z-M^q;+SR$<iN%gVnugt0*$-|{Hvz+Sm-=7@Y@G>UN=LtNvR~s
z^D)FvEU7h$Y~Jv8yM?4e-5t7T>k)$*M_-WM_wz)68t`gabj%DWihYeVi1f|*+AiE|
zpP0kpmT7vLmMUdJO})=CX#oDtXFw=X`b2Erd#fpV9Jp4Ayb(@g{xGYw3WBIAA_rDu
z--vuvMMD6RL9u+mQD%2A-A*lNWUwKBKPSWb{rZ_XFTk4k0PdDbKY^kF%F%&DB^uCC
z<!%E~K5~QNBc8I8S0-nk^22|g<^CDwJ>c!PkJ2y=oz-7?=d@UPljt>PT1QKE`ofDz
z+~$)fi|;C5g%BC#E3^w9cRwj2WiTLg9ynOMUQ7PAgC3Pzssw5zOYd7G>l2DSWJmCx
zwBaAjezKRj;qK>N4nyz}IS97;JbD=NV#V^TS8=I9Hay7f(@-K)|4}(;V~^vJ&j<gM
z=4~L>Ah!AhM-xuW?Zb9FRf$%XGpEB0G7`DNu9d#~&eKoxZZssXTlU1m5Wvj=rRGpI
zP<gwj%IzVEOw*zeoPa_TZHjH_TI0S$<NCG#j~(&hTRj2N%#T1!ubY^wE?$+6o_K#g
zO8>0MpFp@Ot{zkoE_xWH-Yc%B6jvCilkRv!tcU43)dRiaRXZ-CA1ijNCf+>28Spj&
zt-6%ja}08|so3Zj&-4RuKL8ocY_rXLVu~-q!UMwx=(H0tUUmRu1^mD_^rE}PZv-Au
ztyQrgM-m0kNqWW<@j+?7gz-_^4s6QaJ<rMsHoM_V;=c;FQ$Xv%cW)*TxXwLeVIRA0
z;0*v)9WC{Q4u~7~%nZT6u=W)l;i^JUXAC9WT+toAL^!ueV+hZ$1b`N*^pSx1N+FPD
zj98Cm1acMYBQ2~U=?g+e$A0=r{7R3|o;*XJqwNzQLY0;4!IARVZ%{OdlUK}D=nlYf
zQXuDi0vQez{Zki34@Djk6pW3T3B9?*5F$ZRa(60Ah7!tABcMsrpI^geNLrOVYrJCA
zU0dUwLR+}BuivtXOQo0I4Hcg7Lgc}`&2y|fi8^1d)5?ffuxf07T5(E0&a&0~hL~)x
z4SR&&&|VW-PQ2&@TJ7aCkGvOu6=DyZzn^P!oX<E$8MQj%;QZt)!b|vE-xuVSH9!q9
zOTj~iujW!dSb74arj&Hq7HH-A(RZiX&(gOz9_RM?aIqR+(JgD!AO)*`$4DJ8*>@de
z$#zl2Oi_W+#LW!l!Q_&d{BPBy<?c&dsp?ZN$q8(yU$x_?&qg_sJGXF{tD9C5;4!`B
zsZ{fU09?m8MR+};n_%{4Z(uX*Z``=+rq1(>GrOeFtxf}p^RYVG9eYGhT$Cg|MFR69
z^MAMTaSbJ0TT|GUXGh&8no)Hd6vu4mH`4#V5IOU-tM}&t`<l}tU{!V%=LvXIif?<M
zk0bNLu@UXF$87$=mzq!Ic36QB4bqdnm4DrE@7nUQ=YQBBemyh@GeC%p6f}7td|yad
z>V7>+TZL=T@|!vu{P*pE0f20}L98U41l!Ke%}*}veyj0QO%ImTcs)ia0~nc}%)aRW
zVfcS3`nY!9kS^%&%U@!n5WhLzz4VJzpt^IonjdPoZ^@#=DVr|b|H>dEOGc->`@FuX
z*}XGU%Ur`a=@i<{7<%B2e`~70uQwK-MDqHKF#24l2!Hmuouj|I{OE*`<8U<$ln21Y
zswFZPUtgBTgY<y+qt~DM`!z)SLyWP1;Nthf4M~(2zD!?j(NYvWltA;I1B7*~z#bRB
z=?KUuoGy2LCTOn=zm9-@D{FQ$7J9q{6<l*!c(N7#5RG{&#^bef1!&Rh0VU#~*^3Gb
zgns#A<Vdjpu2wE{_Tap1@ti>kFUvB(GyHvHmePc>r1a_tK>B>%il;-w^*p)Ianz{A
z8G$eer3F=Z!Ht7wCCh9sYf^a?S4@Cp@22d4yDbdyyoI!=mGJLD1x<|7-H0uxKv<OB
zHm?+2G7kl20U4q++9ocxNXFXxbNQ|3^f<w;xl~G5{3h)%?mihQ+<4v%#$9Dn$#WE}
z8!FqL*%(%ooPUnoT#<ywn+}jdFm)zCr#_!8QH~0=H??zpk^J%-t)Y;=gAVHT@9tb{
zsXhw5r*=!5`9~afGvqICUcIN`ywz~9%$HZ3?}gW=*9o?S-NPh#j=)qbLqYeAg3TT}
zgU3@w_dOd-6J?5Du#fDGJJQ7Hw^i2W=4f|=LzI**p3NWfdBxUygt*F!)O{v_ixt-N
zJ|I=>w3Vcj2zkTDKSx3H77U=a9$S!ds6ce{1T}-+Z-mx4!$0iCNy5t%<hEMC7y`Xd
z5O3@r*98Q=a{(OUhbL&z?j&%pJQpZ3RhI4L+L4^XF)Dz?#s@|~T4%}xY)RdSZwj6`
z*17mzy8Xd{GJlNnvqIT1su~ePs()LsxD54d@*{woi2lot@oK%@<aa`3eJg__j^+|f
zf!Ps`(<NM$+v)iZ@*$`cP?j|%MBo81-eK`UvJC(A_$WHQe$2_WC*Z8orpfW+cfy+Z
zw4+KR^sS0O90(a+lT8_*1+ou<6}mufJlOpttT*m4W<@To-(}_6C&_jKdHn{2lnDHJ
z9$0tG-!=-ybWR*s7rvU(oY=P`;{9A*KGzpCe}BN$*5t>R+kJ1o;6Q}a;d{2ISx`kb
zT%t3C@+y!c0K9Ve6q}l++dH;!vw!yKC<Q1Cf6<X_-k`0Qc5G9+2xLLDF7F@hb1tkL
zv#{YOx2I_t{AB(uD4BZM(?<N3=YT~C{tDK^;zn6>tub$cqQDrWI}Bume}^E62MdFX
zl=#eDrw{LSYTn9g`lwHkw@&tChvsSdz))Cm3!!HPG#S7!HeQXSP;vzc*DjyMew<{`
zZ_-6ezh!(`3?SV?C2s9m7$3JC<P9Cz*#2yoKbWpuS}?ni*>6}A2U_kX>o?@nAD*!0
zRI^jVgD^Yt<`pX*K@$H>J^z20Xmk@2%?ZM=AL#S*i*Gjd$QKQSC=2={+N^e-KnN#M
z$Ca~wO^Z3CQ#h4^`qTTHK7mu(Y;#l2^^`23>qpHquBaieqrHKtsZb$CT-mu4eqYnl
z(Y|kLJql+_^A~kQ6TH14vJo@WgbZsAGuiplGBioq^04Jj{>8%d%oYq6Zp?}dxb+^Q
zA>B*4;t}$4J<Z$*-zi=X;uE3%y|G)_Kc-n0(2U~$uA(HQUtQ(zqi74_Dz;RnCI`kW
zR;Jb#874af;~d^^xR~iFLxhCGNf%zu0+{Sk(D_4NIR4Y2O0e6_)*AaiC`)=a@)tB%
zHdPk7TqJ%rP6U1RXS?@upv<bDqd$kYdnQk8-idEf;##&*KOqEdVDoKw=4ga(2M^0U
zto9gyEzs1NCcceD1;4OUfL3Fz=pf(nVbvFQs}Qb&@Gbg~m$Ta8IBR(W_}343j#fY~
zVr|}zvpylE(E*OtQm3eQkCjHpjv~^}Yx-!1^x^0AC7hY!N%OODw7{)=0L~7MVl(dq
z!L{)xVMYx9=FmV2a(LODJTXpx`)i=9^Zn-XlwN7xkSqJwJVAIFg}X7B`p!<R1DnBt
z^n+bNJ|OVekx77L+#K{nDoSs>e2E~CB}Llo{TZk7%jJ76b}e_vp(k2550<3NSG_n0
zc3Ix3h=7*gZ3Ifwb-be=Tch1LWl>kUn@FZckEv;n8``#g;hXWd#bl2fU*P!Bt3D89
zmuc%8D6#~Ufu$C8NO#=d^ng}2hG?;lX7#y+Q`L}9cTS<hl5AlNV6J{Ja%Ao7oGwlm
z$bwh44>|zn;goPY5YkJbxPVw?bZrsSbQuU>3P#6BMJenygQ*c(0TdWnAS9S8akk-!
zUGeE%5QpIbuv)?m*$xD9GkITeNJ8Mk`b5GW`0-O2=QBs@@joA;CGfn)he<g)Wzeeb
zg=ns#(7lP&v4Y^-#Fabc>#2~OKW-s0G*vJmd-&f{#El)Hf@9Q0Cn(D+b{vlf*KUFA
z$$?#9^&W7zhIlJ*LzWmUHVg_pB3ap^1!Nr0JeP_Mgj{dyh!Y{CTapr)&27(SK0^`B
zyirmQd0z`BW!;&R(^C61lF;W?XU&dvBd2okJs(glh>4mqjfiLn-F^r|T3wDB%-*9K
zH}V4xOJUvR|A!Lv-^cOUJT=Ik!&IG&@^43@8|obX#qTZtBuf9+Nu-(E>RF;c@vFQz
z60i(=-J<1ov1fG@diiu>>zMlZVqW|F%6EV=i@mm!2=1h|xpI*oNGwQPdoBe`_KKbC
zMAP9Lk7!ZPp#O+a;pw{g#)BU~hU@y=!x%a~t~%%yl9A!`(nq`Py?y14XdkZ6eXh8!
zBi~`GXDJ@ar@2IJI-Q)~7Q{mWH()sabbooO63@s5G`@v63-Rq`=4h1ZkCK~REi}~Z
z(dT4)4C`@=omOJ`K?CxVEeVM$1Gce4HvVCA;$-DA0WS#Gu;z;^b;st2iYwng*|$%4
zwbC?7Tffd&zMrlRM=z9Qm3J%TzGo#|z3IB1+?>#cyKfSC)Unz28RD%<(v@=o7GH$w
zI|$ocmZN~a(w9MVuD@jUH~#jnvYfCYLCMe4-9OxWzI>xU=FIL{sXlv)Ge<@u?`Lke
zhdpG-!C>mj*Sw#1ggJ3+{h{kCBL3+iRDbC`5pi59b4ePI+27pKR9B$2UdXKd<hQ@P
zq=c(yUw&V!u_D7wv!e87&Y-NwC0YFHQlzj?TOoAGgE$c-Ou`hKfD)bdS2k`wHYxFK
zjqq~vz0I@GBHdpO4cON^QfI~??&5coAAshi&xGhIR7pA3CvXZA+~$rN;j@kqGN^k*
zSE7CiEI-Fmavf*7#8XCru>)fcggf_e=g;ywdJ#O=J+w>AUA-G?Qt{e$&Ag)?cg0q$
zP!CSp+A}?yUPj!7;Wvjf*08-EY(RolrY~<l)D=#Z;&`RCVzxtanc6sa8Y7l^QKPlO
z#;eN8y<eSEJd$Y|9-X5_emz3)>#4qPCesz-JP3GVB4?9u{Qgjy0v?8bKn}cJcec;b
zy0P+9=rVLRdp}5?tHxy6uc(>0@=9;TQfERigmRsXhBy-}-E<~ZOhxIpyc;wpPg!zt
z00t{TYbbhez0(ked`}gz;CA>lvb>gG=U~3pHT*7Y*irn8Gy?J6-SGCi%DX~vOlHGf
z;N#GcMs;ffco)PlJ#%ON?fI9ZO{7ie5lLxe5!mFA&>%g$oOb@)Xd_+h4m`>NO8knm
zY%2n$WUVsa8Ry{|n#+R3qqLC;ea%lHR?e<fa|2Ts+ZArA#Mt?xzJrUim(>Gob~$g&
z<<EqGL&8}NA_-oVhuUFRcU-hv9eTc7e60<a7Ou(n;@!G#IriG&oEorTv414RJA^+h
z_+Hj7O`H<JC)%F$A%B28lY*b!BQf+D;$Gb9da&7_WB2k~uNR|XRiRpxFU$!Ky3?}L
zad>1j@r)%<?%<-<P0XQ9t!e=BBKK<p-v?{Gk46;4hYd%d5c;j@WI2D~ID0AV4i|S<
zh^XzAMKRUXfM?#p`Gjt7y6W;?7~dCe&^PI}Vu!Ib#vMGD<sh}kl!jWGjM+V_0#?l=
z+T2?MaYj4-K|6TJ$H=Yd@mUNI5#A#pHVd3)=055T%gChAQzwCM9MFO|6gPmr-(0|P
zHzzALPOo*7JZ25WEEe!ssF?VbrO?-$M5ne)(eR8|LSsGNniT;N-o5Sy!kUBTz44f+
zOKfbxmDeE8*?Qmb&j(5XMy%EHlF31Rk7CInZ^(~AQtwaHUi1TnzZ<8WnkB5r0_m}5
zb<wuA`QNeMqNlT_#{U0W_<!Aivu02}DB{Xu+iK~dGsuK=6$U<jIj!LLkjnXF<KX*j
zXv<Ng#n(RmAjyjvsfTW2TklD)YP+V|VFOn6`Sn-B9#^2_R>Jt|3*)Lu?FR6WtpUNG
zHW|eExUbA`UjN)wUSH45b!gApgzI|#cjKjy`fn%4>vl1wD>xZ#N(lL(-^i4(-S$lU
z%&1&A7MSs%z&y`VKgTN>>eREQqyLnQjepoJ8n9=D5FlLL<zx1$1m0X&kd1v8&~j}i
zC1&v{9D=!Za!QJOJS#47*T|_*ElEk2nv+W_cd>W^qb~_B6RYNtz$X<4AM~h7rzdr1
zA0QG1Gvk)hh#AgK-4KcE(`1}`x3RXA92$&-Yfkx^yFV)LbTm!rq2-Ot8J>qzhh-{;
z6Cwn1mMX3~A;|dAx=cNs&S-r<VZjf^YefnD?FzG(%jRI|E1Eb<L|51MGM@g12`5sR
zig6~?Nb1usoE(;u5|~k4s0yV+?2|&Xvy-ls%rh2|<l`m>?`WZp?KEsUK^w_;DT)w-
zt?l^{*}2wggZI6Jnv#UpEGYZ~$j~K#VF%)&St#dUA)$*K2tf;M3ayOAdeq0wMDufv
zc^QvGIyvGWz}@7wlUB$jG(*zqI^B=0?^jQ{dJ<HG#CeN>!w<(eL>sk;-;pNCY5f}g
z{t?GXB<keuPGpcN`?LnXt@WB0wCzXIXI2K~&lhs31JJf}Kapu}%FP!d=+Vd1km?<L
zE=wE*TLQ7Ylx1rmeB0gOIBqbQQq@uR4rxAL_ptYqL0~C$D?+;2IDok25bCcY0)M$D
z97eLd*!t8@egDv71W0GKg{?9nsV#_h?T`FO-e97D1Ui6p0E)x{NCRrmkW?og0LKmH
z4#xjsS9c^clm1KYD3yY)Gjk~9EqVJoB<)Xk5K!wF6ob;-^yWSiP;c^7egQ-{{8$r=
zFXSM>VKongy>v4v>}7a+UT6)${NHYzRlyK(P~)WQXoIkm_>sBLk7kK^Fhqa%12j$(
zigZHAtgn93ZyF*pt}M@w3vJ9e=~evuc;#bQ@z+rBDbXvMyvRH-M%Na<c8UpMUB9~y
ztVV*Dn4waCc1BAO9l6EMVOx+_b`hIaEgJ{g#d4#&=5JT4k#XN|-#RdlxUycHBnyWf
zzR-KLbz0CCu+?y!0rIKL$%j7G{3Xirpa_h%2a_Qf&n9o}s(^>bY|2pwNt#0jD5o~#
zlrdriTVvSK)axsrMbCc|NOw@k;Ev1>Hs_Ia-F<^vAh;6}pZ#*tWCy_{5>F1?j~U~k
zH~34p*<^Sj!3TUZBvsAvUVfv|RR%`(H7t^{rW0@`)dSwR70~Lf4X3u?yg6EFH+6P|
zEz4QJ^TqJu%@Ab-3vN;?+@r=f?t!GN`U3&2pJylM_m-Zqa$k9L#n6l#&K)=5?@NA4
zc)Stb#k=(S$T{n)O2l5jJ#MlLFJSYTmk=<yb`(J{^!*0l>4p*gqvZ&|TL5pC>h_`q
zm59mRp09b4ek6yNPB~$!n%7|6&@q7lCviCHcTG{>!K6ZnSx_;K+hy$6ic>?d)CrH6
z>weK6_R>o%U1u%RE~CtJ@*~DFz&ithlOVrbkvLwUB)Hn2E^E{E53il|8dTYOW6s7+
z{JU|l>4hqHeBqwEI>lHXyNb+qFzZ}{YQ8~45?7_qp4ZOV00@Kqn>O{|?co2x`?rGA
zVepM3y26n$v*7)!S`LA^zJUT+L#Oa5S-TCK|D<u)x@e=s%vwEm*2Zv$)eW_=gIkn4
z_HQbYiN(3%Z^+s0v8io#i=8I?)9UpIJNEbDmOBgLcr<9LJh}SWNZxij1bJZ~vL>17
z%wNj==(Oy2D9Z+Jj-UKnc^H@weqm&~k2klPd%_xerT$^F*nimU1|X9#@>h|Q@6{za
zudu>yn$`hZFL=%br}Ecs$WtbSqwh!DbmM`>BR@6Up40S0b>@cgjgt}lZ(UYJ@P1Yh
zF9!|t1xr%yG9=l*oD+wX(yW~6e`c3sw;>^1Gj#0{S3%8!r=7sZS3b(e`OgXq^@ogZ
zFP*+bEmya$wx?26K4*143LWOHuX>hJD+(~M6dukr1f(pmU#JxH#|fGY+C3li+-k{q
z1xl`Oo3e2<Elx!Vx=7RAf_JFSn@Hhib2R#%aMHu#`VYW2m0NHvao$#{Ib_0~xH1RT
zj&FKF$a$W5623Sa<nKFX@Ha!mCh;XQ?rUl)-w^jV=KSa1gZq^o*b%UXmO7?1offX_
zxwVv0_;)%@LaU$%CZXlAOYQ@q?&t->8}1C;CCVqDmnSk&wek+y5dtVSL<LL7T|u$f
z1164>+602kk0H1w8GW{U<T-D`DZz;i8V?qCqpVJc?;`aa*s+5V&1%3TaAOSQ=FxAK
z18noBtbF%t^?KxnA@_G;@1hb!jDq%k9DfG8<ldHrd95nW9c5BrcT9|mT|uphR}-{r
zguy|9^*n@A04o~gGGuXZm$~yyh)JaSjt_5}>3aT;K3+)90XR4*FceMuD<!)meq^Gt
zua$-V-69Ni(wnkp{#%6$O54&1X$bUx1e9w9ciu?lEp-!a0`x0UVVVJ4?#Rc>uOz#s
z5YEP9hg$8WuYO|Pa||%ok`!ru#hcUJz29M5inWnLoJX&NiRJ|u00#2)YFRPA;l1rW
zp2D-Fq#Uh8oD<8!V{x);7gB)9zeZ)|PMz{p?eOKR2f<YwL)AAj?dcoleoO#0dHm}$
zCw+4oszQ^gi`pd8z$V+`sS<8Pai^n+5<d=Jokt?VJ8lK6#uKL@Sxv>X_H9tC&wAP~
z+EnAyh*2g~!Jba?o}rC89E11i#aSOonKfeOVrkJutP0Q7AZ-*#yX5mvyBCJ^CO;tr
z^7bu_dl!tVoN<Nw)r1Mo*r{Tf;f>5Pwx+{R6c`Oj^ze%Phohrt)%`t{&y>Cn_>r#?
zmj_O!9QWff4;h97A2$^oJ=u_bU98!7z{wWL!nVm0S2nv$bM&DXS*D(g_pBPy=l82^
zA2(}&TKk{43lao}?8<B<N}eS}AbbLg@=V&g1Ka~mFFLbtAbZXv*B_`{h&19OcUJv`
z5R!e|Q?TKHTmTP%$7ER6YaKSk3epMS%q6FL>HIVqUPE4g#e^jRUzu-9eHxe#l^H@C
zV#ssuFH3Z`n;9QWOj;OIbv9y-^?Tz-1EAaQ0?A%GG=0LBGg)!07sE)FmAnzMJc9$P
zzi;88`_RYj8?8yKWe^eE^d3C_M;_xqAkL)Bye+;~%FKqnrS-VC#IG~@YKjm^{PWE6
zv7YW^&qYkZT2!5HmYyY<|IZB5TzT&2#4#8~S}vnOX=HP7HGfd{DC2C?ez(V5F9d^E
zeJQ9u*L^iQe&ckFAC^){LI3`9F1l6Hwe=76f3tV+-@8hOz~hrpOCY3+g=HMJmO0;+
zh}OP$mhw07QETnDz{{M$NNJQH<k#<u-zn8U{Uv5nxIkf)fq+PLc8p1@mgsH%{u=Do
zLZ@b{<W)mjW?b={v32khq+6vW_*c&d5uBlNk|-E{mb<<O$qT|U3a{>oo8>1fIg5R(
zVV10Z)BoxKIxwMs8RzbfCR5}LsN2Tz4G!+HkcaBz>v~J~38%}l)SP}rmJRH89R&RP
z&t*R)PY7oppg#FG7V|$)0A^p%_&SyKBxG1F=&SLivio(Jsg!@=b<;Pd;f#*f%FWy<
zHvh$Ut@X8G-@><!@5`kJV2{G6D@&^FFdJDR7laviHpk4)FCm-f-wzH6zDlt)ZNCfA
z4*ps?zk~MBd2DONk9%~hi$Y@WD?idN2e-X5JTy{qGB9>AIW=%$A@6e?TNaS{!8j1R
zcfx)-B*o5ObN22{`nd}hkl`8RznlSK+A8O_J@FH)XyY;j1j&yl8dNPTEUxT2<!*J}
zXn6bgru7;w-kOg-bz=Kl%1QmQn;h0AsLjzLS=W5EjSq?eVeGK4pwiswKv<j3E@ip|
zB3dCQyZ&TSW_M?^z^D9XF`)0VWF27D4=`3cpf!poA5jb<)Jf#yvQa^yfdK8_LEwk@
z3OLQCiPHf{lW8$XYi}vub*1J=Nc`GbNWeF!+ZvJo!Fm!%9h1!#iqk%-mEm>$*zQY%
zm6>Ol&K6!rUxd42eJn%GNq{D8wnb!+iYDme(<sxBm!BzG{=CPoHl8&&!}lNk`T*t~
z5-awQ<}yvp3ixn-dJ!@)_roXq6@mN5M|eiJ+H)&VBPsl*0P~c`;q>em^&-%(l*dlc
z=D7j2+rw#-R(+_C&I$dNF9g31^{P_+9f4qqlo--~Jg}e*r)%qBK-L`kn^OQk4jPOe
z#r=Rw(}=&ZvsruoT!<Jk7AYfP7*>lHUYU#C$47a;q8{A#haz{Sd|p9p2{~N#bo#6^
zZ<3h0-y%&wW!^aOkzQdR*Z98h0y;P7d8G98V@mvwWCe+Ff&{|dFTC~xQ>S=)**jj2
zr#%57)wlcfvJp2e0wDeR{I<7~T<8kl-`QVkvY8mT&+r#?UaANNJ+H3vyz{VIN1bT^
z$jZ+nho7+O4tZ`E@V-mTYiV<shpSTXM2pTFy-sT~8o&(8J|-*}7VFug)i*(fJ`PcP
zSK~{fH_4|ST6V9<GTRqY36xA5G8ys{Q9LUL@95HhwRZDu;jJP+J=<XP3SRmuId{{V
zro^wDTYmnJYO#3R{@R!2V*7%7P>G+!R}Tp7odd!dED?pnO>@7Qln?r0M_~m#*~|z#
z&O<?t+sH4xcP6)?oM$A5WJTQ8zH~Bj>IHVj`*Q&n17?4Q^c6*nvcQfcrRIFiKwO!a
zWmnH@n4(Bgf69z9JVD+z{4J*ybu{=L0n^}@MFBO068UOyvwFrinp9PmS`_Z4-6HWh
z!Y%-E+wIF(kv&*fg@#_#<_F5{4g@2<r_MtHWO7wnYH>N(Es0Jx;odt#y6BIYfra%P
zjTZ(F2jTn4x+Lr&GfJxK&>D^~{4}N6+1uh;Z54IemiT)<4hF`{uff<!tozo)m*1^&
z_h|_3-eo3PrC<3Vd7Z?qM7<&YMJt`1n=^1YWyTCnwnaDev&(DUKenG8r18dBFQi5>
z<YDu33e24ol<fR6J&ju53V<;SqY@2}?BA#BKF3kR_ft80U@kL5ZGX%MZ;moB@HiLk
zR=Fr&2)k189Pw^(_s?-pYEND~qB7uMNm3C~%eB*Z!aU_rLu3o8aT}b)lhLt6@SUAR
zJ}?EBeOHvKa;iltAHvbr8K{}V&&p?CSZ6W{A<U&_$r$6q?qxA*N{WaZwZ+#<@n~g&
zAFzGJ7Xz$&Ile*40}y#B@0{V2XW%7`PQQ3{f?c0NMT`QqfcsU8L)}oxSj`*(!R0&I
zbYF%1iA}Gm|0)IYo$d1EcNrzkMKL;EGzB$b1kbbf`gw3!f7``Dt1o-U+*cM9m2vw(
z4a|^QL`1Ju?*!(y89{-uZN3?oiA9d^+i@mSs5n`TF{5P4Xn5eVik83^0>i8K@Nnp4
z2GxMJG%5fPu>#{nt(X7J_bjoBvGOxW?^q`%nT;|E=v7J6CwOydT+pusys2}}#hTd`
zPmB*@&88OD_KqbSQhXy11eG*2XsiRWfu4?6zYB?|R{{jD3*mBl$$FV~_iVF>-?UTT
z`t?wiaZ@Pn!In_xm(%dkmMKP0Y3cPH>K2b=2r}r!g6w}-+5gKafL6c1YXrs|D|3==
z9*5cv&TSfA%5lrC1s*6=Rvh_>L&ql}ThK$~Qm@3+*7hTr*^P>&wOy^jwu*F1Tt!Ju
z*U2E(e5j&6eT%cBqEhPAPuhQG_9&2$B4_-bs1h)Fx76=W=wsYY<l5TKqlWww+|w(v
zY2}?@3Iv<Z-~Coe;Cvsym&6w@RnPK4XUT!AM4H@2kMB>Z;;*ZQqO065Xfm_$T!@Sy
zdY>|$!Ul`%L=ZECe~)aPHxSbf`G9hbzfp`Q_h0FVeZvRF0`nT;S*hI<5{;e*pEd4E
ziBC%>MCLwhBy6rTkPcek604=fvm={1q=KoHcoTR|AgU#P>63?Sr$@gyyI;{iX2gsd
z<{yxoMfmG<+)GU@1$5sJxX%v2PR!7`A-Fx%h$jmEXm_brf<>1`Na{}_oJPQ_;GPXo
zPjOTTIyKN|s376_Ip17%6ivU*h+Zp-2dR4kzx%RkddQJ$Ff<jvWPt}#FXxl{3vwSO
zz0e4&hwvS|AIL<}939B7QR22h)#p>9*US=CCpG>>jSkz|f1{#_(MJYG+mZQ{f>e*d
z<VD!qUJ=PP#>WU9yyWceE_$z9#X#*WDdpHb7i{fZM~Bc-^Sn*+vqyczQS*3biwSGu
zBdc$yW<LF9>7}a16AQpS@o%$kPKmy{M7P$02`ix*7P?=p9B5jOtzm5V`KWQs)^x^l
zZ+pn;0f=N{_&B=ee#d9&OPG#-yBEXLh7NHTejDo*^<2k1Uq>fpH2}6T;D5_>MT%nJ
z1$u!F7<;FRxIbNy-SLeD_#hT;JVGud8oR+~!+oO|xgZ^iCUx;aY=aOcHaXEA_wsd1
zJfUx`s9#o{wsR{UmNSpN^x4r<`SRk#V)2pIkELG*2bW@Rn28zO#UCcy*X^4b2{E#W
z^oo|IGwDem${X~BnYdV?b+^>?NhqWBIP*6SiC^mT0})u7By~{r@Oo9XRtp-$)T#B@
zBd5tuSV%Dc2d5OTAfgvWfeFHj!;Pu5Av_hKLg7{-93(z%zMrVn(mm&XyfD~cocE+t
zw$HiM7a^5DT7T&L9ubj4_&LJfZyZ%=O!(^=U=%HcGk6Sowr}0WQ5%t$zV-=3$zzeE
z6jh}C*BU%7rN^sQpp$w@LB&&X00J0ft~dL5yTL?C`GoL-OqsdGE;jLOdxOH*iXecT
z4p_ZIq5whEk~L2eSU!vDUA;e~AO3@w#{Lgd>)CPXH9+sPUgC{`(U09rup+ge<5`ES
zm^J=7>{Zn5g<>9ZNJaw0;F-^P3vlJfvG1Q!I#soF;Bsli1%nfhCZj|+7O90vHNewd
zOg8%^uEqCJX|*lwec2bfs|_#Qf^=>N+*G?E?g0fZ4{Dx#)10^pq_I<uFu+V7D|-Ow
z(kXSAdrs{0!dCO7AUU4-RgjS`*t1v!^GYbEz=cFF^u5%y+dHRHDc&>Ir{W^v>egJ#
zwFi_GML8&SI*jSY5Bq4btM}TSYf<hW`=8wXvMh?wP++ZZViTvy-aU`BClWoTC~A1!
zK5x_qEM}p)HpbSuU*y!R>G4pG1Zz@=Tzl}wP~kZMbdD2nF#KWC3a~GB48ybVjBn${
z+bAMz@i-)V4(4FoWzzavJcd!ko5lCYmPPr3?>h@8FZ=v_-2KKnsXprbvngb}o8KQA
zj9j08M@>FKV29?#1QO?*fq+5w^s((8U>nQd$J8Hi$g3^s<>rw+024ITQ0#>Mp0LKV
zrBB~Ufj222lf{UCS+P7y2ALF4PKFqL$UlJ0+pA>RbjsJrkxxR(<0l8=jm(vugg@;N
zNZVhCsRM)M1Kb&<p!prd-jdm~V?W}IJ1wTbs{c(tTt^{e+i?ByO2T|>Ir(`f^?-jD
zwcrC_27-&~H<<J~jES4Pik(K4GAzN6QM~3|LN=@Mz=AHAP&mfe>d;gqe1Rd{nt(~`
zH>dRqlTTKrNZk%qhUz@80>?Mz&V!T?*0HQmLVs@-oRjm<;E`6bpW=6WyxzkI6&ccr
z+ElG=ldDuXw56w0d)lQf!crOii57?8lAY!cJBgpo4?Y^OQvQ9IoTJ)(86_+vk9PRj
zUQO&17;iD?n3~;HE{C@j{`LVA7mtgn;E+4P_AE#`#NS4@<$cj{e)8PLtMHxkhPA@b
zNq(hbf3u;?C$rebD38J`uIKIDQek$HSn4Zk+K)@PrRbBKl>PkVH|&(kM6DWp%l>&-
z37dCl`SX=?GeyTs+2^)o{qFsjd|lSU)J0(~yUn!&2TxxETC9(c^+iou<F1-sJ<Jab
z!2%)8F%1L%iyO`o%EyWr&3Dq~zcON<-g4QIdwudelQJ#kh<zx)#^w3_y9H4>-`>pR
zZ+#m_MFt)7VRy#nw%xvR*O}vJa$C32aV@kH_fMw?cg70i!pH~;iEHm~nqT_|F$K-Z
zuwLRWy^knQC{}0EWM<~ggAgsPIL4nOqf+5Bf6NB1r_|GN0uA}5VV+^8LBZO%51&Xk
z|M*g1T6NM-x<Hupl9r|_yboj7mv{FVf|*Q)bOQoW0jl()rS;(=!uno9VYrY?5F*d9
z93rsQV>*51OIarV6Lbeq76ow)<H$+xzS{%yX19k6{2*<I4ZYoXl#{RUj%<72K>Ux^
zuSGJ<jqS*b_^>oqj!trm25No{LM28wZ;&T&_+o+(EtZ)=41JAV5|ShSV)*IT5IaSm
z`ZA0lHr&2na@f3NyMg4J*8FnQ`$+G5uvZrr%I^m<s*G6+!`Z^lJPCM^n1LrsT;Z|l
z6_EFf`;2#Qh2JqFVgm_++g;|qdoV<G+#~Q-?^=g@=$iQ#W4Qo$GTKK_b;0}Qu%_*%
z)-F7oK6|*pv-Lq!y!$dFLqB~gO>cPEpv5(2t-IQbHxshhtE1hX10VPxy8lVN<zwD+
zVncBPJ*j1A*o}m~=6SoIaYCdWEyk2!IgSOCxOCnXJ!%Lxut7i1B9H)k+tc0GTa@+9
zOQM(#%hm~U;c$W$2mxQB*)_XqEuOqOxMzXncuFviM*CulM3I{}=Y<=|;D(9qgsWfs
z%;&?kqy?z~Q*@&G!ifDN`H75WMQ^p@l7b{OuR50edC8YYa0`R)Lr;tzhgbaEh(a*q
zhtaL$Lx`W$Y^eie;Qm%Z2KlUnarmNXUa#acbRte+zvuz;`rW9FZSj2{XR(h%50}Jm
z5*7})Qzip<Xc|tqlU|;a)Op-mYM2HeeqPY4Q<rEnNV-iGmRt_f=NH#9UqykZmOjC7
zP?N`bIulcel&t$)w44A(dZNHU990?coIphS<8QV}`t>W;#IQ-&U0|XF1tCcoNQO_W
z3w(K2{@TjOY6rb~Mus)l)=nKRb4#S<!yanC*j9+78$^6GYE^ie0i6AT&aY85>wqN3
z!#p_@*NquDlyb)oS#((zs}MMn$iB~0{77@=hQ5pVV~y|Xo4U1ZMN$ORfZeq-eBwL6
zejS|o%KGL}@bDaTJ&XjMbFr#7_ss_k<DuX1Q}@hp({VC;oo5twM;roioqI0x=LzUm
z`9aDM9|x+qpg}*)PTbGQ{moyMdILVhTg1ztm54`o-fG>eKMQ&Ntz@M@9(ZDteGYqC
zU#}b_;!9}H_g3~R@xGl6Q^||skK7h_GU3{jJ$zdnMGE(fWF4X?>%%V$=V0&I$uWb$
zMJ+{_N<s~U{W^Re>H}1#H%hk1%1G<D$OWGfJ~Vzfln3dT<I&S5dWA3v&~58tG^<=y
z{6v^c@WZ4R^yz~F)3{`@yu)S5N_NU;ipiVLYjGo2XmQd(Hb`A|2g=-t&9+9`o$a%%
zizMHwDD(%B35Z1BZs(`T^N5)1NoHg5J2%bwfl1U(!4ay9v*a=Iahk_}`O6hp4d;@m
zK_VO3=xuJ6Tk-5-aRVf`<LZMQve^hiM}RNTbIz^$+A^}esp5V;T{&dG+-z!ldDSKz
z(F5JU_^Owa+7Y0tYJ!@>N$pOe&<lrk=@pY(zXHEHM*zO=hzb#g`UN1D`41>Ce*WE~
zH6jNo*(Z`}&~*Ue=<7^@$!a4w|I`~2$H-;xchjKO{7-1yLt8E|*goS!;pvm3Li6vh
zCs!rn&Lu7P)*%>1VF;WFyG?E3#f;{EWgNnzG%*xvHWkYie*f(K=7LI~ij<k{m-6qd
zUFjb{_984r!KnypQ58N(#|tsfwqnN^8pP-UxqhqG-{`y*%jmKEPj|Ks%NaX|4!IAD
z1S7J2xIoa4Gz9q$XQPPQG{2PD$L@+()D<o9^XpVkek6;%gSP(}94pYT_E0Mu8zF%l
zefqvLZcgk+Ap47uzm^XuG(MxNVLxg&V%jovODgq~Y6+PdRCOR{R3G!WOGGXBRV!_C
z4s-?>m+T2=i)Mzf(RcEqJ`QJVeB`C;)FgrL2rflG`jDI0n;vJ?*=R4@*1J@kY%~c}
zPWQZ;K26GWyBU5R5Gsbd6k}R_mPQSdm+s6n=}bYvhR2XPq1>6b$Hk=jb|5wFf}I|;
z4~644_29<d9I*<v3=^e26a%p~d26+uCr&u`Gs(O;&ZkV8Um(b5#P$CRK<mBlUJBH-
zVkCq1#wfwxaV73v88|qTknsPT1+d;SJoapsX(u&Cc4%q`V(@jWb}FcQHALJa^q{l<
z3*Ml2pE7i%**3a0#WJj^@w!{CqTXiyVjeeXZ45MqJr0WwYnF)(Guv6mm1Whx;T~LK
zou6xM=~-(#4!k-F!m?s^##5WU4&$mzYKUu?FORNpj-hLo2Tty8c+DoT1s28v;Fzo<
z)Fb|tu;)DgO4#|22>OTUz%^bLf@D<$QSsM)fQIjjN*evrnigAE=0|Br#DkQcW-5M&
z&;sq7-h0guD_*ndc?!{L>Aq-rGZvpLKnSj+e12P|Tb&j04BhBWMcC0U9apJsEk=3S
z)$4nTt#|YQ4&lE0$6BC~VHW+@VXu}-C9Ow1T%mZ{z3nz3P|M941H(HKVN2pFb{+|4
zsy(%o$>J(vHrOT?2}8nu$kUp*TswB$`Y7zv{dFL_X94ghFFDA3b=UpkX@Q`$Be{S5
zffajm<b_DIWZ|2n=A5ntk3gthAB&GlygqP)@aQJO`3Oj`uYX@4qJQt;<H0Mf&b1`o
zo)RDl5m+UBuE&-^`&RH*o++Y9sq}rB@O)pEB=vr-q(itADO?-kZT4anjPxZ|!<70)
z7Ip+BqNw~xD?e2Aks6@sebk>Lbi1yV*R4ZfKzYOXS+4`|E!Ov|1N4=ZkXRq<B5kvW
z0Z4v&Sv(O7uoB1u(l+;wt&{d^+W1A`Be~6lts6%X;=_vJ--JnA0b?7FqEU+&#J9DN
zk>Dxi8i&N)#KJ7`%55-wuILhE)0(8%+X8M9AJ;U6dK0qrCdi#X&i4D8XDkTRL{x+T
zMs5VA?d{l&hMf+G^cu4#kca+F;?D%1P0>ed?Uzw-xb^U&jTx1NTn6JW0~3b>J?PwD
z(Vvspym?EZV^N5Yk{D9=lax+gdca(G3GI!7VWz<k9^`wHjN0h{rswGd-$h;keT*!F
zbkvBUBtF(e@Jh+yA(VKYfFTC-RReerF5|UGAi!Tfq}u)H51R84LWosaS2s?RsSUW9
z`yboA9(u%mEreH%JR@8zfj$mG(ZOmuBg5=pa8D<hWHBXH;ZU+4s|dlIz7s#@R;kpz
z8<`i_dOyc4DG<3*ONv2QRYi1dAiALJ(xIY(;JAhT4BK;GXnV=06V>xIccOBT$$(na
zT=3ca&R0+Qd1YF9e`~G-2fQ28e#zbJKG3D#seX~?WZw?1@2X+wQf7YpF|dD;E5EbR
z?1;=!q=#|Ko!M{5BEmO4urWBAkr>#e44v)b%@@)zyGK?O4SQZ_V0$-OVf`rqR=H>M
zUGOtWsNb^TBQ6?}3Z&JWI&KhEg^NVu0(t=bjO5K=TAIhW9PnPR#4Xn5>(<xCah+@b
zquW_r?DXzRCD+}aJ0$i2@(-K|EjK?6N!tt_5)Q0V(wZ%?U5uR!C<LfH9AwjP^JG$a
zoIAogC7Lti0drllU`9^sd91wkHDtB&+pmEf4m4&9Be3Y2C_;j7K;Vw9oT1=_SsVhi
zes;_jHz?`)gaKW1c2Z&(KRR$sW)Wa0xo>-uK`knoFm}4_SgQ+nL4outG}zhU83-9d
z{XLP?d%3x%mhO?x?<LFf)`5^46?i7C8X$_J7W;^HRSh=<r$}3jUDWPaU#PZZa=CZc
z<R98iQs}XH`$oa~KaGT}OChd7-<gjd;a;ePS7baeU8t7qntiBJ`dg6ZMK|W}gMN=#
zC51=Z9xTF=1fcgmWI}R^jAg=X4cbz_zR=oUdVORKJM$hUsuR+x0Im*x6C}h8)w%uU
z^@~9f)s>F6T#$i3yjC4sez0bGtL5m8^UMeHiCY%LA(yrv(pO+S+^52^kj>3!TLzXX
z4y@M!ZCQDv`jnhV+vW2~^&dLy4*(g3EVq!fB!WLqK`~v%t5gMUF~IvbYrSzqY-Ow;
z+u{@)>U$I;LK5EFZvC{BA9^5scbOW!UgN_|Dc+y&VQq0j)3u)dve%%GKvsy4Avv$4
zQ;L5EwPq@y&{vd>qUSAN3!eRmL*%|Jri5D&;ieVyX|w<g`Q+=wbAyn6hL*f>&(iS3
zf74g(2WfZmvbDe%$stJe+;(BcJB6<5^XB4kty{JYs{$&{H*$>1bg{&h8k_-a4@a#J
zxbv)t3aw;eL%wScZ}`no#rXk#U7A_UT{o`-9%;h&2BY+Ci!+F-2ZtG=+^&APJ(Irv
zeC8F_?7e9y8<&TgJ-we}O(v_^rUIY28=l7Wsr38L^S}FVJ**=I4SnLV9zChD@ne_R
zz2wrDWPb^5+cy3Eo!itC^ia6@fJET^(=0o(ybVWbgIt`6Scd1x%>S%j%_>68w1G)*
z-K@3(E|~Fjt1om!c`-S<UMVbTw5UF0H<A;v6&Up6>c(IHrpd1C3%gC$vAK2@fecr-
zm9Jqzgy$QuHp&XN>FqFflPz;U0nrxHHn>64M9-i>f1Zbc>GAIpYR}oYV_;`z-i6Gh
zxJ{S>bBS7FL0%-8407WK6OwkftNx=+m7u36;bs31V`m-J2Di2O;8Ltm+}*9XL!oGK
zcPJEh_n@Uff#Pn(-5cE9o#Id|NO0H5`+hTb?wz?a-~ETIELO50IcJ}}_j#V*c4VIV
z<ba4}rD<VVOoOw9P$KC1XMzakD=H}u+LT7fd;58XrWA)!qX6v_v2{y56$Bk`LjJUb
z=5lQ(<30#F2Nj_f2XsVjkIMHqMDy_)H!xbax8}^T>I^k$O0NOyZwmPuDWL62^9h91
z`o`1M%-&`~m9scOz7%uUlmkQKk>)h~Eq*_XszZ%!XWdl9I(QrZhqa(%M_6LDZ)}w$
zoD7)a4PTvPqiDT#QJ#KI)E%~!R<{dby|@?EYKC(vnqiV`5x9f7)fJgp_J!CoOjOaQ
zj+?*!Y14%h4@nl{d|C*HF`;uc1SfIi>JfkkTC0rGZQ<NKO6t)?$j(%%?I)*^a&Z7t
zO{cI1V$It@(l9e0c6pR_Wds{}&N2ntdAx@=w&>cRkQhv^MmN|%CfKKvwvGEJGK42o
znt7IO?C<$j8LkI&t%poyx78e(*wEDM6z||VMul`91;?N3Q+cI{fJ#hIrEDyMMiP@2
zSn+!CpsKek7InbJ$u0%diYlYLnz<kLp2OXqJe;?vq$75g1MpI=t3l4brrK%n`)OKO
z%j6hYyrJ|51D4^6AX7|gwOJ?rJnmiZr!WWiLS=p<rFq?79|gE}6CXM52mF8gn4WAT
zJ1XWfZp`VvpA;VbBVYD~8u`;|k>6bH!2CskPoCdwbtnV-;U<1>iw2K>RrU={I$5Qo
zN~vlkd%@sdxRE|{_=3QxXrQMYl5zXhfj~?WJ6s@h#WDFJEqgQ}1&{b*SkUM1D{NSv
zqkH9w;m@{i*Q3l+&V5}ind%5I!3#Hkq(r>Je7-6^Zgp=`iaAay4n|yICcbeGnLjLx
z8a88HTn;G7J~UD$zOvybO91J;_BKcs8R&>8`aoTn?rt9>N%PS9oj+*-I#CiU?yK(|
zRt_k3X){eM&_)!v0q>O3Dzk^QJG0f<dJi)vuX&(i$Fg^;4c3#IZ|q-FXP}T2(RDK7
z@vkp~<@j4o+U!){H$DUyn_ToxM#UI)YAY+>KvU-D%e!4l#0EQ(0=W|B=AHFcB0I;Q
zZVbik9;q$)da#t~9m<Ad&C0wP*F|eZuKcickQs~F9ZtGjG8<?EEdbu2^4T0mQRA_e
zMXyu(z}Pop3N{pn`QB!R7<P2_k**!}^7bKT{bl=w<K$vDC-yxy%&+&57RKtLdYX-r
z^6%sG=lUUnKKIT)pEa7+ZGC;W(Ptg3GpfummPIa%^SWY^@s~Xz8#r>J>iCDKuUtF)
zpOZt4Ivp2gPu^nTY%WowUE#*64Or>h&hgoc-AQlauJ}Uk5N2SSE5r+}$?F1|^M%v>
z<{qzxEkr;Q>sY43NwQuC_GjN`cd{F-Y>1Rt=%ABEwlN;=8E)mKw>$R_1gai<sA%yY
zT%ZmE`9#YGNar331?*K3CYWg7OG&N+%s<25HS3V(%s_>9XhQPInx022pYp+dIbAPo
z+ewjh^>!>2Bdglyh4aw*Vb}D5XJo`yy<<Y-4wl({wG2YqJ(g%|f8u-nlv$s;4<GDz
zC6H%2u&bvG)gjAFYU{IIr-_HG^<2$P8a7nZS*Z;gYmPXsBpd6CLR_<rCwUedsZTF*
z5HC3cLy{IOF$QWITpz{?c009^zOorlDqc?!H@5piBmUr**)}t@;>mjc5L=<5puUGE
z1A1_8!>jpccJf&AvYf&A>VS<RGucYd<-vz-9an)_yje_`1KZ}h$?Xui=~Jiz&ezO`
zoH{n+Y2RoW)4ySMU(nx3?6vu%LdfapA7rY3(I#vfszHZ(T3x!5i9KXCUoET@TL7zF
zJF-QiKm#w_%PXRH5<rc`ekiDFqw0+JsIz4lW~zfsD_h;?S}POE6nWX%TR%X=JcU32
z;OuuPPu<XVS|&{O)5V<hGiSEg*V>=Ev*a80>h~k;r)*G(ZTLGcK4=5EFFQTCkXZYR
z58^H1CgJ*PW;01+Ss;s0)8z4RNHL(KE6cD5IhJS;{Bd||owt%LxUH?*757Z0c(`An
z!ifT@6)+V}E1=Qz=TjGCOrb-S8S1`#-#Rz0mDNRuuU_|{D*aj997*g%))eQ~aMRLV
z*Z<{bzOo4ci50!$CWQ!Tas<UJDwpQta(g7n$^As&q*%m?V6HgSz)lQkQ7;(^alDCM
zY1nTQcIvWy)-)!8<D0TNXaXZoT?~n%`0W*XaF8U8ebB-aOY7%MO{w>7Ra-ZYJZfxt
z7a5WrQ+*xX()TZZECRhC34orZ#?sTGqJ@~r!rNSBey#sU#rZERu^{cTu0p^R`Gmh+
z3H<g&0jL-)nC)=S6pvi*tP}g{g!RSq@p|s%#lge(^eK70e*co)N_*w#w(7*OhU8}2
zqy@3sEWvVi|8zraeWkl-w6`>g>zLGJ(rGVEIcW98NUQ0^`azrDxqlr4dTnUzyMG=l
z<k1w+@VInz#W<9$wug2j>f@6gX?A<Vw?9XHS7v+cf9-K<I8`)ggoFbho$QG*C4D;j
z^j8<P^o8BYJ}_Gx3-l2o;DZ<Tmcc^LmP!`k+8?MG=DT(fh&)hhhOjt|VK%GS30B=x
zvBf<-r5<Vwj}_!^`V*`@(5$>d)+UtJLx3z8*YzdhpkcmnmjBx{T`3&*jSWOA!7LR6
zkB`$mz+XRu89Ic6g;$Wr?wd<eTIBGtuu?{oEvc|+*<}dg4}{qtom1zkZ>SuqaX5?Y
zayZlp!fn2kk}srwZl|43arq&dMt6&@E=>|Q%gk@X-f;jWH(?fuD~Hl>;__|(bZE3T
zu#A4BfT+>H1$HLJF_SCGviy#pnOt#cGD^$}ffD<SJ^qE;6XYoYHMMoVX+A!g{`bk#
zKQ`Z)5AzvRQI9%AWHb<N;lr@*+GXwt^bG`tzT%3pCoqecfI#b`75SbdfxjMZyv&WO
zodHv2HQCy<o`44J_4NXvu`fUn3vn}A9&L)vzKG01-n6KGv9xRc-P{(#B(uHv<at3K
z{T@w!!;<<|o!cSq(rUR};qqZWqwp!3L&je{f(z8PXQ)TncI(Ek7Ao-+EsayECYB$d
zQ356@&9rjyIB{<L@VU-p>{lk6;3JKAZ|EC&-t)<TKg*4o$67NmCrEqiVC{V<tRp^v
zG*JgJ#gbxQD)M51PBw(mQ~!`{f~0NBTum)Ob$C2{w?r@DNx9XfMmLFSH=Ho$@3ruc
zPRnMN3e==@D#hEH;r7q$ynl&M|3%hoTR=5H1w6xGOhuCF>~BhRECho@#C2~))TLV&
zs9Nbg53_)PHK70_k(um5V1uFAr0>lwS(opgz=P$H|An&a(?iSnx}#W{rST+P1CrIP
zlHWzINtv>P$n*H2`J`>N*{s>5=Yy<qt2&>F;~d#mR(JN`dX~{*g(TLq?c&Pw@ic0M
z5Rz5-!0wCx8Vp#RfiY;PVr<M}w_P74!mYf{!&C9*;$!J1^6+tngMd0rrN4ySc-7Do
zQfE?9bLc9XNc`c+*Qc#;R^5$C0<YC!&mu2}LUj`c1QLKqqTT5+6nsH8<dfMILYbLU
z`%c^IzGNlIqc@{=bN7*HBCqOCZ7#g~r{$B>R}Q?ClTqm4Xw%c1MG!_{w!G|#j}qOU
z`ujLkxz%J`e~+zBB~qjZ*op1?$ekR`Lbq?eBD?$c?mvMb1yHN+KZ%Yf{_>_<mi}4z
zmss_0gln0wodti(lNFilOz>V~5kep~k83NXm_y5_&pejusCdVk)mz)6=a+|gZ`N;a
zYi*C6ErDVf;zzX})i2(NqW3~1ogD%bWLE5pLJ5Xjr&B`f`i_{yP4cG>lPjW4o%7ZN
zfMtcw_8D;>h_=|roAR|4s3@YvqkV0%XckJGiWq%;gbrq71b_w7^wSfR#WIpUHLyNn
zlFJ9U%JAOKC&eC&GMY@F_|&jiL*B@F-2bY0xe*(#+->l~ev*)%JQ)>xc2+#8#D{*^
z3~7%i?+8?(8#b0<6B_K`ayM$xfRc`UnUM;17V>mO`R`L~6+n6^(XC$?k9pwP?$C*V
z2TcqN({=`R%sBB`2!Yw(WZ%Dycan94|J|{a?32f|3!ysM))WvvmaSZeh=jN2>4M`S
z|11IA{D2BirHVpF$UIJGesA&VLss(fa|3&SR=UPLOx12cVC#=;2g`r@ZvGK4{$($0
z{y{as20Xt-rmC_{cDs4S2(H2J%)%$xG9J7o9cUh1*?<M{3bfawIfx<9-QI9RAz=c|
zEw_*-$bMdDyX2(s>;1lvcjhy%7x3l<34~b%T46n_6t4sQ?&PK2ue`ab_tkx7eeW=7
z+j$FGVP@ulv2vP=Ghv}{HVJhyIDi8^&7eYAAKX{<@WFDK56QdBGM(|e_n~9qzY4x4
zoMUc?C0$nry9SHaPg#*R0<K;U;HEa<#5Y_4S7|=YNlHP}f0-1)L>&s2(8t!q6~~iy
z#JrG@+Haxx5)m?lTia!Z?2U!<S6wELEN2$0l#^v|1NWtLs5oDuHt{C5!x5bh>qp-5
zZe?ldFT20kx)q?T<)3UhIRA6>I8$Q8LX)Q`*rpu-S`P%v7+NRm&3yh|Q2)6pO>@0;
zX4By>v(LX>=Ku5Z(uon(fCx}o9aDM9K|VI#IRR)$`Ea@+A!D84dQ;f3Hd+M&PHs5F
z*7*LWR(fgFN4ovBp?u>1kO7ygZ2M=y;8V~dS>QmWGU;P{!khPv548r(@2OAON#zQh
zDQv|=enh)x=3-{zTpbuJYW2ZRy{2G_1NQ;o*$>S;N<p=Zn*eaF+`Urf(0>>k{}E6B
z4+!Zd?B6kSYjyDJE)Sr=#WVRBBJk$X6YGqRM7IwF+U{cYIf{MShOB$gzj?XIiblHS
z_g-K3My%Qpi*3*L3|n71#<=;al)XT={|5;1e&jQmFjaP}e*Jm6Z+JI%06~Gk-1OZ%
zb{V%e@1sGEED~%d9lsFruM&yn7-R5H2|(u$K-9F_UH}bv>w%$EpSrV0hIe}6D^^=r
z->AP$6IqTQnc%u#*;p|5UlEYVVG%F;>l3v3(;<LhRQZ?rpz)!@-V*AmT}jSA3HbM0
z;{W)c|IJeZ&7e`Z+${(iNBL?NtyL`CR7=)t@TWq2wD)1zN~M+yrLGO@zwY<%x?ik)
z2&ztYSc^Ry^(UTe6I@YON%@r>#eDHv*8)I7zfXH#8uv;0bDjm8?%PiHjb1(?{eF|>
z8oZq`Uix&Ig)YwZg&V141@ux3NPV8<56nndf?s+g2v}xvUIH2ep^rNP67=73u4L-!
zpg;W<`6a41fDFWw9$#F^>A^m;8S%4Z9^IXBI%<EGGHFtYL>O_4#H)t`YS|j4S8QWp
zO;O;tv6bn}-=`$X=F*P$N|tIKsX;<N_HfFX&&132(Uz(Ygr_=W0fO_D)b*mv=E`{(
zlWf!+f3;gn_Nt=v&tNOl&}Kw(w)^Sy6h+U4s(ZJ5;#_u+&(}(jFQsYpkt7-uSU!2+
z!$VWxc$Z)$Oqup+#()oRfj8MBp(QobC@$^xRVmrUw0Ziz{J4580r;?;zN*iT721Uz
zdG?yvH+Ehia8jIROYRKu$Y+bT(Y0x8NlZOy=nrd@NBWR{@@`Q<o{lg{D)W@GD4wqy
z+ps9MTE5bY0`~;8dMrPxNO@|R`gq9;<*k500-l3F$3YlyPQZiQ#r@MA`=1H$|K7D-
zLY09p;;Hh5G(^!xWf<cY>P$(I+(gj|is7wI|DLJ%Put|ofzd?wm*-K{+L|E3y5HZN
zEvT>9|JxG4rHr<(_Gfjjn;$$p{Be{NbP(v^_=c0tmWYW6ZG!UjFfSM4mTv3I^|P(I
z-S3S>zO+fjG{x5T6jx6z@I5lPc@|;rShjpAUhs!S`8;-*Z6jChe$Bo)E^Y90tRVJx
z1c1^uc1-w0d+5s9;X5x^fEDY<LwNM#jP%6eW?EgNcG@?yoN4F|(3@vUu}%2)ARISb
z@un|tRuBqD$Et>AWPtReuGY;&UNlK-?)Tf6`WJSfW4K;x6shDd&hBy@Pvdo;LPzUv
z7puRR*=uKO{BcRt{jsYLGT$Bf$ue2+<vnhkYz;N!up{w8*?jw;Wwjl|xZ-VMfxILB
zp8h=T*4*0rqi6>wYZMou+?2F5dfz8f>x=lN)Rd>abm1mn<!pP%utOm$?ki$Q*J$2O
z<`@ghsPAdz$jD5^4jpzp8nt*mMhOXy9J}0c3C+?BsP5+M1O*`YE+_GKUl|Kam6Ncw
z@sK?4@HHIi!5p*N`by#&z1Zk-J*#((W?YENEEr2(Nlw^vwBRv>xW0}%BaWMb`{@^a
zD>|cn0={QQGQD!naQkyI33$AvpYbgD@1-IfGU(@v7r1bK-tK#A4g><nw4I7w|M!`&
zX{b$+GCItft$cm@g-vjx8Ti^kd}?4p*JS&b(dpkyR{raVSm#8zdiHOP7N7+Fox8T_
zqPFn@8b*p#!n^VAiBZF8u%jaBII;ns`+}qwOKnS*s-cyDj?*ZwUd_!D^)cDax650S
zLA>_J_Ma~zr)AKT#*<`m!S(x5+l?@<;iN)wbaE|J3I50cSnG-aE!hz;Jd~7MYM`wf
zzf0ePhC}GItJ~XgnA}QfJtEw6C?RM!7T{#L`<xUgmGM~T@fu`TaXNyhG<B#|A(<M5
zVOFOA+Br;lm2;?68nrA%Qd{$(c)bO7(u;|$C(t3>F$hv`jUl;QKHFYkzShv-1o?a4
z8NZYZ`;T42DPU){Qjz<4DJJ6;nNtyAZ4Z#Zo}9u`^LfCe<&3O#zR)Nyc$k-e_jPko
zrK@_8c35wt1m3D@CDY~4RBSz<^+jjBx2IkhUZV@V<yv~WufDiDPhVYQQ0VA;-jXJr
zoEX`e@pZXg*1SJks9@Pq!=BE?4#tjIW?d~a!&VxXEpTNx?{(Zc_a_ew(2C1fF;G)i
zcn^e7H~ZiMpdd~Q`k!=o{SC%*D;~QlhmW!5u8`8z=2o_&Rs_Z^aD|Gy$1ZcTL<{hB
z`W?os>OsR?WlNZ=8xG*1RQPerc=tSk=U!kVUIa;e1@`!*qaPJYH(;Gu)poLluAEJA
zB=~mNpfyG)%<g}Qbbo|}A>2P*PND-0%M$ORi|(V!es(^7Q6q#CecfdT##L5U8ect}
zeE!D^{$D9YS8I7-N9W>(6e-~OBpJqY-?0i7>Ta3b0-$qRI$6Gy^;WZ?PBZ>~3k&!T
zBU1d{dNs!k(Qo0J>~1UoKQL!J;u*-IQoeXki;sCE8gzwWuwFD&<YaOwU<_Hm0lRt-
zuN*oXPJWnr0KMTZRhmMl0K1fqZ3u2Se=9PpU8-2rT(p8FyR6LNqSF~j;zyNbINWR(
z5h!Wt`pJd1{1TH=PQmLxW=_8Py*_hg<|?Qa=QgsJeDd2%-&udWy;vXjz6UM7acOwf
zcsUXSGJBHS$-QN0PSA_*Th(?sYRA1F+}N@(UW>1OJy5QTakjjDaQtHGt}ALN8t+vO
zuzS+*z$8|Cvrogt6>_=olcqIX?dd-DVyBz>{zgs?LozD9_1bawCYtvCk(gDk0dr>}
z*0wIGTK<i=04EQ->!O1!+kBkez06X;lgi5=pY4TJJsZSCuc+D}1rvCy-yHBo9xue(
z8vk}@db#5mMivx|BB#tglB7>QV$i~x(C@gDb_(zZzVW<C71T9OVF$j}8f3-F)iuz~
zhqMVpeGH}19ZR@r*=dPK3V_vq%M0)%Fg`ri>8Gfb0&6o>b4J1AUfq);pME@i&CB_O
z`qFPk`GluZ%~3V6--&9q48HR*b9(q=$e>pBO>_-tMdfHxWcWEA+K`I))2i@~__9f=
z+66lmrz3SD)<*A()Oq|JXI7nGWuu9;Qd$9egCFxw&@<z|SxP~RQh)Us=m@vsx84za
z_$#fEtAI(%^MvL!hZhwQ@&$qCb%dh682LVq`LInlULuR^2<S(R586W6u#Qo;)r#ZZ
zE3v05uXeY;WNtxi>B`lAe0WcZ(G6^)XvK%pgYs}AJpfnb!-J|54;HXfK7)D+!SR_L
zRIZ=^`bF*Ho!Kx_Ye@Ad`OBlf_m!J5)4Q{%2mLTEg?Iy~Ofuj!@@ZRJ6|k>(|B&-q
zy!z;^$ZNw-rCc#G7Y&5F6QY0J+sh*%br|Y|ZmPPKp^=`AXWz`k;vMO;(m4>>D0ycy
zee5qAH56q9huyD!53L(RNyAkIo-Y){u_vRzM+|)MO~uaoE9S-ewZQ!&bK7^eiqXy|
zpx8)Aqhu)pc6@3l9W(i>l0$|0PX2L=1~2)@>!tC@(4?}hS`^zb)hyxbGw?~i>J!q(
zg$}qM0W=$8zvIv;b}jgs)fM=5+p7cE7cF}03|_T7$X;1quLgO%oA8rlPpF$;*3s`b
zUL8JKY-=t(p6l!So=F8PGYm@zQBId0)ww*k_?`E=r=j8&Ui1PJ25+I|c~0^du{IX2
z^b_I&U(MO)PcOTj8*z`yH&Y@km2B7ThP}h-ZVl6rpIWQ=?`%9P)Hmb*LJ!cQynZ$E
zzzSSnSuuOEld*6FD>j?|V+BDwH+qb@fGd1szwZ3YIKRs^zPjf2`=}yE=K$4?rz?e@
zVQ?1^(1suq*jU5glk>l+Cc9cIp;5^ZlxCRK`F8=e&hj^(L7X&K7cnanSM@uraPfOa
zIau*QC;>&LN8}@W&SgzWEu4~1+WR6*Qo%SuwyAk}O{T&~ZkV63>|P&)kigr)1~dC0
zs8kXrumcA0e2<MWgev~}W|Nb`!5SGLNRW~2wCCS^-i>}A{_6CxDERSW$N0tA+vzs$
z$<K+Va+ug<H|kZ=!Dx7-I^MIerIGUW9`j?VH2zNg>z%J|CWh?sFu6H#*S+%Xjq_Ir
zc_FO0<3EbcFa4bf#0rewVi)y^*&;uHFUGN7+65VP#sBCpTI`%^|0?u7(|EZAKFS3I
zw9)gRC|J3Cq|*Yjf*iMGpCu$=!;db+UZ8z+&_eu&JxSdbf5Vsa4OTfejUUCYmzaQ&
z*xeTi#hai;p`emaRjbKIoiDMkV!o$as|#_bz5#Ju$bmG-9MBQSmZJi(^lL({wi^p8
zt(yA!jjzicOTHUzY0$w2Tx8*KETdY<xT##SG}tsQ7?1YigS?EY1$E}PjQSK94_615
z5YaXC%*oRg@Oe6i&NBw*>nHTU8_VMwDE^k2C#x8VX{uPV>0#b|YzzTw_+4D-VeZ1p
z^y+kY-gdEVpu55o>O!*R`K~7=e3YVR7sRJ|^ylj9yIrIGTARe*&E;ioX;lL4uUPLc
zzo$0~S88mQGEl&Pi>WS^_h?pNz}N0ErWbGSl#2p(!(<T(VAWts12s0iRdO2}ab;r3
zDxn?TDnn_Ch6jzP`9tg8T1jCsC=xQo`$c@SG}}1)6B7mQ57d9WQ2hUXdgskdfmTw0
zGC$dhK2#3m#PvD>ScMEDhtDb@S#i0A=FHm&Cao{spo%kl)de#%4>DJ``d1aSK57oD
z4sV^jbD0cbrpU}jK-OYO{-J33cI7*D&bWV0oJy-aphZet%}k}+ik`r6&hNGPY5Rcj
z>@(~Xla-q^7)rx;0{yJ?#agEmX=?$@*utzfb-)4{Fy41Dh~_3TMdLCV5(_>)p3V4%
zZ`PW}wVu;HalL73>ETrb_}nFdrsZV5I3C0PWTwm{T+IJ-wUuOyN^gNX;+j%>V%%-c
zA8S=aCTHR1GyU5Y9^w!@G=R_t=X!UQ12ui<n9>5)X6L`n+Djz<RJgku6_jNeF>drR
zy&~!EG7(xAaR{Wu=_!ou>>iUxA!f^Vtid_Ws_RO}{ByW5Vd~?8!rY9C{bd?tZQ^(o
zetL%lwyppC$v<S%oixyhmA9w;RFO^QctFmRpl}FQ^zjLgZl4-HHO%2>&O%rBc57^B
zxRIbrthM9iovz=-IQA1fD2vDGaebFfB=_Wfv&Lp|ZXkRv5Vi5{s%py!;FhQI<L%H&
znRq`1Rnh=*$U0g^95Xf8ZOV2|rM&M>Pb%++#Ct*+x*VD8ZEf!rC>2h>aRC{9pWPyX
zObJJ3R1G78*t(#;!WYkD|L*dksUi<UPoJ9mJG~|@ugcan{snC!Fj;}sNz|&L8@y>S
zToRJkA}5gWZIH{rUwT4{tPP?dLT<q2-8ZQKbN(!k9+JkK!E<rT+D_Es2aE7BQ5&~&
zN*0#oduCah0LYCc7mFz?i&R)-`^-}UnEK<RF-64x%f*0`sHsJbC&Gm-I$9&oLxe=@
zbbU@QW)v@VOuC5#F~E$4s=a$Ys_6p1^XvN||07C!BN%aVOQ#A{e0C#02N<iQiLvu$
zLTMtt->f8(k=8T|ym6yD9)vj{qtjVn@mxOP03!Zag^W6F_xTTr>0x0PyOfo(odbN;
zY}NmJ$^Y98fmzb!iXa|^#MFpHtvHbm*ARK;I!@~oZoHYa_J{tdGNVpLuJ(F1+`o9I
zXs1J6bY<2a*g5Om3IQ(M+ljs2++yknz=%g7r^^@WxdyK5Z0x|*k{rEE5Z;|B@QbIE
z(V~c-(p})ZJoUrn_OCJJdh>0qzij}4OqwL&)EU2a9izd*$7?TeeVgsq5m&){B1o?q
zW@;ooIe{VZdUg+<u;K6Bul)rcTsmixM<?aKIYIHVN6;9Yq^N27I!eihwl3OsUM>kf
zb?Hf5m!eIOpfZ-o({Q{bYDe*57E`x086L+e$?hpOUhVn33eP3+=Y$jhj_ik%yp*`Y
zbl+S{so=2aZF)$l<^<^t6g|Q(BQ2l5a2f&W0^h*r7Z*JvUr<^`V(8z(<x1{aG?4jV
z`itVn{N6t>7l~D#__UZ=jKFPFH1NTaxEhMFZUvvZZT_%F)Gc~k(RMv622+f?+@7d7
zM3AbAHa{P~`vJI`tQsLd2&M(J^WD$s5xWiWatp0+Y(m6+L*Ov-@uZ^(DnEadekOTz
z=p~OfiJnVB{^Om^msN>?Hwoj`AmH3YjZ#3><YG-WT29<pcPbok=%s5xK-9W<EH=@l
zhC5fQFl5hSN*({XYil7%E87yCOnK?>k|fF!D?6m~gKHG-$%tk_uX@w{8Y<OR-?qT`
zBprU~{$x?vZkT8=ER~6V>;MKkqB2CXJgWOAvHI_`a3@p2h<Whk66PtI_#&LGog(R3
zj0-Jw3R%Y=nwg^jgUt1=L+M|L6At8Bnk|UIJy}*qSJ-wARNPrzJ-fC#h8R?1r=17(
zakA{FfXc>469*tVSq{FW2qQ&DXhd}tRRc*0g4U_9sMv=DAC~Y)pShmHJre8ho$B0&
z)2iv>Ol`rV>IQL4KBqo@EXB!b|G$v_PwRUVh4E|^X39dagqyeZE_YocJf}a*5g6$r
zgZ2gF1>fqfe#5}{E8wB#G;uX?)pNwsw*_+QDd+%to)pZ1>~Flhn2xdotZGq^1tpQd
zV4^&X4ro}f8oj(ajY1H2^b8>Td08JfF=;y_t?m4{K&AB|Ll&=mvwksrwJ*fpe(nD5
zw?5b!^jU=~=o3vO*T&mGUcNtb8SOQ;ILO&TQT_J}MYE(ep6Ckza1a~PcSgbYP_e*F
zWL?cTY`LE7&v>K$!x<_z<1`r>$M9WIj49lDq?Q3VcfbR#p!6QHIM5B_vizgn8~_|6
z1aQMj5fz9XW)y>M^Fk39Gru0~Er5;vE0~f?wB>B&VF#{P&h(qB!G)9}+zhC?VND5c
zI(OUhh>vSZ2eO1@e*RX$J`VuzUhk6z?mc}d467_es?4v>1J%QXlSB=D#5><@)*WM$
z@r22}ZnI$i#2R9?{>sb3YXN$pt&3xn(!!CQ-8~<6aPN{gs}Z+!4LB7yoDgG1IuvZO
zJmvp(lk%e6@Jnb)OCY4+6_L$PC~7`woSr7!DkU@a@OsMCotm0dg_W))-j*kqQ$QmL
zTfQHb)U;lf7W_4xIaijzX~pdfB?+Qh=da}>DxbDns}@vT38=g^6<4UnMA{Gts=`B0
z|FA&`9hWxg*jLjv56m94mjUS6Z`SOHM^%$k7aM;pRu3y0@~&W?*gQ6W7bO%}&y*Dc
zXuvcy;5<lLM4T#7rgS-ANw(PI?8xr-DQei=@4!b0To6Dqf!w1DA__WN(R@7|K&$fi
z!yDyN@YIs^A+yy^EEN@95ni(r>jHe4V87AF|6#1(mFBo7(D_?DU1I4eLdxOqq~+h_
z9{;pZ|N5<$={v6~fYtf8-+ke|(GG0=L)x_w{yU#Rb|d=dX}^DUR-d*%ZnPJv$FvDO
z-*7Q8o<95Bp6kyt<~XkDckV$Rv%_!Yy>W3pm=fZZ?)^Yl8*o#?6bTa)L`%6`h87C#
zs7PR!MzltWrhB419@H}p2W9;re563U%9Fu~NispPBk&VR@#Q5qY&j+TPews8d@#!k
zLv92=W=gdEacKD|_d{!j^GHfy%a6f+eH)GDy{EVkKb_3z&1HOiPQDzelGU$89TIKQ
zNMH|qa<&PBz7`<D>``bUNMBVevLv~#@zK<bE269r9V$cg7vg8s{zPVFh{Qobl50#0
z$f|~$a(#haFboYq^!GZ|fU^t3ssj4paV13Q{1MpZiDE)Gtb5!NdVzUZt{_m~5O;A$
z1h#Gt+SI;1@pt@LJs6#E!XY1r;CFM+`e{PuM0m3@gad<Y!~aR->emWKQTzC|<@qq5
z!kHz>E$i*&(U0qfQx5NroCH|xz!!n}n|$MP_*~Cfl|Tz0ZvNKkX@8<MHhM%iN(#_d
z#tCNX1DZ$%iYx_6ybUR)6u9jen{u(^<V&u5gZ}1_^jzIr3XG0>R6*kAk)DyoZ!BY*
z!V>kgAIxBn)&&Bf=U>Jl#*{xj%6eIDq@lPG6!TR0V|xT&*`plp_dpR_6JqSeBkANX
z38X`Cy-RM@q<Sb^gYRqg^f4Zk`S1fpd3!-oj4JL9Cq5q|JuOp-`{r&Fa@DnOFOJhW
zO5ko6*pF5h!LZOoHQdwpJ~)s6^Af7d<Z~Zb_uxLXOwNKC*NX~u)j80?vA=8B-^$gc
zFxOpByc+%-VuxCu!JZ7)Ab%RXFcV%CB--}iL!Qp<EY<Oh9X0FPL^^KDs{itGo5AW*
z*8DksASQW2;(K-gX$KuoI&bH0q#PH&t1Wtz?ZLA1@mt%KC|L0~NLK1c#PB`$LXyTL
z^YEm(lScV)ZdlFx-T|tQVVeD$H0;``{NG@zu&$R?sXw7*cHG?arEa0BmOuGZcw2rc
zV|8cT_)mkofaYd1d~U{Sv^x@5=%*au;oeGQM6z@((1JEg?Qm`8l^}2e70Ie)9~Db)
zScZfh#_Hp^<>SL=z|=}+j_=p0W%FPe;`Z$)Vdee(Xc@PFbv;Zyg*V^Fk)~EQf)-<!
zH){xLY6`xV{g6<;6pVi>Hj$mxHReKOokV=n5kTU*PqS=*YlS~Ci(-eTjlXRm$RGYW
zqDGATQ`wxK)x?DIM`XRgc-(a?L~VQ`B;!GGZ5$;Kf-05l)j>)^s*yo8Yok6~ZWi=!
zzcqS<7N>@}v&rs&>=&}O^D<0DLFlBB1AUfBHj{MBti@S3iV7<eTZrU7C+t`y-uE&G
ziViiT+-E|eW0B&i#l^^3I9%{7rNQ%|pv4~SH>{r{8ty7b5UUe#@6`D$*h(XxHUPnP
zwEpg*6)U)(4pzl67l`Ea*u3xeOAF*jkL$&P`ZNbkGo>*r*U>_z;iHxS`9?^UTIiM1
znwQydA?YK#R2T57uB9|}&BApJqO1-eQBB*t1p=FU9ecdgPfz+y#bv)4wU#_NHw%8q
zQ6-F1CKV>w)Yc&sc(Wv3lbBP%fY+EL03bYWo?A1o9dtJVG^=qVNk4zQ{S<1Q$ii=8
z+5}g9oWFRBnCi#YF8q0O%EQcx3g4`SxQ+Q)lBc6HN=?4PMX7T&y&a~^{Hb{64-)h$
zuIKGNCWMytp=DQSk)=EZ@tL+eo<c7jX{TF~)U*61=P^C5Plh^>IiV-UnV=Qq`)%2N
zSKpy+XS%l=blg)y%TrU{1Rk(M==0w1K1<v^AAO^LAA4!Ov0u1Abl`UwSUw(=9U=k-
zTZImmg=hlle<b*)mZeJu$Ly5jaOoJKnOXBhN7L*FjP2gr7fwn~o`xj>Wf6>!5e{Ln
zeo51}`HMDHFzMiw%YNkJ#F?N>514sA>y2=8M6!adU*Oegr|01K9mE&wWRzmqzpLE2
zSB9#9?D8>hCniN5GqnbEmA?(mB`*b>ev6LcqU@b5Y0swW{qc13@IZBZ{0W#MQs-)j
zQRPo>{u!8JCL8m7cZdDiHUq7x#W-*#%V*2eA9o)lI1wF9G-23GB`!MYZSP%usWXjP
zp0{9=$46vy`NxJc%0+Ic);AF3w5O%tGR^fnif^5CSC~5DY%#~o)CP}lNtAlh`q8gR
zi#0a>|654^&%-Pzrv-MBBoI$*<@Ii>$|(R3(6IFR!RQeJXt)S+$s96cUkNGNP{^KC
zC)#~Td=Dvz`s=KE^xeH{?+`saM+LA>q%<P|SZ}l=U}TZ3^7`u6vVj1-hC^}zF;6d!
zKeOEonK{LlSh>AMYxe@L-zFyYk0dJX1DEGu$Wv}ap7%HeSM+ly%Jbwxb0ds;Xa2BE
z7-4><?7J)*b8^2i`-Y(-LW&OVp}L5pHE3`D7M6r=hs`jd?Nzak%mX8_6VKr4eT9~T
zdX$NYB0gC`Eqk`S#1)9+NdB=n17K<nOFVknBtRM{mMK-2OGh)0zA?==4dKk|bb;dp
zk_KkS9_G15=lbR%RcG7C)W<17a27Xn^n1)HBF5uUd|DiSd3tV7<vH;4pcFV}b^jS-
zVPh|@$tyf+gwF->65XFzR(B~w9m#JWxaucuZW{7h>rq%0J-BtEIf#*MN(kpvsqQi(
zOsPq_P(#FFyPd|-IcvusG%D-G%{=m(3$spc3`0K=sF<3G>LGqhoEftFilv*@A1M~N
zl*Iot!eD&f)6#Mkzy3fD-~;mE;(#HgTZ8+}cf%wI5$_!ksQ3s@CHZD1kW?LV{-mag
z`+AzZ#`R)gYa6!Yix$!=+UDOgfJ++O^Z=^n5NQSgTY}+33QsyC?tcLCkv|gJqfu?H
zsFitaBoWf6yj9gycJo~aSUK0Cbxfs!O%7?CqzQ=T@_(3}Ns)a-G!~9fv~=yB5e%FN
z!l*)?`6jK7V*Sbl)BJ8>1}%|mW$VB`WKAuIvA!>mUyKdd8oZm-=Xyf%V0Yz*?M`!<
zh$<|AaJZq+=p*upmrH6jBstKgR7E_#%SnPVAjbfPjA_3W3PZnC?Oj-nTJS$L4P++E
za(YzN$><fE_=X#_@MA9(O7YhzJu<2B%<aC#Mtod3dk6@qR;=1w=>$d%6N>ear0_S)
z|AHofcxQFUfCZu}4r0OyeG3X>s^|~d%>3u_9*Ow@X(|U$*N9<F+Vz<Z0b1{`w=pz7
z#&&M`V=Iva2`jbu^@#{cWMQ@`&D9MKsI*~p4<8+EsA24o^nAmece3~hy9~m{UzOqa
z>74g&5VM+dJaT8AqnO2#{*$c+Q`+_X&Z`K}@PKjuupJJE9oS*)zV=#Ae#D>_DWiD1
zoai>Pzp}A$l==wqo!h1b_=~ycR8MC60`v;=UF+g7tyZQ4+Q{w6h?k>P*_t~dSNNa_
zpkLd><i=u5BqmnB+BN)l%#LoP){rdlj?1ZyAa}T9cK_8JHyg{0ySKV<#9Y_%D$3-P
z^OYOObWHziX=c|5_F7`TGff@s8KKkocxj>{Mg6ZxsqZS}DN-`MlCV?i67a~3#BGLP
zu>g{_4huJe1h<gYt_v4}BjQkGYt2H}hTOtfrG#IotEHz{R87xINt$CHy&NQo+d3Rb
zL<J%z@ZiSe#JYRkSwd$Gs1}j4+R>vGG2B2GrYvjYcx=XfPr>A_ZF`x8mmL%Hts*(k
zMwa*C8k_V5UCP9PTHSM-LFL;N%R)k&zn1{9qf+=*=x#)aUUPI5JzG`Z?Sz9%fJ85}
zh#D-RZ)1vn6uxP2Dh!u@laSR-Y##zXKJ2o}A<m|I(=hKt#?&I7QqO5_=0<+S{`s@t
z+m|T|^rs<v&-j4ul^E!5*3Jb08#utMHM$UvBm1dxJ1Yk}86f5$ry1eb-<nc<0xz!a
zVT}es2T=@8U%r~ZkNG4TD@<SGew<`dksh-f3W@d+Og<u{DVP->MJdzk_h8B#h!POw
zs<WSQ7G}*HIiRW>10K=N*0mqn4z5(<5m<TYG8L%4rKi{_p!{ZMvQj)vUCMxXomA&0
z7E37!;2W3dJQMk0fYkqKT*Qhj;Eg04S=&0Xq`MhRj=vwmHkw{!z5V{L?98;tZSK%o
z7PkYt&<U%e?Up9ClRYg)3zZ4`+(aBFt%&{orhvtPD>wT^-PI{@!x-ymT_l!N&n^)u
zH_@K)Xtl;9dqQr4+t=kp6pg4$uIO&q_O*|<o<g(wrVfAF!Y)bk(-2||KX~}RC60R+
zLLMqccUdG|ctsT1j7Dh=W3i!G627YHNG=FFkX(dU#nLA@eg3{<kva<XdZ-8++Lo(`
z8Wh2K>%&nqwuXB9TlEUV$ElzdRgx|8ASwav`-(V+oCv8yL-hBq#V?YMX0S_BOl*EW
z#ICb%?S9a`Q}3+QZ}%^eTG{FUCaUs{F84(q{bVEk0eVF*=o2}w9J<{(VG=kzh70ed
ze^3T5eW}~0hOiEdMJ-!A#X&!H&FY5<SwhX1!xUL*O;>5t^Bddjm5&HGKW4r#Fr*-j
zt@q!tWv<oGK>QFT90Mus{^;q5`xs{h-|U8Z|C0dpuK%N?8TseWXTjxR7{~A@qZtfe
z5@f&K4EWY~yeV%Ej{JI?IXqH3F;Q1zKtkUykHU1L^pj-Q58Hb$N9inS7fX`3{6U6T
zyMt3l0Mk-v9~H%dH1DH_a9Sp!=8YWPn|<&*wFZC9#-S&j1#ZewbR&GqRe8u0UaGy;
zVK)HA`IO5UVpM9aT5(N$ukqc-yh#skW7fz+;q7nWLRGI_NIzv&$o^by^g<P-_7U~P
z$CkCaIYhX}SU)0^mYu!#ZJ5o~Y{av(oQC!_l9N81I0U>zOYBiTZ!NbY`3pbb_1k3*
zp8G1q1Mv?99T-Pr6TQ#GKBCND-&lgWdT{+&q)8uRTF97g)^J-cllcSQm3$OTko;Z_
z-s!^!Ez`wlOHBGS@CurInMz3#L_X8C`%?QEp;5W8&dr;>R)l$QUQGLC-U)3+&rW##
zyL5SSkeR0-8*TS(wfnUT8ijJztgcv^%vbbK#oCVf6M7LeJAB^9ta<*v-vbvVr9NRw
z-TlHL;xle}mS;MZ4&HWAAl$)w|Jsq4-I>NH9rUkWx^&#`Xl8f2#y>m9LpyqC?bww6
zRO3IV8bvP-%=j9Q--dnRh{<4kdYlql4fiy549{=*dH{TagR(eM<r9DJ&$~8>0mgkp
zo^v8YR4d7M+`qk4k8x_Wi8faT<QxcqcxoM3ED$ei9c=XryBw%{=RaY4F1w$|Kz#PG
zt;f&?oNu5o`bbqzys~3Dy1OiqrsSPS+>s~q{q1fJvM#jn74!{Rv192fk{Tc4^G1%R
z+V_7vmEZmPLPu1T9ke6~2Hr1%PdUu6QsQ*dd+7I5INM3W2?#yQ7wywVK>ukEf)2Hf
z1JK}=>Ae58*YJZqaIRLpr4^&Ce%qP!HFtllRJawQJyM?O_*cfZcEfy-xVUzqJ_EUF
zd2WlG%=Sw3t+p2ew39_#NElcs*ogj2z?izlK4m=hU5Azz10OiLLy|o(Z^-RFhSUZs
z3Px2SfS=m3KV-(p_t+hsyE^*?%HFl)RpJ}UY;;Yj&|`p-a&?Wn#_RVv<OT=Q#;JJ0
z12jJGE2owCYqEA}2>5sM^Gk6s@)4!uRU5moM0cvEmbmc@f?xM=S=ewGVy1_O4_nz~
z4LH4X-O0pXRgl(wD}!R<ObwpFBo@U_@VPt;XA-s{AmU1R>~JtYxRAO$4fFb*TtSmE
zw{TYyNL_Z|{!XjP)WHM8(lM;2A)9`%JN#}!tHCWgw?09sf~GBl7&*A)4v?;`No%Jn
zk7GemfP2Mm=4XSzZ0jtjz-2u6+zlCwCKcIT`H-!|bf$v(<OX9kO^saKh0ze5{Xxd|
z4crGc4y~DQvxMwf)WUiT63TaD2awQNiMtQ2K~hf828J&}{hM;+!g92VDI6zjaaS4k
zugaO?)sqnzy@Dgd414(bZlm=47S!Uivh>d$tQw_&WVT`2sk#5f0sw~GH-Gt5wflBl
zn2F(5W&WWLBOY+&VI8(z52wh+nH`;1AJHY!ErQf-oKYB5<BWUw#{%6e#+76w1?7_J
ztJPd=>A}hwj-J7`IfZ&9NV~lo!B!Gec!Kweo3BUlY>Y}=>a%Rp=SUM>0$aCMG&|{<
zE{`@jWR)?`BmwqHza^tJC%#{wjUD+6r1wa5O9cG1>_t;66+`QyYp}o?+9;)kS~Ykr
z-7fH)89N5F)eYJ(E$4!Qh||6oiv-6mo4NPAYRt2DcR8~JIk5`{yh(GP{4C7|IC?e@
zzviEEA7^9ejKiP8llNDO7mwSW>C^PO0|YYgyyjy;Ef|Q!m^UYj$ee=SlT}WB^sC`?
zO3wVn6l3%k>gPrigW5mz+9MK?XQ-xhhu-{%bj{dvfSnvPaXbi&n<|VmDPBL^d<xdX
z<!$<jFpJGwmDrD4W5kOeXCN3QWfgayXe+)Kt8je=jJlZy$n10YD0O}eA0^|~(}3SS
z5=d4nA3|WK;1CPS*r=qyRuX<HJ@MWltr=Sk>(ExtD;|v@i_S@}+{|!Hsi}D<^Q+HM
z+74e!Q0f-L+xZWJ>8dcy0nngpm4DxVj+&0)nH73)eY;QZX2{hF7{&g<A~67apbrBh
zng%%lmzvfD#>A9hd^oZv&9eGczR7U^));fEMQ7Yxa&<7aF5<BdkY7(aQ6*`0a{Luk
z`4%H3x~4L&rqXKTsp>}r6{+FC!vz|i<C+vVL1|^5+Crna+1g;>Aldg!yD*fuQfyCf
zabez}IBqr19UZbOIG-B0yow=UAuErJ%^@R+_Z(s8`faxd7fd$ttJ*|}D1v&AQxaI~
zv(qD-)36DuUA-(wA#m}g0kOL2-8~RSsotZZ^QbY*+{Pxy`{$sEw&>o|uGtBIjQ$U$
zIsq1>@e**R738Kzu4{&&?8mK%sVf<!VB3U2%dpFi%H}=f$zhZDFuZl`O>3|8-6}u?
zj-l+BFA6RB)5Xj8i4Act?}&09JF2u1`-9iH&>kMV8(+vXSg`8|eAQ*T$Vo#L^?@qT
zoGSL3V9VmyVlrLuPg^vdhePZSPXP&qSXUjDhT#h{J+_1r>Xzh&v%0TFE!)_eRh2{%
zSi;1YX0E$*JqoTm*(j8FyG#PY7w0hP*N+PmoVor@NQP^yVEZp7if|$NQsQ!9T~55=
z8g8V-Xv=y!k(&>nVe?XFau!aNwS9@<lrVpSCZouTiP%D#MA;5;^n3Su_&bd`r%cm>
zYE^femIpUp&762^{bMffv@!|IIjR*j*4ugC%EtE!hFH;0to0q+!H+hm#%wqzYmuC;
zRXU(WH}oz}4{=VwXT){$Q&D{5@DTo><H7kYVx{{bQoNv;SY!nNo<bbtvzZZ!OgL>v
zH#S2^?pLmT&ldz#vNJLDxAkq(mg^TyTIi-ACinUJ_3YtsaFes}N81x8UJ;$MHBS^E
z&#4vyy#N|y<Ux8zYMAmdH}Gp^vDzMge{L}L))jsI{7UigT6od)?ev0BpLa2eQU+L=
z|5wuI5_7^UVZNA%dhNFc7^~Kcx9rg|od~Hb%DI#KJ+>mwB?RJ6llAJUhI;#}QlWN`
zUlAT#fuLf{@D1T%Zv~jbb9RC*;aK7z;hxg9tCAyY`-2e6S6_k?+W`gpa)yt4=Lhr~
zrkM~%xss>#N;gp5@MPhCX$Ahfw)>eI?hgR>_4-Rm)5|xTQ`|g~*W5wKGn&4-gV@H+
zt^DENhn#ldlMrcf!3xCv@f>=OqF9T+e~Awl=pf-5g(Df_Mp<D|^Il*Q>B&!L5~+n-
z(D!G?wA@hcKC)jH>+eOa(66IYF~%)Hg|sa!v%~C_SPE|D>ZK^s+&)tai{UpI?90gX
z{3!T@$P%`plKPYpI#z_E+l#fwn5JnaA18jp`aVjyc@c3ekbD$)Tf~J=d0_JM#;NYJ
z6ZROmaNFih3~6ox?N;@Hqr>MUwn^1sBY_WNOhwMk?ckHsk1`oZ;~2@keMrNH@{sNh
zC;HI=s&AD_&L}qkhv{cV>}vL)a-Ny%s&1s%6acp&<BBlGZ#kR;%`buqbSUuf$ktQC
z?mVH*STLL|*C@kb`U}q^l|vU&%rX{ixLy<Q?n>dN7NoZrfPir}p>$1RbGJV_`P=4H
zhC6ku@VOA99?N|A?`;G}W*i?s6XIBk4qok$(B*%WdZSgM2=DQLbUvdmvt?^hBYh{h
zfb3zA5lNAnyWQCy?xf9!L3SjOkbP1L>g@T$O?qo-rW135KIA=--XGH+_t*J#xH+i>
z(DOtJ{B=qiSd?F`XC?!u%?Un3b4KxkedL8Bx`JP_LekG6#^Eo}cVcV)Hq}ColLwGs
zjqxtP5`a#|Zp_;D5fW^F_PU=USe6ysM`7Co8)VG4<}T=(PEX4v{wnLy6jTOyQu`6U
zT;qP~yKpPflKv2!5L&8_oDKmVX}c|Rcct)$H-@1+?e;JgX~*k#^^$A6rC5lCu_A}D
z5-gdG)^l{9X3PRyUC@8Kcck1YRtIM}KZkGkC)t?T5K3%=JG&(S6J@$IK}k~YD`|B`
zeUsq}o%V1~3g(3+#)fzbyrPdX^Ubl*R?BAYubUBb=WF<C?76-27{h`#H){MIu_v-{
zF|MY`3rs4HzK5z1r<>#jc(ha#A&Z@SDSua=iK)8r?y;r-?*@Y$<LTm^pAl(h9PziY
ziS4mM4m`Mnhg;<kI6YrJp8-F3*w(261**QT=KgcqRkU|lOBgk!OWN2}4MIf7CxRw8
z4lQyY>S_sK-2|1tc*^YExR81lzr9`Y$n~rCS<fOS7I@wE(=NBn_;U!5#u<Y*9CvdC
z38Zh@xa1cWBA~aReLt6je^THVBMSnu`d5#UnHaBe&d<zXp1x>rQSyV`UCHde2zUV(
zf?W<Sn7cM?A{?r^bt~3|V<}+vr-%$w71~lN!>2htuw=x3PX>G@opuFw9abKtqR$!n
z+lDpcU`@{f-%)qok+xL;)z8fA#tgc5nMaYozIR*PeLgh7Qr?G2&d+hO79t{?GMlqK
z!f4M-i82{d;~f#WN7HgJlyY*0iR0N4{xrC>90Bh%n)GEEqs#YVW143wIxm@{p&uSE
zxw+?qL@Xkrke*HV8#J8?8WknhMe%Vt*r6>B(g<SdtwW-|%^)M#Ifn&=Ez7r0-4*3M
z=S{Lr*)SAKLo`%wUk#f?B6xy->$Z^LkGh-uo)Z7oa><~FBs~R+-E^t1MEtGgE%xr<
zXIB2B>#ya$wsI@`NU9DmIQ*A8Mm&1UZZG<GJaoaeY&ys;AT-jT;_{3Qp5xFGghZvO
zobf`Y%#<a}ef7(4Y||f~9~5EdB>L(RS{%i)*}Y&17E%qYAU3^0+wEY8OSf53N3f+O
zVP9LN)Z&3(X7@7lo7Ai~o2z$p$&0ugKq0`IJU|bwdiH~iRm|Ho_X2wM&wmz3UVOfU
z*cZJ#muV%5J?sxcC#zBl4bnQlMkroMq7{4*v$Mlu>tp)eC>L71e}0|A{$~Kasx6_^
zB!9@o2?71>(9GNtjBzXywSOC1Rj#Rp(Bd1XriBhv_?846%ur5GR}9yvw_`FF9J6UJ
z;8>DeI5&tkij%h!ykme9ti2Xuz2Wn>%?tPr-9Mi8Eqtfe`B4q>YoRwUoNZT8p2%vh
zxCPD1HSf7%*y(v|vBnpdub~zxf_<=ygV~un@gq_O#-0sqvlMh5?;sfU#Vg2bw=DF8
zgd7Aj#fA?@@M+v2f@<*G1#fGZ`R*n*r`B*1`VJ18HS0_0`nSXcC!X6Olra(p<2yLP
zgCNTu+4GLy5HAjRIHx>UEBIpIC7m7wKDXK*SuE%x>V-s$K&n1veDm;w<m3?nnFZiF
z2)5z;OXmHV@Bsa9?Xz1P7_(8u|4^GV*$T^!2Jm;J?C(W};aCJFRd+s87GCJL*BN`i
zN=8-!?Ujq$HqsA=+to*kGqt^|GgX(2fp@ew4$652eofl6e7nLUzO*37W76%&zOOH?
zjQzN-b0D5?y+MyAzqsWA;CWl)Gt9~Rlr7C!iD3q^uQROL4$8(sP$d8!rmtqGB$``T
z-E@+iqW1q_?5%?0in?v##@*cm1b27$1P$&M+(Y9o!6k$cEO>w<xI2wQaCc}d(71a;
z-~LYBQ}sXG|K9W1wO@9vT0Qp|bB;O2FYG)@tN>~Jk5Pfp|Fqs^jX$ip3iny>^!tm~
zGND85+7#<~!(O+cw`g<X@`}vdVs1MhX6&mcsylW8T<ckCQqxR)QR<R0*c(H$!2n~X
zo=PDJtNl;ozEaz0ktn%*Wd!aCobNK;YgYh+TPLn1s062{)x=5uT>`sFzZe(~{wr@w
z>hcU|-W01zOUdq&t7z_QY(0)n_l`*MToJ5a;WTdu1HcoeDfd0z{IY4N8@F+CM)1Bo
z(f@A9sgpnT)87nN?fY+4QFXZQ?FRS1P4*J_`0K%#^<oaCQ0bOndWOonaVFkS3zAN*
z(xiUT*28qN!lMVrm)Oxo)GrVUNdH*P-E5a1(aig>;gbPkZY~FO^VUL-^;l`{jMqC3
z<o-s!N;A>e&rXQ51d}BEC+COaE9(oXGjlv8V^vD;6T)wxg3_SY=#>or2`R0cWSP$z
zh|_B>I^#%(krgdH%8s*@Edu1RDci}XkaLRCwNDuT)h{&k%C&-+Xcj60J2^joQ6EbC
zdq6*KQXx(zxE~5^?eHvaA*y0dX}UxiNT<3Gh+`?K@3lIWC7Rl1G}BY7v2lN8r?1oJ
zBrr)~+u9%nJOSDdSu4teT%;-FKMI7aGQ{A^b*X3Y7EI#031OLsV*JJ4Zqvhv@1xN^
z#C@|UESjJT3dS<m&^J1e89cf{mhPZ|t20aoTLbTz_m?Q;qe&r^$;kdx=(wMxr{_@)
zdb}nRKmEdg&_HoN#|ZardY-mgkrirCKUl(eyTlOP79euC5#57JR7unx`vsh(0NM8$
zP#~CWP{p`{26iOggJ>v|n|xn~igtN(jE|O?J}w>O&bK82e8f6<@GpL9Doy$&%zq8u
zwp~3sRd8U2s)<;q4`N1XDwMCuHBv)K*5XN%v%{=H&aQ+3CJ@!ymQpMl<c}Re$l8CD
z(v8EDJ3I!7<z}`t#(9u2P6#m_3fC^dv~od2QRB>qqEbSs9`3_+eHlWEQh$D>jc$GR
z_(@d*^~L6Drsg*UF=us!k6lwBi?l?3W|uE!n4TEkYMbNX+nVUT!*7i#Z4>*^(H8S>
zqy(`~!hE;?s7)c%MtW4NBEo%2Q^Zj5vf0ZgjkGb4ib7DqNKeb>3OQuS0R4D#U_Fvf
zL{XMDFPhGc2+)XQz|$lVoN(aVs~1<8qv2Wo!<K5#)o8-^J<I*~ZaE`$<Ldn@E{1Cn
zuiaTr`67Pv42dmT$%GIP6om$ysI39xQ7o(8kw9Fv?)z(_>qKc>gXBmf7Rd+-!AbUQ
zAF+HvifpN|{=}VfD>_!>rlNb#ifS2_y;X<weFt+Rd&RPH+DmM(M;=up%N(2d=*$5&
z1W$pXbeZ2-TwschynN~`aJwA_0PjbnlYrl?^{c#ZbB*_#)E&j5-y+c_=%WTrXKc6{
z&Si)tj3A#MH=^1d$cc-z6xC#U2YI9X)<7jHy=J{ijCyze_U8tcLn79uZ)nBpkKWlf
zkj>`^<z8}-?H+R08g{t{9ozr{?=*zAb;9g7J?+OFrh%Q#;alvot(ST6Wi8&E`$BsJ
zm-I}GgjaxU<{+kUioykMiuFmUoS@h|Ym7aFm#)}F29!z+p>@0JQ)b;<n^WzP2%k8Y
zR`PVFZoq~ttFKeNCH1*{lRLSIZu$&Bjaj?g*I`+YVPFslRs7|bRq<~A$phioWz190
zcG(C#@b529HUCe*bTO>(y8Ex<)(Qd#5^JS6lBD#16mwC-29YaaD4~e;aIK)ym-s~+
zTRIMdwV7*);#t`I@!H}}j31EPoW=lKgm=rvi=rURpGIW3ZHM6bkl4YTLA$uAgGR-o
z94j;yrP_vg(1`l|>sw)RBOUv;ac;EL_Ewv(MSzVbPH02uk2cEfq=|@r<ifE(>_~1r
z46^0URX)To{r&zhDe=$8#ppj?u*$?NJ80S7C_(}~s1WQ?(fr$oJt2AE!YLQopc768
zpyulXKT>eyZxhh+=<C*U(XO`F=a@vY|LCVR?+_nK6MYPMaJvJMrEG+XulP4w4?JIw
z*~YnQ79yUyNcItQ2`EK8m5@+xbBshtQOUF0b|TxNB8X2l%&H=6KW;JizLMdEFM0}*
zcpqb6C*N&F%^4VZBbdF89c1l^HjcFGQxDQ<^Jbg<4?l!j`Un`ZFje=<k$0|`MunX<
z=OI@xcbS?i3$bgwe>$(L`SNOyo;B~>CH{4XfUZK%9duK)C-r1LNdRcz3L`jc*t82t
zU@Hg$Jh3^`Ycc(oHk?)|qCgnX)xpnRg~iTDLy9rq`BL%X*g$~aaV0XYrM{E<Sx`QM
zbXi=>+OrkwoSLs+5pC@_OeX5D8X`rs-%j857eHl$Eq(}3S8T64*^s)o>XXA|Dv!JE
zC+n(a<j3?Yg^d?XIuA^^0=CS7Ch4jfduyv(*Rh4v8q=HYVT5ziTPc!6JQdtEbGS5*
znRqN3*k$g&;1K?vWbmpFhcnu+P8J}JA%T>EI(>FFKwp4{v*6>(O)!8rxxH#nN{{+H
zFN_lIPSZ1nhF8>*cELbjtOul>dsXACM63HYO7Pak^J_Tf-*gjwuWyHf9co|1If@$x
z%9;txTomp{SmC4jG02-OleSkrQkJ311y{oNRQK&EPerD%s;GQ>o}yL8^M2>@+}qXi
z5o9_*c(by0iUxh~v83=}Pi}DxNr;4bvE^>alG>6<sKY2Hz5ita@VkY4ijGB+M{5Jc
z<GWvT5|~q$egUBtmJhl={g7)jcJt?5XsBHw;xW}rFgoDF566n&n1P*)AjD~$O<Evr
zFj2@$2>B&st9e$+Z>d;cM?LzBMOVVg<D1FNeT3*5Em#UJ2*=EP_ec!c!Qj$dG0I32
zCoy6=NG(}!JZ|U=m-=Nw#~)+f25MTVi4URDBK)>_gz!hW37>c)wKwGXq5|)(2qcy`
z3YFpWxh9pCJRc^e=_{CQHk3O57Sq#U(qAZsI+QhT-!3(0z2;iV*plcz6&;+LJH6u`
zKBu{?JGIp&nK!(&gns!{$1j5x_9oH}m46`P`Lu}VgVEy^bms@KLC6#%VF;a;r9_p9
zA4q7AUfhl#e2y-T3rcR*q}o^?J~V>TbiX{Ka84*vh{_E=<TFCT4nRf8R!+7@SOet5
zUWZieg3lt(R`sLHsOJ4_z_YbfBD$M78sWHqVNisz7WW=4E5W~)8V)jXcWF_g&^vN7
z9Bk?z;##p6YMfIl=r{bowAW;{gV5ccAt$5P{u8^ZoMEx=VXX=OR%E%tOUA8=>5!(S
zY|(gE2b=ZHl^l<#zq7bo<>TAFRVUl$-&oT?{*=2stcN)=`?p(rw#4~7wkqvDssp=<
zJ=y3Z(xE?T8zo?3D}p&?N}(THkn$(^guTxJW?4zNmv8*nN<hKTHbh3UU&Zrb$z!G|
zJ3=kudO54(^It0DJP{-5_jHs&cvcX>XS)Iv&0Fe47H+r(7Nz>(OLe^f@UD0BS{ex<
zrWW>QO;sp5g9F%U-=oX=!wR3(u$IrSu+9NHghi{@Zc3r$%1^PZW@pteH1aTh^<2a>
z%-a7#*~ay*I1P8+w#4mW5J9Lio0U5(l!!>z`VPz#ISAAuwc_74Y>7uGUct7{#2`LL
z-(Sjm>_U<fy*r+RTwb(J>qnQ7ongsxFd1H|5H=abZ%w8$IddVs)9`Hs`rs4ODQM+l
z(EJ0~Byxy)+vCn9=EgP9ag&qde>|53tFmkcmSef4@UM}ru{;;7UGqgBVw-)m@QobW
zc>e9wL4frA&GRJ*^mI;apq@F2S~{kW2EK`0!TaWv990GF;#fq=^SeS8^rj|@x}ev;
zGunqhqp@70(Gd09!w~P)D#+&79NdbODdqR>!*yGLI_I!6?&Ky7f+I)jeUC^dUd`(<
z6*-NgtZBUM{2mwdwq&eTh(@t^lqB^|@4JfDPY>z{w=M9r)OvEsv#?I`Y``N5a^ZqK
z53pK+ocef}2fXcUkb%w&yTd5+n6UclW+&CM^b`Wru*3bIj*yH{@;Lw|oPuu6S<?{r
z$}V=Y!2|N3)n=Bp7rEQ~`ViN6+OFVH61S<t-h^M&ReNRBU2~!Tu7_{iUnJrBpR1{9
z1QUe9FwugGeiGbiCOA8ZVx8LKfoqzHR{p8M`+5-tg@`gifSkz=XYunp9K7vQJY@_&
zrdqFUqHzuN-LD1Ozf!8FqCBh|YiVk5NQ+j?`j*0^wD5m-zx8Wpu;)Ym2H9H)yfDX}
z3Ap;{hx2b*vKzXG$!s6B9GviGJl(zcKP|p(G?c>Q(_x$Q$d0H&4uo;r6keMAOs|Nu
zGH(~;yhJ;3>m11PI<l6x%pD%JQb#HB@xBPUqP?fR57PU1iOB-E_%_P_--R`B#VMvU
z07tGp%fblPie5Q(h0xFlzlR~uqwNBbk5|0J+b10{Ldfnjdd864!7}$va`Mh8n1&@-
z4gY2>mDkUO8q96Co$BU;ylI@Ff>cOjA#$>+wztS!8+go2liwfBBo?(q(9=X4U6PL5
zj%HHG7E90u^&7}^IQ*k=arV5^^$XCbt*5l)fktW4zWr$?EsMk1NUbuFl<^gG&)mIn
z(eaL3&Tr$5unh|5Fy$8HXrKbdkJ-YNI51cPd7C>>Tt;TnLDQuH^w50E7hsqE<rh{I
z9d&7mC&`nsc>XNg(=ingE!EXWGE@h_vFZDLS{(rna-S*2R7+FP^x|q#8LE6%4yN89
zHo~6Ifbb$geDvWH6^mYu9D~|D7?{9Ow3oL1Vx;H(Ey%Es_HHr48plwcZy7Q$nPE8K
z%#~r2UqJ*15Gfq`^3^dz^y1}V0J`A<Bt~pKqk^76nVA)z$OwR)d~FrlwC@q9q+}^d
z`rvInhseb#m>XZ6S$*QeuQqt=^*R$mNi$HFZsx=!6-7n&it>I}H*Qv^$@Ms@>L3$Y
z?AgmRjAZqMkhxnF3r4&>2gEh5J4(#qXcolBzUzvgEYhSF)l(D_PCO2KmH0k<K#r_9
z-S7cK>#~O6uk|VsIE2pb_pdNT!)m8NtJXh=T27pmr9tVAFZw}<6U)3%Uw_5`V~R++
zde+HgID;}t(3_OwfOzna*dXC3w!QXm8erF{;@B4bNf3-Ca@9=#;0_jhF`&Pmv%2*T
zTLbw@tG5OAM)TDst75K_{$Zh@PJTKl-o2a8T2=GQ+O|a8nPF&Zb%X&>n3GW`>>n<m
zOBJ5kDK!QTJqlA%@e>F}p1j`nT7S4BH6T?O*~f@VJf5HS>2|}e8h%Bo0*;>vnknS8
zTRvQ&Mj7-8dEPxgBuX_#2Qk(8uWqe`5tj6G`FEs>D@Q%-?3%Vp5h!Q9SbmoZ&#BmU
zY&v0FcIP;m)17ZFtVH%SEK5a|O*|ofFowDnc62YSsj%$(b_N%tXsik@R)hPXKk1gp
z2+?^}Wh);_yxTDj&-*WG(ave-dqy%)xkLFP)FRjE36}etb#=T!C7(kc(PLtAE*GsA
z!#E>rUW4;0u$-p7E?B?*P{2Tgczy-VH02FlIMRh)*VEjsvsVY-_$7h!2eH?#%LscI
zF$2Kxx+!EvQv#8AsUf$2GfMx0^OpSWjV0{Iz=KVrFU<cfAes2s%jIFLE1Kk*mh3r}
z;KwTt5>x9trNh<O6BTruXKy3=&dy8?J5L1{s==OR{Lo7|x}2tCqsJe(;FhwBjX;8;
zMsn~T^Z#Sd@W17e2c~ccD>L}C@(Qs!h=oXyyc4qt(v&C#-G}~jWD;Ro(0tCAqFXw?
zyH*7}d9gk3UBgjp`jSz;92_G*1h8IQqZAIFDB$Fke&+rGq@_OUbt&(<Nigr9U9z<K
z4p<hY;csYmk5om@eeM$7kTdLQvJ1Wx5x=e;(DpIXW(tmWjTCMN&fat-RJ-$RLRj(}
zyW?u4Ut<byFd3r%@yn#`zx|I?_eu`I5y9qg%k#FR;hg5Cy^?%xQ~8rEZh;1uH8W+@
zg-JCp4!WF(5RQ!}gzH8e2f}S32Mj?im_*_2$gY$~bw?<~E9zJG6!J$Mi*O1ify)Zp
zNIq^HI!6n%ug<>*1R|fqUOlCFw@$*W@0bzBGrEv825JH@sc07wR=3N7yl*k<x7UQ0
z`3Z_TN?9Ar;=}Loi`o!?wC7QpG)gx|miU%Aa_qXLQPuooVQC1CciJXWKxGc>pYq9p
zIKa1yN>fcQ9qC_wcE=x=d3$9SI?*Qw|Ly6H{c>(aX7QX!&}hWJ{BXy)xOj~&L>)P}
z5sh?8p;rvddg)8898Ji-PbvDH_BxQ5NswjH({`-G`MD)9`_GN0V<oWs?6CK5x|E~e
zo(_&hY*;9QCD<e??9}Pj-{->DPsOb$1vAiv(UnWV@$|&LU^61cfF<XIlKf8qJTE&=
zg%QYRA@>Hq=Loat$uW|9#qQ`=V|n{%>Vc(vB@nbgPFW~&O<PA<v^1AzqLO)(v&Nlm
z?t+G$pSgAF-n;Bc`gsJo8aixQ>*+$tr&CsDEgFM<gL_N(MYE({ETV#rP<<a0B|eh!
zXg>tLoC7LK1l&5_vnQmjwLZ*HaBA={DlqFDZ>H`m!15;RUY3{0Vwv0GF0aA#jnvT)
zHey#DH~h)U*u&<{lsd*hJ)61K#{w8uqR3F)_X^&cKq*!@;aBBR4t8Nhao-v(cuhbN
zzZr5ayulrv$<8I6oTfY+aq|d|I9rdAFmZG?iF;l~K{GUg1RM$p8m0dlhqA~MWqO^W
z9&;W?)ZLl`>6T+NHytDSrY@hg!g^+tP0>G<qSiOBlgrBXw4Kg_N?cme`rYXF3?aW>
zhPCQcJw-HB+}@w_VRzo2yDm*QvNeD)G^}@ohc8q&R*c!YdRL-iUR!2nSHro7iNC%V
zxwsuZs1rS{=`Bvhl+8T^Y$%Exr&;rCQrk~yc|MF9!hKT{2z8YGeqt&SV*x{%zvWF_
zWo&tWp0GYJc!B_cr>hImi-(107tMVl!ZE$w%+$^Y=uH$u3j$`BHp~N7KlpbZ+Yw2%
zBs$TwY+MHvzI31~I3t0ByW#@GIm<DGIF8YOCF4Ywc1&;V_Kgi=YYTv|VAl-7i(`)K
ze%QG`w@?5yYA)zEpoEz^TIl{ajKyzsVCW%Tt4|OvmZU@QRNvA;*krTy&5tLVn06|!
zZ<G6n3u?g+gQ6S1mz+;Qb}E2&Txjz{py$><1;`O^N!!Wr&=q3$i#;XQtB(bpE#)`V
z>uAgSBS6(6A7EgBFJtmP*%wLO578NDfTzBxaM2{@IXnF5${vkHwqMuUZfx57Q?dNc
znN1-ooLab8%px-d_iQppCpyjc>-Szgn;(9DK<kqmYr$->*YVKg5q>0g1|?M1xCHBv
z1OAc0rPc%mN{l-y*KSi`lBmx4@ANmRxVtZwsXZ?1vJc}bSzSW$V?~IFf29mBz6bxK
zg0FJ_zs9rwS>Kk_K*@&(e)p*m1wZ)52ESY?Fg6S(m6=l)X52_fMQ@&74|82;9_Ze2
z9IXBB96gZeVu!D!TCCJix6B=^-E+WqyG|cjpIbm@->2?wB)SYI%lBH~yUMAGkA)7$
zNWo9UGi`r3X$t)a;n|d#fE!&xlYHg>RNKEC|EabZW;4%=aGONG8$0Zq0I$X<TWOkn
zo`SZx!xepG47XpohrB@#WI_%HyYB5%)v*_YGKRI;3%!27@NnM~WGt92kN>Kzl!;dM
zz}loN337JDIFNp#BuameP7ux<b(_BY7SLrXB+UviN6R(WK!VT(B1s|Vb|e_qwMi#V
z?MG%A_SpA5VX|&4+;cyjh0p#@HiqUE-ZUb<3&WGe+xi#vJmWn626Q9#J*uI#HDBpX
zL$c`V_NOBNQ055^onO!KiWjJdpC}NgMVLLUg<|#P-GkO>al+jlnaNF{s4F9)(DX6Y
z$|X6)jIy-Oy*HHTicgxja0J|gO2e`{Hm5pUe^rhsTcPLEVwS8dTZdeH9&D`B-LY<t
zcIzRcFMd2rN@|yZLPBFbn08hL07m;bu1sy=u?!&ty6WOx91urbAm}fzeA98zZa||a
zo}m+0tq~Wnyt(hEZP3Wz7qwCXjcFz^(9)gPJ&ELUzPNvf1b~ZJw<JRIB@Yce)N=vA
zeM)kiA4oIGld}q-NWZp5UfNNeOA}3>Amp5&SD9`cczsU8DL8Lu)uBZ^C5?=Y{zfJ7
zL=KoqC?h4?R*akmsw`g23I+;*yoLKdR`<E%*t$Joa>KSk=(1YyjmOAREam&$i&Lt>
z%cWdvPA;3LUD&|rsS`4h@-I_#hwi(u!mhCh;ZqS+Zp(7rORfiu+3$z#u1+%1i@Gqf
zz<U}%wv`|ROSP734_$mQZ7{G`pOWZY1TBdahw_J$E4LXu7VQ<`8ab)|t(5NI(=98Y
z5l|i5c|B4yoA%USQ#(LHH2W6lw>PpdZn=h?yEc63PiGRGhkfVS<1Qdqv!IQIaB)=B
zQY+&rRFY#X>%1d_E^0ZD;exzyT?MRv#c99C*&e{45sY^-gB67J?NnhP_5;<cg;YqI
zC>7=+U@`8fk~HLTMa12ov4jBPs#Y29gHgkLcT}O$t5Kv1*zKPP<NZk=*A2euyA_%?
z4dO&`W9ix<_Fj&O!Vbc0yqt@0lQ#9ic+Cnf-n}P>{aZ#Nn*pUX-O5ilu?(v91*x9u
zaqi4tk}l6ZsW~dV6n6vKJ;613(zI}$xoyy%&+}7=|6?)&P~?yG)-qw1<<KLQ_4tgN
zgaWxKU$HOnVLIeW{{#&FY#1oyc|3;fcvzobrohXjQ>Mh;Zd|dvSY;rT^8>||le6A}
z+bX0gIwq|o?mIES<UQa?2yuD?xe%xJr~jr*s4^gs_PyjGTxh66$1b`SGaa(yM}D?H
zigm{Z7oI;ruGd<n$cn~<YXtyY`>BEC6QqKIM6AM26pCqb^y&MzrR34+VVs&<#ovPd
z<M(iUVqs*8M<96K8=t1!D3a|gfRzj=N!}3$dS)97lyV9S&#F3LHXXB)?f&`*HOjVR
z+M-d$#KBe+O_<y?@E848=cx2N`vFg2<2J9;;gGt(OeH_?Z7YL9{w<5M1c|Zy#iC(W
zf#pDzHk?E-53!pwBGrhJ5dv;JhS6n*@n7EorgdAXM~K2hO?F2u^fI0PxBJEat7Lk5
zpuB|-3(aXA&wUFG#f(;J;0F6eZC`gbYu-t(r5fIGsGQzB-o3mF{O1!SJ^FfD)A6rC
z>P7QB<C^X96eYY2L`d@;UX;?yv|K>Qg$3VduO#8rzemeFqJRZZ6&dp;b#pywKg9x@
zS~>}?$2Y<Bj;k5p?)xV;UgQ2o<7i^9RN#CDk9U48vLqQ9d5Q4>%F+J(o6>WuDauoX
zSi5M>+)*l)YETDpfy@6Mkf%%(`h(?x2>=1WS?-TvthLJjRKx{1*x&+Kb5Q0!^GRNb
zZz%dWPFcKt5K5dP>obZgJ^!ISZXi@E5j3-SEsaWfD(ade@9Rw)mYdZ-ziK}b&{zqW
zc5UIITSZHij-OwbL6@D{HK`28Hz&KV|1HQZ&Us&4U{&fF?%wdWR>wP>c31=mKW9K=
zSA0tC=bAJkz|A~6;mpUX2O)roNO%l<VU;E3FsU<Q;uxlc261|e{&62eYO#fE1;Iq=
z-oYYFK^I4`nF^iCIm3hNzGm<pe6LEgr;}aLJK6E@`2Rzw@$ZIt4G*IeCi^!gjP<@!
zjBlvQO?czLu2@ZS$Org>2qJz51c%rXjiq&o#ezY4T03)SXoVrM;NGo^H@H3&)4x(0
zrdR-7t*T2)_=p7ZaFNX%a-l$*<Qf6}r%nDo^ZPn?XU04r4K>fxHbq&#K*WGSO<GS4
z1P?jK`13pcQiVo9p*b>Eg=1}%t=m3(HFR4m3nXTYROoGj7cq|nA(x7?1xZJvBIQj_
zz2H?6hUep~6kbyIjqrq`)x>fy^`_$IwMB9m8scLognoWeJ0JjdUxk$fxzeGoVb&h<
z$GMe#DXF;V5}Co>SvJb)=`*x^!z+@?O0(2Z8VG}rO}azzP;*(nm=a8mkik#1JxZWn
zR1>Fa1*gOXc|r=fCpC@NQXa1@HLPQeZGJ68+VdM%ydeY7NVRZ6$e#|2|CgKTdFTu{
z{_MMq`br{If+Xtu6LEo=#um1#!1*Co^!M?4-jje}a-sDD7~;Q?*v|+|v!ELuqy*3~
z12!-ZrZK1=Ud|!-r%?@*5zVSuLgtD^o*ozVCJ9A-_0bN8l+Xoz<V>U{?+uCDE|RV#
zi;Q0RSRWB_NNdQ6qDbHx)z&O&As5Mt@b!p2x}5_*_P3RuqYvm65gL{JJxr4TvYCGH
zh8Z0^^)jSvww}j1x}gCNNx`BscmP2~2p2YJnw4+XD-=dqw6_SL%B-P!sp(94v6cSe
z%+p`WVeQ5^?83S*>hC9p;+Wt2G|SFBnS3pdp^-|f08K#xiYhsRcJ-6+wP6$Qm5t{5
z5S|3q%aCqtwzmP0&2&%=!n8^ykt#v>t2SV|LtGYIv6#Qn-GwxbP3$O>kl!uc*;zx8
z=YGe-*{uA2$*o$@iXUPnQhWOy6TVn6vQM!!JjH?1d_B(a-QM8h)==)PzUB=mFj9`n
z4LjvS9rza-@lmp}5w-AU3;fRU5tA!2gg?l0MgENZ=ucY#_WGQ$60mMG!Px0$W9Ao5
zI{-j{SV9BIxrQ{NC!r_;aCO8Ybs^pDWT3Cl+bPcf5n-00L&?Viv~!Du)gF{I!}DFw
zL$w)c$K5u*2?lL|ZXq4u({BY|Kb24Ut-|5n%dOm;hfL^m5R;4@%;Hu%WlgN>N=@qD
z#$m?GE%2RlDfODAl5?6p3&2Fo;%7QsM0T4$5d`PsR2%<{|EsZ>k0>JpFiARcj+CSo
zUBxTxSc>g0(OmvRg}%`pS!yiqh)NhYJ*d~JziI;4jkwSU`wGh!uEfk3-j)2-l>K-o
z$v_p5WO(0ycKHtQRPL86*+U|w1-M}~0jj+{kY)r(#U5WW^kHJOu95tv+1m()lp@^(
z!F&l%eIw_=PzrAmmW$g@q_4{saz9nP!wmqA+kmcmG=R7lTKHtw1pwGpP~QS9vV~Ou
zPfmuk6G=7fBPve2Np!70Mv3r&$on4Egz`>IJ)iv0ww&Hb2Ha9d&T+KT>e)txH)iyh
zHvN<nx0ct{Vo7<qW9>{vCKv_{vTr|K@2XW+o+A&OS$t>7wW$F#vVO)yH6=1HRGFUH
zNZjtleUL<ck8$Djp5mu1fomlS0d6$|K6)Qrl2wR6@>?49#2|PMMW<25q=shzasDgP
zGHl4Y)wtykMD#-uQ{@w5+~5b+j8X0E)k41lSr;vip}RV27a}1*;5IHGPk#mDgI|vn
z5cxUm_I)eWHGFhU;L?EA%D05Bam|_ny%TD6?F{3A;fa%2mdyDe9`hmmfscBhQN?Et
zekgl|P>OI*&=aq>qA7B4YohDO)91+sCUds|p`@O+Z6-Cb=LnE)Qfy%YD-ytsB@e+5
z>=S_OQm<N~1Ns>fNM0q3E^zhzGzkN`x~8?1>N0<ZQqeE#fD=bY+n)a4B3q6B3XNZh
z7~u0|*&4!d_aJq^jThV-IkMT8DB_YQ%`Cg`Ml#~uNYf0uVOkpQEEZ+P9)TRCU7uYw
zx#CAxJ1hn4G&scOT_dO7^_|68n{03D``6g#-qN>S+jnS%Z<zg5!)0Z?np(qC&F`6b
zA%4K+C$gl1T&NEWHq6~VJL>7q#Iq?}OK|5Zx?Irz@obNvd!38C{eHx?;lTjz$Q)r$
z?H8kypzOK-0UfL2uL;FD?l3{nDDce`gIY^iM;Ad!Y--WSDhPPW(5LpQycCG3z!>sy
zJBCwhXXy3F6E=*D0BLhYsiSo4AWJ@esi+7+Mk<HlD426o&w{OZ2asQvGSkT|&1%H-
zg1X#9eIcTH`Xt;IA7xeF)Mkzs1m<)hP757;%0<&GPm~KIt+wh5v~y}&RBkVU(~gbs
zy6>ES4q4qd&6LA&cNzAI^d^hmp^JB?g@X(Bq#4b+ecOB2Fk~7m7vj7&5zEU-LeS8*
zdA%(<fk;%HVPwMZ;ua8V$g{q!D)QIM`W<R0ekJ({qANfC`WxHb@zfS5O*eoBg2*-a
z(!5T=5)Ms)zyoq(8_)Fh{~=Vm=;XLqN1EO_xI4lHwI!mV$!vc67_<S~wLQPR*L-Ai
z@_Py{e;M^!v!oMzx!cXSXDGllj~oq#w>e9&fq}n-Ot{z7_u|I*Dlo-<B?SNYu-6Z4
zXFJy~ryDJ&)&XDlztUyOw$d%kvHi}_Y5^teD*flY?7kb@Zt=JKGBzq-ZW+K$IR4WS
zbQ}El2!HE{f<K5dJOC3>ncPAFu`SojUXfP1?nTrGSKyyDqrNH*k-A!H`K&KWe~b#u
zm%Bn7WuREtw*j8(G|aBVJqHCmHd0l}$KABc>c~=vyU}}%=q4$>8)t*2wm_|9uI+Ud
z%O&bUh3HSs6dPT&6KdkJ=LSA_aIBkEgi&3FfQ=1`pe-lp?jsQon%rq<d$TW+E`*<E
zQLA1a)xVHh-R(D{Lhi2q-s+PrX;=Y6BZ!vq?a<>rDVigK>~Pu}z$xDNZeVevAHc+p
z@nT<TX@q<e`ceS_?rC?w5`1SK^0F8HJorm=&7yf24Q>?y*$bgAv|W<<iFBhkf$)R|
z$N?)%0}}nP^KH+2S9@farr{%J55~PzMiMZB>-t!!lpg&2I(Bm7b86l3#PPc0r6Y?N
zX=&CCZq32DXWXcAD~fTRJNo03Ra++$4DYz_EJ0F{cV(FK>1586li>9fBG<{K)y#Lc
zrMoR;-D&QfS8IHY_`DNP*h$wx5S2rI_2Zj^ab&`Ao#J9U<K{KDmJQsz191WGNi&HK
zy1V{-*y)LdfW!LS++R1pmIgZxmHi)TUlb>Mq&*^-KH#&lYZv#`xc&*pJU8_*MAW{2
zo-eK8^Y$hrW1clyZ<SbSGAWM$=V3!rhV4EinsQ%veERJ4_hV(4Scl&>uK!5XRi#12
zR~T1yAo5Y}^y+4e>U*NTWP0Qc1JNY)>#4!C^`sBeru|o=l*Lr)ahf05w#(8q%fDDZ
zxqlZ1ZbvAMZ5S>=T%(vSa96c{^c~arFmAzjYd>q%dR|iwv5*oZ59t&F+-`3BHg2ha
zdE`CEHP;<L*FATH_758%q&$b|>sOfUdk&_%8;3X^&fTjj@hm9uYS<=PtTllE+`llZ
z!waY37-fLp87VspHHdP;0}6IL$0_0Qr}@27@vxtIz$YY*=Y!E{sJ#&qGT;4Ybd62+
z{<HgsaD#v59|N!!uIHp0Dz2l5UQ-OGZ#O~3O%h3Q8GmQ4MLbW}#<FM%lqJ*Tg&h<I
zr=#0n8$>U2!{l|B0mCQ5Ml{{32!W&=E4-3>^8vwtgUM{`1l=rX3#?~8nO>32*j|t^
z3%o&<LJ!=roEDq@oF0<PTD9I2z=aT)hB1wEQ3tgJJvv19yS^2=H?2%I8~B{qU}RL8
zAA4>LMWfV~(!^f%>f8OS$B{(LbE!qcbAOt|EUZ|Be(K9$bguAgQj0>oC;B8XdX2#m
z8=x_S!dbVySP&``nak)BSGOLt)+YG}Q1v3;H>FN1if9eIYuQO|37S5E$1Lu-jbC7p
zSz1{3&+`)<v@tY2CxV)2@@hcIz1?p%(YYC<M50n*ypdET$Ew~tFVzea6BGWYO-rq(
z6^J(<DzSq$C~oLZ2YJE>W8k7e)38^@824lwR-M`A+mL`w3S*M<<F!=li@Y$!unIJ!
zQmi;la9>!kP|8{Z)oMUp03Cu!9t_)=>i2cwYV{GcrOEt$rQYxR-Wv<aUw{eK0JpIE
zRaeh7u3D$R6VQ*_E)g9sK0v?u?b8%;g-x=H$AcC=@h(i%&XN)EIlEm(biPVLJj9On
zm^2g1pn`;y_Q}3P91mrBej!RgMr!z2kG9k_Y;bl!w3>VGF}uCp;oHNrC4H_Uccw~8
zy(C@ACqoBdjCGYn@~fOXxImcR$YSWC;8hVJ5W8iEsdBT!7AyqnBtVpxMMp=Ve}fzy
zj*tI;`f<UDFZvcCP`g9Kdj4#6^QCoq71>d!C^Yrm2IgwjoCgrH>jFN$p2uARAMf6V
zx`{RQ-`+Qcbak#i-rfgkSW0x>y;xkI|Il2h8rbbzh{vYeFu7ao-@<TC^=!Vvjj#J6
z&(z*S)mp*Jyja2C=$q)&@h#T;^;GN}<_!AO;)_)EMKC>f(V$qheAX=YD5t{JGXubd
zc=IAAlU&CjD}yuoAr}7TJV+6lD&Yo8pBSllg!<Nku}||(MSb1^3g{ys4?djgTGl{!
z8jf6wk8CZ6HZdJ_R2nSO0|1mdx~30VCV4~fAbAoZ;*SXyWbDk8)Y+mk$AW!}k3>NJ
z-`5+P*w`+*4_Ei#ox2Na10#zkl$C77@J$Z|=}JJ=fE*SgeZoW+U7-YIh=Azx6Dta2
z+bK!8Wx!suMDeh_J@f_-N-QNOA)b(lZ)bDNVtY+)3MMSYdlznR&O2Y^V}<YW3ZMB4
z>uu#fAU80!Tpr%C4zYDg8Tl<EHvR!uU`!`FgeoKCco^oRA(+hA)t9Z|S=zEh_TnFf
z5Uaa=J8k51hPvlHHTR#huZUiGB{Z({lw}5NVzq4V@qlH6vYuB*g({OYc;kI2bg`fo
zWeIhU*_|u#)wZV(f2YK?hxaZ@dAj@NtDMZrdzwFKVWk{B&VLl{w{MAbXVLx1)<u$y
zJDy(tRiZ%Cki;W|#$o0%9j5kMEd2Xbd7PH{fT3lQm9Kc<k`1fzjAMPTO@oV8&?nIi
zPwlgtM+I~t;i7Ih!!0{~VpUw5P)fE9wnO1aY{<&a`N)35PP)XV=-@}xcmC(7+hcr_
zcG)yk+4`P!^P!Gv5lZa-@`{($9Y9raiTy$B9XvXx*C33z*A|xKp3vo>`CZ$hf>~Az
zf-#*@h5V0qu50QQYqgzf#!x1b5CpOS(M0wh4gFp6KU3A*TJ_LJim`Ux8}*B}QrX3r
zFL*V??9CJ1?27K2#erU|Y4M2(#uL|=3L#Y88<!vX`uiia2X<E;OC>Ub3jNn@q8x6C
zTvIHEGRD;VEtX{?`U2W^{{8Df(omV&&Io%V>C<pcl6(c#0pBypPJO6#4exqX0Om`^
zh=6f=@^gEtU=J|fkW*&TwsYntfH#rZ1Pg)meV7yC%}g`X-a*ZdghqINDPZDS@!t3*
z<R*+^_Dn8h-@_~=@!>4dbUk&^UvJ~ZbSA{=gj`=rGf7gDQ&Mx>UbwGV-DKbE>jX)5
zrKxTBS(a|l@6aE-<YEOB2DwVl4aQuaF*#dq=PDjr01vt%|FOL*9_j8#DiPAUFFaA(
z?Lr$RnA6T3IZZ64ikj5JvSCPYQ5I`f&CY0M3!h{qVW_wIgI$7Td8O2mxduVBR#%Fx
z3gv}`NDal<^}}AvQmY5IZ3bfHSC{jp1<Yxz8R~I$&2tHO?cS1RMpof_ZUI~0Eb<aX
zVj0cCo5mTxQgxSfS^CV?Rbdw*5RA3y&R3N0Lmt~8Zf+~!dw-7=_`eqiy3jT-PE;75
zJ@b!nD$I1vM}#);6m28S3c+Npz#mueQ^AL^%2|wMW9aDx5K8{Cf%8zC3Yr?UzdX>Y
z-o1OkOvOq#B01BB>VnA<Bzb;;pRn22!~Z!VprJ~<$0#oK19(8M+@iYzh-;t(*Ch(A
zyamIE|Lhj@M<u`iRej#<{d5a9Xi9?)pCtFpK*do}J1)jV%sm}QJuhWsZ2Rt!%d!SQ
z#_7D(Q!F9>mzw#%tLYRW0zskQ3gv<+;r*uiZ0tFIqOd9`^QV^KbGNT_Nbu>!>V059
zQ~$!VGX?6mB+|V~-;Xp1dm$6SzLIoyhq!%5pZfP3dk0h;8JZELSxC1^V$u?Nv)=0_
z?R#dRPvk}hmM@j_6uer{!D?StKRJUF0WY<RcpiZSg?Oo5^PI@hJ&8(N|L_Z2(hFXa
z-5iglVixUX#Gz`$BKw}tvqI{cJT`2`@{w25lao425!$d0;xGpPau8r{NU;00UxYZ<
zp>{lOT+cW}oUdnNUSlS<STMa9j9ydRC>ampd%U_^W)OA^kUagdl6UO+rA8?nKJM&?
zUn&^ihw)QI-L)V{RZTxfH`BMT0uR0)k#{T9Z+-%@%D=eQ&lmmfCS%F^K<SmS6(5rL
zIfD-x;)^p^$2IucgY3wJ+cC2oLR>EWKoQ8wth@uZ@!1i6^$f*j^bX{|4VBDCL0Cm`
zn9~vb@yaBL@Gh<n#MlMIdY{gr>iPk&Plk9ZAy<{$1pXs6`w&ayn{3bQy81{n>K?T*
zI<KMIWW2u#j-Subj^iZJ9xeY;l9e_7=i{dDP3H@0yLcyre}X|wCe{O#yC1+4gAEF#
zSoiT1xi4{fleA>%qx&Y=W{>B9FVuxLy^c_rtzct;g7b!-?bl-nddnw^v%50AZ}F?S
zS(X}%X_H_^g-sz?L|1@l{=ME93n@jG#nHtgJ-NG5R(wNMnsS*unhu?3uXWi?rrMi2
z@v)bG%*<u>UM|cr8RP{YZ^-iq3u)2{N_HOzIxoK?E#ADXei<ItN64XiYu?=B=+#Rl
z7C+J!rg$*JO?~+B(-Bn2?7<Qi;fB!Oj=yLn)42h%j`YK`5Yvh7w;$U3iMACwJtLV)
zOf&_8y%=WE=EZzcy!BW!U>*%>4~<XhWfXl$z*#)uRE9lK?8hj#rl|d74XkK1%%FCu
z*S=|_%zhe0?S*dUZ$C(;n=Rz)X#5KMhV1CmU8!PzUO^7M4Rg4vr>GtT(~FyESXh{;
ze+VtBb@C`K2}4Y?b+{bm*;H0|6W=!tvfUoS%K>yX9!9Nb^}+_!IyLzgUCjG;GGTuQ
zj*qkKDI~|844<}KBtEBzz%WijCLrjVj6wlwM1?G|WvqdpUQ9=xlVM11Qd|(sloGf<
zgCVGW<gGL2?0R{|x+OhUN&EppMHJ!h*{C_zuPWjh|FkIdXByh|=Rxlz?IRm9|4vjT
zUj%V_e%l!tvQf|2?6J4G-}{(8*f(#-0uS=dT{ZcpERbU~w&!TU<4RnJB*nt#Ur8Vn
zG>Cls#4inN!D{siL1=)Q5tjc9^t*RNY)sP{=e>@n*sd1-@ep4SRq@|m05fmeO;6&8
zNo#v|x2}0u_$0gHk&jmc0++L$-LQmvz&_L}Xp9dR`Ye*!IA+hsK1sY2VKxGZtR-y=
zPx!3k!8TbFqu<=!VC-*tfv?)X2x@o{+B-7<UA13-&Vwhf=XIbrnKealEb_Dyrn3x6
z_OKVo+SSFS{Uspkzupj`b*=-2kjW^i#QmK;Qo|@|xmY>%QLomQsXOJ8H5~Me9Ui_`
z#tODbc#a{yiYNb0R=k{4UNni{6x5HzwZ^D^(}Q?JYiEj-cLD59WbDFu7z9uyUtlnY
zeN+JDmW-)>GMrt-JK^*2sTEI&a@_TOoblMSl@~>UjKShpw&{aqatEnv=%4*uFNlt!
zYYu3rDI5o5hd<R`T;Cmlo=IC`>}%y8jsGssV*KCW=YN$_|3!>We8d}zFSp>M`*!21
z)TINki+Bh$bnbYUuI0z-(;d6kLity#dCQ?QxluB?h{Gw8O<vu<x~S>x@dx2^2XL9e
z+-xfLAm^wWGn+eiNxd){<1;(S>K6xbd=zB;rKsxI?jO&$_Z%J`2<;~IIhKTl_a#u^
z5WJuQMc;G5F>>bvvPCe0Nl5XsX6RYri1(E$zO*iNE|CbIj8Jl#F|&-vPc}sUjWc&x
zb}DLW&)gmAQz~#PN<dST-@EndV2W=bdYp~<{SfA#U;${FG%)X(;z?XVbemGeITSnW
z@mK>}quRM|B{VfK%;HXvpzwa}10IKL#T9m~xarpKAQ~x+Q~!zyR1Z56UEQUuO^K-&
z&eXTMNi_M=jl%qGoh8|Lx#i?iFHFp&!(MzjLpJs<coOjY!tVcQ`aJXUR5JrU>~}hF
zduy+9(E-BQy;IanFLuVwG~c3bhJ#oc4(jBnUow|?7sCGAoaV~D|Aa|nh6pUJze>n#
zaX8f!mzo`cNqvnokSK0E`>G=jYuKIUK7RO}Cz<XRV!U!Jk^OqAW=bZ^&ZVQt`JI(y
zQKV#hxdL+L(U+~sjOD;48YUBc_?wlK=-Z!=WJg+RMKqMdd~NFN(tsbZJ?0@5gW5^*
zE%k{Q;VensWs~XEjbv{bu@qnCXo+IUf|TUlb22s!o}s35FRh$1@fO{#p(tiqa0iCk
ztW{)uaa#sh|MckjPd{$Uu$FN*M$r?hpzwUJi&`HkD0y&&E!ZanMSx@USIEsI<S4xA
z%p9|0_;MeOpq2gOU3u8>&8<sTynWWzu|3j`yWm|{Ldkh>94_;@@Z<M7F=ak~GKAGV
z*Uv&Xq^qek!!GB3h23qmzi}kk|0*pDSPHD%@pr?5CH@+Le=w_L9oCc+P)H^lZptVf
z<|g|vhxQza+MTDdRaSra#J$#974prWY719%3vXY?N@2e(m(g{s6W3>-&BHA=Rx7+Z
zpAONyrue)+OzG!bVhnUCPDlN9`<hC9WB<~)4Bc!gvAyKHXm@}^G_;H=bdKR`3rwV}
zCbR})I+26;s;bLT{1a*o^vPV1?{K~Lf@^Wu!wRzc)?lfvpfwQxNIE`31T6c$150jK
zbTOtIOjsB&Vc@iiFgj-rD#VwL)2;E}60Wh@rliVAO0kN-(XdgY)wSnN<v{l1mA?cb
zmRsXyCo8FIa5FaRbXe-uplQ%-h~7?80GryhEr0Yr-H3KS29oazR4hbq<e2|GyQRl>
zQW|kk=!zipXO17t5EPzMC*OY@Usz6Ro@4QB<OyFg6&T?f-<^Vmk}SD%TW1VIyZ(-*
zGRvBF(Z72Lfk@3J_*qn_jQr>u)jy+BXlNBD8SYcoln6U|P8U!8p8Z<=ewsO!%pi;-
z5bg2tFv`6Vjcrad$=2GHG*iVOfST{LbKI_>j_>nSDn8Y(=qR&cf5Z|qvh<ZiTL()8
z>-XXLmI)us>}Nfv-b}tgk$|X=A0vN*E;{>Jh}IJ}2{K(gH?J41K7e$ZN`kh~H(?7D
zf)Zcj!eD6X+RHEQ+)<B;`ad^K!>fhy|9Bh^&4_>%{bK33zB9dbU}*ze*eb-^Ri+Ql
zIX~P%v8ETM4$nM!a<pKGNE`H>`ZE2BPhQYNo+YnzwRyEO!{@~1dsk<Q|9=+#-%qxF
z6X7ESqFr@)I2*G3>B=^f=#uXCeMn(%%zOeqU38T#m9M#V3a5zdVyTBtnwpQa9)0<j
z%w6lTg(IIquD^|g)sTFsf*?cv4K8lR^Khilp0w9aswq-MXs_>%8%1S;%rhswi=4cy
z`4SZ&a_(1QXt^JI2=<WD6T@Sd&Eyzouh(I|;Kvx7%q^Xj@<D_XaG$*oMgJk-tPy19
z;lepIuF?NuL3K!{FDx@Nl=503lo`v^F*Ur80nYKM2iy$#x|mw}k(J*bvfQPQItHeA
zP*soy>vthyvr+e9)J1^C_?2r*>rejF{S_3Ir5e0Ooxfbp2WOVR%0VS4+czYY8Yx>1
z=jD9DWNU;27D+U!$dH%j-4gU^Jy9-tBeRz{LEui)8F~)&I!u^_AW^06%P6DUMbEyw
z0u2$1M6i<HtalbUDEzP8U3PJs&hm$8T=nqk>hgweDjb!~VObAy55Jlc;=G>nu=XTV
zMy$9w>dkEE?}=VP^Qg~GmBK71NhrbsLW@?Oy|gEVrVo_VnxoBibYJ2%t@E7nSBPcK
z1vnbA>};6lq7vJFe1CBEkW84~lIb@cCbqy#%O)AkRmag#Br*{~)s4Ho;hSlqJ3UC@
zr3j$OHGEC~@W8v16hHo9waWM17oq;4pQe^mu@|wqTi2BzSj~!~NA#AG;r<Q`?$Qx9
zpHM!lW1`gWZNsA5he>?t-0C><-<VB=I3BwUX6yR=@+M_Fp0M>6N?CZ@5<eIFbVmAM
zPMkeAXOx{a`1yRFS75l&<m&gtxu8)buXxb(`|Z0Dm@h68m%4TyjC6OYdUuzH+0(`O
zS`1EM4xIM=OghR5BA%E9Ta>lWtKMkm3=NGkaO2ciM|{271;Qs->Sw!-+d_x)LBj+$
z#9t_1QK^VoGndI(j6J`2P%#;~H`uZexL+4ew!|dYz0Uzi1%#mIO1|plG#p{?2a?mM
z%<%i8*1Yzcu1}uUW+qEo#HLX{a;2B@>|8CNaB?$M2)MqOlB_WPI+jd%ZP`@z4x$N0
zrA5o_<kp;Uk@tvjnn%Ub9cjZ8dtBIbN@b{%{5*4BW9t(dP(iQg0}Ay=Fo|yyE=$EL
zery73|4J={ORhh;lG+-o)HRda9`RFYJ!jRg`9!J>yg(rCpBw7K=ci#q<G0R;H+{u~
z2FC=BGAU<%((=(-HjbXvMZ~59>m!1~w#4356Q0-Jvfg1lN5{z*IjqWf=JUvq-$i^H
ziriv3*>7Jk%f%vgJ!q9e@-Q+cyxtm;*7gnTe{2u0j|aop?!=cJdxqvM-yfk0FXP)i
z+#wdbz#F&1A4M#Mi(W>&I$yw>gH{E2T!Yq}cpE)*p~D0FX-Wfr1a^77;`8@6^n`aM
zYw5AcTGJ*QBMiOXAq47axTsl^;DoYp3~TqAroUp)QvvS&Jyb$Y9<3tqh<EMSsbUux
zHM9Ru&dM8Nj1pM#t|M+Xz7d@q(3jvKmT0};_mKgndflXztysiIb~GQ%CK17swBKvP
zDJ{EE>9`MB7E+;3S%*6u>ZaWEWg+e#Tq-oP?DD7BoOnDKvaJ}JorA6S9t*C5-#Z{X
zgi6M3`r_qadl3gz(-qkCH{4RsO+K1p)(~l?qFJ0-(g!6Buds9H6_lEt_Ps%YbaKn`
zaM#hI9j&HpLDoQ9=@>sCqZU0wH~6m)FWAatHmhyUpt+X6lT$vMM3CKs_SDVfH&#Y=
zSC0jJead_-B8hSC=F4}ag{Nk?G7K-nUT20f!*vmX%*R?bwl~bL&@~TFZ%5pU&RWS$
z<4Ao;tNT{O#ucJ{T|&(gsh#1rW^(M`c0XifB7V2|Xq16v3{5e%T|1{2dw2H*<++84
z$zM<_yyse*z8xIwy)>gwA)!*qpCUoRo)1=iX;{sagYA*SpuU*>4U%}ZF)!}|WX<@q
z|Ic03|E}lo=4%AYyR9$Ckdn?O+t&25CU2ZPZWehQdQtNf3AKUFf<~8etoA3zmzQcH
zx}KhwqZJpZMgOhR?C|k9-A5_*#+XF)%~8={)kj8F{zr-wK#~DV+hv*c=fBg9=;H>`
z7Rv__>8bC0AA)O_E2&i?7z<Rg`x*i}J=sW90=!8wAk?+p1B#BAGh)na1kg#lnN05k
z-jHm%a!@9qt3mz0TCJK4vDYTZkp6A%CQJnSiyZ?085Bn<CSk2Pj7EXqH#e8OrL3dh
z$A~LP_j#o)H9|FY{W;mOKA7(&q7X03aukd)>K3{xUd}@bzb&k#iiAC}ud-=oXVzHR
zIU^dz7}gS(Q}3TDww4f;Px_WjzO%kq%*>*s=zXlyC=0MJ_=^4jywiXq;$0}5Y(*4j
z&Fp<njo(eX&}odJoId(k-#USwo)*at)4kH->xc-B{JQsq?ano+D_>GMw0z|TUK)!Y
zM_<kQ`LK8>Cum|5ml~F^f^t?v{F0e5@r0kZvVo}5??Nv64&jVT<j13u8T19r_bG_5
zA&Ekt@Mdz-%B65QfOvC=TM#JJOSE@&@f=S0uFCyg!=DYS2nHXx*!}xgy)=3I0Fu9U
zqj4fNby`JV)hZWbq6iBYT2Qzn1h7pZf}L<9P>ADC*Wq(NCU$*S$KNT>>qEqZx&@5g
zf}i~>qt|KbJPuZA29Em)3X|<6)LqdDU7g@@lC+J@pQrbPdToWAarA|7GpKi5#*A8}
zhW0k>)Thd8^9wKjE_4TRr2i5cIF$_V-W|TY4ik;qj6qD&wY0if#etr!QDC|(AVZ?w
z_`>+}v9*w>E^@|&jof^f^VDOSr)N0JSA;Vo9V3@wf~yEaVWpi8l{0d`TWMeS86Blw
za8YK21(Dx*n!Fo1z+xrMsvidh$Kxb%d|L`3ZS?u@H6Qf(J^b@YQfRHMWwvwcw#AtO
zd!m~OsKmpmrhfO{koWq3arTu_ad6p|P`C#PE&+l|@Zb;#Ubwrv2X_gs!5s<@!QI`x
zfZ!I~-F@ooS>12mdehxA{gbtdA9d^8bI;j(pMCn@Mh`w2nox&Zlu?V$b{*kO3b=CV
z-8N>47@L1uqU}LAdalxPFW<WOmE|D~R}{YYBk~h@J%7;7u%X=%YZ;To1D`){AgQXq
z+F&sft~@*37(3z}sn}Zy^Y2+lA7p}8xvnFZ+@TOm&FoKDZMX=3tazYhOi4o0VyoSs
z@{%Fla;h1R+Jd+3c|&`|Zb$w;&zktuV(%^nTuVCv&NPw<%JX=h5<+Wx)NafBzM_h)
z=T5%}x`;}f&jEqqn>=^6ZUU3oFqM}rYrzie{W=)2Wa3psben3l$fZsaCBnn%oZG4V
zv4z8m(%p(SN_w5GUL4R%m_J29PEfk5<J_xT;xb{;QmFuYBZ@XDK8i)j$nAtF&a#*o
zLn9l^dFstJW|Mk&b@&vrhDSN)+qyr4l^mej;qeDl8~@E9zCMVFkUC>CH)K@?SE^Ok
zu6edJPe}iTht54iLJ7@Wm3YA7(say(ll?~DuwC1#wZwv|xY2i{3rnt%jXmnu&e@Xo
z58qX#uNphrVyan-3X1Q8qOh=!7bVvYFhCvU?@6)@QE!9ZRhakUqEw=+*t)}0Ok&+t
z0`4mDl^DDayZb17n;O0bEJb2hwuelUKzjz<;MbpE3%-))G%3b@Cd5<F$m+@wY7NOn
zI?c&6>ZGw-XtO=9?~Hz3LloqnSTBjMz28i*cd&NGEq!1sJU+Bq)%QowO9EVHbUqOD
z-+ovcHHHw5F+$I;2oWbJVHbC$I`yeEuV-7x;9t3*xOs$>-oPIT*Y^bt797DUA&@Od
z2WK|B0`p%<-psNYbZzQz{Kr+qsW8R3vZe{~PQ6+<&b=*AbDQrF^`0J<El`p-2%q?H
zB_K-ip^)U`@`^9@^SJ_e65{`o^7>nH=KlIuaSQAHGWgaG`=@>2j8msli>$J9z0{ji
zPdVNabx&4p+lI72_lEX-x1{_1HkxkHCVuMk7?BYDOLGsAg<0u)S7flXud8BU!}&!I
zUn??P5SzVSGS(3gLhYr+#+R3UVhIQd2LprI72>(hscC6t8OXI<?zB6yOojHXF+pUB
zzc=J*0M{G#Fq#1J53qWufKL@r<$_fBfAU~|bDT3j#$Io(KoK>jVTZ|~8k<_aj||7c
zO4R+8^=R`YHx#XgjR<97VWE#=1__(TN>sckzrl5DsM%@X3Io*N5W=<-Q(}oMZ;5PT
zM~xVgI!46W`$MPecd&ih1mE}ES>n8dL7bh2<WtRqaH#h6<SIwNCy@ZPYiHIkzZC;r
zwy@?PD6$h}=xh{Lzw6QOSF4~|xrd4MUXw{&=it=KVI0%gq&)nj3M2A<lX26p>Vqtk
z#YMor8I8$ZPP+XGbNBBFPu4JmBIDd^tKlFjS<6d60v8^OIJxas3|;#&+X^30=F!C^
zKcS>V=;0^EO){)n#{;TzZ+=sCX20|==afX}N+{X5xc<|dw05Oj7WY^v*^B9Qbo)I%
z2Tzi!_x2wed4gvbISY)n19PQYxFr7Afw-l4mTjUad2Ts(#xx5EA~PzxZCJeM+*x_J
ze#aPi;Zb$Hv#HY>_oj%(;^&0+e2gsqD4elz#2q=|_C`Zt>syy7DCT_#=y?2wQ_Ek>
zpH@NtlLzo6sAa(*za5E$iC%R9zU7CoU@+>;fcjoCi-%W;R5z=QS?a!4ucAIzLM>);
zmlSFye%~j-Ly1zFfWG=p!~Fr-=aT{Ygkftj1)quUr|R=Z2Up%JHwsM9slbV|iH?SO
z@WPa6H&2kTe;(7_pmbb~ONeF11!~?A&V6%S`m*d$<s@6ltqgJ_yX5)P&Fw}RmImFS
zI6U}uH`L;E({W=QRL2$AeC5~ObB~|Qg(7KobF{iTYHwoIIy^fNbZz$){&8wy3DplQ
zN*+(aEw;=?#E4VNirfepAt&k{8N=BvPI<QswEAXJUs8kQN<9!7<LzIBxT7%n@tgHl
zlcO)bjMLN;^%ddRY>0S3vYvBxLD(u`$h>KR<nXrHNUG*(MoE&TEMg@rf<ak<L5y$o
z_#!51Y=se%*6Ml`uF(AVy>`h@ymF*s%G%h^dMNA(i$Cc)gs0}e(lx@Mrx56lGe|1a
zzP)aBUWKD4XieLG;ZwfwKC;?wslpUzXq1s>I3)DYb6unhzS2=EO3ae^kg|Deh;=*i
zo0IgjlZIiQPlV-*o7=B1z<1I7dzs!x967?>Uw5Y&=gg@uRvRf(w|Qi-E6=jSqs5*b
zKG$D7gTp9SfrNIKUB-=yeS6JuA7yYZX2Q|RSOUDBcX7-XQmwPY$HL1)h>E;mE$|xi
zTY8SCsxNx&0CmmeQA6R%`?)wm3pQWAYg4(N&C%^}N7f&}t-M-=LbcBd4_M@OogjlC
z<8?1DOcr|y+=L=>?!;}oB`;a>FC(UD4kWsRODp_lW^)c+o(Y|Ja2F%Gfa^B3=Ghs5
z+bGZVO~Xce0)MC}?)i(kzOhN-UWE;k6e&@w+sCf;pKWOEVVT}!KDN-A7qXPC{4qj)
z9z?w}rCL_CzDvu>{#?J{5$G46@O>|dd^>Dv*%hCVckS09`J1fg-KgQyhjPcR(^1DN
z(Ilu7qI<G^{Qa)9ZWoogCjGZTeF#IE%Or84=TTKJ<ZCG|<Nt&Z{L-P<_ObzWSdLV7
z;WThPgkN##G=L>!E=luG)dYX9d;fTlJ4gbqL9T9nKhr9K^lOeN`c%U6wp79lVOBj%
zXRebO_w`kcqpeR3ov(78ocW!dZm)+w+6U(4^q+h?FUg!AS4T=%0)7q=Nm^2~swU(R
zJ*2viz^Se6v;Wk#+16wb_M#J3_ML;Z@QQ{i|C3Coh|`FbTiceKzDuc8|J9=CMPY@d
zU(I0XBd6jQThy$`4)4du{l7^Ud>*}umRW@b09-9tJNX85`u6WZy9u!STIr!zdjG8q
zc7)sig^w3@o%^&h>9{Q^B-fCxXm8$Q7JsS46^feR^zar_5qP}Izd4h_!pa&zHejTo
zQM}MQ$%k$a17LcwII`%U%7$m^1`m9dya|`^S)(ibOlK))?C47P*^ZUO%@QUfalFPW
zf}8J`PmEp!BnuBHJ!QeE`I6o?c~`L^O{x6p=nnCA9Qd$%+A4Hj!a+?mhKqNcxn4+!
z!4^1MMkTC_Rmu{VS(4wZ6E9Vy`B76ZKwfi7XkIM^C?K7E<>*_PQ8EfY@(mb0QS*vp
zTF2M%=3AN@`+4cUdTr8V;jhIzB-HGH+?~p_Yo5SQb~Tt?^a-LoCt0QnGs;CA%b8Wm
zYh2n3w8C#6%2S$aD+#&SXljQBVwx9<lCQOPXN*z3<D>ffIV_8U(o=z2dCyrg>{H1l
z$6ABiTD}+li>E>3M+FNKU-+el<9Bd)!g2RIYDtrvN1fFZqJgPOCD}k@j=0Z@zY0Go
zLopYrrM=2sBvu#oJqGc*3{-W^d*H5~y$D%YUXf=$B}&!dosX;IfXuTKAv1Uh6ijz?
zrI81vi9A_}+P2%Jw;C`+dB1*dcvFA>Sh&pC?-}e_xjNfZpliM@OKduQUb&Xnq^;El
zUVjbL{v6_%)w9H=Y?>qIrom6<cJll7&y6U=eH18X+R`$Lj6%d`5#IDHr(;H8SFN$#
zEP7J>hvV5!7L%vCErhW%hrZF->vOr@*_d3>6Fkv|!_~cUx^r-zotY0Df!<Zkp%j9b
zM-cFUGu?fRXT`ytzp6U7X4Wh~iiGkPZnl@SPO_3-_#z`imN<2PonaCCI?wIwtEp4(
zrs)eh!%Ug7%}VB1#*u@xk6!a0dAK>Q-ZgSGIk-Dly%Ud2xO3y%`YtTV_fP)35<i_p
z`wtCesZzgLujtdQ(a=sFV%CaVy9j8+jGnDBht4p>Ep1zd=5JAQGz2*mcpxtZXWXCO
zts6uPchVDgMugt5v94NNee-D29hx5466eFC8#Bozv`e|K3o}aIqvD#IxM&*QaYtQ!
z2?)e4eM#6e&UW&?p*Kt!Bqs9NPK#<Km8B?|u*@{_;=4rS%TJ4DKjxRq;>sRO1C7}l
zn(5T=>K;5vRCo1l193~5qz{?S!{0CGn4_9~`@^%)Z(4b`tWi1Qr)KUi&=RpU0QY*@
z9du<XsQMvkX4{j}ud@0H;Lv(<z8Jkyd`thO99rni;kA!Y%)>5$L!K1QXV2ieGcJ19
z7M+M6xbDXDuw*rdHSia=)`(GQ?#-r=eUwO@!fkq~;DfDK2&LPc0HymLl(cW>>YA5d
ziDBRAh2vtAT6_CaoJvg4f1}DZwphABP#F!+m2GK5)-~+5CgwF1_Gjd?Miz1RUZXl|
z{eTZpJAuBq9o7OSSeKFr{st9&GhhE|_ye?FN~MoD!3%CjQ+>#AQtRmA_s0OVhFLTU
z_hWtV+Iqmu3j=LAZS|WyU*9WC>0vmIiK2+tJ)`F%h5K0)T*EaMv+pB`xQ7n2$tg{p
zP+WhUNbo<=YyCaL3M2C428g}~p|!DBzAob?cW3;d5I)jY>2xc!^H3f7)uU|>Cy2}4
zOZ1&!1PQKag&+&)yF1Riwz~QCS%19GuMXBi3sDPjoeXtif?QWm4XsrvbEZ!FH8Jg8
zM_MUFLtEJL`{%Z~6a#~$xPbUTRteU$@TsVRY4hfp^`p5=!S0EhsZh%o5_bBFW_n?E
z4^L|f+a!1GvLT`z>I`Vt%B;^cv(d5#*<28fL=Kl@i97@e!At6jWEOr(&0BEYly$Ca
z%%wCC?yAtAbz9GCUZB8oQfCq1jF!Rn{>ZQFrD|S~X!VT?)WI4kSad9wew3Ph=syF5
zPRfy)evYc)`W(`{2p2UrScSW#%*3r<zEJS~miUblaP8D~L25ZwYE)QUogfAB=I~hv
z7re49NG>{`-4O#aQP(Ao;@JxMeN<_k=(|EA3L#u@Q1Mw;3FO-<PwVl9_Yr!*<KWcX
zh<t@U+QM^ueUciRv_I7vspSMiNsuJ?A_#WHK~q<u7Z^s%Ze|GiL}&EQq?%t_8ZkWF
z{7HEd+x9q5)SJVK#_?07M97!o%mg`)uOmey*2%ml{cZ!b5uW*VdqpU}kkjAw$+Tdv
zVzaeVulIPHEkmKreg0_AN65m?Zos+~5zMkc$5v}7r~O&(`QC-YBccjeV>odQ%REM1
zh5zYiPX6ghlntYCiFvvwo}SMUP7YXj%4=VS5h(lTQ0XQdp3i(q#(xg${5!DA9Og$(
z=XwY)HW7@^E0VZfjKvP)#Q}wUk#df{hpbwsZjEZt)DXP<vlAzY#MXhIh_)Lxd{4sA
zgnseDn@jY<n@RHih0Kn<)iV<-_=cKyvFC7>g^0~|Vq>{7l(qZg`6|{lS*IM`mw&A^
zghXyv0;R(~piYZZH(c>E5Yj$9qT$FMu67IO_zr?}^$)M+<ti~Mv!rt5$n>A|a`eb5
zIxA0(u8w+d4sJFcy?nfF^>gg@&e`lY@zVa}$LGwnX)5MH*;cWKhf7HviUX4<`pr4n
z-x8s8nUgpn<_8c3S*c0!3!H^2)J*ziTR?weYmIb}*@!Y7u2@>^x|lP%S&;}4cbnGY
zt<q_|9;8Cpy1BEGv&DZ?^x^c@_E$p!KN24f{6qvt%p1B<2$S97{&<AkOm{`ZHVCxX
z;!0#-C{i{<7C3VdlyMM@%HM9UPH&=MlJ1m_l#)SLM1L69oCr*8v#90!bK8`fJu*)(
zpeplIWjGbbavG^1O)u48$u!$C>hP*>Vv_K#{GNw^4idpNx#%{mjWLvXvAHdJ9Gp#4
zcxH!A^pKrGyH#~q>v5T$21y;<aI6ArT`D&DQdCWB<IAK$;lsJIKE*8er?Hrq9~B87
zJ~OVigfV<hscwq*9GKUI`1-h~g{;3GR!%K%3^JUOn<R^09N<ynXGd5`ZMntkV|d!?
zac3i-?e8#8ZX$OnuIEz;Ek{_>nyL`8DwmFWUnWupKAtM$yYGo|z>ZciKSNtn;yE6$
zDVyPKecHZx^jIgl#Q~|-a4Gld28eSwlZdrXMua?buw_78lWGG@xrCQbu2Q;>L#9Z@
zjg1B15uP2?;x!;R;K(##axGPXHKE-xm2fGnw>reChXov=pPAd0k!}q0!`{)$0{$wE
zE&lFf0NL+k1u_E<S;cwmB=AIthj=Z<>+ROQ_m(=&ldc6@=HNh|srM5e*LH@6?*P%J
zY9-BtLF(YHr7a&<GWCyDjUMndyc(C@SV#~;{bxy@e=Cl)!Gh3ngRY8=0F`1H_WH9@
z<HiErmvLqvA7398Tb{p#<Xgo<8b|Mn@%F>dwX)U7vSMg4{h;AV==YI7sWNOQD<SM4
z>^>V=z%MKiCv^J3q}<yp;M!GlR{gMg{k`B}eQLyC^jsY;8e>fF5RtC9AlAIX$a<P-
z<<0cG1O$<oH{Yg@fGY2GA9#Ww7F$G;xPRr+y^yX*24SJk8Go9!6d)<Kblk-NrF2>u
zt>J^WFCK*<`&c1ka#1qoGVqIOflx`?D2#T1DE*Mdma;wVC{H^%tT)%~k%419C3rfp
zA%I!~*-4}IoORbucW}Xm_^A5ij6Jk&=t-rtLyTa<&O%~)LEECDF+cws%J8gaW@mN8
z;_P+B=7wOf;Q2mY>>f;I3-BHaw(J%6eo6oPCzZ)!fsY2v#fv|AM4^`kuGH~g9Z<Al
zox8O(zdS#ZRdIX6<j=5{*<Y3@O$#`|LJ<AZNGl^s@778<y%e<Qm9-rkK<%hwpHj2#
zq$oT)HptfH+#}1vnx#tx2&taYs@;*TFn+ejoKOj8v>S3~$mi#C205M33Fg`$33>Ac
zN+sWX#EwLxra_&9e=Wil`8kDw=cmq|)_%^_K<RzW&F?BmWqVMmLE0QRidS4!_ij0<
zx3)I7bRN6)v%i58UK4>~q_T;8nK6%^h?2ek{V`(|WB9*E`hAf2u>sd|I~r8Np@gZf
zyPIf!%pKIDb_BI|VYQs4jq~^IAxE`Br|#{UOTM<vkM8w)7}F&WGQgD)?PH)XIt7u1
z=%VT%ktA~n_&kJy?5M4_H6d{v4-!AWplt6vX@%6`EF!a{fEcrmbR%Q>%xc)Vkr@oM
z%+dL697r>lus}LNHZ1}4MANwn`xDQ(n0Y)=B(P^Ojj*}<j7pAPG$fx<jVy>0&G@#t
zQa7JqQ<dP+zQ9m@09*%bCiXxi;_l%{VNfqv_RkU;E)akUdMT0xB?rowMa!@{eWU8?
zic1K^Tv-zb*;@-`UjD7@nWF6QOT~Al-)Mek5*7y}U-cU?Zd{m)+_aFQrgeNtr-q5}
zA9fkWqGb(@%{QOFF!u$dnEsg;!s{3Hm2XJ<^Ocy2OFVkOX=r=F;HK+nnfbhbySd%>
z^6&z2AyD_+4dNaJ@$x&oq{RQ@=8{nT_ypybLc7ykS>&-Yj%s{3Eyg%GcF{CSIY`4L
zd3TJtAn&gxH6;EjXv#`t_!(D`?xKXGnF1MTuy(^=fVJ)MT7P~(0^xH**eZ<)1lx^c
zj~4VG`mO*daRfM%(D&r#n6zfqkdiiOLSU-TG(Vrf?2Ulqj<ok;o^J{Wy*y@JJ2jLF
zFh&pW$7IxbhIQ&~WUWmV;ZIx7>SeDlq07^5k|k!=xKGH-{UMT;i=b)OOM_eR0xa)j
zjQV%M(`Esi?E&#>o9|y+BBJMO)3j|p=Jc)HcpUIvx$xwvhv+|VF6u|iG1eC=73|b5
zohA;22TteXb4KYO(mwlGh=6%I8gZhr8Om*tz|w(`A6nYqm8E2$AJ!sr%MflqOGb>G
z4_kt~#eege1vMYfU`gY5vKW)>$>SWe;fZ_uc2+3`piXXQ@ff0sva!R{q=x{K*+PF|
zq<+iCEGh1vp<6T<YogN;O+uS>3r@`w{F%Oz*WST!xRHIaPr=CbPealADp((Nefch#
zMuNrF1=c#!dg$Warl?avD+ct22N^e8gyj*YJ4I!FZa&$G0NT&eyDqcZE)&o@ZAnU^
z3<;Z8++=DARsoL4=z3Yw=wAV~&XW|-RKlH)hoz`lm48A<@v5pg-c;~vn@ix#<!fJS
zpz)ZiUW0>+wft;N)1gSXqj$6Oxm_EuWykf9!8X}Bk(4PKeUHE26;(X@CoMue0^ggU
zeEU*jN_+M%s_U++ufkU+&Qcd1S`M0O<md6&?$odrx{0cd$X3{(+1sf}rus&#hP|0V
zl~4$vU|SkHyM891mvedg?K-z*Q+u3mPG%-_T4s&3?x^(S+pm1<;&q;mzPiS;+3+a#
zAVzz7H63z6&x8Y0v!av}O>7y3w^E^z$s{EY8UNd!ZU~k04#d#UKQnN@aI$EaSm_IY
zb@(yL4R!aBaNqmanX8!NyfA00QEt&ZoW<<?ymB;T3$S?aZ@z?&!t4E~mYtZ;kCxae
zkAGce#lJ3dp4}o%tzJFAnS*eauuULssX&GN+#8$ak}q*_6*hDfrg0gN5z$m&r%AV?
zpfat+7H-1WjWcbfwD;ZD+@qs}|8W{+Qo{U>ZOoE`&)^%pp_9kPH*LdOHu8m^5DF|#
z^=nDj??>mTgBz&=Y)hO=o3<-9e-F9&>XH(qV)>jo*nOFKW<y7hi;@bdCe|o*xwbqc
zaLOnBf$8aK<?^@ekti<w@-GXkr0(CD1*5xrq?+v2k%6*i@h-eE*8{wjGz2Wa(>t|S
zl><@#uLCT9Z;1Zzkb_RwWuRuAYN}0GgN4x`jR%s+6KU}4uV2*aZ|!bv%=d?kXW24j
zp7#2X0y96QvQvGF!QirX82GR#`@j>H*$Vw$9$&mQMX<_K(DX#-apl(}*6%lI-?c|b
zAxQ>;DvyVsHI~^6QM}*iG|+?WWZt);aB)F%5uA17OR>M3=Y!iv?cb|U`bjNvMlDQK
z4qv2sRo&t`a|&T=AuMn+7U;%U%>K*8*I~(xze<mQP)bPZ?Y;0^EQWAw^Yioit{-b&
z|5225L1QZbu1l1Q4Gbgh7W!x*W*RwWc*w9*GqaH*75)tB6~rA-FC6N6hgg7r{L}wz
z8~-RE{d~H6@Yc)j^7^U$g&q$OEB+_#9mtLOQ4f+PirRA?TWe8Y>Y4ut?t4F8KR$bn
ztMloeTtD7JMtn9NuRS5BC3b)Z<T9b-E7o-x^3ui+C-Lvz^zSZ+H@l|0;c+`Vx^zmL
zbW#J<^)`z7H!Qp590Y`_?HnFIzeC>hYo!uq-w3ZM>2QAZJUp|GoEtpqb%EAuUzhWr
zSizi`br*ovg0;w6+PKcafKKO&di0Zluz|B#_z%6^)PFJ3A7D?(A?G9@Y0~9`7zX77
z$t2SMXf?Rs0a~C)P~qbwsp`m{Fbe)4F!qhCSMmeT)Y00%`uhr7{2PuQK|~mKAEui&
z7%@PU{Co@rES)?HqjQI4bw^Pg*?_^DBiOFDrgt?fr~WrBmak8f;LAjZv@f&5w~3{;
zA=-zu;mLE3p01A;y4x!}FM5@nYR?i<;AKEvC{`VrTql{@AcXC*@=^gIf!BS2(4Ij^
z;35fJ5U2RFgn5#j>AO{F|2dBn9FQy*%(0%7|C;ra(80!J1JrnXSgbZzdf793kIk-c
zI2Kv!7_OGsttx$sFPq0Sh_u%GyA}fJ6FO<-mrA68Z=}P~_-qG^HK>N>%kZwV`9+WJ
zmZT|evn8ZAc0seJe;mpDdk5zGxsex9=de9YuDk^+ogq;}Ob@vy81LVl)SH=wODBW!
z^Yhd3uUE>07_0vAW}O4E6*isZ<uO#=Soo-fW22*o_p*9d5S1GL@sYpZ!vC5!b00>8
zgk8UpA{I!$=7hQQ$>^OsHQatn$h%DDP;m_@pZbYB=Fv5#=L6n9w;?4YodV*1s#zkF
z%yY%_qw~eTPL5_~(dQv)_UO#IcxG^&VB-B)#)%|fVEVJpd61#Qqv4+_tIMk_y0fRv
zn3ZAVUjXMcBrq3u8xH72P&TNJ-xbnm2Cc$b_-x#2pLq?O;s3~mYHy$tKH5>W-VQEO
z3Pc3+mGHmJPeM31R|=RYT%s{_GBH1dV^`_~^-J0!BU%%-p<QX(WD5)-gskvAKx8Lg
z+?;ruXX25P#$aFYQEG-}_qUEH6{+%1^YTyX<=9007H^ki<?L7b2+y*Z&Y8T?4nt8b
z*DOXdPE9N|F~JsQ*1QK0IkbZY>{ow5#>+|b_7<q}WM2ylL~Cp7$-RgnC6vFy{cp2+
zlZ?<eFu9{Ufzn2TV{!s!Y)R7ODWfF2Mv|-l;<7`O%qFmjZf=9^Uc+;`YU+smld#z+
z5NDN))5H)Leb+sfdd%yMNB9zwN{sbW^<r)ybj#TFHpPq{yDQl=(1*F@5E_!Y%9xAj
zOR36rOHT?beG0RJnx&VJGz(WRC&!4?(JLG2g`WUb#KM5<1RRhXweXovC)>?LJmfs%
zh)0gh)%>{>;CFL|4}%s7g2oSmMr}ie6$+r*!*zIrZFs+XSKRA-{F0H0Ruuw2HM<%`
zmgCr)q}@M0>DSfQhlP8khGUC<FG8v@`)FH1nIT1~X&@TG=i7({(nYLy&Aq!J%dKCF
za=4_QGp9N4k5(NkE5a~+i<5>t=?m15G{J@9Q7;sb1-LHPZiI~Sk);92|M!9Z%TxPr
zgmK#+Sae-~HP26~t4w3?)Ixl@G{Q%sXHjeEhZE;sTrq-0^l0<Hdfj5%wSTFJ3EW@L
z#ydM|=|?SH-fVd4lXbpy1P1np7u2F_x(P^Eh<BZuUe-o$R7e|m2gM|<V1i_{0d;2v
z5LCj~&KEKGimbPd8$d~AcO&WAKBIqdqzxG#;w5QImqP+Wa%Ut|xia6%Yb~Adl_ZCf
zFPC;I)QSJpVet4y(2Vi-{xU)Uj=~6aoU9FnJkq0wWFXgqH%sgC)QVE*jD&90dn5c#
z{vZfM&qaT8E|%_isDsd!%weSd$;i@-R5_fD>*`U_d^5%<xVQt335I6s4?B4(sfdva
z^k=h8jhGz_H;MQq$jO39vy|zFDV<H!-C6#s3Gr#t{woFl%V+ujNC+N?ZFK<W;2t|T
z@kAglPC2^D*sO#%AuVMZ3ITp39DW)%&`asg$<2L1b@<#7c0ay53Lv&uChdD0LMO!j
zu!!m3ZM3&m%+MQKMR`gk{N(NMhylSZVfQ5#m_H3MPG&;MKCBHHFPKz!8P(RT`UgwI
zY947Ht5JiTGQ-&%cw&{P#i4n_fxMAD?AfrkEPMu4aF~dm;5DPr!o=>&-xOS2XhW$K
zVb^Y3S^DUC6C!C3SMsdv{4p6BRApw)&`U!C6R@o`P<~Blq^+2zEBrOXXk(Ron3FjA
zKLnK2L=pMdVO6$rNlrqu&ywN_{qkVFpNZ$!)+%OM1q7ls7;nEGCG`A@%JY9d-G4j0
z^D^uzFp)EF){;@tj3o|oFipo$$ZJUcdn$}GAljU@DiSz1<Xr-Y4$2PA<WJSyfmM#6
zPL9Oce9YfQb{~G9Blize^bcpU`|Gd-*31m%isOGnf-D&@kS*`k8tNIk)@YyEn_oXu
zebw74O`Bm1elusX`>2aHWH~&EmPoS7l1ghxr26fM(p4LzQmJHiX<Gt>{ym^z`Dtg5
z33{ml_6RbqY~*GOsB;YMt{*Raw9;4fMkza7&4Owd=*)()ts`g>bWJ^p?LN3rdn?R-
zTEqgO;bhseuyU>*I&^R39osNkTTW7C4<S=Ycj1JeFn=1u#Ri7(3+&^3146{gCMlyy
zircK0Kv#OztUVYMIJ=bZ5O!i<h>fIO!8z9^90a-UtvDdjxnEEM0xFQXihQYy>iB3F
z+<fSwZ}6sE$3xpPCbd3^f(b{TP^e(_0Dwc7R8f+gWC`!hUYRaQHOCD9C4C*{6s`|R
z(gH~s$IJDj41Z6=|L=K&-wQTM+?ex2Qe@G}z_*9tCx2}K#|{5?X}b2-()S=vS^Lr1
znWT0m{o7N5hYHuWSG^pC@nT312NY*oARc0M<k_<pq52I^3Ac|Ns$PR+;Dnxhk8E>*
zrg6WfGiD7ivTbios+=!;tlye_s+o%7FC0TXnz&C_{5IDs955pscU8?>&h~5g*Q6f@
zWQ=Uaq`GIrv3KLH_dRNlQRUKUta1t>I9BxRA^R>36Lhm}o`KD!?jK)?jZTx0L&uXc
zeT0+Ao(Nf^O<+^yAyVbo79E<3$%CUL&yJM7$IV>YZxy_Hl6!0snjkf+78y7CD;@sa
zf5%bF#5mH3x!?H^)u@E{n;7yduJo!LA3$(q*(NM5%8nwTK3^ERrM?sI?Bx)@XANsp
z{ga_7B>M~_8>JD`_v6e9MDJ4vTUP1mzjH0coHIi0w;?1d0n~W7<W(Y1<04FAB(mt1
zjT)Njw$Xx9c0Gc|(WSRF$G$aBOAbtzb;6o$*Fpn|?;Hhb;GEd!C;MvZ#NX+VjVu+4
zpg#Zs2SD5l6Ve9}DLyhal_QMTG)69s#JUO3)w21D*-_Ta#<43~=FyWB11&eMP+)-f
z0w|w1hlHyU&y_Q06_Bwxw8JS}c!Srpsw`PH7$;XN$6Oq6W3eX`-3n)B%i{sR<@x@b
zrO7Z~+|UmR%wG{Seh*t#5Qe+~QmHbv2L6iz>7S=f_YOpS_*AHJT#rxCEp`mhS{Y$8
zws1s3ms*FLHT0D>EXp71$hRzoJ96>h{qX++FJw3gnw9bpB`~Wqb-r8r;5IB^9edl-
z6`VnoiYfNy4_4$icaMP5gI|8|CgpY?`3<*M(SCA&XE|>VkovtK1`jbu1;3KWwLr<{
zuYTp3n&7adfwM68p%hcR`;ObV=lni7CyPwv;wjcpk2v>!s7_0Ew`@XbRP2)^1frjR
zO8?w^BTgkOp`MrCRT8WIf;`)YwId0sWu<lwI(@ldEd(AGVM-H}Se3VIT^agyUAA}V
zplIS`sN$9+*$x(9^92w~N6}I;!bi+zxj)Eb-qTTiA!6jOJ8?iDn)<!^Jz0`{iKq?H
zgSaYf@i8dgkuFCp8I5_<dMh;}YjFI6R!ym{es$Ht&bn_gfq4N10y^FD?(Wqrurz=y
z4WQ0mc2QfF0sIoSAYj~Q)iMR%wXZy^!HWk3-fkYy8Kz|E@|mKd;J}t^m%fx;2TR6~
z{%C$p0=iIy4co&nPBKBJv-xz}fuTm#{X>*7mQxSM)Ct9SRor}`xur828WR+%<f8*D
zymF|Z`f?;$J0kCG`;A9@I*OFY#1!Mv1r5SM#{T2nVYD(klf=BSd<{;|4W40b1i#wN
z+{1EFV=z)m(sF&`7v|=e{Y&B^i9wdms)&AfXrv;S(j6Cg!gn@8A<1)yErhE-@07b5
z((9e=aq=~?vbw={pIP`C!|UT=c7?IEJU!o8qU9G(pb07WFo{dAByM9{>*S>IpvE#A
zc`yZ_mVOX92<lR%0_pNu3vuwzQvDeDXPyxMvzY&HvFfe>ctQlDtH4<lQ=^rNoQ1Vx
zXo-$Hk1+jGU}0AL&9tC1)Dk#^K*7Rs-L+jY18V}K{8hDhTQA95%gEEx(g}KC+(W}S
zvWgvT38*;Lm#A1Ttd+JzyxdcJI&tEhR%giJ9f?C;i<|UJY;x%Y>kvXK)SCKivr4~n
z;YCREs%)5NlZI6GK4OKMI-6I3S#2IlU71MK)F)OoP7R@PYz7z9EDp4I5B*rpwFW)r
zy$`s~+BQchG#lvzx;F69)@#vjIK9v>U8IRY`rjj<r&{)>Sa$Y=$rHIE^kv2+Rz<q^
z?omPqA1z?UxG-$i%zii4<(^5>P;9(AB&Oz0)3H%NLjVGm&Ay{<&naql29#W|dV4sc
zD-)rAaKKuHDZk$*A<Jww)p=Z1$0u6t%gcpBdy#;&C#}rF=5Y`_1T7IOAvGhtzcB?b
zu7)dj?<6O`ekw%rndob=#Q9<pC$PNQF=!mYPZVY8DF(ze9W)0*^QC#9jmwm}VbNS{
zB1hv(uHxVfI1_4(xftf=qW^Nw+v<3@TDyO0BmA8lL836sTk~KNSigI`<4xTEn-RCT
z*zsfpzX)#*)A-Q2+rYg23oIceL;z&o9&LfP@MnihrPu&wl#cy`x4k)Ve++TA$efj<
zT|9s{Qm6mxMGK5=v2WDrsVlK12gQ&p1O0f5<N;x!OIb~a_PQdDzBJ{jO+axo8jJ)l
zcm>BlHn2W^BAU9$I;ECnTdlf*`};<zXlk}@w^BUavKHGdG%>AG&^vc1z+oH_)$D$R
z&%u8hhqp*8RKnKNn^~q6UBevnKOkIo8@tNqT$gTluf7-klA4<ele!P~PHYd&m=BMn
z_%Gu?-`j4B!Y{>Q@6IyQu~^}TzX|r5%*v{ynpwqs>ZxW$@uHp}RvMAk#;T)#>lp2?
zDLJ7K#bn#C{L-z8!Tp^6TqYHQ@Z-6xGG7aeN=Q9*<yZ3ZyPVK*jgYL%+V)(S7)dh5
zZ1C-N?7g(qW^-^WHYl2~w-u#qCl7m#RL`dni{-}d4%Q;+ZA=Ig<N^$x6Vie9WOzs$
zj8A?(E`qhK?Xk)G{i{%jfssl!klBQN$c|cJ2ru<iu6E91lhkCFy!fL9&6rxzCn8$X
z-5eFHx~1YY4dMt;#~mXtpSEMoDy$n%I8_mQWx3)<IVUWxuJc9`vHW#^*BSi0+O7NJ
zBgd%nC54VyDBbn>&^uojfT173g*9H9H-Bu}SGbHcM*4@3)5EB9Tqq74u6buC`k;1k
z|7=+nPQHcM+f(#RzSTf+x3s})94@svmd-TMrF}EcZ+PiFdZ?}}NS-dZdvETf`8ZYT
z3^$0^5bdgj`IMHtq314qLSYK6ZAu#Yc%79#3Q;vIcvifc4`Ta#wQgYKO_)z4_7O<F
za1@jG{U%#L%wq}S%xgzTWKE>8dx=MD`jozenYT#XVEdt-BU)x%XRvRKeh$TKLE962
zHGsg_imqE^nV1Upvo^wJ$e=@BrZT~jvSHzDu|V&dc_P%}qu`!WG7NM@RW@eV*l95x
z`{I6h2%f<Xscj3tAMyak%5Ppe17uiD$7E<=v(f+3E1;W~i2Va$`fs`K-~2(06Tk$W
z&bF0&-=ZAmg9YHIH`p$>D`+>|7O`dd?b3T}2B?(=tSSrdDqXyN`yvHqO{7~&n=dw$
zspv_U?HUU*Wjae_JHNfOr~GC1l}Ld_^M^6OHa&cjr&8J%U1`Xqg(3JD<|I{1mky6k
z$V_45l0d1nsvp-N|Jl;cCX{Lg#%uWlqaN}??BW5yc?0rZYZ7m`a;z>U^F>zd<XKNF
z_m)<k;(}(vD!%4^-9M3o-M7UJeL6gcwWz<t$Co}13LdOj-7zypI?CGKv!$n(st+?_
zjs!A>vk}4IA8gQ1v7{&x3e4o``f8lGE}Q@j&9EHE3B=^6#A&W*acC9n@ow=eQ$aRW
z<nIo|?wZ}EW=KUkZAts<33QryBf^_q$_nXO;I*clk8PdB__<FqzFIi~a=Zm2;!Go{
zh22i#{))`+cfLGfKbV4dJ_+_;4{_VsCsq~BDHaZ^q1td5eEHdq0po@Q&WDIsjB?St
zD?Wplmm?q+(GEN6EUw{s7k&Iic?2KF$rlLab6Xn;ggk=dJ&Z8--i{bhV{HrySHeEP
z9h1FmGWKNi*Qme61YaQOXpb4U@0&iw$kn;HZ6wWmy<@SXa6C{3Mn`RKil7tWj!X#%
ziP+1d=$$ciXX_4t#pd{$qXO&aH~;Ph@PLn<cam7D9h+BMN>KciwvwgM1y0d7vN6HM
zcC>qQsB93-8n>%6`$P#5u6(LsG&TzcaLi<lnr1tB9G-K!fR3WwrdGu<m$|<mPvcDJ
z6ZUT_!P8Y}vrGqL@6kFae{iex4h<e=_4c)eQy!(8ZQJp`4H#VTF_}vV^hX4L>NiVH
z!U6ohcPf8}JKO^h75qtm6Zd+-Sv+<#4;p_IK03^+SfaPWNu;AIPJ7O@;ei&dBB56I
zf341b_V%kuVhbKpBHhs;OuB~0cR^lW`glCdsgVe)O9!!TarHboB$*XYq=hd|yUo1j
z%HLNRp6vMbJhn0W`=Fcv15}Jv%Fz5V#gSxp+=H7<Q3Hi8HIo!nf>5;UyO7FZeeqks
z)z(Tt6+)sydlvVVU4a>v)cULkRf-iz+X(YVWQ(UYW?(Je$7-LT5^JlyNdf9&w!x2~
zG{WrtX@iN2ry&9g7#Rsty<FIgMN2-?c%ZcFQdo<TF5E^jYvLb^VfiW?c}5srkgoG2
zcfpzwl(;I)oc5J1TU>Bd9Jb7IuliZC3JtxX9FcrwHI)7A4bj#Go_nvemtJg{OnjcT
zHCem@ap8z>iu<0_bLrWgi6eOIa$6J;EI}vCUVne43jK%+w?B)TlDWs%FFm~Ga)$^u
z#sSS&8`^!@D?Q6^74WCLMKV#RzPQ0iz|UC}rqKU7yoPA~VtIWlcHYgyXLDfc{q|JJ
z!uAUV+>Qg%7t3deyzZB072=Iykl`sSum#Se=a$rB(D+^QrVEHI(7cB9hdX);B!5|%
z3aO|SDoj1@^>@+HUaw?^EZdbWK(^U8Fl%XS4F<S;o_KYCcf)0u!r<3`y}->po}_^2
zYz=UhNFa&Z_9&Z-+O$_!qhr4E?#6L26L5mq3aqTkoK{j|v2}61kR%Vkczw&!p3JwX
z>LNN7-#c&v&mN0(n!<)ZI6m(z(?xybY0^xkWX^i$ehC3LeJ`U5;s5^|Xh>K({D3`0
z1WTvS_N%uCp1@iZeLPxCj&ABq{3&0}Bu4+x+~d5RC=}?tN5nGkq9D?sC|3~l{4OiG
zLT4;LQ3EC~p^61_DS6R=&>4$*WDtI&`IqwW<YA>n1G(|dhpn=i_#8AjAynd!&@#7m
zF_n_Ze&U@y9C{s66zpHRK<oOQR3%#j!ZN-vr6!Dl-GJ}!L3@p``-PA>(R>JqFJlWA
zkg)s$w~s}TVFSO=?ix{r(fD$^LyOJ-E}$0|0^!rx2vQ3(KrhJ!q?L5G2<z(xkN~c!
zW079XFPga{E^Qd$;YIRoE_!U7x(+ycOlU!=izWbP<dU!Oa9YDwLcb?JV!)a<hDVW-
zo{d|a9Sz3%dBDq_qSmAcb&m}p`lgN>kgEykHxaggS?&crm%qEW+aWj4mLTAOS|L_q
zbKJ>-#ZUqq5X1@sF*fi^<FCv5lNLi|2~ST&<O@9zwDhRPar1IU$bVus@(!5h-s9lz
zt@@oMuJ6Yn=-CU6kdW?o-#gC<xF+D>O~dtpECEA{h4@%0Da{^<h?)z*ultaZ+?f4l
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

literal 0
HcmV?d00001

diff --git a/week3/Ouput screenshots/6_9_output.png b/week3/Ouput screenshots/6_9_output.png
new file mode 100644
index 0000000000000000000000000000000000000000..df288e3c8e226ac6327ac02362f90884299adfe5
GIT binary patch
literal 1300650
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%0AMk%%=juu^AD)`{8_@Kf0LplTuB6
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%0Asqf8|
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%0DXGrgLY_0Ql2L%1U;Ej0Z^
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
z%0A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

literal 0
HcmV?d00001

diff --git a/week3/SoftwareEngineering3-10/CMakeLists.txt b/week3/SoftwareEngineering3-10/CMakeLists.txt
new file mode 100644
index 00000000..ccddcaf2
--- /dev/null
+++ b/week3/SoftwareEngineering3-10/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.2.1)
+project (scratch)
+
+# Add project cmake modules to path.
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake)
+
+# We probably don't want this to run on every build.
+option(COVERAGE "Generate Coverage Data" OFF)
+
+if (COVERAGE)
+    include(CodeCoverage)
+    set(LCOV_REMOVE_EXTRA "'vendor/*'")
+    setup_target_for_coverage(code_coverage test/cpp-test coverage)
+    set(COVERAGE_SRCS app/main.cpp include/lib.hpp)
+
+    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+    SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+    SET(CMAKE_EXE_LINKER_FLAGS "-fprofile-arcs -ftest-coverage")
+else()
+    set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wpedantic -g")
+endif()
+
+include(CMakeToolsHelpers OPTIONAL)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_CXX_STANDARD 14)
+
+add_subdirectory(app)
+add_subdirectory(test)
+add_subdirectory(vendor/googletest/googletest)
diff --git a/week3/SoftwareEngineering3-10/UML/3_10_UML.jpg b/week3/SoftwareEngineering3-10/UML/3_10_UML.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..dda84fadc1b85d4d0f08ca75659e62c4fe484574
GIT binary patch
literal 241494
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%0AWmsnavsA&i+D|
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
UP6epj+I#dae__A`<m1r)0~KeMga7~l

literal 0
HcmV?d00001

diff --git a/week3/SoftwareEngineering3-10/app/CMakeLists.txt b/week3/SoftwareEngineering3-10/app/CMakeLists.txt
new file mode 100644
index 00000000..6e03cdc5
--- /dev/null
+++ b/week3/SoftwareEngineering3-10/app/CMakeLists.txt
@@ -0,0 +1,5 @@
+
+add_executable(shell-app SoftwareEngineering3-10.cpp)
+include_directories(
+    ${CMAKE_SOURCE_DIR}/include
+)
diff --git a/week3/SoftwareEngineering3-10/app/SoftwareEngineering3-10.cpp b/week3/SoftwareEngineering3-10/app/SoftwareEngineering3-10.cpp
new file mode 100644
index 00000000..ef388d7d
--- /dev/null
+++ b/week3/SoftwareEngineering3-10/app/SoftwareEngineering3-10.cpp
@@ -0,0 +1,91 @@
+/**
+ *  @copyright (c) 2021 SumedhReddy
+ *  @file    SoftwareEngineering3-10.cpp
+ *  @author  SumedhReddy
+ *  @brief solution
+ * 
+ */
+
+#include "SoftwareEngineering3-10.hpp"
+
+/**
+ * @brief data method stores student 
+ * data entered by the user
+ */
+
+void courseGrader::data(int t) {
+    int i;
+    for (i = 0; i < t; i++) {
+      std::cout << "Enter Student ID:";
+      std::cin >> studentArray[i].id;
+      std::cout << "Enter Grade:";
+      std::cin >> studentArray[i].grade;
+    }
+  }
+/**
+ * @brief updateGrade method updates the grades of the 
+ * students entered by the user
+ */
+  void courseGrader::updateGrade() {
+    int iupdate, j, igrade;
+    std::cout << "Grade Updation-> Enter Student ID:";
+    std::cin >> iupdate;
+    std::cout << "Grade Updation-> Enter new grade:";
+    std::cin >> igrade;
+    for (j = 0; j != studentArray[j].id; j++) {
+      if (studentArray[j].id == iupdate) {
+        studentArray[j].grade = igrade;
+        std::cout << "New grade for the student with ID: " << studentArray[j].id << " is " << studentArray[j].grade << "\n";
+        break;
+      }
+    }
+  }
+/**
+ * @brief GPA method calculates the overall class grades of the 
+ * students entered by the user
+ */
+  void courseGrader::GPA(int t) {
+    int sum = 0, ij, gpa;
+    for (ij = 0; ij < t; ij++) {
+      sum += studentArray[ij].grade;
+    }
+    gpa = sum / t;
+    std::cout << "GPA of the Class:" << gpa;
+  }
+
+
+int main() {
+
+  int isoption, t; //inputs from user
+  courseGrader studentObj; //object for the class courseGrader
+  std::cout << "Please select below options:" <<
+    "\n" <<
+    "1. Insert Student data" <<
+    "\n" <<
+    "2. Update student grade" <<
+    "\n" <<
+    "3. class GPA \n";
+  std::cin >> isoption;
+  //switch statement to select user options
+  switch (isoption) {
+  case 1:
+
+    std::cout << "Enter number of student to be inserted: ";
+    std::cin >> t;
+    std::cout << "Inserting Student data \n";
+    studentObj.data(t);
+
+  case 2:
+    std::cout << "Updating grade of the Student \n";
+    studentObj.updateGrade();
+
+  case 3:
+    std::cout << "Calculating grade point average of the class \n";
+    studentObj.GPA(t);
+
+  default:
+    break;
+  }
+
+  return 0;
+}
\ No newline at end of file
diff --git a/week3/SoftwareEngineering3-10/app/main.cpp b/week3/SoftwareEngineering3-10/app/main.cpp
new file mode 100644
index 00000000..74232ade
--- /dev/null
+++ b/week3/SoftwareEngineering3-10/app/main.cpp
@@ -0,0 +1,8 @@
+#include <iostream>
+#include <lib.hpp>
+
+int main()
+{
+    dummy();
+    return 0;
+}
diff --git a/week3/SoftwareEngineering3-10/cmake/CodeCoverage.cmake b/week3/SoftwareEngineering3-10/cmake/CodeCoverage.cmake
new file mode 100644
index 00000000..50dffc7d
--- /dev/null
+++ b/week3/SoftwareEngineering3-10/cmake/CodeCoverage.cmake
@@ -0,0 +1,203 @@
+# Copyright (c) 2012 - 2015, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. 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.
+#
+# 3. Neither the name of the copyright holder 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 HOLDER 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.
+#
+#
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# USAGE:
+
+# 0. (Mac only) If you use Xcode 5.1 make sure to patch geninfo as described here:
+#      http://stackoverflow.com/a/22404544/80480
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt:
+#      INCLUDE(CodeCoverage)
+#
+# 3. Set compiler flags to turn off optimization and enable coverage:
+#    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#	 SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#
+# 3. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target
+#    which runs your test executable and produces a lcov code coverage report:
+#    Example:
+#	 SETUP_TARGET_FOR_COVERAGE(
+#				my_coverage_target  # Name for custom target.
+#				test_driver         # Name of the test driver executable that runs the tests.
+#									# NOTE! This should always have a ZERO as exit code
+#									# otherwise the coverage generation will not complete.
+#				coverage            # Name of output directory.
+#				)
+#
+#    If you need to exclude additional directories from the report, specify them
+#    using the LCOV_REMOVE_EXTRA variable before calling SETUP_TARGET_FOR_COVERAGE.
+#    For example:
+#
+#    set(LCOV_REMOVE_EXTRA "'thirdparty/*'")
+#
+# 4. Build a Debug build:
+#	 cmake -DCMAKE_BUILD_TYPE=Debug ..
+#	 make
+#	 make my_coverage_target
+#
+#
+
+# Check prereqs
+FIND_PROGRAM( GCOV_PATH gcov )
+FIND_PROGRAM( LCOV_PATH lcov )
+FIND_PROGRAM( GENHTML_PATH genhtml )
+FIND_PROGRAM( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/tests)
+
+IF(NOT GCOV_PATH)
+	MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
+ENDIF() # NOT GCOV_PATH
+
+IF("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+	IF("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
+		MESSAGE(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+	ENDIF()
+ELSEIF(NOT CMAKE_COMPILER_IS_GNUCXX)
+	MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+ENDIF() # CHECK VALID COMPILER
+
+SET(CMAKE_CXX_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+SET(CMAKE_C_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+SET(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+SET(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+MARK_AS_ADVANCED(
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+IF ( NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "Coverage"))
+  MESSAGE( WARNING "Code coverage results with an optimized (non-Debug) build may be misleading" )
+ENDIF() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
+
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests.
+#						MUST return ZERO always, even on errors.
+#						If not, no coverage report will be created!
+# Param _outputname     lcov output is generated as _outputname.info
+#                       HTML report is generated in _outputname/index.html
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
+
+	IF(NOT LCOV_PATH)
+		MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
+	ENDIF() # NOT LCOV_PATH
+
+	IF(NOT GENHTML_PATH)
+		MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
+	ENDIF() # NOT GENHTML_PATH
+
+	SET(coverage_info "${CMAKE_BINARY_DIR}/${_outputname}.info")
+	SET(coverage_cleaned "${coverage_info}.cleaned")
+
+	SEPARATE_ARGUMENTS(test_command UNIX_COMMAND "${_testrunner}")
+
+	# Setup target
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Cleanup lcov
+		${LCOV_PATH} --directory . --zerocounters
+
+		# Run tests
+		COMMAND ${test_command} ${ARGV3}
+
+		# Capturing lcov counters and generating report
+		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${coverage_info}
+		COMMAND ${LCOV_PATH} --remove ${coverage_info} 'tests/*' '/usr/*' ${LCOV_REMOVE_EXTRA} --output-file ${coverage_cleaned}
+		COMMAND ${GENHTML_PATH} -o ${_outputname} ${coverage_cleaned}
+		COMMAND ${CMAKE_COMMAND} -E remove ${coverage_info} ${coverage_cleaned}
+
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests
+# Param _outputname     cobertura output is generated as _outputname.xml
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE_COBERTURA _targetname _testrunner _outputname)
+
+	IF(NOT PYTHON_EXECUTABLE)
+		MESSAGE(FATAL_ERROR "Python not found! Aborting...")
+	ENDIF() # NOT PYTHON_EXECUTABLE
+
+	IF(NOT GCOVR_PATH)
+		MESSAGE(FATAL_ERROR "gcovr not found! Aborting...")
+	ENDIF() # NOT GCOVR_PATH
+
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Run tests
+		${_testrunner} ${ARGV3}
+
+		# Running gcovr
+		COMMAND ${GCOVR_PATH} -x -r ${CMAKE_SOURCE_DIR} -e '${CMAKE_SOURCE_DIR}/tests/'  -o ${_outputname}.xml
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Running gcovr to produce Cobertura code coverage report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Cobertura code coverage report saved in ${_outputname}.xml."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE_COBERTURA
diff --git a/week3/SoftwareEngineering3-10/include/SoftwareEngineering3-10.hpp b/week3/SoftwareEngineering3-10/include/SoftwareEngineering3-10.hpp
new file mode 100644
index 00000000..33e2b7a7
--- /dev/null
+++ b/week3/SoftwareEngineering3-10/include/SoftwareEngineering3-10.hpp
@@ -0,0 +1,37 @@
+/**
+ *  @copyright (c) 2021 Sumedh Reddy Koppula
+ *  @file    SoftwareEngineering3-10.hpp
+ *  @author  SumedhReddy 
+ *
+ *  @brief Header
+ *
+ */
+
+#pragma once
+
+#include <iostream>
+
+#include <string>
+
+ struct studentInfo {
+      int id;
+      int grade;
+    };
+/**
+ * @brief courseGrader class has a struct of array type
+ * to store student data and data, udpdateGrade, GPA 
+ * methods to evaluate student data
+ */
+class courseGrader {
+  public:
+  studentInfo studentArray[100];
+  courseGrader();
+  void data(int t);
+  void updateGrade();
+  void GPA(int t);
+  
+};
+
+courseGrader::courseGrader(void) {
+
+}
\ No newline at end of file
diff --git a/week3/SoftwareEngineering3-10/include/lib.hpp b/week3/SoftwareEngineering3-10/include/lib.hpp
new file mode 100644
index 00000000..45fd193f
--- /dev/null
+++ b/week3/SoftwareEngineering3-10/include/lib.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include<iostream>
+
+void dummy()
+{
+    std::cout << "HI" << std::endl;
+}
diff --git a/week3/SoftwareEngineering3-10/test/CMakeLists.txt b/week3/SoftwareEngineering3-10/test/CMakeLists.txt
new file mode 100644
index 00000000..2b1cd4cb
--- /dev/null
+++ b/week3/SoftwareEngineering3-10/test/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(GTEST_SHUFFLE 1)
+
+add_executable(
+    cpp-test
+    main.cpp
+    test.cpp
+)
+
+target_include_directories(cpp-test PUBLIC ../vendor/googletest/googletest/include 
+                                           ${CMAKE_SOURCE_DIR}/include)
+target_link_libraries(cpp-test PUBLIC gtest)
diff --git a/week3/SoftwareEngineering3-10/test/main.cpp b/week3/SoftwareEngineering3-10/test/main.cpp
new file mode 100644
index 00000000..697a9d70
--- /dev/null
+++ b/week3/SoftwareEngineering3-10/test/main.cpp
@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/week3/SoftwareEngineering3-10/test/test.cpp b/week3/SoftwareEngineering3-10/test/test.cpp
new file mode 100644
index 00000000..2c5cd069
--- /dev/null
+++ b/week3/SoftwareEngineering3-10/test/test.cpp
@@ -0,0 +1,5 @@
+#include <gtest/gtest.h>
+
+TEST(dummy, should_pass) {
+  EXPECT_EQ(1, 1);
+}
diff --git a/week3/sumedh_117386066_writing_assignment.pdf b/week3/sumedh_117386066_writing_assignment.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..fe9447bd2190b686bdefe89e13a78f5fec2150a0
GIT binary patch
literal 535852
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
aRhGbdmd5a*5nQ&y;mEDKckegT+xkBMm#fkM

literal 0
HcmV?d00001


From 898078da86a7d8be4dd048715223b612790bf4bd Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Tue, 21 Sep 2021 16:13:51 -0400
Subject: [PATCH 04/15] readme.md trying to upload output screenshots

---
 week3/readme.md | 60 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 week3/readme.md

diff --git a/week3/readme.md b/week3/readme.md
new file mode 100644
index 00000000..4040b552
--- /dev/null
+++ b/week3/readme.md
@@ -0,0 +1,60 @@
+# C++ Boilerplate
+[![Build Status](https://travis-ci.org/dpiet/cpp-boilerplate.svg?branch=master)](https://travis-ci.org/dpiet/cpp-boilerplate)
+[![Coverage Status](https://coveralls.io/repos/github/dpiet/cpp-boilerplate/badge.svg?branch=master)](https://coveralls.io/github/dpiet/cpp-boilerplate?branch=master)
+---
+## Week 3 Assignment
+
+Name: Sumedh Reddy Koppula
+UID: 117386066
+
+In week3 directory please find invidual folders with programming assignment exercise names with UML diagram. On each folder please perform below executions in command-line to get the ouput.
+1. mkdir build
+2. cd build
+3. cmake ..
+4. make
+5. cd app
+6. ./shell-app
+
+Please find the wrting assignment .pdf and output screenshots in the root folder.
+
+## Sample Outputs
+
+3_5_output
+
+3_10_output
+
+4_5_output
+
+4_7_output
+
+6_9_output
+
+## Plugins
+
+- CppChEclipse
+
+    To install and run cppcheck in Eclipse
+
+    1. In Eclipse, go to Window -> Preferences -> C/C++ -> cppcheclipse.
+    Set cppcheck binary path to "/usr/bin/cppcheck".
+
+    2. To run CPPCheck on a project, right click on the project name in the Project Explorer 
+    and choose cppcheck -> Run cppcheck.
+
+
+- Google C++ Sytle
+
+    To include and use Google C++ Style formatter in Eclipse
+
+    1. In Eclipse, go to Window -> Preferences -> C/C++ -> Code Style -> Formatter. 
+    Import [eclipse-cpp-google-style][reference-id-for-eclipse-cpp-google-style] and apply.
+
+    2. To use Google C++ style formatter, right click on the source code or folder in 
+    Project Explorer and choose Source -> Format
+
+[reference-id-for-eclipse-cpp-google-style]: https://raw.githubusercontent.com/google/styleguide/gh-pages/eclipse-cpp-google-style.xml
+
+- Git
+
+    It is possible to manage version control through Eclipse and the git plugin, but it typically requires creating another project. If you're interested in this, try it out yourself and contact me on Canvas.
+

From c93ba4fa718c9c3449512a542faf8ebb838d07a9 Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Tue, 21 Sep 2021 16:18:20 -0400
Subject: [PATCH 05/15] updating image via GitHub rather than terminal

---
 week3/readme.md | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/week3/readme.md b/week3/readme.md
index 4040b552..0cf285c8 100644
--- a/week3/readme.md
+++ b/week3/readme.md
@@ -19,15 +19,21 @@ Please find the wrting assignment .pdf and output screenshots in the root folder
 
 ## Sample Outputs
 
-3_5_output
+**3_5_output:**
+<img width="1440" alt="3_5_output" src="https://user-images.githubusercontent.com/24978535/134241123-d9610cf4-2ae0-4322-820f-425c45c30bf8.png">
 
-3_10_output
+**3_10_output**
+<img width="1440" alt="3_10_output" src="https://user-images.githubusercontent.com/24978535/134241137-175cd18d-fc65-4356-8da8-1db0e48745f6.png">
 
-4_5_output
+**4_5_output**
+<img width="1440" alt="4_5_output" src="https://user-images.githubusercontent.com/24978535/134241148-fc224652-9a5d-4677-ba38-72c8c49edf82.png">
 
-4_7_output
+**4_7_output**
+<img width="1440" alt="4_7_output" src="https://user-images.githubusercontent.com/24978535/134241159-7d6bbba5-0372-4a08-9d61-3b99a946ac17.png">
+
+**6_9_output**
+<img width="1440" alt="6_9_output" src="https://user-images.githubusercontent.com/24978535/134241172-0b6f06dd-5258-424f-a2dc-46b1d90b581b.png">
 
-6_9_output
 
 ## Plugins
 

From 6008dc89230dae99f7662ba0c39e3ce516081cd5 Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Fri, 24 Sep 2021 20:55:51 -0400
Subject: [PATCH 06/15] commiting without extraction method as to compare with
 extration method

---
 .vscode/c_cpp_properties.json               |  3 +-
 app/softwareEng_9_4.cpp                     |  0
 include/softwareEng_9_4.hpp                 |  0
 softwareEng_9_4/app/CMakeLists.txt          |  2 +-
 softwareEng_9_4/app/softwareEng_9_4.cpp     | 38 +++++++++++++++++++++
 softwareEng_9_4/include/softwareEng_9_4.hpp | 35 +++++++++++++++++++
 6 files changed, 76 insertions(+), 2 deletions(-)
 delete mode 100644 app/softwareEng_9_4.cpp
 delete mode 100644 include/softwareEng_9_4.hpp

diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json
index 1232ff40..3c7dfb90 100644
--- a/.vscode/c_cpp_properties.json
+++ b/.vscode/c_cpp_properties.json
@@ -10,7 +10,8 @@
                 "${workspaceFolder}/week3/SoftwareEngineering3-10/include",
                 "${workspaceFolder}/week3/AcceleratedC++6-9/include",
                 "${workspaceFolder}/week3/AcceleratedC++4-7/include",
-                "${workspaceFolder}/week3/AcceleratedC++4-5/include"
+                "${workspaceFolder}/week3/AcceleratedC++4-5/include",
+                "${workspaceFolder}/softwareEng_9_4/include"
             ],
             "browse": {
                 "limitSymbolsToIncludedHeaders": true,
diff --git a/app/softwareEng_9_4.cpp b/app/softwareEng_9_4.cpp
deleted file mode 100644
index e69de29b..00000000
diff --git a/include/softwareEng_9_4.hpp b/include/softwareEng_9_4.hpp
deleted file mode 100644
index e69de29b..00000000
diff --git a/softwareEng_9_4/app/CMakeLists.txt b/softwareEng_9_4/app/CMakeLists.txt
index 68fb4f28..6b16684e 100644
--- a/softwareEng_9_4/app/CMakeLists.txt
+++ b/softwareEng_9_4/app/CMakeLists.txt
@@ -1,4 +1,4 @@
-add_executable(shell-app main.cpp 9_5.cpp)
+add_executable(shell-app softwareEng_9_4.cpp)
 include_directories(
     ${CMAKE_SOURCE_DIR}/include
 )
diff --git a/softwareEng_9_4/app/softwareEng_9_4.cpp b/softwareEng_9_4/app/softwareEng_9_4.cpp
index e69de29b..df7ea2e9 100644
--- a/softwareEng_9_4/app/softwareEng_9_4.cpp
+++ b/softwareEng_9_4/app/softwareEng_9_4.cpp
@@ -0,0 +1,38 @@
+/**
+ *  @copyright (c) 2021 Sumedh Reddy
+ *  @file    softwareEngineering_9_4.cpp
+ *  @author  SumedhReddy
+ *
+ *  @brief solution
+ *
+ */
+
+#include "softwareEng_9_4.hpp"
+
+/**
+ * @brief initial function without extraction
+ */
+void printer::printPosition() {
+int i, j;
+char text[1024] = "1234567890";
+int text_length = 10;
+char array_to_search1[4] = "23";
+int array_to_search1_length = 2;
+int position1 = -1;
+for (i = 0; i < text_length - array_to_search1_length + 1; i++) {
+  bool found = true;
+  for (j = 0; j < array_to_search1_length; j++)
+    if (text[i + j] != array_to_search1[j])
+      found = false;
+  if (found) {
+    position1 = i;
+    break;
+  }
+}
+std::cout<<position1;
+}
+
+int main() {
+    printer printObj;
+    printObj.printPosition();
+}
\ No newline at end of file
diff --git a/softwareEng_9_4/include/softwareEng_9_4.hpp b/softwareEng_9_4/include/softwareEng_9_4.hpp
index e69de29b..0b425fd6 100644
--- a/softwareEng_9_4/include/softwareEng_9_4.hpp
+++ b/softwareEng_9_4/include/softwareEng_9_4.hpp
@@ -0,0 +1,35 @@
+/**
+ *  @copyright (c) 2021 Sumedh Reddy Koppula
+ *  @file    SoftwareEngineering9-4.hpp
+ *  @author  SumedhReddy 
+ *
+ *  @brief Header
+ *
+ */
+
+#pragma once
+
+#include <iostream>
+
+#include <string>
+
+#include <vector>
+
+#include <numeric>
+
+/**
+ * @brief 
+ * printer is a class to extract a new method from printposition, 
+ * The motivation behind solving this problem
+ * is to implement method extraction for code refractory
+ */
+class printer {
+ public:
+    void inputs();
+    void printPosition();
+    printer();
+}; 
+
+ printer::printer(void){
+
+}

From 0d0963aca224cf567b193b894f20222f86ba9e4a Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Sat, 25 Sep 2021 23:55:09 -0400
Subject: [PATCH 07/15] Adding program for the week4 assignment

---
 week4/softwareEng_9_4/CMakeLists.txt          |   29 +
 week4/softwareEng_9_4/app/CMakeLists.txt      |    4 +
 week4/softwareEng_9_4/app/main.cpp            |    8 +
 week4/softwareEng_9_4/app/softwareEng_9_4     |  Bin 0 -> 58860 bytes
 week4/softwareEng_9_4/app/softwareEng_9_4.cpp |   55 +
 .../softwareEng_9_4.dSYM/Contents/Info.plist  |   20 +
 .../Contents/Resources/DWARF/softwareEng_9_4  |  Bin 0 -> 123205 bytes
 .../softwareEng_9_4/cmake/CodeCoverage.cmake  |  203 +
 .../include/softwareEng_9_4.hpp               |   35 +
 week4/softwareEng_9_4/readme.md               |   50 +
 week4/softwareEng_9_4/test/CMakeLists.txt     |   11 +
 week4/softwareEng_9_4/test/main.cpp           |    6 +
 week4/softwareEng_9_4/test/test.cpp           |    5 +
 .../vendor/googletest/.gitignore              |    2 +
 .../vendor/googletest/.travis.yml             |   46 +
 .../vendor/googletest/CMakeLists.txt          |   16 +
 .../vendor/googletest/README.md               |  142 +
 .../vendor/googletest/appveyor.yml            |   71 +
 .../vendor/googletest/googlemock/CHANGES      |  126 +
 .../googletest/googlemock/CMakeLists.txt      |  202 +
 .../vendor/googletest/googlemock/CONTRIBUTORS |   40 +
 .../vendor/googletest/googlemock/LICENSE      |   28 +
 .../vendor/googletest/googlemock/Makefile.am  |  224 +
 .../vendor/googletest/googlemock/README.md    |  333 +
 .../googletest/googlemock/build-aux/.keep     |    0
 .../vendor/googletest/googlemock/configure.ac |  146 +
 .../googletest/googlemock/docs/CheatSheet.md  |  562 ++
 .../googletest/googlemock/docs/CookBook.md    | 3675 ++++++++
 .../googletest/googlemock/docs/DesignDoc.md   |  280 +
 .../googletest/googlemock/docs/DevGuide.md    |  132 +
 .../googlemock/docs/Documentation.md          |   12 +
 .../googletest/googlemock/docs/ForDummies.md  |  439 +
 .../docs/FrequentlyAskedQuestions.md          |  628 ++
 .../googletest/googlemock/docs/KnownIssues.md |   19 +
 .../googlemock/docs/v1_5/CheatSheet.md        |  525 ++
 .../googlemock/docs/v1_5/CookBook.md          | 3250 +++++++
 .../googlemock/docs/v1_5/Documentation.md     |   11 +
 .../googlemock/docs/v1_5/ForDummies.md        |  439 +
 .../docs/v1_5/FrequentlyAskedQuestions.md     |  624 ++
 .../googlemock/docs/v1_6/CheatSheet.md        |  534 ++
 .../googlemock/docs/v1_6/CookBook.md          | 3342 +++++++
 .../googlemock/docs/v1_6/Documentation.md     |   12 +
 .../googlemock/docs/v1_6/ForDummies.md        |  439 +
 .../docs/v1_6/FrequentlyAskedQuestions.md     |  628 ++
 .../googlemock/docs/v1_7/CheatSheet.md        |  556 ++
 .../googlemock/docs/v1_7/CookBook.md          | 3432 ++++++++
 .../googlemock/docs/v1_7/Documentation.md     |   12 +
 .../googlemock/docs/v1_7/ForDummies.md        |  439 +
 .../docs/v1_7/FrequentlyAskedQuestions.md     |  628 ++
 .../googlemock/include/gmock/gmock-actions.h  | 1205 +++
 .../include/gmock/gmock-cardinalities.h       |  147 +
 .../include/gmock/gmock-generated-actions.h   | 2377 +++++
 .../gmock/gmock-generated-actions.h.pump      |  794 ++
 .../gmock/gmock-generated-function-mockers.h  | 1095 +++
 .../gmock-generated-function-mockers.h.pump   |  291 +
 .../include/gmock/gmock-generated-matchers.h  | 2179 +++++
 .../gmock/gmock-generated-matchers.h.pump     |  672 ++
 .../gmock/gmock-generated-nice-strict.h       |  397 +
 .../gmock/gmock-generated-nice-strict.h.pump  |  161 +
 .../googlemock/include/gmock/gmock-matchers.h | 4399 ++++++++++
 .../include/gmock/gmock-more-actions.h        |  246 +
 .../include/gmock/gmock-more-matchers.h       |   58 +
 .../include/gmock/gmock-spec-builders.h       | 1847 ++++
 .../googlemock/include/gmock/gmock.h          |   94 +
 .../internal/custom/gmock-generated-actions.h |    8 +
 .../custom/gmock-generated-actions.h.pump     |   10 +
 .../gmock/internal/custom/gmock-matchers.h    |   39 +
 .../gmock/internal/custom/gmock-port.h        |   46 +
 .../internal/gmock-generated-internal-utils.h |  279 +
 .../gmock-generated-internal-utils.h.pump     |  136 +
 .../gmock/internal/gmock-internal-utils.h     |  511 ++
 .../include/gmock/internal/gmock-port.h       |   91 +
 .../googletest/googlemock/make/Makefile       |  101 +
 .../googletest/googlemock/msvc/2005/gmock.sln |   32 +
 .../googlemock/msvc/2005/gmock.vcproj         |  191 +
 .../googlemock/msvc/2005/gmock_config.vsprops |   15 +
 .../googlemock/msvc/2005/gmock_main.vcproj    |  187 +
 .../googlemock/msvc/2005/gmock_test.vcproj    |  201 +
 .../googletest/googlemock/msvc/2010/gmock.sln |   32 +
 .../googlemock/msvc/2010/gmock.vcxproj        |   82 +
 .../googlemock/msvc/2010/gmock_config.props   |   19 +
 .../googlemock/msvc/2010/gmock_main.vcxproj   |   88 +
 .../googlemock/msvc/2010/gmock_test.vcxproj   |  101 +
 .../googletest/googlemock/msvc/2015/gmock.sln |   32 +
 .../googlemock/msvc/2015/gmock.vcxproj        |   84 +
 .../googlemock/msvc/2015/gmock_config.props   |   19 +
 .../googlemock/msvc/2015/gmock_main.vcxproj   |   90 +
 .../googlemock/msvc/2015/gmock_test.vcxproj   |  103 +
 .../googlemock/scripts/fuse_gmock_files.py    |  240 +
 .../googlemock/scripts/generator/LICENSE      |  203 +
 .../googlemock/scripts/generator/README       |   35 +
 .../scripts/generator/README.cppclean         |  115 +
 .../scripts/generator/cpp/__init__.py         |    0
 .../googlemock/scripts/generator/cpp/ast.py   | 1733 ++++
 .../scripts/generator/cpp/gmock_class.py      |  227 +
 .../scripts/generator/cpp/gmock_class_test.py |  448 +
 .../scripts/generator/cpp/keywords.py         |   59 +
 .../scripts/generator/cpp/tokenize.py         |  287 +
 .../googlemock/scripts/generator/cpp/utils.py |   41 +
 .../googlemock/scripts/generator/gmock_gen.py |   31 +
 .../googlemock/scripts/gmock-config.in        |  303 +
 .../googlemock/scripts/gmock_doctor.py        |  640 ++
 .../googletest/googlemock/scripts/upload.py   | 1387 +++
 .../googlemock/scripts/upload_gmock.py        |   78 +
 .../googletest/googlemock/src/gmock-all.cc    |   47 +
 .../googlemock/src/gmock-cardinalities.cc     |  156 +
 .../googlemock/src/gmock-internal-utils.cc    |  174 +
 .../googlemock/src/gmock-matchers.cc          |  498 ++
 .../googlemock/src/gmock-spec-builders.cc     |  823 ++
 .../vendor/googletest/googlemock/src/gmock.cc |  183 +
 .../googletest/googlemock/src/gmock_main.cc   |   54 +
 .../googlemock/test/gmock-actions_test.cc     | 1411 +++
 .../test/gmock-cardinalities_test.cc          |  428 +
 .../test/gmock-generated-actions_test.cc      | 1228 +++
 .../gmock-generated-function-mockers_test.cc  |  622 ++
 .../gmock-generated-internal-utils_test.cc    |  127 +
 .../test/gmock-generated-matchers_test.cc     | 1286 +++
 .../test/gmock-internal-utils_test.cc         |  699 ++
 .../googlemock/test/gmock-matchers_test.cc    | 5652 ++++++++++++
 .../test/gmock-more-actions_test.cc           |  708 ++
 .../googlemock/test/gmock-nice-strict_test.cc |  424 +
 .../googlemock/test/gmock-port_test.cc        |   43 +
 .../test/gmock-spec-builders_test.cc          | 2644 ++++++
 .../googlemock/test/gmock_all_test.cc         |   51 +
 .../googlemock/test/gmock_ex_test.cc          |   81 +
 .../googlemock/test/gmock_leak_test.py        |  108 +
 .../googlemock/test/gmock_leak_test_.cc       |  100 +
 .../googlemock/test/gmock_link2_test.cc       |   40 +
 .../googlemock/test/gmock_link_test.cc        |   40 +
 .../googlemock/test/gmock_link_test.h         |  669 ++
 .../googlemock/test/gmock_output_test.py      |  180 +
 .../googlemock/test/gmock_output_test_.cc     |  291 +
 .../test/gmock_output_test_golden.txt         |  310 +
 .../googlemock/test/gmock_stress_test.cc      |  322 +
 .../googletest/googlemock/test/gmock_test.cc  |  220 +
 .../googlemock/test/gmock_test_utils.py       |  112 +
 .../vendor/googletest/googletest/.gitignore   |    2 +
 .../vendor/googletest/googletest/CHANGES      |  157 +
 .../googletest/googletest/CMakeLists.txt      |  286 +
 .../vendor/googletest/googletest/CONTRIBUTORS |   37 +
 .../vendor/googletest/googletest/LICENSE      |   28 +
 .../vendor/googletest/googletest/Makefile.am  |  310 +
 .../vendor/googletest/googletest/README.md    |  280 +
 .../googletest/googletest/build-aux/.keep     |    0
 .../googletest/cmake/internal_utils.cmake     |  256 +
 .../googletest/codegear/gtest.cbproj          |  138 +
 .../googletest/codegear/gtest.groupproj       |   54 +
 .../googletest/codegear/gtest_all.cc          |   38 +
 .../googletest/codegear/gtest_link.cc         |   40 +
 .../googletest/codegear/gtest_main.cbproj     |   82 +
 .../googletest/codegear/gtest_unittest.cbproj |   88 +
 .../vendor/googletest/googletest/configure.ac |   68 +
 .../googletest/docs/AdvancedGuide.md          | 2182 +++++
 .../googletest/googletest/docs/DevGuide.md    |  126 +
 .../googletest/docs/Documentation.md          |   14 +
 .../vendor/googletest/googletest/docs/FAQ.md  | 1087 +++
 .../googletest/googletest/docs/Primer.md      |  502 ++
 .../googletest/googletest/docs/PumpManual.md  |  177 +
 .../googletest/googletest/docs/Samples.md     |   14 +
 .../googletest/docs/V1_5_AdvancedGuide.md     | 2096 +++++
 .../googletest/docs/V1_5_Documentation.md     |   12 +
 .../googletest/googletest/docs/V1_5_FAQ.md    |  886 ++
 .../googletest/googletest/docs/V1_5_Primer.md |  497 ++
 .../googletest/docs/V1_5_PumpManual.md        |  177 +
 .../googletest/docs/V1_5_XcodeGuide.md        |   93 +
 .../googletest/docs/V1_6_AdvancedGuide.md     | 2178 +++++
 .../googletest/docs/V1_6_Documentation.md     |   14 +
 .../googletest/googletest/docs/V1_6_FAQ.md    | 1038 +++
 .../googletest/googletest/docs/V1_6_Primer.md |  501 ++
 .../googletest/docs/V1_6_PumpManual.md        |  177 +
 .../googletest/docs/V1_6_Samples.md           |   14 +
 .../googletest/docs/V1_6_XcodeGuide.md        |   93 +
 .../googletest/docs/V1_7_AdvancedGuide.md     | 2181 +++++
 .../googletest/docs/V1_7_Documentation.md     |   14 +
 .../googletest/googletest/docs/V1_7_FAQ.md    | 1082 +++
 .../googletest/googletest/docs/V1_7_Primer.md |  501 ++
 .../googletest/docs/V1_7_PumpManual.md        |  177 +
 .../googletest/docs/V1_7_Samples.md           |   14 +
 .../googletest/docs/V1_7_XcodeGuide.md        |   93 +
 .../googletest/googletest/docs/XcodeGuide.md  |   93 +
 .../include/gtest/gtest-death-test.h          |  294 +
 .../googletest/include/gtest/gtest-message.h  |  250 +
 .../include/gtest/gtest-param-test.h          | 1444 +++
 .../include/gtest/gtest-param-test.h.pump     |  510 ++
 .../googletest/include/gtest/gtest-printers.h |  993 +++
 .../googletest/include/gtest/gtest-spi.h      |  232 +
 .../include/gtest/gtest-test-part.h           |  179 +
 .../include/gtest/gtest-typed-test.h          |  263 +
 .../googletest/include/gtest/gtest.h          | 2236 +++++
 .../include/gtest/gtest_pred_impl.h           |  358 +
 .../googletest/include/gtest/gtest_prod.h     |   58 +
 .../gtest/internal/custom/gtest-port.h        |   69 +
 .../gtest/internal/custom/gtest-printers.h    |   42 +
 .../include/gtest/internal/custom/gtest.h     |   41 +
 .../internal/gtest-death-test-internal.h      |  319 +
 .../include/gtest/internal/gtest-filepath.h   |  206 +
 .../include/gtest/internal/gtest-internal.h   | 1238 +++
 .../include/gtest/internal/gtest-linked_ptr.h |  243 +
 .../internal/gtest-param-util-generated.h     | 5146 +++++++++++
 .../gtest-param-util-generated.h.pump         |  286 +
 .../include/gtest/internal/gtest-param-util.h |  731 ++
 .../include/gtest/internal/gtest-port-arch.h  |   93 +
 .../include/gtest/internal/gtest-port.h       | 2560 ++++++
 .../include/gtest/internal/gtest-string.h     |  167 +
 .../include/gtest/internal/gtest-tuple.h      | 1020 +++
 .../include/gtest/internal/gtest-tuple.h.pump |  347 +
 .../include/gtest/internal/gtest-type-util.h  | 3331 +++++++
 .../gtest/internal/gtest-type-util.h.pump     |  297 +
 .../googletest/googletest/m4/acx_pthread.m4   |  363 +
 .../vendor/googletest/googletest/m4/gtest.m4  |   74 +
 .../googletest/googletest/make/Makefile       |   82 +
 .../googletest/googletest/msvc/gtest-md.sln   |   45 +
 .../googletest/msvc/gtest-md.vcproj           |  126 +
 .../googletest/googletest/msvc/gtest.sln      |   45 +
 .../googletest/googletest/msvc/gtest.vcproj   |  126 +
 .../googletest/msvc/gtest_main-md.vcproj      |  129 +
 .../googletest/msvc/gtest_main.vcproj         |  129 +
 .../googletest/msvc/gtest_prod_test-md.vcproj |  164 +
 .../googletest/msvc/gtest_prod_test.vcproj    |  164 +
 .../googletest/msvc/gtest_unittest-md.vcproj  |  147 +
 .../googletest/msvc/gtest_unittest.vcproj     |  147 +
 .../googletest/samples/prime_tables.h         |  123 +
 .../googletest/googletest/samples/sample1.cc  |   68 +
 .../googletest/googletest/samples/sample1.h   |   43 +
 .../googletest/samples/sample10_unittest.cc   |  144 +
 .../googletest/samples/sample1_unittest.cc    |  153 +
 .../googletest/googletest/samples/sample2.cc  |   56 +
 .../googletest/googletest/samples/sample2.h   |   85 +
 .../googletest/samples/sample2_unittest.cc    |  109 +
 .../googletest/samples/sample3-inl.h          |  172 +
 .../googletest/samples/sample3_unittest.cc    |  151 +
 .../googletest/googletest/samples/sample4.cc  |   46 +
 .../googletest/googletest/samples/sample4.h   |   53 +
 .../googletest/samples/sample4_unittest.cc    |   45 +
 .../googletest/samples/sample5_unittest.cc    |  199 +
 .../googletest/samples/sample6_unittest.cc    |  224 +
 .../googletest/samples/sample7_unittest.cc    |  130 +
 .../googletest/samples/sample8_unittest.cc    |  173 +
 .../googletest/samples/sample9_unittest.cc    |  160 +
 .../googletest/googletest/scripts/common.py   |   83 +
 .../googletest/scripts/fuse_gtest_files.py    |  253 +
 .../googletest/scripts/gen_gtest_pred_impl.py |  730 ++
 .../googletest/scripts/gtest-config.in        |  274 +
 .../googletest/googletest/scripts/pump.py     |  855 ++
 .../googletest/scripts/release_docs.py        |  158 +
 .../googletest/scripts/test/Makefile          |   59 +
 .../googletest/googletest/scripts/upload.py   | 1387 +++
 .../googletest/scripts/upload_gtest.py        |   78 +
 .../googletest/googletest/src/gtest-all.cc    |   48 +
 .../googletest/src/gtest-death-test.cc        | 1342 +++
 .../googletest/src/gtest-filepath.cc          |  387 +
 .../googletest/src/gtest-internal-inl.h       | 1183 +++
 .../googletest/googletest/src/gtest-port.cc   | 1259 +++
 .../googletest/src/gtest-printers.cc          |  373 +
 .../googletest/src/gtest-test-part.cc         |  110 +
 .../googletest/src/gtest-typed-test.cc        |  118 +
 .../vendor/googletest/googletest/src/gtest.cc | 5388 ++++++++++++
 .../googletest/googletest/src/gtest_main.cc   |   38 +
 .../test/gtest-death-test_ex_test.cc          |   93 +
 .../googletest/test/gtest-death-test_test.cc  | 1427 +++
 .../googletest/test/gtest-filepath_test.cc    |  662 ++
 .../googletest/test/gtest-linked_ptr_test.cc  |  154 +
 .../googletest/test/gtest-listener_test.cc    |  311 +
 .../googletest/test/gtest-message_test.cc     |  159 +
 .../googletest/test/gtest-options_test.cc     |  215 +
 .../googletest/test/gtest-param-test2_test.cc |   65 +
 .../googletest/test/gtest-param-test_test.cc  | 1055 +++
 .../googletest/test/gtest-param-test_test.h   |   57 +
 .../googletest/test/gtest-port_test.cc        | 1311 +++
 .../googletest/test/gtest-printers_test.cc    | 1635 ++++
 .../googletest/test/gtest-test-part_test.cc   |  208 +
 .../googletest/test/gtest-tuple_test.cc       |  320 +
 .../googletest/test/gtest-typed-test2_test.cc |   45 +
 .../googletest/test/gtest-typed-test_test.cc  |  380 +
 .../googletest/test/gtest-typed-test_test.h   |   66 +
 .../test/gtest-unittest-api_test.cc           |  341 +
 .../googletest/test/gtest_all_test.cc         |   47 +
 .../test/gtest_break_on_failure_unittest.py   |  212 +
 .../test/gtest_break_on_failure_unittest_.cc  |   88 +
 .../test/gtest_catch_exceptions_test.py       |  237 +
 .../test/gtest_catch_exceptions_test_.cc      |  311 +
 .../googletest/test/gtest_color_test.py       |  130 +
 .../googletest/test/gtest_color_test_.cc      |   71 +
 .../googletest/test/gtest_env_var_test.py     |  117 +
 .../googletest/test/gtest_env_var_test_.cc    |  126 +
 .../googletest/test/gtest_environment_test.cc |  192 +
 .../googletest/test/gtest_filter_unittest.py  |  636 ++
 .../googletest/test/gtest_filter_unittest_.cc |  140 +
 .../googletest/test/gtest_help_test.py        |  172 +
 .../googletest/test/gtest_help_test_.cc       |   46 +
 .../test/gtest_list_tests_unittest.py         |  207 +
 .../test/gtest_list_tests_unittest_.cc        |  157 +
 .../googletest/test/gtest_main_unittest.cc    |   45 +
 .../googletest/test/gtest_no_test_unittest.cc |   56 +
 .../googletest/test/gtest_output_test.py      |  340 +
 .../googletest/test/gtest_output_test_.cc     | 1062 +++
 .../test/gtest_output_test_golden_lin.txt     |  743 ++
 .../test/gtest_pred_impl_unittest.cc          | 2427 ++++++
 .../test/gtest_premature_exit_test.cc         |  127 +
 .../googletest/test/gtest_prod_test.cc        |   57 +
 .../googletest/test/gtest_repeat_test.cc      |  253 +
 .../googletest/test/gtest_shuffle_test.py     |  325 +
 .../googletest/test/gtest_shuffle_test_.cc    |  103 +
 .../googletest/test/gtest_sole_header_test.cc |   57 +
 .../googletest/test/gtest_stress_test.cc      |  256 +
 .../googletest/test/gtest_test_utils.py       |  320 +
 .../test/gtest_throw_on_failure_ex_test.cc    |   92 +
 .../test/gtest_throw_on_failure_test.py       |  171 +
 .../test/gtest_throw_on_failure_test_.cc      |   72 +
 .../test/gtest_uninitialized_test.py          |   70 +
 .../test/gtest_uninitialized_test_.cc         |   43 +
 .../googletest/test/gtest_unittest.cc         | 7706 +++++++++++++++++
 .../test/gtest_xml_outfile1_test_.cc          |   49 +
 .../test/gtest_xml_outfile2_test_.cc          |   49 +
 .../test/gtest_xml_outfiles_test.py           |  132 +
 .../test/gtest_xml_output_unittest.py         |  308 +
 .../test/gtest_xml_output_unittest_.cc        |  181 +
 .../googletest/test/gtest_xml_test_utils.py   |  194 +
 .../googletest/googletest/test/production.cc  |   36 +
 .../googletest/googletest/test/production.h   |   55 +
 .../xcode/Config/DebugProject.xcconfig        |   30 +
 .../xcode/Config/FrameworkTarget.xcconfig     |   17 +
 .../googletest/xcode/Config/General.xcconfig  |   41 +
 .../xcode/Config/ReleaseProject.xcconfig      |   32 +
 .../xcode/Config/StaticLibraryTarget.xcconfig |   18 +
 .../xcode/Config/TestTarget.xcconfig          |    8 +
 .../googletest/xcode/Resources/Info.plist     |   30 +
 .../xcode/Samples/FrameworkSample/Info.plist  |   28 +
 .../WidgetFramework.xcodeproj/project.pbxproj |  457 +
 .../xcode/Samples/FrameworkSample/runtests.sh |   62 +
 .../xcode/Samples/FrameworkSample/widget.cc   |   63 +
 .../xcode/Samples/FrameworkSample/widget.h    |   59 +
 .../Samples/FrameworkSample/widget_test.cc    |   68 +
 .../googletest/xcode/Scripts/runtests.sh      |   65 +
 .../xcode/Scripts/versiongenerate.py          |  100 +
 .../xcode/gtest.xcodeproj/project.pbxproj     | 1135 +++
 .../vendor/googletest/travis.sh               |   15 +
 337 files changed, 154235 insertions(+)
 create mode 100644 week4/softwareEng_9_4/CMakeLists.txt
 create mode 100644 week4/softwareEng_9_4/app/CMakeLists.txt
 create mode 100644 week4/softwareEng_9_4/app/main.cpp
 create mode 100755 week4/softwareEng_9_4/app/softwareEng_9_4
 create mode 100644 week4/softwareEng_9_4/app/softwareEng_9_4.cpp
 create mode 100644 week4/softwareEng_9_4/app/softwareEng_9_4.dSYM/Contents/Info.plist
 create mode 100644 week4/softwareEng_9_4/app/softwareEng_9_4.dSYM/Contents/Resources/DWARF/softwareEng_9_4
 create mode 100644 week4/softwareEng_9_4/cmake/CodeCoverage.cmake
 create mode 100644 week4/softwareEng_9_4/include/softwareEng_9_4.hpp
 create mode 100644 week4/softwareEng_9_4/readme.md
 create mode 100644 week4/softwareEng_9_4/test/CMakeLists.txt
 create mode 100644 week4/softwareEng_9_4/test/main.cpp
 create mode 100644 week4/softwareEng_9_4/test/test.cpp
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/.gitignore
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/.travis.yml
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/CMakeLists.txt
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/README.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/appveyor.yml
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/CHANGES
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/CMakeLists.txt
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/CONTRIBUTORS
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/LICENSE
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/Makefile.am
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/README.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/build-aux/.keep
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/configure.ac
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CheatSheet.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CookBook.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DesignDoc.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DevGuide.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/Documentation.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/ForDummies.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/FrequentlyAskedQuestions.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/KnownIssues.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CheatSheet.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CookBook.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/Documentation.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/ForDummies.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/FrequentlyAskedQuestions.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CheatSheet.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CookBook.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/Documentation.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/ForDummies.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/FrequentlyAskedQuestions.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CheatSheet.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CookBook.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/Documentation.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/ForDummies.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/FrequentlyAskedQuestions.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-actions.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-cardinalities.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h.pump
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.pump
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h.pump
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h.pump
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-matchers.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-actions.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-matchers.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-spec-builders.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-port.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h.pump
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-port.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/make/Makefile
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.sln
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.vcproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_config.vsprops
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_main.vcproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_test.vcproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.sln
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.vcxproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_config.props
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_main.vcxproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_test.vcxproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.sln
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.vcxproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_config.props
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_main.vcxproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_test.vcxproj
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/fuse_gmock_files.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/LICENSE
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README.cppclean
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/__init__.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/ast.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class_test.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/keywords.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/tokenize.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/utils.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/gmock_gen.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock-config.in
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock_doctor.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload_gmock.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-all.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-cardinalities.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-internal-utils.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-matchers.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-spec-builders.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock_main.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-actions_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-cardinalities_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-actions_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-function-mockers_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-internal-utils_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-matchers_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-internal-utils_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-matchers_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-more-actions_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-nice-strict_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-port_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-spec-builders_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_all_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_ex_test.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test_.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link2_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.h
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_golden.txt
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_stress_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test_utils.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/.gitignore
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/CHANGES
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/CMakeLists.txt
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/CONTRIBUTORS
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/LICENSE
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/Makefile.am
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/README.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/build-aux/.keep
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/cmake/internal_utils.cmake
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.cbproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.groupproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_all.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_link.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_main.cbproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_unittest.cbproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/configure.ac
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/AdvancedGuide.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/DevGuide.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/Documentation.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/FAQ.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/Primer.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/PumpManual.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/Samples.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_AdvancedGuide.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Documentation.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_FAQ.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Primer.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_PumpManual.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_XcodeGuide.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_AdvancedGuide.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Documentation.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_FAQ.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Primer.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_PumpManual.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Samples.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_XcodeGuide.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_AdvancedGuide.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Documentation.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_FAQ.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Primer.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_PumpManual.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Samples.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_XcodeGuide.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/XcodeGuide.md
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-death-test.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-message.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h.pump
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-printers.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-spi.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-test-part.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-typed-test.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_pred_impl.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_prod.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-port.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-printers.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-filepath.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-internal.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-linked_ptr.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h.pump
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port-arch.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-string.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h.pump
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h.pump
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/m4/acx_pthread.m4
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/m4/gtest.m4
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/make/Makefile
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.sln
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.vcproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.sln
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.vcproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main-md.vcproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main.vcproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test-md.vcproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test.vcproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest-md.vcproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest.vcproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/prime_tables.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample10_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3-inl.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample5_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample6_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample7_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample8_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample9_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/common.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/fuse_gtest_files.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gen_gtest_pred_impl.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gtest-config.in
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/pump.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/release_docs.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/test/Makefile
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload_gtest.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-all.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-death-test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-filepath.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-internal-inl.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-port.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-printers.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-test-part.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-typed-test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest_main.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_ex_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-filepath_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-linked_ptr_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-listener_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-message_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-options_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test2_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-port_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-printers_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-test-part_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-tuple_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test2_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-unittest-api_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_all_test.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest_.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test_.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test_.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test_.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_environment_test.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest_.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test_.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest_.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_main_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_no_test_unittest.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_golden_lin.txt
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_pred_impl_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_premature_exit_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_prod_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_repeat_test.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test_.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_sole_header_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_stress_test.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_test_utils.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test_.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test_.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_unittest.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile1_test_.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile2_test_.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfiles_test.py
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest_.cc
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_test_utils.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/production.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/production.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/DebugProject.xcconfig
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/FrameworkTarget.xcconfig
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/General.xcconfig
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/ReleaseProject.xcconfig
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/StaticLibraryTarget.xcconfig
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/TestTarget.xcconfig
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Resources/Info.plist
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/Info.plist
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/runtests.sh
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.h
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget_test.cc
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/runtests.sh
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/versiongenerate.py
 create mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/gtest.xcodeproj/project.pbxproj
 create mode 100755 week4/softwareEng_9_4/vendor/googletest/travis.sh

diff --git a/week4/softwareEng_9_4/CMakeLists.txt b/week4/softwareEng_9_4/CMakeLists.txt
new file mode 100644
index 00000000..ccddcaf2
--- /dev/null
+++ b/week4/softwareEng_9_4/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.2.1)
+project (scratch)
+
+# Add project cmake modules to path.
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake)
+
+# We probably don't want this to run on every build.
+option(COVERAGE "Generate Coverage Data" OFF)
+
+if (COVERAGE)
+    include(CodeCoverage)
+    set(LCOV_REMOVE_EXTRA "'vendor/*'")
+    setup_target_for_coverage(code_coverage test/cpp-test coverage)
+    set(COVERAGE_SRCS app/main.cpp include/lib.hpp)
+
+    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+    SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+    SET(CMAKE_EXE_LINKER_FLAGS "-fprofile-arcs -ftest-coverage")
+else()
+    set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wpedantic -g")
+endif()
+
+include(CMakeToolsHelpers OPTIONAL)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_CXX_STANDARD 14)
+
+add_subdirectory(app)
+add_subdirectory(test)
+add_subdirectory(vendor/googletest/googletest)
diff --git a/week4/softwareEng_9_4/app/CMakeLists.txt b/week4/softwareEng_9_4/app/CMakeLists.txt
new file mode 100644
index 00000000..6b16684e
--- /dev/null
+++ b/week4/softwareEng_9_4/app/CMakeLists.txt
@@ -0,0 +1,4 @@
+add_executable(shell-app softwareEng_9_4.cpp)
+include_directories(
+    ${CMAKE_SOURCE_DIR}/include
+)
diff --git a/week4/softwareEng_9_4/app/main.cpp b/week4/softwareEng_9_4/app/main.cpp
new file mode 100644
index 00000000..74232ade
--- /dev/null
+++ b/week4/softwareEng_9_4/app/main.cpp
@@ -0,0 +1,8 @@
+#include <iostream>
+#include <lib.hpp>
+
+int main()
+{
+    dummy();
+    return 0;
+}
diff --git a/week4/softwareEng_9_4/app/softwareEng_9_4 b/week4/softwareEng_9_4/app/softwareEng_9_4
new file mode 100755
index 0000000000000000000000000000000000000000..5b07679760e62263ee30394a0273d294672117e1
GIT binary patch
literal 58860
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
Qy63h3KCE2fowo0P078|tsQ>@~

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/softwareEng_9_4.cpp b/week4/softwareEng_9_4/app/softwareEng_9_4.cpp
new file mode 100644
index 00000000..3c5aa520
--- /dev/null
+++ b/week4/softwareEng_9_4/app/softwareEng_9_4.cpp
@@ -0,0 +1,55 @@
+/**
+ *  @copyright (c) 2021 Sumedh Reddy
+ *  @file    softwareEngineering_9_4.cpp
+ *  @author  SumedhReddy
+ *
+ *  @brief Extractiob of printPosition and code reusablility
+ *
+ */
+#include "softwareEng_9_4.hpp"
+
+/**
+ * @brief 
+ * printPostion method enable code resuablity and extraction mechanism 
+ * this extracted method is used to find and print position
+ */
+void printer::printPosition(int text_length, int array_to_search1_length, char* text, char* array_to_search1, int position1) {
+int i, j;
+for (i = 0; i < text_length - array_to_search1_length + 1; i++) {
+  bool found = true;
+  for (j = 0; j < array_to_search1_length; j++)
+    if (text[i + j] != array_to_search1[j])
+      found = false;
+  if (found) {
+    position1 = i;
+    break;
+  }
+}
+std::cout<< "Position at ::: " << position1 << std::endl;
+}
+
+/**
+ * @brief 
+ * input() method makes sure that all the inputs for printing the positon
+ * are fed and passed by value to printPosition() method
+ */
+int printer::input() {
+    char text[1024]="";
+    char array_to_search1[4] = "";
+    int array_to_search1_length;
+    std::cout<< "Enter the Text:" << std::endl;
+    std::cin>> text;
+    int text_length = 10;
+    std::cout<< "Enter the element to search: ";
+    std::cin>> array_to_search1;
+    std::cout<< "Enter the length of search element: ";
+    std::cin>> array_to_search1_length;
+    int position1 = -1;
+    printPosition(text_length, array_to_search1_length, text, array_to_search1, position1);
+    return position1;
+}
+
+int main() {
+    printer printObj;
+    printObj.input();
+}
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/app/softwareEng_9_4.dSYM/Contents/Info.plist b/week4/softwareEng_9_4/app/softwareEng_9_4.dSYM/Contents/Info.plist
new file mode 100644
index 00000000..1d4c341a
--- /dev/null
+++ b/week4/softwareEng_9_4/app/softwareEng_9_4.dSYM/Contents/Info.plist
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.softwareEng_9_4</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>
diff --git a/week4/softwareEng_9_4/app/softwareEng_9_4.dSYM/Contents/Resources/DWARF/softwareEng_9_4 b/week4/softwareEng_9_4/app/softwareEng_9_4.dSYM/Contents/Resources/DWARF/softwareEng_9_4
new file mode 100644
index 0000000000000000000000000000000000000000..8a2300b15c3aba83068109fa5adac2ca70956fd1
GIT binary patch
literal 123205
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

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/cmake/CodeCoverage.cmake b/week4/softwareEng_9_4/cmake/CodeCoverage.cmake
new file mode 100644
index 00000000..50dffc7d
--- /dev/null
+++ b/week4/softwareEng_9_4/cmake/CodeCoverage.cmake
@@ -0,0 +1,203 @@
+# Copyright (c) 2012 - 2015, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. 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.
+#
+# 3. Neither the name of the copyright holder 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 HOLDER 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.
+#
+#
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# USAGE:
+
+# 0. (Mac only) If you use Xcode 5.1 make sure to patch geninfo as described here:
+#      http://stackoverflow.com/a/22404544/80480
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt:
+#      INCLUDE(CodeCoverage)
+#
+# 3. Set compiler flags to turn off optimization and enable coverage:
+#    SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#	 SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
+#
+# 3. Use the function SETUP_TARGET_FOR_COVERAGE to create a custom make target
+#    which runs your test executable and produces a lcov code coverage report:
+#    Example:
+#	 SETUP_TARGET_FOR_COVERAGE(
+#				my_coverage_target  # Name for custom target.
+#				test_driver         # Name of the test driver executable that runs the tests.
+#									# NOTE! This should always have a ZERO as exit code
+#									# otherwise the coverage generation will not complete.
+#				coverage            # Name of output directory.
+#				)
+#
+#    If you need to exclude additional directories from the report, specify them
+#    using the LCOV_REMOVE_EXTRA variable before calling SETUP_TARGET_FOR_COVERAGE.
+#    For example:
+#
+#    set(LCOV_REMOVE_EXTRA "'thirdparty/*'")
+#
+# 4. Build a Debug build:
+#	 cmake -DCMAKE_BUILD_TYPE=Debug ..
+#	 make
+#	 make my_coverage_target
+#
+#
+
+# Check prereqs
+FIND_PROGRAM( GCOV_PATH gcov )
+FIND_PROGRAM( LCOV_PATH lcov )
+FIND_PROGRAM( GENHTML_PATH genhtml )
+FIND_PROGRAM( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/tests)
+
+IF(NOT GCOV_PATH)
+	MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
+ENDIF() # NOT GCOV_PATH
+
+IF("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+	IF("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
+		MESSAGE(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+	ENDIF()
+ELSEIF(NOT CMAKE_COMPILER_IS_GNUCXX)
+	MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+ENDIF() # CHECK VALID COMPILER
+
+SET(CMAKE_CXX_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+SET(CMAKE_C_FLAGS_COVERAGE
+    "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+SET(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+SET(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+MARK_AS_ADVANCED(
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+IF ( NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "Coverage"))
+  MESSAGE( WARNING "Code coverage results with an optimized (non-Debug) build may be misleading" )
+ENDIF() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
+
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests.
+#						MUST return ZERO always, even on errors.
+#						If not, no coverage report will be created!
+# Param _outputname     lcov output is generated as _outputname.info
+#                       HTML report is generated in _outputname/index.html
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
+
+	IF(NOT LCOV_PATH)
+		MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
+	ENDIF() # NOT LCOV_PATH
+
+	IF(NOT GENHTML_PATH)
+		MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
+	ENDIF() # NOT GENHTML_PATH
+
+	SET(coverage_info "${CMAKE_BINARY_DIR}/${_outputname}.info")
+	SET(coverage_cleaned "${coverage_info}.cleaned")
+
+	SEPARATE_ARGUMENTS(test_command UNIX_COMMAND "${_testrunner}")
+
+	# Setup target
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Cleanup lcov
+		${LCOV_PATH} --directory . --zerocounters
+
+		# Run tests
+		COMMAND ${test_command} ${ARGV3}
+
+		# Capturing lcov counters and generating report
+		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${coverage_info}
+		COMMAND ${LCOV_PATH} --remove ${coverage_info} 'tests/*' '/usr/*' ${LCOV_REMOVE_EXTRA} --output-file ${coverage_cleaned}
+		COMMAND ${GENHTML_PATH} -o ${_outputname} ${coverage_cleaned}
+		COMMAND ${CMAKE_COMMAND} -E remove ${coverage_info} ${coverage_cleaned}
+
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE
+
+# Param _targetname     The name of new the custom make target
+# Param _testrunner     The name of the target which runs the tests
+# Param _outputname     cobertura output is generated as _outputname.xml
+# Optional fourth parameter is passed as arguments to _testrunner
+#   Pass them in list form, e.g.: "-j;2" for -j 2
+FUNCTION(SETUP_TARGET_FOR_COVERAGE_COBERTURA _targetname _testrunner _outputname)
+
+	IF(NOT PYTHON_EXECUTABLE)
+		MESSAGE(FATAL_ERROR "Python not found! Aborting...")
+	ENDIF() # NOT PYTHON_EXECUTABLE
+
+	IF(NOT GCOVR_PATH)
+		MESSAGE(FATAL_ERROR "gcovr not found! Aborting...")
+	ENDIF() # NOT GCOVR_PATH
+
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Run tests
+		${_testrunner} ${ARGV3}
+
+		# Running gcovr
+		COMMAND ${GCOVR_PATH} -x -r ${CMAKE_SOURCE_DIR} -e '${CMAKE_SOURCE_DIR}/tests/'  -o ${_outputname}.xml
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Running gcovr to produce Cobertura code coverage report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Cobertura code coverage report saved in ${_outputname}.xml."
+	)
+
+ENDFUNCTION() # SETUP_TARGET_FOR_COVERAGE_COBERTURA
diff --git a/week4/softwareEng_9_4/include/softwareEng_9_4.hpp b/week4/softwareEng_9_4/include/softwareEng_9_4.hpp
new file mode 100644
index 00000000..7a11c7fc
--- /dev/null
+++ b/week4/softwareEng_9_4/include/softwareEng_9_4.hpp
@@ -0,0 +1,35 @@
+/**
+ *  @copyright (c) 2021 Sumedh Reddy Koppula
+ *  @file    SoftwareEngineering9-4.hpp
+ *  @author  SumedhReddy 
+ *
+ *  @brief Header
+ *
+ */
+
+#pragma once
+
+#include <iostream>
+
+#include <string>
+
+#include <vector>
+
+#include <numeric>
+
+/**
+ * @brief 
+ * printer is a class to extract a new method from printposition, 
+ * The motivation behind solving this problem
+ * is to implement method extraction for code refractory using 
+ * input method
+ */
+class printer {
+ public:
+    int input();
+    void printPosition(int t_length, int a_length_search, char* text,char* array_to_search1, int position);
+    printer();
+};
+
+ printer::printer(void){
+}
diff --git a/week4/softwareEng_9_4/readme.md b/week4/softwareEng_9_4/readme.md
new file mode 100644
index 00000000..e9656524
--- /dev/null
+++ b/week4/softwareEng_9_4/readme.md
@@ -0,0 +1,50 @@
+# C++ Boilerplate
+[![Build Status](https://travis-ci.org/dpiet/cpp-boilerplate.svg?branch=master)](https://travis-ci.org/dpiet/cpp-boilerplate)
+[![Coverage Status](https://coveralls.io/repos/github/dpiet/cpp-boilerplate/badge.svg?branch=master)](https://coveralls.io/github/dpiet/cpp-boilerplate?branch=master)
+---
+## Week 4 Assignment
+
+Name: Sumedh Reddy Koppula
+UID: 117386066
+
+In week4 directory please find invidual folder with programming assignment exercise names with UML diagram. On each folder please perform below executions in command-line to get the ouput.
+1. mkdir build
+2. cd build
+3. cmake ..
+4. make
+5. cd app
+6. ./shell-app
+
+Please find the wrting assignment .pdf and output screenshots in the root folder.
+
+## Sample Outputs for week4
+
+
+## Plugins
+
+- CppChEclipse
+
+    To install and run cppcheck in Eclipse
+
+    1. In Eclipse, go to Window -> Preferences -> C/C++ -> cppcheclipse.
+    Set cppcheck binary path to "/usr/bin/cppcheck".
+
+    2. To run CPPCheck on a project, right click on the project name in the Project Explorer 
+    and choose cppcheck -> Run cppcheck.
+
+
+- Google C++ Sytle
+
+    To include and use Google C++ Style formatter in Eclipse
+
+    1. In Eclipse, go to Window -> Preferences -> C/C++ -> Code Style -> Formatter. 
+    Import [eclipse-cpp-google-style][reference-id-for-eclipse-cpp-google-style] and apply.
+
+    2. To use Google C++ style formatter, right click on the source code or folder in 
+    Project Explorer and choose Source -> Format
+
+[reference-id-for-eclipse-cpp-google-style]: https://raw.githubusercontent.com/google/styleguide/gh-pages/eclipse-cpp-google-style.xml
+
+- Git
+
+    It is possible to manage version control through Eclipse and the git plugin, but it typically requires creating another project. If you're interested in this, try it out yourself and contact me on Canvas.
diff --git a/week4/softwareEng_9_4/test/CMakeLists.txt b/week4/softwareEng_9_4/test/CMakeLists.txt
new file mode 100644
index 00000000..2b1cd4cb
--- /dev/null
+++ b/week4/softwareEng_9_4/test/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(GTEST_SHUFFLE 1)
+
+add_executable(
+    cpp-test
+    main.cpp
+    test.cpp
+)
+
+target_include_directories(cpp-test PUBLIC ../vendor/googletest/googletest/include 
+                                           ${CMAKE_SOURCE_DIR}/include)
+target_link_libraries(cpp-test PUBLIC gtest)
diff --git a/week4/softwareEng_9_4/test/main.cpp b/week4/softwareEng_9_4/test/main.cpp
new file mode 100644
index 00000000..697a9d70
--- /dev/null
+++ b/week4/softwareEng_9_4/test/main.cpp
@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/test/test.cpp b/week4/softwareEng_9_4/test/test.cpp
new file mode 100644
index 00000000..2c5cd069
--- /dev/null
+++ b/week4/softwareEng_9_4/test/test.cpp
@@ -0,0 +1,5 @@
+#include <gtest/gtest.h>
+
+TEST(dummy, should_pass) {
+  EXPECT_EQ(1, 1);
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/.gitignore b/week4/softwareEng_9_4/vendor/googletest/.gitignore
new file mode 100644
index 00000000..ce310bc3
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/.gitignore
@@ -0,0 +1,2 @@
+# Ignore CI build directory
+build/
diff --git a/week4/softwareEng_9_4/vendor/googletest/.travis.yml b/week4/softwareEng_9_4/vendor/googletest/.travis.yml
new file mode 100644
index 00000000..3204dfac
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/.travis.yml
@@ -0,0 +1,46 @@
+# Build matrix / environment variable are explained on:
+# http://about.travis-ci.org/docs/user/build-configuration/
+# This file can be validated on:
+# http://lint.travis-ci.org/
+
+install:
+# /usr/bin/gcc is 4.6 always, but gcc-X.Y is available.
+- if [ "$CXX" = "g++" ]; then export CXX="g++-4.9" CC="gcc-4.9"; fi
+# /usr/bin/clang is 3.4, lets override with modern one.
+- if [ "$CXX" = "clang++" ] && [ "$TRAVIS_OS_NAME" = "linux" ]; then export CXX="clang++-3.7" CC="clang-3.7"; fi
+- echo ${PATH}
+- echo ${CXX}
+- ${CXX} --version
+- ${CXX} -v
+addons:
+  apt:
+    # List of whitelisted in travis packages for ubuntu-precise can be found here:
+    #   https://github.com/travis-ci/apt-package-whitelist/blob/master/ubuntu-precise
+    # List of whitelisted in travis apt-sources:
+    #   https://github.com/travis-ci/apt-source-whitelist/blob/master/ubuntu.json
+    sources:
+    - ubuntu-toolchain-r-test
+    - llvm-toolchain-precise-3.7
+    packages:
+    - gcc-4.9
+    - g++-4.9
+    - clang-3.7
+    - valgrind
+os:
+  - linux
+  - osx
+language: cpp
+compiler:
+  - gcc
+  - clang
+script: ./travis.sh
+env:
+  matrix:
+    - GTEST_TARGET=googletest SHARED_LIB=OFF STATIC_LIB=ON CMAKE_PKG=OFF BUILD_TYPE=debug   VERBOSE_MAKE=true VERBOSE
+    - GTEST_TARGET=googlemock SHARED_LIB=OFF STATIC_LIB=ON CMAKE_PKG=OFF BUILD_TYPE=debug   VERBOSE_MAKE=true VERBOSE
+    - GTEST_TARGET=googlemock SHARED_LIB=OFF STATIC_LIB=ON CMAKE_PKG=OFF BUILD_TYPE=debug CXX_FLAGS=-std=c++11  VERBOSE_MAKE=true VERBOSE
+#    - GTEST_TARGET=googletest SHARED_LIB=ON  STATIC_LIB=ON CMAKE_PKG=ON  BUILD_TYPE=release VERBOSE_MAKE=false
+#    - GTEST_TARGET=googlemock SHARED_LIB=ON  STATIC_LIB=ON CMAKE_PKG=ON  BUILD_TYPE=release VERBOSE_MAKE=false
+notifications:
+  email: false
+sudo: false
diff --git a/week4/softwareEng_9_4/vendor/googletest/CMakeLists.txt b/week4/softwareEng_9_4/vendor/googletest/CMakeLists.txt
new file mode 100644
index 00000000..8d2b552e
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/CMakeLists.txt
@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 2.6.2)
+
+project( googletest-distribution )
+
+enable_testing()
+
+option(BUILD_GTEST "Builds the googletest subproject" OFF)
+
+#Note that googlemock target already builds googletest
+option(BUILD_GMOCK "Builds the googlemock subproject" ON)
+
+if(BUILD_GMOCK)
+  add_subdirectory( googlemock )
+elseif(BUILD_GTEST)
+  add_subdirectory( googletest )
+endif()
diff --git a/week4/softwareEng_9_4/vendor/googletest/README.md b/week4/softwareEng_9_4/vendor/googletest/README.md
new file mode 100644
index 00000000..076484e4
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/README.md
@@ -0,0 +1,142 @@
+
+# Google Test #
+
+[![Build Status](https://travis-ci.org/google/googletest.svg?branch=master)](https://travis-ci.org/google/googletest)
+[![Build status](https://ci.appveyor.com/api/projects/status/4o38plt0xbo1ubc8/branch/master?svg=true)](https://ci.appveyor.com/project/BillyDonahue/googletest/branch/master)
+
+Welcome to **Google Test**, Google's C++ test framework!
+
+This repository is a merger of the formerly separate GoogleTest and
+GoogleMock projects. These were so closely related that it makes sense to
+maintain and release them together.
+
+Please see the project page above for more information as well as the
+mailing list for questions, discussions, and development.  There is
+also an IRC channel on OFTC (irc.oftc.net) #gtest available.  Please
+join us!
+
+Getting started information for **Google Test** is available in the 
+[Google Test Primer](googletest/docs/Primer.md) documentation.
+
+**Google Mock** is an extension to Google Test for writing and using C++ mock
+classes.  See the separate [Google Mock documentation](googlemock/README.md).
+
+More detailed documentation for googletest (including build instructions) are
+in its interior [googletest/README.md](googletest/README.md) file.
+
+## Features ##
+
+  * An [XUnit](https://en.wikipedia.org/wiki/XUnit) test framework.
+  * Test discovery.
+  * A rich set of assertions.
+  * User-defined assertions.
+  * Death tests.
+  * Fatal and non-fatal failures.
+  * Value-parameterized tests.
+  * Type-parameterized tests.
+  * Various options for running the tests.
+  * XML test report generation.
+
+## Platforms ##
+
+Google test has been used on a variety of platforms:
+
+  * Linux
+  * Mac OS X
+  * Windows
+  * Cygwin
+  * MinGW
+  * Windows Mobile
+  * Symbian
+
+## Who Is Using Google Test? ##
+
+In addition to many internal projects at Google, Google Test is also used by
+the following notable projects:
+
+  * The [Chromium projects](http://www.chromium.org/) (behind the Chrome
+    browser and Chrome OS).
+  * The [LLVM](http://llvm.org/) compiler.
+  * [Protocol Buffers](https://github.com/google/protobuf), Google's data
+    interchange format.
+  * The [OpenCV](http://opencv.org/) computer vision library.
+
+## Related Open Source Projects ##
+
+[Google Test UI](https://github.com/ospector/gtest-gbar) is test runner that runs
+your test binary, allows you to track its progress via a progress bar, and
+displays a list of test failures. Clicking on one shows failure text. Google
+Test UI is written in C#.
+
+[GTest TAP Listener](https://github.com/kinow/gtest-tap-listener) is an event
+listener for Google Test that implements the
+[TAP protocol](https://en.wikipedia.org/wiki/Test_Anything_Protocol) for test
+result output. If your test runner understands TAP, you may find it useful.
+
+## Requirements ##
+
+Google Test is designed to have fairly minimal requirements to build
+and use with your projects, but there are some.  Currently, we support
+Linux, Windows, Mac OS X, and Cygwin.  We will also make our best
+effort to support other platforms (e.g. Solaris, AIX, and z/OS).
+However, since core members of the Google Test project have no access
+to these platforms, Google Test may have outstanding issues there.  If
+you notice any problems on your platform, please notify
+<googletestframework@googlegroups.com>. Patches for fixing them are
+even more welcome!
+
+### Linux Requirements ###
+
+These are the base requirements to build and use Google Test from a source
+package (as described below):
+
+  * GNU-compatible Make or gmake
+  * POSIX-standard shell
+  * POSIX(-2) Regular Expressions (regex.h)
+  * A C++98-standard-compliant compiler
+
+### Windows Requirements ###
+
+  * Microsoft Visual C++ v7.1 or newer
+
+### Cygwin Requirements ###
+
+  * Cygwin v1.5.25-14 or newer
+
+### Mac OS X Requirements ###
+
+  * Mac OS X v10.4 Tiger or newer
+  * Xcode Developer Tools
+
+### Requirements for Contributors ###
+
+We welcome patches.  If you plan to contribute a patch, you need to
+build Google Test and its own tests from a git checkout (described
+below), 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.6.4 or newer
+
+## Regenerating Source Files ##
+
+Some of Google Test's source files are generated from templates (not
+in the C++ sense) using a script.
+For example, the
+file include/gtest/internal/gtest-type-util.h.pump is used to generate
+gtest-type-util.h in the same directory.
+
+You don't need to worry about regenerating the source files
+unless you need to modify them.  You would then modify the
+corresponding `.pump` files and run the '[pump.py](googletest/scripts/pump.py)'
+generator script.  See the [Pump Manual](googletest/docs/PumpManual.md).
+
+### Contributing Code ###
+
+We welcome patches.  Please read the
+[Developer's Guide](googletest/docs/DevGuide.md)
+for how you can contribute. In particular, make sure you have signed
+the Contributor License Agreement, or we won't be able to accept the
+patch.
+
+Happy testing!
diff --git a/week4/softwareEng_9_4/vendor/googletest/appveyor.yml b/week4/softwareEng_9_4/vendor/googletest/appveyor.yml
new file mode 100644
index 00000000..d613fd60
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/appveyor.yml
@@ -0,0 +1,71 @@
+version: '{build}'
+
+os: Visual Studio 2015
+
+environment:
+  matrix:
+  - Toolset: v140
+  - Toolset: v120
+  - Toolset: v110
+  - Toolset: v100
+
+platform:
+  - Win32
+  - x64
+
+configuration:
+#  - Release
+  - Debug
+
+build:
+  verbosity: minimal
+
+artifacts:
+  - path: '_build/Testing/Temporary/*'
+    name: test_results
+
+before_build:
+- ps: |
+    Write-Output "Configuration: $env:CONFIGURATION"
+    Write-Output "Platform: $env:PLATFORM"
+    $generator = switch ($env:TOOLSET)
+    {
+        "v140" {"Visual Studio 14 2015"}
+        "v120" {"Visual Studio 12 2013"}
+        "v110" {"Visual Studio 11 2012"}
+        "v100" {"Visual Studio 10 2010"}
+    }
+    if ($env:PLATFORM -eq "x64")
+    {
+        $generator = "$generator Win64"
+    }
+
+build_script:
+- ps: |
+    if (($env:TOOLSET -eq "v100") -and ($env:PLATFORM -eq "x64"))
+    {
+        return
+    }
+    md _build -Force | Out-Null
+    cd _build
+
+    & cmake -G "$generator" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -Dgtest_build_tests=ON -Dgtest_build_samples=ON -Dgmock_build_tests=ON ..
+    if ($LastExitCode -ne 0) {
+        throw "Exec: $ErrorMessage"
+    }
+    & cmake --build . --config $env:CONFIGURATION
+    if ($LastExitCode -ne 0) {
+        throw "Exec: $ErrorMessage"
+    }
+
+test_script:
+- ps: |
+    if (($env:Toolset -eq "v100") -and ($env:PLATFORM -eq "x64"))
+    {
+        return
+    }
+
+    & ctest -C $env:CONFIGURATION --output-on-failure
+    if ($LastExitCode -ne 0) {
+        throw "Exec: $ErrorMessage"
+    }
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/CHANGES b/week4/softwareEng_9_4/vendor/googletest/googlemock/CHANGES
new file mode 100644
index 00000000..d6f2f760
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/CHANGES
@@ -0,0 +1,126 @@
+Changes for 1.7.0:
+
+* All new improvements in Google Test 1.7.0.
+* New feature: matchers DoubleNear(), FloatNear(),
+  NanSensitiveDoubleNear(), NanSensitiveFloatNear(),
+  UnorderedElementsAre(), UnorderedElementsAreArray(), WhenSorted(),
+  WhenSortedBy(), IsEmpty(), and SizeIs().
+* Improvement: Google Mock can now be built as a DLL.
+* Improvement: when compiled by a C++11 compiler, matchers AllOf()
+  and AnyOf() can accept an arbitrary number of matchers.
+* Improvement: when compiled by a C++11 compiler, matchers
+  ElementsAreArray() can accept an initializer list.
+* Improvement: when exceptions are enabled, a mock method with no
+  default action now throws instead crashing the test.
+* Improvement: added class testing::StringMatchResultListener to aid
+  definition of composite matchers.
+* Improvement: function return types used in MOCK_METHOD*() macros can
+  now contain unprotected commas.
+* Improvement (potentially breaking): EXPECT_THAT() and ASSERT_THAT()
+  are now more strict in ensuring that the value type and the matcher
+  type are compatible, catching potential bugs in tests.
+* Improvement: Pointee() now works on an optional<T>.
+* Improvement: the ElementsAreArray() matcher can now take a vector or
+  iterator range as input, and makes a copy of its input elements
+  before the conversion to a Matcher.
+* Improvement: the Google Mock Generator can now generate mocks for
+  some class templates.
+* Bug fix: mock object destruction triggerred by another mock object's
+  destruction no longer hangs.
+* Improvement: Google Mock Doctor works better with newer Clang and
+  GCC now.
+* Compatibility fixes.
+* Bug/warning fixes.
+
+Changes for 1.6.0:
+
+* Compilation is much faster and uses much less memory, especially
+  when the constructor and destructor of a mock class are moved out of
+  the class body.
+* New matchers: Pointwise(), Each().
+* New actions: ReturnPointee() and ReturnRefOfCopy().
+* CMake support.
+* Project files for Visual Studio 2010.
+* AllOf() and AnyOf() can handle up-to 10 arguments now.
+* Google Mock doctor understands Clang error messages now.
+* SetArgPointee<> now accepts string literals.
+* gmock_gen.py handles storage specifier macros and template return
+  types now.
+* Compatibility fixes.
+* Bug fixes and implementation clean-ups.
+* Potentially incompatible changes: disables the harmful 'make install'
+  command in autotools.
+
+Potentially breaking changes:
+
+* The description string for MATCHER*() changes from Python-style
+  interpolation to an ordinary C++ string expression.
+* SetArgumentPointee is deprecated in favor of SetArgPointee.
+* Some non-essential project files for Visual Studio 2005 are removed.
+
+Changes for 1.5.0:
+
+ * New feature: Google Mock can be safely used in multi-threaded tests
+   on platforms having pthreads.
+ * New feature: function for printing a value of arbitrary type.
+ * New feature: function ExplainMatchResult() for easy definition of
+   composite matchers.
+ * The new matcher API lets user-defined matchers generate custom
+   explanations more directly and efficiently.
+ * Better failure messages all around.
+ * NotNull() and IsNull() now work with smart pointers.
+ * Field() and Property() now work when the matcher argument is a pointer
+   passed by reference.
+ * Regular expression matchers on all platforms.
+ * Added GCC 4.0 support for Google Mock Doctor.
+ * Added gmock_all_test.cc for compiling most Google Mock tests
+   in a single file.
+ * Significantly cleaned up compiler warnings.
+ * Bug fixes, better test coverage, and implementation clean-ups.
+
+ Potentially breaking changes:
+
+ * Custom matchers defined using MatcherInterface or MakePolymorphicMatcher()
+   need to be updated after upgrading to Google Mock 1.5.0; matchers defined
+   using MATCHER or MATCHER_P* aren't affected.
+ * Dropped support for 'make install'.
+
+Changes for 1.4.0 (we skipped 1.2.* and 1.3.* to match the version of
+Google Test):
+
+ * Works in more environments: Symbian and minGW, Visual C++ 7.1.
+ * Lighter weight: comes with our own implementation of TR1 tuple (no
+   more dependency on Boost!).
+ * New feature: --gmock_catch_leaked_mocks for detecting leaked mocks.
+ * New feature: ACTION_TEMPLATE for defining templatized actions.
+ * New feature: the .After() clause for specifying expectation order.
+ * New feature: the .With() clause for for specifying inter-argument
+   constraints.
+ * New feature: actions ReturnArg<k>(), ReturnNew<T>(...), and
+   DeleteArg<k>().
+ * New feature: matchers Key(), Pair(), Args<...>(), AllArgs(), IsNull(),
+   and Contains().
+ * New feature: utility class MockFunction<F>, useful for checkpoints, etc.
+ * New feature: functions Value(x, m) and SafeMatcherCast<T>(m).
+ * New feature: copying a mock object is rejected at compile time.
+ * New feature: a script for fusing all Google Mock and Google Test
+   source files for easy deployment.
+ * Improved the Google Mock doctor to diagnose more diseases.
+ * Improved the Google Mock generator script.
+ * Compatibility fixes for Mac OS X and gcc.
+ * Bug fixes and implementation clean-ups.
+
+Changes for 1.1.0:
+
+ * New feature: ability to use Google Mock with any testing framework.
+ * New feature: macros for easily defining new matchers
+ * New feature: macros for easily defining new actions.
+ * New feature: more container matchers.
+ * New feature: actions for accessing function arguments and throwing
+   exceptions.
+ * Improved the Google Mock doctor script for diagnosing compiler errors.
+ * Bug fixes and implementation clean-ups.
+
+Changes for 1.0.0:
+
+ * Initial Open Source release of Google Mock
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/CMakeLists.txt b/week4/softwareEng_9_4/vendor/googletest/googlemock/CMakeLists.txt
new file mode 100644
index 00000000..beb259a2
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/CMakeLists.txt
@@ -0,0 +1,202 @@
+########################################################################
+# CMake build script for Google Mock.
+#
+# To run the tests for Google Mock itself on Linux, use 'make test' or
+# ctest.  You can select which tests to run using 'ctest -R regex'.
+# For more options, run 'ctest --help'.
+
+# BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to
+# make it prominent in the GUI.
+option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF)
+
+option(gmock_build_tests "Build all of Google Mock's own tests." OFF)
+
+# A directory to find Google Test sources.
+if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/gtest/CMakeLists.txt")
+  set(gtest_dir gtest)
+else()
+  set(gtest_dir ../googletest)
+endif()
+
+# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build().
+include("${gtest_dir}/cmake/hermetic_build.cmake" OPTIONAL)
+
+if (COMMAND pre_project_set_up_hermetic_build)
+  # Google Test also calls hermetic setup functions from add_subdirectory,
+  # although its changes will not affect things at the current scope.
+  pre_project_set_up_hermetic_build()
+endif()
+
+########################################################################
+#
+# Project-wide settings
+
+# Name of the project.
+#
+# CMake files in this project can refer to the root source directory
+# as ${gmock_SOURCE_DIR} and to the root binary directory as
+# ${gmock_BINARY_DIR}.
+# Language "C" is required for find_package(Threads).
+project(gmock CXX C)
+cmake_minimum_required(VERSION 2.6.2)
+
+if (COMMAND set_up_hermetic_build)
+  set_up_hermetic_build()
+endif()
+
+# Instructs CMake to process Google Test's CMakeLists.txt and add its
+# targets to the current scope.  We are placing Google Test's binary
+# directory in a subdirectory of our own as VC compilation may break
+# if they are the same (the default).
+add_subdirectory("${gtest_dir}" "${gmock_BINARY_DIR}/gtest")
+
+# Although Google Test's CMakeLists.txt calls this function, the
+# changes there don't affect the current scope.  Therefore we have to
+# call it again here.
+config_compiler_and_linker()  # from ${gtest_dir}/cmake/internal_utils.cmake
+
+# Adds Google Mock's and Google Test's header directories to the search path.
+include_directories("${gmock_SOURCE_DIR}/include"
+                    "${gmock_SOURCE_DIR}"
+                    "${gtest_SOURCE_DIR}/include"
+                    # This directory is needed to build directly from Google
+                    # Test sources.
+                    "${gtest_SOURCE_DIR}")
+
+# Summary of tuple support for Microsoft Visual Studio:
+# Compiler    version(MS)  version(cmake)  Support
+# ----------  -----------  --------------  -----------------------------
+# <= VS 2010  <= 10        <= 1600         Use Google Tests's own tuple.
+# VS 2012     11           1700            std::tr1::tuple + _VARIADIC_MAX=10
+# VS 2013     12           1800            std::tr1::tuple
+if (MSVC AND MSVC_VERSION EQUAL 1700)
+  add_definitions(/D _VARIADIC_MAX=10)
+endif()
+
+########################################################################
+#
+# Defines the gmock & gmock_main libraries.  User tests should link
+# with one of them.
+
+# Google Mock libraries.  We build them using more strict warnings than what
+# are used for other targets, to ensure that Google Mock can be compiled by
+# a user aggressive about warnings.
+cxx_library(gmock
+            "${cxx_strict}"
+            "${gtest_dir}/src/gtest-all.cc"
+            src/gmock-all.cc)
+
+cxx_library(gmock_main
+            "${cxx_strict}"
+            "${gtest_dir}/src/gtest-all.cc"
+            src/gmock-all.cc
+            src/gmock_main.cc)
+
+# If the CMake version supports it, attach header directory information
+# to the targets for when we are part of a parent build (ie being pulled
+# in via add_subdirectory() rather than being a standalone build).
+if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
+  target_include_directories(gmock      INTERFACE "${gmock_SOURCE_DIR}/include")
+  target_include_directories(gmock_main INTERFACE "${gmock_SOURCE_DIR}/include")
+endif()
+
+########################################################################
+#
+# Install rules
+install(TARGETS gmock gmock_main
+  DESTINATION lib)
+install(DIRECTORY ${gmock_SOURCE_DIR}/include/gmock
+  DESTINATION include)
+
+########################################################################
+#
+# Google Mock's own tests.
+#
+# You can skip this section if you aren't interested in testing
+# Google Mock itself.
+#
+# The tests are not built by default.  To build them, set the
+# gmock_build_tests option to ON.  You can do it by running ccmake
+# or specifying the -Dgmock_build_tests=ON flag when running cmake.
+
+if (gmock_build_tests)
+  # This must be set in the root directory for the tests to be run by
+  # 'make test' or ctest.
+  enable_testing()
+
+  ############################################################
+  # C++ tests built with standard compiler flags.
+
+  cxx_test(gmock-actions_test gmock_main)
+  cxx_test(gmock-cardinalities_test gmock_main)
+  cxx_test(gmock_ex_test gmock_main)
+  cxx_test(gmock-generated-actions_test gmock_main)
+  cxx_test(gmock-generated-function-mockers_test gmock_main)
+  cxx_test(gmock-generated-internal-utils_test gmock_main)
+  cxx_test(gmock-generated-matchers_test gmock_main)
+  cxx_test(gmock-internal-utils_test gmock_main)
+  cxx_test(gmock-matchers_test gmock_main)
+  cxx_test(gmock-more-actions_test gmock_main)
+  cxx_test(gmock-nice-strict_test gmock_main)
+  cxx_test(gmock-port_test gmock_main)
+  cxx_test(gmock-spec-builders_test gmock_main)
+  cxx_test(gmock_link_test gmock_main test/gmock_link2_test.cc)
+  cxx_test(gmock_test gmock_main)
+
+  if (CMAKE_USE_PTHREADS_INIT)
+    cxx_test(gmock_stress_test gmock)
+  endif()
+
+  # gmock_all_test is commented to save time building and running tests.
+  # Uncomment if necessary.
+  # cxx_test(gmock_all_test gmock_main)
+
+  ############################################################
+  # C++ tests built with non-standard compiler flags.
+
+  cxx_library(gmock_main_no_exception "${cxx_no_exception}"
+    "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
+
+  cxx_library(gmock_main_no_rtti "${cxx_no_rtti}"
+    "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
+
+  if (NOT MSVC OR MSVC_VERSION LESS 1600)  # 1600 is Visual Studio 2010.
+    # Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that
+    # conflict with our own definitions. Therefore using our own tuple does not
+    # work on those compilers.
+    cxx_library(gmock_main_use_own_tuple "${cxx_use_own_tuple}"
+      "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
+
+    cxx_test_with_flags(gmock_use_own_tuple_test "${cxx_use_own_tuple}"
+      gmock_main_use_own_tuple test/gmock-spec-builders_test.cc)
+  endif()
+
+  cxx_test_with_flags(gmock-more-actions_no_exception_test "${cxx_no_exception}"
+    gmock_main_no_exception test/gmock-more-actions_test.cc)
+
+  cxx_test_with_flags(gmock_no_rtti_test "${cxx_no_rtti}"
+    gmock_main_no_rtti test/gmock-spec-builders_test.cc)
+
+  cxx_shared_library(shared_gmock_main "${cxx_default}"
+    "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
+
+  # Tests that a binary can be built with Google Mock as a shared library.  On
+  # some system configurations, it may not possible to run the binary without
+  # knowing more details about the system configurations. We do not try to run
+  # this binary. To get a more robust shared library coverage, configure with
+  # -DBUILD_SHARED_LIBS=ON.
+  cxx_executable_with_flags(shared_gmock_test_ "${cxx_default}"
+    shared_gmock_main test/gmock-spec-builders_test.cc)
+  set_target_properties(shared_gmock_test_
+    PROPERTIES
+    COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
+
+  ############################################################
+  # Python tests.
+
+  cxx_executable(gmock_leak_test_ test gmock_main)
+  py_test(gmock_leak_test)
+
+  cxx_executable(gmock_output_test_ test gmock)
+  py_test(gmock_output_test)
+endif()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/CONTRIBUTORS b/week4/softwareEng_9_4/vendor/googletest/googlemock/CONTRIBUTORS
new file mode 100644
index 00000000..6e9ae362
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/CONTRIBUTORS
@@ -0,0 +1,40 @@
+# This file contains a list of people who've made non-trivial
+# contribution to the Google C++ Mocking Framework project.  People
+# who commit code to the project are encouraged to add their names
+# here.  Please keep the list sorted by first names.
+
+Benoit Sigoure <tsuna@google.com>
+Bogdan Piloca <boo@google.com>
+Chandler Carruth <chandlerc@google.com>
+Dave MacLachlan <dmaclach@gmail.com>
+David Anderson <danderson@google.com>
+Dean Sturtevant
+Gene Volovich <gv@cite.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>
+Keir Mierle <mierle@gmail.com>
+Keith Ray <keith.ray@gmail.com>
+Kostya Serebryany <kcc@google.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>
+Mike Bland <mbland@google.com>
+Neal Norwitz <nnorwitz@gmail.com>
+Nermin Ozkiranartli <nermin@google.com>
+Owen Carlsen <ocarlsen@google.com>
+Paneendra Ba <paneendra@google.com>
+Paul Menage <menage@google.com>
+Piotr Kaminski <piotrk@google.com>
+Russ Rufer <russ@pentad.com>
+Sverre Sundsdal <sundsdal@gmail.com>
+Takeshi Yoshino <tyoshino@google.com>
+Vadim Berman <vadimb@google.com>
+Vlad Losev <vladl@google.com>
+Wolfgang Klier <wklier@google.com>
+Zhanyong Wan <wan@google.com>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/LICENSE b/week4/softwareEng_9_4/vendor/googletest/googlemock/LICENSE
new file mode 100644
index 00000000..1941a11f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/LICENSE
@@ -0,0 +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.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/Makefile.am b/week4/softwareEng_9_4/vendor/googletest/googlemock/Makefile.am
new file mode 100644
index 00000000..9adbc516
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/Makefile.am
@@ -0,0 +1,224 @@
+# Automake file
+
+# Nonstandard package files for distribution.
+EXTRA_DIST = LICENSE
+
+# We may need to build our internally packaged gtest. If so, it will be
+# included in the 'subdirs' variable.
+SUBDIRS = $(subdirs)
+
+# This is generated by the configure script, so clean it for distribution.
+DISTCLEANFILES = scripts/gmock-config
+
+# We define the global AM_CPPFLAGS as everything we compile includes from these
+# directories.
+AM_CPPFLAGS = $(GTEST_CPPFLAGS) -I$(srcdir)/include
+
+# Modifies compiler and linker flags for pthreads compatibility.
+if HAVE_PTHREADS
+  AM_CXXFLAGS = @PTHREAD_CFLAGS@ -DGTEST_HAS_PTHREAD=1
+  AM_LIBS = @PTHREAD_LIBS@
+endif
+
+# Build rules for libraries.
+lib_LTLIBRARIES = lib/libgmock.la lib/libgmock_main.la
+
+lib_libgmock_la_SOURCES = src/gmock-all.cc
+
+pkginclude_HEADERS = \
+  include/gmock/gmock-actions.h \
+  include/gmock/gmock-cardinalities.h \
+  include/gmock/gmock-generated-actions.h \
+  include/gmock/gmock-generated-function-mockers.h \
+  include/gmock/gmock-generated-matchers.h \
+  include/gmock/gmock-generated-nice-strict.h \
+  include/gmock/gmock-matchers.h \
+  include/gmock/gmock-more-actions.h \
+  include/gmock/gmock-more-matchers.h \
+  include/gmock/gmock-spec-builders.h \
+  include/gmock/gmock.h
+
+pkginclude_internaldir = $(pkgincludedir)/internal
+pkginclude_internal_HEADERS = \
+  include/gmock/internal/gmock-generated-internal-utils.h \
+  include/gmock/internal/gmock-internal-utils.h \
+  include/gmock/internal/gmock-port.h \
+  include/gmock/internal/custom/gmock-generated-actions.h \
+  include/gmock/internal/custom/gmock-matchers.h \
+  include/gmock/internal/custom/gmock-port.h
+
+lib_libgmock_main_la_SOURCES = src/gmock_main.cc
+lib_libgmock_main_la_LIBADD = lib/libgmock.la
+
+# Build rules for tests. Automake's naming for some of these variables isn't
+# terribly obvious, so this is a brief reference:
+#
+# TESTS -- Programs run automatically by "make check"
+# check_PROGRAMS -- Programs built by "make check" but not necessarily run
+
+TESTS=
+check_PROGRAMS=
+AM_LDFLAGS = $(GTEST_LDFLAGS)
+
+# This exercises all major components of Google Mock.  It also
+# verifies that libgmock works.
+TESTS += test/gmock-spec-builders_test
+check_PROGRAMS += test/gmock-spec-builders_test
+test_gmock_spec_builders_test_SOURCES = test/gmock-spec-builders_test.cc
+test_gmock_spec_builders_test_LDADD = $(GTEST_LIBS) lib/libgmock.la
+
+# This tests using Google Mock in multiple translation units.  It also
+# verifies that libgmock_main and libgmock work.
+TESTS += test/gmock_link_test
+check_PROGRAMS += test/gmock_link_test
+test_gmock_link_test_SOURCES = \
+  test/gmock_link2_test.cc \
+  test/gmock_link_test.cc \
+  test/gmock_link_test.h
+test_gmock_link_test_LDADD = $(GTEST_LIBS) lib/libgmock_main.la  lib/libgmock.la
+
+if HAVE_PYTHON
+  # Tests that fused gmock files compile and work.
+  TESTS += test/gmock_fused_test
+  check_PROGRAMS += test/gmock_fused_test
+  test_gmock_fused_test_SOURCES = \
+    fused-src/gmock-gtest-all.cc \
+    fused-src/gmock/gmock.h \
+    fused-src/gmock_main.cc \
+    fused-src/gtest/gtest.h \
+    test/gmock_test.cc
+  test_gmock_fused_test_CPPFLAGS = -I"$(srcdir)/fused-src"
+endif
+
+# Google Mock source files that we don't compile directly.
+GMOCK_SOURCE_INGLUDES = \
+  src/gmock-cardinalities.cc \
+  src/gmock-internal-utils.cc \
+  src/gmock-matchers.cc \
+  src/gmock-spec-builders.cc \
+  src/gmock.cc
+
+EXTRA_DIST += $(GMOCK_SOURCE_INGLUDES)
+
+# C++ tests that we don't compile using autotools.
+EXTRA_DIST += \
+  test/gmock-actions_test.cc \
+  test/gmock_all_test.cc \
+  test/gmock-cardinalities_test.cc \
+  test/gmock_ex_test.cc \
+  test/gmock-generated-actions_test.cc \
+  test/gmock-generated-function-mockers_test.cc \
+  test/gmock-generated-internal-utils_test.cc \
+  test/gmock-generated-matchers_test.cc \
+  test/gmock-internal-utils_test.cc \
+  test/gmock-matchers_test.cc \
+  test/gmock-more-actions_test.cc \
+  test/gmock-nice-strict_test.cc \
+  test/gmock-port_test.cc \
+  test/gmock_stress_test.cc
+
+# Python tests, which we don't run using autotools.
+EXTRA_DIST += \
+  test/gmock_leak_test.py \
+  test/gmock_leak_test_.cc \
+  test/gmock_output_test.py \
+  test/gmock_output_test_.cc \
+  test/gmock_output_test_golden.txt \
+  test/gmock_test_utils.py
+
+# Nonstandard package files for distribution.
+EXTRA_DIST += \
+  CHANGES \
+  CONTRIBUTORS \
+  make/Makefile
+
+# Pump scripts for generating Google Mock headers.
+# TODO(chandlerc@google.com): automate the generation of *.h from *.h.pump.
+EXTRA_DIST += \
+  include/gmock/gmock-generated-actions.h.pump \
+  include/gmock/gmock-generated-function-mockers.h.pump \
+  include/gmock/gmock-generated-matchers.h.pump \
+  include/gmock/gmock-generated-nice-strict.h.pump \
+  include/gmock/internal/gmock-generated-internal-utils.h.pump \
+  include/gmock/internal/custom/gmock-generated-actions.h.pump
+
+# Script for fusing Google Mock and Google Test source files.
+EXTRA_DIST += scripts/fuse_gmock_files.py
+
+# The Google Mock Generator tool from the cppclean project.
+EXTRA_DIST += \
+  scripts/generator/LICENSE \
+  scripts/generator/README \
+  scripts/generator/README.cppclean \
+  scripts/generator/cpp/__init__.py \
+  scripts/generator/cpp/ast.py \
+  scripts/generator/cpp/gmock_class.py \
+  scripts/generator/cpp/keywords.py \
+  scripts/generator/cpp/tokenize.py \
+  scripts/generator/cpp/utils.py \
+  scripts/generator/gmock_gen.py
+
+# Script for diagnosing compiler errors in programs that use Google
+# Mock.
+EXTRA_DIST += scripts/gmock_doctor.py
+
+# CMake scripts.
+EXTRA_DIST += \
+  CMakeLists.txt
+
+# Microsoft Visual Studio 2005 projects.
+EXTRA_DIST += \
+  msvc/2005/gmock.sln \
+  msvc/2005/gmock.vcproj \
+  msvc/2005/gmock_config.vsprops \
+  msvc/2005/gmock_main.vcproj \
+  msvc/2005/gmock_test.vcproj
+
+# Microsoft Visual Studio 2010 projects.
+EXTRA_DIST += \
+  msvc/2010/gmock.sln \
+  msvc/2010/gmock.vcxproj \
+  msvc/2010/gmock_config.props \
+  msvc/2010/gmock_main.vcxproj \
+  msvc/2010/gmock_test.vcxproj
+
+if HAVE_PYTHON
+# gmock_test.cc does not really depend on files generated by the
+# fused-gmock-internal rule.  However, gmock_test.o does, and it is
+# important to include test/gmock_test.cc as part of this rule in order to
+# prevent compiling gmock_test.o until all dependent files have been
+# generated.
+$(test_gmock_fused_test_SOURCES): fused-gmock-internal
+
+# TODO(vladl@google.com): Find a way to add Google Tests's sources here.
+fused-gmock-internal: $(pkginclude_HEADERS) $(pkginclude_internal_HEADERS) \
+                      $(lib_libgmock_la_SOURCES) $(GMOCK_SOURCE_INGLUDES) \
+                      $(lib_libgmock_main_la_SOURCES) \
+                      scripts/fuse_gmock_files.py
+	mkdir -p "$(srcdir)/fused-src"
+	chmod -R u+w "$(srcdir)/fused-src"
+	rm -f "$(srcdir)/fused-src/gtest/gtest.h"
+	rm -f "$(srcdir)/fused-src/gmock/gmock.h"
+	rm -f "$(srcdir)/fused-src/gmock-gtest-all.cc"
+	"$(srcdir)/scripts/fuse_gmock_files.py" "$(srcdir)/fused-src"
+	cp -f "$(srcdir)/src/gmock_main.cc" "$(srcdir)/fused-src"
+
+maintainer-clean-local:
+	rm -rf "$(srcdir)/fused-src"
+endif
+
+# Death tests may produce core dumps in the build directory. In case
+# this happens, clean them to keep distcleancheck happy.
+CLEANFILES = core
+
+# Disables 'make install' as installing a compiled version of Google
+# Mock can lead to undefined behavior due to violation of the
+# One-Definition Rule.
+
+install-exec-local:
+	echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Mock into your build system."
+	false
+
+install-data-local:
+	echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Mock into your build system."
+	false
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/README.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/README.md
new file mode 100644
index 00000000..332beab3
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/README.md
@@ -0,0 +1,333 @@
+## Google Mock ##
+
+The Google C++ mocking 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/), and
+  * [Hamcrest](http://code.google.com/p/hamcrest/),
+
+and designed with C++'s specifics in mind.
+
+Google mock:
+
+  * lets you create mock classes trivially using simple macros.
+  * supports a rich set of matchers and actions.
+  * handles unordered, partially ordered, or completely ordered expectations.
+  * is extensible by users.
+
+We hope you find it useful!
+
+### Features ###
+
+  * Provides a declarative syntax for defining mocks.
+  * Can easily 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.
+
+Please see the project page above for more information as well as the
+mailing list for questions, discussions, and development.  There is
+also an IRC channel on OFTC (irc.oftc.net) #gtest available.  Please
+join us!
+
+Please note that code under [scripts/generator](scripts/generator/) is
+from [cppclean](http://code.google.com/p/cppclean/) and released under
+the Apache License, which is different from Google Mock's license.
+
+## Getting Started ##
+
+If you are new to the project, we suggest that you read the user
+documentation in the following order:
+
+  * Learn the [basics](../googletest/docs/Primer.md) of
+    Google Test, if you choose to use Google Mock with it (recommended).
+  * Read [Google Mock for Dummies](docs/ForDummies.md).
+  * Read the instructions below on how to build Google Mock.
+
+You can also watch Zhanyong's [talk](http://www.youtube.com/watch?v=sYpCyLI47rM) on Google Mock's usage and implementation.
+
+Once you understand the basics, check out the rest of the docs:
+
+  * [CheatSheet](docs/CheatSheet.md) - all the commonly used stuff
+    at a glance.
+  * [CookBook](docs/CookBook.md) - recipes for getting things done,
+    including advanced techniques.
+
+If you need help, please check the
+[KnownIssues](docs/KnownIssues.md) and
+[FrequentlyAskedQuestions](docs/FrequentlyAskedQuestions.md) before
+posting a question on the
+[discussion group](http://groups.google.com/group/googlemock).
+
+
+### Using Google Mock Without Google Test ###
+
+Google Mock is not a testing framework itself.  Instead, it needs a
+testing framework for writing tests.  Google Mock works seamlessly
+with [Google Test](http://code.google.com/p/googletest/), but
+you can also use it with [any C++ testing framework](googlemock/ForDummies.md#Using_Google_Mock_with_Any_Testing_Framework).
+
+### Requirements for End Users ###
+
+Google Mock is implemented on top of [Google Test](
+http://github.com/google/googletest/), and depends on it.
+You must use the bundled version of Google Test when using Google Mock.
+
+You can also easily configure Google Mock to work with another testing
+framework, although it will still need Google Test.  Please read
+["Using_Google_Mock_with_Any_Testing_Framework"](
+    docs/ForDummies.md#Using_Google_Mock_with_Any_Testing_Framework)
+for instructions.
+
+Google Mock depends on advanced C++ features and thus requires a more
+modern compiler. The following are needed to use Google Mock:
+
+#### Linux Requirements ####
+
+  * GNU-compatible Make or "gmake"
+  * POSIX-standard shell
+  * POSIX(-2) Regular Expressions (regex.h)
+  * C++98-standard-compliant compiler (e.g. GCC 3.4 or newer)
+
+#### Windows Requirements ####
+
+  * Microsoft Visual C++ 8.0 SP1 or newer
+
+#### Mac OS X Requirements ####
+
+  * Mac OS X 10.4 Tiger or newer
+  * Developer Tools Installed
+
+### Requirements for Contributors ###
+
+We welcome patches. If you plan to contribute a patch, you need to
+build Google Mock and its tests, which has further requirements:
+
+  * Automake version 1.9 or newer
+  * Autoconf version 2.59 or newer
+  * Libtool / Libtoolize
+  * Python version 2.3 or newer (for running some of the tests and
+    re-generating certain source files from templates)
+
+### Building Google Mock ###
+
+#### Preparing to Build (Unix only) ####
+
+If you are using a Unix system and plan to use the GNU Autotools build
+system to build Google Mock (described below), you'll need to
+configure it now.
+
+To prepare the Autotools build system:
+
+    cd googlemock
+    autoreconf -fvi
+
+To build Google Mock 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.
+
+This section shows how you can integrate Google Mock into your
+existing build system.
+
+Suppose you put Google Mock in directory `${GMOCK_DIR}` and Google Test
+in `${GTEST_DIR}` (the latter is `${GMOCK_DIR}/gtest` by default).  To
+build Google Mock, create a library build target (or a project as
+called by Visual Studio and Xcode) to compile
+
+    ${GTEST_DIR}/src/gtest-all.cc and ${GMOCK_DIR}/src/gmock-all.cc
+
+with
+
+    ${GTEST_DIR}/include and ${GMOCK_DIR}/include
+
+in the system header search path, and
+
+    ${GTEST_DIR} and ${GMOCK_DIR}
+
+in the normal header search path.  Assuming a Linux-like system and gcc,
+something like the following will do:
+
+    g++ -isystem ${GTEST_DIR}/include -I${GTEST_DIR} \
+        -isystem ${GMOCK_DIR}/include -I${GMOCK_DIR} \
+        -pthread -c ${GTEST_DIR}/src/gtest-all.cc
+    g++ -isystem ${GTEST_DIR}/include -I${GTEST_DIR} \
+        -isystem ${GMOCK_DIR}/include -I${GMOCK_DIR} \
+        -pthread -c ${GMOCK_DIR}/src/gmock-all.cc
+    ar -rv libgmock.a gtest-all.o gmock-all.o
+
+(We need -pthread as Google Test and Google Mock use threads.)
+
+Next, you should compile your test source file with
+${GTEST\_DIR}/include and ${GMOCK\_DIR}/include in the header search
+path, and link it with gmock and any other necessary libraries:
+
+    g++ -isystem ${GTEST_DIR}/include -isystem ${GMOCK_DIR}/include \
+        -pthread path/to/your_test.cc libgmock.a -o your_test
+
+As an example, the make/ directory contains a Makefile that you can
+use to build Google Mock on systems where GNU make is available
+(e.g. Linux, Mac OS X, and Cygwin).  It doesn't try to build Google
+Mock's own tests.  Instead, it just builds the Google Mock library and
+a sample test.  You can use it as a starting point for your own build
+script.
+
+If the default settings are correct for your environment, the
+following commands should succeed:
+
+    cd ${GMOCK_DIR}/make
+    make
+    ./gmock_test
+
+If you see errors, try to tweak the contents of
+[make/Makefile](make/Makefile) to make them go away.
+
+### Windows ###
+
+The msvc/2005 directory contains VC++ 2005 projects and the msvc/2010
+directory contains VC++ 2010 projects for building Google Mock and
+selected tests.
+
+Change to the appropriate directory and run "msbuild gmock.sln" to
+build the library and tests (or open the gmock.sln in the MSVC IDE).
+If you want to create your own project to use with Google Mock, you'll
+have to configure it to use the `gmock_config` propety sheet.  For that:
+
+ * Open the Property Manager window (View | Other Windows | Property Manager)
+ * Right-click on your project and select "Add Existing Property Sheet..."
+ * Navigate to `gmock_config.vsprops` or `gmock_config.props` and select it.
+ * In Project Properties | Configuration Properties | General | Additional
+   Include Directories, type <path to Google Mock>/include.
+
+### Tweaking Google Mock ###
+
+Google Mock 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 Google Mock 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 [${GTEST\_DIR}/include/gtest/internal/gtest-port.h](
+../googletest/include/gtest/internal/gtest-port.h).
+
+### Choosing a TR1 Tuple Library ###
+
+Google Mock uses the C++ Technical Report 1 (TR1) tuple library
+heavily.  Unfortunately TR1 tuple is not yet widely available with all
+compilers.  The good news is that Google Test 1.4.0+ implements a
+subset of TR1 tuple that's enough for Google Mock's need.  Google Mock
+will automatically use that implementation when the compiler doesn't
+provide TR1 tuple.
+
+Usually you don't need to care about which tuple library Google Test
+and Google Mock use.  However, if your project already uses TR1 tuple,
+you need to tell Google Test and Google Mock to use the same TR1 tuple
+library the rest of your project uses, or the two tuple
+implementations will clash.  To do that, add
+
+    -DGTEST_USE_OWN_TR1_TUPLE=0
+
+to the compiler flags while compiling Google Test, Google Mock, and
+your tests.  If you want to force Google Test and Google Mock to use
+their own tuple library, just add
+
+    -DGTEST_USE_OWN_TR1_TUPLE=1
+
+to the compiler flags instead.
+
+If you want to use Boost's TR1 tuple library with Google Mock, please
+refer to the Boost website (http://www.boost.org/) for how to obtain
+it and set it up.
+
+### As a Shared Library (DLL) ###
+
+Google Mock is compact, so most users can build and link it as a static
+library for the simplicity.  Google Mock can be used as a DLL, but the
+same DLL must contain Google Test as well.  See
+[Google Test's README][gtest_readme]
+for instructions on how to set up necessary compiler settings.
+
+### Tweaking Google Mock ###
+
+Most of Google Test's control macros apply to Google Mock as well.
+Please see [Google Test's README][gtest_readme] for how to tweak them.
+
+### Upgrading from an Earlier Version ###
+
+We strive to keep Google Mock releases backward compatible.
+Sometimes, though, we have to make some breaking changes for the
+users' long-term benefits.  This section describes what you'll need to
+do if you are upgrading from an earlier version of Google Mock.
+
+#### Upgrading from 1.1.0 or Earlier ####
+
+You may need to explicitly enable or disable Google Test's own TR1
+tuple library.  See the instructions in section "[Choosing a TR1 Tuple
+Library](../googletest/#choosing-a-tr1-tuple-library)".
+
+#### Upgrading from 1.4.0 or Earlier ####
+
+On platforms where the pthread library is available, Google Test and
+Google Mock use it in order to be thread-safe.  For this to work, you
+may need to tweak your compiler and/or linker flags.  Please see the
+"[Multi-threaded Tests](../googletest#multi-threaded-tests
+)" section in file Google Test's README for what you may need to do.
+
+If you have custom matchers defined using `MatcherInterface` or
+`MakePolymorphicMatcher()`, you'll need to update their definitions to
+use the new matcher API (
+[monomorphic](http://code.google.com/p/googlemock/wiki/CookBook#Writing_New_Monomorphic_Matchers),
+[polymorphic](http://code.google.com/p/googlemock/wiki/CookBook#Writing_New_Polymorphic_Matchers)).
+Matchers defined using `MATCHER()` or `MATCHER_P*()` aren't affected.
+
+### Developing Google Mock ###
+
+This section discusses how to make your own changes to Google Mock.
+
+#### Testing Google Mock Itself ####
+
+To make sure your changes work as intended and don't break existing
+functionality, you'll want to compile and run Google Test's own tests.
+For that you'll need Autotools.  First, make sure you have followed
+the instructions above to configure Google Mock.
+Then, create a build output directory and enter it.  Next,
+
+    ${GMOCK_DIR}/configure  # try --help for more info
+
+Once you have successfully configured Google Mock, the build steps are
+standard for GNU-style OSS packages.
+
+    make        # Standard makefile following GNU conventions
+    make check  # Builds and runs all tests - all should pass.
+
+Note that when building your project against Google Mock, you are building
+against Google Test as well.  There is no need to configure Google Test
+separately.
+
+#### Contributing a Patch ####
+
+We welcome patches.
+Please read the [Developer's Guide](docs/DevGuide.md)
+for how you can contribute. In particular, make sure you have signed
+the Contributor License Agreement, or we won't be able to accept the
+patch.
+
+Happy testing!
+
+[gtest_readme]: ../googletest/README.md "googletest"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/build-aux/.keep b/week4/softwareEng_9_4/vendor/googletest/googlemock/build-aux/.keep
new file mode 100644
index 00000000..e69de29b
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/configure.ac b/week4/softwareEng_9_4/vendor/googletest/googlemock/configure.ac
new file mode 100644
index 00000000..3b740f20
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/configure.ac
@@ -0,0 +1,146 @@
+m4_include(../googletest/m4/acx_pthread.m4)
+
+AC_INIT([Google C++ Mocking Framework],
+        [1.7.0],
+        [googlemock@googlegroups.com],
+        [gmock])
+
+# Provide various options to initialize the Autoconf and configure processes.
+AC_PREREQ([2.59])
+AC_CONFIG_SRCDIR([./LICENSE])
+AC_CONFIG_AUX_DIR([build-aux])
+AC_CONFIG_HEADERS([build-aux/config.h])
+AC_CONFIG_FILES([Makefile])
+AC_CONFIG_FILES([scripts/gmock-config], [chmod +x scripts/gmock-config])
+
+# Initialize Automake with various options. We require at least v1.9, prevent
+# pedantic complaints about package files, and enable various distribution
+# targets.
+AM_INIT_AUTOMAKE([1.9 dist-bzip2 dist-zip foreign subdir-objects])
+
+# Check for programs used in building Google Test.
+AC_PROG_CC
+AC_PROG_CXX
+AC_LANG([C++])
+AC_PROG_LIBTOOL
+
+# TODO(chandlerc@google.com): Currently we aren't running the Python tests
+# against the interpreter detected by AM_PATH_PYTHON, and so we condition
+# HAVE_PYTHON by requiring "python" to be in the PATH, and that interpreter's
+# version to be >= 2.3. This will allow the scripts to use a "/usr/bin/env"
+# hashbang.
+PYTHON=  # We *do not* allow the user to specify a python interpreter
+AC_PATH_PROG([PYTHON],[python],[:])
+AS_IF([test "$PYTHON" != ":"],
+      [AM_PYTHON_CHECK_VERSION([$PYTHON],[2.3],[:],[PYTHON=":"])])
+AM_CONDITIONAL([HAVE_PYTHON],[test "$PYTHON" != ":"])
+
+# TODO(chandlerc@google.com) Check for the necessary system headers.
+
+# Configure pthreads.
+AC_ARG_WITH([pthreads],
+            [AS_HELP_STRING([--with-pthreads],
+               [use pthreads (default is yes)])],
+            [with_pthreads=$withval],
+            [with_pthreads=check])
+
+have_pthreads=no
+AS_IF([test "x$with_pthreads" != "xno"],
+      [ACX_PTHREAD(
+        [],
+        [AS_IF([test "x$with_pthreads" != "xcheck"],
+               [AC_MSG_FAILURE(
+                 [--with-pthreads was specified, but unable to be used])])])
+       have_pthreads="$acx_pthread_ok"])
+AM_CONDITIONAL([HAVE_PTHREADS],[test "x$have_pthreads" == "xyes"])
+AC_SUBST(PTHREAD_CFLAGS)
+AC_SUBST(PTHREAD_LIBS)
+
+# GoogleMock currently has hard dependencies upon GoogleTest above and beyond
+# running its own test suite, so we both provide our own version in
+# a subdirectory and provide some logic to use a custom version or a system
+# installed version.
+AC_ARG_WITH([gtest],
+            [AS_HELP_STRING([--with-gtest],
+                            [Specifies how to find the gtest package. If no
+                            arguments are given, the default behavior, a
+                            system installed gtest will be used if present,
+                            and an internal version built otherwise. If a
+                            path is provided, the gtest built or installed at
+                            that prefix will be used.])],
+            [],
+            [with_gtest=yes])
+AC_ARG_ENABLE([external-gtest],
+              [AS_HELP_STRING([--disable-external-gtest],
+                              [Disables any detection or use of a system
+                              installed or user provided gtest. Any option to
+                              '--with-gtest' is ignored. (Default is enabled.)])
+              ], [], [enable_external_gtest=yes])
+AS_IF([test "x$with_gtest" == "xno"],
+      [AC_MSG_ERROR([dnl
+Support for GoogleTest was explicitly disabled. Currently GoogleMock has a hard
+dependency upon GoogleTest to build, please provide a version, or allow
+GoogleMock to use any installed version and fall back upon its internal
+version.])])
+
+# Setup various GTEST variables. TODO(chandlerc@google.com): When these are
+# used below, they should be used such that any pre-existing values always
+# trump values we set them to, so that they can be used to selectively override
+# details of the detection process.
+AC_ARG_VAR([GTEST_CONFIG],
+           [The exact path of Google Test's 'gtest-config' script.])
+AC_ARG_VAR([GTEST_CPPFLAGS],
+           [C-like preprocessor flags for Google Test.])
+AC_ARG_VAR([GTEST_CXXFLAGS],
+           [C++ compile flags for Google Test.])
+AC_ARG_VAR([GTEST_LDFLAGS],
+           [Linker path and option flags for Google Test.])
+AC_ARG_VAR([GTEST_LIBS],
+           [Library linking flags for Google Test.])
+AC_ARG_VAR([GTEST_VERSION],
+           [The version of Google Test available.])
+HAVE_BUILT_GTEST="no"
+
+GTEST_MIN_VERSION="1.7.0"
+
+AS_IF([test "x${enable_external_gtest}" = "xyes"],
+      [# Begin filling in variables as we are able.
+      AS_IF([test "x${with_gtest}" != "xyes"],
+            [AS_IF([test -x "${with_gtest}/scripts/gtest-config"],
+                   [GTEST_CONFIG="${with_gtest}/scripts/gtest-config"],
+                   [GTEST_CONFIG="${with_gtest}/bin/gtest-config"])
+            AS_IF([test -x "${GTEST_CONFIG}"], [],
+                  [AC_MSG_ERROR([dnl
+Unable to locate either a built or installed Google Test at '${with_gtest}'.])
+                  ])])
+
+      AS_IF([test -x "${GTEST_CONFIG}"], [],
+            [AC_PATH_PROG([GTEST_CONFIG], [gtest-config])])
+      AS_IF([test -x "${GTEST_CONFIG}"],
+            [AC_MSG_CHECKING([for Google Test version >= ${GTEST_MIN_VERSION}])
+            AS_IF([${GTEST_CONFIG} --min-version=${GTEST_MIN_VERSION}],
+                  [AC_MSG_RESULT([yes])
+                  HAVE_BUILT_GTEST="yes"],
+                  [AC_MSG_RESULT([no])])])])
+
+AS_IF([test "x${HAVE_BUILT_GTEST}" = "xyes"],
+      [GTEST_CPPFLAGS=`${GTEST_CONFIG} --cppflags`
+      GTEST_CXXFLAGS=`${GTEST_CONFIG} --cxxflags`
+      GTEST_LDFLAGS=`${GTEST_CONFIG} --ldflags`
+      GTEST_LIBS=`${GTEST_CONFIG} --libs`
+      GTEST_VERSION=`${GTEST_CONFIG} --version`],
+      [AC_CONFIG_SUBDIRS([../googletest])
+      # GTEST_CONFIG needs to be executable both in a Makefile environmont and
+      # in a shell script environment, so resolve an absolute path for it here.
+      GTEST_CONFIG="`pwd -P`/../googletest/scripts/gtest-config"
+      GTEST_CPPFLAGS='-I$(top_srcdir)/../googletest/include'
+      GTEST_CXXFLAGS='-g'
+      GTEST_LDFLAGS=''
+      GTEST_LIBS='$(top_builddir)/../googletest/lib/libgtest.la'
+      GTEST_VERSION="${GTEST_MIN_VERSION}"])
+
+# TODO(chandlerc@google.com) Check the types, structures, and other compiler
+# and architecture characteristics.
+
+# Output the generated files. No further autoconf macros may be used.
+AC_OUTPUT
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CheatSheet.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CheatSheet.md
new file mode 100644
index 00000000..ef4451b8
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CheatSheet.md
@@ -0,0 +1,562 @@
+
+
+# Defining a Mock Class #
+
+## Mocking a Normal Class ##
+
+Given
+```
+class Foo {
+  ...
+  virtual ~Foo();
+  virtual int GetSize() const = 0;
+  virtual string Describe(const char* name) = 0;
+  virtual string Describe(int type) = 0;
+  virtual bool Process(Bar elem, int count) = 0;
+};
+```
+(note that `~Foo()` **must** be virtual) we can define its mock as
+```
+#include "gmock/gmock.h"
+
+class MockFoo : public Foo {
+  MOCK_CONST_METHOD0(GetSize, int());
+  MOCK_METHOD1(Describe, string(const char* name));
+  MOCK_METHOD1(Describe, string(int type));
+  MOCK_METHOD2(Process, bool(Bar elem, int count));
+};
+```
+
+To create a "nice" mock object which ignores all uninteresting calls,
+or a "strict" mock object, which treats them as failures:
+```
+NiceMock<MockFoo> nice_foo;     // The type is a subclass of MockFoo.
+StrictMock<MockFoo> strict_foo; // The type is a subclass of MockFoo.
+```
+
+## Mocking a Class Template ##
+
+To mock
+```
+template <typename Elem>
+class StackInterface {
+ public:
+  ...
+  virtual ~StackInterface();
+  virtual int GetSize() const = 0;
+  virtual void Push(const Elem& x) = 0;
+};
+```
+(note that `~StackInterface()` **must** be virtual) just append `_T` to the `MOCK_*` macros:
+```
+template <typename Elem>
+class MockStack : public StackInterface<Elem> {
+ public:
+  ...
+  MOCK_CONST_METHOD0_T(GetSize, int());
+  MOCK_METHOD1_T(Push, void(const Elem& x));
+};
+```
+
+## Specifying Calling Conventions for Mock Functions ##
+
+If your mock function doesn't use the default calling convention, you
+can specify it by appending `_WITH_CALLTYPE` to any of the macros
+described in the previous two sections and supplying the calling
+convention as the first argument to the macro. For example,
+```
+  MOCK_METHOD_1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int n));
+  MOCK_CONST_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, Bar, int(double x, double y));
+```
+where `STDMETHODCALLTYPE` is defined by `<objbase.h>` on Windows.
+
+# Using Mocks in Tests #
+
+The typical flow is:
+  1. Import the Google Mock names you need to use. All Google Mock names are in the `testing` namespace unless they are macros or otherwise noted.
+  1. Create the mock objects.
+  1. Optionally, set the default actions of the mock objects.
+  1. Set your expectations on the mock objects (How will they be called? What wil they do?).
+  1. Exercise code that uses the mock objects; if necessary, check the result using [Google Test](../../googletest/) assertions.
+  1. When a mock objects is destructed, Google Mock automatically verifies that all expectations on it have been satisfied.
+
+Here is an example:
+```
+using ::testing::Return;                            // #1
+
+TEST(BarTest, DoesThis) {
+  MockFoo foo;                                    // #2
+
+  ON_CALL(foo, GetSize())                         // #3
+      .WillByDefault(Return(1));
+  // ... other default actions ...
+
+  EXPECT_CALL(foo, Describe(5))                   // #4
+      .Times(3)
+      .WillRepeatedly(Return("Category 5"));
+  // ... other expectations ...
+
+  EXPECT_EQ("good", MyProductionFunction(&foo));  // #5
+}                                                 // #6
+```
+
+# Setting Default Actions #
+
+Google Mock has a **built-in default action** for any function that
+returns `void`, `bool`, a numeric value, or a pointer.
+
+To customize the default action for functions with return type `T` globally:
+```
+using ::testing::DefaultValue;
+
+// Sets the default value to be returned. T must be CopyConstructible.
+DefaultValue<T>::Set(value);
+// Sets a factory. Will be invoked on demand. T must be MoveConstructible.
+//   T MakeT();
+DefaultValue<T>::SetFactory(&MakeT);
+// ... use the mocks ...
+// Resets the default value.
+DefaultValue<T>::Clear();
+```
+
+To customize the default action for a particular method, use `ON_CALL()`:
+```
+ON_CALL(mock_object, method(matchers))
+    .With(multi_argument_matcher)  ?
+    .WillByDefault(action);
+```
+
+# Setting Expectations #
+
+`EXPECT_CALL()` sets **expectations** on a mock method (How will it be
+called? What will it do?):
+```
+EXPECT_CALL(mock_object, method(matchers))
+    .With(multi_argument_matcher)  ?
+    .Times(cardinality)            ?
+    .InSequence(sequences)         *
+    .After(expectations)           *
+    .WillOnce(action)              *
+    .WillRepeatedly(action)        ?
+    .RetiresOnSaturation();        ?
+```
+
+If `Times()` is omitted, the cardinality is assumed to be:
+
+  * `Times(1)` when there is neither `WillOnce()` nor `WillRepeatedly()`;
+  * `Times(n)` when there are `n WillOnce()`s but no `WillRepeatedly()`, where `n` >= 1; or
+  * `Times(AtLeast(n))` when there are `n WillOnce()`s and a `WillRepeatedly()`, where `n` >= 0.
+
+A method with no `EXPECT_CALL()` is free to be invoked _any number of times_, and the default action will be taken each time.
+
+# Matchers #
+
+A **matcher** matches a _single_ argument.  You can use it inside
+`ON_CALL()` or `EXPECT_CALL()`, or use it to validate a value
+directly:
+
+| `EXPECT_THAT(value, matcher)` | Asserts that `value` matches `matcher`. |
+|:------------------------------|:----------------------------------------|
+| `ASSERT_THAT(value, matcher)` | The same as `EXPECT_THAT(value, matcher)`, except that it generates a **fatal** failure. |
+
+Built-in matchers (where `argument` is the function argument) are
+divided into several categories:
+
+## Wildcard ##
+|`_`|`argument` can be any value of the correct type.|
+|:--|:-----------------------------------------------|
+|`A<type>()` or `An<type>()`|`argument` can be any value of type `type`.     |
+
+## Generic Comparison ##
+
+|`Eq(value)` or `value`|`argument == value`|
+|:---------------------|:------------------|
+|`Ge(value)`           |`argument >= value`|
+|`Gt(value)`           |`argument > value` |
+|`Le(value)`           |`argument <= value`|
+|`Lt(value)`           |`argument < value` |
+|`Ne(value)`           |`argument != value`|
+|`IsNull()`            |`argument` is a `NULL` pointer (raw or smart).|
+|`NotNull()`           |`argument` is a non-null pointer (raw or smart).|
+|`Ref(variable)`       |`argument` is a reference to `variable`.|
+|`TypedEq<type>(value)`|`argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded.|
+
+Except `Ref()`, these matchers make a _copy_ of `value` in case it's
+modified or destructed later. If the compiler complains that `value`
+doesn't have a public copy constructor, try wrap it in `ByRef()`,
+e.g. `Eq(ByRef(non_copyable_value))`. If you do that, make sure
+`non_copyable_value` is not changed afterwards, or the meaning of your
+matcher will be changed.
+
+## Floating-Point Matchers ##
+
+|`DoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as unequal.|
+|:-------------------|:----------------------------------------------------------------------------------------------|
+|`FloatEq(a_float)`  |`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal.  |
+|`NanSensitiveDoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal.  |
+|`NanSensitiveFloatEq(a_float)`|`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal.    |
+
+The above matchers use ULP-based comparison (the same as used in
+[Google Test](../../googletest/)). They
+automatically pick a reasonable error bound based on the absolute
+value of the expected value.  `DoubleEq()` and `FloatEq()` conform to
+the IEEE standard, which requires comparing two NaNs for equality to
+return false. The `NanSensitive*` version instead treats two NaNs as
+equal, which is often what a user wants.
+
+|`DoubleNear(a_double, max_abs_error)`|`argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as unequal.|
+|:------------------------------------|:--------------------------------------------------------------------------------------------------------------------|
+|`FloatNear(a_float, max_abs_error)`  |`argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as unequal.  |
+|`NanSensitiveDoubleNear(a_double, max_abs_error)`|`argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as equal.  |
+|`NanSensitiveFloatNear(a_float, max_abs_error)`|`argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as equal.    |
+
+## String Matchers ##
+
+The `argument` can be either a C string or a C++ string object:
+
+|`ContainsRegex(string)`|`argument` matches the given regular expression.|
+|:----------------------|:-----------------------------------------------|
+|`EndsWith(suffix)`     |`argument` ends with string `suffix`.           |
+|`HasSubstr(string)`    |`argument` contains `string` as a sub-string.   |
+|`MatchesRegex(string)` |`argument` matches the given regular expression with the match starting at the first character and ending at the last character.|
+|`StartsWith(prefix)`   |`argument` starts with string `prefix`.         |
+|`StrCaseEq(string)`    |`argument` is equal to `string`, ignoring case. |
+|`StrCaseNe(string)`    |`argument` is not equal to `string`, ignoring case.|
+|`StrEq(string)`        |`argument` is equal to `string`.                |
+|`StrNe(string)`        |`argument` is not equal to `string`.            |
+
+`ContainsRegex()` and `MatchesRegex()` use the regular expression
+syntax defined
+[here](../../googletest/docs/AdvancedGuide.md#regular-expression-syntax).
+`StrCaseEq()`, `StrCaseNe()`, `StrEq()`, and `StrNe()` work for wide
+strings as well.
+
+## Container Matchers ##
+
+Most STL-style containers support `==`, so you can use
+`Eq(expected_container)` or simply `expected_container` to match a
+container exactly.   If you want to write the elements in-line,
+match them more flexibly, or get more informative messages, you can use:
+
+| `ContainerEq(container)` | The same as `Eq(container)` except that the failure message also includes which elements are in one container but not the other. |
+|:-------------------------|:---------------------------------------------------------------------------------------------------------------------------------|
+| `Contains(e)`            | `argument` contains an element that matches `e`, which can be either a value or a matcher.                                       |
+| `Each(e)`                | `argument` is a container where _every_ element matches `e`, which can be either a value or a matcher.                           |
+| `ElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, where the i-th element matches `ei`, which can be a value or a matcher. 0 to 10 arguments are allowed. |
+| `ElementsAreArray({ e0, e1, ..., en })`, `ElementsAreArray(array)`, or `ElementsAreArray(array, count)` | The same as `ElementsAre()` except that the expected element values/matchers come from an initializer list, STL-style container, or C-style array. |
+| `IsEmpty()`              | `argument` is an empty container (`container.empty()`).                                                                          |
+| `Pointwise(m, container)` | `argument` contains the same number of elements as in `container`, and for all i, (the i-th element in `argument`, the i-th element in `container`) match `m`, which is a matcher on 2-tuples. E.g. `Pointwise(Le(), upper_bounds)` verifies that each element in `argument` doesn't exceed the corresponding element in `upper_bounds`. See more detail below. |
+| `SizeIs(m)`              | `argument` is a container whose size matches `m`. E.g. `SizeIs(2)` or `SizeIs(Lt(2))`.                                           |
+| `UnorderedElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, and under some permutation each element matches an `ei` (for a different `i`), which can be a value or a matcher. 0 to 10 arguments are allowed. |
+| `UnorderedElementsAreArray({ e0, e1, ..., en })`, `UnorderedElementsAreArray(array)`, or `UnorderedElementsAreArray(array, count)` | The same as `UnorderedElementsAre()` except that the expected element values/matchers come from an initializer list, STL-style container, or C-style array. |
+| `WhenSorted(m)`          | When `argument` is sorted using the `<` operator, it matches container matcher `m`. E.g. `WhenSorted(UnorderedElementsAre(1, 2, 3))` verifies that `argument` contains elements `1`, `2`, and `3`, ignoring order. |
+| `WhenSortedBy(comparator, m)` | The same as `WhenSorted(m)`, except that the given comparator instead of `<` is used to sort `argument`. E.g. `WhenSortedBy(std::greater<int>(), ElementsAre(3, 2, 1))`. |
+
+Notes:
+
+  * These matchers can also match:
+    1. a native array passed by reference (e.g. in `Foo(const int (&a)[5])`), and
+    1. an array passed as a pointer and a count (e.g. in `Bar(const T* buffer, int len)` -- see [Multi-argument Matchers](#Multiargument_Matchers.md)).
+  * The array being matched may be multi-dimensional (i.e. its elements can be arrays).
+  * `m` in `Pointwise(m, ...)` should be a matcher for `::testing::tuple<T, U>` where `T` and `U` are the element type of the actual container and the expected container, respectively. For example, to compare two `Foo` containers where `Foo` doesn't support `operator==` but has an `Equals()` method, one might write:
+
+```
+using ::testing::get;
+MATCHER(FooEq, "") {
+  return get<0>(arg).Equals(get<1>(arg));
+}
+...
+EXPECT_THAT(actual_foos, Pointwise(FooEq(), expected_foos));
+```
+
+## Member Matchers ##
+
+|`Field(&class::field, m)`|`argument.field` (or `argument->field` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
+|:------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------|
+|`Key(e)`                 |`argument.first` matches `e`, which can be either a value or a matcher. E.g. `Contains(Key(Le(5)))` can verify that a `map` contains a key `<= 5`.|
+|`Pair(m1, m2)`           |`argument` is an `std::pair` whose `first` field matches `m1` and `second` field matches `m2`.                                                |
+|`Property(&class::property, m)`|`argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
+
+## Matching the Result of a Function or Functor ##
+
+|`ResultOf(f, m)`|`f(argument)` matches matcher `m`, where `f` is a function or functor.|
+|:---------------|:---------------------------------------------------------------------|
+
+## Pointer Matchers ##
+
+|`Pointee(m)`|`argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`.|
+|:-----------|:-----------------------------------------------------------------------------------------------|
+|`WhenDynamicCastTo<T>(m)`| when `argument` is passed through `dynamic_cast<T>()`, it matches matcher `m`.                 |
+
+## Multiargument Matchers ##
+
+Technically, all matchers match a _single_ value. A "multi-argument"
+matcher is just one that matches a _tuple_. The following matchers can
+be used to match a tuple `(x, y)`:
+
+|`Eq()`|`x == y`|
+|:-----|:-------|
+|`Ge()`|`x >= y`|
+|`Gt()`|`x > y` |
+|`Le()`|`x <= y`|
+|`Lt()`|`x < y` |
+|`Ne()`|`x != y`|
+
+You can use the following selectors to pick a subset of the arguments
+(or reorder them) to participate in the matching:
+
+|`AllArgs(m)`|Equivalent to `m`. Useful as syntactic sugar in `.With(AllArgs(m))`.|
+|:-----------|:-------------------------------------------------------------------|
+|`Args<N1, N2, ..., Nk>(m)`|The tuple of the `k` selected (using 0-based indices) arguments matches `m`, e.g. `Args<1, 2>(Eq())`.|
+
+## Composite Matchers ##
+
+You can make a matcher from one or more other matchers:
+
+|`AllOf(m1, m2, ..., mn)`|`argument` matches all of the matchers `m1` to `mn`.|
+|:-----------------------|:---------------------------------------------------|
+|`AnyOf(m1, m2, ..., mn)`|`argument` matches at least one of the matchers `m1` to `mn`.|
+|`Not(m)`                |`argument` doesn't match matcher `m`.               |
+
+## Adapters for Matchers ##
+
+|`MatcherCast<T>(m)`|casts matcher `m` to type `Matcher<T>`.|
+|:------------------|:--------------------------------------|
+|`SafeMatcherCast<T>(m)`| [safely casts](CookBook.md#casting-matchers) matcher `m` to type `Matcher<T>`. |
+|`Truly(predicate)` |`predicate(argument)` returns something considered by C++ to be true, where `predicate` is a function or functor.|
+
+## Matchers as Predicates ##
+
+|`Matches(m)(value)`|evaluates to `true` if `value` matches `m`. You can use `Matches(m)` alone as a unary functor.|
+|:------------------|:---------------------------------------------------------------------------------------------|
+|`ExplainMatchResult(m, value, result_listener)`|evaluates to `true` if `value` matches `m`, explaining the result to `result_listener`.       |
+|`Value(value, m)`  |evaluates to `true` if `value` matches `m`.                                                   |
+
+## Defining Matchers ##
+
+| `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. |
+|:-------------------------------------------------|:------------------------------------------------------|
+| `MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; }` | Defines a macher `IsDivisibleBy(n)` to match a number divisible by `n`. |
+| `MATCHER_P2(IsBetween, a, b, std::string(negation ? "isn't" : "is") + " between " + PrintToString(a) + " and " + PrintToString(b)) { return a <= arg && arg <= b; }` | Defines a matcher `IsBetween(a, b)` to match a value in the range [`a`, `b`]. |
+
+**Notes:**
+
+  1. The `MATCHER*` macros cannot be used inside a function or class.
+  1. The matcher body must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters).
+  1. You can use `PrintToString(x)` to convert a value `x` of any type to a string.
+
+## Matchers as Test Assertions ##
+
+|`ASSERT_THAT(expression, m)`|Generates a [fatal failure](../../googletest/docs/Primer.md#assertions) if the value of `expression` doesn't match matcher `m`.|
+|:---------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------|
+|`EXPECT_THAT(expression, m)`|Generates a non-fatal failure if the value of `expression` doesn't match matcher `m`.                                                          |
+
+# Actions #
+
+**Actions** specify what a mock function should do when invoked.
+
+## Returning a Value ##
+
+|`Return()`|Return from a `void` mock function.|
+|:---------|:----------------------------------|
+|`Return(value)`|Return `value`. If the type of `value` is different to the mock function's return type, `value` is converted to the latter type <i>at the time the expectation is set</i>, not when the action is executed.|
+|`ReturnArg<N>()`|Return the `N`-th (0-based) argument.|
+|`ReturnNew<T>(a1, ..., ak)`|Return `new T(a1, ..., ak)`; a different object is created each time.|
+|`ReturnNull()`|Return a null pointer.             |
+|`ReturnPointee(ptr)`|Return the value pointed to by `ptr`.|
+|`ReturnRef(variable)`|Return a reference to `variable`.  |
+|`ReturnRefOfCopy(value)`|Return a reference to a copy of `value`; the copy lives as long as the action.|
+
+## Side Effects ##
+
+|`Assign(&variable, value)`|Assign `value` to variable.|
+|:-------------------------|:--------------------------|
+| `DeleteArg<N>()`         | Delete the `N`-th (0-based) argument, which must be a pointer. |
+| `SaveArg<N>(pointer)`    | Save the `N`-th (0-based) argument to `*pointer`. |
+| `SaveArgPointee<N>(pointer)` | Save the value pointed to by the `N`-th (0-based) argument to `*pointer`. |
+| `SetArgReferee<N>(value)` |	Assign value to the variable referenced by the `N`-th (0-based) argument. |
+|`SetArgPointee<N>(value)` |Assign `value` to the variable pointed by the `N`-th (0-based) argument.|
+|`SetArgumentPointee<N>(value)`|Same as `SetArgPointee<N>(value)`. Deprecated. Will be removed in v1.7.0.|
+|`SetArrayArgument<N>(first, last)`|Copies the elements in source range [`first`, `last`) to the array pointed to by the `N`-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.|
+|`SetErrnoAndReturn(error, value)`|Set `errno` to `error` and return `value`.|
+|`Throw(exception)`        |Throws the given exception, which can be any copyable value. Available since v1.1.0.|
+
+## Using a Function or a Functor as an Action ##
+
+|`Invoke(f)`|Invoke `f` with the arguments passed to the mock function, where `f` can be a global/static function or a functor.|
+|:----------|:-----------------------------------------------------------------------------------------------------------------|
+|`Invoke(object_pointer, &class::method)`|Invoke the {method on the object with the arguments passed to the mock function.                                  |
+|`InvokeWithoutArgs(f)`|Invoke `f`, which can be a global/static function or a functor. `f` must take no arguments.                       |
+|`InvokeWithoutArgs(object_pointer, &class::method)`|Invoke the method on the object, which takes no arguments.                                                        |
+|`InvokeArgument<N>(arg1, arg2, ..., argk)`|Invoke the mock function's `N`-th (0-based) argument, which must be a function or a functor, with the `k` arguments.|
+
+The return value of the invoked function is used as the return value
+of the action.
+
+When defining a function or functor to be used with `Invoke*()`, you can declare any unused parameters as `Unused`:
+```
+  double Distance(Unused, double x, double y) { return sqrt(x*x + y*y); }
+  ...
+  EXPECT_CALL(mock, Foo("Hi", _, _)).WillOnce(Invoke(Distance));
+```
+
+In `InvokeArgument<N>(...)`, if an argument needs to be passed by reference, wrap it inside `ByRef()`. For example,
+```
+  InvokeArgument<2>(5, string("Hi"), ByRef(foo))
+```
+calls the mock function's #2 argument, passing to it `5` and `string("Hi")` by value, and `foo` by reference.
+
+## Default Action ##
+
+|`DoDefault()`|Do the default action (specified by `ON_CALL()` or the built-in one).|
+|:------------|:--------------------------------------------------------------------|
+
+**Note:** due to technical reasons, `DoDefault()` cannot be used inside  a composite action - trying to do so will result in a run-time error.
+
+## Composite Actions ##
+
+|`DoAll(a1, a2, ..., an)`|Do all actions `a1` to `an` and return the result of `an` in each invocation. The first `n - 1` sub-actions must return void. |
+|:-----------------------|:-----------------------------------------------------------------------------------------------------------------------------|
+|`IgnoreResult(a)`       |Perform action `a` and ignore its result. `a` must not return void.                                                           |
+|`WithArg<N>(a)`         |Pass the `N`-th (0-based) argument of the mock function to action `a` and perform it.                                         |
+|`WithArgs<N1, N2, ..., Nk>(a)`|Pass the selected (0-based) arguments of the mock function to action `a` and perform it.                                      |
+|`WithoutArgs(a)`        |Perform action `a` without any arguments.                                                                                     |
+
+## Defining Actions ##
+
+| `ACTION(Sum) { return arg0 + arg1; }` | Defines an action `Sum()` to return the sum of the mock function's argument #0 and #1. |
+|:--------------------------------------|:---------------------------------------------------------------------------------------|
+| `ACTION_P(Plus, n) { return arg0 + n; }` | Defines an action `Plus(n)` to return the sum of the mock function's argument #0 and `n`. |
+| `ACTION_Pk(Foo, p1, ..., pk) { statements; }` | Defines a parameterized action `Foo(p1, ..., pk)` to execute the given `statements`.   |
+
+The `ACTION*` macros cannot be used inside a function or class.
+
+# Cardinalities #
+
+These are used in `Times()` to specify how many times a mock function will be called:
+
+|`AnyNumber()`|The function can be called any number of times.|
+|:------------|:----------------------------------------------|
+|`AtLeast(n)` |The call is expected at least `n` times.       |
+|`AtMost(n)`  |The call is expected at most `n` times.        |
+|`Between(m, n)`|The call is expected between `m` and `n` (inclusive) times.|
+|`Exactly(n) or n`|The call is expected exactly `n` times. In particular, the call should never happen when `n` is 0.|
+
+# Expectation Order #
+
+By default, the expectations can be matched in _any_ order.  If some
+or all expectations must be matched in a given order, there are two
+ways to specify it.  They can be used either independently or
+together.
+
+## The After Clause ##
+
+```
+using ::testing::Expectation;
+...
+Expectation init_x = EXPECT_CALL(foo, InitX());
+Expectation init_y = EXPECT_CALL(foo, InitY());
+EXPECT_CALL(foo, Bar())
+    .After(init_x, init_y);
+```
+says that `Bar()` can be called only after both `InitX()` and
+`InitY()` have been called.
+
+If you don't know how many pre-requisites an expectation has when you
+write it, you can use an `ExpectationSet` to collect them:
+
+```
+using ::testing::ExpectationSet;
+...
+ExpectationSet all_inits;
+for (int i = 0; i < element_count; i++) {
+  all_inits += EXPECT_CALL(foo, InitElement(i));
+}
+EXPECT_CALL(foo, Bar())
+    .After(all_inits);
+```
+says that `Bar()` can be called only after all elements have been
+initialized (but we don't care about which elements get initialized
+before the others).
+
+Modifying an `ExpectationSet` after using it in an `.After()` doesn't
+affect the meaning of the `.After()`.
+
+## Sequences ##
+
+When you have a long chain of sequential expectations, it's easier to
+specify the order using **sequences**, which don't require you to given
+each expectation in the chain a different name.  <i>All expected<br>
+calls</i> in the same sequence must occur in the order they are
+specified.
+
+```
+using ::testing::Sequence;
+Sequence s1, s2;
+...
+EXPECT_CALL(foo, Reset())
+    .InSequence(s1, s2)
+    .WillOnce(Return(true));
+EXPECT_CALL(foo, GetSize())
+    .InSequence(s1)
+    .WillOnce(Return(1));
+EXPECT_CALL(foo, Describe(A<const char*>()))
+    .InSequence(s2)
+    .WillOnce(Return("dummy"));
+```
+says that `Reset()` must be called before _both_ `GetSize()` _and_
+`Describe()`, and the latter two can occur in any order.
+
+To put many expectations in a sequence conveniently:
+```
+using ::testing::InSequence;
+{
+  InSequence dummy;
+
+  EXPECT_CALL(...)...;
+  EXPECT_CALL(...)...;
+  ...
+  EXPECT_CALL(...)...;
+}
+```
+says that all expected calls in the scope of `dummy` must occur in
+strict order. The name `dummy` is irrelevant.)
+
+# Verifying and Resetting a Mock #
+
+Google Mock will verify the expectations on a mock object when it is destructed, or you can do it earlier:
+```
+using ::testing::Mock;
+...
+// Verifies and removes the expectations on mock_obj;
+// returns true iff successful.
+Mock::VerifyAndClearExpectations(&mock_obj);
+...
+// Verifies and removes the expectations on mock_obj;
+// also removes the default actions set by ON_CALL();
+// returns true iff successful.
+Mock::VerifyAndClear(&mock_obj);
+```
+
+You can also tell Google Mock that a mock object can be leaked and doesn't
+need to be verified:
+```
+Mock::AllowLeak(&mock_obj);
+```
+
+# Mock Classes #
+
+Google Mock defines a convenient mock class template
+```
+class MockFunction<R(A1, ..., An)> {
+ public:
+  MOCK_METHODn(Call, R(A1, ..., An));
+};
+```
+See this [recipe](CookBook.md#using-check-points) for one application of it.
+
+# Flags #
+
+| `--gmock_catch_leaked_mocks=0` | Don't report leaked mock objects as failures. |
+|:-------------------------------|:----------------------------------------------|
+| `--gmock_verbose=LEVEL`        | Sets the default verbosity level (`info`, `warning`, or `error`) of Google Mock messages. |
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CookBook.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CookBook.md
new file mode 100644
index 00000000..0460d357
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CookBook.md
@@ -0,0 +1,3675 @@
+
+
+You can find recipes for using Google Mock here. If you haven't yet,
+please read the [ForDummies](ForDummies.md) document first to make sure you understand
+the basics.
+
+**Note:** Google Mock lives in the `testing` name space. For
+readability, it is recommended to write `using ::testing::Foo;` once in
+your file before using the name `Foo` defined by Google Mock. We omit
+such `using` statements in this page for brevity, but you should do it
+in your own code.
+
+# Creating Mock Classes #
+
+## Mocking Private or Protected Methods ##
+
+You must always put a mock method definition (`MOCK_METHOD*`) in a
+`public:` section of the mock class, regardless of the method being
+mocked being `public`, `protected`, or `private` in the base class.
+This allows `ON_CALL` and `EXPECT_CALL` to reference the mock function
+from outside of the mock class.  (Yes, C++ allows a subclass to change
+the access level of a virtual function in the base class.)  Example:
+
+```
+class Foo {
+ public:
+  ...
+  virtual bool Transform(Gadget* g) = 0;
+
+ protected:
+  virtual void Resume();
+
+ private:
+  virtual int GetTimeOut();
+};
+
+class MockFoo : public Foo {
+ public:
+  ...
+  MOCK_METHOD1(Transform, bool(Gadget* g));
+
+  // The following must be in the public section, even though the
+  // methods are protected or private in the base class.
+  MOCK_METHOD0(Resume, void());
+  MOCK_METHOD0(GetTimeOut, int());
+};
+```
+
+## Mocking Overloaded Methods ##
+
+You can mock overloaded functions as usual. No special attention is required:
+
+```
+class Foo {
+  ...
+
+  // Must be virtual as we'll inherit from Foo.
+  virtual ~Foo();
+
+  // Overloaded on the types and/or numbers of arguments.
+  virtual int Add(Element x);
+  virtual int Add(int times, Element x);
+
+  // Overloaded on the const-ness of this object.
+  virtual Bar& GetBar();
+  virtual const Bar& GetBar() const;
+};
+
+class MockFoo : public Foo {
+  ...
+  MOCK_METHOD1(Add, int(Element x));
+  MOCK_METHOD2(Add, int(int times, Element x);
+
+  MOCK_METHOD0(GetBar, Bar&());
+  MOCK_CONST_METHOD0(GetBar, const Bar&());
+};
+```
+
+**Note:** if you don't mock all versions of the overloaded method, the
+compiler will give you a warning about some methods in the base class
+being hidden. To fix that, use `using` to bring them in scope:
+
+```
+class MockFoo : public Foo {
+  ...
+  using Foo::Add;
+  MOCK_METHOD1(Add, int(Element x));
+  // We don't want to mock int Add(int times, Element x);
+  ...
+};
+```
+
+## Mocking Class Templates ##
+
+To mock a class template, append `_T` to the `MOCK_*` macros:
+
+```
+template <typename Elem>
+class StackInterface {
+  ...
+  // Must be virtual as we'll inherit from StackInterface.
+  virtual ~StackInterface();
+
+  virtual int GetSize() const = 0;
+  virtual void Push(const Elem& x) = 0;
+};
+
+template <typename Elem>
+class MockStack : public StackInterface<Elem> {
+  ...
+  MOCK_CONST_METHOD0_T(GetSize, int());
+  MOCK_METHOD1_T(Push, void(const Elem& x));
+};
+```
+
+## Mocking Nonvirtual Methods ##
+
+Google Mock can mock non-virtual functions to be used in what we call _hi-perf
+dependency injection_.
+
+In this case, instead of sharing a common base class with the real
+class, your mock class will be _unrelated_ to the real class, but
+contain methods with the same signatures.  The syntax for mocking
+non-virtual methods is the _same_ as mocking virtual methods:
+
+```
+// A simple packet stream class.  None of its members is virtual.
+class ConcretePacketStream {
+ public:
+  void AppendPacket(Packet* new_packet);
+  const Packet* GetPacket(size_t packet_number) const;
+  size_t NumberOfPackets() const;
+  ...
+};
+
+// A mock packet stream class.  It inherits from no other, but defines
+// GetPacket() and NumberOfPackets().
+class MockPacketStream {
+ public:
+  MOCK_CONST_METHOD1(GetPacket, const Packet*(size_t packet_number));
+  MOCK_CONST_METHOD0(NumberOfPackets, size_t());
+  ...
+};
+```
+
+Note that the mock class doesn't define `AppendPacket()`, unlike the
+real class. That's fine as long as the test doesn't need to call it.
+
+Next, you need a way to say that you want to use
+`ConcretePacketStream` in production code, and use `MockPacketStream`
+in tests.  Since the functions are not virtual and the two classes are
+unrelated, you must specify your choice at _compile time_ (as opposed
+to run time).
+
+One way to do it is to templatize your code that needs to use a packet
+stream.  More specifically, you will give your code a template type
+argument for the type of the packet stream.  In production, you will
+instantiate your template with `ConcretePacketStream` as the type
+argument.  In tests, you will instantiate the same template with
+`MockPacketStream`.  For example, you may write:
+
+```
+template <class PacketStream>
+void CreateConnection(PacketStream* stream) { ... }
+
+template <class PacketStream>
+class PacketReader {
+ public:
+  void ReadPackets(PacketStream* stream, size_t packet_num);
+};
+```
+
+Then you can use `CreateConnection<ConcretePacketStream>()` and
+`PacketReader<ConcretePacketStream>` in production code, and use
+`CreateConnection<MockPacketStream>()` and
+`PacketReader<MockPacketStream>` in tests.
+
+```
+  MockPacketStream mock_stream;
+  EXPECT_CALL(mock_stream, ...)...;
+  .. set more expectations on mock_stream ...
+  PacketReader<MockPacketStream> reader(&mock_stream);
+  ... exercise reader ...
+```
+
+## Mocking Free Functions ##
+
+It's possible to use Google Mock to mock a free function (i.e. a
+C-style function or a static method).  You just need to rewrite your
+code to use an interface (abstract class).
+
+Instead of calling a free function (say, `OpenFile`) directly,
+introduce an interface for it and have a concrete subclass that calls
+the free function:
+
+```
+class FileInterface {
+ public:
+  ...
+  virtual bool Open(const char* path, const char* mode) = 0;
+};
+
+class File : public FileInterface {
+ public:
+  ...
+  virtual bool Open(const char* path, const char* mode) {
+    return OpenFile(path, mode);
+  }
+};
+```
+
+Your code should talk to `FileInterface` to open a file.  Now it's
+easy to mock out the function.
+
+This may seem much hassle, but in practice you often have multiple
+related functions that you can put in the same interface, so the
+per-function syntactic overhead will be much lower.
+
+If you are concerned about the performance overhead incurred by
+virtual functions, and profiling confirms your concern, you can
+combine this with the recipe for [mocking non-virtual methods](#mocking-nonvirtual-methods).
+
+## The Nice, the Strict, and the Naggy ##
+
+If a mock method has no `EXPECT_CALL` spec but is called, Google Mock
+will print a warning about the "uninteresting call". The rationale is:
+
+  * New methods may be added to an interface after a test is written. We shouldn't fail a test just because a method it doesn't know about is called.
+  * However, this may also mean there's a bug in the test, so Google Mock shouldn't be silent either. If the user believes these calls are harmless, he can add an `EXPECT_CALL()` to suppress the warning.
+
+However, sometimes you may want to suppress all "uninteresting call"
+warnings, while sometimes you may want the opposite, i.e. to treat all
+of them as errors. Google Mock lets you make the decision on a
+per-mock-object basis.
+
+Suppose your test uses a mock class `MockFoo`:
+
+```
+TEST(...) {
+  MockFoo mock_foo;
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+}
+```
+
+If a method of `mock_foo` other than `DoThis()` is called, it will be
+reported by Google Mock as a warning. However, if you rewrite your
+test to use `NiceMock<MockFoo>` instead, the warning will be gone,
+resulting in a cleaner test output:
+
+```
+using ::testing::NiceMock;
+
+TEST(...) {
+  NiceMock<MockFoo> mock_foo;
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+}
+```
+
+`NiceMock<MockFoo>` is a subclass of `MockFoo`, so it can be used
+wherever `MockFoo` is accepted.
+
+It also works if `MockFoo`'s constructor takes some arguments, as
+`NiceMock<MockFoo>` "inherits" `MockFoo`'s constructors:
+
+```
+using ::testing::NiceMock;
+
+TEST(...) {
+  NiceMock<MockFoo> mock_foo(5, "hi");  // Calls MockFoo(5, "hi").
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+}
+```
+
+The usage of `StrictMock` is similar, except that it makes all
+uninteresting calls failures:
+
+```
+using ::testing::StrictMock;
+
+TEST(...) {
+  StrictMock<MockFoo> mock_foo;
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+
+  // The test will fail if a method of mock_foo other than DoThis()
+  // is called.
+}
+```
+
+There are some caveats though (I don't like them just as much as the
+next guy, but sadly they are side effects of C++'s limitations):
+
+  1. `NiceMock<MockFoo>` and `StrictMock<MockFoo>` only work 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` and `StrictMock` (e.g. `NiceMock<StrictMock<MockFoo> >`) is **not** supported.
+  1. The constructors of the base mock (`MockFoo`) cannot have arguments passed by non-const reference, which happens to be banned by the [Google C++ style guide](http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml).
+  1. During the constructor or destructor of `MockFoo`, the mock object is _not_ nice or strict.  This may cause surprises if the constructor or destructor calls a mock method on `this` object. (This behavior, however, is consistent with C++'s general rule: if a constructor or destructor calls a virtual method of `this` object, that method is treated as non-virtual.  In other words, to the base class's constructor or destructor, `this` object behaves like an instance of the base class, not the derived class.  This rule is required for safety.  Otherwise a base constructor may use members of a derived class before they are initialized, or a base destructor may use members of a derived class after they have been destroyed.)
+
+Finally, you should be **very cautious** about when to use naggy or strict mocks, as they tend to make tests more brittle and harder to maintain. When you refactor your code without changing its externally visible behavior, ideally you should't need to update any tests. If your code interacts with a naggy mock, however, you may start to get spammed with warnings as the result of your change. Worse, if your code interacts with a strict mock, your tests may start to fail and you'll be forced to fix them. Our general recommendation is to use nice mocks (not yet the default) most of the time, use naggy mocks (the current default) when developing or debugging tests, and use strict mocks only as the last resort.
+
+## Simplifying the Interface without Breaking Existing Code ##
+
+Sometimes a method has a long list of arguments that is mostly
+uninteresting. For example,
+
+```
+class LogSink {
+ public:
+  ...
+  virtual void send(LogSeverity severity, const char* full_filename,
+                    const char* base_filename, int line,
+                    const struct tm* tm_time,
+                    const char* message, size_t message_len) = 0;
+};
+```
+
+This method's argument list is lengthy and hard to work with (let's
+say that the `message` argument is not even 0-terminated). If we mock
+it as is, using the mock will be awkward. If, however, we try to
+simplify this interface, we'll need to fix all clients depending on
+it, which is often infeasible.
+
+The trick is to re-dispatch the method in the mock class:
+
+```
+class ScopedMockLog : public LogSink {
+ public:
+  ...
+  virtual void send(LogSeverity severity, const char* full_filename,
+                    const char* base_filename, int line, const tm* tm_time,
+                    const char* message, size_t message_len) {
+    // We are only interested in the log severity, full file name, and
+    // log message.
+    Log(severity, full_filename, std::string(message, message_len));
+  }
+
+  // Implements the mock method:
+  //
+  //   void Log(LogSeverity severity,
+  //            const string& file_path,
+  //            const string& message);
+  MOCK_METHOD3(Log, void(LogSeverity severity, const string& file_path,
+                         const string& message));
+};
+```
+
+By defining a new mock method with a trimmed argument list, we make
+the mock class much more user-friendly.
+
+## Alternative to Mocking Concrete Classes ##
+
+Often you may find yourself using classes that don't implement
+interfaces. In order to test your code that uses such a class (let's
+call it `Concrete`), you may be tempted to make the methods of
+`Concrete` virtual and then mock it.
+
+Try not to do that.
+
+Making a non-virtual function virtual is a big decision. It creates an
+extension point where subclasses can tweak your class' behavior. This
+weakens your control on the class because now it's harder to maintain
+the class' invariants. You should make a function virtual only when
+there is a valid reason for a subclass to override it.
+
+Mocking concrete classes directly is problematic as it creates a tight
+coupling between the class and the tests - any small change in the
+class may invalidate your tests and make test maintenance a pain.
+
+To avoid such problems, many programmers have been practicing "coding
+to interfaces": instead of talking to the `Concrete` class, your code
+would define an interface and talk to it. Then you implement that
+interface as an adaptor on top of `Concrete`. In tests, you can easily
+mock that interface to observe how your code is doing.
+
+This technique incurs some overhead:
+
+  * You pay the cost of virtual function calls (usually not a problem).
+  * There is more abstraction for the programmers to learn.
+
+However, it can also bring significant benefits in addition to better
+testability:
+
+  * `Concrete`'s API may not fit your problem domain very well, as you may not be the only client it tries to serve. By designing your own interface, you have a chance to tailor it to your need - you may add higher-level functionalities, rename stuff, etc instead of just trimming the class. This allows you to write your code (user of the interface) in a more natural way, which means it will be more readable, more maintainable, and you'll be more productive.
+  * If `Concrete`'s implementation ever has to change, you don't have to rewrite everywhere it is used. Instead, you can absorb the change in your implementation of the interface, and your other code and tests will be insulated from this change.
+
+Some people worry that if everyone is practicing this technique, they
+will end up writing lots of redundant code. This concern is totally
+understandable. However, there are two reasons why it may not be the
+case:
+
+  * Different projects may need to use `Concrete` in different ways, so the best interfaces for them will be different. Therefore, each of them will have its own domain-specific interface on top of `Concrete`, and they will not be the same code.
+  * If enough projects want to use the same interface, they can always share it, just like they have been sharing `Concrete`. You can check in the interface and the adaptor somewhere near `Concrete` (perhaps in a `contrib` sub-directory) and let many projects use it.
+
+You need to weigh the pros and cons carefully for your particular
+problem, but I'd like to assure you that the Java community has been
+practicing this for a long time and it's a proven effective technique
+applicable in a wide variety of situations. :-)
+
+## Delegating Calls to a Fake ##
+
+Some times you have a non-trivial fake implementation of an
+interface. For example:
+
+```
+class Foo {
+ public:
+  virtual ~Foo() {}
+  virtual char DoThis(int n) = 0;
+  virtual void DoThat(const char* s, int* p) = 0;
+};
+
+class FakeFoo : public Foo {
+ public:
+  virtual char DoThis(int n) {
+    return (n > 0) ? '+' :
+        (n < 0) ? '-' : '0';
+  }
+
+  virtual void DoThat(const char* s, int* p) {
+    *p = strlen(s);
+  }
+};
+```
+
+Now you want to mock this interface such that you can set expectations
+on it. However, you also want to use `FakeFoo` for the default
+behavior, as duplicating it in the mock object is, well, a lot of
+work.
+
+When you define the mock class using Google Mock, you can have it
+delegate its default action to a fake class you already have, using
+this pattern:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+class MockFoo : public Foo {
+ public:
+  // Normal mock method definitions using Google Mock.
+  MOCK_METHOD1(DoThis, char(int n));
+  MOCK_METHOD2(DoThat, void(const char* s, int* p));
+
+  // Delegates the default actions of the methods to a FakeFoo object.
+  // This must be called *before* the custom ON_CALL() statements.
+  void DelegateToFake() {
+    ON_CALL(*this, DoThis(_))
+        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThis));
+    ON_CALL(*this, DoThat(_, _))
+        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThat));
+  }
+ private:
+  FakeFoo fake_;  // Keeps an instance of the fake in the mock.
+};
+```
+
+With that, you can use `MockFoo` in your tests as usual. Just remember
+that if you don't explicitly set an action in an `ON_CALL()` or
+`EXPECT_CALL()`, the fake will be called upon to do it:
+
+```
+using ::testing::_;
+
+TEST(AbcTest, Xyz) {
+  MockFoo foo;
+  foo.DelegateToFake(); // Enables the fake for delegation.
+
+  // Put your ON_CALL(foo, ...)s here, if any.
+
+  // No action specified, meaning to use the default action.
+  EXPECT_CALL(foo, DoThis(5));
+  EXPECT_CALL(foo, DoThat(_, _));
+
+  int n = 0;
+  EXPECT_EQ('+', foo.DoThis(5));  // FakeFoo::DoThis() is invoked.
+  foo.DoThat("Hi", &n);           // FakeFoo::DoThat() is invoked.
+  EXPECT_EQ(2, n);
+}
+```
+
+**Some tips:**
+
+  * If you want, you can still override the default action by providing your own `ON_CALL()` or using `.WillOnce()` / `.WillRepeatedly()` in `EXPECT_CALL()`.
+  * In `DelegateToFake()`, you only need to delegate the methods whose fake implementation you intend to use.
+  * The general technique discussed here works for overloaded methods, but you'll need to tell the compiler which version you mean. To disambiguate a mock function (the one you specify inside the parentheses of `ON_CALL()`), see the "Selecting Between Overloaded Functions" section on this page; to disambiguate a fake function (the one you place inside `Invoke()`), use a `static_cast` to specify the function's type. For instance, if class `Foo` has methods `char DoThis(int n)` and `bool DoThis(double x) const`, and you want to invoke the latter, you need to write `Invoke(&fake_, static_cast<bool (FakeFoo::*)(double) const>(&FakeFoo::DoThis))` instead of `Invoke(&fake_, &FakeFoo::DoThis)` (The strange-looking thing inside the angled brackets of `static_cast` is the type of a function pointer to the second `DoThis()` method.).
+  * Having to mix a mock and a fake is often a sign of something gone wrong. Perhaps you haven't got used to the interaction-based way of testing yet. Or perhaps your interface is taking on too many roles and should be split up. Therefore, **don't abuse this**. We would only recommend to do it as an intermediate step when you are refactoring your code.
+
+Regarding the tip on mixing a mock and a fake, here's an example on
+why it may be a bad sign: Suppose you have a class `System` for
+low-level system operations. In particular, it does file and I/O
+operations. And suppose you want to test how your code uses `System`
+to do I/O, and you just want the file operations to work normally. If
+you mock out the entire `System` class, you'll have to provide a fake
+implementation for the file operation part, which suggests that
+`System` is taking on too many roles.
+
+Instead, you can define a `FileOps` interface and an `IOOps` interface
+and split `System`'s functionalities into the two. Then you can mock
+`IOOps` without mocking `FileOps`.
+
+## Delegating Calls to a Real Object ##
+
+When using testing doubles (mocks, fakes, stubs, and etc), sometimes
+their behaviors will differ from those of the real objects. This
+difference could be either intentional (as in simulating an error such
+that you can test the error handling code) or unintentional. If your
+mocks have different behaviors than the real objects by mistake, you
+could end up with code that passes the tests but fails in production.
+
+You can use the _delegating-to-real_ technique to ensure that your
+mock has the same behavior as the real object while retaining the
+ability to validate calls. This technique is very similar to the
+delegating-to-fake technique, the difference being that we use a real
+object instead of a fake. Here's an example:
+
+```
+using ::testing::_;
+using ::testing::AtLeast;
+using ::testing::Invoke;
+
+class MockFoo : public Foo {
+ public:
+  MockFoo() {
+    // By default, all calls are delegated to the real object.
+    ON_CALL(*this, DoThis())
+        .WillByDefault(Invoke(&real_, &Foo::DoThis));
+    ON_CALL(*this, DoThat(_))
+        .WillByDefault(Invoke(&real_, &Foo::DoThat));
+    ...
+  }
+  MOCK_METHOD0(DoThis, ...);
+  MOCK_METHOD1(DoThat, ...);
+  ...
+ private:
+  Foo real_;
+};
+...
+
+  MockFoo mock;
+
+  EXPECT_CALL(mock, DoThis())
+      .Times(3);
+  EXPECT_CALL(mock, DoThat("Hi"))
+      .Times(AtLeast(1));
+  ... use mock in test ...
+```
+
+With this, Google Mock will verify that your code made the right calls
+(with the right arguments, in the right order, called the right number
+of times, etc), and a real object will answer the calls (so the
+behavior will be the same as in production). This gives you the best
+of both worlds.
+
+## Delegating Calls to a Parent Class ##
+
+Ideally, you should code to interfaces, whose methods are all pure
+virtual. In reality, sometimes you do need to mock a virtual method
+that is not pure (i.e, it already has an implementation). For example:
+
+```
+class Foo {
+ public:
+  virtual ~Foo();
+
+  virtual void Pure(int n) = 0;
+  virtual int Concrete(const char* str) { ... }
+};
+
+class MockFoo : public Foo {
+ public:
+  // Mocking a pure method.
+  MOCK_METHOD1(Pure, void(int n));
+  // Mocking a concrete method.  Foo::Concrete() is shadowed.
+  MOCK_METHOD1(Concrete, int(const char* str));
+};
+```
+
+Sometimes you may want to call `Foo::Concrete()` instead of
+`MockFoo::Concrete()`. Perhaps you want to do it as part of a stub
+action, or perhaps your test doesn't need to mock `Concrete()` at all
+(but it would be oh-so painful to have to define a new mock class
+whenever you don't need to mock one of its methods).
+
+The trick is to leave a back door in your mock class for accessing the
+real methods in the base class:
+
+```
+class MockFoo : public Foo {
+ public:
+  // Mocking a pure method.
+  MOCK_METHOD1(Pure, void(int n));
+  // Mocking a concrete method.  Foo::Concrete() is shadowed.
+  MOCK_METHOD1(Concrete, int(const char* str));
+
+  // Use this to call Concrete() defined in Foo.
+  int FooConcrete(const char* str) { return Foo::Concrete(str); }
+};
+```
+
+Now, you can call `Foo::Concrete()` inside an action by:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+...
+  EXPECT_CALL(foo, Concrete(_))
+      .WillOnce(Invoke(&foo, &MockFoo::FooConcrete));
+```
+
+or tell the mock object that you don't want to mock `Concrete()`:
+
+```
+using ::testing::Invoke;
+...
+  ON_CALL(foo, Concrete(_))
+      .WillByDefault(Invoke(&foo, &MockFoo::FooConcrete));
+```
+
+(Why don't we just write `Invoke(&foo, &Foo::Concrete)`? If you do
+that, `MockFoo::Concrete()` will be called (and cause an infinite
+recursion) since `Foo::Concrete()` is virtual. That's just how C++
+works.)
+
+# Using Matchers #
+
+## Matching Argument Values Exactly ##
+
+You can specify exactly which arguments a mock method is expecting:
+
+```
+using ::testing::Return;
+...
+  EXPECT_CALL(foo, DoThis(5))
+      .WillOnce(Return('a'));
+  EXPECT_CALL(foo, DoThat("Hello", bar));
+```
+
+## Using Simple Matchers ##
+
+You can use matchers to match arguments that have a certain property:
+
+```
+using ::testing::Ge;
+using ::testing::NotNull;
+using ::testing::Return;
+...
+  EXPECT_CALL(foo, DoThis(Ge(5)))  // The argument must be >= 5.
+      .WillOnce(Return('a'));
+  EXPECT_CALL(foo, DoThat("Hello", NotNull()));
+  // The second argument must not be NULL.
+```
+
+A frequently used matcher is `_`, which matches anything:
+
+```
+using ::testing::_;
+using ::testing::NotNull;
+...
+  EXPECT_CALL(foo, DoThat(_, NotNull()));
+```
+
+## Combining Matchers ##
+
+You can build complex matchers from existing ones using `AllOf()`,
+`AnyOf()`, and `Not()`:
+
+```
+using ::testing::AllOf;
+using ::testing::Gt;
+using ::testing::HasSubstr;
+using ::testing::Ne;
+using ::testing::Not;
+...
+  // The argument must be > 5 and != 10.
+  EXPECT_CALL(foo, DoThis(AllOf(Gt(5),
+                                Ne(10))));
+
+  // The first argument must not contain sub-string "blah".
+  EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")),
+                          NULL));
+```
+
+## Casting Matchers ##
+
+Google Mock matchers are statically typed, meaning that the compiler
+can catch your mistake if you use a matcher of the wrong type (for
+example, if you use `Eq(5)` to match a `string` argument). Good for
+you!
+
+Sometimes, however, you know what you're doing and want the compiler
+to give you some slack. One example is that you have a matcher for
+`long` and the argument you want to match is `int`. While the two
+types aren't exactly the same, there is nothing really wrong with
+using a `Matcher<long>` to match an `int` - after all, we can first
+convert the `int` argument to a `long` before giving it to the
+matcher.
+
+To support this need, Google Mock gives you the
+`SafeMatcherCast<T>(m)` function. It casts a matcher `m` to type
+`Matcher<T>`. To ensure safety, Google Mock checks that (let `U` be the
+type `m` accepts):
+
+  1. Type `T` can be implicitly cast to type `U`;
+  1. When both `T` and `U` are built-in arithmetic types (`bool`, integers, and floating-point numbers), the conversion from `T` to `U` is not lossy (in other words, any value representable by `T` can also be represented by `U`); and
+  1. When `U` is a reference, `T` must also be a reference (as the underlying matcher may be interested in the address of the `U` value).
+
+The code won't compile if any of these conditions isn't met.
+
+Here's one example:
+
+```
+using ::testing::SafeMatcherCast;
+
+// A base class and a child class.
+class Base { ... };
+class Derived : public Base { ... };
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(DoThis, void(Derived* derived));
+};
+...
+
+  MockFoo foo;
+  // m is a Matcher<Base*> we got from somewhere.
+  EXPECT_CALL(foo, DoThis(SafeMatcherCast<Derived*>(m)));
+```
+
+If you find `SafeMatcherCast<T>(m)` too limiting, you can use a similar
+function `MatcherCast<T>(m)`. The difference is that `MatcherCast` works
+as long as you can `static_cast` type `T` to type `U`.
+
+`MatcherCast` essentially lets you bypass C++'s type system
+(`static_cast` isn't always safe as it could throw away information,
+for example), so be careful not to misuse/abuse it.
+
+## Selecting Between Overloaded Functions ##
+
+If you expect an overloaded function to be called, the compiler may
+need some help on which overloaded version it is.
+
+To disambiguate functions overloaded on the const-ness of this object,
+use the `Const()` argument wrapper.
+
+```
+using ::testing::ReturnRef;
+
+class MockFoo : public Foo {
+  ...
+  MOCK_METHOD0(GetBar, Bar&());
+  MOCK_CONST_METHOD0(GetBar, const Bar&());
+};
+...
+
+  MockFoo foo;
+  Bar bar1, bar2;
+  EXPECT_CALL(foo, GetBar())         // The non-const GetBar().
+      .WillOnce(ReturnRef(bar1));
+  EXPECT_CALL(Const(foo), GetBar())  // The const GetBar().
+      .WillOnce(ReturnRef(bar2));
+```
+
+(`Const()` is defined by Google Mock and returns a `const` reference
+to its argument.)
+
+To disambiguate overloaded functions with the same number of arguments
+but different argument types, you may need to specify the exact type
+of a matcher, either by wrapping your matcher in `Matcher<type>()`, or
+using a matcher whose type is fixed (`TypedEq<type>`, `An<type>()`,
+etc):
+
+```
+using ::testing::An;
+using ::testing::Lt;
+using ::testing::Matcher;
+using ::testing::TypedEq;
+
+class MockPrinter : public Printer {
+ public:
+  MOCK_METHOD1(Print, void(int n));
+  MOCK_METHOD1(Print, void(char c));
+};
+
+TEST(PrinterTest, Print) {
+  MockPrinter printer;
+
+  EXPECT_CALL(printer, Print(An<int>()));            // void Print(int);
+  EXPECT_CALL(printer, Print(Matcher<int>(Lt(5))));  // void Print(int);
+  EXPECT_CALL(printer, Print(TypedEq<char>('a')));   // void Print(char);
+
+  printer.Print(3);
+  printer.Print(6);
+  printer.Print('a');
+}
+```
+
+## Performing Different Actions Based on the Arguments ##
+
+When a mock method is called, the _last_ matching expectation that's
+still active will be selected (think "newer overrides older"). So, you
+can make a method do different things depending on its argument values
+like this:
+
+```
+using ::testing::_;
+using ::testing::Lt;
+using ::testing::Return;
+...
+  // The default case.
+  EXPECT_CALL(foo, DoThis(_))
+      .WillRepeatedly(Return('b'));
+
+  // The more specific case.
+  EXPECT_CALL(foo, DoThis(Lt(5)))
+      .WillRepeatedly(Return('a'));
+```
+
+Now, if `foo.DoThis()` is called with a value less than 5, `'a'` will
+be returned; otherwise `'b'` will be returned.
+
+## Matching Multiple Arguments as a Whole ##
+
+Sometimes it's not enough to match the arguments individually. For
+example, we may want to say that the first argument must be less than
+the second argument. The `With()` clause allows us to match
+all arguments of a mock function as a whole. For example,
+
+```
+using ::testing::_;
+using ::testing::Lt;
+using ::testing::Ne;
+...
+  EXPECT_CALL(foo, InRange(Ne(0), _))
+      .With(Lt());
+```
+
+says that the first argument of `InRange()` must not be 0, and must be
+less than the second argument.
+
+The expression inside `With()` must be a matcher of type
+`Matcher< ::testing::tuple<A1, ..., An> >`, where `A1`, ..., `An` are the
+types of the function arguments.
+
+You can also write `AllArgs(m)` instead of `m` inside `.With()`. The
+two forms are equivalent, but `.With(AllArgs(Lt()))` is more readable
+than `.With(Lt())`.
+
+You can use `Args<k1, ..., kn>(m)` to match the `n` selected arguments
+(as a tuple) against `m`. For example,
+
+```
+using ::testing::_;
+using ::testing::AllOf;
+using ::testing::Args;
+using ::testing::Lt;
+...
+  EXPECT_CALL(foo, Blah(_, _, _))
+      .With(AllOf(Args<0, 1>(Lt()), Args<1, 2>(Lt())));
+```
+
+says that `Blah()` will be called with arguments `x`, `y`, and `z` where
+`x < y < z`.
+
+As a convenience and example, Google Mock provides some matchers for
+2-tuples, including the `Lt()` matcher above. See the [CheatSheet](CheatSheet.md) for
+the complete list.
+
+Note that if you want to pass the arguments to a predicate of your own
+(e.g. `.With(Args<0, 1>(Truly(&MyPredicate)))`), that predicate MUST be
+written to take a `::testing::tuple` as its argument; Google Mock will pass the `n` selected arguments as _one_ single tuple to the predicate.
+
+## Using Matchers as Predicates ##
+
+Have you noticed that a matcher is just a fancy predicate that also
+knows how to describe itself? Many existing algorithms take predicates
+as arguments (e.g. those defined in STL's `<algorithm>` header), and
+it would be a shame if Google Mock matchers are not allowed to
+participate.
+
+Luckily, you can use a matcher where a unary predicate functor is
+expected by wrapping it inside the `Matches()` function. For example,
+
+```
+#include <algorithm>
+#include <vector>
+
+std::vector<int> v;
+...
+// How many elements in v are >= 10?
+const int count = count_if(v.begin(), v.end(), Matches(Ge(10)));
+```
+
+Since you can build complex matchers from simpler ones easily using
+Google Mock, this gives you a way to conveniently construct composite
+predicates (doing the same using STL's `<functional>` header is just
+painful). For example, here's a predicate that's satisfied by any
+number that is >= 0, <= 100, and != 50:
+
+```
+Matches(AllOf(Ge(0), Le(100), Ne(50)))
+```
+
+## Using Matchers in Google Test Assertions ##
+
+Since matchers are basically predicates that also know how to describe
+themselves, there is a way to take advantage of them in
+[Google Test](../../googletest/) assertions. It's
+called `ASSERT_THAT` and `EXPECT_THAT`:
+
+```
+  ASSERT_THAT(value, matcher);  // Asserts that value matches matcher.
+  EXPECT_THAT(value, matcher);  // The non-fatal version.
+```
+
+For example, in a Google Test test you can write:
+
+```
+#include "gmock/gmock.h"
+
+using ::testing::AllOf;
+using ::testing::Ge;
+using ::testing::Le;
+using ::testing::MatchesRegex;
+using ::testing::StartsWith;
+...
+
+  EXPECT_THAT(Foo(), StartsWith("Hello"));
+  EXPECT_THAT(Bar(), MatchesRegex("Line \\d+"));
+  ASSERT_THAT(Baz(), AllOf(Ge(5), Le(10)));
+```
+
+which (as you can probably guess) executes `Foo()`, `Bar()`, and
+`Baz()`, and verifies that:
+
+  * `Foo()` returns a string that starts with `"Hello"`.
+  * `Bar()` returns a string that matches regular expression `"Line \\d+"`.
+  * `Baz()` returns a number in the range [5, 10].
+
+The nice thing about these macros is that _they read like
+English_. They generate informative messages too. For example, if the
+first `EXPECT_THAT()` above fails, the message will be something like:
+
+```
+Value of: Foo()
+  Actual: "Hi, world!"
+Expected: starts with "Hello"
+```
+
+**Credit:** The idea of `(ASSERT|EXPECT)_THAT` was stolen from the
+[Hamcrest](https://github.com/hamcrest/) project, which adds
+`assertThat()` to JUnit.
+
+## Using Predicates as Matchers ##
+
+Google Mock provides a built-in set of matchers. In case you find them
+lacking, you can use an arbitray unary predicate function or functor
+as a matcher - as long as the predicate accepts a value of the type
+you want. You do this by wrapping the predicate inside the `Truly()`
+function, for example:
+
+```
+using ::testing::Truly;
+
+int IsEven(int n) { return (n % 2) == 0 ? 1 : 0; }
+...
+
+  // Bar() must be called with an even number.
+  EXPECT_CALL(foo, Bar(Truly(IsEven)));
+```
+
+Note that the predicate function / functor doesn't have to return
+`bool`. It works as long as the return value can be used as the
+condition in statement `if (condition) ...`.
+
+## Matching Arguments that Are Not Copyable ##
+
+When you do an `EXPECT_CALL(mock_obj, Foo(bar))`, Google Mock saves
+away a copy of `bar`. When `Foo()` is called later, Google Mock
+compares the argument to `Foo()` with the saved copy of `bar`. This
+way, you don't need to worry about `bar` being modified or destroyed
+after the `EXPECT_CALL()` is executed. The same is true when you use
+matchers like `Eq(bar)`, `Le(bar)`, and so on.
+
+But what if `bar` cannot be copied (i.e. has no copy constructor)? You
+could define your own matcher function and use it with `Truly()`, as
+the previous couple of recipes have shown. Or, you may be able to get
+away from it if you can guarantee that `bar` won't be changed after
+the `EXPECT_CALL()` is executed. Just tell Google Mock that it should
+save a reference to `bar`, instead of a copy of it. Here's how:
+
+```
+using ::testing::Eq;
+using ::testing::ByRef;
+using ::testing::Lt;
+...
+  // Expects that Foo()'s argument == bar.
+  EXPECT_CALL(mock_obj, Foo(Eq(ByRef(bar))));
+
+  // Expects that Foo()'s argument < bar.
+  EXPECT_CALL(mock_obj, Foo(Lt(ByRef(bar))));
+```
+
+Remember: if you do this, don't change `bar` after the
+`EXPECT_CALL()`, or the result is undefined.
+
+## Validating a Member of an Object ##
+
+Often a mock function takes a reference to object as an argument. When
+matching the argument, you may not want to compare the entire object
+against a fixed object, as that may be over-specification. Instead,
+you may need to validate a certain member variable or the result of a
+certain getter method of the object. You can do this with `Field()`
+and `Property()`. More specifically,
+
+```
+Field(&Foo::bar, m)
+```
+
+is a matcher that matches a `Foo` object whose `bar` member variable
+satisfies matcher `m`.
+
+```
+Property(&Foo::baz, m)
+```
+
+is a matcher that matches a `Foo` object whose `baz()` method returns
+a value that satisfies matcher `m`.
+
+For example:
+
+> | `Field(&Foo::number, Ge(3))` | Matches `x` where `x.number >= 3`. |
+|:-----------------------------|:-----------------------------------|
+> | `Property(&Foo::name, StartsWith("John "))` | Matches `x` where `x.name()` starts with `"John "`. |
+
+Note that in `Property(&Foo::baz, ...)`, method `baz()` must take no
+argument and be declared as `const`.
+
+BTW, `Field()` and `Property()` can also match plain pointers to
+objects. For instance,
+
+```
+Field(&Foo::number, Ge(3))
+```
+
+matches a plain pointer `p` where `p->number >= 3`. If `p` is `NULL`,
+the match will always fail regardless of the inner matcher.
+
+What if you want to validate more than one members at the same time?
+Remember that there is `AllOf()`.
+
+## Validating the Value Pointed to by a Pointer Argument ##
+
+C++ functions often take pointers as arguments. You can use matchers
+like `IsNull()`, `NotNull()`, and other comparison matchers to match a
+pointer, but what if you want to make sure the value _pointed to_ by
+the pointer, instead of the pointer itself, has a certain property?
+Well, you can use the `Pointee(m)` matcher.
+
+`Pointee(m)` matches a pointer iff `m` matches the value the pointer
+points to. For example:
+
+```
+using ::testing::Ge;
+using ::testing::Pointee;
+...
+  EXPECT_CALL(foo, Bar(Pointee(Ge(3))));
+```
+
+expects `foo.Bar()` to be called with a pointer that points to a value
+greater than or equal to 3.
+
+One nice thing about `Pointee()` is that it treats a `NULL` pointer as
+a match failure, so you can write `Pointee(m)` instead of
+
+```
+  AllOf(NotNull(), Pointee(m))
+```
+
+without worrying that a `NULL` pointer will crash your test.
+
+Also, did we tell you that `Pointee()` works with both raw pointers
+**and** smart pointers (`linked_ptr`, `shared_ptr`, `scoped_ptr`, and
+etc)?
+
+What if you have a pointer to pointer? You guessed it - you can use
+nested `Pointee()` to probe deeper inside the value. For example,
+`Pointee(Pointee(Lt(3)))` matches a pointer that points to a pointer
+that points to a number less than 3 (what a mouthful...).
+
+## Testing a Certain Property of an Object ##
+
+Sometimes you want to specify that an object argument has a certain
+property, but there is no existing matcher that does this. If you want
+good error messages, you should define a matcher. If you want to do it
+quick and dirty, you could get away with writing an ordinary function.
+
+Let's say you have a mock function that takes an object of type `Foo`,
+which has an `int bar()` method and an `int baz()` method, and you
+want to constrain that the argument's `bar()` value plus its `baz()`
+value is a given number. Here's how you can define a matcher to do it:
+
+```
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+
+class BarPlusBazEqMatcher : public MatcherInterface<const Foo&> {
+ public:
+  explicit BarPlusBazEqMatcher(int expected_sum)
+      : expected_sum_(expected_sum) {}
+
+  virtual bool MatchAndExplain(const Foo& foo,
+                               MatchResultListener* listener) const {
+    return (foo.bar() + foo.baz()) == expected_sum_;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "bar() + baz() equals " << expected_sum_;
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "bar() + baz() does not equal " << expected_sum_;
+  }
+ private:
+  const int expected_sum_;
+};
+
+inline Matcher<const Foo&> BarPlusBazEq(int expected_sum) {
+  return MakeMatcher(new BarPlusBazEqMatcher(expected_sum));
+}
+
+...
+
+  EXPECT_CALL(..., DoThis(BarPlusBazEq(5)))...;
+```
+
+## Matching Containers ##
+
+Sometimes an STL container (e.g. list, vector, map, ...) is passed to
+a mock function and you may want to validate it. Since most STL
+containers support the `==` operator, you can write
+`Eq(expected_container)` or simply `expected_container` to match a
+container exactly.
+
+Sometimes, though, you may want to be more flexible (for example, the
+first element must be an exact match, but the second element can be
+any positive number, and so on). Also, containers used in tests often
+have a small number of elements, and having to define the expected
+container out-of-line is a bit of a hassle.
+
+You can use the `ElementsAre()` or `UnorderedElementsAre()` matcher in
+such cases:
+
+```
+using ::testing::_;
+using ::testing::ElementsAre;
+using ::testing::Gt;
+...
+
+  MOCK_METHOD1(Foo, void(const vector<int>& numbers));
+...
+
+  EXPECT_CALL(mock, Foo(ElementsAre(1, Gt(0), _, 5)));
+```
+
+The above matcher says that the container must have 4 elements, which
+must be 1, greater than 0, anything, and 5 respectively.
+
+If you instead write:
+
+```
+using ::testing::_;
+using ::testing::Gt;
+using ::testing::UnorderedElementsAre;
+...
+
+  MOCK_METHOD1(Foo, void(const vector<int>& numbers));
+...
+
+  EXPECT_CALL(mock, Foo(UnorderedElementsAre(1, Gt(0), _, 5)));
+```
+
+It means that the container must have 4 elements, which under some
+permutation must be 1, greater than 0, anything, and 5 respectively.
+
+`ElementsAre()` and `UnorderedElementsAre()` are overloaded to take 0
+to 10 arguments. If more are needed, you can place them in a C-style
+array and use `ElementsAreArray()` or `UnorderedElementsAreArray()`
+instead:
+
+```
+using ::testing::ElementsAreArray;
+...
+
+  // ElementsAreArray accepts an array of element values.
+  const int expected_vector1[] = { 1, 5, 2, 4, ... };
+  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector1)));
+
+  // Or, an array of element matchers.
+  Matcher<int> expected_vector2 = { 1, Gt(2), _, 3, ... };
+  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector2)));
+```
+
+In case the array needs to be dynamically created (and therefore the
+array size cannot be inferred by the compiler), you can give
+`ElementsAreArray()` an additional argument to specify the array size:
+
+```
+using ::testing::ElementsAreArray;
+...
+  int* const expected_vector3 = new int[count];
+  ... fill expected_vector3 with values ...
+  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector3, count)));
+```
+
+**Tips:**
+
+  * `ElementsAre*()` can be used to match _any_ container that implements the STL iterator pattern (i.e. it has a `const_iterator` type and supports `begin()/end()`), not just the ones defined in STL. It will even work with container types yet to be written - as long as they follows the above pattern.
+  * You can use nested `ElementsAre*()` to match nested (multi-dimensional) containers.
+  * If the container is passed by pointer instead of by reference, just write `Pointee(ElementsAre*(...))`.
+  * The order of elements _matters_ for `ElementsAre*()`. Therefore don't use it with containers whose element order is undefined (e.g. `hash_map`).
+
+## Sharing Matchers ##
+
+Under the hood, a Google Mock matcher object consists of a pointer to
+a ref-counted implementation object. Copying matchers is allowed and
+very efficient, as only the pointer is copied. When the last matcher
+that references the implementation object dies, the implementation
+object will be deleted.
+
+Therefore, if you have some complex matcher that you want to use again
+and again, there is no need to build it everytime. Just assign it to a
+matcher variable and use that variable repeatedly! For example,
+
+```
+  Matcher<int> in_range = AllOf(Gt(5), Le(10));
+  ... use in_range as a matcher in multiple EXPECT_CALLs ...
+```
+
+# Setting Expectations #
+
+## Knowing When to Expect ##
+
+`ON_CALL` is likely the single most under-utilized construct in Google Mock.
+
+There are basically two constructs for defining the behavior of a mock object: `ON_CALL` and `EXPECT_CALL`. The difference? `ON_CALL` defines what happens when a mock method is called, but _doesn't imply any expectation on the method being called._ `EXPECT_CALL` not only defines the behavior, but also sets an expectation that _the method will be called with the given arguments, for the given number of times_ (and _in the given order_ when you specify the order too).
+
+Since `EXPECT_CALL` does more, isn't it better than `ON_CALL`? Not really. Every `EXPECT_CALL` adds a constraint on the behavior of the code under test. Having more constraints than necessary is _baaad_ - even worse than not having enough constraints.
+
+This may be counter-intuitive. How could tests that verify more be worse than tests that verify less? Isn't verification the whole point of tests?
+
+The answer, lies in _what_ a test should verify. **A good test verifies the contract of the code.** If a test over-specifies, it doesn't leave enough freedom to the implementation. As a result, changing the implementation without breaking the contract (e.g. refactoring and optimization), which should be perfectly fine to do, can break such tests. Then you have to spend time fixing them, only to see them broken again the next time the implementation is changed.
+
+Keep in mind that one doesn't have to verify more than one property in one test. In fact, **it's a good style to verify only one thing in one test.** If you do that, a bug will likely break only one or two tests instead of dozens (which case would you rather debug?). If you are also in the habit of giving tests descriptive names that tell what they verify, you can often easily guess what's wrong just from the test log itself.
+
+So use `ON_CALL` by default, and only use `EXPECT_CALL` when you actually intend to verify that the call is made. For example, you may have a bunch of `ON_CALL`s in your test fixture to set the common mock behavior shared by all tests in the same group, and write (scarcely) different `EXPECT_CALL`s in different `TEST_F`s to verify different aspects of the code's behavior. Compared with the style where each `TEST` has many `EXPECT_CALL`s, this leads to tests that are more resilient to implementational changes (and thus less likely to require maintenance) and makes the intent of the tests more obvious (so they are easier to maintain when you do need to maintain them).
+
+If you are bothered by the "Uninteresting mock function call" message printed when a mock method without an `EXPECT_CALL` is called, you may use a `NiceMock` instead to suppress all such messages for the mock object, or suppress the message for specific methods by adding `EXPECT_CALL(...).Times(AnyNumber())`. DO NOT suppress it by blindly adding an `EXPECT_CALL(...)`, or you'll have a test that's a pain to maintain.
+
+## Ignoring Uninteresting Calls ##
+
+If you are not interested in how a mock method is called, just don't
+say anything about it. In this case, if the method is ever called,
+Google Mock will perform its default action to allow the test program
+to continue. If you are not happy with the default action taken by
+Google Mock, you can override it using `DefaultValue<T>::Set()`
+(described later in this document) or `ON_CALL()`.
+
+Please note that once you expressed interest in a particular mock
+method (via `EXPECT_CALL()`), all invocations to it must match some
+expectation. If this function is called but the arguments don't match
+any `EXPECT_CALL()` statement, it will be an error.
+
+## Disallowing Unexpected Calls ##
+
+If a mock method shouldn't be called at all, explicitly say so:
+
+```
+using ::testing::_;
+...
+  EXPECT_CALL(foo, Bar(_))
+      .Times(0);
+```
+
+If some calls to the method are allowed, but the rest are not, just
+list all the expected calls:
+
+```
+using ::testing::AnyNumber;
+using ::testing::Gt;
+...
+  EXPECT_CALL(foo, Bar(5));
+  EXPECT_CALL(foo, Bar(Gt(10)))
+      .Times(AnyNumber());
+```
+
+A call to `foo.Bar()` that doesn't match any of the `EXPECT_CALL()`
+statements will be an error.
+
+## Understanding Uninteresting vs Unexpected Calls ##
+
+_Uninteresting_ calls and _unexpected_ calls are different concepts in Google Mock. _Very_ different.
+
+A call `x.Y(...)` is **uninteresting** if there's _not even a single_ `EXPECT_CALL(x, Y(...))` set. In other words, the test isn't interested in the `x.Y()` method at all, as evident in that the test doesn't care to say anything about it.
+
+A call `x.Y(...)` is **unexpected** if there are some `EXPECT_CALL(x, Y(...))s` set, but none of them matches the call. Put another way, the test is interested in the `x.Y()` method (therefore it _explicitly_ sets some `EXPECT_CALL` to verify how it's called); however, the verification fails as the test doesn't expect this particular call to happen.
+
+**An unexpected call is always an error,** as the code under test doesn't behave the way the test expects it to behave.
+
+**By default, an uninteresting call is not an error,** as it violates no constraint specified by the test. (Google Mock's philosophy is that saying nothing means there is no constraint.) However, it leads to a warning, as it _might_ indicate a problem (e.g. the test author might have forgotten to specify a constraint).
+
+In Google Mock, `NiceMock` and `StrictMock` can be used to make a mock class "nice" or "strict". How does this affect uninteresting calls and unexpected calls?
+
+A **nice mock** suppresses uninteresting call warnings. It is less chatty than the default mock, but otherwise is the same. If a test fails with a default mock, it will also fail using a nice mock instead. And vice versa. Don't expect making a mock nice to change the test's result.
+
+A **strict mock** turns uninteresting call warnings into errors. So making a mock strict may change the test's result.
+
+Let's look at an example:
+
+```
+TEST(...) {
+  NiceMock<MockDomainRegistry> mock_registry;
+  EXPECT_CALL(mock_registry, GetDomainOwner("google.com"))
+          .WillRepeatedly(Return("Larry Page"));
+
+  // Use mock_registry in code under test.
+  ... &mock_registry ...
+}
+```
+
+The sole `EXPECT_CALL` here says that all calls to `GetDomainOwner()` must have `"google.com"` as the argument. If `GetDomainOwner("yahoo.com")` is called, it will be an unexpected call, and thus an error. Having a nice mock doesn't change the severity of an unexpected call.
+
+So how do we tell Google Mock that `GetDomainOwner()` can be called with some other arguments as well? The standard technique is to add a "catch all" `EXPECT_CALL`:
+
+```
+  EXPECT_CALL(mock_registry, GetDomainOwner(_))
+        .Times(AnyNumber());  // catches all other calls to this method.
+  EXPECT_CALL(mock_registry, GetDomainOwner("google.com"))
+        .WillRepeatedly(Return("Larry Page"));
+```
+
+Remember that `_` is the wildcard matcher that matches anything. With this, if `GetDomainOwner("google.com")` is called, it will do what the second `EXPECT_CALL` says; if it is called with a different argument, it will do what the first `EXPECT_CALL` says.
+
+Note that the order of the two `EXPECT_CALLs` is important, as a newer `EXPECT_CALL` takes precedence over an older one.
+
+For more on uninteresting calls, nice mocks, and strict mocks, read ["The Nice, the Strict, and the Naggy"](#the-nice-the-strict-and-the-naggy).
+
+## Expecting Ordered Calls ##
+
+Although an `EXPECT_CALL()` statement defined earlier takes precedence
+when Google Mock tries to match a function call with an expectation,
+by default calls don't have to happen in the order `EXPECT_CALL()`
+statements are written. For example, if the arguments match the
+matchers in the third `EXPECT_CALL()`, but not those in the first two,
+then the third expectation will be used.
+
+If you would rather have all calls occur in the order of the
+expectations, put the `EXPECT_CALL()` statements in a block where you
+define a variable of type `InSequence`:
+
+```
+  using ::testing::_;
+  using ::testing::InSequence;
+
+  {
+    InSequence s;
+
+    EXPECT_CALL(foo, DoThis(5));
+    EXPECT_CALL(bar, DoThat(_))
+        .Times(2);
+    EXPECT_CALL(foo, DoThis(6));
+  }
+```
+
+In this example, we expect a call to `foo.DoThis(5)`, followed by two
+calls to `bar.DoThat()` where the argument can be anything, which are
+in turn followed by a call to `foo.DoThis(6)`. If a call occurred
+out-of-order, Google Mock will report an error.
+
+## Expecting Partially Ordered Calls ##
+
+Sometimes requiring everything to occur in a predetermined order can
+lead to brittle tests. For example, we may care about `A` occurring
+before both `B` and `C`, but aren't interested in the relative order
+of `B` and `C`. In this case, the test should reflect our real intent,
+instead of being overly constraining.
+
+Google Mock allows you to impose an arbitrary DAG (directed acyclic
+graph) on the calls. One way to express the DAG is to use the
+[After](CheatSheet.md#the-after-clause) clause of `EXPECT_CALL`.
+
+Another way is via the `InSequence()` clause (not the same as the
+`InSequence` class), which we borrowed from jMock 2. It's less
+flexible than `After()`, but more convenient when you have long chains
+of sequential calls, as it doesn't require you to come up with
+different names for the expectations in the chains.  Here's how it
+works:
+
+If we view `EXPECT_CALL()` statements as nodes in a graph, and add an
+edge from node A to node B wherever A must occur before B, we can get
+a DAG. We use the term "sequence" to mean a directed path in this
+DAG. Now, if we decompose the DAG into sequences, we just need to know
+which sequences each `EXPECT_CALL()` belongs to in order to be able to
+reconstruct the orginal DAG.
+
+So, to specify the partial order on the expectations we need to do two
+things: first to define some `Sequence` objects, and then for each
+`EXPECT_CALL()` say which `Sequence` objects it is part
+of. Expectations in the same sequence must occur in the order they are
+written. For example,
+
+```
+  using ::testing::Sequence;
+
+  Sequence s1, s2;
+
+  EXPECT_CALL(foo, A())
+      .InSequence(s1, s2);
+  EXPECT_CALL(bar, B())
+      .InSequence(s1);
+  EXPECT_CALL(bar, C())
+      .InSequence(s2);
+  EXPECT_CALL(foo, D())
+      .InSequence(s2);
+```
+
+specifies the following DAG (where `s1` is `A -> B`, and `s2` is `A ->
+C -> D`):
+
+```
+       +---> B
+       |
+  A ---|
+       |
+       +---> C ---> D
+```
+
+This means that A must occur before B and C, and C must occur before
+D. There's no restriction about the order other than these.
+
+## Controlling When an Expectation Retires ##
+
+When a mock method is called, Google Mock only consider expectations
+that are still active. An expectation is active when created, and
+becomes inactive (aka _retires_) when a call that has to occur later
+has occurred. For example, in
+
+```
+  using ::testing::_;
+  using ::testing::Sequence;
+
+  Sequence s1, s2;
+
+  EXPECT_CALL(log, Log(WARNING, _, "File too large."))     // #1
+      .Times(AnyNumber())
+      .InSequence(s1, s2);
+  EXPECT_CALL(log, Log(WARNING, _, "Data set is empty."))  // #2
+      .InSequence(s1);
+  EXPECT_CALL(log, Log(WARNING, _, "User not found."))     // #3
+      .InSequence(s2);
+```
+
+as soon as either #2 or #3 is matched, #1 will retire. If a warning
+`"File too large."` is logged after this, it will be an error.
+
+Note that an expectation doesn't retire automatically when it's
+saturated. For example,
+
+```
+using ::testing::_;
+...
+  EXPECT_CALL(log, Log(WARNING, _, _));                  // #1
+  EXPECT_CALL(log, Log(WARNING, _, "File too large."));  // #2
+```
+
+says that there will be exactly one warning with the message `"File
+too large."`. If the second warning contains this message too, #2 will
+match again and result in an upper-bound-violated error.
+
+If this is not what you want, you can ask an expectation to retire as
+soon as it becomes saturated:
+
+```
+using ::testing::_;
+...
+  EXPECT_CALL(log, Log(WARNING, _, _));                 // #1
+  EXPECT_CALL(log, Log(WARNING, _, "File too large."))  // #2
+      .RetiresOnSaturation();
+```
+
+Here #2 can be used only once, so if you have two warnings with the
+message `"File too large."`, the first will match #2 and the second
+will match #1 - there will be no error.
+
+# Using Actions #
+
+## Returning References from Mock Methods ##
+
+If a mock function's return type is a reference, you need to use
+`ReturnRef()` instead of `Return()` to return a result:
+
+```
+using ::testing::ReturnRef;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD0(GetBar, Bar&());
+};
+...
+
+  MockFoo foo;
+  Bar bar;
+  EXPECT_CALL(foo, GetBar())
+      .WillOnce(ReturnRef(bar));
+```
+
+## Returning Live Values from Mock Methods ##
+
+The `Return(x)` action saves a copy of `x` when the action is
+_created_, and always returns the same value whenever it's
+executed. Sometimes you may want to instead return the _live_ value of
+`x` (i.e. its value at the time when the action is _executed_.).
+
+If the mock function's return type is a reference, you can do it using
+`ReturnRef(x)`, as shown in the previous recipe ("Returning References
+from Mock Methods"). However, Google Mock doesn't let you use
+`ReturnRef()` in a mock function whose return type is not a reference,
+as doing that usually indicates a user error. So, what shall you do?
+
+You may be tempted to try `ByRef()`:
+
+```
+using testing::ByRef;
+using testing::Return;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD0(GetValue, int());
+};
+...
+  int x = 0;
+  MockFoo foo;
+  EXPECT_CALL(foo, GetValue())
+      .WillRepeatedly(Return(ByRef(x)));
+  x = 42;
+  EXPECT_EQ(42, foo.GetValue());
+```
+
+Unfortunately, it doesn't work here. The above code will fail with error:
+
+```
+Value of: foo.GetValue()
+  Actual: 0
+Expected: 42
+```
+
+The reason is that `Return(value)` converts `value` to the actual
+return type of the mock function at the time when the action is
+_created_, not when it is _executed_. (This behavior was chosen for
+the action to be safe when `value` is a proxy object that references
+some temporary objects.) As a result, `ByRef(x)` is converted to an
+`int` value (instead of a `const int&`) when the expectation is set,
+and `Return(ByRef(x))` will always return 0.
+
+`ReturnPointee(pointer)` was provided to solve this problem
+specifically. It returns the value pointed to by `pointer` at the time
+the action is _executed_:
+
+```
+using testing::ReturnPointee;
+...
+  int x = 0;
+  MockFoo foo;
+  EXPECT_CALL(foo, GetValue())
+      .WillRepeatedly(ReturnPointee(&x));  // Note the & here.
+  x = 42;
+  EXPECT_EQ(42, foo.GetValue());  // This will succeed now.
+```
+
+## Combining Actions ##
+
+Want to do more than one thing when a function is called? That's
+fine. `DoAll()` allow you to do sequence of actions every time. Only
+the return value of the last action in the sequence will be used.
+
+```
+using ::testing::DoAll;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(Bar, bool(int n));
+};
+...
+
+  EXPECT_CALL(foo, Bar(_))
+      .WillOnce(DoAll(action_1,
+                      action_2,
+                      ...
+                      action_n));
+```
+
+## Mocking Side Effects ##
+
+Sometimes a method exhibits its effect not via returning a value but
+via side effects. For example, it may change some global state or
+modify an output argument. To mock side effects, in general you can
+define your own action by implementing `::testing::ActionInterface`.
+
+If all you need to do is to change an output argument, the built-in
+`SetArgPointee()` action is convenient:
+
+```
+using ::testing::SetArgPointee;
+
+class MockMutator : public Mutator {
+ public:
+  MOCK_METHOD2(Mutate, void(bool mutate, int* value));
+  ...
+};
+...
+
+  MockMutator mutator;
+  EXPECT_CALL(mutator, Mutate(true, _))
+      .WillOnce(SetArgPointee<1>(5));
+```
+
+In this example, when `mutator.Mutate()` is called, we will assign 5
+to the `int` variable pointed to by argument #1
+(0-based).
+
+`SetArgPointee()` conveniently makes an internal copy of the
+value you pass to it, removing the need to keep the value in scope and
+alive. The implication however is that the value must have a copy
+constructor and assignment operator.
+
+If the mock method also needs to return a value as well, you can chain
+`SetArgPointee()` with `Return()` using `DoAll()`:
+
+```
+using ::testing::_;
+using ::testing::Return;
+using ::testing::SetArgPointee;
+
+class MockMutator : public Mutator {
+ public:
+  ...
+  MOCK_METHOD1(MutateInt, bool(int* value));
+};
+...
+
+  MockMutator mutator;
+  EXPECT_CALL(mutator, MutateInt(_))
+      .WillOnce(DoAll(SetArgPointee<0>(5),
+                      Return(true)));
+```
+
+If the output argument is an array, use the
+`SetArrayArgument<N>(first, last)` action instead. It copies the
+elements in source range `[first, last)` to the array pointed to by
+the `N`-th (0-based) argument:
+
+```
+using ::testing::NotNull;
+using ::testing::SetArrayArgument;
+
+class MockArrayMutator : public ArrayMutator {
+ public:
+  MOCK_METHOD2(Mutate, void(int* values, int num_values));
+  ...
+};
+...
+
+  MockArrayMutator mutator;
+  int values[5] = { 1, 2, 3, 4, 5 };
+  EXPECT_CALL(mutator, Mutate(NotNull(), 5))
+      .WillOnce(SetArrayArgument<0>(values, values + 5));
+```
+
+This also works when the argument is an output iterator:
+
+```
+using ::testing::_;
+using ::testing::SeArrayArgument;
+
+class MockRolodex : public Rolodex {
+ public:
+  MOCK_METHOD1(GetNames, void(std::back_insert_iterator<vector<string> >));
+  ...
+};
+...
+
+  MockRolodex rolodex;
+  vector<string> names;
+  names.push_back("George");
+  names.push_back("John");
+  names.push_back("Thomas");
+  EXPECT_CALL(rolodex, GetNames(_))
+      .WillOnce(SetArrayArgument<0>(names.begin(), names.end()));
+```
+
+## Changing a Mock Object's Behavior Based on the State ##
+
+If you expect a call to change the behavior of a mock object, you can use `::testing::InSequence` to specify different behaviors before and after the call:
+
+```
+using ::testing::InSequence;
+using ::testing::Return;
+
+...
+  {
+    InSequence seq;
+    EXPECT_CALL(my_mock, IsDirty())
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(my_mock, Flush());
+    EXPECT_CALL(my_mock, IsDirty())
+        .WillRepeatedly(Return(false));
+  }
+  my_mock.FlushIfDirty();
+```
+
+This makes `my_mock.IsDirty()` return `true` before `my_mock.Flush()` is called and return `false` afterwards.
+
+If the behavior change is more complex, you can store the effects in a variable and make a mock method get its return value from that variable:
+
+```
+using ::testing::_;
+using ::testing::SaveArg;
+using ::testing::Return;
+
+ACTION_P(ReturnPointee, p) { return *p; }
+...
+  int previous_value = 0;
+  EXPECT_CALL(my_mock, GetPrevValue())
+      .WillRepeatedly(ReturnPointee(&previous_value));
+  EXPECT_CALL(my_mock, UpdateValue(_))
+      .WillRepeatedly(SaveArg<0>(&previous_value));
+  my_mock.DoSomethingToUpdateValue();
+```
+
+Here `my_mock.GetPrevValue()` will always return the argument of the last `UpdateValue()` call.
+
+## Setting the Default Value for a Return Type ##
+
+If a mock method's return type is a built-in C++ type or pointer, by
+default it will return 0 when invoked. Also, in C++ 11 and above, a mock
+method whose return type has a default constructor will return a default-constructed
+value by default.  You only need to specify an
+action if this default value doesn't work for you.
+
+Sometimes, you may want to change this default value, or you may want
+to specify a default value for types Google Mock doesn't know
+about. You can do this using the `::testing::DefaultValue` class
+template:
+
+```
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD0(CalculateBar, Bar());
+};
+...
+
+  Bar default_bar;
+  // Sets the default return value for type Bar.
+  DefaultValue<Bar>::Set(default_bar);
+
+  MockFoo foo;
+
+  // We don't need to specify an action here, as the default
+  // return value works for us.
+  EXPECT_CALL(foo, CalculateBar());
+
+  foo.CalculateBar();  // This should return default_bar.
+
+  // Unsets the default return value.
+  DefaultValue<Bar>::Clear();
+```
+
+Please note that changing the default value for a type can make you
+tests hard to understand. We recommend you to use this feature
+judiciously. For example, you may want to make sure the `Set()` and
+`Clear()` calls are right next to the code that uses your mock.
+
+## Setting the Default Actions for a Mock Method ##
+
+You've learned how to change the default value of a given
+type. However, this may be too coarse for your purpose: perhaps you
+have two mock methods with the same return type and you want them to
+have different behaviors. The `ON_CALL()` macro allows you to
+customize your mock's behavior at the method level:
+
+```
+using ::testing::_;
+using ::testing::AnyNumber;
+using ::testing::Gt;
+using ::testing::Return;
+...
+  ON_CALL(foo, Sign(_))
+      .WillByDefault(Return(-1));
+  ON_CALL(foo, Sign(0))
+      .WillByDefault(Return(0));
+  ON_CALL(foo, Sign(Gt(0)))
+      .WillByDefault(Return(1));
+
+  EXPECT_CALL(foo, Sign(_))
+      .Times(AnyNumber());
+
+  foo.Sign(5);   // This should return 1.
+  foo.Sign(-9);  // This should return -1.
+  foo.Sign(0);   // This should return 0.
+```
+
+As you may have guessed, when there are more than one `ON_CALL()`
+statements, the news order take precedence over the older ones. In
+other words, the **last** one that matches the function arguments will
+be used. This matching order allows you to set up the common behavior
+in a mock object's constructor or the test fixture's set-up phase and
+specialize the mock's behavior later.
+
+## Using Functions/Methods/Functors as Actions ##
+
+If the built-in actions don't suit you, you can easily use an existing
+function, method, or functor as an action:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD2(Sum, int(int x, int y));
+  MOCK_METHOD1(ComplexJob, bool(int x));
+};
+
+int CalculateSum(int x, int y) { return x + y; }
+
+class Helper {
+ public:
+  bool ComplexJob(int x);
+};
+...
+
+  MockFoo foo;
+  Helper helper;
+  EXPECT_CALL(foo, Sum(_, _))
+      .WillOnce(Invoke(CalculateSum));
+  EXPECT_CALL(foo, ComplexJob(_))
+      .WillOnce(Invoke(&helper, &Helper::ComplexJob));
+
+  foo.Sum(5, 6);       // Invokes CalculateSum(5, 6).
+  foo.ComplexJob(10);  // Invokes helper.ComplexJob(10);
+```
+
+The only requirement is that the type of the function, etc must be
+_compatible_ with the signature of the mock function, meaning that the
+latter's arguments can be implicitly converted to the corresponding
+arguments of the former, and the former's return type can be
+implicitly converted to that of the latter. So, you can invoke
+something whose type is _not_ exactly the same as the mock function,
+as long as it's safe to do so - nice, huh?
+
+## Invoking a Function/Method/Functor Without Arguments ##
+
+`Invoke()` is very useful for doing actions that are more complex. It
+passes the mock function's arguments to the function or functor being
+invoked such that the callee has the full context of the call to work
+with. If the invoked function is not interested in some or all of the
+arguments, it can simply ignore them.
+
+Yet, a common pattern is that a test author wants to invoke a function
+without the arguments of the mock function. `Invoke()` allows her to
+do that using a wrapper function that throws away the arguments before
+invoking an underlining nullary function. Needless to say, this can be
+tedious and obscures the intent of the test.
+
+`InvokeWithoutArgs()` solves this problem. It's like `Invoke()` except
+that it doesn't pass the mock function's arguments to the
+callee. Here's an example:
+
+```
+using ::testing::_;
+using ::testing::InvokeWithoutArgs;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(ComplexJob, bool(int n));
+};
+
+bool Job1() { ... }
+...
+
+  MockFoo foo;
+  EXPECT_CALL(foo, ComplexJob(_))
+      .WillOnce(InvokeWithoutArgs(Job1));
+
+  foo.ComplexJob(10);  // Invokes Job1().
+```
+
+## Invoking an Argument of the Mock Function ##
+
+Sometimes a mock function will receive a function pointer or a functor
+(in other words, a "callable") as an argument, e.g.
+
+```
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD2(DoThis, bool(int n, bool (*fp)(int)));
+};
+```
+
+and you may want to invoke this callable argument:
+
+```
+using ::testing::_;
+...
+  MockFoo foo;
+  EXPECT_CALL(foo, DoThis(_, _))
+      .WillOnce(...);
+  // Will execute (*fp)(5), where fp is the
+  // second argument DoThis() receives.
+```
+
+Arghh, you need to refer to a mock function argument but C++ has no
+lambda (yet), so you have to define your own action. :-( Or do you
+really?
+
+Well, Google Mock has an action to solve _exactly_ this problem:
+
+```
+  InvokeArgument<N>(arg_1, arg_2, ..., arg_m)
+```
+
+will invoke the `N`-th (0-based) argument the mock function receives,
+with `arg_1`, `arg_2`, ..., and `arg_m`. No matter if the argument is
+a function pointer or a functor, Google Mock handles them both.
+
+With that, you could write:
+
+```
+using ::testing::_;
+using ::testing::InvokeArgument;
+...
+  EXPECT_CALL(foo, DoThis(_, _))
+      .WillOnce(InvokeArgument<1>(5));
+  // Will execute (*fp)(5), where fp is the
+  // second argument DoThis() receives.
+```
+
+What if the callable takes an argument by reference? No problem - just
+wrap it inside `ByRef()`:
+
+```
+...
+  MOCK_METHOD1(Bar, bool(bool (*fp)(int, const Helper&)));
+...
+using ::testing::_;
+using ::testing::ByRef;
+using ::testing::InvokeArgument;
+...
+
+  MockFoo foo;
+  Helper helper;
+  ...
+  EXPECT_CALL(foo, Bar(_))
+      .WillOnce(InvokeArgument<0>(5, ByRef(helper)));
+  // ByRef(helper) guarantees that a reference to helper, not a copy of it,
+  // will be passed to the callable.
+```
+
+What if the callable takes an argument by reference and we do **not**
+wrap the argument in `ByRef()`? Then `InvokeArgument()` will _make a
+copy_ of the argument, and pass a _reference to the copy_, instead of
+a reference to the original value, to the callable. This is especially
+handy when the argument is a temporary value:
+
+```
+...
+  MOCK_METHOD1(DoThat, bool(bool (*f)(const double& x, const string& s)));
+...
+using ::testing::_;
+using ::testing::InvokeArgument;
+...
+
+  MockFoo foo;
+  ...
+  EXPECT_CALL(foo, DoThat(_))
+      .WillOnce(InvokeArgument<0>(5.0, string("Hi")));
+  // Will execute (*f)(5.0, string("Hi")), where f is the function pointer
+  // DoThat() receives.  Note that the values 5.0 and string("Hi") are
+  // temporary and dead once the EXPECT_CALL() statement finishes.  Yet
+  // it's fine to perform this action later, since a copy of the values
+  // are kept inside the InvokeArgument action.
+```
+
+## Ignoring an Action's Result ##
+
+Sometimes you have an action that returns _something_, but you need an
+action that returns `void` (perhaps you want to use it in a mock
+function that returns `void`, or perhaps it needs to be used in
+`DoAll()` and it's not the last in the list). `IgnoreResult()` lets
+you do that. For example:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Return;
+
+int Process(const MyData& data);
+string DoSomething();
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(Abc, void(const MyData& data));
+  MOCK_METHOD0(Xyz, bool());
+};
+...
+
+  MockFoo foo;
+  EXPECT_CALL(foo, Abc(_))
+  // .WillOnce(Invoke(Process));
+  // The above line won't compile as Process() returns int but Abc() needs
+  // to return void.
+      .WillOnce(IgnoreResult(Invoke(Process)));
+
+  EXPECT_CALL(foo, Xyz())
+      .WillOnce(DoAll(IgnoreResult(Invoke(DoSomething)),
+      // Ignores the string DoSomething() returns.
+                      Return(true)));
+```
+
+Note that you **cannot** use `IgnoreResult()` on an action that already
+returns `void`. Doing so will lead to ugly compiler errors.
+
+## Selecting an Action's Arguments ##
+
+Say you have a mock function `Foo()` that takes seven arguments, and
+you have a custom action that you want to invoke when `Foo()` is
+called. Trouble is, the custom action only wants three arguments:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+...
+  MOCK_METHOD7(Foo, bool(bool visible, const string& name, int x, int y,
+                         const map<pair<int, int>, double>& weight,
+                         double min_weight, double max_wight));
+...
+
+bool IsVisibleInQuadrant1(bool visible, int x, int y) {
+  return visible && x >= 0 && y >= 0;
+}
+...
+
+  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
+      .WillOnce(Invoke(IsVisibleInQuadrant1));  // Uh, won't compile. :-(
+```
+
+To please the compiler God, you can to define an "adaptor" that has
+the same signature as `Foo()` and calls the custom action with the
+right arguments:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+bool MyIsVisibleInQuadrant1(bool visible, const string& name, int x, int y,
+                            const map<pair<int, int>, double>& weight,
+                            double min_weight, double max_wight) {
+  return IsVisibleInQuadrant1(visible, x, y);
+}
+...
+
+  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
+      .WillOnce(Invoke(MyIsVisibleInQuadrant1));  // Now it works.
+```
+
+But isn't this awkward?
+
+Google Mock provides a generic _action adaptor_, so you can spend your
+time minding more important business than writing your own
+adaptors. Here's the syntax:
+
+```
+  WithArgs<N1, N2, ..., Nk>(action)
+```
+
+creates an action that passes the arguments of the mock function at
+the given indices (0-based) to the inner `action` and performs
+it. Using `WithArgs`, our original example can be written as:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::WithArgs;
+...
+  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
+      .WillOnce(WithArgs<0, 2, 3>(Invoke(IsVisibleInQuadrant1)));
+      // No need to define your own adaptor.
+```
+
+For better readability, Google Mock also gives you:
+
+  * `WithoutArgs(action)` when the inner `action` takes _no_ argument, and
+  * `WithArg<N>(action)` (no `s` after `Arg`) when the inner `action` takes _one_ argument.
+
+As you may have realized, `InvokeWithoutArgs(...)` is just syntactic
+sugar for `WithoutArgs(Invoke(...))`.
+
+Here are more tips:
+
+  * The inner action used in `WithArgs` and friends does not have to be `Invoke()` -- it can be anything.
+  * You can repeat an argument in the argument list if necessary, e.g. `WithArgs<2, 3, 3, 5>(...)`.
+  * You can change the order of the arguments, e.g. `WithArgs<3, 2, 1>(...)`.
+  * The types of the selected arguments do _not_ have to match the signature of the inner action exactly. It works as long as they can be implicitly converted to the corresponding arguments of the inner action. For example, if the 4-th argument of the mock function is an `int` and `my_action` takes a `double`, `WithArg<4>(my_action)` will work.
+
+## Ignoring Arguments in Action Functions ##
+
+The selecting-an-action's-arguments recipe showed us one way to make a
+mock function and an action with incompatible argument lists fit
+together. The downside is that wrapping the action in
+`WithArgs<...>()` can get tedious for people writing the tests.
+
+If you are defining a function, method, or functor to be used with
+`Invoke*()`, and you are not interested in some of its arguments, an
+alternative to `WithArgs` is to declare the uninteresting arguments as
+`Unused`. This makes the definition less cluttered and less fragile in
+case the types of the uninteresting arguments change. It could also
+increase the chance the action function can be reused. For example,
+given
+
+```
+  MOCK_METHOD3(Foo, double(const string& label, double x, double y));
+  MOCK_METHOD3(Bar, double(int index, double x, double y));
+```
+
+instead of
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+double DistanceToOriginWithLabel(const string& label, double x, double y) {
+  return sqrt(x*x + y*y);
+}
+
+double DistanceToOriginWithIndex(int index, double x, double y) {
+  return sqrt(x*x + y*y);
+}
+...
+
+  EXEPCT_CALL(mock, Foo("abc", _, _))
+      .WillOnce(Invoke(DistanceToOriginWithLabel));
+  EXEPCT_CALL(mock, Bar(5, _, _))
+      .WillOnce(Invoke(DistanceToOriginWithIndex));
+```
+
+you could write
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Unused;
+
+double DistanceToOrigin(Unused, double x, double y) {
+  return sqrt(x*x + y*y);
+}
+...
+
+  EXEPCT_CALL(mock, Foo("abc", _, _))
+      .WillOnce(Invoke(DistanceToOrigin));
+  EXEPCT_CALL(mock, Bar(5, _, _))
+      .WillOnce(Invoke(DistanceToOrigin));
+```
+
+## Sharing Actions ##
+
+Just like matchers, a Google Mock action object consists of a pointer
+to a ref-counted implementation object. Therefore copying actions is
+also allowed and very efficient. When the last action that references
+the implementation object dies, the implementation object will be
+deleted.
+
+If you have some complex action that you want to use again and again,
+you may not have to build it from scratch everytime. If the action
+doesn't have an internal state (i.e. if it always does the same thing
+no matter how many times it has been called), you can assign it to an
+action variable and use that variable repeatedly. For example:
+
+```
+  Action<bool(int*)> set_flag = DoAll(SetArgPointee<0>(5),
+                                      Return(true));
+  ... use set_flag in .WillOnce() and .WillRepeatedly() ...
+```
+
+However, if the action has its own state, you may be surprised if you
+share the action object. Suppose you have an action factory
+`IncrementCounter(init)` which creates an action that increments and
+returns a counter whose initial value is `init`, using two actions
+created from the same expression and using a shared action will
+exihibit different behaviors. Example:
+
+```
+  EXPECT_CALL(foo, DoThis())
+      .WillRepeatedly(IncrementCounter(0));
+  EXPECT_CALL(foo, DoThat())
+      .WillRepeatedly(IncrementCounter(0));
+  foo.DoThis();  // Returns 1.
+  foo.DoThis();  // Returns 2.
+  foo.DoThat();  // Returns 1 - Blah() uses a different
+                 // counter than Bar()'s.
+```
+
+versus
+
+```
+  Action<int()> increment = IncrementCounter(0);
+
+  EXPECT_CALL(foo, DoThis())
+      .WillRepeatedly(increment);
+  EXPECT_CALL(foo, DoThat())
+      .WillRepeatedly(increment);
+  foo.DoThis();  // Returns 1.
+  foo.DoThis();  // Returns 2.
+  foo.DoThat();  // Returns 3 - the counter is shared.
+```
+
+# Misc Recipes on Using Google Mock #
+
+## Mocking Methods That Use Move-Only Types ##
+
+C++11 introduced <em>move-only types</em>.  A move-only-typed value can be moved from one object to another, but cannot be copied.  `std::unique_ptr<T>` is probably the most commonly used move-only type.
+
+Mocking a method that takes and/or returns move-only types presents some challenges, but nothing insurmountable.  This recipe shows you how you can do it.
+
+Let’s say we are working on a fictional project that lets one post and share snippets called “buzzes”.  Your code uses these types:
+
+```
+enum class AccessLevel { kInternal, kPublic };
+
+class Buzz {
+ public:
+  explicit Buzz(AccessLevel access) { … }
+  ...
+};
+
+class Buzzer {
+ public:
+  virtual ~Buzzer() {}
+  virtual std::unique_ptr<Buzz> MakeBuzz(const std::string& text) = 0;
+  virtual bool ShareBuzz(std::unique_ptr<Buzz> buzz, Time timestamp) = 0;
+  ...
+};
+```
+
+A `Buzz` object represents a snippet being posted.  A class that implements the `Buzzer` interface is capable of creating and sharing `Buzz`.  Methods in `Buzzer` may return a `unique_ptr<Buzz>` or take a `unique_ptr<Buzz>`.  Now we need to mock `Buzzer` in our tests.
+
+To mock a method that returns a move-only type, you just use the familiar `MOCK_METHOD` syntax as usual:
+
+```
+class MockBuzzer : public Buzzer {
+ public:
+  MOCK_METHOD1(MakeBuzz, std::unique_ptr<Buzz>(const std::string& text));
+  …
+};
+```
+
+However, if you attempt to use the same `MOCK_METHOD` pattern to mock a method that takes a move-only parameter, you’ll get a compiler error currently:
+
+```
+  // Does NOT compile!
+  MOCK_METHOD2(ShareBuzz, bool(std::unique_ptr<Buzz> buzz, Time timestamp));
+```
+
+While it’s highly desirable to make this syntax just work, it’s not trivial and the work hasn’t been done yet.  Fortunately, there is a trick you can apply today to get something that works nearly as well as this.
+
+The trick, is to delegate the `ShareBuzz()` method to a mock method (let’s call it `DoShareBuzz()`) that does not take move-only parameters:
+
+```
+class MockBuzzer : public Buzzer {
+ public:
+  MOCK_METHOD1(MakeBuzz, std::unique_ptr<Buzz>(const std::string& text));
+  MOCK_METHOD2(DoShareBuzz, bool(Buzz* buzz, Time timestamp));
+  bool ShareBuzz(std::unique_ptr<Buzz> buzz, Time timestamp) {
+    return DoShareBuzz(buzz.get(), timestamp);
+  }
+};
+```
+
+Note that there's no need to define or declare `DoShareBuzz()` in a base class.  You only need to define it as a `MOCK_METHOD` in the mock class.
+
+Now that we have the mock class defined, we can use it in tests.  In the following code examples, we assume that we have defined a `MockBuzzer` object named `mock_buzzer_`:
+
+```
+  MockBuzzer mock_buzzer_;
+```
+
+First let’s see how we can set expectations on the `MakeBuzz()` method, which returns a `unique_ptr<Buzz>`.
+
+As usual, if you set an expectation without an action (i.e. the `.WillOnce()` or `.WillRepeated()` clause), when that expectation fires, the default action for that method will be taken.  Since `unique_ptr<>` has a default constructor that returns a null `unique_ptr`, that’s what you’ll get if you don’t specify an action:
+
+```
+  // Use the default action.
+  EXPECT_CALL(mock_buzzer_, MakeBuzz("hello"));
+
+  // Triggers the previous EXPECT_CALL.
+  EXPECT_EQ(nullptr, mock_buzzer_.MakeBuzz("hello"));
+```
+
+If you are not happy with the default action, you can tweak it.  Depending on what you need, you may either tweak the default action for a specific (mock object, mock method) combination using `ON_CALL()`, or you may tweak the default action for all mock methods that return a specific type.  The usage of `ON_CALL()` is similar to `EXPECT_CALL()`, so we’ll skip it and just explain how to do the latter (tweaking the default action for a specific return type).  You do this via the `DefaultValue<>::SetFactory()` and `DefaultValue<>::Clear()` API:
+
+```
+  // Sets the default action for return type std::unique_ptr<Buzz> to
+  // creating a new Buzz every time.
+  DefaultValue<std::unique_ptr<Buzz>>::SetFactory(
+      [] { return MakeUnique<Buzz>(AccessLevel::kInternal); });
+
+  // When this fires, the default action of MakeBuzz() will run, which
+  // will return a new Buzz object.
+  EXPECT_CALL(mock_buzzer_, MakeBuzz("hello")).Times(AnyNumber());
+
+  auto buzz1 = mock_buzzer_.MakeBuzz("hello");
+  auto buzz2 = mock_buzzer_.MakeBuzz("hello");
+  EXPECT_NE(nullptr, buzz1);
+  EXPECT_NE(nullptr, buzz2);
+  EXPECT_NE(buzz1, buzz2);
+
+  // Resets the default action for return type std::unique_ptr<Buzz>,
+  // to avoid interfere with other tests.
+  DefaultValue<std::unique_ptr<Buzz>>::Clear();
+```
+
+What if you want the method to do something other than the default action?  If you just need to return a pre-defined move-only value, you can use the `Return(ByMove(...))` action:
+
+```
+  // When this fires, the unique_ptr<> specified by ByMove(...) will
+  // be returned.
+  EXPECT_CALL(mock_buzzer_, MakeBuzz("world"))
+      .WillOnce(Return(ByMove(MakeUnique<Buzz>(AccessLevel::kInternal))));
+
+  EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("world"));
+```
+
+Note that `ByMove()` is essential here - if you drop it, the code won’t compile.
+
+Quiz time!  What do you think will happen if a `Return(ByMove(...))` action is performed more than once (e.g. you write `….WillRepeatedly(Return(ByMove(...)));`)?  Come think of it, after the first time the action runs, the source value will be consumed (since it’s a move-only value), so the next time around, there’s no value to move from -- you’ll get a run-time error that `Return(ByMove(...))` can only be run once.
+
+If you need your mock method to do more than just moving a pre-defined value, remember that you can always use `Invoke()` to call a lambda or a callable object, which can do pretty much anything you want:
+
+```
+  EXPECT_CALL(mock_buzzer_, MakeBuzz("x"))
+      .WillRepeatedly(Invoke([](const std::string& text) {
+        return std::make_unique<Buzz>(AccessLevel::kInternal);
+      }));
+
+  EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("x"));
+  EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("x"));
+```
+
+Every time this `EXPECT_CALL` fires, a new `unique_ptr<Buzz>` will be created and returned.  You cannot do this with `Return(ByMove(...))`.
+
+Now there’s one topic we haven’t covered: how do you set expectations on `ShareBuzz()`, which takes a move-only-typed parameter?  The answer is you don’t.  Instead, you set expectations on the `DoShareBuzz()` mock method (remember that we defined a `MOCK_METHOD` for `DoShareBuzz()`, not `ShareBuzz()`):
+
+```
+  EXPECT_CALL(mock_buzzer_, DoShareBuzz(NotNull(), _));
+
+  // When one calls ShareBuzz() on the MockBuzzer like this, the call is
+  // forwarded to DoShareBuzz(), which is mocked.  Therefore this statement
+  // will trigger the above EXPECT_CALL.
+  mock_buzzer_.ShareBuzz(MakeUnique&lt;Buzz&gt;(AccessLevel::kInternal),
+                         ::base::Now());
+```
+
+Some of you may have spotted one problem with this approach: the `DoShareBuzz()` mock method differs from the real `ShareBuzz()` method in that it cannot take ownership of the buzz parameter - `ShareBuzz()` will always delete buzz after `DoShareBuzz()` returns.  What if you need to save the buzz object somewhere for later use when `ShareBuzz()` is called?  Indeed, you'd be stuck.
+
+Another problem with the `DoShareBuzz()` we had is that it can surprise people reading or maintaining the test, as one would expect that `DoShareBuzz()` has (logically) the same contract as `ShareBuzz()`.
+
+Fortunately, these problems can be fixed with a bit more code.  Let's try to get it right this time:
+
+```
+class MockBuzzer : public Buzzer {
+ public:
+  MockBuzzer() {
+    // Since DoShareBuzz(buzz, time) is supposed to take ownership of
+    // buzz, define a default behavior for DoShareBuzz(buzz, time) to
+    // delete buzz.
+    ON_CALL(*this, DoShareBuzz(_, _))
+        .WillByDefault(Invoke([](Buzz* buzz, Time timestamp) {
+          delete buzz;
+          return true;
+        }));
+  }
+
+  MOCK_METHOD1(MakeBuzz, std::unique_ptr<Buzz>(const std::string& text));
+
+  // Takes ownership of buzz.
+  MOCK_METHOD2(DoShareBuzz, bool(Buzz* buzz, Time timestamp));
+  bool ShareBuzz(std::unique_ptr<Buzz> buzz, Time timestamp) {
+    return DoShareBuzz(buzz.release(), timestamp);
+  }
+};
+```
+
+Now, the mock `DoShareBuzz()` method is free to save the buzz argument for later use if this is what you want:
+
+```
+  std::unique_ptr<Buzz> intercepted_buzz;
+  EXPECT_CALL(mock_buzzer_, DoShareBuzz(NotNull(), _))
+      .WillOnce(Invoke([&amp;intercepted_buzz](Buzz* buzz, Time timestamp) {
+        // Save buzz in intercepted_buzz for analysis later.
+        intercepted_buzz.reset(buzz);
+        return false;
+      }));
+
+  mock_buzzer_.ShareBuzz(std::make_unique<Buzz>(AccessLevel::kInternal),
+                         Now());
+  EXPECT_NE(nullptr, intercepted_buzz);
+```
+
+Using the tricks covered in this recipe, you are now able to mock methods that take and/or return move-only types.  Put your newly-acquired power to good use - when you design a new API, you can now feel comfortable using `unique_ptrs` as appropriate, without fearing that doing so will compromise your tests.
+
+## Making the Compilation Faster ##
+
+Believe it or not, the _vast majority_ of the time spent on compiling
+a mock class is in generating its constructor and destructor, as they
+perform non-trivial tasks (e.g. verification of the
+expectations). What's more, mock methods with different signatures
+have different types and thus their constructors/destructors need to
+be generated by the compiler separately. As a result, if you mock many
+different types of methods, compiling your mock class can get really
+slow.
+
+If you are experiencing slow compilation, you can move the definition
+of your mock class' constructor and destructor out of the class body
+and into a `.cpp` file. This way, even if you `#include` your mock
+class in N files, the compiler only needs to generate its constructor
+and destructor once, resulting in a much faster compilation.
+
+Let's illustrate the idea using an example. Here's the definition of a
+mock class before applying this recipe:
+
+```
+// File mock_foo.h.
+...
+class MockFoo : public Foo {
+ public:
+  // Since we don't declare the constructor or the destructor,
+  // the compiler will generate them in every translation unit
+  // where this mock class is used.
+
+  MOCK_METHOD0(DoThis, int());
+  MOCK_METHOD1(DoThat, bool(const char* str));
+  ... more mock methods ...
+};
+```
+
+After the change, it would look like:
+
+```
+// File mock_foo.h.
+...
+class MockFoo : public Foo {
+ public:
+  // The constructor and destructor are declared, but not defined, here.
+  MockFoo();
+  virtual ~MockFoo();
+
+  MOCK_METHOD0(DoThis, int());
+  MOCK_METHOD1(DoThat, bool(const char* str));
+  ... more mock methods ...
+};
+```
+and
+```
+// File mock_foo.cpp.
+#include "path/to/mock_foo.h"
+
+// The definitions may appear trivial, but the functions actually do a
+// lot of things through the constructors/destructors of the member
+// variables used to implement the mock methods.
+MockFoo::MockFoo() {}
+MockFoo::~MockFoo() {}
+```
+
+## Forcing a Verification ##
+
+When it's being destoyed, your friendly mock object will automatically
+verify that all expectations on it have been satisfied, and will
+generate [Google Test](../../googletest/) failures
+if not. This is convenient as it leaves you with one less thing to
+worry about. That is, unless you are not sure if your mock object will
+be destoyed.
+
+How could it be that your mock object won't eventually be destroyed?
+Well, it might be created on the heap and owned by the code you are
+testing. Suppose there's a bug in that code and it doesn't delete the
+mock object properly - you could end up with a passing test when
+there's actually a bug.
+
+Using a heap checker is a good idea and can alleviate the concern, but
+its implementation may not be 100% reliable. So, sometimes you do want
+to _force_ Google Mock to verify a mock object before it is
+(hopefully) destructed. You can do this with
+`Mock::VerifyAndClearExpectations(&mock_object)`:
+
+```
+TEST(MyServerTest, ProcessesRequest) {
+  using ::testing::Mock;
+
+  MockFoo* const foo = new MockFoo;
+  EXPECT_CALL(*foo, ...)...;
+  // ... other expectations ...
+
+  // server now owns foo.
+  MyServer server(foo);
+  server.ProcessRequest(...);
+
+  // In case that server's destructor will forget to delete foo,
+  // this will verify the expectations anyway.
+  Mock::VerifyAndClearExpectations(foo);
+}  // server is destroyed when it goes out of scope here.
+```
+
+**Tip:** The `Mock::VerifyAndClearExpectations()` function returns a
+`bool` to indicate whether the verification was successful (`true` for
+yes), so you can wrap that function call inside a `ASSERT_TRUE()` if
+there is no point going further when the verification has failed.
+
+## Using Check Points ##
+
+Sometimes you may want to "reset" a mock object at various check
+points in your test: at each check point, you verify that all existing
+expectations on the mock object have been satisfied, and then you set
+some new expectations on it as if it's newly created. This allows you
+to work with a mock object in "phases" whose sizes are each
+manageable.
+
+One such scenario is that in your test's `SetUp()` function, you may
+want to put the object you are testing into a certain state, with the
+help from a mock object. Once in the desired state, you want to clear
+all expectations on the mock, such that in the `TEST_F` body you can
+set fresh expectations on it.
+
+As you may have figured out, the `Mock::VerifyAndClearExpectations()`
+function we saw in the previous recipe can help you here. Or, if you
+are using `ON_CALL()` to set default actions on the mock object and
+want to clear the default actions as well, use
+`Mock::VerifyAndClear(&mock_object)` instead. This function does what
+`Mock::VerifyAndClearExpectations(&mock_object)` does and returns the
+same `bool`, **plus** it clears the `ON_CALL()` statements on
+`mock_object` too.
+
+Another trick you can use to achieve the same effect is to put the
+expectations in sequences and insert calls to a dummy "check-point"
+function at specific places. Then you can verify that the mock
+function calls do happen at the right time. 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:
+
+```
+using ::testing::MockFunction;
+
+TEST(FooTest, InvokesBarCorrectly) {
+  MyMock mock;
+  // Class MockFunction<F> has exactly one mock method.  It is named
+  // Call() and has type F.
+  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()`.
+
+## Mocking Destructors ##
+
+Sometimes you want to make sure a mock object is destructed at the
+right time, e.g. after `bar->A()` is called but before `bar->B()` is
+called. We already know that you can specify constraints on the order
+of mock function calls, so all we need to do is to mock the destructor
+of the mock function.
+
+This sounds simple, except for one problem: a destructor is a special
+function with special syntax and special semantics, and the
+`MOCK_METHOD0` macro doesn't work for it:
+
+```
+  MOCK_METHOD0(~MockFoo, void());  // Won't compile!
+```
+
+The good news is that you can use a simple pattern to achieve the same
+effect. First, add a mock function `Die()` to your mock class and call
+it in the destructor, like this:
+
+```
+class MockFoo : public Foo {
+  ...
+  // Add the following two lines to the mock class.
+  MOCK_METHOD0(Die, void());
+  virtual ~MockFoo() { Die(); }
+};
+```
+
+(If the name `Die()` clashes with an existing symbol, choose another
+name.) Now, we have translated the problem of testing when a `MockFoo`
+object dies to testing when its `Die()` method is called:
+
+```
+  MockFoo* foo = new MockFoo;
+  MockBar* bar = new MockBar;
+  ...
+  {
+    InSequence s;
+
+    // Expects *foo to die after bar->A() and before bar->B().
+    EXPECT_CALL(*bar, A());
+    EXPECT_CALL(*foo, Die());
+    EXPECT_CALL(*bar, B());
+  }
+```
+
+And that's that.
+
+## Using Google Mock and Threads ##
+
+**IMPORTANT NOTE:** What we describe in this recipe is **ONLY** true on
+platforms where Google Mock is thread-safe. Currently these are only
+platforms that support the pthreads library (this includes Linux and Mac).
+To make it thread-safe on other platforms we only need to implement
+some synchronization operations in `"gtest/internal/gtest-port.h"`.
+
+In a **unit** test, it's best if you could isolate and test a piece of
+code in a single-threaded context. That avoids race conditions and
+dead locks, and makes debugging your test much easier.
+
+Yet many programs are multi-threaded, and sometimes to test something
+we need to pound on it from more than one thread. Google Mock works
+for this purpose too.
+
+Remember the steps for using a mock:
+
+  1. Create a mock object `foo`.
+  1. Set its default actions and expectations using `ON_CALL()` and `EXPECT_CALL()`.
+  1. The code under test calls methods of `foo`.
+  1. Optionally, verify and reset the mock.
+  1. Destroy the mock yourself, or let the code under test destroy it. The destructor will automatically verify it.
+
+If you follow the following simple rules, your mocks and threads can
+live happily together:
+
+  * Execute your _test code_ (as opposed to the code being tested) in _one_ thread. This makes your test easy to follow.
+  * Obviously, you can do step #1 without locking.
+  * When doing step #2 and #5, make sure no other thread is accessing `foo`. Obvious too, huh?
+  * #3 and #4 can be done either in one thread or in multiple threads - anyway you want. Google Mock takes care of the locking, so you don't have to do any - unless required by your test logic.
+
+If you violate the rules (for example, if you set expectations on a
+mock while another thread is calling its methods), you get undefined
+behavior. That's not fun, so don't do it.
+
+Google Mock guarantees that the action for a mock function is done in
+the same thread that called the mock function. For example, in
+
+```
+  EXPECT_CALL(mock, Foo(1))
+      .WillOnce(action1);
+  EXPECT_CALL(mock, Foo(2))
+      .WillOnce(action2);
+```
+
+if `Foo(1)` is called in thread 1 and `Foo(2)` is called in thread 2,
+Google Mock will execute `action1` in thread 1 and `action2` in thread
+2.
+
+Google Mock does _not_ impose a sequence on actions performed in
+different threads (doing so may create deadlocks as the actions may
+need to cooperate). This means that the execution of `action1` and
+`action2` in the above example _may_ interleave. If this is a problem,
+you should add proper synchronization logic to `action1` and `action2`
+to make the test thread-safe.
+
+
+Also, remember that `DefaultValue<T>` is a global resource that
+potentially affects _all_ living mock objects in your
+program. Naturally, you won't want to mess with it from multiple
+threads or when there still are mocks in action.
+
+## Controlling How Much Information Google Mock Prints ##
+
+When Google Mock sees something that has the potential of being an
+error (e.g. a mock function with no expectation is called, a.k.a. an
+uninteresting call, which is allowed but perhaps you forgot to
+explicitly ban the call), it prints some warning messages, including
+the arguments of the function and the return value. Hopefully this
+will remind you to take a look and see if there is indeed a problem.
+
+Sometimes you are confident that your tests are correct and may not
+appreciate such friendly messages. Some other times, you are debugging
+your tests or learning about the behavior of the code you are testing,
+and wish you could observe every mock call that happens (including
+argument values and the return value). Clearly, one size doesn't fit
+all.
+
+You can control how much Google Mock tells you using the
+`--gmock_verbose=LEVEL` command-line flag, where `LEVEL` is a string
+with three possible values:
+
+  * `info`: Google Mock will print all informational messages, warnings, and errors (most verbose). At this setting, Google Mock will also log any calls to the `ON_CALL/EXPECT_CALL` macros.
+  * `warning`: Google Mock will print both warnings and errors (less verbose). This is the default.
+  * `error`: Google Mock will print errors only (least verbose).
+
+Alternatively, you can adjust the value of that flag from within your
+tests like so:
+
+```
+  ::testing::FLAGS_gmock_verbose = "error";
+```
+
+Now, judiciously use the right flag to enable Google Mock serve you better!
+
+## Gaining Super Vision into Mock Calls ##
+
+You have a test using Google Mock. It fails: Google Mock tells you
+that some expectations aren't satisfied. However, you aren't sure why:
+Is there a typo somewhere in the matchers? Did you mess up the order
+of the `EXPECT_CALL`s? Or is the code under test doing something
+wrong?  How can you find out the cause?
+
+Won't it be nice if you have X-ray vision and can actually see the
+trace of all `EXPECT_CALL`s and mock method calls as they are made?
+For each call, would you like to see its actual argument values and
+which `EXPECT_CALL` Google Mock thinks it matches?
+
+You can unlock this power by running your test with the
+`--gmock_verbose=info` flag. For example, given the test program:
+
+```
+using testing::_;
+using testing::HasSubstr;
+using testing::Return;
+
+class MockFoo {
+ public:
+  MOCK_METHOD2(F, void(const string& x, const string& y));
+};
+
+TEST(Foo, Bar) {
+  MockFoo mock;
+  EXPECT_CALL(mock, F(_, _)).WillRepeatedly(Return());
+  EXPECT_CALL(mock, F("a", "b"));
+  EXPECT_CALL(mock, F("c", HasSubstr("d")));
+
+  mock.F("a", "good");
+  mock.F("a", "b");
+}
+```
+
+if you run it with `--gmock_verbose=info`, you will see this output:
+
+```
+[ RUN      ] Foo.Bar
+
+foo_test.cc:14: EXPECT_CALL(mock, F(_, _)) invoked
+foo_test.cc:15: EXPECT_CALL(mock, F("a", "b")) invoked
+foo_test.cc:16: EXPECT_CALL(mock, F("c", HasSubstr("d"))) invoked
+foo_test.cc:14: Mock function call matches EXPECT_CALL(mock, F(_, _))...
+    Function call: F(@0x7fff7c8dad40"a", @0x7fff7c8dad10"good")
+foo_test.cc:15: Mock function call matches EXPECT_CALL(mock, F("a", "b"))...
+    Function call: F(@0x7fff7c8dada0"a", @0x7fff7c8dad70"b")
+foo_test.cc:16: Failure
+Actual function call count doesn't match EXPECT_CALL(mock, F("c", HasSubstr("d")))...
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] Foo.Bar
+```
+
+Suppose the bug is that the `"c"` in the third `EXPECT_CALL` is a typo
+and should actually be `"a"`. With the above message, you should see
+that the actual `F("a", "good")` call is matched by the first
+`EXPECT_CALL`, not the third as you thought. From that it should be
+obvious that the third `EXPECT_CALL` is written wrong. Case solved.
+
+## Running Tests in Emacs ##
+
+If you build and run your tests in Emacs, the source file locations of
+Google Mock and [Google Test](../../googletest/)
+errors will be highlighted. Just press `<Enter>` on one of them and
+you'll be taken to the offending line. Or, you can just type `C-x ``
+to jump to the next error.
+
+To make it even easier, you can add the following lines to your
+`~/.emacs` file:
+
+```
+(global-set-key "\M-m"   'compile)  ; m is for make
+(global-set-key [M-down] 'next-error)
+(global-set-key [M-up]   '(lambda () (interactive) (next-error -1)))
+```
+
+Then you can type `M-m` to start a build, or `M-up`/`M-down` to move
+back and forth between errors.
+
+## Fusing Google Mock Source Files ##
+
+Google Mock's implementation consists of dozens of files (excluding
+its own tests).  Sometimes you may want them to be packaged up in
+fewer files instead, such that you can easily copy them to a new
+machine and start hacking there.  For this we provide an experimental
+Python script `fuse_gmock_files.py` in the `scripts/` directory
+(starting with release 1.2.0).  Assuming you have Python 2.4 or above
+installed on your machine, just go to that directory and run
+```
+python fuse_gmock_files.py OUTPUT_DIR
+```
+
+and you should see an `OUTPUT_DIR` directory being created with files
+`gtest/gtest.h`, `gmock/gmock.h`, and `gmock-gtest-all.cc` in it.
+These three files contain everything you need to use Google Mock (and
+Google Test).  Just copy them to anywhere you want and you are ready
+to write tests and use mocks.  You can use the
+[scrpts/test/Makefile](../scripts/test/Makefile) file as an example on how to compile your tests
+against them.
+
+# Extending Google Mock #
+
+## Writing New Matchers Quickly ##
+
+The `MATCHER*` family of macros can be used to define custom matchers
+easily.  The syntax:
+
+```
+MATCHER(name, description_string_expression) { statements; }
+```
+
+will define 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 is a `string`-typed expression that documents
+what the matcher does, and is used to generate the failure message
+when the match fails.  It can (and should) reference the special
+`bool` variable `negation`, and should evaluate to the description of
+the matcher when `negation` is `false`, or that of the matcher's
+negation when `negation` is `true`.
+
+For convenience, we allow the description string to be empty (`""`),
+in which case Google Mock will use the sequence of words in the
+matcher name as the description.
+
+For example:
+```
+MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; }
+```
+allows you to write
+```
+  // Expects mock_foo.Bar(n) to be called where n is divisible by 7.
+  EXPECT_CALL(mock_foo, Bar(IsDivisibleBy7()));
+```
+or,
+```
+using ::testing::Not;
+...
+  EXPECT_THAT(some_expression, IsDivisibleBy7());
+  EXPECT_THAT(some_other_expression, Not(IsDivisibleBy7()));
+```
+If the above assertions fail, they will print something like:
+```
+  Value of: some_expression
+  Expected: is divisible by 7
+    Actual: 27
+...
+  Value of: some_other_expression
+  Expected: not (is divisible by 7)
+    Actual: 21
+```
+where the descriptions `"is divisible by 7"` and `"not (is divisible
+by 7)"` are automatically calculated from the matcher name
+`IsDivisibleBy7`.
+
+As you may have noticed, the auto-generated descriptions (especially
+those for the negation) may not be so great. You can always override
+them with a string expression of your own:
+```
+MATCHER(IsDivisibleBy7, std::string(negation ? "isn't" : "is") +
+                        " divisible by 7") {
+  return (arg % 7) == 0;
+}
+```
+
+Optionally, you can stream additional information to a hidden argument
+named `result_listener` to explain the match result. For example, a
+better definition of `IsDivisibleBy7` is:
+```
+MATCHER(IsDivisibleBy7, "") {
+  if ((arg % 7) == 0)
+    return true;
+
+  *result_listener << "the remainder is " << (arg % 7);
+  return false;
+}
+```
+
+With this definition, the above assertion will give a better message:
+```
+  Value of: some_expression
+  Expected: is divisible by 7
+    Actual: 27 (the remainder is 6)
+```
+
+You should let `MatchAndExplain()` print _any additional information_
+that can help a user understand the match result. Note that it should
+explain why the match succeeds in case of a success (unless it's
+obvious) - this is useful when the matcher is used inside
+`Not()`. There is no need to print the argument value itself, as
+Google Mock already prints it for you.
+
+**Notes:**
+
+  1. 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, `IsDivisibleBy7()` can be used to match any type where the value of `(arg % 7) == 0` can be implicitly converted to a `bool`.  In the `Bar(IsDivisibleBy7())` 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.
+  1. Google Mock doesn't guarantee when or how many times a matcher will be invoked. Therefore the matcher logic must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters). This requirement must be satisfied no matter how you define the matcher (e.g. using one of the methods described in the following recipes). In particular, a matcher can never call a mock function, as that will affect the state of the mock object and Google Mock.
+
+## Writing New Parameterized Matchers Quickly ##
+
+Sometimes you'll want to define a matcher that has parameters.  For that you
+can use the macro:
+```
+MATCHER_P(name, param_name, description_string) { statements; }
+```
+where the description string can be either `""` or a string expression
+that references `negation` and `param_name`.
+
+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`.
+
+Google Mock also provides `MATCHER_P2`, `MATCHER_P3`, ..., up to
+`MATCHER_P10` to support multi-parameter matchers:
+```
+MATCHER_Pk(name, param_1, ..., param_k, description_string) { statements; }
+```
+
+Please note that the custom description string is for a particular
+**instance** of the matcher, where the parameters have been bound to
+actual values.  Therefore usually you'll want the parameter values to
+be part of the description.  Google Mock lets you do that by
+referencing the matcher parameters in the description string
+expression.
+
+For example,
+```
+  using ::testing::PrintToString;
+  MATCHER_P2(InClosedRange, low, hi,
+             std::string(negation ? "isn't" : "is") + " in range [" +
+             PrintToString(low) + ", " + PrintToString(hi) + "]") {
+    return low <= arg && arg <= hi;
+  }
+  ...
+  EXPECT_THAT(3, InClosedRange(4, 6));
+```
+would generate a failure that contains the message:
+```
+  Expected: is in range [4, 6]
+```
+
+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));
+```
+would generate a failure that contains the text:
+```
+  Expected: in closed range (4, 6)
+```
+
+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.  Matchers that don't have a parameter
+or have only one parameter have special types: you can assign `Foo()`
+to a `FooMatcher`-typed variable, and assign `Foo(p)` to a
+`FooMatcherP<p_type>`-typed variable.
+
+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.
+
+You can overload matchers with different numbers of parameters:
+```
+MATCHER_P(Blah, a, description_string_1) { ... }
+MATCHER_P2(Blah, a, b, description_string_2) { ... }
+```
+
+While it's tempting to always use the `MATCHER*` macros when defining
+a new matcher, you should also consider implementing
+`MatcherInterface` or using `MakePolymorphicMatcher()` instead (see
+the recipes that follow), especially if you need to use the matcher a
+lot.  While these approaches require more work, they give you more
+control on the types of the value being matched and the matcher
+parameters, which in general leads to better compiler error messages
+that pay off in the long run.  They also allow overloading matchers
+based on parameter types (as opposed to just based on the number of
+parameters).
+
+## Writing New Monomorphic Matchers ##
+
+A matcher of argument type `T` implements
+`::testing::MatcherInterface<T>` and does two things: it tests whether a
+value of type `T` matches the matcher, and can describe what kind of
+values it matches. The latter ability is used for generating readable
+error messages when expectations are violated.
+
+The interface looks like this:
+
+```
+class MatchResultListener {
+ public:
+  ...
+  // Streams x to the underlying ostream; does nothing if the ostream
+  // is NULL.
+  template <typename T>
+  MatchResultListener& operator<<(const T& x);
+
+  // Returns the underlying ostream.
+  ::std::ostream* stream();
+};
+
+template <typename T>
+class MatcherInterface {
+ public:
+  virtual ~MatcherInterface();
+
+  // Returns true iff the matcher matches x; also explains the match
+  // result to 'listener'.
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
+
+  // Describes this matcher to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+
+  // Describes the negation of this matcher to an ostream.
+  virtual void DescribeNegationTo(::std::ostream* os) const;
+};
+```
+
+If you need a custom matcher but `Truly()` is not a good option (for
+example, you may not be happy with the way `Truly(predicate)`
+describes itself, or you may want your matcher to be polymorphic as
+`Eq(value)` is), you can define a matcher to do whatever you want in
+two steps: first implement the matcher interface, and then define a
+factory function to create a matcher instance. The second step is not
+strictly needed but it makes the syntax of using the matcher nicer.
+
+For example, you can define a matcher to test whether an `int` is
+divisible by 7 and then use it like this:
+```
+using ::testing::MakeMatcher;
+using ::testing::Matcher;
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+
+class DivisibleBy7Matcher : public MatcherInterface<int> {
+ public:
+  virtual bool MatchAndExplain(int n, MatchResultListener* listener) const {
+    return (n % 7) == 0;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "is divisible by 7";
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is not divisible by 7";
+  }
+};
+
+inline Matcher<int> DivisibleBy7() {
+  return MakeMatcher(new DivisibleBy7Matcher);
+}
+...
+
+  EXPECT_CALL(foo, Bar(DivisibleBy7()));
+```
+
+You may improve the matcher message by streaming additional
+information to the `listener` argument in `MatchAndExplain()`:
+
+```
+class DivisibleBy7Matcher : public MatcherInterface<int> {
+ public:
+  virtual bool MatchAndExplain(int n,
+                               MatchResultListener* listener) const {
+    const int remainder = n % 7;
+    if (remainder != 0) {
+      *listener << "the remainder is " << remainder;
+    }
+    return remainder == 0;
+  }
+  ...
+};
+```
+
+Then, `EXPECT_THAT(x, DivisibleBy7());` may general a message like this:
+```
+Value of: x
+Expected: is divisible by 7
+  Actual: 23 (the remainder is 2)
+```
+
+## Writing New Polymorphic Matchers ##
+
+You've learned how to write your own matchers in the previous
+recipe. Just one problem: a matcher created using `MakeMatcher()` only
+works for one particular type of arguments. If you want a
+_polymorphic_ matcher that works with arguments of several types (for
+instance, `Eq(x)` can be used to match a `value` as long as `value` ==
+`x` compiles -- `value` and `x` don't have to share the same type),
+you can learn the trick from `"gmock/gmock-matchers.h"` but it's a bit
+involved.
+
+Fortunately, most of the time you can define a polymorphic matcher
+easily with the help of `MakePolymorphicMatcher()`. Here's how you can
+define `NotNull()` as an example:
+
+```
+using ::testing::MakePolymorphicMatcher;
+using ::testing::MatchResultListener;
+using ::testing::NotNull;
+using ::testing::PolymorphicMatcher;
+
+class NotNullMatcher {
+ public:
+  // To implement a polymorphic matcher, first define a COPYABLE class
+  // that has three members MatchAndExplain(), DescribeTo(), and
+  // DescribeNegationTo(), like the following.
+
+  // In this example, we want to use NotNull() with any pointer, so
+  // MatchAndExplain() accepts a pointer of any type as its first argument.
+  // In general, you can define MatchAndExplain() as an ordinary method or
+  // a method template, or even overload it.
+  template <typename T>
+  bool MatchAndExplain(T* p,
+                       MatchResultListener* /* listener */) const {
+    return p != NULL;
+  }
+
+  // Describes the property of a value matching this matcher.
+  void DescribeTo(::std::ostream* os) const { *os << "is not NULL"; }
+
+  // Describes the property of a value NOT matching this matcher.
+  void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
+};
+
+// To construct a polymorphic matcher, pass an instance of the class
+// to MakePolymorphicMatcher().  Note the return type.
+inline PolymorphicMatcher<NotNullMatcher> NotNull() {
+  return MakePolymorphicMatcher(NotNullMatcher());
+}
+...
+
+  EXPECT_CALL(foo, Bar(NotNull()));  // The argument must be a non-NULL pointer.
+```
+
+**Note:** Your polymorphic matcher class does **not** need to inherit from
+`MatcherInterface` or any other class, and its methods do **not** need
+to be virtual.
+
+Like in a monomorphic matcher, you may explain the match result by
+streaming additional information to the `listener` argument in
+`MatchAndExplain()`.
+
+## Writing New Cardinalities ##
+
+A cardinality is used in `Times()` to tell Google Mock how many times
+you expect a call to occur. It doesn't have to be exact. For example,
+you can say `AtLeast(5)` or `Between(2, 4)`.
+
+If the built-in set of cardinalities doesn't suit you, you are free to
+define your own by implementing the following interface (in namespace
+`testing`):
+
+```
+class CardinalityInterface {
+ public:
+  virtual ~CardinalityInterface();
+
+  // Returns true iff call_count calls will satisfy this cardinality.
+  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
+
+  // Returns true iff call_count calls will saturate this cardinality.
+  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
+
+  // Describes self to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+};
+```
+
+For example, to specify that a call must occur even number of times,
+you can write
+
+```
+using ::testing::Cardinality;
+using ::testing::CardinalityInterface;
+using ::testing::MakeCardinality;
+
+class EvenNumberCardinality : public CardinalityInterface {
+ public:
+  virtual bool IsSatisfiedByCallCount(int call_count) const {
+    return (call_count % 2) == 0;
+  }
+
+  virtual bool IsSaturatedByCallCount(int call_count) const {
+    return false;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "called even number of times";
+  }
+};
+
+Cardinality EvenNumber() {
+  return MakeCardinality(new EvenNumberCardinality);
+}
+...
+
+  EXPECT_CALL(foo, Bar(3))
+      .Times(EvenNumber());
+```
+
+## Writing New Actions Quickly ##
+
+If the built-in actions don't work for you, and you find it
+inconvenient to use `Invoke()`, you can use a macro from the `ACTION*`
+family to quickly define a new action that can be used in your code as
+if it's a built-in action.
+
+By writing
+```
+ACTION(name) { statements; }
+```
+in a namespace scope (i.e. not inside a class or function), you will
+define an action with the given name that executes the statements.
+The value returned by `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 as `argK`.  For example:
+```
+ACTION(IncrementArg1) { return ++(*arg1); }
+```
+allows you to write
+```
+... WillOnce(IncrementArg1());
+```
+
+Note that you don't need to specify the types of the mock function
+arguments.  Rest assured that your code is type-safe though:
+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.
+
+Another example:
+```
+ACTION(Foo) {
+  (*arg2)(5);
+  Blah();
+  *arg1 = 0;
+  return arg0;
+}
+```
+defines an action `Foo()` that invokes argument #2 (a function pointer)
+with 5, calls function `Blah()`, sets the value pointed to by argument
+#1 to 0, and returns argument #0.
+
+For more convenience and flexibility, you can also use the following
+pre-defined symbols in the body of `ACTION`:
+
+| `argK_type` | The type of the K-th (0-based) argument of the mock function |
+|:------------|:-------------------------------------------------------------|
+| `args`      | All arguments of the mock function as a tuple                |
+| `args_type` | The type of all arguments of the mock function as a tuple    |
+| `return_type` | The return type of the mock function                         |
+| `function_type` | The type of the mock function                                |
+
+For example, when using an `ACTION` as a stub action for mock function:
+```
+int DoSomething(bool flag, int* ptr);
+```
+we have:
+| **Pre-defined Symbol** | **Is Bound To** |
+|:-----------------------|:----------------|
+| `arg0`                 | the value of `flag` |
+| `arg0_type`            | the type `bool` |
+| `arg1`                 | the value of `ptr` |
+| `arg1_type`            | the type `int*` |
+| `args`                 | the tuple `(flag, ptr)` |
+| `args_type`            | the type `::testing::tuple<bool, int*>` |
+| `return_type`          | the type `int`  |
+| `function_type`        | the type `int(bool, int*)` |
+
+## Writing New Parameterized Actions Quickly ##
+
+Sometimes you'll want to parameterize an action you define.  For that
+we have another macro
+```
+ACTION_P(name, param) { statements; }
+```
+
+For example,
+```
+ACTION_P(Add, n) { return arg0 + n; }
+```
+will allow you to write
+```
+// Returns argument #0 + 5.
+... WillOnce(Add(5));
+```
+
+For convenience, we use the term _arguments_ for the values used to
+invoke the mock function, and the term _parameters_ for the values
+used to instantiate an action.
+
+Note that you don't need to provide the type of the parameter either.
+Suppose the parameter is named `param`, you can also use the
+Google-Mock-defined symbol `param_type` to refer to the type of the
+parameter as inferred by the compiler.  For example, in the body of
+`ACTION_P(Add, n)` above, you can write `n_type` for the type of `n`.
+
+Google Mock also provides `ACTION_P2`, `ACTION_P3`, and etc to support
+multi-parameter actions.  For example,
+```
+ACTION_P2(ReturnDistanceTo, x, y) {
+  double dx = arg0 - x;
+  double dy = arg1 - y;
+  return sqrt(dx*dx + dy*dy);
+}
+```
+lets you write
+```
+... WillOnce(ReturnDistanceTo(5.0, 26.5));
+```
+
+You can view `ACTION` as a degenerated parameterized action where the
+number of parameters is 0.
+
+You can also easily define actions overloaded on the number of parameters:
+```
+ACTION_P(Plus, a) { ... }
+ACTION_P2(Plus, a, b) { ... }
+```
+
+## Restricting the Type of an Argument or Parameter in an ACTION ##
+
+For maximum brevity and reusability, the `ACTION*` macros don't ask
+you to provide the types of the mock function arguments and the action
+parameters.  Instead, we let the compiler infer the types for us.
+
+Sometimes, however, we may want to be more explicit about the types.
+There are several tricks to do that.  For example:
+```
+ACTION(Foo) {
+  // Makes sure arg0 can be converted to int.
+  int n = arg0;
+  ... use n instead of arg0 here ...
+}
+
+ACTION_P(Bar, param) {
+  // Makes sure the type of arg1 is const char*.
+  ::testing::StaticAssertTypeEq<const char*, arg1_type>();
+
+  // Makes sure param can be converted to bool.
+  bool flag = param;
+}
+```
+where `StaticAssertTypeEq` is a compile-time assertion in Google Test
+that verifies two types are the same.
+
+## Writing New Action Templates Quickly ##
+
+Sometimes you want to give an action explicit template parameters that
+cannot be inferred from its value parameters.  `ACTION_TEMPLATE()`
+supports 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, where _m_ is between 1 and 10, and _n_ is
+between 0 and 10.  `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,
+                // Note the comma between int and k:
+                HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
+                AND_1_VALUE_PARAMS(output)) {
+  *output = T(::testing::get<k>(args));
+}
+```
+
+To create an instance of an action template, write:
+```
+  ActionName<t1, ..., t_m>(v1, ..., v_n)
+```
+where the `t`s are the template arguments and the
+`v`s are the value arguments.  The value argument
+types are inferred by the compiler.  For example:
+```
+using ::testing::_;
+...
+  int n;
+  EXPECT_CALL(mock, Foo(_, _))
+      .WillOnce(DuplicateArg<1, unsigned char>(&n));
+```
+
+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 a two-template-parameter action where the compiler
+is asked to infer the type of `x`?
+
+## Using the ACTION Object's Type ##
+
+If you are writing a function that returns an `ACTION` object, you'll
+need to know its type.  The type depends on the macro used to define
+the action and the parameter types.  The rule is relatively simple:
+| **Given Definition** | **Expression** | **Has Type** |
+|:---------------------|:---------------|:-------------|
+| `ACTION(Foo)`        | `Foo()`        | `FooAction`  |
+| `ACTION_TEMPLATE(Foo, HAS_m_TEMPLATE_PARAMS(...), AND_0_VALUE_PARAMS())` |	`Foo<t1, ..., t_m>()` | `FooAction<t1, ..., t_m>` |
+| `ACTION_P(Bar, param)` | `Bar(int_value)` | `BarActionP<int>` |
+| `ACTION_TEMPLATE(Bar, HAS_m_TEMPLATE_PARAMS(...), AND_1_VALUE_PARAMS(p1))` | `Bar<t1, ..., t_m>(int_value)` | `FooActionP<t1, ..., t_m, int>` |
+| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value, int_value)` | `BazActionP2<bool, int>` |
+| `ACTION_TEMPLATE(Baz, HAS_m_TEMPLATE_PARAMS(...), AND_2_VALUE_PARAMS(p1, p2))` | `Baz<t1, ..., t_m>(bool_value, int_value)` | `FooActionP2<t1, ..., t_m, bool, int>` |
+| ...                  | ...            | ...          |
+
+Note that we have to pick different suffixes (`Action`, `ActionP`,
+`ActionP2`, and etc) for actions with different numbers of value
+parameters, or the action definitions cannot be overloaded on the
+number of them.
+
+## Writing New Monomorphic Actions ##
+
+While the `ACTION*` macros are very convenient, sometimes they are
+inappropriate.  For example, despite the tricks shown in the previous
+recipes, they don't let you directly specify the types of the mock
+function arguments and the action parameters, which in general leads
+to unoptimized compiler error messages that can baffle unfamiliar
+users.  They also don't allow overloading actions based on parameter
+types without jumping through some hoops.
+
+An alternative to the `ACTION*` macros is to implement
+`::testing::ActionInterface<F>`, where `F` is the type of the mock
+function in which the action will be used. For example:
+
+```
+template <typename F>class ActionInterface {
+ public:
+  virtual ~ActionInterface();
+
+  // Performs the action.  Result is the return type of function type
+  // F, and ArgumentTuple is the tuple of arguments of F.
+  //
+  // For example, if F is int(bool, const string&), then Result would
+  // be int, and ArgumentTuple would be ::testing::tuple<bool, const string&>.
+  virtual Result Perform(const ArgumentTuple& args) = 0;
+};
+
+using ::testing::_;
+using ::testing::Action;
+using ::testing::ActionInterface;
+using ::testing::MakeAction;
+
+typedef int IncrementMethod(int*);
+
+class IncrementArgumentAction : public ActionInterface<IncrementMethod> {
+ public:
+  virtual int Perform(const ::testing::tuple<int*>& args) {
+    int* p = ::testing::get<0>(args);  // Grabs the first argument.
+    return *p++;
+  }
+};
+
+Action<IncrementMethod> IncrementArgument() {
+  return MakeAction(new IncrementArgumentAction);
+}
+...
+
+  EXPECT_CALL(foo, Baz(_))
+      .WillOnce(IncrementArgument());
+
+  int n = 5;
+  foo.Baz(&n);  // Should return 5 and change n to 6.
+```
+
+## Writing New Polymorphic Actions ##
+
+The previous recipe showed you how to define your own action. This is
+all good, except that you need to know the type of the function in
+which the action will be used. Sometimes that can be a problem. For
+example, if you want to use the action in functions with _different_
+types (e.g. like `Return()` and `SetArgPointee()`).
+
+If an action can be used in several types of mock functions, we say
+it's _polymorphic_. The `MakePolymorphicAction()` function template
+makes it easy to define such an action:
+
+```
+namespace testing {
+
+template <typename Impl>
+PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl);
+
+}  // namespace testing
+```
+
+As an example, let's define an action that returns the second argument
+in the mock function's argument list. The first step is to define an
+implementation class:
+
+```
+class ReturnSecondArgumentAction {
+ public:
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& args) const {
+    // To get the i-th (0-based) argument, use ::testing::get<i>(args).
+    return ::testing::get<1>(args);
+  }
+};
+```
+
+This implementation class does _not_ need to inherit from any
+particular class. What matters is that it must have a `Perform()`
+method template. This method template takes the mock function's
+arguments as a tuple in a **single** argument, and returns the result of
+the action. It can be either `const` or not, but must be invokable
+with exactly one template argument, which is the result type. In other
+words, you must be able to call `Perform<R>(args)` where `R` is the
+mock function's return type and `args` is its arguments in a tuple.
+
+Next, we use `MakePolymorphicAction()` to turn an instance of the
+implementation class into the polymorphic action we need. It will be
+convenient to have a wrapper for this:
+
+```
+using ::testing::MakePolymorphicAction;
+using ::testing::PolymorphicAction;
+
+PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
+  return MakePolymorphicAction(ReturnSecondArgumentAction());
+}
+```
+
+Now, you can use this polymorphic action the same way you use the
+built-in ones:
+
+```
+using ::testing::_;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD2(DoThis, int(bool flag, int n));
+  MOCK_METHOD3(DoThat, string(int x, const char* str1, const char* str2));
+};
+...
+
+  MockFoo foo;
+  EXPECT_CALL(foo, DoThis(_, _))
+      .WillOnce(ReturnSecondArgument());
+  EXPECT_CALL(foo, DoThat(_, _, _))
+      .WillOnce(ReturnSecondArgument());
+  ...
+  foo.DoThis(true, 5);         // Will return 5.
+  foo.DoThat(1, "Hi", "Bye");  // Will return "Hi".
+```
+
+## Teaching Google Mock How to Print Your Values ##
+
+When an uninteresting or unexpected call occurs, Google Mock prints the
+argument values and the stack trace to help you debug.  Assertion
+macros like `EXPECT_THAT` and `EXPECT_EQ` also print the values in
+question when the assertion fails.  Google Mock and Google Test do this using
+Google Test's user-extensible value printer.
+
+This printer knows how to print built-in C++ types, native arrays, STL
+containers, and any type that supports the `<<` operator.  For other
+types, it prints the raw bytes in the value and hopes that you the
+user can figure it out.
+[Google Test's advanced guide](../../googletest/docs/AdvancedGuide.md#teaching-google-test-how-to-print-your-values)
+explains how to extend the printer to do a better job at
+printing your particular type than to dump the bytes.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DesignDoc.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DesignDoc.md
new file mode 100644
index 00000000..3f515c3b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DesignDoc.md
@@ -0,0 +1,280 @@
+This page discusses the design of new Google Mock features.
+
+
+
+# Macros for Defining Actions #
+
+## Problem ##
+
+Due to the lack of closures in C++, it currently requires some
+non-trivial effort to define a custom action in Google Mock.  For
+example, suppose you want to "increment the value pointed to by the
+second argument of the mock function and return it", you could write:
+
+```
+int IncrementArg1(Unused, int* p, Unused) {
+  return ++(*p);
+}
+
+... WillOnce(Invoke(IncrementArg1));
+```
+
+There are several things unsatisfactory about this approach:
+
+  * Even though the action only cares about the second argument of the mock function, its definition needs to list other arguments as dummies.  This is tedious.
+  * The defined action is usable only in mock functions that takes exactly 3 arguments - an unnecessary restriction.
+  * To use the action, one has to say `Invoke(IncrementArg1)`, which isn't as nice as `IncrementArg1()`.
+
+The latter two problems can be overcome using `MakePolymorphicAction()`,
+but it requires much more boilerplate code:
+
+```
+class IncrementArg1Action {
+ public:
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& args) const {
+    return ++(*tr1::get<1>(args));
+  }
+};
+
+PolymorphicAction<IncrementArg1Action> IncrementArg1() {
+  return MakePolymorphicAction(IncrementArg1Action());
+}
+
+... WillOnce(IncrementArg1());
+```
+
+Our goal is to allow defining custom actions with the least amount of
+boiler-plate C++ requires.
+
+## Solution ##
+
+We propose to introduce a new macro:
+```
+ACTION(name) { statements; }
+```
+
+Using this in a namespace scope will define an action with the given
+name that executes the statements.  Inside the statements, you can
+refer to the K-th (0-based) argument of the mock function as `argK`.
+For example:
+```
+ACTION(IncrementArg1) { return ++(*arg1); }
+```
+allows you to write
+```
+... WillOnce(IncrementArg1());
+```
+
+Note that you don't need to specify the types of the mock function
+arguments, as brevity is a top design goal here.  Rest assured that
+your code is still type-safe though: 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.
+
+Another example:
+```
+ACTION(Foo) {
+  (*arg2)(5);
+  Blah();
+  *arg1 = 0;
+  return arg0;
+}
+```
+defines an action `Foo()` that invokes argument #2 (a function pointer)
+with 5, calls function `Blah()`, sets the value pointed to by argument
+#1 to 0, and returns argument #0.
+
+For more convenience and flexibility, you can also use the following
+pre-defined symbols in the body of `ACTION`:
+
+| `argK_type` | The type of the K-th (0-based) argument of the mock function |
+|:------------|:-------------------------------------------------------------|
+| `args`      | All arguments of the mock function as a tuple                |
+| `args_type` | The type of all arguments of the mock function as a tuple    |
+| `return_type` | The return type of the mock function                         |
+| `function_type` | The type of the mock function                                |
+
+For example, when using an `ACTION` as a stub action for mock function:
+```
+int DoSomething(bool flag, int* ptr);
+```
+we have:
+| **Pre-defined Symbol** | **Is Bound To** |
+|:-----------------------|:----------------|
+| `arg0`                 | the value of `flag` |
+| `arg0_type`            | the type `bool` |
+| `arg1`                 | the value of `ptr` |
+| `arg1_type`            | the type `int*` |
+| `args`                 | the tuple `(flag, ptr)` |
+| `args_type`            | the type `std::tr1::tuple<bool, int*>` |
+| `return_type`          | the type `int`  |
+| `function_type`        | the type `int(bool, int*)` |
+
+## Parameterized actions ##
+
+Sometimes you'll want to parameterize the action.   For that we propose
+another macro
+```
+ACTION_P(name, param) { statements; }
+```
+
+For example,
+```
+ACTION_P(Add, n) { return arg0 + n; }
+```
+will allow you to write
+```
+// Returns argument #0 + 5.
+... WillOnce(Add(5));
+```
+
+For convenience, we use the term _arguments_ for the values used to
+invoke the mock function, and the term _parameters_ for the values
+used to instantiate an action.
+
+Note that you don't need to provide the type of the parameter either.
+Suppose the parameter is named `param`, you can also use the
+Google-Mock-defined symbol `param_type` to refer to the type of the
+parameter as inferred by the compiler.
+
+We will also provide `ACTION_P2`, `ACTION_P3`, and etc to support
+multi-parameter actions.  For example,
+```
+ACTION_P2(ReturnDistanceTo, x, y) {
+  double dx = arg0 - x;
+  double dy = arg1 - y;
+  return sqrt(dx*dx + dy*dy);
+}
+```
+lets you write
+```
+... WillOnce(ReturnDistanceTo(5.0, 26.5));
+```
+
+You can view `ACTION` as a degenerated parameterized action where the
+number of parameters is 0.
+
+## Advanced Usages ##
+
+### Overloading Actions ###
+
+You can easily define actions overloaded on the number of parameters:
+```
+ACTION_P(Plus, a) { ... }
+ACTION_P2(Plus, a, b) { ... }
+```
+
+### Restricting the Type of an Argument or Parameter ###
+
+For maximum brevity and reusability, the `ACTION*` macros don't let
+you specify the types of the mock function arguments and the action
+parameters.  Instead, we let the compiler infer the types for us.
+
+Sometimes, however, we may want to be more explicit about the types.
+There are several tricks to do that.  For example:
+```
+ACTION(Foo) {
+  // Makes sure arg0 can be converted to int.
+  int n = arg0;
+  ... use n instead of arg0 here ...
+}
+
+ACTION_P(Bar, param) {
+  // Makes sure the type of arg1 is const char*.
+  ::testing::StaticAssertTypeEq<const char*, arg1_type>();
+
+  // Makes sure param can be converted to bool.
+  bool flag = param;
+}
+```
+where `StaticAssertTypeEq` is a compile-time assertion we plan to add to
+Google Test (the name is chosen to match `static_assert` in C++0x).
+
+### Using the ACTION Object's Type ###
+
+If you are writing a function that returns an `ACTION` object, you'll
+need to know its type.  The type depends on the macro used to define
+the action and the parameter types.  The rule is relatively simple:
+| **Given Definition** | **Expression** | **Has Type** |
+|:---------------------|:---------------|:-------------|
+| `ACTION(Foo)`        | `Foo()`        | `FooAction`  |
+| `ACTION_P(Bar, param)` | `Bar(int_value)` | `BarActionP<int>` |
+| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value, int_value)` | `BazActionP2<bool, int>` |
+| ...                  | ...            | ...          |
+
+Note that we have to pick different suffixes (`Action`, `ActionP`,
+`ActionP2`, and etc) for actions with different numbers of parameters,
+or the action definitions cannot be overloaded on the number of
+parameters.
+
+## When to Use ##
+
+While the new macros are very convenient, please also consider other
+means of implementing actions (e.g. via `ActionInterface` or
+`MakePolymorphicAction()`), especially if you need to use the defined
+action a lot.  While the other 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 the number of
+parameters.
+
+## Related Work ##
+
+As you may have realized, the `ACTION*` macros resemble closures (also
+known as lambda expressions or anonymous functions).  Indeed, both of
+them seek to lower the syntactic overhead for defining a function.
+
+C++0x will support lambdas, but they are not part of C++ right now.
+Some non-standard libraries (most notably BLL or Boost Lambda Library)
+try to alleviate this problem.  However, they are not a good choice
+for defining actions as:
+
+  * They are non-standard and not widely installed.  Google Mock only depends on standard libraries and `tr1::tuple`, which is part of the new C++ standard and comes with gcc 4+.  We want to keep it that way.
+  * They are not trivial to learn.
+  * They will become obsolete when C++0x's lambda feature is widely supported.  We don't want to make our users use a dying library.
+  * Since they are based on operators, they are rather ad hoc: you cannot use statements, and you cannot pass the lambda arguments to a function, for example.
+  * They have subtle semantics that easily confuses new users.  For example, in expression `_1++ + foo++`, `foo` will be incremented only once where the expression is evaluated, while `_1` will be incremented every time the unnamed function is invoked.  This is far from intuitive.
+
+`ACTION*` avoid all these problems.
+
+## Future Improvements ##
+
+There may be a need for composing `ACTION*` definitions (i.e. invoking
+another `ACTION` inside the definition of one `ACTION*`).  We are not
+sure we want it yet, as one can get a similar effect by putting
+`ACTION` definitions in function templates and composing the function
+templates.  We'll revisit this based on user feedback.
+
+The reason we don't allow `ACTION*()` inside a function body is that
+the current C++ standard doesn't allow function-local types to be used
+to instantiate templates.  The upcoming C++0x standard will lift this
+restriction.  Once this feature is widely supported by compilers, we
+can revisit the implementation and add support for using `ACTION*()`
+inside a function.
+
+C++0x will also support lambda expressions.  When they become
+available, we may want to support using lambdas as actions.
+
+# Macros for Defining Matchers #
+
+Once the macros for defining actions are implemented, we plan to do
+the same for matchers:
+
+```
+MATCHER(name) { statements; }
+```
+
+where you can refer to the value being matched as `arg`.  For example,
+given:
+
+```
+MATCHER(IsPositive) { return arg > 0; }
+```
+
+you can use `IsPositive()` as a matcher that matches a value iff it is
+greater than 0.
+
+We will also add `MATCHER_P`, `MATCHER_P2`, and etc for parameterized
+matchers.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DevGuide.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DevGuide.md
new file mode 100644
index 00000000..f4bab75c
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DevGuide.md
@@ -0,0 +1,132 @@
+
+
+If you are interested in understanding the internals of Google Mock,
+building from source, or contributing ideas or modifications to the
+project, then this document is for you.
+
+# Introduction #
+
+First, let's give you some background of the project.
+
+## Licensing ##
+
+All Google Mock source and pre-built packages are provided under the [New BSD License](http://www.opensource.org/licenses/bsd-license.php).
+
+## The Google Mock Community ##
+
+The Google Mock community exists primarily through the [discussion group](http://groups.google.com/group/googlemock), the
+[issue tracker](https://github.com/google/googletest/issues) and, to a lesser extent, the [source control repository](../). 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
+Mock 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.
+
+### Where to Discuss Google Mock ###
+
+As always, discuss Google Mock in the official [Google C++ Mocking Framework discussion group](http://groups.google.com/group/googlemock).  You don't have to actually submit
+code in order to sign up. Your participation itself is a valuable
+contribution.
+
+# Working with the Code #
+
+If you want to get your hands dirty with the code inside Google Mock,
+this is the section for you.
+
+## Checking Out the Source from Subversion ##
+
+Checking out the Google Mock source is most useful if you plan to
+tweak it yourself.  You check out the source for Google Mock using a
+[Subversion](http://subversion.tigris.org/) client as you would for any
+other project hosted on Google Code.  Please see the instruction on
+the [source code access page](../) for how to do it.
+
+## Compiling from Source ##
+
+Once you check out the code, you can find instructions on how to
+compile it in the [README](../README.md) file.
+
+## Testing ##
+
+A mocking framework is of no good if itself is not thoroughly tested.
+Tests should be written for any new code, and changes should be
+verified to not break existing tests before they are submitted for
+review. To perform the tests, follow the instructions in [README](http://code.google.com/p/googlemock/source/browse/trunk/README) and
+verify that there are no failures.
+
+# Contributing Code #
+
+We are excited that Google Mock is now open source, and hope to get
+great patches from the community. Before you fire up your favorite IDE
+and begin hammering away at that new feature, though, please take the
+time to read this section and understand the process. While it seems
+rigorous, we want to keep a high standard of quality in the code
+base.
+
+## Contributor License Agreements ##
+
+You must sign a Contributor License Agreement (CLA) before we can
+accept any code.  The CLA protects you and us.
+
+  * 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](http://code.google.com/legal/individual-cla-v1.0.html).
+  * If you work for a company that wants to allow you to contribute your work to Google Mock, then you'll need to sign a [corporate CLA](http://code.google.com/legal/corporate-cla-v1.0.html).
+
+Follow either of the two links above to access the appropriate CLA and
+instructions for how to sign and return it.
+
+## Coding 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://github.com/google/styleguide/blob/gh-pages/cppguide.xml).
+
+## Submitting Patches ##
+
+Please do submit code. Here's what you need to do:
+
+  1. Normally you should make your change against the SVN trunk instead of a branch or a tag, as the latter two are for release control and should be treated mostly as read-only.
+  1. Decide which code you want to submit. A submission should be a set of changes that addresses one issue in the [Google Mock issue tracker](http://code.google.com/p/googlemock/issues/list). 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.
+  1. 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.
+  1. Ensure that your code adheres to the [Google Mock source code style](#Coding_Style.md).
+  1. Ensure that there are unit tests for your code.
+  1. Sign a Contributor License Agreement.
+  1. Create a patch file using `svn diff`.
+  1. We use [Rietveld](http://codereview.appspot.com/) to do web-based code reviews.  You can read about the tool [here](https://github.com/rietveld-codereview/rietveld/wiki).  When you are ready, upload your patch via Rietveld and notify `googlemock@googlegroups.com` to review it.  There are several ways to upload the patch.  We recommend using the [upload\_gmock.py](../scripts/upload_gmock.py) script, which you can find in the `scripts/` folder in the SVN trunk.
+
+## Google Mock Committers ##
+
+The current members of the Google Mock engineering team are the only
+committers at present. In the great tradition of eating one's own
+dogfood, we will be requiring each new Google Mock engineering team
+member to earn the right to become a committer by following the
+procedures in this document, writing consistently great code, and
+demonstrating repeatedly that he or she truly gets the zen of Google
+Mock.
+
+# Release Process #
+
+We follow the typical release process for Subversion-based projects:
+
+  1. A release branch named `release-X.Y` is created.
+  1. Bugs are fixed and features are added in trunk; those individual patches are merged into the release branch until it's stable.
+  1. An individual point release (the `Z` in `X.Y.Z`) is made by creating a tag from the branch.
+  1. Repeat steps 2 and 3 throughout one release cycle (as determined by features or time).
+  1. Go back to step 1 to create another release branch and so on.
+
+
+---
+
+This page is based on the [Making GWT Better](http://code.google.com/webtoolkit/makinggwtbetter.html) guide from the [Google Web Toolkit](http://code.google.com/webtoolkit/) project.  Except as otherwise [noted](http://code.google.com/policies.html#restrictions), the content of this page is licensed under the [Creative Commons Attribution 2.5 License](http://creativecommons.org/licenses/by/2.5/).
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/Documentation.md
new file mode 100644
index 00000000..444151ee
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/Documentation.md
@@ -0,0 +1,12 @@
+This page lists all documentation wiki pages for Google Mock **(the SVN trunk version)**
+- **if you use a released version of Google Mock, please read the documentation for that specific version instead.**
+
+  * [ForDummies](ForDummies.md) -- start here if you are new to Google Mock.
+  * [CheatSheet](CheatSheet.md) -- a quick reference.
+  * [CookBook](CookBook.md) -- recipes for doing various tasks using Google Mock.
+  * [FrequentlyAskedQuestions](FrequentlyAskedQuestions.md) -- check here before asking a question on the mailing list.
+
+To contribute code to Google Mock, read:
+
+  * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
+  * [Pump Manual](../googletest/docs/PumpManual.md) -- how we generate some of Google Mock's source files.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/ForDummies.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/ForDummies.md
new file mode 100644
index 00000000..0da4cbe2
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/ForDummies.md
@@ -0,0 +1,439 @@
+
+
+(**Note:** If you get compiler errors that you don't understand, be sure to consult [Google Mock Doctor](FrequentlyAskedQuestions.md#how-am-i-supposed-to-make-sense-of-these-horrible-template-errors).)
+
+# What Is Google C++ Mocking Framework? #
+When you write a prototype or test, often it's not feasible or wise to rely on real objects entirely. A **mock object** implements the same interface as a real object (so it can be used as one), but lets you specify at run time how it will be used and what it should do (which methods will be called? in which order? how many times? with what arguments? what will they return? etc).
+
+**Note:** It is easy to confuse the term _fake objects_ with mock objects. Fakes and mocks actually mean very different things in the Test-Driven Development (TDD) community:
+
+  * **Fake** objects have working implementations, but usually take some shortcut (perhaps to make the operations less expensive), which makes them not suitable for production. An in-memory file system would be an example of a fake.
+  * **Mocks** are objects pre-programmed with _expectations_, which form a specification of the calls they are expected to receive.
+
+If all this seems too abstract for you, don't worry - the most important thing to remember is that a mock allows you to check the _interaction_ between itself and code that uses it. The difference between fakes and mocks will become much clearer once you start to use mocks.
+
+**Google C++ Mocking Framework** (or **Google Mock** for short) is a library (sometimes we also call it a "framework" to make it sound cool) for creating mock classes and using them. It does to C++ what [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/) do to Java.
+
+Using Google Mock involves three basic steps:
+
+  1. Use some simple macros to describe the interface you want to mock, and they will expand to the implementation of your mock class;
+  1. Create some mock objects and specify its expectations and behavior using an intuitive syntax;
+  1. Exercise code that uses the mock objects. Google Mock will catch any violation of the expectations as soon as it arises.
+
+# Why Google Mock? #
+While mock objects help you remove unnecessary dependencies in tests and make them fast and reliable, using mocks manually in C++ is _hard_:
+
+  * Someone has to implement the mocks. The job is usually tedious and error-prone. No wonder people go great distance to avoid it.
+  * The quality of those manually written mocks is a bit, uh, unpredictable. You may see some really polished ones, but you may also see some that were hacked up in a hurry and have all sorts of ad hoc restrictions.
+  * The knowledge you gained from using one mock doesn't transfer to the next.
+
+In contrast, Java and Python programmers have some fine mock frameworks, which automate the creation of mocks. As a result, mocking is a proven effective technique and widely adopted practice in those communities. Having the right tool absolutely makes the difference.
+
+Google Mock was built to help C++ programmers. It was inspired by [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/), but designed with C++'s specifics in mind. It is your friend if any of the following problems is bothering you:
+
+  * You are stuck with a sub-optimal design and wish you had done more prototyping before it was too late, but prototyping in C++ is by no means "rapid".
+  * Your tests are slow as they depend on too many libraries or use expensive resources (e.g. a database).
+  * Your tests are brittle as some resources they use are unreliable (e.g. the network).
+  * You want to test how your code handles a failure (e.g. a file checksum error), but it's not easy to cause one.
+  * You need to make sure that your module interacts with other modules in the right way, but it's hard to observe the interaction; therefore you resort to observing the side effects at the end of the action, which is awkward at best.
+  * You want to "mock out" your dependencies, except that they don't have mock implementations yet; and, frankly, you aren't thrilled by some of those hand-written mocks.
+
+We encourage you to use Google Mock as:
+
+  * a _design_ tool, for it lets you experiment with your interface design early and often. More iterations lead to better designs!
+  * a _testing_ tool to cut your tests' outbound dependencies and probe the interaction between your module and its collaborators.
+
+# Getting Started #
+Using Google Mock is easy! Inside your C++ source file, just `#include` `"gtest/gtest.h"` and `"gmock/gmock.h"`, and you are ready to go.
+
+# A Case for Mock Turtles #
+Let's look at an example. Suppose you are developing a graphics program that relies on a LOGO-like API for drawing. How would you test that it does the right thing? Well, you can run it and compare the screen with a golden screen snapshot, but let's admit it: tests like this are expensive to run and fragile (What if you just upgraded to a shiny new graphics card that has better anti-aliasing? Suddenly you have to update all your golden images.). It would be too painful if all your tests are like this. Fortunately, you learned about Dependency Injection and know the right thing to do: instead of having your application talk to the drawing API directly, wrap the API in an interface (say, `Turtle`) and code to that interface:
+
+```
+class Turtle {
+  ...
+  virtual ~Turtle() {}
+  virtual void PenUp() = 0;
+  virtual void PenDown() = 0;
+  virtual void Forward(int distance) = 0;
+  virtual void Turn(int degrees) = 0;
+  virtual void GoTo(int x, int y) = 0;
+  virtual int GetX() const = 0;
+  virtual int GetY() const = 0;
+};
+```
+
+(Note that the destructor of `Turtle` **must** be virtual, as is the case for **all** classes you intend to inherit from - otherwise the destructor of the derived class will not be called when you delete an object through a base pointer, and you'll get corrupted program states like memory leaks.)
+
+You can control whether the turtle's movement will leave a trace using `PenUp()` and `PenDown()`, and control its movement using `Forward()`, `Turn()`, and `GoTo()`. Finally, `GetX()` and `GetY()` tell you the current position of the turtle.
+
+Your program will normally use a real implementation of this interface. In tests, you can use a mock implementation instead. This allows you to easily check what drawing primitives your program is calling, with what arguments, and in which order. Tests written this way are much more robust (they won't break because your new machine does anti-aliasing differently), easier to read and maintain (the intent of a test is expressed in the code, not in some binary images), and run _much, much faster_.
+
+# Writing the Mock Class #
+If you are lucky, the mocks you need to use have already been implemented by some nice people. If, however, you find yourself in the position to write a mock class, relax - Google Mock turns this task into a fun game! (Well, almost.)
+
+## How to Define It ##
+Using the `Turtle` interface as example, here are the simple steps you need to follow:
+
+  1. Derive a class `MockTurtle` from `Turtle`.
+  1. Take a _virtual_ function of `Turtle` (while it's possible to [mock non-virtual methods using templates](CookBook.md#mocking-nonvirtual-methods), it's much more involved). Count how many arguments it has.
+  1. In the `public:` section of the child class, write `MOCK_METHODn();` (or `MOCK_CONST_METHODn();` if you are mocking a `const` method), where `n` is the number of the arguments; if you counted wrong, shame on you, and a compiler error will tell you so.
+  1. Now comes the fun part: you take the function signature, cut-and-paste the _function name_ as the _first_ argument to the macro, and leave what's left as the _second_ argument (in case you're curious, this is the _type of the function_).
+  1. Repeat until all virtual functions you want to mock are done.
+
+After the process, you should have something like:
+
+```
+#include "gmock/gmock.h"  // Brings in Google Mock.
+class MockTurtle : public Turtle {
+ public:
+  ...
+  MOCK_METHOD0(PenUp, void());
+  MOCK_METHOD0(PenDown, void());
+  MOCK_METHOD1(Forward, void(int distance));
+  MOCK_METHOD1(Turn, void(int degrees));
+  MOCK_METHOD2(GoTo, void(int x, int y));
+  MOCK_CONST_METHOD0(GetX, int());
+  MOCK_CONST_METHOD0(GetY, int());
+};
+```
+
+You don't need to define these mock methods somewhere else - the `MOCK_METHOD*` macros will generate the definitions for you. It's that simple! Once you get the hang of it, you can pump out mock classes faster than your source-control system can handle your check-ins.
+
+**Tip:** If even this is too much work for you, you'll find the
+`gmock_gen.py` tool in Google Mock's `scripts/generator/` directory (courtesy of the [cppclean](http://code.google.com/p/cppclean/) project) useful.  This command-line
+tool requires that you have Python 2.4 installed.  You give it a C++ file and the name of an abstract class defined in it,
+and it will print the definition of the mock class for you.  Due to the
+complexity of the C++ language, this script may not always work, but
+it can be quite handy when it does.  For more details, read the [user documentation](../scripts/generator/README).
+
+## Where to Put It ##
+When you define a mock class, you need to decide where to put its definition. Some people put it in a `*_test.cc`. This is fine when the interface being mocked (say, `Foo`) is owned by the same person or team. Otherwise, when the owner of `Foo` changes it, your test could break. (You can't really expect `Foo`'s maintainer to fix every test that uses `Foo`, can you?)
+
+So, the rule of thumb is: if you need to mock `Foo` and it's owned by others, define the mock class in `Foo`'s package (better, in a `testing` sub-package such that you can clearly separate production code and testing utilities), and put it in a `mock_foo.h`. Then everyone can reference `mock_foo.h` from their tests. If `Foo` ever changes, there is only one copy of `MockFoo` to change, and only tests that depend on the changed methods need to be fixed.
+
+Another way to do it: you can introduce a thin layer `FooAdaptor` on top of `Foo` and code to this new interface. Since you own `FooAdaptor`, you can absorb changes in `Foo` much more easily. While this is more work initially, carefully choosing the adaptor interface can make your code easier to write and more readable (a net win in the long run), as you can choose `FooAdaptor` to fit your specific domain much better than `Foo` does.
+
+# Using Mocks in Tests #
+Once you have a mock class, using it is easy. The typical work flow is:
+
+  1. Import the Google Mock names from the `testing` namespace such that you can use them unqualified (You only have to do it once per file. Remember that namespaces are a good idea and good for your health.).
+  1. Create some mock objects.
+  1. Specify your expectations on them (How many times will a method be called? With what arguments? What should it do? etc.).
+  1. Exercise some code that uses the mocks; optionally, check the result using Google Test assertions. If a mock method is called more than expected or with wrong arguments, you'll get an error immediately.
+  1. When a mock is destructed, Google Mock will automatically check whether all expectations on it have been satisfied.
+
+Here's an example:
+
+```
+#include "path/to/mock-turtle.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+using ::testing::AtLeast;                     // #1
+
+TEST(PainterTest, CanDrawSomething) {
+  MockTurtle turtle;                          // #2
+  EXPECT_CALL(turtle, PenDown())              // #3
+      .Times(AtLeast(1));
+
+  Painter painter(&turtle);                   // #4
+
+  EXPECT_TRUE(painter.DrawCircle(0, 0, 10));
+}                                             // #5
+
+int main(int argc, char** argv) {
+  // The following line must be executed to initialize Google Mock
+  // (and Google Test) before running the tests.
+  ::testing::InitGoogleMock(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+```
+
+As you might have guessed, this test checks that `PenDown()` is called at least once. If the `painter` object didn't call this method, your test will fail with a message like this:
+
+```
+path/to/my_test.cc:119: Failure
+Actual function call count doesn't match this expectation:
+Actually: never called;
+Expected: called at least once.
+```
+
+**Tip 1:** If you run the test from an Emacs buffer, you can hit `<Enter>` on the line number displayed in the error message to jump right to the failed expectation.
+
+**Tip 2:** If your mock objects are never deleted, the final verification won't happen. Therefore it's a good idea to use a heap leak checker in your tests when you allocate mocks on the heap.
+
+**Important note:** Google Mock requires expectations to be set **before** the mock functions are called, otherwise the behavior is **undefined**. In particular, you mustn't interleave `EXPECT_CALL()`s and calls to the mock functions.
+
+This means `EXPECT_CALL()` should be read as expecting that a call will occur _in the future_, not that a call has occurred. Why does Google Mock work like that? Well, specifying the expectation beforehand allows Google Mock to report a violation as soon as it arises, when the context (stack trace, etc) is still available. This makes debugging much easier.
+
+Admittedly, this test is contrived and doesn't do much. You can easily achieve the same effect without using Google Mock. However, as we shall reveal soon, Google Mock allows you to do _much more_ with the mocks.
+
+## Using Google Mock with Any Testing Framework ##
+If you want to use something other than Google Test (e.g. [CppUnit](http://sourceforge.net/projects/cppunit/) or
+[CxxTest](http://cxxtest.tigris.org/)) as your testing framework, just change the `main()` function in the previous section to:
+```
+int main(int argc, char** argv) {
+  // The following line causes Google Mock to throw an exception on failure,
+  // which will be interpreted by your testing framework as a test failure.
+  ::testing::GTEST_FLAG(throw_on_failure) = true;
+  ::testing::InitGoogleMock(&argc, argv);
+  ... whatever your testing framework requires ...
+}
+```
+
+This approach has a catch: it makes Google Mock throw an exception
+from a mock object's destructor sometimes.  With some compilers, this
+sometimes causes the test program to crash.  You'll still be able to
+notice that the test has failed, but it's not a graceful failure.
+
+A better solution is to use Google Test's
+[event listener API](../../googletest/docs/AdvancedGuide.md#extending-google-test-by-handling-test-events)
+to report a test failure to your testing framework properly.  You'll need to
+implement the `OnTestPartResult()` method of the event listener interface, but it
+should be straightforward.
+
+If this turns out to be too much work, we suggest that you stick with
+Google Test, which works with Google Mock seamlessly (in fact, it is
+technically part of Google Mock.).  If there is a reason that you
+cannot use Google Test, please let us know.
+
+# Setting Expectations #
+The key to using a mock object successfully is to set the _right expectations_ on it. If you set the expectations too strict, your test will fail as the result of unrelated changes. If you set them too loose, bugs can slip through. You want to do it just right such that your test can catch exactly the kind of bugs you intend it to catch. Google Mock provides the necessary means for you to do it "just right."
+
+## General Syntax ##
+In Google Mock we use the `EXPECT_CALL()` macro to set an expectation on a mock method. The general syntax is:
+
+```
+EXPECT_CALL(mock_object, method(matchers))
+    .Times(cardinality)
+    .WillOnce(action)
+    .WillRepeatedly(action);
+```
+
+The macro has two arguments: first the mock object, and then the method and its arguments. Note that the two are separated by a comma (`,`), not a period (`.`). (Why using a comma? The answer is that it was necessary for technical reasons.)
+
+The macro can be followed by some optional _clauses_ that provide more information about the expectation. We'll discuss how each clause works in the coming sections.
+
+This syntax is designed to make an expectation read like English. For example, you can probably guess that
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetX())
+    .Times(5)
+    .WillOnce(Return(100))
+    .WillOnce(Return(150))
+    .WillRepeatedly(Return(200));
+```
+
+says that the `turtle` object's `GetX()` method will be called five times, it will return 100 the first time, 150 the second time, and then 200 every time. Some people like to call this style of syntax a Domain-Specific Language (DSL).
+
+**Note:** Why do we use a macro to do this? It serves two purposes: first it makes expectations easily identifiable (either by `grep` or by a human reader), and second it allows Google Mock to include the source file location of a failed expectation in messages, making debugging easier.
+
+## Matchers: What Arguments Do We Expect? ##
+When a mock function takes arguments, we must specify what arguments we are expecting; for example:
+
+```
+// Expects the turtle to move forward by 100 units.
+EXPECT_CALL(turtle, Forward(100));
+```
+
+Sometimes you may not want to be too specific (Remember that talk about tests being too rigid? Over specification leads to brittle tests and obscures the intent of tests. Therefore we encourage you to specify only what's necessary - no more, no less.). If you care to check that `Forward()` will be called but aren't interested in its actual argument, write `_` as the argument, which means "anything goes":
+
+```
+using ::testing::_;
+...
+// Expects the turtle to move forward.
+EXPECT_CALL(turtle, Forward(_));
+```
+
+`_` is an instance of what we call **matchers**. A matcher is like a predicate and can test whether an argument is what we'd expect. You can use a matcher inside `EXPECT_CALL()` wherever a function argument is expected.
+
+A list of built-in matchers can be found in the [CheatSheet](CheatSheet.md). For example, here's the `Ge` (greater than or equal) matcher:
+
+```
+using ::testing::Ge;...
+EXPECT_CALL(turtle, Forward(Ge(100)));
+```
+
+This checks that the turtle will be told to go forward by at least 100 units.
+
+## Cardinalities: How Many Times Will It Be Called? ##
+The first clause we can specify following an `EXPECT_CALL()` is `Times()`. We call its argument a **cardinality** as it tells _how many times_ the call should occur. It allows us to repeat an expectation many times without actually writing it as many times. More importantly, a cardinality can be "fuzzy", just like a matcher can be. This allows a user to express the intent of a test exactly.
+
+An interesting special case is when we say `Times(0)`. You may have guessed - it means that the function shouldn't be called with the given arguments at all, and Google Mock will report a Google Test failure whenever the function is (wrongfully) called.
+
+We've seen `AtLeast(n)` as an example of fuzzy cardinalities earlier. For the list of built-in cardinalities you can use, see the [CheatSheet](CheatSheet.md).
+
+The `Times()` clause can be omitted. **If you omit `Times()`, Google Mock will infer the cardinality for you.** The rules are easy to remember:
+
+  * If **neither** `WillOnce()` **nor** `WillRepeatedly()` is in the `EXPECT_CALL()`, the inferred cardinality is `Times(1)`.
+  * If there are `n WillOnce()`'s but **no** `WillRepeatedly()`, where `n` >= 1, the cardinality is `Times(n)`.
+  * If there are `n WillOnce()`'s and **one** `WillRepeatedly()`, where `n` >= 0, the cardinality is `Times(AtLeast(n))`.
+
+**Quick quiz:** what do you think will happen if a function is expected to be called twice but actually called four times?
+
+## Actions: What Should It Do? ##
+Remember that a mock object doesn't really have a working implementation? We as users have to tell it what to do when a method is invoked. This is easy in Google Mock.
+
+First, if the return type of a mock function is a built-in type or a pointer, the function has a **default action** (a `void` function will just return, a `bool` function will return `false`, and other functions will return 0). In addition, in C++ 11 and above, a mock function whose return type is default-constructible (i.e. has a default constructor) has a default action of returning a default-constructed value.  If you don't say anything, this behavior will be used.
+
+Second, if a mock function doesn't have a default action, or the default action doesn't suit you, you can specify the action to be taken each time the expectation matches using a series of `WillOnce()` clauses followed by an optional `WillRepeatedly()`. For example,
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetX())
+    .WillOnce(Return(100))
+    .WillOnce(Return(200))
+    .WillOnce(Return(300));
+```
+
+This says that `turtle.GetX()` will be called _exactly three times_ (Google Mock inferred this from how many `WillOnce()` clauses we've written, since we didn't explicitly write `Times()`), and will return 100, 200, and 300 respectively.
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetY())
+    .WillOnce(Return(100))
+    .WillOnce(Return(200))
+    .WillRepeatedly(Return(300));
+```
+
+says that `turtle.GetY()` will be called _at least twice_ (Google Mock knows this as we've written two `WillOnce()` clauses and a `WillRepeatedly()` while having no explicit `Times()`), will return 100 the first time, 200 the second time, and 300 from the third time on.
+
+Of course, if you explicitly write a `Times()`, Google Mock will not try to infer the cardinality itself. What if the number you specified is larger than there are `WillOnce()` clauses? Well, after all `WillOnce()`s are used up, Google Mock will do the _default_ action for the function every time (unless, of course, you have a `WillRepeatedly()`.).
+
+What can we do inside `WillOnce()` besides `Return()`? You can return a reference using `ReturnRef(variable)`, or invoke a pre-defined function, among [others](CheatSheet.md#actions).
+
+**Important note:** The `EXPECT_CALL()` statement evaluates the action clause only once, even though the action may be performed many times. Therefore you must be careful about side effects. The following may not do what you want:
+
+```
+int n = 100;
+EXPECT_CALL(turtle, GetX())
+.Times(4)
+.WillRepeatedly(Return(n++));
+```
+
+Instead of returning 100, 101, 102, ..., consecutively, this mock function will always return 100 as `n++` is only evaluated once. Similarly, `Return(new Foo)` will create a new `Foo` object when the `EXPECT_CALL()` is executed, and will return the same pointer every time. If you want the side effect to happen every time, you need to define a custom action, which we'll teach in the [CookBook](CookBook.md).
+
+Time for another quiz! What do you think the following means?
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetY())
+.Times(4)
+.WillOnce(Return(100));
+```
+
+Obviously `turtle.GetY()` is expected to be called four times. But if you think it will return 100 every time, think twice! Remember that one `WillOnce()` clause will be consumed each time the function is invoked and the default action will be taken afterwards. So the right answer is that `turtle.GetY()` will return 100 the first time, but **return 0 from the second time on**, as returning 0 is the default action for `int` functions.
+
+## Using Multiple Expectations ##
+So far we've only shown examples where you have a single expectation. More realistically, you're going to specify expectations on multiple mock methods, which may be from multiple mock objects.
+
+By default, when a mock method is invoked, Google Mock will search the expectations in the **reverse order** they are defined, and stop when an active expectation that matches the arguments is found (you can think of it as "newer rules override older ones."). If the matching expectation cannot take any more calls, you will get an upper-bound-violated failure. Here's an example:
+
+```
+using ::testing::_;...
+EXPECT_CALL(turtle, Forward(_));  // #1
+EXPECT_CALL(turtle, Forward(10))  // #2
+    .Times(2);
+```
+
+If `Forward(10)` is called three times in a row, the third time it will be an error, as the last matching expectation (#2) has been saturated. If, however, the third `Forward(10)` call is replaced by `Forward(20)`, then it would be OK, as now #1 will be the matching expectation.
+
+**Side note:** Why does Google Mock search for a match in the _reverse_ order of the expectations? The reason is that this allows a user to set up the default expectations in a mock object's constructor or the test fixture's set-up phase and then customize the mock by writing more specific expectations in the test body. So, if you have two expectations on the same method, you want to put the one with more specific matchers **after** the other, or the more specific rule would be shadowed by the more general one that comes after it.
+
+## Ordered vs Unordered Calls ##
+By default, an expectation can match a call even though an earlier expectation hasn't been satisfied. In other words, the calls don't have to occur in the order the expectations are specified.
+
+Sometimes, you may want all the expected calls to occur in a strict order. To say this in Google Mock is easy:
+
+```
+using ::testing::InSequence;...
+TEST(FooTest, DrawsLineSegment) {
+  ...
+  {
+    InSequence dummy;
+
+    EXPECT_CALL(turtle, PenDown());
+    EXPECT_CALL(turtle, Forward(100));
+    EXPECT_CALL(turtle, PenUp());
+  }
+  Foo();
+}
+```
+
+By creating an object of type `InSequence`, all expectations in its scope are put into a _sequence_ and have to occur _sequentially_. Since we are just relying on the constructor and destructor of this object to do the actual work, its name is really irrelevant.
+
+In this example, we test that `Foo()` calls the three expected functions in the order as written. If a call is made out-of-order, it will be an error.
+
+(What if you care about the relative order of some of the calls, but not all of them? Can you specify an arbitrary partial order? The answer is ... yes! If you are impatient, the details can be found in the [CookBook](CookBook#Expecting_Partially_Ordered_Calls.md).)
+
+## All Expectations Are Sticky (Unless Said Otherwise) ##
+Now let's do a quick quiz to see how well you can use this mock stuff already. How would you test that the turtle is asked to go to the origin _exactly twice_ (you want to ignore any other instructions it receives)?
+
+After you've come up with your answer, take a look at ours and compare notes (solve it yourself first - don't cheat!):
+
+```
+using ::testing::_;...
+EXPECT_CALL(turtle, GoTo(_, _))  // #1
+    .Times(AnyNumber());
+EXPECT_CALL(turtle, GoTo(0, 0))  // #2
+    .Times(2);
+```
+
+Suppose `turtle.GoTo(0, 0)` is called three times. In the third time, Google Mock will see that the arguments match expectation #2 (remember that we always pick the last matching expectation). Now, since we said that there should be only two such calls, Google Mock will report an error immediately. This is basically what we've told you in the "Using Multiple Expectations" section above.
+
+This example shows that **expectations in Google Mock are "sticky" by default**, in the sense that they remain active even after we have reached their invocation upper bounds. This is an important rule to remember, as it affects the meaning of the spec, and is **different** to how it's done in many other mocking frameworks (Why'd we do that? Because we think our rule makes the common cases easier to express and understand.).
+
+Simple? Let's see if you've really understood it: what does the following code say?
+
+```
+using ::testing::Return;
+...
+for (int i = n; i > 0; i--) {
+  EXPECT_CALL(turtle, GetX())
+      .WillOnce(Return(10*i));
+}
+```
+
+If you think it says that `turtle.GetX()` will be called `n` times and will return 10, 20, 30, ..., consecutively, think twice! The problem is that, as we said, expectations are sticky. So, the second time `turtle.GetX()` is called, the last (latest) `EXPECT_CALL()` statement will match, and will immediately lead to an "upper bound exceeded" error - this piece of code is not very useful!
+
+One correct way of saying that `turtle.GetX()` will return 10, 20, 30, ..., is to explicitly say that the expectations are _not_ sticky. In other words, they should _retire_ as soon as they are saturated:
+
+```
+using ::testing::Return;
+...
+for (int i = n; i > 0; i--) {
+  EXPECT_CALL(turtle, GetX())
+    .WillOnce(Return(10*i))
+    .RetiresOnSaturation();
+}
+```
+
+And, there's a better way to do it: in this case, we expect the calls to occur in a specific order, and we line up the actions to match the order. Since the order is important here, we should make it explicit using a sequence:
+
+```
+using ::testing::InSequence;
+using ::testing::Return;
+...
+{
+  InSequence s;
+
+  for (int i = 1; i <= n; i++) {
+    EXPECT_CALL(turtle, GetX())
+        .WillOnce(Return(10*i))
+        .RetiresOnSaturation();
+  }
+}
+```
+
+By the way, the other situation where an expectation may _not_ be sticky is when it's in a sequence - as soon as another expectation that comes after it in the sequence has been used, it automatically retires (and will never be used to match any call).
+
+## Uninteresting Calls ##
+A mock object may have many methods, and not all of them are that interesting. For example, in some tests we may not care about how many times `GetX()` and `GetY()` get called.
+
+In Google Mock, if you are not interested in a method, just don't say anything about it. If a call to this method occurs, you'll see a warning in the test output, but it won't be a failure.
+
+# What Now? #
+Congratulations! You've learned enough about Google Mock to start using it. Now, you might want to join the [googlemock](http://groups.google.com/group/googlemock) discussion group and actually write some tests using Google Mock - it will be fun. Hey, it may even be addictive - you've been warned.
+
+Then, if you feel like increasing your mock quotient, you should move on to the [CookBook](CookBook.md). You can learn many advanced features of Google Mock there -- and advance your level of enjoyment and testing bliss.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/FrequentlyAskedQuestions.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/FrequentlyAskedQuestions.md
new file mode 100644
index 00000000..5eac83f4
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/FrequentlyAskedQuestions.md
@@ -0,0 +1,628 @@
+
+
+Please send your questions to the
+[googlemock](http://groups.google.com/group/googlemock) discussion
+group. If you need help with compiler errors, make sure you have
+tried [Google Mock Doctor](#How_am_I_supposed_to_make_sense_of_these_horrible_template_error.md) first.
+
+## When I call a method on my mock object, the method for the real object is invoked instead.  What's the problem? ##
+
+In order for a method to be mocked, it must be _virtual_, unless you use the [high-perf dependency injection technique](CookBook.md#mocking-nonvirtual-methods).
+
+## I wrote some matchers.  After I upgraded to a new version of Google Mock, they no longer compile.  What's going on? ##
+
+After version 1.4.0 of Google Mock was released, we had an idea on how
+to make it easier to write matchers that can generate informative
+messages efficiently.  We experimented with this idea and liked what
+we saw.  Therefore we decided to implement it.
+
+Unfortunately, this means that if you have defined your own matchers
+by implementing `MatcherInterface` or using `MakePolymorphicMatcher()`,
+your definitions will no longer compile.  Matchers defined using the
+`MATCHER*` family of macros are not affected.
+
+Sorry for the hassle if your matchers are affected.  We believe it's
+in everyone's long-term interest to make this change sooner than
+later.  Fortunately, it's usually not hard to migrate an existing
+matcher to the new API.  Here's what you need to do:
+
+If you wrote your matcher like this:
+```
+// Old matcher definition that doesn't work with the latest
+// Google Mock.
+using ::testing::MatcherInterface;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetFoo() > 5;
+  }
+  ...
+};
+```
+
+you'll need to change it to:
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool MatchAndExplain(MyType value,
+                               MatchResultListener* listener) const {
+    // Returns true if value matches.
+    return value.GetFoo() > 5;
+  }
+  ...
+};
+```
+(i.e. rename `Matches()` to `MatchAndExplain()` and give it a second
+argument of type `MatchResultListener*`.)
+
+If you were also using `ExplainMatchResultTo()` to improve the matcher
+message:
+```
+// Old matcher definition that doesn't work with the lastest
+// Google Mock.
+using ::testing::MatcherInterface;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetFoo() > 5;
+  }
+
+  virtual void ExplainMatchResultTo(MyType value,
+                                    ::std::ostream* os) const {
+    // Prints some helpful information to os to help
+    // a user understand why value matches (or doesn't match).
+    *os << "the Foo property is " << value.GetFoo();
+  }
+  ...
+};
+```
+
+you should move the logic of `ExplainMatchResultTo()` into
+`MatchAndExplain()`, using the `MatchResultListener` argument where
+the `::std::ostream` was used:
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool MatchAndExplain(MyType value,
+                               MatchResultListener* listener) const {
+    // Returns true if value matches.
+    *listener << "the Foo property is " << value.GetFoo();
+    return value.GetFoo() > 5;
+  }
+  ...
+};
+```
+
+If your matcher is defined using `MakePolymorphicMatcher()`:
+```
+// Old matcher definition that doesn't work with the latest
+// Google Mock.
+using ::testing::MakePolymorphicMatcher;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetBar() < 42;
+  }
+  ...
+};
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+you should rename the `Matches()` method to `MatchAndExplain()` and
+add a `MatchResultListener*` argument (the same as what you need to do
+for matchers defined by implementing `MatcherInterface`):
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MakePolymorphicMatcher;
+using ::testing::MatchResultListener;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool MatchAndExplain(MyType value,
+                       MatchResultListener* listener) const {
+    // Returns true if value matches.
+    return value.GetBar() < 42;
+  }
+  ...
+};
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+If your polymorphic matcher uses `ExplainMatchResultTo()` for better
+failure messages:
+```
+// Old matcher definition that doesn't work with the latest
+// Google Mock.
+using ::testing::MakePolymorphicMatcher;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetBar() < 42;
+  }
+  ...
+};
+void ExplainMatchResultTo(const MyGreatMatcher& matcher,
+                          MyType value,
+                          ::std::ostream* os) {
+  // Prints some helpful information to os to help
+  // a user understand why value matches (or doesn't match).
+  *os << "the Bar property is " << value.GetBar();
+}
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+you'll need to move the logic inside `ExplainMatchResultTo()` to
+`MatchAndExplain()`:
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MakePolymorphicMatcher;
+using ::testing::MatchResultListener;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool MatchAndExplain(MyType value,
+                       MatchResultListener* listener) const {
+    // Returns true if value matches.
+    *listener << "the Bar property is " << value.GetBar();
+    return value.GetBar() < 42;
+  }
+  ...
+};
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+For more information, you can read these
+[two](CookBook.md#writing-new-monomorphic-matchers)
+[recipes](CookBook.md#writing-new-polymorphic-matchers)
+from the cookbook.  As always, you
+are welcome to post questions on `googlemock@googlegroups.com` if you
+need any help.
+
+## When using Google Mock, do I have to use Google Test as the testing framework?  I have my favorite testing framework and don't want to switch. ##
+
+Google Mock works out of the box with Google Test.  However, it's easy
+to configure it to work with any testing framework of your choice.
+[Here](ForDummies.md#using-google-mock-with-any-testing-framework) is how.
+
+## How am I supposed to make sense of these horrible template errors? ##
+
+If you are confused by the compiler errors gcc threw at you,
+try consulting the _Google Mock Doctor_ tool first.  What it does is to
+scan stdin for gcc error messages, and spit out diagnoses on the
+problems (we call them diseases) your code has.
+
+To "install", run command:
+```
+alias gmd='<path to googlemock>/scripts/gmock_doctor.py'
+```
+
+To use it, do:
+```
+<your-favorite-build-command> <your-test> 2>&1 | gmd
+```
+
+For example:
+```
+make my_test 2>&1 | gmd
+```
+
+Or you can run `gmd` and copy-n-paste gcc's error messages to it.
+
+## Can I mock a variadic function? ##
+
+You cannot mock a variadic function (i.e. a function taking ellipsis
+(`...`) arguments) directly in Google Mock.
+
+The problem is that in general, there is _no way_ for a mock object to
+know how many arguments are passed to the variadic method, and what
+the arguments' types are.  Only the _author of the base class_ knows
+the protocol, and we cannot look into his head.
+
+Therefore, to mock such a function, the _user_ must teach the mock
+object how to figure out the number of arguments and their types.  One
+way to do it is to provide overloaded versions of the function.
+
+Ellipsis arguments are inherited from C and not really a C++ feature.
+They are unsafe to use and don't work with arguments that have
+constructors or destructors.  Therefore we recommend to avoid them in
+C++ as much as possible.
+
+## MSVC gives me warning C4301 or C4373 when I define a mock method with a const parameter.  Why? ##
+
+If you compile this using Microsoft Visual C++ 2005 SP1:
+```
+class Foo {
+  ...
+  virtual void Bar(const int i) = 0;
+};
+
+class MockFoo : public Foo {
+  ...
+  MOCK_METHOD1(Bar, void(const int i));
+};
+```
+You may get the following warning:
+```
+warning C4301: 'MockFoo::Bar': overriding virtual function only differs from 'Foo::Bar' by const/volatile qualifier
+```
+
+This is a MSVC bug.  The same code compiles fine with gcc ,for
+example.  If you use Visual C++ 2008 SP1, you would get the warning:
+```
+warning C4373: 'MockFoo::Bar': virtual function overrides 'Foo::Bar', previous versions of the compiler did not override when parameters only differed by const/volatile qualifiers
+```
+
+In C++, if you _declare_ a function with a `const` parameter, the
+`const` modifier is _ignored_.  Therefore, the `Foo` base class above
+is equivalent to:
+```
+class Foo {
+  ...
+  virtual void Bar(int i) = 0;  // int or const int?  Makes no difference.
+};
+```
+
+In fact, you can _declare_ Bar() with an `int` parameter, and _define_
+it with a `const int` parameter.  The compiler will still match them
+up.
+
+Since making a parameter `const` is meaningless in the method
+_declaration_, we recommend to remove it in both `Foo` and `MockFoo`.
+That should workaround the VC bug.
+
+Note that we are talking about the _top-level_ `const` modifier here.
+If the function parameter is passed by pointer or reference, declaring
+the _pointee_ or _referee_ as `const` is still meaningful.  For
+example, the following two declarations are _not_ equivalent:
+```
+void Bar(int* p);        // Neither p nor *p is const.
+void Bar(const int* p);  // p is not const, but *p is.
+```
+
+## I have a huge mock class, and Microsoft Visual C++ runs out of memory when compiling it.  What can I do? ##
+
+We've noticed that when the `/clr` compiler flag is used, Visual C++
+uses 5~6 times as much memory when compiling a mock class.  We suggest
+to avoid `/clr` when compiling native C++ mocks.
+
+## I can't figure out why Google Mock thinks my expectations are not satisfied.  What should I do? ##
+
+You might want to run your test with
+`--gmock_verbose=info`.  This flag lets Google Mock print a trace
+of every mock function call it receives.  By studying the trace,
+you'll gain insights on why the expectations you set are not met.
+
+## How can I assert that a function is NEVER called? ##
+
+```
+EXPECT_CALL(foo, Bar(_))
+    .Times(0);
+```
+
+## I have a failed test where Google Mock tells me TWICE that a particular expectation is not satisfied.  Isn't this redundant? ##
+
+When Google Mock detects a failure, it prints relevant information
+(the mock function arguments, the state of relevant expectations, and
+etc) to help the user debug.  If another failure is detected, Google
+Mock will do the same, including printing the state of relevant
+expectations.
+
+Sometimes an expectation's state didn't change between two failures,
+and you'll see the same description of the state twice.  They are
+however _not_ redundant, as they refer to _different points in time_.
+The fact they are the same _is_ interesting information.
+
+## I get a heap check failure when using a mock object, but using a real object is fine.  What can be wrong? ##
+
+Does the class (hopefully a pure interface) you are mocking have a
+virtual destructor?
+
+Whenever you derive from a base class, make sure its destructor is
+virtual.  Otherwise Bad Things will happen.  Consider the following
+code:
+
+```
+class Base {
+ public:
+  // Not virtual, but should be.
+  ~Base() { ... }
+  ...
+};
+
+class Derived : public Base {
+ public:
+  ...
+ private:
+  std::string value_;
+};
+
+...
+  Base* p = new Derived;
+  ...
+  delete p;  // Surprise! ~Base() will be called, but ~Derived() will not
+             // - value_ is leaked.
+```
+
+By changing `~Base()` to virtual, `~Derived()` will be correctly
+called when `delete p` is executed, and the heap checker
+will be happy.
+
+## The "newer expectations override older ones" rule makes writing expectations awkward.  Why does Google Mock do that? ##
+
+When people complain about this, often they are referring to code like:
+
+```
+// foo.Bar() should be called twice, return 1 the first time, and return
+// 2 the second time.  However, I have to write the expectations in the
+// reverse order.  This sucks big time!!!
+EXPECT_CALL(foo, Bar())
+    .WillOnce(Return(2))
+    .RetiresOnSaturation();
+EXPECT_CALL(foo, Bar())
+    .WillOnce(Return(1))
+    .RetiresOnSaturation();
+```
+
+The problem is that they didn't pick the **best** way to express the test's
+intent.
+
+By default, expectations don't have to be matched in _any_ particular
+order.  If you want them to match in a certain order, you need to be
+explicit.  This is Google Mock's (and jMock's) fundamental philosophy: it's
+easy to accidentally over-specify your tests, and we want to make it
+harder to do so.
+
+There are two better ways to write the test spec.  You could either
+put the expectations in sequence:
+
+```
+// foo.Bar() should be called twice, return 1 the first time, and return
+// 2 the second time.  Using a sequence, we can write the expectations
+// in their natural order.
+{
+  InSequence s;
+  EXPECT_CALL(foo, Bar())
+      .WillOnce(Return(1))
+      .RetiresOnSaturation();
+  EXPECT_CALL(foo, Bar())
+      .WillOnce(Return(2))
+      .RetiresOnSaturation();
+}
+```
+
+or you can put the sequence of actions in the same expectation:
+
+```
+// foo.Bar() should be called twice, return 1 the first time, and return
+// 2 the second time.
+EXPECT_CALL(foo, Bar())
+    .WillOnce(Return(1))
+    .WillOnce(Return(2))
+    .RetiresOnSaturation();
+```
+
+Back to the original questions: why does Google Mock search the
+expectations (and `ON_CALL`s) from back to front?  Because this
+allows a user to set up a mock's behavior for the common case early
+(e.g. in the mock's constructor or the test fixture's set-up phase)
+and customize it with more specific rules later.  If Google Mock
+searches from front to back, this very useful pattern won't be
+possible.
+
+## Google Mock prints a warning when a function without EXPECT\_CALL is called, even if I have set its behavior using ON\_CALL.  Would it be reasonable not to show the warning in this case? ##
+
+When choosing between being neat and being safe, we lean toward the
+latter.  So the answer is that we think it's better to show the
+warning.
+
+Often people write `ON_CALL`s in the mock object's
+constructor or `SetUp()`, as the default behavior rarely changes from
+test to test.  Then in the test body they set the expectations, which
+are often different for each test.  Having an `ON_CALL` in the set-up
+part of a test doesn't mean that the calls are expected.  If there's
+no `EXPECT_CALL` and the method is called, it's possibly an error.  If
+we quietly let the call go through without notifying the user, bugs
+may creep in unnoticed.
+
+If, however, you are sure that the calls are OK, you can write
+
+```
+EXPECT_CALL(foo, Bar(_))
+    .WillRepeatedly(...);
+```
+
+instead of
+
+```
+ON_CALL(foo, Bar(_))
+    .WillByDefault(...);
+```
+
+This tells Google Mock that you do expect the calls and no warning should be
+printed.
+
+Also, you can control the verbosity using the `--gmock_verbose` flag.
+If you find the output too noisy when debugging, just choose a less
+verbose level.
+
+## How can I delete the mock function's argument in an action? ##
+
+If you find yourself needing to perform some action that's not
+supported by Google Mock directly, remember that you can define your own
+actions using
+[MakeAction()](CookBook.md#writing-new-actions) or
+[MakePolymorphicAction()](CookBook.md#writing_new_polymorphic_actions),
+or you can write a stub function and invoke it using
+[Invoke()](CookBook.md#using-functions_methods_functors).
+
+## MOCK\_METHODn()'s second argument looks funny.  Why don't you use the MOCK\_METHODn(Method, return\_type, arg\_1, ..., arg\_n) syntax? ##
+
+What?!  I think it's beautiful. :-)
+
+While which syntax looks more natural is a subjective matter to some
+extent, Google Mock's syntax was chosen for several practical advantages it
+has.
+
+Try to mock a function that takes a map as an argument:
+```
+virtual int GetSize(const map<int, std::string>& m);
+```
+
+Using the proposed syntax, it would be:
+```
+MOCK_METHOD1(GetSize, int, const map<int, std::string>& m);
+```
+
+Guess what?  You'll get a compiler error as the compiler thinks that
+`const map<int, std::string>& m` are **two**, not one, arguments. To work
+around this you can use `typedef` to give the map type a name, but
+that gets in the way of your work.  Google Mock's syntax avoids this
+problem as the function's argument types are protected inside a pair
+of parentheses:
+```
+// This compiles fine.
+MOCK_METHOD1(GetSize, int(const map<int, std::string>& m));
+```
+
+You still need a `typedef` if the return type contains an unprotected
+comma, but that's much rarer.
+
+Other advantages include:
+  1. `MOCK_METHOD1(Foo, int, bool)` can leave a reader wonder whether the method returns `int` or `bool`, while there won't be such confusion using Google Mock's syntax.
+  1. The way Google Mock describes a function type is nothing new, although many people may not be familiar with it.  The same syntax was used in C, and the `function` library in `tr1` uses this syntax extensively.  Since `tr1` will become a part of the new version of STL, we feel very comfortable to be consistent with it.
+  1. The function type syntax is also used in other parts of Google Mock's API (e.g. the action interface) in order to make the implementation tractable. A user needs to learn it anyway in order to utilize Google Mock's more advanced features.  We'd as well stick to the same syntax in `MOCK_METHOD*`!
+
+## My code calls a static/global function.  Can I mock it? ##
+
+You can, but you need to make some changes.
+
+In general, if you find yourself needing to mock a static function,
+it's a sign that your modules are too tightly coupled (and less
+flexible, less reusable, less testable, etc).  You are probably better
+off defining a small interface and call the function through that
+interface, which then can be easily mocked.  It's a bit of work
+initially, but usually pays for itself quickly.
+
+This Google Testing Blog
+[post](http://googletesting.blogspot.com/2008/06/defeat-static-cling.html)
+says it excellently.  Check it out.
+
+## My mock object needs to do complex stuff.  It's a lot of pain to specify the actions.  Google Mock sucks! ##
+
+I know it's not a question, but you get an answer for free any way. :-)
+
+With Google Mock, you can create mocks in C++ easily.  And people might be
+tempted to use them everywhere. Sometimes they work great, and
+sometimes you may find them, well, a pain to use. So, what's wrong in
+the latter case?
+
+When you write a test without using mocks, you exercise the code and
+assert that it returns the correct value or that the system is in an
+expected state.  This is sometimes called "state-based testing".
+
+Mocks are great for what some call "interaction-based" testing:
+instead of checking the system state at the very end, mock objects
+verify that they are invoked the right way and report an error as soon
+as it arises, giving you a handle on the precise context in which the
+error was triggered.  This is often more effective and economical to
+do than state-based testing.
+
+If you are doing state-based testing and using a test double just to
+simulate the real object, you are probably better off using a fake.
+Using a mock in this case causes pain, as it's not a strong point for
+mocks to perform complex actions.  If you experience this and think
+that mocks suck, you are just not using the right tool for your
+problem. Or, you might be trying to solve the wrong problem. :-)
+
+## I got a warning "Uninteresting function call encountered - default action taken.."  Should I panic? ##
+
+By all means, NO!  It's just an FYI.
+
+What it means is that you have a mock function, you haven't set any
+expectations on it (by Google Mock's rule this means that you are not
+interested in calls to this function and therefore it can be called
+any number of times), and it is called.  That's OK - you didn't say
+it's not OK to call the function!
+
+What if you actually meant to disallow this function to be called, but
+forgot to write `EXPECT_CALL(foo, Bar()).Times(0)`?  While
+one can argue that it's the user's fault, Google Mock tries to be nice and
+prints you a note.
+
+So, when you see the message and believe that there shouldn't be any
+uninteresting calls, you should investigate what's going on.  To make
+your life easier, Google Mock prints the function name and arguments
+when an uninteresting call is encountered.
+
+## I want to define a custom action.  Should I use Invoke() or implement the action interface? ##
+
+Either way is fine - you want to choose the one that's more convenient
+for your circumstance.
+
+Usually, if your action is for a particular function type, defining it
+using `Invoke()` should be easier; if your action can be used in
+functions of different types (e.g. if you are defining
+`Return(value)`), `MakePolymorphicAction()` is
+easiest.  Sometimes you want precise control on what types of
+functions the action can be used in, and implementing
+`ActionInterface` is the way to go here. See the implementation of
+`Return()` in `include/gmock/gmock-actions.h` for an example.
+
+## I'm using the set-argument-pointee action, and the compiler complains about "conflicting return type specified".  What does it mean? ##
+
+You got this error as Google Mock has no idea what value it should return
+when the mock method is called.  `SetArgPointee()` says what the
+side effect is, but doesn't say what the return value should be.  You
+need `DoAll()` to chain a `SetArgPointee()` with a `Return()`.
+
+See this [recipe](CookBook.md#mocking_side_effects) for more details and an example.
+
+
+## My question is not in your FAQ! ##
+
+If you cannot find the answer to your question in this FAQ, there are
+some other resources you can use:
+
+  1. read other [documentation](Documentation.md),
+  1. search the mailing list [archive](http://groups.google.com/group/googlemock/topics),
+  1. ask it on [googlemock@googlegroups.com](mailto:googlemock@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googlemock) before you can post.).
+
+Please note that creating an issue in the
+[issue tracker](https://github.com/google/googletest/issues) is _not_
+a good way to get your answer, as it is monitored infrequently by a
+very small number of people.
+
+When asking a question, it's helpful to provide as much of the
+following information as possible (people cannot help you if there's
+not enough information in your question):
+
+  * the version (or the revision number if you check out from SVN directly) of Google Mock you use (Google Mock is under active development, so it's possible that your problem has been solved in a later version),
+  * your operating system,
+  * the name and version of your compiler,
+  * the complete command line flags you give to your compiler,
+  * the complete compiler error messages (if the question is about compilation),
+  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/KnownIssues.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/KnownIssues.md
new file mode 100644
index 00000000..adadf514
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/KnownIssues.md
@@ -0,0 +1,19 @@
+As any non-trivial software system, Google Mock has some known limitations and problems.  We are working on improving it, and welcome your help!  The follow is a list of issues we know about.
+
+
+
+## README contains outdated information on Google Mock's compatibility with other testing frameworks ##
+
+The `README` file in release 1.1.0 still says that Google Mock only works with Google Test.  Actually, you can configure Google Mock to work with any testing framework you choose.
+
+## Tests failing on machines using Power PC CPUs (e.g. some Macs) ##
+
+`gmock_output_test` and `gmock-printers_test` are known to fail with Power PC CPUs.  This is due to portability issues with these tests, and is not an indication of problems in Google Mock itself.  You can safely ignore them.
+
+## Failed to resolve libgtest.so.0 in tests when built against installed Google Test ##
+
+This only applies if you manually built and installed Google Test, and then built a Google Mock against it (either explicitly, or because gtest-config was in your path post-install). In this situation, Libtool has a known issue with certain systems' ldconfig setup:
+
+http://article.gmane.org/gmane.comp.sysutils.automake.general/9025
+
+This requires a manual run of "sudo ldconfig" after the "sudo make install" for Google Test before any binaries which link against it can be executed. This isn't a bug in our install, but we should at least have documented it or hacked a work-around into our install. We should have one of these solutions in our next release.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CheatSheet.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CheatSheet.md
new file mode 100644
index 00000000..3c7bed4c
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CheatSheet.md
@@ -0,0 +1,525 @@
+
+
+# Defining a Mock Class #
+
+## Mocking a Normal Class ##
+
+Given
+```
+class Foo {
+  ...
+  virtual ~Foo();
+  virtual int GetSize() const = 0;
+  virtual string Describe(const char* name) = 0;
+  virtual string Describe(int type) = 0;
+  virtual bool Process(Bar elem, int count) = 0;
+};
+```
+(note that `~Foo()` **must** be virtual) we can define its mock as
+```
+#include <gmock/gmock.h>
+
+class MockFoo : public Foo {
+  MOCK_CONST_METHOD0(GetSize, int());
+  MOCK_METHOD1(Describe, string(const char* name));
+  MOCK_METHOD1(Describe, string(int type));
+  MOCK_METHOD2(Process, bool(Bar elem, int count));
+};
+```
+
+To create a "nice" mock object which ignores all uninteresting calls,
+or a "strict" mock object, which treats them as failures:
+```
+NiceMock<MockFoo> nice_foo;     // The type is a subclass of MockFoo.
+StrictMock<MockFoo> strict_foo; // The type is a subclass of MockFoo.
+```
+
+## Mocking a Class Template ##
+
+To mock
+```
+template <typename Elem>
+class StackInterface {
+ public:
+  ...
+  virtual ~StackInterface();
+  virtual int GetSize() const = 0;
+  virtual void Push(const Elem& x) = 0;
+};
+```
+(note that `~StackInterface()` **must** be virtual) just append `_T` to the `MOCK_*` macros:
+```
+template <typename Elem>
+class MockStack : public StackInterface<Elem> {
+ public:
+  ...
+  MOCK_CONST_METHOD0_T(GetSize, int());
+  MOCK_METHOD1_T(Push, void(const Elem& x));
+};
+```
+
+## Specifying Calling Conventions for Mock Functions ##
+
+If your mock function doesn't use the default calling convention, you
+can specify it by appending `_WITH_CALLTYPE` to any of the macros
+described in the previous two sections and supplying the calling
+convention as the first argument to the macro. For example,
+```
+  MOCK_METHOD_1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int n));
+  MOCK_CONST_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, Bar, int(double x, double y));
+```
+where `STDMETHODCALLTYPE` is defined by `<objbase.h>` on Windows.
+
+# Using Mocks in Tests #
+
+The typical flow is:
+  1. Import the Google Mock names you need to use. All Google Mock names are in the `testing` namespace unless they are macros or otherwise noted.
+  1. Create the mock objects.
+  1. Optionally, set the default actions of the mock objects.
+  1. Set your expectations on the mock objects (How will they be called? What wil they do?).
+  1. Exercise code that uses the mock objects; if necessary, check the result using [Google Test](http://code.google.com/p/googletest/) assertions.
+  1. When a mock objects is destructed, Google Mock automatically verifies that all expectations on it have been satisfied.
+
+Here is an example:
+```
+using ::testing::Return;                            // #1
+
+TEST(BarTest, DoesThis) {
+  MockFoo foo;                                    // #2
+
+  ON_CALL(foo, GetSize())                         // #3
+      .WillByDefault(Return(1));
+  // ... other default actions ...
+
+  EXPECT_CALL(foo, Describe(5))                   // #4
+      .Times(3)
+      .WillRepeatedly(Return("Category 5"));
+  // ... other expectations ...
+
+  EXPECT_EQ("good", MyProductionFunction(&foo));  // #5
+}                                                 // #6
+```
+
+# Setting Default Actions #
+
+Google Mock has a **built-in default action** for any function that
+returns `void`, `bool`, a numeric value, or a pointer.
+
+To customize the default action for functions with return type `T` globally:
+```
+using ::testing::DefaultValue;
+
+DefaultValue<T>::Set(value);  // Sets the default value to be returned.
+// ... use the mocks ...
+DefaultValue<T>::Clear();     // Resets the default value.
+```
+
+To customize the default action for a particular method, use `ON_CALL()`:
+```
+ON_CALL(mock_object, method(matchers))
+    .With(multi_argument_matcher)  ?
+    .WillByDefault(action);
+```
+
+# Setting Expectations #
+
+`EXPECT_CALL()` sets **expectations** on a mock method (How will it be
+called? What will it do?):
+```
+EXPECT_CALL(mock_object, method(matchers))
+    .With(multi_argument_matcher)  ?
+    .Times(cardinality)            ?
+    .InSequence(sequences)         *
+    .After(expectations)           *
+    .WillOnce(action)              *
+    .WillRepeatedly(action)        ?
+    .RetiresOnSaturation();        ?
+```
+
+If `Times()` is omitted, the cardinality is assumed to be:
+
+  * `Times(1)` when there is neither `WillOnce()` nor `WillRepeatedly()`;
+  * `Times(n)` when there are `n WillOnce()`s but no `WillRepeatedly()`, where `n` >= 1; or
+  * `Times(AtLeast(n))` when there are `n WillOnce()`s and a `WillRepeatedly()`, where `n` >= 0.
+
+A method with no `EXPECT_CALL()` is free to be invoked _any number of times_, and the default action will be taken each time.
+
+# Matchers #
+
+A **matcher** matches a _single_ argument.  You can use it inside
+`ON_CALL()` or `EXPECT_CALL()`, or use it to validate a value
+directly:
+
+| `EXPECT_THAT(value, matcher)` | Asserts that `value` matches `matcher`. |
+|:------------------------------|:----------------------------------------|
+| `ASSERT_THAT(value, matcher)` | The same as `EXPECT_THAT(value, matcher)`, except that it generates a **fatal** failure. |
+
+Built-in matchers (where `argument` is the function argument) are
+divided into several categories:
+
+## Wildcard ##
+|`_`|`argument` can be any value of the correct type.|
+|:--|:-----------------------------------------------|
+|`A<type>()` or `An<type>()`|`argument` can be any value of type `type`.     |
+
+## Generic Comparison ##
+
+|`Eq(value)` or `value`|`argument == value`|
+|:---------------------|:------------------|
+|`Ge(value)`           |`argument >= value`|
+|`Gt(value)`           |`argument > value` |
+|`Le(value)`           |`argument <= value`|
+|`Lt(value)`           |`argument < value` |
+|`Ne(value)`           |`argument != value`|
+|`IsNull()`            |`argument` is a `NULL` pointer (raw or smart).|
+|`NotNull()`           |`argument` is a non-null pointer (raw or smart).|
+|`Ref(variable)`       |`argument` is a reference to `variable`.|
+|`TypedEq<type>(value)`|`argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded.|
+
+Except `Ref()`, these matchers make a _copy_ of `value` in case it's
+modified or destructed later. If the compiler complains that `value`
+doesn't have a public copy constructor, try wrap it in `ByRef()`,
+e.g. `Eq(ByRef(non_copyable_value))`. If you do that, make sure
+`non_copyable_value` is not changed afterwards, or the meaning of your
+matcher will be changed.
+
+## Floating-Point Matchers ##
+
+|`DoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as unequal.|
+|:-------------------|:----------------------------------------------------------------------------------------------|
+|`FloatEq(a_float)`  |`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal.  |
+|`NanSensitiveDoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal.  |
+|`NanSensitiveFloatEq(a_float)`|`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal.    |
+
+The above matchers use ULP-based comparison (the same as used in
+[Google Test](http://code.google.com/p/googletest/)). They
+automatically pick a reasonable error bound based on the absolute
+value of the expected value.  `DoubleEq()` and `FloatEq()` conform to
+the IEEE standard, which requires comparing two NaNs for equality to
+return false. The `NanSensitive*` version instead treats two NaNs as
+equal, which is often what a user wants.
+
+## String Matchers ##
+
+The `argument` can be either a C string or a C++ string object:
+
+|`ContainsRegex(string)`|`argument` matches the given regular expression.|
+|:----------------------|:-----------------------------------------------|
+|`EndsWith(suffix)`     |`argument` ends with string `suffix`.           |
+|`HasSubstr(string)`    |`argument` contains `string` as a sub-string.   |
+|`MatchesRegex(string)` |`argument` matches the given regular expression with the match starting at the first character and ending at the last character.|
+|`StartsWith(prefix)`   |`argument` starts with string `prefix`.         |
+|`StrCaseEq(string)`    |`argument` is equal to `string`, ignoring case. |
+|`StrCaseNe(string)`    |`argument` is not equal to `string`, ignoring case.|
+|`StrEq(string)`        |`argument` is equal to `string`.                |
+|`StrNe(string)`        |`argument` is not equal to `string`.            |
+
+`StrCaseEq()`, `StrCaseNe()`, `StrEq()`, and `StrNe()` work for wide
+strings as well.
+
+## Container Matchers ##
+
+Most STL-style containers support `==`, so you can use
+`Eq(expected_container)` or simply `expected_container` to match a
+container exactly.   If you want to write the elements in-line,
+match them more flexibly, or get more informative messages, you can use:
+
+| `Contains(e)` | `argument` contains an element that matches `e`, which can be either a value or a matcher. |
+|:--------------|:-------------------------------------------------------------------------------------------|
+|`ElementsAre(e0, e1, ..., en)`|`argument` has `n + 1` elements, where the i-th element matches `ei`, which can be a value or a matcher. 0 to 10 arguments are allowed.|
+|`ElementsAreArray(array)` or `ElementsAreArray(array, count)`|The same as `ElementsAre()` except that the expected element values/matchers come from a C-style array.|
+| `ContainerEq(container)` | The same as `Eq(container)` except that the failure message also includes which elements are in one container but not the other. |
+
+These matchers can also match:
+
+  1. a native array passed by reference (e.g. in `Foo(const int (&a)[5])`), and
+  1. an array passed as a pointer and a count (e.g. in `Bar(const T* buffer, int len)` -- see [Multi-argument Matchers](#Multiargument_Matchers.md)).
+
+where the array may be multi-dimensional (i.e. its elements can be arrays).
+
+## Member Matchers ##
+
+|`Field(&class::field, m)`|`argument.field` (or `argument->field` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
+|:------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------|
+|`Key(e)`                 |`argument.first` matches `e`, which can be either a value or a matcher. E.g. `Contains(Key(Le(5)))` can verify that a `map` contains a key `<= 5`.|
+|`Pair(m1, m2)`           |`argument` is an `std::pair` whose `first` field matches `m1` and `second` field matches `m2`.                                                |
+|`Property(&class::property, m)`|`argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
+
+## Matching the Result of a Function or Functor ##
+
+|`ResultOf(f, m)`|`f(argument)` matches matcher `m`, where `f` is a function or functor.|
+|:---------------|:---------------------------------------------------------------------|
+
+## Pointer Matchers ##
+
+|`Pointee(m)`|`argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`.|
+|:-----------|:-----------------------------------------------------------------------------------------------|
+
+## Multiargument Matchers ##
+
+These are matchers on tuple types. They can be used in
+`.With()`. The following can be used on functions with <i>two<br>
+arguments</i> `x` and `y`:
+
+|`Eq()`|`x == y`|
+|:-----|:-------|
+|`Ge()`|`x >= y`|
+|`Gt()`|`x > y` |
+|`Le()`|`x <= y`|
+|`Lt()`|`x < y` |
+|`Ne()`|`x != y`|
+
+You can use the following selectors to pick a subset of the arguments
+(or reorder them) to participate in the matching:
+
+|`AllArgs(m)`|Equivalent to `m`. Useful as syntactic sugar in `.With(AllArgs(m))`.|
+|:-----------|:-------------------------------------------------------------------|
+|`Args<N1, N2, ..., Nk>(m)`|The `k` selected (using 0-based indices) arguments match `m`, e.g. `Args<1, 2>(Contains(5))`.|
+
+## Composite Matchers ##
+
+You can make a matcher from one or more other matchers:
+
+|`AllOf(m1, m2, ..., mn)`|`argument` matches all of the matchers `m1` to `mn`.|
+|:-----------------------|:---------------------------------------------------|
+|`AnyOf(m1, m2, ..., mn)`|`argument` matches at least one of the matchers `m1` to `mn`.|
+|`Not(m)`                |`argument` doesn't match matcher `m`.               |
+
+## Adapters for Matchers ##
+
+|`MatcherCast<T>(m)`|casts matcher `m` to type `Matcher<T>`.|
+|:------------------|:--------------------------------------|
+|`SafeMatcherCast<T>(m)`| [safely casts](V1_5_CookBook#Casting_Matchers.md) matcher `m` to type `Matcher<T>`. |
+|`Truly(predicate)` |`predicate(argument)` returns something considered by C++ to be true, where `predicate` is a function or functor.|
+
+## Matchers as Predicates ##
+
+|`Matches(m)`|a unary functor that returns `true` if the argument matches `m`.|
+|:-----------|:---------------------------------------------------------------|
+|`ExplainMatchResult(m, value, result_listener)`|returns `true` if `value` matches `m`, explaining the result to `result_listener`.|
+|`Value(x, m)`|returns `true` if the value of `x` matches `m`.                 |
+
+## Defining Matchers ##
+
+| `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. |
+|:-------------------------------------------------|:------------------------------------------------------|
+| `MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; }` | Defines a macher `IsDivisibleBy(n)` to match a number divisible by `n`. |
+| `MATCHER_P2(IsBetween, a, b, "is between %(a)s and %(b)s") { return a <= arg && arg <= b; }` | Defines a matcher `IsBetween(a, b)` to match a value in the range [`a`, `b`]. |
+
+**Notes:**
+
+  1. The `MATCHER*` macros cannot be used inside a function or class.
+  1. The matcher body must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters).
+  1. You can use `PrintToString(x)` to convert a value `x` of any type to a string.
+
+## Matchers as Test Assertions ##
+
+|`ASSERT_THAT(expression, m)`|Generates a [fatal failure](http://code.google.com/p/googletest/wiki/GoogleTestPrimer#Assertions) if the value of `expression` doesn't match matcher `m`.|
+|:---------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------|
+|`EXPECT_THAT(expression, m)`|Generates a non-fatal failure if the value of `expression` doesn't match matcher `m`.                                                                    |
+
+# Actions #
+
+**Actions** specify what a mock function should do when invoked.
+
+## Returning a Value ##
+
+|`Return()`|Return from a `void` mock function.|
+|:---------|:----------------------------------|
+|`Return(value)`|Return `value`.                    |
+|`ReturnArg<N>()`|Return the `N`-th (0-based) argument.|
+|`ReturnNew<T>(a1, ..., ak)`|Return `new T(a1, ..., ak)`; a different object is created each time.|
+|`ReturnNull()`|Return a null pointer.             |
+|`ReturnRef(variable)`|Return a reference to `variable`.  |
+
+## Side Effects ##
+
+|`Assign(&variable, value)`|Assign `value` to variable.|
+|:-------------------------|:--------------------------|
+| `DeleteArg<N>()`         | Delete the `N`-th (0-based) argument, which must be a pointer. |
+| `SaveArg<N>(pointer)`    | Save the `N`-th (0-based) argument to `*pointer`. |
+| `SetArgReferee<N>(value)` |	Assign value to the variable referenced by the `N`-th (0-based) argument. |
+|`SetArgumentPointee<N>(value)`|Assign `value` to the variable pointed by the `N`-th (0-based) argument.|
+|`SetArrayArgument<N>(first, last)`|Copies the elements in source range [`first`, `last`) to the array pointed to by the `N`-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.|
+|`SetErrnoAndReturn(error, value)`|Set `errno` to `error` and return `value`.|
+|`Throw(exception)`        |Throws the given exception, which can be any copyable value. Available since v1.1.0.|
+
+## Using a Function or a Functor as an Action ##
+
+|`Invoke(f)`|Invoke `f` with the arguments passed to the mock function, where `f` can be a global/static function or a functor.|
+|:----------|:-----------------------------------------------------------------------------------------------------------------|
+|`Invoke(object_pointer, &class::method)`|Invoke the {method on the object with the arguments passed to the mock function.                                  |
+|`InvokeWithoutArgs(f)`|Invoke `f`, which can be a global/static function or a functor. `f` must take no arguments.                       |
+|`InvokeWithoutArgs(object_pointer, &class::method)`|Invoke the method on the object, which takes no arguments.                                                        |
+|`InvokeArgument<N>(arg1, arg2, ..., argk)`|Invoke the mock function's `N`-th (0-based) argument, which must be a function or a functor, with the `k` arguments.|
+
+The return value of the invoked function is used as the return value
+of the action.
+
+When defining a function or functor to be used with `Invoke*()`, you can declare any unused parameters as `Unused`:
+```
+  double Distance(Unused, double x, double y) { return sqrt(x*x + y*y); }
+  ...
+  EXPECT_CALL(mock, Foo("Hi", _, _)).WillOnce(Invoke(Distance));
+```
+
+In `InvokeArgument<N>(...)`, if an argument needs to be passed by reference, wrap it inside `ByRef()`. For example,
+```
+  InvokeArgument<2>(5, string("Hi"), ByRef(foo))
+```
+calls the mock function's #2 argument, passing to it `5` and `string("Hi")` by value, and `foo` by reference.
+
+## Default Action ##
+
+|`DoDefault()`|Do the default action (specified by `ON_CALL()` or the built-in one).|
+|:------------|:--------------------------------------------------------------------|
+
+**Note:** due to technical reasons, `DoDefault()` cannot be used inside  a composite action - trying to do so will result in a run-time error.
+
+## Composite Actions ##
+
+|`DoAll(a1, a2, ..., an)`|Do all actions `a1` to `an` and return the result of `an` in each invocation. The first `n - 1` sub-actions must return void. |
+|:-----------------------|:-----------------------------------------------------------------------------------------------------------------------------|
+|`IgnoreResult(a)`       |Perform action `a` and ignore its result. `a` must not return void.                                                           |
+|`WithArg<N>(a)`         |Pass the `N`-th (0-based) argument of the mock function to action `a` and perform it.                                         |
+|`WithArgs<N1, N2, ..., Nk>(a)`|Pass the selected (0-based) arguments of the mock function to action `a` and perform it.                                      |
+|`WithoutArgs(a)`        |Perform action `a` without any arguments.                                                                                     |
+
+## Defining Actions ##
+
+| `ACTION(Sum) { return arg0 + arg1; }` | Defines an action `Sum()` to return the sum of the mock function's argument #0 and #1. |
+|:--------------------------------------|:---------------------------------------------------------------------------------------|
+| `ACTION_P(Plus, n) { return arg0 + n; }` | Defines an action `Plus(n)` to return the sum of the mock function's argument #0 and `n`. |
+| `ACTION_Pk(Foo, p1, ..., pk) { statements; }` | Defines a parameterized action `Foo(p1, ..., pk)` to execute the given `statements`.   |
+
+The `ACTION*` macros cannot be used inside a function or class.
+
+# Cardinalities #
+
+These are used in `Times()` to specify how many times a mock function will be called:
+
+|`AnyNumber()`|The function can be called any number of times.|
+|:------------|:----------------------------------------------|
+|`AtLeast(n)` |The call is expected at least `n` times.       |
+|`AtMost(n)`  |The call is expected at most `n` times.        |
+|`Between(m, n)`|The call is expected between `m` and `n` (inclusive) times.|
+|`Exactly(n) or n`|The call is expected exactly `n` times. In particular, the call should never happen when `n` is 0.|
+
+# Expectation Order #
+
+By default, the expectations can be matched in _any_ order.  If some
+or all expectations must be matched in a given order, there are two
+ways to specify it.  They can be used either independently or
+together.
+
+## The After Clause ##
+
+```
+using ::testing::Expectation;
+...
+Expectation init_x = EXPECT_CALL(foo, InitX());
+Expectation init_y = EXPECT_CALL(foo, InitY());
+EXPECT_CALL(foo, Bar())
+    .After(init_x, init_y);
+```
+says that `Bar()` can be called only after both `InitX()` and
+`InitY()` have been called.
+
+If you don't know how many pre-requisites an expectation has when you
+write it, you can use an `ExpectationSet` to collect them:
+
+```
+using ::testing::ExpectationSet;
+...
+ExpectationSet all_inits;
+for (int i = 0; i < element_count; i++) {
+  all_inits += EXPECT_CALL(foo, InitElement(i));
+}
+EXPECT_CALL(foo, Bar())
+    .After(all_inits);
+```
+says that `Bar()` can be called only after all elements have been
+initialized (but we don't care about which elements get initialized
+before the others).
+
+Modifying an `ExpectationSet` after using it in an `.After()` doesn't
+affect the meaning of the `.After()`.
+
+## Sequences ##
+
+When you have a long chain of sequential expectations, it's easier to
+specify the order using **sequences**, which don't require you to given
+each expectation in the chain a different name.  <i>All expected<br>
+calls</i> in the same sequence must occur in the order they are
+specified.
+
+```
+using ::testing::Sequence;
+Sequence s1, s2;
+...
+EXPECT_CALL(foo, Reset())
+    .InSequence(s1, s2)
+    .WillOnce(Return(true));
+EXPECT_CALL(foo, GetSize())
+    .InSequence(s1)
+    .WillOnce(Return(1));
+EXPECT_CALL(foo, Describe(A<const char*>()))
+    .InSequence(s2)
+    .WillOnce(Return("dummy"));
+```
+says that `Reset()` must be called before _both_ `GetSize()` _and_
+`Describe()`, and the latter two can occur in any order.
+
+To put many expectations in a sequence conveniently:
+```
+using ::testing::InSequence;
+{
+  InSequence dummy;
+
+  EXPECT_CALL(...)...;
+  EXPECT_CALL(...)...;
+  ...
+  EXPECT_CALL(...)...;
+}
+```
+says that all expected calls in the scope of `dummy` must occur in
+strict order. The name `dummy` is irrelevant.)
+
+# Verifying and Resetting a Mock #
+
+Google Mock will verify the expectations on a mock object when it is destructed, or you can do it earlier:
+```
+using ::testing::Mock;
+...
+// Verifies and removes the expectations on mock_obj;
+// returns true iff successful.
+Mock::VerifyAndClearExpectations(&mock_obj);
+...
+// Verifies and removes the expectations on mock_obj;
+// also removes the default actions set by ON_CALL();
+// returns true iff successful.
+Mock::VerifyAndClear(&mock_obj);
+```
+
+You can also tell Google Mock that a mock object can be leaked and doesn't
+need to be verified:
+```
+Mock::AllowLeak(&mock_obj);
+```
+
+# Mock Classes #
+
+Google Mock defines a convenient mock class template
+```
+class MockFunction<R(A1, ..., An)> {
+ public:
+  MOCK_METHODn(Call, R(A1, ..., An));
+};
+```
+See this [recipe](V1_5_CookBook#Using_Check_Points.md) for one application of it.
+
+# Flags #
+
+| `--gmock_catch_leaked_mocks=0` | Don't report leaked mock objects as failures. |
+|:-------------------------------|:----------------------------------------------|
+| `--gmock_verbose=LEVEL`        | Sets the default verbosity level (`info`, `warning`, or `error`) of Google Mock messages. |
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CookBook.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CookBook.md
new file mode 100644
index 00000000..26e153c6
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CookBook.md
@@ -0,0 +1,3250 @@
+
+
+You can find recipes for using Google Mock here. If you haven't yet,
+please read the [ForDummies](V1_5_ForDummies.md) document first to make sure you understand
+the basics.
+
+**Note:** Google Mock lives in the `testing` name space. For
+readability, it is recommended to write `using ::testing::Foo;` once in
+your file before using the name `Foo` defined by Google Mock. We omit
+such `using` statements in this page for brevity, but you should do it
+in your own code.
+
+# Creating Mock Classes #
+
+## Mocking Private or Protected Methods ##
+
+You must always put a mock method definition (`MOCK_METHOD*`) in a
+`public:` section of the mock class, regardless of the method being
+mocked being `public`, `protected`, or `private` in the base class.
+This allows `ON_CALL` and `EXPECT_CALL` to reference the mock function
+from outside of the mock class.  (Yes, C++ allows a subclass to change
+the access level of a virtual function in the base class.)  Example:
+
+```
+class Foo {
+ public:
+  ...
+  virtual bool Transform(Gadget* g) = 0;
+
+ protected:
+  virtual void Resume();
+
+ private:
+  virtual int GetTimeOut();
+};
+
+class MockFoo : public Foo {
+ public:
+  ...
+  MOCK_METHOD1(Transform, bool(Gadget* g));
+
+  // The following must be in the public section, even though the
+  // methods are protected or private in the base class.
+  MOCK_METHOD0(Resume, void());
+  MOCK_METHOD0(GetTimeOut, int());
+};
+```
+
+## Mocking Overloaded Methods ##
+
+You can mock overloaded functions as usual. No special attention is required:
+
+```
+class Foo {
+  ...
+
+  // Must be virtual as we'll inherit from Foo.
+  virtual ~Foo();
+
+  // Overloaded on the types and/or numbers of arguments.
+  virtual int Add(Element x);
+  virtual int Add(int times, Element x);
+
+  // Overloaded on the const-ness of this object.
+  virtual Bar& GetBar();
+  virtual const Bar& GetBar() const;
+};
+
+class MockFoo : public Foo {
+  ...
+  MOCK_METHOD1(Add, int(Element x));
+  MOCK_METHOD2(Add, int(int times, Element x);
+
+  MOCK_METHOD0(GetBar, Bar&());
+  MOCK_CONST_METHOD0(GetBar, const Bar&());
+};
+```
+
+**Note:** if you don't mock all versions of the overloaded method, the
+compiler will give you a warning about some methods in the base class
+being hidden. To fix that, use `using` to bring them in scope:
+
+```
+class MockFoo : public Foo {
+  ...
+  using Foo::Add;
+  MOCK_METHOD1(Add, int(Element x));
+  // We don't want to mock int Add(int times, Element x);
+  ...
+};
+```
+
+## Mocking Class Templates ##
+
+To mock a class template, append `_T` to the `MOCK_*` macros:
+
+```
+template <typename Elem>
+class StackInterface {
+  ...
+  // Must be virtual as we'll inherit from StackInterface.
+  virtual ~StackInterface();
+
+  virtual int GetSize() const = 0;
+  virtual void Push(const Elem& x) = 0;
+};
+
+template <typename Elem>
+class MockStack : public StackInterface<Elem> {
+  ...
+  MOCK_CONST_METHOD0_T(GetSize, int());
+  MOCK_METHOD1_T(Push, void(const Elem& x));
+};
+```
+
+## Mocking Nonvirtual Methods ##
+
+Google Mock can mock non-virtual functions to be used in what we call _hi-perf
+dependency injection_.
+
+In this case, instead of sharing a common base class with the real
+class, your mock class will be _unrelated_ to the real class, but
+contain methods with the same signatures.  The syntax for mocking
+non-virtual methods is the _same_ as mocking virtual methods:
+
+```
+// A simple packet stream class.  None of its members is virtual.
+class ConcretePacketStream {
+ public:
+  void AppendPacket(Packet* new_packet);
+  const Packet* GetPacket(size_t packet_number) const;
+  size_t NumberOfPackets() const;
+  ...
+};
+
+// A mock packet stream class.  It inherits from no other, but defines
+// GetPacket() and NumberOfPackets().
+class MockPacketStream {
+ public:
+  MOCK_CONST_METHOD1(GetPacket, const Packet*(size_t packet_number));
+  MOCK_CONST_METHOD0(NumberOfPackets, size_t());
+  ...
+};
+```
+
+Note that the mock class doesn't define `AppendPacket()`, unlike the
+real class. That's fine as long as the test doesn't need to call it.
+
+Next, you need a way to say that you want to use
+`ConcretePacketStream` in production code, and use `MockPacketStream`
+in tests.  Since the functions are not virtual and the two classes are
+unrelated, you must specify your choice at _compile time_ (as opposed
+to run time).
+
+One way to do it is to templatize your code that needs to use a packet
+stream.  More specifically, you will give your code a template type
+argument for the type of the packet stream.  In production, you will
+instantiate your template with `ConcretePacketStream` as the type
+argument.  In tests, you will instantiate the same template with
+`MockPacketStream`.  For example, you may write:
+
+```
+template <class PacketStream>
+void CreateConnection(PacketStream* stream) { ... }
+
+template <class PacketStream>
+class PacketReader {
+ public:
+  void ReadPackets(PacketStream* stream, size_t packet_num);
+};
+```
+
+Then you can use `CreateConnection<ConcretePacketStream>()` and
+`PacketReader<ConcretePacketStream>` in production code, and use
+`CreateConnection<MockPacketStream>()` and
+`PacketReader<MockPacketStream>` in tests.
+
+```
+  MockPacketStream mock_stream;
+  EXPECT_CALL(mock_stream, ...)...;
+  .. set more expectations on mock_stream ...
+  PacketReader<MockPacketStream> reader(&mock_stream);
+  ... exercise reader ...
+```
+
+## Mocking Free Functions ##
+
+It's possible to use Google Mock to mock a free function (i.e. a
+C-style function or a static method).  You just need to rewrite your
+code to use an interface (abstract class).
+
+Instead of calling a free function (say, `OpenFile`) directly,
+introduce an interface for it and have a concrete subclass that calls
+the free function:
+
+```
+class FileInterface {
+ public:
+  ...
+  virtual bool Open(const char* path, const char* mode) = 0;
+};
+
+class File : public FileInterface {
+ public:
+  ...
+  virtual bool Open(const char* path, const char* mode) {
+    return OpenFile(path, mode);
+  }
+};
+```
+
+Your code should talk to `FileInterface` to open a file.  Now it's
+easy to mock out the function.
+
+This may seem much hassle, but in practice you often have multiple
+related functions that you can put in the same interface, so the
+per-function syntactic overhead will be much lower.
+
+If you are concerned about the performance overhead incurred by
+virtual functions, and profiling confirms your concern, you can
+combine this with the recipe for [mocking non-virtual methods](#Mocking_Nonvirtual_Methods.md).
+
+## Nice Mocks and Strict Mocks ##
+
+If a mock method has no `EXPECT_CALL` spec but is called, Google Mock
+will print a warning about the "uninteresting call". The rationale is:
+
+  * New methods may be added to an interface after a test is written. We shouldn't fail a test just because a method it doesn't know about is called.
+  * However, this may also mean there's a bug in the test, so Google Mock shouldn't be silent either. If the user believes these calls are harmless, he can add an `EXPECT_CALL()` to suppress the warning.
+
+However, sometimes you may want to suppress all "uninteresting call"
+warnings, while sometimes you may want the opposite, i.e. to treat all
+of them as errors. Google Mock lets you make the decision on a
+per-mock-object basis.
+
+Suppose your test uses a mock class `MockFoo`:
+
+```
+TEST(...) {
+  MockFoo mock_foo;
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+}
+```
+
+If a method of `mock_foo` other than `DoThis()` is called, it will be
+reported by Google Mock as a warning. However, if you rewrite your
+test to use `NiceMock<MockFoo>` instead, the warning will be gone,
+resulting in a cleaner test output:
+
+```
+using ::testing::NiceMock;
+
+TEST(...) {
+  NiceMock<MockFoo> mock_foo;
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+}
+```
+
+`NiceMock<MockFoo>` is a subclass of `MockFoo`, so it can be used
+wherever `MockFoo` is accepted.
+
+It also works if `MockFoo`'s constructor takes some arguments, as
+`NiceMock<MockFoo>` "inherits" `MockFoo`'s constructors:
+
+```
+using ::testing::NiceMock;
+
+TEST(...) {
+  NiceMock<MockFoo> mock_foo(5, "hi");  // Calls MockFoo(5, "hi").
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+}
+```
+
+The usage of `StrictMock` is similar, except that it makes all
+uninteresting calls failures:
+
+```
+using ::testing::StrictMock;
+
+TEST(...) {
+  StrictMock<MockFoo> mock_foo;
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+
+  // The test will fail if a method of mock_foo other than DoThis()
+  // is called.
+}
+```
+
+There are some caveats though (I don't like them just as much as the
+next guy, but sadly they are side effects of C++'s limitations):
+
+  1. `NiceMock<MockFoo>` and `StrictMock<MockFoo>` only work 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` and `StrictMock` (e.g. `NiceMock<StrictMock<MockFoo> >`) is **not** supported.
+  1. The constructors of the base mock (`MockFoo`) cannot have arguments passed by non-const reference, which happens to be banned by the [Google C++ style guide](http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml).
+  1. During the constructor or destructor of `MockFoo`, the mock object is _not_ nice or strict.  This may cause surprises if the constructor or destructor calls a mock method on `this` object. (This behavior, however, is consistent with C++'s general rule: if a constructor or destructor calls a virtual method of `this` object, that method is treated as non-virtual.  In other words, to the base class's constructor or destructor, `this` object behaves like an instance of the base class, not the derived class.  This rule is required for safety.  Otherwise a base constructor may use members of a derived class before they are initialized, or a base destructor may use members of a derived class after they have been destroyed.)
+
+Finally, you should be **very cautious** when using this feature, as the
+decision you make applies to **all** future changes to the mock
+class. If an important change is made in the interface you are mocking
+(and thus in the mock class), it could break your tests (if you use
+`StrictMock`) or let bugs pass through without a warning (if you use
+`NiceMock`). Therefore, try to specify the mock's behavior using
+explicit `EXPECT_CALL` first, and only turn to `NiceMock` or
+`StrictMock` as the last resort.
+
+## Simplifying the Interface without Breaking Existing Code ##
+
+Sometimes a method has a long list of arguments that is mostly
+uninteresting. For example,
+
+```
+class LogSink {
+ public:
+  ...
+  virtual void send(LogSeverity severity, const char* full_filename,
+                    const char* base_filename, int line,
+                    const struct tm* tm_time,
+                    const char* message, size_t message_len) = 0;
+};
+```
+
+This method's argument list is lengthy and hard to work with (let's
+say that the `message` argument is not even 0-terminated). If we mock
+it as is, using the mock will be awkward. If, however, we try to
+simplify this interface, we'll need to fix all clients depending on
+it, which is often infeasible.
+
+The trick is to re-dispatch the method in the mock class:
+
+```
+class ScopedMockLog : public LogSink {
+ public:
+  ...
+  virtual void send(LogSeverity severity, const char* full_filename,
+                    const char* base_filename, int line, const tm* tm_time,
+                    const char* message, size_t message_len) {
+    // We are only interested in the log severity, full file name, and
+    // log message.
+    Log(severity, full_filename, std::string(message, message_len));
+  }
+
+  // Implements the mock method:
+  //
+  //   void Log(LogSeverity severity,
+  //            const string& file_path,
+  //            const string& message);
+  MOCK_METHOD3(Log, void(LogSeverity severity, const string& file_path,
+                         const string& message));
+};
+```
+
+By defining a new mock method with a trimmed argument list, we make
+the mock class much more user-friendly.
+
+## Alternative to Mocking Concrete Classes ##
+
+Often you may find yourself using classes that don't implement
+interfaces. In order to test your code that uses such a class (let's
+call it `Concrete`), you may be tempted to make the methods of
+`Concrete` virtual and then mock it.
+
+Try not to do that.
+
+Making a non-virtual function virtual is a big decision. It creates an
+extension point where subclasses can tweak your class' behavior. This
+weakens your control on the class because now it's harder to maintain
+the class' invariants. You should make a function virtual only when
+there is a valid reason for a subclass to override it.
+
+Mocking concrete classes directly is problematic as it creates a tight
+coupling between the class and the tests - any small change in the
+class may invalidate your tests and make test maintenance a pain.
+
+To avoid such problems, many programmers have been practicing "coding
+to interfaces": instead of talking to the `Concrete` class, your code
+would define an interface and talk to it. Then you implement that
+interface as an adaptor on top of `Concrete`. In tests, you can easily
+mock that interface to observe how your code is doing.
+
+This technique incurs some overhead:
+
+  * You pay the cost of virtual function calls (usually not a problem).
+  * There is more abstraction for the programmers to learn.
+
+However, it can also bring significant benefits in addition to better
+testability:
+
+  * `Concrete`'s API may not fit your problem domain very well, as you may not be the only client it tries to serve. By designing your own interface, you have a chance to tailor it to your need - you may add higher-level functionalities, rename stuff, etc instead of just trimming the class. This allows you to write your code (user of the interface) in a more natural way, which means it will be more readable, more maintainable, and you'll be more productive.
+  * If `Concrete`'s implementation ever has to change, you don't have to rewrite everywhere it is used. Instead, you can absorb the change in your implementation of the interface, and your other code and tests will be insulated from this change.
+
+Some people worry that if everyone is practicing this technique, they
+will end up writing lots of redundant code. This concern is totally
+understandable. However, there are two reasons why it may not be the
+case:
+
+  * Different projects may need to use `Concrete` in different ways, so the best interfaces for them will be different. Therefore, each of them will have its own domain-specific interface on top of `Concrete`, and they will not be the same code.
+  * If enough projects want to use the same interface, they can always share it, just like they have been sharing `Concrete`. You can check in the interface and the adaptor somewhere near `Concrete` (perhaps in a `contrib` sub-directory) and let many projects use it.
+
+You need to weigh the pros and cons carefully for your particular
+problem, but I'd like to assure you that the Java community has been
+practicing this for a long time and it's a proven effective technique
+applicable in a wide variety of situations. :-)
+
+## Delegating Calls to a Fake ##
+
+Some times you have a non-trivial fake implementation of an
+interface. For example:
+
+```
+class Foo {
+ public:
+  virtual ~Foo() {}
+  virtual char DoThis(int n) = 0;
+  virtual void DoThat(const char* s, int* p) = 0;
+};
+
+class FakeFoo : public Foo {
+ public:
+  virtual char DoThis(int n) {
+    return (n > 0) ? '+' :
+        (n < 0) ? '-' : '0';
+  }
+
+  virtual void DoThat(const char* s, int* p) {
+    *p = strlen(s);
+  }
+};
+```
+
+Now you want to mock this interface such that you can set expectations
+on it. However, you also want to use `FakeFoo` for the default
+behavior, as duplicating it in the mock object is, well, a lot of
+work.
+
+When you define the mock class using Google Mock, you can have it
+delegate its default action to a fake class you already have, using
+this pattern:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+class MockFoo : public Foo {
+ public:
+  // Normal mock method definitions using Google Mock.
+  MOCK_METHOD1(DoThis, char(int n));
+  MOCK_METHOD2(DoThat, void(const char* s, int* p));
+
+  // Delegates the default actions of the methods to a FakeFoo object.
+  // This must be called *before* the custom ON_CALL() statements.
+  void DelegateToFake() {
+    ON_CALL(*this, DoThis(_))
+        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThis));
+    ON_CALL(*this, DoThat(_, _))
+        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThat));
+  }
+ private:
+  FakeFoo fake_;  // Keeps an instance of the fake in the mock.
+};
+```
+
+With that, you can use `MockFoo` in your tests as usual. Just remember
+that if you don't explicitly set an action in an `ON_CALL()` or
+`EXPECT_CALL()`, the fake will be called upon to do it:
+
+```
+using ::testing::_;
+
+TEST(AbcTest, Xyz) {
+  MockFoo foo;
+  foo.DelegateToFake(); // Enables the fake for delegation.
+
+  // Put your ON_CALL(foo, ...)s here, if any.
+
+  // No action specified, meaning to use the default action.
+  EXPECT_CALL(foo, DoThis(5));
+  EXPECT_CALL(foo, DoThat(_, _));
+
+  int n = 0;
+  EXPECT_EQ('+', foo.DoThis(5));  // FakeFoo::DoThis() is invoked.
+  foo.DoThat("Hi", &n);           // FakeFoo::DoThat() is invoked.
+  EXPECT_EQ(2, n);
+}
+```
+
+**Some tips:**
+
+  * If you want, you can still override the default action by providing your own `ON_CALL()` or using `.WillOnce()` / `.WillRepeatedly()` in `EXPECT_CALL()`.
+  * In `DelegateToFake()`, you only need to delegate the methods whose fake implementation you intend to use.
+  * The general technique discussed here works for overloaded methods, but you'll need to tell the compiler which version you mean. To disambiguate a mock function (the one you specify inside the parentheses of `ON_CALL()`), see the "Selecting Between Overloaded Functions" section on this page; to disambiguate a fake function (the one you place inside `Invoke()`), use a `static_cast` to specify the function's type.
+  * Having to mix a mock and a fake is often a sign of something gone wrong. Perhaps you haven't got used to the interaction-based way of testing yet. Or perhaps your interface is taking on too many roles and should be split up. Therefore, **don't abuse this**. We would only recommend to do it as an intermediate step when you are refactoring your code.
+
+Regarding the tip on mixing a mock and a fake, here's an example on
+why it may be a bad sign: Suppose you have a class `System` for
+low-level system operations. In particular, it does file and I/O
+operations. And suppose you want to test how your code uses `System`
+to do I/O, and you just want the file operations to work normally. If
+you mock out the entire `System` class, you'll have to provide a fake
+implementation for the file operation part, which suggests that
+`System` is taking on too many roles.
+
+Instead, you can define a `FileOps` interface and an `IOOps` interface
+and split `System`'s functionalities into the two. Then you can mock
+`IOOps` without mocking `FileOps`.
+
+## Delegating Calls to a Real Object ##
+
+When using testing doubles (mocks, fakes, stubs, and etc), sometimes
+their behaviors will differ from those of the real objects. This
+difference could be either intentional (as in simulating an error such
+that you can test the error handling code) or unintentional. If your
+mocks have different behaviors than the real objects by mistake, you
+could end up with code that passes the tests but fails in production.
+
+You can use the _delegating-to-real_ technique to ensure that your
+mock has the same behavior as the real object while retaining the
+ability to validate calls. This technique is very similar to the
+delegating-to-fake technique, the difference being that we use a real
+object instead of a fake. Here's an example:
+
+```
+using ::testing::_;
+using ::testing::AtLeast;
+using ::testing::Invoke;
+
+class MockFoo : public Foo {
+ public:
+  MockFoo() {
+    // By default, all calls are delegated to the real object.
+    ON_CALL(*this, DoThis())
+        .WillByDefault(Invoke(&real_, &Foo::DoThis));
+    ON_CALL(*this, DoThat(_))
+        .WillByDefault(Invoke(&real_, &Foo::DoThat));
+    ...
+  }
+  MOCK_METHOD0(DoThis, ...);
+  MOCK_METHOD1(DoThat, ...);
+  ...
+ private:
+  Foo real_;
+};
+...
+
+  MockFoo mock;
+
+  EXPECT_CALL(mock, DoThis())
+      .Times(3);
+  EXPECT_CALL(mock, DoThat("Hi"))
+      .Times(AtLeast(1));
+  ... use mock in test ...
+```
+
+With this, Google Mock will verify that your code made the right calls
+(with the right arguments, in the right order, called the right number
+of times, etc), and a real object will answer the calls (so the
+behavior will be the same as in production). This gives you the best
+of both worlds.
+
+## Delegating Calls to a Parent Class ##
+
+Ideally, you should code to interfaces, whose methods are all pure
+virtual. In reality, sometimes you do need to mock a virtual method
+that is not pure (i.e, it already has an implementation). For example:
+
+```
+class Foo {
+ public:
+  virtual ~Foo();
+
+  virtual void Pure(int n) = 0;
+  virtual int Concrete(const char* str) { ... }
+};
+
+class MockFoo : public Foo {
+ public:
+  // Mocking a pure method.
+  MOCK_METHOD1(Pure, void(int n));
+  // Mocking a concrete method.  Foo::Concrete() is shadowed.
+  MOCK_METHOD1(Concrete, int(const char* str));
+};
+```
+
+Sometimes you may want to call `Foo::Concrete()` instead of
+`MockFoo::Concrete()`. Perhaps you want to do it as part of a stub
+action, or perhaps your test doesn't need to mock `Concrete()` at all
+(but it would be oh-so painful to have to define a new mock class
+whenever you don't need to mock one of its methods).
+
+The trick is to leave a back door in your mock class for accessing the
+real methods in the base class:
+
+```
+class MockFoo : public Foo {
+ public:
+  // Mocking a pure method.
+  MOCK_METHOD1(Pure, void(int n));
+  // Mocking a concrete method.  Foo::Concrete() is shadowed.
+  MOCK_METHOD1(Concrete, int(const char* str));
+
+  // Use this to call Concrete() defined in Foo.
+  int FooConcrete(const char* str) { return Foo::Concrete(str); }
+};
+```
+
+Now, you can call `Foo::Concrete()` inside an action by:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+...
+  EXPECT_CALL(foo, Concrete(_))
+      .WillOnce(Invoke(&foo, &MockFoo::FooConcrete));
+```
+
+or tell the mock object that you don't want to mock `Concrete()`:
+
+```
+using ::testing::Invoke;
+...
+  ON_CALL(foo, Concrete(_))
+      .WillByDefault(Invoke(&foo, &MockFoo::FooConcrete));
+```
+
+(Why don't we just write `Invoke(&foo, &Foo::Concrete)`? If you do
+that, `MockFoo::Concrete()` will be called (and cause an infinite
+recursion) since `Foo::Concrete()` is virtual. That's just how C++
+works.)
+
+# Using Matchers #
+
+## Matching Argument Values Exactly ##
+
+You can specify exactly which arguments a mock method is expecting:
+
+```
+using ::testing::Return;
+...
+  EXPECT_CALL(foo, DoThis(5))
+      .WillOnce(Return('a'));
+  EXPECT_CALL(foo, DoThat("Hello", bar));
+```
+
+## Using Simple Matchers ##
+
+You can use matchers to match arguments that have a certain property:
+
+```
+using ::testing::Ge;
+using ::testing::NotNull;
+using ::testing::Return;
+...
+  EXPECT_CALL(foo, DoThis(Ge(5)))  // The argument must be >= 5.
+      .WillOnce(Return('a'));
+  EXPECT_CALL(foo, DoThat("Hello", NotNull()));
+  // The second argument must not be NULL.
+```
+
+A frequently used matcher is `_`, which matches anything:
+
+```
+using ::testing::_;
+using ::testing::NotNull;
+...
+  EXPECT_CALL(foo, DoThat(_, NotNull()));
+```
+
+## Combining Matchers ##
+
+You can build complex matchers from existing ones using `AllOf()`,
+`AnyOf()`, and `Not()`:
+
+```
+using ::testing::AllOf;
+using ::testing::Gt;
+using ::testing::HasSubstr;
+using ::testing::Ne;
+using ::testing::Not;
+...
+  // The argument must be > 5 and != 10.
+  EXPECT_CALL(foo, DoThis(AllOf(Gt(5),
+                                Ne(10))));
+
+  // The first argument must not contain sub-string "blah".
+  EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")),
+                          NULL));
+```
+
+## Casting Matchers ##
+
+Google Mock matchers are statically typed, meaning that the compiler
+can catch your mistake if you use a matcher of the wrong type (for
+example, if you use `Eq(5)` to match a `string` argument). Good for
+you!
+
+Sometimes, however, you know what you're doing and want the compiler
+to give you some slack. One example is that you have a matcher for
+`long` and the argument you want to match is `int`. While the two
+types aren't exactly the same, there is nothing really wrong with
+using a `Matcher<long>` to match an `int` - after all, we can first
+convert the `int` argument to a `long` before giving it to the
+matcher.
+
+To support this need, Google Mock gives you the
+`SafeMatcherCast<T>(m)` function. It casts a matcher `m` to type
+`Matcher<T>`. To ensure safety, Google Mock checks that (let `U` be the
+type `m` accepts):
+
+  1. Type `T` can be implicitly cast to type `U`;
+  1. When both `T` and `U` are built-in arithmetic types (`bool`, integers, and floating-point numbers), the conversion from `T` to `U` is not lossy (in other words, any value representable by `T` can also be represented by `U`); and
+  1. When `U` is a reference, `T` must also be a reference (as the underlying matcher may be interested in the address of the `U` value).
+
+The code won't compile if any of these conditions isn't met.
+
+Here's one example:
+
+```
+using ::testing::SafeMatcherCast;
+
+// A base class and a child class.
+class Base { ... };
+class Derived : public Base { ... };
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(DoThis, void(Derived* derived));
+};
+...
+
+  MockFoo foo;
+  // m is a Matcher<Base*> we got from somewhere.
+  EXPECT_CALL(foo, DoThis(SafeMatcherCast<Derived*>(m)));
+```
+
+If you find `SafeMatcherCast<T>(m)` too limiting, you can use a similar
+function `MatcherCast<T>(m)`. The difference is that `MatcherCast` works
+as long as you can `static_cast` type `T` to type `U`.
+
+`MatcherCast` essentially lets you bypass C++'s type system
+(`static_cast` isn't always safe as it could throw away information,
+for example), so be careful not to misuse/abuse it.
+
+## Selecting Between Overloaded Functions ##
+
+If you expect an overloaded function to be called, the compiler may
+need some help on which overloaded version it is.
+
+To disambiguate functions overloaded on the const-ness of this object,
+use the `Const()` argument wrapper.
+
+```
+using ::testing::ReturnRef;
+
+class MockFoo : public Foo {
+  ...
+  MOCK_METHOD0(GetBar, Bar&());
+  MOCK_CONST_METHOD0(GetBar, const Bar&());
+};
+...
+
+  MockFoo foo;
+  Bar bar1, bar2;
+  EXPECT_CALL(foo, GetBar())         // The non-const GetBar().
+      .WillOnce(ReturnRef(bar1));
+  EXPECT_CALL(Const(foo), GetBar())  // The const GetBar().
+      .WillOnce(ReturnRef(bar2));
+```
+
+(`Const()` is defined by Google Mock and returns a `const` reference
+to its argument.)
+
+To disambiguate overloaded functions with the same number of arguments
+but different argument types, you may need to specify the exact type
+of a matcher, either by wrapping your matcher in `Matcher<type>()`, or
+using a matcher whose type is fixed (`TypedEq<type>`, `An<type>()`,
+etc):
+
+```
+using ::testing::An;
+using ::testing::Lt;
+using ::testing::Matcher;
+using ::testing::TypedEq;
+
+class MockPrinter : public Printer {
+ public:
+  MOCK_METHOD1(Print, void(int n));
+  MOCK_METHOD1(Print, void(char c));
+};
+
+TEST(PrinterTest, Print) {
+  MockPrinter printer;
+
+  EXPECT_CALL(printer, Print(An<int>()));            // void Print(int);
+  EXPECT_CALL(printer, Print(Matcher<int>(Lt(5))));  // void Print(int);
+  EXPECT_CALL(printer, Print(TypedEq<char>('a')));   // void Print(char);
+
+  printer.Print(3);
+  printer.Print(6);
+  printer.Print('a');
+}
+```
+
+## Performing Different Actions Based on the Arguments ##
+
+When a mock method is called, the _last_ matching expectation that's
+still active will be selected (think "newer overrides older"). So, you
+can make a method do different things depending on its argument values
+like this:
+
+```
+using ::testing::_;
+using ::testing::Lt;
+using ::testing::Return;
+...
+  // The default case.
+  EXPECT_CALL(foo, DoThis(_))
+      .WillRepeatedly(Return('b'));
+
+  // The more specific case.
+  EXPECT_CALL(foo, DoThis(Lt(5)))
+      .WillRepeatedly(Return('a'));
+```
+
+Now, if `foo.DoThis()` is called with a value less than 5, `'a'` will
+be returned; otherwise `'b'` will be returned.
+
+## Matching Multiple Arguments as a Whole ##
+
+Sometimes it's not enough to match the arguments individually. For
+example, we may want to say that the first argument must be less than
+the second argument. The `With()` clause allows us to match
+all arguments of a mock function as a whole. For example,
+
+```
+using ::testing::_;
+using ::testing::Lt;
+using ::testing::Ne;
+...
+  EXPECT_CALL(foo, InRange(Ne(0), _))
+      .With(Lt());
+```
+
+says that the first argument of `InRange()` must not be 0, and must be
+less than the second argument.
+
+The expression inside `With()` must be a matcher of type
+`Matcher<tr1::tuple<A1, ..., An> >`, where `A1`, ..., `An` are the
+types of the function arguments.
+
+You can also write `AllArgs(m)` instead of `m` inside `.With()`. The
+two forms are equivalent, but `.With(AllArgs(Lt()))` is more readable
+than `.With(Lt())`.
+
+You can use `Args<k1, ..., kn>(m)` to match the `n` selected arguments
+against `m`. For example,
+
+```
+using ::testing::_;
+using ::testing::AllOf;
+using ::testing::Args;
+using ::testing::Lt;
+...
+  EXPECT_CALL(foo, Blah(_, _, _))
+      .With(AllOf(Args<0, 1>(Lt()), Args<1, 2>(Lt())));
+```
+
+says that `Blah()` will be called with arguments `x`, `y`, and `z` where
+`x < y < z`.
+
+As a convenience and example, Google Mock provides some matchers for
+2-tuples, including the `Lt()` matcher above. See the [CheatSheet](V1_5_CheatSheet.md) for
+the complete list.
+
+## Using Matchers as Predicates ##
+
+Have you noticed that a matcher is just a fancy predicate that also
+knows how to describe itself? Many existing algorithms take predicates
+as arguments (e.g. those defined in STL's `<algorithm>` header), and
+it would be a shame if Google Mock matchers are not allowed to
+participate.
+
+Luckily, you can use a matcher where a unary predicate functor is
+expected by wrapping it inside the `Matches()` function. For example,
+
+```
+#include <algorithm>
+#include <vector>
+
+std::vector<int> v;
+...
+// How many elements in v are >= 10?
+const int count = count_if(v.begin(), v.end(), Matches(Ge(10)));
+```
+
+Since you can build complex matchers from simpler ones easily using
+Google Mock, this gives you a way to conveniently construct composite
+predicates (doing the same using STL's `<functional>` header is just
+painful). For example, here's a predicate that's satisfied by any
+number that is >= 0, <= 100, and != 50:
+
+```
+Matches(AllOf(Ge(0), Le(100), Ne(50)))
+```
+
+## Using Matchers in Google Test Assertions ##
+
+Since matchers are basically predicates that also know how to describe
+themselves, there is a way to take advantage of them in
+[Google Test](http://code.google.com/p/googletest/) assertions. It's
+called `ASSERT_THAT` and `EXPECT_THAT`:
+
+```
+  ASSERT_THAT(value, matcher);  // Asserts that value matches matcher.
+  EXPECT_THAT(value, matcher);  // The non-fatal version.
+```
+
+For example, in a Google Test test you can write:
+
+```
+#include <gmock/gmock.h>
+
+using ::testing::AllOf;
+using ::testing::Ge;
+using ::testing::Le;
+using ::testing::MatchesRegex;
+using ::testing::StartsWith;
+...
+
+  EXPECT_THAT(Foo(), StartsWith("Hello"));
+  EXPECT_THAT(Bar(), MatchesRegex("Line \\d+"));
+  ASSERT_THAT(Baz(), AllOf(Ge(5), Le(10)));
+```
+
+which (as you can probably guess) executes `Foo()`, `Bar()`, and
+`Baz()`, and verifies that:
+
+  * `Foo()` returns a string that starts with `"Hello"`.
+  * `Bar()` returns a string that matches regular expression `"Line \\d+"`.
+  * `Baz()` returns a number in the range [5, 10].
+
+The nice thing about these macros is that _they read like
+English_. They generate informative messages too. For example, if the
+first `EXPECT_THAT()` above fails, the message will be something like:
+
+```
+Value of: Foo()
+  Actual: "Hi, world!"
+Expected: starts with "Hello"
+```
+
+**Credit:** The idea of `(ASSERT|EXPECT)_THAT` was stolen from the
+[Hamcrest](http://code.google.com/p/hamcrest/) project, which adds
+`assertThat()` to JUnit.
+
+## Using Predicates as Matchers ##
+
+Google Mock provides a built-in set of matchers. In case you find them
+lacking, you can use an arbitray unary predicate function or functor
+as a matcher - as long as the predicate accepts a value of the type
+you want. You do this by wrapping the predicate inside the `Truly()`
+function, for example:
+
+```
+using ::testing::Truly;
+
+int IsEven(int n) { return (n % 2) == 0 ? 1 : 0; }
+...
+
+  // Bar() must be called with an even number.
+  EXPECT_CALL(foo, Bar(Truly(IsEven)));
+```
+
+Note that the predicate function / functor doesn't have to return
+`bool`. It works as long as the return value can be used as the
+condition in statement `if (condition) ...`.
+
+## Matching Arguments that Are Not Copyable ##
+
+When you do an `EXPECT_CALL(mock_obj, Foo(bar))`, Google Mock saves
+away a copy of `bar`. When `Foo()` is called later, Google Mock
+compares the argument to `Foo()` with the saved copy of `bar`. This
+way, you don't need to worry about `bar` being modified or destroyed
+after the `EXPECT_CALL()` is executed. The same is true when you use
+matchers like `Eq(bar)`, `Le(bar)`, and so on.
+
+But what if `bar` cannot be copied (i.e. has no copy constructor)? You
+could define your own matcher function and use it with `Truly()`, as
+the previous couple of recipes have shown. Or, you may be able to get
+away from it if you can guarantee that `bar` won't be changed after
+the `EXPECT_CALL()` is executed. Just tell Google Mock that it should
+save a reference to `bar`, instead of a copy of it. Here's how:
+
+```
+using ::testing::Eq;
+using ::testing::ByRef;
+using ::testing::Lt;
+...
+  // Expects that Foo()'s argument == bar.
+  EXPECT_CALL(mock_obj, Foo(Eq(ByRef(bar))));
+
+  // Expects that Foo()'s argument < bar.
+  EXPECT_CALL(mock_obj, Foo(Lt(ByRef(bar))));
+```
+
+Remember: if you do this, don't change `bar` after the
+`EXPECT_CALL()`, or the result is undefined.
+
+## Validating a Member of an Object ##
+
+Often a mock function takes a reference to object as an argument. When
+matching the argument, you may not want to compare the entire object
+against a fixed object, as that may be over-specification. Instead,
+you may need to validate a certain member variable or the result of a
+certain getter method of the object. You can do this with `Field()`
+and `Property()`. More specifically,
+
+```
+Field(&Foo::bar, m)
+```
+
+is a matcher that matches a `Foo` object whose `bar` member variable
+satisfies matcher `m`.
+
+```
+Property(&Foo::baz, m)
+```
+
+is a matcher that matches a `Foo` object whose `baz()` method returns
+a value that satisfies matcher `m`.
+
+For example:
+
+> | `Field(&Foo::number, Ge(3))` | Matches `x` where `x.number >= 3`. |
+|:-----------------------------|:-----------------------------------|
+> | `Property(&Foo::name, StartsWith("John "))` | Matches `x` where `x.name()` starts with `"John "`. |
+
+Note that in `Property(&Foo::baz, ...)`, method `baz()` must take no
+argument and be declared as `const`.
+
+BTW, `Field()` and `Property()` can also match plain pointers to
+objects. For instance,
+
+```
+Field(&Foo::number, Ge(3))
+```
+
+matches a plain pointer `p` where `p->number >= 3`. If `p` is `NULL`,
+the match will always fail regardless of the inner matcher.
+
+What if you want to validate more than one members at the same time?
+Remember that there is `AllOf()`.
+
+## Validating the Value Pointed to by a Pointer Argument ##
+
+C++ functions often take pointers as arguments. You can use matchers
+like `NULL`, `NotNull()`, and other comparison matchers to match a
+pointer, but what if you want to make sure the value _pointed to_ by
+the pointer, instead of the pointer itself, has a certain property?
+Well, you can use the `Pointee(m)` matcher.
+
+`Pointee(m)` matches a pointer iff `m` matches the value the pointer
+points to. For example:
+
+```
+using ::testing::Ge;
+using ::testing::Pointee;
+...
+  EXPECT_CALL(foo, Bar(Pointee(Ge(3))));
+```
+
+expects `foo.Bar()` to be called with a pointer that points to a value
+greater than or equal to 3.
+
+One nice thing about `Pointee()` is that it treats a `NULL` pointer as
+a match failure, so you can write `Pointee(m)` instead of
+
+```
+  AllOf(NotNull(), Pointee(m))
+```
+
+without worrying that a `NULL` pointer will crash your test.
+
+Also, did we tell you that `Pointee()` works with both raw pointers
+**and** smart pointers (`linked_ptr`, `shared_ptr`, `scoped_ptr`, and
+etc)?
+
+What if you have a pointer to pointer? You guessed it - you can use
+nested `Pointee()` to probe deeper inside the value. For example,
+`Pointee(Pointee(Lt(3)))` matches a pointer that points to a pointer
+that points to a number less than 3 (what a mouthful...).
+
+## Testing a Certain Property of an Object ##
+
+Sometimes you want to specify that an object argument has a certain
+property, but there is no existing matcher that does this. If you want
+good error messages, you should define a matcher. If you want to do it
+quick and dirty, you could get away with writing an ordinary function.
+
+Let's say you have a mock function that takes an object of type `Foo`,
+which has an `int bar()` method and an `int baz()` method, and you
+want to constrain that the argument's `bar()` value plus its `baz()`
+value is a given number. Here's how you can define a matcher to do it:
+
+```
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+
+class BarPlusBazEqMatcher : public MatcherInterface<const Foo&> {
+ public:
+  explicit BarPlusBazEqMatcher(int expected_sum)
+      : expected_sum_(expected_sum) {}
+
+  virtual bool MatchAndExplain(const Foo& foo,
+                               MatchResultListener* listener) const {
+    return (foo.bar() + foo.baz()) == expected_sum_;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "bar() + baz() equals " << expected_sum_;
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "bar() + baz() does not equal " << expected_sum_;
+  }
+ private:
+  const int expected_sum_;
+};
+
+inline Matcher<const Foo&> BarPlusBazEq(int expected_sum) {
+  return MakeMatcher(new BarPlusBazEqMatcher(expected_sum));
+}
+
+...
+
+  EXPECT_CALL(..., DoThis(BarPlusBazEq(5)))...;
+```
+
+## Matching Containers ##
+
+Sometimes an STL container (e.g. list, vector, map, ...) is passed to
+a mock function and you may want to validate it. Since most STL
+containers support the `==` operator, you can write
+`Eq(expected_container)` or simply `expected_container` to match a
+container exactly.
+
+Sometimes, though, you may want to be more flexible (for example, the
+first element must be an exact match, but the second element can be
+any positive number, and so on). Also, containers used in tests often
+have a small number of elements, and having to define the expected
+container out-of-line is a bit of a hassle.
+
+You can use the `ElementsAre()` matcher in such cases:
+
+```
+using ::testing::_;
+using ::testing::ElementsAre;
+using ::testing::Gt;
+...
+
+  MOCK_METHOD1(Foo, void(const vector<int>& numbers));
+...
+
+  EXPECT_CALL(mock, Foo(ElementsAre(1, Gt(0), _, 5)));
+```
+
+The above matcher says that the container must have 4 elements, which
+must be 1, greater than 0, anything, and 5 respectively.
+
+`ElementsAre()` is overloaded to take 0 to 10 arguments. If more are
+needed, you can place them in a C-style array and use
+`ElementsAreArray()` instead:
+
+```
+using ::testing::ElementsAreArray;
+...
+
+  // ElementsAreArray accepts an array of element values.
+  const int expected_vector1[] = { 1, 5, 2, 4, ... };
+  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector1)));
+
+  // Or, an array of element matchers.
+  Matcher<int> expected_vector2 = { 1, Gt(2), _, 3, ... };
+  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector2)));
+```
+
+In case the array needs to be dynamically created (and therefore the
+array size cannot be inferred by the compiler), you can give
+`ElementsAreArray()` an additional argument to specify the array size:
+
+```
+using ::testing::ElementsAreArray;
+...
+  int* const expected_vector3 = new int[count];
+  ... fill expected_vector3 with values ...
+  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector3, count)));
+```
+
+**Tips:**
+
+  * `ElementAre*()` works with _any_ container that implements the STL iterator concept (i.e. it has a `const_iterator` type and supports `begin()/end()`) and supports `size()`, not just the ones defined in STL. It will even work with container types yet to be written - as long as they follows the above pattern.
+  * You can use nested `ElementAre*()` to match nested (multi-dimensional) containers.
+  * If the container is passed by pointer instead of by reference, just write `Pointee(ElementsAre*(...))`.
+  * The order of elements _matters_ for `ElementsAre*()`. Therefore don't use it with containers whose element order is undefined (e.g. `hash_map`).
+
+## Sharing Matchers ##
+
+Under the hood, a Google Mock matcher object consists of a pointer to
+a ref-counted implementation object. Copying matchers is allowed and
+very efficient, as only the pointer is copied. When the last matcher
+that references the implementation object dies, the implementation
+object will be deleted.
+
+Therefore, if you have some complex matcher that you want to use again
+and again, there is no need to build it everytime. Just assign it to a
+matcher variable and use that variable repeatedly! For example,
+
+```
+  Matcher<int> in_range = AllOf(Gt(5), Le(10));
+  ... use in_range as a matcher in multiple EXPECT_CALLs ...
+```
+
+# Setting Expectations #
+
+## Ignoring Uninteresting Calls ##
+
+If you are not interested in how a mock method is called, just don't
+say anything about it. In this case, if the method is ever called,
+Google Mock will perform its default action to allow the test program
+to continue. If you are not happy with the default action taken by
+Google Mock, you can override it using `DefaultValue<T>::Set()`
+(described later in this document) or `ON_CALL()`.
+
+Please note that once you expressed interest in a particular mock
+method (via `EXPECT_CALL()`), all invocations to it must match some
+expectation. If this function is called but the arguments don't match
+any `EXPECT_CALL()` statement, it will be an error.
+
+## Disallowing Unexpected Calls ##
+
+If a mock method shouldn't be called at all, explicitly say so:
+
+```
+using ::testing::_;
+...
+  EXPECT_CALL(foo, Bar(_))
+      .Times(0);
+```
+
+If some calls to the method are allowed, but the rest are not, just
+list all the expected calls:
+
+```
+using ::testing::AnyNumber;
+using ::testing::Gt;
+...
+  EXPECT_CALL(foo, Bar(5));
+  EXPECT_CALL(foo, Bar(Gt(10)))
+      .Times(AnyNumber());
+```
+
+A call to `foo.Bar()` that doesn't match any of the `EXPECT_CALL()`
+statements will be an error.
+
+## Expecting Ordered Calls ##
+
+Although an `EXPECT_CALL()` statement defined earlier takes precedence
+when Google Mock tries to match a function call with an expectation,
+by default calls don't have to happen in the order `EXPECT_CALL()`
+statements are written. For example, if the arguments match the
+matchers in the third `EXPECT_CALL()`, but not those in the first two,
+then the third expectation will be used.
+
+If you would rather have all calls occur in the order of the
+expectations, put the `EXPECT_CALL()` statements in a block where you
+define a variable of type `InSequence`:
+
+```
+  using ::testing::_;
+  using ::testing::InSequence;
+
+  {
+    InSequence s;
+
+    EXPECT_CALL(foo, DoThis(5));
+    EXPECT_CALL(bar, DoThat(_))
+        .Times(2);
+    EXPECT_CALL(foo, DoThis(6));
+  }
+```
+
+In this example, we expect a call to `foo.DoThis(5)`, followed by two
+calls to `bar.DoThat()` where the argument can be anything, which are
+in turn followed by a call to `foo.DoThis(6)`. If a call occurred
+out-of-order, Google Mock will report an error.
+
+## Expecting Partially Ordered Calls ##
+
+Sometimes requiring everything to occur in a predetermined order can
+lead to brittle tests. For example, we may care about `A` occurring
+before both `B` and `C`, but aren't interested in the relative order
+of `B` and `C`. In this case, the test should reflect our real intent,
+instead of being overly constraining.
+
+Google Mock allows you to impose an arbitrary DAG (directed acyclic
+graph) on the calls. One way to express the DAG is to use the
+[After](V1_5_CheatSheet#The_After_Clause.md) clause of `EXPECT_CALL`.
+
+Another way is via the `InSequence()` clause (not the same as the
+`InSequence` class), which we borrowed from jMock 2. It's less
+flexible than `After()`, but more convenient when you have long chains
+of sequential calls, as it doesn't require you to come up with
+different names for the expectations in the chains.  Here's how it
+works:
+
+If we view `EXPECT_CALL()` statements as nodes in a graph, and add an
+edge from node A to node B wherever A must occur before B, we can get
+a DAG. We use the term "sequence" to mean a directed path in this
+DAG. Now, if we decompose the DAG into sequences, we just need to know
+which sequences each `EXPECT_CALL()` belongs to in order to be able to
+reconstruct the orginal DAG.
+
+So, to specify the partial order on the expectations we need to do two
+things: first to define some `Sequence` objects, and then for each
+`EXPECT_CALL()` say which `Sequence` objects it is part
+of. Expectations in the same sequence must occur in the order they are
+written. For example,
+
+```
+  using ::testing::Sequence;
+
+  Sequence s1, s2;
+
+  EXPECT_CALL(foo, A())
+      .InSequence(s1, s2);
+  EXPECT_CALL(bar, B())
+      .InSequence(s1);
+  EXPECT_CALL(bar, C())
+      .InSequence(s2);
+  EXPECT_CALL(foo, D())
+      .InSequence(s2);
+```
+
+specifies the following DAG (where `s1` is `A -> B`, and `s2` is `A ->
+C -> D`):
+
+```
+       +---> B
+       |
+  A ---|
+       |
+       +---> C ---> D
+```
+
+This means that A must occur before B and C, and C must occur before
+D. There's no restriction about the order other than these.
+
+## Controlling When an Expectation Retires ##
+
+When a mock method is called, Google Mock only consider expectations
+that are still active. An expectation is active when created, and
+becomes inactive (aka _retires_) when a call that has to occur later
+has occurred. For example, in
+
+```
+  using ::testing::_;
+  using ::testing::Sequence;
+
+  Sequence s1, s2;
+
+  EXPECT_CALL(log, Log(WARNING, _, "File too large."))     // #1
+      .Times(AnyNumber())
+      .InSequence(s1, s2);
+  EXPECT_CALL(log, Log(WARNING, _, "Data set is empty."))  // #2
+      .InSequence(s1);
+  EXPECT_CALL(log, Log(WARNING, _, "User not found."))     // #3
+      .InSequence(s2);
+```
+
+as soon as either #2 or #3 is matched, #1 will retire. If a warning
+`"File too large."` is logged after this, it will be an error.
+
+Note that an expectation doesn't retire automatically when it's
+saturated. For example,
+
+```
+using ::testing::_;
+...
+  EXPECT_CALL(log, Log(WARNING, _, _));                  // #1
+  EXPECT_CALL(log, Log(WARNING, _, "File too large."));  // #2
+```
+
+says that there will be exactly one warning with the message `"File
+too large."`. If the second warning contains this message too, #2 will
+match again and result in an upper-bound-violated error.
+
+If this is not what you want, you can ask an expectation to retire as
+soon as it becomes saturated:
+
+```
+using ::testing::_;
+...
+  EXPECT_CALL(log, Log(WARNING, _, _));                 // #1
+  EXPECT_CALL(log, Log(WARNING, _, "File too large."))  // #2
+      .RetiresOnSaturation();
+```
+
+Here #2 can be used only once, so if you have two warnings with the
+message `"File too large."`, the first will match #2 and the second
+will match #1 - there will be no error.
+
+# Using Actions #
+
+## Returning References from Mock Methods ##
+
+If a mock function's return type is a reference, you need to use
+`ReturnRef()` instead of `Return()` to return a result:
+
+```
+using ::testing::ReturnRef;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD0(GetBar, Bar&());
+};
+...
+
+  MockFoo foo;
+  Bar bar;
+  EXPECT_CALL(foo, GetBar())
+      .WillOnce(ReturnRef(bar));
+```
+
+## Combining Actions ##
+
+Want to do more than one thing when a function is called? That's
+fine. `DoAll()` allow you to do sequence of actions every time. Only
+the return value of the last action in the sequence will be used.
+
+```
+using ::testing::DoAll;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(Bar, bool(int n));
+};
+...
+
+  EXPECT_CALL(foo, Bar(_))
+      .WillOnce(DoAll(action_1,
+                      action_2,
+                      ...
+                      action_n));
+```
+
+## Mocking Side Effects ##
+
+Sometimes a method exhibits its effect not via returning a value but
+via side effects. For example, it may change some global state or
+modify an output argument. To mock side effects, in general you can
+define your own action by implementing `::testing::ActionInterface`.
+
+If all you need to do is to change an output argument, the built-in
+`SetArgumentPointee()` action is convenient:
+
+```
+using ::testing::SetArgumentPointee;
+
+class MockMutator : public Mutator {
+ public:
+  MOCK_METHOD2(Mutate, void(bool mutate, int* value));
+  ...
+};
+...
+
+  MockMutator mutator;
+  EXPECT_CALL(mutator, Mutate(true, _))
+      .WillOnce(SetArgumentPointee<1>(5));
+```
+
+In this example, when `mutator.Mutate()` is called, we will assign 5
+to the `int` variable pointed to by argument #1
+(0-based).
+
+`SetArgumentPointee()` conveniently makes an internal copy of the
+value you pass to it, removing the need to keep the value in scope and
+alive. The implication however is that the value must have a copy
+constructor and assignment operator.
+
+If the mock method also needs to return a value as well, you can chain
+`SetArgumentPointee()` with `Return()` using `DoAll()`:
+
+```
+using ::testing::_;
+using ::testing::Return;
+using ::testing::SetArgumentPointee;
+
+class MockMutator : public Mutator {
+ public:
+  ...
+  MOCK_METHOD1(MutateInt, bool(int* value));
+};
+...
+
+  MockMutator mutator;
+  EXPECT_CALL(mutator, MutateInt(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(5),
+                      Return(true)));
+```
+
+If the output argument is an array, use the
+`SetArrayArgument<N>(first, last)` action instead. It copies the
+elements in source range `[first, last)` to the array pointed to by
+the `N`-th (0-based) argument:
+
+```
+using ::testing::NotNull;
+using ::testing::SetArrayArgument;
+
+class MockArrayMutator : public ArrayMutator {
+ public:
+  MOCK_METHOD2(Mutate, void(int* values, int num_values));
+  ...
+};
+...
+
+  MockArrayMutator mutator;
+  int values[5] = { 1, 2, 3, 4, 5 };
+  EXPECT_CALL(mutator, Mutate(NotNull(), 5))
+      .WillOnce(SetArrayArgument<0>(values, values + 5));
+```
+
+This also works when the argument is an output iterator:
+
+```
+using ::testing::_;
+using ::testing::SeArrayArgument;
+
+class MockRolodex : public Rolodex {
+ public:
+  MOCK_METHOD1(GetNames, void(std::back_insert_iterator<vector<string> >));
+  ...
+};
+...
+
+  MockRolodex rolodex;
+  vector<string> names;
+  names.push_back("George");
+  names.push_back("John");
+  names.push_back("Thomas");
+  EXPECT_CALL(rolodex, GetNames(_))
+      .WillOnce(SetArrayArgument<0>(names.begin(), names.end()));
+```
+
+## Changing a Mock Object's Behavior Based on the State ##
+
+If you expect a call to change the behavior of a mock object, you can use `::testing::InSequence` to specify different behaviors before and after the call:
+
+```
+using ::testing::InSequence;
+using ::testing::Return;
+
+...
+  {
+    InSequence seq;
+    EXPECT_CALL(my_mock, IsDirty())
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(my_mock, Flush());
+    EXPECT_CALL(my_mock, IsDirty())
+        .WillRepeatedly(Return(false));
+  }
+  my_mock.FlushIfDirty();
+```
+
+This makes `my_mock.IsDirty()` return `true` before `my_mock.Flush()` is called and return `false` afterwards.
+
+If the behavior change is more complex, you can store the effects in a variable and make a mock method get its return value from that variable:
+
+```
+using ::testing::_;
+using ::testing::SaveArg;
+using ::testing::Return;
+
+ACTION_P(ReturnPointee, p) { return *p; }
+...
+  int previous_value = 0;
+  EXPECT_CALL(my_mock, GetPrevValue())
+      .WillRepeatedly(ReturnPointee(&previous_value));
+  EXPECT_CALL(my_mock, UpdateValue(_))
+      .WillRepeatedly(SaveArg<0>(&previous_value));
+  my_mock.DoSomethingToUpdateValue();
+```
+
+Here `my_mock.GetPrevValue()` will always return the argument of the last `UpdateValue()` call.
+
+## Setting the Default Value for a Return Type ##
+
+If a mock method's return type is a built-in C++ type or pointer, by
+default it will return 0 when invoked. You only need to specify an
+action if this default value doesn't work for you.
+
+Sometimes, you may want to change this default value, or you may want
+to specify a default value for types Google Mock doesn't know
+about. You can do this using the `::testing::DefaultValue` class
+template:
+
+```
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD0(CalculateBar, Bar());
+};
+...
+
+  Bar default_bar;
+  // Sets the default return value for type Bar.
+  DefaultValue<Bar>::Set(default_bar);
+
+  MockFoo foo;
+
+  // We don't need to specify an action here, as the default
+  // return value works for us.
+  EXPECT_CALL(foo, CalculateBar());
+
+  foo.CalculateBar();  // This should return default_bar.
+
+  // Unsets the default return value.
+  DefaultValue<Bar>::Clear();
+```
+
+Please note that changing the default value for a type can make you
+tests hard to understand. We recommend you to use this feature
+judiciously. For example, you may want to make sure the `Set()` and
+`Clear()` calls are right next to the code that uses your mock.
+
+## Setting the Default Actions for a Mock Method ##
+
+You've learned how to change the default value of a given
+type. However, this may be too coarse for your purpose: perhaps you
+have two mock methods with the same return type and you want them to
+have different behaviors. The `ON_CALL()` macro allows you to
+customize your mock's behavior at the method level:
+
+```
+using ::testing::_;
+using ::testing::AnyNumber;
+using ::testing::Gt;
+using ::testing::Return;
+...
+  ON_CALL(foo, Sign(_))
+      .WillByDefault(Return(-1));
+  ON_CALL(foo, Sign(0))
+      .WillByDefault(Return(0));
+  ON_CALL(foo, Sign(Gt(0)))
+      .WillByDefault(Return(1));
+
+  EXPECT_CALL(foo, Sign(_))
+      .Times(AnyNumber());
+
+  foo.Sign(5);   // This should return 1.
+  foo.Sign(-9);  // This should return -1.
+  foo.Sign(0);   // This should return 0.
+```
+
+As you may have guessed, when there are more than one `ON_CALL()`
+statements, the news order take precedence over the older ones. In
+other words, the **last** one that matches the function arguments will
+be used. This matching order allows you to set up the common behavior
+in a mock object's constructor or the test fixture's set-up phase and
+specialize the mock's behavior later.
+
+## Using Functions/Methods/Functors as Actions ##
+
+If the built-in actions don't suit you, you can easily use an existing
+function, method, or functor as an action:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD2(Sum, int(int x, int y));
+  MOCK_METHOD1(ComplexJob, bool(int x));
+};
+
+int CalculateSum(int x, int y) { return x + y; }
+
+class Helper {
+ public:
+  bool ComplexJob(int x);
+};
+...
+
+  MockFoo foo;
+  Helper helper;
+  EXPECT_CALL(foo, Sum(_, _))
+      .WillOnce(Invoke(CalculateSum));
+  EXPECT_CALL(foo, ComplexJob(_))
+      .WillOnce(Invoke(&helper, &Helper::ComplexJob));
+
+  foo.Sum(5, 6);       // Invokes CalculateSum(5, 6).
+  foo.ComplexJob(10);  // Invokes helper.ComplexJob(10);
+```
+
+The only requirement is that the type of the function, etc must be
+_compatible_ with the signature of the mock function, meaning that the
+latter's arguments can be implicitly converted to the corresponding
+arguments of the former, and the former's return type can be
+implicitly converted to that of the latter. So, you can invoke
+something whose type is _not_ exactly the same as the mock function,
+as long as it's safe to do so - nice, huh?
+
+## Invoking a Function/Method/Functor Without Arguments ##
+
+`Invoke()` is very useful for doing actions that are more complex. It
+passes the mock function's arguments to the function or functor being
+invoked such that the callee has the full context of the call to work
+with. If the invoked function is not interested in some or all of the
+arguments, it can simply ignore them.
+
+Yet, a common pattern is that a test author wants to invoke a function
+without the arguments of the mock function. `Invoke()` allows her to
+do that using a wrapper function that throws away the arguments before
+invoking an underlining nullary function. Needless to say, this can be
+tedious and obscures the intent of the test.
+
+`InvokeWithoutArgs()` solves this problem. It's like `Invoke()` except
+that it doesn't pass the mock function's arguments to the
+callee. Here's an example:
+
+```
+using ::testing::_;
+using ::testing::InvokeWithoutArgs;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(ComplexJob, bool(int n));
+};
+
+bool Job1() { ... }
+...
+
+  MockFoo foo;
+  EXPECT_CALL(foo, ComplexJob(_))
+      .WillOnce(InvokeWithoutArgs(Job1));
+
+  foo.ComplexJob(10);  // Invokes Job1().
+```
+
+## Invoking an Argument of the Mock Function ##
+
+Sometimes a mock function will receive a function pointer or a functor
+(in other words, a "callable") as an argument, e.g.
+
+```
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD2(DoThis, bool(int n, bool (*fp)(int)));
+};
+```
+
+and you may want to invoke this callable argument:
+
+```
+using ::testing::_;
+...
+  MockFoo foo;
+  EXPECT_CALL(foo, DoThis(_, _))
+      .WillOnce(...);
+  // Will execute (*fp)(5), where fp is the
+  // second argument DoThis() receives.
+```
+
+Arghh, you need to refer to a mock function argument but C++ has no
+lambda (yet), so you have to define your own action. :-( Or do you
+really?
+
+Well, Google Mock has an action to solve _exactly_ this problem:
+
+```
+  InvokeArgument<N>(arg_1, arg_2, ..., arg_m)
+```
+
+will invoke the `N`-th (0-based) argument the mock function receives,
+with `arg_1`, `arg_2`, ..., and `arg_m`. No matter if the argument is
+a function pointer or a functor, Google Mock handles them both.
+
+With that, you could write:
+
+```
+using ::testing::_;
+using ::testing::InvokeArgument;
+...
+  EXPECT_CALL(foo, DoThis(_, _))
+      .WillOnce(InvokeArgument<1>(5));
+  // Will execute (*fp)(5), where fp is the
+  // second argument DoThis() receives.
+```
+
+What if the callable takes an argument by reference? No problem - just
+wrap it inside `ByRef()`:
+
+```
+...
+  MOCK_METHOD1(Bar, bool(bool (*fp)(int, const Helper&)));
+...
+using ::testing::_;
+using ::testing::ByRef;
+using ::testing::InvokeArgument;
+...
+
+  MockFoo foo;
+  Helper helper;
+  ...
+  EXPECT_CALL(foo, Bar(_))
+      .WillOnce(InvokeArgument<0>(5, ByRef(helper)));
+  // ByRef(helper) guarantees that a reference to helper, not a copy of it,
+  // will be passed to the callable.
+```
+
+What if the callable takes an argument by reference and we do **not**
+wrap the argument in `ByRef()`? Then `InvokeArgument()` will _make a
+copy_ of the argument, and pass a _reference to the copy_, instead of
+a reference to the original value, to the callable. This is especially
+handy when the argument is a temporary value:
+
+```
+...
+  MOCK_METHOD1(DoThat, bool(bool (*f)(const double& x, const string& s)));
+...
+using ::testing::_;
+using ::testing::InvokeArgument;
+...
+
+  MockFoo foo;
+  ...
+  EXPECT_CALL(foo, DoThat(_))
+      .WillOnce(InvokeArgument<0>(5.0, string("Hi")));
+  // Will execute (*f)(5.0, string("Hi")), where f is the function pointer
+  // DoThat() receives.  Note that the values 5.0 and string("Hi") are
+  // temporary and dead once the EXPECT_CALL() statement finishes.  Yet
+  // it's fine to perform this action later, since a copy of the values
+  // are kept inside the InvokeArgument action.
+```
+
+## Ignoring an Action's Result ##
+
+Sometimes you have an action that returns _something_, but you need an
+action that returns `void` (perhaps you want to use it in a mock
+function that returns `void`, or perhaps it needs to be used in
+`DoAll()` and it's not the last in the list). `IgnoreResult()` lets
+you do that. For example:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Return;
+
+int Process(const MyData& data);
+string DoSomething();
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(Abc, void(const MyData& data));
+  MOCK_METHOD0(Xyz, bool());
+};
+...
+
+  MockFoo foo;
+  EXPECT_CALL(foo, Abc(_))
+  // .WillOnce(Invoke(Process));
+  // The above line won't compile as Process() returns int but Abc() needs
+  // to return void.
+      .WillOnce(IgnoreResult(Invoke(Process)));
+
+  EXPECT_CALL(foo, Xyz())
+      .WillOnce(DoAll(IgnoreResult(Invoke(DoSomething)),
+      // Ignores the string DoSomething() returns.
+                      Return(true)));
+```
+
+Note that you **cannot** use `IgnoreResult()` on an action that already
+returns `void`. Doing so will lead to ugly compiler errors.
+
+## Selecting an Action's Arguments ##
+
+Say you have a mock function `Foo()` that takes seven arguments, and
+you have a custom action that you want to invoke when `Foo()` is
+called. Trouble is, the custom action only wants three arguments:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+...
+  MOCK_METHOD7(Foo, bool(bool visible, const string& name, int x, int y,
+                         const map<pair<int, int>, double>& weight,
+                         double min_weight, double max_wight));
+...
+
+bool IsVisibleInQuadrant1(bool visible, int x, int y) {
+  return visible && x >= 0 && y >= 0;
+}
+...
+
+  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
+      .WillOnce(Invoke(IsVisibleInQuadrant1));  // Uh, won't compile. :-(
+```
+
+To please the compiler God, you can to define an "adaptor" that has
+the same signature as `Foo()` and calls the custom action with the
+right arguments:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+bool MyIsVisibleInQuadrant1(bool visible, const string& name, int x, int y,
+                            const map<pair<int, int>, double>& weight,
+                            double min_weight, double max_wight) {
+  return IsVisibleInQuadrant1(visible, x, y);
+}
+...
+
+  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
+      .WillOnce(Invoke(MyIsVisibleInQuadrant1));  // Now it works.
+```
+
+But isn't this awkward?
+
+Google Mock provides a generic _action adaptor_, so you can spend your
+time minding more important business than writing your own
+adaptors. Here's the syntax:
+
+```
+  WithArgs<N1, N2, ..., Nk>(action)
+```
+
+creates an action that passes the arguments of the mock function at
+the given indices (0-based) to the inner `action` and performs
+it. Using `WithArgs`, our original example can be written as:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::WithArgs;
+...
+  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
+      .WillOnce(WithArgs<0, 2, 3>(Invoke(IsVisibleInQuadrant1)));
+      // No need to define your own adaptor.
+```
+
+For better readability, Google Mock also gives you:
+
+  * `WithoutArgs(action)` when the inner `action` takes _no_ argument, and
+  * `WithArg<N>(action)` (no `s` after `Arg`) when the inner `action` takes _one_ argument.
+
+As you may have realized, `InvokeWithoutArgs(...)` is just syntactic
+sugar for `WithoutArgs(Inovke(...))`.
+
+Here are more tips:
+
+  * The inner action used in `WithArgs` and friends does not have to be `Invoke()` -- it can be anything.
+  * You can repeat an argument in the argument list if necessary, e.g. `WithArgs<2, 3, 3, 5>(...)`.
+  * You can change the order of the arguments, e.g. `WithArgs<3, 2, 1>(...)`.
+  * The types of the selected arguments do _not_ have to match the signature of the inner action exactly. It works as long as they can be implicitly converted to the corresponding arguments of the inner action. For example, if the 4-th argument of the mock function is an `int` and `my_action` takes a `double`, `WithArg<4>(my_action)` will work.
+
+## Ignoring Arguments in Action Functions ##
+
+The selecting-an-action's-arguments recipe showed us one way to make a
+mock function and an action with incompatible argument lists fit
+together. The downside is that wrapping the action in
+`WithArgs<...>()` can get tedious for people writing the tests.
+
+If you are defining a function, method, or functor to be used with
+`Invoke*()`, and you are not interested in some of its arguments, an
+alternative to `WithArgs` is to declare the uninteresting arguments as
+`Unused`. This makes the definition less cluttered and less fragile in
+case the types of the uninteresting arguments change. It could also
+increase the chance the action function can be reused. For example,
+given
+
+```
+  MOCK_METHOD3(Foo, double(const string& label, double x, double y));
+  MOCK_METHOD3(Bar, double(int index, double x, double y));
+```
+
+instead of
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+double DistanceToOriginWithLabel(const string& label, double x, double y) {
+  return sqrt(x*x + y*y);
+}
+
+double DistanceToOriginWithIndex(int index, double x, double y) {
+  return sqrt(x*x + y*y);
+}
+...
+
+  EXEPCT_CALL(mock, Foo("abc", _, _))
+      .WillOnce(Invoke(DistanceToOriginWithLabel));
+  EXEPCT_CALL(mock, Bar(5, _, _))
+      .WillOnce(Invoke(DistanceToOriginWithIndex));
+```
+
+you could write
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Unused;
+
+double DistanceToOrigin(Unused, double x, double y) {
+  return sqrt(x*x + y*y);
+}
+...
+
+  EXEPCT_CALL(mock, Foo("abc", _, _))
+      .WillOnce(Invoke(DistanceToOrigin));
+  EXEPCT_CALL(mock, Bar(5, _, _))
+      .WillOnce(Invoke(DistanceToOrigin));
+```
+
+## Sharing Actions ##
+
+Just like matchers, a Google Mock action object consists of a pointer
+to a ref-counted implementation object. Therefore copying actions is
+also allowed and very efficient. When the last action that references
+the implementation object dies, the implementation object will be
+deleted.
+
+If you have some complex action that you want to use again and again,
+you may not have to build it from scratch everytime. If the action
+doesn't have an internal state (i.e. if it always does the same thing
+no matter how many times it has been called), you can assign it to an
+action variable and use that variable repeatedly. For example:
+
+```
+  Action<bool(int*)> set_flag = DoAll(SetArgumentPointee<0>(5),
+                                      Return(true));
+  ... use set_flag in .WillOnce() and .WillRepeatedly() ...
+```
+
+However, if the action has its own state, you may be surprised if you
+share the action object. Suppose you have an action factory
+`IncrementCounter(init)` which creates an action that increments and
+returns a counter whose initial value is `init`, using two actions
+created from the same expression and using a shared action will
+exihibit different behaviors. Example:
+
+```
+  EXPECT_CALL(foo, DoThis())
+      .WillRepeatedly(IncrementCounter(0));
+  EXPECT_CALL(foo, DoThat())
+      .WillRepeatedly(IncrementCounter(0));
+  foo.DoThis();  // Returns 1.
+  foo.DoThis();  // Returns 2.
+  foo.DoThat();  // Returns 1 - Blah() uses a different
+                 // counter than Bar()'s.
+```
+
+versus
+
+```
+  Action<int()> increment = IncrementCounter(0);
+
+  EXPECT_CALL(foo, DoThis())
+      .WillRepeatedly(increment);
+  EXPECT_CALL(foo, DoThat())
+      .WillRepeatedly(increment);
+  foo.DoThis();  // Returns 1.
+  foo.DoThis();  // Returns 2.
+  foo.DoThat();  // Returns 3 - the counter is shared.
+```
+
+# Misc Recipes on Using Google Mock #
+
+## Forcing a Verification ##
+
+When it's being destoyed, your friendly mock object will automatically
+verify that all expectations on it have been satisfied, and will
+generate [Google Test](http://code.google.com/p/googletest/) failures
+if not. This is convenient as it leaves you with one less thing to
+worry about. That is, unless you are not sure if your mock object will
+be destoyed.
+
+How could it be that your mock object won't eventually be destroyed?
+Well, it might be created on the heap and owned by the code you are
+testing. Suppose there's a bug in that code and it doesn't delete the
+mock object properly - you could end up with a passing test when
+there's actually a bug.
+
+Using a heap checker is a good idea and can alleviate the concern, but
+its implementation may not be 100% reliable. So, sometimes you do want
+to _force_ Google Mock to verify a mock object before it is
+(hopefully) destructed. You can do this with
+`Mock::VerifyAndClearExpectations(&mock_object)`:
+
+```
+TEST(MyServerTest, ProcessesRequest) {
+  using ::testing::Mock;
+
+  MockFoo* const foo = new MockFoo;
+  EXPECT_CALL(*foo, ...)...;
+  // ... other expectations ...
+
+  // server now owns foo.
+  MyServer server(foo);
+  server.ProcessRequest(...);
+
+  // In case that server's destructor will forget to delete foo,
+  // this will verify the expectations anyway.
+  Mock::VerifyAndClearExpectations(foo);
+}  // server is destroyed when it goes out of scope here.
+```
+
+**Tip:** The `Mock::VerifyAndClearExpectations()` function returns a
+`bool` to indicate whether the verification was successful (`true` for
+yes), so you can wrap that function call inside a `ASSERT_TRUE()` if
+there is no point going further when the verification has failed.
+
+## Using Check Points ##
+
+Sometimes you may want to "reset" a mock object at various check
+points in your test: at each check point, you verify that all existing
+expectations on the mock object have been satisfied, and then you set
+some new expectations on it as if it's newly created. This allows you
+to work with a mock object in "phases" whose sizes are each
+manageable.
+
+One such scenario is that in your test's `SetUp()` function, you may
+want to put the object you are testing into a certain state, with the
+help from a mock object. Once in the desired state, you want to clear
+all expectations on the mock, such that in the `TEST_F` body you can
+set fresh expectations on it.
+
+As you may have figured out, the `Mock::VerifyAndClearExpectations()`
+function we saw in the previous recipe can help you here. Or, if you
+are using `ON_CALL()` to set default actions on the mock object and
+want to clear the default actions as well, use
+`Mock::VerifyAndClear(&mock_object)` instead. This function does what
+`Mock::VerifyAndClearExpectations(&mock_object)` does and returns the
+same `bool`, **plus** it clears the `ON_CALL()` statements on
+`mock_object` too.
+
+Another trick you can use to achieve the same effect is to put the
+expectations in sequences and insert calls to a dummy "check-point"
+function at specific places. Then you can verify that the mock
+function calls do happen at the right time. 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:
+
+```
+using ::testing::MockFunction;
+
+TEST(FooTest, InvokesBarCorrectly) {
+  MyMock mock;
+  // Class MockFunction<F> has exactly one mock method.  It is named
+  // Call() and has type F.
+  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()`.
+
+## Mocking Destructors ##
+
+Sometimes you want to make sure a mock object is destructed at the
+right time, e.g. after `bar->A()` is called but before `bar->B()` is
+called. We already know that you can specify constraints on the order
+of mock function calls, so all we need to do is to mock the destructor
+of the mock function.
+
+This sounds simple, except for one problem: a destructor is a special
+function with special syntax and special semantics, and the
+`MOCK_METHOD0` macro doesn't work for it:
+
+```
+  MOCK_METHOD0(~MockFoo, void());  // Won't compile!
+```
+
+The good news is that you can use a simple pattern to achieve the same
+effect. First, add a mock function `Die()` to your mock class and call
+it in the destructor, like this:
+
+```
+class MockFoo : public Foo {
+  ...
+  // Add the following two lines to the mock class.
+  MOCK_METHOD0(Die, void());
+  virtual ~MockFoo() { Die(); }
+};
+```
+
+(If the name `Die()` clashes with an existing symbol, choose another
+name.) Now, we have translated the problem of testing when a `MockFoo`
+object dies to testing when its `Die()` method is called:
+
+```
+  MockFoo* foo = new MockFoo;
+  MockBar* bar = new MockBar;
+  ...
+  {
+    InSequence s;
+
+    // Expects *foo to die after bar->A() and before bar->B().
+    EXPECT_CALL(*bar, A());
+    EXPECT_CALL(*foo, Die());
+    EXPECT_CALL(*bar, B());
+  }
+```
+
+And that's that.
+
+## Using Google Mock and Threads ##
+
+**IMPORTANT NOTE:** What we describe in this recipe is **NOT** true yet,
+as Google Mock is not currently thread-safe.  However, all we need to
+make it thread-safe is to implement some synchronization operations in
+`<gtest/internal/gtest-port.h>` - and then the information below will
+become true.
+
+In a **unit** test, it's best if you could isolate and test a piece of
+code in a single-threaded context. That avoids race conditions and
+dead locks, and makes debugging your test much easier.
+
+Yet many programs are multi-threaded, and sometimes to test something
+we need to pound on it from more than one thread. Google Mock works
+for this purpose too.
+
+Remember the steps for using a mock:
+
+  1. Create a mock object `foo`.
+  1. Set its default actions and expectations using `ON_CALL()` and `EXPECT_CALL()`.
+  1. The code under test calls methods of `foo`.
+  1. Optionally, verify and reset the mock.
+  1. Destroy the mock yourself, or let the code under test destroy it. The destructor will automatically verify it.
+
+If you follow the following simple rules, your mocks and threads can
+live happily togeter:
+
+  * Execute your _test code_ (as opposed to the code being tested) in _one_ thread. This makes your test easy to follow.
+  * Obviously, you can do step #1 without locking.
+  * When doing step #2 and #5, make sure no other thread is accessing `foo`. Obvious too, huh?
+  * #3 and #4 can be done either in one thread or in multiple threads - anyway you want. Google Mock takes care of the locking, so you don't have to do any - unless required by your test logic.
+
+If you violate the rules (for example, if you set expectations on a
+mock while another thread is calling its methods), you get undefined
+behavior. That's not fun, so don't do it.
+
+Google Mock guarantees that the action for a mock function is done in
+the same thread that called the mock function. For example, in
+
+```
+  EXPECT_CALL(mock, Foo(1))
+      .WillOnce(action1);
+  EXPECT_CALL(mock, Foo(2))
+      .WillOnce(action2);
+```
+
+if `Foo(1)` is called in thread 1 and `Foo(2)` is called in thread 2,
+Google Mock will execute `action1` in thread 1 and `action2` in thread
+2.
+
+Google Mock does _not_ impose a sequence on actions performed in
+different threads (doing so may create deadlocks as the actions may
+need to cooperate). This means that the execution of `action1` and
+`action2` in the above example _may_ interleave. If this is a problem,
+you should add proper synchronization logic to `action1` and `action2`
+to make the test thread-safe.
+
+
+Also, remember that `DefaultValue<T>` is a global resource that
+potentially affects _all_ living mock objects in your
+program. Naturally, you won't want to mess with it from multiple
+threads or when there still are mocks in action.
+
+## Controlling How Much Information Google Mock Prints ##
+
+When Google Mock sees something that has the potential of being an
+error (e.g. a mock function with no expectation is called, a.k.a. an
+uninteresting call, which is allowed but perhaps you forgot to
+explicitly ban the call), it prints some warning messages, including
+the arguments of the function and the return value. Hopefully this
+will remind you to take a look and see if there is indeed a problem.
+
+Sometimes you are confident that your tests are correct and may not
+appreciate such friendly messages. Some other times, you are debugging
+your tests or learning about the behavior of the code you are testing,
+and wish you could observe every mock call that happens (including
+argument values and the return value). Clearly, one size doesn't fit
+all.
+
+You can control how much Google Mock tells you using the
+`--gmock_verbose=LEVEL` command-line flag, where `LEVEL` is a string
+with three possible values:
+
+  * `info`: Google Mock will print all informational messages, warnings, and errors (most verbose). At this setting, Google Mock will also log any calls to the `ON_CALL/EXPECT_CALL` macros.
+  * `warning`: Google Mock will print both warnings and errors (less verbose). This is the default.
+  * `error`: Google Mock will print errors only (least verbose).
+
+Alternatively, you can adjust the value of that flag from within your
+tests like so:
+
+```
+  ::testing::FLAGS_gmock_verbose = "error";
+```
+
+Now, judiciously use the right flag to enable Google Mock serve you better!
+
+## Running Tests in Emacs ##
+
+If you build and run your tests in Emacs, the source file locations of
+Google Mock and [Google Test](http://code.google.com/p/googletest/)
+errors will be highlighted. Just press `<Enter>` on one of them and
+you'll be taken to the offending line. Or, you can just type `C-x ``
+to jump to the next error.
+
+To make it even easier, you can add the following lines to your
+`~/.emacs` file:
+
+```
+(global-set-key "\M-m"   'compile)  ; m is for make
+(global-set-key [M-down] 'next-error)
+(global-set-key [M-up]   '(lambda () (interactive) (next-error -1)))
+```
+
+Then you can type `M-m` to start a build, or `M-up`/`M-down` to move
+back and forth between errors.
+
+## Fusing Google Mock Source Files ##
+
+Google Mock's implementation consists of dozens of files (excluding
+its own tests).  Sometimes you may want them to be packaged up in
+fewer files instead, such that you can easily copy them to a new
+machine and start hacking there.  For this we provide an experimental
+Python script `fuse_gmock_files.py` in the `scripts/` directory
+(starting with release 1.2.0).  Assuming you have Python 2.4 or above
+installed on your machine, just go to that directory and run
+```
+python fuse_gmock_files.py OUTPUT_DIR
+```
+
+and you should see an `OUTPUT_DIR` directory being created with files
+`gtest/gtest.h`, `gmock/gmock.h`, and `gmock-gtest-all.cc` in it.
+These three files contain everything you need to use Google Mock (and
+Google Test).  Just copy them to anywhere you want and you are ready
+to write tests and use mocks.  You can use the
+[scrpts/test/Makefile](http://code.google.com/p/googlemock/source/browse/trunk/scripts/test/Makefile) file as an example on how to compile your tests
+against them.
+
+# Extending Google Mock #
+
+## Writing New Matchers Quickly ##
+
+The `MATCHER*` family of macros can be used to define custom matchers
+easily.  The syntax:
+
+```
+MATCHER(name, "description string") { statements; }
+```
+
+will define 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
+Google Mock will use the sequence of words in the matcher name as the
+description.
+
+For example:
+```
+MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; }
+```
+allows you to write
+```
+  // Expects mock_foo.Bar(n) to be called where n is divisible by 7.
+  EXPECT_CALL(mock_foo, Bar(IsDivisibleBy7()));
+```
+or,
+```
+  // Verifies that the value of some_expression is divisible by 7.
+  EXPECT_THAT(some_expression, IsDivisibleBy7());
+```
+If the above assertion fails, it will print something like:
+```
+  Value of: some_expression
+  Expected: is divisible by 7
+    Actual: 27
+```
+where the description `"is divisible by 7"` is automatically calculated from the
+matcher name `IsDivisibleBy7`.
+
+Optionally, you can stream additional information to a hidden argument
+named `result_listener` to explain the match result. For example, a
+better definition of `IsDivisibleBy7` is:
+```
+MATCHER(IsDivisibleBy7, "") {
+  if ((arg % 7) == 0)
+    return true;
+
+  *result_listener << "the remainder is " << (arg % 7);
+  return false;
+}
+```
+
+With this definition, the above assertion will give a better message:
+```
+  Value of: some_expression
+  Expected: is divisible by 7
+    Actual: 27 (the remainder is 6)
+```
+
+You should let `MatchAndExplain()` print _any additional information_
+that can help a user understand the match result. Note that it should
+explain why the match succeeds in case of a success (unless it's
+obvious) - this is useful when the matcher is used inside
+`Not()`. There is no need to print the argument value itself, as
+Google Mock already prints it for you.
+
+**Notes:**
+
+  1. 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, `IsDivisibleBy7()` can be used to match any type where the value of `(arg % 7) == 0` can be implicitly converted to a `bool`.  In the `Bar(IsDivisibleBy7())` 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.
+  1. Google Mock doesn't guarantee when or how many times a matcher will be invoked. Therefore the matcher logic must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters). This requirement must be satisfied no matter how you define the matcher (e.g. using one of the methods described in the following recipes). In particular, a matcher can never call a mock function, as that will affect the state of the mock object and Google Mock.
+
+## Writing New Parameterized Matchers Quickly ##
+
+Sometimes you'll want to define a matcher that has parameters.  For that you
+can use the 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`.
+
+Google Mock also provides `MATCHER_P2`, `MATCHER_P3`, ..., up to
+`MATCHER_P10` to support multi-parameter matchers:
+```
+MATCHER_Pk(name, param_1, ..., param_k, "description string") { statements; }
+```
+
+Please note that the custom description string is for a particular
+**instance** of the matcher, where the parameters have been bound to
+actual values.  Therefore usually you'll want the parameter values to
+be part of the description.  Google Mock lets you do that using
+Python-style interpolations.  The following syntaxes are supported
+currently:
+
+| `%%` | a single `%` character |
+|:-----|:-----------------------|
+| `%(*)s` | all parameters of the matcher printed as a tuple |
+| `%(foo)s` | value of the matcher parameter named `foo` |
+
+For example,
+```
+  MATCHER_P2(InClosedRange, low, hi, "is in range [%(low)s, %(hi)s]") {
+    return low <= arg && arg <= hi;
+  }
+  ...
+  EXPECT_THAT(3, InClosedRange(4, 6));
+```
+would generate a failure that contains the message:
+```
+  Expected: is in range [4, 6]
+```
+
+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));
+```
+would generate a failure that contains the text:
+```
+  Expected: in closed range (4, 6)
+```
+
+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.  Matchers that don't have a parameter
+or have only one parameter have special types: you can assign `Foo()`
+to a `FooMatcher`-typed variable, and assign `Foo(p)` to a
+`FooMatcherP<p_type>`-typed variable.
+
+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.
+
+You can overload matchers with different numbers of parameters:
+```
+MATCHER_P(Blah, a, "description string 1") { ... }
+MATCHER_P2(Blah, a, b, "description string 2") { ... }
+```
+
+While it's tempting to always use the `MATCHER*` macros when defining
+a new matcher, you should also consider implementing
+`MatcherInterface` or using `MakePolymorphicMatcher()` instead (see
+the recipes that follow), especially if you need to use the matcher a
+lot.  While these approaches require more work, they give you more
+control on the types of the value being matched and the matcher
+parameters, which in general leads to better compiler error messages
+that pay off in the long run.  They also allow overloading matchers
+based on parameter types (as opposed to just based on the number of
+parameters).
+
+## Writing New Monomorphic Matchers ##
+
+A matcher of argument type `T` implements
+`::testing::MatcherInterface<T>` and does two things: it tests whether a
+value of type `T` matches the matcher, and can describe what kind of
+values it matches. The latter ability is used for generating readable
+error messages when expectations are violated.
+
+The interface looks like this:
+
+```
+class MatchResultListener {
+ public:
+  ...
+  // Streams x to the underlying ostream; does nothing if the ostream
+  // is NULL.
+  template <typename T>
+  MatchResultListener& operator<<(const T& x);
+
+  // Returns the underlying ostream.
+  ::std::ostream* stream();
+};
+
+template <typename T>
+class MatcherInterface {
+ public:
+  virtual ~MatcherInterface();
+
+  // Returns true iff the matcher matches x; also explains the match
+  // result to 'listener'.
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
+
+  // Describes this matcher to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+
+  // Describes the negation of this matcher to an ostream.
+  virtual void DescribeNegationTo(::std::ostream* os) const;
+};
+```
+
+If you need a custom matcher but `Truly()` is not a good option (for
+example, you may not be happy with the way `Truly(predicate)`
+describes itself, or you may want your matcher to be polymorphic as
+`Eq(value)` is), you can define a matcher to do whatever you want in
+two steps: first implement the matcher interface, and then define a
+factory function to create a matcher instance. The second step is not
+strictly needed but it makes the syntax of using the matcher nicer.
+
+For example, you can define a matcher to test whether an `int` is
+divisible by 7 and then use it like this:
+```
+using ::testing::MakeMatcher;
+using ::testing::Matcher;
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+
+class DivisibleBy7Matcher : public MatcherInterface<int> {
+ public:
+  virtual bool MatchAndExplain(int n, MatchResultListener* listener) const {
+    return (n % 7) == 0;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "is divisible by 7";
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is not divisible by 7";
+  }
+};
+
+inline Matcher<int> DivisibleBy7() {
+  return MakeMatcher(new DivisibleBy7Matcher);
+}
+...
+
+  EXPECT_CALL(foo, Bar(DivisibleBy7()));
+```
+
+You may improve the matcher message by streaming additional
+information to the `listener` argument in `MatchAndExplain()`:
+
+```
+class DivisibleBy7Matcher : public MatcherInterface<int> {
+ public:
+  virtual bool MatchAndExplain(int n,
+                               MatchResultListener* listener) const {
+    const int remainder = n % 7;
+    if (remainder != 0) {
+      *listener << "the remainder is " << remainder;
+    }
+    return remainder == 0;
+  }
+  ...
+};
+```
+
+Then, `EXPECT_THAT(x, DivisibleBy7());` may general a message like this:
+```
+Value of: x
+Expected: is divisible by 7
+  Actual: 23 (the remainder is 2)
+```
+
+## Writing New Polymorphic Matchers ##
+
+You've learned how to write your own matchers in the previous
+recipe. Just one problem: a matcher created using `MakeMatcher()` only
+works for one particular type of arguments. If you want a
+_polymorphic_ matcher that works with arguments of several types (for
+instance, `Eq(x)` can be used to match a `value` as long as `value` ==
+`x` compiles -- `value` and `x` don't have to share the same type),
+you can learn the trick from `<gmock/gmock-matchers.h>` but it's a bit
+involved.
+
+Fortunately, most of the time you can define a polymorphic matcher
+easily with the help of `MakePolymorphicMatcher()`. Here's how you can
+define `NotNull()` as an example:
+
+```
+using ::testing::MakePolymorphicMatcher;
+using ::testing::MatchResultListener;
+using ::testing::NotNull;
+using ::testing::PolymorphicMatcher;
+
+class NotNullMatcher {
+ public:
+  // To implement a polymorphic matcher, first define a COPYABLE class
+  // that has three members MatchAndExplain(), DescribeTo(), and
+  // DescribeNegationTo(), like the following.
+
+  // In this example, we want to use NotNull() with any pointer, so
+  // MatchAndExplain() accepts a pointer of any type as its first argument.
+  // In general, you can define MatchAndExplain() as an ordinary method or
+  // a method template, or even overload it.
+  template <typename T>
+  bool MatchAndExplain(T* p,
+                       MatchResultListener* /* listener */) const {
+    return p != NULL;
+  }
+
+  // Describes the property of a value matching this matcher.
+  void DescribeTo(::std::ostream* os) const { *os << "is not NULL"; }
+
+  // Describes the property of a value NOT matching this matcher.
+  void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
+};
+
+// To construct a polymorphic matcher, pass an instance of the class
+// to MakePolymorphicMatcher().  Note the return type.
+inline PolymorphicMatcher<NotNullMatcher> NotNull() {
+  return MakePolymorphicMatcher(NotNullMatcher());
+}
+...
+
+  EXPECT_CALL(foo, Bar(NotNull()));  // The argument must be a non-NULL pointer.
+```
+
+**Note:** Your polymorphic matcher class does **not** need to inherit from
+`MatcherInterface` or any other class, and its methods do **not** need
+to be virtual.
+
+Like in a monomorphic matcher, you may explain the match result by
+streaming additional information to the `listener` argument in
+`MatchAndExplain()`.
+
+## Writing New Cardinalities ##
+
+A cardinality is used in `Times()` to tell Google Mock how many times
+you expect a call to occur. It doesn't have to be exact. For example,
+you can say `AtLeast(5)` or `Between(2, 4)`.
+
+If the built-in set of cardinalities doesn't suit you, you are free to
+define your own by implementing the following interface (in namespace
+`testing`):
+
+```
+class CardinalityInterface {
+ public:
+  virtual ~CardinalityInterface();
+
+  // Returns true iff call_count calls will satisfy this cardinality.
+  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
+
+  // Returns true iff call_count calls will saturate this cardinality.
+  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
+
+  // Describes self to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+};
+```
+
+For example, to specify that a call must occur even number of times,
+you can write
+
+```
+using ::testing::Cardinality;
+using ::testing::CardinalityInterface;
+using ::testing::MakeCardinality;
+
+class EvenNumberCardinality : public CardinalityInterface {
+ public:
+  virtual bool IsSatisfiedByCallCount(int call_count) const {
+    return (call_count % 2) == 0;
+  }
+
+  virtual bool IsSaturatedByCallCount(int call_count) const {
+    return false;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "called even number of times";
+  }
+};
+
+Cardinality EvenNumber() {
+  return MakeCardinality(new EvenNumberCardinality);
+}
+...
+
+  EXPECT_CALL(foo, Bar(3))
+      .Times(EvenNumber());
+```
+
+## Writing New Actions Quickly ##
+
+If the built-in actions don't work for you, and you find it
+inconvenient to use `Invoke()`, you can use a macro from the `ACTION*`
+family to quickly define a new action that can be used in your code as
+if it's a built-in action.
+
+By writing
+```
+ACTION(name) { statements; }
+```
+in a namespace scope (i.e. not inside a class or function), you will
+define an action with the given name that executes the statements.
+The value returned by `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 as `argK`.  For example:
+```
+ACTION(IncrementArg1) { return ++(*arg1); }
+```
+allows you to write
+```
+... WillOnce(IncrementArg1());
+```
+
+Note that you don't need to specify the types of the mock function
+arguments.  Rest assured that your code is type-safe though:
+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.
+
+Another example:
+```
+ACTION(Foo) {
+  (*arg2)(5);
+  Blah();
+  *arg1 = 0;
+  return arg0;
+}
+```
+defines an action `Foo()` that invokes argument #2 (a function pointer)
+with 5, calls function `Blah()`, sets the value pointed to by argument
+#1 to 0, and returns argument #0.
+
+For more convenience and flexibility, you can also use the following
+pre-defined symbols in the body of `ACTION`:
+
+| `argK_type` | The type of the K-th (0-based) argument of the mock function |
+|:------------|:-------------------------------------------------------------|
+| `args`      | All arguments of the mock function as a tuple                |
+| `args_type` | The type of all arguments of the mock function as a tuple    |
+| `return_type` | The return type of the mock function                         |
+| `function_type` | The type of the mock function                                |
+
+For example, when using an `ACTION` as a stub action for mock function:
+```
+int DoSomething(bool flag, int* ptr);
+```
+we have:
+| **Pre-defined Symbol** | **Is Bound To** |
+|:-----------------------|:----------------|
+| `arg0`                 | the value of `flag` |
+| `arg0_type`            | the type `bool` |
+| `arg1`                 | the value of `ptr` |
+| `arg1_type`            | the type `int*` |
+| `args`                 | the tuple `(flag, ptr)` |
+| `args_type`            | the type `std::tr1::tuple<bool, int*>` |
+| `return_type`          | the type `int`  |
+| `function_type`        | the type `int(bool, int*)` |
+
+## Writing New Parameterized Actions Quickly ##
+
+Sometimes you'll want to parameterize an action you define.  For that
+we have another macro
+```
+ACTION_P(name, param) { statements; }
+```
+
+For example,
+```
+ACTION_P(Add, n) { return arg0 + n; }
+```
+will allow you to write
+```
+// Returns argument #0 + 5.
+... WillOnce(Add(5));
+```
+
+For convenience, we use the term _arguments_ for the values used to
+invoke the mock function, and the term _parameters_ for the values
+used to instantiate an action.
+
+Note that you don't need to provide the type of the parameter either.
+Suppose the parameter is named `param`, you can also use the
+Google-Mock-defined symbol `param_type` to refer to the type of the
+parameter as inferred by the compiler.  For example, in the body of
+`ACTION_P(Add, n)` above, you can write `n_type` for the type of `n`.
+
+Google Mock also provides `ACTION_P2`, `ACTION_P3`, and etc to support
+multi-parameter actions.  For example,
+```
+ACTION_P2(ReturnDistanceTo, x, y) {
+  double dx = arg0 - x;
+  double dy = arg1 - y;
+  return sqrt(dx*dx + dy*dy);
+}
+```
+lets you write
+```
+... WillOnce(ReturnDistanceTo(5.0, 26.5));
+```
+
+You can view `ACTION` as a degenerated parameterized action where the
+number of parameters is 0.
+
+You can also easily define actions overloaded on the number of parameters:
+```
+ACTION_P(Plus, a) { ... }
+ACTION_P2(Plus, a, b) { ... }
+```
+
+## Restricting the Type of an Argument or Parameter in an ACTION ##
+
+For maximum brevity and reusability, the `ACTION*` macros don't ask
+you to provide the types of the mock function arguments and the action
+parameters.  Instead, we let the compiler infer the types for us.
+
+Sometimes, however, we may want to be more explicit about the types.
+There are several tricks to do that.  For example:
+```
+ACTION(Foo) {
+  // Makes sure arg0 can be converted to int.
+  int n = arg0;
+  ... use n instead of arg0 here ...
+}
+
+ACTION_P(Bar, param) {
+  // Makes sure the type of arg1 is const char*.
+  ::testing::StaticAssertTypeEq<const char*, arg1_type>();
+
+  // Makes sure param can be converted to bool.
+  bool flag = param;
+}
+```
+where `StaticAssertTypeEq` is a compile-time assertion in Google Test
+that verifies two types are the same.
+
+## Writing New Action Templates Quickly ##
+
+Sometimes you want to give an action explicit template parameters that
+cannot be inferred from its value parameters.  `ACTION_TEMPLATE()`
+supports 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, where _m_ is between 1 and 10, and _n_ is
+between 0 and 10.  `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,
+                // Note the comma between int and k:
+                HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
+                AND_1_VALUE_PARAMS(output)) {
+  *output = T(std::tr1::get<k>(args));
+}
+```
+
+To create an instance of an action template, write:
+```
+  ActionName<t1, ..., t_m>(v1, ..., v_n)
+```
+where the `t`s are the template arguments and the
+`v`s are the value arguments.  The value argument
+types are inferred by the compiler.  For example:
+```
+using ::testing::_;
+...
+  int n;
+  EXPECT_CALL(mock, Foo(_, _))
+      .WillOnce(DuplicateArg<1, unsigned char>(&n));
+```
+
+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 a two-template-parameter action where the compiler
+is asked to infer the type of `x`?
+
+## Using the ACTION Object's Type ##
+
+If you are writing a function that returns an `ACTION` object, you'll
+need to know its type.  The type depends on the macro used to define
+the action and the parameter types.  The rule is relatively simple:
+| **Given Definition** | **Expression** | **Has Type** |
+|:---------------------|:---------------|:-------------|
+| `ACTION(Foo)`        | `Foo()`        | `FooAction`  |
+| `ACTION_TEMPLATE(Foo, HAS_m_TEMPLATE_PARAMS(...), AND_0_VALUE_PARAMS())` |	`Foo<t1, ..., t_m>()` | `FooAction<t1, ..., t_m>` |
+| `ACTION_P(Bar, param)` | `Bar(int_value)` | `BarActionP<int>` |
+| `ACTION_TEMPLATE(Bar, HAS_m_TEMPLATE_PARAMS(...), AND_1_VALUE_PARAMS(p1))` | `Bar<t1, ..., t_m>(int_value)` | `FooActionP<t1, ..., t_m, int>` |
+| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value, int_value)` | `BazActionP2<bool, int>` |
+| `ACTION_TEMPLATE(Baz, HAS_m_TEMPLATE_PARAMS(...), AND_2_VALUE_PARAMS(p1, p2))` | `Baz<t1, ..., t_m>(bool_value, int_value)` | `FooActionP2<t1, ..., t_m, bool, int>` |
+| ...                  | ...            | ...          |
+
+Note that we have to pick different suffixes (`Action`, `ActionP`,
+`ActionP2`, and etc) for actions with different numbers of value
+parameters, or the action definitions cannot be overloaded on the
+number of them.
+
+## Writing New Monomorphic Actions ##
+
+While the `ACTION*` macros are very convenient, sometimes they are
+inappropriate.  For example, despite the tricks shown in the previous
+recipes, they don't let you directly specify the types of the mock
+function arguments and the action parameters, which in general leads
+to unoptimized compiler error messages that can baffle unfamiliar
+users.  They also don't allow overloading actions based on parameter
+types without jumping through some hoops.
+
+An alternative to the `ACTION*` macros is to implement
+`::testing::ActionInterface<F>`, where `F` is the type of the mock
+function in which the action will be used. For example:
+
+```
+template <typename F>class ActionInterface {
+ public:
+  virtual ~ActionInterface();
+
+  // Performs the action.  Result is the return type of function type
+  // F, and ArgumentTuple is the tuple of arguments of F.
+  //
+  // For example, if F is int(bool, const string&), then Result would
+  // be int, and ArgumentTuple would be tr1::tuple<bool, const string&>.
+  virtual Result Perform(const ArgumentTuple& args) = 0;
+};
+
+using ::testing::_;
+using ::testing::Action;
+using ::testing::ActionInterface;
+using ::testing::MakeAction;
+
+typedef int IncrementMethod(int*);
+
+class IncrementArgumentAction : public ActionInterface<IncrementMethod> {
+ public:
+  virtual int Perform(const tr1::tuple<int*>& args) {
+    int* p = tr1::get<0>(args);  // Grabs the first argument.
+    return *p++;
+  }
+};
+
+Action<IncrementMethod> IncrementArgument() {
+  return MakeAction(new IncrementArgumentAction);
+}
+...
+
+  EXPECT_CALL(foo, Baz(_))
+      .WillOnce(IncrementArgument());
+
+  int n = 5;
+  foo.Baz(&n);  // Should return 5 and change n to 6.
+```
+
+## Writing New Polymorphic Actions ##
+
+The previous recipe showed you how to define your own action. This is
+all good, except that you need to know the type of the function in
+which the action will be used. Sometimes that can be a problem. For
+example, if you want to use the action in functions with _different_
+types (e.g. like `Return()` and `SetArgumentPointee()`).
+
+If an action can be used in several types of mock functions, we say
+it's _polymorphic_. The `MakePolymorphicAction()` function template
+makes it easy to define such an action:
+
+```
+namespace testing {
+
+template <typename Impl>
+PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl);
+
+}  // namespace testing
+```
+
+As an example, let's define an action that returns the second argument
+in the mock function's argument list. The first step is to define an
+implementation class:
+
+```
+class ReturnSecondArgumentAction {
+ public:
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& args) const {
+    // To get the i-th (0-based) argument, use tr1::get<i>(args).
+    return tr1::get<1>(args);
+  }
+};
+```
+
+This implementation class does _not_ need to inherit from any
+particular class. What matters is that it must have a `Perform()`
+method template. This method template takes the mock function's
+arguments as a tuple in a **single** argument, and returns the result of
+the action. It can be either `const` or not, but must be invokable
+with exactly one template argument, which is the result type. In other
+words, you must be able to call `Perform<R>(args)` where `R` is the
+mock function's return type and `args` is its arguments in a tuple.
+
+Next, we use `MakePolymorphicAction()` to turn an instance of the
+implementation class into the polymorphic action we need. It will be
+convenient to have a wrapper for this:
+
+```
+using ::testing::MakePolymorphicAction;
+using ::testing::PolymorphicAction;
+
+PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
+  return MakePolymorphicAction(ReturnSecondArgumentAction());
+}
+```
+
+Now, you can use this polymorphic action the same way you use the
+built-in ones:
+
+```
+using ::testing::_;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD2(DoThis, int(bool flag, int n));
+  MOCK_METHOD3(DoThat, string(int x, const char* str1, const char* str2));
+};
+...
+
+  MockFoo foo;
+  EXPECT_CALL(foo, DoThis(_, _))
+      .WillOnce(ReturnSecondArgument());
+  EXPECT_CALL(foo, DoThat(_, _, _))
+      .WillOnce(ReturnSecondArgument());
+  ...
+  foo.DoThis(true, 5);         // Will return 5.
+  foo.DoThat(1, "Hi", "Bye");  // Will return "Hi".
+```
+
+## Teaching Google Mock How to Print Your Values ##
+
+When an uninteresting or unexpected call occurs, Google Mock prints
+the argument values to help you debug.  The `EXPECT_THAT` and
+`ASSERT_THAT` assertions also print the value being validated when the
+test fails.  Google Mock does this using the user-extensible value
+printer defined in `<gmock/gmock-printers.h>`.
+
+This printer knows how to print the built-in C++ types, native arrays,
+STL containers, and any type that supports the `<<` operator. For
+other types, it prints the raw bytes in the value and hope you the
+user can figure it out.
+
+Did I say that the printer is `extensible`? That means you can teach
+it to do a better job at printing your particular type than to dump
+the bytes. To do that, you just need to define `<<` for your type:
+
+```
+#include <iostream>
+
+namespace foo {
+
+class Foo { ... };
+
+// It's important that the << operator is defined in the SAME
+// namespace that defines Foo.  C++'s look-up rules rely on that.
+::std::ostream& operator<<(::std::ostream& os, const Foo& foo) {
+  return os << foo.DebugString();  // Whatever needed to print foo to os.
+}
+
+}  // namespace foo
+```
+
+Sometimes, this might not be an option. For example, your team may
+consider it dangerous or bad style to have a `<<` operator for `Foo`,
+or `Foo` may already have a `<<` operator that doesn't do what you
+want (and you cannot change it). Don't despair though - Google Mock
+gives you a second chance to get it right. Namely, you can define a
+`PrintTo()` function like this:
+
+```
+#include <iostream>
+
+namespace foo {
+
+class Foo { ... };
+
+// It's important that PrintTo() is defined in the SAME
+// namespace that defines Foo.  C++'s look-up rules rely on that.
+void PrintTo(const Foo& foo, ::std::ostream* os) {
+  *os << foo.DebugString();  // Whatever needed to print foo to os.
+}
+
+}  // namespace foo
+```
+
+What if you have both `<<` and `PrintTo()`? In this case, the latter
+will override the former when Google Mock is concerned. This allows
+you to customize how the value should appear in Google Mock's output
+without affecting code that relies on the behavior of its `<<`
+operator.
+
+**Note:** When printing a pointer of type `T*`, Google Mock calls
+`PrintTo(T*, std::ostream* os)` instead of `operator<<(std::ostream&, T*)`.
+Therefore the only way to affect how a pointer is printed by Google
+Mock is to define `PrintTo()` for it. Also note that `T*` and `const T*`
+are different types, so you may need to define `PrintTo()` for both.
+
+Why does Google Mock treat pointers specially? There are several reasons:
+
+  * We cannot use `operator<<` to print a `signed char*` or `unsigned char*`, since it will print the pointer as a NUL-terminated C string, which likely will cause an access violation.
+  * We want `NULL` pointers to be printed as `"NULL"`, but `operator<<` prints it as `"0"`, `"nullptr"`, or something else, depending on the compiler.
+  * With some compilers, printing a `NULL` `char*` using `operator<<` will segfault.
+  * `operator<<` prints a function pointer as a `bool` (hence it always prints `"1"`), which is not very useful.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/Documentation.md
new file mode 100644
index 00000000..315b0a29
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/Documentation.md
@@ -0,0 +1,11 @@
+This page lists all documentation wiki pages for Google Mock **version 1.5.0** -- **if you use a different version of Google Mock, please read the documentation for that specific version instead.**
+
+  * [ForDummies](V1_5_ForDummies.md) -- start here if you are new to Google Mock.
+  * [CheatSheet](V1_5_CheatSheet.md) -- a quick reference.
+  * [CookBook](V1_5_CookBook.md) -- recipes for doing various tasks using Google Mock.
+  * [FrequentlyAskedQuestions](V1_5_FrequentlyAskedQuestions.md) -- check here before asking a question on the mailing list.
+
+To contribute code to Google Mock, read:
+
+  * DevGuide -- read this _before_ writing your first patch.
+  * [Pump Manual](http://code.google.com/p/googletest/wiki/PumpManual) -- how we generate some of Google Mock's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/ForDummies.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/ForDummies.md
new file mode 100644
index 00000000..fcc3b561
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/ForDummies.md
@@ -0,0 +1,439 @@
+
+
+(**Note:** If you get compiler errors that you don't understand, be sure to consult [Google Mock Doctor](V1_5_FrequentlyAskedQuestions#How_am_I_supposed_to_make_sense_of_these_horrible_template_error.md).)
+
+# What Is Google C++ Mocking Framework? #
+When you write a prototype or test, often it's not feasible or wise to rely on real objects entirely. A **mock object** implements the same interface as a real object (so it can be used as one), but lets you specify at run time how it will be used and what it should do (which methods will be called? in which order? how many times? with what arguments? what will they return? etc).
+
+**Note:** It is easy to confuse the term _fake objects_ with mock objects. Fakes and mocks actually mean very different things in the Test-Driven Development (TDD) community:
+
+  * **Fake** objects have working implementations, but usually take some shortcut (perhaps to make the operations less expensive), which makes them not suitable for production. An in-memory file system would be an example of a fake.
+  * **Mocks** are objects pre-programmed with _expectations_, which form a specification of the calls they are expected to receive.
+
+If all this seems too abstract for you, don't worry - the most important thing to remember is that a mock allows you to check the _interaction_ between itself and code that uses it. The difference between fakes and mocks will become much clearer once you start to use mocks.
+
+**Google C++ Mocking Framework** (or **Google Mock** for short) is a library (sometimes we also call it a "framework" to make it sound cool) for creating mock classes and using them. It does to C++ what [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/) do to Java.
+
+Using Google Mock involves three basic steps:
+
+  1. Use some simple macros to describe the interface you want to mock, and they will expand to the implementation of your mock class;
+  1. Create some mock objects and specify its expectations and behavior using an intuitive syntax;
+  1. Exercise code that uses the mock objects. Google Mock will catch any violation of the expectations as soon as it arises.
+
+# Why Google Mock? #
+While mock objects help you remove unnecessary dependencies in tests and make them fast and reliable, using mocks manually in C++ is _hard_:
+
+  * Someone has to implement the mocks. The job is usually tedious and error-prone. No wonder people go great distance to avoid it.
+  * The quality of those manually written mocks is a bit, uh, unpredictable. You may see some really polished ones, but you may also see some that were hacked up in a hurry and have all sorts of ad hoc restrictions.
+  * The knowledge you gained from using one mock doesn't transfer to the next.
+
+In contrast, Java and Python programmers have some fine mock frameworks, which automate the creation of mocks. As a result, mocking is a proven effective technique and widely adopted practice in those communities. Having the right tool absolutely makes the difference.
+
+Google Mock was built to help C++ programmers. It was inspired by [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/), but designed with C++'s specifics in mind. It is your friend if any of the following problems is bothering you:
+
+  * You are stuck with a sub-optimal design and wish you had done more prototyping before it was too late, but prototyping in C++ is by no means "rapid".
+  * Your tests are slow as they depend on too many libraries or use expensive resources (e.g. a database).
+  * Your tests are brittle as some resources they use are unreliable (e.g. the network).
+  * You want to test how your code handles a failure (e.g. a file checksum error), but it's not easy to cause one.
+  * You need to make sure that your module interacts with other modules in the right way, but it's hard to observe the interaction; therefore you resort to observing the side effects at the end of the action, which is awkward at best.
+  * You want to "mock out" your dependencies, except that they don't have mock implementations yet; and, frankly, you aren't thrilled by some of those hand-written mocks.
+
+We encourage you to use Google Mock as:
+
+  * a _design_ tool, for it lets you experiment with your interface design early and often. More iterations lead to better designs!
+  * a _testing_ tool to cut your tests' outbound dependencies and probe the interaction between your module and its collaborators.
+
+# Getting Started #
+Using Google Mock is easy! Inside your C++ source file, just `#include` `<gtest/gtest.h>` and `<gmock/gmock.h>`, and you are ready to go.
+
+# A Case for Mock Turtles #
+Let's look at an example. Suppose you are developing a graphics program that relies on a LOGO-like API for drawing. How would you test that it does the right thing? Well, you can run it and compare the screen with a golden screen snapshot, but let's admit it: tests like this are expensive to run and fragile (What if you just upgraded to a shiny new graphics card that has better anti-aliasing? Suddenly you have to update all your golden images.). It would be too painful if all your tests are like this. Fortunately, you learned about Dependency Injection and know the right thing to do: instead of having your application talk to the drawing API directly, wrap the API in an interface (say, `Turtle`) and code to that interface:
+
+```
+class Turtle {
+  ...
+  virtual ~Turtle() {}
+  virtual void PenUp() = 0;
+  virtual void PenDown() = 0;
+  virtual void Forward(int distance) = 0;
+  virtual void Turn(int degrees) = 0;
+  virtual void GoTo(int x, int y) = 0;
+  virtual int GetX() const = 0;
+  virtual int GetY() const = 0;
+};
+```
+
+(Note that the destructor of `Turtle` **must** be virtual, as is the case for **all** classes you intend to inherit from - otherwise the destructor of the derived class will not be called when you delete an object through a base pointer, and you'll get corrupted program states like memory leaks.)
+
+You can control whether the turtle's movement will leave a trace using `PenUp()` and `PenDown()`, and control its movement using `Forward()`, `Turn()`, and `GoTo()`. Finally, `GetX()` and `GetY()` tell you the current position of the turtle.
+
+Your program will normally use a real implementation of this interface. In tests, you can use a mock implementation instead. This allows you to easily check what drawing primitives your program is calling, with what arguments, and in which order. Tests written this way are much more robust (they won't break because your new machine does anti-aliasing differently), easier to read and maintain (the intent of a test is expressed in the code, not in some binary images), and run _much, much faster_.
+
+# Writing the Mock Class #
+If you are lucky, the mocks you need to use have already been implemented by some nice people. If, however, you find yourself in the position to write a mock class, relax - Google Mock turns this task into a fun game! (Well, almost.)
+
+## How to Define It ##
+Using the `Turtle` interface as example, here are the simple steps you need to follow:
+
+  1. Derive a class `MockTurtle` from `Turtle`.
+  1. Take a virtual function of `Turtle`. Count how many arguments it has.
+  1. In the `public:` section of the child class, write `MOCK_METHODn();` (or `MOCK_CONST_METHODn();` if you are mocking a `const` method), where `n` is the number of the arguments; if you counted wrong, shame on you, and a compiler error will tell you so.
+  1. Now comes the fun part: you take the function signature, cut-and-paste the _function name_ as the _first_ argument to the macro, and leave what's left as the _second_ argument (in case you're curious, this is the _type of the function_).
+  1. Repeat until all virtual functions you want to mock are done.
+
+After the process, you should have something like:
+
+```
+#include <gmock/gmock.h>  // Brings in Google Mock.
+class MockTurtle : public Turtle {
+ public:
+  ...
+  MOCK_METHOD0(PenUp, void());
+  MOCK_METHOD0(PenDown, void());
+  MOCK_METHOD1(Forward, void(int distance));
+  MOCK_METHOD1(Turn, void(int degrees));
+  MOCK_METHOD2(GoTo, void(int x, int y));
+  MOCK_CONST_METHOD0(GetX, int());
+  MOCK_CONST_METHOD0(GetY, int());
+};
+```
+
+You don't need to define these mock methods somewhere else - the `MOCK_METHOD*` macros will generate the definitions for you. It's that simple! Once you get the hang of it, you can pump out mock classes faster than your source-control system can handle your check-ins.
+
+**Tip:** If even this is too much work for you, you'll find the
+`gmock_gen.py` tool in Google Mock's `scripts/generator/` directory (courtesy of the [cppclean](http://code.google.com/p/cppclean/) project) useful.  This command-line
+tool requires that you have Python 2.4 installed.  You give it a C++ file and the name of an abstract class defined in it,
+and it will print the definition of the mock class for you.  Due to the
+complexity of the C++ language, this script may not always work, but
+it can be quite handy when it does.  For more details, read the [user documentation](http://code.google.com/p/googlemock/source/browse/trunk/scripts/generator/README).
+
+## Where to Put It ##
+When you define a mock class, you need to decide where to put its definition. Some people put it in a `*_test.cc`. This is fine when the interface being mocked (say, `Foo`) is owned by the same person or team. Otherwise, when the owner of `Foo` changes it, your test could break. (You can't really expect `Foo`'s maintainer to fix every test that uses `Foo`, can you?)
+
+So, the rule of thumb is: if you need to mock `Foo` and it's owned by others, define the mock class in `Foo`'s package (better, in a `testing` sub-package such that you can clearly separate production code and testing utilities), and put it in a `mock_foo.h`. Then everyone can reference `mock_foo.h` from their tests. If `Foo` ever changes, there is only one copy of `MockFoo` to change, and only tests that depend on the changed methods need to be fixed.
+
+Another way to do it: you can introduce a thin layer `FooAdaptor` on top of `Foo` and code to this new interface. Since you own `FooAdaptor`, you can absorb changes in `Foo` much more easily. While this is more work initially, carefully choosing the adaptor interface can make your code easier to write and more readable (a net win in the long run), as you can choose `FooAdaptor` to fit your specific domain much better than `Foo` does.
+
+# Using Mocks in Tests #
+Once you have a mock class, using it is easy. The typical work flow is:
+
+  1. Import the Google Mock names from the `testing` namespace such that you can use them unqualified (You only have to do it once per file. Remember that namespaces are a good idea and good for your health.).
+  1. Create some mock objects.
+  1. Specify your expectations on them (How many times will a method be called? With what arguments? What should it do? etc.).
+  1. Exercise some code that uses the mocks; optionally, check the result using Google Test assertions. If a mock method is called more than expected or with wrong arguments, you'll get an error immediately.
+  1. When a mock is destructed, Google Mock will automatically check whether all expectations on it have been satisfied.
+
+Here's an example:
+
+```
+#include "path/to/mock-turtle.h"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+using ::testing::AtLeast;                     // #1
+
+TEST(PainterTest, CanDrawSomething) {
+  MockTurtle turtle;                          // #2
+  EXPECT_CALL(turtle, PenDown())              // #3
+      .Times(AtLeast(1));
+
+  Painter painter(&turtle);                   // #4
+
+  EXPECT_TRUE(painter.DrawCircle(0, 0, 10));
+}                                             // #5
+
+int main(int argc, char** argv) {
+  // The following line must be executed to initialize Google Mock
+  // (and Google Test) before running the tests.
+  ::testing::InitGoogleMock(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+```
+
+As you might have guessed, this test checks that `PenDown()` is called at least once. If the `painter` object didn't call this method, your test will fail with a message like this:
+
+```
+path/to/my_test.cc:119: Failure
+Actual function call count doesn't match this expectation:
+Actually: never called;
+Expected: called at least once.
+```
+
+**Tip 1:** If you run the test from an Emacs buffer, you can hit `<Enter>` on the line number displayed in the error message to jump right to the failed expectation.
+
+**Tip 2:** If your mock objects are never deleted, the final verification won't happen. Therefore it's a good idea to use a heap leak checker in your tests when you allocate mocks on the heap.
+
+**Important note:** Google Mock requires expectations to be set **before** the mock functions are called, otherwise the behavior is **undefined**. In particular, you mustn't interleave `EXPECT_CALL()`s and calls to the mock functions.
+
+This means `EXPECT_CALL()` should be read as expecting that a call will occur _in the future_, not that a call has occurred. Why does Google Mock work like that? Well, specifying the expectation beforehand allows Google Mock to report a violation as soon as it arises, when the context (stack trace, etc) is still available. This makes debugging much easier.
+
+Admittedly, this test is contrived and doesn't do much. You can easily achieve the same effect without using Google Mock. However, as we shall reveal soon, Google Mock allows you to do _much more_ with the mocks.
+
+## Using Google Mock with Any Testing Framework ##
+If you want to use something other than Google Test (e.g. [CppUnit](http://apps.sourceforge.net/mediawiki/cppunit/index.php?title=Main_Page) or
+[CxxTest](http://cxxtest.tigris.org/)) as your testing framework, just change the `main()` function in the previous section to:
+```
+int main(int argc, char** argv) {
+  // The following line causes Google Mock to throw an exception on failure,
+  // which will be interpreted by your testing framework as a test failure.
+  ::testing::GTEST_FLAG(throw_on_failure) = true;
+  ::testing::InitGoogleMock(&argc, argv);
+  ... whatever your testing framework requires ...
+}
+```
+
+This approach has a catch: it makes Google Mock throw an exception
+from a mock object's destructor sometimes.  With some compilers, this
+sometimes causes the test program to crash.  You'll still be able to
+notice that the test has failed, but it's not a graceful failure.
+
+A better solution is to use Google Test's
+[event listener API](http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide#Extending_Google_Test_by_Handling_Test_Events)
+to report a test failure to your testing framework properly.  You'll need to
+implement the `OnTestPartResult()` method of the event listener interface, but it
+should be straightforward.
+
+If this turns out to be too much work, we suggest that you stick with
+Google Test, which works with Google Mock seamlessly (in fact, it is
+technically part of Google Mock.).  If there is a reason that you
+cannot use Google Test, please let us know.
+
+# Setting Expectations #
+The key to using a mock object successfully is to set the _right expectations_ on it. If you set the expectations too strict, your test will fail as the result of unrelated changes. If you set them too loose, bugs can slip through. You want to do it just right such that your test can catch exactly the kind of bugs you intend it to catch. Google Mock provides the necessary means for you to do it "just right."
+
+## General Syntax ##
+In Google Mock we use the `EXPECT_CALL()` macro to set an expectation on a mock method. The general syntax is:
+
+```
+EXPECT_CALL(mock_object, method(matchers))
+    .Times(cardinality)
+    .WillOnce(action)
+    .WillRepeatedly(action);
+```
+
+The macro has two arguments: first the mock object, and then the method and its arguments. Note that the two are separated by a comma (`,`), not a period (`.`). (Why using a comma? The answer is that it was necessary for technical reasons.)
+
+The macro can be followed by some optional _clauses_ that provide more information about the expectation. We'll discuss how each clause works in the coming sections.
+
+This syntax is designed to make an expectation read like English. For example, you can probably guess that
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetX())
+    .Times(5)
+    .WillOnce(Return(100))
+    .WillOnce(Return(150))
+    .WillRepeatedly(Return(200));
+```
+
+says that the `turtle` object's `GetX()` method will be called five times, it will return 100 the first time, 150 the second time, and then 200 every time. Some people like to call this style of syntax a Domain-Specific Language (DSL).
+
+**Note:** Why do we use a macro to do this? It serves two purposes: first it makes expectations easily identifiable (either by `grep` or by a human reader), and second it allows Google Mock to include the source file location of a failed expectation in messages, making debugging easier.
+
+## Matchers: What Arguments Do We Expect? ##
+When a mock function takes arguments, we must specify what arguments we are expecting; for example:
+
+```
+// Expects the turtle to move forward by 100 units.
+EXPECT_CALL(turtle, Forward(100));
+```
+
+Sometimes you may not want to be too specific (Remember that talk about tests being too rigid? Over specification leads to brittle tests and obscures the intent of tests. Therefore we encourage you to specify only what's necessary - no more, no less.). If you care to check that `Forward()` will be called but aren't interested in its actual argument, write `_` as the argument, which means "anything goes":
+
+```
+using ::testing::_;
+...
+// Expects the turtle to move forward.
+EXPECT_CALL(turtle, Forward(_));
+```
+
+`_` is an instance of what we call **matchers**. A matcher is like a predicate and can test whether an argument is what we'd expect. You can use a matcher inside `EXPECT_CALL()` wherever a function argument is expected.
+
+A list of built-in matchers can be found in the [CheatSheet](V1_5_CheatSheet.md). For example, here's the `Ge` (greater than or equal) matcher:
+
+```
+using ::testing::Ge;...
+EXPECT_CALL(turtle, Forward(Ge(100)));
+```
+
+This checks that the turtle will be told to go forward by at least 100 units.
+
+## Cardinalities: How Many Times Will It Be Called? ##
+The first clause we can specify following an `EXPECT_CALL()` is `Times()`. We call its argument a **cardinality** as it tells _how many times_ the call should occur. It allows us to repeat an expectation many times without actually writing it as many times. More importantly, a cardinality can be "fuzzy", just like a matcher can be. This allows a user to express the intent of a test exactly.
+
+An interesting special case is when we say `Times(0)`. You may have guessed - it means that the function shouldn't be called with the given arguments at all, and Google Mock will report a Google Test failure whenever the function is (wrongfully) called.
+
+We've seen `AtLeast(n)` as an example of fuzzy cardinalities earlier. For the list of built-in cardinalities you can use, see the [CheatSheet](V1_5_CheatSheet.md).
+
+The `Times()` clause can be omitted. **If you omit `Times()`, Google Mock will infer the cardinality for you.** The rules are easy to remember:
+
+  * If **neither** `WillOnce()` **nor** `WillRepeatedly()` is in the `EXPECT_CALL()`, the inferred cardinality is `Times(1)`.
+  * If there are `n WillOnce()`'s but **no** `WillRepeatedly()`, where `n` >= 1, the cardinality is `Times(n)`.
+  * If there are `n WillOnce()`'s and **one** `WillRepeatedly()`, where `n` >= 0, the cardinality is `Times(AtLeast(n))`.
+
+**Quick quiz:** what do you think will happen if a function is expected to be called twice but actually called four times?
+
+## Actions: What Should It Do? ##
+Remember that a mock object doesn't really have a working implementation? We as users have to tell it what to do when a method is invoked. This is easy in Google Mock.
+
+First, if the return type of a mock function is a built-in type or a pointer, the function has a **default action** (a `void` function will just return, a `bool` function will return `false`, and other functions will return 0). If you don't say anything, this behavior will be used.
+
+Second, if a mock function doesn't have a default action, or the default action doesn't suit you, you can specify the action to be taken each time the expectation matches using a series of `WillOnce()` clauses followed by an optional `WillRepeatedly()`. For example,
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetX())
+    .WillOnce(Return(100))
+    .WillOnce(Return(200))
+    .WillOnce(Return(300));
+```
+
+This says that `turtle.GetX()` will be called _exactly three times_ (Google Mock inferred this from how many `WillOnce()` clauses we've written, since we didn't explicitly write `Times()`), and will return 100, 200, and 300 respectively.
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetY())
+    .WillOnce(Return(100))
+    .WillOnce(Return(200))
+    .WillRepeatedly(Return(300));
+```
+
+says that `turtle.GetY()` will be called _at least twice_ (Google Mock knows this as we've written two `WillOnce()` clauses and a `WillRepeatedly()` while having no explicit `Times()`), will return 100 the first time, 200 the second time, and 300 from the third time on.
+
+Of course, if you explicitly write a `Times()`, Google Mock will not try to infer the cardinality itself. What if the number you specified is larger than there are `WillOnce()` clauses? Well, after all `WillOnce()`s are used up, Google Mock will do the _default_ action for the function every time (unless, of course, you have a `WillRepeatedly()`.).
+
+What can we do inside `WillOnce()` besides `Return()`? You can return a reference using `ReturnRef(variable)`, or invoke a pre-defined function, among [others](V1_5_CheatSheet#Actions.md).
+
+**Important note:** The `EXPECT_CALL()` statement evaluates the action clause only once, even though the action may be performed many times. Therefore you must be careful about side effects. The following may not do what you want:
+
+```
+int n = 100;
+EXPECT_CALL(turtle, GetX())
+.Times(4)
+.WillOnce(Return(n++));
+```
+
+Instead of returning 100, 101, 102, ..., consecutively, this mock function will always return 100 as `n++` is only evaluated once. Similarly, `Return(new Foo)` will create a new `Foo` object when the `EXPECT_CALL()` is executed, and will return the same pointer every time. If you want the side effect to happen every time, you need to define a custom action, which we'll teach in the [CookBook](V1_5_CookBook.md).
+
+Time for another quiz! What do you think the following means?
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetY())
+.Times(4)
+.WillOnce(Return(100));
+```
+
+Obviously `turtle.GetY()` is expected to be called four times. But if you think it will return 100 every time, think twice! Remember that one `WillOnce()` clause will be consumed each time the function is invoked and the default action will be taken afterwards. So the right answer is that `turtle.GetY()` will return 100 the first time, but **return 0 from the second time on**, as returning 0 is the default action for `int` functions.
+
+## Using Multiple Expectations ##
+So far we've only shown examples where you have a single expectation. More realistically, you're going to specify expectations on multiple mock methods, which may be from multiple mock objects.
+
+By default, when a mock method is invoked, Google Mock will search the expectations in the **reverse order** they are defined, and stop when an active expectation that matches the arguments is found (you can think of it as "newer rules override older ones."). If the matching expectation cannot take any more calls, you will get an upper-bound-violated failure. Here's an example:
+
+```
+using ::testing::_;...
+EXPECT_CALL(turtle, Forward(_));  // #1
+EXPECT_CALL(turtle, Forward(10))  // #2
+    .Times(2);
+```
+
+If `Forward(10)` is called three times in a row, the third time it will be an error, as the last matching expectation (#2) has been saturated. If, however, the third `Forward(10)` call is replaced by `Forward(20)`, then it would be OK, as now #1 will be the matching expectation.
+
+**Side note:** Why does Google Mock search for a match in the _reverse_ order of the expectations? The reason is that this allows a user to set up the default expectations in a mock object's constructor or the test fixture's set-up phase and then customize the mock by writing more specific expectations in the test body. So, if you have two expectations on the same method, you want to put the one with more specific matchers **after** the other, or the more specific rule would be shadowed by the more general one that comes after it.
+
+## Ordered vs Unordered Calls ##
+By default, an expectation can match a call even though an earlier expectation hasn't been satisfied. In other words, the calls don't have to occur in the order the expectations are specified.
+
+Sometimes, you may want all the expected calls to occur in a strict order. To say this in Google Mock is easy:
+
+```
+using ::testing::InSequence;...
+TEST(FooTest, DrawsLineSegment) {
+  ...
+  {
+    InSequence dummy;
+
+    EXPECT_CALL(turtle, PenDown());
+    EXPECT_CALL(turtle, Forward(100));
+    EXPECT_CALL(turtle, PenUp());
+  }
+  Foo();
+}
+```
+
+By creating an object of type `InSequence`, all expectations in its scope are put into a _sequence_ and have to occur _sequentially_. Since we are just relying on the constructor and destructor of this object to do the actual work, its name is really irrelevant.
+
+In this example, we test that `Foo()` calls the three expected functions in the order as written. If a call is made out-of-order, it will be an error.
+
+(What if you care about the relative order of some of the calls, but not all of them? Can you specify an arbitrary partial order? The answer is ... yes! If you are impatient, the details can be found in the [CookBook](V1_5_CookBook.md).)
+
+## All Expectations Are Sticky (Unless Said Otherwise) ##
+Now let's do a quick quiz to see how well you can use this mock stuff already. How would you test that the turtle is asked to go to the origin _exactly twice_ (you want to ignore any other instructions it receives)?
+
+After you've come up with your answer, take a look at ours and compare notes (solve it yourself first - don't cheat!):
+
+```
+using ::testing::_;...
+EXPECT_CALL(turtle, GoTo(_, _))  // #1
+    .Times(AnyNumber());
+EXPECT_CALL(turtle, GoTo(0, 0))  // #2
+    .Times(2);
+```
+
+Suppose `turtle.GoTo(0, 0)` is called three times. In the third time, Google Mock will see that the arguments match expectation #2 (remember that we always pick the last matching expectation). Now, since we said that there should be only two such calls, Google Mock will report an error immediately. This is basically what we've told you in the "Using Multiple Expectations" section above.
+
+This example shows that **expectations in Google Mock are "sticky" by default**, in the sense that they remain active even after we have reached their invocation upper bounds. This is an important rule to remember, as it affects the meaning of the spec, and is **different** to how it's done in many other mocking frameworks (Why'd we do that? Because we think our rule makes the common cases easier to express and understand.).
+
+Simple? Let's see if you've really understood it: what does the following code say?
+
+```
+using ::testing::Return;
+...
+for (int i = n; i > 0; i--) {
+  EXPECT_CALL(turtle, GetX())
+      .WillOnce(Return(10*i));
+}
+```
+
+If you think it says that `turtle.GetX()` will be called `n` times and will return 10, 20, 30, ..., consecutively, think twice! The problem is that, as we said, expectations are sticky. So, the second time `turtle.GetX()` is called, the last (latest) `EXPECT_CALL()` statement will match, and will immediately lead to an "upper bound exceeded" error - this piece of code is not very useful!
+
+One correct way of saying that `turtle.GetX()` will return 10, 20, 30, ..., is to explicitly say that the expectations are _not_ sticky. In other words, they should _retire_ as soon as they are saturated:
+
+```
+using ::testing::Return;
+...
+for (int i = n; i > 0; i--) {
+  EXPECT_CALL(turtle, GetX())
+    .WillOnce(Return(10*i))
+    .RetiresOnSaturation();
+}
+```
+
+And, there's a better way to do it: in this case, we expect the calls to occur in a specific order, and we line up the actions to match the order. Since the order is important here, we should make it explicit using a sequence:
+
+```
+using ::testing::InSequence;
+using ::testing::Return;
+...
+{
+  InSequence s;
+
+  for (int i = 1; i <= n; i++) {
+    EXPECT_CALL(turtle, GetX())
+        .WillOnce(Return(10*i))
+        .RetiresOnSaturation();
+  }
+}
+```
+
+By the way, the other situation where an expectation may _not_ be sticky is when it's in a sequence - as soon as another expectation that comes after it in the sequence has been used, it automatically retires (and will never be used to match any call).
+
+## Uninteresting Calls ##
+A mock object may have many methods, and not all of them are that interesting. For example, in some tests we may not care about how many times `GetX()` and `GetY()` get called.
+
+In Google Mock, if you are not interested in a method, just don't say anything about it. If a call to this method occurs, you'll see a warning in the test output, but it won't be a failure.
+
+# What Now? #
+Congratulations! You've learned enough about Google Mock to start using it. Now, you might want to join the [googlemock](http://groups.google.com/group/googlemock) discussion group and actually write some tests using Google Mock - it will be fun. Hey, it may even be addictive - you've been warned.
+
+Then, if you feel like increasing your mock quotient, you should move on to the [CookBook](V1_5_CookBook.md). You can learn many advanced features of Google Mock there -- and advance your level of enjoyment and testing bliss.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/FrequentlyAskedQuestions.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/FrequentlyAskedQuestions.md
new file mode 100644
index 00000000..7593243c
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/FrequentlyAskedQuestions.md
@@ -0,0 +1,624 @@
+
+
+Please send your questions to the
+[googlemock](http://groups.google.com/group/googlemock) discussion
+group. If you need help with compiler errors, make sure you have
+tried [Google Mock Doctor](#How_am_I_supposed_to_make_sense_of_these_horrible_template_error.md) first.
+
+## I wrote some matchers.  After I upgraded to a new version of Google Mock, they no longer compile.  What's going on? ##
+
+After version 1.4.0 of Google Mock was released, we had an idea on how
+to make it easier to write matchers that can generate informative
+messages efficiently.  We experimented with this idea and liked what
+we saw.  Therefore we decided to implement it.
+
+Unfortunately, this means that if you have defined your own matchers
+by implementing `MatcherInterface` or using `MakePolymorphicMatcher()`,
+your definitions will no longer compile.  Matchers defined using the
+`MATCHER*` family of macros are not affected.
+
+Sorry for the hassle if your matchers are affected.  We believe it's
+in everyone's long-term interest to make this change sooner than
+later.  Fortunately, it's usually not hard to migrate an existing
+matcher to the new API.  Here's what you need to do:
+
+If you wrote your matcher like this:
+```
+// Old matcher definition that doesn't work with the latest
+// Google Mock.
+using ::testing::MatcherInterface;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetFoo() > 5;
+  }
+  ...
+};
+```
+
+you'll need to change it to:
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool MatchAndExplain(MyType value,
+                               MatchResultListener* listener) const {
+    // Returns true if value matches.
+    return value.GetFoo() > 5;
+  }
+  ...
+};
+```
+(i.e. rename `Matches()` to `MatchAndExplain()` and give it a second
+argument of type `MatchResultListener*`.)
+
+If you were also using `ExplainMatchResultTo()` to improve the matcher
+message:
+```
+// Old matcher definition that doesn't work with the lastest
+// Google Mock.
+using ::testing::MatcherInterface;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetFoo() > 5;
+  }
+
+  virtual void ExplainMatchResultTo(MyType value,
+                                    ::std::ostream* os) const {
+    // Prints some helpful information to os to help
+    // a user understand why value matches (or doesn't match).
+    *os << "the Foo property is " << value.GetFoo();
+  }
+  ...
+};
+```
+
+you should move the logic of `ExplainMatchResultTo()` into
+`MatchAndExplain()`, using the `MatchResultListener` argument where
+the `::std::ostream` was used:
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool MatchAndExplain(MyType value,
+                               MatchResultListener* listener) const {
+    // Returns true if value matches.
+    *listener << "the Foo property is " << value.GetFoo();
+    return value.GetFoo() > 5;
+  }
+  ...
+};
+```
+
+If your matcher is defined using `MakePolymorphicMatcher()`:
+```
+// Old matcher definition that doesn't work with the latest
+// Google Mock.
+using ::testing::MakePolymorphicMatcher;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetBar() < 42;
+  }
+  ...
+};
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+you should rename the `Matches()` method to `MatchAndExplain()` and
+add a `MatchResultListener*` argument (the same as what you need to do
+for matchers defined by implementing `MatcherInterface`):
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MakePolymorphicMatcher;
+using ::testing::MatchResultListener;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool MatchAndExplain(MyType value,
+                       MatchResultListener* listener) const {
+    // Returns true if value matches.
+    return value.GetBar() < 42;
+  }
+  ...
+};
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+If your polymorphic matcher uses `ExplainMatchResultTo()` for better
+failure messages:
+```
+// Old matcher definition that doesn't work with the latest
+// Google Mock.
+using ::testing::MakePolymorphicMatcher;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetBar() < 42;
+  }
+  ...
+};
+void ExplainMatchResultTo(const MyGreatMatcher& matcher,
+                          MyType value,
+                          ::std::ostream* os) {
+  // Prints some helpful information to os to help
+  // a user understand why value matches (or doesn't match).
+  *os << "the Bar property is " << value.GetBar();
+}
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+you'll need to move the logic inside `ExplainMatchResultTo()` to
+`MatchAndExplain()`:
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MakePolymorphicMatcher;
+using ::testing::MatchResultListener;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool MatchAndExplain(MyType value,
+                       MatchResultListener* listener) const {
+    // Returns true if value matches.
+    *listener << "the Bar property is " << value.GetBar();
+    return value.GetBar() < 42;
+  }
+  ...
+};
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+For more information, you can read these
+[two](V1_5_CookBook#Writing_New_Monomorphic_Matchers.md)
+[recipes](V1_5_CookBook#Writing_New_Polymorphic_Matchers.md)
+from the cookbook.  As always, you
+are welcome to post questions on `googlemock@googlegroups.com` if you
+need any help.
+
+## When using Google Mock, do I have to use Google Test as the testing framework?  I have my favorite testing framework and don't want to switch. ##
+
+Google Mock works out of the box with Google Test.  However, it's easy
+to configure it to work with any testing framework of your choice.
+[Here](V1_5_ForDummies#Using_Google_Mock_with_Any_Testing_Framework.md) is how.
+
+## How am I supposed to make sense of these horrible template errors? ##
+
+If you are confused by the compiler errors gcc threw at you,
+try consulting the _Google Mock Doctor_ tool first.  What it does is to
+scan stdin for gcc error messages, and spit out diagnoses on the
+problems (we call them diseases) your code has.
+
+To "install", run command:
+```
+alias gmd='<path to googlemock>/scripts/gmock_doctor.py'
+```
+
+To use it, do:
+```
+<your-favorite-build-command> <your-test> 2>&1 | gmd
+```
+
+For example:
+```
+make my_test 2>&1 | gmd
+```
+
+Or you can run `gmd` and copy-n-paste gcc's error messages to it.
+
+## Can I mock a variadic function? ##
+
+You cannot mock a variadic function (i.e. a function taking ellipsis
+(`...`) arguments) directly in Google Mock.
+
+The problem is that in general, there is _no way_ for a mock object to
+know how many arguments are passed to the variadic method, and what
+the arguments' types are.  Only the _author of the base class_ knows
+the protocol, and we cannot look into his head.
+
+Therefore, to mock such a function, the _user_ must teach the mock
+object how to figure out the number of arguments and their types.  One
+way to do it is to provide overloaded versions of the function.
+
+Ellipsis arguments are inherited from C and not really a C++ feature.
+They are unsafe to use and don't work with arguments that have
+constructors or destructors.  Therefore we recommend to avoid them in
+C++ as much as possible.
+
+## MSVC gives me warning C4301 or C4373 when I define a mock method with a const parameter.  Why? ##
+
+If you compile this using Microsoft Visual C++ 2005 SP1:
+```
+class Foo {
+  ...
+  virtual void Bar(const int i) = 0;
+};
+
+class MockFoo : public Foo {
+  ...
+  MOCK_METHOD1(Bar, void(const int i));
+};
+```
+You may get the following warning:
+```
+warning C4301: 'MockFoo::Bar': overriding virtual function only differs from 'Foo::Bar' by const/volatile qualifier
+```
+
+This is a MSVC bug.  The same code compiles fine with gcc ,for
+example.  If you use Visual C++ 2008 SP1, you would get the warning:
+```
+warning C4373: 'MockFoo::Bar': virtual function overrides 'Foo::Bar', previous versions of the compiler did not override when parameters only differed by const/volatile qualifiers
+```
+
+In C++, if you _declare_ a function with a `const` parameter, the
+`const` modifier is _ignored_.  Therefore, the `Foo` base class above
+is equivalent to:
+```
+class Foo {
+  ...
+  virtual void Bar(int i) = 0;  // int or const int?  Makes no difference.
+};
+```
+
+In fact, you can _declare_ Bar() with an `int` parameter, and _define_
+it with a `const int` parameter.  The compiler will still match them
+up.
+
+Since making a parameter `const` is meaningless in the method
+_declaration_, we recommend to remove it in both `Foo` and `MockFoo`.
+That should workaround the VC bug.
+
+Note that we are talking about the _top-level_ `const` modifier here.
+If the function parameter is passed by pointer or reference, declaring
+the _pointee_ or _referee_ as `const` is still meaningful.  For
+example, the following two declarations are _not_ equivalent:
+```
+void Bar(int* p);        // Neither p nor *p is const.
+void Bar(const int* p);  // p is not const, but *p is.
+```
+
+## I have a huge mock class, and Microsoft Visual C++ runs out of memory when compiling it.  What can I do? ##
+
+We've noticed that when the `/clr` compiler flag is used, Visual C++
+uses 5~6 times as much memory when compiling a mock class.  We suggest
+to avoid `/clr` when compiling native C++ mocks.
+
+## I can't figure out why Google Mock thinks my expectations are not satisfied.  What should I do? ##
+
+You might want to run your test with
+`--gmock_verbose=info`.  This flag lets Google Mock print a trace
+of every mock function call it receives.  By studying the trace,
+you'll gain insights on why the expectations you set are not met.
+
+## How can I assert that a function is NEVER called? ##
+
+```
+EXPECT_CALL(foo, Bar(_))
+    .Times(0);
+```
+
+## I have a failed test where Google Mock tells me TWICE that a particular expectation is not satisfied.  Isn't this redundant? ##
+
+When Google Mock detects a failure, it prints relevant information
+(the mock function arguments, the state of relevant expectations, and
+etc) to help the user debug.  If another failure is detected, Google
+Mock will do the same, including printing the state of relevant
+expectations.
+
+Sometimes an expectation's state didn't change between two failures,
+and you'll see the same description of the state twice.  They are
+however _not_ redundant, as they refer to _different points in time_.
+The fact they are the same _is_ interesting information.
+
+## I get a heap check failure when using a mock object, but using a real object is fine.  What can be wrong? ##
+
+Does the class (hopefully a pure interface) you are mocking have a
+virtual destructor?
+
+Whenever you derive from a base class, make sure its destructor is
+virtual.  Otherwise Bad Things will happen.  Consider the following
+code:
+
+```
+class Base {
+ public:
+  // Not virtual, but should be.
+  ~Base() { ... }
+  ...
+};
+
+class Derived : public Base {
+ public:
+  ...
+ private:
+  std::string value_;
+};
+
+...
+  Base* p = new Derived;
+  ...
+  delete p;  // Surprise! ~Base() will be called, but ~Derived() will not
+             // - value_ is leaked.
+```
+
+By changing `~Base()` to virtual, `~Derived()` will be correctly
+called when `delete p` is executed, and the heap checker
+will be happy.
+
+## The "newer expectations override older ones" rule makes writing expectations awkward.  Why does Google Mock do that? ##
+
+When people complain about this, often they are referring to code like:
+
+```
+// foo.Bar() should be called twice, return 1 the first time, and return
+// 2 the second time.  However, I have to write the expectations in the
+// reverse order.  This sucks big time!!!
+EXPECT_CALL(foo, Bar())
+    .WillOnce(Return(2))
+    .RetiresOnSaturation();
+EXPECT_CALL(foo, Bar())
+    .WillOnce(Return(1))
+    .RetiresOnSaturation();
+```
+
+The problem is that they didn't pick the **best** way to express the test's
+intent.
+
+By default, expectations don't have to be matched in _any_ particular
+order.  If you want them to match in a certain order, you need to be
+explicit.  This is Google Mock's (and jMock's) fundamental philosophy: it's
+easy to accidentally over-specify your tests, and we want to make it
+harder to do so.
+
+There are two better ways to write the test spec.  You could either
+put the expectations in sequence:
+
+```
+// foo.Bar() should be called twice, return 1 the first time, and return
+// 2 the second time.  Using a sequence, we can write the expectations
+// in their natural order.
+{
+  InSequence s;
+  EXPECT_CALL(foo, Bar())
+      .WillOnce(Return(1))
+      .RetiresOnSaturation();
+  EXPECT_CALL(foo, Bar())
+      .WillOnce(Return(2))
+      .RetiresOnSaturation();
+}
+```
+
+or you can put the sequence of actions in the same expectation:
+
+```
+// foo.Bar() should be called twice, return 1 the first time, and return
+// 2 the second time.
+EXPECT_CALL(foo, Bar())
+    .WillOnce(Return(1))
+    .WillOnce(Return(2))
+    .RetiresOnSaturation();
+```
+
+Back to the original questions: why does Google Mock search the
+expectations (and `ON_CALL`s) from back to front?  Because this
+allows a user to set up a mock's behavior for the common case early
+(e.g. in the mock's constructor or the test fixture's set-up phase)
+and customize it with more specific rules later.  If Google Mock
+searches from front to back, this very useful pattern won't be
+possible.
+
+## Google Mock prints a warning when a function without EXPECT\_CALL is called, even if I have set its behavior using ON\_CALL.  Would it be reasonable not to show the warning in this case? ##
+
+When choosing between being neat and being safe, we lean toward the
+latter.  So the answer is that we think it's better to show the
+warning.
+
+Often people write `ON_CALL`s in the mock object's
+constructor or `SetUp()`, as the default behavior rarely changes from
+test to test.  Then in the test body they set the expectations, which
+are often different for each test.  Having an `ON_CALL` in the set-up
+part of a test doesn't mean that the calls are expected.  If there's
+no `EXPECT_CALL` and the method is called, it's possibly an error.  If
+we quietly let the call go through without notifying the user, bugs
+may creep in unnoticed.
+
+If, however, you are sure that the calls are OK, you can write
+
+```
+EXPECT_CALL(foo, Bar(_))
+    .WillRepeatedly(...);
+```
+
+instead of
+
+```
+ON_CALL(foo, Bar(_))
+    .WillByDefault(...);
+```
+
+This tells Google Mock that you do expect the calls and no warning should be
+printed.
+
+Also, you can control the verbosity using the `--gmock_verbose` flag.
+If you find the output too noisy when debugging, just choose a less
+verbose level.
+
+## How can I delete the mock function's argument in an action? ##
+
+If you find yourself needing to perform some action that's not
+supported by Google Mock directly, remember that you can define your own
+actions using
+[MakeAction()](V1_5_CookBook#Writing_New_Actions.md) or
+[MakePolymorphicAction()](V1_5_CookBook#Writing_New_Polymorphic_Actions.md),
+or you can write a stub function and invoke it using
+[Invoke()](V1_5_CookBook#Using_Functions_Methods_Functors.md).
+
+## MOCK\_METHODn()'s second argument looks funny.  Why don't you use the MOCK\_METHODn(Method, return\_type, arg\_1, ..., arg\_n) syntax? ##
+
+What?!  I think it's beautiful. :-)
+
+While which syntax looks more natural is a subjective matter to some
+extent, Google Mock's syntax was chosen for several practical advantages it
+has.
+
+Try to mock a function that takes a map as an argument:
+```
+virtual int GetSize(const map<int, std::string>& m);
+```
+
+Using the proposed syntax, it would be:
+```
+MOCK_METHOD1(GetSize, int, const map<int, std::string>& m);
+```
+
+Guess what?  You'll get a compiler error as the compiler thinks that
+`const map<int, std::string>& m` are **two**, not one, arguments. To work
+around this you can use `typedef` to give the map type a name, but
+that gets in the way of your work.  Google Mock's syntax avoids this
+problem as the function's argument types are protected inside a pair
+of parentheses:
+```
+// This compiles fine.
+MOCK_METHOD1(GetSize, int(const map<int, std::string>& m));
+```
+
+You still need a `typedef` if the return type contains an unprotected
+comma, but that's much rarer.
+
+Other advantages include:
+  1. `MOCK_METHOD1(Foo, int, bool)` can leave a reader wonder whether the method returns `int` or `bool`, while there won't be such confusion using Google Mock's syntax.
+  1. The way Google Mock describes a function type is nothing new, although many people may not be familiar with it.  The same syntax was used in C, and the `function` library in `tr1` uses this syntax extensively.  Since `tr1` will become a part of the new version of STL, we feel very comfortable to be consistent with it.
+  1. The function type syntax is also used in other parts of Google Mock's API (e.g. the action interface) in order to make the implementation tractable. A user needs to learn it anyway in order to utilize Google Mock's more advanced features.  We'd as well stick to the same syntax in `MOCK_METHOD*`!
+
+## My code calls a static/global function.  Can I mock it? ##
+
+You can, but you need to make some changes.
+
+In general, if you find yourself needing to mock a static function,
+it's a sign that your modules are too tightly coupled (and less
+flexible, less reusable, less testable, etc).  You are probably better
+off defining a small interface and call the function through that
+interface, which then can be easily mocked.  It's a bit of work
+initially, but usually pays for itself quickly.
+
+This Google Testing Blog
+[post](http://googletesting.blogspot.com/2008/06/defeat-static-cling.html)
+says it excellently.  Check it out.
+
+## My mock object needs to do complex stuff.  It's a lot of pain to specify the actions.  Google Mock sucks! ##
+
+I know it's not a question, but you get an answer for free any way. :-)
+
+With Google Mock, you can create mocks in C++ easily.  And people might be
+tempted to use them everywhere. Sometimes they work great, and
+sometimes you may find them, well, a pain to use. So, what's wrong in
+the latter case?
+
+When you write a test without using mocks, you exercise the code and
+assert that it returns the correct value or that the system is in an
+expected state.  This is sometimes called "state-based testing".
+
+Mocks are great for what some call "interaction-based" testing:
+instead of checking the system state at the very end, mock objects
+verify that they are invoked the right way and report an error as soon
+as it arises, giving you a handle on the precise context in which the
+error was triggered.  This is often more effective and economical to
+do than state-based testing.
+
+If you are doing state-based testing and using a test double just to
+simulate the real object, you are probably better off using a fake.
+Using a mock in this case causes pain, as it's not a strong point for
+mocks to perform complex actions.  If you experience this and think
+that mocks suck, you are just not using the right tool for your
+problem. Or, you might be trying to solve the wrong problem. :-)
+
+## I got a warning "Uninteresting function call encountered - default action taken.."  Should I panic? ##
+
+By all means, NO!  It's just an FYI.
+
+What it means is that you have a mock function, you haven't set any
+expectations on it (by Google Mock's rule this means that you are not
+interested in calls to this function and therefore it can be called
+any number of times), and it is called.  That's OK - you didn't say
+it's not OK to call the function!
+
+What if you actually meant to disallow this function to be called, but
+forgot to write `EXPECT_CALL(foo, Bar()).Times(0)`?  While
+one can argue that it's the user's fault, Google Mock tries to be nice and
+prints you a note.
+
+So, when you see the message and believe that there shouldn't be any
+uninteresting calls, you should investigate what's going on.  To make
+your life easier, Google Mock prints the function name and arguments
+when an uninteresting call is encountered.
+
+## I want to define a custom action.  Should I use Invoke() or implement the action interface? ##
+
+Either way is fine - you want to choose the one that's more convenient
+for your circumstance.
+
+Usually, if your action is for a particular function type, defining it
+using `Invoke()` should be easier; if your action can be used in
+functions of different types (e.g. if you are defining
+`Return(value)`), `MakePolymorphicAction()` is
+easiest.  Sometimes you want precise control on what types of
+functions the action can be used in, and implementing
+`ActionInterface` is the way to go here. See the implementation of
+`Return()` in `include/gmock/gmock-actions.h` for an example.
+
+## I'm using the set-argument-pointee action, and the compiler complains about "conflicting return type specified".  What does it mean? ##
+
+You got this error as Google Mock has no idea what value it should return
+when the mock method is called.  `SetArgumentPointee()` says what the
+side effect is, but doesn't say what the return value should be.  You
+need `DoAll()` to chain a `SetArgumentPointee()` with a `Return()`.
+
+See this [recipe](V1_5_CookBook#Mocking_Side_Effects.md) for more details and an example.
+
+
+## My question is not in your FAQ! ##
+
+If you cannot find the answer to your question in this FAQ, there are
+some other resources you can use:
+
+  1. read other [wiki pages](http://code.google.com/p/googlemock/w/list),
+  1. search the mailing list [archive](http://groups.google.com/group/googlemock/topics),
+  1. ask it on [googlemock@googlegroups.com](mailto:googlemock@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googlemock) before you can post.).
+
+Please note that creating an issue in the
+[issue tracker](http://code.google.com/p/googlemock/issues/list) is _not_
+a good way to get your answer, as it is monitored infrequently by a
+very small number of people.
+
+When asking a question, it's helpful to provide as much of the
+following information as possible (people cannot help you if there's
+not enough information in your question):
+
+  * the version (or the revision number if you check out from SVN directly) of Google Mock you use (Google Mock is under active development, so it's possible that your problem has been solved in a later version),
+  * your operating system,
+  * the name and version of your compiler,
+  * the complete command line flags you give to your compiler,
+  * the complete compiler error messages (if the question is about compilation),
+  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CheatSheet.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CheatSheet.md
new file mode 100644
index 00000000..91de1d21
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CheatSheet.md
@@ -0,0 +1,534 @@
+
+
+# Defining a Mock Class #
+
+## Mocking a Normal Class ##
+
+Given
+```
+class Foo {
+  ...
+  virtual ~Foo();
+  virtual int GetSize() const = 0;
+  virtual string Describe(const char* name) = 0;
+  virtual string Describe(int type) = 0;
+  virtual bool Process(Bar elem, int count) = 0;
+};
+```
+(note that `~Foo()` **must** be virtual) we can define its mock as
+```
+#include "gmock/gmock.h"
+
+class MockFoo : public Foo {
+  MOCK_CONST_METHOD0(GetSize, int());
+  MOCK_METHOD1(Describe, string(const char* name));
+  MOCK_METHOD1(Describe, string(int type));
+  MOCK_METHOD2(Process, bool(Bar elem, int count));
+};
+```
+
+To create a "nice" mock object which ignores all uninteresting calls,
+or a "strict" mock object, which treats them as failures:
+```
+NiceMock<MockFoo> nice_foo;     // The type is a subclass of MockFoo.
+StrictMock<MockFoo> strict_foo; // The type is a subclass of MockFoo.
+```
+
+## Mocking a Class Template ##
+
+To mock
+```
+template <typename Elem>
+class StackInterface {
+ public:
+  ...
+  virtual ~StackInterface();
+  virtual int GetSize() const = 0;
+  virtual void Push(const Elem& x) = 0;
+};
+```
+(note that `~StackInterface()` **must** be virtual) just append `_T` to the `MOCK_*` macros:
+```
+template <typename Elem>
+class MockStack : public StackInterface<Elem> {
+ public:
+  ...
+  MOCK_CONST_METHOD0_T(GetSize, int());
+  MOCK_METHOD1_T(Push, void(const Elem& x));
+};
+```
+
+## Specifying Calling Conventions for Mock Functions ##
+
+If your mock function doesn't use the default calling convention, you
+can specify it by appending `_WITH_CALLTYPE` to any of the macros
+described in the previous two sections and supplying the calling
+convention as the first argument to the macro. For example,
+```
+  MOCK_METHOD_1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int n));
+  MOCK_CONST_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, Bar, int(double x, double y));
+```
+where `STDMETHODCALLTYPE` is defined by `<objbase.h>` on Windows.
+
+# Using Mocks in Tests #
+
+The typical flow is:
+  1. Import the Google Mock names you need to use. All Google Mock names are in the `testing` namespace unless they are macros or otherwise noted.
+  1. Create the mock objects.
+  1. Optionally, set the default actions of the mock objects.
+  1. Set your expectations on the mock objects (How will they be called? What wil they do?).
+  1. Exercise code that uses the mock objects; if necessary, check the result using [Google Test](http://code.google.com/p/googletest/) assertions.
+  1. When a mock objects is destructed, Google Mock automatically verifies that all expectations on it have been satisfied.
+
+Here is an example:
+```
+using ::testing::Return;                            // #1
+
+TEST(BarTest, DoesThis) {
+  MockFoo foo;                                    // #2
+
+  ON_CALL(foo, GetSize())                         // #3
+      .WillByDefault(Return(1));
+  // ... other default actions ...
+
+  EXPECT_CALL(foo, Describe(5))                   // #4
+      .Times(3)
+      .WillRepeatedly(Return("Category 5"));
+  // ... other expectations ...
+
+  EXPECT_EQ("good", MyProductionFunction(&foo));  // #5
+}                                                 // #6
+```
+
+# Setting Default Actions #
+
+Google Mock has a **built-in default action** for any function that
+returns `void`, `bool`, a numeric value, or a pointer.
+
+To customize the default action for functions with return type `T` globally:
+```
+using ::testing::DefaultValue;
+
+DefaultValue<T>::Set(value);  // Sets the default value to be returned.
+// ... use the mocks ...
+DefaultValue<T>::Clear();     // Resets the default value.
+```
+
+To customize the default action for a particular method, use `ON_CALL()`:
+```
+ON_CALL(mock_object, method(matchers))
+    .With(multi_argument_matcher)  ?
+    .WillByDefault(action);
+```
+
+# Setting Expectations #
+
+`EXPECT_CALL()` sets **expectations** on a mock method (How will it be
+called? What will it do?):
+```
+EXPECT_CALL(mock_object, method(matchers))
+    .With(multi_argument_matcher)  ?
+    .Times(cardinality)            ?
+    .InSequence(sequences)         *
+    .After(expectations)           *
+    .WillOnce(action)              *
+    .WillRepeatedly(action)        ?
+    .RetiresOnSaturation();        ?
+```
+
+If `Times()` is omitted, the cardinality is assumed to be:
+
+  * `Times(1)` when there is neither `WillOnce()` nor `WillRepeatedly()`;
+  * `Times(n)` when there are `n WillOnce()`s but no `WillRepeatedly()`, where `n` >= 1; or
+  * `Times(AtLeast(n))` when there are `n WillOnce()`s and a `WillRepeatedly()`, where `n` >= 0.
+
+A method with no `EXPECT_CALL()` is free to be invoked _any number of times_, and the default action will be taken each time.
+
+# Matchers #
+
+A **matcher** matches a _single_ argument.  You can use it inside
+`ON_CALL()` or `EXPECT_CALL()`, or use it to validate a value
+directly:
+
+| `EXPECT_THAT(value, matcher)` | Asserts that `value` matches `matcher`. |
+|:------------------------------|:----------------------------------------|
+| `ASSERT_THAT(value, matcher)` | The same as `EXPECT_THAT(value, matcher)`, except that it generates a **fatal** failure. |
+
+Built-in matchers (where `argument` is the function argument) are
+divided into several categories:
+
+## Wildcard ##
+|`_`|`argument` can be any value of the correct type.|
+|:--|:-----------------------------------------------|
+|`A<type>()` or `An<type>()`|`argument` can be any value of type `type`.     |
+
+## Generic Comparison ##
+
+|`Eq(value)` or `value`|`argument == value`|
+|:---------------------|:------------------|
+|`Ge(value)`           |`argument >= value`|
+|`Gt(value)`           |`argument > value` |
+|`Le(value)`           |`argument <= value`|
+|`Lt(value)`           |`argument < value` |
+|`Ne(value)`           |`argument != value`|
+|`IsNull()`            |`argument` is a `NULL` pointer (raw or smart).|
+|`NotNull()`           |`argument` is a non-null pointer (raw or smart).|
+|`Ref(variable)`       |`argument` is a reference to `variable`.|
+|`TypedEq<type>(value)`|`argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded.|
+
+Except `Ref()`, these matchers make a _copy_ of `value` in case it's
+modified or destructed later. If the compiler complains that `value`
+doesn't have a public copy constructor, try wrap it in `ByRef()`,
+e.g. `Eq(ByRef(non_copyable_value))`. If you do that, make sure
+`non_copyable_value` is not changed afterwards, or the meaning of your
+matcher will be changed.
+
+## Floating-Point Matchers ##
+
+|`DoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as unequal.|
+|:-------------------|:----------------------------------------------------------------------------------------------|
+|`FloatEq(a_float)`  |`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal.  |
+|`NanSensitiveDoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal.  |
+|`NanSensitiveFloatEq(a_float)`|`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal.    |
+
+These matchers use ULP-based comparison (the same as used in
+[Google Test](http://code.google.com/p/googletest/)). They
+automatically pick a reasonable error bound based on the absolute
+value of the expected value.  `DoubleEq()` and `FloatEq()` conform to
+the IEEE standard, which requires comparing two NaNs for equality to
+return false. The `NanSensitive*` version instead treats two NaNs as
+equal, which is often what a user wants.
+
+## String Matchers ##
+
+The `argument` can be either a C string or a C++ string object:
+
+|`ContainsRegex(string)`|`argument` matches the given regular expression.|
+|:----------------------|:-----------------------------------------------|
+|`EndsWith(suffix)`     |`argument` ends with string `suffix`.           |
+|`HasSubstr(string)`    |`argument` contains `string` as a sub-string.   |
+|`MatchesRegex(string)` |`argument` matches the given regular expression with the match starting at the first character and ending at the last character.|
+|`StartsWith(prefix)`   |`argument` starts with string `prefix`.         |
+|`StrCaseEq(string)`    |`argument` is equal to `string`, ignoring case. |
+|`StrCaseNe(string)`    |`argument` is not equal to `string`, ignoring case.|
+|`StrEq(string)`        |`argument` is equal to `string`.                |
+|`StrNe(string)`        |`argument` is not equal to `string`.            |
+
+`ContainsRegex()` and `MatchesRegex()` use the regular expression
+syntax defined
+[here](http://code.google.com/p/googletest/wiki/V1_6_AdvancedGuide#Regular_Expression_Syntax).
+`StrCaseEq()`, `StrCaseNe()`, `StrEq()`, and `StrNe()` work for wide
+strings as well.
+
+## Container Matchers ##
+
+Most STL-style containers support `==`, so you can use
+`Eq(expected_container)` or simply `expected_container` to match a
+container exactly.   If you want to write the elements in-line,
+match them more flexibly, or get more informative messages, you can use:
+
+| `Contains(e)` | `argument` contains an element that matches `e`, which can be either a value or a matcher. |
+|:--------------|:-------------------------------------------------------------------------------------------|
+| `Each(e)`     | `argument` is a container where _every_ element matches `e`, which can be either a value or a matcher. |
+| `ElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, where the i-th element matches `ei`, which can be a value or a matcher. 0 to 10 arguments are allowed. |
+| `ElementsAreArray(array)` or `ElementsAreArray(array, count)` | The same as `ElementsAre()` except that the expected element values/matchers come from a C-style array. |
+| `ContainerEq(container)` | The same as `Eq(container)` except that the failure message also includes which elements are in one container but not the other. |
+| `Pointwise(m, container)` | `argument` contains the same number of elements as in `container`, and for all i, (the i-th element in `argument`, the i-th element in `container`) match `m`, which is a matcher on 2-tuples. E.g. `Pointwise(Le(), upper_bounds)` verifies that each element in `argument` doesn't exceed the corresponding element in `upper_bounds`. |
+
+These matchers can also match:
+
+  1. a native array passed by reference (e.g. in `Foo(const int (&a)[5])`), and
+  1. an array passed as a pointer and a count (e.g. in `Bar(const T* buffer, int len)` -- see [Multi-argument Matchers](#Multiargument_Matchers.md)).
+
+where the array may be multi-dimensional (i.e. its elements can be arrays).
+
+## Member Matchers ##
+
+|`Field(&class::field, m)`|`argument.field` (or `argument->field` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
+|:------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------|
+|`Key(e)`                 |`argument.first` matches `e`, which can be either a value or a matcher. E.g. `Contains(Key(Le(5)))` can verify that a `map` contains a key `<= 5`.|
+|`Pair(m1, m2)`           |`argument` is an `std::pair` whose `first` field matches `m1` and `second` field matches `m2`.                                                |
+|`Property(&class::property, m)`|`argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
+
+## Matching the Result of a Function or Functor ##
+
+|`ResultOf(f, m)`|`f(argument)` matches matcher `m`, where `f` is a function or functor.|
+|:---------------|:---------------------------------------------------------------------|
+
+## Pointer Matchers ##
+
+|`Pointee(m)`|`argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`.|
+|:-----------|:-----------------------------------------------------------------------------------------------|
+
+## Multiargument Matchers ##
+
+Technically, all matchers match a _single_ value. A "multi-argument"
+matcher is just one that matches a _tuple_. The following matchers can
+be used to match a tuple `(x, y)`:
+
+|`Eq()`|`x == y`|
+|:-----|:-------|
+|`Ge()`|`x >= y`|
+|`Gt()`|`x > y` |
+|`Le()`|`x <= y`|
+|`Lt()`|`x < y` |
+|`Ne()`|`x != y`|
+
+You can use the following selectors to pick a subset of the arguments
+(or reorder them) to participate in the matching:
+
+|`AllArgs(m)`|Equivalent to `m`. Useful as syntactic sugar in `.With(AllArgs(m))`.|
+|:-----------|:-------------------------------------------------------------------|
+|`Args<N1, N2, ..., Nk>(m)`|The tuple of the `k` selected (using 0-based indices) arguments matches `m`, e.g. `Args<1, 2>(Eq())`.|
+
+## Composite Matchers ##
+
+You can make a matcher from one or more other matchers:
+
+|`AllOf(m1, m2, ..., mn)`|`argument` matches all of the matchers `m1` to `mn`.|
+|:-----------------------|:---------------------------------------------------|
+|`AnyOf(m1, m2, ..., mn)`|`argument` matches at least one of the matchers `m1` to `mn`.|
+|`Not(m)`                |`argument` doesn't match matcher `m`.               |
+
+## Adapters for Matchers ##
+
+|`MatcherCast<T>(m)`|casts matcher `m` to type `Matcher<T>`.|
+|:------------------|:--------------------------------------|
+|`SafeMatcherCast<T>(m)`| [safely casts](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Casting_Matchers) matcher `m` to type `Matcher<T>`. |
+|`Truly(predicate)` |`predicate(argument)` returns something considered by C++ to be true, where `predicate` is a function or functor.|
+
+## Matchers as Predicates ##
+
+|`Matches(m)(value)`|evaluates to `true` if `value` matches `m`. You can use `Matches(m)` alone as a unary functor.|
+|:------------------|:---------------------------------------------------------------------------------------------|
+|`ExplainMatchResult(m, value, result_listener)`|evaluates to `true` if `value` matches `m`, explaining the result to `result_listener`.       |
+|`Value(value, m)`  |evaluates to `true` if `value` matches `m`.                                                   |
+
+## Defining Matchers ##
+
+| `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. |
+|:-------------------------------------------------|:------------------------------------------------------|
+| `MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; }` | Defines a macher `IsDivisibleBy(n)` to match a number divisible by `n`. |
+| `MATCHER_P2(IsBetween, a, b, std::string(negation ? "isn't" : "is") + " between " + PrintToString(a) + " and " + PrintToString(b)) { return a <= arg && arg <= b; }` | Defines a matcher `IsBetween(a, b)` to match a value in the range [`a`, `b`]. |
+
+**Notes:**
+
+  1. The `MATCHER*` macros cannot be used inside a function or class.
+  1. The matcher body must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters).
+  1. You can use `PrintToString(x)` to convert a value `x` of any type to a string.
+
+## Matchers as Test Assertions ##
+
+|`ASSERT_THAT(expression, m)`|Generates a [fatal failure](http://code.google.com/p/googletest/wiki/V1_6_Primer#Assertions) if the value of `expression` doesn't match matcher `m`.|
+|:---------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------|
+|`EXPECT_THAT(expression, m)`|Generates a non-fatal failure if the value of `expression` doesn't match matcher `m`.                                                               |
+
+# Actions #
+
+**Actions** specify what a mock function should do when invoked.
+
+## Returning a Value ##
+
+|`Return()`|Return from a `void` mock function.|
+|:---------|:----------------------------------|
+|`Return(value)`|Return `value`. If the type of `value` is different to the mock function's return type, `value` is converted to the latter type <i>at the time the expectation is set</i>, not when the action is executed.|
+|`ReturnArg<N>()`|Return the `N`-th (0-based) argument.|
+|`ReturnNew<T>(a1, ..., ak)`|Return `new T(a1, ..., ak)`; a different object is created each time.|
+|`ReturnNull()`|Return a null pointer.             |
+|`ReturnPointee(ptr)`|Return the value pointed to by `ptr`.|
+|`ReturnRef(variable)`|Return a reference to `variable`.  |
+|`ReturnRefOfCopy(value)`|Return a reference to a copy of `value`; the copy lives as long as the action.|
+
+## Side Effects ##
+
+|`Assign(&variable, value)`|Assign `value` to variable.|
+|:-------------------------|:--------------------------|
+| `DeleteArg<N>()`         | Delete the `N`-th (0-based) argument, which must be a pointer. |
+| `SaveArg<N>(pointer)`    | Save the `N`-th (0-based) argument to `*pointer`. |
+| `SaveArgPointee<N>(pointer)` | Save the value pointed to by the `N`-th (0-based) argument to `*pointer`. |
+| `SetArgReferee<N>(value)` |	Assign value to the variable referenced by the `N`-th (0-based) argument. |
+|`SetArgPointee<N>(value)` |Assign `value` to the variable pointed by the `N`-th (0-based) argument.|
+|`SetArgumentPointee<N>(value)`|Same as `SetArgPointee<N>(value)`. Deprecated. Will be removed in v1.7.0.|
+|`SetArrayArgument<N>(first, last)`|Copies the elements in source range [`first`, `last`) to the array pointed to by the `N`-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.|
+|`SetErrnoAndReturn(error, value)`|Set `errno` to `error` and return `value`.|
+|`Throw(exception)`        |Throws the given exception, which can be any copyable value. Available since v1.1.0.|
+
+## Using a Function or a Functor as an Action ##
+
+|`Invoke(f)`|Invoke `f` with the arguments passed to the mock function, where `f` can be a global/static function or a functor.|
+|:----------|:-----------------------------------------------------------------------------------------------------------------|
+|`Invoke(object_pointer, &class::method)`|Invoke the {method on the object with the arguments passed to the mock function.                                  |
+|`InvokeWithoutArgs(f)`|Invoke `f`, which can be a global/static function or a functor. `f` must take no arguments.                       |
+|`InvokeWithoutArgs(object_pointer, &class::method)`|Invoke the method on the object, which takes no arguments.                                                        |
+|`InvokeArgument<N>(arg1, arg2, ..., argk)`|Invoke the mock function's `N`-th (0-based) argument, which must be a function or a functor, with the `k` arguments.|
+
+The return value of the invoked function is used as the return value
+of the action.
+
+When defining a function or functor to be used with `Invoke*()`, you can declare any unused parameters as `Unused`:
+```
+  double Distance(Unused, double x, double y) { return sqrt(x*x + y*y); }
+  ...
+  EXPECT_CALL(mock, Foo("Hi", _, _)).WillOnce(Invoke(Distance));
+```
+
+In `InvokeArgument<N>(...)`, if an argument needs to be passed by reference, wrap it inside `ByRef()`. For example,
+```
+  InvokeArgument<2>(5, string("Hi"), ByRef(foo))
+```
+calls the mock function's #2 argument, passing to it `5` and `string("Hi")` by value, and `foo` by reference.
+
+## Default Action ##
+
+|`DoDefault()`|Do the default action (specified by `ON_CALL()` or the built-in one).|
+|:------------|:--------------------------------------------------------------------|
+
+**Note:** due to technical reasons, `DoDefault()` cannot be used inside  a composite action - trying to do so will result in a run-time error.
+
+## Composite Actions ##
+
+|`DoAll(a1, a2, ..., an)`|Do all actions `a1` to `an` and return the result of `an` in each invocation. The first `n - 1` sub-actions must return void. |
+|:-----------------------|:-----------------------------------------------------------------------------------------------------------------------------|
+|`IgnoreResult(a)`       |Perform action `a` and ignore its result. `a` must not return void.                                                           |
+|`WithArg<N>(a)`         |Pass the `N`-th (0-based) argument of the mock function to action `a` and perform it.                                         |
+|`WithArgs<N1, N2, ..., Nk>(a)`|Pass the selected (0-based) arguments of the mock function to action `a` and perform it.                                      |
+|`WithoutArgs(a)`        |Perform action `a` without any arguments.                                                                                     |
+
+## Defining Actions ##
+
+| `ACTION(Sum) { return arg0 + arg1; }` | Defines an action `Sum()` to return the sum of the mock function's argument #0 and #1. |
+|:--------------------------------------|:---------------------------------------------------------------------------------------|
+| `ACTION_P(Plus, n) { return arg0 + n; }` | Defines an action `Plus(n)` to return the sum of the mock function's argument #0 and `n`. |
+| `ACTION_Pk(Foo, p1, ..., pk) { statements; }` | Defines a parameterized action `Foo(p1, ..., pk)` to execute the given `statements`.   |
+
+The `ACTION*` macros cannot be used inside a function or class.
+
+# Cardinalities #
+
+These are used in `Times()` to specify how many times a mock function will be called:
+
+|`AnyNumber()`|The function can be called any number of times.|
+|:------------|:----------------------------------------------|
+|`AtLeast(n)` |The call is expected at least `n` times.       |
+|`AtMost(n)`  |The call is expected at most `n` times.        |
+|`Between(m, n)`|The call is expected between `m` and `n` (inclusive) times.|
+|`Exactly(n) or n`|The call is expected exactly `n` times. In particular, the call should never happen when `n` is 0.|
+
+# Expectation Order #
+
+By default, the expectations can be matched in _any_ order.  If some
+or all expectations must be matched in a given order, there are two
+ways to specify it.  They can be used either independently or
+together.
+
+## The After Clause ##
+
+```
+using ::testing::Expectation;
+...
+Expectation init_x = EXPECT_CALL(foo, InitX());
+Expectation init_y = EXPECT_CALL(foo, InitY());
+EXPECT_CALL(foo, Bar())
+    .After(init_x, init_y);
+```
+says that `Bar()` can be called only after both `InitX()` and
+`InitY()` have been called.
+
+If you don't know how many pre-requisites an expectation has when you
+write it, you can use an `ExpectationSet` to collect them:
+
+```
+using ::testing::ExpectationSet;
+...
+ExpectationSet all_inits;
+for (int i = 0; i < element_count; i++) {
+  all_inits += EXPECT_CALL(foo, InitElement(i));
+}
+EXPECT_CALL(foo, Bar())
+    .After(all_inits);
+```
+says that `Bar()` can be called only after all elements have been
+initialized (but we don't care about which elements get initialized
+before the others).
+
+Modifying an `ExpectationSet` after using it in an `.After()` doesn't
+affect the meaning of the `.After()`.
+
+## Sequences ##
+
+When you have a long chain of sequential expectations, it's easier to
+specify the order using **sequences**, which don't require you to given
+each expectation in the chain a different name.  <i>All expected<br>
+calls</i> in the same sequence must occur in the order they are
+specified.
+
+```
+using ::testing::Sequence;
+Sequence s1, s2;
+...
+EXPECT_CALL(foo, Reset())
+    .InSequence(s1, s2)
+    .WillOnce(Return(true));
+EXPECT_CALL(foo, GetSize())
+    .InSequence(s1)
+    .WillOnce(Return(1));
+EXPECT_CALL(foo, Describe(A<const char*>()))
+    .InSequence(s2)
+    .WillOnce(Return("dummy"));
+```
+says that `Reset()` must be called before _both_ `GetSize()` _and_
+`Describe()`, and the latter two can occur in any order.
+
+To put many expectations in a sequence conveniently:
+```
+using ::testing::InSequence;
+{
+  InSequence dummy;
+
+  EXPECT_CALL(...)...;
+  EXPECT_CALL(...)...;
+  ...
+  EXPECT_CALL(...)...;
+}
+```
+says that all expected calls in the scope of `dummy` must occur in
+strict order. The name `dummy` is irrelevant.)
+
+# Verifying and Resetting a Mock #
+
+Google Mock will verify the expectations on a mock object when it is destructed, or you can do it earlier:
+```
+using ::testing::Mock;
+...
+// Verifies and removes the expectations on mock_obj;
+// returns true iff successful.
+Mock::VerifyAndClearExpectations(&mock_obj);
+...
+// Verifies and removes the expectations on mock_obj;
+// also removes the default actions set by ON_CALL();
+// returns true iff successful.
+Mock::VerifyAndClear(&mock_obj);
+```
+
+You can also tell Google Mock that a mock object can be leaked and doesn't
+need to be verified:
+```
+Mock::AllowLeak(&mock_obj);
+```
+
+# Mock Classes #
+
+Google Mock defines a convenient mock class template
+```
+class MockFunction<R(A1, ..., An)> {
+ public:
+  MOCK_METHODn(Call, R(A1, ..., An));
+};
+```
+See this [recipe](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Using_Check_Points) for one application of it.
+
+# Flags #
+
+| `--gmock_catch_leaked_mocks=0` | Don't report leaked mock objects as failures. |
+|:-------------------------------|:----------------------------------------------|
+| `--gmock_verbose=LEVEL`        | Sets the default verbosity level (`info`, `warning`, or `error`) of Google Mock messages. |
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CookBook.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CookBook.md
new file mode 100644
index 00000000..f5975a00
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CookBook.md
@@ -0,0 +1,3342 @@
+
+
+You can find recipes for using Google Mock here. If you haven't yet,
+please read the [ForDummies](V1_6_ForDummies.md) document first to make sure you understand
+the basics.
+
+**Note:** Google Mock lives in the `testing` name space. For
+readability, it is recommended to write `using ::testing::Foo;` once in
+your file before using the name `Foo` defined by Google Mock. We omit
+such `using` statements in this page for brevity, but you should do it
+in your own code.
+
+# Creating Mock Classes #
+
+## Mocking Private or Protected Methods ##
+
+You must always put a mock method definition (`MOCK_METHOD*`) in a
+`public:` section of the mock class, regardless of the method being
+mocked being `public`, `protected`, or `private` in the base class.
+This allows `ON_CALL` and `EXPECT_CALL` to reference the mock function
+from outside of the mock class.  (Yes, C++ allows a subclass to change
+the access level of a virtual function in the base class.)  Example:
+
+```
+class Foo {
+ public:
+  ...
+  virtual bool Transform(Gadget* g) = 0;
+
+ protected:
+  virtual void Resume();
+
+ private:
+  virtual int GetTimeOut();
+};
+
+class MockFoo : public Foo {
+ public:
+  ...
+  MOCK_METHOD1(Transform, bool(Gadget* g));
+
+  // The following must be in the public section, even though the
+  // methods are protected or private in the base class.
+  MOCK_METHOD0(Resume, void());
+  MOCK_METHOD0(GetTimeOut, int());
+};
+```
+
+## Mocking Overloaded Methods ##
+
+You can mock overloaded functions as usual. No special attention is required:
+
+```
+class Foo {
+  ...
+
+  // Must be virtual as we'll inherit from Foo.
+  virtual ~Foo();
+
+  // Overloaded on the types and/or numbers of arguments.
+  virtual int Add(Element x);
+  virtual int Add(int times, Element x);
+
+  // Overloaded on the const-ness of this object.
+  virtual Bar& GetBar();
+  virtual const Bar& GetBar() const;
+};
+
+class MockFoo : public Foo {
+  ...
+  MOCK_METHOD1(Add, int(Element x));
+  MOCK_METHOD2(Add, int(int times, Element x);
+
+  MOCK_METHOD0(GetBar, Bar&());
+  MOCK_CONST_METHOD0(GetBar, const Bar&());
+};
+```
+
+**Note:** if you don't mock all versions of the overloaded method, the
+compiler will give you a warning about some methods in the base class
+being hidden. To fix that, use `using` to bring them in scope:
+
+```
+class MockFoo : public Foo {
+  ...
+  using Foo::Add;
+  MOCK_METHOD1(Add, int(Element x));
+  // We don't want to mock int Add(int times, Element x);
+  ...
+};
+```
+
+## Mocking Class Templates ##
+
+To mock a class template, append `_T` to the `MOCK_*` macros:
+
+```
+template <typename Elem>
+class StackInterface {
+  ...
+  // Must be virtual as we'll inherit from StackInterface.
+  virtual ~StackInterface();
+
+  virtual int GetSize() const = 0;
+  virtual void Push(const Elem& x) = 0;
+};
+
+template <typename Elem>
+class MockStack : public StackInterface<Elem> {
+  ...
+  MOCK_CONST_METHOD0_T(GetSize, int());
+  MOCK_METHOD1_T(Push, void(const Elem& x));
+};
+```
+
+## Mocking Nonvirtual Methods ##
+
+Google Mock can mock non-virtual functions to be used in what we call _hi-perf
+dependency injection_.
+
+In this case, instead of sharing a common base class with the real
+class, your mock class will be _unrelated_ to the real class, but
+contain methods with the same signatures.  The syntax for mocking
+non-virtual methods is the _same_ as mocking virtual methods:
+
+```
+// A simple packet stream class.  None of its members is virtual.
+class ConcretePacketStream {
+ public:
+  void AppendPacket(Packet* new_packet);
+  const Packet* GetPacket(size_t packet_number) const;
+  size_t NumberOfPackets() const;
+  ...
+};
+
+// A mock packet stream class.  It inherits from no other, but defines
+// GetPacket() and NumberOfPackets().
+class MockPacketStream {
+ public:
+  MOCK_CONST_METHOD1(GetPacket, const Packet*(size_t packet_number));
+  MOCK_CONST_METHOD0(NumberOfPackets, size_t());
+  ...
+};
+```
+
+Note that the mock class doesn't define `AppendPacket()`, unlike the
+real class. That's fine as long as the test doesn't need to call it.
+
+Next, you need a way to say that you want to use
+`ConcretePacketStream` in production code, and use `MockPacketStream`
+in tests.  Since the functions are not virtual and the two classes are
+unrelated, you must specify your choice at _compile time_ (as opposed
+to run time).
+
+One way to do it is to templatize your code that needs to use a packet
+stream.  More specifically, you will give your code a template type
+argument for the type of the packet stream.  In production, you will
+instantiate your template with `ConcretePacketStream` as the type
+argument.  In tests, you will instantiate the same template with
+`MockPacketStream`.  For example, you may write:
+
+```
+template <class PacketStream>
+void CreateConnection(PacketStream* stream) { ... }
+
+template <class PacketStream>
+class PacketReader {
+ public:
+  void ReadPackets(PacketStream* stream, size_t packet_num);
+};
+```
+
+Then you can use `CreateConnection<ConcretePacketStream>()` and
+`PacketReader<ConcretePacketStream>` in production code, and use
+`CreateConnection<MockPacketStream>()` and
+`PacketReader<MockPacketStream>` in tests.
+
+```
+  MockPacketStream mock_stream;
+  EXPECT_CALL(mock_stream, ...)...;
+  .. set more expectations on mock_stream ...
+  PacketReader<MockPacketStream> reader(&mock_stream);
+  ... exercise reader ...
+```
+
+## Mocking Free Functions ##
+
+It's possible to use Google Mock to mock a free function (i.e. a
+C-style function or a static method).  You just need to rewrite your
+code to use an interface (abstract class).
+
+Instead of calling a free function (say, `OpenFile`) directly,
+introduce an interface for it and have a concrete subclass that calls
+the free function:
+
+```
+class FileInterface {
+ public:
+  ...
+  virtual bool Open(const char* path, const char* mode) = 0;
+};
+
+class File : public FileInterface {
+ public:
+  ...
+  virtual bool Open(const char* path, const char* mode) {
+    return OpenFile(path, mode);
+  }
+};
+```
+
+Your code should talk to `FileInterface` to open a file.  Now it's
+easy to mock out the function.
+
+This may seem much hassle, but in practice you often have multiple
+related functions that you can put in the same interface, so the
+per-function syntactic overhead will be much lower.
+
+If you are concerned about the performance overhead incurred by
+virtual functions, and profiling confirms your concern, you can
+combine this with the recipe for [mocking non-virtual methods](#Mocking_Nonvirtual_Methods.md).
+
+## Nice Mocks and Strict Mocks ##
+
+If a mock method has no `EXPECT_CALL` spec but is called, Google Mock
+will print a warning about the "uninteresting call". The rationale is:
+
+  * New methods may be added to an interface after a test is written. We shouldn't fail a test just because a method it doesn't know about is called.
+  * However, this may also mean there's a bug in the test, so Google Mock shouldn't be silent either. If the user believes these calls are harmless, he can add an `EXPECT_CALL()` to suppress the warning.
+
+However, sometimes you may want to suppress all "uninteresting call"
+warnings, while sometimes you may want the opposite, i.e. to treat all
+of them as errors. Google Mock lets you make the decision on a
+per-mock-object basis.
+
+Suppose your test uses a mock class `MockFoo`:
+
+```
+TEST(...) {
+  MockFoo mock_foo;
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+}
+```
+
+If a method of `mock_foo` other than `DoThis()` is called, it will be
+reported by Google Mock as a warning. However, if you rewrite your
+test to use `NiceMock<MockFoo>` instead, the warning will be gone,
+resulting in a cleaner test output:
+
+```
+using ::testing::NiceMock;
+
+TEST(...) {
+  NiceMock<MockFoo> mock_foo;
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+}
+```
+
+`NiceMock<MockFoo>` is a subclass of `MockFoo`, so it can be used
+wherever `MockFoo` is accepted.
+
+It also works if `MockFoo`'s constructor takes some arguments, as
+`NiceMock<MockFoo>` "inherits" `MockFoo`'s constructors:
+
+```
+using ::testing::NiceMock;
+
+TEST(...) {
+  NiceMock<MockFoo> mock_foo(5, "hi");  // Calls MockFoo(5, "hi").
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+}
+```
+
+The usage of `StrictMock` is similar, except that it makes all
+uninteresting calls failures:
+
+```
+using ::testing::StrictMock;
+
+TEST(...) {
+  StrictMock<MockFoo> mock_foo;
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+
+  // The test will fail if a method of mock_foo other than DoThis()
+  // is called.
+}
+```
+
+There are some caveats though (I don't like them just as much as the
+next guy, but sadly they are side effects of C++'s limitations):
+
+  1. `NiceMock<MockFoo>` and `StrictMock<MockFoo>` only work 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` and `StrictMock` (e.g. `NiceMock<StrictMock<MockFoo> >`) is **not** supported.
+  1. The constructors of the base mock (`MockFoo`) cannot have arguments passed by non-const reference, which happens to be banned by the [Google C++ style guide](http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml).
+  1. During the constructor or destructor of `MockFoo`, the mock object is _not_ nice or strict.  This may cause surprises if the constructor or destructor calls a mock method on `this` object. (This behavior, however, is consistent with C++'s general rule: if a constructor or destructor calls a virtual method of `this` object, that method is treated as non-virtual.  In other words, to the base class's constructor or destructor, `this` object behaves like an instance of the base class, not the derived class.  This rule is required for safety.  Otherwise a base constructor may use members of a derived class before they are initialized, or a base destructor may use members of a derived class after they have been destroyed.)
+
+Finally, you should be **very cautious** when using this feature, as the
+decision you make applies to **all** future changes to the mock
+class. If an important change is made in the interface you are mocking
+(and thus in the mock class), it could break your tests (if you use
+`StrictMock`) or let bugs pass through without a warning (if you use
+`NiceMock`). Therefore, try to specify the mock's behavior using
+explicit `EXPECT_CALL` first, and only turn to `NiceMock` or
+`StrictMock` as the last resort.
+
+## Simplifying the Interface without Breaking Existing Code ##
+
+Sometimes a method has a long list of arguments that is mostly
+uninteresting. For example,
+
+```
+class LogSink {
+ public:
+  ...
+  virtual void send(LogSeverity severity, const char* full_filename,
+                    const char* base_filename, int line,
+                    const struct tm* tm_time,
+                    const char* message, size_t message_len) = 0;
+};
+```
+
+This method's argument list is lengthy and hard to work with (let's
+say that the `message` argument is not even 0-terminated). If we mock
+it as is, using the mock will be awkward. If, however, we try to
+simplify this interface, we'll need to fix all clients depending on
+it, which is often infeasible.
+
+The trick is to re-dispatch the method in the mock class:
+
+```
+class ScopedMockLog : public LogSink {
+ public:
+  ...
+  virtual void send(LogSeverity severity, const char* full_filename,
+                    const char* base_filename, int line, const tm* tm_time,
+                    const char* message, size_t message_len) {
+    // We are only interested in the log severity, full file name, and
+    // log message.
+    Log(severity, full_filename, std::string(message, message_len));
+  }
+
+  // Implements the mock method:
+  //
+  //   void Log(LogSeverity severity,
+  //            const string& file_path,
+  //            const string& message);
+  MOCK_METHOD3(Log, void(LogSeverity severity, const string& file_path,
+                         const string& message));
+};
+```
+
+By defining a new mock method with a trimmed argument list, we make
+the mock class much more user-friendly.
+
+## Alternative to Mocking Concrete Classes ##
+
+Often you may find yourself using classes that don't implement
+interfaces. In order to test your code that uses such a class (let's
+call it `Concrete`), you may be tempted to make the methods of
+`Concrete` virtual and then mock it.
+
+Try not to do that.
+
+Making a non-virtual function virtual is a big decision. It creates an
+extension point where subclasses can tweak your class' behavior. This
+weakens your control on the class because now it's harder to maintain
+the class' invariants. You should make a function virtual only when
+there is a valid reason for a subclass to override it.
+
+Mocking concrete classes directly is problematic as it creates a tight
+coupling between the class and the tests - any small change in the
+class may invalidate your tests and make test maintenance a pain.
+
+To avoid such problems, many programmers have been practicing "coding
+to interfaces": instead of talking to the `Concrete` class, your code
+would define an interface and talk to it. Then you implement that
+interface as an adaptor on top of `Concrete`. In tests, you can easily
+mock that interface to observe how your code is doing.
+
+This technique incurs some overhead:
+
+  * You pay the cost of virtual function calls (usually not a problem).
+  * There is more abstraction for the programmers to learn.
+
+However, it can also bring significant benefits in addition to better
+testability:
+
+  * `Concrete`'s API may not fit your problem domain very well, as you may not be the only client it tries to serve. By designing your own interface, you have a chance to tailor it to your need - you may add higher-level functionalities, rename stuff, etc instead of just trimming the class. This allows you to write your code (user of the interface) in a more natural way, which means it will be more readable, more maintainable, and you'll be more productive.
+  * If `Concrete`'s implementation ever has to change, you don't have to rewrite everywhere it is used. Instead, you can absorb the change in your implementation of the interface, and your other code and tests will be insulated from this change.
+
+Some people worry that if everyone is practicing this technique, they
+will end up writing lots of redundant code. This concern is totally
+understandable. However, there are two reasons why it may not be the
+case:
+
+  * Different projects may need to use `Concrete` in different ways, so the best interfaces for them will be different. Therefore, each of them will have its own domain-specific interface on top of `Concrete`, and they will not be the same code.
+  * If enough projects want to use the same interface, they can always share it, just like they have been sharing `Concrete`. You can check in the interface and the adaptor somewhere near `Concrete` (perhaps in a `contrib` sub-directory) and let many projects use it.
+
+You need to weigh the pros and cons carefully for your particular
+problem, but I'd like to assure you that the Java community has been
+practicing this for a long time and it's a proven effective technique
+applicable in a wide variety of situations. :-)
+
+## Delegating Calls to a Fake ##
+
+Some times you have a non-trivial fake implementation of an
+interface. For example:
+
+```
+class Foo {
+ public:
+  virtual ~Foo() {}
+  virtual char DoThis(int n) = 0;
+  virtual void DoThat(const char* s, int* p) = 0;
+};
+
+class FakeFoo : public Foo {
+ public:
+  virtual char DoThis(int n) {
+    return (n > 0) ? '+' :
+        (n < 0) ? '-' : '0';
+  }
+
+  virtual void DoThat(const char* s, int* p) {
+    *p = strlen(s);
+  }
+};
+```
+
+Now you want to mock this interface such that you can set expectations
+on it. However, you also want to use `FakeFoo` for the default
+behavior, as duplicating it in the mock object is, well, a lot of
+work.
+
+When you define the mock class using Google Mock, you can have it
+delegate its default action to a fake class you already have, using
+this pattern:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+class MockFoo : public Foo {
+ public:
+  // Normal mock method definitions using Google Mock.
+  MOCK_METHOD1(DoThis, char(int n));
+  MOCK_METHOD2(DoThat, void(const char* s, int* p));
+
+  // Delegates the default actions of the methods to a FakeFoo object.
+  // This must be called *before* the custom ON_CALL() statements.
+  void DelegateToFake() {
+    ON_CALL(*this, DoThis(_))
+        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThis));
+    ON_CALL(*this, DoThat(_, _))
+        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThat));
+  }
+ private:
+  FakeFoo fake_;  // Keeps an instance of the fake in the mock.
+};
+```
+
+With that, you can use `MockFoo` in your tests as usual. Just remember
+that if you don't explicitly set an action in an `ON_CALL()` or
+`EXPECT_CALL()`, the fake will be called upon to do it:
+
+```
+using ::testing::_;
+
+TEST(AbcTest, Xyz) {
+  MockFoo foo;
+  foo.DelegateToFake(); // Enables the fake for delegation.
+
+  // Put your ON_CALL(foo, ...)s here, if any.
+
+  // No action specified, meaning to use the default action.
+  EXPECT_CALL(foo, DoThis(5));
+  EXPECT_CALL(foo, DoThat(_, _));
+
+  int n = 0;
+  EXPECT_EQ('+', foo.DoThis(5));  // FakeFoo::DoThis() is invoked.
+  foo.DoThat("Hi", &n);           // FakeFoo::DoThat() is invoked.
+  EXPECT_EQ(2, n);
+}
+```
+
+**Some tips:**
+
+  * If you want, you can still override the default action by providing your own `ON_CALL()` or using `.WillOnce()` / `.WillRepeatedly()` in `EXPECT_CALL()`.
+  * In `DelegateToFake()`, you only need to delegate the methods whose fake implementation you intend to use.
+  * The general technique discussed here works for overloaded methods, but you'll need to tell the compiler which version you mean. To disambiguate a mock function (the one you specify inside the parentheses of `ON_CALL()`), see the "Selecting Between Overloaded Functions" section on this page; to disambiguate a fake function (the one you place inside `Invoke()`), use a `static_cast` to specify the function's type.
+  * Having to mix a mock and a fake is often a sign of something gone wrong. Perhaps you haven't got used to the interaction-based way of testing yet. Or perhaps your interface is taking on too many roles and should be split up. Therefore, **don't abuse this**. We would only recommend to do it as an intermediate step when you are refactoring your code.
+
+Regarding the tip on mixing a mock and a fake, here's an example on
+why it may be a bad sign: Suppose you have a class `System` for
+low-level system operations. In particular, it does file and I/O
+operations. And suppose you want to test how your code uses `System`
+to do I/O, and you just want the file operations to work normally. If
+you mock out the entire `System` class, you'll have to provide a fake
+implementation for the file operation part, which suggests that
+`System` is taking on too many roles.
+
+Instead, you can define a `FileOps` interface and an `IOOps` interface
+and split `System`'s functionalities into the two. Then you can mock
+`IOOps` without mocking `FileOps`.
+
+## Delegating Calls to a Real Object ##
+
+When using testing doubles (mocks, fakes, stubs, and etc), sometimes
+their behaviors will differ from those of the real objects. This
+difference could be either intentional (as in simulating an error such
+that you can test the error handling code) or unintentional. If your
+mocks have different behaviors than the real objects by mistake, you
+could end up with code that passes the tests but fails in production.
+
+You can use the _delegating-to-real_ technique to ensure that your
+mock has the same behavior as the real object while retaining the
+ability to validate calls. This technique is very similar to the
+delegating-to-fake technique, the difference being that we use a real
+object instead of a fake. Here's an example:
+
+```
+using ::testing::_;
+using ::testing::AtLeast;
+using ::testing::Invoke;
+
+class MockFoo : public Foo {
+ public:
+  MockFoo() {
+    // By default, all calls are delegated to the real object.
+    ON_CALL(*this, DoThis())
+        .WillByDefault(Invoke(&real_, &Foo::DoThis));
+    ON_CALL(*this, DoThat(_))
+        .WillByDefault(Invoke(&real_, &Foo::DoThat));
+    ...
+  }
+  MOCK_METHOD0(DoThis, ...);
+  MOCK_METHOD1(DoThat, ...);
+  ...
+ private:
+  Foo real_;
+};
+...
+
+  MockFoo mock;
+
+  EXPECT_CALL(mock, DoThis())
+      .Times(3);
+  EXPECT_CALL(mock, DoThat("Hi"))
+      .Times(AtLeast(1));
+  ... use mock in test ...
+```
+
+With this, Google Mock will verify that your code made the right calls
+(with the right arguments, in the right order, called the right number
+of times, etc), and a real object will answer the calls (so the
+behavior will be the same as in production). This gives you the best
+of both worlds.
+
+## Delegating Calls to a Parent Class ##
+
+Ideally, you should code to interfaces, whose methods are all pure
+virtual. In reality, sometimes you do need to mock a virtual method
+that is not pure (i.e, it already has an implementation). For example:
+
+```
+class Foo {
+ public:
+  virtual ~Foo();
+
+  virtual void Pure(int n) = 0;
+  virtual int Concrete(const char* str) { ... }
+};
+
+class MockFoo : public Foo {
+ public:
+  // Mocking a pure method.
+  MOCK_METHOD1(Pure, void(int n));
+  // Mocking a concrete method.  Foo::Concrete() is shadowed.
+  MOCK_METHOD1(Concrete, int(const char* str));
+};
+```
+
+Sometimes you may want to call `Foo::Concrete()` instead of
+`MockFoo::Concrete()`. Perhaps you want to do it as part of a stub
+action, or perhaps your test doesn't need to mock `Concrete()` at all
+(but it would be oh-so painful to have to define a new mock class
+whenever you don't need to mock one of its methods).
+
+The trick is to leave a back door in your mock class for accessing the
+real methods in the base class:
+
+```
+class MockFoo : public Foo {
+ public:
+  // Mocking a pure method.
+  MOCK_METHOD1(Pure, void(int n));
+  // Mocking a concrete method.  Foo::Concrete() is shadowed.
+  MOCK_METHOD1(Concrete, int(const char* str));
+
+  // Use this to call Concrete() defined in Foo.
+  int FooConcrete(const char* str) { return Foo::Concrete(str); }
+};
+```
+
+Now, you can call `Foo::Concrete()` inside an action by:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+...
+  EXPECT_CALL(foo, Concrete(_))
+      .WillOnce(Invoke(&foo, &MockFoo::FooConcrete));
+```
+
+or tell the mock object that you don't want to mock `Concrete()`:
+
+```
+using ::testing::Invoke;
+...
+  ON_CALL(foo, Concrete(_))
+      .WillByDefault(Invoke(&foo, &MockFoo::FooConcrete));
+```
+
+(Why don't we just write `Invoke(&foo, &Foo::Concrete)`? If you do
+that, `MockFoo::Concrete()` will be called (and cause an infinite
+recursion) since `Foo::Concrete()` is virtual. That's just how C++
+works.)
+
+# Using Matchers #
+
+## Matching Argument Values Exactly ##
+
+You can specify exactly which arguments a mock method is expecting:
+
+```
+using ::testing::Return;
+...
+  EXPECT_CALL(foo, DoThis(5))
+      .WillOnce(Return('a'));
+  EXPECT_CALL(foo, DoThat("Hello", bar));
+```
+
+## Using Simple Matchers ##
+
+You can use matchers to match arguments that have a certain property:
+
+```
+using ::testing::Ge;
+using ::testing::NotNull;
+using ::testing::Return;
+...
+  EXPECT_CALL(foo, DoThis(Ge(5)))  // The argument must be >= 5.
+      .WillOnce(Return('a'));
+  EXPECT_CALL(foo, DoThat("Hello", NotNull()));
+  // The second argument must not be NULL.
+```
+
+A frequently used matcher is `_`, which matches anything:
+
+```
+using ::testing::_;
+using ::testing::NotNull;
+...
+  EXPECT_CALL(foo, DoThat(_, NotNull()));
+```
+
+## Combining Matchers ##
+
+You can build complex matchers from existing ones using `AllOf()`,
+`AnyOf()`, and `Not()`:
+
+```
+using ::testing::AllOf;
+using ::testing::Gt;
+using ::testing::HasSubstr;
+using ::testing::Ne;
+using ::testing::Not;
+...
+  // The argument must be > 5 and != 10.
+  EXPECT_CALL(foo, DoThis(AllOf(Gt(5),
+                                Ne(10))));
+
+  // The first argument must not contain sub-string "blah".
+  EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")),
+                          NULL));
+```
+
+## Casting Matchers ##
+
+Google Mock matchers are statically typed, meaning that the compiler
+can catch your mistake if you use a matcher of the wrong type (for
+example, if you use `Eq(5)` to match a `string` argument). Good for
+you!
+
+Sometimes, however, you know what you're doing and want the compiler
+to give you some slack. One example is that you have a matcher for
+`long` and the argument you want to match is `int`. While the two
+types aren't exactly the same, there is nothing really wrong with
+using a `Matcher<long>` to match an `int` - after all, we can first
+convert the `int` argument to a `long` before giving it to the
+matcher.
+
+To support this need, Google Mock gives you the
+`SafeMatcherCast<T>(m)` function. It casts a matcher `m` to type
+`Matcher<T>`. To ensure safety, Google Mock checks that (let `U` be the
+type `m` accepts):
+
+  1. Type `T` can be implicitly cast to type `U`;
+  1. When both `T` and `U` are built-in arithmetic types (`bool`, integers, and floating-point numbers), the conversion from `T` to `U` is not lossy (in other words, any value representable by `T` can also be represented by `U`); and
+  1. When `U` is a reference, `T` must also be a reference (as the underlying matcher may be interested in the address of the `U` value).
+
+The code won't compile if any of these conditions isn't met.
+
+Here's one example:
+
+```
+using ::testing::SafeMatcherCast;
+
+// A base class and a child class.
+class Base { ... };
+class Derived : public Base { ... };
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(DoThis, void(Derived* derived));
+};
+...
+
+  MockFoo foo;
+  // m is a Matcher<Base*> we got from somewhere.
+  EXPECT_CALL(foo, DoThis(SafeMatcherCast<Derived*>(m)));
+```
+
+If you find `SafeMatcherCast<T>(m)` too limiting, you can use a similar
+function `MatcherCast<T>(m)`. The difference is that `MatcherCast` works
+as long as you can `static_cast` type `T` to type `U`.
+
+`MatcherCast` essentially lets you bypass C++'s type system
+(`static_cast` isn't always safe as it could throw away information,
+for example), so be careful not to misuse/abuse it.
+
+## Selecting Between Overloaded Functions ##
+
+If you expect an overloaded function to be called, the compiler may
+need some help on which overloaded version it is.
+
+To disambiguate functions overloaded on the const-ness of this object,
+use the `Const()` argument wrapper.
+
+```
+using ::testing::ReturnRef;
+
+class MockFoo : public Foo {
+  ...
+  MOCK_METHOD0(GetBar, Bar&());
+  MOCK_CONST_METHOD0(GetBar, const Bar&());
+};
+...
+
+  MockFoo foo;
+  Bar bar1, bar2;
+  EXPECT_CALL(foo, GetBar())         // The non-const GetBar().
+      .WillOnce(ReturnRef(bar1));
+  EXPECT_CALL(Const(foo), GetBar())  // The const GetBar().
+      .WillOnce(ReturnRef(bar2));
+```
+
+(`Const()` is defined by Google Mock and returns a `const` reference
+to its argument.)
+
+To disambiguate overloaded functions with the same number of arguments
+but different argument types, you may need to specify the exact type
+of a matcher, either by wrapping your matcher in `Matcher<type>()`, or
+using a matcher whose type is fixed (`TypedEq<type>`, `An<type>()`,
+etc):
+
+```
+using ::testing::An;
+using ::testing::Lt;
+using ::testing::Matcher;
+using ::testing::TypedEq;
+
+class MockPrinter : public Printer {
+ public:
+  MOCK_METHOD1(Print, void(int n));
+  MOCK_METHOD1(Print, void(char c));
+};
+
+TEST(PrinterTest, Print) {
+  MockPrinter printer;
+
+  EXPECT_CALL(printer, Print(An<int>()));            // void Print(int);
+  EXPECT_CALL(printer, Print(Matcher<int>(Lt(5))));  // void Print(int);
+  EXPECT_CALL(printer, Print(TypedEq<char>('a')));   // void Print(char);
+
+  printer.Print(3);
+  printer.Print(6);
+  printer.Print('a');
+}
+```
+
+## Performing Different Actions Based on the Arguments ##
+
+When a mock method is called, the _last_ matching expectation that's
+still active will be selected (think "newer overrides older"). So, you
+can make a method do different things depending on its argument values
+like this:
+
+```
+using ::testing::_;
+using ::testing::Lt;
+using ::testing::Return;
+...
+  // The default case.
+  EXPECT_CALL(foo, DoThis(_))
+      .WillRepeatedly(Return('b'));
+
+  // The more specific case.
+  EXPECT_CALL(foo, DoThis(Lt(5)))
+      .WillRepeatedly(Return('a'));
+```
+
+Now, if `foo.DoThis()` is called with a value less than 5, `'a'` will
+be returned; otherwise `'b'` will be returned.
+
+## Matching Multiple Arguments as a Whole ##
+
+Sometimes it's not enough to match the arguments individually. For
+example, we may want to say that the first argument must be less than
+the second argument. The `With()` clause allows us to match
+all arguments of a mock function as a whole. For example,
+
+```
+using ::testing::_;
+using ::testing::Lt;
+using ::testing::Ne;
+...
+  EXPECT_CALL(foo, InRange(Ne(0), _))
+      .With(Lt());
+```
+
+says that the first argument of `InRange()` must not be 0, and must be
+less than the second argument.
+
+The expression inside `With()` must be a matcher of type
+`Matcher<tr1::tuple<A1, ..., An> >`, where `A1`, ..., `An` are the
+types of the function arguments.
+
+You can also write `AllArgs(m)` instead of `m` inside `.With()`. The
+two forms are equivalent, but `.With(AllArgs(Lt()))` is more readable
+than `.With(Lt())`.
+
+You can use `Args<k1, ..., kn>(m)` to match the `n` selected arguments
+(as a tuple) against `m`. For example,
+
+```
+using ::testing::_;
+using ::testing::AllOf;
+using ::testing::Args;
+using ::testing::Lt;
+...
+  EXPECT_CALL(foo, Blah(_, _, _))
+      .With(AllOf(Args<0, 1>(Lt()), Args<1, 2>(Lt())));
+```
+
+says that `Blah()` will be called with arguments `x`, `y`, and `z` where
+`x < y < z`.
+
+As a convenience and example, Google Mock provides some matchers for
+2-tuples, including the `Lt()` matcher above. See the [CheatSheet](V1_6_CheatSheet.md) for
+the complete list.
+
+Note that if you want to pass the arguments to a predicate of your own
+(e.g. `.With(Args<0, 1>(Truly(&MyPredicate)))`), that predicate MUST be
+written to take a `tr1::tuple` as its argument; Google Mock will pass the `n`
+selected arguments as _one_ single tuple to the predicate.
+
+## Using Matchers as Predicates ##
+
+Have you noticed that a matcher is just a fancy predicate that also
+knows how to describe itself? Many existing algorithms take predicates
+as arguments (e.g. those defined in STL's `<algorithm>` header), and
+it would be a shame if Google Mock matchers are not allowed to
+participate.
+
+Luckily, you can use a matcher where a unary predicate functor is
+expected by wrapping it inside the `Matches()` function. For example,
+
+```
+#include <algorithm>
+#include <vector>
+
+std::vector<int> v;
+...
+// How many elements in v are >= 10?
+const int count = count_if(v.begin(), v.end(), Matches(Ge(10)));
+```
+
+Since you can build complex matchers from simpler ones easily using
+Google Mock, this gives you a way to conveniently construct composite
+predicates (doing the same using STL's `<functional>` header is just
+painful). For example, here's a predicate that's satisfied by any
+number that is >= 0, <= 100, and != 50:
+
+```
+Matches(AllOf(Ge(0), Le(100), Ne(50)))
+```
+
+## Using Matchers in Google Test Assertions ##
+
+Since matchers are basically predicates that also know how to describe
+themselves, there is a way to take advantage of them in
+[Google Test](http://code.google.com/p/googletest/) assertions. It's
+called `ASSERT_THAT` and `EXPECT_THAT`:
+
+```
+  ASSERT_THAT(value, matcher);  // Asserts that value matches matcher.
+  EXPECT_THAT(value, matcher);  // The non-fatal version.
+```
+
+For example, in a Google Test test you can write:
+
+```
+#include "gmock/gmock.h"
+
+using ::testing::AllOf;
+using ::testing::Ge;
+using ::testing::Le;
+using ::testing::MatchesRegex;
+using ::testing::StartsWith;
+...
+
+  EXPECT_THAT(Foo(), StartsWith("Hello"));
+  EXPECT_THAT(Bar(), MatchesRegex("Line \\d+"));
+  ASSERT_THAT(Baz(), AllOf(Ge(5), Le(10)));
+```
+
+which (as you can probably guess) executes `Foo()`, `Bar()`, and
+`Baz()`, and verifies that:
+
+  * `Foo()` returns a string that starts with `"Hello"`.
+  * `Bar()` returns a string that matches regular expression `"Line \\d+"`.
+  * `Baz()` returns a number in the range [5, 10].
+
+The nice thing about these macros is that _they read like
+English_. They generate informative messages too. For example, if the
+first `EXPECT_THAT()` above fails, the message will be something like:
+
+```
+Value of: Foo()
+  Actual: "Hi, world!"
+Expected: starts with "Hello"
+```
+
+**Credit:** The idea of `(ASSERT|EXPECT)_THAT` was stolen from the
+[Hamcrest](http://code.google.com/p/hamcrest/) project, which adds
+`assertThat()` to JUnit.
+
+## Using Predicates as Matchers ##
+
+Google Mock provides a built-in set of matchers. In case you find them
+lacking, you can use an arbitray unary predicate function or functor
+as a matcher - as long as the predicate accepts a value of the type
+you want. You do this by wrapping the predicate inside the `Truly()`
+function, for example:
+
+```
+using ::testing::Truly;
+
+int IsEven(int n) { return (n % 2) == 0 ? 1 : 0; }
+...
+
+  // Bar() must be called with an even number.
+  EXPECT_CALL(foo, Bar(Truly(IsEven)));
+```
+
+Note that the predicate function / functor doesn't have to return
+`bool`. It works as long as the return value can be used as the
+condition in statement `if (condition) ...`.
+
+## Matching Arguments that Are Not Copyable ##
+
+When you do an `EXPECT_CALL(mock_obj, Foo(bar))`, Google Mock saves
+away a copy of `bar`. When `Foo()` is called later, Google Mock
+compares the argument to `Foo()` with the saved copy of `bar`. This
+way, you don't need to worry about `bar` being modified or destroyed
+after the `EXPECT_CALL()` is executed. The same is true when you use
+matchers like `Eq(bar)`, `Le(bar)`, and so on.
+
+But what if `bar` cannot be copied (i.e. has no copy constructor)? You
+could define your own matcher function and use it with `Truly()`, as
+the previous couple of recipes have shown. Or, you may be able to get
+away from it if you can guarantee that `bar` won't be changed after
+the `EXPECT_CALL()` is executed. Just tell Google Mock that it should
+save a reference to `bar`, instead of a copy of it. Here's how:
+
+```
+using ::testing::Eq;
+using ::testing::ByRef;
+using ::testing::Lt;
+...
+  // Expects that Foo()'s argument == bar.
+  EXPECT_CALL(mock_obj, Foo(Eq(ByRef(bar))));
+
+  // Expects that Foo()'s argument < bar.
+  EXPECT_CALL(mock_obj, Foo(Lt(ByRef(bar))));
+```
+
+Remember: if you do this, don't change `bar` after the
+`EXPECT_CALL()`, or the result is undefined.
+
+## Validating a Member of an Object ##
+
+Often a mock function takes a reference to object as an argument. When
+matching the argument, you may not want to compare the entire object
+against a fixed object, as that may be over-specification. Instead,
+you may need to validate a certain member variable or the result of a
+certain getter method of the object. You can do this with `Field()`
+and `Property()`. More specifically,
+
+```
+Field(&Foo::bar, m)
+```
+
+is a matcher that matches a `Foo` object whose `bar` member variable
+satisfies matcher `m`.
+
+```
+Property(&Foo::baz, m)
+```
+
+is a matcher that matches a `Foo` object whose `baz()` method returns
+a value that satisfies matcher `m`.
+
+For example:
+
+> | `Field(&Foo::number, Ge(3))` | Matches `x` where `x.number >= 3`. |
+|:-----------------------------|:-----------------------------------|
+> | `Property(&Foo::name, StartsWith("John "))` | Matches `x` where `x.name()` starts with `"John "`. |
+
+Note that in `Property(&Foo::baz, ...)`, method `baz()` must take no
+argument and be declared as `const`.
+
+BTW, `Field()` and `Property()` can also match plain pointers to
+objects. For instance,
+
+```
+Field(&Foo::number, Ge(3))
+```
+
+matches a plain pointer `p` where `p->number >= 3`. If `p` is `NULL`,
+the match will always fail regardless of the inner matcher.
+
+What if you want to validate more than one members at the same time?
+Remember that there is `AllOf()`.
+
+## Validating the Value Pointed to by a Pointer Argument ##
+
+C++ functions often take pointers as arguments. You can use matchers
+like `NULL`, `NotNull()`, and other comparison matchers to match a
+pointer, but what if you want to make sure the value _pointed to_ by
+the pointer, instead of the pointer itself, has a certain property?
+Well, you can use the `Pointee(m)` matcher.
+
+`Pointee(m)` matches a pointer iff `m` matches the value the pointer
+points to. For example:
+
+```
+using ::testing::Ge;
+using ::testing::Pointee;
+...
+  EXPECT_CALL(foo, Bar(Pointee(Ge(3))));
+```
+
+expects `foo.Bar()` to be called with a pointer that points to a value
+greater than or equal to 3.
+
+One nice thing about `Pointee()` is that it treats a `NULL` pointer as
+a match failure, so you can write `Pointee(m)` instead of
+
+```
+  AllOf(NotNull(), Pointee(m))
+```
+
+without worrying that a `NULL` pointer will crash your test.
+
+Also, did we tell you that `Pointee()` works with both raw pointers
+**and** smart pointers (`linked_ptr`, `shared_ptr`, `scoped_ptr`, and
+etc)?
+
+What if you have a pointer to pointer? You guessed it - you can use
+nested `Pointee()` to probe deeper inside the value. For example,
+`Pointee(Pointee(Lt(3)))` matches a pointer that points to a pointer
+that points to a number less than 3 (what a mouthful...).
+
+## Testing a Certain Property of an Object ##
+
+Sometimes you want to specify that an object argument has a certain
+property, but there is no existing matcher that does this. If you want
+good error messages, you should define a matcher. If you want to do it
+quick and dirty, you could get away with writing an ordinary function.
+
+Let's say you have a mock function that takes an object of type `Foo`,
+which has an `int bar()` method and an `int baz()` method, and you
+want to constrain that the argument's `bar()` value plus its `baz()`
+value is a given number. Here's how you can define a matcher to do it:
+
+```
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+
+class BarPlusBazEqMatcher : public MatcherInterface<const Foo&> {
+ public:
+  explicit BarPlusBazEqMatcher(int expected_sum)
+      : expected_sum_(expected_sum) {}
+
+  virtual bool MatchAndExplain(const Foo& foo,
+                               MatchResultListener* listener) const {
+    return (foo.bar() + foo.baz()) == expected_sum_;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "bar() + baz() equals " << expected_sum_;
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "bar() + baz() does not equal " << expected_sum_;
+  }
+ private:
+  const int expected_sum_;
+};
+
+inline Matcher<const Foo&> BarPlusBazEq(int expected_sum) {
+  return MakeMatcher(new BarPlusBazEqMatcher(expected_sum));
+}
+
+...
+
+  EXPECT_CALL(..., DoThis(BarPlusBazEq(5)))...;
+```
+
+## Matching Containers ##
+
+Sometimes an STL container (e.g. list, vector, map, ...) is passed to
+a mock function and you may want to validate it. Since most STL
+containers support the `==` operator, you can write
+`Eq(expected_container)` or simply `expected_container` to match a
+container exactly.
+
+Sometimes, though, you may want to be more flexible (for example, the
+first element must be an exact match, but the second element can be
+any positive number, and so on). Also, containers used in tests often
+have a small number of elements, and having to define the expected
+container out-of-line is a bit of a hassle.
+
+You can use the `ElementsAre()` matcher in such cases:
+
+```
+using ::testing::_;
+using ::testing::ElementsAre;
+using ::testing::Gt;
+...
+
+  MOCK_METHOD1(Foo, void(const vector<int>& numbers));
+...
+
+  EXPECT_CALL(mock, Foo(ElementsAre(1, Gt(0), _, 5)));
+```
+
+The above matcher says that the container must have 4 elements, which
+must be 1, greater than 0, anything, and 5 respectively.
+
+`ElementsAre()` is overloaded to take 0 to 10 arguments. If more are
+needed, you can place them in a C-style array and use
+`ElementsAreArray()` instead:
+
+```
+using ::testing::ElementsAreArray;
+...
+
+  // ElementsAreArray accepts an array of element values.
+  const int expected_vector1[] = { 1, 5, 2, 4, ... };
+  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector1)));
+
+  // Or, an array of element matchers.
+  Matcher<int> expected_vector2 = { 1, Gt(2), _, 3, ... };
+  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector2)));
+```
+
+In case the array needs to be dynamically created (and therefore the
+array size cannot be inferred by the compiler), you can give
+`ElementsAreArray()` an additional argument to specify the array size:
+
+```
+using ::testing::ElementsAreArray;
+...
+  int* const expected_vector3 = new int[count];
+  ... fill expected_vector3 with values ...
+  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector3, count)));
+```
+
+**Tips:**
+
+  * `ElementAre*()` works with _any_ container that implements the STL iterator concept (i.e. it has a `const_iterator` type and supports `begin()/end()`) and supports `size()`, not just the ones defined in STL. It will even work with container types yet to be written - as long as they follows the above pattern.
+  * You can use nested `ElementAre*()` to match nested (multi-dimensional) containers.
+  * If the container is passed by pointer instead of by reference, just write `Pointee(ElementsAre*(...))`.
+  * The order of elements _matters_ for `ElementsAre*()`. Therefore don't use it with containers whose element order is undefined (e.g. `hash_map`).
+
+## Sharing Matchers ##
+
+Under the hood, a Google Mock matcher object consists of a pointer to
+a ref-counted implementation object. Copying matchers is allowed and
+very efficient, as only the pointer is copied. When the last matcher
+that references the implementation object dies, the implementation
+object will be deleted.
+
+Therefore, if you have some complex matcher that you want to use again
+and again, there is no need to build it everytime. Just assign it to a
+matcher variable and use that variable repeatedly! For example,
+
+```
+  Matcher<int> in_range = AllOf(Gt(5), Le(10));
+  ... use in_range as a matcher in multiple EXPECT_CALLs ...
+```
+
+# Setting Expectations #
+
+## Ignoring Uninteresting Calls ##
+
+If you are not interested in how a mock method is called, just don't
+say anything about it. In this case, if the method is ever called,
+Google Mock will perform its default action to allow the test program
+to continue. If you are not happy with the default action taken by
+Google Mock, you can override it using `DefaultValue<T>::Set()`
+(described later in this document) or `ON_CALL()`.
+
+Please note that once you expressed interest in a particular mock
+method (via `EXPECT_CALL()`), all invocations to it must match some
+expectation. If this function is called but the arguments don't match
+any `EXPECT_CALL()` statement, it will be an error.
+
+## Disallowing Unexpected Calls ##
+
+If a mock method shouldn't be called at all, explicitly say so:
+
+```
+using ::testing::_;
+...
+  EXPECT_CALL(foo, Bar(_))
+      .Times(0);
+```
+
+If some calls to the method are allowed, but the rest are not, just
+list all the expected calls:
+
+```
+using ::testing::AnyNumber;
+using ::testing::Gt;
+...
+  EXPECT_CALL(foo, Bar(5));
+  EXPECT_CALL(foo, Bar(Gt(10)))
+      .Times(AnyNumber());
+```
+
+A call to `foo.Bar()` that doesn't match any of the `EXPECT_CALL()`
+statements will be an error.
+
+## Expecting Ordered Calls ##
+
+Although an `EXPECT_CALL()` statement defined earlier takes precedence
+when Google Mock tries to match a function call with an expectation,
+by default calls don't have to happen in the order `EXPECT_CALL()`
+statements are written. For example, if the arguments match the
+matchers in the third `EXPECT_CALL()`, but not those in the first two,
+then the third expectation will be used.
+
+If you would rather have all calls occur in the order of the
+expectations, put the `EXPECT_CALL()` statements in a block where you
+define a variable of type `InSequence`:
+
+```
+  using ::testing::_;
+  using ::testing::InSequence;
+
+  {
+    InSequence s;
+
+    EXPECT_CALL(foo, DoThis(5));
+    EXPECT_CALL(bar, DoThat(_))
+        .Times(2);
+    EXPECT_CALL(foo, DoThis(6));
+  }
+```
+
+In this example, we expect a call to `foo.DoThis(5)`, followed by two
+calls to `bar.DoThat()` where the argument can be anything, which are
+in turn followed by a call to `foo.DoThis(6)`. If a call occurred
+out-of-order, Google Mock will report an error.
+
+## Expecting Partially Ordered Calls ##
+
+Sometimes requiring everything to occur in a predetermined order can
+lead to brittle tests. For example, we may care about `A` occurring
+before both `B` and `C`, but aren't interested in the relative order
+of `B` and `C`. In this case, the test should reflect our real intent,
+instead of being overly constraining.
+
+Google Mock allows you to impose an arbitrary DAG (directed acyclic
+graph) on the calls. One way to express the DAG is to use the
+[After](http://code.google.com/p/googlemock/wiki/V1_6_CheatSheet#The_After_Clause) clause of `EXPECT_CALL`.
+
+Another way is via the `InSequence()` clause (not the same as the
+`InSequence` class), which we borrowed from jMock 2. It's less
+flexible than `After()`, but more convenient when you have long chains
+of sequential calls, as it doesn't require you to come up with
+different names for the expectations in the chains.  Here's how it
+works:
+
+If we view `EXPECT_CALL()` statements as nodes in a graph, and add an
+edge from node A to node B wherever A must occur before B, we can get
+a DAG. We use the term "sequence" to mean a directed path in this
+DAG. Now, if we decompose the DAG into sequences, we just need to know
+which sequences each `EXPECT_CALL()` belongs to in order to be able to
+reconstruct the orginal DAG.
+
+So, to specify the partial order on the expectations we need to do two
+things: first to define some `Sequence` objects, and then for each
+`EXPECT_CALL()` say which `Sequence` objects it is part
+of. Expectations in the same sequence must occur in the order they are
+written. For example,
+
+```
+  using ::testing::Sequence;
+
+  Sequence s1, s2;
+
+  EXPECT_CALL(foo, A())
+      .InSequence(s1, s2);
+  EXPECT_CALL(bar, B())
+      .InSequence(s1);
+  EXPECT_CALL(bar, C())
+      .InSequence(s2);
+  EXPECT_CALL(foo, D())
+      .InSequence(s2);
+```
+
+specifies the following DAG (where `s1` is `A -> B`, and `s2` is `A ->
+C -> D`):
+
+```
+       +---> B
+       |
+  A ---|
+       |
+       +---> C ---> D
+```
+
+This means that A must occur before B and C, and C must occur before
+D. There's no restriction about the order other than these.
+
+## Controlling When an Expectation Retires ##
+
+When a mock method is called, Google Mock only consider expectations
+that are still active. An expectation is active when created, and
+becomes inactive (aka _retires_) when a call that has to occur later
+has occurred. For example, in
+
+```
+  using ::testing::_;
+  using ::testing::Sequence;
+
+  Sequence s1, s2;
+
+  EXPECT_CALL(log, Log(WARNING, _, "File too large."))     // #1
+      .Times(AnyNumber())
+      .InSequence(s1, s2);
+  EXPECT_CALL(log, Log(WARNING, _, "Data set is empty."))  // #2
+      .InSequence(s1);
+  EXPECT_CALL(log, Log(WARNING, _, "User not found."))     // #3
+      .InSequence(s2);
+```
+
+as soon as either #2 or #3 is matched, #1 will retire. If a warning
+`"File too large."` is logged after this, it will be an error.
+
+Note that an expectation doesn't retire automatically when it's
+saturated. For example,
+
+```
+using ::testing::_;
+...
+  EXPECT_CALL(log, Log(WARNING, _, _));                  // #1
+  EXPECT_CALL(log, Log(WARNING, _, "File too large."));  // #2
+```
+
+says that there will be exactly one warning with the message `"File
+too large."`. If the second warning contains this message too, #2 will
+match again and result in an upper-bound-violated error.
+
+If this is not what you want, you can ask an expectation to retire as
+soon as it becomes saturated:
+
+```
+using ::testing::_;
+...
+  EXPECT_CALL(log, Log(WARNING, _, _));                 // #1
+  EXPECT_CALL(log, Log(WARNING, _, "File too large."))  // #2
+      .RetiresOnSaturation();
+```
+
+Here #2 can be used only once, so if you have two warnings with the
+message `"File too large."`, the first will match #2 and the second
+will match #1 - there will be no error.
+
+# Using Actions #
+
+## Returning References from Mock Methods ##
+
+If a mock function's return type is a reference, you need to use
+`ReturnRef()` instead of `Return()` to return a result:
+
+```
+using ::testing::ReturnRef;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD0(GetBar, Bar&());
+};
+...
+
+  MockFoo foo;
+  Bar bar;
+  EXPECT_CALL(foo, GetBar())
+      .WillOnce(ReturnRef(bar));
+```
+
+## Returning Live Values from Mock Methods ##
+
+The `Return(x)` action saves a copy of `x` when the action is
+_created_, and always returns the same value whenever it's
+executed. Sometimes you may want to instead return the _live_ value of
+`x` (i.e. its value at the time when the action is _executed_.).
+
+If the mock function's return type is a reference, you can do it using
+`ReturnRef(x)`, as shown in the previous recipe ("Returning References
+from Mock Methods"). However, Google Mock doesn't let you use
+`ReturnRef()` in a mock function whose return type is not a reference,
+as doing that usually indicates a user error. So, what shall you do?
+
+You may be tempted to try `ByRef()`:
+
+```
+using testing::ByRef;
+using testing::Return;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD0(GetValue, int());
+};
+...
+  int x = 0;
+  MockFoo foo;
+  EXPECT_CALL(foo, GetValue())
+      .WillRepeatedly(Return(ByRef(x)));
+  x = 42;
+  EXPECT_EQ(42, foo.GetValue());
+```
+
+Unfortunately, it doesn't work here. The above code will fail with error:
+
+```
+Value of: foo.GetValue()
+  Actual: 0
+Expected: 42
+```
+
+The reason is that `Return(value)` converts `value` to the actual
+return type of the mock function at the time when the action is
+_created_, not when it is _executed_. (This behavior was chosen for
+the action to be safe when `value` is a proxy object that references
+some temporary objects.) As a result, `ByRef(x)` is converted to an
+`int` value (instead of a `const int&`) when the expectation is set,
+and `Return(ByRef(x))` will always return 0.
+
+`ReturnPointee(pointer)` was provided to solve this problem
+specifically. It returns the value pointed to by `pointer` at the time
+the action is _executed_:
+
+```
+using testing::ReturnPointee;
+...
+  int x = 0;
+  MockFoo foo;
+  EXPECT_CALL(foo, GetValue())
+      .WillRepeatedly(ReturnPointee(&x));  // Note the & here.
+  x = 42;
+  EXPECT_EQ(42, foo.GetValue());  // This will succeed now.
+```
+
+## Combining Actions ##
+
+Want to do more than one thing when a function is called? That's
+fine. `DoAll()` allow you to do sequence of actions every time. Only
+the return value of the last action in the sequence will be used.
+
+```
+using ::testing::DoAll;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(Bar, bool(int n));
+};
+...
+
+  EXPECT_CALL(foo, Bar(_))
+      .WillOnce(DoAll(action_1,
+                      action_2,
+                      ...
+                      action_n));
+```
+
+## Mocking Side Effects ##
+
+Sometimes a method exhibits its effect not via returning a value but
+via side effects. For example, it may change some global state or
+modify an output argument. To mock side effects, in general you can
+define your own action by implementing `::testing::ActionInterface`.
+
+If all you need to do is to change an output argument, the built-in
+`SetArgPointee()` action is convenient:
+
+```
+using ::testing::SetArgPointee;
+
+class MockMutator : public Mutator {
+ public:
+  MOCK_METHOD2(Mutate, void(bool mutate, int* value));
+  ...
+};
+...
+
+  MockMutator mutator;
+  EXPECT_CALL(mutator, Mutate(true, _))
+      .WillOnce(SetArgPointee<1>(5));
+```
+
+In this example, when `mutator.Mutate()` is called, we will assign 5
+to the `int` variable pointed to by argument #1
+(0-based).
+
+`SetArgPointee()` conveniently makes an internal copy of the
+value you pass to it, removing the need to keep the value in scope and
+alive. The implication however is that the value must have a copy
+constructor and assignment operator.
+
+If the mock method also needs to return a value as well, you can chain
+`SetArgPointee()` with `Return()` using `DoAll()`:
+
+```
+using ::testing::_;
+using ::testing::Return;
+using ::testing::SetArgPointee;
+
+class MockMutator : public Mutator {
+ public:
+  ...
+  MOCK_METHOD1(MutateInt, bool(int* value));
+};
+...
+
+  MockMutator mutator;
+  EXPECT_CALL(mutator, MutateInt(_))
+      .WillOnce(DoAll(SetArgPointee<0>(5),
+                      Return(true)));
+```
+
+If the output argument is an array, use the
+`SetArrayArgument<N>(first, last)` action instead. It copies the
+elements in source range `[first, last)` to the array pointed to by
+the `N`-th (0-based) argument:
+
+```
+using ::testing::NotNull;
+using ::testing::SetArrayArgument;
+
+class MockArrayMutator : public ArrayMutator {
+ public:
+  MOCK_METHOD2(Mutate, void(int* values, int num_values));
+  ...
+};
+...
+
+  MockArrayMutator mutator;
+  int values[5] = { 1, 2, 3, 4, 5 };
+  EXPECT_CALL(mutator, Mutate(NotNull(), 5))
+      .WillOnce(SetArrayArgument<0>(values, values + 5));
+```
+
+This also works when the argument is an output iterator:
+
+```
+using ::testing::_;
+using ::testing::SeArrayArgument;
+
+class MockRolodex : public Rolodex {
+ public:
+  MOCK_METHOD1(GetNames, void(std::back_insert_iterator<vector<string> >));
+  ...
+};
+...
+
+  MockRolodex rolodex;
+  vector<string> names;
+  names.push_back("George");
+  names.push_back("John");
+  names.push_back("Thomas");
+  EXPECT_CALL(rolodex, GetNames(_))
+      .WillOnce(SetArrayArgument<0>(names.begin(), names.end()));
+```
+
+## Changing a Mock Object's Behavior Based on the State ##
+
+If you expect a call to change the behavior of a mock object, you can use `::testing::InSequence` to specify different behaviors before and after the call:
+
+```
+using ::testing::InSequence;
+using ::testing::Return;
+
+...
+  {
+    InSequence seq;
+    EXPECT_CALL(my_mock, IsDirty())
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(my_mock, Flush());
+    EXPECT_CALL(my_mock, IsDirty())
+        .WillRepeatedly(Return(false));
+  }
+  my_mock.FlushIfDirty();
+```
+
+This makes `my_mock.IsDirty()` return `true` before `my_mock.Flush()` is called and return `false` afterwards.
+
+If the behavior change is more complex, you can store the effects in a variable and make a mock method get its return value from that variable:
+
+```
+using ::testing::_;
+using ::testing::SaveArg;
+using ::testing::Return;
+
+ACTION_P(ReturnPointee, p) { return *p; }
+...
+  int previous_value = 0;
+  EXPECT_CALL(my_mock, GetPrevValue())
+      .WillRepeatedly(ReturnPointee(&previous_value));
+  EXPECT_CALL(my_mock, UpdateValue(_))
+      .WillRepeatedly(SaveArg<0>(&previous_value));
+  my_mock.DoSomethingToUpdateValue();
+```
+
+Here `my_mock.GetPrevValue()` will always return the argument of the last `UpdateValue()` call.
+
+## Setting the Default Value for a Return Type ##
+
+If a mock method's return type is a built-in C++ type or pointer, by
+default it will return 0 when invoked. You only need to specify an
+action if this default value doesn't work for you.
+
+Sometimes, you may want to change this default value, or you may want
+to specify a default value for types Google Mock doesn't know
+about. You can do this using the `::testing::DefaultValue` class
+template:
+
+```
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD0(CalculateBar, Bar());
+};
+...
+
+  Bar default_bar;
+  // Sets the default return value for type Bar.
+  DefaultValue<Bar>::Set(default_bar);
+
+  MockFoo foo;
+
+  // We don't need to specify an action here, as the default
+  // return value works for us.
+  EXPECT_CALL(foo, CalculateBar());
+
+  foo.CalculateBar();  // This should return default_bar.
+
+  // Unsets the default return value.
+  DefaultValue<Bar>::Clear();
+```
+
+Please note that changing the default value for a type can make you
+tests hard to understand. We recommend you to use this feature
+judiciously. For example, you may want to make sure the `Set()` and
+`Clear()` calls are right next to the code that uses your mock.
+
+## Setting the Default Actions for a Mock Method ##
+
+You've learned how to change the default value of a given
+type. However, this may be too coarse for your purpose: perhaps you
+have two mock methods with the same return type and you want them to
+have different behaviors. The `ON_CALL()` macro allows you to
+customize your mock's behavior at the method level:
+
+```
+using ::testing::_;
+using ::testing::AnyNumber;
+using ::testing::Gt;
+using ::testing::Return;
+...
+  ON_CALL(foo, Sign(_))
+      .WillByDefault(Return(-1));
+  ON_CALL(foo, Sign(0))
+      .WillByDefault(Return(0));
+  ON_CALL(foo, Sign(Gt(0)))
+      .WillByDefault(Return(1));
+
+  EXPECT_CALL(foo, Sign(_))
+      .Times(AnyNumber());
+
+  foo.Sign(5);   // This should return 1.
+  foo.Sign(-9);  // This should return -1.
+  foo.Sign(0);   // This should return 0.
+```
+
+As you may have guessed, when there are more than one `ON_CALL()`
+statements, the news order take precedence over the older ones. In
+other words, the **last** one that matches the function arguments will
+be used. This matching order allows you to set up the common behavior
+in a mock object's constructor or the test fixture's set-up phase and
+specialize the mock's behavior later.
+
+## Using Functions/Methods/Functors as Actions ##
+
+If the built-in actions don't suit you, you can easily use an existing
+function, method, or functor as an action:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD2(Sum, int(int x, int y));
+  MOCK_METHOD1(ComplexJob, bool(int x));
+};
+
+int CalculateSum(int x, int y) { return x + y; }
+
+class Helper {
+ public:
+  bool ComplexJob(int x);
+};
+...
+
+  MockFoo foo;
+  Helper helper;
+  EXPECT_CALL(foo, Sum(_, _))
+      .WillOnce(Invoke(CalculateSum));
+  EXPECT_CALL(foo, ComplexJob(_))
+      .WillOnce(Invoke(&helper, &Helper::ComplexJob));
+
+  foo.Sum(5, 6);       // Invokes CalculateSum(5, 6).
+  foo.ComplexJob(10);  // Invokes helper.ComplexJob(10);
+```
+
+The only requirement is that the type of the function, etc must be
+_compatible_ with the signature of the mock function, meaning that the
+latter's arguments can be implicitly converted to the corresponding
+arguments of the former, and the former's return type can be
+implicitly converted to that of the latter. So, you can invoke
+something whose type is _not_ exactly the same as the mock function,
+as long as it's safe to do so - nice, huh?
+
+## Invoking a Function/Method/Functor Without Arguments ##
+
+`Invoke()` is very useful for doing actions that are more complex. It
+passes the mock function's arguments to the function or functor being
+invoked such that the callee has the full context of the call to work
+with. If the invoked function is not interested in some or all of the
+arguments, it can simply ignore them.
+
+Yet, a common pattern is that a test author wants to invoke a function
+without the arguments of the mock function. `Invoke()` allows her to
+do that using a wrapper function that throws away the arguments before
+invoking an underlining nullary function. Needless to say, this can be
+tedious and obscures the intent of the test.
+
+`InvokeWithoutArgs()` solves this problem. It's like `Invoke()` except
+that it doesn't pass the mock function's arguments to the
+callee. Here's an example:
+
+```
+using ::testing::_;
+using ::testing::InvokeWithoutArgs;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(ComplexJob, bool(int n));
+};
+
+bool Job1() { ... }
+...
+
+  MockFoo foo;
+  EXPECT_CALL(foo, ComplexJob(_))
+      .WillOnce(InvokeWithoutArgs(Job1));
+
+  foo.ComplexJob(10);  // Invokes Job1().
+```
+
+## Invoking an Argument of the Mock Function ##
+
+Sometimes a mock function will receive a function pointer or a functor
+(in other words, a "callable") as an argument, e.g.
+
+```
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD2(DoThis, bool(int n, bool (*fp)(int)));
+};
+```
+
+and you may want to invoke this callable argument:
+
+```
+using ::testing::_;
+...
+  MockFoo foo;
+  EXPECT_CALL(foo, DoThis(_, _))
+      .WillOnce(...);
+  // Will execute (*fp)(5), where fp is the
+  // second argument DoThis() receives.
+```
+
+Arghh, you need to refer to a mock function argument but C++ has no
+lambda (yet), so you have to define your own action. :-( Or do you
+really?
+
+Well, Google Mock has an action to solve _exactly_ this problem:
+
+```
+  InvokeArgument<N>(arg_1, arg_2, ..., arg_m)
+```
+
+will invoke the `N`-th (0-based) argument the mock function receives,
+with `arg_1`, `arg_2`, ..., and `arg_m`. No matter if the argument is
+a function pointer or a functor, Google Mock handles them both.
+
+With that, you could write:
+
+```
+using ::testing::_;
+using ::testing::InvokeArgument;
+...
+  EXPECT_CALL(foo, DoThis(_, _))
+      .WillOnce(InvokeArgument<1>(5));
+  // Will execute (*fp)(5), where fp is the
+  // second argument DoThis() receives.
+```
+
+What if the callable takes an argument by reference? No problem - just
+wrap it inside `ByRef()`:
+
+```
+...
+  MOCK_METHOD1(Bar, bool(bool (*fp)(int, const Helper&)));
+...
+using ::testing::_;
+using ::testing::ByRef;
+using ::testing::InvokeArgument;
+...
+
+  MockFoo foo;
+  Helper helper;
+  ...
+  EXPECT_CALL(foo, Bar(_))
+      .WillOnce(InvokeArgument<0>(5, ByRef(helper)));
+  // ByRef(helper) guarantees that a reference to helper, not a copy of it,
+  // will be passed to the callable.
+```
+
+What if the callable takes an argument by reference and we do **not**
+wrap the argument in `ByRef()`? Then `InvokeArgument()` will _make a
+copy_ of the argument, and pass a _reference to the copy_, instead of
+a reference to the original value, to the callable. This is especially
+handy when the argument is a temporary value:
+
+```
+...
+  MOCK_METHOD1(DoThat, bool(bool (*f)(const double& x, const string& s)));
+...
+using ::testing::_;
+using ::testing::InvokeArgument;
+...
+
+  MockFoo foo;
+  ...
+  EXPECT_CALL(foo, DoThat(_))
+      .WillOnce(InvokeArgument<0>(5.0, string("Hi")));
+  // Will execute (*f)(5.0, string("Hi")), where f is the function pointer
+  // DoThat() receives.  Note that the values 5.0 and string("Hi") are
+  // temporary and dead once the EXPECT_CALL() statement finishes.  Yet
+  // it's fine to perform this action later, since a copy of the values
+  // are kept inside the InvokeArgument action.
+```
+
+## Ignoring an Action's Result ##
+
+Sometimes you have an action that returns _something_, but you need an
+action that returns `void` (perhaps you want to use it in a mock
+function that returns `void`, or perhaps it needs to be used in
+`DoAll()` and it's not the last in the list). `IgnoreResult()` lets
+you do that. For example:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Return;
+
+int Process(const MyData& data);
+string DoSomething();
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(Abc, void(const MyData& data));
+  MOCK_METHOD0(Xyz, bool());
+};
+...
+
+  MockFoo foo;
+  EXPECT_CALL(foo, Abc(_))
+  // .WillOnce(Invoke(Process));
+  // The above line won't compile as Process() returns int but Abc() needs
+  // to return void.
+      .WillOnce(IgnoreResult(Invoke(Process)));
+
+  EXPECT_CALL(foo, Xyz())
+      .WillOnce(DoAll(IgnoreResult(Invoke(DoSomething)),
+      // Ignores the string DoSomething() returns.
+                      Return(true)));
+```
+
+Note that you **cannot** use `IgnoreResult()` on an action that already
+returns `void`. Doing so will lead to ugly compiler errors.
+
+## Selecting an Action's Arguments ##
+
+Say you have a mock function `Foo()` that takes seven arguments, and
+you have a custom action that you want to invoke when `Foo()` is
+called. Trouble is, the custom action only wants three arguments:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+...
+  MOCK_METHOD7(Foo, bool(bool visible, const string& name, int x, int y,
+                         const map<pair<int, int>, double>& weight,
+                         double min_weight, double max_wight));
+...
+
+bool IsVisibleInQuadrant1(bool visible, int x, int y) {
+  return visible && x >= 0 && y >= 0;
+}
+...
+
+  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
+      .WillOnce(Invoke(IsVisibleInQuadrant1));  // Uh, won't compile. :-(
+```
+
+To please the compiler God, you can to define an "adaptor" that has
+the same signature as `Foo()` and calls the custom action with the
+right arguments:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+bool MyIsVisibleInQuadrant1(bool visible, const string& name, int x, int y,
+                            const map<pair<int, int>, double>& weight,
+                            double min_weight, double max_wight) {
+  return IsVisibleInQuadrant1(visible, x, y);
+}
+...
+
+  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
+      .WillOnce(Invoke(MyIsVisibleInQuadrant1));  // Now it works.
+```
+
+But isn't this awkward?
+
+Google Mock provides a generic _action adaptor_, so you can spend your
+time minding more important business than writing your own
+adaptors. Here's the syntax:
+
+```
+  WithArgs<N1, N2, ..., Nk>(action)
+```
+
+creates an action that passes the arguments of the mock function at
+the given indices (0-based) to the inner `action` and performs
+it. Using `WithArgs`, our original example can be written as:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::WithArgs;
+...
+  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
+      .WillOnce(WithArgs<0, 2, 3>(Invoke(IsVisibleInQuadrant1)));
+      // No need to define your own adaptor.
+```
+
+For better readability, Google Mock also gives you:
+
+  * `WithoutArgs(action)` when the inner `action` takes _no_ argument, and
+  * `WithArg<N>(action)` (no `s` after `Arg`) when the inner `action` takes _one_ argument.
+
+As you may have realized, `InvokeWithoutArgs(...)` is just syntactic
+sugar for `WithoutArgs(Inovke(...))`.
+
+Here are more tips:
+
+  * The inner action used in `WithArgs` and friends does not have to be `Invoke()` -- it can be anything.
+  * You can repeat an argument in the argument list if necessary, e.g. `WithArgs<2, 3, 3, 5>(...)`.
+  * You can change the order of the arguments, e.g. `WithArgs<3, 2, 1>(...)`.
+  * The types of the selected arguments do _not_ have to match the signature of the inner action exactly. It works as long as they can be implicitly converted to the corresponding arguments of the inner action. For example, if the 4-th argument of the mock function is an `int` and `my_action` takes a `double`, `WithArg<4>(my_action)` will work.
+
+## Ignoring Arguments in Action Functions ##
+
+The selecting-an-action's-arguments recipe showed us one way to make a
+mock function and an action with incompatible argument lists fit
+together. The downside is that wrapping the action in
+`WithArgs<...>()` can get tedious for people writing the tests.
+
+If you are defining a function, method, or functor to be used with
+`Invoke*()`, and you are not interested in some of its arguments, an
+alternative to `WithArgs` is to declare the uninteresting arguments as
+`Unused`. This makes the definition less cluttered and less fragile in
+case the types of the uninteresting arguments change. It could also
+increase the chance the action function can be reused. For example,
+given
+
+```
+  MOCK_METHOD3(Foo, double(const string& label, double x, double y));
+  MOCK_METHOD3(Bar, double(int index, double x, double y));
+```
+
+instead of
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+double DistanceToOriginWithLabel(const string& label, double x, double y) {
+  return sqrt(x*x + y*y);
+}
+
+double DistanceToOriginWithIndex(int index, double x, double y) {
+  return sqrt(x*x + y*y);
+}
+...
+
+  EXEPCT_CALL(mock, Foo("abc", _, _))
+      .WillOnce(Invoke(DistanceToOriginWithLabel));
+  EXEPCT_CALL(mock, Bar(5, _, _))
+      .WillOnce(Invoke(DistanceToOriginWithIndex));
+```
+
+you could write
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Unused;
+
+double DistanceToOrigin(Unused, double x, double y) {
+  return sqrt(x*x + y*y);
+}
+...
+
+  EXEPCT_CALL(mock, Foo("abc", _, _))
+      .WillOnce(Invoke(DistanceToOrigin));
+  EXEPCT_CALL(mock, Bar(5, _, _))
+      .WillOnce(Invoke(DistanceToOrigin));
+```
+
+## Sharing Actions ##
+
+Just like matchers, a Google Mock action object consists of a pointer
+to a ref-counted implementation object. Therefore copying actions is
+also allowed and very efficient. When the last action that references
+the implementation object dies, the implementation object will be
+deleted.
+
+If you have some complex action that you want to use again and again,
+you may not have to build it from scratch everytime. If the action
+doesn't have an internal state (i.e. if it always does the same thing
+no matter how many times it has been called), you can assign it to an
+action variable and use that variable repeatedly. For example:
+
+```
+  Action<bool(int*)> set_flag = DoAll(SetArgPointee<0>(5),
+                                      Return(true));
+  ... use set_flag in .WillOnce() and .WillRepeatedly() ...
+```
+
+However, if the action has its own state, you may be surprised if you
+share the action object. Suppose you have an action factory
+`IncrementCounter(init)` which creates an action that increments and
+returns a counter whose initial value is `init`, using two actions
+created from the same expression and using a shared action will
+exihibit different behaviors. Example:
+
+```
+  EXPECT_CALL(foo, DoThis())
+      .WillRepeatedly(IncrementCounter(0));
+  EXPECT_CALL(foo, DoThat())
+      .WillRepeatedly(IncrementCounter(0));
+  foo.DoThis();  // Returns 1.
+  foo.DoThis();  // Returns 2.
+  foo.DoThat();  // Returns 1 - Blah() uses a different
+                 // counter than Bar()'s.
+```
+
+versus
+
+```
+  Action<int()> increment = IncrementCounter(0);
+
+  EXPECT_CALL(foo, DoThis())
+      .WillRepeatedly(increment);
+  EXPECT_CALL(foo, DoThat())
+      .WillRepeatedly(increment);
+  foo.DoThis();  // Returns 1.
+  foo.DoThis();  // Returns 2.
+  foo.DoThat();  // Returns 3 - the counter is shared.
+```
+
+# Misc Recipes on Using Google Mock #
+
+## Making the Compilation Faster ##
+
+Believe it or not, the _vast majority_ of the time spent on compiling
+a mock class is in generating its constructor and destructor, as they
+perform non-trivial tasks (e.g. verification of the
+expectations). What's more, mock methods with different signatures
+have different types and thus their constructors/destructors need to
+be generated by the compiler separately. As a result, if you mock many
+different types of methods, compiling your mock class can get really
+slow.
+
+If you are experiencing slow compilation, you can move the definition
+of your mock class' constructor and destructor out of the class body
+and into a `.cpp` file. This way, even if you `#include` your mock
+class in N files, the compiler only needs to generate its constructor
+and destructor once, resulting in a much faster compilation.
+
+Let's illustrate the idea using an example. Here's the definition of a
+mock class before applying this recipe:
+
+```
+// File mock_foo.h.
+...
+class MockFoo : public Foo {
+ public:
+  // Since we don't declare the constructor or the destructor,
+  // the compiler will generate them in every translation unit
+  // where this mock class is used.
+
+  MOCK_METHOD0(DoThis, int());
+  MOCK_METHOD1(DoThat, bool(const char* str));
+  ... more mock methods ...
+};
+```
+
+After the change, it would look like:
+
+```
+// File mock_foo.h.
+...
+class MockFoo : public Foo {
+ public:
+  // The constructor and destructor are declared, but not defined, here.
+  MockFoo();
+  virtual ~MockFoo();
+
+  MOCK_METHOD0(DoThis, int());
+  MOCK_METHOD1(DoThat, bool(const char* str));
+  ... more mock methods ...
+};
+```
+and
+```
+// File mock_foo.cpp.
+#include "path/to/mock_foo.h"
+
+// The definitions may appear trivial, but the functions actually do a
+// lot of things through the constructors/destructors of the member
+// variables used to implement the mock methods.
+MockFoo::MockFoo() {}
+MockFoo::~MockFoo() {}
+```
+
+## Forcing a Verification ##
+
+When it's being destoyed, your friendly mock object will automatically
+verify that all expectations on it have been satisfied, and will
+generate [Google Test](http://code.google.com/p/googletest/) failures
+if not. This is convenient as it leaves you with one less thing to
+worry about. That is, unless you are not sure if your mock object will
+be destoyed.
+
+How could it be that your mock object won't eventually be destroyed?
+Well, it might be created on the heap and owned by the code you are
+testing. Suppose there's a bug in that code and it doesn't delete the
+mock object properly - you could end up with a passing test when
+there's actually a bug.
+
+Using a heap checker is a good idea and can alleviate the concern, but
+its implementation may not be 100% reliable. So, sometimes you do want
+to _force_ Google Mock to verify a mock object before it is
+(hopefully) destructed. You can do this with
+`Mock::VerifyAndClearExpectations(&mock_object)`:
+
+```
+TEST(MyServerTest, ProcessesRequest) {
+  using ::testing::Mock;
+
+  MockFoo* const foo = new MockFoo;
+  EXPECT_CALL(*foo, ...)...;
+  // ... other expectations ...
+
+  // server now owns foo.
+  MyServer server(foo);
+  server.ProcessRequest(...);
+
+  // In case that server's destructor will forget to delete foo,
+  // this will verify the expectations anyway.
+  Mock::VerifyAndClearExpectations(foo);
+}  // server is destroyed when it goes out of scope here.
+```
+
+**Tip:** The `Mock::VerifyAndClearExpectations()` function returns a
+`bool` to indicate whether the verification was successful (`true` for
+yes), so you can wrap that function call inside a `ASSERT_TRUE()` if
+there is no point going further when the verification has failed.
+
+## Using Check Points ##
+
+Sometimes you may want to "reset" a mock object at various check
+points in your test: at each check point, you verify that all existing
+expectations on the mock object have been satisfied, and then you set
+some new expectations on it as if it's newly created. This allows you
+to work with a mock object in "phases" whose sizes are each
+manageable.
+
+One such scenario is that in your test's `SetUp()` function, you may
+want to put the object you are testing into a certain state, with the
+help from a mock object. Once in the desired state, you want to clear
+all expectations on the mock, such that in the `TEST_F` body you can
+set fresh expectations on it.
+
+As you may have figured out, the `Mock::VerifyAndClearExpectations()`
+function we saw in the previous recipe can help you here. Or, if you
+are using `ON_CALL()` to set default actions on the mock object and
+want to clear the default actions as well, use
+`Mock::VerifyAndClear(&mock_object)` instead. This function does what
+`Mock::VerifyAndClearExpectations(&mock_object)` does and returns the
+same `bool`, **plus** it clears the `ON_CALL()` statements on
+`mock_object` too.
+
+Another trick you can use to achieve the same effect is to put the
+expectations in sequences and insert calls to a dummy "check-point"
+function at specific places. Then you can verify that the mock
+function calls do happen at the right time. 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:
+
+```
+using ::testing::MockFunction;
+
+TEST(FooTest, InvokesBarCorrectly) {
+  MyMock mock;
+  // Class MockFunction<F> has exactly one mock method.  It is named
+  // Call() and has type F.
+  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()`.
+
+## Mocking Destructors ##
+
+Sometimes you want to make sure a mock object is destructed at the
+right time, e.g. after `bar->A()` is called but before `bar->B()` is
+called. We already know that you can specify constraints on the order
+of mock function calls, so all we need to do is to mock the destructor
+of the mock function.
+
+This sounds simple, except for one problem: a destructor is a special
+function with special syntax and special semantics, and the
+`MOCK_METHOD0` macro doesn't work for it:
+
+```
+  MOCK_METHOD0(~MockFoo, void());  // Won't compile!
+```
+
+The good news is that you can use a simple pattern to achieve the same
+effect. First, add a mock function `Die()` to your mock class and call
+it in the destructor, like this:
+
+```
+class MockFoo : public Foo {
+  ...
+  // Add the following two lines to the mock class.
+  MOCK_METHOD0(Die, void());
+  virtual ~MockFoo() { Die(); }
+};
+```
+
+(If the name `Die()` clashes with an existing symbol, choose another
+name.) Now, we have translated the problem of testing when a `MockFoo`
+object dies to testing when its `Die()` method is called:
+
+```
+  MockFoo* foo = new MockFoo;
+  MockBar* bar = new MockBar;
+  ...
+  {
+    InSequence s;
+
+    // Expects *foo to die after bar->A() and before bar->B().
+    EXPECT_CALL(*bar, A());
+    EXPECT_CALL(*foo, Die());
+    EXPECT_CALL(*bar, B());
+  }
+```
+
+And that's that.
+
+## Using Google Mock and Threads ##
+
+**IMPORTANT NOTE:** What we describe in this recipe is **ONLY** true on
+platforms where Google Mock is thread-safe. Currently these are only
+platforms that support the pthreads library (this includes Linux and Mac).
+To make it thread-safe on other platforms we only need to implement
+some synchronization operations in `"gtest/internal/gtest-port.h"`.
+
+In a **unit** test, it's best if you could isolate and test a piece of
+code in a single-threaded context. That avoids race conditions and
+dead locks, and makes debugging your test much easier.
+
+Yet many programs are multi-threaded, and sometimes to test something
+we need to pound on it from more than one thread. Google Mock works
+for this purpose too.
+
+Remember the steps for using a mock:
+
+  1. Create a mock object `foo`.
+  1. Set its default actions and expectations using `ON_CALL()` and `EXPECT_CALL()`.
+  1. The code under test calls methods of `foo`.
+  1. Optionally, verify and reset the mock.
+  1. Destroy the mock yourself, or let the code under test destroy it. The destructor will automatically verify it.
+
+If you follow the following simple rules, your mocks and threads can
+live happily togeter:
+
+  * Execute your _test code_ (as opposed to the code being tested) in _one_ thread. This makes your test easy to follow.
+  * Obviously, you can do step #1 without locking.
+  * When doing step #2 and #5, make sure no other thread is accessing `foo`. Obvious too, huh?
+  * #3 and #4 can be done either in one thread or in multiple threads - anyway you want. Google Mock takes care of the locking, so you don't have to do any - unless required by your test logic.
+
+If you violate the rules (for example, if you set expectations on a
+mock while another thread is calling its methods), you get undefined
+behavior. That's not fun, so don't do it.
+
+Google Mock guarantees that the action for a mock function is done in
+the same thread that called the mock function. For example, in
+
+```
+  EXPECT_CALL(mock, Foo(1))
+      .WillOnce(action1);
+  EXPECT_CALL(mock, Foo(2))
+      .WillOnce(action2);
+```
+
+if `Foo(1)` is called in thread 1 and `Foo(2)` is called in thread 2,
+Google Mock will execute `action1` in thread 1 and `action2` in thread
+2.
+
+Google Mock does _not_ impose a sequence on actions performed in
+different threads (doing so may create deadlocks as the actions may
+need to cooperate). This means that the execution of `action1` and
+`action2` in the above example _may_ interleave. If this is a problem,
+you should add proper synchronization logic to `action1` and `action2`
+to make the test thread-safe.
+
+
+Also, remember that `DefaultValue<T>` is a global resource that
+potentially affects _all_ living mock objects in your
+program. Naturally, you won't want to mess with it from multiple
+threads or when there still are mocks in action.
+
+## Controlling How Much Information Google Mock Prints ##
+
+When Google Mock sees something that has the potential of being an
+error (e.g. a mock function with no expectation is called, a.k.a. an
+uninteresting call, which is allowed but perhaps you forgot to
+explicitly ban the call), it prints some warning messages, including
+the arguments of the function and the return value. Hopefully this
+will remind you to take a look and see if there is indeed a problem.
+
+Sometimes you are confident that your tests are correct and may not
+appreciate such friendly messages. Some other times, you are debugging
+your tests or learning about the behavior of the code you are testing,
+and wish you could observe every mock call that happens (including
+argument values and the return value). Clearly, one size doesn't fit
+all.
+
+You can control how much Google Mock tells you using the
+`--gmock_verbose=LEVEL` command-line flag, where `LEVEL` is a string
+with three possible values:
+
+  * `info`: Google Mock will print all informational messages, warnings, and errors (most verbose). At this setting, Google Mock will also log any calls to the `ON_CALL/EXPECT_CALL` macros.
+  * `warning`: Google Mock will print both warnings and errors (less verbose). This is the default.
+  * `error`: Google Mock will print errors only (least verbose).
+
+Alternatively, you can adjust the value of that flag from within your
+tests like so:
+
+```
+  ::testing::FLAGS_gmock_verbose = "error";
+```
+
+Now, judiciously use the right flag to enable Google Mock serve you better!
+
+## Running Tests in Emacs ##
+
+If you build and run your tests in Emacs, the source file locations of
+Google Mock and [Google Test](http://code.google.com/p/googletest/)
+errors will be highlighted. Just press `<Enter>` on one of them and
+you'll be taken to the offending line. Or, you can just type `C-x ``
+to jump to the next error.
+
+To make it even easier, you can add the following lines to your
+`~/.emacs` file:
+
+```
+(global-set-key "\M-m"   'compile)  ; m is for make
+(global-set-key [M-down] 'next-error)
+(global-set-key [M-up]   '(lambda () (interactive) (next-error -1)))
+```
+
+Then you can type `M-m` to start a build, or `M-up`/`M-down` to move
+back and forth between errors.
+
+## Fusing Google Mock Source Files ##
+
+Google Mock's implementation consists of dozens of files (excluding
+its own tests).  Sometimes you may want them to be packaged up in
+fewer files instead, such that you can easily copy them to a new
+machine and start hacking there.  For this we provide an experimental
+Python script `fuse_gmock_files.py` in the `scripts/` directory
+(starting with release 1.2.0).  Assuming you have Python 2.4 or above
+installed on your machine, just go to that directory and run
+```
+python fuse_gmock_files.py OUTPUT_DIR
+```
+
+and you should see an `OUTPUT_DIR` directory being created with files
+`gtest/gtest.h`, `gmock/gmock.h`, and `gmock-gtest-all.cc` in it.
+These three files contain everything you need to use Google Mock (and
+Google Test).  Just copy them to anywhere you want and you are ready
+to write tests and use mocks.  You can use the
+[scrpts/test/Makefile](http://code.google.com/p/googlemock/source/browse/trunk/scripts/test/Makefile) file as an example on how to compile your tests
+against them.
+
+# Extending Google Mock #
+
+## Writing New Matchers Quickly ##
+
+The `MATCHER*` family of macros can be used to define custom matchers
+easily.  The syntax:
+
+```
+MATCHER(name, description_string_expression) { statements; }
+```
+
+will define 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 is a `string`-typed expression that documents
+what the matcher does, and is used to generate the failure message
+when the match fails.  It can (and should) reference the special
+`bool` variable `negation`, and should evaluate to the description of
+the matcher when `negation` is `false`, or that of the matcher's
+negation when `negation` is `true`.
+
+For convenience, we allow the description string to be empty (`""`),
+in which case Google Mock will use the sequence of words in the
+matcher name as the description.
+
+For example:
+```
+MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; }
+```
+allows you to write
+```
+  // Expects mock_foo.Bar(n) to be called where n is divisible by 7.
+  EXPECT_CALL(mock_foo, Bar(IsDivisibleBy7()));
+```
+or,
+```
+using ::testing::Not;
+...
+  EXPECT_THAT(some_expression, IsDivisibleBy7());
+  EXPECT_THAT(some_other_expression, Not(IsDivisibleBy7()));
+```
+If the above assertions fail, they will print something like:
+```
+  Value of: some_expression
+  Expected: is divisible by 7
+    Actual: 27
+...
+  Value of: some_other_expression
+  Expected: not (is divisible by 7)
+    Actual: 21
+```
+where the descriptions `"is divisible by 7"` and `"not (is divisible
+by 7)"` are automatically calculated from the matcher name
+`IsDivisibleBy7`.
+
+As you may have noticed, the auto-generated descriptions (especially
+those for the negation) may not be so great. You can always override
+them with a string expression of your own:
+```
+MATCHER(IsDivisibleBy7, std::string(negation ? "isn't" : "is") +
+                        " divisible by 7") {
+  return (arg % 7) == 0;
+}
+```
+
+Optionally, you can stream additional information to a hidden argument
+named `result_listener` to explain the match result. For example, a
+better definition of `IsDivisibleBy7` is:
+```
+MATCHER(IsDivisibleBy7, "") {
+  if ((arg % 7) == 0)
+    return true;
+
+  *result_listener << "the remainder is " << (arg % 7);
+  return false;
+}
+```
+
+With this definition, the above assertion will give a better message:
+```
+  Value of: some_expression
+  Expected: is divisible by 7
+    Actual: 27 (the remainder is 6)
+```
+
+You should let `MatchAndExplain()` print _any additional information_
+that can help a user understand the match result. Note that it should
+explain why the match succeeds in case of a success (unless it's
+obvious) - this is useful when the matcher is used inside
+`Not()`. There is no need to print the argument value itself, as
+Google Mock already prints it for you.
+
+**Notes:**
+
+  1. 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, `IsDivisibleBy7()` can be used to match any type where the value of `(arg % 7) == 0` can be implicitly converted to a `bool`.  In the `Bar(IsDivisibleBy7())` 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.
+  1. Google Mock doesn't guarantee when or how many times a matcher will be invoked. Therefore the matcher logic must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters). This requirement must be satisfied no matter how you define the matcher (e.g. using one of the methods described in the following recipes). In particular, a matcher can never call a mock function, as that will affect the state of the mock object and Google Mock.
+
+## Writing New Parameterized Matchers Quickly ##
+
+Sometimes you'll want to define a matcher that has parameters.  For that you
+can use the macro:
+```
+MATCHER_P(name, param_name, description_string) { statements; }
+```
+where the description string can be either `""` or a string expression
+that references `negation` and `param_name`.
+
+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`.
+
+Google Mock also provides `MATCHER_P2`, `MATCHER_P3`, ..., up to
+`MATCHER_P10` to support multi-parameter matchers:
+```
+MATCHER_Pk(name, param_1, ..., param_k, description_string) { statements; }
+```
+
+Please note that the custom description string is for a particular
+**instance** of the matcher, where the parameters have been bound to
+actual values.  Therefore usually you'll want the parameter values to
+be part of the description.  Google Mock lets you do that by
+referencing the matcher parameters in the description string
+expression.
+
+For example,
+```
+  using ::testing::PrintToString;
+  MATCHER_P2(InClosedRange, low, hi,
+             std::string(negation ? "isn't" : "is") + " in range [" +
+             PrintToString(low) + ", " + PrintToString(hi) + "]") {
+    return low <= arg && arg <= hi;
+  }
+  ...
+  EXPECT_THAT(3, InClosedRange(4, 6));
+```
+would generate a failure that contains the message:
+```
+  Expected: is in range [4, 6]
+```
+
+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));
+```
+would generate a failure that contains the text:
+```
+  Expected: in closed range (4, 6)
+```
+
+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.  Matchers that don't have a parameter
+or have only one parameter have special types: you can assign `Foo()`
+to a `FooMatcher`-typed variable, and assign `Foo(p)` to a
+`FooMatcherP<p_type>`-typed variable.
+
+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.
+
+You can overload matchers with different numbers of parameters:
+```
+MATCHER_P(Blah, a, description_string_1) { ... }
+MATCHER_P2(Blah, a, b, description_string_2) { ... }
+```
+
+While it's tempting to always use the `MATCHER*` macros when defining
+a new matcher, you should also consider implementing
+`MatcherInterface` or using `MakePolymorphicMatcher()` instead (see
+the recipes that follow), especially if you need to use the matcher a
+lot.  While these approaches require more work, they give you more
+control on the types of the value being matched and the matcher
+parameters, which in general leads to better compiler error messages
+that pay off in the long run.  They also allow overloading matchers
+based on parameter types (as opposed to just based on the number of
+parameters).
+
+## Writing New Monomorphic Matchers ##
+
+A matcher of argument type `T` implements
+`::testing::MatcherInterface<T>` and does two things: it tests whether a
+value of type `T` matches the matcher, and can describe what kind of
+values it matches. The latter ability is used for generating readable
+error messages when expectations are violated.
+
+The interface looks like this:
+
+```
+class MatchResultListener {
+ public:
+  ...
+  // Streams x to the underlying ostream; does nothing if the ostream
+  // is NULL.
+  template <typename T>
+  MatchResultListener& operator<<(const T& x);
+
+  // Returns the underlying ostream.
+  ::std::ostream* stream();
+};
+
+template <typename T>
+class MatcherInterface {
+ public:
+  virtual ~MatcherInterface();
+
+  // Returns true iff the matcher matches x; also explains the match
+  // result to 'listener'.
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
+
+  // Describes this matcher to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+
+  // Describes the negation of this matcher to an ostream.
+  virtual void DescribeNegationTo(::std::ostream* os) const;
+};
+```
+
+If you need a custom matcher but `Truly()` is not a good option (for
+example, you may not be happy with the way `Truly(predicate)`
+describes itself, or you may want your matcher to be polymorphic as
+`Eq(value)` is), you can define a matcher to do whatever you want in
+two steps: first implement the matcher interface, and then define a
+factory function to create a matcher instance. The second step is not
+strictly needed but it makes the syntax of using the matcher nicer.
+
+For example, you can define a matcher to test whether an `int` is
+divisible by 7 and then use it like this:
+```
+using ::testing::MakeMatcher;
+using ::testing::Matcher;
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+
+class DivisibleBy7Matcher : public MatcherInterface<int> {
+ public:
+  virtual bool MatchAndExplain(int n, MatchResultListener* listener) const {
+    return (n % 7) == 0;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "is divisible by 7";
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is not divisible by 7";
+  }
+};
+
+inline Matcher<int> DivisibleBy7() {
+  return MakeMatcher(new DivisibleBy7Matcher);
+}
+...
+
+  EXPECT_CALL(foo, Bar(DivisibleBy7()));
+```
+
+You may improve the matcher message by streaming additional
+information to the `listener` argument in `MatchAndExplain()`:
+
+```
+class DivisibleBy7Matcher : public MatcherInterface<int> {
+ public:
+  virtual bool MatchAndExplain(int n,
+                               MatchResultListener* listener) const {
+    const int remainder = n % 7;
+    if (remainder != 0) {
+      *listener << "the remainder is " << remainder;
+    }
+    return remainder == 0;
+  }
+  ...
+};
+```
+
+Then, `EXPECT_THAT(x, DivisibleBy7());` may general a message like this:
+```
+Value of: x
+Expected: is divisible by 7
+  Actual: 23 (the remainder is 2)
+```
+
+## Writing New Polymorphic Matchers ##
+
+You've learned how to write your own matchers in the previous
+recipe. Just one problem: a matcher created using `MakeMatcher()` only
+works for one particular type of arguments. If you want a
+_polymorphic_ matcher that works with arguments of several types (for
+instance, `Eq(x)` can be used to match a `value` as long as `value` ==
+`x` compiles -- `value` and `x` don't have to share the same type),
+you can learn the trick from `"gmock/gmock-matchers.h"` but it's a bit
+involved.
+
+Fortunately, most of the time you can define a polymorphic matcher
+easily with the help of `MakePolymorphicMatcher()`. Here's how you can
+define `NotNull()` as an example:
+
+```
+using ::testing::MakePolymorphicMatcher;
+using ::testing::MatchResultListener;
+using ::testing::NotNull;
+using ::testing::PolymorphicMatcher;
+
+class NotNullMatcher {
+ public:
+  // To implement a polymorphic matcher, first define a COPYABLE class
+  // that has three members MatchAndExplain(), DescribeTo(), and
+  // DescribeNegationTo(), like the following.
+
+  // In this example, we want to use NotNull() with any pointer, so
+  // MatchAndExplain() accepts a pointer of any type as its first argument.
+  // In general, you can define MatchAndExplain() as an ordinary method or
+  // a method template, or even overload it.
+  template <typename T>
+  bool MatchAndExplain(T* p,
+                       MatchResultListener* /* listener */) const {
+    return p != NULL;
+  }
+
+  // Describes the property of a value matching this matcher.
+  void DescribeTo(::std::ostream* os) const { *os << "is not NULL"; }
+
+  // Describes the property of a value NOT matching this matcher.
+  void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
+};
+
+// To construct a polymorphic matcher, pass an instance of the class
+// to MakePolymorphicMatcher().  Note the return type.
+inline PolymorphicMatcher<NotNullMatcher> NotNull() {
+  return MakePolymorphicMatcher(NotNullMatcher());
+}
+...
+
+  EXPECT_CALL(foo, Bar(NotNull()));  // The argument must be a non-NULL pointer.
+```
+
+**Note:** Your polymorphic matcher class does **not** need to inherit from
+`MatcherInterface` or any other class, and its methods do **not** need
+to be virtual.
+
+Like in a monomorphic matcher, you may explain the match result by
+streaming additional information to the `listener` argument in
+`MatchAndExplain()`.
+
+## Writing New Cardinalities ##
+
+A cardinality is used in `Times()` to tell Google Mock how many times
+you expect a call to occur. It doesn't have to be exact. For example,
+you can say `AtLeast(5)` or `Between(2, 4)`.
+
+If the built-in set of cardinalities doesn't suit you, you are free to
+define your own by implementing the following interface (in namespace
+`testing`):
+
+```
+class CardinalityInterface {
+ public:
+  virtual ~CardinalityInterface();
+
+  // Returns true iff call_count calls will satisfy this cardinality.
+  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
+
+  // Returns true iff call_count calls will saturate this cardinality.
+  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
+
+  // Describes self to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+};
+```
+
+For example, to specify that a call must occur even number of times,
+you can write
+
+```
+using ::testing::Cardinality;
+using ::testing::CardinalityInterface;
+using ::testing::MakeCardinality;
+
+class EvenNumberCardinality : public CardinalityInterface {
+ public:
+  virtual bool IsSatisfiedByCallCount(int call_count) const {
+    return (call_count % 2) == 0;
+  }
+
+  virtual bool IsSaturatedByCallCount(int call_count) const {
+    return false;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "called even number of times";
+  }
+};
+
+Cardinality EvenNumber() {
+  return MakeCardinality(new EvenNumberCardinality);
+}
+...
+
+  EXPECT_CALL(foo, Bar(3))
+      .Times(EvenNumber());
+```
+
+## Writing New Actions Quickly ##
+
+If the built-in actions don't work for you, and you find it
+inconvenient to use `Invoke()`, you can use a macro from the `ACTION*`
+family to quickly define a new action that can be used in your code as
+if it's a built-in action.
+
+By writing
+```
+ACTION(name) { statements; }
+```
+in a namespace scope (i.e. not inside a class or function), you will
+define an action with the given name that executes the statements.
+The value returned by `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 as `argK`.  For example:
+```
+ACTION(IncrementArg1) { return ++(*arg1); }
+```
+allows you to write
+```
+... WillOnce(IncrementArg1());
+```
+
+Note that you don't need to specify the types of the mock function
+arguments.  Rest assured that your code is type-safe though:
+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.
+
+Another example:
+```
+ACTION(Foo) {
+  (*arg2)(5);
+  Blah();
+  *arg1 = 0;
+  return arg0;
+}
+```
+defines an action `Foo()` that invokes argument #2 (a function pointer)
+with 5, calls function `Blah()`, sets the value pointed to by argument
+#1 to 0, and returns argument #0.
+
+For more convenience and flexibility, you can also use the following
+pre-defined symbols in the body of `ACTION`:
+
+| `argK_type` | The type of the K-th (0-based) argument of the mock function |
+|:------------|:-------------------------------------------------------------|
+| `args`      | All arguments of the mock function as a tuple                |
+| `args_type` | The type of all arguments of the mock function as a tuple    |
+| `return_type` | The return type of the mock function                         |
+| `function_type` | The type of the mock function                                |
+
+For example, when using an `ACTION` as a stub action for mock function:
+```
+int DoSomething(bool flag, int* ptr);
+```
+we have:
+| **Pre-defined Symbol** | **Is Bound To** |
+|:-----------------------|:----------------|
+| `arg0`                 | the value of `flag` |
+| `arg0_type`            | the type `bool` |
+| `arg1`                 | the value of `ptr` |
+| `arg1_type`            | the type `int*` |
+| `args`                 | the tuple `(flag, ptr)` |
+| `args_type`            | the type `std::tr1::tuple<bool, int*>` |
+| `return_type`          | the type `int`  |
+| `function_type`        | the type `int(bool, int*)` |
+
+## Writing New Parameterized Actions Quickly ##
+
+Sometimes you'll want to parameterize an action you define.  For that
+we have another macro
+```
+ACTION_P(name, param) { statements; }
+```
+
+For example,
+```
+ACTION_P(Add, n) { return arg0 + n; }
+```
+will allow you to write
+```
+// Returns argument #0 + 5.
+... WillOnce(Add(5));
+```
+
+For convenience, we use the term _arguments_ for the values used to
+invoke the mock function, and the term _parameters_ for the values
+used to instantiate an action.
+
+Note that you don't need to provide the type of the parameter either.
+Suppose the parameter is named `param`, you can also use the
+Google-Mock-defined symbol `param_type` to refer to the type of the
+parameter as inferred by the compiler.  For example, in the body of
+`ACTION_P(Add, n)` above, you can write `n_type` for the type of `n`.
+
+Google Mock also provides `ACTION_P2`, `ACTION_P3`, and etc to support
+multi-parameter actions.  For example,
+```
+ACTION_P2(ReturnDistanceTo, x, y) {
+  double dx = arg0 - x;
+  double dy = arg1 - y;
+  return sqrt(dx*dx + dy*dy);
+}
+```
+lets you write
+```
+... WillOnce(ReturnDistanceTo(5.0, 26.5));
+```
+
+You can view `ACTION` as a degenerated parameterized action where the
+number of parameters is 0.
+
+You can also easily define actions overloaded on the number of parameters:
+```
+ACTION_P(Plus, a) { ... }
+ACTION_P2(Plus, a, b) { ... }
+```
+
+## Restricting the Type of an Argument or Parameter in an ACTION ##
+
+For maximum brevity and reusability, the `ACTION*` macros don't ask
+you to provide the types of the mock function arguments and the action
+parameters.  Instead, we let the compiler infer the types for us.
+
+Sometimes, however, we may want to be more explicit about the types.
+There are several tricks to do that.  For example:
+```
+ACTION(Foo) {
+  // Makes sure arg0 can be converted to int.
+  int n = arg0;
+  ... use n instead of arg0 here ...
+}
+
+ACTION_P(Bar, param) {
+  // Makes sure the type of arg1 is const char*.
+  ::testing::StaticAssertTypeEq<const char*, arg1_type>();
+
+  // Makes sure param can be converted to bool.
+  bool flag = param;
+}
+```
+where `StaticAssertTypeEq` is a compile-time assertion in Google Test
+that verifies two types are the same.
+
+## Writing New Action Templates Quickly ##
+
+Sometimes you want to give an action explicit template parameters that
+cannot be inferred from its value parameters.  `ACTION_TEMPLATE()`
+supports 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, where _m_ is between 1 and 10, and _n_ is
+between 0 and 10.  `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,
+                // Note the comma between int and k:
+                HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
+                AND_1_VALUE_PARAMS(output)) {
+  *output = T(std::tr1::get<k>(args));
+}
+```
+
+To create an instance of an action template, write:
+```
+  ActionName<t1, ..., t_m>(v1, ..., v_n)
+```
+where the `t`s are the template arguments and the
+`v`s are the value arguments.  The value argument
+types are inferred by the compiler.  For example:
+```
+using ::testing::_;
+...
+  int n;
+  EXPECT_CALL(mock, Foo(_, _))
+      .WillOnce(DuplicateArg<1, unsigned char>(&n));
+```
+
+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 a two-template-parameter action where the compiler
+is asked to infer the type of `x`?
+
+## Using the ACTION Object's Type ##
+
+If you are writing a function that returns an `ACTION` object, you'll
+need to know its type.  The type depends on the macro used to define
+the action and the parameter types.  The rule is relatively simple:
+| **Given Definition** | **Expression** | **Has Type** |
+|:---------------------|:---------------|:-------------|
+| `ACTION(Foo)`        | `Foo()`        | `FooAction`  |
+| `ACTION_TEMPLATE(Foo, HAS_m_TEMPLATE_PARAMS(...), AND_0_VALUE_PARAMS())` |	`Foo<t1, ..., t_m>()` | `FooAction<t1, ..., t_m>` |
+| `ACTION_P(Bar, param)` | `Bar(int_value)` | `BarActionP<int>` |
+| `ACTION_TEMPLATE(Bar, HAS_m_TEMPLATE_PARAMS(...), AND_1_VALUE_PARAMS(p1))` | `Bar<t1, ..., t_m>(int_value)` | `FooActionP<t1, ..., t_m, int>` |
+| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value, int_value)` | `BazActionP2<bool, int>` |
+| `ACTION_TEMPLATE(Baz, HAS_m_TEMPLATE_PARAMS(...), AND_2_VALUE_PARAMS(p1, p2))` | `Baz<t1, ..., t_m>(bool_value, int_value)` | `FooActionP2<t1, ..., t_m, bool, int>` |
+| ...                  | ...            | ...          |
+
+Note that we have to pick different suffixes (`Action`, `ActionP`,
+`ActionP2`, and etc) for actions with different numbers of value
+parameters, or the action definitions cannot be overloaded on the
+number of them.
+
+## Writing New Monomorphic Actions ##
+
+While the `ACTION*` macros are very convenient, sometimes they are
+inappropriate.  For example, despite the tricks shown in the previous
+recipes, they don't let you directly specify the types of the mock
+function arguments and the action parameters, which in general leads
+to unoptimized compiler error messages that can baffle unfamiliar
+users.  They also don't allow overloading actions based on parameter
+types without jumping through some hoops.
+
+An alternative to the `ACTION*` macros is to implement
+`::testing::ActionInterface<F>`, where `F` is the type of the mock
+function in which the action will be used. For example:
+
+```
+template <typename F>class ActionInterface {
+ public:
+  virtual ~ActionInterface();
+
+  // Performs the action.  Result is the return type of function type
+  // F, and ArgumentTuple is the tuple of arguments of F.
+  //
+  // For example, if F is int(bool, const string&), then Result would
+  // be int, and ArgumentTuple would be tr1::tuple<bool, const string&>.
+  virtual Result Perform(const ArgumentTuple& args) = 0;
+};
+
+using ::testing::_;
+using ::testing::Action;
+using ::testing::ActionInterface;
+using ::testing::MakeAction;
+
+typedef int IncrementMethod(int*);
+
+class IncrementArgumentAction : public ActionInterface<IncrementMethod> {
+ public:
+  virtual int Perform(const tr1::tuple<int*>& args) {
+    int* p = tr1::get<0>(args);  // Grabs the first argument.
+    return *p++;
+  }
+};
+
+Action<IncrementMethod> IncrementArgument() {
+  return MakeAction(new IncrementArgumentAction);
+}
+...
+
+  EXPECT_CALL(foo, Baz(_))
+      .WillOnce(IncrementArgument());
+
+  int n = 5;
+  foo.Baz(&n);  // Should return 5 and change n to 6.
+```
+
+## Writing New Polymorphic Actions ##
+
+The previous recipe showed you how to define your own action. This is
+all good, except that you need to know the type of the function in
+which the action will be used. Sometimes that can be a problem. For
+example, if you want to use the action in functions with _different_
+types (e.g. like `Return()` and `SetArgPointee()`).
+
+If an action can be used in several types of mock functions, we say
+it's _polymorphic_. The `MakePolymorphicAction()` function template
+makes it easy to define such an action:
+
+```
+namespace testing {
+
+template <typename Impl>
+PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl);
+
+}  // namespace testing
+```
+
+As an example, let's define an action that returns the second argument
+in the mock function's argument list. The first step is to define an
+implementation class:
+
+```
+class ReturnSecondArgumentAction {
+ public:
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& args) const {
+    // To get the i-th (0-based) argument, use tr1::get<i>(args).
+    return tr1::get<1>(args);
+  }
+};
+```
+
+This implementation class does _not_ need to inherit from any
+particular class. What matters is that it must have a `Perform()`
+method template. This method template takes the mock function's
+arguments as a tuple in a **single** argument, and returns the result of
+the action. It can be either `const` or not, but must be invokable
+with exactly one template argument, which is the result type. In other
+words, you must be able to call `Perform<R>(args)` where `R` is the
+mock function's return type and `args` is its arguments in a tuple.
+
+Next, we use `MakePolymorphicAction()` to turn an instance of the
+implementation class into the polymorphic action we need. It will be
+convenient to have a wrapper for this:
+
+```
+using ::testing::MakePolymorphicAction;
+using ::testing::PolymorphicAction;
+
+PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
+  return MakePolymorphicAction(ReturnSecondArgumentAction());
+}
+```
+
+Now, you can use this polymorphic action the same way you use the
+built-in ones:
+
+```
+using ::testing::_;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD2(DoThis, int(bool flag, int n));
+  MOCK_METHOD3(DoThat, string(int x, const char* str1, const char* str2));
+};
+...
+
+  MockFoo foo;
+  EXPECT_CALL(foo, DoThis(_, _))
+      .WillOnce(ReturnSecondArgument());
+  EXPECT_CALL(foo, DoThat(_, _, _))
+      .WillOnce(ReturnSecondArgument());
+  ...
+  foo.DoThis(true, 5);         // Will return 5.
+  foo.DoThat(1, "Hi", "Bye");  // Will return "Hi".
+```
+
+## Teaching Google Mock How to Print Your Values ##
+
+When an uninteresting or unexpected call occurs, Google Mock prints the
+argument values and the stack trace to help you debug.  Assertion
+macros like `EXPECT_THAT` and `EXPECT_EQ` also print the values in
+question when the assertion fails.  Google Mock and Google Test do this using
+Google Test's user-extensible value printer.
+
+This printer knows how to print built-in C++ types, native arrays, STL
+containers, and any type that supports the `<<` operator.  For other
+types, it prints the raw bytes in the value and hopes that you the
+user can figure it out.
+[Google Test's advanced guide](http://code.google.com/p/googletest/wiki/V1_6_AdvancedGuide#Teaching_Google_Test_How_to_Print_Your_Values)
+explains how to extend the printer to do a better job at
+printing your particular type than to dump the bytes.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/Documentation.md
new file mode 100644
index 00000000..dcc9156c
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/Documentation.md
@@ -0,0 +1,12 @@
+This page lists all documentation wiki pages for Google Mock **1.6**
+- **if you use a released version of Google Mock, please read the documentation for that specific version instead.**
+
+  * [ForDummies](V1_6_ForDummies.md) -- start here if you are new to Google Mock.
+  * [CheatSheet](V1_6_CheatSheet.md) -- a quick reference.
+  * [CookBook](V1_6_CookBook.md) -- recipes for doing various tasks using Google Mock.
+  * [FrequentlyAskedQuestions](V1_6_FrequentlyAskedQuestions.md) -- check here before asking a question on the mailing list.
+
+To contribute code to Google Mock, read:
+
+  * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
+  * [Pump Manual](http://code.google.com/p/googletest/wiki/V1_6_PumpManual) -- how we generate some of Google Mock's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/ForDummies.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/ForDummies.md
new file mode 100644
index 00000000..19ee63ab
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/ForDummies.md
@@ -0,0 +1,439 @@
+
+
+(**Note:** If you get compiler errors that you don't understand, be sure to consult [Google Mock Doctor](http://code.google.com/p/googlemock/wiki/V1_6_FrequentlyAskedQuestions#How_am_I_supposed_to_make_sense_of_these_horrible_template_error).)
+
+# What Is Google C++ Mocking Framework? #
+When you write a prototype or test, often it's not feasible or wise to rely on real objects entirely. A **mock object** implements the same interface as a real object (so it can be used as one), but lets you specify at run time how it will be used and what it should do (which methods will be called? in which order? how many times? with what arguments? what will they return? etc).
+
+**Note:** It is easy to confuse the term _fake objects_ with mock objects. Fakes and mocks actually mean very different things in the Test-Driven Development (TDD) community:
+
+  * **Fake** objects have working implementations, but usually take some shortcut (perhaps to make the operations less expensive), which makes them not suitable for production. An in-memory file system would be an example of a fake.
+  * **Mocks** are objects pre-programmed with _expectations_, which form a specification of the calls they are expected to receive.
+
+If all this seems too abstract for you, don't worry - the most important thing to remember is that a mock allows you to check the _interaction_ between itself and code that uses it. The difference between fakes and mocks will become much clearer once you start to use mocks.
+
+**Google C++ Mocking Framework** (or **Google Mock** for short) is a library (sometimes we also call it a "framework" to make it sound cool) for creating mock classes and using them. It does to C++ what [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/) do to Java.
+
+Using Google Mock involves three basic steps:
+
+  1. Use some simple macros to describe the interface you want to mock, and they will expand to the implementation of your mock class;
+  1. Create some mock objects and specify its expectations and behavior using an intuitive syntax;
+  1. Exercise code that uses the mock objects. Google Mock will catch any violation of the expectations as soon as it arises.
+
+# Why Google Mock? #
+While mock objects help you remove unnecessary dependencies in tests and make them fast and reliable, using mocks manually in C++ is _hard_:
+
+  * Someone has to implement the mocks. The job is usually tedious and error-prone. No wonder people go great distance to avoid it.
+  * The quality of those manually written mocks is a bit, uh, unpredictable. You may see some really polished ones, but you may also see some that were hacked up in a hurry and have all sorts of ad hoc restrictions.
+  * The knowledge you gained from using one mock doesn't transfer to the next.
+
+In contrast, Java and Python programmers have some fine mock frameworks, which automate the creation of mocks. As a result, mocking is a proven effective technique and widely adopted practice in those communities. Having the right tool absolutely makes the difference.
+
+Google Mock was built to help C++ programmers. It was inspired by [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/), but designed with C++'s specifics in mind. It is your friend if any of the following problems is bothering you:
+
+  * You are stuck with a sub-optimal design and wish you had done more prototyping before it was too late, but prototyping in C++ is by no means "rapid".
+  * Your tests are slow as they depend on too many libraries or use expensive resources (e.g. a database).
+  * Your tests are brittle as some resources they use are unreliable (e.g. the network).
+  * You want to test how your code handles a failure (e.g. a file checksum error), but it's not easy to cause one.
+  * You need to make sure that your module interacts with other modules in the right way, but it's hard to observe the interaction; therefore you resort to observing the side effects at the end of the action, which is awkward at best.
+  * You want to "mock out" your dependencies, except that they don't have mock implementations yet; and, frankly, you aren't thrilled by some of those hand-written mocks.
+
+We encourage you to use Google Mock as:
+
+  * a _design_ tool, for it lets you experiment with your interface design early and often. More iterations lead to better designs!
+  * a _testing_ tool to cut your tests' outbound dependencies and probe the interaction between your module and its collaborators.
+
+# Getting Started #
+Using Google Mock is easy! Inside your C++ source file, just `#include` `"gtest/gtest.h"` and `"gmock/gmock.h"`, and you are ready to go.
+
+# A Case for Mock Turtles #
+Let's look at an example. Suppose you are developing a graphics program that relies on a LOGO-like API for drawing. How would you test that it does the right thing? Well, you can run it and compare the screen with a golden screen snapshot, but let's admit it: tests like this are expensive to run and fragile (What if you just upgraded to a shiny new graphics card that has better anti-aliasing? Suddenly you have to update all your golden images.). It would be too painful if all your tests are like this. Fortunately, you learned about Dependency Injection and know the right thing to do: instead of having your application talk to the drawing API directly, wrap the API in an interface (say, `Turtle`) and code to that interface:
+
+```
+class Turtle {
+  ...
+  virtual ~Turtle() {}
+  virtual void PenUp() = 0;
+  virtual void PenDown() = 0;
+  virtual void Forward(int distance) = 0;
+  virtual void Turn(int degrees) = 0;
+  virtual void GoTo(int x, int y) = 0;
+  virtual int GetX() const = 0;
+  virtual int GetY() const = 0;
+};
+```
+
+(Note that the destructor of `Turtle` **must** be virtual, as is the case for **all** classes you intend to inherit from - otherwise the destructor of the derived class will not be called when you delete an object through a base pointer, and you'll get corrupted program states like memory leaks.)
+
+You can control whether the turtle's movement will leave a trace using `PenUp()` and `PenDown()`, and control its movement using `Forward()`, `Turn()`, and `GoTo()`. Finally, `GetX()` and `GetY()` tell you the current position of the turtle.
+
+Your program will normally use a real implementation of this interface. In tests, you can use a mock implementation instead. This allows you to easily check what drawing primitives your program is calling, with what arguments, and in which order. Tests written this way are much more robust (they won't break because your new machine does anti-aliasing differently), easier to read and maintain (the intent of a test is expressed in the code, not in some binary images), and run _much, much faster_.
+
+# Writing the Mock Class #
+If you are lucky, the mocks you need to use have already been implemented by some nice people. If, however, you find yourself in the position to write a mock class, relax - Google Mock turns this task into a fun game! (Well, almost.)
+
+## How to Define It ##
+Using the `Turtle` interface as example, here are the simple steps you need to follow:
+
+  1. Derive a class `MockTurtle` from `Turtle`.
+  1. Take a _virtual_ function of `Turtle` (while it's possible to [mock non-virtual methods using templates](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Mocking_Nonvirtual_Methods), it's much more involved). Count how many arguments it has.
+  1. In the `public:` section of the child class, write `MOCK_METHODn();` (or `MOCK_CONST_METHODn();` if you are mocking a `const` method), where `n` is the number of the arguments; if you counted wrong, shame on you, and a compiler error will tell you so.
+  1. Now comes the fun part: you take the function signature, cut-and-paste the _function name_ as the _first_ argument to the macro, and leave what's left as the _second_ argument (in case you're curious, this is the _type of the function_).
+  1. Repeat until all virtual functions you want to mock are done.
+
+After the process, you should have something like:
+
+```
+#include "gmock/gmock.h"  // Brings in Google Mock.
+class MockTurtle : public Turtle {
+ public:
+  ...
+  MOCK_METHOD0(PenUp, void());
+  MOCK_METHOD0(PenDown, void());
+  MOCK_METHOD1(Forward, void(int distance));
+  MOCK_METHOD1(Turn, void(int degrees));
+  MOCK_METHOD2(GoTo, void(int x, int y));
+  MOCK_CONST_METHOD0(GetX, int());
+  MOCK_CONST_METHOD0(GetY, int());
+};
+```
+
+You don't need to define these mock methods somewhere else - the `MOCK_METHOD*` macros will generate the definitions for you. It's that simple! Once you get the hang of it, you can pump out mock classes faster than your source-control system can handle your check-ins.
+
+**Tip:** If even this is too much work for you, you'll find the
+`gmock_gen.py` tool in Google Mock's `scripts/generator/` directory (courtesy of the [cppclean](http://code.google.com/p/cppclean/) project) useful.  This command-line
+tool requires that you have Python 2.4 installed.  You give it a C++ file and the name of an abstract class defined in it,
+and it will print the definition of the mock class for you.  Due to the
+complexity of the C++ language, this script may not always work, but
+it can be quite handy when it does.  For more details, read the [user documentation](http://code.google.com/p/googlemock/source/browse/trunk/scripts/generator/README).
+
+## Where to Put It ##
+When you define a mock class, you need to decide where to put its definition. Some people put it in a `*_test.cc`. This is fine when the interface being mocked (say, `Foo`) is owned by the same person or team. Otherwise, when the owner of `Foo` changes it, your test could break. (You can't really expect `Foo`'s maintainer to fix every test that uses `Foo`, can you?)
+
+So, the rule of thumb is: if you need to mock `Foo` and it's owned by others, define the mock class in `Foo`'s package (better, in a `testing` sub-package such that you can clearly separate production code and testing utilities), and put it in a `mock_foo.h`. Then everyone can reference `mock_foo.h` from their tests. If `Foo` ever changes, there is only one copy of `MockFoo` to change, and only tests that depend on the changed methods need to be fixed.
+
+Another way to do it: you can introduce a thin layer `FooAdaptor` on top of `Foo` and code to this new interface. Since you own `FooAdaptor`, you can absorb changes in `Foo` much more easily. While this is more work initially, carefully choosing the adaptor interface can make your code easier to write and more readable (a net win in the long run), as you can choose `FooAdaptor` to fit your specific domain much better than `Foo` does.
+
+# Using Mocks in Tests #
+Once you have a mock class, using it is easy. The typical work flow is:
+
+  1. Import the Google Mock names from the `testing` namespace such that you can use them unqualified (You only have to do it once per file. Remember that namespaces are a good idea and good for your health.).
+  1. Create some mock objects.
+  1. Specify your expectations on them (How many times will a method be called? With what arguments? What should it do? etc.).
+  1. Exercise some code that uses the mocks; optionally, check the result using Google Test assertions. If a mock method is called more than expected or with wrong arguments, you'll get an error immediately.
+  1. When a mock is destructed, Google Mock will automatically check whether all expectations on it have been satisfied.
+
+Here's an example:
+
+```
+#include "path/to/mock-turtle.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+using ::testing::AtLeast;                     // #1
+
+TEST(PainterTest, CanDrawSomething) {
+  MockTurtle turtle;                          // #2
+  EXPECT_CALL(turtle, PenDown())              // #3
+      .Times(AtLeast(1));
+
+  Painter painter(&turtle);                   // #4
+
+  EXPECT_TRUE(painter.DrawCircle(0, 0, 10));
+}                                             // #5
+
+int main(int argc, char** argv) {
+  // The following line must be executed to initialize Google Mock
+  // (and Google Test) before running the tests.
+  ::testing::InitGoogleMock(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+```
+
+As you might have guessed, this test checks that `PenDown()` is called at least once. If the `painter` object didn't call this method, your test will fail with a message like this:
+
+```
+path/to/my_test.cc:119: Failure
+Actual function call count doesn't match this expectation:
+Actually: never called;
+Expected: called at least once.
+```
+
+**Tip 1:** If you run the test from an Emacs buffer, you can hit `<Enter>` on the line number displayed in the error message to jump right to the failed expectation.
+
+**Tip 2:** If your mock objects are never deleted, the final verification won't happen. Therefore it's a good idea to use a heap leak checker in your tests when you allocate mocks on the heap.
+
+**Important note:** Google Mock requires expectations to be set **before** the mock functions are called, otherwise the behavior is **undefined**. In particular, you mustn't interleave `EXPECT_CALL()`s and calls to the mock functions.
+
+This means `EXPECT_CALL()` should be read as expecting that a call will occur _in the future_, not that a call has occurred. Why does Google Mock work like that? Well, specifying the expectation beforehand allows Google Mock to report a violation as soon as it arises, when the context (stack trace, etc) is still available. This makes debugging much easier.
+
+Admittedly, this test is contrived and doesn't do much. You can easily achieve the same effect without using Google Mock. However, as we shall reveal soon, Google Mock allows you to do _much more_ with the mocks.
+
+## Using Google Mock with Any Testing Framework ##
+If you want to use something other than Google Test (e.g. [CppUnit](http://apps.sourceforge.net/mediawiki/cppunit/index.php?title=Main_Page) or
+[CxxTest](http://cxxtest.tigris.org/)) as your testing framework, just change the `main()` function in the previous section to:
+```
+int main(int argc, char** argv) {
+  // The following line causes Google Mock to throw an exception on failure,
+  // which will be interpreted by your testing framework as a test failure.
+  ::testing::GTEST_FLAG(throw_on_failure) = true;
+  ::testing::InitGoogleMock(&argc, argv);
+  ... whatever your testing framework requires ...
+}
+```
+
+This approach has a catch: it makes Google Mock throw an exception
+from a mock object's destructor sometimes.  With some compilers, this
+sometimes causes the test program to crash.  You'll still be able to
+notice that the test has failed, but it's not a graceful failure.
+
+A better solution is to use Google Test's
+[event listener API](http://code.google.com/p/googletest/wiki/V1_6_AdvancedGuide#Extending_Google_Test_by_Handling_Test_Events)
+to report a test failure to your testing framework properly.  You'll need to
+implement the `OnTestPartResult()` method of the event listener interface, but it
+should be straightforward.
+
+If this turns out to be too much work, we suggest that you stick with
+Google Test, which works with Google Mock seamlessly (in fact, it is
+technically part of Google Mock.).  If there is a reason that you
+cannot use Google Test, please let us know.
+
+# Setting Expectations #
+The key to using a mock object successfully is to set the _right expectations_ on it. If you set the expectations too strict, your test will fail as the result of unrelated changes. If you set them too loose, bugs can slip through. You want to do it just right such that your test can catch exactly the kind of bugs you intend it to catch. Google Mock provides the necessary means for you to do it "just right."
+
+## General Syntax ##
+In Google Mock we use the `EXPECT_CALL()` macro to set an expectation on a mock method. The general syntax is:
+
+```
+EXPECT_CALL(mock_object, method(matchers))
+    .Times(cardinality)
+    .WillOnce(action)
+    .WillRepeatedly(action);
+```
+
+The macro has two arguments: first the mock object, and then the method and its arguments. Note that the two are separated by a comma (`,`), not a period (`.`). (Why using a comma? The answer is that it was necessary for technical reasons.)
+
+The macro can be followed by some optional _clauses_ that provide more information about the expectation. We'll discuss how each clause works in the coming sections.
+
+This syntax is designed to make an expectation read like English. For example, you can probably guess that
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetX())
+    .Times(5)
+    .WillOnce(Return(100))
+    .WillOnce(Return(150))
+    .WillRepeatedly(Return(200));
+```
+
+says that the `turtle` object's `GetX()` method will be called five times, it will return 100 the first time, 150 the second time, and then 200 every time. Some people like to call this style of syntax a Domain-Specific Language (DSL).
+
+**Note:** Why do we use a macro to do this? It serves two purposes: first it makes expectations easily identifiable (either by `grep` or by a human reader), and second it allows Google Mock to include the source file location of a failed expectation in messages, making debugging easier.
+
+## Matchers: What Arguments Do We Expect? ##
+When a mock function takes arguments, we must specify what arguments we are expecting; for example:
+
+```
+// Expects the turtle to move forward by 100 units.
+EXPECT_CALL(turtle, Forward(100));
+```
+
+Sometimes you may not want to be too specific (Remember that talk about tests being too rigid? Over specification leads to brittle tests and obscures the intent of tests. Therefore we encourage you to specify only what's necessary - no more, no less.). If you care to check that `Forward()` will be called but aren't interested in its actual argument, write `_` as the argument, which means "anything goes":
+
+```
+using ::testing::_;
+...
+// Expects the turtle to move forward.
+EXPECT_CALL(turtle, Forward(_));
+```
+
+`_` is an instance of what we call **matchers**. A matcher is like a predicate and can test whether an argument is what we'd expect. You can use a matcher inside `EXPECT_CALL()` wherever a function argument is expected.
+
+A list of built-in matchers can be found in the [CheatSheet](V1_6_CheatSheet.md). For example, here's the `Ge` (greater than or equal) matcher:
+
+```
+using ::testing::Ge;...
+EXPECT_CALL(turtle, Forward(Ge(100)));
+```
+
+This checks that the turtle will be told to go forward by at least 100 units.
+
+## Cardinalities: How Many Times Will It Be Called? ##
+The first clause we can specify following an `EXPECT_CALL()` is `Times()`. We call its argument a **cardinality** as it tells _how many times_ the call should occur. It allows us to repeat an expectation many times without actually writing it as many times. More importantly, a cardinality can be "fuzzy", just like a matcher can be. This allows a user to express the intent of a test exactly.
+
+An interesting special case is when we say `Times(0)`. You may have guessed - it means that the function shouldn't be called with the given arguments at all, and Google Mock will report a Google Test failure whenever the function is (wrongfully) called.
+
+We've seen `AtLeast(n)` as an example of fuzzy cardinalities earlier. For the list of built-in cardinalities you can use, see the [CheatSheet](V1_6_CheatSheet.md).
+
+The `Times()` clause can be omitted. **If you omit `Times()`, Google Mock will infer the cardinality for you.** The rules are easy to remember:
+
+  * If **neither** `WillOnce()` **nor** `WillRepeatedly()` is in the `EXPECT_CALL()`, the inferred cardinality is `Times(1)`.
+  * If there are `n WillOnce()`'s but **no** `WillRepeatedly()`, where `n` >= 1, the cardinality is `Times(n)`.
+  * If there are `n WillOnce()`'s and **one** `WillRepeatedly()`, where `n` >= 0, the cardinality is `Times(AtLeast(n))`.
+
+**Quick quiz:** what do you think will happen if a function is expected to be called twice but actually called four times?
+
+## Actions: What Should It Do? ##
+Remember that a mock object doesn't really have a working implementation? We as users have to tell it what to do when a method is invoked. This is easy in Google Mock.
+
+First, if the return type of a mock function is a built-in type or a pointer, the function has a **default action** (a `void` function will just return, a `bool` function will return `false`, and other functions will return 0). If you don't say anything, this behavior will be used.
+
+Second, if a mock function doesn't have a default action, or the default action doesn't suit you, you can specify the action to be taken each time the expectation matches using a series of `WillOnce()` clauses followed by an optional `WillRepeatedly()`. For example,
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetX())
+    .WillOnce(Return(100))
+    .WillOnce(Return(200))
+    .WillOnce(Return(300));
+```
+
+This says that `turtle.GetX()` will be called _exactly three times_ (Google Mock inferred this from how many `WillOnce()` clauses we've written, since we didn't explicitly write `Times()`), and will return 100, 200, and 300 respectively.
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetY())
+    .WillOnce(Return(100))
+    .WillOnce(Return(200))
+    .WillRepeatedly(Return(300));
+```
+
+says that `turtle.GetY()` will be called _at least twice_ (Google Mock knows this as we've written two `WillOnce()` clauses and a `WillRepeatedly()` while having no explicit `Times()`), will return 100 the first time, 200 the second time, and 300 from the third time on.
+
+Of course, if you explicitly write a `Times()`, Google Mock will not try to infer the cardinality itself. What if the number you specified is larger than there are `WillOnce()` clauses? Well, after all `WillOnce()`s are used up, Google Mock will do the _default_ action for the function every time (unless, of course, you have a `WillRepeatedly()`.).
+
+What can we do inside `WillOnce()` besides `Return()`? You can return a reference using `ReturnRef(variable)`, or invoke a pre-defined function, among [others](http://code.google.com/p/googlemock/wiki/V1_6_CheatSheet#Actions).
+
+**Important note:** The `EXPECT_CALL()` statement evaluates the action clause only once, even though the action may be performed many times. Therefore you must be careful about side effects. The following may not do what you want:
+
+```
+int n = 100;
+EXPECT_CALL(turtle, GetX())
+.Times(4)
+.WillRepeatedly(Return(n++));
+```
+
+Instead of returning 100, 101, 102, ..., consecutively, this mock function will always return 100 as `n++` is only evaluated once. Similarly, `Return(new Foo)` will create a new `Foo` object when the `EXPECT_CALL()` is executed, and will return the same pointer every time. If you want the side effect to happen every time, you need to define a custom action, which we'll teach in the [CookBook](V1_6_CookBook.md).
+
+Time for another quiz! What do you think the following means?
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetY())
+.Times(4)
+.WillOnce(Return(100));
+```
+
+Obviously `turtle.GetY()` is expected to be called four times. But if you think it will return 100 every time, think twice! Remember that one `WillOnce()` clause will be consumed each time the function is invoked and the default action will be taken afterwards. So the right answer is that `turtle.GetY()` will return 100 the first time, but **return 0 from the second time on**, as returning 0 is the default action for `int` functions.
+
+## Using Multiple Expectations ##
+So far we've only shown examples where you have a single expectation. More realistically, you're going to specify expectations on multiple mock methods, which may be from multiple mock objects.
+
+By default, when a mock method is invoked, Google Mock will search the expectations in the **reverse order** they are defined, and stop when an active expectation that matches the arguments is found (you can think of it as "newer rules override older ones."). If the matching expectation cannot take any more calls, you will get an upper-bound-violated failure. Here's an example:
+
+```
+using ::testing::_;...
+EXPECT_CALL(turtle, Forward(_));  // #1
+EXPECT_CALL(turtle, Forward(10))  // #2
+    .Times(2);
+```
+
+If `Forward(10)` is called three times in a row, the third time it will be an error, as the last matching expectation (#2) has been saturated. If, however, the third `Forward(10)` call is replaced by `Forward(20)`, then it would be OK, as now #1 will be the matching expectation.
+
+**Side note:** Why does Google Mock search for a match in the _reverse_ order of the expectations? The reason is that this allows a user to set up the default expectations in a mock object's constructor or the test fixture's set-up phase and then customize the mock by writing more specific expectations in the test body. So, if you have two expectations on the same method, you want to put the one with more specific matchers **after** the other, or the more specific rule would be shadowed by the more general one that comes after it.
+
+## Ordered vs Unordered Calls ##
+By default, an expectation can match a call even though an earlier expectation hasn't been satisfied. In other words, the calls don't have to occur in the order the expectations are specified.
+
+Sometimes, you may want all the expected calls to occur in a strict order. To say this in Google Mock is easy:
+
+```
+using ::testing::InSequence;...
+TEST(FooTest, DrawsLineSegment) {
+  ...
+  {
+    InSequence dummy;
+
+    EXPECT_CALL(turtle, PenDown());
+    EXPECT_CALL(turtle, Forward(100));
+    EXPECT_CALL(turtle, PenUp());
+  }
+  Foo();
+}
+```
+
+By creating an object of type `InSequence`, all expectations in its scope are put into a _sequence_ and have to occur _sequentially_. Since we are just relying on the constructor and destructor of this object to do the actual work, its name is really irrelevant.
+
+In this example, we test that `Foo()` calls the three expected functions in the order as written. If a call is made out-of-order, it will be an error.
+
+(What if you care about the relative order of some of the calls, but not all of them? Can you specify an arbitrary partial order? The answer is ... yes! If you are impatient, the details can be found in the [CookBook](V1_6_CookBook.md).)
+
+## All Expectations Are Sticky (Unless Said Otherwise) ##
+Now let's do a quick quiz to see how well you can use this mock stuff already. How would you test that the turtle is asked to go to the origin _exactly twice_ (you want to ignore any other instructions it receives)?
+
+After you've come up with your answer, take a look at ours and compare notes (solve it yourself first - don't cheat!):
+
+```
+using ::testing::_;...
+EXPECT_CALL(turtle, GoTo(_, _))  // #1
+    .Times(AnyNumber());
+EXPECT_CALL(turtle, GoTo(0, 0))  // #2
+    .Times(2);
+```
+
+Suppose `turtle.GoTo(0, 0)` is called three times. In the third time, Google Mock will see that the arguments match expectation #2 (remember that we always pick the last matching expectation). Now, since we said that there should be only two such calls, Google Mock will report an error immediately. This is basically what we've told you in the "Using Multiple Expectations" section above.
+
+This example shows that **expectations in Google Mock are "sticky" by default**, in the sense that they remain active even after we have reached their invocation upper bounds. This is an important rule to remember, as it affects the meaning of the spec, and is **different** to how it's done in many other mocking frameworks (Why'd we do that? Because we think our rule makes the common cases easier to express and understand.).
+
+Simple? Let's see if you've really understood it: what does the following code say?
+
+```
+using ::testing::Return;
+...
+for (int i = n; i > 0; i--) {
+  EXPECT_CALL(turtle, GetX())
+      .WillOnce(Return(10*i));
+}
+```
+
+If you think it says that `turtle.GetX()` will be called `n` times and will return 10, 20, 30, ..., consecutively, think twice! The problem is that, as we said, expectations are sticky. So, the second time `turtle.GetX()` is called, the last (latest) `EXPECT_CALL()` statement will match, and will immediately lead to an "upper bound exceeded" error - this piece of code is not very useful!
+
+One correct way of saying that `turtle.GetX()` will return 10, 20, 30, ..., is to explicitly say that the expectations are _not_ sticky. In other words, they should _retire_ as soon as they are saturated:
+
+```
+using ::testing::Return;
+...
+for (int i = n; i > 0; i--) {
+  EXPECT_CALL(turtle, GetX())
+    .WillOnce(Return(10*i))
+    .RetiresOnSaturation();
+}
+```
+
+And, there's a better way to do it: in this case, we expect the calls to occur in a specific order, and we line up the actions to match the order. Since the order is important here, we should make it explicit using a sequence:
+
+```
+using ::testing::InSequence;
+using ::testing::Return;
+...
+{
+  InSequence s;
+
+  for (int i = 1; i <= n; i++) {
+    EXPECT_CALL(turtle, GetX())
+        .WillOnce(Return(10*i))
+        .RetiresOnSaturation();
+  }
+}
+```
+
+By the way, the other situation where an expectation may _not_ be sticky is when it's in a sequence - as soon as another expectation that comes after it in the sequence has been used, it automatically retires (and will never be used to match any call).
+
+## Uninteresting Calls ##
+A mock object may have many methods, and not all of them are that interesting. For example, in some tests we may not care about how many times `GetX()` and `GetY()` get called.
+
+In Google Mock, if you are not interested in a method, just don't say anything about it. If a call to this method occurs, you'll see a warning in the test output, but it won't be a failure.
+
+# What Now? #
+Congratulations! You've learned enough about Google Mock to start using it. Now, you might want to join the [googlemock](http://groups.google.com/group/googlemock) discussion group and actually write some tests using Google Mock - it will be fun. Hey, it may even be addictive - you've been warned.
+
+Then, if you feel like increasing your mock quotient, you should move on to the [CookBook](V1_6_CookBook.md). You can learn many advanced features of Google Mock there -- and advance your level of enjoyment and testing bliss.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/FrequentlyAskedQuestions.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/FrequentlyAskedQuestions.md
new file mode 100644
index 00000000..f74715d2
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/FrequentlyAskedQuestions.md
@@ -0,0 +1,628 @@
+
+
+Please send your questions to the
+[googlemock](http://groups.google.com/group/googlemock) discussion
+group. If you need help with compiler errors, make sure you have
+tried [Google Mock Doctor](#How_am_I_supposed_to_make_sense_of_these_horrible_template_error.md) first.
+
+## When I call a method on my mock object, the method for the real object is invoked instead.  What's the problem? ##
+
+In order for a method to be mocked, it must be _virtual_, unless you use the [high-perf dependency injection technique](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Mocking_Nonvirtual_Methods).
+
+## I wrote some matchers.  After I upgraded to a new version of Google Mock, they no longer compile.  What's going on? ##
+
+After version 1.4.0 of Google Mock was released, we had an idea on how
+to make it easier to write matchers that can generate informative
+messages efficiently.  We experimented with this idea and liked what
+we saw.  Therefore we decided to implement it.
+
+Unfortunately, this means that if you have defined your own matchers
+by implementing `MatcherInterface` or using `MakePolymorphicMatcher()`,
+your definitions will no longer compile.  Matchers defined using the
+`MATCHER*` family of macros are not affected.
+
+Sorry for the hassle if your matchers are affected.  We believe it's
+in everyone's long-term interest to make this change sooner than
+later.  Fortunately, it's usually not hard to migrate an existing
+matcher to the new API.  Here's what you need to do:
+
+If you wrote your matcher like this:
+```
+// Old matcher definition that doesn't work with the latest
+// Google Mock.
+using ::testing::MatcherInterface;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetFoo() > 5;
+  }
+  ...
+};
+```
+
+you'll need to change it to:
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool MatchAndExplain(MyType value,
+                               MatchResultListener* listener) const {
+    // Returns true if value matches.
+    return value.GetFoo() > 5;
+  }
+  ...
+};
+```
+(i.e. rename `Matches()` to `MatchAndExplain()` and give it a second
+argument of type `MatchResultListener*`.)
+
+If you were also using `ExplainMatchResultTo()` to improve the matcher
+message:
+```
+// Old matcher definition that doesn't work with the lastest
+// Google Mock.
+using ::testing::MatcherInterface;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetFoo() > 5;
+  }
+
+  virtual void ExplainMatchResultTo(MyType value,
+                                    ::std::ostream* os) const {
+    // Prints some helpful information to os to help
+    // a user understand why value matches (or doesn't match).
+    *os << "the Foo property is " << value.GetFoo();
+  }
+  ...
+};
+```
+
+you should move the logic of `ExplainMatchResultTo()` into
+`MatchAndExplain()`, using the `MatchResultListener` argument where
+the `::std::ostream` was used:
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool MatchAndExplain(MyType value,
+                               MatchResultListener* listener) const {
+    // Returns true if value matches.
+    *listener << "the Foo property is " << value.GetFoo();
+    return value.GetFoo() > 5;
+  }
+  ...
+};
+```
+
+If your matcher is defined using `MakePolymorphicMatcher()`:
+```
+// Old matcher definition that doesn't work with the latest
+// Google Mock.
+using ::testing::MakePolymorphicMatcher;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetBar() < 42;
+  }
+  ...
+};
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+you should rename the `Matches()` method to `MatchAndExplain()` and
+add a `MatchResultListener*` argument (the same as what you need to do
+for matchers defined by implementing `MatcherInterface`):
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MakePolymorphicMatcher;
+using ::testing::MatchResultListener;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool MatchAndExplain(MyType value,
+                       MatchResultListener* listener) const {
+    // Returns true if value matches.
+    return value.GetBar() < 42;
+  }
+  ...
+};
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+If your polymorphic matcher uses `ExplainMatchResultTo()` for better
+failure messages:
+```
+// Old matcher definition that doesn't work with the latest
+// Google Mock.
+using ::testing::MakePolymorphicMatcher;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetBar() < 42;
+  }
+  ...
+};
+void ExplainMatchResultTo(const MyGreatMatcher& matcher,
+                          MyType value,
+                          ::std::ostream* os) {
+  // Prints some helpful information to os to help
+  // a user understand why value matches (or doesn't match).
+  *os << "the Bar property is " << value.GetBar();
+}
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+you'll need to move the logic inside `ExplainMatchResultTo()` to
+`MatchAndExplain()`:
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MakePolymorphicMatcher;
+using ::testing::MatchResultListener;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool MatchAndExplain(MyType value,
+                       MatchResultListener* listener) const {
+    // Returns true if value matches.
+    *listener << "the Bar property is " << value.GetBar();
+    return value.GetBar() < 42;
+  }
+  ...
+};
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+For more information, you can read these
+[two](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Writing_New_Monomorphic_Matchers)
+[recipes](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Writing_New_Polymorphic_Matchers)
+from the cookbook.  As always, you
+are welcome to post questions on `googlemock@googlegroups.com` if you
+need any help.
+
+## When using Google Mock, do I have to use Google Test as the testing framework?  I have my favorite testing framework and don't want to switch. ##
+
+Google Mock works out of the box with Google Test.  However, it's easy
+to configure it to work with any testing framework of your choice.
+[Here](http://code.google.com/p/googlemock/wiki/V1_6_ForDummies#Using_Google_Mock_with_Any_Testing_Framework) is how.
+
+## How am I supposed to make sense of these horrible template errors? ##
+
+If you are confused by the compiler errors gcc threw at you,
+try consulting the _Google Mock Doctor_ tool first.  What it does is to
+scan stdin for gcc error messages, and spit out diagnoses on the
+problems (we call them diseases) your code has.
+
+To "install", run command:
+```
+alias gmd='<path to googlemock>/scripts/gmock_doctor.py'
+```
+
+To use it, do:
+```
+<your-favorite-build-command> <your-test> 2>&1 | gmd
+```
+
+For example:
+```
+make my_test 2>&1 | gmd
+```
+
+Or you can run `gmd` and copy-n-paste gcc's error messages to it.
+
+## Can I mock a variadic function? ##
+
+You cannot mock a variadic function (i.e. a function taking ellipsis
+(`...`) arguments) directly in Google Mock.
+
+The problem is that in general, there is _no way_ for a mock object to
+know how many arguments are passed to the variadic method, and what
+the arguments' types are.  Only the _author of the base class_ knows
+the protocol, and we cannot look into his head.
+
+Therefore, to mock such a function, the _user_ must teach the mock
+object how to figure out the number of arguments and their types.  One
+way to do it is to provide overloaded versions of the function.
+
+Ellipsis arguments are inherited from C and not really a C++ feature.
+They are unsafe to use and don't work with arguments that have
+constructors or destructors.  Therefore we recommend to avoid them in
+C++ as much as possible.
+
+## MSVC gives me warning C4301 or C4373 when I define a mock method with a const parameter.  Why? ##
+
+If you compile this using Microsoft Visual C++ 2005 SP1:
+```
+class Foo {
+  ...
+  virtual void Bar(const int i) = 0;
+};
+
+class MockFoo : public Foo {
+  ...
+  MOCK_METHOD1(Bar, void(const int i));
+};
+```
+You may get the following warning:
+```
+warning C4301: 'MockFoo::Bar': overriding virtual function only differs from 'Foo::Bar' by const/volatile qualifier
+```
+
+This is a MSVC bug.  The same code compiles fine with gcc ,for
+example.  If you use Visual C++ 2008 SP1, you would get the warning:
+```
+warning C4373: 'MockFoo::Bar': virtual function overrides 'Foo::Bar', previous versions of the compiler did not override when parameters only differed by const/volatile qualifiers
+```
+
+In C++, if you _declare_ a function with a `const` parameter, the
+`const` modifier is _ignored_.  Therefore, the `Foo` base class above
+is equivalent to:
+```
+class Foo {
+  ...
+  virtual void Bar(int i) = 0;  // int or const int?  Makes no difference.
+};
+```
+
+In fact, you can _declare_ Bar() with an `int` parameter, and _define_
+it with a `const int` parameter.  The compiler will still match them
+up.
+
+Since making a parameter `const` is meaningless in the method
+_declaration_, we recommend to remove it in both `Foo` and `MockFoo`.
+That should workaround the VC bug.
+
+Note that we are talking about the _top-level_ `const` modifier here.
+If the function parameter is passed by pointer or reference, declaring
+the _pointee_ or _referee_ as `const` is still meaningful.  For
+example, the following two declarations are _not_ equivalent:
+```
+void Bar(int* p);        // Neither p nor *p is const.
+void Bar(const int* p);  // p is not const, but *p is.
+```
+
+## I have a huge mock class, and Microsoft Visual C++ runs out of memory when compiling it.  What can I do? ##
+
+We've noticed that when the `/clr` compiler flag is used, Visual C++
+uses 5~6 times as much memory when compiling a mock class.  We suggest
+to avoid `/clr` when compiling native C++ mocks.
+
+## I can't figure out why Google Mock thinks my expectations are not satisfied.  What should I do? ##
+
+You might want to run your test with
+`--gmock_verbose=info`.  This flag lets Google Mock print a trace
+of every mock function call it receives.  By studying the trace,
+you'll gain insights on why the expectations you set are not met.
+
+## How can I assert that a function is NEVER called? ##
+
+```
+EXPECT_CALL(foo, Bar(_))
+    .Times(0);
+```
+
+## I have a failed test where Google Mock tells me TWICE that a particular expectation is not satisfied.  Isn't this redundant? ##
+
+When Google Mock detects a failure, it prints relevant information
+(the mock function arguments, the state of relevant expectations, and
+etc) to help the user debug.  If another failure is detected, Google
+Mock will do the same, including printing the state of relevant
+expectations.
+
+Sometimes an expectation's state didn't change between two failures,
+and you'll see the same description of the state twice.  They are
+however _not_ redundant, as they refer to _different points in time_.
+The fact they are the same _is_ interesting information.
+
+## I get a heap check failure when using a mock object, but using a real object is fine.  What can be wrong? ##
+
+Does the class (hopefully a pure interface) you are mocking have a
+virtual destructor?
+
+Whenever you derive from a base class, make sure its destructor is
+virtual.  Otherwise Bad Things will happen.  Consider the following
+code:
+
+```
+class Base {
+ public:
+  // Not virtual, but should be.
+  ~Base() { ... }
+  ...
+};
+
+class Derived : public Base {
+ public:
+  ...
+ private:
+  std::string value_;
+};
+
+...
+  Base* p = new Derived;
+  ...
+  delete p;  // Surprise! ~Base() will be called, but ~Derived() will not
+             // - value_ is leaked.
+```
+
+By changing `~Base()` to virtual, `~Derived()` will be correctly
+called when `delete p` is executed, and the heap checker
+will be happy.
+
+## The "newer expectations override older ones" rule makes writing expectations awkward.  Why does Google Mock do that? ##
+
+When people complain about this, often they are referring to code like:
+
+```
+// foo.Bar() should be called twice, return 1 the first time, and return
+// 2 the second time.  However, I have to write the expectations in the
+// reverse order.  This sucks big time!!!
+EXPECT_CALL(foo, Bar())
+    .WillOnce(Return(2))
+    .RetiresOnSaturation();
+EXPECT_CALL(foo, Bar())
+    .WillOnce(Return(1))
+    .RetiresOnSaturation();
+```
+
+The problem is that they didn't pick the **best** way to express the test's
+intent.
+
+By default, expectations don't have to be matched in _any_ particular
+order.  If you want them to match in a certain order, you need to be
+explicit.  This is Google Mock's (and jMock's) fundamental philosophy: it's
+easy to accidentally over-specify your tests, and we want to make it
+harder to do so.
+
+There are two better ways to write the test spec.  You could either
+put the expectations in sequence:
+
+```
+// foo.Bar() should be called twice, return 1 the first time, and return
+// 2 the second time.  Using a sequence, we can write the expectations
+// in their natural order.
+{
+  InSequence s;
+  EXPECT_CALL(foo, Bar())
+      .WillOnce(Return(1))
+      .RetiresOnSaturation();
+  EXPECT_CALL(foo, Bar())
+      .WillOnce(Return(2))
+      .RetiresOnSaturation();
+}
+```
+
+or you can put the sequence of actions in the same expectation:
+
+```
+// foo.Bar() should be called twice, return 1 the first time, and return
+// 2 the second time.
+EXPECT_CALL(foo, Bar())
+    .WillOnce(Return(1))
+    .WillOnce(Return(2))
+    .RetiresOnSaturation();
+```
+
+Back to the original questions: why does Google Mock search the
+expectations (and `ON_CALL`s) from back to front?  Because this
+allows a user to set up a mock's behavior for the common case early
+(e.g. in the mock's constructor or the test fixture's set-up phase)
+and customize it with more specific rules later.  If Google Mock
+searches from front to back, this very useful pattern won't be
+possible.
+
+## Google Mock prints a warning when a function without EXPECT\_CALL is called, even if I have set its behavior using ON\_CALL.  Would it be reasonable not to show the warning in this case? ##
+
+When choosing between being neat and being safe, we lean toward the
+latter.  So the answer is that we think it's better to show the
+warning.
+
+Often people write `ON_CALL`s in the mock object's
+constructor or `SetUp()`, as the default behavior rarely changes from
+test to test.  Then in the test body they set the expectations, which
+are often different for each test.  Having an `ON_CALL` in the set-up
+part of a test doesn't mean that the calls are expected.  If there's
+no `EXPECT_CALL` and the method is called, it's possibly an error.  If
+we quietly let the call go through without notifying the user, bugs
+may creep in unnoticed.
+
+If, however, you are sure that the calls are OK, you can write
+
+```
+EXPECT_CALL(foo, Bar(_))
+    .WillRepeatedly(...);
+```
+
+instead of
+
+```
+ON_CALL(foo, Bar(_))
+    .WillByDefault(...);
+```
+
+This tells Google Mock that you do expect the calls and no warning should be
+printed.
+
+Also, you can control the verbosity using the `--gmock_verbose` flag.
+If you find the output too noisy when debugging, just choose a less
+verbose level.
+
+## How can I delete the mock function's argument in an action? ##
+
+If you find yourself needing to perform some action that's not
+supported by Google Mock directly, remember that you can define your own
+actions using
+[MakeAction()](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Writing_New_Actions) or
+[MakePolymorphicAction()](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Writing_New_Polymorphic_Actions),
+or you can write a stub function and invoke it using
+[Invoke()](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Using_Functions_Methods_Functors).
+
+## MOCK\_METHODn()'s second argument looks funny.  Why don't you use the MOCK\_METHODn(Method, return\_type, arg\_1, ..., arg\_n) syntax? ##
+
+What?!  I think it's beautiful. :-)
+
+While which syntax looks more natural is a subjective matter to some
+extent, Google Mock's syntax was chosen for several practical advantages it
+has.
+
+Try to mock a function that takes a map as an argument:
+```
+virtual int GetSize(const map<int, std::string>& m);
+```
+
+Using the proposed syntax, it would be:
+```
+MOCK_METHOD1(GetSize, int, const map<int, std::string>& m);
+```
+
+Guess what?  You'll get a compiler error as the compiler thinks that
+`const map<int, std::string>& m` are **two**, not one, arguments. To work
+around this you can use `typedef` to give the map type a name, but
+that gets in the way of your work.  Google Mock's syntax avoids this
+problem as the function's argument types are protected inside a pair
+of parentheses:
+```
+// This compiles fine.
+MOCK_METHOD1(GetSize, int(const map<int, std::string>& m));
+```
+
+You still need a `typedef` if the return type contains an unprotected
+comma, but that's much rarer.
+
+Other advantages include:
+  1. `MOCK_METHOD1(Foo, int, bool)` can leave a reader wonder whether the method returns `int` or `bool`, while there won't be such confusion using Google Mock's syntax.
+  1. The way Google Mock describes a function type is nothing new, although many people may not be familiar with it.  The same syntax was used in C, and the `function` library in `tr1` uses this syntax extensively.  Since `tr1` will become a part of the new version of STL, we feel very comfortable to be consistent with it.
+  1. The function type syntax is also used in other parts of Google Mock's API (e.g. the action interface) in order to make the implementation tractable. A user needs to learn it anyway in order to utilize Google Mock's more advanced features.  We'd as well stick to the same syntax in `MOCK_METHOD*`!
+
+## My code calls a static/global function.  Can I mock it? ##
+
+You can, but you need to make some changes.
+
+In general, if you find yourself needing to mock a static function,
+it's a sign that your modules are too tightly coupled (and less
+flexible, less reusable, less testable, etc).  You are probably better
+off defining a small interface and call the function through that
+interface, which then can be easily mocked.  It's a bit of work
+initially, but usually pays for itself quickly.
+
+This Google Testing Blog
+[post](http://googletesting.blogspot.com/2008/06/defeat-static-cling.html)
+says it excellently.  Check it out.
+
+## My mock object needs to do complex stuff.  It's a lot of pain to specify the actions.  Google Mock sucks! ##
+
+I know it's not a question, but you get an answer for free any way. :-)
+
+With Google Mock, you can create mocks in C++ easily.  And people might be
+tempted to use them everywhere. Sometimes they work great, and
+sometimes you may find them, well, a pain to use. So, what's wrong in
+the latter case?
+
+When you write a test without using mocks, you exercise the code and
+assert that it returns the correct value or that the system is in an
+expected state.  This is sometimes called "state-based testing".
+
+Mocks are great for what some call "interaction-based" testing:
+instead of checking the system state at the very end, mock objects
+verify that they are invoked the right way and report an error as soon
+as it arises, giving you a handle on the precise context in which the
+error was triggered.  This is often more effective and economical to
+do than state-based testing.
+
+If you are doing state-based testing and using a test double just to
+simulate the real object, you are probably better off using a fake.
+Using a mock in this case causes pain, as it's not a strong point for
+mocks to perform complex actions.  If you experience this and think
+that mocks suck, you are just not using the right tool for your
+problem. Or, you might be trying to solve the wrong problem. :-)
+
+## I got a warning "Uninteresting function call encountered - default action taken.."  Should I panic? ##
+
+By all means, NO!  It's just an FYI.
+
+What it means is that you have a mock function, you haven't set any
+expectations on it (by Google Mock's rule this means that you are not
+interested in calls to this function and therefore it can be called
+any number of times), and it is called.  That's OK - you didn't say
+it's not OK to call the function!
+
+What if you actually meant to disallow this function to be called, but
+forgot to write `EXPECT_CALL(foo, Bar()).Times(0)`?  While
+one can argue that it's the user's fault, Google Mock tries to be nice and
+prints you a note.
+
+So, when you see the message and believe that there shouldn't be any
+uninteresting calls, you should investigate what's going on.  To make
+your life easier, Google Mock prints the function name and arguments
+when an uninteresting call is encountered.
+
+## I want to define a custom action.  Should I use Invoke() or implement the action interface? ##
+
+Either way is fine - you want to choose the one that's more convenient
+for your circumstance.
+
+Usually, if your action is for a particular function type, defining it
+using `Invoke()` should be easier; if your action can be used in
+functions of different types (e.g. if you are defining
+`Return(value)`), `MakePolymorphicAction()` is
+easiest.  Sometimes you want precise control on what types of
+functions the action can be used in, and implementing
+`ActionInterface` is the way to go here. See the implementation of
+`Return()` in `include/gmock/gmock-actions.h` for an example.
+
+## I'm using the set-argument-pointee action, and the compiler complains about "conflicting return type specified".  What does it mean? ##
+
+You got this error as Google Mock has no idea what value it should return
+when the mock method is called.  `SetArgPointee()` says what the
+side effect is, but doesn't say what the return value should be.  You
+need `DoAll()` to chain a `SetArgPointee()` with a `Return()`.
+
+See this [recipe](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Mocking_Side_Effects) for more details and an example.
+
+
+## My question is not in your FAQ! ##
+
+If you cannot find the answer to your question in this FAQ, there are
+some other resources you can use:
+
+  1. read other [wiki pages](http://code.google.com/p/googlemock/w/list),
+  1. search the mailing list [archive](http://groups.google.com/group/googlemock/topics),
+  1. ask it on [googlemock@googlegroups.com](mailto:googlemock@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googlemock) before you can post.).
+
+Please note that creating an issue in the
+[issue tracker](http://code.google.com/p/googlemock/issues/list) is _not_
+a good way to get your answer, as it is monitored infrequently by a
+very small number of people.
+
+When asking a question, it's helpful to provide as much of the
+following information as possible (people cannot help you if there's
+not enough information in your question):
+
+  * the version (or the revision number if you check out from SVN directly) of Google Mock you use (Google Mock is under active development, so it's possible that your problem has been solved in a later version),
+  * your operating system,
+  * the name and version of your compiler,
+  * the complete command line flags you give to your compiler,
+  * the complete compiler error messages (if the question is about compilation),
+  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CheatSheet.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CheatSheet.md
new file mode 100644
index 00000000..db421e51
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CheatSheet.md
@@ -0,0 +1,556 @@
+
+
+# Defining a Mock Class #
+
+## Mocking a Normal Class ##
+
+Given
+```
+class Foo {
+  ...
+  virtual ~Foo();
+  virtual int GetSize() const = 0;
+  virtual string Describe(const char* name) = 0;
+  virtual string Describe(int type) = 0;
+  virtual bool Process(Bar elem, int count) = 0;
+};
+```
+(note that `~Foo()` **must** be virtual) we can define its mock as
+```
+#include "gmock/gmock.h"
+
+class MockFoo : public Foo {
+  MOCK_CONST_METHOD0(GetSize, int());
+  MOCK_METHOD1(Describe, string(const char* name));
+  MOCK_METHOD1(Describe, string(int type));
+  MOCK_METHOD2(Process, bool(Bar elem, int count));
+};
+```
+
+To create a "nice" mock object which ignores all uninteresting calls,
+or a "strict" mock object, which treats them as failures:
+```
+NiceMock<MockFoo> nice_foo;     // The type is a subclass of MockFoo.
+StrictMock<MockFoo> strict_foo; // The type is a subclass of MockFoo.
+```
+
+## Mocking a Class Template ##
+
+To mock
+```
+template <typename Elem>
+class StackInterface {
+ public:
+  ...
+  virtual ~StackInterface();
+  virtual int GetSize() const = 0;
+  virtual void Push(const Elem& x) = 0;
+};
+```
+(note that `~StackInterface()` **must** be virtual) just append `_T` to the `MOCK_*` macros:
+```
+template <typename Elem>
+class MockStack : public StackInterface<Elem> {
+ public:
+  ...
+  MOCK_CONST_METHOD0_T(GetSize, int());
+  MOCK_METHOD1_T(Push, void(const Elem& x));
+};
+```
+
+## Specifying Calling Conventions for Mock Functions ##
+
+If your mock function doesn't use the default calling convention, you
+can specify it by appending `_WITH_CALLTYPE` to any of the macros
+described in the previous two sections and supplying the calling
+convention as the first argument to the macro. For example,
+```
+  MOCK_METHOD_1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int n));
+  MOCK_CONST_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, Bar, int(double x, double y));
+```
+where `STDMETHODCALLTYPE` is defined by `<objbase.h>` on Windows.
+
+# Using Mocks in Tests #
+
+The typical flow is:
+  1. Import the Google Mock names you need to use. All Google Mock names are in the `testing` namespace unless they are macros or otherwise noted.
+  1. Create the mock objects.
+  1. Optionally, set the default actions of the mock objects.
+  1. Set your expectations on the mock objects (How will they be called? What wil they do?).
+  1. Exercise code that uses the mock objects; if necessary, check the result using [Google Test](http://code.google.com/p/googletest/) assertions.
+  1. When a mock objects is destructed, Google Mock automatically verifies that all expectations on it have been satisfied.
+
+Here is an example:
+```
+using ::testing::Return;                            // #1
+
+TEST(BarTest, DoesThis) {
+  MockFoo foo;                                    // #2
+
+  ON_CALL(foo, GetSize())                         // #3
+      .WillByDefault(Return(1));
+  // ... other default actions ...
+
+  EXPECT_CALL(foo, Describe(5))                   // #4
+      .Times(3)
+      .WillRepeatedly(Return("Category 5"));
+  // ... other expectations ...
+
+  EXPECT_EQ("good", MyProductionFunction(&foo));  // #5
+}                                                 // #6
+```
+
+# Setting Default Actions #
+
+Google Mock has a **built-in default action** for any function that
+returns `void`, `bool`, a numeric value, or a pointer.
+
+To customize the default action for functions with return type `T` globally:
+```
+using ::testing::DefaultValue;
+
+DefaultValue<T>::Set(value);  // Sets the default value to be returned.
+// ... use the mocks ...
+DefaultValue<T>::Clear();     // Resets the default value.
+```
+
+To customize the default action for a particular method, use `ON_CALL()`:
+```
+ON_CALL(mock_object, method(matchers))
+    .With(multi_argument_matcher)  ?
+    .WillByDefault(action);
+```
+
+# Setting Expectations #
+
+`EXPECT_CALL()` sets **expectations** on a mock method (How will it be
+called? What will it do?):
+```
+EXPECT_CALL(mock_object, method(matchers))
+    .With(multi_argument_matcher)  ?
+    .Times(cardinality)            ?
+    .InSequence(sequences)         *
+    .After(expectations)           *
+    .WillOnce(action)              *
+    .WillRepeatedly(action)        ?
+    .RetiresOnSaturation();        ?
+```
+
+If `Times()` is omitted, the cardinality is assumed to be:
+
+  * `Times(1)` when there is neither `WillOnce()` nor `WillRepeatedly()`;
+  * `Times(n)` when there are `n WillOnce()`s but no `WillRepeatedly()`, where `n` >= 1; or
+  * `Times(AtLeast(n))` when there are `n WillOnce()`s and a `WillRepeatedly()`, where `n` >= 0.
+
+A method with no `EXPECT_CALL()` is free to be invoked _any number of times_, and the default action will be taken each time.
+
+# Matchers #
+
+A **matcher** matches a _single_ argument.  You can use it inside
+`ON_CALL()` or `EXPECT_CALL()`, or use it to validate a value
+directly:
+
+| `EXPECT_THAT(value, matcher)` | Asserts that `value` matches `matcher`. |
+|:------------------------------|:----------------------------------------|
+| `ASSERT_THAT(value, matcher)` | The same as `EXPECT_THAT(value, matcher)`, except that it generates a **fatal** failure. |
+
+Built-in matchers (where `argument` is the function argument) are
+divided into several categories:
+
+## Wildcard ##
+|`_`|`argument` can be any value of the correct type.|
+|:--|:-----------------------------------------------|
+|`A<type>()` or `An<type>()`|`argument` can be any value of type `type`.     |
+
+## Generic Comparison ##
+
+|`Eq(value)` or `value`|`argument == value`|
+|:---------------------|:------------------|
+|`Ge(value)`           |`argument >= value`|
+|`Gt(value)`           |`argument > value` |
+|`Le(value)`           |`argument <= value`|
+|`Lt(value)`           |`argument < value` |
+|`Ne(value)`           |`argument != value`|
+|`IsNull()`            |`argument` is a `NULL` pointer (raw or smart).|
+|`NotNull()`           |`argument` is a non-null pointer (raw or smart).|
+|`Ref(variable)`       |`argument` is a reference to `variable`.|
+|`TypedEq<type>(value)`|`argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded.|
+
+Except `Ref()`, these matchers make a _copy_ of `value` in case it's
+modified or destructed later. If the compiler complains that `value`
+doesn't have a public copy constructor, try wrap it in `ByRef()`,
+e.g. `Eq(ByRef(non_copyable_value))`. If you do that, make sure
+`non_copyable_value` is not changed afterwards, or the meaning of your
+matcher will be changed.
+
+## Floating-Point Matchers ##
+
+|`DoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as unequal.|
+|:-------------------|:----------------------------------------------------------------------------------------------|
+|`FloatEq(a_float)`  |`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal.  |
+|`NanSensitiveDoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal.  |
+|`NanSensitiveFloatEq(a_float)`|`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal.    |
+
+The above matchers use ULP-based comparison (the same as used in
+[Google Test](http://code.google.com/p/googletest/)). They
+automatically pick a reasonable error bound based on the absolute
+value of the expected value.  `DoubleEq()` and `FloatEq()` conform to
+the IEEE standard, which requires comparing two NaNs for equality to
+return false. The `NanSensitive*` version instead treats two NaNs as
+equal, which is often what a user wants.
+
+|`DoubleNear(a_double, max_abs_error)`|`argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as unequal.|
+|:------------------------------------|:--------------------------------------------------------------------------------------------------------------------|
+|`FloatNear(a_float, max_abs_error)`  |`argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as unequal.  |
+|`NanSensitiveDoubleNear(a_double, max_abs_error)`|`argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as equal.  |
+|`NanSensitiveFloatNear(a_float, max_abs_error)`|`argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as equal.    |
+
+## String Matchers ##
+
+The `argument` can be either a C string or a C++ string object:
+
+|`ContainsRegex(string)`|`argument` matches the given regular expression.|
+|:----------------------|:-----------------------------------------------|
+|`EndsWith(suffix)`     |`argument` ends with string `suffix`.           |
+|`HasSubstr(string)`    |`argument` contains `string` as a sub-string.   |
+|`MatchesRegex(string)` |`argument` matches the given regular expression with the match starting at the first character and ending at the last character.|
+|`StartsWith(prefix)`   |`argument` starts with string `prefix`.         |
+|`StrCaseEq(string)`    |`argument` is equal to `string`, ignoring case. |
+|`StrCaseNe(string)`    |`argument` is not equal to `string`, ignoring case.|
+|`StrEq(string)`        |`argument` is equal to `string`.                |
+|`StrNe(string)`        |`argument` is not equal to `string`.            |
+
+`ContainsRegex()` and `MatchesRegex()` use the regular expression
+syntax defined
+[here](http://code.google.com/p/googletest/wiki/AdvancedGuide#Regular_Expression_Syntax).
+`StrCaseEq()`, `StrCaseNe()`, `StrEq()`, and `StrNe()` work for wide
+strings as well.
+
+## Container Matchers ##
+
+Most STL-style containers support `==`, so you can use
+`Eq(expected_container)` or simply `expected_container` to match a
+container exactly.   If you want to write the elements in-line,
+match them more flexibly, or get more informative messages, you can use:
+
+| `ContainerEq(container)` | The same as `Eq(container)` except that the failure message also includes which elements are in one container but not the other. |
+|:-------------------------|:---------------------------------------------------------------------------------------------------------------------------------|
+| `Contains(e)`            | `argument` contains an element that matches `e`, which can be either a value or a matcher.                                       |
+| `Each(e)`                | `argument` is a container where _every_ element matches `e`, which can be either a value or a matcher.                           |
+| `ElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, where the i-th element matches `ei`, which can be a value or a matcher. 0 to 10 arguments are allowed. |
+| `ElementsAreArray({ e0, e1, ..., en })`, `ElementsAreArray(array)`, or `ElementsAreArray(array, count)` | The same as `ElementsAre()` except that the expected element values/matchers come from an initializer list, vector, or C-style array. |
+| `IsEmpty()`              | `argument` is an empty container (`container.empty()`).                                                                          |
+| `Pointwise(m, container)` | `argument` contains the same number of elements as in `container`, and for all i, (the i-th element in `argument`, the i-th element in `container`) match `m`, which is a matcher on 2-tuples. E.g. `Pointwise(Le(), upper_bounds)` verifies that each element in `argument` doesn't exceed the corresponding element in `upper_bounds`. See more detail below. |
+| `SizeIs(m)`              | `argument` is a container whose size matches `m`. E.g. `SizeIs(2)` or `SizeIs(Lt(2))`.                                           |
+| `UnorderedElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, and under some permutation each element matches an `ei` (for a different `i`), which can be a value or a matcher. 0 to 10 arguments are allowed. |
+| `UnorderedElementsAreArray({ e0, e1, ..., en })`, `UnorderedElementsAreArray(array)`, or `UnorderedElementsAreArray(array, count)` | The same as `UnorderedElementsAre()` except that the expected element values/matchers come from an initializer list, vector, or C-style array. |
+| `WhenSorted(m)`          | When `argument` is sorted using the `<` operator, it matches container matcher `m`. E.g. `WhenSorted(UnorderedElementsAre(1, 2, 3))` verifies that `argument` contains elements `1`, `2`, and `3`, ignoring order. |
+| `WhenSortedBy(comparator, m)` | The same as `WhenSorted(m)`, except that the given comparator instead of `<` is used to sort `argument`. E.g. `WhenSortedBy(std::greater<int>(), ElementsAre(3, 2, 1))`. |
+
+Notes:
+
+  * These matchers can also match:
+    1. a native array passed by reference (e.g. in `Foo(const int (&a)[5])`), and
+    1. an array passed as a pointer and a count (e.g. in `Bar(const T* buffer, int len)` -- see [Multi-argument Matchers](#Multiargument_Matchers.md)).
+  * The array being matched may be multi-dimensional (i.e. its elements can be arrays).
+  * `m` in `Pointwise(m, ...)` should be a matcher for `std::tr1::tuple<T, U>` where `T` and `U` are the element type of the actual container and the expected container, respectively. For example, to compare two `Foo` containers where `Foo` doesn't support `operator==` but has an `Equals()` method, one might write:
+
+```
+using ::std::tr1::get;
+MATCHER(FooEq, "") {
+  return get<0>(arg).Equals(get<1>(arg));
+}
+...
+EXPECT_THAT(actual_foos, Pointwise(FooEq(), expected_foos));
+```
+
+## Member Matchers ##
+
+|`Field(&class::field, m)`|`argument.field` (or `argument->field` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
+|:------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------|
+|`Key(e)`                 |`argument.first` matches `e`, which can be either a value or a matcher. E.g. `Contains(Key(Le(5)))` can verify that a `map` contains a key `<= 5`.|
+|`Pair(m1, m2)`           |`argument` is an `std::pair` whose `first` field matches `m1` and `second` field matches `m2`.                                                |
+|`Property(&class::property, m)`|`argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
+
+## Matching the Result of a Function or Functor ##
+
+|`ResultOf(f, m)`|`f(argument)` matches matcher `m`, where `f` is a function or functor.|
+|:---------------|:---------------------------------------------------------------------|
+
+## Pointer Matchers ##
+
+|`Pointee(m)`|`argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`.|
+|:-----------|:-----------------------------------------------------------------------------------------------|
+
+## Multiargument Matchers ##
+
+Technically, all matchers match a _single_ value. A "multi-argument"
+matcher is just one that matches a _tuple_. The following matchers can
+be used to match a tuple `(x, y)`:
+
+|`Eq()`|`x == y`|
+|:-----|:-------|
+|`Ge()`|`x >= y`|
+|`Gt()`|`x > y` |
+|`Le()`|`x <= y`|
+|`Lt()`|`x < y` |
+|`Ne()`|`x != y`|
+
+You can use the following selectors to pick a subset of the arguments
+(or reorder them) to participate in the matching:
+
+|`AllArgs(m)`|Equivalent to `m`. Useful as syntactic sugar in `.With(AllArgs(m))`.|
+|:-----------|:-------------------------------------------------------------------|
+|`Args<N1, N2, ..., Nk>(m)`|The tuple of the `k` selected (using 0-based indices) arguments matches `m`, e.g. `Args<1, 2>(Eq())`.|
+
+## Composite Matchers ##
+
+You can make a matcher from one or more other matchers:
+
+|`AllOf(m1, m2, ..., mn)`|`argument` matches all of the matchers `m1` to `mn`.|
+|:-----------------------|:---------------------------------------------------|
+|`AnyOf(m1, m2, ..., mn)`|`argument` matches at least one of the matchers `m1` to `mn`.|
+|`Not(m)`                |`argument` doesn't match matcher `m`.               |
+
+## Adapters for Matchers ##
+
+|`MatcherCast<T>(m)`|casts matcher `m` to type `Matcher<T>`.|
+|:------------------|:--------------------------------------|
+|`SafeMatcherCast<T>(m)`| [safely casts](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Casting_Matchers) matcher `m` to type `Matcher<T>`. |
+|`Truly(predicate)` |`predicate(argument)` returns something considered by C++ to be true, where `predicate` is a function or functor.|
+
+## Matchers as Predicates ##
+
+|`Matches(m)(value)`|evaluates to `true` if `value` matches `m`. You can use `Matches(m)` alone as a unary functor.|
+|:------------------|:---------------------------------------------------------------------------------------------|
+|`ExplainMatchResult(m, value, result_listener)`|evaluates to `true` if `value` matches `m`, explaining the result to `result_listener`.       |
+|`Value(value, m)`  |evaluates to `true` if `value` matches `m`.                                                   |
+
+## Defining Matchers ##
+
+| `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. |
+|:-------------------------------------------------|:------------------------------------------------------|
+| `MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; }` | Defines a macher `IsDivisibleBy(n)` to match a number divisible by `n`. |
+| `MATCHER_P2(IsBetween, a, b, std::string(negation ? "isn't" : "is") + " between " + PrintToString(a) + " and " + PrintToString(b)) { return a <= arg && arg <= b; }` | Defines a matcher `IsBetween(a, b)` to match a value in the range [`a`, `b`]. |
+
+**Notes:**
+
+  1. The `MATCHER*` macros cannot be used inside a function or class.
+  1. The matcher body must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters).
+  1. You can use `PrintToString(x)` to convert a value `x` of any type to a string.
+
+## Matchers as Test Assertions ##
+
+|`ASSERT_THAT(expression, m)`|Generates a [fatal failure](http://code.google.com/p/googletest/wiki/Primer#Assertions) if the value of `expression` doesn't match matcher `m`.|
+|:---------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------|
+|`EXPECT_THAT(expression, m)`|Generates a non-fatal failure if the value of `expression` doesn't match matcher `m`.                                                          |
+
+# Actions #
+
+**Actions** specify what a mock function should do when invoked.
+
+## Returning a Value ##
+
+|`Return()`|Return from a `void` mock function.|
+|:---------|:----------------------------------|
+|`Return(value)`|Return `value`. If the type of `value` is different to the mock function's return type, `value` is converted to the latter type <i>at the time the expectation is set</i>, not when the action is executed.|
+|`ReturnArg<N>()`|Return the `N`-th (0-based) argument.|
+|`ReturnNew<T>(a1, ..., ak)`|Return `new T(a1, ..., ak)`; a different object is created each time.|
+|`ReturnNull()`|Return a null pointer.             |
+|`ReturnPointee(ptr)`|Return the value pointed to by `ptr`.|
+|`ReturnRef(variable)`|Return a reference to `variable`.  |
+|`ReturnRefOfCopy(value)`|Return a reference to a copy of `value`; the copy lives as long as the action.|
+
+## Side Effects ##
+
+|`Assign(&variable, value)`|Assign `value` to variable.|
+|:-------------------------|:--------------------------|
+| `DeleteArg<N>()`         | Delete the `N`-th (0-based) argument, which must be a pointer. |
+| `SaveArg<N>(pointer)`    | Save the `N`-th (0-based) argument to `*pointer`. |
+| `SaveArgPointee<N>(pointer)` | Save the value pointed to by the `N`-th (0-based) argument to `*pointer`. |
+| `SetArgReferee<N>(value)` |	Assign value to the variable referenced by the `N`-th (0-based) argument. |
+|`SetArgPointee<N>(value)` |Assign `value` to the variable pointed by the `N`-th (0-based) argument.|
+|`SetArgumentPointee<N>(value)`|Same as `SetArgPointee<N>(value)`. Deprecated. Will be removed in v1.7.0.|
+|`SetArrayArgument<N>(first, last)`|Copies the elements in source range [`first`, `last`) to the array pointed to by the `N`-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.|
+|`SetErrnoAndReturn(error, value)`|Set `errno` to `error` and return `value`.|
+|`Throw(exception)`        |Throws the given exception, which can be any copyable value. Available since v1.1.0.|
+
+## Using a Function or a Functor as an Action ##
+
+|`Invoke(f)`|Invoke `f` with the arguments passed to the mock function, where `f` can be a global/static function or a functor.|
+|:----------|:-----------------------------------------------------------------------------------------------------------------|
+|`Invoke(object_pointer, &class::method)`|Invoke the {method on the object with the arguments passed to the mock function.                                  |
+|`InvokeWithoutArgs(f)`|Invoke `f`, which can be a global/static function or a functor. `f` must take no arguments.                       |
+|`InvokeWithoutArgs(object_pointer, &class::method)`|Invoke the method on the object, which takes no arguments.                                                        |
+|`InvokeArgument<N>(arg1, arg2, ..., argk)`|Invoke the mock function's `N`-th (0-based) argument, which must be a function or a functor, with the `k` arguments.|
+
+The return value of the invoked function is used as the return value
+of the action.
+
+When defining a function or functor to be used with `Invoke*()`, you can declare any unused parameters as `Unused`:
+```
+  double Distance(Unused, double x, double y) { return sqrt(x*x + y*y); }
+  ...
+  EXPECT_CALL(mock, Foo("Hi", _, _)).WillOnce(Invoke(Distance));
+```
+
+In `InvokeArgument<N>(...)`, if an argument needs to be passed by reference, wrap it inside `ByRef()`. For example,
+```
+  InvokeArgument<2>(5, string("Hi"), ByRef(foo))
+```
+calls the mock function's #2 argument, passing to it `5` and `string("Hi")` by value, and `foo` by reference.
+
+## Default Action ##
+
+|`DoDefault()`|Do the default action (specified by `ON_CALL()` or the built-in one).|
+|:------------|:--------------------------------------------------------------------|
+
+**Note:** due to technical reasons, `DoDefault()` cannot be used inside  a composite action - trying to do so will result in a run-time error.
+
+## Composite Actions ##
+
+|`DoAll(a1, a2, ..., an)`|Do all actions `a1` to `an` and return the result of `an` in each invocation. The first `n - 1` sub-actions must return void. |
+|:-----------------------|:-----------------------------------------------------------------------------------------------------------------------------|
+|`IgnoreResult(a)`       |Perform action `a` and ignore its result. `a` must not return void.                                                           |
+|`WithArg<N>(a)`         |Pass the `N`-th (0-based) argument of the mock function to action `a` and perform it.                                         |
+|`WithArgs<N1, N2, ..., Nk>(a)`|Pass the selected (0-based) arguments of the mock function to action `a` and perform it.                                      |
+|`WithoutArgs(a)`        |Perform action `a` without any arguments.                                                                                     |
+
+## Defining Actions ##
+
+| `ACTION(Sum) { return arg0 + arg1; }` | Defines an action `Sum()` to return the sum of the mock function's argument #0 and #1. |
+|:--------------------------------------|:---------------------------------------------------------------------------------------|
+| `ACTION_P(Plus, n) { return arg0 + n; }` | Defines an action `Plus(n)` to return the sum of the mock function's argument #0 and `n`. |
+| `ACTION_Pk(Foo, p1, ..., pk) { statements; }` | Defines a parameterized action `Foo(p1, ..., pk)` to execute the given `statements`.   |
+
+The `ACTION*` macros cannot be used inside a function or class.
+
+# Cardinalities #
+
+These are used in `Times()` to specify how many times a mock function will be called:
+
+|`AnyNumber()`|The function can be called any number of times.|
+|:------------|:----------------------------------------------|
+|`AtLeast(n)` |The call is expected at least `n` times.       |
+|`AtMost(n)`  |The call is expected at most `n` times.        |
+|`Between(m, n)`|The call is expected between `m` and `n` (inclusive) times.|
+|`Exactly(n) or n`|The call is expected exactly `n` times. In particular, the call should never happen when `n` is 0.|
+
+# Expectation Order #
+
+By default, the expectations can be matched in _any_ order.  If some
+or all expectations must be matched in a given order, there are two
+ways to specify it.  They can be used either independently or
+together.
+
+## The After Clause ##
+
+```
+using ::testing::Expectation;
+...
+Expectation init_x = EXPECT_CALL(foo, InitX());
+Expectation init_y = EXPECT_CALL(foo, InitY());
+EXPECT_CALL(foo, Bar())
+    .After(init_x, init_y);
+```
+says that `Bar()` can be called only after both `InitX()` and
+`InitY()` have been called.
+
+If you don't know how many pre-requisites an expectation has when you
+write it, you can use an `ExpectationSet` to collect them:
+
+```
+using ::testing::ExpectationSet;
+...
+ExpectationSet all_inits;
+for (int i = 0; i < element_count; i++) {
+  all_inits += EXPECT_CALL(foo, InitElement(i));
+}
+EXPECT_CALL(foo, Bar())
+    .After(all_inits);
+```
+says that `Bar()` can be called only after all elements have been
+initialized (but we don't care about which elements get initialized
+before the others).
+
+Modifying an `ExpectationSet` after using it in an `.After()` doesn't
+affect the meaning of the `.After()`.
+
+## Sequences ##
+
+When you have a long chain of sequential expectations, it's easier to
+specify the order using **sequences**, which don't require you to given
+each expectation in the chain a different name.  <i>All expected<br>
+calls</i> in the same sequence must occur in the order they are
+specified.
+
+```
+using ::testing::Sequence;
+Sequence s1, s2;
+...
+EXPECT_CALL(foo, Reset())
+    .InSequence(s1, s2)
+    .WillOnce(Return(true));
+EXPECT_CALL(foo, GetSize())
+    .InSequence(s1)
+    .WillOnce(Return(1));
+EXPECT_CALL(foo, Describe(A<const char*>()))
+    .InSequence(s2)
+    .WillOnce(Return("dummy"));
+```
+says that `Reset()` must be called before _both_ `GetSize()` _and_
+`Describe()`, and the latter two can occur in any order.
+
+To put many expectations in a sequence conveniently:
+```
+using ::testing::InSequence;
+{
+  InSequence dummy;
+
+  EXPECT_CALL(...)...;
+  EXPECT_CALL(...)...;
+  ...
+  EXPECT_CALL(...)...;
+}
+```
+says that all expected calls in the scope of `dummy` must occur in
+strict order. The name `dummy` is irrelevant.)
+
+# Verifying and Resetting a Mock #
+
+Google Mock will verify the expectations on a mock object when it is destructed, or you can do it earlier:
+```
+using ::testing::Mock;
+...
+// Verifies and removes the expectations on mock_obj;
+// returns true iff successful.
+Mock::VerifyAndClearExpectations(&mock_obj);
+...
+// Verifies and removes the expectations on mock_obj;
+// also removes the default actions set by ON_CALL();
+// returns true iff successful.
+Mock::VerifyAndClear(&mock_obj);
+```
+
+You can also tell Google Mock that a mock object can be leaked and doesn't
+need to be verified:
+```
+Mock::AllowLeak(&mock_obj);
+```
+
+# Mock Classes #
+
+Google Mock defines a convenient mock class template
+```
+class MockFunction<R(A1, ..., An)> {
+ public:
+  MOCK_METHODn(Call, R(A1, ..., An));
+};
+```
+See this [recipe](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Using_Check_Points) for one application of it.
+
+# Flags #
+
+| `--gmock_catch_leaked_mocks=0` | Don't report leaked mock objects as failures. |
+|:-------------------------------|:----------------------------------------------|
+| `--gmock_verbose=LEVEL`        | Sets the default verbosity level (`info`, `warning`, or `error`) of Google Mock messages. |
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CookBook.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CookBook.md
new file mode 100644
index 00000000..419a0010
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CookBook.md
@@ -0,0 +1,3432 @@
+
+
+You can find recipes for using Google Mock here. If you haven't yet,
+please read the [ForDummies](V1_7_ForDummies.md) document first to make sure you understand
+the basics.
+
+**Note:** Google Mock lives in the `testing` name space. For
+readability, it is recommended to write `using ::testing::Foo;` once in
+your file before using the name `Foo` defined by Google Mock. We omit
+such `using` statements in this page for brevity, but you should do it
+in your own code.
+
+# Creating Mock Classes #
+
+## Mocking Private or Protected Methods ##
+
+You must always put a mock method definition (`MOCK_METHOD*`) in a
+`public:` section of the mock class, regardless of the method being
+mocked being `public`, `protected`, or `private` in the base class.
+This allows `ON_CALL` and `EXPECT_CALL` to reference the mock function
+from outside of the mock class.  (Yes, C++ allows a subclass to change
+the access level of a virtual function in the base class.)  Example:
+
+```
+class Foo {
+ public:
+  ...
+  virtual bool Transform(Gadget* g) = 0;
+
+ protected:
+  virtual void Resume();
+
+ private:
+  virtual int GetTimeOut();
+};
+
+class MockFoo : public Foo {
+ public:
+  ...
+  MOCK_METHOD1(Transform, bool(Gadget* g));
+
+  // The following must be in the public section, even though the
+  // methods are protected or private in the base class.
+  MOCK_METHOD0(Resume, void());
+  MOCK_METHOD0(GetTimeOut, int());
+};
+```
+
+## Mocking Overloaded Methods ##
+
+You can mock overloaded functions as usual. No special attention is required:
+
+```
+class Foo {
+  ...
+
+  // Must be virtual as we'll inherit from Foo.
+  virtual ~Foo();
+
+  // Overloaded on the types and/or numbers of arguments.
+  virtual int Add(Element x);
+  virtual int Add(int times, Element x);
+
+  // Overloaded on the const-ness of this object.
+  virtual Bar& GetBar();
+  virtual const Bar& GetBar() const;
+};
+
+class MockFoo : public Foo {
+  ...
+  MOCK_METHOD1(Add, int(Element x));
+  MOCK_METHOD2(Add, int(int times, Element x);
+
+  MOCK_METHOD0(GetBar, Bar&());
+  MOCK_CONST_METHOD0(GetBar, const Bar&());
+};
+```
+
+**Note:** if you don't mock all versions of the overloaded method, the
+compiler will give you a warning about some methods in the base class
+being hidden. To fix that, use `using` to bring them in scope:
+
+```
+class MockFoo : public Foo {
+  ...
+  using Foo::Add;
+  MOCK_METHOD1(Add, int(Element x));
+  // We don't want to mock int Add(int times, Element x);
+  ...
+};
+```
+
+## Mocking Class Templates ##
+
+To mock a class template, append `_T` to the `MOCK_*` macros:
+
+```
+template <typename Elem>
+class StackInterface {
+  ...
+  // Must be virtual as we'll inherit from StackInterface.
+  virtual ~StackInterface();
+
+  virtual int GetSize() const = 0;
+  virtual void Push(const Elem& x) = 0;
+};
+
+template <typename Elem>
+class MockStack : public StackInterface<Elem> {
+  ...
+  MOCK_CONST_METHOD0_T(GetSize, int());
+  MOCK_METHOD1_T(Push, void(const Elem& x));
+};
+```
+
+## Mocking Nonvirtual Methods ##
+
+Google Mock can mock non-virtual functions to be used in what we call _hi-perf
+dependency injection_.
+
+In this case, instead of sharing a common base class with the real
+class, your mock class will be _unrelated_ to the real class, but
+contain methods with the same signatures.  The syntax for mocking
+non-virtual methods is the _same_ as mocking virtual methods:
+
+```
+// A simple packet stream class.  None of its members is virtual.
+class ConcretePacketStream {
+ public:
+  void AppendPacket(Packet* new_packet);
+  const Packet* GetPacket(size_t packet_number) const;
+  size_t NumberOfPackets() const;
+  ...
+};
+
+// A mock packet stream class.  It inherits from no other, but defines
+// GetPacket() and NumberOfPackets().
+class MockPacketStream {
+ public:
+  MOCK_CONST_METHOD1(GetPacket, const Packet*(size_t packet_number));
+  MOCK_CONST_METHOD0(NumberOfPackets, size_t());
+  ...
+};
+```
+
+Note that the mock class doesn't define `AppendPacket()`, unlike the
+real class. That's fine as long as the test doesn't need to call it.
+
+Next, you need a way to say that you want to use
+`ConcretePacketStream` in production code, and use `MockPacketStream`
+in tests.  Since the functions are not virtual and the two classes are
+unrelated, you must specify your choice at _compile time_ (as opposed
+to run time).
+
+One way to do it is to templatize your code that needs to use a packet
+stream.  More specifically, you will give your code a template type
+argument for the type of the packet stream.  In production, you will
+instantiate your template with `ConcretePacketStream` as the type
+argument.  In tests, you will instantiate the same template with
+`MockPacketStream`.  For example, you may write:
+
+```
+template <class PacketStream>
+void CreateConnection(PacketStream* stream) { ... }
+
+template <class PacketStream>
+class PacketReader {
+ public:
+  void ReadPackets(PacketStream* stream, size_t packet_num);
+};
+```
+
+Then you can use `CreateConnection<ConcretePacketStream>()` and
+`PacketReader<ConcretePacketStream>` in production code, and use
+`CreateConnection<MockPacketStream>()` and
+`PacketReader<MockPacketStream>` in tests.
+
+```
+  MockPacketStream mock_stream;
+  EXPECT_CALL(mock_stream, ...)...;
+  .. set more expectations on mock_stream ...
+  PacketReader<MockPacketStream> reader(&mock_stream);
+  ... exercise reader ...
+```
+
+## Mocking Free Functions ##
+
+It's possible to use Google Mock to mock a free function (i.e. a
+C-style function or a static method).  You just need to rewrite your
+code to use an interface (abstract class).
+
+Instead of calling a free function (say, `OpenFile`) directly,
+introduce an interface for it and have a concrete subclass that calls
+the free function:
+
+```
+class FileInterface {
+ public:
+  ...
+  virtual bool Open(const char* path, const char* mode) = 0;
+};
+
+class File : public FileInterface {
+ public:
+  ...
+  virtual bool Open(const char* path, const char* mode) {
+    return OpenFile(path, mode);
+  }
+};
+```
+
+Your code should talk to `FileInterface` to open a file.  Now it's
+easy to mock out the function.
+
+This may seem much hassle, but in practice you often have multiple
+related functions that you can put in the same interface, so the
+per-function syntactic overhead will be much lower.
+
+If you are concerned about the performance overhead incurred by
+virtual functions, and profiling confirms your concern, you can
+combine this with the recipe for [mocking non-virtual methods](#Mocking_Nonvirtual_Methods.md).
+
+## The Nice, the Strict, and the Naggy ##
+
+If a mock method has no `EXPECT_CALL` spec but is called, Google Mock
+will print a warning about the "uninteresting call". The rationale is:
+
+  * New methods may be added to an interface after a test is written. We shouldn't fail a test just because a method it doesn't know about is called.
+  * However, this may also mean there's a bug in the test, so Google Mock shouldn't be silent either. If the user believes these calls are harmless, he can add an `EXPECT_CALL()` to suppress the warning.
+
+However, sometimes you may want to suppress all "uninteresting call"
+warnings, while sometimes you may want the opposite, i.e. to treat all
+of them as errors. Google Mock lets you make the decision on a
+per-mock-object basis.
+
+Suppose your test uses a mock class `MockFoo`:
+
+```
+TEST(...) {
+  MockFoo mock_foo;
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+}
+```
+
+If a method of `mock_foo` other than `DoThis()` is called, it will be
+reported by Google Mock as a warning. However, if you rewrite your
+test to use `NiceMock<MockFoo>` instead, the warning will be gone,
+resulting in a cleaner test output:
+
+```
+using ::testing::NiceMock;
+
+TEST(...) {
+  NiceMock<MockFoo> mock_foo;
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+}
+```
+
+`NiceMock<MockFoo>` is a subclass of `MockFoo`, so it can be used
+wherever `MockFoo` is accepted.
+
+It also works if `MockFoo`'s constructor takes some arguments, as
+`NiceMock<MockFoo>` "inherits" `MockFoo`'s constructors:
+
+```
+using ::testing::NiceMock;
+
+TEST(...) {
+  NiceMock<MockFoo> mock_foo(5, "hi");  // Calls MockFoo(5, "hi").
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+}
+```
+
+The usage of `StrictMock` is similar, except that it makes all
+uninteresting calls failures:
+
+```
+using ::testing::StrictMock;
+
+TEST(...) {
+  StrictMock<MockFoo> mock_foo;
+  EXPECT_CALL(mock_foo, DoThis());
+  ... code that uses mock_foo ...
+
+  // The test will fail if a method of mock_foo other than DoThis()
+  // is called.
+}
+```
+
+There are some caveats though (I don't like them just as much as the
+next guy, but sadly they are side effects of C++'s limitations):
+
+  1. `NiceMock<MockFoo>` and `StrictMock<MockFoo>` only work 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` and `StrictMock` (e.g. `NiceMock<StrictMock<MockFoo> >`) is **not** supported.
+  1. The constructors of the base mock (`MockFoo`) cannot have arguments passed by non-const reference, which happens to be banned by the [Google C++ style guide](http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml).
+  1. During the constructor or destructor of `MockFoo`, the mock object is _not_ nice or strict.  This may cause surprises if the constructor or destructor calls a mock method on `this` object. (This behavior, however, is consistent with C++'s general rule: if a constructor or destructor calls a virtual method of `this` object, that method is treated as non-virtual.  In other words, to the base class's constructor or destructor, `this` object behaves like an instance of the base class, not the derived class.  This rule is required for safety.  Otherwise a base constructor may use members of a derived class before they are initialized, or a base destructor may use members of a derived class after they have been destroyed.)
+
+Finally, you should be **very cautious** about when to use naggy or strict mocks, as they tend to make tests more brittle and harder to maintain. When you refactor your code without changing its externally visible behavior, ideally you should't need to update any tests. If your code interacts with a naggy mock, however, you may start to get spammed with warnings as the result of your change. Worse, if your code interacts with a strict mock, your tests may start to fail and you'll be forced to fix them. Our general recommendation is to use nice mocks (not yet the default) most of the time, use naggy mocks (the current default) when developing or debugging tests, and use strict mocks only as the last resort.
+
+## Simplifying the Interface without Breaking Existing Code ##
+
+Sometimes a method has a long list of arguments that is mostly
+uninteresting. For example,
+
+```
+class LogSink {
+ public:
+  ...
+  virtual void send(LogSeverity severity, const char* full_filename,
+                    const char* base_filename, int line,
+                    const struct tm* tm_time,
+                    const char* message, size_t message_len) = 0;
+};
+```
+
+This method's argument list is lengthy and hard to work with (let's
+say that the `message` argument is not even 0-terminated). If we mock
+it as is, using the mock will be awkward. If, however, we try to
+simplify this interface, we'll need to fix all clients depending on
+it, which is often infeasible.
+
+The trick is to re-dispatch the method in the mock class:
+
+```
+class ScopedMockLog : public LogSink {
+ public:
+  ...
+  virtual void send(LogSeverity severity, const char* full_filename,
+                    const char* base_filename, int line, const tm* tm_time,
+                    const char* message, size_t message_len) {
+    // We are only interested in the log severity, full file name, and
+    // log message.
+    Log(severity, full_filename, std::string(message, message_len));
+  }
+
+  // Implements the mock method:
+  //
+  //   void Log(LogSeverity severity,
+  //            const string& file_path,
+  //            const string& message);
+  MOCK_METHOD3(Log, void(LogSeverity severity, const string& file_path,
+                         const string& message));
+};
+```
+
+By defining a new mock method with a trimmed argument list, we make
+the mock class much more user-friendly.
+
+## Alternative to Mocking Concrete Classes ##
+
+Often you may find yourself using classes that don't implement
+interfaces. In order to test your code that uses such a class (let's
+call it `Concrete`), you may be tempted to make the methods of
+`Concrete` virtual and then mock it.
+
+Try not to do that.
+
+Making a non-virtual function virtual is a big decision. It creates an
+extension point where subclasses can tweak your class' behavior. This
+weakens your control on the class because now it's harder to maintain
+the class' invariants. You should make a function virtual only when
+there is a valid reason for a subclass to override it.
+
+Mocking concrete classes directly is problematic as it creates a tight
+coupling between the class and the tests - any small change in the
+class may invalidate your tests and make test maintenance a pain.
+
+To avoid such problems, many programmers have been practicing "coding
+to interfaces": instead of talking to the `Concrete` class, your code
+would define an interface and talk to it. Then you implement that
+interface as an adaptor on top of `Concrete`. In tests, you can easily
+mock that interface to observe how your code is doing.
+
+This technique incurs some overhead:
+
+  * You pay the cost of virtual function calls (usually not a problem).
+  * There is more abstraction for the programmers to learn.
+
+However, it can also bring significant benefits in addition to better
+testability:
+
+  * `Concrete`'s API may not fit your problem domain very well, as you may not be the only client it tries to serve. By designing your own interface, you have a chance to tailor it to your need - you may add higher-level functionalities, rename stuff, etc instead of just trimming the class. This allows you to write your code (user of the interface) in a more natural way, which means it will be more readable, more maintainable, and you'll be more productive.
+  * If `Concrete`'s implementation ever has to change, you don't have to rewrite everywhere it is used. Instead, you can absorb the change in your implementation of the interface, and your other code and tests will be insulated from this change.
+
+Some people worry that if everyone is practicing this technique, they
+will end up writing lots of redundant code. This concern is totally
+understandable. However, there are two reasons why it may not be the
+case:
+
+  * Different projects may need to use `Concrete` in different ways, so the best interfaces for them will be different. Therefore, each of them will have its own domain-specific interface on top of `Concrete`, and they will not be the same code.
+  * If enough projects want to use the same interface, they can always share it, just like they have been sharing `Concrete`. You can check in the interface and the adaptor somewhere near `Concrete` (perhaps in a `contrib` sub-directory) and let many projects use it.
+
+You need to weigh the pros and cons carefully for your particular
+problem, but I'd like to assure you that the Java community has been
+practicing this for a long time and it's a proven effective technique
+applicable in a wide variety of situations. :-)
+
+## Delegating Calls to a Fake ##
+
+Some times you have a non-trivial fake implementation of an
+interface. For example:
+
+```
+class Foo {
+ public:
+  virtual ~Foo() {}
+  virtual char DoThis(int n) = 0;
+  virtual void DoThat(const char* s, int* p) = 0;
+};
+
+class FakeFoo : public Foo {
+ public:
+  virtual char DoThis(int n) {
+    return (n > 0) ? '+' :
+        (n < 0) ? '-' : '0';
+  }
+
+  virtual void DoThat(const char* s, int* p) {
+    *p = strlen(s);
+  }
+};
+```
+
+Now you want to mock this interface such that you can set expectations
+on it. However, you also want to use `FakeFoo` for the default
+behavior, as duplicating it in the mock object is, well, a lot of
+work.
+
+When you define the mock class using Google Mock, you can have it
+delegate its default action to a fake class you already have, using
+this pattern:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+class MockFoo : public Foo {
+ public:
+  // Normal mock method definitions using Google Mock.
+  MOCK_METHOD1(DoThis, char(int n));
+  MOCK_METHOD2(DoThat, void(const char* s, int* p));
+
+  // Delegates the default actions of the methods to a FakeFoo object.
+  // This must be called *before* the custom ON_CALL() statements.
+  void DelegateToFake() {
+    ON_CALL(*this, DoThis(_))
+        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThis));
+    ON_CALL(*this, DoThat(_, _))
+        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThat));
+  }
+ private:
+  FakeFoo fake_;  // Keeps an instance of the fake in the mock.
+};
+```
+
+With that, you can use `MockFoo` in your tests as usual. Just remember
+that if you don't explicitly set an action in an `ON_CALL()` or
+`EXPECT_CALL()`, the fake will be called upon to do it:
+
+```
+using ::testing::_;
+
+TEST(AbcTest, Xyz) {
+  MockFoo foo;
+  foo.DelegateToFake(); // Enables the fake for delegation.
+
+  // Put your ON_CALL(foo, ...)s here, if any.
+
+  // No action specified, meaning to use the default action.
+  EXPECT_CALL(foo, DoThis(5));
+  EXPECT_CALL(foo, DoThat(_, _));
+
+  int n = 0;
+  EXPECT_EQ('+', foo.DoThis(5));  // FakeFoo::DoThis() is invoked.
+  foo.DoThat("Hi", &n);           // FakeFoo::DoThat() is invoked.
+  EXPECT_EQ(2, n);
+}
+```
+
+**Some tips:**
+
+  * If you want, you can still override the default action by providing your own `ON_CALL()` or using `.WillOnce()` / `.WillRepeatedly()` in `EXPECT_CALL()`.
+  * In `DelegateToFake()`, you only need to delegate the methods whose fake implementation you intend to use.
+  * The general technique discussed here works for overloaded methods, but you'll need to tell the compiler which version you mean. To disambiguate a mock function (the one you specify inside the parentheses of `ON_CALL()`), see the "Selecting Between Overloaded Functions" section on this page; to disambiguate a fake function (the one you place inside `Invoke()`), use a `static_cast` to specify the function's type. For instance, if class `Foo` has methods `char DoThis(int n)` and `bool DoThis(double x) const`, and you want to invoke the latter, you need to write `Invoke(&fake_, static_cast<bool (FakeFoo::*)(double) const>(&FakeFoo::DoThis))` instead of `Invoke(&fake_, &FakeFoo::DoThis)` (The strange-looking thing inside the angled brackets of `static_cast` is the type of a function pointer to the second `DoThis()` method.).
+  * Having to mix a mock and a fake is often a sign of something gone wrong. Perhaps you haven't got used to the interaction-based way of testing yet. Or perhaps your interface is taking on too many roles and should be split up. Therefore, **don't abuse this**. We would only recommend to do it as an intermediate step when you are refactoring your code.
+
+Regarding the tip on mixing a mock and a fake, here's an example on
+why it may be a bad sign: Suppose you have a class `System` for
+low-level system operations. In particular, it does file and I/O
+operations. And suppose you want to test how your code uses `System`
+to do I/O, and you just want the file operations to work normally. If
+you mock out the entire `System` class, you'll have to provide a fake
+implementation for the file operation part, which suggests that
+`System` is taking on too many roles.
+
+Instead, you can define a `FileOps` interface and an `IOOps` interface
+and split `System`'s functionalities into the two. Then you can mock
+`IOOps` without mocking `FileOps`.
+
+## Delegating Calls to a Real Object ##
+
+When using testing doubles (mocks, fakes, stubs, and etc), sometimes
+their behaviors will differ from those of the real objects. This
+difference could be either intentional (as in simulating an error such
+that you can test the error handling code) or unintentional. If your
+mocks have different behaviors than the real objects by mistake, you
+could end up with code that passes the tests but fails in production.
+
+You can use the _delegating-to-real_ technique to ensure that your
+mock has the same behavior as the real object while retaining the
+ability to validate calls. This technique is very similar to the
+delegating-to-fake technique, the difference being that we use a real
+object instead of a fake. Here's an example:
+
+```
+using ::testing::_;
+using ::testing::AtLeast;
+using ::testing::Invoke;
+
+class MockFoo : public Foo {
+ public:
+  MockFoo() {
+    // By default, all calls are delegated to the real object.
+    ON_CALL(*this, DoThis())
+        .WillByDefault(Invoke(&real_, &Foo::DoThis));
+    ON_CALL(*this, DoThat(_))
+        .WillByDefault(Invoke(&real_, &Foo::DoThat));
+    ...
+  }
+  MOCK_METHOD0(DoThis, ...);
+  MOCK_METHOD1(DoThat, ...);
+  ...
+ private:
+  Foo real_;
+};
+...
+
+  MockFoo mock;
+
+  EXPECT_CALL(mock, DoThis())
+      .Times(3);
+  EXPECT_CALL(mock, DoThat("Hi"))
+      .Times(AtLeast(1));
+  ... use mock in test ...
+```
+
+With this, Google Mock will verify that your code made the right calls
+(with the right arguments, in the right order, called the right number
+of times, etc), and a real object will answer the calls (so the
+behavior will be the same as in production). This gives you the best
+of both worlds.
+
+## Delegating Calls to a Parent Class ##
+
+Ideally, you should code to interfaces, whose methods are all pure
+virtual. In reality, sometimes you do need to mock a virtual method
+that is not pure (i.e, it already has an implementation). For example:
+
+```
+class Foo {
+ public:
+  virtual ~Foo();
+
+  virtual void Pure(int n) = 0;
+  virtual int Concrete(const char* str) { ... }
+};
+
+class MockFoo : public Foo {
+ public:
+  // Mocking a pure method.
+  MOCK_METHOD1(Pure, void(int n));
+  // Mocking a concrete method.  Foo::Concrete() is shadowed.
+  MOCK_METHOD1(Concrete, int(const char* str));
+};
+```
+
+Sometimes you may want to call `Foo::Concrete()` instead of
+`MockFoo::Concrete()`. Perhaps you want to do it as part of a stub
+action, or perhaps your test doesn't need to mock `Concrete()` at all
+(but it would be oh-so painful to have to define a new mock class
+whenever you don't need to mock one of its methods).
+
+The trick is to leave a back door in your mock class for accessing the
+real methods in the base class:
+
+```
+class MockFoo : public Foo {
+ public:
+  // Mocking a pure method.
+  MOCK_METHOD1(Pure, void(int n));
+  // Mocking a concrete method.  Foo::Concrete() is shadowed.
+  MOCK_METHOD1(Concrete, int(const char* str));
+
+  // Use this to call Concrete() defined in Foo.
+  int FooConcrete(const char* str) { return Foo::Concrete(str); }
+};
+```
+
+Now, you can call `Foo::Concrete()` inside an action by:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+...
+  EXPECT_CALL(foo, Concrete(_))
+      .WillOnce(Invoke(&foo, &MockFoo::FooConcrete));
+```
+
+or tell the mock object that you don't want to mock `Concrete()`:
+
+```
+using ::testing::Invoke;
+...
+  ON_CALL(foo, Concrete(_))
+      .WillByDefault(Invoke(&foo, &MockFoo::FooConcrete));
+```
+
+(Why don't we just write `Invoke(&foo, &Foo::Concrete)`? If you do
+that, `MockFoo::Concrete()` will be called (and cause an infinite
+recursion) since `Foo::Concrete()` is virtual. That's just how C++
+works.)
+
+# Using Matchers #
+
+## Matching Argument Values Exactly ##
+
+You can specify exactly which arguments a mock method is expecting:
+
+```
+using ::testing::Return;
+...
+  EXPECT_CALL(foo, DoThis(5))
+      .WillOnce(Return('a'));
+  EXPECT_CALL(foo, DoThat("Hello", bar));
+```
+
+## Using Simple Matchers ##
+
+You can use matchers to match arguments that have a certain property:
+
+```
+using ::testing::Ge;
+using ::testing::NotNull;
+using ::testing::Return;
+...
+  EXPECT_CALL(foo, DoThis(Ge(5)))  // The argument must be >= 5.
+      .WillOnce(Return('a'));
+  EXPECT_CALL(foo, DoThat("Hello", NotNull()));
+  // The second argument must not be NULL.
+```
+
+A frequently used matcher is `_`, which matches anything:
+
+```
+using ::testing::_;
+using ::testing::NotNull;
+...
+  EXPECT_CALL(foo, DoThat(_, NotNull()));
+```
+
+## Combining Matchers ##
+
+You can build complex matchers from existing ones using `AllOf()`,
+`AnyOf()`, and `Not()`:
+
+```
+using ::testing::AllOf;
+using ::testing::Gt;
+using ::testing::HasSubstr;
+using ::testing::Ne;
+using ::testing::Not;
+...
+  // The argument must be > 5 and != 10.
+  EXPECT_CALL(foo, DoThis(AllOf(Gt(5),
+                                Ne(10))));
+
+  // The first argument must not contain sub-string "blah".
+  EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")),
+                          NULL));
+```
+
+## Casting Matchers ##
+
+Google Mock matchers are statically typed, meaning that the compiler
+can catch your mistake if you use a matcher of the wrong type (for
+example, if you use `Eq(5)` to match a `string` argument). Good for
+you!
+
+Sometimes, however, you know what you're doing and want the compiler
+to give you some slack. One example is that you have a matcher for
+`long` and the argument you want to match is `int`. While the two
+types aren't exactly the same, there is nothing really wrong with
+using a `Matcher<long>` to match an `int` - after all, we can first
+convert the `int` argument to a `long` before giving it to the
+matcher.
+
+To support this need, Google Mock gives you the
+`SafeMatcherCast<T>(m)` function. It casts a matcher `m` to type
+`Matcher<T>`. To ensure safety, Google Mock checks that (let `U` be the
+type `m` accepts):
+
+  1. Type `T` can be implicitly cast to type `U`;
+  1. When both `T` and `U` are built-in arithmetic types (`bool`, integers, and floating-point numbers), the conversion from `T` to `U` is not lossy (in other words, any value representable by `T` can also be represented by `U`); and
+  1. When `U` is a reference, `T` must also be a reference (as the underlying matcher may be interested in the address of the `U` value).
+
+The code won't compile if any of these conditions isn't met.
+
+Here's one example:
+
+```
+using ::testing::SafeMatcherCast;
+
+// A base class and a child class.
+class Base { ... };
+class Derived : public Base { ... };
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(DoThis, void(Derived* derived));
+};
+...
+
+  MockFoo foo;
+  // m is a Matcher<Base*> we got from somewhere.
+  EXPECT_CALL(foo, DoThis(SafeMatcherCast<Derived*>(m)));
+```
+
+If you find `SafeMatcherCast<T>(m)` too limiting, you can use a similar
+function `MatcherCast<T>(m)`. The difference is that `MatcherCast` works
+as long as you can `static_cast` type `T` to type `U`.
+
+`MatcherCast` essentially lets you bypass C++'s type system
+(`static_cast` isn't always safe as it could throw away information,
+for example), so be careful not to misuse/abuse it.
+
+## Selecting Between Overloaded Functions ##
+
+If you expect an overloaded function to be called, the compiler may
+need some help on which overloaded version it is.
+
+To disambiguate functions overloaded on the const-ness of this object,
+use the `Const()` argument wrapper.
+
+```
+using ::testing::ReturnRef;
+
+class MockFoo : public Foo {
+  ...
+  MOCK_METHOD0(GetBar, Bar&());
+  MOCK_CONST_METHOD0(GetBar, const Bar&());
+};
+...
+
+  MockFoo foo;
+  Bar bar1, bar2;
+  EXPECT_CALL(foo, GetBar())         // The non-const GetBar().
+      .WillOnce(ReturnRef(bar1));
+  EXPECT_CALL(Const(foo), GetBar())  // The const GetBar().
+      .WillOnce(ReturnRef(bar2));
+```
+
+(`Const()` is defined by Google Mock and returns a `const` reference
+to its argument.)
+
+To disambiguate overloaded functions with the same number of arguments
+but different argument types, you may need to specify the exact type
+of a matcher, either by wrapping your matcher in `Matcher<type>()`, or
+using a matcher whose type is fixed (`TypedEq<type>`, `An<type>()`,
+etc):
+
+```
+using ::testing::An;
+using ::testing::Lt;
+using ::testing::Matcher;
+using ::testing::TypedEq;
+
+class MockPrinter : public Printer {
+ public:
+  MOCK_METHOD1(Print, void(int n));
+  MOCK_METHOD1(Print, void(char c));
+};
+
+TEST(PrinterTest, Print) {
+  MockPrinter printer;
+
+  EXPECT_CALL(printer, Print(An<int>()));            // void Print(int);
+  EXPECT_CALL(printer, Print(Matcher<int>(Lt(5))));  // void Print(int);
+  EXPECT_CALL(printer, Print(TypedEq<char>('a')));   // void Print(char);
+
+  printer.Print(3);
+  printer.Print(6);
+  printer.Print('a');
+}
+```
+
+## Performing Different Actions Based on the Arguments ##
+
+When a mock method is called, the _last_ matching expectation that's
+still active will be selected (think "newer overrides older"). So, you
+can make a method do different things depending on its argument values
+like this:
+
+```
+using ::testing::_;
+using ::testing::Lt;
+using ::testing::Return;
+...
+  // The default case.
+  EXPECT_CALL(foo, DoThis(_))
+      .WillRepeatedly(Return('b'));
+
+  // The more specific case.
+  EXPECT_CALL(foo, DoThis(Lt(5)))
+      .WillRepeatedly(Return('a'));
+```
+
+Now, if `foo.DoThis()` is called with a value less than 5, `'a'` will
+be returned; otherwise `'b'` will be returned.
+
+## Matching Multiple Arguments as a Whole ##
+
+Sometimes it's not enough to match the arguments individually. For
+example, we may want to say that the first argument must be less than
+the second argument. The `With()` clause allows us to match
+all arguments of a mock function as a whole. For example,
+
+```
+using ::testing::_;
+using ::testing::Lt;
+using ::testing::Ne;
+...
+  EXPECT_CALL(foo, InRange(Ne(0), _))
+      .With(Lt());
+```
+
+says that the first argument of `InRange()` must not be 0, and must be
+less than the second argument.
+
+The expression inside `With()` must be a matcher of type
+`Matcher<tr1::tuple<A1, ..., An> >`, where `A1`, ..., `An` are the
+types of the function arguments.
+
+You can also write `AllArgs(m)` instead of `m` inside `.With()`. The
+two forms are equivalent, but `.With(AllArgs(Lt()))` is more readable
+than `.With(Lt())`.
+
+You can use `Args<k1, ..., kn>(m)` to match the `n` selected arguments
+(as a tuple) against `m`. For example,
+
+```
+using ::testing::_;
+using ::testing::AllOf;
+using ::testing::Args;
+using ::testing::Lt;
+...
+  EXPECT_CALL(foo, Blah(_, _, _))
+      .With(AllOf(Args<0, 1>(Lt()), Args<1, 2>(Lt())));
+```
+
+says that `Blah()` will be called with arguments `x`, `y`, and `z` where
+`x < y < z`.
+
+As a convenience and example, Google Mock provides some matchers for
+2-tuples, including the `Lt()` matcher above. See the [CheatSheet](V1_7_CheatSheet.md) for
+the complete list.
+
+Note that if you want to pass the arguments to a predicate of your own
+(e.g. `.With(Args<0, 1>(Truly(&MyPredicate)))`), that predicate MUST be
+written to take a `tr1::tuple` as its argument; Google Mock will pass the `n`
+selected arguments as _one_ single tuple to the predicate.
+
+## Using Matchers as Predicates ##
+
+Have you noticed that a matcher is just a fancy predicate that also
+knows how to describe itself? Many existing algorithms take predicates
+as arguments (e.g. those defined in STL's `<algorithm>` header), and
+it would be a shame if Google Mock matchers are not allowed to
+participate.
+
+Luckily, you can use a matcher where a unary predicate functor is
+expected by wrapping it inside the `Matches()` function. For example,
+
+```
+#include <algorithm>
+#include <vector>
+
+std::vector<int> v;
+...
+// How many elements in v are >= 10?
+const int count = count_if(v.begin(), v.end(), Matches(Ge(10)));
+```
+
+Since you can build complex matchers from simpler ones easily using
+Google Mock, this gives you a way to conveniently construct composite
+predicates (doing the same using STL's `<functional>` header is just
+painful). For example, here's a predicate that's satisfied by any
+number that is >= 0, <= 100, and != 50:
+
+```
+Matches(AllOf(Ge(0), Le(100), Ne(50)))
+```
+
+## Using Matchers in Google Test Assertions ##
+
+Since matchers are basically predicates that also know how to describe
+themselves, there is a way to take advantage of them in
+[Google Test](http://code.google.com/p/googletest/) assertions. It's
+called `ASSERT_THAT` and `EXPECT_THAT`:
+
+```
+  ASSERT_THAT(value, matcher);  // Asserts that value matches matcher.
+  EXPECT_THAT(value, matcher);  // The non-fatal version.
+```
+
+For example, in a Google Test test you can write:
+
+```
+#include "gmock/gmock.h"
+
+using ::testing::AllOf;
+using ::testing::Ge;
+using ::testing::Le;
+using ::testing::MatchesRegex;
+using ::testing::StartsWith;
+...
+
+  EXPECT_THAT(Foo(), StartsWith("Hello"));
+  EXPECT_THAT(Bar(), MatchesRegex("Line \\d+"));
+  ASSERT_THAT(Baz(), AllOf(Ge(5), Le(10)));
+```
+
+which (as you can probably guess) executes `Foo()`, `Bar()`, and
+`Baz()`, and verifies that:
+
+  * `Foo()` returns a string that starts with `"Hello"`.
+  * `Bar()` returns a string that matches regular expression `"Line \\d+"`.
+  * `Baz()` returns a number in the range [5, 10].
+
+The nice thing about these macros is that _they read like
+English_. They generate informative messages too. For example, if the
+first `EXPECT_THAT()` above fails, the message will be something like:
+
+```
+Value of: Foo()
+  Actual: "Hi, world!"
+Expected: starts with "Hello"
+```
+
+**Credit:** The idea of `(ASSERT|EXPECT)_THAT` was stolen from the
+[Hamcrest](http://code.google.com/p/hamcrest/) project, which adds
+`assertThat()` to JUnit.
+
+## Using Predicates as Matchers ##
+
+Google Mock provides a built-in set of matchers. In case you find them
+lacking, you can use an arbitray unary predicate function or functor
+as a matcher - as long as the predicate accepts a value of the type
+you want. You do this by wrapping the predicate inside the `Truly()`
+function, for example:
+
+```
+using ::testing::Truly;
+
+int IsEven(int n) { return (n % 2) == 0 ? 1 : 0; }
+...
+
+  // Bar() must be called with an even number.
+  EXPECT_CALL(foo, Bar(Truly(IsEven)));
+```
+
+Note that the predicate function / functor doesn't have to return
+`bool`. It works as long as the return value can be used as the
+condition in statement `if (condition) ...`.
+
+## Matching Arguments that Are Not Copyable ##
+
+When you do an `EXPECT_CALL(mock_obj, Foo(bar))`, Google Mock saves
+away a copy of `bar`. When `Foo()` is called later, Google Mock
+compares the argument to `Foo()` with the saved copy of `bar`. This
+way, you don't need to worry about `bar` being modified or destroyed
+after the `EXPECT_CALL()` is executed. The same is true when you use
+matchers like `Eq(bar)`, `Le(bar)`, and so on.
+
+But what if `bar` cannot be copied (i.e. has no copy constructor)? You
+could define your own matcher function and use it with `Truly()`, as
+the previous couple of recipes have shown. Or, you may be able to get
+away from it if you can guarantee that `bar` won't be changed after
+the `EXPECT_CALL()` is executed. Just tell Google Mock that it should
+save a reference to `bar`, instead of a copy of it. Here's how:
+
+```
+using ::testing::Eq;
+using ::testing::ByRef;
+using ::testing::Lt;
+...
+  // Expects that Foo()'s argument == bar.
+  EXPECT_CALL(mock_obj, Foo(Eq(ByRef(bar))));
+
+  // Expects that Foo()'s argument < bar.
+  EXPECT_CALL(mock_obj, Foo(Lt(ByRef(bar))));
+```
+
+Remember: if you do this, don't change `bar` after the
+`EXPECT_CALL()`, or the result is undefined.
+
+## Validating a Member of an Object ##
+
+Often a mock function takes a reference to object as an argument. When
+matching the argument, you may not want to compare the entire object
+against a fixed object, as that may be over-specification. Instead,
+you may need to validate a certain member variable or the result of a
+certain getter method of the object. You can do this with `Field()`
+and `Property()`. More specifically,
+
+```
+Field(&Foo::bar, m)
+```
+
+is a matcher that matches a `Foo` object whose `bar` member variable
+satisfies matcher `m`.
+
+```
+Property(&Foo::baz, m)
+```
+
+is a matcher that matches a `Foo` object whose `baz()` method returns
+a value that satisfies matcher `m`.
+
+For example:
+
+> | `Field(&Foo::number, Ge(3))` | Matches `x` where `x.number >= 3`. |
+|:-----------------------------|:-----------------------------------|
+> | `Property(&Foo::name, StartsWith("John "))` | Matches `x` where `x.name()` starts with `"John "`. |
+
+Note that in `Property(&Foo::baz, ...)`, method `baz()` must take no
+argument and be declared as `const`.
+
+BTW, `Field()` and `Property()` can also match plain pointers to
+objects. For instance,
+
+```
+Field(&Foo::number, Ge(3))
+```
+
+matches a plain pointer `p` where `p->number >= 3`. If `p` is `NULL`,
+the match will always fail regardless of the inner matcher.
+
+What if you want to validate more than one members at the same time?
+Remember that there is `AllOf()`.
+
+## Validating the Value Pointed to by a Pointer Argument ##
+
+C++ functions often take pointers as arguments. You can use matchers
+like `IsNull()`, `NotNull()`, and other comparison matchers to match a
+pointer, but what if you want to make sure the value _pointed to_ by
+the pointer, instead of the pointer itself, has a certain property?
+Well, you can use the `Pointee(m)` matcher.
+
+`Pointee(m)` matches a pointer iff `m` matches the value the pointer
+points to. For example:
+
+```
+using ::testing::Ge;
+using ::testing::Pointee;
+...
+  EXPECT_CALL(foo, Bar(Pointee(Ge(3))));
+```
+
+expects `foo.Bar()` to be called with a pointer that points to a value
+greater than or equal to 3.
+
+One nice thing about `Pointee()` is that it treats a `NULL` pointer as
+a match failure, so you can write `Pointee(m)` instead of
+
+```
+  AllOf(NotNull(), Pointee(m))
+```
+
+without worrying that a `NULL` pointer will crash your test.
+
+Also, did we tell you that `Pointee()` works with both raw pointers
+**and** smart pointers (`linked_ptr`, `shared_ptr`, `scoped_ptr`, and
+etc)?
+
+What if you have a pointer to pointer? You guessed it - you can use
+nested `Pointee()` to probe deeper inside the value. For example,
+`Pointee(Pointee(Lt(3)))` matches a pointer that points to a pointer
+that points to a number less than 3 (what a mouthful...).
+
+## Testing a Certain Property of an Object ##
+
+Sometimes you want to specify that an object argument has a certain
+property, but there is no existing matcher that does this. If you want
+good error messages, you should define a matcher. If you want to do it
+quick and dirty, you could get away with writing an ordinary function.
+
+Let's say you have a mock function that takes an object of type `Foo`,
+which has an `int bar()` method and an `int baz()` method, and you
+want to constrain that the argument's `bar()` value plus its `baz()`
+value is a given number. Here's how you can define a matcher to do it:
+
+```
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+
+class BarPlusBazEqMatcher : public MatcherInterface<const Foo&> {
+ public:
+  explicit BarPlusBazEqMatcher(int expected_sum)
+      : expected_sum_(expected_sum) {}
+
+  virtual bool MatchAndExplain(const Foo& foo,
+                               MatchResultListener* listener) const {
+    return (foo.bar() + foo.baz()) == expected_sum_;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "bar() + baz() equals " << expected_sum_;
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "bar() + baz() does not equal " << expected_sum_;
+  }
+ private:
+  const int expected_sum_;
+};
+
+inline Matcher<const Foo&> BarPlusBazEq(int expected_sum) {
+  return MakeMatcher(new BarPlusBazEqMatcher(expected_sum));
+}
+
+...
+
+  EXPECT_CALL(..., DoThis(BarPlusBazEq(5)))...;
+```
+
+## Matching Containers ##
+
+Sometimes an STL container (e.g. list, vector, map, ...) is passed to
+a mock function and you may want to validate it. Since most STL
+containers support the `==` operator, you can write
+`Eq(expected_container)` or simply `expected_container` to match a
+container exactly.
+
+Sometimes, though, you may want to be more flexible (for example, the
+first element must be an exact match, but the second element can be
+any positive number, and so on). Also, containers used in tests often
+have a small number of elements, and having to define the expected
+container out-of-line is a bit of a hassle.
+
+You can use the `ElementsAre()` or `UnorderedElementsAre()` matcher in
+such cases:
+
+```
+using ::testing::_;
+using ::testing::ElementsAre;
+using ::testing::Gt;
+...
+
+  MOCK_METHOD1(Foo, void(const vector<int>& numbers));
+...
+
+  EXPECT_CALL(mock, Foo(ElementsAre(1, Gt(0), _, 5)));
+```
+
+The above matcher says that the container must have 4 elements, which
+must be 1, greater than 0, anything, and 5 respectively.
+
+If you instead write:
+
+```
+using ::testing::_;
+using ::testing::Gt;
+using ::testing::UnorderedElementsAre;
+...
+
+  MOCK_METHOD1(Foo, void(const vector<int>& numbers));
+...
+
+  EXPECT_CALL(mock, Foo(UnorderedElementsAre(1, Gt(0), _, 5)));
+```
+
+It means that the container must have 4 elements, which under some
+permutation must be 1, greater than 0, anything, and 5 respectively.
+
+`ElementsAre()` and `UnorderedElementsAre()` are overloaded to take 0
+to 10 arguments. If more are needed, you can place them in a C-style
+array and use `ElementsAreArray()` or `UnorderedElementsAreArray()`
+instead:
+
+```
+using ::testing::ElementsAreArray;
+...
+
+  // ElementsAreArray accepts an array of element values.
+  const int expected_vector1[] = { 1, 5, 2, 4, ... };
+  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector1)));
+
+  // Or, an array of element matchers.
+  Matcher<int> expected_vector2 = { 1, Gt(2), _, 3, ... };
+  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector2)));
+```
+
+In case the array needs to be dynamically created (and therefore the
+array size cannot be inferred by the compiler), you can give
+`ElementsAreArray()` an additional argument to specify the array size:
+
+```
+using ::testing::ElementsAreArray;
+...
+  int* const expected_vector3 = new int[count];
+  ... fill expected_vector3 with values ...
+  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector3, count)));
+```
+
+**Tips:**
+
+  * `ElementsAre*()` can be used to match _any_ container that implements the STL iterator pattern (i.e. it has a `const_iterator` type and supports `begin()/end()`), not just the ones defined in STL. It will even work with container types yet to be written - as long as they follows the above pattern.
+  * You can use nested `ElementsAre*()` to match nested (multi-dimensional) containers.
+  * If the container is passed by pointer instead of by reference, just write `Pointee(ElementsAre*(...))`.
+  * The order of elements _matters_ for `ElementsAre*()`. Therefore don't use it with containers whose element order is undefined (e.g. `hash_map`).
+
+## Sharing Matchers ##
+
+Under the hood, a Google Mock matcher object consists of a pointer to
+a ref-counted implementation object. Copying matchers is allowed and
+very efficient, as only the pointer is copied. When the last matcher
+that references the implementation object dies, the implementation
+object will be deleted.
+
+Therefore, if you have some complex matcher that you want to use again
+and again, there is no need to build it everytime. Just assign it to a
+matcher variable and use that variable repeatedly! For example,
+
+```
+  Matcher<int> in_range = AllOf(Gt(5), Le(10));
+  ... use in_range as a matcher in multiple EXPECT_CALLs ...
+```
+
+# Setting Expectations #
+
+## Knowing When to Expect ##
+
+`ON_CALL` is likely the single most under-utilized construct in Google Mock.
+
+There are basically two constructs for defining the behavior of a mock object: `ON_CALL` and `EXPECT_CALL`. The difference? `ON_CALL` defines what happens when a mock method is called, but _doesn't imply any expectation on the method being called._ `EXPECT_CALL` not only defines the behavior, but also sets an expectation that _the method will be called with the given arguments, for the given number of times_ (and _in the given order_ when you specify the order too).
+
+Since `EXPECT_CALL` does more, isn't it better than `ON_CALL`? Not really. Every `EXPECT_CALL` adds a constraint on the behavior of the code under test. Having more constraints than necessary is _baaad_ - even worse than not having enough constraints.
+
+This may be counter-intuitive. How could tests that verify more be worse than tests that verify less? Isn't verification the whole point of tests?
+
+The answer, lies in _what_ a test should verify. **A good test verifies the contract of the code.** If a test over-specifies, it doesn't leave enough freedom to the implementation. As a result, changing the implementation without breaking the contract (e.g. refactoring and optimization), which should be perfectly fine to do, can break such tests. Then you have to spend time fixing them, only to see them broken again the next time the implementation is changed.
+
+Keep in mind that one doesn't have to verify more than one property in one test. In fact, **it's a good style to verify only one thing in one test.** If you do that, a bug will likely break only one or two tests instead of dozens (which case would you rather debug?). If you are also in the habit of giving tests descriptive names that tell what they verify, you can often easily guess what's wrong just from the test log itself.
+
+So use `ON_CALL` by default, and only use `EXPECT_CALL` when you actually intend to verify that the call is made. For example, you may have a bunch of `ON_CALL`s in your test fixture to set the common mock behavior shared by all tests in the same group, and write (scarcely) different `EXPECT_CALL`s in different `TEST_F`s to verify different aspects of the code's behavior. Compared with the style where each `TEST` has many `EXPECT_CALL`s, this leads to tests that are more resilient to implementational changes (and thus less likely to require maintenance) and makes the intent of the tests more obvious (so they are easier to maintain when you do need to maintain them).
+
+## Ignoring Uninteresting Calls ##
+
+If you are not interested in how a mock method is called, just don't
+say anything about it. In this case, if the method is ever called,
+Google Mock will perform its default action to allow the test program
+to continue. If you are not happy with the default action taken by
+Google Mock, you can override it using `DefaultValue<T>::Set()`
+(described later in this document) or `ON_CALL()`.
+
+Please note that once you expressed interest in a particular mock
+method (via `EXPECT_CALL()`), all invocations to it must match some
+expectation. If this function is called but the arguments don't match
+any `EXPECT_CALL()` statement, it will be an error.
+
+## Disallowing Unexpected Calls ##
+
+If a mock method shouldn't be called at all, explicitly say so:
+
+```
+using ::testing::_;
+...
+  EXPECT_CALL(foo, Bar(_))
+      .Times(0);
+```
+
+If some calls to the method are allowed, but the rest are not, just
+list all the expected calls:
+
+```
+using ::testing::AnyNumber;
+using ::testing::Gt;
+...
+  EXPECT_CALL(foo, Bar(5));
+  EXPECT_CALL(foo, Bar(Gt(10)))
+      .Times(AnyNumber());
+```
+
+A call to `foo.Bar()` that doesn't match any of the `EXPECT_CALL()`
+statements will be an error.
+
+## Expecting Ordered Calls ##
+
+Although an `EXPECT_CALL()` statement defined earlier takes precedence
+when Google Mock tries to match a function call with an expectation,
+by default calls don't have to happen in the order `EXPECT_CALL()`
+statements are written. For example, if the arguments match the
+matchers in the third `EXPECT_CALL()`, but not those in the first two,
+then the third expectation will be used.
+
+If you would rather have all calls occur in the order of the
+expectations, put the `EXPECT_CALL()` statements in a block where you
+define a variable of type `InSequence`:
+
+```
+  using ::testing::_;
+  using ::testing::InSequence;
+
+  {
+    InSequence s;
+
+    EXPECT_CALL(foo, DoThis(5));
+    EXPECT_CALL(bar, DoThat(_))
+        .Times(2);
+    EXPECT_CALL(foo, DoThis(6));
+  }
+```
+
+In this example, we expect a call to `foo.DoThis(5)`, followed by two
+calls to `bar.DoThat()` where the argument can be anything, which are
+in turn followed by a call to `foo.DoThis(6)`. If a call occurred
+out-of-order, Google Mock will report an error.
+
+## Expecting Partially Ordered Calls ##
+
+Sometimes requiring everything to occur in a predetermined order can
+lead to brittle tests. For example, we may care about `A` occurring
+before both `B` and `C`, but aren't interested in the relative order
+of `B` and `C`. In this case, the test should reflect our real intent,
+instead of being overly constraining.
+
+Google Mock allows you to impose an arbitrary DAG (directed acyclic
+graph) on the calls. One way to express the DAG is to use the
+[After](http://code.google.com/p/googlemock/wiki/V1_7_CheatSheet#The_After_Clause) clause of `EXPECT_CALL`.
+
+Another way is via the `InSequence()` clause (not the same as the
+`InSequence` class), which we borrowed from jMock 2. It's less
+flexible than `After()`, but more convenient when you have long chains
+of sequential calls, as it doesn't require you to come up with
+different names for the expectations in the chains.  Here's how it
+works:
+
+If we view `EXPECT_CALL()` statements as nodes in a graph, and add an
+edge from node A to node B wherever A must occur before B, we can get
+a DAG. We use the term "sequence" to mean a directed path in this
+DAG. Now, if we decompose the DAG into sequences, we just need to know
+which sequences each `EXPECT_CALL()` belongs to in order to be able to
+reconstruct the orginal DAG.
+
+So, to specify the partial order on the expectations we need to do two
+things: first to define some `Sequence` objects, and then for each
+`EXPECT_CALL()` say which `Sequence` objects it is part
+of. Expectations in the same sequence must occur in the order they are
+written. For example,
+
+```
+  using ::testing::Sequence;
+
+  Sequence s1, s2;
+
+  EXPECT_CALL(foo, A())
+      .InSequence(s1, s2);
+  EXPECT_CALL(bar, B())
+      .InSequence(s1);
+  EXPECT_CALL(bar, C())
+      .InSequence(s2);
+  EXPECT_CALL(foo, D())
+      .InSequence(s2);
+```
+
+specifies the following DAG (where `s1` is `A -> B`, and `s2` is `A ->
+C -> D`):
+
+```
+       +---> B
+       |
+  A ---|
+       |
+       +---> C ---> D
+```
+
+This means that A must occur before B and C, and C must occur before
+D. There's no restriction about the order other than these.
+
+## Controlling When an Expectation Retires ##
+
+When a mock method is called, Google Mock only consider expectations
+that are still active. An expectation is active when created, and
+becomes inactive (aka _retires_) when a call that has to occur later
+has occurred. For example, in
+
+```
+  using ::testing::_;
+  using ::testing::Sequence;
+
+  Sequence s1, s2;
+
+  EXPECT_CALL(log, Log(WARNING, _, "File too large."))     // #1
+      .Times(AnyNumber())
+      .InSequence(s1, s2);
+  EXPECT_CALL(log, Log(WARNING, _, "Data set is empty."))  // #2
+      .InSequence(s1);
+  EXPECT_CALL(log, Log(WARNING, _, "User not found."))     // #3
+      .InSequence(s2);
+```
+
+as soon as either #2 or #3 is matched, #1 will retire. If a warning
+`"File too large."` is logged after this, it will be an error.
+
+Note that an expectation doesn't retire automatically when it's
+saturated. For example,
+
+```
+using ::testing::_;
+...
+  EXPECT_CALL(log, Log(WARNING, _, _));                  // #1
+  EXPECT_CALL(log, Log(WARNING, _, "File too large."));  // #2
+```
+
+says that there will be exactly one warning with the message `"File
+too large."`. If the second warning contains this message too, #2 will
+match again and result in an upper-bound-violated error.
+
+If this is not what you want, you can ask an expectation to retire as
+soon as it becomes saturated:
+
+```
+using ::testing::_;
+...
+  EXPECT_CALL(log, Log(WARNING, _, _));                 // #1
+  EXPECT_CALL(log, Log(WARNING, _, "File too large."))  // #2
+      .RetiresOnSaturation();
+```
+
+Here #2 can be used only once, so if you have two warnings with the
+message `"File too large."`, the first will match #2 and the second
+will match #1 - there will be no error.
+
+# Using Actions #
+
+## Returning References from Mock Methods ##
+
+If a mock function's return type is a reference, you need to use
+`ReturnRef()` instead of `Return()` to return a result:
+
+```
+using ::testing::ReturnRef;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD0(GetBar, Bar&());
+};
+...
+
+  MockFoo foo;
+  Bar bar;
+  EXPECT_CALL(foo, GetBar())
+      .WillOnce(ReturnRef(bar));
+```
+
+## Returning Live Values from Mock Methods ##
+
+The `Return(x)` action saves a copy of `x` when the action is
+_created_, and always returns the same value whenever it's
+executed. Sometimes you may want to instead return the _live_ value of
+`x` (i.e. its value at the time when the action is _executed_.).
+
+If the mock function's return type is a reference, you can do it using
+`ReturnRef(x)`, as shown in the previous recipe ("Returning References
+from Mock Methods"). However, Google Mock doesn't let you use
+`ReturnRef()` in a mock function whose return type is not a reference,
+as doing that usually indicates a user error. So, what shall you do?
+
+You may be tempted to try `ByRef()`:
+
+```
+using testing::ByRef;
+using testing::Return;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD0(GetValue, int());
+};
+...
+  int x = 0;
+  MockFoo foo;
+  EXPECT_CALL(foo, GetValue())
+      .WillRepeatedly(Return(ByRef(x)));
+  x = 42;
+  EXPECT_EQ(42, foo.GetValue());
+```
+
+Unfortunately, it doesn't work here. The above code will fail with error:
+
+```
+Value of: foo.GetValue()
+  Actual: 0
+Expected: 42
+```
+
+The reason is that `Return(value)` converts `value` to the actual
+return type of the mock function at the time when the action is
+_created_, not when it is _executed_. (This behavior was chosen for
+the action to be safe when `value` is a proxy object that references
+some temporary objects.) As a result, `ByRef(x)` is converted to an
+`int` value (instead of a `const int&`) when the expectation is set,
+and `Return(ByRef(x))` will always return 0.
+
+`ReturnPointee(pointer)` was provided to solve this problem
+specifically. It returns the value pointed to by `pointer` at the time
+the action is _executed_:
+
+```
+using testing::ReturnPointee;
+...
+  int x = 0;
+  MockFoo foo;
+  EXPECT_CALL(foo, GetValue())
+      .WillRepeatedly(ReturnPointee(&x));  // Note the & here.
+  x = 42;
+  EXPECT_EQ(42, foo.GetValue());  // This will succeed now.
+```
+
+## Combining Actions ##
+
+Want to do more than one thing when a function is called? That's
+fine. `DoAll()` allow you to do sequence of actions every time. Only
+the return value of the last action in the sequence will be used.
+
+```
+using ::testing::DoAll;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(Bar, bool(int n));
+};
+...
+
+  EXPECT_CALL(foo, Bar(_))
+      .WillOnce(DoAll(action_1,
+                      action_2,
+                      ...
+                      action_n));
+```
+
+## Mocking Side Effects ##
+
+Sometimes a method exhibits its effect not via returning a value but
+via side effects. For example, it may change some global state or
+modify an output argument. To mock side effects, in general you can
+define your own action by implementing `::testing::ActionInterface`.
+
+If all you need to do is to change an output argument, the built-in
+`SetArgPointee()` action is convenient:
+
+```
+using ::testing::SetArgPointee;
+
+class MockMutator : public Mutator {
+ public:
+  MOCK_METHOD2(Mutate, void(bool mutate, int* value));
+  ...
+};
+...
+
+  MockMutator mutator;
+  EXPECT_CALL(mutator, Mutate(true, _))
+      .WillOnce(SetArgPointee<1>(5));
+```
+
+In this example, when `mutator.Mutate()` is called, we will assign 5
+to the `int` variable pointed to by argument #1
+(0-based).
+
+`SetArgPointee()` conveniently makes an internal copy of the
+value you pass to it, removing the need to keep the value in scope and
+alive. The implication however is that the value must have a copy
+constructor and assignment operator.
+
+If the mock method also needs to return a value as well, you can chain
+`SetArgPointee()` with `Return()` using `DoAll()`:
+
+```
+using ::testing::_;
+using ::testing::Return;
+using ::testing::SetArgPointee;
+
+class MockMutator : public Mutator {
+ public:
+  ...
+  MOCK_METHOD1(MutateInt, bool(int* value));
+};
+...
+
+  MockMutator mutator;
+  EXPECT_CALL(mutator, MutateInt(_))
+      .WillOnce(DoAll(SetArgPointee<0>(5),
+                      Return(true)));
+```
+
+If the output argument is an array, use the
+`SetArrayArgument<N>(first, last)` action instead. It copies the
+elements in source range `[first, last)` to the array pointed to by
+the `N`-th (0-based) argument:
+
+```
+using ::testing::NotNull;
+using ::testing::SetArrayArgument;
+
+class MockArrayMutator : public ArrayMutator {
+ public:
+  MOCK_METHOD2(Mutate, void(int* values, int num_values));
+  ...
+};
+...
+
+  MockArrayMutator mutator;
+  int values[5] = { 1, 2, 3, 4, 5 };
+  EXPECT_CALL(mutator, Mutate(NotNull(), 5))
+      .WillOnce(SetArrayArgument<0>(values, values + 5));
+```
+
+This also works when the argument is an output iterator:
+
+```
+using ::testing::_;
+using ::testing::SeArrayArgument;
+
+class MockRolodex : public Rolodex {
+ public:
+  MOCK_METHOD1(GetNames, void(std::back_insert_iterator<vector<string> >));
+  ...
+};
+...
+
+  MockRolodex rolodex;
+  vector<string> names;
+  names.push_back("George");
+  names.push_back("John");
+  names.push_back("Thomas");
+  EXPECT_CALL(rolodex, GetNames(_))
+      .WillOnce(SetArrayArgument<0>(names.begin(), names.end()));
+```
+
+## Changing a Mock Object's Behavior Based on the State ##
+
+If you expect a call to change the behavior of a mock object, you can use `::testing::InSequence` to specify different behaviors before and after the call:
+
+```
+using ::testing::InSequence;
+using ::testing::Return;
+
+...
+  {
+    InSequence seq;
+    EXPECT_CALL(my_mock, IsDirty())
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(my_mock, Flush());
+    EXPECT_CALL(my_mock, IsDirty())
+        .WillRepeatedly(Return(false));
+  }
+  my_mock.FlushIfDirty();
+```
+
+This makes `my_mock.IsDirty()` return `true` before `my_mock.Flush()` is called and return `false` afterwards.
+
+If the behavior change is more complex, you can store the effects in a variable and make a mock method get its return value from that variable:
+
+```
+using ::testing::_;
+using ::testing::SaveArg;
+using ::testing::Return;
+
+ACTION_P(ReturnPointee, p) { return *p; }
+...
+  int previous_value = 0;
+  EXPECT_CALL(my_mock, GetPrevValue())
+      .WillRepeatedly(ReturnPointee(&previous_value));
+  EXPECT_CALL(my_mock, UpdateValue(_))
+      .WillRepeatedly(SaveArg<0>(&previous_value));
+  my_mock.DoSomethingToUpdateValue();
+```
+
+Here `my_mock.GetPrevValue()` will always return the argument of the last `UpdateValue()` call.
+
+## Setting the Default Value for a Return Type ##
+
+If a mock method's return type is a built-in C++ type or pointer, by
+default it will return 0 when invoked. You only need to specify an
+action if this default value doesn't work for you.
+
+Sometimes, you may want to change this default value, or you may want
+to specify a default value for types Google Mock doesn't know
+about. You can do this using the `::testing::DefaultValue` class
+template:
+
+```
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD0(CalculateBar, Bar());
+};
+...
+
+  Bar default_bar;
+  // Sets the default return value for type Bar.
+  DefaultValue<Bar>::Set(default_bar);
+
+  MockFoo foo;
+
+  // We don't need to specify an action here, as the default
+  // return value works for us.
+  EXPECT_CALL(foo, CalculateBar());
+
+  foo.CalculateBar();  // This should return default_bar.
+
+  // Unsets the default return value.
+  DefaultValue<Bar>::Clear();
+```
+
+Please note that changing the default value for a type can make you
+tests hard to understand. We recommend you to use this feature
+judiciously. For example, you may want to make sure the `Set()` and
+`Clear()` calls are right next to the code that uses your mock.
+
+## Setting the Default Actions for a Mock Method ##
+
+You've learned how to change the default value of a given
+type. However, this may be too coarse for your purpose: perhaps you
+have two mock methods with the same return type and you want them to
+have different behaviors. The `ON_CALL()` macro allows you to
+customize your mock's behavior at the method level:
+
+```
+using ::testing::_;
+using ::testing::AnyNumber;
+using ::testing::Gt;
+using ::testing::Return;
+...
+  ON_CALL(foo, Sign(_))
+      .WillByDefault(Return(-1));
+  ON_CALL(foo, Sign(0))
+      .WillByDefault(Return(0));
+  ON_CALL(foo, Sign(Gt(0)))
+      .WillByDefault(Return(1));
+
+  EXPECT_CALL(foo, Sign(_))
+      .Times(AnyNumber());
+
+  foo.Sign(5);   // This should return 1.
+  foo.Sign(-9);  // This should return -1.
+  foo.Sign(0);   // This should return 0.
+```
+
+As you may have guessed, when there are more than one `ON_CALL()`
+statements, the news order take precedence over the older ones. In
+other words, the **last** one that matches the function arguments will
+be used. This matching order allows you to set up the common behavior
+in a mock object's constructor or the test fixture's set-up phase and
+specialize the mock's behavior later.
+
+## Using Functions/Methods/Functors as Actions ##
+
+If the built-in actions don't suit you, you can easily use an existing
+function, method, or functor as an action:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD2(Sum, int(int x, int y));
+  MOCK_METHOD1(ComplexJob, bool(int x));
+};
+
+int CalculateSum(int x, int y) { return x + y; }
+
+class Helper {
+ public:
+  bool ComplexJob(int x);
+};
+...
+
+  MockFoo foo;
+  Helper helper;
+  EXPECT_CALL(foo, Sum(_, _))
+      .WillOnce(Invoke(CalculateSum));
+  EXPECT_CALL(foo, ComplexJob(_))
+      .WillOnce(Invoke(&helper, &Helper::ComplexJob));
+
+  foo.Sum(5, 6);       // Invokes CalculateSum(5, 6).
+  foo.ComplexJob(10);  // Invokes helper.ComplexJob(10);
+```
+
+The only requirement is that the type of the function, etc must be
+_compatible_ with the signature of the mock function, meaning that the
+latter's arguments can be implicitly converted to the corresponding
+arguments of the former, and the former's return type can be
+implicitly converted to that of the latter. So, you can invoke
+something whose type is _not_ exactly the same as the mock function,
+as long as it's safe to do so - nice, huh?
+
+## Invoking a Function/Method/Functor Without Arguments ##
+
+`Invoke()` is very useful for doing actions that are more complex. It
+passes the mock function's arguments to the function or functor being
+invoked such that the callee has the full context of the call to work
+with. If the invoked function is not interested in some or all of the
+arguments, it can simply ignore them.
+
+Yet, a common pattern is that a test author wants to invoke a function
+without the arguments of the mock function. `Invoke()` allows her to
+do that using a wrapper function that throws away the arguments before
+invoking an underlining nullary function. Needless to say, this can be
+tedious and obscures the intent of the test.
+
+`InvokeWithoutArgs()` solves this problem. It's like `Invoke()` except
+that it doesn't pass the mock function's arguments to the
+callee. Here's an example:
+
+```
+using ::testing::_;
+using ::testing::InvokeWithoutArgs;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(ComplexJob, bool(int n));
+};
+
+bool Job1() { ... }
+...
+
+  MockFoo foo;
+  EXPECT_CALL(foo, ComplexJob(_))
+      .WillOnce(InvokeWithoutArgs(Job1));
+
+  foo.ComplexJob(10);  // Invokes Job1().
+```
+
+## Invoking an Argument of the Mock Function ##
+
+Sometimes a mock function will receive a function pointer or a functor
+(in other words, a "callable") as an argument, e.g.
+
+```
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD2(DoThis, bool(int n, bool (*fp)(int)));
+};
+```
+
+and you may want to invoke this callable argument:
+
+```
+using ::testing::_;
+...
+  MockFoo foo;
+  EXPECT_CALL(foo, DoThis(_, _))
+      .WillOnce(...);
+  // Will execute (*fp)(5), where fp is the
+  // second argument DoThis() receives.
+```
+
+Arghh, you need to refer to a mock function argument but C++ has no
+lambda (yet), so you have to define your own action. :-( Or do you
+really?
+
+Well, Google Mock has an action to solve _exactly_ this problem:
+
+```
+  InvokeArgument<N>(arg_1, arg_2, ..., arg_m)
+```
+
+will invoke the `N`-th (0-based) argument the mock function receives,
+with `arg_1`, `arg_2`, ..., and `arg_m`. No matter if the argument is
+a function pointer or a functor, Google Mock handles them both.
+
+With that, you could write:
+
+```
+using ::testing::_;
+using ::testing::InvokeArgument;
+...
+  EXPECT_CALL(foo, DoThis(_, _))
+      .WillOnce(InvokeArgument<1>(5));
+  // Will execute (*fp)(5), where fp is the
+  // second argument DoThis() receives.
+```
+
+What if the callable takes an argument by reference? No problem - just
+wrap it inside `ByRef()`:
+
+```
+...
+  MOCK_METHOD1(Bar, bool(bool (*fp)(int, const Helper&)));
+...
+using ::testing::_;
+using ::testing::ByRef;
+using ::testing::InvokeArgument;
+...
+
+  MockFoo foo;
+  Helper helper;
+  ...
+  EXPECT_CALL(foo, Bar(_))
+      .WillOnce(InvokeArgument<0>(5, ByRef(helper)));
+  // ByRef(helper) guarantees that a reference to helper, not a copy of it,
+  // will be passed to the callable.
+```
+
+What if the callable takes an argument by reference and we do **not**
+wrap the argument in `ByRef()`? Then `InvokeArgument()` will _make a
+copy_ of the argument, and pass a _reference to the copy_, instead of
+a reference to the original value, to the callable. This is especially
+handy when the argument is a temporary value:
+
+```
+...
+  MOCK_METHOD1(DoThat, bool(bool (*f)(const double& x, const string& s)));
+...
+using ::testing::_;
+using ::testing::InvokeArgument;
+...
+
+  MockFoo foo;
+  ...
+  EXPECT_CALL(foo, DoThat(_))
+      .WillOnce(InvokeArgument<0>(5.0, string("Hi")));
+  // Will execute (*f)(5.0, string("Hi")), where f is the function pointer
+  // DoThat() receives.  Note that the values 5.0 and string("Hi") are
+  // temporary and dead once the EXPECT_CALL() statement finishes.  Yet
+  // it's fine to perform this action later, since a copy of the values
+  // are kept inside the InvokeArgument action.
+```
+
+## Ignoring an Action's Result ##
+
+Sometimes you have an action that returns _something_, but you need an
+action that returns `void` (perhaps you want to use it in a mock
+function that returns `void`, or perhaps it needs to be used in
+`DoAll()` and it's not the last in the list). `IgnoreResult()` lets
+you do that. For example:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Return;
+
+int Process(const MyData& data);
+string DoSomething();
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD1(Abc, void(const MyData& data));
+  MOCK_METHOD0(Xyz, bool());
+};
+...
+
+  MockFoo foo;
+  EXPECT_CALL(foo, Abc(_))
+  // .WillOnce(Invoke(Process));
+  // The above line won't compile as Process() returns int but Abc() needs
+  // to return void.
+      .WillOnce(IgnoreResult(Invoke(Process)));
+
+  EXPECT_CALL(foo, Xyz())
+      .WillOnce(DoAll(IgnoreResult(Invoke(DoSomething)),
+      // Ignores the string DoSomething() returns.
+                      Return(true)));
+```
+
+Note that you **cannot** use `IgnoreResult()` on an action that already
+returns `void`. Doing so will lead to ugly compiler errors.
+
+## Selecting an Action's Arguments ##
+
+Say you have a mock function `Foo()` that takes seven arguments, and
+you have a custom action that you want to invoke when `Foo()` is
+called. Trouble is, the custom action only wants three arguments:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+...
+  MOCK_METHOD7(Foo, bool(bool visible, const string& name, int x, int y,
+                         const map<pair<int, int>, double>& weight,
+                         double min_weight, double max_wight));
+...
+
+bool IsVisibleInQuadrant1(bool visible, int x, int y) {
+  return visible && x >= 0 && y >= 0;
+}
+...
+
+  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
+      .WillOnce(Invoke(IsVisibleInQuadrant1));  // Uh, won't compile. :-(
+```
+
+To please the compiler God, you can to define an "adaptor" that has
+the same signature as `Foo()` and calls the custom action with the
+right arguments:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+bool MyIsVisibleInQuadrant1(bool visible, const string& name, int x, int y,
+                            const map<pair<int, int>, double>& weight,
+                            double min_weight, double max_wight) {
+  return IsVisibleInQuadrant1(visible, x, y);
+}
+...
+
+  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
+      .WillOnce(Invoke(MyIsVisibleInQuadrant1));  // Now it works.
+```
+
+But isn't this awkward?
+
+Google Mock provides a generic _action adaptor_, so you can spend your
+time minding more important business than writing your own
+adaptors. Here's the syntax:
+
+```
+  WithArgs<N1, N2, ..., Nk>(action)
+```
+
+creates an action that passes the arguments of the mock function at
+the given indices (0-based) to the inner `action` and performs
+it. Using `WithArgs`, our original example can be written as:
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::WithArgs;
+...
+  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
+      .WillOnce(WithArgs<0, 2, 3>(Invoke(IsVisibleInQuadrant1)));
+      // No need to define your own adaptor.
+```
+
+For better readability, Google Mock also gives you:
+
+  * `WithoutArgs(action)` when the inner `action` takes _no_ argument, and
+  * `WithArg<N>(action)` (no `s` after `Arg`) when the inner `action` takes _one_ argument.
+
+As you may have realized, `InvokeWithoutArgs(...)` is just syntactic
+sugar for `WithoutArgs(Inovke(...))`.
+
+Here are more tips:
+
+  * The inner action used in `WithArgs` and friends does not have to be `Invoke()` -- it can be anything.
+  * You can repeat an argument in the argument list if necessary, e.g. `WithArgs<2, 3, 3, 5>(...)`.
+  * You can change the order of the arguments, e.g. `WithArgs<3, 2, 1>(...)`.
+  * The types of the selected arguments do _not_ have to match the signature of the inner action exactly. It works as long as they can be implicitly converted to the corresponding arguments of the inner action. For example, if the 4-th argument of the mock function is an `int` and `my_action` takes a `double`, `WithArg<4>(my_action)` will work.
+
+## Ignoring Arguments in Action Functions ##
+
+The selecting-an-action's-arguments recipe showed us one way to make a
+mock function and an action with incompatible argument lists fit
+together. The downside is that wrapping the action in
+`WithArgs<...>()` can get tedious for people writing the tests.
+
+If you are defining a function, method, or functor to be used with
+`Invoke*()`, and you are not interested in some of its arguments, an
+alternative to `WithArgs` is to declare the uninteresting arguments as
+`Unused`. This makes the definition less cluttered and less fragile in
+case the types of the uninteresting arguments change. It could also
+increase the chance the action function can be reused. For example,
+given
+
+```
+  MOCK_METHOD3(Foo, double(const string& label, double x, double y));
+  MOCK_METHOD3(Bar, double(int index, double x, double y));
+```
+
+instead of
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+
+double DistanceToOriginWithLabel(const string& label, double x, double y) {
+  return sqrt(x*x + y*y);
+}
+
+double DistanceToOriginWithIndex(int index, double x, double y) {
+  return sqrt(x*x + y*y);
+}
+...
+
+  EXEPCT_CALL(mock, Foo("abc", _, _))
+      .WillOnce(Invoke(DistanceToOriginWithLabel));
+  EXEPCT_CALL(mock, Bar(5, _, _))
+      .WillOnce(Invoke(DistanceToOriginWithIndex));
+```
+
+you could write
+
+```
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Unused;
+
+double DistanceToOrigin(Unused, double x, double y) {
+  return sqrt(x*x + y*y);
+}
+...
+
+  EXEPCT_CALL(mock, Foo("abc", _, _))
+      .WillOnce(Invoke(DistanceToOrigin));
+  EXEPCT_CALL(mock, Bar(5, _, _))
+      .WillOnce(Invoke(DistanceToOrigin));
+```
+
+## Sharing Actions ##
+
+Just like matchers, a Google Mock action object consists of a pointer
+to a ref-counted implementation object. Therefore copying actions is
+also allowed and very efficient. When the last action that references
+the implementation object dies, the implementation object will be
+deleted.
+
+If you have some complex action that you want to use again and again,
+you may not have to build it from scratch everytime. If the action
+doesn't have an internal state (i.e. if it always does the same thing
+no matter how many times it has been called), you can assign it to an
+action variable and use that variable repeatedly. For example:
+
+```
+  Action<bool(int*)> set_flag = DoAll(SetArgPointee<0>(5),
+                                      Return(true));
+  ... use set_flag in .WillOnce() and .WillRepeatedly() ...
+```
+
+However, if the action has its own state, you may be surprised if you
+share the action object. Suppose you have an action factory
+`IncrementCounter(init)` which creates an action that increments and
+returns a counter whose initial value is `init`, using two actions
+created from the same expression and using a shared action will
+exihibit different behaviors. Example:
+
+```
+  EXPECT_CALL(foo, DoThis())
+      .WillRepeatedly(IncrementCounter(0));
+  EXPECT_CALL(foo, DoThat())
+      .WillRepeatedly(IncrementCounter(0));
+  foo.DoThis();  // Returns 1.
+  foo.DoThis();  // Returns 2.
+  foo.DoThat();  // Returns 1 - Blah() uses a different
+                 // counter than Bar()'s.
+```
+
+versus
+
+```
+  Action<int()> increment = IncrementCounter(0);
+
+  EXPECT_CALL(foo, DoThis())
+      .WillRepeatedly(increment);
+  EXPECT_CALL(foo, DoThat())
+      .WillRepeatedly(increment);
+  foo.DoThis();  // Returns 1.
+  foo.DoThis();  // Returns 2.
+  foo.DoThat();  // Returns 3 - the counter is shared.
+```
+
+# Misc Recipes on Using Google Mock #
+
+## Making the Compilation Faster ##
+
+Believe it or not, the _vast majority_ of the time spent on compiling
+a mock class is in generating its constructor and destructor, as they
+perform non-trivial tasks (e.g. verification of the
+expectations). What's more, mock methods with different signatures
+have different types and thus their constructors/destructors need to
+be generated by the compiler separately. As a result, if you mock many
+different types of methods, compiling your mock class can get really
+slow.
+
+If you are experiencing slow compilation, you can move the definition
+of your mock class' constructor and destructor out of the class body
+and into a `.cpp` file. This way, even if you `#include` your mock
+class in N files, the compiler only needs to generate its constructor
+and destructor once, resulting in a much faster compilation.
+
+Let's illustrate the idea using an example. Here's the definition of a
+mock class before applying this recipe:
+
+```
+// File mock_foo.h.
+...
+class MockFoo : public Foo {
+ public:
+  // Since we don't declare the constructor or the destructor,
+  // the compiler will generate them in every translation unit
+  // where this mock class is used.
+
+  MOCK_METHOD0(DoThis, int());
+  MOCK_METHOD1(DoThat, bool(const char* str));
+  ... more mock methods ...
+};
+```
+
+After the change, it would look like:
+
+```
+// File mock_foo.h.
+...
+class MockFoo : public Foo {
+ public:
+  // The constructor and destructor are declared, but not defined, here.
+  MockFoo();
+  virtual ~MockFoo();
+
+  MOCK_METHOD0(DoThis, int());
+  MOCK_METHOD1(DoThat, bool(const char* str));
+  ... more mock methods ...
+};
+```
+and
+```
+// File mock_foo.cpp.
+#include "path/to/mock_foo.h"
+
+// The definitions may appear trivial, but the functions actually do a
+// lot of things through the constructors/destructors of the member
+// variables used to implement the mock methods.
+MockFoo::MockFoo() {}
+MockFoo::~MockFoo() {}
+```
+
+## Forcing a Verification ##
+
+When it's being destoyed, your friendly mock object will automatically
+verify that all expectations on it have been satisfied, and will
+generate [Google Test](http://code.google.com/p/googletest/) failures
+if not. This is convenient as it leaves you with one less thing to
+worry about. That is, unless you are not sure if your mock object will
+be destoyed.
+
+How could it be that your mock object won't eventually be destroyed?
+Well, it might be created on the heap and owned by the code you are
+testing. Suppose there's a bug in that code and it doesn't delete the
+mock object properly - you could end up with a passing test when
+there's actually a bug.
+
+Using a heap checker is a good idea and can alleviate the concern, but
+its implementation may not be 100% reliable. So, sometimes you do want
+to _force_ Google Mock to verify a mock object before it is
+(hopefully) destructed. You can do this with
+`Mock::VerifyAndClearExpectations(&mock_object)`:
+
+```
+TEST(MyServerTest, ProcessesRequest) {
+  using ::testing::Mock;
+
+  MockFoo* const foo = new MockFoo;
+  EXPECT_CALL(*foo, ...)...;
+  // ... other expectations ...
+
+  // server now owns foo.
+  MyServer server(foo);
+  server.ProcessRequest(...);
+
+  // In case that server's destructor will forget to delete foo,
+  // this will verify the expectations anyway.
+  Mock::VerifyAndClearExpectations(foo);
+}  // server is destroyed when it goes out of scope here.
+```
+
+**Tip:** The `Mock::VerifyAndClearExpectations()` function returns a
+`bool` to indicate whether the verification was successful (`true` for
+yes), so you can wrap that function call inside a `ASSERT_TRUE()` if
+there is no point going further when the verification has failed.
+
+## Using Check Points ##
+
+Sometimes you may want to "reset" a mock object at various check
+points in your test: at each check point, you verify that all existing
+expectations on the mock object have been satisfied, and then you set
+some new expectations on it as if it's newly created. This allows you
+to work with a mock object in "phases" whose sizes are each
+manageable.
+
+One such scenario is that in your test's `SetUp()` function, you may
+want to put the object you are testing into a certain state, with the
+help from a mock object. Once in the desired state, you want to clear
+all expectations on the mock, such that in the `TEST_F` body you can
+set fresh expectations on it.
+
+As you may have figured out, the `Mock::VerifyAndClearExpectations()`
+function we saw in the previous recipe can help you here. Or, if you
+are using `ON_CALL()` to set default actions on the mock object and
+want to clear the default actions as well, use
+`Mock::VerifyAndClear(&mock_object)` instead. This function does what
+`Mock::VerifyAndClearExpectations(&mock_object)` does and returns the
+same `bool`, **plus** it clears the `ON_CALL()` statements on
+`mock_object` too.
+
+Another trick you can use to achieve the same effect is to put the
+expectations in sequences and insert calls to a dummy "check-point"
+function at specific places. Then you can verify that the mock
+function calls do happen at the right time. 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:
+
+```
+using ::testing::MockFunction;
+
+TEST(FooTest, InvokesBarCorrectly) {
+  MyMock mock;
+  // Class MockFunction<F> has exactly one mock method.  It is named
+  // Call() and has type F.
+  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()`.
+
+## Mocking Destructors ##
+
+Sometimes you want to make sure a mock object is destructed at the
+right time, e.g. after `bar->A()` is called but before `bar->B()` is
+called. We already know that you can specify constraints on the order
+of mock function calls, so all we need to do is to mock the destructor
+of the mock function.
+
+This sounds simple, except for one problem: a destructor is a special
+function with special syntax and special semantics, and the
+`MOCK_METHOD0` macro doesn't work for it:
+
+```
+  MOCK_METHOD0(~MockFoo, void());  // Won't compile!
+```
+
+The good news is that you can use a simple pattern to achieve the same
+effect. First, add a mock function `Die()` to your mock class and call
+it in the destructor, like this:
+
+```
+class MockFoo : public Foo {
+  ...
+  // Add the following two lines to the mock class.
+  MOCK_METHOD0(Die, void());
+  virtual ~MockFoo() { Die(); }
+};
+```
+
+(If the name `Die()` clashes with an existing symbol, choose another
+name.) Now, we have translated the problem of testing when a `MockFoo`
+object dies to testing when its `Die()` method is called:
+
+```
+  MockFoo* foo = new MockFoo;
+  MockBar* bar = new MockBar;
+  ...
+  {
+    InSequence s;
+
+    // Expects *foo to die after bar->A() and before bar->B().
+    EXPECT_CALL(*bar, A());
+    EXPECT_CALL(*foo, Die());
+    EXPECT_CALL(*bar, B());
+  }
+```
+
+And that's that.
+
+## Using Google Mock and Threads ##
+
+**IMPORTANT NOTE:** What we describe in this recipe is **ONLY** true on
+platforms where Google Mock is thread-safe. Currently these are only
+platforms that support the pthreads library (this includes Linux and Mac).
+To make it thread-safe on other platforms we only need to implement
+some synchronization operations in `"gtest/internal/gtest-port.h"`.
+
+In a **unit** test, it's best if you could isolate and test a piece of
+code in a single-threaded context. That avoids race conditions and
+dead locks, and makes debugging your test much easier.
+
+Yet many programs are multi-threaded, and sometimes to test something
+we need to pound on it from more than one thread. Google Mock works
+for this purpose too.
+
+Remember the steps for using a mock:
+
+  1. Create a mock object `foo`.
+  1. Set its default actions and expectations using `ON_CALL()` and `EXPECT_CALL()`.
+  1. The code under test calls methods of `foo`.
+  1. Optionally, verify and reset the mock.
+  1. Destroy the mock yourself, or let the code under test destroy it. The destructor will automatically verify it.
+
+If you follow the following simple rules, your mocks and threads can
+live happily togeter:
+
+  * Execute your _test code_ (as opposed to the code being tested) in _one_ thread. This makes your test easy to follow.
+  * Obviously, you can do step #1 without locking.
+  * When doing step #2 and #5, make sure no other thread is accessing `foo`. Obvious too, huh?
+  * #3 and #4 can be done either in one thread or in multiple threads - anyway you want. Google Mock takes care of the locking, so you don't have to do any - unless required by your test logic.
+
+If you violate the rules (for example, if you set expectations on a
+mock while another thread is calling its methods), you get undefined
+behavior. That's not fun, so don't do it.
+
+Google Mock guarantees that the action for a mock function is done in
+the same thread that called the mock function. For example, in
+
+```
+  EXPECT_CALL(mock, Foo(1))
+      .WillOnce(action1);
+  EXPECT_CALL(mock, Foo(2))
+      .WillOnce(action2);
+```
+
+if `Foo(1)` is called in thread 1 and `Foo(2)` is called in thread 2,
+Google Mock will execute `action1` in thread 1 and `action2` in thread
+2.
+
+Google Mock does _not_ impose a sequence on actions performed in
+different threads (doing so may create deadlocks as the actions may
+need to cooperate). This means that the execution of `action1` and
+`action2` in the above example _may_ interleave. If this is a problem,
+you should add proper synchronization logic to `action1` and `action2`
+to make the test thread-safe.
+
+
+Also, remember that `DefaultValue<T>` is a global resource that
+potentially affects _all_ living mock objects in your
+program. Naturally, you won't want to mess with it from multiple
+threads or when there still are mocks in action.
+
+## Controlling How Much Information Google Mock Prints ##
+
+When Google Mock sees something that has the potential of being an
+error (e.g. a mock function with no expectation is called, a.k.a. an
+uninteresting call, which is allowed but perhaps you forgot to
+explicitly ban the call), it prints some warning messages, including
+the arguments of the function and the return value. Hopefully this
+will remind you to take a look and see if there is indeed a problem.
+
+Sometimes you are confident that your tests are correct and may not
+appreciate such friendly messages. Some other times, you are debugging
+your tests or learning about the behavior of the code you are testing,
+and wish you could observe every mock call that happens (including
+argument values and the return value). Clearly, one size doesn't fit
+all.
+
+You can control how much Google Mock tells you using the
+`--gmock_verbose=LEVEL` command-line flag, where `LEVEL` is a string
+with three possible values:
+
+  * `info`: Google Mock will print all informational messages, warnings, and errors (most verbose). At this setting, Google Mock will also log any calls to the `ON_CALL/EXPECT_CALL` macros.
+  * `warning`: Google Mock will print both warnings and errors (less verbose). This is the default.
+  * `error`: Google Mock will print errors only (least verbose).
+
+Alternatively, you can adjust the value of that flag from within your
+tests like so:
+
+```
+  ::testing::FLAGS_gmock_verbose = "error";
+```
+
+Now, judiciously use the right flag to enable Google Mock serve you better!
+
+## Gaining Super Vision into Mock Calls ##
+
+You have a test using Google Mock. It fails: Google Mock tells you
+that some expectations aren't satisfied. However, you aren't sure why:
+Is there a typo somewhere in the matchers? Did you mess up the order
+of the `EXPECT_CALL`s? Or is the code under test doing something
+wrong?  How can you find out the cause?
+
+Won't it be nice if you have X-ray vision and can actually see the
+trace of all `EXPECT_CALL`s and mock method calls as they are made?
+For each call, would you like to see its actual argument values and
+which `EXPECT_CALL` Google Mock thinks it matches?
+
+You can unlock this power by running your test with the
+`--gmock_verbose=info` flag. For example, given the test program:
+
+```
+using testing::_;
+using testing::HasSubstr;
+using testing::Return;
+
+class MockFoo {
+ public:
+  MOCK_METHOD2(F, void(const string& x, const string& y));
+};
+
+TEST(Foo, Bar) {
+  MockFoo mock;
+  EXPECT_CALL(mock, F(_, _)).WillRepeatedly(Return());
+  EXPECT_CALL(mock, F("a", "b"));
+  EXPECT_CALL(mock, F("c", HasSubstr("d")));
+
+  mock.F("a", "good");
+  mock.F("a", "b");
+}
+```
+
+if you run it with `--gmock_verbose=info`, you will see this output:
+
+```
+[ RUN      ] Foo.Bar
+
+foo_test.cc:14: EXPECT_CALL(mock, F(_, _)) invoked
+foo_test.cc:15: EXPECT_CALL(mock, F("a", "b")) invoked
+foo_test.cc:16: EXPECT_CALL(mock, F("c", HasSubstr("d"))) invoked
+foo_test.cc:14: Mock function call matches EXPECT_CALL(mock, F(_, _))...
+    Function call: F(@0x7fff7c8dad40"a", @0x7fff7c8dad10"good")
+foo_test.cc:15: Mock function call matches EXPECT_CALL(mock, F("a", "b"))...
+    Function call: F(@0x7fff7c8dada0"a", @0x7fff7c8dad70"b")
+foo_test.cc:16: Failure
+Actual function call count doesn't match EXPECT_CALL(mock, F("c", HasSubstr("d")))...
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] Foo.Bar
+```
+
+Suppose the bug is that the `"c"` in the third `EXPECT_CALL` is a typo
+and should actually be `"a"`. With the above message, you should see
+that the actual `F("a", "good")` call is matched by the first
+`EXPECT_CALL`, not the third as you thought. From that it should be
+obvious that the third `EXPECT_CALL` is written wrong. Case solved.
+
+## Running Tests in Emacs ##
+
+If you build and run your tests in Emacs, the source file locations of
+Google Mock and [Google Test](http://code.google.com/p/googletest/)
+errors will be highlighted. Just press `<Enter>` on one of them and
+you'll be taken to the offending line. Or, you can just type `C-x ``
+to jump to the next error.
+
+To make it even easier, you can add the following lines to your
+`~/.emacs` file:
+
+```
+(global-set-key "\M-m"   'compile)  ; m is for make
+(global-set-key [M-down] 'next-error)
+(global-set-key [M-up]   '(lambda () (interactive) (next-error -1)))
+```
+
+Then you can type `M-m` to start a build, or `M-up`/`M-down` to move
+back and forth between errors.
+
+## Fusing Google Mock Source Files ##
+
+Google Mock's implementation consists of dozens of files (excluding
+its own tests).  Sometimes you may want them to be packaged up in
+fewer files instead, such that you can easily copy them to a new
+machine and start hacking there.  For this we provide an experimental
+Python script `fuse_gmock_files.py` in the `scripts/` directory
+(starting with release 1.2.0).  Assuming you have Python 2.4 or above
+installed on your machine, just go to that directory and run
+```
+python fuse_gmock_files.py OUTPUT_DIR
+```
+
+and you should see an `OUTPUT_DIR` directory being created with files
+`gtest/gtest.h`, `gmock/gmock.h`, and `gmock-gtest-all.cc` in it.
+These three files contain everything you need to use Google Mock (and
+Google Test).  Just copy them to anywhere you want and you are ready
+to write tests and use mocks.  You can use the
+[scrpts/test/Makefile](http://code.google.com/p/googlemock/source/browse/trunk/scripts/test/Makefile) file as an example on how to compile your tests
+against them.
+
+# Extending Google Mock #
+
+## Writing New Matchers Quickly ##
+
+The `MATCHER*` family of macros can be used to define custom matchers
+easily.  The syntax:
+
+```
+MATCHER(name, description_string_expression) { statements; }
+```
+
+will define 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 is a `string`-typed expression that documents
+what the matcher does, and is used to generate the failure message
+when the match fails.  It can (and should) reference the special
+`bool` variable `negation`, and should evaluate to the description of
+the matcher when `negation` is `false`, or that of the matcher's
+negation when `negation` is `true`.
+
+For convenience, we allow the description string to be empty (`""`),
+in which case Google Mock will use the sequence of words in the
+matcher name as the description.
+
+For example:
+```
+MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; }
+```
+allows you to write
+```
+  // Expects mock_foo.Bar(n) to be called where n is divisible by 7.
+  EXPECT_CALL(mock_foo, Bar(IsDivisibleBy7()));
+```
+or,
+```
+using ::testing::Not;
+...
+  EXPECT_THAT(some_expression, IsDivisibleBy7());
+  EXPECT_THAT(some_other_expression, Not(IsDivisibleBy7()));
+```
+If the above assertions fail, they will print something like:
+```
+  Value of: some_expression
+  Expected: is divisible by 7
+    Actual: 27
+...
+  Value of: some_other_expression
+  Expected: not (is divisible by 7)
+    Actual: 21
+```
+where the descriptions `"is divisible by 7"` and `"not (is divisible
+by 7)"` are automatically calculated from the matcher name
+`IsDivisibleBy7`.
+
+As you may have noticed, the auto-generated descriptions (especially
+those for the negation) may not be so great. You can always override
+them with a string expression of your own:
+```
+MATCHER(IsDivisibleBy7, std::string(negation ? "isn't" : "is") +
+                        " divisible by 7") {
+  return (arg % 7) == 0;
+}
+```
+
+Optionally, you can stream additional information to a hidden argument
+named `result_listener` to explain the match result. For example, a
+better definition of `IsDivisibleBy7` is:
+```
+MATCHER(IsDivisibleBy7, "") {
+  if ((arg % 7) == 0)
+    return true;
+
+  *result_listener << "the remainder is " << (arg % 7);
+  return false;
+}
+```
+
+With this definition, the above assertion will give a better message:
+```
+  Value of: some_expression
+  Expected: is divisible by 7
+    Actual: 27 (the remainder is 6)
+```
+
+You should let `MatchAndExplain()` print _any additional information_
+that can help a user understand the match result. Note that it should
+explain why the match succeeds in case of a success (unless it's
+obvious) - this is useful when the matcher is used inside
+`Not()`. There is no need to print the argument value itself, as
+Google Mock already prints it for you.
+
+**Notes:**
+
+  1. 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, `IsDivisibleBy7()` can be used to match any type where the value of `(arg % 7) == 0` can be implicitly converted to a `bool`.  In the `Bar(IsDivisibleBy7())` 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.
+  1. Google Mock doesn't guarantee when or how many times a matcher will be invoked. Therefore the matcher logic must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters). This requirement must be satisfied no matter how you define the matcher (e.g. using one of the methods described in the following recipes). In particular, a matcher can never call a mock function, as that will affect the state of the mock object and Google Mock.
+
+## Writing New Parameterized Matchers Quickly ##
+
+Sometimes you'll want to define a matcher that has parameters.  For that you
+can use the macro:
+```
+MATCHER_P(name, param_name, description_string) { statements; }
+```
+where the description string can be either `""` or a string expression
+that references `negation` and `param_name`.
+
+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`.
+
+Google Mock also provides `MATCHER_P2`, `MATCHER_P3`, ..., up to
+`MATCHER_P10` to support multi-parameter matchers:
+```
+MATCHER_Pk(name, param_1, ..., param_k, description_string) { statements; }
+```
+
+Please note that the custom description string is for a particular
+**instance** of the matcher, where the parameters have been bound to
+actual values.  Therefore usually you'll want the parameter values to
+be part of the description.  Google Mock lets you do that by
+referencing the matcher parameters in the description string
+expression.
+
+For example,
+```
+  using ::testing::PrintToString;
+  MATCHER_P2(InClosedRange, low, hi,
+             std::string(negation ? "isn't" : "is") + " in range [" +
+             PrintToString(low) + ", " + PrintToString(hi) + "]") {
+    return low <= arg && arg <= hi;
+  }
+  ...
+  EXPECT_THAT(3, InClosedRange(4, 6));
+```
+would generate a failure that contains the message:
+```
+  Expected: is in range [4, 6]
+```
+
+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));
+```
+would generate a failure that contains the text:
+```
+  Expected: in closed range (4, 6)
+```
+
+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.  Matchers that don't have a parameter
+or have only one parameter have special types: you can assign `Foo()`
+to a `FooMatcher`-typed variable, and assign `Foo(p)` to a
+`FooMatcherP<p_type>`-typed variable.
+
+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.
+
+You can overload matchers with different numbers of parameters:
+```
+MATCHER_P(Blah, a, description_string_1) { ... }
+MATCHER_P2(Blah, a, b, description_string_2) { ... }
+```
+
+While it's tempting to always use the `MATCHER*` macros when defining
+a new matcher, you should also consider implementing
+`MatcherInterface` or using `MakePolymorphicMatcher()` instead (see
+the recipes that follow), especially if you need to use the matcher a
+lot.  While these approaches require more work, they give you more
+control on the types of the value being matched and the matcher
+parameters, which in general leads to better compiler error messages
+that pay off in the long run.  They also allow overloading matchers
+based on parameter types (as opposed to just based on the number of
+parameters).
+
+## Writing New Monomorphic Matchers ##
+
+A matcher of argument type `T` implements
+`::testing::MatcherInterface<T>` and does two things: it tests whether a
+value of type `T` matches the matcher, and can describe what kind of
+values it matches. The latter ability is used for generating readable
+error messages when expectations are violated.
+
+The interface looks like this:
+
+```
+class MatchResultListener {
+ public:
+  ...
+  // Streams x to the underlying ostream; does nothing if the ostream
+  // is NULL.
+  template <typename T>
+  MatchResultListener& operator<<(const T& x);
+
+  // Returns the underlying ostream.
+  ::std::ostream* stream();
+};
+
+template <typename T>
+class MatcherInterface {
+ public:
+  virtual ~MatcherInterface();
+
+  // Returns true iff the matcher matches x; also explains the match
+  // result to 'listener'.
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
+
+  // Describes this matcher to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+
+  // Describes the negation of this matcher to an ostream.
+  virtual void DescribeNegationTo(::std::ostream* os) const;
+};
+```
+
+If you need a custom matcher but `Truly()` is not a good option (for
+example, you may not be happy with the way `Truly(predicate)`
+describes itself, or you may want your matcher to be polymorphic as
+`Eq(value)` is), you can define a matcher to do whatever you want in
+two steps: first implement the matcher interface, and then define a
+factory function to create a matcher instance. The second step is not
+strictly needed but it makes the syntax of using the matcher nicer.
+
+For example, you can define a matcher to test whether an `int` is
+divisible by 7 and then use it like this:
+```
+using ::testing::MakeMatcher;
+using ::testing::Matcher;
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+
+class DivisibleBy7Matcher : public MatcherInterface<int> {
+ public:
+  virtual bool MatchAndExplain(int n, MatchResultListener* listener) const {
+    return (n % 7) == 0;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "is divisible by 7";
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is not divisible by 7";
+  }
+};
+
+inline Matcher<int> DivisibleBy7() {
+  return MakeMatcher(new DivisibleBy7Matcher);
+}
+...
+
+  EXPECT_CALL(foo, Bar(DivisibleBy7()));
+```
+
+You may improve the matcher message by streaming additional
+information to the `listener` argument in `MatchAndExplain()`:
+
+```
+class DivisibleBy7Matcher : public MatcherInterface<int> {
+ public:
+  virtual bool MatchAndExplain(int n,
+                               MatchResultListener* listener) const {
+    const int remainder = n % 7;
+    if (remainder != 0) {
+      *listener << "the remainder is " << remainder;
+    }
+    return remainder == 0;
+  }
+  ...
+};
+```
+
+Then, `EXPECT_THAT(x, DivisibleBy7());` may general a message like this:
+```
+Value of: x
+Expected: is divisible by 7
+  Actual: 23 (the remainder is 2)
+```
+
+## Writing New Polymorphic Matchers ##
+
+You've learned how to write your own matchers in the previous
+recipe. Just one problem: a matcher created using `MakeMatcher()` only
+works for one particular type of arguments. If you want a
+_polymorphic_ matcher that works with arguments of several types (for
+instance, `Eq(x)` can be used to match a `value` as long as `value` ==
+`x` compiles -- `value` and `x` don't have to share the same type),
+you can learn the trick from `"gmock/gmock-matchers.h"` but it's a bit
+involved.
+
+Fortunately, most of the time you can define a polymorphic matcher
+easily with the help of `MakePolymorphicMatcher()`. Here's how you can
+define `NotNull()` as an example:
+
+```
+using ::testing::MakePolymorphicMatcher;
+using ::testing::MatchResultListener;
+using ::testing::NotNull;
+using ::testing::PolymorphicMatcher;
+
+class NotNullMatcher {
+ public:
+  // To implement a polymorphic matcher, first define a COPYABLE class
+  // that has three members MatchAndExplain(), DescribeTo(), and
+  // DescribeNegationTo(), like the following.
+
+  // In this example, we want to use NotNull() with any pointer, so
+  // MatchAndExplain() accepts a pointer of any type as its first argument.
+  // In general, you can define MatchAndExplain() as an ordinary method or
+  // a method template, or even overload it.
+  template <typename T>
+  bool MatchAndExplain(T* p,
+                       MatchResultListener* /* listener */) const {
+    return p != NULL;
+  }
+
+  // Describes the property of a value matching this matcher.
+  void DescribeTo(::std::ostream* os) const { *os << "is not NULL"; }
+
+  // Describes the property of a value NOT matching this matcher.
+  void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
+};
+
+// To construct a polymorphic matcher, pass an instance of the class
+// to MakePolymorphicMatcher().  Note the return type.
+inline PolymorphicMatcher<NotNullMatcher> NotNull() {
+  return MakePolymorphicMatcher(NotNullMatcher());
+}
+...
+
+  EXPECT_CALL(foo, Bar(NotNull()));  // The argument must be a non-NULL pointer.
+```
+
+**Note:** Your polymorphic matcher class does **not** need to inherit from
+`MatcherInterface` or any other class, and its methods do **not** need
+to be virtual.
+
+Like in a monomorphic matcher, you may explain the match result by
+streaming additional information to the `listener` argument in
+`MatchAndExplain()`.
+
+## Writing New Cardinalities ##
+
+A cardinality is used in `Times()` to tell Google Mock how many times
+you expect a call to occur. It doesn't have to be exact. For example,
+you can say `AtLeast(5)` or `Between(2, 4)`.
+
+If the built-in set of cardinalities doesn't suit you, you are free to
+define your own by implementing the following interface (in namespace
+`testing`):
+
+```
+class CardinalityInterface {
+ public:
+  virtual ~CardinalityInterface();
+
+  // Returns true iff call_count calls will satisfy this cardinality.
+  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
+
+  // Returns true iff call_count calls will saturate this cardinality.
+  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
+
+  // Describes self to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+};
+```
+
+For example, to specify that a call must occur even number of times,
+you can write
+
+```
+using ::testing::Cardinality;
+using ::testing::CardinalityInterface;
+using ::testing::MakeCardinality;
+
+class EvenNumberCardinality : public CardinalityInterface {
+ public:
+  virtual bool IsSatisfiedByCallCount(int call_count) const {
+    return (call_count % 2) == 0;
+  }
+
+  virtual bool IsSaturatedByCallCount(int call_count) const {
+    return false;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "called even number of times";
+  }
+};
+
+Cardinality EvenNumber() {
+  return MakeCardinality(new EvenNumberCardinality);
+}
+...
+
+  EXPECT_CALL(foo, Bar(3))
+      .Times(EvenNumber());
+```
+
+## Writing New Actions Quickly ##
+
+If the built-in actions don't work for you, and you find it
+inconvenient to use `Invoke()`, you can use a macro from the `ACTION*`
+family to quickly define a new action that can be used in your code as
+if it's a built-in action.
+
+By writing
+```
+ACTION(name) { statements; }
+```
+in a namespace scope (i.e. not inside a class or function), you will
+define an action with the given name that executes the statements.
+The value returned by `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 as `argK`.  For example:
+```
+ACTION(IncrementArg1) { return ++(*arg1); }
+```
+allows you to write
+```
+... WillOnce(IncrementArg1());
+```
+
+Note that you don't need to specify the types of the mock function
+arguments.  Rest assured that your code is type-safe though:
+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.
+
+Another example:
+```
+ACTION(Foo) {
+  (*arg2)(5);
+  Blah();
+  *arg1 = 0;
+  return arg0;
+}
+```
+defines an action `Foo()` that invokes argument #2 (a function pointer)
+with 5, calls function `Blah()`, sets the value pointed to by argument
+#1 to 0, and returns argument #0.
+
+For more convenience and flexibility, you can also use the following
+pre-defined symbols in the body of `ACTION`:
+
+| `argK_type` | The type of the K-th (0-based) argument of the mock function |
+|:------------|:-------------------------------------------------------------|
+| `args`      | All arguments of the mock function as a tuple                |
+| `args_type` | The type of all arguments of the mock function as a tuple    |
+| `return_type` | The return type of the mock function                         |
+| `function_type` | The type of the mock function                                |
+
+For example, when using an `ACTION` as a stub action for mock function:
+```
+int DoSomething(bool flag, int* ptr);
+```
+we have:
+| **Pre-defined Symbol** | **Is Bound To** |
+|:-----------------------|:----------------|
+| `arg0`                 | the value of `flag` |
+| `arg0_type`            | the type `bool` |
+| `arg1`                 | the value of `ptr` |
+| `arg1_type`            | the type `int*` |
+| `args`                 | the tuple `(flag, ptr)` |
+| `args_type`            | the type `std::tr1::tuple<bool, int*>` |
+| `return_type`          | the type `int`  |
+| `function_type`        | the type `int(bool, int*)` |
+
+## Writing New Parameterized Actions Quickly ##
+
+Sometimes you'll want to parameterize an action you define.  For that
+we have another macro
+```
+ACTION_P(name, param) { statements; }
+```
+
+For example,
+```
+ACTION_P(Add, n) { return arg0 + n; }
+```
+will allow you to write
+```
+// Returns argument #0 + 5.
+... WillOnce(Add(5));
+```
+
+For convenience, we use the term _arguments_ for the values used to
+invoke the mock function, and the term _parameters_ for the values
+used to instantiate an action.
+
+Note that you don't need to provide the type of the parameter either.
+Suppose the parameter is named `param`, you can also use the
+Google-Mock-defined symbol `param_type` to refer to the type of the
+parameter as inferred by the compiler.  For example, in the body of
+`ACTION_P(Add, n)` above, you can write `n_type` for the type of `n`.
+
+Google Mock also provides `ACTION_P2`, `ACTION_P3`, and etc to support
+multi-parameter actions.  For example,
+```
+ACTION_P2(ReturnDistanceTo, x, y) {
+  double dx = arg0 - x;
+  double dy = arg1 - y;
+  return sqrt(dx*dx + dy*dy);
+}
+```
+lets you write
+```
+... WillOnce(ReturnDistanceTo(5.0, 26.5));
+```
+
+You can view `ACTION` as a degenerated parameterized action where the
+number of parameters is 0.
+
+You can also easily define actions overloaded on the number of parameters:
+```
+ACTION_P(Plus, a) { ... }
+ACTION_P2(Plus, a, b) { ... }
+```
+
+## Restricting the Type of an Argument or Parameter in an ACTION ##
+
+For maximum brevity and reusability, the `ACTION*` macros don't ask
+you to provide the types of the mock function arguments and the action
+parameters.  Instead, we let the compiler infer the types for us.
+
+Sometimes, however, we may want to be more explicit about the types.
+There are several tricks to do that.  For example:
+```
+ACTION(Foo) {
+  // Makes sure arg0 can be converted to int.
+  int n = arg0;
+  ... use n instead of arg0 here ...
+}
+
+ACTION_P(Bar, param) {
+  // Makes sure the type of arg1 is const char*.
+  ::testing::StaticAssertTypeEq<const char*, arg1_type>();
+
+  // Makes sure param can be converted to bool.
+  bool flag = param;
+}
+```
+where `StaticAssertTypeEq` is a compile-time assertion in Google Test
+that verifies two types are the same.
+
+## Writing New Action Templates Quickly ##
+
+Sometimes you want to give an action explicit template parameters that
+cannot be inferred from its value parameters.  `ACTION_TEMPLATE()`
+supports 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, where _m_ is between 1 and 10, and _n_ is
+between 0 and 10.  `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,
+                // Note the comma between int and k:
+                HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
+                AND_1_VALUE_PARAMS(output)) {
+  *output = T(std::tr1::get<k>(args));
+}
+```
+
+To create an instance of an action template, write:
+```
+  ActionName<t1, ..., t_m>(v1, ..., v_n)
+```
+where the `t`s are the template arguments and the
+`v`s are the value arguments.  The value argument
+types are inferred by the compiler.  For example:
+```
+using ::testing::_;
+...
+  int n;
+  EXPECT_CALL(mock, Foo(_, _))
+      .WillOnce(DuplicateArg<1, unsigned char>(&n));
+```
+
+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 a two-template-parameter action where the compiler
+is asked to infer the type of `x`?
+
+## Using the ACTION Object's Type ##
+
+If you are writing a function that returns an `ACTION` object, you'll
+need to know its type.  The type depends on the macro used to define
+the action and the parameter types.  The rule is relatively simple:
+| **Given Definition** | **Expression** | **Has Type** |
+|:---------------------|:---------------|:-------------|
+| `ACTION(Foo)`        | `Foo()`        | `FooAction`  |
+| `ACTION_TEMPLATE(Foo, HAS_m_TEMPLATE_PARAMS(...), AND_0_VALUE_PARAMS())` |	`Foo<t1, ..., t_m>()` | `FooAction<t1, ..., t_m>` |
+| `ACTION_P(Bar, param)` | `Bar(int_value)` | `BarActionP<int>` |
+| `ACTION_TEMPLATE(Bar, HAS_m_TEMPLATE_PARAMS(...), AND_1_VALUE_PARAMS(p1))` | `Bar<t1, ..., t_m>(int_value)` | `FooActionP<t1, ..., t_m, int>` |
+| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value, int_value)` | `BazActionP2<bool, int>` |
+| `ACTION_TEMPLATE(Baz, HAS_m_TEMPLATE_PARAMS(...), AND_2_VALUE_PARAMS(p1, p2))` | `Baz<t1, ..., t_m>(bool_value, int_value)` | `FooActionP2<t1, ..., t_m, bool, int>` |
+| ...                  | ...            | ...          |
+
+Note that we have to pick different suffixes (`Action`, `ActionP`,
+`ActionP2`, and etc) for actions with different numbers of value
+parameters, or the action definitions cannot be overloaded on the
+number of them.
+
+## Writing New Monomorphic Actions ##
+
+While the `ACTION*` macros are very convenient, sometimes they are
+inappropriate.  For example, despite the tricks shown in the previous
+recipes, they don't let you directly specify the types of the mock
+function arguments and the action parameters, which in general leads
+to unoptimized compiler error messages that can baffle unfamiliar
+users.  They also don't allow overloading actions based on parameter
+types without jumping through some hoops.
+
+An alternative to the `ACTION*` macros is to implement
+`::testing::ActionInterface<F>`, where `F` is the type of the mock
+function in which the action will be used. For example:
+
+```
+template <typename F>class ActionInterface {
+ public:
+  virtual ~ActionInterface();
+
+  // Performs the action.  Result is the return type of function type
+  // F, and ArgumentTuple is the tuple of arguments of F.
+  //
+  // For example, if F is int(bool, const string&), then Result would
+  // be int, and ArgumentTuple would be tr1::tuple<bool, const string&>.
+  virtual Result Perform(const ArgumentTuple& args) = 0;
+};
+
+using ::testing::_;
+using ::testing::Action;
+using ::testing::ActionInterface;
+using ::testing::MakeAction;
+
+typedef int IncrementMethod(int*);
+
+class IncrementArgumentAction : public ActionInterface<IncrementMethod> {
+ public:
+  virtual int Perform(const tr1::tuple<int*>& args) {
+    int* p = tr1::get<0>(args);  // Grabs the first argument.
+    return *p++;
+  }
+};
+
+Action<IncrementMethod> IncrementArgument() {
+  return MakeAction(new IncrementArgumentAction);
+}
+...
+
+  EXPECT_CALL(foo, Baz(_))
+      .WillOnce(IncrementArgument());
+
+  int n = 5;
+  foo.Baz(&n);  // Should return 5 and change n to 6.
+```
+
+## Writing New Polymorphic Actions ##
+
+The previous recipe showed you how to define your own action. This is
+all good, except that you need to know the type of the function in
+which the action will be used. Sometimes that can be a problem. For
+example, if you want to use the action in functions with _different_
+types (e.g. like `Return()` and `SetArgPointee()`).
+
+If an action can be used in several types of mock functions, we say
+it's _polymorphic_. The `MakePolymorphicAction()` function template
+makes it easy to define such an action:
+
+```
+namespace testing {
+
+template <typename Impl>
+PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl);
+
+}  // namespace testing
+```
+
+As an example, let's define an action that returns the second argument
+in the mock function's argument list. The first step is to define an
+implementation class:
+
+```
+class ReturnSecondArgumentAction {
+ public:
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& args) const {
+    // To get the i-th (0-based) argument, use tr1::get<i>(args).
+    return tr1::get<1>(args);
+  }
+};
+```
+
+This implementation class does _not_ need to inherit from any
+particular class. What matters is that it must have a `Perform()`
+method template. This method template takes the mock function's
+arguments as a tuple in a **single** argument, and returns the result of
+the action. It can be either `const` or not, but must be invokable
+with exactly one template argument, which is the result type. In other
+words, you must be able to call `Perform<R>(args)` where `R` is the
+mock function's return type and `args` is its arguments in a tuple.
+
+Next, we use `MakePolymorphicAction()` to turn an instance of the
+implementation class into the polymorphic action we need. It will be
+convenient to have a wrapper for this:
+
+```
+using ::testing::MakePolymorphicAction;
+using ::testing::PolymorphicAction;
+
+PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
+  return MakePolymorphicAction(ReturnSecondArgumentAction());
+}
+```
+
+Now, you can use this polymorphic action the same way you use the
+built-in ones:
+
+```
+using ::testing::_;
+
+class MockFoo : public Foo {
+ public:
+  MOCK_METHOD2(DoThis, int(bool flag, int n));
+  MOCK_METHOD3(DoThat, string(int x, const char* str1, const char* str2));
+};
+...
+
+  MockFoo foo;
+  EXPECT_CALL(foo, DoThis(_, _))
+      .WillOnce(ReturnSecondArgument());
+  EXPECT_CALL(foo, DoThat(_, _, _))
+      .WillOnce(ReturnSecondArgument());
+  ...
+  foo.DoThis(true, 5);         // Will return 5.
+  foo.DoThat(1, "Hi", "Bye");  // Will return "Hi".
+```
+
+## Teaching Google Mock How to Print Your Values ##
+
+When an uninteresting or unexpected call occurs, Google Mock prints the
+argument values and the stack trace to help you debug.  Assertion
+macros like `EXPECT_THAT` and `EXPECT_EQ` also print the values in
+question when the assertion fails.  Google Mock and Google Test do this using
+Google Test's user-extensible value printer.
+
+This printer knows how to print built-in C++ types, native arrays, STL
+containers, and any type that supports the `<<` operator.  For other
+types, it prints the raw bytes in the value and hopes that you the
+user can figure it out.
+[Google Test's advanced guide](http://code.google.com/p/googletest/wiki/AdvancedGuide#Teaching_Google_Test_How_to_Print_Your_Values)
+explains how to extend the printer to do a better job at
+printing your particular type than to dump the bytes.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/Documentation.md
new file mode 100644
index 00000000..d9181f28
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/Documentation.md
@@ -0,0 +1,12 @@
+This page lists all documentation wiki pages for Google Mock **(the SVN trunk version)**
+- **if you use a released version of Google Mock, please read the documentation for that specific version instead.**
+
+  * [ForDummies](V1_7_ForDummies.md) -- start here if you are new to Google Mock.
+  * [CheatSheet](V1_7_CheatSheet.md) -- a quick reference.
+  * [CookBook](V1_7_CookBook.md) -- recipes for doing various tasks using Google Mock.
+  * [FrequentlyAskedQuestions](V1_7_FrequentlyAskedQuestions.md) -- check here before asking a question on the mailing list.
+
+To contribute code to Google Mock, read:
+
+  * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
+  * [Pump Manual](http://code.google.com/p/googletest/wiki/PumpManual) -- how we generate some of Google Mock's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/ForDummies.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/ForDummies.md
new file mode 100644
index 00000000..ee03c5b9
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/ForDummies.md
@@ -0,0 +1,439 @@
+
+
+(**Note:** If you get compiler errors that you don't understand, be sure to consult [Google Mock Doctor](http://code.google.com/p/googlemock/wiki/V1_7_FrequentlyAskedQuestions#How_am_I_supposed_to_make_sense_of_these_horrible_template_error).)
+
+# What Is Google C++ Mocking Framework? #
+When you write a prototype or test, often it's not feasible or wise to rely on real objects entirely. A **mock object** implements the same interface as a real object (so it can be used as one), but lets you specify at run time how it will be used and what it should do (which methods will be called? in which order? how many times? with what arguments? what will they return? etc).
+
+**Note:** It is easy to confuse the term _fake objects_ with mock objects. Fakes and mocks actually mean very different things in the Test-Driven Development (TDD) community:
+
+  * **Fake** objects have working implementations, but usually take some shortcut (perhaps to make the operations less expensive), which makes them not suitable for production. An in-memory file system would be an example of a fake.
+  * **Mocks** are objects pre-programmed with _expectations_, which form a specification of the calls they are expected to receive.
+
+If all this seems too abstract for you, don't worry - the most important thing to remember is that a mock allows you to check the _interaction_ between itself and code that uses it. The difference between fakes and mocks will become much clearer once you start to use mocks.
+
+**Google C++ Mocking Framework** (or **Google Mock** for short) is a library (sometimes we also call it a "framework" to make it sound cool) for creating mock classes and using them. It does to C++ what [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/) do to Java.
+
+Using Google Mock involves three basic steps:
+
+  1. Use some simple macros to describe the interface you want to mock, and they will expand to the implementation of your mock class;
+  1. Create some mock objects and specify its expectations and behavior using an intuitive syntax;
+  1. Exercise code that uses the mock objects. Google Mock will catch any violation of the expectations as soon as it arises.
+
+# Why Google Mock? #
+While mock objects help you remove unnecessary dependencies in tests and make them fast and reliable, using mocks manually in C++ is _hard_:
+
+  * Someone has to implement the mocks. The job is usually tedious and error-prone. No wonder people go great distance to avoid it.
+  * The quality of those manually written mocks is a bit, uh, unpredictable. You may see some really polished ones, but you may also see some that were hacked up in a hurry and have all sorts of ad hoc restrictions.
+  * The knowledge you gained from using one mock doesn't transfer to the next.
+
+In contrast, Java and Python programmers have some fine mock frameworks, which automate the creation of mocks. As a result, mocking is a proven effective technique and widely adopted practice in those communities. Having the right tool absolutely makes the difference.
+
+Google Mock was built to help C++ programmers. It was inspired by [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/), but designed with C++'s specifics in mind. It is your friend if any of the following problems is bothering you:
+
+  * You are stuck with a sub-optimal design and wish you had done more prototyping before it was too late, but prototyping in C++ is by no means "rapid".
+  * Your tests are slow as they depend on too many libraries or use expensive resources (e.g. a database).
+  * Your tests are brittle as some resources they use are unreliable (e.g. the network).
+  * You want to test how your code handles a failure (e.g. a file checksum error), but it's not easy to cause one.
+  * You need to make sure that your module interacts with other modules in the right way, but it's hard to observe the interaction; therefore you resort to observing the side effects at the end of the action, which is awkward at best.
+  * You want to "mock out" your dependencies, except that they don't have mock implementations yet; and, frankly, you aren't thrilled by some of those hand-written mocks.
+
+We encourage you to use Google Mock as:
+
+  * a _design_ tool, for it lets you experiment with your interface design early and often. More iterations lead to better designs!
+  * a _testing_ tool to cut your tests' outbound dependencies and probe the interaction between your module and its collaborators.
+
+# Getting Started #
+Using Google Mock is easy! Inside your C++ source file, just `#include` `"gtest/gtest.h"` and `"gmock/gmock.h"`, and you are ready to go.
+
+# A Case for Mock Turtles #
+Let's look at an example. Suppose you are developing a graphics program that relies on a LOGO-like API for drawing. How would you test that it does the right thing? Well, you can run it and compare the screen with a golden screen snapshot, but let's admit it: tests like this are expensive to run and fragile (What if you just upgraded to a shiny new graphics card that has better anti-aliasing? Suddenly you have to update all your golden images.). It would be too painful if all your tests are like this. Fortunately, you learned about Dependency Injection and know the right thing to do: instead of having your application talk to the drawing API directly, wrap the API in an interface (say, `Turtle`) and code to that interface:
+
+```
+class Turtle {
+  ...
+  virtual ~Turtle() {}
+  virtual void PenUp() = 0;
+  virtual void PenDown() = 0;
+  virtual void Forward(int distance) = 0;
+  virtual void Turn(int degrees) = 0;
+  virtual void GoTo(int x, int y) = 0;
+  virtual int GetX() const = 0;
+  virtual int GetY() const = 0;
+};
+```
+
+(Note that the destructor of `Turtle` **must** be virtual, as is the case for **all** classes you intend to inherit from - otherwise the destructor of the derived class will not be called when you delete an object through a base pointer, and you'll get corrupted program states like memory leaks.)
+
+You can control whether the turtle's movement will leave a trace using `PenUp()` and `PenDown()`, and control its movement using `Forward()`, `Turn()`, and `GoTo()`. Finally, `GetX()` and `GetY()` tell you the current position of the turtle.
+
+Your program will normally use a real implementation of this interface. In tests, you can use a mock implementation instead. This allows you to easily check what drawing primitives your program is calling, with what arguments, and in which order. Tests written this way are much more robust (they won't break because your new machine does anti-aliasing differently), easier to read and maintain (the intent of a test is expressed in the code, not in some binary images), and run _much, much faster_.
+
+# Writing the Mock Class #
+If you are lucky, the mocks you need to use have already been implemented by some nice people. If, however, you find yourself in the position to write a mock class, relax - Google Mock turns this task into a fun game! (Well, almost.)
+
+## How to Define It ##
+Using the `Turtle` interface as example, here are the simple steps you need to follow:
+
+  1. Derive a class `MockTurtle` from `Turtle`.
+  1. Take a _virtual_ function of `Turtle` (while it's possible to [mock non-virtual methods using templates](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Mocking_Nonvirtual_Methods), it's much more involved). Count how many arguments it has.
+  1. In the `public:` section of the child class, write `MOCK_METHODn();` (or `MOCK_CONST_METHODn();` if you are mocking a `const` method), where `n` is the number of the arguments; if you counted wrong, shame on you, and a compiler error will tell you so.
+  1. Now comes the fun part: you take the function signature, cut-and-paste the _function name_ as the _first_ argument to the macro, and leave what's left as the _second_ argument (in case you're curious, this is the _type of the function_).
+  1. Repeat until all virtual functions you want to mock are done.
+
+After the process, you should have something like:
+
+```
+#include "gmock/gmock.h"  // Brings in Google Mock.
+class MockTurtle : public Turtle {
+ public:
+  ...
+  MOCK_METHOD0(PenUp, void());
+  MOCK_METHOD0(PenDown, void());
+  MOCK_METHOD1(Forward, void(int distance));
+  MOCK_METHOD1(Turn, void(int degrees));
+  MOCK_METHOD2(GoTo, void(int x, int y));
+  MOCK_CONST_METHOD0(GetX, int());
+  MOCK_CONST_METHOD0(GetY, int());
+};
+```
+
+You don't need to define these mock methods somewhere else - the `MOCK_METHOD*` macros will generate the definitions for you. It's that simple! Once you get the hang of it, you can pump out mock classes faster than your source-control system can handle your check-ins.
+
+**Tip:** If even this is too much work for you, you'll find the
+`gmock_gen.py` tool in Google Mock's `scripts/generator/` directory (courtesy of the [cppclean](http://code.google.com/p/cppclean/) project) useful.  This command-line
+tool requires that you have Python 2.4 installed.  You give it a C++ file and the name of an abstract class defined in it,
+and it will print the definition of the mock class for you.  Due to the
+complexity of the C++ language, this script may not always work, but
+it can be quite handy when it does.  For more details, read the [user documentation](http://code.google.com/p/googlemock/source/browse/trunk/scripts/generator/README).
+
+## Where to Put It ##
+When you define a mock class, you need to decide where to put its definition. Some people put it in a `*_test.cc`. This is fine when the interface being mocked (say, `Foo`) is owned by the same person or team. Otherwise, when the owner of `Foo` changes it, your test could break. (You can't really expect `Foo`'s maintainer to fix every test that uses `Foo`, can you?)
+
+So, the rule of thumb is: if you need to mock `Foo` and it's owned by others, define the mock class in `Foo`'s package (better, in a `testing` sub-package such that you can clearly separate production code and testing utilities), and put it in a `mock_foo.h`. Then everyone can reference `mock_foo.h` from their tests. If `Foo` ever changes, there is only one copy of `MockFoo` to change, and only tests that depend on the changed methods need to be fixed.
+
+Another way to do it: you can introduce a thin layer `FooAdaptor` on top of `Foo` and code to this new interface. Since you own `FooAdaptor`, you can absorb changes in `Foo` much more easily. While this is more work initially, carefully choosing the adaptor interface can make your code easier to write and more readable (a net win in the long run), as you can choose `FooAdaptor` to fit your specific domain much better than `Foo` does.
+
+# Using Mocks in Tests #
+Once you have a mock class, using it is easy. The typical work flow is:
+
+  1. Import the Google Mock names from the `testing` namespace such that you can use them unqualified (You only have to do it once per file. Remember that namespaces are a good idea and good for your health.).
+  1. Create some mock objects.
+  1. Specify your expectations on them (How many times will a method be called? With what arguments? What should it do? etc.).
+  1. Exercise some code that uses the mocks; optionally, check the result using Google Test assertions. If a mock method is called more than expected or with wrong arguments, you'll get an error immediately.
+  1. When a mock is destructed, Google Mock will automatically check whether all expectations on it have been satisfied.
+
+Here's an example:
+
+```
+#include "path/to/mock-turtle.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+using ::testing::AtLeast;                     // #1
+
+TEST(PainterTest, CanDrawSomething) {
+  MockTurtle turtle;                          // #2
+  EXPECT_CALL(turtle, PenDown())              // #3
+      .Times(AtLeast(1));
+
+  Painter painter(&turtle);                   // #4
+
+  EXPECT_TRUE(painter.DrawCircle(0, 0, 10));
+}                                             // #5
+
+int main(int argc, char** argv) {
+  // The following line must be executed to initialize Google Mock
+  // (and Google Test) before running the tests.
+  ::testing::InitGoogleMock(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+```
+
+As you might have guessed, this test checks that `PenDown()` is called at least once. If the `painter` object didn't call this method, your test will fail with a message like this:
+
+```
+path/to/my_test.cc:119: Failure
+Actual function call count doesn't match this expectation:
+Actually: never called;
+Expected: called at least once.
+```
+
+**Tip 1:** If you run the test from an Emacs buffer, you can hit `<Enter>` on the line number displayed in the error message to jump right to the failed expectation.
+
+**Tip 2:** If your mock objects are never deleted, the final verification won't happen. Therefore it's a good idea to use a heap leak checker in your tests when you allocate mocks on the heap.
+
+**Important note:** Google Mock requires expectations to be set **before** the mock functions are called, otherwise the behavior is **undefined**. In particular, you mustn't interleave `EXPECT_CALL()`s and calls to the mock functions.
+
+This means `EXPECT_CALL()` should be read as expecting that a call will occur _in the future_, not that a call has occurred. Why does Google Mock work like that? Well, specifying the expectation beforehand allows Google Mock to report a violation as soon as it arises, when the context (stack trace, etc) is still available. This makes debugging much easier.
+
+Admittedly, this test is contrived and doesn't do much. You can easily achieve the same effect without using Google Mock. However, as we shall reveal soon, Google Mock allows you to do _much more_ with the mocks.
+
+## Using Google Mock with Any Testing Framework ##
+If you want to use something other than Google Test (e.g. [CppUnit](http://apps.sourceforge.net/mediawiki/cppunit/index.php?title=Main_Page) or
+[CxxTest](http://cxxtest.tigris.org/)) as your testing framework, just change the `main()` function in the previous section to:
+```
+int main(int argc, char** argv) {
+  // The following line causes Google Mock to throw an exception on failure,
+  // which will be interpreted by your testing framework as a test failure.
+  ::testing::GTEST_FLAG(throw_on_failure) = true;
+  ::testing::InitGoogleMock(&argc, argv);
+  ... whatever your testing framework requires ...
+}
+```
+
+This approach has a catch: it makes Google Mock throw an exception
+from a mock object's destructor sometimes.  With some compilers, this
+sometimes causes the test program to crash.  You'll still be able to
+notice that the test has failed, but it's not a graceful failure.
+
+A better solution is to use Google Test's
+[event listener API](http://code.google.com/p/googletest/wiki/AdvancedGuide#Extending_Google_Test_by_Handling_Test_Events)
+to report a test failure to your testing framework properly.  You'll need to
+implement the `OnTestPartResult()` method of the event listener interface, but it
+should be straightforward.
+
+If this turns out to be too much work, we suggest that you stick with
+Google Test, which works with Google Mock seamlessly (in fact, it is
+technically part of Google Mock.).  If there is a reason that you
+cannot use Google Test, please let us know.
+
+# Setting Expectations #
+The key to using a mock object successfully is to set the _right expectations_ on it. If you set the expectations too strict, your test will fail as the result of unrelated changes. If you set them too loose, bugs can slip through. You want to do it just right such that your test can catch exactly the kind of bugs you intend it to catch. Google Mock provides the necessary means for you to do it "just right."
+
+## General Syntax ##
+In Google Mock we use the `EXPECT_CALL()` macro to set an expectation on a mock method. The general syntax is:
+
+```
+EXPECT_CALL(mock_object, method(matchers))
+    .Times(cardinality)
+    .WillOnce(action)
+    .WillRepeatedly(action);
+```
+
+The macro has two arguments: first the mock object, and then the method and its arguments. Note that the two are separated by a comma (`,`), not a period (`.`). (Why using a comma? The answer is that it was necessary for technical reasons.)
+
+The macro can be followed by some optional _clauses_ that provide more information about the expectation. We'll discuss how each clause works in the coming sections.
+
+This syntax is designed to make an expectation read like English. For example, you can probably guess that
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetX())
+    .Times(5)
+    .WillOnce(Return(100))
+    .WillOnce(Return(150))
+    .WillRepeatedly(Return(200));
+```
+
+says that the `turtle` object's `GetX()` method will be called five times, it will return 100 the first time, 150 the second time, and then 200 every time. Some people like to call this style of syntax a Domain-Specific Language (DSL).
+
+**Note:** Why do we use a macro to do this? It serves two purposes: first it makes expectations easily identifiable (either by `grep` or by a human reader), and second it allows Google Mock to include the source file location of a failed expectation in messages, making debugging easier.
+
+## Matchers: What Arguments Do We Expect? ##
+When a mock function takes arguments, we must specify what arguments we are expecting; for example:
+
+```
+// Expects the turtle to move forward by 100 units.
+EXPECT_CALL(turtle, Forward(100));
+```
+
+Sometimes you may not want to be too specific (Remember that talk about tests being too rigid? Over specification leads to brittle tests and obscures the intent of tests. Therefore we encourage you to specify only what's necessary - no more, no less.). If you care to check that `Forward()` will be called but aren't interested in its actual argument, write `_` as the argument, which means "anything goes":
+
+```
+using ::testing::_;
+...
+// Expects the turtle to move forward.
+EXPECT_CALL(turtle, Forward(_));
+```
+
+`_` is an instance of what we call **matchers**. A matcher is like a predicate and can test whether an argument is what we'd expect. You can use a matcher inside `EXPECT_CALL()` wherever a function argument is expected.
+
+A list of built-in matchers can be found in the [CheatSheet](V1_7_CheatSheet.md). For example, here's the `Ge` (greater than or equal) matcher:
+
+```
+using ::testing::Ge;...
+EXPECT_CALL(turtle, Forward(Ge(100)));
+```
+
+This checks that the turtle will be told to go forward by at least 100 units.
+
+## Cardinalities: How Many Times Will It Be Called? ##
+The first clause we can specify following an `EXPECT_CALL()` is `Times()`. We call its argument a **cardinality** as it tells _how many times_ the call should occur. It allows us to repeat an expectation many times without actually writing it as many times. More importantly, a cardinality can be "fuzzy", just like a matcher can be. This allows a user to express the intent of a test exactly.
+
+An interesting special case is when we say `Times(0)`. You may have guessed - it means that the function shouldn't be called with the given arguments at all, and Google Mock will report a Google Test failure whenever the function is (wrongfully) called.
+
+We've seen `AtLeast(n)` as an example of fuzzy cardinalities earlier. For the list of built-in cardinalities you can use, see the [CheatSheet](V1_7_CheatSheet.md).
+
+The `Times()` clause can be omitted. **If you omit `Times()`, Google Mock will infer the cardinality for you.** The rules are easy to remember:
+
+  * If **neither** `WillOnce()` **nor** `WillRepeatedly()` is in the `EXPECT_CALL()`, the inferred cardinality is `Times(1)`.
+  * If there are `n WillOnce()`'s but **no** `WillRepeatedly()`, where `n` >= 1, the cardinality is `Times(n)`.
+  * If there are `n WillOnce()`'s and **one** `WillRepeatedly()`, where `n` >= 0, the cardinality is `Times(AtLeast(n))`.
+
+**Quick quiz:** what do you think will happen if a function is expected to be called twice but actually called four times?
+
+## Actions: What Should It Do? ##
+Remember that a mock object doesn't really have a working implementation? We as users have to tell it what to do when a method is invoked. This is easy in Google Mock.
+
+First, if the return type of a mock function is a built-in type or a pointer, the function has a **default action** (a `void` function will just return, a `bool` function will return `false`, and other functions will return 0). If you don't say anything, this behavior will be used.
+
+Second, if a mock function doesn't have a default action, or the default action doesn't suit you, you can specify the action to be taken each time the expectation matches using a series of `WillOnce()` clauses followed by an optional `WillRepeatedly()`. For example,
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetX())
+    .WillOnce(Return(100))
+    .WillOnce(Return(200))
+    .WillOnce(Return(300));
+```
+
+This says that `turtle.GetX()` will be called _exactly three times_ (Google Mock inferred this from how many `WillOnce()` clauses we've written, since we didn't explicitly write `Times()`), and will return 100, 200, and 300 respectively.
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetY())
+    .WillOnce(Return(100))
+    .WillOnce(Return(200))
+    .WillRepeatedly(Return(300));
+```
+
+says that `turtle.GetY()` will be called _at least twice_ (Google Mock knows this as we've written two `WillOnce()` clauses and a `WillRepeatedly()` while having no explicit `Times()`), will return 100 the first time, 200 the second time, and 300 from the third time on.
+
+Of course, if you explicitly write a `Times()`, Google Mock will not try to infer the cardinality itself. What if the number you specified is larger than there are `WillOnce()` clauses? Well, after all `WillOnce()`s are used up, Google Mock will do the _default_ action for the function every time (unless, of course, you have a `WillRepeatedly()`.).
+
+What can we do inside `WillOnce()` besides `Return()`? You can return a reference using `ReturnRef(variable)`, or invoke a pre-defined function, among [others](http://code.google.com/p/googlemock/wiki/V1_7_CheatSheet#Actions).
+
+**Important note:** The `EXPECT_CALL()` statement evaluates the action clause only once, even though the action may be performed many times. Therefore you must be careful about side effects. The following may not do what you want:
+
+```
+int n = 100;
+EXPECT_CALL(turtle, GetX())
+.Times(4)
+.WillRepeatedly(Return(n++));
+```
+
+Instead of returning 100, 101, 102, ..., consecutively, this mock function will always return 100 as `n++` is only evaluated once. Similarly, `Return(new Foo)` will create a new `Foo` object when the `EXPECT_CALL()` is executed, and will return the same pointer every time. If you want the side effect to happen every time, you need to define a custom action, which we'll teach in the [CookBook](V1_7_CookBook.md).
+
+Time for another quiz! What do you think the following means?
+
+```
+using ::testing::Return;...
+EXPECT_CALL(turtle, GetY())
+.Times(4)
+.WillOnce(Return(100));
+```
+
+Obviously `turtle.GetY()` is expected to be called four times. But if you think it will return 100 every time, think twice! Remember that one `WillOnce()` clause will be consumed each time the function is invoked and the default action will be taken afterwards. So the right answer is that `turtle.GetY()` will return 100 the first time, but **return 0 from the second time on**, as returning 0 is the default action for `int` functions.
+
+## Using Multiple Expectations ##
+So far we've only shown examples where you have a single expectation. More realistically, you're going to specify expectations on multiple mock methods, which may be from multiple mock objects.
+
+By default, when a mock method is invoked, Google Mock will search the expectations in the **reverse order** they are defined, and stop when an active expectation that matches the arguments is found (you can think of it as "newer rules override older ones."). If the matching expectation cannot take any more calls, you will get an upper-bound-violated failure. Here's an example:
+
+```
+using ::testing::_;...
+EXPECT_CALL(turtle, Forward(_));  // #1
+EXPECT_CALL(turtle, Forward(10))  // #2
+    .Times(2);
+```
+
+If `Forward(10)` is called three times in a row, the third time it will be an error, as the last matching expectation (#2) has been saturated. If, however, the third `Forward(10)` call is replaced by `Forward(20)`, then it would be OK, as now #1 will be the matching expectation.
+
+**Side note:** Why does Google Mock search for a match in the _reverse_ order of the expectations? The reason is that this allows a user to set up the default expectations in a mock object's constructor or the test fixture's set-up phase and then customize the mock by writing more specific expectations in the test body. So, if you have two expectations on the same method, you want to put the one with more specific matchers **after** the other, or the more specific rule would be shadowed by the more general one that comes after it.
+
+## Ordered vs Unordered Calls ##
+By default, an expectation can match a call even though an earlier expectation hasn't been satisfied. In other words, the calls don't have to occur in the order the expectations are specified.
+
+Sometimes, you may want all the expected calls to occur in a strict order. To say this in Google Mock is easy:
+
+```
+using ::testing::InSequence;...
+TEST(FooTest, DrawsLineSegment) {
+  ...
+  {
+    InSequence dummy;
+
+    EXPECT_CALL(turtle, PenDown());
+    EXPECT_CALL(turtle, Forward(100));
+    EXPECT_CALL(turtle, PenUp());
+  }
+  Foo();
+}
+```
+
+By creating an object of type `InSequence`, all expectations in its scope are put into a _sequence_ and have to occur _sequentially_. Since we are just relying on the constructor and destructor of this object to do the actual work, its name is really irrelevant.
+
+In this example, we test that `Foo()` calls the three expected functions in the order as written. If a call is made out-of-order, it will be an error.
+
+(What if you care about the relative order of some of the calls, but not all of them? Can you specify an arbitrary partial order? The answer is ... yes! If you are impatient, the details can be found in the [CookBook](V1_7_CookBook#Expecting_Partially_Ordered_Calls.md).)
+
+## All Expectations Are Sticky (Unless Said Otherwise) ##
+Now let's do a quick quiz to see how well you can use this mock stuff already. How would you test that the turtle is asked to go to the origin _exactly twice_ (you want to ignore any other instructions it receives)?
+
+After you've come up with your answer, take a look at ours and compare notes (solve it yourself first - don't cheat!):
+
+```
+using ::testing::_;...
+EXPECT_CALL(turtle, GoTo(_, _))  // #1
+    .Times(AnyNumber());
+EXPECT_CALL(turtle, GoTo(0, 0))  // #2
+    .Times(2);
+```
+
+Suppose `turtle.GoTo(0, 0)` is called three times. In the third time, Google Mock will see that the arguments match expectation #2 (remember that we always pick the last matching expectation). Now, since we said that there should be only two such calls, Google Mock will report an error immediately. This is basically what we've told you in the "Using Multiple Expectations" section above.
+
+This example shows that **expectations in Google Mock are "sticky" by default**, in the sense that they remain active even after we have reached their invocation upper bounds. This is an important rule to remember, as it affects the meaning of the spec, and is **different** to how it's done in many other mocking frameworks (Why'd we do that? Because we think our rule makes the common cases easier to express and understand.).
+
+Simple? Let's see if you've really understood it: what does the following code say?
+
+```
+using ::testing::Return;
+...
+for (int i = n; i > 0; i--) {
+  EXPECT_CALL(turtle, GetX())
+      .WillOnce(Return(10*i));
+}
+```
+
+If you think it says that `turtle.GetX()` will be called `n` times and will return 10, 20, 30, ..., consecutively, think twice! The problem is that, as we said, expectations are sticky. So, the second time `turtle.GetX()` is called, the last (latest) `EXPECT_CALL()` statement will match, and will immediately lead to an "upper bound exceeded" error - this piece of code is not very useful!
+
+One correct way of saying that `turtle.GetX()` will return 10, 20, 30, ..., is to explicitly say that the expectations are _not_ sticky. In other words, they should _retire_ as soon as they are saturated:
+
+```
+using ::testing::Return;
+...
+for (int i = n; i > 0; i--) {
+  EXPECT_CALL(turtle, GetX())
+    .WillOnce(Return(10*i))
+    .RetiresOnSaturation();
+}
+```
+
+And, there's a better way to do it: in this case, we expect the calls to occur in a specific order, and we line up the actions to match the order. Since the order is important here, we should make it explicit using a sequence:
+
+```
+using ::testing::InSequence;
+using ::testing::Return;
+...
+{
+  InSequence s;
+
+  for (int i = 1; i <= n; i++) {
+    EXPECT_CALL(turtle, GetX())
+        .WillOnce(Return(10*i))
+        .RetiresOnSaturation();
+  }
+}
+```
+
+By the way, the other situation where an expectation may _not_ be sticky is when it's in a sequence - as soon as another expectation that comes after it in the sequence has been used, it automatically retires (and will never be used to match any call).
+
+## Uninteresting Calls ##
+A mock object may have many methods, and not all of them are that interesting. For example, in some tests we may not care about how many times `GetX()` and `GetY()` get called.
+
+In Google Mock, if you are not interested in a method, just don't say anything about it. If a call to this method occurs, you'll see a warning in the test output, but it won't be a failure.
+
+# What Now? #
+Congratulations! You've learned enough about Google Mock to start using it. Now, you might want to join the [googlemock](http://groups.google.com/group/googlemock) discussion group and actually write some tests using Google Mock - it will be fun. Hey, it may even be addictive - you've been warned.
+
+Then, if you feel like increasing your mock quotient, you should move on to the [CookBook](V1_7_CookBook.md). You can learn many advanced features of Google Mock there -- and advance your level of enjoyment and testing bliss.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/FrequentlyAskedQuestions.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/FrequentlyAskedQuestions.md
new file mode 100644
index 00000000..fa21233a
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/FrequentlyAskedQuestions.md
@@ -0,0 +1,628 @@
+
+
+Please send your questions to the
+[googlemock](http://groups.google.com/group/googlemock) discussion
+group. If you need help with compiler errors, make sure you have
+tried [Google Mock Doctor](#How_am_I_supposed_to_make_sense_of_these_horrible_template_error.md) first.
+
+## When I call a method on my mock object, the method for the real object is invoked instead.  What's the problem? ##
+
+In order for a method to be mocked, it must be _virtual_, unless you use the [high-perf dependency injection technique](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Mocking_Nonvirtual_Methods).
+
+## I wrote some matchers.  After I upgraded to a new version of Google Mock, they no longer compile.  What's going on? ##
+
+After version 1.4.0 of Google Mock was released, we had an idea on how
+to make it easier to write matchers that can generate informative
+messages efficiently.  We experimented with this idea and liked what
+we saw.  Therefore we decided to implement it.
+
+Unfortunately, this means that if you have defined your own matchers
+by implementing `MatcherInterface` or using `MakePolymorphicMatcher()`,
+your definitions will no longer compile.  Matchers defined using the
+`MATCHER*` family of macros are not affected.
+
+Sorry for the hassle if your matchers are affected.  We believe it's
+in everyone's long-term interest to make this change sooner than
+later.  Fortunately, it's usually not hard to migrate an existing
+matcher to the new API.  Here's what you need to do:
+
+If you wrote your matcher like this:
+```
+// Old matcher definition that doesn't work with the latest
+// Google Mock.
+using ::testing::MatcherInterface;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetFoo() > 5;
+  }
+  ...
+};
+```
+
+you'll need to change it to:
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool MatchAndExplain(MyType value,
+                               MatchResultListener* listener) const {
+    // Returns true if value matches.
+    return value.GetFoo() > 5;
+  }
+  ...
+};
+```
+(i.e. rename `Matches()` to `MatchAndExplain()` and give it a second
+argument of type `MatchResultListener*`.)
+
+If you were also using `ExplainMatchResultTo()` to improve the matcher
+message:
+```
+// Old matcher definition that doesn't work with the lastest
+// Google Mock.
+using ::testing::MatcherInterface;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetFoo() > 5;
+  }
+
+  virtual void ExplainMatchResultTo(MyType value,
+                                    ::std::ostream* os) const {
+    // Prints some helpful information to os to help
+    // a user understand why value matches (or doesn't match).
+    *os << "the Foo property is " << value.GetFoo();
+  }
+  ...
+};
+```
+
+you should move the logic of `ExplainMatchResultTo()` into
+`MatchAndExplain()`, using the `MatchResultListener` argument where
+the `::std::ostream` was used:
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+...
+class MyWonderfulMatcher : public MatcherInterface<MyType> {
+ public:
+  ...
+  virtual bool MatchAndExplain(MyType value,
+                               MatchResultListener* listener) const {
+    // Returns true if value matches.
+    *listener << "the Foo property is " << value.GetFoo();
+    return value.GetFoo() > 5;
+  }
+  ...
+};
+```
+
+If your matcher is defined using `MakePolymorphicMatcher()`:
+```
+// Old matcher definition that doesn't work with the latest
+// Google Mock.
+using ::testing::MakePolymorphicMatcher;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetBar() < 42;
+  }
+  ...
+};
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+you should rename the `Matches()` method to `MatchAndExplain()` and
+add a `MatchResultListener*` argument (the same as what you need to do
+for matchers defined by implementing `MatcherInterface`):
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MakePolymorphicMatcher;
+using ::testing::MatchResultListener;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool MatchAndExplain(MyType value,
+                       MatchResultListener* listener) const {
+    // Returns true if value matches.
+    return value.GetBar() < 42;
+  }
+  ...
+};
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+If your polymorphic matcher uses `ExplainMatchResultTo()` for better
+failure messages:
+```
+// Old matcher definition that doesn't work with the latest
+// Google Mock.
+using ::testing::MakePolymorphicMatcher;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool Matches(MyType value) const {
+    // Returns true if value matches.
+    return value.GetBar() < 42;
+  }
+  ...
+};
+void ExplainMatchResultTo(const MyGreatMatcher& matcher,
+                          MyType value,
+                          ::std::ostream* os) {
+  // Prints some helpful information to os to help
+  // a user understand why value matches (or doesn't match).
+  *os << "the Bar property is " << value.GetBar();
+}
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+you'll need to move the logic inside `ExplainMatchResultTo()` to
+`MatchAndExplain()`:
+```
+// New matcher definition that works with the latest Google Mock.
+using ::testing::MakePolymorphicMatcher;
+using ::testing::MatchResultListener;
+...
+class MyGreatMatcher {
+ public:
+  ...
+  bool MatchAndExplain(MyType value,
+                       MatchResultListener* listener) const {
+    // Returns true if value matches.
+    *listener << "the Bar property is " << value.GetBar();
+    return value.GetBar() < 42;
+  }
+  ...
+};
+... MakePolymorphicMatcher(MyGreatMatcher()) ...
+```
+
+For more information, you can read these
+[two](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Writing_New_Monomorphic_Matchers)
+[recipes](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Writing_New_Polymorphic_Matchers)
+from the cookbook.  As always, you
+are welcome to post questions on `googlemock@googlegroups.com` if you
+need any help.
+
+## When using Google Mock, do I have to use Google Test as the testing framework?  I have my favorite testing framework and don't want to switch. ##
+
+Google Mock works out of the box with Google Test.  However, it's easy
+to configure it to work with any testing framework of your choice.
+[Here](http://code.google.com/p/googlemock/wiki/V1_7_ForDummies#Using_Google_Mock_with_Any_Testing_Framework) is how.
+
+## How am I supposed to make sense of these horrible template errors? ##
+
+If you are confused by the compiler errors gcc threw at you,
+try consulting the _Google Mock Doctor_ tool first.  What it does is to
+scan stdin for gcc error messages, and spit out diagnoses on the
+problems (we call them diseases) your code has.
+
+To "install", run command:
+```
+alias gmd='<path to googlemock>/scripts/gmock_doctor.py'
+```
+
+To use it, do:
+```
+<your-favorite-build-command> <your-test> 2>&1 | gmd
+```
+
+For example:
+```
+make my_test 2>&1 | gmd
+```
+
+Or you can run `gmd` and copy-n-paste gcc's error messages to it.
+
+## Can I mock a variadic function? ##
+
+You cannot mock a variadic function (i.e. a function taking ellipsis
+(`...`) arguments) directly in Google Mock.
+
+The problem is that in general, there is _no way_ for a mock object to
+know how many arguments are passed to the variadic method, and what
+the arguments' types are.  Only the _author of the base class_ knows
+the protocol, and we cannot look into his head.
+
+Therefore, to mock such a function, the _user_ must teach the mock
+object how to figure out the number of arguments and their types.  One
+way to do it is to provide overloaded versions of the function.
+
+Ellipsis arguments are inherited from C and not really a C++ feature.
+They are unsafe to use and don't work with arguments that have
+constructors or destructors.  Therefore we recommend to avoid them in
+C++ as much as possible.
+
+## MSVC gives me warning C4301 or C4373 when I define a mock method with a const parameter.  Why? ##
+
+If you compile this using Microsoft Visual C++ 2005 SP1:
+```
+class Foo {
+  ...
+  virtual void Bar(const int i) = 0;
+};
+
+class MockFoo : public Foo {
+  ...
+  MOCK_METHOD1(Bar, void(const int i));
+};
+```
+You may get the following warning:
+```
+warning C4301: 'MockFoo::Bar': overriding virtual function only differs from 'Foo::Bar' by const/volatile qualifier
+```
+
+This is a MSVC bug.  The same code compiles fine with gcc ,for
+example.  If you use Visual C++ 2008 SP1, you would get the warning:
+```
+warning C4373: 'MockFoo::Bar': virtual function overrides 'Foo::Bar', previous versions of the compiler did not override when parameters only differed by const/volatile qualifiers
+```
+
+In C++, if you _declare_ a function with a `const` parameter, the
+`const` modifier is _ignored_.  Therefore, the `Foo` base class above
+is equivalent to:
+```
+class Foo {
+  ...
+  virtual void Bar(int i) = 0;  // int or const int?  Makes no difference.
+};
+```
+
+In fact, you can _declare_ Bar() with an `int` parameter, and _define_
+it with a `const int` parameter.  The compiler will still match them
+up.
+
+Since making a parameter `const` is meaningless in the method
+_declaration_, we recommend to remove it in both `Foo` and `MockFoo`.
+That should workaround the VC bug.
+
+Note that we are talking about the _top-level_ `const` modifier here.
+If the function parameter is passed by pointer or reference, declaring
+the _pointee_ or _referee_ as `const` is still meaningful.  For
+example, the following two declarations are _not_ equivalent:
+```
+void Bar(int* p);        // Neither p nor *p is const.
+void Bar(const int* p);  // p is not const, but *p is.
+```
+
+## I have a huge mock class, and Microsoft Visual C++ runs out of memory when compiling it.  What can I do? ##
+
+We've noticed that when the `/clr` compiler flag is used, Visual C++
+uses 5~6 times as much memory when compiling a mock class.  We suggest
+to avoid `/clr` when compiling native C++ mocks.
+
+## I can't figure out why Google Mock thinks my expectations are not satisfied.  What should I do? ##
+
+You might want to run your test with
+`--gmock_verbose=info`.  This flag lets Google Mock print a trace
+of every mock function call it receives.  By studying the trace,
+you'll gain insights on why the expectations you set are not met.
+
+## How can I assert that a function is NEVER called? ##
+
+```
+EXPECT_CALL(foo, Bar(_))
+    .Times(0);
+```
+
+## I have a failed test where Google Mock tells me TWICE that a particular expectation is not satisfied.  Isn't this redundant? ##
+
+When Google Mock detects a failure, it prints relevant information
+(the mock function arguments, the state of relevant expectations, and
+etc) to help the user debug.  If another failure is detected, Google
+Mock will do the same, including printing the state of relevant
+expectations.
+
+Sometimes an expectation's state didn't change between two failures,
+and you'll see the same description of the state twice.  They are
+however _not_ redundant, as they refer to _different points in time_.
+The fact they are the same _is_ interesting information.
+
+## I get a heap check failure when using a mock object, but using a real object is fine.  What can be wrong? ##
+
+Does the class (hopefully a pure interface) you are mocking have a
+virtual destructor?
+
+Whenever you derive from a base class, make sure its destructor is
+virtual.  Otherwise Bad Things will happen.  Consider the following
+code:
+
+```
+class Base {
+ public:
+  // Not virtual, but should be.
+  ~Base() { ... }
+  ...
+};
+
+class Derived : public Base {
+ public:
+  ...
+ private:
+  std::string value_;
+};
+
+...
+  Base* p = new Derived;
+  ...
+  delete p;  // Surprise! ~Base() will be called, but ~Derived() will not
+             // - value_ is leaked.
+```
+
+By changing `~Base()` to virtual, `~Derived()` will be correctly
+called when `delete p` is executed, and the heap checker
+will be happy.
+
+## The "newer expectations override older ones" rule makes writing expectations awkward.  Why does Google Mock do that? ##
+
+When people complain about this, often they are referring to code like:
+
+```
+// foo.Bar() should be called twice, return 1 the first time, and return
+// 2 the second time.  However, I have to write the expectations in the
+// reverse order.  This sucks big time!!!
+EXPECT_CALL(foo, Bar())
+    .WillOnce(Return(2))
+    .RetiresOnSaturation();
+EXPECT_CALL(foo, Bar())
+    .WillOnce(Return(1))
+    .RetiresOnSaturation();
+```
+
+The problem is that they didn't pick the **best** way to express the test's
+intent.
+
+By default, expectations don't have to be matched in _any_ particular
+order.  If you want them to match in a certain order, you need to be
+explicit.  This is Google Mock's (and jMock's) fundamental philosophy: it's
+easy to accidentally over-specify your tests, and we want to make it
+harder to do so.
+
+There are two better ways to write the test spec.  You could either
+put the expectations in sequence:
+
+```
+// foo.Bar() should be called twice, return 1 the first time, and return
+// 2 the second time.  Using a sequence, we can write the expectations
+// in their natural order.
+{
+  InSequence s;
+  EXPECT_CALL(foo, Bar())
+      .WillOnce(Return(1))
+      .RetiresOnSaturation();
+  EXPECT_CALL(foo, Bar())
+      .WillOnce(Return(2))
+      .RetiresOnSaturation();
+}
+```
+
+or you can put the sequence of actions in the same expectation:
+
+```
+// foo.Bar() should be called twice, return 1 the first time, and return
+// 2 the second time.
+EXPECT_CALL(foo, Bar())
+    .WillOnce(Return(1))
+    .WillOnce(Return(2))
+    .RetiresOnSaturation();
+```
+
+Back to the original questions: why does Google Mock search the
+expectations (and `ON_CALL`s) from back to front?  Because this
+allows a user to set up a mock's behavior for the common case early
+(e.g. in the mock's constructor or the test fixture's set-up phase)
+and customize it with more specific rules later.  If Google Mock
+searches from front to back, this very useful pattern won't be
+possible.
+
+## Google Mock prints a warning when a function without EXPECT\_CALL is called, even if I have set its behavior using ON\_CALL.  Would it be reasonable not to show the warning in this case? ##
+
+When choosing between being neat and being safe, we lean toward the
+latter.  So the answer is that we think it's better to show the
+warning.
+
+Often people write `ON_CALL`s in the mock object's
+constructor or `SetUp()`, as the default behavior rarely changes from
+test to test.  Then in the test body they set the expectations, which
+are often different for each test.  Having an `ON_CALL` in the set-up
+part of a test doesn't mean that the calls are expected.  If there's
+no `EXPECT_CALL` and the method is called, it's possibly an error.  If
+we quietly let the call go through without notifying the user, bugs
+may creep in unnoticed.
+
+If, however, you are sure that the calls are OK, you can write
+
+```
+EXPECT_CALL(foo, Bar(_))
+    .WillRepeatedly(...);
+```
+
+instead of
+
+```
+ON_CALL(foo, Bar(_))
+    .WillByDefault(...);
+```
+
+This tells Google Mock that you do expect the calls and no warning should be
+printed.
+
+Also, you can control the verbosity using the `--gmock_verbose` flag.
+If you find the output too noisy when debugging, just choose a less
+verbose level.
+
+## How can I delete the mock function's argument in an action? ##
+
+If you find yourself needing to perform some action that's not
+supported by Google Mock directly, remember that you can define your own
+actions using
+[MakeAction()](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Writing_New_Actions) or
+[MakePolymorphicAction()](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Writing_New_Polymorphic_Actions),
+or you can write a stub function and invoke it using
+[Invoke()](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Using_Functions_Methods_Functors).
+
+## MOCK\_METHODn()'s second argument looks funny.  Why don't you use the MOCK\_METHODn(Method, return\_type, arg\_1, ..., arg\_n) syntax? ##
+
+What?!  I think it's beautiful. :-)
+
+While which syntax looks more natural is a subjective matter to some
+extent, Google Mock's syntax was chosen for several practical advantages it
+has.
+
+Try to mock a function that takes a map as an argument:
+```
+virtual int GetSize(const map<int, std::string>& m);
+```
+
+Using the proposed syntax, it would be:
+```
+MOCK_METHOD1(GetSize, int, const map<int, std::string>& m);
+```
+
+Guess what?  You'll get a compiler error as the compiler thinks that
+`const map<int, std::string>& m` are **two**, not one, arguments. To work
+around this you can use `typedef` to give the map type a name, but
+that gets in the way of your work.  Google Mock's syntax avoids this
+problem as the function's argument types are protected inside a pair
+of parentheses:
+```
+// This compiles fine.
+MOCK_METHOD1(GetSize, int(const map<int, std::string>& m));
+```
+
+You still need a `typedef` if the return type contains an unprotected
+comma, but that's much rarer.
+
+Other advantages include:
+  1. `MOCK_METHOD1(Foo, int, bool)` can leave a reader wonder whether the method returns `int` or `bool`, while there won't be such confusion using Google Mock's syntax.
+  1. The way Google Mock describes a function type is nothing new, although many people may not be familiar with it.  The same syntax was used in C, and the `function` library in `tr1` uses this syntax extensively.  Since `tr1` will become a part of the new version of STL, we feel very comfortable to be consistent with it.
+  1. The function type syntax is also used in other parts of Google Mock's API (e.g. the action interface) in order to make the implementation tractable. A user needs to learn it anyway in order to utilize Google Mock's more advanced features.  We'd as well stick to the same syntax in `MOCK_METHOD*`!
+
+## My code calls a static/global function.  Can I mock it? ##
+
+You can, but you need to make some changes.
+
+In general, if you find yourself needing to mock a static function,
+it's a sign that your modules are too tightly coupled (and less
+flexible, less reusable, less testable, etc).  You are probably better
+off defining a small interface and call the function through that
+interface, which then can be easily mocked.  It's a bit of work
+initially, but usually pays for itself quickly.
+
+This Google Testing Blog
+[post](http://googletesting.blogspot.com/2008/06/defeat-static-cling.html)
+says it excellently.  Check it out.
+
+## My mock object needs to do complex stuff.  It's a lot of pain to specify the actions.  Google Mock sucks! ##
+
+I know it's not a question, but you get an answer for free any way. :-)
+
+With Google Mock, you can create mocks in C++ easily.  And people might be
+tempted to use them everywhere. Sometimes they work great, and
+sometimes you may find them, well, a pain to use. So, what's wrong in
+the latter case?
+
+When you write a test without using mocks, you exercise the code and
+assert that it returns the correct value or that the system is in an
+expected state.  This is sometimes called "state-based testing".
+
+Mocks are great for what some call "interaction-based" testing:
+instead of checking the system state at the very end, mock objects
+verify that they are invoked the right way and report an error as soon
+as it arises, giving you a handle on the precise context in which the
+error was triggered.  This is often more effective and economical to
+do than state-based testing.
+
+If you are doing state-based testing and using a test double just to
+simulate the real object, you are probably better off using a fake.
+Using a mock in this case causes pain, as it's not a strong point for
+mocks to perform complex actions.  If you experience this and think
+that mocks suck, you are just not using the right tool for your
+problem. Or, you might be trying to solve the wrong problem. :-)
+
+## I got a warning "Uninteresting function call encountered - default action taken.."  Should I panic? ##
+
+By all means, NO!  It's just an FYI.
+
+What it means is that you have a mock function, you haven't set any
+expectations on it (by Google Mock's rule this means that you are not
+interested in calls to this function and therefore it can be called
+any number of times), and it is called.  That's OK - you didn't say
+it's not OK to call the function!
+
+What if you actually meant to disallow this function to be called, but
+forgot to write `EXPECT_CALL(foo, Bar()).Times(0)`?  While
+one can argue that it's the user's fault, Google Mock tries to be nice and
+prints you a note.
+
+So, when you see the message and believe that there shouldn't be any
+uninteresting calls, you should investigate what's going on.  To make
+your life easier, Google Mock prints the function name and arguments
+when an uninteresting call is encountered.
+
+## I want to define a custom action.  Should I use Invoke() or implement the action interface? ##
+
+Either way is fine - you want to choose the one that's more convenient
+for your circumstance.
+
+Usually, if your action is for a particular function type, defining it
+using `Invoke()` should be easier; if your action can be used in
+functions of different types (e.g. if you are defining
+`Return(value)`), `MakePolymorphicAction()` is
+easiest.  Sometimes you want precise control on what types of
+functions the action can be used in, and implementing
+`ActionInterface` is the way to go here. See the implementation of
+`Return()` in `include/gmock/gmock-actions.h` for an example.
+
+## I'm using the set-argument-pointee action, and the compiler complains about "conflicting return type specified".  What does it mean? ##
+
+You got this error as Google Mock has no idea what value it should return
+when the mock method is called.  `SetArgPointee()` says what the
+side effect is, but doesn't say what the return value should be.  You
+need `DoAll()` to chain a `SetArgPointee()` with a `Return()`.
+
+See this [recipe](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Mocking_Side_Effects) for more details and an example.
+
+
+## My question is not in your FAQ! ##
+
+If you cannot find the answer to your question in this FAQ, there are
+some other resources you can use:
+
+  1. read other [wiki pages](http://code.google.com/p/googlemock/w/list),
+  1. search the mailing list [archive](http://groups.google.com/group/googlemock/topics),
+  1. ask it on [googlemock@googlegroups.com](mailto:googlemock@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googlemock) before you can post.).
+
+Please note that creating an issue in the
+[issue tracker](http://code.google.com/p/googlemock/issues/list) is _not_
+a good way to get your answer, as it is monitored infrequently by a
+very small number of people.
+
+When asking a question, it's helpful to provide as much of the
+following information as possible (people cannot help you if there's
+not enough information in your question):
+
+  * the version (or the revision number if you check out from SVN directly) of Google Mock you use (Google Mock is under active development, so it's possible that your problem has been solved in a later version),
+  * your operating system,
+  * the name and version of your compiler,
+  * the complete command line flags you give to your compiler,
+  * the complete compiler error messages (if the question is about compilation),
+  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-actions.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-actions.h
new file mode 100644
index 00000000..b3f654af
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-actions.h
@@ -0,0 +1,1205 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used actions.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+
+#ifndef _WIN32_WCE
+# include <errno.h>
+#endif
+
+#include <algorithm>
+#include <string>
+
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gmock/internal/gmock-port.h"
+
+#if GTEST_HAS_STD_TYPE_TRAITS_  // Defined by gtest-port.h via gmock-port.h.
+#include <type_traits>
+#endif
+
+namespace testing {
+
+// To implement an action Foo, define:
+//   1. a class FooAction that implements the ActionInterface interface, and
+//   2. a factory function that creates an Action object from a
+//      const FooAction*.
+//
+// The two-level delegation design follows that of Matcher, providing
+// consistency for extension developers.  It also eases ownership
+// management as Action objects can now be copied like plain values.
+
+namespace internal {
+
+template <typename F1, typename F2>
+class ActionAdaptor;
+
+// BuiltInDefaultValueGetter<T, true>::Get() returns a
+// default-constructed T value.  BuiltInDefaultValueGetter<T,
+// false>::Get() crashes with an error.
+//
+// This primary template is used when kDefaultConstructible is true.
+template <typename T, bool kDefaultConstructible>
+struct BuiltInDefaultValueGetter {
+  static T Get() { return T(); }
+};
+template <typename T>
+struct BuiltInDefaultValueGetter<T, false> {
+  static T Get() {
+    Assert(false, __FILE__, __LINE__,
+           "Default action undefined for the function return type.");
+    return internal::Invalid<T>();
+    // The above statement will never be reached, but is required in
+    // order for this function to compile.
+  }
+};
+
+// BuiltInDefaultValue<T>::Get() returns the "built-in" default value
+// for type T, which is NULL when T is a raw pointer type, 0 when T is
+// a numeric type, false when T is bool, or "" when T is string or
+// std::string.  In addition, in C++11 and above, it turns a
+// default-constructed T value if T is default constructible.  For any
+// other type T, the built-in default T value is undefined, and the
+// function will abort the process.
+template <typename T>
+class BuiltInDefaultValue {
+ public:
+#if GTEST_HAS_STD_TYPE_TRAITS_
+  // This function returns true iff type T has a built-in default value.
+  static bool Exists() {
+    return ::std::is_default_constructible<T>::value;
+  }
+
+  static T Get() {
+    return BuiltInDefaultValueGetter<
+        T, ::std::is_default_constructible<T>::value>::Get();
+  }
+
+#else  // GTEST_HAS_STD_TYPE_TRAITS_
+  // This function returns true iff type T has a built-in default value.
+  static bool Exists() {
+    return false;
+  }
+
+  static T Get() {
+    return BuiltInDefaultValueGetter<T, false>::Get();
+  }
+
+#endif  // GTEST_HAS_STD_TYPE_TRAITS_
+};
+
+// This partial specialization says that we use the same built-in
+// default value for T and const T.
+template <typename T>
+class BuiltInDefaultValue<const T> {
+ public:
+  static bool Exists() { return BuiltInDefaultValue<T>::Exists(); }
+  static T Get() { return BuiltInDefaultValue<T>::Get(); }
+};
+
+// This partial specialization defines the default values for pointer
+// types.
+template <typename T>
+class BuiltInDefaultValue<T*> {
+ public:
+  static bool Exists() { return true; }
+  static T* Get() { return NULL; }
+};
+
+// The following specializations define the default values for
+// specific types we care about.
+#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
+  template <> \
+  class BuiltInDefaultValue<type> { \
+   public: \
+    static bool Exists() { return true; } \
+    static type Get() { return value; } \
+  }
+
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, );  // NOLINT
+#if GTEST_HAS_GLOBAL_STRING
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::string, "");
+#endif  // GTEST_HAS_GLOBAL_STRING
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, "");
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0');
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0');
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0');
+
+// There's no need for a default action for signed wchar_t, as that
+// type is the same as wchar_t for gcc, and invalid for MSVC.
+//
+// There's also no need for a default action for unsigned wchar_t, as
+// that type is the same as unsigned int for gcc, and invalid for
+// MSVC.
+#if GMOCK_WCHAR_T_IS_NATIVE_
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U);  // NOLINT
+#endif
+
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0);     // NOLINT
+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_(UInt64, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(Int64, 0);
+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_
+
+}  // namespace internal
+
+// When an unexpected function call is encountered, Google Mock will
+// let it return a default value if the user has specified one for its
+// return type, or if the return type has a built-in default value;
+// otherwise Google Mock won't know what value to return and will have
+// to abort the process.
+//
+// The DefaultValue<T> class allows a user to specify the
+// default value for a type T that is both copyable and publicly
+// destructible (i.e. anything that can be used as a function return
+// type).  The usage is:
+//
+//   // Sets the default value for type T to be foo.
+//   DefaultValue<T>::Set(foo);
+template <typename T>
+class DefaultValue {
+ public:
+  // Sets the default value for type T; requires T to be
+  // copy-constructable and have a public destructor.
+  static void Set(T x) {
+    delete producer_;
+    producer_ = new FixedValueProducer(x);
+  }
+
+  // Provides a factory function to be called to generate the default value.
+  // This method can be used even if T is only move-constructible, but it is not
+  // limited to that case.
+  typedef T (*FactoryFunction)();
+  static void SetFactory(FactoryFunction factory) {
+    delete producer_;
+    producer_ = new FactoryValueProducer(factory);
+  }
+
+  // Unsets the default value for type T.
+  static void Clear() {
+    delete producer_;
+    producer_ = NULL;
+  }
+
+  // Returns true iff the user has set the default value for type T.
+  static bool IsSet() { return producer_ != NULL; }
+
+  // Returns true if T has a default return value set by the user or there
+  // exists a built-in default value.
+  static bool Exists() {
+    return IsSet() || internal::BuiltInDefaultValue<T>::Exists();
+  }
+
+  // Returns the default value for type T if the user has set one;
+  // 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_ == NULL ?
+        internal::BuiltInDefaultValue<T>::Get() : producer_->Produce();
+  }
+
+ private:
+  class ValueProducer {
+   public:
+    virtual ~ValueProducer() {}
+    virtual T Produce() = 0;
+  };
+
+  class FixedValueProducer : public ValueProducer {
+   public:
+    explicit FixedValueProducer(T value) : value_(value) {}
+    virtual T Produce() { return value_; }
+
+   private:
+    const T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer);
+  };
+
+  class FactoryValueProducer : public ValueProducer {
+   public:
+    explicit FactoryValueProducer(FactoryFunction factory)
+        : factory_(factory) {}
+    virtual T Produce() { return factory_(); }
+
+   private:
+    const FactoryFunction factory_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer);
+  };
+
+  static ValueProducer* producer_;
+};
+
+// This partial specialization allows a user to set default values for
+// reference types.
+template <typename T>
+class DefaultValue<T&> {
+ public:
+  // Sets the default value for type T&.
+  static void Set(T& x) {  // NOLINT
+    address_ = &x;
+  }
+
+  // Unsets the default value for type T&.
+  static void Clear() {
+    address_ = NULL;
+  }
+
+  // Returns true iff the user has set the default value for type T&.
+  static bool IsSet() { return address_ != NULL; }
+
+  // Returns true if T has a default return value set by the user or there
+  // exists a built-in default value.
+  static bool Exists() {
+    return IsSet() || internal::BuiltInDefaultValue<T&>::Exists();
+  }
+
+  // Returns the default value for type T& if the user has set one;
+  // otherwise returns the built-in default value if there is one;
+  // otherwise aborts the process.
+  static T& Get() {
+    return address_ == NULL ?
+        internal::BuiltInDefaultValue<T&>::Get() : *address_;
+  }
+
+ private:
+  static T* address_;
+};
+
+// This specialization allows DefaultValue<void>::Get() to
+// compile.
+template <>
+class DefaultValue<void> {
+ public:
+  static bool Exists() { return true; }
+  static void Get() {}
+};
+
+// Points to the user-set default value for type T.
+template <typename T>
+typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = NULL;
+
+// Points to the user-set default value for type T&.
+template <typename T>
+T* DefaultValue<T&>::address_ = NULL;
+
+// Implement this interface to define an action for function type F.
+template <typename F>
+class ActionInterface {
+ public:
+  typedef typename internal::Function<F>::Result Result;
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  ActionInterface() {}
+  virtual ~ActionInterface() {}
+
+  // Performs the action.  This method is not const, as in general an
+  // action can have side effects and be stateful.  For example, a
+  // get-the-next-element-from-the-collection action will need to
+  // remember the current element.
+  virtual Result Perform(const ArgumentTuple& args) = 0;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(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
+// linked_ptr to const ActionInterface<T>, so copying is fairly cheap.
+// 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 {
+ 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() : impl_(NULL) {}
+
+  // Constructs an Action from its implementation.  A NULL impl is
+  // used to represent the "do-default" action.
+  explicit Action(ActionInterface<F>* impl) : impl_(impl) {}
+
+  // Copy constructor.
+  Action(const Action& action) : impl_(action.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.
+  template <typename Func>
+  explicit Action(const Action<Func>& action);
+
+  // Returns true iff this is the DoDefault() action.
+  bool IsDoDefault() const { return impl_.get() == NULL; }
+
+  // Performs the action.  Note that this method is const even though
+  // the corresponding method in ActionInterface is not.  The reason
+  // is that a const Action<F> means that it cannot be re-bound to
+  // 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(const ArgumentTuple& args) const {
+    internal::Assert(
+        !IsDoDefault(), __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.");
+    return impl_->Perform(args);
+  }
+
+ private:
+  template <typename F1, typename F2>
+  friend class internal::ActionAdaptor;
+
+  internal::linked_ptr<ActionInterface<F> > impl_;
+};
+
+// The PolymorphicAction class template makes it easy to implement a
+// polymorphic action (i.e. an action that can be used in mock
+// functions of than one type, e.g. Return()).
+//
+// To define a polymorphic action, a user first provides a COPYABLE
+// implementation class that has a Perform() method template:
+//
+//   class FooAction {
+//    public:
+//     template <typename Result, typename ArgumentTuple>
+//     Result Perform(const ArgumentTuple& args) const {
+//       // Processes the arguments and returns a result, using
+//       // tr1::get<N>(args) to get the N-th (0-based) argument in the tuple.
+//     }
+//     ...
+//   };
+//
+// Then the user creates the polymorphic action using
+// MakePolymorphicAction(object) where object has type FooAction.  See
+// the definition of Return(void) and SetArgumentPointee<N>(value) for
+// complete examples.
+template <typename Impl>
+class PolymorphicAction {
+ public:
+  explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}
+
+  template <typename F>
+  operator Action<F>() const {
+    return Action<F>(new MonomorphicImpl<F>(impl_));
+  }
+
+ private:
+  template <typename F>
+  class MonomorphicImpl : public ActionInterface<F> {
+   public:
+    typedef typename internal::Function<F>::Result Result;
+    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
+
+    virtual Result Perform(const ArgumentTuple& args) {
+      return impl_.template Perform<Result>(args);
+    }
+
+   private:
+    Impl impl_;
+
+    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
+  };
+
+  Impl impl_;
+
+  GTEST_DISALLOW_ASSIGN_(PolymorphicAction);
+};
+
+// Creates an Action from its implementation and returns it.  The
+// created Action object owns the implementation.
+template <typename F>
+Action<F> MakeAction(ActionInterface<F>* impl) {
+  return Action<F>(impl);
+}
+
+// Creates a polymorphic action from its implementation.  This is
+// easier to use than the PolymorphicAction<Impl> constructor as it
+// doesn't require you to explicitly write the template argument, e.g.
+//
+//   MakePolymorphicAction(foo);
+// vs
+//   PolymorphicAction<TypeOfFoo>(foo);
+template <typename Impl>
+inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) {
+  return PolymorphicAction<Impl>(impl);
+}
+
+namespace internal {
+
+// Allows an Action<F2> object to pose as an Action<F1>, as long as F2
+// and F1 are compatible.
+template <typename F1, typename F2>
+class ActionAdaptor : public ActionInterface<F1> {
+ public:
+  typedef typename internal::Function<F1>::Result Result;
+  typedef typename internal::Function<F1>::ArgumentTuple ArgumentTuple;
+
+  explicit ActionAdaptor(const Action<F2>& from) : impl_(from.impl_) {}
+
+  virtual Result Perform(const ArgumentTuple& args) {
+    return impl_->Perform(args);
+  }
+
+ private:
+  const internal::linked_ptr<ActionInterface<F2> > impl_;
+
+  GTEST_DISALLOW_ASSIGN_(ActionAdaptor);
+};
+
+// Helper struct to specialize ReturnAction to execute a move instead of a copy
+// on return. Useful for move-only types, but could be used on any type.
+template <typename T>
+struct ByMoveWrapper {
+  explicit ByMoveWrapper(T value) : payload(internal::move(value)) {}
+  T payload;
+};
+
+// Implements the polymorphic Return(x) action, which can be used in
+// any function that returns the type of x, regardless of the argument
+// types.
+//
+// Note: The value passed into Return must be converted into
+// Function<F>::Result when this action is cast to Action<F> rather than
+// when that action is performed. This is important in scenarios like
+//
+// MOCK_METHOD1(Method, T(U));
+// ...
+// {
+//   Foo foo;
+//   X x(&foo);
+//   EXPECT_CALL(mock, Method(_)).WillOnce(Return(x));
+// }
+//
+// In the example above the variable x holds reference to foo which leaves
+// scope and gets destroyed.  If copying X just copies a reference to foo,
+// that copy will be left with a hanging reference.  If conversion to T
+// makes a copy of foo, the above code is safe. To support that scenario, we
+// need to make sure that the type conversion happens inside the EXPECT_CALL
+// statement, and conversion of the result of Return to Action<T(U)> is a
+// good place for that.
+//
+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(internal::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 {
+    // Assert statement belongs here because this is the best place to verify
+    // conditions on F. It produces the clearest error messages
+    // in most compilers.
+    // Impl really belongs in this scope as a local class but can't
+    // because MSVC produces duplicate symbols in different translation units
+    // in this case. Until MS fixes that bug we put Impl into the class scope
+    // and put the typedef both here (for use in assert statement) and
+    // in the Impl class. But both definitions must be the same.
+    typedef typename Function<F>::Result Result;
+    GTEST_COMPILE_ASSERT_(
+        !is_reference<Result>::value,
+        use_ReturnRef_instead_of_Return_to_return_a_reference);
+    return Action<F>(new Impl<R, F>(value_));
+  }
+
+ private:
+  // Implements the Return(x) action for a particular function type F.
+  template <typename R_, typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    // The implicit cast is necessary when Result has more than one
+    // single-argument constructor (e.g. Result is std::vector<int>) and R
+    // has a type conversion operator template.  In that case, value_(value)
+    // won't compile as the compiler doesn't known which constructor of
+    // 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 linked_ptr<R>& value)
+        : value_before_cast_(*value),
+          value_(ImplicitCast_<Result>(value_before_cast_)) {}
+
+    virtual Result Perform(const ArgumentTuple&) { return value_; }
+
+   private:
+    GTEST_COMPILE_ASSERT_(!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.
+    R value_before_cast_;
+    Result value_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
+  };
+
+  // Partially specialize for ByMoveWrapper. This version of ReturnAction will
+  // move its contents instead.
+  template <typename R_, typename F>
+  class Impl<ByMoveWrapper<R_>, F> : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const linked_ptr<R>& wrapper)
+        : performed_(false), wrapper_(wrapper) {}
+
+    virtual Result Perform(const ArgumentTuple&) {
+      GTEST_CHECK_(!performed_)
+          << "A ByMove() action should only be performed once.";
+      performed_ = true;
+      return internal::move(wrapper_->payload);
+    }
+
+   private:
+    bool performed_;
+    const linked_ptr<R> wrapper_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  const linked_ptr<R> value_;
+
+  GTEST_DISALLOW_ASSIGN_(ReturnAction);
+};
+
+// Implements the ReturnNull() action.
+class ReturnNullAction {
+ public:
+  // Allows ReturnNull() to be used in any pointer-returning function. In C++11
+  // this is enforced by returning nullptr, and in non-C++11 by asserting a
+  // pointer type on compile time.
+  template <typename Result, typename ArgumentTuple>
+  static Result Perform(const ArgumentTuple&) {
+#if GTEST_LANG_CXX11
+    return nullptr;
+#else
+    GTEST_COMPILE_ASSERT_(internal::is_pointer<Result>::value,
+                          ReturnNull_can_be_used_to_return_a_pointer_only);
+    return NULL;
+#endif  // GTEST_LANG_CXX11
+  }
+};
+
+// Implements the Return() action.
+class ReturnVoidAction {
+ public:
+  // Allows Return() to be used in any void-returning function.
+  template <typename Result, typename ArgumentTuple>
+  static void Perform(const ArgumentTuple&) {
+    CompileAssertTypesEqual<void, Result>();
+  }
+};
+
+// Implements the polymorphic ReturnRef(x) action, which can be used
+// in any function that returns a reference to the type of x,
+// regardless of the argument types.
+template <typename T>
+class ReturnRefAction {
+ public:
+  // Constructs a ReturnRefAction object from the reference to be returned.
+  explicit ReturnRefAction(T& ref) : ref_(ref) {}  // NOLINT
+
+  // This template type conversion operator allows ReturnRef(x) to be
+  // used in ANY function that returns a reference to x's type.
+  template <typename F>
+  operator Action<F>() const {
+    typedef typename Function<F>::Result Result;
+    // 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_(internal::is_reference<Result>::value,
+                          use_Return_instead_of_ReturnRef_to_return_a_value);
+    return Action<F>(new Impl<F>(ref_));
+  }
+
+ private:
+  // Implements the ReturnRef(x) action for a particular function type F.
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(T& ref) : ref_(ref) {}  // NOLINT
+
+    virtual Result Perform(const ArgumentTuple&) {
+      return ref_;
+    }
+
+   private:
+    T& ref_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  T& ref_;
+
+  GTEST_DISALLOW_ASSIGN_(ReturnRefAction);
+};
+
+// Implements the polymorphic ReturnRefOfCopy(x) action, which can be
+// used in any function that returns a reference to the type of x,
+// regardless of the argument types.
+template <typename T>
+class ReturnRefOfCopyAction {
+ public:
+  // Constructs a ReturnRefOfCopyAction object from the reference to
+  // be returned.
+  explicit ReturnRefOfCopyAction(const T& value) : value_(value) {}  // NOLINT
+
+  // This template type conversion operator allows ReturnRefOfCopy(x) to be
+  // used in ANY function that returns a reference to x's type.
+  template <typename F>
+  operator Action<F>() const {
+    typedef typename Function<F>::Result Result;
+    // Asserts that the function return type is a reference.  This
+    // catches the user error of using ReturnRefOfCopy(x) when Return(x)
+    // should be used, and generates some helpful error message.
+    GTEST_COMPILE_ASSERT_(
+        internal::is_reference<Result>::value,
+        use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
+    return Action<F>(new Impl<F>(value_));
+  }
+
+ private:
+  // Implements the ReturnRefOfCopy(x) action for a particular function type F.
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const T& value) : value_(value) {}  // NOLINT
+
+    virtual Result Perform(const ArgumentTuple&) {
+      return value_;
+    }
+
+   private:
+    T value_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  const T value_;
+
+  GTEST_DISALLOW_ASSIGN_(ReturnRefOfCopyAction);
+};
+
+// Implements the polymorphic DoDefault() action.
+class DoDefaultAction {
+ public:
+  // This template type conversion operator allows DoDefault() to be
+  // used in any function.
+  template <typename F>
+  operator Action<F>() const { return Action<F>(NULL); }
+};
+
+// Implements the Assign action to set a given pointer referent to a
+// particular value.
+template <typename T1, typename T2>
+class AssignAction {
+ public:
+  AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}
+
+  template <typename Result, typename ArgumentTuple>
+  void Perform(const ArgumentTuple& /* args */) const {
+    *ptr_ = value_;
+  }
+
+ private:
+  T1* const ptr_;
+  const T2 value_;
+
+  GTEST_DISALLOW_ASSIGN_(AssignAction);
+};
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+// Implements the SetErrnoAndReturn action to simulate return from
+// various system calls and libc functions.
+template <typename T>
+class SetErrnoAndReturnAction {
+ public:
+  SetErrnoAndReturnAction(int errno_value, T result)
+      : errno_(errno_value),
+        result_(result) {}
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& /* args */) const {
+    errno = errno_;
+    return result_;
+  }
+
+ private:
+  const int errno_;
+  const T result_;
+
+  GTEST_DISALLOW_ASSIGN_(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.  The
+// template parameter kIsProto is true iff type A is ProtocolMessage,
+// proto2::Message, or a sub-class of those.
+template <size_t N, typename A, bool kIsProto>
+class SetArgumentPointeeAction {
+ public:
+  // Constructs an action that sets the variable pointed to by the
+  // N-th function argument to 'value'.
+  explicit SetArgumentPointeeAction(const A& value) : value_(value) {}
+
+  template <typename Result, typename ArgumentTuple>
+  void Perform(const ArgumentTuple& args) const {
+    CompileAssertTypesEqual<void, Result>();
+    *::testing::get<N>(args) = value_;
+  }
+
+ private:
+  const A value_;
+
+  GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
+};
+
+template <size_t N, typename Proto>
+class SetArgumentPointeeAction<N, Proto, true> {
+ public:
+  // Constructs an action that sets the variable pointed to by the
+  // N-th function argument to 'proto'.  Both ProtocolMessage and
+  // proto2::Message have the CopyFrom() method, so the same
+  // implementation works for both.
+  explicit SetArgumentPointeeAction(const Proto& proto) : proto_(new Proto) {
+    proto_->CopyFrom(proto);
+  }
+
+  template <typename Result, typename ArgumentTuple>
+  void Perform(const ArgumentTuple& args) const {
+    CompileAssertTypesEqual<void, Result>();
+    ::testing::get<N>(args)->CopyFrom(*proto_);
+  }
+
+ private:
+  const internal::linked_ptr<Proto> proto_;
+
+  GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
+};
+
+// 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 (i.e. f can be
+// assigned to a tr1::function<F>).
+template <typename FunctionImpl>
+class InvokeWithoutArgsAction {
+ public:
+  // The c'tor makes a copy of function_impl (either a function
+  // pointer or a functor).
+  explicit InvokeWithoutArgsAction(FunctionImpl function_impl)
+      : function_impl_(function_impl) {}
+
+  // Allows InvokeWithoutArgs(f) to be used as any action whose type is
+  // compatible with f.
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple&) { return function_impl_(); }
+
+ private:
+  FunctionImpl function_impl_;
+
+  GTEST_DISALLOW_ASSIGN_(InvokeWithoutArgsAction);
+};
+
+// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
+template <class Class, typename MethodPtr>
+class InvokeMethodWithoutArgsAction {
+ public:
+  InvokeMethodWithoutArgsAction(Class* obj_ptr, MethodPtr method_ptr)
+      : obj_ptr_(obj_ptr), method_ptr_(method_ptr) {}
+
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple&) const {
+    return (obj_ptr_->*method_ptr_)();
+  }
+
+ private:
+  Class* const obj_ptr_;
+  const MethodPtr method_ptr_;
+
+  GTEST_DISALLOW_ASSIGN_(InvokeMethodWithoutArgsAction);
+};
+
+// Implements the IgnoreResult(action) action.
+template <typename A>
+class IgnoreResultAction {
+ public:
+  explicit IgnoreResultAction(const A& action) : action_(action) {}
+
+  template <typename F>
+  operator Action<F>() const {
+    // Assert statement belongs here because this is the best place to verify
+    // conditions on F. It produces the clearest error messages
+    // in most compilers.
+    // Impl really belongs in this scope as a local class but can't
+    // because MSVC produces duplicate symbols in different translation units
+    // in this case. Until MS fixes that bug we put Impl into the class scope
+    // and put the typedef both here (for use in assert statement) and
+    // in the Impl class. But both definitions must be the same.
+    typedef typename internal::Function<F>::Result Result;
+
+    // Asserts at compile time that F returns void.
+    CompileAssertTypesEqual<void, Result>();
+
+    return Action<F>(new Impl<F>(action_));
+  }
+
+ private:
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename internal::Function<F>::Result Result;
+    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const A& action) : action_(action) {}
+
+    virtual void Perform(const ArgumentTuple& args) {
+      // Performs the action and ignores its result.
+      action_.Perform(args);
+    }
+
+   private:
+    // Type OriginalFunction is the same as F except that its return
+    // type is IgnoredValue.
+    typedef typename internal::Function<F>::MakeResultIgnoredValue
+        OriginalFunction;
+
+    const Action<OriginalFunction> action_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  const A action_;
+
+  GTEST_DISALLOW_ASSIGN_(IgnoreResultAction);
+};
+
+// A ReferenceWrapper<T> object represents a reference to type T,
+// which can be either const or not.  It can be explicitly converted
+// from, and implicitly converted to, a T&.  Unlike a reference,
+// ReferenceWrapper<T> can be copied and can survive template type
+// inference.  This is used to support by-reference arguments in the
+// InvokeArgument<N>(...) action.  The idea was from "reference
+// wrappers" in tr1, which we don't have in our source tree yet.
+template <typename T>
+class ReferenceWrapper {
+ public:
+  // Constructs a ReferenceWrapper<T> object from a T&.
+  explicit ReferenceWrapper(T& l_value) : pointer_(&l_value) {}  // NOLINT
+
+  // Allows a ReferenceWrapper<T> object to be implicitly converted to
+  // a T&.
+  operator T&() const { return *pointer_; }
+ private:
+  T* pointer_;
+};
+
+// Allows the expression ByRef(x) to be printed as a reference to x.
+template <typename T>
+void PrintTo(const ReferenceWrapper<T>& ref, ::std::ostream* os) {
+  T& value = ref;
+  UniversalPrinter<T&>::Print(value, os);
+}
+
+// Does two actions sequentially.  Used for implementing the DoAll(a1,
+// a2, ...) action.
+template <typename Action1, typename Action2>
+class DoBothAction {
+ public:
+  DoBothAction(Action1 action1, Action2 action2)
+      : action1_(action1), action2_(action2) {}
+
+  // This template type conversion operator allows DoAll(a1, ..., a_n)
+  // to be used in ANY function of compatible type.
+  template <typename F>
+  operator Action<F>() const {
+    return Action<F>(new Impl<F>(action1_, action2_));
+  }
+
+ private:
+  // Implements the DoAll(...) action for a particular function type F.
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+    typedef typename Function<F>::MakeResultVoid VoidResult;
+
+    Impl(const Action<VoidResult>& action1, const Action<F>& action2)
+        : action1_(action1), action2_(action2) {}
+
+    virtual Result Perform(const ArgumentTuple& args) {
+      action1_.Perform(args);
+      return action2_.Perform(args);
+    }
+
+   private:
+    const Action<VoidResult> action1_;
+    const Action<F> action2_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  Action1 action1_;
+  Action2 action2_;
+
+  GTEST_DISALLOW_ASSIGN_(DoBothAction);
+};
+
+}  // namespace internal
+
+// An Unused object can be implicitly constructed from ANY value.
+// This is handy when defining actions that ignore some or all of the
+// mock function arguments.  For example, given
+//
+//   MOCK_METHOD3(Foo, double(const string& label, double x, double y));
+//   MOCK_METHOD3(Bar, double(int index, double x, double y));
+//
+// instead of
+//
+//   double DistanceToOriginWithLabel(const string& label, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   double DistanceToOriginWithIndex(int index, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   ...
+//   EXEPCT_CALL(mock, Foo("abc", _, _))
+//       .WillOnce(Invoke(DistanceToOriginWithLabel));
+//   EXEPCT_CALL(mock, Bar(5, _, _))
+//       .WillOnce(Invoke(DistanceToOriginWithIndex));
+//
+// you could write
+//
+//   // We can declare any uninteresting argument as Unused.
+//   double DistanceToOrigin(Unused, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   ...
+//   EXEPCT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
+//   EXEPCT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
+typedef internal::IgnoredValue Unused;
+
+// This constructor allows us to turn an Action<From> object into an
+// Action<To>, as long as To's arguments can be implicitly converted
+// to From's and From's return type cann be implicitly converted to
+// To's.
+template <typename To>
+template <typename From>
+Action<To>::Action(const Action<From>& from)
+    : impl_(new internal::ActionAdaptor<To, From>(from)) {}
+
+// 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>(internal::move(value));
+}
+
+// Creates an action that returns NULL.
+inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
+  return MakePolymorphicAction(internal::ReturnNullAction());
+}
+
+// Creates an action that returns from a void function.
+inline PolymorphicAction<internal::ReturnVoidAction> Return() {
+  return MakePolymorphicAction(internal::ReturnVoidAction());
+}
+
+// Creates an action that returns the reference to a variable.
+template <typename R>
+inline internal::ReturnRefAction<R> ReturnRef(R& x) {  // NOLINT
+  return internal::ReturnRefAction<R>(x);
+}
+
+// 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.
+template <typename R>
+inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) {
+  return internal::ReturnRefOfCopyAction<R>(x);
+}
+
+// Modifies the parent action (a Return() action) to perform a move of the
+// argument instead of a copy.
+// Return(ByMove()) actions can only be executed once and will assert this
+// invariant.
+template <typename R>
+internal::ByMoveWrapper<R> ByMove(R x) {
+  return internal::ByMoveWrapper<R>(internal::move(x));
+}
+
+// Creates an action that does the default action for the give mock function.
+inline internal::DoDefaultAction DoDefault() {
+  return internal::DoDefaultAction();
+}
+
+// Creates an action that sets the variable pointed by the N-th
+// (0-based) function argument to 'value'.
+template <size_t N, typename T>
+PolymorphicAction<
+  internal::SetArgumentPointeeAction<
+    N, T, internal::IsAProtocolMessage<T>::value> >
+SetArgPointee(const T& x) {
+  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
+      N, T, internal::IsAProtocolMessage<T>::value>(x));
+}
+
+#if !((GTEST_GCC_VER_ && GTEST_GCC_VER_ < 40000) || GTEST_OS_SYMBIAN)
+// This overload allows SetArgPointee() to accept a string literal.
+// GCC prior to the version 4.0 and Symbian C++ compiler cannot distinguish
+// this overload from the templated version and emit a compile error.
+template <size_t N>
+PolymorphicAction<
+  internal::SetArgumentPointeeAction<N, const char*, false> >
+SetArgPointee(const char* p) {
+  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
+      N, const char*, false>(p));
+}
+
+template <size_t N>
+PolymorphicAction<
+  internal::SetArgumentPointeeAction<N, const wchar_t*, false> >
+SetArgPointee(const wchar_t* p) {
+  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
+      N, const wchar_t*, false>(p));
+}
+#endif
+
+// The following version is DEPRECATED.
+template <size_t N, typename T>
+PolymorphicAction<
+  internal::SetArgumentPointeeAction<
+    N, T, internal::IsAProtocolMessage<T>::value> >
+SetArgumentPointee(const T& x) {
+  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
+      N, T, internal::IsAProtocolMessage<T>::value>(x));
+}
+
+// Creates an action that sets a pointer referent to a given value.
+template <typename T1, typename T2>
+PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
+  return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
+}
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+// Creates an action that sets errno and returns the appropriate error.
+template <typename T>
+PolymorphicAction<internal::SetErrnoAndReturnAction<T> >
+SetErrnoAndReturn(int errval, T result) {
+  return MakePolymorphicAction(
+      internal::SetErrnoAndReturnAction<T>(errval, result));
+}
+
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Various overloads for InvokeWithoutArgs().
+
+// Creates an action that invokes 'function_impl' with no argument.
+template <typename FunctionImpl>
+PolymorphicAction<internal::InvokeWithoutArgsAction<FunctionImpl> >
+InvokeWithoutArgs(FunctionImpl function_impl) {
+  return MakePolymorphicAction(
+      internal::InvokeWithoutArgsAction<FunctionImpl>(function_impl));
+}
+
+// Creates an action that invokes the given method on the given object
+// with no argument.
+template <class Class, typename MethodPtr>
+PolymorphicAction<internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> >
+InvokeWithoutArgs(Class* obj_ptr, MethodPtr method_ptr) {
+  return MakePolymorphicAction(
+      internal::InvokeMethodWithoutArgsAction<Class, MethodPtr>(
+          obj_ptr, method_ptr));
+}
+
+// Creates an action that performs an_action and throws away its
+// result.  In other words, it changes the return type of an_action to
+// void.  an_action MUST NOT return void, or the code won't compile.
+template <typename A>
+inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) {
+  return internal::IgnoreResultAction<A>(an_action);
+}
+
+// Creates a reference wrapper for the given L-value.  If necessary,
+// you can explicitly specify the type of the reference.  For example,
+// suppose 'derived' is an object of type Derived, ByRef(derived)
+// would wrap a Derived&.  If you want to wrap a const Base& instead,
+// where Base is a base class of Derived, just write:
+//
+//   ByRef<const Base>(derived)
+template <typename T>
+inline internal::ReferenceWrapper<T> ByRef(T& l_value) {  // NOLINT
+  return internal::ReferenceWrapper<T>(l_value);
+}
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-cardinalities.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-cardinalities.h
new file mode 100644
index 00000000..fc315f92
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-cardinalities.h
@@ -0,0 +1,147 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// 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.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+
+#include <limits.h>
+#include <ostream>  // NOLINT
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+
+// To implement a cardinality Foo, define:
+//   1. a class FooCardinality that implements the
+//      CardinalityInterface interface, and
+//   2. a factory function that creates a Cardinality object from a
+//      const FooCardinality*.
+//
+// The two-level delegation design follows that of Matcher, providing
+// consistency for extension developers.  It also eases ownership
+// management as Cardinality objects can now be copied like plain values.
+
+// The implementation of a cardinality.
+class CardinalityInterface {
+ public:
+  virtual ~CardinalityInterface() {}
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  virtual int ConservativeLowerBound() const { return 0; }
+  virtual int ConservativeUpperBound() const { return INT_MAX; }
+
+  // Returns true iff call_count calls will satisfy this cardinality.
+  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
+
+  // Returns true iff call_count calls will saturate this cardinality.
+  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
+
+  // Describes self to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+};
+
+// 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 linked_ptr
+// to const CardinalityInterface, so copying is fairly cheap.
+// Don't inherit from Cardinality!
+class GTEST_API_ Cardinality {
+ public:
+  // Constructs a null cardinality.  Needed for storing Cardinality
+  // objects in STL containers.
+  Cardinality() {}
+
+  // Constructs a Cardinality from its implementation.
+  explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); }
+  int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); }
+
+  // Returns true iff call_count calls will satisfy this cardinality.
+  bool IsSatisfiedByCallCount(int call_count) const {
+    return impl_->IsSatisfiedByCallCount(call_count);
+  }
+
+  // Returns true iff call_count calls will saturate this cardinality.
+  bool IsSaturatedByCallCount(int call_count) const {
+    return impl_->IsSaturatedByCallCount(call_count);
+  }
+
+  // Returns true iff 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) &&
+        !impl_->IsSatisfiedByCallCount(call_count);
+  }
+
+  // Describes self to an ostream
+  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
+
+  // Describes the given actual call count to an ostream.
+  static void DescribeActualCallCountTo(int actual_call_count,
+                                        ::std::ostream* os);
+
+ private:
+  internal::linked_ptr<const CardinalityInterface> impl_;
+};
+
+// Creates a cardinality that allows at least n calls.
+GTEST_API_ Cardinality AtLeast(int n);
+
+// Creates a cardinality that allows at most n calls.
+GTEST_API_ Cardinality AtMost(int n);
+
+// Creates a cardinality that allows any number of calls.
+GTEST_API_ Cardinality AnyNumber();
+
+// Creates a cardinality that allows between min and max calls.
+GTEST_API_ Cardinality Between(int min, int max);
+
+// Creates a cardinality that allows exactly n calls.
+GTEST_API_ Cardinality Exactly(int n);
+
+// Creates a cardinality from its implementation.
+inline Cardinality MakeCardinality(const CardinalityInterface* c) {
+  return Cardinality(c);
+}
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h
new file mode 100644
index 00000000..b5a889c0
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h
@@ -0,0 +1,2377 @@
+// This file was GENERATED by a script.  DO NOT EDIT BY HAND!!!
+
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used variadic actions.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
+
+#include "gmock/gmock-actions.h"
+#include "gmock/internal/gmock-port.h"
+
+namespace testing {
+namespace internal {
+
+// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary
+// function or method with the unpacked values, where F is a function
+// type that takes N arguments.
+template <typename Result, typename ArgumentTuple>
+class InvokeHelper;
+
+template <typename R>
+class InvokeHelper<R, ::testing::tuple<> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<>&) {
+           return function();
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<>&) {
+           return (obj_ptr->*method_ptr)();
+  }
+};
+
+template <typename R, typename A1>
+class InvokeHelper<R, ::testing::tuple<A1> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1>& args) {
+           return function(get<0>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2>
+class InvokeHelper<R, ::testing::tuple<A1, A2> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2>& args) {
+           return function(get<0>(args), get<1>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
+      A4>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4,
+      A5>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args), get<4>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4, A5>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args), get<4>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
+      A6>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args), get<4>(args), get<5>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4, A5, A6>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args), get<4>(args), get<5>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
+      A6, A7>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args), get<4>(args), get<5>(args), get<6>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4, A5, A6,
+                            A7>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
+               get<6>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
+      A6, A7, A8>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
+               get<7>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7,
+                            A8>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
+               get<6>(args), get<7>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8, typename A9>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
+      A6, A7, A8, A9>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
+               get<7>(args), get<8>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
+                            A9>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
+               get<6>(args), get<7>(args), get<8>(args));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8, typename A9,
+    typename A10>
+class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
+    A10> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
+      A6, A7, A8, A9, A10>& args) {
+           return function(get<0>(args), get<1>(args), get<2>(args),
+               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
+               get<7>(args), get<8>(args), get<9>(args));
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
+                            A9, A10>& args) {
+           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
+               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
+               get<6>(args), get<7>(args), get<8>(args), get<9>(args));
+  }
+};
+
+// An INTERNAL macro for extracting the type of a tuple field.  It's
+// subject to change without notice - DO NOT USE IN USER CODE!
+#define GMOCK_FIELD_(Tuple, N) \
+    typename ::testing::tuple_element<N, Tuple>::type
+
+// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the
+// type of an n-ary function whose i-th (1-based) argument type is the
+// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple
+// type, and whose return type is Result.  For example,
+//   SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type
+// is int(bool, long).
+//
+// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args)
+// returns the selected fields (k1, k2, ..., k_n) of args as a tuple.
+// For example,
+//   SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select(
+//       ::testing::make_tuple(true, 'a', 2.5))
+// returns tuple (2.5, true).
+//
+// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be
+// in the range [0, 10].  Duplicates are allowed and they don't have
+// to be in an ascending or descending order.
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4, int k5, int k6, int k7, int k8, int k9, int k10>
+class SelectArgs {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
+      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
+      GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9),
+      GMOCK_FIELD_(ArgumentTuple, k10));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
+        get<k8>(args), get<k9>(args), get<k10>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple>
+class SelectArgs<Result, ArgumentTuple,
+                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef Result type();
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& /* args */) {
+    return SelectedArgs();
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, -1, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, k4, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4, int k5>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, k4, k5, -1, -1, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args), get<k5>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4, int k5, int k6>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, k4, k5, k6, -1, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
+      GMOCK_FIELD_(ArgumentTuple, k6));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args), get<k5>(args), get<k6>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4, int k5, int k6, int k7>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, k4, k5, k6, k7, -1, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
+      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4, int k5, int k6, int k7, int k8>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, k4, k5, k6, k7, k8, -1, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
+      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
+      GMOCK_FIELD_(ArgumentTuple, k8));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
+        get<k8>(args));
+  }
+};
+
+template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
+    int k4, int k5, int k6, int k7, int k8, int k9>
+class SelectArgs<Result, ArgumentTuple,
+                 k1, k2, k3, k4, k5, k6, k7, k8, k9, -1> {
+ public:
+  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
+      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
+      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
+      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
+      GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9));
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
+        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
+        get<k8>(args), get<k9>(args));
+  }
+};
+
+#undef GMOCK_FIELD_
+
+// Implements the WithArgs action.
+template <typename InnerAction, int k1 = -1, int k2 = -1, int k3 = -1,
+    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
+    int k9 = -1, int k10 = -1>
+class WithArgsAction {
+ public:
+  explicit WithArgsAction(const InnerAction& action) : action_(action) {}
+
+  template <typename F>
+  operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
+
+ private:
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const InnerAction& action) : action_(action) {}
+
+    virtual Result Perform(const ArgumentTuple& args) {
+      return action_.Perform(SelectArgs<Result, ArgumentTuple, k1, k2, k3, k4,
+          k5, k6, k7, k8, k9, k10>::Select(args));
+    }
+
+   private:
+    typedef typename SelectArgs<Result, ArgumentTuple,
+        k1, k2, k3, k4, k5, k6, k7, k8, k9, k10>::type InnerFunctionType;
+
+    Action<InnerFunctionType> action_;
+  };
+
+  const InnerAction action_;
+
+  GTEST_DISALLOW_ASSIGN_(WithArgsAction);
+};
+
+// A macro from the ACTION* family (defined later in this file)
+// 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 {};
+
+// A helper class needed for implementing the ACTION* macros.
+template <typename Result, class Impl>
+class ActionHelper {
+ public:
+  static Result Perform(Impl* impl, const ::testing::tuple<>& args) {
+    return impl->template gmock_PerformImpl<>(args, ExcessiveArg(),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0>& args) {
+    return impl->template gmock_PerformImpl<A0>(args, get<0>(args),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1>& args) {
+    return impl->template gmock_PerformImpl<A0, A1>(args, get<0>(args),
+        get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2>(args, get<0>(args),
+        get<1>(args), get<2>(args), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
+      A3>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3>(args, get<0>(args),
+        get<1>(args), get<2>(args), get<3>(args), ExcessiveArg(),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3, typename A4>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3,
+      A4>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4>(args,
+        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
+        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3, typename A4,
+      typename A5>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
+      A5>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5>(args,
+        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
+        get<5>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3, typename A4,
+      typename A5, typename A6>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
+      A5, A6>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6>(args,
+        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
+        get<5>(args), get<6>(args), ExcessiveArg(), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3, typename A4,
+      typename A5, typename A6, typename A7>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
+      A5, A6, A7>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6,
+        A7>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
+        get<4>(args), get<5>(args), get<6>(args), get<7>(args), ExcessiveArg(),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3, typename A4,
+      typename A5, typename A6, typename A7, typename A8>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
+      A5, A6, A7, A8>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7,
+        A8>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
+        get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
+        ExcessiveArg());
+  }
+
+  template <typename A0, typename A1, typename A2, typename A3, typename A4,
+      typename A5, typename A6, typename A7, typename A8, typename A9>
+  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
+      A5, A6, A7, A8, A9>& args) {
+    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7, A8,
+        A9>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
+        get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
+        get<9>(args));
+  }
+};
+
+}  // namespace internal
+
+// Various overloads for Invoke().
+
+// 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.  C++ doesn't support default arguments for
+// function templates, so we have to overload it.
+template <int k1, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1>(action);
+}
+
+template <int k1, int k2, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2>(action);
+}
+
+template <int k1, int k2, int k3, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3>(action);
+}
+
+template <int k1, int k2, int k3, int k4, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>(action);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>(action);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
+    typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
+      k7>(action);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
+    typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
+      k8>(action);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
+    int k9, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
+      k9>(action);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
+    int k9, int k10, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
+    k9, k10>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
+      k9, k10>(action);
+}
+
+// Creates an action that does actions a1, a2, ..., sequentially in
+// each invocation.
+template <typename Action1, typename Action2>
+inline internal::DoBothAction<Action1, Action2>
+DoAll(Action1 a1, Action2 a2) {
+  return internal::DoBothAction<Action1, Action2>(a1, a2);
+}
+
+template <typename Action1, typename Action2, typename Action3>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    Action3> >
+DoAll(Action1 a1, Action2 a2, Action3 a3) {
+  return DoAll(a1, DoAll(a2, a3));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, Action4> > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) {
+  return DoAll(a1, DoAll(a2, a3, a4));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4, typename Action5>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
+    Action5> > > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) {
+  return DoAll(a1, DoAll(a2, a3, a4, a5));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4, typename Action5, typename Action6>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
+    internal::DoBothAction<Action5, Action6> > > > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6) {
+  return DoAll(a1, DoAll(a2, a3, a4, a5, a6));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4, typename Action5, typename Action6, typename Action7>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
+    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
+    Action7> > > > > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
+    Action7 a7) {
+  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4, typename Action5, typename Action6, typename Action7,
+    typename Action8>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
+    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
+    internal::DoBothAction<Action7, Action8> > > > > > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
+    Action7 a7, Action8 a8) {
+  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4, typename Action5, typename Action6, typename Action7,
+    typename Action8, typename Action9>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
+    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
+    internal::DoBothAction<Action7, internal::DoBothAction<Action8,
+    Action9> > > > > > > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
+    Action7 a7, Action8 a8, Action9 a9) {
+  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+template <typename Action1, typename Action2, typename Action3,
+    typename Action4, typename Action5, typename Action6, typename Action7,
+    typename Action8, typename Action9, typename Action10>
+inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
+    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
+    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
+    internal::DoBothAction<Action7, internal::DoBothAction<Action8,
+    internal::DoBothAction<Action9, Action10> > > > > > > > >
+DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
+    Action7 a7, Action8 a8, Action9 a9, Action10 a10) {
+  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10));
+}
+
+}  // namespace testing
+
+// 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.  The reason is
+// that C++ doesn't yet allow function-local types to be used to
+// instantiate templates.  The up-coming C++0x standard will fix this.
+// Once that's done, we'll consider supporting using ACTION*() inside
+// a function.
+//
+// MORE INFORMATION:
+//
+// To learn more about using these macros, please search for 'ACTION'
+// on http://code.google.com/p/googlemock/wiki/CookBook.
+
+// An internal macro needed for implementing ACTION*().
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
+    const args_type& args GTEST_ATTRIBUTE_UNUSED_, \
+    arg0_type arg0 GTEST_ATTRIBUTE_UNUSED_, \
+    arg1_type arg1 GTEST_ATTRIBUTE_UNUSED_, \
+    arg2_type arg2 GTEST_ATTRIBUTE_UNUSED_, \
+    arg3_type arg3 GTEST_ATTRIBUTE_UNUSED_, \
+    arg4_type arg4 GTEST_ATTRIBUTE_UNUSED_, \
+    arg5_type arg5 GTEST_ATTRIBUTE_UNUSED_, \
+    arg6_type arg6 GTEST_ATTRIBUTE_UNUSED_, \
+    arg7_type arg7 GTEST_ATTRIBUTE_UNUSED_, \
+    arg8_type arg8 GTEST_ATTRIBUTE_UNUSED_, \
+    arg9_type arg9 GTEST_ATTRIBUTE_UNUSED_
+
+// 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(::testing::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(gmock_p0)
+#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
+    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), p1(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(gmock_p0), p1(gmock_p1), p2(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(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(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3), p4(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(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(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+        p7(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
+        p8(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
+        p8(gmock_p8), p9(gmock_p9)
+
+// 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_INIT_##value_params {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      GMOCK_INTERNAL_DEFN_##value_params\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(\
+          new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
+    }\
+    GMOCK_INTERNAL_DEFN_##value_params\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
+  };\
+  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 F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      GMOCK_ACTION_CLASS_(name, value_params)<\
+          GMOCK_INTERNAL_LIST_##template_params\
+          GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\
+              gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION(name)\
+  class name##Action {\
+   public:\
+    name##Action() {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl() {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>());\
+    }\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##Action);\
+  };\
+  inline name##Action name() {\
+    return name##Action();\
+  }\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##Action::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P(name, p0)\
+  template <typename p0##_type>\
+  class name##ActionP {\
+   public:\
+    explicit name##ActionP(p0##_type gmock_p0) : p0(gmock_p0) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      explicit gmock_Impl(p0##_type gmock_p0) : p0(gmock_p0) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0));\
+    }\
+    p0##_type p0;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP);\
+  };\
+  template <typename p0##_type>\
+  inline name##ActionP<p0##_type> name(p0##_type p0) {\
+    return name##ActionP<p0##_type>(p0);\
+  }\
+  template <typename p0##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP<p0##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P2(name, p0, p1)\
+  template <typename p0##_type, typename p1##_type>\
+  class name##ActionP2 {\
+   public:\
+    name##ActionP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
+        p1(gmock_p1) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
+          p1(gmock_p1) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP2);\
+  };\
+  template <typename p0##_type, typename p1##_type>\
+  inline name##ActionP2<p0##_type, p1##_type> name(p0##_type p0, \
+      p1##_type p1) {\
+    return name##ActionP2<p0##_type, p1##_type>(p0, p1);\
+  }\
+  template <typename p0##_type, typename p1##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP2<p0##_type, p1##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P3(name, p0, p1, p2)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type>\
+  class name##ActionP3 {\
+   public:\
+    name##ActionP3(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, \
+          p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP3);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type>\
+  inline name##ActionP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
+      p1##_type p1, p2##_type p2) {\
+    return name##ActionP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP3<p0##_type, p1##_type, \
+          p2##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P4(name, p0, p1, p2, p3)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type>\
+  class name##ActionP4 {\
+   public:\
+    name##ActionP4(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+          p3(gmock_p3) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP4);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type>\
+  inline name##ActionP4<p0##_type, p1##_type, p2##_type, \
+      p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
+      p3##_type p3) {\
+    return name##ActionP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, p1, \
+        p2, p3);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP4<p0##_type, p1##_type, p2##_type, \
+          p3##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P5(name, p0, p1, p2, p3, p4)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type>\
+  class name##ActionP5 {\
+   public:\
+    name##ActionP5(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, \
+        p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), \
+          p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP5);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type>\
+  inline name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+      p4##_type p4) {\
+    return name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type>(p0, p1, p2, p3, p4);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
+          p4##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P6(name, p0, p1, p2, p3, p4, p5)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type>\
+  class name##ActionP6 {\
+   public:\
+    name##ActionP6(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5));\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP6);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type>\
+  inline name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
+      p3##_type p3, p4##_type p4, p5##_type p5) {\
+    return name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+          p5##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P7(name, p0, p1, p2, p3, p4, p5, p6)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type>\
+  class name##ActionP7 {\
+   public:\
+    name##ActionP7(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(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
+        p6(gmock_p6) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+      p6##_type p6;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(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;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP7);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type>\
+  inline name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
+      p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
+      p6##_type p6) {\
+    return name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+          p5##_type, p6##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P8(name, p0, p1, p2, p3, p4, p5, p6, p7)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type>\
+  class name##ActionP8 {\
+   public:\
+    name##ActionP8(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+        p7(gmock_p7) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(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(gmock_p0), \
+          p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), \
+          p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+      p6##_type p6;\
+      p7##_type p7;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(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;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP8);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type>\
+  inline name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
+      p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
+      p6##_type p6, p7##_type p7) {\
+    return name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
+        p6, p7);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+          p5##_type, p6##_type, \
+          p7##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8)\
+  template <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>\
+  class name##ActionP9 {\
+   public:\
+    name##ActionP9(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
+        p8(gmock_p8) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+          p7(gmock_p7), p8(gmock_p8) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      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;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(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;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP9);\
+  };\
+  template <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>\
+  inline name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type, \
+      p8##_type> name(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) {\
+    return name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
+        p3, p4, p5, p6, p7, p8);\
+  }\
+  template <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>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+          p5##_type, p6##_type, p7##_type, \
+          p8##_type>::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)\
+  template <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>\
+  class name##ActionP10 {\
+   public:\
+    name##ActionP10(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(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+        p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+          p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <typename arg0_type, typename arg1_type, typename arg2_type, \
+          typename arg3_type, typename arg4_type, typename arg5_type, \
+          typename arg6_type, typename arg7_type, typename arg8_type, \
+          typename arg9_type>\
+      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
+          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
+          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
+          arg9_type arg9) const;\
+      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;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>(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;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP10);\
+  };\
+  template <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>\
+  inline name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
+      p9##_type> name(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) {\
+    return name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
+        p1, p2, p3, p4, p5, p6, p7, p8, p9);\
+  }\
+  template <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>\
+  template <typename F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+          p5##_type, p6##_type, p7##_type, p8##_type, \
+          p9##_type>::gmock_Impl<F>::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
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+// Various overloads for InvokeArgument<N>().
+//
+// 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 ByRef().  For
+//   example,
+//
+//     InvokeArgument<1>(5, string("Hello"), ByRef(foo))
+//
+//   passes 5 and string("Hello") by value, and passes foo by
+//   reference.
+//
+//   2. If the callable takes an argument by reference but ByRef() 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.
+
+namespace internal {
+namespace invoke_argument {
+
+// Appears in InvokeArgumentAdl's argument list to help avoid
+// accidental calls to user functions of the same name.
+struct AdlTag {};
+
+// InvokeArgumentAdl - a helper for InvokeArgument.
+// The basic overloads are provided here for generic functors.
+// Overloads for other custom-callables are provided in the
+// internal/custom/callback-actions.h header.
+
+template <typename R, typename F>
+R InvokeArgumentAdl(AdlTag, F f) {
+  return f();
+}
+template <typename R, typename F, typename A1>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1) {
+  return f(a1);
+}
+template <typename R, typename F, typename A1, typename A2>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2) {
+  return f(a1, a2);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3) {
+  return f(a1, a2, a3);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4) {
+  return f(a1, a2, a3, a4);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4, typename A5>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
+  return f(a1, a2, a3, a4, a5);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
+  return f(a1, a2, a3, a4, a5, a6);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
+    A7 a7) {
+  return f(a1, a2, a3, a4, a5, a6, a7);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7, typename A8>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
+    A7 a7, A8 a8) {
+  return f(a1, a2, a3, a4, a5, a6, a7, a8);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7, typename A8,
+    typename A9>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
+    A7 a7, A8 a8, A9 a9) {
+  return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+}
+template <typename R, typename F, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7, typename A8,
+    typename A9, typename A10>
+R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
+    A7 a7, A8 a8, A9 a9, A10 a10) {
+  return f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+}
+}  // namespace invoke_argument
+}  // namespace internal
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_0_VALUE_PARAMS()) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args));
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(p0)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_2_VALUE_PARAMS(p0, p1)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_3_VALUE_PARAMS(p0, p1, p2)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3, p4);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
+}
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+}
+
+// Various overloads for ReturnNew<T>().
+//
+// 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.
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_0_VALUE_PARAMS()) {
+  return new T();
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_1_VALUE_PARAMS(p0)) {
+  return new T(p0);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_2_VALUE_PARAMS(p0, p1)) {
+  return new T(p0, p1);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_3_VALUE_PARAMS(p0, p1, p2)) {
+  return new T(p0, p1, p2);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
+  return new T(p0, p1, p2, p3);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
+  return new T(p0, p1, p2, p3, p4);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
+  return new T(p0, p1, p2, p3, p4, p5);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
+  return new T(p0, p1, p2, p3, p4, p5, p6);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
+  return new T(p0, p1, p2, p3, p4, p5, p6, p7);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
+  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8);
+}
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
+  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace testing
+
+// Include any custom actions 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-generated-actions.h"
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h.pump b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h.pump
new file mode 100644
index 00000000..66d9f9d5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h.pump
@@ -0,0 +1,794 @@
+$$ -*- mode: c++; -*-
+$$ This is a Pump source file.  Please use Pump to convert it to
+$$ gmock-generated-actions.h.
+$$
+$var n = 10  $$ The maximum arity we support.
+$$}} This meta comment fixes auto-indentation in editors.
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used variadic actions.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
+
+#include "gmock/gmock-actions.h"
+#include "gmock/internal/gmock-port.h"
+
+namespace testing {
+namespace internal {
+
+// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary
+// function or method with the unpacked values, where F is a function
+// type that takes N arguments.
+template <typename Result, typename ArgumentTuple>
+class InvokeHelper;
+
+
+$range i 0..n
+$for i [[
+$range j 1..i
+$var types = [[$for j [[, typename A$j]]]]
+$var as = [[$for j, [[A$j]]]]
+$var args = [[$if i==0 [[]] $else [[ args]]]]
+$var gets = [[$for j, [[get<$(j - 1)>(args)]]]]
+template <typename R$types>
+class InvokeHelper<R, ::testing::tuple<$as> > {
+ public:
+  template <typename Function>
+  static R Invoke(Function function, const ::testing::tuple<$as>&$args) {
+           return function($gets);
+  }
+
+  template <class Class, typename MethodPtr>
+  static R InvokeMethod(Class* obj_ptr,
+                        MethodPtr method_ptr,
+                        const ::testing::tuple<$as>&$args) {
+           return (obj_ptr->*method_ptr)($gets);
+  }
+};
+
+
+]]
+// An INTERNAL macro for extracting the type of a tuple field.  It's
+// subject to change without notice - DO NOT USE IN USER CODE!
+#define GMOCK_FIELD_(Tuple, N) \
+    typename ::testing::tuple_element<N, Tuple>::type
+
+$range i 1..n
+
+// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the
+// type of an n-ary function whose i-th (1-based) argument type is the
+// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple
+// type, and whose return type is Result.  For example,
+//   SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type
+// is int(bool, long).
+//
+// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args)
+// returns the selected fields (k1, k2, ..., k_n) of args as a tuple.
+// For example,
+//   SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select(
+//       ::testing::make_tuple(true, 'a', 2.5))
+// returns tuple (2.5, true).
+//
+// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be
+// in the range [0, $n].  Duplicates are allowed and they don't have
+// to be in an ascending or descending order.
+
+template <typename Result, typename ArgumentTuple, $for i, [[int k$i]]>
+class SelectArgs {
+ public:
+  typedef Result type($for i, [[GMOCK_FIELD_(ArgumentTuple, k$i)]]);
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& args) {
+    return SelectedArgs($for i, [[get<k$i>(args)]]);
+  }
+};
+
+
+$for i [[
+$range j 1..n
+$range j1 1..i-1
+template <typename Result, typename ArgumentTuple$for j1[[, int k$j1]]>
+class SelectArgs<Result, ArgumentTuple,
+                 $for j, [[$if j <= i-1 [[k$j]] $else [[-1]]]]> {
+ public:
+  typedef Result type($for j1, [[GMOCK_FIELD_(ArgumentTuple, k$j1)]]);
+  typedef typename Function<type>::ArgumentTuple SelectedArgs;
+  static SelectedArgs Select(const ArgumentTuple& [[]]
+$if i == 1 [[/* args */]] $else [[args]]) {
+    return SelectedArgs($for j1, [[get<k$j1>(args)]]);
+  }
+};
+
+
+]]
+#undef GMOCK_FIELD_
+
+$var ks = [[$for i, [[k$i]]]]
+
+// Implements the WithArgs action.
+template <typename InnerAction, $for i, [[int k$i = -1]]>
+class WithArgsAction {
+ public:
+  explicit WithArgsAction(const InnerAction& action) : action_(action) {}
+
+  template <typename F>
+  operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
+
+ private:
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const InnerAction& action) : action_(action) {}
+
+    virtual Result Perform(const ArgumentTuple& args) {
+      return action_.Perform(SelectArgs<Result, ArgumentTuple, $ks>::Select(args));
+    }
+
+   private:
+    typedef typename SelectArgs<Result, ArgumentTuple,
+        $ks>::type InnerFunctionType;
+
+    Action<InnerFunctionType> action_;
+  };
+
+  const InnerAction action_;
+
+  GTEST_DISALLOW_ASSIGN_(WithArgsAction);
+};
+
+// A macro from the ACTION* family (defined later in this file)
+// 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 {};
+
+// A helper class needed for implementing the ACTION* macros.
+template <typename Result, class Impl>
+class ActionHelper {
+ public:
+$range i 0..n
+$for i
+
+[[
+$var template = [[$if i==0 [[]] $else [[
+$range j 0..i-1
+  template <$for j, [[typename A$j]]>
+]]]]
+$range j 0..i-1
+$var As = [[$for j, [[A$j]]]]
+$var as = [[$for j, [[get<$j>(args)]]]]
+$range k 1..n-i
+$var eas = [[$for k, [[ExcessiveArg()]]]]
+$var arg_list = [[$if (i==0) | (i==n) [[$as$eas]] $else [[$as, $eas]]]]
+$template
+  static Result Perform(Impl* impl, const ::testing::tuple<$As>& args) {
+    return impl->template gmock_PerformImpl<$As>(args, $arg_list);
+  }
+
+]]
+};
+
+}  // namespace internal
+
+// Various overloads for Invoke().
+
+// 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.  C++ doesn't support default arguments for
+// function templates, so we have to overload it.
+
+$range i 1..n
+$for i [[
+$range j 1..i
+template <$for j [[int k$j, ]]typename InnerAction>
+inline internal::WithArgsAction<InnerAction$for j [[, k$j]]>
+WithArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction$for j [[, k$j]]>(action);
+}
+
+
+]]
+// Creates an action that does actions a1, a2, ..., sequentially in
+// each invocation.
+$range i 2..n
+$for i [[
+$range j 2..i
+$var types = [[$for j, [[typename Action$j]]]]
+$var Aas = [[$for j [[, Action$j a$j]]]]
+
+template <typename Action1, $types>
+$range k 1..i-1
+
+inline $for k [[internal::DoBothAction<Action$k, ]]Action$i$for k  [[>]]
+
+DoAll(Action1 a1$Aas) {
+$if i==2 [[
+
+  return internal::DoBothAction<Action1, Action2>(a1, a2);
+]] $else [[
+$range j2 2..i
+
+  return DoAll(a1, DoAll($for j2, [[a$j2]]));
+]]
+
+}
+
+]]
+
+}  // namespace testing
+
+// 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_P$n 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.  The reason is
+// that C++ doesn't yet allow function-local types to be used to
+// instantiate templates.  The up-coming C++0x standard will fix this.
+// Once that's done, we'll consider supporting using ACTION*() inside
+// a function.
+//
+// MORE INFORMATION:
+//
+// To learn more about using these macros, please search for 'ACTION'
+// on http://code.google.com/p/googlemock/wiki/CookBook.
+
+$range i 0..n
+$range k 0..n-1
+
+// An internal macro needed for implementing ACTION*().
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
+    const args_type& args GTEST_ATTRIBUTE_UNUSED_
+$for k [[, \
+    arg$k[[]]_type arg$k GTEST_ATTRIBUTE_UNUSED_]]
+
+
+// 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(::testing::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.
+
+$range j 1..n
+$for j [[
+$range m 0..j-1
+#define GMOCK_INTERNAL_DECL_HAS_$j[[]]
+_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[kind$m name$m]]
+
+
+]]
+
+// Lists the template parameters.
+
+$for j [[
+$range m 0..j-1
+#define GMOCK_INTERNAL_LIST_HAS_$j[[]]
+_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[name$m]]
+
+
+]]
+
+// Declares the types of value parameters.
+
+$for i [[
+$range j 0..i-1
+#define GMOCK_INTERNAL_DECL_TYPE_AND_$i[[]]
+_VALUE_PARAMS($for j, [[p$j]]) $for j [[, typename p$j##_type]]
+
+
+]]
+
+// Initializes the value parameters.
+
+$for i [[
+$range j 0..i-1
+#define GMOCK_INTERNAL_INIT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])\
+    ($for j, [[p$j##_type gmock_p$j]])$if i>0 [[ : ]]$for j, [[p$j(gmock_p$j)]]
+
+
+]]
+
+// Declares the fields for storing the value parameters.
+
+$for i [[
+$range j 0..i-1
+#define GMOCK_INTERNAL_DEFN_AND_$i[[]]
+_VALUE_PARAMS($for j, [[p$j]]) $for j [[p$j##_type p$j; ]]
+
+
+]]
+
+// Lists the value parameters.
+
+$for i [[
+$range j 0..i-1
+#define GMOCK_INTERNAL_LIST_AND_$i[[]]
+_VALUE_PARAMS($for j, [[p$j]]) $for j, [[p$j]]
+
+
+]]
+
+// Lists the value parameter types.
+
+$for i [[
+$range j 0..i-1
+#define GMOCK_INTERNAL_LIST_TYPE_AND_$i[[]]
+_VALUE_PARAMS($for j, [[p$j]]) $for j [[, p$j##_type]]
+
+
+]]
+
+// Declares the value parameters.
+
+$for i [[
+$range j 0..i-1
+#define GMOCK_INTERNAL_DECL_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]]
+$for j, [[p$j##_type p$j]]
+
+
+]]
+
+// The suffix of the class template implementing the action template.
+$for i [[
+
+
+$range j 0..i-1
+#define GMOCK_INTERNAL_COUNT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]]
+$if i==1 [[P]] $elif i>=2 [[P$i]]
+]]
+
+
+// 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)
+
+$range k 0..n-1
+
+#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_INIT_##value_params {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <$for k, [[typename arg$k[[]]_type]]>\
+      return_type gmock_PerformImpl(const args_type& args[[]]
+$for k [[, arg$k[[]]_type arg$k]]) const;\
+      GMOCK_INTERNAL_DEFN_##value_params\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(\
+          new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
+    }\
+    GMOCK_INTERNAL_DEFN_##value_params\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
+  };\
+  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 F>\
+  template <typename arg0_type, typename arg1_type, typename arg2_type, \
+      typename arg3_type, typename arg4_type, typename arg5_type, \
+      typename arg6_type, typename arg7_type, typename arg8_type, \
+      typename arg9_type>\
+  typename ::testing::internal::Function<F>::Result\
+      GMOCK_ACTION_CLASS_(name, value_params)<\
+          GMOCK_INTERNAL_LIST_##template_params\
+          GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\
+              gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+$for i
+
+[[
+$var template = [[$if i==0 [[]] $else [[
+$range j 0..i-1
+
+  template <$for j, [[typename p$j##_type]]>\
+]]]]
+$var class_name = [[name##Action[[$if i==0 [[]] $elif i==1 [[P]]
+                                                $else [[P$i]]]]]]
+$range j 0..i-1
+$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
+$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]]
+$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]
+$var param_field_decls = [[$for j
+[[
+
+      p$j##_type p$j;\
+]]]]
+$var param_field_decls2 = [[$for j
+[[
+
+    p$j##_type p$j;\
+]]]]
+$var params = [[$for j, [[p$j]]]]
+$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]]
+$var typename_arg_types = [[$for k, [[typename arg$k[[]]_type]]]]
+$var arg_types_and_names = [[$for k, [[arg$k[[]]_type arg$k]]]]
+$var macro_name = [[$if i==0 [[ACTION]] $elif i==1 [[ACTION_P]]
+                                        $else [[ACTION_P$i]]]]
+
+#define $macro_name(name$for j [[, p$j]])\$template
+  class $class_name {\
+   public:\
+    [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {}\
+    template <typename F>\
+    class gmock_Impl : public ::testing::ActionInterface<F> {\
+     public:\
+      typedef F function_type;\
+      typedef typename ::testing::internal::Function<F>::Result return_type;\
+      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
+          args_type;\
+      [[$if i==1 [[explicit ]]]]gmock_Impl($ctor_param_list)$inits {}\
+      virtual return_type Perform(const args_type& args) {\
+        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
+            Perform(this, args);\
+      }\
+      template <$typename_arg_types>\
+      return_type gmock_PerformImpl(const args_type& args, [[]]
+$arg_types_and_names) const;\$param_field_decls
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename F> operator ::testing::Action<F>() const {\
+      return ::testing::Action<F>(new gmock_Impl<F>($params));\
+    }\$param_field_decls2
+   private:\
+    GTEST_DISALLOW_ASSIGN_($class_name);\
+  };\$template
+  inline $class_name$param_types name($param_types_and_names) {\
+    return $class_name$param_types($params);\
+  }\$template
+  template <typename F>\
+  template <$typename_arg_types>\
+  typename ::testing::internal::Function<F>::Result\
+      $class_name$param_types::gmock_Impl<F>::gmock_PerformImpl(\
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+]]
+$$ }  // This meta comment fixes auto-indentation in Emacs.  It won't
+$$    // show up in the generated code.
+
+
+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
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+// Various overloads for InvokeArgument<N>().
+//
+// 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 ByRef().  For
+//   example,
+//
+//     InvokeArgument<1>(5, string("Hello"), ByRef(foo))
+//
+//   passes 5 and string("Hello") by value, and passes foo by
+//   reference.
+//
+//   2. If the callable takes an argument by reference but ByRef() 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.
+
+namespace internal {
+namespace invoke_argument {
+
+// Appears in InvokeArgumentAdl's argument list to help avoid
+// accidental calls to user functions of the same name.
+struct AdlTag {};
+
+// InvokeArgumentAdl - a helper for InvokeArgument.
+// The basic overloads are provided here for generic functors.
+// Overloads for other custom-callables are provided in the
+// internal/custom/callback-actions.h header.
+
+$range i 0..n
+$for i
+[[
+$range j 1..i
+
+template <typename R, typename F[[$for j [[, typename A$j]]]]>
+R InvokeArgumentAdl(AdlTag, F f[[$for j [[, A$j a$j]]]]) {
+  return f([[$for j, [[a$j]]]]);
+}
+]]
+
+}  // namespace invoke_argument
+}  // namespace internal
+
+$range i 0..n
+$for i [[
+$range j 0..i-1
+
+ACTION_TEMPLATE(InvokeArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])) {
+  using internal::invoke_argument::InvokeArgumentAdl;
+  return InvokeArgumentAdl<return_type>(
+      internal::invoke_argument::AdlTag(),
+      ::testing::get<k>(args)$for j [[, p$j]]);
+}
+
+]]
+
+// Various overloads for ReturnNew<T>().
+//
+// 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.
+$range i 0..n
+$for i [[
+$range j 0..i-1
+$var ps = [[$for j, [[p$j]]]]
+
+ACTION_TEMPLATE(ReturnNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_$i[[]]_VALUE_PARAMS($ps)) {
+  return new T($ps);
+}
+
+]]
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace testing
+
+// Include any custom callback actions 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-generated-actions.h"
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h
new file mode 100644
index 00000000..4fa5ca94
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h
@@ -0,0 +1,1095 @@
+// This file was GENERATED by command:
+//     pump.py gmock-generated-function-mockers.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements function mockers of various arities.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
+
+#include "gmock/gmock-spec-builders.h"
+#include "gmock/internal/gmock-internal-utils.h"
+
+#if GTEST_HAS_STD_FUNCTION_
+# include <functional>
+#endif
+
+namespace testing {
+namespace internal {
+
+template <typename F>
+class FunctionMockerBase;
+
+// Note: class FunctionMocker really belongs to the ::testing
+// namespace.  However if we define it in ::testing, MSVC will
+// complain when classes in ::testing::internal declare it as a
+// friend class template.  To workaround this compiler bug, we define
+// FunctionMocker in ::testing::internal and import it into ::testing.
+template <typename F>
+class FunctionMocker;
+
+template <typename R>
+class FunctionMocker<R()> : public
+    internal::FunctionMockerBase<R()> {
+ public:
+  typedef R F();
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With() {
+    return this->current_spec();
+  }
+
+  R Invoke() {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple());
+  }
+};
+
+template <typename R, typename A1>
+class FunctionMocker<R(A1)> : public
+    internal::FunctionMockerBase<R(A1)> {
+ public:
+  typedef R F(A1);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1));
+  }
+};
+
+template <typename R, typename A1, typename A2>
+class FunctionMocker<R(A1, A2)> : public
+    internal::FunctionMockerBase<R(A1, A2)> {
+ public:
+  typedef R F(A1, A2);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3>
+class FunctionMocker<R(A1, A2, A3)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3)> {
+ public:
+  typedef R F(A1, A2, A3);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+class FunctionMocker<R(A1, A2, A3, A4)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4)> {
+ public:
+  typedef R F(A1, A2, A3, A4);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+class FunctionMocker<R(A1, A2, A3, A4, A5)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5)> {
+ public:
+  typedef R F(A1, A2, A3, A4, A5);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6)> {
+ public:
+  typedef R F(A1, A2, A3, A4, A5, A6);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
+      const Matcher<A6>& m6) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
+        m6));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7)> {
+ public:
+  typedef R F(A1, A2, A3, A4, A5, A6, A7);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
+      const Matcher<A6>& m6, const Matcher<A7>& m7) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
+        m6, m7));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8>
+class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
+ public:
+  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
+      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
+        m6, m7, m8));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8, typename A9>
+class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
+ public:
+  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
+      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
+      const Matcher<A9>& m9) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
+        m6, m7, m8, m9));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+  }
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8, typename A9,
+    typename A10>
+class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public
+    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> {
+ public:
+  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
+      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
+      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
+      const Matcher<A9>& m9, const Matcher<A10>& m10) {
+    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
+        m6, m7, m8, m9, m10));
+    return this->current_spec();
+  }
+
+  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
+      A10 a10) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9,
+        a10));
+  }
+};
+
+}  // 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;
+
+// GMOCK_RESULT_(tn, F) expands to the result type of function type F.
+// We define this as a variadic macro in case F contains unprotected
+// commas (the same reason that we use variadic macros in other places
+// in this file).
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_RESULT_(tn, ...) \
+    tn ::testing::internal::Function<__VA_ARGS__>::Result
+
+// The type of argument N of the given function type.
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_ARG_(tn, N, ...) \
+    tn ::testing::internal::Function<__VA_ARGS__>::Argument##N
+
+// The matcher type for argument N of the given function type.
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_MATCHER_(tn, N, ...) \
+    const ::testing::Matcher<GMOCK_ARG_(tn, N, __VA_ARGS__)>&
+
+// The variable for mocking the given method.
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_MOCKER_(arity, constness, Method) \
+    GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD0_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      ) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 0), \
+        this_method_does_not_take_0_arguments); \
+    GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(0, constness, Method).Invoke(); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method() constness { \
+    GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(0, constness, Method).With(); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(0, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD1_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 1), \
+        this_method_does_not_take_1_argument); \
+    GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(1, constness, Method).Invoke(gmock_a1); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1) constness { \
+    GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(1, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD2_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 2), \
+        this_method_does_not_take_2_arguments); \
+    GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(2, constness, Method).Invoke(gmock_a1, gmock_a2); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2) constness { \
+    GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(2, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD3_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 3), \
+        this_method_does_not_take_3_arguments); \
+    GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(3, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3) constness { \
+    GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(3, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(3, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD4_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 4), \
+        this_method_does_not_take_4_arguments); \
+    GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(4, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4) constness { \
+    GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(4, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(4, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD5_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
+      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 5), \
+        this_method_does_not_take_5_arguments); \
+    GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(5, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
+                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5) constness { \
+    GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(5, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(5, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD6_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
+      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
+      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 6), \
+        this_method_does_not_take_6_arguments); \
+    GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(6, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
+                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
+                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6) constness { \
+    GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(6, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(6, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD7_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
+      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
+      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
+      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 7), \
+        this_method_does_not_take_7_arguments); \
+    GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(7, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
+                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
+                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
+                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7) constness { \
+    GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(7, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(7, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD8_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
+      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
+      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
+      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
+      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 8), \
+        this_method_does_not_take_8_arguments); \
+    GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(8, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
+                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
+                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
+                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
+                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8) constness { \
+    GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(8, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(8, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD9_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
+      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
+      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
+      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
+      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \
+      GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 9), \
+        this_method_does_not_take_9_arguments); \
+    GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(9, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
+        gmock_a9); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
+                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
+                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
+                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
+                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \
+                     GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9) constness { \
+    GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(9, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
+        gmock_a9); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(9, constness, \
+      Method)
+
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD10_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
+      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
+      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
+      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
+      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
+      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
+      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
+      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \
+      GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9, \
+      GMOCK_ARG_(tn, 10, __VA_ARGS__) gmock_a10) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
+            == 10), \
+        this_method_does_not_take_10_arguments); \
+    GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_(10, constness, Method).Invoke(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
+        gmock_a10); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
+                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
+                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
+                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
+                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
+                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
+                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
+                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \
+                     GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9, \
+                     GMOCK_MATCHER_(tn, 10, \
+                         __VA_ARGS__) gmock_a10) constness { \
+    GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_(10, constness, Method).With(gmock_a1, gmock_a2, \
+        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
+        gmock_a10); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(10, constness, \
+      Method)
+
+#define MOCK_METHOD0(m, ...) GMOCK_METHOD0_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD1(m, ...) GMOCK_METHOD1_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD2(m, ...) GMOCK_METHOD2_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD3(m, ...) GMOCK_METHOD3_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD4(m, ...) GMOCK_METHOD4_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD5(m, ...) GMOCK_METHOD5_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD6(m, ...) GMOCK_METHOD6_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD7(m, ...) GMOCK_METHOD7_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD8(m, ...) GMOCK_METHOD8_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD9(m, ...) GMOCK_METHOD9_(, , , m, __VA_ARGS__)
+#define MOCK_METHOD10(m, ...) GMOCK_METHOD10_(, , , m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0(m, ...) GMOCK_METHOD0_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1(m, ...) GMOCK_METHOD1_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2(m, ...) GMOCK_METHOD2_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3(m, ...) GMOCK_METHOD3_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4(m, ...) GMOCK_METHOD4_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5(m, ...) GMOCK_METHOD5_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6(m, ...) GMOCK_METHOD6_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7(m, ...) GMOCK_METHOD7_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8(m, ...) GMOCK_METHOD8_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9(m, ...) GMOCK_METHOD9_(, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10(m, ...) GMOCK_METHOD10_(, const, , m, __VA_ARGS__)
+
+#define MOCK_METHOD0_T(m, ...) GMOCK_METHOD0_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD1_T(m, ...) GMOCK_METHOD1_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD2_T(m, ...) GMOCK_METHOD2_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD3_T(m, ...) GMOCK_METHOD3_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD4_T(m, ...) GMOCK_METHOD4_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD5_T(m, ...) GMOCK_METHOD5_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD6_T(m, ...) GMOCK_METHOD6_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD7_T(m, ...) GMOCK_METHOD7_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD8_T(m, ...) GMOCK_METHOD8_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD9_T(m, ...) GMOCK_METHOD9_(typename, , , m, __VA_ARGS__)
+#define MOCK_METHOD10_T(m, ...) GMOCK_METHOD10_(typename, , , m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_T(m, ...) \
+    GMOCK_METHOD0_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_T(m, ...) \
+    GMOCK_METHOD1_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_T(m, ...) \
+    GMOCK_METHOD2_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_T(m, ...) \
+    GMOCK_METHOD3_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_T(m, ...) \
+    GMOCK_METHOD4_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_T(m, ...) \
+    GMOCK_METHOD5_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_T(m, ...) \
+    GMOCK_METHOD6_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_T(m, ...) \
+    GMOCK_METHOD7_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_T(m, ...) \
+    GMOCK_METHOD8_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_T(m, ...) \
+    GMOCK_METHOD9_(typename, const, , m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_T(m, ...) \
+    GMOCK_METHOD10_(typename, const, , m, __VA_ARGS__)
+
+#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD0_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD1_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD2_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD3_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD4_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD5_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD6_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD7_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD8_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD9_(, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD10_(, , ct, m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD0_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD1_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD2_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD3_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD4_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD5_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD6_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD7_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD8_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD9_(, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD10_(, const, ct, m, __VA_ARGS__)
+
+#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD0_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD1_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD2_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD3_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD4_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD5_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD6_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD7_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD8_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD9_(typename, , ct, m, __VA_ARGS__)
+#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD10_(typename, , ct, m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD0_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD1_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD2_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD3_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD4_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD5_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD6_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD7_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD8_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD9_(typename, const, ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD10_(typename, const, ct, m, __VA_ARGS__)
+
+// A MockFunction<F> class has one mock method whose type is 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<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());
+// }
+template <typename F>
+class MockFunction;
+
+template <typename R>
+class MockFunction<R()> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD0_T(Call, R());
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R()> AsStdFunction() {
+    return [this]() -> R {
+      return this->Call();
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0>
+class MockFunction<R(A0)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD1_T(Call, R(A0));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0)> AsStdFunction() {
+    return [this](A0 a0) -> R {
+      return this->Call(a0);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1>
+class MockFunction<R(A0, A1)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD2_T(Call, R(A0, A1));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1)> AsStdFunction() {
+    return [this](A0 a0, A1 a1) -> R {
+      return this->Call(a0, a1);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2>
+class MockFunction<R(A0, A1, A2)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD3_T(Call, R(A0, A1, A2));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2) -> R {
+      return this->Call(a0, a1, a2);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3>
+class MockFunction<R(A0, A1, A2, A3)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD4_T(Call, R(A0, A1, A2, A3));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3) -> R {
+      return this->Call(a0, a1, a2, a3);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3,
+    typename A4>
+class MockFunction<R(A0, A1, A2, A3, A4)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3, A4)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) -> R {
+      return this->Call(a0, a1, a2, a3, a4);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3,
+    typename A4, typename A5>
+class MockFunction<R(A0, A1, A2, A3, A4, A5)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3, A4, A5)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) -> R {
+      return this->Call(a0, a1, a2, a3, a4, a5);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6>
+class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3, A4, A5, A6)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) -> R {
+      return this->Call(a0, a1, a2, a3, a4, a5, a6);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7>
+class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3, A4, A5, A6, A7)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) -> R {
+      return this->Call(a0, a1, a2, a3, a4, a5, a6, a7);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7, typename A8>
+class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
+        A8 a8) -> R {
+      return this->Call(a0, a1, a2, a3, a4, a5, a6, a7, a8);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+template <typename R, typename A0, typename A1, typename A2, typename A3,
+    typename A4, typename A5, typename A6, typename A7, typename A8,
+    typename A9>
+class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> AsStdFunction() {
+    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
+        A8 a8, A9 a9) -> R {
+      return this->Call(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.pump b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.pump
new file mode 100644
index 00000000..811502d0
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.pump
@@ -0,0 +1,291 @@
+$$ -*- mode: c++; -*-
+$$ This is a Pump source file.  Please use Pump to convert it to
+$$ gmock-generated-function-mockers.h.
+$$
+$var n = 10  $$ The maximum arity we support.
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements function mockers of various arities.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
+
+#include "gmock/gmock-spec-builders.h"
+#include "gmock/internal/gmock-internal-utils.h"
+
+#if GTEST_HAS_STD_FUNCTION_
+# include <functional>
+#endif
+
+namespace testing {
+namespace internal {
+
+template <typename F>
+class FunctionMockerBase;
+
+// Note: class FunctionMocker really belongs to the ::testing
+// namespace.  However if we define it in ::testing, MSVC will
+// complain when classes in ::testing::internal declare it as a
+// friend class template.  To workaround this compiler bug, we define
+// FunctionMocker in ::testing::internal and import it into ::testing.
+template <typename F>
+class FunctionMocker;
+
+
+$range i 0..n
+$for i [[
+$range j 1..i
+$var typename_As = [[$for j [[, typename A$j]]]]
+$var As = [[$for j, [[A$j]]]]
+$var as = [[$for j, [[a$j]]]]
+$var Aas = [[$for j, [[A$j a$j]]]]
+$var ms = [[$for j, [[m$j]]]]
+$var matchers = [[$for j, [[const Matcher<A$j>& m$j]]]]
+template <typename R$typename_As>
+class FunctionMocker<R($As)> : public
+    internal::FunctionMockerBase<R($As)> {
+ public:
+  typedef R F($As);
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  MockSpec<F>& With($matchers) {
+
+$if i >= 1 [[
+    this->current_spec().SetMatchers(::testing::make_tuple($ms));
+
+]]
+    return this->current_spec();
+  }
+
+  R Invoke($Aas) {
+    // Even though gcc and MSVC don't enforce it, 'this->' is required
+    // by the C++ standard [14.6.4] here, as the base class type is
+    // dependent on the template argument (and thus shouldn't be
+    // looked into when resolving InvokeWith).
+    return this->InvokeWith(ArgumentTuple($as));
+  }
+};
+
+
+]]
+}  // 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;
+
+// GMOCK_RESULT_(tn, F) expands to the result type of function type F.
+// We define this as a variadic macro in case F contains unprotected
+// commas (the same reason that we use variadic macros in other places
+// in this file).
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_RESULT_(tn, ...) \
+    tn ::testing::internal::Function<__VA_ARGS__>::Result
+
+// The type of argument N of the given function type.
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_ARG_(tn, N, ...) \
+    tn ::testing::internal::Function<__VA_ARGS__>::Argument##N
+
+// The matcher type for argument N of the given function type.
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_MATCHER_(tn, N, ...) \
+    const ::testing::Matcher<GMOCK_ARG_(tn, N, __VA_ARGS__)>&
+
+// The variable for mocking the given method.
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_MOCKER_(arity, constness, Method) \
+    GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
+
+
+$for i [[
+$range j 1..i
+$var arg_as = [[$for j, \
+      [[GMOCK_ARG_(tn, $j, __VA_ARGS__) gmock_a$j]]]]
+$var as = [[$for j, [[gmock_a$j]]]]
+$var matcher_as = [[$for j, \
+                     [[GMOCK_MATCHER_(tn, $j, __VA_ARGS__) gmock_a$j]]]]
+// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
+#define GMOCK_METHOD$i[[]]_(tn, constness, ct, Method, ...) \
+  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
+      $arg_as) constness { \
+    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
+        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value == $i), \
+        this_method_does_not_take_$i[[]]_argument[[$if i != 1 [[s]]]]); \
+    GMOCK_MOCKER_($i, constness, Method).SetOwnerAndName(this, #Method); \
+    return GMOCK_MOCKER_($i, constness, Method).Invoke($as); \
+  } \
+  ::testing::MockSpec<__VA_ARGS__>& \
+      gmock_##Method($matcher_as) constness { \
+    GMOCK_MOCKER_($i, constness, Method).RegisterOwner(this); \
+    return GMOCK_MOCKER_($i, constness, Method).With($as); \
+  } \
+  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_($i, constness, Method)
+
+
+]]
+$for i [[
+#define MOCK_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, , , m, __VA_ARGS__)
+
+]]
+
+
+$for i [[
+#define MOCK_CONST_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, const, , m, __VA_ARGS__)
+
+]]
+
+
+$for i [[
+#define MOCK_METHOD$i[[]]_T(m, ...) GMOCK_METHOD$i[[]]_(typename, , , m, __VA_ARGS__)
+
+]]
+
+
+$for i [[
+#define MOCK_CONST_METHOD$i[[]]_T(m, ...) \
+    GMOCK_METHOD$i[[]]_(typename, const, , m, __VA_ARGS__)
+
+]]
+
+
+$for i [[
+#define MOCK_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD$i[[]]_(, , ct, m, __VA_ARGS__)
+
+]]
+
+
+$for i [[
+#define MOCK_CONST_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD$i[[]]_(, const, ct, m, __VA_ARGS__)
+
+]]
+
+
+$for i [[
+#define MOCK_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD$i[[]]_(typename, , ct, m, __VA_ARGS__)
+
+]]
+
+
+$for i [[
+#define MOCK_CONST_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \
+    GMOCK_METHOD$i[[]]_(typename, const, ct, m, __VA_ARGS__)
+
+]]
+
+// A MockFunction<F> class has one mock method whose type is 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<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());
+// }
+template <typename F>
+class MockFunction;
+
+
+$for i [[
+$range j 0..i-1
+$var ArgTypes = [[$for j, [[A$j]]]]
+$var ArgNames = [[$for j, [[a$j]]]]
+$var ArgDecls = [[$for j, [[A$j a$j]]]]
+template <typename R$for j [[, typename A$j]]>
+class MockFunction<R($ArgTypes)> {
+ public:
+  MockFunction() {}
+
+  MOCK_METHOD$i[[]]_T(Call, R($ArgTypes));
+
+#if GTEST_HAS_STD_FUNCTION_
+  std::function<R($ArgTypes)> AsStdFunction() {
+    return [this]($ArgDecls) -> R {
+      return this->Call($ArgNames);
+    };
+  }
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
+};
+
+
+]]
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h
new file mode 100644
index 00000000..57056fd9
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h
@@ -0,0 +1,2179 @@
+// This file was GENERATED by command:
+//     pump.py gmock-generated-matchers.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// 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.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used variadic matchers.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
+
+#include <iterator>
+#include <sstream>
+#include <string>
+#include <vector>
+#include "gmock/gmock-matchers.h"
+
+namespace testing {
+namespace internal {
+
+// The type of the i-th (0-based) field of Tuple.
+#define GMOCK_FIELD_TYPE_(Tuple, i) \
+    typename ::testing::tuple_element<i, Tuple>::type
+
+// TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
+// tuple of type Tuple.  It has two members:
+//
+//   type: a tuple type whose i-th field is the ki-th field of Tuple.
+//   GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
+//
+// For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
+//
+//   type is tuple<int, bool>, and
+//   GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
+
+template <class Tuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
+    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
+    int k9 = -1>
+class TupleFields;
+
+// This generic version is used when there are 10 selectors.
+template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
+    int k7, int k8, int k9>
+class TupleFields {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
+      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
+      GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8),
+      GMOCK_FIELD_TYPE_(Tuple, k9)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
+        get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t), get<k9>(t));
+  }
+};
+
+// The following specialization is used for 0 ~ 9 selectors.
+
+template <class Tuple>
+class TupleFields<Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<> type;
+  static type GetSelectedFields(const Tuple& /* t */) {
+    return type();
+  }
+};
+
+template <class Tuple, int k0>
+class TupleFields<Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1>
+class TupleFields<Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2>
+class TupleFields<Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2, int k3>
+class TupleFields<Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2, int k3, int k4>
+class TupleFields<Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5>
+class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
+      GMOCK_FIELD_TYPE_(Tuple, k5)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
+        get<k5>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6>
+class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
+      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
+        get<k5>(t), get<k6>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
+    int k7>
+class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
+      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
+      GMOCK_FIELD_TYPE_(Tuple, k7)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
+        get<k5>(t), get<k6>(t), get<k7>(t));
+  }
+};
+
+template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
+    int k7, int k8>
+class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1> {
+ public:
+  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
+      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
+      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
+      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
+      GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
+        get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t));
+  }
+};
+
+#undef GMOCK_FIELD_TYPE_
+
+// Implements the Args() matcher.
+template <class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
+    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
+    int k9 = -1>
+class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
+ public:
+  // ArgsTuple may have top-level const or reference modifiers.
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
+  typedef typename internal::TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5,
+      k6, k7, k8, k9>::type SelectedArgs;
+  typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
+
+  template <typename InnerMatcher>
+  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
+      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
+
+  virtual bool MatchAndExplain(ArgsTuple args,
+                               MatchResultListener* listener) const {
+    const SelectedArgs& selected_args = GetSelectedArgs(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;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "are a tuple ";
+    PrintIndices(os);
+    inner_matcher_.DescribeTo(os);
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "are a tuple ";
+    PrintIndices(os);
+    inner_matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  static SelectedArgs GetSelectedArgs(ArgsTuple args) {
+    return TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,
+        k9>::GetSelectedFields(args);
+  }
+
+  // Prints the indices of the selected fields.
+  static void PrintIndices(::std::ostream* os) {
+    *os << "whose fields (";
+    const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 };
+    for (int i = 0; i < 10; i++) {
+      if (indices[i] < 0)
+        break;
+
+      if (i >= 1)
+        *os << ", ";
+
+      *os << "#" << indices[i];
+    }
+    *os << ") ";
+  }
+
+  const MonomorphicInnerMatcher inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
+};
+
+template <class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1,
+    int k3 = -1, int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1,
+    int k8 = -1, int k9 = -1>
+class ArgsMatcher {
+ public:
+  explicit ArgsMatcher(const InnerMatcher& inner_matcher)
+      : inner_matcher_(inner_matcher) {}
+
+  template <typename ArgsTuple>
+  operator Matcher<ArgsTuple>() const {
+    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k0, k1, k2, k3, k4, k5,
+        k6, k7, k8, k9>(inner_matcher_));
+  }
+
+ private:
+  const InnerMatcher inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
+};
+
+// A set of metafunctions for computing the result type of AllOf.
+// AllOf(m1, ..., mN) returns
+// AllOfResultN<decltype(m1), ..., decltype(mN)>::type.
+
+// Although AllOf isn't defined for one argument, AllOfResult1 is defined
+// to simplify the implementation.
+template <typename M1>
+struct AllOfResult1 {
+  typedef M1 type;
+};
+
+template <typename M1, typename M2>
+struct AllOfResult2 {
+  typedef BothOfMatcher<
+      typename AllOfResult1<M1>::type,
+      typename AllOfResult1<M2>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3>
+struct AllOfResult3 {
+  typedef BothOfMatcher<
+      typename AllOfResult1<M1>::type,
+      typename AllOfResult2<M2, M3>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4>
+struct AllOfResult4 {
+  typedef BothOfMatcher<
+      typename AllOfResult2<M1, M2>::type,
+      typename AllOfResult2<M3, M4>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5>
+struct AllOfResult5 {
+  typedef BothOfMatcher<
+      typename AllOfResult2<M1, M2>::type,
+      typename AllOfResult3<M3, M4, M5>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6>
+struct AllOfResult6 {
+  typedef BothOfMatcher<
+      typename AllOfResult3<M1, M2, M3>::type,
+      typename AllOfResult3<M4, M5, M6>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7>
+struct AllOfResult7 {
+  typedef BothOfMatcher<
+      typename AllOfResult3<M1, M2, M3>::type,
+      typename AllOfResult4<M4, M5, M6, M7>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8>
+struct AllOfResult8 {
+  typedef BothOfMatcher<
+      typename AllOfResult4<M1, M2, M3, M4>::type,
+      typename AllOfResult4<M5, M6, M7, M8>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9>
+struct AllOfResult9 {
+  typedef BothOfMatcher<
+      typename AllOfResult4<M1, M2, M3, M4>::type,
+      typename AllOfResult5<M5, M6, M7, M8, M9>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9, typename M10>
+struct AllOfResult10 {
+  typedef BothOfMatcher<
+      typename AllOfResult5<M1, M2, M3, M4, M5>::type,
+      typename AllOfResult5<M6, M7, M8, M9, M10>::type
+  > type;
+};
+
+// A set of metafunctions for computing the result type of AnyOf.
+// AnyOf(m1, ..., mN) returns
+// AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.
+
+// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
+// to simplify the implementation.
+template <typename M1>
+struct AnyOfResult1 {
+  typedef M1 type;
+};
+
+template <typename M1, typename M2>
+struct AnyOfResult2 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult1<M1>::type,
+      typename AnyOfResult1<M2>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3>
+struct AnyOfResult3 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult1<M1>::type,
+      typename AnyOfResult2<M2, M3>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4>
+struct AnyOfResult4 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult2<M1, M2>::type,
+      typename AnyOfResult2<M3, M4>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5>
+struct AnyOfResult5 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult2<M1, M2>::type,
+      typename AnyOfResult3<M3, M4, M5>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6>
+struct AnyOfResult6 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult3<M1, M2, M3>::type,
+      typename AnyOfResult3<M4, M5, M6>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7>
+struct AnyOfResult7 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult3<M1, M2, M3>::type,
+      typename AnyOfResult4<M4, M5, M6, M7>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8>
+struct AnyOfResult8 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult4<M1, M2, M3, M4>::type,
+      typename AnyOfResult4<M5, M6, M7, M8>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9>
+struct AnyOfResult9 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult4<M1, M2, M3, M4>::type,
+      typename AnyOfResult5<M5, M6, M7, M8, M9>::type
+  > type;
+};
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9, typename M10>
+struct AnyOfResult10 {
+  typedef EitherOfMatcher<
+      typename AnyOfResult5<M1, M2, M3, M4, M5>::type,
+      typename AnyOfResult5<M6, M7, M8, M9, M10>::type
+  > type;
+};
+
+}  // namespace internal
+
+// 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 <typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher>(matcher);
+}
+
+template <int k1, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1>(matcher);
+}
+
+template <int k1, int k2, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher);
+}
+
+template <int k1, int k2, int k3, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
+    typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6,
+      k7>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
+    typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
+      k8>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
+    int k9, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
+      k9>(matcher);
+}
+
+template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
+    int k9, int k10, typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9,
+    k10>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
+      k9, k10>(matcher);
+}
+
+// ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
+// n elements, where the i-th element in the container must
+// match the i-th argument in the list.  Each argument of
+// ElementsAre() can be either a value or a matcher.  We support up to
+// 10 arguments.
+//
+// The use of DecayArray in the implementation allows ElementsAre()
+// to accept string literals, whose type is const char[N], but we
+// want to treat them as const char*.
+//
+// NOTE: Since ElementsAre() cares about the order of the elements, it
+// must not be used with containers whose elements's order is
+// undefined (e.g. hash_map).
+
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<> >
+ElementsAre() {
+  typedef ::testing::tuple<> Args;
+  return internal::ElementsAreMatcher<Args>(Args());
+}
+
+template <typename T1>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type> >
+ElementsAre(const T1& e1) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1));
+}
+
+template <typename T1, typename T2>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type> >
+ElementsAre(const T1& e1, const T2& e2) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2));
+}
+
+template <typename T1, typename T2, typename T3>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3));
+}
+
+template <typename T1, typename T2, typename T3, typename T4>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type,
+        typename internal::DecayArray<T8>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type,
+      typename internal::DecayArray<T8>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
+      e8));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type,
+        typename internal::DecayArray<T8>::type,
+        typename internal::DecayArray<T9>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type,
+      typename internal::DecayArray<T8>::type,
+      typename internal::DecayArray<T9>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
+      e8, e9));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type,
+        typename internal::DecayArray<T8>::type,
+        typename internal::DecayArray<T9>::type,
+        typename internal::DecayArray<T10>::type> >
+ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
+    const T10& e10) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type,
+      typename internal::DecayArray<T8>::type,
+      typename internal::DecayArray<T9>::type,
+      typename internal::DecayArray<T10>::type> Args;
+  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
+      e8, e9, e10));
+}
+
+// UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
+// that matches n elements in any order.  We support up to n=10 arguments.
+
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<> >
+UnorderedElementsAre() {
+  typedef ::testing::tuple<> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args());
+}
+
+template <typename T1>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type> >
+UnorderedElementsAre(const T1& e1) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1));
+}
+
+template <typename T1, typename T2>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2));
+}
+
+template <typename T1, typename T2, typename T3>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3));
+}
+
+template <typename T1, typename T2, typename T3, typename T4>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
+      e6));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
+      e6, e7));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type,
+        typename internal::DecayArray<T8>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type,
+      typename internal::DecayArray<T8>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
+      e6, e7, e8));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type,
+        typename internal::DecayArray<T8>::type,
+        typename internal::DecayArray<T9>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type,
+      typename internal::DecayArray<T8>::type,
+      typename internal::DecayArray<T9>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
+      e6, e7, e8, e9));
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+        typename internal::DecayArray<T1>::type,
+        typename internal::DecayArray<T2>::type,
+        typename internal::DecayArray<T3>::type,
+        typename internal::DecayArray<T4>::type,
+        typename internal::DecayArray<T5>::type,
+        typename internal::DecayArray<T6>::type,
+        typename internal::DecayArray<T7>::type,
+        typename internal::DecayArray<T8>::type,
+        typename internal::DecayArray<T9>::type,
+        typename internal::DecayArray<T10>::type> >
+UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
+    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
+    const T10& e10) {
+  typedef ::testing::tuple<
+      typename internal::DecayArray<T1>::type,
+      typename internal::DecayArray<T2>::type,
+      typename internal::DecayArray<T3>::type,
+      typename internal::DecayArray<T4>::type,
+      typename internal::DecayArray<T5>::type,
+      typename internal::DecayArray<T6>::type,
+      typename internal::DecayArray<T7>::type,
+      typename internal::DecayArray<T8>::type,
+      typename internal::DecayArray<T9>::type,
+      typename internal::DecayArray<T10>::type> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
+      e6, e7, e8, e9, e10));
+}
+
+// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
+// sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.
+
+template <typename M1, typename M2>
+inline typename internal::AllOfResult2<M1, M2>::type
+AllOf(M1 m1, M2 m2) {
+  return typename internal::AllOfResult2<M1, M2>::type(
+      m1,
+      m2);
+}
+
+template <typename M1, typename M2, typename M3>
+inline typename internal::AllOfResult3<M1, M2, M3>::type
+AllOf(M1 m1, M2 m2, M3 m3) {
+  return typename internal::AllOfResult3<M1, M2, M3>::type(
+      m1,
+      ::testing::AllOf(m2, m3));
+}
+
+template <typename M1, typename M2, typename M3, typename M4>
+inline typename internal::AllOfResult4<M1, M2, M3, M4>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4) {
+  return typename internal::AllOfResult4<M1, M2, M3, M4>::type(
+      ::testing::AllOf(m1, m2),
+      ::testing::AllOf(m3, m4));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5>
+inline typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
+  return typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type(
+      ::testing::AllOf(m1, m2),
+      ::testing::AllOf(m3, m4, m5));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6>
+inline typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
+  return typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type(
+      ::testing::AllOf(m1, m2, m3),
+      ::testing::AllOf(m4, m5, m6));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7>
+inline typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
+  return typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
+      ::testing::AllOf(m1, m2, m3),
+      ::testing::AllOf(m4, m5, m6, m7));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8>
+inline typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
+  return typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
+      ::testing::AllOf(m1, m2, m3, m4),
+      ::testing::AllOf(m5, m6, m7, m8));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9>
+inline typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
+  return typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
+      M9>::type(
+      ::testing::AllOf(m1, m2, m3, m4),
+      ::testing::AllOf(m5, m6, m7, m8, m9));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9, typename M10>
+inline typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
+    M10>::type
+AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
+  return typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
+      M10>::type(
+      ::testing::AllOf(m1, m2, m3, m4, m5),
+      ::testing::AllOf(m6, m7, m8, m9, m10));
+}
+
+// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
+// sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
+
+template <typename M1, typename M2>
+inline typename internal::AnyOfResult2<M1, M2>::type
+AnyOf(M1 m1, M2 m2) {
+  return typename internal::AnyOfResult2<M1, M2>::type(
+      m1,
+      m2);
+}
+
+template <typename M1, typename M2, typename M3>
+inline typename internal::AnyOfResult3<M1, M2, M3>::type
+AnyOf(M1 m1, M2 m2, M3 m3) {
+  return typename internal::AnyOfResult3<M1, M2, M3>::type(
+      m1,
+      ::testing::AnyOf(m2, m3));
+}
+
+template <typename M1, typename M2, typename M3, typename M4>
+inline typename internal::AnyOfResult4<M1, M2, M3, M4>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4) {
+  return typename internal::AnyOfResult4<M1, M2, M3, M4>::type(
+      ::testing::AnyOf(m1, m2),
+      ::testing::AnyOf(m3, m4));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5>
+inline typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
+  return typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type(
+      ::testing::AnyOf(m1, m2),
+      ::testing::AnyOf(m3, m4, m5));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6>
+inline typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
+  return typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type(
+      ::testing::AnyOf(m1, m2, m3),
+      ::testing::AnyOf(m4, m5, m6));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7>
+inline typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
+  return typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
+      ::testing::AnyOf(m1, m2, m3),
+      ::testing::AnyOf(m4, m5, m6, m7));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8>
+inline typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
+  return typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
+      ::testing::AnyOf(m1, m2, m3, m4),
+      ::testing::AnyOf(m5, m6, m7, m8));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9>
+inline typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
+  return typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
+      M9>::type(
+      ::testing::AnyOf(m1, m2, m3, m4),
+      ::testing::AnyOf(m5, m6, m7, m8, m9));
+}
+
+template <typename M1, typename M2, typename M3, typename M4, typename M5,
+    typename M6, typename M7, typename M8, typename M9, typename M10>
+inline typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
+    M10>::type
+AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
+  return typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
+      M10>::type(
+      ::testing::AnyOf(m1, m2, m3, m4, m5),
+      ::testing::AnyOf(m6, m7, m8, m9, m10));
+}
+
+}  // namespace testing
+
+
+// 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_P10 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,
+//       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.  The reason is
+// that C++ doesn't yet allow function-local types to be used to
+// instantiate templates.  The up-coming C++0x standard will fix this.
+// Once that's done, we'll consider supporting using MATCHER*() inside
+// a function.
+//
+// More Information
+// ================
+//
+// To learn more about using these macros, please search for 'MATCHER'
+// on http://code.google.com/p/googlemock/wiki/CookBook.
+
+#define MATCHER(name, description)\
+  class name##Matcher {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl()\
+           {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<>()));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>());\
+    }\
+    name##Matcher() {\
+    }\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##Matcher);\
+  };\
+  inline name##Matcher name() {\
+    return name##Matcher();\
+  }\
+  template <typename arg_type>\
+  bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P(name, p0, description)\
+  template <typename p0##_type>\
+  class name##MatcherP {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      explicit gmock_Impl(p0##_type gmock_p0)\
+           : p0(gmock_p0) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type>(p0)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0));\
+    }\
+    explicit name##MatcherP(p0##_type gmock_p0) : p0(gmock_p0) {\
+    }\
+    p0##_type p0;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP);\
+  };\
+  template <typename p0##_type>\
+  inline name##MatcherP<p0##_type> name(p0##_type p0) {\
+    return name##MatcherP<p0##_type>(p0);\
+  }\
+  template <typename p0##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P2(name, p0, p1, description)\
+  template <typename p0##_type, typename p1##_type>\
+  class name##MatcherP2 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
+           : p0(gmock_p0), p1(gmock_p1) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type>(p0, p1)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1));\
+    }\
+    name##MatcherP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
+        p1(gmock_p1) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP2);\
+  };\
+  template <typename p0##_type, typename p1##_type>\
+  inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \
+      p1##_type p1) {\
+    return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\
+  }\
+  template <typename p0##_type, typename p1##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP2<p0##_type, \
+      p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P3(name, p0, p1, p2, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type>\
+  class name##MatcherP3 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\
+           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, \
+                    p2)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2));\
+    }\
+    name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP3);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type>\
+  inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
+      p1##_type p1, p2##_type p2) {\
+    return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP3<p0##_type, p1##_type, \
+      p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P4(name, p0, p1, p2, p3, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type>\
+  class name##MatcherP4 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3)\
+           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, \
+                    p3##_type>(p0, p1, p2, p3)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3));\
+    }\
+    name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP4);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type>\
+  inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \
+      p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
+      p3##_type p3) {\
+    return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
+        p1, p2, p3);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \
+      p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type>\
+  class name##MatcherP5 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+          p3##_type gmock_p3, p4##_type gmock_p4)\
+           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
+               p4(gmock_p4) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
+                    p4##_type>(p0, p1, p2, p3, p4)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\
+    }\
+    name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2, p3##_type gmock_p3, \
+        p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP5);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type>\
+  inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+      p4##_type p4) {\
+    return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type>(p0, p1, p2, p3, p4);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type>\
+  class name##MatcherP6 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
+               p4(gmock_p4), p5(gmock_p5) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
+                    p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\
+    }\
+    name##MatcherP6(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP6);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type>\
+  inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
+      p3##_type p3, p4##_type p4, p5##_type p5) {\
+    return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+      p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type>\
+  class name##MatcherP7 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
+               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+      p6##_type p6;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
+                    p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \
+                    p6)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\
+    }\
+    name##MatcherP7(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(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
+        p6(gmock_p6) {\
+    }\
+    p0##_type p0;\
+    p1##_type p1;\
+    p2##_type p2;\
+    p3##_type p3;\
+    p4##_type p4;\
+    p5##_type p5;\
+    p6##_type p6;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP7);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type>\
+  inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
+      p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
+      p6##_type p6) {\
+    return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+      p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type>\
+  class name##MatcherP8 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
+               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      p0##_type p0;\
+      p1##_type p1;\
+      p2##_type p2;\
+      p3##_type p3;\
+      p4##_type p4;\
+      p5##_type p5;\
+      p6##_type p6;\
+      p7##_type p7;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
+                    p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \
+                    p3, p4, p5, p6, p7)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\
+    }\
+    name##MatcherP8(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+        p7(gmock_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;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP8);\
+  };\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type>\
+  inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
+      p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
+      p6##_type p6, p7##_type p7) {\
+    return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
+        p6, p7);\
+  }\
+  template <typename p0##_type, typename p1##_type, typename p2##_type, \
+      typename p3##_type, typename p4##_type, typename p5##_type, \
+      typename p6##_type, typename p7##_type>\
+  template <typename arg_type>\
+  bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+      p5##_type, p6##_type, \
+      p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\
+  template <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>\
+  class name##MatcherP9 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
+               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
+               p8(gmock_p8) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      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;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
+                    p4##_type, p5##_type, p6##_type, p7##_type, \
+                    p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\
+    }\
+    name##MatcherP9(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
+        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
+        p8(gmock_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;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP9);\
+  };\
+  template <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>\
+  inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type, \
+      p8##_type> name(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) {\
+    return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
+        p3, p4, p5, p6, p7, p8);\
+  }\
+  template <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>\
+  template <typename arg_type>\
+  bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+      p5##_type, p6##_type, p7##_type, \
+      p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\
+  template <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>\
+  class name##MatcherP10 {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
+               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
+               p8(gmock_p8), p9(gmock_p9) {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\
+      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;\
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
+                    p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
+                    p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\
+    }\
+    name##MatcherP10(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(gmock_p0), p1(gmock_p1), \
+        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
+        p7(gmock_p7), p8(gmock_p8), p9(gmock_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;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP10);\
+  };\
+  template <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>\
+  inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
+      p9##_type> name(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) {\
+    return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
+        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
+        p1, p2, p3, p4, p5, p6, p7, p8, p9);\
+  }\
+  template <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>\
+  template <typename arg_type>\
+  bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
+      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
+      p9##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h.pump b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h.pump
new file mode 100644
index 00000000..de30c2c9
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h.pump
@@ -0,0 +1,672 @@
+$$ -*- mode: c++; -*-
+$$ This is a Pump source file.  Please use Pump to convert it to
+$$ gmock-generated-actions.h.
+$$
+$var n = 10  $$ The maximum arity we support.
+$$ }} This line fixes auto-indentation of the following code in Emacs.
+// 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.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used variadic matchers.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
+
+#include <iterator>
+#include <sstream>
+#include <string>
+#include <vector>
+#include "gmock/gmock-matchers.h"
+
+namespace testing {
+namespace internal {
+
+$range i 0..n-1
+
+// The type of the i-th (0-based) field of Tuple.
+#define GMOCK_FIELD_TYPE_(Tuple, i) \
+    typename ::testing::tuple_element<i, Tuple>::type
+
+// TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
+// tuple of type Tuple.  It has two members:
+//
+//   type: a tuple type whose i-th field is the ki-th field of Tuple.
+//   GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
+//
+// For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
+//
+//   type is tuple<int, bool>, and
+//   GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
+
+template <class Tuple$for i [[, int k$i = -1]]>
+class TupleFields;
+
+// This generic version is used when there are $n selectors.
+template <class Tuple$for i [[, int k$i]]>
+class TupleFields {
+ public:
+  typedef ::testing::tuple<$for i, [[GMOCK_FIELD_TYPE_(Tuple, k$i)]]> type;
+  static type GetSelectedFields(const Tuple& t) {
+    return type($for i, [[get<k$i>(t)]]);
+  }
+};
+
+// The following specialization is used for 0 ~ $(n-1) selectors.
+
+$for i [[
+$$ }}}
+$range j 0..i-1
+$range k 0..n-1
+
+template <class Tuple$for j [[, int k$j]]>
+class TupleFields<Tuple, $for k, [[$if k < i [[k$k]] $else [[-1]]]]> {
+ public:
+  typedef ::testing::tuple<$for j, [[GMOCK_FIELD_TYPE_(Tuple, k$j)]]> type;
+  static type GetSelectedFields(const Tuple& $if i==0 [[/* t */]] $else [[t]]) {
+    return type($for j, [[get<k$j>(t)]]);
+  }
+};
+
+]]
+
+#undef GMOCK_FIELD_TYPE_
+
+// Implements the Args() matcher.
+
+$var ks = [[$for i, [[k$i]]]]
+template <class ArgsTuple$for i [[, int k$i = -1]]>
+class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
+ public:
+  // ArgsTuple may have top-level const or reference modifiers.
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
+  typedef typename internal::TupleFields<RawArgsTuple, $ks>::type SelectedArgs;
+  typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
+
+  template <typename InnerMatcher>
+  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
+      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
+
+  virtual bool MatchAndExplain(ArgsTuple args,
+                               MatchResultListener* listener) const {
+    const SelectedArgs& selected_args = GetSelectedArgs(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;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "are a tuple ";
+    PrintIndices(os);
+    inner_matcher_.DescribeTo(os);
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "are a tuple ";
+    PrintIndices(os);
+    inner_matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  static SelectedArgs GetSelectedArgs(ArgsTuple args) {
+    return TupleFields<RawArgsTuple, $ks>::GetSelectedFields(args);
+  }
+
+  // Prints the indices of the selected fields.
+  static void PrintIndices(::std::ostream* os) {
+    *os << "whose fields (";
+    const int indices[$n] = { $ks };
+    for (int i = 0; i < $n; i++) {
+      if (indices[i] < 0)
+        break;
+
+      if (i >= 1)
+        *os << ", ";
+
+      *os << "#" << indices[i];
+    }
+    *os << ") ";
+  }
+
+  const MonomorphicInnerMatcher inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
+};
+
+template <class InnerMatcher$for i [[, int k$i = -1]]>
+class ArgsMatcher {
+ public:
+  explicit ArgsMatcher(const InnerMatcher& inner_matcher)
+      : inner_matcher_(inner_matcher) {}
+
+  template <typename ArgsTuple>
+  operator Matcher<ArgsTuple>() const {
+    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, $ks>(inner_matcher_));
+  }
+
+ private:
+  const InnerMatcher inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
+};
+
+// A set of metafunctions for computing the result type of AllOf.
+// AllOf(m1, ..., mN) returns
+// AllOfResultN<decltype(m1), ..., decltype(mN)>::type.
+
+// Although AllOf isn't defined for one argument, AllOfResult1 is defined
+// to simplify the implementation.
+template <typename M1>
+struct AllOfResult1 {
+  typedef M1 type;
+};
+
+$range i 1..n
+
+$range i 2..n
+$for i [[
+$range j 2..i
+$var m = i/2
+$range k 1..m
+$range t m+1..i
+
+template <typename M1$for j [[, typename M$j]]>
+struct AllOfResult$i {
+  typedef BothOfMatcher<
+      typename AllOfResult$m<$for k, [[M$k]]>::type,
+      typename AllOfResult$(i-m)<$for t, [[M$t]]>::type
+  > type;
+};
+
+]]
+
+// A set of metafunctions for computing the result type of AnyOf.
+// AnyOf(m1, ..., mN) returns
+// AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.
+
+// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
+// to simplify the implementation.
+template <typename M1>
+struct AnyOfResult1 {
+  typedef M1 type;
+};
+
+$range i 1..n
+
+$range i 2..n
+$for i [[
+$range j 2..i
+$var m = i/2
+$range k 1..m
+$range t m+1..i
+
+template <typename M1$for j [[, typename M$j]]>
+struct AnyOfResult$i {
+  typedef EitherOfMatcher<
+      typename AnyOfResult$m<$for k, [[M$k]]>::type,
+      typename AnyOfResult$(i-m)<$for t, [[M$t]]>::type
+  > type;
+};
+
+]]
+
+}  // namespace internal
+
+// 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.
+
+$range i 0..n
+$for i [[
+$range j 1..i
+template <$for j [[int k$j, ]]typename InnerMatcher>
+inline internal::ArgsMatcher<InnerMatcher$for j [[, k$j]]>
+Args(const InnerMatcher& matcher) {
+  return internal::ArgsMatcher<InnerMatcher$for j [[, k$j]]>(matcher);
+}
+
+
+]]
+// ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
+// n elements, where the i-th element in the container must
+// match the i-th argument in the list.  Each argument of
+// ElementsAre() can be either a value or a matcher.  We support up to
+// $n arguments.
+//
+// The use of DecayArray in the implementation allows ElementsAre()
+// to accept string literals, whose type is const char[N], but we
+// want to treat them as const char*.
+//
+// NOTE: Since ElementsAre() cares about the order of the elements, it
+// must not be used with containers whose elements's order is
+// undefined (e.g. hash_map).
+
+$range i 0..n
+$for i [[
+
+$range j 1..i
+
+$if i>0 [[
+
+template <$for j, [[typename T$j]]>
+]]
+
+inline internal::ElementsAreMatcher<
+    ::testing::tuple<
+$for j, [[
+
+        typename internal::DecayArray<T$j[[]]>::type]]> >
+ElementsAre($for j, [[const T$j& e$j]]) {
+  typedef ::testing::tuple<
+$for j, [[
+
+      typename internal::DecayArray<T$j[[]]>::type]]> Args;
+  return internal::ElementsAreMatcher<Args>(Args($for j, [[e$j]]));
+}
+
+]]
+
+// UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
+// that matches n elements in any order.  We support up to n=$n arguments.
+
+$range i 0..n
+$for i [[
+
+$range j 1..i
+
+$if i>0 [[
+
+template <$for j, [[typename T$j]]>
+]]
+
+inline internal::UnorderedElementsAreMatcher<
+    ::testing::tuple<
+$for j, [[
+
+        typename internal::DecayArray<T$j[[]]>::type]]> >
+UnorderedElementsAre($for j, [[const T$j& e$j]]) {
+  typedef ::testing::tuple<
+$for j, [[
+
+      typename internal::DecayArray<T$j[[]]>::type]]> Args;
+  return internal::UnorderedElementsAreMatcher<Args>(Args($for j, [[e$j]]));
+}
+
+]]
+
+// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
+// sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.
+
+$range i 2..n
+$for i [[
+$range j 1..i
+$var m = i/2
+$range k 1..m
+$range t m+1..i
+
+template <$for j, [[typename M$j]]>
+inline typename internal::AllOfResult$i<$for j, [[M$j]]>::type
+AllOf($for j, [[M$j m$j]]) {
+  return typename internal::AllOfResult$i<$for j, [[M$j]]>::type(
+      $if m == 1 [[m1]] $else [[::testing::AllOf($for k, [[m$k]])]],
+      $if m+1 == i [[m$i]] $else [[::testing::AllOf($for t, [[m$t]])]]);
+}
+
+]]
+
+// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
+// sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
+
+$range i 2..n
+$for i [[
+$range j 1..i
+$var m = i/2
+$range k 1..m
+$range t m+1..i
+
+template <$for j, [[typename M$j]]>
+inline typename internal::AnyOfResult$i<$for j, [[M$j]]>::type
+AnyOf($for j, [[M$j m$j]]) {
+  return typename internal::AnyOfResult$i<$for j, [[M$j]]>::type(
+      $if m == 1 [[m1]] $else [[::testing::AnyOf($for k, [[m$k]])]],
+      $if m+1 == i [[m$i]] $else [[::testing::AnyOf($for t, [[m$t]])]]);
+}
+
+]]
+
+}  // namespace testing
+$$ } // This Pump meta comment fixes auto-indentation in Emacs. It will not
+$$   // show up in the generated code.
+
+
+// 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,
+//       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.  The reason is
+// that C++ doesn't yet allow function-local types to be used to
+// instantiate templates.  The up-coming C++0x standard will fix this.
+// Once that's done, we'll consider supporting using MATCHER*() inside
+// a function.
+//
+// More Information
+// ================
+//
+// To learn more about using these macros, please search for 'MATCHER'
+// on http://code.google.com/p/googlemock/wiki/CookBook.
+
+$range i 0..n
+$for i
+
+[[
+$var macro_name = [[$if i==0 [[MATCHER]] $elif i==1 [[MATCHER_P]]
+                                         $else [[MATCHER_P$i]]]]
+$var class_name = [[name##Matcher[[$if i==0 [[]] $elif i==1 [[P]]
+                                                 $else [[P$i]]]]]]
+$range j 0..i-1
+$var template = [[$if i==0 [[]] $else [[
+
+  template <$for j, [[typename p$j##_type]]>\
+]]]]
+$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
+$var impl_ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
+$var impl_inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]
+$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]
+$var params = [[$for j, [[p$j]]]]
+$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]]
+$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]]
+$var param_field_decls = [[$for j
+[[
+
+      p$j##_type p$j;\
+]]]]
+$var param_field_decls2 = [[$for j
+[[
+
+    p$j##_type p$j;\
+]]]]
+
+#define $macro_name(name$for j [[, p$j]], description)\$template
+  class $class_name {\
+   public:\
+    template <typename arg_type>\
+    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
+     public:\
+      [[$if i==1 [[explicit ]]]]gmock_Impl($impl_ctor_param_list)\
+          $impl_inits {}\
+      virtual bool MatchAndExplain(\
+          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
+      virtual void DescribeTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(false);\
+      }\
+      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
+        *gmock_os << FormatDescription(true);\
+      }\$param_field_decls
+     private:\
+      ::testing::internal::string FormatDescription(bool negation) const {\
+        const ::testing::internal::string gmock_description = (description);\
+        if (!gmock_description.empty())\
+          return gmock_description;\
+        return ::testing::internal::FormatMatcherDescription(\
+            negation, #name, \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
+                ::testing::tuple<$for j, [[p$j##_type]]>($for j, [[p$j]])));\
+      }\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
+    };\
+    template <typename arg_type>\
+    operator ::testing::Matcher<arg_type>() const {\
+      return ::testing::Matcher<arg_type>(\
+          new gmock_Impl<arg_type>($params));\
+    }\
+    [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {\
+    }\$param_field_decls2
+   private:\
+    GTEST_DISALLOW_ASSIGN_($class_name);\
+  };\$template
+  inline $class_name$param_types name($param_types_and_names) {\
+    return $class_name$param_types($params);\
+  }\$template
+  template <typename arg_type>\
+  bool $class_name$param_types::gmock_Impl<arg_type>::MatchAndExplain(\
+      arg_type arg, \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
+          const
+]]
+
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h
new file mode 100644
index 00000000..4095f4d5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h
@@ -0,0 +1,397 @@
+// This file was GENERATED by command:
+//     pump.py gmock-generated-nice-strict.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// 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, with up-to 10 arguments.  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.
+//
+// Another known limitation is that the constructors of the base mock
+// cannot have arguments passed by non-const reference, which are
+// banned by the Google C++ style guide anyway.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
+
+#include "gmock/gmock-spec-builders.h"
+#include "gmock/internal/gmock-port.h"
+
+namespace testing {
+
+template <class MockClass>
+class NiceMock : public MockClass {
+ public:
+  // We don't factor out the constructor body to a common method, as
+  // we have to avoid a possible clash with members of MockClass.
+  NiceMock() {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  // C++ doesn't (yet) allow inheritance of constructors, so we have
+  // to define it for each arity.
+  template <typename A1>
+  explicit NiceMock(const A1& a1) : MockClass(a1) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+  template <typename A1, typename A2>
+  NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3,
+      const A4& a4) : MockClass(a1, a2, a3, a4) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
+      a6, a7) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
+      a2, a3, a4, a5, a6, a7, a8) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
+      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9, typename A10>
+  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
+      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
+    ::testing::Mock::AllowUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  virtual ~NiceMock() {
+    ::testing::Mock::UnregisterCallReaction(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
+};
+
+template <class MockClass>
+class NaggyMock : public MockClass {
+ public:
+  // We don't factor out the constructor body to a common method, as
+  // we have to avoid a possible clash with members of MockClass.
+  NaggyMock() {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  // C++ doesn't (yet) allow inheritance of constructors, so we have
+  // to define it for each arity.
+  template <typename A1>
+  explicit NaggyMock(const A1& a1) : MockClass(a1) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+  template <typename A1, typename A2>
+  NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3,
+      const A4& a4) : MockClass(a1, a2, a3, a4) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
+      a6, a7) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
+      a2, a3, a4, a5, a6, a7, a8) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
+      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9, typename A10>
+  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
+      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
+    ::testing::Mock::WarnUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  virtual ~NaggyMock() {
+    ::testing::Mock::UnregisterCallReaction(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
+};
+
+template <class MockClass>
+class StrictMock : public MockClass {
+ public:
+  // We don't factor out the constructor body to a common method, as
+  // we have to avoid a possible clash with members of MockClass.
+  StrictMock() {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  // C++ doesn't (yet) allow inheritance of constructors, so we have
+  // to define it for each arity.
+  template <typename A1>
+  explicit StrictMock(const A1& a1) : MockClass(a1) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+  template <typename A1, typename A2>
+  StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3,
+      const A4& a4) : MockClass(a1, a2, a3, a4) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
+      a6, a7) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
+      a2, a3, a4, a5, a6, a7, a8) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
+      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  template <typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9, typename A10>
+  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
+      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
+    ::testing::Mock::FailUninterestingCalls(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  virtual ~StrictMock() {
+    ::testing::Mock::UnregisterCallReaction(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
+};
+
+// The following specializations catch some (relatively more common)
+// user errors of nesting nice and strict mocks.  They do NOT catch
+// all possible errors.
+
+// These specializations are declared but not defined, as NiceMock,
+// NaggyMock, and StrictMock cannot be nested.
+
+template <typename MockClass>
+class NiceMock<NiceMock<MockClass> >;
+template <typename MockClass>
+class NiceMock<NaggyMock<MockClass> >;
+template <typename MockClass>
+class NiceMock<StrictMock<MockClass> >;
+
+template <typename MockClass>
+class NaggyMock<NiceMock<MockClass> >;
+template <typename MockClass>
+class NaggyMock<NaggyMock<MockClass> >;
+template <typename MockClass>
+class NaggyMock<StrictMock<MockClass> >;
+
+template <typename MockClass>
+class StrictMock<NiceMock<MockClass> >;
+template <typename MockClass>
+class StrictMock<NaggyMock<MockClass> >;
+template <typename MockClass>
+class StrictMock<StrictMock<MockClass> >;
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h.pump b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h.pump
new file mode 100644
index 00000000..3ee1ce7f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h.pump
@@ -0,0 +1,161 @@
+$$ -*- mode: c++; -*-
+$$ This is a Pump source file.  Please use Pump to convert it to
+$$ gmock-generated-nice-strict.h.
+$$
+$var n = 10  $$ The maximum arity we support.
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// 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, with up-to $n arguments.  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.
+//
+// Another known limitation is that the constructors of the base mock
+// cannot have arguments passed by non-const reference, which are
+// banned by the Google C++ style guide anyway.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
+
+#include "gmock/gmock-spec-builders.h"
+#include "gmock/internal/gmock-port.h"
+
+namespace testing {
+
+$range kind 0..2
+$for kind [[
+
+$var clazz=[[$if kind==0 [[NiceMock]]
+             $elif kind==1 [[NaggyMock]]
+             $else [[StrictMock]]]]
+
+$var method=[[$if kind==0 [[AllowUninterestingCalls]]
+             $elif kind==1 [[WarnUninterestingCalls]]
+             $else [[FailUninterestingCalls]]]]
+
+template <class MockClass>
+class $clazz : public MockClass {
+ public:
+  // We don't factor out the constructor body to a common method, as
+  // we have to avoid a possible clash with members of MockClass.
+  $clazz() {
+    ::testing::Mock::$method(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+  // C++ doesn't (yet) allow inheritance of constructors, so we have
+  // to define it for each arity.
+  template <typename A1>
+  explicit $clazz(const A1& a1) : MockClass(a1) {
+    ::testing::Mock::$method(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+$range i 2..n
+$for i [[
+$range j 1..i
+  template <$for j, [[typename A$j]]>
+  $clazz($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) {
+    ::testing::Mock::$method(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+
+]]
+  virtual ~$clazz() {
+    ::testing::Mock::UnregisterCallReaction(
+        internal::ImplicitCast_<MockClass*>(this));
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_($clazz);
+};
+
+]]
+
+// The following specializations catch some (relatively more common)
+// user errors of nesting nice and strict mocks.  They do NOT catch
+// all possible errors.
+
+// These specializations are declared but not defined, as NiceMock,
+// NaggyMock, and StrictMock cannot be nested.
+
+template <typename MockClass>
+class NiceMock<NiceMock<MockClass> >;
+template <typename MockClass>
+class NiceMock<NaggyMock<MockClass> >;
+template <typename MockClass>
+class NiceMock<StrictMock<MockClass> >;
+
+template <typename MockClass>
+class NaggyMock<NiceMock<MockClass> >;
+template <typename MockClass>
+class NaggyMock<NaggyMock<MockClass> >;
+template <typename MockClass>
+class NaggyMock<StrictMock<MockClass> >;
+
+template <typename MockClass>
+class StrictMock<NiceMock<MockClass> >;
+template <typename MockClass>
+class StrictMock<NaggyMock<MockClass> >;
+template <typename MockClass>
+class StrictMock<StrictMock<MockClass> >;
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-matchers.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-matchers.h
new file mode 100644
index 00000000..33b37a7a
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-matchers.h
@@ -0,0 +1,4399 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used argument matchers.  More
+// matchers can be defined by the user implementing the
+// MatcherInterface<T> interface if necessary.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+
+#include <math.h>
+#include <algorithm>
+#include <iterator>
+#include <limits>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+# include <initializer_list>  // NOLINT -- must be after gtest.h
+#endif
+
+namespace testing {
+
+// To implement a matcher Foo for type T, define:
+//   1. a class FooMatcherImpl that implements the
+//      MatcherInterface<T> interface, and
+//   2. a factory function that creates a Matcher<T> object from a
+//      FooMatcherImpl*.
+//
+// The two-level delegation design makes it possible to allow a user
+// to write "v" instead of "Eq(v)" where a Matcher is expected, which
+// is impossible if we pass matchers by pointers.  It also eases
+// ownership management as Matcher objects can now be copied like
+// plain values.
+
+// MatchResultListener is an abstract class.  Its << operator can be
+// used by a matcher to explain why a value matches or doesn't match.
+//
+// TODO(wan@google.com): add method
+//   bool InterestedInWhy(bool result) const;
+// to indicate whether the listener is interested in why the match
+// result is 'result'.
+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_ != NULL)
+      *stream_ << x;
+    return *this;
+  }
+
+  // Returns the underlying ostream.
+  ::std::ostream* stream() { return stream_; }
+
+  // Returns true iff 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_ != NULL; }
+
+ 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 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 iff 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 Mock) 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;
+};
+
+// A match result listener that stores the explanation in a string.
+class StringMatchResultListener : public MatchResultListener {
+ public:
+  StringMatchResultListener() : MatchResultListener(&ss_) {}
+
+  // Returns the explanation accumulated so far.
+  internal::string str() const { return ss_.str(); }
+
+  // Clears the explanation accumulated so far.
+  void Clear() { ss_.str(""); }
+
+ private:
+  ::std::stringstream ss_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
+};
+
+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(NULL) {}
+
+ 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);
+};
+
+// 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 {
+ public:
+  // Returns true iff the matcher matches x; also explains the match
+  // result to 'listener'.
+  bool MatchAndExplain(T x, MatchResultListener* listener) const {
+    return impl_->MatchAndExplain(x, listener);
+  }
+
+  // Returns true iff this matcher matches x.
+  bool Matches(T x) const {
+    DummyMatchResultListener dummy;
+    return MatchAndExplain(x, &dummy);
+  }
+
+  // Describes this matcher to an ostream.
+  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
+
+  // Describes the negation of this matcher to an ostream.
+  void DescribeNegationTo(::std::ostream* os) const {
+    impl_->DescribeNegationTo(os);
+  }
+
+  // Explains why x matches, or doesn't match, the matcher.
+  void ExplainMatchResultTo(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 {
+    return impl_.get();
+  }
+
+ protected:
+  MatcherBase() {}
+
+  // Constructs a matcher from its implementation.
+  explicit MatcherBase(const MatcherInterface<T>* impl)
+      : impl_(impl) {}
+
+  virtual ~MatcherBase() {}
+
+ private:
+  // shared_ptr (util/gtl/shared_ptr.h) and linked_ptr have similar
+  // interfaces.  The former dynamically allocates a chunk of memory
+  // to hold the reference count, while the latter tracks all
+  // references using a circular linked list without allocating
+  // memory.  It has been observed that linked_ptr performs better in
+  // typical scenarios.  However, shared_ptr can out-perform
+  // linked_ptr when there are many more uses of the copy constructor
+  // than the default constructor.
+  //
+  // If performance becomes a problem, we should see if using
+  // shared_ptr helps.
+  ::testing::internal::linked_ptr<const MatcherInterface<T> > impl_;
+};
+
+}  // 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 linked_ptr to const
+// MatcherInterface<T>, so copying is fairly cheap.  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<T>* impl)
+      : internal::MatcherBase<T>(impl) {}
+
+  // 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 string
+// matcher is expected.
+template <>
+class GTEST_API_ Matcher<const internal::string&>
+    : public internal::MatcherBase<const internal::string&> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const internal::string&>* impl)
+      : internal::MatcherBase<const internal::string&>(impl) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a string object.
+  Matcher(const internal::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+};
+
+template <>
+class GTEST_API_ Matcher<internal::string>
+    : public internal::MatcherBase<internal::string> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<internal::string>* impl)
+      : internal::MatcherBase<internal::string>(impl) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a string object.
+  Matcher(const internal::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+};
+
+#if GTEST_HAS_STRING_PIECE_
+// The following two specializations allow the user to write str
+// instead of Eq(str) and "foo" instead of Eq("foo") when a StringPiece
+// matcher is expected.
+template <>
+class GTEST_API_ Matcher<const StringPiece&>
+    : public internal::MatcherBase<const StringPiece&> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const StringPiece&>* impl)
+      : internal::MatcherBase<const StringPiece&>(impl) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a string object.
+  Matcher(const internal::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+
+  // Allows the user to pass StringPieces directly.
+  Matcher(StringPiece s);  // NOLINT
+};
+
+template <>
+class GTEST_API_ Matcher<StringPiece>
+    : public internal::MatcherBase<StringPiece> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<StringPiece>* impl)
+      : internal::MatcherBase<StringPiece>(impl) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a string object.
+  Matcher(const internal::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+
+  // Allows the user to pass StringPieces directly.
+  Matcher(StringPiece s);  // NOLINT
+};
+#endif  // GTEST_HAS_STRING_PIECE_
+
+// 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<T>(impl_));
+  }
+
+ private:
+  template <typename T>
+  class MonomorphicImpl : public MatcherInterface<T> {
+   public:
+    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      impl_.DescribeTo(os);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      impl_.DescribeNegationTo(os);
+    }
+
+    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
+      return impl_.MatchAndExplain(x, listener);
+    }
+
+   private:
+    const Impl impl_;
+
+    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
+  };
+
+  Impl impl_;
+
+  GTEST_DISALLOW_ASSIGN_(PolymorphicMatcher);
+};
+
+// Creates a matcher from its implementation.  This is easier to use
+// than the Matcher<T> constructor as it doesn't require you to
+// explicitly write the template argument, e.g.
+//
+//   MakeMatcher(foo);
+// vs
+//   Matcher<const string&>(foo);
+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);
+}
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// The MatcherCastImpl class template is a helper for implementing
+// MatcherCast().  We need this helper in order to partially
+// specialize the implementation of MatcherCast() (C++ allows
+// class/struct templates to be partially specialized, but not
+// function templates.).
+
+// This general version is used when MatcherCast()'s argument is a
+// polymorphic matcher (i.e. something that can be converted to a
+// Matcher but is not one yet; for example, Eq(value)) or a value (for
+// example, "hello").
+template <typename T, typename M>
+class MatcherCastImpl {
+ public:
+  static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
+    // M can be a polymorhic 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.
+    //
+    // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a
+    // polymorphic matcher because it'll be ambiguous if T has an implicit
+    // constructor from M (this usually happens when T has an implicit
+    // constructor from any type).
+    //
+    // It won't work to unconditionally implict_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,
+        BooleanConstant<
+            internal::ImplicitlyConvertible<M, Matcher<T> >::value>());
+  }
+
+ private:
+  static Matcher<T> CastImpl(const M& value, BooleanConstant<false>) {
+    // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
+    // matcher.  It must be a value then.  Use direct initialization to create
+    // a matcher.
+    return Matcher<T>(ImplicitCast_<T>(value));
+  }
+
+  static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,
+                             BooleanConstant<true>) {
+    // M is implicitly convertible to Matcher<T>, which means that either
+    // M is a polymorhpic matcher or Matcher<T> has an implicit constructor
+    // from M.  In both cases using the implicit conversion will produce a
+    // matcher.
+    //
+    // Even if T has an implicit constructor from M, it won't be called because
+    // creating Matcher<T> would require a chain of two user-defined conversions
+    // (first to create T from M and then to create Matcher<T> from T).
+    return polymorphic_matcher_or_value;
+  }
+};
+
+// This more specialized version is used when MatcherCast()'s argument
+// is already a Matcher.  This only compiles when type T can be
+// statically converted to type U.
+template <typename T, typename U>
+class MatcherCastImpl<T, Matcher<U> > {
+ public:
+  static Matcher<T> Cast(const Matcher<U>& source_matcher) {
+    return Matcher<T>(new Impl(source_matcher));
+  }
+
+ private:
+  class Impl : public MatcherInterface<T> {
+   public:
+    explicit Impl(const Matcher<U>& source_matcher)
+        : source_matcher_(source_matcher) {}
+
+    // We delegate the matching logic to the source matcher.
+    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
+      return source_matcher_.MatchAndExplain(static_cast<U>(x), listener);
+    }
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      source_matcher_.DescribeTo(os);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      source_matcher_.DescribeNegationTo(os);
+    }
+
+   private:
+    const Matcher<U> source_matcher_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+};
+
+// This even more specialized version is used for efficiently casting
+// a matcher to its own type.
+template <typename T>
+class MatcherCastImpl<T, Matcher<T> > {
+ public:
+  static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }
+};
+
+}  // namespace internal
+
+// In order to be safe and clear, casting between different matcher
+// types is done explicitly via MatcherCast<T>(m), which takes a
+// matcher m and returns a Matcher<T>.  It compiles only when T can be
+// statically converted to the argument type of m.
+template <typename T, typename M>
+inline Matcher<T> MatcherCast(const M& matcher) {
+  return internal::MatcherCastImpl<T, M>::Cast(matcher);
+}
+
+// Implements SafeMatcherCast().
+//
+// We use an intermediate class to do the actual safe casting as Nokia's
+// Symbian compiler cannot decide between
+// template <T, M> ... (M) and
+// template <T, U> ... (const Matcher<U>&)
+// for function templates but can for member function templates.
+template <typename T>
+class SafeMatcherCastImpl {
+ public:
+  // This overload handles polymorphic matchers and values only since
+  // monomorphic matchers are handled by the next one.
+  template <typename M>
+  static inline Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
+    return internal::MatcherCastImpl<T, M>::Cast(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 U>
+  static inline Matcher<T> Cast(const Matcher<U>& matcher) {
+    // Enforce that T can be implicitly converted to U.
+    GTEST_COMPILE_ASSERT_((internal::ImplicitlyConvertible<T, 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_(
+        internal::is_reference<T>::value || !internal::is_reference<U>::value,
+        cannot_convert_non_referentce_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;
+    const bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
+    const 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);
+  }
+};
+
+template <typename T, typename M>
+inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher) {
+  return SafeMatcherCastImpl<T>::Cast(polymorphic_matcher);
+}
+
+// A<T>() returns a matcher that matches any value of type T.
+template <typename T>
+Matcher<T> A();
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// If the explanation is not empty, prints it to the ostream.
+inline void PrintIfNotEmpty(const internal::string& explanation,
+                            ::std::ostream* os) {
+  if (explanation != "" && os != NULL) {
+    *os << ", " << 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 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("<(") == string::npos);
+}
+
+// Matches the value against the given matcher, prints the value and explains
+// the match result to the listener. Returns the match result.
+// 'listener' must not be NULL.
+// Value cannot be passed by const reference, because some matchers take a
+// non-const argument.
+template <typename Value, typename T>
+bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
+                          MatchResultListener* listener) {
+  if (!listener->IsInterested()) {
+    // If the listener is not interested, we do not need to construct the
+    // inner explanation.
+    return matcher.Matches(value);
+  }
+
+  StringMatchResultListener inner_listener;
+  const bool match = matcher.MatchAndExplain(value, &inner_listener);
+
+  UniversalPrint(value, listener->stream());
+#if GTEST_HAS_RTTI
+  const string& type_name = GetTypeName<Value>();
+  if (IsReadableTypeName(type_name))
+    *listener->stream() << " (of type " << type_name << ")";
+#endif
+  PrintIfNotEmpty(inner_listener.str(), listener->stream());
+
+  return match;
+}
+
+// An internal helper class for doing compile-time loop on a tuple's
+// fields.
+template <size_t N>
+class TuplePrefix {
+ public:
+  // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true
+  // iff 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)
+        && get<N - 1>(matcher_tuple).Matches(get<N - 1>(value_tuple));
+  }
+
+  // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
+  // describes failures in matching the first N fields of matchers
+  // against the first N fields of values.  If there is no failure,
+  // nothing will be streamed to os.
+  template <typename MatcherTuple, typename ValueTuple>
+  static void ExplainMatchFailuresTo(const MatcherTuple& matchers,
+                                     const ValueTuple& values,
+                                     ::std::ostream* os) {
+    // First, describes failures in the first N - 1 fields.
+    TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os);
+
+    // Then describes the failure (if any) in the (N - 1)-th (0-based)
+    // field.
+    typename tuple_element<N - 1, MatcherTuple>::type matcher =
+        get<N - 1>(matchers);
+    typedef typename tuple_element<N - 1, ValueTuple>::type Value;
+    Value value = get<N - 1>(values);
+    StringMatchResultListener listener;
+    if (!matcher.MatchAndExplain(value, &listener)) {
+      // TODO(wan): include in the message the name of the parameter
+      // as used in MOCK_METHOD*() when possible.
+      *os << "  Expected arg #" << N - 1 << ": ";
+      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
+      // isn't interesting to the user most of the time.  The
+      // matcher's MatchAndExplain() method handles the case when
+      // the address is interesting.
+      internal::UniversalPrint(value, os);
+      PrintIfNotEmpty(listener.str(), os);
+      *os << "\n";
+    }
+  }
+};
+
+// The base case.
+template <>
+class TuplePrefix<0> {
+ public:
+  template <typename MatcherTuple, typename ValueTuple>
+  static bool Matches(const MatcherTuple& /* matcher_tuple */,
+                      const ValueTuple& /* value_tuple */) {
+    return true;
+  }
+
+  template <typename MatcherTuple, typename ValueTuple>
+  static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */,
+                                     const ValueTuple& /* values */,
+                                     ::std::ostream* /* os */) {}
+};
+
+// TupleMatches(matcher_tuple, value_tuple) returns true iff 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.
+template <typename MatcherTuple, typename ValueTuple>
+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_(tuple_size<MatcherTuple>::value ==
+                        tuple_size<ValueTuple>::value,
+                        matcher_and_value_have_different_numbers_of_fields);
+  return TuplePrefix<tuple_size<ValueTuple>::value>::
+      Matches(matcher_tuple, value_tuple);
+}
+
+// Describes failures in matching matchers against values.  If there
+// is no failure, nothing will be streamed to os.
+template <typename MatcherTuple, typename ValueTuple>
+void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
+                                const ValueTuple& values,
+                                ::std::ostream* os) {
+  TuplePrefix<tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
+      matchers, values, os);
+}
+
+// TransformTupleValues and its helper.
+//
+// TransformTupleValuesHelper hides the internal machinery that
+// TransformTupleValues uses to implement a tuple traversal.
+template <typename Tuple, typename Func, typename OutIter>
+class TransformTupleValuesHelper {
+ private:
+  typedef ::testing::tuple_size<Tuple> TupleSize;
+
+ public:
+  // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'.
+  // Returns the final value of 'out' in case the caller needs it.
+  static OutIter Run(Func f, const Tuple& t, OutIter out) {
+    return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out);
+  }
+
+ private:
+  template <typename Tup, size_t kRemainingSize>
+  struct IterateOverTuple {
+    OutIter operator() (Func f, const Tup& t, OutIter out) const {
+      *out++ = f(::testing::get<TupleSize::value - kRemainingSize>(t));
+      return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
+    }
+  };
+  template <typename Tup>
+  struct IterateOverTuple<Tup, 0> {
+    OutIter operator() (Func /* f */, const Tup& /* t */, OutIter out) const {
+      return out;
+    }
+  };
+};
+
+// Successively invokes 'f(element)' on each element of the tuple 't',
+// appending each result to the 'out' iterator. Returns the final value
+// of 'out'.
+template <typename Tuple, typename Func, typename OutIter>
+OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) {
+  return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);
+}
+
+// Implements A<T>().
+template <typename T>
+class AnyMatcherImpl : public MatcherInterface<T> {
+ public:
+  virtual bool MatchAndExplain(
+      T /* x */, MatchResultListener* /* listener */) const { return true; }
+  virtual void DescribeTo(::std::ostream* os) const { *os << "is anything"; }
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    // This is mostly for completeness' safe, 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";
+  }
+};
+
+// 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:
+  template <typename T>
+  operator Matcher<T>() const { return A<T>(); }
+};
+
+// 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) {}
+  template <typename Lhs>
+  operator Matcher<Lhs>() const {
+    return MakeMatcher(new Impl<Lhs>(rhs_));
+  }
+
+ private:
+  template <typename Lhs>
+  class Impl : public MatcherInterface<Lhs> {
+   public:
+    explicit Impl(const Rhs& rhs) : rhs_(rhs) {}
+    virtual bool MatchAndExplain(
+        Lhs lhs, MatchResultListener* /* listener */) const {
+      return Op()(lhs, rhs_);
+    }
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << D::Desc() << " ";
+      UniversalPrint(rhs_, os);
+    }
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << D::NegatedDesc() <<  " ";
+      UniversalPrint(rhs_, os);
+    }
+   private:
+    Rhs rhs_;
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+  Rhs rhs_;
+  GTEST_DISALLOW_ASSIGN_(ComparisonBase);
+};
+
+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 >="; }
+};
+
+// Implements the polymorphic IsNull() matcher, which matches any raw or smart
+// pointer that is NULL.
+class IsNullMatcher {
+ public:
+  template <typename Pointer>
+  bool MatchAndExplain(const Pointer& p,
+                       MatchResultListener* /* listener */) const {
+#if GTEST_LANG_CXX11
+    return p == nullptr;
+#else  // GTEST_LANG_CXX11
+    return GetRawPointer(p) == NULL;
+#endif  // GTEST_LANG_CXX11
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "isn't NULL";
+  }
+};
+
+// Implements the polymorphic NotNull() matcher, which matches any raw or smart
+// pointer that is not NULL.
+class NotNullMatcher {
+ public:
+  template <typename Pointer>
+  bool MatchAndExplain(const Pointer& p,
+                       MatchResultListener* /* listener */) const {
+#if GTEST_LANG_CXX11
+    return p != nullptr;
+#else  // GTEST_LANG_CXX11
+    return GetRawPointer(p) != NULL;
+#endif  // GTEST_LANG_CXX11
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is NULL";
+  }
+};
+
+// Ref(variable) matches any argument that is a reference to
+// 'variable'.  This matcher is polymorphic as it can match any
+// super type of the type of 'variable'.
+//
+// The RefMatcher template class implements Ref(variable).  It can
+// only be instantiated with a reference type.  This prevents a user
+// from mistakenly using Ref(x) to match a non-reference function
+// argument.  For example, the following will righteously cause a
+// compiler error:
+//
+//   int n;
+//   Matcher<int> m1 = Ref(n);   // This won't compile.
+//   Matcher<int&> m2 = Ref(n);  // This will compile.
+template <typename T>
+class RefMatcher;
+
+template <typename T>
+class RefMatcher<T&> {
+  // Google Mock is a generic framework and thus needs to support
+  // mocking any function types, including those that take non-const
+  // reference arguments.  Therefore the template parameter T (and
+  // Super below) can be instantiated to either a const type or a
+  // non-const type.
+ public:
+  // RefMatcher() takes a T& instead of const T&, as we want the
+  // compiler to catch using Ref(const_value) as a matcher for a
+  // non-const reference.
+  explicit RefMatcher(T& x) : object_(x) {}  // NOLINT
+
+  template <typename Super>
+  operator Matcher<Super&>() const {
+    // By passing object_ (type T&) to Impl(), which expects a Super&,
+    // we make sure that Super is a super type of T.  In particular,
+    // this catches using Ref(const_value) as a matcher for a
+    // non-const reference, as you cannot implicitly convert a const
+    // reference to a non-const reference.
+    return MakeMatcher(new Impl<Super>(object_));
+  }
+
+ private:
+  template <typename Super>
+  class Impl : public MatcherInterface<Super&> {
+   public:
+    explicit Impl(Super& x) : object_(x) {}  // NOLINT
+
+    // MatchAndExplain() takes a Super& (as opposed to const Super&)
+    // in order to match the interface MatcherInterface<Super&>.
+    virtual bool MatchAndExplain(
+        Super& x, MatchResultListener* listener) const {
+      *listener << "which is located @" << static_cast<const void*>(&x);
+      return &x == &object_;
+    }
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "references the variable ";
+      UniversalPrinter<Super&>::Print(object_, os);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "does not reference the variable ";
+      UniversalPrinter<Super&>::Print(object_, os);
+    }
+
+   private:
+    const Super& object_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  T& object_;
+
+  GTEST_DISALLOW_ASSIGN_(RefMatcher);
+};
+
+// Polymorphic helper functions for narrow and wide string matchers.
+inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
+  return String::CaseInsensitiveCStringEquals(lhs, rhs);
+}
+
+inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
+                                         const wchar_t* rhs) {
+  return String::CaseInsensitiveWideCStringEquals(lhs, rhs);
+}
+
+// String comparison for narrow or wide strings that can have embedded NUL
+// characters.
+template <typename StringType>
+bool CaseInsensitiveStringEquals(const StringType& s1,
+                                 const StringType& s2) {
+  // Are the heads equal?
+  if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {
+    return false;
+  }
+
+  // Skip the equal heads.
+  const typename StringType::value_type nul = 0;
+  const size_t i1 = s1.find(nul), i2 = s2.find(nul);
+
+  // Are we at the end of either s1 or s2?
+  if (i1 == StringType::npos || i2 == StringType::npos) {
+    return i1 == i2;
+  }
+
+  // Are the tails equal?
+  return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1));
+}
+
+// String matchers.
+
+// Implements equality-based string matchers like StrEq, StrCaseNe, and etc.
+template <typename StringType>
+class StrEqualityMatcher {
+ public:
+  StrEqualityMatcher(const StringType& str, bool expect_eq,
+                     bool case_sensitive)
+      : string_(str), expect_eq_(expect_eq), case_sensitive_(case_sensitive) {}
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    if (s == NULL) {
+      return !expect_eq_;
+    }
+    return MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringPiece has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    const bool eq = case_sensitive_ ? s2 == string_ :
+        CaseInsensitiveStringEquals(s2, string_);
+    return expect_eq_ == eq;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    DescribeToHelper(expect_eq_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    DescribeToHelper(!expect_eq_, os);
+  }
+
+ private:
+  void DescribeToHelper(bool expect_eq, ::std::ostream* os) const {
+    *os << (expect_eq ? "is " : "isn't ");
+    *os << "equal to ";
+    if (!case_sensitive_) {
+      *os << "(ignoring case) ";
+    }
+    UniversalPrint(string_, os);
+  }
+
+  const StringType string_;
+  const bool expect_eq_;
+  const bool case_sensitive_;
+
+  GTEST_DISALLOW_ASSIGN_(StrEqualityMatcher);
+};
+
+// Implements the polymorphic HasSubstr(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class HasSubstrMatcher {
+ public:
+  explicit HasSubstrMatcher(const StringType& substring)
+      : substring_(substring) {}
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != NULL && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringPiece has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    return s2.find(substring_) != StringType::npos;
+  }
+
+  // Describes what this matcher matches.
+  void DescribeTo(::std::ostream* os) const {
+    *os << "has substring ";
+    UniversalPrint(substring_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "has no substring ";
+    UniversalPrint(substring_, os);
+  }
+
+ private:
+  const StringType substring_;
+
+  GTEST_DISALLOW_ASSIGN_(HasSubstrMatcher);
+};
+
+// Implements the polymorphic StartsWith(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class StartsWithMatcher {
+ public:
+  explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {
+  }
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != NULL && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringPiece has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    return s2.length() >= prefix_.length() &&
+        s2.substr(0, prefix_.length()) == prefix_;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "starts with ";
+    UniversalPrint(prefix_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't start with ";
+    UniversalPrint(prefix_, os);
+  }
+
+ private:
+  const StringType prefix_;
+
+  GTEST_DISALLOW_ASSIGN_(StartsWithMatcher);
+};
+
+// Implements the polymorphic EndsWith(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class EndsWithMatcher {
+ public:
+  explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != NULL && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringPiece has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    return s2.length() >= suffix_.length() &&
+        s2.substr(s2.length() - suffix_.length()) == suffix_;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "ends with ";
+    UniversalPrint(suffix_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't end with ";
+    UniversalPrint(suffix_, os);
+  }
+
+ private:
+  const StringType suffix_;
+
+  GTEST_DISALLOW_ASSIGN_(EndsWithMatcher);
+};
+
+// 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) {}
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != NULL && MatchAndExplain(internal::string(s), listener);
+  }
+
+  // Matches anything that can convert to internal::string.
+  //
+  // This is a template, not just a plain function with const internal::string&,
+  // because StringPiece has some interfering non-explicit constructors.
+  template <class MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const internal::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<internal::string>::Print(regex_->pattern(), os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't " << (full_match_ ? "match" : "contain")
+        << " regular expression ";
+    UniversalPrinter<internal::string>::Print(regex_->pattern(), os);
+  }
+
+ private:
+  const internal::linked_ptr<const RE> regex_;
+  const bool full_match_;
+
+  GTEST_DISALLOW_ASSIGN_(MatchesRegexMatcher);
+};
+
+// Implements a matcher that compares the two fields of a 2-tuple
+// using one of the ==, <=, <, etc, operators.  The two fields being
+// compared don't have to have the same type.
+//
+// The matcher defined here is polymorphic (for example, Eq() can be
+// used to match a tuple<int, short>, a 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< ::testing::tuple<T1, T2> >() const {
+    return MakeMatcher(new Impl< ::testing::tuple<T1, T2> >);
+  }
+  template <typename T1, typename T2>
+  operator Matcher<const ::testing::tuple<T1, T2>&>() const {
+    return MakeMatcher(new Impl<const ::testing::tuple<T1, T2>&>);
+  }
+
+ private:
+  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
+    return os << D::Desc();
+  }
+
+  template <typename Tuple>
+  class Impl : public MatcherInterface<Tuple> {
+   public:
+    virtual bool MatchAndExplain(
+        Tuple args,
+        MatchResultListener* /* listener */) const {
+      return Op()(::testing::get<0>(args), ::testing::get<1>(args));
+    }
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "are " << GetDesc;
+    }
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "aren't " << GetDesc;
+    }
+  };
+};
+
+class Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> {
+ public:
+  static const char* Desc() { return "an equal pair"; }
+};
+class Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> {
+ public:
+  static const char* Desc() { return "an unequal pair"; }
+};
+class Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> {
+ public:
+  static const char* Desc() { return "a pair where the first < the second"; }
+};
+class Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> {
+ public:
+  static const char* Desc() { return "a pair where the first > the second"; }
+};
+class Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> {
+ public:
+  static const char* Desc() { return "a pair where the first <= the second"; }
+};
+class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> {
+ public:
+  static const char* Desc() { return "a pair where the first >= the second"; }
+};
+
+// Implements the Not(...) matcher for a particular argument type T.
+// We do not nest it inside the NotMatcher class template, as that
+// will prevent different instantiations of NotMatcher from sharing
+// the same NotMatcherImpl<T> class.
+template <typename T>
+class NotMatcherImpl : public MatcherInterface<T> {
+ public:
+  explicit NotMatcherImpl(const Matcher<T>& matcher)
+      : matcher_(matcher) {}
+
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
+    return !matcher_.MatchAndExplain(x, listener);
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    matcher_.DescribeNegationTo(os);
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    matcher_.DescribeTo(os);
+  }
+
+ private:
+  const Matcher<T> matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(NotMatcherImpl);
+};
+
+// Implements the Not(m) matcher, which matches a value that doesn't
+// match matcher m.
+template <typename InnerMatcher>
+class NotMatcher {
+ public:
+  explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {}
+
+  // This template type conversion operator allows Not(m) to be used
+  // to match any type m can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
+  }
+
+ private:
+  InnerMatcher matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(NotMatcher);
+};
+
+// Implements the AllOf(m1, m2) matcher for a particular argument type
+// T. We do not nest it inside the BothOfMatcher class template, as
+// that will prevent different instantiations of BothOfMatcher from
+// sharing the same BothOfMatcherImpl<T> class.
+template <typename T>
+class BothOfMatcherImpl : public MatcherInterface<T> {
+ public:
+  BothOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2)
+      : matcher1_(matcher1), matcher2_(matcher2) {}
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "(";
+    matcher1_.DescribeTo(os);
+    *os << ") and (";
+    matcher2_.DescribeTo(os);
+    *os << ")";
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "(";
+    matcher1_.DescribeNegationTo(os);
+    *os << ") or (";
+    matcher2_.DescribeNegationTo(os);
+    *os << ")";
+  }
+
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
+    // If either matcher1_ or matcher2_ doesn't match x, we only need
+    // to explain why one of them fails.
+    StringMatchResultListener listener1;
+    if (!matcher1_.MatchAndExplain(x, &listener1)) {
+      *listener << listener1.str();
+      return false;
+    }
+
+    StringMatchResultListener listener2;
+    if (!matcher2_.MatchAndExplain(x, &listener2)) {
+      *listener << listener2.str();
+      return false;
+    }
+
+    // Otherwise we need to explain why *both* of them match.
+    const internal::string s1 = listener1.str();
+    const internal::string s2 = listener2.str();
+
+    if (s1 == "") {
+      *listener << s2;
+    } else {
+      *listener << s1;
+      if (s2 != "") {
+        *listener << ", and " << s2;
+      }
+    }
+    return true;
+  }
+
+ private:
+  const Matcher<T> matcher1_;
+  const Matcher<T> matcher2_;
+
+  GTEST_DISALLOW_ASSIGN_(BothOfMatcherImpl);
+};
+
+#if GTEST_LANG_CXX11
+// MatcherList provides mechanisms for storing a variable number of matchers in
+// a list structure (ListType) and creating a combining matcher from such a
+// list.
+// The template is defined recursively using the following template paramters:
+//   * kSize is the length of the MatcherList.
+//   * Head is the type of the first matcher of the list.
+//   * Tail denotes the types of the remaining matchers of the list.
+template <int kSize, typename Head, typename... Tail>
+struct MatcherList {
+  typedef MatcherList<kSize - 1, Tail...> MatcherListTail;
+  typedef ::std::pair<Head, typename MatcherListTail::ListType> ListType;
+
+  // BuildList stores variadic type values in a nested pair structure.
+  // Example:
+  // MatcherList<3, int, string, float>::BuildList(5, "foo", 2.0) will return
+  // the corresponding result of type pair<int, pair<string, float>>.
+  static ListType BuildList(const Head& matcher, const Tail&... tail) {
+    return ListType(matcher, MatcherListTail::BuildList(tail...));
+  }
+
+  // CreateMatcher<T> creates a Matcher<T> from a given list of matchers (built
+  // by BuildList()). CombiningMatcher<T> is used to combine the matchers of the
+  // list. CombiningMatcher<T> must implement MatcherInterface<T> and have a
+  // constructor taking two Matcher<T>s as input.
+  template <typename T, template <typename /* T */> class CombiningMatcher>
+  static Matcher<T> CreateMatcher(const ListType& matchers) {
+    return Matcher<T>(new CombiningMatcher<T>(
+        SafeMatcherCast<T>(matchers.first),
+        MatcherListTail::template CreateMatcher<T, CombiningMatcher>(
+            matchers.second)));
+  }
+};
+
+// The following defines the base case for the recursive definition of
+// MatcherList.
+template <typename Matcher1, typename Matcher2>
+struct MatcherList<2, Matcher1, Matcher2> {
+  typedef ::std::pair<Matcher1, Matcher2> ListType;
+
+  static ListType BuildList(const Matcher1& matcher1,
+                            const Matcher2& matcher2) {
+    return ::std::pair<Matcher1, Matcher2>(matcher1, matcher2);
+  }
+
+  template <typename T, template <typename /* T */> class CombiningMatcher>
+  static Matcher<T> CreateMatcher(const ListType& matchers) {
+    return Matcher<T>(new CombiningMatcher<T>(
+        SafeMatcherCast<T>(matchers.first),
+        SafeMatcherCast<T>(matchers.second)));
+  }
+};
+
+// VariadicMatcher is used for the variadic implementation of
+// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...).
+// CombiningMatcher<T> is used to recursively combine the provided matchers
+// (of type Args...).
+template <template <typename T> class CombiningMatcher, typename... Args>
+class VariadicMatcher {
+ public:
+  VariadicMatcher(const Args&... matchers)  // NOLINT
+      : matchers_(MatcherListType::BuildList(matchers...)) {}
+
+  // 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 {
+    return MatcherListType::template CreateMatcher<T, CombiningMatcher>(
+        matchers_);
+  }
+
+ private:
+  typedef MatcherList<sizeof...(Args), Args...> MatcherListType;
+
+  const typename MatcherListType::ListType matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(VariadicMatcher);
+};
+
+template <typename... Args>
+using AllOfMatcher = VariadicMatcher<BothOfMatcherImpl, Args...>;
+
+#endif  // GTEST_LANG_CXX11
+
+// Used for implementing the AllOf(m_1, ..., m_n) matcher, which
+// matches a value that matches all of the matchers m_1, ..., and m_n.
+template <typename Matcher1, typename Matcher2>
+class BothOfMatcher {
+ public:
+  BothOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
+      : matcher1_(matcher1), matcher2_(matcher2) {}
+
+  // This template type conversion operator allows a
+  // BothOfMatcher<Matcher1, Matcher2> object to match any type that
+  // both Matcher1 and Matcher2 can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new BothOfMatcherImpl<T>(SafeMatcherCast<T>(matcher1_),
+                                               SafeMatcherCast<T>(matcher2_)));
+  }
+
+ private:
+  Matcher1 matcher1_;
+  Matcher2 matcher2_;
+
+  GTEST_DISALLOW_ASSIGN_(BothOfMatcher);
+};
+
+// 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 EitherOfMatcherImpl : public MatcherInterface<T> {
+ public:
+  EitherOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2)
+      : matcher1_(matcher1), matcher2_(matcher2) {}
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "(";
+    matcher1_.DescribeTo(os);
+    *os << ") or (";
+    matcher2_.DescribeTo(os);
+    *os << ")";
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "(";
+    matcher1_.DescribeNegationTo(os);
+    *os << ") and (";
+    matcher2_.DescribeNegationTo(os);
+    *os << ")";
+  }
+
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
+    // If either matcher1_ or matcher2_ matches x, we just need to
+    // explain why *one* of them matches.
+    StringMatchResultListener listener1;
+    if (matcher1_.MatchAndExplain(x, &listener1)) {
+      *listener << listener1.str();
+      return true;
+    }
+
+    StringMatchResultListener listener2;
+    if (matcher2_.MatchAndExplain(x, &listener2)) {
+      *listener << listener2.str();
+      return true;
+    }
+
+    // Otherwise we need to explain why *both* of them fail.
+    const internal::string s1 = listener1.str();
+    const internal::string s2 = listener2.str();
+
+    if (s1 == "") {
+      *listener << s2;
+    } else {
+      *listener << s1;
+      if (s2 != "") {
+        *listener << ", and " << s2;
+      }
+    }
+    return false;
+  }
+
+ private:
+  const Matcher<T> matcher1_;
+  const Matcher<T> matcher2_;
+
+  GTEST_DISALLOW_ASSIGN_(EitherOfMatcherImpl);
+};
+
+#if GTEST_LANG_CXX11
+// AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...).
+template <typename... Args>
+using AnyOfMatcher = VariadicMatcher<EitherOfMatcherImpl, Args...>;
+
+#endif  // GTEST_LANG_CXX11
+
+// Used for implementing the AnyOf(m_1, ..., m_n) matcher, which
+// matches a value that matches at least one of the matchers m_1, ...,
+// and m_n.
+template <typename Matcher1, typename Matcher2>
+class EitherOfMatcher {
+ public:
+  EitherOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
+      : matcher1_(matcher1), matcher2_(matcher2) {}
+
+  // This template type conversion operator allows a
+  // EitherOfMatcher<Matcher1, Matcher2> object to match any type that
+  // both Matcher1 and Matcher2 can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new EitherOfMatcherImpl<T>(
+        SafeMatcherCast<T>(matcher1_), SafeMatcherCast<T>(matcher2_)));
+  }
+
+ private:
+  Matcher1 matcher1_;
+  Matcher2 matcher2_;
+
+  GTEST_DISALLOW_ASSIGN_(EitherOfMatcher);
+};
+
+// Used for implementing Truly(pred), which turns a predicate into a
+// matcher.
+template <typename Predicate>
+class TrulyMatcher {
+ public:
+  explicit TrulyMatcher(Predicate pred) : predicate_(pred) {}
+
+  // This method template allows Truly(pred) to be used as a matcher
+  // for type T where T is the argument type of predicate 'pred'.  The
+  // argument is passed by reference as the predicate may be
+  // interested in the address of the argument.
+  template <typename T>
+  bool MatchAndExplain(T& x,  // NOLINT
+                       MatchResultListener* /* listener */) const {
+    // Without the if-statement, MSVC sometimes warns about converting
+    // a value to bool (warning 4800).
+    //
+    // We cannot write 'return !!predicate_(x);' as that doesn't work
+    // when predicate_(x) returns a class convertible to bool but
+    // having no operator!().
+    if (predicate_(x))
+      return true;
+    return false;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "satisfies the given predicate";
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't satisfy the given predicate";
+  }
+
+ private:
+  Predicate predicate_;
+
+  GTEST_DISALLOW_ASSIGN_(TrulyMatcher);
+};
+
+// Used for implementing Matches(matcher), which turns a matcher into
+// a predicate.
+template <typename M>
+class MatcherAsPredicate {
+ public:
+  explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {}
+
+  // This template operator() allows Matches(m) to be used as a
+  // predicate on type T where m is a matcher on type T.
+  //
+  // The argument x is passed by reference instead of by value, as
+  // some matcher may be interested in its address (e.g. as in
+  // Matches(Ref(n))(x)).
+  template <typename T>
+  bool operator()(const T& x) const {
+    // We let matcher_ commit to a particular type here instead of
+    // when the MatcherAsPredicate object was constructed.  This
+    // allows us to write Matches(m) where m is a polymorphic matcher
+    // (e.g. Eq(5)).
+    //
+    // If we write Matcher<T>(matcher_).Matches(x) here, it won't
+    // compile when matcher_ has type Matcher<const T&>; if we write
+    // Matcher<const T&>(matcher_).Matches(x) here, it won't compile
+    // when matcher_ has type Matcher<T>; if we just write
+    // matcher_.Matches(x), it won't compile when matcher_ is
+    // polymorphic, e.g. Eq(5).
+    //
+    // MatcherCast<const T&>() is necessary for making the code work
+    // in all of the above situations.
+    return MatcherCast<const T&>(matcher_).Matches(x);
+  }
+
+ private:
+  M matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(MatcherAsPredicate);
+};
+
+// For implementing ASSERT_THAT() and EXPECT_THAT().  The template
+// argument M must be a type that can be converted to a matcher.
+template <typename M>
+class PredicateFormatterFromMatcher {
+ public:
+  explicit PredicateFormatterFromMatcher(M m) : matcher_(internal::move(m)) {}
+
+  // This template () operator allows a PredicateFormatterFromMatcher
+  // object to act as a predicate-formatter suitable for using with
+  // Google Test's EXPECT_PRED_FORMAT1() macro.
+  template <typename T>
+  AssertionResult operator()(const char* value_text, const T& x) const {
+    // We convert matcher_ to a Matcher<const T&> *now* instead of
+    // when the PredicateFormatterFromMatcher object was constructed,
+    // as matcher_ may be polymorphic (e.g. NotNull()) and we won't
+    // know which type to instantiate it to until we actually see the
+    // type of x here.
+    //
+    // We write SafeMatcherCast<const T&>(matcher_) instead of
+    // Matcher<const T&>(matcher_), as the latter won't compile when
+    // matcher_ has type Matcher<T> (e.g. An<int>()).
+    // 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_);
+    StringMatchResultListener listener;
+    if (MatchPrintAndExplain(x, matcher, &listener))
+      return AssertionSuccess();
+
+    ::std::stringstream ss;
+    ss << "Value of: " << value_text << "\n"
+       << "Expected: ";
+    matcher.DescribeTo(&ss);
+    ss << "\n  Actual: " << listener.str();
+    return AssertionFailure() << ss.str();
+  }
+
+ private:
+  const M matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PredicateFormatterFromMatcher);
+};
+
+// A helper function for converting a matcher to a predicate-formatter
+// without the user needing to explicitly write the type.  This is
+// used for implementing ASSERT_THAT() and EXPECT_THAT().
+// Implementation detail: 'matcher' is received by-value to force decaying.
+template <typename M>
+inline PredicateFormatterFromMatcher<M>
+MakePredicateFormatterFromMatcher(M matcher) {
+  return PredicateFormatterFromMatcher<M>(internal::move(matcher));
+}
+
+// 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
+// FloatType being either float or double.
+template <typename FloatType>
+class FloatingEqMatcher {
+ public:
+  // Constructor for FloatingEqMatcher.
+  // The matcher's input will be compared with expected.  The matcher treats two
+  // NANs as equal if nan_eq_nan is true.  Otherwise, under IEEE standards,
+  // equality comparisons between NANs will always return false.  We specify a
+  // negative max_abs_error_ term to indicate that ULP-based approximation will
+  // be used for comparison.
+  FloatingEqMatcher(FloatType expected, bool nan_eq_nan) :
+    expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {
+  }
+
+  // Constructor that supports a user-specified max_abs_error that will be used
+  // for comparison instead of ULP-based approximation.  The max absolute
+  // should be non-negative.
+  FloatingEqMatcher(FloatType expected, bool nan_eq_nan,
+                    FloatType max_abs_error)
+      : expected_(expected),
+        nan_eq_nan_(nan_eq_nan),
+        max_abs_error_(max_abs_error) {
+    GTEST_CHECK_(max_abs_error >= 0)
+        << ", where max_abs_error is" << max_abs_error;
+  }
+
+  // Implements floating point equality matcher as a Matcher<T>.
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+   public:
+    Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error)
+        : expected_(expected),
+          nan_eq_nan_(nan_eq_nan),
+          max_abs_error_(max_abs_error) {}
+
+    virtual bool MatchAndExplain(T value,
+                                 MatchResultListener* listener) const {
+      const FloatingPoint<FloatType> actual(value), expected(expected_);
+
+      // Compares NaNs first, if nan_eq_nan_ is true.
+      if (actual.is_nan() || expected.is_nan()) {
+        if (actual.is_nan() && expected.is_nan()) {
+          return nan_eq_nan_;
+        }
+        // One is nan; the other is not nan.
+        return false;
+      }
+      if (HasMaxAbsError()) {
+        // We perform an equality check so that inf will match inf, regardless
+        // of error bounds.  If the result of value - expected_ would result in
+        // overflow or if either value is inf, the default result is infinity,
+        // which should only match if max_abs_error_ is also infinity.
+        if (value == expected_) {
+          return true;
+        }
+
+        const FloatType diff = value - expected_;
+        if (fabs(diff) <= max_abs_error_) {
+          return true;
+        }
+
+        if (listener->IsInterested()) {
+          *listener << "which is " << diff << " from " << expected_;
+        }
+        return false;
+      } else {
+        return actual.AlmostEquals(expected);
+      }
+    }
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      // os->precision() returns the previously set precision, which we
+      // store to restore the ostream to its original configuration
+      // after outputting.
+      const ::std::streamsize old_precision = os->precision(
+          ::std::numeric_limits<FloatType>::digits10 + 2);
+      if (FloatingPoint<FloatType>(expected_).is_nan()) {
+        if (nan_eq_nan_) {
+          *os << "is NaN";
+        } else {
+          *os << "never matches";
+        }
+      } else {
+        *os << "is approximately " << expected_;
+        if (HasMaxAbsError()) {
+          *os << " (absolute error <= " << max_abs_error_ << ")";
+        }
+      }
+      os->precision(old_precision);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      // As before, get original precision.
+      const ::std::streamsize old_precision = os->precision(
+          ::std::numeric_limits<FloatType>::digits10 + 2);
+      if (FloatingPoint<FloatType>(expected_).is_nan()) {
+        if (nan_eq_nan_) {
+          *os << "isn't NaN";
+        } else {
+          *os << "is anything";
+        }
+      } else {
+        *os << "isn't approximately " << expected_;
+        if (HasMaxAbsError()) {
+          *os << " (absolute error > " << max_abs_error_ << ")";
+        }
+      }
+      // Restore original precision.
+      os->precision(old_precision);
+    }
+
+   private:
+    bool HasMaxAbsError() const {
+      return max_abs_error_ >= 0;
+    }
+
+    const FloatType expected_;
+    const bool nan_eq_nan_;
+    // max_abs_error will be used for value comparison when >= 0.
+    const FloatType max_abs_error_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  // The following 3 type conversion operators allow FloatEq(expected) and
+  // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a
+  // Matcher<const float&>, or a Matcher<float&>, but nothing else.
+  // (While Google's C++ coding style doesn't allow arguments passed
+  // by non-const reference, we may see them in code not conforming to
+  // the style.  Therefore Google Mock needs to support them.)
+  operator Matcher<FloatType>() const {
+    return MakeMatcher(
+        new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+  operator Matcher<const FloatType&>() const {
+    return MakeMatcher(
+        new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+  operator Matcher<FloatType&>() const {
+    return MakeMatcher(
+        new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+ private:
+  const FloatType expected_;
+  const bool nan_eq_nan_;
+  // max_abs_error will be used for value comparison when >= 0.
+  const FloatType max_abs_error_;
+
+  GTEST_DISALLOW_ASSIGN_(FloatingEqMatcher);
+};
+
+// 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>
+class PointeeMatcher {
+ public:
+  explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
+
+  // This type conversion operator template allows Pointee(m) to be
+  // used as a matcher for any pointer type whose pointee type is
+  // compatible with the inner matcher, where type Pointer 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 Pointee().
+  template <typename Pointer>
+  operator Matcher<Pointer>() const {
+    return MakeMatcher(new Impl<Pointer>(matcher_));
+  }
+
+ private:
+  // The monomorphic implementation that works for a particular pointer type.
+  template <typename Pointer>
+  class Impl : public MatcherInterface<Pointer> {
+   public:
+    typedef typename PointeeOf<GTEST_REMOVE_CONST_(  // NOLINT
+        GTEST_REMOVE_REFERENCE_(Pointer))>::type Pointee;
+
+    explicit Impl(const InnerMatcher& matcher)
+        : matcher_(MatcherCast<const Pointee&>(matcher)) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "points to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "does not point to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    virtual bool MatchAndExplain(Pointer pointer,
+                                 MatchResultListener* listener) const {
+      if (GetRawPointer(pointer) == NULL)
+        return false;
+
+      *listener << "which points to ";
+      return MatchPrintAndExplain(*pointer, matcher_, listener);
+    }
+
+   private:
+    const Matcher<const Pointee&> matcher_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  const InnerMatcher matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PointeeMatcher);
+};
+
+// 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.
+// If To is a pointer and the cast fails, the inner matcher will receive NULL.
+// If To is a reference and the cast fails, this matcher returns false
+// immediately.
+template <typename To>
+class WhenDynamicCastToMatcherBase {
+ public:
+  explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher)
+      : matcher_(matcher) {}
+
+  void DescribeTo(::std::ostream* os) const {
+    GetCastTypeDescription(os);
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    GetCastTypeDescription(os);
+    matcher_.DescribeNegationTo(os);
+  }
+
+ protected:
+  const Matcher<To> matcher_;
+
+  static string GetToName() {
+#if GTEST_HAS_RTTI
+    return GetTypeName<To>();
+#else  // GTEST_HAS_RTTI
+    return "the target type";
+#endif  // GTEST_HAS_RTTI
+  }
+
+ private:
+  static void GetCastTypeDescription(::std::ostream* os) {
+    *os << "when dynamic_cast to " << GetToName() << ", ";
+  }
+
+  GTEST_DISALLOW_ASSIGN_(WhenDynamicCastToMatcherBase);
+};
+
+// Primary template.
+// To is a pointer. Cast and forward the result.
+template <typename To>
+class WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> {
+ public:
+  explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher)
+      : WhenDynamicCastToMatcherBase<To>(matcher) {}
+
+  template <typename From>
+  bool MatchAndExplain(From from, MatchResultListener* listener) const {
+    // TODO(sbenza): Add more detail on failures. ie did the dyn_cast fail?
+    To to = dynamic_cast<To>(from);
+    return MatchPrintAndExplain(to, this->matcher_, listener);
+  }
+};
+
+// Specialize for references.
+// In this case we return false if the dynamic_cast fails.
+template <typename To>
+class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> {
+ public:
+  explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher)
+      : WhenDynamicCastToMatcherBase<To&>(matcher) {}
+
+  template <typename From>
+  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 == NULL) {
+      *listener << "which cannot be dynamic_cast to " << this->GetToName();
+      return false;
+    }
+    return MatchPrintAndExplain(*to, this->matcher_, listener);
+  }
+};
+
+// Implements the Field() matcher for matching a field (i.e. member
+// variable) of an object.
+template <typename Class, typename FieldType>
+class FieldMatcher {
+ public:
+  FieldMatcher(FieldType Class::*field,
+               const Matcher<const FieldType&>& matcher)
+      : field_(field), matcher_(matcher) {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "is an object whose given field ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is an object whose given field ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
+    return MatchAndExplainImpl(
+        typename ::testing::internal::
+            is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
+        value, listener);
+  }
+
+ private:
+  // The first argument of MatchAndExplainImpl() is needed to help
+  // Symbian's C++ compiler choose which overload to use.  Its type is
+  // true_type iff the Field() matcher is used to match a pointer.
+  bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj,
+                           MatchResultListener* listener) const {
+    *listener << "whose given field is ";
+    return MatchPrintAndExplain(obj.*field_, matcher_, listener);
+  }
+
+  bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
+                           MatchResultListener* listener) const {
+    if (p == NULL)
+      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(false_type(), *p, listener);
+  }
+
+  const FieldType Class::*field_;
+  const Matcher<const FieldType&> matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(FieldMatcher);
+};
+
+// Implements the Property() matcher for matching a property
+// (i.e. return value of a getter method) of an object.
+template <typename Class, typename PropertyType>
+class PropertyMatcher {
+ public:
+  // The property may have a reference type, so 'const PropertyType&'
+  // may cause double references and fail to compile.  That's why we
+  // need GTEST_REFERENCE_TO_CONST, which works regardless of
+  // PropertyType being a reference or not.
+  typedef GTEST_REFERENCE_TO_CONST_(PropertyType) RefToConstProperty;
+
+  PropertyMatcher(PropertyType (Class::*property)() const,
+                  const Matcher<RefToConstProperty>& matcher)
+      : property_(property), matcher_(matcher) {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "is an object whose given property ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is an object whose given property ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(const T&value, MatchResultListener* listener) const {
+    return MatchAndExplainImpl(
+        typename ::testing::internal::
+            is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
+        value, listener);
+  }
+
+ private:
+  // The first argument of MatchAndExplainImpl() is needed to help
+  // Symbian's C++ compiler choose which overload to use.  Its type is
+  // true_type iff the Property() matcher is used to match a pointer.
+  bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj,
+                           MatchResultListener* listener) const {
+    *listener << "whose given property is ";
+    // Cannot pass the return value (for example, int) to MatchPrintAndExplain,
+    // which takes a non-const reference as argument.
+#if defined(_PREFAST_ ) && _MSC_VER == 1800
+    // Workaround bug in VC++ 2013's /analyze parser.
+    // https://connect.microsoft.com/VisualStudio/feedback/details/1106363/internal-compiler-error-with-analyze-due-to-failure-to-infer-move
+    posix::Abort();  // To make sure it is never run.
+    return false;
+#else
+    RefToConstProperty result = (obj.*property_)();
+    return MatchPrintAndExplain(result, matcher_, listener);
+#endif
+  }
+
+  bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
+                           MatchResultListener* listener) const {
+    if (p == NULL)
+      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(false_type(), *p, listener);
+  }
+
+  PropertyType (Class::*property_)() const;
+  const Matcher<RefToConstProperty> matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PropertyMatcher);
+};
+
+// Type traits specifying various features of different functors for ResultOf.
+// The default template specifies features for functor objects.
+// Functor classes have to typedef argument_type and result_type
+// to be compatible with ResultOf.
+template <typename Functor>
+struct CallableTraits {
+  typedef typename Functor::result_type ResultType;
+  typedef Functor StorageType;
+
+  static void CheckIsValid(Functor /* functor */) {}
+  template <typename T>
+  static ResultType Invoke(Functor f, T arg) { return f(arg); }
+};
+
+// Specialization for function pointers.
+template <typename ArgType, typename ResType>
+struct CallableTraits<ResType(*)(ArgType)> {
+  typedef ResType ResultType;
+  typedef ResType(*StorageType)(ArgType);
+
+  static void CheckIsValid(ResType(*f)(ArgType)) {
+    GTEST_CHECK_(f != NULL)
+        << "NULL function pointer is passed into ResultOf().";
+  }
+  template <typename T>
+  static ResType Invoke(ResType(*f)(ArgType), T arg) {
+    return (*f)(arg);
+  }
+};
+
+// Implements the ResultOf() matcher for matching a return value of a
+// unary function of an object.
+template <typename Callable>
+class ResultOfMatcher {
+ public:
+  typedef typename CallableTraits<Callable>::ResultType ResultType;
+
+  ResultOfMatcher(Callable callable, const Matcher<ResultType>& matcher)
+      : callable_(callable), matcher_(matcher) {
+    CallableTraits<Callable>::CheckIsValid(callable_);
+  }
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new Impl<T>(callable_, matcher_));
+  }
+
+ private:
+  typedef typename CallableTraits<Callable>::StorageType CallableStorageType;
+
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+   public:
+    Impl(CallableStorageType callable, const Matcher<ResultType>& matcher)
+        : callable_(callable), matcher_(matcher) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "is mapped by the given callable to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "is mapped by the given callable to a value that ";
+      matcher_.DescribeNegationTo(os);
+    }
+
+    virtual bool MatchAndExplain(T obj, MatchResultListener* listener) const {
+      *listener << "which is mapped by the given callable to ";
+      // Cannot pass the return value (for example, int) to
+      // MatchPrintAndExplain, which takes a non-const reference as argument.
+      ResultType result =
+          CallableTraits<Callable>::template Invoke<T>(callable_, obj);
+      return MatchPrintAndExplain(result, matcher_, listener);
+    }
+
+   private:
+    // Functors often define operator() as non-const method even though
+    // they are actualy 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 does't guarantee
+    // how many times the callable will be invoked.
+    mutable CallableStorageType callable_;
+    const Matcher<ResultType> matcher_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };  // class Impl
+
+  const CallableStorageType callable_;
+  const Matcher<ResultType> matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ResultOfMatcher);
+};
+
+// Implements a matcher that checks the size of an STL-style container.
+template <typename SizeMatcher>
+class SizeIsMatcher {
+ public:
+  explicit SizeIsMatcher(const SizeMatcher& size_matcher)
+       : size_matcher_(size_matcher) {
+  }
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return MakeMatcher(new Impl<Container>(size_matcher_));
+  }
+
+  template <typename Container>
+  class Impl : public MatcherInterface<Container> {
+   public:
+    typedef internal::StlContainerView<
+         GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
+    typedef typename ContainerView::type::size_type SizeType;
+    explicit Impl(const SizeMatcher& size_matcher)
+        : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "size ";
+      size_matcher_.DescribeTo(os);
+    }
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "size ";
+      size_matcher_.DescribeNegationTo(os);
+    }
+
+    virtual bool MatchAndExplain(Container container,
+                                 MatchResultListener* listener) const {
+      SizeType size = container.size();
+      StringMatchResultListener size_listener;
+      const bool result = size_matcher_.MatchAndExplain(size, &size_listener);
+      *listener
+          << "whose size " << size << (result ? " matches" : " doesn't match");
+      PrintIfNotEmpty(size_listener.str(), listener->stream());
+      return result;
+    }
+
+   private:
+    const Matcher<SizeType> size_matcher_;
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+ private:
+  const SizeMatcher size_matcher_;
+  GTEST_DISALLOW_ASSIGN_(SizeIsMatcher);
+};
+
+// Implements a matcher that checks the begin()..end() distance of an STL-style
+// container.
+template <typename DistanceMatcher>
+class BeginEndDistanceIsMatcher {
+ public:
+  explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher)
+      : distance_matcher_(distance_matcher) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return MakeMatcher(new Impl<Container>(distance_matcher_));
+  }
+
+  template <typename Container>
+  class Impl : public MatcherInterface<Container> {
+   public:
+    typedef internal::StlContainerView<
+        GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
+    typedef typename std::iterator_traits<
+        typename ContainerView::type::const_iterator>::difference_type
+        DistanceType;
+    explicit Impl(const DistanceMatcher& distance_matcher)
+        : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "distance between begin() and end() ";
+      distance_matcher_.DescribeTo(os);
+    }
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "distance between begin() and end() ";
+      distance_matcher_.DescribeNegationTo(os);
+    }
+
+    virtual bool MatchAndExplain(Container container,
+                                 MatchResultListener* listener) const {
+#if GTEST_HAS_STD_BEGIN_AND_END_
+      using std::begin;
+      using std::end;
+      DistanceType distance = std::distance(begin(container), end(container));
+#else
+      DistanceType distance = std::distance(container.begin(), container.end());
+#endif
+      StringMatchResultListener distance_listener;
+      const bool result =
+          distance_matcher_.MatchAndExplain(distance, &distance_listener);
+      *listener << "whose distance between begin() and end() " << distance
+                << (result ? " matches" : " doesn't match");
+      PrintIfNotEmpty(distance_listener.str(), listener->stream());
+      return result;
+    }
+
+   private:
+    const Matcher<DistanceType> distance_matcher_;
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+ private:
+  const DistanceMatcher distance_matcher_;
+  GTEST_DISALLOW_ASSIGN_(BeginEndDistanceIsMatcher);
+};
+
+// Implements an equality matcher for any STL-style container whose elements
+// support ==. This matcher is like Eq(), but its failure explanations provide
+// more detailed information that is useful when the container is used as a set.
+// The failure message reports elements that are in one of the operands but not
+// the other. The failure messages do not report duplicate or out-of-order
+// elements in the containers (which don't properly matter to sets, but can
+// occur if the containers are vectors or lists, for example).
+//
+// Uses the container's const_iterator, value_type, operator ==,
+// begin(), and end().
+template <typename Container>
+class ContainerEqMatcher {
+ public:
+  typedef internal::StlContainerView<Container> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+
+  // 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)) {
+    // Makes sure the user doesn't instantiate this class template
+    // with a const or reference type.
+    (void)testing::StaticAssertTypeEq<Container,
+        GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>();
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "equals ";
+    UniversalPrint(expected_, os);
+  }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "does not equal ";
+    UniversalPrint(expected_, os);
+  }
+
+  template <typename LhsContainer>
+  bool MatchAndExplain(const LhsContainer& lhs,
+                       MatchResultListener* listener) const {
+    // GTEST_REMOVE_CONST_() is needed to work around an MSVC 8.0 bug
+    // that causes LhsContainer to be a const type sometimes.
+    typedef internal::StlContainerView<GTEST_REMOVE_CONST_(LhsContainer)>
+        LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+    if (lhs_stl_container == expected_)
+      return true;
+
+    ::std::ostream* const os = listener->stream();
+    if (os != NULL) {
+      // Something is different. Check for extra values first.
+      bool printed_header = false;
+      for (typename LhsStlContainer::const_iterator it =
+               lhs_stl_container.begin();
+           it != lhs_stl_container.end(); ++it) {
+        if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) ==
+            expected_.end()) {
+          if (printed_header) {
+            *os << ", ";
+          } else {
+            *os << "which has these unexpected elements: ";
+            printed_header = true;
+          }
+          UniversalPrint(*it, os);
+        }
+      }
+
+      // Now check for missing values.
+      bool printed_header2 = false;
+      for (typename StlContainer::const_iterator it = expected_.begin();
+           it != expected_.end(); ++it) {
+        if (internal::ArrayAwareFind(
+                lhs_stl_container.begin(), lhs_stl_container.end(), *it) ==
+            lhs_stl_container.end()) {
+          if (printed_header2) {
+            *os << ", ";
+          } else {
+            *os << (printed_header ? ",\nand" : "which")
+                << " doesn't have these expected elements: ";
+            printed_header2 = true;
+          }
+          UniversalPrint(*it, os);
+        }
+      }
+    }
+
+    return false;
+  }
+
+ private:
+  const StlContainer expected_;
+
+  GTEST_DISALLOW_ASSIGN_(ContainerEqMatcher);
+};
+
+// A comparator functor that uses the < operator to compare two values.
+struct LessComparator {
+  template <typename T, typename U>
+  bool operator()(const T& lhs, const U& rhs) const { return lhs < rhs; }
+};
+
+// Implements WhenSortedBy(comparator, container_matcher).
+template <typename Comparator, typename ContainerMatcher>
+class WhenSortedByMatcher {
+ public:
+  WhenSortedByMatcher(const Comparator& comparator,
+                      const ContainerMatcher& matcher)
+      : comparator_(comparator), matcher_(matcher) {}
+
+  template <typename LhsContainer>
+  operator Matcher<LhsContainer>() const {
+    return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_));
+  }
+
+  template <typename LhsContainer>
+  class Impl : public MatcherInterface<LhsContainer> {
+   public:
+    typedef internal::StlContainerView<
+         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    typedef typename LhsView::const_reference LhsStlContainerReference;
+    // Transforms std::pair<const Key, Value> into std::pair<Key, Value>
+    // so that we can match associative containers.
+    typedef typename RemoveConstFromKey<
+        typename LhsStlContainer::value_type>::type LhsValue;
+
+    Impl(const Comparator& comparator, const ContainerMatcher& matcher)
+        : comparator_(comparator), matcher_(matcher) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "(when sorted) ";
+      matcher_.DescribeTo(os);
+    }
+
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *os << "(when sorted) ";
+      matcher_.DescribeNegationTo(os);
+    }
+
+    virtual bool MatchAndExplain(LhsContainer lhs,
+                                 MatchResultListener* listener) const {
+      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+      ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
+                                               lhs_stl_container.end());
+      ::std::sort(
+           sorted_container.begin(), sorted_container.end(), comparator_);
+
+      if (!listener->IsInterested()) {
+        // If the listener is not interested, we do not need to
+        // construct the inner explanation.
+        return matcher_.Matches(sorted_container);
+      }
+
+      *listener << "which is ";
+      UniversalPrint(sorted_container, listener->stream());
+      *listener << " when sorted";
+
+      StringMatchResultListener inner_listener;
+      const bool match = matcher_.MatchAndExplain(sorted_container,
+                                                  &inner_listener);
+      PrintIfNotEmpty(inner_listener.str(), listener->stream());
+      return match;
+    }
+
+   private:
+    const Comparator comparator_;
+    const Matcher<const ::std::vector<LhsValue>&> matcher_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
+  };
+
+ private:
+  const Comparator comparator_;
+  const ContainerMatcher matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(WhenSortedByMatcher);
+};
+
+// Implements Pointwise(tuple_matcher, rhs_container).  tuple_matcher
+// must be able to be safely cast to Matcher<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 {
+ public:
+  typedef internal::StlContainerView<RhsContainer> RhsView;
+  typedef typename RhsView::type RhsStlContainer;
+  typedef typename RhsStlContainer::value_type RhsValue;
+
+  // 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)) {
+    // Makes sure the user doesn't instantiate this class template
+    // with a const or reference type.
+    (void)testing::StaticAssertTypeEq<RhsContainer,
+        GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>();
+  }
+
+  template <typename LhsContainer>
+  operator Matcher<LhsContainer>() const {
+    return MakeMatcher(new Impl<LhsContainer>(tuple_matcher_, rhs_));
+  }
+
+  template <typename LhsContainer>
+  class Impl : public MatcherInterface<LhsContainer> {
+   public:
+    typedef internal::StlContainerView<
+         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    typedef typename LhsView::const_reference LhsStlContainerReference;
+    typedef typename LhsStlContainer::value_type LhsValue;
+    // We pass the LHS value and the RHS value to the inner matcher by
+    // 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 ::testing::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) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "contains " << rhs_.size()
+          << " values, where each value and its corresponding value in ";
+      UniversalPrinter<RhsStlContainer>::Print(rhs_, os);
+      *os << " ";
+      mono_tuple_matcher_.DescribeTo(os);
+    }
+    virtual void DescribeNegationTo(::std::ostream* os) const {
+      *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 ";
+      UniversalPrint(rhs_, os);
+      *os << " ";
+      mono_tuple_matcher_.DescribeNegationTo(os);
+    }
+
+    virtual bool MatchAndExplain(LhsContainer lhs,
+                                 MatchResultListener* listener) const {
+      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+      const size_t actual_size = lhs_stl_container.size();
+      if (actual_size != rhs_.size()) {
+        *listener << "which contains " << actual_size << " values";
+        return false;
+      }
+
+      typename LhsStlContainer::const_iterator left = lhs_stl_container.begin();
+      typename RhsStlContainer::const_iterator right = rhs_.begin();
+      for (size_t i = 0; i != actual_size; ++i, ++left, ++right) {
+        const InnerMatcherArg value_pair(*left, *right);
+
+        if (listener->IsInterested()) {
+          StringMatchResultListener inner_listener;
+          if (!mono_tuple_matcher_.MatchAndExplain(
+                  value_pair, &inner_listener)) {
+            *listener << "where the value pair (";
+            UniversalPrint(*left, listener->stream());
+            *listener << ", ";
+            UniversalPrint(*right, listener->stream());
+            *listener << ") at index #" << i << " don't match";
+            PrintIfNotEmpty(inner_listener.str(), listener->stream());
+            return false;
+          }
+        } else {
+          if (!mono_tuple_matcher_.Matches(value_pair))
+            return false;
+        }
+      }
+
+      return true;
+    }
+
+   private:
+    const Matcher<InnerMatcherArg> mono_tuple_matcher_;
+    const RhsStlContainer rhs_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+ private:
+  const TupleMatcher tuple_matcher_;
+  const RhsStlContainer rhs_;
+
+  GTEST_DISALLOW_ASSIGN_(PointwiseMatcher);
+};
+
+// Holds the logic common to ContainsMatcherImpl and EachMatcherImpl.
+template <typename Container>
+class QuantifierMatcherImpl : public MatcherInterface<Container> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::value_type Element;
+
+  template <typename InnerMatcher>
+  explicit QuantifierMatcherImpl(InnerMatcher inner_matcher)
+      : inner_matcher_(
+           testing::SafeMatcherCast<const Element&>(inner_matcher)) {}
+
+  // Checks whether:
+  // * All elements in the container match, if all_elements_should_match.
+  // * Any element in the container matches, if !all_elements_should_match.
+  bool MatchAndExplainImpl(bool all_elements_should_match,
+                           Container container,
+                           MatchResultListener* listener) const {
+    StlContainerReference stl_container = View::ConstReference(container);
+    size_t i = 0;
+    for (typename StlContainer::const_iterator it = stl_container.begin();
+         it != stl_container.end(); ++it, ++i) {
+      StringMatchResultListener inner_listener;
+      const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);
+
+      if (matches != all_elements_should_match) {
+        *listener << "whose element #" << i
+                  << (matches ? " matches" : " doesn't match");
+        PrintIfNotEmpty(inner_listener.str(), listener->stream());
+        return !all_elements_should_match;
+      }
+    }
+    return all_elements_should_match;
+  }
+
+ protected:
+  const Matcher<const Element&> inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(QuantifierMatcherImpl);
+};
+
+// Implements Contains(element_matcher) for the given argument type Container.
+// Symmetric to EachMatcherImpl.
+template <typename Container>
+class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> {
+ public:
+  template <typename InnerMatcher>
+  explicit ContainsMatcherImpl(InnerMatcher inner_matcher)
+      : QuantifierMatcherImpl<Container>(inner_matcher) {}
+
+  // Describes what this matcher does.
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "contains at least one element that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't contain any element that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  virtual bool MatchAndExplain(Container container,
+                               MatchResultListener* listener) const {
+    return this->MatchAndExplainImpl(false, container, listener);
+  }
+
+ private:
+  GTEST_DISALLOW_ASSIGN_(ContainsMatcherImpl);
+};
+
+// Implements Each(element_matcher) for the given argument type Container.
+// Symmetric to ContainsMatcherImpl.
+template <typename Container>
+class EachMatcherImpl : public QuantifierMatcherImpl<Container> {
+ public:
+  template <typename InnerMatcher>
+  explicit EachMatcherImpl(InnerMatcher inner_matcher)
+      : QuantifierMatcherImpl<Container>(inner_matcher) {}
+
+  // Describes what this matcher does.
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "only contains elements that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "contains some element that ";
+    this->inner_matcher_.DescribeNegationTo(os);
+  }
+
+  virtual bool MatchAndExplain(Container container,
+                               MatchResultListener* listener) const {
+    return this->MatchAndExplainImpl(true, container, listener);
+  }
+
+ private:
+  GTEST_DISALLOW_ASSIGN_(EachMatcherImpl);
+};
+
+// Implements polymorphic Contains(element_matcher).
+template <typename M>
+class ContainsMatcher {
+ public:
+  explicit ContainsMatcher(M m) : inner_matcher_(m) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return MakeMatcher(new ContainsMatcherImpl<Container>(inner_matcher_));
+  }
+
+ private:
+  const M inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ContainsMatcher);
+};
+
+// Implements polymorphic Each(element_matcher).
+template <typename M>
+class EachMatcher {
+ public:
+  explicit EachMatcher(M m) : inner_matcher_(m) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return MakeMatcher(new EachMatcherImpl<Container>(inner_matcher_));
+  }
+
+ private:
+  const M inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(EachMatcher);
+};
+
+// 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
+// std::map that contains at least one element whose key is >= 5.
+template <typename PairType>
+class KeyMatcherImpl : public MatcherInterface<PairType> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
+  typedef typename RawPairType::first_type KeyType;
+
+  template <typename InnerMatcher>
+  explicit KeyMatcherImpl(InnerMatcher inner_matcher)
+      : inner_matcher_(
+          testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {
+  }
+
+  // Returns true iff 'key_value.first' (the key) matches the inner matcher.
+  virtual bool MatchAndExplain(PairType key_value,
+                               MatchResultListener* listener) const {
+    StringMatchResultListener inner_listener;
+    const bool match = inner_matcher_.MatchAndExplain(key_value.first,
+                                                      &inner_listener);
+    const internal::string explanation = inner_listener.str();
+    if (explanation != "") {
+      *listener << "whose first field is a value " << explanation;
+    }
+    return match;
+  }
+
+  // Describes what this matcher does.
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "has a key that ";
+    inner_matcher_.DescribeTo(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't have a key that ";
+    inner_matcher_.DescribeTo(os);
+  }
+
+ private:
+  const Matcher<const KeyType&> inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(KeyMatcherImpl);
+};
+
+// Implements polymorphic Key(matcher_for_key).
+template <typename M>
+class KeyMatcher {
+ public:
+  explicit KeyMatcher(M m) : matcher_for_key_(m) {}
+
+  template <typename PairType>
+  operator Matcher<PairType>() const {
+    return MakeMatcher(new KeyMatcherImpl<PairType>(matcher_for_key_));
+  }
+
+ private:
+  const M matcher_for_key_;
+
+  GTEST_DISALLOW_ASSIGN_(KeyMatcher);
+};
+
+// Implements Pair(first_matcher, second_matcher) for the given argument pair
+// type with its two matchers. See Pair() function below.
+template <typename PairType>
+class PairMatcherImpl : public MatcherInterface<PairType> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
+  typedef typename RawPairType::first_type FirstType;
+  typedef typename RawPairType::second_type SecondType;
+
+  template <typename FirstMatcher, typename SecondMatcher>
+  PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher)
+      : first_matcher_(
+            testing::SafeMatcherCast<const FirstType&>(first_matcher)),
+        second_matcher_(
+            testing::SafeMatcherCast<const SecondType&>(second_matcher)) {
+  }
+
+  // Describes what this matcher does.
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "has a first field that ";
+    first_matcher_.DescribeTo(os);
+    *os << ", and has a second field that ";
+    second_matcher_.DescribeTo(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "has a first field that ";
+    first_matcher_.DescribeNegationTo(os);
+    *os << ", or has a second field that ";
+    second_matcher_.DescribeNegationTo(os);
+  }
+
+  // Returns true iff 'a_pair.first' matches first_matcher and 'a_pair.second'
+  // matches second_matcher.
+  virtual bool MatchAndExplain(PairType a_pair,
+                               MatchResultListener* listener) const {
+    if (!listener->IsInterested()) {
+      // If the listener is not interested, we don't need to construct the
+      // explanation.
+      return first_matcher_.Matches(a_pair.first) &&
+             second_matcher_.Matches(a_pair.second);
+    }
+    StringMatchResultListener first_inner_listener;
+    if (!first_matcher_.MatchAndExplain(a_pair.first,
+                                        &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(a_pair.second,
+                                         &second_inner_listener)) {
+      *listener << "whose second field does not match";
+      PrintIfNotEmpty(second_inner_listener.str(), listener->stream());
+      return false;
+    }
+    ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(),
+                   listener);
+    return true;
+  }
+
+ private:
+  void ExplainSuccess(const internal::string& first_explanation,
+                      const internal::string& second_explanation,
+                      MatchResultListener* listener) const {
+    *listener << "whose both fields match";
+    if (first_explanation != "") {
+      *listener << ", where the first field is a value " << first_explanation;
+    }
+    if (second_explanation != "") {
+      *listener << ", ";
+      if (first_explanation != "") {
+        *listener << "and ";
+      } else {
+        *listener << "where ";
+      }
+      *listener << "the second field is a value " << second_explanation;
+    }
+  }
+
+  const Matcher<const FirstType&> first_matcher_;
+  const Matcher<const SecondType&> second_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PairMatcherImpl);
+};
+
+// Implements polymorphic Pair(first_matcher, second_matcher).
+template <typename FirstMatcher, typename SecondMatcher>
+class PairMatcher {
+ public:
+  PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher)
+      : first_matcher_(first_matcher), second_matcher_(second_matcher) {}
+
+  template <typename PairType>
+  operator Matcher<PairType> () const {
+    return MakeMatcher(
+        new PairMatcherImpl<PairType>(
+            first_matcher_, second_matcher_));
+  }
+
+ private:
+  const FirstMatcher first_matcher_;
+  const SecondMatcher second_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PairMatcher);
+};
+
+// Implements ElementsAre() and ElementsAreArray().
+template <typename Container>
+class ElementsAreMatcherImpl : public MatcherInterface<Container> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef internal::StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::value_type Element;
+
+  // Constructs the matcher from a sequence of element values or
+  // element matchers.
+  template <typename InputIter>
+  ElementsAreMatcherImpl(InputIter first, InputIter last) {
+    while (first != last) {
+      matchers_.push_back(MatcherCast<const Element&>(*first++));
+    }
+  }
+
+  // Describes what this matcher does.
+  virtual void DescribeTo(::std::ostream* os) const {
+    if (count() == 0) {
+      *os << "is empty";
+    } else if (count() == 1) {
+      *os << "has 1 element that ";
+      matchers_[0].DescribeTo(os);
+    } else {
+      *os << "has " << Elements(count()) << " where\n";
+      for (size_t i = 0; i != count(); ++i) {
+        *os << "element #" << i << " ";
+        matchers_[i].DescribeTo(os);
+        if (i + 1 < count()) {
+          *os << ",\n";
+        }
+      }
+    }
+  }
+
+  // Describes what the negation of this matcher does.
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    if (count() == 0) {
+      *os << "isn't empty";
+      return;
+    }
+
+    *os << "doesn't have " << Elements(count()) << ", or\n";
+    for (size_t i = 0; i != count(); ++i) {
+      *os << "element #" << i << " ";
+      matchers_[i].DescribeNegationTo(os);
+      if (i + 1 < count()) {
+        *os << ", or\n";
+      }
+    }
+  }
+
+  virtual bool MatchAndExplain(Container container,
+                               MatchResultListener* listener) const {
+    // 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<internal::string> explanations(count());
+    StlContainerReference stl_container = View::ConstReference(container);
+    typename StlContainer::const_iterator it = stl_container.begin();
+    size_t exam_pos = 0;
+    bool mismatch_found = false;  // Have we found a mismatched element yet?
+
+    // Go through the elements and matchers in pairs, until we reach
+    // the end of either the elements or the matchers, or until we find a
+    // mismatch.
+    for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) {
+      bool match;  // Does the current element match the current matcher?
+      if (listener_interested) {
+        StringMatchResultListener s;
+        match = matchers_[exam_pos].MatchAndExplain(*it, &s);
+        explanations[exam_pos] = s.str();
+      } else {
+        match = matchers_[exam_pos].Matches(*it);
+      }
+
+      if (!match) {
+        mismatch_found = true;
+        break;
+      }
+    }
+    // If mismatch_found is true, 'exam_pos' is the index of the mismatch.
+
+    // Find how many elements the actual container has.  We avoid
+    // calling size() s.t. this code works for stream-like "containers"
+    // that don't define size().
+    size_t actual_count = exam_pos;
+    for (; it != stl_container.end(); ++it) {
+      ++actual_count;
+    }
+
+    if (actual_count != count()) {
+      // 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 (listener_interested && (actual_count != 0)) {
+        *listener << "which has " << Elements(actual_count);
+      }
+      return false;
+    }
+
+    if (mismatch_found) {
+      // The element count matches, but the exam_pos-th element doesn't match.
+      if (listener_interested) {
+        *listener << "whose element #" << exam_pos << " doesn't match";
+        PrintIfNotEmpty(explanations[exam_pos], listener->stream());
+      }
+      return false;
+    }
+
+    // Every element matches its expectation.  We need to explain why
+    // (the obvious ones can be skipped).
+    if (listener_interested) {
+      bool reason_printed = false;
+      for (size_t i = 0; i != count(); ++i) {
+        const internal::string& s = explanations[i];
+        if (!s.empty()) {
+          if (reason_printed) {
+            *listener << ",\nand ";
+          }
+          *listener << "whose element #" << i << " matches, " << s;
+          reason_printed = true;
+        }
+      }
+    }
+    return true;
+  }
+
+ private:
+  static Message Elements(size_t count) {
+    return Message() << count << (count == 1 ? " element" : " elements");
+  }
+
+  size_t count() const { return matchers_.size(); }
+
+  ::std::vector<Matcher<const Element&> > matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcherImpl);
+};
+
+// Connectivity matrix of (elements X matchers), in element-major order.
+// Initially, there are no edges.
+// Use NextGraph() to iterate over all possible edge configurations.
+// Use Randomize() to generate a random edge configuration.
+class GTEST_API_ MatchMatrix {
+ public:
+  MatchMatrix(size_t num_elements, size_t num_matchers)
+      : num_elements_(num_elements),
+        num_matchers_(num_matchers),
+        matched_(num_elements_* num_matchers_, 0) {
+  }
+
+  size_t LhsSize() const { return num_elements_; }
+  size_t RhsSize() const { return num_matchers_; }
+  bool HasEdge(size_t ilhs, size_t irhs) const {
+    return matched_[SpaceIndex(ilhs, irhs)] == 1;
+  }
+  void SetEdge(size_t ilhs, size_t irhs, bool b) {
+    matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0;
+  }
+
+  // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number,
+  // adds 1 to that number; returns false if incrementing the graph left it
+  // empty.
+  bool NextGraph();
+
+  void Randomize();
+
+  string DebugString() const;
+
+ private:
+  size_t SpaceIndex(size_t ilhs, size_t irhs) const {
+    return ilhs * num_matchers_ + irhs;
+  }
+
+  size_t num_elements_;
+  size_t num_matchers_;
+
+  // Each element is a char interpreted as bool. They are stored as a
+  // flattened array in lhs-major order, use 'SpaceIndex()' to translate
+  // a (ilhs, irhs) matrix coordinate into an offset.
+  ::std::vector<char> matched_;
+};
+
+typedef ::std::pair<size_t, size_t> ElementMatcherPair;
+typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;
+
+// Returns a maximum bipartite matching for the specified graph 'g'.
+// The matching is represented as a vector of {element, matcher} pairs.
+GTEST_API_ ElementMatcherPairs
+FindMaxBipartiteMatching(const MatchMatrix& g);
+
+GTEST_API_ bool FindPairing(const MatchMatrix& matrix,
+                            MatchResultListener* listener);
+
+// 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:
+  // 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).
+  typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec;
+
+  // Describes this UnorderedElementsAre matcher.
+  void DescribeToImpl(::std::ostream* os) const;
+
+  // Describes the negation of this UnorderedElementsAre matcher.
+  void DescribeNegationToImpl(::std::ostream* os) const;
+
+  bool VerifyAllElementsAndMatchersAreMatched(
+      const ::std::vector<string>& element_printouts,
+      const MatchMatrix& matrix,
+      MatchResultListener* listener) const;
+
+  MatcherDescriberVec& matcher_describers() {
+    return matcher_describers_;
+  }
+
+  static Message Elements(size_t n) {
+    return Message() << n << " element" << (n == 1 ? "" : "s");
+  }
+
+ private:
+  MatcherDescriberVec matcher_describers_;
+
+  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcherImplBase);
+};
+
+// Implements unordered ElementsAre and unordered ElementsAreArray.
+template <typename Container>
+class UnorderedElementsAreMatcherImpl
+    : public MatcherInterface<Container>,
+      public UnorderedElementsAreMatcherImplBase {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef internal::StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::const_iterator StlContainerConstIterator;
+  typedef typename StlContainer::value_type Element;
+
+  // Constructs the matcher from a sequence of element values or
+  // element matchers.
+  template <typename InputIter>
+  UnorderedElementsAreMatcherImpl(InputIter first, InputIter last) {
+    for (; first != last; ++first) {
+      matchers_.push_back(MatcherCast<const Element&>(*first));
+      matcher_describers().push_back(matchers_.back().GetDescriber());
+    }
+  }
+
+  // Describes what this matcher does.
+  virtual void DescribeTo(::std::ostream* os) const {
+    return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os);
+  }
+
+  virtual bool MatchAndExplain(Container container,
+                               MatchResultListener* listener) const {
+    StlContainerReference stl_container = View::ConstReference(container);
+    ::std::vector<string> element_printouts;
+    MatchMatrix matrix = AnalyzeElements(stl_container.begin(),
+                                         stl_container.end(),
+                                         &element_printouts,
+                                         listener);
+
+    const size_t actual_count = matrix.LhsSize();
+    if (actual_count == 0 && matchers_.empty()) {
+      return true;
+    }
+    if (actual_count != matchers_.size()) {
+      // 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 (actual_count != 0 && listener->IsInterested()) {
+        *listener << "which has " << Elements(actual_count);
+      }
+      return false;
+    }
+
+    return VerifyAllElementsAndMatchersAreMatched(element_printouts,
+                                                  matrix, listener) &&
+           FindPairing(matrix, listener);
+  }
+
+ private:
+  typedef ::std::vector<Matcher<const Element&> > MatcherVec;
+
+  template <typename ElementIter>
+  MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last,
+                              ::std::vector<string>* element_printouts,
+                              MatchResultListener* listener) const {
+    element_printouts->clear();
+    ::std::vector<char> did_match;
+    size_t num_elements = 0;
+    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(Matches(matchers_[irhs])(*elem_first));
+      }
+    }
+
+    MatchMatrix matrix(num_elements, matchers_.size());
+    ::std::vector<char>::const_iterator did_match_iter = did_match.begin();
+    for (size_t ilhs = 0; ilhs != num_elements; ++ilhs) {
+      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
+        matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0);
+      }
+    }
+    return matrix;
+  }
+
+  MatcherVec matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcherImpl);
+};
+
+// Functor for use in TransformTuple.
+// Performs MatcherCast<Target> on an input argument of any type.
+template <typename Target>
+struct CastAndAppendTransform {
+  template <typename Arg>
+  Matcher<Target> operator()(const Arg& a) const {
+    return MatcherCast<Target>(a);
+  }
+};
+
+// Implements UnorderedElementsAre.
+template <typename MatcherTuple>
+class UnorderedElementsAreMatcher {
+ public:
+  explicit UnorderedElementsAreMatcher(const MatcherTuple& args)
+      : matchers_(args) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    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(::testing::tuple_size<MatcherTuple>::value);
+    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
+                         ::std::back_inserter(matchers));
+    return MakeMatcher(new UnorderedElementsAreMatcherImpl<Container>(
+                           matchers.begin(), matchers.end()));
+  }
+
+ private:
+  const MatcherTuple matchers_;
+  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcher);
+};
+
+// Implements ElementsAre.
+template <typename MatcherTuple>
+class ElementsAreMatcher {
+ public:
+  explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    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(::testing::tuple_size<MatcherTuple>::value);
+    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
+                         ::std::back_inserter(matchers));
+    return MakeMatcher(new ElementsAreMatcherImpl<Container>(
+                           matchers.begin(), matchers.end()));
+  }
+
+ private:
+  const MatcherTuple matchers_;
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher);
+};
+
+// Implements UnorderedElementsAreArray().
+template <typename T>
+class UnorderedElementsAreArrayMatcher {
+ public:
+  UnorderedElementsAreArrayMatcher() {}
+
+  template <typename Iter>
+  UnorderedElementsAreArrayMatcher(Iter first, Iter last)
+      : matchers_(first, last) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return MakeMatcher(
+        new UnorderedElementsAreMatcherImpl<Container>(matchers_.begin(),
+                                                       matchers_.end()));
+  }
+
+ private:
+  ::std::vector<T> matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreArrayMatcher);
+};
+
+// Implements ElementsAreArray().
+template <typename T>
+class ElementsAreArrayMatcher {
+ public:
+  template <typename Iter>
+  ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return MakeMatcher(new ElementsAreMatcherImpl<Container>(
+        matchers_.begin(), matchers_.end()));
+  }
+
+ private:
+  const ::std::vector<T> matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(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 iff tm
+// matches tuple (x, second).  Useful for implementing
+// UnorderedPointwise() in terms of UnorderedElementsAreArray().
+//
+// BoundSecondMatcher is copyable and assignable, as we need to put
+// instances of this class in a vector when implementing
+// UnorderedPointwise().
+template <typename Tuple2Matcher, typename Second>
+class BoundSecondMatcher {
+ public:
+  BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second)
+      : tuple2_matcher_(tm), second_value_(second) {}
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_));
+  }
+
+  // We have to define this for UnorderedPointwise() to compile in
+  // C++98 mode, as it puts BoundSecondMatcher instances in a vector,
+  // which requires the elements to be assignable in C++98.  The
+  // compiler cannot generate the operator= for us, as Tuple2Matcher
+  // and Second may not be assignable.
+  //
+  // However, this should never be called, so the implementation just
+  // need to assert.
+  void operator=(const BoundSecondMatcher& /*rhs*/) {
+    GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned.";
+  }
+
+ private:
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+   public:
+    typedef ::testing::tuple<T, Second> ArgTuple;
+
+    Impl(const Tuple2Matcher& tm, const Second& second)
+        : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)),
+          second_value_(second) {}
+
+    virtual void DescribeTo(::std::ostream* os) const {
+      *os << "and ";
+      UniversalPrint(second_value_, os);
+      *os << " ";
+      mono_tuple2_matcher_.DescribeTo(os);
+    }
+
+    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
+      return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_),
+                                                  listener);
+    }
+
+   private:
+    const Matcher<const ArgTuple&> mono_tuple2_matcher_;
+    const Second second_value_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
+  };
+
+  const Tuple2Matcher tuple2_matcher_;
+  const Second second_value_;
+};
+
+// Given a 2-tuple matcher tm and a value second,
+// MatcherBindSecond(tm, second) returns a matcher that matches a
+// value x iff 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) {
+  return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second);
+}
+
+// Returns the description for a matcher defined using the MATCHER*()
+// macro where the user-supplied description string is "", if
+// '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_ string FormatMatcherDescription(bool negation,
+                                           const char* matcher_name,
+                                           const Strings& param_values);
+
+}  // namespace internal
+
+// ElementsAreArray(first, last)
+// ElementsAreArray(pointer, count)
+// ElementsAreArray(array)
+// ElementsAreArray(container)
+// ElementsAreArray({ e1, e2, ..., en })
+//
+// The ElementsAreArray() functions are like ElementsAre(...), except
+// that they are given a homogeneous sequence rather than taking each
+// element as a function argument. The sequence can be specified as an
+// array, a pointer and count, a vector, an initializer list, or an
+// STL iterator range. In each of these cases, the underlying sequence
+// can be either a sequence of values or a sequence of matchers.
+//
+// All forms of ElementsAreArray() make a copy of the input matcher sequence.
+
+template <typename Iter>
+inline internal::ElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+ElementsAreArray(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::ElementsAreArrayMatcher<T>(first, last);
+}
+
+template <typename T>
+inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
+    const T* pointer, size_t count) {
+  return ElementsAreArray(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
+    const T (&array)[N]) {
+  return ElementsAreArray(array, N);
+}
+
+template <typename Container>
+inline internal::ElementsAreArrayMatcher<typename Container::value_type>
+ElementsAreArray(const Container& container) {
+  return ElementsAreArray(container.begin(), container.end());
+}
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+template <typename T>
+inline internal::ElementsAreArrayMatcher<T>
+ElementsAreArray(::std::initializer_list<T> xs) {
+  return ElementsAreArray(xs.begin(), xs.end());
+}
+#endif
+
+// UnorderedElementsAreArray(first, last)
+// UnorderedElementsAreArray(pointer, count)
+// UnorderedElementsAreArray(array)
+// UnorderedElementsAreArray(container)
+// UnorderedElementsAreArray({ e1, e2, ..., en })
+//
+// The UnorderedElementsAreArray() functions are like
+// ElementsAreArray(...), but allow matching the elements in any order.
+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>(first, last);
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T>
+UnorderedElementsAreArray(const T* pointer, size_t count) {
+  return UnorderedElementsAreArray(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::UnorderedElementsAreArrayMatcher<T>
+UnorderedElementsAreArray(const T (&array)[N]) {
+  return UnorderedElementsAreArray(array, N);
+}
+
+template <typename Container>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename Container::value_type>
+UnorderedElementsAreArray(const Container& container) {
+  return UnorderedElementsAreArray(container.begin(), container.end());
+}
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T>
+UnorderedElementsAreArray(::std::initializer_list<T> xs) {
+  return UnorderedElementsAreArray(xs.begin(), xs.end());
+}
+#endif
+
+// _ is a matcher that matches anything of any type.
+//
+// This definition is fine as:
+//
+//   1. The C++ standard permits using the name _ in a namespace that
+//      is not the global namespace or ::std.
+//   2. The AnythingMatcher class has no data member or constructor,
+//      so it's OK to create global variables of this type.
+//   3. c-style has approved of using _ in this case.
+const internal::AnythingMatcher _ = {};
+// Creates a matcher that matches any value of the given type T.
+template <typename T>
+inline Matcher<T> A() { return MakeMatcher(new internal::AnyMatcherImpl<T>()); }
+
+// Creates a matcher that matches any value of the given type T.
+template <typename T>
+inline Matcher<T> An() { return A<T>(); }
+
+// 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);
+}
+
+// Creates a polymorphic matcher that matches any NULL pointer.
+inline PolymorphicMatcher<internal::IsNullMatcher > IsNull() {
+  return MakePolymorphicMatcher(internal::IsNullMatcher());
+}
+
+// Creates a polymorphic matcher that matches any non-NULL pointer.
+// This is convenient as Not(NULL) doesn't compile (the compiler
+// thinks that that expression is comparing a pointer with an integer).
+inline PolymorphicMatcher<internal::NotNullMatcher > NotNull() {
+  return MakePolymorphicMatcher(internal::NotNullMatcher());
+}
+
+// Creates a polymorphic matcher that matches any argument that
+// references variable x.
+template <typename T>
+inline internal::RefMatcher<T&> Ref(T& x) {  // NOLINT
+  return internal::RefMatcher<T&>(x);
+}
+
+// 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) {
+  return internal::FloatingEqMatcher<double>(rhs, false);
+}
+
+// Creates a matcher that matches any double argument approximately
+// equal to rhs, including NaN values when rhs is NaN.
+inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) {
+  return internal::FloatingEqMatcher<double>(rhs, true);
+}
+
+// Creates a matcher that matches any double argument approximately equal to
+// rhs, up to the specified max absolute error bound, where two NANs are
+// considered unequal.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<double> DoubleNear(
+    double rhs, double max_abs_error) {
+  return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);
+}
+
+// Creates a matcher that matches any double argument approximately equal to
+// rhs, up to the specified max absolute error bound, including NaN values when
+// rhs is NaN.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear(
+    double rhs, double max_abs_error) {
+  return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error);
+}
+
+// Creates a matcher that matches any float argument approximately
+// equal to rhs, where two NANs are considered unequal.
+inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {
+  return internal::FloatingEqMatcher<float>(rhs, false);
+}
+
+// Creates a matcher that matches any float argument approximately
+// equal to rhs, including NaN values when rhs is NaN.
+inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
+  return internal::FloatingEqMatcher<float>(rhs, true);
+}
+
+// Creates a matcher that matches any float argument approximately equal to
+// rhs, up to the specified max absolute error bound, where two NANs are
+// considered unequal.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<float> FloatNear(
+    float rhs, float max_abs_error) {
+  return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);
+}
+
+// Creates a matcher that matches any float argument approximately equal to
+// rhs, up to the specified max absolute error bound, including NaN values when
+// rhs is NaN.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear(
+    float rhs, float max_abs_error) {
+  return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error);
+}
+
+// Creates a matcher that matches a pointer (raw or smart) that points
+// to a value that matches inner_matcher.
+template <typename InnerMatcher>
+inline internal::PointeeMatcher<InnerMatcher> Pointee(
+    const InnerMatcher& inner_matcher) {
+  return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
+}
+
+// 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.
+// If To is a pointer and the cast fails, the inner matcher will receive NULL.
+// If To is a reference and the cast fails, this matcher returns false
+// immediately.
+template <typename To>
+inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To> >
+WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
+  return MakePolymorphicMatcher(
+      internal::WhenDynamicCastToMatcher<To>(inner_matcher));
+}
+
+// Creates a matcher that matches an object whose given field matches
+// 'matcher'.  For example,
+//   Field(&Foo::number, Ge(5))
+// matches a Foo object x iff x.number >= 5.
+template <typename Class, typename FieldType, typename FieldMatcher>
+inline PolymorphicMatcher<
+  internal::FieldMatcher<Class, FieldType> > Field(
+    FieldType Class::*field, const FieldMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::FieldMatcher<Class, FieldType>(
+          field, MatcherCast<const FieldType&>(matcher)));
+  // The call to MatcherCast() is required for supporting inner
+  // matchers of compatible types.  For example, it allows
+  //   Field(&Foo::bar, m)
+  // to compile where bar is an int32 and m is a matcher for int64.
+}
+
+// Creates a matcher that matches an object whose given property
+// matches 'matcher'.  For example,
+//   Property(&Foo::str, StartsWith("hi"))
+// matches a Foo object x iff x.str() starts with "hi".
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<
+  internal::PropertyMatcher<Class, PropertyType> > Property(
+    PropertyType (Class::*property)() const, const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType>(
+          property,
+          MatcherCast<GTEST_REFERENCE_TO_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.
+}
+
+// Creates a matcher that matches an object iff the result of applying
+// a callable to x matches 'matcher'.
+// For example,
+//   ResultOf(f, StartsWith("hi"))
+// matches a Foo object x iff f(x) starts with "hi".
+// callable parameter can be a function, function pointer, or a functor.
+// Callable has to satisfy the following conditions:
+//   * 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.
+//   * If it is a function object, it has to define type result_type.
+//     We recommend deriving your functor classes from std::unary_function.
+template <typename Callable, typename ResultOfMatcher>
+internal::ResultOfMatcher<Callable> ResultOf(
+    Callable callable, const ResultOfMatcher& matcher) {
+  return internal::ResultOfMatcher<Callable>(
+          callable,
+          MatcherCast<typename internal::CallableTraits<Callable>::ResultType>(
+              matcher));
+  // The call to MatcherCast() is required for supporting inner
+  // matchers of compatible types.  For example, it allows
+  //   ResultOf(Function, m)
+  // to compile where Function() returns an int32 and m is a matcher for int64.
+}
+
+// String matchers.
+
+// Matches a string equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
+    StrEq(const internal::string& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
+      str, true, true));
+}
+
+// Matches a string not equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
+    StrNe(const internal::string& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
+      str, false, true));
+}
+
+// Matches a string equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
+    StrCaseEq(const internal::string& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
+      str, true, false));
+}
+
+// Matches a string not equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
+    StrCaseNe(const internal::string& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
+      str, false, false));
+}
+
+// Creates a matcher that matches any string, std::string, or C string
+// that contains the given substring.
+inline PolymorphicMatcher<internal::HasSubstrMatcher<internal::string> >
+    HasSubstr(const internal::string& substring) {
+  return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::string>(
+      substring));
+}
+
+// Matches a string that starts with 'prefix' (case-sensitive).
+inline PolymorphicMatcher<internal::StartsWithMatcher<internal::string> >
+    StartsWith(const internal::string& prefix) {
+  return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::string>(
+      prefix));
+}
+
+// Matches a string that ends with 'suffix' (case-sensitive).
+inline PolymorphicMatcher<internal::EndsWithMatcher<internal::string> >
+    EndsWith(const internal::string& suffix) {
+  return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::string>(
+      suffix));
+}
+
+// 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));
+}
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
+    const internal::string& regex) {
+  return MatchesRegex(new internal::RE(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));
+}
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
+    const internal::string& regex) {
+  return ContainsRegex(new internal::RE(regex));
+}
+
+#if GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING
+// Wide string matchers.
+
+// Matches a string equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
+    StrEq(const internal::wstring& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
+      str, true, true));
+}
+
+// Matches a string not equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
+    StrNe(const internal::wstring& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
+      str, false, true));
+}
+
+// Matches a string equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
+    StrCaseEq(const internal::wstring& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
+      str, true, false));
+}
+
+// Matches a string not equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
+    StrCaseNe(const internal::wstring& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
+      str, false, false));
+}
+
+// Creates a matcher that matches any wstring, std::wstring, or C wide string
+// that contains the given substring.
+inline PolymorphicMatcher<internal::HasSubstrMatcher<internal::wstring> >
+    HasSubstr(const internal::wstring& substring) {
+  return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::wstring>(
+      substring));
+}
+
+// Matches a string that starts with 'prefix' (case-sensitive).
+inline PolymorphicMatcher<internal::StartsWithMatcher<internal::wstring> >
+    StartsWith(const internal::wstring& prefix) {
+  return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::wstring>(
+      prefix));
+}
+
+// Matches a string that ends with 'suffix' (case-sensitive).
+inline PolymorphicMatcher<internal::EndsWithMatcher<internal::wstring> >
+    EndsWith(const internal::wstring& suffix) {
+  return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::wstring>(
+      suffix));
+}
+
+#endif  // GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field == the second field.
+inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field >= the second field.
+inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field > the second field.
+inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field <= the second field.
+inline internal::Le2Matcher Le() { return internal::Le2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field < the second field.
+inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field != the second field.
+inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }
+
+// Creates a matcher that matches any value of type T that m doesn't
+// match.
+template <typename InnerMatcher>
+inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) {
+  return internal::NotMatcher<InnerMatcher>(m);
+}
+
+// Returns a matcher that matches anything that satisfies the given
+// predicate.  The predicate can be any unary function or functor
+// whose return type can be implicitly converted to bool.
+template <typename Predicate>
+inline PolymorphicMatcher<internal::TrulyMatcher<Predicate> >
+Truly(Predicate pred) {
+  return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
+}
+
+// Returns a matcher that matches the container size. The container must
+// support both size() and size_type which all STL-like containers provide.
+// Note that the parameter 'size' can be a value of type size_type as well as
+// matcher. For instance:
+//   EXPECT_THAT(container, SizeIs(2));     // Checks container has 2 elements.
+//   EXPECT_THAT(container, SizeIs(Le(2));  // Checks container has at most 2.
+template <typename SizeMatcher>
+inline internal::SizeIsMatcher<SizeMatcher>
+SizeIs(const SizeMatcher& size_matcher) {
+  return internal::SizeIsMatcher<SizeMatcher>(size_matcher);
+}
+
+// Returns a matcher that matches the distance between the container's begin()
+// iterator and its end() iterator, i.e. the size of the container. This matcher
+// can be used instead of SizeIs with containers such as std::forward_list which
+// do not implement size(). The container must provide const_iterator (with
+// valid iterator_traits), begin() and end().
+template <typename DistanceMatcher>
+inline internal::BeginEndDistanceIsMatcher<DistanceMatcher>
+BeginEndDistanceIs(const DistanceMatcher& distance_matcher) {
+  return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher);
+}
+
+// Returns a matcher that matches an equal container.
+// This matcher behaves like Eq(), but in the event of mismatch lists the
+// 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<  // NOLINT
+                            GTEST_REMOVE_CONST_(Container)> >
+    ContainerEq(const Container& rhs) {
+  // This following line is for working around a bug in MSVC 8.0,
+  // which causes Container to be a const type sometimes.
+  typedef GTEST_REMOVE_CONST_(Container) RawContainer;
+  return MakePolymorphicMatcher(
+      internal::ContainerEqMatcher<RawContainer>(rhs));
+}
+
+// Returns a matcher that matches a container that, when sorted using
+// the given comparator, matches container_matcher.
+template <typename Comparator, typename ContainerMatcher>
+inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher>
+WhenSortedBy(const Comparator& comparator,
+             const ContainerMatcher& container_matcher) {
+  return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(
+      comparator, container_matcher);
+}
+
+// Returns a matcher that matches a container that, when sorted using
+// the < operator, matches container_matcher.
+template <typename ContainerMatcher>
+inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>
+WhenSorted(const ContainerMatcher& container_matcher) {
+  return
+      internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>(
+          internal::LessComparator(), 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<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,
+                                  GTEST_REMOVE_CONST_(Container)>
+Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
+  // This following line is for working around a bug in MSVC 8.0,
+  // which causes Container to be a const type sometimes (e.g. when
+  // rhs is a const int[])..
+  typedef GTEST_REMOVE_CONST_(Container) RawContainer;
+  return internal::PointwiseMatcher<TupleMatcher, RawContainer>(
+      tuple_matcher, rhs);
+}
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+
+// Supports the Pointwise(m, {a, b, c}) syntax.
+template <typename TupleMatcher, typename T>
+inline internal::PointwiseMatcher<TupleMatcher, std::vector<T> > Pointwise(
+    const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {
+  return Pointwise(tuple_matcher, std::vector<T>(rhs));
+}
+
+#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
+
+// UnorderedPointwise(pair_matcher, rhs) matches an STL-style
+// container or a native array that contains the same number of
+// 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<tuple<const T1&, const T2&> >, where T1 and T2 are
+// the types of elements in the LHS container and the RHS container
+// respectively.
+//
+// This is like Pointwise(pair_matcher, rhs), except that the element
+// order doesn't matter.
+template <typename Tuple2Matcher, typename RhsContainer>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename internal::BoundSecondMatcher<
+        Tuple2Matcher, typename internal::StlContainerView<GTEST_REMOVE_CONST_(
+                           RhsContainer)>::type::value_type> >
+UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
+                   const RhsContainer& rhs_container) {
+  // This following line is for working around a bug in MSVC 8.0,
+  // which causes RhsContainer to be a const type sometimes (e.g. when
+  // rhs_container is a const int[]).
+  typedef GTEST_REMOVE_CONST_(RhsContainer) RawRhsContainer;
+
+  // 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<RawRhsContainer> RhsView;
+  typedef typename RhsView::type RhsStlContainer;
+  typedef typename RhsStlContainer::value_type Second;
+  const RhsStlContainer& rhs_stl_container =
+      RhsView::ConstReference(rhs_container);
+
+  // Create a matcher for each element in rhs_container.
+  ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers;
+  for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin();
+       it != rhs_stl_container.end(); ++it) {
+    matchers.push_back(
+        internal::MatcherBindSecond(tuple2_matcher, *it));
+  }
+
+  // Delegate the work to UnorderedElementsAreArray().
+  return UnorderedElementsAreArray(matchers);
+}
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+
+// Supports the UnorderedPointwise(m, {a, b, c}) syntax.
+template <typename Tuple2Matcher, typename T>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename internal::BoundSecondMatcher<Tuple2Matcher, T> >
+UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
+                   std::initializer_list<T> rhs) {
+  return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));
+}
+
+#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
+
+// Matches an STL-style container or a native array that contains at
+// least one element matching the given value or matcher.
+//
+// Examples:
+//   ::std::set<int> page_ids;
+//   page_ids.insert(3);
+//   page_ids.insert(1);
+//   EXPECT_THAT(page_ids, Contains(1));
+//   EXPECT_THAT(page_ids, Contains(Gt(2)));
+//   EXPECT_THAT(page_ids, Not(Contains(4)));
+//
+//   ::std::map<int, size_t> page_lengths;
+//   page_lengths[1] = 100;
+//   EXPECT_THAT(page_lengths,
+//               Contains(::std::pair<const int, size_t>(1, 100)));
+//
+//   const char* user_ids[] = { "joe", "mike", "tom" };
+//   EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom"))));
+template <typename M>
+inline internal::ContainsMatcher<M> Contains(M matcher) {
+  return internal::ContainsMatcher<M>(matcher);
+}
+
+// Matches an STL-style container or a native array that contains only
+// elements matching the given value or matcher.
+//
+// Each(m) is semantically equivalent to Not(Contains(Not(m))). Only
+// the messages are different.
+//
+// Examples:
+//   ::std::set<int> page_ids;
+//   // Each(m) matches an empty container, regardless of what m is.
+//   EXPECT_THAT(page_ids, Each(Eq(1)));
+//   EXPECT_THAT(page_ids, Each(Eq(77)));
+//
+//   page_ids.insert(3);
+//   EXPECT_THAT(page_ids, Each(Gt(0)));
+//   EXPECT_THAT(page_ids, Not(Each(Gt(4))));
+//   page_ids.insert(1);
+//   EXPECT_THAT(page_ids, Not(Each(Lt(2))));
+//
+//   ::std::map<int, size_t> page_lengths;
+//   page_lengths[1] = 100;
+//   page_lengths[2] = 200;
+//   page_lengths[3] = 300;
+//   EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100))));
+//   EXPECT_THAT(page_lengths, Each(Key(Le(3))));
+//
+//   const char* user_ids[] = { "joe", "mike", "tom" };
+//   EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom")))));
+template <typename M>
+inline internal::EachMatcher<M> Each(M matcher) {
+  return internal::EachMatcher<M>(matcher);
+}
+
+// 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
+// std::map that contains at least one element whose key is >= 5.
+template <typename M>
+inline internal::KeyMatcher<M> Key(M inner_matcher) {
+  return internal::KeyMatcher<M>(inner_matcher);
+}
+
+// Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field
+// matches first_matcher and whose 'second' field matches second_matcher.  For
+// example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used
+// to match a std::map<int, string> that contains exactly one element whose key
+// is >= 5 and whose value equals "foo".
+template <typename FirstMatcher, typename SecondMatcher>
+inline internal::PairMatcher<FirstMatcher, SecondMatcher>
+Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) {
+  return internal::PairMatcher<FirstMatcher, SecondMatcher>(
+      first_matcher, second_matcher);
+}
+
+// Returns a predicate that is satisfied by anything that matches the
+// given matcher.
+template <typename M>
+inline internal::MatcherAsPredicate<M> Matches(M matcher) {
+  return internal::MatcherAsPredicate<M>(matcher);
+}
+
+// Returns true iff the value matches the matcher.
+template <typename T, typename M>
+inline bool Value(const T& value, M matcher) {
+  return testing::Matches(matcher)(value);
+}
+
+// Matches the value against the given matcher and explains the match
+// result to listener.
+template <typename T, typename M>
+inline bool ExplainMatchResult(
+    M matcher, const T& value, MatchResultListener* listener) {
+  return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
+}
+
+#if GTEST_LANG_CXX11
+// Define variadic matcher versions. They are overloaded in
+// gmock-generated-matchers.h for the cases supported by pre C++11 compilers.
+template <typename... Args>
+inline internal::AllOfMatcher<Args...> AllOf(const Args&... matchers) {
+  return internal::AllOfMatcher<Args...>(matchers...);
+}
+
+template <typename... Args>
+inline internal::AnyOfMatcher<Args...> AnyOf(const Args&... matchers) {
+  return internal::AnyOfMatcher<Args...>(matchers...);
+}
+
+#endif  // GTEST_LANG_CXX11
+
+// AllArgs(m) is a synonym of m.  This is useful in
+//
+//   EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq()));
+//
+// which is easier to read than
+//
+//   EXPECT_CALL(foo, Bar(_, _)).With(Eq());
+template <typename InnerMatcher>
+inline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; }
+
+// These macros allow using matchers to check values in Google Test
+// tests.  ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)
+// succeed iff 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)
+
+}  // namespace testing
+
+// 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  // GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-actions.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-actions.h
new file mode 100644
index 00000000..3d387b6b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-actions.h
@@ -0,0 +1,246 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some actions that depend on gmock-generated-actions.h.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+
+#include <algorithm>
+
+#include "gmock/gmock-generated-actions.h"
+
+namespace testing {
+namespace internal {
+
+// Implements the Invoke(f) action.  The template argument
+// FunctionImpl is the implementation type of f, which can be either a
+// function pointer or a functor.  Invoke(f) can be used as an
+// Action<F> as long as f's type is compatible with F (i.e. f can be
+// assigned to a tr1::function<F>).
+template <typename FunctionImpl>
+class InvokeAction {
+ public:
+  // The c'tor makes a copy of function_impl (either a function
+  // pointer or a functor).
+  explicit InvokeAction(FunctionImpl function_impl)
+      : function_impl_(function_impl) {}
+
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& args) {
+    return InvokeHelper<Result, ArgumentTuple>::Invoke(function_impl_, args);
+  }
+
+ private:
+  FunctionImpl function_impl_;
+
+  GTEST_DISALLOW_ASSIGN_(InvokeAction);
+};
+
+// Implements the Invoke(object_ptr, &Class::Method) action.
+template <class Class, typename MethodPtr>
+class InvokeMethodAction {
+ public:
+  InvokeMethodAction(Class* obj_ptr, MethodPtr method_ptr)
+      : method_ptr_(method_ptr), obj_ptr_(obj_ptr) {}
+
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& args) const {
+    return InvokeHelper<Result, ArgumentTuple>::InvokeMethod(
+        obj_ptr_, method_ptr_, args);
+  }
+
+ private:
+  // The order of these members matters.  Reversing the order can trigger
+  // warning C4121 in MSVC (see
+  // http://computer-programming-forum.com/7-vc.net/6fbc30265f860ad1.htm ).
+  const MethodPtr method_ptr_;
+  Class* const obj_ptr_;
+
+  GTEST_DISALLOW_ASSIGN_(InvokeMethodAction);
+};
+
+// An internal replacement for std::copy which mimics its behavior. This is
+// necessary because Visual Studio deprecates ::std::copy, issuing warning 4996.
+// However Visual Studio 2010 and later do not honor #pragmas which disable that
+// warning.
+template<typename InputIterator, typename OutputIterator>
+inline OutputIterator CopyElements(InputIterator first,
+                                   InputIterator last,
+                                   OutputIterator output) {
+  for (; first != last; ++first, ++output) {
+    *output = *first;
+  }
+  return output;
+}
+
+}  // namespace internal
+
+// Various overloads for Invoke().
+
+// Creates an action that invokes 'function_impl' with the mock
+// function's arguments.
+template <typename FunctionImpl>
+PolymorphicAction<internal::InvokeAction<FunctionImpl> > Invoke(
+    FunctionImpl function_impl) {
+  return MakePolymorphicAction(
+      internal::InvokeAction<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>
+PolymorphicAction<internal::InvokeMethodAction<Class, MethodPtr> > Invoke(
+    Class* obj_ptr, MethodPtr method_ptr) {
+  return MakePolymorphicAction(
+      internal::InvokeMethodAction<Class, MethodPtr>(obj_ptr, method_ptr));
+}
+
+// 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>
+inline internal::WithArgsAction<InnerAction>
+WithoutArgs(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction>(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 <int k, typename InnerAction>
+inline internal::WithArgsAction<InnerAction, k>
+WithArg(const InnerAction& action) {
+  return internal::WithArgsAction<InnerAction, k>(action);
+}
+
+// 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
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+// Action ReturnArg<k>() returns the k-th argument of the mock function.
+ACTION_TEMPLATE(ReturnArg,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_0_VALUE_PARAMS()) {
+  return ::testing::get<k>(args);
+}
+
+// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
+// mock function to *pointer.
+ACTION_TEMPLATE(SaveArg,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(pointer)) {
+  *pointer = ::testing::get<k>(args);
+}
+
+// Action SaveArgPointee<k>(pointer) saves the value pointed to
+// by the k-th (0-based) argument of the mock function to *pointer.
+ACTION_TEMPLATE(SaveArgPointee,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(pointer)) {
+  *pointer = *::testing::get<k>(args);
+}
+
+// Action SetArgReferee<k>(value) assigns 'value' to the variable
+// referenced by the k-th (0-based) argument of the mock function.
+ACTION_TEMPLATE(SetArgReferee,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(value)) {
+  typedef typename ::testing::tuple_element<k, args_type>::type argk_type;
+  // Ensures that argument #k is a reference.  If you get a compiler
+  // error on the next line, you are using SetArgReferee<k>(value) in
+  // a mock function whose k-th (0-based) argument is not a reference.
+  GTEST_COMPILE_ASSERT_(internal::is_reference<argk_type>::value,
+                        SetArgReferee_must_be_used_with_a_reference_argument);
+  ::testing::get<k>(args) = 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.
+ACTION_TEMPLATE(SetArrayArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_2_VALUE_PARAMS(first, last)) {
+  // Visual Studio deprecates ::std::copy, so we use our own copy in that case.
+#ifdef _MSC_VER
+  internal::CopyElements(first, last, ::testing::get<k>(args));
+#else
+  ::std::copy(first, last, ::testing::get<k>(args));
+#endif
+}
+
+// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
+// function.
+ACTION_TEMPLATE(DeleteArg,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_0_VALUE_PARAMS()) {
+  delete ::testing::get<k>(args);
+}
+
+// This action returns the value pointed to by 'pointer'.
+ACTION_P(ReturnPointee, 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
+
+// Suppresses the 'unreachable code' warning that VC generates in opt modes.
+# ifdef _MSC_VER
+#  pragma warning(push)          // Saves the current warning state.
+#  pragma warning(disable:4702)  // Temporarily disables warning 4702.
+# endif
+ACTION_P(Throw, exception) { throw exception; }
+# ifdef _MSC_VER
+#  pragma warning(pop)           // Restores the warning state.
+# endif
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-matchers.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-matchers.h
new file mode 100644
index 00000000..3db899f4
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-matchers.h
@@ -0,0 +1,58 @@
+// Copyright 2013, 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.
+//
+// Author: marcus.boerger@google.com (Marcus Boerger)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some matchers that depend on gmock-generated-matchers.h.
+//
+// Note that tests are implemented in gmock-matchers_test.cc rather than
+// gmock-more-matchers-test.cc.
+
+#ifndef GMOCK_GMOCK_MORE_MATCHERS_H_
+#define GMOCK_GMOCK_MORE_MATCHERS_H_
+
+#include "gmock/gmock-generated-matchers.h"
+
+namespace testing {
+
+// 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") {
+  if (arg.empty()) {
+    return true;
+  }
+  *result_listener << "whose size is " << arg.size();
+  return false;
+}
+
+}  // namespace testing
+
+#endif  // GMOCK_GMOCK_MORE_MATCHERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-spec-builders.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-spec-builders.h
new file mode 100644
index 00000000..fed7de66
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-spec-builders.h
@@ -0,0 +1,1847 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements the ON_CALL() and EXPECT_CALL() macros.
+//
+// A user can use the ON_CALL() macro to specify the default action of
+// a mock method.  The syntax is:
+//
+//   ON_CALL(mock_object, Method(argument-matchers))
+//       .With(multi-argument-matcher)
+//       .WillByDefault(action);
+//
+//  where the .With() clause is optional.
+//
+// A user can use the EXPECT_CALL() macro to specify an expectation on
+// a mock method.  The syntax is:
+//
+//   EXPECT_CALL(mock_object, Method(argument-matchers))
+//       .With(multi-argument-matchers)
+//       .Times(cardinality)
+//       .InSequence(sequences)
+//       .After(expectations)
+//       .WillOnce(action)
+//       .WillRepeatedly(action)
+//       .RetiresOnSaturation();
+//
+// where all clauses are optional, and .InSequence()/.After()/
+// .WillOnce() can appear any number of times.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>  // NOLINT
+#endif
+
+#include "gmock/gmock-actions.h"
+#include "gmock/gmock-cardinalities.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+
+// An abstract handle of an expectation.
+class Expectation;
+
+// A set of expectation handles.
+class ExpectationSet;
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// Implements a mock function.
+template <typename F> class FunctionMocker;
+
+// Base class for expectations.
+class ExpectationBase;
+
+// Implements an expectation.
+template <typename F> class TypedExpectation;
+
+// Helper class for testing the Expectation class template.
+class ExpectationTester;
+
+// Base class for function mockers.
+template <typename F> class FunctionMockerBase;
+
+// Protects the mock object registry (in class Mock), all function
+// mockers, and all expectations.
+//
+// The reason we don't use more fine-grained protection is: when a
+// mock function Foo() is called, it needs to consult its expectations
+// to see which one should be picked.  If another thread is allowed to
+// call a mock function (either Foo() or a different one) at the same
+// time, it could affect the "retired" attributes of Foo()'s
+// expectations when InSequence() is used, and thus affect which
+// expectation gets picked.  Therefore, we sequence all mock function
+// calls to ensure the integrity of the mock objects' states.
+GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
+
+// Untyped base class for ActionResultHolder<R>.
+class UntypedActionResultHolderBase;
+
+// Abstract base class of FunctionMockerBase.  This is the
+// type-agnostic part of the function mocker interface.  Its pure
+// virtual methods are implemented by FunctionMockerBase.
+class GTEST_API_ UntypedFunctionMockerBase {
+ public:
+  UntypedFunctionMockerBase();
+  virtual ~UntypedFunctionMockerBase();
+
+  // Verifies that all expectations on this mock function have been
+  // satisfied.  Reports one or more Google Test non-fatal failures
+  // and returns false if not.
+  bool VerifyAndClearExpectationsLocked()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Clears the ON_CALL()s set on this mock function.
+  virtual void ClearDefaultActionsLocked()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0;
+
+  // In all of the following Untyped* functions, it's the caller's
+  // responsibility to guarantee the correctness of the arguments'
+  // types.
+
+  // Performs the default action with the given arguments and returns
+  // the action's result.  The call description string will be used in
+  // the error message to describe the call in the case the default
+  // action fails.
+  // L = *
+  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
+      const void* untyped_args,
+      const 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,
+      const void* untyped_args) const = 0;
+
+  // Writes a message that the call is uninteresting (i.e. neither
+  // explicitly expected nor explicitly unexpected) to the given
+  // ostream.
+  virtual void UntypedDescribeUninterestingCall(
+      const void* untyped_args,
+      ::std::ostream* os) const
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
+
+  // Returns the expectation that matches the given function arguments
+  // (or NULL is there's no match); when a match is found,
+  // untyped_action is set to point to the action that should be
+  // performed (or NULL if the action is "do default"), and
+  // is_excessive is modified to indicate whether the call exceeds the
+  // expected number.
+  virtual const ExpectationBase* UntypedFindMatchingExpectation(
+      const void* untyped_args,
+      const void** untyped_action, bool* is_excessive,
+      ::std::ostream* what, ::std::ostream* why)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
+
+  // Prints the given function arguments to the ostream.
+  virtual void UntypedPrintArgs(const void* untyped_args,
+                                ::std::ostream* os) const = 0;
+
+  // Sets the mock object this mock method belongs to, and registers
+  // this information in the global mock registry.  Will be called
+  // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
+  // method.
+  // TODO(wan@google.com): rename to SetAndRegisterOwner().
+  void RegisterOwner(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Sets the mock object this mock method belongs to, and sets the
+  // name of the mock function.  Will be called upon each invocation
+  // of this mock function.
+  void SetOwnerAndName(const void* mock_obj, const char* name)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the mock object this mock method belongs to.  Must be
+  // called after RegisterOwner() or SetOwnerAndName() has been
+  // called.
+  const void* MockObject() const
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the name of this mock method.  Must be called after
+  // SetOwnerAndName() has been called.
+  const char* Name() const
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the result of invoking this mock function with the given
+  // arguments.  This function can be safely called from multiple
+  // threads concurrently.  The caller is responsible for deleting the
+  // result.
+  UntypedActionResultHolderBase* UntypedInvokeWith(
+      const void* untyped_args)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+ protected:
+  typedef std::vector<const void*> UntypedOnCallSpecs;
+
+  typedef std::vector<internal::linked_ptr<ExpectationBase> >
+  UntypedExpectations;
+
+  // Returns an Expectation object that references and co-owns exp,
+  // which must be an expectation on this mock function.
+  Expectation GetHandleOf(ExpectationBase* exp);
+
+  // Address of the mock object this mock method belongs to.  Only
+  // valid after this mock method has been called or
+  // ON_CALL/EXPECT_CALL has been invoked on it.
+  const void* mock_obj_;  // Protected by g_gmock_mutex.
+
+  // Name of the function being mocked.  Only valid after this mock
+  // method has been called.
+  const char* name_;  // Protected by g_gmock_mutex.
+
+  // All default action specs for this function mocker.
+  UntypedOnCallSpecs untyped_on_call_specs_;
+
+  // All expectations for this function mocker.
+  UntypedExpectations untyped_expectations_;
+};  // class UntypedFunctionMockerBase
+
+// Untyped base class for OnCallSpec<F>.
+class UntypedOnCallSpecBase {
+ public:
+  // The arguments are the location of the ON_CALL() statement.
+  UntypedOnCallSpecBase(const char* a_file, int a_line)
+      : file_(a_file), line_(a_line), last_clause_(kNone) {}
+
+  // Where in the source file was the default action spec defined?
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+
+ protected:
+  // Gives each clause in the ON_CALL() statement a name.
+  enum Clause {
+    // Do not change the order of the enum members!  The run-time
+    // syntax checking relies on it.
+    kNone,
+    kWith,
+    kWillByDefault
+  };
+
+  // Asserts that the ON_CALL() statement has a certain property.
+  void AssertSpecProperty(bool property, const 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 string& failure_message) const {
+    Expect(property, file_, line_, failure_message);
+  }
+
+  const char* file_;
+  int line_;
+
+  // The last clause in the ON_CALL() statement as seen so far.
+  // Initially kNone and changes as the statement is parsed.
+  Clause last_clause_;
+};  // class UntypedOnCallSpecBase
+
+// This template class implements an ON_CALL spec.
+template <typename F>
+class OnCallSpec : public UntypedOnCallSpecBase {
+ public:
+  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
+
+  // Constructs an OnCallSpec object from the information inside
+  // the parenthesis of an ON_CALL() statement.
+  OnCallSpec(const char* a_file, int a_line,
+             const ArgumentMatcherTuple& matchers)
+      : UntypedOnCallSpecBase(a_file, a_line),
+        matchers_(matchers),
+        // By default, extra_matcher_ should match anything.  However,
+        // we cannot initialize it with _ as that triggers a compiler
+        // bug in Symbian's C++ compiler (cannot decide between two
+        // overloaded constructors of Matcher<const ArgumentTuple&>).
+        extra_matcher_(A<const ArgumentTuple&>()) {
+  }
+
+  // Implements the .With() clause.
+  OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
+    // Makes sure this is called at most once.
+    ExpectSpecProperty(last_clause_ < kWith,
+                       ".With() cannot appear "
+                       "more than once in an ON_CALL().");
+    last_clause_ = kWith;
+
+    extra_matcher_ = m;
+    return *this;
+  }
+
+  // Implements the .WillByDefault() clause.
+  OnCallSpec& WillByDefault(const Action<F>& action) {
+    ExpectSpecProperty(last_clause_ < kWillByDefault,
+                       ".WillByDefault() must appear "
+                       "exactly once in an ON_CALL().");
+    last_clause_ = kWillByDefault;
+
+    ExpectSpecProperty(!action.IsDoDefault(),
+                       "DoDefault() cannot be used in ON_CALL().");
+    action_ = action;
+    return *this;
+  }
+
+  // Returns true iff the given arguments match the matchers.
+  bool Matches(const ArgumentTuple& args) const {
+    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
+  }
+
+  // Returns the action specified by the user.
+  const Action<F>& GetAction() const {
+    AssertSpecProperty(last_clause_ == kWillByDefault,
+                       ".WillByDefault() must appear exactly "
+                       "once in an ON_CALL().");
+    return action_;
+  }
+
+ private:
+  // The information in statement
+  //
+  //   ON_CALL(mock_object, Method(matchers))
+  //       .With(multi-argument-matcher)
+  //       .WillByDefault(action);
+  //
+  // is recorded in the data members like this:
+  //
+  //   source file that contains the statement => file_
+  //   line number of the statement            => line_
+  //   matchers                                => matchers_
+  //   multi-argument-matcher                  => extra_matcher_
+  //   action                                  => action_
+  ArgumentMatcherTuple matchers_;
+  Matcher<const ArgumentTuple&> extra_matcher_;
+  Action<F> action_;
+};  // class OnCallSpec
+
+// Possible reactions on uninteresting calls.
+enum CallReaction {
+  kAllow,
+  kWarn,
+  kFail,
+  kDefault = kWarn  // By default, warn about uninteresting calls.
+};
+
+}  // namespace internal
+
+// Utilities for manipulating mock objects.
+class GTEST_API_ Mock {
+ public:
+  // The following public methods can be called concurrently.
+
+  // Tells Google Mock to ignore mock_obj when checking for leaked
+  // mock objects.
+  static void AllowLeak(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies and clears all expectations on the given mock object.
+  // If the expectations aren't satisfied, generates one or more
+  // Google Test non-fatal failures and returns false.
+  static bool VerifyAndClearExpectations(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies all expectations on the given mock object and clears its
+  // default actions and expectations.  Returns true iff the
+  // verification was successful.
+  static bool VerifyAndClear(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::FunctionMockerBase;
+
+  template <typename M>
+  friend class NiceMock;
+
+  template <typename M>
+  friend class NaggyMock;
+
+  template <typename M>
+  friend class StrictMock;
+
+  // Tells Google Mock to allow uninteresting calls on the given mock
+  // object.
+  static void AllowUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock to warn the user about uninteresting calls on
+  // the given mock object.
+  static void WarnUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock to fail uninteresting calls on the given mock
+  // object.
+  static void FailUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock the given mock object is being destroyed and
+  // its entry in the call-reaction table should be removed.
+  static void UnregisterCallReaction(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Returns the reaction Google Mock will have on uninteresting calls
+  // made on the given mock object.
+  static internal::CallReaction GetReactionOnUninterestingCalls(
+      const void* mock_obj)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies that all expectations on the given mock object have been
+  // satisfied.  Reports one or more Google Test non-fatal failures
+  // and returns false if not.
+  static bool VerifyAndClearExpectationsLocked(void* mock_obj)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+
+  // Clears all ON_CALL()s set on the given mock object.
+  static void ClearDefaultActionsLocked(void* mock_obj)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+
+  // Registers a mock object and a mock method it owns.
+  static void Register(
+      const void* mock_obj,
+      internal::UntypedFunctionMockerBase* mocker)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock where in the source code mock_obj is used in an
+  // ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
+  // information helps the user identify which object it is.
+  static void RegisterUseByOnCallOrExpectCall(
+      const void* mock_obj, const char* file, int line)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // 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
+  // FunctionMockerBase.
+  static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+};  // class Mock
+
+// An abstract handle of an expectation.  Useful in the .After()
+// clause of EXPECT_CALL() for setting the (partial) order of
+// expectations.  The syntax:
+//
+//   Expectation e1 = EXPECT_CALL(...)...;
+//   EXPECT_CALL(...).After(e1)...;
+//
+// sets two expectations where the latter can only be matched after
+// the former has been satisfied.
+//
+// Notes:
+//   - This class is copyable and has value semantics.
+//   - 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().
+//   - The constructors and destructor are defined out-of-line because
+//     the Symbian WINSCW compiler wants to otherwise instantiate them
+//     when it sees this class definition, at which point it doesn't have
+//     ExpectationBase available yet, leading to incorrect destruction
+//     in the linked_ptr (or compilation errors if using a checking
+//     linked_ptr).
+class GTEST_API_ Expectation {
+ public:
+  // Constructs a null object that doesn't reference any expectation.
+  Expectation();
+
+  ~Expectation();
+
+  // This single-argument ctor must not be explicit, in order to support the
+  //   Expectation e = EXPECT_CALL(...);
+  // syntax.
+  //
+  // A TypedExpectation object stores its pre-requisites as
+  // Expectation objects, and needs to call the non-const Retire()
+  // method on the ExpectationBase objects they reference.  Therefore
+  // Expectation must receive a *non-const* reference to the
+  // ExpectationBase object.
+  Expectation(internal::ExpectationBase& exp);  // NOLINT
+
+  // The compiler-generated copy ctor and operator= work exactly as
+  // intended, so we don't need to define our own.
+
+  // Returns true iff rhs references the same expectation as this object does.
+  bool operator==(const Expectation& rhs) const {
+    return expectation_base_ == rhs.expectation_base_;
+  }
+
+  bool operator!=(const Expectation& rhs) const { return !(*this == rhs); }
+
+ private:
+  friend class ExpectationSet;
+  friend class Sequence;
+  friend class ::testing::internal::ExpectationBase;
+  friend class ::testing::internal::UntypedFunctionMockerBase;
+
+  template <typename F>
+  friend class ::testing::internal::FunctionMockerBase;
+
+  template <typename F>
+  friend class ::testing::internal::TypedExpectation;
+
+  // This comparator is needed for putting Expectation objects into a set.
+  class Less {
+   public:
+    bool operator()(const Expectation& lhs, const Expectation& rhs) const {
+      return lhs.expectation_base_.get() < rhs.expectation_base_.get();
+    }
+  };
+
+  typedef ::std::set<Expectation, Less> Set;
+
+  Expectation(
+      const internal::linked_ptr<internal::ExpectationBase>& expectation_base);
+
+  // Returns the expectation this object references.
+  const internal::linked_ptr<internal::ExpectationBase>&
+  expectation_base() const {
+    return expectation_base_;
+  }
+
+  // A linked_ptr that co-owns the expectation this handle references.
+  internal::linked_ptr<internal::ExpectationBase> expectation_base_;
+};
+
+// A set of expectation handles.  Useful in the .After() clause of
+// EXPECT_CALL() for setting the (partial) order of expectations.  The
+// syntax:
+//
+//   ExpectationSet es;
+//   es += EXPECT_CALL(...)...;
+//   es += EXPECT_CALL(...)...;
+//   EXPECT_CALL(...).After(es)...;
+//
+// sets three expectations where the last one can only be matched
+// after the first two have both been satisfied.
+//
+// This class is copyable and has value semantics.
+class ExpectationSet {
+ public:
+  // A bidirectional iterator that can read a const element in the set.
+  typedef Expectation::Set::const_iterator const_iterator;
+
+  // An object stored in the set.  This is an alias of Expectation.
+  typedef Expectation::Set::value_type value_type;
+
+  // Constructs an empty set.
+  ExpectationSet() {}
+
+  // This single-argument ctor must not be explicit, in order to support the
+  //   ExpectationSet es = EXPECT_CALL(...);
+  // syntax.
+  ExpectationSet(internal::ExpectationBase& exp) {  // NOLINT
+    *this += Expectation(exp);
+  }
+
+  // This single-argument ctor implements implicit conversion from
+  // Expectation and thus must not be explicit.  This allows either an
+  // Expectation or an ExpectationSet to be used in .After().
+  ExpectationSet(const Expectation& e) {  // NOLINT
+    *this += e;
+  }
+
+  // The compiler-generator ctor and operator= works exactly as
+  // intended, so we don't need to define our own.
+
+  // Returns true iff rhs contains the same set of Expectation objects
+  // as this does.
+  bool operator==(const ExpectationSet& rhs) const {
+    return expectations_ == rhs.expectations_;
+  }
+
+  bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); }
+
+  // Implements the syntax
+  //   expectation_set += EXPECT_CALL(...);
+  ExpectationSet& operator+=(const Expectation& e) {
+    expectations_.insert(e);
+    return *this;
+  }
+
+  int size() const { return static_cast<int>(expectations_.size()); }
+
+  const_iterator begin() const { return expectations_.begin(); }
+  const_iterator end() const { return expectations_.end(); }
+
+ private:
+  Expectation::Set expectations_;
+};
+
+
+// Sequence objects are used by a user to specify the relative order
+// in which the expectations should match.  They are copyable (we rely
+// on the compiler-defined copy constructor and assignment operator).
+class GTEST_API_ Sequence {
+ public:
+  // Constructs an empty sequence.
+  Sequence() : last_expectation_(new Expectation) {}
+
+  // Adds an expectation to this sequence.  The caller must ensure
+  // that no other thread is accessing this Sequence object.
+  void AddExpectation(const Expectation& expectation) const;
+
+ private:
+  // The last expectation in this sequence.  We use a linked_ptr here
+  // because Sequence objects are copyable and we want the copies to
+  // be aliases.  The linked_ptr allows the copies to co-own and share
+  // the same Expectation object.
+  internal::linked_ptr<Expectation> last_expectation_;
+};  // class Sequence
+
+// An object of this type causes all EXPECT_CALL() statements
+// encountered in its scope to be put in an anonymous sequence.  The
+// work is done in the constructor and destructor.  You should only
+// create an InSequence object on the stack.
+//
+// The sole purpose for this class is to support easy definition of
+// sequential expectations, e.g.
+//
+//   {
+//     InSequence dummy;  // The name of the object doesn't matter.
+//
+//     // The following expectations must match in the order they appear.
+//     EXPECT_CALL(a, Bar())...;
+//     EXPECT_CALL(a, Baz())...;
+//     ...
+//     EXPECT_CALL(b, Xyz())...;
+//   }
+//
+// You can create InSequence objects in multiple threads, as long as
+// they are used to affect different mock objects.  The idea is that
+// each thread can create and set up its own mocks as if it's the only
+// thread.  However, for clarity of your tests we recommend you to set
+// up mocks in the main thread unless you have a good reason not to do
+// so.
+class GTEST_API_ InSequence {
+ public:
+  InSequence();
+  ~InSequence();
+ private:
+  bool sequence_created_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence);  // NOLINT
+} GTEST_ATTRIBUTE_UNUSED_;
+
+namespace internal {
+
+// Points to the implicit sequence introduced by a living InSequence
+// object (if any) in the current thread or NULL.
+GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence;
+
+// Base class for implementing expectations.
+//
+// There are two reasons for having a type-agnostic base class for
+// Expectation:
+//
+//   1. We need to store collections of expectations of different
+//   types (e.g. all pre-requisites of a particular expectation, all
+//   expectations in a sequence).  Therefore these expectation objects
+//   must share a common base class.
+//
+//   2. We can avoid binary code bloat by moving methods not depending
+//   on the template argument of Expectation to the base class.
+//
+// This class is internal and mustn't be used by user code directly.
+class GTEST_API_ ExpectationBase {
+ public:
+  // source_text is the EXPECT_CALL(...) source that created this Expectation.
+  ExpectationBase(const char* file, int line, const string& source_text);
+
+  virtual ~ExpectationBase();
+
+  // Where in the source file was the expectation spec defined?
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+  const char* source_text() const { return source_text_.c_str(); }
+  // Returns the cardinality specified in the expectation spec.
+  const Cardinality& cardinality() const { return cardinality_; }
+
+  // Describes the source file location of this expectation.
+  void DescribeLocationTo(::std::ostream* os) const {
+    *os << FormatFileLocation(file(), line()) << " ";
+  }
+
+  // Describes how many times a function call matching this
+  // expectation has occurred.
+  void DescribeCallCountTo(::std::ostream* os) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // If this mock method has an extra matcher (i.e. .With(matcher)),
+  // describes it to the ostream.
+  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0;
+
+ protected:
+  friend class ::testing::Expectation;
+  friend class UntypedFunctionMockerBase;
+
+  enum Clause {
+    // Don't change the order of the enum members!
+    kNone,
+    kWith,
+    kTimes,
+    kInSequence,
+    kAfter,
+    kWillOnce,
+    kWillRepeatedly,
+    kRetiresOnSaturation
+  };
+
+  typedef std::vector<const void*> UntypedActions;
+
+  // Returns an Expectation object that references and co-owns this
+  // expectation.
+  virtual Expectation GetHandle() = 0;
+
+  // Asserts that the EXPECT_CALL() statement has the given property.
+  void AssertSpecProperty(bool property, const 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 string& failure_message) const {
+    Expect(property, file_, line_, failure_message);
+  }
+
+  // Explicitly specifies the cardinality of this expectation.  Used
+  // by the subclasses to implement the .Times() clause.
+  void SpecifyCardinality(const Cardinality& cardinality);
+
+  // Returns true iff the user specified the cardinality explicitly
+  // using a .Times().
+  bool cardinality_specified() const { return cardinality_specified_; }
+
+  // Sets the cardinality of this expectation spec.
+  void set_cardinality(const Cardinality& a_cardinality) {
+    cardinality_ = a_cardinality;
+  }
+
+  // The following group of methods should only be called after the
+  // EXPECT_CALL() statement, and only when g_gmock_mutex is held by
+  // the current thread.
+
+  // Retires all pre-requisites of this expectation.
+  void RetireAllPreRequisites()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Returns true iff this expectation is retired.
+  bool is_retired() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return retired_;
+  }
+
+  // Retires this expectation.
+  void Retire()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    retired_ = true;
+  }
+
+  // Returns true iff 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 iff 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 iff 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 iff all pre-requisites of this expectation are satisfied.
+  bool AllPrerequisitesAreSatisfied() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Adds unsatisfied pre-requisites of this expectation to 'result'.
+  void FindUnsatisfiedPrerequisites(ExpectationSet* result) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Returns the number this expectation has been invoked.
+  int call_count() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return call_count_;
+  }
+
+  // Increments the number this expectation has been invoked.
+  void IncrementCallCount()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    call_count_++;
+  }
+
+  // Checks the action count (i.e. the number of WillOnce() and
+  // WillRepeatedly() clauses) against the cardinality if this hasn't
+  // been done before.  Prints a warning if there are too many or too
+  // few actions.
+  void CheckActionCountIfNotDone() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  friend class ::testing::Sequence;
+  friend class ::testing::internal::ExpectationTester;
+
+  template <typename Function>
+  friend class TypedExpectation;
+
+  // Implements the .Times() clause.
+  void UntypedTimes(const Cardinality& a_cardinality);
+
+  // This group of fields are part of the spec and won't change after
+  // an EXPECT_CALL() statement finishes.
+  const char* file_;          // The file that contains the expectation.
+  int line_;                  // The line number of the expectation.
+  const string source_text_;  // The EXPECT_CALL(...) source text.
+  // True iff 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 linked_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.
+  ExpectationSet immediate_prerequisites_;
+
+  // 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 iff this expectation has retired.
+  UntypedActions untyped_actions_;
+  bool extra_matcher_specified_;
+  bool repeated_action_specified_;  // True if a WillRepeatedly() was specified.
+  bool retires_on_saturation_;
+  Clause last_clause_;
+  mutable bool action_count_checked_;  // Under mutex_.
+  mutable Mutex mutex_;  // Protects action_count_checked_.
+
+  GTEST_DISALLOW_ASSIGN_(ExpectationBase);
+};  // class ExpectationBase
+
+// Impements an expectation for the given function type.
+template <typename F>
+class TypedExpectation : public ExpectationBase {
+ public:
+  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
+  typedef typename Function<F>::Result Result;
+
+  TypedExpectation(FunctionMockerBase<F>* owner,
+                   const char* a_file, int a_line, const 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 triggers a compiler
+        // bug in Symbian's C++ compiler (cannot decide between two
+        // overloaded constructors of Matcher<const ArgumentTuple&>).
+        extra_matcher_(A<const ArgumentTuple&>()),
+        repeated_action_(DoDefault()) {}
+
+  virtual ~TypedExpectation() {
+    // Check the validity of the action count if it hasn't been done
+    // yet (for example, if the expectation was never used).
+    CheckActionCountIfNotDone();
+    for (UntypedActions::const_iterator it = untyped_actions_.begin();
+         it != untyped_actions_.end(); ++it) {
+      delete static_cast<const Action<F>*>(*it);
+    }
+  }
+
+  // Implements the .With() clause.
+  TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) {
+    if (last_clause_ == kWith) {
+      ExpectSpecProperty(false,
+                         ".With() cannot appear "
+                         "more than once in an EXPECT_CALL().");
+    } else {
+      ExpectSpecProperty(last_clause_ < kWith,
+                         ".With() must be the first "
+                         "clause in an EXPECT_CALL().");
+    }
+    last_clause_ = kWith;
+
+    extra_matcher_ = m;
+    extra_matcher_specified_ = true;
+    return *this;
+  }
+
+  // Implements the .Times() clause.
+  TypedExpectation& Times(const Cardinality& a_cardinality) {
+    ExpectationBase::UntypedTimes(a_cardinality);
+    return *this;
+  }
+
+  // Implements the .Times() clause.
+  TypedExpectation& Times(int n) {
+    return Times(Exactly(n));
+  }
+
+  // Implements the .InSequence() clause.
+  TypedExpectation& InSequence(const Sequence& s) {
+    ExpectSpecProperty(last_clause_ <= kInSequence,
+                       ".InSequence() cannot appear after .After(),"
+                       " .WillOnce(), .WillRepeatedly(), or "
+                       ".RetiresOnSaturation().");
+    last_clause_ = kInSequence;
+
+    s.AddExpectation(GetHandle());
+    return *this;
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) {
+    return InSequence(s1).InSequence(s2);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3) {
+    return InSequence(s1, s2).InSequence(s3);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3, const Sequence& s4) {
+    return InSequence(s1, s2, s3).InSequence(s4);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3, const Sequence& s4,
+                               const Sequence& s5) {
+    return InSequence(s1, s2, s3, s4).InSequence(s5);
+  }
+
+  // Implements that .After() clause.
+  TypedExpectation& After(const ExpectationSet& s) {
+    ExpectSpecProperty(last_clause_ <= kAfter,
+                       ".After() cannot appear after .WillOnce(),"
+                       " .WillRepeatedly(), or "
+                       ".RetiresOnSaturation().");
+    last_clause_ = kAfter;
+
+    for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) {
+      immediate_prerequisites_ += *it;
+    }
+    return *this;
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) {
+    return After(s1).After(s2);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3) {
+    return After(s1, s2).After(s3);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3, const ExpectationSet& s4) {
+    return After(s1, s2, s3).After(s4);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3, const ExpectationSet& s4,
+                          const ExpectationSet& s5) {
+    return After(s1, s2, s3, s4).After(s5);
+  }
+
+  // Implements the .WillOnce() clause.
+  TypedExpectation& WillOnce(const Action<F>& action) {
+    ExpectSpecProperty(last_clause_ <= kWillOnce,
+                       ".WillOnce() cannot appear after "
+                       ".WillRepeatedly() or .RetiresOnSaturation().");
+    last_clause_ = kWillOnce;
+
+    untyped_actions_.push_back(new Action<F>(action));
+    if (!cardinality_specified()) {
+      set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
+    }
+    return *this;
+  }
+
+  // Implements the .WillRepeatedly() clause.
+  TypedExpectation& WillRepeatedly(const Action<F>& action) {
+    if (last_clause_ == kWillRepeatedly) {
+      ExpectSpecProperty(false,
+                         ".WillRepeatedly() cannot appear "
+                         "more than once in an EXPECT_CALL().");
+    } else {
+      ExpectSpecProperty(last_clause_ < kWillRepeatedly,
+                         ".WillRepeatedly() cannot appear "
+                         "after .RetiresOnSaturation().");
+    }
+    last_clause_ = kWillRepeatedly;
+    repeated_action_specified_ = true;
+
+    repeated_action_ = action;
+    if (!cardinality_specified()) {
+      set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size())));
+    }
+
+    // Now that no more action clauses can be specified, we check
+    // whether their count makes sense.
+    CheckActionCountIfNotDone();
+    return *this;
+  }
+
+  // Implements the .RetiresOnSaturation() clause.
+  TypedExpectation& RetiresOnSaturation() {
+    ExpectSpecProperty(last_clause_ < kRetiresOnSaturation,
+                       ".RetiresOnSaturation() cannot appear "
+                       "more than once.");
+    last_clause_ = kRetiresOnSaturation;
+    retires_on_saturation_ = true;
+
+    // Now that no more action clauses can be specified, we check
+    // whether their count makes sense.
+    CheckActionCountIfNotDone();
+    return *this;
+  }
+
+  // Returns the matchers for the arguments as specified inside the
+  // EXPECT_CALL() macro.
+  const ArgumentMatcherTuple& matchers() const {
+    return matchers_;
+  }
+
+  // Returns the matcher specified by the .With() clause.
+  const Matcher<const ArgumentTuple&>& extra_matcher() const {
+    return extra_matcher_;
+  }
+
+  // Returns the action specified by the .WillRepeatedly() clause.
+  const Action<F>& repeated_action() const { return repeated_action_; }
+
+  // If this mock method has an extra matcher (i.e. .With(matcher)),
+  // describes it to the ostream.
+  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) {
+    if (extra_matcher_specified_) {
+      *os << "    Expected args: ";
+      extra_matcher_.DescribeTo(os);
+      *os << "\n";
+    }
+  }
+
+ private:
+  template <typename Function>
+  friend class FunctionMockerBase;
+
+  // Returns an Expectation object that references and co-owns this
+  // expectation.
+  virtual Expectation GetHandle() {
+    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 iff 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 iff this expectation should handle the given arguments.
+  bool ShouldHandleArguments(const ArgumentTuple& args) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    // In case the action count wasn't checked when the expectation
+    // was defined (e.g. if this expectation has no WillRepeatedly()
+    // or RetiresOnSaturation() clause), we check it when the
+    // expectation is used for the first time.
+    CheckActionCountIfNotDone();
+    return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args);
+  }
+
+  // Describes the result of matching the arguments against this
+  // expectation to the given ostream.
+  void ExplainMatchResultTo(
+      const ArgumentTuple& args,
+      ::std::ostream* os) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    if (is_retired()) {
+      *os << "         Expected: the expectation is active\n"
+          << "           Actual: it is retired\n";
+    } else if (!Matches(args)) {
+      if (!TupleMatches(matchers_, args)) {
+        ExplainMatchFailureTupleTo(matchers_, args, os);
+      }
+      StringMatchResultListener listener;
+      if (!extra_matcher_.MatchAndExplain(args, &listener)) {
+        *os << "    Expected args: ";
+        extra_matcher_.DescribeTo(os);
+        *os << "\n           Actual: don't match";
+
+        internal::PrintIfNotEmpty(listener.str(), os);
+        *os << "\n";
+      }
+    } else if (!AllPrerequisitesAreSatisfied()) {
+      *os << "         Expected: all pre-requisites are satisfied\n"
+          << "           Actual: the following immediate pre-requisites "
+          << "are not satisfied:\n";
+      ExpectationSet unsatisfied_prereqs;
+      FindUnsatisfiedPrerequisites(&unsatisfied_prereqs);
+      int i = 0;
+      for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin();
+           it != unsatisfied_prereqs.end(); ++it) {
+        it->expectation_base()->DescribeLocationTo(os);
+        *os << "pre-requisite #" << i++ << "\n";
+      }
+      *os << "                   (end of pre-requisites)\n";
+    } else {
+      // This line is here just for completeness' sake.  It will never
+      // be executed as currently the ExplainMatchResultTo() function
+      // is called only when the mock function call does NOT match the
+      // expectation.
+      *os << "The call matches the expectation.\n";
+    }
+  }
+
+  // Returns the action that should be taken for the current invocation.
+  const Action<F>& GetCurrentAction(
+      const FunctionMockerBase<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__,
+           "call_count() is <= 0 when GetCurrentAction() is "
+           "called - this should never happen.");
+
+    const int action_count = static_cast<int>(untyped_actions_.size());
+    if (action_count > 0 && !repeated_action_specified_ &&
+        count > action_count) {
+      // If there is at least one WillOnce() and no WillRepeatedly(),
+      // we warn the user when the WillOnce() clauses ran out.
+      ::std::stringstream ss;
+      DescribeLocationTo(&ss);
+      ss << "Actions ran out in " << source_text() << "...\n"
+         << "Called " << count << " times, but only "
+         << action_count << " WillOnce()"
+         << (action_count == 1 ? " is" : "s are") << " specified - ";
+      mocker->DescribeDefaultActionTo(args, &ss);
+      Log(kWarning, ss.str(), 1);
+    }
+
+    return count <= action_count ?
+        *static_cast<const Action<F>*>(untyped_actions_[count - 1]) :
+        repeated_action();
+  }
+
+  // Given the arguments of a mock function call, if the call will
+  // over-saturate this expectation, returns the default action;
+  // otherwise, returns the next action in this expectation.  Also
+  // describes *what* happened to 'what', and explains *why* Google
+  // 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 FunctionMockerBase<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.
+      IncrementCallCount();
+      *what << "Mock function called more times than expected - ";
+      mocker->DescribeDefaultActionTo(args, what);
+      DescribeCallCountTo(why);
+
+      // TODO(wan@google.com): allow the user to control whether
+      // unexpected calls should fail immediately or continue using a
+      // flag --gmock_unexpected_calls_are_fatal.
+      return NULL;
+    }
+
+    IncrementCallCount();
+    RetireAllPreRequisites();
+
+    if (retires_on_saturation_ && IsSaturated()) {
+      Retire();
+    }
+
+    // Must be done after IncrementCount()!
+    *what << "Mock function call matches " << source_text() <<"...\n";
+    return &(GetCurrentAction(mocker, args));
+  }
+
+  // All the fields below won't change once the EXPECT_CALL()
+  // statement finishes.
+  FunctionMockerBase<F>* const owner_;
+  ArgumentMatcherTuple matchers_;
+  Matcher<const ArgumentTuple&> extra_matcher_;
+  Action<F> repeated_action_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
+};  // class TypedExpectation
+
+// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
+// specifying the default behavior of, or expectation on, a mock
+// function.
+
+// Note: class MockSpec really belongs to the ::testing namespace.
+// However if we define it in ::testing, MSVC will complain when
+// classes in ::testing::internal declare it as a friend class
+// template.  To workaround this compiler bug, we define MockSpec in
+// ::testing::internal and import it into ::testing.
+
+// Logs a message including file and line number information.
+GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
+                                const char* file, int line,
+                                const string& message);
+
+template <typename F>
+class MockSpec {
+ public:
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename internal::Function<F>::ArgumentMatcherTuple
+      ArgumentMatcherTuple;
+
+  // Constructs a MockSpec object, given the function mocker object
+  // that the spec is associated with.
+  explicit MockSpec(internal::FunctionMockerBase<F>* function_mocker)
+      : function_mocker_(function_mocker) {}
+
+  // 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,
+        string("ON_CALL(") + obj + ", " + call + ") invoked");
+    return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
+  }
+
+  // Adds a new expectation spec to the function mocker and returns
+  // the newly created spec.
+  internal::TypedExpectation<F>& InternalExpectedAt(
+      const char* file, int line, const char* obj, const char* call) {
+    const string source_text(string("EXPECT_CALL(") + obj + ", " + call + ")");
+    LogWithLocation(internal::kInfo, file, line, source_text + " invoked");
+    return function_mocker_->AddNewExpectation(
+        file, line, source_text, matchers_);
+  }
+
+ private:
+  template <typename Function>
+  friend class internal::FunctionMocker;
+
+  void SetMatchers(const ArgumentMatcherTuple& matchers) {
+    matchers_ = matchers;
+  }
+
+  // The function mocker that owns this spec.
+  internal::FunctionMockerBase<F>* const function_mocker_;
+  // The argument matchers specified in the spec.
+  ArgumentMatcherTuple matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(MockSpec);
+};  // class MockSpec
+
+// Wrapper type for generically holding an ordinary value or lvalue reference.
+// If T is not a reference type, it must be copyable or movable.
+// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless
+// T is a move-only value type (which means that it will always be copyable
+// if the current platform does not support move semantics).
+//
+// The primary template defines handling for values, but function header
+// comments describe the contract for the whole template (including
+// specializations).
+template <typename T>
+class ReferenceOrValueWrapper {
+ public:
+  // Constructs a wrapper from the given value/reference.
+  explicit ReferenceOrValueWrapper(T value)
+      : value_(::testing::internal::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 ::testing::internal::move(value_); }
+
+  // Provides nondestructive access to the underlying value/reference.
+  // Always returns a const reference (more precisely,
+  // const RemoveReference<T>&). The behavior of calling this after
+  // calling Unwrap on the same object is unspecified.
+  const T& Peek() const {
+    return value_;
+  }
+
+ private:
+  T value_;
+};
+
+// Specialization for lvalue reference types. See primary template
+// for documentation.
+template <typename T>
+class ReferenceOrValueWrapper<T&> {
+ public:
+  // Workaround for debatable pass-by-reference lint warning (c-library-team
+  // policy precludes NOLINT in this context)
+  typedef T& reference;
+  explicit ReferenceOrValueWrapper(reference ref)
+      : value_ptr_(&ref) {}
+  T& Unwrap() { return *value_ptr_; }
+  const T& Peek() const { return *value_ptr_; }
+
+ private:
+  T* value_ptr_;
+};
+
+// MSVC warns about using 'this' in base member initializer list, so
+// we need to temporarily disable the warning.  We have to do it for
+// the entire class to suppress the warning, even though it's about
+// the constructor only.
+
+#ifdef _MSC_VER
+# pragma warning(push)          // Saves the current warning state.
+# pragma warning(disable:4355)  // Temporarily disables warning 4355.
+#endif  // _MSV_VER
+
+// C++ treats the void type specially.  For example, you cannot define
+// a void-typed variable or pass a void value to a function.
+// ActionResultHolder<T> holds a value of type T, where T must be a
+// copyable type or void (T doesn't need to be default-constructable).
+// It hides the syntactic difference between void and other types, and
+// is used to unify the code for invoking both void-returning and
+// non-void-returning mock functions.
+
+// Untyped base class for ActionResultHolder<T>.
+class UntypedActionResultHolderBase {
+ public:
+  virtual ~UntypedActionResultHolderBase() {}
+
+  // Prints the held value as an action's result to os.
+  virtual void PrintAsActionResult(::std::ostream* os) const = 0;
+};
+
+// This generic definition is used when T is not void.
+template <typename T>
+class ActionResultHolder : public UntypedActionResultHolderBase {
+ public:
+  // Returns the held value. Must not be called more than once.
+  T Unwrap() {
+    return result_.Unwrap();
+  }
+
+  // Prints the held value as an action's result to os.
+  virtual void PrintAsActionResult(::std::ostream* os) const {
+    *os << "\n          Returns: ";
+    // T may be a reference type, so we don't use UniversalPrint().
+    UniversalPrinter<T>::Print(result_.Peek(), os);
+  }
+
+  // Performs the given mock function's default action and returns the
+  // result in a new-ed ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder* PerformDefaultAction(
+      const FunctionMockerBase<F>* func_mocker,
+      const typename Function<F>::ArgumentTuple& args,
+      const string& call_description) {
+    return new ActionResultHolder(Wrapper(
+        func_mocker->PerformDefaultAction(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,
+                const typename Function<F>::ArgumentTuple& args) {
+    return new ActionResultHolder(Wrapper(action.Perform(args)));
+  }
+
+ private:
+  typedef ReferenceOrValueWrapper<T> Wrapper;
+
+  explicit ActionResultHolder(Wrapper result)
+      : result_(::testing::internal::move(result)) {
+  }
+
+  Wrapper result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
+};
+
+// Specialization for T = void.
+template <>
+class ActionResultHolder<void> : public UntypedActionResultHolderBase {
+ public:
+  void Unwrap() { }
+
+  virtual void PrintAsActionResult(::std::ostream* /* os */) const {}
+
+  // Performs the given mock function's default action and returns ownership
+  // of an empty ActionResultHolder*.
+  template <typename F>
+  static ActionResultHolder* PerformDefaultAction(
+      const FunctionMockerBase<F>* func_mocker,
+      const typename Function<F>::ArgumentTuple& args,
+      const string& call_description) {
+    func_mocker->PerformDefaultAction(args, call_description);
+    return new ActionResultHolder;
+  }
+
+  // Performs the given action and returns ownership of an empty
+  // ActionResultHolder*.
+  template <typename F>
+  static ActionResultHolder* PerformAction(
+      const Action<F>& action,
+      const typename Function<F>::ArgumentTuple& args) {
+    action.Perform(args);
+    return new ActionResultHolder;
+  }
+
+ private:
+  ActionResultHolder() {}
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
+};
+
+// The base of the function mocker class for the given function type.
+// We put the methods in this class instead of its child to avoid code
+// bloat.
+template <typename F>
+class FunctionMockerBase : public UntypedFunctionMockerBase {
+ public:
+  typedef typename Function<F>::Result Result;
+  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
+
+  FunctionMockerBase() : current_spec_(this) {}
+
+  // 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.
+  virtual ~FunctionMockerBase()
+        GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    MutexLock l(&g_gmock_mutex);
+    VerifyAndClearExpectationsLocked();
+    Mock::UnregisterLocked(this);
+    ClearDefaultActionsLocked();
+  }
+
+  // Returns the ON_CALL spec that matches this mock function with the
+  // given arguments; returns NULL if no matching ON_CALL is found.
+  // L = *
+  const OnCallSpec<F>* FindOnCallSpec(
+      const ArgumentTuple& args) const {
+    for (UntypedOnCallSpecs::const_reverse_iterator it
+             = untyped_on_call_specs_.rbegin();
+         it != untyped_on_call_specs_.rend(); ++it) {
+      const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it);
+      if (spec->Matches(args))
+        return spec;
+    }
+
+    return NULL;
+  }
+
+  // Performs the default action of this mock function on the given
+  // arguments and returns the result. Asserts (or throws if
+  // exceptions are enabled) with a helpful call descrption if there
+  // is no valid return value. This method doesn't depend on the
+  // mutable state of this object, and thus can be called concurrently
+  // without locking.
+  // L = *
+  Result PerformDefaultAction(const ArgumentTuple& args,
+                              const string& call_description) const {
+    const OnCallSpec<F>* const spec =
+        this->FindOnCallSpec(args);
+    if (spec != NULL) {
+      return spec->GetAction().Perform(args);
+    }
+    const 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
+    if (!DefaultValue<Result>::Exists()) {
+      throw std::runtime_error(message);
+    }
+#else
+    Assert(DefaultValue<Result>::Exists(), "", -1, message);
+#endif
+    return DefaultValue<Result>::Get();
+  }
+
+  // Performs the default action with the given arguments and returns
+  // the action's result.  The call description string will be used in
+  // the error message to describe the call in the case the default
+  // action fails.  The caller is responsible for deleting the result.
+  // L = *
+  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
+      const void* untyped_args,  // must point to an ArgumentTuple
+      const string& call_description) const {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    return ResultHolder::PerformDefaultAction(this, 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 = *
+  virtual UntypedActionResultHolderBase* UntypedPerformAction(
+      const void* untyped_action, const void* untyped_args) const {
+    // 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);
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    return ResultHolder::PerformAction(action, args);
+  }
+
+  // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
+  // clears the ON_CALL()s set on this mock function.
+  virtual void ClearDefaultActionsLocked()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    // Deleting our default actions may trigger other mock objects to be
+    // deleted, for example if an action contains a reference counted smart
+    // pointer to that mock object, and that is the last reference. So if we
+    // delete our actions within the context of the global mutex we may deadlock
+    // when this method is called again. Instead, make a copy of the set of
+    // actions to delete, clear our set within the mutex, and then delete the
+    // actions outside of the mutex.
+    UntypedOnCallSpecs specs_to_delete;
+    untyped_on_call_specs_.swap(specs_to_delete);
+
+    g_gmock_mutex.Unlock();
+    for (UntypedOnCallSpecs::const_iterator it =
+             specs_to_delete.begin();
+         it != specs_to_delete.end(); ++it) {
+      delete static_cast<const OnCallSpec<F>*>(*it);
+    }
+
+    // Lock the mutex again, since the caller expects it to be locked when we
+    // return.
+    g_gmock_mutex.Lock();
+  }
+
+ protected:
+  template <typename Function>
+  friend class MockSpec;
+
+  typedef ActionResultHolder<Result> ResultHolder;
+
+  // Returns the result of invoking this mock function with the given
+  // arguments.  This function can be safely called from multiple
+  // threads concurrently.
+  Result InvokeWith(const ArgumentTuple& args)
+        GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    scoped_ptr<ResultHolder> holder(
+        DownCast_<ResultHolder*>(this->UntypedInvokeWith(&args)));
+    return holder->Unwrap();
+  }
+
+  // Adds and returns a default action spec for this mock function.
+  OnCallSpec<F>& AddNewOnCallSpec(
+      const char* file, int line,
+      const ArgumentMatcherTuple& m)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
+    OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m);
+    untyped_on_call_specs_.push_back(on_call_spec);
+    return *on_call_spec;
+  }
+
+  // Adds and returns an expectation spec for this mock function.
+  TypedExpectation<F>& AddNewExpectation(
+      const char* file,
+      int line,
+      const 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 linked_ptr<ExpectationBase> untyped_expectation(expectation);
+    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 != NULL) {
+      implicit_sequence->AddExpectation(Expectation(untyped_expectation));
+    }
+
+    return *expectation;
+  }
+
+  // The current spec (either default action spec or expectation spec)
+  // being described on this function mocker.
+  MockSpec<F>& current_spec() { return current_spec_; }
+
+ private:
+  template <typename Func> friend class TypedExpectation;
+
+  // Some utilities needed for implementing UntypedInvokeWith().
+
+  // Describes what default action will be performed for the given
+  // arguments.
+  // L = *
+  void DescribeDefaultActionTo(const ArgumentTuple& args,
+                               ::std::ostream* os) const {
+    const OnCallSpec<F>* const spec = FindOnCallSpec(args);
+
+    if (spec == NULL) {
+      *os << (internal::type_equals<Result, void>::value ?
+              "returning directly.\n" :
+              "returning default value.\n");
+    } else {
+      *os << "taking default action specified at:\n"
+          << FormatFileLocation(spec->file(), spec->line()) << "\n";
+    }
+  }
+
+  // Writes a message that the call is uninteresting (i.e. neither
+  // explicitly expected nor explicitly unexpected) to the given
+  // ostream.
+  virtual void UntypedDescribeUninterestingCall(
+      const void* untyped_args,
+      ::std::ostream* os) const
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    *os << "Uninteresting mock function call - ";
+    DescribeDefaultActionTo(args, os);
+    *os << "    Function call: " << Name();
+    UniversalPrint(args, os);
+  }
+
+  // Returns the expectation that matches the given function arguments
+  // (or NULL is there's no match); when a match is found,
+  // untyped_action is set to point to the action that should be
+  // performed (or NULL if the action is "do default"), and
+  // is_excessive is modified to indicate whether the call exceeds the
+  // expected number.
+  //
+  // Critical section: We must find the matching expectation and the
+  // corresponding action that needs to be taken in an ATOMIC
+  // transaction.  Otherwise another thread may call this mock
+  // method in the middle and mess up the state.
+  //
+  // However, performing the action has to be left out of the critical
+  // 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.
+  virtual const ExpectationBase* UntypedFindMatchingExpectation(
+      const void* untyped_args,
+      const void** untyped_action, bool* is_excessive,
+      ::std::ostream* what, ::std::ostream* why)
+          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 == NULL) {  // A match wasn't found.
+      this->FormatUnexpectedCallMessageLocked(args, what, why);
+      return NULL;
+    }
+
+    // This line must be done before calling GetActionForArguments(),
+    // which will increment the call count for *exp and thus affect
+    // its saturation status.
+    *is_excessive = exp->IsSaturated();
+    const Action<F>* action = exp->GetActionForArguments(this, args, what, why);
+    if (action != NULL && action->IsDoDefault())
+      action = NULL;  // Normalize "do default" to NULL.
+    *untyped_action = action;
+    return exp;
+  }
+
+  // Prints the given function arguments to the ostream.
+  virtual void UntypedPrintArgs(const void* untyped_args,
+                                ::std::ostream* os) const {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    UniversalPrint(args, os);
+  }
+
+  // Returns the expectation that matches the arguments, or NULL if no
+  // expectation matches them.
+  TypedExpectation<F>* FindMatchingExpectationLocked(
+      const ArgumentTuple& args) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    for (typename UntypedExpectations::const_reverse_iterator it =
+             untyped_expectations_.rbegin();
+         it != untyped_expectations_.rend(); ++it) {
+      TypedExpectation<F>* const exp =
+          static_cast<TypedExpectation<F>*>(it->get());
+      if (exp->ShouldHandleArguments(args)) {
+        return exp;
+      }
+    }
+    return NULL;
+  }
+
+  // Returns a message that the arguments don't match any expectation.
+  void FormatUnexpectedCallMessageLocked(
+      const ArgumentTuple& args,
+      ::std::ostream* os,
+      ::std::ostream* why) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    *os << "\nUnexpected mock function call - ";
+    DescribeDefaultActionTo(args, os);
+    PrintTriedExpectationsLocked(args, why);
+  }
+
+  // Prints a list of expectations that have been tried against the
+  // current mock function call.
+  void PrintTriedExpectationsLocked(
+      const ArgumentTuple& args,
+      ::std::ostream* why) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    const int count = static_cast<int>(untyped_expectations_.size());
+    *why << "Google Mock tried the following " << count << " "
+         << (count == 1 ? "expectation, but it didn't match" :
+             "expectations, but none matched")
+         << ":\n";
+    for (int i = 0; i < count; i++) {
+      TypedExpectation<F>* const expectation =
+          static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get());
+      *why << "\n";
+      expectation->DescribeLocationTo(why);
+      if (count > 1) {
+        *why << "tried expectation #" << i << ": ";
+      }
+      *why << expectation->source_text() << "...\n";
+      expectation->ExplainMatchResultTo(args, why);
+      expectation->DescribeCallCountTo(why);
+    }
+  }
+
+  // The current spec (either default action spec or expectation spec)
+  // being described on this function mocker.
+  MockSpec<F> current_spec_;
+
+  // 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, he should implement his own copy
+  // operation, for example:
+  //
+  //   class MockFoo : public Foo {
+  //    public:
+  //     // Defines a copy constructor explicitly.
+  //     MockFoo(const MockFoo& src) {}
+  //     ...
+  //   };
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(FunctionMockerBase);
+};  // class FunctionMockerBase
+
+#ifdef _MSC_VER
+# pragma warning(pop)  // Restores the warning state.
+#endif  // _MSV_VER
+
+// Implements methods of FunctionMockerBase.
+
+// Verifies that all expectations on this mock function have been
+// satisfied.  Reports one or more Google Test non-fatal failures and
+// returns false if not.
+
+// Reports an uninteresting call (whose description is in msg) in the
+// manner specified by 'reaction'.
+void ReportUninterestingCall(CallReaction reaction, const string& msg);
+
+}  // namespace internal
+
+// 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
+// is just a trick for working around a bug in MSVC 8.0, which cannot
+// handle it if we define MockSpec in ::testing.
+using internal::MockSpec;
+
+// Const(x) is a convenient function for obtaining a const reference
+// to x.  This is useful for setting expectations on an overloaded
+// const mock method, e.g.
+//
+//   class MockFoo : public FooInterface {
+//    public:
+//     MOCK_METHOD0(Bar, int());
+//     MOCK_CONST_METHOD0(Bar, int&());
+//   };
+//
+//   MockFoo foo;
+//   // Expects a call to non-const MockFoo::Bar().
+//   EXPECT_CALL(foo, Bar());
+//   // Expects a call to const MockFoo::Bar().
+//   EXPECT_CALL(Const(foo), Bar());
+template <typename T>
+inline const T& Const(const T& x) { return x; }
+
+// Constructs an Expectation object that references and co-owns exp.
+inline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT
+    : expectation_base_(exp.GetHandle().expectation_base()) {}
+
+}  // namespace testing
+
+// 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.
+#define GMOCK_ON_CALL_IMPL_(obj, call) \
+    ((obj).gmock_##call).InternalDefaultActionSetAt(__FILE__, __LINE__, \
+                                                    #obj, #call)
+#define ON_CALL(obj, call) GMOCK_ON_CALL_IMPL_(obj, call)
+
+#define GMOCK_EXPECT_CALL_IMPL_(obj, call) \
+    ((obj).gmock_##call).InternalExpectedAt(__FILE__, __LINE__, #obj, #call)
+#define EXPECT_CALL(obj, call) GMOCK_EXPECT_CALL_IMPL_(obj, call)
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock.h
new file mode 100644
index 00000000..6735c71b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock.h
@@ -0,0 +1,94 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This is the main header file a user should include.
+
+#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_H_
+#define GMOCK_INCLUDE_GMOCK_GMOCK_H_
+
+// This file implements the following syntax:
+//
+//   ON_CALL(mock_object.Method(...))
+//     .With(...) ?
+//     .WillByDefault(...);
+//
+// where With() is optional and WillByDefault() must appear exactly
+// once.
+//
+//   EXPECT_CALL(mock_object.Method(...))
+//     .With(...) ?
+//     .Times(...) ?
+//     .InSequence(...) *
+//     .WillOnce(...) *
+//     .WillRepeatedly(...) ?
+//     .RetiresOnSaturation() ? ;
+//
+// where all clauses are optional and WillOnce() can be repeated.
+
+#include "gmock/gmock-actions.h"
+#include "gmock/gmock-cardinalities.h"
+#include "gmock/gmock-generated-actions.h"
+#include "gmock/gmock-generated-function-mockers.h"
+#include "gmock/gmock-generated-nice-strict.h"
+#include "gmock/gmock-generated-matchers.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock-more-actions.h"
+#include "gmock/gmock-more-matchers.h"
+#include "gmock/internal/gmock-internal-utils.h"
+
+namespace testing {
+
+// Declares Google Mock flags that we want a user to use programmatically.
+GMOCK_DECLARE_bool_(catch_leaked_mocks);
+GMOCK_DECLARE_string_(verbose);
+
+// Initializes Google Mock.  This must be called before running the
+// tests.  In particular, it parses the command line for the flags
+// that Google Mock recognizes.  Whenever a Google Mock flag is seen,
+// it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Mock flag variables are
+// updated.
+//
+// Since Google Test is needed for Google Mock to work, this function
+// also initializes Google Test and parses its flags, if that hasn't
+// been done.
+GTEST_API_ void InitGoogleMock(int* argc, char** argv);
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv);
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
new file mode 100644
index 00000000..7dc3b1ad
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
@@ -0,0 +1,8 @@
+// This file was GENERATED by command:
+//     pump.py gmock-generated-actions.h.pump
+// DO NOT EDIT BY HAND!!!
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+
+#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump
new file mode 100644
index 00000000..d26c8a08
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump
@@ -0,0 +1,10 @@
+$$ -*- mode: c++; -*-
+$$ This is a Pump source file (http://go/pump).  Please use Pump to convert
+$$ it to callback-actions.h.
+$$
+$var max_callback_arity = 5
+$$}} This meta comment fixes auto-indentation in editors.
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+
+#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h
new file mode 100644
index 00000000..f2efef91
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h
@@ -0,0 +1,39 @@
+// Copyright 2015, 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.
+//
+// ============================================================
+// An installation-specific extension point for gmock-matchers.h.
+// ============================================================
+//
+// Adds google3 callback support to CallableTraits.
+//
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
+
+#endif  //  GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-port.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-port.h
new file mode 100644
index 00000000..9ce8bfe0
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-port.h
@@ -0,0 +1,46 @@
+// Copyright 2015, 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.
+//
+// Injection point for custom user configurations.
+// The following macros can be defined:
+//
+//   Flag related macros:
+//     GMOCK_DECLARE_bool_(name)
+//     GMOCK_DECLARE_int32_(name)
+//     GMOCK_DECLARE_string_(name)
+//     GMOCK_DEFINE_bool_(name, default_val, doc)
+//     GMOCK_DEFINE_int32_(name, default_val, doc)
+//     GMOCK_DEFINE_string_(name, default_val, doc)
+//
+// ** Custom implementation starts here **
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+
+#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h
new file mode 100644
index 00000000..7811e43f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h
@@ -0,0 +1,279 @@
+// This file was GENERATED by command:
+//     pump.py gmock-generated-internal-utils.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file contains template meta-programming utility classes needed
+// for implementing Google Mock.
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
+
+#include "gmock/internal/gmock-port.h"
+
+namespace testing {
+
+template <typename T>
+class Matcher;
+
+namespace internal {
+
+// An IgnoredValue object can be implicitly constructed from ANY value.
+// This is used in implementing the IgnoreResult(a) action.
+class IgnoredValue {
+ 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.
+  template <typename T>
+  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
+};
+
+// MatcherTuple<T>::type is a tuple type where each field is a Matcher
+// for the corresponding field in tuple type T.
+template <typename Tuple>
+struct MatcherTuple;
+
+template <>
+struct MatcherTuple< ::testing::tuple<> > {
+  typedef ::testing::tuple< > type;
+};
+
+template <typename A1>
+struct MatcherTuple< ::testing::tuple<A1> > {
+  typedef ::testing::tuple<Matcher<A1> > type;
+};
+
+template <typename A1, typename A2>
+struct MatcherTuple< ::testing::tuple<A1, A2> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2> > type;
+};
+
+template <typename A1, typename A2, typename A3>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
+      Matcher<A4> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
+      Matcher<A5> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
+      Matcher<A5>, Matcher<A6> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6, typename A7>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
+      Matcher<A5>, Matcher<A6>, Matcher<A7> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6, typename A7, typename A8>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
+      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6, typename A7, typename A8, typename A9>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
+      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9> > type;
+};
+
+template <typename A1, typename A2, typename A3, typename A4, typename A5,
+    typename A6, typename A7, typename A8, typename A9, typename A10>
+struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
+    A10> > {
+  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
+      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9>,
+      Matcher<A10> > type;
+};
+
+// Template struct Function<F>, where F must be a function type, contains
+// the following typedefs:
+//
+//   Result:               the function's return type.
+//   ArgumentN:            the type of the N-th argument, where N starts with 1.
+//   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 F>
+struct Function;
+
+template <typename R>
+struct Function<R()> {
+  typedef R Result;
+  typedef ::testing::tuple<> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid();
+  typedef IgnoredValue MakeResultIgnoredValue();
+};
+
+template <typename R, typename A1>
+struct Function<R(A1)>
+    : Function<R()> {
+  typedef A1 Argument1;
+  typedef ::testing::tuple<A1> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1);
+  typedef IgnoredValue MakeResultIgnoredValue(A1);
+};
+
+template <typename R, typename A1, typename A2>
+struct Function<R(A1, A2)>
+    : Function<R(A1)> {
+  typedef A2 Argument2;
+  typedef ::testing::tuple<A1, A2> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2);
+};
+
+template <typename R, typename A1, typename A2, typename A3>
+struct Function<R(A1, A2, A3)>
+    : Function<R(A1, A2)> {
+  typedef A3 Argument3;
+  typedef ::testing::tuple<A1, A2, A3> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4>
+struct Function<R(A1, A2, A3, A4)>
+    : Function<R(A1, A2, A3)> {
+  typedef A4 Argument4;
+  typedef ::testing::tuple<A1, A2, A3, A4> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5>
+struct Function<R(A1, A2, A3, A4, A5)>
+    : Function<R(A1, A2, A3, A4)> {
+  typedef A5 Argument5;
+  typedef ::testing::tuple<A1, A2, A3, A4, A5> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4, A5);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6>
+struct Function<R(A1, A2, A3, A4, A5, A6)>
+    : Function<R(A1, A2, A3, A4, A5)> {
+  typedef A6 Argument6;
+  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7>
+struct Function<R(A1, A2, A3, A4, A5, A6, A7)>
+    : Function<R(A1, A2, A3, A4, A5, A6)> {
+  typedef A7 Argument7;
+  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8>
+struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8)>
+    : Function<R(A1, A2, A3, A4, A5, A6, A7)> {
+  typedef A8 Argument8;
+  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8, typename A9>
+struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
+    : Function<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
+  typedef A9 Argument9;
+  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
+      A9);
+};
+
+template <typename R, typename A1, typename A2, typename A3, typename A4,
+    typename A5, typename A6, typename A7, typename A8, typename A9,
+    typename A10>
+struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
+    : Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
+  typedef A10 Argument10;
+  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
+      A10> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
+      A9, A10);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h.pump b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h.pump
new file mode 100644
index 00000000..800af17c
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h.pump
@@ -0,0 +1,136 @@
+$$ -*- mode: c++; -*-
+$$ This is a Pump source file.  Please use Pump to convert it to
+$$ gmock-generated-function-mockers.h.
+$$
+$var n = 10  $$ The maximum arity we support.
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file contains template meta-programming utility classes needed
+// for implementing Google Mock.
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
+
+#include "gmock/internal/gmock-port.h"
+
+namespace testing {
+
+template <typename T>
+class Matcher;
+
+namespace internal {
+
+// An IgnoredValue object can be implicitly constructed from ANY value.
+// This is used in implementing the IgnoreResult(a) action.
+class IgnoredValue {
+ 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.
+  template <typename T>
+  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
+};
+
+// MatcherTuple<T>::type is a tuple type where each field is a Matcher
+// for the corresponding field in tuple type T.
+template <typename Tuple>
+struct MatcherTuple;
+
+
+$range i 0..n
+$for i [[
+$range j 1..i
+$var typename_As = [[$for j, [[typename A$j]]]]
+$var As = [[$for j, [[A$j]]]]
+$var matcher_As = [[$for j, [[Matcher<A$j>]]]]
+template <$typename_As>
+struct MatcherTuple< ::testing::tuple<$As> > {
+  typedef ::testing::tuple<$matcher_As > type;
+};
+
+
+]]
+// Template struct Function<F>, where F must be a function type, contains
+// the following typedefs:
+//
+//   Result:               the function's return type.
+//   ArgumentN:            the type of the N-th argument, where N starts with 1.
+//   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 F>
+struct Function;
+
+template <typename R>
+struct Function<R()> {
+  typedef R Result;
+  typedef ::testing::tuple<> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid();
+  typedef IgnoredValue MakeResultIgnoredValue();
+};
+
+
+$range i 1..n
+$for i [[
+$range j 1..i
+$var typename_As = [[$for j [[, typename A$j]]]]
+$var As = [[$for j, [[A$j]]]]
+$var matcher_As = [[$for j, [[Matcher<A$j>]]]]
+$range k 1..i-1
+$var prev_As = [[$for k, [[A$k]]]]
+template <typename R$typename_As>
+struct Function<R($As)>
+    : Function<R($prev_As)> {
+  typedef A$i Argument$i;
+  typedef ::testing::tuple<$As> ArgumentTuple;
+  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
+  typedef void MakeResultVoid($As);
+  typedef IgnoredValue MakeResultIgnoredValue($As);
+};
+
+
+]]
+}  // namespace internal
+
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
new file mode 100644
index 00000000..e2ddb05c
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
@@ -0,0 +1,511 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// 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.
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+
+#include <stdio.h>
+#include <ostream>  // NOLINT
+#include <string>
+
+#include "gmock/internal/gmock-generated-internal-utils.h"
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+namespace internal {
+
+// 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_ string ConvertIdentifierNameToWords(const char* id_name);
+
+// PointeeOf<Pointer>::type is the type of a value pointed to by a
+// Pointer, which can be either a smart pointer or a raw pointer.  The
+// following default implementation is for the case where Pointer is a
+// smart pointer.
+template <typename Pointer>
+struct PointeeOf {
+  // Smart pointer classes define type element_type as the type of
+  // their pointees.
+  typedef typename Pointer::element_type type;
+};
+// This specialization is for the raw pointer case.
+template <typename T>
+struct PointeeOf<T*> { typedef T type; };  // NOLINT
+
+// 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.
+// The following default implementation is for the smart pointer case.
+template <typename Pointer>
+inline const typename Pointer::element_type* GetRawPointer(const Pointer& p) {
+  return p.get();
+}
+// This overloaded version is for the raw pointer case.
+template <typename Element>
+inline Element* GetRawPointer(Element* p) { return p; }
+
+// This comparator allows linked_ptr to be stored in sets.
+template <typename T>
+struct LinkedPtrLessThan {
+  bool operator()(const ::testing::internal::linked_ptr<T>& lhs,
+                  const ::testing::internal::linked_ptr<T>& rhs) const {
+    return lhs.get() < rhs.get();
+  }
+};
+
+// Symbian compilation can be done with wchar_t being either a native
+// type or a typedef.  Using Google Mock with OpenC without wchar_t
+// should require the definition of _STLP_NO_WCHAR_T.
+//
+// MSVC treats wchar_t as a native type usually, but treats it as the
+// 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 (GTEST_OS_SYMBIAN && defined(_STLP_NO_WCHAR_T)) || \
+    (defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED))
+// wchar_t is a typedef.
+#else
+# define GMOCK_WCHAR_T_IS_NATIVE_ 1
+#endif
+
+// signed wchar_t and unsigned wchar_t are NOT in the C++ standard.
+// Using them is a bad practice and not portable.  So DON'T use them.
+//
+// Still, Google Mock is designed to work even if the user uses signed
+// wchar_t or unsigned wchar_t (obviously, assuming the compiler
+// supports them).
+//
+// To gcc,
+//   wchar_t == signed wchar_t != unsigned wchar_t == unsigned int
+#ifdef __GNUC__
+// signed/unsigned wchar_t are valid types.
+# define GMOCK_HAS_SIGNED_WCHAR_T_ 1
+#endif
+
+// In what follows, we use the term "kind" to indicate whether a type
+// is bool, an integer type (excluding bool), a floating-point type,
+// or none of them.  This categorization is useful for determining
+// when a matcher argument type can be safely converted to another
+// type in the implementation of SafeMatcherCast.
+enum TypeKind {
+  kBool, kInteger, kFloatingPoint, kOther
+};
+
+// KindOf<T>::value is the kind of type T.
+template <typename T> struct KindOf {
+  enum { value = kOther };  // The default kind.
+};
+
+// This macro declares that the kind of 'type' is 'kind'.
+#define GMOCK_DECLARE_KIND_(type, kind) \
+  template <> struct KindOf<type> { enum { value = kind }; }
+
+GMOCK_DECLARE_KIND_(bool, kBool);
+
+// All standard integer types.
+GMOCK_DECLARE_KIND_(char, kInteger);
+GMOCK_DECLARE_KIND_(signed char, kInteger);
+GMOCK_DECLARE_KIND_(unsigned char, kInteger);
+GMOCK_DECLARE_KIND_(short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(int, kInteger);
+GMOCK_DECLARE_KIND_(unsigned int, kInteger);
+GMOCK_DECLARE_KIND_(long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned long, kInteger);  // NOLINT
+
+#if GMOCK_WCHAR_T_IS_NATIVE_
+GMOCK_DECLARE_KIND_(wchar_t, kInteger);
+#endif
+
+// Non-standard integer types.
+GMOCK_DECLARE_KIND_(Int64, kInteger);
+GMOCK_DECLARE_KIND_(UInt64, kInteger);
+
+// All standard floating-point types.
+GMOCK_DECLARE_KIND_(float, kFloatingPoint);
+GMOCK_DECLARE_KIND_(double, kFloatingPoint);
+GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
+
+#undef GMOCK_DECLARE_KIND_
+
+// Evaluates to the kind of 'type'.
+#define GMOCK_KIND_OF_(type) \
+  static_cast< ::testing::internal::TypeKind>( \
+      ::testing::internal::KindOf<type>::value)
+
+// Evaluates to true iff integer type T is signed.
+#define GMOCK_IS_SIGNED_(T) (static_cast<T>(-1) < 0)
+
+// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value
+// is true iff 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, kFromKind is the kind of
+// 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>
+struct LosslessArithmeticConvertibleImpl : public false_type {};
+
+// Converting bool to bool is lossless.
+template <>
+struct LosslessArithmeticConvertibleImpl<kBool, bool, kBool, bool>
+    : public true_type {};  // NOLINT
+
+// Converting bool to any integer type is lossless.
+template <typename To>
+struct LosslessArithmeticConvertibleImpl<kBool, bool, kInteger, To>
+    : public true_type {};  // NOLINT
+
+// Converting bool to any floating-point type is lossless.
+template <typename To>
+struct LosslessArithmeticConvertibleImpl<kBool, bool, kFloatingPoint, To>
+    : public true_type {};  // NOLINT
+
+// Converting an integer to bool is lossy.
+template <typename From>
+struct LosslessArithmeticConvertibleImpl<kInteger, From, kBool, bool>
+    : public false_type {};  // NOLINT
+
+// Converting an integer to another non-bool integer is lossless iff
+// the target type's range encloses the source type's range.
+template <typename From, typename To>
+struct LosslessArithmeticConvertibleImpl<kInteger, From, kInteger, To>
+    : public bool_constant<
+      // When converting from a smaller size to a larger size, we are
+      // fine as long as we are not converting from signed to unsigned.
+      ((sizeof(From) < sizeof(To)) &&
+       (!GMOCK_IS_SIGNED_(From) || GMOCK_IS_SIGNED_(To))) ||
+      // When converting between the same size, the signedness must match.
+      ((sizeof(From) == sizeof(To)) &&
+       (GMOCK_IS_SIGNED_(From) == GMOCK_IS_SIGNED_(To)))> {};  // NOLINT
+
+#undef GMOCK_IS_SIGNED_
+
+// Converting an integer to a floating-point type may be lossy, since
+// the format of a floating-point number is implementation-defined.
+template <typename From, typename To>
+struct LosslessArithmeticConvertibleImpl<kInteger, From, kFloatingPoint, To>
+    : public false_type {};  // NOLINT
+
+// Converting a floating-point to bool is lossy.
+template <typename From>
+struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kBool, bool>
+    : public false_type {};  // NOLINT
+
+// Converting a floating-point to an integer is lossy.
+template <typename From, typename To>
+struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kInteger, To>
+    : public false_type {};  // NOLINT
+
+// Converting a floating-point to another floating-point is lossless
+// iff the target type is at least as big as the source type.
+template <typename From, typename To>
+struct LosslessArithmeticConvertibleImpl<
+  kFloatingPoint, From, kFloatingPoint, To>
+    : public bool_constant<sizeof(From) <= sizeof(To)> {};  // NOLINT
+
+// LosslessArithmeticConvertible<From, To>::value is true iff 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>
+struct LosslessArithmeticConvertible
+    : public LosslessArithmeticConvertibleImpl<
+  GMOCK_KIND_OF_(From), From, GMOCK_KIND_OF_(To), To> {};  // NOLINT
+
+// This interface knows how to report a Google Mock failure (either
+// non-fatal or fatal).
+class FailureReporterInterface {
+ public:
+  // The type of a failure (either non-fatal or fatal).
+  enum FailureType {
+    kNonfatal, kFatal
+  };
+
+  virtual ~FailureReporterInterface() {}
+
+  // Reports a failure that occurred at the given source file location.
+  virtual void ReportFailure(FailureType type, const char* file, int line,
+                             const string& message) = 0;
+};
+
+// Returns the failure reporter used by Google Mock.
+GTEST_API_ FailureReporterInterface* GetFailureReporter();
+
+// Asserts that condition is true; aborts the process with the given
+// message if condition is false.  We cannot use LOG(FATAL) or CHECK()
+// as Google Mock might be used to mock the log sink itself.  We
+// inline this function to prevent it from showing up in the stack
+// trace.
+inline void Assert(bool condition, const char* file, int line,
+                   const string& msg) {
+  if (!condition) {
+    GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal,
+                                        file, line, msg);
+  }
+}
+inline void Assert(bool condition, const char* file, int line) {
+  Assert(condition, file, line, "Assertion failed.");
+}
+
+// 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 string& msg) {
+  if (!condition) {
+    GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal,
+                                        file, line, msg);
+  }
+}
+inline void Expect(bool condition, const char* file, int line) {
+  Expect(condition, file, line, "Expectation failed.");
+}
+
+// Severity level of a log.
+enum LogSeverity {
+  kInfo = 0,
+  kWarning = 1
+};
+
+// Valid values for the --gmock_verbose flag.
+
+// All logs (informational and warnings) are printed.
+const char kInfoVerbosity[] = "info";
+// Only warnings are printed.
+const char kWarningVerbosity[] = "warning";
+// No logs are printed.
+const char kErrorVerbosity[] = "error";
+
+// Returns true iff 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 iff '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 string& message,
+                    int stack_frames_to_skip);
+
+// TODO(wan@google.com): group all type utilities together.
+
+// Type traits.
+
+// is_reference<T>::value is non-zero iff T is a reference type.
+template <typename T> struct is_reference : public false_type {};
+template <typename T> struct is_reference<T&> : public true_type {};
+
+// type_equals<T1, T2>::value is non-zero iff T1 and T2 are the same type.
+template <typename T1, typename T2> struct type_equals : public false_type {};
+template <typename T> struct type_equals<T, T> : public true_type {};
+
+// remove_reference<T>::type removes the reference from type T, if any.
+template <typename T> struct remove_reference { typedef T type; };  // NOLINT
+template <typename T> struct remove_reference<T&> { typedef T type; }; // NOLINT
+
+// DecayArray<T>::type turns an array type U[N] to const U* and preserves
+// other types.  Useful for saving a copy of a function argument.
+template <typename T> struct DecayArray { typedef T type; };  // NOLINT
+template <typename T, size_t N> struct DecayArray<T[N]> {
+  typedef const T* type;
+};
+// Sometimes people use arrays whose size is not available at the use site
+// (e.g. extern const char kNamePrefix[]).  This specialization covers that
+// case.
+template <typename T> struct DecayArray<T[]> {
+  typedef const T* type;
+};
+
+// Disable MSVC warnings for infinite recursion, since in this case the
+// the recursion is unreachable.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4717)
+#endif
+
+// Invalid<T>() is usable as an expression of type T, but will terminate
+// the program with an assertion failure if actually run.  This is useful
+// when a value of type T is needed for compilation, but the statement
+// will not really be executed (or we don't care if the statement
+// crashes).
+template <typename T>
+inline T Invalid() {
+  Assert(false, "", -1, "Internal error: attempt to return invalid value");
+  // This statement is unreachable, and would never terminate even if it
+  // could be reached. It is provided only to placate compiler warnings
+  // about missing return statements.
+  return Invalid<T>();
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+// Given a raw type (i.e. having no top-level reference or const
+// modifier) RawContainer that's either an STL-style container or a
+// native array, class StlContainerView<RawContainer> has the
+// following members:
+//
+//   - type is a type that provides an STL-style container view to
+//     (i.e. implements the STL container concept for) RawContainer;
+//   - const_reference is a type that provides a reference to a const
+//     RawContainer;
+//   - ConstReference(raw_container) returns a const reference to an STL-style
+//     container view to raw_container, which is a RawContainer.
+//   - Copy(raw_container) returns an STL-style container view of a
+//     copy of raw_container, which is a RawContainer.
+//
+// This generic version is used when RawContainer itself is already an
+// STL-style container.
+template <class RawContainer>
+class StlContainerView {
+ public:
+  typedef RawContainer type;
+  typedef const type& const_reference;
+
+  static const_reference ConstReference(const RawContainer& container) {
+    // Ensures that RawContainer is not a const type.
+    testing::StaticAssertTypeEq<RawContainer,
+        GTEST_REMOVE_CONST_(RawContainer)>();
+    return container;
+  }
+  static type Copy(const RawContainer& container) { return container; }
+};
+
+// This specialization is used when RawContainer is a native array type.
+template <typename Element, size_t N>
+class StlContainerView<Element[N]> {
+ public:
+  typedef GTEST_REMOVE_CONST_(Element) 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'
+  // can be used to reference a const native array.  We cannot
+  // 'typedef const type& const_reference' here, as that would mean
+  // ConstReference() has to return a reference to a local variable.
+  typedef const type const_reference;
+
+  static const_reference ConstReference(const Element (&array)[N]) {
+    // Ensures that Element is not a const type.
+    testing::StaticAssertTypeEq<Element, RawElement>();
+#if GTEST_OS_SYMBIAN
+    // The Nokia Symbian compiler confuses itself in template instantiation
+    // for this call without the cast to Element*:
+    // function call '[testing::internal::NativeArray<char *>].NativeArray(
+    //     {lval} const char *[4], long, testing::internal::RelationToSource)'
+    //     does not match
+    // 'testing::internal::NativeArray<char *>::NativeArray(
+    //     char *const *, unsigned int, testing::internal::RelationToSource)'
+    // (instantiating: 'testing::internal::ContainsMatcherImpl
+    //     <const char * (&)[4]>::Matches(const char * (&)[4]) const')
+    // (instantiating: 'testing::internal::StlContainerView<char *[4]>::
+    //     ConstReference(const char * (&)[4])')
+    // (and though the N parameter type is mismatched in the above explicit
+    // conversion of it doesn't help - only the conversion of the array).
+    return type(const_cast<Element*>(&array[0]), N,
+                RelationToSourceReference());
+#else
+    return type(array, N, RelationToSourceReference());
+#endif  // GTEST_OS_SYMBIAN
+  }
+  static type Copy(const Element (&array)[N]) {
+#if GTEST_OS_SYMBIAN
+    return type(const_cast<Element*>(&array[0]), N, RelationToSourceCopy());
+#else
+    return type(array, N, RelationToSourceCopy());
+#endif  // GTEST_OS_SYMBIAN
+  }
+};
+
+// This specialization is used when RawContainer is a native array
+// represented as a (pointer, size) tuple.
+template <typename ElementPointer, typename Size>
+class StlContainerView< ::testing::tuple<ElementPointer, Size> > {
+ public:
+  typedef GTEST_REMOVE_CONST_(
+      typename internal::PointeeOf<ElementPointer>::type) RawElement;
+  typedef internal::NativeArray<RawElement> type;
+  typedef const type const_reference;
+
+  static const_reference ConstReference(
+      const ::testing::tuple<ElementPointer, Size>& array) {
+    return type(get<0>(array), get<1>(array), RelationToSourceReference());
+  }
+  static type Copy(const ::testing::tuple<ElementPointer, Size>& array) {
+    return type(get<0>(array), get<1>(array), RelationToSourceCopy());
+  }
+};
+
+// The following specialization prevents the user from instantiating
+// StlContainer with a reference type.
+template <typename T> class StlContainerView<T&>;
+
+// A type transform to remove constness from the first part of a pair.
+// Pairs like that are used as the value_type of associative containers,
+// and this transform produces a similar but assignable pair.
+template <typename T>
+struct RemoveConstFromKey {
+  typedef T type;
+};
+
+// Partially specialized to remove constness from std::pair<const K, V>.
+template <typename K, typename V>
+struct RemoveConstFromKey<std::pair<const K, V> > {
+  typedef std::pair<K, V> type;
+};
+
+// Mapping from booleans to types. Similar to boost::bool_<kValue> and
+// std::integral_constant<bool, kValue>.
+template <bool kValue>
+struct BooleanConstant {};
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-port.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-port.h
new file mode 100644
index 00000000..63f4a680
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-port.h
@@ -0,0 +1,91 @@
+// 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.
+//
+// Author: vadimb@google.com (Vadim Berman)
+//
+// Low-level types and utilities for porting Google Mock to various
+// platforms.  All macros ending with _ and symbols defined in an
+// internal namespace are subject to change without notice.  Code
+// outside Google Mock MUST NOT USE THEM DIRECTLY.  Macros that don't
+// end with _ are part of Google Mock's public API and can be used by
+// code outside Google Mock.
+
+#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+
+#include <assert.h>
+#include <stdlib.h>
+#include <iostream>
+
+// Most of the utilities needed for porting Google Mock are also
+// required for Google Test and are defined in gtest-port.h.
+//
+// Note to maintainers: to reduce code duplication, prefer adding
+// 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-linked_ptr.h"
+#include "gtest/internal/gtest-port.h"
+#include "gmock/internal/custom/gmock-port.h"
+
+// To avoid conditional compilation everywhere, we make it
+// gmock-port.h's responsibility to #include the header implementing
+// tr1/tuple.  gmock-port.h does this via gtest-port.h, which is
+// guaranteed to pull in the tuple header.
+
+// For MS Visual C++, check the compiler version. At least VS 2003 is
+// required to compile Google Mock.
+#if defined(_MSC_VER) && _MSC_VER < 1310
+# error "At least Visual C++ 2003 (7.1) is required to compile Google Mock."
+#endif
+
+// Macro for referencing flags.  This is public as we want the user to
+// use this syntax to reference Google Mock flags.
+#define GMOCK_FLAG(name) FLAGS_gmock_##name
+
+#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_ ::testing::internal::Int32 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) \
+    GTEST_API_ bool GMOCK_FLAG(name) = (default_val)
+#define GMOCK_DEFINE_int32_(name, default_val, doc) \
+    GTEST_API_ ::testing::internal::Int32 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  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/make/Makefile b/week4/softwareEng_9_4/vendor/googletest/googlemock/make/Makefile
new file mode 100644
index 00000000..7c13e05f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/make/Makefile
@@ -0,0 +1,101 @@
+# A sample Makefile for building both Google Mock and Google Test and
+# using them in user tests.  This file is self-contained, so you don't
+# need to use the Makefile in Google Test's source tree.  Please tweak
+# it to suit your environment and project.  You may want to move it to
+# your project's root directory.
+#
+# SYNOPSIS:
+#
+#   make [all]  - makes everything.
+#   make TARGET - makes the given target.
+#   make clean  - removes all files generated by make.
+
+# Please tweak the following variable definitions as needed by your
+# project, except GMOCK_HEADERS and GTEST_HEADERS, which you can use
+# in your own targets but shouldn't modify.
+
+# Points to the root of Google Test, relative to where this file is.
+# Remember to tweak this if you move this file, or if you want to use
+# a copy of Google Test at a different location.
+GTEST_DIR = ../../googletest
+
+# Points to the root of Google Mock, relative to where this file is.
+# Remember to tweak this if you move this file.
+GMOCK_DIR = ..
+
+# Where to find user code.
+USER_DIR = ../test
+
+# Flags passed to the preprocessor.
+# Set Google Test and Google Mock's header directories as system
+# directories, such that the compiler doesn't generate warnings in
+# these headers.
+CPPFLAGS += -isystem $(GTEST_DIR)/include -isystem $(GMOCK_DIR)/include
+
+# Flags passed to the C++ compiler.
+CXXFLAGS += -g -Wall -Wextra -pthread
+
+# All tests produced by this Makefile.  Remember to add new tests you
+# created to the list.
+TESTS = gmock_test
+
+# All Google Test headers.  Usually you shouldn't change this
+# definition.
+GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
+                $(GTEST_DIR)/include/gtest/internal/*.h
+
+# All Google Mock headers. Note that all Google Test headers are
+# included here too, as they are #included by Google Mock headers.
+# Usually you shouldn't change this definition.	
+GMOCK_HEADERS = $(GMOCK_DIR)/include/gmock/*.h \
+                $(GMOCK_DIR)/include/gmock/internal/*.h \
+                $(GTEST_HEADERS)
+
+# House-keeping build targets.
+
+all : $(TESTS)
+
+clean :
+	rm -f $(TESTS) gmock.a gmock_main.a *.o
+
+# Builds gmock.a and gmock_main.a.  These libraries contain both
+# Google Mock and Google Test.  A test should link with either gmock.a
+# or gmock_main.a, depending on whether it defines its own main()
+# function.  It's fine if your test only uses features from Google
+# Test (and not Google Mock).
+
+# Usually you shouldn't tweak such internal variables, indicated by a
+# trailing _.
+GTEST_SRCS_ = $(GTEST_DIR)/src/*.cc $(GTEST_DIR)/src/*.h $(GTEST_HEADERS)
+GMOCK_SRCS_ = $(GMOCK_DIR)/src/*.cc $(GMOCK_HEADERS)
+
+# For simplicity and to avoid depending on implementation details of
+# Google Mock and Google Test, the dependencies specified below are
+# conservative and not optimized.  This is fine as Google Mock and
+# Google Test compile fast and for ordinary users their source rarely
+# changes.
+gtest-all.o : $(GTEST_SRCS_)
+	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
+            -c $(GTEST_DIR)/src/gtest-all.cc
+
+gmock-all.o : $(GMOCK_SRCS_)
+	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
+            -c $(GMOCK_DIR)/src/gmock-all.cc
+
+gmock_main.o : $(GMOCK_SRCS_)
+	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
+            -c $(GMOCK_DIR)/src/gmock_main.cc
+
+gmock.a : gmock-all.o gtest-all.o
+	$(AR) $(ARFLAGS) $@ $^
+
+gmock_main.a : gmock-all.o gtest-all.o gmock_main.o
+	$(AR) $(ARFLAGS) $@ $^
+
+# Builds a sample test.
+
+gmock_test.o : $(USER_DIR)/gmock_test.cc $(GMOCK_HEADERS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/gmock_test.cc
+
+gmock_test : gmock_test.o gmock_main.a
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.sln b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.sln
new file mode 100644
index 00000000..b752f876
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.sln
@@ -0,0 +1,32 @@
+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual Studio 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock", "gmock.vcproj", "{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_test", "gmock_test.vcproj", "{F10D22F8-AC7B-4213-8720-608E7D878CD2}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_main", "gmock_main.vcproj", "{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.ActiveCfg = Debug|Win32
+		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.Build.0 = Debug|Win32
+		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.ActiveCfg = Release|Win32
+		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.Build.0 = Release|Win32
+		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.ActiveCfg = Debug|Win32
+		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.Build.0 = Debug|Win32
+		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.ActiveCfg = Release|Win32
+		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.Build.0 = Release|Win32
+		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.Build.0 = Debug|Win32
+		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.ActiveCfg = Release|Win32
+		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.vcproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.vcproj
new file mode 100644
index 00000000..4bbfe989
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.vcproj
@@ -0,0 +1,191 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="gmock"
+	ProjectGUID="{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
+	RootNamespace="gmock"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\$(ProjectName)"
+			ConfigurationType="4"
+			InheritedPropertySheets=".\gmock_config.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\..\include;..\.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\$(ProjectName)"
+			ConfigurationType="4"
+			InheritedPropertySheets=".\gmock_config.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="..\..\include;..\.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+				RuntimeLibrary="0"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\gmock-all.cc"
+				>
+			</File>
+			<File
+				RelativePath="$(GTestDir)\src\gtest-all.cc"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="$(GTestDir)"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="$(GTestDir)"
+					/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Public Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Private Header Files"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_config.vsprops b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_config.vsprops
new file mode 100644
index 00000000..875939c1
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_config.vsprops
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioPropertySheet
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="gmock_config"
+	>
+	<Tool
+		Name="VCCLCompilerTool"
+		AdditionalIncludeDirectories="&quot;$(GTestDir)/include&quot;"
+	/>
+	<UserMacro
+		Name="GTestDir"
+		Value="../../../googletest"
+	/>
+</VisualStudioPropertySheet>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_main.vcproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_main.vcproj
new file mode 100644
index 00000000..01505a93
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_main.vcproj
@@ -0,0 +1,187 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="gmock_main"
+	ProjectGUID="{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
+	RootNamespace="gmock_main"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\$(ProjectName)"
+			ConfigurationType="4"
+			InheritedPropertySheets=".\gmock_config.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\$(ProjectName)"
+			ConfigurationType="4"
+			InheritedPropertySheets=".\gmock_config.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../../include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+				RuntimeLibrary="0"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+		<ProjectReference
+			ReferencedProjectIdentifier="{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
+			RelativePathToProject=".\gmock.vcproj"
+		/>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\src\gmock_main.cc"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="../../include"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="../../include"
+					/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_test.vcproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_test.vcproj
new file mode 100644
index 00000000..d1e01e71
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_test.vcproj
@@ -0,0 +1,201 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="gmock_test"
+	ProjectGUID="{F10D22F8-AC7B-4213-8720-608E7D878CD2}"
+	RootNamespace="gmock_test"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\$(ProjectName)"
+			ConfigurationType="1"
+			InheritedPropertySheets=".\gmock_config.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions="/bigobj"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\..\include;..\.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\$(ProjectName)"
+			ConfigurationType="1"
+			InheritedPropertySheets=".\gmock_config.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions="/bigobj"
+				AdditionalIncludeDirectories="..\..\include;..\.."
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="0"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+		<ProjectReference
+			ReferencedProjectIdentifier="{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
+			RelativePathToProject=".\gmock_main.vcproj"
+		/>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\test\gmock_all_test.cc"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.sln b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.sln
new file mode 100644
index 00000000..d9496569
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.sln
@@ -0,0 +1,32 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual C++ Express 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock", "gmock.vcxproj", "{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_test", "gmock_test.vcxproj", "{F10D22F8-AC7B-4213-8720-608E7D878CD2}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_main", "gmock_main.vcxproj", "{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.ActiveCfg = Debug|Win32
+		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.Build.0 = Debug|Win32
+		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.ActiveCfg = Release|Win32
+		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.Build.0 = Release|Win32
+		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.ActiveCfg = Debug|Win32
+		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.Build.0 = Debug|Win32
+		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.ActiveCfg = Release|Win32
+		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.Build.0 = Release|Win32
+		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.Build.0 = Debug|Win32
+		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.ActiveCfg = Release|Win32
+		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.vcxproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.vcxproj
new file mode 100644
index 00000000..21a85ef6
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.vcxproj
@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}</ProjectGuid>
+    <RootNamespace>gmock</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="gmock_config.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="gmock_config.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\gmock-all.cc" />
+    <ClCompile Include="$(GTestDir)\src\gtest-all.cc">
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(GTestDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(GTestDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_config.props b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_config.props
new file mode 100644
index 00000000..441f31cf
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_config.props
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="UserMacros">
+    <GTestDir>../../../googletest</GTestDir>
+  </PropertyGroup>
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(GTestDir)/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <BuildMacro Include="GTestDir">
+      <Value>$(GTestDir)</Value>
+    </BuildMacro>
+  </ItemGroup>
+</Project>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_main.vcxproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_main.vcxproj
new file mode 100644
index 00000000..27fecd5f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_main.vcxproj
@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{E4EF614B-30DF-4954-8C53-580A0BF6B589}</ProjectGuid>
+    <RootNamespace>gmock_main</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="gmock_config.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="gmock_config.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectReference Include="gmock.vcxproj">
+      <Project>{34681f0d-ce45-415d-b5f2-5c662dfe3bd5}</Project>
+      <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\gmock_main.cc">
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_test.vcxproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_test.vcxproj
new file mode 100644
index 00000000..265439ec
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_test.vcxproj
@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{F10D22F8-AC7B-4213-8720-608E7D878CD2}</ProjectGuid>
+    <RootNamespace>gmock_test</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="gmock_config.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="gmock_config.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectReference Include="gmock_main.vcxproj">
+      <Project>{e4ef614b-30df-4954-8c53-580a0bf6b589}</Project>
+      <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\test\gmock_all_test.cc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.sln b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.sln
new file mode 100644
index 00000000..c59e07fc
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.sln
@@ -0,0 +1,32 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock", "gmock.vcxproj", "{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_test", "gmock_test.vcxproj", "{F10D22F8-AC7B-4213-8720-608E7D878CD2}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_main", "gmock_main.vcxproj", "{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.ActiveCfg = Debug|Win32
+		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.Build.0 = Debug|Win32
+		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.ActiveCfg = Release|Win32
+		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.Build.0 = Release|Win32
+		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.ActiveCfg = Debug|Win32
+		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.Build.0 = Debug|Win32
+		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.ActiveCfg = Release|Win32
+		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.Build.0 = Release|Win32
+		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.Build.0 = Debug|Win32
+		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.ActiveCfg = Release|Win32
+		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.vcxproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.vcxproj
new file mode 100644
index 00000000..d5ddd091
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.vcxproj
@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}</ProjectGuid>
+    <RootNamespace>gmock</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="gmock_config.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="gmock_config.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\gmock-all.cc" />
+    <ClCompile Include="$(GTestDir)\src\gtest-all.cc">
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(GTestDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(GTestDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_config.props b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_config.props
new file mode 100644
index 00000000..77bc95b1
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_config.props
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="UserMacros">
+    <GTestDir>../../../googletest</GTestDir>
+  </PropertyGroup>
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(GTestDir)/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <BuildMacro Include="GTestDir">
+      <Value>$(GTestDir)</Value>
+    </BuildMacro>
+  </ItemGroup>
+</Project>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_main.vcxproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_main.vcxproj
new file mode 100644
index 00000000..76cc68b9
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_main.vcxproj
@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{E4EF614B-30DF-4954-8C53-580A0BF6B589}</ProjectGuid>
+    <RootNamespace>gmock_main</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="gmock_config.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="gmock_config.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectReference Include="gmock.vcxproj">
+      <Project>{34681f0d-ce45-415d-b5f2-5c662dfe3bd5}</Project>
+      <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\gmock_main.cc">
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_test.vcxproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_test.vcxproj
new file mode 100644
index 00000000..76ea5534
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_test.vcxproj
@@ -0,0 +1,103 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{F10D22F8-AC7B-4213-8720-608E7D878CD2}</ProjectGuid>
+    <RootNamespace>gmock_test</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="gmock_config.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="gmock_config.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>..\..\include;..\..;$(GTestDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectReference Include="gmock_main.vcxproj">
+      <Project>{e4ef614b-30df-4954-8c53-580a0bf6b589}</Project>
+      <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\test\gmock_all_test.cc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/fuse_gmock_files.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/fuse_gmock_files.py
new file mode 100755
index 00000000..cb7fdf2f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/fuse_gmock_files.py
@@ -0,0 +1,240 @@
+#!/usr/bin/env python
+#
+# Copyright 2009, 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.
+
+"""fuse_gmock_files.py v0.1.0
+Fuses Google Mock and Google Test source code into two .h files and a .cc file.
+
+SYNOPSIS
+       fuse_gmock_files.py [GMOCK_ROOT_DIR] OUTPUT_DIR
+
+       Scans GMOCK_ROOT_DIR for Google Mock and Google Test source
+       code, assuming Google Test is in the GMOCK_ROOT_DIR/../googletest
+       directory, and generates three files:
+       OUTPUT_DIR/gtest/gtest.h, OUTPUT_DIR/gmock/gmock.h, and
+       OUTPUT_DIR/gmock-gtest-all.cc.  Then you can build your tests
+       by adding OUTPUT_DIR to the include search path and linking
+       with OUTPUT_DIR/gmock-gtest-all.cc.  These three files contain
+       everything you need to use Google Mock.  Hence you can
+       "install" Google Mock by copying them to wherever you want.
+
+       GMOCK_ROOT_DIR can be omitted and defaults to the parent
+       directory of the directory holding this script.
+
+EXAMPLES
+       ./fuse_gmock_files.py fused_gmock
+       ./fuse_gmock_files.py path/to/unpacked/gmock fused_gmock
+
+This tool is experimental.  In particular, it assumes that there is no
+conditional inclusion of Google Mock or Google Test headers.  Please
+report any problems to googlemock@googlegroups.com.  You can read
+http://code.google.com/p/googlemock/wiki/CookBook for more
+information.
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import re
+import sets
+import sys
+
+# We assume that this file is in the scripts/ directory in the Google
+# Mock root directory.
+DEFAULT_GMOCK_ROOT_DIR = os.path.join(os.path.dirname(__file__), '..')
+
+# We need to call into googletest/scripts/fuse_gtest_files.py.
+sys.path.append(os.path.join(DEFAULT_GMOCK_ROOT_DIR, '../googletest/scripts'))
+import fuse_gtest_files
+gtest = fuse_gtest_files
+
+# Regex for matching '#include "gmock/..."'.
+INCLUDE_GMOCK_FILE_REGEX = re.compile(r'^\s*#\s*include\s*"(gmock/.+)"')
+
+# Where to find the source seed files.
+GMOCK_H_SEED = 'include/gmock/gmock.h'
+GMOCK_ALL_CC_SEED = 'src/gmock-all.cc'
+
+# Where to put the generated files.
+GTEST_H_OUTPUT = 'gtest/gtest.h'
+GMOCK_H_OUTPUT = 'gmock/gmock.h'
+GMOCK_GTEST_ALL_CC_OUTPUT = 'gmock-gtest-all.cc'
+
+
+def GetGTestRootDir(gmock_root):
+  """Returns the root directory of Google Test."""
+
+  return os.path.join(gmock_root, '../googletest')
+
+
+def ValidateGMockRootDir(gmock_root):
+  """Makes sure gmock_root points to a valid gmock root directory.
+
+  The function aborts the program on failure.
+  """
+
+  gtest.ValidateGTestRootDir(GetGTestRootDir(gmock_root))
+  gtest.VerifyFileExists(gmock_root, GMOCK_H_SEED)
+  gtest.VerifyFileExists(gmock_root, GMOCK_ALL_CC_SEED)
+
+
+def ValidateOutputDir(output_dir):
+  """Makes sure output_dir points to a valid output directory.
+
+  The function aborts the program on failure.
+  """
+
+  gtest.VerifyOutputFile(output_dir, gtest.GTEST_H_OUTPUT)
+  gtest.VerifyOutputFile(output_dir, GMOCK_H_OUTPUT)
+  gtest.VerifyOutputFile(output_dir, GMOCK_GTEST_ALL_CC_OUTPUT)
+
+
+def FuseGMockH(gmock_root, output_dir):
+  """Scans folder gmock_root to generate gmock/gmock.h in output_dir."""
+
+  output_file = file(os.path.join(output_dir, GMOCK_H_OUTPUT), 'w')
+  processed_files = sets.Set()  # Holds all gmock headers we've processed.
+
+  def ProcessFile(gmock_header_path):
+    """Processes the given gmock header file."""
+
+    # We don't process the same header twice.
+    if gmock_header_path in processed_files:
+      return
+
+    processed_files.add(gmock_header_path)
+
+    # Reads each line in the given gmock header.
+    for line in file(os.path.join(gmock_root, gmock_header_path), 'r'):
+      m = INCLUDE_GMOCK_FILE_REGEX.match(line)
+      if m:
+        # It's '#include "gmock/..."' - let's process it recursively.
+        ProcessFile('include/' + m.group(1))
+      else:
+        m = gtest.INCLUDE_GTEST_FILE_REGEX.match(line)
+        if m:
+          # It's '#include "gtest/foo.h"'.  We translate it to
+          # "gtest/gtest.h", regardless of what foo is, since all
+          # gtest headers are fused into gtest/gtest.h.
+
+          # There is no need to #include gtest.h twice.
+          if not gtest.GTEST_H_SEED in processed_files:
+            processed_files.add(gtest.GTEST_H_SEED)
+            output_file.write('#include "%s"\n' % (gtest.GTEST_H_OUTPUT,))
+        else:
+          # Otherwise we copy the line unchanged to the output file.
+          output_file.write(line)
+
+  ProcessFile(GMOCK_H_SEED)
+  output_file.close()
+
+
+def FuseGMockAllCcToFile(gmock_root, output_file):
+  """Scans folder gmock_root to fuse gmock-all.cc into output_file."""
+
+  processed_files = sets.Set()
+
+  def ProcessFile(gmock_source_file):
+    """Processes the given gmock source file."""
+
+    # We don't process the same #included file twice.
+    if gmock_source_file in processed_files:
+      return
+
+    processed_files.add(gmock_source_file)
+
+    # Reads each line in the given gmock source file.
+    for line in file(os.path.join(gmock_root, gmock_source_file), 'r'):
+      m = INCLUDE_GMOCK_FILE_REGEX.match(line)
+      if m:
+        # It's '#include "gmock/foo.h"'.  We treat it as '#include
+        # "gmock/gmock.h"', as all other gmock headers are being fused
+        # into gmock.h and cannot be #included directly.
+
+        # There is no need to #include "gmock/gmock.h" more than once.
+        if not GMOCK_H_SEED in processed_files:
+          processed_files.add(GMOCK_H_SEED)
+          output_file.write('#include "%s"\n' % (GMOCK_H_OUTPUT,))
+      else:
+        m = gtest.INCLUDE_GTEST_FILE_REGEX.match(line)
+        if m:
+          # It's '#include "gtest/..."'.
+          # There is no need to #include gtest.h as it has been
+          # #included by gtest-all.cc.
+          pass
+        else:
+          m = gtest.INCLUDE_SRC_FILE_REGEX.match(line)
+          if m:
+            # It's '#include "src/foo"' - let's process it recursively.
+            ProcessFile(m.group(1))
+          else:
+            # Otherwise we copy the line unchanged to the output file.
+            output_file.write(line)
+
+  ProcessFile(GMOCK_ALL_CC_SEED)
+
+
+def FuseGMockGTestAllCc(gmock_root, output_dir):
+  """Scans folder gmock_root to generate gmock-gtest-all.cc in output_dir."""
+
+  output_file = file(os.path.join(output_dir, GMOCK_GTEST_ALL_CC_OUTPUT), 'w')
+  # First, fuse gtest-all.cc into gmock-gtest-all.cc.
+  gtest.FuseGTestAllCcToFile(GetGTestRootDir(gmock_root), output_file)
+  # Next, append fused gmock-all.cc to gmock-gtest-all.cc.
+  FuseGMockAllCcToFile(gmock_root, output_file)
+  output_file.close()
+
+
+def FuseGMock(gmock_root, output_dir):
+  """Fuses gtest.h, gmock.h, and gmock-gtest-all.h."""
+
+  ValidateGMockRootDir(gmock_root)
+  ValidateOutputDir(output_dir)
+
+  gtest.FuseGTestH(GetGTestRootDir(gmock_root), output_dir)
+  FuseGMockH(gmock_root, output_dir)
+  FuseGMockGTestAllCc(gmock_root, output_dir)
+
+
+def main():
+  argc = len(sys.argv)
+  if argc == 2:
+    # fuse_gmock_files.py OUTPUT_DIR
+    FuseGMock(DEFAULT_GMOCK_ROOT_DIR, sys.argv[1])
+  elif argc == 3:
+    # fuse_gmock_files.py GMOCK_ROOT_DIR OUTPUT_DIR
+    FuseGMock(sys.argv[1], sys.argv[2])
+  else:
+    print __doc__
+    sys.exit(1)
+
+
+if __name__ == '__main__':
+  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/LICENSE b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/LICENSE
new file mode 100644
index 00000000..87ea0636
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/LICENSE
@@ -0,0 +1,203 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2007] Neal Norwitz
+   Portions Copyright [2007] Google Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README
new file mode 100644
index 00000000..d6f95974
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README
@@ -0,0 +1,35 @@
+
+The Google Mock class generator is an application that is part of cppclean.
+For more information about cppclean, see the README.cppclean file or
+visit http://code.google.com/p/cppclean/
+
+cppclean requires Python 2.3.5 or later.  If you don't have Python installed
+on your system, you will also need to install it.  You can download Python
+from:  http://www.python.org/download/releases/
+
+To use the Google Mock class generator, you need to call it
+on the command line passing the header file and class for which you want
+to generate a Google Mock class.
+
+Make sure to install the scripts somewhere in your path.  Then you can
+run the program.
+
+  gmock_gen.py header-file.h [ClassName]...
+
+If no ClassNames are specified, all classes in the file are emitted.
+
+To change the indentation from the default of 2, set INDENT in
+the environment.  For example to use an indent of 4 spaces:
+
+INDENT=4 gmock_gen.py header-file.h ClassName
+
+This version was made from SVN revision 281 in the cppclean repository.
+
+Known Limitations
+-----------------
+Not all code will be generated properly.  For example, when mocking templated
+classes, the template information is lost.  You will need to add the template
+information manually.
+
+Not all permutations of using multiple pointers/references will be rendered
+properly.  These will also have to be fixed manually.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README.cppclean b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README.cppclean
new file mode 100644
index 00000000..65431b61
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README.cppclean
@@ -0,0 +1,115 @@
+Goal:
+-----
+  CppClean attempts to find problems in C++ source that slow development
+  in large code bases, for example various forms of unused code.
+  Unused code can be unused functions, methods, data members, types, etc
+  to unnecessary #include directives.  Unnecessary #includes can cause
+  considerable extra compiles increasing the edit-compile-run cycle.
+
+  The project home page is:   http://code.google.com/p/cppclean/
+
+
+Features:
+---------
+ * Find and print C++ language constructs: classes, methods, functions, etc.
+ * Find classes with virtual methods, no virtual destructor, and no bases
+ * Find global/static data that are potential problems when using threads
+ * Unnecessary forward class declarations
+ * Unnecessary function declarations
+ * Undeclared function definitions
+ * (planned) Find unnecessary header files #included
+   - No direct reference to anything in the header
+   - Header is unnecessary if classes were forward declared instead
+ * (planned) Source files that reference headers not directly #included,
+   ie, files that rely on a transitive #include from another header
+ * (planned) Unused members (private, protected, & public) methods and data
+ * (planned) Store AST in a SQL database so relationships can be queried
+
+AST is Abstract Syntax Tree, a representation of parsed source code.
+http://en.wikipedia.org/wiki/Abstract_syntax_tree
+
+
+System Requirements:
+--------------------
+ * Python 2.4 or later (2.3 probably works too)
+ * Works on Windows (untested), Mac OS X, and Unix
+
+
+How to Run:
+-----------
+  For all examples, it is assumed that cppclean resides in a directory called
+  /cppclean.
+
+  To print warnings for classes with virtual methods, no virtual destructor and
+  no base classes:
+
+      /cppclean/run.sh nonvirtual_dtors.py file1.h file2.h file3.cc ...
+
+  To print all the functions defined in header file(s):
+
+      /cppclean/run.sh functions.py file1.h file2.h ...
+
+  All the commands take multiple files on the command line.  Other programs
+  include: find_warnings, headers, methods, and types.  Some other programs
+  are available, but used primarily for debugging.
+
+  run.sh is a simple wrapper that sets PYTHONPATH to /cppclean and then
+  runs the program in /cppclean/cpp/PROGRAM.py.  There is currently
+  no equivalent for Windows.  Contributions for a run.bat file
+  would be greatly appreciated.
+
+
+How to Configure:
+-----------------
+  You can add a siteheaders.py file in /cppclean/cpp to configure where
+  to look for other headers (typically -I options passed to a compiler).
+  Currently two values are supported:  _TRANSITIVE and GetIncludeDirs.
+  _TRANSITIVE should be set to a boolean value (True or False) indicating
+  whether to transitively process all header files.  The default is False.
+
+  GetIncludeDirs is a function that takes a single argument and returns
+  a sequence of directories to include.  This can be a generator or
+  return a static list.
+
+      def GetIncludeDirs(filename):
+          return ['/some/path/with/other/headers']
+
+      # Here is a more complicated example.
+      def GetIncludeDirs(filename):
+          yield '/path1'
+          yield os.path.join('/path2', os.path.dirname(filename))
+          yield '/path3'
+
+
+How to Test:
+------------
+  For all examples, it is assumed that cppclean resides in a directory called
+  /cppclean.  The tests require
+
+  cd /cppclean
+  make test
+  # To generate expected results after a change:
+  make expected
+
+
+Current Status:
+---------------
+  The parser works pretty well for header files, parsing about 99% of Google's
+  header files.  Anything which inspects structure of C++ source files should
+  work reasonably well.  Function bodies are not transformed to an AST,
+  but left as tokens.  Much work is still needed on finding unused header files
+  and storing an AST in a database.
+
+
+Non-goals:
+----------
+ * Parsing all valid C++ source
+ * Handling invalid C++ source gracefully
+ * Compiling to machine code (or anything beyond an AST)
+
+
+Contact:
+--------
+  If you used cppclean, I would love to hear about your experiences
+  cppclean@googlegroups.com.  Even if you don't use cppclean, I'd like to
+  hear from you.  :-)  (You can contact me directly at:  nnorwitz@gmail.com)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/__init__.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/__init__.py
new file mode 100755
index 00000000..e69de29b
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/ast.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/ast.py
new file mode 100755
index 00000000..11cbe912
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/ast.py
@@ -0,0 +1,1733 @@
+#!/usr/bin/env python
+#
+# Copyright 2007 Neal Norwitz
+# Portions Copyright 2007 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Generate an Abstract Syntax Tree (AST) for C++."""
+
+__author__ = 'nnorwitz@google.com (Neal Norwitz)'
+
+
+# TODO:
+#  * Tokens should never be exported, need to convert to Nodes
+#    (return types, parameters, etc.)
+#  * Handle static class data for templatized classes
+#  * Handle casts (both C++ and C-style)
+#  * Handle conditions and loops (if/else, switch, for, while/do)
+#
+# TODO much, much later:
+#  * Handle #define
+#  * exceptions
+
+
+try:
+    # Python 3.x
+    import builtins
+except ImportError:
+    # Python 2.x
+    import __builtin__ as builtins
+
+import sys
+import traceback
+
+from cpp import keywords
+from cpp import tokenize
+from cpp import utils
+
+
+if not hasattr(builtins, 'reversed'):
+    # Support Python 2.3 and earlier.
+    def reversed(seq):
+        for i in range(len(seq)-1, -1, -1):
+            yield seq[i]
+
+if not hasattr(builtins, 'next'):
+    # Support Python 2.5 and earlier.
+    def next(obj):
+        return obj.next()
+
+
+VISIBILITY_PUBLIC, VISIBILITY_PROTECTED, VISIBILITY_PRIVATE = range(3)
+
+FUNCTION_NONE = 0x00
+FUNCTION_CONST = 0x01
+FUNCTION_VIRTUAL = 0x02
+FUNCTION_PURE_VIRTUAL = 0x04
+FUNCTION_CTOR = 0x08
+FUNCTION_DTOR = 0x10
+FUNCTION_ATTRIBUTE = 0x20
+FUNCTION_UNKNOWN_ANNOTATION = 0x40
+FUNCTION_THROW = 0x80
+FUNCTION_OVERRIDE = 0x100
+
+"""
+These are currently unused.  Should really handle these properly at some point.
+
+TYPE_MODIFIER_INLINE   = 0x010000
+TYPE_MODIFIER_EXTERN   = 0x020000
+TYPE_MODIFIER_STATIC   = 0x040000
+TYPE_MODIFIER_CONST    = 0x080000
+TYPE_MODIFIER_REGISTER = 0x100000
+TYPE_MODIFIER_VOLATILE = 0x200000
+TYPE_MODIFIER_MUTABLE  = 0x400000
+
+TYPE_MODIFIER_MAP = {
+    'inline': TYPE_MODIFIER_INLINE,
+    'extern': TYPE_MODIFIER_EXTERN,
+    'static': TYPE_MODIFIER_STATIC,
+    'const': TYPE_MODIFIER_CONST,
+    'register': TYPE_MODIFIER_REGISTER,
+    'volatile': TYPE_MODIFIER_VOLATILE,
+    'mutable': TYPE_MODIFIER_MUTABLE,
+    }
+"""
+
+_INTERNAL_TOKEN = 'internal'
+_NAMESPACE_POP = 'ns-pop'
+
+
+# TODO(nnorwitz): use this as a singleton for templated_types, etc
+# where we don't want to create a new empty dict each time.  It is also const.
+class _NullDict(object):
+    __contains__ = lambda self: False
+    keys = values = items = iterkeys = itervalues = iteritems = lambda self: ()
+
+
+# TODO(nnorwitz): move AST nodes into a separate module.
+class Node(object):
+    """Base AST node."""
+
+    def __init__(self, start, end):
+        self.start = start
+        self.end = end
+
+    def IsDeclaration(self):
+        """Returns bool if this node is a declaration."""
+        return False
+
+    def IsDefinition(self):
+        """Returns bool if this node is a definition."""
+        return False
+
+    def IsExportable(self):
+        """Returns bool if this node exportable from a header file."""
+        return False
+
+    def Requires(self, node):
+        """Does this AST node require the definition of the node passed in?"""
+        return False
+
+    def XXX__str__(self):
+        return self._StringHelper(self.__class__.__name__, '')
+
+    def _StringHelper(self, name, suffix):
+        if not utils.DEBUG:
+            return '%s(%s)' % (name, suffix)
+        return '%s(%d, %d, %s)' % (name, self.start, self.end, suffix)
+
+    def __repr__(self):
+        return str(self)
+
+
+class Define(Node):
+    def __init__(self, start, end, name, definition):
+        Node.__init__(self, start, end)
+        self.name = name
+        self.definition = definition
+
+    def __str__(self):
+        value = '%s %s' % (self.name, self.definition)
+        return self._StringHelper(self.__class__.__name__, value)
+
+
+class Include(Node):
+    def __init__(self, start, end, filename, system):
+        Node.__init__(self, start, end)
+        self.filename = filename
+        self.system = system
+
+    def __str__(self):
+        fmt = '"%s"'
+        if self.system:
+            fmt = '<%s>'
+        return self._StringHelper(self.__class__.__name__, fmt % self.filename)
+
+
+class Goto(Node):
+    def __init__(self, start, end, label):
+        Node.__init__(self, start, end)
+        self.label = label
+
+    def __str__(self):
+        return self._StringHelper(self.__class__.__name__, str(self.label))
+
+
+class Expr(Node):
+    def __init__(self, start, end, expr):
+        Node.__init__(self, start, end)
+        self.expr = expr
+
+    def Requires(self, node):
+        # TODO(nnorwitz): impl.
+        return False
+
+    def __str__(self):
+        return self._StringHelper(self.__class__.__name__, str(self.expr))
+
+
+class Return(Expr):
+    pass
+
+
+class Delete(Expr):
+    pass
+
+
+class Friend(Expr):
+    def __init__(self, start, end, expr, namespace):
+        Expr.__init__(self, start, end, expr)
+        self.namespace = namespace[:]
+
+
+class Using(Node):
+    def __init__(self, start, end, names):
+        Node.__init__(self, start, end)
+        self.names = names
+
+    def __str__(self):
+        return self._StringHelper(self.__class__.__name__, str(self.names))
+
+
+class Parameter(Node):
+    def __init__(self, start, end, name, parameter_type, default):
+        Node.__init__(self, start, end)
+        self.name = name
+        self.type = parameter_type
+        self.default = default
+
+    def Requires(self, node):
+        # TODO(nnorwitz): handle namespaces, etc.
+        return self.type.name == node.name
+
+    def __str__(self):
+        name = str(self.type)
+        suffix = '%s %s' % (name, self.name)
+        if self.default:
+            suffix += ' = ' + ''.join([d.name for d in self.default])
+        return self._StringHelper(self.__class__.__name__, suffix)
+
+
+class _GenericDeclaration(Node):
+    def __init__(self, start, end, name, namespace):
+        Node.__init__(self, start, end)
+        self.name = name
+        self.namespace = namespace[:]
+
+    def FullName(self):
+        prefix = ''
+        if self.namespace and self.namespace[-1]:
+            prefix = '::'.join(self.namespace) + '::'
+        return prefix + self.name
+
+    def _TypeStringHelper(self, suffix):
+        if self.namespace:
+            names = [n or '<anonymous>' for n in self.namespace]
+            suffix += ' in ' + '::'.join(names)
+        return self._StringHelper(self.__class__.__name__, suffix)
+
+
+# TODO(nnorwitz): merge with Parameter in some way?
+class VariableDeclaration(_GenericDeclaration):
+    def __init__(self, start, end, name, var_type, initial_value, namespace):
+        _GenericDeclaration.__init__(self, start, end, name, namespace)
+        self.type = var_type
+        self.initial_value = initial_value
+
+    def Requires(self, node):
+        # TODO(nnorwitz): handle namespaces, etc.
+        return self.type.name == node.name
+
+    def ToString(self):
+        """Return a string that tries to reconstitute the variable decl."""
+        suffix = '%s %s' % (self.type, self.name)
+        if self.initial_value:
+            suffix += ' = ' + self.initial_value
+        return suffix
+
+    def __str__(self):
+        return self._StringHelper(self.__class__.__name__, self.ToString())
+
+
+class Typedef(_GenericDeclaration):
+    def __init__(self, start, end, name, alias, namespace):
+        _GenericDeclaration.__init__(self, start, end, name, namespace)
+        self.alias = alias
+
+    def IsDefinition(self):
+        return True
+
+    def IsExportable(self):
+        return True
+
+    def Requires(self, node):
+        # TODO(nnorwitz): handle namespaces, etc.
+        name = node.name
+        for token in self.alias:
+            if token is not None and name == token.name:
+                return True
+        return False
+
+    def __str__(self):
+        suffix = '%s, %s' % (self.name, self.alias)
+        return self._TypeStringHelper(suffix)
+
+
+class _NestedType(_GenericDeclaration):
+    def __init__(self, start, end, name, fields, namespace):
+        _GenericDeclaration.__init__(self, start, end, name, namespace)
+        self.fields = fields
+
+    def IsDefinition(self):
+        return True
+
+    def IsExportable(self):
+        return True
+
+    def __str__(self):
+        suffix = '%s, {%s}' % (self.name, self.fields)
+        return self._TypeStringHelper(suffix)
+
+
+class Union(_NestedType):
+    pass
+
+
+class Enum(_NestedType):
+    pass
+
+
+class Class(_GenericDeclaration):
+    def __init__(self, start, end, name, bases, templated_types, body, namespace):
+        _GenericDeclaration.__init__(self, start, end, name, namespace)
+        self.bases = bases
+        self.body = body
+        self.templated_types = templated_types
+
+    def IsDeclaration(self):
+        return self.bases is None and self.body is None
+
+    def IsDefinition(self):
+        return not self.IsDeclaration()
+
+    def IsExportable(self):
+        return not self.IsDeclaration()
+
+    def Requires(self, node):
+        # TODO(nnorwitz): handle namespaces, etc.
+        if self.bases:
+            for token_list in self.bases:
+                # TODO(nnorwitz): bases are tokens, do name comparision.
+                for token in token_list:
+                    if token.name == node.name:
+                        return True
+        # TODO(nnorwitz): search in body too.
+        return False
+
+    def __str__(self):
+        name = self.name
+        if self.templated_types:
+            name += '<%s>' % self.templated_types
+        suffix = '%s, %s, %s' % (name, self.bases, self.body)
+        return self._TypeStringHelper(suffix)
+
+
+class Struct(Class):
+    pass
+
+
+class Function(_GenericDeclaration):
+    def __init__(self, start, end, name, return_type, parameters,
+                 modifiers, templated_types, body, namespace):
+        _GenericDeclaration.__init__(self, start, end, name, namespace)
+        converter = TypeConverter(namespace)
+        self.return_type = converter.CreateReturnType(return_type)
+        self.parameters = converter.ToParameters(parameters)
+        self.modifiers = modifiers
+        self.body = body
+        self.templated_types = templated_types
+
+    def IsDeclaration(self):
+        return self.body is None
+
+    def IsDefinition(self):
+        return self.body is not None
+
+    def IsExportable(self):
+        if self.return_type and 'static' in self.return_type.modifiers:
+            return False
+        return None not in self.namespace
+
+    def Requires(self, node):
+        if self.parameters:
+            # TODO(nnorwitz): parameters are tokens, do name comparision.
+            for p in self.parameters:
+                if p.name == node.name:
+                    return True
+        # TODO(nnorwitz): search in body too.
+        return False
+
+    def __str__(self):
+        # TODO(nnorwitz): add templated_types.
+        suffix = ('%s %s(%s), 0x%02x, %s' %
+                  (self.return_type, self.name, self.parameters,
+                   self.modifiers, self.body))
+        return self._TypeStringHelper(suffix)
+
+
+class Method(Function):
+    def __init__(self, start, end, name, in_class, return_type, parameters,
+                 modifiers, templated_types, body, namespace):
+        Function.__init__(self, start, end, name, return_type, parameters,
+                          modifiers, templated_types, body, namespace)
+        # TODO(nnorwitz): in_class could also be a namespace which can
+        # mess up finding functions properly.
+        self.in_class = in_class
+
+
+class Type(_GenericDeclaration):
+    """Type used for any variable (eg class, primitive, struct, etc)."""
+
+    def __init__(self, start, end, name, templated_types, modifiers,
+                 reference, pointer, array):
+        """
+        Args:
+          name: str name of main type
+          templated_types: [Class (Type?)] template type info between <>
+          modifiers: [str] type modifiers (keywords) eg, const, mutable, etc.
+          reference, pointer, array: bools
+        """
+        _GenericDeclaration.__init__(self, start, end, name, [])
+        self.templated_types = templated_types
+        if not name and modifiers:
+            self.name = modifiers.pop()
+        self.modifiers = modifiers
+        self.reference = reference
+        self.pointer = pointer
+        self.array = array
+
+    def __str__(self):
+        prefix = ''
+        if self.modifiers:
+            prefix = ' '.join(self.modifiers) + ' '
+        name = str(self.name)
+        if self.templated_types:
+            name += '<%s>' % self.templated_types
+        suffix = prefix + name
+        if self.reference:
+            suffix += '&'
+        if self.pointer:
+            suffix += '*'
+        if self.array:
+            suffix += '[]'
+        return self._TypeStringHelper(suffix)
+
+    # By definition, Is* are always False.  A Type can only exist in
+    # some sort of variable declaration, parameter, or return value.
+    def IsDeclaration(self):
+        return False
+
+    def IsDefinition(self):
+        return False
+
+    def IsExportable(self):
+        return False
+
+
+class TypeConverter(object):
+
+    def __init__(self, namespace_stack):
+        self.namespace_stack = namespace_stack
+
+    def _GetTemplateEnd(self, tokens, start):
+        count = 1
+        end = start
+        while 1:
+            token = tokens[end]
+            end += 1
+            if token.name == '<':
+                count += 1
+            elif token.name == '>':
+                count -= 1
+                if count == 0:
+                    break
+        return tokens[start:end-1], end
+
+    def ToType(self, tokens):
+        """Convert [Token,...] to [Class(...), ] useful for base classes.
+        For example, code like class Foo : public Bar<x, y> { ... };
+        the "Bar<x, y>" portion gets converted to an AST.
+
+        Returns:
+          [Class(...), ...]
+        """
+        result = []
+        name_tokens = []
+        reference = pointer = array = False
+
+        def AddType(templated_types):
+            # Partition tokens into name and modifier tokens.
+            names = []
+            modifiers = []
+            for t in name_tokens:
+                if keywords.IsKeyword(t.name):
+                    modifiers.append(t.name)
+                else:
+                    names.append(t.name)
+            name = ''.join(names)
+            if name_tokens:
+                result.append(Type(name_tokens[0].start, name_tokens[-1].end,
+                                   name, templated_types, modifiers,
+                                   reference, pointer, array))
+            del name_tokens[:]
+
+        i = 0
+        end = len(tokens)
+        while i < end:
+            token = tokens[i]
+            if token.name == '<':
+                new_tokens, new_end = self._GetTemplateEnd(tokens, i+1)
+                AddType(self.ToType(new_tokens))
+                # If there is a comma after the template, we need to consume
+                # that here otherwise it becomes part of the name.
+                i = new_end
+                reference = pointer = array = False
+            elif token.name == ',':
+                AddType([])
+                reference = pointer = array = False
+            elif token.name == '*':
+                pointer = True
+            elif token.name == '&':
+                reference = True
+            elif token.name == '[':
+               pointer = True
+            elif token.name == ']':
+                pass
+            else:
+                name_tokens.append(token)
+            i += 1
+
+        if name_tokens:
+            # No '<' in the tokens, just a simple name and no template.
+            AddType([])
+        return result
+
+    def DeclarationToParts(self, parts, needs_name_removed):
+        name = None
+        default = []
+        if needs_name_removed:
+            # Handle default (initial) values properly.
+            for i, t in enumerate(parts):
+                if t.name == '=':
+                    default = parts[i+1:]
+                    name = parts[i-1].name
+                    if name == ']' and parts[i-2].name == '[':
+                        name = parts[i-3].name
+                        i -= 1
+                    parts = parts[:i-1]
+                    break
+            else:
+                if parts[-1].token_type == tokenize.NAME:
+                    name = parts.pop().name
+                else:
+                    # TODO(nnorwitz): this is a hack that happens for code like
+                    # Register(Foo<T>); where it thinks this is a function call
+                    # but it's actually a declaration.
+                    name = '???'
+        modifiers = []
+        type_name = []
+        other_tokens = []
+        templated_types = []
+        i = 0
+        end = len(parts)
+        while i < end:
+            p = parts[i]
+            if keywords.IsKeyword(p.name):
+                modifiers.append(p.name)
+            elif p.name == '<':
+                templated_tokens, new_end = self._GetTemplateEnd(parts, i+1)
+                templated_types = self.ToType(templated_tokens)
+                i = new_end - 1
+                # Don't add a spurious :: to data members being initialized.
+                next_index = i + 1
+                if next_index < end and parts[next_index].name == '::':
+                    i += 1
+            elif p.name in ('[', ']', '='):
+                # These are handled elsewhere.
+                other_tokens.append(p)
+            elif p.name not in ('*', '&', '>'):
+                # Ensure that names have a space between them.
+                if (type_name and type_name[-1].token_type == tokenize.NAME and
+                    p.token_type == tokenize.NAME):
+                    type_name.append(tokenize.Token(tokenize.SYNTAX, ' ', 0, 0))
+                type_name.append(p)
+            else:
+                other_tokens.append(p)
+            i += 1
+        type_name = ''.join([t.name for t in type_name])
+        return name, type_name, templated_types, modifiers, default, other_tokens
+
+    def ToParameters(self, tokens):
+        if not tokens:
+            return []
+
+        result = []
+        name = type_name = ''
+        type_modifiers = []
+        pointer = reference = array = False
+        first_token = None
+        default = []
+
+        def AddParameter(end):
+            if default:
+                del default[0]  # Remove flag.
+            parts = self.DeclarationToParts(type_modifiers, True)
+            (name, type_name, templated_types, modifiers,
+             unused_default, unused_other_tokens) = parts
+            parameter_type = Type(first_token.start, first_token.end,
+                                  type_name, templated_types, modifiers,
+                                  reference, pointer, array)
+            p = Parameter(first_token.start, end, name,
+                          parameter_type, default)
+            result.append(p)
+
+        template_count = 0
+        for s in tokens:
+            if not first_token:
+                first_token = s
+            if s.name == '<':
+                template_count += 1
+            elif s.name == '>':
+                template_count -= 1
+            if template_count > 0:
+                type_modifiers.append(s)
+                continue
+
+            if s.name == ',':
+                AddParameter(s.start)
+                name = type_name = ''
+                type_modifiers = []
+                pointer = reference = array = False
+                first_token = None
+                default = []
+            elif s.name == '*':
+                pointer = True
+            elif s.name == '&':
+                reference = True
+            elif s.name == '[':
+                array = True
+            elif s.name == ']':
+                pass  # Just don't add to type_modifiers.
+            elif s.name == '=':
+                # Got a default value.  Add any value (None) as a flag.
+                default.append(None)
+            elif default:
+                default.append(s)
+            else:
+                type_modifiers.append(s)
+        AddParameter(tokens[-1].end)
+        return result
+
+    def CreateReturnType(self, return_type_seq):
+        if not return_type_seq:
+            return None
+        start = return_type_seq[0].start
+        end = return_type_seq[-1].end
+        _, name, templated_types, modifiers, default, other_tokens = \
+           self.DeclarationToParts(return_type_seq, False)
+        names = [n.name for n in other_tokens]
+        reference = '&' in names
+        pointer = '*' in names
+        array = '[' in names
+        return Type(start, end, name, templated_types, modifiers,
+                    reference, pointer, array)
+
+    def GetTemplateIndices(self, names):
+        # names is a list of strings.
+        start = names.index('<')
+        end = len(names) - 1
+        while end > 0:
+            if names[end] == '>':
+                break
+            end -= 1
+        return start, end+1
+
+class AstBuilder(object):
+    def __init__(self, token_stream, filename, in_class='', visibility=None,
+                 namespace_stack=[]):
+        self.tokens = token_stream
+        self.filename = filename
+        # TODO(nnorwitz): use a better data structure (deque) for the queue.
+        # Switching directions of the "queue" improved perf by about 25%.
+        # Using a deque should be even better since we access from both sides.
+        self.token_queue = []
+        self.namespace_stack = namespace_stack[:]
+        self.in_class = in_class
+        if in_class is None:
+            self.in_class_name_only = None
+        else:
+            self.in_class_name_only = in_class.split('::')[-1]
+        self.visibility = visibility
+        self.in_function = False
+        self.current_token = None
+        # Keep the state whether we are currently handling a typedef or not.
+        self._handling_typedef = False
+
+        self.converter = TypeConverter(self.namespace_stack)
+
+    def HandleError(self, msg, token):
+        printable_queue = list(reversed(self.token_queue[-20:]))
+        sys.stderr.write('Got %s in %s @ %s %s\n' %
+                         (msg, self.filename, token, printable_queue))
+
+    def Generate(self):
+        while 1:
+            token = self._GetNextToken()
+            if not token:
+                break
+
+            # Get the next token.
+            self.current_token = token
+
+            # Dispatch on the next token type.
+            if token.token_type == _INTERNAL_TOKEN:
+                if token.name == _NAMESPACE_POP:
+                    self.namespace_stack.pop()
+                continue
+
+            try:
+                result = self._GenerateOne(token)
+                if result is not None:
+                    yield result
+            except:
+                self.HandleError('exception', token)
+                raise
+
+    def _CreateVariable(self, pos_token, name, type_name, type_modifiers,
+                        ref_pointer_name_seq, templated_types, value=None):
+        reference = '&' in ref_pointer_name_seq
+        pointer = '*' in ref_pointer_name_seq
+        array = '[' in ref_pointer_name_seq
+        var_type = Type(pos_token.start, pos_token.end, type_name,
+                        templated_types, type_modifiers,
+                        reference, pointer, array)
+        return VariableDeclaration(pos_token.start, pos_token.end,
+                                   name, var_type, value, self.namespace_stack)
+
+    def _GenerateOne(self, token):
+        if token.token_type == tokenize.NAME:
+            if (keywords.IsKeyword(token.name) and
+                not keywords.IsBuiltinType(token.name)):
+                method = getattr(self, 'handle_' + token.name)
+                return method()
+            elif token.name == self.in_class_name_only:
+                # The token name is the same as the class, must be a ctor if
+                # there is a paren.  Otherwise, it's the return type.
+                # Peek ahead to get the next token to figure out which.
+                next = self._GetNextToken()
+                self._AddBackToken(next)
+                if next.token_type == tokenize.SYNTAX and next.name == '(':
+                    return self._GetMethod([token], FUNCTION_CTOR, None, True)
+                # Fall through--handle like any other method.
+
+            # Handle data or function declaration/definition.
+            syntax = tokenize.SYNTAX
+            temp_tokens, last_token = \
+                self._GetVarTokensUpTo(syntax, '(', ';', '{', '[')
+            temp_tokens.insert(0, token)
+            if last_token.name == '(':
+                # If there is an assignment before the paren,
+                # this is an expression, not a method.
+                expr = bool([e for e in temp_tokens if e.name == '='])
+                if expr:
+                    new_temp = self._GetTokensUpTo(tokenize.SYNTAX, ';')
+                    temp_tokens.append(last_token)
+                    temp_tokens.extend(new_temp)
+                    last_token = tokenize.Token(tokenize.SYNTAX, ';', 0, 0)
+
+            if last_token.name == '[':
+                # Handle array, this isn't a method, unless it's an operator.
+                # TODO(nnorwitz): keep the size somewhere.
+                # unused_size = self._GetTokensUpTo(tokenize.SYNTAX, ']')
+                temp_tokens.append(last_token)
+                if temp_tokens[-2].name == 'operator':
+                    temp_tokens.append(self._GetNextToken())
+                else:
+                    temp_tokens2, last_token = \
+                        self._GetVarTokensUpTo(tokenize.SYNTAX, ';')
+                    temp_tokens.extend(temp_tokens2)
+
+            if last_token.name == ';':
+                # Handle data, this isn't a method.
+                parts = self.converter.DeclarationToParts(temp_tokens, True)
+                (name, type_name, templated_types, modifiers, default,
+                 unused_other_tokens) = parts
+
+                t0 = temp_tokens[0]
+                names = [t.name for t in temp_tokens]
+                if templated_types:
+                    start, end = self.converter.GetTemplateIndices(names)
+                    names = names[:start] + names[end:]
+                default = ''.join([t.name for t in default])
+                return self._CreateVariable(t0, name, type_name, modifiers,
+                                            names, templated_types, default)
+            if last_token.name == '{':
+                self._AddBackTokens(temp_tokens[1:])
+                self._AddBackToken(last_token)
+                method_name = temp_tokens[0].name
+                method = getattr(self, 'handle_' + method_name, None)
+                if not method:
+                    # Must be declaring a variable.
+                    # TODO(nnorwitz): handle the declaration.
+                    return None
+                return method()
+            return self._GetMethod(temp_tokens, 0, None, False)
+        elif token.token_type == tokenize.SYNTAX:
+            if token.name == '~' and self.in_class:
+                # Must be a dtor (probably not in method body).
+                token = self._GetNextToken()
+                # self.in_class can contain A::Name, but the dtor will only
+                # be Name.  Make sure to compare against the right value.
+                if (token.token_type == tokenize.NAME and
+                    token.name == self.in_class_name_only):
+                    return self._GetMethod([token], FUNCTION_DTOR, None, True)
+            # TODO(nnorwitz): handle a lot more syntax.
+        elif token.token_type == tokenize.PREPROCESSOR:
+            # TODO(nnorwitz): handle more preprocessor directives.
+            # token starts with a #, so remove it and strip whitespace.
+            name = token.name[1:].lstrip()
+            if name.startswith('include'):
+                # Remove "include".
+                name = name[7:].strip()
+                assert name
+                # Handle #include \<newline> "header-on-second-line.h".
+                if name.startswith('\\'):
+                    name = name[1:].strip()
+                assert name[0] in '<"', token
+                assert name[-1] in '>"', token
+                system = name[0] == '<'
+                filename = name[1:-1]
+                return Include(token.start, token.end, filename, system)
+            if name.startswith('define'):
+                # Remove "define".
+                name = name[6:].strip()
+                assert name
+                value = ''
+                for i, c in enumerate(name):
+                    if c.isspace():
+                        value = name[i:].lstrip()
+                        name = name[:i]
+                        break
+                return Define(token.start, token.end, name, value)
+            if name.startswith('if') and name[2:3].isspace():
+                condition = name[3:].strip()
+                if condition.startswith('0') or condition.startswith('(0)'):
+                    self._SkipIf0Blocks()
+        return None
+
+    def _GetTokensUpTo(self, expected_token_type, expected_token):
+        return self._GetVarTokensUpTo(expected_token_type, expected_token)[0]
+
+    def _GetVarTokensUpTo(self, expected_token_type, *expected_tokens):
+        last_token = self._GetNextToken()
+        tokens = []
+        while (last_token.token_type != expected_token_type or
+               last_token.name not in expected_tokens):
+            tokens.append(last_token)
+            last_token = self._GetNextToken()
+        return tokens, last_token
+
+    # TODO(nnorwitz): remove _IgnoreUpTo() it shouldn't be necesary.
+    def _IgnoreUpTo(self, token_type, token):
+        unused_tokens = self._GetTokensUpTo(token_type, token)
+
+    def _SkipIf0Blocks(self):
+        count = 1
+        while 1:
+            token = self._GetNextToken()
+            if token.token_type != tokenize.PREPROCESSOR:
+                continue
+
+            name = token.name[1:].lstrip()
+            if name.startswith('endif'):
+                count -= 1
+                if count == 0:
+                    break
+            elif name.startswith('if'):
+                count += 1
+
+    def _GetMatchingChar(self, open_paren, close_paren, GetNextToken=None):
+        if GetNextToken is None:
+            GetNextToken = self._GetNextToken
+        # Assumes the current token is open_paren and we will consume
+        # and return up to the close_paren.
+        count = 1
+        token = GetNextToken()
+        while 1:
+            if token.token_type == tokenize.SYNTAX:
+                if token.name == open_paren:
+                    count += 1
+                elif token.name == close_paren:
+                    count -= 1
+                    if count == 0:
+                        break
+            yield token
+            token = GetNextToken()
+        yield token
+
+    def _GetParameters(self):
+        return self._GetMatchingChar('(', ')')
+
+    def GetScope(self):
+        return self._GetMatchingChar('{', '}')
+
+    def _GetNextToken(self):
+        if self.token_queue:
+            return self.token_queue.pop()
+        return next(self.tokens)
+
+    def _AddBackToken(self, token):
+        if token.whence == tokenize.WHENCE_STREAM:
+            token.whence = tokenize.WHENCE_QUEUE
+            self.token_queue.insert(0, token)
+        else:
+            assert token.whence == tokenize.WHENCE_QUEUE, token
+            self.token_queue.append(token)
+
+    def _AddBackTokens(self, tokens):
+        if tokens:
+            if tokens[-1].whence == tokenize.WHENCE_STREAM:
+                for token in tokens:
+                    token.whence = tokenize.WHENCE_QUEUE
+                self.token_queue[:0] = reversed(tokens)
+            else:
+                assert tokens[-1].whence == tokenize.WHENCE_QUEUE, tokens
+                self.token_queue.extend(reversed(tokens))
+
+    def GetName(self, seq=None):
+        """Returns ([tokens], next_token_info)."""
+        GetNextToken = self._GetNextToken
+        if seq is not None:
+            it = iter(seq)
+            GetNextToken = lambda: next(it)
+        next_token = GetNextToken()
+        tokens = []
+        last_token_was_name = False
+        while (next_token.token_type == tokenize.NAME or
+               (next_token.token_type == tokenize.SYNTAX and
+                next_token.name in ('::', '<'))):
+            # Two NAMEs in a row means the identifier should terminate.
+            # It's probably some sort of variable declaration.
+            if last_token_was_name and next_token.token_type == tokenize.NAME:
+                break
+            last_token_was_name = next_token.token_type == tokenize.NAME
+            tokens.append(next_token)
+            # Handle templated names.
+            if next_token.name == '<':
+                tokens.extend(self._GetMatchingChar('<', '>', GetNextToken))
+                last_token_was_name = True
+            next_token = GetNextToken()
+        return tokens, next_token
+
+    def GetMethod(self, modifiers, templated_types):
+        return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(')
+        assert len(return_type_and_name) >= 1
+        return self._GetMethod(return_type_and_name, modifiers, templated_types,
+                               False)
+
+    def _GetMethod(self, return_type_and_name, modifiers, templated_types,
+                   get_paren):
+        template_portion = None
+        if get_paren:
+            token = self._GetNextToken()
+            assert token.token_type == tokenize.SYNTAX, token
+            if token.name == '<':
+                # Handle templatized dtors.
+                template_portion = [token]
+                template_portion.extend(self._GetMatchingChar('<', '>'))
+                token = self._GetNextToken()
+            assert token.token_type == tokenize.SYNTAX, token
+            assert token.name == '(', token
+
+        name = return_type_and_name.pop()
+        # Handle templatized ctors.
+        if name.name == '>':
+            index = 1
+            while return_type_and_name[index].name != '<':
+                index += 1
+            template_portion = return_type_and_name[index:] + [name]
+            del return_type_and_name[index:]
+            name = return_type_and_name.pop()
+        elif name.name == ']':
+            rt = return_type_and_name
+            assert rt[-1].name == '[', return_type_and_name
+            assert rt[-2].name == 'operator', return_type_and_name
+            name_seq = return_type_and_name[-2:]
+            del return_type_and_name[-2:]
+            name = tokenize.Token(tokenize.NAME, 'operator[]',
+                                  name_seq[0].start, name.end)
+            # Get the open paren so _GetParameters() below works.
+            unused_open_paren = self._GetNextToken()
+
+        # TODO(nnorwitz): store template_portion.
+        return_type = return_type_and_name
+        indices = name
+        if return_type:
+            indices = return_type[0]
+
+        # Force ctor for templatized ctors.
+        if name.name == self.in_class and not modifiers:
+            modifiers |= FUNCTION_CTOR
+        parameters = list(self._GetParameters())
+        del parameters[-1]              # Remove trailing ')'.
+
+        # Handling operator() is especially weird.
+        if name.name == 'operator' and not parameters:
+            token = self._GetNextToken()
+            assert token.name == '(', token
+            parameters = list(self._GetParameters())
+            del parameters[-1]          # Remove trailing ')'.
+
+        token = self._GetNextToken()
+        while token.token_type == tokenize.NAME:
+            modifier_token = token
+            token = self._GetNextToken()
+            if modifier_token.name == 'const':
+                modifiers |= FUNCTION_CONST
+            elif modifier_token.name == '__attribute__':
+                # TODO(nnorwitz): handle more __attribute__ details.
+                modifiers |= FUNCTION_ATTRIBUTE
+                assert token.name == '(', token
+                # Consume everything between the (parens).
+                unused_tokens = list(self._GetMatchingChar('(', ')'))
+                token = self._GetNextToken()
+            elif modifier_token.name == 'throw':
+                modifiers |= FUNCTION_THROW
+                assert token.name == '(', token
+                # Consume everything between the (parens).
+                unused_tokens = list(self._GetMatchingChar('(', ')'))
+                token = self._GetNextToken()
+            elif modifier_token.name == 'override':
+                modifiers |= FUNCTION_OVERRIDE
+            elif modifier_token.name == modifier_token.name.upper():
+                # HACK(nnorwitz):  assume that all upper-case names
+                # are some macro we aren't expanding.
+                modifiers |= FUNCTION_UNKNOWN_ANNOTATION
+            else:
+                self.HandleError('unexpected token', modifier_token)
+
+        assert token.token_type == tokenize.SYNTAX, token
+        # Handle ctor initializers.
+        if token.name == ':':
+            # TODO(nnorwitz): anything else to handle for initializer list?
+            while token.name != ';' and token.name != '{':
+                token = self._GetNextToken()
+
+        # Handle pointer to functions that are really data but look
+        # like method declarations.
+        if token.name == '(':
+            if parameters[0].name == '*':
+                # name contains the return type.
+                name = parameters.pop()
+                # parameters contains the name of the data.
+                modifiers = [p.name for p in parameters]
+                # Already at the ( to open the parameter list.
+                function_parameters = list(self._GetMatchingChar('(', ')'))
+                del function_parameters[-1]  # Remove trailing ')'.
+                # TODO(nnorwitz): store the function_parameters.
+                token = self._GetNextToken()
+                assert token.token_type == tokenize.SYNTAX, token
+                assert token.name == ';', token
+                return self._CreateVariable(indices, name.name, indices.name,
+                                            modifiers, '', None)
+            # At this point, we got something like:
+            #  return_type (type::*name_)(params);
+            # This is a data member called name_ that is a function pointer.
+            # With this code: void (sq_type::*field_)(string&);
+            # We get: name=void return_type=[] parameters=sq_type ... field_
+            # TODO(nnorwitz): is return_type always empty?
+            # TODO(nnorwitz): this isn't even close to being correct.
+            # Just put in something so we don't crash and can move on.
+            real_name = parameters[-1]
+            modifiers = [p.name for p in self._GetParameters()]
+            del modifiers[-1]           # Remove trailing ')'.
+            return self._CreateVariable(indices, real_name.name, indices.name,
+                                        modifiers, '', None)
+
+        if token.name == '{':
+            body = list(self.GetScope())
+            del body[-1]                # Remove trailing '}'.
+        else:
+            body = None
+            if token.name == '=':
+                token = self._GetNextToken()
+
+                if token.name == 'default' or token.name == 'delete':
+                    # Ignore explicitly defaulted and deleted special members
+                    # in C++11.
+                    token = self._GetNextToken()
+                else:
+                    # Handle pure-virtual declarations.
+                    assert token.token_type == tokenize.CONSTANT, token
+                    assert token.name == '0', token
+                    modifiers |= FUNCTION_PURE_VIRTUAL
+                    token = self._GetNextToken()
+
+            if token.name == '[':
+                # TODO(nnorwitz): store tokens and improve parsing.
+                # template <typename T, size_t N> char (&ASH(T (&seq)[N]))[N];
+                tokens = list(self._GetMatchingChar('[', ']'))
+                token = self._GetNextToken()
+
+            assert token.name == ';', (token, return_type_and_name, parameters)
+
+        # Looks like we got a method, not a function.
+        if len(return_type) > 2 and return_type[-1].name == '::':
+            return_type, in_class = \
+                         self._GetReturnTypeAndClassName(return_type)
+            return Method(indices.start, indices.end, name.name, in_class,
+                          return_type, parameters, modifiers, templated_types,
+                          body, self.namespace_stack)
+        return Function(indices.start, indices.end, name.name, return_type,
+                        parameters, modifiers, templated_types, body,
+                        self.namespace_stack)
+
+    def _GetReturnTypeAndClassName(self, token_seq):
+        # Splitting the return type from the class name in a method
+        # can be tricky.  For example, Return::Type::Is::Hard::To::Find().
+        # Where is the return type and where is the class name?
+        # The heuristic used is to pull the last name as the class name.
+        # This includes all the templated type info.
+        # TODO(nnorwitz): if there is only One name like in the
+        # example above, punt and assume the last bit is the class name.
+
+        # Ignore a :: prefix, if exists so we can find the first real name.
+        i = 0
+        if token_seq[0].name == '::':
+            i = 1
+        # Ignore a :: suffix, if exists.
+        end = len(token_seq) - 1
+        if token_seq[end-1].name == '::':
+            end -= 1
+
+        # Make a copy of the sequence so we can append a sentinel
+        # value. This is required for GetName will has to have some
+        # terminating condition beyond the last name.
+        seq_copy = token_seq[i:end]
+        seq_copy.append(tokenize.Token(tokenize.SYNTAX, '', 0, 0))
+        names = []
+        while i < end:
+            # Iterate through the sequence parsing out each name.
+            new_name, next = self.GetName(seq_copy[i:])
+            assert new_name, 'Got empty new_name, next=%s' % next
+            # We got a pointer or ref.  Add it to the name.
+            if next and next.token_type == tokenize.SYNTAX:
+                new_name.append(next)
+            names.append(new_name)
+            i += len(new_name)
+
+        # Now that we have the names, it's time to undo what we did.
+
+        # Remove the sentinel value.
+        names[-1].pop()
+        # Flatten the token sequence for the return type.
+        return_type = [e for seq in names[:-1] for e in seq]
+        # The class name is the last name.
+        class_name = names[-1]
+        return return_type, class_name
+
+    def handle_bool(self):
+        pass
+
+    def handle_char(self):
+        pass
+
+    def handle_int(self):
+        pass
+
+    def handle_long(self):
+        pass
+
+    def handle_short(self):
+        pass
+
+    def handle_double(self):
+        pass
+
+    def handle_float(self):
+        pass
+
+    def handle_void(self):
+        pass
+
+    def handle_wchar_t(self):
+        pass
+
+    def handle_unsigned(self):
+        pass
+
+    def handle_signed(self):
+        pass
+
+    def _GetNestedType(self, ctor):
+        name = None
+        name_tokens, token = self.GetName()
+        if name_tokens:
+            name = ''.join([t.name for t in name_tokens])
+
+        # Handle forward declarations.
+        if token.token_type == tokenize.SYNTAX and token.name == ';':
+            return ctor(token.start, token.end, name, None,
+                        self.namespace_stack)
+
+        if token.token_type == tokenize.NAME and self._handling_typedef:
+            self._AddBackToken(token)
+            return ctor(token.start, token.end, name, None,
+                        self.namespace_stack)
+
+        # Must be the type declaration.
+        fields = list(self._GetMatchingChar('{', '}'))
+        del fields[-1]                  # Remove trailing '}'.
+        if token.token_type == tokenize.SYNTAX and token.name == '{':
+            next = self._GetNextToken()
+            new_type = ctor(token.start, token.end, name, fields,
+                            self.namespace_stack)
+            # A name means this is an anonymous type and the name
+            # is the variable declaration.
+            if next.token_type != tokenize.NAME:
+                return new_type
+            name = new_type
+            token = next
+
+        # Must be variable declaration using the type prefixed with keyword.
+        assert token.token_type == tokenize.NAME, token
+        return self._CreateVariable(token, token.name, name, [], '', None)
+
+    def handle_struct(self):
+        # Special case the handling typedef/aliasing of structs here.
+        # It would be a pain to handle in the class code.
+        name_tokens, var_token = self.GetName()
+        if name_tokens:
+            next_token = self._GetNextToken()
+            is_syntax = (var_token.token_type == tokenize.SYNTAX and
+                         var_token.name[0] in '*&')
+            is_variable = (var_token.token_type == tokenize.NAME and
+                           next_token.name == ';')
+            variable = var_token
+            if is_syntax and not is_variable:
+                variable = next_token
+                temp = self._GetNextToken()
+                if temp.token_type == tokenize.SYNTAX and temp.name == '(':
+                    # Handle methods declared to return a struct.
+                    t0 = name_tokens[0]
+                    struct = tokenize.Token(tokenize.NAME, 'struct',
+                                            t0.start-7, t0.start-2)
+                    type_and_name = [struct]
+                    type_and_name.extend(name_tokens)
+                    type_and_name.extend((var_token, next_token))
+                    return self._GetMethod(type_and_name, 0, None, False)
+                assert temp.name == ';', (temp, name_tokens, var_token)
+            if is_syntax or (is_variable and not self._handling_typedef):
+                modifiers = ['struct']
+                type_name = ''.join([t.name for t in name_tokens])
+                position = name_tokens[0]
+                return self._CreateVariable(position, variable.name, type_name,
+                                            modifiers, var_token.name, None)
+            name_tokens.extend((var_token, next_token))
+            self._AddBackTokens(name_tokens)
+        else:
+            self._AddBackToken(var_token)
+        return self._GetClass(Struct, VISIBILITY_PUBLIC, None)
+
+    def handle_union(self):
+        return self._GetNestedType(Union)
+
+    def handle_enum(self):
+        return self._GetNestedType(Enum)
+
+    def handle_auto(self):
+        # TODO(nnorwitz): warn about using auto?  Probably not since it
+        # will be reclaimed and useful for C++0x.
+        pass
+
+    def handle_register(self):
+        pass
+
+    def handle_const(self):
+        pass
+
+    def handle_inline(self):
+        pass
+
+    def handle_extern(self):
+        pass
+
+    def handle_static(self):
+        pass
+
+    def handle_virtual(self):
+        # What follows must be a method.
+        token = token2 = self._GetNextToken()
+        if token.name == 'inline':
+            # HACK(nnorwitz): handle inline dtors by ignoring 'inline'.
+            token2 = self._GetNextToken()
+        if token2.token_type == tokenize.SYNTAX and token2.name == '~':
+            return self.GetMethod(FUNCTION_VIRTUAL + FUNCTION_DTOR, None)
+        assert token.token_type == tokenize.NAME or token.name == '::', token
+        return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(')  # )
+        return_type_and_name.insert(0, token)
+        if token2 is not token:
+            return_type_and_name.insert(1, token2)
+        return self._GetMethod(return_type_and_name, FUNCTION_VIRTUAL,
+                               None, False)
+
+    def handle_volatile(self):
+        pass
+
+    def handle_mutable(self):
+        pass
+
+    def handle_public(self):
+        assert self.in_class
+        self.visibility = VISIBILITY_PUBLIC
+
+    def handle_protected(self):
+        assert self.in_class
+        self.visibility = VISIBILITY_PROTECTED
+
+    def handle_private(self):
+        assert self.in_class
+        self.visibility = VISIBILITY_PRIVATE
+
+    def handle_friend(self):
+        tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
+        assert tokens
+        t0 = tokens[0]
+        return Friend(t0.start, t0.end, tokens, self.namespace_stack)
+
+    def handle_static_cast(self):
+        pass
+
+    def handle_const_cast(self):
+        pass
+
+    def handle_dynamic_cast(self):
+        pass
+
+    def handle_reinterpret_cast(self):
+        pass
+
+    def handle_new(self):
+        pass
+
+    def handle_delete(self):
+        tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
+        assert tokens
+        return Delete(tokens[0].start, tokens[0].end, tokens)
+
+    def handle_typedef(self):
+        token = self._GetNextToken()
+        if (token.token_type == tokenize.NAME and
+            keywords.IsKeyword(token.name)):
+            # Token must be struct/enum/union/class.
+            method = getattr(self, 'handle_' + token.name)
+            self._handling_typedef = True
+            tokens = [method()]
+            self._handling_typedef = False
+        else:
+            tokens = [token]
+
+        # Get the remainder of the typedef up to the semi-colon.
+        tokens.extend(self._GetTokensUpTo(tokenize.SYNTAX, ';'))
+
+        # TODO(nnorwitz): clean all this up.
+        assert tokens
+        name = tokens.pop()
+        indices = name
+        if tokens:
+            indices = tokens[0]
+        if not indices:
+            indices = token
+        if name.name == ')':
+            # HACK(nnorwitz): Handle pointers to functions "properly".
+            if (len(tokens) >= 4 and
+                tokens[1].name == '(' and tokens[2].name == '*'):
+                tokens.append(name)
+                name = tokens[3]
+        elif name.name == ']':
+            # HACK(nnorwitz): Handle arrays properly.
+            if len(tokens) >= 2:
+                tokens.append(name)
+                name = tokens[1]
+        new_type = tokens
+        if tokens and isinstance(tokens[0], tokenize.Token):
+            new_type = self.converter.ToType(tokens)[0]
+        return Typedef(indices.start, indices.end, name.name,
+                       new_type, self.namespace_stack)
+
+    def handle_typeid(self):
+        pass  # Not needed yet.
+
+    def handle_typename(self):
+        pass  # Not needed yet.
+
+    def _GetTemplatedTypes(self):
+        result = {}
+        tokens = list(self._GetMatchingChar('<', '>'))
+        len_tokens = len(tokens) - 1    # Ignore trailing '>'.
+        i = 0
+        while i < len_tokens:
+            key = tokens[i].name
+            i += 1
+            if keywords.IsKeyword(key) or key == ',':
+                continue
+            type_name = default = None
+            if i < len_tokens:
+                i += 1
+                if tokens[i-1].name == '=':
+                    assert i < len_tokens, '%s %s' % (i, tokens)
+                    default, unused_next_token = self.GetName(tokens[i:])
+                    i += len(default)
+                else:
+                    if tokens[i-1].name != ',':
+                        # We got something like: Type variable.
+                        # Re-adjust the key (variable) and type_name (Type).
+                        key = tokens[i-1].name
+                        type_name = tokens[i-2]
+
+            result[key] = (type_name, default)
+        return result
+
+    def handle_template(self):
+        token = self._GetNextToken()
+        assert token.token_type == tokenize.SYNTAX, token
+        assert token.name == '<', token
+        templated_types = self._GetTemplatedTypes()
+        # TODO(nnorwitz): for now, just ignore the template params.
+        token = self._GetNextToken()
+        if token.token_type == tokenize.NAME:
+            if token.name == 'class':
+                return self._GetClass(Class, VISIBILITY_PRIVATE, templated_types)
+            elif token.name == 'struct':
+                return self._GetClass(Struct, VISIBILITY_PUBLIC, templated_types)
+            elif token.name == 'friend':
+                return self.handle_friend()
+        self._AddBackToken(token)
+        tokens, last = self._GetVarTokensUpTo(tokenize.SYNTAX, '(', ';')
+        tokens.append(last)
+        self._AddBackTokens(tokens)
+        if last.name == '(':
+            return self.GetMethod(FUNCTION_NONE, templated_types)
+        # Must be a variable definition.
+        return None
+
+    def handle_true(self):
+        pass  # Nothing to do.
+
+    def handle_false(self):
+        pass  # Nothing to do.
+
+    def handle_asm(self):
+        pass  # Not needed yet.
+
+    def handle_class(self):
+        return self._GetClass(Class, VISIBILITY_PRIVATE, None)
+
+    def _GetBases(self):
+        # Get base classes.
+        bases = []
+        while 1:
+            token = self._GetNextToken()
+            assert token.token_type == tokenize.NAME, token
+            # TODO(nnorwitz): store kind of inheritance...maybe.
+            if token.name not in ('public', 'protected', 'private'):
+                # If inheritance type is not specified, it is private.
+                # Just put the token back so we can form a name.
+                # TODO(nnorwitz): it would be good to warn about this.
+                self._AddBackToken(token)
+            else:
+                # Check for virtual inheritance.
+                token = self._GetNextToken()
+                if token.name != 'virtual':
+                    self._AddBackToken(token)
+                else:
+                    # TODO(nnorwitz): store that we got virtual for this base.
+                    pass
+            base, next_token = self.GetName()
+            bases_ast = self.converter.ToType(base)
+            assert len(bases_ast) == 1, bases_ast
+            bases.append(bases_ast[0])
+            assert next_token.token_type == tokenize.SYNTAX, next_token
+            if next_token.name == '{':
+                token = next_token
+                break
+            # Support multiple inheritance.
+            assert next_token.name == ',', next_token
+        return bases, token
+
+    def _GetClass(self, class_type, visibility, templated_types):
+        class_name = None
+        class_token = self._GetNextToken()
+        if class_token.token_type != tokenize.NAME:
+            assert class_token.token_type == tokenize.SYNTAX, class_token
+            token = class_token
+        else:
+            # Skip any macro (e.g. storage class specifiers) after the
+            # 'class' keyword.
+            next_token = self._GetNextToken()
+            if next_token.token_type == tokenize.NAME:
+                self._AddBackToken(next_token)
+            else:
+                self._AddBackTokens([class_token, next_token])
+            name_tokens, token = self.GetName()
+            class_name = ''.join([t.name for t in name_tokens])
+        bases = None
+        if token.token_type == tokenize.SYNTAX:
+            if token.name == ';':
+                # Forward declaration.
+                return class_type(class_token.start, class_token.end,
+                                  class_name, None, templated_types, None,
+                                  self.namespace_stack)
+            if token.name in '*&':
+                # Inline forward declaration.  Could be method or data.
+                name_token = self._GetNextToken()
+                next_token = self._GetNextToken()
+                if next_token.name == ';':
+                    # Handle data
+                    modifiers = ['class']
+                    return self._CreateVariable(class_token, name_token.name,
+                                                class_name,
+                                                modifiers, token.name, None)
+                else:
+                    # Assume this is a method.
+                    tokens = (class_token, token, name_token, next_token)
+                    self._AddBackTokens(tokens)
+                    return self.GetMethod(FUNCTION_NONE, None)
+            if token.name == ':':
+                bases, token = self._GetBases()
+
+        body = None
+        if token.token_type == tokenize.SYNTAX and token.name == '{':
+            assert token.token_type == tokenize.SYNTAX, token
+            assert token.name == '{', token
+
+            ast = AstBuilder(self.GetScope(), self.filename, class_name,
+                             visibility, self.namespace_stack)
+            body = list(ast.Generate())
+
+            if not self._handling_typedef:
+                token = self._GetNextToken()
+                if token.token_type != tokenize.NAME:
+                    assert token.token_type == tokenize.SYNTAX, token
+                    assert token.name == ';', token
+                else:
+                    new_class = class_type(class_token.start, class_token.end,
+                                           class_name, bases, None,
+                                           body, self.namespace_stack)
+
+                    modifiers = []
+                    return self._CreateVariable(class_token,
+                                                token.name, new_class,
+                                                modifiers, token.name, None)
+        else:
+            if not self._handling_typedef:
+                self.HandleError('non-typedef token', token)
+            self._AddBackToken(token)
+
+        return class_type(class_token.start, class_token.end, class_name,
+                          bases, templated_types, body, self.namespace_stack)
+
+    def handle_namespace(self):
+        token = self._GetNextToken()
+        # Support anonymous namespaces.
+        name = None
+        if token.token_type == tokenize.NAME:
+            name = token.name
+            token = self._GetNextToken()
+        self.namespace_stack.append(name)
+        assert token.token_type == tokenize.SYNTAX, token
+        # Create an internal token that denotes when the namespace is complete.
+        internal_token = tokenize.Token(_INTERNAL_TOKEN, _NAMESPACE_POP,
+                                        None, None)
+        internal_token.whence = token.whence
+        if token.name == '=':
+            # TODO(nnorwitz): handle aliasing namespaces.
+            name, next_token = self.GetName()
+            assert next_token.name == ';', next_token
+            self._AddBackToken(internal_token)
+        else:
+            assert token.name == '{', token
+            tokens = list(self.GetScope())
+            # Replace the trailing } with the internal namespace pop token.
+            tokens[-1] = internal_token
+            # Handle namespace with nothing in it.
+            self._AddBackTokens(tokens)
+        return None
+
+    def handle_using(self):
+        tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
+        assert tokens
+        return Using(tokens[0].start, tokens[0].end, tokens)
+
+    def handle_explicit(self):
+        assert self.in_class
+        # Nothing much to do.
+        # TODO(nnorwitz): maybe verify the method name == class name.
+        # This must be a ctor.
+        return self.GetMethod(FUNCTION_CTOR, None)
+
+    def handle_this(self):
+        pass  # Nothing to do.
+
+    def handle_operator(self):
+        # Pull off the next token(s?) and make that part of the method name.
+        pass
+
+    def handle_sizeof(self):
+        pass
+
+    def handle_case(self):
+        pass
+
+    def handle_switch(self):
+        pass
+
+    def handle_default(self):
+        token = self._GetNextToken()
+        assert token.token_type == tokenize.SYNTAX
+        assert token.name == ':'
+
+    def handle_if(self):
+        pass
+
+    def handle_else(self):
+        pass
+
+    def handle_return(self):
+        tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
+        if not tokens:
+            return Return(self.current_token.start, self.current_token.end, None)
+        return Return(tokens[0].start, tokens[0].end, tokens)
+
+    def handle_goto(self):
+        tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
+        assert len(tokens) == 1, str(tokens)
+        return Goto(tokens[0].start, tokens[0].end, tokens[0].name)
+
+    def handle_try(self):
+        pass  # Not needed yet.
+
+    def handle_catch(self):
+        pass  # Not needed yet.
+
+    def handle_throw(self):
+        pass  # Not needed yet.
+
+    def handle_while(self):
+        pass
+
+    def handle_do(self):
+        pass
+
+    def handle_for(self):
+        pass
+
+    def handle_break(self):
+        self._IgnoreUpTo(tokenize.SYNTAX, ';')
+
+    def handle_continue(self):
+        self._IgnoreUpTo(tokenize.SYNTAX, ';')
+
+
+def BuilderFromSource(source, filename):
+    """Utility method that returns an AstBuilder from source code.
+
+    Args:
+      source: 'C++ source code'
+      filename: 'file1'
+
+    Returns:
+      AstBuilder
+    """
+    return AstBuilder(tokenize.GetTokens(source), filename)
+
+
+def PrintIndentifiers(filename, should_print):
+    """Prints all identifiers for a C++ source file.
+
+    Args:
+      filename: 'file1'
+      should_print: predicate with signature: bool Function(token)
+    """
+    source = utils.ReadFile(filename, False)
+    if source is None:
+        sys.stderr.write('Unable to find: %s\n' % filename)
+        return
+
+    #print('Processing %s' % actual_filename)
+    builder = BuilderFromSource(source, filename)
+    try:
+        for node in builder.Generate():
+            if should_print(node):
+                print(node.name)
+    except KeyboardInterrupt:
+        return
+    except:
+        pass
+
+
+def PrintAllIndentifiers(filenames, should_print):
+    """Prints all identifiers for each C++ source file in filenames.
+
+    Args:
+      filenames: ['file1', 'file2', ...]
+      should_print: predicate with signature: bool Function(token)
+    """
+    for path in filenames:
+        PrintIndentifiers(path, should_print)
+
+
+def main(argv):
+    for filename in argv[1:]:
+        source = utils.ReadFile(filename)
+        if source is None:
+            continue
+
+        print('Processing %s' % filename)
+        builder = BuilderFromSource(source, filename)
+        try:
+            entire_ast = filter(None, builder.Generate())
+        except KeyboardInterrupt:
+            return
+        except:
+            # Already printed a warning, print the traceback and continue.
+            traceback.print_exc()
+        else:
+            if utils.DEBUG:
+                for ast in entire_ast:
+                    print(ast)
+
+
+if __name__ == '__main__':
+    main(sys.argv)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class.py
new file mode 100755
index 00000000..f9966cbb
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class.py
@@ -0,0 +1,227 @@
+#!/usr/bin/env python
+#
+# Copyright 2008 Google Inc.  All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Generate Google Mock classes from base classes.
+
+This program will read in a C++ source file and output the Google Mock
+classes for the specified classes.  If no class is specified, all
+classes in the source file are emitted.
+
+Usage:
+  gmock_class.py header-file.h [ClassName]...
+
+Output is sent to stdout.
+"""
+
+__author__ = 'nnorwitz@google.com (Neal Norwitz)'
+
+
+import os
+import re
+import sys
+
+from cpp import ast
+from cpp import utils
+
+# Preserve compatibility with Python 2.3.
+try:
+  _dummy = set
+except NameError:
+  import sets
+  set = sets.Set
+
+_VERSION = (1, 0, 1)  # The version of this script.
+# How many spaces to indent.  Can set me with the INDENT environment variable.
+_INDENT = 2
+
+
+def _GenerateMethods(output_lines, source, class_node):
+  function_type = (ast.FUNCTION_VIRTUAL | ast.FUNCTION_PURE_VIRTUAL |
+                   ast.FUNCTION_OVERRIDE)
+  ctor_or_dtor = ast.FUNCTION_CTOR | ast.FUNCTION_DTOR
+  indent = ' ' * _INDENT
+
+  for node in class_node.body:
+    # We only care about virtual functions.
+    if (isinstance(node, ast.Function) and
+        node.modifiers & function_type and
+        not node.modifiers & ctor_or_dtor):
+      # Pick out all the elements we need from the original function.
+      const = ''
+      if node.modifiers & ast.FUNCTION_CONST:
+        const = 'CONST_'
+      return_type = 'void'
+      if node.return_type:
+        # Add modifiers like 'const'.
+        modifiers = ''
+        if node.return_type.modifiers:
+          modifiers = ' '.join(node.return_type.modifiers) + ' '
+        return_type = modifiers + node.return_type.name
+        template_args = [arg.name for arg in node.return_type.templated_types]
+        if template_args:
+          return_type += '<' + ', '.join(template_args) + '>'
+          if len(template_args) > 1:
+            for line in [
+                '// The following line won\'t really compile, as the return',
+                '// type has multiple template arguments.  To fix it, use a',
+                '// typedef for the return type.']:
+              output_lines.append(indent + line)
+        if node.return_type.pointer:
+          return_type += '*'
+        if node.return_type.reference:
+          return_type += '&'
+        num_parameters = len(node.parameters)
+        if len(node.parameters) == 1:
+          first_param = node.parameters[0]
+          if source[first_param.start:first_param.end].strip() == 'void':
+            # We must treat T(void) as a function with no parameters.
+            num_parameters = 0
+      tmpl = ''
+      if class_node.templated_types:
+        tmpl = '_T'
+      mock_method_macro = 'MOCK_%sMETHOD%d%s' % (const, num_parameters, tmpl)
+
+      args = ''
+      if node.parameters:
+        # Due to the parser limitations, it is impossible to keep comments
+        # while stripping the default parameters.  When defaults are
+        # present, we choose to strip them and comments (and produce
+        # compilable code).
+        # TODO(nnorwitz@google.com): Investigate whether it is possible to
+        # preserve parameter name when reconstructing parameter text from
+        # the AST.
+        if len([param for param in node.parameters if param.default]) > 0:
+          args = ', '.join(param.type.name for param in node.parameters)
+        else:
+          # Get the full text of the parameters from the start
+          # of the first parameter to the end of the last parameter.
+          start = node.parameters[0].start
+          end = node.parameters[-1].end
+          # Remove // comments.
+          args_strings = re.sub(r'//.*', '', source[start:end])
+          # Condense multiple spaces and eliminate newlines putting the
+          # parameters together on a single line.  Ensure there is a
+          # space in an argument which is split by a newline without
+          # intervening whitespace, e.g.: int\nBar
+          args = re.sub('  +', ' ', args_strings.replace('\n', ' '))
+
+      # Create the mock method definition.
+      output_lines.extend(['%s%s(%s,' % (indent, mock_method_macro, node.name),
+                           '%s%s(%s));' % (indent*3, return_type, args)])
+
+
+def _GenerateMocks(filename, source, ast_list, desired_class_names):
+  processed_class_names = set()
+  lines = []
+  for node in ast_list:
+    if (isinstance(node, ast.Class) and node.body and
+        # desired_class_names being None means that all classes are selected.
+        (not desired_class_names or node.name in desired_class_names)):
+      class_name = node.name
+      parent_name = class_name
+      processed_class_names.add(class_name)
+      class_node = node
+      # Add namespace before the class.
+      if class_node.namespace:
+        lines.extend(['namespace %s {' % n for n in class_node.namespace])  # }
+        lines.append('')
+
+      # Add template args for templated classes.
+      if class_node.templated_types:
+        # TODO(paulchang): The AST doesn't preserve template argument order,
+        # so we have to make up names here.
+        # TODO(paulchang): Handle non-type template arguments (e.g.
+        # template<typename T, int N>).
+        template_arg_count = len(class_node.templated_types.keys())
+        template_args = ['T%d' % n for n in range(template_arg_count)]
+        template_decls = ['typename ' + arg for arg in template_args]
+        lines.append('template <' + ', '.join(template_decls) + '>')
+        parent_name += '<' + ', '.join(template_args) + '>'
+
+      # Add the class prolog.
+      lines.append('class Mock%s : public %s {'  # }
+                   % (class_name, parent_name))
+      lines.append('%spublic:' % (' ' * (_INDENT // 2)))
+
+      # Add all the methods.
+      _GenerateMethods(lines, source, class_node)
+
+      # Close the class.
+      if lines:
+        # If there are no virtual methods, no need for a public label.
+        if len(lines) == 2:
+          del lines[-1]
+
+        # Only close the class if there really is a class.
+        lines.append('};')
+        lines.append('')  # Add an extra newline.
+
+      # Close the namespace.
+      if class_node.namespace:
+        for i in range(len(class_node.namespace)-1, -1, -1):
+          lines.append('}  // namespace %s' % class_node.namespace[i])
+        lines.append('')  # Add an extra newline.
+
+  if desired_class_names:
+    missing_class_name_list = list(desired_class_names - processed_class_names)
+    if missing_class_name_list:
+      missing_class_name_list.sort()
+      sys.stderr.write('Class(es) not found in %s: %s\n' %
+                       (filename, ', '.join(missing_class_name_list)))
+  elif not processed_class_names:
+    sys.stderr.write('No class found in %s\n' % filename)
+
+  return lines
+
+
+def main(argv=sys.argv):
+  if len(argv) < 2:
+    sys.stderr.write('Google Mock Class Generator v%s\n\n' %
+                     '.'.join(map(str, _VERSION)))
+    sys.stderr.write(__doc__)
+    return 1
+
+  global _INDENT
+  try:
+    _INDENT = int(os.environ['INDENT'])
+  except KeyError:
+    pass
+  except:
+    sys.stderr.write('Unable to use indent of %s\n' % os.environ.get('INDENT'))
+
+  filename = argv[1]
+  desired_class_names = None  # None means all classes in the source file.
+  if len(argv) >= 3:
+    desired_class_names = set(argv[2:])
+  source = utils.ReadFile(filename)
+  if source is None:
+    return 1
+
+  builder = ast.BuilderFromSource(source, filename)
+  try:
+    entire_ast = filter(None, builder.Generate())
+  except KeyboardInterrupt:
+    return
+  except:
+    # An error message was already printed since we couldn't parse.
+    sys.exit(1)
+  else:
+    lines = _GenerateMocks(filename, source, entire_ast, desired_class_names)
+    sys.stdout.write('\n'.join(lines))
+
+
+if __name__ == '__main__':
+  main(sys.argv)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class_test.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class_test.py
new file mode 100755
index 00000000..018f90a6
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class_test.py
@@ -0,0 +1,448 @@
+#!/usr/bin/env python
+#
+# Copyright 2009 Neal Norwitz All Rights Reserved.
+# Portions Copyright 2009 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tests for gmock.scripts.generator.cpp.gmock_class."""
+
+__author__ = 'nnorwitz@google.com (Neal Norwitz)'
+
+
+import os
+import sys
+import unittest
+
+# Allow the cpp imports below to work when run as a standalone script.
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
+from cpp import ast
+from cpp import gmock_class
+
+
+class TestCase(unittest.TestCase):
+  """Helper class that adds assert methods."""
+
+  def StripLeadingWhitespace(self, lines):
+    """Strip leading whitespace in each line in 'lines'."""
+    return '\n'.join([s.lstrip() for s in lines.split('\n')])
+
+  def assertEqualIgnoreLeadingWhitespace(self, expected_lines, lines):
+    """Specialized assert that ignores the indent level."""
+    self.assertEqual(expected_lines, self.StripLeadingWhitespace(lines))
+
+
+class GenerateMethodsTest(TestCase):
+
+  def GenerateMethodSource(self, cpp_source):
+    """Convert C++ source to Google Mock output source lines."""
+    method_source_lines = []
+    # <test> is a pseudo-filename, it is not read or written.
+    builder = ast.BuilderFromSource(cpp_source, '<test>')
+    ast_list = list(builder.Generate())
+    gmock_class._GenerateMethods(method_source_lines, cpp_source, ast_list[0])
+    return '\n'.join(method_source_lines)
+
+  def testSimpleMethod(self):
+    source = """
+class Foo {
+ public:
+  virtual int Bar();
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD0(Bar,\nint());',
+        self.GenerateMethodSource(source))
+
+  def testSimpleConstructorsAndDestructor(self):
+    source = """
+class Foo {
+ public:
+  Foo();
+  Foo(int x);
+  Foo(const Foo& f);
+  Foo(Foo&& f);
+  ~Foo();
+  virtual int Bar() = 0;
+};
+"""
+    # The constructors and destructor should be ignored.
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD0(Bar,\nint());',
+        self.GenerateMethodSource(source))
+
+  def testVirtualDestructor(self):
+    source = """
+class Foo {
+ public:
+  virtual ~Foo();
+  virtual int Bar() = 0;
+};
+"""
+    # The destructor should be ignored.
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD0(Bar,\nint());',
+        self.GenerateMethodSource(source))
+
+  def testExplicitlyDefaultedConstructorsAndDestructor(self):
+    source = """
+class Foo {
+ public:
+  Foo() = default;
+  Foo(const Foo& f) = default;
+  Foo(Foo&& f) = default;
+  ~Foo() = default;
+  virtual int Bar() = 0;
+};
+"""
+    # The constructors and destructor should be ignored.
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD0(Bar,\nint());',
+        self.GenerateMethodSource(source))
+
+  def testExplicitlyDeletedConstructorsAndDestructor(self):
+    source = """
+class Foo {
+ public:
+  Foo() = delete;
+  Foo(const Foo& f) = delete;
+  Foo(Foo&& f) = delete;
+  ~Foo() = delete;
+  virtual int Bar() = 0;
+};
+"""
+    # The constructors and destructor should be ignored.
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD0(Bar,\nint());',
+        self.GenerateMethodSource(source))
+
+  def testSimpleOverrideMethod(self):
+    source = """
+class Foo {
+ public:
+  int Bar() override;
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD0(Bar,\nint());',
+        self.GenerateMethodSource(source))
+
+  def testSimpleConstMethod(self):
+    source = """
+class Foo {
+ public:
+  virtual void Bar(bool flag) const;
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_CONST_METHOD1(Bar,\nvoid(bool flag));',
+        self.GenerateMethodSource(source))
+
+  def testExplicitVoid(self):
+    source = """
+class Foo {
+ public:
+  virtual int Bar(void);
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD0(Bar,\nint(void));',
+        self.GenerateMethodSource(source))
+
+  def testStrangeNewlineInParameter(self):
+    source = """
+class Foo {
+ public:
+  virtual void Bar(int
+a) = 0;
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD1(Bar,\nvoid(int a));',
+        self.GenerateMethodSource(source))
+
+  def testDefaultParameters(self):
+    source = """
+class Foo {
+ public:
+  virtual void Bar(int a, char c = 'x') = 0;
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD2(Bar,\nvoid(int, char));',
+        self.GenerateMethodSource(source))
+
+  def testMultipleDefaultParameters(self):
+    source = """
+class Foo {
+ public:
+  virtual void Bar(int a = 42, char c = 'x') = 0;
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD2(Bar,\nvoid(int, char));',
+        self.GenerateMethodSource(source))
+
+  def testRemovesCommentsWhenDefaultsArePresent(self):
+    source = """
+class Foo {
+ public:
+  virtual void Bar(int a = 42 /* a comment */,
+                   char /* other comment */ c= 'x') = 0;
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD2(Bar,\nvoid(int, char));',
+        self.GenerateMethodSource(source))
+
+  def testDoubleSlashCommentsInParameterListAreRemoved(self):
+    source = """
+class Foo {
+ public:
+  virtual void Bar(int a,  // inline comments should be elided.
+                   int b   // inline comments should be elided.
+                   ) const = 0;
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_CONST_METHOD2(Bar,\nvoid(int a, int b));',
+        self.GenerateMethodSource(source))
+
+  def testCStyleCommentsInParameterListAreNotRemoved(self):
+    # NOTE(nnorwitz): I'm not sure if it's the best behavior to keep these
+    # comments.  Also note that C style comments after the last parameter
+    # are still elided.
+    source = """
+class Foo {
+ public:
+  virtual const string& Bar(int /* keeper */, int b);
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD2(Bar,\nconst string&(int /* keeper */, int b));',
+        self.GenerateMethodSource(source))
+
+  def testArgsOfTemplateTypes(self):
+    source = """
+class Foo {
+ public:
+  virtual int Bar(const vector<int>& v, map<int, string>* output);
+};"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD2(Bar,\n'
+        'int(const vector<int>& v, map<int, string>* output));',
+        self.GenerateMethodSource(source))
+
+  def testReturnTypeWithOneTemplateArg(self):
+    source = """
+class Foo {
+ public:
+  virtual vector<int>* Bar(int n);
+};"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD1(Bar,\nvector<int>*(int n));',
+        self.GenerateMethodSource(source))
+
+  def testReturnTypeWithManyTemplateArgs(self):
+    source = """
+class Foo {
+ public:
+  virtual map<int, string> Bar();
+};"""
+    # Comparing the comment text is brittle - we'll think of something
+    # better in case this gets annoying, but for now let's keep it simple.
+    self.assertEqualIgnoreLeadingWhitespace(
+        '// The following line won\'t really compile, as the return\n'
+        '// type has multiple template arguments.  To fix it, use a\n'
+        '// typedef for the return type.\n'
+        'MOCK_METHOD0(Bar,\nmap<int, string>());',
+        self.GenerateMethodSource(source))
+
+  def testSimpleMethodInTemplatedClass(self):
+    source = """
+template<class T>
+class Foo {
+ public:
+  virtual int Bar();
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD0_T(Bar,\nint());',
+        self.GenerateMethodSource(source))
+
+  def testPointerArgWithoutNames(self):
+    source = """
+class Foo {
+  virtual int Bar(C*);
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD1(Bar,\nint(C*));',
+        self.GenerateMethodSource(source))
+
+  def testReferenceArgWithoutNames(self):
+    source = """
+class Foo {
+  virtual int Bar(C&);
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD1(Bar,\nint(C&));',
+        self.GenerateMethodSource(source))
+
+  def testArrayArgWithoutNames(self):
+    source = """
+class Foo {
+  virtual int Bar(C[]);
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD1(Bar,\nint(C[]));',
+        self.GenerateMethodSource(source))
+
+
+class GenerateMocksTest(TestCase):
+
+  def GenerateMocks(self, cpp_source):
+    """Convert C++ source to complete Google Mock output source."""
+    # <test> is a pseudo-filename, it is not read or written.
+    filename = '<test>'
+    builder = ast.BuilderFromSource(cpp_source, filename)
+    ast_list = list(builder.Generate())
+    lines = gmock_class._GenerateMocks(filename, cpp_source, ast_list, None)
+    return '\n'.join(lines)
+
+  def testNamespaces(self):
+    source = """
+namespace Foo {
+namespace Bar { class Forward; }
+namespace Baz {
+
+class Test {
+ public:
+  virtual void Foo();
+};
+
+}  // namespace Baz
+}  // namespace Foo
+"""
+    expected = """\
+namespace Foo {
+namespace Baz {
+
+class MockTest : public Test {
+public:
+MOCK_METHOD0(Foo,
+void());
+};
+
+}  // namespace Baz
+}  // namespace Foo
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        expected, self.GenerateMocks(source))
+
+  def testClassWithStorageSpecifierMacro(self):
+    source = """
+class STORAGE_SPECIFIER Test {
+ public:
+  virtual void Foo();
+};
+"""
+    expected = """\
+class MockTest : public Test {
+public:
+MOCK_METHOD0(Foo,
+void());
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        expected, self.GenerateMocks(source))
+
+  def testTemplatedForwardDeclaration(self):
+    source = """
+template <class T> class Forward;  // Forward declaration should be ignored.
+class Test {
+ public:
+  virtual void Foo();
+};
+"""
+    expected = """\
+class MockTest : public Test {
+public:
+MOCK_METHOD0(Foo,
+void());
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        expected, self.GenerateMocks(source))
+
+  def testTemplatedClass(self):
+    source = """
+template <typename S, typename T>
+class Test {
+ public:
+  virtual void Foo();
+};
+"""
+    expected = """\
+template <typename T0, typename T1>
+class MockTest : public Test<T0, T1> {
+public:
+MOCK_METHOD0_T(Foo,
+void());
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        expected, self.GenerateMocks(source))
+
+  def testTemplateInATemplateTypedef(self):
+    source = """
+class Test {
+ public:
+  typedef std::vector<std::list<int>> FooType;
+  virtual void Bar(const FooType& test_arg);
+};
+"""
+    expected = """\
+class MockTest : public Test {
+public:
+MOCK_METHOD1(Bar,
+void(const FooType& test_arg));
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        expected, self.GenerateMocks(source))
+
+  def testTemplateInATemplateTypedefWithComma(self):
+    source = """
+class Test {
+ public:
+  typedef std::function<void(
+      const vector<std::list<int>>&, int> FooType;
+  virtual void Bar(const FooType& test_arg);
+};
+"""
+    expected = """\
+class MockTest : public Test {
+public:
+MOCK_METHOD1(Bar,
+void(const FooType& test_arg));
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        expected, self.GenerateMocks(source))
+
+if __name__ == '__main__':
+  unittest.main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/keywords.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/keywords.py
new file mode 100755
index 00000000..f694450e
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/keywords.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+#
+# Copyright 2007 Neal Norwitz
+# Portions Copyright 2007 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""C++ keywords and helper utilities for determining keywords."""
+
+__author__ = 'nnorwitz@google.com (Neal Norwitz)'
+
+
+try:
+    # Python 3.x
+    import builtins
+except ImportError:
+    # Python 2.x
+    import __builtin__ as builtins
+
+
+if not hasattr(builtins, 'set'):
+    # Nominal support for Python 2.3.
+    from sets import Set as set
+
+
+TYPES = set('bool char int long short double float void wchar_t unsigned signed'.split())
+TYPE_MODIFIERS = set('auto register const inline extern static virtual volatile mutable'.split())
+ACCESS = set('public protected private friend'.split())
+
+CASTS = set('static_cast const_cast dynamic_cast reinterpret_cast'.split())
+
+OTHERS = set('true false asm class namespace using explicit this operator sizeof'.split())
+OTHER_TYPES = set('new delete typedef struct union enum typeid typename template'.split())
+
+CONTROL = set('case switch default if else return goto'.split())
+EXCEPTION = set('try catch throw'.split())
+LOOP = set('while do for break continue'.split())
+
+ALL = TYPES | TYPE_MODIFIERS | ACCESS | CASTS | OTHERS | OTHER_TYPES | CONTROL | EXCEPTION | LOOP
+
+
+def IsKeyword(token):
+    return token in ALL
+
+def IsBuiltinType(token):
+    if token in ('virtual', 'inline'):
+        # These only apply to methods, they can't be types by themselves.
+        return False
+    return token in TYPES or token in TYPE_MODIFIERS
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/tokenize.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/tokenize.py
new file mode 100755
index 00000000..359d5562
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/tokenize.py
@@ -0,0 +1,287 @@
+#!/usr/bin/env python
+#
+# Copyright 2007 Neal Norwitz
+# Portions Copyright 2007 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tokenize C++ source code."""
+
+__author__ = 'nnorwitz@google.com (Neal Norwitz)'
+
+
+try:
+    # Python 3.x
+    import builtins
+except ImportError:
+    # Python 2.x
+    import __builtin__ as builtins
+
+
+import sys
+
+from cpp import utils
+
+
+if not hasattr(builtins, 'set'):
+    # Nominal support for Python 2.3.
+    from sets import Set as set
+
+
+# Add $ as a valid identifier char since so much code uses it.
+_letters = 'abcdefghijklmnopqrstuvwxyz'
+VALID_IDENTIFIER_CHARS = set(_letters + _letters.upper() + '_0123456789$')
+HEX_DIGITS = set('0123456789abcdefABCDEF')
+INT_OR_FLOAT_DIGITS = set('01234567890eE-+')
+
+
+# C++0x string preffixes.
+_STR_PREFIXES = set(('R', 'u8', 'u8R', 'u', 'uR', 'U', 'UR', 'L', 'LR'))
+
+
+# Token types.
+UNKNOWN = 'UNKNOWN'
+SYNTAX = 'SYNTAX'
+CONSTANT = 'CONSTANT'
+NAME = 'NAME'
+PREPROCESSOR = 'PREPROCESSOR'
+
+# Where the token originated from.  This can be used for backtracking.
+# It is always set to WHENCE_STREAM in this code.
+WHENCE_STREAM, WHENCE_QUEUE = range(2)
+
+
+class Token(object):
+    """Data container to represent a C++ token.
+
+    Tokens can be identifiers, syntax char(s), constants, or
+    pre-processor directives.
+
+    start contains the index of the first char of the token in the source
+    end contains the index of the last char of the token in the source
+    """
+
+    def __init__(self, token_type, name, start, end):
+        self.token_type = token_type
+        self.name = name
+        self.start = start
+        self.end = end
+        self.whence = WHENCE_STREAM
+
+    def __str__(self):
+        if not utils.DEBUG:
+            return 'Token(%r)' % self.name
+        return 'Token(%r, %s, %s)' % (self.name, self.start, self.end)
+
+    __repr__ = __str__
+
+
+def _GetString(source, start, i):
+    i = source.find('"', i+1)
+    while source[i-1] == '\\':
+        # Count the trailing backslashes.
+        backslash_count = 1
+        j = i - 2
+        while source[j] == '\\':
+            backslash_count += 1
+            j -= 1
+        # When trailing backslashes are even, they escape each other.
+        if (backslash_count % 2) == 0:
+            break
+        i = source.find('"', i+1)
+    return i + 1
+
+
+def _GetChar(source, start, i):
+    # NOTE(nnorwitz): may not be quite correct, should be good enough.
+    i = source.find("'", i+1)
+    while source[i-1] == '\\':
+        # Need to special case '\\'.
+        if (i - 2) > start and source[i-2] == '\\':
+            break
+        i = source.find("'", i+1)
+    # Try to handle unterminated single quotes (in a #if 0 block).
+    if i < 0:
+        i = start
+    return i + 1
+
+
+def GetTokens(source):
+    """Returns a sequence of Tokens.
+
+    Args:
+      source: string of C++ source code.
+
+    Yields:
+      Token that represents the next token in the source.
+    """
+    # Cache various valid character sets for speed.
+    valid_identifier_chars = VALID_IDENTIFIER_CHARS
+    hex_digits = HEX_DIGITS
+    int_or_float_digits = INT_OR_FLOAT_DIGITS
+    int_or_float_digits2 = int_or_float_digits | set('.')
+
+    # Only ignore errors while in a #if 0 block.
+    ignore_errors = False
+    count_ifs = 0
+
+    i = 0
+    end = len(source)
+    while i < end:
+        # Skip whitespace.
+        while i < end and source[i].isspace():
+            i += 1
+        if i >= end:
+            return
+
+        token_type = UNKNOWN
+        start = i
+        c = source[i]
+        if c.isalpha() or c == '_':              # Find a string token.
+            token_type = NAME
+            while source[i] in valid_identifier_chars:
+                i += 1
+            # String and character constants can look like a name if
+            # they are something like L"".
+            if (source[i] == "'" and (i - start) == 1 and
+                source[start:i] in 'uUL'):
+                # u, U, and L are valid C++0x character preffixes.
+                token_type = CONSTANT
+                i = _GetChar(source, start, i)
+            elif source[i] == "'" and source[start:i] in _STR_PREFIXES:
+                token_type = CONSTANT
+                i = _GetString(source, start, i)
+        elif c == '/' and source[i+1] == '/':    # Find // comments.
+            i = source.find('\n', i)
+            if i == -1:  # Handle EOF.
+                i = end
+            continue
+        elif c == '/' and source[i+1] == '*':    # Find /* comments. */
+            i = source.find('*/', i) + 2
+            continue
+        elif c in ':+-<>&|*=':                   # : or :: (plus other chars).
+            token_type = SYNTAX
+            i += 1
+            new_ch = source[i]
+            if new_ch == c and c != '>':         # Treat ">>" as two tokens.
+                i += 1
+            elif c == '-' and new_ch == '>':
+                i += 1
+            elif new_ch == '=':
+                i += 1
+        elif c in '()[]{}~!?^%;/.,':             # Handle single char tokens.
+            token_type = SYNTAX
+            i += 1
+            if c == '.' and source[i].isdigit():
+                token_type = CONSTANT
+                i += 1
+                while source[i] in int_or_float_digits:
+                    i += 1
+                # Handle float suffixes.
+                for suffix in ('l', 'f'):
+                    if suffix == source[i:i+1].lower():
+                        i += 1
+                        break
+        elif c.isdigit():                        # Find integer.
+            token_type = CONSTANT
+            if c == '0' and source[i+1] in 'xX':
+                # Handle hex digits.
+                i += 2
+                while source[i] in hex_digits:
+                    i += 1
+            else:
+                while source[i] in int_or_float_digits2:
+                    i += 1
+            # Handle integer (and float) suffixes.
+            for suffix in ('ull', 'll', 'ul', 'l', 'f', 'u'):
+                size = len(suffix)
+                if suffix == source[i:i+size].lower():
+                    i += size
+                    break
+        elif c == '"':                           # Find string.
+            token_type = CONSTANT
+            i = _GetString(source, start, i)
+        elif c == "'":                           # Find char.
+            token_type = CONSTANT
+            i = _GetChar(source, start, i)
+        elif c == '#':                           # Find pre-processor command.
+            token_type = PREPROCESSOR
+            got_if = source[i:i+3] == '#if' and source[i+3:i+4].isspace()
+            if got_if:
+                count_ifs += 1
+            elif source[i:i+6] == '#endif':
+                count_ifs -= 1
+                if count_ifs == 0:
+                    ignore_errors = False
+
+            # TODO(nnorwitz): handle preprocessor statements (\ continuations).
+            while 1:
+                i1 = source.find('\n', i)
+                i2 = source.find('//', i)
+                i3 = source.find('/*', i)
+                i4 = source.find('"', i)
+                # NOTE(nnorwitz): doesn't handle comments in #define macros.
+                # Get the first important symbol (newline, comment, EOF/end).
+                i = min([x for x in (i1, i2, i3, i4, end) if x != -1])
+
+                # Handle #include "dir//foo.h" properly.
+                if source[i] == '"':
+                    i = source.find('"', i+1) + 1
+                    assert i > 0
+                    continue
+                # Keep going if end of the line and the line ends with \.
+                if not (i == i1 and source[i-1] == '\\'):
+                    if got_if:
+                        condition = source[start+4:i].lstrip()
+                        if (condition.startswith('0') or
+                            condition.startswith('(0)')):
+                            ignore_errors = True
+                    break
+                i += 1
+        elif c == '\\':                          # Handle \ in code.
+            # This is different from the pre-processor \ handling.
+            i += 1
+            continue
+        elif ignore_errors:
+            # The tokenizer seems to be in pretty good shape.  This
+            # raise is conditionally disabled so that bogus code
+            # in an #if 0 block can be handled.  Since we will ignore
+            # it anyways, this is probably fine.  So disable the
+            # exception and  return the bogus char.
+            i += 1
+        else:
+            sys.stderr.write('Got invalid token in %s @ %d token:%s: %r\n' %
+                             ('?', i, c, source[i-10:i+10]))
+            raise RuntimeError('unexpected token')
+
+        if i <= 0:
+            print('Invalid index, exiting now.')
+            return
+        yield Token(token_type, source[start:i], start, i)
+
+
+if __name__ == '__main__':
+    def main(argv):
+        """Driver mostly for testing purposes."""
+        for filename in argv[1:]:
+            source = utils.ReadFile(filename)
+            if source is None:
+                continue
+
+            for token in GetTokens(source):
+                print('%-12s: %s' % (token.token_type, token.name))
+                # print('\r%6.2f%%' % (100.0 * index / token.end),)
+            sys.stdout.write('\n')
+
+
+    main(sys.argv)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/utils.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/utils.py
new file mode 100755
index 00000000..eab36eec
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/utils.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+#
+# Copyright 2007 Neal Norwitz
+# Portions Copyright 2007 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Generic utilities for C++ parsing."""
+
+__author__ = 'nnorwitz@google.com (Neal Norwitz)'
+
+
+import sys
+
+
+# Set to True to see the start/end token indices.
+DEBUG = True
+
+
+def ReadFile(filename, print_error=True):
+    """Returns the contents of a file."""
+    try:
+        fp = open(filename)
+        try:
+            return fp.read()
+        finally:
+            fp.close()
+    except IOError:
+        if print_error:
+            print('Error reading %s: %s' % (filename, sys.exc_info()[1]))
+        return None
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/gmock_gen.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/gmock_gen.py
new file mode 100755
index 00000000..8cc0d135
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/gmock_gen.py
@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+#
+# Copyright 2008 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Driver for starting up Google Mock class generator."""
+
+__author__ = 'nnorwitz@google.com (Neal Norwitz)'
+
+import os
+import sys
+
+if __name__ == '__main__':
+  # Add the directory of this script to the path so we can import gmock_class.
+  sys.path.append(os.path.dirname(__file__))
+
+  from cpp import gmock_class
+  # Fix the docstring in case they require the usage.
+  gmock_class.__doc__ = gmock_class.__doc__.replace('gmock_class.py', __file__)
+  gmock_class.main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock-config.in b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock-config.in
new file mode 100755
index 00000000..2baefe94
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock-config.in
@@ -0,0 +1,303 @@
+#!/bin/sh
+
+# These variables are automatically filled in by the configure script.
+name="@PACKAGE_TARNAME@"
+version="@PACKAGE_VERSION@"
+
+show_usage()
+{
+  echo "Usage: gmock-config [OPTIONS...]"
+}
+
+show_help()
+{
+  show_usage
+  cat <<\EOF
+
+The `gmock-config' script provides access to the necessary compile and linking
+flags to connect with Google C++ Mocking Framework, both in a build prior to
+installation, and on the system proper after installation. The installation
+overrides may be issued in combination with any other queries, but will only
+affect installation queries if called on a built but not installed gmock. The
+installation queries may not be issued with any other types of queries, and
+only one installation query may be made at a time. The version queries and
+compiler flag queries may be combined as desired but not mixed. Different
+version queries are always combined with logical "and" semantics, and only the
+last of any particular query is used while all previous ones ignored. All
+versions must be specified as a sequence of numbers separated by periods.
+Compiler flag queries output the union of the sets of flags when combined.
+
+ Examples:
+  gmock-config --min-version=1.0 || echo "Insufficient Google Mock version."
+
+  g++ $(gmock-config --cppflags --cxxflags) -o foo.o -c foo.cpp
+  g++ $(gmock-config --ldflags --libs) -o foo foo.o
+
+  # When using a built but not installed Google Mock:
+  g++ $(../../my_gmock_build/scripts/gmock-config ...) ...
+
+  # When using an installed Google Mock, but with installation overrides:
+  export GMOCK_PREFIX="/opt"
+  g++ $(gmock-config --libdir="/opt/lib64" ...) ...
+
+ Help:
+  --usage                    brief usage information
+  --help                     display this help message
+
+ Installation Overrides:
+  --prefix=<dir>             overrides the installation prefix
+  --exec-prefix=<dir>        overrides the executable installation prefix
+  --libdir=<dir>             overrides the library installation prefix
+  --includedir=<dir>         overrides the header file installation prefix
+
+ Installation Queries:
+  --prefix                   installation prefix
+  --exec-prefix              executable installation prefix
+  --libdir                   library installation directory
+  --includedir               header file installation directory
+  --version                  the version of the Google Mock installation
+
+ Version Queries:
+  --min-version=VERSION      return 0 if the version is at least VERSION
+  --exact-version=VERSION    return 0 if the version is exactly VERSION
+  --max-version=VERSION      return 0 if the version is at most VERSION
+
+ Compilation Flag Queries:
+  --cppflags                 compile flags specific to the C-like preprocessors
+  --cxxflags                 compile flags appropriate for C++ programs
+  --ldflags                  linker flags
+  --libs                     libraries for linking
+
+EOF
+}
+
+# This function bounds our version with a min and a max. It uses some clever
+# POSIX-compliant variable expansion to portably do all the work in the shell
+# and avoid any dependency on a particular "sed" or "awk" implementation.
+# Notable is that it will only ever compare the first 3 components of versions.
+# Further components will be cleanly stripped off. All versions must be
+# unadorned, so "v1.0" will *not* work. The minimum version must be in $1, and
+# the max in $2. TODO(chandlerc@google.com): If this ever breaks, we should
+# investigate expanding this via autom4te from AS_VERSION_COMPARE rather than
+# continuing to maintain our own shell version.
+check_versions()
+{
+  major_version=${version%%.*}
+  minor_version="0"
+  point_version="0"
+  if test "${version#*.}" != "${version}"; then
+    minor_version=${version#*.}
+    minor_version=${minor_version%%.*}
+  fi
+  if test "${version#*.*.}" != "${version}"; then
+    point_version=${version#*.*.}
+    point_version=${point_version%%.*}
+  fi
+
+  min_version="$1"
+  min_major_version=${min_version%%.*}
+  min_minor_version="0"
+  min_point_version="0"
+  if test "${min_version#*.}" != "${min_version}"; then
+    min_minor_version=${min_version#*.}
+    min_minor_version=${min_minor_version%%.*}
+  fi
+  if test "${min_version#*.*.}" != "${min_version}"; then
+    min_point_version=${min_version#*.*.}
+    min_point_version=${min_point_version%%.*}
+  fi
+
+  max_version="$2"
+  max_major_version=${max_version%%.*}
+  max_minor_version="0"
+  max_point_version="0"
+  if test "${max_version#*.}" != "${max_version}"; then
+    max_minor_version=${max_version#*.}
+    max_minor_version=${max_minor_version%%.*}
+  fi
+  if test "${max_version#*.*.}" != "${max_version}"; then
+    max_point_version=${max_version#*.*.}
+    max_point_version=${max_point_version%%.*}
+  fi
+
+  test $(($major_version)) -lt $(($min_major_version)) && exit 1
+  if test $(($major_version)) -eq $(($min_major_version)); then
+    test $(($minor_version)) -lt $(($min_minor_version)) && exit 1
+    if test $(($minor_version)) -eq $(($min_minor_version)); then
+      test $(($point_version)) -lt $(($min_point_version)) && exit 1
+    fi
+  fi
+
+  test $(($major_version)) -gt $(($max_major_version)) && exit 1
+  if test $(($major_version)) -eq $(($max_major_version)); then
+    test $(($minor_version)) -gt $(($max_minor_version)) && exit 1
+    if test $(($minor_version)) -eq $(($max_minor_version)); then
+      test $(($point_version)) -gt $(($max_point_version)) && exit 1
+    fi
+  fi
+
+  exit 0
+}
+
+# Show the usage line when no arguments are specified.
+if test $# -eq 0; then
+  show_usage
+  exit 1
+fi
+
+while test $# -gt 0; do
+  case $1 in
+    --usage)          show_usage;         exit 0;;
+    --help)           show_help;          exit 0;;
+
+    # Installation overrides
+    --prefix=*)       GMOCK_PREFIX=${1#--prefix=};;
+    --exec-prefix=*)  GMOCK_EXEC_PREFIX=${1#--exec-prefix=};;
+    --libdir=*)       GMOCK_LIBDIR=${1#--libdir=};;
+    --includedir=*)   GMOCK_INCLUDEDIR=${1#--includedir=};;
+
+    # Installation queries
+    --prefix|--exec-prefix|--libdir|--includedir|--version)
+      if test -n "${do_query}"; then
+        show_usage
+        exit 1
+      fi
+      do_query=${1#--}
+      ;;
+
+    # Version checking
+    --min-version=*)
+      do_check_versions=yes
+      min_version=${1#--min-version=}
+      ;;
+    --max-version=*)
+      do_check_versions=yes
+      max_version=${1#--max-version=}
+      ;;
+    --exact-version=*)
+      do_check_versions=yes
+      exact_version=${1#--exact-version=}
+      ;;
+
+    # Compiler flag output
+    --cppflags)       echo_cppflags=yes;;
+    --cxxflags)       echo_cxxflags=yes;;
+    --ldflags)        echo_ldflags=yes;;
+    --libs)           echo_libs=yes;;
+
+    # Everything else is an error
+    *)                show_usage;         exit 1;;
+  esac
+  shift
+done
+
+# These have defaults filled in by the configure script but can also be
+# overridden by environment variables or command line parameters.
+prefix="${GMOCK_PREFIX:-@prefix@}"
+exec_prefix="${GMOCK_EXEC_PREFIX:-@exec_prefix@}"
+libdir="${GMOCK_LIBDIR:-@libdir@}"
+includedir="${GMOCK_INCLUDEDIR:-@includedir@}"
+
+# We try and detect if our binary is not located at its installed location. If
+# it's not, we provide variables pointing to the source and build tree rather
+# than to the install tree. We also locate Google Test using the configured
+# gtest-config script rather than searching the PATH and our bindir for one.
+# This allows building against a just-built gmock rather than an installed
+# gmock.
+bindir="@bindir@"
+this_relative_bindir=`dirname $0`
+this_bindir=`cd ${this_relative_bindir}; pwd -P`
+if test "${this_bindir}" = "${this_bindir%${bindir}}"; then
+  # The path to the script doesn't end in the bindir sequence from Autoconf,
+  # assume that we are in a build tree.
+  build_dir=`dirname ${this_bindir}`
+  src_dir=`cd ${this_bindir}/@top_srcdir@; pwd -P`
+
+  # TODO(chandlerc@google.com): This is a dangerous dependency on libtool, we
+  # should work to remove it, and/or remove libtool altogether, replacing it
+  # with direct references to the library and a link path.
+  gmock_libs="${build_dir}/lib/libgmock.la"
+  gmock_ldflags=""
+
+  # We provide hooks to include from either the source or build dir, where the
+  # build dir is always preferred. This will potentially allow us to write
+  # build rules for generated headers and have them automatically be preferred
+  # over provided versions.
+  gmock_cppflags="-I${build_dir}/include -I${src_dir}/include"
+  gmock_cxxflags=""
+
+  # Directly invoke the gtest-config script used during the build process.
+  gtest_config="@GTEST_CONFIG@"
+else
+  # We're using an installed gmock, although it may be staged under some
+  # prefix. Assume (as our own libraries do) that we can resolve the prefix,
+  # and are present in the dynamic link paths.
+  gmock_ldflags="-L${libdir}"
+  gmock_libs="-l${name}"
+  gmock_cppflags="-I${includedir}"
+  gmock_cxxflags=""
+
+  # We also prefer any gtest-config script installed in our prefix. Lacking
+  # one, we look in the PATH for one.
+  gtest_config="${bindir}/gtest-config"
+  if test ! -x "${gtest_config}"; then
+    gtest_config=`which gtest-config`
+  fi
+fi
+
+# Ensure that we have located a Google Test to link against.
+if ! test -x "${gtest_config}"; then
+  echo "Unable to locate Google Test, check your Google Mock configuration" \
+       "and installation" >&2
+  exit 1
+elif ! "${gtest_config}" "--exact-version=@GTEST_VERSION@"; then
+  echo "The Google Test found is not the same version as Google Mock was " \
+       "built against" >&2
+  exit 1
+fi
+
+# Add the necessary Google Test bits into the various flag variables
+gmock_cppflags="${gmock_cppflags} `${gtest_config} --cppflags`"
+gmock_cxxflags="${gmock_cxxflags} `${gtest_config} --cxxflags`"
+gmock_ldflags="${gmock_ldflags} `${gtest_config} --ldflags`"
+gmock_libs="${gmock_libs} `${gtest_config} --libs`"
+
+# Do an installation query if requested.
+if test -n "$do_query"; then
+  case $do_query in
+    prefix)           echo $prefix;       exit 0;;
+    exec-prefix)      echo $exec_prefix;  exit 0;;
+    libdir)           echo $libdir;       exit 0;;
+    includedir)       echo $includedir;   exit 0;;
+    version)          echo $version;      exit 0;;
+    *)                show_usage;         exit 1;;
+  esac
+fi
+
+# Do a version check if requested.
+if test "$do_check_versions" = "yes"; then
+  # Make sure we didn't receive a bad combination of parameters.
+  test "$echo_cppflags" = "yes" && show_usage && exit 1
+  test "$echo_cxxflags" = "yes" && show_usage && exit 1
+  test "$echo_ldflags" = "yes"  && show_usage && exit 1
+  test "$echo_libs" = "yes"     && show_usage && exit 1
+
+  if test "$exact_version" != ""; then
+    check_versions $exact_version $exact_version
+    # unreachable
+  else
+    check_versions ${min_version:-0.0.0} ${max_version:-9999.9999.9999}
+    # unreachable
+  fi
+fi
+
+# Do the output in the correct order so that these can be used in-line of
+# a compiler invocation.
+output=""
+test "$echo_cppflags" = "yes" && output="$output $gmock_cppflags"
+test "$echo_cxxflags" = "yes" && output="$output $gmock_cxxflags"
+test "$echo_ldflags" = "yes"  && output="$output $gmock_ldflags"
+test "$echo_libs" = "yes"     && output="$output $gmock_libs"
+echo $output
+
+exit 0
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock_doctor.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock_doctor.py
new file mode 100755
index 00000000..74992bc7
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock_doctor.py
@@ -0,0 +1,640 @@
+#!/usr/bin/env python
+#
+# 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.
+
+"""Converts compiler's errors in code using Google Mock to plain English."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import re
+import sys
+
+_VERSION = '1.0.3'
+
+_EMAIL = 'googlemock@googlegroups.com'
+
+_COMMON_GMOCK_SYMBOLS = [
+    # Matchers
+    '_',
+    'A',
+    'AddressSatisfies',
+    'AllOf',
+    'An',
+    'AnyOf',
+    'ContainerEq',
+    'Contains',
+    'ContainsRegex',
+    'DoubleEq',
+    'ElementsAre',
+    'ElementsAreArray',
+    'EndsWith',
+    'Eq',
+    'Field',
+    'FloatEq',
+    'Ge',
+    'Gt',
+    'HasSubstr',
+    'IsInitializedProto',
+    'Le',
+    'Lt',
+    'MatcherCast',
+    'Matches',
+    'MatchesRegex',
+    'NanSensitiveDoubleEq',
+    'NanSensitiveFloatEq',
+    'Ne',
+    'Not',
+    'NotNull',
+    'Pointee',
+    'Property',
+    'Ref',
+    'ResultOf',
+    'SafeMatcherCast',
+    'StartsWith',
+    'StrCaseEq',
+    'StrCaseNe',
+    'StrEq',
+    'StrNe',
+    'Truly',
+    'TypedEq',
+    'Value',
+
+    # Actions
+    'Assign',
+    'ByRef',
+    'DeleteArg',
+    'DoAll',
+    'DoDefault',
+    'IgnoreResult',
+    'Invoke',
+    'InvokeArgument',
+    'InvokeWithoutArgs',
+    'Return',
+    'ReturnNew',
+    'ReturnNull',
+    'ReturnRef',
+    'SaveArg',
+    'SetArgReferee',
+    'SetArgPointee',
+    'SetArgumentPointee',
+    'SetArrayArgument',
+    'SetErrnoAndReturn',
+    'Throw',
+    'WithArg',
+    'WithArgs',
+    'WithoutArgs',
+
+    # Cardinalities
+    'AnyNumber',
+    'AtLeast',
+    'AtMost',
+    'Between',
+    'Exactly',
+
+    # Sequences
+    'InSequence',
+    'Sequence',
+
+    # Misc
+    'DefaultValue',
+    'Mock',
+    ]
+
+# Regex for matching source file path and line number in the compiler's errors.
+_GCC_FILE_LINE_RE = r'(?P<file>.*):(?P<line>\d+):(\d+:)?\s+'
+_CLANG_FILE_LINE_RE = r'(?P<file>.*):(?P<line>\d+):(?P<column>\d+):\s+'
+_CLANG_NON_GMOCK_FILE_LINE_RE = (
+    r'(?P<file>.*[/\\^](?!gmock-)[^/\\]+):(?P<line>\d+):(?P<column>\d+):\s+')
+
+
+def _FindAllMatches(regex, s):
+  """Generates all matches of regex in string s."""
+
+  r = re.compile(regex)
+  return r.finditer(s)
+
+
+def _GenericDiagnoser(short_name, long_name, diagnoses, msg):
+  """Diagnoses the given disease by pattern matching.
+
+  Can provide different diagnoses for different patterns.
+
+  Args:
+    short_name: Short name of the disease.
+    long_name:  Long name of the disease.
+    diagnoses:  A list of pairs (regex, pattern for formatting the diagnosis
+                for matching regex).
+    msg:        Compiler's error messages.
+  Yields:
+    Tuples of the form
+      (short name of disease, long name of disease, diagnosis).
+  """
+  for regex, diagnosis in diagnoses:
+    if re.search(regex, msg):
+      diagnosis = '%(file)s:%(line)s:' + diagnosis
+      for m in _FindAllMatches(regex, msg):
+        yield (short_name, long_name, diagnosis % m.groupdict())
+
+
+def _NeedToReturnReferenceDiagnoser(msg):
+  """Diagnoses the NRR disease, given the error messages by the compiler."""
+
+  gcc_regex = (r'In member function \'testing::internal::ReturnAction<R>.*\n'
+               + _GCC_FILE_LINE_RE + r'instantiated from here\n'
+               r'.*gmock-actions\.h.*error: creating array with negative size')
+  clang_regex = (r'error:.*array.*negative.*\r?\n'
+                 r'(.*\n)*?' +
+                 _CLANG_NON_GMOCK_FILE_LINE_RE +
+                 r'note: in instantiation of function template specialization '
+                 r'\'testing::internal::ReturnAction<(?P<type>.*)>'
+                 r'::operator Action<.*>\' requested here')
+  clang11_re = (r'use_ReturnRef_instead_of_Return_to_return_a_reference.*'
+                r'(.*\n)*?' + _CLANG_NON_GMOCK_FILE_LINE_RE)
+
+  diagnosis = """
+You are using a Return() action in a function that returns a reference to
+%(type)s.  Please use ReturnRef() instead."""
+  return _GenericDiagnoser('NRR', 'Need to Return Reference',
+                           [(clang_regex, diagnosis),
+                            (clang11_re, diagnosis % {'type': 'a type'}),
+                            (gcc_regex, diagnosis % {'type': 'a type'})],
+                           msg)
+
+
+def _NeedToReturnSomethingDiagnoser(msg):
+  """Diagnoses the NRS disease, given the error messages by the compiler."""
+
+  gcc_regex = (_GCC_FILE_LINE_RE + r'(instantiated from here\n.'
+               r'*gmock.*actions\.h.*error: void value not ignored)'
+               r'|(error: control reaches end of non-void function)')
+  clang_regex1 = (_CLANG_FILE_LINE_RE +
+                  r'error: cannot initialize return object '
+                  r'of type \'Result\' \(aka \'(?P<return_type>.*)\'\) '
+                  r'with an rvalue of type \'void\'')
+  clang_regex2 = (_CLANG_FILE_LINE_RE +
+                  r'error: cannot initialize return object '
+                  r'of type \'(?P<return_type>.*)\' '
+                  r'with an rvalue of type \'void\'')
+  diagnosis = """
+You are using an action that returns void, but it needs to return
+%(return_type)s.  Please tell it *what* to return.  Perhaps you can use
+the pattern DoAll(some_action, Return(some_value))?"""
+  return _GenericDiagnoser(
+      'NRS',
+      'Need to Return Something',
+      [(gcc_regex, diagnosis % {'return_type': '*something*'}),
+       (clang_regex1, diagnosis),
+       (clang_regex2, diagnosis)],
+      msg)
+
+
+def _NeedToReturnNothingDiagnoser(msg):
+  """Diagnoses the NRN disease, given the error messages by the compiler."""
+
+  gcc_regex = (_GCC_FILE_LINE_RE + r'instantiated from here\n'
+               r'.*gmock-actions\.h.*error: instantiation of '
+               r'\'testing::internal::ReturnAction<R>::Impl<F>::value_\' '
+               r'as type \'void\'')
+  clang_regex1 = (r'error: field has incomplete type '
+                  r'\'Result\' \(aka \'void\'\)(\r)?\n'
+                  r'(.*\n)*?' +
+                  _CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
+                  r'of function template specialization '
+                  r'\'testing::internal::ReturnAction<(?P<return_type>.*)>'
+                  r'::operator Action<void \(.*\)>\' requested here')
+  clang_regex2 = (r'error: field has incomplete type '
+                  r'\'Result\' \(aka \'void\'\)(\r)?\n'
+                  r'(.*\n)*?' +
+                  _CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
+                  r'of function template specialization '
+                  r'\'testing::internal::DoBothAction<.*>'
+                  r'::operator Action<(?P<return_type>.*) \(.*\)>\' '
+                  r'requested here')
+  diagnosis = """
+You are using an action that returns %(return_type)s, but it needs to return
+void.  Please use a void-returning action instead.
+
+All actions but the last in DoAll(...) must return void.  Perhaps you need
+to re-arrange the order of actions in a DoAll(), if you are using one?"""
+  return _GenericDiagnoser(
+      'NRN',
+      'Need to Return Nothing',
+      [(gcc_regex, diagnosis % {'return_type': '*something*'}),
+       (clang_regex1, diagnosis),
+       (clang_regex2, diagnosis)],
+      msg)
+
+
+def _IncompleteByReferenceArgumentDiagnoser(msg):
+  """Diagnoses the IBRA disease, given the error messages by the compiler."""
+
+  gcc_regex = (_GCC_FILE_LINE_RE + r'instantiated from here\n'
+               r'.*gtest-printers\.h.*error: invalid application of '
+               r'\'sizeof\' to incomplete type \'(?P<type>.*)\'')
+
+  clang_regex = (r'.*gtest-printers\.h.*error: invalid application of '
+                 r'\'sizeof\' to an incomplete type '
+                 r'\'(?P<type>.*)( const)?\'\r?\n'
+                 r'(.*\n)*?' +
+                 _CLANG_NON_GMOCK_FILE_LINE_RE +
+                 r'note: in instantiation of member function '
+                 r'\'testing::internal2::TypeWithoutFormatter<.*>::'
+                 r'PrintValue\' requested here')
+  diagnosis = """
+In order to mock this function, Google Mock needs to see the definition
+of type "%(type)s" - declaration alone is not enough.  Either #include
+the header that defines it, or change the argument to be passed
+by pointer."""
+
+  return _GenericDiagnoser('IBRA', 'Incomplete By-Reference Argument Type',
+                           [(gcc_regex, diagnosis),
+                            (clang_regex, diagnosis)],
+                           msg)
+
+
+def _OverloadedFunctionMatcherDiagnoser(msg):
+  """Diagnoses the OFM disease, given the error messages by the compiler."""
+
+  gcc_regex = (_GCC_FILE_LINE_RE + r'error: no matching function for '
+               r'call to \'Truly\(<unresolved overloaded function type>\)')
+  clang_regex = (_CLANG_FILE_LINE_RE + r'error: no matching function for '
+                 r'call to \'Truly')
+  diagnosis = """
+The argument you gave to Truly() is an overloaded function.  Please tell
+your compiler which overloaded version you want to use.
+
+For example, if you want to use the version whose signature is
+  bool Foo(int n);
+you should write
+  Truly(static_cast<bool (*)(int n)>(Foo))"""
+  return _GenericDiagnoser('OFM', 'Overloaded Function Matcher',
+                           [(gcc_regex, diagnosis),
+                            (clang_regex, diagnosis)],
+                           msg)
+
+
+def _OverloadedFunctionActionDiagnoser(msg):
+  """Diagnoses the OFA disease, given the error messages by the compiler."""
+
+  gcc_regex = (_GCC_FILE_LINE_RE + r'error: no matching function for call to '
+               r'\'Invoke\(<unresolved overloaded function type>')
+  clang_regex = (_CLANG_FILE_LINE_RE + r'error: no matching '
+                 r'function for call to \'Invoke\'\r?\n'
+                 r'(.*\n)*?'
+                 r'.*\bgmock-generated-actions\.h:\d+:\d+:\s+'
+                 r'note: candidate template ignored:\s+'
+                 r'couldn\'t infer template argument \'FunctionImpl\'')
+  diagnosis = """
+Function you are passing to Invoke is overloaded.  Please tell your compiler
+which overloaded version you want to use.
+
+For example, if you want to use the version whose signature is
+  bool MyFunction(int n, double x);
+you should write something like
+  Invoke(static_cast<bool (*)(int n, double x)>(MyFunction))"""
+  return _GenericDiagnoser('OFA', 'Overloaded Function Action',
+                           [(gcc_regex, diagnosis),
+                            (clang_regex, diagnosis)],
+                           msg)
+
+
+def _OverloadedMethodActionDiagnoser(msg):
+  """Diagnoses the OMA disease, given the error messages by the compiler."""
+
+  gcc_regex = (_GCC_FILE_LINE_RE + r'error: no matching function for '
+               r'call to \'Invoke\(.+, <unresolved overloaded function '
+               r'type>\)')
+  clang_regex = (_CLANG_FILE_LINE_RE + r'error: no matching function '
+                 r'for call to \'Invoke\'\r?\n'
+                 r'(.*\n)*?'
+                 r'.*\bgmock-generated-actions\.h:\d+:\d+: '
+                 r'note: candidate function template not viable: '
+                 r'requires .*, but 2 (arguments )?were provided')
+  diagnosis = """
+The second argument you gave to Invoke() is an overloaded method.  Please
+tell your compiler which overloaded version you want to use.
+
+For example, if you want to use the version whose signature is
+  class Foo {
+    ...
+    bool Bar(int n, double x);
+  };
+you should write something like
+  Invoke(foo, static_cast<bool (Foo::*)(int n, double x)>(&Foo::Bar))"""
+  return _GenericDiagnoser('OMA', 'Overloaded Method Action',
+                           [(gcc_regex, diagnosis),
+                            (clang_regex, diagnosis)],
+                           msg)
+
+
+def _MockObjectPointerDiagnoser(msg):
+  """Diagnoses the MOP disease, given the error messages by the compiler."""
+
+  gcc_regex = (_GCC_FILE_LINE_RE + r'error: request for member '
+               r'\'gmock_(?P<method>.+)\' in \'(?P<mock_object>.+)\', '
+               r'which is of non-class type \'(.*::)*(?P<class_name>.+)\*\'')
+  clang_regex = (_CLANG_FILE_LINE_RE + r'error: member reference type '
+                 r'\'(?P<class_name>.*?) *\' is a pointer; '
+                 r'(did you mean|maybe you meant) to use \'->\'\?')
+  diagnosis = """
+The first argument to ON_CALL() and EXPECT_CALL() must be a mock *object*,
+not a *pointer* to it.  Please write '*(%(mock_object)s)' instead of
+'%(mock_object)s' as your first argument.
+
+For example, given the mock class:
+
+  class %(class_name)s : public ... {
+    ...
+    MOCK_METHOD0(%(method)s, ...);
+  };
+
+and the following mock instance:
+
+  %(class_name)s* mock_ptr = ...
+
+you should use the EXPECT_CALL like this:
+
+  EXPECT_CALL(*mock_ptr, %(method)s(...));"""
+
+  return _GenericDiagnoser(
+      'MOP',
+      'Mock Object Pointer',
+      [(gcc_regex, diagnosis),
+       (clang_regex, diagnosis % {'mock_object': 'mock_object',
+                                  'method': 'method',
+                                  'class_name': '%(class_name)s'})],
+       msg)
+
+
+def _NeedToUseSymbolDiagnoser(msg):
+  """Diagnoses the NUS disease, given the error messages by the compiler."""
+
+  gcc_regex = (_GCC_FILE_LINE_RE + r'error: \'(?P<symbol>.+)\' '
+               r'(was not declared in this scope|has not been declared)')
+  clang_regex = (_CLANG_FILE_LINE_RE +
+                 r'error: (use of undeclared identifier|unknown type name|'
+                 r'no template named) \'(?P<symbol>[^\']+)\'')
+  diagnosis = """
+'%(symbol)s' is defined by Google Mock in the testing namespace.
+Did you forget to write
+  using testing::%(symbol)s;
+?"""
+  for m in (list(_FindAllMatches(gcc_regex, msg)) +
+            list(_FindAllMatches(clang_regex, msg))):
+    symbol = m.groupdict()['symbol']
+    if symbol in _COMMON_GMOCK_SYMBOLS:
+      yield ('NUS', 'Need to Use Symbol', diagnosis % m.groupdict())
+
+
+def _NeedToUseReturnNullDiagnoser(msg):
+  """Diagnoses the NRNULL disease, given the error messages by the compiler."""
+
+  gcc_regex = ('instantiated from \'testing::internal::ReturnAction<R>'
+               '::operator testing::Action<Func>\(\) const.*\n' +
+               _GCC_FILE_LINE_RE + r'instantiated from here\n'
+               r'.*error: no matching function for call to \'ImplicitCast_\('
+               r'(:?long )?int&\)')
+  clang_regex = (r'\bgmock-actions.h:.* error: no matching function for '
+                 r'call to \'ImplicitCast_\'\r?\n'
+                 r'(.*\n)*?' +
+                 _CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
+                 r'of function template specialization '
+                 r'\'testing::internal::ReturnAction<(int|long)>::operator '
+                 r'Action<(?P<type>.*)\(\)>\' requested here')
+  diagnosis = """
+You are probably calling Return(NULL) and the compiler isn't sure how to turn
+NULL into %(type)s. Use ReturnNull() instead.
+Note: the line number may be off; please fix all instances of Return(NULL)."""
+  return _GenericDiagnoser(
+      'NRNULL', 'Need to use ReturnNull',
+      [(clang_regex, diagnosis),
+       (gcc_regex, diagnosis % {'type': 'the right type'})],
+      msg)
+
+
+def _TypeInTemplatedBaseDiagnoser(msg):
+  """Diagnoses the TTB disease, given the error messages by the compiler."""
+
+  # This version works when the type is used as the mock function's return
+  # type.
+  gcc_4_3_1_regex_type_in_retval = (
+      r'In member function \'int .*\n' + _GCC_FILE_LINE_RE +
+      r'error: a function call cannot appear in a constant-expression')
+  gcc_4_4_0_regex_type_in_retval = (
+      r'error: a function call cannot appear in a constant-expression'
+      + _GCC_FILE_LINE_RE + r'error: template argument 1 is invalid\n')
+  # This version works when the type is used as the mock function's sole
+  # parameter type.
+  gcc_regex_type_of_sole_param = (
+      _GCC_FILE_LINE_RE +
+      r'error: \'(?P<type>.+)\' was not declared in this scope\n'
+      r'.*error: template argument 1 is invalid\n')
+  # This version works when the type is used as a parameter of a mock
+  # function that has multiple parameters.
+  gcc_regex_type_of_a_param = (
+      r'error: expected `;\' before \'::\' token\n'
+      + _GCC_FILE_LINE_RE +
+      r'error: \'(?P<type>.+)\' was not declared in this scope\n'
+      r'.*error: template argument 1 is invalid\n'
+      r'.*error: \'.+\' was not declared in this scope')
+  clang_regex_type_of_retval_or_sole_param = (
+      _CLANG_FILE_LINE_RE +
+      r'error: use of undeclared identifier \'(?P<type>.*)\'\n'
+      r'(.*\n)*?'
+      r'(?P=file):(?P=line):\d+: error: '
+      r'non-friend class member \'Result\' cannot have a qualified name'
+      )
+  clang_regex_type_of_a_param = (
+      _CLANG_FILE_LINE_RE +
+      r'error: C\+\+ requires a type specifier for all declarations\n'
+      r'(.*\n)*?'
+      r'(?P=file):(?P=line):(?P=column): error: '
+      r'C\+\+ requires a type specifier for all declarations'
+      )
+  clang_regex_unknown_type = (
+      _CLANG_FILE_LINE_RE +
+      r'error: unknown type name \'(?P<type>[^\']+)\''
+      )
+
+  diagnosis = """
+In a mock class template, types or typedefs defined in the base class
+template are *not* automatically visible.  This is how C++ works.  Before
+you can use a type or typedef named %(type)s defined in base class Base<T>, you
+need to make it visible.  One way to do it is:
+
+  typedef typename Base<T>::%(type)s %(type)s;"""
+
+  for diag in _GenericDiagnoser(
+      'TTB', 'Type in Template Base',
+      [(gcc_4_3_1_regex_type_in_retval, diagnosis % {'type': 'Foo'}),
+       (gcc_4_4_0_regex_type_in_retval, diagnosis % {'type': 'Foo'}),
+       (gcc_regex_type_of_sole_param, diagnosis),
+       (gcc_regex_type_of_a_param, diagnosis),
+       (clang_regex_type_of_retval_or_sole_param, diagnosis),
+       (clang_regex_type_of_a_param, diagnosis % {'type': 'Foo'})],
+      msg):
+    yield diag
+  # Avoid overlap with the NUS pattern.
+  for m in _FindAllMatches(clang_regex_unknown_type, msg):
+    type_ = m.groupdict()['type']
+    if type_ not in _COMMON_GMOCK_SYMBOLS:
+      yield ('TTB', 'Type in Template Base', diagnosis % m.groupdict())
+
+
+def _WrongMockMethodMacroDiagnoser(msg):
+  """Diagnoses the WMM disease, given the error messages by the compiler."""
+
+  gcc_regex = (_GCC_FILE_LINE_RE +
+               r'.*this_method_does_not_take_(?P<wrong_args>\d+)_argument.*\n'
+               r'.*\n'
+               r'.*candidates are.*FunctionMocker<[^>]+A(?P<args>\d+)\)>')
+  clang_regex = (_CLANG_NON_GMOCK_FILE_LINE_RE +
+                 r'error:.*array.*negative.*r?\n'
+                 r'(.*\n)*?'
+                 r'(?P=file):(?P=line):(?P=column): error: too few arguments '
+                 r'to function call, expected (?P<args>\d+), '
+                 r'have (?P<wrong_args>\d+)')
+  clang11_re = (_CLANG_NON_GMOCK_FILE_LINE_RE +
+                r'.*this_method_does_not_take_'
+                r'(?P<wrong_args>\d+)_argument.*')
+  diagnosis = """
+You are using MOCK_METHOD%(wrong_args)s to define a mock method that has
+%(args)s arguments. Use MOCK_METHOD%(args)s (or MOCK_CONST_METHOD%(args)s,
+MOCK_METHOD%(args)s_T, MOCK_CONST_METHOD%(args)s_T as appropriate) instead."""
+  return _GenericDiagnoser('WMM', 'Wrong MOCK_METHODn Macro',
+                           [(gcc_regex, diagnosis),
+                            (clang11_re, diagnosis % {'wrong_args': 'm',
+                                                      'args': 'n'}),
+                            (clang_regex, diagnosis)],
+                           msg)
+
+
+def _WrongParenPositionDiagnoser(msg):
+  """Diagnoses the WPP disease, given the error messages by the compiler."""
+
+  gcc_regex = (_GCC_FILE_LINE_RE +
+               r'error:.*testing::internal::MockSpec<.* has no member named \''
+               r'(?P<method>\w+)\'')
+  clang_regex = (_CLANG_NON_GMOCK_FILE_LINE_RE +
+                 r'error: no member named \'(?P<method>\w+)\' in '
+                 r'\'testing::internal::MockSpec<.*>\'')
+  diagnosis = """
+The closing parenthesis of ON_CALL or EXPECT_CALL should be *before*
+".%(method)s".  For example, you should write:
+  EXPECT_CALL(my_mock, Foo(_)).%(method)s(...);
+instead of:
+  EXPECT_CALL(my_mock, Foo(_).%(method)s(...));"""
+  return _GenericDiagnoser('WPP', 'Wrong Parenthesis Position',
+                           [(gcc_regex, diagnosis),
+                            (clang_regex, diagnosis)],
+                           msg)
+
+
+_DIAGNOSERS = [
+    _IncompleteByReferenceArgumentDiagnoser,
+    _MockObjectPointerDiagnoser,
+    _NeedToReturnNothingDiagnoser,
+    _NeedToReturnReferenceDiagnoser,
+    _NeedToReturnSomethingDiagnoser,
+    _NeedToUseReturnNullDiagnoser,
+    _NeedToUseSymbolDiagnoser,
+    _OverloadedFunctionActionDiagnoser,
+    _OverloadedFunctionMatcherDiagnoser,
+    _OverloadedMethodActionDiagnoser,
+    _TypeInTemplatedBaseDiagnoser,
+    _WrongMockMethodMacroDiagnoser,
+    _WrongParenPositionDiagnoser,
+    ]
+
+
+def Diagnose(msg):
+  """Generates all possible diagnoses given the compiler error message."""
+
+  msg = re.sub(r'\x1b\[[^m]*m', '', msg)  # Strips all color formatting.
+  # Assuming the string is using the UTF-8 encoding, replaces the left and
+  # the right single quote characters with apostrophes.
+  msg = re.sub(r'(\xe2\x80\x98|\xe2\x80\x99)', "'", msg)
+
+  diagnoses = []
+  for diagnoser in _DIAGNOSERS:
+    for diag in diagnoser(msg):
+      diagnosis = '[%s - %s]\n%s' % diag
+      if not diagnosis in diagnoses:
+        diagnoses.append(diagnosis)
+  return diagnoses
+
+
+def main():
+  print ('Google Mock Doctor v%s - '
+         'diagnoses problems in code using Google Mock.' % _VERSION)
+
+  if sys.stdin.isatty():
+    print ('Please copy and paste the compiler errors here.  Press c-D when '
+           'you are done:')
+  else:
+    print ('Waiting for compiler errors on stdin . . .')
+
+  msg = sys.stdin.read().strip()
+  diagnoses = Diagnose(msg)
+  count = len(diagnoses)
+  if not count:
+    print ("""
+Your compiler complained:
+8<------------------------------------------------------------
+%s
+------------------------------------------------------------>8
+
+Uh-oh, I'm not smart enough to figure out what the problem is. :-(
+However...
+If you send your source code and the compiler's error messages to
+%s, you can be helped and I can get smarter --
+win-win for us!""" % (msg, _EMAIL))
+  else:
+    print ('------------------------------------------------------------')
+    print ('Your code appears to have the following',)
+    if count > 1:
+      print ('%s diseases:' % (count,))
+    else:
+      print ('disease:')
+    i = 0
+    for d in diagnoses:
+      i += 1
+      if count > 1:
+        print ('\n#%s:' % (i,))
+      print (d)
+    print ("""
+How did I do?  If you think I'm wrong or unhelpful, please send your
+source code and the compiler's error messages to %s.
+Then you can be helped and I can get smarter -- I promise I won't be upset!""" %
+           _EMAIL)
+
+
+if __name__ == '__main__':
+  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload.py
new file mode 100755
index 00000000..6e6f9a14
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload.py
@@ -0,0 +1,1387 @@
+#!/usr/bin/env python
+#
+# Copyright 2007 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tool for uploading diffs from a version control system to the codereview app.
+
+Usage summary: upload.py [options] [-- diff_options]
+
+Diff options are passed to the diff command of the underlying system.
+
+Supported version control systems:
+  Git
+  Mercurial
+  Subversion
+
+It is important for Git/Mercurial users to specify a tree/node/branch to diff
+against by using the '--rev' option.
+"""
+# This code is derived from appcfg.py in the App Engine SDK (open source),
+# and from ASPN recipe #146306.
+
+import cookielib
+import getpass
+import logging
+import md5
+import mimetypes
+import optparse
+import os
+import re
+import socket
+import subprocess
+import sys
+import urllib
+import urllib2
+import urlparse
+
+try:
+  import readline
+except ImportError:
+  pass
+
+# The logging verbosity:
+#  0: Errors only.
+#  1: Status messages.
+#  2: Info logs.
+#  3: Debug logs.
+verbosity = 1
+
+# Max size of patch or base file.
+MAX_UPLOAD_SIZE = 900 * 1024
+
+
+def GetEmail(prompt):
+  """Prompts the user for their email address and returns it.
+
+  The last used email address is saved to a file and offered up as a suggestion
+  to the user. If the user presses enter without typing in anything the last
+  used email address is used. If the user enters a new address, it is saved
+  for next time we prompt.
+
+  """
+  last_email_file_name = os.path.expanduser("~/.last_codereview_email_address")
+  last_email = ""
+  if os.path.exists(last_email_file_name):
+    try:
+      last_email_file = open(last_email_file_name, "r")
+      last_email = last_email_file.readline().strip("\n")
+      last_email_file.close()
+      prompt += " [%s]" % last_email
+    except IOError, e:
+      pass
+  email = raw_input(prompt + ": ").strip()
+  if email:
+    try:
+      last_email_file = open(last_email_file_name, "w")
+      last_email_file.write(email)
+      last_email_file.close()
+    except IOError, e:
+      pass
+  else:
+    email = last_email
+  return email
+
+
+def StatusUpdate(msg):
+  """Print a status message to stdout.
+
+  If 'verbosity' is greater than 0, print the message.
+
+  Args:
+    msg: The string to print.
+  """
+  if verbosity > 0:
+    print msg
+
+
+def ErrorExit(msg):
+  """Print an error message to stderr and exit."""
+  print >>sys.stderr, msg
+  sys.exit(1)
+
+
+class ClientLoginError(urllib2.HTTPError):
+  """Raised to indicate there was an error authenticating with ClientLogin."""
+
+  def __init__(self, url, code, msg, headers, args):
+    urllib2.HTTPError.__init__(self, url, code, msg, headers, None)
+    self.args = args
+    self.reason = args["Error"]
+
+
+class AbstractRpcServer(object):
+  """Provides a common interface for a simple RPC server."""
+
+  def __init__(self, host, auth_function, host_override=None, extra_headers={},
+               save_cookies=False):
+    """Creates a new HttpRpcServer.
+
+    Args:
+      host: The host to send requests to.
+      auth_function: A function that takes no arguments and returns an
+        (email, password) tuple when called. Will be called if authentication
+        is required.
+      host_override: The host header to send to the server (defaults to host).
+      extra_headers: A dict of extra headers to append to every request.
+      save_cookies: If True, save the authentication cookies to local disk.
+        If False, use an in-memory cookiejar instead.  Subclasses must
+        implement this functionality.  Defaults to False.
+    """
+    self.host = host
+    self.host_override = host_override
+    self.auth_function = auth_function
+    self.authenticated = False
+    self.extra_headers = extra_headers
+    self.save_cookies = save_cookies
+    self.opener = self._GetOpener()
+    if self.host_override:
+      logging.info("Server: %s; Host: %s", self.host, self.host_override)
+    else:
+      logging.info("Server: %s", self.host)
+
+  def _GetOpener(self):
+    """Returns an OpenerDirector for making HTTP requests.
+
+    Returns:
+      A urllib2.OpenerDirector object.
+    """
+    raise NotImplementedError()
+
+  def _CreateRequest(self, url, data=None):
+    """Creates a new urllib request."""
+    logging.debug("Creating request for: '%s' with payload:\n%s", url, data)
+    req = urllib2.Request(url, data=data)
+    if self.host_override:
+      req.add_header("Host", self.host_override)
+    for key, value in self.extra_headers.iteritems():
+      req.add_header(key, value)
+    return req
+
+  def _GetAuthToken(self, email, password):
+    """Uses ClientLogin to authenticate the user, returning an auth token.
+
+    Args:
+      email:    The user's email address
+      password: The user's password
+
+    Raises:
+      ClientLoginError: If there was an error authenticating with ClientLogin.
+      HTTPError: If there was some other form of HTTP error.
+
+    Returns:
+      The authentication token returned by ClientLogin.
+    """
+    account_type = "GOOGLE"
+    if self.host.endswith(".google.com"):
+      # Needed for use inside Google.
+      account_type = "HOSTED"
+    req = self._CreateRequest(
+        url="https://www.google.com/accounts/ClientLogin",
+        data=urllib.urlencode({
+            "Email": email,
+            "Passwd": password,
+            "service": "ah",
+            "source": "rietveld-codereview-upload",
+            "accountType": account_type,
+        }),
+    )
+    try:
+      response = self.opener.open(req)
+      response_body = response.read()
+      response_dict = dict(x.split("=")
+                           for x in response_body.split("\n") if x)
+      return response_dict["Auth"]
+    except urllib2.HTTPError, e:
+      if e.code == 403:
+        body = e.read()
+        response_dict = dict(x.split("=", 1) for x in body.split("\n") if x)
+        raise ClientLoginError(req.get_full_url(), e.code, e.msg,
+                               e.headers, response_dict)
+      else:
+        raise
+
+  def _GetAuthCookie(self, auth_token):
+    """Fetches authentication cookies for an authentication token.
+
+    Args:
+      auth_token: The authentication token returned by ClientLogin.
+
+    Raises:
+      HTTPError: If there was an error fetching the authentication cookies.
+    """
+    # This is a dummy value to allow us to identify when we're successful.
+    continue_location = "http://localhost/"
+    args = {"continue": continue_location, "auth": auth_token}
+    req = self._CreateRequest("http://%s/_ah/login?%s" %
+                              (self.host, urllib.urlencode(args)))
+    try:
+      response = self.opener.open(req)
+    except urllib2.HTTPError, e:
+      response = e
+    if (response.code != 302 or
+        response.info()["location"] != continue_location):
+      raise urllib2.HTTPError(req.get_full_url(), response.code, response.msg,
+                              response.headers, response.fp)
+    self.authenticated = True
+
+  def _Authenticate(self):
+    """Authenticates the user.
+
+    The authentication process works as follows:
+     1) We get a username and password from the user
+     2) We use ClientLogin to obtain an AUTH token for the user
+        (see http://code.google.com/apis/accounts/AuthForInstalledApps.html).
+     3) We pass the auth token to /_ah/login on the server to obtain an
+        authentication cookie. If login was successful, it tries to redirect
+        us to the URL we provided.
+
+    If we attempt to access the upload API without first obtaining an
+    authentication cookie, it returns a 401 response and directs us to
+    authenticate ourselves with ClientLogin.
+    """
+    for i in range(3):
+      credentials = self.auth_function()
+      try:
+        auth_token = self._GetAuthToken(credentials[0], credentials[1])
+      except ClientLoginError, e:
+        if e.reason == "BadAuthentication":
+          print >>sys.stderr, "Invalid username or password."
+          continue
+        if e.reason == "CaptchaRequired":
+          print >>sys.stderr, (
+              "Please go to\n"
+              "https://www.google.com/accounts/DisplayUnlockCaptcha\n"
+              "and verify you are a human.  Then try again.")
+          break
+        if e.reason == "NotVerified":
+          print >>sys.stderr, "Account not verified."
+          break
+        if e.reason == "TermsNotAgreed":
+          print >>sys.stderr, "User has not agreed to TOS."
+          break
+        if e.reason == "AccountDeleted":
+          print >>sys.stderr, "The user account has been deleted."
+          break
+        if e.reason == "AccountDisabled":
+          print >>sys.stderr, "The user account has been disabled."
+          break
+        if e.reason == "ServiceDisabled":
+          print >>sys.stderr, ("The user's access to the service has been "
+                               "disabled.")
+          break
+        if e.reason == "ServiceUnavailable":
+          print >>sys.stderr, "The service is not available; try again later."
+          break
+        raise
+      self._GetAuthCookie(auth_token)
+      return
+
+  def Send(self, request_path, payload=None,
+           content_type="application/octet-stream",
+           timeout=None,
+           **kwargs):
+    """Sends an RPC and returns the response.
+
+    Args:
+      request_path: The path to send the request to, eg /api/appversion/create.
+      payload: The body of the request, or None to send an empty request.
+      content_type: The Content-Type header to use.
+      timeout: timeout in seconds; default None i.e. no timeout.
+        (Note: for large requests on OS X, the timeout doesn't work right.)
+      kwargs: Any keyword arguments are converted into query string parameters.
+
+    Returns:
+      The response body, as a string.
+    """
+    # TODO: Don't require authentication.  Let the server say
+    # whether it is necessary.
+    if not self.authenticated:
+      self._Authenticate()
+
+    old_timeout = socket.getdefaulttimeout()
+    socket.setdefaulttimeout(timeout)
+    try:
+      tries = 0
+      while True:
+        tries += 1
+        args = dict(kwargs)
+        url = "http://%s%s" % (self.host, request_path)
+        if args:
+          url += "?" + urllib.urlencode(args)
+        req = self._CreateRequest(url=url, data=payload)
+        req.add_header("Content-Type", content_type)
+        try:
+          f = self.opener.open(req)
+          response = f.read()
+          f.close()
+          return response
+        except urllib2.HTTPError, e:
+          if tries > 3:
+            raise
+          elif e.code == 401:
+            self._Authenticate()
+##           elif e.code >= 500 and e.code < 600:
+##             # Server Error - try again.
+##             continue
+          else:
+            raise
+    finally:
+      socket.setdefaulttimeout(old_timeout)
+
+
+class HttpRpcServer(AbstractRpcServer):
+  """Provides a simplified RPC-style interface for HTTP requests."""
+
+  def _Authenticate(self):
+    """Save the cookie jar after authentication."""
+    super(HttpRpcServer, self)._Authenticate()
+    if self.save_cookies:
+      StatusUpdate("Saving authentication cookies to %s" % self.cookie_file)
+      self.cookie_jar.save()
+
+  def _GetOpener(self):
+    """Returns an OpenerDirector that supports cookies and ignores redirects.
+
+    Returns:
+      A urllib2.OpenerDirector object.
+    """
+    opener = urllib2.OpenerDirector()
+    opener.add_handler(urllib2.ProxyHandler())
+    opener.add_handler(urllib2.UnknownHandler())
+    opener.add_handler(urllib2.HTTPHandler())
+    opener.add_handler(urllib2.HTTPDefaultErrorHandler())
+    opener.add_handler(urllib2.HTTPSHandler())
+    opener.add_handler(urllib2.HTTPErrorProcessor())
+    if self.save_cookies:
+      self.cookie_file = os.path.expanduser("~/.codereview_upload_cookies")
+      self.cookie_jar = cookielib.MozillaCookieJar(self.cookie_file)
+      if os.path.exists(self.cookie_file):
+        try:
+          self.cookie_jar.load()
+          self.authenticated = True
+          StatusUpdate("Loaded authentication cookies from %s" %
+                       self.cookie_file)
+        except (cookielib.LoadError, IOError):
+          # Failed to load cookies - just ignore them.
+          pass
+      else:
+        # Create an empty cookie file with mode 600
+        fd = os.open(self.cookie_file, os.O_CREAT, 0600)
+        os.close(fd)
+      # Always chmod the cookie file
+      os.chmod(self.cookie_file, 0600)
+    else:
+      # Don't save cookies across runs of update.py.
+      self.cookie_jar = cookielib.CookieJar()
+    opener.add_handler(urllib2.HTTPCookieProcessor(self.cookie_jar))
+    return opener
+
+
+parser = optparse.OptionParser(usage="%prog [options] [-- diff_options]")
+parser.add_option("-y", "--assume_yes", action="store_true",
+                  dest="assume_yes", default=False,
+                  help="Assume that the answer to yes/no questions is 'yes'.")
+# Logging
+group = parser.add_option_group("Logging options")
+group.add_option("-q", "--quiet", action="store_const", const=0,
+                 dest="verbose", help="Print errors only.")
+group.add_option("-v", "--verbose", action="store_const", const=2,
+                 dest="verbose", default=1,
+                 help="Print info level logs (default).")
+group.add_option("--noisy", action="store_const", const=3,
+                 dest="verbose", help="Print all logs.")
+# Review server
+group = parser.add_option_group("Review server options")
+group.add_option("-s", "--server", action="store", dest="server",
+                 default="codereview.appspot.com",
+                 metavar="SERVER",
+                 help=("The server to upload to. The format is host[:port]. "
+                       "Defaults to 'codereview.appspot.com'."))
+group.add_option("-e", "--email", action="store", dest="email",
+                 metavar="EMAIL", default=None,
+                 help="The username to use. Will prompt if omitted.")
+group.add_option("-H", "--host", action="store", dest="host",
+                 metavar="HOST", default=None,
+                 help="Overrides the Host header sent with all RPCs.")
+group.add_option("--no_cookies", action="store_false",
+                 dest="save_cookies", default=True,
+                 help="Do not save authentication cookies to local disk.")
+# Issue
+group = parser.add_option_group("Issue options")
+group.add_option("-d", "--description", action="store", dest="description",
+                 metavar="DESCRIPTION", default=None,
+                 help="Optional description when creating an issue.")
+group.add_option("-f", "--description_file", action="store",
+                 dest="description_file", metavar="DESCRIPTION_FILE",
+                 default=None,
+                 help="Optional path of a file that contains "
+                      "the description when creating an issue.")
+group.add_option("-r", "--reviewers", action="store", dest="reviewers",
+                 metavar="REVIEWERS", default=None,
+                 help="Add reviewers (comma separated email addresses).")
+group.add_option("--cc", action="store", dest="cc",
+                 metavar="CC", default=None,
+                 help="Add CC (comma separated email addresses).")
+# Upload options
+group = parser.add_option_group("Patch options")
+group.add_option("-m", "--message", action="store", dest="message",
+                 metavar="MESSAGE", default=None,
+                 help="A message to identify the patch. "
+                      "Will prompt if omitted.")
+group.add_option("-i", "--issue", type="int", action="store",
+                 metavar="ISSUE", default=None,
+                 help="Issue number to which to add. Defaults to new issue.")
+group.add_option("--download_base", action="store_true",
+                 dest="download_base", default=False,
+                 help="Base files will be downloaded by the server "
+                 "(side-by-side diffs may not work on files with CRs).")
+group.add_option("--rev", action="store", dest="revision",
+                 metavar="REV", default=None,
+                 help="Branch/tree/revision to diff against (used by DVCS).")
+group.add_option("--send_mail", action="store_true",
+                 dest="send_mail", default=False,
+                 help="Send notification email to reviewers.")
+
+
+def GetRpcServer(options):
+  """Returns an instance of an AbstractRpcServer.
+
+  Returns:
+    A new AbstractRpcServer, on which RPC calls can be made.
+  """
+
+  rpc_server_class = HttpRpcServer
+
+  def GetUserCredentials():
+    """Prompts the user for a username and password."""
+    email = options.email
+    if email is None:
+      email = GetEmail("Email (login for uploading to %s)" % options.server)
+    password = getpass.getpass("Password for %s: " % email)
+    return (email, password)
+
+  # If this is the dev_appserver, use fake authentication.
+  host = (options.host or options.server).lower()
+  if host == "localhost" or host.startswith("localhost:"):
+    email = options.email
+    if email is None:
+      email = "test@example.com"
+      logging.info("Using debug user %s.  Override with --email" % email)
+    server = rpc_server_class(
+        options.server,
+        lambda: (email, "password"),
+        host_override=options.host,
+        extra_headers={"Cookie":
+                       'dev_appserver_login="%s:False"' % email},
+        save_cookies=options.save_cookies)
+    # Don't try to talk to ClientLogin.
+    server.authenticated = True
+    return server
+
+  return rpc_server_class(options.server, GetUserCredentials,
+                          host_override=options.host,
+                          save_cookies=options.save_cookies)
+
+
+def EncodeMultipartFormData(fields, files):
+  """Encode form fields for multipart/form-data.
+
+  Args:
+    fields: A sequence of (name, value) elements for regular form fields.
+    files: A sequence of (name, filename, value) elements for data to be
+           uploaded as files.
+  Returns:
+    (content_type, body) ready for httplib.HTTP instance.
+
+  Source:
+    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/146306
+  """
+  BOUNDARY = '-M-A-G-I-C---B-O-U-N-D-A-R-Y-'
+  CRLF = '\r\n'
+  lines = []
+  for (key, value) in fields:
+    lines.append('--' + BOUNDARY)
+    lines.append('Content-Disposition: form-data; name="%s"' % key)
+    lines.append('')
+    lines.append(value)
+  for (key, filename, value) in files:
+    lines.append('--' + BOUNDARY)
+    lines.append('Content-Disposition: form-data; name="%s"; filename="%s"' %
+             (key, filename))
+    lines.append('Content-Type: %s' % GetContentType(filename))
+    lines.append('')
+    lines.append(value)
+  lines.append('--' + BOUNDARY + '--')
+  lines.append('')
+  body = CRLF.join(lines)
+  content_type = 'multipart/form-data; boundary=%s' % BOUNDARY
+  return content_type, body
+
+
+def GetContentType(filename):
+  """Helper to guess the content-type from the filename."""
+  return mimetypes.guess_type(filename)[0] or 'application/octet-stream'
+
+
+# Use a shell for subcommands on Windows to get a PATH search.
+use_shell = sys.platform.startswith("win")
+
+def RunShellWithReturnCode(command, print_output=False,
+                           universal_newlines=True):
+  """Executes a command and returns the output from stdout and the return code.
+
+  Args:
+    command: Command to execute.
+    print_output: If True, the output is printed to stdout.
+                  If False, both stdout and stderr are ignored.
+    universal_newlines: Use universal_newlines flag (default: True).
+
+  Returns:
+    Tuple (output, return code)
+  """
+  logging.info("Running %s", command)
+  p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                       shell=use_shell, universal_newlines=universal_newlines)
+  if print_output:
+    output_array = []
+    while True:
+      line = p.stdout.readline()
+      if not line:
+        break
+      print line.strip("\n")
+      output_array.append(line)
+    output = "".join(output_array)
+  else:
+    output = p.stdout.read()
+  p.wait()
+  errout = p.stderr.read()
+  if print_output and errout:
+    print >>sys.stderr, errout
+  p.stdout.close()
+  p.stderr.close()
+  return output, p.returncode
+
+
+def RunShell(command, silent_ok=False, universal_newlines=True,
+             print_output=False):
+  data, retcode = RunShellWithReturnCode(command, print_output,
+                                         universal_newlines)
+  if retcode:
+    ErrorExit("Got error status from %s:\n%s" % (command, data))
+  if not silent_ok and not data:
+    ErrorExit("No output from %s" % command)
+  return data
+
+
+class VersionControlSystem(object):
+  """Abstract base class providing an interface to the VCS."""
+
+  def __init__(self, options):
+    """Constructor.
+
+    Args:
+      options: Command line options.
+    """
+    self.options = options
+
+  def GenerateDiff(self, args):
+    """Return the current diff as a string.
+
+    Args:
+      args: Extra arguments to pass to the diff command.
+    """
+    raise NotImplementedError(
+        "abstract method -- subclass %s must override" % self.__class__)
+
+  def GetUnknownFiles(self):
+    """Return a list of files unknown to the VCS."""
+    raise NotImplementedError(
+        "abstract method -- subclass %s must override" % self.__class__)
+
+  def CheckForUnknownFiles(self):
+    """Show an "are you sure?" prompt if there are unknown files."""
+    unknown_files = self.GetUnknownFiles()
+    if unknown_files:
+      print "The following files are not added to version control:"
+      for line in unknown_files:
+        print line
+      prompt = "Are you sure to continue?(y/N) "
+      answer = raw_input(prompt).strip()
+      if answer != "y":
+        ErrorExit("User aborted")
+
+  def GetBaseFile(self, filename):
+    """Get the content of the upstream version of a file.
+
+    Returns:
+      A tuple (base_content, new_content, is_binary, status)
+        base_content: The contents of the base file.
+        new_content: For text files, this is empty.  For binary files, this is
+          the contents of the new file, since the diff output won't contain
+          information to reconstruct the current file.
+        is_binary: True iff the file is binary.
+        status: The status of the file.
+    """
+
+    raise NotImplementedError(
+        "abstract method -- subclass %s must override" % self.__class__)
+
+
+  def GetBaseFiles(self, diff):
+    """Helper that calls GetBase file for each file in the patch.
+
+    Returns:
+      A dictionary that maps from filename to GetBaseFile's tuple.  Filenames
+      are retrieved based on lines that start with "Index:" or
+      "Property changes on:".
+    """
+    files = {}
+    for line in diff.splitlines(True):
+      if line.startswith('Index:') or line.startswith('Property changes on:'):
+        unused, filename = line.split(':', 1)
+        # On Windows if a file has property changes its filename uses '\'
+        # instead of '/'.
+        filename = filename.strip().replace('\\', '/')
+        files[filename] = self.GetBaseFile(filename)
+    return files
+
+
+  def UploadBaseFiles(self, issue, rpc_server, patch_list, patchset, options,
+                      files):
+    """Uploads the base files (and if necessary, the current ones as well)."""
+
+    def UploadFile(filename, file_id, content, is_binary, status, is_base):
+      """Uploads a file to the server."""
+      file_too_large = False
+      if is_base:
+        type = "base"
+      else:
+        type = "current"
+      if len(content) > MAX_UPLOAD_SIZE:
+        print ("Not uploading the %s file for %s because it's too large." %
+               (type, filename))
+        file_too_large = True
+        content = ""
+      checksum = md5.new(content).hexdigest()
+      if options.verbose > 0 and not file_too_large:
+        print "Uploading %s file for %s" % (type, filename)
+      url = "/%d/upload_content/%d/%d" % (int(issue), int(patchset), file_id)
+      form_fields = [("filename", filename),
+                     ("status", status),
+                     ("checksum", checksum),
+                     ("is_binary", str(is_binary)),
+                     ("is_current", str(not is_base)),
+                    ]
+      if file_too_large:
+        form_fields.append(("file_too_large", "1"))
+      if options.email:
+        form_fields.append(("user", options.email))
+      ctype, body = EncodeMultipartFormData(form_fields,
+                                            [("data", filename, content)])
+      response_body = rpc_server.Send(url, body,
+                                      content_type=ctype)
+      if not response_body.startswith("OK"):
+        StatusUpdate("  --> %s" % response_body)
+        sys.exit(1)
+
+    patches = dict()
+    [patches.setdefault(v, k) for k, v in patch_list]
+    for filename in patches.keys():
+      base_content, new_content, is_binary, status = files[filename]
+      file_id_str = patches.get(filename)
+      if file_id_str.find("nobase") != -1:
+        base_content = None
+        file_id_str = file_id_str[file_id_str.rfind("_") + 1:]
+      file_id = int(file_id_str)
+      if base_content != None:
+        UploadFile(filename, file_id, base_content, is_binary, status, True)
+      if new_content != None:
+        UploadFile(filename, file_id, new_content, is_binary, status, False)
+
+  def IsImage(self, filename):
+    """Returns true if the filename has an image extension."""
+    mimetype =  mimetypes.guess_type(filename)[0]
+    if not mimetype:
+      return False
+    return mimetype.startswith("image/")
+
+
+class SubversionVCS(VersionControlSystem):
+  """Implementation of the VersionControlSystem interface for Subversion."""
+
+  def __init__(self, options):
+    super(SubversionVCS, self).__init__(options)
+    if self.options.revision:
+      match = re.match(r"(\d+)(:(\d+))?", self.options.revision)
+      if not match:
+        ErrorExit("Invalid Subversion revision %s." % self.options.revision)
+      self.rev_start = match.group(1)
+      self.rev_end = match.group(3)
+    else:
+      self.rev_start = self.rev_end = None
+    # Cache output from "svn list -r REVNO dirname".
+    # Keys: dirname, Values: 2-tuple (ouput for start rev and end rev).
+    self.svnls_cache = {}
+    # SVN base URL is required to fetch files deleted in an older revision.
+    # Result is cached to not guess it over and over again in GetBaseFile().
+    required = self.options.download_base or self.options.revision is not None
+    self.svn_base = self._GuessBase(required)
+
+  def GuessBase(self, required):
+    """Wrapper for _GuessBase."""
+    return self.svn_base
+
+  def _GuessBase(self, required):
+    """Returns the SVN base URL.
+
+    Args:
+      required: If true, exits if the url can't be guessed, otherwise None is
+        returned.
+    """
+    info = RunShell(["svn", "info"])
+    for line in info.splitlines():
+      words = line.split()
+      if len(words) == 2 and words[0] == "URL:":
+        url = words[1]
+        scheme, netloc, path, params, query, fragment = urlparse.urlparse(url)
+        username, netloc = urllib.splituser(netloc)
+        if username:
+          logging.info("Removed username from base URL")
+        if netloc.endswith("svn.python.org"):
+          if netloc == "svn.python.org":
+            if path.startswith("/projects/"):
+              path = path[9:]
+          elif netloc != "pythondev@svn.python.org":
+            ErrorExit("Unrecognized Python URL: %s" % url)
+          base = "http://svn.python.org/view/*checkout*%s/" % path
+          logging.info("Guessed Python base = %s", base)
+        elif netloc.endswith("svn.collab.net"):
+          if path.startswith("/repos/"):
+            path = path[6:]
+          base = "http://svn.collab.net/viewvc/*checkout*%s/" % path
+          logging.info("Guessed CollabNet base = %s", base)
+        elif netloc.endswith(".googlecode.com"):
+          path = path + "/"
+          base = urlparse.urlunparse(("http", netloc, path, params,
+                                      query, fragment))
+          logging.info("Guessed Google Code base = %s", base)
+        else:
+          path = path + "/"
+          base = urlparse.urlunparse((scheme, netloc, path, params,
+                                      query, fragment))
+          logging.info("Guessed base = %s", base)
+        return base
+    if required:
+      ErrorExit("Can't find URL in output from svn info")
+    return None
+
+  def GenerateDiff(self, args):
+    cmd = ["svn", "diff"]
+    if self.options.revision:
+      cmd += ["-r", self.options.revision]
+    cmd.extend(args)
+    data = RunShell(cmd)
+    count = 0
+    for line in data.splitlines():
+      if line.startswith("Index:") or line.startswith("Property changes on:"):
+        count += 1
+        logging.info(line)
+    if not count:
+      ErrorExit("No valid patches found in output from svn diff")
+    return data
+
+  def _CollapseKeywords(self, content, keyword_str):
+    """Collapses SVN keywords."""
+    # svn cat translates keywords but svn diff doesn't. As a result of this
+    # behavior patching.PatchChunks() fails with a chunk mismatch error.
+    # This part was originally written by the Review Board development team
+    # who had the same problem (http://reviews.review-board.org/r/276/).
+    # Mapping of keywords to known aliases
+    svn_keywords = {
+      # Standard keywords
+      'Date':                ['Date', 'LastChangedDate'],
+      'Revision':            ['Revision', 'LastChangedRevision', 'Rev'],
+      'Author':              ['Author', 'LastChangedBy'],
+      'HeadURL':             ['HeadURL', 'URL'],
+      'Id':                  ['Id'],
+
+      # Aliases
+      'LastChangedDate':     ['LastChangedDate', 'Date'],
+      'LastChangedRevision': ['LastChangedRevision', 'Rev', 'Revision'],
+      'LastChangedBy':       ['LastChangedBy', 'Author'],
+      'URL':                 ['URL', 'HeadURL'],
+    }
+
+    def repl(m):
+       if m.group(2):
+         return "$%s::%s$" % (m.group(1), " " * len(m.group(3)))
+       return "$%s$" % m.group(1)
+    keywords = [keyword
+                for name in keyword_str.split(" ")
+                for keyword in svn_keywords.get(name, [])]
+    return re.sub(r"\$(%s):(:?)([^\$]+)\$" % '|'.join(keywords), repl, content)
+
+  def GetUnknownFiles(self):
+    status = RunShell(["svn", "status", "--ignore-externals"], silent_ok=True)
+    unknown_files = []
+    for line in status.split("\n"):
+      if line and line[0] == "?":
+        unknown_files.append(line)
+    return unknown_files
+
+  def ReadFile(self, filename):
+    """Returns the contents of a file."""
+    file = open(filename, 'rb')
+    result = ""
+    try:
+      result = file.read()
+    finally:
+      file.close()
+    return result
+
+  def GetStatus(self, filename):
+    """Returns the status of a file."""
+    if not self.options.revision:
+      status = RunShell(["svn", "status", "--ignore-externals", filename])
+      if not status:
+        ErrorExit("svn status returned no output for %s" % filename)
+      status_lines = status.splitlines()
+      # If file is in a cl, the output will begin with
+      # "\n--- Changelist 'cl_name':\n".  See
+      # http://svn.collab.net/repos/svn/trunk/notes/changelist-design.txt
+      if (len(status_lines) == 3 and
+          not status_lines[0] and
+          status_lines[1].startswith("--- Changelist")):
+        status = status_lines[2]
+      else:
+        status = status_lines[0]
+    # If we have a revision to diff against we need to run "svn list"
+    # for the old and the new revision and compare the results to get
+    # the correct status for a file.
+    else:
+      dirname, relfilename = os.path.split(filename)
+      if dirname not in self.svnls_cache:
+        cmd = ["svn", "list", "-r", self.rev_start, dirname or "."]
+        out, returncode = RunShellWithReturnCode(cmd)
+        if returncode:
+          ErrorExit("Failed to get status for %s." % filename)
+        old_files = out.splitlines()
+        args = ["svn", "list"]
+        if self.rev_end:
+          args += ["-r", self.rev_end]
+        cmd = args + [dirname or "."]
+        out, returncode = RunShellWithReturnCode(cmd)
+        if returncode:
+          ErrorExit("Failed to run command %s" % cmd)
+        self.svnls_cache[dirname] = (old_files, out.splitlines())
+      old_files, new_files = self.svnls_cache[dirname]
+      if relfilename in old_files and relfilename not in new_files:
+        status = "D   "
+      elif relfilename in old_files and relfilename in new_files:
+        status = "M   "
+      else:
+        status = "A   "
+    return status
+
+  def GetBaseFile(self, filename):
+    status = self.GetStatus(filename)
+    base_content = None
+    new_content = None
+
+    # If a file is copied its status will be "A  +", which signifies
+    # "addition-with-history".  See "svn st" for more information.  We need to
+    # upload the original file or else diff parsing will fail if the file was
+    # edited.
+    if status[0] == "A" and status[3] != "+":
+      # We'll need to upload the new content if we're adding a binary file
+      # since diff's output won't contain it.
+      mimetype = RunShell(["svn", "propget", "svn:mime-type", filename],
+                          silent_ok=True)
+      base_content = ""
+      is_binary = mimetype and not mimetype.startswith("text/")
+      if is_binary and self.IsImage(filename):
+        new_content = self.ReadFile(filename)
+    elif (status[0] in ("M", "D", "R") or
+          (status[0] == "A" and status[3] == "+") or  # Copied file.
+          (status[0] == " " and status[1] == "M")):  # Property change.
+      args = []
+      if self.options.revision:
+        url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
+      else:
+        # Don't change filename, it's needed later.
+        url = filename
+        args += ["-r", "BASE"]
+      cmd = ["svn"] + args + ["propget", "svn:mime-type", url]
+      mimetype, returncode = RunShellWithReturnCode(cmd)
+      if returncode:
+        # File does not exist in the requested revision.
+        # Reset mimetype, it contains an error message.
+        mimetype = ""
+      get_base = False
+      is_binary = mimetype and not mimetype.startswith("text/")
+      if status[0] == " ":
+        # Empty base content just to force an upload.
+        base_content = ""
+      elif is_binary:
+        if self.IsImage(filename):
+          get_base = True
+          if status[0] == "M":
+            if not self.rev_end:
+              new_content = self.ReadFile(filename)
+            else:
+              url = "%s/%s@%s" % (self.svn_base, filename, self.rev_end)
+              new_content = RunShell(["svn", "cat", url],
+                                     universal_newlines=True, silent_ok=True)
+        else:
+          base_content = ""
+      else:
+        get_base = True
+
+      if get_base:
+        if is_binary:
+          universal_newlines = False
+        else:
+          universal_newlines = True
+        if self.rev_start:
+          # "svn cat -r REV delete_file.txt" doesn't work. cat requires
+          # the full URL with "@REV" appended instead of using "-r" option.
+          url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
+          base_content = RunShell(["svn", "cat", url],
+                                  universal_newlines=universal_newlines,
+                                  silent_ok=True)
+        else:
+          base_content = RunShell(["svn", "cat", filename],
+                                  universal_newlines=universal_newlines,
+                                  silent_ok=True)
+        if not is_binary:
+          args = []
+          if self.rev_start:
+            url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
+          else:
+            url = filename
+            args += ["-r", "BASE"]
+          cmd = ["svn"] + args + ["propget", "svn:keywords", url]
+          keywords, returncode = RunShellWithReturnCode(cmd)
+          if keywords and not returncode:
+            base_content = self._CollapseKeywords(base_content, keywords)
+    else:
+      StatusUpdate("svn status returned unexpected output: %s" % status)
+      sys.exit(1)
+    return base_content, new_content, is_binary, status[0:5]
+
+
+class GitVCS(VersionControlSystem):
+  """Implementation of the VersionControlSystem interface for Git."""
+
+  def __init__(self, options):
+    super(GitVCS, self).__init__(options)
+    # Map of filename -> hash of base file.
+    self.base_hashes = {}
+
+  def GenerateDiff(self, extra_args):
+    # This is more complicated than svn's GenerateDiff because we must convert
+    # the diff output to include an svn-style "Index:" line as well as record
+    # the hashes of the base files, so we can upload them along with our diff.
+    if self.options.revision:
+      extra_args = [self.options.revision] + extra_args
+    gitdiff = RunShell(["git", "diff", "--full-index"] + extra_args)
+    svndiff = []
+    filecount = 0
+    filename = None
+    for line in gitdiff.splitlines():
+      match = re.match(r"diff --git a/(.*) b/.*$", line)
+      if match:
+        filecount += 1
+        filename = match.group(1)
+        svndiff.append("Index: %s\n" % filename)
+      else:
+        # The "index" line in a git diff looks like this (long hashes elided):
+        #   index 82c0d44..b2cee3f 100755
+        # We want to save the left hash, as that identifies the base file.
+        match = re.match(r"index (\w+)\.\.", line)
+        if match:
+          self.base_hashes[filename] = match.group(1)
+      svndiff.append(line + "\n")
+    if not filecount:
+      ErrorExit("No valid patches found in output from git diff")
+    return "".join(svndiff)
+
+  def GetUnknownFiles(self):
+    status = RunShell(["git", "ls-files", "--exclude-standard", "--others"],
+                      silent_ok=True)
+    return status.splitlines()
+
+  def GetBaseFile(self, filename):
+    hash = self.base_hashes[filename]
+    base_content = None
+    new_content = None
+    is_binary = False
+    if hash == "0" * 40:  # All-zero hash indicates no base file.
+      status = "A"
+      base_content = ""
+    else:
+      status = "M"
+      base_content, returncode = RunShellWithReturnCode(["git", "show", hash])
+      if returncode:
+        ErrorExit("Got error status from 'git show %s'" % hash)
+    return (base_content, new_content, is_binary, status)
+
+
+class MercurialVCS(VersionControlSystem):
+  """Implementation of the VersionControlSystem interface for Mercurial."""
+
+  def __init__(self, options, repo_dir):
+    super(MercurialVCS, self).__init__(options)
+    # Absolute path to repository (we can be in a subdir)
+    self.repo_dir = os.path.normpath(repo_dir)
+    # Compute the subdir
+    cwd = os.path.normpath(os.getcwd())
+    assert cwd.startswith(self.repo_dir)
+    self.subdir = cwd[len(self.repo_dir):].lstrip(r"\/")
+    if self.options.revision:
+      self.base_rev = self.options.revision
+    else:
+      self.base_rev = RunShell(["hg", "parent", "-q"]).split(':')[1].strip()
+
+  def _GetRelPath(self, filename):
+    """Get relative path of a file according to the current directory,
+    given its logical path in the repo."""
+    assert filename.startswith(self.subdir), filename
+    return filename[len(self.subdir):].lstrip(r"\/")
+
+  def GenerateDiff(self, extra_args):
+    # If no file specified, restrict to the current subdir
+    extra_args = extra_args or ["."]
+    cmd = ["hg", "diff", "--git", "-r", self.base_rev] + extra_args
+    data = RunShell(cmd, silent_ok=True)
+    svndiff = []
+    filecount = 0
+    for line in data.splitlines():
+      m = re.match("diff --git a/(\S+) b/(\S+)", line)
+      if m:
+        # Modify line to make it look like as it comes from svn diff.
+        # With this modification no changes on the server side are required
+        # to make upload.py work with Mercurial repos.
+        # NOTE: for proper handling of moved/copied files, we have to use
+        # the second filename.
+        filename = m.group(2)
+        svndiff.append("Index: %s" % filename)
+        svndiff.append("=" * 67)
+        filecount += 1
+        logging.info(line)
+      else:
+        svndiff.append(line)
+    if not filecount:
+      ErrorExit("No valid patches found in output from hg diff")
+    return "\n".join(svndiff) + "\n"
+
+  def GetUnknownFiles(self):
+    """Return a list of files unknown to the VCS."""
+    args = []
+    status = RunShell(["hg", "status", "--rev", self.base_rev, "-u", "."],
+        silent_ok=True)
+    unknown_files = []
+    for line in status.splitlines():
+      st, fn = line.split(" ", 1)
+      if st == "?":
+        unknown_files.append(fn)
+    return unknown_files
+
+  def GetBaseFile(self, filename):
+    # "hg status" and "hg cat" both take a path relative to the current subdir
+    # rather than to the repo root, but "hg diff" has given us the full path
+    # to the repo root.
+    base_content = ""
+    new_content = None
+    is_binary = False
+    oldrelpath = relpath = self._GetRelPath(filename)
+    # "hg status -C" returns two lines for moved/copied files, one otherwise
+    out = RunShell(["hg", "status", "-C", "--rev", self.base_rev, relpath])
+    out = out.splitlines()
+    # HACK: strip error message about missing file/directory if it isn't in
+    # the working copy
+    if out[0].startswith('%s: ' % relpath):
+      out = out[1:]
+    if len(out) > 1:
+      # Moved/copied => considered as modified, use old filename to
+      # retrieve base contents
+      oldrelpath = out[1].strip()
+      status = "M"
+    else:
+      status, _ = out[0].split(' ', 1)
+    if status != "A":
+      base_content = RunShell(["hg", "cat", "-r", self.base_rev, oldrelpath],
+        silent_ok=True)
+      is_binary = "\0" in base_content  # Mercurial's heuristic
+    if status != "R":
+      new_content = open(relpath, "rb").read()
+      is_binary = is_binary or "\0" in new_content
+    if is_binary and base_content:
+      # Fetch again without converting newlines
+      base_content = RunShell(["hg", "cat", "-r", self.base_rev, oldrelpath],
+        silent_ok=True, universal_newlines=False)
+    if not is_binary or not self.IsImage(relpath):
+      new_content = None
+    return base_content, new_content, is_binary, status
+
+
+# NOTE: The SplitPatch function is duplicated in engine.py, keep them in sync.
+def SplitPatch(data):
+  """Splits a patch into separate pieces for each file.
+
+  Args:
+    data: A string containing the output of svn diff.
+
+  Returns:
+    A list of 2-tuple (filename, text) where text is the svn diff output
+      pertaining to filename.
+  """
+  patches = []
+  filename = None
+  diff = []
+  for line in data.splitlines(True):
+    new_filename = None
+    if line.startswith('Index:'):
+      unused, new_filename = line.split(':', 1)
+      new_filename = new_filename.strip()
+    elif line.startswith('Property changes on:'):
+      unused, temp_filename = line.split(':', 1)
+      # When a file is modified, paths use '/' between directories, however
+      # when a property is modified '\' is used on Windows.  Make them the same
+      # otherwise the file shows up twice.
+      temp_filename = temp_filename.strip().replace('\\', '/')
+      if temp_filename != filename:
+        # File has property changes but no modifications, create a new diff.
+        new_filename = temp_filename
+    if new_filename:
+      if filename and diff:
+        patches.append((filename, ''.join(diff)))
+      filename = new_filename
+      diff = [line]
+      continue
+    if diff is not None:
+      diff.append(line)
+  if filename and diff:
+    patches.append((filename, ''.join(diff)))
+  return patches
+
+
+def UploadSeparatePatches(issue, rpc_server, patchset, data, options):
+  """Uploads a separate patch for each file in the diff output.
+
+  Returns a list of [patch_key, filename] for each file.
+  """
+  patches = SplitPatch(data)
+  rv = []
+  for patch in patches:
+    if len(patch[1]) > MAX_UPLOAD_SIZE:
+      print ("Not uploading the patch for " + patch[0] +
+             " because the file is too large.")
+      continue
+    form_fields = [("filename", patch[0])]
+    if not options.download_base:
+      form_fields.append(("content_upload", "1"))
+    files = [("data", "data.diff", patch[1])]
+    ctype, body = EncodeMultipartFormData(form_fields, files)
+    url = "/%d/upload_patch/%d" % (int(issue), int(patchset))
+    print "Uploading patch for " + patch[0]
+    response_body = rpc_server.Send(url, body, content_type=ctype)
+    lines = response_body.splitlines()
+    if not lines or lines[0] != "OK":
+      StatusUpdate("  --> %s" % response_body)
+      sys.exit(1)
+    rv.append([lines[1], patch[0]])
+  return rv
+
+
+def GuessVCS(options):
+  """Helper to guess the version control system.
+
+  This examines the current directory, guesses which VersionControlSystem
+  we're using, and returns an instance of the appropriate class.  Exit with an
+  error if we can't figure it out.
+
+  Returns:
+    A VersionControlSystem instance. Exits if the VCS can't be guessed.
+  """
+  # Mercurial has a command to get the base directory of a repository
+  # Try running it, but don't die if we don't have hg installed.
+  # NOTE: we try Mercurial first as it can sit on top of an SVN working copy.
+  try:
+    out, returncode = RunShellWithReturnCode(["hg", "root"])
+    if returncode == 0:
+      return MercurialVCS(options, out.strip())
+  except OSError, (errno, message):
+    if errno != 2:  # ENOENT -- they don't have hg installed.
+      raise
+
+  # Subversion has a .svn in all working directories.
+  if os.path.isdir('.svn'):
+    logging.info("Guessed VCS = Subversion")
+    return SubversionVCS(options)
+
+  # Git has a command to test if you're in a git tree.
+  # Try running it, but don't die if we don't have git installed.
+  try:
+    out, returncode = RunShellWithReturnCode(["git", "rev-parse",
+                                              "--is-inside-work-tree"])
+    if returncode == 0:
+      return GitVCS(options)
+  except OSError, (errno, message):
+    if errno != 2:  # ENOENT -- they don't have git installed.
+      raise
+
+  ErrorExit(("Could not guess version control system. "
+             "Are you in a working copy directory?"))
+
+
+def RealMain(argv, data=None):
+  """The real main function.
+
+  Args:
+    argv: Command line arguments.
+    data: Diff contents. If None (default) the diff is generated by
+      the VersionControlSystem implementation returned by GuessVCS().
+
+  Returns:
+    A 2-tuple (issue id, patchset id).
+    The patchset id is None if the base files are not uploaded by this
+    script (applies only to SVN checkouts).
+  """
+  logging.basicConfig(format=("%(asctime).19s %(levelname)s %(filename)s:"
+                              "%(lineno)s %(message)s "))
+  os.environ['LC_ALL'] = 'C'
+  options, args = parser.parse_args(argv[1:])
+  global verbosity
+  verbosity = options.verbose
+  if verbosity >= 3:
+    logging.getLogger().setLevel(logging.DEBUG)
+  elif verbosity >= 2:
+    logging.getLogger().setLevel(logging.INFO)
+  vcs = GuessVCS(options)
+  if isinstance(vcs, SubversionVCS):
+    # base field is only allowed for Subversion.
+    # Note: Fetching base files may become deprecated in future releases.
+    base = vcs.GuessBase(options.download_base)
+  else:
+    base = None
+  if not base and options.download_base:
+    options.download_base = True
+    logging.info("Enabled upload of base file")
+  if not options.assume_yes:
+    vcs.CheckForUnknownFiles()
+  if data is None:
+    data = vcs.GenerateDiff(args)
+  files = vcs.GetBaseFiles(data)
+  if verbosity >= 1:
+    print "Upload server:", options.server, "(change with -s/--server)"
+  if options.issue:
+    prompt = "Message describing this patch set: "
+  else:
+    prompt = "New issue subject: "
+  message = options.message or raw_input(prompt).strip()
+  if not message:
+    ErrorExit("A non-empty message is required")
+  rpc_server = GetRpcServer(options)
+  form_fields = [("subject", message)]
+  if base:
+    form_fields.append(("base", base))
+  if options.issue:
+    form_fields.append(("issue", str(options.issue)))
+  if options.email:
+    form_fields.append(("user", options.email))
+  if options.reviewers:
+    for reviewer in options.reviewers.split(','):
+      if "@" in reviewer and not reviewer.split("@")[1].count(".") == 1:
+        ErrorExit("Invalid email address: %s" % reviewer)
+    form_fields.append(("reviewers", options.reviewers))
+  if options.cc:
+    for cc in options.cc.split(','):
+      if "@" in cc and not cc.split("@")[1].count(".") == 1:
+        ErrorExit("Invalid email address: %s" % cc)
+    form_fields.append(("cc", options.cc))
+  description = options.description
+  if options.description_file:
+    if options.description:
+      ErrorExit("Can't specify description and description_file")
+    file = open(options.description_file, 'r')
+    description = file.read()
+    file.close()
+  if description:
+    form_fields.append(("description", description))
+  # Send a hash of all the base file so the server can determine if a copy
+  # already exists in an earlier patchset.
+  base_hashes = ""
+  for file, info in files.iteritems():
+    if not info[0] is None:
+      checksum = md5.new(info[0]).hexdigest()
+      if base_hashes:
+        base_hashes += "|"
+      base_hashes += checksum + ":" + file
+  form_fields.append(("base_hashes", base_hashes))
+  # If we're uploading base files, don't send the email before the uploads, so
+  # that it contains the file status.
+  if options.send_mail and options.download_base:
+    form_fields.append(("send_mail", "1"))
+  if not options.download_base:
+    form_fields.append(("content_upload", "1"))
+  if len(data) > MAX_UPLOAD_SIZE:
+    print "Patch is large, so uploading file patches separately."
+    uploaded_diff_file = []
+    form_fields.append(("separate_patches", "1"))
+  else:
+    uploaded_diff_file = [("data", "data.diff", data)]
+  ctype, body = EncodeMultipartFormData(form_fields, uploaded_diff_file)
+  response_body = rpc_server.Send("/upload", body, content_type=ctype)
+  patchset = None
+  if not options.download_base or not uploaded_diff_file:
+    lines = response_body.splitlines()
+    if len(lines) >= 2:
+      msg = lines[0]
+      patchset = lines[1].strip()
+      patches = [x.split(" ", 1) for x in lines[2:]]
+    else:
+      msg = response_body
+  else:
+    msg = response_body
+  StatusUpdate(msg)
+  if not response_body.startswith("Issue created.") and \
+  not response_body.startswith("Issue updated."):
+    sys.exit(0)
+  issue = msg[msg.rfind("/")+1:]
+
+  if not uploaded_diff_file:
+    result = UploadSeparatePatches(issue, rpc_server, patchset, data, options)
+    if not options.download_base:
+      patches = result
+
+  if not options.download_base:
+    vcs.UploadBaseFiles(issue, rpc_server, patches, patchset, options, files)
+    if options.send_mail:
+      rpc_server.Send("/" + issue + "/mail", payload="")
+  return issue, patchset
+
+
+def main():
+  try:
+    RealMain(sys.argv)
+  except KeyboardInterrupt:
+    print
+    StatusUpdate("Interrupted.")
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload_gmock.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload_gmock.py
new file mode 100755
index 00000000..5dc484b3
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload_gmock.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+#
+# Copyright 2009, 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.
+
+"""upload_gmock.py v0.1.0 -- uploads a Google Mock patch for review.
+
+This simple wrapper passes all command line flags and
+--cc=googlemock@googlegroups.com to upload.py.
+
+USAGE: upload_gmock.py [options for upload.py]
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import sys
+
+CC_FLAG = '--cc='
+GMOCK_GROUP = 'googlemock@googlegroups.com'
+
+
+def main():
+  # Finds the path to upload.py, assuming it is in the same directory
+  # as this file.
+  my_dir = os.path.dirname(os.path.abspath(__file__))
+  upload_py_path = os.path.join(my_dir, 'upload.py')
+
+  # Adds Google Mock discussion group to the cc line if it's not there
+  # already.
+  upload_py_argv = [upload_py_path]
+  found_cc_flag = False
+  for arg in sys.argv[1:]:
+    if arg.startswith(CC_FLAG):
+      found_cc_flag = True
+      cc_line = arg[len(CC_FLAG):]
+      cc_list = [addr for addr in cc_line.split(',') if addr]
+      if GMOCK_GROUP not in cc_list:
+        cc_list.append(GMOCK_GROUP)
+      upload_py_argv.append(CC_FLAG + ','.join(cc_list))
+    else:
+      upload_py_argv.append(arg)
+
+  if not found_cc_flag:
+    upload_py_argv.append(CC_FLAG + GMOCK_GROUP)
+
+  # Invokes upload.py with the modified command line flags.
+  os.execv(upload_py_path, upload_py_argv)
+
+
+if __name__ == '__main__':
+  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-all.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-all.cc
new file mode 100644
index 00000000..7aebce7a
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-all.cc
@@ -0,0 +1,47 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Google C++ Mocking Framework (Google Mock)
+//
+// This file #includes all Google Mock implementation .cc files.  The
+// purpose is to allow a user to build Google Mock by compiling this
+// file alone.
+
+// This line ensures that gmock.h can be compiled on its own, even
+// when it's fused.
+#include "gmock/gmock.h"
+
+// The following lines pull in the real gmock *.cc files.
+#include "src/gmock-cardinalities.cc"
+#include "src/gmock-internal-utils.cc"
+#include "src/gmock-matchers.cc"
+#include "src/gmock-spec-builders.cc"
+#include "src/gmock.cc"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-cardinalities.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-cardinalities.cc
new file mode 100644
index 00000000..50ec7286
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-cardinalities.cc
@@ -0,0 +1,156 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements cardinalities.
+
+#include "gmock/gmock-cardinalities.h"
+
+#include <limits.h>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+
+namespace {
+
+// Implements the Between(m, n) cardinality.
+class BetweenCardinalityImpl : public CardinalityInterface {
+ public:
+  BetweenCardinalityImpl(int min, int max)
+      : min_(min >= 0 ? min : 0),
+        max_(max >= min_ ? max : min_) {
+    std::stringstream ss;
+    if (min < 0) {
+      ss << "The invocation lower bound must be >= 0, "
+         << "but is actually " << min << ".";
+      internal::Expect(false, __FILE__, __LINE__, ss.str());
+    } else if (max < 0) {
+      ss << "The invocation upper bound must be >= 0, "
+         << "but is actually " << max << ".";
+      internal::Expect(false, __FILE__, __LINE__, ss.str());
+    } else if (min > max) {
+      ss << "The invocation upper bound (" << max
+         << ") must be >= the invocation lower bound (" << min
+         << ").";
+      internal::Expect(false, __FILE__, __LINE__, ss.str());
+    }
+  }
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  virtual int ConservativeLowerBound() const { return min_; }
+  virtual int ConservativeUpperBound() const { return max_; }
+
+  virtual bool IsSatisfiedByCallCount(int call_count) const {
+    return min_ <= call_count && call_count <= max_;
+  }
+
+  virtual bool IsSaturatedByCallCount(int call_count) const {
+    return call_count >= max_;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const;
+
+ private:
+  const int min_;
+  const int max_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(BetweenCardinalityImpl);
+};
+
+// Formats "n times" in a human-friendly way.
+inline internal::string FormatTimes(int n) {
+  if (n == 1) {
+    return "once";
+  } else if (n == 2) {
+    return "twice";
+  } else {
+    std::stringstream ss;
+    ss << n << " times";
+    return ss.str();
+  }
+}
+
+// Describes the Between(m, n) cardinality in human-friendly text.
+void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const {
+  if (min_ == 0) {
+    if (max_ == 0) {
+      *os << "never called";
+    } else if (max_ == INT_MAX) {
+      *os << "called any number of times";
+    } else {
+      *os << "called at most " << FormatTimes(max_);
+    }
+  } else if (min_ == max_) {
+    *os << "called " << FormatTimes(min_);
+  } else if (max_ == INT_MAX) {
+    *os << "called at least " << FormatTimes(min_);
+  } else {
+    // 0 < min_ < max_ < INT_MAX
+    *os << "called between " << min_ << " and " << max_ << " times";
+  }
+}
+
+}  // Unnamed namespace
+
+// Describes the given call count to an ostream.
+void Cardinality::DescribeActualCallCountTo(int actual_call_count,
+                                            ::std::ostream* os) {
+  if (actual_call_count > 0) {
+    *os << "called " << FormatTimes(actual_call_count);
+  } else {
+    *os << "never called";
+  }
+}
+
+// Creates a cardinality that allows at least n calls.
+GTEST_API_ Cardinality AtLeast(int n) { return Between(n, INT_MAX); }
+
+// Creates a cardinality that allows at most n calls.
+GTEST_API_ Cardinality AtMost(int n) { return Between(0, n); }
+
+// Creates a cardinality that allows any number of calls.
+GTEST_API_ Cardinality AnyNumber() { return AtLeast(0); }
+
+// Creates a cardinality that allows between min and max calls.
+GTEST_API_ Cardinality Between(int min, int max) {
+  return Cardinality(new BetweenCardinalityImpl(min, max));
+}
+
+// Creates a cardinality that allows exactly n calls.
+GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); }
+
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-internal-utils.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-internal-utils.cc
new file mode 100644
index 00000000..fb530801
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-internal-utils.cc
@@ -0,0 +1,174 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// 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.
+
+#include "gmock/internal/gmock-internal-utils.h"
+
+#include <ctype.h>
+#include <ostream>  // NOLINT
+#include <string>
+#include "gmock/gmock.h"
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+namespace internal {
+
+// 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_ string ConvertIdentifierNameToWords(const char* id_name) {
+  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
+    // guaranteed to be a valid C++ identifier name.
+    const bool starts_new_word = IsUpper(*p) ||
+        (!IsAlpha(prev_char) && IsLower(*p)) ||
+        (!IsDigit(prev_char) && IsDigit(*p));
+
+    if (IsAlNum(*p)) {
+      if (starts_new_word && result != "")
+        result += ' ';
+      result += ToLower(*p);
+    }
+  }
+  return result;
+}
+
+// This class reports Google Mock failures as Google Test failures.  A
+// user can define another class in a similar fashion if he intends to
+// use Google Mock with a testing framework other than Google Test.
+class GoogleTestFailureReporter : public FailureReporterInterface {
+ public:
+  virtual void ReportFailure(FailureType type, const char* file, int line,
+                             const string& message) {
+    AssertHelper(type == kFatal ?
+                 TestPartResult::kFatalFailure :
+                 TestPartResult::kNonFatalFailure,
+                 file,
+                 line,
+                 message.c_str()) = Message();
+    if (type == kFatal) {
+      posix::Abort();
+    }
+  }
+};
+
+// Returns the global failure reporter.  Will create a
+// GoogleTestFailureReporter and return it the first time called.
+GTEST_API_ FailureReporterInterface* GetFailureReporter() {
+  // Points to the global failure reporter used by Google Mock.  gcc
+  // guarantees that the following use of failure_reporter is
+  // thread-safe.  We may need to add additional synchronization to
+  // protect failure_reporter if we port Google Mock to other
+  // compilers.
+  static FailureReporterInterface* const failure_reporter =
+      new GoogleTestFailureReporter();
+  return failure_reporter;
+}
+
+// Protects global resources (stdout in particular) used by Log().
+static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex);
+
+// Returns true iff 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.
+    return true;
+  } else if (GMOCK_FLAG(verbose) == kErrorVerbosity) {
+    // Always hide it if --gmock_verbose=error.
+    return false;
+  } else {
+    // If --gmock_verbose is neither "info" nor "error", we treat it
+    // as "warning" (its default value).
+    return severity == kWarning;
+  }
+}
+
+// Prints the given message to stdout iff '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 string& message,
+                    int stack_frames_to_skip) {
+  if (!LogIsVisible(severity))
+    return;
+
+  // Ensures that logs from different threads don't interleave.
+  MutexLock l(&g_log_mutex);
+
+  // "using ::std::cout;" doesn't work with Symbian's STLport, where cout is a
+  // macro.
+
+  if (severity == kWarning) {
+    // Prints a GMOCK WARNING marker to make the warnings easily searchable.
+    std::cout << "\nGMOCK WARNING:";
+  }
+  // Pre-pends a new-line to message if it doesn't start with one.
+  if (message.empty() || message[0] != '\n') {
+    std::cout << "\n";
+  }
+  std::cout << message;
+  if (stack_frames_to_skip >= 0) {
+#ifdef NDEBUG
+    // In opt mode, we have to be conservative and skip no stack frame.
+    const int actual_to_skip = 0;
+#else
+    // In dbg mode, we can do what the caller tell us to do (plus one
+    // for skipping this function's stack frame).
+    const int actual_to_skip = stack_frames_to_skip + 1;
+#endif  // NDEBUG
+
+    // Appends a new-line to message if it doesn't end with one.
+    if (!message.empty() && *message.rbegin() != '\n') {
+      std::cout << "\n";
+    }
+    std::cout << "Stack trace:\n"
+         << ::testing::internal::GetCurrentOsStackTraceExceptTop(
+             ::testing::UnitTest::GetInstance(), actual_to_skip);
+  }
+  std::cout << ::std::flush;
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-matchers.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-matchers.cc
new file mode 100644
index 00000000..e7424510
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-matchers.cc
@@ -0,0 +1,498 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements Matcher<const string&>, Matcher<string>, and
+// utilities for defining matchers.
+
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock-generated-matchers.h"
+
+#include <string.h>
+#include <sstream>
+#include <string>
+
+namespace testing {
+
+// Constructs a matcher that matches a const string& whose value is
+// equal to s.
+Matcher<const internal::string&>::Matcher(const internal::string& s) {
+  *this = Eq(s);
+}
+
+// Constructs a matcher that matches a const string& whose value is
+// equal to s.
+Matcher<const internal::string&>::Matcher(const char* s) {
+  *this = Eq(internal::string(s));
+}
+
+// Constructs a matcher that matches a string whose value is equal to s.
+Matcher<internal::string>::Matcher(const internal::string& s) { *this = Eq(s); }
+
+// Constructs a matcher that matches a string whose value is equal to s.
+Matcher<internal::string>::Matcher(const char* s) {
+  *this = Eq(internal::string(s));
+}
+
+#if GTEST_HAS_STRING_PIECE_
+// Constructs a matcher that matches a const StringPiece& whose value is
+// equal to s.
+Matcher<const StringPiece&>::Matcher(const internal::string& s) {
+  *this = Eq(s);
+}
+
+// Constructs a matcher that matches a const StringPiece& whose value is
+// equal to s.
+Matcher<const StringPiece&>::Matcher(const char* s) {
+  *this = Eq(internal::string(s));
+}
+
+// Constructs a matcher that matches a const StringPiece& whose value is
+// equal to s.
+Matcher<const StringPiece&>::Matcher(StringPiece s) {
+  *this = Eq(s.ToString());
+}
+
+// Constructs a matcher that matches a StringPiece whose value is equal to s.
+Matcher<StringPiece>::Matcher(const internal::string& s) {
+  *this = Eq(s);
+}
+
+// Constructs a matcher that matches a StringPiece whose value is equal to s.
+Matcher<StringPiece>::Matcher(const char* s) {
+  *this = Eq(internal::string(s));
+}
+
+// Constructs a matcher that matches a StringPiece whose value is equal to s.
+Matcher<StringPiece>::Matcher(StringPiece s) {
+  *this = Eq(s.ToString());
+}
+#endif  // GTEST_HAS_STRING_PIECE_
+
+namespace internal {
+
+// Joins a vector of strings as if they are fields of a tuple; returns
+// the joined string.
+GTEST_API_ string JoinAsTuple(const Strings& fields) {
+  switch (fields.size()) {
+    case 0:
+      return "";
+    case 1:
+      return fields[0];
+    default:
+      string result = "(" + fields[0];
+      for (size_t i = 1; i < fields.size(); i++) {
+        result += ", ";
+        result += fields[i];
+      }
+      result += ")";
+      return result;
+  }
+}
+
+// Returns the description for a matcher defined using the MATCHER*()
+// macro where the user-supplied description string is "", if
+// '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_ string FormatMatcherDescription(bool negation,
+                                           const char* matcher_name,
+                                           const Strings& param_values) {
+  string result = ConvertIdentifierNameToWords(matcher_name);
+  if (param_values.size() >= 1)
+    result += " " + JoinAsTuple(param_values);
+  return negation ? "not (" + result + ")" : result;
+}
+
+// FindMaxBipartiteMatching and its helper class.
+//
+// Uses the well-known Ford-Fulkerson max flow method to find a maximum
+// bipartite matching. Flow is considered to be from left to right.
+// There is an implicit source node that is connected to all of the left
+// nodes, and an implicit sink node that is connected to all of the
+// right nodes. All edges have unit capacity.
+//
+// Neither the flow graph nor the residual flow graph are represented
+// explicitly. Instead, they are implied by the information in 'graph' and
+// a vector<int> called 'left_' whose elements are initialized to the
+// value kUnused. This represents the initial state of the algorithm,
+// where the flow graph is empty, and the residual flow graph has the
+// following edges:
+//   - An edge from source to each left_ node
+//   - An edge from each right_ node to sink
+//   - An edge from each left_ node to each right_ node, if the
+//     corresponding edge exists in 'graph'.
+//
+// When the TryAugment() method adds a flow, it sets left_[l] = r for some
+// nodes l and r. This induces the following changes:
+//   - The edges (source, l), (l, r), and (r, sink) are added to the
+//     flow graph.
+//   - The same three edges are removed from the residual flow graph.
+//   - The reverse edges (l, source), (r, l), and (sink, r) are added
+//     to the residual flow graph, which is a directional graph
+//     representing unused flow capacity.
+//
+// When the method augments a flow (moving left_[l] from some r1 to some
+// other r2), this can be thought of as "undoing" the above steps with
+// respect to r1 and "redoing" them with respect to r2.
+//
+// It bears repeating that the flow graph and residual flow graph are
+// never represented explicitly, but can be derived by looking at the
+// information in 'graph' and in left_.
+//
+// As an optimization, there is a second vector<int> called right_ which
+// does not provide any new information. Instead, it enables more
+// efficient queries about edges entering or leaving the right-side nodes
+// of the flow or residual flow graphs. The following invariants are
+// maintained:
+//
+// left[l] == kUnused or right[left[l]] == l
+// right[r] == kUnused or left[right[r]] == r
+//
+// . [ source ]                                        .
+// .   |||                                             .
+// .   |||                                             .
+// .   ||\--> left[0]=1  ---\    right[0]=-1 ----\     .
+// .   ||                   |                    |     .
+// .   |\---> left[1]=-1    \--> right[1]=0  ---\|     .
+// .   |                                        ||     .
+// .   \----> left[2]=2  ------> right[2]=2  --\||     .
+// .                                           |||     .
+// .         elements           matchers       vvv     .
+// .                                         [ sink ]  .
+//
+// See Also:
+//   [1] Cormen, et al (2001). "Section 26.2: The Ford-Fulkerson method".
+//       "Introduction to Algorithms (Second ed.)", pp. 651-664.
+//   [2] "Ford-Fulkerson algorithm", Wikipedia,
+//       'http://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
+class MaxBipartiteMatchState {
+ public:
+  explicit MaxBipartiteMatchState(const MatchMatrix& graph)
+      : graph_(&graph),
+        left_(graph_->LhsSize(), kUnused),
+        right_(graph_->RhsSize(), kUnused) {
+  }
+
+  // Returns the edges of a maximal match, each in the form {left, right}.
+  ElementMatcherPairs Compute() {
+    // 'seen' is used for path finding { 0: unseen, 1: seen }.
+    ::std::vector<char> seen;
+    // Searches the residual flow graph for a path from each left node to
+    // the sink in the residual flow graph, and if one is found, add flow
+    // to the graph. It's okay to search through the left nodes once. The
+    // edge from the implicit source node to each previously-visited left
+    // node will have flow if that left node has any path to the sink
+    // whatsoever. Subsequent augmentations can only add flow to the
+    // network, and cannot take away that previous flow unit from the source.
+    // Since the source-to-left edge can only carry one flow unit (or,
+    // each element can be matched to only one matcher), there is no need
+    // to visit the left nodes more than once looking for augmented paths.
+    // The flow is known to be possible or impossible by looking at the
+    // node once.
+    for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
+      // Reset the path-marking vector and try to find a path from
+      // source to sink starting at the left_[ilhs] node.
+      GTEST_CHECK_(left_[ilhs] == kUnused)
+          << "ilhs: " << ilhs << ", left_[ilhs]: " << left_[ilhs];
+      // 'seen' initialized to 'graph_->RhsSize()' copies of 0.
+      seen.assign(graph_->RhsSize(), 0);
+      TryAugment(ilhs, &seen);
+    }
+    ElementMatcherPairs result;
+    for (size_t ilhs = 0; ilhs < left_.size(); ++ilhs) {
+      size_t irhs = left_[ilhs];
+      if (irhs == kUnused) continue;
+      result.push_back(ElementMatcherPair(ilhs, irhs));
+    }
+    return result;
+  }
+
+ private:
+  static const size_t kUnused = static_cast<size_t>(-1);
+
+  // Perform a depth-first search from left node ilhs to the sink.  If a
+  // path is found, flow is added to the network by linking the left and
+  // right vector elements corresponding each segment of the path.
+  // Returns true if a path to sink was found, which means that a unit of
+  // flow was added to the network. The 'seen' vector elements correspond
+  // to right nodes and are marked to eliminate cycles from the search.
+  //
+  // Left nodes will only be explored at most once because they
+  // are accessible from at most one right node in the residual flow
+  // graph.
+  //
+  // Note that left_[ilhs] is the only element of left_ that TryAugment will
+  // potentially transition from kUnused to another value. Any other
+  // left_ element holding kUnused before TryAugment will be holding it
+  // when TryAugment returns.
+  //
+  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;
+      // There's an available edge from ilhs to irhs.
+      (*seen)[irhs] = 1;
+      // Next a search is performed to determine whether
+      // this edge is a dead end or leads to the sink.
+      //
+      // right_[irhs] == kUnused means that there is residual flow from
+      // right node irhs to the sink, so we can use that to finish this
+      // flow path and return success.
+      //
+      // Otherwise there is residual flow to some ilhs. We push flow
+      // along that path and call ourselves recursively to see if this
+      // ultimately leads to sink.
+      if (right_[irhs] == kUnused || TryAugment(right_[irhs], seen)) {
+        // Add flow from left_[ilhs] to right_[irhs].
+        left_[ilhs] = irhs;
+        right_[irhs] = ilhs;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  const MatchMatrix* graph_;  // not owned
+  // 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 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
+  // be redundantly represented in the right_ vector as right_[1] == 3.
+  // Elements of left_ and right_ are either kUnused or mutually
+  // referent. Mutually referent means that left_[right_[i]] = i and
+  // right_[left_[i]] = i.
+  ::std::vector<size_t> left_;
+  ::std::vector<size_t> right_;
+
+  GTEST_DISALLOW_ASSIGN_(MaxBipartiteMatchState);
+};
+
+const size_t MaxBipartiteMatchState::kUnused;
+
+GTEST_API_ ElementMatcherPairs
+FindMaxBipartiteMatching(const MatchMatrix& g) {
+  return MaxBipartiteMatchState(g).Compute();
+}
+
+static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
+                                     ::std::ostream* stream) {
+  typedef ElementMatcherPairs::const_iterator Iter;
+  ::std::ostream& os = *stream;
+  os << "{";
+  const char *sep = "";
+  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
+    os << sep << "\n  ("
+       << "element #" << it->first << ", "
+       << "matcher #" << it->second << ")";
+    sep = ",";
+  }
+  os << "\n}";
+}
+
+// Tries to find a pairing, and explains the result.
+GTEST_API_ bool FindPairing(const MatchMatrix& matrix,
+                            MatchResultListener* listener) {
+  ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix);
+
+  size_t max_flow = matches.size();
+  bool result = (max_flow == matrix.RhsSize());
+
+  if (!result) {
+    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 (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 MatchMatrix::NextGraph() {
+  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
+    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
+      char& b = matched_[SpaceIndex(ilhs, irhs)];
+      if (!b) {
+        b = 1;
+        return true;
+      }
+      b = 0;
+    }
+  }
+  return false;
+}
+
+void MatchMatrix::Randomize() {
+  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
+    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
+      char& b = matched_[SpaceIndex(ilhs, irhs)];
+      b = static_cast<char>(rand() & 1);  // NOLINT
+    }
+  }
+}
+
+string MatchMatrix::DebugString() const {
+  ::std::stringstream ss;
+  const char *sep = "";
+  for (size_t i = 0; i < LhsSize(); ++i) {
+    ss << sep;
+    for (size_t j = 0; j < RhsSize(); ++j) {
+      ss << HasEdge(i, j);
+    }
+    sep = ";";
+  }
+  return ss.str();
+}
+
+void UnorderedElementsAreMatcherImplBase::DescribeToImpl(
+    ::std::ostream* os) const {
+  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";
+  const char* sep = "";
+  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
+    *os << sep << " - element #" << i << " ";
+    matcher_describers_[i]->DescribeTo(os);
+    sep = ", and\n";
+  }
+}
+
+void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(
+    ::std::ostream* os) const {
+  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";
+  const char* sep = "";
+  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
+    *os << sep << " - element #" << i << " ";
+    matcher_describers_[i]->DescribeTo(os);
+    sep = ", and\n";
+  }
+}
+
+// Checks that all matchers match at least one element, and that all
+// elements match at least one matcher. This enables faster matching
+// and better error reporting.
+// Returns false, writing an explanation to 'listener', if and only
+// if the success criteria are not met.
+bool UnorderedElementsAreMatcherImplBase::
+VerifyAllElementsAndMatchersAreMatched(
+    const ::std::vector<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);
+
+  for (size_t ilhs = 0; ilhs < matrix.LhsSize(); ilhs++) {
+    for (size_t irhs = 0; irhs < matrix.RhsSize(); irhs++) {
+      char matched = matrix.HasEdge(ilhs, irhs);
+      element_matched[ilhs] |= matched;
+      matcher_matched[irhs] |= matched;
+    }
+  }
+
+  {
+    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;
+      result = false;
+      if (listener->IsInterested()) {
+        *listener << sep << "matcher #" << mi << ": ";
+        matcher_describers_[mi]->DescribeTo(listener->stream());
+        sep = ",\n";
+      }
+    }
+  }
+
+  {
+    const char* sep =
+        "where the following elements don't match any matchers:\n";
+    const char* outer_sep = "";
+    if (!result) {
+      outer_sep = "\nand ";
+    }
+    for (size_t ei = 0; ei < element_matched.size(); ++ei) {
+      if (element_matched[ei])
+        continue;
+      result = false;
+      if (listener->IsInterested()) {
+        *listener << outer_sep << sep << "element #" << ei << ": "
+                  << element_printouts[ei];
+        sep = ",\n";
+        outer_sep = "";
+      }
+    }
+  }
+  return result;
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-spec-builders.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-spec-builders.cc
new file mode 100644
index 00000000..95513420
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-spec-builders.cc
@@ -0,0 +1,823 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements the spec builder syntax (ON_CALL and
+// EXPECT_CALL).
+
+#include "gmock/gmock-spec-builders.h"
+
+#include <stdlib.h>
+#include <iostream>  // NOLINT
+#include <map>
+#include <set>
+#include <string>
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
+# include <unistd.h>  // NOLINT
+#endif
+
+namespace testing {
+namespace internal {
+
+// Protects the mock object registry (in class Mock), all function
+// mockers, and all expectations.
+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 string& message) {
+  ::std::ostringstream s;
+  s << file << ":" << line << ": " << message << ::std::endl;
+  Log(severity, s.str(), 0);
+}
+
+// Constructs an ExpectationBase object.
+ExpectationBase::ExpectationBase(const char* a_file,
+                                 int a_line,
+                                 const string& a_source_text)
+    : file_(a_file),
+      line_(a_line),
+      source_text_(a_source_text),
+      cardinality_specified_(false),
+      cardinality_(Exactly(1)),
+      call_count_(0),
+      retired_(false),
+      extra_matcher_specified_(false),
+      repeated_action_specified_(false),
+      retires_on_saturation_(false),
+      last_clause_(kNone),
+      action_count_checked_(false) {}
+
+// Destructs an ExpectationBase object.
+ExpectationBase::~ExpectationBase() {}
+
+// Explicitly specifies the cardinality of this expectation.  Used by
+// the subclasses to implement the .Times() clause.
+void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) {
+  cardinality_specified_ = true;
+  cardinality_ = a_cardinality;
+}
+
+// Retires all pre-requisites of this expectation.
+void ExpectationBase::RetireAllPreRequisites()
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  if (is_retired()) {
+    // We can take this short-cut as we never retire an expectation
+    // until we have retired all its pre-requisites.
+    return;
+  }
+
+  for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
+       it != immediate_prerequisites_.end(); ++it) {
+    ExpectationBase* const prerequisite = it->expectation_base().get();
+    if (!prerequisite->is_retired()) {
+      prerequisite->RetireAllPreRequisites();
+      prerequisite->Retire();
+    }
+  }
+}
+
+// Returns true iff all pre-requisites of this expectation have been
+// satisfied.
+bool ExpectationBase::AllPrerequisitesAreSatisfied() const
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+  for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
+       it != immediate_prerequisites_.end(); ++it) {
+    if (!(it->expectation_base()->IsSatisfied()) ||
+        !(it->expectation_base()->AllPrerequisitesAreSatisfied()))
+      return false;
+  }
+  return true;
+}
+
+// Adds unsatisfied pre-requisites of this expectation to 'result'.
+void ExpectationBase::FindUnsatisfiedPrerequisites(ExpectationSet* result) const
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+  for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
+       it != immediate_prerequisites_.end(); ++it) {
+    if (it->expectation_base()->IsSatisfied()) {
+      // If *it is satisfied and has a call count of 0, some of its
+      // pre-requisites may not be satisfied yet.
+      if (it->expectation_base()->call_count_ == 0) {
+        it->expectation_base()->FindUnsatisfiedPrerequisites(result);
+      }
+    } else {
+      // Now that we know *it is unsatisfied, we are not so interested
+      // in whether its pre-requisites are satisfied.  Therefore we
+      // don't recursively call FindUnsatisfiedPrerequisites() here.
+      *result += *it;
+    }
+  }
+}
+
+// Describes how many times a function call matching this
+// expectation has occurred.
+void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+
+  // Describes how many times the function is expected to be called.
+  *os << "         Expected: to be ";
+  cardinality().DescribeTo(os);
+  *os << "\n           Actual: ";
+  Cardinality::DescribeActualCallCountTo(call_count(), os);
+
+  // Describes the state of the expectation (e.g. is it satisfied?
+  // is it active?).
+  *os << " - " << (IsOverSaturated() ? "over-saturated" :
+                   IsSaturated() ? "saturated" :
+                   IsSatisfied() ? "satisfied" : "unsatisfied")
+      << " and "
+      << (is_retired() ? "retired" : "active");
+}
+
+// Checks the action count (i.e. the number of WillOnce() and
+// WillRepeatedly() clauses) against the cardinality if this hasn't
+// been done before.  Prints a warning if there are too many or too
+// few actions.
+void ExpectationBase::CheckActionCountIfNotDone() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  bool should_check = false;
+  {
+    MutexLock l(&mutex_);
+    if (!action_count_checked_) {
+      action_count_checked_ = true;
+      should_check = true;
+    }
+  }
+
+  if (should_check) {
+    if (!cardinality_specified_) {
+      // The cardinality was inferred - no need to check the action
+      // count against it.
+      return;
+    }
+
+    // The cardinality was explicitly specified.
+    const int action_count = static_cast<int>(untyped_actions_.size());
+    const int upper_bound = cardinality().ConservativeUpperBound();
+    const int lower_bound = cardinality().ConservativeLowerBound();
+    bool too_many;  // True if there are too many actions, or false
+    // if there are too few.
+    if (action_count > upper_bound ||
+        (action_count == upper_bound && repeated_action_specified_)) {
+      too_many = true;
+    } else if (0 < action_count && action_count < lower_bound &&
+               !repeated_action_specified_) {
+      too_many = false;
+    } else {
+      return;
+    }
+
+    ::std::stringstream ss;
+    DescribeLocationTo(&ss);
+    ss << "Too " << (too_many ? "many" : "few")
+       << " actions specified in " << source_text() << "...\n"
+       << "Expected to be ";
+    cardinality().DescribeTo(&ss);
+    ss << ", but has " << (too_many ? "" : "only ")
+       << action_count << " WillOnce()"
+       << (action_count == 1 ? "" : "s");
+    if (repeated_action_specified_) {
+      ss << " and a WillRepeatedly()";
+    }
+    ss << ".";
+    Log(kWarning, ss.str(), -1);  // -1 means "don't print stack trace".
+  }
+}
+
+// Implements the .Times() clause.
+void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) {
+  if (last_clause_ == kTimes) {
+    ExpectSpecProperty(false,
+                       ".Times() cannot appear "
+                       "more than once in an EXPECT_CALL().");
+  } else {
+    ExpectSpecProperty(last_clause_ < kTimes,
+                       ".Times() cannot appear after "
+                       ".InSequence(), .WillOnce(), .WillRepeatedly(), "
+                       "or .RetiresOnSaturation().");
+  }
+  last_clause_ = kTimes;
+
+  SpecifyCardinality(a_cardinality);
+}
+
+// Points to the implicit sequence introduced by a living InSequence
+// object (if any) in the current thread or NULL.
+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 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;
+  switch (reaction) {
+    case kAllow:
+      Log(kInfo, msg, stack_frames_to_skip);
+      break;
+    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/googlemock/docs/CookBook.md#"
+          "knowing-when-to-expect for details.\n",
+          stack_frames_to_skip);
+      break;
+    default:  // FAIL
+      Expect(false, NULL, -1, msg);
+  }
+}
+
+UntypedFunctionMockerBase::UntypedFunctionMockerBase()
+    : mock_obj_(NULL), name_("") {}
+
+UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}
+
+// Sets the mock object this mock method belongs to, and registers
+// this information in the global mock registry.  Will be called
+// whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
+// method.
+void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  {
+    MutexLock l(&g_gmock_mutex);
+    mock_obj_ = mock_obj;
+  }
+  Mock::Register(mock_obj, this);
+}
+
+// Sets the mock object this mock method belongs to, and sets the name
+// of the mock function.  Will be called upon each invocation of this
+// mock function.
+void UntypedFunctionMockerBase::SetOwnerAndName(const void* mock_obj,
+                                                const char* name)
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  // We protect name_ under g_gmock_mutex in case this mock function
+  // is called from two threads concurrently.
+  MutexLock l(&g_gmock_mutex);
+  mock_obj_ = mock_obj;
+  name_ = name;
+}
+
+// Returns the name of the function being mocked.  Must be called
+// after RegisterOwner() or SetOwnerAndName() has been called.
+const void* UntypedFunctionMockerBase::MockObject() const
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  const void* mock_obj;
+  {
+    // 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_ != NULL, __FILE__, __LINE__,
+           "MockObject() must not be called before RegisterOwner() or "
+           "SetOwnerAndName() has been called.");
+    mock_obj = mock_obj_;
+  }
+  return mock_obj;
+}
+
+// Returns the name of this mock method.  Must be called after
+// SetOwnerAndName() has been called.
+const char* UntypedFunctionMockerBase::Name() const
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  const char* name;
+  {
+    // 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_ != NULL, __FILE__, __LINE__,
+           "Name() must not be called before SetOwnerAndName() has "
+           "been called.");
+    name = name_;
+  }
+  return name;
+}
+
+// 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(const void* const untyped_args)
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  if (untyped_expectations_.size() == 0) {
+    // No expectation is set on this mock method - we have an
+    // uninteresting call.
+
+    // We must get Google Mock's reaction on uninteresting calls
+    // made on this mock object BEFORE performing the action,
+    // because the action may DELETE the mock object and make the
+    // following expression meaningless.
+    const CallReaction reaction =
+        Mock::GetReactionOnUninterestingCalls(MockObject());
+
+    // True iff 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 he wants informational messages.
+        reaction == kAllow ? LogIsVisible(kInfo) :
+        // If the user wants this to be a warning, we print it only
+        // when he wants 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, "");
+    }
+
+    // Warns about the uninteresting call.
+    ::std::stringstream ss;
+    this->UntypedDescribeUninterestingCall(untyped_args, &ss);
+
+    // Calculates the function result.
+    UntypedActionResultHolderBase* const result =
+        this->UntypedPerformDefaultAction(untyped_args, ss.str());
+
+    // Prints the function result.
+    if (result != NULL)
+      result->PrintAsActionResult(&ss);
+
+    ReportUninterestingCall(reaction, ss.str());
+    return result;
+  }
+
+  bool is_excessive = false;
+  ::std::stringstream ss;
+  ::std::stringstream why;
+  ::std::stringstream loc;
+  const void* untyped_action = NULL;
+
+  // 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 != NULL;
+
+  // True iff 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 == NULL ?
+        this->UntypedPerformDefaultAction(untyped_args, "") :
+        this->UntypedPerformAction(untyped_action, untyped_args);
+  }
+
+  ss << "    Function call: " << Name();
+  this->UntypedPrintArgs(untyped_args, &ss);
+
+  // In case the action deletes a piece of the expectation, we
+  // generate the message beforehand.
+  if (found && !is_excessive) {
+    untyped_expectation->DescribeLocationTo(&loc);
+  }
+
+  UntypedActionResultHolderBase* const result =
+      untyped_action == NULL ?
+      this->UntypedPerformDefaultAction(untyped_args, ss.str()) :
+      this->UntypedPerformAction(untyped_action, untyped_args);
+  if (result != NULL)
+    result->PrintAsActionResult(&ss);
+  ss << "\n" << why.str();
+
+  if (!found) {
+    // No expectation matches this call - reports a failure.
+    Expect(false, NULL, -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);
+  }
+
+  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) {
+  for (UntypedExpectations::const_iterator it =
+           untyped_expectations_.begin();
+       it != untyped_expectations_.end(); ++it) {
+    if (it->get() == exp) {
+      return Expectation(*it);
+    }
+  }
+
+  Assert(false, __FILE__, __LINE__, "Cannot find expectation.");
+  return Expectation();
+  // The above statement is just to make the code compile, and will
+  // never be executed.
+}
+
+// Verifies that all expectations on this mock function have been
+// satisfied.  Reports one or more Google Test non-fatal failures
+// and returns false if not.
+bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+  bool expectations_met = true;
+  for (UntypedExpectations::const_iterator it =
+           untyped_expectations_.begin();
+       it != untyped_expectations_.end(); ++it) {
+    ExpectationBase* const untyped_expectation = it->get();
+    if (untyped_expectation->IsOverSaturated()) {
+      // There was an upper-bound violation.  Since the error was
+      // already reported when it occurred, there is no need to do
+      // anything here.
+      expectations_met = false;
+    } else if (!untyped_expectation->IsSatisfied()) {
+      expectations_met = false;
+      ::std::stringstream ss;
+      ss  << "Actual function call count doesn't match "
+          << untyped_expectation->source_text() << "...\n";
+      // No need to show the source file location of the expectation
+      // in the description, as the Expect() call that follows already
+      // takes care of it.
+      untyped_expectation->MaybeDescribeExtraMatcherTo(&ss);
+      untyped_expectation->DescribeCallCountTo(&ss);
+      Expect(false, untyped_expectation->file(),
+             untyped_expectation->line(), ss.str());
+    }
+  }
+
+  // Deleting our expectations may trigger other mock objects to be deleted, for
+  // example if an action contains a reference counted smart pointer to that
+  // mock object, and that is the last reference. So if we delete our
+  // expectations within the context of the global mutex we may deadlock when
+  // this method is called again. Instead, make a copy of the set of
+  // expectations to delete, clear our set within the mutex, and then clear the
+  // copied set outside of it.
+  UntypedExpectations expectations_to_delete;
+  untyped_expectations_.swap(expectations_to_delete);
+
+  g_gmock_mutex.Unlock();
+  expectations_to_delete.clear();
+  g_gmock_mutex.Lock();
+
+  return expectations_met;
+}
+
+}  // namespace internal
+
+// Class Mock.
+
+namespace {
+
+typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers;
+
+// The current state of a mock object.  Such information is needed for
+// detecting leaked mock objects and explicitly verifying a mock's
+// expectations.
+struct MockObjectState {
+  MockObjectState()
+      : first_used_file(NULL), 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_case;
+  ::std::string first_used_test;
+  bool leakable;  // true iff it's OK to leak the object.
+  FunctionMockers function_mockers;  // All registered methods of the object.
+};
+
+// A global registry holding the state of all mock objects that are
+// alive.  A mock object is added to this registry the first time
+// Mock::AllowLeak(), ON_CALL(), or EXPECT_CALL() is called on it.  It
+// is removed from the registry in the mock object's destructor.
+class MockObjectRegistry {
+ public:
+  // Maps a mock object (identified by its address) to its state.
+  typedef std::map<const void*, MockObjectState> StateMap;
+
+  // This destructor will be called when a program exits, after all
+  // tests in it have been run.  By then, there should be no mock
+  // object alive.  Therefore we report any living object as test
+  // failure, unless the user explicitly asked us to ignore it.
+  ~MockObjectRegistry() {
+    // "using ::std::cout;" doesn't work with Symbian's STLport, where cout is
+    // a macro.
+
+    if (!GMOCK_FLAG(catch_leaked_mocks))
+      return;
+
+    int leaked_count = 0;
+    for (StateMap::const_iterator it = states_.begin(); it != states_.end();
+         ++it) {
+      if (it->second.leakable)  // The user said it's fine to leak this object.
+        continue;
+
+      // TODO(wan@google.com): Print the type of the leaked object.
+      // This can help the user identify the leaked object.
+      std::cout << "\n";
+      const MockObjectState& state = it->second;
+      std::cout << internal::FormatFileLocation(state.first_used_file,
+                                                state.first_used_line);
+      std::cout << " ERROR: this mock object";
+      if (state.first_used_test != "") {
+        std::cout << " (used in test " << state.first_used_test_case << "."
+             << 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.\n";
+      std::cout.flush();
+      ::std::cerr.flush();
+      // RUN_ALL_TESTS() has already returned when this destructor is
+      // called.  Therefore we cannot use the normal Google Test
+      // failure reporting mechanism.
+      _exit(1);  // We cannot call exit() as it is not reentrant and
+                 // may already have been called.
+    }
+  }
+
+  StateMap& states() { return states_; }
+
+ private:
+  StateMap states_;
+};
+
+// Protected by g_gmock_mutex.
+MockObjectRegistry g_mock_object_registry;
+
+// Maps a mock object to the reaction Google Mock should have when an
+// uninteresting method is called.  Protected by g_gmock_mutex.
+std::map<const void*, internal::CallReaction> g_uninteresting_call_reaction;
+
+// Sets the reaction Google Mock should have when an uninteresting
+// method of the given mock object is called.
+void SetReactionOnUninterestingCalls(const void* mock_obj,
+                                     internal::CallReaction reaction)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_uninteresting_call_reaction[mock_obj] = reaction;
+}
+
+}  // namespace
+
+// Tells Google Mock to allow uninteresting calls on the given mock
+// object.
+void Mock::AllowUninterestingCalls(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  SetReactionOnUninterestingCalls(mock_obj, internal::kAllow);
+}
+
+// Tells Google Mock to warn the user about uninteresting calls on the
+// given mock object.
+void Mock::WarnUninterestingCalls(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  SetReactionOnUninterestingCalls(mock_obj, internal::kWarn);
+}
+
+// Tells Google Mock to fail uninteresting calls on the given mock
+// object.
+void Mock::FailUninterestingCalls(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  SetReactionOnUninterestingCalls(mock_obj, internal::kFail);
+}
+
+// Tells Google Mock the given mock object is being destroyed and its
+// entry in the call-reaction table should be removed.
+void Mock::UnregisterCallReaction(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_uninteresting_call_reaction.erase(mock_obj);
+}
+
+// Returns the reaction Google Mock will have on uninteresting calls
+// made on the given mock object.
+internal::CallReaction Mock::GetReactionOnUninterestingCalls(
+    const void* mock_obj)
+        GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  return (g_uninteresting_call_reaction.count(mock_obj) == 0) ?
+      internal::kDefault : g_uninteresting_call_reaction[mock_obj];
+}
+
+// Tells Google Mock to ignore mock_obj when checking for leaked mock
+// objects.
+void Mock::AllowLeak(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_mock_object_registry.states()[mock_obj].leakable = true;
+}
+
+// Verifies and clears all expectations on the given mock object.  If
+// the expectations aren't satisfied, generates one or more Google
+// Test non-fatal failures and returns false.
+bool Mock::VerifyAndClearExpectations(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  return VerifyAndClearExpectationsLocked(mock_obj);
+}
+
+// Verifies all expectations on the given mock object and clears its
+// default actions and expectations.  Returns true iff the
+// verification was successful.
+bool Mock::VerifyAndClear(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  ClearDefaultActionsLocked(mock_obj);
+  return VerifyAndClearExpectationsLocked(mock_obj);
+}
+
+// Verifies and clears all expectations on the given mock object.  If
+// the expectations aren't satisfied, generates one or more Google
+// Test non-fatal failures and returns false.
+bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj)
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
+  internal::g_gmock_mutex.AssertHeld();
+  if (g_mock_object_registry.states().count(mock_obj) == 0) {
+    // No EXPECT_CALL() was set on the given mock object.
+    return true;
+  }
+
+  // Verifies and clears the expectations on each mock method in the
+  // given mock object.
+  bool expectations_met = true;
+  FunctionMockers& mockers =
+      g_mock_object_registry.states()[mock_obj].function_mockers;
+  for (FunctionMockers::const_iterator it = mockers.begin();
+       it != mockers.end(); ++it) {
+    if (!(*it)->VerifyAndClearExpectationsLocked()) {
+      expectations_met = false;
+    }
+  }
+
+  // We don't clear the content of mockers, as they may still be
+  // needed by ClearDefaultActionsLocked().
+  return expectations_met;
+}
+
+// Registers a mock object and a mock method it owns.
+void Mock::Register(const void* mock_obj,
+                    internal::UntypedFunctionMockerBase* mocker)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker);
+}
+
+// Tells Google Mock where in the source code mock_obj is used in an
+// ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
+// information helps the user identify which object it is.
+void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj,
+                                           const char* file, int line)
+    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 == NULL) {
+    state.first_used_file = file;
+    state.first_used_line = line;
+    const TestInfo* const test_info =
+        UnitTest::GetInstance()->current_test_info();
+    if (test_info != NULL) {
+      // TODO(wan@google.com): record the test case name when the
+      // ON_CALL or EXPECT_CALL is invoked from SetUpTestCase() or
+      // TearDownTestCase().
+      state.first_used_test_case = test_info->test_case_name();
+      state.first_used_test = test_info->name();
+    }
+  }
+}
+
+// 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
+// FunctionMockerBase.
+void Mock::UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
+  internal::g_gmock_mutex.AssertHeld();
+  for (MockObjectRegistry::StateMap::iterator it =
+           g_mock_object_registry.states().begin();
+       it != g_mock_object_registry.states().end(); ++it) {
+    FunctionMockers& mockers = it->second.function_mockers;
+    if (mockers.erase(mocker) > 0) {
+      // mocker was in mockers and has been just removed.
+      if (mockers.empty()) {
+        g_mock_object_registry.states().erase(it);
+      }
+      return;
+    }
+  }
+}
+
+// Clears all ON_CALL()s set on the given mock object.
+void Mock::ClearDefaultActionsLocked(void* mock_obj)
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
+  internal::g_gmock_mutex.AssertHeld();
+
+  if (g_mock_object_registry.states().count(mock_obj) == 0) {
+    // No ON_CALL() was set on the given mock object.
+    return;
+  }
+
+  // Clears the default actions for each mock method in the given mock
+  // object.
+  FunctionMockers& mockers =
+      g_mock_object_registry.states()[mock_obj].function_mockers;
+  for (FunctionMockers::const_iterator it = mockers.begin();
+       it != mockers.end(); ++it) {
+    (*it)->ClearDefaultActionsLocked();
+  }
+
+  // We don't clear the content of mockers, as they may still be
+  // needed by VerifyAndClearExpectationsLocked().
+}
+
+Expectation::Expectation() {}
+
+Expectation::Expectation(
+    const internal::linked_ptr<internal::ExpectationBase>& an_expectation_base)
+    : expectation_base_(an_expectation_base) {}
+
+Expectation::~Expectation() {}
+
+// Adds an expectation to a sequence.
+void Sequence::AddExpectation(const Expectation& expectation) const {
+  if (*last_expectation_ != expectation) {
+    if (last_expectation_->expectation_base() != NULL) {
+      expectation.expectation_base()->immediate_prerequisites_
+          += *last_expectation_;
+    }
+    *last_expectation_ = expectation;
+  }
+}
+
+// Creates the implicit sequence if there isn't one.
+InSequence::InSequence() {
+  if (internal::g_gmock_implicit_sequence.get() == NULL) {
+    internal::g_gmock_implicit_sequence.set(new Sequence);
+    sequence_created_ = true;
+  } else {
+    sequence_created_ = false;
+  }
+}
+
+// Deletes the implicit sequence if it was created by the constructor
+// of this object.
+InSequence::~InSequence() {
+  if (sequence_created_) {
+    delete internal::g_gmock_implicit_sequence.get();
+    internal::g_gmock_implicit_sequence.set(NULL);
+  }
+}
+
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock.cc
new file mode 100644
index 00000000..eac3d842
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock.cc
@@ -0,0 +1,183 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "gmock/gmock.h"
+#include "gmock/internal/gmock-port.h"
+
+namespace testing {
+
+// TODO(wan@google.com): support using environment variables to
+// control the flag values, like what Google Test does.
+
+GMOCK_DEFINE_bool_(catch_leaked_mocks, true,
+                   "true iff Google Mock should report leaked mock objects "
+                   "as failures.");
+
+GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
+                     "Controls how verbose Google Mock's output is."
+                     "  Valid values:\n"
+                     "  info    - prints all messages.\n"
+                     "  warning - prints warnings and errors.\n"
+                     "  error   - prints errors only.");
+
+namespace internal {
+
+// Parses a string as a command line flag.  The string should have the
+// format "--gmock_flag=value".  When def_optional is true, the
+// "=value" part can be omitted.
+//
+// Returns the value of the flag, or NULL if the parsing failed.
+static const char* ParseGoogleMockFlagValue(const char* str,
+                                            const char* flag,
+                                            bool def_optional) {
+  // str and flag must not be NULL.
+  if (str == NULL || flag == NULL) return NULL;
+
+  // 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 NULL;
+
+  // Skips the flag name.
+  const char* flag_end = str + flag_len;
+
+  // When def_optional is true, it's OK to not have a "=value" part.
+  if (def_optional && (flag_end[0] == '\0')) {
+    return flag_end;
+  }
+
+  // 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 NULL;
+
+  // Returns the string after "=".
+  return flag_end + 1;
+}
+
+// Parses a string for a Google Mock bool flag, in the form of
+// "--gmock_flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
+                                    bool* 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 == NULL) 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 a Google Mock string flag, in the form of
+// "--gmock_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 ParseGoogleMockStringFlag(const char* str, const char* flag,
+                                      String* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);
+
+  // Aborts if the parsing failed.
+  if (value_str == NULL) return false;
+
+  // Sets *value to the value of the flag.
+  *value = value_str;
+  return true;
+}
+
+// The internal implementation of InitGoogleMock().
+//
+// The type parameter CharType can be instantiated to either char or
+// wchar_t.
+template <typename CharType>
+void InitGoogleMockImpl(int* argc, CharType** argv) {
+  // Makes sure Google Test is initialized.  InitGoogleTest() is
+  // idempotent, so it's fine if the user has already called it.
+  InitGoogleTest(argc, argv);
+  if (*argc <= 0) return;
+
+  for (int i = 1; i != *argc; i++) {
+    const std::string arg_string = StreamableToString(argv[i]);
+    const char* const arg = arg_string.c_str();
+
+    // Do we see a Google Mock flag?
+    if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
+                                &GMOCK_FLAG(catch_leaked_mocks)) ||
+        ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose))) {
+      // 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
+      // well.
+      for (int j = i; j != *argc; j++) {
+        argv[j] = argv[j + 1];
+      }
+
+      // Decrements the argument count.
+      (*argc)--;
+
+      // We also need to decrement the iterator as we just removed
+      // an element.
+      i--;
+    }
+  }
+}
+
+}  // namespace internal
+
+// Initializes Google Mock.  This must be called before running the
+// tests.  In particular, it parses a command line for the flags that
+// Google Mock recognizes.  Whenever a Google Mock flag is seen, it is
+// removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Mock flag variables are
+// updated.
+//
+// Since Google Test is needed for Google Mock to work, this function
+// also initializes Google Test and parses its flags, if that hasn't
+// been done.
+GTEST_API_ void InitGoogleMock(int* argc, char** argv) {
+  internal::InitGoogleMockImpl(argc, argv);
+}
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv) {
+  internal::InitGoogleMockImpl(argc, argv);
+}
+
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock_main.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock_main.cc
new file mode 100644
index 00000000..bd5be03b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock_main.cc
@@ -0,0 +1,54 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include <iostream>
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+// 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:
+// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=394464  // NOLINT
+#if GTEST_OS_WINDOWS_MOBILE
+# include <tchar.h>  // NOLINT
+
+GTEST_API_ int _tmain(int argc, TCHAR** argv) {
+#else
+GTEST_API_ int main(int argc, char** argv) {
+#endif  // GTEST_OS_WINDOWS_MOBILE
+  std::cout << "Running main() from gmock_main.cc\n";
+  // 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(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-actions_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-actions_test.cc
new file mode 100644
index 00000000..f470de4c
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-actions_test.cc
@@ -0,0 +1,1411 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests the built-in actions.
+
+#include "gmock/gmock-actions.h"
+#include <algorithm>
+#include <iterator>
+#include <memory>
+#include <string>
+#include "gmock/gmock.h"
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+#include "gtest/gtest-spi.h"
+
+namespace {
+
+// This list should be kept sorted.
+using testing::Action;
+using testing::ActionInterface;
+using testing::Assign;
+using testing::ByMove;
+using testing::ByRef;
+using testing::DefaultValue;
+using testing::DoDefault;
+using testing::IgnoreResult;
+using testing::Invoke;
+using testing::InvokeWithoutArgs;
+using testing::MakePolymorphicAction;
+using testing::Ne;
+using testing::PolymorphicAction;
+using testing::Return;
+using testing::ReturnNull;
+using testing::ReturnRef;
+using testing::ReturnRefOfCopy;
+using testing::SetArgPointee;
+using testing::SetArgumentPointee;
+using testing::_;
+using testing::get;
+using testing::internal::BuiltInDefaultValue;
+using testing::internal::Int64;
+using testing::internal::UInt64;
+using testing::make_tuple;
+using testing::tuple;
+using testing::tuple_element;
+
+#if !GTEST_OS_WINDOWS_MOBILE
+using testing::SetErrnoAndReturn;
+#endif
+
+#if GTEST_HAS_PROTOBUF_
+using testing::internal::TestMessage;
+#endif  // GTEST_HAS_PROTOBUF_
+
+// Tests that BuiltInDefaultValue<T*>::Get() returns NULL.
+TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {
+  EXPECT_TRUE(BuiltInDefaultValue<int*>::Get() == NULL);
+  EXPECT_TRUE(BuiltInDefaultValue<const char*>::Get() == NULL);
+  EXPECT_TRUE(BuiltInDefaultValue<void*>::Get() == NULL);
+}
+
+// Tests that BuiltInDefaultValue<T*>::Exists() return true.
+TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) {
+  EXPECT_TRUE(BuiltInDefaultValue<int*>::Exists());
+  EXPECT_TRUE(BuiltInDefaultValue<const char*>::Exists());
+  EXPECT_TRUE(BuiltInDefaultValue<void*>::Exists());
+}
+
+// Tests that BuiltInDefaultValue<T>::Get() returns 0 when T is a
+// built-in numeric type.
+TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) {
+  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned char>::Get());
+  EXPECT_EQ(0, BuiltInDefaultValue<signed char>::Get());
+  EXPECT_EQ(0, BuiltInDefaultValue<char>::Get());
+#if GMOCK_HAS_SIGNED_WCHAR_T_
+  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned wchar_t>::Get());
+  EXPECT_EQ(0, BuiltInDefaultValue<signed wchar_t>::Get());
+#endif
+#if GMOCK_WCHAR_T_IS_NATIVE_
+  EXPECT_EQ(0, BuiltInDefaultValue<wchar_t>::Get());
+#endif
+  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned short>::Get());  // NOLINT
+  EXPECT_EQ(0, BuiltInDefaultValue<signed short>::Get());  // NOLINT
+  EXPECT_EQ(0, BuiltInDefaultValue<short>::Get());  // NOLINT
+  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned int>::Get());
+  EXPECT_EQ(0, BuiltInDefaultValue<signed int>::Get());
+  EXPECT_EQ(0, BuiltInDefaultValue<int>::Get());
+  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long>::Get());  // NOLINT
+  EXPECT_EQ(0, BuiltInDefaultValue<signed long>::Get());  // NOLINT
+  EXPECT_EQ(0, BuiltInDefaultValue<long>::Get());  // NOLINT
+  EXPECT_EQ(0U, BuiltInDefaultValue<UInt64>::Get());
+  EXPECT_EQ(0, BuiltInDefaultValue<Int64>::Get());
+  EXPECT_EQ(0, BuiltInDefaultValue<float>::Get());
+  EXPECT_EQ(0, BuiltInDefaultValue<double>::Get());
+}
+
+// Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
+// built-in numeric type.
+TEST(BuiltInDefaultValueTest, ExistsForNumericTypes) {
+  EXPECT_TRUE(BuiltInDefaultValue<unsigned char>::Exists());
+  EXPECT_TRUE(BuiltInDefaultValue<signed char>::Exists());
+  EXPECT_TRUE(BuiltInDefaultValue<char>::Exists());
+#if GMOCK_HAS_SIGNED_WCHAR_T_
+  EXPECT_TRUE(BuiltInDefaultValue<unsigned wchar_t>::Exists());
+  EXPECT_TRUE(BuiltInDefaultValue<signed wchar_t>::Exists());
+#endif
+#if GMOCK_WCHAR_T_IS_NATIVE_
+  EXPECT_TRUE(BuiltInDefaultValue<wchar_t>::Exists());
+#endif
+  EXPECT_TRUE(BuiltInDefaultValue<unsigned short>::Exists());  // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<signed short>::Exists());  // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<short>::Exists());  // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<unsigned int>::Exists());
+  EXPECT_TRUE(BuiltInDefaultValue<signed int>::Exists());
+  EXPECT_TRUE(BuiltInDefaultValue<int>::Exists());
+  EXPECT_TRUE(BuiltInDefaultValue<unsigned long>::Exists());  // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<signed long>::Exists());  // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<long>::Exists());  // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<UInt64>::Exists());
+  EXPECT_TRUE(BuiltInDefaultValue<Int64>::Exists());
+  EXPECT_TRUE(BuiltInDefaultValue<float>::Exists());
+  EXPECT_TRUE(BuiltInDefaultValue<double>::Exists());
+}
+
+// Tests that BuiltInDefaultValue<bool>::Get() returns false.
+TEST(BuiltInDefaultValueTest, IsFalseForBool) {
+  EXPECT_FALSE(BuiltInDefaultValue<bool>::Get());
+}
+
+// Tests that BuiltInDefaultValue<bool>::Exists() returns true.
+TEST(BuiltInDefaultValueTest, BoolExists) {
+  EXPECT_TRUE(BuiltInDefaultValue<bool>::Exists());
+}
+
+// Tests that BuiltInDefaultValue<T>::Get() returns "" when T is a
+// string type.
+TEST(BuiltInDefaultValueTest, IsEmptyStringForString) {
+#if GTEST_HAS_GLOBAL_STRING
+  EXPECT_EQ("", BuiltInDefaultValue< ::string>::Get());
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+  EXPECT_EQ("", BuiltInDefaultValue< ::std::string>::Get());
+}
+
+// Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
+// string type.
+TEST(BuiltInDefaultValueTest, ExistsForString) {
+#if GTEST_HAS_GLOBAL_STRING
+  EXPECT_TRUE(BuiltInDefaultValue< ::string>::Exists());
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+  EXPECT_TRUE(BuiltInDefaultValue< ::std::string>::Exists());
+}
+
+// Tests that BuiltInDefaultValue<const T>::Get() returns the same
+// value as BuiltInDefaultValue<T>::Get() does.
+TEST(BuiltInDefaultValueTest, WorksForConstTypes) {
+  EXPECT_EQ("", BuiltInDefaultValue<const std::string>::Get());
+  EXPECT_EQ(0, BuiltInDefaultValue<const int>::Get());
+  EXPECT_TRUE(BuiltInDefaultValue<char* const>::Get() == NULL);
+  EXPECT_FALSE(BuiltInDefaultValue<const bool>::Get());
+}
+
+// A type that's default constructible.
+class MyDefaultConstructible {
+ public:
+  MyDefaultConstructible() : value_(42) {}
+
+  int value() const { return value_; }
+
+ private:
+  int value_;
+};
+
+// A type that's not default constructible.
+class MyNonDefaultConstructible {
+ public:
+  // Does not have a default ctor.
+  explicit MyNonDefaultConstructible(int a_value) : value_(a_value) {}
+
+  int value() const { return value_; }
+
+ private:
+  int value_;
+};
+
+#if GTEST_HAS_STD_TYPE_TRAITS_
+
+TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {
+  EXPECT_TRUE(BuiltInDefaultValue<MyDefaultConstructible>::Exists());
+}
+
+TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructibleType) {
+  EXPECT_EQ(42, BuiltInDefaultValue<MyDefaultConstructible>::Get().value());
+}
+
+#endif  // GTEST_HAS_STD_TYPE_TRAITS_
+
+TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleType) {
+  EXPECT_FALSE(BuiltInDefaultValue<MyNonDefaultConstructible>::Exists());
+}
+
+// Tests that BuiltInDefaultValue<T&>::Get() aborts the program.
+TEST(BuiltInDefaultValueDeathTest, IsUndefinedForReferences) {
+  EXPECT_DEATH_IF_SUPPORTED({
+    BuiltInDefaultValue<int&>::Get();
+  }, "");
+  EXPECT_DEATH_IF_SUPPORTED({
+    BuiltInDefaultValue<const char&>::Get();
+  }, "");
+}
+
+TEST(BuiltInDefaultValueDeathTest, IsUndefinedForNonDefaultConstructibleType) {
+  EXPECT_DEATH_IF_SUPPORTED({
+    BuiltInDefaultValue<MyNonDefaultConstructible>::Get();
+  }, "");
+}
+
+// Tests that DefaultValue<T>::IsSet() is false initially.
+TEST(DefaultValueTest, IsInitiallyUnset) {
+  EXPECT_FALSE(DefaultValue<int>::IsSet());
+  EXPECT_FALSE(DefaultValue<MyDefaultConstructible>::IsSet());
+  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
+}
+
+// Tests that DefaultValue<T> can be set and then unset.
+TEST(DefaultValueTest, CanBeSetAndUnset) {
+  EXPECT_TRUE(DefaultValue<int>::Exists());
+  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
+
+  DefaultValue<int>::Set(1);
+  DefaultValue<const MyNonDefaultConstructible>::Set(
+      MyNonDefaultConstructible(42));
+
+  EXPECT_EQ(1, DefaultValue<int>::Get());
+  EXPECT_EQ(42, DefaultValue<const MyNonDefaultConstructible>::Get().value());
+
+  EXPECT_TRUE(DefaultValue<int>::Exists());
+  EXPECT_TRUE(DefaultValue<const MyNonDefaultConstructible>::Exists());
+
+  DefaultValue<int>::Clear();
+  DefaultValue<const MyNonDefaultConstructible>::Clear();
+
+  EXPECT_FALSE(DefaultValue<int>::IsSet());
+  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
+
+  EXPECT_TRUE(DefaultValue<int>::Exists());
+  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
+}
+
+// Tests that DefaultValue<T>::Get() returns the
+// BuiltInDefaultValue<T>::Get() when DefaultValue<T>::IsSet() is
+// false.
+TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
+  EXPECT_FALSE(DefaultValue<int>::IsSet());
+  EXPECT_TRUE(DefaultValue<int>::Exists());
+  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::IsSet());
+  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::Exists());
+
+  EXPECT_EQ(0, DefaultValue<int>::Get());
+
+  EXPECT_DEATH_IF_SUPPORTED({
+    DefaultValue<MyNonDefaultConstructible>::Get();
+  }, "");
+}
+
+#if GTEST_HAS_STD_UNIQUE_PTR_
+TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
+  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
+  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == NULL);
+  DefaultValue<std::unique_ptr<int>>::SetFactory([] {
+    return std::unique_ptr<int>(new int(42));
+  });
+  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
+  std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();
+  EXPECT_EQ(42, *i);
+}
+#endif  // GTEST_HAS_STD_UNIQUE_PTR_
+
+// Tests that DefaultValue<void>::Get() returns void.
+TEST(DefaultValueTest, GetWorksForVoid) {
+  return DefaultValue<void>::Get();
+}
+
+// Tests using DefaultValue with a reference type.
+
+// Tests that DefaultValue<T&>::IsSet() is false initially.
+TEST(DefaultValueOfReferenceTest, IsInitiallyUnset) {
+  EXPECT_FALSE(DefaultValue<int&>::IsSet());
+  EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::IsSet());
+  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
+}
+
+// Tests that DefaultValue<T&>::Exists is false initiallly.
+TEST(DefaultValueOfReferenceTest, IsInitiallyNotExisting) {
+  EXPECT_FALSE(DefaultValue<int&>::Exists());
+  EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::Exists());
+  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
+}
+
+// Tests that DefaultValue<T&> can be set and then unset.
+TEST(DefaultValueOfReferenceTest, CanBeSetAndUnset) {
+  int n = 1;
+  DefaultValue<const int&>::Set(n);
+  MyNonDefaultConstructible x(42);
+  DefaultValue<MyNonDefaultConstructible&>::Set(x);
+
+  EXPECT_TRUE(DefaultValue<const int&>::Exists());
+  EXPECT_TRUE(DefaultValue<MyNonDefaultConstructible&>::Exists());
+
+  EXPECT_EQ(&n, &(DefaultValue<const int&>::Get()));
+  EXPECT_EQ(&x, &(DefaultValue<MyNonDefaultConstructible&>::Get()));
+
+  DefaultValue<const int&>::Clear();
+  DefaultValue<MyNonDefaultConstructible&>::Clear();
+
+  EXPECT_FALSE(DefaultValue<const int&>::Exists());
+  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
+
+  EXPECT_FALSE(DefaultValue<const int&>::IsSet());
+  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
+}
+
+// Tests that DefaultValue<T&>::Get() returns the
+// BuiltInDefaultValue<T&>::Get() when DefaultValue<T&>::IsSet() is
+// false.
+TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
+  EXPECT_FALSE(DefaultValue<int&>::IsSet());
+  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
+
+  EXPECT_DEATH_IF_SUPPORTED({
+    DefaultValue<int&>::Get();
+  }, "");
+  EXPECT_DEATH_IF_SUPPORTED({
+    DefaultValue<MyNonDefaultConstructible>::Get();
+  }, "");
+}
+
+// Tests that ActionInterface can be implemented by defining the
+// Perform method.
+
+typedef int MyGlobalFunction(bool, int);
+
+class MyActionImpl : public ActionInterface<MyGlobalFunction> {
+ public:
+  virtual int Perform(const tuple<bool, int>& args) {
+    return get<0>(args) ? get<1>(args) : 0;
+  }
+};
+
+TEST(ActionInterfaceTest, CanBeImplementedByDefiningPerform) {
+  MyActionImpl my_action_impl;
+  (void)my_action_impl;
+}
+
+TEST(ActionInterfaceTest, MakeAction) {
+  Action<MyGlobalFunction> action = MakeAction(new MyActionImpl);
+
+  // When exercising the Perform() method of Action<F>, we must pass
+  // it a tuple whose size and type are compatible with F's argument
+  // types.  For example, if F is int(), then Perform() takes a
+  // 0-tuple; if F is void(bool, int), then Perform() takes a
+  // tuple<bool, int>, and so on.
+  EXPECT_EQ(5, action.Perform(make_tuple(true, 5)));
+}
+
+// Tests that Action<F> can be contructed from a pointer to
+// ActionInterface<F>.
+TEST(ActionTest, CanBeConstructedFromActionInterface) {
+  Action<MyGlobalFunction> action(new MyActionImpl);
+}
+
+// Tests that Action<F> delegates actual work to ActionInterface<F>.
+TEST(ActionTest, DelegatesWorkToActionInterface) {
+  const Action<MyGlobalFunction> action(new MyActionImpl);
+
+  EXPECT_EQ(5, action.Perform(make_tuple(true, 5)));
+  EXPECT_EQ(0, action.Perform(make_tuple(false, 1)));
+}
+
+// Tests that Action<F> can be copied.
+TEST(ActionTest, IsCopyable) {
+  Action<MyGlobalFunction> a1(new MyActionImpl);
+  Action<MyGlobalFunction> a2(a1);  // Tests the copy constructor.
+
+  // a1 should continue to work after being copied from.
+  EXPECT_EQ(5, a1.Perform(make_tuple(true, 5)));
+  EXPECT_EQ(0, a1.Perform(make_tuple(false, 1)));
+
+  // a2 should work like the action it was copied from.
+  EXPECT_EQ(5, a2.Perform(make_tuple(true, 5)));
+  EXPECT_EQ(0, a2.Perform(make_tuple(false, 1)));
+
+  a2 = a1;  // Tests the assignment operator.
+
+  // a1 should continue to work after being copied from.
+  EXPECT_EQ(5, a1.Perform(make_tuple(true, 5)));
+  EXPECT_EQ(0, a1.Perform(make_tuple(false, 1)));
+
+  // a2 should work like the action it was copied from.
+  EXPECT_EQ(5, a2.Perform(make_tuple(true, 5)));
+  EXPECT_EQ(0, a2.Perform(make_tuple(false, 1)));
+}
+
+// Tests that an Action<From> object can be converted to a
+// compatible Action<To> object.
+
+class IsNotZero : public ActionInterface<bool(int)> {  // NOLINT
+ public:
+  virtual bool Perform(const tuple<int>& arg) {
+    return get<0>(arg) != 0;
+  }
+};
+
+#if !GTEST_OS_SYMBIAN
+// Compiling this test on Nokia's Symbian compiler fails with:
+//  'Result' is not a member of class 'testing::internal::Function<int>'
+//  (point of instantiation: '@unnamed@gmock_actions_test_cc@::
+//      ActionTest_CanBeConvertedToOtherActionType_Test::TestBody()')
+// with no obvious fix.
+TEST(ActionTest, CanBeConvertedToOtherActionType) {
+  const Action<bool(int)> a1(new IsNotZero);  // NOLINT
+  const Action<int(char)> a2 = Action<int(char)>(a1);  // NOLINT
+  EXPECT_EQ(1, a2.Perform(make_tuple('a')));
+  EXPECT_EQ(0, a2.Perform(make_tuple('\0')));
+}
+#endif  // !GTEST_OS_SYMBIAN
+
+// The following two classes are for testing MakePolymorphicAction().
+
+// Implements a polymorphic action that returns the second of the
+// arguments it receives.
+class ReturnSecondArgumentAction {
+ public:
+  // We want to verify that MakePolymorphicAction() can work with a
+  // polymorphic action whose Perform() method template is either
+  // const or not.  This lets us verify the non-const case.
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& args) { return get<1>(args); }
+};
+
+// Implements a polymorphic action that can be used in a nullary
+// function to return 0.
+class ReturnZeroFromNullaryFunctionAction {
+ public:
+  // For testing that MakePolymorphicAction() works when the
+  // implementation class' Perform() method template takes only one
+  // template parameter.
+  //
+  // We want to verify that MakePolymorphicAction() can work with a
+  // polymorphic action whose Perform() method template is either
+  // const or not.  This lets us verify the const case.
+  template <typename Result>
+  Result Perform(const tuple<>&) const { return 0; }
+};
+
+// These functions verify that MakePolymorphicAction() returns a
+// PolymorphicAction<T> where T is the argument's type.
+
+PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
+  return MakePolymorphicAction(ReturnSecondArgumentAction());
+}
+
+PolymorphicAction<ReturnZeroFromNullaryFunctionAction>
+ReturnZeroFromNullaryFunction() {
+  return MakePolymorphicAction(ReturnZeroFromNullaryFunctionAction());
+}
+
+// Tests that MakePolymorphicAction() turns a polymorphic action
+// implementation class into a polymorphic action.
+TEST(MakePolymorphicActionTest, ConstructsActionFromImpl) {
+  Action<int(bool, int, double)> a1 = ReturnSecondArgument();  // NOLINT
+  EXPECT_EQ(5, a1.Perform(make_tuple(false, 5, 2.0)));
+}
+
+// Tests that MakePolymorphicAction() works when the implementation
+// class' Perform() method template has only one template parameter.
+TEST(MakePolymorphicActionTest, WorksWhenPerformHasOneTemplateParameter) {
+  Action<int()> a1 = ReturnZeroFromNullaryFunction();
+  EXPECT_EQ(0, a1.Perform(make_tuple()));
+
+  Action<void*()> a2 = ReturnZeroFromNullaryFunction();
+  EXPECT_TRUE(a2.Perform(make_tuple()) == NULL);
+}
+
+// Tests that Return() works as an action for void-returning
+// functions.
+TEST(ReturnTest, WorksForVoid) {
+  const Action<void(int)> ret = Return();  // NOLINT
+  return ret.Perform(make_tuple(1));
+}
+
+// Tests that Return(v) returns v.
+TEST(ReturnTest, ReturnsGivenValue) {
+  Action<int()> ret = Return(1);  // NOLINT
+  EXPECT_EQ(1, ret.Perform(make_tuple()));
+
+  ret = Return(-5);
+  EXPECT_EQ(-5, ret.Perform(make_tuple()));
+}
+
+// Tests that Return("string literal") works.
+TEST(ReturnTest, AcceptsStringLiteral) {
+  Action<const char*()> a1 = Return("Hello");
+  EXPECT_STREQ("Hello", a1.Perform(make_tuple()));
+
+  Action<std::string()> a2 = Return("world");
+  EXPECT_EQ("world", a2.Perform(make_tuple()));
+}
+
+// Test struct which wraps a vector of integers. Used in
+// 'SupportsWrapperReturnType' test.
+struct IntegerVectorWrapper {
+  std::vector<int> * v;
+  IntegerVectorWrapper(std::vector<int>& _v) : v(&_v) {}  // NOLINT
+};
+
+// Tests that Return() works when return type is a wrapper type.
+TEST(ReturnTest, SupportsWrapperReturnType) {
+  // Initialize vector of integers.
+  std::vector<int> v;
+  for (int i = 0; i < 5; ++i) v.push_back(i);
+
+  // Return() called with 'v' as argument. The Action will return the same data
+  // as 'v' (copy) but it will be wrapped in an IntegerVectorWrapper.
+  Action<IntegerVectorWrapper()> a = Return(v);
+  const std::vector<int>& result = *(a.Perform(make_tuple()).v);
+  EXPECT_THAT(result, ::testing::ElementsAre(0, 1, 2, 3, 4));
+}
+
+// Tests that Return(v) is covaraint.
+
+struct Base {
+  bool operator==(const Base&) { return true; }
+};
+
+struct Derived : public Base {
+  bool operator==(const Derived&) { return true; }
+};
+
+TEST(ReturnTest, IsCovariant) {
+  Base base;
+  Derived derived;
+  Action<Base*()> ret = Return(&base);
+  EXPECT_EQ(&base, ret.Perform(make_tuple()));
+
+  ret = Return(&derived);
+  EXPECT_EQ(&derived, ret.Perform(make_tuple()));
+}
+
+// Tests that the type of the value passed into Return is converted into T
+// when the action is cast to Action<T(...)> rather than when the action is
+// performed. See comments on testing::internal::ReturnAction in
+// gmock-actions.h for more information.
+class FromType {
+ public:
+  explicit FromType(bool* is_converted) : converted_(is_converted) {}
+  bool* converted() const { return converted_; }
+
+ private:
+  bool* const converted_;
+
+  GTEST_DISALLOW_ASSIGN_(FromType);
+};
+
+class ToType {
+ public:
+  // Must allow implicit conversion due to use in ImplicitCast_<T>.
+  ToType(const FromType& x) { *x.converted() = true; }  // NOLINT
+};
+
+TEST(ReturnTest, ConvertsArgumentWhenConverted) {
+  bool converted = false;
+  FromType x(&converted);
+  Action<ToType()> action(Return(x));
+  EXPECT_TRUE(converted) << "Return must convert its argument in its own "
+                         << "conversion operator.";
+  converted = false;
+  action.Perform(tuple<>());
+  EXPECT_FALSE(converted) << "Action must NOT convert its argument "
+                          << "when performed.";
+}
+
+class DestinationType {};
+
+class SourceType {
+ public:
+  // Note: a non-const typecast operator.
+  operator DestinationType() { return DestinationType(); }
+};
+
+TEST(ReturnTest, CanConvertArgumentUsingNonConstTypeCastOperator) {
+  SourceType s;
+  Action<DestinationType()> action(Return(s));
+}
+
+// Tests that ReturnNull() returns NULL in a pointer-returning function.
+TEST(ReturnNullTest, WorksInPointerReturningFunction) {
+  const Action<int*()> a1 = ReturnNull();
+  EXPECT_TRUE(a1.Perform(make_tuple()) == NULL);
+
+  const Action<const char*(bool)> a2 = ReturnNull();  // NOLINT
+  EXPECT_TRUE(a2.Perform(make_tuple(true)) == NULL);
+}
+
+#if GTEST_HAS_STD_UNIQUE_PTR_
+// Tests that ReturnNull() returns NULL for shared_ptr and unique_ptr returning
+// functions.
+TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) {
+  const Action<std::unique_ptr<const int>()> a1 = ReturnNull();
+  EXPECT_TRUE(a1.Perform(make_tuple()) == nullptr);
+
+  const Action<std::shared_ptr<int>(std::string)> a2 = ReturnNull();
+  EXPECT_TRUE(a2.Perform(make_tuple("foo")) == nullptr);
+}
+#endif  // GTEST_HAS_STD_UNIQUE_PTR_
+
+// Tests that ReturnRef(v) works for reference types.
+TEST(ReturnRefTest, WorksForReference) {
+  const int n = 0;
+  const Action<const int&(bool)> ret = ReturnRef(n);  // NOLINT
+
+  EXPECT_EQ(&n, &ret.Perform(make_tuple(true)));
+}
+
+// Tests that ReturnRef(v) is covariant.
+TEST(ReturnRefTest, IsCovariant) {
+  Base base;
+  Derived derived;
+  Action<Base&()> a = ReturnRef(base);
+  EXPECT_EQ(&base, &a.Perform(make_tuple()));
+
+  a = ReturnRef(derived);
+  EXPECT_EQ(&derived, &a.Perform(make_tuple()));
+}
+
+// Tests that ReturnRefOfCopy(v) works for reference types.
+TEST(ReturnRefOfCopyTest, WorksForReference) {
+  int n = 42;
+  const Action<const int&()> ret = ReturnRefOfCopy(n);
+
+  EXPECT_NE(&n, &ret.Perform(make_tuple()));
+  EXPECT_EQ(42, ret.Perform(make_tuple()));
+
+  n = 43;
+  EXPECT_NE(&n, &ret.Perform(make_tuple()));
+  EXPECT_EQ(42, ret.Perform(make_tuple()));
+}
+
+// Tests that ReturnRefOfCopy(v) is covariant.
+TEST(ReturnRefOfCopyTest, IsCovariant) {
+  Base base;
+  Derived derived;
+  Action<Base&()> a = ReturnRefOfCopy(base);
+  EXPECT_NE(&base, &a.Perform(make_tuple()));
+
+  a = ReturnRefOfCopy(derived);
+  EXPECT_NE(&derived, &a.Perform(make_tuple()));
+}
+
+// Tests that DoDefault() does the default action for the mock method.
+
+class MockClass {
+ public:
+  MockClass() {}
+
+  MOCK_METHOD1(IntFunc, int(bool flag));  // NOLINT
+  MOCK_METHOD0(Foo, MyNonDefaultConstructible());
+#if GTEST_HAS_STD_UNIQUE_PTR_
+  MOCK_METHOD0(MakeUnique, std::unique_ptr<int>());
+  MOCK_METHOD0(MakeUniqueBase, std::unique_ptr<Base>());
+  MOCK_METHOD0(MakeVectorUnique, std::vector<std::unique_ptr<int>>());
+#endif
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass);
+};
+
+// Tests that DoDefault() returns the built-in default value for the
+// return type by default.
+TEST(DoDefaultTest, ReturnsBuiltInDefaultValueByDefault) {
+  MockClass mock;
+  EXPECT_CALL(mock, IntFunc(_))
+      .WillOnce(DoDefault());
+  EXPECT_EQ(0, mock.IntFunc(true));
+}
+
+// Tests that DoDefault() throws (when exceptions are enabled) or aborts
+// the process when there is no built-in default value for the return type.
+TEST(DoDefaultDeathTest, DiesForUnknowType) {
+  MockClass mock;
+  EXPECT_CALL(mock, Foo())
+      .WillRepeatedly(DoDefault());
+#if GTEST_HAS_EXCEPTIONS
+  EXPECT_ANY_THROW(mock.Foo());
+#else
+  EXPECT_DEATH_IF_SUPPORTED({
+    mock.Foo();
+  }, "");
+#endif
+}
+
+// Tests that using DoDefault() inside a composite action leads to a
+// run-time error.
+
+void VoidFunc(bool /* flag */) {}
+
+TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
+  MockClass mock;
+  EXPECT_CALL(mock, IntFunc(_))
+      .WillRepeatedly(DoAll(Invoke(VoidFunc),
+                            DoDefault()));
+
+  // Ideally we should verify the error message as well.  Sadly,
+  // EXPECT_DEATH() can only capture stderr, while Google Mock's
+  // errors are printed on stdout.  Therefore we have to settle for
+  // not verifying the message.
+  EXPECT_DEATH_IF_SUPPORTED({
+    mock.IntFunc(true);
+  }, "");
+}
+
+// Tests that DoDefault() returns the default value set by
+// DefaultValue<T>::Set() when it's not overriden by an ON_CALL().
+TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIsOne) {
+  DefaultValue<int>::Set(1);
+  MockClass mock;
+  EXPECT_CALL(mock, IntFunc(_))
+      .WillOnce(DoDefault());
+  EXPECT_EQ(1, mock.IntFunc(false));
+  DefaultValue<int>::Clear();
+}
+
+// Tests that DoDefault() does the action specified by ON_CALL().
+TEST(DoDefaultTest, DoesWhatOnCallSpecifies) {
+  MockClass mock;
+  ON_CALL(mock, IntFunc(_))
+      .WillByDefault(Return(2));
+  EXPECT_CALL(mock, IntFunc(_))
+      .WillOnce(DoDefault());
+  EXPECT_EQ(2, mock.IntFunc(false));
+}
+
+// Tests that using DoDefault() in ON_CALL() leads to a run-time failure.
+TEST(DoDefaultTest, CannotBeUsedInOnCall) {
+  MockClass mock;
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    ON_CALL(mock, IntFunc(_))
+      .WillByDefault(DoDefault());
+  }, "DoDefault() cannot be used in ON_CALL()");
+}
+
+// Tests that SetArgPointee<N>(v) sets the variable pointed to by
+// the N-th (0-based) argument to v.
+TEST(SetArgPointeeTest, SetsTheNthPointee) {
+  typedef void MyFunction(bool, int*, char*);
+  Action<MyFunction> a = SetArgPointee<1>(2);
+
+  int n = 0;
+  char ch = '\0';
+  a.Perform(make_tuple(true, &n, &ch));
+  EXPECT_EQ(2, n);
+  EXPECT_EQ('\0', ch);
+
+  a = SetArgPointee<2>('a');
+  n = 0;
+  ch = '\0';
+  a.Perform(make_tuple(true, &n, &ch));
+  EXPECT_EQ(0, n);
+  EXPECT_EQ('a', ch);
+}
+
+#if !((GTEST_GCC_VER_ && GTEST_GCC_VER_ < 40000) || GTEST_OS_SYMBIAN)
+// Tests that SetArgPointee<N>() accepts a string literal.
+// GCC prior to v4.0 and the Symbian compiler do not support this.
+TEST(SetArgPointeeTest, AcceptsStringLiteral) {
+  typedef void MyFunction(std::string*, const char**);
+  Action<MyFunction> a = SetArgPointee<0>("hi");
+  std::string str;
+  const char* ptr = NULL;
+  a.Perform(make_tuple(&str, &ptr));
+  EXPECT_EQ("hi", str);
+  EXPECT_TRUE(ptr == NULL);
+
+  a = SetArgPointee<1>("world");
+  str = "";
+  a.Perform(make_tuple(&str, &ptr));
+  EXPECT_EQ("", str);
+  EXPECT_STREQ("world", ptr);
+}
+
+TEST(SetArgPointeeTest, AcceptsWideStringLiteral) {
+  typedef void MyFunction(const wchar_t**);
+  Action<MyFunction> a = SetArgPointee<0>(L"world");
+  const wchar_t* ptr = NULL;
+  a.Perform(make_tuple(&ptr));
+  EXPECT_STREQ(L"world", ptr);
+
+# if GTEST_HAS_STD_WSTRING
+
+  typedef void MyStringFunction(std::wstring*);
+  Action<MyStringFunction> a2 = SetArgPointee<0>(L"world");
+  std::wstring str = L"";
+  a2.Perform(make_tuple(&str));
+  EXPECT_EQ(L"world", str);
+
+# endif
+}
+#endif
+
+// Tests that SetArgPointee<N>() accepts a char pointer.
+TEST(SetArgPointeeTest, AcceptsCharPointer) {
+  typedef void MyFunction(bool, std::string*, const char**);
+  const char* const hi = "hi";
+  Action<MyFunction> a = SetArgPointee<1>(hi);
+  std::string str;
+  const char* ptr = NULL;
+  a.Perform(make_tuple(true, &str, &ptr));
+  EXPECT_EQ("hi", str);
+  EXPECT_TRUE(ptr == NULL);
+
+  char world_array[] = "world";
+  char* const world = world_array;
+  a = SetArgPointee<2>(world);
+  str = "";
+  a.Perform(make_tuple(true, &str, &ptr));
+  EXPECT_EQ("", str);
+  EXPECT_EQ(world, ptr);
+}
+
+TEST(SetArgPointeeTest, AcceptsWideCharPointer) {
+  typedef void MyFunction(bool, const wchar_t**);
+  const wchar_t* const hi = L"hi";
+  Action<MyFunction> a = SetArgPointee<1>(hi);
+  const wchar_t* ptr = NULL;
+  a.Perform(make_tuple(true, &ptr));
+  EXPECT_EQ(hi, ptr);
+
+# if GTEST_HAS_STD_WSTRING
+
+  typedef void MyStringFunction(bool, std::wstring*);
+  wchar_t world_array[] = L"world";
+  wchar_t* const world = world_array;
+  Action<MyStringFunction> a2 = SetArgPointee<1>(world);
+  std::wstring str;
+  a2.Perform(make_tuple(true, &str));
+  EXPECT_EQ(world_array, str);
+# endif
+}
+
+#if GTEST_HAS_PROTOBUF_
+
+// Tests that SetArgPointee<N>(proto_buffer) sets the v1 protobuf
+// variable pointed to by the N-th (0-based) argument to proto_buffer.
+TEST(SetArgPointeeTest, SetsTheNthPointeeOfProtoBufferType) {
+  TestMessage* const msg = new TestMessage;
+  msg->set_member("yes");
+  TestMessage orig_msg;
+  orig_msg.CopyFrom(*msg);
+
+  Action<void(bool, TestMessage*)> a = SetArgPointee<1>(*msg);
+  // SetArgPointee<N>(proto_buffer) makes a copy of proto_buffer
+  // s.t. the action works even when the original proto_buffer has
+  // died.  We ensure this behavior by deleting msg before using the
+  // action.
+  delete msg;
+
+  TestMessage dest;
+  EXPECT_FALSE(orig_msg.Equals(dest));
+  a.Perform(make_tuple(true, &dest));
+  EXPECT_TRUE(orig_msg.Equals(dest));
+}
+
+// Tests that SetArgPointee<N>(proto_buffer) sets the
+// ::ProtocolMessage variable pointed to by the N-th (0-based)
+// argument to proto_buffer.
+TEST(SetArgPointeeTest, SetsTheNthPointeeOfProtoBufferBaseType) {
+  TestMessage* const msg = new TestMessage;
+  msg->set_member("yes");
+  TestMessage orig_msg;
+  orig_msg.CopyFrom(*msg);
+
+  Action<void(bool, ::ProtocolMessage*)> a = SetArgPointee<1>(*msg);
+  // SetArgPointee<N>(proto_buffer) makes a copy of proto_buffer
+  // s.t. the action works even when the original proto_buffer has
+  // died.  We ensure this behavior by deleting msg before using the
+  // action.
+  delete msg;
+
+  TestMessage dest;
+  ::ProtocolMessage* const dest_base = &dest;
+  EXPECT_FALSE(orig_msg.Equals(dest));
+  a.Perform(make_tuple(true, dest_base));
+  EXPECT_TRUE(orig_msg.Equals(dest));
+}
+
+// Tests that SetArgPointee<N>(proto2_buffer) sets the v2
+// protobuf variable pointed to by the N-th (0-based) argument to
+// proto2_buffer.
+TEST(SetArgPointeeTest, SetsTheNthPointeeOfProto2BufferType) {
+  using testing::internal::FooMessage;
+  FooMessage* const msg = new FooMessage;
+  msg->set_int_field(2);
+  msg->set_string_field("hi");
+  FooMessage orig_msg;
+  orig_msg.CopyFrom(*msg);
+
+  Action<void(bool, FooMessage*)> a = SetArgPointee<1>(*msg);
+  // SetArgPointee<N>(proto2_buffer) makes a copy of
+  // proto2_buffer s.t. the action works even when the original
+  // proto2_buffer has died.  We ensure this behavior by deleting msg
+  // before using the action.
+  delete msg;
+
+  FooMessage dest;
+  dest.set_int_field(0);
+  a.Perform(make_tuple(true, &dest));
+  EXPECT_EQ(2, dest.int_field());
+  EXPECT_EQ("hi", dest.string_field());
+}
+
+// Tests that SetArgPointee<N>(proto2_buffer) sets the
+// proto2::Message variable pointed to by the N-th (0-based) argument
+// to proto2_buffer.
+TEST(SetArgPointeeTest, SetsTheNthPointeeOfProto2BufferBaseType) {
+  using testing::internal::FooMessage;
+  FooMessage* const msg = new FooMessage;
+  msg->set_int_field(2);
+  msg->set_string_field("hi");
+  FooMessage orig_msg;
+  orig_msg.CopyFrom(*msg);
+
+  Action<void(bool, ::proto2::Message*)> a = SetArgPointee<1>(*msg);
+  // SetArgPointee<N>(proto2_buffer) makes a copy of
+  // proto2_buffer s.t. the action works even when the original
+  // proto2_buffer has died.  We ensure this behavior by deleting msg
+  // before using the action.
+  delete msg;
+
+  FooMessage dest;
+  dest.set_int_field(0);
+  ::proto2::Message* const dest_base = &dest;
+  a.Perform(make_tuple(true, dest_base));
+  EXPECT_EQ(2, dest.int_field());
+  EXPECT_EQ("hi", dest.string_field());
+}
+
+#endif  // GTEST_HAS_PROTOBUF_
+
+// Tests that SetArgumentPointee<N>(v) sets the variable pointed to by
+// the N-th (0-based) argument to v.
+TEST(SetArgumentPointeeTest, SetsTheNthPointee) {
+  typedef void MyFunction(bool, int*, char*);
+  Action<MyFunction> a = SetArgumentPointee<1>(2);
+
+  int n = 0;
+  char ch = '\0';
+  a.Perform(make_tuple(true, &n, &ch));
+  EXPECT_EQ(2, n);
+  EXPECT_EQ('\0', ch);
+
+  a = SetArgumentPointee<2>('a');
+  n = 0;
+  ch = '\0';
+  a.Perform(make_tuple(true, &n, &ch));
+  EXPECT_EQ(0, n);
+  EXPECT_EQ('a', ch);
+}
+
+#if GTEST_HAS_PROTOBUF_
+
+// Tests that SetArgumentPointee<N>(proto_buffer) sets the v1 protobuf
+// variable pointed to by the N-th (0-based) argument to proto_buffer.
+TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProtoBufferType) {
+  TestMessage* const msg = new TestMessage;
+  msg->set_member("yes");
+  TestMessage orig_msg;
+  orig_msg.CopyFrom(*msg);
+
+  Action<void(bool, TestMessage*)> a = SetArgumentPointee<1>(*msg);
+  // SetArgumentPointee<N>(proto_buffer) makes a copy of proto_buffer
+  // s.t. the action works even when the original proto_buffer has
+  // died.  We ensure this behavior by deleting msg before using the
+  // action.
+  delete msg;
+
+  TestMessage dest;
+  EXPECT_FALSE(orig_msg.Equals(dest));
+  a.Perform(make_tuple(true, &dest));
+  EXPECT_TRUE(orig_msg.Equals(dest));
+}
+
+// Tests that SetArgumentPointee<N>(proto_buffer) sets the
+// ::ProtocolMessage variable pointed to by the N-th (0-based)
+// argument to proto_buffer.
+TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProtoBufferBaseType) {
+  TestMessage* const msg = new TestMessage;
+  msg->set_member("yes");
+  TestMessage orig_msg;
+  orig_msg.CopyFrom(*msg);
+
+  Action<void(bool, ::ProtocolMessage*)> a = SetArgumentPointee<1>(*msg);
+  // SetArgumentPointee<N>(proto_buffer) makes a copy of proto_buffer
+  // s.t. the action works even when the original proto_buffer has
+  // died.  We ensure this behavior by deleting msg before using the
+  // action.
+  delete msg;
+
+  TestMessage dest;
+  ::ProtocolMessage* const dest_base = &dest;
+  EXPECT_FALSE(orig_msg.Equals(dest));
+  a.Perform(make_tuple(true, dest_base));
+  EXPECT_TRUE(orig_msg.Equals(dest));
+}
+
+// Tests that SetArgumentPointee<N>(proto2_buffer) sets the v2
+// protobuf variable pointed to by the N-th (0-based) argument to
+// proto2_buffer.
+TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProto2BufferType) {
+  using testing::internal::FooMessage;
+  FooMessage* const msg = new FooMessage;
+  msg->set_int_field(2);
+  msg->set_string_field("hi");
+  FooMessage orig_msg;
+  orig_msg.CopyFrom(*msg);
+
+  Action<void(bool, FooMessage*)> a = SetArgumentPointee<1>(*msg);
+  // SetArgumentPointee<N>(proto2_buffer) makes a copy of
+  // proto2_buffer s.t. the action works even when the original
+  // proto2_buffer has died.  We ensure this behavior by deleting msg
+  // before using the action.
+  delete msg;
+
+  FooMessage dest;
+  dest.set_int_field(0);
+  a.Perform(make_tuple(true, &dest));
+  EXPECT_EQ(2, dest.int_field());
+  EXPECT_EQ("hi", dest.string_field());
+}
+
+// Tests that SetArgumentPointee<N>(proto2_buffer) sets the
+// proto2::Message variable pointed to by the N-th (0-based) argument
+// to proto2_buffer.
+TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProto2BufferBaseType) {
+  using testing::internal::FooMessage;
+  FooMessage* const msg = new FooMessage;
+  msg->set_int_field(2);
+  msg->set_string_field("hi");
+  FooMessage orig_msg;
+  orig_msg.CopyFrom(*msg);
+
+  Action<void(bool, ::proto2::Message*)> a = SetArgumentPointee<1>(*msg);
+  // SetArgumentPointee<N>(proto2_buffer) makes a copy of
+  // proto2_buffer s.t. the action works even when the original
+  // proto2_buffer has died.  We ensure this behavior by deleting msg
+  // before using the action.
+  delete msg;
+
+  FooMessage dest;
+  dest.set_int_field(0);
+  ::proto2::Message* const dest_base = &dest;
+  a.Perform(make_tuple(true, dest_base));
+  EXPECT_EQ(2, dest.int_field());
+  EXPECT_EQ("hi", dest.string_field());
+}
+
+#endif  // GTEST_HAS_PROTOBUF_
+
+// Sample functions and functors for testing Invoke() and etc.
+int Nullary() { return 1; }
+
+class NullaryFunctor {
+ public:
+  int operator()() { return 2; }
+};
+
+bool g_done = false;
+void VoidNullary() { g_done = true; }
+
+class VoidNullaryFunctor {
+ public:
+  void operator()() { g_done = true; }
+};
+
+class Foo {
+ public:
+  Foo() : value_(123) {}
+
+  int Nullary() const { return value_; }
+
+ private:
+  int value_;
+};
+
+// Tests InvokeWithoutArgs(function).
+TEST(InvokeWithoutArgsTest, Function) {
+  // As an action that takes one argument.
+  Action<int(int)> a = InvokeWithoutArgs(Nullary);  // NOLINT
+  EXPECT_EQ(1, a.Perform(make_tuple(2)));
+
+  // As an action that takes two arguments.
+  Action<int(int, double)> a2 = InvokeWithoutArgs(Nullary);  // NOLINT
+  EXPECT_EQ(1, a2.Perform(make_tuple(2, 3.5)));
+
+  // As an action that returns void.
+  Action<void(int)> a3 = InvokeWithoutArgs(VoidNullary);  // NOLINT
+  g_done = false;
+  a3.Perform(make_tuple(1));
+  EXPECT_TRUE(g_done);
+}
+
+// Tests InvokeWithoutArgs(functor).
+TEST(InvokeWithoutArgsTest, Functor) {
+  // As an action that takes no argument.
+  Action<int()> a = InvokeWithoutArgs(NullaryFunctor());  // NOLINT
+  EXPECT_EQ(2, a.Perform(make_tuple()));
+
+  // As an action that takes three arguments.
+  Action<int(int, double, char)> a2 =  // NOLINT
+      InvokeWithoutArgs(NullaryFunctor());
+  EXPECT_EQ(2, a2.Perform(make_tuple(3, 3.5, 'a')));
+
+  // As an action that returns void.
+  Action<void()> a3 = InvokeWithoutArgs(VoidNullaryFunctor());
+  g_done = false;
+  a3.Perform(make_tuple());
+  EXPECT_TRUE(g_done);
+}
+
+// Tests InvokeWithoutArgs(obj_ptr, method).
+TEST(InvokeWithoutArgsTest, Method) {
+  Foo foo;
+  Action<int(bool, char)> a =  // NOLINT
+      InvokeWithoutArgs(&foo, &Foo::Nullary);
+  EXPECT_EQ(123, a.Perform(make_tuple(true, 'a')));
+}
+
+// Tests using IgnoreResult() on a polymorphic action.
+TEST(IgnoreResultTest, PolymorphicAction) {
+  Action<void(int)> a = IgnoreResult(Return(5));  // NOLINT
+  a.Perform(make_tuple(1));
+}
+
+// Tests using IgnoreResult() on a monomorphic action.
+
+int ReturnOne() {
+  g_done = true;
+  return 1;
+}
+
+TEST(IgnoreResultTest, MonomorphicAction) {
+  g_done = false;
+  Action<void()> a = IgnoreResult(Invoke(ReturnOne));
+  a.Perform(make_tuple());
+  EXPECT_TRUE(g_done);
+}
+
+// Tests using IgnoreResult() on an action that returns a class type.
+
+MyNonDefaultConstructible ReturnMyNonDefaultConstructible(double /* x */) {
+  g_done = true;
+  return MyNonDefaultConstructible(42);
+}
+
+TEST(IgnoreResultTest, ActionReturningClass) {
+  g_done = false;
+  Action<void(int)> a =
+      IgnoreResult(Invoke(ReturnMyNonDefaultConstructible));  // NOLINT
+  a.Perform(make_tuple(2));
+  EXPECT_TRUE(g_done);
+}
+
+TEST(AssignTest, Int) {
+  int x = 0;
+  Action<void(int)> a = Assign(&x, 5);
+  a.Perform(make_tuple(0));
+  EXPECT_EQ(5, x);
+}
+
+TEST(AssignTest, String) {
+  ::std::string x;
+  Action<void(void)> a = Assign(&x, "Hello, world");
+  a.Perform(make_tuple());
+  EXPECT_EQ("Hello, world", x);
+}
+
+TEST(AssignTest, CompatibleTypes) {
+  double x = 0;
+  Action<void(int)> a = Assign(&x, 5);
+  a.Perform(make_tuple(0));
+  EXPECT_DOUBLE_EQ(5, x);
+}
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+class SetErrnoAndReturnTest : public testing::Test {
+ protected:
+  virtual void SetUp() { errno = 0; }
+  virtual void TearDown() { errno = 0; }
+};
+
+TEST_F(SetErrnoAndReturnTest, Int) {
+  Action<int(void)> a = SetErrnoAndReturn(ENOTTY, -5);
+  EXPECT_EQ(-5, a.Perform(make_tuple()));
+  EXPECT_EQ(ENOTTY, errno);
+}
+
+TEST_F(SetErrnoAndReturnTest, Ptr) {
+  int x;
+  Action<int*(void)> a = SetErrnoAndReturn(ENOTTY, &x);
+  EXPECT_EQ(&x, a.Perform(make_tuple()));
+  EXPECT_EQ(ENOTTY, errno);
+}
+
+TEST_F(SetErrnoAndReturnTest, CompatibleTypes) {
+  Action<double()> a = SetErrnoAndReturn(EINVAL, 5);
+  EXPECT_DOUBLE_EQ(5.0, a.Perform(make_tuple()));
+  EXPECT_EQ(EINVAL, errno);
+}
+
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Tests ByRef().
+
+// Tests that ReferenceWrapper<T> is copyable.
+TEST(ByRefTest, IsCopyable) {
+  const std::string s1 = "Hi";
+  const std::string s2 = "Hello";
+
+  ::testing::internal::ReferenceWrapper<const std::string> ref_wrapper =
+      ByRef(s1);
+  const std::string& r1 = ref_wrapper;
+  EXPECT_EQ(&s1, &r1);
+
+  // Assigns a new value to ref_wrapper.
+  ref_wrapper = ByRef(s2);
+  const std::string& r2 = ref_wrapper;
+  EXPECT_EQ(&s2, &r2);
+
+  ::testing::internal::ReferenceWrapper<const std::string> ref_wrapper1 =
+      ByRef(s1);
+  // Copies ref_wrapper1 to ref_wrapper.
+  ref_wrapper = ref_wrapper1;
+  const std::string& r3 = ref_wrapper;
+  EXPECT_EQ(&s1, &r3);
+}
+
+// Tests using ByRef() on a const value.
+TEST(ByRefTest, ConstValue) {
+  const int n = 0;
+  // int& ref = ByRef(n);  // This shouldn't compile - we have a
+                           // negative compilation test to catch it.
+  const int& const_ref = ByRef(n);
+  EXPECT_EQ(&n, &const_ref);
+}
+
+// Tests using ByRef() on a non-const value.
+TEST(ByRefTest, NonConstValue) {
+  int n = 0;
+
+  // ByRef(n) can be used as either an int&,
+  int& ref = ByRef(n);
+  EXPECT_EQ(&n, &ref);
+
+  // or a const int&.
+  const int& const_ref = ByRef(n);
+  EXPECT_EQ(&n, &const_ref);
+}
+
+// Tests explicitly specifying the type when using ByRef().
+TEST(ByRefTest, ExplicitType) {
+  int n = 0;
+  const int& r1 = ByRef<const int>(n);
+  EXPECT_EQ(&n, &r1);
+
+  // ByRef<char>(n);  // This shouldn't compile - we have a negative
+                      // compilation test to catch it.
+
+  Derived d;
+  Derived& r2 = ByRef<Derived>(d);
+  EXPECT_EQ(&d, &r2);
+
+  const Derived& r3 = ByRef<const Derived>(d);
+  EXPECT_EQ(&d, &r3);
+
+  Base& r4 = ByRef<Base>(d);
+  EXPECT_EQ(&d, &r4);
+
+  const Base& r5 = ByRef<const Base>(d);
+  EXPECT_EQ(&d, &r5);
+
+  // The following shouldn't compile - we have a negative compilation
+  // test for it.
+  //
+  // Base b;
+  // ByRef<Derived>(b);
+}
+
+// Tests that Google Mock prints expression ByRef(x) as a reference to x.
+TEST(ByRefTest, PrintsCorrectly) {
+  int n = 42;
+  ::std::stringstream expected, actual;
+  testing::internal::UniversalPrinter<const int&>::Print(n, &expected);
+  testing::internal::UniversalPrint(ByRef(n), &actual);
+  EXPECT_EQ(expected.str(), actual.str());
+}
+
+#if GTEST_HAS_STD_UNIQUE_PTR_
+
+std::unique_ptr<int> UniquePtrSource() {
+  return std::unique_ptr<int>(new int(19));
+}
+
+std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
+  std::vector<std::unique_ptr<int>> out;
+  out.emplace_back(new int(7));
+  return out;
+}
+
+TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
+  MockClass mock;
+  std::unique_ptr<int> i(new int(19));
+  EXPECT_CALL(mock, MakeUnique()).WillOnce(Return(ByMove(std::move(i))));
+  EXPECT_CALL(mock, MakeVectorUnique())
+      .WillOnce(Return(ByMove(VectorUniquePtrSource())));
+  Derived* d = new Derived;
+  EXPECT_CALL(mock, MakeUniqueBase())
+      .WillOnce(Return(ByMove(std::unique_ptr<Derived>(d))));
+
+  std::unique_ptr<int> result1 = mock.MakeUnique();
+  EXPECT_EQ(19, *result1);
+
+  std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
+  EXPECT_EQ(1u, vresult.size());
+  EXPECT_NE(nullptr, vresult[0]);
+  EXPECT_EQ(7, *vresult[0]);
+
+  std::unique_ptr<Base> result2 = mock.MakeUniqueBase();
+  EXPECT_EQ(d, result2.get());
+}
+
+TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
+  testing::MockFunction<void()> mock_function;
+  MockClass mock;
+  std::unique_ptr<int> i(new int(19));
+  EXPECT_CALL(mock_function, Call());
+  EXPECT_CALL(mock, MakeUnique()).WillOnce(DoAll(
+      InvokeWithoutArgs(&mock_function, &testing::MockFunction<void()>::Call),
+      Return(ByMove(std::move(i)))));
+
+  std::unique_ptr<int> result1 = mock.MakeUnique();
+  EXPECT_EQ(19, *result1);
+}
+
+TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
+  MockClass mock;
+
+  // Check default value
+  DefaultValue<std::unique_ptr<int>>::SetFactory([] {
+    return std::unique_ptr<int>(new int(42));
+  });
+  EXPECT_EQ(42, *mock.MakeUnique());
+
+  EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(Invoke(UniquePtrSource));
+  EXPECT_CALL(mock, MakeVectorUnique())
+      .WillRepeatedly(Invoke(VectorUniquePtrSource));
+  std::unique_ptr<int> result1 = mock.MakeUnique();
+  EXPECT_EQ(19, *result1);
+  std::unique_ptr<int> result2 = mock.MakeUnique();
+  EXPECT_EQ(19, *result2);
+  EXPECT_NE(result1, result2);
+
+  std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
+  EXPECT_EQ(1u, vresult.size());
+  EXPECT_NE(nullptr, vresult[0]);
+  EXPECT_EQ(7, *vresult[0]);
+}
+
+#endif  // GTEST_HAS_STD_UNIQUE_PTR_
+
+}  // Unnamed namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-cardinalities_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-cardinalities_test.cc
new file mode 100644
index 00000000..64815e57
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-cardinalities_test.cc
@@ -0,0 +1,428 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests the built-in cardinalities.
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "gtest/gtest-spi.h"
+
+namespace {
+
+using std::stringstream;
+using testing::AnyNumber;
+using testing::AtLeast;
+using testing::AtMost;
+using testing::Between;
+using testing::Cardinality;
+using testing::CardinalityInterface;
+using testing::Exactly;
+using testing::IsSubstring;
+using testing::MakeCardinality;
+
+class MockFoo {
+ public:
+  MockFoo() {}
+  MOCK_METHOD0(Bar, int());  // NOLINT
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
+};
+
+// Tests that Cardinality objects can be default constructed.
+TEST(CardinalityTest, IsDefaultConstructable) {
+  Cardinality c;
+}
+
+// Tests that Cardinality objects are copyable.
+TEST(CardinalityTest, IsCopyable) {
+  // Tests the copy constructor.
+  Cardinality c = Exactly(1);
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(1));
+
+  // Tests the assignment operator.
+  c = Exactly(2);
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(2));
+}
+
+TEST(CardinalityTest, IsOverSaturatedByCallCountWorks) {
+  const Cardinality c = AtMost(5);
+  EXPECT_FALSE(c.IsOverSaturatedByCallCount(4));
+  EXPECT_FALSE(c.IsOverSaturatedByCallCount(5));
+  EXPECT_TRUE(c.IsOverSaturatedByCallCount(6));
+}
+
+// Tests that Cardinality::DescribeActualCallCountTo() creates the
+// correct description.
+TEST(CardinalityTest, CanDescribeActualCallCount) {
+  stringstream ss0;
+  Cardinality::DescribeActualCallCountTo(0, &ss0);
+  EXPECT_EQ("never called", ss0.str());
+
+  stringstream ss1;
+  Cardinality::DescribeActualCallCountTo(1, &ss1);
+  EXPECT_EQ("called once", ss1.str());
+
+  stringstream ss2;
+  Cardinality::DescribeActualCallCountTo(2, &ss2);
+  EXPECT_EQ("called twice", ss2.str());
+
+  stringstream ss3;
+  Cardinality::DescribeActualCallCountTo(3, &ss3);
+  EXPECT_EQ("called 3 times", ss3.str());
+}
+
+// Tests AnyNumber()
+TEST(AnyNumber, Works) {
+  const Cardinality c = AnyNumber();
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(1));
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(9));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(9));
+
+  stringstream ss;
+  c.DescribeTo(&ss);
+  EXPECT_PRED_FORMAT2(IsSubstring, "called any number of times",
+                      ss.str());
+}
+
+TEST(AnyNumberTest, HasCorrectBounds) {
+  const Cardinality c = AnyNumber();
+  EXPECT_EQ(0, c.ConservativeLowerBound());
+  EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
+}
+
+// Tests AtLeast(n).
+
+TEST(AtLeastTest, OnNegativeNumber) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    AtLeast(-1);
+  }, "The invocation lower bound must be >= 0");
+}
+
+TEST(AtLeastTest, OnZero) {
+  const Cardinality c = AtLeast(0);
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(1));
+
+  stringstream ss;
+  c.DescribeTo(&ss);
+  EXPECT_PRED_FORMAT2(IsSubstring, "any number of times",
+                      ss.str());
+}
+
+TEST(AtLeastTest, OnPositiveNumber) {
+  const Cardinality c = AtLeast(2);
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
+
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(1));
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(2));
+
+  stringstream ss1;
+  AtLeast(1).DescribeTo(&ss1);
+  EXPECT_PRED_FORMAT2(IsSubstring, "at least once",
+                      ss1.str());
+
+  stringstream ss2;
+  c.DescribeTo(&ss2);
+  EXPECT_PRED_FORMAT2(IsSubstring, "at least twice",
+                      ss2.str());
+
+  stringstream ss3;
+  AtLeast(3).DescribeTo(&ss3);
+  EXPECT_PRED_FORMAT2(IsSubstring, "at least 3 times",
+                      ss3.str());
+}
+
+TEST(AtLeastTest, HasCorrectBounds) {
+  const Cardinality c = AtLeast(2);
+  EXPECT_EQ(2, c.ConservativeLowerBound());
+  EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
+}
+
+// Tests AtMost(n).
+
+TEST(AtMostTest, OnNegativeNumber) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    AtMost(-1);
+  }, "The invocation upper bound must be >= 0");
+}
+
+TEST(AtMostTest, OnZero) {
+  const Cardinality c = AtMost(0);
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(0));
+
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(1));
+
+  stringstream ss;
+  c.DescribeTo(&ss);
+  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
+                      ss.str());
+}
+
+TEST(AtMostTest, OnPositiveNumber) {
+  const Cardinality c = AtMost(2);
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(1));
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(2));
+
+  stringstream ss1;
+  AtMost(1).DescribeTo(&ss1);
+  EXPECT_PRED_FORMAT2(IsSubstring, "called at most once",
+                      ss1.str());
+
+  stringstream ss2;
+  c.DescribeTo(&ss2);
+  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
+                      ss2.str());
+
+  stringstream ss3;
+  AtMost(3).DescribeTo(&ss3);
+  EXPECT_PRED_FORMAT2(IsSubstring, "called at most 3 times",
+                      ss3.str());
+}
+
+TEST(AtMostTest, HasCorrectBounds) {
+  const Cardinality c = AtMost(2);
+  EXPECT_EQ(0, c.ConservativeLowerBound());
+  EXPECT_EQ(2, c.ConservativeUpperBound());
+}
+
+// Tests Between(m, n).
+
+TEST(BetweenTest, OnNegativeStart) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    Between(-1, 2);
+  }, "The invocation lower bound must be >= 0, but is actually -1");
+}
+
+TEST(BetweenTest, OnNegativeEnd) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    Between(1, -2);
+  }, "The invocation upper bound must be >= 0, but is actually -2");
+}
+
+TEST(BetweenTest, OnStartBiggerThanEnd) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    Between(2, 1);
+  }, "The invocation upper bound (1) must be >= "
+     "the invocation lower bound (2)");
+}
+
+TEST(BetweenTest, OnZeroStartAndZeroEnd) {
+  const Cardinality c = Between(0, 0);
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(0));
+
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(1));
+
+  stringstream ss;
+  c.DescribeTo(&ss);
+  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
+                      ss.str());
+}
+
+TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
+  const Cardinality c = Between(0, 2);
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(2));
+
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(4));
+
+  stringstream ss;
+  c.DescribeTo(&ss);
+  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
+                      ss.str());
+}
+
+TEST(BetweenTest, OnSameStartAndEnd) {
+  const Cardinality c = Between(3, 3);
+
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(2));
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(3));
+
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(4));
+
+  stringstream ss;
+  c.DescribeTo(&ss);
+  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
+                      ss.str());
+}
+
+TEST(BetweenTest, OnDifferentStartAndEnd) {
+  const Cardinality c = Between(3, 5);
+
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(2));
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(3));
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(5));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(5));
+
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(6));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(6));
+
+  stringstream ss;
+  c.DescribeTo(&ss);
+  EXPECT_PRED_FORMAT2(IsSubstring, "called between 3 and 5 times",
+                      ss.str());
+}
+
+TEST(BetweenTest, HasCorrectBounds) {
+  const Cardinality c = Between(3, 5);
+  EXPECT_EQ(3, c.ConservativeLowerBound());
+  EXPECT_EQ(5, c.ConservativeUpperBound());
+}
+
+// Tests Exactly(n).
+
+TEST(ExactlyTest, OnNegativeNumber) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    Exactly(-1);
+  }, "The invocation lower bound must be >= 0");
+}
+
+TEST(ExactlyTest, OnZero) {
+  const Cardinality c = Exactly(0);
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(0));
+
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(1));
+
+  stringstream ss;
+  c.DescribeTo(&ss);
+  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
+                      ss.str());
+}
+
+TEST(ExactlyTest, OnPositiveNumber) {
+  const Cardinality c = Exactly(2);
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
+  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
+  EXPECT_TRUE(c.IsSaturatedByCallCount(2));
+
+  stringstream ss1;
+  Exactly(1).DescribeTo(&ss1);
+  EXPECT_PRED_FORMAT2(IsSubstring, "called once",
+                      ss1.str());
+
+  stringstream ss2;
+  c.DescribeTo(&ss2);
+  EXPECT_PRED_FORMAT2(IsSubstring, "called twice",
+                      ss2.str());
+
+  stringstream ss3;
+  Exactly(3).DescribeTo(&ss3);
+  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
+                      ss3.str());
+}
+
+TEST(ExactlyTest, HasCorrectBounds) {
+  const Cardinality c = Exactly(3);
+  EXPECT_EQ(3, c.ConservativeLowerBound());
+  EXPECT_EQ(3, c.ConservativeUpperBound());
+}
+
+// Tests that a user can make his own cardinality by implementing
+// CardinalityInterface and calling MakeCardinality().
+
+class EvenCardinality : public CardinalityInterface {
+ public:
+  // Returns true iff call_count calls will satisfy this cardinality.
+  virtual bool IsSatisfiedByCallCount(int call_count) const {
+    return (call_count % 2 == 0);
+  }
+
+  // Returns true iff call_count calls will saturate this cardinality.
+  virtual bool IsSaturatedByCallCount(int /* call_count */) const {
+    return false;
+  }
+
+  // Describes self to an ostream.
+  virtual void DescribeTo(::std::ostream* ss) const {
+    *ss << "called even number of times";
+  }
+};
+
+TEST(MakeCardinalityTest, ConstructsCardinalityFromInterface) {
+  const Cardinality c = MakeCardinality(new EvenCardinality);
+
+  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
+  EXPECT_FALSE(c.IsSatisfiedByCallCount(3));
+
+  EXPECT_FALSE(c.IsSaturatedByCallCount(10000));
+
+  stringstream ss;
+  c.DescribeTo(&ss);
+  EXPECT_EQ("called even number of times", ss.str());
+}
+
+}  // Unnamed namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-actions_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-actions_test.cc
new file mode 100644
index 00000000..5ca5bc78
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-actions_test.cc
@@ -0,0 +1,1228 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests the built-in actions generated by a script.
+
+#include "gmock/gmock-generated-actions.h"
+
+#include <functional>
+#include <sstream>
+#include <string>
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+namespace gmock_generated_actions_test {
+
+using ::std::plus;
+using ::std::string;
+using testing::get;
+using testing::make_tuple;
+using testing::tuple;
+using testing::tuple_element;
+using testing::_;
+using testing::Action;
+using testing::ActionInterface;
+using testing::ByRef;
+using testing::DoAll;
+using testing::Invoke;
+using testing::Return;
+using testing::ReturnNew;
+using testing::SetArgPointee;
+using testing::StaticAssertTypeEq;
+using testing::Unused;
+using testing::WithArgs;
+
+// For suppressing compiler warnings on conversion possibly losing precision.
+inline short Short(short n) { return n; }  // NOLINT
+inline char Char(char ch) { return ch; }
+
+// Sample functions and functors for testing various actions.
+int Nullary() { return 1; }
+
+class NullaryFunctor {
+ public:
+  int operator()() { return 2; }
+};
+
+bool g_done = false;
+
+bool Unary(int x) { return x < 0; }
+
+const char* Plus1(const char* s) { return s + 1; }
+
+bool ByConstRef(const string& s) { return s == "Hi"; }
+
+const double g_double = 0;
+bool ReferencesGlobalDouble(const double& x) { return &x == &g_double; }
+
+string ByNonConstRef(string& s) { return s += "+"; }  // NOLINT
+
+struct UnaryFunctor {
+  int operator()(bool x) { return x ? 1 : -1; }
+};
+
+const char* Binary(const char* input, short n) { return input + n; }  // NOLINT
+
+void VoidBinary(int, char) { g_done = true; }
+
+int Ternary(int x, char y, short z) { return x + y + z; }  // NOLINT
+
+void VoidTernary(int, char, bool) { g_done = true; }
+
+int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }
+
+string Concat4(const char* s1, const char* s2, const char* s3,
+               const char* s4) {
+  return string(s1) + s2 + s3 + s4;
+}
+
+int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d + e; }
+
+struct SumOf5Functor {
+  int operator()(int a, int b, int c, int d, int e) {
+    return a + b + c + d + e;
+  }
+};
+
+string Concat5(const char* s1, const char* s2, const char* s3,
+               const char* s4, const char* s5) {
+  return string(s1) + s2 + s3 + s4 + s5;
+}
+
+int SumOf6(int a, int b, int c, int d, int e, int f) {
+  return a + b + c + d + e + f;
+}
+
+struct SumOf6Functor {
+  int operator()(int a, int b, int c, int d, int e, int f) {
+    return a + b + c + d + e + f;
+  }
+};
+
+string Concat6(const char* s1, const char* s2, const char* s3,
+               const char* s4, const char* s5, const char* s6) {
+  return string(s1) + s2 + s3 + s4 + s5 + s6;
+}
+
+string Concat7(const char* s1, const char* s2, const char* s3,
+               const char* s4, const char* s5, const char* s6,
+               const char* s7) {
+  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7;
+}
+
+string Concat8(const char* s1, const char* s2, const char* s3,
+               const char* s4, const char* s5, const char* s6,
+               const char* s7, const char* s8) {
+  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8;
+}
+
+string Concat9(const char* s1, const char* s2, const char* s3,
+               const char* s4, const char* s5, const char* s6,
+               const char* s7, const char* s8, const char* s9) {
+  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9;
+}
+
+string Concat10(const char* s1, const char* s2, const char* s3,
+                const char* s4, const char* s5, const char* s6,
+                const char* s7, const char* s8, const char* s9,
+                const char* s10) {
+  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10;
+}
+
+// A helper that turns the type of a C-string literal from const
+// char[N] to const char*.
+inline const char* CharPtr(const char* s) { return s; }
+
+// Tests InvokeArgument<N>(...).
+
+// Tests using InvokeArgument with a nullary function.
+TEST(InvokeArgumentTest, Function0) {
+  Action<int(int, int(*)())> a = InvokeArgument<1>();  // NOLINT
+  EXPECT_EQ(1, a.Perform(make_tuple(2, &Nullary)));
+}
+
+// Tests using InvokeArgument with a unary function.
+TEST(InvokeArgumentTest, Functor1) {
+  Action<int(UnaryFunctor)> a = InvokeArgument<0>(true);  // NOLINT
+  EXPECT_EQ(1, a.Perform(make_tuple(UnaryFunctor())));
+}
+
+// Tests using InvokeArgument with a 5-ary function.
+TEST(InvokeArgumentTest, Function5) {
+  Action<int(int(*)(int, int, int, int, int))> a =  // NOLINT
+      InvokeArgument<0>(10000, 2000, 300, 40, 5);
+  EXPECT_EQ(12345, a.Perform(make_tuple(&SumOf5)));
+}
+
+// Tests using InvokeArgument with a 5-ary functor.
+TEST(InvokeArgumentTest, Functor5) {
+  Action<int(SumOf5Functor)> a =  // NOLINT
+      InvokeArgument<0>(10000, 2000, 300, 40, 5);
+  EXPECT_EQ(12345, a.Perform(make_tuple(SumOf5Functor())));
+}
+
+// Tests using InvokeArgument with a 6-ary function.
+TEST(InvokeArgumentTest, Function6) {
+  Action<int(int(*)(int, int, int, int, int, int))> a =  // NOLINT
+      InvokeArgument<0>(100000, 20000, 3000, 400, 50, 6);
+  EXPECT_EQ(123456, a.Perform(make_tuple(&SumOf6)));
+}
+
+// Tests using InvokeArgument with a 6-ary functor.
+TEST(InvokeArgumentTest, Functor6) {
+  Action<int(SumOf6Functor)> a =  // NOLINT
+      InvokeArgument<0>(100000, 20000, 3000, 400, 50, 6);
+  EXPECT_EQ(123456, a.Perform(make_tuple(SumOf6Functor())));
+}
+
+// Tests using InvokeArgument with a 7-ary function.
+TEST(InvokeArgumentTest, Function7) {
+  Action<string(string(*)(const char*, const char*, const char*,
+                          const char*, const char*, const char*,
+                          const char*))> a =
+      InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7");
+  EXPECT_EQ("1234567", a.Perform(make_tuple(&Concat7)));
+}
+
+// Tests using InvokeArgument with a 8-ary function.
+TEST(InvokeArgumentTest, Function8) {
+  Action<string(string(*)(const char*, const char*, const char*,
+                          const char*, const char*, const char*,
+                          const char*, const char*))> a =
+      InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7", "8");
+  EXPECT_EQ("12345678", a.Perform(make_tuple(&Concat8)));
+}
+
+// Tests using InvokeArgument with a 9-ary function.
+TEST(InvokeArgumentTest, Function9) {
+  Action<string(string(*)(const char*, const char*, const char*,
+                          const char*, const char*, const char*,
+                          const char*, const char*, const char*))> a =
+      InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7", "8", "9");
+  EXPECT_EQ("123456789", a.Perform(make_tuple(&Concat9)));
+}
+
+// Tests using InvokeArgument with a 10-ary function.
+TEST(InvokeArgumentTest, Function10) {
+  Action<string(string(*)(const char*, const char*, const char*,
+                          const char*, const char*, const char*,
+                          const char*, const char*, const char*,
+                          const char*))> a =
+      InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7", "8", "9", "0");
+  EXPECT_EQ("1234567890", a.Perform(make_tuple(&Concat10)));
+}
+
+// Tests using InvokeArgument with a function that takes a pointer argument.
+TEST(InvokeArgumentTest, ByPointerFunction) {
+  Action<const char*(const char*(*)(const char* input, short n))> a =  // NOLINT
+      InvokeArgument<0>(static_cast<const char*>("Hi"), Short(1));
+  EXPECT_STREQ("i", a.Perform(make_tuple(&Binary)));
+}
+
+// Tests using InvokeArgument with a function that takes a const char*
+// by passing it a C-string literal.
+TEST(InvokeArgumentTest, FunctionWithCStringLiteral) {
+  Action<const char*(const char*(*)(const char* input, short n))> a =  // NOLINT
+      InvokeArgument<0>("Hi", Short(1));
+  EXPECT_STREQ("i", a.Perform(make_tuple(&Binary)));
+}
+
+// Tests using InvokeArgument with a function that takes a const reference.
+TEST(InvokeArgumentTest, ByConstReferenceFunction) {
+  Action<bool(bool(*function)(const string& s))> a =  // NOLINT
+      InvokeArgument<0>(string("Hi"));
+  // When action 'a' is constructed, it makes a copy of the temporary
+  // string object passed to it, so it's OK to use 'a' later, when the
+  // temporary object has already died.
+  EXPECT_TRUE(a.Perform(make_tuple(&ByConstRef)));
+}
+
+// Tests using InvokeArgument with ByRef() and a function that takes a
+// const reference.
+TEST(InvokeArgumentTest, ByExplicitConstReferenceFunction) {
+  Action<bool(bool(*)(const double& x))> a =  // NOLINT
+      InvokeArgument<0>(ByRef(g_double));
+  // The above line calls ByRef() on a const value.
+  EXPECT_TRUE(a.Perform(make_tuple(&ReferencesGlobalDouble)));
+
+  double x = 0;
+  a = InvokeArgument<0>(ByRef(x));  // This calls ByRef() on a non-const.
+  EXPECT_FALSE(a.Perform(make_tuple(&ReferencesGlobalDouble)));
+}
+
+// Tests using WithArgs and with an action that takes 1 argument.
+TEST(WithArgsTest, OneArg) {
+  Action<bool(double x, int n)> a = WithArgs<1>(Invoke(Unary));  // NOLINT
+  EXPECT_TRUE(a.Perform(make_tuple(1.5, -1)));
+  EXPECT_FALSE(a.Perform(make_tuple(1.5, 1)));
+}
+
+// Tests using WithArgs with an action that takes 2 arguments.
+TEST(WithArgsTest, TwoArgs) {
+  Action<const char*(const char* s, double x, short n)> a =
+      WithArgs<0, 2>(Invoke(Binary));
+  const char s[] = "Hello";
+  EXPECT_EQ(s + 2, a.Perform(make_tuple(CharPtr(s), 0.5, Short(2))));
+}
+
+// Tests using WithArgs with an action that takes 3 arguments.
+TEST(WithArgsTest, ThreeArgs) {
+  Action<int(int, double, char, short)> a =  // NOLINT
+      WithArgs<0, 2, 3>(Invoke(Ternary));
+  EXPECT_EQ(123, a.Perform(make_tuple(100, 6.5, Char(20), Short(3))));
+}
+
+// Tests using WithArgs with an action that takes 4 arguments.
+TEST(WithArgsTest, FourArgs) {
+  Action<string(const char*, const char*, double, const char*, const char*)> a =
+      WithArgs<4, 3, 1, 0>(Invoke(Concat4));
+  EXPECT_EQ("4310", a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), 2.5,
+                                         CharPtr("3"), CharPtr("4"))));
+}
+
+// Tests using WithArgs with an action that takes 5 arguments.
+TEST(WithArgsTest, FiveArgs) {
+  Action<string(const char*, const char*, const char*,
+                const char*, const char*)> a =
+      WithArgs<4, 3, 2, 1, 0>(Invoke(Concat5));
+  EXPECT_EQ("43210",
+            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
+                                 CharPtr("3"), CharPtr("4"))));
+}
+
+// Tests using WithArgs with an action that takes 6 arguments.
+TEST(WithArgsTest, SixArgs) {
+  Action<string(const char*, const char*, const char*)> a =
+      WithArgs<0, 1, 2, 2, 1, 0>(Invoke(Concat6));
+  EXPECT_EQ("012210",
+            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"))));
+}
+
+// Tests using WithArgs with an action that takes 7 arguments.
+TEST(WithArgsTest, SevenArgs) {
+  Action<string(const char*, const char*, const char*, const char*)> a =
+      WithArgs<0, 1, 2, 3, 2, 1, 0>(Invoke(Concat7));
+  EXPECT_EQ("0123210",
+            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
+                                 CharPtr("3"))));
+}
+
+// Tests using WithArgs with an action that takes 8 arguments.
+TEST(WithArgsTest, EightArgs) {
+  Action<string(const char*, const char*, const char*, const char*)> a =
+      WithArgs<0, 1, 2, 3, 0, 1, 2, 3>(Invoke(Concat8));
+  EXPECT_EQ("01230123",
+            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
+                                 CharPtr("3"))));
+}
+
+// Tests using WithArgs with an action that takes 9 arguments.
+TEST(WithArgsTest, NineArgs) {
+  Action<string(const char*, const char*, const char*, const char*)> a =
+      WithArgs<0, 1, 2, 3, 1, 2, 3, 2, 3>(Invoke(Concat9));
+  EXPECT_EQ("012312323",
+            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
+                                 CharPtr("3"))));
+}
+
+// Tests using WithArgs with an action that takes 10 arguments.
+TEST(WithArgsTest, TenArgs) {
+  Action<string(const char*, const char*, const char*, const char*)> a =
+      WithArgs<0, 1, 2, 3, 2, 1, 0, 1, 2, 3>(Invoke(Concat10));
+  EXPECT_EQ("0123210123",
+            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
+                                 CharPtr("3"))));
+}
+
+// Tests using WithArgs with an action that is not Invoke().
+class SubstractAction : public ActionInterface<int(int, int)> {  // NOLINT
+ public:
+  virtual int Perform(const tuple<int, int>& args) {
+    return get<0>(args) - get<1>(args);
+  }
+};
+
+TEST(WithArgsTest, NonInvokeAction) {
+  Action<int(const string&, int, int)> a =  // NOLINT
+      WithArgs<2, 1>(MakeAction(new SubstractAction));
+  string s("hello");
+  EXPECT_EQ(8, a.Perform(tuple<const string&, int, int>(s, 2, 10)));
+}
+
+// Tests using WithArgs to pass all original arguments in the original order.
+TEST(WithArgsTest, Identity) {
+  Action<int(int x, char y, short z)> a =  // NOLINT
+      WithArgs<0, 1, 2>(Invoke(Ternary));
+  EXPECT_EQ(123, a.Perform(make_tuple(100, Char(20), Short(3))));
+}
+
+// Tests using WithArgs with repeated arguments.
+TEST(WithArgsTest, RepeatedArguments) {
+  Action<int(bool, int m, int n)> a =  // NOLINT
+      WithArgs<1, 1, 1, 1>(Invoke(SumOf4));
+  EXPECT_EQ(4, a.Perform(make_tuple(false, 1, 10)));
+}
+
+// Tests using WithArgs with reversed argument order.
+TEST(WithArgsTest, ReversedArgumentOrder) {
+  Action<const char*(short n, const char* input)> a =  // NOLINT
+      WithArgs<1, 0>(Invoke(Binary));
+  const char s[] = "Hello";
+  EXPECT_EQ(s + 2, a.Perform(make_tuple(Short(2), CharPtr(s))));
+}
+
+// Tests using WithArgs with compatible, but not identical, argument types.
+TEST(WithArgsTest, ArgsOfCompatibleTypes) {
+  Action<long(short x, char y, double z, char c)> a =  // NOLINT
+      WithArgs<0, 1, 3>(Invoke(Ternary));
+  EXPECT_EQ(123, a.Perform(make_tuple(Short(100), Char(20), 5.6, Char(3))));
+}
+
+// Tests using WithArgs with an action that returns void.
+TEST(WithArgsTest, VoidAction) {
+  Action<void(double x, char c, int n)> a = WithArgs<2, 1>(Invoke(VoidBinary));
+  g_done = false;
+  a.Perform(make_tuple(1.5, 'a', 3));
+  EXPECT_TRUE(g_done);
+}
+
+// Tests DoAll(a1, a2).
+TEST(DoAllTest, TwoActions) {
+  int n = 0;
+  Action<int(int*)> a = DoAll(SetArgPointee<0>(1),  // NOLINT
+                              Return(2));
+  EXPECT_EQ(2, a.Perform(make_tuple(&n)));
+  EXPECT_EQ(1, n);
+}
+
+// Tests DoAll(a1, a2, a3).
+TEST(DoAllTest, ThreeActions) {
+  int m = 0, n = 0;
+  Action<int(int*, int*)> a = DoAll(SetArgPointee<0>(1),  // NOLINT
+                                    SetArgPointee<1>(2),
+                                    Return(3));
+  EXPECT_EQ(3, a.Perform(make_tuple(&m, &n)));
+  EXPECT_EQ(1, m);
+  EXPECT_EQ(2, n);
+}
+
+// Tests DoAll(a1, a2, a3, a4).
+TEST(DoAllTest, FourActions) {
+  int m = 0, n = 0;
+  char ch = '\0';
+  Action<int(int*, int*, char*)> a =  // NOLINT
+      DoAll(SetArgPointee<0>(1),
+            SetArgPointee<1>(2),
+            SetArgPointee<2>('a'),
+            Return(3));
+  EXPECT_EQ(3, a.Perform(make_tuple(&m, &n, &ch)));
+  EXPECT_EQ(1, m);
+  EXPECT_EQ(2, n);
+  EXPECT_EQ('a', ch);
+}
+
+// Tests DoAll(a1, a2, a3, a4, a5).
+TEST(DoAllTest, FiveActions) {
+  int m = 0, n = 0;
+  char a = '\0', b = '\0';
+  Action<int(int*, int*, char*, char*)> action =  // NOLINT
+      DoAll(SetArgPointee<0>(1),
+            SetArgPointee<1>(2),
+            SetArgPointee<2>('a'),
+            SetArgPointee<3>('b'),
+            Return(3));
+  EXPECT_EQ(3, action.Perform(make_tuple(&m, &n, &a, &b)));
+  EXPECT_EQ(1, m);
+  EXPECT_EQ(2, n);
+  EXPECT_EQ('a', a);
+  EXPECT_EQ('b', b);
+}
+
+// Tests DoAll(a1, a2, ..., a6).
+TEST(DoAllTest, SixActions) {
+  int m = 0, n = 0;
+  char a = '\0', b = '\0', c = '\0';
+  Action<int(int*, int*, char*, char*, char*)> action =  // NOLINT
+      DoAll(SetArgPointee<0>(1),
+            SetArgPointee<1>(2),
+            SetArgPointee<2>('a'),
+            SetArgPointee<3>('b'),
+            SetArgPointee<4>('c'),
+            Return(3));
+  EXPECT_EQ(3, action.Perform(make_tuple(&m, &n, &a, &b, &c)));
+  EXPECT_EQ(1, m);
+  EXPECT_EQ(2, n);
+  EXPECT_EQ('a', a);
+  EXPECT_EQ('b', b);
+  EXPECT_EQ('c', c);
+}
+
+// Tests DoAll(a1, a2, ..., a7).
+TEST(DoAllTest, SevenActions) {
+  int m = 0, n = 0;
+  char a = '\0', b = '\0', c = '\0', d = '\0';
+  Action<int(int*, int*, char*, char*, char*, char*)> action =  // NOLINT
+      DoAll(SetArgPointee<0>(1),
+            SetArgPointee<1>(2),
+            SetArgPointee<2>('a'),
+            SetArgPointee<3>('b'),
+            SetArgPointee<4>('c'),
+            SetArgPointee<5>('d'),
+            Return(3));
+  EXPECT_EQ(3, action.Perform(make_tuple(&m, &n, &a, &b, &c, &d)));
+  EXPECT_EQ(1, m);
+  EXPECT_EQ(2, n);
+  EXPECT_EQ('a', a);
+  EXPECT_EQ('b', b);
+  EXPECT_EQ('c', c);
+  EXPECT_EQ('d', d);
+}
+
+// Tests DoAll(a1, a2, ..., a8).
+TEST(DoAllTest, EightActions) {
+  int m = 0, n = 0;
+  char a = '\0', b = '\0', c = '\0', d = '\0', e = '\0';
+  Action<int(int*, int*, char*, char*, char*, char*,  // NOLINT
+             char*)> action =
+      DoAll(SetArgPointee<0>(1),
+            SetArgPointee<1>(2),
+            SetArgPointee<2>('a'),
+            SetArgPointee<3>('b'),
+            SetArgPointee<4>('c'),
+            SetArgPointee<5>('d'),
+            SetArgPointee<6>('e'),
+            Return(3));
+  EXPECT_EQ(3, action.Perform(make_tuple(&m, &n, &a, &b, &c, &d, &e)));
+  EXPECT_EQ(1, m);
+  EXPECT_EQ(2, n);
+  EXPECT_EQ('a', a);
+  EXPECT_EQ('b', b);
+  EXPECT_EQ('c', c);
+  EXPECT_EQ('d', d);
+  EXPECT_EQ('e', e);
+}
+
+// Tests DoAll(a1, a2, ..., a9).
+TEST(DoAllTest, NineActions) {
+  int m = 0, n = 0;
+  char a = '\0', b = '\0', c = '\0', d = '\0', e = '\0', f = '\0';
+  Action<int(int*, int*, char*, char*, char*, char*,  // NOLINT
+             char*, char*)> action =
+      DoAll(SetArgPointee<0>(1),
+            SetArgPointee<1>(2),
+            SetArgPointee<2>('a'),
+            SetArgPointee<3>('b'),
+            SetArgPointee<4>('c'),
+            SetArgPointee<5>('d'),
+            SetArgPointee<6>('e'),
+            SetArgPointee<7>('f'),
+            Return(3));
+  EXPECT_EQ(3, action.Perform(make_tuple(&m, &n, &a, &b, &c, &d, &e, &f)));
+  EXPECT_EQ(1, m);
+  EXPECT_EQ(2, n);
+  EXPECT_EQ('a', a);
+  EXPECT_EQ('b', b);
+  EXPECT_EQ('c', c);
+  EXPECT_EQ('d', d);
+  EXPECT_EQ('e', e);
+  EXPECT_EQ('f', f);
+}
+
+// Tests DoAll(a1, a2, ..., a10).
+TEST(DoAllTest, TenActions) {
+  int m = 0, n = 0;
+  char a = '\0', b = '\0', c = '\0', d = '\0';
+  char e = '\0', f = '\0', g = '\0';
+  Action<int(int*, int*, char*, char*, char*, char*,  // NOLINT
+             char*, char*, char*)> action =
+      DoAll(SetArgPointee<0>(1),
+            SetArgPointee<1>(2),
+            SetArgPointee<2>('a'),
+            SetArgPointee<3>('b'),
+            SetArgPointee<4>('c'),
+            SetArgPointee<5>('d'),
+            SetArgPointee<6>('e'),
+            SetArgPointee<7>('f'),
+            SetArgPointee<8>('g'),
+            Return(3));
+  EXPECT_EQ(3, action.Perform(make_tuple(&m, &n, &a, &b, &c, &d, &e, &f, &g)));
+  EXPECT_EQ(1, m);
+  EXPECT_EQ(2, n);
+  EXPECT_EQ('a', a);
+  EXPECT_EQ('b', b);
+  EXPECT_EQ('c', c);
+  EXPECT_EQ('d', d);
+  EXPECT_EQ('e', e);
+  EXPECT_EQ('f', f);
+  EXPECT_EQ('g', g);
+}
+
+// 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
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+// Tests the ACTION*() macro family.
+
+// Tests that ACTION() can define an action that doesn't reference the
+// mock function arguments.
+ACTION(Return5) { return 5; }
+
+TEST(ActionMacroTest, WorksWhenNotReferencingArguments) {
+  Action<double()> a1 = Return5();
+  EXPECT_DOUBLE_EQ(5, a1.Perform(make_tuple()));
+
+  Action<int(double, bool)> a2 = Return5();
+  EXPECT_EQ(5, a2.Perform(make_tuple(1, true)));
+}
+
+// Tests that ACTION() can define an action that returns void.
+ACTION(IncrementArg1) { (*arg1)++; }
+
+TEST(ActionMacroTest, WorksWhenReturningVoid) {
+  Action<void(int, int*)> a1 = IncrementArg1();
+  int n = 0;
+  a1.Perform(make_tuple(5, &n));
+  EXPECT_EQ(1, n);
+}
+
+// Tests that the body of ACTION() can reference the type of the
+// argument.
+ACTION(IncrementArg2) {
+  StaticAssertTypeEq<int*, arg2_type>();
+  arg2_type temp = arg2;
+  (*temp)++;
+}
+
+TEST(ActionMacroTest, CanReferenceArgumentType) {
+  Action<void(int, bool, int*)> a1 = IncrementArg2();
+  int n = 0;
+  a1.Perform(make_tuple(5, false, &n));
+  EXPECT_EQ(1, n);
+}
+
+// Tests that the body of ACTION() can reference the argument tuple
+// via args_type and args.
+ACTION(Sum2) {
+  StaticAssertTypeEq<tuple<int, char, int*>, args_type>();
+  args_type args_copy = args;
+  return get<0>(args_copy) + get<1>(args_copy);
+}
+
+TEST(ActionMacroTest, CanReferenceArgumentTuple) {
+  Action<int(int, char, int*)> a1 = Sum2();
+  int dummy = 0;
+  EXPECT_EQ(11, a1.Perform(make_tuple(5, Char(6), &dummy)));
+}
+
+// Tests that the body of ACTION() can reference the mock function
+// type.
+int Dummy(bool flag) { return flag? 1 : 0; }
+
+ACTION(InvokeDummy) {
+  StaticAssertTypeEq<int(bool), function_type>();
+  function_type* fp = &Dummy;
+  return (*fp)(true);
+}
+
+TEST(ActionMacroTest, CanReferenceMockFunctionType) {
+  Action<int(bool)> a1 = InvokeDummy();
+  EXPECT_EQ(1, a1.Perform(make_tuple(true)));
+  EXPECT_EQ(1, a1.Perform(make_tuple(false)));
+}
+
+// Tests that the body of ACTION() can reference the mock function's
+// return type.
+ACTION(InvokeDummy2) {
+  StaticAssertTypeEq<int, return_type>();
+  return_type result = Dummy(true);
+  return result;
+}
+
+TEST(ActionMacroTest, CanReferenceMockFunctionReturnType) {
+  Action<int(bool)> a1 = InvokeDummy2();
+  EXPECT_EQ(1, a1.Perform(make_tuple(true)));
+  EXPECT_EQ(1, a1.Perform(make_tuple(false)));
+}
+
+// Tests that ACTION() works for arguments passed by const reference.
+ACTION(ReturnAddrOfConstBoolReferenceArg) {
+  StaticAssertTypeEq<const bool&, arg1_type>();
+  return &arg1;
+}
+
+TEST(ActionMacroTest, WorksForConstReferenceArg) {
+  Action<const bool*(int, const bool&)> a = ReturnAddrOfConstBoolReferenceArg();
+  const bool b = false;
+  EXPECT_EQ(&b, a.Perform(tuple<int, const bool&>(0, b)));
+}
+
+// Tests that ACTION() works for arguments passed by non-const reference.
+ACTION(ReturnAddrOfIntReferenceArg) {
+  StaticAssertTypeEq<int&, arg0_type>();
+  return &arg0;
+}
+
+TEST(ActionMacroTest, WorksForNonConstReferenceArg) {
+  Action<int*(int&, bool, int)> a = ReturnAddrOfIntReferenceArg();
+  int n = 0;
+  EXPECT_EQ(&n, a.Perform(tuple<int&, bool, int>(n, true, 1)));
+}
+
+// Tests that ACTION() can be used in a namespace.
+namespace action_test {
+ACTION(Sum) { return arg0 + arg1; }
+}  // namespace action_test
+
+TEST(ActionMacroTest, WorksInNamespace) {
+  Action<int(int, int)> a1 = action_test::Sum();
+  EXPECT_EQ(3, a1.Perform(make_tuple(1, 2)));
+}
+
+// Tests that the same ACTION definition works for mock functions with
+// different argument numbers.
+ACTION(PlusTwo) { return arg0 + 2; }
+
+TEST(ActionMacroTest, WorksForDifferentArgumentNumbers) {
+  Action<int(int)> a1 = PlusTwo();
+  EXPECT_EQ(4, a1.Perform(make_tuple(2)));
+
+  Action<double(float, void*)> a2 = PlusTwo();
+  int dummy;
+  EXPECT_DOUBLE_EQ(6, a2.Perform(make_tuple(4.0f, &dummy)));
+}
+
+// Tests that ACTION_P can define a parameterized action.
+ACTION_P(Plus, n) { return arg0 + n; }
+
+TEST(ActionPMacroTest, DefinesParameterizedAction) {
+  Action<int(int m, bool t)> a1 = Plus(9);
+  EXPECT_EQ(10, a1.Perform(make_tuple(1, true)));
+}
+
+// Tests that the body of ACTION_P can reference the argument types
+// and the parameter type.
+ACTION_P(TypedPlus, n) {
+  arg0_type t1 = arg0;
+  n_type t2 = n;
+  return t1 + t2;
+}
+
+TEST(ActionPMacroTest, CanReferenceArgumentAndParameterTypes) {
+  Action<int(char m, bool t)> a1 = TypedPlus(9);
+  EXPECT_EQ(10, a1.Perform(make_tuple(Char(1), true)));
+}
+
+// Tests that a parameterized action can be used in any mock function
+// whose type is compatible.
+TEST(ActionPMacroTest, WorksInCompatibleMockFunction) {
+  Action<std::string(const std::string& s)> a1 = Plus("tail");
+  const std::string re = "re";
+  EXPECT_EQ("retail", a1.Perform(tuple<const std::string&>(re)));
+}
+
+// Tests that we can use ACTION*() to define actions overloaded on the
+// number of parameters.
+
+ACTION(OverloadedAction) { return arg0 ? arg1 : "hello"; }
+
+ACTION_P(OverloadedAction, default_value) {
+  return arg0 ? arg1 : default_value;
+}
+
+ACTION_P2(OverloadedAction, true_value, false_value) {
+  return arg0 ? true_value : false_value;
+}
+
+TEST(ActionMacroTest, CanDefineOverloadedActions) {
+  typedef Action<const char*(bool, const char*)> MyAction;
+
+  const MyAction a1 = OverloadedAction();
+  EXPECT_STREQ("hello", a1.Perform(make_tuple(false, CharPtr("world"))));
+  EXPECT_STREQ("world", a1.Perform(make_tuple(true, CharPtr("world"))));
+
+  const MyAction a2 = OverloadedAction("hi");
+  EXPECT_STREQ("hi", a2.Perform(make_tuple(false, CharPtr("world"))));
+  EXPECT_STREQ("world", a2.Perform(make_tuple(true, CharPtr("world"))));
+
+  const MyAction a3 = OverloadedAction("hi", "you");
+  EXPECT_STREQ("hi", a3.Perform(make_tuple(true, CharPtr("world"))));
+  EXPECT_STREQ("you", a3.Perform(make_tuple(false, CharPtr("world"))));
+}
+
+// Tests ACTION_Pn where n >= 3.
+
+ACTION_P3(Plus, m, n, k) { return arg0 + m + n + k; }
+
+TEST(ActionPnMacroTest, WorksFor3Parameters) {
+  Action<double(int m, bool t)> a1 = Plus(100, 20, 3.4);
+  EXPECT_DOUBLE_EQ(3123.4, a1.Perform(make_tuple(3000, true)));
+
+  Action<std::string(const std::string& s)> a2 = Plus("tail", "-", ">");
+  const std::string re = "re";
+  EXPECT_EQ("retail->", a2.Perform(tuple<const std::string&>(re)));
+}
+
+ACTION_P4(Plus, p0, p1, p2, p3) { return arg0 + p0 + p1 + p2 + p3; }
+
+TEST(ActionPnMacroTest, WorksFor4Parameters) {
+  Action<int(int)> a1 = Plus(1, 2, 3, 4);
+  EXPECT_EQ(10 + 1 + 2 + 3 + 4, a1.Perform(make_tuple(10)));
+}
+
+ACTION_P5(Plus, p0, p1, p2, p3, p4) { return arg0 + p0 + p1 + p2 + p3 + p4; }
+
+TEST(ActionPnMacroTest, WorksFor5Parameters) {
+  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5);
+  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5, a1.Perform(make_tuple(10)));
+}
+
+ACTION_P6(Plus, p0, p1, p2, p3, p4, p5) {
+  return arg0 + p0 + p1 + p2 + p3 + p4 + p5;
+}
+
+TEST(ActionPnMacroTest, WorksFor6Parameters) {
+  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6);
+  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6, a1.Perform(make_tuple(10)));
+}
+
+ACTION_P7(Plus, p0, p1, p2, p3, p4, p5, p6) {
+  return arg0 + p0 + p1 + p2 + p3 + p4 + p5 + p6;
+}
+
+TEST(ActionPnMacroTest, WorksFor7Parameters) {
+  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7);
+  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7, a1.Perform(make_tuple(10)));
+}
+
+ACTION_P8(Plus, p0, p1, p2, p3, p4, p5, p6, p7) {
+  return arg0 + p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7;
+}
+
+TEST(ActionPnMacroTest, WorksFor8Parameters) {
+  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7, 8);
+  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8, a1.Perform(make_tuple(10)));
+}
+
+ACTION_P9(Plus, p0, p1, p2, p3, p4, p5, p6, p7, p8) {
+  return arg0 + p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8;
+}
+
+TEST(ActionPnMacroTest, WorksFor9Parameters) {
+  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7, 8, 9);
+  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9, a1.Perform(make_tuple(10)));
+}
+
+ACTION_P10(Plus, p0, p1, p2, p3, p4, p5, p6, p7, p8, last_param) {
+  arg0_type t0 = arg0;
+  last_param_type t9 = last_param;
+  return t0 + p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + t9;
+}
+
+TEST(ActionPnMacroTest, WorksFor10Parameters) {
+  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10,
+            a1.Perform(make_tuple(10)));
+}
+
+// Tests that the action body can promote the parameter types.
+
+ACTION_P2(PadArgument, prefix, suffix) {
+  // The following lines promote the two parameters to desired types.
+  std::string prefix_str(prefix);
+  char suffix_char = static_cast<char>(suffix);
+  return prefix_str + arg0 + suffix_char;
+}
+
+TEST(ActionPnMacroTest, SimpleTypePromotion) {
+  Action<std::string(const char*)> no_promo =
+      PadArgument(std::string("foo"), 'r');
+  Action<std::string(const char*)> promo =
+      PadArgument("foo", static_cast<int>('r'));
+  EXPECT_EQ("foobar", no_promo.Perform(make_tuple(CharPtr("ba"))));
+  EXPECT_EQ("foobar", promo.Perform(make_tuple(CharPtr("ba"))));
+}
+
+// Tests that we can partially restrict parameter types using a
+// straight-forward pattern.
+
+// Defines a generic action that doesn't restrict the types of its
+// parameters.
+ACTION_P3(ConcatImpl, a, b, c) {
+  std::stringstream ss;
+  ss << a << b << c;
+  return ss.str();
+}
+
+// Next, we try to restrict that either the first parameter is a
+// string, or the second parameter is an int.
+
+// Defines a partially specialized wrapper that restricts the first
+// parameter to std::string.
+template <typename T1, typename T2>
+// ConcatImplActionP3 is the class template ACTION_P3 uses to
+// implement ConcatImpl.  We shouldn't change the name as this
+// pattern requires the user to use it directly.
+ConcatImplActionP3<std::string, T1, T2>
+Concat(const std::string& a, T1 b, T2 c) {
+  GTEST_INTENTIONAL_CONST_COND_PUSH_()
+  if (true) {
+  GTEST_INTENTIONAL_CONST_COND_POP_()
+    // This branch verifies that ConcatImpl() can be invoked without
+    // explicit template arguments.
+    return ConcatImpl(a, b, c);
+  } else {
+    // This branch verifies that ConcatImpl() can also be invoked with
+    // explicit template arguments.  It doesn't really need to be
+    // executed as this is a compile-time verification.
+    return ConcatImpl<std::string, T1, T2>(a, b, c);
+  }
+}
+
+// Defines another partially specialized wrapper that restricts the
+// second parameter to int.
+template <typename T1, typename T2>
+ConcatImplActionP3<T1, int, T2>
+Concat(T1 a, int b, T2 c) {
+  return ConcatImpl(a, b, c);
+}
+
+TEST(ActionPnMacroTest, CanPartiallyRestrictParameterTypes) {
+  Action<const std::string()> a1 = Concat("Hello", "1", 2);
+  EXPECT_EQ("Hello12", a1.Perform(make_tuple()));
+
+  a1 = Concat(1, 2, 3);
+  EXPECT_EQ("123", a1.Perform(make_tuple()));
+}
+
+// Verifies the type of an ACTION*.
+
+ACTION(DoFoo) {}
+ACTION_P(DoFoo, p) {}
+ACTION_P2(DoFoo, p0, p1) {}
+
+TEST(ActionPnMacroTest, TypesAreCorrect) {
+  // DoFoo() must be assignable to a DoFooAction variable.
+  DoFooAction a0 = DoFoo();
+
+  // DoFoo(1) must be assignable to a DoFooActionP variable.
+  DoFooActionP<int> a1 = DoFoo(1);
+
+  // DoFoo(p1, ..., pk) must be assignable to a DoFooActionPk
+  // variable, and so on.
+  DoFooActionP2<int, char> a2 = DoFoo(1, '2');
+  PlusActionP3<int, int, char> a3 = Plus(1, 2, '3');
+  PlusActionP4<int, int, int, char> a4 = Plus(1, 2, 3, '4');
+  PlusActionP5<int, int, int, int, char> a5 = Plus(1, 2, 3, 4, '5');
+  PlusActionP6<int, int, int, int, int, char> a6 = Plus(1, 2, 3, 4, 5, '6');
+  PlusActionP7<int, int, int, int, int, int, char> a7 =
+      Plus(1, 2, 3, 4, 5, 6, '7');
+  PlusActionP8<int, int, int, int, int, int, int, char> a8 =
+      Plus(1, 2, 3, 4, 5, 6, 7, '8');
+  PlusActionP9<int, int, int, int, int, int, int, int, char> a9 =
+      Plus(1, 2, 3, 4, 5, 6, 7, 8, '9');
+  PlusActionP10<int, int, int, int, int, int, int, int, int, char> a10 =
+      Plus(1, 2, 3, 4, 5, 6, 7, 8, 9, '0');
+
+  // Avoid "unused variable" warnings.
+  (void)a0;
+  (void)a1;
+  (void)a2;
+  (void)a3;
+  (void)a4;
+  (void)a5;
+  (void)a6;
+  (void)a7;
+  (void)a8;
+  (void)a9;
+  (void)a10;
+}
+
+// Tests that an ACTION_P*() action can be explicitly instantiated
+// with reference-typed parameters.
+
+ACTION_P(Plus1, x) { return x; }
+ACTION_P2(Plus2, x, y) { return x + y; }
+ACTION_P3(Plus3, x, y, z) { return x + y + z; }
+ACTION_P10(Plus10, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+  return a0 + a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9;
+}
+
+TEST(ActionPnMacroTest, CanExplicitlyInstantiateWithReferenceTypes) {
+  int x = 1, y = 2, z = 3;
+  const tuple<> empty = make_tuple();
+
+  Action<int()> a = Plus1<int&>(x);
+  EXPECT_EQ(1, a.Perform(empty));
+
+  a = Plus2<const int&, int&>(x, y);
+  EXPECT_EQ(3, a.Perform(empty));
+
+  a = Plus3<int&, const int&, int&>(x, y, z);
+  EXPECT_EQ(6, a.Perform(empty));
+
+  int n[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+  a = Plus10<const int&, int&, const int&, int&, const int&, int&, const int&,
+      int&, const int&, int&>(n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7],
+                              n[8], n[9]);
+  EXPECT_EQ(55, a.Perform(empty));
+}
+
+class NullaryConstructorClass {
+ public:
+  NullaryConstructorClass() : value_(123) {}
+  int value_;
+};
+
+// Tests using ReturnNew() with a nullary constructor.
+TEST(ReturnNewTest, NoArgs) {
+  Action<NullaryConstructorClass*()> a = ReturnNew<NullaryConstructorClass>();
+  NullaryConstructorClass* c = a.Perform(make_tuple());
+  EXPECT_EQ(123, c->value_);
+  delete c;
+}
+
+class UnaryConstructorClass {
+ public:
+  explicit UnaryConstructorClass(int value) : value_(value) {}
+  int value_;
+};
+
+// Tests using ReturnNew() with a unary constructor.
+TEST(ReturnNewTest, Unary) {
+  Action<UnaryConstructorClass*()> a = ReturnNew<UnaryConstructorClass>(4000);
+  UnaryConstructorClass* c = a.Perform(make_tuple());
+  EXPECT_EQ(4000, c->value_);
+  delete c;
+}
+
+TEST(ReturnNewTest, UnaryWorksWhenMockMethodHasArgs) {
+  Action<UnaryConstructorClass*(bool, int)> a =
+      ReturnNew<UnaryConstructorClass>(4000);
+  UnaryConstructorClass* c = a.Perform(make_tuple(false, 5));
+  EXPECT_EQ(4000, c->value_);
+  delete c;
+}
+
+TEST(ReturnNewTest, UnaryWorksWhenMockMethodReturnsPointerToConst) {
+  Action<const UnaryConstructorClass*()> a =
+      ReturnNew<UnaryConstructorClass>(4000);
+  const UnaryConstructorClass* c = a.Perform(make_tuple());
+  EXPECT_EQ(4000, c->value_);
+  delete c;
+}
+
+class TenArgConstructorClass {
+ public:
+  TenArgConstructorClass(int a1, int a2, int a3, int a4, int a5,
+                         int a6, int a7, int a8, int a9, int a10)
+    : value_(a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10) {
+  }
+  int value_;
+};
+
+// Tests using ReturnNew() with a 10-argument constructor.
+TEST(ReturnNewTest, ConstructorThatTakes10Arguments) {
+  Action<TenArgConstructorClass*()> a =
+      ReturnNew<TenArgConstructorClass>(1000000000, 200000000, 30000000,
+                                        4000000, 500000, 60000,
+                                        7000, 800, 90, 0);
+  TenArgConstructorClass* c = a.Perform(make_tuple());
+  EXPECT_EQ(1234567890, c->value_);
+  delete c;
+}
+
+// Tests that ACTION_TEMPLATE works when there is no value parameter.
+ACTION_TEMPLATE(CreateNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_0_VALUE_PARAMS()) {
+  return new T;
+}
+
+TEST(ActionTemplateTest, WorksWithoutValueParam) {
+  const Action<int*()> a = CreateNew<int>();
+  int* p = a.Perform(make_tuple());
+  delete p;
+}
+
+// Tests that ACTION_TEMPLATE works when there are value parameters.
+ACTION_TEMPLATE(CreateNew,
+                HAS_1_TEMPLATE_PARAMS(typename, T),
+                AND_1_VALUE_PARAMS(a0)) {
+  return new T(a0);
+}
+
+TEST(ActionTemplateTest, WorksWithValueParams) {
+  const Action<int*()> a = CreateNew<int>(42);
+  int* p = a.Perform(make_tuple());
+  EXPECT_EQ(42, *p);
+  delete p;
+}
+
+// Tests that ACTION_TEMPLATE works for integral template parameters.
+ACTION_TEMPLATE(MyDeleteArg,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_0_VALUE_PARAMS()) {
+  delete get<k>(args);
+}
+
+// Resets a bool variable in the destructor.
+class BoolResetter {
+ public:
+  explicit BoolResetter(bool* value) : value_(value) {}
+  ~BoolResetter() { *value_ = false; }
+ private:
+  bool* value_;
+};
+
+TEST(ActionTemplateTest, WorksForIntegralTemplateParams) {
+  const Action<void(int*, BoolResetter*)> a = MyDeleteArg<1>();
+  int n = 0;
+  bool b = true;
+  BoolResetter* resetter = new BoolResetter(&b);
+  a.Perform(make_tuple(&n, resetter));
+  EXPECT_FALSE(b);  // Verifies that resetter is deleted.
+}
+
+// Tests that ACTION_TEMPLATES works for template template parameters.
+ACTION_TEMPLATE(ReturnSmartPointer,
+                HAS_1_TEMPLATE_PARAMS(template <typename Pointee> class,
+                                      Pointer),
+                AND_1_VALUE_PARAMS(pointee)) {
+  return Pointer<pointee_type>(new pointee_type(pointee));
+}
+
+TEST(ActionTemplateTest, WorksForTemplateTemplateParameters) {
+  using ::testing::internal::linked_ptr;
+  const Action<linked_ptr<int>()> a = ReturnSmartPointer<linked_ptr>(42);
+  linked_ptr<int> p = a.Perform(make_tuple());
+  EXPECT_EQ(42, *p);
+}
+
+// Tests that ACTION_TEMPLATE works for 10 template parameters.
+template <typename T1, typename T2, typename T3, int k4, bool k5,
+          unsigned int k6, typename T7, typename T8, typename T9>
+struct GiantTemplate {
+ public:
+  explicit GiantTemplate(int a_value) : value(a_value) {}
+  int value;
+};
+
+ACTION_TEMPLATE(ReturnGiant,
+                HAS_10_TEMPLATE_PARAMS(
+                    typename, T1,
+                    typename, T2,
+                    typename, T3,
+                    int, k4,
+                    bool, k5,
+                    unsigned int, k6,
+                    class, T7,
+                    class, T8,
+                    class, T9,
+                    template <typename T> class, T10),
+                AND_1_VALUE_PARAMS(value)) {
+  return GiantTemplate<T10<T1>, T2, T3, k4, k5, k6, T7, T8, T9>(value);
+}
+
+TEST(ActionTemplateTest, WorksFor10TemplateParameters) {
+  using ::testing::internal::linked_ptr;
+  typedef GiantTemplate<linked_ptr<int>, bool, double, 5,
+      true, 6, char, unsigned, int> Giant;
+  const Action<Giant()> a = ReturnGiant<
+      int, bool, double, 5, true, 6, char, unsigned, int, linked_ptr>(42);
+  Giant giant = a.Perform(make_tuple());
+  EXPECT_EQ(42, giant.value);
+}
+
+// Tests that ACTION_TEMPLATE works for 10 value parameters.
+ACTION_TEMPLATE(ReturnSum,
+                HAS_1_TEMPLATE_PARAMS(typename, Number),
+                AND_10_VALUE_PARAMS(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)) {
+  return static_cast<Number>(v1) + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10;
+}
+
+TEST(ActionTemplateTest, WorksFor10ValueParameters) {
+  const Action<int()> a = ReturnSum<int>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+  EXPECT_EQ(55, a.Perform(make_tuple()));
+}
+
+// Tests that ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded
+// on the number of value parameters.
+
+ACTION(ReturnSum) { return 0; }
+
+ACTION_P(ReturnSum, x) { return x; }
+
+ACTION_TEMPLATE(ReturnSum,
+                HAS_1_TEMPLATE_PARAMS(typename, Number),
+                AND_2_VALUE_PARAMS(v1, v2)) {
+  return static_cast<Number>(v1) + v2;
+}
+
+ACTION_TEMPLATE(ReturnSum,
+                HAS_1_TEMPLATE_PARAMS(typename, Number),
+                AND_3_VALUE_PARAMS(v1, v2, v3)) {
+  return static_cast<Number>(v1) + v2 + v3;
+}
+
+ACTION_TEMPLATE(ReturnSum,
+                HAS_2_TEMPLATE_PARAMS(typename, Number, int, k),
+                AND_4_VALUE_PARAMS(v1, v2, v3, v4)) {
+  return static_cast<Number>(v1) + v2 + v3 + v4 + k;
+}
+
+TEST(ActionTemplateTest, CanBeOverloadedOnNumberOfValueParameters) {
+  const Action<int()> a0 = ReturnSum();
+  const Action<int()> a1 = ReturnSum(1);
+  const Action<int()> a2 = ReturnSum<int>(1, 2);
+  const Action<int()> a3 = ReturnSum<int>(1, 2, 3);
+  const Action<int()> a4 = ReturnSum<int, 10000>(2000, 300, 40, 5);
+  EXPECT_EQ(0, a0.Perform(make_tuple()));
+  EXPECT_EQ(1, a1.Perform(make_tuple()));
+  EXPECT_EQ(3, a2.Perform(make_tuple()));
+  EXPECT_EQ(6, a3.Perform(make_tuple()));
+  EXPECT_EQ(12345, a4.Perform(make_tuple()));
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace gmock_generated_actions_test
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-function-mockers_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-function-mockers_test.cc
new file mode 100644
index 00000000..a86a6135
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-function-mockers_test.cc
@@ -0,0 +1,622 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests the function mocker classes.
+
+#include "gmock/gmock-generated-function-mockers.h"
+
+#if GTEST_OS_WINDOWS
+// MSDN says the header file to be included for STDMETHOD is BaseTyps.h but
+// we are getting compiler errors if we use basetyps.h, hence including
+// objbase.h for definition of STDMETHOD.
+# include <objbase.h>
+#endif  // GTEST_OS_WINDOWS
+
+#include <map>
+#include <string>
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+// There is a bug in MSVC (fixed in VS 2008) that prevents creating a
+// mock for a function with const arguments, so we don't test such
+// cases for MSVC versions older than 2008.
+#if !GTEST_OS_WINDOWS || (_MSC_VER >= 1500)
+# define GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
+#endif  // !GTEST_OS_WINDOWS || (_MSC_VER >= 1500)
+
+namespace testing {
+namespace gmock_generated_function_mockers_test {
+
+using testing::internal::string;
+using testing::_;
+using testing::A;
+using testing::An;
+using testing::AnyNumber;
+using testing::Const;
+using testing::DoDefault;
+using testing::Eq;
+using testing::Lt;
+using testing::MockFunction;
+using testing::Ref;
+using testing::Return;
+using testing::ReturnRef;
+using testing::TypedEq;
+
+class FooInterface {
+ public:
+  virtual ~FooInterface() {}
+
+  virtual void VoidReturning(int x) = 0;
+
+  virtual int Nullary() = 0;
+  virtual bool Unary(int x) = 0;
+  virtual long Binary(short x, int y) = 0;  // NOLINT
+  virtual int Decimal(bool b, char c, short d, int e, long f,  // NOLINT
+                      float g, double h, unsigned i, char* j, const string& k)
+      = 0;
+
+  virtual bool TakesNonConstReference(int& n) = 0;  // NOLINT
+  virtual string TakesConstReference(const int& n) = 0;
+#ifdef GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
+  virtual bool TakesConst(const int x) = 0;
+#endif  // GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
+
+  virtual int OverloadedOnArgumentNumber() = 0;
+  virtual int OverloadedOnArgumentNumber(int n) = 0;
+
+  virtual int OverloadedOnArgumentType(int n) = 0;
+  virtual char OverloadedOnArgumentType(char c) = 0;
+
+  virtual int OverloadedOnConstness() = 0;
+  virtual char OverloadedOnConstness() const = 0;
+
+  virtual int TypeWithHole(int (*func)()) = 0;
+  virtual int TypeWithComma(const std::map<int, string>& a_map) = 0;
+
+#if GTEST_OS_WINDOWS
+  STDMETHOD_(int, CTNullary)() = 0;
+  STDMETHOD_(bool, CTUnary)(int x) = 0;
+  STDMETHOD_(int, CTDecimal)(bool b, char c, short d, int e, long f,  // NOLINT
+      float g, double h, unsigned i, char* j, const string& k) = 0;
+  STDMETHOD_(char, CTConst)(int x) const = 0;
+#endif  // GTEST_OS_WINDOWS
+};
+
+// Const qualifiers on arguments were once (incorrectly) considered
+// significant in determining whether two virtual functions had the same
+// signature. This was fixed in Visual Studio 2008. However, the compiler
+// still emits a warning that alerts about this change in behavior.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable : 4373)
+#endif
+class MockFoo : public FooInterface {
+ public:
+  MockFoo() {}
+
+  // Makes sure that a mock function parameter can be named.
+  MOCK_METHOD1(VoidReturning, void(int n));  // NOLINT
+
+  MOCK_METHOD0(Nullary, int());  // NOLINT
+
+  // Makes sure that a mock function parameter can be unnamed.
+  MOCK_METHOD1(Unary, bool(int));  // NOLINT
+  MOCK_METHOD2(Binary, long(short, int));  // NOLINT
+  MOCK_METHOD10(Decimal, int(bool, char, short, int, long, float,  // NOLINT
+                             double, unsigned, char*, const string& str));
+
+  MOCK_METHOD1(TakesNonConstReference, bool(int&));  // NOLINT
+  MOCK_METHOD1(TakesConstReference, string(const int&));
+
+#ifdef GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
+  MOCK_METHOD1(TakesConst, bool(const int));  // NOLINT
+#endif
+
+  // Tests that the function return type can contain unprotected comma.
+  MOCK_METHOD0(ReturnTypeWithComma, std::map<int, string>());
+  MOCK_CONST_METHOD1(ReturnTypeWithComma,
+                     std::map<int, string>(int));  // NOLINT
+
+  MOCK_METHOD0(OverloadedOnArgumentNumber, int());  // NOLINT
+  MOCK_METHOD1(OverloadedOnArgumentNumber, int(int));  // NOLINT
+
+  MOCK_METHOD1(OverloadedOnArgumentType, int(int));  // NOLINT
+  MOCK_METHOD1(OverloadedOnArgumentType, char(char));  // NOLINT
+
+  MOCK_METHOD0(OverloadedOnConstness, int());  // NOLINT
+  MOCK_CONST_METHOD0(OverloadedOnConstness, char());  // NOLINT
+
+  MOCK_METHOD1(TypeWithHole, int(int (*)()));  // NOLINT
+  MOCK_METHOD1(TypeWithComma, int(const std::map<int, string>&));  // NOLINT
+
+#if GTEST_OS_WINDOWS
+  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTNullary, int());
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTUnary, bool(int));
+  MOCK_METHOD10_WITH_CALLTYPE(STDMETHODCALLTYPE, CTDecimal, int(bool b, char c,
+      short d, int e, long f, float g, double h, unsigned i, char* j,
+      const string& k));
+  MOCK_CONST_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTConst, char(int));
+
+  // Tests that the function return type can contain unprotected comma.
+  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTReturnTypeWithComma,
+                             std::map<int, string>());
+#endif  // GTEST_OS_WINDOWS
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
+};
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+class FunctionMockerTest : public testing::Test {
+ protected:
+  FunctionMockerTest() : foo_(&mock_foo_) {}
+
+  FooInterface* const foo_;
+  MockFoo mock_foo_;
+};
+
+// Tests mocking a void-returning function.
+TEST_F(FunctionMockerTest, MocksVoidFunction) {
+  EXPECT_CALL(mock_foo_, VoidReturning(Lt(100)));
+  foo_->VoidReturning(0);
+}
+
+// Tests mocking a nullary function.
+TEST_F(FunctionMockerTest, MocksNullaryFunction) {
+  EXPECT_CALL(mock_foo_, Nullary())
+      .WillOnce(DoDefault())
+      .WillOnce(Return(1));
+
+  EXPECT_EQ(0, foo_->Nullary());
+  EXPECT_EQ(1, foo_->Nullary());
+}
+
+// Tests mocking a unary function.
+TEST_F(FunctionMockerTest, MocksUnaryFunction) {
+  EXPECT_CALL(mock_foo_, Unary(Eq(2)))
+      .Times(2)
+      .WillOnce(Return(true));
+
+  EXPECT_TRUE(foo_->Unary(2));
+  EXPECT_FALSE(foo_->Unary(2));
+}
+
+// Tests mocking a binary function.
+TEST_F(FunctionMockerTest, MocksBinaryFunction) {
+  EXPECT_CALL(mock_foo_, Binary(2, _))
+      .WillOnce(Return(3));
+
+  EXPECT_EQ(3, foo_->Binary(2, 1));
+}
+
+// Tests mocking a decimal function.
+TEST_F(FunctionMockerTest, MocksDecimalFunction) {
+  EXPECT_CALL(mock_foo_, Decimal(true, 'a', 0, 0, 1L, A<float>(),
+                                 Lt(100), 5U, NULL, "hi"))
+      .WillOnce(Return(5));
+
+  EXPECT_EQ(5, foo_->Decimal(true, 'a', 0, 0, 1, 0, 0, 5, NULL, "hi"));
+}
+
+// Tests mocking a function that takes a non-const reference.
+TEST_F(FunctionMockerTest, MocksFunctionWithNonConstReferenceArgument) {
+  int a = 0;
+  EXPECT_CALL(mock_foo_, TakesNonConstReference(Ref(a)))
+      .WillOnce(Return(true));
+
+  EXPECT_TRUE(foo_->TakesNonConstReference(a));
+}
+
+// Tests mocking a function that takes a const reference.
+TEST_F(FunctionMockerTest, MocksFunctionWithConstReferenceArgument) {
+  int a = 0;
+  EXPECT_CALL(mock_foo_, TakesConstReference(Ref(a)))
+      .WillOnce(Return("Hello"));
+
+  EXPECT_EQ("Hello", foo_->TakesConstReference(a));
+}
+
+#ifdef GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
+// Tests mocking a function that takes a const variable.
+TEST_F(FunctionMockerTest, MocksFunctionWithConstArgument) {
+  EXPECT_CALL(mock_foo_, TakesConst(Lt(10)))
+      .WillOnce(DoDefault());
+
+  EXPECT_FALSE(foo_->TakesConst(5));
+}
+#endif  // GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
+
+// Tests mocking functions overloaded on the number of arguments.
+TEST_F(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentNumber) {
+  EXPECT_CALL(mock_foo_, OverloadedOnArgumentNumber())
+      .WillOnce(Return(1));
+  EXPECT_CALL(mock_foo_, OverloadedOnArgumentNumber(_))
+      .WillOnce(Return(2));
+
+  EXPECT_EQ(2, foo_->OverloadedOnArgumentNumber(1));
+  EXPECT_EQ(1, foo_->OverloadedOnArgumentNumber());
+}
+
+// Tests mocking functions overloaded on the types of argument.
+TEST_F(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentType) {
+  EXPECT_CALL(mock_foo_, OverloadedOnArgumentType(An<int>()))
+      .WillOnce(Return(1));
+  EXPECT_CALL(mock_foo_, OverloadedOnArgumentType(TypedEq<char>('a')))
+      .WillOnce(Return('b'));
+
+  EXPECT_EQ(1, foo_->OverloadedOnArgumentType(0));
+  EXPECT_EQ('b', foo_->OverloadedOnArgumentType('a'));
+}
+
+// Tests mocking functions overloaded on the const-ness of this object.
+TEST_F(FunctionMockerTest, MocksFunctionsOverloadedOnConstnessOfThis) {
+  EXPECT_CALL(mock_foo_, OverloadedOnConstness());
+  EXPECT_CALL(Const(mock_foo_), OverloadedOnConstness())
+      .WillOnce(Return('a'));
+
+  EXPECT_EQ(0, foo_->OverloadedOnConstness());
+  EXPECT_EQ('a', Const(*foo_).OverloadedOnConstness());
+}
+
+TEST_F(FunctionMockerTest, MocksReturnTypeWithComma) {
+  const std::map<int, string> a_map;
+  EXPECT_CALL(mock_foo_, ReturnTypeWithComma())
+      .WillOnce(Return(a_map));
+  EXPECT_CALL(mock_foo_, ReturnTypeWithComma(42))
+      .WillOnce(Return(a_map));
+
+  EXPECT_EQ(a_map, mock_foo_.ReturnTypeWithComma());
+  EXPECT_EQ(a_map, mock_foo_.ReturnTypeWithComma(42));
+}
+
+#if GTEST_OS_WINDOWS
+// Tests mocking a nullary function with calltype.
+TEST_F(FunctionMockerTest, MocksNullaryFunctionWithCallType) {
+  EXPECT_CALL(mock_foo_, CTNullary())
+      .WillOnce(Return(-1))
+      .WillOnce(Return(0));
+
+  EXPECT_EQ(-1, foo_->CTNullary());
+  EXPECT_EQ(0, foo_->CTNullary());
+}
+
+// Tests mocking a unary function with calltype.
+TEST_F(FunctionMockerTest, MocksUnaryFunctionWithCallType) {
+  EXPECT_CALL(mock_foo_, CTUnary(Eq(2)))
+      .Times(2)
+      .WillOnce(Return(true))
+      .WillOnce(Return(false));
+
+  EXPECT_TRUE(foo_->CTUnary(2));
+  EXPECT_FALSE(foo_->CTUnary(2));
+}
+
+// Tests mocking a decimal function with calltype.
+TEST_F(FunctionMockerTest, MocksDecimalFunctionWithCallType) {
+  EXPECT_CALL(mock_foo_, CTDecimal(true, 'a', 0, 0, 1L, A<float>(),
+                                   Lt(100), 5U, NULL, "hi"))
+      .WillOnce(Return(10));
+
+  EXPECT_EQ(10, foo_->CTDecimal(true, 'a', 0, 0, 1, 0, 0, 5, NULL, "hi"));
+}
+
+// Tests mocking functions overloaded on the const-ness of this object.
+TEST_F(FunctionMockerTest, MocksFunctionsConstFunctionWithCallType) {
+  EXPECT_CALL(Const(mock_foo_), CTConst(_))
+      .WillOnce(Return('a'));
+
+  EXPECT_EQ('a', Const(*foo_).CTConst(0));
+}
+
+TEST_F(FunctionMockerTest, MocksReturnTypeWithCommaAndCallType) {
+  const std::map<int, string> a_map;
+  EXPECT_CALL(mock_foo_, CTReturnTypeWithComma())
+      .WillOnce(Return(a_map));
+
+  EXPECT_EQ(a_map, mock_foo_.CTReturnTypeWithComma());
+}
+
+#endif  // GTEST_OS_WINDOWS
+
+class MockB {
+ public:
+  MockB() {}
+
+  MOCK_METHOD0(DoB, void());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
+};
+
+// Tests that functions with no EXPECT_CALL() ruls can be called any
+// number of times.
+TEST(ExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOfTimes) {
+  {
+    MockB b;
+  }
+
+  {
+    MockB b;
+    b.DoB();
+  }
+
+  {
+    MockB b;
+    b.DoB();
+    b.DoB();
+  }
+}
+
+// Tests mocking template interfaces.
+
+template <typename T>
+class StackInterface {
+ public:
+  virtual ~StackInterface() {}
+
+  // Template parameter appears in function parameter.
+  virtual void Push(const T& value) = 0;
+  virtual void Pop() = 0;
+  virtual int GetSize() const = 0;
+  // Template parameter appears in function return type.
+  virtual const T& GetTop() const = 0;
+};
+
+template <typename T>
+class MockStack : public StackInterface<T> {
+ public:
+  MockStack() {}
+
+  MOCK_METHOD1_T(Push, void(const T& elem));
+  MOCK_METHOD0_T(Pop, void());
+  MOCK_CONST_METHOD0_T(GetSize, int());  // NOLINT
+  MOCK_CONST_METHOD0_T(GetTop, const T&());
+
+  // Tests that the function return type can contain unprotected comma.
+  MOCK_METHOD0_T(ReturnTypeWithComma, std::map<int, int>());
+  MOCK_CONST_METHOD1_T(ReturnTypeWithComma, std::map<int, int>(int));  // NOLINT
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStack);
+};
+
+// Tests that template mock works.
+TEST(TemplateMockTest, Works) {
+  MockStack<int> mock;
+
+  EXPECT_CALL(mock, GetSize())
+      .WillOnce(Return(0))
+      .WillOnce(Return(1))
+      .WillOnce(Return(0));
+  EXPECT_CALL(mock, Push(_));
+  int n = 5;
+  EXPECT_CALL(mock, GetTop())
+      .WillOnce(ReturnRef(n));
+  EXPECT_CALL(mock, Pop())
+      .Times(AnyNumber());
+
+  EXPECT_EQ(0, mock.GetSize());
+  mock.Push(5);
+  EXPECT_EQ(1, mock.GetSize());
+  EXPECT_EQ(5, mock.GetTop());
+  mock.Pop();
+  EXPECT_EQ(0, mock.GetSize());
+}
+
+TEST(TemplateMockTest, MethodWithCommaInReturnTypeWorks) {
+  MockStack<int> mock;
+
+  const std::map<int, int> a_map;
+  EXPECT_CALL(mock, ReturnTypeWithComma())
+      .WillOnce(Return(a_map));
+  EXPECT_CALL(mock, ReturnTypeWithComma(1))
+      .WillOnce(Return(a_map));
+
+  EXPECT_EQ(a_map, mock.ReturnTypeWithComma());
+  EXPECT_EQ(a_map, mock.ReturnTypeWithComma(1));
+}
+
+#if GTEST_OS_WINDOWS
+// Tests mocking template interfaces with calltype.
+
+template <typename T>
+class StackInterfaceWithCallType {
+ public:
+  virtual ~StackInterfaceWithCallType() {}
+
+  // Template parameter appears in function parameter.
+  STDMETHOD_(void, Push)(const T& value) = 0;
+  STDMETHOD_(void, Pop)() = 0;
+  STDMETHOD_(int, GetSize)() const = 0;
+  // Template parameter appears in function return type.
+  STDMETHOD_(const T&, GetTop)() const = 0;
+};
+
+template <typename T>
+class MockStackWithCallType : public StackInterfaceWithCallType<T> {
+ public:
+  MockStackWithCallType() {}
+
+  MOCK_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Push, void(const T& elem));
+  MOCK_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Pop, void());
+  MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetSize, int());
+  MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetTop, const T&());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStackWithCallType);
+};
+
+// Tests that template mock with calltype works.
+TEST(TemplateMockTestWithCallType, Works) {
+  MockStackWithCallType<int> mock;
+
+  EXPECT_CALL(mock, GetSize())
+      .WillOnce(Return(0))
+      .WillOnce(Return(1))
+      .WillOnce(Return(0));
+  EXPECT_CALL(mock, Push(_));
+  int n = 5;
+  EXPECT_CALL(mock, GetTop())
+      .WillOnce(ReturnRef(n));
+  EXPECT_CALL(mock, Pop())
+      .Times(AnyNumber());
+
+  EXPECT_EQ(0, mock.GetSize());
+  mock.Push(5);
+  EXPECT_EQ(1, mock.GetSize());
+  EXPECT_EQ(5, mock.GetTop());
+  mock.Pop();
+  EXPECT_EQ(0, mock.GetSize());
+}
+#endif  // GTEST_OS_WINDOWS
+
+#define MY_MOCK_METHODS1_ \
+    MOCK_METHOD0(Overloaded, void()); \
+    MOCK_CONST_METHOD1(Overloaded, int(int n)); \
+    MOCK_METHOD2(Overloaded, bool(bool f, int n))
+
+class MockOverloadedOnArgNumber {
+ public:
+  MockOverloadedOnArgNumber() {}
+
+  MY_MOCK_METHODS1_;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnArgNumber);
+};
+
+TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) {
+  MockOverloadedOnArgNumber mock;
+  EXPECT_CALL(mock, Overloaded());
+  EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2));
+  EXPECT_CALL(mock, Overloaded(true, 1)).WillOnce(Return(true));
+
+  mock.Overloaded();
+  EXPECT_EQ(2, mock.Overloaded(1));
+  EXPECT_TRUE(mock.Overloaded(true, 1));
+}
+
+#define MY_MOCK_METHODS2_ \
+    MOCK_CONST_METHOD1(Overloaded, int(int n)); \
+    MOCK_METHOD1(Overloaded, int(int n));
+
+class MockOverloadedOnConstness {
+ public:
+  MockOverloadedOnConstness() {}
+
+  MY_MOCK_METHODS2_;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnConstness);
+};
+
+TEST(OverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody) {
+  MockOverloadedOnConstness mock;
+  const MockOverloadedOnConstness* const_mock = &mock;
+  EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2));
+  EXPECT_CALL(*const_mock, Overloaded(1)).WillOnce(Return(3));
+
+  EXPECT_EQ(2, mock.Overloaded(1));
+  EXPECT_EQ(3, const_mock->Overloaded(1));
+}
+
+TEST(MockFunctionTest, WorksForVoidNullary) {
+  MockFunction<void()> foo;
+  EXPECT_CALL(foo, Call());
+  foo.Call();
+}
+
+TEST(MockFunctionTest, WorksForNonVoidNullary) {
+  MockFunction<int()> foo;
+  EXPECT_CALL(foo, Call())
+      .WillOnce(Return(1))
+      .WillOnce(Return(2));
+  EXPECT_EQ(1, foo.Call());
+  EXPECT_EQ(2, foo.Call());
+}
+
+TEST(MockFunctionTest, WorksForVoidUnary) {
+  MockFunction<void(int)> foo;
+  EXPECT_CALL(foo, Call(1));
+  foo.Call(1);
+}
+
+TEST(MockFunctionTest, WorksForNonVoidBinary) {
+  MockFunction<int(bool, int)> foo;
+  EXPECT_CALL(foo, Call(false, 42))
+      .WillOnce(Return(1))
+      .WillOnce(Return(2));
+  EXPECT_CALL(foo, Call(true, Ge(100)))
+      .WillOnce(Return(3));
+  EXPECT_EQ(1, foo.Call(false, 42));
+  EXPECT_EQ(2, foo.Call(false, 42));
+  EXPECT_EQ(3, foo.Call(true, 120));
+}
+
+TEST(MockFunctionTest, WorksFor10Arguments) {
+  MockFunction<int(bool a0, char a1, int a2, int a3, int a4,
+                   int a5, int a6, char a7, int a8, bool a9)> foo;
+  EXPECT_CALL(foo, Call(_, 'a', _, _, _, _, _, _, _, _))
+      .WillOnce(Return(1))
+      .WillOnce(Return(2));
+  EXPECT_EQ(1, foo.Call(false, 'a', 0, 0, 0, 0, 0, 'b', 0, true));
+  EXPECT_EQ(2, foo.Call(true, 'a', 0, 0, 0, 0, 0, 'b', 1, false));
+}
+
+#if GTEST_HAS_STD_FUNCTION_
+TEST(MockFunctionTest, AsStdFunction) {
+  MockFunction<int(int)> foo;
+  auto call = [](const std::function<int(int)> &f, int i) {
+    return f(i);
+  };
+  EXPECT_CALL(foo, Call(1)).WillOnce(Return(-1));
+  EXPECT_CALL(foo, Call(2)).WillOnce(Return(-2));
+  EXPECT_EQ(-1, call(foo.AsStdFunction(), 1));
+  EXPECT_EQ(-2, call(foo.AsStdFunction(), 2));
+}
+
+TEST(MockFunctionTest, AsStdFunctionReturnsReference) {
+  MockFunction<int&()> foo;
+  int value = 1;
+  EXPECT_CALL(foo, Call()).WillOnce(ReturnRef(value));
+  int& ref = foo.AsStdFunction()();
+  EXPECT_EQ(1, ref);
+  value = 2;
+  EXPECT_EQ(2, ref);
+}
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+}  // namespace gmock_generated_function_mockers_test
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-internal-utils_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-internal-utils_test.cc
new file mode 100644
index 00000000..e0a535a3
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-internal-utils_test.cc
@@ -0,0 +1,127 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests the internal utilities.
+
+#include "gmock/internal/gmock-generated-internal-utils.h"
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+using ::testing::tuple;
+using ::testing::Matcher;
+using ::testing::internal::CompileAssertTypesEqual;
+using ::testing::internal::MatcherTuple;
+using ::testing::internal::Function;
+using ::testing::internal::IgnoredValue;
+
+// Tests the MatcherTuple template struct.
+
+TEST(MatcherTupleTest, ForSize0) {
+  CompileAssertTypesEqual<tuple<>, MatcherTuple<tuple<> >::type>();
+}
+
+TEST(MatcherTupleTest, ForSize1) {
+  CompileAssertTypesEqual<tuple<Matcher<int> >,
+                          MatcherTuple<tuple<int> >::type>();
+}
+
+TEST(MatcherTupleTest, ForSize2) {
+  CompileAssertTypesEqual<tuple<Matcher<int>, Matcher<char> >,
+                          MatcherTuple<tuple<int, char> >::type>();
+}
+
+TEST(MatcherTupleTest, ForSize5) {
+  CompileAssertTypesEqual<tuple<Matcher<int>, Matcher<char>, Matcher<bool>,
+                                Matcher<double>, Matcher<char*> >,
+                          MatcherTuple<tuple<int, char, bool, double, char*>
+                                      >::type>();
+}
+
+// Tests the Function template struct.
+
+TEST(FunctionTest, Nullary) {
+  typedef Function<int()> F;  // NOLINT
+  CompileAssertTypesEqual<int, F::Result>();
+  CompileAssertTypesEqual<tuple<>, F::ArgumentTuple>();
+  CompileAssertTypesEqual<tuple<>, F::ArgumentMatcherTuple>();
+  CompileAssertTypesEqual<void(), F::MakeResultVoid>();
+  CompileAssertTypesEqual<IgnoredValue(), F::MakeResultIgnoredValue>();
+}
+
+TEST(FunctionTest, Unary) {
+  typedef Function<int(bool)> F;  // NOLINT
+  CompileAssertTypesEqual<int, F::Result>();
+  CompileAssertTypesEqual<bool, F::Argument1>();
+  CompileAssertTypesEqual<tuple<bool>, F::ArgumentTuple>();
+  CompileAssertTypesEqual<tuple<Matcher<bool> >, F::ArgumentMatcherTuple>();
+  CompileAssertTypesEqual<void(bool), F::MakeResultVoid>();  // NOLINT
+  CompileAssertTypesEqual<IgnoredValue(bool),  // NOLINT
+      F::MakeResultIgnoredValue>();
+}
+
+TEST(FunctionTest, Binary) {
+  typedef Function<int(bool, const long&)> F;  // NOLINT
+  CompileAssertTypesEqual<int, F::Result>();
+  CompileAssertTypesEqual<bool, F::Argument1>();
+  CompileAssertTypesEqual<const long&, F::Argument2>();  // NOLINT
+  CompileAssertTypesEqual<tuple<bool, const long&>, F::ArgumentTuple>();  // NOLINT
+  CompileAssertTypesEqual<tuple<Matcher<bool>, Matcher<const long&> >,  // NOLINT
+                          F::ArgumentMatcherTuple>();
+  CompileAssertTypesEqual<void(bool, const long&), F::MakeResultVoid>();  // NOLINT
+  CompileAssertTypesEqual<IgnoredValue(bool, const long&),  // NOLINT
+      F::MakeResultIgnoredValue>();
+}
+
+TEST(FunctionTest, LongArgumentList) {
+  typedef Function<char(bool, int, char*, int&, const long&)> F;  // NOLINT
+  CompileAssertTypesEqual<char, F::Result>();
+  CompileAssertTypesEqual<bool, F::Argument1>();
+  CompileAssertTypesEqual<int, F::Argument2>();
+  CompileAssertTypesEqual<char*, F::Argument3>();
+  CompileAssertTypesEqual<int&, F::Argument4>();
+  CompileAssertTypesEqual<const long&, F::Argument5>();  // NOLINT
+  CompileAssertTypesEqual<tuple<bool, int, char*, int&, const long&>,  // NOLINT
+                          F::ArgumentTuple>();
+  CompileAssertTypesEqual<tuple<Matcher<bool>, Matcher<int>, Matcher<char*>,
+                                Matcher<int&>, Matcher<const long&> >,  // NOLINT
+                          F::ArgumentMatcherTuple>();
+  CompileAssertTypesEqual<void(bool, int, char*, int&, const long&),  // NOLINT
+                          F::MakeResultVoid>();
+  CompileAssertTypesEqual<
+      IgnoredValue(bool, int, char*, int&, const long&),  // NOLINT
+      F::MakeResultIgnoredValue>();
+}
+
+}  // Unnamed namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-matchers_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-matchers_test.cc
new file mode 100644
index 00000000..0e9f77f5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-matchers_test.cc
@@ -0,0 +1,1286 @@
+// 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.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests the built-in matchers generated by a script.
+
+#include "gmock/gmock-generated-matchers.h"
+
+#include <list>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "gtest/gtest-spi.h"
+
+namespace {
+
+using std::list;
+using std::map;
+using std::pair;
+using std::set;
+using std::stringstream;
+using std::vector;
+using testing::get;
+using testing::make_tuple;
+using testing::tuple;
+using testing::_;
+using testing::Args;
+using testing::Contains;
+using testing::ElementsAre;
+using testing::ElementsAreArray;
+using testing::Eq;
+using testing::Ge;
+using testing::Gt;
+using testing::Le;
+using testing::Lt;
+using testing::MakeMatcher;
+using testing::Matcher;
+using testing::MatcherInterface;
+using testing::MatchResultListener;
+using testing::Ne;
+using testing::Not;
+using testing::Pointee;
+using testing::PrintToString;
+using testing::Ref;
+using testing::StaticAssertTypeEq;
+using testing::StrEq;
+using testing::Value;
+using testing::internal::ElementsAreArrayMatcher;
+using testing::internal::string;
+
+// Returns the description of the given matcher.
+template <typename T>
+string Describe(const Matcher<T>& m) {
+  stringstream ss;
+  m.DescribeTo(&ss);
+  return ss.str();
+}
+
+// Returns the description of the negation of the given matcher.
+template <typename T>
+string DescribeNegation(const Matcher<T>& m) {
+  stringstream ss;
+  m.DescribeNegationTo(&ss);
+  return ss.str();
+}
+
+// Returns the reason why x matches, or doesn't match, m.
+template <typename MatcherType, typename Value>
+string Explain(const MatcherType& m, const Value& x) {
+  stringstream ss;
+  m.ExplainMatchResultTo(x, &ss);
+  return ss.str();
+}
+
+// Tests Args<k0, ..., kn>(m).
+
+TEST(ArgsTest, AcceptsZeroTemplateArg) {
+  const tuple<int, bool> t(5, true);
+  EXPECT_THAT(t, Args<>(Eq(tuple<>())));
+  EXPECT_THAT(t, Not(Args<>(Ne(tuple<>()))));
+}
+
+TEST(ArgsTest, AcceptsOneTemplateArg) {
+  const tuple<int, bool> t(5, true);
+  EXPECT_THAT(t, Args<0>(Eq(make_tuple(5))));
+  EXPECT_THAT(t, Args<1>(Eq(make_tuple(true))));
+  EXPECT_THAT(t, Not(Args<1>(Eq(make_tuple(false)))));
+}
+
+TEST(ArgsTest, AcceptsTwoTemplateArgs) {
+  const tuple<short, int, long> t(4, 5, 6L);  // NOLINT
+
+  EXPECT_THAT(t, (Args<0, 1>(Lt())));
+  EXPECT_THAT(t, (Args<1, 2>(Lt())));
+  EXPECT_THAT(t, Not(Args<0, 2>(Gt())));
+}
+
+TEST(ArgsTest, AcceptsRepeatedTemplateArgs) {
+  const tuple<short, int, long> t(4, 5, 6L);  // NOLINT
+  EXPECT_THAT(t, (Args<0, 0>(Eq())));
+  EXPECT_THAT(t, Not(Args<1, 1>(Ne())));
+}
+
+TEST(ArgsTest, AcceptsDecreasingTemplateArgs) {
+  const tuple<short, int, long> t(4, 5, 6L);  // NOLINT
+  EXPECT_THAT(t, (Args<2, 0>(Gt())));
+  EXPECT_THAT(t, Not(Args<2, 1>(Lt())));
+}
+
+// The MATCHER*() 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
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+MATCHER(SumIsZero, "") {
+  return get<0>(arg) + get<1>(arg) + get<2>(arg) == 0;
+}
+
+TEST(ArgsTest, AcceptsMoreTemplateArgsThanArityOfOriginalTuple) {
+  EXPECT_THAT(make_tuple(-1, 2), (Args<0, 0, 1>(SumIsZero())));
+  EXPECT_THAT(make_tuple(1, 2), Not(Args<0, 0, 1>(SumIsZero())));
+}
+
+TEST(ArgsTest, CanBeNested) {
+  const tuple<short, int, long, int> t(4, 5, 6L, 6);  // NOLINT
+  EXPECT_THAT(t, (Args<1, 2, 3>(Args<1, 2>(Eq()))));
+  EXPECT_THAT(t, (Args<0, 1, 3>(Args<0, 2>(Lt()))));
+}
+
+TEST(ArgsTest, CanMatchTupleByValue) {
+  typedef tuple<char, int, int> Tuple3;
+  const Matcher<Tuple3> m = Args<1, 2>(Lt());
+  EXPECT_TRUE(m.Matches(Tuple3('a', 1, 2)));
+  EXPECT_FALSE(m.Matches(Tuple3('b', 2, 2)));
+}
+
+TEST(ArgsTest, CanMatchTupleByReference) {
+  typedef tuple<char, char, int> Tuple3;
+  const Matcher<const Tuple3&> m = Args<0, 1>(Lt());
+  EXPECT_TRUE(m.Matches(Tuple3('a', 'b', 2)));
+  EXPECT_FALSE(m.Matches(Tuple3('b', 'b', 2)));
+}
+
+// Validates that arg is printed as str.
+MATCHER_P(PrintsAs, str, "") {
+  return testing::PrintToString(arg) == str;
+}
+
+TEST(ArgsTest, AcceptsTenTemplateArgs) {
+  EXPECT_THAT(make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9),
+              (Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>(
+                  PrintsAs("(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)"))));
+  EXPECT_THAT(make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9),
+              Not(Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>(
+                      PrintsAs("(0, 8, 7, 6, 5, 4, 3, 2, 1, 0)"))));
+}
+
+TEST(ArgsTest, DescirbesSelfCorrectly) {
+  const Matcher<tuple<int, bool, char> > m = Args<2, 0>(Lt());
+  EXPECT_EQ("are a tuple whose fields (#2, #0) are a pair where "
+            "the first < the second",
+            Describe(m));
+}
+
+TEST(ArgsTest, DescirbesNestedArgsCorrectly) {
+  const Matcher<const tuple<int, bool, char, int>&> m =
+      Args<0, 2, 3>(Args<2, 0>(Lt()));
+  EXPECT_EQ("are a tuple whose fields (#0, #2, #3) are a tuple "
+            "whose fields (#2, #0) are a pair where the first < the second",
+            Describe(m));
+}
+
+TEST(ArgsTest, DescribesNegationCorrectly) {
+  const Matcher<tuple<int, char> > m = Args<1, 0>(Gt());
+  EXPECT_EQ("are a tuple whose fields (#1, #0) aren't a pair "
+            "where the first > the second",
+            DescribeNegation(m));
+}
+
+TEST(ArgsTest, ExplainsMatchResultWithoutInnerExplanation) {
+  const Matcher<tuple<bool, int, int> > m = Args<1, 2>(Eq());
+  EXPECT_EQ("whose fields (#1, #2) are (42, 42)",
+            Explain(m, make_tuple(false, 42, 42)));
+  EXPECT_EQ("whose fields (#1, #2) are (42, 43)",
+            Explain(m, make_tuple(false, 42, 43)));
+}
+
+// For testing Args<>'s explanation.
+class LessThanMatcher : public MatcherInterface<tuple<char, int> > {
+ public:
+  virtual void DescribeTo(::std::ostream* os) const {}
+
+  virtual bool MatchAndExplain(tuple<char, int> value,
+                               MatchResultListener* listener) const {
+    const int diff = get<0>(value) - get<1>(value);
+    if (diff > 0) {
+      *listener << "where the first value is " << diff
+                << " more than the second";
+    }
+    return diff < 0;
+  }
+};
+
+Matcher<tuple<char, int> > LessThan() {
+  return MakeMatcher(new LessThanMatcher);
+}
+
+TEST(ArgsTest, ExplainsMatchResultWithInnerExplanation) {
+  const Matcher<tuple<char, int, int> > m = Args<0, 2>(LessThan());
+  EXPECT_EQ("whose fields (#0, #2) are ('a' (97, 0x61), 42), "
+            "where the first value is 55 more than the second",
+            Explain(m, make_tuple('a', 42, 42)));
+  EXPECT_EQ("whose fields (#0, #2) are ('\\0', 43)",
+            Explain(m, make_tuple('\0', 42, 43)));
+}
+
+// For testing ExplainMatchResultTo().
+class GreaterThanMatcher : public MatcherInterface<int> {
+ public:
+  explicit GreaterThanMatcher(int rhs) : rhs_(rhs) {}
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "is greater than " << rhs_;
+  }
+
+  virtual bool MatchAndExplain(int lhs,
+                               MatchResultListener* listener) const {
+    const int diff = lhs - rhs_;
+    if (diff > 0) {
+      *listener << "which is " << diff << " more than " << rhs_;
+    } else if (diff == 0) {
+      *listener << "which is the same as " << rhs_;
+    } else {
+      *listener << "which is " << -diff << " less than " << rhs_;
+    }
+
+    return lhs > rhs_;
+  }
+
+ private:
+  int rhs_;
+};
+
+Matcher<int> GreaterThan(int n) {
+  return MakeMatcher(new GreaterThanMatcher(n));
+}
+
+// Tests for ElementsAre().
+
+TEST(ElementsAreTest, CanDescribeExpectingNoElement) {
+  Matcher<const vector<int>&> m = ElementsAre();
+  EXPECT_EQ("is empty", Describe(m));
+}
+
+TEST(ElementsAreTest, CanDescribeExpectingOneElement) {
+  Matcher<vector<int> > m = ElementsAre(Gt(5));
+  EXPECT_EQ("has 1 element that is > 5", Describe(m));
+}
+
+TEST(ElementsAreTest, CanDescribeExpectingManyElements) {
+  Matcher<list<string> > m = ElementsAre(StrEq("one"), "two");
+  EXPECT_EQ("has 2 elements where\n"
+            "element #0 is equal to \"one\",\n"
+            "element #1 is equal to \"two\"", Describe(m));
+}
+
+TEST(ElementsAreTest, CanDescribeNegationOfExpectingNoElement) {
+  Matcher<vector<int> > m = ElementsAre();
+  EXPECT_EQ("isn't empty", DescribeNegation(m));
+}
+
+TEST(ElementsAreTest, CanDescribeNegationOfExpectingOneElment) {
+  Matcher<const list<int>& > m = ElementsAre(Gt(5));
+  EXPECT_EQ("doesn't have 1 element, or\n"
+            "element #0 isn't > 5", DescribeNegation(m));
+}
+
+TEST(ElementsAreTest, CanDescribeNegationOfExpectingManyElements) {
+  Matcher<const list<string>& > m = ElementsAre("one", "two");
+  EXPECT_EQ("doesn't have 2 elements, or\n"
+            "element #0 isn't equal to \"one\", or\n"
+            "element #1 isn't equal to \"two\"", DescribeNegation(m));
+}
+
+TEST(ElementsAreTest, DoesNotExplainTrivialMatch) {
+  Matcher<const list<int>& > m = ElementsAre(1, Ne(2));
+
+  list<int> test_list;
+  test_list.push_back(1);
+  test_list.push_back(3);
+  EXPECT_EQ("", Explain(m, test_list));  // No need to explain anything.
+}
+
+TEST(ElementsAreTest, ExplainsNonTrivialMatch) {
+  Matcher<const vector<int>& > m =
+      ElementsAre(GreaterThan(1), 0, GreaterThan(2));
+
+  const int a[] = { 10, 0, 100 };
+  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
+  EXPECT_EQ("whose element #0 matches, which is 9 more than 1,\n"
+            "and whose element #2 matches, which is 98 more than 2",
+            Explain(m, test_vector));
+}
+
+TEST(ElementsAreTest, CanExplainMismatchWrongSize) {
+  Matcher<const list<int>& > m = ElementsAre(1, 3);
+
+  list<int> test_list;
+  // No need to explain when the container is empty.
+  EXPECT_EQ("", Explain(m, test_list));
+
+  test_list.push_back(1);
+  EXPECT_EQ("which has 1 element", Explain(m, test_list));
+}
+
+TEST(ElementsAreTest, CanExplainMismatchRightSize) {
+  Matcher<const vector<int>& > m = ElementsAre(1, GreaterThan(5));
+
+  vector<int> v;
+  v.push_back(2);
+  v.push_back(1);
+  EXPECT_EQ("whose element #0 doesn't match", Explain(m, v));
+
+  v[0] = 1;
+  EXPECT_EQ("whose element #1 doesn't match, which is 4 less than 5",
+            Explain(m, v));
+}
+
+TEST(ElementsAreTest, MatchesOneElementVector) {
+  vector<string> test_vector;
+  test_vector.push_back("test string");
+
+  EXPECT_THAT(test_vector, ElementsAre(StrEq("test string")));
+}
+
+TEST(ElementsAreTest, MatchesOneElementList) {
+  list<string> test_list;
+  test_list.push_back("test string");
+
+  EXPECT_THAT(test_list, ElementsAre("test string"));
+}
+
+TEST(ElementsAreTest, MatchesThreeElementVector) {
+  vector<string> test_vector;
+  test_vector.push_back("one");
+  test_vector.push_back("two");
+  test_vector.push_back("three");
+
+  EXPECT_THAT(test_vector, ElementsAre("one", StrEq("two"), _));
+}
+
+TEST(ElementsAreTest, MatchesOneElementEqMatcher) {
+  vector<int> test_vector;
+  test_vector.push_back(4);
+
+  EXPECT_THAT(test_vector, ElementsAre(Eq(4)));
+}
+
+TEST(ElementsAreTest, MatchesOneElementAnyMatcher) {
+  vector<int> test_vector;
+  test_vector.push_back(4);
+
+  EXPECT_THAT(test_vector, ElementsAre(_));
+}
+
+TEST(ElementsAreTest, MatchesOneElementValue) {
+  vector<int> test_vector;
+  test_vector.push_back(4);
+
+  EXPECT_THAT(test_vector, ElementsAre(4));
+}
+
+TEST(ElementsAreTest, MatchesThreeElementsMixedMatchers) {
+  vector<int> test_vector;
+  test_vector.push_back(1);
+  test_vector.push_back(2);
+  test_vector.push_back(3);
+
+  EXPECT_THAT(test_vector, ElementsAre(1, Eq(2), _));
+}
+
+TEST(ElementsAreTest, MatchesTenElementVector) {
+  const int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
+
+  EXPECT_THAT(test_vector,
+              // The element list can contain values and/or matchers
+              // of different types.
+              ElementsAre(0, Ge(0), _, 3, 4, Ne(2), Eq(6), 7, 8, _));
+}
+
+TEST(ElementsAreTest, DoesNotMatchWrongSize) {
+  vector<string> test_vector;
+  test_vector.push_back("test string");
+  test_vector.push_back("test string");
+
+  Matcher<vector<string> > m = ElementsAre(StrEq("test string"));
+  EXPECT_FALSE(m.Matches(test_vector));
+}
+
+TEST(ElementsAreTest, DoesNotMatchWrongValue) {
+  vector<string> test_vector;
+  test_vector.push_back("other string");
+
+  Matcher<vector<string> > m = ElementsAre(StrEq("test string"));
+  EXPECT_FALSE(m.Matches(test_vector));
+}
+
+TEST(ElementsAreTest, DoesNotMatchWrongOrder) {
+  vector<string> test_vector;
+  test_vector.push_back("one");
+  test_vector.push_back("three");
+  test_vector.push_back("two");
+
+  Matcher<vector<string> > m = ElementsAre(
+    StrEq("one"), StrEq("two"), StrEq("three"));
+  EXPECT_FALSE(m.Matches(test_vector));
+}
+
+TEST(ElementsAreTest, WorksForNestedContainer) {
+  const char* strings[] = {
+    "Hi",
+    "world"
+  };
+
+  vector<list<char> > nested;
+  for (size_t i = 0; i < GTEST_ARRAY_SIZE_(strings); i++) {
+    nested.push_back(list<char>(strings[i], strings[i] + strlen(strings[i])));
+  }
+
+  EXPECT_THAT(nested, ElementsAre(ElementsAre('H', Ne('e')),
+                                  ElementsAre('w', 'o', _, _, 'd')));
+  EXPECT_THAT(nested, Not(ElementsAre(ElementsAre('H', 'e'),
+                                      ElementsAre('w', 'o', _, _, 'd'))));
+}
+
+TEST(ElementsAreTest, WorksWithByRefElementMatchers) {
+  int a[] = { 0, 1, 2 };
+  vector<int> v(a, a + GTEST_ARRAY_SIZE_(a));
+
+  EXPECT_THAT(v, ElementsAre(Ref(v[0]), Ref(v[1]), Ref(v[2])));
+  EXPECT_THAT(v, Not(ElementsAre(Ref(v[0]), Ref(v[1]), Ref(a[2]))));
+}
+
+TEST(ElementsAreTest, WorksWithContainerPointerUsingPointee) {
+  int a[] = { 0, 1, 2 };
+  vector<int> v(a, a + GTEST_ARRAY_SIZE_(a));
+
+  EXPECT_THAT(&v, Pointee(ElementsAre(0, 1, _)));
+  EXPECT_THAT(&v, Not(Pointee(ElementsAre(0, _, 3))));
+}
+
+TEST(ElementsAreTest, WorksWithNativeArrayPassedByReference) {
+  int array[] = { 0, 1, 2 };
+  EXPECT_THAT(array, ElementsAre(0, 1, _));
+  EXPECT_THAT(array, Not(ElementsAre(1, _, _)));
+  EXPECT_THAT(array, Not(ElementsAre(0, _)));
+}
+
+class NativeArrayPassedAsPointerAndSize {
+ public:
+  NativeArrayPassedAsPointerAndSize() {}
+
+  MOCK_METHOD2(Helper, void(int* array, int size));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NativeArrayPassedAsPointerAndSize);
+};
+
+TEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) {
+  int array[] = { 0, 1 };
+  ::testing::tuple<int*, size_t> array_as_tuple(array, 2);
+  EXPECT_THAT(array_as_tuple, ElementsAre(0, 1));
+  EXPECT_THAT(array_as_tuple, Not(ElementsAre(0)));
+
+  NativeArrayPassedAsPointerAndSize helper;
+  EXPECT_CALL(helper, Helper(_, _))
+      .With(ElementsAre(0, 1));
+  helper.Helper(array, 2);
+}
+
+TEST(ElementsAreTest, WorksWithTwoDimensionalNativeArray) {
+  const char a2[][3] = { "hi", "lo" };
+  EXPECT_THAT(a2, ElementsAre(ElementsAre('h', 'i', '\0'),
+                              ElementsAre('l', 'o', '\0')));
+  EXPECT_THAT(a2, ElementsAre(StrEq("hi"), StrEq("lo")));
+  EXPECT_THAT(a2, ElementsAre(Not(ElementsAre('h', 'o', '\0')),
+                              ElementsAre('l', 'o', '\0')));
+}
+
+TEST(ElementsAreTest, AcceptsStringLiteral) {
+  string array[] = { "hi", "one", "two" };
+  EXPECT_THAT(array, ElementsAre("hi", "one", "two"));
+  EXPECT_THAT(array, Not(ElementsAre("hi", "one", "too")));
+}
+
+#ifndef _MSC_VER
+
+// The following test passes a value of type const char[] to a
+// function template that expects const T&.  Some versions of MSVC
+// generates a compiler error C2665 for that.  We believe it's a bug
+// in MSVC.  Therefore this test is #if-ed out for MSVC.
+
+// Declared here with the size unknown.  Defined AFTER the following test.
+extern const char kHi[];
+
+TEST(ElementsAreTest, AcceptsArrayWithUnknownSize) {
+  // The size of kHi is not known in this test, but ElementsAre() should
+  // still accept it.
+
+  string array1[] = { "hi" };
+  EXPECT_THAT(array1, ElementsAre(kHi));
+
+  string array2[] = { "ho" };
+  EXPECT_THAT(array2, Not(ElementsAre(kHi)));
+}
+
+const char kHi[] = "hi";
+
+#endif  // _MSC_VER
+
+TEST(ElementsAreTest, MakesCopyOfArguments) {
+  int x = 1;
+  int y = 2;
+  // This should make a copy of x and y.
+  ::testing::internal::ElementsAreMatcher<testing::tuple<int, int> >
+          polymorphic_matcher = ElementsAre(x, y);
+  // Changing x and y now shouldn't affect the meaning of the above matcher.
+  x = y = 0;
+  const int array1[] = { 1, 2 };
+  EXPECT_THAT(array1, polymorphic_matcher);
+  const int array2[] = { 0, 0 };
+  EXPECT_THAT(array2, Not(polymorphic_matcher));
+}
+
+
+// Tests for ElementsAreArray().  Since ElementsAreArray() shares most
+// of the implementation with ElementsAre(), we don't test it as
+// thoroughly here.
+
+TEST(ElementsAreArrayTest, CanBeCreatedWithValueArray) {
+  const int a[] = { 1, 2, 3 };
+
+  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
+  EXPECT_THAT(test_vector, ElementsAreArray(a));
+
+  test_vector[2] = 0;
+  EXPECT_THAT(test_vector, Not(ElementsAreArray(a)));
+}
+
+TEST(ElementsAreArrayTest, CanBeCreatedWithArraySize) {
+  const char* a[] = { "one", "two", "three" };
+
+  vector<string> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
+  EXPECT_THAT(test_vector, ElementsAreArray(a, GTEST_ARRAY_SIZE_(a)));
+
+  const char** p = a;
+  test_vector[0] = "1";
+  EXPECT_THAT(test_vector, Not(ElementsAreArray(p, GTEST_ARRAY_SIZE_(a))));
+}
+
+TEST(ElementsAreArrayTest, CanBeCreatedWithoutArraySize) {
+  const char* a[] = { "one", "two", "three" };
+
+  vector<string> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
+  EXPECT_THAT(test_vector, ElementsAreArray(a));
+
+  test_vector[0] = "1";
+  EXPECT_THAT(test_vector, Not(ElementsAreArray(a)));
+}
+
+TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherArray) {
+  const Matcher<string> kMatcherArray[] =
+    { StrEq("one"), StrEq("two"), StrEq("three") };
+
+  vector<string> test_vector;
+  test_vector.push_back("one");
+  test_vector.push_back("two");
+  test_vector.push_back("three");
+  EXPECT_THAT(test_vector, ElementsAreArray(kMatcherArray));
+
+  test_vector.push_back("three");
+  EXPECT_THAT(test_vector, Not(ElementsAreArray(kMatcherArray)));
+}
+
+TEST(ElementsAreArrayTest, CanBeCreatedWithVector) {
+  const int a[] = { 1, 2, 3 };
+  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
+  const vector<int> expected(a, a + GTEST_ARRAY_SIZE_(a));
+  EXPECT_THAT(test_vector, ElementsAreArray(expected));
+  test_vector.push_back(4);
+  EXPECT_THAT(test_vector, Not(ElementsAreArray(expected)));
+}
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+
+TEST(ElementsAreArrayTest, TakesInitializerList) {
+  const int a[5] = { 1, 2, 3, 4, 5 };
+  EXPECT_THAT(a, ElementsAreArray({ 1, 2, 3, 4, 5 }));
+  EXPECT_THAT(a, Not(ElementsAreArray({ 1, 2, 3, 5, 4 })));
+  EXPECT_THAT(a, Not(ElementsAreArray({ 1, 2, 3, 4, 6 })));
+}
+
+TEST(ElementsAreArrayTest, TakesInitializerListOfCStrings) {
+  const string a[5] = { "a", "b", "c", "d", "e" };
+  EXPECT_THAT(a, ElementsAreArray({ "a", "b", "c", "d", "e" }));
+  EXPECT_THAT(a, Not(ElementsAreArray({ "a", "b", "c", "e", "d" })));
+  EXPECT_THAT(a, Not(ElementsAreArray({ "a", "b", "c", "d", "ef" })));
+}
+
+TEST(ElementsAreArrayTest, TakesInitializerListOfSameTypedMatchers) {
+  const int a[5] = { 1, 2, 3, 4, 5 };
+  EXPECT_THAT(a, ElementsAreArray(
+      { Eq(1), Eq(2), Eq(3), Eq(4), Eq(5) }));
+  EXPECT_THAT(a, Not(ElementsAreArray(
+      { Eq(1), Eq(2), Eq(3), Eq(4), Eq(6) })));
+}
+
+TEST(ElementsAreArrayTest,
+     TakesInitializerListOfDifferentTypedMatchers) {
+  const int a[5] = { 1, 2, 3, 4, 5 };
+  // The compiler cannot infer the type of the initializer list if its
+  // elements have different types.  We must explicitly specify the
+  // unified element type in this case.
+  EXPECT_THAT(a, ElementsAreArray<Matcher<int> >(
+      { Eq(1), Ne(-2), Ge(3), Le(4), Eq(5) }));
+  EXPECT_THAT(a, Not(ElementsAreArray<Matcher<int> >(
+      { Eq(1), Ne(-2), Ge(3), Le(4), Eq(6) })));
+}
+
+#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
+
+TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherVector) {
+  const int a[] = { 1, 2, 3 };
+  const Matcher<int> kMatchers[] = { Eq(1), Eq(2), Eq(3) };
+  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
+  const vector<Matcher<int> > expected(
+      kMatchers, kMatchers + GTEST_ARRAY_SIZE_(kMatchers));
+  EXPECT_THAT(test_vector, ElementsAreArray(expected));
+  test_vector.push_back(4);
+  EXPECT_THAT(test_vector, Not(ElementsAreArray(expected)));
+}
+
+TEST(ElementsAreArrayTest, CanBeCreatedWithIteratorRange) {
+  const int a[] = { 1, 2, 3 };
+  const vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
+  const vector<int> expected(a, a + GTEST_ARRAY_SIZE_(a));
+  EXPECT_THAT(test_vector, ElementsAreArray(expected.begin(), expected.end()));
+  // Pointers are iterators, too.
+  EXPECT_THAT(test_vector, ElementsAreArray(a, a + GTEST_ARRAY_SIZE_(a)));
+  // The empty range of NULL pointers should also be okay.
+  int* const null_int = NULL;
+  EXPECT_THAT(test_vector, Not(ElementsAreArray(null_int, null_int)));
+  EXPECT_THAT((vector<int>()), ElementsAreArray(null_int, null_int));
+}
+
+// Since ElementsAre() and ElementsAreArray() share much of the
+// implementation, we only do a sanity test for native arrays here.
+TEST(ElementsAreArrayTest, WorksWithNativeArray) {
+  ::std::string a[] = { "hi", "ho" };
+  ::std::string b[] = { "hi", "ho" };
+
+  EXPECT_THAT(a, ElementsAreArray(b));
+  EXPECT_THAT(a, ElementsAreArray(b, 2));
+  EXPECT_THAT(a, Not(ElementsAreArray(b, 1)));
+}
+
+TEST(ElementsAreArrayTest, SourceLifeSpan) {
+  const int a[] = { 1, 2, 3 };
+  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
+  vector<int> expect(a, a + GTEST_ARRAY_SIZE_(a));
+  ElementsAreArrayMatcher<int> matcher_maker =
+      ElementsAreArray(expect.begin(), expect.end());
+  EXPECT_THAT(test_vector, matcher_maker);
+  // Changing in place the values that initialized matcher_maker should not
+  // affect matcher_maker anymore. It should have made its own copy of them.
+  typedef vector<int>::iterator Iter;
+  for (Iter it = expect.begin(); it != expect.end(); ++it) { *it += 10; }
+  EXPECT_THAT(test_vector, matcher_maker);
+  test_vector.push_back(3);
+  EXPECT_THAT(test_vector, Not(matcher_maker));
+}
+
+// Tests for the MATCHER*() macro family.
+
+// Tests that a simple MATCHER() definition works.
+
+MATCHER(IsEven, "") { return (arg % 2) == 0; }
+
+TEST(MatcherMacroTest, Works) {
+  const Matcher<int> m = IsEven();
+  EXPECT_TRUE(m.Matches(6));
+  EXPECT_FALSE(m.Matches(7));
+
+  EXPECT_EQ("is even", Describe(m));
+  EXPECT_EQ("not (is even)", DescribeNegation(m));
+  EXPECT_EQ("", Explain(m, 6));
+  EXPECT_EQ("", Explain(m, 7));
+}
+
+// This also tests that the description string can reference 'negation'.
+MATCHER(IsEven2, negation ? "is odd" : "is even") {
+  if ((arg % 2) == 0) {
+    // Verifies that we can stream to result_listener, a listener
+    // supplied by the MATCHER macro implicitly.
+    *result_listener << "OK";
+    return true;
+  } else {
+    *result_listener << "% 2 == " << (arg % 2);
+    return false;
+  }
+}
+
+// This also tests that the description string can reference matcher
+// parameters.
+MATCHER_P2(EqSumOf, x, y,
+           string(negation ? "doesn't equal" : "equals") + " the sum of " +
+           PrintToString(x) + " and " + PrintToString(y)) {
+  if (arg == (x + y)) {
+    *result_listener << "OK";
+    return true;
+  } else {
+    // Verifies that we can stream to the underlying stream of
+    // result_listener.
+    if (result_listener->stream() != NULL) {
+      *result_listener->stream() << "diff == " << (x + y - arg);
+    }
+    return false;
+  }
+}
+
+// Tests that the matcher description can reference 'negation' and the
+// matcher parameters.
+TEST(MatcherMacroTest, DescriptionCanReferenceNegationAndParameters) {
+  const Matcher<int> m1 = IsEven2();
+  EXPECT_EQ("is even", Describe(m1));
+  EXPECT_EQ("is odd", DescribeNegation(m1));
+
+  const Matcher<int> m2 = EqSumOf(5, 9);
+  EXPECT_EQ("equals the sum of 5 and 9", Describe(m2));
+  EXPECT_EQ("doesn't equal the sum of 5 and 9", DescribeNegation(m2));
+}
+
+// Tests explaining match result in a MATCHER* macro.
+TEST(MatcherMacroTest, CanExplainMatchResult) {
+  const Matcher<int> m1 = IsEven2();
+  EXPECT_EQ("OK", Explain(m1, 4));
+  EXPECT_EQ("% 2 == 1", Explain(m1, 5));
+
+  const Matcher<int> m2 = EqSumOf(1, 2);
+  EXPECT_EQ("OK", Explain(m2, 3));
+  EXPECT_EQ("diff == -1", Explain(m2, 4));
+}
+
+// Tests that the body of MATCHER() can reference the type of the
+// value being matched.
+
+MATCHER(IsEmptyString, "") {
+  StaticAssertTypeEq< ::std::string, arg_type>();
+  return arg == "";
+}
+
+MATCHER(IsEmptyStringByRef, "") {
+  StaticAssertTypeEq<const ::std::string&, arg_type>();
+  return arg == "";
+}
+
+TEST(MatcherMacroTest, CanReferenceArgType) {
+  const Matcher< ::std::string> m1 = IsEmptyString();
+  EXPECT_TRUE(m1.Matches(""));
+
+  const Matcher<const ::std::string&> m2 = IsEmptyStringByRef();
+  EXPECT_TRUE(m2.Matches(""));
+}
+
+// Tests that MATCHER() can be used in a namespace.
+
+namespace matcher_test {
+MATCHER(IsOdd, "") { return (arg % 2) != 0; }
+}  // namespace matcher_test
+
+TEST(MatcherMacroTest, WorksInNamespace) {
+  Matcher<int> m = matcher_test::IsOdd();
+  EXPECT_FALSE(m.Matches(4));
+  EXPECT_TRUE(m.Matches(5));
+}
+
+// Tests that Value() can be used to compose matchers.
+MATCHER(IsPositiveOdd, "") {
+  return Value(arg, matcher_test::IsOdd()) && arg > 0;
+}
+
+TEST(MatcherMacroTest, CanBeComposedUsingValue) {
+  EXPECT_THAT(3, IsPositiveOdd());
+  EXPECT_THAT(4, Not(IsPositiveOdd()));
+  EXPECT_THAT(-1, Not(IsPositiveOdd()));
+}
+
+// Tests that a simple MATCHER_P() definition works.
+
+MATCHER_P(IsGreaterThan32And, n, "") { return arg > 32 && arg > n; }
+
+TEST(MatcherPMacroTest, Works) {
+  const Matcher<int> m = IsGreaterThan32And(5);
+  EXPECT_TRUE(m.Matches(36));
+  EXPECT_FALSE(m.Matches(5));
+
+  EXPECT_EQ("is greater than 32 and 5", Describe(m));
+  EXPECT_EQ("not (is greater than 32 and 5)", DescribeNegation(m));
+  EXPECT_EQ("", Explain(m, 36));
+  EXPECT_EQ("", Explain(m, 5));
+}
+
+// Tests that the description is calculated correctly from the matcher name.
+MATCHER_P(_is_Greater_Than32and_, n, "") { return arg > 32 && arg > n; }
+
+TEST(MatcherPMacroTest, GeneratesCorrectDescription) {
+  const Matcher<int> m = _is_Greater_Than32and_(5);
+
+  EXPECT_EQ("is greater than 32 and 5", Describe(m));
+  EXPECT_EQ("not (is greater than 32 and 5)", DescribeNegation(m));
+  EXPECT_EQ("", Explain(m, 36));
+  EXPECT_EQ("", Explain(m, 5));
+}
+
+// Tests that a MATCHER_P matcher can be explicitly instantiated with
+// a reference parameter type.
+
+class UncopyableFoo {
+ public:
+  explicit UncopyableFoo(char value) : value_(value) {}
+ private:
+  UncopyableFoo(const UncopyableFoo&);
+  void operator=(const UncopyableFoo&);
+
+  char value_;
+};
+
+MATCHER_P(ReferencesUncopyable, variable, "") { return &arg == &variable; }
+
+TEST(MatcherPMacroTest, WorksWhenExplicitlyInstantiatedWithReference) {
+  UncopyableFoo foo1('1'), foo2('2');
+  const Matcher<const UncopyableFoo&> m =
+      ReferencesUncopyable<const UncopyableFoo&>(foo1);
+
+  EXPECT_TRUE(m.Matches(foo1));
+  EXPECT_FALSE(m.Matches(foo2));
+
+  // We don't want the address of the parameter printed, as most
+  // likely it will just annoy the user.  If the address is
+  // interesting, the user should consider passing the parameter by
+  // pointer instead.
+  EXPECT_EQ("references uncopyable 1-byte object <31>", Describe(m));
+}
+
+
+// Tests that the body of MATCHER_Pn() can reference the parameter
+// types.
+
+MATCHER_P3(ParamTypesAreIntLongAndChar, foo, bar, baz, "") {
+  StaticAssertTypeEq<int, foo_type>();
+  StaticAssertTypeEq<long, bar_type>();  // NOLINT
+  StaticAssertTypeEq<char, baz_type>();
+  return arg == 0;
+}
+
+TEST(MatcherPnMacroTest, CanReferenceParamTypes) {
+  EXPECT_THAT(0, ParamTypesAreIntLongAndChar(10, 20L, 'a'));
+}
+
+// Tests that a MATCHER_Pn matcher can be explicitly instantiated with
+// reference parameter types.
+
+MATCHER_P2(ReferencesAnyOf, variable1, variable2, "") {
+  return &arg == &variable1 || &arg == &variable2;
+}
+
+TEST(MatcherPnMacroTest, WorksWhenExplicitlyInstantiatedWithReferences) {
+  UncopyableFoo foo1('1'), foo2('2'), foo3('3');
+  const Matcher<const UncopyableFoo&> m =
+      ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2);
+
+  EXPECT_TRUE(m.Matches(foo1));
+  EXPECT_TRUE(m.Matches(foo2));
+  EXPECT_FALSE(m.Matches(foo3));
+}
+
+TEST(MatcherPnMacroTest,
+     GeneratesCorretDescriptionWhenExplicitlyInstantiatedWithReferences) {
+  UncopyableFoo foo1('1'), foo2('2');
+  const Matcher<const UncopyableFoo&> m =
+      ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2);
+
+  // We don't want the addresses of the parameters printed, as most
+  // likely they will just annoy the user.  If the addresses are
+  // interesting, the user should consider passing the parameters by
+  // pointers instead.
+  EXPECT_EQ("references any of (1-byte object <31>, 1-byte object <32>)",
+            Describe(m));
+}
+
+// Tests that a simple MATCHER_P2() definition works.
+
+MATCHER_P2(IsNotInClosedRange, low, hi, "") { return arg < low || arg > hi; }
+
+TEST(MatcherPnMacroTest, Works) {
+  const Matcher<const long&> m = IsNotInClosedRange(10, 20);  // NOLINT
+  EXPECT_TRUE(m.Matches(36L));
+  EXPECT_FALSE(m.Matches(15L));
+
+  EXPECT_EQ("is not in closed range (10, 20)", Describe(m));
+  EXPECT_EQ("not (is not in closed range (10, 20))", DescribeNegation(m));
+  EXPECT_EQ("", Explain(m, 36L));
+  EXPECT_EQ("", Explain(m, 15L));
+}
+
+// Tests that MATCHER*() definitions can be overloaded on the number
+// of parameters; also tests MATCHER_Pn() where n >= 3.
+
+MATCHER(EqualsSumOf, "") { return arg == 0; }
+MATCHER_P(EqualsSumOf, a, "") { return arg == a; }
+MATCHER_P2(EqualsSumOf, a, b, "") { return arg == a + b; }
+MATCHER_P3(EqualsSumOf, a, b, c, "") { return arg == a + b + c; }
+MATCHER_P4(EqualsSumOf, a, b, c, d, "") { return arg == a + b + c + d; }
+MATCHER_P5(EqualsSumOf, a, b, c, d, e, "") { return arg == a + b + c + d + e; }
+MATCHER_P6(EqualsSumOf, a, b, c, d, e, f, "") {
+  return arg == a + b + c + d + e + f;
+}
+MATCHER_P7(EqualsSumOf, a, b, c, d, e, f, g, "") {
+  return arg == a + b + c + d + e + f + g;
+}
+MATCHER_P8(EqualsSumOf, a, b, c, d, e, f, g, h, "") {
+  return arg == a + b + c + d + e + f + g + h;
+}
+MATCHER_P9(EqualsSumOf, a, b, c, d, e, f, g, h, i, "") {
+  return arg == a + b + c + d + e + f + g + h + i;
+}
+MATCHER_P10(EqualsSumOf, a, b, c, d, e, f, g, h, i, j, "") {
+  return arg == a + b + c + d + e + f + g + h + i + j;
+}
+
+TEST(MatcherPnMacroTest, CanBeOverloadedOnNumberOfParameters) {
+  EXPECT_THAT(0, EqualsSumOf());
+  EXPECT_THAT(1, EqualsSumOf(1));
+  EXPECT_THAT(12, EqualsSumOf(10, 2));
+  EXPECT_THAT(123, EqualsSumOf(100, 20, 3));
+  EXPECT_THAT(1234, EqualsSumOf(1000, 200, 30, 4));
+  EXPECT_THAT(12345, EqualsSumOf(10000, 2000, 300, 40, 5));
+  EXPECT_THAT("abcdef",
+              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f'));
+  EXPECT_THAT("abcdefg",
+              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g'));
+  EXPECT_THAT("abcdefgh",
+              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
+                          "h"));
+  EXPECT_THAT("abcdefghi",
+              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
+                          "h", 'i'));
+  EXPECT_THAT("abcdefghij",
+              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
+                          "h", 'i', ::std::string("j")));
+
+  EXPECT_THAT(1, Not(EqualsSumOf()));
+  EXPECT_THAT(-1, Not(EqualsSumOf(1)));
+  EXPECT_THAT(-12, Not(EqualsSumOf(10, 2)));
+  EXPECT_THAT(-123, Not(EqualsSumOf(100, 20, 3)));
+  EXPECT_THAT(-1234, Not(EqualsSumOf(1000, 200, 30, 4)));
+  EXPECT_THAT(-12345, Not(EqualsSumOf(10000, 2000, 300, 40, 5)));
+  EXPECT_THAT("abcdef ",
+              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f')));
+  EXPECT_THAT("abcdefg ",
+              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f',
+                              'g')));
+  EXPECT_THAT("abcdefgh ",
+              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
+                              "h")));
+  EXPECT_THAT("abcdefghi ",
+              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
+                              "h", 'i')));
+  EXPECT_THAT("abcdefghij ",
+              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
+                              "h", 'i', ::std::string("j"))));
+}
+
+// Tests that a MATCHER_Pn() definition can be instantiated with any
+// compatible parameter types.
+TEST(MatcherPnMacroTest, WorksForDifferentParameterTypes) {
+  EXPECT_THAT(123, EqualsSumOf(100L, 20, static_cast<char>(3)));
+  EXPECT_THAT("abcd", EqualsSumOf(::std::string("a"), "b", 'c', "d"));
+
+  EXPECT_THAT(124, Not(EqualsSumOf(100L, 20, static_cast<char>(3))));
+  EXPECT_THAT("abcde", Not(EqualsSumOf(::std::string("a"), "b", 'c', "d")));
+}
+
+// Tests that the matcher body can promote the parameter types.
+
+MATCHER_P2(EqConcat, prefix, suffix, "") {
+  // The following lines promote the two parameters to desired types.
+  std::string prefix_str(prefix);
+  char suffix_char = static_cast<char>(suffix);
+  return arg == prefix_str + suffix_char;
+}
+
+TEST(MatcherPnMacroTest, SimpleTypePromotion) {
+  Matcher<std::string> no_promo =
+      EqConcat(std::string("foo"), 't');
+  Matcher<const std::string&> promo =
+      EqConcat("foo", static_cast<int>('t'));
+  EXPECT_FALSE(no_promo.Matches("fool"));
+  EXPECT_FALSE(promo.Matches("fool"));
+  EXPECT_TRUE(no_promo.Matches("foot"));
+  EXPECT_TRUE(promo.Matches("foot"));
+}
+
+// Verifies the type of a MATCHER*.
+
+TEST(MatcherPnMacroTest, TypesAreCorrect) {
+  // EqualsSumOf() must be assignable to a EqualsSumOfMatcher variable.
+  EqualsSumOfMatcher a0 = EqualsSumOf();
+
+  // EqualsSumOf(1) must be assignable to a EqualsSumOfMatcherP variable.
+  EqualsSumOfMatcherP<int> a1 = EqualsSumOf(1);
+
+  // EqualsSumOf(p1, ..., pk) must be assignable to a EqualsSumOfMatcherPk
+  // variable, and so on.
+  EqualsSumOfMatcherP2<int, char> a2 = EqualsSumOf(1, '2');
+  EqualsSumOfMatcherP3<int, int, char> a3 = EqualsSumOf(1, 2, '3');
+  EqualsSumOfMatcherP4<int, int, int, char> a4 = EqualsSumOf(1, 2, 3, '4');
+  EqualsSumOfMatcherP5<int, int, int, int, char> a5 =
+      EqualsSumOf(1, 2, 3, 4, '5');
+  EqualsSumOfMatcherP6<int, int, int, int, int, char> a6 =
+      EqualsSumOf(1, 2, 3, 4, 5, '6');
+  EqualsSumOfMatcherP7<int, int, int, int, int, int, char> a7 =
+      EqualsSumOf(1, 2, 3, 4, 5, 6, '7');
+  EqualsSumOfMatcherP8<int, int, int, int, int, int, int, char> a8 =
+      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, '8');
+  EqualsSumOfMatcherP9<int, int, int, int, int, int, int, int, char> a9 =
+      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, '9');
+  EqualsSumOfMatcherP10<int, int, int, int, int, int, int, int, int, char> a10 =
+      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, 9, '0');
+
+  // Avoid "unused variable" warnings.
+  (void)a0;
+  (void)a1;
+  (void)a2;
+  (void)a3;
+  (void)a4;
+  (void)a5;
+  (void)a6;
+  (void)a7;
+  (void)a8;
+  (void)a9;
+  (void)a10;
+}
+
+// Tests that matcher-typed parameters can be used in Value() inside a
+// MATCHER_Pn definition.
+
+// Succeeds if arg matches exactly 2 of the 3 matchers.
+MATCHER_P3(TwoOf, m1, m2, m3, "") {
+  const int count = static_cast<int>(Value(arg, m1))
+      + static_cast<int>(Value(arg, m2)) + static_cast<int>(Value(arg, m3));
+  return count == 2;
+}
+
+TEST(MatcherPnMacroTest, CanUseMatcherTypedParameterInValue) {
+  EXPECT_THAT(42, TwoOf(Gt(0), Lt(50), Eq(10)));
+  EXPECT_THAT(0, Not(TwoOf(Gt(-1), Lt(1), Eq(0))));
+}
+
+// Tests Contains().
+
+TEST(ContainsTest, ListMatchesWhenElementIsInContainer) {
+  list<int> some_list;
+  some_list.push_back(3);
+  some_list.push_back(1);
+  some_list.push_back(2);
+  EXPECT_THAT(some_list, Contains(1));
+  EXPECT_THAT(some_list, Contains(Gt(2.5)));
+  EXPECT_THAT(some_list, Contains(Eq(2.0f)));
+
+  list<string> another_list;
+  another_list.push_back("fee");
+  another_list.push_back("fie");
+  another_list.push_back("foe");
+  another_list.push_back("fum");
+  EXPECT_THAT(another_list, Contains(string("fee")));
+}
+
+TEST(ContainsTest, ListDoesNotMatchWhenElementIsNotInContainer) {
+  list<int> some_list;
+  some_list.push_back(3);
+  some_list.push_back(1);
+  EXPECT_THAT(some_list, Not(Contains(4)));
+}
+
+TEST(ContainsTest, SetMatchesWhenElementIsInContainer) {
+  set<int> some_set;
+  some_set.insert(3);
+  some_set.insert(1);
+  some_set.insert(2);
+  EXPECT_THAT(some_set, Contains(Eq(1.0)));
+  EXPECT_THAT(some_set, Contains(Eq(3.0f)));
+  EXPECT_THAT(some_set, Contains(2));
+
+  set<const char*> another_set;
+  another_set.insert("fee");
+  another_set.insert("fie");
+  another_set.insert("foe");
+  another_set.insert("fum");
+  EXPECT_THAT(another_set, Contains(Eq(string("fum"))));
+}
+
+TEST(ContainsTest, SetDoesNotMatchWhenElementIsNotInContainer) {
+  set<int> some_set;
+  some_set.insert(3);
+  some_set.insert(1);
+  EXPECT_THAT(some_set, Not(Contains(4)));
+
+  set<const char*> c_string_set;
+  c_string_set.insert("hello");
+  EXPECT_THAT(c_string_set, Not(Contains(string("hello").c_str())));
+}
+
+TEST(ContainsTest, ExplainsMatchResultCorrectly) {
+  const int a[2] = { 1, 2 };
+  Matcher<const int (&)[2]> m = Contains(2);
+  EXPECT_EQ("whose element #1 matches", Explain(m, a));
+
+  m = Contains(3);
+  EXPECT_EQ("", Explain(m, a));
+
+  m = Contains(GreaterThan(0));
+  EXPECT_EQ("whose element #0 matches, which is 1 more than 0", Explain(m, a));
+
+  m = Contains(GreaterThan(10));
+  EXPECT_EQ("", Explain(m, a));
+}
+
+TEST(ContainsTest, DescribesItselfCorrectly) {
+  Matcher<vector<int> > m = Contains(1);
+  EXPECT_EQ("contains at least one element that is equal to 1", Describe(m));
+
+  Matcher<vector<int> > m2 = Not(m);
+  EXPECT_EQ("doesn't contain any element that is equal to 1", Describe(m2));
+}
+
+TEST(ContainsTest, MapMatchesWhenElementIsInContainer) {
+  map<const char*, int> my_map;
+  const char* bar = "a string";
+  my_map[bar] = 2;
+  EXPECT_THAT(my_map, Contains(pair<const char* const, int>(bar, 2)));
+
+  map<string, int> another_map;
+  another_map["fee"] = 1;
+  another_map["fie"] = 2;
+  another_map["foe"] = 3;
+  another_map["fum"] = 4;
+  EXPECT_THAT(another_map, Contains(pair<const string, int>(string("fee"), 1)));
+  EXPECT_THAT(another_map, Contains(pair<const string, int>("fie", 2)));
+}
+
+TEST(ContainsTest, MapDoesNotMatchWhenElementIsNotInContainer) {
+  map<int, int> some_map;
+  some_map[1] = 11;
+  some_map[2] = 22;
+  EXPECT_THAT(some_map, Not(Contains(pair<const int, int>(2, 23))));
+}
+
+TEST(ContainsTest, ArrayMatchesWhenElementIsInContainer) {
+  const char* string_array[] = { "fee", "fie", "foe", "fum" };
+  EXPECT_THAT(string_array, Contains(Eq(string("fum"))));
+}
+
+TEST(ContainsTest, ArrayDoesNotMatchWhenElementIsNotInContainer) {
+  int int_array[] = { 1, 2, 3, 4 };
+  EXPECT_THAT(int_array, Not(Contains(5)));
+}
+
+TEST(ContainsTest, AcceptsMatcher) {
+  const int a[] = { 1, 2, 3 };
+  EXPECT_THAT(a, Contains(Gt(2)));
+  EXPECT_THAT(a, Not(Contains(Gt(4))));
+}
+
+TEST(ContainsTest, WorksForNativeArrayAsTuple) {
+  const int a[] = { 1, 2 };
+  const int* const pointer = a;
+  EXPECT_THAT(make_tuple(pointer, 2), Contains(1));
+  EXPECT_THAT(make_tuple(pointer, 2), Not(Contains(Gt(3))));
+}
+
+TEST(ContainsTest, WorksForTwoDimensionalNativeArray) {
+  int a[][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
+  EXPECT_THAT(a, Contains(ElementsAre(4, 5, 6)));
+  EXPECT_THAT(a, Contains(Contains(5)));
+  EXPECT_THAT(a, Not(Contains(ElementsAre(3, 4, 5))));
+  EXPECT_THAT(a, Contains(Not(Contains(5))));
+}
+
+TEST(AllOfTest, HugeMatcher) {
+  // Verify that using AllOf with many arguments doesn't cause
+  // the compiler to exceed template instantiation depth limit.
+  EXPECT_THAT(0, testing::AllOf(_, _, _, _, _, _, _, _, _,
+                                testing::AllOf(_, _, _, _, _, _, _, _, _, _)));
+}
+
+TEST(AnyOfTest, HugeMatcher) {
+  // Verify that using AnyOf with many arguments doesn't cause
+  // the compiler to exceed template instantiation depth limit.
+  EXPECT_THAT(0, testing::AnyOf(_, _, _, _, _, _, _, _, _,
+                                testing::AnyOf(_, _, _, _, _, _, _, _, _, _)));
+}
+
+namespace adl_test {
+
+// Verifies that the implementation of ::testing::AllOf and ::testing::AnyOf
+// don't issue unqualified recursive calls.  If they do, the argument dependent
+// name lookup will cause AllOf/AnyOf in the 'adl_test' namespace to be found
+// as a candidate and the compilation will break due to an ambiguous overload.
+
+// The matcher must be in the same namespace as AllOf/AnyOf to make argument
+// dependent lookup find those.
+MATCHER(M, "") { return true; }
+
+template <typename T1, typename T2>
+bool AllOf(const T1& t1, const T2& t2) { return true; }
+
+TEST(AllOfTest, DoesNotCallAllOfUnqualified) {
+  EXPECT_THAT(42, testing::AllOf(
+      M(), M(), M(), M(), M(), M(), M(), M(), M(), M()));
+}
+
+template <typename T1, typename T2> bool
+AnyOf(const T1& t1, const T2& t2) { return true; }
+
+TEST(AnyOfTest, DoesNotCallAnyOfUnqualified) {
+  EXPECT_THAT(42, testing::AnyOf(
+      M(), M(), M(), M(), M(), M(), M(), M(), M(), M()));
+}
+
+}  // namespace adl_test
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-internal-utils_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-internal-utils_test.cc
new file mode 100644
index 00000000..9d5ec609
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-internal-utils_test.cc
@@ -0,0 +1,699 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests the internal utilities.
+
+#include "gmock/internal/gmock-internal-utils.h"
+#include <stdlib.h>
+#include <map>
+#include <memory>
+#include <string>
+#include <sstream>
+#include <vector>
+#include "gmock/gmock.h"
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+#include "gtest/gtest-spi.h"
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+#if GTEST_OS_CYGWIN
+# include <sys/types.h>  // For ssize_t. NOLINT
+#endif
+
+class ProtocolMessage;
+
+namespace proto2 {
+class Message;
+}  // namespace proto2
+
+namespace testing {
+namespace internal {
+
+namespace {
+
+TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) {
+  EXPECT_EQ("", ConvertIdentifierNameToWords(""));
+  EXPECT_EQ("", ConvertIdentifierNameToWords("_"));
+  EXPECT_EQ("", ConvertIdentifierNameToWords("__"));
+}
+
+TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsDigits) {
+  EXPECT_EQ("1", ConvertIdentifierNameToWords("_1"));
+  EXPECT_EQ("2", ConvertIdentifierNameToWords("2_"));
+  EXPECT_EQ("34", ConvertIdentifierNameToWords("_34_"));
+  EXPECT_EQ("34 56", ConvertIdentifierNameToWords("_34_56"));
+}
+
+TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsCamelCaseWords) {
+  EXPECT_EQ("a big word", ConvertIdentifierNameToWords("ABigWord"));
+  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("FooBar"));
+  EXPECT_EQ("foo", ConvertIdentifierNameToWords("Foo_"));
+  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_Foo_Bar_"));
+  EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_Foo__And_Bar"));
+}
+
+TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContains_SeparatedWords) {
+  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("foo_bar"));
+  EXPECT_EQ("foo", ConvertIdentifierNameToWords("_foo_"));
+  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_foo_bar_"));
+  EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_foo__and_bar"));
+}
+
+TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) {
+  EXPECT_EQ("foo bar 123", ConvertIdentifierNameToWords("Foo_bar123"));
+  EXPECT_EQ("chapter 11 section 1",
+            ConvertIdentifierNameToWords("_Chapter11Section_1_"));
+}
+
+TEST(PointeeOfTest, WorksForSmartPointers) {
+  CompileAssertTypesEqual<const char,
+      PointeeOf<internal::linked_ptr<const char> >::type>();
+#if GTEST_HAS_STD_UNIQUE_PTR_
+  CompileAssertTypesEqual<int, PointeeOf<std::unique_ptr<int> >::type>();
+#endif  // GTEST_HAS_STD_UNIQUE_PTR_
+#if GTEST_HAS_STD_SHARED_PTR_
+  CompileAssertTypesEqual<std::string,
+                          PointeeOf<std::shared_ptr<std::string> >::type>();
+#endif  // GTEST_HAS_STD_SHARED_PTR_
+}
+
+TEST(PointeeOfTest, WorksForRawPointers) {
+  CompileAssertTypesEqual<int, PointeeOf<int*>::type>();
+  CompileAssertTypesEqual<const char, PointeeOf<const char*>::type>();
+  CompileAssertTypesEqual<void, PointeeOf<void*>::type>();
+}
+
+TEST(GetRawPointerTest, WorksForSmartPointers) {
+#if GTEST_HAS_STD_UNIQUE_PTR_
+  const char* const raw_p1 = new const char('a');  // NOLINT
+  const std::unique_ptr<const char> p1(raw_p1);
+  EXPECT_EQ(raw_p1, GetRawPointer(p1));
+#endif  // GTEST_HAS_STD_UNIQUE_PTR_
+#if GTEST_HAS_STD_SHARED_PTR_
+  double* const raw_p2 = new double(2.5);  // NOLINT
+  const std::shared_ptr<double> p2(raw_p2);
+  EXPECT_EQ(raw_p2, GetRawPointer(p2));
+#endif  // GTEST_HAS_STD_SHARED_PTR_
+
+  const char* const raw_p4 = new const char('a');  // NOLINT
+  const internal::linked_ptr<const char> p4(raw_p4);
+  EXPECT_EQ(raw_p4, GetRawPointer(p4));
+}
+
+TEST(GetRawPointerTest, WorksForRawPointers) {
+  int* p = NULL;
+  // Don't use EXPECT_EQ as no NULL-testing magic on Symbian.
+  EXPECT_TRUE(NULL == GetRawPointer(p));
+  int n = 1;
+  EXPECT_EQ(&n, GetRawPointer(&n));
+}
+
+// Tests KindOf<T>.
+
+class Base {};
+class Derived : public Base {};
+
+TEST(KindOfTest, Bool) {
+  EXPECT_EQ(kBool, GMOCK_KIND_OF_(bool));  // NOLINT
+}
+
+TEST(KindOfTest, Integer) {
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(char));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(signed char));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned char));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(short));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned short));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(int));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned int));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(Int64));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(UInt64));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t));  // NOLINT
+#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN
+  // ssize_t is not defined on Windows and possibly some other OSes.
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t));  // NOLINT
+#endif
+}
+
+TEST(KindOfTest, FloatingPoint) {
+  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(float));  // NOLINT
+  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(double));  // NOLINT
+  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(long double));  // NOLINT
+}
+
+TEST(KindOfTest, Other) {
+  EXPECT_EQ(kOther, GMOCK_KIND_OF_(void*));  // NOLINT
+  EXPECT_EQ(kOther, GMOCK_KIND_OF_(char**));  // NOLINT
+  EXPECT_EQ(kOther, GMOCK_KIND_OF_(Base));  // NOLINT
+}
+
+// Tests LosslessArithmeticConvertible<T, U>.
+
+TEST(LosslessArithmeticConvertibleTest, BoolToBool) {
+  EXPECT_TRUE((LosslessArithmeticConvertible<bool, bool>::value));
+}
+
+TEST(LosslessArithmeticConvertibleTest, BoolToInteger) {
+  EXPECT_TRUE((LosslessArithmeticConvertible<bool, char>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<bool, int>::value));
+  EXPECT_TRUE(
+      (LosslessArithmeticConvertible<bool, unsigned long>::value));  // NOLINT
+}
+
+TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) {
+  EXPECT_TRUE((LosslessArithmeticConvertible<bool, float>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<bool, double>::value));
+}
+
+TEST(LosslessArithmeticConvertibleTest, IntegerToBool) {
+  EXPECT_FALSE((LosslessArithmeticConvertible<unsigned char, bool>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<int, bool>::value));
+}
+
+TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) {
+  // Unsigned => larger signed is fine.
+  EXPECT_TRUE((LosslessArithmeticConvertible<unsigned char, int>::value));
+
+  // Unsigned => larger unsigned is fine.
+  EXPECT_TRUE(
+      (LosslessArithmeticConvertible<unsigned short, UInt64>::value)); // NOLINT
+
+  // Signed => unsigned is not fine.
+  EXPECT_FALSE((LosslessArithmeticConvertible<short, UInt64>::value)); // NOLINT
+  EXPECT_FALSE((LosslessArithmeticConvertible<
+      signed char, unsigned int>::value));  // NOLINT
+
+  // Same size and same signedness: fine too.
+  EXPECT_TRUE((LosslessArithmeticConvertible<
+               unsigned char, unsigned char>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<int, int>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<wchar_t, wchar_t>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<
+               unsigned long, unsigned long>::value));  // NOLINT
+
+  // Same size, different signedness: not fine.
+  EXPECT_FALSE((LosslessArithmeticConvertible<
+                unsigned char, signed char>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<int, unsigned int>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<UInt64, Int64>::value));
+
+  // Larger size => smaller size is not fine.
+  EXPECT_FALSE((LosslessArithmeticConvertible<long, char>::value));  // NOLINT
+  EXPECT_FALSE((LosslessArithmeticConvertible<int, signed char>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<Int64, unsigned int>::value));
+}
+
+TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) {
+  // Integers cannot be losslessly converted to floating-points, as
+  // the format of the latter is implementation-defined.
+  EXPECT_FALSE((LosslessArithmeticConvertible<char, float>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<int, double>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<
+                short, long double>::value));  // NOLINT
+}
+
+TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) {
+  EXPECT_FALSE((LosslessArithmeticConvertible<float, bool>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<double, bool>::value));
+}
+
+TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) {
+  EXPECT_FALSE((LosslessArithmeticConvertible<float, long>::value));  // NOLINT
+  EXPECT_FALSE((LosslessArithmeticConvertible<double, Int64>::value));
+  EXPECT_FALSE((LosslessArithmeticConvertible<long double, int>::value));
+}
+
+TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) {
+  // Smaller size => larger size is fine.
+  EXPECT_TRUE((LosslessArithmeticConvertible<float, double>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<float, long double>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<double, long double>::value));
+
+  // Same size: fine.
+  EXPECT_TRUE((LosslessArithmeticConvertible<float, float>::value));
+  EXPECT_TRUE((LosslessArithmeticConvertible<double, double>::value));
+
+  // Larger size => smaller size is not fine.
+  EXPECT_FALSE((LosslessArithmeticConvertible<double, float>::value));
+  GTEST_INTENTIONAL_CONST_COND_PUSH_()
+  if (sizeof(double) == sizeof(long double)) {  // NOLINT
+  GTEST_INTENTIONAL_CONST_COND_POP_()
+    // In some implementations (e.g. MSVC), double and long double
+    // have the same size.
+    EXPECT_TRUE((LosslessArithmeticConvertible<long double, double>::value));
+  } else {
+    EXPECT_FALSE((LosslessArithmeticConvertible<long double, double>::value));
+  }
+}
+
+// Tests the TupleMatches() template function.
+
+TEST(TupleMatchesTest, WorksForSize0) {
+  tuple<> matchers;
+  tuple<> values;
+
+  EXPECT_TRUE(TupleMatches(matchers, values));
+}
+
+TEST(TupleMatchesTest, WorksForSize1) {
+  tuple<Matcher<int> > matchers(Eq(1));
+  tuple<int> values1(1),
+      values2(2);
+
+  EXPECT_TRUE(TupleMatches(matchers, values1));
+  EXPECT_FALSE(TupleMatches(matchers, values2));
+}
+
+TEST(TupleMatchesTest, WorksForSize2) {
+  tuple<Matcher<int>, Matcher<char> > matchers(Eq(1), Eq('a'));
+  tuple<int, char> values1(1, 'a'),
+      values2(1, 'b'),
+      values3(2, 'a'),
+      values4(2, 'b');
+
+  EXPECT_TRUE(TupleMatches(matchers, values1));
+  EXPECT_FALSE(TupleMatches(matchers, values2));
+  EXPECT_FALSE(TupleMatches(matchers, values3));
+  EXPECT_FALSE(TupleMatches(matchers, values4));
+}
+
+TEST(TupleMatchesTest, WorksForSize5) {
+  tuple<Matcher<int>, Matcher<char>, Matcher<bool>, Matcher<long>,  // NOLINT
+      Matcher<string> >
+      matchers(Eq(1), Eq('a'), Eq(true), Eq(2L), Eq("hi"));
+  tuple<int, char, bool, long, string>  // NOLINT
+      values1(1, 'a', true, 2L, "hi"),
+      values2(1, 'a', true, 2L, "hello"),
+      values3(2, 'a', true, 2L, "hi");
+
+  EXPECT_TRUE(TupleMatches(matchers, values1));
+  EXPECT_FALSE(TupleMatches(matchers, values2));
+  EXPECT_FALSE(TupleMatches(matchers, values3));
+}
+
+// Tests that Assert(true, ...) succeeds.
+TEST(AssertTest, SucceedsOnTrue) {
+  Assert(true, __FILE__, __LINE__, "This should succeed.");
+  Assert(true, __FILE__, __LINE__);  // This should succeed too.
+}
+
+// Tests that Assert(false, ...) generates a fatal failure.
+TEST(AssertTest, FailsFatallyOnFalse) {
+  EXPECT_DEATH_IF_SUPPORTED({
+    Assert(false, __FILE__, __LINE__, "This should fail.");
+  }, "");
+
+  EXPECT_DEATH_IF_SUPPORTED({
+    Assert(false, __FILE__, __LINE__);
+  }, "");
+}
+
+// Tests that Expect(true, ...) succeeds.
+TEST(ExpectTest, SucceedsOnTrue) {
+  Expect(true, __FILE__, __LINE__, "This should succeed.");
+  Expect(true, __FILE__, __LINE__);  // This should succeed too.
+}
+
+// Tests that Expect(false, ...) generates a non-fatal failure.
+TEST(ExpectTest, FailsNonfatallyOnFalse) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    Expect(false, __FILE__, __LINE__, "This should fail.");
+  }, "This should fail");
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    Expect(false, __FILE__, __LINE__);
+  }, "Expectation failed");
+}
+
+// Tests LogIsVisible().
+
+class LogIsVisibleTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    original_verbose_ = GMOCK_FLAG(verbose);
+  }
+
+  virtual void TearDown() { GMOCK_FLAG(verbose) = original_verbose_; }
+
+  string original_verbose_;
+};
+
+TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) {
+  GMOCK_FLAG(verbose) = kInfoVerbosity;
+  EXPECT_TRUE(LogIsVisible(kInfo));
+  EXPECT_TRUE(LogIsVisible(kWarning));
+}
+
+TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) {
+  GMOCK_FLAG(verbose) = kErrorVerbosity;
+  EXPECT_FALSE(LogIsVisible(kInfo));
+  EXPECT_FALSE(LogIsVisible(kWarning));
+}
+
+TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
+  GMOCK_FLAG(verbose) = kWarningVerbosity;
+  EXPECT_FALSE(LogIsVisible(kInfo));
+  EXPECT_TRUE(LogIsVisible(kWarning));
+}
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Tests the Log() function.
+
+// Verifies that Log() behaves correctly for the given verbosity level
+// and log severity.
+void TestLogWithSeverity(const string& verbosity, LogSeverity severity,
+                         bool should_print) {
+  const string old_flag = GMOCK_FLAG(verbose);
+  GMOCK_FLAG(verbose) = verbosity;
+  CaptureStdout();
+  Log(severity, "Test log.\n", 0);
+  if (should_print) {
+    EXPECT_THAT(GetCapturedStdout().c_str(),
+                ContainsRegex(
+                    severity == kWarning ?
+                    "^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n" :
+                    "^\nTest log\\.\nStack trace:\n"));
+  } else {
+    EXPECT_STREQ("", GetCapturedStdout().c_str());
+  }
+  GMOCK_FLAG(verbose) = old_flag;
+}
+
+// Tests that when the stack_frames_to_skip parameter is negative,
+// Log() doesn't include the stack trace in the output.
+TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) {
+  const string saved_flag = GMOCK_FLAG(verbose);
+  GMOCK_FLAG(verbose) = kInfoVerbosity;
+  CaptureStdout();
+  Log(kInfo, "Test log.\n", -1);
+  EXPECT_STREQ("\nTest log.\n", GetCapturedStdout().c_str());
+  GMOCK_FLAG(verbose) = saved_flag;
+}
+
+struct MockStackTraceGetter : testing::internal::OsStackTraceGetterInterface {
+  virtual string CurrentStackTrace(int max_depth, int skip_count) {
+    return (testing::Message() << max_depth << "::" << skip_count << "\n")
+        .GetString();
+  }
+  virtual void UponLeavingGTest() {}
+};
+
+// Tests that in opt mode, a positive stack_frames_to_skip argument is
+// treated as 0.
+TEST(LogTest, NoSkippingStackFrameInOptMode) {
+  MockStackTraceGetter* mock_os_stack_trace_getter = new MockStackTraceGetter;
+  GetUnitTestImpl()->set_os_stack_trace_getter(mock_os_stack_trace_getter);
+
+  CaptureStdout();
+  Log(kWarning, "Test log.\n", 100);
+  const string log = GetCapturedStdout();
+
+  string expected_trace =
+      (testing::Message() << GTEST_FLAG(stack_trace_depth) << "::").GetString();
+  string expected_message =
+      "\nGMOCK WARNING:\n"
+      "Test log.\n"
+      "Stack trace:\n" +
+      expected_trace;
+  EXPECT_THAT(log, HasSubstr(expected_message));
+  int skip_count = atoi(log.substr(expected_message.size()).c_str());
+
+# if defined(NDEBUG)
+  // In opt mode, no stack frame should be skipped.
+  const int expected_skip_count = 0;
+# else
+  // In dbg mode, the stack frames should be skipped.
+  const int expected_skip_count = 100;
+# endif
+
+  // Note that each inner implementation layer will +1 the number to remove
+  // itself from the trace. This means that the value is a little higher than
+  // expected, but close enough.
+  EXPECT_THAT(skip_count,
+              AllOf(Ge(expected_skip_count), Le(expected_skip_count + 10)));
+
+  // Restores the default OS stack trace getter.
+  GetUnitTestImpl()->set_os_stack_trace_getter(NULL);
+}
+
+// Tests that all logs are printed when the value of the
+// --gmock_verbose flag is "info".
+TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) {
+  TestLogWithSeverity(kInfoVerbosity, kInfo, true);
+  TestLogWithSeverity(kInfoVerbosity, kWarning, true);
+}
+
+// Tests that only warnings are printed when the value of the
+// --gmock_verbose flag is "warning".
+TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsWarning) {
+  TestLogWithSeverity(kWarningVerbosity, kInfo, false);
+  TestLogWithSeverity(kWarningVerbosity, kWarning, true);
+}
+
+// Tests that no logs are printed when the value of the
+// --gmock_verbose flag is "error".
+TEST(LogTest, NoLogsArePrintedWhenVerbosityIsError) {
+  TestLogWithSeverity(kErrorVerbosity, kInfo, false);
+  TestLogWithSeverity(kErrorVerbosity, kWarning, false);
+}
+
+// Tests that only warnings are printed when the value of the
+// --gmock_verbose flag is invalid.
+TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) {
+  TestLogWithSeverity("invalid", kInfo, false);
+  TestLogWithSeverity("invalid", kWarning, true);
+}
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+TEST(TypeTraitsTest, true_type) {
+  EXPECT_TRUE(true_type::value);
+}
+
+TEST(TypeTraitsTest, false_type) {
+  EXPECT_FALSE(false_type::value);
+}
+
+TEST(TypeTraitsTest, is_reference) {
+  EXPECT_FALSE(is_reference<int>::value);
+  EXPECT_FALSE(is_reference<char*>::value);
+  EXPECT_TRUE(is_reference<const int&>::value);
+}
+
+TEST(TypeTraitsTest, is_pointer) {
+  EXPECT_FALSE(is_pointer<int>::value);
+  EXPECT_FALSE(is_pointer<char&>::value);
+  EXPECT_TRUE(is_pointer<const int*>::value);
+}
+
+TEST(TypeTraitsTest, type_equals) {
+  EXPECT_FALSE((type_equals<int, const int>::value));
+  EXPECT_FALSE((type_equals<int, int&>::value));
+  EXPECT_FALSE((type_equals<int, double>::value));
+  EXPECT_TRUE((type_equals<char, char>::value));
+}
+
+TEST(TypeTraitsTest, remove_reference) {
+  EXPECT_TRUE((type_equals<char, remove_reference<char&>::type>::value));
+  EXPECT_TRUE((type_equals<const int,
+               remove_reference<const int&>::type>::value));
+  EXPECT_TRUE((type_equals<int, remove_reference<int>::type>::value));
+  EXPECT_TRUE((type_equals<double*, remove_reference<double*>::type>::value));
+}
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Verifies that Log() behaves correctly for the given verbosity level
+// and log severity.
+std::string GrabOutput(void(*logger)(), const char* verbosity) {
+  const string saved_flag = GMOCK_FLAG(verbose);
+  GMOCK_FLAG(verbose) = verbosity;
+  CaptureStdout();
+  logger();
+  GMOCK_FLAG(verbose) = saved_flag;
+  return GetCapturedStdout();
+}
+
+class DummyMock {
+ public:
+  MOCK_METHOD0(TestMethod, void());
+  MOCK_METHOD1(TestMethodArg, void(int dummy));
+};
+
+void ExpectCallLogger() {
+  DummyMock mock;
+  EXPECT_CALL(mock, TestMethod());
+  mock.TestMethod();
+};
+
+// Verifies that EXPECT_CALL logs if the --gmock_verbose flag is set to "info".
+TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) {
+  EXPECT_THAT(std::string(GrabOutput(ExpectCallLogger, kInfoVerbosity)),
+              HasSubstr("EXPECT_CALL(mock, TestMethod())"));
+}
+
+// Verifies that EXPECT_CALL doesn't log
+// if the --gmock_verbose flag is set to "warning".
+TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) {
+  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kWarningVerbosity).c_str());
+}
+
+// Verifies that EXPECT_CALL doesn't log
+// if the --gmock_verbose flag is set to "error".
+TEST(ExpectCallTest,  DoesNotLogWhenVerbosityIsError) {
+  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str());
+}
+
+void OnCallLogger() {
+  DummyMock mock;
+  ON_CALL(mock, TestMethod());
+};
+
+// Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info".
+TEST(OnCallTest, LogsWhenVerbosityIsInfo) {
+  EXPECT_THAT(std::string(GrabOutput(OnCallLogger, kInfoVerbosity)),
+              HasSubstr("ON_CALL(mock, TestMethod())"));
+}
+
+// Verifies that ON_CALL doesn't log
+// if the --gmock_verbose flag is set to "warning".
+TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) {
+  EXPECT_STREQ("", GrabOutput(OnCallLogger, kWarningVerbosity).c_str());
+}
+
+// Verifies that ON_CALL doesn't log if
+// the --gmock_verbose flag is set to "error".
+TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {
+  EXPECT_STREQ("", GrabOutput(OnCallLogger, kErrorVerbosity).c_str());
+}
+
+void OnCallAnyArgumentLogger() {
+  DummyMock mock;
+  ON_CALL(mock, TestMethodArg(_));
+}
+
+// Verifies that ON_CALL prints provided _ argument.
+TEST(OnCallTest, LogsAnythingArgument) {
+  EXPECT_THAT(std::string(GrabOutput(OnCallAnyArgumentLogger, kInfoVerbosity)),
+              HasSubstr("ON_CALL(mock, TestMethodArg(_)"));
+}
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// Tests StlContainerView.
+
+TEST(StlContainerViewTest, WorksForStlContainer) {
+  StaticAssertTypeEq<std::vector<int>,
+      StlContainerView<std::vector<int> >::type>();
+  StaticAssertTypeEq<const std::vector<double>&,
+      StlContainerView<std::vector<double> >::const_reference>();
+
+  typedef std::vector<char> Chars;
+  Chars v1;
+  const Chars& v2(StlContainerView<Chars>::ConstReference(v1));
+  EXPECT_EQ(&v1, &v2);
+
+  v1.push_back('a');
+  Chars v3 = StlContainerView<Chars>::Copy(v1);
+  EXPECT_THAT(v3, Eq(v3));
+}
+
+TEST(StlContainerViewTest, WorksForStaticNativeArray) {
+  StaticAssertTypeEq<NativeArray<int>,
+      StlContainerView<int[3]>::type>();
+  StaticAssertTypeEq<NativeArray<double>,
+      StlContainerView<const double[4]>::type>();
+  StaticAssertTypeEq<NativeArray<char[3]>,
+      StlContainerView<const char[2][3]>::type>();
+
+  StaticAssertTypeEq<const NativeArray<int>,
+      StlContainerView<int[2]>::const_reference>();
+
+  int a1[3] = { 0, 1, 2 };
+  NativeArray<int> a2 = StlContainerView<int[3]>::ConstReference(a1);
+  EXPECT_EQ(3U, a2.size());
+  EXPECT_EQ(a1, a2.begin());
+
+  const NativeArray<int> a3 = StlContainerView<int[3]>::Copy(a1);
+  ASSERT_EQ(3U, a3.size());
+  EXPECT_EQ(0, a3.begin()[0]);
+  EXPECT_EQ(1, a3.begin()[1]);
+  EXPECT_EQ(2, a3.begin()[2]);
+
+  // Makes sure a1 and a3 aren't aliases.
+  a1[0] = 3;
+  EXPECT_EQ(0, a3.begin()[0]);
+}
+
+TEST(StlContainerViewTest, WorksForDynamicNativeArray) {
+  StaticAssertTypeEq<NativeArray<int>,
+      StlContainerView<tuple<const int*, size_t> >::type>();
+  StaticAssertTypeEq<NativeArray<double>,
+      StlContainerView<tuple<linked_ptr<double>, int> >::type>();
+
+  StaticAssertTypeEq<const NativeArray<int>,
+      StlContainerView<tuple<const int*, int> >::const_reference>();
+
+  int a1[3] = { 0, 1, 2 };
+  const int* const p1 = a1;
+  NativeArray<int> a2 = StlContainerView<tuple<const int*, int> >::
+      ConstReference(make_tuple(p1, 3));
+  EXPECT_EQ(3U, a2.size());
+  EXPECT_EQ(a1, a2.begin());
+
+  const NativeArray<int> a3 = StlContainerView<tuple<int*, size_t> >::
+      Copy(make_tuple(static_cast<int*>(a1), 3));
+  ASSERT_EQ(3U, a3.size());
+  EXPECT_EQ(0, a3.begin()[0]);
+  EXPECT_EQ(1, a3.begin()[1]);
+  EXPECT_EQ(2, a3.begin()[2]);
+
+  // Makes sure a1 and a3 aren't aliases.
+  a1[0] = 3;
+  EXPECT_EQ(0, a3.begin()[0]);
+}
+
+}  // namespace
+}  // namespace internal
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-matchers_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-matchers_test.cc
new file mode 100644
index 00000000..9f62c3d8
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-matchers_test.cc
@@ -0,0 +1,5652 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests some commonly used argument matchers.
+
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock-more-matchers.h"
+
+#include <string.h>
+#include <time.h>
+#include <deque>
+#include <functional>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <list>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "gtest/gtest-spi.h"
+
+#if GTEST_HAS_STD_FORWARD_LIST_
+# include <forward_list>  // NOLINT
+#endif
+
+namespace testing {
+
+namespace internal {
+GTEST_API_ string JoinAsTuple(const Strings& fields);
+}  // namespace internal
+
+namespace gmock_matchers_test {
+
+using std::greater;
+using std::less;
+using std::list;
+using std::make_pair;
+using std::map;
+using std::multimap;
+using std::multiset;
+using std::ostream;
+using std::pair;
+using std::set;
+using std::stringstream;
+using std::vector;
+using testing::A;
+using testing::AllArgs;
+using testing::AllOf;
+using testing::An;
+using testing::AnyOf;
+using testing::ByRef;
+using testing::ContainsRegex;
+using testing::DoubleEq;
+using testing::DoubleNear;
+using testing::EndsWith;
+using testing::Eq;
+using testing::ExplainMatchResult;
+using testing::Field;
+using testing::FloatEq;
+using testing::FloatNear;
+using testing::Ge;
+using testing::Gt;
+using testing::HasSubstr;
+using testing::IsEmpty;
+using testing::IsNull;
+using testing::Key;
+using testing::Le;
+using testing::Lt;
+using testing::MakeMatcher;
+using testing::MakePolymorphicMatcher;
+using testing::MatchResultListener;
+using testing::Matcher;
+using testing::MatcherCast;
+using testing::MatcherInterface;
+using testing::Matches;
+using testing::MatchesRegex;
+using testing::NanSensitiveDoubleEq;
+using testing::NanSensitiveDoubleNear;
+using testing::NanSensitiveFloatEq;
+using testing::NanSensitiveFloatNear;
+using testing::Ne;
+using testing::Not;
+using testing::NotNull;
+using testing::Pair;
+using testing::Pointee;
+using testing::Pointwise;
+using testing::PolymorphicMatcher;
+using testing::Property;
+using testing::Ref;
+using testing::ResultOf;
+using testing::SizeIs;
+using testing::StartsWith;
+using testing::StrCaseEq;
+using testing::StrCaseNe;
+using testing::StrEq;
+using testing::StrNe;
+using testing::StringMatchResultListener;
+using testing::Truly;
+using testing::TypedEq;
+using testing::UnorderedPointwise;
+using testing::Value;
+using testing::WhenSorted;
+using testing::WhenSortedBy;
+using testing::_;
+using testing::get;
+using testing::internal::DummyMatchResultListener;
+using testing::internal::ElementMatcherPair;
+using testing::internal::ElementMatcherPairs;
+using testing::internal::ExplainMatchFailureTupleTo;
+using testing::internal::FloatingEqMatcher;
+using testing::internal::FormatMatcherDescription;
+using testing::internal::IsReadableTypeName;
+using testing::internal::JoinAsTuple;
+using testing::internal::linked_ptr;
+using testing::internal::MatchMatrix;
+using testing::internal::RE;
+using testing::internal::scoped_ptr;
+using testing::internal::StreamMatchResultListener;
+using testing::internal::Strings;
+using testing::internal::linked_ptr;
+using testing::internal::scoped_ptr;
+using testing::internal::string;
+using testing::make_tuple;
+using testing::tuple;
+
+// For testing ExplainMatchResultTo().
+class GreaterThanMatcher : public MatcherInterface<int> {
+ public:
+  explicit GreaterThanMatcher(int rhs) : rhs_(rhs) {}
+
+  virtual void DescribeTo(ostream* os) const {
+    *os << "is > " << rhs_;
+  }
+
+  virtual bool MatchAndExplain(int lhs,
+                               MatchResultListener* listener) const {
+    const int diff = lhs - rhs_;
+    if (diff > 0) {
+      *listener << "which is " << diff << " more than " << rhs_;
+    } else if (diff == 0) {
+      *listener << "which is the same as " << rhs_;
+    } else {
+      *listener << "which is " << -diff << " less than " << rhs_;
+    }
+
+    return lhs > rhs_;
+  }
+
+ private:
+  int rhs_;
+};
+
+Matcher<int> GreaterThan(int n) {
+  return MakeMatcher(new GreaterThanMatcher(n));
+}
+
+string OfType(const string& type_name) {
+#if GTEST_HAS_RTTI
+  return " (of type " + type_name + ")";
+#else
+  return "";
+#endif
+}
+
+// Returns the description of the given matcher.
+template <typename T>
+string Describe(const Matcher<T>& m) {
+  stringstream ss;
+  m.DescribeTo(&ss);
+  return ss.str();
+}
+
+// Returns the description of the negation of the given matcher.
+template <typename T>
+string DescribeNegation(const Matcher<T>& m) {
+  stringstream ss;
+  m.DescribeNegationTo(&ss);
+  return ss.str();
+}
+
+// Returns the reason why x matches, or doesn't match, m.
+template <typename MatcherType, typename Value>
+string Explain(const MatcherType& m, const Value& x) {
+  StringMatchResultListener listener;
+  ExplainMatchResult(m, x, &listener);
+  return listener.str();
+}
+
+TEST(MatchResultListenerTest, StreamingWorks) {
+  StringMatchResultListener listener;
+  listener << "hi" << 5;
+  EXPECT_EQ("hi5", listener.str());
+
+  listener.Clear();
+  EXPECT_EQ("", listener.str());
+
+  listener << 42;
+  EXPECT_EQ("42", listener.str());
+
+  // Streaming shouldn't crash when the underlying ostream is NULL.
+  DummyMatchResultListener dummy;
+  dummy << "hi" << 5;
+}
+
+TEST(MatchResultListenerTest, CanAccessUnderlyingStream) {
+  EXPECT_TRUE(DummyMatchResultListener().stream() == NULL);
+  EXPECT_TRUE(StreamMatchResultListener(NULL).stream() == NULL);
+
+  EXPECT_EQ(&std::cout, StreamMatchResultListener(&std::cout).stream());
+}
+
+TEST(MatchResultListenerTest, IsInterestedWorks) {
+  EXPECT_TRUE(StringMatchResultListener().IsInterested());
+  EXPECT_TRUE(StreamMatchResultListener(&std::cout).IsInterested());
+
+  EXPECT_FALSE(DummyMatchResultListener().IsInterested());
+  EXPECT_FALSE(StreamMatchResultListener(NULL).IsInterested());
+}
+
+// Makes sure that the MatcherInterface<T> interface doesn't
+// change.
+class EvenMatcherImpl : public MatcherInterface<int> {
+ public:
+  virtual bool MatchAndExplain(int x,
+                               MatchResultListener* /* listener */) const {
+    return x % 2 == 0;
+  }
+
+  virtual void DescribeTo(ostream* os) const {
+    *os << "is an even number";
+  }
+
+  // We deliberately don't define DescribeNegationTo() and
+  // ExplainMatchResultTo() here, to make sure the definition of these
+  // two methods is optional.
+};
+
+// Makes sure that the MatcherInterface API doesn't change.
+TEST(MatcherInterfaceTest, CanBeImplementedUsingPublishedAPI) {
+  EvenMatcherImpl m;
+}
+
+// Tests implementing a monomorphic matcher using MatchAndExplain().
+
+class NewEvenMatcherImpl : public MatcherInterface<int> {
+ public:
+  virtual bool MatchAndExplain(int x, MatchResultListener* listener) const {
+    const bool match = x % 2 == 0;
+    // Verifies that we can stream to a listener directly.
+    *listener << "value % " << 2;
+    if (listener->stream() != NULL) {
+      // Verifies that we can stream to a listener's underlying stream
+      // too.
+      *listener->stream() << " == " << (x % 2);
+    }
+    return match;
+  }
+
+  virtual void DescribeTo(ostream* os) const {
+    *os << "is an even number";
+  }
+};
+
+TEST(MatcherInterfaceTest, CanBeImplementedUsingNewAPI) {
+  Matcher<int> m = MakeMatcher(new NewEvenMatcherImpl);
+  EXPECT_TRUE(m.Matches(2));
+  EXPECT_FALSE(m.Matches(3));
+  EXPECT_EQ("value % 2 == 0", Explain(m, 2));
+  EXPECT_EQ("value % 2 == 1", Explain(m, 3));
+}
+
+// Tests default-constructing a matcher.
+TEST(MatcherTest, CanBeDefaultConstructed) {
+  Matcher<double> m;
+}
+
+// Tests that Matcher<T> can be constructed from a MatcherInterface<T>*.
+TEST(MatcherTest, CanBeConstructedFromMatcherInterface) {
+  const MatcherInterface<int>* impl = new EvenMatcherImpl;
+  Matcher<int> m(impl);
+  EXPECT_TRUE(m.Matches(4));
+  EXPECT_FALSE(m.Matches(5));
+}
+
+// Tests that value can be used in place of Eq(value).
+TEST(MatcherTest, CanBeImplicitlyConstructedFromValue) {
+  Matcher<int> m1 = 5;
+  EXPECT_TRUE(m1.Matches(5));
+  EXPECT_FALSE(m1.Matches(6));
+}
+
+// Tests that NULL can be used in place of Eq(NULL).
+TEST(MatcherTest, CanBeImplicitlyConstructedFromNULL) {
+  Matcher<int*> m1 = NULL;
+  EXPECT_TRUE(m1.Matches(NULL));
+  int n = 0;
+  EXPECT_FALSE(m1.Matches(&n));
+}
+
+// Tests that matchers are copyable.
+TEST(MatcherTest, IsCopyable) {
+  // Tests the copy constructor.
+  Matcher<bool> m1 = Eq(false);
+  EXPECT_TRUE(m1.Matches(false));
+  EXPECT_FALSE(m1.Matches(true));
+
+  // Tests the assignment operator.
+  m1 = Eq(true);
+  EXPECT_TRUE(m1.Matches(true));
+  EXPECT_FALSE(m1.Matches(false));
+}
+
+// Tests that Matcher<T>::DescribeTo() calls
+// MatcherInterface<T>::DescribeTo().
+TEST(MatcherTest, CanDescribeItself) {
+  EXPECT_EQ("is an even number",
+            Describe(Matcher<int>(new EvenMatcherImpl)));
+}
+
+// Tests Matcher<T>::MatchAndExplain().
+TEST(MatcherTest, MatchAndExplain) {
+  Matcher<int> m = GreaterThan(0);
+  StringMatchResultListener listener1;
+  EXPECT_TRUE(m.MatchAndExplain(42, &listener1));
+  EXPECT_EQ("which is 42 more than 0", listener1.str());
+
+  StringMatchResultListener listener2;
+  EXPECT_FALSE(m.MatchAndExplain(-9, &listener2));
+  EXPECT_EQ("which is 9 less than 0", listener2.str());
+}
+
+// Tests that a C-string literal can be implicitly converted to a
+// Matcher<string> or Matcher<const string&>.
+TEST(StringMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
+  Matcher<string> m1 = "hi";
+  EXPECT_TRUE(m1.Matches("hi"));
+  EXPECT_FALSE(m1.Matches("hello"));
+
+  Matcher<const string&> m2 = "hi";
+  EXPECT_TRUE(m2.Matches("hi"));
+  EXPECT_FALSE(m2.Matches("hello"));
+}
+
+// Tests that a string object can be implicitly converted to a
+// Matcher<string> or Matcher<const string&>.
+TEST(StringMatcherTest, CanBeImplicitlyConstructedFromString) {
+  Matcher<string> m1 = string("hi");
+  EXPECT_TRUE(m1.Matches("hi"));
+  EXPECT_FALSE(m1.Matches("hello"));
+
+  Matcher<const string&> m2 = string("hi");
+  EXPECT_TRUE(m2.Matches("hi"));
+  EXPECT_FALSE(m2.Matches("hello"));
+}
+
+#if GTEST_HAS_STRING_PIECE_
+// Tests that a C-string literal can be implicitly converted to a
+// Matcher<StringPiece> or Matcher<const StringPiece&>.
+TEST(StringPieceMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
+  Matcher<StringPiece> m1 = "cats";
+  EXPECT_TRUE(m1.Matches("cats"));
+  EXPECT_FALSE(m1.Matches("dogs"));
+
+  Matcher<const StringPiece&> m2 = "cats";
+  EXPECT_TRUE(m2.Matches("cats"));
+  EXPECT_FALSE(m2.Matches("dogs"));
+}
+
+// Tests that a string object can be implicitly converted to a
+// Matcher<StringPiece> or Matcher<const StringPiece&>.
+TEST(StringPieceMatcherTest, CanBeImplicitlyConstructedFromString) {
+  Matcher<StringPiece> m1 = string("cats");
+  EXPECT_TRUE(m1.Matches("cats"));
+  EXPECT_FALSE(m1.Matches("dogs"));
+
+  Matcher<const StringPiece&> m2 = string("cats");
+  EXPECT_TRUE(m2.Matches("cats"));
+  EXPECT_FALSE(m2.Matches("dogs"));
+}
+
+// Tests that a StringPiece object can be implicitly converted to a
+// Matcher<StringPiece> or Matcher<const StringPiece&>.
+TEST(StringPieceMatcherTest, CanBeImplicitlyConstructedFromStringPiece) {
+  Matcher<StringPiece> m1 = StringPiece("cats");
+  EXPECT_TRUE(m1.Matches("cats"));
+  EXPECT_FALSE(m1.Matches("dogs"));
+
+  Matcher<const StringPiece&> m2 = StringPiece("cats");
+  EXPECT_TRUE(m2.Matches("cats"));
+  EXPECT_FALSE(m2.Matches("dogs"));
+}
+#endif  // GTEST_HAS_STRING_PIECE_
+
+// Tests that MakeMatcher() constructs a Matcher<T> from a
+// MatcherInterface* without requiring the user to explicitly
+// write the type.
+TEST(MakeMatcherTest, ConstructsMatcherFromMatcherInterface) {
+  const MatcherInterface<int>* dummy_impl = NULL;
+  Matcher<int> m = MakeMatcher(dummy_impl);
+}
+
+// Tests that MakePolymorphicMatcher() can construct a polymorphic
+// matcher from its implementation using the old API.
+const int g_bar = 1;
+class ReferencesBarOrIsZeroImpl {
+ public:
+  template <typename T>
+  bool MatchAndExplain(const T& x,
+                       MatchResultListener* /* listener */) const {
+    const void* p = &x;
+    return p == &g_bar || x == 0;
+  }
+
+  void DescribeTo(ostream* os) const { *os << "g_bar or zero"; }
+
+  void DescribeNegationTo(ostream* os) const {
+    *os << "doesn't reference g_bar and is not zero";
+  }
+};
+
+// This function verifies that MakePolymorphicMatcher() returns a
+// PolymorphicMatcher<T> where T is the argument's type.
+PolymorphicMatcher<ReferencesBarOrIsZeroImpl> ReferencesBarOrIsZero() {
+  return MakePolymorphicMatcher(ReferencesBarOrIsZeroImpl());
+}
+
+TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingOldAPI) {
+  // Using a polymorphic matcher to match a reference type.
+  Matcher<const int&> m1 = ReferencesBarOrIsZero();
+  EXPECT_TRUE(m1.Matches(0));
+  // Verifies that the identity of a by-reference argument is preserved.
+  EXPECT_TRUE(m1.Matches(g_bar));
+  EXPECT_FALSE(m1.Matches(1));
+  EXPECT_EQ("g_bar or zero", Describe(m1));
+
+  // Using a polymorphic matcher to match a value type.
+  Matcher<double> m2 = ReferencesBarOrIsZero();
+  EXPECT_TRUE(m2.Matches(0.0));
+  EXPECT_FALSE(m2.Matches(0.1));
+  EXPECT_EQ("g_bar or zero", Describe(m2));
+}
+
+// Tests implementing a polymorphic matcher using MatchAndExplain().
+
+class PolymorphicIsEvenImpl {
+ public:
+  void DescribeTo(ostream* os) const { *os << "is even"; }
+
+  void DescribeNegationTo(ostream* os) const {
+    *os << "is odd";
+  }
+
+  template <typename T>
+  bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
+    // Verifies that we can stream to the listener directly.
+    *listener << "% " << 2;
+    if (listener->stream() != NULL) {
+      // Verifies that we can stream to the listener's underlying stream
+      // too.
+      *listener->stream() << " == " << (x % 2);
+    }
+    return (x % 2) == 0;
+  }
+};
+
+PolymorphicMatcher<PolymorphicIsEvenImpl> PolymorphicIsEven() {
+  return MakePolymorphicMatcher(PolymorphicIsEvenImpl());
+}
+
+TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingNewAPI) {
+  // Using PolymorphicIsEven() as a Matcher<int>.
+  const Matcher<int> m1 = PolymorphicIsEven();
+  EXPECT_TRUE(m1.Matches(42));
+  EXPECT_FALSE(m1.Matches(43));
+  EXPECT_EQ("is even", Describe(m1));
+
+  const Matcher<int> not_m1 = Not(m1);
+  EXPECT_EQ("is odd", Describe(not_m1));
+
+  EXPECT_EQ("% 2 == 0", Explain(m1, 42));
+
+  // Using PolymorphicIsEven() as a Matcher<char>.
+  const Matcher<char> m2 = PolymorphicIsEven();
+  EXPECT_TRUE(m2.Matches('\x42'));
+  EXPECT_FALSE(m2.Matches('\x43'));
+  EXPECT_EQ("is even", Describe(m2));
+
+  const Matcher<char> not_m2 = Not(m2);
+  EXPECT_EQ("is odd", Describe(not_m2));
+
+  EXPECT_EQ("% 2 == 0", Explain(m2, '\x42'));
+}
+
+// Tests that MatcherCast<T>(m) works when m is a polymorphic matcher.
+TEST(MatcherCastTest, FromPolymorphicMatcher) {
+  Matcher<int> m = MatcherCast<int>(Eq(5));
+  EXPECT_TRUE(m.Matches(5));
+  EXPECT_FALSE(m.Matches(6));
+}
+
+// For testing casting matchers between compatible types.
+class IntValue {
+ public:
+  // An int can be statically (although not implicitly) cast to a
+  // IntValue.
+  explicit IntValue(int a_value) : value_(a_value) {}
+
+  int value() const { return value_; }
+ private:
+  int value_;
+};
+
+// For testing casting matchers between compatible types.
+bool IsPositiveIntValue(const IntValue& foo) {
+  return foo.value() > 0;
+}
+
+// Tests that MatcherCast<T>(m) works when m is a Matcher<U> where T
+// can be statically converted to U.
+TEST(MatcherCastTest, FromCompatibleType) {
+  Matcher<double> m1 = Eq(2.0);
+  Matcher<int> m2 = MatcherCast<int>(m1);
+  EXPECT_TRUE(m2.Matches(2));
+  EXPECT_FALSE(m2.Matches(3));
+
+  Matcher<IntValue> m3 = Truly(IsPositiveIntValue);
+  Matcher<int> m4 = MatcherCast<int>(m3);
+  // In the following, the arguments 1 and 0 are statically converted
+  // to IntValue objects, and then tested by the IsPositiveIntValue()
+  // predicate.
+  EXPECT_TRUE(m4.Matches(1));
+  EXPECT_FALSE(m4.Matches(0));
+}
+
+// Tests that MatcherCast<T>(m) works when m is a Matcher<const T&>.
+TEST(MatcherCastTest, FromConstReferenceToNonReference) {
+  Matcher<const int&> m1 = Eq(0);
+  Matcher<int> m2 = MatcherCast<int>(m1);
+  EXPECT_TRUE(m2.Matches(0));
+  EXPECT_FALSE(m2.Matches(1));
+}
+
+// Tests that MatcherCast<T>(m) works when m is a Matcher<T&>.
+TEST(MatcherCastTest, FromReferenceToNonReference) {
+  Matcher<int&> m1 = Eq(0);
+  Matcher<int> m2 = MatcherCast<int>(m1);
+  EXPECT_TRUE(m2.Matches(0));
+  EXPECT_FALSE(m2.Matches(1));
+}
+
+// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
+TEST(MatcherCastTest, FromNonReferenceToConstReference) {
+  Matcher<int> m1 = Eq(0);
+  Matcher<const int&> m2 = MatcherCast<const int&>(m1);
+  EXPECT_TRUE(m2.Matches(0));
+  EXPECT_FALSE(m2.Matches(1));
+}
+
+// Tests that MatcherCast<T&>(m) works when m is a Matcher<T>.
+TEST(MatcherCastTest, FromNonReferenceToReference) {
+  Matcher<int> m1 = Eq(0);
+  Matcher<int&> m2 = MatcherCast<int&>(m1);
+  int n = 0;
+  EXPECT_TRUE(m2.Matches(n));
+  n = 1;
+  EXPECT_FALSE(m2.Matches(n));
+}
+
+// Tests that MatcherCast<T>(m) works when m is a Matcher<T>.
+TEST(MatcherCastTest, FromSameType) {
+  Matcher<int> m1 = Eq(0);
+  Matcher<int> m2 = MatcherCast<int>(m1);
+  EXPECT_TRUE(m2.Matches(0));
+  EXPECT_FALSE(m2.Matches(1));
+}
+
+// Implicitly convertible from any type.
+struct ConvertibleFromAny {
+  ConvertibleFromAny(int a_value) : value(a_value) {}
+  template <typename T>
+  explicit ConvertibleFromAny(const T& /*a_value*/) : value(-1) {
+    ADD_FAILURE() << "Conversion constructor called";
+  }
+  int value;
+};
+
+bool operator==(const ConvertibleFromAny& a, const ConvertibleFromAny& b) {
+  return a.value == b.value;
+}
+
+ostream& operator<<(ostream& os, const ConvertibleFromAny& a) {
+  return os << a.value;
+}
+
+TEST(MatcherCastTest, ConversionConstructorIsUsed) {
+  Matcher<ConvertibleFromAny> m = MatcherCast<ConvertibleFromAny>(1);
+  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
+  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
+}
+
+TEST(MatcherCastTest, FromConvertibleFromAny) {
+  Matcher<ConvertibleFromAny> m =
+      MatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
+  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
+  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
+}
+
+struct IntReferenceWrapper {
+  IntReferenceWrapper(const int& a_value) : value(&a_value) {}
+  const int* value;
+};
+
+bool operator==(const IntReferenceWrapper& a, const IntReferenceWrapper& b) {
+  return a.value == b.value;
+}
+
+TEST(MatcherCastTest, ValueIsNotCopied) {
+  int n = 42;
+  Matcher<IntReferenceWrapper> m = MatcherCast<IntReferenceWrapper>(n);
+  // Verify that the matcher holds a reference to n, not to its temporary copy.
+  EXPECT_TRUE(m.Matches(n));
+}
+
+class Base {
+ public:
+  virtual ~Base() {}
+  Base() {}
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Base);
+};
+
+class Derived : public Base {
+ public:
+  Derived() : Base() {}
+  int i;
+};
+
+class OtherDerived : public Base {};
+
+// Tests that SafeMatcherCast<T>(m) works when m is a polymorphic matcher.
+TEST(SafeMatcherCastTest, FromPolymorphicMatcher) {
+  Matcher<char> m2 = SafeMatcherCast<char>(Eq(32));
+  EXPECT_TRUE(m2.Matches(' '));
+  EXPECT_FALSE(m2.Matches('\n'));
+}
+
+// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where
+// T and U are arithmetic types and T can be losslessly converted to
+// U.
+TEST(SafeMatcherCastTest, FromLosslesslyConvertibleArithmeticType) {
+  Matcher<double> m1 = DoubleEq(1.0);
+  Matcher<float> m2 = SafeMatcherCast<float>(m1);
+  EXPECT_TRUE(m2.Matches(1.0f));
+  EXPECT_FALSE(m2.Matches(2.0f));
+
+  Matcher<char> m3 = SafeMatcherCast<char>(TypedEq<int>('a'));
+  EXPECT_TRUE(m3.Matches('a'));
+  EXPECT_FALSE(m3.Matches('b'));
+}
+
+// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T and U
+// are pointers or references to a derived and a base class, correspondingly.
+TEST(SafeMatcherCastTest, FromBaseClass) {
+  Derived d, d2;
+  Matcher<Base*> m1 = Eq(&d);
+  Matcher<Derived*> m2 = SafeMatcherCast<Derived*>(m1);
+  EXPECT_TRUE(m2.Matches(&d));
+  EXPECT_FALSE(m2.Matches(&d2));
+
+  Matcher<Base&> m3 = Ref(d);
+  Matcher<Derived&> m4 = SafeMatcherCast<Derived&>(m3);
+  EXPECT_TRUE(m4.Matches(d));
+  EXPECT_FALSE(m4.Matches(d2));
+}
+
+// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<const T&>.
+TEST(SafeMatcherCastTest, FromConstReferenceToReference) {
+  int n = 0;
+  Matcher<const int&> m1 = Ref(n);
+  Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
+  int n1 = 0;
+  EXPECT_TRUE(m2.Matches(n));
+  EXPECT_FALSE(m2.Matches(n1));
+}
+
+// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
+TEST(SafeMatcherCastTest, FromNonReferenceToConstReference) {
+  Matcher<int> m1 = Eq(0);
+  Matcher<const int&> m2 = SafeMatcherCast<const int&>(m1);
+  EXPECT_TRUE(m2.Matches(0));
+  EXPECT_FALSE(m2.Matches(1));
+}
+
+// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<T>.
+TEST(SafeMatcherCastTest, FromNonReferenceToReference) {
+  Matcher<int> m1 = Eq(0);
+  Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
+  int n = 0;
+  EXPECT_TRUE(m2.Matches(n));
+  n = 1;
+  EXPECT_FALSE(m2.Matches(n));
+}
+
+// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<T>.
+TEST(SafeMatcherCastTest, FromSameType) {
+  Matcher<int> m1 = Eq(0);
+  Matcher<int> m2 = SafeMatcherCast<int>(m1);
+  EXPECT_TRUE(m2.Matches(0));
+  EXPECT_FALSE(m2.Matches(1));
+}
+
+TEST(SafeMatcherCastTest, ConversionConstructorIsUsed) {
+  Matcher<ConvertibleFromAny> m = SafeMatcherCast<ConvertibleFromAny>(1);
+  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
+  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
+}
+
+TEST(SafeMatcherCastTest, FromConvertibleFromAny) {
+  Matcher<ConvertibleFromAny> m =
+      SafeMatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
+  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
+  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
+}
+
+TEST(SafeMatcherCastTest, ValueIsNotCopied) {
+  int n = 42;
+  Matcher<IntReferenceWrapper> m = SafeMatcherCast<IntReferenceWrapper>(n);
+  // Verify that the matcher holds a reference to n, not to its temporary copy.
+  EXPECT_TRUE(m.Matches(n));
+}
+
+TEST(ExpectThat, TakesLiterals) {
+  EXPECT_THAT(1, 1);
+  EXPECT_THAT(1.0, 1.0);
+  EXPECT_THAT(string(), "");
+}
+
+TEST(ExpectThat, TakesFunctions) {
+  struct Helper {
+    static void Func() {}
+  };
+  void (*func)() = Helper::Func;
+  EXPECT_THAT(func, Helper::Func);
+  EXPECT_THAT(func, &Helper::Func);
+}
+
+// Tests that A<T>() matches any value of type T.
+TEST(ATest, MatchesAnyValue) {
+  // Tests a matcher for a value type.
+  Matcher<double> m1 = A<double>();
+  EXPECT_TRUE(m1.Matches(91.43));
+  EXPECT_TRUE(m1.Matches(-15.32));
+
+  // Tests a matcher for a reference type.
+  int a = 2;
+  int b = -6;
+  Matcher<int&> m2 = A<int&>();
+  EXPECT_TRUE(m2.Matches(a));
+  EXPECT_TRUE(m2.Matches(b));
+}
+
+TEST(ATest, WorksForDerivedClass) {
+  Base base;
+  Derived derived;
+  EXPECT_THAT(&base, A<Base*>());
+  // This shouldn't compile: EXPECT_THAT(&base, A<Derived*>());
+  EXPECT_THAT(&derived, A<Base*>());
+  EXPECT_THAT(&derived, A<Derived*>());
+}
+
+// Tests that A<T>() describes itself properly.
+TEST(ATest, CanDescribeSelf) {
+  EXPECT_EQ("is anything", Describe(A<bool>()));
+}
+
+// Tests that An<T>() matches any value of type T.
+TEST(AnTest, MatchesAnyValue) {
+  // Tests a matcher for a value type.
+  Matcher<int> m1 = An<int>();
+  EXPECT_TRUE(m1.Matches(9143));
+  EXPECT_TRUE(m1.Matches(-1532));
+
+  // Tests a matcher for a reference type.
+  int a = 2;
+  int b = -6;
+  Matcher<int&> m2 = An<int&>();
+  EXPECT_TRUE(m2.Matches(a));
+  EXPECT_TRUE(m2.Matches(b));
+}
+
+// Tests that An<T>() describes itself properly.
+TEST(AnTest, CanDescribeSelf) {
+  EXPECT_EQ("is anything", Describe(An<int>()));
+}
+
+// Tests that _ can be used as a matcher for any type and matches any
+// value of that type.
+TEST(UnderscoreTest, MatchesAnyValue) {
+  // Uses _ as a matcher for a value type.
+  Matcher<int> m1 = _;
+  EXPECT_TRUE(m1.Matches(123));
+  EXPECT_TRUE(m1.Matches(-242));
+
+  // Uses _ as a matcher for a reference type.
+  bool a = false;
+  const bool b = true;
+  Matcher<const bool&> m2 = _;
+  EXPECT_TRUE(m2.Matches(a));
+  EXPECT_TRUE(m2.Matches(b));
+}
+
+// Tests that _ describes itself properly.
+TEST(UnderscoreTest, CanDescribeSelf) {
+  Matcher<int> m = _;
+  EXPECT_EQ("is anything", Describe(m));
+}
+
+// Tests that Eq(x) matches any value equal to x.
+TEST(EqTest, MatchesEqualValue) {
+  // 2 C-strings with same content but different addresses.
+  const char a1[] = "hi";
+  const char a2[] = "hi";
+
+  Matcher<const char*> m1 = Eq(a1);
+  EXPECT_TRUE(m1.Matches(a1));
+  EXPECT_FALSE(m1.Matches(a2));
+}
+
+// Tests that Eq(v) describes itself properly.
+
+class Unprintable {
+ public:
+  Unprintable() : c_('a') {}
+
+ private:
+  char c_;
+};
+
+inline bool operator==(const Unprintable& /* lhs */, 
+                       const Unprintable& /* rhs */) { 
+    return true; 
+}
+
+TEST(EqTest, CanDescribeSelf) {
+  Matcher<Unprintable> m = Eq(Unprintable());
+  EXPECT_EQ("is equal to 1-byte object <61>", Describe(m));
+}
+
+// Tests that Eq(v) can be used to match any type that supports
+// comparing with type T, where T is v's type.
+TEST(EqTest, IsPolymorphic) {
+  Matcher<int> m1 = Eq(1);
+  EXPECT_TRUE(m1.Matches(1));
+  EXPECT_FALSE(m1.Matches(2));
+
+  Matcher<char> m2 = Eq(1);
+  EXPECT_TRUE(m2.Matches('\1'));
+  EXPECT_FALSE(m2.Matches('a'));
+}
+
+// Tests that TypedEq<T>(v) matches values of type T that's equal to v.
+TEST(TypedEqTest, ChecksEqualityForGivenType) {
+  Matcher<char> m1 = TypedEq<char>('a');
+  EXPECT_TRUE(m1.Matches('a'));
+  EXPECT_FALSE(m1.Matches('b'));
+
+  Matcher<int> m2 = TypedEq<int>(6);
+  EXPECT_TRUE(m2.Matches(6));
+  EXPECT_FALSE(m2.Matches(7));
+}
+
+// Tests that TypedEq(v) describes itself properly.
+TEST(TypedEqTest, CanDescribeSelf) {
+  EXPECT_EQ("is equal to 2", Describe(TypedEq<int>(2)));
+}
+
+// Tests that TypedEq<T>(v) has type Matcher<T>.
+
+// Type<T>::IsTypeOf(v) compiles iff the type of value v is T, where T
+// is a "bare" type (i.e. not in the form of const U or U&).  If v's
+// type is not T, the compiler will generate a message about
+// "undefined referece".
+template <typename T>
+struct Type {
+  static bool IsTypeOf(const T& /* v */) { return true; }
+
+  template <typename T2>
+  static void IsTypeOf(T2 v);
+};
+
+TEST(TypedEqTest, HasSpecifiedType) {
+  // Verfies that the type of TypedEq<T>(v) is Matcher<T>.
+  Type<Matcher<int> >::IsTypeOf(TypedEq<int>(5));
+  Type<Matcher<double> >::IsTypeOf(TypedEq<double>(5));
+}
+
+// Tests that Ge(v) matches anything >= v.
+TEST(GeTest, ImplementsGreaterThanOrEqual) {
+  Matcher<int> m1 = Ge(0);
+  EXPECT_TRUE(m1.Matches(1));
+  EXPECT_TRUE(m1.Matches(0));
+  EXPECT_FALSE(m1.Matches(-1));
+}
+
+// Tests that Ge(v) describes itself properly.
+TEST(GeTest, CanDescribeSelf) {
+  Matcher<int> m = Ge(5);
+  EXPECT_EQ("is >= 5", Describe(m));
+}
+
+// Tests that Gt(v) matches anything > v.
+TEST(GtTest, ImplementsGreaterThan) {
+  Matcher<double> m1 = Gt(0);
+  EXPECT_TRUE(m1.Matches(1.0));
+  EXPECT_FALSE(m1.Matches(0.0));
+  EXPECT_FALSE(m1.Matches(-1.0));
+}
+
+// Tests that Gt(v) describes itself properly.
+TEST(GtTest, CanDescribeSelf) {
+  Matcher<int> m = Gt(5);
+  EXPECT_EQ("is > 5", Describe(m));
+}
+
+// Tests that Le(v) matches anything <= v.
+TEST(LeTest, ImplementsLessThanOrEqual) {
+  Matcher<char> m1 = Le('b');
+  EXPECT_TRUE(m1.Matches('a'));
+  EXPECT_TRUE(m1.Matches('b'));
+  EXPECT_FALSE(m1.Matches('c'));
+}
+
+// Tests that Le(v) describes itself properly.
+TEST(LeTest, CanDescribeSelf) {
+  Matcher<int> m = Le(5);
+  EXPECT_EQ("is <= 5", Describe(m));
+}
+
+// Tests that Lt(v) matches anything < v.
+TEST(LtTest, ImplementsLessThan) {
+  Matcher<const string&> m1 = Lt("Hello");
+  EXPECT_TRUE(m1.Matches("Abc"));
+  EXPECT_FALSE(m1.Matches("Hello"));
+  EXPECT_FALSE(m1.Matches("Hello, world!"));
+}
+
+// Tests that Lt(v) describes itself properly.
+TEST(LtTest, CanDescribeSelf) {
+  Matcher<int> m = Lt(5);
+  EXPECT_EQ("is < 5", Describe(m));
+}
+
+// Tests that Ne(v) matches anything != v.
+TEST(NeTest, ImplementsNotEqual) {
+  Matcher<int> m1 = Ne(0);
+  EXPECT_TRUE(m1.Matches(1));
+  EXPECT_TRUE(m1.Matches(-1));
+  EXPECT_FALSE(m1.Matches(0));
+}
+
+// Tests that Ne(v) describes itself properly.
+TEST(NeTest, CanDescribeSelf) {
+  Matcher<int> m = Ne(5);
+  EXPECT_EQ("isn't equal to 5", Describe(m));
+}
+
+// Tests that IsNull() matches any NULL pointer of any type.
+TEST(IsNullTest, MatchesNullPointer) {
+  Matcher<int*> m1 = IsNull();
+  int* p1 = NULL;
+  int n = 0;
+  EXPECT_TRUE(m1.Matches(p1));
+  EXPECT_FALSE(m1.Matches(&n));
+
+  Matcher<const char*> m2 = IsNull();
+  const char* p2 = NULL;
+  EXPECT_TRUE(m2.Matches(p2));
+  EXPECT_FALSE(m2.Matches("hi"));
+
+#if !GTEST_OS_SYMBIAN
+  // Nokia's Symbian compiler generates:
+  // gmock-matchers.h: ambiguous access to overloaded function
+  // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(void *)'
+  // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(const testing::
+  //     MatcherInterface<void *> *)'
+  // gmock-matchers.h:  (point of instantiation: 'testing::
+  //     gmock_matchers_test::IsNullTest_MatchesNullPointer_Test::TestBody()')
+  // gmock-matchers.h:   (instantiating: 'testing::PolymorphicMatc
+  Matcher<void*> m3 = IsNull();
+  void* p3 = NULL;
+  EXPECT_TRUE(m3.Matches(p3));
+  EXPECT_FALSE(m3.Matches(reinterpret_cast<void*>(0xbeef)));
+#endif
+}
+
+TEST(IsNullTest, LinkedPtr) {
+  const Matcher<linked_ptr<int> > m = IsNull();
+  const linked_ptr<int> null_p;
+  const linked_ptr<int> non_null_p(new int);
+
+  EXPECT_TRUE(m.Matches(null_p));
+  EXPECT_FALSE(m.Matches(non_null_p));
+}
+
+TEST(IsNullTest, ReferenceToConstLinkedPtr) {
+  const Matcher<const linked_ptr<double>&> m = IsNull();
+  const linked_ptr<double> null_p;
+  const linked_ptr<double> non_null_p(new double);
+
+  EXPECT_TRUE(m.Matches(null_p));
+  EXPECT_FALSE(m.Matches(non_null_p));
+}
+
+#if GTEST_HAS_STD_FUNCTION_
+TEST(IsNullTest, StdFunction) {
+  const Matcher<std::function<void()>> m = IsNull();
+
+  EXPECT_TRUE(m.Matches(std::function<void()>()));
+  EXPECT_FALSE(m.Matches([]{}));
+}
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+// Tests that IsNull() describes itself properly.
+TEST(IsNullTest, CanDescribeSelf) {
+  Matcher<int*> m = IsNull();
+  EXPECT_EQ("is NULL", Describe(m));
+  EXPECT_EQ("isn't NULL", DescribeNegation(m));
+}
+
+// Tests that NotNull() matches any non-NULL pointer of any type.
+TEST(NotNullTest, MatchesNonNullPointer) {
+  Matcher<int*> m1 = NotNull();
+  int* p1 = NULL;
+  int n = 0;
+  EXPECT_FALSE(m1.Matches(p1));
+  EXPECT_TRUE(m1.Matches(&n));
+
+  Matcher<const char*> m2 = NotNull();
+  const char* p2 = NULL;
+  EXPECT_FALSE(m2.Matches(p2));
+  EXPECT_TRUE(m2.Matches("hi"));
+}
+
+TEST(NotNullTest, LinkedPtr) {
+  const Matcher<linked_ptr<int> > m = NotNull();
+  const linked_ptr<int> null_p;
+  const linked_ptr<int> non_null_p(new int);
+
+  EXPECT_FALSE(m.Matches(null_p));
+  EXPECT_TRUE(m.Matches(non_null_p));
+}
+
+TEST(NotNullTest, ReferenceToConstLinkedPtr) {
+  const Matcher<const linked_ptr<double>&> m = NotNull();
+  const linked_ptr<double> null_p;
+  const linked_ptr<double> non_null_p(new double);
+
+  EXPECT_FALSE(m.Matches(null_p));
+  EXPECT_TRUE(m.Matches(non_null_p));
+}
+
+#if GTEST_HAS_STD_FUNCTION_
+TEST(NotNullTest, StdFunction) {
+  const Matcher<std::function<void()>> m = NotNull();
+
+  EXPECT_TRUE(m.Matches([]{}));
+  EXPECT_FALSE(m.Matches(std::function<void()>()));
+}
+#endif  // GTEST_HAS_STD_FUNCTION_
+
+// Tests that NotNull() describes itself properly.
+TEST(NotNullTest, CanDescribeSelf) {
+  Matcher<int*> m = NotNull();
+  EXPECT_EQ("isn't NULL", Describe(m));
+}
+
+// Tests that Ref(variable) matches an argument that references
+// 'variable'.
+TEST(RefTest, MatchesSameVariable) {
+  int a = 0;
+  int b = 0;
+  Matcher<int&> m = Ref(a);
+  EXPECT_TRUE(m.Matches(a));
+  EXPECT_FALSE(m.Matches(b));
+}
+
+// Tests that Ref(variable) describes itself properly.
+TEST(RefTest, CanDescribeSelf) {
+  int n = 5;
+  Matcher<int&> m = Ref(n);
+  stringstream ss;
+  ss << "references the variable @" << &n << " 5";
+  EXPECT_EQ(string(ss.str()), Describe(m));
+}
+
+// Test that Ref(non_const_varialbe) can be used as a matcher for a
+// const reference.
+TEST(RefTest, CanBeUsedAsMatcherForConstReference) {
+  int a = 0;
+  int b = 0;
+  Matcher<const int&> m = Ref(a);
+  EXPECT_TRUE(m.Matches(a));
+  EXPECT_FALSE(m.Matches(b));
+}
+
+// Tests that Ref(variable) is covariant, i.e. Ref(derived) can be
+// used wherever Ref(base) can be used (Ref(derived) is a sub-type
+// of Ref(base), but not vice versa.
+
+TEST(RefTest, IsCovariant) {
+  Base base, base2;
+  Derived derived;
+  Matcher<const Base&> m1 = Ref(base);
+  EXPECT_TRUE(m1.Matches(base));
+  EXPECT_FALSE(m1.Matches(base2));
+  EXPECT_FALSE(m1.Matches(derived));
+
+  m1 = Ref(derived);
+  EXPECT_TRUE(m1.Matches(derived));
+  EXPECT_FALSE(m1.Matches(base));
+  EXPECT_FALSE(m1.Matches(base2));
+}
+
+TEST(RefTest, ExplainsResult) {
+  int n = 0;
+  EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), n),
+              StartsWith("which is located @"));
+
+  int m = 0;
+  EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), m),
+              StartsWith("which is located @"));
+}
+
+// Tests string comparison matchers.
+
+TEST(StrEqTest, MatchesEqualString) {
+  Matcher<const char*> m = StrEq(string("Hello"));
+  EXPECT_TRUE(m.Matches("Hello"));
+  EXPECT_FALSE(m.Matches("hello"));
+  EXPECT_FALSE(m.Matches(NULL));
+
+  Matcher<const string&> m2 = StrEq("Hello");
+  EXPECT_TRUE(m2.Matches("Hello"));
+  EXPECT_FALSE(m2.Matches("Hi"));
+}
+
+TEST(StrEqTest, CanDescribeSelf) {
+  Matcher<string> m = StrEq("Hi-\'\"?\\\a\b\f\n\r\t\v\xD3");
+  EXPECT_EQ("is equal to \"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\\xD3\"",
+      Describe(m));
+
+  string str("01204500800");
+  str[3] = '\0';
+  Matcher<string> m2 = StrEq(str);
+  EXPECT_EQ("is equal to \"012\\04500800\"", Describe(m2));
+  str[0] = str[6] = str[7] = str[9] = str[10] = '\0';
+  Matcher<string> m3 = StrEq(str);
+  EXPECT_EQ("is equal to \"\\012\\045\\0\\08\\0\\0\"", Describe(m3));
+}
+
+TEST(StrNeTest, MatchesUnequalString) {
+  Matcher<const char*> m = StrNe("Hello");
+  EXPECT_TRUE(m.Matches(""));
+  EXPECT_TRUE(m.Matches(NULL));
+  EXPECT_FALSE(m.Matches("Hello"));
+
+  Matcher<string> m2 = StrNe(string("Hello"));
+  EXPECT_TRUE(m2.Matches("hello"));
+  EXPECT_FALSE(m2.Matches("Hello"));
+}
+
+TEST(StrNeTest, CanDescribeSelf) {
+  Matcher<const char*> m = StrNe("Hi");
+  EXPECT_EQ("isn't equal to \"Hi\"", Describe(m));
+}
+
+TEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) {
+  Matcher<const char*> m = StrCaseEq(string("Hello"));
+  EXPECT_TRUE(m.Matches("Hello"));
+  EXPECT_TRUE(m.Matches("hello"));
+  EXPECT_FALSE(m.Matches("Hi"));
+  EXPECT_FALSE(m.Matches(NULL));
+
+  Matcher<const string&> m2 = StrCaseEq("Hello");
+  EXPECT_TRUE(m2.Matches("hello"));
+  EXPECT_FALSE(m2.Matches("Hi"));
+}
+
+TEST(StrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
+  string str1("oabocdooeoo");
+  string str2("OABOCDOOEOO");
+  Matcher<const string&> m0 = StrCaseEq(str1);
+  EXPECT_FALSE(m0.Matches(str2 + string(1, '\0')));
+
+  str1[3] = str2[3] = '\0';
+  Matcher<const string&> m1 = StrCaseEq(str1);
+  EXPECT_TRUE(m1.Matches(str2));
+
+  str1[0] = str1[6] = str1[7] = str1[10] = '\0';
+  str2[0] = str2[6] = str2[7] = str2[10] = '\0';
+  Matcher<const string&> m2 = StrCaseEq(str1);
+  str1[9] = str2[9] = '\0';
+  EXPECT_FALSE(m2.Matches(str2));
+
+  Matcher<const string&> m3 = StrCaseEq(str1);
+  EXPECT_TRUE(m3.Matches(str2));
+
+  EXPECT_FALSE(m3.Matches(str2 + "x"));
+  str2.append(1, '\0');
+  EXPECT_FALSE(m3.Matches(str2));
+  EXPECT_FALSE(m3.Matches(string(str2, 0, 9)));
+}
+
+TEST(StrCaseEqTest, CanDescribeSelf) {
+  Matcher<string> m = StrCaseEq("Hi");
+  EXPECT_EQ("is equal to (ignoring case) \"Hi\"", Describe(m));
+}
+
+TEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) {
+  Matcher<const char*> m = StrCaseNe("Hello");
+  EXPECT_TRUE(m.Matches("Hi"));
+  EXPECT_TRUE(m.Matches(NULL));
+  EXPECT_FALSE(m.Matches("Hello"));
+  EXPECT_FALSE(m.Matches("hello"));
+
+  Matcher<string> m2 = StrCaseNe(string("Hello"));
+  EXPECT_TRUE(m2.Matches(""));
+  EXPECT_FALSE(m2.Matches("Hello"));
+}
+
+TEST(StrCaseNeTest, CanDescribeSelf) {
+  Matcher<const char*> m = StrCaseNe("Hi");
+  EXPECT_EQ("isn't equal to (ignoring case) \"Hi\"", Describe(m));
+}
+
+// Tests that HasSubstr() works for matching string-typed values.
+TEST(HasSubstrTest, WorksForStringClasses) {
+  const Matcher<string> m1 = HasSubstr("foo");
+  EXPECT_TRUE(m1.Matches(string("I love food.")));
+  EXPECT_FALSE(m1.Matches(string("tofo")));
+
+  const Matcher<const std::string&> m2 = HasSubstr("foo");
+  EXPECT_TRUE(m2.Matches(std::string("I love food.")));
+  EXPECT_FALSE(m2.Matches(std::string("tofo")));
+}
+
+// Tests that HasSubstr() works for matching C-string-typed values.
+TEST(HasSubstrTest, WorksForCStrings) {
+  const Matcher<char*> m1 = HasSubstr("foo");
+  EXPECT_TRUE(m1.Matches(const_cast<char*>("I love food.")));
+  EXPECT_FALSE(m1.Matches(const_cast<char*>("tofo")));
+  EXPECT_FALSE(m1.Matches(NULL));
+
+  const Matcher<const char*> m2 = HasSubstr("foo");
+  EXPECT_TRUE(m2.Matches("I love food."));
+  EXPECT_FALSE(m2.Matches("tofo"));
+  EXPECT_FALSE(m2.Matches(NULL));
+}
+
+// Tests that HasSubstr(s) describes itself properly.
+TEST(HasSubstrTest, CanDescribeSelf) {
+  Matcher<string> m = HasSubstr("foo\n\"");
+  EXPECT_EQ("has substring \"foo\\n\\\"\"", Describe(m));
+}
+
+TEST(KeyTest, CanDescribeSelf) {
+  Matcher<const pair<std::string, int>&> m = Key("foo");
+  EXPECT_EQ("has a key that is equal to \"foo\"", Describe(m));
+  EXPECT_EQ("doesn't have a key that is equal to \"foo\"", DescribeNegation(m));
+}
+
+TEST(KeyTest, ExplainsResult) {
+  Matcher<pair<int, bool> > m = Key(GreaterThan(10));
+  EXPECT_EQ("whose first field is a value which is 5 less than 10",
+            Explain(m, make_pair(5, true)));
+  EXPECT_EQ("whose first field is a value which is 5 more than 10",
+            Explain(m, make_pair(15, true)));
+}
+
+TEST(KeyTest, MatchesCorrectly) {
+  pair<int, std::string> p(25, "foo");
+  EXPECT_THAT(p, Key(25));
+  EXPECT_THAT(p, Not(Key(42)));
+  EXPECT_THAT(p, Key(Ge(20)));
+  EXPECT_THAT(p, Not(Key(Lt(25))));
+}
+
+TEST(KeyTest, SafelyCastsInnerMatcher) {
+  Matcher<int> is_positive = Gt(0);
+  Matcher<int> is_negative = Lt(0);
+  pair<char, bool> p('a', true);
+  EXPECT_THAT(p, Key(is_positive));
+  EXPECT_THAT(p, Not(Key(is_negative)));
+}
+
+TEST(KeyTest, InsideContainsUsingMap) {
+  map<int, char> container;
+  container.insert(make_pair(1, 'a'));
+  container.insert(make_pair(2, 'b'));
+  container.insert(make_pair(4, 'c'));
+  EXPECT_THAT(container, Contains(Key(1)));
+  EXPECT_THAT(container, Not(Contains(Key(3))));
+}
+
+TEST(KeyTest, InsideContainsUsingMultimap) {
+  multimap<int, char> container;
+  container.insert(make_pair(1, 'a'));
+  container.insert(make_pair(2, 'b'));
+  container.insert(make_pair(4, 'c'));
+
+  EXPECT_THAT(container, Not(Contains(Key(25))));
+  container.insert(make_pair(25, 'd'));
+  EXPECT_THAT(container, Contains(Key(25)));
+  container.insert(make_pair(25, 'e'));
+  EXPECT_THAT(container, Contains(Key(25)));
+
+  EXPECT_THAT(container, Contains(Key(1)));
+  EXPECT_THAT(container, Not(Contains(Key(3))));
+}
+
+TEST(PairTest, Typing) {
+  // Test verifies the following type conversions can be compiled.
+  Matcher<const pair<const char*, int>&> m1 = Pair("foo", 42);
+  Matcher<const pair<const char*, int> > m2 = Pair("foo", 42);
+  Matcher<pair<const char*, int> > m3 = Pair("foo", 42);
+
+  Matcher<pair<int, const std::string> > m4 = Pair(25, "42");
+  Matcher<pair<const std::string, int> > m5 = Pair("25", 42);
+}
+
+TEST(PairTest, CanDescribeSelf) {
+  Matcher<const pair<std::string, int>&> m1 = Pair("foo", 42);
+  EXPECT_EQ("has a first field that is equal to \"foo\""
+            ", and has a second field that is equal to 42",
+            Describe(m1));
+  EXPECT_EQ("has a first field that isn't equal to \"foo\""
+            ", or has a second field that isn't equal to 42",
+            DescribeNegation(m1));
+  // Double and triple negation (1 or 2 times not and description of negation).
+  Matcher<const pair<int, int>&> m2 = Not(Pair(Not(13), 42));
+  EXPECT_EQ("has a first field that isn't equal to 13"
+            ", and has a second field that is equal to 42",
+            DescribeNegation(m2));
+}
+
+TEST(PairTest, CanExplainMatchResultTo) {
+  // If neither field matches, Pair() should explain about the first
+  // field.
+  const Matcher<pair<int, int> > m = Pair(GreaterThan(0), GreaterThan(0));
+  EXPECT_EQ("whose first field does not match, which is 1 less than 0",
+            Explain(m, make_pair(-1, -2)));
+
+  // If the first field matches but the second doesn't, Pair() should
+  // explain about the second field.
+  EXPECT_EQ("whose second field does not match, which is 2 less than 0",
+            Explain(m, make_pair(1, -2)));
+
+  // If the first field doesn't match but the second does, Pair()
+  // should explain about the first field.
+  EXPECT_EQ("whose first field does not match, which is 1 less than 0",
+            Explain(m, make_pair(-1, 2)));
+
+  // If both fields match, Pair() should explain about them both.
+  EXPECT_EQ("whose both fields match, where the first field is a value "
+            "which is 1 more than 0, and the second field is a value "
+            "which is 2 more than 0",
+            Explain(m, make_pair(1, 2)));
+
+  // If only the first match has an explanation, only this explanation should
+  // be printed.
+  const Matcher<pair<int, int> > explain_first = Pair(GreaterThan(0), 0);
+  EXPECT_EQ("whose both fields match, where the first field is a value "
+            "which is 1 more than 0",
+            Explain(explain_first, make_pair(1, 0)));
+
+  // If only the second match has an explanation, only this explanation should
+  // be printed.
+  const Matcher<pair<int, int> > explain_second = Pair(0, GreaterThan(0));
+  EXPECT_EQ("whose both fields match, where the second field is a value "
+            "which is 1 more than 0",
+            Explain(explain_second, make_pair(0, 1)));
+}
+
+TEST(PairTest, MatchesCorrectly) {
+  pair<int, std::string> p(25, "foo");
+
+  // Both fields match.
+  EXPECT_THAT(p, Pair(25, "foo"));
+  EXPECT_THAT(p, Pair(Ge(20), HasSubstr("o")));
+
+  // 'first' doesnt' match, but 'second' matches.
+  EXPECT_THAT(p, Not(Pair(42, "foo")));
+  EXPECT_THAT(p, Not(Pair(Lt(25), "foo")));
+
+  // 'first' matches, but 'second' doesn't match.
+  EXPECT_THAT(p, Not(Pair(25, "bar")));
+  EXPECT_THAT(p, Not(Pair(25, Not("foo"))));
+
+  // Neither field matches.
+  EXPECT_THAT(p, Not(Pair(13, "bar")));
+  EXPECT_THAT(p, Not(Pair(Lt(13), HasSubstr("a"))));
+}
+
+TEST(PairTest, SafelyCastsInnerMatchers) {
+  Matcher<int> is_positive = Gt(0);
+  Matcher<int> is_negative = Lt(0);
+  pair<char, bool> p('a', true);
+  EXPECT_THAT(p, Pair(is_positive, _));
+  EXPECT_THAT(p, Not(Pair(is_negative, _)));
+  EXPECT_THAT(p, Pair(_, is_positive));
+  EXPECT_THAT(p, Not(Pair(_, is_negative)));
+}
+
+TEST(PairTest, InsideContainsUsingMap) {
+  map<int, char> container;
+  container.insert(make_pair(1, 'a'));
+  container.insert(make_pair(2, 'b'));
+  container.insert(make_pair(4, 'c'));
+  EXPECT_THAT(container, Contains(Pair(1, 'a')));
+  EXPECT_THAT(container, Contains(Pair(1, _)));
+  EXPECT_THAT(container, Contains(Pair(_, 'a')));
+  EXPECT_THAT(container, Not(Contains(Pair(3, _))));
+}
+
+// Tests StartsWith(s).
+
+TEST(StartsWithTest, MatchesStringWithGivenPrefix) {
+  const Matcher<const char*> m1 = StartsWith(string(""));
+  EXPECT_TRUE(m1.Matches("Hi"));
+  EXPECT_TRUE(m1.Matches(""));
+  EXPECT_FALSE(m1.Matches(NULL));
+
+  const Matcher<const string&> m2 = StartsWith("Hi");
+  EXPECT_TRUE(m2.Matches("Hi"));
+  EXPECT_TRUE(m2.Matches("Hi Hi!"));
+  EXPECT_TRUE(m2.Matches("High"));
+  EXPECT_FALSE(m2.Matches("H"));
+  EXPECT_FALSE(m2.Matches(" Hi"));
+}
+
+TEST(StartsWithTest, CanDescribeSelf) {
+  Matcher<const std::string> m = StartsWith("Hi");
+  EXPECT_EQ("starts with \"Hi\"", Describe(m));
+}
+
+// Tests EndsWith(s).
+
+TEST(EndsWithTest, MatchesStringWithGivenSuffix) {
+  const Matcher<const char*> m1 = EndsWith("");
+  EXPECT_TRUE(m1.Matches("Hi"));
+  EXPECT_TRUE(m1.Matches(""));
+  EXPECT_FALSE(m1.Matches(NULL));
+
+  const Matcher<const string&> m2 = EndsWith(string("Hi"));
+  EXPECT_TRUE(m2.Matches("Hi"));
+  EXPECT_TRUE(m2.Matches("Wow Hi Hi"));
+  EXPECT_TRUE(m2.Matches("Super Hi"));
+  EXPECT_FALSE(m2.Matches("i"));
+  EXPECT_FALSE(m2.Matches("Hi "));
+}
+
+TEST(EndsWithTest, CanDescribeSelf) {
+  Matcher<const std::string> m = EndsWith("Hi");
+  EXPECT_EQ("ends with \"Hi\"", Describe(m));
+}
+
+// Tests MatchesRegex().
+
+TEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) {
+  const Matcher<const char*> m1 = MatchesRegex("a.*z");
+  EXPECT_TRUE(m1.Matches("az"));
+  EXPECT_TRUE(m1.Matches("abcz"));
+  EXPECT_FALSE(m1.Matches(NULL));
+
+  const Matcher<const string&> m2 = MatchesRegex(new RE("a.*z"));
+  EXPECT_TRUE(m2.Matches("azbz"));
+  EXPECT_FALSE(m2.Matches("az1"));
+  EXPECT_FALSE(m2.Matches("1az"));
+}
+
+TEST(MatchesRegexTest, CanDescribeSelf) {
+  Matcher<const std::string> m1 = MatchesRegex(string("Hi.*"));
+  EXPECT_EQ("matches regular expression \"Hi.*\"", Describe(m1));
+
+  Matcher<const char*> m2 = MatchesRegex(new RE("a.*"));
+  EXPECT_EQ("matches regular expression \"a.*\"", Describe(m2));
+}
+
+// Tests ContainsRegex().
+
+TEST(ContainsRegexTest, MatchesStringContainingGivenRegex) {
+  const Matcher<const char*> m1 = ContainsRegex(string("a.*z"));
+  EXPECT_TRUE(m1.Matches("az"));
+  EXPECT_TRUE(m1.Matches("0abcz1"));
+  EXPECT_FALSE(m1.Matches(NULL));
+
+  const Matcher<const string&> m2 = ContainsRegex(new RE("a.*z"));
+  EXPECT_TRUE(m2.Matches("azbz"));
+  EXPECT_TRUE(m2.Matches("az1"));
+  EXPECT_FALSE(m2.Matches("1a"));
+}
+
+TEST(ContainsRegexTest, CanDescribeSelf) {
+  Matcher<const std::string> m1 = ContainsRegex("Hi.*");
+  EXPECT_EQ("contains regular expression \"Hi.*\"", Describe(m1));
+
+  Matcher<const char*> m2 = ContainsRegex(new RE("a.*"));
+  EXPECT_EQ("contains regular expression \"a.*\"", Describe(m2));
+}
+
+// Tests for wide strings.
+#if GTEST_HAS_STD_WSTRING
+TEST(StdWideStrEqTest, MatchesEqual) {
+  Matcher<const wchar_t*> m = StrEq(::std::wstring(L"Hello"));
+  EXPECT_TRUE(m.Matches(L"Hello"));
+  EXPECT_FALSE(m.Matches(L"hello"));
+  EXPECT_FALSE(m.Matches(NULL));
+
+  Matcher<const ::std::wstring&> m2 = StrEq(L"Hello");
+  EXPECT_TRUE(m2.Matches(L"Hello"));
+  EXPECT_FALSE(m2.Matches(L"Hi"));
+
+  Matcher<const ::std::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D");
+  EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D"));
+  EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E"));
+
+  ::std::wstring str(L"01204500800");
+  str[3] = L'\0';
+  Matcher<const ::std::wstring&> m4 = StrEq(str);
+  EXPECT_TRUE(m4.Matches(str));
+  str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
+  Matcher<const ::std::wstring&> m5 = StrEq(str);
+  EXPECT_TRUE(m5.Matches(str));
+}
+
+TEST(StdWideStrEqTest, CanDescribeSelf) {
+  Matcher< ::std::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v");
+  EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"",
+    Describe(m));
+
+  Matcher< ::std::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D");
+  EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"",
+    Describe(m2));
+
+  ::std::wstring str(L"01204500800");
+  str[3] = L'\0';
+  Matcher<const ::std::wstring&> m4 = StrEq(str);
+  EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4));
+  str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
+  Matcher<const ::std::wstring&> m5 = StrEq(str);
+  EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5));
+}
+
+TEST(StdWideStrNeTest, MatchesUnequalString) {
+  Matcher<const wchar_t*> m = StrNe(L"Hello");
+  EXPECT_TRUE(m.Matches(L""));
+  EXPECT_TRUE(m.Matches(NULL));
+  EXPECT_FALSE(m.Matches(L"Hello"));
+
+  Matcher< ::std::wstring> m2 = StrNe(::std::wstring(L"Hello"));
+  EXPECT_TRUE(m2.Matches(L"hello"));
+  EXPECT_FALSE(m2.Matches(L"Hello"));
+}
+
+TEST(StdWideStrNeTest, CanDescribeSelf) {
+  Matcher<const wchar_t*> m = StrNe(L"Hi");
+  EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m));
+}
+
+TEST(StdWideStrCaseEqTest, MatchesEqualStringIgnoringCase) {
+  Matcher<const wchar_t*> m = StrCaseEq(::std::wstring(L"Hello"));
+  EXPECT_TRUE(m.Matches(L"Hello"));
+  EXPECT_TRUE(m.Matches(L"hello"));
+  EXPECT_FALSE(m.Matches(L"Hi"));
+  EXPECT_FALSE(m.Matches(NULL));
+
+  Matcher<const ::std::wstring&> m2 = StrCaseEq(L"Hello");
+  EXPECT_TRUE(m2.Matches(L"hello"));
+  EXPECT_FALSE(m2.Matches(L"Hi"));
+}
+
+TEST(StdWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
+  ::std::wstring str1(L"oabocdooeoo");
+  ::std::wstring str2(L"OABOCDOOEOO");
+  Matcher<const ::std::wstring&> m0 = StrCaseEq(str1);
+  EXPECT_FALSE(m0.Matches(str2 + ::std::wstring(1, L'\0')));
+
+  str1[3] = str2[3] = L'\0';
+  Matcher<const ::std::wstring&> m1 = StrCaseEq(str1);
+  EXPECT_TRUE(m1.Matches(str2));
+
+  str1[0] = str1[6] = str1[7] = str1[10] = L'\0';
+  str2[0] = str2[6] = str2[7] = str2[10] = L'\0';
+  Matcher<const ::std::wstring&> m2 = StrCaseEq(str1);
+  str1[9] = str2[9] = L'\0';
+  EXPECT_FALSE(m2.Matches(str2));
+
+  Matcher<const ::std::wstring&> m3 = StrCaseEq(str1);
+  EXPECT_TRUE(m3.Matches(str2));
+
+  EXPECT_FALSE(m3.Matches(str2 + L"x"));
+  str2.append(1, L'\0');
+  EXPECT_FALSE(m3.Matches(str2));
+  EXPECT_FALSE(m3.Matches(::std::wstring(str2, 0, 9)));
+}
+
+TEST(StdWideStrCaseEqTest, CanDescribeSelf) {
+  Matcher< ::std::wstring> m = StrCaseEq(L"Hi");
+  EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m));
+}
+
+TEST(StdWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) {
+  Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
+  EXPECT_TRUE(m.Matches(L"Hi"));
+  EXPECT_TRUE(m.Matches(NULL));
+  EXPECT_FALSE(m.Matches(L"Hello"));
+  EXPECT_FALSE(m.Matches(L"hello"));
+
+  Matcher< ::std::wstring> m2 = StrCaseNe(::std::wstring(L"Hello"));
+  EXPECT_TRUE(m2.Matches(L""));
+  EXPECT_FALSE(m2.Matches(L"Hello"));
+}
+
+TEST(StdWideStrCaseNeTest, CanDescribeSelf) {
+  Matcher<const wchar_t*> m = StrCaseNe(L"Hi");
+  EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m));
+}
+
+// Tests that HasSubstr() works for matching wstring-typed values.
+TEST(StdWideHasSubstrTest, WorksForStringClasses) {
+  const Matcher< ::std::wstring> m1 = HasSubstr(L"foo");
+  EXPECT_TRUE(m1.Matches(::std::wstring(L"I love food.")));
+  EXPECT_FALSE(m1.Matches(::std::wstring(L"tofo")));
+
+  const Matcher<const ::std::wstring&> m2 = HasSubstr(L"foo");
+  EXPECT_TRUE(m2.Matches(::std::wstring(L"I love food.")));
+  EXPECT_FALSE(m2.Matches(::std::wstring(L"tofo")));
+}
+
+// Tests that HasSubstr() works for matching C-wide-string-typed values.
+TEST(StdWideHasSubstrTest, WorksForCStrings) {
+  const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
+  EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food.")));
+  EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo")));
+  EXPECT_FALSE(m1.Matches(NULL));
+
+  const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
+  EXPECT_TRUE(m2.Matches(L"I love food."));
+  EXPECT_FALSE(m2.Matches(L"tofo"));
+  EXPECT_FALSE(m2.Matches(NULL));
+}
+
+// Tests that HasSubstr(s) describes itself properly.
+TEST(StdWideHasSubstrTest, CanDescribeSelf) {
+  Matcher< ::std::wstring> m = HasSubstr(L"foo\n\"");
+  EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m));
+}
+
+// Tests StartsWith(s).
+
+TEST(StdWideStartsWithTest, MatchesStringWithGivenPrefix) {
+  const Matcher<const wchar_t*> m1 = StartsWith(::std::wstring(L""));
+  EXPECT_TRUE(m1.Matches(L"Hi"));
+  EXPECT_TRUE(m1.Matches(L""));
+  EXPECT_FALSE(m1.Matches(NULL));
+
+  const Matcher<const ::std::wstring&> m2 = StartsWith(L"Hi");
+  EXPECT_TRUE(m2.Matches(L"Hi"));
+  EXPECT_TRUE(m2.Matches(L"Hi Hi!"));
+  EXPECT_TRUE(m2.Matches(L"High"));
+  EXPECT_FALSE(m2.Matches(L"H"));
+  EXPECT_FALSE(m2.Matches(L" Hi"));
+}
+
+TEST(StdWideStartsWithTest, CanDescribeSelf) {
+  Matcher<const ::std::wstring> m = StartsWith(L"Hi");
+  EXPECT_EQ("starts with L\"Hi\"", Describe(m));
+}
+
+// Tests EndsWith(s).
+
+TEST(StdWideEndsWithTest, MatchesStringWithGivenSuffix) {
+  const Matcher<const wchar_t*> m1 = EndsWith(L"");
+  EXPECT_TRUE(m1.Matches(L"Hi"));
+  EXPECT_TRUE(m1.Matches(L""));
+  EXPECT_FALSE(m1.Matches(NULL));
+
+  const Matcher<const ::std::wstring&> m2 = EndsWith(::std::wstring(L"Hi"));
+  EXPECT_TRUE(m2.Matches(L"Hi"));
+  EXPECT_TRUE(m2.Matches(L"Wow Hi Hi"));
+  EXPECT_TRUE(m2.Matches(L"Super Hi"));
+  EXPECT_FALSE(m2.Matches(L"i"));
+  EXPECT_FALSE(m2.Matches(L"Hi "));
+}
+
+TEST(StdWideEndsWithTest, CanDescribeSelf) {
+  Matcher<const ::std::wstring> m = EndsWith(L"Hi");
+  EXPECT_EQ("ends with L\"Hi\"", Describe(m));
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_HAS_GLOBAL_WSTRING
+TEST(GlobalWideStrEqTest, MatchesEqual) {
+  Matcher<const wchar_t*> m = StrEq(::wstring(L"Hello"));
+  EXPECT_TRUE(m.Matches(L"Hello"));
+  EXPECT_FALSE(m.Matches(L"hello"));
+  EXPECT_FALSE(m.Matches(NULL));
+
+  Matcher<const ::wstring&> m2 = StrEq(L"Hello");
+  EXPECT_TRUE(m2.Matches(L"Hello"));
+  EXPECT_FALSE(m2.Matches(L"Hi"));
+
+  Matcher<const ::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D");
+  EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D"));
+  EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E"));
+
+  ::wstring str(L"01204500800");
+  str[3] = L'\0';
+  Matcher<const ::wstring&> m4 = StrEq(str);
+  EXPECT_TRUE(m4.Matches(str));
+  str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
+  Matcher<const ::wstring&> m5 = StrEq(str);
+  EXPECT_TRUE(m5.Matches(str));
+}
+
+TEST(GlobalWideStrEqTest, CanDescribeSelf) {
+  Matcher< ::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v");
+  EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"",
+    Describe(m));
+
+  Matcher< ::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D");
+  EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"",
+    Describe(m2));
+
+  ::wstring str(L"01204500800");
+  str[3] = L'\0';
+  Matcher<const ::wstring&> m4 = StrEq(str);
+  EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4));
+  str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
+  Matcher<const ::wstring&> m5 = StrEq(str);
+  EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5));
+}
+
+TEST(GlobalWideStrNeTest, MatchesUnequalString) {
+  Matcher<const wchar_t*> m = StrNe(L"Hello");
+  EXPECT_TRUE(m.Matches(L""));
+  EXPECT_TRUE(m.Matches(NULL));
+  EXPECT_FALSE(m.Matches(L"Hello"));
+
+  Matcher< ::wstring> m2 = StrNe(::wstring(L"Hello"));
+  EXPECT_TRUE(m2.Matches(L"hello"));
+  EXPECT_FALSE(m2.Matches(L"Hello"));
+}
+
+TEST(GlobalWideStrNeTest, CanDescribeSelf) {
+  Matcher<const wchar_t*> m = StrNe(L"Hi");
+  EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m));
+}
+
+TEST(GlobalWideStrCaseEqTest, MatchesEqualStringIgnoringCase) {
+  Matcher<const wchar_t*> m = StrCaseEq(::wstring(L"Hello"));
+  EXPECT_TRUE(m.Matches(L"Hello"));
+  EXPECT_TRUE(m.Matches(L"hello"));
+  EXPECT_FALSE(m.Matches(L"Hi"));
+  EXPECT_FALSE(m.Matches(NULL));
+
+  Matcher<const ::wstring&> m2 = StrCaseEq(L"Hello");
+  EXPECT_TRUE(m2.Matches(L"hello"));
+  EXPECT_FALSE(m2.Matches(L"Hi"));
+}
+
+TEST(GlobalWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
+  ::wstring str1(L"oabocdooeoo");
+  ::wstring str2(L"OABOCDOOEOO");
+  Matcher<const ::wstring&> m0 = StrCaseEq(str1);
+  EXPECT_FALSE(m0.Matches(str2 + ::wstring(1, L'\0')));
+
+  str1[3] = str2[3] = L'\0';
+  Matcher<const ::wstring&> m1 = StrCaseEq(str1);
+  EXPECT_TRUE(m1.Matches(str2));
+
+  str1[0] = str1[6] = str1[7] = str1[10] = L'\0';
+  str2[0] = str2[6] = str2[7] = str2[10] = L'\0';
+  Matcher<const ::wstring&> m2 = StrCaseEq(str1);
+  str1[9] = str2[9] = L'\0';
+  EXPECT_FALSE(m2.Matches(str2));
+
+  Matcher<const ::wstring&> m3 = StrCaseEq(str1);
+  EXPECT_TRUE(m3.Matches(str2));
+
+  EXPECT_FALSE(m3.Matches(str2 + L"x"));
+  str2.append(1, L'\0');
+  EXPECT_FALSE(m3.Matches(str2));
+  EXPECT_FALSE(m3.Matches(::wstring(str2, 0, 9)));
+}
+
+TEST(GlobalWideStrCaseEqTest, CanDescribeSelf) {
+  Matcher< ::wstring> m = StrCaseEq(L"Hi");
+  EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m));
+}
+
+TEST(GlobalWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) {
+  Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
+  EXPECT_TRUE(m.Matches(L"Hi"));
+  EXPECT_TRUE(m.Matches(NULL));
+  EXPECT_FALSE(m.Matches(L"Hello"));
+  EXPECT_FALSE(m.Matches(L"hello"));
+
+  Matcher< ::wstring> m2 = StrCaseNe(::wstring(L"Hello"));
+  EXPECT_TRUE(m2.Matches(L""));
+  EXPECT_FALSE(m2.Matches(L"Hello"));
+}
+
+TEST(GlobalWideStrCaseNeTest, CanDescribeSelf) {
+  Matcher<const wchar_t*> m = StrCaseNe(L"Hi");
+  EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m));
+}
+
+// Tests that HasSubstr() works for matching wstring-typed values.
+TEST(GlobalWideHasSubstrTest, WorksForStringClasses) {
+  const Matcher< ::wstring> m1 = HasSubstr(L"foo");
+  EXPECT_TRUE(m1.Matches(::wstring(L"I love food.")));
+  EXPECT_FALSE(m1.Matches(::wstring(L"tofo")));
+
+  const Matcher<const ::wstring&> m2 = HasSubstr(L"foo");
+  EXPECT_TRUE(m2.Matches(::wstring(L"I love food.")));
+  EXPECT_FALSE(m2.Matches(::wstring(L"tofo")));
+}
+
+// Tests that HasSubstr() works for matching C-wide-string-typed values.
+TEST(GlobalWideHasSubstrTest, WorksForCStrings) {
+  const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
+  EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food.")));
+  EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo")));
+  EXPECT_FALSE(m1.Matches(NULL));
+
+  const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
+  EXPECT_TRUE(m2.Matches(L"I love food."));
+  EXPECT_FALSE(m2.Matches(L"tofo"));
+  EXPECT_FALSE(m2.Matches(NULL));
+}
+
+// Tests that HasSubstr(s) describes itself properly.
+TEST(GlobalWideHasSubstrTest, CanDescribeSelf) {
+  Matcher< ::wstring> m = HasSubstr(L"foo\n\"");
+  EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m));
+}
+
+// Tests StartsWith(s).
+
+TEST(GlobalWideStartsWithTest, MatchesStringWithGivenPrefix) {
+  const Matcher<const wchar_t*> m1 = StartsWith(::wstring(L""));
+  EXPECT_TRUE(m1.Matches(L"Hi"));
+  EXPECT_TRUE(m1.Matches(L""));
+  EXPECT_FALSE(m1.Matches(NULL));
+
+  const Matcher<const ::wstring&> m2 = StartsWith(L"Hi");
+  EXPECT_TRUE(m2.Matches(L"Hi"));
+  EXPECT_TRUE(m2.Matches(L"Hi Hi!"));
+  EXPECT_TRUE(m2.Matches(L"High"));
+  EXPECT_FALSE(m2.Matches(L"H"));
+  EXPECT_FALSE(m2.Matches(L" Hi"));
+}
+
+TEST(GlobalWideStartsWithTest, CanDescribeSelf) {
+  Matcher<const ::wstring> m = StartsWith(L"Hi");
+  EXPECT_EQ("starts with L\"Hi\"", Describe(m));
+}
+
+// Tests EndsWith(s).
+
+TEST(GlobalWideEndsWithTest, MatchesStringWithGivenSuffix) {
+  const Matcher<const wchar_t*> m1 = EndsWith(L"");
+  EXPECT_TRUE(m1.Matches(L"Hi"));
+  EXPECT_TRUE(m1.Matches(L""));
+  EXPECT_FALSE(m1.Matches(NULL));
+
+  const Matcher<const ::wstring&> m2 = EndsWith(::wstring(L"Hi"));
+  EXPECT_TRUE(m2.Matches(L"Hi"));
+  EXPECT_TRUE(m2.Matches(L"Wow Hi Hi"));
+  EXPECT_TRUE(m2.Matches(L"Super Hi"));
+  EXPECT_FALSE(m2.Matches(L"i"));
+  EXPECT_FALSE(m2.Matches(L"Hi "));
+}
+
+TEST(GlobalWideEndsWithTest, CanDescribeSelf) {
+  Matcher<const ::wstring> m = EndsWith(L"Hi");
+  EXPECT_EQ("ends with L\"Hi\"", Describe(m));
+}
+
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+
+typedef ::testing::tuple<long, int> Tuple2;  // NOLINT
+
+// Tests that Eq() matches a 2-tuple where the first field == the
+// second field.
+TEST(Eq2Test, MatchesEqualArguments) {
+  Matcher<const Tuple2&> m = Eq();
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
+}
+
+// Tests that Eq() describes itself properly.
+TEST(Eq2Test, CanDescribeSelf) {
+  Matcher<const Tuple2&> m = Eq();
+  EXPECT_EQ("are an equal pair", Describe(m));
+}
+
+// Tests that Ge() matches a 2-tuple where the first field >= the
+// second field.
+TEST(Ge2Test, MatchesGreaterThanOrEqualArguments) {
+  Matcher<const Tuple2&> m = Ge();
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
+}
+
+// Tests that Ge() describes itself properly.
+TEST(Ge2Test, CanDescribeSelf) {
+  Matcher<const Tuple2&> m = Ge();
+  EXPECT_EQ("are a pair where the first >= the second", Describe(m));
+}
+
+// Tests that Gt() matches a 2-tuple where the first field > the
+// second field.
+TEST(Gt2Test, MatchesGreaterThanArguments) {
+  Matcher<const Tuple2&> m = Gt();
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
+}
+
+// Tests that Gt() describes itself properly.
+TEST(Gt2Test, CanDescribeSelf) {
+  Matcher<const Tuple2&> m = Gt();
+  EXPECT_EQ("are a pair where the first > the second", Describe(m));
+}
+
+// Tests that Le() matches a 2-tuple where the first field <= the
+// second field.
+TEST(Le2Test, MatchesLessThanOrEqualArguments) {
+  Matcher<const Tuple2&> m = Le();
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
+}
+
+// Tests that Le() describes itself properly.
+TEST(Le2Test, CanDescribeSelf) {
+  Matcher<const Tuple2&> m = Le();
+  EXPECT_EQ("are a pair where the first <= the second", Describe(m));
+}
+
+// Tests that Lt() matches a 2-tuple where the first field < the
+// second field.
+TEST(Lt2Test, MatchesLessThanArguments) {
+  Matcher<const Tuple2&> m = Lt();
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
+}
+
+// Tests that Lt() describes itself properly.
+TEST(Lt2Test, CanDescribeSelf) {
+  Matcher<const Tuple2&> m = Lt();
+  EXPECT_EQ("are a pair where the first < the second", Describe(m));
+}
+
+// Tests that Ne() matches a 2-tuple where the first field != the
+// second field.
+TEST(Ne2Test, MatchesUnequalArguments) {
+  Matcher<const Tuple2&> m = Ne();
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
+}
+
+// Tests that Ne() describes itself properly.
+TEST(Ne2Test, CanDescribeSelf) {
+  Matcher<const Tuple2&> m = Ne();
+  EXPECT_EQ("are an unequal pair", Describe(m));
+}
+
+// Tests that Not(m) matches any value that doesn't match m.
+TEST(NotTest, NegatesMatcher) {
+  Matcher<int> m;
+  m = Not(Eq(2));
+  EXPECT_TRUE(m.Matches(3));
+  EXPECT_FALSE(m.Matches(2));
+}
+
+// Tests that Not(m) describes itself properly.
+TEST(NotTest, CanDescribeSelf) {
+  Matcher<int> m = Not(Eq(5));
+  EXPECT_EQ("isn't equal to 5", Describe(m));
+}
+
+// Tests that monomorphic matchers are safely cast by the Not matcher.
+TEST(NotTest, NotMatcherSafelyCastsMonomorphicMatchers) {
+  // greater_than_5 is a monomorphic matcher.
+  Matcher<int> greater_than_5 = Gt(5);
+
+  Matcher<const int&> m = Not(greater_than_5);
+  Matcher<int&> m2 = Not(greater_than_5);
+  Matcher<int&> m3 = Not(m);
+}
+
+// Helper to allow easy testing of AllOf matchers with num parameters.
+void AllOfMatches(int num, const Matcher<int>& m) {
+  SCOPED_TRACE(Describe(m));
+  EXPECT_TRUE(m.Matches(0));
+  for (int i = 1; i <= num; ++i) {
+    EXPECT_FALSE(m.Matches(i));
+  }
+  EXPECT_TRUE(m.Matches(num + 1));
+}
+
+// Tests that AllOf(m1, ..., mn) matches any value that matches all of
+// the given matchers.
+TEST(AllOfTest, MatchesWhenAllMatch) {
+  Matcher<int> m;
+  m = AllOf(Le(2), Ge(1));
+  EXPECT_TRUE(m.Matches(1));
+  EXPECT_TRUE(m.Matches(2));
+  EXPECT_FALSE(m.Matches(0));
+  EXPECT_FALSE(m.Matches(3));
+
+  m = AllOf(Gt(0), Ne(1), Ne(2));
+  EXPECT_TRUE(m.Matches(3));
+  EXPECT_FALSE(m.Matches(2));
+  EXPECT_FALSE(m.Matches(1));
+  EXPECT_FALSE(m.Matches(0));
+
+  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
+  EXPECT_TRUE(m.Matches(4));
+  EXPECT_FALSE(m.Matches(3));
+  EXPECT_FALSE(m.Matches(2));
+  EXPECT_FALSE(m.Matches(1));
+  EXPECT_FALSE(m.Matches(0));
+
+  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
+  EXPECT_TRUE(m.Matches(0));
+  EXPECT_TRUE(m.Matches(1));
+  EXPECT_FALSE(m.Matches(3));
+
+  // The following tests for varying number of sub-matchers. Due to the way
+  // the sub-matchers are handled it is enough to test every sub-matcher once
+  // with sub-matchers using the same matcher type. Varying matcher types are
+  // checked for above.
+  AllOfMatches(2, AllOf(Ne(1), Ne(2)));
+  AllOfMatches(3, AllOf(Ne(1), Ne(2), Ne(3)));
+  AllOfMatches(4, AllOf(Ne(1), Ne(2), Ne(3), Ne(4)));
+  AllOfMatches(5, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5)));
+  AllOfMatches(6, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6)));
+  AllOfMatches(7, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7)));
+  AllOfMatches(8, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7),
+                        Ne(8)));
+  AllOfMatches(9, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7),
+                        Ne(8), Ne(9)));
+  AllOfMatches(10, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
+                         Ne(9), Ne(10)));
+}
+
+#if GTEST_LANG_CXX11
+// Tests the variadic version of the AllOfMatcher.
+TEST(AllOfTest, VariadicMatchesWhenAllMatch) {
+  // Make sure AllOf is defined in the right namespace and does not depend on
+  // ADL.
+  ::testing::AllOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+  Matcher<int> m = AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
+                         Ne(9), Ne(10), Ne(11));
+  EXPECT_THAT(Describe(m), EndsWith("and (isn't equal to 11))))))))))"));
+  AllOfMatches(11, m);
+  AllOfMatches(50, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
+                         Ne(9), Ne(10), Ne(11), Ne(12), Ne(13), Ne(14), Ne(15),
+                         Ne(16), Ne(17), Ne(18), Ne(19), Ne(20), Ne(21), Ne(22),
+                         Ne(23), Ne(24), Ne(25), Ne(26), Ne(27), Ne(28), Ne(29),
+                         Ne(30), Ne(31), Ne(32), Ne(33), Ne(34), Ne(35), Ne(36),
+                         Ne(37), Ne(38), Ne(39), Ne(40), Ne(41), Ne(42), Ne(43),
+                         Ne(44), Ne(45), Ne(46), Ne(47), Ne(48), Ne(49),
+                         Ne(50)));
+}
+
+#endif  // GTEST_LANG_CXX11
+
+// Tests that AllOf(m1, ..., mn) describes itself properly.
+TEST(AllOfTest, CanDescribeSelf) {
+  Matcher<int> m;
+  m = AllOf(Le(2), Ge(1));
+  EXPECT_EQ("(is <= 2) and (is >= 1)", Describe(m));
+
+  m = AllOf(Gt(0), Ne(1), Ne(2));
+  EXPECT_EQ("(is > 0) and "
+            "((isn't equal to 1) and "
+            "(isn't equal to 2))",
+            Describe(m));
+
+
+  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
+  EXPECT_EQ("((is > 0) and "
+            "(isn't equal to 1)) and "
+            "((isn't equal to 2) and "
+            "(isn't equal to 3))",
+            Describe(m));
+
+
+  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
+  EXPECT_EQ("((is >= 0) and "
+            "(is < 10)) and "
+            "((isn't equal to 3) and "
+            "((isn't equal to 5) and "
+            "(isn't equal to 7)))",
+            Describe(m));
+}
+
+// Tests that AllOf(m1, ..., mn) describes its negation properly.
+TEST(AllOfTest, CanDescribeNegation) {
+  Matcher<int> m;
+  m = AllOf(Le(2), Ge(1));
+  EXPECT_EQ("(isn't <= 2) or "
+            "(isn't >= 1)",
+            DescribeNegation(m));
+
+  m = AllOf(Gt(0), Ne(1), Ne(2));
+  EXPECT_EQ("(isn't > 0) or "
+            "((is equal to 1) or "
+            "(is equal to 2))",
+            DescribeNegation(m));
+
+
+  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
+  EXPECT_EQ("((isn't > 0) or "
+            "(is equal to 1)) or "
+            "((is equal to 2) or "
+            "(is equal to 3))",
+            DescribeNegation(m));
+
+
+  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
+  EXPECT_EQ("((isn't >= 0) or "
+            "(isn't < 10)) or "
+            "((is equal to 3) or "
+            "((is equal to 5) or "
+            "(is equal to 7)))",
+            DescribeNegation(m));
+}
+
+// Tests that monomorphic matchers are safely cast by the AllOf matcher.
+TEST(AllOfTest, AllOfMatcherSafelyCastsMonomorphicMatchers) {
+  // greater_than_5 and less_than_10 are monomorphic matchers.
+  Matcher<int> greater_than_5 = Gt(5);
+  Matcher<int> less_than_10 = Lt(10);
+
+  Matcher<const int&> m = AllOf(greater_than_5, less_than_10);
+  Matcher<int&> m2 = AllOf(greater_than_5, less_than_10);
+  Matcher<int&> m3 = AllOf(greater_than_5, m2);
+
+  // Tests that BothOf works when composing itself.
+  Matcher<const int&> m4 = AllOf(greater_than_5, less_than_10, less_than_10);
+  Matcher<int&> m5 = AllOf(greater_than_5, less_than_10, less_than_10);
+}
+
+TEST(AllOfTest, ExplainsResult) {
+  Matcher<int> m;
+
+  // Successful match.  Both matchers need to explain.  The second
+  // matcher doesn't give an explanation, so only the first matcher's
+  // explanation is printed.
+  m = AllOf(GreaterThan(10), Lt(30));
+  EXPECT_EQ("which is 15 more than 10", Explain(m, 25));
+
+  // Successful match.  Both matchers need to explain.
+  m = AllOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 20 more than 10, and which is 10 more than 20",
+            Explain(m, 30));
+
+  // Successful match.  All matchers need to explain.  The second
+  // matcher doesn't given an explanation.
+  m = AllOf(GreaterThan(10), Lt(30), GreaterThan(20));
+  EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20",
+            Explain(m, 25));
+
+  // Successful match.  All matchers need to explain.
+  m = AllOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
+  EXPECT_EQ("which is 30 more than 10, and which is 20 more than 20, "
+            "and which is 10 more than 30",
+            Explain(m, 40));
+
+  // Failed match.  The first matcher, which failed, needs to
+  // explain.
+  m = AllOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
+
+  // Failed match.  The second matcher, which failed, needs to
+  // explain.  Since it doesn't given an explanation, nothing is
+  // printed.
+  m = AllOf(GreaterThan(10), Lt(30));
+  EXPECT_EQ("", Explain(m, 40));
+
+  // Failed match.  The second matcher, which failed, needs to
+  // explain.
+  m = AllOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 5 less than 20", Explain(m, 15));
+}
+
+// Helper to allow easy testing of AnyOf matchers with num parameters.
+void AnyOfMatches(int num, const Matcher<int>& m) {
+  SCOPED_TRACE(Describe(m));
+  EXPECT_FALSE(m.Matches(0));
+  for (int i = 1; i <= num; ++i) {
+    EXPECT_TRUE(m.Matches(i));
+  }
+  EXPECT_FALSE(m.Matches(num + 1));
+}
+
+// Tests that AnyOf(m1, ..., mn) matches any value that matches at
+// least one of the given matchers.
+TEST(AnyOfTest, MatchesWhenAnyMatches) {
+  Matcher<int> m;
+  m = AnyOf(Le(1), Ge(3));
+  EXPECT_TRUE(m.Matches(1));
+  EXPECT_TRUE(m.Matches(4));
+  EXPECT_FALSE(m.Matches(2));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2));
+  EXPECT_TRUE(m.Matches(-1));
+  EXPECT_TRUE(m.Matches(1));
+  EXPECT_TRUE(m.Matches(2));
+  EXPECT_FALSE(m.Matches(0));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
+  EXPECT_TRUE(m.Matches(-1));
+  EXPECT_TRUE(m.Matches(1));
+  EXPECT_TRUE(m.Matches(2));
+  EXPECT_TRUE(m.Matches(3));
+  EXPECT_FALSE(m.Matches(0));
+
+  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
+  EXPECT_TRUE(m.Matches(0));
+  EXPECT_TRUE(m.Matches(11));
+  EXPECT_TRUE(m.Matches(3));
+  EXPECT_FALSE(m.Matches(2));
+
+  // The following tests for varying number of sub-matchers. Due to the way
+  // the sub-matchers are handled it is enough to test every sub-matcher once
+  // with sub-matchers using the same matcher type. Varying matcher types are
+  // checked for above.
+  AnyOfMatches(2, AnyOf(1, 2));
+  AnyOfMatches(3, AnyOf(1, 2, 3));
+  AnyOfMatches(4, AnyOf(1, 2, 3, 4));
+  AnyOfMatches(5, AnyOf(1, 2, 3, 4, 5));
+  AnyOfMatches(6, AnyOf(1, 2, 3, 4, 5, 6));
+  AnyOfMatches(7, AnyOf(1, 2, 3, 4, 5, 6, 7));
+  AnyOfMatches(8, AnyOf(1, 2, 3, 4, 5, 6, 7, 8));
+  AnyOfMatches(9, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9));
+  AnyOfMatches(10, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
+}
+
+#if GTEST_LANG_CXX11
+// Tests the variadic version of the AnyOfMatcher.
+TEST(AnyOfTest, VariadicMatchesWhenAnyMatches) {
+  // Also make sure AnyOf is defined in the right namespace and does not depend
+  // on ADL.
+  Matcher<int> m = ::testing::AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+
+  EXPECT_THAT(Describe(m), EndsWith("or (is equal to 11))))))))))"));
+  AnyOfMatches(11, m);
+  AnyOfMatches(50, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+                         11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+                         21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+                         31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+                         41, 42, 43, 44, 45, 46, 47, 48, 49, 50));
+}
+
+#endif  // GTEST_LANG_CXX11
+
+// Tests that AnyOf(m1, ..., mn) describes itself properly.
+TEST(AnyOfTest, CanDescribeSelf) {
+  Matcher<int> m;
+  m = AnyOf(Le(1), Ge(3));
+  EXPECT_EQ("(is <= 1) or (is >= 3)",
+            Describe(m));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2));
+  EXPECT_EQ("(is < 0) or "
+            "((is equal to 1) or (is equal to 2))",
+            Describe(m));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
+  EXPECT_EQ("((is < 0) or "
+            "(is equal to 1)) or "
+            "((is equal to 2) or "
+            "(is equal to 3))",
+            Describe(m));
+
+  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
+  EXPECT_EQ("((is <= 0) or "
+            "(is > 10)) or "
+            "((is equal to 3) or "
+            "((is equal to 5) or "
+            "(is equal to 7)))",
+            Describe(m));
+}
+
+// Tests that AnyOf(m1, ..., mn) describes its negation properly.
+TEST(AnyOfTest, CanDescribeNegation) {
+  Matcher<int> m;
+  m = AnyOf(Le(1), Ge(3));
+  EXPECT_EQ("(isn't <= 1) and (isn't >= 3)",
+            DescribeNegation(m));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2));
+  EXPECT_EQ("(isn't < 0) and "
+            "((isn't equal to 1) and (isn't equal to 2))",
+            DescribeNegation(m));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
+  EXPECT_EQ("((isn't < 0) and "
+            "(isn't equal to 1)) and "
+            "((isn't equal to 2) and "
+            "(isn't equal to 3))",
+            DescribeNegation(m));
+
+  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
+  EXPECT_EQ("((isn't <= 0) and "
+            "(isn't > 10)) and "
+            "((isn't equal to 3) and "
+            "((isn't equal to 5) and "
+            "(isn't equal to 7)))",
+            DescribeNegation(m));
+}
+
+// Tests that monomorphic matchers are safely cast by the AnyOf matcher.
+TEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) {
+  // greater_than_5 and less_than_10 are monomorphic matchers.
+  Matcher<int> greater_than_5 = Gt(5);
+  Matcher<int> less_than_10 = Lt(10);
+
+  Matcher<const int&> m = AnyOf(greater_than_5, less_than_10);
+  Matcher<int&> m2 = AnyOf(greater_than_5, less_than_10);
+  Matcher<int&> m3 = AnyOf(greater_than_5, m2);
+
+  // Tests that EitherOf works when composing itself.
+  Matcher<const int&> m4 = AnyOf(greater_than_5, less_than_10, less_than_10);
+  Matcher<int&> m5 = AnyOf(greater_than_5, less_than_10, less_than_10);
+}
+
+TEST(AnyOfTest, ExplainsResult) {
+  Matcher<int> m;
+
+  // Failed match.  Both matchers need to explain.  The second
+  // matcher doesn't give an explanation, so only the first matcher's
+  // explanation is printed.
+  m = AnyOf(GreaterThan(10), Lt(0));
+  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
+
+  // Failed match.  Both matchers need to explain.
+  m = AnyOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20",
+            Explain(m, 5));
+
+  // Failed match.  All matchers need to explain.  The second
+  // matcher doesn't given an explanation.
+  m = AnyOf(GreaterThan(10), Gt(20), GreaterThan(30));
+  EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30",
+            Explain(m, 5));
+
+  // Failed match.  All matchers need to explain.
+  m = AnyOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
+  EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20, "
+            "and which is 25 less than 30",
+            Explain(m, 5));
+
+  // Successful match.  The first matcher, which succeeded, needs to
+  // explain.
+  m = AnyOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 5 more than 10", Explain(m, 15));
+
+  // Successful match.  The second matcher, which succeeded, needs to
+  // explain.  Since it doesn't given an explanation, nothing is
+  // printed.
+  m = AnyOf(GreaterThan(10), Lt(30));
+  EXPECT_EQ("", Explain(m, 0));
+
+  // Successful match.  The second matcher, which succeeded, needs to
+  // explain.
+  m = AnyOf(GreaterThan(30), GreaterThan(20));
+  EXPECT_EQ("which is 5 more than 20", Explain(m, 25));
+}
+
+// The following predicate function and predicate functor are for
+// testing the Truly(predicate) matcher.
+
+// Returns non-zero if the input is positive.  Note that the return
+// type of this function is not bool.  It's OK as Truly() accepts any
+// unary function or functor whose return type can be implicitly
+// converted to bool.
+int IsPositive(double x) {
+  return x > 0 ? 1 : 0;
+}
+
+// This functor returns true if the input is greater than the given
+// number.
+class IsGreaterThan {
+ public:
+  explicit IsGreaterThan(int threshold) : threshold_(threshold) {}
+
+  bool operator()(int n) const { return n > threshold_; }
+
+ private:
+  int threshold_;
+};
+
+// For testing Truly().
+const int foo = 0;
+
+// This predicate returns true iff the argument references foo and has
+// a zero value.
+bool ReferencesFooAndIsZero(const int& n) {
+  return (&n == &foo) && (n == 0);
+}
+
+// Tests that Truly(predicate) matches what satisfies the given
+// predicate.
+TEST(TrulyTest, MatchesWhatSatisfiesThePredicate) {
+  Matcher<double> m = Truly(IsPositive);
+  EXPECT_TRUE(m.Matches(2.0));
+  EXPECT_FALSE(m.Matches(-1.5));
+}
+
+// Tests that Truly(predicate_functor) works too.
+TEST(TrulyTest, CanBeUsedWithFunctor) {
+  Matcher<int> m = Truly(IsGreaterThan(5));
+  EXPECT_TRUE(m.Matches(6));
+  EXPECT_FALSE(m.Matches(4));
+}
+
+// A class that can be implicitly converted to bool.
+class ConvertibleToBool {
+ public:
+  explicit ConvertibleToBool(int number) : number_(number) {}
+  operator bool() const { return number_ != 0; }
+
+ private:
+  int number_;
+};
+
+ConvertibleToBool IsNotZero(int number) {
+  return ConvertibleToBool(number);
+}
+
+// Tests that the predicate used in Truly() may return a class that's
+// implicitly convertible to bool, even when the class has no
+// operator!().
+TEST(TrulyTest, PredicateCanReturnAClassConvertibleToBool) {
+  Matcher<int> m = Truly(IsNotZero);
+  EXPECT_TRUE(m.Matches(1));
+  EXPECT_FALSE(m.Matches(0));
+}
+
+// Tests that Truly(predicate) can describe itself properly.
+TEST(TrulyTest, CanDescribeSelf) {
+  Matcher<double> m = Truly(IsPositive);
+  EXPECT_EQ("satisfies the given predicate",
+            Describe(m));
+}
+
+// Tests that Truly(predicate) works when the matcher takes its
+// argument by reference.
+TEST(TrulyTest, WorksForByRefArguments) {
+  Matcher<const int&> m = Truly(ReferencesFooAndIsZero);
+  EXPECT_TRUE(m.Matches(foo));
+  int n = 0;
+  EXPECT_FALSE(m.Matches(n));
+}
+
+// Tests that Matches(m) is a predicate satisfied by whatever that
+// matches matcher m.
+TEST(MatchesTest, IsSatisfiedByWhatMatchesTheMatcher) {
+  EXPECT_TRUE(Matches(Ge(0))(1));
+  EXPECT_FALSE(Matches(Eq('a'))('b'));
+}
+
+// Tests that Matches(m) works when the matcher takes its argument by
+// reference.
+TEST(MatchesTest, WorksOnByRefArguments) {
+  int m = 0, n = 0;
+  EXPECT_TRUE(Matches(AllOf(Ref(n), Eq(0)))(n));
+  EXPECT_FALSE(Matches(Ref(m))(n));
+}
+
+// Tests that a Matcher on non-reference type can be used in
+// Matches().
+TEST(MatchesTest, WorksWithMatcherOnNonRefType) {
+  Matcher<int> eq5 = Eq(5);
+  EXPECT_TRUE(Matches(eq5)(5));
+  EXPECT_FALSE(Matches(eq5)(2));
+}
+
+// Tests Value(value, matcher).  Since Value() is a simple wrapper for
+// Matches(), which has been tested already, we don't spend a lot of
+// effort on testing Value().
+TEST(ValueTest, WorksWithPolymorphicMatcher) {
+  EXPECT_TRUE(Value("hi", StartsWith("h")));
+  EXPECT_FALSE(Value(5, Gt(10)));
+}
+
+TEST(ValueTest, WorksWithMonomorphicMatcher) {
+  const Matcher<int> is_zero = Eq(0);
+  EXPECT_TRUE(Value(0, is_zero));
+  EXPECT_FALSE(Value('a', is_zero));
+
+  int n = 0;
+  const Matcher<const int&> ref_n = Ref(n);
+  EXPECT_TRUE(Value(n, ref_n));
+  EXPECT_FALSE(Value(1, ref_n));
+}
+
+TEST(ExplainMatchResultTest, WorksWithPolymorphicMatcher) {
+  StringMatchResultListener listener1;
+  EXPECT_TRUE(ExplainMatchResult(PolymorphicIsEven(), 42, &listener1));
+  EXPECT_EQ("% 2 == 0", listener1.str());
+
+  StringMatchResultListener listener2;
+  EXPECT_FALSE(ExplainMatchResult(Ge(42), 1.5, &listener2));
+  EXPECT_EQ("", listener2.str());
+}
+
+TEST(ExplainMatchResultTest, WorksWithMonomorphicMatcher) {
+  const Matcher<int> is_even = PolymorphicIsEven();
+  StringMatchResultListener listener1;
+  EXPECT_TRUE(ExplainMatchResult(is_even, 42, &listener1));
+  EXPECT_EQ("% 2 == 0", listener1.str());
+
+  const Matcher<const double&> is_zero = Eq(0);
+  StringMatchResultListener listener2;
+  EXPECT_FALSE(ExplainMatchResult(is_zero, 1.5, &listener2));
+  EXPECT_EQ("", listener2.str());
+}
+
+MATCHER_P(Really, inner_matcher, "") {
+  return ExplainMatchResult(inner_matcher, arg, result_listener);
+}
+
+TEST(ExplainMatchResultTest, WorksInsideMATCHER) {
+  EXPECT_THAT(0, Really(Eq(0)));
+}
+
+TEST(AllArgsTest, WorksForTuple) {
+  EXPECT_THAT(make_tuple(1, 2L), AllArgs(Lt()));
+  EXPECT_THAT(make_tuple(2L, 1), Not(AllArgs(Lt())));
+}
+
+TEST(AllArgsTest, WorksForNonTuple) {
+  EXPECT_THAT(42, AllArgs(Gt(0)));
+  EXPECT_THAT('a', Not(AllArgs(Eq('b'))));
+}
+
+class AllArgsHelper {
+ public:
+  AllArgsHelper() {}
+
+  MOCK_METHOD2(Helper, int(char x, int y));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AllArgsHelper);
+};
+
+TEST(AllArgsTest, WorksInWithClause) {
+  AllArgsHelper helper;
+  ON_CALL(helper, Helper(_, _))
+      .With(AllArgs(Lt()))
+      .WillByDefault(Return(1));
+  EXPECT_CALL(helper, Helper(_, _));
+  EXPECT_CALL(helper, Helper(_, _))
+      .With(AllArgs(Gt()))
+      .WillOnce(Return(2));
+
+  EXPECT_EQ(1, helper.Helper('\1', 2));
+  EXPECT_EQ(2, helper.Helper('a', 1));
+}
+
+// Tests that ASSERT_THAT() and EXPECT_THAT() work when the value
+// matches the matcher.
+TEST(MatcherAssertionTest, WorksWhenMatcherIsSatisfied) {
+  ASSERT_THAT(5, Ge(2)) << "This should succeed.";
+  ASSERT_THAT("Foo", EndsWith("oo"));
+  EXPECT_THAT(2, AllOf(Le(7), Ge(0))) << "This should succeed too.";
+  EXPECT_THAT("Hello", StartsWith("Hell"));
+}
+
+// Tests that ASSERT_THAT() and EXPECT_THAT() work when the value
+// doesn't match the matcher.
+TEST(MatcherAssertionTest, WorksWhenMatcherIsNotSatisfied) {
+  // 'n' must be static as it is used in an EXPECT_FATAL_FAILURE(),
+  // which cannot reference auto variables.
+  static unsigned short n;  // NOLINT
+  n = 5;
+
+  // VC++ prior to version 8.0 SP1 has a bug where it will not see any
+  // functions declared in the namespace scope from within nested classes.
+  // EXPECT/ASSERT_(NON)FATAL_FAILURE macros use nested classes so that all
+  // namespace-level functions invoked inside them need to be explicitly
+  // resolved.
+  EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Gt(10)),
+                       "Value of: n\n"
+                       "Expected: is > 10\n"
+                       "  Actual: 5" + OfType("unsigned short"));
+  n = 0;
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THAT(n, ::testing::AllOf(::testing::Le(7), ::testing::Ge(5))),
+      "Value of: n\n"
+      "Expected: (is <= 7) and (is >= 5)\n"
+      "  Actual: 0" + OfType("unsigned short"));
+}
+
+// Tests that ASSERT_THAT() and EXPECT_THAT() work when the argument
+// has a reference type.
+TEST(MatcherAssertionTest, WorksForByRefArguments) {
+  // We use a static variable here as EXPECT_FATAL_FAILURE() cannot
+  // reference auto variables.
+  static int n;
+  n = 0;
+  EXPECT_THAT(n, AllOf(Le(7), Ref(n)));
+  EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))),
+                       "Value of: n\n"
+                       "Expected: does not reference the variable @");
+  // Tests the "Actual" part.
+  EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))),
+                       "Actual: 0" + OfType("int") + ", which is located @");
+}
+
+#if !GTEST_OS_SYMBIAN
+// Tests that ASSERT_THAT() and EXPECT_THAT() work when the matcher is
+// monomorphic.
+
+// ASSERT_THAT("hello", starts_with_he) fails to compile with Nokia's
+// Symbian compiler: it tries to compile
+// template<T, U> class MatcherCastImpl { ...
+//   virtual bool MatchAndExplain(T x, ...) const {
+//     return source_matcher_.MatchAndExplain(static_cast<U>(x), ...);
+// with U == string and T == const char*
+// With ASSERT_THAT("hello"...) changed to ASSERT_THAT(string("hello") ... )
+// the compiler silently crashes with no output.
+// If MatcherCastImpl is changed to use U(x) instead of static_cast<U>(x)
+// the code compiles but the converted string is bogus.
+TEST(MatcherAssertionTest, WorksForMonomorphicMatcher) {
+  Matcher<const char*> starts_with_he = StartsWith("he");
+  ASSERT_THAT("hello", starts_with_he);
+
+  Matcher<const string&> ends_with_ok = EndsWith("ok");
+  ASSERT_THAT("book", ends_with_ok);
+  const string bad = "bad";
+  EXPECT_NONFATAL_FAILURE(EXPECT_THAT(bad, ends_with_ok),
+                          "Value of: bad\n"
+                          "Expected: ends with \"ok\"\n"
+                          "  Actual: \"bad\"");
+  Matcher<int> is_greater_than_5 = Gt(5);
+  EXPECT_NONFATAL_FAILURE(EXPECT_THAT(5, is_greater_than_5),
+                          "Value of: 5\n"
+                          "Expected: is > 5\n"
+                          "  Actual: 5" + OfType("int"));
+}
+#endif  // !GTEST_OS_SYMBIAN
+
+// Tests floating-point matchers.
+template <typename RawType>
+class FloatingPointTest : public testing::Test {
+ protected:
+  typedef testing::internal::FloatingPoint<RawType> Floating;
+  typedef typename Floating::Bits Bits;
+
+  FloatingPointTest()
+      : max_ulps_(Floating::kMaxUlps),
+        zero_bits_(Floating(0).bits()),
+        one_bits_(Floating(1).bits()),
+        infinity_bits_(Floating(Floating::Infinity()).bits()),
+        close_to_positive_zero_(AsBits(zero_bits_ + max_ulps_/2)),
+        close_to_negative_zero_(AsBits(zero_bits_ + max_ulps_ - max_ulps_/2)),
+        further_from_negative_zero_(-AsBits(
+            zero_bits_ + max_ulps_ + 1 - max_ulps_/2)),
+        close_to_one_(AsBits(one_bits_ + max_ulps_)),
+        further_from_one_(AsBits(one_bits_ + max_ulps_ + 1)),
+        infinity_(Floating::Infinity()),
+        close_to_infinity_(AsBits(infinity_bits_ - max_ulps_)),
+        further_from_infinity_(AsBits(infinity_bits_ - max_ulps_ - 1)),
+        max_(Floating::Max()),
+        nan1_(AsBits(Floating::kExponentBitMask | 1)),
+        nan2_(AsBits(Floating::kExponentBitMask | 200)) {
+  }
+
+  void TestSize() {
+    EXPECT_EQ(sizeof(RawType), sizeof(Bits));
+  }
+
+  // A battery of tests for FloatingEqMatcher::Matches.
+  // matcher_maker is a pointer to a function which creates a FloatingEqMatcher.
+  void TestMatches(
+      testing::internal::FloatingEqMatcher<RawType> (*matcher_maker)(RawType)) {
+    Matcher<RawType> m1 = matcher_maker(0.0);
+    EXPECT_TRUE(m1.Matches(-0.0));
+    EXPECT_TRUE(m1.Matches(close_to_positive_zero_));
+    EXPECT_TRUE(m1.Matches(close_to_negative_zero_));
+    EXPECT_FALSE(m1.Matches(1.0));
+
+    Matcher<RawType> m2 = matcher_maker(close_to_positive_zero_);
+    EXPECT_FALSE(m2.Matches(further_from_negative_zero_));
+
+    Matcher<RawType> m3 = matcher_maker(1.0);
+    EXPECT_TRUE(m3.Matches(close_to_one_));
+    EXPECT_FALSE(m3.Matches(further_from_one_));
+
+    // Test commutativity: matcher_maker(0.0).Matches(1.0) was tested above.
+    EXPECT_FALSE(m3.Matches(0.0));
+
+    Matcher<RawType> m4 = matcher_maker(-infinity_);
+    EXPECT_TRUE(m4.Matches(-close_to_infinity_));
+
+    Matcher<RawType> m5 = matcher_maker(infinity_);
+    EXPECT_TRUE(m5.Matches(close_to_infinity_));
+
+    // This is interesting as the representations of infinity_ and nan1_
+    // are only 1 DLP apart.
+    EXPECT_FALSE(m5.Matches(nan1_));
+
+    // matcher_maker can produce a Matcher<const RawType&>, which is needed in
+    // some cases.
+    Matcher<const RawType&> m6 = matcher_maker(0.0);
+    EXPECT_TRUE(m6.Matches(-0.0));
+    EXPECT_TRUE(m6.Matches(close_to_positive_zero_));
+    EXPECT_FALSE(m6.Matches(1.0));
+
+    // matcher_maker can produce a Matcher<RawType&>, which is needed in some
+    // cases.
+    Matcher<RawType&> m7 = matcher_maker(0.0);
+    RawType x = 0.0;
+    EXPECT_TRUE(m7.Matches(x));
+    x = 0.01f;
+    EXPECT_FALSE(m7.Matches(x));
+  }
+
+  // Pre-calculated numbers to be used by the tests.
+
+  const size_t max_ulps_;
+
+  const Bits zero_bits_;  // The bits that represent 0.0.
+  const Bits one_bits_;  // The bits that represent 1.0.
+  const Bits infinity_bits_;  // The bits that represent +infinity.
+
+  // Some numbers close to 0.0.
+  const RawType close_to_positive_zero_;
+  const RawType close_to_negative_zero_;
+  const RawType further_from_negative_zero_;
+
+  // Some numbers close to 1.0.
+  const RawType close_to_one_;
+  const RawType further_from_one_;
+
+  // Some numbers close to +infinity.
+  const RawType infinity_;
+  const RawType close_to_infinity_;
+  const RawType further_from_infinity_;
+
+  // Maximum representable value that's not infinity.
+  const RawType max_;
+
+  // Some NaNs.
+  const RawType nan1_;
+  const RawType nan2_;
+
+ private:
+  template <typename T>
+  static RawType AsBits(T value) {
+    return Floating::ReinterpretBits(static_cast<Bits>(value));
+  }
+};
+
+// Tests floating-point matchers with fixed epsilons.
+template <typename RawType>
+class FloatingPointNearTest : public FloatingPointTest<RawType> {
+ protected:
+  typedef FloatingPointTest<RawType> ParentType;
+
+  // A battery of tests for FloatingEqMatcher::Matches with a fixed epsilon.
+  // matcher_maker is a pointer to a function which creates a FloatingEqMatcher.
+  void TestNearMatches(
+      testing::internal::FloatingEqMatcher<RawType>
+          (*matcher_maker)(RawType, RawType)) {
+    Matcher<RawType> m1 = matcher_maker(0.0, 0.0);
+    EXPECT_TRUE(m1.Matches(0.0));
+    EXPECT_TRUE(m1.Matches(-0.0));
+    EXPECT_FALSE(m1.Matches(ParentType::close_to_positive_zero_));
+    EXPECT_FALSE(m1.Matches(ParentType::close_to_negative_zero_));
+    EXPECT_FALSE(m1.Matches(1.0));
+
+    Matcher<RawType> m2 = matcher_maker(0.0, 1.0);
+    EXPECT_TRUE(m2.Matches(0.0));
+    EXPECT_TRUE(m2.Matches(-0.0));
+    EXPECT_TRUE(m2.Matches(1.0));
+    EXPECT_TRUE(m2.Matches(-1.0));
+    EXPECT_FALSE(m2.Matches(ParentType::close_to_one_));
+    EXPECT_FALSE(m2.Matches(-ParentType::close_to_one_));
+
+    // Check that inf matches inf, regardless of the of the specified max
+    // absolute error.
+    Matcher<RawType> m3 = matcher_maker(ParentType::infinity_, 0.0);
+    EXPECT_TRUE(m3.Matches(ParentType::infinity_));
+    EXPECT_FALSE(m3.Matches(ParentType::close_to_infinity_));
+    EXPECT_FALSE(m3.Matches(-ParentType::infinity_));
+
+    Matcher<RawType> m4 = matcher_maker(-ParentType::infinity_, 0.0);
+    EXPECT_TRUE(m4.Matches(-ParentType::infinity_));
+    EXPECT_FALSE(m4.Matches(-ParentType::close_to_infinity_));
+    EXPECT_FALSE(m4.Matches(ParentType::infinity_));
+
+    // Test various overflow scenarios.
+    Matcher<RawType> m5 = matcher_maker(ParentType::max_, ParentType::max_);
+    EXPECT_TRUE(m5.Matches(ParentType::max_));
+    EXPECT_FALSE(m5.Matches(-ParentType::max_));
+
+    Matcher<RawType> m6 = matcher_maker(-ParentType::max_, ParentType::max_);
+    EXPECT_FALSE(m6.Matches(ParentType::max_));
+    EXPECT_TRUE(m6.Matches(-ParentType::max_));
+
+    Matcher<RawType> m7 = matcher_maker(ParentType::max_, 0);
+    EXPECT_TRUE(m7.Matches(ParentType::max_));
+    EXPECT_FALSE(m7.Matches(-ParentType::max_));
+
+    Matcher<RawType> m8 = matcher_maker(-ParentType::max_, 0);
+    EXPECT_FALSE(m8.Matches(ParentType::max_));
+    EXPECT_TRUE(m8.Matches(-ParentType::max_));
+
+    // The difference between max() and -max() normally overflows to infinity,
+    // but it should still match if the max_abs_error is also infinity.
+    Matcher<RawType> m9 = matcher_maker(
+        ParentType::max_, ParentType::infinity_);
+    EXPECT_TRUE(m8.Matches(-ParentType::max_));
+
+    // matcher_maker can produce a Matcher<const RawType&>, which is needed in
+    // some cases.
+    Matcher<const RawType&> m10 = matcher_maker(0.0, 1.0);
+    EXPECT_TRUE(m10.Matches(-0.0));
+    EXPECT_TRUE(m10.Matches(ParentType::close_to_positive_zero_));
+    EXPECT_FALSE(m10.Matches(ParentType::close_to_one_));
+
+    // matcher_maker can produce a Matcher<RawType&>, which is needed in some
+    // cases.
+    Matcher<RawType&> m11 = matcher_maker(0.0, 1.0);
+    RawType x = 0.0;
+    EXPECT_TRUE(m11.Matches(x));
+    x = 1.0f;
+    EXPECT_TRUE(m11.Matches(x));
+    x = -1.0f;
+    EXPECT_TRUE(m11.Matches(x));
+    x = 1.1f;
+    EXPECT_FALSE(m11.Matches(x));
+    x = -1.1f;
+    EXPECT_FALSE(m11.Matches(x));
+  }
+};
+
+// Instantiate FloatingPointTest for testing floats.
+typedef FloatingPointTest<float> FloatTest;
+
+TEST_F(FloatTest, FloatEqApproximatelyMatchesFloats) {
+  TestMatches(&FloatEq);
+}
+
+TEST_F(FloatTest, NanSensitiveFloatEqApproximatelyMatchesFloats) {
+  TestMatches(&NanSensitiveFloatEq);
+}
+
+TEST_F(FloatTest, FloatEqCannotMatchNaN) {
+  // FloatEq never matches NaN.
+  Matcher<float> m = FloatEq(nan1_);
+  EXPECT_FALSE(m.Matches(nan1_));
+  EXPECT_FALSE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST_F(FloatTest, NanSensitiveFloatEqCanMatchNaN) {
+  // NanSensitiveFloatEq will match NaN.
+  Matcher<float> m = NanSensitiveFloatEq(nan1_);
+  EXPECT_TRUE(m.Matches(nan1_));
+  EXPECT_TRUE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST_F(FloatTest, FloatEqCanDescribeSelf) {
+  Matcher<float> m1 = FloatEq(2.0f);
+  EXPECT_EQ("is approximately 2", Describe(m1));
+  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
+
+  Matcher<float> m2 = FloatEq(0.5f);
+  EXPECT_EQ("is approximately 0.5", Describe(m2));
+  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
+
+  Matcher<float> m3 = FloatEq(nan1_);
+  EXPECT_EQ("never matches", Describe(m3));
+  EXPECT_EQ("is anything", DescribeNegation(m3));
+}
+
+TEST_F(FloatTest, NanSensitiveFloatEqCanDescribeSelf) {
+  Matcher<float> m1 = NanSensitiveFloatEq(2.0f);
+  EXPECT_EQ("is approximately 2", Describe(m1));
+  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
+
+  Matcher<float> m2 = NanSensitiveFloatEq(0.5f);
+  EXPECT_EQ("is approximately 0.5", Describe(m2));
+  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
+
+  Matcher<float> m3 = NanSensitiveFloatEq(nan1_);
+  EXPECT_EQ("is NaN", Describe(m3));
+  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
+}
+
+// Instantiate FloatingPointTest for testing floats with a user-specified
+// max absolute error.
+typedef FloatingPointNearTest<float> FloatNearTest;
+
+TEST_F(FloatNearTest, FloatNearMatches) {
+  TestNearMatches(&FloatNear);
+}
+
+TEST_F(FloatNearTest, NanSensitiveFloatNearApproximatelyMatchesFloats) {
+  TestNearMatches(&NanSensitiveFloatNear);
+}
+
+TEST_F(FloatNearTest, FloatNearCanDescribeSelf) {
+  Matcher<float> m1 = FloatNear(2.0f, 0.5f);
+  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
+  EXPECT_EQ(
+      "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
+
+  Matcher<float> m2 = FloatNear(0.5f, 0.5f);
+  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
+  EXPECT_EQ(
+      "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
+
+  Matcher<float> m3 = FloatNear(nan1_, 0.0);
+  EXPECT_EQ("never matches", Describe(m3));
+  EXPECT_EQ("is anything", DescribeNegation(m3));
+}
+
+TEST_F(FloatNearTest, NanSensitiveFloatNearCanDescribeSelf) {
+  Matcher<float> m1 = NanSensitiveFloatNear(2.0f, 0.5f);
+  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
+  EXPECT_EQ(
+      "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
+
+  Matcher<float> m2 = NanSensitiveFloatNear(0.5f, 0.5f);
+  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
+  EXPECT_EQ(
+      "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
+
+  Matcher<float> m3 = NanSensitiveFloatNear(nan1_, 0.1f);
+  EXPECT_EQ("is NaN", Describe(m3));
+  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
+}
+
+TEST_F(FloatNearTest, FloatNearCannotMatchNaN) {
+  // FloatNear never matches NaN.
+  Matcher<float> m = FloatNear(ParentType::nan1_, 0.1f);
+  EXPECT_FALSE(m.Matches(nan1_));
+  EXPECT_FALSE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST_F(FloatNearTest, NanSensitiveFloatNearCanMatchNaN) {
+  // NanSensitiveFloatNear will match NaN.
+  Matcher<float> m = NanSensitiveFloatNear(nan1_, 0.1f);
+  EXPECT_TRUE(m.Matches(nan1_));
+  EXPECT_TRUE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+// Instantiate FloatingPointTest for testing doubles.
+typedef FloatingPointTest<double> DoubleTest;
+
+TEST_F(DoubleTest, DoubleEqApproximatelyMatchesDoubles) {
+  TestMatches(&DoubleEq);
+}
+
+TEST_F(DoubleTest, NanSensitiveDoubleEqApproximatelyMatchesDoubles) {
+  TestMatches(&NanSensitiveDoubleEq);
+}
+
+TEST_F(DoubleTest, DoubleEqCannotMatchNaN) {
+  // DoubleEq never matches NaN.
+  Matcher<double> m = DoubleEq(nan1_);
+  EXPECT_FALSE(m.Matches(nan1_));
+  EXPECT_FALSE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST_F(DoubleTest, NanSensitiveDoubleEqCanMatchNaN) {
+  // NanSensitiveDoubleEq will match NaN.
+  Matcher<double> m = NanSensitiveDoubleEq(nan1_);
+  EXPECT_TRUE(m.Matches(nan1_));
+  EXPECT_TRUE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST_F(DoubleTest, DoubleEqCanDescribeSelf) {
+  Matcher<double> m1 = DoubleEq(2.0);
+  EXPECT_EQ("is approximately 2", Describe(m1));
+  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
+
+  Matcher<double> m2 = DoubleEq(0.5);
+  EXPECT_EQ("is approximately 0.5", Describe(m2));
+  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
+
+  Matcher<double> m3 = DoubleEq(nan1_);
+  EXPECT_EQ("never matches", Describe(m3));
+  EXPECT_EQ("is anything", DescribeNegation(m3));
+}
+
+TEST_F(DoubleTest, NanSensitiveDoubleEqCanDescribeSelf) {
+  Matcher<double> m1 = NanSensitiveDoubleEq(2.0);
+  EXPECT_EQ("is approximately 2", Describe(m1));
+  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
+
+  Matcher<double> m2 = NanSensitiveDoubleEq(0.5);
+  EXPECT_EQ("is approximately 0.5", Describe(m2));
+  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
+
+  Matcher<double> m3 = NanSensitiveDoubleEq(nan1_);
+  EXPECT_EQ("is NaN", Describe(m3));
+  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
+}
+
+// Instantiate FloatingPointTest for testing floats with a user-specified
+// max absolute error.
+typedef FloatingPointNearTest<double> DoubleNearTest;
+
+TEST_F(DoubleNearTest, DoubleNearMatches) {
+  TestNearMatches(&DoubleNear);
+}
+
+TEST_F(DoubleNearTest, NanSensitiveDoubleNearApproximatelyMatchesDoubles) {
+  TestNearMatches(&NanSensitiveDoubleNear);
+}
+
+TEST_F(DoubleNearTest, DoubleNearCanDescribeSelf) {
+  Matcher<double> m1 = DoubleNear(2.0, 0.5);
+  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
+  EXPECT_EQ(
+      "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
+
+  Matcher<double> m2 = DoubleNear(0.5, 0.5);
+  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
+  EXPECT_EQ(
+      "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
+
+  Matcher<double> m3 = DoubleNear(nan1_, 0.0);
+  EXPECT_EQ("never matches", Describe(m3));
+  EXPECT_EQ("is anything", DescribeNegation(m3));
+}
+
+TEST_F(DoubleNearTest, ExplainsResultWhenMatchFails) {
+  EXPECT_EQ("", Explain(DoubleNear(2.0, 0.1), 2.05));
+  EXPECT_EQ("which is 0.2 from 2", Explain(DoubleNear(2.0, 0.1), 2.2));
+  EXPECT_EQ("which is -0.3 from 2", Explain(DoubleNear(2.0, 0.1), 1.7));
+
+  const string explanation = Explain(DoubleNear(2.1, 1e-10), 2.1 + 1.2e-10);
+  // Different C++ implementations may print floating-point numbers
+  // slightly differently.
+  EXPECT_TRUE(explanation == "which is 1.2e-10 from 2.1" ||  // GCC
+              explanation == "which is 1.2e-010 from 2.1")   // MSVC
+      << " where explanation is \"" << explanation << "\".";
+}
+
+TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanDescribeSelf) {
+  Matcher<double> m1 = NanSensitiveDoubleNear(2.0, 0.5);
+  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
+  EXPECT_EQ(
+      "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
+
+  Matcher<double> m2 = NanSensitiveDoubleNear(0.5, 0.5);
+  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
+  EXPECT_EQ(
+      "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
+
+  Matcher<double> m3 = NanSensitiveDoubleNear(nan1_, 0.1);
+  EXPECT_EQ("is NaN", Describe(m3));
+  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
+}
+
+TEST_F(DoubleNearTest, DoubleNearCannotMatchNaN) {
+  // DoubleNear never matches NaN.
+  Matcher<double> m = DoubleNear(ParentType::nan1_, 0.1);
+  EXPECT_FALSE(m.Matches(nan1_));
+  EXPECT_FALSE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanMatchNaN) {
+  // NanSensitiveDoubleNear will match NaN.
+  Matcher<double> m = NanSensitiveDoubleNear(nan1_, 0.1);
+  EXPECT_TRUE(m.Matches(nan1_));
+  EXPECT_TRUE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST(PointeeTest, RawPointer) {
+  const Matcher<int*> m = Pointee(Ge(0));
+
+  int n = 1;
+  EXPECT_TRUE(m.Matches(&n));
+  n = -1;
+  EXPECT_FALSE(m.Matches(&n));
+  EXPECT_FALSE(m.Matches(NULL));
+}
+
+TEST(PointeeTest, RawPointerToConst) {
+  const Matcher<const double*> m = Pointee(Ge(0));
+
+  double x = 1;
+  EXPECT_TRUE(m.Matches(&x));
+  x = -1;
+  EXPECT_FALSE(m.Matches(&x));
+  EXPECT_FALSE(m.Matches(NULL));
+}
+
+TEST(PointeeTest, ReferenceToConstRawPointer) {
+  const Matcher<int* const &> m = Pointee(Ge(0));
+
+  int n = 1;
+  EXPECT_TRUE(m.Matches(&n));
+  n = -1;
+  EXPECT_FALSE(m.Matches(&n));
+  EXPECT_FALSE(m.Matches(NULL));
+}
+
+TEST(PointeeTest, ReferenceToNonConstRawPointer) {
+  const Matcher<double* &> m = Pointee(Ge(0));
+
+  double x = 1.0;
+  double* p = &x;
+  EXPECT_TRUE(m.Matches(p));
+  x = -1;
+  EXPECT_FALSE(m.Matches(p));
+  p = NULL;
+  EXPECT_FALSE(m.Matches(p));
+}
+
+MATCHER_P(FieldIIs, inner_matcher, "") {
+  return ExplainMatchResult(inner_matcher, arg.i, result_listener);
+}
+
+#if GTEST_HAS_RTTI
+
+TEST(WhenDynamicCastToTest, SameType) {
+  Derived derived;
+  derived.i = 4;
+
+  // Right type. A pointer is passed down.
+  Base* as_base_ptr = &derived;
+  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Not(IsNull())));
+  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(4))));
+  EXPECT_THAT(as_base_ptr,
+              Not(WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(5)))));
+}
+
+TEST(WhenDynamicCastToTest, WrongTypes) {
+  Base base;
+  Derived derived;
+  OtherDerived other_derived;
+
+  // Wrong types. NULL is passed.
+  EXPECT_THAT(&base, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
+  EXPECT_THAT(&base, WhenDynamicCastTo<Derived*>(IsNull()));
+  Base* as_base_ptr = &derived;
+  EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<OtherDerived*>(Pointee(_))));
+  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<OtherDerived*>(IsNull()));
+  as_base_ptr = &other_derived;
+  EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
+  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
+}
+
+TEST(WhenDynamicCastToTest, AlreadyNull) {
+  // Already NULL.
+  Base* as_base_ptr = NULL;
+  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
+}
+
+struct AmbiguousCastTypes {
+  class VirtualDerived : public virtual Base {};
+  class DerivedSub1 : public VirtualDerived {};
+  class DerivedSub2 : public VirtualDerived {};
+  class ManyDerivedInHierarchy : public DerivedSub1, public DerivedSub2 {};
+};
+
+TEST(WhenDynamicCastToTest, AmbiguousCast) {
+  AmbiguousCastTypes::DerivedSub1 sub1;
+  AmbiguousCastTypes::ManyDerivedInHierarchy many_derived;
+  // Multiply derived from Base. dynamic_cast<> returns NULL.
+  Base* as_base_ptr =
+      static_cast<AmbiguousCastTypes::DerivedSub1*>(&many_derived);
+  EXPECT_THAT(as_base_ptr,
+              WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(IsNull()));
+  as_base_ptr = &sub1;
+  EXPECT_THAT(
+      as_base_ptr,
+      WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(Not(IsNull())));
+}
+
+TEST(WhenDynamicCastToTest, Describe) {
+  Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
+  const string prefix =
+      "when dynamic_cast to " + internal::GetTypeName<Derived*>() + ", ";
+  EXPECT_EQ(prefix + "points to a value that is anything", Describe(matcher));
+  EXPECT_EQ(prefix + "does not point to a value that is anything",
+            DescribeNegation(matcher));
+}
+
+TEST(WhenDynamicCastToTest, Explain) {
+  Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
+  Base* null = NULL;
+  EXPECT_THAT(Explain(matcher, null), HasSubstr("NULL"));
+  Derived derived;
+  EXPECT_TRUE(matcher.Matches(&derived));
+  EXPECT_THAT(Explain(matcher, &derived), HasSubstr("which points to "));
+
+  // With references, the matcher itself can fail. Test for that one.
+  Matcher<const Base&> ref_matcher = WhenDynamicCastTo<const OtherDerived&>(_);
+  EXPECT_THAT(Explain(ref_matcher, derived),
+              HasSubstr("which cannot be dynamic_cast"));
+}
+
+TEST(WhenDynamicCastToTest, GoodReference) {
+  Derived derived;
+  derived.i = 4;
+  Base& as_base_ref = derived;
+  EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(FieldIIs(4)));
+  EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(Not(FieldIIs(5))));
+}
+
+TEST(WhenDynamicCastToTest, BadReference) {
+  Derived derived;
+  Base& as_base_ref = derived;
+  EXPECT_THAT(as_base_ref, Not(WhenDynamicCastTo<const OtherDerived&>(_)));
+}
+
+#endif  // GTEST_HAS_RTTI
+
+// Minimal const-propagating pointer.
+template <typename T>
+class ConstPropagatingPtr {
+ public:
+  typedef T element_type;
+
+  ConstPropagatingPtr() : val_() {}
+  explicit ConstPropagatingPtr(T* t) : val_(t) {}
+  ConstPropagatingPtr(const ConstPropagatingPtr& other) : val_(other.val_) {}
+
+  T* get() { return val_; }
+  T& operator*() { return *val_; }
+  // Most smart pointers return non-const T* and T& from the next methods.
+  const T* get() const { return val_; }
+  const T& operator*() const { return *val_; }
+
+ private:
+  T* val_;
+};
+
+TEST(PointeeTest, WorksWithConstPropagatingPointers) {
+  const Matcher< ConstPropagatingPtr<int> > m = Pointee(Lt(5));
+  int three = 3;
+  const ConstPropagatingPtr<int> co(&three);
+  ConstPropagatingPtr<int> o(&three);
+  EXPECT_TRUE(m.Matches(o));
+  EXPECT_TRUE(m.Matches(co));
+  *o = 6;
+  EXPECT_FALSE(m.Matches(o));
+  EXPECT_FALSE(m.Matches(ConstPropagatingPtr<int>()));
+}
+
+TEST(PointeeTest, NeverMatchesNull) {
+  const Matcher<const char*> m = Pointee(_);
+  EXPECT_FALSE(m.Matches(NULL));
+}
+
+// Tests that we can write Pointee(value) instead of Pointee(Eq(value)).
+TEST(PointeeTest, MatchesAgainstAValue) {
+  const Matcher<int*> m = Pointee(5);
+
+  int n = 5;
+  EXPECT_TRUE(m.Matches(&n));
+  n = -1;
+  EXPECT_FALSE(m.Matches(&n));
+  EXPECT_FALSE(m.Matches(NULL));
+}
+
+TEST(PointeeTest, CanDescribeSelf) {
+  const Matcher<int*> m = Pointee(Gt(3));
+  EXPECT_EQ("points to a value that is > 3", Describe(m));
+  EXPECT_EQ("does not point to a value that is > 3",
+            DescribeNegation(m));
+}
+
+TEST(PointeeTest, CanExplainMatchResult) {
+  const Matcher<const string*> m = Pointee(StartsWith("Hi"));
+
+  EXPECT_EQ("", Explain(m, static_cast<const string*>(NULL)));
+
+  const Matcher<long*> m2 = Pointee(GreaterThan(1));  // NOLINT
+  long n = 3;  // NOLINT
+  EXPECT_EQ("which points to 3" + OfType("long") + ", which is 2 more than 1",
+            Explain(m2, &n));
+}
+
+TEST(PointeeTest, AlwaysExplainsPointee) {
+  const Matcher<int*> m = Pointee(0);
+  int n = 42;
+  EXPECT_EQ("which points to 42" + OfType("int"), Explain(m, &n));
+}
+
+// An uncopyable class.
+class Uncopyable {
+ public:
+  Uncopyable() : value_(-1) {}
+  explicit Uncopyable(int a_value) : value_(a_value) {}
+
+  int value() const { return value_; }
+  void set_value(int i) { value_ = i; }
+
+ private:
+  int value_;
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Uncopyable);
+};
+
+// Returns true iff x.value() is positive.
+bool ValueIsPositive(const Uncopyable& x) { return x.value() > 0; }
+
+MATCHER_P(UncopyableIs, inner_matcher, "") {
+  return ExplainMatchResult(inner_matcher, arg.value(), result_listener);
+}
+
+// A user-defined struct for testing Field().
+struct AStruct {
+  AStruct() : x(0), y(1.0), z(5), p(NULL) {}
+  AStruct(const AStruct& rhs)
+      : x(rhs.x), y(rhs.y), z(rhs.z.value()), p(rhs.p) {}
+
+  int x;           // A non-const field.
+  const double y;  // A const field.
+  Uncopyable z;    // An uncopyable field.
+  const char* p;   // A pointer field.
+
+ private:
+  GTEST_DISALLOW_ASSIGN_(AStruct);
+};
+
+// A derived struct for testing Field().
+struct DerivedStruct : public AStruct {
+  char ch;
+
+ private:
+  GTEST_DISALLOW_ASSIGN_(DerivedStruct);
+};
+
+// Tests that Field(&Foo::field, ...) works when field is non-const.
+TEST(FieldTest, WorksForNonConstField) {
+  Matcher<AStruct> m = Field(&AStruct::x, Ge(0));
+
+  AStruct a;
+  EXPECT_TRUE(m.Matches(a));
+  a.x = -1;
+  EXPECT_FALSE(m.Matches(a));
+}
+
+// Tests that Field(&Foo::field, ...) works when field is const.
+TEST(FieldTest, WorksForConstField) {
+  AStruct a;
+
+  Matcher<AStruct> m = Field(&AStruct::y, Ge(0.0));
+  EXPECT_TRUE(m.Matches(a));
+  m = Field(&AStruct::y, Le(0.0));
+  EXPECT_FALSE(m.Matches(a));
+}
+
+// Tests that Field(&Foo::field, ...) works when field is not copyable.
+TEST(FieldTest, WorksForUncopyableField) {
+  AStruct a;
+
+  Matcher<AStruct> m = Field(&AStruct::z, Truly(ValueIsPositive));
+  EXPECT_TRUE(m.Matches(a));
+  m = Field(&AStruct::z, Not(Truly(ValueIsPositive)));
+  EXPECT_FALSE(m.Matches(a));
+}
+
+// Tests that Field(&Foo::field, ...) works when field is a pointer.
+TEST(FieldTest, WorksForPointerField) {
+  // Matching against NULL.
+  Matcher<AStruct> m = Field(&AStruct::p, static_cast<const char*>(NULL));
+  AStruct a;
+  EXPECT_TRUE(m.Matches(a));
+  a.p = "hi";
+  EXPECT_FALSE(m.Matches(a));
+
+  // Matching a pointer that is not NULL.
+  m = Field(&AStruct::p, StartsWith("hi"));
+  a.p = "hill";
+  EXPECT_TRUE(m.Matches(a));
+  a.p = "hole";
+  EXPECT_FALSE(m.Matches(a));
+}
+
+// Tests that Field() works when the object is passed by reference.
+TEST(FieldTest, WorksForByRefArgument) {
+  Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
+
+  AStruct a;
+  EXPECT_TRUE(m.Matches(a));
+  a.x = -1;
+  EXPECT_FALSE(m.Matches(a));
+}
+
+// Tests that Field(&Foo::field, ...) works when the argument's type
+// is a sub-type of Foo.
+TEST(FieldTest, WorksForArgumentOfSubType) {
+  // Note that the matcher expects DerivedStruct but we say AStruct
+  // inside Field().
+  Matcher<const DerivedStruct&> m = Field(&AStruct::x, Ge(0));
+
+  DerivedStruct d;
+  EXPECT_TRUE(m.Matches(d));
+  d.x = -1;
+  EXPECT_FALSE(m.Matches(d));
+}
+
+// Tests that Field(&Foo::field, m) works when field's type and m's
+// argument type are compatible but not the same.
+TEST(FieldTest, WorksForCompatibleMatcherType) {
+  // The field is an int, but the inner matcher expects a signed char.
+  Matcher<const AStruct&> m = Field(&AStruct::x,
+                                    Matcher<signed char>(Ge(0)));
+
+  AStruct a;
+  EXPECT_TRUE(m.Matches(a));
+  a.x = -1;
+  EXPECT_FALSE(m.Matches(a));
+}
+
+// Tests that Field() can describe itself.
+TEST(FieldTest, CanDescribeSelf) {
+  Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
+
+  EXPECT_EQ("is an object whose given field is >= 0", Describe(m));
+  EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m));
+}
+
+// Tests that Field() can explain the match result.
+TEST(FieldTest, CanExplainMatchResult) {
+  Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
+
+  AStruct a;
+  a.x = 1;
+  EXPECT_EQ("whose given field is 1" + OfType("int"), Explain(m, a));
+
+  m = Field(&AStruct::x, GreaterThan(0));
+  EXPECT_EQ(
+      "whose given field is 1" + OfType("int") + ", which is 1 more than 0",
+      Explain(m, a));
+}
+
+// Tests that Field() works when the argument is a pointer to const.
+TEST(FieldForPointerTest, WorksForPointerToConst) {
+  Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
+
+  AStruct a;
+  EXPECT_TRUE(m.Matches(&a));
+  a.x = -1;
+  EXPECT_FALSE(m.Matches(&a));
+}
+
+// Tests that Field() works when the argument is a pointer to non-const.
+TEST(FieldForPointerTest, WorksForPointerToNonConst) {
+  Matcher<AStruct*> m = Field(&AStruct::x, Ge(0));
+
+  AStruct a;
+  EXPECT_TRUE(m.Matches(&a));
+  a.x = -1;
+  EXPECT_FALSE(m.Matches(&a));
+}
+
+// Tests that Field() works when the argument is a reference to a const pointer.
+TEST(FieldForPointerTest, WorksForReferenceToConstPointer) {
+  Matcher<AStruct* const&> m = Field(&AStruct::x, Ge(0));
+
+  AStruct a;
+  EXPECT_TRUE(m.Matches(&a));
+  a.x = -1;
+  EXPECT_FALSE(m.Matches(&a));
+}
+
+// Tests that Field() does not match the NULL pointer.
+TEST(FieldForPointerTest, DoesNotMatchNull) {
+  Matcher<const AStruct*> m = Field(&AStruct::x, _);
+  EXPECT_FALSE(m.Matches(NULL));
+}
+
+// Tests that Field(&Foo::field, ...) works when the argument's type
+// is a sub-type of const Foo*.
+TEST(FieldForPointerTest, WorksForArgumentOfSubType) {
+  // Note that the matcher expects DerivedStruct but we say AStruct
+  // inside Field().
+  Matcher<DerivedStruct*> m = Field(&AStruct::x, Ge(0));
+
+  DerivedStruct d;
+  EXPECT_TRUE(m.Matches(&d));
+  d.x = -1;
+  EXPECT_FALSE(m.Matches(&d));
+}
+
+// Tests that Field() can describe itself when used to match a pointer.
+TEST(FieldForPointerTest, CanDescribeSelf) {
+  Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
+
+  EXPECT_EQ("is an object whose given field is >= 0", Describe(m));
+  EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m));
+}
+
+// Tests that Field() can explain the result of matching a pointer.
+TEST(FieldForPointerTest, CanExplainMatchResult) {
+  Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
+
+  AStruct a;
+  a.x = 1;
+  EXPECT_EQ("", Explain(m, static_cast<const AStruct*>(NULL)));
+  EXPECT_EQ("which points to an object whose given field is 1" + OfType("int"),
+            Explain(m, &a));
+
+  m = Field(&AStruct::x, GreaterThan(0));
+  EXPECT_EQ("which points to an object whose given field is 1" + OfType("int") +
+            ", which is 1 more than 0", Explain(m, &a));
+}
+
+// A user-defined class for testing Property().
+class AClass {
+ public:
+  AClass() : n_(0) {}
+
+  // A getter that returns a non-reference.
+  int n() const { return n_; }
+
+  void set_n(int new_n) { n_ = new_n; }
+
+  // A getter that returns a reference to const.
+  const string& s() const { return s_; }
+
+  void set_s(const string& new_s) { s_ = new_s; }
+
+  // A getter that returns a reference to non-const.
+  double& x() const { return x_; }
+ private:
+  int n_;
+  string s_;
+
+  static double x_;
+};
+
+double AClass::x_ = 0.0;
+
+// A derived class for testing Property().
+class DerivedClass : public AClass {
+ public:
+  int k() const { return k_; }
+ private:
+  int k_;
+};
+
+// Tests that Property(&Foo::property, ...) works when property()
+// returns a non-reference.
+TEST(PropertyTest, WorksForNonReferenceProperty) {
+  Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
+
+  AClass a;
+  a.set_n(1);
+  EXPECT_TRUE(m.Matches(a));
+
+  a.set_n(-1);
+  EXPECT_FALSE(m.Matches(a));
+}
+
+// Tests that Property(&Foo::property, ...) works when property()
+// returns a reference to const.
+TEST(PropertyTest, WorksForReferenceToConstProperty) {
+  Matcher<const AClass&> m = Property(&AClass::s, StartsWith("hi"));
+
+  AClass a;
+  a.set_s("hill");
+  EXPECT_TRUE(m.Matches(a));
+
+  a.set_s("hole");
+  EXPECT_FALSE(m.Matches(a));
+}
+
+// Tests that Property(&Foo::property, ...) works when property()
+// returns a reference to non-const.
+TEST(PropertyTest, WorksForReferenceToNonConstProperty) {
+  double x = 0.0;
+  AClass a;
+
+  Matcher<const AClass&> m = Property(&AClass::x, Ref(x));
+  EXPECT_FALSE(m.Matches(a));
+
+  m = Property(&AClass::x, Not(Ref(x)));
+  EXPECT_TRUE(m.Matches(a));
+}
+
+// Tests that Property(&Foo::property, ...) works when the argument is
+// passed by value.
+TEST(PropertyTest, WorksForByValueArgument) {
+  Matcher<AClass> m = Property(&AClass::s, StartsWith("hi"));
+
+  AClass a;
+  a.set_s("hill");
+  EXPECT_TRUE(m.Matches(a));
+
+  a.set_s("hole");
+  EXPECT_FALSE(m.Matches(a));
+}
+
+// Tests that Property(&Foo::property, ...) works when the argument's
+// type is a sub-type of Foo.
+TEST(PropertyTest, WorksForArgumentOfSubType) {
+  // The matcher expects a DerivedClass, but inside the Property() we
+  // say AClass.
+  Matcher<const DerivedClass&> m = Property(&AClass::n, Ge(0));
+
+  DerivedClass d;
+  d.set_n(1);
+  EXPECT_TRUE(m.Matches(d));
+
+  d.set_n(-1);
+  EXPECT_FALSE(m.Matches(d));
+}
+
+// Tests that Property(&Foo::property, m) works when property()'s type
+// and m's argument type are compatible but different.
+TEST(PropertyTest, WorksForCompatibleMatcherType) {
+  // n() returns an int but the inner matcher expects a signed char.
+  Matcher<const AClass&> m = Property(&AClass::n,
+                                      Matcher<signed char>(Ge(0)));
+
+  AClass a;
+  EXPECT_TRUE(m.Matches(a));
+  a.set_n(-1);
+  EXPECT_FALSE(m.Matches(a));
+}
+
+// Tests that Property() can describe itself.
+TEST(PropertyTest, CanDescribeSelf) {
+  Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
+
+  EXPECT_EQ("is an object whose given property is >= 0", Describe(m));
+  EXPECT_EQ("is an object whose given property isn't >= 0",
+            DescribeNegation(m));
+}
+
+// Tests that Property() can explain the match result.
+TEST(PropertyTest, CanExplainMatchResult) {
+  Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
+
+  AClass a;
+  a.set_n(1);
+  EXPECT_EQ("whose given property is 1" + OfType("int"), Explain(m, a));
+
+  m = Property(&AClass::n, GreaterThan(0));
+  EXPECT_EQ(
+      "whose given property is 1" + OfType("int") + ", which is 1 more than 0",
+      Explain(m, a));
+}
+
+// Tests that Property() works when the argument is a pointer to const.
+TEST(PropertyForPointerTest, WorksForPointerToConst) {
+  Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
+
+  AClass a;
+  a.set_n(1);
+  EXPECT_TRUE(m.Matches(&a));
+
+  a.set_n(-1);
+  EXPECT_FALSE(m.Matches(&a));
+}
+
+// Tests that Property() works when the argument is a pointer to non-const.
+TEST(PropertyForPointerTest, WorksForPointerToNonConst) {
+  Matcher<AClass*> m = Property(&AClass::s, StartsWith("hi"));
+
+  AClass a;
+  a.set_s("hill");
+  EXPECT_TRUE(m.Matches(&a));
+
+  a.set_s("hole");
+  EXPECT_FALSE(m.Matches(&a));
+}
+
+// Tests that Property() works when the argument is a reference to a
+// const pointer.
+TEST(PropertyForPointerTest, WorksForReferenceToConstPointer) {
+  Matcher<AClass* const&> m = Property(&AClass::s, StartsWith("hi"));
+
+  AClass a;
+  a.set_s("hill");
+  EXPECT_TRUE(m.Matches(&a));
+
+  a.set_s("hole");
+  EXPECT_FALSE(m.Matches(&a));
+}
+
+// Tests that Property() does not match the NULL pointer.
+TEST(PropertyForPointerTest, WorksForReferenceToNonConstProperty) {
+  Matcher<const AClass*> m = Property(&AClass::x, _);
+  EXPECT_FALSE(m.Matches(NULL));
+}
+
+// Tests that Property(&Foo::property, ...) works when the argument's
+// type is a sub-type of const Foo*.
+TEST(PropertyForPointerTest, WorksForArgumentOfSubType) {
+  // The matcher expects a DerivedClass, but inside the Property() we
+  // say AClass.
+  Matcher<const DerivedClass*> m = Property(&AClass::n, Ge(0));
+
+  DerivedClass d;
+  d.set_n(1);
+  EXPECT_TRUE(m.Matches(&d));
+
+  d.set_n(-1);
+  EXPECT_FALSE(m.Matches(&d));
+}
+
+// Tests that Property() can describe itself when used to match a pointer.
+TEST(PropertyForPointerTest, CanDescribeSelf) {
+  Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
+
+  EXPECT_EQ("is an object whose given property is >= 0", Describe(m));
+  EXPECT_EQ("is an object whose given property isn't >= 0",
+            DescribeNegation(m));
+}
+
+// Tests that Property() can explain the result of matching a pointer.
+TEST(PropertyForPointerTest, CanExplainMatchResult) {
+  Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
+
+  AClass a;
+  a.set_n(1);
+  EXPECT_EQ("", Explain(m, static_cast<const AClass*>(NULL)));
+  EXPECT_EQ(
+      "which points to an object whose given property is 1" + OfType("int"),
+      Explain(m, &a));
+
+  m = Property(&AClass::n, GreaterThan(0));
+  EXPECT_EQ("which points to an object whose given property is 1" +
+            OfType("int") + ", which is 1 more than 0",
+            Explain(m, &a));
+}
+
+// Tests ResultOf.
+
+// Tests that ResultOf(f, ...) compiles and works as expected when f is a
+// function pointer.
+string IntToStringFunction(int input) { return input == 1 ? "foo" : "bar"; }
+
+TEST(ResultOfTest, WorksForFunctionPointers) {
+  Matcher<int> matcher = ResultOf(&IntToStringFunction, Eq(string("foo")));
+
+  EXPECT_TRUE(matcher.Matches(1));
+  EXPECT_FALSE(matcher.Matches(2));
+}
+
+// Tests that ResultOf() can describe itself.
+TEST(ResultOfTest, CanDescribeItself) {
+  Matcher<int> matcher = ResultOf(&IntToStringFunction, StrEq("foo"));
+
+  EXPECT_EQ("is mapped by the given callable to a value that "
+            "is equal to \"foo\"", Describe(matcher));
+  EXPECT_EQ("is mapped by the given callable to a value that "
+            "isn't equal to \"foo\"", DescribeNegation(matcher));
+}
+
+// Tests that ResultOf() can explain the match result.
+int IntFunction(int input) { return input == 42 ? 80 : 90; }
+
+TEST(ResultOfTest, CanExplainMatchResult) {
+  Matcher<int> matcher = ResultOf(&IntFunction, Ge(85));
+  EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int"),
+            Explain(matcher, 36));
+
+  matcher = ResultOf(&IntFunction, GreaterThan(85));
+  EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int") +
+            ", which is 5 more than 85", Explain(matcher, 36));
+}
+
+// Tests that ResultOf(f, ...) compiles and works as expected when f(x)
+// returns a non-reference.
+TEST(ResultOfTest, WorksForNonReferenceResults) {
+  Matcher<int> matcher = ResultOf(&IntFunction, Eq(80));
+
+  EXPECT_TRUE(matcher.Matches(42));
+  EXPECT_FALSE(matcher.Matches(36));
+}
+
+// Tests that ResultOf(f, ...) compiles and works as expected when f(x)
+// returns a reference to non-const.
+double& DoubleFunction(double& input) { return input; }  // NOLINT
+
+Uncopyable& RefUncopyableFunction(Uncopyable& obj) {  // NOLINT
+  return obj;
+}
+
+TEST(ResultOfTest, WorksForReferenceToNonConstResults) {
+  double x = 3.14;
+  double x2 = x;
+  Matcher<double&> matcher = ResultOf(&DoubleFunction, Ref(x));
+
+  EXPECT_TRUE(matcher.Matches(x));
+  EXPECT_FALSE(matcher.Matches(x2));
+
+  // Test that ResultOf works with uncopyable objects
+  Uncopyable obj(0);
+  Uncopyable obj2(0);
+  Matcher<Uncopyable&> matcher2 =
+      ResultOf(&RefUncopyableFunction, Ref(obj));
+
+  EXPECT_TRUE(matcher2.Matches(obj));
+  EXPECT_FALSE(matcher2.Matches(obj2));
+}
+
+// Tests that ResultOf(f, ...) compiles and works as expected when f(x)
+// returns a reference to const.
+const string& StringFunction(const string& input) { return input; }
+
+TEST(ResultOfTest, WorksForReferenceToConstResults) {
+  string s = "foo";
+  string s2 = s;
+  Matcher<const string&> matcher = ResultOf(&StringFunction, Ref(s));
+
+  EXPECT_TRUE(matcher.Matches(s));
+  EXPECT_FALSE(matcher.Matches(s2));
+}
+
+// Tests that ResultOf(f, m) works when f(x) and m's
+// argument types are compatible but different.
+TEST(ResultOfTest, WorksForCompatibleMatcherTypes) {
+  // IntFunction() returns int but the inner matcher expects a signed char.
+  Matcher<int> matcher = ResultOf(IntFunction, Matcher<signed char>(Ge(85)));
+
+  EXPECT_TRUE(matcher.Matches(36));
+  EXPECT_FALSE(matcher.Matches(42));
+}
+
+// Tests that the program aborts when ResultOf is passed
+// a NULL function pointer.
+TEST(ResultOfDeathTest, DiesOnNullFunctionPointers) {
+  EXPECT_DEATH_IF_SUPPORTED(
+      ResultOf(static_cast<string(*)(int dummy)>(NULL), Eq(string("foo"))),
+               "NULL function pointer is passed into ResultOf\\(\\)\\.");
+}
+
+// Tests that ResultOf(f, ...) compiles and works as expected when f is a
+// function reference.
+TEST(ResultOfTest, WorksForFunctionReferences) {
+  Matcher<int> matcher = ResultOf(IntToStringFunction, StrEq("foo"));
+  EXPECT_TRUE(matcher.Matches(1));
+  EXPECT_FALSE(matcher.Matches(2));
+}
+
+// Tests that ResultOf(f, ...) compiles and works as expected when f is a
+// function object.
+struct Functor : public ::std::unary_function<int, string> {
+  result_type operator()(argument_type input) const {
+    return IntToStringFunction(input);
+  }
+};
+
+TEST(ResultOfTest, WorksForFunctors) {
+  Matcher<int> matcher = ResultOf(Functor(), Eq(string("foo")));
+
+  EXPECT_TRUE(matcher.Matches(1));
+  EXPECT_FALSE(matcher.Matches(2));
+}
+
+// Tests that ResultOf(f, ...) compiles and works as expected when f is a
+// functor with more then one operator() defined. ResultOf() must work
+// for each defined operator().
+struct PolymorphicFunctor {
+  typedef int result_type;
+  int operator()(int n) { return n; }
+  int operator()(const char* s) { return static_cast<int>(strlen(s)); }
+};
+
+TEST(ResultOfTest, WorksForPolymorphicFunctors) {
+  Matcher<int> matcher_int = ResultOf(PolymorphicFunctor(), Ge(5));
+
+  EXPECT_TRUE(matcher_int.Matches(10));
+  EXPECT_FALSE(matcher_int.Matches(2));
+
+  Matcher<const char*> matcher_string = ResultOf(PolymorphicFunctor(), Ge(5));
+
+  EXPECT_TRUE(matcher_string.Matches("long string"));
+  EXPECT_FALSE(matcher_string.Matches("shrt"));
+}
+
+const int* ReferencingFunction(const int& n) { return &n; }
+
+struct ReferencingFunctor {
+  typedef const int* result_type;
+  result_type operator()(const int& n) { return &n; }
+};
+
+TEST(ResultOfTest, WorksForReferencingCallables) {
+  const int n = 1;
+  const int n2 = 1;
+  Matcher<const int&> matcher2 = ResultOf(ReferencingFunction, Eq(&n));
+  EXPECT_TRUE(matcher2.Matches(n));
+  EXPECT_FALSE(matcher2.Matches(n2));
+
+  Matcher<const int&> matcher3 = ResultOf(ReferencingFunctor(), Eq(&n));
+  EXPECT_TRUE(matcher3.Matches(n));
+  EXPECT_FALSE(matcher3.Matches(n2));
+}
+
+class DivisibleByImpl {
+ public:
+  explicit DivisibleByImpl(int a_divider) : divider_(a_divider) {}
+
+  // For testing using ExplainMatchResultTo() with polymorphic matchers.
+  template <typename T>
+  bool MatchAndExplain(const T& n, MatchResultListener* listener) const {
+    *listener << "which is " << (n % divider_) << " modulo "
+              << divider_;
+    return (n % divider_) == 0;
+  }
+
+  void DescribeTo(ostream* os) const {
+    *os << "is divisible by " << divider_;
+  }
+
+  void DescribeNegationTo(ostream* os) const {
+    *os << "is not divisible by " << divider_;
+  }
+
+  void set_divider(int a_divider) { divider_ = a_divider; }
+  int divider() const { return divider_; }
+
+ private:
+  int divider_;
+};
+
+PolymorphicMatcher<DivisibleByImpl> DivisibleBy(int n) {
+  return MakePolymorphicMatcher(DivisibleByImpl(n));
+}
+
+// Tests that when AllOf() fails, only the first failing matcher is
+// asked to explain why.
+TEST(ExplainMatchResultTest, AllOf_False_False) {
+  const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
+  EXPECT_EQ("which is 1 modulo 4", Explain(m, 5));
+}
+
+// Tests that when AllOf() fails, only the first failing matcher is
+// asked to explain why.
+TEST(ExplainMatchResultTest, AllOf_False_True) {
+  const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
+  EXPECT_EQ("which is 2 modulo 4", Explain(m, 6));
+}
+
+// Tests that when AllOf() fails, only the first failing matcher is
+// asked to explain why.
+TEST(ExplainMatchResultTest, AllOf_True_False) {
+  const Matcher<int> m = AllOf(Ge(1), DivisibleBy(3));
+  EXPECT_EQ("which is 2 modulo 3", Explain(m, 5));
+}
+
+// Tests that when AllOf() succeeds, all matchers are asked to explain
+// why.
+TEST(ExplainMatchResultTest, AllOf_True_True) {
+  const Matcher<int> m = AllOf(DivisibleBy(2), DivisibleBy(3));
+  EXPECT_EQ("which is 0 modulo 2, and which is 0 modulo 3", Explain(m, 6));
+}
+
+TEST(ExplainMatchResultTest, AllOf_True_True_2) {
+  const Matcher<int> m = AllOf(Ge(2), Le(3));
+  EXPECT_EQ("", Explain(m, 2));
+}
+
+TEST(ExplainmatcherResultTest, MonomorphicMatcher) {
+  const Matcher<int> m = GreaterThan(5);
+  EXPECT_EQ("which is 1 more than 5", Explain(m, 6));
+}
+
+// The following two tests verify that values without a public copy
+// ctor can be used as arguments to matchers like Eq(), Ge(), and etc
+// with the help of ByRef().
+
+class NotCopyable {
+ public:
+  explicit NotCopyable(int a_value) : value_(a_value) {}
+
+  int value() const { return value_; }
+
+  bool operator==(const NotCopyable& rhs) const {
+    return value() == rhs.value();
+  }
+
+  bool operator>=(const NotCopyable& rhs) const {
+    return value() >= rhs.value();
+  }
+ private:
+  int value_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NotCopyable);
+};
+
+TEST(ByRefTest, AllowsNotCopyableConstValueInMatchers) {
+  const NotCopyable const_value1(1);
+  const Matcher<const NotCopyable&> m = Eq(ByRef(const_value1));
+
+  const NotCopyable n1(1), n2(2);
+  EXPECT_TRUE(m.Matches(n1));
+  EXPECT_FALSE(m.Matches(n2));
+}
+
+TEST(ByRefTest, AllowsNotCopyableValueInMatchers) {
+  NotCopyable value2(2);
+  const Matcher<NotCopyable&> m = Ge(ByRef(value2));
+
+  NotCopyable n1(1), n2(2);
+  EXPECT_FALSE(m.Matches(n1));
+  EXPECT_TRUE(m.Matches(n2));
+}
+
+TEST(IsEmptyTest, ImplementsIsEmpty) {
+  vector<int> container;
+  EXPECT_THAT(container, IsEmpty());
+  container.push_back(0);
+  EXPECT_THAT(container, Not(IsEmpty()));
+  container.push_back(1);
+  EXPECT_THAT(container, Not(IsEmpty()));
+}
+
+TEST(IsEmptyTest, WorksWithString) {
+  string text;
+  EXPECT_THAT(text, IsEmpty());
+  text = "foo";
+  EXPECT_THAT(text, Not(IsEmpty()));
+  text = string("\0", 1);
+  EXPECT_THAT(text, Not(IsEmpty()));
+}
+
+TEST(IsEmptyTest, CanDescribeSelf) {
+  Matcher<vector<int> > m = IsEmpty();
+  EXPECT_EQ("is empty", Describe(m));
+  EXPECT_EQ("isn't empty", DescribeNegation(m));
+}
+
+TEST(IsEmptyTest, ExplainsResult) {
+  Matcher<vector<int> > m = IsEmpty();
+  vector<int> container;
+  EXPECT_EQ("", Explain(m, container));
+  container.push_back(0);
+  EXPECT_EQ("whose size is 1", Explain(m, container));
+}
+
+TEST(SizeIsTest, ImplementsSizeIs) {
+  vector<int> container;
+  EXPECT_THAT(container, SizeIs(0));
+  EXPECT_THAT(container, Not(SizeIs(1)));
+  container.push_back(0);
+  EXPECT_THAT(container, Not(SizeIs(0)));
+  EXPECT_THAT(container, SizeIs(1));
+  container.push_back(0);
+  EXPECT_THAT(container, Not(SizeIs(0)));
+  EXPECT_THAT(container, SizeIs(2));
+}
+
+TEST(SizeIsTest, WorksWithMap) {
+  map<string, int> container;
+  EXPECT_THAT(container, SizeIs(0));
+  EXPECT_THAT(container, Not(SizeIs(1)));
+  container.insert(make_pair("foo", 1));
+  EXPECT_THAT(container, Not(SizeIs(0)));
+  EXPECT_THAT(container, SizeIs(1));
+  container.insert(make_pair("bar", 2));
+  EXPECT_THAT(container, Not(SizeIs(0)));
+  EXPECT_THAT(container, SizeIs(2));
+}
+
+TEST(SizeIsTest, WorksWithReferences) {
+  vector<int> container;
+  Matcher<const vector<int>&> m = SizeIs(1);
+  EXPECT_THAT(container, Not(m));
+  container.push_back(0);
+  EXPECT_THAT(container, m);
+}
+
+TEST(SizeIsTest, CanDescribeSelf) {
+  Matcher<vector<int> > m = SizeIs(2);
+  EXPECT_EQ("size is equal to 2", Describe(m));
+  EXPECT_EQ("size isn't equal to 2", DescribeNegation(m));
+}
+
+TEST(SizeIsTest, ExplainsResult) {
+  Matcher<vector<int> > m1 = SizeIs(2);
+  Matcher<vector<int> > m2 = SizeIs(Lt(2u));
+  Matcher<vector<int> > m3 = SizeIs(AnyOf(0, 3));
+  Matcher<vector<int> > m4 = SizeIs(GreaterThan(1));
+  vector<int> container;
+  EXPECT_EQ("whose size 0 doesn't match", Explain(m1, container));
+  EXPECT_EQ("whose size 0 matches", Explain(m2, container));
+  EXPECT_EQ("whose size 0 matches", Explain(m3, container));
+  EXPECT_EQ("whose size 0 doesn't match, which is 1 less than 1",
+            Explain(m4, container));
+  container.push_back(0);
+  container.push_back(0);
+  EXPECT_EQ("whose size 2 matches", Explain(m1, container));
+  EXPECT_EQ("whose size 2 doesn't match", Explain(m2, container));
+  EXPECT_EQ("whose size 2 doesn't match", Explain(m3, container));
+  EXPECT_EQ("whose size 2 matches, which is 1 more than 1",
+            Explain(m4, container));
+}
+
+#if GTEST_HAS_TYPED_TEST
+// Tests ContainerEq with different container types, and
+// different element types.
+
+template <typename T>
+class ContainerEqTest : public testing::Test {};
+
+typedef testing::Types<
+    set<int>,
+    vector<size_t>,
+    multiset<size_t>,
+    list<int> >
+    ContainerEqTestTypes;
+
+TYPED_TEST_CASE(ContainerEqTest, ContainerEqTestTypes);
+
+// Tests that the filled container is equal to itself.
+TYPED_TEST(ContainerEqTest, EqualsSelf) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  TypeParam my_set(vals, vals + 6);
+  const Matcher<TypeParam> m = ContainerEq(my_set);
+  EXPECT_TRUE(m.Matches(my_set));
+  EXPECT_EQ("", Explain(m, my_set));
+}
+
+// Tests that missing values are reported.
+TYPED_TEST(ContainerEqTest, ValueMissing) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {2, 1, 8, 5};
+  TypeParam my_set(vals, vals + 6);
+  TypeParam test_set(test_vals, test_vals + 4);
+  const Matcher<TypeParam> m = ContainerEq(my_set);
+  EXPECT_FALSE(m.Matches(test_set));
+  EXPECT_EQ("which doesn't have these expected elements: 3",
+            Explain(m, test_set));
+}
+
+// Tests that added values are reported.
+TYPED_TEST(ContainerEqTest, ValueAdded) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {1, 2, 3, 5, 8, 46};
+  TypeParam my_set(vals, vals + 6);
+  TypeParam test_set(test_vals, test_vals + 6);
+  const Matcher<const TypeParam&> m = ContainerEq(my_set);
+  EXPECT_FALSE(m.Matches(test_set));
+  EXPECT_EQ("which has these unexpected elements: 46", Explain(m, test_set));
+}
+
+// Tests that added and missing values are reported together.
+TYPED_TEST(ContainerEqTest, ValueAddedAndRemoved) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {1, 2, 3, 8, 46};
+  TypeParam my_set(vals, vals + 6);
+  TypeParam test_set(test_vals, test_vals + 5);
+  const Matcher<TypeParam> m = ContainerEq(my_set);
+  EXPECT_FALSE(m.Matches(test_set));
+  EXPECT_EQ("which has these unexpected elements: 46,\n"
+            "and doesn't have these expected elements: 5",
+            Explain(m, test_set));
+}
+
+// Tests duplicated value -- expect no explanation.
+TYPED_TEST(ContainerEqTest, DuplicateDifference) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {1, 2, 3, 5, 8};
+  TypeParam my_set(vals, vals + 6);
+  TypeParam test_set(test_vals, test_vals + 5);
+  const Matcher<const TypeParam&> m = ContainerEq(my_set);
+  // Depending on the container, match may be true or false
+  // But in any case there should be no explanation.
+  EXPECT_EQ("", Explain(m, test_set));
+}
+#endif  // GTEST_HAS_TYPED_TEST
+
+// Tests that mutliple missing values are reported.
+// Using just vector here, so order is predicatble.
+TEST(ContainerEqExtraTest, MultipleValuesMissing) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {2, 1, 5};
+  vector<int> my_set(vals, vals + 6);
+  vector<int> test_set(test_vals, test_vals + 3);
+  const Matcher<vector<int> > m = ContainerEq(my_set);
+  EXPECT_FALSE(m.Matches(test_set));
+  EXPECT_EQ("which doesn't have these expected elements: 3, 8",
+            Explain(m, test_set));
+}
+
+// Tests that added values are reported.
+// Using just vector here, so order is predicatble.
+TEST(ContainerEqExtraTest, MultipleValuesAdded) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {1, 2, 92, 3, 5, 8, 46};
+  list<size_t> my_set(vals, vals + 6);
+  list<size_t> test_set(test_vals, test_vals + 7);
+  const Matcher<const list<size_t>&> m = ContainerEq(my_set);
+  EXPECT_FALSE(m.Matches(test_set));
+  EXPECT_EQ("which has these unexpected elements: 92, 46",
+            Explain(m, test_set));
+}
+
+// Tests that added and missing values are reported together.
+TEST(ContainerEqExtraTest, MultipleValuesAddedAndRemoved) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {1, 2, 3, 92, 46};
+  list<size_t> my_set(vals, vals + 6);
+  list<size_t> test_set(test_vals, test_vals + 5);
+  const Matcher<const list<size_t> > m = ContainerEq(my_set);
+  EXPECT_FALSE(m.Matches(test_set));
+  EXPECT_EQ("which has these unexpected elements: 92, 46,\n"
+            "and doesn't have these expected elements: 5, 8",
+            Explain(m, test_set));
+}
+
+// Tests to see that duplicate elements are detected,
+// but (as above) not reported in the explanation.
+TEST(ContainerEqExtraTest, MultiSetOfIntDuplicateDifference) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {1, 2, 3, 5, 8};
+  vector<int> my_set(vals, vals + 6);
+  vector<int> test_set(test_vals, test_vals + 5);
+  const Matcher<vector<int> > m = ContainerEq(my_set);
+  EXPECT_TRUE(m.Matches(my_set));
+  EXPECT_FALSE(m.Matches(test_set));
+  // There is nothing to report when both sets contain all the same values.
+  EXPECT_EQ("", Explain(m, test_set));
+}
+
+// Tests that ContainerEq works for non-trivial associative containers,
+// like maps.
+TEST(ContainerEqExtraTest, WorksForMaps) {
+  map<int, std::string> my_map;
+  my_map[0] = "a";
+  my_map[1] = "b";
+
+  map<int, std::string> test_map;
+  test_map[0] = "aa";
+  test_map[1] = "b";
+
+  const Matcher<const map<int, std::string>&> m = ContainerEq(my_map);
+  EXPECT_TRUE(m.Matches(my_map));
+  EXPECT_FALSE(m.Matches(test_map));
+
+  EXPECT_EQ("which has these unexpected elements: (0, \"aa\"),\n"
+            "and doesn't have these expected elements: (0, \"a\")",
+            Explain(m, test_map));
+}
+
+TEST(ContainerEqExtraTest, WorksForNativeArray) {
+  int a1[] = {1, 2, 3};
+  int a2[] = {1, 2, 3};
+  int b[] = {1, 2, 4};
+
+  EXPECT_THAT(a1, ContainerEq(a2));
+  EXPECT_THAT(a1, Not(ContainerEq(b)));
+}
+
+TEST(ContainerEqExtraTest, WorksForTwoDimensionalNativeArray) {
+  const char a1[][3] = {"hi", "lo"};
+  const char a2[][3] = {"hi", "lo"};
+  const char b[][3] = {"lo", "hi"};
+
+  // Tests using ContainerEq() in the first dimension.
+  EXPECT_THAT(a1, ContainerEq(a2));
+  EXPECT_THAT(a1, Not(ContainerEq(b)));
+
+  // Tests using ContainerEq() in the second dimension.
+  EXPECT_THAT(a1, ElementsAre(ContainerEq(a2[0]), ContainerEq(a2[1])));
+  EXPECT_THAT(a1, ElementsAre(Not(ContainerEq(b[0])), ContainerEq(a2[1])));
+}
+
+TEST(ContainerEqExtraTest, WorksForNativeArrayAsTuple) {
+  const int a1[] = {1, 2, 3};
+  const int a2[] = {1, 2, 3};
+  const int b[] = {1, 2, 3, 4};
+
+  const int* const p1 = a1;
+  EXPECT_THAT(make_tuple(p1, 3), ContainerEq(a2));
+  EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(b)));
+
+  const int c[] = {1, 3, 2};
+  EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(c)));
+}
+
+TEST(ContainerEqExtraTest, CopiesNativeArrayParameter) {
+  std::string a1[][3] = {
+    {"hi", "hello", "ciao"},
+    {"bye", "see you", "ciao"}
+  };
+
+  std::string a2[][3] = {
+    {"hi", "hello", "ciao"},
+    {"bye", "see you", "ciao"}
+  };
+
+  const Matcher<const std::string(&)[2][3]> m = ContainerEq(a2);
+  EXPECT_THAT(a1, m);
+
+  a2[0][0] = "ha";
+  EXPECT_THAT(a1, m);
+}
+
+TEST(WhenSortedByTest, WorksForEmptyContainer) {
+  const vector<int> numbers;
+  EXPECT_THAT(numbers, WhenSortedBy(less<int>(), ElementsAre()));
+  EXPECT_THAT(numbers, Not(WhenSortedBy(less<int>(), ElementsAre(1))));
+}
+
+TEST(WhenSortedByTest, WorksForNonEmptyContainer) {
+  vector<unsigned> numbers;
+  numbers.push_back(3);
+  numbers.push_back(1);
+  numbers.push_back(2);
+  numbers.push_back(2);
+  EXPECT_THAT(numbers, WhenSortedBy(greater<unsigned>(),
+                                    ElementsAre(3, 2, 2, 1)));
+  EXPECT_THAT(numbers, Not(WhenSortedBy(greater<unsigned>(),
+                                        ElementsAre(1, 2, 2, 3))));
+}
+
+TEST(WhenSortedByTest, WorksForNonVectorContainer) {
+  list<string> words;
+  words.push_back("say");
+  words.push_back("hello");
+  words.push_back("world");
+  EXPECT_THAT(words, WhenSortedBy(less<string>(),
+                                  ElementsAre("hello", "say", "world")));
+  EXPECT_THAT(words, Not(WhenSortedBy(less<string>(),
+                                      ElementsAre("say", "hello", "world"))));
+}
+
+TEST(WhenSortedByTest, WorksForNativeArray) {
+  const int numbers[] = {1, 3, 2, 4};
+  const int sorted_numbers[] = {1, 2, 3, 4};
+  EXPECT_THAT(numbers, WhenSortedBy(less<int>(), ElementsAre(1, 2, 3, 4)));
+  EXPECT_THAT(numbers, WhenSortedBy(less<int>(),
+                                    ElementsAreArray(sorted_numbers)));
+  EXPECT_THAT(numbers, Not(WhenSortedBy(less<int>(), ElementsAre(1, 3, 2, 4))));
+}
+
+TEST(WhenSortedByTest, CanDescribeSelf) {
+  const Matcher<vector<int> > m = WhenSortedBy(less<int>(), ElementsAre(1, 2));
+  EXPECT_EQ("(when sorted) has 2 elements where\n"
+            "element #0 is equal to 1,\n"
+            "element #1 is equal to 2",
+            Describe(m));
+  EXPECT_EQ("(when sorted) doesn't have 2 elements, or\n"
+            "element #0 isn't equal to 1, or\n"
+            "element #1 isn't equal to 2",
+            DescribeNegation(m));
+}
+
+TEST(WhenSortedByTest, ExplainsMatchResult) {
+  const int a[] = {2, 1};
+  EXPECT_EQ("which is { 1, 2 } when sorted, whose element #0 doesn't match",
+            Explain(WhenSortedBy(less<int>(), ElementsAre(2, 3)), a));
+  EXPECT_EQ("which is { 1, 2 } when sorted",
+            Explain(WhenSortedBy(less<int>(), ElementsAre(1, 2)), a));
+}
+
+// WhenSorted() is a simple wrapper on WhenSortedBy().  Hence we don't
+// need to test it as exhaustively as we test the latter.
+
+TEST(WhenSortedTest, WorksForEmptyContainer) {
+  const vector<int> numbers;
+  EXPECT_THAT(numbers, WhenSorted(ElementsAre()));
+  EXPECT_THAT(numbers, Not(WhenSorted(ElementsAre(1))));
+}
+
+TEST(WhenSortedTest, WorksForNonEmptyContainer) {
+  list<string> words;
+  words.push_back("3");
+  words.push_back("1");
+  words.push_back("2");
+  words.push_back("2");
+  EXPECT_THAT(words, WhenSorted(ElementsAre("1", "2", "2", "3")));
+  EXPECT_THAT(words, Not(WhenSorted(ElementsAre("3", "1", "2", "2"))));
+}
+
+TEST(WhenSortedTest, WorksForMapTypes) {
+    map<string, int> word_counts;
+    word_counts["and"] = 1;
+    word_counts["the"] = 1;
+    word_counts["buffalo"] = 2;
+    EXPECT_THAT(word_counts, WhenSorted(ElementsAre(
+            Pair("and", 1), Pair("buffalo", 2), Pair("the", 1))));
+    EXPECT_THAT(word_counts, Not(WhenSorted(ElementsAre(
+            Pair("and", 1), Pair("the", 1), Pair("buffalo", 2)))));
+}
+
+TEST(WhenSortedTest, WorksForMultiMapTypes) {
+    multimap<int, int> ifib;
+    ifib.insert(make_pair(8, 6));
+    ifib.insert(make_pair(2, 3));
+    ifib.insert(make_pair(1, 1));
+    ifib.insert(make_pair(3, 4));
+    ifib.insert(make_pair(1, 2));
+    ifib.insert(make_pair(5, 5));
+    EXPECT_THAT(ifib, WhenSorted(ElementsAre(Pair(1, 1),
+                                             Pair(1, 2),
+                                             Pair(2, 3),
+                                             Pair(3, 4),
+                                             Pair(5, 5),
+                                             Pair(8, 6))));
+    EXPECT_THAT(ifib, Not(WhenSorted(ElementsAre(Pair(8, 6),
+                                                 Pair(2, 3),
+                                                 Pair(1, 1),
+                                                 Pair(3, 4),
+                                                 Pair(1, 2),
+                                                 Pair(5, 5)))));
+}
+
+TEST(WhenSortedTest, WorksForPolymorphicMatcher) {
+    std::deque<int> d;
+    d.push_back(2);
+    d.push_back(1);
+    EXPECT_THAT(d, WhenSorted(ElementsAre(1, 2)));
+    EXPECT_THAT(d, Not(WhenSorted(ElementsAre(2, 1))));
+}
+
+TEST(WhenSortedTest, WorksForVectorConstRefMatcher) {
+    std::deque<int> d;
+    d.push_back(2);
+    d.push_back(1);
+    Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2);
+    EXPECT_THAT(d, WhenSorted(vector_match));
+    Matcher<const std::vector<int>&> not_vector_match = ElementsAre(2, 1);
+    EXPECT_THAT(d, Not(WhenSorted(not_vector_match)));
+}
+
+// Deliberately bare pseudo-container.
+// Offers only begin() and end() accessors, yielding InputIterator.
+template <typename T>
+class Streamlike {
+ private:
+  class ConstIter;
+ public:
+  typedef ConstIter const_iterator;
+  typedef T value_type;
+
+  template <typename InIter>
+  Streamlike(InIter first, InIter last) : remainder_(first, last) {}
+
+  const_iterator begin() const {
+    return const_iterator(this, remainder_.begin());
+  }
+  const_iterator end() const {
+    return const_iterator(this, remainder_.end());
+  }
+
+ private:
+  class ConstIter : public std::iterator<std::input_iterator_tag,
+                                         value_type,
+                                         ptrdiff_t,
+                                         const value_type*,
+                                         const value_type&> {
+   public:
+    ConstIter(const Streamlike* s,
+              typename std::list<value_type>::iterator pos)
+        : s_(s), pos_(pos) {}
+
+    const value_type& operator*() const { return *pos_; }
+    const value_type* operator->() const { return &*pos_; }
+    ConstIter& operator++() {
+      s_->remainder_.erase(pos_++);
+      return *this;
+    }
+
+    // *iter++ is required to work (see std::istreambuf_iterator).
+    // (void)iter++ is also required to work.
+    class PostIncrProxy {
+     public:
+      explicit PostIncrProxy(const value_type& value) : value_(value) {}
+      value_type operator*() const { return value_; }
+     private:
+      value_type value_;
+    };
+    PostIncrProxy operator++(int) {
+      PostIncrProxy proxy(**this);
+      ++(*this);
+      return proxy;
+    }
+
+    friend bool operator==(const ConstIter& a, const ConstIter& b) {
+      return a.s_ == b.s_ && a.pos_ == b.pos_;
+    }
+    friend bool operator!=(const ConstIter& a, const ConstIter& b) {
+      return !(a == b);
+    }
+
+   private:
+    const Streamlike* s_;
+    typename std::list<value_type>::iterator pos_;
+  };
+
+  friend std::ostream& operator<<(std::ostream& os, const Streamlike& s) {
+    os << "[";
+    typedef typename std::list<value_type>::const_iterator Iter;
+    const char* sep = "";
+    for (Iter it = s.remainder_.begin(); it != s.remainder_.end(); ++it) {
+      os << sep << *it;
+      sep = ",";
+    }
+    os << "]";
+    return os;
+  }
+
+  mutable std::list<value_type> remainder_;  // modified by iteration
+};
+
+TEST(StreamlikeTest, Iteration) {
+  const int a[5] = {2, 1, 4, 5, 3};
+  Streamlike<int> s(a, a + 5);
+  Streamlike<int>::const_iterator it = s.begin();
+  const int* ip = a;
+  while (it != s.end()) {
+    SCOPED_TRACE(ip - a);
+    EXPECT_EQ(*ip++, *it++);
+  }
+}
+
+#if GTEST_HAS_STD_FORWARD_LIST_
+TEST(BeginEndDistanceIsTest, WorksWithForwardList) {
+  std::forward_list<int> container;
+  EXPECT_THAT(container, BeginEndDistanceIs(0));
+  EXPECT_THAT(container, Not(BeginEndDistanceIs(1)));
+  container.push_front(0);
+  EXPECT_THAT(container, Not(BeginEndDistanceIs(0)));
+  EXPECT_THAT(container, BeginEndDistanceIs(1));
+  container.push_front(0);
+  EXPECT_THAT(container, Not(BeginEndDistanceIs(0)));
+  EXPECT_THAT(container, BeginEndDistanceIs(2));
+}
+#endif  // GTEST_HAS_STD_FORWARD_LIST_
+
+TEST(BeginEndDistanceIsTest, WorksWithNonStdList) {
+  const int a[5] = {1, 2, 3, 4, 5};
+  Streamlike<int> s(a, a + 5);
+  EXPECT_THAT(s, BeginEndDistanceIs(5));
+}
+
+TEST(BeginEndDistanceIsTest, CanDescribeSelf) {
+  Matcher<vector<int> > m = BeginEndDistanceIs(2);
+  EXPECT_EQ("distance between begin() and end() is equal to 2", Describe(m));
+  EXPECT_EQ("distance between begin() and end() isn't equal to 2",
+            DescribeNegation(m));
+}
+
+TEST(BeginEndDistanceIsTest, ExplainsResult) {
+  Matcher<vector<int> > m1 = BeginEndDistanceIs(2);
+  Matcher<vector<int> > m2 = BeginEndDistanceIs(Lt(2));
+  Matcher<vector<int> > m3 = BeginEndDistanceIs(AnyOf(0, 3));
+  Matcher<vector<int> > m4 = BeginEndDistanceIs(GreaterThan(1));
+  vector<int> container;
+  EXPECT_EQ("whose distance between begin() and end() 0 doesn't match",
+            Explain(m1, container));
+  EXPECT_EQ("whose distance between begin() and end() 0 matches",
+            Explain(m2, container));
+  EXPECT_EQ("whose distance between begin() and end() 0 matches",
+            Explain(m3, container));
+  EXPECT_EQ(
+      "whose distance between begin() and end() 0 doesn't match, which is 1 "
+      "less than 1",
+      Explain(m4, container));
+  container.push_back(0);
+  container.push_back(0);
+  EXPECT_EQ("whose distance between begin() and end() 2 matches",
+            Explain(m1, container));
+  EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
+            Explain(m2, container));
+  EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
+            Explain(m3, container));
+  EXPECT_EQ(
+      "whose distance between begin() and end() 2 matches, which is 1 more "
+      "than 1",
+      Explain(m4, container));
+}
+
+TEST(WhenSortedTest, WorksForStreamlike) {
+  // Streamlike 'container' provides only minimal iterator support.
+  // Its iterators are tagged with input_iterator_tag.
+  const int a[5] = {2, 1, 4, 5, 3};
+  Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
+  EXPECT_THAT(s, WhenSorted(ElementsAre(1, 2, 3, 4, 5)));
+  EXPECT_THAT(s, Not(WhenSorted(ElementsAre(2, 1, 4, 5, 3))));
+}
+
+TEST(WhenSortedTest, WorksForVectorConstRefMatcherOnStreamlike) {
+  const int a[] = {2, 1, 4, 5, 3};
+  Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
+  Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2, 3, 4, 5);
+  EXPECT_THAT(s, WhenSorted(vector_match));
+  EXPECT_THAT(s, Not(WhenSorted(ElementsAre(2, 1, 4, 5, 3))));
+}
+
+// Tests using ElementsAre() and ElementsAreArray() with stream-like
+// "containers".
+
+TEST(ElemensAreStreamTest, WorksForStreamlike) {
+  const int a[5] = {1, 2, 3, 4, 5};
+  Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
+  EXPECT_THAT(s, ElementsAre(1, 2, 3, 4, 5));
+  EXPECT_THAT(s, Not(ElementsAre(2, 1, 4, 5, 3)));
+}
+
+TEST(ElemensAreArrayStreamTest, WorksForStreamlike) {
+  const int a[5] = {1, 2, 3, 4, 5};
+  Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
+
+  vector<int> expected;
+  expected.push_back(1);
+  expected.push_back(2);
+  expected.push_back(3);
+  expected.push_back(4);
+  expected.push_back(5);
+  EXPECT_THAT(s, ElementsAreArray(expected));
+
+  expected[3] = 0;
+  EXPECT_THAT(s, Not(ElementsAreArray(expected)));
+}
+
+TEST(ElementsAreTest, WorksWithUncopyable) {
+  Uncopyable objs[2];
+  objs[0].set_value(-3);
+  objs[1].set_value(1);
+  EXPECT_THAT(objs, ElementsAre(UncopyableIs(-3), Truly(ValueIsPositive)));
+}
+
+TEST(ElementsAreTest, TakesStlContainer) {
+  const int actual[] = {3, 1, 2};
+
+  ::std::list<int> expected;
+  expected.push_back(3);
+  expected.push_back(1);
+  expected.push_back(2);
+  EXPECT_THAT(actual, ElementsAreArray(expected));
+
+  expected.push_back(4);
+  EXPECT_THAT(actual, Not(ElementsAreArray(expected)));
+}
+
+// Tests for UnorderedElementsAreArray()
+
+TEST(UnorderedElementsAreArrayTest, SucceedsWhenExpected) {
+  const int a[] = {0, 1, 2, 3, 4};
+  std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
+  do {
+    StringMatchResultListener listener;
+    EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(a),
+                                   s, &listener)) << listener.str();
+  } while (std::next_permutation(s.begin(), s.end()));
+}
+
+TEST(UnorderedElementsAreArrayTest, VectorBool) {
+  const bool a[] = {0, 1, 0, 1, 1};
+  const bool b[] = {1, 0, 1, 1, 0};
+  std::vector<bool> expected(a, a + GTEST_ARRAY_SIZE_(a));
+  std::vector<bool> actual(b, b + GTEST_ARRAY_SIZE_(b));
+  StringMatchResultListener listener;
+  EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(expected),
+                                 actual, &listener)) << listener.str();
+}
+
+TEST(UnorderedElementsAreArrayTest, WorksForStreamlike) {
+  // Streamlike 'container' provides only minimal iterator support.
+  // Its iterators are tagged with input_iterator_tag, and it has no
+  // size() or empty() methods.
+  const int a[5] = {2, 1, 4, 5, 3};
+  Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
+
+  ::std::vector<int> expected;
+  expected.push_back(1);
+  expected.push_back(2);
+  expected.push_back(3);
+  expected.push_back(4);
+  expected.push_back(5);
+  EXPECT_THAT(s, UnorderedElementsAreArray(expected));
+
+  expected.push_back(6);
+  EXPECT_THAT(s, Not(UnorderedElementsAreArray(expected)));
+}
+
+TEST(UnorderedElementsAreArrayTest, TakesStlContainer) {
+  const int actual[] = {3, 1, 2};
+
+  ::std::list<int> expected;
+  expected.push_back(1);
+  expected.push_back(2);
+  expected.push_back(3);
+  EXPECT_THAT(actual, UnorderedElementsAreArray(expected));
+
+  expected.push_back(4);
+  EXPECT_THAT(actual, Not(UnorderedElementsAreArray(expected)));
+}
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+
+TEST(UnorderedElementsAreArrayTest, TakesInitializerList) {
+  const int a[5] = {2, 1, 4, 5, 3};
+  EXPECT_THAT(a, UnorderedElementsAreArray({1, 2, 3, 4, 5}));
+  EXPECT_THAT(a, Not(UnorderedElementsAreArray({1, 2, 3, 4, 6})));
+}
+
+TEST(UnorderedElementsAreArrayTest, TakesInitializerListOfCStrings) {
+  const string a[5] = {"a", "b", "c", "d", "e"};
+  EXPECT_THAT(a, UnorderedElementsAreArray({"a", "b", "c", "d", "e"}));
+  EXPECT_THAT(a, Not(UnorderedElementsAreArray({"a", "b", "c", "d", "ef"})));
+}
+
+TEST(UnorderedElementsAreArrayTest, TakesInitializerListOfSameTypedMatchers) {
+  const int a[5] = {2, 1, 4, 5, 3};
+  EXPECT_THAT(a, UnorderedElementsAreArray(
+      {Eq(1), Eq(2), Eq(3), Eq(4), Eq(5)}));
+  EXPECT_THAT(a, Not(UnorderedElementsAreArray(
+      {Eq(1), Eq(2), Eq(3), Eq(4), Eq(6)})));
+}
+
+TEST(UnorderedElementsAreArrayTest,
+     TakesInitializerListOfDifferentTypedMatchers) {
+  const int a[5] = {2, 1, 4, 5, 3};
+  // The compiler cannot infer the type of the initializer list if its
+  // elements have different types.  We must explicitly specify the
+  // unified element type in this case.
+  EXPECT_THAT(a, UnorderedElementsAreArray<Matcher<int> >(
+      {Eq(1), Ne(-2), Ge(3), Le(4), Eq(5)}));
+  EXPECT_THAT(a, Not(UnorderedElementsAreArray<Matcher<int> >(
+      {Eq(1), Ne(-2), Ge(3), Le(4), Eq(6)})));
+}
+
+#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
+
+class UnorderedElementsAreTest : public testing::Test {
+ protected:
+  typedef std::vector<int> IntVec;
+};
+
+TEST_F(UnorderedElementsAreTest, WorksWithUncopyable) {
+  Uncopyable objs[2];
+  objs[0].set_value(-3);
+  objs[1].set_value(1);
+  EXPECT_THAT(objs,
+              UnorderedElementsAre(Truly(ValueIsPositive), UncopyableIs(-3)));
+}
+
+TEST_F(UnorderedElementsAreTest, SucceedsWhenExpected) {
+  const int a[] = {1, 2, 3};
+  std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
+  do {
+    StringMatchResultListener listener;
+    EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
+                                   s, &listener)) << listener.str();
+  } while (std::next_permutation(s.begin(), s.end()));
+}
+
+TEST_F(UnorderedElementsAreTest, FailsWhenAnElementMatchesNoMatcher) {
+  const int a[] = {1, 2, 3};
+  std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
+  std::vector<Matcher<int> > mv;
+  mv.push_back(1);
+  mv.push_back(2);
+  mv.push_back(2);
+  // The element with value '3' matches nothing: fail fast.
+  StringMatchResultListener listener;
+  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAreArray(mv),
+                                  s, &listener)) << listener.str();
+}
+
+TEST_F(UnorderedElementsAreTest, WorksForStreamlike) {
+  // Streamlike 'container' provides only minimal iterator support.
+  // Its iterators are tagged with input_iterator_tag, and it has no
+  // size() or empty() methods.
+  const int a[5] = {2, 1, 4, 5, 3};
+  Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
+
+  EXPECT_THAT(s, UnorderedElementsAre(1, 2, 3, 4, 5));
+  EXPECT_THAT(s, Not(UnorderedElementsAre(2, 2, 3, 4, 5)));
+}
+
+// One naive implementation of the matcher runs in O(N!) time, which is too
+// slow for many real-world inputs. This test shows that our matcher can match
+// 100 inputs very quickly (a few milliseconds).  An O(100!) is 10^158
+// iterations and obviously effectively incomputable.
+// [ RUN      ] UnorderedElementsAreTest.Performance
+// [       OK ] UnorderedElementsAreTest.Performance (4 ms)
+TEST_F(UnorderedElementsAreTest, Performance) {
+  std::vector<int> s;
+  std::vector<Matcher<int> > mv;
+  for (int i = 0; i < 100; ++i) {
+    s.push_back(i);
+    mv.push_back(_);
+  }
+  mv[50] = Eq(0);
+  StringMatchResultListener listener;
+  EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv),
+                                 s, &listener)) << listener.str();
+}
+
+// Another variant of 'Performance' with similar expectations.
+// [ RUN      ] UnorderedElementsAreTest.PerformanceHalfStrict
+// [       OK ] UnorderedElementsAreTest.PerformanceHalfStrict (4 ms)
+TEST_F(UnorderedElementsAreTest, PerformanceHalfStrict) {
+  std::vector<int> s;
+  std::vector<Matcher<int> > mv;
+  for (int i = 0; i < 100; ++i) {
+    s.push_back(i);
+    if (i & 1) {
+      mv.push_back(_);
+    } else {
+      mv.push_back(i);
+    }
+  }
+  StringMatchResultListener listener;
+  EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv),
+                                 s, &listener)) << listener.str();
+}
+
+TEST_F(UnorderedElementsAreTest, FailMessageCountWrong) {
+  std::vector<int> v;
+  v.push_back(4);
+  StringMatchResultListener listener;
+  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
+                                  v, &listener)) << listener.str();
+  EXPECT_THAT(listener.str(), Eq("which has 1 element"));
+}
+
+TEST_F(UnorderedElementsAreTest, FailMessageCountWrongZero) {
+  std::vector<int> v;
+  StringMatchResultListener listener;
+  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
+                                  v, &listener)) << listener.str();
+  EXPECT_THAT(listener.str(), Eq(""));
+}
+
+TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatchers) {
+  std::vector<int> v;
+  v.push_back(1);
+  v.push_back(1);
+  StringMatchResultListener listener;
+  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2),
+                                  v, &listener)) << listener.str();
+  EXPECT_THAT(
+      listener.str(),
+      Eq("where the following matchers don't match any elements:\n"
+         "matcher #1: is equal to 2"));
+}
+
+TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedElements) {
+  std::vector<int> v;
+  v.push_back(1);
+  v.push_back(2);
+  StringMatchResultListener listener;
+  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 1),
+                                  v, &listener)) << listener.str();
+  EXPECT_THAT(
+      listener.str(),
+      Eq("where the following elements don't match any matchers:\n"
+         "element #1: 2"));
+}
+
+TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatcherAndElement) {
+  std::vector<int> v;
+  v.push_back(2);
+  v.push_back(3);
+  StringMatchResultListener listener;
+  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2),
+                                  v, &listener)) << listener.str();
+  EXPECT_THAT(
+      listener.str(),
+      Eq("where"
+         " the following matchers don't match any elements:\n"
+         "matcher #0: is equal to 1\n"
+         "and"
+         " where"
+         " the following elements don't match any matchers:\n"
+         "element #1: 3"));
+}
+
+// Test helper for formatting element, matcher index pairs in expectations.
+static string EMString(int element, int matcher) {
+  stringstream ss;
+  ss << "(element #" << element << ", matcher #" << matcher << ")";
+  return ss.str();
+}
+
+TEST_F(UnorderedElementsAreTest, FailMessageImperfectMatchOnly) {
+  // A situation where all elements and matchers have a match
+  // associated with them, but the max matching is not perfect.
+  std::vector<string> v;
+  v.push_back("a");
+  v.push_back("b");
+  v.push_back("c");
+  StringMatchResultListener listener;
+  EXPECT_FALSE(ExplainMatchResult(
+      UnorderedElementsAre("a", "a", AnyOf("b", "c")), v, &listener))
+      << listener.str();
+
+  string prefix =
+      "where no permutation of the elements can satisfy all matchers, "
+      "and the closest match is 2 of 3 matchers with the "
+      "pairings:\n";
+
+  // We have to be a bit loose here, because there are 4 valid max matches.
+  EXPECT_THAT(
+      listener.str(),
+      AnyOf(prefix + "{\n  " + EMString(0, 0) +
+                     ",\n  " + EMString(1, 2) + "\n}",
+            prefix + "{\n  " + EMString(0, 1) +
+                     ",\n  " + EMString(1, 2) + "\n}",
+            prefix + "{\n  " + EMString(0, 0) +
+                     ",\n  " + EMString(2, 2) + "\n}",
+            prefix + "{\n  " + EMString(0, 1) +
+                     ",\n  " + EMString(2, 2) + "\n}"));
+}
+
+TEST_F(UnorderedElementsAreTest, Describe) {
+  EXPECT_THAT(Describe<IntVec>(UnorderedElementsAre()),
+              Eq("is empty"));
+  EXPECT_THAT(
+      Describe<IntVec>(UnorderedElementsAre(345)),
+      Eq("has 1 element and that element is equal to 345"));
+  EXPECT_THAT(
+      Describe<IntVec>(UnorderedElementsAre(111, 222, 333)),
+      Eq("has 3 elements and there exists some permutation "
+         "of elements such that:\n"
+         " - element #0 is equal to 111, and\n"
+         " - element #1 is equal to 222, and\n"
+         " - element #2 is equal to 333"));
+}
+
+TEST_F(UnorderedElementsAreTest, DescribeNegation) {
+  EXPECT_THAT(DescribeNegation<IntVec>(UnorderedElementsAre()),
+              Eq("isn't empty"));
+  EXPECT_THAT(
+      DescribeNegation<IntVec>(UnorderedElementsAre(345)),
+      Eq("doesn't have 1 element, or has 1 element that isn't equal to 345"));
+  EXPECT_THAT(
+      DescribeNegation<IntVec>(UnorderedElementsAre(123, 234, 345)),
+      Eq("doesn't have 3 elements, or there exists no permutation "
+         "of elements such that:\n"
+         " - element #0 is equal to 123, and\n"
+         " - element #1 is equal to 234, and\n"
+         " - element #2 is equal to 345"));
+}
+
+namespace {
+
+// Used as a check on the more complex max flow method used in the
+// real testing::internal::FindMaxBipartiteMatching. This method is
+// compatible but runs in worst-case factorial time, so we only
+// use it in testing for small problem sizes.
+template <typename Graph>
+class BacktrackingMaxBPMState {
+ public:
+  // Does not take ownership of 'g'.
+  explicit BacktrackingMaxBPMState(const Graph* g) : graph_(g) { }
+
+  ElementMatcherPairs Compute() {
+    if (graph_->LhsSize() == 0 || graph_->RhsSize() == 0) {
+      return best_so_far_;
+    }
+    lhs_used_.assign(graph_->LhsSize(), kUnused);
+    rhs_used_.assign(graph_->RhsSize(), kUnused);
+    for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
+      matches_.clear();
+      RecurseInto(irhs);
+      if (best_so_far_.size() == graph_->RhsSize())
+        break;
+    }
+    return best_so_far_;
+  }
+
+ private:
+  static const size_t kUnused = static_cast<size_t>(-1);
+
+  void PushMatch(size_t lhs, size_t rhs) {
+    matches_.push_back(ElementMatcherPair(lhs, rhs));
+    lhs_used_[lhs] = rhs;
+    rhs_used_[rhs] = lhs;
+    if (matches_.size() > best_so_far_.size()) {
+      best_so_far_ = matches_;
+    }
+  }
+
+  void PopMatch() {
+    const ElementMatcherPair& back = matches_.back();
+    lhs_used_[back.first] = kUnused;
+    rhs_used_[back.second] = kUnused;
+    matches_.pop_back();
+  }
+
+  bool RecurseInto(size_t irhs) {
+    if (rhs_used_[irhs] != kUnused) {
+      return true;
+    }
+    for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
+      if (lhs_used_[ilhs] != kUnused) {
+        continue;
+      }
+      if (!graph_->HasEdge(ilhs, irhs)) {
+        continue;
+      }
+      PushMatch(ilhs, irhs);
+      if (best_so_far_.size() == graph_->RhsSize()) {
+        return false;
+      }
+      for (size_t mi = irhs + 1; mi < graph_->RhsSize(); ++mi) {
+        if (!RecurseInto(mi)) return false;
+      }
+      PopMatch();
+    }
+    return true;
+  }
+
+  const Graph* graph_;  // not owned
+  std::vector<size_t> lhs_used_;
+  std::vector<size_t> rhs_used_;
+  ElementMatcherPairs matches_;
+  ElementMatcherPairs best_so_far_;
+};
+
+template <typename Graph>
+const size_t BacktrackingMaxBPMState<Graph>::kUnused;
+
+}  // namespace
+
+// Implement a simple backtracking algorithm to determine if it is possible
+// to find one element per matcher, without reusing elements.
+template <typename Graph>
+ElementMatcherPairs
+FindBacktrackingMaxBPM(const Graph& g) {
+  return BacktrackingMaxBPMState<Graph>(&g).Compute();
+}
+
+class BacktrackingBPMTest : public ::testing::Test { };
+
+// Tests the MaxBipartiteMatching algorithm with square matrices.
+// The single int param is the # of nodes on each of the left and right sides.
+class BipartiteTest : public ::testing::TestWithParam<int> { };
+
+// Verify all match graphs up to some moderate number of edges.
+TEST_P(BipartiteTest, Exhaustive) {
+  int nodes = GetParam();
+  MatchMatrix graph(nodes, nodes);
+  do {
+    ElementMatcherPairs matches =
+        internal::FindMaxBipartiteMatching(graph);
+    EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(), matches.size())
+        << "graph: " << graph.DebugString();
+    // Check that all elements of matches are in the graph.
+    // Check that elements of first and second are unique.
+    std::vector<bool> seen_element(graph.LhsSize());
+    std::vector<bool> seen_matcher(graph.RhsSize());
+    SCOPED_TRACE(PrintToString(matches));
+    for (size_t i = 0; i < matches.size(); ++i) {
+      size_t ilhs = matches[i].first;
+      size_t irhs = matches[i].second;
+      EXPECT_TRUE(graph.HasEdge(ilhs, irhs));
+      EXPECT_FALSE(seen_element[ilhs]);
+      EXPECT_FALSE(seen_matcher[irhs]);
+      seen_element[ilhs] = true;
+      seen_matcher[irhs] = true;
+    }
+  } while (graph.NextGraph());
+}
+
+INSTANTIATE_TEST_CASE_P(AllGraphs, BipartiteTest,
+                        ::testing::Range(0, 5));
+
+// Parameterized by a pair interpreted as (LhsSize, RhsSize).
+class BipartiteNonSquareTest
+    : public ::testing::TestWithParam<std::pair<size_t, size_t> > {
+};
+
+TEST_F(BipartiteNonSquareTest, SimpleBacktracking) {
+  //   .......
+  // 0:-----\ :
+  // 1:---\ | :
+  // 2:---\ | :
+  // 3:-\ | | :
+  //  :.......:
+  //    0 1 2
+  MatchMatrix g(4, 3);
+  static const int kEdges[][2] = {{0, 2}, {1, 1}, {2, 1}, {3, 0}};
+  for (size_t i = 0; i < GTEST_ARRAY_SIZE_(kEdges); ++i) {
+    g.SetEdge(kEdges[i][0], kEdges[i][1], true);
+  }
+  EXPECT_THAT(FindBacktrackingMaxBPM(g),
+              ElementsAre(Pair(3, 0),
+                          Pair(AnyOf(1, 2), 1),
+                          Pair(0, 2))) << g.DebugString();
+}
+
+// Verify a few nonsquare matrices.
+TEST_P(BipartiteNonSquareTest, Exhaustive) {
+  size_t nlhs = GetParam().first;
+  size_t nrhs = GetParam().second;
+  MatchMatrix graph(nlhs, nrhs);
+  do {
+    EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
+              internal::FindMaxBipartiteMatching(graph).size())
+        << "graph: " << graph.DebugString()
+        << "\nbacktracking: "
+        << PrintToString(FindBacktrackingMaxBPM(graph))
+        << "\nmax flow: "
+        << PrintToString(internal::FindMaxBipartiteMatching(graph));
+  } while (graph.NextGraph());
+}
+
+INSTANTIATE_TEST_CASE_P(AllGraphs, BipartiteNonSquareTest,
+    testing::Values(
+        std::make_pair(1, 2),
+        std::make_pair(2, 1),
+        std::make_pair(3, 2),
+        std::make_pair(2, 3),
+        std::make_pair(4, 1),
+        std::make_pair(1, 4),
+        std::make_pair(4, 3),
+        std::make_pair(3, 4)));
+
+class BipartiteRandomTest
+    : public ::testing::TestWithParam<std::pair<int, int> > {
+};
+
+// Verifies a large sample of larger graphs.
+TEST_P(BipartiteRandomTest, LargerNets) {
+  int nodes = GetParam().first;
+  int iters = GetParam().second;
+  MatchMatrix graph(nodes, nodes);
+
+  testing::internal::Int32 seed = GTEST_FLAG(random_seed);
+  if (seed == 0) {
+    seed = static_cast<testing::internal::Int32>(time(NULL));
+  }
+
+  for (; iters > 0; --iters, ++seed) {
+    srand(static_cast<int>(seed));
+    graph.Randomize();
+    EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
+              internal::FindMaxBipartiteMatching(graph).size())
+        << " graph: " << graph.DebugString()
+        << "\nTo reproduce the failure, rerun the test with the flag"
+           " --" << GTEST_FLAG_PREFIX_ << "random_seed=" << seed;
+  }
+}
+
+// Test argument is a std::pair<int, int> representing (nodes, iters).
+INSTANTIATE_TEST_CASE_P(Samples, BipartiteRandomTest,
+    testing::Values(
+        std::make_pair(5, 10000),
+        std::make_pair(6, 5000),
+        std::make_pair(7, 2000),
+        std::make_pair(8, 500),
+        std::make_pair(9, 100)));
+
+// Tests IsReadableTypeName().
+
+TEST(IsReadableTypeNameTest, ReturnsTrueForShortNames) {
+  EXPECT_TRUE(IsReadableTypeName("int"));
+  EXPECT_TRUE(IsReadableTypeName("const unsigned char*"));
+  EXPECT_TRUE(IsReadableTypeName("MyMap<int, void*>"));
+  EXPECT_TRUE(IsReadableTypeName("void (*)(int, bool)"));
+}
+
+TEST(IsReadableTypeNameTest, ReturnsTrueForLongNonTemplateNonFunctionNames) {
+  EXPECT_TRUE(IsReadableTypeName("my_long_namespace::MyClassName"));
+  EXPECT_TRUE(IsReadableTypeName("int [5][6][7][8][9][10][11]"));
+  EXPECT_TRUE(IsReadableTypeName("my_namespace::MyOuterClass::MyInnerClass"));
+}
+
+TEST(IsReadableTypeNameTest, ReturnsFalseForLongTemplateNames) {
+  EXPECT_FALSE(
+      IsReadableTypeName("basic_string<char, std::char_traits<char> >"));
+  EXPECT_FALSE(IsReadableTypeName("std::vector<int, std::alloc_traits<int> >"));
+}
+
+TEST(IsReadableTypeNameTest, ReturnsFalseForLongFunctionTypeNames) {
+  EXPECT_FALSE(IsReadableTypeName("void (&)(int, bool, char, float)"));
+}
+
+// Tests JoinAsTuple().
+
+TEST(JoinAsTupleTest, JoinsEmptyTuple) {
+  EXPECT_EQ("", JoinAsTuple(Strings()));
+}
+
+TEST(JoinAsTupleTest, JoinsOneTuple) {
+  const char* fields[] = {"1"};
+  EXPECT_EQ("1", JoinAsTuple(Strings(fields, fields + 1)));
+}
+
+TEST(JoinAsTupleTest, JoinsTwoTuple) {
+  const char* fields[] = {"1", "a"};
+  EXPECT_EQ("(1, a)", JoinAsTuple(Strings(fields, fields + 2)));
+}
+
+TEST(JoinAsTupleTest, JoinsTenTuple) {
+  const char* fields[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
+  EXPECT_EQ("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)",
+            JoinAsTuple(Strings(fields, fields + 10)));
+}
+
+// Tests FormatMatcherDescription().
+
+TEST(FormatMatcherDescriptionTest, WorksForEmptyDescription) {
+  EXPECT_EQ("is even",
+            FormatMatcherDescription(false, "IsEven", Strings()));
+  EXPECT_EQ("not (is even)",
+            FormatMatcherDescription(true, "IsEven", Strings()));
+
+  const char* params[] = {"5"};
+  EXPECT_EQ("equals 5",
+            FormatMatcherDescription(false, "Equals",
+                                     Strings(params, params + 1)));
+
+  const char* params2[] = {"5", "8"};
+  EXPECT_EQ("is in range (5, 8)",
+            FormatMatcherDescription(false, "IsInRange",
+                                     Strings(params2, params2 + 2)));
+}
+
+// Tests PolymorphicMatcher::mutable_impl().
+TEST(PolymorphicMatcherTest, CanAccessMutableImpl) {
+  PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
+  DivisibleByImpl& impl = m.mutable_impl();
+  EXPECT_EQ(42, impl.divider());
+
+  impl.set_divider(0);
+  EXPECT_EQ(0, m.mutable_impl().divider());
+}
+
+// Tests PolymorphicMatcher::impl().
+TEST(PolymorphicMatcherTest, CanAccessImpl) {
+  const PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
+  const DivisibleByImpl& impl = m.impl();
+  EXPECT_EQ(42, impl.divider());
+}
+
+TEST(MatcherTupleTest, ExplainsMatchFailure) {
+  stringstream ss1;
+  ExplainMatchFailureTupleTo(make_tuple(Matcher<char>(Eq('a')), GreaterThan(5)),
+                             make_tuple('a', 10), &ss1);
+  EXPECT_EQ("", ss1.str());  // Successful match.
+
+  stringstream ss2;
+  ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
+                             make_tuple(2, 'b'), &ss2);
+  EXPECT_EQ("  Expected arg #0: is > 5\n"
+            "           Actual: 2, which is 3 less than 5\n"
+            "  Expected arg #1: is equal to 'a' (97, 0x61)\n"
+            "           Actual: 'b' (98, 0x62)\n",
+            ss2.str());  // Failed match where both arguments need explanation.
+
+  stringstream ss3;
+  ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
+                             make_tuple(2, 'a'), &ss3);
+  EXPECT_EQ("  Expected arg #0: is > 5\n"
+            "           Actual: 2, which is 3 less than 5\n",
+            ss3.str());  // Failed match where only one argument needs
+                         // explanation.
+}
+
+// Tests Each().
+
+TEST(EachTest, ExplainsMatchResultCorrectly) {
+  set<int> a;  // empty
+
+  Matcher<set<int> > m = Each(2);
+  EXPECT_EQ("", Explain(m, a));
+
+  Matcher<const int(&)[1]> n = Each(1);  // NOLINT
+
+  const int b[1] = {1};
+  EXPECT_EQ("", Explain(n, b));
+
+  n = Each(3);
+  EXPECT_EQ("whose element #0 doesn't match", Explain(n, b));
+
+  a.insert(1);
+  a.insert(2);
+  a.insert(3);
+  m = Each(GreaterThan(0));
+  EXPECT_EQ("", Explain(m, a));
+
+  m = Each(GreaterThan(10));
+  EXPECT_EQ("whose element #0 doesn't match, which is 9 less than 10",
+            Explain(m, a));
+}
+
+TEST(EachTest, DescribesItselfCorrectly) {
+  Matcher<vector<int> > m = Each(1);
+  EXPECT_EQ("only contains elements that is equal to 1", Describe(m));
+
+  Matcher<vector<int> > m2 = Not(m);
+  EXPECT_EQ("contains some element that isn't equal to 1", Describe(m2));
+}
+
+TEST(EachTest, MatchesVectorWhenAllElementsMatch) {
+  vector<int> some_vector;
+  EXPECT_THAT(some_vector, Each(1));
+  some_vector.push_back(3);
+  EXPECT_THAT(some_vector, Not(Each(1)));
+  EXPECT_THAT(some_vector, Each(3));
+  some_vector.push_back(1);
+  some_vector.push_back(2);
+  EXPECT_THAT(some_vector, Not(Each(3)));
+  EXPECT_THAT(some_vector, Each(Lt(3.5)));
+
+  vector<string> another_vector;
+  another_vector.push_back("fee");
+  EXPECT_THAT(another_vector, Each(string("fee")));
+  another_vector.push_back("fie");
+  another_vector.push_back("foe");
+  another_vector.push_back("fum");
+  EXPECT_THAT(another_vector, Not(Each(string("fee"))));
+}
+
+TEST(EachTest, MatchesMapWhenAllElementsMatch) {
+  map<const char*, int> my_map;
+  const char* bar = "a string";
+  my_map[bar] = 2;
+  EXPECT_THAT(my_map, Each(make_pair(bar, 2)));
+
+  map<string, int> another_map;
+  EXPECT_THAT(another_map, Each(make_pair(string("fee"), 1)));
+  another_map["fee"] = 1;
+  EXPECT_THAT(another_map, Each(make_pair(string("fee"), 1)));
+  another_map["fie"] = 2;
+  another_map["foe"] = 3;
+  another_map["fum"] = 4;
+  EXPECT_THAT(another_map, Not(Each(make_pair(string("fee"), 1))));
+  EXPECT_THAT(another_map, Not(Each(make_pair(string("fum"), 1))));
+  EXPECT_THAT(another_map, Each(Pair(_, Gt(0))));
+}
+
+TEST(EachTest, AcceptsMatcher) {
+  const int a[] = {1, 2, 3};
+  EXPECT_THAT(a, Each(Gt(0)));
+  EXPECT_THAT(a, Not(Each(Gt(1))));
+}
+
+TEST(EachTest, WorksForNativeArrayAsTuple) {
+  const int a[] = {1, 2};
+  const int* const pointer = a;
+  EXPECT_THAT(make_tuple(pointer, 2), Each(Gt(0)));
+  EXPECT_THAT(make_tuple(pointer, 2), Not(Each(Gt(1))));
+}
+
+// For testing Pointwise().
+class IsHalfOfMatcher {
+ public:
+  template <typename T1, typename T2>
+  bool MatchAndExplain(const tuple<T1, T2>& a_pair,
+                       MatchResultListener* listener) const {
+    if (get<0>(a_pair) == get<1>(a_pair)/2) {
+      *listener << "where the second is " << get<1>(a_pair);
+      return true;
+    } else {
+      *listener << "where the second/2 is " << get<1>(a_pair)/2;
+      return false;
+    }
+  }
+
+  void DescribeTo(ostream* os) const {
+    *os << "are a pair where the first is half of the second";
+  }
+
+  void DescribeNegationTo(ostream* os) const {
+    *os << "are a pair where the first isn't half of the second";
+  }
+};
+
+PolymorphicMatcher<IsHalfOfMatcher> IsHalfOf() {
+  return MakePolymorphicMatcher(IsHalfOfMatcher());
+}
+
+TEST(PointwiseTest, DescribesSelf) {
+  vector<int> rhs;
+  rhs.push_back(1);
+  rhs.push_back(2);
+  rhs.push_back(3);
+  const Matcher<const vector<int>&> m = Pointwise(IsHalfOf(), rhs);
+  EXPECT_EQ("contains 3 values, where each value and its corresponding value "
+            "in { 1, 2, 3 } are a pair where the first is half of the second",
+            Describe(m));
+  EXPECT_EQ("doesn't contain exactly 3 values, or contains a value x at some "
+            "index i where x and the i-th value of { 1, 2, 3 } are a pair "
+            "where the first isn't half of the second",
+            DescribeNegation(m));
+}
+
+TEST(PointwiseTest, MakesCopyOfRhs) {
+  list<signed char> rhs;
+  rhs.push_back(2);
+  rhs.push_back(4);
+
+  int lhs[] = {1, 2};
+  const Matcher<const int (&)[2]> m = Pointwise(IsHalfOf(), rhs);
+  EXPECT_THAT(lhs, m);
+
+  // Changing rhs now shouldn't affect m, which made a copy of rhs.
+  rhs.push_back(6);
+  EXPECT_THAT(lhs, m);
+}
+
+TEST(PointwiseTest, WorksForLhsNativeArray) {
+  const int lhs[] = {1, 2, 3};
+  vector<int> rhs;
+  rhs.push_back(2);
+  rhs.push_back(4);
+  rhs.push_back(6);
+  EXPECT_THAT(lhs, Pointwise(Lt(), rhs));
+  EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs)));
+}
+
+TEST(PointwiseTest, WorksForRhsNativeArray) {
+  const int rhs[] = {1, 2, 3};
+  vector<int> lhs;
+  lhs.push_back(2);
+  lhs.push_back(4);
+  lhs.push_back(6);
+  EXPECT_THAT(lhs, Pointwise(Gt(), rhs));
+  EXPECT_THAT(lhs, Not(Pointwise(Lt(), rhs)));
+}
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+
+TEST(PointwiseTest, WorksForRhsInitializerList) {
+  const vector<int> lhs{2, 4, 6};
+  EXPECT_THAT(lhs, Pointwise(Gt(), {1, 2, 3}));
+  EXPECT_THAT(lhs, Not(Pointwise(Lt(), {3, 3, 7})));
+}
+
+#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
+
+TEST(PointwiseTest, RejectsWrongSize) {
+  const double lhs[2] = {1, 2};
+  const int rhs[1] = {0};
+  EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs)));
+  EXPECT_EQ("which contains 2 values",
+            Explain(Pointwise(Gt(), rhs), lhs));
+
+  const int rhs2[3] = {0, 1, 2};
+  EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs2)));
+}
+
+TEST(PointwiseTest, RejectsWrongContent) {
+  const double lhs[3] = {1, 2, 3};
+  const int rhs[3] = {2, 6, 4};
+  EXPECT_THAT(lhs, Not(Pointwise(IsHalfOf(), rhs)));
+  EXPECT_EQ("where the value pair (2, 6) at index #1 don't match, "
+            "where the second/2 is 3",
+            Explain(Pointwise(IsHalfOf(), rhs), lhs));
+}
+
+TEST(PointwiseTest, AcceptsCorrectContent) {
+  const double lhs[3] = {1, 2, 3};
+  const int rhs[3] = {2, 4, 6};
+  EXPECT_THAT(lhs, Pointwise(IsHalfOf(), rhs));
+  EXPECT_EQ("", Explain(Pointwise(IsHalfOf(), rhs), lhs));
+}
+
+TEST(PointwiseTest, AllowsMonomorphicInnerMatcher) {
+  const double lhs[3] = {1, 2, 3};
+  const int rhs[3] = {2, 4, 6};
+  const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf();
+  EXPECT_THAT(lhs, Pointwise(m1, rhs));
+  EXPECT_EQ("", Explain(Pointwise(m1, rhs), lhs));
+
+  // This type works as a tuple<const double&, const int&> can be
+  // implicitly cast to tuple<double, int>.
+  const Matcher<tuple<double, int> > m2 = IsHalfOf();
+  EXPECT_THAT(lhs, Pointwise(m2, rhs));
+  EXPECT_EQ("", Explain(Pointwise(m2, rhs), lhs));
+}
+
+TEST(UnorderedPointwiseTest, DescribesSelf) {
+  vector<int> rhs;
+  rhs.push_back(1);
+  rhs.push_back(2);
+  rhs.push_back(3);
+  const Matcher<const vector<int>&> m = UnorderedPointwise(IsHalfOf(), rhs);
+  EXPECT_EQ(
+      "has 3 elements and there exists some permutation of elements such "
+      "that:\n"
+      " - element #0 and 1 are a pair where the first is half of the second, "
+      "and\n"
+      " - element #1 and 2 are a pair where the first is half of the second, "
+      "and\n"
+      " - element #2 and 3 are a pair where the first is half of the second",
+      Describe(m));
+  EXPECT_EQ(
+      "doesn't have 3 elements, or there exists no permutation of elements "
+      "such that:\n"
+      " - element #0 and 1 are a pair where the first is half of the second, "
+      "and\n"
+      " - element #1 and 2 are a pair where the first is half of the second, "
+      "and\n"
+      " - element #2 and 3 are a pair where the first is half of the second",
+      DescribeNegation(m));
+}
+
+TEST(UnorderedPointwiseTest, MakesCopyOfRhs) {
+  list<signed char> rhs;
+  rhs.push_back(2);
+  rhs.push_back(4);
+
+  int lhs[] = {2, 1};
+  const Matcher<const int (&)[2]> m = UnorderedPointwise(IsHalfOf(), rhs);
+  EXPECT_THAT(lhs, m);
+
+  // Changing rhs now shouldn't affect m, which made a copy of rhs.
+  rhs.push_back(6);
+  EXPECT_THAT(lhs, m);
+}
+
+TEST(UnorderedPointwiseTest, WorksForLhsNativeArray) {
+  const int lhs[] = {1, 2, 3};
+  vector<int> rhs;
+  rhs.push_back(4);
+  rhs.push_back(6);
+  rhs.push_back(2);
+  EXPECT_THAT(lhs, UnorderedPointwise(Lt(), rhs));
+  EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs)));
+}
+
+TEST(UnorderedPointwiseTest, WorksForRhsNativeArray) {
+  const int rhs[] = {1, 2, 3};
+  vector<int> lhs;
+  lhs.push_back(4);
+  lhs.push_back(2);
+  lhs.push_back(6);
+  EXPECT_THAT(lhs, UnorderedPointwise(Gt(), rhs));
+  EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), rhs)));
+}
+
+#if GTEST_HAS_STD_INITIALIZER_LIST_
+
+TEST(UnorderedPointwiseTest, WorksForRhsInitializerList) {
+  const vector<int> lhs{2, 4, 6};
+  EXPECT_THAT(lhs, UnorderedPointwise(Gt(), {5, 1, 3}));
+  EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), {1, 1, 7})));
+}
+
+#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
+
+TEST(UnorderedPointwiseTest, RejectsWrongSize) {
+  const double lhs[2] = {1, 2};
+  const int rhs[1] = {0};
+  EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs)));
+  EXPECT_EQ("which has 2 elements",
+            Explain(UnorderedPointwise(Gt(), rhs), lhs));
+
+  const int rhs2[3] = {0, 1, 2};
+  EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs2)));
+}
+
+TEST(UnorderedPointwiseTest, RejectsWrongContent) {
+  const double lhs[3] = {1, 2, 3};
+  const int rhs[3] = {2, 6, 6};
+  EXPECT_THAT(lhs, Not(UnorderedPointwise(IsHalfOf(), rhs)));
+  EXPECT_EQ("where the following elements don't match any matchers:\n"
+            "element #1: 2",
+            Explain(UnorderedPointwise(IsHalfOf(), rhs), lhs));
+}
+
+TEST(UnorderedPointwiseTest, AcceptsCorrectContentInSameOrder) {
+  const double lhs[3] = {1, 2, 3};
+  const int rhs[3] = {2, 4, 6};
+  EXPECT_THAT(lhs, UnorderedPointwise(IsHalfOf(), rhs));
+}
+
+TEST(UnorderedPointwiseTest, AcceptsCorrectContentInDifferentOrder) {
+  const double lhs[3] = {1, 2, 3};
+  const int rhs[3] = {6, 4, 2};
+  EXPECT_THAT(lhs, UnorderedPointwise(IsHalfOf(), rhs));
+}
+
+TEST(UnorderedPointwiseTest, AllowsMonomorphicInnerMatcher) {
+  const double lhs[3] = {1, 2, 3};
+  const int rhs[3] = {4, 6, 2};
+  const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf();
+  EXPECT_THAT(lhs, UnorderedPointwise(m1, rhs));
+
+  // This type works as a tuple<const double&, const int&> can be
+  // implicitly cast to tuple<double, int>.
+  const Matcher<tuple<double, int> > m2 = IsHalfOf();
+  EXPECT_THAT(lhs, UnorderedPointwise(m2, rhs));
+}
+
+}  // namespace gmock_matchers_test
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-more-actions_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-more-actions_test.cc
new file mode 100644
index 00000000..77e15bd5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-more-actions_test.cc
@@ -0,0 +1,708 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests the built-in actions in gmock-more-actions.h.
+
+#include "gmock/gmock-more-actions.h"
+
+#include <functional>
+#include <sstream>
+#include <string>
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "gtest/internal/gtest-linked_ptr.h"
+
+namespace testing {
+namespace gmock_more_actions_test {
+
+using ::std::plus;
+using ::std::string;
+using testing::get;
+using testing::make_tuple;
+using testing::tuple;
+using testing::tuple_element;
+using testing::_;
+using testing::Action;
+using testing::ActionInterface;
+using testing::DeleteArg;
+using testing::Invoke;
+using testing::Return;
+using testing::ReturnArg;
+using testing::ReturnPointee;
+using testing::SaveArg;
+using testing::SaveArgPointee;
+using testing::SetArgReferee;
+using testing::StaticAssertTypeEq;
+using testing::Unused;
+using testing::WithArg;
+using testing::WithoutArgs;
+using testing::internal::linked_ptr;
+
+// For suppressing compiler warnings on conversion possibly losing precision.
+inline short Short(short n) { return n; }  // NOLINT
+inline char Char(char ch) { return ch; }
+
+// Sample functions and functors for testing Invoke() and etc.
+int Nullary() { return 1; }
+
+class NullaryFunctor {
+ public:
+  int operator()() { return 2; }
+};
+
+bool g_done = false;
+void VoidNullary() { g_done = true; }
+
+class VoidNullaryFunctor {
+ public:
+  void operator()() { g_done = true; }
+};
+
+bool Unary(int x) { return x < 0; }
+
+const char* Plus1(const char* s) { return s + 1; }
+
+void VoidUnary(int /* n */) { g_done = true; }
+
+bool ByConstRef(const string& s) { return s == "Hi"; }
+
+const double g_double = 0;
+bool ReferencesGlobalDouble(const double& x) { return &x == &g_double; }
+
+string ByNonConstRef(string& s) { return s += "+"; }  // NOLINT
+
+struct UnaryFunctor {
+  int operator()(bool x) { return x ? 1 : -1; }
+};
+
+const char* Binary(const char* input, short n) { return input + n; }  // NOLINT
+
+void VoidBinary(int, char) { g_done = true; }
+
+int Ternary(int x, char y, short z) { return x + y + z; }  // NOLINT
+
+void VoidTernary(int, char, bool) { g_done = true; }
+
+int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }
+
+int SumOfFirst2(int a, int b, Unused, Unused) { return a + b; }
+
+void VoidFunctionWithFourArguments(char, int, float, double) { g_done = true; }
+
+string Concat4(const char* s1, const char* s2, const char* s3,
+               const char* s4) {
+  return string(s1) + s2 + s3 + s4;
+}
+
+int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d + e; }
+
+struct SumOf5Functor {
+  int operator()(int a, int b, int c, int d, int e) {
+    return a + b + c + d + e;
+  }
+};
+
+string Concat5(const char* s1, const char* s2, const char* s3,
+               const char* s4, const char* s5) {
+  return string(s1) + s2 + s3 + s4 + s5;
+}
+
+int SumOf6(int a, int b, int c, int d, int e, int f) {
+  return a + b + c + d + e + f;
+}
+
+struct SumOf6Functor {
+  int operator()(int a, int b, int c, int d, int e, int f) {
+    return a + b + c + d + e + f;
+  }
+};
+
+string Concat6(const char* s1, const char* s2, const char* s3,
+               const char* s4, const char* s5, const char* s6) {
+  return string(s1) + s2 + s3 + s4 + s5 + s6;
+}
+
+string Concat7(const char* s1, const char* s2, const char* s3,
+               const char* s4, const char* s5, const char* s6,
+               const char* s7) {
+  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7;
+}
+
+string Concat8(const char* s1, const char* s2, const char* s3,
+               const char* s4, const char* s5, const char* s6,
+               const char* s7, const char* s8) {
+  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8;
+}
+
+string Concat9(const char* s1, const char* s2, const char* s3,
+               const char* s4, const char* s5, const char* s6,
+               const char* s7, const char* s8, const char* s9) {
+  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9;
+}
+
+string Concat10(const char* s1, const char* s2, const char* s3,
+                const char* s4, const char* s5, const char* s6,
+                const char* s7, const char* s8, const char* s9,
+                const char* s10) {
+  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10;
+}
+
+class Foo {
+ public:
+  Foo() : value_(123) {}
+
+  int Nullary() const { return value_; }
+
+  short Unary(long x) { return static_cast<short>(value_ + x); }  // NOLINT
+
+  string Binary(const string& str, char c) const { return str + c; }
+
+  int Ternary(int x, bool y, char z) { return value_ + x + y*z; }
+
+  int SumOf4(int a, int b, int c, int d) const {
+    return a + b + c + d + value_;
+  }
+
+  int SumOfLast2(Unused, Unused, int a, int b) const { return a + b; }
+
+  int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d + e; }
+
+  int SumOf6(int a, int b, int c, int d, int e, int f) {
+    return a + b + c + d + e + f;
+  }
+
+  string Concat7(const char* s1, const char* s2, const char* s3,
+                 const char* s4, const char* s5, const char* s6,
+                 const char* s7) {
+    return string(s1) + s2 + s3 + s4 + s5 + s6 + s7;
+  }
+
+  string Concat8(const char* s1, const char* s2, const char* s3,
+                 const char* s4, const char* s5, const char* s6,
+                 const char* s7, const char* s8) {
+    return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8;
+  }
+
+  string Concat9(const char* s1, const char* s2, const char* s3,
+                 const char* s4, const char* s5, const char* s6,
+                 const char* s7, const char* s8, const char* s9) {
+    return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9;
+  }
+
+  string Concat10(const char* s1, const char* s2, const char* s3,
+                  const char* s4, const char* s5, const char* s6,
+                  const char* s7, const char* s8, const char* s9,
+                  const char* s10) {
+    return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10;
+  }
+
+ private:
+  int value_;
+};
+
+// Tests using Invoke() with a nullary function.
+TEST(InvokeTest, Nullary) {
+  Action<int()> a = Invoke(Nullary);  // NOLINT
+  EXPECT_EQ(1, a.Perform(make_tuple()));
+}
+
+// Tests using Invoke() with a unary function.
+TEST(InvokeTest, Unary) {
+  Action<bool(int)> a = Invoke(Unary);  // NOLINT
+  EXPECT_FALSE(a.Perform(make_tuple(1)));
+  EXPECT_TRUE(a.Perform(make_tuple(-1)));
+}
+
+// Tests using Invoke() with a binary function.
+TEST(InvokeTest, Binary) {
+  Action<const char*(const char*, short)> a = Invoke(Binary);  // NOLINT
+  const char* p = "Hello";
+  EXPECT_EQ(p + 2, a.Perform(make_tuple(p, Short(2))));
+}
+
+// Tests using Invoke() with a ternary function.
+TEST(InvokeTest, Ternary) {
+  Action<int(int, char, short)> a = Invoke(Ternary);  // NOLINT
+  EXPECT_EQ(6, a.Perform(make_tuple(1, '\2', Short(3))));
+}
+
+// Tests using Invoke() with a 4-argument function.
+TEST(InvokeTest, FunctionThatTakes4Arguments) {
+  Action<int(int, int, int, int)> a = Invoke(SumOf4);  // NOLINT
+  EXPECT_EQ(1234, a.Perform(make_tuple(1000, 200, 30, 4)));
+}
+
+// Tests using Invoke() with a 5-argument function.
+TEST(InvokeTest, FunctionThatTakes5Arguments) {
+  Action<int(int, int, int, int, int)> a = Invoke(SumOf5);  // NOLINT
+  EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5)));
+}
+
+// Tests using Invoke() with a 6-argument function.
+TEST(InvokeTest, FunctionThatTakes6Arguments) {
+  Action<int(int, int, int, int, int, int)> a = Invoke(SumOf6);  // NOLINT
+  EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6)));
+}
+
+// A helper that turns the type of a C-string literal from const
+// char[N] to const char*.
+inline const char* CharPtr(const char* s) { return s; }
+
+// Tests using Invoke() with a 7-argument function.
+TEST(InvokeTest, FunctionThatTakes7Arguments) {
+  Action<string(const char*, const char*, const char*, const char*,
+                const char*, const char*, const char*)> a =
+      Invoke(Concat7);
+  EXPECT_EQ("1234567",
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"))));
+}
+
+// Tests using Invoke() with a 8-argument function.
+TEST(InvokeTest, FunctionThatTakes8Arguments) {
+  Action<string(const char*, const char*, const char*, const char*,
+                const char*, const char*, const char*, const char*)> a =
+      Invoke(Concat8);
+  EXPECT_EQ("12345678",
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"), CharPtr("8"))));
+}
+
+// Tests using Invoke() with a 9-argument function.
+TEST(InvokeTest, FunctionThatTakes9Arguments) {
+  Action<string(const char*, const char*, const char*, const char*,
+                const char*, const char*, const char*, const char*,
+                const char*)> a = Invoke(Concat9);
+  EXPECT_EQ("123456789",
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"), CharPtr("8"), CharPtr("9"))));
+}
+
+// Tests using Invoke() with a 10-argument function.
+TEST(InvokeTest, FunctionThatTakes10Arguments) {
+  Action<string(const char*, const char*, const char*, const char*,
+                const char*, const char*, const char*, const char*,
+                const char*, const char*)> a = Invoke(Concat10);
+  EXPECT_EQ("1234567890",
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"), CharPtr("8"), CharPtr("9"),
+                                 CharPtr("0"))));
+}
+
+// Tests using Invoke() with functions with parameters declared as Unused.
+TEST(InvokeTest, FunctionWithUnusedParameters) {
+  Action<int(int, int, double, const string&)> a1 =
+      Invoke(SumOfFirst2);
+  string s("hi");
+  EXPECT_EQ(12, a1.Perform(
+    tuple<int, int, double, const string&>(10, 2, 5.6, s)));
+
+  Action<int(int, int, bool, int*)> a2 =
+      Invoke(SumOfFirst2);
+  EXPECT_EQ(23, a2.Perform(make_tuple(20, 3, true, static_cast<int*>(NULL))));
+}
+
+// Tests using Invoke() with methods with parameters declared as Unused.
+TEST(InvokeTest, MethodWithUnusedParameters) {
+  Foo foo;
+  Action<int(string, bool, int, int)> a1 =
+      Invoke(&foo, &Foo::SumOfLast2);
+  EXPECT_EQ(12, a1.Perform(make_tuple(CharPtr("hi"), true, 10, 2)));
+
+  Action<int(char, double, int, int)> a2 =
+      Invoke(&foo, &Foo::SumOfLast2);
+  EXPECT_EQ(23, a2.Perform(make_tuple('a', 2.5, 20, 3)));
+}
+
+// Tests using Invoke() with a functor.
+TEST(InvokeTest, Functor) {
+  Action<long(long, int)> a = Invoke(plus<long>());  // NOLINT
+  EXPECT_EQ(3L, a.Perform(make_tuple(1, 2)));
+}
+
+// Tests using Invoke(f) as an action of a compatible type.
+TEST(InvokeTest, FunctionWithCompatibleType) {
+  Action<long(int, short, char, bool)> a = Invoke(SumOf4);  // NOLINT
+  EXPECT_EQ(4321, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
+}
+
+// Tests using Invoke() with an object pointer and a method pointer.
+
+// Tests using Invoke() with a nullary method.
+TEST(InvokeMethodTest, Nullary) {
+  Foo foo;
+  Action<int()> a = Invoke(&foo, &Foo::Nullary);  // NOLINT
+  EXPECT_EQ(123, a.Perform(make_tuple()));
+}
+
+// Tests using Invoke() with a unary method.
+TEST(InvokeMethodTest, Unary) {
+  Foo foo;
+  Action<short(long)> a = Invoke(&foo, &Foo::Unary);  // NOLINT
+  EXPECT_EQ(4123, a.Perform(make_tuple(4000)));
+}
+
+// Tests using Invoke() with a binary method.
+TEST(InvokeMethodTest, Binary) {
+  Foo foo;
+  Action<string(const string&, char)> a = Invoke(&foo, &Foo::Binary);
+  string s("Hell");
+  EXPECT_EQ("Hello", a.Perform(
+      tuple<const string&, char>(s, 'o')));
+}
+
+// Tests using Invoke() with a ternary method.
+TEST(InvokeMethodTest, Ternary) {
+  Foo foo;
+  Action<int(int, bool, char)> a = Invoke(&foo, &Foo::Ternary);  // NOLINT
+  EXPECT_EQ(1124, a.Perform(make_tuple(1000, true, Char(1))));
+}
+
+// Tests using Invoke() with a 4-argument method.
+TEST(InvokeMethodTest, MethodThatTakes4Arguments) {
+  Foo foo;
+  Action<int(int, int, int, int)> a = Invoke(&foo, &Foo::SumOf4);  // NOLINT
+  EXPECT_EQ(1357, a.Perform(make_tuple(1000, 200, 30, 4)));
+}
+
+// Tests using Invoke() with a 5-argument method.
+TEST(InvokeMethodTest, MethodThatTakes5Arguments) {
+  Foo foo;
+  Action<int(int, int, int, int, int)> a = Invoke(&foo, &Foo::SumOf5);  // NOLINT
+  EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5)));
+}
+
+// Tests using Invoke() with a 6-argument method.
+TEST(InvokeMethodTest, MethodThatTakes6Arguments) {
+  Foo foo;
+  Action<int(int, int, int, int, int, int)> a =  // NOLINT
+      Invoke(&foo, &Foo::SumOf6);
+  EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6)));
+}
+
+// Tests using Invoke() with a 7-argument method.
+TEST(InvokeMethodTest, MethodThatTakes7Arguments) {
+  Foo foo;
+  Action<string(const char*, const char*, const char*, const char*,
+                const char*, const char*, const char*)> a =
+      Invoke(&foo, &Foo::Concat7);
+  EXPECT_EQ("1234567",
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"))));
+}
+
+// Tests using Invoke() with a 8-argument method.
+TEST(InvokeMethodTest, MethodThatTakes8Arguments) {
+  Foo foo;
+  Action<string(const char*, const char*, const char*, const char*,
+                const char*, const char*, const char*, const char*)> a =
+      Invoke(&foo, &Foo::Concat8);
+  EXPECT_EQ("12345678",
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"), CharPtr("8"))));
+}
+
+// Tests using Invoke() with a 9-argument method.
+TEST(InvokeMethodTest, MethodThatTakes9Arguments) {
+  Foo foo;
+  Action<string(const char*, const char*, const char*, const char*,
+                const char*, const char*, const char*, const char*,
+                const char*)> a = Invoke(&foo, &Foo::Concat9);
+  EXPECT_EQ("123456789",
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"), CharPtr("8"), CharPtr("9"))));
+}
+
+// Tests using Invoke() with a 10-argument method.
+TEST(InvokeMethodTest, MethodThatTakes10Arguments) {
+  Foo foo;
+  Action<string(const char*, const char*, const char*, const char*,
+                const char*, const char*, const char*, const char*,
+                const char*, const char*)> a = Invoke(&foo, &Foo::Concat10);
+  EXPECT_EQ("1234567890",
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"), CharPtr("8"), CharPtr("9"),
+                                 CharPtr("0"))));
+}
+
+// Tests using Invoke(f) as an action of a compatible type.
+TEST(InvokeMethodTest, MethodWithCompatibleType) {
+  Foo foo;
+  Action<long(int, short, char, bool)> a =  // NOLINT
+      Invoke(&foo, &Foo::SumOf4);
+  EXPECT_EQ(4444, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
+}
+
+// Tests using WithoutArgs with an action that takes no argument.
+TEST(WithoutArgsTest, NoArg) {
+  Action<int(int n)> a = WithoutArgs(Invoke(Nullary));  // NOLINT
+  EXPECT_EQ(1, a.Perform(make_tuple(2)));
+}
+
+// Tests using WithArg with an action that takes 1 argument.
+TEST(WithArgTest, OneArg) {
+  Action<bool(double x, int n)> b = WithArg<1>(Invoke(Unary));  // NOLINT
+  EXPECT_TRUE(b.Perform(make_tuple(1.5, -1)));
+  EXPECT_FALSE(b.Perform(make_tuple(1.5, 1)));
+}
+
+TEST(ReturnArgActionTest, WorksForOneArgIntArg0) {
+  const Action<int(int)> a = ReturnArg<0>();
+  EXPECT_EQ(5, a.Perform(make_tuple(5)));
+}
+
+TEST(ReturnArgActionTest, WorksForMultiArgBoolArg0) {
+  const Action<bool(bool, bool, bool)> a = ReturnArg<0>();
+  EXPECT_TRUE(a.Perform(make_tuple(true, false, false)));
+}
+
+TEST(ReturnArgActionTest, WorksForMultiArgStringArg2) {
+  const Action<string(int, int, string, int)> a = ReturnArg<2>();
+  EXPECT_EQ("seven", a.Perform(make_tuple(5, 6, string("seven"), 8)));
+}
+
+TEST(SaveArgActionTest, WorksForSameType) {
+  int result = 0;
+  const Action<void(int n)> a1 = SaveArg<0>(&result);
+  a1.Perform(make_tuple(5));
+  EXPECT_EQ(5, result);
+}
+
+TEST(SaveArgActionTest, WorksForCompatibleType) {
+  int result = 0;
+  const Action<void(bool, char)> a1 = SaveArg<1>(&result);
+  a1.Perform(make_tuple(true, 'a'));
+  EXPECT_EQ('a', result);
+}
+
+TEST(SaveArgPointeeActionTest, WorksForSameType) {
+  int result = 0;
+  const int value = 5;
+  const Action<void(const int*)> a1 = SaveArgPointee<0>(&result);
+  a1.Perform(make_tuple(&value));
+  EXPECT_EQ(5, result);
+}
+
+TEST(SaveArgPointeeActionTest, WorksForCompatibleType) {
+  int result = 0;
+  char value = 'a';
+  const Action<void(bool, char*)> a1 = SaveArgPointee<1>(&result);
+  a1.Perform(make_tuple(true, &value));
+  EXPECT_EQ('a', result);
+}
+
+TEST(SaveArgPointeeActionTest, WorksForLinkedPtr) {
+  int result = 0;
+  linked_ptr<int> value(new int(5));
+  const Action<void(linked_ptr<int>)> a1 = SaveArgPointee<0>(&result);
+  a1.Perform(make_tuple(value));
+  EXPECT_EQ(5, result);
+}
+
+TEST(SetArgRefereeActionTest, WorksForSameType) {
+  int value = 0;
+  const Action<void(int&)> a1 = SetArgReferee<0>(1);
+  a1.Perform(tuple<int&>(value));
+  EXPECT_EQ(1, value);
+}
+
+TEST(SetArgRefereeActionTest, WorksForCompatibleType) {
+  int value = 0;
+  const Action<void(int, int&)> a1 = SetArgReferee<1>('a');
+  a1.Perform(tuple<int, int&>(0, value));
+  EXPECT_EQ('a', value);
+}
+
+TEST(SetArgRefereeActionTest, WorksWithExtraArguments) {
+  int value = 0;
+  const Action<void(bool, int, int&, const char*)> a1 = SetArgReferee<2>('a');
+  a1.Perform(tuple<bool, int, int&, const char*>(true, 0, value, "hi"));
+  EXPECT_EQ('a', value);
+}
+
+// A class that can be used to verify that its destructor is called: it will set
+// the bool provided to the constructor to true when destroyed.
+class DeletionTester {
+ public:
+  explicit DeletionTester(bool* is_deleted)
+    : is_deleted_(is_deleted) {
+    // Make sure the bit is set to false.
+    *is_deleted_ = false;
+  }
+
+  ~DeletionTester() {
+    *is_deleted_ = true;
+  }
+
+ private:
+  bool* is_deleted_;
+};
+
+TEST(DeleteArgActionTest, OneArg) {
+  bool is_deleted = false;
+  DeletionTester* t = new DeletionTester(&is_deleted);
+  const Action<void(DeletionTester*)> a1 = DeleteArg<0>();      // NOLINT
+  EXPECT_FALSE(is_deleted);
+  a1.Perform(make_tuple(t));
+  EXPECT_TRUE(is_deleted);
+}
+
+TEST(DeleteArgActionTest, TenArgs) {
+  bool is_deleted = false;
+  DeletionTester* t = new DeletionTester(&is_deleted);
+  const Action<void(bool, int, int, const char*, bool,
+                    int, int, int, int, DeletionTester*)> a1 = DeleteArg<9>();
+  EXPECT_FALSE(is_deleted);
+  a1.Perform(make_tuple(true, 5, 6, CharPtr("hi"), false, 7, 8, 9, 10, t));
+  EXPECT_TRUE(is_deleted);
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+TEST(ThrowActionTest, ThrowsGivenExceptionInVoidFunction) {
+  const Action<void(int n)> a = Throw('a');
+  EXPECT_THROW(a.Perform(make_tuple(0)), char);
+}
+
+class MyException {};
+
+TEST(ThrowActionTest, ThrowsGivenExceptionInNonVoidFunction) {
+  const Action<double(char ch)> a = Throw(MyException());
+  EXPECT_THROW(a.Perform(make_tuple('0')), MyException);
+}
+
+TEST(ThrowActionTest, ThrowsGivenExceptionInNullaryFunction) {
+  const Action<double()> a = Throw(MyException());
+  EXPECT_THROW(a.Perform(make_tuple()), MyException);
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// Tests that SetArrayArgument<N>(first, last) sets the elements of the array
+// pointed to by the N-th (0-based) argument to values in range [first, last).
+TEST(SetArrayArgumentTest, SetsTheNthArray) {
+  typedef void MyFunction(bool, int*, char*);
+  int numbers[] = { 1, 2, 3 };
+  Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers + 3);
+
+  int n[4] = {};
+  int* pn = n;
+  char ch[4] = {};
+  char* pch = ch;
+  a.Perform(make_tuple(true, pn, pch));
+  EXPECT_EQ(1, n[0]);
+  EXPECT_EQ(2, n[1]);
+  EXPECT_EQ(3, n[2]);
+  EXPECT_EQ(0, n[3]);
+  EXPECT_EQ('\0', ch[0]);
+  EXPECT_EQ('\0', ch[1]);
+  EXPECT_EQ('\0', ch[2]);
+  EXPECT_EQ('\0', ch[3]);
+
+  // Tests first and last are iterators.
+  std::string letters = "abc";
+  a = SetArrayArgument<2>(letters.begin(), letters.end());
+  std::fill_n(n, 4, 0);
+  std::fill_n(ch, 4, '\0');
+  a.Perform(make_tuple(true, pn, pch));
+  EXPECT_EQ(0, n[0]);
+  EXPECT_EQ(0, n[1]);
+  EXPECT_EQ(0, n[2]);
+  EXPECT_EQ(0, n[3]);
+  EXPECT_EQ('a', ch[0]);
+  EXPECT_EQ('b', ch[1]);
+  EXPECT_EQ('c', ch[2]);
+  EXPECT_EQ('\0', ch[3]);
+}
+
+// Tests SetArrayArgument<N>(first, last) where first == last.
+TEST(SetArrayArgumentTest, SetsTheNthArrayWithEmptyRange) {
+  typedef void MyFunction(bool, int*);
+  int numbers[] = { 1, 2, 3 };
+  Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers);
+
+  int n[4] = {};
+  int* pn = n;
+  a.Perform(make_tuple(true, pn));
+  EXPECT_EQ(0, n[0]);
+  EXPECT_EQ(0, n[1]);
+  EXPECT_EQ(0, n[2]);
+  EXPECT_EQ(0, n[3]);
+}
+
+// Tests SetArrayArgument<N>(first, last) where *first is convertible
+// (but not equal) to the argument type.
+TEST(SetArrayArgumentTest, SetsTheNthArrayWithConvertibleType) {
+  typedef void MyFunction(bool, int*);
+  char chars[] = { 97, 98, 99 };
+  Action<MyFunction> a = SetArrayArgument<1>(chars, chars + 3);
+
+  int codes[4] = { 111, 222, 333, 444 };
+  int* pcodes = codes;
+  a.Perform(make_tuple(true, pcodes));
+  EXPECT_EQ(97, codes[0]);
+  EXPECT_EQ(98, codes[1]);
+  EXPECT_EQ(99, codes[2]);
+  EXPECT_EQ(444, codes[3]);
+}
+
+// Test SetArrayArgument<N>(first, last) with iterator as argument.
+TEST(SetArrayArgumentTest, SetsTheNthArrayWithIteratorArgument) {
+  typedef void MyFunction(bool, std::back_insert_iterator<std::string>);
+  std::string letters = "abc";
+  Action<MyFunction> a = SetArrayArgument<1>(letters.begin(), letters.end());
+
+  std::string s;
+  a.Perform(make_tuple(true, back_inserter(s)));
+  EXPECT_EQ(letters, s);
+}
+
+TEST(ReturnPointeeTest, Works) {
+  int n = 42;
+  const Action<int()> a = ReturnPointee(&n);
+  EXPECT_EQ(42, a.Perform(make_tuple()));
+
+  n = 43;
+  EXPECT_EQ(43, a.Perform(make_tuple()));
+}
+
+}  // namespace gmock_generated_actions_test
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-nice-strict_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-nice-strict_test.cc
new file mode 100644
index 00000000..d0adcbbe
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-nice-strict_test.cc
@@ -0,0 +1,424 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "gmock/gmock-generated-nice-strict.h"
+
+#include <string>
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "gtest/gtest-spi.h"
+
+// This must not be defined inside the ::testing namespace, or it will
+// clash with ::testing::Mock.
+class Mock {
+ public:
+  Mock() {}
+
+  MOCK_METHOD0(DoThis, void());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
+};
+
+namespace testing {
+namespace gmock_nice_strict_test {
+
+using testing::internal::string;
+using testing::GMOCK_FLAG(verbose);
+using testing::HasSubstr;
+using testing::NaggyMock;
+using testing::NiceMock;
+using testing::StrictMock;
+
+#if GTEST_HAS_STREAM_REDIRECTION
+using testing::internal::CaptureStdout;
+using testing::internal::GetCapturedStdout;
+#endif
+
+// Defines some mock classes needed by the tests.
+
+class Foo {
+ public:
+  virtual ~Foo() {}
+
+  virtual void DoThis() = 0;
+  virtual int DoThat(bool flag) = 0;
+};
+
+class MockFoo : public Foo {
+ public:
+  MockFoo() {}
+  void Delete() { delete this; }
+
+  MOCK_METHOD0(DoThis, void());
+  MOCK_METHOD1(DoThat, int(bool flag));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
+};
+
+class MockBar {
+ public:
+  explicit MockBar(const string& s) : str_(s) {}
+
+  MockBar(char a1, char a2, string a3, string a4, int a5, int a6,
+          const string& a7, const string& a8, bool a9, bool a10) {
+    str_ = string() + a1 + a2 + a3 + a4 + static_cast<char>(a5) +
+        static_cast<char>(a6) + a7 + a8 + (a9 ? 'T' : 'F') + (a10 ? 'T' : 'F');
+  }
+
+  virtual ~MockBar() {}
+
+  const string& str() const { return str_; }
+
+  MOCK_METHOD0(This, int());
+  MOCK_METHOD2(That, string(int, bool));
+
+ private:
+  string str_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockBar);
+};
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Tests that a raw mock generates warnings for uninteresting calls.
+TEST(RawMockTest, WarningForUninterestingCall) {
+  const string saved_flag = GMOCK_FLAG(verbose);
+  GMOCK_FLAG(verbose) = "warning";
+
+  MockFoo raw_foo;
+
+  CaptureStdout();
+  raw_foo.DoThis();
+  raw_foo.DoThat(true);
+  EXPECT_THAT(GetCapturedStdout(),
+              HasSubstr("Uninteresting mock function call"));
+
+  GMOCK_FLAG(verbose) = saved_flag;
+}
+
+// Tests that a raw mock generates warnings for uninteresting calls
+// that delete the mock object.
+TEST(RawMockTest, WarningForUninterestingCallAfterDeath) {
+  const string saved_flag = GMOCK_FLAG(verbose);
+  GMOCK_FLAG(verbose) = "warning";
+
+  MockFoo* const raw_foo = new MockFoo;
+
+  ON_CALL(*raw_foo, DoThis())
+      .WillByDefault(Invoke(raw_foo, &MockFoo::Delete));
+
+  CaptureStdout();
+  raw_foo->DoThis();
+  EXPECT_THAT(GetCapturedStdout(),
+              HasSubstr("Uninteresting mock function call"));
+
+  GMOCK_FLAG(verbose) = saved_flag;
+}
+
+// Tests that a raw mock generates informational logs for
+// uninteresting calls.
+TEST(RawMockTest, InfoForUninterestingCall) {
+  MockFoo raw_foo;
+
+  const string saved_flag = GMOCK_FLAG(verbose);
+  GMOCK_FLAG(verbose) = "info";
+  CaptureStdout();
+  raw_foo.DoThis();
+  EXPECT_THAT(GetCapturedStdout(),
+              HasSubstr("Uninteresting mock function call"));
+
+  GMOCK_FLAG(verbose) = saved_flag;
+}
+
+// Tests that a nice mock generates no warning for uninteresting calls.
+TEST(NiceMockTest, NoWarningForUninterestingCall) {
+  NiceMock<MockFoo> nice_foo;
+
+  CaptureStdout();
+  nice_foo.DoThis();
+  nice_foo.DoThat(true);
+  EXPECT_EQ("", GetCapturedStdout());
+}
+
+// Tests that a nice mock generates no warning for uninteresting calls
+// that delete the mock object.
+TEST(NiceMockTest, NoWarningForUninterestingCallAfterDeath) {
+  NiceMock<MockFoo>* const nice_foo = new NiceMock<MockFoo>;
+
+  ON_CALL(*nice_foo, DoThis())
+      .WillByDefault(Invoke(nice_foo, &MockFoo::Delete));
+
+  CaptureStdout();
+  nice_foo->DoThis();
+  EXPECT_EQ("", GetCapturedStdout());
+}
+
+// Tests that a nice mock generates informational logs for
+// uninteresting calls.
+TEST(NiceMockTest, InfoForUninterestingCall) {
+  NiceMock<MockFoo> nice_foo;
+
+  const string saved_flag = GMOCK_FLAG(verbose);
+  GMOCK_FLAG(verbose) = "info";
+  CaptureStdout();
+  nice_foo.DoThis();
+  EXPECT_THAT(GetCapturedStdout(),
+              HasSubstr("Uninteresting mock function call"));
+
+  GMOCK_FLAG(verbose) = saved_flag;
+}
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// Tests that a nice mock allows expected calls.
+TEST(NiceMockTest, AllowsExpectedCall) {
+  NiceMock<MockFoo> nice_foo;
+
+  EXPECT_CALL(nice_foo, DoThis());
+  nice_foo.DoThis();
+}
+
+// Tests that an unexpected call on a nice mock fails.
+TEST(NiceMockTest, UnexpectedCallFails) {
+  NiceMock<MockFoo> nice_foo;
+
+  EXPECT_CALL(nice_foo, DoThis()).Times(0);
+  EXPECT_NONFATAL_FAILURE(nice_foo.DoThis(), "called more times than expected");
+}
+
+// Tests that NiceMock works with a mock class that has a non-default
+// constructor.
+TEST(NiceMockTest, NonDefaultConstructor) {
+  NiceMock<MockBar> nice_bar("hi");
+  EXPECT_EQ("hi", nice_bar.str());
+
+  nice_bar.This();
+  nice_bar.That(5, true);
+}
+
+// Tests that NiceMock works with a mock class that has a 10-ary
+// non-default constructor.
+TEST(NiceMockTest, NonDefaultConstructor10) {
+  NiceMock<MockBar> nice_bar('a', 'b', "c", "d", 'e', 'f',
+                             "g", "h", true, false);
+  EXPECT_EQ("abcdefghTF", nice_bar.str());
+
+  nice_bar.This();
+  nice_bar.That(5, true);
+}
+
+#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
+// Tests that NiceMock<Mock> compiles where Mock is a user-defined
+// class (as opposed to ::testing::Mock).  We had to work around an
+// MSVC 8.0 bug that caused the symbol Mock used in the definition of
+// NiceMock to be looked up in the wrong context, and this test
+// ensures that our fix works.
+//
+// We have to skip this test on Symbian and Windows Mobile, as it
+// causes the program to crash there, for reasons unclear to us yet.
+TEST(NiceMockTest, AcceptsClassNamedMock) {
+  NiceMock< ::Mock> nice;
+  EXPECT_CALL(nice, DoThis());
+  nice.DoThis();
+}
+#endif  // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Tests that a naggy mock generates warnings for uninteresting calls.
+TEST(NaggyMockTest, WarningForUninterestingCall) {
+  const string saved_flag = GMOCK_FLAG(verbose);
+  GMOCK_FLAG(verbose) = "warning";
+
+  NaggyMock<MockFoo> naggy_foo;
+
+  CaptureStdout();
+  naggy_foo.DoThis();
+  naggy_foo.DoThat(true);
+  EXPECT_THAT(GetCapturedStdout(),
+              HasSubstr("Uninteresting mock function call"));
+
+  GMOCK_FLAG(verbose) = saved_flag;
+}
+
+// Tests that a naggy mock generates a warning for an uninteresting call
+// that deletes the mock object.
+TEST(NaggyMockTest, WarningForUninterestingCallAfterDeath) {
+  const string saved_flag = GMOCK_FLAG(verbose);
+  GMOCK_FLAG(verbose) = "warning";
+
+  NaggyMock<MockFoo>* const naggy_foo = new NaggyMock<MockFoo>;
+
+  ON_CALL(*naggy_foo, DoThis())
+      .WillByDefault(Invoke(naggy_foo, &MockFoo::Delete));
+
+  CaptureStdout();
+  naggy_foo->DoThis();
+  EXPECT_THAT(GetCapturedStdout(),
+              HasSubstr("Uninteresting mock function call"));
+
+  GMOCK_FLAG(verbose) = saved_flag;
+}
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// Tests that a naggy mock allows expected calls.
+TEST(NaggyMockTest, AllowsExpectedCall) {
+  NaggyMock<MockFoo> naggy_foo;
+
+  EXPECT_CALL(naggy_foo, DoThis());
+  naggy_foo.DoThis();
+}
+
+// Tests that an unexpected call on a naggy mock fails.
+TEST(NaggyMockTest, UnexpectedCallFails) {
+  NaggyMock<MockFoo> naggy_foo;
+
+  EXPECT_CALL(naggy_foo, DoThis()).Times(0);
+  EXPECT_NONFATAL_FAILURE(naggy_foo.DoThis(),
+                          "called more times than expected");
+}
+
+// Tests that NaggyMock works with a mock class that has a non-default
+// constructor.
+TEST(NaggyMockTest, NonDefaultConstructor) {
+  NaggyMock<MockBar> naggy_bar("hi");
+  EXPECT_EQ("hi", naggy_bar.str());
+
+  naggy_bar.This();
+  naggy_bar.That(5, true);
+}
+
+// Tests that NaggyMock works with a mock class that has a 10-ary
+// non-default constructor.
+TEST(NaggyMockTest, NonDefaultConstructor10) {
+  NaggyMock<MockBar> naggy_bar('0', '1', "2", "3", '4', '5',
+                               "6", "7", true, false);
+  EXPECT_EQ("01234567TF", naggy_bar.str());
+
+  naggy_bar.This();
+  naggy_bar.That(5, true);
+}
+
+#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
+// Tests that NaggyMock<Mock> compiles where Mock is a user-defined
+// class (as opposed to ::testing::Mock).  We had to work around an
+// MSVC 8.0 bug that caused the symbol Mock used in the definition of
+// NaggyMock to be looked up in the wrong context, and this test
+// ensures that our fix works.
+//
+// We have to skip this test on Symbian and Windows Mobile, as it
+// causes the program to crash there, for reasons unclear to us yet.
+TEST(NaggyMockTest, AcceptsClassNamedMock) {
+  NaggyMock< ::Mock> naggy;
+  EXPECT_CALL(naggy, DoThis());
+  naggy.DoThis();
+}
+#endif  // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
+
+// Tests that a strict mock allows expected calls.
+TEST(StrictMockTest, AllowsExpectedCall) {
+  StrictMock<MockFoo> strict_foo;
+
+  EXPECT_CALL(strict_foo, DoThis());
+  strict_foo.DoThis();
+}
+
+// Tests that an unexpected call on a strict mock fails.
+TEST(StrictMockTest, UnexpectedCallFails) {
+  StrictMock<MockFoo> strict_foo;
+
+  EXPECT_CALL(strict_foo, DoThis()).Times(0);
+  EXPECT_NONFATAL_FAILURE(strict_foo.DoThis(),
+                          "called more times than expected");
+}
+
+// Tests that an uninteresting call on a strict mock fails.
+TEST(StrictMockTest, UninterestingCallFails) {
+  StrictMock<MockFoo> strict_foo;
+
+  EXPECT_NONFATAL_FAILURE(strict_foo.DoThis(),
+                          "Uninteresting mock function call");
+}
+
+// Tests that an uninteresting call on a strict mock fails, even if
+// the call deletes the mock object.
+TEST(StrictMockTest, UninterestingCallFailsAfterDeath) {
+  StrictMock<MockFoo>* const strict_foo = new StrictMock<MockFoo>;
+
+  ON_CALL(*strict_foo, DoThis())
+      .WillByDefault(Invoke(strict_foo, &MockFoo::Delete));
+
+  EXPECT_NONFATAL_FAILURE(strict_foo->DoThis(),
+                          "Uninteresting mock function call");
+}
+
+// Tests that StrictMock works with a mock class that has a
+// non-default constructor.
+TEST(StrictMockTest, NonDefaultConstructor) {
+  StrictMock<MockBar> strict_bar("hi");
+  EXPECT_EQ("hi", strict_bar.str());
+
+  EXPECT_NONFATAL_FAILURE(strict_bar.That(5, true),
+                          "Uninteresting mock function call");
+}
+
+// Tests that StrictMock works with a mock class that has a 10-ary
+// non-default constructor.
+TEST(StrictMockTest, NonDefaultConstructor10) {
+  StrictMock<MockBar> strict_bar('a', 'b', "c", "d", 'e', 'f',
+                                 "g", "h", true, false);
+  EXPECT_EQ("abcdefghTF", strict_bar.str());
+
+  EXPECT_NONFATAL_FAILURE(strict_bar.That(5, true),
+                          "Uninteresting mock function call");
+}
+
+#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
+// Tests that StrictMock<Mock> compiles where Mock is a user-defined
+// class (as opposed to ::testing::Mock).  We had to work around an
+// MSVC 8.0 bug that caused the symbol Mock used in the definition of
+// StrictMock to be looked up in the wrong context, and this test
+// ensures that our fix works.
+//
+// We have to skip this test on Symbian and Windows Mobile, as it
+// causes the program to crash there, for reasons unclear to us yet.
+TEST(StrictMockTest, AcceptsClassNamedMock) {
+  StrictMock< ::Mock> strict;
+  EXPECT_CALL(strict, DoThis());
+  strict.DoThis();
+}
+#endif  // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
+
+}  // namespace gmock_nice_strict_test
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-port_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-port_test.cc
new file mode 100644
index 00000000..d6a8d444
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-port_test.cc
@@ -0,0 +1,43 @@
+// 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests the internal cross-platform support utilities.
+
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+// NOTE: if this file is left without tests for some reason, put a dummy
+// test here to make references to symbols in the gtest library and avoid
+// 'undefined symbol' linker errors in gmock_main:
+
+TEST(DummyTest, Dummy) {}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-spec-builders_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-spec-builders_test.cc
new file mode 100644
index 00000000..59ea87c8
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-spec-builders_test.cc
@@ -0,0 +1,2644 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests the spec builder syntax.
+
+#include "gmock/gmock-spec-builders.h"
+
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+
+#include "gmock/gmock.h"
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+#include "gtest/gtest-spi.h"
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+namespace internal {
+
+// Helper class for testing the Expectation class template.
+class ExpectationTester {
+ public:
+  // Sets the call count of the given expectation to the given number.
+  void SetCallCount(int n, ExpectationBase* exp) {
+    exp->call_count_ = n;
+  }
+};
+
+}  // namespace internal
+}  // namespace testing
+
+namespace {
+
+using testing::_;
+using testing::AnyNumber;
+using testing::AtLeast;
+using testing::AtMost;
+using testing::Between;
+using testing::Cardinality;
+using testing::CardinalityInterface;
+using testing::ContainsRegex;
+using testing::Const;
+using testing::DoAll;
+using testing::DoDefault;
+using testing::Eq;
+using testing::Expectation;
+using testing::ExpectationSet;
+using testing::GMOCK_FLAG(verbose);
+using testing::Gt;
+using testing::InSequence;
+using testing::Invoke;
+using testing::InvokeWithoutArgs;
+using testing::IsNotSubstring;
+using testing::IsSubstring;
+using testing::Lt;
+using testing::Message;
+using testing::Mock;
+using testing::NaggyMock;
+using testing::Ne;
+using testing::Return;
+using testing::Sequence;
+using testing::SetArgPointee;
+using testing::internal::ExpectationTester;
+using testing::internal::FormatFileLocation;
+using testing::internal::kErrorVerbosity;
+using testing::internal::kInfoVerbosity;
+using testing::internal::kWarningVerbosity;
+using testing::internal::linked_ptr;
+using testing::internal::string;
+
+#if GTEST_HAS_STREAM_REDIRECTION
+using testing::HasSubstr;
+using testing::internal::CaptureStdout;
+using testing::internal::GetCapturedStdout;
+#endif
+
+class Incomplete;
+
+class MockIncomplete {
+ public:
+  // This line verifies that a mock method can take a by-reference
+  // argument of an incomplete type.
+  MOCK_METHOD1(ByRefFunc, void(const Incomplete& x));
+};
+
+// Tells Google Mock how to print a value of type Incomplete.
+void PrintTo(const Incomplete& x, ::std::ostream* os);
+
+TEST(MockMethodTest, CanInstantiateWithIncompleteArgType) {
+  // Even though this mock class contains a mock method that takes
+  // by-reference an argument whose type is incomplete, we can still
+  // use the mock, as long as Google Mock knows how to print the
+  // argument.
+  MockIncomplete incomplete;
+  EXPECT_CALL(incomplete, ByRefFunc(_))
+      .Times(AnyNumber());
+}
+
+// The definition of the printer for the argument type doesn't have to
+// be visible where the mock is used.
+void PrintTo(const Incomplete& /* x */, ::std::ostream* os) {
+  *os << "incomplete";
+}
+
+class Result {};
+
+// A type that's not default constructible.
+class NonDefaultConstructible {
+ public:
+  explicit NonDefaultConstructible(int /* dummy */) {}
+};
+
+class MockA {
+ public:
+  MockA() {}
+
+  MOCK_METHOD1(DoA, void(int n));
+  MOCK_METHOD1(ReturnResult, Result(int n));
+  MOCK_METHOD0(ReturnNonDefaultConstructible, NonDefaultConstructible());
+  MOCK_METHOD2(Binary, bool(int x, int y));
+  MOCK_METHOD2(ReturnInt, int(int x, int y));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockA);
+};
+
+class MockB {
+ public:
+  MockB() {}
+
+  MOCK_CONST_METHOD0(DoB, int());  // NOLINT
+  MOCK_METHOD1(DoB, int(int n));  // NOLINT
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
+};
+
+class ReferenceHoldingMock {
+ public:
+  ReferenceHoldingMock() {}
+
+  MOCK_METHOD1(AcceptReference, void(linked_ptr<MockA>*));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ReferenceHoldingMock);
+};
+
+// Tests that EXPECT_CALL and ON_CALL compile in a presence of macro
+// redefining a mock method name. This could happen, for example, when
+// the tested code #includes Win32 API headers which define many APIs
+// as macros, e.g. #define TextOut TextOutW.
+
+#define Method MethodW
+
+class CC {
+ public:
+  virtual ~CC() {}
+  virtual int Method() = 0;
+};
+class MockCC : public CC {
+ public:
+  MockCC() {}
+
+  MOCK_METHOD0(Method, int());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockCC);
+};
+
+// Tests that a method with expanded name compiles.
+TEST(OnCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
+  MockCC cc;
+  ON_CALL(cc, Method());
+}
+
+// Tests that the method with expanded name not only compiles but runs
+// and returns a correct value, too.
+TEST(OnCallSyntaxTest, WorksWithMethodNameExpandedFromMacro) {
+  MockCC cc;
+  ON_CALL(cc, Method()).WillByDefault(Return(42));
+  EXPECT_EQ(42, cc.Method());
+}
+
+// Tests that a method with expanded name compiles.
+TEST(ExpectCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
+  MockCC cc;
+  EXPECT_CALL(cc, Method());
+  cc.Method();
+}
+
+// Tests that it works, too.
+TEST(ExpectCallSyntaxTest, WorksWithMethodNameExpandedFromMacro) {
+  MockCC cc;
+  EXPECT_CALL(cc, Method()).WillOnce(Return(42));
+  EXPECT_EQ(42, cc.Method());
+}
+
+#undef Method  // Done with macro redefinition tests.
+
+// Tests that ON_CALL evaluates its arguments exactly once as promised
+// by Google Mock.
+TEST(OnCallSyntaxTest, EvaluatesFirstArgumentOnce) {
+  MockA a;
+  MockA* pa = &a;
+
+  ON_CALL(*pa++, DoA(_));
+  EXPECT_EQ(&a + 1, pa);
+}
+
+TEST(OnCallSyntaxTest, EvaluatesSecondArgumentOnce) {
+  MockA a;
+  int n = 0;
+
+  ON_CALL(a, DoA(n++));
+  EXPECT_EQ(1, n);
+}
+
+// Tests that the syntax of ON_CALL() is enforced at run time.
+
+TEST(OnCallSyntaxTest, WithIsOptional) {
+  MockA a;
+
+  ON_CALL(a, DoA(5))
+      .WillByDefault(Return());
+  ON_CALL(a, DoA(_))
+      .With(_)
+      .WillByDefault(Return());
+}
+
+TEST(OnCallSyntaxTest, WithCanAppearAtMostOnce) {
+  MockA a;
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    ON_CALL(a, ReturnResult(_))
+        .With(_)
+        .With(_)
+        .WillByDefault(Return(Result()));
+  }, ".With() cannot appear more than once in an ON_CALL()");
+}
+
+TEST(OnCallSyntaxTest, WillByDefaultIsMandatory) {
+  MockA a;
+
+  EXPECT_DEATH_IF_SUPPORTED({
+    ON_CALL(a, DoA(5));
+    a.DoA(5);
+  }, "");
+}
+
+TEST(OnCallSyntaxTest, WillByDefaultCanAppearAtMostOnce) {
+  MockA a;
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    ON_CALL(a, DoA(5))
+        .WillByDefault(Return())
+        .WillByDefault(Return());
+  }, ".WillByDefault() must appear exactly once in an ON_CALL()");
+}
+
+// Tests that EXPECT_CALL evaluates its arguments exactly once as
+// promised by Google Mock.
+TEST(ExpectCallSyntaxTest, EvaluatesFirstArgumentOnce) {
+  MockA a;
+  MockA* pa = &a;
+
+  EXPECT_CALL(*pa++, DoA(_));
+  a.DoA(0);
+  EXPECT_EQ(&a + 1, pa);
+}
+
+TEST(ExpectCallSyntaxTest, EvaluatesSecondArgumentOnce) {
+  MockA a;
+  int n = 0;
+
+  EXPECT_CALL(a, DoA(n++));
+  a.DoA(0);
+  EXPECT_EQ(1, n);
+}
+
+// Tests that the syntax of EXPECT_CALL() is enforced at run time.
+
+TEST(ExpectCallSyntaxTest, WithIsOptional) {
+  MockA a;
+
+  EXPECT_CALL(a, DoA(5))
+      .Times(0);
+  EXPECT_CALL(a, DoA(6))
+      .With(_)
+      .Times(0);
+}
+
+TEST(ExpectCallSyntaxTest, WithCanAppearAtMostOnce) {
+  MockA a;
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_CALL(a, DoA(6))
+        .With(_)
+        .With(_);
+  }, ".With() cannot appear more than once in an EXPECT_CALL()");
+
+  a.DoA(6);
+}
+
+TEST(ExpectCallSyntaxTest, WithMustBeFirstClause) {
+  MockA a;
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_CALL(a, DoA(1))
+        .Times(1)
+        .With(_);
+  }, ".With() must be the first clause in an EXPECT_CALL()");
+
+  a.DoA(1);
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_CALL(a, DoA(2))
+        .WillOnce(Return())
+        .With(_);
+  }, ".With() must be the first clause in an EXPECT_CALL()");
+
+  a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, TimesCanBeInferred) {
+  MockA a;
+
+  EXPECT_CALL(a, DoA(1))
+      .WillOnce(Return());
+
+  EXPECT_CALL(a, DoA(2))
+      .WillOnce(Return())
+      .WillRepeatedly(Return());
+
+  a.DoA(1);
+  a.DoA(2);
+  a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, TimesCanAppearAtMostOnce) {
+  MockA a;
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_CALL(a, DoA(1))
+        .Times(1)
+        .Times(2);
+  }, ".Times() cannot appear more than once in an EXPECT_CALL()");
+
+  a.DoA(1);
+  a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, TimesMustBeBeforeInSequence) {
+  MockA a;
+  Sequence s;
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_CALL(a, DoA(1))
+        .InSequence(s)
+        .Times(1);
+  }, ".Times() cannot appear after ");
+
+  a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, InSequenceIsOptional) {
+  MockA a;
+  Sequence s;
+
+  EXPECT_CALL(a, DoA(1));
+  EXPECT_CALL(a, DoA(2))
+      .InSequence(s);
+
+  a.DoA(1);
+  a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, InSequenceCanAppearMultipleTimes) {
+  MockA a;
+  Sequence s1, s2;
+
+  EXPECT_CALL(a, DoA(1))
+      .InSequence(s1, s2)
+      .InSequence(s1);
+
+  a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeAfter) {
+  MockA a;
+  Sequence s;
+
+  Expectation e = EXPECT_CALL(a, DoA(1))
+      .Times(AnyNumber());
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_CALL(a, DoA(2))
+        .After(e)
+        .InSequence(s);
+  }, ".InSequence() cannot appear after ");
+
+  a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeWillOnce) {
+  MockA a;
+  Sequence s;
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_CALL(a, DoA(1))
+        .WillOnce(Return())
+        .InSequence(s);
+  }, ".InSequence() cannot appear after ");
+
+  a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, AfterMustBeBeforeWillOnce) {
+  MockA a;
+
+  Expectation e = EXPECT_CALL(a, DoA(1));
+  EXPECT_NONFATAL_FAILURE({
+    EXPECT_CALL(a, DoA(2))
+        .WillOnce(Return())
+        .After(e);
+  }, ".After() cannot appear after ");
+
+  a.DoA(1);
+  a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, WillIsOptional) {
+  MockA a;
+
+  EXPECT_CALL(a, DoA(1));
+  EXPECT_CALL(a, DoA(2))
+      .WillOnce(Return());
+
+  a.DoA(1);
+  a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, WillCanAppearMultipleTimes) {
+  MockA a;
+
+  EXPECT_CALL(a, DoA(1))
+      .Times(AnyNumber())
+      .WillOnce(Return())
+      .WillOnce(Return())
+      .WillOnce(Return());
+}
+
+TEST(ExpectCallSyntaxTest, WillMustBeBeforeWillRepeatedly) {
+  MockA a;
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_CALL(a, DoA(1))
+        .WillRepeatedly(Return())
+        .WillOnce(Return());
+  }, ".WillOnce() cannot appear after ");
+
+  a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, WillRepeatedlyIsOptional) {
+  MockA a;
+
+  EXPECT_CALL(a, DoA(1))
+      .WillOnce(Return());
+  EXPECT_CALL(a, DoA(2))
+      .WillOnce(Return())
+      .WillRepeatedly(Return());
+
+  a.DoA(1);
+  a.DoA(2);
+  a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, WillRepeatedlyCannotAppearMultipleTimes) {
+  MockA a;
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_CALL(a, DoA(1))
+        .WillRepeatedly(Return())
+        .WillRepeatedly(Return());
+  }, ".WillRepeatedly() cannot appear more than once in an "
+     "EXPECT_CALL()");
+}
+
+TEST(ExpectCallSyntaxTest, WillRepeatedlyMustBeBeforeRetiresOnSaturation) {
+  MockA a;
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_CALL(a, DoA(1))
+        .RetiresOnSaturation()
+        .WillRepeatedly(Return());
+  }, ".WillRepeatedly() cannot appear after ");
+}
+
+TEST(ExpectCallSyntaxTest, RetiresOnSaturationIsOptional) {
+  MockA a;
+
+  EXPECT_CALL(a, DoA(1));
+  EXPECT_CALL(a, DoA(1))
+      .RetiresOnSaturation();
+
+  a.DoA(1);
+  a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, RetiresOnSaturationCannotAppearMultipleTimes) {
+  MockA a;
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_CALL(a, DoA(1))
+        .RetiresOnSaturation()
+        .RetiresOnSaturation();
+  }, ".RetiresOnSaturation() cannot appear more than once");
+
+  a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, DefaultCardinalityIsOnce) {
+  {
+    MockA a;
+    EXPECT_CALL(a, DoA(1));
+    a.DoA(1);
+  }
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    MockA a;
+    EXPECT_CALL(a, DoA(1));
+  }, "to be called once");
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    MockA a;
+    EXPECT_CALL(a, DoA(1));
+    a.DoA(1);
+    a.DoA(1);
+  }, "to be called once");
+}
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Tests that Google Mock doesn't print a warning when the number of
+// WillOnce() is adequate.
+TEST(ExpectCallSyntaxTest, DoesNotWarnOnAdequateActionCount) {
+  CaptureStdout();
+  {
+    MockB b;
+
+    // It's always fine to omit WillOnce() entirely.
+    EXPECT_CALL(b, DoB())
+        .Times(0);
+    EXPECT_CALL(b, DoB(1))
+        .Times(AtMost(1));
+    EXPECT_CALL(b, DoB(2))
+        .Times(1)
+        .WillRepeatedly(Return(1));
+
+    // It's fine for the number of WillOnce()s to equal the upper bound.
+    EXPECT_CALL(b, DoB(3))
+        .Times(Between(1, 2))
+        .WillOnce(Return(1))
+        .WillOnce(Return(2));
+
+    // It's fine for the number of WillOnce()s to be smaller than the
+    // upper bound when there is a WillRepeatedly().
+    EXPECT_CALL(b, DoB(4))
+        .Times(AtMost(3))
+        .WillOnce(Return(1))
+        .WillRepeatedly(Return(2));
+
+    // Satisfies the above expectations.
+    b.DoB(2);
+    b.DoB(3);
+  }
+  EXPECT_STREQ("", GetCapturedStdout().c_str());
+}
+
+// Tests that Google Mock warns on having too many actions in an
+// expectation compared to its cardinality.
+TEST(ExpectCallSyntaxTest, WarnsOnTooManyActions) {
+  CaptureStdout();
+  {
+    MockB b;
+
+    // Warns when the number of WillOnce()s is larger than the upper bound.
+    EXPECT_CALL(b, DoB())
+        .Times(0)
+        .WillOnce(Return(1));  // #1
+    EXPECT_CALL(b, DoB())
+        .Times(AtMost(1))
+        .WillOnce(Return(1))
+        .WillOnce(Return(2));  // #2
+    EXPECT_CALL(b, DoB(1))
+        .Times(1)
+        .WillOnce(Return(1))
+        .WillOnce(Return(2))
+        .RetiresOnSaturation();  // #3
+
+    // Warns when the number of WillOnce()s equals the upper bound and
+    // there is a WillRepeatedly().
+    EXPECT_CALL(b, DoB())
+        .Times(0)
+        .WillRepeatedly(Return(1));  // #4
+    EXPECT_CALL(b, DoB(2))
+        .Times(1)
+        .WillOnce(Return(1))
+        .WillRepeatedly(Return(2));  // #5
+
+    // Satisfies the above expectations.
+    b.DoB(1);
+    b.DoB(2);
+  }
+  const std::string output = GetCapturedStdout();
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
+      "Expected to be never called, but has 1 WillOnce().",
+      output);  // #1
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
+      "Expected to be called at most once, "
+      "but has 2 WillOnce()s.",
+      output);  // #2
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Too many actions specified in EXPECT_CALL(b, DoB(1))...\n"
+      "Expected to be called once, but has 2 WillOnce()s.",
+      output);  // #3
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
+      "Expected to be never called, but has 0 WillOnce()s "
+      "and a WillRepeatedly().",
+      output);  // #4
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Too many actions specified in EXPECT_CALL(b, DoB(2))...\n"
+      "Expected to be called once, but has 1 WillOnce() "
+      "and a WillRepeatedly().",
+      output);  // #5
+}
+
+// Tests that Google Mock warns on having too few actions in an
+// expectation compared to its cardinality.
+TEST(ExpectCallSyntaxTest, WarnsOnTooFewActions) {
+  MockB b;
+
+  EXPECT_CALL(b, DoB())
+      .Times(Between(2, 3))
+      .WillOnce(Return(1));
+
+  CaptureStdout();
+  b.DoB();
+  const std::string output = GetCapturedStdout();
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Too few actions specified in EXPECT_CALL(b, DoB())...\n"
+      "Expected to be called between 2 and 3 times, "
+      "but has only 1 WillOnce().",
+      output);
+  b.DoB();
+}
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// Tests the semantics of ON_CALL().
+
+// Tests that the built-in default action is taken when no ON_CALL()
+// is specified.
+TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCall) {
+  MockB b;
+  EXPECT_CALL(b, DoB());
+
+  EXPECT_EQ(0, b.DoB());
+}
+
+// Tests that the built-in default action is taken when no ON_CALL()
+// matches the invocation.
+TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCallMatches) {
+  MockB b;
+  ON_CALL(b, DoB(1))
+      .WillByDefault(Return(1));
+  EXPECT_CALL(b, DoB(_));
+
+  EXPECT_EQ(0, b.DoB(2));
+}
+
+// Tests that the last matching ON_CALL() action is taken.
+TEST(OnCallTest, PicksLastMatchingOnCall) {
+  MockB b;
+  ON_CALL(b, DoB(_))
+      .WillByDefault(Return(3));
+  ON_CALL(b, DoB(2))
+      .WillByDefault(Return(2));
+  ON_CALL(b, DoB(1))
+      .WillByDefault(Return(1));
+  EXPECT_CALL(b, DoB(_));
+
+  EXPECT_EQ(2, b.DoB(2));
+}
+
+// Tests the semantics of EXPECT_CALL().
+
+// Tests that any call is allowed when no EXPECT_CALL() is specified.
+TEST(ExpectCallTest, AllowsAnyCallWhenNoSpec) {
+  MockB b;
+  EXPECT_CALL(b, DoB());
+  // There is no expectation on DoB(int).
+
+  b.DoB();
+
+  // DoB(int) can be called any number of times.
+  b.DoB(1);
+  b.DoB(2);
+}
+
+// Tests that the last matching EXPECT_CALL() fires.
+TEST(ExpectCallTest, PicksLastMatchingExpectCall) {
+  MockB b;
+  EXPECT_CALL(b, DoB(_))
+      .WillRepeatedly(Return(2));
+  EXPECT_CALL(b, DoB(1))
+      .WillRepeatedly(Return(1));
+
+  EXPECT_EQ(1, b.DoB(1));
+}
+
+// Tests lower-bound violation.
+TEST(ExpectCallTest, CatchesTooFewCalls) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    MockB b;
+    EXPECT_CALL(b, DoB(5))
+        .Times(AtLeast(2));
+
+    b.DoB(5);
+  }, "Actual function call count doesn't match EXPECT_CALL(b, DoB(5))...\n"
+     "         Expected: to be called at least twice\n"
+     "           Actual: called once - unsatisfied and active");
+}
+
+// Tests that the cardinality can be inferred when no Times(...) is
+// specified.
+TEST(ExpectCallTest, InfersCardinalityWhenThereIsNoWillRepeatedly) {
+  {
+    MockB b;
+    EXPECT_CALL(b, DoB())
+        .WillOnce(Return(1))
+        .WillOnce(Return(2));
+
+    EXPECT_EQ(1, b.DoB());
+    EXPECT_EQ(2, b.DoB());
+  }
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    MockB b;
+    EXPECT_CALL(b, DoB())
+        .WillOnce(Return(1))
+        .WillOnce(Return(2));
+
+    EXPECT_EQ(1, b.DoB());
+  }, "to be called twice");
+
+  {  // NOLINT
+    MockB b;
+    EXPECT_CALL(b, DoB())
+        .WillOnce(Return(1))
+        .WillOnce(Return(2));
+
+    EXPECT_EQ(1, b.DoB());
+    EXPECT_EQ(2, b.DoB());
+    EXPECT_NONFATAL_FAILURE(b.DoB(), "to be called twice");
+  }
+}
+
+TEST(ExpectCallTest, InfersCardinality1WhenThereIsWillRepeatedly) {
+  {
+    MockB b;
+    EXPECT_CALL(b, DoB())
+        .WillOnce(Return(1))
+        .WillRepeatedly(Return(2));
+
+    EXPECT_EQ(1, b.DoB());
+  }
+
+  {  // NOLINT
+    MockB b;
+    EXPECT_CALL(b, DoB())
+        .WillOnce(Return(1))
+        .WillRepeatedly(Return(2));
+
+    EXPECT_EQ(1, b.DoB());
+    EXPECT_EQ(2, b.DoB());
+    EXPECT_EQ(2, b.DoB());
+  }
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    MockB b;
+    EXPECT_CALL(b, DoB())
+        .WillOnce(Return(1))
+        .WillRepeatedly(Return(2));
+  }, "to be called at least once");
+}
+
+// Tests that the n-th action is taken for the n-th matching
+// invocation.
+TEST(ExpectCallTest, NthMatchTakesNthAction) {
+  MockB b;
+  EXPECT_CALL(b, DoB())
+      .WillOnce(Return(1))
+      .WillOnce(Return(2))
+      .WillOnce(Return(3));
+
+  EXPECT_EQ(1, b.DoB());
+  EXPECT_EQ(2, b.DoB());
+  EXPECT_EQ(3, b.DoB());
+}
+
+// Tests that the WillRepeatedly() action is taken when the WillOnce(...)
+// list is exhausted.
+TEST(ExpectCallTest, TakesRepeatedActionWhenWillListIsExhausted) {
+  MockB b;
+  EXPECT_CALL(b, DoB())
+      .WillOnce(Return(1))
+      .WillRepeatedly(Return(2));
+
+  EXPECT_EQ(1, b.DoB());
+  EXPECT_EQ(2, b.DoB());
+  EXPECT_EQ(2, b.DoB());
+}
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Tests that the default action is taken when the WillOnce(...) list is
+// exhausted and there is no WillRepeatedly().
+TEST(ExpectCallTest, TakesDefaultActionWhenWillListIsExhausted) {
+  MockB b;
+  EXPECT_CALL(b, DoB(_))
+      .Times(1);
+  EXPECT_CALL(b, DoB())
+      .Times(AnyNumber())
+      .WillOnce(Return(1))
+      .WillOnce(Return(2));
+
+  CaptureStdout();
+  EXPECT_EQ(0, b.DoB(1));  // Shouldn't generate a warning as the
+                           // expectation has no action clause at all.
+  EXPECT_EQ(1, b.DoB());
+  EXPECT_EQ(2, b.DoB());
+  const std::string output1 = GetCapturedStdout();
+  EXPECT_STREQ("", output1.c_str());
+
+  CaptureStdout();
+  EXPECT_EQ(0, b.DoB());
+  EXPECT_EQ(0, b.DoB());
+  const std::string output2 = GetCapturedStdout();
+  EXPECT_THAT(output2.c_str(),
+              HasSubstr("Actions ran out in EXPECT_CALL(b, DoB())...\n"
+                        "Called 3 times, but only 2 WillOnce()s are specified"
+                        " - returning default value."));
+  EXPECT_THAT(output2.c_str(),
+              HasSubstr("Actions ran out in EXPECT_CALL(b, DoB())...\n"
+                        "Called 4 times, but only 2 WillOnce()s are specified"
+                        " - returning default value."));
+}
+
+TEST(FunctionMockerMessageTest, ReportsExpectCallLocationForExhausedActions) {
+  MockB b;
+  std::string expect_call_location = FormatFileLocation(__FILE__, __LINE__ + 1);
+  EXPECT_CALL(b, DoB()).Times(AnyNumber()).WillOnce(Return(1));
+
+  EXPECT_EQ(1, b.DoB());
+
+  CaptureStdout();
+  EXPECT_EQ(0, b.DoB());
+  const std::string output = GetCapturedStdout();
+  // The warning message should contain the call location.
+  EXPECT_PRED_FORMAT2(IsSubstring, expect_call_location, output);
+}
+
+TEST(FunctionMockerMessageTest,
+     ReportsDefaultActionLocationOfUninterestingCallsForNaggyMock) {
+  std::string on_call_location;
+  CaptureStdout();
+  {
+    NaggyMock<MockB> b;
+    on_call_location = FormatFileLocation(__FILE__, __LINE__ + 1);
+    ON_CALL(b, DoB(_)).WillByDefault(Return(0));
+    b.DoB(0);
+  }
+  EXPECT_PRED_FORMAT2(IsSubstring, on_call_location, GetCapturedStdout());
+}
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// Tests that an uninteresting call performs the default action.
+TEST(UninterestingCallTest, DoesDefaultAction) {
+  // When there is an ON_CALL() statement, the action specified by it
+  // should be taken.
+  MockA a;
+  ON_CALL(a, Binary(_, _))
+      .WillByDefault(Return(true));
+  EXPECT_TRUE(a.Binary(1, 2));
+
+  // When there is no ON_CALL(), the default value for the return type
+  // should be returned.
+  MockB b;
+  EXPECT_EQ(0, b.DoB());
+}
+
+// Tests that an unexpected call performs the default action.
+TEST(UnexpectedCallTest, DoesDefaultAction) {
+  // When there is an ON_CALL() statement, the action specified by it
+  // should be taken.
+  MockA a;
+  ON_CALL(a, Binary(_, _))
+      .WillByDefault(Return(true));
+  EXPECT_CALL(a, Binary(0, 0));
+  a.Binary(0, 0);
+  bool result = false;
+  EXPECT_NONFATAL_FAILURE(result = a.Binary(1, 2),
+                          "Unexpected mock function call");
+  EXPECT_TRUE(result);
+
+  // When there is no ON_CALL(), the default value for the return type
+  // should be returned.
+  MockB b;
+  EXPECT_CALL(b, DoB(0))
+      .Times(0);
+  int n = -1;
+  EXPECT_NONFATAL_FAILURE(n = b.DoB(1),
+                          "Unexpected mock function call");
+  EXPECT_EQ(0, n);
+}
+
+// Tests that when an unexpected void function generates the right
+// failure message.
+TEST(UnexpectedCallTest, GeneratesFailureForVoidFunction) {
+  // First, tests the message when there is only one EXPECT_CALL().
+  MockA a1;
+  EXPECT_CALL(a1, DoA(1));
+  a1.DoA(1);
+  // Ideally we should match the failure message against a regex, but
+  // EXPECT_NONFATAL_FAILURE doesn't support that, so we test for
+  // multiple sub-strings instead.
+  EXPECT_NONFATAL_FAILURE(
+      a1.DoA(9),
+      "Unexpected mock function call - returning directly.\n"
+      "    Function call: DoA(9)\n"
+      "Google Mock tried the following 1 expectation, but it didn't match:");
+  EXPECT_NONFATAL_FAILURE(
+      a1.DoA(9),
+      "  Expected arg #0: is equal to 1\n"
+      "           Actual: 9\n"
+      "         Expected: to be called once\n"
+      "           Actual: called once - saturated and active");
+
+  // Next, tests the message when there are more than one EXPECT_CALL().
+  MockA a2;
+  EXPECT_CALL(a2, DoA(1));
+  EXPECT_CALL(a2, DoA(3));
+  a2.DoA(1);
+  EXPECT_NONFATAL_FAILURE(
+      a2.DoA(2),
+      "Unexpected mock function call - returning directly.\n"
+      "    Function call: DoA(2)\n"
+      "Google Mock tried the following 2 expectations, but none matched:");
+  EXPECT_NONFATAL_FAILURE(
+      a2.DoA(2),
+      "tried expectation #0: EXPECT_CALL(a2, DoA(1))...\n"
+      "  Expected arg #0: is equal to 1\n"
+      "           Actual: 2\n"
+      "         Expected: to be called once\n"
+      "           Actual: called once - saturated and active");
+  EXPECT_NONFATAL_FAILURE(
+      a2.DoA(2),
+      "tried expectation #1: EXPECT_CALL(a2, DoA(3))...\n"
+      "  Expected arg #0: is equal to 3\n"
+      "           Actual: 2\n"
+      "         Expected: to be called once\n"
+      "           Actual: never called - unsatisfied and active");
+  a2.DoA(3);
+}
+
+// Tests that an unexpected non-void function generates the right
+// failure message.
+TEST(UnexpectedCallTest, GeneartesFailureForNonVoidFunction) {
+  MockB b1;
+  EXPECT_CALL(b1, DoB(1));
+  b1.DoB(1);
+  EXPECT_NONFATAL_FAILURE(
+      b1.DoB(2),
+      "Unexpected mock function call - returning default value.\n"
+      "    Function call: DoB(2)\n"
+      "          Returns: 0\n"
+      "Google Mock tried the following 1 expectation, but it didn't match:");
+  EXPECT_NONFATAL_FAILURE(
+      b1.DoB(2),
+      "  Expected arg #0: is equal to 1\n"
+      "           Actual: 2\n"
+      "         Expected: to be called once\n"
+      "           Actual: called once - saturated and active");
+}
+
+// Tests that Google Mock explains that an retired expectation doesn't
+// match the call.
+TEST(UnexpectedCallTest, RetiredExpectation) {
+  MockB b;
+  EXPECT_CALL(b, DoB(1))
+      .RetiresOnSaturation();
+
+  b.DoB(1);
+  EXPECT_NONFATAL_FAILURE(
+      b.DoB(1),
+      "         Expected: the expectation is active\n"
+      "           Actual: it is retired");
+}
+
+// Tests that Google Mock explains that an expectation that doesn't
+// match the arguments doesn't match the call.
+TEST(UnexpectedCallTest, UnmatchedArguments) {
+  MockB b;
+  EXPECT_CALL(b, DoB(1));
+
+  EXPECT_NONFATAL_FAILURE(
+      b.DoB(2),
+      "  Expected arg #0: is equal to 1\n"
+      "           Actual: 2\n");
+  b.DoB(1);
+}
+
+// Tests that Google Mock explains that an expectation with
+// unsatisfied pre-requisites doesn't match the call.
+TEST(UnexpectedCallTest, UnsatisifiedPrerequisites) {
+  Sequence s1, s2;
+  MockB b;
+  EXPECT_CALL(b, DoB(1))
+      .InSequence(s1);
+  EXPECT_CALL(b, DoB(2))
+      .Times(AnyNumber())
+      .InSequence(s1);
+  EXPECT_CALL(b, DoB(3))
+      .InSequence(s2);
+  EXPECT_CALL(b, DoB(4))
+      .InSequence(s1, s2);
+
+  ::testing::TestPartResultArray failures;
+  {
+    ::testing::ScopedFakeTestPartResultReporter reporter(&failures);
+    b.DoB(4);
+    // Now 'failures' contains the Google Test failures generated by
+    // the above statement.
+  }
+
+  // There should be one non-fatal failure.
+  ASSERT_EQ(1, failures.size());
+  const ::testing::TestPartResult& r = failures.GetTestPartResult(0);
+  EXPECT_EQ(::testing::TestPartResult::kNonFatalFailure, r.type());
+
+  // Verifies that the failure message contains the two unsatisfied
+  // pre-requisites but not the satisfied one.
+#if GTEST_USES_PCRE
+  EXPECT_THAT(r.message(), ContainsRegex(
+      // PCRE has trouble using (.|\n) to match any character, but
+      // supports the (?s) prefix for using . to match any character.
+      "(?s)the following immediate pre-requisites are not satisfied:\n"
+      ".*: pre-requisite #0\n"
+      ".*: pre-requisite #1"));
+#elif GTEST_USES_POSIX_RE
+  EXPECT_THAT(r.message(), ContainsRegex(
+      // POSIX RE doesn't understand the (?s) prefix, but has no trouble
+      // with (.|\n).
+      "the following immediate pre-requisites are not satisfied:\n"
+      "(.|\n)*: pre-requisite #0\n"
+      "(.|\n)*: pre-requisite #1"));
+#else
+  // We can only use Google Test's own simple regex.
+  EXPECT_THAT(r.message(), ContainsRegex(
+      "the following immediate pre-requisites are not satisfied:"));
+  EXPECT_THAT(r.message(), ContainsRegex(": pre-requisite #0"));
+  EXPECT_THAT(r.message(), ContainsRegex(": pre-requisite #1"));
+#endif  // GTEST_USES_PCRE
+
+  b.DoB(1);
+  b.DoB(3);
+  b.DoB(4);
+}
+
+TEST(UndefinedReturnValueTest,
+     ReturnValueIsMandatoryWhenNotDefaultConstructible) {
+  MockA a;
+  // TODO(wan@google.com): We should really verify the output message,
+  // but we cannot yet due to that EXPECT_DEATH only captures stderr
+  // while Google Mock logs to stdout.
+#if GTEST_HAS_EXCEPTIONS
+  EXPECT_ANY_THROW(a.ReturnNonDefaultConstructible());
+#else
+  EXPECT_DEATH_IF_SUPPORTED(a.ReturnNonDefaultConstructible(), "");
+#endif
+}
+
+// Tests that an excessive call (one whose arguments match the
+// matchers but is called too many times) performs the default action.
+TEST(ExcessiveCallTest, DoesDefaultAction) {
+  // When there is an ON_CALL() statement, the action specified by it
+  // should be taken.
+  MockA a;
+  ON_CALL(a, Binary(_, _))
+      .WillByDefault(Return(true));
+  EXPECT_CALL(a, Binary(0, 0));
+  a.Binary(0, 0);
+  bool result = false;
+  EXPECT_NONFATAL_FAILURE(result = a.Binary(0, 0),
+                          "Mock function called more times than expected");
+  EXPECT_TRUE(result);
+
+  // When there is no ON_CALL(), the default value for the return type
+  // should be returned.
+  MockB b;
+  EXPECT_CALL(b, DoB(0))
+      .Times(0);
+  int n = -1;
+  EXPECT_NONFATAL_FAILURE(n = b.DoB(0),
+                          "Mock function called more times than expected");
+  EXPECT_EQ(0, n);
+}
+
+// Tests that when a void function is called too many times,
+// the failure message contains the argument values.
+TEST(ExcessiveCallTest, GeneratesFailureForVoidFunction) {
+  MockA a;
+  EXPECT_CALL(a, DoA(_))
+      .Times(0);
+  EXPECT_NONFATAL_FAILURE(
+      a.DoA(9),
+      "Mock function called more times than expected - returning directly.\n"
+      "    Function call: DoA(9)\n"
+      "         Expected: to be never called\n"
+      "           Actual: called once - over-saturated and active");
+}
+
+// Tests that when a non-void function is called too many times, the
+// failure message contains the argument values and the return value.
+TEST(ExcessiveCallTest, GeneratesFailureForNonVoidFunction) {
+  MockB b;
+  EXPECT_CALL(b, DoB(_));
+  b.DoB(1);
+  EXPECT_NONFATAL_FAILURE(
+      b.DoB(2),
+      "Mock function called more times than expected - "
+      "returning default value.\n"
+      "    Function call: DoB(2)\n"
+      "          Returns: 0\n"
+      "         Expected: to be called once\n"
+      "           Actual: called twice - over-saturated and active");
+}
+
+// Tests using sequences.
+
+TEST(InSequenceTest, AllExpectationInScopeAreInSequence) {
+  MockA a;
+  {
+    InSequence dummy;
+
+    EXPECT_CALL(a, DoA(1));
+    EXPECT_CALL(a, DoA(2));
+  }
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    a.DoA(2);
+  }, "Unexpected mock function call");
+
+  a.DoA(1);
+  a.DoA(2);
+}
+
+TEST(InSequenceTest, NestedInSequence) {
+  MockA a;
+  {
+    InSequence dummy;
+
+    EXPECT_CALL(a, DoA(1));
+    {
+      InSequence dummy2;
+
+      EXPECT_CALL(a, DoA(2));
+      EXPECT_CALL(a, DoA(3));
+    }
+  }
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    a.DoA(1);
+    a.DoA(3);
+  }, "Unexpected mock function call");
+
+  a.DoA(2);
+  a.DoA(3);
+}
+
+TEST(InSequenceTest, ExpectationsOutOfScopeAreNotAffected) {
+  MockA a;
+  {
+    InSequence dummy;
+
+    EXPECT_CALL(a, DoA(1));
+    EXPECT_CALL(a, DoA(2));
+  }
+  EXPECT_CALL(a, DoA(3));
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    a.DoA(2);
+  }, "Unexpected mock function call");
+
+  a.DoA(3);
+  a.DoA(1);
+  a.DoA(2);
+}
+
+// Tests that any order is allowed when no sequence is used.
+TEST(SequenceTest, AnyOrderIsOkByDefault) {
+  {
+    MockA a;
+    MockB b;
+
+    EXPECT_CALL(a, DoA(1));
+    EXPECT_CALL(b, DoB())
+        .Times(AnyNumber());
+
+    a.DoA(1);
+    b.DoB();
+  }
+
+  {  // NOLINT
+    MockA a;
+    MockB b;
+
+    EXPECT_CALL(a, DoA(1));
+    EXPECT_CALL(b, DoB())
+        .Times(AnyNumber());
+
+    b.DoB();
+    a.DoA(1);
+  }
+}
+
+// Tests that the calls must be in strict order when a complete order
+// is specified.
+TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo1) {
+  MockA a;
+  ON_CALL(a, ReturnResult(_))
+      .WillByDefault(Return(Result()));
+
+  Sequence s;
+  EXPECT_CALL(a, ReturnResult(1))
+      .InSequence(s);
+  EXPECT_CALL(a, ReturnResult(2))
+      .InSequence(s);
+  EXPECT_CALL(a, ReturnResult(3))
+      .InSequence(s);
+
+  a.ReturnResult(1);
+
+  // May only be called after a.ReturnResult(2).
+  EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
+
+  a.ReturnResult(2);
+  a.ReturnResult(3);
+}
+
+// Tests that the calls must be in strict order when a complete order
+// is specified.
+TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo2) {
+  MockA a;
+  ON_CALL(a, ReturnResult(_))
+      .WillByDefault(Return(Result()));
+
+  Sequence s;
+  EXPECT_CALL(a, ReturnResult(1))
+      .InSequence(s);
+  EXPECT_CALL(a, ReturnResult(2))
+      .InSequence(s);
+
+  // May only be called after a.ReturnResult(1).
+  EXPECT_NONFATAL_FAILURE(a.ReturnResult(2), "Unexpected mock function call");
+
+  a.ReturnResult(1);
+  a.ReturnResult(2);
+}
+
+// Tests specifying a DAG using multiple sequences.
+class PartialOrderTest : public testing::Test {
+ protected:
+  PartialOrderTest() {
+    ON_CALL(a_, ReturnResult(_))
+        .WillByDefault(Return(Result()));
+
+    // Specifies this partial ordering:
+    //
+    // a.ReturnResult(1) ==>
+    //                       a.ReturnResult(2) * n  ==>  a.ReturnResult(3)
+    // b.DoB() * 2       ==>
+    Sequence x, y;
+    EXPECT_CALL(a_, ReturnResult(1))
+        .InSequence(x);
+    EXPECT_CALL(b_, DoB())
+        .Times(2)
+        .InSequence(y);
+    EXPECT_CALL(a_, ReturnResult(2))
+        .Times(AnyNumber())
+        .InSequence(x, y);
+    EXPECT_CALL(a_, ReturnResult(3))
+        .InSequence(x);
+  }
+
+  MockA a_;
+  MockB b_;
+};
+
+TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag1) {
+  a_.ReturnResult(1);
+  b_.DoB();
+
+  // May only be called after the second DoB().
+  EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2), "Unexpected mock function call");
+
+  b_.DoB();
+  a_.ReturnResult(3);
+}
+
+TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag2) {
+  // May only be called after ReturnResult(1).
+  EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2), "Unexpected mock function call");
+
+  a_.ReturnResult(1);
+  b_.DoB();
+  b_.DoB();
+  a_.ReturnResult(3);
+}
+
+TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag3) {
+  // May only be called last.
+  EXPECT_NONFATAL_FAILURE(a_.ReturnResult(3), "Unexpected mock function call");
+
+  a_.ReturnResult(1);
+  b_.DoB();
+  b_.DoB();
+  a_.ReturnResult(3);
+}
+
+TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag4) {
+  a_.ReturnResult(1);
+  b_.DoB();
+  b_.DoB();
+  a_.ReturnResult(3);
+
+  // May only be called before ReturnResult(3).
+  EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2), "Unexpected mock function call");
+}
+
+TEST(SequenceTest, Retirement) {
+  MockA a;
+  Sequence s;
+
+  EXPECT_CALL(a, DoA(1))
+      .InSequence(s);
+  EXPECT_CALL(a, DoA(_))
+      .InSequence(s)
+      .RetiresOnSaturation();
+  EXPECT_CALL(a, DoA(1))
+      .InSequence(s);
+
+  a.DoA(1);
+  a.DoA(2);
+  a.DoA(1);
+}
+
+// Tests Expectation.
+
+TEST(ExpectationTest, ConstrutorsWork) {
+  MockA a;
+  Expectation e1;  // Default ctor.
+
+  // Ctor from various forms of EXPECT_CALL.
+  Expectation e2 = EXPECT_CALL(a, DoA(2));
+  Expectation e3 = EXPECT_CALL(a, DoA(3)).With(_);
+  {
+    Sequence s;
+    Expectation e4 = EXPECT_CALL(a, DoA(4)).Times(1);
+    Expectation e5 = EXPECT_CALL(a, DoA(5)).InSequence(s);
+  }
+  Expectation e6 = EXPECT_CALL(a, DoA(6)).After(e2);
+  Expectation e7 = EXPECT_CALL(a, DoA(7)).WillOnce(Return());
+  Expectation e8 = EXPECT_CALL(a, DoA(8)).WillRepeatedly(Return());
+  Expectation e9 = EXPECT_CALL(a, DoA(9)).RetiresOnSaturation();
+
+  Expectation e10 = e2;  // Copy ctor.
+
+  EXPECT_THAT(e1, Ne(e2));
+  EXPECT_THAT(e2, Eq(e10));
+
+  a.DoA(2);
+  a.DoA(3);
+  a.DoA(4);
+  a.DoA(5);
+  a.DoA(6);
+  a.DoA(7);
+  a.DoA(8);
+  a.DoA(9);
+}
+
+TEST(ExpectationTest, AssignmentWorks) {
+  MockA a;
+  Expectation e1;
+  Expectation e2 = EXPECT_CALL(a, DoA(1));
+
+  EXPECT_THAT(e1, Ne(e2));
+
+  e1 = e2;
+  EXPECT_THAT(e1, Eq(e2));
+
+  a.DoA(1);
+}
+
+// Tests ExpectationSet.
+
+TEST(ExpectationSetTest, MemberTypesAreCorrect) {
+  ::testing::StaticAssertTypeEq<Expectation, ExpectationSet::value_type>();
+}
+
+TEST(ExpectationSetTest, ConstructorsWork) {
+  MockA a;
+
+  Expectation e1;
+  const Expectation e2;
+  ExpectationSet es1;  // Default ctor.
+  ExpectationSet es2 = EXPECT_CALL(a, DoA(1));  // Ctor from EXPECT_CALL.
+  ExpectationSet es3 = e1;  // Ctor from Expectation.
+  ExpectationSet es4(e1);   // Ctor from Expectation; alternative syntax.
+  ExpectationSet es5 = e2;  // Ctor from const Expectation.
+  ExpectationSet es6(e2);   // Ctor from const Expectation; alternative syntax.
+  ExpectationSet es7 = es2;  // Copy ctor.
+
+  EXPECT_EQ(0, es1.size());
+  EXPECT_EQ(1, es2.size());
+  EXPECT_EQ(1, es3.size());
+  EXPECT_EQ(1, es4.size());
+  EXPECT_EQ(1, es5.size());
+  EXPECT_EQ(1, es6.size());
+  EXPECT_EQ(1, es7.size());
+
+  EXPECT_THAT(es3, Ne(es2));
+  EXPECT_THAT(es4, Eq(es3));
+  EXPECT_THAT(es5, Eq(es4));
+  EXPECT_THAT(es6, Eq(es5));
+  EXPECT_THAT(es7, Eq(es2));
+  a.DoA(1);
+}
+
+TEST(ExpectationSetTest, AssignmentWorks) {
+  ExpectationSet es1;
+  ExpectationSet es2 = Expectation();
+
+  es1 = es2;
+  EXPECT_EQ(1, es1.size());
+  EXPECT_THAT(*(es1.begin()), Eq(Expectation()));
+  EXPECT_THAT(es1, Eq(es2));
+}
+
+TEST(ExpectationSetTest, InsertionWorks) {
+  ExpectationSet es1;
+  Expectation e1;
+  es1 += e1;
+  EXPECT_EQ(1, es1.size());
+  EXPECT_THAT(*(es1.begin()), Eq(e1));
+
+  MockA a;
+  Expectation e2 = EXPECT_CALL(a, DoA(1));
+  es1 += e2;
+  EXPECT_EQ(2, es1.size());
+
+  ExpectationSet::const_iterator it1 = es1.begin();
+  ExpectationSet::const_iterator it2 = it1;
+  ++it2;
+  EXPECT_TRUE(*it1 == e1 || *it2 == e1);  // e1 must be in the set.
+  EXPECT_TRUE(*it1 == e2 || *it2 == e2);  // e2 must be in the set too.
+  a.DoA(1);
+}
+
+TEST(ExpectationSetTest, SizeWorks) {
+  ExpectationSet es;
+  EXPECT_EQ(0, es.size());
+
+  es += Expectation();
+  EXPECT_EQ(1, es.size());
+
+  MockA a;
+  es += EXPECT_CALL(a, DoA(1));
+  EXPECT_EQ(2, es.size());
+
+  a.DoA(1);
+}
+
+TEST(ExpectationSetTest, IsEnumerable) {
+  ExpectationSet es;
+  EXPECT_TRUE(es.begin() == es.end());
+
+  es += Expectation();
+  ExpectationSet::const_iterator it = es.begin();
+  EXPECT_TRUE(it != es.end());
+  EXPECT_THAT(*it, Eq(Expectation()));
+  ++it;
+  EXPECT_TRUE(it== es.end());
+}
+
+// Tests the .After() clause.
+
+TEST(AfterTest, SucceedsWhenPartialOrderIsSatisfied) {
+  MockA a;
+  ExpectationSet es;
+  es += EXPECT_CALL(a, DoA(1));
+  es += EXPECT_CALL(a, DoA(2));
+  EXPECT_CALL(a, DoA(3))
+      .After(es);
+
+  a.DoA(1);
+  a.DoA(2);
+  a.DoA(3);
+}
+
+TEST(AfterTest, SucceedsWhenTotalOrderIsSatisfied) {
+  MockA a;
+  MockB b;
+  // The following also verifies that const Expectation objects work
+  // too.  Do not remove the const modifiers.
+  const Expectation e1 = EXPECT_CALL(a, DoA(1));
+  const Expectation e2 = EXPECT_CALL(b, DoB())
+      .Times(2)
+      .After(e1);
+  EXPECT_CALL(a, DoA(2)).After(e2);
+
+  a.DoA(1);
+  b.DoB();
+  b.DoB();
+  a.DoA(2);
+}
+
+// Calls must be in strict order when specified so using .After().
+TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo1) {
+  MockA a;
+  MockB b;
+
+  // Define ordering:
+  //   a.DoA(1) ==> b.DoB() ==> a.DoA(2)
+  Expectation e1 = EXPECT_CALL(a, DoA(1));
+  Expectation e2 = EXPECT_CALL(b, DoB())
+      .After(e1);
+  EXPECT_CALL(a, DoA(2))
+      .After(e2);
+
+  a.DoA(1);
+
+  // May only be called after DoB().
+  EXPECT_NONFATAL_FAILURE(a.DoA(2), "Unexpected mock function call");
+
+  b.DoB();
+  a.DoA(2);
+}
+
+// Calls must be in strict order when specified so using .After().
+TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo2) {
+  MockA a;
+  MockB b;
+
+  // Define ordering:
+  //   a.DoA(1) ==> b.DoB() * 2 ==> a.DoA(2)
+  Expectation e1 = EXPECT_CALL(a, DoA(1));
+  Expectation e2 = EXPECT_CALL(b, DoB())
+      .Times(2)
+      .After(e1);
+  EXPECT_CALL(a, DoA(2))
+      .After(e2);
+
+  a.DoA(1);
+  b.DoB();
+
+  // May only be called after the second DoB().
+  EXPECT_NONFATAL_FAILURE(a.DoA(2), "Unexpected mock function call");
+
+  b.DoB();
+  a.DoA(2);
+}
+
+// Calls must satisfy the partial order when specified so.
+TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo) {
+  MockA a;
+  ON_CALL(a, ReturnResult(_))
+      .WillByDefault(Return(Result()));
+
+  // Define ordering:
+  //   a.DoA(1) ==>
+  //   a.DoA(2) ==> a.ReturnResult(3)
+  Expectation e = EXPECT_CALL(a, DoA(1));
+  const ExpectationSet es = EXPECT_CALL(a, DoA(2));
+  EXPECT_CALL(a, ReturnResult(3))
+      .After(e, es);
+
+  // May only be called last.
+  EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
+
+  a.DoA(2);
+  a.DoA(1);
+  a.ReturnResult(3);
+}
+
+// Calls must satisfy the partial order when specified so.
+TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo2) {
+  MockA a;
+
+  // Define ordering:
+  //   a.DoA(1) ==>
+  //   a.DoA(2) ==> a.DoA(3)
+  Expectation e = EXPECT_CALL(a, DoA(1));
+  const ExpectationSet es = EXPECT_CALL(a, DoA(2));
+  EXPECT_CALL(a, DoA(3))
+      .After(e, es);
+
+  a.DoA(2);
+
+  // May only be called last.
+  EXPECT_NONFATAL_FAILURE(a.DoA(3), "Unexpected mock function call");
+
+  a.DoA(1);
+  a.DoA(3);
+}
+
+// .After() can be combined with .InSequence().
+TEST(AfterTest, CanBeUsedWithInSequence) {
+  MockA a;
+  Sequence s;
+  Expectation e = EXPECT_CALL(a, DoA(1));
+  EXPECT_CALL(a, DoA(2)).InSequence(s);
+  EXPECT_CALL(a, DoA(3))
+      .InSequence(s)
+      .After(e);
+
+  a.DoA(1);
+
+  // May only be after DoA(2).
+  EXPECT_NONFATAL_FAILURE(a.DoA(3), "Unexpected mock function call");
+
+  a.DoA(2);
+  a.DoA(3);
+}
+
+// .After() can be called multiple times.
+TEST(AfterTest, CanBeCalledManyTimes) {
+  MockA a;
+  Expectation e1 = EXPECT_CALL(a, DoA(1));
+  Expectation e2 = EXPECT_CALL(a, DoA(2));
+  Expectation e3 = EXPECT_CALL(a, DoA(3));
+  EXPECT_CALL(a, DoA(4))
+      .After(e1)
+      .After(e2)
+      .After(e3);
+
+  a.DoA(3);
+  a.DoA(1);
+  a.DoA(2);
+  a.DoA(4);
+}
+
+// .After() accepts up to 5 arguments.
+TEST(AfterTest, AcceptsUpToFiveArguments) {
+  MockA a;
+  Expectation e1 = EXPECT_CALL(a, DoA(1));
+  Expectation e2 = EXPECT_CALL(a, DoA(2));
+  Expectation e3 = EXPECT_CALL(a, DoA(3));
+  ExpectationSet es1 = EXPECT_CALL(a, DoA(4));
+  ExpectationSet es2 = EXPECT_CALL(a, DoA(5));
+  EXPECT_CALL(a, DoA(6))
+      .After(e1, e2, e3, es1, es2);
+
+  a.DoA(5);
+  a.DoA(2);
+  a.DoA(4);
+  a.DoA(1);
+  a.DoA(3);
+  a.DoA(6);
+}
+
+// .After() allows input to contain duplicated Expectations.
+TEST(AfterTest, AcceptsDuplicatedInput) {
+  MockA a;
+  ON_CALL(a, ReturnResult(_))
+      .WillByDefault(Return(Result()));
+
+  // Define ordering:
+  //   DoA(1) ==>
+  //   DoA(2) ==> ReturnResult(3)
+  Expectation e1 = EXPECT_CALL(a, DoA(1));
+  Expectation e2 = EXPECT_CALL(a, DoA(2));
+  ExpectationSet es;
+  es += e1;
+  es += e2;
+  EXPECT_CALL(a, ReturnResult(3))
+      .After(e1, e2, es, e1);
+
+  a.DoA(1);
+
+  // May only be after DoA(2).
+  EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
+
+  a.DoA(2);
+  a.ReturnResult(3);
+}
+
+// An Expectation added to an ExpectationSet after it has been used in
+// an .After() has no effect.
+TEST(AfterTest, ChangesToExpectationSetHaveNoEffectAfterwards) {
+  MockA a;
+  ExpectationSet es1 = EXPECT_CALL(a, DoA(1));
+  Expectation e2 = EXPECT_CALL(a, DoA(2));
+  EXPECT_CALL(a, DoA(3))
+      .After(es1);
+  es1 += e2;
+
+  a.DoA(1);
+  a.DoA(3);
+  a.DoA(2);
+}
+
+// Tests that Google Mock correctly handles calls to mock functions
+// after a mock object owning one of their pre-requisites has died.
+
+// Tests that calls that satisfy the original spec are successful.
+TEST(DeletingMockEarlyTest, Success1) {
+  MockB* const b1 = new MockB;
+  MockA* const a = new MockA;
+  MockB* const b2 = new MockB;
+
+  {
+    InSequence dummy;
+    EXPECT_CALL(*b1, DoB(_))
+        .WillOnce(Return(1));
+    EXPECT_CALL(*a, Binary(_, _))
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*b2, DoB(_))
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(2));
+  }
+
+  EXPECT_EQ(1, b1->DoB(1));
+  delete b1;
+  // a's pre-requisite has died.
+  EXPECT_TRUE(a->Binary(0, 1));
+  delete b2;
+  // a's successor has died.
+  EXPECT_TRUE(a->Binary(1, 2));
+  delete a;
+}
+
+// Tests that calls that satisfy the original spec are successful.
+TEST(DeletingMockEarlyTest, Success2) {
+  MockB* const b1 = new MockB;
+  MockA* const a = new MockA;
+  MockB* const b2 = new MockB;
+
+  {
+    InSequence dummy;
+    EXPECT_CALL(*b1, DoB(_))
+        .WillOnce(Return(1));
+    EXPECT_CALL(*a, Binary(_, _))
+        .Times(AnyNumber());
+    EXPECT_CALL(*b2, DoB(_))
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(2));
+  }
+
+  delete a;  // a is trivially satisfied.
+  EXPECT_EQ(1, b1->DoB(1));
+  EXPECT_EQ(2, b2->DoB(2));
+  delete b1;
+  delete b2;
+}
+
+// Tests that it's OK to delete a mock object itself in its action.
+
+// Suppresses warning on unreferenced formal parameter in MSVC with
+// -W4.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+ACTION_P(Delete, ptr) { delete ptr; }
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningVoid) {
+  MockA* const a = new MockA;
+  EXPECT_CALL(*a, DoA(_)).WillOnce(Delete(a));
+  a->DoA(42);  // This will cause a to be deleted.
+}
+
+TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningValue) {
+  MockA* const a = new MockA;
+  EXPECT_CALL(*a, ReturnResult(_))
+      .WillOnce(DoAll(Delete(a), Return(Result())));
+  a->ReturnResult(42);  // This will cause a to be deleted.
+}
+
+// Tests that calls that violate the original spec yield failures.
+TEST(DeletingMockEarlyTest, Failure1) {
+  MockB* const b1 = new MockB;
+  MockA* const a = new MockA;
+  MockB* const b2 = new MockB;
+
+  {
+    InSequence dummy;
+    EXPECT_CALL(*b1, DoB(_))
+        .WillOnce(Return(1));
+    EXPECT_CALL(*a, Binary(_, _))
+        .Times(AnyNumber());
+    EXPECT_CALL(*b2, DoB(_))
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(2));
+  }
+
+  delete a;  // a is trivially satisfied.
+  EXPECT_NONFATAL_FAILURE({
+    b2->DoB(2);
+  }, "Unexpected mock function call");
+  EXPECT_EQ(1, b1->DoB(1));
+  delete b1;
+  delete b2;
+}
+
+// Tests that calls that violate the original spec yield failures.
+TEST(DeletingMockEarlyTest, Failure2) {
+  MockB* const b1 = new MockB;
+  MockA* const a = new MockA;
+  MockB* const b2 = new MockB;
+
+  {
+    InSequence dummy;
+    EXPECT_CALL(*b1, DoB(_));
+    EXPECT_CALL(*a, Binary(_, _))
+        .Times(AnyNumber());
+    EXPECT_CALL(*b2, DoB(_))
+        .Times(AnyNumber());
+  }
+
+  EXPECT_NONFATAL_FAILURE(delete b1,
+                          "Actual: never called");
+  EXPECT_NONFATAL_FAILURE(a->Binary(0, 1),
+                          "Unexpected mock function call");
+  EXPECT_NONFATAL_FAILURE(b2->DoB(1),
+                          "Unexpected mock function call");
+  delete a;
+  delete b2;
+}
+
+class EvenNumberCardinality : public CardinalityInterface {
+ public:
+  // Returns true iff call_count calls will satisfy this cardinality.
+  virtual bool IsSatisfiedByCallCount(int call_count) const {
+    return call_count % 2 == 0;
+  }
+
+  // Returns true iff call_count calls will saturate this cardinality.
+  virtual bool IsSaturatedByCallCount(int /* call_count */) const {
+    return false;
+  }
+
+  // Describes self to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "called even number of times";
+  }
+};
+
+Cardinality EvenNumber() {
+  return Cardinality(new EvenNumberCardinality);
+}
+
+TEST(ExpectationBaseTest,
+     AllPrerequisitesAreSatisfiedWorksForNonMonotonicCardinality) {
+  MockA* a = new MockA;
+  Sequence s;
+
+  EXPECT_CALL(*a, DoA(1))
+      .Times(EvenNumber())
+      .InSequence(s);
+  EXPECT_CALL(*a, DoA(2))
+      .Times(AnyNumber())
+      .InSequence(s);
+  EXPECT_CALL(*a, DoA(3))
+      .Times(AnyNumber());
+
+  a->DoA(3);
+  a->DoA(1);
+  EXPECT_NONFATAL_FAILURE(a->DoA(2), "Unexpected mock function call");
+  EXPECT_NONFATAL_FAILURE(delete a, "to be called even number of times");
+}
+
+// The following tests verify the message generated when a mock
+// function is called.
+
+struct Printable {
+};
+
+inline void operator<<(::std::ostream& os, const Printable&) {
+  os << "Printable";
+}
+
+struct Unprintable {
+  Unprintable() : value(0) {}
+  int value;
+};
+
+class MockC {
+ public:
+  MockC() {}
+
+  MOCK_METHOD6(VoidMethod, void(bool cond, int n, string s, void* p,
+                                const Printable& x, Unprintable y));
+  MOCK_METHOD0(NonVoidMethod, int());  // NOLINT
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockC);
+};
+
+class VerboseFlagPreservingFixture : public testing::Test {
+ protected:
+  VerboseFlagPreservingFixture()
+      : saved_verbose_flag_(GMOCK_FLAG(verbose)) {}
+
+  ~VerboseFlagPreservingFixture() { GMOCK_FLAG(verbose) = saved_verbose_flag_; }
+
+ private:
+  const string saved_verbose_flag_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(VerboseFlagPreservingFixture);
+};
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Tests that an uninteresting mock function call on a naggy mock
+// generates a warning without the stack trace when
+// --gmock_verbose=warning is specified.
+TEST(FunctionCallMessageTest,
+     UninterestingCallOnNaggyMockGeneratesNoStackTraceWhenVerboseWarning) {
+  GMOCK_FLAG(verbose) = kWarningVerbosity;
+  NaggyMock<MockC> c;
+  CaptureStdout();
+  c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
+  const std::string output = GetCapturedStdout();
+  EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output);
+  EXPECT_PRED_FORMAT2(IsNotSubstring, "Stack trace:", output);
+}
+
+// Tests that an uninteresting mock function call on a naggy mock
+// generates a warning containing the stack trace when
+// --gmock_verbose=info is specified.
+TEST(FunctionCallMessageTest,
+     UninterestingCallOnNaggyMockGeneratesFyiWithStackTraceWhenVerboseInfo) {
+  GMOCK_FLAG(verbose) = kInfoVerbosity;
+  NaggyMock<MockC> c;
+  CaptureStdout();
+  c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
+  const std::string output = GetCapturedStdout();
+  EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output);
+  EXPECT_PRED_FORMAT2(IsSubstring, "Stack trace:", output);
+
+# ifndef NDEBUG
+
+  // We check the stack trace content in dbg-mode only, as opt-mode
+  // may inline the call we are interested in seeing.
+
+  // Verifies that a void mock function's name appears in the stack
+  // trace.
+  EXPECT_PRED_FORMAT2(IsSubstring, "VoidMethod(", output);
+
+  // Verifies that a non-void mock function's name appears in the
+  // stack trace.
+  CaptureStdout();
+  c.NonVoidMethod();
+  const std::string output2 = GetCapturedStdout();
+  EXPECT_PRED_FORMAT2(IsSubstring, "NonVoidMethod(", output2);
+
+# endif  // NDEBUG
+}
+
+// Tests that an uninteresting mock function call on a naggy mock
+// causes the function arguments and return value to be printed.
+TEST(FunctionCallMessageTest,
+     UninterestingCallOnNaggyMockPrintsArgumentsAndReturnValue) {
+  // A non-void mock function.
+  NaggyMock<MockB> b;
+  CaptureStdout();
+  b.DoB();
+  const std::string output1 = GetCapturedStdout();
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Uninteresting mock function call - returning default value.\n"
+      "    Function call: DoB()\n"
+      "          Returns: 0\n", output1.c_str());
+  // Makes sure the return value is printed.
+
+  // A void mock function.
+  NaggyMock<MockC> c;
+  CaptureStdout();
+  c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
+  const std::string output2 = GetCapturedStdout();
+  EXPECT_THAT(output2.c_str(),
+              ContainsRegex(
+                  "Uninteresting mock function call - returning directly\\.\n"
+                  "    Function call: VoidMethod"
+                  "\\(false, 5, \"Hi\", NULL, @.+ "
+                  "Printable, 4-byte object <00-00 00-00>\\)"));
+  // A void function has no return value to print.
+}
+
+// Tests how the --gmock_verbose flag affects Google Mock's output.
+
+class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
+ public:
+  // Verifies that the given Google Mock output is correct.  (When
+  // should_print is true, the output should match the given regex and
+  // contain the given function name in the stack trace.  When it's
+  // false, the output should be empty.)
+  void VerifyOutput(const std::string& output, bool should_print,
+                    const string& expected_substring,
+                    const string& function_name) {
+    if (should_print) {
+      EXPECT_THAT(output.c_str(), HasSubstr(expected_substring));
+# ifndef NDEBUG
+      // We check the stack trace content in dbg-mode only, as opt-mode
+      // may inline the call we are interested in seeing.
+      EXPECT_THAT(output.c_str(), HasSubstr(function_name));
+# else
+      // Suppresses 'unused function parameter' warnings.
+      static_cast<void>(function_name);
+# endif  // NDEBUG
+    } else {
+      EXPECT_STREQ("", output.c_str());
+    }
+  }
+
+  // Tests how the flag affects expected calls.
+  void TestExpectedCall(bool should_print) {
+    MockA a;
+    EXPECT_CALL(a, DoA(5));
+    EXPECT_CALL(a, Binary(_, 1))
+        .WillOnce(Return(true));
+
+    // A void-returning function.
+    CaptureStdout();
+    a.DoA(5);
+    VerifyOutput(
+        GetCapturedStdout(),
+        should_print,
+        "Mock function call matches EXPECT_CALL(a, DoA(5))...\n"
+        "    Function call: DoA(5)\n"
+        "Stack trace:\n",
+        "DoA");
+
+    // A non-void-returning function.
+    CaptureStdout();
+    a.Binary(2, 1);
+    VerifyOutput(
+        GetCapturedStdout(),
+        should_print,
+        "Mock function call matches EXPECT_CALL(a, Binary(_, 1))...\n"
+        "    Function call: Binary(2, 1)\n"
+        "          Returns: true\n"
+        "Stack trace:\n",
+        "Binary");
+  }
+
+  // Tests how the flag affects uninteresting calls on a naggy mock.
+  void TestUninterestingCallOnNaggyMock(bool should_print) {
+    NaggyMock<MockA> a;
+    const string note =
+        "NOTE: 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/googlemock/docs/CookBook.md#"
+        "knowing-when-to-expect for details.";
+
+    // A void-returning function.
+    CaptureStdout();
+    a.DoA(5);
+    VerifyOutput(
+        GetCapturedStdout(),
+        should_print,
+        "\nGMOCK WARNING:\n"
+        "Uninteresting mock function call - returning directly.\n"
+        "    Function call: DoA(5)\n" +
+        note,
+        "DoA");
+
+    // A non-void-returning function.
+    CaptureStdout();
+    a.Binary(2, 1);
+    VerifyOutput(
+        GetCapturedStdout(),
+        should_print,
+        "\nGMOCK WARNING:\n"
+        "Uninteresting mock function call - returning default value.\n"
+        "    Function call: Binary(2, 1)\n"
+        "          Returns: false\n" +
+        note,
+        "Binary");
+  }
+};
+
+// Tests that --gmock_verbose=info causes both expected and
+// uninteresting calls to be reported.
+TEST_F(GMockVerboseFlagTest, Info) {
+  GMOCK_FLAG(verbose) = kInfoVerbosity;
+  TestExpectedCall(true);
+  TestUninterestingCallOnNaggyMock(true);
+}
+
+// Tests that --gmock_verbose=warning causes uninteresting calls to be
+// reported.
+TEST_F(GMockVerboseFlagTest, Warning) {
+  GMOCK_FLAG(verbose) = kWarningVerbosity;
+  TestExpectedCall(false);
+  TestUninterestingCallOnNaggyMock(true);
+}
+
+// Tests that --gmock_verbose=warning causes neither expected nor
+// uninteresting calls to be reported.
+TEST_F(GMockVerboseFlagTest, Error) {
+  GMOCK_FLAG(verbose) = kErrorVerbosity;
+  TestExpectedCall(false);
+  TestUninterestingCallOnNaggyMock(false);
+}
+
+// Tests that --gmock_verbose=SOME_INVALID_VALUE has the same effect
+// as --gmock_verbose=warning.
+TEST_F(GMockVerboseFlagTest, InvalidFlagIsTreatedAsWarning) {
+  GMOCK_FLAG(verbose) = "invalid";  // Treated as "warning".
+  TestExpectedCall(false);
+  TestUninterestingCallOnNaggyMock(true);
+}
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// A helper class that generates a failure when printed.  We use it to
+// ensure that Google Mock doesn't print a value (even to an internal
+// buffer) when it is not supposed to do so.
+class PrintMeNot {};
+
+void PrintTo(PrintMeNot /* dummy */, ::std::ostream* /* os */) {
+  ADD_FAILURE() << "Google Mock is printing a value that shouldn't be "
+                << "printed even to an internal buffer.";
+}
+
+class LogTestHelper {
+ public:
+  LogTestHelper() {}
+
+  MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(LogTestHelper);
+};
+
+class GMockLogTest : public VerboseFlagPreservingFixture {
+ protected:
+  LogTestHelper helper_;
+};
+
+TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsWarning) {
+  GMOCK_FLAG(verbose) = kWarningVerbosity;
+  EXPECT_CALL(helper_, Foo(_))
+      .WillOnce(Return(PrintMeNot()));
+  helper_.Foo(PrintMeNot());  // This is an expected call.
+}
+
+TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsError) {
+  GMOCK_FLAG(verbose) = kErrorVerbosity;
+  EXPECT_CALL(helper_, Foo(_))
+      .WillOnce(Return(PrintMeNot()));
+  helper_.Foo(PrintMeNot());  // This is an expected call.
+}
+
+TEST_F(GMockLogTest, DoesNotPrintWarningInternallyIfVerbosityIsError) {
+  GMOCK_FLAG(verbose) = kErrorVerbosity;
+  ON_CALL(helper_, Foo(_))
+      .WillByDefault(Return(PrintMeNot()));
+  helper_.Foo(PrintMeNot());  // This should generate a warning.
+}
+
+// Tests Mock::AllowLeak().
+
+TEST(AllowLeakTest, AllowsLeakingUnusedMockObject) {
+  MockA* a = new MockA;
+  Mock::AllowLeak(a);
+}
+
+TEST(AllowLeakTest, CanBeCalledBeforeOnCall) {
+  MockA* a = new MockA;
+  Mock::AllowLeak(a);
+  ON_CALL(*a, DoA(_)).WillByDefault(Return());
+  a->DoA(0);
+}
+
+TEST(AllowLeakTest, CanBeCalledAfterOnCall) {
+  MockA* a = new MockA;
+  ON_CALL(*a, DoA(_)).WillByDefault(Return());
+  Mock::AllowLeak(a);
+}
+
+TEST(AllowLeakTest, CanBeCalledBeforeExpectCall) {
+  MockA* a = new MockA;
+  Mock::AllowLeak(a);
+  EXPECT_CALL(*a, DoA(_));
+  a->DoA(0);
+}
+
+TEST(AllowLeakTest, CanBeCalledAfterExpectCall) {
+  MockA* a = new MockA;
+  EXPECT_CALL(*a, DoA(_)).Times(AnyNumber());
+  Mock::AllowLeak(a);
+}
+
+TEST(AllowLeakTest, WorksWhenBothOnCallAndExpectCallArePresent) {
+  MockA* a = new MockA;
+  ON_CALL(*a, DoA(_)).WillByDefault(Return());
+  EXPECT_CALL(*a, DoA(_)).Times(AnyNumber());
+  Mock::AllowLeak(a);
+}
+
+// Tests that we can verify and clear a mock object's expectations
+// when none of its methods has expectations.
+TEST(VerifyAndClearExpectationsTest, NoMethodHasExpectations) {
+  MockB b;
+  ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
+
+  // There should be no expectations on the methods now, so we can
+  // freely call them.
+  EXPECT_EQ(0, b.DoB());
+  EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can verify and clear a mock object's expectations
+// when some, but not all, of its methods have expectations *and* the
+// verification succeeds.
+TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndSucceed) {
+  MockB b;
+  EXPECT_CALL(b, DoB())
+      .WillOnce(Return(1));
+  b.DoB();
+  ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
+
+  // There should be no expectations on the methods now, so we can
+  // freely call them.
+  EXPECT_EQ(0, b.DoB());
+  EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can verify and clear a mock object's expectations
+// when some, but not all, of its methods have expectations *and* the
+// verification fails.
+TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndFail) {
+  MockB b;
+  EXPECT_CALL(b, DoB())
+      .WillOnce(Return(1));
+  bool result = true;
+  EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
+                          "Actual: never called");
+  ASSERT_FALSE(result);
+
+  // There should be no expectations on the methods now, so we can
+  // freely call them.
+  EXPECT_EQ(0, b.DoB());
+  EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can verify and clear a mock object's expectations
+// when all of its methods have expectations.
+TEST(VerifyAndClearExpectationsTest, AllMethodsHaveExpectations) {
+  MockB b;
+  EXPECT_CALL(b, DoB())
+      .WillOnce(Return(1));
+  EXPECT_CALL(b, DoB(_))
+      .WillOnce(Return(2));
+  b.DoB();
+  b.DoB(1);
+  ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
+
+  // There should be no expectations on the methods now, so we can
+  // freely call them.
+  EXPECT_EQ(0, b.DoB());
+  EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can verify and clear a mock object's expectations
+// when a method has more than one expectation.
+TEST(VerifyAndClearExpectationsTest, AMethodHasManyExpectations) {
+  MockB b;
+  EXPECT_CALL(b, DoB(0))
+      .WillOnce(Return(1));
+  EXPECT_CALL(b, DoB(_))
+      .WillOnce(Return(2));
+  b.DoB(1);
+  bool result = true;
+  EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
+                          "Actual: never called");
+  ASSERT_FALSE(result);
+
+  // There should be no expectations on the methods now, so we can
+  // freely call them.
+  EXPECT_EQ(0, b.DoB());
+  EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can call VerifyAndClearExpectations() on the same
+// mock object multiple times.
+TEST(VerifyAndClearExpectationsTest, CanCallManyTimes) {
+  MockB b;
+  EXPECT_CALL(b, DoB());
+  b.DoB();
+  Mock::VerifyAndClearExpectations(&b);
+
+  EXPECT_CALL(b, DoB(_))
+      .WillOnce(Return(1));
+  b.DoB(1);
+  Mock::VerifyAndClearExpectations(&b);
+  Mock::VerifyAndClearExpectations(&b);
+
+  // There should be no expectations on the methods now, so we can
+  // freely call them.
+  EXPECT_EQ(0, b.DoB());
+  EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can clear a mock object's default actions when none
+// of its methods has default actions.
+TEST(VerifyAndClearTest, NoMethodHasDefaultActions) {
+  MockB b;
+  // If this crashes or generates a failure, the test will catch it.
+  Mock::VerifyAndClear(&b);
+  EXPECT_EQ(0, b.DoB());
+}
+
+// Tests that we can clear a mock object's default actions when some,
+// but not all of its methods have default actions.
+TEST(VerifyAndClearTest, SomeMethodsHaveDefaultActions) {
+  MockB b;
+  ON_CALL(b, DoB())
+      .WillByDefault(Return(1));
+
+  Mock::VerifyAndClear(&b);
+
+  // Verifies that the default action of int DoB() was removed.
+  EXPECT_EQ(0, b.DoB());
+}
+
+// Tests that we can clear a mock object's default actions when all of
+// its methods have default actions.
+TEST(VerifyAndClearTest, AllMethodsHaveDefaultActions) {
+  MockB b;
+  ON_CALL(b, DoB())
+      .WillByDefault(Return(1));
+  ON_CALL(b, DoB(_))
+      .WillByDefault(Return(2));
+
+  Mock::VerifyAndClear(&b);
+
+  // Verifies that the default action of int DoB() was removed.
+  EXPECT_EQ(0, b.DoB());
+
+  // Verifies that the default action of int DoB(int) was removed.
+  EXPECT_EQ(0, b.DoB(0));
+}
+
+// Tests that we can clear a mock object's default actions when a
+// method has more than one ON_CALL() set on it.
+TEST(VerifyAndClearTest, AMethodHasManyDefaultActions) {
+  MockB b;
+  ON_CALL(b, DoB(0))
+      .WillByDefault(Return(1));
+  ON_CALL(b, DoB(_))
+      .WillByDefault(Return(2));
+
+  Mock::VerifyAndClear(&b);
+
+  // Verifies that the default actions (there are two) of int DoB(int)
+  // were removed.
+  EXPECT_EQ(0, b.DoB(0));
+  EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can call VerifyAndClear() on a mock object multiple
+// times.
+TEST(VerifyAndClearTest, CanCallManyTimes) {
+  MockB b;
+  ON_CALL(b, DoB())
+      .WillByDefault(Return(1));
+  Mock::VerifyAndClear(&b);
+  Mock::VerifyAndClear(&b);
+
+  ON_CALL(b, DoB(_))
+      .WillByDefault(Return(1));
+  Mock::VerifyAndClear(&b);
+
+  EXPECT_EQ(0, b.DoB());
+  EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that VerifyAndClear() works when the verification succeeds.
+TEST(VerifyAndClearTest, Success) {
+  MockB b;
+  ON_CALL(b, DoB())
+      .WillByDefault(Return(1));
+  EXPECT_CALL(b, DoB(1))
+      .WillOnce(Return(2));
+
+  b.DoB();
+  b.DoB(1);
+  ASSERT_TRUE(Mock::VerifyAndClear(&b));
+
+  // There should be no expectations on the methods now, so we can
+  // freely call them.
+  EXPECT_EQ(0, b.DoB());
+  EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that VerifyAndClear() works when the verification fails.
+TEST(VerifyAndClearTest, Failure) {
+  MockB b;
+  ON_CALL(b, DoB(_))
+      .WillByDefault(Return(1));
+  EXPECT_CALL(b, DoB())
+      .WillOnce(Return(2));
+
+  b.DoB(1);
+  bool result = true;
+  EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClear(&b),
+                          "Actual: never called");
+  ASSERT_FALSE(result);
+
+  // There should be no expectations on the methods now, so we can
+  // freely call them.
+  EXPECT_EQ(0, b.DoB());
+  EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that VerifyAndClear() works when the default actions and
+// expectations are set on a const mock object.
+TEST(VerifyAndClearTest, Const) {
+  MockB b;
+  ON_CALL(Const(b), DoB())
+      .WillByDefault(Return(1));
+
+  EXPECT_CALL(Const(b), DoB())
+      .WillOnce(DoDefault())
+      .WillOnce(Return(2));
+
+  b.DoB();
+  b.DoB();
+  ASSERT_TRUE(Mock::VerifyAndClear(&b));
+
+  // There should be no expectations on the methods now, so we can
+  // freely call them.
+  EXPECT_EQ(0, b.DoB());
+  EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can set default actions and expectations on a mock
+// object after VerifyAndClear() has been called on it.
+TEST(VerifyAndClearTest, CanSetDefaultActionsAndExpectationsAfterwards) {
+  MockB b;
+  ON_CALL(b, DoB())
+      .WillByDefault(Return(1));
+  EXPECT_CALL(b, DoB(_))
+      .WillOnce(Return(2));
+  b.DoB(1);
+
+  Mock::VerifyAndClear(&b);
+
+  EXPECT_CALL(b, DoB())
+      .WillOnce(Return(3));
+  ON_CALL(b, DoB(_))
+      .WillByDefault(Return(4));
+
+  EXPECT_EQ(3, b.DoB());
+  EXPECT_EQ(4, b.DoB(1));
+}
+
+// Tests that calling VerifyAndClear() on one mock object does not
+// affect other mock objects (either of the same type or not).
+TEST(VerifyAndClearTest, DoesNotAffectOtherMockObjects) {
+  MockA a;
+  MockB b1;
+  MockB b2;
+
+  ON_CALL(a, Binary(_, _))
+      .WillByDefault(Return(true));
+  EXPECT_CALL(a, Binary(_, _))
+      .WillOnce(DoDefault())
+      .WillOnce(Return(false));
+
+  ON_CALL(b1, DoB())
+      .WillByDefault(Return(1));
+  EXPECT_CALL(b1, DoB(_))
+      .WillOnce(Return(2));
+
+  ON_CALL(b2, DoB())
+      .WillByDefault(Return(3));
+  EXPECT_CALL(b2, DoB(_));
+
+  b2.DoB(0);
+  Mock::VerifyAndClear(&b2);
+
+  // Verifies that the default actions and expectations of a and b1
+  // are still in effect.
+  EXPECT_TRUE(a.Binary(0, 0));
+  EXPECT_FALSE(a.Binary(0, 0));
+
+  EXPECT_EQ(1, b1.DoB());
+  EXPECT_EQ(2, b1.DoB(0));
+}
+
+TEST(VerifyAndClearTest,
+     DestroyingChainedMocksDoesNotDeadlockThroughExpectations) {
+  linked_ptr<MockA> a(new MockA);
+  ReferenceHoldingMock test_mock;
+
+  // EXPECT_CALL stores a reference to a inside test_mock.
+  EXPECT_CALL(test_mock, AcceptReference(_))
+      .WillRepeatedly(SetArgPointee<0>(a));
+
+  // Throw away the reference to the mock that we have in a. After this, the
+  // only reference to it is stored by test_mock.
+  a.reset();
+
+  // When test_mock goes out of scope, it destroys the last remaining reference
+  // to the mock object originally pointed to by a. This will cause the MockA
+  // destructor to be called from inside the ReferenceHoldingMock destructor.
+  // The state of all mocks is protected by a single global lock, but there
+  // should be no deadlock.
+}
+
+TEST(VerifyAndClearTest,
+     DestroyingChainedMocksDoesNotDeadlockThroughDefaultAction) {
+  linked_ptr<MockA> a(new MockA);
+  ReferenceHoldingMock test_mock;
+
+  // ON_CALL stores a reference to a inside test_mock.
+  ON_CALL(test_mock, AcceptReference(_))
+      .WillByDefault(SetArgPointee<0>(a));
+
+  // Throw away the reference to the mock that we have in a. After this, the
+  // only reference to it is stored by test_mock.
+  a.reset();
+
+  // When test_mock goes out of scope, it destroys the last remaining reference
+  // to the mock object originally pointed to by a. This will cause the MockA
+  // destructor to be called from inside the ReferenceHoldingMock destructor.
+  // The state of all mocks is protected by a single global lock, but there
+  // should be no deadlock.
+}
+
+// Tests that a mock function's action can call a mock function
+// (either the same function or a different one) either as an explicit
+// action or as a default action without causing a dead lock.  It
+// verifies that the action is not performed inside the critical
+// section.
+TEST(SynchronizationTest, CanCallMockMethodInAction) {
+  MockA a;
+  MockC c;
+  ON_CALL(a, DoA(_))
+      .WillByDefault(IgnoreResult(InvokeWithoutArgs(&c,
+                                                    &MockC::NonVoidMethod)));
+  EXPECT_CALL(a, DoA(1));
+  EXPECT_CALL(a, DoA(1))
+      .WillOnce(Invoke(&a, &MockA::DoA))
+      .RetiresOnSaturation();
+  EXPECT_CALL(c, NonVoidMethod());
+
+  a.DoA(1);
+  // This will match the second EXPECT_CALL() and trigger another a.DoA(1),
+  // which will in turn match the first EXPECT_CALL() and trigger a call to
+  // c.NonVoidMethod() that was specified by the ON_CALL() since the first
+  // EXPECT_CALL() did not specify an action.
+}
+
+}  // namespace
+
+// Allows the user to define his own main and then invoke gmock_main
+// from it. This might be necessary on some platforms which require
+// specific setup and teardown.
+#if GMOCK_RENAME_MAIN
+int gmock_main(int argc, char **argv) {
+#else
+int main(int argc, char **argv) {
+#endif  // GMOCK_RENAME_MAIN
+  testing::InitGoogleMock(&argc, argv);
+
+  // Ensures that the tests pass no matter what value of
+  // --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
+  testing::GMOCK_FLAG(catch_leaked_mocks) = true;
+  testing::GMOCK_FLAG(verbose) = testing::internal::kWarningVerbosity;
+
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_all_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_all_test.cc
new file mode 100644
index 00000000..56d6c49c
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_all_test.cc
@@ -0,0 +1,51 @@
+// Copyright 2009, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Tests for Google C++ Mocking Framework (Google Mock)
+//
+// Some users use a build system that Google Mock doesn't support directly,
+// yet they still want to build and run Google Mock's own tests.  This file
+// includes most such tests, making it easier for these users to maintain
+// their build scripts (they just need to build this file, even though the
+// below list of actual *_test.cc files might change).
+#include "test/gmock-actions_test.cc"
+#include "test/gmock-cardinalities_test.cc"
+#include "test/gmock-generated-actions_test.cc"
+#include "test/gmock-generated-function-mockers_test.cc"
+#include "test/gmock-generated-internal-utils_test.cc"
+#include "test/gmock-generated-matchers_test.cc"
+#include "test/gmock-internal-utils_test.cc"
+#include "test/gmock-matchers_test.cc"
+#include "test/gmock-more-actions_test.cc"
+#include "test/gmock-nice-strict_test.cc"
+#include "test/gmock-port_test.cc"
+#include "test/gmock-spec-builders_test.cc"
+#include "test/gmock_test.cc"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_ex_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_ex_test.cc
new file mode 100644
index 00000000..3afed86a
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_ex_test.cc
@@ -0,0 +1,81 @@
+// Copyright 2013, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Tests Google Mock's functionality that depends on exceptions.
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+using testing::HasSubstr;
+using testing::internal::GoogleTestFailureException;
+
+// A type that cannot be default constructed.
+class NonDefaultConstructible {
+ public:
+  explicit NonDefaultConstructible(int /* dummy */) {}
+};
+
+class MockFoo {
+ public:
+  // A mock method that returns a user-defined type.  Google Mock
+  // doesn't know what the default value for this type is.
+  MOCK_METHOD0(GetNonDefaultConstructible, NonDefaultConstructible());
+};
+
+#if GTEST_HAS_EXCEPTIONS
+
+TEST(DefaultValueTest, ThrowsRuntimeErrorWhenNoDefaultValue) {
+  MockFoo mock;
+  try {
+    // No expectation is set on this method, so Google Mock must
+    // return the default value.  However, since Google Mock knows
+    // nothing about the return type, it doesn't know what to return,
+    // and has to throw (when exceptions are enabled) or abort
+    // (otherwise).
+    mock.GetNonDefaultConstructible();
+    FAIL() << "GetNonDefaultConstructible()'s return type has no default "
+           << "value, so Google Mock should have thrown.";
+  } catch (const GoogleTestFailureException& /* unused */) {
+    FAIL() << "Google Test does not try to catch an exception of type "
+           << "GoogleTestFailureException, which is used for reporting "
+           << "a failure to other testing frameworks.  Google Mock should "
+           << "not throw a GoogleTestFailureException as it will kill the "
+           << "entire test program instead of just the current TEST.";
+  } catch (const std::exception& ex) {
+    EXPECT_THAT(ex.what(), HasSubstr("has no default value"));
+  }
+}
+
+#endif
+
+}  // unnamed namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test.py
new file mode 100755
index 00000000..997680ce
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test.py
@@ -0,0 +1,108 @@
+#!/usr/bin/env python
+#
+# Copyright 2009, 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.
+
+"""Tests that leaked mock objects can be caught be Google Mock."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+
+import gmock_test_utils
+
+
+PROGRAM_PATH = gmock_test_utils.GetTestExecutablePath('gmock_leak_test_')
+TEST_WITH_EXPECT_CALL = [PROGRAM_PATH, '--gtest_filter=*ExpectCall*']
+TEST_WITH_ON_CALL = [PROGRAM_PATH, '--gtest_filter=*OnCall*']
+TEST_MULTIPLE_LEAKS = [PROGRAM_PATH, '--gtest_filter=*MultipleLeaked*']
+
+environ = gmock_test_utils.environ
+SetEnvVar = gmock_test_utils.SetEnvVar
+
+# Tests in this file run a Google-Test-based test program and expect it
+# to terminate prematurely.  Therefore they are incompatible with
+# the premature-exit-file protocol by design.  Unset the
+# premature-exit filepath to prevent Google Test from creating
+# the file.
+SetEnvVar(gmock_test_utils.PREMATURE_EXIT_FILE_ENV_VAR, None)
+
+
+class GMockLeakTest(gmock_test_utils.TestCase):
+
+  def testCatchesLeakedMockByDefault(self):
+    self.assertNotEqual(
+        0,
+        gmock_test_utils.Subprocess(TEST_WITH_EXPECT_CALL,
+                                    env=environ).exit_code)
+    self.assertNotEqual(
+        0,
+        gmock_test_utils.Subprocess(TEST_WITH_ON_CALL,
+                                    env=environ).exit_code)
+
+  def testDoesNotCatchLeakedMockWhenDisabled(self):
+    self.assertEquals(
+        0,
+        gmock_test_utils.Subprocess(TEST_WITH_EXPECT_CALL +
+                                    ['--gmock_catch_leaked_mocks=0'],
+                                    env=environ).exit_code)
+    self.assertEquals(
+        0,
+        gmock_test_utils.Subprocess(TEST_WITH_ON_CALL +
+                                    ['--gmock_catch_leaked_mocks=0'],
+                                    env=environ).exit_code)
+
+  def testCatchesLeakedMockWhenEnabled(self):
+    self.assertNotEqual(
+        0,
+        gmock_test_utils.Subprocess(TEST_WITH_EXPECT_CALL +
+                                    ['--gmock_catch_leaked_mocks'],
+                                    env=environ).exit_code)
+    self.assertNotEqual(
+        0,
+        gmock_test_utils.Subprocess(TEST_WITH_ON_CALL +
+                                    ['--gmock_catch_leaked_mocks'],
+                                    env=environ).exit_code)
+
+  def testCatchesLeakedMockWhenEnabledWithExplictFlagValue(self):
+    self.assertNotEqual(
+        0,
+        gmock_test_utils.Subprocess(TEST_WITH_EXPECT_CALL +
+                                    ['--gmock_catch_leaked_mocks=1'],
+                                    env=environ).exit_code)
+
+  def testCatchesMultipleLeakedMocks(self):
+    self.assertNotEqual(
+        0,
+        gmock_test_utils.Subprocess(TEST_MULTIPLE_LEAKS +
+                                    ['--gmock_catch_leaked_mocks'],
+                                    env=environ).exit_code)
+
+
+if __name__ == '__main__':
+  gmock_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test_.cc
new file mode 100644
index 00000000..1d27d22f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test_.cc
@@ -0,0 +1,100 @@
+// Copyright 2009, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This program is for verifying that a leaked mock object can be
+// caught by Google Mock's leak detector.
+
+#include "gmock/gmock.h"
+
+namespace {
+
+using ::testing::Return;
+
+class FooInterface {
+ public:
+  virtual ~FooInterface() {}
+  virtual void DoThis() = 0;
+};
+
+class MockFoo : public FooInterface {
+ public:
+  MockFoo() {}
+
+  MOCK_METHOD0(DoThis, void());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
+};
+
+TEST(LeakTest, LeakedMockWithExpectCallCausesFailureWhenLeakCheckingIsEnabled) {
+  MockFoo* foo = new MockFoo;
+
+  EXPECT_CALL(*foo, DoThis());
+  foo->DoThis();
+
+  // In order to test the leak detector, we deliberately leak foo.
+
+  // Makes sure Google Mock's leak detector can change the exit code
+  // to 1 even when the code is already exiting with 0.
+  exit(0);
+}
+
+TEST(LeakTest, LeakedMockWithOnCallCausesFailureWhenLeakCheckingIsEnabled) {
+  MockFoo* foo = new MockFoo;
+
+  ON_CALL(*foo, DoThis()).WillByDefault(Return());
+
+  // In order to test the leak detector, we deliberately leak foo.
+
+  // Makes sure Google Mock's leak detector can change the exit code
+  // to 1 even when the code is already exiting with 0.
+  exit(0);
+}
+
+TEST(LeakTest, CatchesMultipleLeakedMockObjects) {
+  MockFoo* foo1 = new MockFoo;
+  MockFoo* foo2 = new MockFoo;
+
+  ON_CALL(*foo1, DoThis()).WillByDefault(Return());
+  EXPECT_CALL(*foo2, DoThis());
+  foo2->DoThis();
+
+  // In order to test the leak detector, we deliberately leak foo1 and
+  // foo2.
+
+  // Makes sure Google Mock's leak detector can change the exit code
+  // to 1 even when the code is already exiting with 0.
+  exit(0);
+}
+
+}  // namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link2_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link2_test.cc
new file mode 100644
index 00000000..4c310c3d
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link2_test.cc
@@ -0,0 +1,40 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file is for verifying that various Google Mock constructs do not
+// produce linker errors when instantiated in different translation units.
+// Please see gmock_link_test.h for details.
+
+#define LinkTest LinkTest2
+
+#include  "test/gmock_link_test.h"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.cc
new file mode 100644
index 00000000..61e97d10
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.cc
@@ -0,0 +1,40 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file is for verifying that various Google Mock constructs do not
+// produce linker errors when instantiated in different translation units.
+// Please see gmock_link_test.h for details.
+
+#define LinkTest LinkTest1
+
+#include  "test/gmock_link_test.h"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.h
new file mode 100644
index 00000000..1f55f5bd
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.h
@@ -0,0 +1,669 @@
+// Copyright 2009, 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests that:
+// a. A header file defining a mock class can be included in multiple
+//    translation units without causing a link error.
+// b. Actions and matchers can be instantiated with identical template
+//    arguments in different translation units without causing link
+//    errors.
+//    The following constructs are currently tested:
+//    Actions:
+//      Return()
+//      Return(value)
+//      ReturnNull
+//      ReturnRef
+//      Assign
+//      SetArgPointee
+//      SetArrayArgument
+//      SetErrnoAndReturn
+//      Invoke(function)
+//      Invoke(object, method)
+//      InvokeWithoutArgs(function)
+//      InvokeWithoutArgs(object, method)
+//      InvokeArgument
+//      WithArg
+//      WithArgs
+//      WithoutArgs
+//      DoAll
+//      DoDefault
+//      IgnoreResult
+//      Throw
+//      ACTION()-generated
+//      ACTION_P()-generated
+//      ACTION_P2()-generated
+//    Matchers:
+//      _
+//      A
+//      An
+//      Eq
+//      Gt, Lt, Ge, Le, Ne
+//      NotNull
+//      Ref
+//      TypedEq
+//      DoubleEq
+//      FloatEq
+//      NanSensitiveDoubleEq
+//      NanSensitiveFloatEq
+//      ContainsRegex
+//      MatchesRegex
+//      EndsWith
+//      HasSubstr
+//      StartsWith
+//      StrCaseEq
+//      StrCaseNe
+//      StrEq
+//      StrNe
+//      ElementsAre
+//      ElementsAreArray
+//      ContainerEq
+//      Field
+//      Property
+//      ResultOf(function)
+//      Pointee
+//      Truly(predicate)
+//      AllOf
+//      AnyOf
+//      Not
+//      MatcherCast<T>
+//
+//  Please note: this test does not verify the functioning of these
+//  constructs, only that the programs using them will link successfully.
+//
+// Implementation note:
+// This test requires identical definitions of Interface and Mock to be
+// included in different translation units.  We achieve this by writing
+// them in this header and #including it in gmock_link_test.cc and
+// gmock_link2_test.cc.  Because the symbols generated by the compiler for
+// those constructs must be identical in both translation units,
+// definitions of Interface and Mock tests MUST be kept in the SAME
+// NON-ANONYMOUS namespace in this file.  The test fixture class LinkTest
+// is defined as LinkTest1 in gmock_link_test.cc and as LinkTest2 in
+// gmock_link2_test.cc to avoid producing linker errors.
+
+#ifndef GMOCK_TEST_GMOCK_LINK_TEST_H_
+#define GMOCK_TEST_GMOCK_LINK_TEST_H_
+
+#include "gmock/gmock.h"
+
+#if !GTEST_OS_WINDOWS_MOBILE
+# include <errno.h>
+#endif
+
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+#include <iostream>
+#include <vector>
+
+using testing::_;
+using testing::A;
+using testing::AllOf;
+using testing::AnyOf;
+using testing::Assign;
+using testing::ContainerEq;
+using testing::DoAll;
+using testing::DoDefault;
+using testing::DoubleEq;
+using testing::ElementsAre;
+using testing::ElementsAreArray;
+using testing::EndsWith;
+using testing::Eq;
+using testing::Field;
+using testing::FloatEq;
+using testing::Ge;
+using testing::Gt;
+using testing::HasSubstr;
+using testing::IgnoreResult;
+using testing::Invoke;
+using testing::InvokeArgument;
+using testing::InvokeWithoutArgs;
+using testing::IsNull;
+using testing::Le;
+using testing::Lt;
+using testing::Matcher;
+using testing::MatcherCast;
+using testing::NanSensitiveDoubleEq;
+using testing::NanSensitiveFloatEq;
+using testing::Ne;
+using testing::Not;
+using testing::NotNull;
+using testing::Pointee;
+using testing::Property;
+using testing::Ref;
+using testing::ResultOf;
+using testing::Return;
+using testing::ReturnNull;
+using testing::ReturnRef;
+using testing::SetArgPointee;
+using testing::SetArrayArgument;
+using testing::StartsWith;
+using testing::StrCaseEq;
+using testing::StrCaseNe;
+using testing::StrEq;
+using testing::StrNe;
+using testing::Truly;
+using testing::TypedEq;
+using testing::WithArg;
+using testing::WithArgs;
+using testing::WithoutArgs;
+
+#if !GTEST_OS_WINDOWS_MOBILE
+using testing::SetErrnoAndReturn;
+#endif
+
+#if GTEST_HAS_EXCEPTIONS
+using testing::Throw;
+#endif
+
+using testing::ContainsRegex;
+using testing::MatchesRegex;
+
+class Interface {
+ public:
+  virtual ~Interface() {}
+  virtual void VoidFromString(char* str) = 0;
+  virtual char* StringFromString(char* str) = 0;
+  virtual int IntFromString(char* str) = 0;
+  virtual int& IntRefFromString(char* str) = 0;
+  virtual void VoidFromFunc(void(*func)(char* str)) = 0;
+  virtual void VoidFromIntRef(int& n) = 0;  // NOLINT
+  virtual void VoidFromFloat(float n) = 0;
+  virtual void VoidFromDouble(double n) = 0;
+  virtual void VoidFromVector(const std::vector<int>& v) = 0;
+};
+
+class Mock: public Interface {
+ public:
+  Mock() {}
+
+  MOCK_METHOD1(VoidFromString, void(char* str));
+  MOCK_METHOD1(StringFromString, char*(char* str));
+  MOCK_METHOD1(IntFromString, int(char* str));
+  MOCK_METHOD1(IntRefFromString, int&(char* str));
+  MOCK_METHOD1(VoidFromFunc, void(void(*func)(char* str)));
+  MOCK_METHOD1(VoidFromIntRef, void(int& n));  // NOLINT
+  MOCK_METHOD1(VoidFromFloat, void(float n));
+  MOCK_METHOD1(VoidFromDouble, void(double n));
+  MOCK_METHOD1(VoidFromVector, void(const std::vector<int>& v));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
+};
+
+class InvokeHelper {
+ public:
+  static void StaticVoidFromVoid() {}
+  void VoidFromVoid() {}
+  static void StaticVoidFromString(char* /* str */) {}
+  void VoidFromString(char* /* str */) {}
+  static int StaticIntFromString(char* /* str */) { return 1; }
+  static bool StaticBoolFromString(const char* /* str */) { return true; }
+};
+
+class FieldHelper {
+ public:
+  explicit FieldHelper(int a_field) : field_(a_field) {}
+  int field() const { return field_; }
+  int field_;  // NOLINT -- need external access to field_ to test
+               //           the Field matcher.
+};
+
+// Tests the linkage of the ReturnVoid action.
+TEST(LinkTest, TestReturnVoid) {
+  Mock mock;
+
+  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
+  mock.VoidFromString(NULL);
+}
+
+// Tests the linkage of the Return action.
+TEST(LinkTest, TestReturn) {
+  Mock mock;
+  char ch = 'x';
+
+  EXPECT_CALL(mock, StringFromString(_)).WillOnce(Return(&ch));
+  mock.StringFromString(NULL);
+}
+
+// Tests the linkage of the ReturnNull action.
+TEST(LinkTest, TestReturnNull) {
+  Mock mock;
+
+  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
+  mock.VoidFromString(NULL);
+}
+
+// Tests the linkage of the ReturnRef action.
+TEST(LinkTest, TestReturnRef) {
+  Mock mock;
+  int n = 42;
+
+  EXPECT_CALL(mock, IntRefFromString(_)).WillOnce(ReturnRef(n));
+  mock.IntRefFromString(NULL);
+}
+
+// Tests the linkage of the Assign action.
+TEST(LinkTest, TestAssign) {
+  Mock mock;
+  char ch = 'x';
+
+  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Assign(&ch, 'y'));
+  mock.VoidFromString(NULL);
+}
+
+// Tests the linkage of the SetArgPointee action.
+TEST(LinkTest, TestSetArgPointee) {
+  Mock mock;
+  char ch = 'x';
+
+  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(SetArgPointee<0>('y'));
+  mock.VoidFromString(&ch);
+}
+
+// Tests the linkage of the SetArrayArgument action.
+TEST(LinkTest, TestSetArrayArgument) {
+  Mock mock;
+  char ch = 'x';
+  char ch2 = 'y';
+
+  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(SetArrayArgument<0>(&ch2,
+                                                                    &ch2 + 1));
+  mock.VoidFromString(&ch);
+}
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+// Tests the linkage of the SetErrnoAndReturn action.
+TEST(LinkTest, TestSetErrnoAndReturn) {
+  Mock mock;
+
+  int saved_errno = errno;
+  EXPECT_CALL(mock, IntFromString(_)).WillOnce(SetErrnoAndReturn(1, -1));
+  mock.IntFromString(NULL);
+  errno = saved_errno;
+}
+
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Tests the linkage of the Invoke(function) and Invoke(object, method) actions.
+TEST(LinkTest, TestInvoke) {
+  Mock mock;
+  InvokeHelper test_invoke_helper;
+
+  EXPECT_CALL(mock, VoidFromString(_))
+      .WillOnce(Invoke(&InvokeHelper::StaticVoidFromString))
+      .WillOnce(Invoke(&test_invoke_helper, &InvokeHelper::VoidFromString));
+  mock.VoidFromString(NULL);
+  mock.VoidFromString(NULL);
+}
+
+// Tests the linkage of the InvokeWithoutArgs action.
+TEST(LinkTest, TestInvokeWithoutArgs) {
+  Mock mock;
+  InvokeHelper test_invoke_helper;
+
+  EXPECT_CALL(mock, VoidFromString(_))
+      .WillOnce(InvokeWithoutArgs(&InvokeHelper::StaticVoidFromVoid))
+      .WillOnce(InvokeWithoutArgs(&test_invoke_helper,
+                                  &InvokeHelper::VoidFromVoid));
+  mock.VoidFromString(NULL);
+  mock.VoidFromString(NULL);
+}
+
+// Tests the linkage of the InvokeArgument action.
+TEST(LinkTest, TestInvokeArgument) {
+  Mock mock;
+  char ch = 'x';
+
+  EXPECT_CALL(mock, VoidFromFunc(_)).WillOnce(InvokeArgument<0>(&ch));
+  mock.VoidFromFunc(InvokeHelper::StaticVoidFromString);
+}
+
+// Tests the linkage of the WithArg action.
+TEST(LinkTest, TestWithArg) {
+  Mock mock;
+
+  EXPECT_CALL(mock, VoidFromString(_))
+      .WillOnce(WithArg<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
+  mock.VoidFromString(NULL);
+}
+
+// Tests the linkage of the WithArgs action.
+TEST(LinkTest, TestWithArgs) {
+  Mock mock;
+
+  EXPECT_CALL(mock, VoidFromString(_))
+      .WillOnce(WithArgs<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
+  mock.VoidFromString(NULL);
+}
+
+// Tests the linkage of the WithoutArgs action.
+TEST(LinkTest, TestWithoutArgs) {
+  Mock mock;
+
+  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(WithoutArgs(Return()));
+  mock.VoidFromString(NULL);
+}
+
+// Tests the linkage of the DoAll action.
+TEST(LinkTest, TestDoAll) {
+  Mock mock;
+  char ch = 'x';
+
+  EXPECT_CALL(mock, VoidFromString(_))
+      .WillOnce(DoAll(SetArgPointee<0>('y'), Return()));
+  mock.VoidFromString(&ch);
+}
+
+// Tests the linkage of the DoDefault action.
+TEST(LinkTest, TestDoDefault) {
+  Mock mock;
+  char ch = 'x';
+
+  ON_CALL(mock, VoidFromString(_)).WillByDefault(Return());
+  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(DoDefault());
+  mock.VoidFromString(&ch);
+}
+
+// Tests the linkage of the IgnoreResult action.
+TEST(LinkTest, TestIgnoreResult) {
+  Mock mock;
+
+  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(IgnoreResult(Return(42)));
+  mock.VoidFromString(NULL);
+}
+
+#if GTEST_HAS_EXCEPTIONS
+// Tests the linkage of the Throw action.
+TEST(LinkTest, TestThrow) {
+  Mock mock;
+
+  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Throw(42));
+  EXPECT_THROW(mock.VoidFromString(NULL), int);
+}
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// 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
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+// Tests the linkage of actions created using ACTION macro.
+namespace {
+ACTION(Return1) { return 1; }
+}
+
+TEST(LinkTest, TestActionMacro) {
+  Mock mock;
+
+  EXPECT_CALL(mock, IntFromString(_)).WillOnce(Return1());
+  mock.IntFromString(NULL);
+}
+
+// Tests the linkage of actions created using ACTION_P macro.
+namespace {
+ACTION_P(ReturnArgument, ret_value) { return ret_value; }
+}
+
+TEST(LinkTest, TestActionPMacro) {
+  Mock mock;
+
+  EXPECT_CALL(mock, IntFromString(_)).WillOnce(ReturnArgument(42));
+  mock.IntFromString(NULL);
+}
+
+// Tests the linkage of actions created using ACTION_P2 macro.
+namespace {
+ACTION_P2(ReturnEqualsEitherOf, first, second) {
+  return arg0 == first || arg0 == second;
+}
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+TEST(LinkTest, TestActionP2Macro) {
+  Mock mock;
+  char ch = 'x';
+
+  EXPECT_CALL(mock, IntFromString(_))
+      .WillOnce(ReturnEqualsEitherOf("one", "two"));
+  mock.IntFromString(&ch);
+}
+
+// Tests the linkage of the "_" matcher.
+TEST(LinkTest, TestMatcherAnything) {
+  Mock mock;
+
+  ON_CALL(mock, VoidFromString(_)).WillByDefault(Return());
+}
+
+// Tests the linkage of the A matcher.
+TEST(LinkTest, TestMatcherA) {
+  Mock mock;
+
+  ON_CALL(mock, VoidFromString(A<char*>())).WillByDefault(Return());
+}
+
+// Tests the linkage of the Eq and the "bare value" matcher.
+TEST(LinkTest, TestMatchersEq) {
+  Mock mock;
+  const char* p = "x";
+
+  ON_CALL(mock, VoidFromString(Eq(p))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromString(const_cast<char*>("y")))
+      .WillByDefault(Return());
+}
+
+// Tests the linkage of the Lt, Gt, Le, Ge, and Ne matchers.
+TEST(LinkTest, TestMatchersRelations) {
+  Mock mock;
+
+  ON_CALL(mock, VoidFromFloat(Lt(1.0f))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromFloat(Gt(1.0f))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromFloat(Le(1.0f))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromFloat(Ge(1.0f))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromFloat(Ne(1.0f))).WillByDefault(Return());
+}
+
+// Tests the linkage of the NotNull matcher.
+TEST(LinkTest, TestMatcherNotNull) {
+  Mock mock;
+
+  ON_CALL(mock, VoidFromString(NotNull())).WillByDefault(Return());
+}
+
+// Tests the linkage of the IsNull matcher.
+TEST(LinkTest, TestMatcherIsNull) {
+  Mock mock;
+
+  ON_CALL(mock, VoidFromString(IsNull())).WillByDefault(Return());
+}
+
+// Tests the linkage of the Ref matcher.
+TEST(LinkTest, TestMatcherRef) {
+  Mock mock;
+  int a = 0;
+
+  ON_CALL(mock, VoidFromIntRef(Ref(a))).WillByDefault(Return());
+}
+
+// Tests the linkage of the TypedEq matcher.
+TEST(LinkTest, TestMatcherTypedEq) {
+  Mock mock;
+  long a = 0;
+
+  ON_CALL(mock, VoidFromIntRef(TypedEq<int&>(a))).WillByDefault(Return());
+}
+
+// Tests the linkage of the FloatEq, DoubleEq, NanSensitiveFloatEq and
+// NanSensitiveDoubleEq matchers.
+TEST(LinkTest, TestMatchersFloatingPoint) {
+  Mock mock;
+  float a = 0;
+
+  ON_CALL(mock, VoidFromFloat(FloatEq(a))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromDouble(DoubleEq(a))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromFloat(NanSensitiveFloatEq(a))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromDouble(NanSensitiveDoubleEq(a)))
+      .WillByDefault(Return());
+}
+
+// Tests the linkage of the ContainsRegex matcher.
+TEST(LinkTest, TestMatcherContainsRegex) {
+  Mock mock;
+
+  ON_CALL(mock, VoidFromString(ContainsRegex(".*"))).WillByDefault(Return());
+}
+
+// Tests the linkage of the MatchesRegex matcher.
+TEST(LinkTest, TestMatcherMatchesRegex) {
+  Mock mock;
+
+  ON_CALL(mock, VoidFromString(MatchesRegex(".*"))).WillByDefault(Return());
+}
+
+// Tests the linkage of the StartsWith, EndsWith, and HasSubstr matchers.
+TEST(LinkTest, TestMatchersSubstrings) {
+  Mock mock;
+
+  ON_CALL(mock, VoidFromString(StartsWith("a"))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromString(EndsWith("c"))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromString(HasSubstr("b"))).WillByDefault(Return());
+}
+
+// Tests the linkage of the StrEq, StrNe, StrCaseEq, and StrCaseNe matchers.
+TEST(LinkTest, TestMatchersStringEquality) {
+  Mock mock;
+  ON_CALL(mock, VoidFromString(StrEq("a"))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromString(StrNe("a"))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromString(StrCaseEq("a"))).WillByDefault(Return());
+  ON_CALL(mock, VoidFromString(StrCaseNe("a"))).WillByDefault(Return());
+}
+
+// Tests the linkage of the ElementsAre matcher.
+TEST(LinkTest, TestMatcherElementsAre) {
+  Mock mock;
+
+  ON_CALL(mock, VoidFromVector(ElementsAre('a', _))).WillByDefault(Return());
+}
+
+// Tests the linkage of the ElementsAreArray matcher.
+TEST(LinkTest, TestMatcherElementsAreArray) {
+  Mock mock;
+  char arr[] = { 'a', 'b' };
+
+  ON_CALL(mock, VoidFromVector(ElementsAreArray(arr))).WillByDefault(Return());
+}
+
+// Tests the linkage of the ContainerEq matcher.
+TEST(LinkTest, TestMatcherContainerEq) {
+  Mock mock;
+  std::vector<int> v;
+
+  ON_CALL(mock, VoidFromVector(ContainerEq(v))).WillByDefault(Return());
+}
+
+// Tests the linkage of the Field matcher.
+TEST(LinkTest, TestMatcherField) {
+  FieldHelper helper(0);
+
+  Matcher<const FieldHelper&> m = Field(&FieldHelper::field_, Eq(0));
+  EXPECT_TRUE(m.Matches(helper));
+
+  Matcher<const FieldHelper*> m2 = Field(&FieldHelper::field_, Eq(0));
+  EXPECT_TRUE(m2.Matches(&helper));
+}
+
+// Tests the linkage of the Property matcher.
+TEST(LinkTest, TestMatcherProperty) {
+  FieldHelper helper(0);
+
+  Matcher<const FieldHelper&> m = Property(&FieldHelper::field, Eq(0));
+  EXPECT_TRUE(m.Matches(helper));
+
+  Matcher<const FieldHelper*> m2 = Property(&FieldHelper::field, Eq(0));
+  EXPECT_TRUE(m2.Matches(&helper));
+}
+
+// Tests the linkage of the ResultOf matcher.
+TEST(LinkTest, TestMatcherResultOf) {
+  Matcher<char*> m = ResultOf(&InvokeHelper::StaticIntFromString, Eq(1));
+  EXPECT_TRUE(m.Matches(NULL));
+}
+
+// Tests the linkage of the ResultOf matcher.
+TEST(LinkTest, TestMatcherPointee) {
+  int n = 1;
+
+  Matcher<int*> m = Pointee(Eq(1));
+  EXPECT_TRUE(m.Matches(&n));
+}
+
+// Tests the linkage of the Truly matcher.
+TEST(LinkTest, TestMatcherTruly) {
+  Matcher<const char*> m = Truly(&InvokeHelper::StaticBoolFromString);
+  EXPECT_TRUE(m.Matches(NULL));
+}
+
+// Tests the linkage of the AllOf matcher.
+TEST(LinkTest, TestMatcherAllOf) {
+  Matcher<int> m = AllOf(_, Eq(1));
+  EXPECT_TRUE(m.Matches(1));
+}
+
+// Tests the linkage of the AnyOf matcher.
+TEST(LinkTest, TestMatcherAnyOf) {
+  Matcher<int> m = AnyOf(_, Eq(1));
+  EXPECT_TRUE(m.Matches(1));
+}
+
+// Tests the linkage of the Not matcher.
+TEST(LinkTest, TestMatcherNot) {
+  Matcher<int> m = Not(_);
+  EXPECT_FALSE(m.Matches(1));
+}
+
+// Tests the linkage of the MatcherCast<T>() function.
+TEST(LinkTest, TestMatcherCast) {
+  Matcher<const char*> m = MatcherCast<const char*>(_);
+  EXPECT_TRUE(m.Matches(NULL));
+}
+
+#endif  // GMOCK_TEST_GMOCK_LINK_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test.py
new file mode 100755
index 00000000..eced8a81
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test.py
@@ -0,0 +1,180 @@
+#!/usr/bin/env python
+#
+# 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.
+
+"""Tests the text output of Google C++ Mocking Framework.
+
+SYNOPSIS
+       gmock_output_test.py --build_dir=BUILD/DIR --gengolden
+         # where BUILD/DIR contains the built gmock_output_test_ file.
+       gmock_output_test.py --gengolden
+       gmock_output_test.py
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import re
+import sys
+
+import gmock_test_utils
+
+
+# The flag for generating the golden file
+GENGOLDEN_FLAG = '--gengolden'
+
+PROGRAM_PATH = gmock_test_utils.GetTestExecutablePath('gmock_output_test_')
+COMMAND = [PROGRAM_PATH, '--gtest_stack_trace_depth=0', '--gtest_print_time=0']
+GOLDEN_NAME = 'gmock_output_test_golden.txt'
+GOLDEN_PATH = os.path.join(gmock_test_utils.GetSourceDir(), GOLDEN_NAME)
+
+
+def ToUnixLineEnding(s):
+  """Changes all Windows/Mac line endings in s to UNIX line endings."""
+
+  return s.replace('\r\n', '\n').replace('\r', '\n')
+
+
+def RemoveReportHeaderAndFooter(output):
+  """Removes Google Test result report's header and footer from the output."""
+
+  output = re.sub(r'.*gtest_main.*\n', '', output)
+  output = re.sub(r'\[.*\d+ tests.*\n', '', output)
+  output = re.sub(r'\[.* test environment .*\n', '', output)
+  output = re.sub(r'\[=+\] \d+ tests .* ran.*', '', output)
+  output = re.sub(r'.* FAILED TESTS\n', '', output)
+  return output
+
+
+def RemoveLocations(output):
+  """Removes all file location info from a Google Test program's output.
+
+  Args:
+       output:  the output of a Google Test program.
+
+  Returns:
+       output with all file location info (in the form of
+       'DIRECTORY/FILE_NAME:LINE_NUMBER: 'or
+       'DIRECTORY\\FILE_NAME(LINE_NUMBER): ') replaced by
+       'FILE:#: '.
+  """
+
+  return re.sub(r'.*[/\\](.+)(\:\d+|\(\d+\))\:', 'FILE:#:', output)
+
+
+def NormalizeErrorMarker(output):
+  """Normalizes the error marker, which is different on Windows vs on Linux."""
+
+  return re.sub(r' error: ', ' Failure\n', output)
+
+
+def RemoveMemoryAddresses(output):
+  """Removes memory addresses from the test output."""
+
+  return re.sub(r'@\w+', '@0x#', output)
+
+
+def RemoveTestNamesOfLeakedMocks(output):
+  """Removes the test names of leaked mock objects from the test output."""
+
+  return re.sub(r'\(used in test .+\) ', '', output)
+
+
+def GetLeakyTests(output):
+  """Returns a list of test names that leak mock objects."""
+
+  # findall() returns a list of all matches of the regex in output.
+  # For example, if '(used in test FooTest.Bar)' is in output, the
+  # list will contain 'FooTest.Bar'.
+  return re.findall(r'\(used in test (.+)\)', output)
+
+
+def GetNormalizedOutputAndLeakyTests(output):
+  """Normalizes the output of gmock_output_test_.
+
+  Args:
+    output: The test output.
+
+  Returns:
+    A tuple (the normalized test output, the list of test names that have
+    leaked mocks).
+  """
+
+  output = ToUnixLineEnding(output)
+  output = RemoveReportHeaderAndFooter(output)
+  output = NormalizeErrorMarker(output)
+  output = RemoveLocations(output)
+  output = RemoveMemoryAddresses(output)
+  return (RemoveTestNamesOfLeakedMocks(output), GetLeakyTests(output))
+
+
+def GetShellCommandOutput(cmd):
+  """Runs a command in a sub-process, and returns its STDOUT in a string."""
+
+  return gmock_test_utils.Subprocess(cmd, capture_stderr=False).output
+
+
+def GetNormalizedCommandOutputAndLeakyTests(cmd):
+  """Runs a command and returns its normalized output and a list of leaky tests.
+
+  Args:
+    cmd:  the shell command.
+  """
+
+  # Disables exception pop-ups on Windows.
+  os.environ['GTEST_CATCH_EXCEPTIONS'] = '1'
+  return GetNormalizedOutputAndLeakyTests(GetShellCommandOutput(cmd))
+
+
+class GMockOutputTest(gmock_test_utils.TestCase):
+  def testOutput(self):
+    (output, leaky_tests) = GetNormalizedCommandOutputAndLeakyTests(COMMAND)
+    golden_file = open(GOLDEN_PATH, 'rb')
+    golden = golden_file.read()
+    golden_file.close()
+
+    # The normalized output should match the golden file.
+    self.assertEquals(golden, output)
+
+    # The raw output should contain 2 leaked mock object errors for
+    # test GMockOutputTest.CatchesLeakedMocks.
+    self.assertEquals(['GMockOutputTest.CatchesLeakedMocks',
+                       'GMockOutputTest.CatchesLeakedMocks'],
+                      leaky_tests)
+
+
+if __name__ == '__main__':
+  if sys.argv[1:] == [GENGOLDEN_FLAG]:
+    (output, _) = GetNormalizedCommandOutputAndLeakyTests(COMMAND)
+    golden_file = open(GOLDEN_PATH, 'wb')
+    golden_file.write(output)
+    golden_file.close()
+  else:
+    gmock_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_.cc
new file mode 100644
index 00000000..44cba342
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_.cc
@@ -0,0 +1,291 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Tests Google Mock's output in various scenarios.  This ensures that
+// Google Mock's messages are readable and useful.
+
+#include "gmock/gmock.h"
+
+#include <stdio.h>
+#include <string>
+
+#include "gtest/gtest.h"
+
+using testing::_;
+using testing::AnyNumber;
+using testing::Ge;
+using testing::InSequence;
+using testing::NaggyMock;
+using testing::Ref;
+using testing::Return;
+using testing::Sequence;
+
+class MockFoo {
+ public:
+  MockFoo() {}
+
+  MOCK_METHOD3(Bar, char(const std::string& s, int i, double x));
+  MOCK_METHOD2(Bar2, bool(int x, int y));
+  MOCK_METHOD2(Bar3, void(int x, int y));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
+};
+
+class GMockOutputTest : public testing::Test {
+ protected:
+  NaggyMock<MockFoo> foo_;
+};
+
+TEST_F(GMockOutputTest, ExpectedCall) {
+  testing::GMOCK_FLAG(verbose) = "info";
+
+  EXPECT_CALL(foo_, Bar2(0, _));
+  foo_.Bar2(0, 0);  // Expected call
+
+  testing::GMOCK_FLAG(verbose) = "warning";
+}
+
+TEST_F(GMockOutputTest, ExpectedCallToVoidFunction) {
+  testing::GMOCK_FLAG(verbose) = "info";
+
+  EXPECT_CALL(foo_, Bar3(0, _));
+  foo_.Bar3(0, 0);  // Expected call
+
+  testing::GMOCK_FLAG(verbose) = "warning";
+}
+
+TEST_F(GMockOutputTest, ExplicitActionsRunOut) {
+  EXPECT_CALL(foo_, Bar2(_, _))
+      .Times(2)
+      .WillOnce(Return(false));
+  foo_.Bar2(2, 2);
+  foo_.Bar2(1, 1);  // Explicit actions in EXPECT_CALL run out.
+}
+
+TEST_F(GMockOutputTest, UnexpectedCall) {
+  EXPECT_CALL(foo_, Bar2(0, _));
+
+  foo_.Bar2(1, 0);  // Unexpected call
+  foo_.Bar2(0, 0);  // Expected call
+}
+
+TEST_F(GMockOutputTest, UnexpectedCallToVoidFunction) {
+  EXPECT_CALL(foo_, Bar3(0, _));
+
+  foo_.Bar3(1, 0);  // Unexpected call
+  foo_.Bar3(0, 0);  // Expected call
+}
+
+TEST_F(GMockOutputTest, ExcessiveCall) {
+  EXPECT_CALL(foo_, Bar2(0, _));
+
+  foo_.Bar2(0, 0);  // Expected call
+  foo_.Bar2(0, 1);  // Excessive call
+}
+
+TEST_F(GMockOutputTest, ExcessiveCallToVoidFunction) {
+  EXPECT_CALL(foo_, Bar3(0, _));
+
+  foo_.Bar3(0, 0);  // Expected call
+  foo_.Bar3(0, 1);  // Excessive call
+}
+
+TEST_F(GMockOutputTest, UninterestingCall) {
+  foo_.Bar2(0, 1);  // Uninteresting call
+}
+
+TEST_F(GMockOutputTest, UninterestingCallToVoidFunction) {
+  foo_.Bar3(0, 1);  // Uninteresting call
+}
+
+TEST_F(GMockOutputTest, RetiredExpectation) {
+  EXPECT_CALL(foo_, Bar2(_, _))
+      .RetiresOnSaturation();
+  EXPECT_CALL(foo_, Bar2(0, 0));
+
+  foo_.Bar2(1, 1);
+  foo_.Bar2(1, 1);  // Matches a retired expectation
+  foo_.Bar2(0, 0);
+}
+
+TEST_F(GMockOutputTest, UnsatisfiedPrerequisite) {
+  {
+    InSequence s;
+    EXPECT_CALL(foo_, Bar(_, 0, _));
+    EXPECT_CALL(foo_, Bar2(0, 0));
+    EXPECT_CALL(foo_, Bar2(1, _));
+  }
+
+  foo_.Bar2(1, 0);  // Has one immediate unsatisfied pre-requisite
+  foo_.Bar("Hi", 0, 0);
+  foo_.Bar2(0, 0);
+  foo_.Bar2(1, 0);
+}
+
+TEST_F(GMockOutputTest, UnsatisfiedPrerequisites) {
+  Sequence s1, s2;
+
+  EXPECT_CALL(foo_, Bar(_, 0, _))
+      .InSequence(s1);
+  EXPECT_CALL(foo_, Bar2(0, 0))
+      .InSequence(s2);
+  EXPECT_CALL(foo_, Bar2(1, _))
+      .InSequence(s1, s2);
+
+  foo_.Bar2(1, 0);  // Has two immediate unsatisfied pre-requisites
+  foo_.Bar("Hi", 0, 0);
+  foo_.Bar2(0, 0);
+  foo_.Bar2(1, 0);
+}
+
+TEST_F(GMockOutputTest, UnsatisfiedWith) {
+  EXPECT_CALL(foo_, Bar2(_, _)).With(Ge());
+}
+
+TEST_F(GMockOutputTest, UnsatisfiedExpectation) {
+  EXPECT_CALL(foo_, Bar(_, _, _));
+  EXPECT_CALL(foo_, Bar2(0, _))
+      .Times(2);
+
+  foo_.Bar2(0, 1);
+}
+
+TEST_F(GMockOutputTest, MismatchArguments) {
+  const std::string s = "Hi";
+  EXPECT_CALL(foo_, Bar(Ref(s), _, Ge(0)));
+
+  foo_.Bar("Ho", 0, -0.1);  // Mismatch arguments
+  foo_.Bar(s, 0, 0);
+}
+
+TEST_F(GMockOutputTest, MismatchWith) {
+  EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))
+      .With(Ge());
+
+  foo_.Bar2(2, 3);  // Mismatch With()
+  foo_.Bar2(2, 1);
+}
+
+TEST_F(GMockOutputTest, MismatchArgumentsAndWith) {
+  EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))
+      .With(Ge());
+
+  foo_.Bar2(1, 3);  // Mismatch arguments and mismatch With()
+  foo_.Bar2(2, 1);
+}
+
+TEST_F(GMockOutputTest, UnexpectedCallWithDefaultAction) {
+  ON_CALL(foo_, Bar2(_, _))
+      .WillByDefault(Return(true));   // Default action #1
+  ON_CALL(foo_, Bar2(1, _))
+      .WillByDefault(Return(false));  // Default action #2
+
+  EXPECT_CALL(foo_, Bar2(2, 2));
+  foo_.Bar2(1, 0);  // Unexpected call, takes default action #2.
+  foo_.Bar2(0, 0);  // Unexpected call, takes default action #1.
+  foo_.Bar2(2, 2);  // Expected call.
+}
+
+TEST_F(GMockOutputTest, ExcessiveCallWithDefaultAction) {
+  ON_CALL(foo_, Bar2(_, _))
+      .WillByDefault(Return(true));   // Default action #1
+  ON_CALL(foo_, Bar2(1, _))
+      .WillByDefault(Return(false));  // Default action #2
+
+  EXPECT_CALL(foo_, Bar2(2, 2));
+  EXPECT_CALL(foo_, Bar2(1, 1));
+
+  foo_.Bar2(2, 2);  // Expected call.
+  foo_.Bar2(2, 2);  // Excessive call, takes default action #1.
+  foo_.Bar2(1, 1);  // Expected call.
+  foo_.Bar2(1, 1);  // Excessive call, takes default action #2.
+}
+
+TEST_F(GMockOutputTest, UninterestingCallWithDefaultAction) {
+  ON_CALL(foo_, Bar2(_, _))
+      .WillByDefault(Return(true));   // Default action #1
+  ON_CALL(foo_, Bar2(1, _))
+      .WillByDefault(Return(false));  // Default action #2
+
+  foo_.Bar2(2, 2);  // Uninteresting call, takes default action #1.
+  foo_.Bar2(1, 1);  // Uninteresting call, takes default action #2.
+}
+
+TEST_F(GMockOutputTest, ExplicitActionsRunOutWithDefaultAction) {
+  ON_CALL(foo_, Bar2(_, _))
+      .WillByDefault(Return(true));   // Default action #1
+
+  EXPECT_CALL(foo_, Bar2(_, _))
+      .Times(2)
+      .WillOnce(Return(false));
+  foo_.Bar2(2, 2);
+  foo_.Bar2(1, 1);  // Explicit actions in EXPECT_CALL run out.
+}
+
+TEST_F(GMockOutputTest, CatchesLeakedMocks) {
+  MockFoo* foo1 = new MockFoo;
+  MockFoo* foo2 = new MockFoo;
+
+  // Invokes ON_CALL on foo1.
+  ON_CALL(*foo1, Bar(_, _, _)).WillByDefault(Return('a'));
+
+  // Invokes EXPECT_CALL on foo2.
+  EXPECT_CALL(*foo2, Bar2(_, _));
+  EXPECT_CALL(*foo2, Bar2(1, _));
+  EXPECT_CALL(*foo2, Bar3(_, _)).Times(AnyNumber());
+  foo2->Bar2(2, 1);
+  foo2->Bar2(1, 1);
+
+  // Both foo1 and foo2 are deliberately leaked.
+}
+
+void TestCatchesLeakedMocksInAdHocTests() {
+  MockFoo* foo = new MockFoo;
+
+  // Invokes EXPECT_CALL on foo.
+  EXPECT_CALL(*foo, Bar2(_, _));
+  foo->Bar2(2, 1);
+
+  // foo is deliberately leaked.
+}
+
+int main(int argc, char **argv) {
+  testing::InitGoogleMock(&argc, argv);
+
+  // Ensures that the tests pass no matter what value of
+  // --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
+  testing::GMOCK_FLAG(catch_leaked_mocks) = true;
+  testing::GMOCK_FLAG(verbose) = "warning";
+
+  TestCatchesLeakedMocksInAdHocTests();
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_golden.txt b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_golden.txt
new file mode 100644
index 00000000..689d5eeb
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_golden.txt
@@ -0,0 +1,310 @@
+[ RUN      ] GMockOutputTest.ExpectedCall
+
+FILE:#: EXPECT_CALL(foo_, Bar2(0, _)) invoked
+Stack trace:
+
+FILE:#: Mock function call matches EXPECT_CALL(foo_, Bar2(0, _))...
+    Function call: Bar2(0, 0)
+          Returns: false
+Stack trace:
+[       OK ] GMockOutputTest.ExpectedCall
+[ RUN      ] GMockOutputTest.ExpectedCallToVoidFunction
+
+FILE:#: EXPECT_CALL(foo_, Bar3(0, _)) invoked
+Stack trace:
+
+FILE:#: Mock function call matches EXPECT_CALL(foo_, Bar3(0, _))...
+    Function call: Bar3(0, 0)
+Stack trace:
+[       OK ] GMockOutputTest.ExpectedCallToVoidFunction
+[ RUN      ] GMockOutputTest.ExplicitActionsRunOut
+
+GMOCK WARNING:
+FILE:#: Too few actions specified in EXPECT_CALL(foo_, Bar2(_, _))...
+Expected to be called twice, but has only 1 WillOnce().
+GMOCK WARNING:
+FILE:#: Actions ran out in EXPECT_CALL(foo_, Bar2(_, _))...
+Called 2 times, but only 1 WillOnce() is specified - returning default value.
+Stack trace:
+[       OK ] GMockOutputTest.ExplicitActionsRunOut
+[ RUN      ] GMockOutputTest.UnexpectedCall
+unknown file: Failure
+
+Unexpected mock function call - returning default value.
+    Function call: Bar2(1, 0)
+          Returns: false
+Google Mock tried the following 1 expectation, but it didn't match:
+
+FILE:#: EXPECT_CALL(foo_, Bar2(0, _))...
+  Expected arg #0: is equal to 0
+           Actual: 1
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] GMockOutputTest.UnexpectedCall
+[ RUN      ] GMockOutputTest.UnexpectedCallToVoidFunction
+unknown file: Failure
+
+Unexpected mock function call - returning directly.
+    Function call: Bar3(1, 0)
+Google Mock tried the following 1 expectation, but it didn't match:
+
+FILE:#: EXPECT_CALL(foo_, Bar3(0, _))...
+  Expected arg #0: is equal to 0
+           Actual: 1
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] GMockOutputTest.UnexpectedCallToVoidFunction
+[ RUN      ] GMockOutputTest.ExcessiveCall
+FILE:#: Failure
+Mock function called more times than expected - returning default value.
+    Function call: Bar2(0, 1)
+          Returns: false
+         Expected: to be called once
+           Actual: called twice - over-saturated and active
+[  FAILED  ] GMockOutputTest.ExcessiveCall
+[ RUN      ] GMockOutputTest.ExcessiveCallToVoidFunction
+FILE:#: Failure
+Mock function called more times than expected - returning directly.
+    Function call: Bar3(0, 1)
+         Expected: to be called once
+           Actual: called twice - over-saturated and active
+[  FAILED  ] GMockOutputTest.ExcessiveCallToVoidFunction
+[ RUN      ] GMockOutputTest.UninterestingCall
+
+GMOCK WARNING:
+Uninteresting mock function call - returning default value.
+    Function call: Bar2(0, 1)
+          Returns: false
+NOTE: 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/googlemock/docs/CookBook.md#knowing-when-to-expect for details.
+[       OK ] GMockOutputTest.UninterestingCall
+[ RUN      ] GMockOutputTest.UninterestingCallToVoidFunction
+
+GMOCK WARNING:
+Uninteresting mock function call - returning directly.
+    Function call: Bar3(0, 1)
+NOTE: 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/googlemock/docs/CookBook.md#knowing-when-to-expect for details.
+[       OK ] GMockOutputTest.UninterestingCallToVoidFunction
+[ RUN      ] GMockOutputTest.RetiredExpectation
+unknown file: Failure
+
+Unexpected mock function call - returning default value.
+    Function call: Bar2(1, 1)
+          Returns: false
+Google Mock tried the following 2 expectations, but none matched:
+
+FILE:#: tried expectation #0: EXPECT_CALL(foo_, Bar2(_, _))...
+         Expected: the expectation is active
+           Actual: it is retired
+         Expected: to be called once
+           Actual: called once - saturated and retired
+FILE:#: tried expectation #1: EXPECT_CALL(foo_, Bar2(0, 0))...
+  Expected arg #0: is equal to 0
+           Actual: 1
+  Expected arg #1: is equal to 0
+           Actual: 1
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] GMockOutputTest.RetiredExpectation
+[ RUN      ] GMockOutputTest.UnsatisfiedPrerequisite
+unknown file: Failure
+
+Unexpected mock function call - returning default value.
+    Function call: Bar2(1, 0)
+          Returns: false
+Google Mock tried the following 2 expectations, but none matched:
+
+FILE:#: tried expectation #0: EXPECT_CALL(foo_, Bar2(0, 0))...
+  Expected arg #0: is equal to 0
+           Actual: 1
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+FILE:#: tried expectation #1: EXPECT_CALL(foo_, Bar2(1, _))...
+         Expected: all pre-requisites are satisfied
+           Actual: the following immediate pre-requisites are not satisfied:
+FILE:#: pre-requisite #0
+                   (end of pre-requisites)
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] GMockOutputTest.UnsatisfiedPrerequisite
+[ RUN      ] GMockOutputTest.UnsatisfiedPrerequisites
+unknown file: Failure
+
+Unexpected mock function call - returning default value.
+    Function call: Bar2(1, 0)
+          Returns: false
+Google Mock tried the following 2 expectations, but none matched:
+
+FILE:#: tried expectation #0: EXPECT_CALL(foo_, Bar2(0, 0))...
+  Expected arg #0: is equal to 0
+           Actual: 1
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+FILE:#: tried expectation #1: EXPECT_CALL(foo_, Bar2(1, _))...
+         Expected: all pre-requisites are satisfied
+           Actual: the following immediate pre-requisites are not satisfied:
+FILE:#: pre-requisite #0
+FILE:#: pre-requisite #1
+                   (end of pre-requisites)
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] GMockOutputTest.UnsatisfiedPrerequisites
+[ RUN      ] GMockOutputTest.UnsatisfiedWith
+FILE:#: Failure
+Actual function call count doesn't match EXPECT_CALL(foo_, Bar2(_, _))...
+    Expected args: are a pair where the first >= the second
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] GMockOutputTest.UnsatisfiedWith
+[ RUN      ] GMockOutputTest.UnsatisfiedExpectation
+FILE:#: Failure
+Actual function call count doesn't match EXPECT_CALL(foo_, Bar2(0, _))...
+         Expected: to be called twice
+           Actual: called once - unsatisfied and active
+FILE:#: Failure
+Actual function call count doesn't match EXPECT_CALL(foo_, Bar(_, _, _))...
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] GMockOutputTest.UnsatisfiedExpectation
+[ RUN      ] GMockOutputTest.MismatchArguments
+unknown file: Failure
+
+Unexpected mock function call - returning default value.
+    Function call: Bar(@0x# "Ho", 0, -0.1)
+          Returns: '\0'
+Google Mock tried the following 1 expectation, but it didn't match:
+
+FILE:#: EXPECT_CALL(foo_, Bar(Ref(s), _, Ge(0)))...
+  Expected arg #0: references the variable @0x# "Hi"
+           Actual: "Ho", which is located @0x#
+  Expected arg #2: is >= 0
+           Actual: -0.1
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] GMockOutputTest.MismatchArguments
+[ RUN      ] GMockOutputTest.MismatchWith
+unknown file: Failure
+
+Unexpected mock function call - returning default value.
+    Function call: Bar2(2, 3)
+          Returns: false
+Google Mock tried the following 1 expectation, but it didn't match:
+
+FILE:#: EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))...
+    Expected args: are a pair where the first >= the second
+           Actual: don't match
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] GMockOutputTest.MismatchWith
+[ RUN      ] GMockOutputTest.MismatchArgumentsAndWith
+unknown file: Failure
+
+Unexpected mock function call - returning default value.
+    Function call: Bar2(1, 3)
+          Returns: false
+Google Mock tried the following 1 expectation, but it didn't match:
+
+FILE:#: EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))...
+  Expected arg #0: is >= 2
+           Actual: 1
+    Expected args: are a pair where the first >= the second
+           Actual: don't match
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] GMockOutputTest.MismatchArgumentsAndWith
+[ RUN      ] GMockOutputTest.UnexpectedCallWithDefaultAction
+unknown file: Failure
+
+Unexpected mock function call - taking default action specified at:
+FILE:#:
+    Function call: Bar2(1, 0)
+          Returns: false
+Google Mock tried the following 1 expectation, but it didn't match:
+
+FILE:#: EXPECT_CALL(foo_, Bar2(2, 2))...
+  Expected arg #0: is equal to 2
+           Actual: 1
+  Expected arg #1: is equal to 2
+           Actual: 0
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+unknown file: Failure
+
+Unexpected mock function call - taking default action specified at:
+FILE:#:
+    Function call: Bar2(0, 0)
+          Returns: true
+Google Mock tried the following 1 expectation, but it didn't match:
+
+FILE:#: EXPECT_CALL(foo_, Bar2(2, 2))...
+  Expected arg #0: is equal to 2
+           Actual: 0
+  Expected arg #1: is equal to 2
+           Actual: 0
+         Expected: to be called once
+           Actual: never called - unsatisfied and active
+[  FAILED  ] GMockOutputTest.UnexpectedCallWithDefaultAction
+[ RUN      ] GMockOutputTest.ExcessiveCallWithDefaultAction
+FILE:#: Failure
+Mock function called more times than expected - taking default action specified at:
+FILE:#:
+    Function call: Bar2(2, 2)
+          Returns: true
+         Expected: to be called once
+           Actual: called twice - over-saturated and active
+FILE:#: Failure
+Mock function called more times than expected - taking default action specified at:
+FILE:#:
+    Function call: Bar2(1, 1)
+          Returns: false
+         Expected: to be called once
+           Actual: called twice - over-saturated and active
+[  FAILED  ] GMockOutputTest.ExcessiveCallWithDefaultAction
+[ RUN      ] GMockOutputTest.UninterestingCallWithDefaultAction
+
+GMOCK WARNING:
+Uninteresting mock function call - taking default action specified at:
+FILE:#:
+    Function call: Bar2(2, 2)
+          Returns: true
+NOTE: 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/googlemock/docs/CookBook.md#knowing-when-to-expect for details.
+
+GMOCK WARNING:
+Uninteresting mock function call - taking default action specified at:
+FILE:#:
+    Function call: Bar2(1, 1)
+          Returns: false
+NOTE: 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/googlemock/docs/CookBook.md#knowing-when-to-expect for details.
+[       OK ] GMockOutputTest.UninterestingCallWithDefaultAction
+[ RUN      ] GMockOutputTest.ExplicitActionsRunOutWithDefaultAction
+
+GMOCK WARNING:
+FILE:#: Too few actions specified in EXPECT_CALL(foo_, Bar2(_, _))...
+Expected to be called twice, but has only 1 WillOnce().
+GMOCK WARNING:
+FILE:#: Actions ran out in EXPECT_CALL(foo_, Bar2(_, _))...
+Called 2 times, but only 1 WillOnce() is specified - taking default action specified at:
+FILE:#:
+Stack trace:
+[       OK ] GMockOutputTest.ExplicitActionsRunOutWithDefaultAction
+[ RUN      ] GMockOutputTest.CatchesLeakedMocks
+[       OK ] GMockOutputTest.CatchesLeakedMocks
+[  FAILED  ] GMockOutputTest.UnexpectedCall
+[  FAILED  ] GMockOutputTest.UnexpectedCallToVoidFunction
+[  FAILED  ] GMockOutputTest.ExcessiveCall
+[  FAILED  ] GMockOutputTest.ExcessiveCallToVoidFunction
+[  FAILED  ] GMockOutputTest.RetiredExpectation
+[  FAILED  ] GMockOutputTest.UnsatisfiedPrerequisite
+[  FAILED  ] GMockOutputTest.UnsatisfiedPrerequisites
+[  FAILED  ] GMockOutputTest.UnsatisfiedWith
+[  FAILED  ] GMockOutputTest.UnsatisfiedExpectation
+[  FAILED  ] GMockOutputTest.MismatchArguments
+[  FAILED  ] GMockOutputTest.MismatchWith
+[  FAILED  ] GMockOutputTest.MismatchArgumentsAndWith
+[  FAILED  ] GMockOutputTest.UnexpectedCallWithDefaultAction
+[  FAILED  ] GMockOutputTest.ExcessiveCallWithDefaultAction
+
+
+FILE:#: ERROR: this mock object should be deleted but never is. Its address is @0x#.
+FILE:#: ERROR: this mock object should be deleted but never is. Its address is @0x#.
+FILE:#: ERROR: this mock object should be deleted but never is. Its address is @0x#.
+ERROR: 3 leaked mock objects found at program exit.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_stress_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_stress_test.cc
new file mode 100644
index 00000000..0e97aeed
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_stress_test.cc
@@ -0,0 +1,322 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Tests that Google Mock constructs can be used in a large number of
+// threads concurrently.
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+namespace {
+
+// From <gtest/internal/gtest-port.h>.
+using ::testing::internal::ThreadWithParam;
+
+// The maximum number of test threads (not including helper threads)
+// to create.
+const int kMaxTestThreads = 50;
+
+// How many times to repeat a task in a test thread.
+const int kRepeat = 50;
+
+class MockFoo {
+ public:
+  MOCK_METHOD1(Bar, int(int n));  // NOLINT
+  MOCK_METHOD2(Baz, char(const char* s1, const internal::string& s2));  // NOLINT
+};
+
+// Helper for waiting for the given thread to finish and then deleting it.
+template <typename T>
+void JoinAndDelete(ThreadWithParam<T>* t) {
+  t->Join();
+  delete t;
+}
+
+using internal::linked_ptr;
+
+// Helper classes for testing using linked_ptr concurrently.
+
+class Base {
+ public:
+  explicit Base(int a_x) : x_(a_x) {}
+  virtual ~Base() {}
+  int x() const { return x_; }
+ private:
+  int x_;
+};
+
+class Derived1 : public Base {
+ public:
+  Derived1(int a_x, int a_y) : Base(a_x), y_(a_y) {}
+  int y() const { return y_; }
+ private:
+  int y_;
+};
+
+class Derived2 : public Base {
+ public:
+  Derived2(int a_x, int a_z) : Base(a_x), z_(a_z) {}
+  int z() const { return z_; }
+ private:
+  int z_;
+};
+
+linked_ptr<Derived1> pointer1(new Derived1(1, 2));
+linked_ptr<Derived2> pointer2(new Derived2(3, 4));
+
+struct Dummy {};
+
+// Tests that we can copy from a linked_ptr and read it concurrently.
+void TestConcurrentCopyAndReadLinkedPtr(Dummy /* dummy */) {
+  // Reads pointer1 and pointer2 while they are being copied from in
+  // another thread.
+  EXPECT_EQ(1, pointer1->x());
+  EXPECT_EQ(2, pointer1->y());
+  EXPECT_EQ(3, pointer2->x());
+  EXPECT_EQ(4, pointer2->z());
+
+  // Copies from pointer1.
+  linked_ptr<Derived1> p1(pointer1);
+  EXPECT_EQ(1, p1->x());
+  EXPECT_EQ(2, p1->y());
+
+  // Assigns from pointer2 where the LHS was empty.
+  linked_ptr<Base> p2;
+  p2 = pointer1;
+  EXPECT_EQ(1, p2->x());
+
+  // Assigns from pointer2 where the LHS was not empty.
+  p2 = pointer2;
+  EXPECT_EQ(3, p2->x());
+}
+
+const linked_ptr<Derived1> p0(new Derived1(1, 2));
+
+// Tests that we can concurrently modify two linked_ptrs that point to
+// the same object.
+void TestConcurrentWriteToEqualLinkedPtr(Dummy /* dummy */) {
+  // p1 and p2 point to the same, shared thing.  One thread resets p1.
+  // Another thread assigns to p2.  This will cause the same
+  // underlying "ring" to be updated concurrently.
+  linked_ptr<Derived1> p1(p0);
+  linked_ptr<Derived1> p2(p0);
+
+  EXPECT_EQ(1, p1->x());
+  EXPECT_EQ(2, p1->y());
+
+  EXPECT_EQ(1, p2->x());
+  EXPECT_EQ(2, p2->y());
+
+  p1.reset();
+  p2 = p0;
+
+  EXPECT_EQ(1, p2->x());
+  EXPECT_EQ(2, p2->y());
+}
+
+// Tests that different mock objects can be used in their respective
+// threads.  This should generate no Google Test failure.
+void TestConcurrentMockObjects(Dummy /* dummy */) {
+  // Creates a mock and does some typical operations on it.
+  MockFoo foo;
+  ON_CALL(foo, Bar(_))
+      .WillByDefault(Return(1));
+  ON_CALL(foo, Baz(_, _))
+      .WillByDefault(Return('b'));
+  ON_CALL(foo, Baz(_, "you"))
+      .WillByDefault(Return('a'));
+
+  EXPECT_CALL(foo, Bar(0))
+      .Times(AtMost(3));
+  EXPECT_CALL(foo, Baz(_, _));
+  EXPECT_CALL(foo, Baz("hi", "you"))
+      .WillOnce(Return('z'))
+      .WillRepeatedly(DoDefault());
+
+  EXPECT_EQ(1, foo.Bar(0));
+  EXPECT_EQ(1, foo.Bar(0));
+  EXPECT_EQ('z', foo.Baz("hi", "you"));
+  EXPECT_EQ('a', foo.Baz("hi", "you"));
+  EXPECT_EQ('b', foo.Baz("hi", "me"));
+}
+
+// Tests invoking methods of the same mock object in multiple threads.
+
+struct Helper1Param {
+  MockFoo* mock_foo;
+  int* count;
+};
+
+void Helper1(Helper1Param param) {
+  for (int i = 0; i < kRepeat; i++) {
+    const char ch = param.mock_foo->Baz("a", "b");
+    if (ch == 'a') {
+      // It was an expected call.
+      (*param.count)++;
+    } else {
+      // It was an excessive call.
+      EXPECT_EQ('\0', ch);
+    }
+
+    // An unexpected call.
+    EXPECT_EQ('\0', param.mock_foo->Baz("x", "y")) << "Expected failure.";
+
+    // An uninteresting call.
+    EXPECT_EQ(1, param.mock_foo->Bar(5));
+  }
+}
+
+// This should generate 3*kRepeat + 1 failures in total.
+void TestConcurrentCallsOnSameObject(Dummy /* dummy */) {
+  MockFoo foo;
+
+  ON_CALL(foo, Bar(_))
+      .WillByDefault(Return(1));
+  EXPECT_CALL(foo, Baz(_, "b"))
+      .Times(kRepeat)
+      .WillRepeatedly(Return('a'));
+  EXPECT_CALL(foo, Baz(_, "c"));  // Expected to be unsatisfied.
+
+  // This chunk of code should generate kRepeat failures about
+  // excessive calls, and 2*kRepeat failures about unexpected calls.
+  int count1 = 0;
+  const Helper1Param param = { &foo, &count1 };
+  ThreadWithParam<Helper1Param>* const t =
+      new ThreadWithParam<Helper1Param>(Helper1, param, NULL);
+
+  int count2 = 0;
+  const Helper1Param param2 = { &foo, &count2 };
+  Helper1(param2);
+  JoinAndDelete(t);
+
+  EXPECT_EQ(kRepeat, count1 + count2);
+
+  // foo's destructor should generate one failure about unsatisfied
+  // expectation.
+}
+
+// Tests using the same mock object in multiple threads when the
+// expectations are partially ordered.
+
+void Helper2(MockFoo* foo) {
+  for (int i = 0; i < kRepeat; i++) {
+    foo->Bar(2);
+    foo->Bar(3);
+  }
+}
+
+// This should generate no Google Test failures.
+void TestPartiallyOrderedExpectationsWithThreads(Dummy /* dummy */) {
+  MockFoo foo;
+  Sequence s1, s2;
+
+  {
+    InSequence dummy;
+    EXPECT_CALL(foo, Bar(0));
+    EXPECT_CALL(foo, Bar(1))
+        .InSequence(s1, s2);
+  }
+
+  EXPECT_CALL(foo, Bar(2))
+      .Times(2*kRepeat)
+      .InSequence(s1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(foo, Bar(3))
+      .Times(2*kRepeat)
+      .InSequence(s2);
+
+  {
+    InSequence dummy;
+    EXPECT_CALL(foo, Bar(2))
+        .InSequence(s1, s2);
+    EXPECT_CALL(foo, Bar(4));
+  }
+
+  foo.Bar(0);
+  foo.Bar(1);
+
+  ThreadWithParam<MockFoo*>* const t =
+      new ThreadWithParam<MockFoo*>(Helper2, &foo, NULL);
+  Helper2(&foo);
+  JoinAndDelete(t);
+
+  foo.Bar(2);
+  foo.Bar(4);
+}
+
+// Tests using Google Mock constructs in many threads concurrently.
+TEST(StressTest, CanUseGMockWithThreads) {
+  void (*test_routines[])(Dummy dummy) = {
+    &TestConcurrentCopyAndReadLinkedPtr,
+    &TestConcurrentWriteToEqualLinkedPtr,
+    &TestConcurrentMockObjects,
+    &TestConcurrentCallsOnSameObject,
+    &TestPartiallyOrderedExpectationsWithThreads,
+  };
+
+  const int kRoutines = sizeof(test_routines)/sizeof(test_routines[0]);
+  const int kCopiesOfEachRoutine = kMaxTestThreads / kRoutines;
+  const int kTestThreads = kCopiesOfEachRoutine * kRoutines;
+  ThreadWithParam<Dummy>* threads[kTestThreads] = {};
+  for (int i = 0; i < kTestThreads; i++) {
+    // Creates a thread to run the test function.
+    threads[i] =
+        new ThreadWithParam<Dummy>(test_routines[i % kRoutines], Dummy(), NULL);
+    GTEST_LOG_(INFO) << "Thread #" << i << " running . . .";
+  }
+
+  // At this point, we have many threads running.
+  for (int i = 0; i < kTestThreads; i++) {
+    JoinAndDelete(threads[i]);
+  }
+
+  // Ensures that the correct number of failures have been reported.
+  const TestInfo* const info = UnitTest::GetInstance()->current_test_info();
+  const TestResult& result = *info->result();
+  const int kExpectedFailures = (3*kRepeat + 1)*kCopiesOfEachRoutine;
+  GTEST_CHECK_(kExpectedFailures == result.total_part_count())
+      << "Expected " << kExpectedFailures << " failures, but got "
+      << result.total_part_count();
+}
+
+}  // namespace
+}  // namespace testing
+
+int main(int argc, char **argv) {
+  testing::InitGoogleMock(&argc, argv);
+
+  const int exit_code = RUN_ALL_TESTS();  // Expected to fail.
+  GTEST_CHECK_(exit_code != 0) << "RUN_ALL_TESTS() did not fail as expected";
+
+  printf("\nPASS\n");
+  return 0;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test.cc
new file mode 100644
index 00000000..d8d0c57b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test.cc
@@ -0,0 +1,220 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests code in gmock.cc.
+
+#include "gmock/gmock.h"
+
+#include <string>
+#include "gtest/gtest.h"
+
+#if !defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+
+using testing::GMOCK_FLAG(verbose);
+using testing::InitGoogleMock;
+
+// Verifies that calling InitGoogleMock() on argv results in new_argv,
+// and the gmock_verbose flag's value is set to expected_gmock_verbose.
+template <typename Char, int M, int N>
+void TestInitGoogleMock(const Char* (&argv)[M], const Char* (&new_argv)[N],
+                        const ::std::string& expected_gmock_verbose) {
+  const ::std::string old_verbose = GMOCK_FLAG(verbose);
+
+  int argc = M;
+  InitGoogleMock(&argc, const_cast<Char**>(argv));
+  ASSERT_EQ(N, argc) << "The new argv has wrong number of elements.";
+
+  for (int i = 0; i < N; i++) {
+    EXPECT_STREQ(new_argv[i], argv[i]);
+  }
+
+  EXPECT_EQ(expected_gmock_verbose, GMOCK_FLAG(verbose).c_str());
+  GMOCK_FLAG(verbose) = old_verbose;  // Restores the gmock_verbose flag.
+}
+
+TEST(InitGoogleMockTest, ParsesInvalidCommandLine) {
+  const char* argv[] = {
+    NULL
+  };
+
+  const char* new_argv[] = {
+    NULL
+  };
+
+  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
+}
+
+TEST(InitGoogleMockTest, ParsesEmptyCommandLine) {
+  const char* argv[] = {
+    "foo.exe",
+    NULL
+  };
+
+  const char* new_argv[] = {
+    "foo.exe",
+    NULL
+  };
+
+  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
+}
+
+TEST(InitGoogleMockTest, ParsesSingleFlag) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gmock_verbose=info",
+    NULL
+  };
+
+  const char* new_argv[] = {
+    "foo.exe",
+    NULL
+  };
+
+  TestInitGoogleMock(argv, new_argv, "info");
+}
+
+TEST(InitGoogleMockTest, ParsesUnrecognizedFlag) {
+  const char* argv[] = {
+    "foo.exe",
+    "--non_gmock_flag=blah",
+    NULL
+  };
+
+  const char* new_argv[] = {
+    "foo.exe",
+    "--non_gmock_flag=blah",
+    NULL
+  };
+
+  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
+}
+
+TEST(InitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
+  const char* argv[] = {
+    "foo.exe",
+    "--non_gmock_flag=blah",
+    "--gmock_verbose=error",
+    NULL
+  };
+
+  const char* new_argv[] = {
+    "foo.exe",
+    "--non_gmock_flag=blah",
+    NULL
+  };
+
+  TestInitGoogleMock(argv, new_argv, "error");
+}
+
+TEST(WideInitGoogleMockTest, ParsesInvalidCommandLine) {
+  const wchar_t* argv[] = {
+    NULL
+  };
+
+  const wchar_t* new_argv[] = {
+    NULL
+  };
+
+  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
+}
+
+TEST(WideInitGoogleMockTest, ParsesEmptyCommandLine) {
+  const wchar_t* argv[] = {
+    L"foo.exe",
+    NULL
+  };
+
+  const wchar_t* new_argv[] = {
+    L"foo.exe",
+    NULL
+  };
+
+  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
+}
+
+TEST(WideInitGoogleMockTest, ParsesSingleFlag) {
+  const wchar_t* argv[] = {
+    L"foo.exe",
+    L"--gmock_verbose=info",
+    NULL
+  };
+
+  const wchar_t* new_argv[] = {
+    L"foo.exe",
+    NULL
+  };
+
+  TestInitGoogleMock(argv, new_argv, "info");
+}
+
+TEST(WideInitGoogleMockTest, ParsesUnrecognizedFlag) {
+  const wchar_t* argv[] = {
+    L"foo.exe",
+    L"--non_gmock_flag=blah",
+    NULL
+  };
+
+  const wchar_t* new_argv[] = {
+    L"foo.exe",
+    L"--non_gmock_flag=blah",
+    NULL
+  };
+
+  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
+}
+
+TEST(WideInitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
+  const wchar_t* argv[] = {
+    L"foo.exe",
+    L"--non_gmock_flag=blah",
+    L"--gmock_verbose=error",
+    NULL
+  };
+
+  const wchar_t* new_argv[] = {
+    L"foo.exe",
+    L"--non_gmock_flag=blah",
+    NULL
+  };
+
+  TestInitGoogleMock(argv, new_argv, "error");
+}
+
+#endif  // !defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+
+// Makes sure Google Mock flags can be accessed in code.
+TEST(FlagTest, IsAccessibleInCode) {
+  bool dummy = testing::GMOCK_FLAG(catch_leaked_mocks) &&
+      testing::GMOCK_FLAG(verbose) == "";
+  (void)dummy;  // Avoids the "unused local variable" warning.
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test_utils.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test_utils.py
new file mode 100755
index 00000000..20e3d3d4
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test_utils.py
@@ -0,0 +1,112 @@
+#!/usr/bin/env python
+#
+# Copyright 2006, 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.
+
+"""Unit test utilities for Google C++ Mocking Framework."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import sys
+
+
+# Determines path to gtest_test_utils and imports it.
+SCRIPT_DIR = os.path.dirname(__file__) or '.'
+
+# isdir resolves symbolic links.
+gtest_tests_util_dir = os.path.join(SCRIPT_DIR, '../gtest/test')
+if os.path.isdir(gtest_tests_util_dir):
+  GTEST_TESTS_UTIL_DIR = gtest_tests_util_dir
+else:
+  GTEST_TESTS_UTIL_DIR = os.path.join(SCRIPT_DIR, '../../gtest/test')
+
+sys.path.append(GTEST_TESTS_UTIL_DIR)
+import gtest_test_utils  # pylint: disable-msg=C6204
+
+
+def GetSourceDir():
+  """Returns the absolute path of the directory where the .py files are."""
+
+  return gtest_test_utils.GetSourceDir()
+
+
+def GetTestExecutablePath(executable_name):
+  """Returns the absolute path of the test binary given its name.
+
+  The function will print a message and abort the program if the resulting file
+  doesn't exist.
+
+  Args:
+    executable_name: name of the test binary that the test script runs.
+
+  Returns:
+    The absolute path of the test binary.
+  """
+
+  return gtest_test_utils.GetTestExecutablePath(executable_name)
+
+
+def GetExitStatus(exit_code):
+  """Returns the argument to exit(), or -1 if exit() wasn't called.
+
+  Args:
+    exit_code: the result value of os.system(command).
+  """
+
+  if os.name == 'nt':
+    # On Windows, os.WEXITSTATUS() doesn't work and os.system() returns
+    # the argument to exit() directly.
+    return exit_code
+  else:
+    # On Unix, os.WEXITSTATUS() must be used to extract the exit status
+    # from the result of os.system().
+    if os.WIFEXITED(exit_code):
+      return os.WEXITSTATUS(exit_code)
+    else:
+      return -1
+
+
+# Suppresses the "Invalid const name" lint complaint
+# pylint: disable-msg=C6409
+
+# Exposes utilities from gtest_test_utils.
+Subprocess = gtest_test_utils.Subprocess
+TestCase = gtest_test_utils.TestCase
+environ = gtest_test_utils.environ
+SetEnvVar = gtest_test_utils.SetEnvVar
+PREMATURE_EXIT_FILE_ENV_VAR = gtest_test_utils.PREMATURE_EXIT_FILE_ENV_VAR
+
+# pylint: enable-msg=C6409
+
+
+def Main():
+  """Runs the unit test."""
+
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/.gitignore b/week4/softwareEng_9_4/vendor/googletest/googletest/.gitignore
new file mode 100644
index 00000000..4b7be4b9
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/.gitignore
@@ -0,0 +1,2 @@
+# python
+*.pyc
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/CHANGES b/week4/softwareEng_9_4/vendor/googletest/googletest/CHANGES
new file mode 100644
index 00000000..05521324
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/CHANGES
@@ -0,0 +1,157 @@
+Changes for 1.7.0:
+
+* New feature: death tests are supported on OpenBSD and in iOS
+  simulator now.
+* New feature: Google Test now implements a protocol to allow
+  a test runner to detect that a test program has exited
+  prematurely and report it as a failure (before it would be
+  falsely reported as a success if the exit code is 0).
+* New feature: Test::RecordProperty() can now be used outside of the
+  lifespan of a test method, in which case it will be attributed to
+  the current test case or the test program in the XML report.
+* New feature (potentially breaking): --gtest_list_tests now prints
+  the type parameters and value parameters for each test.
+* Improvement: char pointers and char arrays are now escaped properly
+  in failure messages.
+* Improvement: failure summary in XML reports now includes file and
+  line information.
+* Improvement: the <testsuites> XML element now has a timestamp attribute.
+* Improvement: When --gtest_filter is specified, XML report now doesn't
+  contain information about tests that are filtered out.
+* Fixed the bug where long --gtest_filter flag values are truncated in
+  death tests.
+* Potentially breaking change: RUN_ALL_TESTS() is now implemented as a
+  function instead of a macro in order to work better with Clang.
+* Compatibility fixes with C++ 11 and various platforms.
+* Bug/warning fixes.
+
+Changes for 1.6.0:
+
+* New feature: ADD_FAILURE_AT() for reporting a test failure at the
+  given source location -- useful for writing testing utilities.
+* New feature: the universal value printer is moved from Google Mock
+  to Google Test.
+* New feature: type parameters and value parameters are reported in
+  the XML report now.
+* A gtest_disable_pthreads CMake option.
+* Colored output works in GNU Screen sessions now.
+* Parameters of value-parameterized tests are now printed in the
+  textual output.
+* Failures from ad hoc test assertions run before RUN_ALL_TESTS() are
+  now correctly reported.
+* Arguments of ASSERT_XY and EXPECT_XY no longer need to support << to
+  ostream.
+* More complete handling of exceptions.
+* GTEST_ASSERT_XY can be used instead of ASSERT_XY in case the latter
+  name is already used by another library.
+* --gtest_catch_exceptions is now true by default, allowing a test
+  program to continue after an exception is thrown.
+* Value-parameterized test fixtures can now derive from Test and
+  WithParamInterface<T> separately, easing conversion of legacy tests.
+* Death test messages are clearly marked to make them more
+  distinguishable from other messages.
+* Compatibility fixes for Android, Google Native Client, MinGW, HP UX,
+  PowerPC, Lucid autotools, libCStd, Sun C++, Borland C++ Builder (Code Gear),
+  IBM XL C++ (Visual Age C++), and C++0x.
+* Bug fixes and implementation clean-ups.
+* Potentially incompatible changes: disables the harmful 'make install'
+  command in autotools.
+
+Changes for 1.5.0:
+
+ * New feature: assertions can be safely called in multiple threads
+   where the pthreads library is available.
+ * New feature: predicates used inside EXPECT_TRUE() and friends
+   can now generate custom failure messages.
+ * New feature: Google Test can now be compiled as a DLL.
+ * New feature: fused source files are included.
+ * New feature: prints help when encountering unrecognized Google Test flags.
+ * Experimental feature: CMake build script (requires CMake 2.6.4+).
+ * Experimental feature: the Pump script for meta programming.
+ * double values streamed to an assertion are printed with enough precision
+   to differentiate any two different values.
+ * Google Test now works on Solaris and AIX.
+ * Build and test script improvements.
+ * Bug fixes and implementation clean-ups.
+
+ Potentially breaking changes:
+
+ * Stopped supporting VC++ 7.1 with exceptions disabled.
+ * Dropped support for 'make install'.
+
+Changes for 1.4.0:
+
+ * New feature: the event listener API
+ * New feature: test shuffling
+ * New feature: the XML report format is closer to junitreport and can
+   be parsed by Hudson now.
+ * New feature: when a test runs under Visual Studio, its failures are
+   integrated in the IDE.
+ * New feature: /MD(d) versions of VC++ projects.
+ * New feature: elapsed time for the tests is printed by default.
+ * New feature: comes with a TR1 tuple implementation such that Boost
+   is no longer needed for Combine().
+ * New feature: EXPECT_DEATH_IF_SUPPORTED macro and friends.
+ * New feature: the Xcode project can now produce static gtest
+   libraries in addition to a framework.
+ * Compatibility fixes for Solaris, Cygwin, minGW, Windows Mobile,
+   Symbian, gcc, and C++Builder.
+ * Bug fixes and implementation clean-ups.
+
+Changes for 1.3.0:
+
+ * New feature: death tests on Windows, Cygwin, and Mac.
+ * New feature: ability to use Google Test assertions in other testing
+   frameworks.
+ * New feature: ability to run disabled test via
+   --gtest_also_run_disabled_tests.
+ * New feature: the --help flag for printing the usage.
+ * New feature: access to Google Test flag values in user code.
+ * New feature: a script that packs Google Test into one .h and one
+   .cc file for easy deployment.
+ * New feature: support for distributing test functions to multiple
+   machines (requires support from the test runner).
+ * Bug fixes and implementation clean-ups.
+
+Changes for 1.2.1:
+
+ * Compatibility fixes for Linux IA-64 and IBM z/OS.
+ * Added support for using Boost and other TR1 implementations.
+ * Changes to the build scripts to support upcoming release of Google C++
+   Mocking Framework.
+ * Added Makefile to the distribution package.
+ * Improved build instructions in README.
+
+Changes for 1.2.0:
+
+ * New feature: value-parameterized tests.
+ * New feature: the ASSERT/EXPECT_(NON)FATAL_FAILURE(_ON_ALL_THREADS)
+   macros.
+ * Changed the XML report format to match JUnit/Ant's.
+ * Added tests to the Xcode project.
+ * Added scons/SConscript for building with SCons.
+ * Added src/gtest-all.cc for building Google Test from a single file.
+ * Fixed compatibility with Solaris and z/OS.
+ * Enabled running Python tests on systems with python 2.3 installed,
+   e.g. Mac OS X 10.4.
+ * Bug fixes.
+
+Changes for 1.1.0:
+
+ * New feature: type-parameterized tests.
+ * New feature: exception assertions.
+ * New feature: printing elapsed time of tests.
+ * Improved the robustness of death tests.
+ * Added an Xcode project and samples.
+ * Adjusted the output format on Windows to be understandable by Visual Studio.
+ * Minor bug fixes.
+
+Changes for 1.0.1:
+
+ * Added project files for Visual Studio 7.1.
+ * Fixed issues with compiling on Mac OS X.
+ * Fixed issues with compiling on Cygwin.
+
+Changes for 1.0.0:
+
+ * Initial Open Source release of Google Test
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/CMakeLists.txt b/week4/softwareEng_9_4/vendor/googletest/googletest/CMakeLists.txt
new file mode 100644
index 00000000..621d0f04
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/CMakeLists.txt
@@ -0,0 +1,286 @@
+########################################################################
+# CMake build script for Google Test.
+#
+# To run the tests for Google Test itself on Linux, use 'make test' or
+# ctest.  You can select which tests to run using 'ctest -R regex'.
+# For more options, run 'ctest --help'.
+
+# BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to
+# make it prominent in the GUI.
+option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF)
+
+# When other libraries are using a shared version of runtime libraries,
+# Google Test also has to use one.
+option(
+  gtest_force_shared_crt
+  "Use shared (DLL) run-time lib even when Google Test is built as static lib."
+  OFF)
+
+option(gtest_build_tests "Build all of gtest's own tests." OFF)
+
+option(gtest_build_samples "Build gtest's sample programs." OFF)
+
+option(gtest_disable_pthreads "Disable uses of pthreads in gtest." OFF)
+
+option(
+  gtest_hide_internal_symbols
+  "Build gtest with internal symbols hidden in shared libraries."
+  OFF)
+
+# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build().
+include(cmake/hermetic_build.cmake OPTIONAL)
+
+if (COMMAND pre_project_set_up_hermetic_build)
+  pre_project_set_up_hermetic_build()
+endif()
+
+########################################################################
+#
+# Project-wide settings
+
+# Name of the project.
+#
+# CMake files in this project can refer to the root source directory
+# as ${gtest_SOURCE_DIR} and to the root binary directory as
+# ${gtest_BINARY_DIR}.
+# Language "C" is required for find_package(Threads).
+project(gtest CXX C)
+cmake_minimum_required(VERSION 2.6.2)
+
+if (COMMAND set_up_hermetic_build)
+  set_up_hermetic_build()
+endif()
+
+if (gtest_hide_internal_symbols)
+  set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+  set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
+endif()
+
+# Define helper functions and macros used by Google Test.
+include(cmake/internal_utils.cmake)
+
+config_compiler_and_linker()  # Defined in internal_utils.cmake.
+
+# Where Google Test's .h files can be found.
+include_directories(
+  ${gtest_SOURCE_DIR}/include
+  ${gtest_SOURCE_DIR})
+
+# Where Google Test's libraries can be found.
+link_directories(${gtest_BINARY_DIR}/src)
+
+# Summary of tuple support for Microsoft Visual Studio:
+# Compiler    version(MS)  version(cmake)  Support
+# ----------  -----------  --------------  -----------------------------
+# <= VS 2010  <= 10        <= 1600         Use Google Tests's own tuple.
+# VS 2012     11           1700            std::tr1::tuple + _VARIADIC_MAX=10
+# VS 2013     12           1800            std::tr1::tuple
+if (MSVC AND MSVC_VERSION EQUAL 1700)
+  add_definitions(/D _VARIADIC_MAX=10)
+endif()
+
+########################################################################
+#
+# Defines the gtest & gtest_main libraries.  User tests should link
+# with one of them.
+
+# Google Test libraries.  We build them using more strict warnings than what
+# are used for other targets, to ensure that gtest can be compiled by a user
+# aggressive about warnings.
+cxx_library(gtest "${cxx_strict}" src/gtest-all.cc)
+cxx_library(gtest_main "${cxx_strict}" src/gtest_main.cc)
+target_link_libraries(gtest_main gtest)
+
+# If the CMake version supports it, attach header directory information
+# to the targets for when we are part of a parent build (ie being pulled
+# in via add_subdirectory() rather than being a standalone build).
+if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
+  target_include_directories(gtest      INTERFACE "${gtest_SOURCE_DIR}/include")
+  target_include_directories(gtest_main INTERFACE "${gtest_SOURCE_DIR}/include")
+endif()
+
+########################################################################
+#
+# Install rules
+install(TARGETS gtest gtest_main
+  DESTINATION lib)
+install(DIRECTORY ${gtest_SOURCE_DIR}/include/gtest
+  DESTINATION include)
+
+########################################################################
+#
+# Samples on how to link user tests with gtest or gtest_main.
+#
+# They are not built by default.  To build them, set the
+# gtest_build_samples option to ON.  You can do it by running ccmake
+# or specifying the -Dgtest_build_samples=ON flag when running cmake.
+
+if (gtest_build_samples)
+  cxx_executable(sample1_unittest samples gtest_main samples/sample1.cc)
+  cxx_executable(sample2_unittest samples gtest_main samples/sample2.cc)
+  cxx_executable(sample3_unittest samples gtest_main)
+  cxx_executable(sample4_unittest samples gtest_main samples/sample4.cc)
+  cxx_executable(sample5_unittest samples gtest_main samples/sample1.cc)
+  cxx_executable(sample6_unittest samples gtest_main)
+  cxx_executable(sample7_unittest samples gtest_main)
+  cxx_executable(sample8_unittest samples gtest_main)
+  cxx_executable(sample9_unittest samples gtest)
+  cxx_executable(sample10_unittest samples gtest)
+endif()
+
+########################################################################
+#
+# Google Test's own tests.
+#
+# You can skip this section if you aren't interested in testing
+# Google Test itself.
+#
+# The tests are not built by default.  To build them, set the
+# gtest_build_tests option to ON.  You can do it by running ccmake
+# or specifying the -Dgtest_build_tests=ON flag when running cmake.
+
+if (gtest_build_tests)
+  # This must be set in the root directory for the tests to be run by
+  # 'make test' or ctest.
+  enable_testing()
+
+  ############################################################
+  # C++ tests built with standard compiler flags.
+
+  cxx_test(gtest-death-test_test gtest_main)
+  cxx_test(gtest_environment_test gtest)
+  cxx_test(gtest-filepath_test gtest_main)
+  cxx_test(gtest-linked_ptr_test gtest_main)
+  cxx_test(gtest-listener_test gtest_main)
+  cxx_test(gtest_main_unittest gtest_main)
+  cxx_test(gtest-message_test gtest_main)
+  cxx_test(gtest_no_test_unittest gtest)
+  cxx_test(gtest-options_test gtest_main)
+  cxx_test(gtest-param-test_test gtest
+    test/gtest-param-test2_test.cc)
+  cxx_test(gtest-port_test gtest_main)
+  cxx_test(gtest_pred_impl_unittest gtest_main)
+  cxx_test(gtest_premature_exit_test gtest
+    test/gtest_premature_exit_test.cc)
+  cxx_test(gtest-printers_test gtest_main)
+  cxx_test(gtest_prod_test gtest_main
+    test/production.cc)
+  cxx_test(gtest_repeat_test gtest)
+  cxx_test(gtest_sole_header_test gtest_main)
+  cxx_test(gtest_stress_test gtest)
+  cxx_test(gtest-test-part_test gtest_main)
+  cxx_test(gtest_throw_on_failure_ex_test gtest)
+  cxx_test(gtest-typed-test_test gtest_main
+    test/gtest-typed-test2_test.cc)
+  cxx_test(gtest_unittest gtest_main)
+  cxx_test(gtest-unittest-api_test gtest)
+
+  ############################################################
+  # C++ tests built with non-standard compiler flags.
+
+  # MSVC 7.1 does not support STL with exceptions disabled.
+  if (NOT MSVC OR MSVC_VERSION GREATER 1310)
+    cxx_library(gtest_no_exception "${cxx_no_exception}"
+      src/gtest-all.cc)
+    cxx_library(gtest_main_no_exception "${cxx_no_exception}"
+      src/gtest-all.cc src/gtest_main.cc)
+  endif()
+  cxx_library(gtest_main_no_rtti "${cxx_no_rtti}"
+    src/gtest-all.cc src/gtest_main.cc)
+
+  cxx_test_with_flags(gtest-death-test_ex_nocatch_test
+    "${cxx_exception} -DGTEST_ENABLE_CATCH_EXCEPTIONS_=0"
+    gtest test/gtest-death-test_ex_test.cc)
+  cxx_test_with_flags(gtest-death-test_ex_catch_test
+    "${cxx_exception} -DGTEST_ENABLE_CATCH_EXCEPTIONS_=1"
+    gtest test/gtest-death-test_ex_test.cc)
+
+  cxx_test_with_flags(gtest_no_rtti_unittest "${cxx_no_rtti}"
+    gtest_main_no_rtti test/gtest_unittest.cc)
+
+  cxx_shared_library(gtest_dll "${cxx_default}"
+    src/gtest-all.cc src/gtest_main.cc)
+
+  cxx_executable_with_flags(gtest_dll_test_ "${cxx_default}"
+    gtest_dll test/gtest_all_test.cc)
+  set_target_properties(gtest_dll_test_
+                        PROPERTIES
+                        COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
+
+  if (NOT MSVC OR MSVC_VERSION LESS 1600)  # 1600 is Visual Studio 2010.
+    # Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that
+    # conflict with our own definitions. Therefore using our own tuple does not
+    # work on those compilers.
+    cxx_library(gtest_main_use_own_tuple "${cxx_use_own_tuple}"
+      src/gtest-all.cc src/gtest_main.cc)
+
+    cxx_test_with_flags(gtest-tuple_test "${cxx_use_own_tuple}"
+      gtest_main_use_own_tuple test/gtest-tuple_test.cc)
+
+    cxx_test_with_flags(gtest_use_own_tuple_test "${cxx_use_own_tuple}"
+      gtest_main_use_own_tuple
+      test/gtest-param-test_test.cc test/gtest-param-test2_test.cc)
+  endif()
+
+  ############################################################
+  # Python tests.
+
+  cxx_executable(gtest_break_on_failure_unittest_ test gtest)
+  py_test(gtest_break_on_failure_unittest)
+
+  # Visual Studio .NET 2003 does not support STL with exceptions disabled.
+  if (NOT MSVC OR MSVC_VERSION GREATER 1310)  # 1310 is Visual Studio .NET 2003
+    cxx_executable_with_flags(
+      gtest_catch_exceptions_no_ex_test_
+      "${cxx_no_exception}"
+      gtest_main_no_exception
+      test/gtest_catch_exceptions_test_.cc)
+  endif()
+
+  cxx_executable_with_flags(
+    gtest_catch_exceptions_ex_test_
+    "${cxx_exception}"
+    gtest_main
+    test/gtest_catch_exceptions_test_.cc)
+  py_test(gtest_catch_exceptions_test)
+
+  cxx_executable(gtest_color_test_ test gtest)
+  py_test(gtest_color_test)
+
+  cxx_executable(gtest_env_var_test_ test gtest)
+  py_test(gtest_env_var_test)
+
+  cxx_executable(gtest_filter_unittest_ test gtest)
+  py_test(gtest_filter_unittest)
+
+  cxx_executable(gtest_help_test_ test gtest_main)
+  py_test(gtest_help_test)
+
+  cxx_executable(gtest_list_tests_unittest_ test gtest)
+  py_test(gtest_list_tests_unittest)
+
+  cxx_executable(gtest_output_test_ test gtest)
+  py_test(gtest_output_test)
+
+  cxx_executable(gtest_shuffle_test_ test gtest)
+  py_test(gtest_shuffle_test)
+
+  # MSVC 7.1 does not support STL with exceptions disabled.
+  if (NOT MSVC OR MSVC_VERSION GREATER 1310)
+    cxx_executable(gtest_throw_on_failure_test_ test gtest_no_exception)
+    set_target_properties(gtest_throw_on_failure_test_
+      PROPERTIES
+      COMPILE_FLAGS "${cxx_no_exception}")
+    py_test(gtest_throw_on_failure_test)
+  endif()
+
+  cxx_executable(gtest_uninitialized_test_ test gtest)
+  py_test(gtest_uninitialized_test)
+
+  cxx_executable(gtest_xml_outfile1_test_ test gtest_main)
+  cxx_executable(gtest_xml_outfile2_test_ test gtest_main)
+  py_test(gtest_xml_outfiles_test)
+
+  cxx_executable(gtest_xml_output_unittest_ test gtest)
+  py_test(gtest_xml_output_unittest)
+endif()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/CONTRIBUTORS b/week4/softwareEng_9_4/vendor/googletest/googletest/CONTRIBUTORS
new file mode 100644
index 00000000..feae2fc0
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/CONTRIBUTORS
@@ -0,0 +1,37 @@
+# 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>
+Bharat Mediratta <bharat@menalto.com>
+Chandler Carruth <chandlerc@google.com>
+Chris Prince <cprince@google.com>
+Chris Taylor <taylorc@google.com>
+Dan Egnor <egnor@google.com>
+Eric Roman <eroman@chromium.org>
+Hady Zalek <hady.zalek@gmail.com>
+Jeffrey Yasskin <jyasskin@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>
+Manuel Klimek <klimek@google.com>
+Markus Heule <markus.heule@gmail.com>
+Mika Raento <mikie@iki.fi>
+Miklós Fazekas <mfazekas@szemafor.com>
+Pasi Valminen <pasi.valminen@gmail.com>
+Patrick Hanna <phanna@google.com>
+Patrick Riley <pfr@google.com>
+Peter 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>
+Tracy Bialik <tracy@pentad.com>
+Vadim Berman <vadimb@google.com>
+Vlad Losev <vladl@google.com>
+Zhanyong Wan <wan@google.com>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/LICENSE b/week4/softwareEng_9_4/vendor/googletest/googletest/LICENSE
new file mode 100644
index 00000000..1941a11f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/LICENSE
@@ -0,0 +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.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/Makefile.am b/week4/softwareEng_9_4/vendor/googletest/googletest/Makefile.am
new file mode 100644
index 00000000..29797e4e
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/Makefile.am
@@ -0,0 +1,310 @@
+# Automake file
+
+ACLOCAL_AMFLAGS = -I m4
+
+# Nonstandard package files for distribution
+EXTRA_DIST = \
+  CHANGES \
+  CONTRIBUTORS \
+  LICENSE \
+  include/gtest/gtest-param-test.h.pump \
+  include/gtest/internal/gtest-param-util-generated.h.pump \
+  include/gtest/internal/gtest-tuple.h.pump \
+  include/gtest/internal/gtest-type-util.h.pump \
+  make/Makefile \
+  scripts/fuse_gtest_files.py \
+  scripts/gen_gtest_pred_impl.py \
+  scripts/pump.py \
+  scripts/test/Makefile
+
+# gtest source files that we don't compile directly.  They are
+# #included by gtest-all.cc.
+GTEST_SRC = \
+  src/gtest-death-test.cc \
+  src/gtest-filepath.cc \
+  src/gtest-internal-inl.h \
+  src/gtest-port.cc \
+  src/gtest-printers.cc \
+  src/gtest-test-part.cc \
+  src/gtest-typed-test.cc \
+  src/gtest.cc
+
+EXTRA_DIST += $(GTEST_SRC)
+
+# Sample files that we don't compile.
+EXTRA_DIST += \
+  samples/prime_tables.h \
+  samples/sample2_unittest.cc \
+  samples/sample3_unittest.cc \
+  samples/sample4_unittest.cc \
+  samples/sample5_unittest.cc \
+  samples/sample6_unittest.cc \
+  samples/sample7_unittest.cc \
+  samples/sample8_unittest.cc \
+  samples/sample9_unittest.cc
+
+# C++ test files that we don't compile directly.
+EXTRA_DIST += \
+  test/gtest-death-test_ex_test.cc \
+  test/gtest-death-test_test.cc \
+  test/gtest-filepath_test.cc \
+  test/gtest-linked_ptr_test.cc \
+  test/gtest-listener_test.cc \
+  test/gtest-message_test.cc \
+  test/gtest-options_test.cc \
+  test/gtest-param-test2_test.cc \
+  test/gtest-param-test2_test.cc \
+  test/gtest-param-test_test.cc \
+  test/gtest-param-test_test.cc \
+  test/gtest-param-test_test.h \
+  test/gtest-port_test.cc \
+  test/gtest_premature_exit_test.cc \
+  test/gtest-printers_test.cc \
+  test/gtest-test-part_test.cc \
+  test/gtest-tuple_test.cc \
+  test/gtest-typed-test2_test.cc \
+  test/gtest-typed-test_test.cc \
+  test/gtest-typed-test_test.h \
+  test/gtest-unittest-api_test.cc \
+  test/gtest_break_on_failure_unittest_.cc \
+  test/gtest_catch_exceptions_test_.cc \
+  test/gtest_color_test_.cc \
+  test/gtest_env_var_test_.cc \
+  test/gtest_environment_test.cc \
+  test/gtest_filter_unittest_.cc \
+  test/gtest_help_test_.cc \
+  test/gtest_list_tests_unittest_.cc \
+  test/gtest_main_unittest.cc \
+  test/gtest_no_test_unittest.cc \
+  test/gtest_output_test_.cc \
+  test/gtest_pred_impl_unittest.cc \
+  test/gtest_prod_test.cc \
+  test/gtest_repeat_test.cc \
+  test/gtest_shuffle_test_.cc \
+  test/gtest_sole_header_test.cc \
+  test/gtest_stress_test.cc \
+  test/gtest_throw_on_failure_ex_test.cc \
+  test/gtest_throw_on_failure_test_.cc \
+  test/gtest_uninitialized_test_.cc \
+  test/gtest_unittest.cc \
+  test/gtest_unittest.cc \
+  test/gtest_xml_outfile1_test_.cc \
+  test/gtest_xml_outfile2_test_.cc \
+  test/gtest_xml_output_unittest_.cc \
+  test/production.cc \
+  test/production.h
+
+# Python tests that we don't run.
+EXTRA_DIST += \
+  test/gtest_break_on_failure_unittest.py \
+  test/gtest_catch_exceptions_test.py \
+  test/gtest_color_test.py \
+  test/gtest_env_var_test.py \
+  test/gtest_filter_unittest.py \
+  test/gtest_help_test.py \
+  test/gtest_list_tests_unittest.py \
+  test/gtest_output_test.py \
+  test/gtest_output_test_golden_lin.txt \
+  test/gtest_shuffle_test.py \
+  test/gtest_test_utils.py \
+  test/gtest_throw_on_failure_test.py \
+  test/gtest_uninitialized_test.py \
+  test/gtest_xml_outfiles_test.py \
+  test/gtest_xml_output_unittest.py \
+  test/gtest_xml_test_utils.py
+
+# CMake script
+EXTRA_DIST += \
+  CMakeLists.txt \
+  cmake/internal_utils.cmake
+
+# MSVC project files
+EXTRA_DIST += \
+  msvc/gtest-md.sln \
+  msvc/gtest-md.vcproj \
+  msvc/gtest.sln \
+  msvc/gtest.vcproj \
+  msvc/gtest_main-md.vcproj \
+  msvc/gtest_main.vcproj \
+  msvc/gtest_prod_test-md.vcproj \
+  msvc/gtest_prod_test.vcproj \
+  msvc/gtest_unittest-md.vcproj \
+  msvc/gtest_unittest.vcproj
+
+# xcode project files
+EXTRA_DIST += \
+  xcode/Config/DebugProject.xcconfig \
+  xcode/Config/FrameworkTarget.xcconfig \
+  xcode/Config/General.xcconfig \
+  xcode/Config/ReleaseProject.xcconfig \
+  xcode/Config/StaticLibraryTarget.xcconfig \
+  xcode/Config/TestTarget.xcconfig \
+  xcode/Resources/Info.plist \
+  xcode/Scripts/runtests.sh \
+  xcode/Scripts/versiongenerate.py \
+  xcode/gtest.xcodeproj/project.pbxproj
+
+# xcode sample files
+EXTRA_DIST += \
+  xcode/Samples/FrameworkSample/Info.plist \
+  xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj \
+  xcode/Samples/FrameworkSample/runtests.sh \
+  xcode/Samples/FrameworkSample/widget.cc \
+  xcode/Samples/FrameworkSample/widget.h \
+  xcode/Samples/FrameworkSample/widget_test.cc
+
+# C++Builder project files
+EXTRA_DIST += \
+  codegear/gtest.cbproj \
+  codegear/gtest.groupproj \
+  codegear/gtest_all.cc \
+  codegear/gtest_link.cc \
+  codegear/gtest_main.cbproj \
+  codegear/gtest_unittest.cbproj
+
+# Distribute and install M4 macro
+m4datadir = $(datadir)/aclocal
+m4data_DATA = m4/gtest.m4
+EXTRA_DIST += $(m4data_DATA)
+
+# We define the global AM_CPPFLAGS as everything we compile includes from these
+# directories.
+AM_CPPFLAGS = -I$(srcdir) -I$(srcdir)/include
+
+# Modifies compiler and linker flags for pthreads compatibility.
+if HAVE_PTHREADS
+  AM_CXXFLAGS = @PTHREAD_CFLAGS@ -DGTEST_HAS_PTHREAD=1
+  AM_LIBS = @PTHREAD_LIBS@
+else
+  AM_CXXFLAGS = -DGTEST_HAS_PTHREAD=0
+endif
+
+# Build rules for libraries.
+lib_LTLIBRARIES = lib/libgtest.la lib/libgtest_main.la
+
+lib_libgtest_la_SOURCES = src/gtest-all.cc
+
+pkginclude_HEADERS = \
+  include/gtest/gtest-death-test.h \
+  include/gtest/gtest-message.h \
+  include/gtest/gtest-param-test.h \
+  include/gtest/gtest-printers.h \
+  include/gtest/gtest-spi.h \
+  include/gtest/gtest-test-part.h \
+  include/gtest/gtest-typed-test.h \
+  include/gtest/gtest.h \
+  include/gtest/gtest_pred_impl.h \
+  include/gtest/gtest_prod.h
+
+pkginclude_internaldir = $(pkgincludedir)/internal
+pkginclude_internal_HEADERS = \
+  include/gtest/internal/gtest-death-test-internal.h \
+  include/gtest/internal/gtest-filepath.h \
+  include/gtest/internal/gtest-internal.h \
+  include/gtest/internal/gtest-linked_ptr.h \
+  include/gtest/internal/gtest-param-util-generated.h \
+  include/gtest/internal/gtest-param-util.h \
+  include/gtest/internal/gtest-port.h \
+  include/gtest/internal/gtest-port-arch.h \
+  include/gtest/internal/gtest-string.h \
+  include/gtest/internal/gtest-tuple.h \
+  include/gtest/internal/gtest-type-util.h \
+  include/gtest/internal/custom/gtest.h \
+  include/gtest/internal/custom/gtest-port.h \
+  include/gtest/internal/custom/gtest-printers.h
+
+lib_libgtest_main_la_SOURCES = src/gtest_main.cc
+lib_libgtest_main_la_LIBADD = lib/libgtest.la
+
+# Bulid rules for samples and tests. Automake's naming for some of
+# these variables isn't terribly obvious, so this is a brief
+# reference:
+#
+# TESTS -- Programs run automatically by "make check"
+# check_PROGRAMS -- Programs built by "make check" but not necessarily run
+
+noinst_LTLIBRARIES = samples/libsamples.la
+
+samples_libsamples_la_SOURCES = \
+  samples/sample1.cc \
+  samples/sample1.h \
+  samples/sample2.cc \
+  samples/sample2.h \
+  samples/sample3-inl.h \
+  samples/sample4.cc \
+  samples/sample4.h
+
+TESTS=
+TESTS_ENVIRONMENT = GTEST_SOURCE_DIR="$(srcdir)/test" \
+                    GTEST_BUILD_DIR="$(top_builddir)/test"
+check_PROGRAMS=
+
+# A simple sample on using gtest.
+TESTS += samples/sample1_unittest
+check_PROGRAMS += samples/sample1_unittest
+samples_sample1_unittest_SOURCES = samples/sample1_unittest.cc
+samples_sample1_unittest_LDADD = lib/libgtest_main.la \
+                                 lib/libgtest.la \
+                                 samples/libsamples.la
+
+# Another sample.  It also verifies that libgtest works.
+TESTS += samples/sample10_unittest
+check_PROGRAMS += samples/sample10_unittest
+samples_sample10_unittest_SOURCES = samples/sample10_unittest.cc
+samples_sample10_unittest_LDADD = lib/libgtest.la
+
+# This tests most constructs of gtest and verifies that libgtest_main
+# and libgtest work.
+TESTS += test/gtest_all_test
+check_PROGRAMS += test/gtest_all_test
+test_gtest_all_test_SOURCES = test/gtest_all_test.cc
+test_gtest_all_test_LDADD = lib/libgtest_main.la \
+                            lib/libgtest.la
+
+# Tests that fused gtest files compile and work.
+FUSED_GTEST_SRC = \
+  fused-src/gtest/gtest-all.cc \
+  fused-src/gtest/gtest.h \
+  fused-src/gtest/gtest_main.cc
+
+if HAVE_PYTHON
+TESTS += test/fused_gtest_test
+check_PROGRAMS += test/fused_gtest_test
+test_fused_gtest_test_SOURCES = $(FUSED_GTEST_SRC) \
+                                samples/sample1.cc samples/sample1_unittest.cc
+test_fused_gtest_test_CPPFLAGS = -I"$(srcdir)/fused-src"
+
+# Build rules for putting fused Google Test files into the distribution
+# package. The user can also create those files by manually running
+# scripts/fuse_gtest_files.py.
+$(test_fused_gtest_test_SOURCES): fused-gtest
+
+fused-gtest: $(pkginclude_HEADERS) $(pkginclude_internal_HEADERS) \
+             $(GTEST_SRC) src/gtest-all.cc src/gtest_main.cc \
+             scripts/fuse_gtest_files.py
+	mkdir -p "$(srcdir)/fused-src"
+	chmod -R u+w "$(srcdir)/fused-src"
+	rm -f "$(srcdir)/fused-src/gtest/gtest-all.cc"
+	rm -f "$(srcdir)/fused-src/gtest/gtest.h"
+	"$(srcdir)/scripts/fuse_gtest_files.py" "$(srcdir)/fused-src"
+	cp -f "$(srcdir)/src/gtest_main.cc" "$(srcdir)/fused-src/gtest/"
+
+maintainer-clean-local:
+	rm -rf "$(srcdir)/fused-src"
+endif
+
+# Death tests may produce core dumps in the build directory. In case
+# this happens, clean them to keep distcleancheck happy.
+CLEANFILES = core
+
+# Disables 'make install' as installing a compiled version of Google
+# Test can lead to undefined behavior due to violation of the
+# One-Definition Rule.
+
+install-exec-local:
+	echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Test into your build system."
+	false
+
+install-data-local:
+	echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Test into your build system."
+	false
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/README.md b/week4/softwareEng_9_4/vendor/googletest/googletest/README.md
new file mode 100644
index 00000000..edd44080
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/README.md
@@ -0,0 +1,280 @@
+
+### Generic Build Instructions ###
+
+#### Setup ####
+
+To build Google Test 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 ####
+
+Suppose you put Google Test in directory `${GTEST_DIR}`.  To build it,
+create a library build target (or a project as called by Visual Studio
+and Xcode) to compile
+
+    ${GTEST_DIR}/src/gtest-all.cc
+
+with `${GTEST_DIR}/include` in the system header search path and `${GTEST_DIR}`
+in the normal header search path.  Assuming a Linux-like system and gcc,
+something like the following will do:
+
+    g++ -isystem ${GTEST_DIR}/include -I${GTEST_DIR} \
+        -pthread -c ${GTEST_DIR}/src/gtest-all.cc
+    ar -rv libgtest.a gtest-all.o
+
+(We need `-pthread` as Google Test uses threads.)
+
+Next, you should compile your test source file with
+`${GTEST_DIR}/include` in the system header search path, and link it
+with gtest and any other necessary libraries:
+
+    g++ -isystem ${GTEST_DIR}/include -pthread path/to/your_test.cc libgtest.a \
+        -o your_test
+
+As an example, the make/ directory contains a Makefile that you can
+use to build Google Test on systems where GNU make is available
+(e.g. Linux, Mac OS X, and Cygwin).  It doesn't try to build Google
+Test's own tests.  Instead, it just builds the Google Test library and
+a sample test.  You can use it as a starting point for your own build
+script.
+
+If the default settings are correct for your environment, the
+following commands should succeed:
+
+    cd ${GTEST_DIR}/make
+    make
+    ./sample1_unittest
+
+If you see errors, try to tweak the contents of `make/Makefile` to make
+them go away.  There are instructions in `make/Makefile` on how to do
+it.
+
+### Using CMake ###
+
+Google Test comes with a CMake build script (
+[CMakeLists.txt](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.  The typical
+workflow starts with:
+
+    mkdir mybuild       # Create a directory to hold the build output.
+    cd mybuild
+    cmake ${GTEST_DIR}  # Generate native build scripts.
+
+If you want to build Google Test's samples, you should replace the
+last command with
+
+    cmake -Dgtest_build_samples=ON ${GTEST_DIR}
+
+If you are on a \*nix system, you should now see a Makefile in the
+current directory.  Just type 'make' to build gtest.
+
+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.
+
+### Legacy Build Scripts ###
+
+Before settling on CMake, we have been providing hand-maintained build
+projects/scripts for Visual Studio, Xcode, and Autotools.  While we
+continue to provide them for convenience, they are not actively
+maintained any more.  We highly recommend that you follow the
+instructions in the previous two sections to integrate Google Test
+with your existing build system.
+
+If you still need to use the legacy build scripts, here's how:
+
+The msvc\ folder contains two solutions with Visual C++ projects.
+Open the `gtest.sln` or `gtest-md.sln` file using Visual Studio, and you
+are ready to build Google Test the same way you build any Visual
+Studio project.  Files that have names ending with -md use DLL
+versions of Microsoft runtime libraries (the /MD or the /MDd compiler
+option).  Files without that suffix use static versions of the runtime
+libraries (the /MT or the /MTd option).  Please note that one must use
+the same option to compile both gtest and the test code.  If you use
+Visual Studio 2005 or above, we recommend the -md version as /MD is
+the default for new projects in these versions of Visual Studio.
+
+On Mac OS X, open the `gtest.xcodeproj` in the `xcode/` folder using
+Xcode.  Build the "gtest" target.  The universal binary framework will
+end up in your selected build directory (selected in the Xcode
+"Preferences..." -> "Building" pane and defaults to xcode/build).
+Alternatively, at the command line, enter:
+
+    xcodebuild
+
+This will build the "Release" configuration of gtest.framework in your
+default build location.  See the "xcodebuild" man page for more
+information about building different configurations and building in
+different locations.
+
+If you wish to use the Google Test Xcode project with Xcode 4.x and
+above, you need to either:
+
+ * update the SDK configuration options in xcode/Config/General.xconfig.
+   Comment options `SDKROOT`, `MACOS_DEPLOYMENT_TARGET`, and `GCC_VERSION`. If
+   you choose this route you lose the ability to target earlier versions
+   of MacOS X.
+ * Install an SDK for an earlier version. This doesn't appear to be
+   supported by Apple, but has been reported to work
+   (http://stackoverflow.com/questions/5378518).
+
+### Tweaking Google Test ###
+
+Google Test 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 Google Test 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](include/gtest/internal/gtest-port.h).
+
+### Choosing a TR1 Tuple Library ###
+
+Some Google Test features require the C++ Technical Report 1 (TR1)
+tuple library, which is not yet available with all compilers.  The
+good news is that Google Test implements a subset of TR1 tuple that's
+enough for its own need, and will automatically use this when the
+compiler doesn't provide TR1 tuple.
+
+Usually you don't need to care about which tuple library Google Test
+uses.  However, if your project already uses TR1 tuple, you need to
+tell Google Test to use the same TR1 tuple library the rest of your
+project uses, or the two tuple implementations will clash.  To do
+that, add
+
+    -DGTEST_USE_OWN_TR1_TUPLE=0
+
+to the compiler flags while compiling Google Test and your tests.  If
+you want to force Google Test to use its own tuple library, just add
+
+    -DGTEST_USE_OWN_TR1_TUPLE=1
+
+to the compiler flags instead.
+
+If you don't want Google Test to use tuple at all, add
+
+    -DGTEST_HAS_TR1_TUPLE=0
+
+and all features using tuple will be disabled.
+
+### Multi-threaded Tests ###
+
+Google Test 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 Google Test 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 Google Test 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 or the deprecated Autotools
+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) ###
+
+Google Test is compact, so most users can build and link it as a
+static library for the simplicity.  You can choose to use Google Test
+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 Google Test as a
+shared library.  Otherwise a future release of Google Test 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 Google Test macro clashes with another
+library, you can force Google Test to rename its macro to avoid the
+conflict.
+
+Specifically, if both Google Test and some other code define macro
+FOO, you can add
+
+    -DGTEST_DONT_DEFINE_FOO=1
+
+to the compiler flags to tell Google Test 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.
+
+## Developing Google Test ##
+
+This section discusses how to make your own changes to Google Test.
+
+### Testing Google Test Itself ###
+
+To make sure your changes work as intended and don't break existing
+functionality, you'll want to compile and run Google Test's own tests.
+For that you can use CMake:
+
+    mkdir mybuild
+    cd mybuild
+    cmake -Dgtest_build_tests=ON ${GTEST_DIR}
+
+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 -Dgtest_build_tests=ON ${GTEST_DIR}
+
+Next, you can build Google Test and all of its own tests.  On \*nix,
+this is usually done by 'make'.  To run the tests, do
+
+    make test
+
+All tests should pass.
+
+Normally you don't need to worry about regenerating the source files,
+unless you need to modify them.  In that case, you should modify the
+corresponding .pump files instead and run the pump.py Python script to
+regenerate them.  You can find pump.py in the [scripts/](scripts/) directory.
+Read the [Pump manual](docs/PumpManual.md) for how to use it.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/build-aux/.keep b/week4/softwareEng_9_4/vendor/googletest/googletest/build-aux/.keep
new file mode 100644
index 00000000..e69de29b
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/cmake/internal_utils.cmake b/week4/softwareEng_9_4/vendor/googletest/googletest/cmake/internal_utils.cmake
new file mode 100644
index 00000000..8878dc1a
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/cmake/internal_utils.cmake
@@ -0,0 +1,256 @@
+# Defines functions and macros useful for building Google Test and
+# Google Mock.
+#
+# Note:
+#
+# - This file will be run twice when building Google Mock (once via
+#   Google Test's CMakeLists.txt, and once via Google Mock's).
+#   Therefore it shouldn't have any side effects other than defining
+#   the functions and macros.
+#
+# - The functions/macros defined in this file may depend on Google
+#   Test and Google Mock's option() definitions, and thus must be
+#   called *after* the options have been defined.
+
+# Tweaks CMake's default compiler/linker settings to suit Google Test's needs.
+#
+# This must be a macro(), as inside a function string() can only
+# update variables in the function scope.
+macro(fix_default_compiler_settings_)
+  if (MSVC)
+    # For MSVC, CMake sets certain flags to defaults we want to override.
+    # This replacement code is taken from sample in the CMake Wiki at
+    # http://www.cmake.org/Wiki/CMake_FAQ#Dynamic_Replace.
+    foreach (flag_var
+             CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+             CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+      if (NOT BUILD_SHARED_LIBS AND NOT gtest_force_shared_crt)
+        # When Google Test is built as a shared library, it should also use
+        # shared runtime libraries.  Otherwise, it may end up with multiple
+        # copies of runtime library data in different modules, resulting in
+        # hard-to-find crashes. When it is built as a static library, it is
+        # preferable to use CRT as static libraries, as we don't have to rely
+        # on CRT DLLs being available. CMake always defaults to using shared
+        # CRT libraries, so we override that default here.
+        string(REPLACE "/MD" "-MT" ${flag_var} "${${flag_var}}")
+      endif()
+
+      # We prefer more strict warning checking for building Google Test.
+      # Replaces /W3 with /W4 in defaults.
+      string(REPLACE "/W3" "/W4" ${flag_var} "${${flag_var}}")
+    endforeach()
+  endif()
+endmacro()
+
+# Defines the compiler/linker flags used to build Google Test and
+# Google Mock.  You can tweak these definitions to suit your need.  A
+# variable's value is empty before it's explicitly assigned to.
+macro(config_compiler_and_linker)
+  # Note: pthreads on MinGW is not supported, even if available
+  # instead, we use windows threading primitives
+  if (NOT gtest_disable_pthreads AND NOT MINGW)
+    # Defines CMAKE_USE_PTHREADS_INIT and CMAKE_THREAD_LIBS_INIT.
+    find_package(Threads)
+  endif()
+
+  fix_default_compiler_settings_()
+  if (MSVC)
+    # Newlines inside flags variables break CMake's NMake generator.
+    # TODO(vladl@google.com): Add -RTCs and -RTCu to debug builds.
+    set(cxx_base_flags "-GS -W4 -WX -wd4251 -wd4275 -nologo -J -Zi")
+    if (MSVC_VERSION LESS 1400)  # 1400 is Visual Studio 2005
+      # Suppress spurious warnings MSVC 7.1 sometimes issues.
+      # Forcing value to bool.
+      set(cxx_base_flags "${cxx_base_flags} -wd4800")
+      # Copy constructor and assignment operator could not be generated.
+      set(cxx_base_flags "${cxx_base_flags} -wd4511 -wd4512")
+      # Compatibility warnings not applicable to Google Test.
+      # Resolved overload was found by argument-dependent lookup.
+      set(cxx_base_flags "${cxx_base_flags} -wd4675")
+    endif()
+    if (MSVC_VERSION LESS 1500)  # 1500 is Visual Studio 2008
+      # Conditional expression is constant.
+      # When compiling with /W4, we get several instances of C4127
+      # (Conditional expression is constant). In our code, we disable that
+      # warning on a case-by-case basis. However, on Visual Studio 2005,
+      # the warning fires on std::list. Therefore on that compiler and earlier,
+      # we disable the warning project-wide.
+      set(cxx_base_flags "${cxx_base_flags} -wd4127")
+    endif()
+    if (NOT (MSVC_VERSION LESS 1700))  # 1700 is Visual Studio 2012.
+      # Suppress "unreachable code" warning on VS 2012 and later.
+      # http://stackoverflow.com/questions/3232669 explains the issue.
+      set(cxx_base_flags "${cxx_base_flags} -wd4702")
+    endif()
+    if (NOT (MSVC_VERSION GREATER 1900))  # 1900 is Visual Studio 2015
+      # BigObj required for tests.
+      set(cxx_base_flags "${cxx_base_flags} -bigobj")
+    endif()
+
+    set(cxx_base_flags "${cxx_base_flags} -D_UNICODE -DUNICODE -DWIN32 -D_WIN32")
+    set(cxx_base_flags "${cxx_base_flags} -DSTRICT -DWIN32_LEAN_AND_MEAN")
+    set(cxx_exception_flags "-EHsc -D_HAS_EXCEPTIONS=1")
+    set(cxx_no_exception_flags "-D_HAS_EXCEPTIONS=0")
+    set(cxx_no_rtti_flags "-GR-")
+  elseif (CMAKE_COMPILER_IS_GNUCXX)
+    set(cxx_base_flags "-Wall -Wshadow")
+    set(cxx_exception_flags "-fexceptions")
+    set(cxx_no_exception_flags "-fno-exceptions")
+    # Until version 4.3.2, GCC doesn't define a macro to indicate
+    # whether RTTI is enabled.  Therefore we define GTEST_HAS_RTTI
+    # explicitly.
+    set(cxx_no_rtti_flags "-fno-rtti -DGTEST_HAS_RTTI=0")
+    set(cxx_strict_flags
+      "-Wextra -Wno-unused-parameter -Wno-missing-field-initializers")
+  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "SunPro")
+    set(cxx_exception_flags "-features=except")
+    # Sun Pro doesn't provide macros to indicate whether exceptions and
+    # RTTI are enabled, so we define GTEST_HAS_* explicitly.
+    set(cxx_no_exception_flags "-features=no%except -DGTEST_HAS_EXCEPTIONS=0")
+    set(cxx_no_rtti_flags "-features=no%rtti -DGTEST_HAS_RTTI=0")
+  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "VisualAge" OR
+      CMAKE_CXX_COMPILER_ID STREQUAL "XL")
+    # CMake 2.8 changes Visual Age's compiler ID to "XL".
+    set(cxx_exception_flags "-qeh")
+    set(cxx_no_exception_flags "-qnoeh")
+    # Until version 9.0, Visual Age doesn't define a macro to indicate
+    # whether RTTI is enabled.  Therefore we define GTEST_HAS_RTTI
+    # explicitly.
+    set(cxx_no_rtti_flags "-qnortti -DGTEST_HAS_RTTI=0")
+  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "HP")
+    set(cxx_base_flags "-AA -mt")
+    set(cxx_exception_flags "-DGTEST_HAS_EXCEPTIONS=1")
+    set(cxx_no_exception_flags "+noeh -DGTEST_HAS_EXCEPTIONS=0")
+    # RTTI can not be disabled in HP aCC compiler.
+    set(cxx_no_rtti_flags "")
+  endif()
+
+  if (CMAKE_USE_PTHREADS_INIT)  # The pthreads library is available and allowed.
+    set(cxx_base_flags "${cxx_base_flags} -DGTEST_HAS_PTHREAD=1")
+  else()
+    set(cxx_base_flags "${cxx_base_flags} -DGTEST_HAS_PTHREAD=0")
+  endif()
+
+  # For building gtest's own tests and samples.
+  set(cxx_exception "${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_exception_flags}")
+  set(cxx_no_exception
+    "${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_no_exception_flags}")
+  set(cxx_default "${cxx_exception}")
+  set(cxx_no_rtti "${cxx_default} ${cxx_no_rtti_flags}")
+  set(cxx_use_own_tuple "${cxx_default} -DGTEST_USE_OWN_TR1_TUPLE=1")
+
+  # For building the gtest libraries.
+  set(cxx_strict "${cxx_default} ${cxx_strict_flags}")
+endmacro()
+
+# Defines the gtest & gtest_main libraries.  User tests should link
+# with one of them.
+function(cxx_library_with_type name type cxx_flags)
+  # type can be either STATIC or SHARED to denote a static or shared library.
+  # ARGN refers to additional arguments after 'cxx_flags'.
+  add_library(${name} ${type} ${ARGN})
+  set_target_properties(${name}
+    PROPERTIES
+    COMPILE_FLAGS "${cxx_flags}")
+  if (BUILD_SHARED_LIBS OR type STREQUAL "SHARED")
+    set_target_properties(${name}
+      PROPERTIES
+      COMPILE_DEFINITIONS "GTEST_CREATE_SHARED_LIBRARY=1")
+  endif()
+  if (CMAKE_USE_PTHREADS_INIT)
+    target_link_libraries(${name} ${CMAKE_THREAD_LIBS_INIT})
+  endif()
+endfunction()
+
+########################################################################
+#
+# Helper functions for creating build targets.
+
+function(cxx_shared_library name cxx_flags)
+  cxx_library_with_type(${name} SHARED "${cxx_flags}" ${ARGN})
+endfunction()
+
+function(cxx_library name cxx_flags)
+  cxx_library_with_type(${name} "" "${cxx_flags}" ${ARGN})
+endfunction()
+
+# cxx_executable_with_flags(name cxx_flags libs srcs...)
+#
+# creates a named C++ executable that depends on the given libraries and
+# is built from the given source files with the given compiler flags.
+function(cxx_executable_with_flags name cxx_flags libs)
+  add_executable(${name} ${ARGN})
+  if (cxx_flags)
+    set_target_properties(${name}
+      PROPERTIES
+      COMPILE_FLAGS "${cxx_flags}")
+  endif()
+  if (BUILD_SHARED_LIBS)
+    set_target_properties(${name}
+      PROPERTIES
+      COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
+  endif()
+  # To support mixing linking in static and dynamic libraries, link each
+  # library in with an extra call to target_link_libraries.
+  foreach (lib "${libs}")
+    target_link_libraries(${name} ${lib})
+  endforeach()
+endfunction()
+
+# cxx_executable(name dir lib srcs...)
+#
+# creates a named target that depends on the given libs and is built
+# from the given source files.  dir/name.cc is implicitly included in
+# the source file list.
+function(cxx_executable name dir libs)
+  cxx_executable_with_flags(
+    ${name} "${cxx_default}" "${libs}" "${dir}/${name}.cc" ${ARGN})
+endfunction()
+
+# Sets PYTHONINTERP_FOUND and PYTHON_EXECUTABLE.
+find_package(PythonInterp)
+
+# cxx_test_with_flags(name cxx_flags libs srcs...)
+#
+# creates a named C++ test that depends on the given libs and is built
+# from the given source files with the given compiler flags.
+function(cxx_test_with_flags name cxx_flags libs)
+  cxx_executable_with_flags(${name} "${cxx_flags}" "${libs}" ${ARGN})
+  add_test(${name} ${name})
+endfunction()
+
+# cxx_test(name libs srcs...)
+#
+# creates a named test target that depends on the given libs and is
+# built from the given source files.  Unlike cxx_test_with_flags,
+# test/name.cc is already implicitly included in the source file list.
+function(cxx_test name libs)
+  cxx_test_with_flags("${name}" "${cxx_default}" "${libs}"
+    "test/${name}.cc" ${ARGN})
+endfunction()
+
+# py_test(name)
+#
+# creates a Python test with the given name whose main module is in
+# test/name.py.  It does nothing if Python is not installed.
+function(py_test name)
+  # We are not supporting Python tests on Linux yet as they consider
+  # all Linux environments to be google3 and try to use google3 features.
+  if (PYTHONINTERP_FOUND)
+    # ${CMAKE_BINARY_DIR} is known at configuration time, so we can
+    # directly bind it from cmake. ${CTEST_CONFIGURATION_TYPE} is known
+    # only at ctest runtime (by calling ctest -c <Configuration>), so
+    # we have to escape $ to delay variable substitution here.
+    if (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 3.1)
+      add_test(
+        NAME ${name}
+        COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
+            --build_dir=${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>)
+    else (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 3.1)
+      add_test(
+        ${name}
+        ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
+          --build_dir=${CMAKE_CURRENT_BINARY_DIR}/\${CTEST_CONFIGURATION_TYPE})
+    endif (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 3.1)
+  endif()
+endfunction()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.cbproj b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.cbproj
new file mode 100644
index 00000000..95c3054b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.cbproj
@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectGuid>{bca37a72-5b07-46cf-b44e-89f8e06451a2}</ProjectGuid>
+    <Config Condition="'$(Config)'==''">Release</Config>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''">
+    <Base>true</Base>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_1)'!=''">
+    <Base>true</Base>
+    <Cfg_1>true</Cfg_1>
+    <CfgParent>Base</CfgParent>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_2)'!=''">
+    <Base>true</Base>
+    <Cfg_2>true</Cfg_2>
+    <CfgParent>Base</CfgParent>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Base)'!=''">
+    <BCC_OptimizeForSpeed>true</BCC_OptimizeForSpeed>
+    <OutputExt>lib</OutputExt>
+    <DCC_CBuilderOutput>JPHNE</DCC_CBuilderOutput>
+    <Defines>NO_STRICT</Defines>
+    <DynamicRTL>true</DynamicRTL>
+    <UsePackages>true</UsePackages>
+    <ProjectType>CppStaticLibrary</ProjectType>
+    <BCC_CPPCompileAlways>true</BCC_CPPCompileAlways>
+    <PackageImports>rtl.bpi;vcl.bpi;bcbie.bpi;vclx.bpi;vclactnband.bpi;xmlrtl.bpi;bcbsmp.bpi;dbrtl.bpi;vcldb.bpi;bdertl.bpi;vcldbx.bpi;dsnap.bpi;dsnapcon.bpi;vclib.bpi;ibxpress.bpi;adortl.bpi;dbxcds.bpi;dbexpress.bpi;DbxCommonDriver.bpi;websnap.bpi;vclie.bpi;webdsnap.bpi;inet.bpi;inetdbbde.bpi;inetdbxpress.bpi;soaprtl.bpi;Rave75VCL.bpi;teeUI.bpi;tee.bpi;teedb.bpi;IndyCore.bpi;IndySystem.bpi;IndyProtocols.bpi;IntrawebDB_90_100.bpi;Intraweb_90_100.bpi;dclZipForged11.bpi;vclZipForged11.bpi;GR32_BDS2006.bpi;GR32_DSGN_BDS2006.bpi;Jcl.bpi;JclVcl.bpi;JvCoreD11R.bpi;JvSystemD11R.bpi;JvStdCtrlsD11R.bpi;JvAppFrmD11R.bpi;JvBandsD11R.bpi;JvDBD11R.bpi;JvDlgsD11R.bpi;JvBDED11R.bpi;JvCmpD11R.bpi;JvCryptD11R.bpi;JvCtrlsD11R.bpi;JvCustomD11R.bpi;JvDockingD11R.bpi;JvDotNetCtrlsD11R.bpi;JvEDID11R.bpi;JvGlobusD11R.bpi;JvHMID11R.bpi;JvInterpreterD11R.bpi;JvJansD11R.bpi;JvManagedThreadsD11R.bpi;JvMMD11R.bpi;JvNetD11R.bpi;JvPageCompsD11R.bpi;JvPluginD11R.bpi;JvPrintPreviewD11R.bpi;JvRuntimeDesignD11R.bpi;JvTimeFrameworkD11R.bpi;JvValidatorsD11R.bpi;JvWizardD11R.bpi;JvXPCtrlsD11R.bpi;VclSmp.bpi;CExceptionExpert11.bpi</PackageImports>
+    <BCC_wpar>false</BCC_wpar>
+    <IncludePath>$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</IncludePath>
+    <AllPackageLibs>rtl.lib;vcl.lib</AllPackageLibs>
+    <TLIB_PageSize>32</TLIB_PageSize>
+    <ILINK_LibraryPath>$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk</ILINK_LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Cfg_1)'!=''">
+    <BCC_OptimizeForSpeed>false</BCC_OptimizeForSpeed>
+    <DCC_Optimize>false</DCC_Optimize>
+    <DCC_DebugInfoInExe>true</DCC_DebugInfoInExe>
+    <Defines>_DEBUG;$(Defines)</Defines>
+    <ILINK_FullDebugInfo>true</ILINK_FullDebugInfo>
+    <BCC_InlineFunctionExpansion>false</BCC_InlineFunctionExpansion>
+    <ILINK_DisableIncrementalLinking>true</ILINK_DisableIncrementalLinking>
+    <BCC_UseRegisterVariables>None</BCC_UseRegisterVariables>
+    <DCC_Define>DEBUG</DCC_Define>
+    <BCC_DebugLineNumbers>true</BCC_DebugLineNumbers>
+    <IntermediateOutputDir>Debug</IntermediateOutputDir>
+    <TASM_DisplaySourceLines>true</TASM_DisplaySourceLines>
+    <BCC_StackFrames>true</BCC_StackFrames>
+    <BCC_DisableOptimizations>true</BCC_DisableOptimizations>
+    <ILINK_LibraryPath>$(BDS)\lib\debug;$(ILINK_LibraryPath)</ILINK_LibraryPath>
+    <TASM_Debugging>Full</TASM_Debugging>
+    <BCC_SourceDebuggingOn>true</BCC_SourceDebuggingOn>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Cfg_2)'!=''">
+    <Defines>NDEBUG;$(Defines)</Defines>
+    <IntermediateOutputDir>Release</IntermediateOutputDir>
+    <ILINK_LibraryPath>$(BDS)\lib\release;$(ILINK_LibraryPath)</ILINK_LibraryPath>
+    <TASM_Debugging>None</TASM_Debugging>
+  </PropertyGroup>
+  <ProjectExtensions>
+    <Borland.Personality>CPlusPlusBuilder.Personality</Borland.Personality>
+    <Borland.ProjectType>CppStaticLibrary</Borland.ProjectType>
+    <BorlandProject>
+<BorlandProject><CPlusPlusBuilder.Personality><VersionInfo><VersionInfo Name="IncludeVerInfo">False</VersionInfo><VersionInfo Name="AutoIncBuild">False</VersionInfo><VersionInfo Name="MajorVer">1</VersionInfo><VersionInfo Name="MinorVer">0</VersionInfo><VersionInfo Name="Release">0</VersionInfo><VersionInfo Name="Build">0</VersionInfo><VersionInfo Name="Debug">False</VersionInfo><VersionInfo Name="PreRelease">False</VersionInfo><VersionInfo Name="Special">False</VersionInfo><VersionInfo Name="Private">False</VersionInfo><VersionInfo Name="DLL">False</VersionInfo><VersionInfo Name="Locale">1033</VersionInfo><VersionInfo Name="CodePage">1252</VersionInfo></VersionInfo><VersionInfoKeys><VersionInfoKeys Name="CompanyName"></VersionInfoKeys><VersionInfoKeys Name="FileDescription"></VersionInfoKeys><VersionInfoKeys Name="FileVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="InternalName"></VersionInfoKeys><VersionInfoKeys Name="LegalCopyright"></VersionInfoKeys><VersionInfoKeys Name="LegalTrademarks"></VersionInfoKeys><VersionInfoKeys Name="OriginalFilename"></VersionInfoKeys><VersionInfoKeys Name="ProductName"></VersionInfoKeys><VersionInfoKeys Name="ProductVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="Comments"></VersionInfoKeys></VersionInfoKeys><Debugging><Debugging Name="DebugSourceDirs"></Debugging></Debugging><Parameters><Parameters Name="RunParams"></Parameters><Parameters Name="Launcher"></Parameters><Parameters Name="UseLauncher">False</Parameters><Parameters Name="DebugCWD"></Parameters><Parameters Name="HostApplication"></Parameters><Parameters Name="RemoteHost"></Parameters><Parameters Name="RemotePath"></Parameters><Parameters Name="RemoteParams"></Parameters><Parameters Name="RemoteLauncher"></Parameters><Parameters Name="UseRemoteLauncher">False</Parameters><Parameters Name="RemoteCWD"></Parameters><Parameters Name="RemoteDebug">False</Parameters><Parameters Name="Debug Symbols Search Path"></Parameters><Parameters Name="LoadAllSymbols">True</Parameters><Parameters Name="LoadUnspecifiedSymbols">False</Parameters></Parameters><Excluded_Packages>
+      
+      
+      <Excluded_Packages Name="$(BDS)\bin\bcboffice2k100.bpl">CodeGear C++Builder Office 2000 Servers Package</Excluded_Packages>
+      <Excluded_Packages Name="$(BDS)\bin\bcbofficexp100.bpl">CodeGear C++Builder Office XP Servers Package</Excluded_Packages>
+    </Excluded_Packages><Linker><Linker Name="LibPrefix"></Linker><Linker Name="LibSuffix"></Linker><Linker Name="LibVersion"></Linker></Linker><ProjectProperties><ProjectProperties Name="AutoShowDeps">False</ProjectProperties><ProjectProperties Name="ManagePaths">True</ProjectProperties><ProjectProperties Name="VerifyPackages">True</ProjectProperties></ProjectProperties><HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Count">3</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item0">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item1">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item2">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\src;..\include</HistoryLists_hlIncludePath></HistoryLists_hlIncludePath><HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Count">1</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item0">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk</HistoryLists_hlILINK_LibraryPath></HistoryLists_hlILINK_LibraryPath><HistoryLists_hlDefines><HistoryLists_hlDefines Name="Count">1</HistoryLists_hlDefines><HistoryLists_hlDefines Name="Item0">NO_STRICT</HistoryLists_hlDefines></HistoryLists_hlDefines><HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Count">1</HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Item0">32</HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Item1">16</HistoryLists_hlTLIB_PageSize></HistoryLists_hlTLIB_PageSize></CPlusPlusBuilder.Personality></BorlandProject></BorlandProject>
+  </ProjectExtensions>
+  <Import Project="$(MSBuildBinPath)\Borland.Cpp.Targets" />
+  <ItemGroup>
+    <None Include="..\include\gtest\gtest-death-test.h">
+      <BuildOrder>3</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\gtest-message.h">
+      <BuildOrder>4</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\gtest-param-test.h">
+      <BuildOrder>5</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\gtest-spi.h">
+      <BuildOrder>6</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\gtest-test-part.h">
+      <BuildOrder>7</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\gtest-typed-test.h">
+      <BuildOrder>8</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\gtest.h">
+      <BuildOrder>0</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\gtest_pred_impl.h">
+      <BuildOrder>1</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\gtest_prod.h">
+      <BuildOrder>2</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\internal\gtest-death-test-internal.h">
+      <BuildOrder>9</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\internal\gtest-filepath.h">
+      <BuildOrder>10</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\internal\gtest-internal.h">
+      <BuildOrder>11</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\internal\gtest-linked_ptr.h">
+      <BuildOrder>12</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\internal\gtest-param-util-generated.h">
+      <BuildOrder>14</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\internal\gtest-param-util.h">
+      <BuildOrder>13</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\internal\gtest-port.h">
+      <BuildOrder>15</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\internal\gtest-string.h">
+      <BuildOrder>16</BuildOrder>
+    </None>
+    <None Include="..\include\gtest\internal\gtest-type-util.h">
+      <BuildOrder>17</BuildOrder>
+    </None>
+    <CppCompile Include="gtest_all.cc">
+      <BuildOrder>18</BuildOrder>
+    </CppCompile>
+    <BuildConfiguration Include="Debug">
+      <Key>Cfg_1</Key>
+    </BuildConfiguration>
+    <BuildConfiguration Include="Release">
+      <Key>Cfg_2</Key>
+    </BuildConfiguration>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.groupproj b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.groupproj
new file mode 100644
index 00000000..faf31cab
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.groupproj
@@ -0,0 +1,54 @@
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectGuid>{c1d923e0-6cba-4332-9b6f-3420acbf5091}</ProjectGuid>
+  </PropertyGroup>
+  <ItemGroup />
+  <ItemGroup>
+    <Projects Include="gtest.cbproj" />
+    <Projects Include="gtest_main.cbproj" />
+    <Projects Include="gtest_unittest.cbproj" />
+  </ItemGroup>
+  <ProjectExtensions>
+    <Borland.Personality>Default.Personality</Borland.Personality>
+    <Borland.ProjectType />
+    <BorlandProject>
+<BorlandProject xmlns=""><Default.Personality></Default.Personality></BorlandProject></BorlandProject>
+  </ProjectExtensions>
+  <Target Name="gtest">
+    <MSBuild Projects="gtest.cbproj" Targets="" />
+  </Target>
+  <Target Name="gtest:Clean">
+    <MSBuild Projects="gtest.cbproj" Targets="Clean" />
+  </Target>
+  <Target Name="gtest:Make">
+    <MSBuild Projects="gtest.cbproj" Targets="Make" />
+  </Target>
+  <Target Name="gtest_main">
+    <MSBuild Projects="gtest_main.cbproj" Targets="" />
+  </Target>
+  <Target Name="gtest_main:Clean">
+    <MSBuild Projects="gtest_main.cbproj" Targets="Clean" />
+  </Target>
+  <Target Name="gtest_main:Make">
+    <MSBuild Projects="gtest_main.cbproj" Targets="Make" />
+  </Target>
+  <Target Name="gtest_unittest">
+    <MSBuild Projects="gtest_unittest.cbproj" Targets="" />
+  </Target>
+  <Target Name="gtest_unittest:Clean">
+    <MSBuild Projects="gtest_unittest.cbproj" Targets="Clean" />
+  </Target>
+  <Target Name="gtest_unittest:Make">
+    <MSBuild Projects="gtest_unittest.cbproj" Targets="Make" />
+  </Target>
+  <Target Name="Build">
+    <CallTarget Targets="gtest;gtest_main;gtest_unittest" />
+  </Target>
+  <Target Name="Clean">
+    <CallTarget Targets="gtest:Clean;gtest_main:Clean;gtest_unittest:Clean" />
+  </Target>
+  <Target Name="Make">
+    <CallTarget Targets="gtest:Make;gtest_main:Make;gtest_unittest:Make" />
+  </Target>
+  <Import Condition="Exists('$(MSBuildBinPath)\Borland.Group.Targets')" Project="$(MSBuildBinPath)\Borland.Group.Targets" />
+</Project>
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_all.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_all.cc
new file mode 100644
index 00000000..121b2d80
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_all.cc
@@ -0,0 +1,38 @@
+// Copyright 2009, 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.
+//
+// Author: Josh Kelley (joshkel@gmail.com)
+//
+// Google C++ Testing Framework (Google Test)
+//
+// C++Builder's IDE cannot build a static library from files with hyphens
+// in their name.  See http://qc.codegear.com/wc/qcmain.aspx?d=70977 .
+// This file serves as a workaround.
+
+#include "src/gtest-all.cc"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_link.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_link.cc
new file mode 100644
index 00000000..918eccd1
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_link.cc
@@ -0,0 +1,40 @@
+// Copyright 2009, 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.
+//
+// Author: Josh Kelley (joshkel@gmail.com)
+//
+// Google C++ Testing Framework (Google Test)
+//
+// Links gtest.lib and gtest_main.lib into the current project in C++Builder.
+// This means that these libraries can't be renamed, but it's the only way to
+// ensure that Debug versus Release test builds are linked against the
+// appropriate Debug or Release build of the libraries.
+
+#pragma link "gtest.lib"
+#pragma link "gtest_main.lib"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_main.cbproj b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_main.cbproj
new file mode 100644
index 00000000..d76ce139
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_main.cbproj
@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectGuid>{bca37a72-5b07-46cf-b44e-89f8e06451a2}</ProjectGuid>
+    <Config Condition="'$(Config)'==''">Release</Config>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''">
+    <Base>true</Base>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_1)'!=''">
+    <Base>true</Base>
+    <Cfg_1>true</Cfg_1>
+    <CfgParent>Base</CfgParent>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_2)'!=''">
+    <Base>true</Base>
+    <Cfg_2>true</Cfg_2>
+    <CfgParent>Base</CfgParent>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Base)'!=''">
+    <BCC_OptimizeForSpeed>true</BCC_OptimizeForSpeed>
+    <OutputExt>lib</OutputExt>
+    <DCC_CBuilderOutput>JPHNE</DCC_CBuilderOutput>
+    <Defines>NO_STRICT</Defines>
+    <DynamicRTL>true</DynamicRTL>
+    <UsePackages>true</UsePackages>
+    <ProjectType>CppStaticLibrary</ProjectType>
+    <BCC_CPPCompileAlways>true</BCC_CPPCompileAlways>
+    <PackageImports>rtl.bpi;vcl.bpi;bcbie.bpi;vclx.bpi;vclactnband.bpi;xmlrtl.bpi;bcbsmp.bpi;dbrtl.bpi;vcldb.bpi;bdertl.bpi;vcldbx.bpi;dsnap.bpi;dsnapcon.bpi;vclib.bpi;ibxpress.bpi;adortl.bpi;dbxcds.bpi;dbexpress.bpi;DbxCommonDriver.bpi;websnap.bpi;vclie.bpi;webdsnap.bpi;inet.bpi;inetdbbde.bpi;inetdbxpress.bpi;soaprtl.bpi;Rave75VCL.bpi;teeUI.bpi;tee.bpi;teedb.bpi;IndyCore.bpi;IndySystem.bpi;IndyProtocols.bpi;IntrawebDB_90_100.bpi;Intraweb_90_100.bpi;dclZipForged11.bpi;vclZipForged11.bpi;GR32_BDS2006.bpi;GR32_DSGN_BDS2006.bpi;Jcl.bpi;JclVcl.bpi;JvCoreD11R.bpi;JvSystemD11R.bpi;JvStdCtrlsD11R.bpi;JvAppFrmD11R.bpi;JvBandsD11R.bpi;JvDBD11R.bpi;JvDlgsD11R.bpi;JvBDED11R.bpi;JvCmpD11R.bpi;JvCryptD11R.bpi;JvCtrlsD11R.bpi;JvCustomD11R.bpi;JvDockingD11R.bpi;JvDotNetCtrlsD11R.bpi;JvEDID11R.bpi;JvGlobusD11R.bpi;JvHMID11R.bpi;JvInterpreterD11R.bpi;JvJansD11R.bpi;JvManagedThreadsD11R.bpi;JvMMD11R.bpi;JvNetD11R.bpi;JvPageCompsD11R.bpi;JvPluginD11R.bpi;JvPrintPreviewD11R.bpi;JvRuntimeDesignD11R.bpi;JvTimeFrameworkD11R.bpi;JvValidatorsD11R.bpi;JvWizardD11R.bpi;JvXPCtrlsD11R.bpi;VclSmp.bpi;CExceptionExpert11.bpi</PackageImports>
+    <BCC_wpar>false</BCC_wpar>
+    <IncludePath>$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</IncludePath>
+    <AllPackageLibs>rtl.lib;vcl.lib</AllPackageLibs>
+    <TLIB_PageSize>32</TLIB_PageSize>
+    <ILINK_LibraryPath>$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk</ILINK_LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Cfg_1)'!=''">
+    <BCC_OptimizeForSpeed>false</BCC_OptimizeForSpeed>
+    <DCC_Optimize>false</DCC_Optimize>
+    <DCC_DebugInfoInExe>true</DCC_DebugInfoInExe>
+    <Defines>_DEBUG;$(Defines)</Defines>
+    <ILINK_FullDebugInfo>true</ILINK_FullDebugInfo>
+    <BCC_InlineFunctionExpansion>false</BCC_InlineFunctionExpansion>
+    <ILINK_DisableIncrementalLinking>true</ILINK_DisableIncrementalLinking>
+    <BCC_UseRegisterVariables>None</BCC_UseRegisterVariables>
+    <DCC_Define>DEBUG</DCC_Define>
+    <BCC_DebugLineNumbers>true</BCC_DebugLineNumbers>
+    <IntermediateOutputDir>Debug</IntermediateOutputDir>
+    <TASM_DisplaySourceLines>true</TASM_DisplaySourceLines>
+    <BCC_StackFrames>true</BCC_StackFrames>
+    <BCC_DisableOptimizations>true</BCC_DisableOptimizations>
+    <ILINK_LibraryPath>$(BDS)\lib\debug;$(ILINK_LibraryPath)</ILINK_LibraryPath>
+    <TASM_Debugging>Full</TASM_Debugging>
+    <BCC_SourceDebuggingOn>true</BCC_SourceDebuggingOn>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Cfg_2)'!=''">
+    <Defines>NDEBUG;$(Defines)</Defines>
+    <IntermediateOutputDir>Release</IntermediateOutputDir>
+    <ILINK_LibraryPath>$(BDS)\lib\release;$(ILINK_LibraryPath)</ILINK_LibraryPath>
+    <TASM_Debugging>None</TASM_Debugging>
+  </PropertyGroup>
+  <ProjectExtensions>
+    <Borland.Personality>CPlusPlusBuilder.Personality</Borland.Personality>
+    <Borland.ProjectType>CppStaticLibrary</Borland.ProjectType>
+    <BorlandProject>
+<BorlandProject><CPlusPlusBuilder.Personality><VersionInfo><VersionInfo Name="IncludeVerInfo">False</VersionInfo><VersionInfo Name="AutoIncBuild">False</VersionInfo><VersionInfo Name="MajorVer">1</VersionInfo><VersionInfo Name="MinorVer">0</VersionInfo><VersionInfo Name="Release">0</VersionInfo><VersionInfo Name="Build">0</VersionInfo><VersionInfo Name="Debug">False</VersionInfo><VersionInfo Name="PreRelease">False</VersionInfo><VersionInfo Name="Special">False</VersionInfo><VersionInfo Name="Private">False</VersionInfo><VersionInfo Name="DLL">False</VersionInfo><VersionInfo Name="Locale">1033</VersionInfo><VersionInfo Name="CodePage">1252</VersionInfo></VersionInfo><VersionInfoKeys><VersionInfoKeys Name="CompanyName"></VersionInfoKeys><VersionInfoKeys Name="FileDescription"></VersionInfoKeys><VersionInfoKeys Name="FileVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="InternalName"></VersionInfoKeys><VersionInfoKeys Name="LegalCopyright"></VersionInfoKeys><VersionInfoKeys Name="LegalTrademarks"></VersionInfoKeys><VersionInfoKeys Name="OriginalFilename"></VersionInfoKeys><VersionInfoKeys Name="ProductName"></VersionInfoKeys><VersionInfoKeys Name="ProductVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="Comments"></VersionInfoKeys></VersionInfoKeys><Debugging><Debugging Name="DebugSourceDirs"></Debugging></Debugging><Parameters><Parameters Name="RunParams"></Parameters><Parameters Name="Launcher"></Parameters><Parameters Name="UseLauncher">False</Parameters><Parameters Name="DebugCWD"></Parameters><Parameters Name="HostApplication"></Parameters><Parameters Name="RemoteHost"></Parameters><Parameters Name="RemotePath"></Parameters><Parameters Name="RemoteParams"></Parameters><Parameters Name="RemoteLauncher"></Parameters><Parameters Name="UseRemoteLauncher">False</Parameters><Parameters Name="RemoteCWD"></Parameters><Parameters Name="RemoteDebug">False</Parameters><Parameters Name="Debug Symbols Search Path"></Parameters><Parameters Name="LoadAllSymbols">True</Parameters><Parameters Name="LoadUnspecifiedSymbols">False</Parameters></Parameters><Excluded_Packages>
+      <Excluded_Packages Name="$(BDS)\bin\bcboffice2k100.bpl">CodeGear C++Builder Office 2000 Servers Package</Excluded_Packages>
+      <Excluded_Packages Name="$(BDS)\bin\bcbofficexp100.bpl">CodeGear C++Builder Office XP Servers Package</Excluded_Packages>
+    </Excluded_Packages><Linker><Linker Name="LibPrefix"></Linker><Linker Name="LibSuffix"></Linker><Linker Name="LibVersion"></Linker></Linker><ProjectProperties><ProjectProperties Name="AutoShowDeps">False</ProjectProperties><ProjectProperties Name="ManagePaths">True</ProjectProperties><ProjectProperties Name="VerifyPackages">True</ProjectProperties></ProjectProperties><HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Count">3</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item0">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item1">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item2">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\src;..\include</HistoryLists_hlIncludePath></HistoryLists_hlIncludePath><HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Count">1</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item0">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk</HistoryLists_hlILINK_LibraryPath></HistoryLists_hlILINK_LibraryPath><HistoryLists_hlDefines><HistoryLists_hlDefines Name="Count">1</HistoryLists_hlDefines><HistoryLists_hlDefines Name="Item0">NO_STRICT</HistoryLists_hlDefines></HistoryLists_hlDefines><HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Count">1</HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Item0">32</HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Item1">16</HistoryLists_hlTLIB_PageSize></HistoryLists_hlTLIB_PageSize></CPlusPlusBuilder.Personality></BorlandProject></BorlandProject>
+  </ProjectExtensions>
+  <Import Project="$(MSBuildBinPath)\Borland.Cpp.Targets" />
+  <ItemGroup>
+    <CppCompile Include="..\src\gtest_main.cc">
+      <BuildOrder>0</BuildOrder>
+    </CppCompile>
+    <BuildConfiguration Include="Debug">
+      <Key>Cfg_1</Key>
+    </BuildConfiguration>
+    <BuildConfiguration Include="Release">
+      <Key>Cfg_2</Key>
+    </BuildConfiguration>
+  </ItemGroup>
+</Project>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_unittest.cbproj b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_unittest.cbproj
new file mode 100644
index 00000000..dc5db8e4
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_unittest.cbproj
@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectGuid>{eea63393-5ac5-4b9c-8909-d75fef2daa41}</ProjectGuid>
+    <Config Condition="'$(Config)'==''">Release</Config>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''">
+    <Base>true</Base>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_1)'!=''">
+    <Base>true</Base>
+    <Cfg_1>true</Cfg_1>
+    <CfgParent>Base</CfgParent>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_2)'!=''">
+    <Base>true</Base>
+    <Cfg_2>true</Cfg_2>
+    <CfgParent>Base</CfgParent>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Base)'!=''">
+    <OutputExt>exe</OutputExt>
+    <BCC_OptimizeForSpeed>true</BCC_OptimizeForSpeed>
+    <Defines>NO_STRICT</Defines>
+    <DCC_CBuilderOutput>JPHNE</DCC_CBuilderOutput>
+    <DynamicRTL>true</DynamicRTL>
+    <ILINK_ObjectSearchPath>..\test</ILINK_ObjectSearchPath>
+    <UsePackages>true</UsePackages>
+    <ProjectType>CppConsoleApplication</ProjectType>
+    <NoVCL>true</NoVCL>
+    <BCC_CPPCompileAlways>true</BCC_CPPCompileAlways>
+    <PackageImports>rtl.bpi;vcl.bpi;bcbie.bpi;vclx.bpi;vclactnband.bpi;xmlrtl.bpi;bcbsmp.bpi;dbrtl.bpi;vcldb.bpi;bdertl.bpi;vcldbx.bpi;dsnap.bpi;dsnapcon.bpi;vclib.bpi;ibxpress.bpi;adortl.bpi;dbxcds.bpi;dbexpress.bpi;DbxCommonDriver.bpi;websnap.bpi;vclie.bpi;webdsnap.bpi;inet.bpi;inetdbbde.bpi;inetdbxpress.bpi;soaprtl.bpi;Rave75VCL.bpi;teeUI.bpi;tee.bpi;teedb.bpi;IndyCore.bpi;IndySystem.bpi;IndyProtocols.bpi;IntrawebDB_90_100.bpi;Intraweb_90_100.bpi;Jcl.bpi;JclVcl.bpi;JvCoreD11R.bpi;JvSystemD11R.bpi;JvStdCtrlsD11R.bpi;JvAppFrmD11R.bpi;JvBandsD11R.bpi;JvDBD11R.bpi;JvDlgsD11R.bpi;JvBDED11R.bpi;JvCmpD11R.bpi;JvCryptD11R.bpi;JvCtrlsD11R.bpi;JvCustomD11R.bpi;JvDockingD11R.bpi;JvDotNetCtrlsD11R.bpi;JvEDID11R.bpi;JvGlobusD11R.bpi;JvHMID11R.bpi;JvInterpreterD11R.bpi;JvJansD11R.bpi;JvManagedThreadsD11R.bpi;JvMMD11R.bpi;JvNetD11R.bpi;JvPageCompsD11R.bpi;JvPluginD11R.bpi;JvPrintPreviewD11R.bpi;JvRuntimeDesignD11R.bpi;JvTimeFrameworkD11R.bpi;JvValidatorsD11R.bpi;JvWizardD11R.bpi;JvXPCtrlsD11R.bpi;VclSmp.bpi</PackageImports>
+    <BCC_wpar>false</BCC_wpar>
+    <IncludePath>$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\include;..\test;..</IncludePath>
+    <ILINK_LibraryPath>$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk;..\test</ILINK_LibraryPath>
+    <Multithreaded>true</Multithreaded>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Cfg_1)'!=''">
+    <BCC_OptimizeForSpeed>false</BCC_OptimizeForSpeed>
+    <DCC_Optimize>false</DCC_Optimize>
+    <DCC_DebugInfoInExe>true</DCC_DebugInfoInExe>
+    <Defines>_DEBUG;$(Defines)</Defines>
+    <ILINK_FullDebugInfo>true</ILINK_FullDebugInfo>
+    <BCC_InlineFunctionExpansion>false</BCC_InlineFunctionExpansion>
+    <ILINK_DisableIncrementalLinking>true</ILINK_DisableIncrementalLinking>
+    <BCC_UseRegisterVariables>None</BCC_UseRegisterVariables>
+    <DCC_Define>DEBUG</DCC_Define>
+    <BCC_DebugLineNumbers>true</BCC_DebugLineNumbers>
+    <IntermediateOutputDir>Debug</IntermediateOutputDir>
+    <TASM_DisplaySourceLines>true</TASM_DisplaySourceLines>
+    <BCC_StackFrames>true</BCC_StackFrames>
+    <BCC_DisableOptimizations>true</BCC_DisableOptimizations>
+    <ILINK_LibraryPath>$(BDS)\lib\debug;$(ILINK_LibraryPath)</ILINK_LibraryPath>
+    <TASM_Debugging>Full</TASM_Debugging>
+    <BCC_SourceDebuggingOn>true</BCC_SourceDebuggingOn>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Cfg_2)'!=''">
+    <Defines>NDEBUG;$(Defines)</Defines>
+    <IntermediateOutputDir>Release</IntermediateOutputDir>
+    <ILINK_LibraryPath>$(BDS)\lib\release;$(ILINK_LibraryPath)</ILINK_LibraryPath>
+    <TASM_Debugging>None</TASM_Debugging>
+  </PropertyGroup>
+  <ProjectExtensions>
+    <Borland.Personality>CPlusPlusBuilder.Personality</Borland.Personality>
+    <Borland.ProjectType>CppConsoleApplication</Borland.ProjectType>
+    <BorlandProject>
+<BorlandProject><CPlusPlusBuilder.Personality><VersionInfo><VersionInfo Name="IncludeVerInfo">False</VersionInfo><VersionInfo Name="AutoIncBuild">False</VersionInfo><VersionInfo Name="MajorVer">1</VersionInfo><VersionInfo Name="MinorVer">0</VersionInfo><VersionInfo Name="Release">0</VersionInfo><VersionInfo Name="Build">0</VersionInfo><VersionInfo Name="Debug">False</VersionInfo><VersionInfo Name="PreRelease">False</VersionInfo><VersionInfo Name="Special">False</VersionInfo><VersionInfo Name="Private">False</VersionInfo><VersionInfo Name="DLL">False</VersionInfo><VersionInfo Name="Locale">1033</VersionInfo><VersionInfo Name="CodePage">1252</VersionInfo></VersionInfo><VersionInfoKeys><VersionInfoKeys Name="CompanyName"></VersionInfoKeys><VersionInfoKeys Name="FileDescription"></VersionInfoKeys><VersionInfoKeys Name="FileVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="InternalName"></VersionInfoKeys><VersionInfoKeys Name="LegalCopyright"></VersionInfoKeys><VersionInfoKeys Name="LegalTrademarks"></VersionInfoKeys><VersionInfoKeys Name="OriginalFilename"></VersionInfoKeys><VersionInfoKeys Name="ProductName"></VersionInfoKeys><VersionInfoKeys Name="ProductVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="Comments"></VersionInfoKeys></VersionInfoKeys><Debugging><Debugging Name="DebugSourceDirs"></Debugging></Debugging><Parameters><Parameters Name="RunParams"></Parameters><Parameters Name="Launcher"></Parameters><Parameters Name="UseLauncher">False</Parameters><Parameters Name="DebugCWD"></Parameters><Parameters Name="HostApplication"></Parameters><Parameters Name="RemoteHost"></Parameters><Parameters Name="RemotePath"></Parameters><Parameters Name="RemoteParams"></Parameters><Parameters Name="RemoteLauncher"></Parameters><Parameters Name="UseRemoteLauncher">False</Parameters><Parameters Name="RemoteCWD"></Parameters><Parameters Name="RemoteDebug">False</Parameters><Parameters Name="Debug Symbols Search Path"></Parameters><Parameters Name="LoadAllSymbols">True</Parameters><Parameters Name="LoadUnspecifiedSymbols">False</Parameters></Parameters><Excluded_Packages>
+      
+      
+      <Excluded_Packages Name="$(BDS)\bin\bcboffice2k100.bpl">CodeGear C++Builder Office 2000 Servers Package</Excluded_Packages>
+      <Excluded_Packages Name="$(BDS)\bin\bcbofficexp100.bpl">CodeGear C++Builder Office XP Servers Package</Excluded_Packages>
+    </Excluded_Packages><Linker><Linker Name="LibPrefix"></Linker><Linker Name="LibSuffix"></Linker><Linker Name="LibVersion"></Linker></Linker><ProjectProperties><ProjectProperties Name="AutoShowDeps">False</ProjectProperties><ProjectProperties Name="ManagePaths">True</ProjectProperties><ProjectProperties Name="VerifyPackages">True</ProjectProperties></ProjectProperties><HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Count">3</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item0">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\include;..\test;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item1">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\include;..\test</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item2">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\include</HistoryLists_hlIncludePath></HistoryLists_hlIncludePath><HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Count">1</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item0">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk;..\test</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item1">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk;..\test</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item2">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk;$(OUTPUTDIR);..\test</HistoryLists_hlILINK_LibraryPath></HistoryLists_hlILINK_LibraryPath><HistoryLists_hlDefines><HistoryLists_hlDefines Name="Count">2</HistoryLists_hlDefines><HistoryLists_hlDefines Name="Item0">NO_STRICT</HistoryLists_hlDefines><HistoryLists_hlDefines Name="Item1">STRICT</HistoryLists_hlDefines></HistoryLists_hlDefines></CPlusPlusBuilder.Personality></BorlandProject></BorlandProject>
+  </ProjectExtensions>
+  <Import Project="$(MSBuildBinPath)\Borland.Cpp.Targets" />
+  <ItemGroup>
+    <CppCompile Include="..\test\gtest_unittest.cc">
+      <BuildOrder>0</BuildOrder>
+    </CppCompile>
+    <CppCompile Include="gtest_link.cc">
+      <BuildOrder>1</BuildOrder>
+    </CppCompile>
+    <BuildConfiguration Include="Debug">
+      <Key>Cfg_1</Key>
+    </BuildConfiguration>
+    <BuildConfiguration Include="Release">
+      <Key>Cfg_2</Key>
+    </BuildConfiguration>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/configure.ac b/week4/softwareEng_9_4/vendor/googletest/googletest/configure.ac
new file mode 100644
index 00000000..cc592e15
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/configure.ac
@@ -0,0 +1,68 @@
+m4_include(m4/acx_pthread.m4)
+
+# At this point, the Xcode project assumes the version string will be three
+# integers separated by periods and surrounded by square brackets (e.g.
+# "[1.0.1]"). It also asumes that there won't be any closing parenthesis
+# between "AC_INIT(" and the closing ")" including comments and strings.
+AC_INIT([Google C++ Testing Framework],
+        [1.7.0],
+        [googletestframework@googlegroups.com],
+        [gtest])
+
+# Provide various options to initialize the Autoconf and configure processes.
+AC_PREREQ([2.59])
+AC_CONFIG_SRCDIR([./LICENSE])
+AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_AUX_DIR([build-aux])
+AC_CONFIG_HEADERS([build-aux/config.h])
+AC_CONFIG_FILES([Makefile])
+AC_CONFIG_FILES([scripts/gtest-config], [chmod +x scripts/gtest-config])
+
+# Initialize Automake with various options. We require at least v1.9, prevent
+# pedantic complaints about package files, and enable various distribution
+# targets.
+AM_INIT_AUTOMAKE([1.9 dist-bzip2 dist-zip foreign subdir-objects])
+
+# Check for programs used in building Google Test.
+AC_PROG_CC
+AC_PROG_CXX
+AC_LANG([C++])
+AC_PROG_LIBTOOL
+
+# TODO(chandlerc@google.com): Currently we aren't running the Python tests
+# against the interpreter detected by AM_PATH_PYTHON, and so we condition
+# HAVE_PYTHON by requiring "python" to be in the PATH, and that interpreter's
+# version to be >= 2.3. This will allow the scripts to use a "/usr/bin/env"
+# hashbang.
+PYTHON=  # We *do not* allow the user to specify a python interpreter
+AC_PATH_PROG([PYTHON],[python],[:])
+AS_IF([test "$PYTHON" != ":"],
+      [AM_PYTHON_CHECK_VERSION([$PYTHON],[2.3],[:],[PYTHON=":"])])
+AM_CONDITIONAL([HAVE_PYTHON],[test "$PYTHON" != ":"])
+
+# Configure pthreads.
+AC_ARG_WITH([pthreads],
+            [AS_HELP_STRING([--with-pthreads],
+               [use pthreads (default is yes)])],
+            [with_pthreads=$withval],
+            [with_pthreads=check])
+
+have_pthreads=no
+AS_IF([test "x$with_pthreads" != "xno"],
+      [ACX_PTHREAD(
+        [],
+        [AS_IF([test "x$with_pthreads" != "xcheck"],
+               [AC_MSG_FAILURE(
+                 [--with-pthreads was specified, but unable to be used])])])
+       have_pthreads="$acx_pthread_ok"])
+AM_CONDITIONAL([HAVE_PTHREADS],[test "x$have_pthreads" = "xyes"])
+AC_SUBST(PTHREAD_CFLAGS)
+AC_SUBST(PTHREAD_LIBS)
+
+# TODO(chandlerc@google.com) Check for the necessary system headers.
+
+# TODO(chandlerc@google.com) Check the types, structures, and other compiler
+# and architecture characteristics.
+
+# Output the generated files. No further autoconf macros may be used.
+AC_OUTPUT
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/AdvancedGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/AdvancedGuide.md
new file mode 100644
index 00000000..93a65200
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/AdvancedGuide.md
@@ -0,0 +1,2182 @@
+
+
+Now that you have read [Primer](Primer.md) and learned how to write tests
+using Google Test, it's time to learn some new tricks. This document
+will show you more assertions as well as how to construct complex
+failure messages, propagate fatal failures, reuse and speed up your
+test fixtures, and use various flags with your tests.
+
+# More Assertions #
+
+This section covers some less frequently used, but still significant,
+assertions.
+
+## Explicit Success and Failure ##
+
+These three assertions do not actually test a value or expression. Instead,
+they generate a success or failure directly. Like the macros that actually
+perform a test, you may stream a custom failure message into the them.
+
+| `SUCCEED();` |
+|:-------------|
+
+Generates a success. This does NOT make the overall test succeed. A test is
+considered successful only if none of its assertions fail during its execution.
+
+Note: `SUCCEED()` is purely documentary and currently doesn't generate any
+user-visible output. However, we may add `SUCCEED()` messages to Google Test's
+output in the future.
+
+| `FAIL();`  | `ADD_FAILURE();` | `ADD_FAILURE_AT("`_file\_path_`", `_line\_number_`);` |
+|:-----------|:-----------------|:------------------------------------------------------|
+
+`FAIL()` generates a fatal failure, while `ADD_FAILURE()` and `ADD_FAILURE_AT()` generate a nonfatal
+failure. These are useful when control flow, rather than a Boolean expression,
+deteremines the test's success or failure. For example, you might want to write
+something like:
+
+```
+switch(expression) {
+  case 1: ... some checks ...
+  case 2: ... some other checks
+  ...
+  default: FAIL() << "We shouldn't get here.";
+}
+```
+
+Note: you can only use `FAIL()` in functions that return `void`. See the [Assertion Placement section](#assertion-placement) for more information.
+
+_Availability_: Linux, Windows, Mac.
+
+## Exception Assertions ##
+
+These are for verifying that a piece of code throws (or does not
+throw) an exception of the given type:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_THROW(`_statement_, _exception\_type_`);`  | `EXPECT_THROW(`_statement_, _exception\_type_`);`  | _statement_ throws an exception of the given type  |
+| `ASSERT_ANY_THROW(`_statement_`);`                | `EXPECT_ANY_THROW(`_statement_`);`                | _statement_ throws an exception of any type        |
+| `ASSERT_NO_THROW(`_statement_`);`                 | `EXPECT_NO_THROW(`_statement_`);`                 | _statement_ doesn't throw any exception            |
+
+Examples:
+
+```
+ASSERT_THROW(Foo(5), bar_exception);
+
+EXPECT_NO_THROW({
+  int n = 5;
+  Bar(&n);
+});
+```
+
+_Availability_: Linux, Windows, Mac; since version 1.1.0.
+
+## Predicate Assertions for Better Error Messages ##
+
+Even though Google Test has a rich set of assertions, they can never be
+complete, as it's impossible (nor a good idea) to anticipate all the scenarios
+a user might run into. Therefore, sometimes a user has to use `EXPECT_TRUE()`
+to check a complex expression, for lack of a better macro. This has the problem
+of not showing you the values of the parts of the expression, making it hard to
+understand what went wrong. As a workaround, some users choose to construct the
+failure message by themselves, streaming it into `EXPECT_TRUE()`. However, this
+is awkward especially when the expression has side-effects or is expensive to
+evaluate.
+
+Google Test gives you three different options to solve this problem:
+
+### Using an Existing Boolean Function ###
+
+If you already have a function or a functor that returns `bool` (or a type
+that can be implicitly converted to `bool`), you can use it in a _predicate
+assertion_ to get the function arguments printed for free:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_PRED1(`_pred1, val1_`);`       | `EXPECT_PRED1(`_pred1, val1_`);` | _pred1(val1)_ returns true |
+| `ASSERT_PRED2(`_pred2, val1, val2_`);` | `EXPECT_PRED2(`_pred2, val1, val2_`);` |  _pred2(val1, val2)_ returns true |
+|  ...                | ...                    | ...          |
+
+In the above, _predn_ is an _n_-ary predicate function or functor, where
+_val1_, _val2_, ..., and _valn_ are its arguments. The assertion succeeds
+if the predicate returns `true` when applied to the given arguments, and fails
+otherwise. When the assertion fails, it prints the value of each argument. In
+either case, the arguments are evaluated exactly once.
+
+Here's an example. Given
+
+```
+// Returns true iff m and n have no common divisors except 1.
+bool MutuallyPrime(int m, int n) { ... }
+const int a = 3;
+const int b = 4;
+const int c = 10;
+```
+
+the assertion `EXPECT_PRED2(MutuallyPrime, a, b);` will succeed, while the
+assertion `EXPECT_PRED2(MutuallyPrime, b, c);` will fail with the message
+
+<pre>
+!MutuallyPrime(b, c) is false, where<br>
+b is 4<br>
+c is 10<br>
+</pre>
+
+**Notes:**
+
+  1. If you see a compiler error "no matching function to call" when using `ASSERT_PRED*` or `EXPECT_PRED*`, please see [this FAQ](FAQ.md#the-compiler-complains-no-matching-function-to-call-when-i-use-assert_predn-how-do-i-fix-it) for how to resolve it.
+  1. Currently we only provide predicate assertions of arity <= 5. If you need a higher-arity assertion, let us know.
+
+_Availability_: Linux, Windows, Mac
+
+### Using a Function That Returns an AssertionResult ###
+
+While `EXPECT_PRED*()` and friends are handy for a quick job, the
+syntax is not satisfactory: you have to use different macros for
+different arities, and it feels more like Lisp than C++.  The
+`::testing::AssertionResult` class solves this problem.
+
+An `AssertionResult` object represents the result of an assertion
+(whether it's a success or a failure, and an associated message).  You
+can create an `AssertionResult` using one of these factory
+functions:
+
+```
+namespace testing {
+
+// Returns an AssertionResult object to indicate that an assertion has
+// succeeded.
+AssertionResult AssertionSuccess();
+
+// Returns an AssertionResult object to indicate that an assertion has
+// failed.
+AssertionResult AssertionFailure();
+
+}
+```
+
+You can then use the `<<` operator to stream messages to the
+`AssertionResult` object.
+
+To provide more readable messages in Boolean assertions
+(e.g. `EXPECT_TRUE()`), write a predicate function that returns
+`AssertionResult` instead of `bool`. For example, if you define
+`IsEven()` as:
+
+```
+::testing::AssertionResult IsEven(int n) {
+  if ((n % 2) == 0)
+    return ::testing::AssertionSuccess();
+  else
+    return ::testing::AssertionFailure() << n << " is odd";
+}
+```
+
+instead of:
+
+```
+bool IsEven(int n) {
+  return (n % 2) == 0;
+}
+```
+
+the failed assertion `EXPECT_TRUE(IsEven(Fib(4)))` will print:
+
+<pre>
+Value of: IsEven(Fib(4))<br>
+Actual: false (*3 is odd*)<br>
+Expected: true<br>
+</pre>
+
+instead of a more opaque
+
+<pre>
+Value of: IsEven(Fib(4))<br>
+Actual: false<br>
+Expected: true<br>
+</pre>
+
+If you want informative messages in `EXPECT_FALSE` and `ASSERT_FALSE`
+as well, and are fine with making the predicate slower in the success
+case, you can supply a success message:
+
+```
+::testing::AssertionResult IsEven(int n) {
+  if ((n % 2) == 0)
+    return ::testing::AssertionSuccess() << n << " is even";
+  else
+    return ::testing::AssertionFailure() << n << " is odd";
+}
+```
+
+Then the statement `EXPECT_FALSE(IsEven(Fib(6)))` will print
+
+<pre>
+Value of: IsEven(Fib(6))<br>
+Actual: true (8 is even)<br>
+Expected: false<br>
+</pre>
+
+_Availability_: Linux, Windows, Mac; since version 1.4.1.
+
+### Using a Predicate-Formatter ###
+
+If you find the default message generated by `(ASSERT|EXPECT)_PRED*` and
+`(ASSERT|EXPECT)_(TRUE|FALSE)` unsatisfactory, or some arguments to your
+predicate do not support streaming to `ostream`, you can instead use the
+following _predicate-formatter assertions_ to _fully_ customize how the
+message is formatted:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_PRED_FORMAT1(`_pred\_format1, val1_`);`        | `EXPECT_PRED_FORMAT1(`_pred\_format1, val1_`);` | _pred\_format1(val1)_ is successful |
+| `ASSERT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | `EXPECT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | _pred\_format2(val1, val2)_ is successful |
+| `...`               | `...`                  | `...`        |
+
+The difference between this and the previous two groups of macros is that instead of
+a predicate, `(ASSERT|EXPECT)_PRED_FORMAT*` take a _predicate-formatter_
+(_pred\_formatn_), which is a function or functor with the signature:
+
+`::testing::AssertionResult PredicateFormattern(const char* `_expr1_`, const char* `_expr2_`, ... const char* `_exprn_`, T1 `_val1_`, T2 `_val2_`, ... Tn `_valn_`);`
+
+where _val1_, _val2_, ..., and _valn_ are the values of the predicate
+arguments, and _expr1_, _expr2_, ..., and _exprn_ are the corresponding
+expressions as they appear in the source code. The types `T1`, `T2`, ..., and
+`Tn` can be either value types or reference types. For example, if an
+argument has type `Foo`, you can declare it as either `Foo` or `const Foo&`,
+whichever is appropriate.
+
+A predicate-formatter returns a `::testing::AssertionResult` object to indicate
+whether the assertion has succeeded or not. The only way to create such an
+object is to call one of these factory functions:
+
+As an example, let's improve the failure message in the previous example, which uses `EXPECT_PRED2()`:
+
+```
+// Returns the smallest prime common divisor of m and n,
+// or 1 when m and n are mutually prime.
+int SmallestPrimeCommonDivisor(int m, int n) { ... }
+
+// A predicate-formatter for asserting that two integers are mutually prime.
+::testing::AssertionResult AssertMutuallyPrime(const char* m_expr,
+                                               const char* n_expr,
+                                               int m,
+                                               int n) {
+  if (MutuallyPrime(m, n))
+    return ::testing::AssertionSuccess();
+
+  return ::testing::AssertionFailure()
+      << m_expr << " and " << n_expr << " (" << m << " and " << n
+      << ") are not mutually prime, " << "as they have a common divisor "
+      << SmallestPrimeCommonDivisor(m, n);
+}
+```
+
+With this predicate-formatter, we can use
+
+```
+EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c);
+```
+
+to generate the message
+
+<pre>
+b and c (4 and 10) are not mutually prime, as they have a common divisor 2.<br>
+</pre>
+
+As you may have realized, many of the assertions we introduced earlier are
+special cases of `(EXPECT|ASSERT)_PRED_FORMAT*`. In fact, most of them are
+indeed defined using `(EXPECT|ASSERT)_PRED_FORMAT*`.
+
+_Availability_: Linux, Windows, Mac.
+
+
+## Floating-Point Comparison ##
+
+Comparing floating-point numbers is tricky. Due to round-off errors, it is
+very unlikely that two floating-points will match exactly. Therefore,
+`ASSERT_EQ` 's naive comparison usually doesn't work. And since floating-points
+can have a wide value range, no single fixed error bound works. It's better to
+compare by a fixed relative error bound, except for values close to 0 due to
+the loss of precision there.
+
+In general, for floating-point comparison to make sense, the user needs to
+carefully choose the error bound. If they don't want or care to, comparing in
+terms of Units in the Last Place (ULPs) is a good default, and Google Test
+provides assertions to do this. Full details about ULPs are quite long; if you
+want to learn more, see
+[this article on float comparison](http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm).
+
+### Floating-Point Macros ###
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_FLOAT_EQ(`_val1, val2_`);`  | `EXPECT_FLOAT_EQ(`_val1, val2_`);` | the two `float` values are almost equal |
+| `ASSERT_DOUBLE_EQ(`_val1, val2_`);` | `EXPECT_DOUBLE_EQ(`_val1, val2_`);` | the two `double` values are almost equal |
+
+By "almost equal", we mean the two values are within 4 ULP's from each
+other.
+
+The following assertions allow you to choose the acceptable error bound:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_NEAR(`_val1, val2, abs\_error_`);` | `EXPECT_NEAR`_(val1, val2, abs\_error_`);` | the difference between _val1_ and _val2_ doesn't exceed the given absolute error |
+
+_Availability_: Linux, Windows, Mac.
+
+### Floating-Point Predicate-Format Functions ###
+
+Some floating-point operations are useful, but not that often used. In order
+to avoid an explosion of new macros, we provide them as predicate-format
+functions that can be used in predicate assertion macros (e.g.
+`EXPECT_PRED_FORMAT2`, etc).
+
+```
+EXPECT_PRED_FORMAT2(::testing::FloatLE, val1, val2);
+EXPECT_PRED_FORMAT2(::testing::DoubleLE, val1, val2);
+```
+
+Verifies that _val1_ is less than, or almost equal to, _val2_. You can
+replace `EXPECT_PRED_FORMAT2` in the above table with `ASSERT_PRED_FORMAT2`.
+
+_Availability_: Linux, Windows, Mac.
+
+## Windows HRESULT assertions ##
+
+These assertions test for `HRESULT` success or failure.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_HRESULT_SUCCEEDED(`_expression_`);` | `EXPECT_HRESULT_SUCCEEDED(`_expression_`);` | _expression_ is a success `HRESULT` |
+| `ASSERT_HRESULT_FAILED(`_expression_`);`    | `EXPECT_HRESULT_FAILED(`_expression_`);`    | _expression_ is a failure `HRESULT` |
+
+The generated output contains the human-readable error message
+associated with the `HRESULT` code returned by _expression_.
+
+You might use them like this:
+
+```
+CComPtr shell;
+ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application"));
+CComVariant empty;
+ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty));
+```
+
+_Availability_: Windows.
+
+## Type Assertions ##
+
+You can call the function
+```
+::testing::StaticAssertTypeEq<T1, T2>();
+```
+to assert that types `T1` and `T2` are the same.  The function does
+nothing if the assertion is satisfied.  If the types are different,
+the function call will fail to compile, and the compiler error message
+will likely (depending on the compiler) show you the actual values of
+`T1` and `T2`.  This is mainly useful inside template code.
+
+_Caveat:_ When used inside a member function of a class template or a
+function template, `StaticAssertTypeEq<T1, T2>()` is effective _only if_
+the function is instantiated.  For example, given:
+```
+template <typename T> class Foo {
+ public:
+  void Bar() { ::testing::StaticAssertTypeEq<int, T>(); }
+};
+```
+the code:
+```
+void Test1() { Foo<bool> foo; }
+```
+will _not_ generate a compiler error, as `Foo<bool>::Bar()` is never
+actually instantiated.  Instead, you need:
+```
+void Test2() { Foo<bool> foo; foo.Bar(); }
+```
+to cause a compiler error.
+
+_Availability:_ Linux, Windows, Mac; since version 1.3.0.
+
+## Assertion Placement ##
+
+You can use assertions in any C++ function. In particular, it doesn't
+have to be a method of the test fixture class. The one constraint is
+that assertions that generate a fatal failure (`FAIL*` and `ASSERT_*`)
+can only be used in void-returning functions. This is a consequence of
+Google Test not using exceptions. By placing it in a non-void function
+you'll get a confusing compile error like
+`"error: void value not ignored as it ought to be"`.
+
+If you need to use assertions in a function that returns non-void, one option
+is to make the function return the value in an out parameter instead. For
+example, you can rewrite `T2 Foo(T1 x)` to `void Foo(T1 x, T2* result)`. You
+need to make sure that `*result` contains some sensible value even when the
+function returns prematurely. As the function now returns `void`, you can use
+any assertion inside of it.
+
+If changing the function's type is not an option, you should just use
+assertions that generate non-fatal failures, such as `ADD_FAILURE*` and
+`EXPECT_*`.
+
+_Note_: Constructors and destructors are not considered void-returning
+functions, according to the C++ language specification, and so you may not use
+fatal assertions in them. You'll get a compilation error if you try. A simple
+workaround is to transfer the entire body of the constructor or destructor to a
+private void-returning method. However, you should be aware that a fatal
+assertion failure in a constructor does not terminate the current test, as your
+intuition might suggest; it merely returns from the constructor early, possibly
+leaving your object in a partially-constructed state. Likewise, a fatal
+assertion failure in a destructor may leave your object in a
+partially-destructed state. Use assertions carefully in these situations!
+
+# Teaching Google Test How to Print Your Values #
+
+When a test assertion such as `EXPECT_EQ` fails, Google Test prints the
+argument values to help you debug.  It does this using a
+user-extensible value printer.
+
+This printer knows how to print built-in C++ types, native arrays, STL
+containers, and any type that supports the `<<` operator.  For other
+types, it prints the raw bytes in the value and hopes that you the
+user can figure it out.
+
+As mentioned earlier, the printer is _extensible_.  That means
+you can teach it to do a better job at printing your particular type
+than to dump the bytes.  To do that, define `<<` for your type:
+
+```
+#include <iostream>
+
+namespace foo {
+
+class Bar { ... };  // We want Google Test to be able to print instances of this.
+
+// It's important that the << operator is defined in the SAME
+// namespace that defines Bar.  C++'s look-up rules rely on that.
+::std::ostream& operator<<(::std::ostream& os, const Bar& bar) {
+  return os << bar.DebugString();  // whatever needed to print bar to os
+}
+
+}  // namespace foo
+```
+
+Sometimes, this might not be an option: your team may consider it bad
+style to have a `<<` operator for `Bar`, or `Bar` may already have a
+`<<` operator that doesn't do what you want (and you cannot change
+it).  If so, you can instead define a `PrintTo()` function like this:
+
+```
+#include <iostream>
+
+namespace foo {
+
+class Bar { ... };
+
+// It's important that PrintTo() is defined in the SAME
+// namespace that defines Bar.  C++'s look-up rules rely on that.
+void PrintTo(const Bar& bar, ::std::ostream* os) {
+  *os << bar.DebugString();  // whatever needed to print bar to os
+}
+
+}  // namespace foo
+```
+
+If you have defined both `<<` and `PrintTo()`, the latter will be used
+when Google Test is concerned.  This allows you to customize how the value
+appears in Google Test's output without affecting code that relies on the
+behavior of its `<<` operator.
+
+If you want to print a value `x` using Google Test's value printer
+yourself, just call `::testing::PrintToString(`_x_`)`, which
+returns an `std::string`:
+
+```
+vector<pair<Bar, int> > bar_ints = GetBarIntVector();
+
+EXPECT_TRUE(IsCorrectBarIntVector(bar_ints))
+    << "bar_ints = " << ::testing::PrintToString(bar_ints);
+```
+
+# Death Tests #
+
+In many applications, there are assertions that can cause application failure
+if a condition is not met. These sanity checks, which ensure that the program
+is in a known good state, are there to fail at the earliest possible time after
+some program state is corrupted. If the assertion checks the wrong condition,
+then the program may proceed in an erroneous state, which could lead to memory
+corruption, security holes, or worse. Hence it is vitally important to test
+that such assertion statements work as expected.
+
+Since these precondition checks cause the processes to die, we call such tests
+_death tests_. More generally, any test that checks that a program terminates
+(except by throwing an exception) in an expected fashion is also a death test.
+
+Note that if a piece of code throws an exception, we don't consider it "death"
+for the purpose of death tests, as the caller of the code could catch the exception
+and avoid the crash. If you want to verify exceptions thrown by your code,
+see [Exception Assertions](#exception-assertions).
+
+If you want to test `EXPECT_*()/ASSERT_*()` failures in your test code, see [Catching Failures](#catching-failures).
+
+## How to Write a Death Test ##
+
+Google Test has the following macros to support death tests:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_DEATH(`_statement, regex_`);` | `EXPECT_DEATH(`_statement, regex_`);` | _statement_ crashes with the given error |
+| `ASSERT_DEATH_IF_SUPPORTED(`_statement, regex_`);` | `EXPECT_DEATH_IF_SUPPORTED(`_statement, regex_`);` | if death tests are supported, verifies that _statement_ crashes with the given error; otherwise verifies nothing |
+| `ASSERT_EXIT(`_statement, predicate, regex_`);` | `EXPECT_EXIT(`_statement, predicate, regex_`);` |_statement_ exits with the given error and its exit code matches _predicate_ |
+
+where _statement_ is a statement that is expected to cause the process to
+die, _predicate_ is a function or function object that evaluates an integer
+exit status, and _regex_ is a regular expression that the stderr output of
+_statement_ is expected to match. Note that _statement_ can be _any valid
+statement_ (including _compound statement_) and doesn't have to be an
+expression.
+
+As usual, the `ASSERT` variants abort the current test function, while the
+`EXPECT` variants do not.
+
+**Note:** We use the word "crash" here to mean that the process
+terminates with a _non-zero_ exit status code.  There are two
+possibilities: either the process has called `exit()` or `_exit()`
+with a non-zero value, or it may be killed by a signal.
+
+This means that if _statement_ terminates the process with a 0 exit
+code, it is _not_ considered a crash by `EXPECT_DEATH`.  Use
+`EXPECT_EXIT` instead if this is the case, or if you want to restrict
+the exit code more precisely.
+
+A predicate here must accept an `int` and return a `bool`. The death test
+succeeds only if the predicate returns `true`. Google Test defines a few
+predicates that handle the most common cases:
+
+```
+::testing::ExitedWithCode(exit_code)
+```
+
+This expression is `true` if the program exited normally with the given exit
+code.
+
+```
+::testing::KilledBySignal(signal_number)  // Not available on Windows.
+```
+
+This expression is `true` if the program was killed by the given signal.
+
+The `*_DEATH` macros are convenient wrappers for `*_EXIT` that use a predicate
+that verifies the process' exit code is non-zero.
+
+Note that a death test only cares about three things:
+
+  1. does _statement_ abort or exit the process?
+  1. (in the case of `ASSERT_EXIT` and `EXPECT_EXIT`) does the exit status satisfy _predicate_?  Or (in the case of `ASSERT_DEATH` and `EXPECT_DEATH`) is the exit status non-zero?  And
+  1. does the stderr output match _regex_?
+
+In particular, if _statement_ generates an `ASSERT_*` or `EXPECT_*` failure, it will **not** cause the death test to fail, as Google Test assertions don't abort the process.
+
+To write a death test, simply use one of the above macros inside your test
+function. For example,
+
+```
+TEST(MyDeathTest, Foo) {
+  // This death test uses a compound statement.
+  ASSERT_DEATH({ int n = 5; Foo(&n); }, "Error on line .* of Foo()");
+}
+TEST(MyDeathTest, NormalExit) {
+  EXPECT_EXIT(NormalExit(), ::testing::ExitedWithCode(0), "Success");
+}
+TEST(MyDeathTest, KillMyself) {
+  EXPECT_EXIT(KillMyself(), ::testing::KilledBySignal(SIGKILL), "Sending myself unblockable signal");
+}
+```
+
+verifies that:
+
+  * calling `Foo(5)` causes the process to die with the given error message,
+  * calling `NormalExit()` causes the process to print `"Success"` to stderr and exit with exit code 0, and
+  * calling `KillMyself()` kills the process with signal `SIGKILL`.
+
+The test function body may contain other assertions and statements as well, if
+necessary.
+
+_Important:_ We strongly recommend you to follow the convention of naming your
+test case (not test) `*DeathTest` when it contains a death test, as
+demonstrated in the above example. The `Death Tests And Threads` section below
+explains why.
+
+If a test fixture class is shared by normal tests and death tests, you
+can use typedef to introduce an alias for the fixture class and avoid
+duplicating its code:
+```
+class FooTest : public ::testing::Test { ... };
+
+typedef FooTest FooDeathTest;
+
+TEST_F(FooTest, DoesThis) {
+  // normal test
+}
+
+TEST_F(FooDeathTest, DoesThat) {
+  // death test
+}
+```
+
+_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Cygwin, and Mac (the latter three are supported since v1.3.0).  `(ASSERT|EXPECT)_DEATH_IF_SUPPORTED` are new in v1.4.0.
+
+## Regular Expression Syntax ##
+
+On POSIX systems (e.g. Linux, Cygwin, and Mac), Google Test uses the
+[POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
+syntax in death tests. To learn about this syntax, you may want to read this [Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
+
+On Windows, Google Test uses its own simple regular expression
+implementation. It lacks many features you can find in POSIX extended
+regular expressions.  For example, we don't support union (`"x|y"`),
+grouping (`"(xy)"`), brackets (`"[xy]"`), and repetition count
+(`"x{5,7}"`), among others. Below is what we do support (Letter `A` denotes a
+literal character, period (`.`), or a single `\\` escape sequence; `x`
+and `y` denote regular expressions.):
+
+| `c` | matches any literal character `c` |
+|:----|:----------------------------------|
+| `\\d` | matches any decimal digit         |
+| `\\D` | matches any character that's not a decimal digit |
+| `\\f` | matches `\f`                      |
+| `\\n` | matches `\n`                      |
+| `\\r` | matches `\r`                      |
+| `\\s` | matches any ASCII whitespace, including `\n` |
+| `\\S` | matches any character that's not a whitespace |
+| `\\t` | matches `\t`                      |
+| `\\v` | matches `\v`                      |
+| `\\w` | matches any letter, `_`, or decimal digit |
+| `\\W` | matches any character that `\\w` doesn't match |
+| `\\c` | matches any literal character `c`, which must be a punctuation |
+| `\\.` | matches the `.` character         |
+| `.` | matches any single character except `\n` |
+| `A?` | matches 0 or 1 occurrences of `A` |
+| `A*` | matches 0 or many occurrences of `A` |
+| `A+` | matches 1 or many occurrences of `A` |
+| `^` | matches the beginning of a string (not that of each line) |
+| `$` | matches the end of a string (not that of each line) |
+| `xy` | matches `x` followed by `y`       |
+
+To help you determine which capability is available on your system,
+Google Test defines macro `GTEST_USES_POSIX_RE=1` when it uses POSIX
+extended regular expressions, or `GTEST_USES_SIMPLE_RE=1` when it uses
+the simple version.  If you want your death tests to work in both
+cases, you can either `#if` on these macros or use the more limited
+syntax only.
+
+## How It Works ##
+
+Under the hood, `ASSERT_EXIT()` spawns a new process and executes the
+death test statement in that process. The details of of how precisely
+that happens depend on the platform and the variable
+`::testing::GTEST_FLAG(death_test_style)` (which is initialized from the
+command-line flag `--gtest_death_test_style`).
+
+  * On POSIX systems, `fork()` (or `clone()` on Linux) is used to spawn the child, after which:
+    * If the variable's value is `"fast"`, the death test statement is immediately executed.
+    * If the variable's value is `"threadsafe"`, the child process re-executes the unit test binary just as it was originally invoked, but with some extra flags to cause just the single death test under consideration to be run.
+  * On Windows, the child is spawned using the `CreateProcess()` API, and re-executes the binary to cause just the single death test under consideration to be run - much like the `threadsafe` mode on POSIX.
+
+Other values for the variable are illegal and will cause the death test to
+fail. Currently, the flag's default value is `"fast"`. However, we reserve the
+right to change it in the future. Therefore, your tests should not depend on
+this.
+
+In either case, the parent process waits for the child process to complete, and checks that
+
+  1. the child's exit status satisfies the predicate, and
+  1. the child's stderr matches the regular expression.
+
+If the death test statement runs to completion without dying, the child
+process will nonetheless terminate, and the assertion fails.
+
+## Death Tests And Threads ##
+
+The reason for the two death test styles has to do with thread safety. Due to
+well-known problems with forking in the presence of threads, death tests should
+be run in a single-threaded context. Sometimes, however, it isn't feasible to
+arrange that kind of environment. For example, statically-initialized modules
+may start threads before main is ever reached. Once threads have been created,
+it may be difficult or impossible to clean them up.
+
+Google Test has three features intended to raise awareness of threading issues.
+
+  1. A warning is emitted if multiple threads are running when a death test is encountered.
+  1. Test cases with a name ending in "DeathTest" are run before all other tests.
+  1. It uses `clone()` instead of `fork()` to spawn the child process on Linux (`clone()` is not available on Cygwin and Mac), as `fork()` is more likely to cause the child to hang when the parent process has multiple threads.
+
+It's perfectly fine to create threads inside a death test statement; they are
+executed in a separate process and cannot affect the parent.
+
+## Death Test Styles ##
+
+The "threadsafe" death test style was introduced in order to help mitigate the
+risks of testing in a possibly multithreaded environment. It trades increased
+test execution time (potentially dramatically so) for improved thread safety.
+We suggest using the faster, default "fast" style unless your test has specific
+problems with it.
+
+You can choose a particular style of death tests by setting the flag
+programmatically:
+
+```
+::testing::FLAGS_gtest_death_test_style = "threadsafe";
+```
+
+You can do this in `main()` to set the style for all death tests in the
+binary, or in individual tests. Recall that flags are saved before running each
+test and restored afterwards, so you need not do that yourself. For example:
+
+```
+TEST(MyDeathTest, TestOne) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+  // This test is run in the "threadsafe" style:
+  ASSERT_DEATH(ThisShouldDie(), "");
+}
+
+TEST(MyDeathTest, TestTwo) {
+  // This test is run in the "fast" style:
+  ASSERT_DEATH(ThisShouldDie(), "");
+}
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  ::testing::FLAGS_gtest_death_test_style = "fast";
+  return RUN_ALL_TESTS();
+}
+```
+
+## Caveats ##
+
+The _statement_ argument of `ASSERT_EXIT()` can be any valid C++ statement.
+If it leaves the current function via a `return` statement or by throwing an exception,
+the death test is considered to have failed.  Some Google Test macros may return
+from the current function (e.g. `ASSERT_TRUE()`), so be sure to avoid them in _statement_.
+
+Since _statement_ runs in the child process, any in-memory side effect (e.g.
+modifying a variable, releasing memory, etc) it causes will _not_ be observable
+in the parent process. In particular, if you release memory in a death test,
+your program will fail the heap check as the parent process will never see the
+memory reclaimed. To solve this problem, you can
+
+  1. try not to free memory in a death test;
+  1. free the memory again in the parent process; or
+  1. do not use the heap checker in your program.
+
+Due to an implementation detail, you cannot place multiple death test
+assertions on the same line; otherwise, compilation will fail with an unobvious
+error message.
+
+Despite the improved thread safety afforded by the "threadsafe" style of death
+test, thread problems such as deadlock are still possible in the presence of
+handlers registered with `pthread_atfork(3)`.
+
+# Using Assertions in Sub-routines #
+
+## Adding Traces to Assertions ##
+
+If a test sub-routine is called from several places, when an assertion
+inside it fails, it can be hard to tell which invocation of the
+sub-routine the failure is from.  You can alleviate this problem using
+extra logging or custom failure messages, but that usually clutters up
+your tests. A better solution is to use the `SCOPED_TRACE` macro:
+
+| `SCOPED_TRACE(`_message_`);` |
+|:-----------------------------|
+
+where _message_ can be anything streamable to `std::ostream`. This
+macro will cause the current file name, line number, and the given
+message to be added in every failure message. The effect will be
+undone when the control leaves the current lexical scope.
+
+For example,
+
+```
+10: void Sub1(int n) {
+11:   EXPECT_EQ(1, Bar(n));
+12:   EXPECT_EQ(2, Bar(n + 1));
+13: }
+14:
+15: TEST(FooTest, Bar) {
+16:   {
+17:     SCOPED_TRACE("A");  // This trace point will be included in
+18:                         // every failure in this scope.
+19:     Sub1(1);
+20:   }
+21:   // Now it won't.
+22:   Sub1(9);
+23: }
+```
+
+could result in messages like these:
+
+```
+path/to/foo_test.cc:11: Failure
+Value of: Bar(n)
+Expected: 1
+  Actual: 2
+   Trace:
+path/to/foo_test.cc:17: A
+
+path/to/foo_test.cc:12: Failure
+Value of: Bar(n + 1)
+Expected: 2
+  Actual: 3
+```
+
+Without the trace, it would've been difficult to know which invocation
+of `Sub1()` the two failures come from respectively. (You could add an
+extra message to each assertion in `Sub1()` to indicate the value of
+`n`, but that's tedious.)
+
+Some tips on using `SCOPED_TRACE`:
+
+  1. With a suitable message, it's often enough to use `SCOPED_TRACE` at the beginning of a sub-routine, instead of at each call site.
+  1. When calling sub-routines inside a loop, make the loop iterator part of the message in `SCOPED_TRACE` such that you can know which iteration the failure is from.
+  1. Sometimes the line number of the trace point is enough for identifying the particular invocation of a sub-routine. In this case, you don't have to choose a unique message for `SCOPED_TRACE`. You can simply use `""`.
+  1. You can use `SCOPED_TRACE` in an inner scope when there is one in the outer scope. In this case, all active trace points will be included in the failure messages, in reverse order they are encountered.
+  1. The trace dump is clickable in Emacs' compilation buffer - hit return on a line number and you'll be taken to that line in the source file!
+
+_Availability:_ Linux, Windows, Mac.
+
+## Propagating Fatal Failures ##
+
+A common pitfall when using `ASSERT_*` and `FAIL*` is not understanding that
+when they fail they only abort the _current function_, not the entire test. For
+example, the following test will segfault:
+```
+void Subroutine() {
+  // Generates a fatal failure and aborts the current function.
+  ASSERT_EQ(1, 2);
+  // The following won't be executed.
+  ...
+}
+
+TEST(FooTest, Bar) {
+  Subroutine();
+  // The intended behavior is for the fatal failure
+  // in Subroutine() to abort the entire test.
+  // The actual behavior: the function goes on after Subroutine() returns.
+  int* p = NULL;
+  *p = 3; // Segfault!
+}
+```
+
+Since we don't use exceptions, it is technically impossible to
+implement the intended behavior here.  To alleviate this, Google Test
+provides two solutions.  You could use either the
+`(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the
+`HasFatalFailure()` function.  They are described in the following two
+subsections.
+
+### Asserting on Subroutines ###
+
+As shown above, if your test calls a subroutine that has an `ASSERT_*`
+failure in it, the test will continue after the subroutine
+returns. This may not be what you want.
+
+Often people want fatal failures to propagate like exceptions.  For
+that Google Test offers the following macros:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_NO_FATAL_FAILURE(`_statement_`);` | `EXPECT_NO_FATAL_FAILURE(`_statement_`);` | _statement_ doesn't generate any new fatal failures in the current thread. |
+
+Only failures in the thread that executes the assertion are checked to
+determine the result of this type of assertions.  If _statement_
+creates new threads, failures in these threads are ignored.
+
+Examples:
+
+```
+ASSERT_NO_FATAL_FAILURE(Foo());
+
+int i;
+EXPECT_NO_FATAL_FAILURE({
+  i = Bar();
+});
+```
+
+_Availability:_ Linux, Windows, Mac. Assertions from multiple threads
+are currently not supported.
+
+### Checking for Failures in the Current Test ###
+
+`HasFatalFailure()` in the `::testing::Test` class returns `true` if an
+assertion in the current test has suffered a fatal failure. This
+allows functions to catch fatal failures in a sub-routine and return
+early.
+
+```
+class Test {
+ public:
+  ...
+  static bool HasFatalFailure();
+};
+```
+
+The typical usage, which basically simulates the behavior of a thrown
+exception, is:
+
+```
+TEST(FooTest, Bar) {
+  Subroutine();
+  // Aborts if Subroutine() had a fatal failure.
+  if (HasFatalFailure())
+    return;
+  // The following won't be executed.
+  ...
+}
+```
+
+If `HasFatalFailure()` is used outside of `TEST()` , `TEST_F()` , or a test
+fixture, you must add the `::testing::Test::` prefix, as in:
+
+```
+if (::testing::Test::HasFatalFailure())
+  return;
+```
+
+Similarly, `HasNonfatalFailure()` returns `true` if the current test
+has at least one non-fatal failure, and `HasFailure()` returns `true`
+if the current test has at least one failure of either kind.
+
+_Availability:_ Linux, Windows, Mac.  `HasNonfatalFailure()` and
+`HasFailure()` are available since version 1.4.0.
+
+# Logging Additional Information #
+
+In your test code, you can call `RecordProperty("key", value)` to log
+additional information, where `value` can be either a string or an `int`. The _last_ value recorded for a key will be emitted to the XML output
+if you specify one. For example, the test
+
+```
+TEST_F(WidgetUsageTest, MinAndMaxWidgets) {
+  RecordProperty("MaximumWidgets", ComputeMaxUsage());
+  RecordProperty("MinimumWidgets", ComputeMinUsage());
+}
+```
+
+will output XML like this:
+
+```
+...
+  <testcase name="MinAndMaxWidgets" status="run" time="6" classname="WidgetUsageTest"
+            MaximumWidgets="12"
+            MinimumWidgets="9" />
+...
+```
+
+_Note_:
+  * `RecordProperty()` is a static member of the `Test` class. Therefore it needs to be prefixed with `::testing::Test::` if used outside of the `TEST` body and the test fixture class.
+  * `key` must be a valid XML attribute name, and cannot conflict with the ones already used by Google Test (`name`, `status`, `time`, `classname`, `type_param`, and `value_param`).
+  * Calling `RecordProperty()` outside of the lifespan of a test is allowed. If it's called outside of a test but between a test case's `SetUpTestCase()` and `TearDownTestCase()` methods, it will be attributed to the XML element for the test case. If it's called outside of all test cases (e.g. in a test environment), it will be attributed to the top-level XML element.
+
+_Availability_: Linux, Windows, Mac.
+
+# Sharing Resources Between Tests in the Same Test Case #
+
+
+
+Google Test creates a new test fixture object for each test in order to make
+tests independent and easier to debug. However, sometimes tests use resources
+that are expensive to set up, making the one-copy-per-test model prohibitively
+expensive.
+
+If the tests don't change the resource, there's no harm in them sharing a
+single resource copy. So, in addition to per-test set-up/tear-down, Google Test
+also supports per-test-case set-up/tear-down. To use it:
+
+  1. In your test fixture class (say `FooTest` ), define as `static` some member variables to hold the shared resources.
+  1. In the same test fixture class, define a `static void SetUpTestCase()` function (remember not to spell it as **`SetupTestCase`** with a small `u`!) to set up the shared resources and a `static void TearDownTestCase()` function to tear them down.
+
+That's it! Google Test automatically calls `SetUpTestCase()` before running the
+_first test_ in the `FooTest` test case (i.e. before creating the first
+`FooTest` object), and calls `TearDownTestCase()` after running the _last test_
+in it (i.e. after deleting the last `FooTest` object). In between, the tests
+can use the shared resources.
+
+Remember that the test order is undefined, so your code can't depend on a test
+preceding or following another. Also, the tests must either not modify the
+state of any shared resource, or, if they do modify the state, they must
+restore the state to its original value before passing control to the next
+test.
+
+Here's an example of per-test-case set-up and tear-down:
+```
+class FooTest : public ::testing::Test {
+ protected:
+  // Per-test-case set-up.
+  // Called before the first test in this test case.
+  // Can be omitted if not needed.
+  static void SetUpTestCase() {
+    shared_resource_ = new ...;
+  }
+
+  // Per-test-case tear-down.
+  // Called after the last test in this test case.
+  // Can be omitted if not needed.
+  static void TearDownTestCase() {
+    delete shared_resource_;
+    shared_resource_ = NULL;
+  }
+
+  // You can define per-test set-up and tear-down logic as usual.
+  virtual void SetUp() { ... }
+  virtual void TearDown() { ... }
+
+  // Some expensive resource shared by all tests.
+  static T* shared_resource_;
+};
+
+T* FooTest::shared_resource_ = NULL;
+
+TEST_F(FooTest, Test1) {
+  ... you can refer to shared_resource here ...
+}
+TEST_F(FooTest, Test2) {
+  ... you can refer to shared_resource here ...
+}
+```
+
+_Availability:_ Linux, Windows, Mac.
+
+# Global Set-Up and Tear-Down #
+
+Just as you can do set-up and tear-down at the test level and the test case
+level, you can also do it at the test program level. Here's how.
+
+First, you subclass the `::testing::Environment` class to define a test
+environment, which knows how to set-up and tear-down:
+
+```
+class Environment {
+ public:
+  virtual ~Environment() {}
+  // Override this to define how to set up the environment.
+  virtual void SetUp() {}
+  // Override this to define how to tear down the environment.
+  virtual void TearDown() {}
+};
+```
+
+Then, you register an instance of your environment class with Google Test by
+calling the `::testing::AddGlobalTestEnvironment()` function:
+
+```
+Environment* AddGlobalTestEnvironment(Environment* env);
+```
+
+Now, when `RUN_ALL_TESTS()` is called, it first calls the `SetUp()` method of
+the environment object, then runs the tests if there was no fatal failures, and
+finally calls `TearDown()` of the environment object.
+
+It's OK to register multiple environment objects. In this case, their `SetUp()`
+will be called in the order they are registered, and their `TearDown()` will be
+called in the reverse order.
+
+Note that Google Test takes ownership of the registered environment objects.
+Therefore **do not delete them** by yourself.
+
+You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is
+called, probably in `main()`. If you use `gtest_main`, you need to      call
+this before `main()` starts for it to take effect. One way to do this is to
+define a global variable like this:
+
+```
+::testing::Environment* const foo_env = ::testing::AddGlobalTestEnvironment(new FooEnvironment);
+```
+
+However, we strongly recommend you to write your own `main()` and call
+`AddGlobalTestEnvironment()` there, as relying on initialization of global
+variables makes the code harder to read and may cause problems when you
+register multiple environments from different translation units and the
+environments have dependencies among them (remember that the compiler doesn't
+guarantee the order in which global variables from different translation units
+are initialized).
+
+_Availability:_ Linux, Windows, Mac.
+
+
+# Value Parameterized Tests #
+
+_Value-parameterized tests_ allow you to test your code with different
+parameters without writing multiple copies of the same test.
+
+Suppose you write a test for your code and then realize that your code is affected by a presence of a Boolean command line flag.
+
+```
+TEST(MyCodeTest, TestFoo) {
+  // A code to test foo().
+}
+```
+
+Usually people factor their test code into a function with a Boolean parameter in such situations. The function sets the flag, then executes the testing code.
+
+```
+void TestFooHelper(bool flag_value) {
+  flag = flag_value;
+  // A code to test foo().
+}
+
+TEST(MyCodeTest, TestFoo) {
+  TestFooHelper(false);
+  TestFooHelper(true);
+}
+```
+
+But this setup has serious drawbacks. First, when a test assertion fails in your tests, it becomes unclear what value of the parameter caused it to fail. You can stream a clarifying message into your `EXPECT`/`ASSERT` statements, but it you'll have to do it with all of them. Second, you have to add one such helper function per test. What if you have ten tests? Twenty? A hundred?
+
+Value-parameterized tests will let you write your test only once and then easily instantiate and run it with an arbitrary number of parameter values.
+
+Here are some other situations when value-parameterized tests come handy:
+
+  * You want to test different implementations of an OO interface.
+  * You want to test your code over various inputs (a.k.a. data-driven testing). This feature is easy to abuse, so please exercise your good sense when doing it!
+
+## How to Write Value-Parameterized Tests ##
+
+To write value-parameterized tests, first you should define a fixture
+class.  It must be derived from both `::testing::Test` and
+`::testing::WithParamInterface<T>` (the latter is a pure interface),
+where `T` is the type of your parameter values.  For convenience, you
+can just derive the fixture class from `::testing::TestWithParam<T>`,
+which itself is derived from both `::testing::Test` and
+`::testing::WithParamInterface<T>`. `T` can be any copyable type. If
+it's a raw pointer, you are responsible for managing the lifespan of
+the pointed values.
+
+```
+class FooTest : public ::testing::TestWithParam<const char*> {
+  // You can implement all the usual fixture class members here.
+  // To access the test parameter, call GetParam() from class
+  // TestWithParam<T>.
+};
+
+// Or, when you want to add parameters to a pre-existing fixture class:
+class BaseTest : public ::testing::Test {
+  ...
+};
+class BarTest : public BaseTest,
+                public ::testing::WithParamInterface<const char*> {
+  ...
+};
+```
+
+Then, use the `TEST_P` macro to define as many test patterns using
+this fixture as you want.  The `_P` suffix is for "parameterized" or
+"pattern", whichever you prefer to think.
+
+```
+TEST_P(FooTest, DoesBlah) {
+  // Inside a test, access the test parameter with the GetParam() method
+  // of the TestWithParam<T> class:
+  EXPECT_TRUE(foo.Blah(GetParam()));
+  ...
+}
+
+TEST_P(FooTest, HasBlahBlah) {
+  ...
+}
+```
+
+Finally, you can use `INSTANTIATE_TEST_CASE_P` to instantiate the test
+case with 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 are all in the `testing` namespace:
+
+| `Range(begin, end[, step])` | Yields values `{begin, begin+step, begin+step+step, ...}`. The values do not include `end`. `step` defaults to 1. |
+|:----------------------------|:------------------------------------------------------------------------------------------------------------------|
+| `Values(v1, v2, ..., vN)`   | Yields values `{v1, v2, ..., vN}`.                                                                                |
+| `ValuesIn(container)` and `ValuesIn(begin, end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)`. `container`, `begin`, and `end` can be expressions whose values are determined at run time.  |
+| `Bool()`                    | Yields sequence `{false, true}`.                                                                                  |
+| `Combine(g1, g2, ..., gN)`  | Yields all combinations (the Cartesian product for the math savvy) of the values generated by the `N` generators. This is only available if your system provides the `<tr1/tuple>` header. If you are sure your system does, and Google Test disagrees, you can override it by defining `GTEST_HAS_TR1_TUPLE=1`. See comments in [include/gtest/internal/gtest-port.h](../include/gtest/internal/gtest-port.h) for more information. |
+
+For more details, see the comments at the definitions of these functions in the [source code](../include/gtest/gtest-param-test.h).
+
+The following statement will instantiate tests from the `FooTest` test case
+each with parameter values `"meeny"`, `"miny"`, and `"moe"`.
+
+```
+INSTANTIATE_TEST_CASE_P(InstantiationName,
+                        FooTest,
+                        ::testing::Values("meeny", "miny", "moe"));
+```
+
+To distinguish different instances of the pattern (yes, you can
+instantiate it more than once), the first argument to
+`INSTANTIATE_TEST_CASE_P` is a prefix that will be added to the actual
+test case name. Remember to pick unique prefixes for different
+instantiations. The tests from the instantiation above will have these
+names:
+
+  * `InstantiationName/FooTest.DoesBlah/0` for `"meeny"`
+  * `InstantiationName/FooTest.DoesBlah/1` for `"miny"`
+  * `InstantiationName/FooTest.DoesBlah/2` for `"moe"`
+  * `InstantiationName/FooTest.HasBlahBlah/0` for `"meeny"`
+  * `InstantiationName/FooTest.HasBlahBlah/1` for `"miny"`
+  * `InstantiationName/FooTest.HasBlahBlah/2` for `"moe"`
+
+You can use these names in [--gtest\_filter](#running-a-subset-of-the-tests).
+
+This statement will instantiate all tests from `FooTest` again, each
+with parameter values `"cat"` and `"dog"`:
+
+```
+const char* pets[] = {"cat", "dog"};
+INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest,
+                        ::testing::ValuesIn(pets));
+```
+
+The tests from the instantiation above will have these names:
+
+  * `AnotherInstantiationName/FooTest.DoesBlah/0` for `"cat"`
+  * `AnotherInstantiationName/FooTest.DoesBlah/1` for `"dog"`
+  * `AnotherInstantiationName/FooTest.HasBlahBlah/0` for `"cat"`
+  * `AnotherInstantiationName/FooTest.HasBlahBlah/1` for `"dog"`
+
+Please note that `INSTANTIATE_TEST_CASE_P` will instantiate _all_
+tests in the given test case, whether their definitions come before or
+_after_ the `INSTANTIATE_TEST_CASE_P` statement.
+
+You can see
+[these](../samples/sample7_unittest.cc)
+[files](../samples/sample8_unittest.cc) for more examples.
+
+_Availability_: Linux, Windows (requires MSVC 8.0 or above), Mac; since version 1.2.0.
+
+## Creating Value-Parameterized Abstract Tests ##
+
+In the above, we define and instantiate `FooTest` in the same source
+file. Sometimes you may want to define value-parameterized tests in a
+library and let other people instantiate them later. This pattern is
+known as <i>abstract tests</i>. As an example of its application, when you
+are designing an interface you can write a standard suite of abstract
+tests (perhaps using a factory function as the test parameter) that
+all implementations of the interface are expected to pass. When
+someone implements the interface, he can instantiate your suite to get
+all the interface-conformance tests for free.
+
+To define abstract tests, you should organize your code like this:
+
+  1. Put the definition of the parameterized test fixture class (e.g. `FooTest`) in a header file, say `foo_param_test.h`. Think of this as _declaring_ your abstract tests.
+  1. Put the `TEST_P` definitions in `foo_param_test.cc`, which includes `foo_param_test.h`. Think of this as _implementing_ your abstract tests.
+
+Once they are defined, you can instantiate them by including
+`foo_param_test.h`, invoking `INSTANTIATE_TEST_CASE_P()`, and linking
+with `foo_param_test.cc`. You can instantiate the same abstract test
+case multiple times, possibly in different source files.
+
+# Typed Tests #
+
+Suppose you have multiple implementations of the same interface and
+want to make sure that all of them satisfy some common requirements.
+Or, you may have defined several types that are supposed to conform to
+the same "concept" and you want to verify it.  In both cases, you want
+the same test logic repeated for different types.
+
+While you can write one `TEST` or `TEST_F` for each type you want to
+test (and you may even factor the test logic into a function template
+that you invoke from the `TEST`), it's tedious and doesn't scale:
+if you want _m_ tests over _n_ types, you'll end up writing _m\*n_
+`TEST`s.
+
+_Typed tests_ allow you to repeat the same test logic over a list of
+types.  You only need to write the test logic once, although you must
+know the type list when writing typed tests.  Here's how you do it:
+
+First, define a fixture class template.  It should be parameterized
+by a type.  Remember to derive it from `::testing::Test`:
+
+```
+template <typename T>
+class FooTest : public ::testing::Test {
+ public:
+  ...
+  typedef std::list<T> List;
+  static T shared_;
+  T value_;
+};
+```
+
+Next, associate a list of types with the test case, which will be
+repeated for each type in the list:
+
+```
+typedef ::testing::Types<char, int, unsigned int> MyTypes;
+TYPED_TEST_CASE(FooTest, MyTypes);
+```
+
+The `typedef` is necessary for the `TYPED_TEST_CASE` macro to parse
+correctly.  Otherwise the compiler will think that each comma in the
+type list introduces a new macro argument.
+
+Then, use `TYPED_TEST()` instead of `TEST_F()` to define a typed test
+for this test case.  You can repeat this as many times as you want:
+
+```
+TYPED_TEST(FooTest, DoesBlah) {
+  // Inside a test, refer to the special name TypeParam to get the type
+  // parameter.  Since we are inside a derived class template, C++ requires
+  // us to visit the members of FooTest via 'this'.
+  TypeParam n = this->value_;
+
+  // To visit static members of the fixture, add the 'TestFixture::'
+  // prefix.
+  n += TestFixture::shared_;
+
+  // To refer to typedefs in the fixture, add the 'typename TestFixture::'
+  // prefix.  The 'typename' is required to satisfy the compiler.
+  typename TestFixture::List values;
+  values.push_back(n);
+  ...
+}
+
+TYPED_TEST(FooTest, HasPropertyA) { ... }
+```
+
+You can see `samples/sample6_unittest.cc` for a complete example.
+
+_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
+since version 1.1.0.
+
+# Type-Parameterized Tests #
+
+_Type-parameterized tests_ are like typed tests, except that they
+don't require you to know the list of types ahead of time.  Instead,
+you can define the test logic first and instantiate it with different
+type lists later.  You can even instantiate it more than once in the
+same program.
+
+If you are designing an interface or concept, you can define a suite
+of type-parameterized tests to verify properties that any valid
+implementation of the interface/concept should have.  Then, the author
+of each implementation can just instantiate the test suite with his
+type to verify that it conforms to the requirements, without having to
+write similar tests repeatedly.  Here's an example:
+
+First, define a fixture class template, as we did with typed tests:
+
+```
+template <typename T>
+class FooTest : public ::testing::Test {
+  ...
+};
+```
+
+Next, declare that you will define a type-parameterized test case:
+
+```
+TYPED_TEST_CASE_P(FooTest);
+```
+
+The `_P` suffix is for "parameterized" or "pattern", whichever you
+prefer to think.
+
+Then, use `TYPED_TEST_P()` to define a type-parameterized test.  You
+can repeat this as many times as you want:
+
+```
+TYPED_TEST_P(FooTest, DoesBlah) {
+  // Inside a test, refer to TypeParam to get the type parameter.
+  TypeParam n = 0;
+  ...
+}
+
+TYPED_TEST_P(FooTest, HasPropertyA) { ... }
+```
+
+Now the tricky part: you need to register all test patterns using the
+`REGISTER_TYPED_TEST_CASE_P` macro before you can instantiate them.
+The first argument of the macro is the test case name; the rest are
+the names of the tests in this test case:
+
+```
+REGISTER_TYPED_TEST_CASE_P(FooTest,
+                           DoesBlah, HasPropertyA);
+```
+
+Finally, you are free to instantiate the pattern with the types you
+want.  If you put the above code in a header file, you can `#include`
+it in multiple C++ source files and instantiate it multiple times.
+
+```
+typedef ::testing::Types<char, int, unsigned int> MyTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
+```
+
+To distinguish different instances of the pattern, the first argument
+to the `INSTANTIATE_TYPED_TEST_CASE_P` macro is a prefix that will be
+added to the actual test case name.  Remember to pick unique prefixes
+for different instances.
+
+In the special case where the type list contains only one type, you
+can write that type directly without `::testing::Types<...>`, like this:
+
+```
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
+```
+
+You can see `samples/sample6_unittest.cc` for a complete example.
+
+_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
+since version 1.1.0.
+
+# Testing Private Code #
+
+If you change your software's internal implementation, your tests should not
+break as long as the change is not observable by users. Therefore, per the
+_black-box testing principle_, most of the time you should test your code
+through its public interfaces.
+
+If you still find yourself needing to test internal implementation code,
+consider if there's a better design that wouldn't require you to do so. If you
+absolutely have to test non-public interface code though, you can. There are
+two cases to consider:
+
+  * Static functions (_not_ the same as static member functions!) or unnamed namespaces, and
+  * Private or protected class members
+
+## Static Functions ##
+
+Both static functions and definitions/declarations in an unnamed namespace are
+only visible within the same translation unit. To test them, you can `#include`
+the entire `.cc` file being tested in your `*_test.cc` file. (`#include`ing `.cc`
+files is not a good way to reuse code - you should not do this in production
+code!)
+
+However, a better approach is to move the private code into the
+`foo::internal` namespace, where `foo` is the namespace your project normally
+uses, and put the private declarations in a `*-internal.h` file. Your
+production `.cc` files and your tests are allowed to include this internal
+header, but your clients are not. This way, you can fully test your internal
+implementation without leaking it to your clients.
+
+## Private Class Members ##
+
+Private class members are only accessible from within the class or by friends.
+To access a class' private members, you can declare your test fixture as a
+friend to the class and define accessors in your fixture. Tests using the
+fixture can then access the private members of your production class via the
+accessors in the fixture. Note that even though your fixture is a friend to
+your production class, your tests are not automatically friends to it, as they
+are technically defined in sub-classes of the fixture.
+
+Another way to test private members is to refactor them into an implementation
+class, which is then declared in a `*-internal.h` file. Your clients aren't
+allowed to include this header but your tests can. Such is called the Pimpl
+(Private Implementation) idiom.
+
+Or, you can declare an individual test as a friend of your class by adding this
+line in the class body:
+
+```
+FRIEND_TEST(TestCaseName, TestName);
+```
+
+For example,
+```
+// foo.h
+#include "gtest/gtest_prod.h"
+
+// Defines FRIEND_TEST.
+class Foo {
+  ...
+ private:
+  FRIEND_TEST(FooTest, BarReturnsZeroOnNull);
+  int Bar(void* x);
+};
+
+// foo_test.cc
+...
+TEST(FooTest, BarReturnsZeroOnNull) {
+  Foo foo;
+  EXPECT_EQ(0, foo.Bar(NULL));
+  // Uses Foo's private member Bar().
+}
+```
+
+Pay special attention when your class is defined in a namespace, as you should
+define your test fixtures and tests in the same namespace if you want them to
+be friends of your class. For example, if the code to be tested looks like:
+
+```
+namespace my_namespace {
+
+class Foo {
+  friend class FooTest;
+  FRIEND_TEST(FooTest, Bar);
+  FRIEND_TEST(FooTest, Baz);
+  ...
+  definition of the class Foo
+  ...
+};
+
+}  // namespace my_namespace
+```
+
+Your test code should be something like:
+
+```
+namespace my_namespace {
+class FooTest : public ::testing::Test {
+ protected:
+  ...
+};
+
+TEST_F(FooTest, Bar) { ... }
+TEST_F(FooTest, Baz) { ... }
+
+}  // namespace my_namespace
+```
+
+# Catching Failures #
+
+If you are building a testing utility on top of Google Test, you'll
+want to test your utility.  What framework would you use to test it?
+Google Test, of course.
+
+The challenge is to verify that your testing utility reports failures
+correctly.  In frameworks that report a failure by throwing an
+exception, you could catch the exception and assert on it.  But Google
+Test doesn't use exceptions, so how do we test that a piece of code
+generates an expected failure?
+
+`"gtest/gtest-spi.h"` contains some constructs to do this.  After 
+`#include`ing this header, you can use
+
+| `EXPECT_FATAL_FAILURE(`_statement, substring_`);` |
+|:--------------------------------------------------|
+
+to assert that _statement_ generates a fatal (e.g. `ASSERT_*`) failure
+whose message contains the given _substring_, or use
+
+| `EXPECT_NONFATAL_FAILURE(`_statement, substring_`);` |
+|:-----------------------------------------------------|
+
+if you are expecting a non-fatal (e.g. `EXPECT_*`) failure.
+
+For technical reasons, there are some caveats:
+
+  1. You cannot stream a failure message to either macro.
+  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot reference local non-static variables or non-static members of `this` object.
+  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot return a value.
+
+_Note:_ Google Test is designed with threads in mind. Once the
+synchronization primitives in `"gtest/internal/gtest-port.h"` have
+been implemented, Google Test will become thread-safe, meaning that
+you can then use assertions in multiple threads concurrently. Before
+that, however, Google Test only supports single-threaded usage. Once
+thread-safe, `EXPECT_FATAL_FAILURE()` and `EXPECT_NONFATAL_FAILURE()`
+will capture failures in the current thread only. If _statement_
+creates new threads, failures in these threads will be ignored. If
+you want to capture failures from all threads instead, you should use
+the following macros:
+
+| `EXPECT_FATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
+|:-----------------------------------------------------------------|
+| `EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
+
+# Getting the Current Test's Name #
+
+Sometimes a function may need to know the name of the currently running test.
+For example, you may be using the `SetUp()` method of your test fixture to set
+the golden file name based on which test is running. The `::testing::TestInfo`
+class has this information:
+
+```
+namespace testing {
+
+class TestInfo {
+ public:
+  // Returns the test case name and the test name, respectively.
+  //
+  // Do NOT delete or free the return value - it's managed by the
+  // TestInfo class.
+  const char* test_case_name() const;
+  const char* name() const;
+};
+
+}  // namespace testing
+```
+
+
+> To obtain a `TestInfo` object for the currently running test, call
+`current_test_info()` on the `UnitTest` singleton object:
+
+```
+// Gets information about the currently running test.
+// Do NOT delete the returned object - it's managed by the UnitTest class.
+const ::testing::TestInfo* const test_info =
+  ::testing::UnitTest::GetInstance()->current_test_info();
+printf("We are in test %s of test case %s.\n",
+       test_info->name(), test_info->test_case_name());
+```
+
+`current_test_info()` returns a null pointer if no test is running. In
+particular, you cannot find the test case name in `TestCaseSetUp()`,
+`TestCaseTearDown()` (where you know the test case name implicitly), or
+functions called from them.
+
+_Availability:_ Linux, Windows, Mac.
+
+# Extending Google Test by Handling Test Events #
+
+Google Test provides an <b>event listener API</b> to let you receive
+notifications about the progress of a test program and test
+failures. The events you can listen to include the start and end of
+the test program, a test case, or a test method, among others. You may
+use this API to augment or replace the standard console output,
+replace the XML output, or provide a completely different form of
+output, such as a GUI or a database. You can also use test events as
+checkpoints to implement a resource leak checker, for example.
+
+_Availability:_ Linux, Windows, Mac; since v1.4.0.
+
+## Defining Event Listeners ##
+
+To define a event listener, you subclass either
+[testing::TestEventListener](../include/gtest/gtest.h#L991)
+or [testing::EmptyTestEventListener](../include/gtest/gtest.h#L1044).
+The former is an (abstract) interface, where <i>each pure virtual method<br>
+can be overridden to handle a test event</i> (For example, when a test
+starts, the `OnTestStart()` method will be called.). The latter provides
+an empty implementation of all methods in the interface, such that a
+subclass only needs to override the methods it cares about.
+
+When an event is fired, its context is passed to the handler function
+as an argument. The following argument types are used:
+  * [UnitTest](../include/gtest/gtest.h#L1151) reflects the state of the entire test program,
+  * [TestCase](../include/gtest/gtest.h#L778) has information about a test case, which can contain one or more tests,
+  * [TestInfo](../include/gtest/gtest.h#L644) contains the state of a test, and
+  * [TestPartResult](../include/gtest/gtest-test-part.h#L47) represents the result of a test assertion.
+
+An event handler function can examine the argument it receives to find
+out interesting information about the event and the test program's
+state.  Here's an example:
+
+```
+  class MinimalistPrinter : public ::testing::EmptyTestEventListener {
+    // Called before a test starts.
+    virtual void OnTestStart(const ::testing::TestInfo& test_info) {
+      printf("*** Test %s.%s starting.\n",
+             test_info.test_case_name(), test_info.name());
+    }
+
+    // Called after a failed assertion or a SUCCEED() invocation.
+    virtual void OnTestPartResult(
+        const ::testing::TestPartResult& test_part_result) {
+      printf("%s in %s:%d\n%s\n",
+             test_part_result.failed() ? "*** Failure" : "Success",
+             test_part_result.file_name(),
+             test_part_result.line_number(),
+             test_part_result.summary());
+    }
+
+    // Called after a test ends.
+    virtual void OnTestEnd(const ::testing::TestInfo& test_info) {
+      printf("*** Test %s.%s ending.\n",
+             test_info.test_case_name(), test_info.name());
+    }
+  };
+```
+
+## Using Event Listeners ##
+
+To use the event listener you have defined, add an instance of it to
+the Google Test event listener list (represented by class
+[TestEventListeners](../include/gtest/gtest.h#L1064)
+- note the "s" at the end of the name) in your
+`main()` function, before calling `RUN_ALL_TESTS()`:
+```
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  // Gets hold of the event listener list.
+  ::testing::TestEventListeners& listeners =
+      ::testing::UnitTest::GetInstance()->listeners();
+  // Adds a listener to the end.  Google Test takes the ownership.
+  listeners.Append(new MinimalistPrinter);
+  return RUN_ALL_TESTS();
+}
+```
+
+There's only one problem: the default test result printer is still in
+effect, so its output will mingle with the output from your minimalist
+printer. To suppress the default printer, just release it from the
+event listener list and delete it. You can do so by adding one line:
+```
+  ...
+  delete listeners.Release(listeners.default_result_printer());
+  listeners.Append(new MinimalistPrinter);
+  return RUN_ALL_TESTS();
+```
+
+Now, sit back and enjoy a completely different output from your
+tests. For more details, you can read this
+[sample](../samples/sample9_unittest.cc).
+
+You may append more than one listener to the list. When an `On*Start()`
+or `OnTestPartResult()` event is fired, the listeners will receive it in
+the order they appear in the list (since new listeners are added to
+the end of the list, the default text printer and the default XML
+generator will receive the event first). An `On*End()` event will be
+received by the listeners in the _reverse_ order. This allows output by
+listeners added later to be framed by output from listeners added
+earlier.
+
+## Generating Failures in Listeners ##
+
+You may use failure-raising macros (`EXPECT_*()`, `ASSERT_*()`,
+`FAIL()`, etc) when processing an event. There are some restrictions:
+
+  1. You cannot generate any failure in `OnTestPartResult()` (otherwise it will cause `OnTestPartResult()` to be called recursively).
+  1. A listener that handles `OnTestPartResult()` is not allowed to generate any failure.
+
+When you add listeners to the listener list, you should put listeners
+that handle `OnTestPartResult()` _before_ listeners that can generate
+failures. This ensures that failures generated by the latter are
+attributed to the right test by the former.
+
+We have a sample of failure-raising listener
+[here](../samples/sample10_unittest.cc).
+
+# Running Test Programs: Advanced Options #
+
+Google Test test programs are ordinary executables. Once built, you can run
+them directly and affect their behavior via the following environment variables
+and/or command line flags. For the flags to work, your programs must call
+`::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`.
+
+To see a list of supported flags and their usage, please run your test
+program with the `--help` flag.  You can also use `-h`, `-?`, or `/?`
+for short.  This feature is added in version 1.3.0.
+
+If an option is specified both by an environment variable and by a
+flag, the latter takes precedence.  Most of the options can also be
+set/read in code: to access the value of command line flag
+`--gtest_foo`, write `::testing::GTEST_FLAG(foo)`.  A common pattern is
+to set the value of a flag before calling `::testing::InitGoogleTest()`
+to change the default value of the flag:
+```
+int main(int argc, char** argv) {
+  // Disables elapsed time by default.
+  ::testing::GTEST_FLAG(print_time) = false;
+
+  // This allows the user to override the flag on the command line.
+  ::testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}
+```
+
+## Selecting Tests ##
+
+This section shows various options for choosing which tests to run.
+
+### Listing Test Names ###
+
+Sometimes it is necessary to list the available tests in a program before
+running them so that a filter may be applied if needed. Including the flag
+`--gtest_list_tests` overrides all other flags and lists tests in the following
+format:
+```
+TestCase1.
+  TestName1
+  TestName2
+TestCase2.
+  TestName
+```
+
+None of the tests listed are actually run if the flag is provided. There is no
+corresponding environment variable for this flag.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Running a Subset of the Tests ###
+
+By default, a Google Test program runs all tests the user has defined.
+Sometimes, you want to run only a subset of the tests (e.g. for debugging or
+quickly verifying a change). If you set the `GTEST_FILTER` environment variable
+or the `--gtest_filter` flag to a filter string, Google Test will only run the
+tests whose full names (in the form of `TestCaseName.TestName`) match the
+filter.
+
+The format of a filter is a '`:`'-separated list of wildcard patterns (called
+the positive patterns) optionally followed by a '`-`' and another
+'`:`'-separated pattern list (called the negative patterns). A test matches the
+filter if and only if it matches any of the positive patterns but does not
+match any of the negative patterns.
+
+A pattern may contain `'*'` (matches any string) or `'?'` (matches any single
+character). For convenience, the filter `'*-NegativePatterns'` can be also
+written as `'-NegativePatterns'`.
+
+For example:
+
+  * `./foo_test` Has no flag, and thus runs all its tests.
+  * `./foo_test --gtest_filter=*` Also runs everything, due to the single match-everything `*` value.
+  * `./foo_test --gtest_filter=FooTest.*` Runs everything in test case `FooTest`.
+  * `./foo_test --gtest_filter=*Null*:*Constructor*` Runs any test whose full name contains either `"Null"` or `"Constructor"`.
+  * `./foo_test --gtest_filter=-*DeathTest.*` Runs all non-death tests.
+  * `./foo_test --gtest_filter=FooTest.*-FooTest.Bar` Runs everything in test case `FooTest` except `FooTest.Bar`.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Temporarily Disabling Tests ###
+
+If you have a broken test that you cannot fix right away, you can add the
+`DISABLED_` prefix to its name. This will exclude it from execution. This is
+better than commenting out the code or using `#if 0`, as disabled tests are
+still compiled (and thus won't rot).
+
+If you need to disable all tests in a test case, you can either add `DISABLED_`
+to the front of the name of each test, or alternatively add it to the front of
+the test case name.
+
+For example, the following tests won't be run by Google Test, even though they
+will still be compiled:
+
+```
+// Tests that Foo does Abc.
+TEST(FooTest, DISABLED_DoesAbc) { ... }
+
+class DISABLED_BarTest : public ::testing::Test { ... };
+
+// Tests that Bar does Xyz.
+TEST_F(DISABLED_BarTest, DoesXyz) { ... }
+```
+
+_Note:_ This feature should only be used for temporary pain-relief. You still
+have to fix the disabled tests at a later date. As a reminder, Google Test will
+print a banner warning you if a test program contains any disabled tests.
+
+_Tip:_ You can easily count the number of disabled tests you have
+using `grep`. This number can be used as a metric for improving your
+test quality.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Temporarily Enabling Disabled Tests ###
+
+To include [disabled tests](#temporarily-disabling-tests) in test
+execution, just invoke the test program with the
+`--gtest_also_run_disabled_tests` flag or set the
+`GTEST_ALSO_RUN_DISABLED_TESTS` environment variable to a value other
+than `0`.  You can combine this with the
+[--gtest\_filter](#running-a-subset-of-the-tests) flag to further select
+which disabled tests to run.
+
+_Availability:_ Linux, Windows, Mac; since version 1.3.0.
+
+## Repeating the Tests ##
+
+Once in a while you'll run into a test whose result is hit-or-miss. Perhaps it
+will fail only 1% of the time, making it rather hard to reproduce the bug under
+a debugger. This can be a major source of frustration.
+
+The `--gtest_repeat` flag allows you to repeat all (or selected) test methods
+in a program many times. Hopefully, a flaky test will eventually fail and give
+you a chance to debug. Here's how to use it:
+
+| `$ foo_test --gtest_repeat=1000` | Repeat foo\_test 1000 times and don't stop at failures. |
+|:---------------------------------|:--------------------------------------------------------|
+| `$ foo_test --gtest_repeat=-1`   | A negative count means repeating forever.               |
+| `$ foo_test --gtest_repeat=1000 --gtest_break_on_failure` | Repeat foo\_test 1000 times, stopping at the first failure. This is especially useful when running under a debugger: when the testfails, it will drop into the debugger and you can then inspect variables and stacks. |
+| `$ foo_test --gtest_repeat=1000 --gtest_filter=FooBar` | Repeat the tests whose name matches the filter 1000 times. |
+
+If your test program contains global set-up/tear-down code registered
+using `AddGlobalTestEnvironment()`, it will be repeated in each
+iteration as well, as the flakiness may be in it. You can also specify
+the repeat count by setting the `GTEST_REPEAT` environment variable.
+
+_Availability:_ Linux, Windows, Mac.
+
+## Shuffling the Tests ##
+
+You can specify the `--gtest_shuffle` flag (or set the `GTEST_SHUFFLE`
+environment variable to `1`) to run the tests in a program in a random
+order. This helps to reveal bad dependencies between tests.
+
+By default, Google Test uses a random seed calculated from the current
+time. Therefore you'll get a different order every time. The console
+output includes the random seed value, such that you can reproduce an
+order-related test failure later. To specify the random seed
+explicitly, use the `--gtest_random_seed=SEED` flag (or set the
+`GTEST_RANDOM_SEED` environment variable), where `SEED` is an integer
+between 0 and 99999. The seed value 0 is special: it tells Google Test
+to do the default behavior of calculating the seed from the current
+time.
+
+If you combine this with `--gtest_repeat=N`, Google Test will pick a
+different random seed and re-shuffle the tests in each iteration.
+
+_Availability:_ Linux, Windows, Mac; since v1.4.0.
+
+## Controlling Test Output ##
+
+This section teaches how to tweak the way test results are reported.
+
+### Colored Terminal Output ###
+
+Google Test can use colors in its terminal output to make it easier to spot
+the separation between tests, and whether tests passed.
+
+You can set the GTEST\_COLOR environment variable or set the `--gtest_color`
+command line flag to `yes`, `no`, or `auto` (the default) to enable colors,
+disable colors, or let Google Test decide. When the value is `auto`, Google
+Test will use colors if and only if the output goes to a terminal and (on
+non-Windows platforms) the `TERM` environment variable is set to `xterm` or
+`xterm-color`.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Suppressing the Elapsed Time ###
+
+By default, Google Test prints the time it takes to run each test.  To
+suppress that, run the test program with the `--gtest_print_time=0`
+command line flag.  Setting the `GTEST_PRINT_TIME` environment
+variable to `0` has the same effect.
+
+_Availability:_ Linux, Windows, Mac.  (In Google Test 1.3.0 and lower,
+the default behavior is that the elapsed time is **not** printed.)
+
+### Generating an XML Report ###
+
+Google Test can emit a detailed XML report to a file in addition to its normal
+textual output. The report contains the duration of each test, and thus can
+help you identify slow tests.
+
+To generate the XML report, set the `GTEST_OUTPUT` environment variable or the
+`--gtest_output` flag to the string `"xml:_path_to_output_file_"`, which will
+create the file at the given location. You can also just use the string
+`"xml"`, in which case the output can be found in the `test_detail.xml` file in
+the current directory.
+
+If you specify a directory (for example, `"xml:output/directory/"` on Linux or
+`"xml:output\directory\"` on Windows), Google Test will create the XML file in
+that directory, named after the test executable (e.g. `foo_test.xml` for test
+program `foo_test` or `foo_test.exe`). If the file already exists (perhaps left
+over from a previous run), Google Test will pick a different name (e.g.
+`foo_test_1.xml`) to avoid overwriting it.
+
+The report uses the format described here.  It is based on the
+`junitreport` Ant task and can be parsed by popular continuous build
+systems like [Hudson](https://hudson.dev.java.net/). Since that format
+was originally intended for Java, a little interpretation is required
+to make it apply to Google Test tests, as shown here:
+
+```
+<testsuites name="AllTests" ...>
+  <testsuite name="test_case_name" ...>
+    <testcase name="test_name" ...>
+      <failure message="..."/>
+      <failure message="..."/>
+      <failure message="..."/>
+    </testcase>
+  </testsuite>
+</testsuites>
+```
+
+  * The root `<testsuites>` element corresponds to the entire test program.
+  * `<testsuite>` elements correspond to Google Test test cases.
+  * `<testcase>` elements correspond to Google Test test functions.
+
+For instance, the following program
+
+```
+TEST(MathTest, Addition) { ... }
+TEST(MathTest, Subtraction) { ... }
+TEST(LogicTest, NonContradiction) { ... }
+```
+
+could generate this report:
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="3" failures="1" errors="0" time="35" name="AllTests">
+  <testsuite name="MathTest" tests="2" failures="1" errors="0" time="15">
+    <testcase name="Addition" status="run" time="7" classname="">
+      <failure message="Value of: add(1, 1)&#x0A; Actual: 3&#x0A;Expected: 2" type=""/>
+      <failure message="Value of: add(1, -1)&#x0A; Actual: 1&#x0A;Expected: 0" type=""/>
+    </testcase>
+    <testcase name="Subtraction" status="run" time="5" classname="">
+    </testcase>
+  </testsuite>
+  <testsuite name="LogicTest" tests="1" failures="0" errors="0" time="5">
+    <testcase name="NonContradiction" status="run" time="5" classname="">
+    </testcase>
+  </testsuite>
+</testsuites>
+```
+
+Things to note:
+
+  * The `tests` attribute of a `<testsuites>` or `<testsuite>` element tells how many test functions the Google Test program or test case contains, while the `failures` attribute tells how many of them failed.
+  * The `time` attribute expresses the duration of the test, test case, or entire test program in milliseconds.
+  * Each `<failure>` element corresponds to a single failed Google Test assertion.
+  * Some JUnit concepts don't apply to Google Test, yet we have to conform to the DTD. Therefore you'll see some dummy elements and attributes in the report. You can safely ignore these parts.
+
+_Availability:_ Linux, Windows, Mac.
+
+## Controlling How Failures Are Reported ##
+
+### Turning Assertion Failures into Break-Points ###
+
+When running test programs under a debugger, it's very convenient if the
+debugger can catch an assertion failure and automatically drop into interactive
+mode. Google Test's _break-on-failure_ mode supports this behavior.
+
+To enable it, set the `GTEST_BREAK_ON_FAILURE` environment variable to a value
+other than `0` . Alternatively, you can use the `--gtest_break_on_failure`
+command line flag.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Disabling Catching Test-Thrown Exceptions ###
+
+Google Test can be used either with or without exceptions enabled.  If
+a test throws a C++ exception or (on Windows) a structured exception
+(SEH), by default Google Test catches it, reports it as a test
+failure, and continues with the next test method.  This maximizes the
+coverage of a test run.  Also, on Windows an uncaught exception will
+cause a pop-up window, so catching the exceptions allows you to run
+the tests automatically.
+
+When debugging the test failures, however, you may instead want the
+exceptions to be handled by the debugger, such that you can examine
+the call stack when an exception is thrown.  To achieve that, set the
+`GTEST_CATCH_EXCEPTIONS` environment variable to `0`, or use the
+`--gtest_catch_exceptions=0` flag when running the tests.
+
+**Availability**: Linux, Windows, Mac.
+
+### Letting Another Testing Framework Drive ###
+
+If you work on a project that has already been using another testing
+framework and is not ready to completely switch to Google Test yet,
+you can get much of Google Test's benefit by using its assertions in
+your existing tests.  Just change your `main()` function to look
+like:
+
+```
+#include "gtest/gtest.h"
+
+int main(int argc, char** argv) {
+  ::testing::GTEST_FLAG(throw_on_failure) = true;
+  // Important: Google Test must be initialized.
+  ::testing::InitGoogleTest(&argc, argv);
+
+  ... whatever your existing testing framework requires ...
+}
+```
+
+With that, you can use Google Test assertions in addition to the
+native assertions your testing framework provides, for example:
+
+```
+void TestFooDoesBar() {
+  Foo foo;
+  EXPECT_LE(foo.Bar(1), 100);     // A Google Test assertion.
+  CPPUNIT_ASSERT(foo.IsEmpty());  // A native assertion.
+}
+```
+
+If a Google Test assertion fails, it will print an error message and
+throw an exception, which will be treated as a failure by your host
+testing framework.  If you compile your code with exceptions disabled,
+a failed Google Test assertion will instead exit your program with a
+non-zero code, which will also signal a test failure to your test
+runner.
+
+If you don't write `::testing::GTEST_FLAG(throw_on_failure) = true;` in
+your `main()`, you can alternatively enable this feature by specifying
+the `--gtest_throw_on_failure` flag on the command-line or setting the
+`GTEST_THROW_ON_FAILURE` environment variable to a non-zero value.
+
+Death tests are _not_ supported when other test framework is used to organize tests.
+
+_Availability:_ Linux, Windows, Mac; since v1.3.0.
+
+## Distributing Test Functions to Multiple Machines ##
+
+If you have more than one machine you can use to run a test program,
+you might want to run the test functions in parallel and get the
+result faster.  We call this technique _sharding_, where each machine
+is called a _shard_.
+
+Google Test is compatible with test sharding.  To take advantage of
+this feature, your test runner (not part of Google Test) needs to do
+the following:
+
+  1. Allocate a number of machines (shards) to run the tests.
+  1. On each shard, set the `GTEST_TOTAL_SHARDS` environment variable to the total number of shards.  It must be the same for all shards.
+  1. On each shard, set the `GTEST_SHARD_INDEX` environment variable to the index of the shard.  Different shards must be assigned different indices, which must be in the range `[0, GTEST_TOTAL_SHARDS - 1]`.
+  1. Run the same test program on all shards.  When Google Test sees the above two environment variables, it will select a subset of the test functions to run.  Across all shards, each test function in the program will be run exactly once.
+  1. Wait for all shards to finish, then collect and report the results.
+
+Your project may have tests that were written without Google Test and
+thus don't understand this protocol.  In order for your test runner to
+figure out which test supports sharding, it can set the environment
+variable `GTEST_SHARD_STATUS_FILE` to a non-existent file path.  If a
+test program supports sharding, it will create this file to
+acknowledge the fact (the actual contents of the file are not
+important at this time; although we may stick some useful information
+in it in the future.); otherwise it will not create it.
+
+Here's an example to make it clear.  Suppose you have a test program
+`foo_test` that contains the following 5 test functions:
+```
+TEST(A, V)
+TEST(A, W)
+TEST(B, X)
+TEST(B, Y)
+TEST(B, Z)
+```
+and you have 3 machines at your disposal.  To run the test functions in
+parallel, you would set `GTEST_TOTAL_SHARDS` to 3 on all machines, and
+set `GTEST_SHARD_INDEX` to 0, 1, and 2 on the machines respectively.
+Then you would run the same `foo_test` on each machine.
+
+Google Test reserves the right to change how the work is distributed
+across the shards, but here's one possible scenario:
+
+  * Machine #0 runs `A.V` and `B.X`.
+  * Machine #1 runs `A.W` and `B.Y`.
+  * Machine #2 runs `B.Z`.
+
+_Availability:_ Linux, Windows, Mac; since version 1.3.0.
+
+# Fusing Google Test Source Files #
+
+Google Test's implementation consists of ~30 files (excluding its own
+tests).  Sometimes you may want them to be packaged up in two files (a
+`.h` and a `.cc`) instead, such that you can easily copy them to a new
+machine and start hacking there.  For this we provide an experimental
+Python script `fuse_gtest_files.py` in the `scripts/` directory (since release 1.3.0).
+Assuming you have Python 2.4 or above installed on your machine, just
+go to that directory and run
+```
+python fuse_gtest_files.py OUTPUT_DIR
+```
+
+and you should see an `OUTPUT_DIR` directory being created with files
+`gtest/gtest.h` and `gtest/gtest-all.cc` in it.  These files contain
+everything you need to use Google Test.  Just copy them to anywhere
+you want and you are ready to write tests.  You can use the
+[scripts/test/Makefile](../scripts/test/Makefile)
+file as an example on how to compile your tests against them.
+
+# Where to Go from Here #
+
+Congratulations! You've now learned more advanced Google Test tools and are
+ready to tackle more complex testing tasks. If you want to dive even deeper, you
+can read the [Frequently-Asked Questions](FAQ.md).
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/DevGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/DevGuide.md
new file mode 100644
index 00000000..06467a32
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/DevGuide.md
@@ -0,0 +1,126 @@
+
+
+If you are interested in understanding the internals of Google Test,
+building from source, or contributing ideas or modifications to the
+project, then this document is for you.
+
+# Introduction #
+
+First, let's give you some background of the project.
+
+## Licensing ##
+
+All Google Test source and pre-built packages are provided under the [New BSD License](http://www.opensource.org/licenses/bsd-license.php).
+
+## The Google Test Community ##
+
+The Google Test community exists primarily through the [discussion group](http://groups.google.com/group/googletestframework) and the GitHub repository.
+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.
+
+# Working with the Code #
+
+If you want to get your hands dirty with the code inside Google Test,
+this is the section for you.
+
+## Compiling from Source ##
+
+Once you check out the code, you can find instructions on how to
+compile it in the [README](../README.md) file.
+
+## Testing ##
+
+A testing framework is of no good if itself is not thoroughly tested.
+Tests should be written for any new code, and changes should be
+verified to not break existing tests before they are submitted for
+review. To perform the tests, follow the instructions in
+[README](../README.md) and verify that there are no failures.
+
+# Contributing Code #
+
+We are excited that Google Test is now open source, and hope to get
+great patches from the community. Before you fire up your favorite IDE
+and begin hammering away at that new feature, though, please take the
+time to read this section and understand the process. While it seems
+rigorous, we want to keep a high standard of quality in the code
+base.
+
+## Contributor License Agreements ##
+
+You must sign a Contributor License Agreement (CLA) before we can
+accept any code.  The CLA protects you and us.
+
+  * 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](http://code.google.com/legal/individual-cla-v1.0.html).
+  * If you work for a company that wants to allow you to contribute your work to Google Test, then you'll need to sign a [corporate CLA](http://code.google.com/legal/corporate-cla-v1.0.html).
+
+Follow either of the two links above to access the appropriate CLA and
+instructions for how to sign and return it.
+
+## Coding 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](http://code.google.com/p/google-styleguide/) project.  All patches will be expected
+to conform to the style outlined [here](http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml).
+
+## Updating Generated Code ##
+
+Some of Google Test's source files are generated by the Pump tool (a
+Python script).  If you need to update such files, please modify the
+source (`foo.h.pump`) and re-generate the C++ file using Pump.  You
+can read the PumpManual for details.
+
+## Submitting Patches ##
+
+Please do submit code. Here's what you need to do:
+
+  1. A submission should be a set of changes that addresses one issue in the [issue tracker](https://github.com/google/googletest/issues). 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.
+  1. 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.
+  1. Ensure that your code adheres to the [Google Test source code style](#Coding_Style.md).
+  1. Ensure that there are unit tests for your code.
+  1. Sign a Contributor License Agreement.
+  1. Create a Pull Request in the usual way.
+
+## Google Test Committers ##
+
+The current members of the Google Test engineering team are the only
+committers at present. In the great tradition of eating one's own
+dogfood, we will be requiring each new Google Test engineering team
+member to earn the right to become a committer by following the
+procedures in this document, writing consistently great code, and
+demonstrating repeatedly that he or she truly gets the zen of Google
+Test.
+
+# Release Process #
+
+We follow a typical release process:
+
+  1. A release branch named `release-X.Y` is created.
+  1. Bugs are fixed and features are added in trunk; those individual patches are merged into the release branch until it's stable.
+  1. An individual point release (the `Z` in `X.Y.Z`) is made by creating a tag from the branch.
+  1. Repeat steps 2 and 3 throughout one release cycle (as determined by features or time).
+  1. Go back to step 1 to create another release branch and so on.
+
+---
+
+This page is based on the [Making GWT Better](http://code.google.com/webtoolkit/makinggwtbetter.html) guide from the [Google Web Toolkit](http://code.google.com/webtoolkit/) project.  Except as otherwise [noted](http://code.google.com/policies.html#restrictions), the content of this page is licensed under the [Creative Commons Attribution 2.5 License](http://creativecommons.org/licenses/by/2.5/).
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Documentation.md
new file mode 100644
index 00000000..8ca1aac7
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Documentation.md
@@ -0,0 +1,14 @@
+This page lists all documentation wiki pages for Google Test **(the SVN trunk version)**
+-- **if you use a released version of Google Test, please read the
+documentation for that specific version instead.**
+
+  * [Primer](Primer.md) -- start here if you are new to Google Test.
+  * [Samples](Samples.md) -- learn from examples.
+  * [AdvancedGuide](AdvancedGuide.md) -- learn more about Google Test.
+  * [XcodeGuide](XcodeGuide.md) -- how to use Google Test in Xcode on Mac.
+  * [Frequently-Asked Questions](FAQ.md) -- check here before asking a question on the mailing list.
+
+To contribute code to Google Test, read:
+
+  * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
+  * [PumpManual](PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/FAQ.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/FAQ.md
new file mode 100644
index 00000000..5fd6cb72
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/FAQ.md
@@ -0,0 +1,1087 @@
+
+
+If you cannot find the answer to your question here, and you have read
+[Primer](Primer.md) and [AdvancedGuide](AdvancedGuide.md), send it to
+googletestframework@googlegroups.com.
+
+## Why should I use Google Test instead of my favorite C++ testing framework? ##
+
+First, let us say clearly that we don't want to get into the debate of
+which C++ testing framework is **the best**.  There exist many fine
+frameworks for writing C++ tests, and we have tremendous respect for
+the developers and users of them.  We don't think there is (or will
+be) a single best framework - you have to pick the right tool for the
+particular task you are tackling.
+
+We created Google Test because we couldn't find the right combination
+of features and conveniences in an existing framework to satisfy _our_
+needs.  The following is a list of things that _we_ like about Google
+Test.  We don't claim them to be unique to Google Test - rather, the
+combination of them makes Google Test the choice for us.  We hope this
+list can help you decide whether it is for you too.
+
+  * Google Test is designed to be portable: it doesn't require exceptions or RTTI; it works around various bugs in various compilers and environments; etc.  As a result, it works on Linux, Mac OS X, Windows and several embedded operating systems.
+  * Nonfatal assertions (`EXPECT_*`) have proven to be great time savers, as they allow a test to report multiple failures in a single edit-compile-test cycle.
+  * It's easy to write assertions that generate informative messages: you just use the stream syntax to append any additional information, e.g. `ASSERT_EQ(5, Foo(i)) << " where i = " << i;`.  It doesn't require a new set of macros or special functions.
+  * Google Test automatically detects your tests and doesn't require you to enumerate them in order to run them.
+  * Death tests are pretty handy for ensuring that your asserts in production code are triggered by the right conditions.
+  * `SCOPED_TRACE` helps you understand the context of an assertion failure when it comes from inside a sub-routine or loop.
+  * You can decide which tests to run using name patterns.  This saves time when you want to quickly reproduce a test failure.
+  * Google Test can generate XML test result reports that can be parsed by popular continuous build system like Hudson.
+  * Simple things are easy in Google Test, while hard things are possible: in addition to advanced features like [global test environments](AdvancedGuide.md#global-set-up-and-tear-down) and tests parameterized by [values](AdvancedGuide.md#value-parameterized-tests) or [types](docs/AdvancedGuide.md#typed-tests), Google Test supports various ways for the user to extend the framework -- if Google Test doesn't do something out of the box, chances are that a user can implement the feature using Google Test's public API, without changing Google Test itself.  In particular, you can:
+    * expand your testing vocabulary by defining [custom predicates](AdvancedGuide.md#predicate-assertions-for-better-error-messages),
+    * teach Google Test how to [print your types](AdvancedGuide.md#teaching-google-test-how-to-print-your-values),
+    * define your own testing macros or utilities and verify them using Google Test's [Service Provider Interface](AdvancedGuide.md#catching-failures), and
+    * reflect on the test cases or change the test output format by intercepting the [test events](AdvancedGuide.md#extending-google-test-by-handling-test-events).
+
+## I'm getting warnings when compiling Google Test.  Would you fix them? ##
+
+We strive to minimize compiler warnings Google Test generates.  Before releasing a new version, we test to make sure that it doesn't generate warnings when compiled using its CMake script on Windows, Linux, and Mac OS.
+
+Unfortunately, this doesn't mean you are guaranteed to see no warnings when compiling Google Test in your environment:
+
+  * You may be using a different compiler as we use, or a different version of the same compiler.  We cannot possibly test for all compilers.
+  * You may be compiling on a different platform as we do.
+  * Your project may be using different compiler flags as we do.
+
+It is not always possible to make Google Test warning-free for everyone.  Or, it may not be desirable if the warning is rarely enabled and fixing the violations makes the code more complex.
+
+If you see warnings when compiling Google Test, we suggest that you use the `-isystem` flag (assuming your are using GCC) to mark Google Test headers as system headers.  That'll suppress warnings from Google Test headers.
+
+## Why should not test case names and test names contain underscore? ##
+
+Underscore (`_`) is special, as C++ reserves the following to be used by
+the compiler and the standard library:
+
+  1. any identifier that starts with an `_` followed by an upper-case letter, and
+  1. any identifier that containers two consecutive underscores (i.e. `__`) _anywhere_ in its name.
+
+User code is _prohibited_ from using such identifiers.
+
+Now let's look at what this means for `TEST` and `TEST_F`.
+
+Currently `TEST(TestCaseName, TestName)` generates a class named
+`TestCaseName_TestName_Test`.  What happens if `TestCaseName` or `TestName`
+contains `_`?
+
+  1. If `TestCaseName` starts with an `_` followed by an upper-case letter (say, `_Foo`), we end up with `_Foo_TestName_Test`, which is reserved and thus invalid.
+  1. If `TestCaseName` ends with an `_` (say, `Foo_`), we get `Foo__TestName_Test`, which is invalid.
+  1. If `TestName` starts with an `_` (say, `_Bar`), we get `TestCaseName__Bar_Test`, which is invalid.
+  1. If `TestName` ends with an `_` (say, `Bar_`), we get `TestCaseName_Bar__Test`, which is invalid.
+
+So clearly `TestCaseName` and `TestName` cannot start or end with `_`
+(Actually, `TestCaseName` can start with `_` -- as long as the `_` isn't
+followed by an upper-case letter.  But that's getting complicated.  So
+for simplicity we just say that it cannot start with `_`.).
+
+It may seem fine for `TestCaseName` and `TestName` to contain `_` in the
+middle.  However, consider this:
+``` cpp
+TEST(Time, Flies_Like_An_Arrow) { ... }
+TEST(Time_Flies, Like_An_Arrow) { ... }
+```
+
+Now, the two `TEST`s will both generate the same class
+(`Time_Files_Like_An_Arrow_Test`).  That's not good.
+
+So for simplicity, we just ask the users to avoid `_` in `TestCaseName`
+and `TestName`.  The rule is more constraining than necessary, but it's
+simple and easy to remember.  It also gives Google Test some wiggle
+room in case its implementation needs to change in the future.
+
+If you violate the rule, there may not be immediately consequences,
+but your test may (just may) break with a new compiler (or a new
+version of the compiler you are using) or with a new version of Google
+Test.  Therefore it's best to follow the rule.
+
+## Why is it not recommended to install a pre-compiled copy of Google Test (for example, into /usr/local)? ##
+
+In the early days, we said that you could install
+compiled Google Test libraries on `*`nix systems using `make install`.
+Then every user of your machine can write tests without
+recompiling Google Test.
+
+This seemed like a good idea, but it has a
+got-cha: every user needs to compile his tests using the _same_ compiler
+flags used to compile the installed Google Test libraries; otherwise
+he may run into undefined behaviors (i.e. the tests can behave
+strangely and may even crash for no obvious reasons).
+
+Why?  Because C++ has this thing called the One-Definition Rule: if
+two C++ source files contain different definitions of the same
+class/function/variable, and you link them together, you violate the
+rule.  The linker may or may not catch the error (in many cases it's
+not required by the C++ standard to catch the violation).  If it
+doesn't, you get strange run-time behaviors that are unexpected and
+hard to debug.
+
+If you compile Google Test and your test code using different compiler
+flags, they may see different definitions of the same
+class/function/variable (e.g. due to the use of `#if` in Google Test).
+Therefore, for your sanity, we recommend to avoid installing pre-compiled
+Google Test libraries.  Instead, each project should compile
+Google Test itself such that it can be sure that the same flags are
+used for both Google Test and the tests.
+
+## How do I generate 64-bit binaries on Windows (using Visual Studio 2008)? ##
+
+(Answered by Trevor Robinson)
+
+Load the supplied Visual Studio solution file, either `msvc\gtest-md.sln` or
+`msvc\gtest.sln`. Go through the migration wizard to migrate the
+solution and project files to Visual Studio 2008. Select
+`Configuration Manager...` from the `Build` menu. Select `<New...>` from
+the `Active solution platform` dropdown.  Select `x64` from the new
+platform dropdown, leave `Copy settings from` set to `Win32` and
+`Create new project platforms` checked, then click `OK`. You now have
+`Win32` and `x64` platform configurations, selectable from the
+`Standard` toolbar, which allow you to toggle between building 32-bit or
+64-bit binaries (or both at once using Batch Build).
+
+In order to prevent build output files from overwriting one another,
+you'll need to change the `Intermediate Directory` settings for the
+newly created platform configuration across all the projects. To do
+this, multi-select (e.g. using shift-click) all projects (but not the
+solution) in the `Solution Explorer`. Right-click one of them and
+select `Properties`. In the left pane, select `Configuration Properties`,
+and from the `Configuration` dropdown, select `All Configurations`.
+Make sure the selected platform is `x64`. For the
+`Intermediate Directory` setting, change the value from
+`$(PlatformName)\$(ConfigurationName)` to
+`$(OutDir)\$(ProjectName)`. Click `OK` and then build the
+solution. When the build is complete, the 64-bit binaries will be in
+the `msvc\x64\Debug` directory.
+
+## Can I use Google Test on MinGW? ##
+
+We haven't tested this ourselves, but Per Abrahamsen reported that he
+was able to compile and install Google Test successfully when using
+MinGW from Cygwin.  You'll need to configure it with:
+
+`PATH/TO/configure CC="gcc -mno-cygwin" CXX="g++ -mno-cygwin"`
+
+You should be able to replace the `-mno-cygwin` option with direct links
+to the real MinGW binaries, but we haven't tried that.
+
+Caveats:
+
+  * There are many warnings when compiling.
+  * `make check` will produce some errors as not all tests for Google Test itself are compatible with MinGW.
+
+We also have reports on successful cross compilation of Google Test
+MinGW binaries on Linux using
+[these instructions](http://wiki.wxwidgets.org/Cross-Compiling_Under_Linux#Cross-compiling_under_Linux_for_MS_Windows)
+on the WxWidgets site.
+
+Please contact `googletestframework@googlegroups.com` if you are
+interested in improving the support for MinGW.
+
+## Why does Google Test support EXPECT\_EQ(NULL, ptr) and ASSERT\_EQ(NULL, ptr) but not EXPECT\_NE(NULL, ptr) and ASSERT\_NE(NULL, ptr)? ##
+
+Due to some peculiarity of C++, it requires some non-trivial template
+meta programming tricks to support using `NULL` as an argument of the
+`EXPECT_XX()` and `ASSERT_XX()` macros. Therefore we only do it where
+it's most needed (otherwise we make the implementation of Google Test
+harder to maintain and more error-prone than necessary).
+
+The `EXPECT_EQ()` macro takes the _expected_ value as its first
+argument and the _actual_ value as the second. It's reasonable that
+someone wants to write `EXPECT_EQ(NULL, some_expression)`, and this
+indeed was requested several times. Therefore we implemented it.
+
+The need for `EXPECT_NE(NULL, ptr)` isn't nearly as strong. When the
+assertion fails, you already know that `ptr` must be `NULL`, so it
+doesn't add any information to print ptr in this case. That means
+`EXPECT_TRUE(ptr != NULL)` works just as well.
+
+If we were to support `EXPECT_NE(NULL, ptr)`, for consistency we'll
+have to support `EXPECT_NE(ptr, NULL)` as well, as unlike `EXPECT_EQ`,
+we don't have a convention on the order of the two arguments for
+`EXPECT_NE`. This means using the template meta programming tricks
+twice in the implementation, making it even harder to understand and
+maintain. We believe the benefit doesn't justify the cost.
+
+Finally, with the growth of Google Mock's [matcher](../../googlemock/docs/CookBook.md#using-matchers-in-google-test-assertions) library, we are
+encouraging people to use the unified `EXPECT_THAT(value, matcher)`
+syntax more often in tests. One significant advantage of the matcher
+approach is that matchers can be easily combined to form new matchers,
+while the `EXPECT_NE`, etc, macros cannot be easily
+combined. Therefore we want to invest more in the matchers than in the
+`EXPECT_XX()` macros.
+
+## Does Google Test support running tests in parallel? ##
+
+Test runners tend to be tightly coupled with the build/test
+environment, and Google Test doesn't try to solve the problem of
+running tests in parallel.  Instead, we tried to make Google Test work
+nicely with test runners.  For example, Google Test's XML report
+contains the time spent on each test, and its `gtest_list_tests` and
+`gtest_filter` flags can be used for splitting the execution of test
+methods into multiple processes.  These functionalities can help the
+test runner run the tests in parallel.
+
+## Why don't Google Test run the tests in different threads to speed things up? ##
+
+It's difficult to write thread-safe code.  Most tests are not written
+with thread-safety in mind, and thus may not work correctly in a
+multi-threaded setting.
+
+If you think about it, it's already hard to make your code work when
+you know what other threads are doing.  It's much harder, and
+sometimes even impossible, to make your code work when you don't know
+what other threads are doing (remember that test methods can be added,
+deleted, or modified after your test was written).  If you want to run
+the tests in parallel, you'd better run them in different processes.
+
+## Why aren't Google Test assertions implemented using exceptions? ##
+
+Our original motivation was to be able to use Google Test in projects
+that disable exceptions.  Later we realized some additional benefits
+of this approach:
+
+  1. Throwing in a destructor is undefined behavior in C++.  Not using exceptions means Google Test's assertions are safe to use in destructors.
+  1. The `EXPECT_*` family of macros will continue even after a failure, allowing multiple failures in a `TEST` to be reported in a single run. This is a popular feature, as in C++ the edit-compile-test cycle is usually quite long and being able to fixing more than one thing at a time is a blessing.
+  1. If assertions are implemented using exceptions, a test may falsely ignore a failure if it's caught by user code:
+``` cpp
+try { ... ASSERT_TRUE(...) ... }
+catch (...) { ... }
+```
+The above code will pass even if the `ASSERT_TRUE` throws.  While it's unlikely for someone to write this in a test, it's possible to run into this pattern when you write assertions in callbacks that are called by the code under test.
+
+The downside of not using exceptions is that `ASSERT_*` (implemented
+using `return`) will only abort the current function, not the current
+`TEST`.
+
+## Why do we use two different macros for tests with and without fixtures? ##
+
+Unfortunately, C++'s macro system doesn't allow us to use the same
+macro for both cases.  One possibility is to provide only one macro
+for tests with fixtures, and require the user to define an empty
+fixture sometimes:
+
+``` cpp
+class FooTest : public ::testing::Test {};
+
+TEST_F(FooTest, DoesThis) { ... }
+```
+or
+``` cpp
+typedef ::testing::Test FooTest;
+
+TEST_F(FooTest, DoesThat) { ... }
+```
+
+Yet, many people think this is one line too many. :-) Our goal was to
+make it really easy to write tests, so we tried to make simple tests
+trivial to create.  That means using a separate macro for such tests.
+
+We think neither approach is ideal, yet either of them is reasonable.
+In the end, it probably doesn't matter much either way.
+
+## Why don't we use structs as test fixtures? ##
+
+We like to use structs only when representing passive data.  This
+distinction between structs and classes is good for documenting the
+intent of the code's author.  Since test fixtures have logic like
+`SetUp()` and `TearDown()`, they are better defined as classes.
+
+## Why are death tests implemented as assertions instead of using a test runner? ##
+
+Our goal was to make death tests as convenient for a user as C++
+possibly allows.  In particular:
+
+  * The runner-style requires to split the information into two pieces: the definition of the death test itself, and the specification for the runner on how to run the death test and what to expect.  The death test would be written in C++, while the runner spec may or may not be.  A user needs to carefully keep the two in sync. `ASSERT_DEATH(statement, expected_message)` specifies all necessary information in one place, in one language, without boilerplate code. It is very declarative.
+  * `ASSERT_DEATH` has a similar syntax and error-reporting semantics as other Google Test assertions, and thus is easy to learn.
+  * `ASSERT_DEATH` can be mixed with other assertions and other logic at your will.  You are not limited to one death test per test method. For example, you can write something like:
+``` cpp
+    if (FooCondition()) {
+      ASSERT_DEATH(Bar(), "blah");
+    } else {
+      ASSERT_EQ(5, Bar());
+    }
+```
+If you prefer one death test per test method, you can write your tests in that style too, but we don't want to impose that on the users.  The fewer artificial limitations the better.
+  * `ASSERT_DEATH` can reference local variables in the current function, and you can decide how many death tests you want based on run-time information.  For example,
+``` cpp
+    const int count = GetCount();  // Only known at run time.
+    for (int i = 1; i <= count; i++) {
+      ASSERT_DEATH({
+        double* buffer = new double[i];
+        ... initializes buffer ...
+        Foo(buffer, i)
+      }, "blah blah");
+    }
+```
+The runner-based approach tends to be more static and less flexible, or requires more user effort to get this kind of flexibility.
+
+Another interesting thing about `ASSERT_DEATH` is that it calls `fork()`
+to create a child process to run the death test.  This is lightening
+fast, as `fork()` uses copy-on-write pages and incurs almost zero
+overhead, and the child process starts from the user-supplied
+statement directly, skipping all global and local initialization and
+any code leading to the given statement.  If you launch the child
+process from scratch, it can take seconds just to load everything and
+start running if the test links to many libraries dynamically.
+
+## My death test modifies some state, but the change seems lost after the death test finishes. Why? ##
+
+Death tests (`EXPECT_DEATH`, etc) are executed in a sub-process s.t. the
+expected crash won't kill the test program (i.e. the parent process). As a
+result, any in-memory side effects they incur are observable in their
+respective sub-processes, but not in the parent process. You can think of them
+as running in a parallel universe, more or less.
+
+## The compiler complains about "undefined references" to some static const member variables, but I did define them in the class body. What's wrong? ##
+
+If your class has a static data member:
+
+``` cpp
+// foo.h
+class Foo {
+  ...
+  static const int kBar = 100;
+};
+```
+
+You also need to define it _outside_ of the class body in `foo.cc`:
+
+``` cpp
+const int Foo::kBar;  // No initializer here.
+```
+
+Otherwise your code is **invalid C++**, and may break in unexpected ways. In
+particular, using it in Google Test comparison assertions (`EXPECT_EQ`, etc)
+will generate an "undefined reference" linker error.
+
+## I have an interface that has several implementations. Can I write a set of tests once and repeat them over all the implementations? ##
+
+Google Test doesn't yet have good support for this kind of tests, or
+data-driven tests in general. We hope to be able to make improvements in this
+area soon.
+
+## Can I derive a test fixture from another? ##
+
+Yes.
+
+Each test fixture has a corresponding and same named test case. This means only
+one test case can use a particular fixture. Sometimes, however, multiple test
+cases may want to use the same or slightly different fixtures. For example, you
+may want to make sure that all of a GUI library's test cases don't leak
+important system resources like fonts and brushes.
+
+In Google Test, you share a fixture among test cases by putting the shared
+logic in a base test fixture, then deriving from that base a separate fixture
+for each test case that wants to use this common logic. You then use `TEST_F()`
+to write tests using each derived fixture.
+
+Typically, your code looks like this:
+
+``` cpp
+// Defines a base test fixture.
+class BaseTest : public ::testing::Test {
+  protected:
+   ...
+};
+
+// Derives a fixture FooTest from BaseTest.
+class FooTest : public BaseTest {
+  protected:
+    virtual void SetUp() {
+      BaseTest::SetUp();  // Sets up the base fixture first.
+      ... additional set-up work ...
+    }
+    virtual void TearDown() {
+      ... clean-up work for FooTest ...
+      BaseTest::TearDown();  // Remember to tear down the base fixture
+                             // after cleaning up FooTest!
+    }
+    ... functions and variables for FooTest ...
+};
+
+// Tests that use the fixture FooTest.
+TEST_F(FooTest, Bar) { ... }
+TEST_F(FooTest, Baz) { ... }
+
+... additional fixtures derived from BaseTest ...
+```
+
+If necessary, you can continue to derive test fixtures from a derived fixture.
+Google Test has no limit on how deep the hierarchy can be.
+
+For a complete example using derived test fixtures, see
+[sample5](../samples/sample5_unittest.cc).
+
+## My compiler complains "void value not ignored as it ought to be." What does this mean? ##
+
+You're probably using an `ASSERT_*()` in a function that doesn't return `void`.
+`ASSERT_*()` can only be used in `void` functions.
+
+## My death test hangs (or seg-faults). How do I fix it? ##
+
+In Google Test, death tests are run in a child process and the way they work is
+delicate. To write death tests you really need to understand how they work.
+Please make sure you have read this.
+
+In particular, death tests don't like having multiple threads in the parent
+process. So the first thing you can try is to eliminate creating threads
+outside of `EXPECT_DEATH()`.
+
+Sometimes this is impossible as some library you must use may be creating
+threads before `main()` is even reached. In this case, you can try to minimize
+the chance of conflicts by either moving as many activities as possible inside
+`EXPECT_DEATH()` (in the extreme case, you want to move everything inside), or
+leaving as few things as possible in it. Also, you can try to set the death
+test style to `"threadsafe"`, which is safer but slower, and see if it helps.
+
+If you go with thread-safe death tests, remember that they rerun the test
+program from the beginning in the child process. Therefore make sure your
+program can run side-by-side with itself and is deterministic.
+
+In the end, this boils down to good concurrent programming. You have to make
+sure that there is no race conditions or dead locks in your program. No silver
+bullet - sorry!
+
+## Should I use the constructor/destructor of the test fixture or the set-up/tear-down function? ##
+
+The first thing to remember is that Google Test does not reuse the
+same test fixture object across multiple tests. For each `TEST_F`,
+Google Test will create a fresh test fixture object, _immediately_
+call `SetUp()`, run the test body, call `TearDown()`, and then
+_immediately_ delete the test fixture object.
+
+When you need to write per-test set-up and tear-down logic, you have
+the choice between using the test fixture constructor/destructor or
+`SetUp()/TearDown()`. The former is usually preferred, as it has the
+following benefits:
+
+  * By initializing a member variable in the constructor, we have the option to make it `const`, which helps prevent accidental changes to its value and makes the tests more obviously correct.
+  * In case we need to subclass the test fixture class, the subclass' constructor is guaranteed to call the base class' constructor first, and the subclass' destructor is guaranteed to call the base class' destructor afterward. With `SetUp()/TearDown()`, a subclass may make the mistake of forgetting to call the base class' `SetUp()/TearDown()` or call them at the wrong moment.
+
+You may still want to use `SetUp()/TearDown()` in the following rare cases:
+  * If the tear-down operation could throw an exception, you must use `TearDown()` as opposed to the destructor, as throwing in a destructor leads to undefined behavior and usually will kill your program right away. Note that many standard libraries (like STL) may throw when exceptions are enabled in the compiler. Therefore you should prefer `TearDown()` if you want to write portable tests that work with or without exceptions.
+  * The assertion macros throw an exception when flag `--gtest_throw_on_failure` is specified. Therefore, you shouldn't use Google Test assertions in a destructor if you plan to run your tests with this flag.
+  * In a constructor or destructor, you cannot make a virtual function call on this object. (You can call a method declared as virtual, but it will be statically bound.) Therefore, if you need to call a method that will be overriden in a derived class, you have to use `SetUp()/TearDown()`.
+
+## The compiler complains "no matching function to call" when I use ASSERT\_PREDn. How do I fix it? ##
+
+If the predicate function you use in `ASSERT_PRED*` or `EXPECT_PRED*` is
+overloaded or a template, the compiler will have trouble figuring out which
+overloaded version it should use. `ASSERT_PRED_FORMAT*` and
+`EXPECT_PRED_FORMAT*` don't have this problem.
+
+If you see this error, you might want to switch to
+`(ASSERT|EXPECT)_PRED_FORMAT*`, which will also give you a better failure
+message. If, however, that is not an option, you can resolve the problem by
+explicitly telling the compiler which version to pick.
+
+For example, suppose you have
+
+``` cpp
+bool IsPositive(int n) {
+  return n > 0;
+}
+bool IsPositive(double x) {
+  return x > 0;
+}
+```
+
+you will get a compiler error if you write
+
+``` cpp
+EXPECT_PRED1(IsPositive, 5);
+```
+
+However, this will work:
+
+``` cpp
+EXPECT_PRED1(*static_cast<bool (*)(int)>*(IsPositive), 5);
+```
+
+(The stuff inside the angled brackets for the `static_cast` operator is the
+type of the function pointer for the `int`-version of `IsPositive()`.)
+
+As another example, when you have a template function
+
+``` cpp
+template <typename T>
+bool IsNegative(T x) {
+  return x < 0;
+}
+```
+
+you can use it in a predicate assertion like this:
+
+``` cpp
+ASSERT_PRED1(IsNegative*<int>*, -5);
+```
+
+Things are more interesting if your template has more than one parameters. The
+following won't compile:
+
+``` cpp
+ASSERT_PRED2(*GreaterThan<int, int>*, 5, 0);
+```
+
+
+as the C++ pre-processor thinks you are giving `ASSERT_PRED2` 4 arguments,
+which is one more than expected. The workaround is to wrap the predicate
+function in parentheses:
+
+``` cpp
+ASSERT_PRED2(*(GreaterThan<int, int>)*, 5, 0);
+```
+
+
+## My compiler complains about "ignoring return value" when I call RUN\_ALL\_TESTS(). Why? ##
+
+Some people had been ignoring the return value of `RUN_ALL_TESTS()`. That is,
+instead of
+
+``` cpp
+return RUN_ALL_TESTS();
+```
+
+they write
+
+``` cpp
+RUN_ALL_TESTS();
+```
+
+This is wrong and dangerous. A test runner needs to see the return value of
+`RUN_ALL_TESTS()` in order to determine if a test has passed. If your `main()`
+function ignores it, your test will be considered successful even if it has a
+Google Test assertion failure. Very bad.
+
+To help the users avoid this dangerous bug, the implementation of
+`RUN_ALL_TESTS()` causes gcc to raise this warning, when the return value is
+ignored. If you see this warning, the fix is simple: just make sure its value
+is used as the return value of `main()`.
+
+## My compiler complains that a constructor (or destructor) cannot return a value. What's going on? ##
+
+Due to a peculiarity of C++, in order to support the syntax for streaming
+messages to an `ASSERT_*`, e.g.
+
+``` cpp
+ASSERT_EQ(1, Foo()) << "blah blah" << foo;
+```
+
+we had to give up using `ASSERT*` and `FAIL*` (but not `EXPECT*` and
+`ADD_FAILURE*`) in constructors and destructors. The workaround is to move the
+content of your constructor/destructor to a private void member function, or
+switch to `EXPECT_*()` if that works. This section in the user's guide explains
+it.
+
+## My set-up function is not called. Why? ##
+
+C++ is case-sensitive. It should be spelled as `SetUp()`.  Did you
+spell it as `Setup()`?
+
+Similarly, sometimes people spell `SetUpTestCase()` as `SetupTestCase()` and
+wonder why it's never called.
+
+## How do I jump to the line of a failure in Emacs directly? ##
+
+Google Test's failure message format is understood by Emacs and many other
+IDEs, like acme and XCode. If a Google Test message is in a compilation buffer
+in Emacs, then it's clickable. You can now hit `enter` on a message to jump to
+the corresponding source code, or use `C-x `` to jump to the next failure.
+
+## I have several test cases which share the same test fixture logic, do I have to define a new test fixture class for each of them? This seems pretty tedious. ##
+
+You don't have to. Instead of
+
+``` cpp
+class FooTest : public BaseTest {};
+
+TEST_F(FooTest, Abc) { ... }
+TEST_F(FooTest, Def) { ... }
+
+class BarTest : public BaseTest {};
+
+TEST_F(BarTest, Abc) { ... }
+TEST_F(BarTest, Def) { ... }
+```
+
+you can simply `typedef` the test fixtures:
+``` cpp
+typedef BaseTest FooTest;
+
+TEST_F(FooTest, Abc) { ... }
+TEST_F(FooTest, Def) { ... }
+
+typedef BaseTest BarTest;
+
+TEST_F(BarTest, Abc) { ... }
+TEST_F(BarTest, Def) { ... }
+```
+
+## The Google Test output is buried in a whole bunch of log messages. What do I do? ##
+
+The Google Test output is meant to be a concise and human-friendly report. If
+your test generates textual output itself, it will mix with the Google Test
+output, making it hard to read. However, there is an easy solution to this
+problem.
+
+Since most log messages go to stderr, we decided to let Google Test output go
+to stdout. This way, you can easily separate the two using redirection. For
+example:
+```
+./my_test > googletest_output.txt
+```
+
+## Why should I prefer test fixtures over global variables? ##
+
+There are several good reasons:
+  1. It's likely your test needs to change the states of its global variables. This makes it difficult to keep side effects from escaping one test and contaminating others, making debugging difficult. By using fixtures, each test has a fresh set of variables that's different (but with the same names). Thus, tests are kept independent of each other.
+  1. Global variables pollute the global namespace.
+  1. Test fixtures can be reused via subclassing, which cannot be done easily with global variables. This is useful if many test cases have something in common.
+
+## How do I test private class members without writing FRIEND\_TEST()s? ##
+
+You should try to write testable code, which means classes should be easily
+tested from their public interface. One way to achieve this is the Pimpl idiom:
+you move all private members of a class into a helper class, and make all
+members of the helper class public.
+
+You have several other options that don't require using `FRIEND_TEST`:
+  * Write the tests as members of the fixture class:
+``` cpp
+class Foo {
+  friend class FooTest;
+  ...
+};
+
+class FooTest : public ::testing::Test {
+ protected:
+  ...
+  void Test1() {...} // This accesses private members of class Foo.
+  void Test2() {...} // So does this one.
+};
+
+TEST_F(FooTest, Test1) {
+  Test1();
+}
+
+TEST_F(FooTest, Test2) {
+  Test2();
+}
+```
+  * In the fixture class, write accessors for the tested class' private members, then use the accessors in your tests:
+``` cpp
+class Foo {
+  friend class FooTest;
+  ...
+};
+
+class FooTest : public ::testing::Test {
+ protected:
+  ...
+  T1 get_private_member1(Foo* obj) {
+    return obj->private_member1_;
+  }
+};
+
+TEST_F(FooTest, Test1) {
+  ...
+  get_private_member1(x)
+  ...
+}
+```
+  * If the methods are declared **protected**, you can change their access level in a test-only subclass:
+``` cpp
+class YourClass {
+  ...
+ protected: // protected access for testability.
+  int DoSomethingReturningInt();
+  ...
+};
+
+// in the your_class_test.cc file:
+class TestableYourClass : public YourClass {
+  ...
+ public: using YourClass::DoSomethingReturningInt; // changes access rights
+  ...
+};
+
+TEST_F(YourClassTest, DoSomethingTest) {
+  TestableYourClass obj;
+  assertEquals(expected_value, obj.DoSomethingReturningInt());
+}
+```
+
+## How do I test private class static members without writing FRIEND\_TEST()s? ##
+
+We find private static methods clutter the header file.  They are
+implementation details and ideally should be kept out of a .h. So often I make
+them free functions instead.
+
+Instead of:
+``` cpp
+// foo.h
+class Foo {
+  ...
+ private:
+  static bool Func(int n);
+};
+
+// foo.cc
+bool Foo::Func(int n) { ... }
+
+// foo_test.cc
+EXPECT_TRUE(Foo::Func(12345));
+```
+
+You probably should better write:
+``` cpp
+// foo.h
+class Foo {
+  ...
+};
+
+// foo.cc
+namespace internal {
+  bool Func(int n) { ... }
+}
+
+// foo_test.cc
+namespace internal {
+  bool Func(int n);
+}
+
+EXPECT_TRUE(internal::Func(12345));
+```
+
+## I would like to run a test several times with different parameters. Do I need to write several similar copies of it? ##
+
+No. You can use a feature called [value-parameterized tests](AdvancedGuide.md#Value_Parameterized_Tests) which
+lets you repeat your tests with different parameters, without defining it more than once.
+
+## How do I test a file that defines main()? ##
+
+To test a `foo.cc` file, you need to compile and link it into your unit test
+program. However, when the file contains a definition for the `main()`
+function, it will clash with the `main()` of your unit test, and will result in
+a build error.
+
+The right solution is to split it into three files:
+  1. `foo.h` which contains the declarations,
+  1. `foo.cc` which contains the definitions except `main()`, and
+  1. `foo_main.cc` which contains nothing but the definition of `main()`.
+
+Then `foo.cc` can be easily tested.
+
+If you are adding tests to an existing file and don't want an intrusive change
+like this, there is a hack: just include the entire `foo.cc` file in your unit
+test. For example:
+``` cpp
+// File foo_unittest.cc
+
+// The headers section
+...
+
+// Renames main() in foo.cc to make room for the unit test main()
+#define main FooMain
+
+#include "a/b/foo.cc"
+
+// The tests start here.
+...
+```
+
+
+However, please remember this is a hack and should only be used as the last
+resort.
+
+## What can the statement argument in ASSERT\_DEATH() be? ##
+
+`ASSERT_DEATH(_statement_, _regex_)` (or any death assertion macro) can be used
+wherever `_statement_` is valid. So basically `_statement_` can be any C++
+statement that makes sense in the current context. In particular, it can
+reference global and/or local variables, and can be:
+  * a simple function call (often the case),
+  * a complex expression, or
+  * a compound statement.
+
+Some examples are shown here:
+
+``` cpp
+// A death test can be a simple function call.
+TEST(MyDeathTest, FunctionCall) {
+  ASSERT_DEATH(Xyz(5), "Xyz failed");
+}
+
+// Or a complex expression that references variables and functions.
+TEST(MyDeathTest, ComplexExpression) {
+  const bool c = Condition();
+  ASSERT_DEATH((c ? Func1(0) : object2.Method("test")),
+               "(Func1|Method) failed");
+}
+
+// Death assertions can be used any where in a function. In
+// particular, they can be inside a loop.
+TEST(MyDeathTest, InsideLoop) {
+  // Verifies that Foo(0), Foo(1), ..., and Foo(4) all die.
+  for (int i = 0; i < 5; i++) {
+    EXPECT_DEATH_M(Foo(i), "Foo has \\d+ errors",
+                   ::testing::Message() << "where i is " << i);
+  }
+}
+
+// A death assertion can contain a compound statement.
+TEST(MyDeathTest, CompoundStatement) {
+  // Verifies that at lease one of Bar(0), Bar(1), ..., and
+  // Bar(4) dies.
+  ASSERT_DEATH({
+    for (int i = 0; i < 5; i++) {
+      Bar(i);
+    }
+  },
+  "Bar has \\d+ errors");}
+```
+
+`googletest_unittest.cc` contains more examples if you are interested.
+
+## What syntax does the regular expression in ASSERT\_DEATH use? ##
+
+On POSIX systems, Google Test uses the POSIX Extended regular
+expression syntax
+(http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
+On Windows, it uses a limited variant of regular expression
+syntax. For more details, see the
+[regular expression syntax](AdvancedGuide.md#Regular_Expression_Syntax).
+
+## I have a fixture class Foo, but TEST\_F(Foo, Bar) gives me error "no matching function for call to Foo::Foo()". Why? ##
+
+Google Test needs to be able to create objects of your test fixture class, so
+it must have a default constructor. Normally the compiler will define one for
+you. However, there are cases where you have to define your own:
+  * If you explicitly declare a non-default constructor for class `Foo`, then you need to define a default constructor, even if it would be empty.
+  * If `Foo` has a const non-static data member, then you have to define the default constructor _and_ initialize the const member in the initializer list of the constructor. (Early versions of `gcc` doesn't force you to initialize the const member. It's a bug that has been fixed in `gcc 4`.)
+
+## Why does ASSERT\_DEATH complain about previous threads that were already joined? ##
+
+With the Linux pthread library, there is no turning back once you cross the
+line from single thread to multiple threads. The first time you create a
+thread, a manager thread is created in addition, so you get 3, not 2, threads.
+Later when the thread you create joins the main thread, the thread count
+decrements by 1, but the manager thread will never be killed, so you still have
+2 threads, which means you cannot safely run a death test.
+
+The new NPTL thread library doesn't suffer from this problem, as it doesn't
+create a manager thread. However, if you don't control which machine your test
+runs on, you shouldn't depend on this.
+
+## Why does Google Test require the entire test case, instead of individual tests, to be named FOODeathTest when it uses ASSERT\_DEATH? ##
+
+Google Test does not interleave tests from different test cases. That is, it
+runs all tests in one test case first, and then runs all tests in the next test
+case, and so on. Google Test does this because it needs to set up a test case
+before the first test in it is run, and tear it down afterwords. Splitting up
+the test case would require multiple set-up and tear-down processes, which is
+inefficient and makes the semantics unclean.
+
+If we were to determine the order of tests based on test name instead of test
+case name, then we would have a problem with the following situation:
+
+``` cpp
+TEST_F(FooTest, AbcDeathTest) { ... }
+TEST_F(FooTest, Uvw) { ... }
+
+TEST_F(BarTest, DefDeathTest) { ... }
+TEST_F(BarTest, Xyz) { ... }
+```
+
+Since `FooTest.AbcDeathTest` needs to run before `BarTest.Xyz`, and we don't
+interleave tests from different test cases, we need to run all tests in the
+`FooTest` case before running any test in the `BarTest` case. This contradicts
+with the requirement to run `BarTest.DefDeathTest` before `FooTest.Uvw`.
+
+## But I don't like calling my entire test case FOODeathTest when it contains both death tests and non-death tests. What do I do? ##
+
+You don't have to, but if you like, you may split up the test case into
+`FooTest` and `FooDeathTest`, where the names make it clear that they are
+related:
+
+``` cpp
+class FooTest : public ::testing::Test { ... };
+
+TEST_F(FooTest, Abc) { ... }
+TEST_F(FooTest, Def) { ... }
+
+typedef FooTest FooDeathTest;
+
+TEST_F(FooDeathTest, Uvw) { ... EXPECT_DEATH(...) ... }
+TEST_F(FooDeathTest, Xyz) { ... ASSERT_DEATH(...) ... }
+```
+
+## The compiler complains about "no match for 'operator<<'" when I use an assertion. What gives? ##
+
+If you use a user-defined type `FooType` in an assertion, you must make sure
+there is an `std::ostream& operator<<(std::ostream&, const FooType&)` function
+defined such that we can print a value of `FooType`.
+
+In addition, if `FooType` is declared in a name space, the `<<` operator also
+needs to be defined in the _same_ name space.
+
+## How do I suppress the memory leak messages on Windows? ##
+
+Since the statically initialized Google Test singleton requires allocations on
+the heap, the Visual C++ memory leak detector will report memory leaks at the
+end of the program run. The easiest way to avoid this is to use the
+`_CrtMemCheckpoint` and `_CrtMemDumpAllObjectsSince` calls to not report any
+statically initialized heap objects. See MSDN for more details and additional
+heap check/debug routines.
+
+## I am building my project with Google Test in Visual Studio and all I'm getting is a bunch of linker errors (or warnings). Help! ##
+
+You may get a number of the following linker error or warnings if you
+attempt to link your test project with the Google Test library when
+your project and the are not built using the same compiler settings.
+
+  * LNK2005: symbol already defined in object
+  * LNK4217: locally defined symbol 'symbol' imported in function 'function'
+  * LNK4049: locally defined symbol 'symbol' imported
+
+The Google Test project (gtest.vcproj) has the Runtime Library option
+set to /MT (use multi-threaded static libraries, /MTd for debug). If
+your project uses something else, for example /MD (use multi-threaded
+DLLs, /MDd for debug), you need to change the setting in the Google
+Test project to match your project's.
+
+To update this setting open the project properties in the Visual
+Studio IDE then select the branch Configuration Properties | C/C++ |
+Code Generation and change the option "Runtime Library".  You may also try
+using gtest-md.vcproj instead of gtest.vcproj.
+
+## I put my tests in a library and Google Test doesn't run them. What's happening? ##
+Have you read a
+[warning](Primer.md#important-note-for-visual-c-users) on
+the Google Test Primer page?
+
+## I want to use Google Test with Visual Studio but don't know where to start. ##
+Many people are in your position and one of the posted his solution to
+our mailing list.
+
+## I am seeing compile errors mentioning std::type\_traits when I try to use Google Test on Solaris. ##
+Google Test uses parts of the standard C++ library that SunStudio does not support.
+Our users reported success using alternative implementations. Try running the build after runing this commad:
+
+`export CC=cc CXX=CC CXXFLAGS='-library=stlport4'`
+
+## How can my code detect if it is running in a test? ##
+
+If you write code that sniffs whether it's running in a test and does
+different things accordingly, you are leaking test-only logic into
+production code and there is no easy way to ensure that the test-only
+code paths aren't run by mistake in production.  Such cleverness also
+leads to
+[Heisenbugs](http://en.wikipedia.org/wiki/Unusual_software_bug#Heisenbug).
+Therefore we strongly advise against the practice, and Google Test doesn't
+provide a way to do it.
+
+In general, the recommended way to cause the code to behave
+differently under test is [dependency injection](http://jamesshore.com/Blog/Dependency-Injection-Demystified.html).
+You can inject different functionality from the test and from the
+production code.  Since your production code doesn't link in the
+for-test logic at all, there is no danger in accidentally running it.
+
+However, if you _really_, _really_, _really_ have no choice, and if
+you follow the rule of ending your test program names with `_test`,
+you can use the _horrible_ hack of sniffing your executable name
+(`argv[0]` in `main()`) to know whether the code is under test.
+
+## Google Test defines a macro that clashes with one defined by another library. How do I deal with that? ##
+
+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 Google Test macro clashes with another
+library, you can force Google Test to rename its macro to avoid the
+conflict.
+
+Specifically, if both Google Test and some other code define macro
+`FOO`, you can add
+```
+  -DGTEST_DONT_DEFINE_FOO=1
+```
+to the compiler flags to tell Google Test to change the macro's name
+from `FOO` to `GTEST_FOO`. For example, with `-DGTEST_DONT_DEFINE_TEST=1`, you'll need to write
+``` cpp
+  GTEST_TEST(SomeTest, DoesThis) { ... }
+```
+instead of
+``` cpp
+  TEST(SomeTest, DoesThis) { ... }
+```
+in order to define a test.
+
+Currently, the following `TEST`, `FAIL`, `SUCCEED`, and the basic comparison assertion macros can have alternative names. You can see the full list of covered macros [here](http://www.google.com/codesearch?q=if+!GTEST_DONT_DEFINE_\w%2B+package:http://googletest\.googlecode\.com+file:/include/gtest/gtest.h). More information can be found in the "Avoiding Macro Name Clashes" section of the README file.
+
+
+## Is it OK if I have two separate `TEST(Foo, Bar)` test methods defined in different namespaces? ##
+
+Yes.
+
+The rule is **all test methods in the same test case must use the same fixture class**. This means that the following is **allowed** because both tests use the same fixture class (`::testing::Test`).
+
+``` cpp
+namespace foo {
+TEST(CoolTest, DoSomething) {
+  SUCCEED();
+}
+}  // namespace foo
+
+namespace bar {
+TEST(CoolTest, DoSomething) {
+  SUCCEED();
+}
+}  // namespace foo
+```
+
+However, the following code is **not allowed** and will produce a runtime error from Google Test because the test methods are using different test fixture classes with the same test case name.
+
+``` cpp
+namespace foo {
+class CoolTest : public ::testing::Test {};  // Fixture foo::CoolTest
+TEST_F(CoolTest, DoSomething) {
+  SUCCEED();
+}
+}  // namespace foo
+
+namespace bar {
+class CoolTest : public ::testing::Test {};  // Fixture: bar::CoolTest
+TEST_F(CoolTest, DoSomething) {
+  SUCCEED();
+}
+}  // namespace foo
+```
+
+## How do I build Google Testing Framework with Xcode 4? ##
+
+If you try to build Google Test's Xcode project with Xcode 4.0 or later, you may encounter an error message that looks like
+"Missing SDK in target gtest\_framework: /Developer/SDKs/MacOSX10.4u.sdk". That means that Xcode does not support the SDK the project is targeting. See the Xcode section in the [README](../README.md) file on how to resolve this.
+
+## My question is not covered in your FAQ! ##
+
+If you cannot find the answer to your question in this FAQ, there are
+some other resources you can use:
+
+  1. read other [wiki pages](../docs),
+  1. search the mailing list [archive](https://groups.google.com/forum/#!forum/googletestframework),
+  1. ask it on [googletestframework@googlegroups.com](mailto:googletestframework@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googletestframework) before you can post.).
+
+Please note that creating an issue in the
+[issue tracker](https://github.com/google/googletest/issues) is _not_
+a good way to get your answer, as it is monitored infrequently by a
+very small number of people.
+
+When asking a question, it's helpful to provide as much of the
+following information as possible (people cannot help you if there's
+not enough information in your question):
+
+  * the version (or the commit hash if you check out from Git directly) of Google Test you use (Google Test is under active development, so it's possible that your problem has been solved in a later version),
+  * your operating system,
+  * the name and version of your compiler,
+  * the complete command line flags you give to your compiler,
+  * the complete compiler error messages (if the question is about compilation),
+  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Primer.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Primer.md
new file mode 100644
index 00000000..474c1d2a
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Primer.md
@@ -0,0 +1,502 @@
+
+
+# Introduction: Why Google C++ Testing Framework? #
+
+_Google C++ Testing Framework_ helps you write better C++ tests.
+
+No matter whether you work on Linux, Windows, or a Mac, if you write C++ code,
+Google Test can help you.
+
+So what makes a good test, and how does Google C++ Testing Framework fit in? We believe:
+  1. Tests should be _independent_ and _repeatable_. It's a pain to debug a test that succeeds or fails as a result of other tests.  Google C++ Testing Framework isolates the tests by running each of them on a different object. When a test fails, Google C++ Testing Framework allows you to run it in isolation for quick debugging.
+  1. Tests should be well _organized_ and reflect the structure of the tested code.  Google C++ Testing Framework groups related tests into test cases that can share data and subroutines. This common pattern is easy to recognize and makes tests easy to maintain. Such consistency is especially helpful when people switch projects and start to work on a new code base.
+  1. Tests should be _portable_ and _reusable_. The open-source community has a lot of code that is platform-neutral, its tests should also be platform-neutral.  Google C++ Testing Framework works on different OSes, with different compilers (gcc, MSVC, and others), with or without exceptions, so Google C++ Testing Framework tests can easily work with a variety of configurations.  (Note that the current release only contains build scripts for Linux - we are actively working on scripts for other platforms.)
+  1. When tests fail, they should provide as much _information_ about the problem as possible. Google C++ Testing Framework doesn't stop at the first test failure. Instead, it only stops the current test and continues with the next. You can also set up tests that report non-fatal failures after which the current test continues. Thus, you can detect and fix multiple bugs in a single run-edit-compile cycle.
+  1. The testing framework should liberate test writers from housekeeping chores and let them focus on the test _content_.  Google C++ Testing Framework automatically keeps track of all tests defined, and doesn't require the user to enumerate them in order to run them.
+  1. Tests should be _fast_. With Google C++ Testing Framework, you can reuse shared resources across tests and pay for the set-up/tear-down only once, without making tests depend on each other.
+
+Since Google C++ Testing Framework is based on the popular xUnit
+architecture, you'll feel right at home if you've used JUnit or PyUnit before.
+If not, it will take you about 10 minutes to learn the basics and get started.
+So let's go!
+
+_Note:_ We sometimes refer to Google C++ Testing Framework informally
+as _Google Test_.
+
+# Setting up a New Test Project #
+
+To write a test program using Google Test, you need to compile Google
+Test into a library and link your test with it.  We provide build
+files for some popular build systems: `msvc/` for Visual Studio,
+`xcode/` for Mac Xcode, `make/` for GNU make, `codegear/` for Borland
+C++ Builder, and the autotools script (deprecated) and
+`CMakeLists.txt` for CMake (recommended) in the Google Test root
+directory.  If your build system is not on this list, you can take a
+look at `make/Makefile` to learn how Google Test should be compiled
+(basically you want to compile `src/gtest-all.cc` with `GTEST_ROOT`
+and `GTEST_ROOT/include` in the header search path, where `GTEST_ROOT`
+is the Google Test root directory).
+
+Once you are able to compile the Google Test library, you should
+create a project or build target for your test program.  Make sure you
+have `GTEST_ROOT/include` in the header search path so that the
+compiler can find `"gtest/gtest.h"` when compiling your test.  Set up
+your test project to link with the Google Test library (for example,
+in Visual Studio, this is done by adding a dependency on
+`gtest.vcproj`).
+
+If you still have questions, take a look at how Google Test's own
+tests are built and use them as examples.
+
+# Basic Concepts #
+
+When using Google Test, you start by writing _assertions_, which are statements
+that check whether a condition is true. An assertion's result can be _success_,
+_nonfatal failure_, or _fatal failure_. If a fatal failure occurs, it aborts
+the current function; otherwise the program continues normally.
+
+_Tests_ use assertions to verify the tested code's behavior. If a test crashes
+or has a failed assertion, then it _fails_; otherwise it _succeeds_.
+
+A _test case_ contains one or many tests. You should group your tests into test
+cases that reflect the structure of the tested code. When multiple tests in a
+test case need to share common objects and subroutines, you can put them into a
+_test fixture_ class.
+
+A _test program_ can contain multiple test cases.
+
+We'll now explain how to write a test program, starting at the individual
+assertion level and building up to tests and test cases.
+
+# Assertions #
+
+Google Test assertions are macros that resemble function calls. You test a
+class or function by making assertions about its behavior. When an assertion
+fails, Google Test prints the assertion's source file and line number location,
+along with a failure message. You may also supply a custom failure message
+which will be appended to Google Test's message.
+
+The assertions come in pairs that test the same thing but have different
+effects on the current function. `ASSERT_*` versions generate fatal failures
+when they fail, and **abort the current function**. `EXPECT_*` versions generate
+nonfatal failures, which don't abort the current function. Usually `EXPECT_*`
+are preferred, as they allow more than one failures to be reported in a test.
+However, you should use `ASSERT_*` if it doesn't make sense to continue when
+the assertion in question fails.
+
+Since a failed `ASSERT_*` returns from the current function immediately,
+possibly skipping clean-up code that comes after it, it may cause a space leak.
+Depending on the nature of the leak, it may or may not be worth fixing - so
+keep this in mind if you get a heap checker error in addition to assertion
+errors.
+
+To provide a custom failure message, simply stream it into the macro using the
+`<<` operator, or a sequence of such operators. An example:
+```
+ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length";
+
+for (int i = 0; i < x.size(); ++i) {
+  EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i;
+}
+```
+
+Anything that can be streamed to an `ostream` can be streamed to an assertion
+macro--in particular, C strings and `string` objects. If a wide string
+(`wchar_t*`, `TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is
+streamed to an assertion, it will be translated to UTF-8 when printed.
+
+## Basic Assertions ##
+
+These assertions do basic true/false condition testing.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_TRUE(`_condition_`)`;  | `EXPECT_TRUE(`_condition_`)`;   | _condition_ is true |
+| `ASSERT_FALSE(`_condition_`)`; | `EXPECT_FALSE(`_condition_`)`;  | _condition_ is false |
+
+Remember, when they fail, `ASSERT_*` yields a fatal failure and
+returns from the current function, while `EXPECT_*` yields a nonfatal
+failure, allowing the function to continue running. In either case, an
+assertion failure means its containing test fails.
+
+_Availability_: Linux, Windows, Mac.
+
+## Binary Comparison ##
+
+This section describes assertions that compare two values.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+|`ASSERT_EQ(`_val1_`, `_val2_`);`|`EXPECT_EQ(`_val1_`, `_val2_`);`| _val1_ `==` _val2_ |
+|`ASSERT_NE(`_val1_`, `_val2_`);`|`EXPECT_NE(`_val1_`, `_val2_`);`| _val1_ `!=` _val2_ |
+|`ASSERT_LT(`_val1_`, `_val2_`);`|`EXPECT_LT(`_val1_`, `_val2_`);`| _val1_ `<` _val2_ |
+|`ASSERT_LE(`_val1_`, `_val2_`);`|`EXPECT_LE(`_val1_`, `_val2_`);`| _val1_ `<=` _val2_ |
+|`ASSERT_GT(`_val1_`, `_val2_`);`|`EXPECT_GT(`_val1_`, `_val2_`);`| _val1_ `>` _val2_ |
+|`ASSERT_GE(`_val1_`, `_val2_`);`|`EXPECT_GE(`_val1_`, `_val2_`);`| _val1_ `>=` _val2_ |
+
+In the event of a failure, Google Test prints both _val1_ and _val2_.
+
+Value arguments must be comparable by the assertion's comparison
+operator or you'll get a compiler error.  We used to require the
+arguments to support the `<<` operator for streaming to an `ostream`,
+but it's no longer necessary since v1.6.0 (if `<<` is supported, it
+will be called to print the arguments when the assertion fails;
+otherwise Google Test will attempt to print them in the best way it
+can. For more details and how to customize the printing of the
+arguments, see this Google Mock [recipe](../../googlemock/docs/CookBook.md#teaching-google-mock-how-to-print-your-values).).
+
+These assertions can work with a user-defined type, but only if you define the
+corresponding comparison operator (e.g. `==`, `<`, etc).  If the corresponding
+operator is defined, prefer using the `ASSERT_*()` macros because they will
+print out not only the result of the comparison, but the two operands as well.
+
+Arguments are always evaluated exactly once. Therefore, it's OK for the
+arguments to have side effects. However, as with any ordinary C/C++ function,
+the arguments' evaluation order is undefined (i.e. the compiler is free to
+choose any order) and your code should not depend on any particular argument
+evaluation order.
+
+`ASSERT_EQ()` does pointer equality on pointers. If used on two C strings, it
+tests if they are in the same memory location, not if they have the same value.
+Therefore, if you want to compare C strings (e.g. `const char*`) by value, use
+`ASSERT_STREQ()` , which will be described later on. In particular, to assert
+that a C string is `NULL`, use `ASSERT_STREQ(NULL, c_string)` . However, to
+compare two `string` objects, you should use `ASSERT_EQ`.
+
+Macros in this section work with both narrow and wide string objects (`string`
+and `wstring`).
+
+_Availability_: Linux, Windows, Mac.
+
+_Historical note_: Before February 2016 `*_EQ` had a convention of calling it as
+`ASSERT_EQ(expected, actual)`, so lots of existing code uses this order.
+Now `*_EQ` treats both parameters in the same way.
+
+## String Comparison ##
+
+The assertions in this group compare two **C strings**. If you want to compare
+two `string` objects, use `EXPECT_EQ`, `EXPECT_NE`, and etc instead.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_STREQ(`_str1_`, `_str2_`);`    | `EXPECT_STREQ(`_str1_`, `_str_2`);`     | the two C strings have the same content |
+| `ASSERT_STRNE(`_str1_`, `_str2_`);`    | `EXPECT_STRNE(`_str1_`, `_str2_`);`     | the two C strings have different content |
+| `ASSERT_STRCASEEQ(`_str1_`, `_str2_`);`| `EXPECT_STRCASEEQ(`_str1_`, `_str2_`);` | the two C strings have the same content, ignoring case |
+| `ASSERT_STRCASENE(`_str1_`, `_str2_`);`| `EXPECT_STRCASENE(`_str1_`, `_str2_`);` | the two C strings have different content, ignoring case |
+
+Note that "CASE" in an assertion name means that case is ignored.
+
+`*STREQ*` and `*STRNE*` also accept wide C strings (`wchar_t*`). If a
+comparison of two wide strings fails, their values will be printed as UTF-8
+narrow strings.
+
+A `NULL` pointer and an empty string are considered _different_.
+
+_Availability_: Linux, Windows, Mac.
+
+See also: For more string comparison tricks (substring, prefix, suffix, and
+regular expression matching, for example), see the [Advanced Google Test Guide](AdvancedGuide.md).
+
+# Simple Tests #
+
+To create a test:
+  1. Use the `TEST()` macro to define and name a test function, These are ordinary C++ functions that don't return a value.
+  1. In this function, along with any valid C++ statements you want to include, use the various Google Test assertions to check values.
+  1. The test's result is determined by the assertions; if any assertion in the test fails (either fatally or non-fatally), or if the test crashes, the entire test fails. Otherwise, it succeeds.
+
+```
+TEST(test_case_name, test_name) {
+ ... test body ...
+}
+```
+
+
+`TEST()` arguments go from general to specific. The _first_ argument is the
+name of the test case, and the _second_ argument is the test's name within the
+test case. Both names must be valid C++ identifiers, and they should not contain underscore (`_`). A test's _full name_ consists of its containing test case and its
+individual name. Tests from different test cases can have the same individual
+name.
+
+For example, let's take a simple integer function:
+```
+int Factorial(int n); // Returns the factorial of n
+```
+
+A test case for this function might look like:
+```
+// Tests factorial of 0.
+TEST(FactorialTest, HandlesZeroInput) {
+  EXPECT_EQ(1, Factorial(0));
+}
+
+// Tests factorial of positive numbers.
+TEST(FactorialTest, HandlesPositiveInput) {
+  EXPECT_EQ(1, Factorial(1));
+  EXPECT_EQ(2, Factorial(2));
+  EXPECT_EQ(6, Factorial(3));
+  EXPECT_EQ(40320, Factorial(8));
+}
+```
+
+Google Test groups the test results by test cases, so logically-related tests
+should be in the same test case; in other words, the first argument to their
+`TEST()` should be the same. In the above example, we have two tests,
+`HandlesZeroInput` and `HandlesPositiveInput`, that belong to the same test
+case `FactorialTest`.
+
+_Availability_: Linux, Windows, Mac.
+
+# Test Fixtures: Using the Same Data Configuration for Multiple Tests #
+
+If you find yourself writing two or more tests that operate on similar data,
+you can use a _test fixture_. It allows you to reuse the same configuration of
+objects for several different tests.
+
+To create a fixture, just:
+  1. Derive a class from `::testing::Test` . Start its body with `protected:` or `public:` as we'll want to access fixture members from sub-classes.
+  1. Inside the class, declare any objects you plan to use.
+  1. If necessary, write a default constructor or `SetUp()` function to prepare the objects for each test. A common mistake is to spell `SetUp()` as `Setup()` with a small `u` - don't let that happen to you.
+  1. If necessary, write a destructor or `TearDown()` function to release any resources you allocated in `SetUp()` . To learn when you should use the constructor/destructor and when you should use `SetUp()/TearDown()`, read this [FAQ entry](FAQ.md#should-i-use-the-constructordestructor-of-the-test-fixture-or-the-set-uptear-down-function).
+  1. If needed, define subroutines for your tests to share.
+
+When using a fixture, use `TEST_F()` instead of `TEST()` as it allows you to
+access objects and subroutines in the test fixture:
+```
+TEST_F(test_case_name, test_name) {
+ ... test body ...
+}
+```
+
+Like `TEST()`, the first argument is the test case name, but for `TEST_F()`
+this must be the name of the test fixture class. You've probably guessed: `_F`
+is for fixture.
+
+Unfortunately, the C++ macro system does not allow us to create a single macro
+that can handle both types of tests. Using the wrong macro causes a compiler
+error.
+
+Also, you must first define a test fixture class before using it in a
+`TEST_F()`, or you'll get the compiler error "`virtual outside class
+declaration`".
+
+For each test defined with `TEST_F()`, Google Test will:
+  1. Create a _fresh_ test fixture at runtime
+  1. Immediately initialize it via `SetUp()` ,
+  1. Run the test
+  1. Clean up by calling `TearDown()`
+  1. Delete the test fixture.  Note that different tests in the same test case have different test fixture objects, and Google Test always deletes a test fixture before it creates the next one. Google Test does not reuse the same test fixture for multiple tests. Any changes one test makes to the fixture do not affect other tests.
+
+As an example, let's write tests for a FIFO queue class named `Queue`, which
+has the following interface:
+```
+template <typename E> // E is the element type.
+class Queue {
+ public:
+  Queue();
+  void Enqueue(const E& element);
+  E* Dequeue(); // Returns NULL if the queue is empty.
+  size_t size() const;
+  ...
+};
+```
+
+First, define a fixture class. By convention, you should give it the name
+`FooTest` where `Foo` is the class being tested.
+```
+class QueueTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    q1_.Enqueue(1);
+    q2_.Enqueue(2);
+    q2_.Enqueue(3);
+  }
+
+  // virtual void TearDown() {}
+
+  Queue<int> q0_;
+  Queue<int> q1_;
+  Queue<int> q2_;
+};
+```
+
+In this case, `TearDown()` is not needed since we don't have to clean up after
+each test, other than what's already done by the destructor.
+
+Now we'll write tests using `TEST_F()` and this fixture.
+```
+TEST_F(QueueTest, IsEmptyInitially) {
+  EXPECT_EQ(0, q0_.size());
+}
+
+TEST_F(QueueTest, DequeueWorks) {
+  int* n = q0_.Dequeue();
+  EXPECT_EQ(NULL, n);
+
+  n = q1_.Dequeue();
+  ASSERT_TRUE(n != NULL);
+  EXPECT_EQ(1, *n);
+  EXPECT_EQ(0, q1_.size());
+  delete n;
+
+  n = q2_.Dequeue();
+  ASSERT_TRUE(n != NULL);
+  EXPECT_EQ(2, *n);
+  EXPECT_EQ(1, q2_.size());
+  delete n;
+}
+```
+
+The above uses both `ASSERT_*` and `EXPECT_*` assertions. The rule of thumb is
+to use `EXPECT_*` when you want the test to continue to reveal more errors
+after the assertion failure, and use `ASSERT_*` when continuing after failure
+doesn't make sense. For example, the second assertion in the `Dequeue` test is
+`ASSERT_TRUE(n != NULL)`, as we need to dereference the pointer `n` later,
+which would lead to a segfault when `n` is `NULL`.
+
+When these tests run, the following happens:
+  1. Google Test constructs a `QueueTest` object (let's call it `t1` ).
+  1. `t1.SetUp()` initializes `t1` .
+  1. The first test ( `IsEmptyInitially` ) runs on `t1` .
+  1. `t1.TearDown()` cleans up after the test finishes.
+  1. `t1` is destructed.
+  1. The above steps are repeated on another `QueueTest` object, this time running the `DequeueWorks` test.
+
+_Availability_: Linux, Windows, Mac.
+
+_Note_: Google Test automatically saves all _Google Test_ flags when a test
+object is constructed, and restores them when it is destructed.
+
+# Invoking the Tests #
+
+`TEST()` and `TEST_F()` implicitly register their tests with Google Test. So, unlike with many other C++ testing frameworks, you don't have to re-list all your defined tests in order to run them.
+
+After defining your tests, you can run them with `RUN_ALL_TESTS()` , which returns `0` if all the tests are successful, or `1` otherwise. Note that `RUN_ALL_TESTS()` runs _all tests_ in your link unit -- they can be from different test cases, or even different source files.
+
+When invoked, the `RUN_ALL_TESTS()` macro:
+  1. Saves the state of all  Google Test flags.
+  1. Creates a test fixture object for the first test.
+  1. Initializes it via `SetUp()`.
+  1. Runs the test on the fixture object.
+  1. Cleans up the fixture via `TearDown()`.
+  1. Deletes the fixture.
+  1. Restores the state of all Google Test flags.
+  1. Repeats the above steps for the next test, until all tests have run.
+
+In addition, if the text fixture's constructor generates a fatal failure in
+step 2, there is no point for step 3 - 5 and they are thus skipped. Similarly,
+if step 3 generates a fatal failure, step 4 will be skipped.
+
+_Important_: You must not ignore the return value of `RUN_ALL_TESTS()`, or `gcc`
+will give you a compiler error. The rationale for this design is that the
+automated testing service determines whether a test has passed based on its
+exit code, not on its stdout/stderr output; thus your `main()` function must
+return the value of `RUN_ALL_TESTS()`.
+
+Also, you should call `RUN_ALL_TESTS()` only **once**. Calling it more than once
+conflicts with some advanced Google Test features (e.g. thread-safe death
+tests) and thus is not supported.
+
+_Availability_: Linux, Windows, Mac.
+
+# Writing the main() Function #
+
+You can start from this boilerplate:
+```
+#include "this/package/foo.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+// The fixture for testing class Foo.
+class FooTest : public ::testing::Test {
+ protected:
+  // You can remove any or all of the following functions if its body
+  // is empty.
+
+  FooTest() {
+    // You can do set-up work for each test here.
+  }
+
+  virtual ~FooTest() {
+    // You can do clean-up work that doesn't throw exceptions here.
+  }
+
+  // If the constructor and destructor are not enough for setting up
+  // and cleaning up each test, you can define the following methods:
+
+  virtual void SetUp() {
+    // Code here will be called immediately after the constructor (right
+    // before each test).
+  }
+
+  virtual void TearDown() {
+    // Code here will be called immediately after each test (right
+    // before the destructor).
+  }
+
+  // Objects declared here can be used by all tests in the test case for Foo.
+};
+
+// Tests that the Foo::Bar() method does Abc.
+TEST_F(FooTest, MethodBarDoesAbc) {
+  const string input_filepath = "this/package/testdata/myinputfile.dat";
+  const string output_filepath = "this/package/testdata/myoutputfile.dat";
+  Foo f;
+  EXPECT_EQ(0, f.Bar(input_filepath, output_filepath));
+}
+
+// Tests that Foo does Xyz.
+TEST_F(FooTest, DoesXyz) {
+  // Exercises the Xyz feature of Foo.
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+```
+
+The `::testing::InitGoogleTest()` function parses the command line for Google
+Test flags, and removes all recognized flags. This allows the user to control a
+test program's behavior via various flags, which we'll cover in [AdvancedGuide](AdvancedGuide.md).
+You must call this function before calling `RUN_ALL_TESTS()`, or the flags
+won't be properly initialized.
+
+On Windows, `InitGoogleTest()` also works with wide strings, so it can be used
+in programs compiled in `UNICODE` mode as well.
+
+But maybe you think that writing all those main() functions is too much work? We agree with you completely and that's why Google Test provides a basic implementation of main(). If it fits your needs, then just link your test with gtest\_main library and you are good to go.
+
+## Important note for Visual C++ users ##
+If you put your tests into a library and your `main()` function is in a different library or in your .exe file, those tests will not run. The reason is a [bug](https://connect.microsoft.com/feedback/viewfeedback.aspx?FeedbackID=244410&siteid=210) in Visual C++. When you define your tests, Google Test creates certain static objects to register them. These objects are not referenced from elsewhere but their constructors are still supposed to run. When Visual C++ linker sees that nothing in the library is referenced from other places it throws the library out. You have to reference your library with tests from your main program to keep the linker from discarding it. Here is how to do it. Somewhere in your library code declare a function:
+```
+__declspec(dllexport) int PullInMyLibrary() { return 0; }
+```
+If you put your tests in a static library (not DLL) then `__declspec(dllexport)` is not required. Now, in your main program, write a code that invokes that function:
+```
+int PullInMyLibrary();
+static int dummy = PullInMyLibrary();
+```
+This will keep your tests referenced and will make them register themselves at startup.
+
+In addition, if you define your tests in a static library, add `/OPT:NOREF` to your main program linker options. If you use MSVC++ IDE, go to your .exe project properties/Configuration Properties/Linker/Optimization and set References setting to `Keep Unreferenced Data (/OPT:NOREF)`. This will keep Visual C++ linker from discarding individual symbols generated by your tests from the final executable.
+
+There is one more pitfall, though. If you use Google Test as a static library (that's how it is defined in gtest.vcproj) your tests must also reside in a static library. If you have to have them in a DLL, you _must_ change Google Test to build into a DLL as well. Otherwise your tests will not run correctly or will not run at all. The general conclusion here is: make your life easier - do not write your tests in libraries!
+
+# Where to Go from Here #
+
+Congratulations! You've learned the Google Test basics. You can start writing
+and running Google Test tests, read some [samples](Samples.md), or continue with
+[AdvancedGuide](AdvancedGuide.md), which describes many more useful Google Test features.
+
+# Known Limitations #
+
+Google Test is designed to be thread-safe.  The implementation is
+thread-safe on systems where the `pthreads` library is available.  It
+is currently _unsafe_ to use Google Test assertions from two threads
+concurrently on other systems (e.g. Windows).  In most tests this is
+not an issue as usually the assertions are done in the main thread. If
+you want to help, you can volunteer to implement the necessary
+synchronization primitives in `gtest-port.h` for your platform.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/PumpManual.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/PumpManual.md
new file mode 100644
index 00000000..8184f153
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/PumpManual.md
@@ -0,0 +1,177 @@
+
+
+<b>P</b>ump is <b>U</b>seful for <b>M</b>eta <b>P</b>rogramming.
+
+# The Problem #
+
+Template and macro libraries often need to define many classes,
+functions, or macros that vary only (or almost only) in the number of
+arguments they take. It's a lot of repetitive, mechanical, and
+error-prone work.
+
+Variadic templates and variadic macros can alleviate the problem.
+However, while both are being considered by the C++ committee, neither
+is in the standard yet or widely supported by compilers.  Thus they
+are often not a good choice, especially when your code needs to be
+portable. And their capabilities are still limited.
+
+As a result, authors of such libraries often have to write scripts to
+generate their implementation. However, our experience is that it's
+tedious to write such scripts, which tend to reflect the structure of
+the generated code poorly and are often hard to read and edit. For
+example, a small change needed in the generated code may require some
+non-intuitive, non-trivial changes in the script. This is especially
+painful when experimenting with the code.
+
+# Our Solution #
+
+Pump (for Pump is Useful for Meta Programming, Pretty Useful for Meta
+Programming, or Practical Utility for Meta Programming, whichever you
+prefer) is a simple meta-programming tool for C++. The idea is that a
+programmer writes a `foo.pump` file which contains C++ code plus meta
+code that manipulates the C++ code. The meta code can handle
+iterations over a range, nested iterations, local meta variable
+definitions, simple arithmetic, and conditional expressions. You can
+view it as a small Domain-Specific Language. The meta language is
+designed to be non-intrusive (s.t. it won't confuse Emacs' C++ mode,
+for example) and concise, making Pump code intuitive and easy to
+maintain.
+
+## Highlights ##
+
+  * The implementation is in a single Python script and thus ultra portable: no build or installation is needed and it works cross platforms.
+  * Pump tries to be smart with respect to [Google's style guide](http://code.google.com/p/google-styleguide/): it breaks long lines (easy to have when they are generated) at acceptable places to fit within 80 columns and indent the continuation lines correctly.
+  * The format is human-readable and more concise than XML.
+  * The format works relatively well with Emacs' C++ mode.
+
+## Examples ##
+
+The following Pump code (where meta keywords start with `$`, `[[` and `]]` are meta brackets, and `$$` starts a meta comment that ends with the line):
+
+```
+$var n = 3     $$ Defines a meta variable n.
+$range i 0..n  $$ Declares the range of meta iterator i (inclusive).
+$for i [[
+               $$ Meta loop.
+// Foo$i does blah for $i-ary predicates.
+$range j 1..i
+template <size_t N $for j [[, typename A$j]]>
+class Foo$i {
+$if i == 0 [[
+  blah a;
+]] $elif i <= 2 [[
+  blah b;
+]] $else [[
+  blah c;
+]]
+};
+
+]]
+```
+
+will be translated by the Pump compiler to:
+
+```
+// Foo0 does blah for 0-ary predicates.
+template <size_t N>
+class Foo0 {
+  blah a;
+};
+
+// Foo1 does blah for 1-ary predicates.
+template <size_t N, typename A1>
+class Foo1 {
+  blah b;
+};
+
+// Foo2 does blah for 2-ary predicates.
+template <size_t N, typename A1, typename A2>
+class Foo2 {
+  blah b;
+};
+
+// Foo3 does blah for 3-ary predicates.
+template <size_t N, typename A1, typename A2, typename A3>
+class Foo3 {
+  blah c;
+};
+```
+
+In another example,
+
+```
+$range i 1..n
+Func($for i + [[a$i]]);
+$$ The text between i and [[ is the separator between iterations.
+```
+
+will generate one of the following lines (without the comments), depending on the value of `n`:
+
+```
+Func();              // If n is 0.
+Func(a1);            // If n is 1.
+Func(a1 + a2);       // If n is 2.
+Func(a1 + a2 + a3);  // If n is 3.
+// And so on...
+```
+
+## Constructs ##
+
+We support the following meta programming constructs:
+
+| `$var id = exp` | Defines a named constant value. `$id` is valid util the end of the current meta lexical block. |
+|:----------------|:-----------------------------------------------------------------------------------------------|
+| `$range id exp..exp` | Sets the range of an iteration variable, which can be reused in multiple loops later.          |
+| `$for id sep [[ code ]]` | Iteration. The range of `id` must have been defined earlier. `$id` is valid in `code`.         |
+| `$($)`          | Generates a single `$` character.                                                              |
+| `$id`           | Value of the named constant or iteration variable.                                             |
+| `$(exp)`        | Value of the expression.                                                                       |
+| `$if exp [[ code ]] else_branch` | Conditional.                                                                                   |
+| `[[ code ]]`    | Meta lexical block.                                                                            |
+| `cpp_code`      | Raw C++ code.                                                                                  |
+| `$$ comment`    | Meta comment.                                                                                  |
+
+**Note:** To give the user some freedom in formatting the Pump source
+code, Pump ignores a new-line character if it's right after `$for foo`
+or next to `[[` or `]]`. Without this rule you'll often be forced to write
+very long lines to get the desired output. Therefore sometimes you may
+need to insert an extra new-line in such places for a new-line to show
+up in your output.
+
+## Grammar ##
+
+```
+code ::= atomic_code*
+atomic_code ::= $var id = exp
+    | $var id = [[ code ]]
+    | $range id exp..exp
+    | $for id sep [[ code ]]
+    | $($)
+    | $id
+    | $(exp)
+    | $if exp [[ code ]] else_branch
+    | [[ code ]]
+    | cpp_code
+sep ::= cpp_code | empty_string
+else_branch ::= $else [[ code ]]
+    | $elif exp [[ code ]] else_branch
+    | empty_string
+exp ::= simple_expression_in_Python_syntax
+```
+
+## Code ##
+
+You can find the source code of Pump in [scripts/pump.py](../scripts/pump.py). It is still
+very unpolished and lacks automated tests, although it has been
+successfully used many times. If you find a chance to use it in your
+project, please let us know what you think!  We also welcome help on
+improving Pump.
+
+## Real Examples ##
+
+You can find real-world applications of Pump in [Google Test](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgoogletest\.googlecode\.com) and [Google Mock](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgooglemock\.googlecode\.com).  The source file `foo.h.pump` generates `foo.h`.
+
+## Tips ##
+
+  * If a meta variable is followed by a letter or digit, you can separate them using `[[]]`, which inserts an empty string. For example `Foo$j[[]]Helper` generate `Foo1Helper` when `j` is 1.
+  * To avoid extra-long Pump source lines, you can break a line anywhere you want by inserting `[[]]` followed by a new line. Since any new-line character next to `[[` or `]]` is ignored, the generated code won't contain this new line.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Samples.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Samples.md
new file mode 100644
index 00000000..f21d2005
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Samples.md
@@ -0,0 +1,14 @@
+If you're like us, you'd like to look at some Google Test sample code.  The
+[samples folder](../samples) has a number of well-commented samples showing how to use a
+variety of Google Test features.
+
+  * [Sample #1](../samples/sample1_unittest.cc) shows the basic steps of using Google Test to test C++ functions.
+  * [Sample #2](../samples/sample2_unittest.cc) shows a more complex unit test for a class with multiple member functions.
+  * [Sample #3](../samples/sample3_unittest.cc) uses a test fixture.
+  * [Sample #4](../samples/sample4_unittest.cc) is another basic example of using Google Test.
+  * [Sample #5](../samples/sample5_unittest.cc) teaches how to reuse a test fixture in multiple test cases by deriving sub-fixtures from it.
+  * [Sample #6](../samples/sample6_unittest.cc) demonstrates type-parameterized tests.
+  * [Sample #7](../samples/sample7_unittest.cc) teaches the basics of value-parameterized tests.
+  * [Sample #8](../samples/sample8_unittest.cc) shows using `Combine()` in value-parameterized tests.
+  * [Sample #9](../samples/sample9_unittest.cc) shows use of the listener API to modify Google Test's console output and the use of its reflection API to inspect test results.
+  * [Sample #10](../samples/sample10_unittest.cc) shows use of the listener API to implement a primitive memory leak checker.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_AdvancedGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_AdvancedGuide.md
new file mode 100644
index 00000000..34e19c26
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_AdvancedGuide.md
@@ -0,0 +1,2096 @@
+
+
+Now that you have read [Primer](V1_5_Primer.md) and learned how to write tests
+using Google Test, it's time to learn some new tricks. This document
+will show you more assertions as well as how to construct complex
+failure messages, propagate fatal failures, reuse and speed up your
+test fixtures, and use various flags with your tests.
+
+# More Assertions #
+
+This section covers some less frequently used, but still significant,
+assertions.
+
+## Explicit Success and Failure ##
+
+These three assertions do not actually test a value or expression. Instead,
+they generate a success or failure directly. Like the macros that actually
+perform a test, you may stream a custom failure message into the them.
+
+| `SUCCEED();` |
+|:-------------|
+
+Generates a success. This does NOT make the overall test succeed. A test is
+considered successful only if none of its assertions fail during its execution.
+
+Note: `SUCCEED()` is purely documentary and currently doesn't generate any
+user-visible output. However, we may add `SUCCEED()` messages to Google Test's
+output in the future.
+
+| `FAIL();`  | `ADD_FAILURE();` |
+|:-----------|:-----------------|
+
+`FAIL*` generates a fatal failure while `ADD_FAILURE*` generates a nonfatal
+failure. These are useful when control flow, rather than a Boolean expression,
+deteremines the test's success or failure. For example, you might want to write
+something like:
+
+```
+switch(expression) {
+  case 1: ... some checks ...
+  case 2: ... some other checks
+  ...
+  default: FAIL() << "We shouldn't get here.";
+}
+```
+
+_Availability_: Linux, Windows, Mac.
+
+## Exception Assertions ##
+
+These are for verifying that a piece of code throws (or does not
+throw) an exception of the given type:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_THROW(`_statement_, _exception\_type_`);`  | `EXPECT_THROW(`_statement_, _exception\_type_`);`  | _statement_ throws an exception of the given type  |
+| `ASSERT_ANY_THROW(`_statement_`);`                | `EXPECT_ANY_THROW(`_statement_`);`                | _statement_ throws an exception of any type        |
+| `ASSERT_NO_THROW(`_statement_`);`                 | `EXPECT_NO_THROW(`_statement_`);`                 | _statement_ doesn't throw any exception            |
+
+Examples:
+
+```
+ASSERT_THROW(Foo(5), bar_exception);
+
+EXPECT_NO_THROW({
+  int n = 5;
+  Bar(&n);
+});
+```
+
+_Availability_: Linux, Windows, Mac; since version 1.1.0.
+
+## Predicate Assertions for Better Error Messages ##
+
+Even though Google Test has a rich set of assertions, they can never be
+complete, as it's impossible (nor a good idea) to anticipate all the scenarios
+a user might run into. Therefore, sometimes a user has to use `EXPECT_TRUE()`
+to check a complex expression, for lack of a better macro. This has the problem
+of not showing you the values of the parts of the expression, making it hard to
+understand what went wrong. As a workaround, some users choose to construct the
+failure message by themselves, streaming it into `EXPECT_TRUE()`. However, this
+is awkward especially when the expression has side-effects or is expensive to
+evaluate.
+
+Google Test gives you three different options to solve this problem:
+
+### Using an Existing Boolean Function ###
+
+If you already have a function or a functor that returns `bool` (or a type
+that can be implicitly converted to `bool`), you can use it in a _predicate
+assertion_ to get the function arguments printed for free:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_PRED1(`_pred1, val1_`);`       | `EXPECT_PRED1(`_pred1, val1_`);` | _pred1(val1)_ returns true |
+| `ASSERT_PRED2(`_pred2, val1, val2_`);` | `EXPECT_PRED2(`_pred2, val1, val2_`);` |  _pred2(val1, val2)_ returns true |
+|  ...                | ...                    | ...          |
+
+In the above, _predn_ is an _n_-ary predicate function or functor, where
+_val1_, _val2_, ..., and _valn_ are its arguments. The assertion succeeds
+if the predicate returns `true` when applied to the given arguments, and fails
+otherwise. When the assertion fails, it prints the value of each argument. In
+either case, the arguments are evaluated exactly once.
+
+Here's an example. Given
+
+```
+// Returns true iff m and n have no common divisors except 1.
+bool MutuallyPrime(int m, int n) { ... }
+const int a = 3;
+const int b = 4;
+const int c = 10;
+```
+
+the assertion `EXPECT_PRED2(MutuallyPrime, a, b);` will succeed, while the
+assertion `EXPECT_PRED2(MutuallyPrime, b, c);` will fail with the message
+
+<pre>
+!MutuallyPrime(b, c) is false, where<br>
+b is 4<br>
+c is 10<br>
+</pre>
+
+**Notes:**
+
+  1. If you see a compiler error "no matching function to call" when using `ASSERT_PRED*` or `EXPECT_PRED*`, please see [this](V1_5_FAQ.md#the-compiler-complains-about-undefined-references-to-some-static-const-member-variables-but-i-did-define-them-in-the-class-body-whats-wrong) for how to resolve it.
+  1. Currently we only provide predicate assertions of arity <= 5. If you need a higher-arity assertion, let us know.
+
+_Availability_: Linux, Windows, Mac
+
+### Using a Function That Returns an AssertionResult ###
+
+While `EXPECT_PRED*()` and friends are handy for a quick job, the
+syntax is not satisfactory: you have to use different macros for
+different arities, and it feels more like Lisp than C++.  The
+`::testing::AssertionResult` class solves this problem.
+
+An `AssertionResult` object represents the result of an assertion
+(whether it's a success or a failure, and an associated message).  You
+can create an `AssertionResult` using one of these factory
+functions:
+
+```
+namespace testing {
+
+// Returns an AssertionResult object to indicate that an assertion has
+// succeeded.
+AssertionResult AssertionSuccess();
+
+// Returns an AssertionResult object to indicate that an assertion has
+// failed.
+AssertionResult AssertionFailure();
+
+}
+```
+
+You can then use the `<<` operator to stream messages to the
+`AssertionResult` object.
+
+To provide more readable messages in Boolean assertions
+(e.g. `EXPECT_TRUE()`), write a predicate function that returns
+`AssertionResult` instead of `bool`. For example, if you define
+`IsEven()` as:
+
+```
+::testing::AssertionResult IsEven(int n) {
+  if ((n % 2) == 0)
+    return ::testing::AssertionSuccess();
+  else
+    return ::testing::AssertionFailure() << n << " is odd";
+}
+```
+
+instead of:
+
+```
+bool IsEven(int n) {
+  return (n % 2) == 0;
+}
+```
+
+the failed assertion `EXPECT_TRUE(IsEven(Fib(4)))` will print:
+
+<pre>
+Value of: !IsEven(Fib(4))<br>
+Actual: false (*3 is odd*)<br>
+Expected: true<br>
+</pre>
+
+instead of a more opaque
+
+<pre>
+Value of: !IsEven(Fib(4))<br>
+Actual: false<br>
+Expected: true<br>
+</pre>
+
+If you want informative messages in `EXPECT_FALSE` and `ASSERT_FALSE`
+as well, and are fine with making the predicate slower in the success
+case, you can supply a success message:
+
+```
+::testing::AssertionResult IsEven(int n) {
+  if ((n % 2) == 0)
+    return ::testing::AssertionSuccess() << n << " is even";
+  else
+    return ::testing::AssertionFailure() << n << " is odd";
+}
+```
+
+Then the statement `EXPECT_FALSE(IsEven(Fib(6)))` will print
+
+<pre>
+Value of: !IsEven(Fib(6))<br>
+Actual: true (8 is even)<br>
+Expected: false<br>
+</pre>
+
+_Availability_: Linux, Windows, Mac; since version 1.4.1.
+
+### Using a Predicate-Formatter ###
+
+If you find the default message generated by `(ASSERT|EXPECT)_PRED*` and
+`(ASSERT|EXPECT)_(TRUE|FALSE)` unsatisfactory, or some arguments to your
+predicate do not support streaming to `ostream`, you can instead use the
+following _predicate-formatter assertions_ to _fully_ customize how the
+message is formatted:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_PRED_FORMAT1(`_pred\_format1, val1_`);`        | `EXPECT_PRED_FORMAT1(`_pred\_format1, val1_`); | _pred\_format1(val1)_ is successful |
+| `ASSERT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | `EXPECT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | _pred\_format2(val1, val2)_ is successful |
+| `...`               | `...`                  | `...`        |
+
+The difference between this and the previous two groups of macros is that instead of
+a predicate, `(ASSERT|EXPECT)_PRED_FORMAT*` take a _predicate-formatter_
+(_pred\_formatn_), which is a function or functor with the signature:
+
+`::testing::AssertionResult PredicateFormattern(const char* `_expr1_`, const char* `_expr2_`, ... const char* `_exprn_`, T1 `_val1_`, T2 `_val2_`, ... Tn `_valn_`);`
+
+where _val1_, _val2_, ..., and _valn_ are the values of the predicate
+arguments, and _expr1_, _expr2_, ..., and _exprn_ are the corresponding
+expressions as they appear in the source code. The types `T1`, `T2`, ..., and
+`Tn` can be either value types or reference types. For example, if an
+argument has type `Foo`, you can declare it as either `Foo` or `const Foo&`,
+whichever is appropriate.
+
+A predicate-formatter returns a `::testing::AssertionResult` object to indicate
+whether the assertion has succeeded or not. The only way to create such an
+object is to call one of these factory functions:
+
+As an example, let's improve the failure message in the previous example, which uses `EXPECT_PRED2()`:
+
+```
+// Returns the smallest prime common divisor of m and n,
+// or 1 when m and n are mutually prime.
+int SmallestPrimeCommonDivisor(int m, int n) { ... }
+
+// A predicate-formatter for asserting that two integers are mutually prime.
+::testing::AssertionResult AssertMutuallyPrime(const char* m_expr,
+                                               const char* n_expr,
+                                               int m,
+                                               int n) {
+  if (MutuallyPrime(m, n))
+    return ::testing::AssertionSuccess();
+
+  return ::testing::AssertionFailure()
+      << m_expr << " and " << n_expr << " (" << m << " and " << n
+      << ") are not mutually prime, " << "as they have a common divisor "
+      << SmallestPrimeCommonDivisor(m, n);
+}
+```
+
+With this predicate-formatter, we can use
+
+```
+EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c);
+```
+
+to generate the message
+
+<pre>
+b and c (4 and 10) are not mutually prime, as they have a common divisor 2.<br>
+</pre>
+
+As you may have realized, many of the assertions we introduced earlier are
+special cases of `(EXPECT|ASSERT)_PRED_FORMAT*`. In fact, most of them are
+indeed defined using `(EXPECT|ASSERT)_PRED_FORMAT*`.
+
+_Availability_: Linux, Windows, Mac.
+
+
+## Floating-Point Comparison ##
+
+Comparing floating-point numbers is tricky. Due to round-off errors, it is
+very unlikely that two floating-points will match exactly. Therefore,
+`ASSERT_EQ` 's naive comparison usually doesn't work. And since floating-points
+can have a wide value range, no single fixed error bound works. It's better to
+compare by a fixed relative error bound, except for values close to 0 due to
+the loss of precision there.
+
+In general, for floating-point comparison to make sense, the user needs to
+carefully choose the error bound. If they don't want or care to, comparing in
+terms of Units in the Last Place (ULPs) is a good default, and Google Test
+provides assertions to do this. Full details about ULPs are quite long; if you
+want to learn more, see
+[this article on float comparison](http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm).
+
+### Floating-Point Macros ###
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_FLOAT_EQ(`_expected, actual_`);`  | `EXPECT_FLOAT_EQ(`_expected, actual_`);` | the two `float` values are almost equal |
+| `ASSERT_DOUBLE_EQ(`_expected, actual_`);` | `EXPECT_DOUBLE_EQ(`_expected, actual_`);` | the two `double` values are almost equal |
+
+By "almost equal", we mean the two values are within 4 ULP's from each
+other.
+
+The following assertions allow you to choose the acceptable error bound:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_NEAR(`_val1, val2, abs\_error_`);` | `EXPECT_NEAR`_(val1, val2, abs\_error_`);` | the difference between _val1_ and _val2_ doesn't exceed the given absolute error |
+
+_Availability_: Linux, Windows, Mac.
+
+### Floating-Point Predicate-Format Functions ###
+
+Some floating-point operations are useful, but not that often used. In order
+to avoid an explosion of new macros, we provide them as predicate-format
+functions that can be used in predicate assertion macros (e.g.
+`EXPECT_PRED_FORMAT2`, etc).
+
+```
+EXPECT_PRED_FORMAT2(::testing::FloatLE, val1, val2);
+EXPECT_PRED_FORMAT2(::testing::DoubleLE, val1, val2);
+```
+
+Verifies that _val1_ is less than, or almost equal to, _val2_. You can
+replace `EXPECT_PRED_FORMAT2` in the above table with `ASSERT_PRED_FORMAT2`.
+
+_Availability_: Linux, Windows, Mac.
+
+## Windows HRESULT assertions ##
+
+These assertions test for `HRESULT` success or failure.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_HRESULT_SUCCEEDED(`_expression_`);` | `EXPECT_HRESULT_SUCCEEDED(`_expression_`);` | _expression_ is a success `HRESULT` |
+| `ASSERT_HRESULT_FAILED(`_expression_`);`    | `EXPECT_HRESULT_FAILED(`_expression_`);`    | _expression_ is a failure `HRESULT` |
+
+The generated output contains the human-readable error message
+associated with the `HRESULT` code returned by _expression_.
+
+You might use them like this:
+
+```
+CComPtr shell;
+ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application"));
+CComVariant empty;
+ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty));
+```
+
+_Availability_: Windows.
+
+## Type Assertions ##
+
+You can call the function
+```
+::testing::StaticAssertTypeEq<T1, T2>();
+```
+to assert that types `T1` and `T2` are the same.  The function does
+nothing if the assertion is satisfied.  If the types are different,
+the function call will fail to compile, and the compiler error message
+will likely (depending on the compiler) show you the actual values of
+`T1` and `T2`.  This is mainly useful inside template code.
+
+_Caveat:_ When used inside a member function of a class template or a
+function template, `StaticAssertTypeEq<T1, T2>()` is effective _only if_
+the function is instantiated.  For example, given:
+```
+template <typename T> class Foo {
+ public:
+  void Bar() { ::testing::StaticAssertTypeEq<int, T>(); }
+};
+```
+the code:
+```
+void Test1() { Foo<bool> foo; }
+```
+will _not_ generate a compiler error, as `Foo<bool>::Bar()` is never
+actually instantiated.  Instead, you need:
+```
+void Test2() { Foo<bool> foo; foo.Bar(); }
+```
+to cause a compiler error.
+
+_Availability:_ Linux, Windows, Mac; since version 1.3.0.
+
+## Assertion Placement ##
+
+You can use assertions in any C++ function. In particular, it doesn't
+have to be a method of the test fixture class. The one constraint is
+that assertions that generate a fatal failure (`FAIL*` and `ASSERT_*`)
+can only be used in void-returning functions. This is a consequence of
+Google Test not using exceptions. By placing it in a non-void function
+you'll get a confusing compile error like
+`"error: void value not ignored as it ought to be"`.
+
+If you need to use assertions in a function that returns non-void, one option
+is to make the function return the value in an out parameter instead. For
+example, you can rewrite `T2 Foo(T1 x)` to `void Foo(T1 x, T2* result)`. You
+need to make sure that `*result` contains some sensible value even when the
+function returns prematurely. As the function now returns `void`, you can use
+any assertion inside of it.
+
+If changing the function's type is not an option, you should just use
+assertions that generate non-fatal failures, such as `ADD_FAILURE*` and
+`EXPECT_*`.
+
+_Note_: Constructors and destructors are not considered void-returning
+functions, according to the C++ language specification, and so you may not use
+fatal assertions in them. You'll get a compilation error if you try. A simple
+workaround is to transfer the entire body of the constructor or destructor to a
+private void-returning method. However, you should be aware that a fatal
+assertion failure in a constructor does not terminate the current test, as your
+intuition might suggest; it merely returns from the constructor early, possibly
+leaving your object in a partially-constructed state. Likewise, a fatal
+assertion failure in a destructor may leave your object in a
+partially-destructed state. Use assertions carefully in these situations!
+
+# Death Tests #
+
+In many applications, there are assertions that can cause application failure
+if a condition is not met. These sanity checks, which ensure that the program
+is in a known good state, are there to fail at the earliest possible time after
+some program state is corrupted. If the assertion checks the wrong condition,
+then the program may proceed in an erroneous state, which could lead to memory
+corruption, security holes, or worse. Hence it is vitally important to test
+that such assertion statements work as expected.
+
+Since these precondition checks cause the processes to die, we call such tests
+_death tests_. More generally, any test that checks that a program terminates
+in an expected fashion is also a death test.
+
+If you want to test `EXPECT_*()/ASSERT_*()` failures in your test code, see [Catching Failures](#catching-failures).
+
+## How to Write a Death Test ##
+
+Google Test has the following macros to support death tests:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_DEATH(`_statement, regex_`); | `EXPECT_DEATH(`_statement, regex_`); | _statement_ crashes with the given error |
+| `ASSERT_DEATH_IF_SUPPORTED(`_statement, regex_`); | `EXPECT_DEATH_IF_SUPPORTED(`_statement, regex_`); | if death tests are supported, verifies that _statement_ crashes with the given error; otherwise verifies nothing |
+| `ASSERT_EXIT(`_statement, predicate, regex_`); | `EXPECT_EXIT(`_statement, predicate, regex_`); |_statement_ exits with the given error and its exit code matches _predicate_ |
+
+where _statement_ is a statement that is expected to cause the process to
+die, _predicate_ is a function or function object that evaluates an integer
+exit status, and _regex_ is a regular expression that the stderr output of
+_statement_ is expected to match. Note that _statement_ can be _any valid
+statement_ (including _compound statement_) and doesn't have to be an
+expression.
+
+As usual, the `ASSERT` variants abort the current test function, while the
+`EXPECT` variants do not.
+
+**Note:** We use the word "crash" here to mean that the process
+terminates with a _non-zero_ exit status code.  There are two
+possibilities: either the process has called `exit()` or `_exit()`
+with a non-zero value, or it may be killed by a signal.
+
+This means that if _statement_ terminates the process with a 0 exit
+code, it is _not_ considered a crash by `EXPECT_DEATH`.  Use
+`EXPECT_EXIT` instead if this is the case, or if you want to restrict
+the exit code more precisely.
+
+A predicate here must accept an `int` and return a `bool`. The death test
+succeeds only if the predicate returns `true`. Google Test defines a few
+predicates that handle the most common cases:
+
+```
+::testing::ExitedWithCode(exit_code)
+```
+
+This expression is `true` if the program exited normally with the given exit
+code.
+
+```
+::testing::KilledBySignal(signal_number)  // Not available on Windows.
+```
+
+This expression is `true` if the program was killed by the given signal.
+
+The `*_DEATH` macros are convenient wrappers for `*_EXIT` that use a predicate
+that verifies the process' exit code is non-zero.
+
+Note that a death test only cares about three things:
+
+  1. does _statement_ abort or exit the process?
+  1. (in the case of `ASSERT_EXIT` and `EXPECT_EXIT`) does the exit status satisfy _predicate_?  Or (in the case of `ASSERT_DEATH` and `EXPECT_DEATH`) is the exit status non-zero?  And
+  1. does the stderr output match _regex_?
+
+In particular, if _statement_ generates an `ASSERT_*` or `EXPECT_*` failure, it will **not** cause the death test to fail, as Google Test assertions don't abort the process.
+
+To write a death test, simply use one of the above macros inside your test
+function. For example,
+
+```
+TEST(My*DeathTest*, Foo) {
+  // This death test uses a compound statement.
+  ASSERT_DEATH({ int n = 5; Foo(&n); }, "Error on line .* of Foo()");
+}
+TEST(MyDeathTest, NormalExit) {
+  EXPECT_EXIT(NormalExit(), ::testing::ExitedWithCode(0), "Success");
+}
+TEST(MyDeathTest, KillMyself) {
+  EXPECT_EXIT(KillMyself(), ::testing::KilledBySignal(SIGKILL), "Sending myself unblockable signal");
+}
+```
+
+verifies that:
+
+  * calling `Foo(5)` causes the process to die with the given error message,
+  * calling `NormalExit()` causes the process to print `"Success"` to stderr and exit with exit code 0, and
+  * calling `KillMyself()` kills the process with signal `SIGKILL`.
+
+The test function body may contain other assertions and statements as well, if
+necessary.
+
+_Important:_ We strongly recommend you to follow the convention of naming your
+test case (not test) `*DeathTest` when it contains a death test, as
+demonstrated in the above example. The `Death Tests And Threads` section below
+explains why.
+
+If a test fixture class is shared by normal tests and death tests, you
+can use typedef to introduce an alias for the fixture class and avoid
+duplicating its code:
+```
+class FooTest : public ::testing::Test { ... };
+
+typedef FooTest FooDeathTest;
+
+TEST_F(FooTest, DoesThis) {
+  // normal test
+}
+
+TEST_F(FooDeathTest, DoesThat) {
+  // death test
+}
+```
+
+_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Cygwin, and Mac (the latter three are supported since v1.3.0).  `(ASSERT|EXPECT)_DEATH_IF_SUPPORTED` are new in v1.4.0.
+
+## Regular Expression Syntax ##
+
+On POSIX systems (e.g. Linux, Cygwin, and Mac), Google Test uses the
+[POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
+syntax in death tests. To learn about this syntax, you may want to read this [Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
+
+On Windows, Google Test uses its own simple regular expression
+implementation. It lacks many features you can find in POSIX extended
+regular expressions.  For example, we don't support union (`"x|y"`),
+grouping (`"(xy)"`), brackets (`"[xy]"`), and repetition count
+(`"x{5,7}"`), among others. Below is what we do support (`A` denotes a
+literal character, period (`.`), or a single `\\` escape sequence; `x`
+and `y` denote regular expressions.):
+
+| `c` | matches any literal character `c` |
+|:----|:----------------------------------|
+| `\\d` | matches any decimal digit         |
+| `\\D` | matches any character that's not a decimal digit |
+| `\\f` | matches `\f`                      |
+| `\\n` | matches `\n`                      |
+| `\\r` | matches `\r`                      |
+| `\\s` | matches any ASCII whitespace, including `\n` |
+| `\\S` | matches any character that's not a whitespace |
+| `\\t` | matches `\t`                      |
+| `\\v` | matches `\v`                      |
+| `\\w` | matches any letter, `_`, or decimal digit |
+| `\\W` | matches any character that `\\w` doesn't match |
+| `\\c` | matches any literal character `c`, which must be a punctuation |
+| `.` | matches any single character except `\n` |
+| `A?` | matches 0 or 1 occurrences of `A` |
+| `A*` | matches 0 or many occurrences of `A` |
+| `A+` | matches 1 or many occurrences of `A` |
+| `^` | matches the beginning of a string (not that of each line) |
+| `$` | matches the end of a string (not that of each line) |
+| `xy` | matches `x` followed by `y`       |
+
+To help you determine which capability is available on your system,
+Google Test defines macro `GTEST_USES_POSIX_RE=1` when it uses POSIX
+extended regular expressions, or `GTEST_USES_SIMPLE_RE=1` when it uses
+the simple version.  If you want your death tests to work in both
+cases, you can either `#if` on these macros or use the more limited
+syntax only.
+
+## How It Works ##
+
+Under the hood, `ASSERT_EXIT()` spawns a new process and executes the
+death test statement in that process. The details of of how precisely
+that happens depend on the platform and the variable
+`::testing::GTEST_FLAG(death_test_style)` (which is initialized from the
+command-line flag `--gtest_death_test_style`).
+
+  * On POSIX systems, `fork()` (or `clone()` on Linux) is used to spawn the child, after which:
+    * If the variable's value is `"fast"`, the death test statement is immediately executed.
+    * If the variable's value is `"threadsafe"`, the child process re-executes the unit test binary just as it was originally invoked, but with some extra flags to cause just the single death test under consideration to be run.
+  * On Windows, the child is spawned using the `CreateProcess()` API, and re-executes the binary to cause just the single death test under consideration to be run - much like the `threadsafe` mode on POSIX.
+
+Other values for the variable are illegal and will cause the death test to
+fail. Currently, the flag's default value is `"fast"`. However, we reserve the
+right to change it in the future. Therefore, your tests should not depend on
+this.
+
+In either case, the parent process waits for the child process to complete, and checks that
+
+  1. the child's exit status satisfies the predicate, and
+  1. the child's stderr matches the regular expression.
+
+If the death test statement runs to completion without dying, the child
+process will nonetheless terminate, and the assertion fails.
+
+## Death Tests And Threads ##
+
+The reason for the two death test styles has to do with thread safety. Due to
+well-known problems with forking in the presence of threads, death tests should
+be run in a single-threaded context. Sometimes, however, it isn't feasible to
+arrange that kind of environment. For example, statically-initialized modules
+may start threads before main is ever reached. Once threads have been created,
+it may be difficult or impossible to clean them up.
+
+Google Test has three features intended to raise awareness of threading issues.
+
+  1. A warning is emitted if multiple threads are running when a death test is encountered.
+  1. Test cases with a name ending in "DeathTest" are run before all other tests.
+  1. It uses `clone()` instead of `fork()` to spawn the child process on Linux (`clone()` is not available on Cygwin and Mac), as `fork()` is more likely to cause the child to hang when the parent process has multiple threads.
+
+It's perfectly fine to create threads inside a death test statement; they are
+executed in a separate process and cannot affect the parent.
+
+## Death Test Styles ##
+
+The "threadsafe" death test style was introduced in order to help mitigate the
+risks of testing in a possibly multithreaded environment. It trades increased
+test execution time (potentially dramatically so) for improved thread safety.
+We suggest using the faster, default "fast" style unless your test has specific
+problems with it.
+
+You can choose a particular style of death tests by setting the flag
+programmatically:
+
+```
+::testing::FLAGS_gtest_death_test_style = "threadsafe";
+```
+
+You can do this in `main()` to set the style for all death tests in the
+binary, or in individual tests. Recall that flags are saved before running each
+test and restored afterwards, so you need not do that yourself. For example:
+
+```
+TEST(MyDeathTest, TestOne) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+  // This test is run in the "threadsafe" style:
+  ASSERT_DEATH(ThisShouldDie(), "");
+}
+
+TEST(MyDeathTest, TestTwo) {
+  // This test is run in the "fast" style:
+  ASSERT_DEATH(ThisShouldDie(), "");
+}
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  ::testing::FLAGS_gtest_death_test_style = "fast";
+  return RUN_ALL_TESTS();
+}
+```
+
+## Caveats ##
+
+The _statement_ argument of `ASSERT_EXIT()` can be any valid C++ statement
+except that it can not return from the current function. This means
+_statement_ should not contain `return` or a macro that might return (e.g.
+`ASSERT_TRUE()` ). If _statement_ returns before it crashes, Google Test will
+print an error message, and the test will fail.
+
+Since _statement_ runs in the child process, any in-memory side effect (e.g.
+modifying a variable, releasing memory, etc) it causes will _not_ be observable
+in the parent process. In particular, if you release memory in a death test,
+your program will fail the heap check as the parent process will never see the
+memory reclaimed. To solve this problem, you can
+
+  1. try not to free memory in a death test;
+  1. free the memory again in the parent process; or
+  1. do not use the heap checker in your program.
+
+Due to an implementation detail, you cannot place multiple death test
+assertions on the same line; otherwise, compilation will fail with an unobvious
+error message.
+
+Despite the improved thread safety afforded by the "threadsafe" style of death
+test, thread problems such as deadlock are still possible in the presence of
+handlers registered with `pthread_atfork(3)`.
+
+# Using Assertions in Sub-routines #
+
+## Adding Traces to Assertions ##
+
+If a test sub-routine is called from several places, when an assertion
+inside it fails, it can be hard to tell which invocation of the
+sub-routine the failure is from.  You can alleviate this problem using
+extra logging or custom failure messages, but that usually clutters up
+your tests. A better solution is to use the `SCOPED_TRACE` macro:
+
+| `SCOPED_TRACE(`_message_`);` |
+|:-----------------------------|
+
+where _message_ can be anything streamable to `std::ostream`. This
+macro will cause the current file name, line number, and the given
+message to be added in every failure message. The effect will be
+undone when the control leaves the current lexical scope.
+
+For example,
+
+```
+10: void Sub1(int n) {
+11:   EXPECT_EQ(1, Bar(n));
+12:   EXPECT_EQ(2, Bar(n + 1));
+13: }
+14:
+15: TEST(FooTest, Bar) {
+16:   {
+17:     SCOPED_TRACE("A");  // This trace point will be included in
+18:                         // every failure in this scope.
+19:     Sub1(1);
+20:   }
+21:   // Now it won't.
+22:   Sub1(9);
+23: }
+```
+
+could result in messages like these:
+
+```
+path/to/foo_test.cc:11: Failure
+Value of: Bar(n)
+Expected: 1
+  Actual: 2
+   Trace:
+path/to/foo_test.cc:17: A
+
+path/to/foo_test.cc:12: Failure
+Value of: Bar(n + 1)
+Expected: 2
+  Actual: 3
+```
+
+Without the trace, it would've been difficult to know which invocation
+of `Sub1()` the two failures come from respectively. (You could add an
+extra message to each assertion in `Sub1()` to indicate the value of
+`n`, but that's tedious.)
+
+Some tips on using `SCOPED_TRACE`:
+
+  1. With a suitable message, it's often enough to use `SCOPED_TRACE` at the beginning of a sub-routine, instead of at each call site.
+  1. When calling sub-routines inside a loop, make the loop iterator part of the message in `SCOPED_TRACE` such that you can know which iteration the failure is from.
+  1. Sometimes the line number of the trace point is enough for identifying the particular invocation of a sub-routine. In this case, you don't have to choose a unique message for `SCOPED_TRACE`. You can simply use `""`.
+  1. You can use `SCOPED_TRACE` in an inner scope when there is one in the outer scope. In this case, all active trace points will be included in the failure messages, in reverse order they are encountered.
+  1. The trace dump is clickable in Emacs' compilation buffer - hit return on a line number and you'll be taken to that line in the source file!
+
+_Availability:_ Linux, Windows, Mac.
+
+## Propagating Fatal Failures ##
+
+A common pitfall when using `ASSERT_*` and `FAIL*` is not understanding that
+when they fail they only abort the _current function_, not the entire test. For
+example, the following test will segfault:
+```
+void Subroutine() {
+  // Generates a fatal failure and aborts the current function.
+  ASSERT_EQ(1, 2);
+  // The following won't be executed.
+  ...
+}
+
+TEST(FooTest, Bar) {
+  Subroutine();
+  // The intended behavior is for the fatal failure
+  // in Subroutine() to abort the entire test.
+  // The actual behavior: the function goes on after Subroutine() returns.
+  int* p = NULL;
+  *p = 3; // Segfault!
+}
+```
+
+Since we don't use exceptions, it is technically impossible to
+implement the intended behavior here.  To alleviate this, Google Test
+provides two solutions.  You could use either the
+`(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the
+`HasFatalFailure()` function.  They are described in the following two
+subsections.
+
+
+
+### Asserting on Subroutines ###
+
+As shown above, if your test calls a subroutine that has an `ASSERT_*`
+failure in it, the test will continue after the subroutine
+returns. This may not be what you want.
+
+Often people want fatal failures to propagate like exceptions.  For
+that Google Test offers the following macros:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_NO_FATAL_FAILURE(`_statement_`);` | `EXPECT_NO_FATAL_FAILURE(`_statement_`);` | _statement_ doesn't generate any new fatal failures in the current thread. |
+
+Only failures in the thread that executes the assertion are checked to
+determine the result of this type of assertions.  If _statement_
+creates new threads, failures in these threads are ignored.
+
+Examples:
+
+```
+ASSERT_NO_FATAL_FAILURE(Foo());
+
+int i;
+EXPECT_NO_FATAL_FAILURE({
+  i = Bar();
+});
+```
+
+_Availability:_ Linux, Windows, Mac. Assertions from multiple threads
+are currently not supported.
+
+### Checking for Failures in the Current Test ###
+
+`HasFatalFailure()` in the `::testing::Test` class returns `true` if an
+assertion in the current test has suffered a fatal failure. This
+allows functions to catch fatal failures in a sub-routine and return
+early.
+
+```
+class Test {
+ public:
+  ...
+  static bool HasFatalFailure();
+};
+```
+
+The typical usage, which basically simulates the behavior of a thrown
+exception, is:
+
+```
+TEST(FooTest, Bar) {
+  Subroutine();
+  // Aborts if Subroutine() had a fatal failure.
+  if (HasFatalFailure())
+    return;
+  // The following won't be executed.
+  ...
+}
+```
+
+If `HasFatalFailure()` is used outside of `TEST()` , `TEST_F()` , or a test
+fixture, you must add the `::testing::Test::` prefix, as in:
+
+```
+if (::testing::Test::HasFatalFailure())
+  return;
+```
+
+Similarly, `HasNonfatalFailure()` returns `true` if the current test
+has at least one non-fatal failure, and `HasFailure()` returns `true`
+if the current test has at least one failure of either kind.
+
+_Availability:_ Linux, Windows, Mac.  `HasNonfatalFailure()` and
+`HasFailure()` are available since version 1.4.0.
+
+# Logging Additional Information #
+
+In your test code, you can call `RecordProperty("key", value)` to log
+additional information, where `value` can be either a C string or a 32-bit
+integer. The _last_ value recorded for a key will be emitted to the XML output
+if you specify one. For example, the test
+
+```
+TEST_F(WidgetUsageTest, MinAndMaxWidgets) {
+  RecordProperty("MaximumWidgets", ComputeMaxUsage());
+  RecordProperty("MinimumWidgets", ComputeMinUsage());
+}
+```
+
+will output XML like this:
+
+```
+...
+  <testcase name="MinAndMaxWidgets" status="run" time="6" classname="WidgetUsageTest"
+            MaximumWidgets="12"
+            MinimumWidgets="9" />
+...
+```
+
+_Note_:
+  * `RecordProperty()` is a static member of the `Test` class. Therefore it needs to be prefixed with `::testing::Test::` if used outside of the `TEST` body and the test fixture class.
+  * `key` must be a valid XML attribute name, and cannot conflict with the ones already used by Google Test (`name`, `status`,     `time`, and `classname`).
+
+_Availability_: Linux, Windows, Mac.
+
+# Sharing Resources Between Tests in the Same Test Case #
+
+
+
+Google Test creates a new test fixture object for each test in order to make
+tests independent and easier to debug. However, sometimes tests use resources
+that are expensive to set up, making the one-copy-per-test model prohibitively
+expensive.
+
+If the tests don't change the resource, there's no harm in them sharing a
+single resource copy. So, in addition to per-test set-up/tear-down, Google Test
+also supports per-test-case set-up/tear-down. To use it:
+
+  1. In your test fixture class (say `FooTest` ), define as `static` some member variables to hold the shared resources.
+  1. In the same test fixture class, define a `static void SetUpTestCase()` function (remember not to spell it as **`SetupTestCase`** with a small `u`!) to set up the shared resources and a `static void TearDownTestCase()` function to tear them down.
+
+That's it! Google Test automatically calls `SetUpTestCase()` before running the
+_first test_ in the `FooTest` test case (i.e. before creating the first
+`FooTest` object), and calls `TearDownTestCase()` after running the _last test_
+in it (i.e. after deleting the last `FooTest` object). In between, the tests
+can use the shared resources.
+
+Remember that the test order is undefined, so your code can't depend on a test
+preceding or following another. Also, the tests must either not modify the
+state of any shared resource, or, if they do modify the state, they must
+restore the state to its original value before passing control to the next
+test.
+
+Here's an example of per-test-case set-up and tear-down:
+```
+class FooTest : public ::testing::Test {
+ protected:
+  // Per-test-case set-up.
+  // Called before the first test in this test case.
+  // Can be omitted if not needed.
+  static void SetUpTestCase() {
+    shared_resource_ = new ...;
+  }
+
+  // Per-test-case tear-down.
+  // Called after the last test in this test case.
+  // Can be omitted if not needed.
+  static void TearDownTestCase() {
+    delete shared_resource_;
+    shared_resource_ = NULL;
+  }
+
+  // You can define per-test set-up and tear-down logic as usual.
+  virtual void SetUp() { ... }
+  virtual void TearDown() { ... }
+
+  // Some expensive resource shared by all tests.
+  static T* shared_resource_;
+};
+
+T* FooTest::shared_resource_ = NULL;
+
+TEST_F(FooTest, Test1) {
+  ... you can refer to shared_resource here ...
+}
+TEST_F(FooTest, Test2) {
+  ... you can refer to shared_resource here ...
+}
+```
+
+_Availability:_ Linux, Windows, Mac.
+
+# Global Set-Up and Tear-Down #
+
+Just as you can do set-up and tear-down at the test level and the test case
+level, you can also do it at the test program level. Here's how.
+
+First, you subclass the `::testing::Environment` class to define a test
+environment, which knows how to set-up and tear-down:
+
+```
+class Environment {
+ public:
+  virtual ~Environment() {}
+  // Override this to define how to set up the environment.
+  virtual void SetUp() {}
+  // Override this to define how to tear down the environment.
+  virtual void TearDown() {}
+};
+```
+
+Then, you register an instance of your environment class with Google Test by
+calling the `::testing::AddGlobalTestEnvironment()` function:
+
+```
+Environment* AddGlobalTestEnvironment(Environment* env);
+```
+
+Now, when `RUN_ALL_TESTS()` is called, it first calls the `SetUp()` method of
+the environment object, then runs the tests if there was no fatal failures, and
+finally calls `TearDown()` of the environment object.
+
+It's OK to register multiple environment objects. In this case, their `SetUp()`
+will be called in the order they are registered, and their `TearDown()` will be
+called in the reverse order.
+
+Note that Google Test takes ownership of the registered environment objects.
+Therefore **do not delete them** by yourself.
+
+You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is
+called, probably in `main()`. If you use `gtest_main`, you need to      call
+this before `main()` starts for it to take effect. One way to do this is to
+define a global variable like this:
+
+```
+::testing::Environment* const foo_env = ::testing::AddGlobalTestEnvironment(new FooEnvironment);
+```
+
+However, we strongly recommend you to write your own `main()` and call
+`AddGlobalTestEnvironment()` there, as relying on initialization of global
+variables makes the code harder to read and may cause problems when you
+register multiple environments from different translation units and the
+environments have dependencies among them (remember that the compiler doesn't
+guarantee the order in which global variables from different translation units
+are initialized).
+
+_Availability:_ Linux, Windows, Mac.
+
+
+# Value Parameterized Tests #
+
+_Value-parameterized tests_ allow you to test your code with different
+parameters without writing multiple copies of the same test.
+
+Suppose you write a test for your code and then realize that your code is affected by a presence of a Boolean command line flag.
+
+```
+TEST(MyCodeTest, TestFoo) {
+  // A code to test foo().
+}
+```
+
+Usually people factor their test code into a function with a Boolean parameter in such situations. The function sets the flag, then executes the testing code.
+
+```
+void TestFooHelper(bool flag_value) {
+  flag = flag_value;
+  // A code to test foo().
+}
+
+TEST(MyCodeTest, TestFooo) {
+  TestFooHelper(false);
+  TestFooHelper(true);
+}
+```
+
+But this setup has serious drawbacks. First, when a test assertion fails in your tests, it becomes unclear what value of the parameter caused it to fail. You can stream a clarifying message into your `EXPECT`/`ASSERT` statements, but it you'll have to do it with all of them. Second, you have to add one such helper function per test. What if you have ten tests? Twenty? A hundred?
+
+Value-parameterized tests will let you write your test only once and then easily instantiate and run it with an arbitrary number of parameter values.
+
+Here are some other situations when value-parameterized tests come handy:
+
+  * You wan to test different implementations of an OO interface.
+  * You want to test your code over various inputs (a.k.a. data-driven testing). This feature is easy to abuse, so please exercise your good sense when doing it!
+
+## How to Write Value-Parameterized Tests ##
+
+To write value-parameterized tests, first you should define a fixture
+class. It must be derived from `::testing::TestWithParam<T>`, where `T`
+is the type of your parameter values. `TestWithParam<T>` is itself
+derived from `::testing::Test`. `T` can be any copyable type. If it's
+a raw pointer, you are responsible for managing the lifespan of the
+pointed values.
+
+```
+class FooTest : public ::testing::TestWithParam<const char*> {
+  // You can implement all the usual fixture class members here.
+  // To access the test parameter, call GetParam() from class
+  // TestWithParam<T>.
+};
+```
+
+Then, use the `TEST_P` macro to define as many test patterns using
+this fixture as you want.  The `_P` suffix is for "parameterized" or
+"pattern", whichever you prefer to think.
+
+```
+TEST_P(FooTest, DoesBlah) {
+  // Inside a test, access the test parameter with the GetParam() method
+  // of the TestWithParam<T> class:
+  EXPECT_TRUE(foo.Blah(GetParam()));
+  ...
+}
+
+TEST_P(FooTest, HasBlahBlah) {
+  ...
+}
+```
+
+Finally, you can use `INSTANTIATE_TEST_CASE_P` to instantiate the test
+case with 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 are all in the `testing` namespace:
+
+| `Range(begin, end[, step])` | Yields values `{begin, begin+step, begin+step+step, ...}`. The values do not include `end`. `step` defaults to 1. |
+|:----------------------------|:------------------------------------------------------------------------------------------------------------------|
+| `Values(v1, v2, ..., vN)`   | Yields values `{v1, v2, ..., vN}`.                                                                                |
+| `ValuesIn(container)` and `ValuesIn(begin, end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)`.                  |
+| `Bool()`                    | Yields sequence `{false, true}`.                                                                                  |
+| `Combine(g1, g2, ..., gN)`  | Yields all combinations (the Cartesian product for the math savvy) of the values generated by the `N` generators. This is only available if your system provides the `<tr1/tuple>` header. If you are sure your system does, and Google Test disagrees, you can override it by defining `GTEST_HAS_TR1_TUPLE=1`. See comments in [include/gtest/internal/gtest-port.h](../include/gtest/internal/gtest-port.h) for more information. |
+
+For more details, see the comments at the definitions of these functions in the [source code](../include/gtest/gtest-param-test.h).
+
+The following statement will instantiate tests from the `FooTest` test case
+each with parameter values `"meeny"`, `"miny"`, and `"moe"`.
+
+```
+INSTANTIATE_TEST_CASE_P(InstantiationName,
+                        FooTest,
+                        ::testing::Values("meeny", "miny", "moe"));
+```
+
+To distinguish different instances of the pattern (yes, you can
+instantiate it more than once), the first argument to
+`INSTANTIATE_TEST_CASE_P` is a prefix that will be added to the actual
+test case name. Remember to pick unique prefixes for different
+instantiations. The tests from the instantiation above will have these
+names:
+
+  * `InstantiationName/FooTest.DoesBlah/0` for `"meeny"`
+  * `InstantiationName/FooTest.DoesBlah/1` for `"miny"`
+  * `InstantiationName/FooTest.DoesBlah/2` for `"moe"`
+  * `InstantiationName/FooTest.HasBlahBlah/0` for `"meeny"`
+  * `InstantiationName/FooTest.HasBlahBlah/1` for `"miny"`
+  * `InstantiationName/FooTest.HasBlahBlah/2` for `"moe"`
+
+You can use these names in [--gtest\-filter](#running-a-subset-of-the-tests).
+
+This statement will instantiate all tests from `FooTest` again, each
+with parameter values `"cat"` and `"dog"`:
+
+```
+const char* pets[] = {"cat", "dog"};
+INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest,
+                        ::testing::ValuesIn(pets));
+```
+
+The tests from the instantiation above will have these names:
+
+  * `AnotherInstantiationName/FooTest.DoesBlah/0` for `"cat"`
+  * `AnotherInstantiationName/FooTest.DoesBlah/1` for `"dog"`
+  * `AnotherInstantiationName/FooTest.HasBlahBlah/0` for `"cat"`
+  * `AnotherInstantiationName/FooTest.HasBlahBlah/1` for `"dog"`
+
+Please note that `INSTANTIATE_TEST_CASE_P` will instantiate _all_
+tests in the given test case, whether their definitions come before or
+_after_ the `INSTANTIATE_TEST_CASE_P` statement.
+
+You can see
+[these](../samples/sample7_unittest.cc)
+[files](../samples/sample8_unittest.cc) for more examples.
+
+_Availability_: Linux, Windows (requires MSVC 8.0 or above), Mac; since version 1.2.0.
+
+## Creating Value-Parameterized Abstract Tests ##
+
+In the above, we define and instantiate `FooTest` in the same source
+file. Sometimes you may want to define value-parameterized tests in a
+library and let other people instantiate them later. This pattern is
+known as <i>abstract tests</i>. As an example of its application, when you
+are designing an interface you can write a standard suite of abstract
+tests (perhaps using a factory function as the test parameter) that
+all implementations of the interface are expected to pass. When
+someone implements the interface, he can instantiate your suite to get
+all the interface-conformance tests for free.
+
+To define abstract tests, you should organize your code like this:
+
+  1. Put the definition of the parameterized test fixture class (e.g. `FooTest`) in a header file, say `foo_param_test.h`. Think of this as _declaring_ your abstract tests.
+  1. Put the `TEST_P` definitions in `foo_param_test.cc`, which includes `foo_param_test.h`. Think of this as _implementing_ your abstract tests.
+
+Once they are defined, you can instantiate them by including
+`foo_param_test.h`, invoking `INSTANTIATE_TEST_CASE_P()`, and linking
+with `foo_param_test.cc`. You can instantiate the same abstract test
+case multiple times, possibly in different source files.
+
+# Typed Tests #
+
+Suppose you have multiple implementations of the same interface and
+want to make sure that all of them satisfy some common requirements.
+Or, you may have defined several types that are supposed to conform to
+the same "concept" and you want to verify it.  In both cases, you want
+the same test logic repeated for different types.
+
+While you can write one `TEST` or `TEST_F` for each type you want to
+test (and you may even factor the test logic into a function template
+that you invoke from the `TEST`), it's tedious and doesn't scale:
+if you want _m_ tests over _n_ types, you'll end up writing _m\*n_
+`TEST`s.
+
+_Typed tests_ allow you to repeat the same test logic over a list of
+types.  You only need to write the test logic once, although you must
+know the type list when writing typed tests.  Here's how you do it:
+
+First, define a fixture class template.  It should be parameterized
+by a type.  Remember to derive it from `::testing::Test`:
+
+```
+template <typename T>
+class FooTest : public ::testing::Test {
+ public:
+  ...
+  typedef std::list<T> List;
+  static T shared_;
+  T value_;
+};
+```
+
+Next, associate a list of types with the test case, which will be
+repeated for each type in the list:
+
+```
+typedef ::testing::Types<char, int, unsigned int> MyTypes;
+TYPED_TEST_CASE(FooTest, MyTypes);
+```
+
+The `typedef` is necessary for the `TYPED_TEST_CASE` macro to parse
+correctly.  Otherwise the compiler will think that each comma in the
+type list introduces a new macro argument.
+
+Then, use `TYPED_TEST()` instead of `TEST_F()` to define a typed test
+for this test case.  You can repeat this as many times as you want:
+
+```
+TYPED_TEST(FooTest, DoesBlah) {
+  // Inside a test, refer to the special name TypeParam to get the type
+  // parameter.  Since we are inside a derived class template, C++ requires
+  // us to visit the members of FooTest via 'this'.
+  TypeParam n = this->value_;
+
+  // To visit static members of the fixture, add the 'TestFixture::'
+  // prefix.
+  n += TestFixture::shared_;
+
+  // To refer to typedefs in the fixture, add the 'typename TestFixture::'
+  // prefix.  The 'typename' is required to satisfy the compiler.
+  typename TestFixture::List values;
+  values.push_back(n);
+  ...
+}
+
+TYPED_TEST(FooTest, HasPropertyA) { ... }
+```
+
+You can see `samples/sample6_unittest.cc` for a complete example.
+
+_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
+since version 1.1.0.
+
+# Type-Parameterized Tests #
+
+_Type-parameterized tests_ are like typed tests, except that they
+don't require you to know the list of types ahead of time.  Instead,
+you can define the test logic first and instantiate it with different
+type lists later.  You can even instantiate it more than once in the
+same program.
+
+If you are designing an interface or concept, you can define a suite
+of type-parameterized tests to verify properties that any valid
+implementation of the interface/concept should have.  Then, the author
+of each implementation can just instantiate the test suite with his
+type to verify that it conforms to the requirements, without having to
+write similar tests repeatedly.  Here's an example:
+
+First, define a fixture class template, as we did with typed tests:
+
+```
+template <typename T>
+class FooTest : public ::testing::Test {
+  ...
+};
+```
+
+Next, declare that you will define a type-parameterized test case:
+
+```
+TYPED_TEST_CASE_P(FooTest);
+```
+
+The `_P` suffix is for "parameterized" or "pattern", whichever you
+prefer to think.
+
+Then, use `TYPED_TEST_P()` to define a type-parameterized test.  You
+can repeat this as many times as you want:
+
+```
+TYPED_TEST_P(FooTest, DoesBlah) {
+  // Inside a test, refer to TypeParam to get the type parameter.
+  TypeParam n = 0;
+  ...
+}
+
+TYPED_TEST_P(FooTest, HasPropertyA) { ... }
+```
+
+Now the tricky part: you need to register all test patterns using the
+`REGISTER_TYPED_TEST_CASE_P` macro before you can instantiate them.
+The first argument of the macro is the test case name; the rest are
+the names of the tests in this test case:
+
+```
+REGISTER_TYPED_TEST_CASE_P(FooTest,
+                           DoesBlah, HasPropertyA);
+```
+
+Finally, you are free to instantiate the pattern with the types you
+want.  If you put the above code in a header file, you can `#include`
+it in multiple C++ source files and instantiate it multiple times.
+
+```
+typedef ::testing::Types<char, int, unsigned int> MyTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
+```
+
+To distinguish different instances of the pattern, the first argument
+to the `INSTANTIATE_TYPED_TEST_CASE_P` macro is a prefix that will be
+added to the actual test case name.  Remember to pick unique prefixes
+for different instances.
+
+In the special case where the type list contains only one type, you
+can write that type directly without `::testing::Types<...>`, like this:
+
+```
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
+```
+
+You can see `samples/sample6_unittest.cc` for a complete example.
+
+_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
+since version 1.1.0.
+
+# Testing Private Code #
+
+If you change your software's internal implementation, your tests should not
+break as long as the change is not observable by users. Therefore, per the
+_black-box testing principle_, most of the time you should test your code
+through its public interfaces.
+
+If you still find yourself needing to test internal implementation code,
+consider if there's a better design that wouldn't require you to do so. If you
+absolutely have to test non-public interface code though, you can. There are
+two cases to consider:
+
+  * Static functions (_not_ the same as static member functions!) or unnamed namespaces, and
+  * Private or protected class members
+
+## Static Functions ##
+
+Both static functions and definitions/declarations in an unnamed namespace are
+only visible within the same translation unit. To test them, you can `#include`
+the entire `.cc` file being tested in your `*_test.cc` file. (`#include`ing `.cc`
+files is not a good way to reuse code - you should not do this in production
+code!)
+
+However, a better approach is to move the private code into the
+`foo::internal` namespace, where `foo` is the namespace your project normally
+uses, and put the private declarations in a `*-internal.h` file. Your
+production `.cc` files and your tests are allowed to include this internal
+header, but your clients are not. This way, you can fully test your internal
+implementation without leaking it to your clients.
+
+## Private Class Members ##
+
+Private class members are only accessible from within the class or by friends.
+To access a class' private members, you can declare your test fixture as a
+friend to the class and define accessors in your fixture. Tests using the
+fixture can then access the private members of your production class via the
+accessors in the fixture. Note that even though your fixture is a friend to
+your production class, your tests are not automatically friends to it, as they
+are technically defined in sub-classes of the fixture.
+
+Another way to test private members is to refactor them into an implementation
+class, which is then declared in a `*-internal.h` file. Your clients aren't
+allowed to include this header but your tests can. Such is called the Pimpl
+(Private Implementation) idiom.
+
+Or, you can declare an individual test as a friend of your class by adding this
+line in the class body:
+
+```
+FRIEND_TEST(TestCaseName, TestName);
+```
+
+For example,
+```
+// foo.h
+#include <gtest/gtest_prod.h>
+
+// Defines FRIEND_TEST.
+class Foo {
+  ...
+ private:
+  FRIEND_TEST(FooTest, BarReturnsZeroOnNull);
+  int Bar(void* x);
+};
+
+// foo_test.cc
+...
+TEST(FooTest, BarReturnsZeroOnNull) {
+  Foo foo;
+  EXPECT_EQ(0, foo.Bar(NULL));
+  // Uses Foo's private member Bar().
+}
+```
+
+Pay special attention when your class is defined in a namespace, as you should
+define your test fixtures and tests in the same namespace if you want them to
+be friends of your class. For example, if the code to be tested looks like:
+
+```
+namespace my_namespace {
+
+class Foo {
+  friend class FooTest;
+  FRIEND_TEST(FooTest, Bar);
+  FRIEND_TEST(FooTest, Baz);
+  ...
+  definition of the class Foo
+  ...
+};
+
+}  // namespace my_namespace
+```
+
+Your test code should be something like:
+
+```
+namespace my_namespace {
+class FooTest : public ::testing::Test {
+ protected:
+  ...
+};
+
+TEST_F(FooTest, Bar) { ... }
+TEST_F(FooTest, Baz) { ... }
+
+}  // namespace my_namespace
+```
+
+# Catching Failures #
+
+If you are building a testing utility on top of Google Test, you'll
+want to test your utility.  What framework would you use to test it?
+Google Test, of course.
+
+The challenge is to verify that your testing utility reports failures
+correctly.  In frameworks that report a failure by throwing an
+exception, you could catch the exception and assert on it.  But Google
+Test doesn't use exceptions, so how do we test that a piece of code
+generates an expected failure?
+
+`<gtest/gtest-spi.h>` contains some constructs to do this.  After
+`#include`ing this header, you can use
+
+| `EXPECT_FATAL_FAILURE(`_statement, substring_`);` |
+|:--------------------------------------------------|
+
+to assert that _statement_ generates a fatal (e.g. `ASSERT_*`) failure
+whose message contains the given _substring_, or use
+
+| `EXPECT_NONFATAL_FAILURE(`_statement, substring_`);` |
+|:-----------------------------------------------------|
+
+if you are expecting a non-fatal (e.g. `EXPECT_*`) failure.
+
+For technical reasons, there are some caveats:
+
+  1. You cannot stream a failure message to either macro.
+  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot reference local non-static variables or non-static members of `this` object.
+  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot return a value.
+
+_Note:_ Google Test is designed with threads in mind.  Once the
+synchronization primitives in `<gtest/internal/gtest-port.h>` have
+been implemented, Google Test will become thread-safe, meaning that
+you can then use assertions in multiple threads concurrently.  Before
+
+that, however, Google Test only supports single-threaded usage.  Once
+thread-safe, `EXPECT_FATAL_FAILURE()` and `EXPECT_NONFATAL_FAILURE()`
+will capture failures in the current thread only. If _statement_
+creates new threads, failures in these threads will be ignored.  If
+you want to capture failures from all threads instead, you should use
+the following macros:
+
+| `EXPECT_FATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
+|:-----------------------------------------------------------------|
+| `EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
+
+# Getting the Current Test's Name #
+
+Sometimes a function may need to know the name of the currently running test.
+For example, you may be using the `SetUp()` method of your test fixture to set
+the golden file name based on which test is running. The `::testing::TestInfo`
+class has this information:
+
+```
+namespace testing {
+
+class TestInfo {
+ public:
+  // Returns the test case name and the test name, respectively.
+  //
+  // Do NOT delete or free the return value - it's managed by the
+  // TestInfo class.
+  const char* test_case_name() const;
+  const char* name() const;
+};
+
+}  // namespace testing
+```
+
+
+> To obtain a `TestInfo` object for the currently running test, call
+`current_test_info()` on the `UnitTest` singleton object:
+
+```
+// Gets information about the currently running test.
+// Do NOT delete the returned object - it's managed by the UnitTest class.
+const ::testing::TestInfo* const test_info =
+  ::testing::UnitTest::GetInstance()->current_test_info();
+printf("We are in test %s of test case %s.\n",
+       test_info->name(), test_info->test_case_name());
+```
+
+`current_test_info()` returns a null pointer if no test is running. In
+particular, you cannot find the test case name in `TestCaseSetUp()`,
+`TestCaseTearDown()` (where you know the test case name implicitly), or
+functions called from them.
+
+_Availability:_ Linux, Windows, Mac.
+
+# Extending Google Test by Handling Test Events #
+
+Google Test provides an <b>event listener API</b> to let you receive
+notifications about the progress of a test program and test
+failures. The events you can listen to include the start and end of
+the test program, a test case, or a test method, among others. You may
+use this API to augment or replace the standard console output,
+replace the XML output, or provide a completely different form of
+output, such as a GUI or a database. You can also use test events as
+checkpoints to implement a resource leak checker, for example.
+
+_Availability:_ Linux, Windows, Mac; since v1.4.0.
+
+## Defining Event Listeners ##
+
+To define a event listener, you subclass either
+[testing::TestEventListener](../include/gtest/gtest.h#L855)
+or [testing::EmptyTestEventListener](../include/gtest/gtest.h#L905).
+The former is an (abstract) interface, where <i>each pure virtual method<br>
+can be overridden to handle a test event</i> (For example, when a test
+starts, the `OnTestStart()` method will be called.). The latter provides
+an empty implementation of all methods in the interface, such that a
+subclass only needs to override the methods it cares about.
+
+When an event is fired, its context is passed to the handler function
+as an argument. The following argument types are used:
+  * [UnitTest](../include/gtest/gtest.h#L1007) reflects the state of the entire test program,
+  * [TestCase](../include/gtest/gtest.h#L689) has information about a test case, which can contain one or more tests,
+  * [TestInfo](../include/gtest/gtest.h#L599) contains the state of a test, and
+  * [TestPartResult](../include/gtest/gtest-test-part.h#L42) represents the result of a test assertion.
+
+An event handler function can examine the argument it receives to find
+out interesting information about the event and the test program's
+state.  Here's an example:
+
+```
+  class MinimalistPrinter : public ::testing::EmptyTestEventListener {
+    // Called before a test starts.
+    virtual void OnTestStart(const ::testing::TestInfo& test_info) {
+      printf("*** Test %s.%s starting.\n",
+             test_info.test_case_name(), test_info.name());
+    }
+
+    // Called after a failed assertion or a SUCCESS().
+    virtual void OnTestPartResult(
+        const ::testing::TestPartResult& test_part_result) {
+      printf("%s in %s:%d\n%s\n",
+             test_part_result.failed() ? "*** Failure" : "Success",
+             test_part_result.file_name(),
+             test_part_result.line_number(),
+             test_part_result.summary());
+    }
+
+    // Called after a test ends.
+    virtual void OnTestEnd(const ::testing::TestInfo& test_info) {
+      printf("*** Test %s.%s ending.\n",
+             test_info.test_case_name(), test_info.name());
+    }
+  };
+```
+
+## Using Event Listeners ##
+
+To use the event listener you have defined, add an instance of it to
+the Google Test event listener list (represented by class
+[TestEventListeners](../include/gtest/gtest.h#L929)
+- note the "s" at the end of the name) in your
+`main()` function, before calling `RUN_ALL_TESTS()`:
+```
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  // Gets hold of the event listener list.
+  ::testing::TestEventListeners& listeners =
+      ::testing::UnitTest::GetInstance()->listeners();
+  // Adds a listener to the end.  Google Test takes the ownership.
+  listeners.Append(new MinimalistPrinter);
+  return RUN_ALL_TESTS();
+}
+```
+
+There's only one problem: the default test result printer is still in
+effect, so its output will mingle with the output from your minimalist
+printer. To suppress the default printer, just release it from the
+event listener list and delete it. You can do so by adding one line:
+```
+  ...
+  delete listeners.Release(listeners.default_result_printer());
+  listeners.Append(new MinimalistPrinter);
+  return RUN_ALL_TESTS();
+```
+
+Now, sit back and enjoy a completely different output from your
+tests. For more details, you can read this
+[sample](../samples/sample9_unittest.cc).
+
+You may append more than one listener to the list. When an `On*Start()`
+or `OnTestPartResult()` event is fired, the listeners will receive it in
+the order they appear in the list (since new listeners are added to
+the end of the list, the default text printer and the default XML
+generator will receive the event first). An `On*End()` event will be
+received by the listeners in the _reverse_ order. This allows output by
+listeners added later to be framed by output from listeners added
+earlier.
+
+## Generating Failures in Listeners ##
+
+You may use failure-raising macros (`EXPECT_*()`, `ASSERT_*()`,
+`FAIL()`, etc) when processing an event. There are some restrictions:
+
+  1. You cannot generate any failure in `OnTestPartResult()` (otherwise it will cause `OnTestPartResult()` to be called recursively).
+  1. A listener that handles `OnTestPartResult()` is not allowed to generate any failure.
+
+When you add listeners to the listener list, you should put listeners
+that handle `OnTestPartResult()` _before_ listeners that can generate
+failures. This ensures that failures generated by the latter are
+attributed to the right test by the former.
+
+We have a sample of failure-raising listener
+[here](../samples/sample10_unittest.cc).
+
+# Running Test Programs: Advanced Options #
+
+Google Test test programs are ordinary executables. Once built, you can run
+them directly and affect their behavior via the following environment variables
+and/or command line flags. For the flags to work, your programs must call
+`::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`.
+
+To see a list of supported flags and their usage, please run your test
+program with the `--help` flag.  You can also use `-h`, `-?`, or `/?`
+for short.  This feature is added in version 1.3.0.
+
+If an option is specified both by an environment variable and by a
+flag, the latter takes precedence.  Most of the options can also be
+set/read in code: to access the value of command line flag
+`--gtest_foo`, write `::testing::GTEST_FLAG(foo)`.  A common pattern is
+to set the value of a flag before calling `::testing::InitGoogleTest()`
+to change the default value of the flag:
+```
+int main(int argc, char** argv) {
+  // Disables elapsed time by default.
+  ::testing::GTEST_FLAG(print_time) = false;
+
+  // This allows the user to override the flag on the command line.
+  ::testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}
+```
+
+## Selecting Tests ##
+
+This section shows various options for choosing which tests to run.
+
+### Listing Test Names ###
+
+Sometimes it is necessary to list the available tests in a program before
+running them so that a filter may be applied if needed. Including the flag
+`--gtest_list_tests` overrides all other flags and lists tests in the following
+format:
+```
+TestCase1.
+  TestName1
+  TestName2
+TestCase2.
+  TestName
+```
+
+None of the tests listed are actually run if the flag is provided. There is no
+corresponding environment variable for this flag.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Running a Subset of the Tests ###
+
+By default, a Google Test program runs all tests the user has defined.
+Sometimes, you want to run only a subset of the tests (e.g. for debugging or
+quickly verifying a change). If you set the `GTEST_FILTER` environment variable
+or the `--gtest_filter` flag to a filter string, Google Test will only run the
+tests whose full names (in the form of `TestCaseName.TestName`) match the
+filter.
+
+The format of a filter is a '`:`'-separated list of wildcard patterns (called
+the positive patterns) optionally followed by a '`-`' and another
+'`:`'-separated pattern list (called the negative patterns). A test matches the
+filter if and only if it matches any of the positive patterns but does not
+match any of the negative patterns.
+
+A pattern may contain `'*'` (matches any string) or `'?'` (matches any single
+character). For convenience, the filter `'*-NegativePatterns'` can be also
+written as `'-NegativePatterns'`.
+
+For example:
+
+  * `./foo_test` Has no flag, and thus runs all its tests.
+  * `./foo_test --gtest_filter=*` Also runs everything, due to the single match-everything `*` value.
+  * `./foo_test --gtest_filter=FooTest.*` Runs everything in test case `FooTest`.
+  * `./foo_test --gtest_filter=*Null*:*Constructor*` Runs any test whose full name contains either `"Null"` or `"Constructor"`.
+  * `./foo_test --gtest_filter=-*DeathTest.*` Runs all non-death tests.
+  * `./foo_test --gtest_filter=FooTest.*-FooTest.Bar` Runs everything in test case `FooTest` except `FooTest.Bar`.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Temporarily Disabling Tests ###
+
+If you have a broken test that you cannot fix right away, you can add the
+`DISABLED_` prefix to its name. This will exclude it from execution. This is
+better than commenting out the code or using `#if 0`, as disabled tests are
+still compiled (and thus won't rot).
+
+If you need to disable all tests in a test case, you can either add `DISABLED_`
+to the front of the name of each test, or alternatively add it to the front of
+the test case name.
+
+For example, the following tests won't be run by Google Test, even though they
+will still be compiled:
+
+```
+// Tests that Foo does Abc.
+TEST(FooTest, DISABLED_DoesAbc) { ... }
+
+class DISABLED_BarTest : public ::testing::Test { ... };
+
+// Tests that Bar does Xyz.
+TEST_F(DISABLED_BarTest, DoesXyz) { ... }
+```
+
+_Note:_ This feature should only be used for temporary pain-relief. You still
+have to fix the disabled tests at a later date. As a reminder, Google Test will
+print a banner warning you if a test program contains any disabled tests.
+
+_Tip:_ You can easily count the number of disabled tests you have
+using `grep`. This number can be used as a metric for improving your
+test quality.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Temporarily Enabling Disabled Tests ###
+
+To include [disabled tests](#temporarily-disabling-tests) in test
+execution, just invoke the test program with the
+`--gtest_also_run_disabled_tests` flag or set the
+`GTEST_ALSO_RUN_DISABLED_TESTS` environment variable to a value other
+than `0`.  You can combine this with the
+[--gtest\_filter](#running-a-subset-of-the-tests) flag to further select
+which disabled tests to run.
+
+_Availability:_ Linux, Windows, Mac; since version 1.3.0.
+
+## Repeating the Tests ##
+
+Once in a while you'll run into a test whose result is hit-or-miss. Perhaps it
+will fail only 1% of the time, making it rather hard to reproduce the bug under
+a debugger. This can be a major source of frustration.
+
+The `--gtest_repeat` flag allows you to repeat all (or selected) test methods
+in a program many times. Hopefully, a flaky test will eventually fail and give
+you a chance to debug. Here's how to use it:
+
+| `$ foo_test --gtest_repeat=1000` | Repeat foo\_test 1000 times and don't stop at failures. |
+|:---------------------------------|:--------------------------------------------------------|
+| `$ foo_test --gtest_repeat=-1`   | A negative count means repeating forever.               |
+| `$ foo_test --gtest_repeat=1000 --gtest_break_on_failure` | Repeat foo\_test 1000 times, stopping at the first failure. This is especially useful when running under a debugger: when the testfails, it will drop into the debugger and you can then inspect variables and stacks. |
+| `$ foo_test --gtest_repeat=1000 --gtest_filter=FooBar` | Repeat the tests whose name matches the filter 1000 times. |
+
+If your test program contains global set-up/tear-down code registered
+using `AddGlobalTestEnvironment()`, it will be repeated in each
+iteration as well, as the flakiness may be in it. You can also specify
+the repeat count by setting the `GTEST_REPEAT` environment variable.
+
+_Availability:_ Linux, Windows, Mac.
+
+## Shuffling the Tests ##
+
+You can specify the `--gtest_shuffle` flag (or set the `GTEST_SHUFFLE`
+environment variable to `1`) to run the tests in a program in a random
+order. This helps to reveal bad dependencies between tests.
+
+By default, Google Test uses a random seed calculated from the current
+time. Therefore you'll get a different order every time. The console
+output includes the random seed value, such that you can reproduce an
+order-related test failure later. To specify the random seed
+explicitly, use the `--gtest_random_seed=SEED` flag (or set the
+`GTEST_RANDOM_SEED` environment variable), where `SEED` is an integer
+between 0 and 99999. The seed value 0 is special: it tells Google Test
+to do the default behavior of calculating the seed from the current
+time.
+
+If you combine this with `--gtest_repeat=N`, Google Test will pick a
+different random seed and re-shuffle the tests in each iteration.
+
+_Availability:_ Linux, Windows, Mac; since v1.4.0.
+
+## Controlling Test Output ##
+
+This section teaches how to tweak the way test results are reported.
+
+### Colored Terminal Output ###
+
+Google Test can use colors in its terminal output to make it easier to spot
+the separation between tests, and whether tests passed.
+
+You can set the GTEST\_COLOR environment variable or set the `--gtest_color`
+command line flag to `yes`, `no`, or `auto` (the default) to enable colors,
+disable colors, or let Google Test decide. When the value is `auto`, Google
+Test will use colors if and only if the output goes to a terminal and (on
+non-Windows platforms) the `TERM` environment variable is set to `xterm` or
+`xterm-color`.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Suppressing the Elapsed Time ###
+
+By default, Google Test prints the time it takes to run each test.  To
+suppress that, run the test program with the `--gtest_print_time=0`
+command line flag.  Setting the `GTEST_PRINT_TIME` environment
+variable to `0` has the same effect.
+
+_Availability:_ Linux, Windows, Mac.  (In Google Test 1.3.0 and lower,
+the default behavior is that the elapsed time is **not** printed.)
+
+### Generating an XML Report ###
+
+Google Test can emit a detailed XML report to a file in addition to its normal
+textual output. The report contains the duration of each test, and thus can
+help you identify slow tests.
+
+To generate the XML report, set the `GTEST_OUTPUT` environment variable or the
+`--gtest_output` flag to the string `"xml:_path_to_output_file_"`, which will
+create the file at the given location. You can also just use the string
+`"xml"`, in which case the output can be found in the `test_detail.xml` file in
+the current directory.
+
+If you specify a directory (for example, `"xml:output/directory/"` on Linux or
+`"xml:output\directory\"` on Windows), Google Test will create the XML file in
+that directory, named after the test executable (e.g. `foo_test.xml` for test
+program `foo_test` or `foo_test.exe`). If the file already exists (perhaps left
+over from a previous run), Google Test will pick a different name (e.g.
+`foo_test_1.xml`) to avoid overwriting it.
+
+The report uses the format described here.  It is based on the
+`junitreport` Ant task and can be parsed by popular continuous build
+systems like [Hudson](https://hudson.dev.java.net/). Since that format
+was originally intended for Java, a little interpretation is required
+to make it apply to Google Test tests, as shown here:
+
+```
+<testsuites name="AllTests" ...>
+  <testsuite name="test_case_name" ...>
+    <testcase name="test_name" ...>
+      <failure message="..."/>
+      <failure message="..."/>
+      <failure message="..."/>
+    </testcase>
+  </testsuite>
+</testsuites>
+```
+
+  * The root `<testsuites>` element corresponds to the entire test program.
+  * `<testsuite>` elements correspond to Google Test test cases.
+  * `<testcase>` elements correspond to Google Test test functions.
+
+For instance, the following program
+
+```
+TEST(MathTest, Addition) { ... }
+TEST(MathTest, Subtraction) { ... }
+TEST(LogicTest, NonContradiction) { ... }
+```
+
+could generate this report:
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="3" failures="1" errors="0" time="35" name="AllTests">
+  <testsuite name="MathTest" tests="2" failures="1"* errors="0" time="15">
+    <testcase name="Addition" status="run" time="7" classname="">
+      <failure message="Value of: add(1, 1)&#x0A; Actual: 3&#x0A;Expected: 2" type=""/>
+      <failure message="Value of: add(1, -1)&#x0A; Actual: 1&#x0A;Expected: 0" type=""/>
+    </testcase>
+    <testcase name="Subtraction" status="run" time="5" classname="">
+    </testcase>
+  </testsuite>
+  <testsuite name="LogicTest" tests="1" failures="0" errors="0" time="5">
+    <testcase name="NonContradiction" status="run" time="5" classname="">
+    </testcase>
+  </testsuite>
+</testsuites>
+```
+
+Things to note:
+
+  * The `tests` attribute of a `<testsuites>` or `<testsuite>` element tells how many test functions the Google Test program or test case contains, while the `failures` attribute tells how many of them failed.
+  * The `time` attribute expresses the duration of the test, test case, or entire test program in milliseconds.
+  * Each `<failure>` element corresponds to a single failed Google Test assertion.
+  * Some JUnit concepts don't apply to Google Test, yet we have to conform to the DTD. Therefore you'll see some dummy elements and attributes in the report. You can safely ignore these parts.
+
+_Availability:_ Linux, Windows, Mac.
+
+## Controlling How Failures Are Reported ##
+
+### Turning Assertion Failures into Break-Points ###
+
+When running test programs under a debugger, it's very convenient if the
+debugger can catch an assertion failure and automatically drop into interactive
+mode. Google Test's _break-on-failure_ mode supports this behavior.
+
+To enable it, set the `GTEST_BREAK_ON_FAILURE` environment variable to a value
+other than `0` . Alternatively, you can use the `--gtest_break_on_failure`
+command line flag.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Suppressing Pop-ups Caused by Exceptions ###
+
+On Windows, Google Test may be used with exceptions enabled. Even when
+exceptions are disabled, an application can still throw structured exceptions
+(SEH's). If a test throws an exception, by default Google Test doesn't try to
+catch it. Instead, you'll see a pop-up dialog, at which point you can attach
+the process to a debugger and easily find out what went wrong.
+
+However, if you don't want to see the pop-ups (for example, if you run the
+tests in a batch job), set the `GTEST_CATCH_EXCEPTIONS` environment variable to
+a non- `0` value, or use the `--gtest_catch_exceptions` flag. Google Test now
+catches all test-thrown exceptions and logs them as failures.
+
+_Availability:_ Windows. `GTEST_CATCH_EXCEPTIONS` and
+`--gtest_catch_exceptions` have no effect on Google Test's behavior on Linux or
+Mac, even if exceptions are enabled. It is possible to add support for catching
+exceptions on these platforms, but it is not implemented yet.
+
+### Letting Another Testing Framework Drive ###
+
+If you work on a project that has already been using another testing
+framework and is not ready to completely switch to Google Test yet,
+you can get much of Google Test's benefit by using its assertions in
+your existing tests.  Just change your `main()` function to look
+like:
+
+```
+#include <gtest/gtest.h>
+
+int main(int argc, char** argv) {
+  ::testing::GTEST_FLAG(throw_on_failure) = true;
+  // Important: Google Test must be initialized.
+  ::testing::InitGoogleTest(&argc, argv);
+
+  ... whatever your existing testing framework requires ...
+}
+```
+
+With that, you can use Google Test assertions in addition to the
+native assertions your testing framework provides, for example:
+
+```
+void TestFooDoesBar() {
+  Foo foo;
+  EXPECT_LE(foo.Bar(1), 100);     // A Google Test assertion.
+  CPPUNIT_ASSERT(foo.IsEmpty());  // A native assertion.
+}
+```
+
+If a Google Test assertion fails, it will print an error message and
+throw an exception, which will be treated as a failure by your host
+testing framework.  If you compile your code with exceptions disabled,
+a failed Google Test assertion will instead exit your program with a
+non-zero code, which will also signal a test failure to your test
+runner.
+
+If you don't write `::testing::GTEST_FLAG(throw_on_failure) = true;` in
+your `main()`, you can alternatively enable this feature by specifying
+the `--gtest_throw_on_failure` flag on the command-line or setting the
+`GTEST_THROW_ON_FAILURE` environment variable to a non-zero value.
+
+_Availability:_ Linux, Windows, Mac; since v1.3.0.
+
+## Distributing Test Functions to Multiple Machines ##
+
+If you have more than one machine you can use to run a test program,
+you might want to run the test functions in parallel and get the
+result faster.  We call this technique _sharding_, where each machine
+is called a _shard_.
+
+Google Test is compatible with test sharding.  To take advantage of
+this feature, your test runner (not part of Google Test) needs to do
+the following:
+
+  1. Allocate a number of machines (shards) to run the tests.
+  1. On each shard, set the `GTEST_TOTAL_SHARDS` environment variable to the total number of shards.  It must be the same for all shards.
+  1. On each shard, set the `GTEST_SHARD_INDEX` environment variable to the index of the shard.  Different shards must be assigned different indices, which must be in the range `[0, GTEST_TOTAL_SHARDS - 1]`.
+  1. Run the same test program on all shards.  When Google Test sees the above two environment variables, it will select a subset of the test functions to run.  Across all shards, each test function in the program will be run exactly once.
+  1. Wait for all shards to finish, then collect and report the results.
+
+Your project may have tests that were written without Google Test and
+thus don't understand this protocol.  In order for your test runner to
+figure out which test supports sharding, it can set the environment
+variable `GTEST_SHARD_STATUS_FILE` to a non-existent file path.  If a
+test program supports sharding, it will create this file to
+acknowledge the fact (the actual contents of the file are not
+important at this time; although we may stick some useful information
+in it in the future.); otherwise it will not create it.
+
+Here's an example to make it clear.  Suppose you have a test program
+`foo_test` that contains the following 5 test functions:
+```
+TEST(A, V)
+TEST(A, W)
+TEST(B, X)
+TEST(B, Y)
+TEST(B, Z)
+```
+and you have 3 machines at your disposal.  To run the test functions in
+parallel, you would set `GTEST_TOTAL_SHARDS` to 3 on all machines, and
+set `GTEST_SHARD_INDEX` to 0, 1, and 2 on the machines respectively.
+Then you would run the same `foo_test` on each machine.
+
+Google Test reserves the right to change how the work is distributed
+across the shards, but here's one possible scenario:
+
+  * Machine #0 runs `A.V` and `B.X`.
+  * Machine #1 runs `A.W` and `B.Y`.
+  * Machine #2 runs `B.Z`.
+
+_Availability:_ Linux, Windows, Mac; since version 1.3.0.
+
+# Fusing Google Test Source Files #
+
+Google Test's implementation consists of ~30 files (excluding its own
+tests).  Sometimes you may want them to be packaged up in two files (a
+`.h` and a `.cc`) instead, such that you can easily copy them to a new
+machine and start hacking there.  For this we provide an experimental
+Python script `fuse_gtest_files.py` in the `scripts/` directory (since release 1.3.0).
+Assuming you have Python 2.4 or above installed on your machine, just
+go to that directory and run
+```
+python fuse_gtest_files.py OUTPUT_DIR
+```
+
+and you should see an `OUTPUT_DIR` directory being created with files
+`gtest/gtest.h` and `gtest/gtest-all.cc` in it.  These files contain
+everything you need to use Google Test.  Just copy them to anywhere
+you want and you are ready to write tests.  You can use the
+[scrpts/test/Makefile](../scripts/test/Makefile)
+file as an example on how to compile your tests against them.
+
+# Where to Go from Here #
+
+Congratulations! You've now learned more advanced Google Test tools and are
+ready to tackle more complex testing tasks. If you want to dive even deeper, you
+can read the [FAQ](V1_5_FAQ.md).
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Documentation.md
new file mode 100644
index 00000000..46bba2ec
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Documentation.md
@@ -0,0 +1,12 @@
+This page lists all official documentation wiki pages for Google Test **1.5.0** -- **if you use a different version of Google Test, make sure to read the documentation for that version instead.**
+
+  * [Primer](V1_5_Primer.md) -- start here if you are new to Google Test.
+  * [Samples](Samples.md) -- learn from examples.
+  * [AdvancedGuide](V1_5_AdvancedGuide.md) -- learn more about Google Test.
+  * [XcodeGuide](V1_5_XcodeGuide.md) -- how to use Google Test in Xcode on Mac.
+  * [Frequently-Asked Questions](V1_5_FAQ.md) -- check here before asking a question on the mailing list.
+
+To contribute code to Google Test, read:
+
+  * DevGuide -- read this _before_ writing your first patch.
+  * [PumpManual](V1_5_PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_FAQ.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_FAQ.md
new file mode 100644
index 00000000..e870aff0
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_FAQ.md
@@ -0,0 +1,886 @@
+
+
+If you cannot find the answer to your question here, and you have read
+[Primer](V1_5_Primer.md) and [AdvancedGuide](V1_5_AdvancedGuide.md), send it to
+googletestframework@googlegroups.com.
+
+## Why should I use Google Test instead of my favorite C++ testing framework? ##
+
+First, let's say clearly that we don't want to get into the debate of
+which C++ testing framework is **the best**.  There exist many fine
+frameworks for writing C++ tests, and we have tremendous respect for
+the developers and users of them.  We don't think there is (or will
+be) a single best framework - you have to pick the right tool for the
+particular task you are tackling.
+
+We created Google Test because we couldn't find the right combination
+of features and conveniences in an existing framework to satisfy _our_
+needs.  The following is a list of things that _we_ like about Google
+Test.  We don't claim them to be unique to Google Test - rather, the
+combination of them makes Google Test the choice for us.  We hope this
+list can help you decide whether it is for you too.
+
+  * Google Test is designed to be portable.  It works where many STL types (e.g. `std::string` and `std::vector`) don't compile.  It doesn't require exceptions or RTTI.  As a result, it runs on Linux, Mac OS X, Windows and several embedded operating systems.
+  * Nonfatal assertions (`EXPECT_*`) have proven to be great time savers, as they allow a test to report multiple failures in a single edit-compile-test cycle.
+  * It's easy to write assertions that generate informative messages: you just use the stream syntax to append any additional information, e.g. `ASSERT_EQ(5, Foo(i)) << " where i = " << i;`.  It doesn't require a new set of macros or special functions.
+  * Google Test automatically detects your tests and doesn't require you to enumerate them in order to run them.
+  * No framework can anticipate all your needs, so Google Test provides `EXPECT_PRED*` to make it easy to extend your assertion vocabulary.  For a nicer syntax, you can define your own assertion macros trivially in terms of `EXPECT_PRED*`.
+  * Death tests are pretty handy for ensuring that your asserts in production code are triggered by the right conditions.
+  * `SCOPED_TRACE` helps you understand the context of an assertion failure when it comes from inside a sub-routine or loop.
+  * You can decide which tests to run using name patterns.  This saves time when you want to quickly reproduce a test failure.
+
+## How do I generate 64-bit binaries on Windows (using Visual Studio 2008)? ##
+
+(Answered by Trevor Robinson)
+
+Load the supplied Visual Studio solution file, either `msvc\gtest-md.sln` or
+`msvc\gtest.sln`. Go through the migration wizard to migrate the
+solution and project files to Visual Studio 2008. Select
+`Configuration Manager...` from the `Build` menu. Select `<New...>` from
+the `Active solution platform` dropdown.  Select `x64` from the new
+platform dropdown, leave `Copy settings from` set to `Win32` and
+`Create new project platforms` checked, then click `OK`. You now have
+`Win32` and `x64` platform configurations, selectable from the
+`Standard` toolbar, which allow you to toggle between building 32-bit or
+64-bit binaries (or both at once using Batch Build).
+
+In order to prevent build output files from overwriting one another,
+you'll need to change the `Intermediate Directory` settings for the
+newly created platform configuration across all the projects. To do
+this, multi-select (e.g. using shift-click) all projects (but not the
+solution) in the `Solution Explorer`. Right-click one of them and
+select `Properties`. In the left pane, select `Configuration Properties`,
+and from the `Configuration` dropdown, select `All Configurations`.
+Make sure the selected platform is `x64`. For the
+`Intermediate Directory` setting, change the value from
+`$(PlatformName)\$(ConfigurationName)` to
+`$(OutDir)\$(ProjectName)`. Click `OK` and then build the
+solution. When the build is complete, the 64-bit binaries will be in
+the `msvc\x64\Debug` directory.
+
+## Can I use Google Test on MinGW? ##
+
+We haven't tested this ourselves, but Per Abrahamsen reported that he
+was able to compile and install Google Test successfully when using
+MinGW from Cygwin.  You'll need to configure it with:
+
+`PATH/TO/configure CC="gcc -mno-cygwin" CXX="g++ -mno-cygwin"`
+
+You should be able to replace the `-mno-cygwin` option with direct links
+to the real MinGW binaries, but we haven't tried that.
+
+Caveats:
+
+  * There are many warnings when compiling.
+  * `make check` will produce some errors as not all tests for Google Test itself are compatible with MinGW.
+
+We also have reports on successful cross compilation of Google Test MinGW binaries on Linux using [these instructions](http://wiki.wxwidgets.org/Cross-Compiling_Under_Linux#Cross-compiling_under_Linux_for_MS_Windows) on the WxWidgets site.
+
+Please contact `googletestframework@googlegroups.com` if you are
+interested in improving the support for MinGW.
+
+## Why does Google Test support EXPECT\_EQ(NULL, ptr) and ASSERT\_EQ(NULL, ptr) but not EXPECT\_NE(NULL, ptr) and ASSERT\_NE(NULL, ptr)? ##
+
+Due to some peculiarity of C++, it requires some non-trivial template
+meta programming tricks to support using `NULL` as an argument of the
+`EXPECT_XX()` and `ASSERT_XX()` macros. Therefore we only do it where
+it's most needed (otherwise we make the implementation of Google Test
+harder to maintain and more error-prone than necessary).
+
+The `EXPECT_EQ()` macro takes the _expected_ value as its first
+argument and the _actual_ value as the second. It's reasonable that
+someone wants to write `EXPECT_EQ(NULL, some_expression)`, and this
+indeed was requested several times. Therefore we implemented it.
+
+The need for `EXPECT_NE(NULL, ptr)` isn't nearly as strong. When the
+assertion fails, you already know that `ptr` must be `NULL`, so it
+doesn't add any information to print ptr in this case. That means
+`EXPECT_TRUE(ptr ! NULL)` works just as well.
+
+If we were to support `EXPECT_NE(NULL, ptr)`, for consistency we'll
+have to support `EXPECT_NE(ptr, NULL)` as well, as unlike `EXPECT_EQ`,
+we don't have a convention on the order of the two arguments for
+`EXPECT_NE`. This means using the template meta programming tricks
+twice in the implementation, making it even harder to understand and
+maintain. We believe the benefit doesn't justify the cost.
+
+Finally, with the growth of Google Mock's [matcher](../../CookBook.md#using-matchers-in-google-test-assertions) library, we are
+encouraging people to use the unified `EXPECT_THAT(value, matcher)`
+syntax more often in tests. One significant advantage of the matcher
+approach is that matchers can be easily combined to form new matchers,
+while the `EXPECT_NE`, etc, macros cannot be easily
+combined. Therefore we want to invest more in the matchers than in the
+`EXPECT_XX()` macros.
+
+## Does Google Test support running tests in parallel? ##
+
+Test runners tend to be tightly coupled with the build/test
+environment, and Google Test doesn't try to solve the problem of
+running tests in parallel.  Instead, we tried to make Google Test work
+nicely with test runners.  For example, Google Test's XML report
+contains the time spent on each test, and its `gtest_list_tests` and
+`gtest_filter` flags can be used for splitting the execution of test
+methods into multiple processes.  These functionalities can help the
+test runner run the tests in parallel.
+
+## Why don't Google Test run the tests in different threads to speed things up? ##
+
+It's difficult to write thread-safe code.  Most tests are not written
+with thread-safety in mind, and thus may not work correctly in a
+multi-threaded setting.
+
+If you think about it, it's already hard to make your code work when
+you know what other threads are doing.  It's much harder, and
+sometimes even impossible, to make your code work when you don't know
+what other threads are doing (remember that test methods can be added,
+deleted, or modified after your test was written).  If you want to run
+the tests in parallel, you'd better run them in different processes.
+
+## Why aren't Google Test assertions implemented using exceptions? ##
+
+Our original motivation was to be able to use Google Test in projects
+that disable exceptions.  Later we realized some additional benefits
+of this approach:
+
+  1. Throwing in a destructor is undefined behavior in C++.  Not using exceptions means Google Test's assertions are safe to use in destructors.
+  1. The `EXPECT_*` family of macros will continue even after a failure, allowing multiple failures in a `TEST` to be reported in a single run. This is a popular feature, as in C++ the edit-compile-test cycle is usually quite long and being able to fixing more than one thing at a time is a blessing.
+  1. If assertions are implemented using exceptions, a test may falsely ignore a failure if it's caught by user code:
+```
+try { ... ASSERT_TRUE(...) ... }
+catch (...) { ... }
+```
+The above code will pass even if the `ASSERT_TRUE` throws.  While it's unlikely for someone to write this in a test, it's possible to run into this pattern when you write assertions in callbacks that are called by the code under test.
+
+The downside of not using exceptions is that `ASSERT_*` (implemented
+using `return`) will only abort the current function, not the current
+`TEST`.
+
+## Why do we use two different macros for tests with and without fixtures? ##
+
+Unfortunately, C++'s macro system doesn't allow us to use the same
+macro for both cases.  One possibility is to provide only one macro
+for tests with fixtures, and require the user to define an empty
+fixture sometimes:
+
+```
+class FooTest : public ::testing::Test {};
+
+TEST_F(FooTest, DoesThis) { ... }
+```
+or
+```
+typedef ::testing::Test FooTest;
+
+TEST_F(FooTest, DoesThat) { ... }
+```
+
+Yet, many people think this is one line too many. :-) Our goal was to
+make it really easy to write tests, so we tried to make simple tests
+trivial to create.  That means using a separate macro for such tests.
+
+We think neither approach is ideal, yet either of them is reasonable.
+In the end, it probably doesn't matter much either way.
+
+## Why don't we use structs as test fixtures? ##
+
+We like to use structs only when representing passive data.  This
+distinction between structs and classes is good for documenting the
+intent of the code's author.  Since test fixtures have logic like
+`SetUp()` and `TearDown()`, they are better defined as classes.
+
+## Why are death tests implemented as assertions instead of using a test runner? ##
+
+Our goal was to make death tests as convenient for a user as C++
+possibly allows.  In particular:
+
+  * The runner-style requires to split the information into two pieces: the definition of the death test itself, and the specification for the runner on how to run the death test and what to expect.  The death test would be written in C++, while the runner spec may or may not be.  A user needs to carefully keep the two in sync. `ASSERT_DEATH(statement, expected_message)` specifies all necessary information in one place, in one language, without boilerplate code. It is very declarative.
+  * `ASSERT_DEATH` has a similar syntax and error-reporting semantics as other Google Test assertions, and thus is easy to learn.
+  * `ASSERT_DEATH` can be mixed with other assertions and other logic at your will.  You are not limited to one death test per test method. For example, you can write something like:
+```
+    if (FooCondition()) {
+      ASSERT_DEATH(Bar(), "blah");
+    } else {
+      ASSERT_EQ(5, Bar());
+    }
+```
+If you prefer one death test per test method, you can write your tests in that style too, but we don't want to impose that on the users.  The fewer artificial limitations the better.
+  * `ASSERT_DEATH` can reference local variables in the current function, and you can decide how many death tests you want based on run-time information.  For example,
+```
+    const int count = GetCount();  // Only known at run time.
+    for (int i = 1; i <= count; i++) {
+      ASSERT_DEATH({
+        double* buffer = new double[i];
+        ... initializes buffer ...
+        Foo(buffer, i)
+      }, "blah blah");
+    }
+```
+The runner-based approach tends to be more static and less flexible, or requires more user effort to get this kind of flexibility.
+
+Another interesting thing about `ASSERT_DEATH` is that it calls `fork()`
+to create a child process to run the death test.  This is lightening
+fast, as `fork()` uses copy-on-write pages and incurs almost zero
+overhead, and the child process starts from the user-supplied
+statement directly, skipping all global and local initialization and
+any code leading to the given statement.  If you launch the child
+process from scratch, it can take seconds just to load everything and
+start running if the test links to many libraries dynamically.
+
+## My death test modifies some state, but the change seems lost after the death test finishes. Why? ##
+
+Death tests (`EXPECT_DEATH`, etc) are executed in a sub-process s.t. the
+expected crash won't kill the test program (i.e. the parent process). As a
+result, any in-memory side effects they incur are observable in their
+respective sub-processes, but not in the parent process. You can think of them
+as running in a parallel universe, more or less.
+
+## The compiler complains about "undefined references" to some static const member variables, but I did define them in the class body. What's wrong? ##
+
+If your class has a static data member:
+
+```
+// foo.h
+class Foo {
+  ...
+  static const int kBar = 100;
+};
+```
+
+You also need to define it _outside_ of the class body in `foo.cc`:
+
+```
+const int Foo::kBar;  // No initializer here.
+```
+
+Otherwise your code is **invalid C++**, and may break in unexpected ways. In
+particular, using it in Google Test comparison assertions (`EXPECT_EQ`, etc)
+will generate an "undefined reference" linker error.
+
+## I have an interface that has several implementations. Can I write a set of tests once and repeat them over all the implementations? ##
+
+Google Test doesn't yet have good support for this kind of tests, or
+data-driven tests in general. We hope to be able to make improvements in this
+area soon.
+
+## Can I derive a test fixture from another? ##
+
+Yes.
+
+Each test fixture has a corresponding and same named test case. This means only
+one test case can use a particular fixture. Sometimes, however, multiple test
+cases may want to use the same or slightly different fixtures. For example, you
+may want to make sure that all of a GUI library's test cases don't leak
+important system resources like fonts and brushes.
+
+In Google Test, you share a fixture among test cases by putting the shared
+logic in a base test fixture, then deriving from that base a separate fixture
+for each test case that wants to use this common logic. You then use `TEST_F()`
+to write tests using each derived fixture.
+
+Typically, your code looks like this:
+
+```
+// Defines a base test fixture.
+class BaseTest : public ::testing::Test {
+  protected:
+   ...
+};
+
+// Derives a fixture FooTest from BaseTest.
+class FooTest : public BaseTest {
+  protected:
+    virtual void SetUp() {
+      BaseTest::SetUp();  // Sets up the base fixture first.
+      ... additional set-up work ...
+    }
+    virtual void TearDown() {
+      ... clean-up work for FooTest ...
+      BaseTest::TearDown();  // Remember to tear down the base fixture
+                             // after cleaning up FooTest!
+    }
+    ... functions and variables for FooTest ...
+};
+
+// Tests that use the fixture FooTest.
+TEST_F(FooTest, Bar) { ... }
+TEST_F(FooTest, Baz) { ... }
+
+... additional fixtures derived from BaseTest ...
+```
+
+If necessary, you can continue to derive test fixtures from a derived fixture.
+Google Test has no limit on how deep the hierarchy can be.
+
+For a complete example using derived test fixtures, see
+`samples/sample5_unittest.cc`.
+
+## My compiler complains "void value not ignored as it ought to be." What does this mean? ##
+
+You're probably using an `ASSERT_*()` in a function that doesn't return `void`.
+`ASSERT_*()` can only be used in `void` functions.
+
+## My death test hangs (or seg-faults). How do I fix it? ##
+
+In Google Test, death tests are run in a child process and the way they work is
+delicate. To write death tests you really need to understand how they work.
+Please make sure you have read this.
+
+In particular, death tests don't like having multiple threads in the parent
+process. So the first thing you can try is to eliminate creating threads
+outside of `EXPECT_DEATH()`.
+
+Sometimes this is impossible as some library you must use may be creating
+threads before `main()` is even reached. In this case, you can try to minimize
+the chance of conflicts by either moving as many activities as possible inside
+`EXPECT_DEATH()` (in the extreme case, you want to move everything inside), or
+leaving as few things as possible in it. Also, you can try to set the death
+test style to `"threadsafe"`, which is safer but slower, and see if it helps.
+
+If you go with thread-safe death tests, remember that they rerun the test
+program from the beginning in the child process. Therefore make sure your
+program can run side-by-side with itself and is deterministic.
+
+In the end, this boils down to good concurrent programming. You have to make
+sure that there is no race conditions or dead locks in your program. No silver
+bullet - sorry!
+
+## Should I use the constructor/destructor of the test fixture or the set-up/tear-down function? ##
+
+The first thing to remember is that Google Test does not reuse the
+same test fixture object across multiple tests. For each `TEST_F`,
+Google Test will create a fresh test fixture object, _immediately_
+call `SetUp()`, run the test, call `TearDown()`, and then
+_immediately_ delete the test fixture object. Therefore, there is no
+need to write a `SetUp()` or `TearDown()` function if the constructor
+or destructor already does the job.
+
+You may still want to use `SetUp()/TearDown()` in the following cases:
+  * If the tear-down operation could throw an exception, you must use `TearDown()` as opposed to the destructor, as throwing in a destructor leads to undefined behavior and usually will kill your program right away. Note that many standard libraries (like STL) may throw when exceptions are enabled in the compiler. Therefore you should prefer `TearDown()` if you want to write portable tests that work with or without exceptions.
+  * The Google Test team is considering making the assertion macros throw on platforms where exceptions are enabled (e.g. Windows, Mac OS, and Linux client-side), which will eliminate the need for the user to propagate failures from a subroutine to its caller. Therefore, you shouldn't use Google Test assertions in a destructor if your code could run on such a platform.
+  * In a constructor or destructor, you cannot make a virtual function call on this object. (You can call a method declared as virtual, but it will be statically bound.) Therefore, if you need to call a method that will be overriden in a derived class, you have to use `SetUp()/TearDown()`.
+
+## The compiler complains "no matching function to call" when I use ASSERT\_PREDn. How do I fix it? ##
+
+If the predicate function you use in `ASSERT_PRED*` or `EXPECT_PRED*` is
+overloaded or a template, the compiler will have trouble figuring out which
+overloaded version it should use. `ASSERT_PRED_FORMAT*` and
+`EXPECT_PRED_FORMAT*` don't have this problem.
+
+If you see this error, you might want to switch to
+`(ASSERT|EXPECT)_PRED_FORMAT*`, which will also give you a better failure
+message. If, however, that is not an option, you can resolve the problem by
+explicitly telling the compiler which version to pick.
+
+For example, suppose you have
+
+```
+bool IsPositive(int n) {
+  return n > 0;
+}
+bool IsPositive(double x) {
+  return x > 0;
+}
+```
+
+you will get a compiler error if you write
+
+```
+EXPECT_PRED1(IsPositive, 5);
+```
+
+However, this will work:
+
+```
+EXPECT_PRED1(*static_cast<bool (*)(int)>*(IsPositive), 5);
+```
+
+(The stuff inside the angled brackets for the `static_cast` operator is the
+type of the function pointer for the `int`-version of `IsPositive()`.)
+
+As another example, when you have a template function
+
+```
+template <typename T>
+bool IsNegative(T x) {
+  return x < 0;
+}
+```
+
+you can use it in a predicate assertion like this:
+
+```
+ASSERT_PRED1(IsNegative*<int>*, -5);
+```
+
+Things are more interesting if your template has more than one parameters. The
+following won't compile:
+
+```
+ASSERT_PRED2(*GreaterThan<int, int>*, 5, 0);
+```
+
+
+as the C++ pre-processor thinks you are giving `ASSERT_PRED2` 4 arguments,
+which is one more than expected. The workaround is to wrap the predicate
+function in parentheses:
+
+```
+ASSERT_PRED2(*(GreaterThan<int, int>)*, 5, 0);
+```
+
+
+## My compiler complains about "ignoring return value" when I call RUN\_ALL\_TESTS(). Why? ##
+
+Some people had been ignoring the return value of `RUN_ALL_TESTS()`. That is,
+instead of
+
+```
+return RUN_ALL_TESTS();
+```
+
+they write
+
+```
+RUN_ALL_TESTS();
+```
+
+This is wrong and dangerous. A test runner needs to see the return value of
+`RUN_ALL_TESTS()` in order to determine if a test has passed. If your `main()`
+function ignores it, your test will be considered successful even if it has a
+Google Test assertion failure. Very bad.
+
+To help the users avoid this dangerous bug, the implementation of
+`RUN_ALL_TESTS()` causes gcc to raise this warning, when the return value is
+ignored. If you see this warning, the fix is simple: just make sure its value
+is used as the return value of `main()`.
+
+## My compiler complains that a constructor (or destructor) cannot return a value. What's going on? ##
+
+Due to a peculiarity of C++, in order to support the syntax for streaming
+messages to an `ASSERT_*`, e.g.
+
+```
+ASSERT_EQ(1, Foo()) << "blah blah" << foo;
+```
+
+we had to give up using `ASSERT*` and `FAIL*` (but not `EXPECT*` and
+`ADD_FAILURE*`) in constructors and destructors. The workaround is to move the
+content of your constructor/destructor to a private void member function, or
+switch to `EXPECT_*()` if that works. This section in the user's guide explains
+it.
+
+## My set-up function is not called. Why? ##
+
+C++ is case-sensitive. It should be spelled as `SetUp()`.  Did you
+spell it as `Setup()`?
+
+Similarly, sometimes people spell `SetUpTestCase()` as `SetupTestCase()` and
+wonder why it's never called.
+
+## How do I jump to the line of a failure in Emacs directly? ##
+
+Google Test's failure message format is understood by Emacs and many other
+IDEs, like acme and XCode. If a Google Test message is in a compilation buffer
+in Emacs, then it's clickable. You can now hit `enter` on a message to jump to
+the corresponding source code, or use `C-x `` to jump to the next failure.
+
+## I have several test cases which share the same test fixture logic, do I have to define a new test fixture class for each of them? This seems pretty tedious. ##
+
+You don't have to. Instead of
+
+```
+class FooTest : public BaseTest {};
+
+TEST_F(FooTest, Abc) { ... }
+TEST_F(FooTest, Def) { ... }
+
+class BarTest : public BaseTest {};
+
+TEST_F(BarTest, Abc) { ... }
+TEST_F(BarTest, Def) { ... }
+```
+
+you can simply `typedef` the test fixtures:
+```
+typedef BaseTest FooTest;
+
+TEST_F(FooTest, Abc) { ... }
+TEST_F(FooTest, Def) { ... }
+
+typedef BaseTest BarTest;
+
+TEST_F(BarTest, Abc) { ... }
+TEST_F(BarTest, Def) { ... }
+```
+
+## The Google Test output is buried in a whole bunch of log messages. What do I do? ##
+
+The Google Test output is meant to be a concise and human-friendly report. If
+your test generates textual output itself, it will mix with the Google Test
+output, making it hard to read. However, there is an easy solution to this
+problem.
+
+Since most log messages go to stderr, we decided to let Google Test output go
+to stdout. This way, you can easily separate the two using redirection. For
+example:
+```
+./my_test > googletest_output.txt
+```
+
+## Why should I prefer test fixtures over global variables? ##
+
+There are several good reasons:
+  1. It's likely your test needs to change the states of its global variables. This makes it difficult to keep side effects from escaping one test and contaminating others, making debugging difficult. By using fixtures, each test has a fresh set of variables that's different (but with the same names). Thus, tests are kept independent of each other.
+  1. Global variables pollute the global namespace.
+  1. Test fixtures can be reused via subclassing, which cannot be done easily with global variables. This is useful if many test cases have something in common.
+
+## How do I test private class members without writing FRIEND\_TEST()s? ##
+
+You should try to write testable code, which means classes should be easily
+tested from their public interface. One way to achieve this is the Pimpl idiom:
+you move all private members of a class into a helper class, and make all
+members of the helper class public.
+
+You have several other options that don't require using `FRIEND_TEST`:
+  * Write the tests as members of the fixture class:
+```
+class Foo {
+  friend class FooTest;
+  ...
+};
+
+class FooTest : public ::testing::Test {
+ protected:
+  ...
+  void Test1() {...} // This accesses private members of class Foo.
+  void Test2() {...} // So does this one.
+};
+
+TEST_F(FooTest, Test1) {
+  Test1();
+}
+
+TEST_F(FooTest, Test2) {
+  Test2();
+}
+```
+  * In the fixture class, write accessors for the tested class' private members, then use the accessors in your tests:
+```
+class Foo {
+  friend class FooTest;
+  ...
+};
+
+class FooTest : public ::testing::Test {
+ protected:
+  ...
+  T1 get_private_member1(Foo* obj) {
+    return obj->private_member1_;
+  }
+};
+
+TEST_F(FooTest, Test1) {
+  ...
+  get_private_member1(x)
+  ...
+}
+```
+  * If the methods are declared **protected**, you can change their access level in a test-only subclass:
+```
+class YourClass {
+  ...
+ protected: // protected access for testability.
+  int DoSomethingReturningInt();
+  ...
+};
+
+// in the your_class_test.cc file:
+class TestableYourClass : public YourClass {
+  ...
+ public: using YourClass::DoSomethingReturningInt; // changes access rights
+  ...
+};
+
+TEST_F(YourClassTest, DoSomethingTest) {
+  TestableYourClass obj;
+  assertEquals(expected_value, obj.DoSomethingReturningInt());
+}
+```
+
+## How do I test private class static members without writing FRIEND\_TEST()s? ##
+
+We find private static methods clutter the header file.  They are
+implementation details and ideally should be kept out of a .h. So often I make
+them free functions instead.
+
+Instead of:
+```
+// foo.h
+class Foo {
+  ...
+ private:
+  static bool Func(int n);
+};
+
+// foo.cc
+bool Foo::Func(int n) { ... }
+
+// foo_test.cc
+EXPECT_TRUE(Foo::Func(12345));
+```
+
+You probably should better write:
+```
+// foo.h
+class Foo {
+  ...
+};
+
+// foo.cc
+namespace internal {
+  bool Func(int n) { ... }
+}
+
+// foo_test.cc
+namespace internal {
+  bool Func(int n);
+}
+
+EXPECT_TRUE(internal::Func(12345));
+```
+
+## I would like to run a test several times with different parameters. Do I need to write several similar copies of it? ##
+
+No. You can use a feature called [value-parameterized tests](V1_5_AdvancedGuide.md#Value_Parameterized_Tests) which
+lets you repeat your tests with different parameters, without defining it more than once.
+
+## How do I test a file that defines main()? ##
+
+To test a `foo.cc` file, you need to compile and link it into your unit test
+program. However, when the file contains a definition for the `main()`
+function, it will clash with the `main()` of your unit test, and will result in
+a build error.
+
+The right solution is to split it into three files:
+  1. `foo.h` which contains the declarations,
+  1. `foo.cc` which contains the definitions except `main()`, and
+  1. `foo_main.cc` which contains nothing but the definition of `main()`.
+
+Then `foo.cc` can be easily tested.
+
+If you are adding tests to an existing file and don't want an intrusive change
+like this, there is a hack: just include the entire `foo.cc` file in your unit
+test. For example:
+```
+// File foo_unittest.cc
+
+// The headers section
+...
+
+// Renames main() in foo.cc to make room for the unit test main()
+#define main FooMain
+
+#include "a/b/foo.cc"
+
+// The tests start here.
+...
+```
+
+
+However, please remember this is a hack and should only be used as the last
+resort.
+
+## What can the statement argument in ASSERT\_DEATH() be? ##
+
+`ASSERT_DEATH(_statement_, _regex_)` (or any death assertion macro) can be used
+wherever `_statement_` is valid. So basically `_statement_` can be any C++
+statement that makes sense in the current context. In particular, it can
+reference global and/or local variables, and can be:
+  * a simple function call (often the case),
+  * a complex expression, or
+  * a compound statement.
+
+> Some examples are shown here:
+
+```
+// A death test can be a simple function call.
+TEST(MyDeathTest, FunctionCall) {
+  ASSERT_DEATH(Xyz(5), "Xyz failed");
+}
+
+// Or a complex expression that references variables and functions.
+TEST(MyDeathTest, ComplexExpression) {
+  const bool c = Condition();
+  ASSERT_DEATH((c ? Func1(0) : object2.Method("test")),
+               "(Func1|Method) failed");
+}
+
+// Death assertions can be used any where in a function. In
+// particular, they can be inside a loop.
+TEST(MyDeathTest, InsideLoop) {
+  // Verifies that Foo(0), Foo(1), ..., and Foo(4) all die.
+  for (int i = 0; i < 5; i++) {
+    EXPECT_DEATH_M(Foo(i), "Foo has \\d+ errors",
+                   ::testing::Message() << "where i is " << i);
+  }
+}
+
+// A death assertion can contain a compound statement.
+TEST(MyDeathTest, CompoundStatement) {
+  // Verifies that at lease one of Bar(0), Bar(1), ..., and
+  // Bar(4) dies.
+  ASSERT_DEATH({
+    for (int i = 0; i < 5; i++) {
+      Bar(i);
+    }
+  },
+  "Bar has \\d+ errors");}
+```
+
+`googletest_unittest.cc` contains more examples if you are interested.
+
+## What syntax does the regular expression in ASSERT\_DEATH use? ##
+
+On POSIX systems, Google Test uses the POSIX Extended regular
+expression syntax
+(http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions). On
+Windows, it uses a limited variant of regular expression syntax. For
+more details, see the [regular expression syntax](V1_5_AdvancedGuide.md#Regular_Expression_Syntax).
+
+## I have a fixture class Foo, but TEST\_F(Foo, Bar) gives me error "no matching function for call to Foo::Foo()". Why? ##
+
+Google Test needs to be able to create objects of your test fixture class, so
+it must have a default constructor. Normally the compiler will define one for
+you. However, there are cases where you have to define your own:
+  * If you explicitly declare a non-default constructor for class `Foo`, then you need to define a default constructor, even if it would be empty.
+  * If `Foo` has a const non-static data member, then you have to define the default constructor _and_ initialize the const member in the initializer list of the constructor. (Early versions of `gcc` doesn't force you to initialize the const member. It's a bug that has been fixed in `gcc 4`.)
+
+## Why does ASSERT\_DEATH complain about previous threads that were already joined? ##
+
+With the Linux pthread library, there is no turning back once you cross the
+line from single thread to multiple threads. The first time you create a
+thread, a manager thread is created in addition, so you get 3, not 2, threads.
+Later when the thread you create joins the main thread, the thread count
+decrements by 1, but the manager thread will never be killed, so you still have
+2 threads, which means you cannot safely run a death test.
+
+The new NPTL thread library doesn't suffer from this problem, as it doesn't
+create a manager thread. However, if you don't control which machine your test
+runs on, you shouldn't depend on this.
+
+## Why does Google Test require the entire test case, instead of individual tests, to be named FOODeathTest when it uses ASSERT\_DEATH? ##
+
+Google Test does not interleave tests from different test cases. That is, it
+runs all tests in one test case first, and then runs all tests in the next test
+case, and so on. Google Test does this because it needs to set up a test case
+before the first test in it is run, and tear it down afterwords. Splitting up
+the test case would require multiple set-up and tear-down processes, which is
+inefficient and makes the semantics unclean.
+
+If we were to determine the order of tests based on test name instead of test
+case name, then we would have a problem with the following situation:
+
+```
+TEST_F(FooTest, AbcDeathTest) { ... }
+TEST_F(FooTest, Uvw) { ... }
+
+TEST_F(BarTest, DefDeathTest) { ... }
+TEST_F(BarTest, Xyz) { ... }
+```
+
+Since `FooTest.AbcDeathTest` needs to run before `BarTest.Xyz`, and we don't
+interleave tests from different test cases, we need to run all tests in the
+`FooTest` case before running any test in the `BarTest` case. This contradicts
+with the requirement to run `BarTest.DefDeathTest` before `FooTest.Uvw`.
+
+## But I don't like calling my entire test case FOODeathTest when it contains both death tests and non-death tests. What do I do? ##
+
+You don't have to, but if you like, you may split up the test case into
+`FooTest` and `FooDeathTest`, where the names make it clear that they are
+related:
+
+```
+class FooTest : public ::testing::Test { ... };
+
+TEST_F(FooTest, Abc) { ... }
+TEST_F(FooTest, Def) { ... }
+
+typedef FooTest FooDeathTest;
+
+TEST_F(FooDeathTest, Uvw) { ... EXPECT_DEATH(...) ... }
+TEST_F(FooDeathTest, Xyz) { ... ASSERT_DEATH(...) ... }
+```
+
+## The compiler complains about "no match for 'operator<<'" when I use an assertion. What gives? ##
+
+If you use a user-defined type `FooType` in an assertion, you must make sure
+there is an `std::ostream& operator<<(std::ostream&, const FooType&)` function
+defined such that we can print a value of `FooType`.
+
+In addition, if `FooType` is declared in a name space, the `<<` operator also
+needs to be defined in the _same_ name space.
+
+## How do I suppress the memory leak messages on Windows? ##
+
+Since the statically initialized Google Test singleton requires allocations on
+the heap, the Visual C++ memory leak detector will report memory leaks at the
+end of the program run. The easiest way to avoid this is to use the
+`_CrtMemCheckpoint` and `_CrtMemDumpAllObjectsSince` calls to not report any
+statically initialized heap objects. See MSDN for more details and additional
+heap check/debug routines.
+
+## I am building my project with Google Test in Visual Studio and all I'm getting is a bunch of linker errors (or warnings). Help! ##
+
+You may get a number of the following linker error or warnings if you
+attempt to link your test project with the Google Test library when
+your project and the are not built using the same compiler settings.
+
+  * LNK2005: symbol already defined in object
+  * LNK4217: locally defined symbol 'symbol' imported in function 'function'
+  * LNK4049: locally defined symbol 'symbol' imported
+
+The Google Test project (gtest.vcproj) has the Runtime Library option
+set to /MT (use multi-threaded static libraries, /MTd for debug). If
+your project uses something else, for example /MD (use multi-threaded
+DLLs, /MDd for debug), you need to change the setting in the Google
+Test project to match your project's.
+
+To update this setting open the project properties in the Visual
+Studio IDE then select the branch Configuration Properties | C/C++ |
+Code Generation and change the option "Runtime Library".  You may also try
+using gtest-md.vcproj instead of gtest.vcproj.
+
+## I put my tests in a library and Google Test doesn't run them. What's happening? ##
+Have you read a
+[warning](V1_5_Primer.md#important-note-for-visual-c-users) on
+the Google Test Primer page?
+
+## I want to use Google Test with Visual Studio but don't know where to start. ##
+Many people are in your position and one of the posted his solution to
+our mailing list. Here is his link:
+http://hassanjamilahmad.blogspot.com/2009/07/gtest-starters-help.html.
+
+## My question is not covered in your FAQ! ##
+
+If you cannot find the answer to your question in this FAQ, there are
+some other resources you can use:
+
+  1. read other [wiki pages](http://code.google.com/p/googletest/w/list),
+  1. search the mailing list [archive](http://groups.google.com/group/googletestframework/topics),
+  1. ask it on [googletestframework@googlegroups.com](mailto:googletestframework@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googletestframework) before you can post.).
+
+Please note that creating an issue in the
+[issue tracker](http://code.google.com/p/googletest/issues/list) is _not_
+a good way to get your answer, as it is monitored infrequently by a
+very small number of people.
+
+When asking a question, it's helpful to provide as much of the
+following information as possible (people cannot help you if there's
+not enough information in your question):
+
+  * the version (or the revision number if you check out from SVN directly) of Google Test you use (Google Test is under active development, so it's possible that your problem has been solved in a later version),
+  * your operating system,
+  * the name and version of your compiler,
+  * the complete command line flags you give to your compiler,
+  * the complete compiler error messages (if the question is about compilation),
+  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Primer.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Primer.md
new file mode 100644
index 00000000..6960d2ce
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Primer.md
@@ -0,0 +1,497 @@
+
+
+# Introduction: Why Google C++ Testing Framework? #
+
+_Google C++ Testing Framework_ helps you write better C++ tests.
+
+No matter whether you work on Linux, Windows, or a Mac, if you write C++ code,
+Google Test can help you.
+
+So what makes a good test, and how does Google C++ Testing Framework fit in? We believe:
+  1. Tests should be _independent_ and _repeatable_. It's a pain to debug a test that succeeds or fails as a result of other tests.  Google C++ Testing Framework isolates the tests by running each of them on a different object. When a test fails, Google C++ Testing Framework allows you to run it in isolation for quick debugging.
+  1. Tests should be well _organized_ and reflect the structure of the tested code.  Google C++ Testing Framework groups related tests into test cases that can share data and subroutines. This common pattern is easy to recognize and makes tests easy to maintain. Such consistency is especially helpful when people switch projects and start to work on a new code base.
+  1. Tests should be _portable_ and _reusable_. The open-source community has a lot of code that is platform-neutral, its tests should also be platform-neutral.  Google C++ Testing Framework works on different OSes, with different compilers (gcc, MSVC, and others), with or without exceptions, so Google C++ Testing Framework tests can easily work with a variety of configurations.  (Note that the current release only contains build scripts for Linux - we are actively working on scripts for other platforms.)
+  1. When tests fail, they should provide as much _information_ about the problem as possible. Google C++ Testing Framework doesn't stop at the first test failure. Instead, it only stops the current test and continues with the next. You can also set up tests that report non-fatal failures after which the current test continues. Thus, you can detect and fix multiple bugs in a single run-edit-compile cycle.
+  1. The testing framework should liberate test writers from housekeeping chores and let them focus on the test _content_.  Google C++ Testing Framework automatically keeps track of all tests defined, and doesn't require the user to enumerate them in order to run them.
+  1. Tests should be _fast_. With Google C++ Testing Framework, you can reuse shared resources across tests and pay for the set-up/tear-down only once, without making tests depend on each other.
+
+Since Google C++ Testing Framework is based on the popular xUnit
+architecture, you'll feel right at home if you've used JUnit or PyUnit before.
+If not, it will take you about 10 minutes to learn the basics and get started.
+So let's go!
+
+_Note:_ We sometimes refer to Google C++ Testing Framework informally
+as _Google Test_.
+
+# Setting up a New Test Project #
+
+To write a test program using Google Test, you need to compile Google
+Test into a library and link your test with it.  We provide build
+files for some popular build systems (`msvc/` for Visual Studio,
+`xcode/` for Mac Xcode, `make/` for GNU make, `codegear/` for Borland
+C++ Builder, and the autotools script in the
+Google Test root directory).  If your build system is not on this
+list, you can take a look at `make/Makefile` to learn how Google Test
+should be compiled (basically you want to compile `src/gtest-all.cc`
+with `GTEST_ROOT` and `GTEST_ROOT/include` in the header search path,
+where `GTEST_ROOT` is the Google Test root directory).
+
+Once you are able to compile the Google Test library, you should
+create a project or build target for your test program.  Make sure you
+have `GTEST_ROOT/include` in the header search path so that the
+compiler can find `<gtest/gtest.h>` when compiling your test.  Set up
+your test project to link with the Google Test library (for example,
+in Visual Studio, this is done by adding a dependency on
+`gtest.vcproj`).
+
+If you still have questions, take a look at how Google Test's own
+tests are built and use them as examples.
+
+# Basic Concepts #
+
+When using Google Test, you start by writing _assertions_, which are statements
+that check whether a condition is true. An assertion's result can be _success_,
+_nonfatal failure_, or _fatal failure_. If a fatal failure occurs, it aborts
+the current function; otherwise the program continues normally.
+
+_Tests_ use assertions to verify the tested code's behavior. If a test crashes
+or has a failed assertion, then it _fails_; otherwise it _succeeds_.
+
+A _test case_ contains one or many tests. You should group your tests into test
+cases that reflect the structure of the tested code. When multiple tests in a
+test case need to share common objects and subroutines, you can put them into a
+_test fixture_ class.
+
+A _test program_ can contain multiple test cases.
+
+We'll now explain how to write a test program, starting at the individual
+assertion level and building up to tests and test cases.
+
+# Assertions #
+
+Google Test assertions are macros that resemble function calls. You test a
+class or function by making assertions about its behavior. When an assertion
+fails, Google Test prints the assertion's source file and line number location,
+along with a failure message. You may also supply a custom failure message
+which will be appended to Google Test's message.
+
+The assertions come in pairs that test the same thing but have different
+effects on the current function. `ASSERT_*` versions generate fatal failures
+when they fail, and **abort the current function**. `EXPECT_*` versions generate
+nonfatal failures, which don't abort the current function. Usually `EXPECT_*`
+are preferred, as they allow more than one failures to be reported in a test.
+However, you should use `ASSERT_*` if it doesn't make sense to continue when
+the assertion in question fails.
+
+Since a failed `ASSERT_*` returns from the current function immediately,
+possibly skipping clean-up code that comes after it, it may cause a space leak.
+Depending on the nature of the leak, it may or may not be worth fixing - so
+keep this in mind if you get a heap checker error in addition to assertion
+errors.
+
+To provide a custom failure message, simply stream it into the macro using the
+`<<` operator, or a sequence of such operators. An example:
+```
+ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length";
+
+for (int i = 0; i < x.size(); ++i) {
+  EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i;
+}
+```
+
+Anything that can be streamed to an `ostream` can be streamed to an assertion
+macro--in particular, C strings and `string` objects. If a wide string
+(`wchar_t*`, `TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is
+streamed to an assertion, it will be translated to UTF-8 when printed.
+
+## Basic Assertions ##
+
+These assertions do basic true/false condition testing.
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_TRUE(`_condition_`)`;  | `EXPECT_TRUE(`_condition_`)`;   | _condition_ is true |
+| `ASSERT_FALSE(`_condition_`)`; | `EXPECT_FALSE(`_condition_`)`;  | _condition_ is false |
+
+Remember, when they fail, `ASSERT_*` yields a fatal failure and
+returns from the current function, while `EXPECT_*` yields a nonfatal
+failure, allowing the function to continue running. In either case, an
+assertion failure means its containing test fails.
+
+_Availability_: Linux, Windows, Mac.
+
+## Binary Comparison ##
+
+This section describes assertions that compare two values.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+|`ASSERT_EQ(`_expected_`, `_actual_`);`|`EXPECT_EQ(`_expected_`, `_actual_`);`| _expected_ `==` _actual_ |
+|`ASSERT_NE(`_val1_`, `_val2_`);`      |`EXPECT_NE(`_val1_`, `_val2_`);`      | _val1_ `!=` _val2_ |
+|`ASSERT_LT(`_val1_`, `_val2_`);`      |`EXPECT_LT(`_val1_`, `_val2_`);`      | _val1_ `<` _val2_ |
+|`ASSERT_LE(`_val1_`, `_val2_`);`      |`EXPECT_LE(`_val1_`, `_val2_`);`      | _val1_ `<=` _val2_ |
+|`ASSERT_GT(`_val1_`, `_val2_`);`      |`EXPECT_GT(`_val1_`, `_val2_`);`      | _val1_ `>` _val2_ |
+|`ASSERT_GE(`_val1_`, `_val2_`);`      |`EXPECT_GE(`_val1_`, `_val2_`);`      | _val1_ `>=` _val2_ |
+
+In the event of a failure, Google Test prints both _val1_ and _val2_
+. In `ASSERT_EQ*` and `EXPECT_EQ*` (and all other equality assertions
+we'll introduce later), you should put the expression you want to test
+in the position of _actual_, and put its expected value in _expected_,
+as Google Test's failure messages are optimized for this convention.
+
+Value arguments must be comparable by the assertion's comparison operator or
+you'll get a compiler error. Values must also support the `<<` operator for
+streaming to an `ostream`. All built-in types support this.
+
+These assertions can work with a user-defined type, but only if you define the
+corresponding comparison operator (e.g. `==`, `<`, etc).  If the corresponding
+operator is defined, prefer using the `ASSERT_*()` macros because they will
+print out not only the result of the comparison, but the two operands as well.
+
+Arguments are always evaluated exactly once. Therefore, it's OK for the
+arguments to have side effects. However, as with any ordinary C/C++ function,
+the arguments' evaluation order is undefined (i.e. the compiler is free to
+choose any order) and your code should not depend on any particular argument
+evaluation order.
+
+`ASSERT_EQ()` does pointer equality on pointers. If used on two C strings, it
+tests if they are in the same memory location, not if they have the same value.
+Therefore, if you want to compare C strings (e.g. `const char*`) by value, use
+`ASSERT_STREQ()` , which will be described later on. In particular, to assert
+that a C string is `NULL`, use `ASSERT_STREQ(NULL, c_string)` . However, to
+compare two `string` objects, you should use `ASSERT_EQ`.
+
+Macros in this section work with both narrow and wide string objects (`string`
+and `wstring`).
+
+_Availability_: Linux, Windows, Mac.
+
+## String Comparison ##
+
+The assertions in this group compare two **C strings**. If you want to compare
+two `string` objects, use `EXPECT_EQ`, `EXPECT_NE`, and etc instead.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_STREQ(`_expected\_str_`, `_actual\_str_`);`    | `EXPECT_STREQ(`_expected\_str_`, `_actual\_str_`);`     | the two C strings have the same content |
+| `ASSERT_STRNE(`_str1_`, `_str2_`);`    | `EXPECT_STRNE(`_str1_`, `_str2_`);`     | the two C strings have different content |
+| `ASSERT_STRCASEEQ(`_expected\_str_`, `_actual\_str_`);`| `EXPECT_STRCASEEQ(`_expected\_str_`, `_actual\_str_`);` | the two C strings have the same content, ignoring case |
+| `ASSERT_STRCASENE(`_str1_`, `_str2_`);`| `EXPECT_STRCASENE(`_str1_`, `_str2_`);` | the two C strings have different content, ignoring case |
+
+Note that "CASE" in an assertion name means that case is ignored.
+
+`*STREQ*` and `*STRNE*` also accept wide C strings (`wchar_t*`). If a
+comparison of two wide strings fails, their values will be printed as UTF-8
+narrow strings.
+
+A `NULL` pointer and an empty string are considered _different_.
+
+_Availability_: Linux, Windows, Mac.
+
+See also: For more string comparison tricks (substring, prefix, suffix, and
+regular expression matching, for example), see the [AdvancedGuide Advanced
+Google Test Guide].
+
+# Simple Tests #
+
+To create a test:
+  1. Use the `TEST()` macro to define and name a test function, These are ordinary C++ functions that don't return a value.
+  1. In this function, along with any valid C++ statements you want to include, use the various Google Test assertions to check values.
+  1. The test's result is determined by the assertions; if any assertion in the test fails (either fatally or non-fatally), or if the test crashes, the entire test fails. Otherwise, it succeeds.
+
+```
+TEST(test_case_name, test_name) {
+ ... test body ...
+}
+```
+
+
+`TEST()` arguments go from general to specific. The _first_ argument is the
+name of the test case, and the _second_ argument is the test's name within the
+test case. Remember that a test case can contain any number of individual
+tests. A test's _full name_ consists of its containing test case and its
+individual name. Tests from different test cases can have the same individual
+name.
+
+For example, let's take a simple integer function:
+```
+int Factorial(int n); // Returns the factorial of n
+```
+
+A test case for this function might look like:
+```
+// Tests factorial of 0.
+TEST(FactorialTest, HandlesZeroInput) {
+  EXPECT_EQ(1, Factorial(0));
+}
+
+// Tests factorial of positive numbers.
+TEST(FactorialTest, HandlesPositiveInput) {
+  EXPECT_EQ(1, Factorial(1));
+  EXPECT_EQ(2, Factorial(2));
+  EXPECT_EQ(6, Factorial(3));
+  EXPECT_EQ(40320, Factorial(8));
+}
+```
+
+Google Test groups the test results by test cases, so logically-related tests
+should be in the same test case; in other words, the first argument to their
+`TEST()` should be the same. In the above example, we have two tests,
+`HandlesZeroInput` and `HandlesPositiveInput`, that belong to the same test
+case `FactorialTest`.
+
+_Availability_: Linux, Windows, Mac.
+
+# Test Fixtures: Using the Same Data Configuration for Multiple Tests #
+
+If you find yourself writing two or more tests that operate on similar data,
+you can use a _test fixture_. It allows you to reuse the same configuration of
+objects for several different tests.
+
+To create a fixture, just:
+  1. Derive a class from `::testing::Test` . Start its body with `protected:` or `public:` as we'll want to access fixture members from sub-classes.
+  1. Inside the class, declare any objects you plan to use.
+  1. If necessary, write a default constructor or `SetUp()` function to prepare the objects for each test. A common mistake is to spell `SetUp()` as `Setup()` with a small `u` - don't let that happen to you.
+  1. If necessary, write a destructor or `TearDown()` function to release any resources you allocated in `SetUp()` . To learn when you should use the constructor/destructor and when you should use `SetUp()/TearDown()`, read this [FAQ entry](V1_5_FAQ.md#should-i-use-the-constructordestructor-of-the-test-fixture-or-the-set-uptear-down-function).
+  1. If needed, define subroutines for your tests to share.
+
+When using a fixture, use `TEST_F()` instead of `TEST()` as it allows you to
+access objects and subroutines in the test fixture:
+```
+TEST_F(test_case_name, test_name) {
+ ... test body ...
+}
+```
+
+Like `TEST()`, the first argument is the test case name, but for `TEST_F()`
+this must be the name of the test fixture class. You've probably guessed: `_F`
+is for fixture.
+
+Unfortunately, the C++ macro system does not allow us to create a single macro
+that can handle both types of tests. Using the wrong macro causes a compiler
+error.
+
+Also, you must first define a test fixture class before using it in a
+`TEST_F()`, or you'll get the compiler error "`virtual outside class
+declaration`".
+
+For each test defined with `TEST_F()`, Google Test will:
+  1. Create a _fresh_ test fixture at runtime
+  1. Immediately initialize it via `SetUp()` ,
+  1. Run the test
+  1. Clean up by calling `TearDown()`
+  1. Delete the test fixture.  Note that different tests in the same test case have different test fixture objects, and Google Test always deletes a test fixture before it creates the next one. Google Test does not reuse the same test fixture for multiple tests. Any changes one test makes to the fixture do not affect other tests.
+
+As an example, let's write tests for a FIFO queue class named `Queue`, which
+has the following interface:
+```
+template <typename E> // E is the element type.
+class Queue {
+ public:
+  Queue();
+  void Enqueue(const E& element);
+  E* Dequeue(); // Returns NULL if the queue is empty.
+  size_t size() const;
+  ...
+};
+```
+
+First, define a fixture class. By convention, you should give it the name
+`FooTest` where `Foo` is the class being tested.
+```
+class QueueTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    q1_.Enqueue(1);
+    q2_.Enqueue(2);
+    q2_.Enqueue(3);
+  }
+
+  // virtual void TearDown() {}
+
+  Queue<int> q0_;
+  Queue<int> q1_;
+  Queue<int> q2_;
+};
+```
+
+In this case, `TearDown()` is not needed since we don't have to clean up after
+each test, other than what's already done by the destructor.
+
+Now we'll write tests using `TEST_F()` and this fixture.
+```
+TEST_F(QueueTest, IsEmptyInitially) {
+  EXPECT_EQ(0, q0_.size());
+}
+
+TEST_F(QueueTest, DequeueWorks) {
+  int* n = q0_.Dequeue();
+  EXPECT_EQ(NULL, n);
+
+  n = q1_.Dequeue();
+  ASSERT_TRUE(n != NULL);
+  EXPECT_EQ(1, *n);
+  EXPECT_EQ(0, q1_.size());
+  delete n;
+
+  n = q2_.Dequeue();
+  ASSERT_TRUE(n != NULL);
+  EXPECT_EQ(2, *n);
+  EXPECT_EQ(1, q2_.size());
+  delete n;
+}
+```
+
+The above uses both `ASSERT_*` and `EXPECT_*` assertions. The rule of thumb is
+to use `EXPECT_*` when you want the test to continue to reveal more errors
+after the assertion failure, and use `ASSERT_*` when continuing after failure
+doesn't make sense. For example, the second assertion in the `Dequeue` test is
+`ASSERT_TRUE(n != NULL)`, as we need to dereference the pointer `n` later,
+which would lead to a segfault when `n` is `NULL`.
+
+When these tests run, the following happens:
+  1. Google Test constructs a `QueueTest` object (let's call it `t1` ).
+  1. `t1.SetUp()` initializes `t1` .
+  1. The first test ( `IsEmptyInitially` ) runs on `t1` .
+  1. `t1.TearDown()` cleans up after the test finishes.
+  1. `t1` is destructed.
+  1. The above steps are repeated on another `QueueTest` object, this time running the `DequeueWorks` test.
+
+_Availability_: Linux, Windows, Mac.
+
+_Note_: Google Test automatically saves all _Google Test_ flags when a test
+object is constructed, and restores them when it is destructed.
+
+# Invoking the Tests #
+
+`TEST()` and `TEST_F()` implicitly register their tests with Google Test. So, unlike with many other C++ testing frameworks, you don't have to re-list all your defined tests in order to run them.
+
+After defining your tests, you can run them with `RUN_ALL_TESTS()` , which returns `0` if all the tests are successful, or `1` otherwise. Note that `RUN_ALL_TESTS()` runs _all tests_ in your link unit -- they can be from different test cases, or even different source files.
+
+When invoked, the `RUN_ALL_TESTS()` macro:
+  1. Saves the state of all  Google Test flags.
+  1. Creates a test fixture object for the first test.
+  1. Initializes it via `SetUp()`.
+  1. Runs the test on the fixture object.
+  1. Cleans up the fixture via `TearDown()`.
+  1. Deletes the fixture.
+  1. Restores the state of all Google Test flags.
+  1. Repeats the above steps for the next test, until all tests have run.
+
+In addition, if the text fixture's constructor generates a fatal failure in
+step 2, there is no point for step 3 - 5 and they are thus skipped. Similarly,
+if step 3 generates a fatal failure, step 4 will be skipped.
+
+_Important_: You must not ignore the return value of `RUN_ALL_TESTS()`, or `gcc`
+will give you a compiler error. The rationale for this design is that the
+automated testing service determines whether a test has passed based on its
+exit code, not on its stdout/stderr output; thus your `main()` function must
+return the value of `RUN_ALL_TESTS()`.
+
+Also, you should call `RUN_ALL_TESTS()` only **once**. Calling it more than once
+conflicts with some advanced Google Test features (e.g. thread-safe death
+tests) and thus is not supported.
+
+_Availability_: Linux, Windows, Mac.
+
+# Writing the main() Function #
+
+You can start from this boilerplate:
+```
+#include "this/package/foo.h"
+#include <gtest/gtest.h>
+
+namespace {
+
+// The fixture for testing class Foo.
+class FooTest : public ::testing::Test {
+ protected:
+  // You can remove any or all of the following functions if its body
+  // is empty.
+
+  FooTest() {
+    // You can do set-up work for each test here.
+  }
+
+  virtual ~FooTest() {
+    // You can do clean-up work that doesn't throw exceptions here.
+  }
+
+  // If the constructor and destructor are not enough for setting up
+  // and cleaning up each test, you can define the following methods:
+
+  virtual void SetUp() {
+    // Code here will be called immediately after the constructor (right
+    // before each test).
+  }
+
+  virtual void TearDown() {
+    // Code here will be called immediately after each test (right
+    // before the destructor).
+  }
+
+  // Objects declared here can be used by all tests in the test case for Foo.
+};
+
+// Tests that the Foo::Bar() method does Abc.
+TEST_F(FooTest, MethodBarDoesAbc) {
+  const string input_filepath = "this/package/testdata/myinputfile.dat";
+  const string output_filepath = "this/package/testdata/myoutputfile.dat";
+  Foo f;
+  EXPECT_EQ(0, f.Bar(input_filepath, output_filepath));
+}
+
+// Tests that Foo does Xyz.
+TEST_F(FooTest, DoesXyz) {
+  // Exercises the Xyz feature of Foo.
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+```
+
+The `::testing::InitGoogleTest()` function parses the command line for Google
+Test flags, and removes all recognized flags. This allows the user to control a
+test program's behavior via various flags, which we'll cover in [AdvancedGuide](V1_5_AdvancedGuide.md).
+You must call this function before calling `RUN_ALL_TESTS()`, or the flags
+won't be properly initialized.
+
+On Windows, `InitGoogleTest()` also works with wide strings, so it can be used
+in programs compiled in `UNICODE` mode as well.
+
+But maybe you think that writing all those main() functions is too much work? We agree with you completely and that's why Google Test provides a basic implementation of main(). If it fits your needs, then just link your test with gtest\_main library and you are good to go.
+
+## Important note for Visual C++ users ##
+If you put your tests into a library and your `main()` function is in a different library or in your .exe file, those tests will not run. The reason is a [bug](https://connect.microsoft.com/feedback/viewfeedback.aspx?FeedbackID=244410&siteid=210) in Visual C++. When you define your tests, Google Test creates certain static objects to register them. These objects are not referenced from elsewhere but their constructors are still supposed to run. When Visual C++ linker sees that nothing in the library is referenced from other places it throws the library out. You have to reference your library with tests from your main program to keep the linker from discarding it. Here is how to do it. Somewhere in your library code declare a function:
+```
+__declspec(dllexport) int PullInMyLibrary() { return 0; }
+```
+If you put your tests in a static library (not DLL) then `__declspec(dllexport)` is not required. Now, in your main program, write a code that invokes that function:
+```
+int PullInMyLibrary();
+static int dummy = PullInMyLibrary();
+```
+This will keep your tests referenced and will make them register themselves at startup.
+
+In addition, if you define your tests in a static library, add `/OPT:NOREF` to your main program linker options. If you use MSVC++ IDE, go to your .exe project properties/Configuration Properties/Linker/Optimization and set References setting to `Keep Unreferenced Data (/OPT:NOREF)`. This will keep Visual C++ linker from discarding individual symbols generated by your tests from the final executable.
+
+There is one more pitfall, though. If you use Google Test as a static library (that's how it is defined in gtest.vcproj) your tests must also reside in a static library. If you have to have them in a DLL, you _must_ change Google Test to build into a DLL as well. Otherwise your tests will not run correctly or will not run at all. The general conclusion here is: make your life easier - do not write your tests in libraries!
+
+# Where to Go from Here #
+
+Congratulations! You've learned the Google Test basics. You can start writing
+and running Google Test tests, read some [samples](Samples.md), or continue with
+[AdvancedGuide](V1_5_AdvancedGuide.md), which describes many more useful Google Test features.
+
+# Known Limitations #
+
+Google Test is designed to be thread-safe.  The implementation is
+thread-safe on systems where the `pthreads` library is available.  It
+is currently _unsafe_ to use Google Test assertions from two threads
+concurrently on other systems (e.g. Windows).  In most tests this is
+not an issue as usually the assertions are done in the main thread. If
+you want to help, you can volunteer to implement the necessary
+synchronization primitives in `gtest-port.h` for your platform.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_PumpManual.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_PumpManual.md
new file mode 100644
index 00000000..15710789
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_PumpManual.md
@@ -0,0 +1,177 @@
+
+
+<b>P</b>ump is <b>U</b>seful for <b>M</b>eta <b>P</b>rogramming.
+
+# The Problem #
+
+Template and macro libraries often need to define many classes,
+functions, or macros that vary only (or almost only) in the number of
+arguments they take. It's a lot of repetitive, mechanical, and
+error-prone work.
+
+Variadic templates and variadic macros can alleviate the problem.
+However, while both are being considered by the C++ committee, neither
+is in the standard yet or widely supported by compilers.  Thus they
+are often not a good choice, especially when your code needs to be
+portable. And their capabilities are still limited.
+
+As a result, authors of such libraries often have to write scripts to
+generate their implementation. However, our experience is that it's
+tedious to write such scripts, which tend to reflect the structure of
+the generated code poorly and are often hard to read and edit. For
+example, a small change needed in the generated code may require some
+non-intuitive, non-trivial changes in the script. This is especially
+painful when experimenting with the code.
+
+# Our Solution #
+
+Pump (for Pump is Useful for Meta Programming, Pretty Useful for Meta
+Programming, or Practical Utility for Meta Programming, whichever you
+prefer) is a simple meta-programming tool for C++. The idea is that a
+programmer writes a `foo.pump` file which contains C++ code plus meta
+code that manipulates the C++ code. The meta code can handle
+iterations over a range, nested iterations, local meta variable
+definitions, simple arithmetic, and conditional expressions. You can
+view it as a small Domain-Specific Language. The meta language is
+designed to be non-intrusive (s.t. it won't confuse Emacs' C++ mode,
+for example) and concise, making Pump code intuitive and easy to
+maintain.
+
+## Highlights ##
+
+  * The implementation is in a single Python script and thus ultra portable: no build or installation is needed and it works cross platforms.
+  * Pump tries to be smart with respect to [Google's style guide](http://code.google.com/p/google-styleguide/): it breaks long lines (easy to have when they are generated) at acceptable places to fit within 80 columns and indent the continuation lines correctly.
+  * The format is human-readable and more concise than XML.
+  * The format works relatively well with Emacs' C++ mode.
+
+## Examples ##
+
+The following Pump code (where meta keywords start with `$`, `[[` and `]]` are meta brackets, and `$$` starts a meta comment that ends with the line):
+
+```
+$var n = 3     $$ Defines a meta variable n.
+$range i 0..n  $$ Declares the range of meta iterator i (inclusive).
+$for i [[
+               $$ Meta loop.
+// Foo$i does blah for $i-ary predicates.
+$range j 1..i
+template <size_t N $for j [[, typename A$j]]>
+class Foo$i {
+$if i == 0 [[
+  blah a;
+]] $elif i <= 2 [[
+  blah b;
+]] $else [[
+  blah c;
+]]
+};
+
+]]
+```
+
+will be translated by the Pump compiler to:
+
+```
+// Foo0 does blah for 0-ary predicates.
+template <size_t N>
+class Foo0 {
+  blah a;
+};
+
+// Foo1 does blah for 1-ary predicates.
+template <size_t N, typename A1>
+class Foo1 {
+  blah b;
+};
+
+// Foo2 does blah for 2-ary predicates.
+template <size_t N, typename A1, typename A2>
+class Foo2 {
+  blah b;
+};
+
+// Foo3 does blah for 3-ary predicates.
+template <size_t N, typename A1, typename A2, typename A3>
+class Foo3 {
+  blah c;
+};
+```
+
+In another example,
+
+```
+$range i 1..n
+Func($for i + [[a$i]]);
+$$ The text between i and [[ is the separator between iterations.
+```
+
+will generate one of the following lines (without the comments), depending on the value of `n`:
+
+```
+Func();              // If n is 0.
+Func(a1);            // If n is 1.
+Func(a1 + a2);       // If n is 2.
+Func(a1 + a2 + a3);  // If n is 3.
+// And so on...
+```
+
+## Constructs ##
+
+We support the following meta programming constructs:
+
+| `$var id = exp` | Defines a named constant value. `$id` is valid util the end of the current meta lexical block. |
+|:----------------|:-----------------------------------------------------------------------------------------------|
+| $range id exp..exp | Sets the range of an iteration variable, which can be reused in multiple loops later.          |
+| $for id sep [[code ](.md)] | Iteration. The range of `id` must have been defined earlier. `$id` is valid in `code`.         |
+| `$($)`          | Generates a single `$` character.                                                              |
+| `$id`           | Value of the named constant or iteration variable.                                             |
+| `$(exp)`        | Value of the expression.                                                                       |
+| `$if exp [[ code ]] else_branch` | Conditional.                                                                                   |
+| `[[ code ]]`    | Meta lexical block.                                                                            |
+| `cpp_code`      | Raw C++ code.                                                                                  |
+| `$$ comment`    | Meta comment.                                                                                  |
+
+**Note:** To give the user some freedom in formatting the Pump source
+code, Pump ignores a new-line character if it's right after `$for foo`
+or next to `[[` or `]]`. Without this rule you'll often be forced to write
+very long lines to get the desired output. Therefore sometimes you may
+need to insert an extra new-line in such places for a new-line to show
+up in your output.
+
+## Grammar ##
+
+```
+code ::= atomic_code*
+atomic_code ::= $var id = exp
+    | $var id = [[ code ]]
+    | $range id exp..exp
+    | $for id sep [[ code ]]
+    | $($)
+    | $id
+    | $(exp)
+    | $if exp [[ code ]] else_branch
+    | [[ code ]]
+    | cpp_code
+sep ::= cpp_code | empty_string
+else_branch ::= $else [[ code ]]
+    | $elif exp [[ code ]] else_branch
+    | empty_string
+exp ::= simple_expression_in_Python_syntax
+```
+
+## Code ##
+
+You can find the source code of Pump in [scripts/pump.py](http://code.google.com/p/googletest/source/browse/trunk/scripts/pump.py). It is still
+very unpolished and lacks automated tests, although it has been
+successfully used many times. If you find a chance to use it in your
+project, please let us know what you think!  We also welcome help on
+improving Pump.
+
+## Real Examples ##
+
+You can find real-world applications of Pump in [Google Test](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgoogletest\.googlecode\.com) and [Google Mock](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgooglemock\.googlecode\.com).  The source file `foo.h.pump` generates `foo.h`.
+
+## Tips ##
+
+  * If a meta variable is followed by a letter or digit, you can separate them using `[[]]`, which inserts an empty string. For example `Foo$j[[]]Helper` generate `Foo1Helper` when `j` is 1.
+  * To avoid extra-long Pump source lines, you can break a line anywhere you want by inserting `[[]]` followed by a new line. Since any new-line character next to `[[` or `]]` is ignored, the generated code won't contain this new line.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_XcodeGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_XcodeGuide.md
new file mode 100644
index 00000000..bf24bf51
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_XcodeGuide.md
@@ -0,0 +1,93 @@
+
+
+This guide will explain how to use the Google Testing Framework in your Xcode projects on Mac OS X. This tutorial begins by quickly explaining what to do for experienced users. After the quick start, the guide goes provides additional explanation about each step.
+
+# Quick Start #
+
+Here is the quick guide for using Google Test in your Xcode project.
+
+  1. Download the source from the [website](http://code.google.com/p/googletest) using this command: `svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only`
+  1. Open up the `gtest.xcodeproj` in the `googletest-read-only/xcode/` directory and build the gtest.framework.
+  1. Create a new "Shell Tool" target in your Xcode project called something like "UnitTests"
+  1. Add the gtest.framework to your project and add it to the "Link Binary with Libraries" build phase of "UnitTests"
+  1. Add your unit test source code to the "Compile Sources" build phase of "UnitTests"
+  1. Edit the "UnitTests" executable and add an environment variable named "DYLD\_FRAMEWORK\_PATH" with a value equal to the path to the framework containing the gtest.framework relative to the compiled executable.
+  1. Build and Go
+
+The following sections further explain each of the steps listed above in depth, describing in more detail how to complete it including some variations.
+
+# Get the Source #
+
+Currently, the gtest.framework discussed here isn't available in a tagged release of Google Test, it is only available in the trunk. As explained at the Google Test [site](http://code.google.com/p/googletest/source/checkout">svn), you can get the code from anonymous SVN with this command:
+
+```
+svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only
+```
+
+Alternatively, if you are working with Subversion in your own code base, you can add Google Test as an external dependency to your own Subversion repository. By following this approach, everyone that checks out your svn repository will also receive a copy of Google Test (a specific version, if you wish) without having to check it out explicitly. This makes the set up of your project simpler and reduces the copied code in the repository.
+
+To use `svn:externals`, decide where you would like to have the external source reside. You might choose to put the external source inside the trunk, because you want it to be part of the branch when you make a release. However, keeping it outside the trunk in a version-tagged directory called something like `third-party/googletest/1.0.1`, is another option. Once the location is established, use `svn propedit svn:externals _directory_` to set the svn:externals property on a directory in your repository. This directory won't contain the code, but be its versioned parent directory.
+
+The command `svn propedit` will bring up your Subversion editor, making editing the long, (potentially multi-line) property simpler. This same method can be used to check out a tagged branch, by using the appropriate URL (e.g. `http://googletest.googlecode.com/svn/tags/release-1.0.1`). Additionally, the svn:externals property allows the specification of a particular revision of the trunk with the `-r_##_` option (e.g. `externals/src/googletest -r60 http://googletest.googlecode.com/svn/trunk`).
+
+Here is an example of using the svn:externals properties on a trunk (read via `svn propget`) of a project. This value checks out a copy of Google Test into the `trunk/externals/src/googletest/` directory.
+
+```
+[Computer:svn] user$ svn propget svn:externals trunk
+externals/src/googletest http://googletest.googlecode.com/svn/trunk
+```
+
+# Add the Framework to Your Project #
+
+The next step is to build and add the gtest.framework to your own project. This guide describes two common ways below.
+
+  * **Option 1** --- The simplest way to add Google Test to your own project, is to open gtest.xcodeproj (found in the xcode/ directory of the Google Test trunk) and build the framework manually. Then, add the built framework into your project using the "Add->Existing Framework..." from the context menu or "Project->Add..." from the main menu. The gtest.framework is relocatable and contains the headers and object code that you'll need to make tests. This method requires rebuilding every time you upgrade Google Test in your project.
+  * **Option 2** --- If you are going to be living off the trunk of Google Test, incorporating its latest features into your unit tests (or are a Google Test developer yourself). You'll want to rebuild the framework every time the source updates. to do this, you'll need to add the gtest.xcodeproj file, not the framework itself, to your own Xcode project. Then, from the build products that are revealed by the project's disclosure triangle, you can find the gtest.framework, which can be added to your targets (discussed below).
+
+# Make a Test Target #
+
+To start writing tests, make a new "Shell Tool" target. This target template is available under BSD, Cocoa, or Carbon. Add your unit test source code to the "Compile Sources" build phase of the target.
+
+Next, you'll want to add gtest.framework in two different ways, depending upon which option you chose above.
+
+  * **Option 1** --- During compilation, Xcode will need to know that you are linking against the gtest.framework. Add the gtest.framework to the "Link Binary with Libraries" build phase of your test target. This will include the Google Test headers in your header search path, and will tell the linker where to find the library.
+  * **Option 2** --- If your working out of the trunk, you'll also want to add gtest.framework to your "Link Binary with Libraries" build phase of your test target. In addition, you'll  want to add the gtest.framework as a dependency to your unit test target. This way, Xcode will make sure that gtest.framework is up to date, every time your build your target. Finally, if you don't share build directories with Google Test, you'll have to copy the gtest.framework into your own build products directory using a "Run Script" build phase.
+
+# Set Up the Executable Run Environment #
+
+Since the unit test executable is a shell tool, it doesn't have a bundle with a `Contents/Frameworks` directory, in which to place gtest.framework. Instead, the dynamic linker must be told at runtime to search for the framework in another location. This can be accomplished by setting the "DYLD\_FRAMEWORK\_PATH" environment variable in the "Edit Active Executable ..." Arguments tab, under "Variables to be set in the environment:". The path for this value is the path (relative or absolute) of the directory containing the gtest.framework.
+
+If you haven't set up the DYLD\_FRAMEWORK\_PATH, correctly, you might get a message like this:
+
+```
+[Session started at 2008-08-15 06:23:57 -0600.]
+  dyld: Library not loaded: @loader_path/../Frameworks/gtest.framework/Versions/A/gtest
+    Referenced from: /Users/username/Documents/Sandbox/gtestSample/build/Debug/WidgetFrameworkTest
+    Reason: image not found
+```
+
+To correct this problem, got to the directory containing the executable named in "Referenced from:" value in the error message above. Then, with the terminal in this location, find the relative path to the directory containing the gtest.framework. That is the value you'll need to set as the DYLD\_FRAMEWORK\_PATH.
+
+# Build and Go #
+
+Now, when you click "Build and Go", the test will be executed. Dumping out something like this:
+
+```
+[Session started at 2008-08-06 06:36:13 -0600.]
+[==========] Running 2 tests from 1 test case.
+[----------] Global test environment set-up.
+[----------] 2 tests from WidgetInitializerTest
+[ RUN      ] WidgetInitializerTest.TestConstructor
+[       OK ] WidgetInitializerTest.TestConstructor
+[ RUN      ] WidgetInitializerTest.TestConversion
+[       OK ] WidgetInitializerTest.TestConversion
+[----------] Global test environment tear-down
+[==========] 2 tests from 1 test case ran.
+[  PASSED  ] 2 tests.
+
+The Debugger has exited with status 0.  
+```
+
+# Summary #
+
+Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_AdvancedGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_AdvancedGuide.md
new file mode 100644
index 00000000..78864b16
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_AdvancedGuide.md
@@ -0,0 +1,2178 @@
+
+
+Now that you have read [Primer](V1_6_Primer.md) and learned how to write tests
+using Google Test, it's time to learn some new tricks. This document
+will show you more assertions as well as how to construct complex
+failure messages, propagate fatal failures, reuse and speed up your
+test fixtures, and use various flags with your tests.
+
+# More Assertions #
+
+This section covers some less frequently used, but still significant,
+assertions.
+
+## Explicit Success and Failure ##
+
+These three assertions do not actually test a value or expression. Instead,
+they generate a success or failure directly. Like the macros that actually
+perform a test, you may stream a custom failure message into the them.
+
+| `SUCCEED();` |
+|:-------------|
+
+Generates a success. This does NOT make the overall test succeed. A test is
+considered successful only if none of its assertions fail during its execution.
+
+Note: `SUCCEED()` is purely documentary and currently doesn't generate any
+user-visible output. However, we may add `SUCCEED()` messages to Google Test's
+output in the future.
+
+| `FAIL();`  | `ADD_FAILURE();` | `ADD_FAILURE_AT("`_file\_path_`", `_line\_number_`);` |
+|:-----------|:-----------------|:------------------------------------------------------|
+
+`FAIL()` generates a fatal failure, while `ADD_FAILURE()` and `ADD_FAILURE_AT()` generate a nonfatal
+failure. These are useful when control flow, rather than a Boolean expression,
+deteremines the test's success or failure. For example, you might want to write
+something like:
+
+```
+switch(expression) {
+  case 1: ... some checks ...
+  case 2: ... some other checks
+  ...
+  default: FAIL() << "We shouldn't get here.";
+}
+```
+
+_Availability_: Linux, Windows, Mac.
+
+## Exception Assertions ##
+
+These are for verifying that a piece of code throws (or does not
+throw) an exception of the given type:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_THROW(`_statement_, _exception\_type_`);`  | `EXPECT_THROW(`_statement_, _exception\_type_`);`  | _statement_ throws an exception of the given type  |
+| `ASSERT_ANY_THROW(`_statement_`);`                | `EXPECT_ANY_THROW(`_statement_`);`                | _statement_ throws an exception of any type        |
+| `ASSERT_NO_THROW(`_statement_`);`                 | `EXPECT_NO_THROW(`_statement_`);`                 | _statement_ doesn't throw any exception            |
+
+Examples:
+
+```
+ASSERT_THROW(Foo(5), bar_exception);
+
+EXPECT_NO_THROW({
+  int n = 5;
+  Bar(&n);
+});
+```
+
+_Availability_: Linux, Windows, Mac; since version 1.1.0.
+
+## Predicate Assertions for Better Error Messages ##
+
+Even though Google Test has a rich set of assertions, they can never be
+complete, as it's impossible (nor a good idea) to anticipate all the scenarios
+a user might run into. Therefore, sometimes a user has to use `EXPECT_TRUE()`
+to check a complex expression, for lack of a better macro. This has the problem
+of not showing you the values of the parts of the expression, making it hard to
+understand what went wrong. As a workaround, some users choose to construct the
+failure message by themselves, streaming it into `EXPECT_TRUE()`. However, this
+is awkward especially when the expression has side-effects or is expensive to
+evaluate.
+
+Google Test gives you three different options to solve this problem:
+
+### Using an Existing Boolean Function ###
+
+If you already have a function or a functor that returns `bool` (or a type
+that can be implicitly converted to `bool`), you can use it in a _predicate
+assertion_ to get the function arguments printed for free:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_PRED1(`_pred1, val1_`);`       | `EXPECT_PRED1(`_pred1, val1_`);` | _pred1(val1)_ returns true |
+| `ASSERT_PRED2(`_pred2, val1, val2_`);` | `EXPECT_PRED2(`_pred2, val1, val2_`);` |  _pred2(val1, val2)_ returns true |
+|  ...                | ...                    | ...          |
+
+In the above, _predn_ is an _n_-ary predicate function or functor, where
+_val1_, _val2_, ..., and _valn_ are its arguments. The assertion succeeds
+if the predicate returns `true` when applied to the given arguments, and fails
+otherwise. When the assertion fails, it prints the value of each argument. In
+either case, the arguments are evaluated exactly once.
+
+Here's an example. Given
+
+```
+// Returns true iff m and n have no common divisors except 1.
+bool MutuallyPrime(int m, int n) { ... }
+const int a = 3;
+const int b = 4;
+const int c = 10;
+```
+
+the assertion `EXPECT_PRED2(MutuallyPrime, a, b);` will succeed, while the
+assertion `EXPECT_PRED2(MutuallyPrime, b, c);` will fail with the message
+
+<pre>
+!MutuallyPrime(b, c) is false, where<br>
+b is 4<br>
+c is 10<br>
+</pre>
+
+**Notes:**
+
+  1. If you see a compiler error "no matching function to call" when using `ASSERT_PRED*` or `EXPECT_PRED*`, please see [this](v1_6_FAQ.md#ithe-compiler-complains-about-undefined-references-to-some-static-const-member-variables-but-i-did-define-them-in-the-class-body-whats-wrong) for how to resolve it.
+  1. Currently we only provide predicate assertions of arity <= 5. If you need a higher-arity assertion, let us know.
+
+_Availability_: Linux, Windows, Mac
+
+### Using a Function That Returns an AssertionResult ###
+
+While `EXPECT_PRED*()` and friends are handy for a quick job, the
+syntax is not satisfactory: you have to use different macros for
+different arities, and it feels more like Lisp than C++.  The
+`::testing::AssertionResult` class solves this problem.
+
+An `AssertionResult` object represents the result of an assertion
+(whether it's a success or a failure, and an associated message).  You
+can create an `AssertionResult` using one of these factory
+functions:
+
+```
+namespace testing {
+
+// Returns an AssertionResult object to indicate that an assertion has
+// succeeded.
+AssertionResult AssertionSuccess();
+
+// Returns an AssertionResult object to indicate that an assertion has
+// failed.
+AssertionResult AssertionFailure();
+
+}
+```
+
+You can then use the `<<` operator to stream messages to the
+`AssertionResult` object.
+
+To provide more readable messages in Boolean assertions
+(e.g. `EXPECT_TRUE()`), write a predicate function that returns
+`AssertionResult` instead of `bool`. For example, if you define
+`IsEven()` as:
+
+```
+::testing::AssertionResult IsEven(int n) {
+  if ((n % 2) == 0)
+    return ::testing::AssertionSuccess();
+  else
+    return ::testing::AssertionFailure() << n << " is odd";
+}
+```
+
+instead of:
+
+```
+bool IsEven(int n) {
+  return (n % 2) == 0;
+}
+```
+
+the failed assertion `EXPECT_TRUE(IsEven(Fib(4)))` will print:
+
+<pre>
+Value of: !IsEven(Fib(4))<br>
+Actual: false (*3 is odd*)<br>
+Expected: true<br>
+</pre>
+
+instead of a more opaque
+
+<pre>
+Value of: !IsEven(Fib(4))<br>
+Actual: false<br>
+Expected: true<br>
+</pre>
+
+If you want informative messages in `EXPECT_FALSE` and `ASSERT_FALSE`
+as well, and are fine with making the predicate slower in the success
+case, you can supply a success message:
+
+```
+::testing::AssertionResult IsEven(int n) {
+  if ((n % 2) == 0)
+    return ::testing::AssertionSuccess() << n << " is even";
+  else
+    return ::testing::AssertionFailure() << n << " is odd";
+}
+```
+
+Then the statement `EXPECT_FALSE(IsEven(Fib(6)))` will print
+
+<pre>
+Value of: !IsEven(Fib(6))<br>
+Actual: true (8 is even)<br>
+Expected: false<br>
+</pre>
+
+_Availability_: Linux, Windows, Mac; since version 1.4.1.
+
+### Using a Predicate-Formatter ###
+
+If you find the default message generated by `(ASSERT|EXPECT)_PRED*` and
+`(ASSERT|EXPECT)_(TRUE|FALSE)` unsatisfactory, or some arguments to your
+predicate do not support streaming to `ostream`, you can instead use the
+following _predicate-formatter assertions_ to _fully_ customize how the
+message is formatted:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_PRED_FORMAT1(`_pred\_format1, val1_`);`        | `EXPECT_PRED_FORMAT1(`_pred\_format1, val1_`); | _pred\_format1(val1)_ is successful |
+| `ASSERT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | `EXPECT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | _pred\_format2(val1, val2)_ is successful |
+| `...`               | `...`                  | `...`        |
+
+The difference between this and the previous two groups of macros is that instead of
+a predicate, `(ASSERT|EXPECT)_PRED_FORMAT*` take a _predicate-formatter_
+(_pred\_formatn_), which is a function or functor with the signature:
+
+`::testing::AssertionResult PredicateFormattern(const char* `_expr1_`, const char* `_expr2_`, ... const char* `_exprn_`, T1 `_val1_`, T2 `_val2_`, ... Tn `_valn_`);`
+
+where _val1_, _val2_, ..., and _valn_ are the values of the predicate
+arguments, and _expr1_, _expr2_, ..., and _exprn_ are the corresponding
+expressions as they appear in the source code. The types `T1`, `T2`, ..., and
+`Tn` can be either value types or reference types. For example, if an
+argument has type `Foo`, you can declare it as either `Foo` or `const Foo&`,
+whichever is appropriate.
+
+A predicate-formatter returns a `::testing::AssertionResult` object to indicate
+whether the assertion has succeeded or not. The only way to create such an
+object is to call one of these factory functions:
+
+As an example, let's improve the failure message in the previous example, which uses `EXPECT_PRED2()`:
+
+```
+// Returns the smallest prime common divisor of m and n,
+// or 1 when m and n are mutually prime.
+int SmallestPrimeCommonDivisor(int m, int n) { ... }
+
+// A predicate-formatter for asserting that two integers are mutually prime.
+::testing::AssertionResult AssertMutuallyPrime(const char* m_expr,
+                                               const char* n_expr,
+                                               int m,
+                                               int n) {
+  if (MutuallyPrime(m, n))
+    return ::testing::AssertionSuccess();
+
+  return ::testing::AssertionFailure()
+      << m_expr << " and " << n_expr << " (" << m << " and " << n
+      << ") are not mutually prime, " << "as they have a common divisor "
+      << SmallestPrimeCommonDivisor(m, n);
+}
+```
+
+With this predicate-formatter, we can use
+
+```
+EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c);
+```
+
+to generate the message
+
+<pre>
+b and c (4 and 10) are not mutually prime, as they have a common divisor 2.<br>
+</pre>
+
+As you may have realized, many of the assertions we introduced earlier are
+special cases of `(EXPECT|ASSERT)_PRED_FORMAT*`. In fact, most of them are
+indeed defined using `(EXPECT|ASSERT)_PRED_FORMAT*`.
+
+_Availability_: Linux, Windows, Mac.
+
+
+## Floating-Point Comparison ##
+
+Comparing floating-point numbers is tricky. Due to round-off errors, it is
+very unlikely that two floating-points will match exactly. Therefore,
+`ASSERT_EQ` 's naive comparison usually doesn't work. And since floating-points
+can have a wide value range, no single fixed error bound works. It's better to
+compare by a fixed relative error bound, except for values close to 0 due to
+the loss of precision there.
+
+In general, for floating-point comparison to make sense, the user needs to
+carefully choose the error bound. If they don't want or care to, comparing in
+terms of Units in the Last Place (ULPs) is a good default, and Google Test
+provides assertions to do this. Full details about ULPs are quite long; if you
+want to learn more, see
+[this article on float comparison](http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm).
+
+### Floating-Point Macros ###
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_FLOAT_EQ(`_expected, actual_`);`  | `EXPECT_FLOAT_EQ(`_expected, actual_`);` | the two `float` values are almost equal |
+| `ASSERT_DOUBLE_EQ(`_expected, actual_`);` | `EXPECT_DOUBLE_EQ(`_expected, actual_`);` | the two `double` values are almost equal |
+
+By "almost equal", we mean the two values are within 4 ULP's from each
+other.
+
+The following assertions allow you to choose the acceptable error bound:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_NEAR(`_val1, val2, abs\_error_`);` | `EXPECT_NEAR`_(val1, val2, abs\_error_`);` | the difference between _val1_ and _val2_ doesn't exceed the given absolute error |
+
+_Availability_: Linux, Windows, Mac.
+
+### Floating-Point Predicate-Format Functions ###
+
+Some floating-point operations are useful, but not that often used. In order
+to avoid an explosion of new macros, we provide them as predicate-format
+functions that can be used in predicate assertion macros (e.g.
+`EXPECT_PRED_FORMAT2`, etc).
+
+```
+EXPECT_PRED_FORMAT2(::testing::FloatLE, val1, val2);
+EXPECT_PRED_FORMAT2(::testing::DoubleLE, val1, val2);
+```
+
+Verifies that _val1_ is less than, or almost equal to, _val2_. You can
+replace `EXPECT_PRED_FORMAT2` in the above table with `ASSERT_PRED_FORMAT2`.
+
+_Availability_: Linux, Windows, Mac.
+
+## Windows HRESULT assertions ##
+
+These assertions test for `HRESULT` success or failure.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_HRESULT_SUCCEEDED(`_expression_`);` | `EXPECT_HRESULT_SUCCEEDED(`_expression_`);` | _expression_ is a success `HRESULT` |
+| `ASSERT_HRESULT_FAILED(`_expression_`);`    | `EXPECT_HRESULT_FAILED(`_expression_`);`    | _expression_ is a failure `HRESULT` |
+
+The generated output contains the human-readable error message
+associated with the `HRESULT` code returned by _expression_.
+
+You might use them like this:
+
+```
+CComPtr shell;
+ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application"));
+CComVariant empty;
+ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty));
+```
+
+_Availability_: Windows.
+
+## Type Assertions ##
+
+You can call the function
+```
+::testing::StaticAssertTypeEq<T1, T2>();
+```
+to assert that types `T1` and `T2` are the same.  The function does
+nothing if the assertion is satisfied.  If the types are different,
+the function call will fail to compile, and the compiler error message
+will likely (depending on the compiler) show you the actual values of
+`T1` and `T2`.  This is mainly useful inside template code.
+
+_Caveat:_ When used inside a member function of a class template or a
+function template, `StaticAssertTypeEq<T1, T2>()` is effective _only if_
+the function is instantiated.  For example, given:
+```
+template <typename T> class Foo {
+ public:
+  void Bar() { ::testing::StaticAssertTypeEq<int, T>(); }
+};
+```
+the code:
+```
+void Test1() { Foo<bool> foo; }
+```
+will _not_ generate a compiler error, as `Foo<bool>::Bar()` is never
+actually instantiated.  Instead, you need:
+```
+void Test2() { Foo<bool> foo; foo.Bar(); }
+```
+to cause a compiler error.
+
+_Availability:_ Linux, Windows, Mac; since version 1.3.0.
+
+## Assertion Placement ##
+
+You can use assertions in any C++ function. In particular, it doesn't
+have to be a method of the test fixture class. The one constraint is
+that assertions that generate a fatal failure (`FAIL*` and `ASSERT_*`)
+can only be used in void-returning functions. This is a consequence of
+Google Test not using exceptions. By placing it in a non-void function
+you'll get a confusing compile error like
+`"error: void value not ignored as it ought to be"`.
+
+If you need to use assertions in a function that returns non-void, one option
+is to make the function return the value in an out parameter instead. For
+example, you can rewrite `T2 Foo(T1 x)` to `void Foo(T1 x, T2* result)`. You
+need to make sure that `*result` contains some sensible value even when the
+function returns prematurely. As the function now returns `void`, you can use
+any assertion inside of it.
+
+If changing the function's type is not an option, you should just use
+assertions that generate non-fatal failures, such as `ADD_FAILURE*` and
+`EXPECT_*`.
+
+_Note_: Constructors and destructors are not considered void-returning
+functions, according to the C++ language specification, and so you may not use
+fatal assertions in them. You'll get a compilation error if you try. A simple
+workaround is to transfer the entire body of the constructor or destructor to a
+private void-returning method. However, you should be aware that a fatal
+assertion failure in a constructor does not terminate the current test, as your
+intuition might suggest; it merely returns from the constructor early, possibly
+leaving your object in a partially-constructed state. Likewise, a fatal
+assertion failure in a destructor may leave your object in a
+partially-destructed state. Use assertions carefully in these situations!
+
+# Teaching Google Test How to Print Your Values #
+
+When a test assertion such as `EXPECT_EQ` fails, Google Test prints the
+argument values to help you debug.  It does this using a
+user-extensible value printer.
+
+This printer knows how to print built-in C++ types, native arrays, STL
+containers, and any type that supports the `<<` operator.  For other
+types, it prints the raw bytes in the value and hopes that you the
+user can figure it out.
+
+As mentioned earlier, the printer is _extensible_.  That means
+you can teach it to do a better job at printing your particular type
+than to dump the bytes.  To do that, define `<<` for your type:
+
+```
+#include <iostream>
+
+namespace foo {
+
+class Bar { ... };  // We want Google Test to be able to print instances of this.
+
+// It's important that the << operator is defined in the SAME
+// namespace that defines Bar.  C++'s look-up rules rely on that.
+::std::ostream& operator<<(::std::ostream& os, const Bar& bar) {
+  return os << bar.DebugString();  // whatever needed to print bar to os
+}
+
+}  // namespace foo
+```
+
+Sometimes, this might not be an option: your team may consider it bad
+style to have a `<<` operator for `Bar`, or `Bar` may already have a
+`<<` operator that doesn't do what you want (and you cannot change
+it).  If so, you can instead define a `PrintTo()` function like this:
+
+```
+#include <iostream>
+
+namespace foo {
+
+class Bar { ... };
+
+// It's important that PrintTo() is defined in the SAME
+// namespace that defines Bar.  C++'s look-up rules rely on that.
+void PrintTo(const Bar& bar, ::std::ostream* os) {
+  *os << bar.DebugString();  // whatever needed to print bar to os
+}
+
+}  // namespace foo
+```
+
+If you have defined both `<<` and `PrintTo()`, the latter will be used
+when Google Test is concerned.  This allows you to customize how the value
+appears in Google Test's output without affecting code that relies on the
+behavior of its `<<` operator.
+
+If you want to print a value `x` using Google Test's value printer
+yourself, just call `::testing::PrintToString(`_x_`)`, which
+returns an `std::string`:
+
+```
+vector<pair<Bar, int> > bar_ints = GetBarIntVector();
+
+EXPECT_TRUE(IsCorrectBarIntVector(bar_ints))
+    << "bar_ints = " << ::testing::PrintToString(bar_ints);
+```
+
+# Death Tests #
+
+In many applications, there are assertions that can cause application failure
+if a condition is not met. These sanity checks, which ensure that the program
+is in a known good state, are there to fail at the earliest possible time after
+some program state is corrupted. If the assertion checks the wrong condition,
+then the program may proceed in an erroneous state, which could lead to memory
+corruption, security holes, or worse. Hence it is vitally important to test
+that such assertion statements work as expected.
+
+Since these precondition checks cause the processes to die, we call such tests
+_death tests_. More generally, any test that checks that a program terminates
+(except by throwing an exception) in an expected fashion is also a death test.
+
+Note that if a piece of code throws an exception, we don't consider it "death"
+for the purpose of death tests, as the caller of the code could catch the exception
+and avoid the crash. If you want to verify exceptions thrown by your code,
+see [Exception Assertions](#exception-assertions).
+
+If you want to test `EXPECT_*()/ASSERT_*()` failures in your test code, see [Catching Failures](#catching-failures).
+
+## How to Write a Death Test ##
+
+Google Test has the following macros to support death tests:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_DEATH(`_statement, regex_`); | `EXPECT_DEATH(`_statement, regex_`); | _statement_ crashes with the given error |
+| `ASSERT_DEATH_IF_SUPPORTED(`_statement, regex_`); | `EXPECT_DEATH_IF_SUPPORTED(`_statement, regex_`); | if death tests are supported, verifies that _statement_ crashes with the given error; otherwise verifies nothing |
+| `ASSERT_EXIT(`_statement, predicate, regex_`); | `EXPECT_EXIT(`_statement, predicate, regex_`); |_statement_ exits with the given error and its exit code matches _predicate_ |
+
+where _statement_ is a statement that is expected to cause the process to
+die, _predicate_ is a function or function object that evaluates an integer
+exit status, and _regex_ is a regular expression that the stderr output of
+_statement_ is expected to match. Note that _statement_ can be _any valid
+statement_ (including _compound statement_) and doesn't have to be an
+expression.
+
+As usual, the `ASSERT` variants abort the current test function, while the
+`EXPECT` variants do not.
+
+**Note:** We use the word "crash" here to mean that the process
+terminates with a _non-zero_ exit status code.  There are two
+possibilities: either the process has called `exit()` or `_exit()`
+with a non-zero value, or it may be killed by a signal.
+
+This means that if _statement_ terminates the process with a 0 exit
+code, it is _not_ considered a crash by `EXPECT_DEATH`.  Use
+`EXPECT_EXIT` instead if this is the case, or if you want to restrict
+the exit code more precisely.
+
+A predicate here must accept an `int` and return a `bool`. The death test
+succeeds only if the predicate returns `true`. Google Test defines a few
+predicates that handle the most common cases:
+
+```
+::testing::ExitedWithCode(exit_code)
+```
+
+This expression is `true` if the program exited normally with the given exit
+code.
+
+```
+::testing::KilledBySignal(signal_number)  // Not available on Windows.
+```
+
+This expression is `true` if the program was killed by the given signal.
+
+The `*_DEATH` macros are convenient wrappers for `*_EXIT` that use a predicate
+that verifies the process' exit code is non-zero.
+
+Note that a death test only cares about three things:
+
+  1. does _statement_ abort or exit the process?
+  1. (in the case of `ASSERT_EXIT` and `EXPECT_EXIT`) does the exit status satisfy _predicate_?  Or (in the case of `ASSERT_DEATH` and `EXPECT_DEATH`) is the exit status non-zero?  And
+  1. does the stderr output match _regex_?
+
+In particular, if _statement_ generates an `ASSERT_*` or `EXPECT_*` failure, it will **not** cause the death test to fail, as Google Test assertions don't abort the process.
+
+To write a death test, simply use one of the above macros inside your test
+function. For example,
+
+```
+TEST(My*DeathTest*, Foo) {
+  // This death test uses a compound statement.
+  ASSERT_DEATH({ int n = 5; Foo(&n); }, "Error on line .* of Foo()");
+}
+TEST(MyDeathTest, NormalExit) {
+  EXPECT_EXIT(NormalExit(), ::testing::ExitedWithCode(0), "Success");
+}
+TEST(MyDeathTest, KillMyself) {
+  EXPECT_EXIT(KillMyself(), ::testing::KilledBySignal(SIGKILL), "Sending myself unblockable signal");
+}
+```
+
+verifies that:
+
+  * calling `Foo(5)` causes the process to die with the given error message,
+  * calling `NormalExit()` causes the process to print `"Success"` to stderr and exit with exit code 0, and
+  * calling `KillMyself()` kills the process with signal `SIGKILL`.
+
+The test function body may contain other assertions and statements as well, if
+necessary.
+
+_Important:_ We strongly recommend you to follow the convention of naming your
+test case (not test) `*DeathTest` when it contains a death test, as
+demonstrated in the above example. The `Death Tests And Threads` section below
+explains why.
+
+If a test fixture class is shared by normal tests and death tests, you
+can use typedef to introduce an alias for the fixture class and avoid
+duplicating its code:
+```
+class FooTest : public ::testing::Test { ... };
+
+typedef FooTest FooDeathTest;
+
+TEST_F(FooTest, DoesThis) {
+  // normal test
+}
+
+TEST_F(FooDeathTest, DoesThat) {
+  // death test
+}
+```
+
+_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Cygwin, and Mac (the latter three are supported since v1.3.0).  `(ASSERT|EXPECT)_DEATH_IF_SUPPORTED` are new in v1.4.0.
+
+## Regular Expression Syntax ##
+
+On POSIX systems (e.g. Linux, Cygwin, and Mac), Google Test uses the
+[POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
+syntax in death tests. To learn about this syntax, you may want to read this [Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
+
+On Windows, Google Test uses its own simple regular expression
+implementation. It lacks many features you can find in POSIX extended
+regular expressions.  For example, we don't support union (`"x|y"`),
+grouping (`"(xy)"`), brackets (`"[xy]"`), and repetition count
+(`"x{5,7}"`), among others. Below is what we do support (`A` denotes a
+literal character, period (`.`), or a single `\\` escape sequence; `x`
+and `y` denote regular expressions.):
+
+| `c` | matches any literal character `c` |
+|:----|:----------------------------------|
+| `\\d` | matches any decimal digit         |
+| `\\D` | matches any character that's not a decimal digit |
+| `\\f` | matches `\f`                      |
+| `\\n` | matches `\n`                      |
+| `\\r` | matches `\r`                      |
+| `\\s` | matches any ASCII whitespace, including `\n` |
+| `\\S` | matches any character that's not a whitespace |
+| `\\t` | matches `\t`                      |
+| `\\v` | matches `\v`                      |
+| `\\w` | matches any letter, `_`, or decimal digit |
+| `\\W` | matches any character that `\\w` doesn't match |
+| `\\c` | matches any literal character `c`, which must be a punctuation |
+| `.` | matches any single character except `\n` |
+| `A?` | matches 0 or 1 occurrences of `A` |
+| `A*` | matches 0 or many occurrences of `A` |
+| `A+` | matches 1 or many occurrences of `A` |
+| `^` | matches the beginning of a string (not that of each line) |
+| `$` | matches the end of a string (not that of each line) |
+| `xy` | matches `x` followed by `y`       |
+
+To help you determine which capability is available on your system,
+Google Test defines macro `GTEST_USES_POSIX_RE=1` when it uses POSIX
+extended regular expressions, or `GTEST_USES_SIMPLE_RE=1` when it uses
+the simple version.  If you want your death tests to work in both
+cases, you can either `#if` on these macros or use the more limited
+syntax only.
+
+## How It Works ##
+
+Under the hood, `ASSERT_EXIT()` spawns a new process and executes the
+death test statement in that process. The details of of how precisely
+that happens depend on the platform and the variable
+`::testing::GTEST_FLAG(death_test_style)` (which is initialized from the
+command-line flag `--gtest_death_test_style`).
+
+  * On POSIX systems, `fork()` (or `clone()` on Linux) is used to spawn the child, after which:
+    * If the variable's value is `"fast"`, the death test statement is immediately executed.
+    * If the variable's value is `"threadsafe"`, the child process re-executes the unit test binary just as it was originally invoked, but with some extra flags to cause just the single death test under consideration to be run.
+  * On Windows, the child is spawned using the `CreateProcess()` API, and re-executes the binary to cause just the single death test under consideration to be run - much like the `threadsafe` mode on POSIX.
+
+Other values for the variable are illegal and will cause the death test to
+fail. Currently, the flag's default value is `"fast"`. However, we reserve the
+right to change it in the future. Therefore, your tests should not depend on
+this.
+
+In either case, the parent process waits for the child process to complete, and checks that
+
+  1. the child's exit status satisfies the predicate, and
+  1. the child's stderr matches the regular expression.
+
+If the death test statement runs to completion without dying, the child
+process will nonetheless terminate, and the assertion fails.
+
+## Death Tests And Threads ##
+
+The reason for the two death test styles has to do with thread safety. Due to
+well-known problems with forking in the presence of threads, death tests should
+be run in a single-threaded context. Sometimes, however, it isn't feasible to
+arrange that kind of environment. For example, statically-initialized modules
+may start threads before main is ever reached. Once threads have been created,
+it may be difficult or impossible to clean them up.
+
+Google Test has three features intended to raise awareness of threading issues.
+
+  1. A warning is emitted if multiple threads are running when a death test is encountered.
+  1. Test cases with a name ending in "DeathTest" are run before all other tests.
+  1. It uses `clone()` instead of `fork()` to spawn the child process on Linux (`clone()` is not available on Cygwin and Mac), as `fork()` is more likely to cause the child to hang when the parent process has multiple threads.
+
+It's perfectly fine to create threads inside a death test statement; they are
+executed in a separate process and cannot affect the parent.
+
+## Death Test Styles ##
+
+The "threadsafe" death test style was introduced in order to help mitigate the
+risks of testing in a possibly multithreaded environment. It trades increased
+test execution time (potentially dramatically so) for improved thread safety.
+We suggest using the faster, default "fast" style unless your test has specific
+problems with it.
+
+You can choose a particular style of death tests by setting the flag
+programmatically:
+
+```
+::testing::FLAGS_gtest_death_test_style = "threadsafe";
+```
+
+You can do this in `main()` to set the style for all death tests in the
+binary, or in individual tests. Recall that flags are saved before running each
+test and restored afterwards, so you need not do that yourself. For example:
+
+```
+TEST(MyDeathTest, TestOne) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+  // This test is run in the "threadsafe" style:
+  ASSERT_DEATH(ThisShouldDie(), "");
+}
+
+TEST(MyDeathTest, TestTwo) {
+  // This test is run in the "fast" style:
+  ASSERT_DEATH(ThisShouldDie(), "");
+}
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  ::testing::FLAGS_gtest_death_test_style = "fast";
+  return RUN_ALL_TESTS();
+}
+```
+
+## Caveats ##
+
+The _statement_ argument of `ASSERT_EXIT()` can be any valid C++ statement.
+If it leaves the current function via a `return` statement or by throwing an exception,
+the death test is considered to have failed.  Some Google Test macros may return
+from the current function (e.g. `ASSERT_TRUE()`), so be sure to avoid them in _statement_.
+
+Since _statement_ runs in the child process, any in-memory side effect (e.g.
+modifying a variable, releasing memory, etc) it causes will _not_ be observable
+in the parent process. In particular, if you release memory in a death test,
+your program will fail the heap check as the parent process will never see the
+memory reclaimed. To solve this problem, you can
+
+  1. try not to free memory in a death test;
+  1. free the memory again in the parent process; or
+  1. do not use the heap checker in your program.
+
+Due to an implementation detail, you cannot place multiple death test
+assertions on the same line; otherwise, compilation will fail with an unobvious
+error message.
+
+Despite the improved thread safety afforded by the "threadsafe" style of death
+test, thread problems such as deadlock are still possible in the presence of
+handlers registered with `pthread_atfork(3)`.
+
+# Using Assertions in Sub-routines #
+
+## Adding Traces to Assertions ##
+
+If a test sub-routine is called from several places, when an assertion
+inside it fails, it can be hard to tell which invocation of the
+sub-routine the failure is from.  You can alleviate this problem using
+extra logging or custom failure messages, but that usually clutters up
+your tests. A better solution is to use the `SCOPED_TRACE` macro:
+
+| `SCOPED_TRACE(`_message_`);` |
+|:-----------------------------|
+
+where _message_ can be anything streamable to `std::ostream`. This
+macro will cause the current file name, line number, and the given
+message to be added in every failure message. The effect will be
+undone when the control leaves the current lexical scope.
+
+For example,
+
+```
+10: void Sub1(int n) {
+11:   EXPECT_EQ(1, Bar(n));
+12:   EXPECT_EQ(2, Bar(n + 1));
+13: }
+14:
+15: TEST(FooTest, Bar) {
+16:   {
+17:     SCOPED_TRACE("A");  // This trace point will be included in
+18:                         // every failure in this scope.
+19:     Sub1(1);
+20:   }
+21:   // Now it won't.
+22:   Sub1(9);
+23: }
+```
+
+could result in messages like these:
+
+```
+path/to/foo_test.cc:11: Failure
+Value of: Bar(n)
+Expected: 1
+  Actual: 2
+   Trace:
+path/to/foo_test.cc:17: A
+
+path/to/foo_test.cc:12: Failure
+Value of: Bar(n + 1)
+Expected: 2
+  Actual: 3
+```
+
+Without the trace, it would've been difficult to know which invocation
+of `Sub1()` the two failures come from respectively. (You could add an
+extra message to each assertion in `Sub1()` to indicate the value of
+`n`, but that's tedious.)
+
+Some tips on using `SCOPED_TRACE`:
+
+  1. With a suitable message, it's often enough to use `SCOPED_TRACE` at the beginning of a sub-routine, instead of at each call site.
+  1. When calling sub-routines inside a loop, make the loop iterator part of the message in `SCOPED_TRACE` such that you can know which iteration the failure is from.
+  1. Sometimes the line number of the trace point is enough for identifying the particular invocation of a sub-routine. In this case, you don't have to choose a unique message for `SCOPED_TRACE`. You can simply use `""`.
+  1. You can use `SCOPED_TRACE` in an inner scope when there is one in the outer scope. In this case, all active trace points will be included in the failure messages, in reverse order they are encountered.
+  1. The trace dump is clickable in Emacs' compilation buffer - hit return on a line number and you'll be taken to that line in the source file!
+
+_Availability:_ Linux, Windows, Mac.
+
+## Propagating Fatal Failures ##
+
+A common pitfall when using `ASSERT_*` and `FAIL*` is not understanding that
+when they fail they only abort the _current function_, not the entire test. For
+example, the following test will segfault:
+```
+void Subroutine() {
+  // Generates a fatal failure and aborts the current function.
+  ASSERT_EQ(1, 2);
+  // The following won't be executed.
+  ...
+}
+
+TEST(FooTest, Bar) {
+  Subroutine();
+  // The intended behavior is for the fatal failure
+  // in Subroutine() to abort the entire test.
+  // The actual behavior: the function goes on after Subroutine() returns.
+  int* p = NULL;
+  *p = 3; // Segfault!
+}
+```
+
+Since we don't use exceptions, it is technically impossible to
+implement the intended behavior here.  To alleviate this, Google Test
+provides two solutions.  You could use either the
+`(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the
+`HasFatalFailure()` function.  They are described in the following two
+subsections.
+
+### Asserting on Subroutines ###
+
+As shown above, if your test calls a subroutine that has an `ASSERT_*`
+failure in it, the test will continue after the subroutine
+returns. This may not be what you want.
+
+Often people want fatal failures to propagate like exceptions.  For
+that Google Test offers the following macros:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_NO_FATAL_FAILURE(`_statement_`);` | `EXPECT_NO_FATAL_FAILURE(`_statement_`);` | _statement_ doesn't generate any new fatal failures in the current thread. |
+
+Only failures in the thread that executes the assertion are checked to
+determine the result of this type of assertions.  If _statement_
+creates new threads, failures in these threads are ignored.
+
+Examples:
+
+```
+ASSERT_NO_FATAL_FAILURE(Foo());
+
+int i;
+EXPECT_NO_FATAL_FAILURE({
+  i = Bar();
+});
+```
+
+_Availability:_ Linux, Windows, Mac. Assertions from multiple threads
+are currently not supported.
+
+### Checking for Failures in the Current Test ###
+
+`HasFatalFailure()` in the `::testing::Test` class returns `true` if an
+assertion in the current test has suffered a fatal failure. This
+allows functions to catch fatal failures in a sub-routine and return
+early.
+
+```
+class Test {
+ public:
+  ...
+  static bool HasFatalFailure();
+};
+```
+
+The typical usage, which basically simulates the behavior of a thrown
+exception, is:
+
+```
+TEST(FooTest, Bar) {
+  Subroutine();
+  // Aborts if Subroutine() had a fatal failure.
+  if (HasFatalFailure())
+    return;
+  // The following won't be executed.
+  ...
+}
+```
+
+If `HasFatalFailure()` is used outside of `TEST()` , `TEST_F()` , or a test
+fixture, you must add the `::testing::Test::` prefix, as in:
+
+```
+if (::testing::Test::HasFatalFailure())
+  return;
+```
+
+Similarly, `HasNonfatalFailure()` returns `true` if the current test
+has at least one non-fatal failure, and `HasFailure()` returns `true`
+if the current test has at least one failure of either kind.
+
+_Availability:_ Linux, Windows, Mac.  `HasNonfatalFailure()` and
+`HasFailure()` are available since version 1.4.0.
+
+# Logging Additional Information #
+
+In your test code, you can call `RecordProperty("key", value)` to log
+additional information, where `value` can be either a C string or a 32-bit
+integer. The _last_ value recorded for a key will be emitted to the XML output
+if you specify one. For example, the test
+
+```
+TEST_F(WidgetUsageTest, MinAndMaxWidgets) {
+  RecordProperty("MaximumWidgets", ComputeMaxUsage());
+  RecordProperty("MinimumWidgets", ComputeMinUsage());
+}
+```
+
+will output XML like this:
+
+```
+...
+  <testcase name="MinAndMaxWidgets" status="run" time="6" classname="WidgetUsageTest"
+            MaximumWidgets="12"
+            MinimumWidgets="9" />
+...
+```
+
+_Note_:
+  * `RecordProperty()` is a static member of the `Test` class. Therefore it needs to be prefixed with `::testing::Test::` if used outside of the `TEST` body and the test fixture class.
+  * `key` must be a valid XML attribute name, and cannot conflict with the ones already used by Google Test (`name`, `status`,     `time`, and `classname`).
+
+_Availability_: Linux, Windows, Mac.
+
+# Sharing Resources Between Tests in the Same Test Case #
+
+
+
+Google Test creates a new test fixture object for each test in order to make
+tests independent and easier to debug. However, sometimes tests use resources
+that are expensive to set up, making the one-copy-per-test model prohibitively
+expensive.
+
+If the tests don't change the resource, there's no harm in them sharing a
+single resource copy. So, in addition to per-test set-up/tear-down, Google Test
+also supports per-test-case set-up/tear-down. To use it:
+
+  1. In your test fixture class (say `FooTest` ), define as `static` some member variables to hold the shared resources.
+  1. In the same test fixture class, define a `static void SetUpTestCase()` function (remember not to spell it as **`SetupTestCase`** with a small `u`!) to set up the shared resources and a `static void TearDownTestCase()` function to tear them down.
+
+That's it! Google Test automatically calls `SetUpTestCase()` before running the
+_first test_ in the `FooTest` test case (i.e. before creating the first
+`FooTest` object), and calls `TearDownTestCase()` after running the _last test_
+in it (i.e. after deleting the last `FooTest` object). In between, the tests
+can use the shared resources.
+
+Remember that the test order is undefined, so your code can't depend on a test
+preceding or following another. Also, the tests must either not modify the
+state of any shared resource, or, if they do modify the state, they must
+restore the state to its original value before passing control to the next
+test.
+
+Here's an example of per-test-case set-up and tear-down:
+```
+class FooTest : public ::testing::Test {
+ protected:
+  // Per-test-case set-up.
+  // Called before the first test in this test case.
+  // Can be omitted if not needed.
+  static void SetUpTestCase() {
+    shared_resource_ = new ...;
+  }
+
+  // Per-test-case tear-down.
+  // Called after the last test in this test case.
+  // Can be omitted if not needed.
+  static void TearDownTestCase() {
+    delete shared_resource_;
+    shared_resource_ = NULL;
+  }
+
+  // You can define per-test set-up and tear-down logic as usual.
+  virtual void SetUp() { ... }
+  virtual void TearDown() { ... }
+
+  // Some expensive resource shared by all tests.
+  static T* shared_resource_;
+};
+
+T* FooTest::shared_resource_ = NULL;
+
+TEST_F(FooTest, Test1) {
+  ... you can refer to shared_resource here ...
+}
+TEST_F(FooTest, Test2) {
+  ... you can refer to shared_resource here ...
+}
+```
+
+_Availability:_ Linux, Windows, Mac.
+
+# Global Set-Up and Tear-Down #
+
+Just as you can do set-up and tear-down at the test level and the test case
+level, you can also do it at the test program level. Here's how.
+
+First, you subclass the `::testing::Environment` class to define a test
+environment, which knows how to set-up and tear-down:
+
+```
+class Environment {
+ public:
+  virtual ~Environment() {}
+  // Override this to define how to set up the environment.
+  virtual void SetUp() {}
+  // Override this to define how to tear down the environment.
+  virtual void TearDown() {}
+};
+```
+
+Then, you register an instance of your environment class with Google Test by
+calling the `::testing::AddGlobalTestEnvironment()` function:
+
+```
+Environment* AddGlobalTestEnvironment(Environment* env);
+```
+
+Now, when `RUN_ALL_TESTS()` is called, it first calls the `SetUp()` method of
+the environment object, then runs the tests if there was no fatal failures, and
+finally calls `TearDown()` of the environment object.
+
+It's OK to register multiple environment objects. In this case, their `SetUp()`
+will be called in the order they are registered, and their `TearDown()` will be
+called in the reverse order.
+
+Note that Google Test takes ownership of the registered environment objects.
+Therefore **do not delete them** by yourself.
+
+You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is
+called, probably in `main()`. If you use `gtest_main`, you need to      call
+this before `main()` starts for it to take effect. One way to do this is to
+define a global variable like this:
+
+```
+::testing::Environment* const foo_env = ::testing::AddGlobalTestEnvironment(new FooEnvironment);
+```
+
+However, we strongly recommend you to write your own `main()` and call
+`AddGlobalTestEnvironment()` there, as relying on initialization of global
+variables makes the code harder to read and may cause problems when you
+register multiple environments from different translation units and the
+environments have dependencies among them (remember that the compiler doesn't
+guarantee the order in which global variables from different translation units
+are initialized).
+
+_Availability:_ Linux, Windows, Mac.
+
+
+# Value Parameterized Tests #
+
+_Value-parameterized tests_ allow you to test your code with different
+parameters without writing multiple copies of the same test.
+
+Suppose you write a test for your code and then realize that your code is affected by a presence of a Boolean command line flag.
+
+```
+TEST(MyCodeTest, TestFoo) {
+  // A code to test foo().
+}
+```
+
+Usually people factor their test code into a function with a Boolean parameter in such situations. The function sets the flag, then executes the testing code.
+
+```
+void TestFooHelper(bool flag_value) {
+  flag = flag_value;
+  // A code to test foo().
+}
+
+TEST(MyCodeTest, TestFooo) {
+  TestFooHelper(false);
+  TestFooHelper(true);
+}
+```
+
+But this setup has serious drawbacks. First, when a test assertion fails in your tests, it becomes unclear what value of the parameter caused it to fail. You can stream a clarifying message into your `EXPECT`/`ASSERT` statements, but it you'll have to do it with all of them. Second, you have to add one such helper function per test. What if you have ten tests? Twenty? A hundred?
+
+Value-parameterized tests will let you write your test only once and then easily instantiate and run it with an arbitrary number of parameter values.
+
+Here are some other situations when value-parameterized tests come handy:
+
+  * You want to test different implementations of an OO interface.
+  * You want to test your code over various inputs (a.k.a. data-driven testing). This feature is easy to abuse, so please exercise your good sense when doing it!
+
+## How to Write Value-Parameterized Tests ##
+
+To write value-parameterized tests, first you should define a fixture
+class.  It must be derived from both `::testing::Test` and
+`::testing::WithParamInterface<T>` (the latter is a pure interface),
+where `T` is the type of your parameter values.  For convenience, you
+can just derive the fixture class from `::testing::TestWithParam<T>`,
+which itself is derived from both `::testing::Test` and
+`::testing::WithParamInterface<T>`. `T` can be any copyable type. If
+it's a raw pointer, you are responsible for managing the lifespan of
+the pointed values.
+
+```
+class FooTest : public ::testing::TestWithParam<const char*> {
+  // You can implement all the usual fixture class members here.
+  // To access the test parameter, call GetParam() from class
+  // TestWithParam<T>.
+};
+
+// Or, when you want to add parameters to a pre-existing fixture class:
+class BaseTest : public ::testing::Test {
+  ...
+};
+class BarTest : public BaseTest,
+                public ::testing::WithParamInterface<const char*> {
+  ...
+};
+```
+
+Then, use the `TEST_P` macro to define as many test patterns using
+this fixture as you want.  The `_P` suffix is for "parameterized" or
+"pattern", whichever you prefer to think.
+
+```
+TEST_P(FooTest, DoesBlah) {
+  // Inside a test, access the test parameter with the GetParam() method
+  // of the TestWithParam<T> class:
+  EXPECT_TRUE(foo.Blah(GetParam()));
+  ...
+}
+
+TEST_P(FooTest, HasBlahBlah) {
+  ...
+}
+```
+
+Finally, you can use `INSTANTIATE_TEST_CASE_P` to instantiate the test
+case with 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 are all in the `testing` namespace:
+
+| `Range(begin, end[, step])` | Yields values `{begin, begin+step, begin+step+step, ...}`. The values do not include `end`. `step` defaults to 1. |
+|:----------------------------|:------------------------------------------------------------------------------------------------------------------|
+| `Values(v1, v2, ..., vN)`   | Yields values `{v1, v2, ..., vN}`.                                                                                |
+| `ValuesIn(container)` and `ValuesIn(begin, end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)`. `container`, `begin`, and `end` can be expressions whose values are determined at run time.  |
+| `Bool()`                    | Yields sequence `{false, true}`.                                                                                  |
+| `Combine(g1, g2, ..., gN)`  | Yields all combinations (the Cartesian product for the math savvy) of the values generated by the `N` generators. This is only available if your system provides the `<tr1/tuple>` header. If you are sure your system does, and Google Test disagrees, you can override it by defining `GTEST_HAS_TR1_TUPLE=1`. See comments in [include/gtest/internal/gtest-port.h](../include/gtest/internal/gtest-port.h) for more information. |
+
+For more details, see the comments at the definitions of these functions in the [source code](../include/gtest/gtest-param-test.h).
+
+The following statement will instantiate tests from the `FooTest` test case
+each with parameter values `"meeny"`, `"miny"`, and `"moe"`.
+
+```
+INSTANTIATE_TEST_CASE_P(InstantiationName,
+                        FooTest,
+                        ::testing::Values("meeny", "miny", "moe"));
+```
+
+To distinguish different instances of the pattern (yes, you can
+instantiate it more than once), the first argument to
+`INSTANTIATE_TEST_CASE_P` is a prefix that will be added to the actual
+test case name. Remember to pick unique prefixes for different
+instantiations. The tests from the instantiation above will have these
+names:
+
+  * `InstantiationName/FooTest.DoesBlah/0` for `"meeny"`
+  * `InstantiationName/FooTest.DoesBlah/1` for `"miny"`
+  * `InstantiationName/FooTest.DoesBlah/2` for `"moe"`
+  * `InstantiationName/FooTest.HasBlahBlah/0` for `"meeny"`
+  * `InstantiationName/FooTest.HasBlahBlah/1` for `"miny"`
+  * `InstantiationName/FooTest.HasBlahBlah/2` for `"moe"`
+
+You can use these names in [--gtest\-filter](#running-a-subset-of-the-tests).
+
+This statement will instantiate all tests from `FooTest` again, each
+with parameter values `"cat"` and `"dog"`:
+
+```
+const char* pets[] = {"cat", "dog"};
+INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest,
+                        ::testing::ValuesIn(pets));
+```
+
+The tests from the instantiation above will have these names:
+
+  * `AnotherInstantiationName/FooTest.DoesBlah/0` for `"cat"`
+  * `AnotherInstantiationName/FooTest.DoesBlah/1` for `"dog"`
+  * `AnotherInstantiationName/FooTest.HasBlahBlah/0` for `"cat"`
+  * `AnotherInstantiationName/FooTest.HasBlahBlah/1` for `"dog"`
+
+Please note that `INSTANTIATE_TEST_CASE_P` will instantiate _all_
+tests in the given test case, whether their definitions come before or
+_after_ the `INSTANTIATE_TEST_CASE_P` statement.
+
+You can see
+[these](../samples/sample7_unittest.cc)
+[files](../samples/sample8_unittest.cc) for more examples.
+
+_Availability_: Linux, Windows (requires MSVC 8.0 or above), Mac; since version 1.2.0.
+
+## Creating Value-Parameterized Abstract Tests ##
+
+In the above, we define and instantiate `FooTest` in the same source
+file. Sometimes you may want to define value-parameterized tests in a
+library and let other people instantiate them later. This pattern is
+known as <i>abstract tests</i>. As an example of its application, when you
+are designing an interface you can write a standard suite of abstract
+tests (perhaps using a factory function as the test parameter) that
+all implementations of the interface are expected to pass. When
+someone implements the interface, he can instantiate your suite to get
+all the interface-conformance tests for free.
+
+To define abstract tests, you should organize your code like this:
+
+  1. Put the definition of the parameterized test fixture class (e.g. `FooTest`) in a header file, say `foo_param_test.h`. Think of this as _declaring_ your abstract tests.
+  1. Put the `TEST_P` definitions in `foo_param_test.cc`, which includes `foo_param_test.h`. Think of this as _implementing_ your abstract tests.
+
+Once they are defined, you can instantiate them by including
+`foo_param_test.h`, invoking `INSTANTIATE_TEST_CASE_P()`, and linking
+with `foo_param_test.cc`. You can instantiate the same abstract test
+case multiple times, possibly in different source files.
+
+# Typed Tests #
+
+Suppose you have multiple implementations of the same interface and
+want to make sure that all of them satisfy some common requirements.
+Or, you may have defined several types that are supposed to conform to
+the same "concept" and you want to verify it.  In both cases, you want
+the same test logic repeated for different types.
+
+While you can write one `TEST` or `TEST_F` for each type you want to
+test (and you may even factor the test logic into a function template
+that you invoke from the `TEST`), it's tedious and doesn't scale:
+if you want _m_ tests over _n_ types, you'll end up writing _m\*n_
+`TEST`s.
+
+_Typed tests_ allow you to repeat the same test logic over a list of
+types.  You only need to write the test logic once, although you must
+know the type list when writing typed tests.  Here's how you do it:
+
+First, define a fixture class template.  It should be parameterized
+by a type.  Remember to derive it from `::testing::Test`:
+
+```
+template <typename T>
+class FooTest : public ::testing::Test {
+ public:
+  ...
+  typedef std::list<T> List;
+  static T shared_;
+  T value_;
+};
+```
+
+Next, associate a list of types with the test case, which will be
+repeated for each type in the list:
+
+```
+typedef ::testing::Types<char, int, unsigned int> MyTypes;
+TYPED_TEST_CASE(FooTest, MyTypes);
+```
+
+The `typedef` is necessary for the `TYPED_TEST_CASE` macro to parse
+correctly.  Otherwise the compiler will think that each comma in the
+type list introduces a new macro argument.
+
+Then, use `TYPED_TEST()` instead of `TEST_F()` to define a typed test
+for this test case.  You can repeat this as many times as you want:
+
+```
+TYPED_TEST(FooTest, DoesBlah) {
+  // Inside a test, refer to the special name TypeParam to get the type
+  // parameter.  Since we are inside a derived class template, C++ requires
+  // us to visit the members of FooTest via 'this'.
+  TypeParam n = this->value_;
+
+  // To visit static members of the fixture, add the 'TestFixture::'
+  // prefix.
+  n += TestFixture::shared_;
+
+  // To refer to typedefs in the fixture, add the 'typename TestFixture::'
+  // prefix.  The 'typename' is required to satisfy the compiler.
+  typename TestFixture::List values;
+  values.push_back(n);
+  ...
+}
+
+TYPED_TEST(FooTest, HasPropertyA) { ... }
+```
+
+You can see `samples/sample6_unittest.cc` for a complete example.
+
+_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
+since version 1.1.0.
+
+# Type-Parameterized Tests #
+
+_Type-parameterized tests_ are like typed tests, except that they
+don't require you to know the list of types ahead of time.  Instead,
+you can define the test logic first and instantiate it with different
+type lists later.  You can even instantiate it more than once in the
+same program.
+
+If you are designing an interface or concept, you can define a suite
+of type-parameterized tests to verify properties that any valid
+implementation of the interface/concept should have.  Then, the author
+of each implementation can just instantiate the test suite with his
+type to verify that it conforms to the requirements, without having to
+write similar tests repeatedly.  Here's an example:
+
+First, define a fixture class template, as we did with typed tests:
+
+```
+template <typename T>
+class FooTest : public ::testing::Test {
+  ...
+};
+```
+
+Next, declare that you will define a type-parameterized test case:
+
+```
+TYPED_TEST_CASE_P(FooTest);
+```
+
+The `_P` suffix is for "parameterized" or "pattern", whichever you
+prefer to think.
+
+Then, use `TYPED_TEST_P()` to define a type-parameterized test.  You
+can repeat this as many times as you want:
+
+```
+TYPED_TEST_P(FooTest, DoesBlah) {
+  // Inside a test, refer to TypeParam to get the type parameter.
+  TypeParam n = 0;
+  ...
+}
+
+TYPED_TEST_P(FooTest, HasPropertyA) { ... }
+```
+
+Now the tricky part: you need to register all test patterns using the
+`REGISTER_TYPED_TEST_CASE_P` macro before you can instantiate them.
+The first argument of the macro is the test case name; the rest are
+the names of the tests in this test case:
+
+```
+REGISTER_TYPED_TEST_CASE_P(FooTest,
+                           DoesBlah, HasPropertyA);
+```
+
+Finally, you are free to instantiate the pattern with the types you
+want.  If you put the above code in a header file, you can `#include`
+it in multiple C++ source files and instantiate it multiple times.
+
+```
+typedef ::testing::Types<char, int, unsigned int> MyTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
+```
+
+To distinguish different instances of the pattern, the first argument
+to the `INSTANTIATE_TYPED_TEST_CASE_P` macro is a prefix that will be
+added to the actual test case name.  Remember to pick unique prefixes
+for different instances.
+
+In the special case where the type list contains only one type, you
+can write that type directly without `::testing::Types<...>`, like this:
+
+```
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
+```
+
+You can see `samples/sample6_unittest.cc` for a complete example.
+
+_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
+since version 1.1.0.
+
+# Testing Private Code #
+
+If you change your software's internal implementation, your tests should not
+break as long as the change is not observable by users. Therefore, per the
+_black-box testing principle_, most of the time you should test your code
+through its public interfaces.
+
+If you still find yourself needing to test internal implementation code,
+consider if there's a better design that wouldn't require you to do so. If you
+absolutely have to test non-public interface code though, you can. There are
+two cases to consider:
+
+  * Static functions (_not_ the same as static member functions!) or unnamed namespaces, and
+  * Private or protected class members
+
+## Static Functions ##
+
+Both static functions and definitions/declarations in an unnamed namespace are
+only visible within the same translation unit. To test them, you can `#include`
+the entire `.cc` file being tested in your `*_test.cc` file. (`#include`ing `.cc`
+files is not a good way to reuse code - you should not do this in production
+code!)
+
+However, a better approach is to move the private code into the
+`foo::internal` namespace, where `foo` is the namespace your project normally
+uses, and put the private declarations in a `*-internal.h` file. Your
+production `.cc` files and your tests are allowed to include this internal
+header, but your clients are not. This way, you can fully test your internal
+implementation without leaking it to your clients.
+
+## Private Class Members ##
+
+Private class members are only accessible from within the class or by friends.
+To access a class' private members, you can declare your test fixture as a
+friend to the class and define accessors in your fixture. Tests using the
+fixture can then access the private members of your production class via the
+accessors in the fixture. Note that even though your fixture is a friend to
+your production class, your tests are not automatically friends to it, as they
+are technically defined in sub-classes of the fixture.
+
+Another way to test private members is to refactor them into an implementation
+class, which is then declared in a `*-internal.h` file. Your clients aren't
+allowed to include this header but your tests can. Such is called the Pimpl
+(Private Implementation) idiom.
+
+Or, you can declare an individual test as a friend of your class by adding this
+line in the class body:
+
+```
+FRIEND_TEST(TestCaseName, TestName);
+```
+
+For example,
+```
+// foo.h
+#include "gtest/gtest_prod.h"
+
+// Defines FRIEND_TEST.
+class Foo {
+  ...
+ private:
+  FRIEND_TEST(FooTest, BarReturnsZeroOnNull);
+  int Bar(void* x);
+};
+
+// foo_test.cc
+...
+TEST(FooTest, BarReturnsZeroOnNull) {
+  Foo foo;
+  EXPECT_EQ(0, foo.Bar(NULL));
+  // Uses Foo's private member Bar().
+}
+```
+
+Pay special attention when your class is defined in a namespace, as you should
+define your test fixtures and tests in the same namespace if you want them to
+be friends of your class. For example, if the code to be tested looks like:
+
+```
+namespace my_namespace {
+
+class Foo {
+  friend class FooTest;
+  FRIEND_TEST(FooTest, Bar);
+  FRIEND_TEST(FooTest, Baz);
+  ...
+  definition of the class Foo
+  ...
+};
+
+}  // namespace my_namespace
+```
+
+Your test code should be something like:
+
+```
+namespace my_namespace {
+class FooTest : public ::testing::Test {
+ protected:
+  ...
+};
+
+TEST_F(FooTest, Bar) { ... }
+TEST_F(FooTest, Baz) { ... }
+
+}  // namespace my_namespace
+```
+
+# Catching Failures #
+
+If you are building a testing utility on top of Google Test, you'll
+want to test your utility.  What framework would you use to test it?
+Google Test, of course.
+
+The challenge is to verify that your testing utility reports failures
+correctly.  In frameworks that report a failure by throwing an
+exception, you could catch the exception and assert on it.  But Google
+Test doesn't use exceptions, so how do we test that a piece of code
+generates an expected failure?
+
+`"gtest/gtest-spi.h"` contains some constructs to do this.  After
+`#include`ing this header, you can use
+
+| `EXPECT_FATAL_FAILURE(`_statement, substring_`);` |
+|:--------------------------------------------------|
+
+to assert that _statement_ generates a fatal (e.g. `ASSERT_*`) failure
+whose message contains the given _substring_, or use
+
+| `EXPECT_NONFATAL_FAILURE(`_statement, substring_`);` |
+|:-----------------------------------------------------|
+
+if you are expecting a non-fatal (e.g. `EXPECT_*`) failure.
+
+For technical reasons, there are some caveats:
+
+  1. You cannot stream a failure message to either macro.
+  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot reference local non-static variables or non-static members of `this` object.
+  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot return a value.
+
+_Note:_ Google Test is designed with threads in mind.  Once the
+synchronization primitives in `"gtest/internal/gtest-port.h"` have
+been implemented, Google Test will become thread-safe, meaning that
+you can then use assertions in multiple threads concurrently.  Before
+
+that, however, Google Test only supports single-threaded usage.  Once
+thread-safe, `EXPECT_FATAL_FAILURE()` and `EXPECT_NONFATAL_FAILURE()`
+will capture failures in the current thread only. If _statement_
+creates new threads, failures in these threads will be ignored.  If
+you want to capture failures from all threads instead, you should use
+the following macros:
+
+| `EXPECT_FATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
+|:-----------------------------------------------------------------|
+| `EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
+
+# Getting the Current Test's Name #
+
+Sometimes a function may need to know the name of the currently running test.
+For example, you may be using the `SetUp()` method of your test fixture to set
+the golden file name based on which test is running. The `::testing::TestInfo`
+class has this information:
+
+```
+namespace testing {
+
+class TestInfo {
+ public:
+  // Returns the test case name and the test name, respectively.
+  //
+  // Do NOT delete or free the return value - it's managed by the
+  // TestInfo class.
+  const char* test_case_name() const;
+  const char* name() const;
+};
+
+}  // namespace testing
+```
+
+
+> To obtain a `TestInfo` object for the currently running test, call
+`current_test_info()` on the `UnitTest` singleton object:
+
+```
+// Gets information about the currently running test.
+// Do NOT delete the returned object - it's managed by the UnitTest class.
+const ::testing::TestInfo* const test_info =
+  ::testing::UnitTest::GetInstance()->current_test_info();
+printf("We are in test %s of test case %s.\n",
+       test_info->name(), test_info->test_case_name());
+```
+
+`current_test_info()` returns a null pointer if no test is running. In
+particular, you cannot find the test case name in `TestCaseSetUp()`,
+`TestCaseTearDown()` (where you know the test case name implicitly), or
+functions called from them.
+
+_Availability:_ Linux, Windows, Mac.
+
+# Extending Google Test by Handling Test Events #
+
+Google Test provides an <b>event listener API</b> to let you receive
+notifications about the progress of a test program and test
+failures. The events you can listen to include the start and end of
+the test program, a test case, or a test method, among others. You may
+use this API to augment or replace the standard console output,
+replace the XML output, or provide a completely different form of
+output, such as a GUI or a database. You can also use test events as
+checkpoints to implement a resource leak checker, for example.
+
+_Availability:_ Linux, Windows, Mac; since v1.4.0.
+
+## Defining Event Listeners ##
+
+To define a event listener, you subclass either
+[testing::TestEventListener](../include/gtest/gtest.h#L855)
+or [testing::EmptyTestEventListener](../include/gtest/gtest.h#L905).
+The former is an (abstract) interface, where <i>each pure virtual method<br>
+can be overridden to handle a test event</i> (For example, when a test
+starts, the `OnTestStart()` method will be called.). The latter provides
+an empty implementation of all methods in the interface, such that a
+subclass only needs to override the methods it cares about.
+
+When an event is fired, its context is passed to the handler function
+as an argument. The following argument types are used:
+  * [UnitTest](../include/gtest/gtest.h#L1007) reflects the state of the entire test program,
+  * [TestCase](../include/gtest/gtest.h#L689) has information about a test case, which can contain one or more tests,
+  * [TestInfo](../include/gtest/gtest.h#L599) contains the state of a test, and
+  * [TestPartResult](../include/gtest/gtest-test-part.h#L42) represents the result of a test assertion.
+
+An event handler function can examine the argument it receives to find
+out interesting information about the event and the test program's
+state.  Here's an example:
+
+```
+  class MinimalistPrinter : public ::testing::EmptyTestEventListener {
+    // Called before a test starts.
+    virtual void OnTestStart(const ::testing::TestInfo& test_info) {
+      printf("*** Test %s.%s starting.\n",
+             test_info.test_case_name(), test_info.name());
+    }
+
+    // Called after a failed assertion or a SUCCEED() invocation.
+    virtual void OnTestPartResult(
+        const ::testing::TestPartResult& test_part_result) {
+      printf("%s in %s:%d\n%s\n",
+             test_part_result.failed() ? "*** Failure" : "Success",
+             test_part_result.file_name(),
+             test_part_result.line_number(),
+             test_part_result.summary());
+    }
+
+    // Called after a test ends.
+    virtual void OnTestEnd(const ::testing::TestInfo& test_info) {
+      printf("*** Test %s.%s ending.\n",
+             test_info.test_case_name(), test_info.name());
+    }
+  };
+```
+
+## Using Event Listeners ##
+
+To use the event listener you have defined, add an instance of it to
+the Google Test event listener list (represented by class
+[TestEventListeners](../include/gtest/gtest.h#L929)
+- note the "s" at the end of the name) in your
+`main()` function, before calling `RUN_ALL_TESTS()`:
+```
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  // Gets hold of the event listener list.
+  ::testing::TestEventListeners& listeners =
+      ::testing::UnitTest::GetInstance()->listeners();
+  // Adds a listener to the end.  Google Test takes the ownership.
+  listeners.Append(new MinimalistPrinter);
+  return RUN_ALL_TESTS();
+}
+```
+
+There's only one problem: the default test result printer is still in
+effect, so its output will mingle with the output from your minimalist
+printer. To suppress the default printer, just release it from the
+event listener list and delete it. You can do so by adding one line:
+```
+  ...
+  delete listeners.Release(listeners.default_result_printer());
+  listeners.Append(new MinimalistPrinter);
+  return RUN_ALL_TESTS();
+```
+
+Now, sit back and enjoy a completely different output from your
+tests. For more details, you can read this
+[sample](../samples/sample9_unittest.cc).
+
+You may append more than one listener to the list. When an `On*Start()`
+or `OnTestPartResult()` event is fired, the listeners will receive it in
+the order they appear in the list (since new listeners are added to
+the end of the list, the default text printer and the default XML
+generator will receive the event first). An `On*End()` event will be
+received by the listeners in the _reverse_ order. This allows output by
+listeners added later to be framed by output from listeners added
+earlier.
+
+## Generating Failures in Listeners ##
+
+You may use failure-raising macros (`EXPECT_*()`, `ASSERT_*()`,
+`FAIL()`, etc) when processing an event. There are some restrictions:
+
+  1. You cannot generate any failure in `OnTestPartResult()` (otherwise it will cause `OnTestPartResult()` to be called recursively).
+  1. A listener that handles `OnTestPartResult()` is not allowed to generate any failure.
+
+When you add listeners to the listener list, you should put listeners
+that handle `OnTestPartResult()` _before_ listeners that can generate
+failures. This ensures that failures generated by the latter are
+attributed to the right test by the former.
+
+We have a sample of failure-raising listener
+[here](../samples/sample10_unittest.cc).
+
+# Running Test Programs: Advanced Options #
+
+Google Test test programs are ordinary executables. Once built, you can run
+them directly and affect their behavior via the following environment variables
+and/or command line flags. For the flags to work, your programs must call
+`::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`.
+
+To see a list of supported flags and their usage, please run your test
+program with the `--help` flag.  You can also use `-h`, `-?`, or `/?`
+for short.  This feature is added in version 1.3.0.
+
+If an option is specified both by an environment variable and by a
+flag, the latter takes precedence.  Most of the options can also be
+set/read in code: to access the value of command line flag
+`--gtest_foo`, write `::testing::GTEST_FLAG(foo)`.  A common pattern is
+to set the value of a flag before calling `::testing::InitGoogleTest()`
+to change the default value of the flag:
+```
+int main(int argc, char** argv) {
+  // Disables elapsed time by default.
+  ::testing::GTEST_FLAG(print_time) = false;
+
+  // This allows the user to override the flag on the command line.
+  ::testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}
+```
+
+## Selecting Tests ##
+
+This section shows various options for choosing which tests to run.
+
+### Listing Test Names ###
+
+Sometimes it is necessary to list the available tests in a program before
+running them so that a filter may be applied if needed. Including the flag
+`--gtest_list_tests` overrides all other flags and lists tests in the following
+format:
+```
+TestCase1.
+  TestName1
+  TestName2
+TestCase2.
+  TestName
+```
+
+None of the tests listed are actually run if the flag is provided. There is no
+corresponding environment variable for this flag.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Running a Subset of the Tests ###
+
+By default, a Google Test program runs all tests the user has defined.
+Sometimes, you want to run only a subset of the tests (e.g. for debugging or
+quickly verifying a change). If you set the `GTEST_FILTER` environment variable
+or the `--gtest_filter` flag to a filter string, Google Test will only run the
+tests whose full names (in the form of `TestCaseName.TestName`) match the
+filter.
+
+The format of a filter is a '`:`'-separated list of wildcard patterns (called
+the positive patterns) optionally followed by a '`-`' and another
+'`:`'-separated pattern list (called the negative patterns). A test matches the
+filter if and only if it matches any of the positive patterns but does not
+match any of the negative patterns.
+
+A pattern may contain `'*'` (matches any string) or `'?'` (matches any single
+character). For convenience, the filter `'*-NegativePatterns'` can be also
+written as `'-NegativePatterns'`.
+
+For example:
+
+  * `./foo_test` Has no flag, and thus runs all its tests.
+  * `./foo_test --gtest_filter=*` Also runs everything, due to the single match-everything `*` value.
+  * `./foo_test --gtest_filter=FooTest.*` Runs everything in test case `FooTest`.
+  * `./foo_test --gtest_filter=*Null*:*Constructor*` Runs any test whose full name contains either `"Null"` or `"Constructor"`.
+  * `./foo_test --gtest_filter=-*DeathTest.*` Runs all non-death tests.
+  * `./foo_test --gtest_filter=FooTest.*-FooTest.Bar` Runs everything in test case `FooTest` except `FooTest.Bar`.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Temporarily Disabling Tests ###
+
+If you have a broken test that you cannot fix right away, you can add the
+`DISABLED_` prefix to its name. This will exclude it from execution. This is
+better than commenting out the code or using `#if 0`, as disabled tests are
+still compiled (and thus won't rot).
+
+If you need to disable all tests in a test case, you can either add `DISABLED_`
+to the front of the name of each test, or alternatively add it to the front of
+the test case name.
+
+For example, the following tests won't be run by Google Test, even though they
+will still be compiled:
+
+```
+// Tests that Foo does Abc.
+TEST(FooTest, DISABLED_DoesAbc) { ... }
+
+class DISABLED_BarTest : public ::testing::Test { ... };
+
+// Tests that Bar does Xyz.
+TEST_F(DISABLED_BarTest, DoesXyz) { ... }
+```
+
+_Note:_ This feature should only be used for temporary pain-relief. You still
+have to fix the disabled tests at a later date. As a reminder, Google Test will
+print a banner warning you if a test program contains any disabled tests.
+
+_Tip:_ You can easily count the number of disabled tests you have
+using `grep`. This number can be used as a metric for improving your
+test quality.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Temporarily Enabling Disabled Tests ###
+
+To include [disabled tests](#temporarily-disabling-tests) in test
+execution, just invoke the test program with the
+`--gtest_also_run_disabled_tests` flag or set the
+`GTEST_ALSO_RUN_DISABLED_TESTS` environment variable to a value other
+than `0`.  You can combine this with the
+[--gtest\-filter](#running-a-subset-of-the_tests) flag to further select
+which disabled tests to run.
+
+_Availability:_ Linux, Windows, Mac; since version 1.3.0.
+
+## Repeating the Tests ##
+
+Once in a while you'll run into a test whose result is hit-or-miss. Perhaps it
+will fail only 1% of the time, making it rather hard to reproduce the bug under
+a debugger. This can be a major source of frustration.
+
+The `--gtest_repeat` flag allows you to repeat all (or selected) test methods
+in a program many times. Hopefully, a flaky test will eventually fail and give
+you a chance to debug. Here's how to use it:
+
+| `$ foo_test --gtest_repeat=1000` | Repeat foo\_test 1000 times and don't stop at failures. |
+|:---------------------------------|:--------------------------------------------------------|
+| `$ foo_test --gtest_repeat=-1`   | A negative count means repeating forever.               |
+| `$ foo_test --gtest_repeat=1000 --gtest_break_on_failure` | Repeat foo\_test 1000 times, stopping at the first failure. This is especially useful when running under a debugger: when the testfails, it will drop into the debugger and you can then inspect variables and stacks. |
+| `$ foo_test --gtest_repeat=1000 --gtest_filter=FooBar` | Repeat the tests whose name matches the filter 1000 times. |
+
+If your test program contains global set-up/tear-down code registered
+using `AddGlobalTestEnvironment()`, it will be repeated in each
+iteration as well, as the flakiness may be in it. You can also specify
+the repeat count by setting the `GTEST_REPEAT` environment variable.
+
+_Availability:_ Linux, Windows, Mac.
+
+## Shuffling the Tests ##
+
+You can specify the `--gtest_shuffle` flag (or set the `GTEST_SHUFFLE`
+environment variable to `1`) to run the tests in a program in a random
+order. This helps to reveal bad dependencies between tests.
+
+By default, Google Test uses a random seed calculated from the current
+time. Therefore you'll get a different order every time. The console
+output includes the random seed value, such that you can reproduce an
+order-related test failure later. To specify the random seed
+explicitly, use the `--gtest_random_seed=SEED` flag (or set the
+`GTEST_RANDOM_SEED` environment variable), where `SEED` is an integer
+between 0 and 99999. The seed value 0 is special: it tells Google Test
+to do the default behavior of calculating the seed from the current
+time.
+
+If you combine this with `--gtest_repeat=N`, Google Test will pick a
+different random seed and re-shuffle the tests in each iteration.
+
+_Availability:_ Linux, Windows, Mac; since v1.4.0.
+
+## Controlling Test Output ##
+
+This section teaches how to tweak the way test results are reported.
+
+### Colored Terminal Output ###
+
+Google Test can use colors in its terminal output to make it easier to spot
+the separation between tests, and whether tests passed.
+
+You can set the GTEST\_COLOR environment variable or set the `--gtest_color`
+command line flag to `yes`, `no`, or `auto` (the default) to enable colors,
+disable colors, or let Google Test decide. When the value is `auto`, Google
+Test will use colors if and only if the output goes to a terminal and (on
+non-Windows platforms) the `TERM` environment variable is set to `xterm` or
+`xterm-color`.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Suppressing the Elapsed Time ###
+
+By default, Google Test prints the time it takes to run each test.  To
+suppress that, run the test program with the `--gtest_print_time=0`
+command line flag.  Setting the `GTEST_PRINT_TIME` environment
+variable to `0` has the same effect.
+
+_Availability:_ Linux, Windows, Mac.  (In Google Test 1.3.0 and lower,
+the default behavior is that the elapsed time is **not** printed.)
+
+### Generating an XML Report ###
+
+Google Test can emit a detailed XML report to a file in addition to its normal
+textual output. The report contains the duration of each test, and thus can
+help you identify slow tests.
+
+To generate the XML report, set the `GTEST_OUTPUT` environment variable or the
+`--gtest_output` flag to the string `"xml:_path_to_output_file_"`, which will
+create the file at the given location. You can also just use the string
+`"xml"`, in which case the output can be found in the `test_detail.xml` file in
+the current directory.
+
+If you specify a directory (for example, `"xml:output/directory/"` on Linux or
+`"xml:output\directory\"` on Windows), Google Test will create the XML file in
+that directory, named after the test executable (e.g. `foo_test.xml` for test
+program `foo_test` or `foo_test.exe`). If the file already exists (perhaps left
+over from a previous run), Google Test will pick a different name (e.g.
+`foo_test_1.xml`) to avoid overwriting it.
+
+The report uses the format described here.  It is based on the
+`junitreport` Ant task and can be parsed by popular continuous build
+systems like [Hudson](https://hudson.dev.java.net/). Since that format
+was originally intended for Java, a little interpretation is required
+to make it apply to Google Test tests, as shown here:
+
+```
+<testsuites name="AllTests" ...>
+  <testsuite name="test_case_name" ...>
+    <testcase name="test_name" ...>
+      <failure message="..."/>
+      <failure message="..."/>
+      <failure message="..."/>
+    </testcase>
+  </testsuite>
+</testsuites>
+```
+
+  * The root `<testsuites>` element corresponds to the entire test program.
+  * `<testsuite>` elements correspond to Google Test test cases.
+  * `<testcase>` elements correspond to Google Test test functions.
+
+For instance, the following program
+
+```
+TEST(MathTest, Addition) { ... }
+TEST(MathTest, Subtraction) { ... }
+TEST(LogicTest, NonContradiction) { ... }
+```
+
+could generate this report:
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="3" failures="1" errors="0" time="35" name="AllTests">
+  <testsuite name="MathTest" tests="2" failures="1" errors="0" time="15">
+    <testcase name="Addition" status="run" time="7" classname="">
+      <failure message="Value of: add(1, 1)&#x0A; Actual: 3&#x0A;Expected: 2" type=""/>
+      <failure message="Value of: add(1, -1)&#x0A; Actual: 1&#x0A;Expected: 0" type=""/>
+    </testcase>
+    <testcase name="Subtraction" status="run" time="5" classname="">
+    </testcase>
+  </testsuite>
+  <testsuite name="LogicTest" tests="1" failures="0" errors="0" time="5">
+    <testcase name="NonContradiction" status="run" time="5" classname="">
+    </testcase>
+  </testsuite>
+</testsuites>
+```
+
+Things to note:
+
+  * The `tests` attribute of a `<testsuites>` or `<testsuite>` element tells how many test functions the Google Test program or test case contains, while the `failures` attribute tells how many of them failed.
+  * The `time` attribute expresses the duration of the test, test case, or entire test program in milliseconds.
+  * Each `<failure>` element corresponds to a single failed Google Test assertion.
+  * Some JUnit concepts don't apply to Google Test, yet we have to conform to the DTD. Therefore you'll see some dummy elements and attributes in the report. You can safely ignore these parts.
+
+_Availability:_ Linux, Windows, Mac.
+
+## Controlling How Failures Are Reported ##
+
+### Turning Assertion Failures into Break-Points ###
+
+When running test programs under a debugger, it's very convenient if the
+debugger can catch an assertion failure and automatically drop into interactive
+mode. Google Test's _break-on-failure_ mode supports this behavior.
+
+To enable it, set the `GTEST_BREAK_ON_FAILURE` environment variable to a value
+other than `0` . Alternatively, you can use the `--gtest_break_on_failure`
+command line flag.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Disabling Catching Test-Thrown Exceptions ###
+
+Google Test can be used either with or without exceptions enabled.  If
+a test throws a C++ exception or (on Windows) a structured exception
+(SEH), by default Google Test catches it, reports it as a test
+failure, and continues with the next test method.  This maximizes the
+coverage of a test run.  Also, on Windows an uncaught exception will
+cause a pop-up window, so catching the exceptions allows you to run
+the tests automatically.
+
+When debugging the test failures, however, you may instead want the
+exceptions to be handled by the debugger, such that you can examine
+the call stack when an exception is thrown.  To achieve that, set the
+`GTEST_CATCH_EXCEPTIONS` environment variable to `0`, or use the
+`--gtest_catch_exceptions=0` flag when running the tests.
+
+**Availability**: Linux, Windows, Mac.
+
+### Letting Another Testing Framework Drive ###
+
+If you work on a project that has already been using another testing
+framework and is not ready to completely switch to Google Test yet,
+you can get much of Google Test's benefit by using its assertions in
+your existing tests.  Just change your `main()` function to look
+like:
+
+```
+#include "gtest/gtest.h"
+
+int main(int argc, char** argv) {
+  ::testing::GTEST_FLAG(throw_on_failure) = true;
+  // Important: Google Test must be initialized.
+  ::testing::InitGoogleTest(&argc, argv);
+
+  ... whatever your existing testing framework requires ...
+}
+```
+
+With that, you can use Google Test assertions in addition to the
+native assertions your testing framework provides, for example:
+
+```
+void TestFooDoesBar() {
+  Foo foo;
+  EXPECT_LE(foo.Bar(1), 100);     // A Google Test assertion.
+  CPPUNIT_ASSERT(foo.IsEmpty());  // A native assertion.
+}
+```
+
+If a Google Test assertion fails, it will print an error message and
+throw an exception, which will be treated as a failure by your host
+testing framework.  If you compile your code with exceptions disabled,
+a failed Google Test assertion will instead exit your program with a
+non-zero code, which will also signal a test failure to your test
+runner.
+
+If you don't write `::testing::GTEST_FLAG(throw_on_failure) = true;` in
+your `main()`, you can alternatively enable this feature by specifying
+the `--gtest_throw_on_failure` flag on the command-line or setting the
+`GTEST_THROW_ON_FAILURE` environment variable to a non-zero value.
+
+_Availability:_ Linux, Windows, Mac; since v1.3.0.
+
+## Distributing Test Functions to Multiple Machines ##
+
+If you have more than one machine you can use to run a test program,
+you might want to run the test functions in parallel and get the
+result faster.  We call this technique _sharding_, where each machine
+is called a _shard_.
+
+Google Test is compatible with test sharding.  To take advantage of
+this feature, your test runner (not part of Google Test) needs to do
+the following:
+
+  1. Allocate a number of machines (shards) to run the tests.
+  1. On each shard, set the `GTEST_TOTAL_SHARDS` environment variable to the total number of shards.  It must be the same for all shards.
+  1. On each shard, set the `GTEST_SHARD_INDEX` environment variable to the index of the shard.  Different shards must be assigned different indices, which must be in the range `[0, GTEST_TOTAL_SHARDS - 1]`.
+  1. Run the same test program on all shards.  When Google Test sees the above two environment variables, it will select a subset of the test functions to run.  Across all shards, each test function in the program will be run exactly once.
+  1. Wait for all shards to finish, then collect and report the results.
+
+Your project may have tests that were written without Google Test and
+thus don't understand this protocol.  In order for your test runner to
+figure out which test supports sharding, it can set the environment
+variable `GTEST_SHARD_STATUS_FILE` to a non-existent file path.  If a
+test program supports sharding, it will create this file to
+acknowledge the fact (the actual contents of the file are not
+important at this time; although we may stick some useful information
+in it in the future.); otherwise it will not create it.
+
+Here's an example to make it clear.  Suppose you have a test program
+`foo_test` that contains the following 5 test functions:
+```
+TEST(A, V)
+TEST(A, W)
+TEST(B, X)
+TEST(B, Y)
+TEST(B, Z)
+```
+and you have 3 machines at your disposal.  To run the test functions in
+parallel, you would set `GTEST_TOTAL_SHARDS` to 3 on all machines, and
+set `GTEST_SHARD_INDEX` to 0, 1, and 2 on the machines respectively.
+Then you would run the same `foo_test` on each machine.
+
+Google Test reserves the right to change how the work is distributed
+across the shards, but here's one possible scenario:
+
+  * Machine #0 runs `A.V` and `B.X`.
+  * Machine #1 runs `A.W` and `B.Y`.
+  * Machine #2 runs `B.Z`.
+
+_Availability:_ Linux, Windows, Mac; since version 1.3.0.
+
+# Fusing Google Test Source Files #
+
+Google Test's implementation consists of ~30 files (excluding its own
+tests).  Sometimes you may want them to be packaged up in two files (a
+`.h` and a `.cc`) instead, such that you can easily copy them to a new
+machine and start hacking there.  For this we provide an experimental
+Python script `fuse_gtest_files.py` in the `scripts/` directory (since release 1.3.0).
+Assuming you have Python 2.4 or above installed on your machine, just
+go to that directory and run
+```
+python fuse_gtest_files.py OUTPUT_DIR
+```
+
+and you should see an `OUTPUT_DIR` directory being created with files
+`gtest/gtest.h` and `gtest/gtest-all.cc` in it.  These files contain
+everything you need to use Google Test.  Just copy them to anywhere
+you want and you are ready to write tests.  You can use the
+[scripts/test/Makefile](../scripts/test/Makefile)
+file as an example on how to compile your tests against them.
+
+# Where to Go from Here #
+
+Congratulations! You've now learned more advanced Google Test tools and are
+ready to tackle more complex testing tasks. If you want to dive even deeper, you
+can read the [Frequently-Asked Questions](V1_6_FAQ.md).
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Documentation.md
new file mode 100644
index 00000000..ca924660
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Documentation.md
@@ -0,0 +1,14 @@
+This page lists all documentation wiki pages for Google Test **1.6**
+-- **if you use a released version of Google Test, please read the
+documentation for that specific version instead.**
+
+  * [Primer](V1_6_Primer.md) -- start here if you are new to Google Test.
+  * [Samples](V1_6_Samples.md) -- learn from examples.
+  * [AdvancedGuide](V1_6_AdvancedGuide.md) -- learn more about Google Test.
+  * [XcodeGuide](V1_6_XcodeGuide.md) -- how to use Google Test in Xcode on Mac.
+  * [Frequently-Asked Questions](V1_6_FAQ.md) -- check here before asking a question on the mailing list.
+
+To contribute code to Google Test, read:
+
+  * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
+  * [PumpManual](V1_6_PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_FAQ.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_FAQ.md
new file mode 100644
index 00000000..2b7f7840
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_FAQ.md
@@ -0,0 +1,1038 @@
+
+
+If you cannot find the answer to your question here, and you have read
+[Primer](V1_6_Primer.md) and [AdvancedGuide](V1_6_AdvancedGuide.md), send it to
+googletestframework@googlegroups.com.
+
+## Why should I use Google Test instead of my favorite C++ testing framework? ##
+
+First, let us say clearly that we don't want to get into the debate of
+which C++ testing framework is **the best**.  There exist many fine
+frameworks for writing C++ tests, and we have tremendous respect for
+the developers and users of them.  We don't think there is (or will
+be) a single best framework - you have to pick the right tool for the
+particular task you are tackling.
+
+We created Google Test because we couldn't find the right combination
+of features and conveniences in an existing framework to satisfy _our_
+needs.  The following is a list of things that _we_ like about Google
+Test.  We don't claim them to be unique to Google Test - rather, the
+combination of them makes Google Test the choice for us.  We hope this
+list can help you decide whether it is for you too.
+
+  * Google Test is designed to be portable: it doesn't require exceptions or RTTI; it works around various bugs in various compilers and environments; etc.  As a result, it works on Linux, Mac OS X, Windows and several embedded operating systems.
+  * Nonfatal assertions (`EXPECT_*`) have proven to be great time savers, as they allow a test to report multiple failures in a single edit-compile-test cycle.
+  * It's easy to write assertions that generate informative messages: you just use the stream syntax to append any additional information, e.g. `ASSERT_EQ(5, Foo(i)) << " where i = " << i;`.  It doesn't require a new set of macros or special functions.
+  * Google Test automatically detects your tests and doesn't require you to enumerate them in order to run them.
+  * Death tests are pretty handy for ensuring that your asserts in production code are triggered by the right conditions.
+  * `SCOPED_TRACE` helps you understand the context of an assertion failure when it comes from inside a sub-routine or loop.
+  * You can decide which tests to run using name patterns.  This saves time when you want to quickly reproduce a test failure.
+  * Google Test can generate XML test result reports that can be parsed by popular continuous build system like Hudson.
+  * Simple things are easy in Google Test, while hard things are possible: in addition to advanced features like [global test environments](V1_6_AdvancedGuide.md#Global_Set-Up_and_Tear-Down) and tests parameterized by [values](V1_6_AdvancedGuide.md#value-parameterized-tests) or [types](V1_6_AdvancedGuide.md#typed-tests), Google Test supports various ways for the user to extend the framework -- if Google Test doesn't do something out of the box, chances are that a user can implement the feature using Google Test's public API, without changing Google Test itself.  In particular, you can:
+    * expand your testing vocabulary by defining [custom predicates](V1_6_AdvancedGuide.md#predicate-assertions-for-better-error-messages),
+    * teach Google Test how to [print your types](V1_6_AdvancedGuide.md#teaching-google-test-how-to-print-your-values),
+    * define your own testing macros or utilities and verify them using Google Test's [Service Provider Interface](V1_6_AdvancedGuide.md#catching-failures), and
+    * reflect on the test cases or change the test output format by intercepting the [test events](V1_6_AdvancedGuide.md#extending-google-test-by-handling-test-events).
+
+## I'm getting warnings when compiling Google Test.  Would you fix them? ##
+
+We strive to minimize compiler warnings Google Test generates.  Before releasing a new version, we test to make sure that it doesn't generate warnings when compiled using its CMake script on Windows, Linux, and Mac OS.
+
+Unfortunately, this doesn't mean you are guaranteed to see no warnings when compiling Google Test in your environment:
+
+  * You may be using a different compiler as we use, or a different version of the same compiler.  We cannot possibly test for all compilers.
+  * You may be compiling on a different platform as we do.
+  * Your project may be using different compiler flags as we do.
+
+It is not always possible to make Google Test warning-free for everyone.  Or, it may not be desirable if the warning is rarely enabled and fixing the violations makes the code more complex.
+
+If you see warnings when compiling Google Test, we suggest that you use the `-isystem` flag (assuming your are using GCC) to mark Google Test headers as system headers.  That'll suppress warnings from Google Test headers.
+
+## Why should not test case names and test names contain underscore? ##
+
+Underscore (`_`) is special, as C++ reserves the following to be used by
+the compiler and the standard library:
+
+  1. any identifier that starts with an `_` followed by an upper-case letter, and
+  1. any identifier that containers two consecutive underscores (i.e. `__`) _anywhere_ in its name.
+
+User code is _prohibited_ from using such identifiers.
+
+Now let's look at what this means for `TEST` and `TEST_F`.
+
+Currently `TEST(TestCaseName, TestName)` generates a class named
+`TestCaseName_TestName_Test`.  What happens if `TestCaseName` or `TestName`
+contains `_`?
+
+  1. If `TestCaseName` starts with an `_` followed by an upper-case letter (say, `_Foo`), we end up with `_Foo_TestName_Test`, which is reserved and thus invalid.
+  1. If `TestCaseName` ends with an `_` (say, `Foo_`), we get `Foo__TestName_Test`, which is invalid.
+  1. If `TestName` starts with an `_` (say, `_Bar`), we get `TestCaseName__Bar_Test`, which is invalid.
+  1. If `TestName` ends with an `_` (say, `Bar_`), we get `TestCaseName_Bar__Test`, which is invalid.
+
+So clearly `TestCaseName` and `TestName` cannot start or end with `_`
+(Actually, `TestCaseName` can start with `_` -- as long as the `_` isn't
+followed by an upper-case letter.  But that's getting complicated.  So
+for simplicity we just say that it cannot start with `_`.).
+
+It may seem fine for `TestCaseName` and `TestName` to contain `_` in the
+middle.  However, consider this:
+```
+TEST(Time, Flies_Like_An_Arrow) { ... }
+TEST(Time_Flies, Like_An_Arrow) { ... }
+```
+
+Now, the two `TEST`s will both generate the same class
+(`Time_Files_Like_An_Arrow_Test`).  That's not good.
+
+So for simplicity, we just ask the users to avoid `_` in `TestCaseName`
+and `TestName`.  The rule is more constraining than necessary, but it's
+simple and easy to remember.  It also gives Google Test some wiggle
+room in case its implementation needs to change in the future.
+
+If you violate the rule, there may not be immediately consequences,
+but your test may (just may) break with a new compiler (or a new
+version of the compiler you are using) or with a new version of Google
+Test.  Therefore it's best to follow the rule.
+
+## Why is it not recommended to install a pre-compiled copy of Google Test (for example, into /usr/local)? ##
+
+In the early days, we said that you could install
+compiled Google Test libraries on `*`nix systems using `make install`.
+Then every user of your machine can write tests without
+recompiling Google Test.
+
+This seemed like a good idea, but it has a
+got-cha: every user needs to compile his tests using the _same_ compiler
+flags used to compile the installed Google Test libraries; otherwise
+he may run into undefined behaviors (i.e. the tests can behave
+strangely and may even crash for no obvious reasons).
+
+Why?  Because C++ has this thing called the One-Definition Rule: if
+two C++ source files contain different definitions of the same
+class/function/variable, and you link them together, you violate the
+rule.  The linker may or may not catch the error (in many cases it's
+not required by the C++ standard to catch the violation).  If it
+doesn't, you get strange run-time behaviors that are unexpected and
+hard to debug.
+
+If you compile Google Test and your test code using different compiler
+flags, they may see different definitions of the same
+class/function/variable (e.g. due to the use of `#if` in Google Test).
+Therefore, for your sanity, we recommend to avoid installing pre-compiled
+Google Test libraries.  Instead, each project should compile
+Google Test itself such that it can be sure that the same flags are
+used for both Google Test and the tests.
+
+## How do I generate 64-bit binaries on Windows (using Visual Studio 2008)? ##
+
+(Answered by Trevor Robinson)
+
+Load the supplied Visual Studio solution file, either `msvc\gtest-md.sln` or
+`msvc\gtest.sln`. Go through the migration wizard to migrate the
+solution and project files to Visual Studio 2008. Select
+`Configuration Manager...` from the `Build` menu. Select `<New...>` from
+the `Active solution platform` dropdown.  Select `x64` from the new
+platform dropdown, leave `Copy settings from` set to `Win32` and
+`Create new project platforms` checked, then click `OK`. You now have
+`Win32` and `x64` platform configurations, selectable from the
+`Standard` toolbar, which allow you to toggle between building 32-bit or
+64-bit binaries (or both at once using Batch Build).
+
+In order to prevent build output files from overwriting one another,
+you'll need to change the `Intermediate Directory` settings for the
+newly created platform configuration across all the projects. To do
+this, multi-select (e.g. using shift-click) all projects (but not the
+solution) in the `Solution Explorer`. Right-click one of them and
+select `Properties`. In the left pane, select `Configuration Properties`,
+and from the `Configuration` dropdown, select `All Configurations`.
+Make sure the selected platform is `x64`. For the
+`Intermediate Directory` setting, change the value from
+`$(PlatformName)\$(ConfigurationName)` to
+`$(OutDir)\$(ProjectName)`. Click `OK` and then build the
+solution. When the build is complete, the 64-bit binaries will be in
+the `msvc\x64\Debug` directory.
+
+## Can I use Google Test on MinGW? ##
+
+We haven't tested this ourselves, but Per Abrahamsen reported that he
+was able to compile and install Google Test successfully when using
+MinGW from Cygwin.  You'll need to configure it with:
+
+`PATH/TO/configure CC="gcc -mno-cygwin" CXX="g++ -mno-cygwin"`
+
+You should be able to replace the `-mno-cygwin` option with direct links
+to the real MinGW binaries, but we haven't tried that.
+
+Caveats:
+
+  * There are many warnings when compiling.
+  * `make check` will produce some errors as not all tests for Google Test itself are compatible with MinGW.
+
+We also have reports on successful cross compilation of Google Test
+MinGW binaries on Linux using
+[these instructions](http://wiki.wxwidgets.org/Cross-Compiling_Under_Linux#Cross-compiling_under_Linux_for_MS_Windows)
+on the WxWidgets site.
+
+Please contact `googletestframework@googlegroups.com` if you are
+interested in improving the support for MinGW.
+
+## Why does Google Test support EXPECT\_EQ(NULL, ptr) and ASSERT\_EQ(NULL, ptr) but not EXPECT\_NE(NULL, ptr) and ASSERT\_NE(NULL, ptr)? ##
+
+Due to some peculiarity of C++, it requires some non-trivial template
+meta programming tricks to support using `NULL` as an argument of the
+`EXPECT_XX()` and `ASSERT_XX()` macros. Therefore we only do it where
+it's most needed (otherwise we make the implementation of Google Test
+harder to maintain and more error-prone than necessary).
+
+The `EXPECT_EQ()` macro takes the _expected_ value as its first
+argument and the _actual_ value as the second. It's reasonable that
+someone wants to write `EXPECT_EQ(NULL, some_expression)`, and this
+indeed was requested several times. Therefore we implemented it.
+
+The need for `EXPECT_NE(NULL, ptr)` isn't nearly as strong. When the
+assertion fails, you already know that `ptr` must be `NULL`, so it
+doesn't add any information to print ptr in this case. That means
+`EXPECT_TRUE(ptr ! NULL)` works just as well.
+
+If we were to support `EXPECT_NE(NULL, ptr)`, for consistency we'll
+have to support `EXPECT_NE(ptr, NULL)` as well, as unlike `EXPECT_EQ`,
+we don't have a convention on the order of the two arguments for
+`EXPECT_NE`. This means using the template meta programming tricks
+twice in the implementation, making it even harder to understand and
+maintain. We believe the benefit doesn't justify the cost.
+
+Finally, with the growth of Google Mock's [matcher](../../CookBook.md#using-matchers-in-google-test-assertions) library, we are
+encouraging people to use the unified `EXPECT_THAT(value, matcher)`
+syntax more often in tests. One significant advantage of the matcher
+approach is that matchers can be easily combined to form new matchers,
+while the `EXPECT_NE`, etc, macros cannot be easily
+combined. Therefore we want to invest more in the matchers than in the
+`EXPECT_XX()` macros.
+
+## Does Google Test support running tests in parallel? ##
+
+Test runners tend to be tightly coupled with the build/test
+environment, and Google Test doesn't try to solve the problem of
+running tests in parallel.  Instead, we tried to make Google Test work
+nicely with test runners.  For example, Google Test's XML report
+contains the time spent on each test, and its `gtest_list_tests` and
+`gtest_filter` flags can be used for splitting the execution of test
+methods into multiple processes.  These functionalities can help the
+test runner run the tests in parallel.
+
+## Why don't Google Test run the tests in different threads to speed things up? ##
+
+It's difficult to write thread-safe code.  Most tests are not written
+with thread-safety in mind, and thus may not work correctly in a
+multi-threaded setting.
+
+If you think about it, it's already hard to make your code work when
+you know what other threads are doing.  It's much harder, and
+sometimes even impossible, to make your code work when you don't know
+what other threads are doing (remember that test methods can be added,
+deleted, or modified after your test was written).  If you want to run
+the tests in parallel, you'd better run them in different processes.
+
+## Why aren't Google Test assertions implemented using exceptions? ##
+
+Our original motivation was to be able to use Google Test in projects
+that disable exceptions.  Later we realized some additional benefits
+of this approach:
+
+  1. Throwing in a destructor is undefined behavior in C++.  Not using exceptions means Google Test's assertions are safe to use in destructors.
+  1. The `EXPECT_*` family of macros will continue even after a failure, allowing multiple failures in a `TEST` to be reported in a single run. This is a popular feature, as in C++ the edit-compile-test cycle is usually quite long and being able to fixing more than one thing at a time is a blessing.
+  1. If assertions are implemented using exceptions, a test may falsely ignore a failure if it's caught by user code:
+```
+try { ... ASSERT_TRUE(...) ... }
+catch (...) { ... }
+```
+The above code will pass even if the `ASSERT_TRUE` throws.  While it's unlikely for someone to write this in a test, it's possible to run into this pattern when you write assertions in callbacks that are called by the code under test.
+
+The downside of not using exceptions is that `ASSERT_*` (implemented
+using `return`) will only abort the current function, not the current
+`TEST`.
+
+## Why do we use two different macros for tests with and without fixtures? ##
+
+Unfortunately, C++'s macro system doesn't allow us to use the same
+macro for both cases.  One possibility is to provide only one macro
+for tests with fixtures, and require the user to define an empty
+fixture sometimes:
+
+```
+class FooTest : public ::testing::Test {};
+
+TEST_F(FooTest, DoesThis) { ... }
+```
+or
+```
+typedef ::testing::Test FooTest;
+
+TEST_F(FooTest, DoesThat) { ... }
+```
+
+Yet, many people think this is one line too many. :-) Our goal was to
+make it really easy to write tests, so we tried to make simple tests
+trivial to create.  That means using a separate macro for such tests.
+
+We think neither approach is ideal, yet either of them is reasonable.
+In the end, it probably doesn't matter much either way.
+
+## Why don't we use structs as test fixtures? ##
+
+We like to use structs only when representing passive data.  This
+distinction between structs and classes is good for documenting the
+intent of the code's author.  Since test fixtures have logic like
+`SetUp()` and `TearDown()`, they are better defined as classes.
+
+## Why are death tests implemented as assertions instead of using a test runner? ##
+
+Our goal was to make death tests as convenient for a user as C++
+possibly allows.  In particular:
+
+  * The runner-style requires to split the information into two pieces: the definition of the death test itself, and the specification for the runner on how to run the death test and what to expect.  The death test would be written in C++, while the runner spec may or may not be.  A user needs to carefully keep the two in sync. `ASSERT_DEATH(statement, expected_message)` specifies all necessary information in one place, in one language, without boilerplate code. It is very declarative.
+  * `ASSERT_DEATH` has a similar syntax and error-reporting semantics as other Google Test assertions, and thus is easy to learn.
+  * `ASSERT_DEATH` can be mixed with other assertions and other logic at your will.  You are not limited to one death test per test method. For example, you can write something like:
+```
+    if (FooCondition()) {
+      ASSERT_DEATH(Bar(), "blah");
+    } else {
+      ASSERT_EQ(5, Bar());
+    }
+```
+If you prefer one death test per test method, you can write your tests in that style too, but we don't want to impose that on the users.  The fewer artificial limitations the better.
+  * `ASSERT_DEATH` can reference local variables in the current function, and you can decide how many death tests you want based on run-time information.  For example,
+```
+    const int count = GetCount();  // Only known at run time.
+    for (int i = 1; i <= count; i++) {
+      ASSERT_DEATH({
+        double* buffer = new double[i];
+        ... initializes buffer ...
+        Foo(buffer, i)
+      }, "blah blah");
+    }
+```
+The runner-based approach tends to be more static and less flexible, or requires more user effort to get this kind of flexibility.
+
+Another interesting thing about `ASSERT_DEATH` is that it calls `fork()`
+to create a child process to run the death test.  This is lightening
+fast, as `fork()` uses copy-on-write pages and incurs almost zero
+overhead, and the child process starts from the user-supplied
+statement directly, skipping all global and local initialization and
+any code leading to the given statement.  If you launch the child
+process from scratch, it can take seconds just to load everything and
+start running if the test links to many libraries dynamically.
+
+## My death test modifies some state, but the change seems lost after the death test finishes. Why? ##
+
+Death tests (`EXPECT_DEATH`, etc) are executed in a sub-process s.t. the
+expected crash won't kill the test program (i.e. the parent process). As a
+result, any in-memory side effects they incur are observable in their
+respective sub-processes, but not in the parent process. You can think of them
+as running in a parallel universe, more or less.
+
+## The compiler complains about "undefined references" to some static const member variables, but I did define them in the class body. What's wrong? ##
+
+If your class has a static data member:
+
+```
+// foo.h
+class Foo {
+  ...
+  static const int kBar = 100;
+};
+```
+
+You also need to define it _outside_ of the class body in `foo.cc`:
+
+```
+const int Foo::kBar;  // No initializer here.
+```
+
+Otherwise your code is **invalid C++**, and may break in unexpected ways. In
+particular, using it in Google Test comparison assertions (`EXPECT_EQ`, etc)
+will generate an "undefined reference" linker error.
+
+## I have an interface that has several implementations. Can I write a set of tests once and repeat them over all the implementations? ##
+
+Google Test doesn't yet have good support for this kind of tests, or
+data-driven tests in general. We hope to be able to make improvements in this
+area soon.
+
+## Can I derive a test fixture from another? ##
+
+Yes.
+
+Each test fixture has a corresponding and same named test case. This means only
+one test case can use a particular fixture. Sometimes, however, multiple test
+cases may want to use the same or slightly different fixtures. For example, you
+may want to make sure that all of a GUI library's test cases don't leak
+important system resources like fonts and brushes.
+
+In Google Test, you share a fixture among test cases by putting the shared
+logic in a base test fixture, then deriving from that base a separate fixture
+for each test case that wants to use this common logic. You then use `TEST_F()`
+to write tests using each derived fixture.
+
+Typically, your code looks like this:
+
+```
+// Defines a base test fixture.
+class BaseTest : public ::testing::Test {
+  protected:
+   ...
+};
+
+// Derives a fixture FooTest from BaseTest.
+class FooTest : public BaseTest {
+  protected:
+    virtual void SetUp() {
+      BaseTest::SetUp();  // Sets up the base fixture first.
+      ... additional set-up work ...
+    }
+    virtual void TearDown() {
+      ... clean-up work for FooTest ...
+      BaseTest::TearDown();  // Remember to tear down the base fixture
+                             // after cleaning up FooTest!
+    }
+    ... functions and variables for FooTest ...
+};
+
+// Tests that use the fixture FooTest.
+TEST_F(FooTest, Bar) { ... }
+TEST_F(FooTest, Baz) { ... }
+
+... additional fixtures derived from BaseTest ...
+```
+
+If necessary, you can continue to derive test fixtures from a derived fixture.
+Google Test has no limit on how deep the hierarchy can be.
+
+For a complete example using derived test fixtures, see
+[sample5](../samples/sample5_unittest.cc).
+
+## My compiler complains "void value not ignored as it ought to be." What does this mean? ##
+
+You're probably using an `ASSERT_*()` in a function that doesn't return `void`.
+`ASSERT_*()` can only be used in `void` functions.
+
+## My death test hangs (or seg-faults). How do I fix it? ##
+
+In Google Test, death tests are run in a child process and the way they work is
+delicate. To write death tests you really need to understand how they work.
+Please make sure you have read this.
+
+In particular, death tests don't like having multiple threads in the parent
+process. So the first thing you can try is to eliminate creating threads
+outside of `EXPECT_DEATH()`.
+
+Sometimes this is impossible as some library you must use may be creating
+threads before `main()` is even reached. In this case, you can try to minimize
+the chance of conflicts by either moving as many activities as possible inside
+`EXPECT_DEATH()` (in the extreme case, you want to move everything inside), or
+leaving as few things as possible in it. Also, you can try to set the death
+test style to `"threadsafe"`, which is safer but slower, and see if it helps.
+
+If you go with thread-safe death tests, remember that they rerun the test
+program from the beginning in the child process. Therefore make sure your
+program can run side-by-side with itself and is deterministic.
+
+In the end, this boils down to good concurrent programming. You have to make
+sure that there is no race conditions or dead locks in your program. No silver
+bullet - sorry!
+
+## Should I use the constructor/destructor of the test fixture or the set-up/tear-down function? ##
+
+The first thing to remember is that Google Test does not reuse the
+same test fixture object across multiple tests. For each `TEST_F`,
+Google Test will create a fresh test fixture object, _immediately_
+call `SetUp()`, run the test, call `TearDown()`, and then
+_immediately_ delete the test fixture object. Therefore, there is no
+need to write a `SetUp()` or `TearDown()` function if the constructor
+or destructor already does the job.
+
+You may still want to use `SetUp()/TearDown()` in the following cases:
+  * If the tear-down operation could throw an exception, you must use `TearDown()` as opposed to the destructor, as throwing in a destructor leads to undefined behavior and usually will kill your program right away. Note that many standard libraries (like STL) may throw when exceptions are enabled in the compiler. Therefore you should prefer `TearDown()` if you want to write portable tests that work with or without exceptions.
+  * The Google Test team is considering making the assertion macros throw on platforms where exceptions are enabled (e.g. Windows, Mac OS, and Linux client-side), which will eliminate the need for the user to propagate failures from a subroutine to its caller. Therefore, you shouldn't use Google Test assertions in a destructor if your code could run on such a platform.
+  * In a constructor or destructor, you cannot make a virtual function call on this object. (You can call a method declared as virtual, but it will be statically bound.) Therefore, if you need to call a method that will be overriden in a derived class, you have to use `SetUp()/TearDown()`.
+
+## The compiler complains "no matching function to call" when I use ASSERT\_PREDn. How do I fix it? ##
+
+If the predicate function you use in `ASSERT_PRED*` or `EXPECT_PRED*` is
+overloaded or a template, the compiler will have trouble figuring out which
+overloaded version it should use. `ASSERT_PRED_FORMAT*` and
+`EXPECT_PRED_FORMAT*` don't have this problem.
+
+If you see this error, you might want to switch to
+`(ASSERT|EXPECT)_PRED_FORMAT*`, which will also give you a better failure
+message. If, however, that is not an option, you can resolve the problem by
+explicitly telling the compiler which version to pick.
+
+For example, suppose you have
+
+```
+bool IsPositive(int n) {
+  return n > 0;
+}
+bool IsPositive(double x) {
+  return x > 0;
+}
+```
+
+you will get a compiler error if you write
+
+```
+EXPECT_PRED1(IsPositive, 5);
+```
+
+However, this will work:
+
+```
+EXPECT_PRED1(*static_cast<bool (*)(int)>*(IsPositive), 5);
+```
+
+(The stuff inside the angled brackets for the `static_cast` operator is the
+type of the function pointer for the `int`-version of `IsPositive()`.)
+
+As another example, when you have a template function
+
+```
+template <typename T>
+bool IsNegative(T x) {
+  return x < 0;
+}
+```
+
+you can use it in a predicate assertion like this:
+
+```
+ASSERT_PRED1(IsNegative*<int>*, -5);
+```
+
+Things are more interesting if your template has more than one parameters. The
+following won't compile:
+
+```
+ASSERT_PRED2(*GreaterThan<int, int>*, 5, 0);
+```
+
+
+as the C++ pre-processor thinks you are giving `ASSERT_PRED2` 4 arguments,
+which is one more than expected. The workaround is to wrap the predicate
+function in parentheses:
+
+```
+ASSERT_PRED2(*(GreaterThan<int, int>)*, 5, 0);
+```
+
+
+## My compiler complains about "ignoring return value" when I call RUN\_ALL\_TESTS(). Why? ##
+
+Some people had been ignoring the return value of `RUN_ALL_TESTS()`. That is,
+instead of
+
+```
+return RUN_ALL_TESTS();
+```
+
+they write
+
+```
+RUN_ALL_TESTS();
+```
+
+This is wrong and dangerous. A test runner needs to see the return value of
+`RUN_ALL_TESTS()` in order to determine if a test has passed. If your `main()`
+function ignores it, your test will be considered successful even if it has a
+Google Test assertion failure. Very bad.
+
+To help the users avoid this dangerous bug, the implementation of
+`RUN_ALL_TESTS()` causes gcc to raise this warning, when the return value is
+ignored. If you see this warning, the fix is simple: just make sure its value
+is used as the return value of `main()`.
+
+## My compiler complains that a constructor (or destructor) cannot return a value. What's going on? ##
+
+Due to a peculiarity of C++, in order to support the syntax for streaming
+messages to an `ASSERT_*`, e.g.
+
+```
+ASSERT_EQ(1, Foo()) << "blah blah" << foo;
+```
+
+we had to give up using `ASSERT*` and `FAIL*` (but not `EXPECT*` and
+`ADD_FAILURE*`) in constructors and destructors. The workaround is to move the
+content of your constructor/destructor to a private void member function, or
+switch to `EXPECT_*()` if that works. This section in the user's guide explains
+it.
+
+## My set-up function is not called. Why? ##
+
+C++ is case-sensitive. It should be spelled as `SetUp()`.  Did you
+spell it as `Setup()`?
+
+Similarly, sometimes people spell `SetUpTestCase()` as `SetupTestCase()` and
+wonder why it's never called.
+
+## How do I jump to the line of a failure in Emacs directly? ##
+
+Google Test's failure message format is understood by Emacs and many other
+IDEs, like acme and XCode. If a Google Test message is in a compilation buffer
+in Emacs, then it's clickable. You can now hit `enter` on a message to jump to
+the corresponding source code, or use `C-x `` to jump to the next failure.
+
+## I have several test cases which share the same test fixture logic, do I have to define a new test fixture class for each of them? This seems pretty tedious. ##
+
+You don't have to. Instead of
+
+```
+class FooTest : public BaseTest {};
+
+TEST_F(FooTest, Abc) { ... }
+TEST_F(FooTest, Def) { ... }
+
+class BarTest : public BaseTest {};
+
+TEST_F(BarTest, Abc) { ... }
+TEST_F(BarTest, Def) { ... }
+```
+
+you can simply `typedef` the test fixtures:
+```
+typedef BaseTest FooTest;
+
+TEST_F(FooTest, Abc) { ... }
+TEST_F(FooTest, Def) { ... }
+
+typedef BaseTest BarTest;
+
+TEST_F(BarTest, Abc) { ... }
+TEST_F(BarTest, Def) { ... }
+```
+
+## The Google Test output is buried in a whole bunch of log messages. What do I do? ##
+
+The Google Test output is meant to be a concise and human-friendly report. If
+your test generates textual output itself, it will mix with the Google Test
+output, making it hard to read. However, there is an easy solution to this
+problem.
+
+Since most log messages go to stderr, we decided to let Google Test output go
+to stdout. This way, you can easily separate the two using redirection. For
+example:
+```
+./my_test > googletest_output.txt
+```
+
+## Why should I prefer test fixtures over global variables? ##
+
+There are several good reasons:
+  1. It's likely your test needs to change the states of its global variables. This makes it difficult to keep side effects from escaping one test and contaminating others, making debugging difficult. By using fixtures, each test has a fresh set of variables that's different (but with the same names). Thus, tests are kept independent of each other.
+  1. Global variables pollute the global namespace.
+  1. Test fixtures can be reused via subclassing, which cannot be done easily with global variables. This is useful if many test cases have something in common.
+
+## How do I test private class members without writing FRIEND\_TEST()s? ##
+
+You should try to write testable code, which means classes should be easily
+tested from their public interface. One way to achieve this is the Pimpl idiom:
+you move all private members of a class into a helper class, and make all
+members of the helper class public.
+
+You have several other options that don't require using `FRIEND_TEST`:
+  * Write the tests as members of the fixture class:
+```
+class Foo {
+  friend class FooTest;
+  ...
+};
+
+class FooTest : public ::testing::Test {
+ protected:
+  ...
+  void Test1() {...} // This accesses private members of class Foo.
+  void Test2() {...} // So does this one.
+};
+
+TEST_F(FooTest, Test1) {
+  Test1();
+}
+
+TEST_F(FooTest, Test2) {
+  Test2();
+}
+```
+  * In the fixture class, write accessors for the tested class' private members, then use the accessors in your tests:
+```
+class Foo {
+  friend class FooTest;
+  ...
+};
+
+class FooTest : public ::testing::Test {
+ protected:
+  ...
+  T1 get_private_member1(Foo* obj) {
+    return obj->private_member1_;
+  }
+};
+
+TEST_F(FooTest, Test1) {
+  ...
+  get_private_member1(x)
+  ...
+}
+```
+  * If the methods are declared **protected**, you can change their access level in a test-only subclass:
+```
+class YourClass {
+  ...
+ protected: // protected access for testability.
+  int DoSomethingReturningInt();
+  ...
+};
+
+// in the your_class_test.cc file:
+class TestableYourClass : public YourClass {
+  ...
+ public: using YourClass::DoSomethingReturningInt; // changes access rights
+  ...
+};
+
+TEST_F(YourClassTest, DoSomethingTest) {
+  TestableYourClass obj;
+  assertEquals(expected_value, obj.DoSomethingReturningInt());
+}
+```
+
+## How do I test private class static members without writing FRIEND\_TEST()s? ##
+
+We find private static methods clutter the header file.  They are
+implementation details and ideally should be kept out of a .h. So often I make
+them free functions instead.
+
+Instead of:
+```
+// foo.h
+class Foo {
+  ...
+ private:
+  static bool Func(int n);
+};
+
+// foo.cc
+bool Foo::Func(int n) { ... }
+
+// foo_test.cc
+EXPECT_TRUE(Foo::Func(12345));
+```
+
+You probably should better write:
+```
+// foo.h
+class Foo {
+  ...
+};
+
+// foo.cc
+namespace internal {
+  bool Func(int n) { ... }
+}
+
+// foo_test.cc
+namespace internal {
+  bool Func(int n);
+}
+
+EXPECT_TRUE(internal::Func(12345));
+```
+
+## I would like to run a test several times with different parameters. Do I need to write several similar copies of it? ##
+
+No. You can use a feature called [value-parameterized tests](V1_6_AdvancedGuide.md#Value_Parameterized_Tests) which
+lets you repeat your tests with different parameters, without defining it more than once.
+
+## How do I test a file that defines main()? ##
+
+To test a `foo.cc` file, you need to compile and link it into your unit test
+program. However, when the file contains a definition for the `main()`
+function, it will clash with the `main()` of your unit test, and will result in
+a build error.
+
+The right solution is to split it into three files:
+  1. `foo.h` which contains the declarations,
+  1. `foo.cc` which contains the definitions except `main()`, and
+  1. `foo_main.cc` which contains nothing but the definition of `main()`.
+
+Then `foo.cc` can be easily tested.
+
+If you are adding tests to an existing file and don't want an intrusive change
+like this, there is a hack: just include the entire `foo.cc` file in your unit
+test. For example:
+```
+// File foo_unittest.cc
+
+// The headers section
+...
+
+// Renames main() in foo.cc to make room for the unit test main()
+#define main FooMain
+
+#include "a/b/foo.cc"
+
+// The tests start here.
+...
+```
+
+
+However, please remember this is a hack and should only be used as the last
+resort.
+
+## What can the statement argument in ASSERT\_DEATH() be? ##
+
+`ASSERT_DEATH(_statement_, _regex_)` (or any death assertion macro) can be used
+wherever `_statement_` is valid. So basically `_statement_` can be any C++
+statement that makes sense in the current context. In particular, it can
+reference global and/or local variables, and can be:
+  * a simple function call (often the case),
+  * a complex expression, or
+  * a compound statement.
+
+> Some examples are shown here:
+
+```
+// A death test can be a simple function call.
+TEST(MyDeathTest, FunctionCall) {
+  ASSERT_DEATH(Xyz(5), "Xyz failed");
+}
+
+// Or a complex expression that references variables and functions.
+TEST(MyDeathTest, ComplexExpression) {
+  const bool c = Condition();
+  ASSERT_DEATH((c ? Func1(0) : object2.Method("test")),
+               "(Func1|Method) failed");
+}
+
+// Death assertions can be used any where in a function. In
+// particular, they can be inside a loop.
+TEST(MyDeathTest, InsideLoop) {
+  // Verifies that Foo(0), Foo(1), ..., and Foo(4) all die.
+  for (int i = 0; i < 5; i++) {
+    EXPECT_DEATH_M(Foo(i), "Foo has \\d+ errors",
+                   ::testing::Message() << "where i is " << i);
+  }
+}
+
+// A death assertion can contain a compound statement.
+TEST(MyDeathTest, CompoundStatement) {
+  // Verifies that at lease one of Bar(0), Bar(1), ..., and
+  // Bar(4) dies.
+  ASSERT_DEATH({
+    for (int i = 0; i < 5; i++) {
+      Bar(i);
+    }
+  },
+  "Bar has \\d+ errors");}
+```
+
+`googletest_unittest.cc` contains more examples if you are interested.
+
+## What syntax does the regular expression in ASSERT\_DEATH use? ##
+
+On POSIX systems, Google Test uses the POSIX Extended regular
+expression syntax
+(http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
+On Windows, it uses a limited variant of regular expression
+syntax. For more details, see the
+[regular expression syntax](V1_6_AdvancedGuide.md#Regular_Expression_Syntax).
+
+## I have a fixture class Foo, but TEST\_F(Foo, Bar) gives me error "no matching function for call to Foo::Foo()". Why? ##
+
+Google Test needs to be able to create objects of your test fixture class, so
+it must have a default constructor. Normally the compiler will define one for
+you. However, there are cases where you have to define your own:
+  * If you explicitly declare a non-default constructor for class `Foo`, then you need to define a default constructor, even if it would be empty.
+  * If `Foo` has a const non-static data member, then you have to define the default constructor _and_ initialize the const member in the initializer list of the constructor. (Early versions of `gcc` doesn't force you to initialize the const member. It's a bug that has been fixed in `gcc 4`.)
+
+## Why does ASSERT\_DEATH complain about previous threads that were already joined? ##
+
+With the Linux pthread library, there is no turning back once you cross the
+line from single thread to multiple threads. The first time you create a
+thread, a manager thread is created in addition, so you get 3, not 2, threads.
+Later when the thread you create joins the main thread, the thread count
+decrements by 1, but the manager thread will never be killed, so you still have
+2 threads, which means you cannot safely run a death test.
+
+The new NPTL thread library doesn't suffer from this problem, as it doesn't
+create a manager thread. However, if you don't control which machine your test
+runs on, you shouldn't depend on this.
+
+## Why does Google Test require the entire test case, instead of individual tests, to be named FOODeathTest when it uses ASSERT\_DEATH? ##
+
+Google Test does not interleave tests from different test cases. That is, it
+runs all tests in one test case first, and then runs all tests in the next test
+case, and so on. Google Test does this because it needs to set up a test case
+before the first test in it is run, and tear it down afterwords. Splitting up
+the test case would require multiple set-up and tear-down processes, which is
+inefficient and makes the semantics unclean.
+
+If we were to determine the order of tests based on test name instead of test
+case name, then we would have a problem with the following situation:
+
+```
+TEST_F(FooTest, AbcDeathTest) { ... }
+TEST_F(FooTest, Uvw) { ... }
+
+TEST_F(BarTest, DefDeathTest) { ... }
+TEST_F(BarTest, Xyz) { ... }
+```
+
+Since `FooTest.AbcDeathTest` needs to run before `BarTest.Xyz`, and we don't
+interleave tests from different test cases, we need to run all tests in the
+`FooTest` case before running any test in the `BarTest` case. This contradicts
+with the requirement to run `BarTest.DefDeathTest` before `FooTest.Uvw`.
+
+## But I don't like calling my entire test case FOODeathTest when it contains both death tests and non-death tests. What do I do? ##
+
+You don't have to, but if you like, you may split up the test case into
+`FooTest` and `FooDeathTest`, where the names make it clear that they are
+related:
+
+```
+class FooTest : public ::testing::Test { ... };
+
+TEST_F(FooTest, Abc) { ... }
+TEST_F(FooTest, Def) { ... }
+
+typedef FooTest FooDeathTest;
+
+TEST_F(FooDeathTest, Uvw) { ... EXPECT_DEATH(...) ... }
+TEST_F(FooDeathTest, Xyz) { ... ASSERT_DEATH(...) ... }
+```
+
+## The compiler complains about "no match for 'operator<<'" when I use an assertion. What gives? ##
+
+If you use a user-defined type `FooType` in an assertion, you must make sure
+there is an `std::ostream& operator<<(std::ostream&, const FooType&)` function
+defined such that we can print a value of `FooType`.
+
+In addition, if `FooType` is declared in a name space, the `<<` operator also
+needs to be defined in the _same_ name space.
+
+## How do I suppress the memory leak messages on Windows? ##
+
+Since the statically initialized Google Test singleton requires allocations on
+the heap, the Visual C++ memory leak detector will report memory leaks at the
+end of the program run. The easiest way to avoid this is to use the
+`_CrtMemCheckpoint` and `_CrtMemDumpAllObjectsSince` calls to not report any
+statically initialized heap objects. See MSDN for more details and additional
+heap check/debug routines.
+
+## I am building my project with Google Test in Visual Studio and all I'm getting is a bunch of linker errors (or warnings). Help! ##
+
+You may get a number of the following linker error or warnings if you
+attempt to link your test project with the Google Test library when
+your project and the are not built using the same compiler settings.
+
+  * LNK2005: symbol already defined in object
+  * LNK4217: locally defined symbol 'symbol' imported in function 'function'
+  * LNK4049: locally defined symbol 'symbol' imported
+
+The Google Test project (gtest.vcproj) has the Runtime Library option
+set to /MT (use multi-threaded static libraries, /MTd for debug). If
+your project uses something else, for example /MD (use multi-threaded
+DLLs, /MDd for debug), you need to change the setting in the Google
+Test project to match your project's.
+
+To update this setting open the project properties in the Visual
+Studio IDE then select the branch Configuration Properties | C/C++ |
+Code Generation and change the option "Runtime Library".  You may also try
+using gtest-md.vcproj instead of gtest.vcproj.
+
+## I put my tests in a library and Google Test doesn't run them. What's happening? ##
+Have you read a
+[warning](V1_6_Primer.md#important-note-for-visual-c-users) on
+the Google Test Primer page?
+
+## I want to use Google Test with Visual Studio but don't know where to start. ##
+Many people are in your position and one of the posted his solution to
+our mailing list. Here is his link:
+http://hassanjamilahmad.blogspot.com/2009/07/gtest-starters-help.html.
+
+## I am seeing compile errors mentioning std::type\_traits when I try to use Google Test on Solaris. ##
+Google Test uses parts of the standard C++ library that SunStudio does not support.
+Our users reported success using alternative implementations. Try running the build after runing this commad:
+
+`export CC=cc CXX=CC CXXFLAGS='-library=stlport4'`
+
+## How can my code detect if it is running in a test? ##
+
+If you write code that sniffs whether it's running in a test and does
+different things accordingly, you are leaking test-only logic into
+production code and there is no easy way to ensure that the test-only
+code paths aren't run by mistake in production.  Such cleverness also
+leads to
+[Heisenbugs](http://en.wikipedia.org/wiki/Unusual_software_bug#Heisenbug).
+Therefore we strongly advise against the practice, and Google Test doesn't
+provide a way to do it.
+
+In general, the recommended way to cause the code to behave
+differently under test is [dependency injection](http://jamesshore.com/Blog/Dependency-Injection-Demystified.html).
+You can inject different functionality from the test and from the
+production code.  Since your production code doesn't link in the
+for-test logic at all, there is no danger in accidentally running it.
+
+However, if you _really_, _really_, _really_ have no choice, and if
+you follow the rule of ending your test program names with `_test`,
+you can use the _horrible_ hack of sniffing your executable name
+(`argv[0]` in `main()`) to know whether the code is under test.
+
+## Google Test defines a macro that clashes with one defined by another library. How do I deal with that? ##
+
+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 Google Test macro clashes with another
+library, you can force Google Test to rename its macro to avoid the
+conflict.
+
+Specifically, if both Google Test and some other code define macro
+`FOO`, you can add
+```
+  -DGTEST_DONT_DEFINE_FOO=1
+```
+to the compiler flags to tell Google Test to change the macro's name
+from `FOO` to `GTEST_FOO`. 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.
+
+Currently, the following `TEST`, `FAIL`, `SUCCEED`, and the basic comparison assertion macros can have alternative names. You can see the full list of covered macros [here](http://www.google.com/codesearch?q=if+!GTEST_DONT_DEFINE_\w%2B+package:http://googletest\.googlecode\.com+file:/include/gtest/gtest.h). More information can be found in the "Avoiding Macro Name Clashes" section of the README file.
+
+## My question is not covered in your FAQ! ##
+
+If you cannot find the answer to your question in this FAQ, there are
+some other resources you can use:
+
+  1. read other [wiki pages](http://code.google.com/p/googletest/w/list),
+  1. search the mailing list [archive](http://groups.google.com/group/googletestframework/topics),
+  1. ask it on [googletestframework@googlegroups.com](mailto:googletestframework@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googletestframework) before you can post.).
+
+Please note that creating an issue in the
+[issue tracker](http://code.google.com/p/googletest/issues/list) is _not_
+a good way to get your answer, as it is monitored infrequently by a
+very small number of people.
+
+When asking a question, it's helpful to provide as much of the
+following information as possible (people cannot help you if there's
+not enough information in your question):
+
+  * the version (or the revision number if you check out from SVN directly) of Google Test you use (Google Test is under active development, so it's possible that your problem has been solved in a later version),
+  * your operating system,
+  * the name and version of your compiler,
+  * the complete command line flags you give to your compiler,
+  * the complete compiler error messages (if the question is about compilation),
+  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Primer.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Primer.md
new file mode 100644
index 00000000..8d840ef4
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Primer.md
@@ -0,0 +1,501 @@
+
+
+# Introduction: Why Google C++ Testing Framework? #
+
+_Google C++ Testing Framework_ helps you write better C++ tests.
+
+No matter whether you work on Linux, Windows, or a Mac, if you write C++ code,
+Google Test can help you.
+
+So what makes a good test, and how does Google C++ Testing Framework fit in? We believe:
+  1. Tests should be _independent_ and _repeatable_. It's a pain to debug a test that succeeds or fails as a result of other tests.  Google C++ Testing Framework isolates the tests by running each of them on a different object. When a test fails, Google C++ Testing Framework allows you to run it in isolation for quick debugging.
+  1. Tests should be well _organized_ and reflect the structure of the tested code.  Google C++ Testing Framework groups related tests into test cases that can share data and subroutines. This common pattern is easy to recognize and makes tests easy to maintain. Such consistency is especially helpful when people switch projects and start to work on a new code base.
+  1. Tests should be _portable_ and _reusable_. The open-source community has a lot of code that is platform-neutral, its tests should also be platform-neutral.  Google C++ Testing Framework works on different OSes, with different compilers (gcc, MSVC, and others), with or without exceptions, so Google C++ Testing Framework tests can easily work with a variety of configurations.  (Note that the current release only contains build scripts for Linux - we are actively working on scripts for other platforms.)
+  1. When tests fail, they should provide as much _information_ about the problem as possible. Google C++ Testing Framework doesn't stop at the first test failure. Instead, it only stops the current test and continues with the next. You can also set up tests that report non-fatal failures after which the current test continues. Thus, you can detect and fix multiple bugs in a single run-edit-compile cycle.
+  1. The testing framework should liberate test writers from housekeeping chores and let them focus on the test _content_.  Google C++ Testing Framework automatically keeps track of all tests defined, and doesn't require the user to enumerate them in order to run them.
+  1. Tests should be _fast_. With Google C++ Testing Framework, you can reuse shared resources across tests and pay for the set-up/tear-down only once, without making tests depend on each other.
+
+Since Google C++ Testing Framework is based on the popular xUnit
+architecture, you'll feel right at home if you've used JUnit or PyUnit before.
+If not, it will take you about 10 minutes to learn the basics and get started.
+So let's go!
+
+_Note:_ We sometimes refer to Google C++ Testing Framework informally
+as _Google Test_.
+
+# Setting up a New Test Project #
+
+To write a test program using Google Test, you need to compile Google
+Test into a library and link your test with it.  We provide build
+files for some popular build systems: `msvc/` for Visual Studio,
+`xcode/` for Mac Xcode, `make/` for GNU make, `codegear/` for Borland
+C++ Builder, and the autotools script (deprecated) and
+`CMakeLists.txt` for CMake (recommended) in the Google Test root
+directory.  If your build system is not on this list, you can take a
+look at `make/Makefile` to learn how Google Test should be compiled
+(basically you want to compile `src/gtest-all.cc` with `GTEST_ROOT`
+and `GTEST_ROOT/include` in the header search path, where `GTEST_ROOT`
+is the Google Test root directory).
+
+Once you are able to compile the Google Test library, you should
+create a project or build target for your test program.  Make sure you
+have `GTEST_ROOT/include` in the header search path so that the
+compiler can find `"gtest/gtest.h"` when compiling your test.  Set up
+your test project to link with the Google Test library (for example,
+in Visual Studio, this is done by adding a dependency on
+`gtest.vcproj`).
+
+If you still have questions, take a look at how Google Test's own
+tests are built and use them as examples.
+
+# Basic Concepts #
+
+When using Google Test, you start by writing _assertions_, which are statements
+that check whether a condition is true. An assertion's result can be _success_,
+_nonfatal failure_, or _fatal failure_. If a fatal failure occurs, it aborts
+the current function; otherwise the program continues normally.
+
+_Tests_ use assertions to verify the tested code's behavior. If a test crashes
+or has a failed assertion, then it _fails_; otherwise it _succeeds_.
+
+A _test case_ contains one or many tests. You should group your tests into test
+cases that reflect the structure of the tested code. When multiple tests in a
+test case need to share common objects and subroutines, you can put them into a
+_test fixture_ class.
+
+A _test program_ can contain multiple test cases.
+
+We'll now explain how to write a test program, starting at the individual
+assertion level and building up to tests and test cases.
+
+# Assertions #
+
+Google Test assertions are macros that resemble function calls. You test a
+class or function by making assertions about its behavior. When an assertion
+fails, Google Test prints the assertion's source file and line number location,
+along with a failure message. You may also supply a custom failure message
+which will be appended to Google Test's message.
+
+The assertions come in pairs that test the same thing but have different
+effects on the current function. `ASSERT_*` versions generate fatal failures
+when they fail, and **abort the current function**. `EXPECT_*` versions generate
+nonfatal failures, which don't abort the current function. Usually `EXPECT_*`
+are preferred, as they allow more than one failures to be reported in a test.
+However, you should use `ASSERT_*` if it doesn't make sense to continue when
+the assertion in question fails.
+
+Since a failed `ASSERT_*` returns from the current function immediately,
+possibly skipping clean-up code that comes after it, it may cause a space leak.
+Depending on the nature of the leak, it may or may not be worth fixing - so
+keep this in mind if you get a heap checker error in addition to assertion
+errors.
+
+To provide a custom failure message, simply stream it into the macro using the
+`<<` operator, or a sequence of such operators. An example:
+```
+ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length";
+
+for (int i = 0; i < x.size(); ++i) {
+  EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i;
+}
+```
+
+Anything that can be streamed to an `ostream` can be streamed to an assertion
+macro--in particular, C strings and `string` objects. If a wide string
+(`wchar_t*`, `TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is
+streamed to an assertion, it will be translated to UTF-8 when printed.
+
+## Basic Assertions ##
+
+These assertions do basic true/false condition testing.
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_TRUE(`_condition_`)`;  | `EXPECT_TRUE(`_condition_`)`;   | _condition_ is true |
+| `ASSERT_FALSE(`_condition_`)`; | `EXPECT_FALSE(`_condition_`)`;  | _condition_ is false |
+
+Remember, when they fail, `ASSERT_*` yields a fatal failure and
+returns from the current function, while `EXPECT_*` yields a nonfatal
+failure, allowing the function to continue running. In either case, an
+assertion failure means its containing test fails.
+
+_Availability_: Linux, Windows, Mac.
+
+## Binary Comparison ##
+
+This section describes assertions that compare two values.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+|`ASSERT_EQ(`_expected_`, `_actual_`);`|`EXPECT_EQ(`_expected_`, `_actual_`);`| _expected_ `==` _actual_ |
+|`ASSERT_NE(`_val1_`, `_val2_`);`      |`EXPECT_NE(`_val1_`, `_val2_`);`      | _val1_ `!=` _val2_ |
+|`ASSERT_LT(`_val1_`, `_val2_`);`      |`EXPECT_LT(`_val1_`, `_val2_`);`      | _val1_ `<` _val2_ |
+|`ASSERT_LE(`_val1_`, `_val2_`);`      |`EXPECT_LE(`_val1_`, `_val2_`);`      | _val1_ `<=` _val2_ |
+|`ASSERT_GT(`_val1_`, `_val2_`);`      |`EXPECT_GT(`_val1_`, `_val2_`);`      | _val1_ `>` _val2_ |
+|`ASSERT_GE(`_val1_`, `_val2_`);`      |`EXPECT_GE(`_val1_`, `_val2_`);`      | _val1_ `>=` _val2_ |
+
+In the event of a failure, Google Test prints both _val1_ and _val2_
+. In `ASSERT_EQ*` and `EXPECT_EQ*` (and all other equality assertions
+we'll introduce later), you should put the expression you want to test
+in the position of _actual_, and put its expected value in _expected_,
+as Google Test's failure messages are optimized for this convention.
+
+Value arguments must be comparable by the assertion's comparison
+operator or you'll get a compiler error.  We used to require the
+arguments to support the `<<` operator for streaming to an `ostream`,
+but it's no longer necessary since v1.6.0 (if `<<` is supported, it
+will be called to print the arguments when the assertion fails;
+otherwise Google Test will attempt to print them in the best way it
+can. For more details and how to customize the printing of the
+arguments, see this Google Mock [recipe](../../googlemock/docs/CookBook.md#teaching-google-mock-how-to-print-your-values).).
+
+These assertions can work with a user-defined type, but only if you define the
+corresponding comparison operator (e.g. `==`, `<`, etc).  If the corresponding
+operator is defined, prefer using the `ASSERT_*()` macros because they will
+print out not only the result of the comparison, but the two operands as well.
+
+Arguments are always evaluated exactly once. Therefore, it's OK for the
+arguments to have side effects. However, as with any ordinary C/C++ function,
+the arguments' evaluation order is undefined (i.e. the compiler is free to
+choose any order) and your code should not depend on any particular argument
+evaluation order.
+
+`ASSERT_EQ()` does pointer equality on pointers. If used on two C strings, it
+tests if they are in the same memory location, not if they have the same value.
+Therefore, if you want to compare C strings (e.g. `const char*`) by value, use
+`ASSERT_STREQ()` , which will be described later on. In particular, to assert
+that a C string is `NULL`, use `ASSERT_STREQ(NULL, c_string)` . However, to
+compare two `string` objects, you should use `ASSERT_EQ`.
+
+Macros in this section work with both narrow and wide string objects (`string`
+and `wstring`).
+
+_Availability_: Linux, Windows, Mac.
+
+## String Comparison ##
+
+The assertions in this group compare two **C strings**. If you want to compare
+two `string` objects, use `EXPECT_EQ`, `EXPECT_NE`, and etc instead.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_STREQ(`_expected\_str_`, `_actual\_str_`);`    | `EXPECT_STREQ(`_expected\_str_`, `_actual\_str_`);`     | the two C strings have the same content |
+| `ASSERT_STRNE(`_str1_`, `_str2_`);`    | `EXPECT_STRNE(`_str1_`, `_str2_`);`     | the two C strings have different content |
+| `ASSERT_STRCASEEQ(`_expected\_str_`, `_actual\_str_`);`| `EXPECT_STRCASEEQ(`_expected\_str_`, `_actual\_str_`);` | the two C strings have the same content, ignoring case |
+| `ASSERT_STRCASENE(`_str1_`, `_str2_`);`| `EXPECT_STRCASENE(`_str1_`, `_str2_`);` | the two C strings have different content, ignoring case |
+
+Note that "CASE" in an assertion name means that case is ignored.
+
+`*STREQ*` and `*STRNE*` also accept wide C strings (`wchar_t*`). If a
+comparison of two wide strings fails, their values will be printed as UTF-8
+narrow strings.
+
+A `NULL` pointer and an empty string are considered _different_.
+
+_Availability_: Linux, Windows, Mac.
+
+See also: For more string comparison tricks (substring, prefix, suffix, and
+regular expression matching, for example), see the [Advanced Google Test Guide](V1_6_AdvancedGuide.md).
+
+# Simple Tests #
+
+To create a test:
+  1. Use the `TEST()` macro to define and name a test function, These are ordinary C++ functions that don't return a value.
+  1. In this function, along with any valid C++ statements you want to include, use the various Google Test assertions to check values.
+  1. The test's result is determined by the assertions; if any assertion in the test fails (either fatally or non-fatally), or if the test crashes, the entire test fails. Otherwise, it succeeds.
+
+```
+TEST(test_case_name, test_name) {
+ ... test body ...
+}
+```
+
+
+`TEST()` arguments go from general to specific. The _first_ argument is the
+name of the test case, and the _second_ argument is the test's name within the
+test case. Both names must be valid C++ identifiers, and they should not contain underscore (`_`). A test's _full name_ consists of its containing test case and its
+individual name. Tests from different test cases can have the same individual
+name.
+
+For example, let's take a simple integer function:
+```
+int Factorial(int n); // Returns the factorial of n
+```
+
+A test case for this function might look like:
+```
+// Tests factorial of 0.
+TEST(FactorialTest, HandlesZeroInput) {
+  EXPECT_EQ(1, Factorial(0));
+}
+
+// Tests factorial of positive numbers.
+TEST(FactorialTest, HandlesPositiveInput) {
+  EXPECT_EQ(1, Factorial(1));
+  EXPECT_EQ(2, Factorial(2));
+  EXPECT_EQ(6, Factorial(3));
+  EXPECT_EQ(40320, Factorial(8));
+}
+```
+
+Google Test groups the test results by test cases, so logically-related tests
+should be in the same test case; in other words, the first argument to their
+`TEST()` should be the same. In the above example, we have two tests,
+`HandlesZeroInput` and `HandlesPositiveInput`, that belong to the same test
+case `FactorialTest`.
+
+_Availability_: Linux, Windows, Mac.
+
+# Test Fixtures: Using the Same Data Configuration for Multiple Tests #
+
+If you find yourself writing two or more tests that operate on similar data,
+you can use a _test fixture_. It allows you to reuse the same configuration of
+objects for several different tests.
+
+To create a fixture, just:
+  1. Derive a class from `::testing::Test` . Start its body with `protected:` or `public:` as we'll want to access fixture members from sub-classes.
+  1. Inside the class, declare any objects you plan to use.
+  1. If necessary, write a default constructor or `SetUp()` function to prepare the objects for each test. A common mistake is to spell `SetUp()` as `Setup()` with a small `u` - don't let that happen to you.
+  1. If necessary, write a destructor or `TearDown()` function to release any resources you allocated in `SetUp()` . To learn when you should use the constructor/destructor and when you should use `SetUp()/TearDown()`, read this [FAQ entry](V1_6_FAQ.md#should-i-use-the-constructordestructor-of-the-test-fixture-or-the-set-uptear-down-function).
+  1. If needed, define subroutines for your tests to share.
+
+When using a fixture, use `TEST_F()` instead of `TEST()` as it allows you to
+access objects and subroutines in the test fixture:
+```
+TEST_F(test_case_name, test_name) {
+ ... test body ...
+}
+```
+
+Like `TEST()`, the first argument is the test case name, but for `TEST_F()`
+this must be the name of the test fixture class. You've probably guessed: `_F`
+is for fixture.
+
+Unfortunately, the C++ macro system does not allow us to create a single macro
+that can handle both types of tests. Using the wrong macro causes a compiler
+error.
+
+Also, you must first define a test fixture class before using it in a
+`TEST_F()`, or you'll get the compiler error "`virtual outside class
+declaration`".
+
+For each test defined with `TEST_F()`, Google Test will:
+  1. Create a _fresh_ test fixture at runtime
+  1. Immediately initialize it via `SetUp()` ,
+  1. Run the test
+  1. Clean up by calling `TearDown()`
+  1. Delete the test fixture.  Note that different tests in the same test case have different test fixture objects, and Google Test always deletes a test fixture before it creates the next one. Google Test does not reuse the same test fixture for multiple tests. Any changes one test makes to the fixture do not affect other tests.
+
+As an example, let's write tests for a FIFO queue class named `Queue`, which
+has the following interface:
+```
+template <typename E> // E is the element type.
+class Queue {
+ public:
+  Queue();
+  void Enqueue(const E& element);
+  E* Dequeue(); // Returns NULL if the queue is empty.
+  size_t size() const;
+  ...
+};
+```
+
+First, define a fixture class. By convention, you should give it the name
+`FooTest` where `Foo` is the class being tested.
+```
+class QueueTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    q1_.Enqueue(1);
+    q2_.Enqueue(2);
+    q2_.Enqueue(3);
+  }
+
+  // virtual void TearDown() {}
+
+  Queue<int> q0_;
+  Queue<int> q1_;
+  Queue<int> q2_;
+};
+```
+
+In this case, `TearDown()` is not needed since we don't have to clean up after
+each test, other than what's already done by the destructor.
+
+Now we'll write tests using `TEST_F()` and this fixture.
+```
+TEST_F(QueueTest, IsEmptyInitially) {
+  EXPECT_EQ(0, q0_.size());
+}
+
+TEST_F(QueueTest, DequeueWorks) {
+  int* n = q0_.Dequeue();
+  EXPECT_EQ(NULL, n);
+
+  n = q1_.Dequeue();
+  ASSERT_TRUE(n != NULL);
+  EXPECT_EQ(1, *n);
+  EXPECT_EQ(0, q1_.size());
+  delete n;
+
+  n = q2_.Dequeue();
+  ASSERT_TRUE(n != NULL);
+  EXPECT_EQ(2, *n);
+  EXPECT_EQ(1, q2_.size());
+  delete n;
+}
+```
+
+The above uses both `ASSERT_*` and `EXPECT_*` assertions. The rule of thumb is
+to use `EXPECT_*` when you want the test to continue to reveal more errors
+after the assertion failure, and use `ASSERT_*` when continuing after failure
+doesn't make sense. For example, the second assertion in the `Dequeue` test is
+`ASSERT_TRUE(n != NULL)`, as we need to dereference the pointer `n` later,
+which would lead to a segfault when `n` is `NULL`.
+
+When these tests run, the following happens:
+  1. Google Test constructs a `QueueTest` object (let's call it `t1` ).
+  1. `t1.SetUp()` initializes `t1` .
+  1. The first test ( `IsEmptyInitially` ) runs on `t1` .
+  1. `t1.TearDown()` cleans up after the test finishes.
+  1. `t1` is destructed.
+  1. The above steps are repeated on another `QueueTest` object, this time running the `DequeueWorks` test.
+
+_Availability_: Linux, Windows, Mac.
+
+_Note_: Google Test automatically saves all _Google Test_ flags when a test
+object is constructed, and restores them when it is destructed.
+
+# Invoking the Tests #
+
+`TEST()` and `TEST_F()` implicitly register their tests with Google Test. So, unlike with many other C++ testing frameworks, you don't have to re-list all your defined tests in order to run them.
+
+After defining your tests, you can run them with `RUN_ALL_TESTS()` , which returns `0` if all the tests are successful, or `1` otherwise. Note that `RUN_ALL_TESTS()` runs _all tests_ in your link unit -- they can be from different test cases, or even different source files.
+
+When invoked, the `RUN_ALL_TESTS()` macro:
+  1. Saves the state of all  Google Test flags.
+  1. Creates a test fixture object for the first test.
+  1. Initializes it via `SetUp()`.
+  1. Runs the test on the fixture object.
+  1. Cleans up the fixture via `TearDown()`.
+  1. Deletes the fixture.
+  1. Restores the state of all Google Test flags.
+  1. Repeats the above steps for the next test, until all tests have run.
+
+In addition, if the text fixture's constructor generates a fatal failure in
+step 2, there is no point for step 3 - 5 and they are thus skipped. Similarly,
+if step 3 generates a fatal failure, step 4 will be skipped.
+
+_Important_: You must not ignore the return value of `RUN_ALL_TESTS()`, or `gcc`
+will give you a compiler error. The rationale for this design is that the
+automated testing service determines whether a test has passed based on its
+exit code, not on its stdout/stderr output; thus your `main()` function must
+return the value of `RUN_ALL_TESTS()`.
+
+Also, you should call `RUN_ALL_TESTS()` only **once**. Calling it more than once
+conflicts with some advanced Google Test features (e.g. thread-safe death
+tests) and thus is not supported.
+
+_Availability_: Linux, Windows, Mac.
+
+# Writing the main() Function #
+
+You can start from this boilerplate:
+```
+#include "this/package/foo.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+// The fixture for testing class Foo.
+class FooTest : public ::testing::Test {
+ protected:
+  // You can remove any or all of the following functions if its body
+  // is empty.
+
+  FooTest() {
+    // You can do set-up work for each test here.
+  }
+
+  virtual ~FooTest() {
+    // You can do clean-up work that doesn't throw exceptions here.
+  }
+
+  // If the constructor and destructor are not enough for setting up
+  // and cleaning up each test, you can define the following methods:
+
+  virtual void SetUp() {
+    // Code here will be called immediately after the constructor (right
+    // before each test).
+  }
+
+  virtual void TearDown() {
+    // Code here will be called immediately after each test (right
+    // before the destructor).
+  }
+
+  // Objects declared here can be used by all tests in the test case for Foo.
+};
+
+// Tests that the Foo::Bar() method does Abc.
+TEST_F(FooTest, MethodBarDoesAbc) {
+  const string input_filepath = "this/package/testdata/myinputfile.dat";
+  const string output_filepath = "this/package/testdata/myoutputfile.dat";
+  Foo f;
+  EXPECT_EQ(0, f.Bar(input_filepath, output_filepath));
+}
+
+// Tests that Foo does Xyz.
+TEST_F(FooTest, DoesXyz) {
+  // Exercises the Xyz feature of Foo.
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+```
+
+The `::testing::InitGoogleTest()` function parses the command line for Google
+Test flags, and removes all recognized flags. This allows the user to control a
+test program's behavior via various flags, which we'll cover in [AdvancedGuide](V1_6_AdvancedGuide.md).
+You must call this function before calling `RUN_ALL_TESTS()`, or the flags
+won't be properly initialized.
+
+On Windows, `InitGoogleTest()` also works with wide strings, so it can be used
+in programs compiled in `UNICODE` mode as well.
+
+But maybe you think that writing all those main() functions is too much work? We agree with you completely and that's why Google Test provides a basic implementation of main(). If it fits your needs, then just link your test with gtest\_main library and you are good to go.
+
+## Important note for Visual C++ users ##
+If you put your tests into a library and your `main()` function is in a different library or in your .exe file, those tests will not run. The reason is a [bug](https://connect.microsoft.com/feedback/viewfeedback.aspx?FeedbackID=244410&siteid=210) in Visual C++. When you define your tests, Google Test creates certain static objects to register them. These objects are not referenced from elsewhere but their constructors are still supposed to run. When Visual C++ linker sees that nothing in the library is referenced from other places it throws the library out. You have to reference your library with tests from your main program to keep the linker from discarding it. Here is how to do it. Somewhere in your library code declare a function:
+```
+__declspec(dllexport) int PullInMyLibrary() { return 0; }
+```
+If you put your tests in a static library (not DLL) then `__declspec(dllexport)` is not required. Now, in your main program, write a code that invokes that function:
+```
+int PullInMyLibrary();
+static int dummy = PullInMyLibrary();
+```
+This will keep your tests referenced and will make them register themselves at startup.
+
+In addition, if you define your tests in a static library, add `/OPT:NOREF` to your main program linker options. If you use MSVC++ IDE, go to your .exe project properties/Configuration Properties/Linker/Optimization and set References setting to `Keep Unreferenced Data (/OPT:NOREF)`. This will keep Visual C++ linker from discarding individual symbols generated by your tests from the final executable.
+
+There is one more pitfall, though. If you use Google Test as a static library (that's how it is defined in gtest.vcproj) your tests must also reside in a static library. If you have to have them in a DLL, you _must_ change Google Test to build into a DLL as well. Otherwise your tests will not run correctly or will not run at all. The general conclusion here is: make your life easier - do not write your tests in libraries!
+
+# Where to Go from Here #
+
+Congratulations! You've learned the Google Test basics. You can start writing
+and running Google Test tests, read some [samples](V1_6_Samples.md), or continue with
+[AdvancedGuide](V1_6_AdvancedGuide.md), which describes many more useful Google Test features.
+
+# Known Limitations #
+
+Google Test is designed to be thread-safe.  The implementation is
+thread-safe on systems where the `pthreads` library is available.  It
+is currently _unsafe_ to use Google Test assertions from two threads
+concurrently on other systems (e.g. Windows).  In most tests this is
+not an issue as usually the assertions are done in the main thread. If
+you want to help, you can volunteer to implement the necessary
+synchronization primitives in `gtest-port.h` for your platform.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_PumpManual.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_PumpManual.md
new file mode 100644
index 00000000..8184f153
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_PumpManual.md
@@ -0,0 +1,177 @@
+
+
+<b>P</b>ump is <b>U</b>seful for <b>M</b>eta <b>P</b>rogramming.
+
+# The Problem #
+
+Template and macro libraries often need to define many classes,
+functions, or macros that vary only (or almost only) in the number of
+arguments they take. It's a lot of repetitive, mechanical, and
+error-prone work.
+
+Variadic templates and variadic macros can alleviate the problem.
+However, while both are being considered by the C++ committee, neither
+is in the standard yet or widely supported by compilers.  Thus they
+are often not a good choice, especially when your code needs to be
+portable. And their capabilities are still limited.
+
+As a result, authors of such libraries often have to write scripts to
+generate their implementation. However, our experience is that it's
+tedious to write such scripts, which tend to reflect the structure of
+the generated code poorly and are often hard to read and edit. For
+example, a small change needed in the generated code may require some
+non-intuitive, non-trivial changes in the script. This is especially
+painful when experimenting with the code.
+
+# Our Solution #
+
+Pump (for Pump is Useful for Meta Programming, Pretty Useful for Meta
+Programming, or Practical Utility for Meta Programming, whichever you
+prefer) is a simple meta-programming tool for C++. The idea is that a
+programmer writes a `foo.pump` file which contains C++ code plus meta
+code that manipulates the C++ code. The meta code can handle
+iterations over a range, nested iterations, local meta variable
+definitions, simple arithmetic, and conditional expressions. You can
+view it as a small Domain-Specific Language. The meta language is
+designed to be non-intrusive (s.t. it won't confuse Emacs' C++ mode,
+for example) and concise, making Pump code intuitive and easy to
+maintain.
+
+## Highlights ##
+
+  * The implementation is in a single Python script and thus ultra portable: no build or installation is needed and it works cross platforms.
+  * Pump tries to be smart with respect to [Google's style guide](http://code.google.com/p/google-styleguide/): it breaks long lines (easy to have when they are generated) at acceptable places to fit within 80 columns and indent the continuation lines correctly.
+  * The format is human-readable and more concise than XML.
+  * The format works relatively well with Emacs' C++ mode.
+
+## Examples ##
+
+The following Pump code (where meta keywords start with `$`, `[[` and `]]` are meta brackets, and `$$` starts a meta comment that ends with the line):
+
+```
+$var n = 3     $$ Defines a meta variable n.
+$range i 0..n  $$ Declares the range of meta iterator i (inclusive).
+$for i [[
+               $$ Meta loop.
+// Foo$i does blah for $i-ary predicates.
+$range j 1..i
+template <size_t N $for j [[, typename A$j]]>
+class Foo$i {
+$if i == 0 [[
+  blah a;
+]] $elif i <= 2 [[
+  blah b;
+]] $else [[
+  blah c;
+]]
+};
+
+]]
+```
+
+will be translated by the Pump compiler to:
+
+```
+// Foo0 does blah for 0-ary predicates.
+template <size_t N>
+class Foo0 {
+  blah a;
+};
+
+// Foo1 does blah for 1-ary predicates.
+template <size_t N, typename A1>
+class Foo1 {
+  blah b;
+};
+
+// Foo2 does blah for 2-ary predicates.
+template <size_t N, typename A1, typename A2>
+class Foo2 {
+  blah b;
+};
+
+// Foo3 does blah for 3-ary predicates.
+template <size_t N, typename A1, typename A2, typename A3>
+class Foo3 {
+  blah c;
+};
+```
+
+In another example,
+
+```
+$range i 1..n
+Func($for i + [[a$i]]);
+$$ The text between i and [[ is the separator between iterations.
+```
+
+will generate one of the following lines (without the comments), depending on the value of `n`:
+
+```
+Func();              // If n is 0.
+Func(a1);            // If n is 1.
+Func(a1 + a2);       // If n is 2.
+Func(a1 + a2 + a3);  // If n is 3.
+// And so on...
+```
+
+## Constructs ##
+
+We support the following meta programming constructs:
+
+| `$var id = exp` | Defines a named constant value. `$id` is valid util the end of the current meta lexical block. |
+|:----------------|:-----------------------------------------------------------------------------------------------|
+| `$range id exp..exp` | Sets the range of an iteration variable, which can be reused in multiple loops later.          |
+| `$for id sep [[ code ]]` | Iteration. The range of `id` must have been defined earlier. `$id` is valid in `code`.         |
+| `$($)`          | Generates a single `$` character.                                                              |
+| `$id`           | Value of the named constant or iteration variable.                                             |
+| `$(exp)`        | Value of the expression.                                                                       |
+| `$if exp [[ code ]] else_branch` | Conditional.                                                                                   |
+| `[[ code ]]`    | Meta lexical block.                                                                            |
+| `cpp_code`      | Raw C++ code.                                                                                  |
+| `$$ comment`    | Meta comment.                                                                                  |
+
+**Note:** To give the user some freedom in formatting the Pump source
+code, Pump ignores a new-line character if it's right after `$for foo`
+or next to `[[` or `]]`. Without this rule you'll often be forced to write
+very long lines to get the desired output. Therefore sometimes you may
+need to insert an extra new-line in such places for a new-line to show
+up in your output.
+
+## Grammar ##
+
+```
+code ::= atomic_code*
+atomic_code ::= $var id = exp
+    | $var id = [[ code ]]
+    | $range id exp..exp
+    | $for id sep [[ code ]]
+    | $($)
+    | $id
+    | $(exp)
+    | $if exp [[ code ]] else_branch
+    | [[ code ]]
+    | cpp_code
+sep ::= cpp_code | empty_string
+else_branch ::= $else [[ code ]]
+    | $elif exp [[ code ]] else_branch
+    | empty_string
+exp ::= simple_expression_in_Python_syntax
+```
+
+## Code ##
+
+You can find the source code of Pump in [scripts/pump.py](../scripts/pump.py). It is still
+very unpolished and lacks automated tests, although it has been
+successfully used many times. If you find a chance to use it in your
+project, please let us know what you think!  We also welcome help on
+improving Pump.
+
+## Real Examples ##
+
+You can find real-world applications of Pump in [Google Test](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgoogletest\.googlecode\.com) and [Google Mock](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgooglemock\.googlecode\.com).  The source file `foo.h.pump` generates `foo.h`.
+
+## Tips ##
+
+  * If a meta variable is followed by a letter or digit, you can separate them using `[[]]`, which inserts an empty string. For example `Foo$j[[]]Helper` generate `Foo1Helper` when `j` is 1.
+  * To avoid extra-long Pump source lines, you can break a line anywhere you want by inserting `[[]]` followed by a new line. Since any new-line character next to `[[` or `]]` is ignored, the generated code won't contain this new line.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Samples.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Samples.md
new file mode 100644
index 00000000..f21d2005
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Samples.md
@@ -0,0 +1,14 @@
+If you're like us, you'd like to look at some Google Test sample code.  The
+[samples folder](../samples) has a number of well-commented samples showing how to use a
+variety of Google Test features.
+
+  * [Sample #1](../samples/sample1_unittest.cc) shows the basic steps of using Google Test to test C++ functions.
+  * [Sample #2](../samples/sample2_unittest.cc) shows a more complex unit test for a class with multiple member functions.
+  * [Sample #3](../samples/sample3_unittest.cc) uses a test fixture.
+  * [Sample #4](../samples/sample4_unittest.cc) is another basic example of using Google Test.
+  * [Sample #5](../samples/sample5_unittest.cc) teaches how to reuse a test fixture in multiple test cases by deriving sub-fixtures from it.
+  * [Sample #6](../samples/sample6_unittest.cc) demonstrates type-parameterized tests.
+  * [Sample #7](../samples/sample7_unittest.cc) teaches the basics of value-parameterized tests.
+  * [Sample #8](../samples/sample8_unittest.cc) shows using `Combine()` in value-parameterized tests.
+  * [Sample #9](../samples/sample9_unittest.cc) shows use of the listener API to modify Google Test's console output and the use of its reflection API to inspect test results.
+  * [Sample #10](../samples/sample10_unittest.cc) shows use of the listener API to implement a primitive memory leak checker.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_XcodeGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_XcodeGuide.md
new file mode 100644
index 00000000..bf24bf51
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_XcodeGuide.md
@@ -0,0 +1,93 @@
+
+
+This guide will explain how to use the Google Testing Framework in your Xcode projects on Mac OS X. This tutorial begins by quickly explaining what to do for experienced users. After the quick start, the guide goes provides additional explanation about each step.
+
+# Quick Start #
+
+Here is the quick guide for using Google Test in your Xcode project.
+
+  1. Download the source from the [website](http://code.google.com/p/googletest) using this command: `svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only`
+  1. Open up the `gtest.xcodeproj` in the `googletest-read-only/xcode/` directory and build the gtest.framework.
+  1. Create a new "Shell Tool" target in your Xcode project called something like "UnitTests"
+  1. Add the gtest.framework to your project and add it to the "Link Binary with Libraries" build phase of "UnitTests"
+  1. Add your unit test source code to the "Compile Sources" build phase of "UnitTests"
+  1. Edit the "UnitTests" executable and add an environment variable named "DYLD\_FRAMEWORK\_PATH" with a value equal to the path to the framework containing the gtest.framework relative to the compiled executable.
+  1. Build and Go
+
+The following sections further explain each of the steps listed above in depth, describing in more detail how to complete it including some variations.
+
+# Get the Source #
+
+Currently, the gtest.framework discussed here isn't available in a tagged release of Google Test, it is only available in the trunk. As explained at the Google Test [site](http://code.google.com/p/googletest/source/checkout">svn), you can get the code from anonymous SVN with this command:
+
+```
+svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only
+```
+
+Alternatively, if you are working with Subversion in your own code base, you can add Google Test as an external dependency to your own Subversion repository. By following this approach, everyone that checks out your svn repository will also receive a copy of Google Test (a specific version, if you wish) without having to check it out explicitly. This makes the set up of your project simpler and reduces the copied code in the repository.
+
+To use `svn:externals`, decide where you would like to have the external source reside. You might choose to put the external source inside the trunk, because you want it to be part of the branch when you make a release. However, keeping it outside the trunk in a version-tagged directory called something like `third-party/googletest/1.0.1`, is another option. Once the location is established, use `svn propedit svn:externals _directory_` to set the svn:externals property on a directory in your repository. This directory won't contain the code, but be its versioned parent directory.
+
+The command `svn propedit` will bring up your Subversion editor, making editing the long, (potentially multi-line) property simpler. This same method can be used to check out a tagged branch, by using the appropriate URL (e.g. `http://googletest.googlecode.com/svn/tags/release-1.0.1`). Additionally, the svn:externals property allows the specification of a particular revision of the trunk with the `-r_##_` option (e.g. `externals/src/googletest -r60 http://googletest.googlecode.com/svn/trunk`).
+
+Here is an example of using the svn:externals properties on a trunk (read via `svn propget`) of a project. This value checks out a copy of Google Test into the `trunk/externals/src/googletest/` directory.
+
+```
+[Computer:svn] user$ svn propget svn:externals trunk
+externals/src/googletest http://googletest.googlecode.com/svn/trunk
+```
+
+# Add the Framework to Your Project #
+
+The next step is to build and add the gtest.framework to your own project. This guide describes two common ways below.
+
+  * **Option 1** --- The simplest way to add Google Test to your own project, is to open gtest.xcodeproj (found in the xcode/ directory of the Google Test trunk) and build the framework manually. Then, add the built framework into your project using the "Add->Existing Framework..." from the context menu or "Project->Add..." from the main menu. The gtest.framework is relocatable and contains the headers and object code that you'll need to make tests. This method requires rebuilding every time you upgrade Google Test in your project.
+  * **Option 2** --- If you are going to be living off the trunk of Google Test, incorporating its latest features into your unit tests (or are a Google Test developer yourself). You'll want to rebuild the framework every time the source updates. to do this, you'll need to add the gtest.xcodeproj file, not the framework itself, to your own Xcode project. Then, from the build products that are revealed by the project's disclosure triangle, you can find the gtest.framework, which can be added to your targets (discussed below).
+
+# Make a Test Target #
+
+To start writing tests, make a new "Shell Tool" target. This target template is available under BSD, Cocoa, or Carbon. Add your unit test source code to the "Compile Sources" build phase of the target.
+
+Next, you'll want to add gtest.framework in two different ways, depending upon which option you chose above.
+
+  * **Option 1** --- During compilation, Xcode will need to know that you are linking against the gtest.framework. Add the gtest.framework to the "Link Binary with Libraries" build phase of your test target. This will include the Google Test headers in your header search path, and will tell the linker where to find the library.
+  * **Option 2** --- If your working out of the trunk, you'll also want to add gtest.framework to your "Link Binary with Libraries" build phase of your test target. In addition, you'll  want to add the gtest.framework as a dependency to your unit test target. This way, Xcode will make sure that gtest.framework is up to date, every time your build your target. Finally, if you don't share build directories with Google Test, you'll have to copy the gtest.framework into your own build products directory using a "Run Script" build phase.
+
+# Set Up the Executable Run Environment #
+
+Since the unit test executable is a shell tool, it doesn't have a bundle with a `Contents/Frameworks` directory, in which to place gtest.framework. Instead, the dynamic linker must be told at runtime to search for the framework in another location. This can be accomplished by setting the "DYLD\_FRAMEWORK\_PATH" environment variable in the "Edit Active Executable ..." Arguments tab, under "Variables to be set in the environment:". The path for this value is the path (relative or absolute) of the directory containing the gtest.framework.
+
+If you haven't set up the DYLD\_FRAMEWORK\_PATH, correctly, you might get a message like this:
+
+```
+[Session started at 2008-08-15 06:23:57 -0600.]
+  dyld: Library not loaded: @loader_path/../Frameworks/gtest.framework/Versions/A/gtest
+    Referenced from: /Users/username/Documents/Sandbox/gtestSample/build/Debug/WidgetFrameworkTest
+    Reason: image not found
+```
+
+To correct this problem, got to the directory containing the executable named in "Referenced from:" value in the error message above. Then, with the terminal in this location, find the relative path to the directory containing the gtest.framework. That is the value you'll need to set as the DYLD\_FRAMEWORK\_PATH.
+
+# Build and Go #
+
+Now, when you click "Build and Go", the test will be executed. Dumping out something like this:
+
+```
+[Session started at 2008-08-06 06:36:13 -0600.]
+[==========] Running 2 tests from 1 test case.
+[----------] Global test environment set-up.
+[----------] 2 tests from WidgetInitializerTest
+[ RUN      ] WidgetInitializerTest.TestConstructor
+[       OK ] WidgetInitializerTest.TestConstructor
+[ RUN      ] WidgetInitializerTest.TestConversion
+[       OK ] WidgetInitializerTest.TestConversion
+[----------] Global test environment tear-down
+[==========] 2 tests from 1 test case ran.
+[  PASSED  ] 2 tests.
+
+The Debugger has exited with status 0.  
+```
+
+# Summary #
+
+Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_AdvancedGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_AdvancedGuide.md
new file mode 100644
index 00000000..dd4af8f3
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_AdvancedGuide.md
@@ -0,0 +1,2181 @@
+
+
+Now that you have read [Primer](V1_7_Primer.md) and learned how to write tests
+using Google Test, it's time to learn some new tricks. This document
+will show you more assertions as well as how to construct complex
+failure messages, propagate fatal failures, reuse and speed up your
+test fixtures, and use various flags with your tests.
+
+# More Assertions #
+
+This section covers some less frequently used, but still significant,
+assertions.
+
+## Explicit Success and Failure ##
+
+These three assertions do not actually test a value or expression. Instead,
+they generate a success or failure directly. Like the macros that actually
+perform a test, you may stream a custom failure message into the them.
+
+| `SUCCEED();` |
+|:-------------|
+
+Generates a success. This does NOT make the overall test succeed. A test is
+considered successful only if none of its assertions fail during its execution.
+
+Note: `SUCCEED()` is purely documentary and currently doesn't generate any
+user-visible output. However, we may add `SUCCEED()` messages to Google Test's
+output in the future.
+
+| `FAIL();`  | `ADD_FAILURE();` | `ADD_FAILURE_AT("`_file\_path_`", `_line\_number_`);` |
+|:-----------|:-----------------|:------------------------------------------------------|
+
+`FAIL()` generates a fatal failure, while `ADD_FAILURE()` and `ADD_FAILURE_AT()` generate a nonfatal
+failure. These are useful when control flow, rather than a Boolean expression,
+deteremines the test's success or failure. For example, you might want to write
+something like:
+
+```
+switch(expression) {
+  case 1: ... some checks ...
+  case 2: ... some other checks
+  ...
+  default: FAIL() << "We shouldn't get here.";
+}
+```
+
+_Availability_: Linux, Windows, Mac.
+
+## Exception Assertions ##
+
+These are for verifying that a piece of code throws (or does not
+throw) an exception of the given type:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_THROW(`_statement_, _exception\_type_`);`  | `EXPECT_THROW(`_statement_, _exception\_type_`);`  | _statement_ throws an exception of the given type  |
+| `ASSERT_ANY_THROW(`_statement_`);`                | `EXPECT_ANY_THROW(`_statement_`);`                | _statement_ throws an exception of any type        |
+| `ASSERT_NO_THROW(`_statement_`);`                 | `EXPECT_NO_THROW(`_statement_`);`                 | _statement_ doesn't throw any exception            |
+
+Examples:
+
+```
+ASSERT_THROW(Foo(5), bar_exception);
+
+EXPECT_NO_THROW({
+  int n = 5;
+  Bar(&n);
+});
+```
+
+_Availability_: Linux, Windows, Mac; since version 1.1.0.
+
+## Predicate Assertions for Better Error Messages ##
+
+Even though Google Test has a rich set of assertions, they can never be
+complete, as it's impossible (nor a good idea) to anticipate all the scenarios
+a user might run into. Therefore, sometimes a user has to use `EXPECT_TRUE()`
+to check a complex expression, for lack of a better macro. This has the problem
+of not showing you the values of the parts of the expression, making it hard to
+understand what went wrong. As a workaround, some users choose to construct the
+failure message by themselves, streaming it into `EXPECT_TRUE()`. However, this
+is awkward especially when the expression has side-effects or is expensive to
+evaluate.
+
+Google Test gives you three different options to solve this problem:
+
+### Using an Existing Boolean Function ###
+
+If you already have a function or a functor that returns `bool` (or a type
+that can be implicitly converted to `bool`), you can use it in a _predicate
+assertion_ to get the function arguments printed for free:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_PRED1(`_pred1, val1_`);`       | `EXPECT_PRED1(`_pred1, val1_`);` | _pred1(val1)_ returns true |
+| `ASSERT_PRED2(`_pred2, val1, val2_`);` | `EXPECT_PRED2(`_pred2, val1, val2_`);` |  _pred2(val1, val2)_ returns true |
+|  ...                | ...                    | ...          |
+
+In the above, _predn_ is an _n_-ary predicate function or functor, where
+_val1_, _val2_, ..., and _valn_ are its arguments. The assertion succeeds
+if the predicate returns `true` when applied to the given arguments, and fails
+otherwise. When the assertion fails, it prints the value of each argument. In
+either case, the arguments are evaluated exactly once.
+
+Here's an example. Given
+
+```
+// Returns true iff m and n have no common divisors except 1.
+bool MutuallyPrime(int m, int n) { ... }
+const int a = 3;
+const int b = 4;
+const int c = 10;
+```
+
+the assertion `EXPECT_PRED2(MutuallyPrime, a, b);` will succeed, while the
+assertion `EXPECT_PRED2(MutuallyPrime, b, c);` will fail with the message
+
+<pre>
+!MutuallyPrime(b, c) is false, where<br>
+b is 4<br>
+c is 10<br>
+</pre>
+
+**Notes:**
+
+  1. If you see a compiler error "no matching function to call" when using `ASSERT_PRED*` or `EXPECT_PRED*`, please see [this](V1_7_FAQ.md#the-compiler-complains-about-undefined-references-to-some-static-const-member-variables-but-i-did-define-them-in-the-class-body-whats-wrong) for how to resolve it.
+  1. Currently we only provide predicate assertions of arity <= 5. If you need a higher-arity assertion, let us know.
+
+_Availability_: Linux, Windows, Mac
+
+### Using a Function That Returns an AssertionResult ###
+
+While `EXPECT_PRED*()` and friends are handy for a quick job, the
+syntax is not satisfactory: you have to use different macros for
+different arities, and it feels more like Lisp than C++.  The
+`::testing::AssertionResult` class solves this problem.
+
+An `AssertionResult` object represents the result of an assertion
+(whether it's a success or a failure, and an associated message).  You
+can create an `AssertionResult` using one of these factory
+functions:
+
+```
+namespace testing {
+
+// Returns an AssertionResult object to indicate that an assertion has
+// succeeded.
+AssertionResult AssertionSuccess();
+
+// Returns an AssertionResult object to indicate that an assertion has
+// failed.
+AssertionResult AssertionFailure();
+
+}
+```
+
+You can then use the `<<` operator to stream messages to the
+`AssertionResult` object.
+
+To provide more readable messages in Boolean assertions
+(e.g. `EXPECT_TRUE()`), write a predicate function that returns
+`AssertionResult` instead of `bool`. For example, if you define
+`IsEven()` as:
+
+```
+::testing::AssertionResult IsEven(int n) {
+  if ((n % 2) == 0)
+    return ::testing::AssertionSuccess();
+  else
+    return ::testing::AssertionFailure() << n << " is odd";
+}
+```
+
+instead of:
+
+```
+bool IsEven(int n) {
+  return (n % 2) == 0;
+}
+```
+
+the failed assertion `EXPECT_TRUE(IsEven(Fib(4)))` will print:
+
+<pre>
+Value of: IsEven(Fib(4))<br>
+Actual: false (*3 is odd*)<br>
+Expected: true<br>
+</pre>
+
+instead of a more opaque
+
+<pre>
+Value of: IsEven(Fib(4))<br>
+Actual: false<br>
+Expected: true<br>
+</pre>
+
+If you want informative messages in `EXPECT_FALSE` and `ASSERT_FALSE`
+as well, and are fine with making the predicate slower in the success
+case, you can supply a success message:
+
+```
+::testing::AssertionResult IsEven(int n) {
+  if ((n % 2) == 0)
+    return ::testing::AssertionSuccess() << n << " is even";
+  else
+    return ::testing::AssertionFailure() << n << " is odd";
+}
+```
+
+Then the statement `EXPECT_FALSE(IsEven(Fib(6)))` will print
+
+<pre>
+Value of: IsEven(Fib(6))<br>
+Actual: true (8 is even)<br>
+Expected: false<br>
+</pre>
+
+_Availability_: Linux, Windows, Mac; since version 1.4.1.
+
+### Using a Predicate-Formatter ###
+
+If you find the default message generated by `(ASSERT|EXPECT)_PRED*` and
+`(ASSERT|EXPECT)_(TRUE|FALSE)` unsatisfactory, or some arguments to your
+predicate do not support streaming to `ostream`, you can instead use the
+following _predicate-formatter assertions_ to _fully_ customize how the
+message is formatted:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_PRED_FORMAT1(`_pred\_format1, val1_`);`        | `EXPECT_PRED_FORMAT1(`_pred\_format1, val1_`); | _pred\_format1(val1)_ is successful |
+| `ASSERT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | `EXPECT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | _pred\_format2(val1, val2)_ is successful |
+| `...`               | `...`                  | `...`        |
+
+The difference between this and the previous two groups of macros is that instead of
+a predicate, `(ASSERT|EXPECT)_PRED_FORMAT*` take a _predicate-formatter_
+(_pred\_formatn_), which is a function or functor with the signature:
+
+`::testing::AssertionResult PredicateFormattern(const char* `_expr1_`, const char* `_expr2_`, ... const char* `_exprn_`, T1 `_val1_`, T2 `_val2_`, ... Tn `_valn_`);`
+
+where _val1_, _val2_, ..., and _valn_ are the values of the predicate
+arguments, and _expr1_, _expr2_, ..., and _exprn_ are the corresponding
+expressions as they appear in the source code. The types `T1`, `T2`, ..., and
+`Tn` can be either value types or reference types. For example, if an
+argument has type `Foo`, you can declare it as either `Foo` or `const Foo&`,
+whichever is appropriate.
+
+A predicate-formatter returns a `::testing::AssertionResult` object to indicate
+whether the assertion has succeeded or not. The only way to create such an
+object is to call one of these factory functions:
+
+As an example, let's improve the failure message in the previous example, which uses `EXPECT_PRED2()`:
+
+```
+// Returns the smallest prime common divisor of m and n,
+// or 1 when m and n are mutually prime.
+int SmallestPrimeCommonDivisor(int m, int n) { ... }
+
+// A predicate-formatter for asserting that two integers are mutually prime.
+::testing::AssertionResult AssertMutuallyPrime(const char* m_expr,
+                                               const char* n_expr,
+                                               int m,
+                                               int n) {
+  if (MutuallyPrime(m, n))
+    return ::testing::AssertionSuccess();
+
+  return ::testing::AssertionFailure()
+      << m_expr << " and " << n_expr << " (" << m << " and " << n
+      << ") are not mutually prime, " << "as they have a common divisor "
+      << SmallestPrimeCommonDivisor(m, n);
+}
+```
+
+With this predicate-formatter, we can use
+
+```
+EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c);
+```
+
+to generate the message
+
+<pre>
+b and c (4 and 10) are not mutually prime, as they have a common divisor 2.<br>
+</pre>
+
+As you may have realized, many of the assertions we introduced earlier are
+special cases of `(EXPECT|ASSERT)_PRED_FORMAT*`. In fact, most of them are
+indeed defined using `(EXPECT|ASSERT)_PRED_FORMAT*`.
+
+_Availability_: Linux, Windows, Mac.
+
+
+## Floating-Point Comparison ##
+
+Comparing floating-point numbers is tricky. Due to round-off errors, it is
+very unlikely that two floating-points will match exactly. Therefore,
+`ASSERT_EQ` 's naive comparison usually doesn't work. And since floating-points
+can have a wide value range, no single fixed error bound works. It's better to
+compare by a fixed relative error bound, except for values close to 0 due to
+the loss of precision there.
+
+In general, for floating-point comparison to make sense, the user needs to
+carefully choose the error bound. If they don't want or care to, comparing in
+terms of Units in the Last Place (ULPs) is a good default, and Google Test
+provides assertions to do this. Full details about ULPs are quite long; if you
+want to learn more, see
+[this article on float comparison](http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm).
+
+### Floating-Point Macros ###
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_FLOAT_EQ(`_expected, actual_`);`  | `EXPECT_FLOAT_EQ(`_expected, actual_`);` | the two `float` values are almost equal |
+| `ASSERT_DOUBLE_EQ(`_expected, actual_`);` | `EXPECT_DOUBLE_EQ(`_expected, actual_`);` | the two `double` values are almost equal |
+
+By "almost equal", we mean the two values are within 4 ULP's from each
+other.
+
+The following assertions allow you to choose the acceptable error bound:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_NEAR(`_val1, val2, abs\_error_`);` | `EXPECT_NEAR`_(val1, val2, abs\_error_`);` | the difference between _val1_ and _val2_ doesn't exceed the given absolute error |
+
+_Availability_: Linux, Windows, Mac.
+
+### Floating-Point Predicate-Format Functions ###
+
+Some floating-point operations are useful, but not that often used. In order
+to avoid an explosion of new macros, we provide them as predicate-format
+functions that can be used in predicate assertion macros (e.g.
+`EXPECT_PRED_FORMAT2`, etc).
+
+```
+EXPECT_PRED_FORMAT2(::testing::FloatLE, val1, val2);
+EXPECT_PRED_FORMAT2(::testing::DoubleLE, val1, val2);
+```
+
+Verifies that _val1_ is less than, or almost equal to, _val2_. You can
+replace `EXPECT_PRED_FORMAT2` in the above table with `ASSERT_PRED_FORMAT2`.
+
+_Availability_: Linux, Windows, Mac.
+
+## Windows HRESULT assertions ##
+
+These assertions test for `HRESULT` success or failure.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_HRESULT_SUCCEEDED(`_expression_`);` | `EXPECT_HRESULT_SUCCEEDED(`_expression_`);` | _expression_ is a success `HRESULT` |
+| `ASSERT_HRESULT_FAILED(`_expression_`);`    | `EXPECT_HRESULT_FAILED(`_expression_`);`    | _expression_ is a failure `HRESULT` |
+
+The generated output contains the human-readable error message
+associated with the `HRESULT` code returned by _expression_.
+
+You might use them like this:
+
+```
+CComPtr shell;
+ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application"));
+CComVariant empty;
+ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty));
+```
+
+_Availability_: Windows.
+
+## Type Assertions ##
+
+You can call the function
+```
+::testing::StaticAssertTypeEq<T1, T2>();
+```
+to assert that types `T1` and `T2` are the same.  The function does
+nothing if the assertion is satisfied.  If the types are different,
+the function call will fail to compile, and the compiler error message
+will likely (depending on the compiler) show you the actual values of
+`T1` and `T2`.  This is mainly useful inside template code.
+
+_Caveat:_ When used inside a member function of a class template or a
+function template, `StaticAssertTypeEq<T1, T2>()` is effective _only if_
+the function is instantiated.  For example, given:
+```
+template <typename T> class Foo {
+ public:
+  void Bar() { ::testing::StaticAssertTypeEq<int, T>(); }
+};
+```
+the code:
+```
+void Test1() { Foo<bool> foo; }
+```
+will _not_ generate a compiler error, as `Foo<bool>::Bar()` is never
+actually instantiated.  Instead, you need:
+```
+void Test2() { Foo<bool> foo; foo.Bar(); }
+```
+to cause a compiler error.
+
+_Availability:_ Linux, Windows, Mac; since version 1.3.0.
+
+## Assertion Placement ##
+
+You can use assertions in any C++ function. In particular, it doesn't
+have to be a method of the test fixture class. The one constraint is
+that assertions that generate a fatal failure (`FAIL*` and `ASSERT_*`)
+can only be used in void-returning functions. This is a consequence of
+Google Test not using exceptions. By placing it in a non-void function
+you'll get a confusing compile error like
+`"error: void value not ignored as it ought to be"`.
+
+If you need to use assertions in a function that returns non-void, one option
+is to make the function return the value in an out parameter instead. For
+example, you can rewrite `T2 Foo(T1 x)` to `void Foo(T1 x, T2* result)`. You
+need to make sure that `*result` contains some sensible value even when the
+function returns prematurely. As the function now returns `void`, you can use
+any assertion inside of it.
+
+If changing the function's type is not an option, you should just use
+assertions that generate non-fatal failures, such as `ADD_FAILURE*` and
+`EXPECT_*`.
+
+_Note_: Constructors and destructors are not considered void-returning
+functions, according to the C++ language specification, and so you may not use
+fatal assertions in them. You'll get a compilation error if you try. A simple
+workaround is to transfer the entire body of the constructor or destructor to a
+private void-returning method. However, you should be aware that a fatal
+assertion failure in a constructor does not terminate the current test, as your
+intuition might suggest; it merely returns from the constructor early, possibly
+leaving your object in a partially-constructed state. Likewise, a fatal
+assertion failure in a destructor may leave your object in a
+partially-destructed state. Use assertions carefully in these situations!
+
+# Teaching Google Test How to Print Your Values #
+
+When a test assertion such as `EXPECT_EQ` fails, Google Test prints the
+argument values to help you debug.  It does this using a
+user-extensible value printer.
+
+This printer knows how to print built-in C++ types, native arrays, STL
+containers, and any type that supports the `<<` operator.  For other
+types, it prints the raw bytes in the value and hopes that you the
+user can figure it out.
+
+As mentioned earlier, the printer is _extensible_.  That means
+you can teach it to do a better job at printing your particular type
+than to dump the bytes.  To do that, define `<<` for your type:
+
+```
+#include <iostream>
+
+namespace foo {
+
+class Bar { ... };  // We want Google Test to be able to print instances of this.
+
+// It's important that the << operator is defined in the SAME
+// namespace that defines Bar.  C++'s look-up rules rely on that.
+::std::ostream& operator<<(::std::ostream& os, const Bar& bar) {
+  return os << bar.DebugString();  // whatever needed to print bar to os
+}
+
+}  // namespace foo
+```
+
+Sometimes, this might not be an option: your team may consider it bad
+style to have a `<<` operator for `Bar`, or `Bar` may already have a
+`<<` operator that doesn't do what you want (and you cannot change
+it).  If so, you can instead define a `PrintTo()` function like this:
+
+```
+#include <iostream>
+
+namespace foo {
+
+class Bar { ... };
+
+// It's important that PrintTo() is defined in the SAME
+// namespace that defines Bar.  C++'s look-up rules rely on that.
+void PrintTo(const Bar& bar, ::std::ostream* os) {
+  *os << bar.DebugString();  // whatever needed to print bar to os
+}
+
+}  // namespace foo
+```
+
+If you have defined both `<<` and `PrintTo()`, the latter will be used
+when Google Test is concerned.  This allows you to customize how the value
+appears in Google Test's output without affecting code that relies on the
+behavior of its `<<` operator.
+
+If you want to print a value `x` using Google Test's value printer
+yourself, just call `::testing::PrintToString(`_x_`)`, which
+returns an `std::string`:
+
+```
+vector<pair<Bar, int> > bar_ints = GetBarIntVector();
+
+EXPECT_TRUE(IsCorrectBarIntVector(bar_ints))
+    << "bar_ints = " << ::testing::PrintToString(bar_ints);
+```
+
+# Death Tests #
+
+In many applications, there are assertions that can cause application failure
+if a condition is not met. These sanity checks, which ensure that the program
+is in a known good state, are there to fail at the earliest possible time after
+some program state is corrupted. If the assertion checks the wrong condition,
+then the program may proceed in an erroneous state, which could lead to memory
+corruption, security holes, or worse. Hence it is vitally important to test
+that such assertion statements work as expected.
+
+Since these precondition checks cause the processes to die, we call such tests
+_death tests_. More generally, any test that checks that a program terminates
+(except by throwing an exception) in an expected fashion is also a death test.
+
+Note that if a piece of code throws an exception, we don't consider it "death"
+for the purpose of death tests, as the caller of the code could catch the exception
+and avoid the crash. If you want to verify exceptions thrown by your code,
+see [Exception Assertions](#exception-assertions).
+
+If you want to test `EXPECT_*()/ASSERT_*()` failures in your test code, see [Catching Failures](#catching-failures).
+
+## How to Write a Death Test ##
+
+Google Test has the following macros to support death tests:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_DEATH(`_statement, regex_`); | `EXPECT_DEATH(`_statement, regex_`); | _statement_ crashes with the given error |
+| `ASSERT_DEATH_IF_SUPPORTED(`_statement, regex_`); | `EXPECT_DEATH_IF_SUPPORTED(`_statement, regex_`); | if death tests are supported, verifies that _statement_ crashes with the given error; otherwise verifies nothing |
+| `ASSERT_EXIT(`_statement, predicate, regex_`); | `EXPECT_EXIT(`_statement, predicate, regex_`); |_statement_ exits with the given error and its exit code matches _predicate_ |
+
+where _statement_ is a statement that is expected to cause the process to
+die, _predicate_ is a function or function object that evaluates an integer
+exit status, and _regex_ is a regular expression that the stderr output of
+_statement_ is expected to match. Note that _statement_ can be _any valid
+statement_ (including _compound statement_) and doesn't have to be an
+expression.
+
+As usual, the `ASSERT` variants abort the current test function, while the
+`EXPECT` variants do not.
+
+**Note:** We use the word "crash" here to mean that the process
+terminates with a _non-zero_ exit status code.  There are two
+possibilities: either the process has called `exit()` or `_exit()`
+with a non-zero value, or it may be killed by a signal.
+
+This means that if _statement_ terminates the process with a 0 exit
+code, it is _not_ considered a crash by `EXPECT_DEATH`.  Use
+`EXPECT_EXIT` instead if this is the case, or if you want to restrict
+the exit code more precisely.
+
+A predicate here must accept an `int` and return a `bool`. The death test
+succeeds only if the predicate returns `true`. Google Test defines a few
+predicates that handle the most common cases:
+
+```
+::testing::ExitedWithCode(exit_code)
+```
+
+This expression is `true` if the program exited normally with the given exit
+code.
+
+```
+::testing::KilledBySignal(signal_number)  // Not available on Windows.
+```
+
+This expression is `true` if the program was killed by the given signal.
+
+The `*_DEATH` macros are convenient wrappers for `*_EXIT` that use a predicate
+that verifies the process' exit code is non-zero.
+
+Note that a death test only cares about three things:
+
+  1. does _statement_ abort or exit the process?
+  1. (in the case of `ASSERT_EXIT` and `EXPECT_EXIT`) does the exit status satisfy _predicate_?  Or (in the case of `ASSERT_DEATH` and `EXPECT_DEATH`) is the exit status non-zero?  And
+  1. does the stderr output match _regex_?
+
+In particular, if _statement_ generates an `ASSERT_*` or `EXPECT_*` failure, it will **not** cause the death test to fail, as Google Test assertions don't abort the process.
+
+To write a death test, simply use one of the above macros inside your test
+function. For example,
+
+```
+TEST(MyDeathTest, Foo) {
+  // This death test uses a compound statement.
+  ASSERT_DEATH({ int n = 5; Foo(&n); }, "Error on line .* of Foo()");
+}
+TEST(MyDeathTest, NormalExit) {
+  EXPECT_EXIT(NormalExit(), ::testing::ExitedWithCode(0), "Success");
+}
+TEST(MyDeathTest, KillMyself) {
+  EXPECT_EXIT(KillMyself(), ::testing::KilledBySignal(SIGKILL), "Sending myself unblockable signal");
+}
+```
+
+verifies that:
+
+  * calling `Foo(5)` causes the process to die with the given error message,
+  * calling `NormalExit()` causes the process to print `"Success"` to stderr and exit with exit code 0, and
+  * calling `KillMyself()` kills the process with signal `SIGKILL`.
+
+The test function body may contain other assertions and statements as well, if
+necessary.
+
+_Important:_ We strongly recommend you to follow the convention of naming your
+test case (not test) `*DeathTest` when it contains a death test, as
+demonstrated in the above example. The `Death Tests And Threads` section below
+explains why.
+
+If a test fixture class is shared by normal tests and death tests, you
+can use typedef to introduce an alias for the fixture class and avoid
+duplicating its code:
+```
+class FooTest : public ::testing::Test { ... };
+
+typedef FooTest FooDeathTest;
+
+TEST_F(FooTest, DoesThis) {
+  // normal test
+}
+
+TEST_F(FooDeathTest, DoesThat) {
+  // death test
+}
+```
+
+_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Cygwin, and Mac (the latter three are supported since v1.3.0).  `(ASSERT|EXPECT)_DEATH_IF_SUPPORTED` are new in v1.4.0.
+
+## Regular Expression Syntax ##
+
+On POSIX systems (e.g. Linux, Cygwin, and Mac), Google Test uses the
+[POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
+syntax in death tests. To learn about this syntax, you may want to read this [Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
+
+On Windows, Google Test uses its own simple regular expression
+implementation. It lacks many features you can find in POSIX extended
+regular expressions.  For example, we don't support union (`"x|y"`),
+grouping (`"(xy)"`), brackets (`"[xy]"`), and repetition count
+(`"x{5,7}"`), among others. Below is what we do support (Letter `A` denotes a
+literal character, period (`.`), or a single `\\` escape sequence; `x`
+and `y` denote regular expressions.):
+
+| `c` | matches any literal character `c` |
+|:----|:----------------------------------|
+| `\\d` | matches any decimal digit         |
+| `\\D` | matches any character that's not a decimal digit |
+| `\\f` | matches `\f`                      |
+| `\\n` | matches `\n`                      |
+| `\\r` | matches `\r`                      |
+| `\\s` | matches any ASCII whitespace, including `\n` |
+| `\\S` | matches any character that's not a whitespace |
+| `\\t` | matches `\t`                      |
+| `\\v` | matches `\v`                      |
+| `\\w` | matches any letter, `_`, or decimal digit |
+| `\\W` | matches any character that `\\w` doesn't match |
+| `\\c` | matches any literal character `c`, which must be a punctuation |
+| `\\.` | matches the `.` character         |
+| `.` | matches any single character except `\n` |
+| `A?` | matches 0 or 1 occurrences of `A` |
+| `A*` | matches 0 or many occurrences of `A` |
+| `A+` | matches 1 or many occurrences of `A` |
+| `^` | matches the beginning of a string (not that of each line) |
+| `$` | matches the end of a string (not that of each line) |
+| `xy` | matches `x` followed by `y`       |
+
+To help you determine which capability is available on your system,
+Google Test defines macro `GTEST_USES_POSIX_RE=1` when it uses POSIX
+extended regular expressions, or `GTEST_USES_SIMPLE_RE=1` when it uses
+the simple version.  If you want your death tests to work in both
+cases, you can either `#if` on these macros or use the more limited
+syntax only.
+
+## How It Works ##
+
+Under the hood, `ASSERT_EXIT()` spawns a new process and executes the
+death test statement in that process. The details of of how precisely
+that happens depend on the platform and the variable
+`::testing::GTEST_FLAG(death_test_style)` (which is initialized from the
+command-line flag `--gtest_death_test_style`).
+
+  * On POSIX systems, `fork()` (or `clone()` on Linux) is used to spawn the child, after which:
+    * If the variable's value is `"fast"`, the death test statement is immediately executed.
+    * If the variable's value is `"threadsafe"`, the child process re-executes the unit test binary just as it was originally invoked, but with some extra flags to cause just the single death test under consideration to be run.
+  * On Windows, the child is spawned using the `CreateProcess()` API, and re-executes the binary to cause just the single death test under consideration to be run - much like the `threadsafe` mode on POSIX.
+
+Other values for the variable are illegal and will cause the death test to
+fail. Currently, the flag's default value is `"fast"`. However, we reserve the
+right to change it in the future. Therefore, your tests should not depend on
+this.
+
+In either case, the parent process waits for the child process to complete, and checks that
+
+  1. the child's exit status satisfies the predicate, and
+  1. the child's stderr matches the regular expression.
+
+If the death test statement runs to completion without dying, the child
+process will nonetheless terminate, and the assertion fails.
+
+## Death Tests And Threads ##
+
+The reason for the two death test styles has to do with thread safety. Due to
+well-known problems with forking in the presence of threads, death tests should
+be run in a single-threaded context. Sometimes, however, it isn't feasible to
+arrange that kind of environment. For example, statically-initialized modules
+may start threads before main is ever reached. Once threads have been created,
+it may be difficult or impossible to clean them up.
+
+Google Test has three features intended to raise awareness of threading issues.
+
+  1. A warning is emitted if multiple threads are running when a death test is encountered.
+  1. Test cases with a name ending in "DeathTest" are run before all other tests.
+  1. It uses `clone()` instead of `fork()` to spawn the child process on Linux (`clone()` is not available on Cygwin and Mac), as `fork()` is more likely to cause the child to hang when the parent process has multiple threads.
+
+It's perfectly fine to create threads inside a death test statement; they are
+executed in a separate process and cannot affect the parent.
+
+## Death Test Styles ##
+
+The "threadsafe" death test style was introduced in order to help mitigate the
+risks of testing in a possibly multithreaded environment. It trades increased
+test execution time (potentially dramatically so) for improved thread safety.
+We suggest using the faster, default "fast" style unless your test has specific
+problems with it.
+
+You can choose a particular style of death tests by setting the flag
+programmatically:
+
+```
+::testing::FLAGS_gtest_death_test_style = "threadsafe";
+```
+
+You can do this in `main()` to set the style for all death tests in the
+binary, or in individual tests. Recall that flags are saved before running each
+test and restored afterwards, so you need not do that yourself. For example:
+
+```
+TEST(MyDeathTest, TestOne) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+  // This test is run in the "threadsafe" style:
+  ASSERT_DEATH(ThisShouldDie(), "");
+}
+
+TEST(MyDeathTest, TestTwo) {
+  // This test is run in the "fast" style:
+  ASSERT_DEATH(ThisShouldDie(), "");
+}
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  ::testing::FLAGS_gtest_death_test_style = "fast";
+  return RUN_ALL_TESTS();
+}
+```
+
+## Caveats ##
+
+The _statement_ argument of `ASSERT_EXIT()` can be any valid C++ statement.
+If it leaves the current function via a `return` statement or by throwing an exception,
+the death test is considered to have failed.  Some Google Test macros may return
+from the current function (e.g. `ASSERT_TRUE()`), so be sure to avoid them in _statement_.
+
+Since _statement_ runs in the child process, any in-memory side effect (e.g.
+modifying a variable, releasing memory, etc) it causes will _not_ be observable
+in the parent process. In particular, if you release memory in a death test,
+your program will fail the heap check as the parent process will never see the
+memory reclaimed. To solve this problem, you can
+
+  1. try not to free memory in a death test;
+  1. free the memory again in the parent process; or
+  1. do not use the heap checker in your program.
+
+Due to an implementation detail, you cannot place multiple death test
+assertions on the same line; otherwise, compilation will fail with an unobvious
+error message.
+
+Despite the improved thread safety afforded by the "threadsafe" style of death
+test, thread problems such as deadlock are still possible in the presence of
+handlers registered with `pthread_atfork(3)`.
+
+# Using Assertions in Sub-routines #
+
+## Adding Traces to Assertions ##
+
+If a test sub-routine is called from several places, when an assertion
+inside it fails, it can be hard to tell which invocation of the
+sub-routine the failure is from.  You can alleviate this problem using
+extra logging or custom failure messages, but that usually clutters up
+your tests. A better solution is to use the `SCOPED_TRACE` macro:
+
+| `SCOPED_TRACE(`_message_`);` |
+|:-----------------------------|
+
+where _message_ can be anything streamable to `std::ostream`. This
+macro will cause the current file name, line number, and the given
+message to be added in every failure message. The effect will be
+undone when the control leaves the current lexical scope.
+
+For example,
+
+```
+10: void Sub1(int n) {
+11:   EXPECT_EQ(1, Bar(n));
+12:   EXPECT_EQ(2, Bar(n + 1));
+13: }
+14:
+15: TEST(FooTest, Bar) {
+16:   {
+17:     SCOPED_TRACE("A");  // This trace point will be included in
+18:                         // every failure in this scope.
+19:     Sub1(1);
+20:   }
+21:   // Now it won't.
+22:   Sub1(9);
+23: }
+```
+
+could result in messages like these:
+
+```
+path/to/foo_test.cc:11: Failure
+Value of: Bar(n)
+Expected: 1
+  Actual: 2
+   Trace:
+path/to/foo_test.cc:17: A
+
+path/to/foo_test.cc:12: Failure
+Value of: Bar(n + 1)
+Expected: 2
+  Actual: 3
+```
+
+Without the trace, it would've been difficult to know which invocation
+of `Sub1()` the two failures come from respectively. (You could add an
+extra message to each assertion in `Sub1()` to indicate the value of
+`n`, but that's tedious.)
+
+Some tips on using `SCOPED_TRACE`:
+
+  1. With a suitable message, it's often enough to use `SCOPED_TRACE` at the beginning of a sub-routine, instead of at each call site.
+  1. When calling sub-routines inside a loop, make the loop iterator part of the message in `SCOPED_TRACE` such that you can know which iteration the failure is from.
+  1. Sometimes the line number of the trace point is enough for identifying the particular invocation of a sub-routine. In this case, you don't have to choose a unique message for `SCOPED_TRACE`. You can simply use `""`.
+  1. You can use `SCOPED_TRACE` in an inner scope when there is one in the outer scope. In this case, all active trace points will be included in the failure messages, in reverse order they are encountered.
+  1. The trace dump is clickable in Emacs' compilation buffer - hit return on a line number and you'll be taken to that line in the source file!
+
+_Availability:_ Linux, Windows, Mac.
+
+## Propagating Fatal Failures ##
+
+A common pitfall when using `ASSERT_*` and `FAIL*` is not understanding that
+when they fail they only abort the _current function_, not the entire test. For
+example, the following test will segfault:
+```
+void Subroutine() {
+  // Generates a fatal failure and aborts the current function.
+  ASSERT_EQ(1, 2);
+  // The following won't be executed.
+  ...
+}
+
+TEST(FooTest, Bar) {
+  Subroutine();
+  // The intended behavior is for the fatal failure
+  // in Subroutine() to abort the entire test.
+  // The actual behavior: the function goes on after Subroutine() returns.
+  int* p = NULL;
+  *p = 3; // Segfault!
+}
+```
+
+Since we don't use exceptions, it is technically impossible to
+implement the intended behavior here.  To alleviate this, Google Test
+provides two solutions.  You could use either the
+`(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the
+`HasFatalFailure()` function.  They are described in the following two
+subsections.
+
+### Asserting on Subroutines ###
+
+As shown above, if your test calls a subroutine that has an `ASSERT_*`
+failure in it, the test will continue after the subroutine
+returns. This may not be what you want.
+
+Often people want fatal failures to propagate like exceptions.  For
+that Google Test offers the following macros:
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_NO_FATAL_FAILURE(`_statement_`);` | `EXPECT_NO_FATAL_FAILURE(`_statement_`);` | _statement_ doesn't generate any new fatal failures in the current thread. |
+
+Only failures in the thread that executes the assertion are checked to
+determine the result of this type of assertions.  If _statement_
+creates new threads, failures in these threads are ignored.
+
+Examples:
+
+```
+ASSERT_NO_FATAL_FAILURE(Foo());
+
+int i;
+EXPECT_NO_FATAL_FAILURE({
+  i = Bar();
+});
+```
+
+_Availability:_ Linux, Windows, Mac. Assertions from multiple threads
+are currently not supported.
+
+### Checking for Failures in the Current Test ###
+
+`HasFatalFailure()` in the `::testing::Test` class returns `true` if an
+assertion in the current test has suffered a fatal failure. This
+allows functions to catch fatal failures in a sub-routine and return
+early.
+
+```
+class Test {
+ public:
+  ...
+  static bool HasFatalFailure();
+};
+```
+
+The typical usage, which basically simulates the behavior of a thrown
+exception, is:
+
+```
+TEST(FooTest, Bar) {
+  Subroutine();
+  // Aborts if Subroutine() had a fatal failure.
+  if (HasFatalFailure())
+    return;
+  // The following won't be executed.
+  ...
+}
+```
+
+If `HasFatalFailure()` is used outside of `TEST()` , `TEST_F()` , or a test
+fixture, you must add the `::testing::Test::` prefix, as in:
+
+```
+if (::testing::Test::HasFatalFailure())
+  return;
+```
+
+Similarly, `HasNonfatalFailure()` returns `true` if the current test
+has at least one non-fatal failure, and `HasFailure()` returns `true`
+if the current test has at least one failure of either kind.
+
+_Availability:_ Linux, Windows, Mac.  `HasNonfatalFailure()` and
+`HasFailure()` are available since version 1.4.0.
+
+# Logging Additional Information #
+
+In your test code, you can call `RecordProperty("key", value)` to log
+additional information, where `value` can be either a string or an `int`. The _last_ value recorded for a key will be emitted to the XML output
+if you specify one. For example, the test
+
+```
+TEST_F(WidgetUsageTest, MinAndMaxWidgets) {
+  RecordProperty("MaximumWidgets", ComputeMaxUsage());
+  RecordProperty("MinimumWidgets", ComputeMinUsage());
+}
+```
+
+will output XML like this:
+
+```
+...
+  <testcase name="MinAndMaxWidgets" status="run" time="6" classname="WidgetUsageTest"
+            MaximumWidgets="12"
+            MinimumWidgets="9" />
+...
+```
+
+_Note_:
+  * `RecordProperty()` is a static member of the `Test` class. Therefore it needs to be prefixed with `::testing::Test::` if used outside of the `TEST` body and the test fixture class.
+  * `key` must be a valid XML attribute name, and cannot conflict with the ones already used by Google Test (`name`, `status`, `time`, `classname`, `type_param`, and `value_param`).
+  * Calling `RecordProperty()` outside of the lifespan of a test is allowed. If it's called outside of a test but between a test case's `SetUpTestCase()` and `TearDownTestCase()` methods, it will be attributed to the XML element for the test case. If it's called outside of all test cases (e.g. in a test environment), it will be attributed to the top-level XML element.
+
+_Availability_: Linux, Windows, Mac.
+
+# Sharing Resources Between Tests in the Same Test Case #
+
+
+
+Google Test creates a new test fixture object for each test in order to make
+tests independent and easier to debug. However, sometimes tests use resources
+that are expensive to set up, making the one-copy-per-test model prohibitively
+expensive.
+
+If the tests don't change the resource, there's no harm in them sharing a
+single resource copy. So, in addition to per-test set-up/tear-down, Google Test
+also supports per-test-case set-up/tear-down. To use it:
+
+  1. In your test fixture class (say `FooTest` ), define as `static` some member variables to hold the shared resources.
+  1. In the same test fixture class, define a `static void SetUpTestCase()` function (remember not to spell it as **`SetupTestCase`** with a small `u`!) to set up the shared resources and a `static void TearDownTestCase()` function to tear them down.
+
+That's it! Google Test automatically calls `SetUpTestCase()` before running the
+_first test_ in the `FooTest` test case (i.e. before creating the first
+`FooTest` object), and calls `TearDownTestCase()` after running the _last test_
+in it (i.e. after deleting the last `FooTest` object). In between, the tests
+can use the shared resources.
+
+Remember that the test order is undefined, so your code can't depend on a test
+preceding or following another. Also, the tests must either not modify the
+state of any shared resource, or, if they do modify the state, they must
+restore the state to its original value before passing control to the next
+test.
+
+Here's an example of per-test-case set-up and tear-down:
+```
+class FooTest : public ::testing::Test {
+ protected:
+  // Per-test-case set-up.
+  // Called before the first test in this test case.
+  // Can be omitted if not needed.
+  static void SetUpTestCase() {
+    shared_resource_ = new ...;
+  }
+
+  // Per-test-case tear-down.
+  // Called after the last test in this test case.
+  // Can be omitted if not needed.
+  static void TearDownTestCase() {
+    delete shared_resource_;
+    shared_resource_ = NULL;
+  }
+
+  // You can define per-test set-up and tear-down logic as usual.
+  virtual void SetUp() { ... }
+  virtual void TearDown() { ... }
+
+  // Some expensive resource shared by all tests.
+  static T* shared_resource_;
+};
+
+T* FooTest::shared_resource_ = NULL;
+
+TEST_F(FooTest, Test1) {
+  ... you can refer to shared_resource here ...
+}
+TEST_F(FooTest, Test2) {
+  ... you can refer to shared_resource here ...
+}
+```
+
+_Availability:_ Linux, Windows, Mac.
+
+# Global Set-Up and Tear-Down #
+
+Just as you can do set-up and tear-down at the test level and the test case
+level, you can also do it at the test program level. Here's how.
+
+First, you subclass the `::testing::Environment` class to define a test
+environment, which knows how to set-up and tear-down:
+
+```
+class Environment {
+ public:
+  virtual ~Environment() {}
+  // Override this to define how to set up the environment.
+  virtual void SetUp() {}
+  // Override this to define how to tear down the environment.
+  virtual void TearDown() {}
+};
+```
+
+Then, you register an instance of your environment class with Google Test by
+calling the `::testing::AddGlobalTestEnvironment()` function:
+
+```
+Environment* AddGlobalTestEnvironment(Environment* env);
+```
+
+Now, when `RUN_ALL_TESTS()` is called, it first calls the `SetUp()` method of
+the environment object, then runs the tests if there was no fatal failures, and
+finally calls `TearDown()` of the environment object.
+
+It's OK to register multiple environment objects. In this case, their `SetUp()`
+will be called in the order they are registered, and their `TearDown()` will be
+called in the reverse order.
+
+Note that Google Test takes ownership of the registered environment objects.
+Therefore **do not delete them** by yourself.
+
+You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is
+called, probably in `main()`. If you use `gtest_main`, you need to      call
+this before `main()` starts for it to take effect. One way to do this is to
+define a global variable like this:
+
+```
+::testing::Environment* const foo_env = ::testing::AddGlobalTestEnvironment(new FooEnvironment);
+```
+
+However, we strongly recommend you to write your own `main()` and call
+`AddGlobalTestEnvironment()` there, as relying on initialization of global
+variables makes the code harder to read and may cause problems when you
+register multiple environments from different translation units and the
+environments have dependencies among them (remember that the compiler doesn't
+guarantee the order in which global variables from different translation units
+are initialized).
+
+_Availability:_ Linux, Windows, Mac.
+
+
+# Value Parameterized Tests #
+
+_Value-parameterized tests_ allow you to test your code with different
+parameters without writing multiple copies of the same test.
+
+Suppose you write a test for your code and then realize that your code is affected by a presence of a Boolean command line flag.
+
+```
+TEST(MyCodeTest, TestFoo) {
+  // A code to test foo().
+}
+```
+
+Usually people factor their test code into a function with a Boolean parameter in such situations. The function sets the flag, then executes the testing code.
+
+```
+void TestFooHelper(bool flag_value) {
+  flag = flag_value;
+  // A code to test foo().
+}
+
+TEST(MyCodeTest, TestFoo) {
+  TestFooHelper(false);
+  TestFooHelper(true);
+}
+```
+
+But this setup has serious drawbacks. First, when a test assertion fails in your tests, it becomes unclear what value of the parameter caused it to fail. You can stream a clarifying message into your `EXPECT`/`ASSERT` statements, but it you'll have to do it with all of them. Second, you have to add one such helper function per test. What if you have ten tests? Twenty? A hundred?
+
+Value-parameterized tests will let you write your test only once and then easily instantiate and run it with an arbitrary number of parameter values.
+
+Here are some other situations when value-parameterized tests come handy:
+
+  * You want to test different implementations of an OO interface.
+  * You want to test your code over various inputs (a.k.a. data-driven testing). This feature is easy to abuse, so please exercise your good sense when doing it!
+
+## How to Write Value-Parameterized Tests ##
+
+To write value-parameterized tests, first you should define a fixture
+class.  It must be derived from both `::testing::Test` and
+`::testing::WithParamInterface<T>` (the latter is a pure interface),
+where `T` is the type of your parameter values.  For convenience, you
+can just derive the fixture class from `::testing::TestWithParam<T>`,
+which itself is derived from both `::testing::Test` and
+`::testing::WithParamInterface<T>`. `T` can be any copyable type. If
+it's a raw pointer, you are responsible for managing the lifespan of
+the pointed values.
+
+```
+class FooTest : public ::testing::TestWithParam<const char*> {
+  // You can implement all the usual fixture class members here.
+  // To access the test parameter, call GetParam() from class
+  // TestWithParam<T>.
+};
+
+// Or, when you want to add parameters to a pre-existing fixture class:
+class BaseTest : public ::testing::Test {
+  ...
+};
+class BarTest : public BaseTest,
+                public ::testing::WithParamInterface<const char*> {
+  ...
+};
+```
+
+Then, use the `TEST_P` macro to define as many test patterns using
+this fixture as you want.  The `_P` suffix is for "parameterized" or
+"pattern", whichever you prefer to think.
+
+```
+TEST_P(FooTest, DoesBlah) {
+  // Inside a test, access the test parameter with the GetParam() method
+  // of the TestWithParam<T> class:
+  EXPECT_TRUE(foo.Blah(GetParam()));
+  ...
+}
+
+TEST_P(FooTest, HasBlahBlah) {
+  ...
+}
+```
+
+Finally, you can use `INSTANTIATE_TEST_CASE_P` to instantiate the test
+case with 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 are all in the `testing` namespace:
+
+| `Range(begin, end[, step])` | Yields values `{begin, begin+step, begin+step+step, ...}`. The values do not include `end`. `step` defaults to 1. |
+|:----------------------------|:------------------------------------------------------------------------------------------------------------------|
+| `Values(v1, v2, ..., vN)`   | Yields values `{v1, v2, ..., vN}`.                                                                                |
+| `ValuesIn(container)` and `ValuesIn(begin, end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)`. `container`, `begin`, and `end` can be expressions whose values are determined at run time.  |
+| `Bool()`                    | Yields sequence `{false, true}`.                                                                                  |
+| `Combine(g1, g2, ..., gN)`  | Yields all combinations (the Cartesian product for the math savvy) of the values generated by the `N` generators. This is only available if your system provides the `<tr1/tuple>` header. If you are sure your system does, and Google Test disagrees, you can override it by defining `GTEST_HAS_TR1_TUPLE=1`. See comments in [include/gtest/internal/gtest-port.h](../include/gtest/internal/gtest-port.h) for more information. |
+
+For more details, see the comments at the definitions of these functions in the [source code](../include/gtest/gtest-param-test.h).
+
+The following statement will instantiate tests from the `FooTest` test case
+each with parameter values `"meeny"`, `"miny"`, and `"moe"`.
+
+```
+INSTANTIATE_TEST_CASE_P(InstantiationName,
+                        FooTest,
+                        ::testing::Values("meeny", "miny", "moe"));
+```
+
+To distinguish different instances of the pattern (yes, you can
+instantiate it more than once), the first argument to
+`INSTANTIATE_TEST_CASE_P` is a prefix that will be added to the actual
+test case name. Remember to pick unique prefixes for different
+instantiations. The tests from the instantiation above will have these
+names:
+
+  * `InstantiationName/FooTest.DoesBlah/0` for `"meeny"`
+  * `InstantiationName/FooTest.DoesBlah/1` for `"miny"`
+  * `InstantiationName/FooTest.DoesBlah/2` for `"moe"`
+  * `InstantiationName/FooTest.HasBlahBlah/0` for `"meeny"`
+  * `InstantiationName/FooTest.HasBlahBlah/1` for `"miny"`
+  * `InstantiationName/FooTest.HasBlahBlah/2` for `"moe"`
+
+You can use these names in [--gtest\_filter](#running-a-subset-of-the-tests).
+
+This statement will instantiate all tests from `FooTest` again, each
+with parameter values `"cat"` and `"dog"`:
+
+```
+const char* pets[] = {"cat", "dog"};
+INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest,
+                        ::testing::ValuesIn(pets));
+```
+
+The tests from the instantiation above will have these names:
+
+  * `AnotherInstantiationName/FooTest.DoesBlah/0` for `"cat"`
+  * `AnotherInstantiationName/FooTest.DoesBlah/1` for `"dog"`
+  * `AnotherInstantiationName/FooTest.HasBlahBlah/0` for `"cat"`
+  * `AnotherInstantiationName/FooTest.HasBlahBlah/1` for `"dog"`
+
+Please note that `INSTANTIATE_TEST_CASE_P` will instantiate _all_
+tests in the given test case, whether their definitions come before or
+_after_ the `INSTANTIATE_TEST_CASE_P` statement.
+
+You can see
+[these](../samples/sample7_unittest.cc)
+[files](../samples/sample8_unittest.cc) for more examples.
+
+_Availability_: Linux, Windows (requires MSVC 8.0 or above), Mac; since version 1.2.0.
+
+## Creating Value-Parameterized Abstract Tests ##
+
+In the above, we define and instantiate `FooTest` in the same source
+file. Sometimes you may want to define value-parameterized tests in a
+library and let other people instantiate them later. This pattern is
+known as <i>abstract tests</i>. As an example of its application, when you
+are designing an interface you can write a standard suite of abstract
+tests (perhaps using a factory function as the test parameter) that
+all implementations of the interface are expected to pass. When
+someone implements the interface, he can instantiate your suite to get
+all the interface-conformance tests for free.
+
+To define abstract tests, you should organize your code like this:
+
+  1. Put the definition of the parameterized test fixture class (e.g. `FooTest`) in a header file, say `foo_param_test.h`. Think of this as _declaring_ your abstract tests.
+  1. Put the `TEST_P` definitions in `foo_param_test.cc`, which includes `foo_param_test.h`. Think of this as _implementing_ your abstract tests.
+
+Once they are defined, you can instantiate them by including
+`foo_param_test.h`, invoking `INSTANTIATE_TEST_CASE_P()`, and linking
+with `foo_param_test.cc`. You can instantiate the same abstract test
+case multiple times, possibly in different source files.
+
+# Typed Tests #
+
+Suppose you have multiple implementations of the same interface and
+want to make sure that all of them satisfy some common requirements.
+Or, you may have defined several types that are supposed to conform to
+the same "concept" and you want to verify it.  In both cases, you want
+the same test logic repeated for different types.
+
+While you can write one `TEST` or `TEST_F` for each type you want to
+test (and you may even factor the test logic into a function template
+that you invoke from the `TEST`), it's tedious and doesn't scale:
+if you want _m_ tests over _n_ types, you'll end up writing _m\*n_
+`TEST`s.
+
+_Typed tests_ allow you to repeat the same test logic over a list of
+types.  You only need to write the test logic once, although you must
+know the type list when writing typed tests.  Here's how you do it:
+
+First, define a fixture class template.  It should be parameterized
+by a type.  Remember to derive it from `::testing::Test`:
+
+```
+template <typename T>
+class FooTest : public ::testing::Test {
+ public:
+  ...
+  typedef std::list<T> List;
+  static T shared_;
+  T value_;
+};
+```
+
+Next, associate a list of types with the test case, which will be
+repeated for each type in the list:
+
+```
+typedef ::testing::Types<char, int, unsigned int> MyTypes;
+TYPED_TEST_CASE(FooTest, MyTypes);
+```
+
+The `typedef` is necessary for the `TYPED_TEST_CASE` macro to parse
+correctly.  Otherwise the compiler will think that each comma in the
+type list introduces a new macro argument.
+
+Then, use `TYPED_TEST()` instead of `TEST_F()` to define a typed test
+for this test case.  You can repeat this as many times as you want:
+
+```
+TYPED_TEST(FooTest, DoesBlah) {
+  // Inside a test, refer to the special name TypeParam to get the type
+  // parameter.  Since we are inside a derived class template, C++ requires
+  // us to visit the members of FooTest via 'this'.
+  TypeParam n = this->value_;
+
+  // To visit static members of the fixture, add the 'TestFixture::'
+  // prefix.
+  n += TestFixture::shared_;
+
+  // To refer to typedefs in the fixture, add the 'typename TestFixture::'
+  // prefix.  The 'typename' is required to satisfy the compiler.
+  typename TestFixture::List values;
+  values.push_back(n);
+  ...
+}
+
+TYPED_TEST(FooTest, HasPropertyA) { ... }
+```
+
+You can see `samples/sample6_unittest.cc` for a complete example.
+
+_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
+since version 1.1.0.
+
+# Type-Parameterized Tests #
+
+_Type-parameterized tests_ are like typed tests, except that they
+don't require you to know the list of types ahead of time.  Instead,
+you can define the test logic first and instantiate it with different
+type lists later.  You can even instantiate it more than once in the
+same program.
+
+If you are designing an interface or concept, you can define a suite
+of type-parameterized tests to verify properties that any valid
+implementation of the interface/concept should have.  Then, the author
+of each implementation can just instantiate the test suite with his
+type to verify that it conforms to the requirements, without having to
+write similar tests repeatedly.  Here's an example:
+
+First, define a fixture class template, as we did with typed tests:
+
+```
+template <typename T>
+class FooTest : public ::testing::Test {
+  ...
+};
+```
+
+Next, declare that you will define a type-parameterized test case:
+
+```
+TYPED_TEST_CASE_P(FooTest);
+```
+
+The `_P` suffix is for "parameterized" or "pattern", whichever you
+prefer to think.
+
+Then, use `TYPED_TEST_P()` to define a type-parameterized test.  You
+can repeat this as many times as you want:
+
+```
+TYPED_TEST_P(FooTest, DoesBlah) {
+  // Inside a test, refer to TypeParam to get the type parameter.
+  TypeParam n = 0;
+  ...
+}
+
+TYPED_TEST_P(FooTest, HasPropertyA) { ... }
+```
+
+Now the tricky part: you need to register all test patterns using the
+`REGISTER_TYPED_TEST_CASE_P` macro before you can instantiate them.
+The first argument of the macro is the test case name; the rest are
+the names of the tests in this test case:
+
+```
+REGISTER_TYPED_TEST_CASE_P(FooTest,
+                           DoesBlah, HasPropertyA);
+```
+
+Finally, you are free to instantiate the pattern with the types you
+want.  If you put the above code in a header file, you can `#include`
+it in multiple C++ source files and instantiate it multiple times.
+
+```
+typedef ::testing::Types<char, int, unsigned int> MyTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
+```
+
+To distinguish different instances of the pattern, the first argument
+to the `INSTANTIATE_TYPED_TEST_CASE_P` macro is a prefix that will be
+added to the actual test case name.  Remember to pick unique prefixes
+for different instances.
+
+In the special case where the type list contains only one type, you
+can write that type directly without `::testing::Types<...>`, like this:
+
+```
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
+```
+
+You can see `samples/sample6_unittest.cc` for a complete example.
+
+_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
+since version 1.1.0.
+
+# Testing Private Code #
+
+If you change your software's internal implementation, your tests should not
+break as long as the change is not observable by users. Therefore, per the
+_black-box testing principle_, most of the time you should test your code
+through its public interfaces.
+
+If you still find yourself needing to test internal implementation code,
+consider if there's a better design that wouldn't require you to do so. If you
+absolutely have to test non-public interface code though, you can. There are
+two cases to consider:
+
+  * Static functions (_not_ the same as static member functions!) or unnamed namespaces, and
+  * Private or protected class members
+
+## Static Functions ##
+
+Both static functions and definitions/declarations in an unnamed namespace are
+only visible within the same translation unit. To test them, you can `#include`
+the entire `.cc` file being tested in your `*_test.cc` file. (`#include`ing `.cc`
+files is not a good way to reuse code - you should not do this in production
+code!)
+
+However, a better approach is to move the private code into the
+`foo::internal` namespace, where `foo` is the namespace your project normally
+uses, and put the private declarations in a `*-internal.h` file. Your
+production `.cc` files and your tests are allowed to include this internal
+header, but your clients are not. This way, you can fully test your internal
+implementation without leaking it to your clients.
+
+## Private Class Members ##
+
+Private class members are only accessible from within the class or by friends.
+To access a class' private members, you can declare your test fixture as a
+friend to the class and define accessors in your fixture. Tests using the
+fixture can then access the private members of your production class via the
+accessors in the fixture. Note that even though your fixture is a friend to
+your production class, your tests are not automatically friends to it, as they
+are technically defined in sub-classes of the fixture.
+
+Another way to test private members is to refactor them into an implementation
+class, which is then declared in a `*-internal.h` file. Your clients aren't
+allowed to include this header but your tests can. Such is called the Pimpl
+(Private Implementation) idiom.
+
+Or, you can declare an individual test as a friend of your class by adding this
+line in the class body:
+
+```
+FRIEND_TEST(TestCaseName, TestName);
+```
+
+For example,
+```
+// foo.h
+#include "gtest/gtest_prod.h"
+
+// Defines FRIEND_TEST.
+class Foo {
+  ...
+ private:
+  FRIEND_TEST(FooTest, BarReturnsZeroOnNull);
+  int Bar(void* x);
+};
+
+// foo_test.cc
+...
+TEST(FooTest, BarReturnsZeroOnNull) {
+  Foo foo;
+  EXPECT_EQ(0, foo.Bar(NULL));
+  // Uses Foo's private member Bar().
+}
+```
+
+Pay special attention when your class is defined in a namespace, as you should
+define your test fixtures and tests in the same namespace if you want them to
+be friends of your class. For example, if the code to be tested looks like:
+
+```
+namespace my_namespace {
+
+class Foo {
+  friend class FooTest;
+  FRIEND_TEST(FooTest, Bar);
+  FRIEND_TEST(FooTest, Baz);
+  ...
+  definition of the class Foo
+  ...
+};
+
+}  // namespace my_namespace
+```
+
+Your test code should be something like:
+
+```
+namespace my_namespace {
+class FooTest : public ::testing::Test {
+ protected:
+  ...
+};
+
+TEST_F(FooTest, Bar) { ... }
+TEST_F(FooTest, Baz) { ... }
+
+}  // namespace my_namespace
+```
+
+# Catching Failures #
+
+If you are building a testing utility on top of Google Test, you'll
+want to test your utility.  What framework would you use to test it?
+Google Test, of course.
+
+The challenge is to verify that your testing utility reports failures
+correctly.  In frameworks that report a failure by throwing an
+exception, you could catch the exception and assert on it.  But Google
+Test doesn't use exceptions, so how do we test that a piece of code
+generates an expected failure?
+
+`"gtest/gtest-spi.h"` contains some constructs to do this.  After
+`#include`ing this header, you can use
+
+| `EXPECT_FATAL_FAILURE(`_statement, substring_`);` |
+|:--------------------------------------------------|
+
+to assert that _statement_ generates a fatal (e.g. `ASSERT_*`) failure
+whose message contains the given _substring_, or use
+
+| `EXPECT_NONFATAL_FAILURE(`_statement, substring_`);` |
+|:-----------------------------------------------------|
+
+if you are expecting a non-fatal (e.g. `EXPECT_*`) failure.
+
+For technical reasons, there are some caveats:
+
+  1. You cannot stream a failure message to either macro.
+  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot reference local non-static variables or non-static members of `this` object.
+  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot return a value.
+
+_Note:_ Google Test is designed with threads in mind.  Once the
+synchronization primitives in `"gtest/internal/gtest-port.h"` have
+been implemented, Google Test will become thread-safe, meaning that
+you can then use assertions in multiple threads concurrently.  Before
+
+that, however, Google Test only supports single-threaded usage.  Once
+thread-safe, `EXPECT_FATAL_FAILURE()` and `EXPECT_NONFATAL_FAILURE()`
+will capture failures in the current thread only. If _statement_
+creates new threads, failures in these threads will be ignored.  If
+you want to capture failures from all threads instead, you should use
+the following macros:
+
+| `EXPECT_FATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
+|:-----------------------------------------------------------------|
+| `EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
+
+# Getting the Current Test's Name #
+
+Sometimes a function may need to know the name of the currently running test.
+For example, you may be using the `SetUp()` method of your test fixture to set
+the golden file name based on which test is running. The `::testing::TestInfo`
+class has this information:
+
+```
+namespace testing {
+
+class TestInfo {
+ public:
+  // Returns the test case name and the test name, respectively.
+  //
+  // Do NOT delete or free the return value - it's managed by the
+  // TestInfo class.
+  const char* test_case_name() const;
+  const char* name() const;
+};
+
+}  // namespace testing
+```
+
+
+> To obtain a `TestInfo` object for the currently running test, call
+`current_test_info()` on the `UnitTest` singleton object:
+
+```
+// Gets information about the currently running test.
+// Do NOT delete the returned object - it's managed by the UnitTest class.
+const ::testing::TestInfo* const test_info =
+  ::testing::UnitTest::GetInstance()->current_test_info();
+printf("We are in test %s of test case %s.\n",
+       test_info->name(), test_info->test_case_name());
+```
+
+`current_test_info()` returns a null pointer if no test is running. In
+particular, you cannot find the test case name in `TestCaseSetUp()`,
+`TestCaseTearDown()` (where you know the test case name implicitly), or
+functions called from them.
+
+_Availability:_ Linux, Windows, Mac.
+
+# Extending Google Test by Handling Test Events #
+
+Google Test provides an <b>event listener API</b> to let you receive
+notifications about the progress of a test program and test
+failures. The events you can listen to include the start and end of
+the test program, a test case, or a test method, among others. You may
+use this API to augment or replace the standard console output,
+replace the XML output, or provide a completely different form of
+output, such as a GUI or a database. You can also use test events as
+checkpoints to implement a resource leak checker, for example.
+
+_Availability:_ Linux, Windows, Mac; since v1.4.0.
+
+## Defining Event Listeners ##
+
+To define a event listener, you subclass either
+[testing::TestEventListener](../include/gtest/gtest.h#L855)
+or [testing::EmptyTestEventListener](../include/gtest/gtest.h#L905).
+The former is an (abstract) interface, where <i>each pure virtual method<br>
+can be overridden to handle a test event</i> (For example, when a test
+starts, the `OnTestStart()` method will be called.). The latter provides
+an empty implementation of all methods in the interface, such that a
+subclass only needs to override the methods it cares about.
+
+When an event is fired, its context is passed to the handler function
+as an argument. The following argument types are used:
+  * [UnitTest](../include/gtest/gtest.h#L1007) reflects the state of the entire test program,
+  * [TestCase](../include/gtest/gtest.h#L689) has information about a test case, which can contain one or more tests,
+  * [TestInfo](../include/gtest/gtest.h#L599) contains the state of a test, and
+  * [TestPartResult](../include/gtest/gtest-test-part.h#L42) represents the result of a test assertion.
+
+An event handler function can examine the argument it receives to find
+out interesting information about the event and the test program's
+state.  Here's an example:
+
+```
+  class MinimalistPrinter : public ::testing::EmptyTestEventListener {
+    // Called before a test starts.
+    virtual void OnTestStart(const ::testing::TestInfo& test_info) {
+      printf("*** Test %s.%s starting.\n",
+             test_info.test_case_name(), test_info.name());
+    }
+
+    // Called after a failed assertion or a SUCCEED() invocation.
+    virtual void OnTestPartResult(
+        const ::testing::TestPartResult& test_part_result) {
+      printf("%s in %s:%d\n%s\n",
+             test_part_result.failed() ? "*** Failure" : "Success",
+             test_part_result.file_name(),
+             test_part_result.line_number(),
+             test_part_result.summary());
+    }
+
+    // Called after a test ends.
+    virtual void OnTestEnd(const ::testing::TestInfo& test_info) {
+      printf("*** Test %s.%s ending.\n",
+             test_info.test_case_name(), test_info.name());
+    }
+  };
+```
+
+## Using Event Listeners ##
+
+To use the event listener you have defined, add an instance of it to
+the Google Test event listener list (represented by class
+[TestEventListeners](../include/gtest/gtest.h#L929)
+- note the "s" at the end of the name) in your
+`main()` function, before calling `RUN_ALL_TESTS()`:
+```
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  // Gets hold of the event listener list.
+  ::testing::TestEventListeners& listeners =
+      ::testing::UnitTest::GetInstance()->listeners();
+  // Adds a listener to the end.  Google Test takes the ownership.
+  listeners.Append(new MinimalistPrinter);
+  return RUN_ALL_TESTS();
+}
+```
+
+There's only one problem: the default test result printer is still in
+effect, so its output will mingle with the output from your minimalist
+printer. To suppress the default printer, just release it from the
+event listener list and delete it. You can do so by adding one line:
+```
+  ...
+  delete listeners.Release(listeners.default_result_printer());
+  listeners.Append(new MinimalistPrinter);
+  return RUN_ALL_TESTS();
+```
+
+Now, sit back and enjoy a completely different output from your
+tests. For more details, you can read this
+[sample](../samples/sample9_unittest.cc).
+
+You may append more than one listener to the list. When an `On*Start()`
+or `OnTestPartResult()` event is fired, the listeners will receive it in
+the order they appear in the list (since new listeners are added to
+the end of the list, the default text printer and the default XML
+generator will receive the event first). An `On*End()` event will be
+received by the listeners in the _reverse_ order. This allows output by
+listeners added later to be framed by output from listeners added
+earlier.
+
+## Generating Failures in Listeners ##
+
+You may use failure-raising macros (`EXPECT_*()`, `ASSERT_*()`,
+`FAIL()`, etc) when processing an event. There are some restrictions:
+
+  1. You cannot generate any failure in `OnTestPartResult()` (otherwise it will cause `OnTestPartResult()` to be called recursively).
+  1. A listener that handles `OnTestPartResult()` is not allowed to generate any failure.
+
+When you add listeners to the listener list, you should put listeners
+that handle `OnTestPartResult()` _before_ listeners that can generate
+failures. This ensures that failures generated by the latter are
+attributed to the right test by the former.
+
+We have a sample of failure-raising listener
+[here](../samples/sample10_unittest.cc).
+
+# Running Test Programs: Advanced Options #
+
+Google Test test programs are ordinary executables. Once built, you can run
+them directly and affect their behavior via the following environment variables
+and/or command line flags. For the flags to work, your programs must call
+`::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`.
+
+To see a list of supported flags and their usage, please run your test
+program with the `--help` flag.  You can also use `-h`, `-?`, or `/?`
+for short.  This feature is added in version 1.3.0.
+
+If an option is specified both by an environment variable and by a
+flag, the latter takes precedence.  Most of the options can also be
+set/read in code: to access the value of command line flag
+`--gtest_foo`, write `::testing::GTEST_FLAG(foo)`.  A common pattern is
+to set the value of a flag before calling `::testing::InitGoogleTest()`
+to change the default value of the flag:
+```
+int main(int argc, char** argv) {
+  // Disables elapsed time by default.
+  ::testing::GTEST_FLAG(print_time) = false;
+
+  // This allows the user to override the flag on the command line.
+  ::testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}
+```
+
+## Selecting Tests ##
+
+This section shows various options for choosing which tests to run.
+
+### Listing Test Names ###
+
+Sometimes it is necessary to list the available tests in a program before
+running them so that a filter may be applied if needed. Including the flag
+`--gtest_list_tests` overrides all other flags and lists tests in the following
+format:
+```
+TestCase1.
+  TestName1
+  TestName2
+TestCase2.
+  TestName
+```
+
+None of the tests listed are actually run if the flag is provided. There is no
+corresponding environment variable for this flag.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Running a Subset of the Tests ###
+
+By default, a Google Test program runs all tests the user has defined.
+Sometimes, you want to run only a subset of the tests (e.g. for debugging or
+quickly verifying a change). If you set the `GTEST_FILTER` environment variable
+or the `--gtest_filter` flag to a filter string, Google Test will only run the
+tests whose full names (in the form of `TestCaseName.TestName`) match the
+filter.
+
+The format of a filter is a '`:`'-separated list of wildcard patterns (called
+the positive patterns) optionally followed by a '`-`' and another
+'`:`'-separated pattern list (called the negative patterns). A test matches the
+filter if and only if it matches any of the positive patterns but does not
+match any of the negative patterns.
+
+A pattern may contain `'*'` (matches any string) or `'?'` (matches any single
+character). For convenience, the filter `'*-NegativePatterns'` can be also
+written as `'-NegativePatterns'`.
+
+For example:
+
+  * `./foo_test` Has no flag, and thus runs all its tests.
+  * `./foo_test --gtest_filter=*` Also runs everything, due to the single match-everything `*` value.
+  * `./foo_test --gtest_filter=FooTest.*` Runs everything in test case `FooTest`.
+  * `./foo_test --gtest_filter=*Null*:*Constructor*` Runs any test whose full name contains either `"Null"` or `"Constructor"`.
+  * `./foo_test --gtest_filter=-*DeathTest.*` Runs all non-death tests.
+  * `./foo_test --gtest_filter=FooTest.*-FooTest.Bar` Runs everything in test case `FooTest` except `FooTest.Bar`.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Temporarily Disabling Tests ###
+
+If you have a broken test that you cannot fix right away, you can add the
+`DISABLED_` prefix to its name. This will exclude it from execution. This is
+better than commenting out the code or using `#if 0`, as disabled tests are
+still compiled (and thus won't rot).
+
+If you need to disable all tests in a test case, you can either add `DISABLED_`
+to the front of the name of each test, or alternatively add it to the front of
+the test case name.
+
+For example, the following tests won't be run by Google Test, even though they
+will still be compiled:
+
+```
+// Tests that Foo does Abc.
+TEST(FooTest, DISABLED_DoesAbc) { ... }
+
+class DISABLED_BarTest : public ::testing::Test { ... };
+
+// Tests that Bar does Xyz.
+TEST_F(DISABLED_BarTest, DoesXyz) { ... }
+```
+
+_Note:_ This feature should only be used for temporary pain-relief. You still
+have to fix the disabled tests at a later date. As a reminder, Google Test will
+print a banner warning you if a test program contains any disabled tests.
+
+_Tip:_ You can easily count the number of disabled tests you have
+using `grep`. This number can be used as a metric for improving your
+test quality.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Temporarily Enabling Disabled Tests ###
+
+To include [disabled tests](#temporarily-disabling-tests) in test
+execution, just invoke the test program with the
+`--gtest_also_run_disabled_tests` flag or set the
+`GTEST_ALSO_RUN_DISABLED_TESTS` environment variable to a value other
+than `0`.  You can combine this with the
+[--gtest\_filter](#running-a-subset-of-the-tests) flag to further select
+which disabled tests to run.
+
+_Availability:_ Linux, Windows, Mac; since version 1.3.0.
+
+## Repeating the Tests ##
+
+Once in a while you'll run into a test whose result is hit-or-miss. Perhaps it
+will fail only 1% of the time, making it rather hard to reproduce the bug under
+a debugger. This can be a major source of frustration.
+
+The `--gtest_repeat` flag allows you to repeat all (or selected) test methods
+in a program many times. Hopefully, a flaky test will eventually fail and give
+you a chance to debug. Here's how to use it:
+
+| `$ foo_test --gtest_repeat=1000` | Repeat foo\_test 1000 times and don't stop at failures. |
+|:---------------------------------|:--------------------------------------------------------|
+| `$ foo_test --gtest_repeat=-1`   | A negative count means repeating forever.               |
+| `$ foo_test --gtest_repeat=1000 --gtest_break_on_failure` | Repeat foo\_test 1000 times, stopping at the first failure. This is especially useful when running under a debugger: when the testfails, it will drop into the debugger and you can then inspect variables and stacks. |
+| `$ foo_test --gtest_repeat=1000 --gtest_filter=FooBar` | Repeat the tests whose name matches the filter 1000 times. |
+
+If your test program contains global set-up/tear-down code registered
+using `AddGlobalTestEnvironment()`, it will be repeated in each
+iteration as well, as the flakiness may be in it. You can also specify
+the repeat count by setting the `GTEST_REPEAT` environment variable.
+
+_Availability:_ Linux, Windows, Mac.
+
+## Shuffling the Tests ##
+
+You can specify the `--gtest_shuffle` flag (or set the `GTEST_SHUFFLE`
+environment variable to `1`) to run the tests in a program in a random
+order. This helps to reveal bad dependencies between tests.
+
+By default, Google Test uses a random seed calculated from the current
+time. Therefore you'll get a different order every time. The console
+output includes the random seed value, such that you can reproduce an
+order-related test failure later. To specify the random seed
+explicitly, use the `--gtest_random_seed=SEED` flag (or set the
+`GTEST_RANDOM_SEED` environment variable), where `SEED` is an integer
+between 0 and 99999. The seed value 0 is special: it tells Google Test
+to do the default behavior of calculating the seed from the current
+time.
+
+If you combine this with `--gtest_repeat=N`, Google Test will pick a
+different random seed and re-shuffle the tests in each iteration.
+
+_Availability:_ Linux, Windows, Mac; since v1.4.0.
+
+## Controlling Test Output ##
+
+This section teaches how to tweak the way test results are reported.
+
+### Colored Terminal Output ###
+
+Google Test can use colors in its terminal output to make it easier to spot
+the separation between tests, and whether tests passed.
+
+You can set the GTEST\_COLOR environment variable or set the `--gtest_color`
+command line flag to `yes`, `no`, or `auto` (the default) to enable colors,
+disable colors, or let Google Test decide. When the value is `auto`, Google
+Test will use colors if and only if the output goes to a terminal and (on
+non-Windows platforms) the `TERM` environment variable is set to `xterm` or
+`xterm-color`.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Suppressing the Elapsed Time ###
+
+By default, Google Test prints the time it takes to run each test.  To
+suppress that, run the test program with the `--gtest_print_time=0`
+command line flag.  Setting the `GTEST_PRINT_TIME` environment
+variable to `0` has the same effect.
+
+_Availability:_ Linux, Windows, Mac.  (In Google Test 1.3.0 and lower,
+the default behavior is that the elapsed time is **not** printed.)
+
+### Generating an XML Report ###
+
+Google Test can emit a detailed XML report to a file in addition to its normal
+textual output. The report contains the duration of each test, and thus can
+help you identify slow tests.
+
+To generate the XML report, set the `GTEST_OUTPUT` environment variable or the
+`--gtest_output` flag to the string `"xml:_path_to_output_file_"`, which will
+create the file at the given location. You can also just use the string
+`"xml"`, in which case the output can be found in the `test_detail.xml` file in
+the current directory.
+
+If you specify a directory (for example, `"xml:output/directory/"` on Linux or
+`"xml:output\directory\"` on Windows), Google Test will create the XML file in
+that directory, named after the test executable (e.g. `foo_test.xml` for test
+program `foo_test` or `foo_test.exe`). If the file already exists (perhaps left
+over from a previous run), Google Test will pick a different name (e.g.
+`foo_test_1.xml`) to avoid overwriting it.
+
+The report uses the format described here.  It is based on the
+`junitreport` Ant task and can be parsed by popular continuous build
+systems like [Jenkins](http://jenkins-ci.org/). Since that format
+was originally intended for Java, a little interpretation is required
+to make it apply to Google Test tests, as shown here:
+
+```
+<testsuites name="AllTests" ...>
+  <testsuite name="test_case_name" ...>
+    <testcase name="test_name" ...>
+      <failure message="..."/>
+      <failure message="..."/>
+      <failure message="..."/>
+    </testcase>
+  </testsuite>
+</testsuites>
+```
+
+  * The root `<testsuites>` element corresponds to the entire test program.
+  * `<testsuite>` elements correspond to Google Test test cases.
+  * `<testcase>` elements correspond to Google Test test functions.
+
+For instance, the following program
+
+```
+TEST(MathTest, Addition) { ... }
+TEST(MathTest, Subtraction) { ... }
+TEST(LogicTest, NonContradiction) { ... }
+```
+
+could generate this report:
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="3" failures="1" errors="0" time="35" name="AllTests">
+  <testsuite name="MathTest" tests="2" failures="1" errors="0" time="15">
+    <testcase name="Addition" status="run" time="7" classname="">
+      <failure message="Value of: add(1, 1)&#x0A; Actual: 3&#x0A;Expected: 2" type=""/>
+      <failure message="Value of: add(1, -1)&#x0A; Actual: 1&#x0A;Expected: 0" type=""/>
+    </testcase>
+    <testcase name="Subtraction" status="run" time="5" classname="">
+    </testcase>
+  </testsuite>
+  <testsuite name="LogicTest" tests="1" failures="0" errors="0" time="5">
+    <testcase name="NonContradiction" status="run" time="5" classname="">
+    </testcase>
+  </testsuite>
+</testsuites>
+```
+
+Things to note:
+
+  * The `tests` attribute of a `<testsuites>` or `<testsuite>` element tells how many test functions the Google Test program or test case contains, while the `failures` attribute tells how many of them failed.
+  * The `time` attribute expresses the duration of the test, test case, or entire test program in milliseconds.
+  * Each `<failure>` element corresponds to a single failed Google Test assertion.
+  * Some JUnit concepts don't apply to Google Test, yet we have to conform to the DTD. Therefore you'll see some dummy elements and attributes in the report. You can safely ignore these parts.
+
+_Availability:_ Linux, Windows, Mac.
+
+## Controlling How Failures Are Reported ##
+
+### Turning Assertion Failures into Break-Points ###
+
+When running test programs under a debugger, it's very convenient if the
+debugger can catch an assertion failure and automatically drop into interactive
+mode. Google Test's _break-on-failure_ mode supports this behavior.
+
+To enable it, set the `GTEST_BREAK_ON_FAILURE` environment variable to a value
+other than `0` . Alternatively, you can use the `--gtest_break_on_failure`
+command line flag.
+
+_Availability:_ Linux, Windows, Mac.
+
+### Disabling Catching Test-Thrown Exceptions ###
+
+Google Test can be used either with or without exceptions enabled.  If
+a test throws a C++ exception or (on Windows) a structured exception
+(SEH), by default Google Test catches it, reports it as a test
+failure, and continues with the next test method.  This maximizes the
+coverage of a test run.  Also, on Windows an uncaught exception will
+cause a pop-up window, so catching the exceptions allows you to run
+the tests automatically.
+
+When debugging the test failures, however, you may instead want the
+exceptions to be handled by the debugger, such that you can examine
+the call stack when an exception is thrown.  To achieve that, set the
+`GTEST_CATCH_EXCEPTIONS` environment variable to `0`, or use the
+`--gtest_catch_exceptions=0` flag when running the tests.
+
+**Availability**: Linux, Windows, Mac.
+
+### Letting Another Testing Framework Drive ###
+
+If you work on a project that has already been using another testing
+framework and is not ready to completely switch to Google Test yet,
+you can get much of Google Test's benefit by using its assertions in
+your existing tests.  Just change your `main()` function to look
+like:
+
+```
+#include "gtest/gtest.h"
+
+int main(int argc, char** argv) {
+  ::testing::GTEST_FLAG(throw_on_failure) = true;
+  // Important: Google Test must be initialized.
+  ::testing::InitGoogleTest(&argc, argv);
+
+  ... whatever your existing testing framework requires ...
+}
+```
+
+With that, you can use Google Test assertions in addition to the
+native assertions your testing framework provides, for example:
+
+```
+void TestFooDoesBar() {
+  Foo foo;
+  EXPECT_LE(foo.Bar(1), 100);     // A Google Test assertion.
+  CPPUNIT_ASSERT(foo.IsEmpty());  // A native assertion.
+}
+```
+
+If a Google Test assertion fails, it will print an error message and
+throw an exception, which will be treated as a failure by your host
+testing framework.  If you compile your code with exceptions disabled,
+a failed Google Test assertion will instead exit your program with a
+non-zero code, which will also signal a test failure to your test
+runner.
+
+If you don't write `::testing::GTEST_FLAG(throw_on_failure) = true;` in
+your `main()`, you can alternatively enable this feature by specifying
+the `--gtest_throw_on_failure` flag on the command-line or setting the
+`GTEST_THROW_ON_FAILURE` environment variable to a non-zero value.
+
+Death tests are _not_ supported when other test framework is used to organize tests.
+
+_Availability:_ Linux, Windows, Mac; since v1.3.0.
+
+## Distributing Test Functions to Multiple Machines ##
+
+If you have more than one machine you can use to run a test program,
+you might want to run the test functions in parallel and get the
+result faster.  We call this technique _sharding_, where each machine
+is called a _shard_.
+
+Google Test is compatible with test sharding.  To take advantage of
+this feature, your test runner (not part of Google Test) needs to do
+the following:
+
+  1. Allocate a number of machines (shards) to run the tests.
+  1. On each shard, set the `GTEST_TOTAL_SHARDS` environment variable to the total number of shards.  It must be the same for all shards.
+  1. On each shard, set the `GTEST_SHARD_INDEX` environment variable to the index of the shard.  Different shards must be assigned different indices, which must be in the range `[0, GTEST_TOTAL_SHARDS - 1]`.
+  1. Run the same test program on all shards.  When Google Test sees the above two environment variables, it will select a subset of the test functions to run.  Across all shards, each test function in the program will be run exactly once.
+  1. Wait for all shards to finish, then collect and report the results.
+
+Your project may have tests that were written without Google Test and
+thus don't understand this protocol.  In order for your test runner to
+figure out which test supports sharding, it can set the environment
+variable `GTEST_SHARD_STATUS_FILE` to a non-existent file path.  If a
+test program supports sharding, it will create this file to
+acknowledge the fact (the actual contents of the file are not
+important at this time; although we may stick some useful information
+in it in the future.); otherwise it will not create it.
+
+Here's an example to make it clear.  Suppose you have a test program
+`foo_test` that contains the following 5 test functions:
+```
+TEST(A, V)
+TEST(A, W)
+TEST(B, X)
+TEST(B, Y)
+TEST(B, Z)
+```
+and you have 3 machines at your disposal.  To run the test functions in
+parallel, you would set `GTEST_TOTAL_SHARDS` to 3 on all machines, and
+set `GTEST_SHARD_INDEX` to 0, 1, and 2 on the machines respectively.
+Then you would run the same `foo_test` on each machine.
+
+Google Test reserves the right to change how the work is distributed
+across the shards, but here's one possible scenario:
+
+  * Machine #0 runs `A.V` and `B.X`.
+  * Machine #1 runs `A.W` and `B.Y`.
+  * Machine #2 runs `B.Z`.
+
+_Availability:_ Linux, Windows, Mac; since version 1.3.0.
+
+# Fusing Google Test Source Files #
+
+Google Test's implementation consists of ~30 files (excluding its own
+tests).  Sometimes you may want them to be packaged up in two files (a
+`.h` and a `.cc`) instead, such that you can easily copy them to a new
+machine and start hacking there.  For this we provide an experimental
+Python script `fuse_gtest_files.py` in the `scripts/` directory (since release 1.3.0).
+Assuming you have Python 2.4 or above installed on your machine, just
+go to that directory and run
+```
+python fuse_gtest_files.py OUTPUT_DIR
+```
+
+and you should see an `OUTPUT_DIR` directory being created with files
+`gtest/gtest.h` and `gtest/gtest-all.cc` in it.  These files contain
+everything you need to use Google Test.  Just copy them to anywhere
+you want and you are ready to write tests.  You can use the
+[scripts/test/Makefile](../scripts/test/Makefile)
+file as an example on how to compile your tests against them.
+
+# Where to Go from Here #
+
+Congratulations! You've now learned more advanced Google Test tools and are
+ready to tackle more complex testing tasks. If you want to dive even deeper, you
+can read the [Frequently-Asked Questions](V1_7_FAQ.md).
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Documentation.md
new file mode 100644
index 00000000..282697a5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Documentation.md
@@ -0,0 +1,14 @@
+This page lists all documentation wiki pages for Google Test **(the SVN trunk version)**
+-- **if you use a released version of Google Test, please read the
+documentation for that specific version instead.**
+
+  * [Primer](V1_7_Primer.md) -- start here if you are new to Google Test.
+  * [Samples](V1_7_Samples.md) -- learn from examples.
+  * [AdvancedGuide](V1_7_AdvancedGuide.md) -- learn more about Google Test.
+  * [XcodeGuide](V1_7_XcodeGuide.md) -- how to use Google Test in Xcode on Mac.
+  * [Frequently-Asked Questions](V1_7_FAQ.md) -- check here before asking a question on the mailing list.
+
+To contribute code to Google Test, read:
+
+  * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
+  * [PumpManual](V1_7_PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_FAQ.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_FAQ.md
new file mode 100644
index 00000000..3dd914dc
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_FAQ.md
@@ -0,0 +1,1082 @@
+
+
+If you cannot find the answer to your question here, and you have read
+[Primer](V1_7_Primer.md) and [AdvancedGuide](V1_7_AdvancedGuide.md), send it to
+googletestframework@googlegroups.com.
+
+## Why should I use Google Test instead of my favorite C++ testing framework? ##
+
+First, let us say clearly that we don't want to get into the debate of
+which C++ testing framework is **the best**.  There exist many fine
+frameworks for writing C++ tests, and we have tremendous respect for
+the developers and users of them.  We don't think there is (or will
+be) a single best framework - you have to pick the right tool for the
+particular task you are tackling.
+
+We created Google Test because we couldn't find the right combination
+of features and conveniences in an existing framework to satisfy _our_
+needs.  The following is a list of things that _we_ like about Google
+Test.  We don't claim them to be unique to Google Test - rather, the
+combination of them makes Google Test the choice for us.  We hope this
+list can help you decide whether it is for you too.
+
+  * Google Test is designed to be portable: it doesn't require exceptions or RTTI; it works around various bugs in various compilers and environments; etc.  As a result, it works on Linux, Mac OS X, Windows and several embedded operating systems.
+  * Nonfatal assertions (`EXPECT_*`) have proven to be great time savers, as they allow a test to report multiple failures in a single edit-compile-test cycle.
+  * It's easy to write assertions that generate informative messages: you just use the stream syntax to append any additional information, e.g. `ASSERT_EQ(5, Foo(i)) << " where i = " << i;`.  It doesn't require a new set of macros or special functions.
+  * Google Test automatically detects your tests and doesn't require you to enumerate them in order to run them.
+  * Death tests are pretty handy for ensuring that your asserts in production code are triggered by the right conditions.
+  * `SCOPED_TRACE` helps you understand the context of an assertion failure when it comes from inside a sub-routine or loop.
+  * You can decide which tests to run using name patterns.  This saves time when you want to quickly reproduce a test failure.
+  * Google Test can generate XML test result reports that can be parsed by popular continuous build system like Hudson.
+  * Simple things are easy in Google Test, while hard things are possible: in addition to advanced features like [global test environments](V1_7_AdvancedGuide.md#global-set-up-and-tear-down) and tests parameterized by [values](V1_7_AdvancedGuide.md#value-parameterized-tests) or [types](V1_7_AdvancedGuide.md#typed-tests), Google Test supports various ways for the user to extend the framework -- if Google Test doesn't do something out of the box, chances are that a user can implement the feature using Google Test's public API, without changing Google Test itself.  In particular, you can:
+    * expand your testing vocabulary by defining [custom predicates](V1_7_AdvancedGuide.md#predicate-assertions-for-better-error-messages),
+    * teach Google Test how to [print your types](V1_7_AdvancedGuide.md#teaching-google-test-how-to-print-your-values),
+    * define your own testing macros or utilities and verify them using Google Test's [Service Provider Interface](V1_7_AdvancedGuide.md#catching-failures), and
+    * reflect on the test cases or change the test output format by intercepting the [test events](V1_7_AdvancedGuide.md#extending-google-test-by-handling-test-events).
+
+## I'm getting warnings when compiling Google Test.  Would you fix them? ##
+
+We strive to minimize compiler warnings Google Test generates.  Before releasing a new version, we test to make sure that it doesn't generate warnings when compiled using its CMake script on Windows, Linux, and Mac OS.
+
+Unfortunately, this doesn't mean you are guaranteed to see no warnings when compiling Google Test in your environment:
+
+  * You may be using a different compiler as we use, or a different version of the same compiler.  We cannot possibly test for all compilers.
+  * You may be compiling on a different platform as we do.
+  * Your project may be using different compiler flags as we do.
+
+It is not always possible to make Google Test warning-free for everyone.  Or, it may not be desirable if the warning is rarely enabled and fixing the violations makes the code more complex.
+
+If you see warnings when compiling Google Test, we suggest that you use the `-isystem` flag (assuming your are using GCC) to mark Google Test headers as system headers.  That'll suppress warnings from Google Test headers.
+
+## Why should not test case names and test names contain underscore? ##
+
+Underscore (`_`) is special, as C++ reserves the following to be used by
+the compiler and the standard library:
+
+  1. any identifier that starts with an `_` followed by an upper-case letter, and
+  1. any identifier that containers two consecutive underscores (i.e. `__`) _anywhere_ in its name.
+
+User code is _prohibited_ from using such identifiers.
+
+Now let's look at what this means for `TEST` and `TEST_F`.
+
+Currently `TEST(TestCaseName, TestName)` generates a class named
+`TestCaseName_TestName_Test`.  What happens if `TestCaseName` or `TestName`
+contains `_`?
+
+  1. If `TestCaseName` starts with an `_` followed by an upper-case letter (say, `_Foo`), we end up with `_Foo_TestName_Test`, which is reserved and thus invalid.
+  1. If `TestCaseName` ends with an `_` (say, `Foo_`), we get `Foo__TestName_Test`, which is invalid.
+  1. If `TestName` starts with an `_` (say, `_Bar`), we get `TestCaseName__Bar_Test`, which is invalid.
+  1. If `TestName` ends with an `_` (say, `Bar_`), we get `TestCaseName_Bar__Test`, which is invalid.
+
+So clearly `TestCaseName` and `TestName` cannot start or end with `_`
+(Actually, `TestCaseName` can start with `_` -- as long as the `_` isn't
+followed by an upper-case letter.  But that's getting complicated.  So
+for simplicity we just say that it cannot start with `_`.).
+
+It may seem fine for `TestCaseName` and `TestName` to contain `_` in the
+middle.  However, consider this:
+```
+TEST(Time, Flies_Like_An_Arrow) { ... }
+TEST(Time_Flies, Like_An_Arrow) { ... }
+```
+
+Now, the two `TEST`s will both generate the same class
+(`Time_Files_Like_An_Arrow_Test`).  That's not good.
+
+So for simplicity, we just ask the users to avoid `_` in `TestCaseName`
+and `TestName`.  The rule is more constraining than necessary, but it's
+simple and easy to remember.  It also gives Google Test some wiggle
+room in case its implementation needs to change in the future.
+
+If you violate the rule, there may not be immediately consequences,
+but your test may (just may) break with a new compiler (or a new
+version of the compiler you are using) or with a new version of Google
+Test.  Therefore it's best to follow the rule.
+
+## Why is it not recommended to install a pre-compiled copy of Google Test (for example, into /usr/local)? ##
+
+In the early days, we said that you could install
+compiled Google Test libraries on `*`nix systems using `make install`.
+Then every user of your machine can write tests without
+recompiling Google Test.
+
+This seemed like a good idea, but it has a
+got-cha: every user needs to compile his tests using the _same_ compiler
+flags used to compile the installed Google Test libraries; otherwise
+he may run into undefined behaviors (i.e. the tests can behave
+strangely and may even crash for no obvious reasons).
+
+Why?  Because C++ has this thing called the One-Definition Rule: if
+two C++ source files contain different definitions of the same
+class/function/variable, and you link them together, you violate the
+rule.  The linker may or may not catch the error (in many cases it's
+not required by the C++ standard to catch the violation).  If it
+doesn't, you get strange run-time behaviors that are unexpected and
+hard to debug.
+
+If you compile Google Test and your test code using different compiler
+flags, they may see different definitions of the same
+class/function/variable (e.g. due to the use of `#if` in Google Test).
+Therefore, for your sanity, we recommend to avoid installing pre-compiled
+Google Test libraries.  Instead, each project should compile
+Google Test itself such that it can be sure that the same flags are
+used for both Google Test and the tests.
+
+## How do I generate 64-bit binaries on Windows (using Visual Studio 2008)? ##
+
+(Answered by Trevor Robinson)
+
+Load the supplied Visual Studio solution file, either `msvc\gtest-md.sln` or
+`msvc\gtest.sln`. Go through the migration wizard to migrate the
+solution and project files to Visual Studio 2008. Select
+`Configuration Manager...` from the `Build` menu. Select `<New...>` from
+the `Active solution platform` dropdown.  Select `x64` from the new
+platform dropdown, leave `Copy settings from` set to `Win32` and
+`Create new project platforms` checked, then click `OK`. You now have
+`Win32` and `x64` platform configurations, selectable from the
+`Standard` toolbar, which allow you to toggle between building 32-bit or
+64-bit binaries (or both at once using Batch Build).
+
+In order to prevent build output files from overwriting one another,
+you'll need to change the `Intermediate Directory` settings for the
+newly created platform configuration across all the projects. To do
+this, multi-select (e.g. using shift-click) all projects (but not the
+solution) in the `Solution Explorer`. Right-click one of them and
+select `Properties`. In the left pane, select `Configuration Properties`,
+and from the `Configuration` dropdown, select `All Configurations`.
+Make sure the selected platform is `x64`. For the
+`Intermediate Directory` setting, change the value from
+`$(PlatformName)\$(ConfigurationName)` to
+`$(OutDir)\$(ProjectName)`. Click `OK` and then build the
+solution. When the build is complete, the 64-bit binaries will be in
+the `msvc\x64\Debug` directory.
+
+## Can I use Google Test on MinGW? ##
+
+We haven't tested this ourselves, but Per Abrahamsen reported that he
+was able to compile and install Google Test successfully when using
+MinGW from Cygwin.  You'll need to configure it with:
+
+`PATH/TO/configure CC="gcc -mno-cygwin" CXX="g++ -mno-cygwin"`
+
+You should be able to replace the `-mno-cygwin` option with direct links
+to the real MinGW binaries, but we haven't tried that.
+
+Caveats:
+
+  * There are many warnings when compiling.
+  * `make check` will produce some errors as not all tests for Google Test itself are compatible with MinGW.
+
+We also have reports on successful cross compilation of Google Test
+MinGW binaries on Linux using
+[these instructions](http://wiki.wxwidgets.org/Cross-Compiling_Under_Linux#Cross-compiling_under_Linux_for_MS_Windows)
+on the WxWidgets site.
+
+Please contact `googletestframework@googlegroups.com` if you are
+interested in improving the support for MinGW.
+
+## Why does Google Test support EXPECT\_EQ(NULL, ptr) and ASSERT\_EQ(NULL, ptr) but not EXPECT\_NE(NULL, ptr) and ASSERT\_NE(NULL, ptr)? ##
+
+Due to some peculiarity of C++, it requires some non-trivial template
+meta programming tricks to support using `NULL` as an argument of the
+`EXPECT_XX()` and `ASSERT_XX()` macros. Therefore we only do it where
+it's most needed (otherwise we make the implementation of Google Test
+harder to maintain and more error-prone than necessary).
+
+The `EXPECT_EQ()` macro takes the _expected_ value as its first
+argument and the _actual_ value as the second. It's reasonable that
+someone wants to write `EXPECT_EQ(NULL, some_expression)`, and this
+indeed was requested several times. Therefore we implemented it.
+
+The need for `EXPECT_NE(NULL, ptr)` isn't nearly as strong. When the
+assertion fails, you already know that `ptr` must be `NULL`, so it
+doesn't add any information to print ptr in this case. That means
+`EXPECT_TRUE(ptr != NULL)` works just as well.
+
+If we were to support `EXPECT_NE(NULL, ptr)`, for consistency we'll
+have to support `EXPECT_NE(ptr, NULL)` as well, as unlike `EXPECT_EQ`,
+we don't have a convention on the order of the two arguments for
+`EXPECT_NE`. This means using the template meta programming tricks
+twice in the implementation, making it even harder to understand and
+maintain. We believe the benefit doesn't justify the cost.
+
+Finally, with the growth of Google Mock's [matcher](../../CookBook.md#using-matchers-in-google-test-assertions) library, we are
+encouraging people to use the unified `EXPECT_THAT(value, matcher)`
+syntax more often in tests. One significant advantage of the matcher
+approach is that matchers can be easily combined to form new matchers,
+while the `EXPECT_NE`, etc, macros cannot be easily
+combined. Therefore we want to invest more in the matchers than in the
+`EXPECT_XX()` macros.
+
+## Does Google Test support running tests in parallel? ##
+
+Test runners tend to be tightly coupled with the build/test
+environment, and Google Test doesn't try to solve the problem of
+running tests in parallel.  Instead, we tried to make Google Test work
+nicely with test runners.  For example, Google Test's XML report
+contains the time spent on each test, and its `gtest_list_tests` and
+`gtest_filter` flags can be used for splitting the execution of test
+methods into multiple processes.  These functionalities can help the
+test runner run the tests in parallel.
+
+## Why don't Google Test run the tests in different threads to speed things up? ##
+
+It's difficult to write thread-safe code.  Most tests are not written
+with thread-safety in mind, and thus may not work correctly in a
+multi-threaded setting.
+
+If you think about it, it's already hard to make your code work when
+you know what other threads are doing.  It's much harder, and
+sometimes even impossible, to make your code work when you don't know
+what other threads are doing (remember that test methods can be added,
+deleted, or modified after your test was written).  If you want to run
+the tests in parallel, you'd better run them in different processes.
+
+## Why aren't Google Test assertions implemented using exceptions? ##
+
+Our original motivation was to be able to use Google Test in projects
+that disable exceptions.  Later we realized some additional benefits
+of this approach:
+
+  1. Throwing in a destructor is undefined behavior in C++.  Not using exceptions means Google Test's assertions are safe to use in destructors.
+  1. The `EXPECT_*` family of macros will continue even after a failure, allowing multiple failures in a `TEST` to be reported in a single run. This is a popular feature, as in C++ the edit-compile-test cycle is usually quite long and being able to fixing more than one thing at a time is a blessing.
+  1. If assertions are implemented using exceptions, a test may falsely ignore a failure if it's caught by user code:
+```
+try { ... ASSERT_TRUE(...) ... }
+catch (...) { ... }
+```
+The above code will pass even if the `ASSERT_TRUE` throws.  While it's unlikely for someone to write this in a test, it's possible to run into this pattern when you write assertions in callbacks that are called by the code under test.
+
+The downside of not using exceptions is that `ASSERT_*` (implemented
+using `return`) will only abort the current function, not the current
+`TEST`.
+
+## Why do we use two different macros for tests with and without fixtures? ##
+
+Unfortunately, C++'s macro system doesn't allow us to use the same
+macro for both cases.  One possibility is to provide only one macro
+for tests with fixtures, and require the user to define an empty
+fixture sometimes:
+
+```
+class FooTest : public ::testing::Test {};
+
+TEST_F(FooTest, DoesThis) { ... }
+```
+or
+```
+typedef ::testing::Test FooTest;
+
+TEST_F(FooTest, DoesThat) { ... }
+```
+
+Yet, many people think this is one line too many. :-) Our goal was to
+make it really easy to write tests, so we tried to make simple tests
+trivial to create.  That means using a separate macro for such tests.
+
+We think neither approach is ideal, yet either of them is reasonable.
+In the end, it probably doesn't matter much either way.
+
+## Why don't we use structs as test fixtures? ##
+
+We like to use structs only when representing passive data.  This
+distinction between structs and classes is good for documenting the
+intent of the code's author.  Since test fixtures have logic like
+`SetUp()` and `TearDown()`, they are better defined as classes.
+
+## Why are death tests implemented as assertions instead of using a test runner? ##
+
+Our goal was to make death tests as convenient for a user as C++
+possibly allows.  In particular:
+
+  * The runner-style requires to split the information into two pieces: the definition of the death test itself, and the specification for the runner on how to run the death test and what to expect.  The death test would be written in C++, while the runner spec may or may not be.  A user needs to carefully keep the two in sync. `ASSERT_DEATH(statement, expected_message)` specifies all necessary information in one place, in one language, without boilerplate code. It is very declarative.
+  * `ASSERT_DEATH` has a similar syntax and error-reporting semantics as other Google Test assertions, and thus is easy to learn.
+  * `ASSERT_DEATH` can be mixed with other assertions and other logic at your will.  You are not limited to one death test per test method. For example, you can write something like:
+```
+    if (FooCondition()) {
+      ASSERT_DEATH(Bar(), "blah");
+    } else {
+      ASSERT_EQ(5, Bar());
+    }
+```
+If you prefer one death test per test method, you can write your tests in that style too, but we don't want to impose that on the users.  The fewer artificial limitations the better.
+  * `ASSERT_DEATH` can reference local variables in the current function, and you can decide how many death tests you want based on run-time information.  For example,
+```
+    const int count = GetCount();  // Only known at run time.
+    for (int i = 1; i <= count; i++) {
+      ASSERT_DEATH({
+        double* buffer = new double[i];
+        ... initializes buffer ...
+        Foo(buffer, i)
+      }, "blah blah");
+    }
+```
+The runner-based approach tends to be more static and less flexible, or requires more user effort to get this kind of flexibility.
+
+Another interesting thing about `ASSERT_DEATH` is that it calls `fork()`
+to create a child process to run the death test.  This is lightening
+fast, as `fork()` uses copy-on-write pages and incurs almost zero
+overhead, and the child process starts from the user-supplied
+statement directly, skipping all global and local initialization and
+any code leading to the given statement.  If you launch the child
+process from scratch, it can take seconds just to load everything and
+start running if the test links to many libraries dynamically.
+
+## My death test modifies some state, but the change seems lost after the death test finishes. Why? ##
+
+Death tests (`EXPECT_DEATH`, etc) are executed in a sub-process s.t. the
+expected crash won't kill the test program (i.e. the parent process). As a
+result, any in-memory side effects they incur are observable in their
+respective sub-processes, but not in the parent process. You can think of them
+as running in a parallel universe, more or less.
+
+## The compiler complains about "undefined references" to some static const member variables, but I did define them in the class body. What's wrong? ##
+
+If your class has a static data member:
+
+```
+// foo.h
+class Foo {
+  ...
+  static const int kBar = 100;
+};
+```
+
+You also need to define it _outside_ of the class body in `foo.cc`:
+
+```
+const int Foo::kBar;  // No initializer here.
+```
+
+Otherwise your code is **invalid C++**, and may break in unexpected ways. In
+particular, using it in Google Test comparison assertions (`EXPECT_EQ`, etc)
+will generate an "undefined reference" linker error.
+
+## I have an interface that has several implementations. Can I write a set of tests once and repeat them over all the implementations? ##
+
+Google Test doesn't yet have good support for this kind of tests, or
+data-driven tests in general. We hope to be able to make improvements in this
+area soon.
+
+## Can I derive a test fixture from another? ##
+
+Yes.
+
+Each test fixture has a corresponding and same named test case. This means only
+one test case can use a particular fixture. Sometimes, however, multiple test
+cases may want to use the same or slightly different fixtures. For example, you
+may want to make sure that all of a GUI library's test cases don't leak
+important system resources like fonts and brushes.
+
+In Google Test, you share a fixture among test cases by putting the shared
+logic in a base test fixture, then deriving from that base a separate fixture
+for each test case that wants to use this common logic. You then use `TEST_F()`
+to write tests using each derived fixture.
+
+Typically, your code looks like this:
+
+```
+// Defines a base test fixture.
+class BaseTest : public ::testing::Test {
+  protected:
+   ...
+};
+
+// Derives a fixture FooTest from BaseTest.
+class FooTest : public BaseTest {
+  protected:
+    virtual void SetUp() {
+      BaseTest::SetUp();  // Sets up the base fixture first.
+      ... additional set-up work ...
+    }
+    virtual void TearDown() {
+      ... clean-up work for FooTest ...
+      BaseTest::TearDown();  // Remember to tear down the base fixture
+                             // after cleaning up FooTest!
+    }
+    ... functions and variables for FooTest ...
+};
+
+// Tests that use the fixture FooTest.
+TEST_F(FooTest, Bar) { ... }
+TEST_F(FooTest, Baz) { ... }
+
+... additional fixtures derived from BaseTest ...
+```
+
+If necessary, you can continue to derive test fixtures from a derived fixture.
+Google Test has no limit on how deep the hierarchy can be.
+
+For a complete example using derived test fixtures, see
+[sample5](../samples/sample5_unittest.cc).
+
+## My compiler complains "void value not ignored as it ought to be." What does this mean? ##
+
+You're probably using an `ASSERT_*()` in a function that doesn't return `void`.
+`ASSERT_*()` can only be used in `void` functions.
+
+## My death test hangs (or seg-faults). How do I fix it? ##
+
+In Google Test, death tests are run in a child process and the way they work is
+delicate. To write death tests you really need to understand how they work.
+Please make sure you have read this.
+
+In particular, death tests don't like having multiple threads in the parent
+process. So the first thing you can try is to eliminate creating threads
+outside of `EXPECT_DEATH()`.
+
+Sometimes this is impossible as some library you must use may be creating
+threads before `main()` is even reached. In this case, you can try to minimize
+the chance of conflicts by either moving as many activities as possible inside
+`EXPECT_DEATH()` (in the extreme case, you want to move everything inside), or
+leaving as few things as possible in it. Also, you can try to set the death
+test style to `"threadsafe"`, which is safer but slower, and see if it helps.
+
+If you go with thread-safe death tests, remember that they rerun the test
+program from the beginning in the child process. Therefore make sure your
+program can run side-by-side with itself and is deterministic.
+
+In the end, this boils down to good concurrent programming. You have to make
+sure that there is no race conditions or dead locks in your program. No silver
+bullet - sorry!
+
+## Should I use the constructor/destructor of the test fixture or the set-up/tear-down function? ##
+
+The first thing to remember is that Google Test does not reuse the
+same test fixture object across multiple tests. For each `TEST_F`,
+Google Test will create a fresh test fixture object, _immediately_
+call `SetUp()`, run the test, call `TearDown()`, and then
+_immediately_ delete the test fixture object. Therefore, there is no
+need to write a `SetUp()` or `TearDown()` function if the constructor
+or destructor already does the job.
+
+You may still want to use `SetUp()/TearDown()` in the following cases:
+  * If the tear-down operation could throw an exception, you must use `TearDown()` as opposed to the destructor, as throwing in a destructor leads to undefined behavior and usually will kill your program right away. Note that many standard libraries (like STL) may throw when exceptions are enabled in the compiler. Therefore you should prefer `TearDown()` if you want to write portable tests that work with or without exceptions.
+  * The assertion macros throw an exception when flag `--gtest_throw_on_failure` is specified. Therefore, you shouldn't use Google Test assertions in a destructor if you plan to run your tests with this flag.
+  * In a constructor or destructor, you cannot make a virtual function call on this object. (You can call a method declared as virtual, but it will be statically bound.) Therefore, if you need to call a method that will be overriden in a derived class, you have to use `SetUp()/TearDown()`.
+
+## The compiler complains "no matching function to call" when I use ASSERT\_PREDn. How do I fix it? ##
+
+If the predicate function you use in `ASSERT_PRED*` or `EXPECT_PRED*` is
+overloaded or a template, the compiler will have trouble figuring out which
+overloaded version it should use. `ASSERT_PRED_FORMAT*` and
+`EXPECT_PRED_FORMAT*` don't have this problem.
+
+If you see this error, you might want to switch to
+`(ASSERT|EXPECT)_PRED_FORMAT*`, which will also give you a better failure
+message. If, however, that is not an option, you can resolve the problem by
+explicitly telling the compiler which version to pick.
+
+For example, suppose you have
+
+```
+bool IsPositive(int n) {
+  return n > 0;
+}
+bool IsPositive(double x) {
+  return x > 0;
+}
+```
+
+you will get a compiler error if you write
+
+```
+EXPECT_PRED1(IsPositive, 5);
+```
+
+However, this will work:
+
+```
+EXPECT_PRED1(*static_cast<bool (*)(int)>*(IsPositive), 5);
+```
+
+(The stuff inside the angled brackets for the `static_cast` operator is the
+type of the function pointer for the `int`-version of `IsPositive()`.)
+
+As another example, when you have a template function
+
+```
+template <typename T>
+bool IsNegative(T x) {
+  return x < 0;
+}
+```
+
+you can use it in a predicate assertion like this:
+
+```
+ASSERT_PRED1(IsNegative*<int>*, -5);
+```
+
+Things are more interesting if your template has more than one parameters. The
+following won't compile:
+
+```
+ASSERT_PRED2(*GreaterThan<int, int>*, 5, 0);
+```
+
+
+as the C++ pre-processor thinks you are giving `ASSERT_PRED2` 4 arguments,
+which is one more than expected. The workaround is to wrap the predicate
+function in parentheses:
+
+```
+ASSERT_PRED2(*(GreaterThan<int, int>)*, 5, 0);
+```
+
+
+## My compiler complains about "ignoring return value" when I call RUN\_ALL\_TESTS(). Why? ##
+
+Some people had been ignoring the return value of `RUN_ALL_TESTS()`. That is,
+instead of
+
+```
+return RUN_ALL_TESTS();
+```
+
+they write
+
+```
+RUN_ALL_TESTS();
+```
+
+This is wrong and dangerous. A test runner needs to see the return value of
+`RUN_ALL_TESTS()` in order to determine if a test has passed. If your `main()`
+function ignores it, your test will be considered successful even if it has a
+Google Test assertion failure. Very bad.
+
+To help the users avoid this dangerous bug, the implementation of
+`RUN_ALL_TESTS()` causes gcc to raise this warning, when the return value is
+ignored. If you see this warning, the fix is simple: just make sure its value
+is used as the return value of `main()`.
+
+## My compiler complains that a constructor (or destructor) cannot return a value. What's going on? ##
+
+Due to a peculiarity of C++, in order to support the syntax for streaming
+messages to an `ASSERT_*`, e.g.
+
+```
+ASSERT_EQ(1, Foo()) << "blah blah" << foo;
+```
+
+we had to give up using `ASSERT*` and `FAIL*` (but not `EXPECT*` and
+`ADD_FAILURE*`) in constructors and destructors. The workaround is to move the
+content of your constructor/destructor to a private void member function, or
+switch to `EXPECT_*()` if that works. This section in the user's guide explains
+it.
+
+## My set-up function is not called. Why? ##
+
+C++ is case-sensitive. It should be spelled as `SetUp()`.  Did you
+spell it as `Setup()`?
+
+Similarly, sometimes people spell `SetUpTestCase()` as `SetupTestCase()` and
+wonder why it's never called.
+
+## How do I jump to the line of a failure in Emacs directly? ##
+
+Google Test's failure message format is understood by Emacs and many other
+IDEs, like acme and XCode. If a Google Test message is in a compilation buffer
+in Emacs, then it's clickable. You can now hit `enter` on a message to jump to
+the corresponding source code, or use `C-x `` to jump to the next failure.
+
+## I have several test cases which share the same test fixture logic, do I have to define a new test fixture class for each of them? This seems pretty tedious. ##
+
+You don't have to. Instead of
+
+```
+class FooTest : public BaseTest {};
+
+TEST_F(FooTest, Abc) { ... }
+TEST_F(FooTest, Def) { ... }
+
+class BarTest : public BaseTest {};
+
+TEST_F(BarTest, Abc) { ... }
+TEST_F(BarTest, Def) { ... }
+```
+
+you can simply `typedef` the test fixtures:
+```
+typedef BaseTest FooTest;
+
+TEST_F(FooTest, Abc) { ... }
+TEST_F(FooTest, Def) { ... }
+
+typedef BaseTest BarTest;
+
+TEST_F(BarTest, Abc) { ... }
+TEST_F(BarTest, Def) { ... }
+```
+
+## The Google Test output is buried in a whole bunch of log messages. What do I do? ##
+
+The Google Test output is meant to be a concise and human-friendly report. If
+your test generates textual output itself, it will mix with the Google Test
+output, making it hard to read. However, there is an easy solution to this
+problem.
+
+Since most log messages go to stderr, we decided to let Google Test output go
+to stdout. This way, you can easily separate the two using redirection. For
+example:
+```
+./my_test > googletest_output.txt
+```
+
+## Why should I prefer test fixtures over global variables? ##
+
+There are several good reasons:
+  1. It's likely your test needs to change the states of its global variables. This makes it difficult to keep side effects from escaping one test and contaminating others, making debugging difficult. By using fixtures, each test has a fresh set of variables that's different (but with the same names). Thus, tests are kept independent of each other.
+  1. Global variables pollute the global namespace.
+  1. Test fixtures can be reused via subclassing, which cannot be done easily with global variables. This is useful if many test cases have something in common.
+
+## How do I test private class members without writing FRIEND\_TEST()s? ##
+
+You should try to write testable code, which means classes should be easily
+tested from their public interface. One way to achieve this is the Pimpl idiom:
+you move all private members of a class into a helper class, and make all
+members of the helper class public.
+
+You have several other options that don't require using `FRIEND_TEST`:
+  * Write the tests as members of the fixture class:
+```
+class Foo {
+  friend class FooTest;
+  ...
+};
+
+class FooTest : public ::testing::Test {
+ protected:
+  ...
+  void Test1() {...} // This accesses private members of class Foo.
+  void Test2() {...} // So does this one.
+};
+
+TEST_F(FooTest, Test1) {
+  Test1();
+}
+
+TEST_F(FooTest, Test2) {
+  Test2();
+}
+```
+  * In the fixture class, write accessors for the tested class' private members, then use the accessors in your tests:
+```
+class Foo {
+  friend class FooTest;
+  ...
+};
+
+class FooTest : public ::testing::Test {
+ protected:
+  ...
+  T1 get_private_member1(Foo* obj) {
+    return obj->private_member1_;
+  }
+};
+
+TEST_F(FooTest, Test1) {
+  ...
+  get_private_member1(x)
+  ...
+}
+```
+  * If the methods are declared **protected**, you can change their access level in a test-only subclass:
+```
+class YourClass {
+  ...
+ protected: // protected access for testability.
+  int DoSomethingReturningInt();
+  ...
+};
+
+// in the your_class_test.cc file:
+class TestableYourClass : public YourClass {
+  ...
+ public: using YourClass::DoSomethingReturningInt; // changes access rights
+  ...
+};
+
+TEST_F(YourClassTest, DoSomethingTest) {
+  TestableYourClass obj;
+  assertEquals(expected_value, obj.DoSomethingReturningInt());
+}
+```
+
+## How do I test private class static members without writing FRIEND\_TEST()s? ##
+
+We find private static methods clutter the header file.  They are
+implementation details and ideally should be kept out of a .h. So often I make
+them free functions instead.
+
+Instead of:
+```
+// foo.h
+class Foo {
+  ...
+ private:
+  static bool Func(int n);
+};
+
+// foo.cc
+bool Foo::Func(int n) { ... }
+
+// foo_test.cc
+EXPECT_TRUE(Foo::Func(12345));
+```
+
+You probably should better write:
+```
+// foo.h
+class Foo {
+  ...
+};
+
+// foo.cc
+namespace internal {
+  bool Func(int n) { ... }
+}
+
+// foo_test.cc
+namespace internal {
+  bool Func(int n);
+}
+
+EXPECT_TRUE(internal::Func(12345));
+```
+
+## I would like to run a test several times with different parameters. Do I need to write several similar copies of it? ##
+
+No. You can use a feature called [value-parameterized tests](V1_7_AdvancedGuide.md#Value_Parameterized_Tests) which
+lets you repeat your tests with different parameters, without defining it more than once.
+
+## How do I test a file that defines main()? ##
+
+To test a `foo.cc` file, you need to compile and link it into your unit test
+program. However, when the file contains a definition for the `main()`
+function, it will clash with the `main()` of your unit test, and will result in
+a build error.
+
+The right solution is to split it into three files:
+  1. `foo.h` which contains the declarations,
+  1. `foo.cc` which contains the definitions except `main()`, and
+  1. `foo_main.cc` which contains nothing but the definition of `main()`.
+
+Then `foo.cc` can be easily tested.
+
+If you are adding tests to an existing file and don't want an intrusive change
+like this, there is a hack: just include the entire `foo.cc` file in your unit
+test. For example:
+```
+// File foo_unittest.cc
+
+// The headers section
+...
+
+// Renames main() in foo.cc to make room for the unit test main()
+#define main FooMain
+
+#include "a/b/foo.cc"
+
+// The tests start here.
+...
+```
+
+
+However, please remember this is a hack and should only be used as the last
+resort.
+
+## What can the statement argument in ASSERT\_DEATH() be? ##
+
+`ASSERT_DEATH(_statement_, _regex_)` (or any death assertion macro) can be used
+wherever `_statement_` is valid. So basically `_statement_` can be any C++
+statement that makes sense in the current context. In particular, it can
+reference global and/or local variables, and can be:
+  * a simple function call (often the case),
+  * a complex expression, or
+  * a compound statement.
+
+> Some examples are shown here:
+
+```
+// A death test can be a simple function call.
+TEST(MyDeathTest, FunctionCall) {
+  ASSERT_DEATH(Xyz(5), "Xyz failed");
+}
+
+// Or a complex expression that references variables and functions.
+TEST(MyDeathTest, ComplexExpression) {
+  const bool c = Condition();
+  ASSERT_DEATH((c ? Func1(0) : object2.Method("test")),
+               "(Func1|Method) failed");
+}
+
+// Death assertions can be used any where in a function. In
+// particular, they can be inside a loop.
+TEST(MyDeathTest, InsideLoop) {
+  // Verifies that Foo(0), Foo(1), ..., and Foo(4) all die.
+  for (int i = 0; i < 5; i++) {
+    EXPECT_DEATH_M(Foo(i), "Foo has \\d+ errors",
+                   ::testing::Message() << "where i is " << i);
+  }
+}
+
+// A death assertion can contain a compound statement.
+TEST(MyDeathTest, CompoundStatement) {
+  // Verifies that at lease one of Bar(0), Bar(1), ..., and
+  // Bar(4) dies.
+  ASSERT_DEATH({
+    for (int i = 0; i < 5; i++) {
+      Bar(i);
+    }
+  },
+  "Bar has \\d+ errors");}
+```
+
+`googletest_unittest.cc` contains more examples if you are interested.
+
+## What syntax does the regular expression in ASSERT\_DEATH use? ##
+
+On POSIX systems, Google Test uses the POSIX Extended regular
+expression syntax
+(http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
+On Windows, it uses a limited variant of regular expression
+syntax. For more details, see the
+[regular expression syntax](V1_7_AdvancedGuide.md#Regular_Expression_Syntax).
+
+## I have a fixture class Foo, but TEST\_F(Foo, Bar) gives me error "no matching function for call to Foo::Foo()". Why? ##
+
+Google Test needs to be able to create objects of your test fixture class, so
+it must have a default constructor. Normally the compiler will define one for
+you. However, there are cases where you have to define your own:
+  * If you explicitly declare a non-default constructor for class `Foo`, then you need to define a default constructor, even if it would be empty.
+  * If `Foo` has a const non-static data member, then you have to define the default constructor _and_ initialize the const member in the initializer list of the constructor. (Early versions of `gcc` doesn't force you to initialize the const member. It's a bug that has been fixed in `gcc 4`.)
+
+## Why does ASSERT\_DEATH complain about previous threads that were already joined? ##
+
+With the Linux pthread library, there is no turning back once you cross the
+line from single thread to multiple threads. The first time you create a
+thread, a manager thread is created in addition, so you get 3, not 2, threads.
+Later when the thread you create joins the main thread, the thread count
+decrements by 1, but the manager thread will never be killed, so you still have
+2 threads, which means you cannot safely run a death test.
+
+The new NPTL thread library doesn't suffer from this problem, as it doesn't
+create a manager thread. However, if you don't control which machine your test
+runs on, you shouldn't depend on this.
+
+## Why does Google Test require the entire test case, instead of individual tests, to be named FOODeathTest when it uses ASSERT\_DEATH? ##
+
+Google Test does not interleave tests from different test cases. That is, it
+runs all tests in one test case first, and then runs all tests in the next test
+case, and so on. Google Test does this because it needs to set up a test case
+before the first test in it is run, and tear it down afterwords. Splitting up
+the test case would require multiple set-up and tear-down processes, which is
+inefficient and makes the semantics unclean.
+
+If we were to determine the order of tests based on test name instead of test
+case name, then we would have a problem with the following situation:
+
+```
+TEST_F(FooTest, AbcDeathTest) { ... }
+TEST_F(FooTest, Uvw) { ... }
+
+TEST_F(BarTest, DefDeathTest) { ... }
+TEST_F(BarTest, Xyz) { ... }
+```
+
+Since `FooTest.AbcDeathTest` needs to run before `BarTest.Xyz`, and we don't
+interleave tests from different test cases, we need to run all tests in the
+`FooTest` case before running any test in the `BarTest` case. This contradicts
+with the requirement to run `BarTest.DefDeathTest` before `FooTest.Uvw`.
+
+## But I don't like calling my entire test case FOODeathTest when it contains both death tests and non-death tests. What do I do? ##
+
+You don't have to, but if you like, you may split up the test case into
+`FooTest` and `FooDeathTest`, where the names make it clear that they are
+related:
+
+```
+class FooTest : public ::testing::Test { ... };
+
+TEST_F(FooTest, Abc) { ... }
+TEST_F(FooTest, Def) { ... }
+
+typedef FooTest FooDeathTest;
+
+TEST_F(FooDeathTest, Uvw) { ... EXPECT_DEATH(...) ... }
+TEST_F(FooDeathTest, Xyz) { ... ASSERT_DEATH(...) ... }
+```
+
+## The compiler complains about "no match for 'operator<<'" when I use an assertion. What gives? ##
+
+If you use a user-defined type `FooType` in an assertion, you must make sure
+there is an `std::ostream& operator<<(std::ostream&, const FooType&)` function
+defined such that we can print a value of `FooType`.
+
+In addition, if `FooType` is declared in a name space, the `<<` operator also
+needs to be defined in the _same_ name space.
+
+## How do I suppress the memory leak messages on Windows? ##
+
+Since the statically initialized Google Test singleton requires allocations on
+the heap, the Visual C++ memory leak detector will report memory leaks at the
+end of the program run. The easiest way to avoid this is to use the
+`_CrtMemCheckpoint` and `_CrtMemDumpAllObjectsSince` calls to not report any
+statically initialized heap objects. See MSDN for more details and additional
+heap check/debug routines.
+
+## I am building my project with Google Test in Visual Studio and all I'm getting is a bunch of linker errors (or warnings). Help! ##
+
+You may get a number of the following linker error or warnings if you
+attempt to link your test project with the Google Test library when
+your project and the are not built using the same compiler settings.
+
+  * LNK2005: symbol already defined in object
+  * LNK4217: locally defined symbol 'symbol' imported in function 'function'
+  * LNK4049: locally defined symbol 'symbol' imported
+
+The Google Test project (gtest.vcproj) has the Runtime Library option
+set to /MT (use multi-threaded static libraries, /MTd for debug). If
+your project uses something else, for example /MD (use multi-threaded
+DLLs, /MDd for debug), you need to change the setting in the Google
+Test project to match your project's.
+
+To update this setting open the project properties in the Visual
+Studio IDE then select the branch Configuration Properties | C/C++ |
+Code Generation and change the option "Runtime Library".  You may also try
+using gtest-md.vcproj instead of gtest.vcproj.
+
+## I put my tests in a library and Google Test doesn't run them. What's happening? ##
+Have you read a
+[warning](V1_7_Primer.md#important-note-for-visual-c-users) on
+the Google Test Primer page?
+
+## I want to use Google Test with Visual Studio but don't know where to start. ##
+Many people are in your position and one of the posted his solution to
+our mailing list. Here is his link:
+http://hassanjamilahmad.blogspot.com/2009/07/gtest-starters-help.html.
+
+## I am seeing compile errors mentioning std::type\_traits when I try to use Google Test on Solaris. ##
+Google Test uses parts of the standard C++ library that SunStudio does not support.
+Our users reported success using alternative implementations. Try running the build after runing this commad:
+
+`export CC=cc CXX=CC CXXFLAGS='-library=stlport4'`
+
+## How can my code detect if it is running in a test? ##
+
+If you write code that sniffs whether it's running in a test and does
+different things accordingly, you are leaking test-only logic into
+production code and there is no easy way to ensure that the test-only
+code paths aren't run by mistake in production.  Such cleverness also
+leads to
+[Heisenbugs](http://en.wikipedia.org/wiki/Unusual_software_bug#Heisenbug).
+Therefore we strongly advise against the practice, and Google Test doesn't
+provide a way to do it.
+
+In general, the recommended way to cause the code to behave
+differently under test is [dependency injection](http://jamesshore.com/Blog/Dependency-Injection-Demystified.html).
+You can inject different functionality from the test and from the
+production code.  Since your production code doesn't link in the
+for-test logic at all, there is no danger in accidentally running it.
+
+However, if you _really_, _really_, _really_ have no choice, and if
+you follow the rule of ending your test program names with `_test`,
+you can use the _horrible_ hack of sniffing your executable name
+(`argv[0]` in `main()`) to know whether the code is under test.
+
+## Google Test defines a macro that clashes with one defined by another library. How do I deal with that? ##
+
+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 Google Test macro clashes with another
+library, you can force Google Test to rename its macro to avoid the
+conflict.
+
+Specifically, if both Google Test and some other code define macro
+`FOO`, you can add
+```
+  -DGTEST_DONT_DEFINE_FOO=1
+```
+to the compiler flags to tell Google Test to change the macro's name
+from `FOO` to `GTEST_FOO`. 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.
+
+Currently, the following `TEST`, `FAIL`, `SUCCEED`, and the basic comparison assertion macros can have alternative names. You can see the full list of covered macros [here](http://www.google.com/codesearch?q=if+!GTEST_DONT_DEFINE_\w%2B+package:http://googletest\.googlecode\.com+file:/include/gtest/gtest.h). More information can be found in the "Avoiding Macro Name Clashes" section of the README file.
+
+
+## Is it OK if I have two separate `TEST(Foo, Bar)` test methods defined in different namespaces? ##
+
+Yes.
+
+The rule is **all test methods in the same test case must use the same fixture class**. This means that the following is **allowed** because both tests use the same fixture class (`::testing::Test`).
+
+```
+namespace foo {
+TEST(CoolTest, DoSomething) {
+  SUCCEED();
+}
+}  // namespace foo
+
+namespace bar {
+TEST(CoolTest, DoSomething) {
+  SUCCEED();
+}
+}  // namespace foo
+```
+
+However, the following code is **not allowed** and will produce a runtime error from Google Test because the test methods are using different test fixture classes with the same test case name.
+
+```
+namespace foo {
+class CoolTest : public ::testing::Test {};  // Fixture foo::CoolTest
+TEST_F(CoolTest, DoSomething) {
+  SUCCEED();
+}
+}  // namespace foo
+
+namespace bar {
+class CoolTest : public ::testing::Test {};  // Fixture: bar::CoolTest
+TEST_F(CoolTest, DoSomething) {
+  SUCCEED();
+}
+}  // namespace foo
+```
+
+## How do I build Google Testing Framework with Xcode 4? ##
+
+If you try to build Google Test's Xcode project with Xcode 4.0 or later, you may encounter an error message that looks like
+"Missing SDK in target gtest\_framework: /Developer/SDKs/MacOSX10.4u.sdk". That means that Xcode does not support the SDK the project is targeting. See the Xcode section in the [README](../../README.MD) file on how to resolve this.
+
+## My question is not covered in your FAQ! ##
+
+If you cannot find the answer to your question in this FAQ, there are
+some other resources you can use:
+
+  1. read other [wiki pages](http://code.google.com/p/googletest/w/list),
+  1. search the mailing list [archive](http://groups.google.com/group/googletestframework/topics),
+  1. ask it on [googletestframework@googlegroups.com](mailto:googletestframework@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googletestframework) before you can post.).
+
+Please note that creating an issue in the
+[issue tracker](http://code.google.com/p/googletest/issues/list) is _not_
+a good way to get your answer, as it is monitored infrequently by a
+very small number of people.
+
+When asking a question, it's helpful to provide as much of the
+following information as possible (people cannot help you if there's
+not enough information in your question):
+
+  * the version (or the revision number if you check out from SVN directly) of Google Test you use (Google Test is under active development, so it's possible that your problem has been solved in a later version),
+  * your operating system,
+  * the name and version of your compiler,
+  * the complete command line flags you give to your compiler,
+  * the complete compiler error messages (if the question is about compilation),
+  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Primer.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Primer.md
new file mode 100644
index 00000000..b1827c73
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Primer.md
@@ -0,0 +1,501 @@
+
+
+# Introduction: Why Google C++ Testing Framework? #
+
+_Google C++ Testing Framework_ helps you write better C++ tests.
+
+No matter whether you work on Linux, Windows, or a Mac, if you write C++ code,
+Google Test can help you.
+
+So what makes a good test, and how does Google C++ Testing Framework fit in? We believe:
+  1. Tests should be _independent_ and _repeatable_. It's a pain to debug a test that succeeds or fails as a result of other tests.  Google C++ Testing Framework isolates the tests by running each of them on a different object. When a test fails, Google C++ Testing Framework allows you to run it in isolation for quick debugging.
+  1. Tests should be well _organized_ and reflect the structure of the tested code.  Google C++ Testing Framework groups related tests into test cases that can share data and subroutines. This common pattern is easy to recognize and makes tests easy to maintain. Such consistency is especially helpful when people switch projects and start to work on a new code base.
+  1. Tests should be _portable_ and _reusable_. The open-source community has a lot of code that is platform-neutral, its tests should also be platform-neutral.  Google C++ Testing Framework works on different OSes, with different compilers (gcc, MSVC, and others), with or without exceptions, so Google C++ Testing Framework tests can easily work with a variety of configurations.  (Note that the current release only contains build scripts for Linux - we are actively working on scripts for other platforms.)
+  1. When tests fail, they should provide as much _information_ about the problem as possible. Google C++ Testing Framework doesn't stop at the first test failure. Instead, it only stops the current test and continues with the next. You can also set up tests that report non-fatal failures after which the current test continues. Thus, you can detect and fix multiple bugs in a single run-edit-compile cycle.
+  1. The testing framework should liberate test writers from housekeeping chores and let them focus on the test _content_.  Google C++ Testing Framework automatically keeps track of all tests defined, and doesn't require the user to enumerate them in order to run them.
+  1. Tests should be _fast_. With Google C++ Testing Framework, you can reuse shared resources across tests and pay for the set-up/tear-down only once, without making tests depend on each other.
+
+Since Google C++ Testing Framework is based on the popular xUnit
+architecture, you'll feel right at home if you've used JUnit or PyUnit before.
+If not, it will take you about 10 minutes to learn the basics and get started.
+So let's go!
+
+_Note:_ We sometimes refer to Google C++ Testing Framework informally
+as _Google Test_.
+
+# Setting up a New Test Project #
+
+To write a test program using Google Test, you need to compile Google
+Test into a library and link your test with it.  We provide build
+files for some popular build systems: `msvc/` for Visual Studio,
+`xcode/` for Mac Xcode, `make/` for GNU make, `codegear/` for Borland
+C++ Builder, and the autotools script (deprecated) and
+`CMakeLists.txt` for CMake (recommended) in the Google Test root
+directory.  If your build system is not on this list, you can take a
+look at `make/Makefile` to learn how Google Test should be compiled
+(basically you want to compile `src/gtest-all.cc` with `GTEST_ROOT`
+and `GTEST_ROOT/include` in the header search path, where `GTEST_ROOT`
+is the Google Test root directory).
+
+Once you are able to compile the Google Test library, you should
+create a project or build target for your test program.  Make sure you
+have `GTEST_ROOT/include` in the header search path so that the
+compiler can find `"gtest/gtest.h"` when compiling your test.  Set up
+your test project to link with the Google Test library (for example,
+in Visual Studio, this is done by adding a dependency on
+`gtest.vcproj`).
+
+If you still have questions, take a look at how Google Test's own
+tests are built and use them as examples.
+
+# Basic Concepts #
+
+When using Google Test, you start by writing _assertions_, which are statements
+that check whether a condition is true. An assertion's result can be _success_,
+_nonfatal failure_, or _fatal failure_. If a fatal failure occurs, it aborts
+the current function; otherwise the program continues normally.
+
+_Tests_ use assertions to verify the tested code's behavior. If a test crashes
+or has a failed assertion, then it _fails_; otherwise it _succeeds_.
+
+A _test case_ contains one or many tests. You should group your tests into test
+cases that reflect the structure of the tested code. When multiple tests in a
+test case need to share common objects and subroutines, you can put them into a
+_test fixture_ class.
+
+A _test program_ can contain multiple test cases.
+
+We'll now explain how to write a test program, starting at the individual
+assertion level and building up to tests and test cases.
+
+# Assertions #
+
+Google Test assertions are macros that resemble function calls. You test a
+class or function by making assertions about its behavior. When an assertion
+fails, Google Test prints the assertion's source file and line number location,
+along with a failure message. You may also supply a custom failure message
+which will be appended to Google Test's message.
+
+The assertions come in pairs that test the same thing but have different
+effects on the current function. `ASSERT_*` versions generate fatal failures
+when they fail, and **abort the current function**. `EXPECT_*` versions generate
+nonfatal failures, which don't abort the current function. Usually `EXPECT_*`
+are preferred, as they allow more than one failures to be reported in a test.
+However, you should use `ASSERT_*` if it doesn't make sense to continue when
+the assertion in question fails.
+
+Since a failed `ASSERT_*` returns from the current function immediately,
+possibly skipping clean-up code that comes after it, it may cause a space leak.
+Depending on the nature of the leak, it may or may not be worth fixing - so
+keep this in mind if you get a heap checker error in addition to assertion
+errors.
+
+To provide a custom failure message, simply stream it into the macro using the
+`<<` operator, or a sequence of such operators. An example:
+```
+ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length";
+
+for (int i = 0; i < x.size(); ++i) {
+  EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i;
+}
+```
+
+Anything that can be streamed to an `ostream` can be streamed to an assertion
+macro--in particular, C strings and `string` objects. If a wide string
+(`wchar_t*`, `TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is
+streamed to an assertion, it will be translated to UTF-8 when printed.
+
+## Basic Assertions ##
+
+These assertions do basic true/false condition testing.
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_TRUE(`_condition_`)`;  | `EXPECT_TRUE(`_condition_`)`;   | _condition_ is true |
+| `ASSERT_FALSE(`_condition_`)`; | `EXPECT_FALSE(`_condition_`)`;  | _condition_ is false |
+
+Remember, when they fail, `ASSERT_*` yields a fatal failure and
+returns from the current function, while `EXPECT_*` yields a nonfatal
+failure, allowing the function to continue running. In either case, an
+assertion failure means its containing test fails.
+
+_Availability_: Linux, Windows, Mac.
+
+## Binary Comparison ##
+
+This section describes assertions that compare two values.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+|`ASSERT_EQ(`_expected_`, `_actual_`);`|`EXPECT_EQ(`_expected_`, `_actual_`);`| _expected_ `==` _actual_ |
+|`ASSERT_NE(`_val1_`, `_val2_`);`      |`EXPECT_NE(`_val1_`, `_val2_`);`      | _val1_ `!=` _val2_ |
+|`ASSERT_LT(`_val1_`, `_val2_`);`      |`EXPECT_LT(`_val1_`, `_val2_`);`      | _val1_ `<` _val2_ |
+|`ASSERT_LE(`_val1_`, `_val2_`);`      |`EXPECT_LE(`_val1_`, `_val2_`);`      | _val1_ `<=` _val2_ |
+|`ASSERT_GT(`_val1_`, `_val2_`);`      |`EXPECT_GT(`_val1_`, `_val2_`);`      | _val1_ `>` _val2_ |
+|`ASSERT_GE(`_val1_`, `_val2_`);`      |`EXPECT_GE(`_val1_`, `_val2_`);`      | _val1_ `>=` _val2_ |
+
+In the event of a failure, Google Test prints both _val1_ and _val2_
+. In `ASSERT_EQ*` and `EXPECT_EQ*` (and all other equality assertions
+we'll introduce later), you should put the expression you want to test
+in the position of _actual_, and put its expected value in _expected_,
+as Google Test's failure messages are optimized for this convention.
+
+Value arguments must be comparable by the assertion's comparison
+operator or you'll get a compiler error.  We used to require the
+arguments to support the `<<` operator for streaming to an `ostream`,
+but it's no longer necessary since v1.6.0 (if `<<` is supported, it
+will be called to print the arguments when the assertion fails;
+otherwise Google Test will attempt to print them in the best way it
+can. For more details and how to customize the printing of the
+arguments, see this Google Mock [recipe](../../googlemock/docs/CookBook.md#teaching-google-mock-how-to-print-your-values).).
+
+These assertions can work with a user-defined type, but only if you define the
+corresponding comparison operator (e.g. `==`, `<`, etc).  If the corresponding
+operator is defined, prefer using the `ASSERT_*()` macros because they will
+print out not only the result of the comparison, but the two operands as well.
+
+Arguments are always evaluated exactly once. Therefore, it's OK for the
+arguments to have side effects. However, as with any ordinary C/C++ function,
+the arguments' evaluation order is undefined (i.e. the compiler is free to
+choose any order) and your code should not depend on any particular argument
+evaluation order.
+
+`ASSERT_EQ()` does pointer equality on pointers. If used on two C strings, it
+tests if they are in the same memory location, not if they have the same value.
+Therefore, if you want to compare C strings (e.g. `const char*`) by value, use
+`ASSERT_STREQ()` , which will be described later on. In particular, to assert
+that a C string is `NULL`, use `ASSERT_STREQ(NULL, c_string)` . However, to
+compare two `string` objects, you should use `ASSERT_EQ`.
+
+Macros in this section work with both narrow and wide string objects (`string`
+and `wstring`).
+
+_Availability_: Linux, Windows, Mac.
+
+## String Comparison ##
+
+The assertions in this group compare two **C strings**. If you want to compare
+two `string` objects, use `EXPECT_EQ`, `EXPECT_NE`, and etc instead.
+
+| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
+|:--------------------|:-----------------------|:-------------|
+| `ASSERT_STREQ(`_expected\_str_`, `_actual\_str_`);`    | `EXPECT_STREQ(`_expected\_str_`, `_actual\_str_`);`     | the two C strings have the same content |
+| `ASSERT_STRNE(`_str1_`, `_str2_`);`    | `EXPECT_STRNE(`_str1_`, `_str2_`);`     | the two C strings have different content |
+| `ASSERT_STRCASEEQ(`_expected\_str_`, `_actual\_str_`);`| `EXPECT_STRCASEEQ(`_expected\_str_`, `_actual\_str_`);` | the two C strings have the same content, ignoring case |
+| `ASSERT_STRCASENE(`_str1_`, `_str2_`);`| `EXPECT_STRCASENE(`_str1_`, `_str2_`);` | the two C strings have different content, ignoring case |
+
+Note that "CASE" in an assertion name means that case is ignored.
+
+`*STREQ*` and `*STRNE*` also accept wide C strings (`wchar_t*`). If a
+comparison of two wide strings fails, their values will be printed as UTF-8
+narrow strings.
+
+A `NULL` pointer and an empty string are considered _different_.
+
+_Availability_: Linux, Windows, Mac.
+
+See also: For more string comparison tricks (substring, prefix, suffix, and
+regular expression matching, for example), see the [Advanced Google Test Guide](V1_7_AdvancedGuide.md).
+
+# Simple Tests #
+
+To create a test:
+  1. Use the `TEST()` macro to define and name a test function, These are ordinary C++ functions that don't return a value.
+  1. In this function, along with any valid C++ statements you want to include, use the various Google Test assertions to check values.
+  1. The test's result is determined by the assertions; if any assertion in the test fails (either fatally or non-fatally), or if the test crashes, the entire test fails. Otherwise, it succeeds.
+
+```
+TEST(test_case_name, test_name) {
+ ... test body ...
+}
+```
+
+
+`TEST()` arguments go from general to specific. The _first_ argument is the
+name of the test case, and the _second_ argument is the test's name within the
+test case. Both names must be valid C++ identifiers, and they should not contain underscore (`_`). A test's _full name_ consists of its containing test case and its
+individual name. Tests from different test cases can have the same individual
+name.
+
+For example, let's take a simple integer function:
+```
+int Factorial(int n); // Returns the factorial of n
+```
+
+A test case for this function might look like:
+```
+// Tests factorial of 0.
+TEST(FactorialTest, HandlesZeroInput) {
+  EXPECT_EQ(1, Factorial(0));
+}
+
+// Tests factorial of positive numbers.
+TEST(FactorialTest, HandlesPositiveInput) {
+  EXPECT_EQ(1, Factorial(1));
+  EXPECT_EQ(2, Factorial(2));
+  EXPECT_EQ(6, Factorial(3));
+  EXPECT_EQ(40320, Factorial(8));
+}
+```
+
+Google Test groups the test results by test cases, so logically-related tests
+should be in the same test case; in other words, the first argument to their
+`TEST()` should be the same. In the above example, we have two tests,
+`HandlesZeroInput` and `HandlesPositiveInput`, that belong to the same test
+case `FactorialTest`.
+
+_Availability_: Linux, Windows, Mac.
+
+# Test Fixtures: Using the Same Data Configuration for Multiple Tests #
+
+If you find yourself writing two or more tests that operate on similar data,
+you can use a _test fixture_. It allows you to reuse the same configuration of
+objects for several different tests.
+
+To create a fixture, just:
+  1. Derive a class from `::testing::Test` . Start its body with `protected:` or `public:` as we'll want to access fixture members from sub-classes.
+  1. Inside the class, declare any objects you plan to use.
+  1. If necessary, write a default constructor or `SetUp()` function to prepare the objects for each test. A common mistake is to spell `SetUp()` as `Setup()` with a small `u` - don't let that happen to you.
+  1. If necessary, write a destructor or `TearDown()` function to release any resources you allocated in `SetUp()` . To learn when you should use the constructor/destructor and when you should use `SetUp()/TearDown()`, read this [FAQ entry](V1_7_FAQ.md#should-i-use-the-constructordestructor-of-the-test-fixture-or-the-set-uptear-down-function).
+  1. If needed, define subroutines for your tests to share.
+
+When using a fixture, use `TEST_F()` instead of `TEST()` as it allows you to
+access objects and subroutines in the test fixture:
+```
+TEST_F(test_case_name, test_name) {
+ ... test body ...
+}
+```
+
+Like `TEST()`, the first argument is the test case name, but for `TEST_F()`
+this must be the name of the test fixture class. You've probably guessed: `_F`
+is for fixture.
+
+Unfortunately, the C++ macro system does not allow us to create a single macro
+that can handle both types of tests. Using the wrong macro causes a compiler
+error.
+
+Also, you must first define a test fixture class before using it in a
+`TEST_F()`, or you'll get the compiler error "`virtual outside class
+declaration`".
+
+For each test defined with `TEST_F()`, Google Test will:
+  1. Create a _fresh_ test fixture at runtime
+  1. Immediately initialize it via `SetUp()` ,
+  1. Run the test
+  1. Clean up by calling `TearDown()`
+  1. Delete the test fixture.  Note that different tests in the same test case have different test fixture objects, and Google Test always deletes a test fixture before it creates the next one. Google Test does not reuse the same test fixture for multiple tests. Any changes one test makes to the fixture do not affect other tests.
+
+As an example, let's write tests for a FIFO queue class named `Queue`, which
+has the following interface:
+```
+template <typename E> // E is the element type.
+class Queue {
+ public:
+  Queue();
+  void Enqueue(const E& element);
+  E* Dequeue(); // Returns NULL if the queue is empty.
+  size_t size() const;
+  ...
+};
+```
+
+First, define a fixture class. By convention, you should give it the name
+`FooTest` where `Foo` is the class being tested.
+```
+class QueueTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    q1_.Enqueue(1);
+    q2_.Enqueue(2);
+    q2_.Enqueue(3);
+  }
+
+  // virtual void TearDown() {}
+
+  Queue<int> q0_;
+  Queue<int> q1_;
+  Queue<int> q2_;
+};
+```
+
+In this case, `TearDown()` is not needed since we don't have to clean up after
+each test, other than what's already done by the destructor.
+
+Now we'll write tests using `TEST_F()` and this fixture.
+```
+TEST_F(QueueTest, IsEmptyInitially) {
+  EXPECT_EQ(0, q0_.size());
+}
+
+TEST_F(QueueTest, DequeueWorks) {
+  int* n = q0_.Dequeue();
+  EXPECT_EQ(NULL, n);
+
+  n = q1_.Dequeue();
+  ASSERT_TRUE(n != NULL);
+  EXPECT_EQ(1, *n);
+  EXPECT_EQ(0, q1_.size());
+  delete n;
+
+  n = q2_.Dequeue();
+  ASSERT_TRUE(n != NULL);
+  EXPECT_EQ(2, *n);
+  EXPECT_EQ(1, q2_.size());
+  delete n;
+}
+```
+
+The above uses both `ASSERT_*` and `EXPECT_*` assertions. The rule of thumb is
+to use `EXPECT_*` when you want the test to continue to reveal more errors
+after the assertion failure, and use `ASSERT_*` when continuing after failure
+doesn't make sense. For example, the second assertion in the `Dequeue` test is
+`ASSERT_TRUE(n != NULL)`, as we need to dereference the pointer `n` later,
+which would lead to a segfault when `n` is `NULL`.
+
+When these tests run, the following happens:
+  1. Google Test constructs a `QueueTest` object (let's call it `t1` ).
+  1. `t1.SetUp()` initializes `t1` .
+  1. The first test ( `IsEmptyInitially` ) runs on `t1` .
+  1. `t1.TearDown()` cleans up after the test finishes.
+  1. `t1` is destructed.
+  1. The above steps are repeated on another `QueueTest` object, this time running the `DequeueWorks` test.
+
+_Availability_: Linux, Windows, Mac.
+
+_Note_: Google Test automatically saves all _Google Test_ flags when a test
+object is constructed, and restores them when it is destructed.
+
+# Invoking the Tests #
+
+`TEST()` and `TEST_F()` implicitly register their tests with Google Test. So, unlike with many other C++ testing frameworks, you don't have to re-list all your defined tests in order to run them.
+
+After defining your tests, you can run them with `RUN_ALL_TESTS()` , which returns `0` if all the tests are successful, or `1` otherwise. Note that `RUN_ALL_TESTS()` runs _all tests_ in your link unit -- they can be from different test cases, or even different source files.
+
+When invoked, the `RUN_ALL_TESTS()` macro:
+  1. Saves the state of all  Google Test flags.
+  1. Creates a test fixture object for the first test.
+  1. Initializes it via `SetUp()`.
+  1. Runs the test on the fixture object.
+  1. Cleans up the fixture via `TearDown()`.
+  1. Deletes the fixture.
+  1. Restores the state of all Google Test flags.
+  1. Repeats the above steps for the next test, until all tests have run.
+
+In addition, if the text fixture's constructor generates a fatal failure in
+step 2, there is no point for step 3 - 5 and they are thus skipped. Similarly,
+if step 3 generates a fatal failure, step 4 will be skipped.
+
+_Important_: You must not ignore the return value of `RUN_ALL_TESTS()`, or `gcc`
+will give you a compiler error. The rationale for this design is that the
+automated testing service determines whether a test has passed based on its
+exit code, not on its stdout/stderr output; thus your `main()` function must
+return the value of `RUN_ALL_TESTS()`.
+
+Also, you should call `RUN_ALL_TESTS()` only **once**. Calling it more than once
+conflicts with some advanced Google Test features (e.g. thread-safe death
+tests) and thus is not supported.
+
+_Availability_: Linux, Windows, Mac.
+
+# Writing the main() Function #
+
+You can start from this boilerplate:
+```
+#include "this/package/foo.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+// The fixture for testing class Foo.
+class FooTest : public ::testing::Test {
+ protected:
+  // You can remove any or all of the following functions if its body
+  // is empty.
+
+  FooTest() {
+    // You can do set-up work for each test here.
+  }
+
+  virtual ~FooTest() {
+    // You can do clean-up work that doesn't throw exceptions here.
+  }
+
+  // If the constructor and destructor are not enough for setting up
+  // and cleaning up each test, you can define the following methods:
+
+  virtual void SetUp() {
+    // Code here will be called immediately after the constructor (right
+    // before each test).
+  }
+
+  virtual void TearDown() {
+    // Code here will be called immediately after each test (right
+    // before the destructor).
+  }
+
+  // Objects declared here can be used by all tests in the test case for Foo.
+};
+
+// Tests that the Foo::Bar() method does Abc.
+TEST_F(FooTest, MethodBarDoesAbc) {
+  const string input_filepath = "this/package/testdata/myinputfile.dat";
+  const string output_filepath = "this/package/testdata/myoutputfile.dat";
+  Foo f;
+  EXPECT_EQ(0, f.Bar(input_filepath, output_filepath));
+}
+
+// Tests that Foo does Xyz.
+TEST_F(FooTest, DoesXyz) {
+  // Exercises the Xyz feature of Foo.
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+```
+
+The `::testing::InitGoogleTest()` function parses the command line for Google
+Test flags, and removes all recognized flags. This allows the user to control a
+test program's behavior via various flags, which we'll cover in [AdvancedGuide](V1_7_AdvancedGuide.md).
+You must call this function before calling `RUN_ALL_TESTS()`, or the flags
+won't be properly initialized.
+
+On Windows, `InitGoogleTest()` also works with wide strings, so it can be used
+in programs compiled in `UNICODE` mode as well.
+
+But maybe you think that writing all those main() functions is too much work? We agree with you completely and that's why Google Test provides a basic implementation of main(). If it fits your needs, then just link your test with gtest\_main library and you are good to go.
+
+## Important note for Visual C++ users ##
+If you put your tests into a library and your `main()` function is in a different library or in your .exe file, those tests will not run. The reason is a [bug](https://connect.microsoft.com/feedback/viewfeedback.aspx?FeedbackID=244410&siteid=210) in Visual C++. When you define your tests, Google Test creates certain static objects to register them. These objects are not referenced from elsewhere but their constructors are still supposed to run. When Visual C++ linker sees that nothing in the library is referenced from other places it throws the library out. You have to reference your library with tests from your main program to keep the linker from discarding it. Here is how to do it. Somewhere in your library code declare a function:
+```
+__declspec(dllexport) int PullInMyLibrary() { return 0; }
+```
+If you put your tests in a static library (not DLL) then `__declspec(dllexport)` is not required. Now, in your main program, write a code that invokes that function:
+```
+int PullInMyLibrary();
+static int dummy = PullInMyLibrary();
+```
+This will keep your tests referenced and will make them register themselves at startup.
+
+In addition, if you define your tests in a static library, add `/OPT:NOREF` to your main program linker options. If you use MSVC++ IDE, go to your .exe project properties/Configuration Properties/Linker/Optimization and set References setting to `Keep Unreferenced Data (/OPT:NOREF)`. This will keep Visual C++ linker from discarding individual symbols generated by your tests from the final executable.
+
+There is one more pitfall, though. If you use Google Test as a static library (that's how it is defined in gtest.vcproj) your tests must also reside in a static library. If you have to have them in a DLL, you _must_ change Google Test to build into a DLL as well. Otherwise your tests will not run correctly or will not run at all. The general conclusion here is: make your life easier - do not write your tests in libraries!
+
+# Where to Go from Here #
+
+Congratulations! You've learned the Google Test basics. You can start writing
+and running Google Test tests, read some [samples](V1_7_Samples.md), or continue with
+[AdvancedGuide](V1_7_AdvancedGuide.md), which describes many more useful Google Test features.
+
+# Known Limitations #
+
+Google Test is designed to be thread-safe.  The implementation is
+thread-safe on systems where the `pthreads` library is available.  It
+is currently _unsafe_ to use Google Test assertions from two threads
+concurrently on other systems (e.g. Windows).  In most tests this is
+not an issue as usually the assertions are done in the main thread. If
+you want to help, you can volunteer to implement the necessary
+synchronization primitives in `gtest-port.h` for your platform.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_PumpManual.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_PumpManual.md
new file mode 100644
index 00000000..8184f153
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_PumpManual.md
@@ -0,0 +1,177 @@
+
+
+<b>P</b>ump is <b>U</b>seful for <b>M</b>eta <b>P</b>rogramming.
+
+# The Problem #
+
+Template and macro libraries often need to define many classes,
+functions, or macros that vary only (or almost only) in the number of
+arguments they take. It's a lot of repetitive, mechanical, and
+error-prone work.
+
+Variadic templates and variadic macros can alleviate the problem.
+However, while both are being considered by the C++ committee, neither
+is in the standard yet or widely supported by compilers.  Thus they
+are often not a good choice, especially when your code needs to be
+portable. And their capabilities are still limited.
+
+As a result, authors of such libraries often have to write scripts to
+generate their implementation. However, our experience is that it's
+tedious to write such scripts, which tend to reflect the structure of
+the generated code poorly and are often hard to read and edit. For
+example, a small change needed in the generated code may require some
+non-intuitive, non-trivial changes in the script. This is especially
+painful when experimenting with the code.
+
+# Our Solution #
+
+Pump (for Pump is Useful for Meta Programming, Pretty Useful for Meta
+Programming, or Practical Utility for Meta Programming, whichever you
+prefer) is a simple meta-programming tool for C++. The idea is that a
+programmer writes a `foo.pump` file which contains C++ code plus meta
+code that manipulates the C++ code. The meta code can handle
+iterations over a range, nested iterations, local meta variable
+definitions, simple arithmetic, and conditional expressions. You can
+view it as a small Domain-Specific Language. The meta language is
+designed to be non-intrusive (s.t. it won't confuse Emacs' C++ mode,
+for example) and concise, making Pump code intuitive and easy to
+maintain.
+
+## Highlights ##
+
+  * The implementation is in a single Python script and thus ultra portable: no build or installation is needed and it works cross platforms.
+  * Pump tries to be smart with respect to [Google's style guide](http://code.google.com/p/google-styleguide/): it breaks long lines (easy to have when they are generated) at acceptable places to fit within 80 columns and indent the continuation lines correctly.
+  * The format is human-readable and more concise than XML.
+  * The format works relatively well with Emacs' C++ mode.
+
+## Examples ##
+
+The following Pump code (where meta keywords start with `$`, `[[` and `]]` are meta brackets, and `$$` starts a meta comment that ends with the line):
+
+```
+$var n = 3     $$ Defines a meta variable n.
+$range i 0..n  $$ Declares the range of meta iterator i (inclusive).
+$for i [[
+               $$ Meta loop.
+// Foo$i does blah for $i-ary predicates.
+$range j 1..i
+template <size_t N $for j [[, typename A$j]]>
+class Foo$i {
+$if i == 0 [[
+  blah a;
+]] $elif i <= 2 [[
+  blah b;
+]] $else [[
+  blah c;
+]]
+};
+
+]]
+```
+
+will be translated by the Pump compiler to:
+
+```
+// Foo0 does blah for 0-ary predicates.
+template <size_t N>
+class Foo0 {
+  blah a;
+};
+
+// Foo1 does blah for 1-ary predicates.
+template <size_t N, typename A1>
+class Foo1 {
+  blah b;
+};
+
+// Foo2 does blah for 2-ary predicates.
+template <size_t N, typename A1, typename A2>
+class Foo2 {
+  blah b;
+};
+
+// Foo3 does blah for 3-ary predicates.
+template <size_t N, typename A1, typename A2, typename A3>
+class Foo3 {
+  blah c;
+};
+```
+
+In another example,
+
+```
+$range i 1..n
+Func($for i + [[a$i]]);
+$$ The text between i and [[ is the separator between iterations.
+```
+
+will generate one of the following lines (without the comments), depending on the value of `n`:
+
+```
+Func();              // If n is 0.
+Func(a1);            // If n is 1.
+Func(a1 + a2);       // If n is 2.
+Func(a1 + a2 + a3);  // If n is 3.
+// And so on...
+```
+
+## Constructs ##
+
+We support the following meta programming constructs:
+
+| `$var id = exp` | Defines a named constant value. `$id` is valid util the end of the current meta lexical block. |
+|:----------------|:-----------------------------------------------------------------------------------------------|
+| `$range id exp..exp` | Sets the range of an iteration variable, which can be reused in multiple loops later.          |
+| `$for id sep [[ code ]]` | Iteration. The range of `id` must have been defined earlier. `$id` is valid in `code`.         |
+| `$($)`          | Generates a single `$` character.                                                              |
+| `$id`           | Value of the named constant or iteration variable.                                             |
+| `$(exp)`        | Value of the expression.                                                                       |
+| `$if exp [[ code ]] else_branch` | Conditional.                                                                                   |
+| `[[ code ]]`    | Meta lexical block.                                                                            |
+| `cpp_code`      | Raw C++ code.                                                                                  |
+| `$$ comment`    | Meta comment.                                                                                  |
+
+**Note:** To give the user some freedom in formatting the Pump source
+code, Pump ignores a new-line character if it's right after `$for foo`
+or next to `[[` or `]]`. Without this rule you'll often be forced to write
+very long lines to get the desired output. Therefore sometimes you may
+need to insert an extra new-line in such places for a new-line to show
+up in your output.
+
+## Grammar ##
+
+```
+code ::= atomic_code*
+atomic_code ::= $var id = exp
+    | $var id = [[ code ]]
+    | $range id exp..exp
+    | $for id sep [[ code ]]
+    | $($)
+    | $id
+    | $(exp)
+    | $if exp [[ code ]] else_branch
+    | [[ code ]]
+    | cpp_code
+sep ::= cpp_code | empty_string
+else_branch ::= $else [[ code ]]
+    | $elif exp [[ code ]] else_branch
+    | empty_string
+exp ::= simple_expression_in_Python_syntax
+```
+
+## Code ##
+
+You can find the source code of Pump in [scripts/pump.py](../scripts/pump.py). It is still
+very unpolished and lacks automated tests, although it has been
+successfully used many times. If you find a chance to use it in your
+project, please let us know what you think!  We also welcome help on
+improving Pump.
+
+## Real Examples ##
+
+You can find real-world applications of Pump in [Google Test](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgoogletest\.googlecode\.com) and [Google Mock](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgooglemock\.googlecode\.com).  The source file `foo.h.pump` generates `foo.h`.
+
+## Tips ##
+
+  * If a meta variable is followed by a letter or digit, you can separate them using `[[]]`, which inserts an empty string. For example `Foo$j[[]]Helper` generate `Foo1Helper` when `j` is 1.
+  * To avoid extra-long Pump source lines, you can break a line anywhere you want by inserting `[[]]` followed by a new line. Since any new-line character next to `[[` or `]]` is ignored, the generated code won't contain this new line.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Samples.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Samples.md
new file mode 100644
index 00000000..f21d2005
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Samples.md
@@ -0,0 +1,14 @@
+If you're like us, you'd like to look at some Google Test sample code.  The
+[samples folder](../samples) has a number of well-commented samples showing how to use a
+variety of Google Test features.
+
+  * [Sample #1](../samples/sample1_unittest.cc) shows the basic steps of using Google Test to test C++ functions.
+  * [Sample #2](../samples/sample2_unittest.cc) shows a more complex unit test for a class with multiple member functions.
+  * [Sample #3](../samples/sample3_unittest.cc) uses a test fixture.
+  * [Sample #4](../samples/sample4_unittest.cc) is another basic example of using Google Test.
+  * [Sample #5](../samples/sample5_unittest.cc) teaches how to reuse a test fixture in multiple test cases by deriving sub-fixtures from it.
+  * [Sample #6](../samples/sample6_unittest.cc) demonstrates type-parameterized tests.
+  * [Sample #7](../samples/sample7_unittest.cc) teaches the basics of value-parameterized tests.
+  * [Sample #8](../samples/sample8_unittest.cc) shows using `Combine()` in value-parameterized tests.
+  * [Sample #9](../samples/sample9_unittest.cc) shows use of the listener API to modify Google Test's console output and the use of its reflection API to inspect test results.
+  * [Sample #10](../samples/sample10_unittest.cc) shows use of the listener API to implement a primitive memory leak checker.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_XcodeGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_XcodeGuide.md
new file mode 100644
index 00000000..bf24bf51
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_XcodeGuide.md
@@ -0,0 +1,93 @@
+
+
+This guide will explain how to use the Google Testing Framework in your Xcode projects on Mac OS X. This tutorial begins by quickly explaining what to do for experienced users. After the quick start, the guide goes provides additional explanation about each step.
+
+# Quick Start #
+
+Here is the quick guide for using Google Test in your Xcode project.
+
+  1. Download the source from the [website](http://code.google.com/p/googletest) using this command: `svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only`
+  1. Open up the `gtest.xcodeproj` in the `googletest-read-only/xcode/` directory and build the gtest.framework.
+  1. Create a new "Shell Tool" target in your Xcode project called something like "UnitTests"
+  1. Add the gtest.framework to your project and add it to the "Link Binary with Libraries" build phase of "UnitTests"
+  1. Add your unit test source code to the "Compile Sources" build phase of "UnitTests"
+  1. Edit the "UnitTests" executable and add an environment variable named "DYLD\_FRAMEWORK\_PATH" with a value equal to the path to the framework containing the gtest.framework relative to the compiled executable.
+  1. Build and Go
+
+The following sections further explain each of the steps listed above in depth, describing in more detail how to complete it including some variations.
+
+# Get the Source #
+
+Currently, the gtest.framework discussed here isn't available in a tagged release of Google Test, it is only available in the trunk. As explained at the Google Test [site](http://code.google.com/p/googletest/source/checkout">svn), you can get the code from anonymous SVN with this command:
+
+```
+svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only
+```
+
+Alternatively, if you are working with Subversion in your own code base, you can add Google Test as an external dependency to your own Subversion repository. By following this approach, everyone that checks out your svn repository will also receive a copy of Google Test (a specific version, if you wish) without having to check it out explicitly. This makes the set up of your project simpler and reduces the copied code in the repository.
+
+To use `svn:externals`, decide where you would like to have the external source reside. You might choose to put the external source inside the trunk, because you want it to be part of the branch when you make a release. However, keeping it outside the trunk in a version-tagged directory called something like `third-party/googletest/1.0.1`, is another option. Once the location is established, use `svn propedit svn:externals _directory_` to set the svn:externals property on a directory in your repository. This directory won't contain the code, but be its versioned parent directory.
+
+The command `svn propedit` will bring up your Subversion editor, making editing the long, (potentially multi-line) property simpler. This same method can be used to check out a tagged branch, by using the appropriate URL (e.g. `http://googletest.googlecode.com/svn/tags/release-1.0.1`). Additionally, the svn:externals property allows the specification of a particular revision of the trunk with the `-r_##_` option (e.g. `externals/src/googletest -r60 http://googletest.googlecode.com/svn/trunk`).
+
+Here is an example of using the svn:externals properties on a trunk (read via `svn propget`) of a project. This value checks out a copy of Google Test into the `trunk/externals/src/googletest/` directory.
+
+```
+[Computer:svn] user$ svn propget svn:externals trunk
+externals/src/googletest http://googletest.googlecode.com/svn/trunk
+```
+
+# Add the Framework to Your Project #
+
+The next step is to build and add the gtest.framework to your own project. This guide describes two common ways below.
+
+  * **Option 1** --- The simplest way to add Google Test to your own project, is to open gtest.xcodeproj (found in the xcode/ directory of the Google Test trunk) and build the framework manually. Then, add the built framework into your project using the "Add->Existing Framework..." from the context menu or "Project->Add..." from the main menu. The gtest.framework is relocatable and contains the headers and object code that you'll need to make tests. This method requires rebuilding every time you upgrade Google Test in your project.
+  * **Option 2** --- If you are going to be living off the trunk of Google Test, incorporating its latest features into your unit tests (or are a Google Test developer yourself). You'll want to rebuild the framework every time the source updates. to do this, you'll need to add the gtest.xcodeproj file, not the framework itself, to your own Xcode project. Then, from the build products that are revealed by the project's disclosure triangle, you can find the gtest.framework, which can be added to your targets (discussed below).
+
+# Make a Test Target #
+
+To start writing tests, make a new "Shell Tool" target. This target template is available under BSD, Cocoa, or Carbon. Add your unit test source code to the "Compile Sources" build phase of the target.
+
+Next, you'll want to add gtest.framework in two different ways, depending upon which option you chose above.
+
+  * **Option 1** --- During compilation, Xcode will need to know that you are linking against the gtest.framework. Add the gtest.framework to the "Link Binary with Libraries" build phase of your test target. This will include the Google Test headers in your header search path, and will tell the linker where to find the library.
+  * **Option 2** --- If your working out of the trunk, you'll also want to add gtest.framework to your "Link Binary with Libraries" build phase of your test target. In addition, you'll  want to add the gtest.framework as a dependency to your unit test target. This way, Xcode will make sure that gtest.framework is up to date, every time your build your target. Finally, if you don't share build directories with Google Test, you'll have to copy the gtest.framework into your own build products directory using a "Run Script" build phase.
+
+# Set Up the Executable Run Environment #
+
+Since the unit test executable is a shell tool, it doesn't have a bundle with a `Contents/Frameworks` directory, in which to place gtest.framework. Instead, the dynamic linker must be told at runtime to search for the framework in another location. This can be accomplished by setting the "DYLD\_FRAMEWORK\_PATH" environment variable in the "Edit Active Executable ..." Arguments tab, under "Variables to be set in the environment:". The path for this value is the path (relative or absolute) of the directory containing the gtest.framework.
+
+If you haven't set up the DYLD\_FRAMEWORK\_PATH, correctly, you might get a message like this:
+
+```
+[Session started at 2008-08-15 06:23:57 -0600.]
+  dyld: Library not loaded: @loader_path/../Frameworks/gtest.framework/Versions/A/gtest
+    Referenced from: /Users/username/Documents/Sandbox/gtestSample/build/Debug/WidgetFrameworkTest
+    Reason: image not found
+```
+
+To correct this problem, got to the directory containing the executable named in "Referenced from:" value in the error message above. Then, with the terminal in this location, find the relative path to the directory containing the gtest.framework. That is the value you'll need to set as the DYLD\_FRAMEWORK\_PATH.
+
+# Build and Go #
+
+Now, when you click "Build and Go", the test will be executed. Dumping out something like this:
+
+```
+[Session started at 2008-08-06 06:36:13 -0600.]
+[==========] Running 2 tests from 1 test case.
+[----------] Global test environment set-up.
+[----------] 2 tests from WidgetInitializerTest
+[ RUN      ] WidgetInitializerTest.TestConstructor
+[       OK ] WidgetInitializerTest.TestConstructor
+[ RUN      ] WidgetInitializerTest.TestConversion
+[       OK ] WidgetInitializerTest.TestConversion
+[----------] Global test environment tear-down
+[==========] 2 tests from 1 test case ran.
+[  PASSED  ] 2 tests.
+
+The Debugger has exited with status 0.  
+```
+
+# Summary #
+
+Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/XcodeGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/XcodeGuide.md
new file mode 100644
index 00000000..bf24bf51
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/XcodeGuide.md
@@ -0,0 +1,93 @@
+
+
+This guide will explain how to use the Google Testing Framework in your Xcode projects on Mac OS X. This tutorial begins by quickly explaining what to do for experienced users. After the quick start, the guide goes provides additional explanation about each step.
+
+# Quick Start #
+
+Here is the quick guide for using Google Test in your Xcode project.
+
+  1. Download the source from the [website](http://code.google.com/p/googletest) using this command: `svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only`
+  1. Open up the `gtest.xcodeproj` in the `googletest-read-only/xcode/` directory and build the gtest.framework.
+  1. Create a new "Shell Tool" target in your Xcode project called something like "UnitTests"
+  1. Add the gtest.framework to your project and add it to the "Link Binary with Libraries" build phase of "UnitTests"
+  1. Add your unit test source code to the "Compile Sources" build phase of "UnitTests"
+  1. Edit the "UnitTests" executable and add an environment variable named "DYLD\_FRAMEWORK\_PATH" with a value equal to the path to the framework containing the gtest.framework relative to the compiled executable.
+  1. Build and Go
+
+The following sections further explain each of the steps listed above in depth, describing in more detail how to complete it including some variations.
+
+# Get the Source #
+
+Currently, the gtest.framework discussed here isn't available in a tagged release of Google Test, it is only available in the trunk. As explained at the Google Test [site](http://code.google.com/p/googletest/source/checkout">svn), you can get the code from anonymous SVN with this command:
+
+```
+svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only
+```
+
+Alternatively, if you are working with Subversion in your own code base, you can add Google Test as an external dependency to your own Subversion repository. By following this approach, everyone that checks out your svn repository will also receive a copy of Google Test (a specific version, if you wish) without having to check it out explicitly. This makes the set up of your project simpler and reduces the copied code in the repository.
+
+To use `svn:externals`, decide where you would like to have the external source reside. You might choose to put the external source inside the trunk, because you want it to be part of the branch when you make a release. However, keeping it outside the trunk in a version-tagged directory called something like `third-party/googletest/1.0.1`, is another option. Once the location is established, use `svn propedit svn:externals _directory_` to set the svn:externals property on a directory in your repository. This directory won't contain the code, but be its versioned parent directory.
+
+The command `svn propedit` will bring up your Subversion editor, making editing the long, (potentially multi-line) property simpler. This same method can be used to check out a tagged branch, by using the appropriate URL (e.g. `http://googletest.googlecode.com/svn/tags/release-1.0.1`). Additionally, the svn:externals property allows the specification of a particular revision of the trunk with the `-r_##_` option (e.g. `externals/src/googletest -r60 http://googletest.googlecode.com/svn/trunk`).
+
+Here is an example of using the svn:externals properties on a trunk (read via `svn propget`) of a project. This value checks out a copy of Google Test into the `trunk/externals/src/googletest/` directory.
+
+```
+[Computer:svn] user$ svn propget svn:externals trunk
+externals/src/googletest http://googletest.googlecode.com/svn/trunk
+```
+
+# Add the Framework to Your Project #
+
+The next step is to build and add the gtest.framework to your own project. This guide describes two common ways below.
+
+  * **Option 1** --- The simplest way to add Google Test to your own project, is to open gtest.xcodeproj (found in the xcode/ directory of the Google Test trunk) and build the framework manually. Then, add the built framework into your project using the "Add->Existing Framework..." from the context menu or "Project->Add..." from the main menu. The gtest.framework is relocatable and contains the headers and object code that you'll need to make tests. This method requires rebuilding every time you upgrade Google Test in your project.
+  * **Option 2** --- If you are going to be living off the trunk of Google Test, incorporating its latest features into your unit tests (or are a Google Test developer yourself). You'll want to rebuild the framework every time the source updates. to do this, you'll need to add the gtest.xcodeproj file, not the framework itself, to your own Xcode project. Then, from the build products that are revealed by the project's disclosure triangle, you can find the gtest.framework, which can be added to your targets (discussed below).
+
+# Make a Test Target #
+
+To start writing tests, make a new "Shell Tool" target. This target template is available under BSD, Cocoa, or Carbon. Add your unit test source code to the "Compile Sources" build phase of the target.
+
+Next, you'll want to add gtest.framework in two different ways, depending upon which option you chose above.
+
+  * **Option 1** --- During compilation, Xcode will need to know that you are linking against the gtest.framework. Add the gtest.framework to the "Link Binary with Libraries" build phase of your test target. This will include the Google Test headers in your header search path, and will tell the linker where to find the library.
+  * **Option 2** --- If your working out of the trunk, you'll also want to add gtest.framework to your "Link Binary with Libraries" build phase of your test target. In addition, you'll  want to add the gtest.framework as a dependency to your unit test target. This way, Xcode will make sure that gtest.framework is up to date, every time your build your target. Finally, if you don't share build directories with Google Test, you'll have to copy the gtest.framework into your own build products directory using a "Run Script" build phase.
+
+# Set Up the Executable Run Environment #
+
+Since the unit test executable is a shell tool, it doesn't have a bundle with a `Contents/Frameworks` directory, in which to place gtest.framework. Instead, the dynamic linker must be told at runtime to search for the framework in another location. This can be accomplished by setting the "DYLD\_FRAMEWORK\_PATH" environment variable in the "Edit Active Executable ..." Arguments tab, under "Variables to be set in the environment:". The path for this value is the path (relative or absolute) of the directory containing the gtest.framework.
+
+If you haven't set up the DYLD\_FRAMEWORK\_PATH, correctly, you might get a message like this:
+
+```
+[Session started at 2008-08-15 06:23:57 -0600.]
+  dyld: Library not loaded: @loader_path/../Frameworks/gtest.framework/Versions/A/gtest
+    Referenced from: /Users/username/Documents/Sandbox/gtestSample/build/Debug/WidgetFrameworkTest
+    Reason: image not found
+```
+
+To correct this problem, got to the directory containing the executable named in "Referenced from:" value in the error message above. Then, with the terminal in this location, find the relative path to the directory containing the gtest.framework. That is the value you'll need to set as the DYLD\_FRAMEWORK\_PATH.
+
+# Build and Go #
+
+Now, when you click "Build and Go", the test will be executed. Dumping out something like this:
+
+```
+[Session started at 2008-08-06 06:36:13 -0600.]
+[==========] Running 2 tests from 1 test case.
+[----------] Global test environment set-up.
+[----------] 2 tests from WidgetInitializerTest
+[ RUN      ] WidgetInitializerTest.TestConstructor
+[       OK ] WidgetInitializerTest.TestConstructor
+[ RUN      ] WidgetInitializerTest.TestConversion
+[       OK ] WidgetInitializerTest.TestConversion
+[----------] Global test environment tear-down
+[==========] 2 tests from 1 test case ran.
+[  PASSED  ] 2 tests.
+
+The Debugger has exited with status 0.  
+```
+
+# Summary #
+
+Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-death-test.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-death-test.h
new file mode 100644
index 00000000..957a69c6
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-death-test.h
@@ -0,0 +1,294 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// The Google C++ Testing 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.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+
+#include "gtest/internal/gtest-death-test-internal.h"
+
+namespace testing {
+
+// This flag controls the style of death tests.  Valid values are "threadsafe",
+// meaning that the death test child process will re-execute the test binary
+// from the start, running only a single death test, or "fast",
+// meaning that the child process will execute the test logic immediately
+// after forking.
+GTEST_DECLARE_string_(death_test_style);
+
+#if GTEST_HAS_DEATH_TEST
+
+namespace internal {
+
+// Returns a Boolean value indicating whether the caller is currently
+// executing in the context of the death test child process.  Tools such as
+// Valgrind heap checkers may need this to modify their behavior in death
+// tests.  IMPORTANT: This is an internal utility.  Using it may break the
+// implementation of death tests.  User code MUST NOT use it.
+GTEST_API_ bool InDeathTestChild();
+
+}  // namespace internal
+
+// The following macros are useful for writing death tests.
+
+// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
+// executed:
+//
+//   1. It generates a warning if there is more than one active
+//   thread.  This is because it's safe to fork() or clone() only
+//   when there is a single thread.
+//
+//   2. The parent process clone()s a sub-process and runs the death
+//   test in it; the sub-process exits with code 0 at the end of the
+//   death test, if it hasn't exited already.
+//
+//   3. The parent process waits for the sub-process to terminate.
+//
+//   4. The parent process checks the exit code and error message of
+//   the sub-process.
+//
+// Examples:
+//
+//   ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
+//   for (int i = 0; i < 5; i++) {
+//     EXPECT_DEATH(server.ProcessRequest(i),
+//                  "Invalid request .* in ProcessRequest()")
+//                  << "Failed to die on request " << i;
+//   }
+//
+//   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
+//
+//   bool KilledBySIGHUP(int exit_code) {
+//     return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
+//   }
+//
+//   ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
+//
+// On the regular expressions used in death tests:
+//
+//   On POSIX-compliant systems (*nix), we use the <regex.h> library,
+//   which uses the POSIX extended regex syntax.
+//
+//   On other platforms (e.g. Windows), 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
+//   or POSIX extended regex syntax.  For example, we don't support
+//   union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
+//   repetition count ("x{5,7}"), among others.
+//
+//   Below is the syntax that we do support.  We chose it to be a
+//   subset of both PCRE and POSIX extended regex, so it's easy to
+//   learn wherever you come from.  In the following: 'A' denotes a
+//   literal character, period (.), or a single \\ escape sequence;
+//   'x' and 'y' denote regular expressions; 'm' and 'n' are for
+//   natural numbers.
+//
+//     c     matches any literal character c
+//     \\d   matches any decimal digit
+//     \\D   matches any character that's not a decimal digit
+//     \\f   matches \f
+//     \\n   matches \n
+//     \\r   matches \r
+//     \\s   matches any ASCII whitespace, including \n
+//     \\S   matches any character that's not a whitespace
+//     \\t   matches \t
+//     \\v   matches \v
+//     \\w   matches any letter, _, or decimal digit
+//     \\W   matches any character that \\w doesn't match
+//     \\c   matches any literal character c, which must be a punctuation
+//     .     matches any single character except \n
+//     A?    matches 0 or 1 occurrences of A
+//     A*    matches 0 or many occurrences of A
+//     A+    matches 1 or many occurrences of A
+//     ^     matches the beginning of a string (not that of each line)
+//     $     matches the end of a string (not that of each line)
+//     xy    matches x followed by y
+//
+//   If you accidentally use PCRE or POSIX extended regex features
+//   not implemented by us, you will get a run-time failure.  In that
+//   case, please try to rewrite your regular expression within the
+//   above syntax.
+//
+//   This implementation is *not* meant to be as highly tuned or robust
+//   as a compiled regex library, but should perform well enough for a
+//   death test, which already incurs significant overhead by launching
+//   a child process.
+//
+// Known caveats:
+//
+//   A "threadsafe" style death test obtains the path to the test
+//   program from argv[0] and re-executes it in the sub-process.  For
+//   simplicity, the current implementation doesn't search the PATH
+//   when launching the sub-process.  This means that the user must
+//   invoke the test program via a path that contains at least one
+//   path separator (e.g. path/to/foo_test and
+//   /absolute/path/to/bar_test are fine, but foo_test is not).  This
+//   is rarely a problem as people usually don't put the test binary
+//   directory in PATH.
+//
+// TODO(wan@google.com): make thread-safe death tests search the 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 regex.
+# define ASSERT_EXIT(statement, predicate, regex) \
+    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)
+
+// Like ASSERT_EXIT, but continues on to successive tests in the
+// test case, if any:
+# define EXPECT_EXIT(statement, predicate, regex) \
+    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_)
+
+// 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 regex.
+# define ASSERT_DEATH(statement, regex) \
+    ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
+
+// Like ASSERT_DEATH, but continues on to successive tests in the
+// test case, if any:
+# define EXPECT_DEATH(statement, regex) \
+    EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
+
+// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
+
+// Tests that an exit code describes a normal exit with a given exit code.
+class GTEST_API_ ExitedWithCode {
+ public:
+  explicit ExitedWithCode(int exit_code);
+  bool operator()(int exit_status) const;
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ExitedWithCode& other);
+
+  const int exit_code_;
+};
+
+# if !GTEST_OS_WINDOWS
+// Tests that an exit code describes an exit due to termination by a
+// given signal.
+class GTEST_API_ KilledBySignal {
+ public:
+  explicit KilledBySignal(int signum);
+  bool operator()(int exit_status) const;
+ private:
+  const int signum_;
+};
+# endif  // !GTEST_OS_WINDOWS
+
+// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
+// The death testing framework causes this to have interesting semantics,
+// since the sideeffects of the call are only visible in opt mode, and not
+// in debug mode.
+//
+// In practice, this can be used to test functions that utilize the
+// LOG(DFATAL) macro using the following style:
+//
+// int DieInDebugOr12(int* sideeffect) {
+//   if (sideeffect) {
+//     *sideeffect = 12;
+//   }
+//   LOG(DFATAL) << "death";
+//   return 12;
+// }
+//
+// TEST(TestCase, TestDieOr12WorksInDgbAndOpt) {
+//   int sideeffect = 0;
+//   // Only asserts in dbg.
+//   EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
+//
+// #ifdef NDEBUG
+//   // opt-mode has sideeffect visible.
+//   EXPECT_EQ(12, sideeffect);
+// #else
+//   // dbg-mode no visible sideeffect.
+//   EXPECT_EQ(0, sideeffect);
+// #endif
+// }
+//
+// This will assert that DieInDebugReturn12InOpt() crashes in debug
+// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
+// appropriate fallback value (12 in this case) in opt mode. If you
+// need to test that a function has appropriate side-effects in opt
+// mode, include assertions against the side-effects.  A general
+// pattern for this is:
+//
+// EXPECT_DEBUG_DEATH({
+//   // Side-effects here will have an effect after this statement in
+//   // opt mode, but none in debug mode.
+//   EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
+// }, "death");
+//
+# ifdef NDEBUG
+
+#  define EXPECT_DEBUG_DEATH(statement, regex) \
+  GTEST_EXECUTE_STATEMENT_(statement, regex)
+
+#  define ASSERT_DEBUG_DEATH(statement, regex) \
+  GTEST_EXECUTE_STATEMENT_(statement, regex)
+
+# else
+
+#  define EXPECT_DEBUG_DEATH(statement, regex) \
+  EXPECT_DEATH(statement, regex)
+
+#  define ASSERT_DEBUG_DEATH(statement, regex) \
+  ASSERT_DEATH(statement, regex)
+
+# endif  // NDEBUG for EXPECT_DEBUG_DEATH
+#endif  // GTEST_HAS_DEATH_TEST
+
+// 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
+// useful when you are combining death test assertions with normal test
+// assertions in one test.
+#if GTEST_HAS_DEATH_TEST
+# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
+    EXPECT_DEATH(statement, regex)
+# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
+    ASSERT_DEATH(statement, regex)
+#else
+# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
+    GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, )
+# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
+    GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, return)
+#endif
+
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-message.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-message.h
new file mode 100644
index 00000000..fe879bca
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-message.h
@@ -0,0 +1,250 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file defines the Message class.
+//
+// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
+// leave some internal implementation details in this header file.
+// They are clearly marked by comments like this:
+//
+//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+//
+// Such code is NOT meant to be used by a user directly, and is subject
+// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
+// program!
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+
+#include <limits>
+
+#include "gtest/internal/gtest-port.h"
+
+// 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);
+
+namespace testing {
+
+// The Message class works like an ostream repeater.
+//
+// Typical usage:
+//
+//   1. You stream a bunch of values to a Message object.
+//      It will remember the text in a stringstream.
+//   2. Then you stream the Message object to an ostream.
+//      This causes the text in the Message to be streamed
+//      to the ostream.
+//
+// For example;
+//
+//   testing::Message foo;
+//   foo << 1 << " != " << 2;
+//   std::cout << foo;
+//
+// will print "1 != 2".
+//
+// Message is not intended to be inherited from.  In particular, its
+// destructor is not virtual.
+//
+// Note that stringstream behaves differently in gcc and in MSVC.  You
+// can stream a NULL char pointer to it in the former, but not in the
+// latter (it causes an access violation if you do).  The Message
+// class hides this difference by treating a NULL char pointer as
+// "(null)".
+class GTEST_API_ Message {
+ private:
+  // The type of basic IO manipulators (endl, ends, and flush) for
+  // narrow streams.
+  typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
+
+ public:
+  // Constructs an empty Message.
+  Message();
+
+  // Copy constructor.
+  Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
+    *ss_ << msg.GetString();
+  }
+
+  // Constructs a Message from a C-string.
+  explicit Message(const char* str) : ss_(new ::std::stringstream) {
+    *ss_ << str;
+  }
+
+#if GTEST_OS_SYMBIAN
+  // Streams a value (either a pointer or not) to this object.
+  template <typename T>
+  inline Message& operator <<(const T& value) {
+    StreamHelper(typename internal::is_pointer<T>::type(), value);
+    return *this;
+  }
+#else
+  // Streams a non-pointer value to this object.
+  template <typename T>
+  inline Message& operator <<(const T& val) {
+    // Some libraries overload << for STL containers.  These
+    // overloads are defined in the global namespace instead of ::std.
+    //
+    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
+    // overloads are visible in either the std namespace or the global
+    // namespace, but not other namespaces, including the testing
+    // namespace which Google Test's Message class is in.
+    //
+    // To allow STL containers (and other types that has a << operator
+    // defined in the global namespace) to be used in Google Test
+    // assertions, testing::Message must access the custom << operator
+    // from the global namespace.  With this using declaration,
+    // overloads of << defined in the global namespace and those
+    // visible via Koenig lookup are both exposed in this function.
+    using ::operator <<;
+    *ss_ << val;
+    return *this;
+  }
+
+  // Streams a pointer value to this object.
+  //
+  // This function is an overload of the previous one.  When you
+  // stream a pointer to a Message, this definition will be used as it
+  // is more specialized.  (The C++ Standard, section
+  // [temp.func.order].)  If you stream a non-pointer, then the
+  // previous definition will be used.
+  //
+  // The reason for this overload is that streaming a NULL pointer to
+  // ostream is undefined behavior.  Depending on the compiler, you
+  // may get "0", "(nil)", "(null)", or an access violation.  To
+  // ensure consistent result across compilers, we always treat NULL
+  // as "(null)".
+  template <typename T>
+  inline Message& operator <<(T* const& pointer) {  // NOLINT
+    if (pointer == NULL) {
+      *ss_ << "(null)";
+    } else {
+      *ss_ << pointer;
+    }
+    return *this;
+  }
+#endif  // GTEST_OS_SYMBIAN
+
+  // Since the basic IO manipulators are overloaded for both narrow
+  // and wide streams, we have to provide this specialized definition
+  // of operator <<, even though its body is the same as the
+  // templatized version above.  Without this definition, streaming
+  // endl or other basic IO manipulators to Message will confuse the
+  // compiler.
+  Message& operator <<(BasicNarrowIoManip val) {
+    *ss_ << val;
+    return *this;
+  }
+
+  // Instead of 1/0, we want to see true/false for bool values.
+  Message& operator <<(bool b) {
+    return *this << (b ? "true" : "false");
+  }
+
+  // These two overloads allow streaming a wide C string to a Message
+  // using the UTF-8 encoding.
+  Message& operator <<(const wchar_t* wide_c_str);
+  Message& operator <<(wchar_t* wide_c_str);
+
+#if GTEST_HAS_STD_WSTRING
+  // Converts the given wide string to a narrow string using the UTF-8
+  // encoding, and streams the result to this Message object.
+  Message& operator <<(const ::std::wstring& wstr);
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_HAS_GLOBAL_WSTRING
+  // Converts the given wide string to a narrow string using the UTF-8
+  // encoding, and streams the result to this Message object.
+  Message& operator <<(const ::wstring& wstr);
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+  // Gets the text streamed to this object so far as an std::string.
+  // Each '\0' character in the buffer is replaced with "\\0".
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  std::string GetString() const;
+
+ private:
+
+#if GTEST_OS_SYMBIAN
+  // These are needed as the Nokia Symbian Compiler cannot decide between
+  // const T& and const T* in a function template. The Nokia compiler _can_
+  // decide between class template specializations for T and T*, so a
+  // tr1::type_traits-like is_pointer works, and we can overload on that.
+  template <typename T>
+  inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
+    if (pointer == NULL) {
+      *ss_ << "(null)";
+    } else {
+      *ss_ << pointer;
+    }
+  }
+  template <typename T>
+  inline void StreamHelper(internal::false_type /*is_pointer*/,
+                           const T& value) {
+    // See the comments in Message& operator <<(const T&) above for why
+    // we need this using statement.
+    using ::operator <<;
+    *ss_ << value;
+  }
+#endif  // GTEST_OS_SYMBIAN
+
+  // We'll hold the text streamed to this object here.
+  const internal::scoped_ptr< ::std::stringstream> ss_;
+
+  // We declare (but don't implement) this to prevent the compiler
+  // from implementing the assignment operator.
+  void operator=(const Message&);
+};
+
+// Streams a Message to an ostream.
+inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
+  return os << sb.GetString();
+}
+
+namespace internal {
+
+// Converts a streamable value to an std::string.  A NULL pointer is
+// converted to "(null)".  When the input value is a ::string,
+// ::std::string, ::wstring, or ::std::wstring object, each NUL
+// character in it is replaced with "\\0".
+template <typename T>
+std::string StreamableToString(const T& streamable) {
+  return (Message() << streamable).GetString();
+}
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h
new file mode 100644
index 00000000..038f9ba7
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h
@@ -0,0 +1,1444 @@
+// This file was GENERATED by command:
+//     pump.py gtest-param-test.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// 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.
+//
+// Authors: vladl@google.com (Vlad Losev)
+//
+// Macros and functions for implementing parameterized tests
+// in Google C++ Testing Framework (Google Test)
+//
+// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
+//
+#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+#define GTEST_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.
+//
+// Here is how you use value-parameterized tests:
+
+#if 0
+
+// To write value-parameterized tests, first you should define a fixture
+// class. It is usually derived from testing::TestWithParam<T> (see below for
+// another inheritance scheme that's sometimes useful in more complicated
+// class hierarchies), where the type of your parameter values.
+// TestWithParam<T> is itself derived from testing::Test. T can be any
+// copyable type. If it's a raw pointer, you are responsible for managing the
+// lifespan of the pointed values.
+
+class FooTest : public ::testing::TestWithParam<const char*> {
+  // You can implement all the usual class fixture members here.
+};
+
+// Then, use the TEST_P macro to define as many parameterized tests
+// for this fixture as you want. The _P suffix is for "parameterized"
+// or "pattern", whichever you prefer to think.
+
+TEST_P(FooTest, DoesBlah) {
+  // Inside a test, access the test parameter with the GetParam() method
+  // of the TestWithParam<T> class:
+  EXPECT_TRUE(foo.Blah(GetParam()));
+  ...
+}
+
+TEST_P(FooTest, HasBlahBlah) {
+  ...
+}
+
+// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
+// case with 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
+// are all in the testing namespace:
+//
+//
+//  Range(begin, end [, step]) - Yields values {begin, begin+step,
+//                               begin+step+step, ...}. The values do not
+//                               include end. step defaults to 1.
+//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
+//  ValuesIn(container)        - Yields values from a C-style array, an STL
+//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
+//  Bool()                     - Yields sequence {false, true}.
+//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
+//                               for the math savvy) of the values generated
+//                               by the N generators.
+//
+// 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 case
+// each with parameter values "meeny", "miny", and "moe".
+
+INSTANTIATE_TEST_CASE_P(InstantiationName,
+                        FooTest,
+                        Values("meeny", "miny", "moe"));
+
+// To distinguish different instances of the pattern, (yes, you
+// can instantiate it more then once) the first argument to the
+// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
+// actual test case name. Remember to pick unique prefixes for different
+// instantiations. The tests from the instantiation above will have
+// these names:
+//
+//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
+//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
+//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
+//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
+//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
+//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
+//
+// You can use these names in --gtest_filter.
+//
+// This statement will instantiate all tests from FooTest again, each
+// with parameter values "cat" and "dog":
+
+const char* pets[] = {"cat", "dog"};
+INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
+
+// The tests from the instantiation above will have these names:
+//
+//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
+//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
+//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
+//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
+//
+// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
+// in the given test case, whether their definitions come before or
+// AFTER the INSTANTIATE_TEST_CASE_P statement.
+//
+// Please also note that generator expressions (including parameters to the
+// generators) are evaluated in InitGoogleTest(), after main() has started.
+// This allows the user on one hand, to adjust generator parameters in order
+// to dynamically determine a set of tests to run and on the other hand,
+// give the user a chance to inspect the generated tests with Google Test
+// reflection API before RUN_ALL_TESTS() is executed.
+//
+// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
+// for more examples.
+//
+// In the future, we plan to publish the API for defining new parameter
+// generators. But for now this interface remains part of the internal
+// implementation and is subject to change.
+//
+//
+// A parameterized test fixture must be derived from testing::Test and from
+// testing::WithParamInterface<T>, where T is the type of the parameter
+// values. Inheriting from TestWithParam<T> satisfies that requirement because
+// TestWithParam<T> inherits from both Test and WithParamInterface. In more
+// complicated hierarchies, however, it is occasionally useful to inherit
+// separately from Test and WithParamInterface. For example:
+
+class BaseTest : public ::testing::Test {
+  // You can inherit all the usual members for a non-parameterized test
+  // fixture here.
+};
+
+class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
+  // The usual test fixture members go here too.
+};
+
+TEST_F(BaseTest, HasFoo) {
+  // This is an ordinary non-parameterized test.
+}
+
+TEST_P(DerivedTest, DoesBlah) {
+  // GetParam works just the same here as if you inherit from TestWithParam.
+  EXPECT_TRUE(foo.Blah(GetParam()));
+}
+
+#endif  // 0
+
+#include "gtest/internal/gtest-port.h"
+
+#if !GTEST_OS_SYMBIAN
+# include <utility>
+#endif
+
+// scripts/fuse_gtest.py depends on gtest's own header being #included
+// *unconditionally*.  Therefore these #includes cannot be moved
+// inside #if GTEST_HAS_PARAM_TEST.
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-param-util.h"
+#include "gtest/internal/gtest-param-util-generated.h"
+
+#if GTEST_HAS_PARAM_TEST
+
+namespace testing {
+
+// Functions producing parameter generators.
+//
+// Google Test uses these generators to produce parameters for value-
+// parameterized tests. When a parameterized test case 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 case FooTest are instantiated
+// each three times with parameter values 3, 5, and 8:
+//
+// class FooTest : public TestWithParam<int> { ... };
+//
+// TEST_P(FooTest, TestThis) {
+// }
+// TEST_P(FooTest, TestThat) {
+// }
+// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
+//
+
+// Range() returns generators providing sequences of values in a range.
+//
+// Synopsis:
+// Range(start, end)
+//   - returns a generator producing a sequence of values {start, start+1,
+//     start+2, ..., }.
+// Range(start, end, step)
+//   - returns a generator producing a sequence of values {start, start+step,
+//     start+step+step, ..., }.
+// Notes:
+//   * The generated sequences never include end. For example, Range(1, 5)
+//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
+//     returns a generator producing {1, 3, 5, 7}.
+//   * start and end must have the same type. That type may be any integral or
+//     floating-point type or a user defined type satisfying these conditions:
+//     * It must be assignable (have operator=() defined).
+//     * It must have operator+() (operator+(int-compatible type) for
+//       two-operand version).
+//     * It must have operator<() defined.
+//     Elements in the resulting sequences will also have that type.
+//   * Condition start < end must be satisfied in order for resulting sequences
+//     to contain any elements.
+//
+template <typename T, typename IncrementT>
+internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
+  return internal::ParamGenerator<T>(
+      new internal::RangeGenerator<T, IncrementT>(start, end, step));
+}
+
+template <typename T>
+internal::ParamGenerator<T> Range(T start, T end) {
+  return Range(start, end, 1);
+}
+
+// ValuesIn() function allows generation of tests with parameters coming from
+// a container.
+//
+// Synopsis:
+// ValuesIn(const T (&array)[N])
+//   - returns a generator producing sequences with elements from
+//     a C-style array.
+// ValuesIn(const Container& container)
+//   - returns a generator producing sequences with elements from
+//     an STL-style container.
+// ValuesIn(Iterator begin, Iterator end)
+//   - returns a generator producing sequences with elements from
+//     a range [begin, end) defined by a pair of STL-style iterators. These
+//     iterators can also be plain C pointers.
+//
+// Please note that ValuesIn copies the values from the containers
+// passed in and keeps them to generate tests in RUN_ALL_TESTS().
+//
+// Examples:
+//
+// This instantiates tests from test case StringTest
+// each with C-string values of "foo", "bar", and "baz":
+//
+// const char* strings[] = {"foo", "bar", "baz"};
+// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));
+//
+// This instantiates tests from test case StlStringTest
+// each with STL strings with values "a" and "b":
+//
+// ::std::vector< ::std::string> GetParameterStrings() {
+//   ::std::vector< ::std::string> v;
+//   v.push_back("a");
+//   v.push_back("b");
+//   return v;
+// }
+//
+// INSTANTIATE_TEST_CASE_P(CharSequence,
+//                         StlStringTest,
+//                         ValuesIn(GetParameterStrings()));
+//
+//
+// This will also instantiate tests from CharTest
+// each with parameter values 'a' and 'b':
+//
+// ::std::list<char> GetParameterChars() {
+//   ::std::list<char> list;
+//   list.push_back('a');
+//   list.push_back('b');
+//   return list;
+// }
+// ::std::list<char> l = GetParameterChars();
+// INSTANTIATE_TEST_CASE_P(CharSequence2,
+//                         CharTest,
+//                         ValuesIn(l.begin(), l.end()));
+//
+template <typename ForwardIterator>
+internal::ParamGenerator<
+  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
+ValuesIn(ForwardIterator begin, ForwardIterator end) {
+  typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
+      ::value_type ParamType;
+  return internal::ParamGenerator<ParamType>(
+      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
+}
+
+template <typename T, size_t N>
+internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
+  return ValuesIn(array, array + N);
+}
+
+template <class Container>
+internal::ParamGenerator<typename Container::value_type> ValuesIn(
+    const Container& container) {
+  return ValuesIn(container.begin(), container.end());
+}
+
+// Values() allows generating tests from explicitly specified list of
+// parameters.
+//
+// Synopsis:
+// Values(T v1, T v2, ..., T vN)
+//   - returns a generator producing sequences with elements v1, v2, ..., vN.
+//
+// For example, this instantiates tests from test case BarTest each
+// with values "one", "two", and "three":
+//
+// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));
+//
+// This instantiates tests from test case BazTest each with values 1, 2, 3.5.
+// The exact type of values will depend on the type of parameter in BazTest.
+//
+// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
+//
+// Currently, Values() supports from 1 to 50 parameters.
+//
+template <typename T1>
+internal::ValueArray1<T1> Values(T1 v1) {
+  return internal::ValueArray1<T1>(v1);
+}
+
+template <typename T1, typename T2>
+internal::ValueArray2<T1, T2> Values(T1 v1, T2 v2) {
+  return internal::ValueArray2<T1, T2>(v1, v2);
+}
+
+template <typename T1, typename T2, typename T3>
+internal::ValueArray3<T1, T2, T3> Values(T1 v1, T2 v2, T3 v3) {
+  return internal::ValueArray3<T1, T2, T3>(v1, v2, v3);
+}
+
+template <typename T1, typename T2, typename T3, typename T4>
+internal::ValueArray4<T1, T2, T3, T4> Values(T1 v1, T2 v2, T3 v3, T4 v4) {
+  return internal::ValueArray4<T1, T2, T3, T4>(v1, v2, v3, v4);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+internal::ValueArray5<T1, T2, T3, T4, T5> Values(T1 v1, T2 v2, T3 v3, T4 v4,
+    T5 v5) {
+  return internal::ValueArray5<T1, T2, T3, T4, T5>(v1, v2, v3, v4, v5);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+internal::ValueArray6<T1, T2, T3, T4, T5, T6> Values(T1 v1, T2 v2, T3 v3,
+    T4 v4, T5 v5, T6 v6) {
+  return internal::ValueArray6<T1, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7> Values(T1 v1, T2 v2, T3 v3,
+    T4 v4, T5 v5, T6 v6, T7 v7) {
+  return internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7>(v1, v2, v3, v4, v5,
+      v6, v7);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8> Values(T1 v1, T2 v2,
+    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
+  return internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8>(v1, v2, v3, v4,
+      v5, v6, v7, v8);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9> Values(T1 v1, T2 v2,
+    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
+  return internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1, v2, v3,
+      v4, v5, v6, v7, v8, v9);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Values(T1 v1,
+    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {
+  return internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(v1,
+      v2, v3, v4, v5, v6, v7, v8, v9, v10);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11>
+internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
+    T11> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11) {
+  return internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
+      T11>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12>
+internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+    T12> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12) {
+  return internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13>
+internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+    T13> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13) {
+  return internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14>
+internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) {
+  return internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
+      v14);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15>
+internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
+    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) {
+  return internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+      v13, v14, v15);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16>
+internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16) {
+  return internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+      v12, v13, v14, v15, v16);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17>
+internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17) {
+  return internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
+      v11, v12, v13, v14, v15, v16, v17);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18>
+internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
+    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18) {
+  return internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
+      v10, v11, v12, v13, v14, v15, v16, v17, v18);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19>
+internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
+    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
+    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) {
+  return internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19>(v1, v2, v3, v4, v5, v6, v7, v8,
+      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20>
+internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20> Values(T1 v1, T2 v2, T3 v3, T4 v4,
+    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
+    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) {
+  return internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20>(v1, v2, v3, v4, v5, v6, v7,
+      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21>
+internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21> Values(T1 v1, T2 v2, T3 v3, T4 v4,
+    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
+    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21) {
+  return internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(v1, v2, v3, v4, v5, v6,
+      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22>
+internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22> Values(T1 v1, T2 v2, T3 v3,
+    T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
+    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
+    T21 v21, T22 v22) {
+  return internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(v1, v2, v3, v4,
+      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
+      v20, v21, v22);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23>
+internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Values(T1 v1, T2 v2,
+    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
+    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
+    T21 v21, T22 v22, T23 v23) {
+  return internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>(v1, v2, v3,
+      v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
+      v20, v21, v22, v23);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24>
+internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Values(T1 v1, T2 v2,
+    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
+    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
+    T21 v21, T22 v22, T23 v23, T24 v24) {
+  return internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>(v1, v2,
+      v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
+      v19, v20, v21, v22, v23, v24);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25>
+internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Values(T1 v1,
+    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
+    T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,
+    T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25) {
+  return internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>(v1,
+      v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
+      v18, v19, v20, v21, v22, v23, v24, v25);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26>
+internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+    T26> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26) {
+  return internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+      v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27>
+internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+    T27> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27) {
+  return internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
+      v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28>
+internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+    T28> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27, T28 v28) {
+  return internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
+      v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
+      v28);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29>
+internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27, T28 v28, T29 v29) {
+  return internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+      v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
+      v27, v28, v29);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30>
+internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
+    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
+    T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
+    T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) {
+  return internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+      v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
+      v26, v27, v28, v29, v30);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31>
+internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
+    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) {
+  return internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
+      v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
+      v25, v26, v27, v28, v29, v30, v31);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32>
+internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
+    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
+    T32 v32) {
+  return internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
+      v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
+      v24, v25, v26, v27, v28, v29, v30, v31, v32);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33>
+internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
+    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
+    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
+    T32 v32, T33 v33) {
+  return internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33>(v1, v2, v3, v4, v5, v6, v7, v8,
+      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
+      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34>
+internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
+    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
+    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,
+    T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,
+    T31 v31, T32 v32, T33 v33, T34 v34) {
+  return internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34>(v1, v2, v3, v4, v5, v6, v7,
+      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
+      v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35>
+internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35> Values(T1 v1, T2 v2, T3 v3, T4 v4,
+    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
+    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
+    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
+    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35) {
+  return internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35>(v1, v2, v3, v4, v5, v6,
+      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
+      v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36>
+internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36> Values(T1 v1, T2 v2, T3 v3, T4 v4,
+    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
+    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
+    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
+    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36) {
+  return internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36>(v1, v2, v3, v4,
+      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
+      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
+      v34, v35, v36);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37>
+internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37> Values(T1 v1, T2 v2, T3 v3,
+    T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
+    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
+    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
+    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
+    T37 v37) {
+  return internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37>(v1, v2, v3,
+      v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
+      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
+      v34, v35, v36, v37);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38>
+internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Values(T1 v1, T2 v2,
+    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
+    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
+    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
+    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
+    T37 v37, T38 v38) {
+  return internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38>(v1, v2,
+      v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
+      v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32,
+      v33, v34, v35, v36, v37, v38);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39>
+internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Values(T1 v1, T2 v2,
+    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
+    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
+    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
+    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
+    T37 v37, T38 v38, T39 v39) {
+  return internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39>(v1,
+      v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
+      v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
+      v32, v33, v34, v35, v36, v37, v38, v39);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40>
+internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Values(T1 v1,
+    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
+    T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,
+    T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27,
+    T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35,
+    T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) {
+  return internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
+      v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29,
+      v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41>
+internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+    T41> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41) {
+  return internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
+      v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28,
+      v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42>
+internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+    T42> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+    T42 v42) {
+  return internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
+      v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
+      v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41,
+      v42);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43>
+internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+    T43> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+    T42 v42, T43 v43) {
+  return internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+      v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
+      v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40,
+      v41, v42, v43);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44>
+internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+    T42 v42, T43 v43, T44 v44) {
+  return internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+      v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
+      v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39,
+      v40, v41, v42, v43, v44);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45>
+internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
+    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
+    T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
+    T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
+    T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
+    T41 v41, T42 v42, T43 v43, T44 v44, T45 v45) {
+  return internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44, T45>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
+      v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
+      v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38,
+      v39, v40, v41, v42, v43, v44, v45);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46>
+internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45, T46> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
+    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
+    T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
+    T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) {
+  return internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44, T45, T46>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
+      v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
+      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
+      v38, v39, v40, v41, v42, v43, v44, v45, v46);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47>
+internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45, T46, T47> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
+    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
+    T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
+    T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) {
+  return internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44, T45, T46, T47>(v1, v2, v3, v4, v5, v6, v7, v8,
+      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
+      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
+      v38, v39, v40, v41, v42, v43, v44, v45, v46, v47);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48>
+internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45, T46, T47, T48> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
+    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
+    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
+    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
+    T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
+    T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47,
+    T48 v48) {
+  return internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44, T45, T46, T47, T48>(v1, v2, v3, v4, v5, v6, v7,
+      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
+      v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36,
+      v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49>
+internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45, T46, T47, T48, T49> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
+    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
+    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,
+    T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,
+    T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38,
+    T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46,
+    T47 v47, T48 v48, T49 v49) {
+  return internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44, T45, T46, T47, T48, T49>(v1, v2, v3, v4, v5, v6,
+      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
+      v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35,
+      v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49, typename T50>
+internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45, T46, T47, T48, T49, T50> Values(T1 v1, T2 v2, T3 v3, T4 v4,
+    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
+    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
+    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
+    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37,
+    T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45,
+    T46 v46, T47 v47, T48 v48, T49 v49, T50 v50) {
+  return internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>(v1, v2, v3, v4,
+      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
+      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
+      v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
+      v48, v49, v50);
+}
+
+// Bool() allows generating tests with parameters in a set of (false, true).
+//
+// Synopsis:
+// Bool()
+//   - returns a generator producing sequences with elements {false, true}.
+//
+// It is useful when testing code that depends on Boolean flags. Combinations
+// of multiple flags can be tested when several Bool()'s are combined using
+// Combine() function.
+//
+// In the following example all tests in the test case FlagDependentTest
+// will be instantiated twice with parameters false and true.
+//
+// class FlagDependentTest : public testing::TestWithParam<bool> {
+//   virtual void SetUp() {
+//     external_flag = GetParam();
+//   }
+// }
+// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
+//
+inline internal::ParamGenerator<bool> Bool() {
+  return Values(false, true);
+}
+
+# if GTEST_HAS_COMBINE
+// Combine() allows the user to combine two or more sequences to produce
+// values of a Cartesian product of those sequences' elements.
+//
+// Synopsis:
+// Combine(gen1, gen2, ..., genN)
+//   - 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
+//     tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
+//     of elements from sequences produces by gen1, gen2, ..., genN.
+//
+// Combine can have up to 10 arguments. This number is currently limited
+// by the maximum number of elements in the tuple implementation used by Google
+// Test.
+//
+// Example:
+//
+// This will instantiate tests in test case 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<tuple<const char*, Color> > {...};
+//
+// TEST_P(AnimalTest, AnimalLooksNice) {...}
+//
+// INSTANTIATE_TEST_CASE_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<tuple<bool, bool> > {
+//   virtual void SetUp() {
+//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
+//     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_CASE_P(TwoBoolSequence, FlagDependentTest,
+//                         Combine(Bool(), Bool()));
+//
+template <typename Generator1, typename Generator2>
+internal::CartesianProductHolder2<Generator1, Generator2> Combine(
+    const Generator1& g1, const Generator2& g2) {
+  return internal::CartesianProductHolder2<Generator1, Generator2>(
+      g1, g2);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3>
+internal::CartesianProductHolder3<Generator1, Generator2, Generator3> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3) {
+  return internal::CartesianProductHolder3<Generator1, Generator2, Generator3>(
+      g1, g2, g3);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4>
+internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
+    Generator4> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4) {
+  return internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
+      Generator4>(
+      g1, g2, g3, g4);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4, typename Generator5>
+internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
+    Generator4, Generator5> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4, const Generator5& g5) {
+  return internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
+      Generator4, Generator5>(
+      g1, g2, g3, g4, g5);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4, typename Generator5, typename Generator6>
+internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
+    Generator4, Generator5, Generator6> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4, const Generator5& g5, const Generator6& g6) {
+  return internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
+      Generator4, Generator5, Generator6>(
+      g1, g2, g3, g4, g5, g6);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4, typename Generator5, typename Generator6,
+    typename Generator7>
+internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
+    Generator4, Generator5, Generator6, Generator7> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4, const Generator5& g5, const Generator6& g6,
+        const Generator7& g7) {
+  return internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
+      Generator4, Generator5, Generator6, Generator7>(
+      g1, g2, g3, g4, g5, g6, g7);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4, typename Generator5, typename Generator6,
+    typename Generator7, typename Generator8>
+internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
+    Generator4, Generator5, Generator6, Generator7, Generator8> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4, const Generator5& g5, const Generator6& g6,
+        const Generator7& g7, const Generator8& g8) {
+  return internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
+      Generator4, Generator5, Generator6, Generator7, Generator8>(
+      g1, g2, g3, g4, g5, g6, g7, g8);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4, typename Generator5, typename Generator6,
+    typename Generator7, typename Generator8, typename Generator9>
+internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
+    Generator4, Generator5, Generator6, Generator7, Generator8,
+    Generator9> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4, const Generator5& g5, const Generator6& g6,
+        const Generator7& g7, const Generator8& g8, const Generator9& g9) {
+  return internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
+      Generator4, Generator5, Generator6, Generator7, Generator8, Generator9>(
+      g1, g2, g3, g4, g5, g6, g7, g8, g9);
+}
+
+template <typename Generator1, typename Generator2, typename Generator3,
+    typename Generator4, typename Generator5, typename Generator6,
+    typename Generator7, typename Generator8, typename Generator9,
+    typename Generator10>
+internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
+    Generator4, Generator5, Generator6, Generator7, Generator8, Generator9,
+    Generator10> Combine(
+    const Generator1& g1, const Generator2& g2, const Generator3& g3,
+        const Generator4& g4, const Generator5& g5, const Generator6& g6,
+        const Generator7& g7, const Generator8& g8, const Generator9& g9,
+        const Generator10& g10) {
+  return internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
+      Generator4, Generator5, Generator6, Generator7, Generator8, Generator9,
+      Generator10>(
+      g1, g2, g3, g4, g5, g6, g7, g8, g9, g10);
+}
+# endif  // GTEST_HAS_COMBINE
+
+
+
+# define TEST_P(test_case_name, test_name) \
+  class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
+      : public test_case_name { \
+   public: \
+    GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
+    virtual void TestBody(); \
+   private: \
+    static int AddToRegistry() { \
+      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
+          GetTestCasePatternHolder<test_case_name>(\
+              #test_case_name, \
+              ::testing::internal::CodeLocation(\
+                  __FILE__, __LINE__))->AddTestPattern(\
+                      #test_case_name, \
+                      #test_name, \
+                      new ::testing::internal::TestMetaFactory< \
+                          GTEST_TEST_CLASS_NAME_(\
+                              test_case_name, test_name)>()); \
+      return 0; \
+    } \
+    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(\
+        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
+  }; \
+  int GTEST_TEST_CLASS_NAME_(test_case_name, \
+                             test_name)::gtest_registering_dummy_ = \
+      GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
+  void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
+
+// The optional last argument to INSTANTIATE_TEST_CASE_P allows the user
+// to specify a function or functor that generates custom test name suffixes
+// based on the test parameters. The function should accept one argument of
+// type testing::TestParamInfo<class ParamType>, and return std::string.
+//
+// testing::PrintToStringParamName is a builtin test suffix generator that
+// returns the value of testing::PrintToString(GetParam()). It does not work
+// for std::string or C strings.
+//
+// Note: test names must be non-empty, unique, and may only contain ASCII
+// alphanumeric characters or underscore.
+
+# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, ...) \
+  ::testing::internal::ParamGenerator<test_case_name::ParamType> \
+      gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
+  ::std::string gtest_##prefix##test_case_name##_EvalGenerateName_( \
+      const ::testing::TestParamInfo<test_case_name::ParamType>& info) { \
+    return ::testing::internal::GetParamNameGen<test_case_name::ParamType> \
+        (__VA_ARGS__)(info); \
+  } \
+  int gtest_##prefix##test_case_name##_dummy_ GTEST_ATTRIBUTE_UNUSED_ = \
+      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
+          GetTestCasePatternHolder<test_case_name>(\
+              #test_case_name, \
+              ::testing::internal::CodeLocation(\
+                  __FILE__, __LINE__))->AddTestCaseInstantiation(\
+                      #prefix, \
+                      &gtest_##prefix##test_case_name##_EvalGenerator_, \
+                      &gtest_##prefix##test_case_name##_EvalGenerateName_, \
+                      __FILE__, __LINE__)
+
+}  // namespace testing
+
+#endif  // GTEST_HAS_PARAM_TEST
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h.pump b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h.pump
new file mode 100644
index 00000000..3078d6d2
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h.pump
@@ -0,0 +1,510 @@
+$$ -*- mode: c++; -*-
+$var n = 50  $$ Maximum length of Values arguments we want to support.
+$var maxtuple = 10  $$ Maximum number of Combine arguments we want to support.
+// 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.
+//
+// Authors: vladl@google.com (Vlad Losev)
+//
+// Macros and functions for implementing parameterized tests
+// in Google C++ Testing Framework (Google Test)
+//
+// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
+//
+#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+#define GTEST_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.
+//
+// Here is how you use value-parameterized tests:
+
+#if 0
+
+// To write value-parameterized tests, first you should define a fixture
+// class. It is usually derived from testing::TestWithParam<T> (see below for
+// another inheritance scheme that's sometimes useful in more complicated
+// class hierarchies), where the type of your parameter values.
+// TestWithParam<T> is itself derived from testing::Test. T can be any
+// copyable type. If it's a raw pointer, you are responsible for managing the
+// lifespan of the pointed values.
+
+class FooTest : public ::testing::TestWithParam<const char*> {
+  // You can implement all the usual class fixture members here.
+};
+
+// Then, use the TEST_P macro to define as many parameterized tests
+// for this fixture as you want. The _P suffix is for "parameterized"
+// or "pattern", whichever you prefer to think.
+
+TEST_P(FooTest, DoesBlah) {
+  // Inside a test, access the test parameter with the GetParam() method
+  // of the TestWithParam<T> class:
+  EXPECT_TRUE(foo.Blah(GetParam()));
+  ...
+}
+
+TEST_P(FooTest, HasBlahBlah) {
+  ...
+}
+
+// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
+// case with 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
+// are all in the testing namespace:
+//
+//
+//  Range(begin, end [, step]) - Yields values {begin, begin+step,
+//                               begin+step+step, ...}. The values do not
+//                               include end. step defaults to 1.
+//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
+//  ValuesIn(container)        - Yields values from a C-style array, an STL
+//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
+//  Bool()                     - Yields sequence {false, true}.
+//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
+//                               for the math savvy) of the values generated
+//                               by the N generators.
+//
+// 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 case
+// each with parameter values "meeny", "miny", and "moe".
+
+INSTANTIATE_TEST_CASE_P(InstantiationName,
+                        FooTest,
+                        Values("meeny", "miny", "moe"));
+
+// To distinguish different instances of the pattern, (yes, you
+// can instantiate it more then once) the first argument to the
+// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
+// actual test case name. Remember to pick unique prefixes for different
+// instantiations. The tests from the instantiation above will have
+// these names:
+//
+//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
+//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
+//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
+//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
+//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
+//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
+//
+// You can use these names in --gtest_filter.
+//
+// This statement will instantiate all tests from FooTest again, each
+// with parameter values "cat" and "dog":
+
+const char* pets[] = {"cat", "dog"};
+INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
+
+// The tests from the instantiation above will have these names:
+//
+//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
+//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
+//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
+//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
+//
+// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
+// in the given test case, whether their definitions come before or
+// AFTER the INSTANTIATE_TEST_CASE_P statement.
+//
+// Please also note that generator expressions (including parameters to the
+// generators) are evaluated in InitGoogleTest(), after main() has started.
+// This allows the user on one hand, to adjust generator parameters in order
+// to dynamically determine a set of tests to run and on the other hand,
+// give the user a chance to inspect the generated tests with Google Test
+// reflection API before RUN_ALL_TESTS() is executed.
+//
+// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
+// for more examples.
+//
+// In the future, we plan to publish the API for defining new parameter
+// generators. But for now this interface remains part of the internal
+// implementation and is subject to change.
+//
+//
+// A parameterized test fixture must be derived from testing::Test and from
+// testing::WithParamInterface<T>, where T is the type of the parameter
+// values. Inheriting from TestWithParam<T> satisfies that requirement because
+// TestWithParam<T> inherits from both Test and WithParamInterface. In more
+// complicated hierarchies, however, it is occasionally useful to inherit
+// separately from Test and WithParamInterface. For example:
+
+class BaseTest : public ::testing::Test {
+  // You can inherit all the usual members for a non-parameterized test
+  // fixture here.
+};
+
+class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
+  // The usual test fixture members go here too.
+};
+
+TEST_F(BaseTest, HasFoo) {
+  // This is an ordinary non-parameterized test.
+}
+
+TEST_P(DerivedTest, DoesBlah) {
+  // GetParam works just the same here as if you inherit from TestWithParam.
+  EXPECT_TRUE(foo.Blah(GetParam()));
+}
+
+#endif  // 0
+
+#include "gtest/internal/gtest-port.h"
+
+#if !GTEST_OS_SYMBIAN
+# include <utility>
+#endif
+
+// scripts/fuse_gtest.py depends on gtest's own header being #included
+// *unconditionally*.  Therefore these #includes cannot be moved
+// inside #if GTEST_HAS_PARAM_TEST.
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-param-util.h"
+#include "gtest/internal/gtest-param-util-generated.h"
+
+#if GTEST_HAS_PARAM_TEST
+
+namespace testing {
+
+// Functions producing parameter generators.
+//
+// Google Test uses these generators to produce parameters for value-
+// parameterized tests. When a parameterized test case 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 case FooTest are instantiated
+// each three times with parameter values 3, 5, and 8:
+//
+// class FooTest : public TestWithParam<int> { ... };
+//
+// TEST_P(FooTest, TestThis) {
+// }
+// TEST_P(FooTest, TestThat) {
+// }
+// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
+//
+
+// Range() returns generators providing sequences of values in a range.
+//
+// Synopsis:
+// Range(start, end)
+//   - returns a generator producing a sequence of values {start, start+1,
+//     start+2, ..., }.
+// Range(start, end, step)
+//   - returns a generator producing a sequence of values {start, start+step,
+//     start+step+step, ..., }.
+// Notes:
+//   * The generated sequences never include end. For example, Range(1, 5)
+//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
+//     returns a generator producing {1, 3, 5, 7}.
+//   * start and end must have the same type. That type may be any integral or
+//     floating-point type or a user defined type satisfying these conditions:
+//     * It must be assignable (have operator=() defined).
+//     * It must have operator+() (operator+(int-compatible type) for
+//       two-operand version).
+//     * It must have operator<() defined.
+//     Elements in the resulting sequences will also have that type.
+//   * Condition start < end must be satisfied in order for resulting sequences
+//     to contain any elements.
+//
+template <typename T, typename IncrementT>
+internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
+  return internal::ParamGenerator<T>(
+      new internal::RangeGenerator<T, IncrementT>(start, end, step));
+}
+
+template <typename T>
+internal::ParamGenerator<T> Range(T start, T end) {
+  return Range(start, end, 1);
+}
+
+// ValuesIn() function allows generation of tests with parameters coming from
+// a container.
+//
+// Synopsis:
+// ValuesIn(const T (&array)[N])
+//   - returns a generator producing sequences with elements from
+//     a C-style array.
+// ValuesIn(const Container& container)
+//   - returns a generator producing sequences with elements from
+//     an STL-style container.
+// ValuesIn(Iterator begin, Iterator end)
+//   - returns a generator producing sequences with elements from
+//     a range [begin, end) defined by a pair of STL-style iterators. These
+//     iterators can also be plain C pointers.
+//
+// Please note that ValuesIn copies the values from the containers
+// passed in and keeps them to generate tests in RUN_ALL_TESTS().
+//
+// Examples:
+//
+// This instantiates tests from test case StringTest
+// each with C-string values of "foo", "bar", and "baz":
+//
+// const char* strings[] = {"foo", "bar", "baz"};
+// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));
+//
+// This instantiates tests from test case StlStringTest
+// each with STL strings with values "a" and "b":
+//
+// ::std::vector< ::std::string> GetParameterStrings() {
+//   ::std::vector< ::std::string> v;
+//   v.push_back("a");
+//   v.push_back("b");
+//   return v;
+// }
+//
+// INSTANTIATE_TEST_CASE_P(CharSequence,
+//                         StlStringTest,
+//                         ValuesIn(GetParameterStrings()));
+//
+//
+// This will also instantiate tests from CharTest
+// each with parameter values 'a' and 'b':
+//
+// ::std::list<char> GetParameterChars() {
+//   ::std::list<char> list;
+//   list.push_back('a');
+//   list.push_back('b');
+//   return list;
+// }
+// ::std::list<char> l = GetParameterChars();
+// INSTANTIATE_TEST_CASE_P(CharSequence2,
+//                         CharTest,
+//                         ValuesIn(l.begin(), l.end()));
+//
+template <typename ForwardIterator>
+internal::ParamGenerator<
+  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
+ValuesIn(ForwardIterator begin, ForwardIterator end) {
+  typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
+      ::value_type ParamType;
+  return internal::ParamGenerator<ParamType>(
+      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
+}
+
+template <typename T, size_t N>
+internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
+  return ValuesIn(array, array + N);
+}
+
+template <class Container>
+internal::ParamGenerator<typename Container::value_type> ValuesIn(
+    const Container& container) {
+  return ValuesIn(container.begin(), container.end());
+}
+
+// Values() allows generating tests from explicitly specified list of
+// parameters.
+//
+// Synopsis:
+// Values(T v1, T v2, ..., T vN)
+//   - returns a generator producing sequences with elements v1, v2, ..., vN.
+//
+// For example, this instantiates tests from test case BarTest each
+// with values "one", "two", and "three":
+//
+// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));
+//
+// This instantiates tests from test case BazTest each with values 1, 2, 3.5.
+// The exact type of values will depend on the type of parameter in BazTest.
+//
+// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
+//
+// Currently, Values() supports from 1 to $n parameters.
+//
+$range i 1..n
+$for i [[
+$range j 1..i
+
+template <$for j, [[typename T$j]]>
+internal::ValueArray$i<$for j, [[T$j]]> Values($for j, [[T$j v$j]]) {
+  return internal::ValueArray$i<$for j, [[T$j]]>($for j, [[v$j]]);
+}
+
+]]
+
+// Bool() allows generating tests with parameters in a set of (false, true).
+//
+// Synopsis:
+// Bool()
+//   - returns a generator producing sequences with elements {false, true}.
+//
+// It is useful when testing code that depends on Boolean flags. Combinations
+// of multiple flags can be tested when several Bool()'s are combined using
+// Combine() function.
+//
+// In the following example all tests in the test case FlagDependentTest
+// will be instantiated twice with parameters false and true.
+//
+// class FlagDependentTest : public testing::TestWithParam<bool> {
+//   virtual void SetUp() {
+//     external_flag = GetParam();
+//   }
+// }
+// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
+//
+inline internal::ParamGenerator<bool> Bool() {
+  return Values(false, true);
+}
+
+# if GTEST_HAS_COMBINE
+// Combine() allows the user to combine two or more sequences to produce
+// values of a Cartesian product of those sequences' elements.
+//
+// Synopsis:
+// Combine(gen1, gen2, ..., genN)
+//   - 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
+//     tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
+//     of elements from sequences produces by gen1, gen2, ..., genN.
+//
+// Combine can have up to $maxtuple arguments. This number is currently limited
+// by the maximum number of elements in the tuple implementation used by Google
+// Test.
+//
+// Example:
+//
+// This will instantiate tests in test case 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<tuple<const char*, Color> > {...};
+//
+// TEST_P(AnimalTest, AnimalLooksNice) {...}
+//
+// INSTANTIATE_TEST_CASE_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<tuple<bool, bool> > {
+//   virtual void SetUp() {
+//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
+//     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_CASE_P(TwoBoolSequence, FlagDependentTest,
+//                         Combine(Bool(), Bool()));
+//
+$range i 2..maxtuple
+$for i [[
+$range j 1..i
+
+template <$for j, [[typename Generator$j]]>
+internal::CartesianProductHolder$i<$for j, [[Generator$j]]> Combine(
+    $for j, [[const Generator$j& g$j]]) {
+  return internal::CartesianProductHolder$i<$for j, [[Generator$j]]>(
+      $for j, [[g$j]]);
+}
+
+]]
+# endif  // GTEST_HAS_COMBINE
+
+
+
+# define TEST_P(test_case_name, test_name) \
+  class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
+      : public test_case_name { \
+   public: \
+    GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
+    virtual void TestBody(); \
+   private: \
+    static int AddToRegistry() { \
+      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
+          GetTestCasePatternHolder<test_case_name>(\
+              #test_case_name, \
+              ::testing::internal::CodeLocation(\
+                  __FILE__, __LINE__))->AddTestPattern(\
+                      #test_case_name, \
+                      #test_name, \
+                      new ::testing::internal::TestMetaFactory< \
+                          GTEST_TEST_CLASS_NAME_(\
+                              test_case_name, test_name)>()); \
+      return 0; \
+    } \
+    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(\
+        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
+  }; \
+  int GTEST_TEST_CLASS_NAME_(test_case_name, \
+                             test_name)::gtest_registering_dummy_ = \
+      GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
+  void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
+
+// The optional last argument to INSTANTIATE_TEST_CASE_P allows the user
+// to specify a function or functor that generates custom test name suffixes
+// based on the test parameters. The function should accept one argument of
+// type testing::TestParamInfo<class ParamType>, and return std::string.
+//
+// testing::PrintToStringParamName is a builtin test suffix generator that
+// returns the value of testing::PrintToString(GetParam()).
+//
+// 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 INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, ...) \
+  ::testing::internal::ParamGenerator<test_case_name::ParamType> \
+      gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
+  ::std::string gtest_##prefix##test_case_name##_EvalGenerateName_( \
+      const ::testing::TestParamInfo<test_case_name::ParamType>& info) { \
+    return ::testing::internal::GetParamNameGen<test_case_name::ParamType> \
+        (__VA_ARGS__)(info); \
+  } \
+  int gtest_##prefix##test_case_name##_dummy_ GTEST_ATTRIBUTE_UNUSED_ = \
+      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
+          GetTestCasePatternHolder<test_case_name>(\
+              #test_case_name, \
+              ::testing::internal::CodeLocation(\
+                  __FILE__, __LINE__))->AddTestCaseInstantiation(\
+                      #prefix, \
+                      &gtest_##prefix##test_case_name##_EvalGenerator_, \
+                      &gtest_##prefix##test_case_name##_EvalGenerateName_, \
+                      __FILE__, __LINE__)
+
+}  // namespace testing
+
+#endif  // GTEST_HAS_PARAM_TEST
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-printers.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-printers.h
new file mode 100644
index 00000000..8a33164c
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-printers.h
@@ -0,0 +1,993 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Test - The Google C++ Testing Framework
+//
+// This file implements a universal value printer that can print a
+// value of any type T:
+//
+//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
+//
+// A user can teach this function how to print a class type T by
+// defining either operator<<() or PrintTo() in the namespace that
+// defines T.  More specifically, the FIRST defined function in the
+// following list will be used (assuming T is defined in namespace
+// foo):
+//
+//   1. foo::PrintTo(const T&, ostream*)
+//   2. operator<<(ostream&, const T&) defined in either foo or the
+//      global namespace.
+//
+// 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.
+//
+// To aid debugging: when T is a reference type, the address of the
+// value is also printed; when T is a (const) char pointer, both the
+// pointer value and the NUL-terminated string it points to are
+// printed.
+//
+// We also provide some convenient wrappers:
+//
+//   // Prints a value to a string.  For a (const or not) char
+//   // pointer, the NUL-terminated string (but not the pointer) is
+//   // printed.
+//   std::string ::testing::PrintToString(const T& value);
+//
+//   // Prints a value tersely: for a reference type, the referenced
+//   // value (but not the address) is printed; for a (const or not) char
+//   // pointer, the NUL-terminated string (but not the pointer) is
+//   // printed.
+//   void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
+//
+//   // Prints value using the type inferred by the compiler.  The difference
+//   // from UniversalTersePrint() is that this function prints both the
+//   // pointer and the NUL-terminated string for a (const or not) char pointer.
+//   void ::testing::internal::UniversalPrint(const T& value, ostream*);
+//
+//   // Prints the fields of a tuple tersely to a string vector, one
+//   // element for each field. Tuple support must be enabled in
+//   // gtest-port.h.
+//   std::vector<string> UniversalTersePrintTupleFieldsToStrings(
+//       const Tuple& value);
+//
+// Known limitation:
+//
+// The print primitives print the elements of an STL-style container
+// using the compiler-inferred type of *iter where iter is a
+// const_iterator of the container.  When const_iterator is an input
+// iterator but not a forward iterator, this inferred type may not
+// match value_type, and the print output may be incorrect.  In
+// practice, this is rarely a problem as for most containers
+// const_iterator is a forward iterator.  We'll fix this if there's an
+// actual need for it.  Note that this fix cannot rely on value_type
+// being defined as many user-defined container types don't have
+// value_type.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+#include "gtest/internal/gtest-port.h"
+#include "gtest/internal/gtest-internal.h"
+
+#if GTEST_HAS_STD_TUPLE_
+# include <tuple>
+#endif
+
+namespace testing {
+
+// Definitions in the 'internal' and 'internal2' name spaces are
+// subject to change without notice.  DO NOT USE THEM IN USER CODE!
+namespace internal2 {
+
+// 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);
+
+// For selecting which printer to use when a given type has neither <<
+// nor PrintTo().
+enum TypeKind {
+  kProtobuf,              // a protobuf type
+  kConvertibleToInteger,  // a type implicitly convertible to BiggestInt
+                          // (e.g. a named or unnamed enum type)
+  kOtherType              // anything else
+};
+
+// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
+// by the universal printer to print a value of type T when neither
+// operator<< nor PrintTo() is defined for T, where kTypeKind is the
+// "kind" of T as defined by enum TypeKind.
+template <typename T, TypeKind kTypeKind>
+class TypeWithoutFormatter {
+ public:
+  // This default version is called when kTypeKind is kOtherType.
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value),
+                         sizeof(value), os);
+  }
+};
+
+// 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.
+const size_t kProtobufOneLinerMaxLength = 50;
+
+template <typename T>
+class TypeWithoutFormatter<T, kProtobuf> {
+ public:
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    const ::testing::internal::string short_str = value.ShortDebugString();
+    const ::testing::internal::string pretty_str =
+        short_str.length() <= kProtobufOneLinerMaxLength ?
+        short_str : ("\n" + value.DebugString());
+    *os << ("<" + pretty_str + ">");
+  }
+};
+
+template <typename T>
+class TypeWithoutFormatter<T, kConvertibleToInteger> {
+ public:
+  // Since T has no << operator or PrintTo() but can be implicitly
+  // converted to BiggestInt, we print it as a BiggestInt.
+  //
+  // Most likely T is an enum type (either named or unnamed), in which
+  // 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(const T& value, ::std::ostream* os) {
+    const internal::BiggestInt kBigInt = value;
+    *os << kBigInt;
+  }
+};
+
+// Prints the given value to the given ostream.  If the value is a
+// protocol message, its debug string is printed; if it's an enum or
+// of a type implicitly convertible to BiggestInt, it's printed as an
+// integer; otherwise the bytes in the value are printed.  This is
+// what UniversalPrinter<T>::Print() does when it knows nothing about
+// type T and T has neither << operator nor PrintTo().
+//
+// A user can override this behavior for a class type Foo by defining
+// a << operator in the namespace where Foo is defined.
+//
+// We put this operator in namespace 'internal2' instead of 'internal'
+// to simplify the implementation, as much code in 'internal' needs to
+// use << in STL, which would conflict with our own << were it defined
+// in 'internal'.
+//
+// Note that this operator<< takes a generic std::basic_ostream<Char,
+// CharTraits> type instead of the more restricted std::ostream.  If
+// we define it to take an std::ostream instead, we'll get an
+// "ambiguous overloads" compiler error when trying to print a type
+// Foo that supports streaming to std::basic_ostream<Char,
+// CharTraits>, as the compiler cannot tell whether
+// operator<<(std::ostream&, const T&) or
+// operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more
+// specific.
+template <typename Char, typename CharTraits, typename T>
+::std::basic_ostream<Char, CharTraits>& operator<<(
+    ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
+  TypeWithoutFormatter<T,
+      (internal::IsAProtocolMessage<T>::value ? kProtobuf :
+       internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
+       kConvertibleToInteger : kOtherType)>::PrintValue(x, &os);
+  return os;
+}
+
+}  // namespace internal2
+}  // namespace testing
+
+// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
+// magic needed for implementing UniversalPrinter won't work.
+namespace testing_internal {
+
+// Used to print a value that is not an STL-style container when the
+// user doesn't define PrintTo() for it.
+template <typename T>
+void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
+  // With the following statement, during unqualified name lookup,
+  // testing::internal2::operator<< appears as if it was declared in
+  // the nearest enclosing namespace that contains both
+  // ::testing_internal and ::testing::internal2, i.e. the global
+  // namespace.  For more details, refer to the C++ Standard section
+  // 7.3.4-1 [namespace.udir].  This allows us to fall back onto
+  // testing::internal2::operator<< in case T doesn't come with a <<
+  // operator.
+  //
+  // We cannot write 'using ::testing::internal2::operator<<;', which
+  // gcc 3.3 fails to compile due to a compiler bug.
+  using namespace ::testing::internal2;  // NOLINT
+
+  // Assuming T is defined in namespace foo, in the next statement,
+  // the compiler will consider all of:
+  //
+  //   1. foo::operator<< (thanks to Koenig look-up),
+  //   2. ::operator<< (as the current namespace is enclosed in ::),
+  //   3. testing::internal2::operator<< (thanks to the using statement above).
+  //
+  // The operator<< whose type matches T best will be picked.
+  //
+  // We deliberately allow #2 to be a candidate, as sometimes it's
+  // impossible to define #1 (e.g. when foo is ::std, defining
+  // anything in it is undefined behavior unless you are a compiler
+  // vendor.).
+  *os << value;
+}
+
+}  // namespace testing_internal
+
+namespace testing {
+namespace internal {
+
+// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
+// value of type ToPrint that is an operand of a comparison assertion
+// (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
+// the comparison, and is used to help determine the best way to
+// format the value.  In particular, when the value is a C string
+// (char pointer) and the other operand is an STL string object, we
+// want to format the C string as a string, since we know it is
+// compared by value with the string object.  If the value is a char
+// pointer but the other operand is not an STL string object, we don't
+// know whether the pointer is supposed to point to a NUL-terminated
+// string, and thus want to print it as a pointer to be safe.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+// The default case.
+template <typename ToPrint, typename OtherOperand>
+class FormatForComparison {
+ public:
+  static ::std::string Format(const ToPrint& value) {
+    return ::testing::PrintToString(value);
+  }
+};
+
+// Array.
+template <typename ToPrint, size_t N, typename OtherOperand>
+class FormatForComparison<ToPrint[N], OtherOperand> {
+ public:
+  static ::std::string Format(const ToPrint* value) {
+    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
+  }
+};
+
+// By default, print C string as pointers to be safe, as we don't know
+// whether they actually point to a NUL-terminated string.
+
+#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
+  template <typename OtherOperand>                                      \
+  class FormatForComparison<CharType*, OtherOperand> {                  \
+   public:                                                              \
+    static ::std::string Format(CharType* value) {                      \
+      return ::testing::PrintToString(static_cast<const void*>(value)); \
+    }                                                                   \
+  }
+
+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);
+
+#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
+
+// If a C string is compared with an STL string object, we know it's meant
+// to point to a NUL-terminated string, and thus can print it as a string.
+
+#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
+  template <>                                                           \
+  class FormatForComparison<CharType*, OtherStringType> {               \
+   public:                                                              \
+    static ::std::string Format(CharType* value) {                      \
+      return ::testing::PrintToString(value);                           \
+    }                                                                   \
+  }
+
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
+
+#if GTEST_HAS_GLOBAL_STRING
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
+#endif
+
+#if GTEST_HAS_GLOBAL_WSTRING
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring);
+#endif
+
+#if GTEST_HAS_STD_WSTRING
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
+#endif
+
+#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
+
+// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
+// operand to be used in a failure message.  The type (but not value)
+// of the other operand may affect the format.  This allows us to
+// print a char* as a raw pointer when it is compared against another
+// char* or void*, and print it as a C string when it is compared
+// against an std::string object, for example.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+template <typename T1, typename T2>
+std::string FormatForComparisonFailureMessage(
+    const T1& value, const T2& /* other_operand */) {
+  return FormatForComparison<T1, T2>::Format(value);
+}
+
+// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
+// value to the given ostream.  The caller must ensure that
+// 'ostream_ptr' is not NULL, or the behavior is undefined.
+//
+// We define UniversalPrinter as a class template (as opposed to a
+// function template), as we need to partially specialize it for
+// reference types, which cannot be done with function templates.
+template <typename T>
+class UniversalPrinter;
+
+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.
+template <typename C>
+void DefaultPrintTo(IsContainer /* dummy */,
+                    false_type /* is not a pointer */,
+                    const C& container, ::std::ostream* os) {
+  const size_t kMaxCount = 32;  // The maximum number of elements to print.
+  *os << '{';
+  size_t count = 0;
+  for (typename C::const_iterator it = container.begin();
+       it != container.end(); ++it, ++count) {
+    if (count > 0) {
+      *os << ',';
+      if (count == kMaxCount) {  // Enough has been printed.
+        *os << " ...";
+        break;
+      }
+    }
+    *os << ' ';
+    // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
+    // handle *it being a native array.
+    internal::UniversalPrint(*it, os);
+  }
+
+  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.)
+template <typename T>
+void DefaultPrintTo(IsNotContainer /* dummy */,
+                    true_type /* is a pointer */,
+                    T* p, ::std::ostream* os) {
+  if (p == NULL) {
+    *os << "NULL";
+  } else {
+    // C++ doesn't allow casting from a function pointer to any object
+    // pointer.
+    //
+    // IsTrue() silences warnings: "Condition is always true",
+    // "unreachable code".
+    if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
+      // 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;
+    } 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*.  However, we cannot cast it to const void* directly,
+      // even using reinterpret_cast, as earlier versions of gcc
+      // (e.g. 3.4.5) cannot compile the cast when p is a function
+      // pointer.  Casting to UInt64 first solves the problem.
+      *os << reinterpret_cast<const void*>(
+          reinterpret_cast<internal::UInt64>(p));
+    }
+  }
+}
+
+// Used to print a non-container, non-pointer value when the user
+// doesn't define PrintTo() for it.
+template <typename T>
+void DefaultPrintTo(IsNotContainer /* dummy */,
+                    false_type /* is not a pointer */,
+                    const T& value, ::std::ostream* os) {
+  ::testing_internal::DefaultPrintNonContainerTo(value, os);
+}
+
+// Prints the given value using the << operator if it has one;
+// otherwise prints the bytes in it.  This is what
+// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
+// or overloaded for type T.
+//
+// A user can override this behavior for a class type Foo by defining
+// an overload of PrintTo() in the namespace where Foo is defined.  We
+// give the user this option as sometimes defining a << operator for
+// Foo is not desirable (e.g. the coding style may prevent doing it,
+// or there is already a << operator but it doesn't do what the user
+// wants).
+template <typename T>
+void PrintTo(const T& value, ::std::ostream* os) {
+  // DefaultPrintTo() is overloaded.  The type of its first two
+  // arguments determine which version will be picked.  If T is an
+  // STL-style container, the version for container will be called; if
+  // T is a pointer, the pointer version will be called; otherwise the
+  // generic version will be called.
+  //
+  // Note that we check for container types here, prior to we check
+  // for protocol message types in our operator<<.  The rationale is:
+  //
+  // For protocol messages, we want to give people a chance to
+  // override Google Mock's format by defining a PrintTo() or
+  // operator<<.  For STL containers, other formats can be
+  // incompatible with Google Mock's format for the container
+  // elements; therefore we check for container types here to ensure
+  // that our format is used.
+  //
+  // The second argument of DefaultPrintTo() is needed to bypass a bug
+  // in Symbian's C++ compiler that prevents it from picking the right
+  // overload between:
+  //
+  //   PrintTo(const T& x, ...);
+  //   PrintTo(T* x, ...);
+  DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
+}
+
+// The following list of PrintTo() overloads tells
+// UniversalPrinter<T>::Print() how to print standard types (built-in
+// types, strings, plain arrays, and pointers).
+
+// Overloads for various char types.
+GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
+GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
+inline void PrintTo(char c, ::std::ostream* os) {
+  // When printing a plain char, we always treat it as unsigned.  This
+  // way, the output won't be affected by whether the compiler thinks
+  // char is signed or not.
+  PrintTo(static_cast<unsigned char>(c), os);
+}
+
+// Overloads for other simple built-in types.
+inline void PrintTo(bool x, ::std::ostream* os) {
+  *os << (x ? "true" : "false");
+}
+
+// Overload for wchar_t type.
+// Prints a wchar_t as a symbol if it is printable or as its internal
+// code otherwise and also as its decimal code (except for L'\0').
+// The L'\0' char is printed as "L'\\0'". The decimal code is printed
+// as signed integer when wchar_t is implemented by the compiler
+// as a signed type and is printed as an unsigned integer when wchar_t
+// is implemented as an unsigned type.
+GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
+
+// Overloads for C strings.
+GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
+inline void PrintTo(char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char*>(s), os);
+}
+
+// signed/unsigned char is often used for representing binary data, so
+// we print pointers to it as void* to be safe.
+inline void PrintTo(const signed char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(signed char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(unsigned char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(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
+// type.  When wchar_t is a typedef, defining an overload for const
+// wchar_t* would cause unsigned short* be printed as a wide string,
+// possibly causing invalid memory accesses.
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+// Overloads for wide C strings
+GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
+inline void PrintTo(wchar_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const wchar_t*>(s), os);
+}
+#endif
+
+// Overload for C arrays.  Multi-dimensional arrays are printed
+// properly.
+
+// Prints the given number of elements in an array, without printing
+// the curly braces.
+template <typename T>
+void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
+  UniversalPrint(a[0], os);
+  for (size_t i = 1; i != count; i++) {
+    *os << ", ";
+    UniversalPrint(a[i], os);
+  }
+}
+
+// Overloads for ::string and ::std::string.
+#if GTEST_HAS_GLOBAL_STRING
+GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os);
+inline void PrintTo(const ::string& s, ::std::ostream* os) {
+  PrintStringTo(s, os);
+}
+#endif  // GTEST_HAS_GLOBAL_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 ::wstring and ::std::wstring.
+#if GTEST_HAS_GLOBAL_WSTRING
+GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os);
+inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
+  PrintWideStringTo(s, os);
+}
+#endif  // GTEST_HAS_GLOBAL_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) {
+  PrintWideStringTo(s, os);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
+// Helper function for printing a tuple.  T must be instantiated with
+// a tuple type.
+template <typename T>
+void PrintTupleTo(const T& t, ::std::ostream* os);
+#endif  // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
+
+#if GTEST_HAS_TR1_TUPLE
+// Overload for ::std::tr1::tuple.  Needed for printing function arguments,
+// which are packed as tuples.
+
+// Overloaded PrintTo() for tuples of various arities.  We support
+// tuples of up-to 10 fields.  The following implementation works
+// regardless of whether tr1::tuple is implemented using the
+// non-standard variadic template feature or not.
+
+inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1>
+void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2>
+void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
+             ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t,
+             ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
+             ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
+             ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9>
+void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t,
+             ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9, typename T10>
+void PrintTo(
+    const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t,
+    ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+#endif  // GTEST_HAS_TR1_TUPLE
+
+#if GTEST_HAS_STD_TUPLE_
+template <typename... Types>
+void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
+  PrintTupleTo(t, os);
+}
+#endif  // GTEST_HAS_STD_TUPLE_
+
+// Overload for std::pair.
+template <typename T1, typename T2>
+void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
+  *os << '(';
+  // We cannot use UniversalPrint(value.first, os) here, as T1 may be
+  // a reference type.  The same for printing value.second.
+  UniversalPrinter<T1>::Print(value.first, os);
+  *os << ", ";
+  UniversalPrinter<T2>::Print(value.second, os);
+  *os << ')';
+}
+
+// Implements printing a non-reference type T by letting the compiler
+// pick the right overload of PrintTo() for T.
+template <typename T>
+class UniversalPrinter {
+ public:
+  // MSVC warns about adding const to a function type, so we want to
+  // disable the warning.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
+
+  // Note: we deliberately don't call this PrintTo(), as that name
+  // conflicts with ::testing::internal::PrintTo in the body of the
+  // function.
+  static void Print(const T& value, ::std::ostream* os) {
+    // By default, ::testing::internal::PrintTo() is used for printing
+    // the value.
+    //
+    // Thanks to Koenig look-up, if T is a class and has its own
+    // PrintTo() function defined in its namespace, that function will
+    // be visible here.  Since it is more specific than the generic ones
+    // in ::testing::internal, it will be picked by the compiler in the
+    // following statement - exactly what we want.
+    PrintTo(value, os);
+  }
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+};
+
+// UniversalPrintArray(begin, len, os) prints an array of 'len'
+// elements, starting at address 'begin'.
+template <typename T>
+void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
+  if (len == 0) {
+    *os << "{}";
+  } else {
+    *os << "{ ";
+    const size_t kThreshold = 18;
+    const size_t kChunkSize = 8;
+    // If the array has more than kThreshold elements, we'll have to
+    // omit some details by printing only the first and the last
+    // kChunkSize elements.
+    // TODO(wan@google.com): let the user control the threshold using a flag.
+    if (len <= kThreshold) {
+      PrintRawArrayTo(begin, len, os);
+    } else {
+      PrintRawArrayTo(begin, kChunkSize, os);
+      *os << ", ..., ";
+      PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
+    }
+    *os << " }";
+  }
+}
+// This overload prints a (const) char array compactly.
+GTEST_API_ void UniversalPrintArray(
+    const char* 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);
+
+// Implements printing an array type T[N].
+template <typename T, size_t N>
+class UniversalPrinter<T[N]> {
+ public:
+  // Prints the given array, omitting some elements when there are too
+  // many.
+  static void Print(const T (&a)[N], ::std::ostream* os) {
+    UniversalPrintArray(a, N, os);
+  }
+};
+
+// Implements printing a reference type T&.
+template <typename T>
+class UniversalPrinter<T&> {
+ public:
+  // MSVC warns about adding const to a function type, so we want to
+  // disable the warning.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
+
+  static void Print(const T& value, ::std::ostream* os) {
+    // Prints the address of the value.  We use reinterpret_cast here
+    // as static_cast doesn't compile when T is a function type.
+    *os << "@" << reinterpret_cast<const void*>(&value) << " ";
+
+    // Then prints the value itself.
+    UniversalPrint(value, os);
+  }
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+};
+
+// Prints a value tersely: for a reference type, the referenced value
+// (but not the address) is printed; for a (const) char pointer, the
+// NUL-terminated string (but not the pointer) is printed.
+
+template <typename T>
+class UniversalTersePrinter {
+ public:
+  static void Print(const T& value, ::std::ostream* os) {
+    UniversalPrint(value, os);
+  }
+};
+template <typename T>
+class UniversalTersePrinter<T&> {
+ public:
+  static void Print(const T& value, ::std::ostream* os) {
+    UniversalPrint(value, os);
+  }
+};
+template <typename T, size_t N>
+class UniversalTersePrinter<T[N]> {
+ public:
+  static void Print(const T (&value)[N], ::std::ostream* os) {
+    UniversalPrinter<T[N]>::Print(value, os);
+  }
+};
+template <>
+class UniversalTersePrinter<const char*> {
+ public:
+  static void Print(const char* str, ::std::ostream* os) {
+    if (str == NULL) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char*> {
+ public:
+  static void Print(char* str, ::std::ostream* os) {
+    UniversalTersePrinter<const char*>::Print(str, os);
+  }
+};
+
+#if GTEST_HAS_STD_WSTRING
+template <>
+class UniversalTersePrinter<const wchar_t*> {
+ public:
+  static void Print(const wchar_t* str, ::std::ostream* os) {
+    if (str == NULL) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::wstring(str), os);
+    }
+  }
+};
+#endif
+
+template <>
+class UniversalTersePrinter<wchar_t*> {
+ public:
+  static void Print(wchar_t* str, ::std::ostream* os) {
+    UniversalTersePrinter<const wchar_t*>::Print(str, os);
+  }
+};
+
+template <typename T>
+void UniversalTersePrint(const T& value, ::std::ostream* os) {
+  UniversalTersePrinter<T>::Print(value, os);
+}
+
+// Prints a value using the type inferred by the compiler.  The
+// difference between this and UniversalTersePrint() is that for a
+// (const) char pointer, this prints both the pointer and the
+// NUL-terminated string.
+template <typename T>
+void UniversalPrint(const T& value, ::std::ostream* os) {
+  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
+  // UniversalPrinter with T directly.
+  typedef T T1;
+  UniversalPrinter<T1>::Print(value, os);
+}
+
+typedef ::std::vector<string> Strings;
+
+// TuplePolicy<TupleT> must provide:
+// - tuple_size
+//     size of tuple TupleT.
+// - get<size_t I>(const TupleT& t)
+//     static function extracting element I of tuple TupleT.
+// - tuple_element<size_t I>::type
+//     type of element I of tuple TupleT.
+template <typename TupleT>
+struct TuplePolicy;
+
+#if GTEST_HAS_TR1_TUPLE
+template <typename TupleT>
+struct TuplePolicy {
+  typedef TupleT Tuple;
+  static const size_t tuple_size = ::std::tr1::tuple_size<Tuple>::value;
+
+  template <size_t I>
+  struct tuple_element : ::std::tr1::tuple_element<I, Tuple> {};
+
+  template <size_t I>
+  static typename AddReference<
+      const typename ::std::tr1::tuple_element<I, Tuple>::type>::type get(
+      const Tuple& tuple) {
+    return ::std::tr1::get<I>(tuple);
+  }
+};
+template <typename TupleT>
+const size_t TuplePolicy<TupleT>::tuple_size;
+#endif  // GTEST_HAS_TR1_TUPLE
+
+#if GTEST_HAS_STD_TUPLE_
+template <typename... Types>
+struct TuplePolicy< ::std::tuple<Types...> > {
+  typedef ::std::tuple<Types...> Tuple;
+  static const size_t tuple_size = ::std::tuple_size<Tuple>::value;
+
+  template <size_t I>
+  struct tuple_element : ::std::tuple_element<I, Tuple> {};
+
+  template <size_t I>
+  static const typename ::std::tuple_element<I, Tuple>::type& get(
+      const Tuple& tuple) {
+    return ::std::get<I>(tuple);
+  }
+};
+template <typename... Types>
+const size_t TuplePolicy< ::std::tuple<Types...> >::tuple_size;
+#endif  // GTEST_HAS_STD_TUPLE_
+
+#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
+// This helper template allows PrintTo() for tuples and
+// UniversalTersePrintTupleFieldsToStrings() to be defined by
+// induction on the number of tuple fields.  The idea is that
+// TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N
+// fields in tuple t, and can be defined in terms of
+// TuplePrefixPrinter<N - 1>.
+//
+// The inductive case.
+template <size_t N>
+struct TuplePrefixPrinter {
+  // Prints the first N fields of a tuple.
+  template <typename Tuple>
+  static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
+    TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
+    GTEST_INTENTIONAL_CONST_COND_PUSH_()
+    if (N > 1) {
+    GTEST_INTENTIONAL_CONST_COND_POP_()
+      *os << ", ";
+    }
+    UniversalPrinter<
+        typename TuplePolicy<Tuple>::template tuple_element<N - 1>::type>
+        ::Print(TuplePolicy<Tuple>::template get<N - 1>(t), os);
+  }
+
+  // Tersely prints the first N fields of a tuple to a string vector,
+  // one element for each field.
+  template <typename Tuple>
+  static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
+    TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings);
+    ::std::stringstream ss;
+    UniversalTersePrint(TuplePolicy<Tuple>::template get<N - 1>(t), &ss);
+    strings->push_back(ss.str());
+  }
+};
+
+// Base case.
+template <>
+struct TuplePrefixPrinter<0> {
+  template <typename Tuple>
+  static void PrintPrefixTo(const Tuple&, ::std::ostream*) {}
+
+  template <typename Tuple>
+  static void TersePrintPrefixToStrings(const Tuple&, Strings*) {}
+};
+
+// Helper function for printing a tuple.
+// Tuple must be either std::tr1::tuple or std::tuple type.
+template <typename Tuple>
+void PrintTupleTo(const Tuple& t, ::std::ostream* os) {
+  *os << "(";
+  TuplePrefixPrinter<TuplePolicy<Tuple>::tuple_size>::PrintPrefixTo(t, os);
+  *os << ")";
+}
+
+// Prints the fields of a tuple tersely to a string vector, one
+// element for each field.  See the comment before
+// UniversalTersePrint() for how we define "tersely".
+template <typename Tuple>
+Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
+  Strings result;
+  TuplePrefixPrinter<TuplePolicy<Tuple>::tuple_size>::
+      TersePrintPrefixToStrings(value, &result);
+  return result;
+}
+#endif  // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
+
+}  // namespace internal
+
+template <typename T>
+::std::string PrintToString(const T& value) {
+  ::std::stringstream ss;
+  internal::UniversalTersePrinter<T>::Print(value, &ss);
+  return ss.str();
+}
+
+}  // namespace testing
+
+// Include any custom printer 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 "gtest/internal/custom/gtest-printers.h"
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-spi.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-spi.h
new file mode 100644
index 00000000..f63fa9a1
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-spi.h
@@ -0,0 +1,232 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Utilities for testing Google Test itself and code that uses Google Test
+// (e.g. frameworks built on top of Google Test).
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_
+#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_
+
+#include "gtest/gtest.h"
+
+namespace testing {
+
+// This helper class can be used to mock out Google Test failure reporting
+// so that we can test Google Test or code that builds on Google Test.
+//
+// An object of this class appends a TestPartResult object to the
+// TestPartResultArray object given in the constructor whenever a Google Test
+// failure is reported. It can either intercept only failures that are
+// generated in the same thread that created this object or it can intercept
+// all generated failures. The scope of this mock object can be controlled with
+// the second argument to the two arguments constructor.
+class GTEST_API_ ScopedFakeTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  // The two possible mocking modes of this object.
+  enum InterceptMode {
+    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
+    INTERCEPT_ALL_THREADS           // Intercepts all failures.
+  };
+
+  // The c'tor sets this object as the test part result reporter used
+  // by Google Test.  The 'result' parameter specifies where to report the
+  // results. This reporter will only catch failures generated in the current
+  // thread. DEPRECATED
+  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
+
+  // Same as above, but you can choose the interception scope of this object.
+  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
+                                   TestPartResultArray* result);
+
+  // The d'tor restores the previous test part result reporter.
+  virtual ~ScopedFakeTestPartResultReporter();
+
+  // Appends the TestPartResult object to the TestPartResultArray
+  // received in the constructor.
+  //
+  // This method is from the TestPartResultReporterInterface
+  // interface.
+  virtual void ReportTestPartResult(const TestPartResult& result);
+ private:
+  void Init();
+
+  const InterceptMode intercept_mode_;
+  TestPartResultReporterInterface* old_reporter_;
+  TestPartResultArray* const result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
+};
+
+namespace internal {
+
+// A helper class for implementing EXPECT_FATAL_FAILURE() and
+// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+class GTEST_API_ SingleFailureChecker {
+ public:
+  // The constructor remembers the arguments.
+  SingleFailureChecker(const TestPartResultArray* results,
+                       TestPartResult::Type type,
+                       const string& substr);
+  ~SingleFailureChecker();
+ private:
+  const TestPartResultArray* const results_;
+  const TestPartResult::Type type_;
+  const string substr_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+// 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'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - 'statement' cannot reference local non-static variables or
+//     non-static members of the current object.
+//   - 'statement' cannot return a value.
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
+// gtest_unittest.cc will fail to compile if we do that.
+#define EXPECT_FATAL_FAILURE(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ALL_THREADS, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+// A macro for testing Google Test assertions or code that's expected to
+// generate Google Test non-fatal failures.  It asserts that the given
+// statement will cause exactly one non-fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// 'statement' is allowed to reference local variables and members of
+// the current object.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  If we do that, the code won't compile when the user gives
+// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
+// expands to code containing an unprotected comma.  The
+// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
+// catches that.
+//
+// For the same reason, we have to write
+//   if (::testing::internal::AlwaysTrue()) { statement; }
+// instead of
+//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+// to avoid an MSVC warning on unreachable code.
+#define EXPECT_NONFATAL_FAILURE(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
+          &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_SPI_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-test-part.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-test-part.h
new file mode 100644
index 00000000..77eb8448
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-test-part.h
@@ -0,0 +1,179 @@
+// 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.
+//
+// Author: mheule@google.com (Markus Heule)
+//
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+
+#include <iosfwd>
+#include <vector>
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-string.h"
+
+namespace testing {
+
+// A copyable object representing the result of a test part (i.e. an
+// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
+//
+// Don't inherit from TestPartResult as its destructor is not virtual.
+class GTEST_API_ TestPartResult {
+ public:
+  // The possible outcomes of a test part (i.e. an assertion or an
+  // explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
+  enum Type {
+    kSuccess,          // Succeeded.
+    kNonFatalFailure,  // Failed but the test can continue.
+    kFatalFailure      // Failed and the test should be terminated.
+  };
+
+  // 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,
+                 const char* a_message)
+      : type_(a_type),
+        file_name_(a_file_name == NULL ? "" : a_file_name),
+        line_number_(a_line_number),
+        summary_(ExtractSummary(a_message)),
+        message_(a_message) {
+  }
+
+  // Gets the outcome of the test part.
+  Type type() const { return type_; }
+
+  // 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() ? NULL : file_name_.c_str();
+  }
+
+  // Gets the line in the source file where the test part took place,
+  // or -1 if it's unknown.
+  int line_number() const { return line_number_; }
+
+  // Gets the summary of the failure message.
+  const char* summary() const { return summary_.c_str(); }
+
+  // Gets the message associated with the test part.
+  const char* message() const { return message_.c_str(); }
+
+  // Returns true iff the test part passed.
+  bool passed() const { return type_ == kSuccess; }
+
+  // Returns true iff the test part failed.
+  bool failed() const { return type_ != kSuccess; }
+
+  // Returns true iff the test part non-fatally failed.
+  bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
+
+  // Returns true iff the test part fatally failed.
+  bool fatally_failed() const { return type_ == kFatalFailure; }
+
+ private:
+  Type type_;
+
+  // Gets the summary of the failure message by omitting the stack
+  // trace in it.
+  static std::string ExtractSummary(const char* message);
+
+  // The name of the source file where the test part took place, or
+  // "" if the source file is unknown.
+  std::string file_name_;
+  // The line in the source file where the test part took place, or -1
+  // if the line number is unknown.
+  int line_number_;
+  std::string summary_;  // The test failure summary.
+  std::string message_;  // The test failure message.
+};
+
+// Prints a TestPartResult object.
+std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
+
+// An array of TestPartResult objects.
+//
+// Don't inherit from TestPartResultArray as its destructor is not
+// virtual.
+class GTEST_API_ TestPartResultArray {
+ public:
+  TestPartResultArray() {}
+
+  // Appends the given TestPartResult to the array.
+  void Append(const TestPartResult& result);
+
+  // Returns the TestPartResult at the given index (0-based).
+  const TestPartResult& GetTestPartResult(int index) const;
+
+  // Returns the number of TestPartResult objects in the array.
+  int size() const;
+
+ private:
+  std::vector<TestPartResult> array_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
+};
+
+// This interface knows how to report a test part result.
+class TestPartResultReporterInterface {
+ public:
+  virtual ~TestPartResultReporterInterface() {}
+
+  virtual void ReportTestPartResult(const TestPartResult& result) = 0;
+};
+
+namespace internal {
+
+// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
+// statement generates new fatal failures. To do so it registers itself as the
+// current test part result reporter. Besides checking if fatal failures were
+// reported, it only delegates the reporting to the former result reporter.
+// The original result reporter is restored in the destructor.
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+class GTEST_API_ HasNewFatalFailureHelper
+    : public TestPartResultReporterInterface {
+ public:
+  HasNewFatalFailureHelper();
+  virtual ~HasNewFatalFailureHelper();
+  virtual void ReportTestPartResult(const TestPartResult& result);
+  bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
+ private:
+  bool has_new_fatal_failure_;
+  TestPartResultReporterInterface* original_reporter_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-typed-test.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-typed-test.h
new file mode 100644
index 00000000..5f69d567
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-typed-test.h
@@ -0,0 +1,263 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+
+// This header implements typed tests and type-parameterized tests.
+
+// Typed (aka type-driven) tests repeat the same test for types in a
+// list.  You must know which types you want to test with when writing
+// typed tests. Here's how you do it:
+
+#if 0
+
+// First, define a fixture class template.  It should be parameterized
+// by a type.  Remember to derive it from testing::Test.
+template <typename T>
+class FooTest : public testing::Test {
+ public:
+  ...
+  typedef std::list<T> List;
+  static T shared_;
+  T value_;
+};
+
+// Next, associate a list of types with the test case, which will be
+// repeated for 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_CASE(FooTest, MyTypes);
+
+// If the type list contains only one type, you can write that type
+// directly without Types<...>:
+//   TYPED_TEST_CASE(FooTest, int);
+
+// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
+// tests for this test case as you want.
+TYPED_TEST(FooTest, DoesBlah) {
+  // Inside a test, refer to TypeParam to get the type parameter.
+  // Since we are inside a derived class template, C++ requires use to
+  // visit the members of FooTest via 'this'.
+  TypeParam n = this->value_;
+
+  // To visit static members of the fixture, add the TestFixture::
+  // prefix.
+  n += TestFixture::shared_;
+
+  // To refer to typedefs in the fixture, add the "typename
+  // TestFixture::" prefix.
+  typename TestFixture::List values;
+  values.push_back(n);
+  ...
+}
+
+TYPED_TEST(FooTest, HasPropertyA) { ... }
+
+#endif  // 0
+
+// Type-parameterized tests are abstract test patterns parameterized
+// by a type.  Compared with typed tests, type-parameterized tests
+// allow you to define the test pattern without knowing what the type
+// parameters are.  The defined pattern can be instantiated with
+// different types any number of times, in any number of translation
+// units.
+//
+// If you are designing an interface or concept, you can define a
+// suite of type-parameterized tests to verify properties that any
+// valid implementation of the interface/concept should have.  Then,
+// each implementation can easily instantiate the test suite to verify
+// that it conforms to the requirements, without having to write
+// similar tests repeatedly.  Here's an example:
+
+#if 0
+
+// First, define a fixture class template.  It should be parameterized
+// by a type.  Remember to derive it from testing::Test.
+template <typename T>
+class FooTest : public testing::Test {
+  ...
+};
+
+// Next, declare that you will define a type-parameterized test case
+// (the _P suffix is for "parameterized" or "pattern", whichever you
+// prefer):
+TYPED_TEST_CASE_P(FooTest);
+
+// Then, use TYPED_TEST_P() to define as many type-parameterized tests
+// for this type-parameterized test case as you want.
+TYPED_TEST_P(FooTest, DoesBlah) {
+  // Inside a test, refer to TypeParam to get the type parameter.
+  TypeParam n = 0;
+  ...
+}
+
+TYPED_TEST_P(FooTest, HasPropertyA) { ... }
+
+// Now the tricky part: you need to register all test patterns before
+// you can instantiate them.  The first argument of the macro is the
+// test case name; the rest are the names of the tests in this test
+// case.
+REGISTER_TYPED_TEST_CASE_P(FooTest,
+                           DoesBlah, HasPropertyA);
+
+// Finally, you are free to instantiate the pattern with the types you
+// want.  If you put the above code in a header file, you can #include
+// it in multiple C++ source files and instantiate it multiple times.
+//
+// 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 case name.  Remember to pick unique prefixes for
+// different instances.
+typedef testing::Types<char, int, unsigned int> MyTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
+
+// If the type list contains only one type, you can write that type
+// directly without Types<...>:
+//   INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
+
+#endif  // 0
+
+#include "gtest/internal/gtest-port.h"
+#include "gtest/internal/gtest-type-util.h"
+
+// Implements typed tests.
+
+#if GTEST_HAS_TYPED_TEST
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the name of the typedef for the type parameters of the
+// given test case.
+# define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_
+
+// The 'Types' template argument below must have spaces around it
+// since some compilers may choke on '>>' when passing a template
+// instance (e.g. Types<int>)
+# define TYPED_TEST_CASE(CaseName, Types) \
+  typedef ::testing::internal::TypeList< Types >::type \
+      GTEST_TYPE_PARAMS_(CaseName)
+
+# define TYPED_TEST(CaseName, TestName) \
+  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; \
+    virtual void TestBody(); \
+  }; \
+  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__), \
+              #CaseName, #TestName, 0); \
+  template <typename gtest_TypeParam_> \
+  void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody()
+
+#endif  // GTEST_HAS_TYPED_TEST
+
+// Implements type-parameterized tests.
+
+#if GTEST_HAS_TYPED_TEST_P
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the namespace name that the type-parameterized tests for
+// the given type-parameterized test case are defined in.  The exact
+// name of the namespace is subject to change without notice.
+# define GTEST_CASE_NAMESPACE_(TestCaseName) \
+  gtest_case_##TestCaseName##_
+
+// 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 case.
+# define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \
+  gtest_typed_test_case_p_state_##TestCaseName##_
+
+// 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 case.
+# define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \
+  gtest_registered_test_names_##TestCaseName##_
+
+// 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_CASE_P(CaseName) \
+  static ::testing::internal::TypedTestCasePState \
+      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName)
+
+# define TYPED_TEST_P(CaseName, TestName) \
+  namespace GTEST_CASE_NAMESPACE_(CaseName) { \
+  template <typename gtest_TypeParam_> \
+  class TestName : public CaseName<gtest_TypeParam_> { \
+   private: \
+    typedef CaseName<gtest_TypeParam_> TestFixture; \
+    typedef gtest_TypeParam_ TypeParam; \
+    virtual void TestBody(); \
+  }; \
+  static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
+      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\
+          __FILE__, __LINE__, #CaseName, #TestName); \
+  } \
+  template <typename gtest_TypeParam_> \
+  void GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody()
+
+# define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \
+  namespace GTEST_CASE_NAMESPACE_(CaseName) { \
+  typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \
+  } \
+  static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \
+      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\
+          __FILE__, __LINE__, #__VA_ARGS__)
+
+// The 'Types' template argument below must have spaces around it
+// since some compilers may choke on '>>' when passing a template
+// instance (e.g. Types<int>)
+# define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \
+  bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \
+      ::testing::internal::TypeParameterizedTestCase<CaseName, \
+          GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \
+          ::testing::internal::TypeList< Types >::type>::Register(\
+              #Prefix, \
+              ::testing::internal::CodeLocation(__FILE__, __LINE__), \
+              &GTEST_TYPED_TEST_CASE_P_STATE_(CaseName), \
+              #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName))
+
+#endif  // GTEST_HAS_TYPED_TEST_P
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest.h
new file mode 100644
index 00000000..f846c5bd
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest.h
@@ -0,0 +1,2236 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file defines the public API for Google Test.  It should be
+// included by any test program that uses Google Test.
+//
+// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
+// leave some internal implementation details in this header file.
+// They are clearly marked by comments like this:
+//
+//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+//
+// Such code is NOT meant to be used by a user directly, and is subject
+// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
+// program!
+//
+// Acknowledgment: Google Test borrowed the idea of automatic test
+// registration from Barthelemy Dagenais' (barthelemy@prologique.com)
+// easyUnit framework.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
+#define GTEST_INCLUDE_GTEST_GTEST_H_
+
+#include <limits>
+#include <ostream>
+#include <vector>
+
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-string.h"
+#include "gtest/gtest-death-test.h"
+#include "gtest/gtest-message.h"
+#include "gtest/gtest-param-test.h"
+#include "gtest/gtest-printers.h"
+#include "gtest/gtest_prod.h"
+#include "gtest/gtest-test-part.h"
+#include "gtest/gtest-typed-test.h"
+
+// Depending on the platform, different string classes are available.
+// On Linux, in addition to ::std::string, Google also makes use of
+// class ::string, which has the same interface as ::std::string, but
+// has a different implementation.
+//
+// You can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that
+// ::string is available AND is a distinct type to ::std::string, or
+// define it to 0 to indicate otherwise.
+//
+// If ::std::string and ::string are the same class on your platform
+// due to aliasing, you should define GTEST_HAS_GLOBAL_STRING to 0.
+//
+// If you do not define GTEST_HAS_GLOBAL_STRING, it is defined
+// heuristically.
+
+namespace testing {
+
+// Declares the flags.
+
+// This flag temporary enables the disabled tests.
+GTEST_DECLARE_bool_(also_run_disabled_tests);
+
+// This flag brings the debugger on an assertion failure.
+GTEST_DECLARE_bool_(break_on_failure);
+
+// This flag controls whether Google Test catches all test-thrown exceptions
+// and logs them as failures.
+GTEST_DECLARE_bool_(catch_exceptions);
+
+// This flag enables using colors in terminal output. Available values are
+// "yes" to enable colors, "no" (disable colors), or "auto" (the default)
+// to let Google Test decide.
+GTEST_DECLARE_string_(color);
+
+// This flag sets up the filter to select by name using a glob pattern
+// the tests to run. If the filter is not given all tests are executed.
+GTEST_DECLARE_string_(filter);
+
+// This flag causes the Google Test to list tests. None of the tests listed
+// are actually run if the flag is provided.
+GTEST_DECLARE_bool_(list_tests);
+
+// This flag controls whether Google Test emits a detailed XML report to a file
+// in addition to its normal textual output.
+GTEST_DECLARE_string_(output);
+
+// This flags control whether Google Test prints the elapsed time for each
+// test.
+GTEST_DECLARE_bool_(print_time);
+
+// This flag specifies the random number seed.
+GTEST_DECLARE_int32_(random_seed);
+
+// This flag sets how many times the tests are repeated. The default value
+// is 1. If the value is -1 the tests are repeating forever.
+GTEST_DECLARE_int32_(repeat);
+
+// This flag controls whether Google Test includes Google Test internal
+// stack frames in failure stack traces.
+GTEST_DECLARE_bool_(show_internal_stack_frames);
+
+// When this flag is specified, tests' order is randomized on every iteration.
+GTEST_DECLARE_bool_(shuffle);
+
+// This flag specifies the maximum number of stack frames to be
+// printed in a failure message.
+GTEST_DECLARE_int32_(stack_trace_depth);
+
+// When this flag is specified, a failed assertion will throw an
+// exception if exceptions are enabled, or exit the program with a
+// non-zero code otherwise.
+GTEST_DECLARE_bool_(throw_on_failure);
+
+// When this flag is set with a "host:port" string, on supported
+// platforms test results are streamed to the specified port on
+// the specified host machine.
+GTEST_DECLARE_string_(stream_result_to);
+
+// The upper limit for valid stack trace depths.
+const int kMaxStackTraceDepth = 100;
+
+namespace internal {
+
+class AssertHelper;
+class DefaultGlobalTestPartResultReporter;
+class ExecDeathTest;
+class NoExecDeathTest;
+class FinalSuccessChecker;
+class GTestFlagSaver;
+class StreamingListenerTest;
+class TestResultAccessor;
+class TestEventListenersAccessor;
+class TestEventRepeater;
+class UnitTestRecordPropertyTestHelper;
+class WindowsDeathTest;
+class UnitTestImpl* GetUnitTestImpl();
+void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
+                                    const std::string& message);
+
+}  // namespace internal
+
+// The friend relationship of some of these classes is cyclic.
+// If we don't forward declare them the compiler might confuse the classes
+// in friendship clauses with same named classes on the scope.
+class Test;
+class TestCase;
+class TestInfo;
+class UnitTest;
+
+// A class for indicating whether an assertion was successful.  When
+// the assertion wasn't successful, the AssertionResult object
+// remembers a non-empty message that describes how it failed.
+//
+// To create an instance of this class, use one of the factory functions
+// (AssertionSuccess() and AssertionFailure()).
+//
+// This class is useful for two purposes:
+//   1. Defining predicate functions to be used with Boolean test assertions
+//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
+//   2. Defining predicate-format functions to be
+//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
+//
+// For example, if you define IsEven predicate:
+//
+//   testing::AssertionResult IsEven(int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess();
+//     else
+//       return testing::AssertionFailure() << n << " is odd";
+//   }
+//
+// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
+// will print the message
+//
+//   Value of: IsEven(Fib(5))
+//     Actual: false (5 is odd)
+//   Expected: true
+//
+// instead of a more opaque
+//
+//   Value of: IsEven(Fib(5))
+//     Actual: false
+//   Expected: true
+//
+// in case IsEven is a simple Boolean predicate.
+//
+// If you expect your predicate to be reused and want to support informative
+// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
+// about half as often as positive ones in our tests), supply messages for
+// both success and failure cases:
+//
+//   testing::AssertionResult IsEven(int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess() << n << " is even";
+//     else
+//       return testing::AssertionFailure() << n << " is odd";
+//   }
+//
+// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
+//
+//   Value of: IsEven(Fib(6))
+//     Actual: true (8 is even)
+//   Expected: false
+//
+// NB: Predicates that support negative Boolean assertions have reduced
+// performance in positive ones so be careful not to use them in tests
+// that have lots (tens of thousands) of positive Boolean assertions.
+//
+// To use this class with EXPECT_PRED_FORMAT assertions such as:
+//
+//   // Verifies that Foo() returns an even number.
+//   EXPECT_PRED_FORMAT1(IsEven, Foo());
+//
+// you need to define:
+//
+//   testing::AssertionResult IsEven(const char* expr, int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess();
+//     else
+//       return testing::AssertionFailure()
+//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
+//   }
+//
+// If Foo() returns 5, you will see the following message:
+//
+//   Expected: Foo() is even
+//     Actual: it's 5
+//
+class GTEST_API_ AssertionResult {
+ public:
+  // Copy constructor.
+  // Used in EXPECT_TRUE/FALSE(assertion_result).
+  AssertionResult(const AssertionResult& other);
+
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
+
+  // Used in the EXPECT_TRUE/FALSE(bool_expression).
+  //
+  // T must be contextually convertible to bool.
+  //
+  // The second parameter prevents this overload from being considered if
+  // the argument is implicitly convertible to AssertionResult. In that case
+  // we want AssertionResult's copy constructor to be used.
+  template <typename T>
+  explicit AssertionResult(
+      const T& success,
+      typename internal::EnableIf<
+          !internal::ImplicitlyConvertible<T, AssertionResult>::value>::type*
+          /*enabler*/ = NULL)
+      : success_(success) {}
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+  // Assignment operator.
+  AssertionResult& operator=(AssertionResult other) {
+    swap(other);
+    return *this;
+  }
+
+  // Returns true iff the assertion succeeded.
+  operator bool() const { return success_; }  // NOLINT
+
+  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
+  AssertionResult operator!() const;
+
+  // Returns the text streamed into this AssertionResult. Test assertions
+  // use it when they fail (i.e., the predicate's outcome doesn't match the
+  // assertion's expectation). When nothing has been streamed into the
+  // object, returns an empty string.
+  const char* message() const {
+    return message_.get() != NULL ?  message_->c_str() : "";
+  }
+  // TODO(vladl@google.com): Remove this after making sure no clients use it.
+  // Deprecated; please use message() instead.
+  const char* failure_message() const { return message(); }
+
+  // Streams a custom failure message into this object.
+  template <typename T> AssertionResult& operator<<(const T& value) {
+    AppendMessage(Message() << value);
+    return *this;
+  }
+
+  // Allows streaming basic output manipulators such as endl or flush into
+  // this object.
+  AssertionResult& operator<<(
+      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
+    AppendMessage(Message() << basic_manipulator);
+    return *this;
+  }
+
+ private:
+  // Appends the contents of message to message_.
+  void AppendMessage(const Message& a_message) {
+    if (message_.get() == NULL)
+      message_.reset(new ::std::string);
+    message_->append(a_message.GetString().c_str());
+  }
+
+  // Swap the contents of this AssertionResult with other.
+  void swap(AssertionResult& other);
+
+  // Stores result of the assertion predicate.
+  bool success_;
+  // Stores the message describing the condition in case the expectation
+  // construct is not satisfied with the predicate's outcome.
+  // Referenced via a pointer to avoid taking too much stack frame space
+  // with test assertions.
+  internal::scoped_ptr< ::std::string> message_;
+};
+
+// Makes a successful assertion result.
+GTEST_API_ AssertionResult AssertionSuccess();
+
+// Makes a failed assertion result.
+GTEST_API_ AssertionResult AssertionFailure();
+
+// Makes a failed assertion result with the given failure message.
+// Deprecated; use AssertionFailure() << msg.
+GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
+
+// The abstract class that all tests inherit from.
+//
+// In Google Test, a unit test program contains one or many TestCases, and
+// each TestCase 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 a TEST_F.  For example:
+//
+//   class FooTest : public testing::Test {
+//    protected:
+//     void SetUp() override { ... }
+//     void TearDown() override { ... }
+//     ...
+//   };
+//
+//   TEST_F(FooTest, Bar) { ... }
+//   TEST_F(FooTest, Baz) { ... }
+//
+// Test is not copyable.
+class GTEST_API_ Test {
+ public:
+  friend class TestInfo;
+
+  // Defines types for pointers to functions that set up and tear down
+  // a test case.
+  typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc;
+  typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc;
+
+  // The d'tor is virtual as we intend to inherit from Test.
+  virtual ~Test();
+
+  // Sets up the stuff shared by all tests in this test case.
+  //
+  // Google Test will call Foo::SetUpTestCase() before running the first
+  // test in test case Foo.  Hence a sub-class can define its own
+  // SetUpTestCase() method to shadow the one defined in the super
+  // class.
+  static void SetUpTestCase() {}
+
+  // Tears down the stuff shared by all tests in this test case.
+  //
+  // Google Test will call Foo::TearDownTestCase() after running the last
+  // test in test case Foo.  Hence a sub-class can define its own
+  // TearDownTestCase() method to shadow the one defined in the super
+  // class.
+  static void TearDownTestCase() {}
+
+  // Returns true iff the current test has a fatal failure.
+  static bool HasFatalFailure();
+
+  // Returns true iff the current test has a non-fatal failure.
+  static bool HasNonfatalFailure();
+
+  // Returns true iff the current test has a (either fatal or
+  // non-fatal) failure.
+  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
+
+  // Logs a property for the current test, test case, or for the entire
+  // invocation of the test program when used outside of the context of a
+  // test case.  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
+  // SetUpTestCase or TearDownTestCase are logged as attributes of the
+  // corresponding <testsuite> element.  Calls to RecordProperty made in the
+  // global context (before or after invocation of RUN_ALL_TESTS and from
+  // SetUp/TearDown method of Environment objects registered with Google
+  // Test) will be output as attributes of the <testsuites> element.
+  static void RecordProperty(const std::string& key, const std::string& value);
+  static void RecordProperty(const std::string& key, int value);
+
+ protected:
+  // Creates a Test object.
+  Test();
+
+  // Sets up the test fixture.
+  virtual void SetUp();
+
+  // Tears down the test fixture.
+  virtual void TearDown();
+
+ private:
+  // Returns true iff the current test has the same fixture class as
+  // the first test in the current test case.
+  static bool HasSameFixtureClass();
+
+  // Runs the test after the test fixture has been set up.
+  //
+  // A sub-class must implement this to define the test logic.
+  //
+  // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
+  // Instead, use the TEST or TEST_F macro.
+  virtual void TestBody() = 0;
+
+  // Sets up, executes, and tears down the test.
+  void Run();
+
+  // Deletes self.  We deliberately pick an unusual name for this
+  // internal method to avoid clashing with names used in user TESTs.
+  void DeleteSelf_() { delete this; }
+
+  const internal::scoped_ptr< GTEST_FLAG_SAVER_ > gtest_flag_saver_;
+
+  // Often a user misspells SetUp() as Setup() and spends a long time
+  // wondering why it is never called by Google Test.  The declaration of
+  // the following method is solely for catching such an error at
+  // compile time:
+  //
+  //   - The return type is deliberately chosen to be not void, so it
+  //   will be a conflict if void Setup() is declared in the user's
+  //   test fixture.
+  //
+  //   - This method is private, so it will be another compiler error
+  //   if the method is called from the user's test fixture.
+  //
+  // DO NOT OVERRIDE THIS FUNCTION.
+  //
+  // If you see an error about overriding the following function or
+  // about it being private, you have mis-spelled SetUp() as Setup().
+  struct Setup_should_be_spelled_SetUp {};
+  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
+
+  // We disallow copying Tests.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
+};
+
+typedef internal::TimeInMillis TimeInMillis;
+
+// A copyable object representing a user specified test property which can be
+// output as a key/value string pair.
+//
+// Don't inherit from TestProperty as its destructor is not virtual.
+class TestProperty {
+ public:
+  // C'tor.  TestProperty does NOT have a default constructor.
+  // Always use this constructor (with parameters) to create a
+  // TestProperty object.
+  TestProperty(const std::string& a_key, const std::string& a_value) :
+    key_(a_key), value_(a_value) {
+  }
+
+  // Gets the user supplied key.
+  const char* key() const {
+    return key_.c_str();
+  }
+
+  // Gets the user supplied value.
+  const char* value() const {
+    return value_.c_str();
+  }
+
+  // Sets a new value, overriding the one supplied in the constructor.
+  void SetValue(const std::string& new_value) {
+    value_ = new_value;
+  }
+
+ private:
+  // The key supplied by the user.
+  std::string key_;
+  // The value supplied by the user.
+  std::string value_;
+};
+
+// The result of a single Test.  This includes a list of
+// TestPartResults, a list of TestProperties, a count of how many
+// death tests there are in the Test, and how much time it took to run
+// the Test.
+//
+// TestResult is not copyable.
+class GTEST_API_ TestResult {
+ public:
+  // Creates an empty TestResult.
+  TestResult();
+
+  // D'tor.  Do not inherit from TestResult.
+  ~TestResult();
+
+  // Gets the number of all test parts.  This is the sum of the number
+  // of successful test parts and the number of failed test parts.
+  int total_part_count() const;
+
+  // Returns the number of the test properties.
+  int test_property_count() const;
+
+  // Returns true iff the test passed (i.e. no test part failed).
+  bool Passed() const { return !Failed(); }
+
+  // Returns true iff the test failed.
+  bool Failed() const;
+
+  // Returns true iff the test fatally failed.
+  bool HasFatalFailure() const;
+
+  // Returns true iff the test has a non-fatal failure.
+  bool HasNonfatalFailure() const;
+
+  // Returns the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Returns the i-th test part result among all the results. i can range
+  // from 0 to test_property_count() - 1. If i is not in that range, aborts
+  // the program.
+  const TestPartResult& GetTestPartResult(int i) const;
+
+  // Returns the i-th test property. i can range from 0 to
+  // test_property_count() - 1. If i is not in that range, aborts the
+  // program.
+  const TestProperty& GetTestProperty(int i) const;
+
+ private:
+  friend class TestInfo;
+  friend class TestCase;
+  friend class UnitTest;
+  friend class internal::DefaultGlobalTestPartResultReporter;
+  friend class internal::ExecDeathTest;
+  friend class internal::TestResultAccessor;
+  friend class internal::UnitTestImpl;
+  friend class internal::WindowsDeathTest;
+
+  // Gets the vector of TestPartResults.
+  const std::vector<TestPartResult>& test_part_results() const {
+    return test_part_results_;
+  }
+
+  // Gets the vector of TestProperties.
+  const std::vector<TestProperty>& test_properties() const {
+    return test_properties_;
+  }
+
+  // Sets the elapsed time.
+  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
+
+  // Adds a test property to the list. The property is validated and may add
+  // a non-fatal failure if invalid (e.g., if it conflicts with reserved
+  // key names). If a property is already recorded for the same key, the
+  // value will be updated, rather than storing multiple values for the same
+  // key.  xml_element specifies the element for which the property is being
+  // recorded and is used for validation.
+  void RecordProperty(const std::string& xml_element,
+                      const TestProperty& test_property);
+
+  // Adds a failure if the key is a reserved attribute of Google Test
+  // testcase tags.  Returns true if the property is valid.
+  // TODO(russr): Validate attribute names are legal and human readable.
+  static bool ValidateTestProperty(const std::string& xml_element,
+                                   const TestProperty& test_property);
+
+  // Adds a test part result to the list.
+  void AddTestPartResult(const TestPartResult& test_part_result);
+
+  // Returns the death test count.
+  int death_test_count() const { return death_test_count_; }
+
+  // Increments the death test count, returning the new count.
+  int increment_death_test_count() { return ++death_test_count_; }
+
+  // Clears the test part results.
+  void ClearTestPartResults();
+
+  // Clears the object.
+  void Clear();
+
+  // Protects mutable state of the property vector and of owned
+  // properties, whose values may be updated.
+  internal::Mutex test_properites_mutex_;
+
+  // The vector of TestPartResults
+  std::vector<TestPartResult> test_part_results_;
+  // The vector of TestProperties
+  std::vector<TestProperty> test_properties_;
+  // Running count of death tests.
+  int death_test_count_;
+  // The elapsed time, in milliseconds.
+  TimeInMillis elapsed_time_;
+
+  // We disallow copying TestResult.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
+};  // class TestResult
+
+// A TestInfo object stores the following information about a test:
+//
+//   Test case name
+//   Test name
+//   Whether the test should be run
+//   A function pointer that creates the test object when invoked
+//   Test result
+//
+// The constructor of TestInfo registers itself with the UnitTest
+// singleton such that the RUN_ALL_TESTS() macro knows which tests to
+// run.
+class GTEST_API_ TestInfo {
+ public:
+  // Destructs a TestInfo object.  This function is not virtual, so
+  // don't inherit from TestInfo.
+  ~TestInfo();
+
+  // Returns the test case name.
+  const char* test_case_name() const { return test_case_name_.c_str(); }
+
+  // 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() != NULL)
+      return type_param_->c_str();
+    return NULL;
+  }
+
+  // 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() != NULL)
+      return value_param_->c_str();
+    return NULL;
+  }
+
+  // Returns the file name where this test is defined.
+  const char* file() const { return location_.file.c_str(); }
+
+  // Returns the line where this test is defined.
+  int line() const { return location_.line; }
+
+  // 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 case Foo is defined as
+  // "Foo.Bar".  Only the tests that match the filter will run.
+  //
+  // A filter is a colon-separated list of glob (not regex) patterns,
+  // optionally followed by a '-' and a colon-separated list of
+  // negative patterns (tests to exclude).  A test is run if it
+  // matches one of the positive patterns and does not match any of
+  // the negative patterns.
+  //
+  // For example, *A*:Foo.* is a filter that matches any string that
+  // contains the character 'A' or starts with "Foo.".
+  bool should_run() const { return should_run_; }
+
+  // Returns true iff this test will appear in the XML report.
+  bool is_reportable() const {
+    // For now, the XML report includes all tests matching the filter.
+    // In the future, we may trim tests that are excluded because of
+    // sharding.
+    return matches_filter_;
+  }
+
+  // Returns the result of the test.
+  const TestResult* result() const { return &result_; }
+
+ private:
+#if GTEST_HAS_DEATH_TEST
+  friend class internal::DefaultDeathTestFactory;
+#endif  // GTEST_HAS_DEATH_TEST
+  friend class Test;
+  friend class TestCase;
+  friend class internal::UnitTestImpl;
+  friend class internal::StreamingListenerTest;
+  friend TestInfo* internal::MakeAndRegisterTestInfo(
+      const char* test_case_name,
+      const char* name,
+      const char* type_param,
+      const char* value_param,
+      internal::CodeLocation code_location,
+      internal::TypeId fixture_class_id,
+      Test::SetUpTestCaseFunc set_up_tc,
+      Test::TearDownTestCaseFunc 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_case_name,
+           const std::string& name,
+           const char* a_type_param,   // NULL if not a type-parameterized test
+           const char* a_value_param,  // NULL if not a value-parameterized test
+           internal::CodeLocation a_code_location,
+           internal::TypeId fixture_class_id,
+           internal::TestFactoryBase* factory);
+
+  // Increments the number of death tests encountered in this test so
+  // far.
+  int increment_death_test_count() {
+    return result_.increment_death_test_count();
+  }
+
+  // Creates the test object, runs it, records its result, and then
+  // deletes it.
+  void Run();
+
+  static void ClearTestResult(TestInfo* test_info) {
+    test_info->result_.Clear();
+  }
+
+  // These fields are immutable properties of the test.
+  const std::string test_case_name_;     // Test case 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 internal::scoped_ptr<const ::std::string> type_param_;
+  // Text representation of the value parameter, or NULL if this is not a
+  // value-parameterized test.
+  const internal::scoped_ptr<const ::std::string> value_param_;
+  internal::CodeLocation location_;
+  const internal::TypeId fixture_class_id_;   // ID of the test fixture class
+  bool should_run_;                 // True iff this test should run
+  bool is_disabled_;                // True iff this test is disabled
+  bool matches_filter_;             // True if this test matches the
+                                    // user-specified filter.
+  internal::TestFactoryBase* const factory_;  // The factory that creates
+                                              // the test object
+
+  // This field is mutable and needs to be reset before running the
+  // test for the second time.
+  TestResult result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
+};
+
+// A test case, which consists of a vector of TestInfos.
+//
+// TestCase is not copyable.
+class GTEST_API_ TestCase {
+ public:
+  // Creates a TestCase with the given name.
+  //
+  // TestCase does NOT have a default constructor.  Always use this
+  // constructor to create a TestCase object.
+  //
+  // Arguments:
+  //
+  //   name:         name of the test case
+  //   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 case
+  //   tear_down_tc: pointer to the function that tears down the test case
+  TestCase(const char* name, const char* a_type_param,
+           Test::SetUpTestCaseFunc set_up_tc,
+           Test::TearDownTestCaseFunc tear_down_tc);
+
+  // Destructor of TestCase.
+  virtual ~TestCase();
+
+  // Gets the name of the TestCase.
+  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 case.
+  const char* type_param() const {
+    if (type_param_.get() != NULL)
+      return type_param_->c_str();
+    return NULL;
+  }
+
+  // Returns true if any test in this test case should run.
+  bool should_run() const { return should_run_; }
+
+  // Gets the number of successful tests in this test case.
+  int successful_test_count() const;
+
+  // Gets the number of failed tests in this test case.
+  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 case.
+  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 case that should run.
+  int test_to_run_count() const;
+
+  // Gets the number of all tests in this test case.
+  int total_test_count() const;
+
+  // Returns true iff the test case passed.
+  bool Passed() const { return !Failed(); }
+
+  // Returns true iff the test case failed.
+  bool Failed() const { return failed_test_count() > 0; }
+
+  // Returns the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Returns the i-th test among all the tests. i can range from 0 to
+  // total_test_count() - 1. If i is not in that range, returns NULL.
+  const TestInfo* GetTestInfo(int i) const;
+
+  // Returns the TestResult that holds test properties recorded during
+  // execution of SetUpTestCase and TearDownTestCase.
+  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 TestCase.
+  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
+
+  // Gets the (immutable) vector of TestInfos in this TestCase.
+  const std::vector<TestInfo*>& test_info_list() const {
+    return test_info_list_;
+  }
+
+  // Returns the i-th test among all the tests. i can range from 0 to
+  // total_test_count() - 1. If i is not in that range, returns NULL.
+  TestInfo* GetMutableTestInfo(int i);
+
+  // Sets the should_run member.
+  void set_should_run(bool should) { should_run_ = should; }
+
+  // Adds a TestInfo to this test case.  Will delete the TestInfo upon
+  // destruction of the TestCase object.
+  void AddTestInfo(TestInfo * test_info);
+
+  // Clears the results of all tests in this test case.
+  void ClearResult();
+
+  // Clears the results of all tests in the given test case.
+  static void ClearTestCaseResult(TestCase* test_case) {
+    test_case->ClearResult();
+  }
+
+  // Runs every test in this TestCase.
+  void Run();
+
+  // Runs SetUpTestCase() for this TestCase.  This wrapper is needed
+  // for catching exceptions thrown from SetUpTestCase().
+  void RunSetUpTestCase() { (*set_up_tc_)(); }
+
+  // Runs TearDownTestCase() for this TestCase.  This wrapper is
+  // needed for catching exceptions thrown from TearDownTestCase().
+  void RunTearDownTestCase() { (*tear_down_tc_)(); }
+
+  // Returns true iff test passed.
+  static bool TestPassed(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Passed();
+  }
+
+  // Returns true iff test failed.
+  static bool TestFailed(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Failed();
+  }
+
+  // Returns true iff the test is disabled and will be reported in the XML
+  // report.
+  static bool TestReportableDisabled(const TestInfo* test_info) {
+    return test_info->is_reportable() && test_info->is_disabled_;
+  }
+
+  // Returns true iff test is disabled.
+  static bool TestDisabled(const TestInfo* test_info) {
+    return test_info->is_disabled_;
+  }
+
+  // Returns true iff this test will appear in the XML report.
+  static bool TestReportable(const TestInfo* test_info) {
+    return test_info->is_reportable();
+  }
+
+  // Returns true if the given test should run.
+  static bool ShouldRunTest(const TestInfo* test_info) {
+    return test_info->should_run();
+  }
+
+  // Shuffles the tests in this test case.
+  void ShuffleTests(internal::Random* random);
+
+  // Restores the test order to before the first shuffle.
+  void UnshuffleTests();
+
+  // Name of the test case.
+  std::string name_;
+  // Name of the parameter type, or NULL if this is not a typed or a
+  // type-parameterized test.
+  const internal::scoped_ptr<const ::std::string> type_param_;
+  // The vector of TestInfos in their original order.  It owns the
+  // elements in the vector.
+  std::vector<TestInfo*> test_info_list_;
+  // Provides a level of indirection for the test list to allow easy
+  // shuffling and restoring the test order.  The i-th element in this
+  // vector is the index of the i-th test in the shuffled test list.
+  std::vector<int> test_indices_;
+  // Pointer to the function that sets up the test case.
+  Test::SetUpTestCaseFunc set_up_tc_;
+  // Pointer to the function that tears down the test case.
+  Test::TearDownTestCaseFunc tear_down_tc_;
+  // True iff any test in this test case should run.
+  bool should_run_;
+  // Elapsed time, in milliseconds.
+  TimeInMillis elapsed_time_;
+  // Holds test properties recorded during execution of SetUpTestCase and
+  // TearDownTestCase.
+  TestResult ad_hoc_test_result_;
+
+  // We disallow copying TestCases.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase);
+};
+
+// An Environment object is capable of setting up and tearing down an
+// environment.  You should subclass this to define your own
+// environment(s).
+//
+// An Environment object does the set-up and tear-down in virtual
+// methods SetUp() and TearDown() instead of the constructor and the
+// destructor, as:
+//
+//   1. You cannot safely throw from a destructor.  This is a problem
+//      as in some cases Google Test is used where exceptions are enabled, and
+//      we may want to implement ASSERT_* using exceptions where they are
+//      available.
+//   2. You cannot use ASSERT_* directly in a constructor or
+//      destructor.
+class Environment {
+ public:
+  // The d'tor is virtual as we need to subclass Environment.
+  virtual ~Environment() {}
+
+  // Override this to define how to set up the environment.
+  virtual void SetUp() {}
+
+  // Override this to define how to tear down the environment.
+  virtual void TearDown() {}
+ private:
+  // If you see an error about overriding the following function or
+  // about it being private, you have mis-spelled SetUp() as Setup().
+  struct Setup_should_be_spelled_SetUp {};
+  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
+};
+
+// The interface for tracing execution of tests. The methods are organized in
+// the order the corresponding events are fired.
+class TestEventListener {
+ public:
+  virtual ~TestEventListener() {}
+
+  // Fired before any test activity starts.
+  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
+
+  // Fired before each iteration of tests starts.  There may be more than
+  // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
+  // index, starting from 0.
+  virtual void OnTestIterationStart(const UnitTest& unit_test,
+                                    int iteration) = 0;
+
+  // Fired before environment set-up for each iteration of tests starts.
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
+
+  // Fired after environment set-up for each iteration of tests ends.
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
+
+  // Fired before the test case starts.
+  virtual void OnTestCaseStart(const TestCase& test_case) = 0;
+
+  // Fired before the test starts.
+  virtual void OnTestStart(const TestInfo& test_info) = 0;
+
+  // Fired after a failed assertion or a SUCCEED() invocation.
+  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 case ends.
+  virtual void OnTestCaseEnd(const TestCase& test_case) = 0;
+
+  // Fired before environment tear-down for each iteration of tests starts.
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
+
+  // Fired after environment tear-down for each iteration of tests ends.
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
+
+  // Fired after each iteration of tests finishes.
+  virtual void OnTestIterationEnd(const UnitTest& unit_test,
+                                  int iteration) = 0;
+
+  // Fired after all test activities have ended.
+  virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
+};
+
+// The convenience class for users who need to override just one or two
+// methods and are not concerned that a possible change to a signature of
+// the methods they override will not be caught during the build.  For
+// comments about each method please see the definition of TestEventListener
+// above.
+class EmptyTestEventListener : public TestEventListener {
+ public:
+  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
+  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
+                                    int /*iteration*/) {}
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {}
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
+  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
+  virtual void OnTestStart(const TestInfo& /*test_info*/) {}
+  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {}
+  virtual void OnTestEnd(const TestInfo& /*test_info*/) {}
+  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {}
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
+  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
+                                  int /*iteration*/) {}
+  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
+};
+
+// TestEventListeners lets users add listeners to track events in Google Test.
+class GTEST_API_ TestEventListeners {
+ public:
+  TestEventListeners();
+  ~TestEventListeners();
+
+  // Appends an event listener to the end of the list. Google Test assumes
+  // the ownership of the listener (i.e. it will delete the listener when
+  // the test program finishes).
+  void Append(TestEventListener* listener);
+
+  // Removes the given event listener from the list and returns it.  It then
+  // becomes the caller's responsibility to delete the listener. Returns
+  // NULL if the listener is not found in the list.
+  TestEventListener* Release(TestEventListener* listener);
+
+  // Returns the standard listener responsible for the default console
+  // output.  Can be removed from the listeners list to shut down default
+  // console output.  Note that removing this object from the listener list
+  // with Release transfers its ownership to the caller and makes this
+  // function return NULL the next time.
+  TestEventListener* default_result_printer() const {
+    return default_result_printer_;
+  }
+
+  // Returns the standard listener responsible for the default XML output
+  // controlled by the --gtest_output=xml flag.  Can be removed from the
+  // listeners list by users who want to shut down the default XML output
+  // controlled by this flag and substitute it with custom one.  Note that
+  // removing this object from the listener list with Release transfers its
+  // ownership to the caller and makes this function return NULL the next
+  // time.
+  TestEventListener* default_xml_generator() const {
+    return default_xml_generator_;
+  }
+
+ private:
+  friend class TestCase;
+  friend class TestInfo;
+  friend class internal::DefaultGlobalTestPartResultReporter;
+  friend class internal::NoExecDeathTest;
+  friend class internal::TestEventListenersAccessor;
+  friend class internal::UnitTestImpl;
+
+  // Returns repeater that broadcasts the TestEventListener events to all
+  // subscribers.
+  TestEventListener* repeater();
+
+  // Sets the default_result_printer attribute to the provided listener.
+  // The listener is also added to the listener list and previous
+  // default_result_printer is removed from it and deleted. The listener can
+  // also be NULL in which case it will not be added to the list. Does
+  // nothing if the previous and the current listener objects are the same.
+  void SetDefaultResultPrinter(TestEventListener* listener);
+
+  // Sets the default_xml_generator attribute to the provided listener.  The
+  // listener is also added to the listener list and previous
+  // default_xml_generator is removed from it and deleted. The listener can
+  // also be NULL in which case it will not be added to the list. Does
+  // nothing if the previous and the current listener objects are the same.
+  void SetDefaultXmlGenerator(TestEventListener* listener);
+
+  // Controls whether events will be forwarded by the repeater to the
+  // listeners in the list.
+  bool EventForwardingEnabled() const;
+  void SuppressEventForwarding();
+
+  // The actual list of listeners.
+  internal::TestEventRepeater* repeater_;
+  // Listener responsible for the standard result output.
+  TestEventListener* default_result_printer_;
+  // Listener responsible for the creation of the XML output file.
+  TestEventListener* default_xml_generator_;
+
+  // We disallow copying TestEventListeners.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
+};
+
+// A UnitTest consists of a vector of TestCases.
+//
+// This is a singleton class.  The only instance of UnitTest is
+// created when UnitTest::GetInstance() is first called.  This
+// instance is never deleted.
+//
+// UnitTest is not copyable.
+//
+// This class is thread-safe as long as the methods are called
+// according to their specification.
+class GTEST_API_ UnitTest {
+ public:
+  // Gets the singleton UnitTest object.  The first time this method
+  // is called, a UnitTest object is constructed and returned.
+  // Consecutive calls will return the same object.
+  static UnitTest* GetInstance();
+
+  // Runs all tests in this UnitTest object and prints the result.
+  // Returns 0 if successful, or 1 otherwise.
+  //
+  // This method can only be called from the main thread.
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  int Run() GTEST_MUST_USE_RESULT_;
+
+  // Returns the working directory when the first TEST() or TEST_F()
+  // was executed.  The UnitTest object owns the string.
+  const char* original_working_dir() const;
+
+  // Returns the TestCase object for the test that's currently running,
+  // or NULL if no test is running.
+  const TestCase* current_test_case() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Returns the TestInfo object for the test that's currently running,
+  // or NULL if no test is running.
+  const TestInfo* current_test_info() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Returns the random seed used at the start of the current test run.
+  int random_seed() const;
+
+#if GTEST_HAS_PARAM_TEST
+  // Returns the ParameterizedTestCaseRegistry object used to keep track of
+  // value-parameterized tests and instantiate and register them.
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  internal::ParameterizedTestCaseRegistry& parameterized_test_registry()
+      GTEST_LOCK_EXCLUDED_(mutex_);
+#endif  // GTEST_HAS_PARAM_TEST
+
+  // Gets the number of successful test cases.
+  int successful_test_case_count() const;
+
+  // Gets the number of failed test cases.
+  int failed_test_case_count() const;
+
+  // Gets the number of all test cases.
+  int total_test_case_count() const;
+
+  // Gets the number of all test cases that contain at least one test
+  // that should run.
+  int test_case_to_run_count() const;
+
+  // Gets the number of successful tests.
+  int successful_test_count() const;
+
+  // Gets the number of failed tests.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Gets the number of all tests.
+  int total_test_count() const;
+
+  // Gets the number of tests that should run.
+  int test_to_run_count() const;
+
+  // Gets the time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const;
+
+  // Gets the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const;
+
+  // Returns true iff the unit test passed (i.e. all test cases passed).
+  bool Passed() const;
+
+  // Returns true iff the unit test failed (i.e. some test case failed
+  // or something outside of all tests failed).
+  bool Failed() const;
+
+  // Gets the i-th test case among all the test cases. i can range from 0 to
+  // total_test_case_count() - 1. If i is not in that range, returns NULL.
+  const TestCase* GetTestCase(int i) const;
+
+  // Returns the TestResult containing information on test failures and
+  // properties logged outside of individual test cases.
+  const TestResult& ad_hoc_test_result() const;
+
+  // Returns the list of event listeners that can be used to track events
+  // inside Google Test.
+  TestEventListeners& listeners();
+
+ private:
+  // Registers and returns a global test environment.  When a test
+  // program is run, all global test environments will be set-up in
+  // the order they were registered.  After all tests in the program
+  // have finished, all global test environments will be torn-down in
+  // the *reverse* order they were registered.
+  //
+  // The UnitTest object takes ownership of the given environment.
+  //
+  // This method can only be called from the main thread.
+  Environment* AddEnvironment(Environment* env);
+
+  // Adds a TestPartResult to the current TestResult object.  All
+  // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
+  // eventually call this to report their results.  The user code
+  // should use the assertion macros instead of calling this directly.
+  void AddTestPartResult(TestPartResult::Type result_type,
+                         const char* file_name,
+                         int line_number,
+                         const std::string& message,
+                         const std::string& os_stack_trace)
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Adds a TestProperty to the current TestResult object when invoked from
+  // inside a test, to current TestCase's ad_hoc_test_result_ when invoked
+  // from SetUpTestCase or TearDownTestCase, 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 case among all the test cases. i can range from 0 to
+  // total_test_case_count() - 1. If i is not in that range, returns NULL.
+  TestCase* GetMutableTestCase(int i);
+
+  // Accessors for the implementation object.
+  internal::UnitTestImpl* impl() { return impl_; }
+  const internal::UnitTestImpl* impl() const { return impl_; }
+
+  // These classes and funcions are friends as they need to access private
+  // members of UnitTest.
+  friend class Test;
+  friend class internal::AssertHelper;
+  friend class internal::ScopedTrace;
+  friend class internal::StreamingListenerTest;
+  friend class internal::UnitTestRecordPropertyTestHelper;
+  friend Environment* AddGlobalTestEnvironment(Environment* env);
+  friend internal::UnitTestImpl* internal::GetUnitTestImpl();
+  friend void internal::ReportFailureInUnknownLocation(
+      TestPartResult::Type result_type,
+      const std::string& message);
+
+  // Creates an empty UnitTest.
+  UnitTest();
+
+  // D'tor
+  virtual ~UnitTest();
+
+  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
+  // Google Test trace stack.
+  void PushGTestTrace(const internal::TraceInfo& trace)
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Pops a trace from the per-thread Google Test trace stack.
+  void PopGTestTrace()
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Protects mutable state in *impl_.  This is mutable as some const
+  // methods need to lock it too.
+  mutable internal::Mutex mutex_;
+
+  // Opaque implementation object.  This field is never changed once
+  // the object is constructed.  We don't mark it as const here, as
+  // doing so will cause a warning in the constructor of UnitTest.
+  // Mutable state in *impl_ is protected by mutex_.
+  internal::UnitTestImpl* impl_;
+
+  // We disallow copying UnitTest.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
+};
+
+// A convenient wrapper for adding an environment for the test
+// program.
+//
+// You should call this before RUN_ALL_TESTS() is called, probably in
+// main().  If you use gtest_main, you need to call this before main()
+// starts for it to take effect.  For example, you can define a global
+// variable like this:
+//
+//   testing::Environment* const foo_env =
+//       testing::AddGlobalTestEnvironment(new FooEnvironment);
+//
+// However, we strongly recommend you to write your own main() and
+// call AddGlobalTestEnvironment() there, as relying on initialization
+// of global variables makes the code harder to read and may cause
+// problems when you register multiple environments from different
+// translation units and the environments have dependencies among them
+// (remember that the compiler doesn't guarantee the order in which
+// global variables from different translation units are initialized).
+inline Environment* AddGlobalTestEnvironment(Environment* env) {
+  return UnitTest::GetInstance()->AddEnvironment(env);
+}
+
+// Initializes Google Test.  This must be called before calling
+// RUN_ALL_TESTS().  In particular, it parses a command line for the
+// flags that Google Test recognizes.  Whenever a Google Test flag is
+// seen, it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Test flag variables are
+// updated.
+//
+// Calling the function for the second time has no user-visible effect.
+GTEST_API_ void InitGoogleTest(int* argc, char** argv);
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
+
+namespace internal {
+
+// Separate the error generating code from the code path to reduce the stack
+// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers
+// when calling EXPECT_* in a tight loop.
+template <typename T1, typename T2>
+AssertionResult CmpHelperEQFailure(const char* lhs_expression,
+                                   const char* rhs_expression,
+                                   const T1& lhs, const T2& rhs) {
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   FormatForComparisonFailureMessage(lhs, rhs),
+                   FormatForComparisonFailureMessage(rhs, lhs),
+                   false);
+}
+
+// The helper function for {ASSERT|EXPECT}_EQ.
+template <typename T1, typename T2>
+AssertionResult CmpHelperEQ(const char* lhs_expression,
+                            const char* rhs_expression,
+                            const T1& lhs,
+                            const T2& rhs) {
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
+  if (lhs == rhs) {
+    return AssertionSuccess();
+  }
+GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+  return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
+}
+
+// With this overloaded version, we allow anonymous enums to be used
+// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
+// can be implicitly cast to BiggestInt.
+GTEST_API_ AssertionResult CmpHelperEQ(const char* lhs_expression,
+                                       const char* rhs_expression,
+                                       BiggestInt lhs,
+                                       BiggestInt rhs);
+
+// The helper class for {ASSERT|EXPECT}_EQ.  The template argument
+// lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
+// is a null pointer literal.  The following default implementation is
+// for lhs_is_null_literal being false.
+template <bool lhs_is_null_literal>
+class EqHelper {
+ public:
+  // This templatized version is for the general case.
+  template <typename T1, typename T2>
+  static AssertionResult Compare(const char* lhs_expression,
+                                 const char* rhs_expression,
+                                 const T1& lhs,
+                                 const T2& rhs) {
+    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
+  }
+
+  // With this overloaded version, we allow anonymous enums to be used
+  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
+  // enums can be implicitly cast to BiggestInt.
+  //
+  // Even though its body looks the same as the above version, we
+  // cannot merge the two, as it will make anonymous enums unhappy.
+  static AssertionResult Compare(const char* lhs_expression,
+                                 const char* rhs_expression,
+                                 BiggestInt lhs,
+                                 BiggestInt rhs) {
+    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
+  }
+};
+
+// This specialization is used when the first argument to ASSERT_EQ()
+// is a null pointer literal, like NULL, false, or 0.
+template <>
+class EqHelper<true> {
+ public:
+  // We define two overloaded versions of Compare().  The first
+  // version will be picked when the second argument to ASSERT_EQ() is
+  // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or
+  // EXPECT_EQ(false, a_bool).
+  template <typename T1, typename T2>
+  static AssertionResult Compare(
+      const char* lhs_expression,
+      const char* rhs_expression,
+      const T1& lhs,
+      const T2& rhs,
+      // The following line prevents this overload from being considered if T2
+      // is not a pointer type.  We need this because ASSERT_EQ(NULL, my_ptr)
+      // expands to Compare("", "", NULL, my_ptr), which requires a conversion
+      // to match the Secret* in the other overload, which would otherwise make
+      // this template match better.
+      typename EnableIf<!is_pointer<T2>::value>::type* = 0) {
+    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
+  }
+
+  // This version will be picked when the second argument to ASSERT_EQ() is a
+  // pointer, e.g. ASSERT_EQ(NULL, a_pointer).
+  template <typename T>
+  static AssertionResult Compare(
+      const char* lhs_expression,
+      const char* rhs_expression,
+      // We used to have a second template parameter instead of Secret*.  That
+      // template parameter would deduce to 'long', making this a better match
+      // than the first overload even without the first overload's EnableIf.
+      // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to
+      // non-pointer argument" (even a deduced integral argument), so the old
+      // implementation caused warnings in user code.
+      Secret* /* lhs (NULL) */,
+      T* rhs) {
+    // We already know that 'lhs' is a null pointer.
+    return CmpHelperEQ(lhs_expression, rhs_expression,
+                       static_cast<T*>(NULL), rhs);
+  }
+};
+
+// Separate the error generating code from the code path to reduce the stack
+// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers
+// when calling EXPECT_OP in a tight loop.
+template <typename T1, typename T2>
+AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
+                                   const T1& val1, const T2& val2,
+                                   const char* op) {
+  return AssertionFailure()
+         << "Expected: (" << expr1 << ") " << op << " (" << expr2
+         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
+         << " vs " << FormatForComparisonFailureMessage(val2, val1);
+}
+
+// A macro for implementing the helper functions needed to implement
+// ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
+// of similar code.
+//
+// For each templatized helper function, we also define an overloaded
+// version for BiggestInt in order to reduce code bloat and allow
+// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
+// with gcc 4.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
+template <typename T1, typename T2>\
+AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                   const T1& val1, const T2& val2) {\
+  if (val1 op val2) {\
+    return AssertionSuccess();\
+  } else {\
+    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
+  }\
+}\
+GTEST_API_ AssertionResult CmpHelper##op_name(\
+    const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+// Implements the helper function for {ASSERT|EXPECT}_NE
+GTEST_IMPL_CMP_HELPER_(NE, !=);
+// Implements the helper function for {ASSERT|EXPECT}_LE
+GTEST_IMPL_CMP_HELPER_(LE, <=);
+// Implements the helper function for {ASSERT|EXPECT}_LT
+GTEST_IMPL_CMP_HELPER_(LT, <);
+// Implements the helper function for {ASSERT|EXPECT}_GE
+GTEST_IMPL_CMP_HELPER_(GE, >=);
+// Implements the helper function for {ASSERT|EXPECT}_GT
+GTEST_IMPL_CMP_HELPER_(GT, >);
+
+#undef GTEST_IMPL_CMP_HELPER_
+
+// The helper function for {ASSERT|EXPECT}_STREQ.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const char* s1,
+                                          const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression,
+                                              const char* s2_expression,
+                                              const char* s1,
+                                              const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRNE.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const char* s1,
+                                          const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRCASENE.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
+                                              const char* s2_expression,
+                                              const char* s1,
+                                              const char* s2);
+
+
+// Helper function for *_STREQ on wide strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const wchar_t* s1,
+                                          const wchar_t* s2);
+
+// Helper function for *_STRNE on wide strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const wchar_t* s1,
+                                          const wchar_t* s2);
+
+}  // namespace internal
+
+// IsSubstring() and IsNotSubstring() are intended to be used as the
+// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
+// themselves.  They check whether needle is a substring of haystack
+// (NULL is considered a substring of itself only), and return an
+// appropriate error message when they fail.
+//
+// The {needle,haystack}_expr arguments are the stringified
+// expressions that generated the two real arguments.
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack);
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack);
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack);
+
+#if GTEST_HAS_STD_WSTRING
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack);
+#endif  // GTEST_HAS_STD_WSTRING
+
+namespace internal {
+
+// Helper template function for comparing floating-points.
+//
+// Template parameter:
+//
+//   RawType: the raw floating-point type (either float or double)
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+template <typename RawType>
+AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
+                                         const char* rhs_expression,
+                                         RawType lhs_value,
+                                         RawType rhs_value) {
+  const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);
+
+  if (lhs.AlmostEquals(rhs)) {
+    return AssertionSuccess();
+  }
+
+  ::std::stringstream lhs_ss;
+  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+         << lhs_value;
+
+  ::std::stringstream rhs_ss;
+  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+         << rhs_value;
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   StringStreamToString(&lhs_ss),
+                   StringStreamToString(&rhs_ss),
+                   false);
+}
+
+// Helper function for implementing ASSERT_NEAR.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
+                                                const char* expr2,
+                                                const char* abs_error_expr,
+                                                double val1,
+                                                double val2,
+                                                double abs_error);
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+// A class that enables one to stream messages to assertion macros
+class GTEST_API_ AssertHelper {
+ public:
+  // Constructor.
+  AssertHelper(TestPartResult::Type type,
+               const char* file,
+               int line,
+               const char* message);
+  ~AssertHelper();
+
+  // Message assignment is a semantic trick to enable assertion
+  // streaming; see the GTEST_MESSAGE_ macro below.
+  void operator=(const Message& message) const;
+
+ private:
+  // We put our data in a struct so that the size of the AssertHelper class can
+  // be as small as possible.  This is important because gcc is incapable of
+  // re-using stack space even for temporary variables, so every EXPECT_EQ
+  // reserves stack space for another AssertHelper.
+  struct AssertHelperData {
+    AssertHelperData(TestPartResult::Type t,
+                     const char* srcfile,
+                     int line_num,
+                     const char* msg)
+        : type(t), file(srcfile), line(line_num), message(msg) { }
+
+    TestPartResult::Type const type;
+    const char* const file;
+    int const line;
+    std::string const message;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
+  };
+
+  AssertHelperData* const data_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
+};
+
+}  // namespace internal
+
+#if GTEST_HAS_PARAM_TEST
+// The pure interface class that all value-parameterized tests inherit from.
+// A value-parameterized class must inherit from both ::testing::Test and
+// ::testing::WithParamInterface. In most cases that just means inheriting
+// from ::testing::TestWithParam, but more complicated test hierarchies
+// may need to inherit from Test and WithParamInterface at different levels.
+//
+// This interface has support for accessing the test parameter value via
+// the GetParam() method.
+//
+// Use it with one of the parameter generator defining functions, like Range(),
+// Values(), ValuesIn(), Bool(), and Combine().
+//
+// class FooTest : public ::testing::TestWithParam<int> {
+//  protected:
+//   FooTest() {
+//     // Can use GetParam() here.
+//   }
+//   virtual ~FooTest() {
+//     // Can use GetParam() here.
+//   }
+//   virtual void SetUp() {
+//     // Can use GetParam() here.
+//   }
+//   virtual void TearDown {
+//     // Can use GetParam() here.
+//   }
+// };
+// TEST_P(FooTest, DoesBar) {
+//   // Can use GetParam() method here.
+//   Foo foo;
+//   ASSERT_TRUE(foo.DoesBar(GetParam()));
+// }
+// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
+
+template <typename T>
+class WithParamInterface {
+ public:
+  typedef T ParamType;
+  virtual ~WithParamInterface() {}
+
+  // The current parameter value. Is also available in the test fixture's
+  // constructor. This member function is non-static, even though it only
+  // references static data, to reduce the opportunity for incorrect uses
+  // like writing 'WithParamInterface<bool>::GetParam()' for a test that
+  // uses a fixture whose parameter type is int.
+  const ParamType& GetParam() const {
+    GTEST_CHECK_(parameter_ != NULL)
+        << "GetParam() can only be called inside a value-parameterized test "
+        << "-- did you intend to write TEST_P instead of TEST_F?";
+    return *parameter_;
+  }
+
+ private:
+  // Sets parameter value. The caller is responsible for making sure the value
+  // remains alive and unchanged throughout the current test.
+  static void SetParam(const ParamType* parameter) {
+    parameter_ = parameter;
+  }
+
+  // Static value used for accessing parameter during a test lifetime.
+  static const ParamType* parameter_;
+
+  // TestClass must be a subclass of WithParamInterface<T> and Test.
+  template <class TestClass> friend class internal::ParameterizedTestFactory;
+};
+
+template <typename T>
+const T* WithParamInterface<T>::parameter_ = NULL;
+
+// Most value-parameterized classes can ignore the existence of
+// WithParamInterface, and can just inherit from ::testing::TestWithParam.
+
+template <typename T>
+class TestWithParam : public Test, public WithParamInterface<T> {
+};
+
+#endif  // GTEST_HAS_PARAM_TEST
+
+// Macros for indicating success/failure in test code.
+
+// ADD_FAILURE unconditionally adds a failure to the current test.
+// SUCCEED generates a success - it doesn't automatically make the
+// current test successful, as a test is only successful when it has
+// no failure.
+//
+// EXPECT_* verifies that a certain condition is satisfied.  If not,
+// it behaves like ADD_FAILURE.  In particular:
+//
+//   EXPECT_TRUE  verifies that a Boolean condition is true.
+//   EXPECT_FALSE verifies that a Boolean condition is false.
+//
+// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
+// that they will also abort the current function on failure.  People
+// usually want the fail-fast behavior of FAIL and ASSERT_*, but those
+// writing data-driven tests often find themselves using ADD_FAILURE
+// and EXPECT_* more.
+
+// Generates a nonfatal failure with a generic message.
+#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
+
+// Generates a nonfatal failure at the given source file location with
+// a generic message.
+#define ADD_FAILURE_AT(file, line) \
+  GTEST_MESSAGE_AT_(file, line, "Failed", \
+                    ::testing::TestPartResult::kNonFatalFailure)
+
+// Generates a fatal failure with a generic message.
+#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
+
+// Define this macro to 1 to omit the definition of FAIL(), which is a
+// generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_FAIL
+# define FAIL() GTEST_FAIL()
+#endif
+
+// Generates a success with a generic message.
+#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
+
+// Define this macro to 1 to omit the definition of SUCCEED(), which
+// is a generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_SUCCEED
+# define SUCCEED() GTEST_SUCCEED()
+#endif
+
+// Macros for testing exceptions.
+//
+//    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
+//         Tests that the statement throws the expected exception.
+//    * {ASSERT|EXPECT}_NO_THROW(statement):
+//         Tests that the statement doesn't throw any exception.
+//    * {ASSERT|EXPECT}_ANY_THROW(statement):
+//         Tests that the statement throws an exception.
+
+#define EXPECT_THROW(statement, expected_exception) \
+  GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_NO_THROW(statement) \
+  GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_ANY_THROW(statement) \
+  GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_THROW(statement, expected_exception) \
+  GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
+#define ASSERT_NO_THROW(statement) \
+  GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
+#define ASSERT_ANY_THROW(statement) \
+  GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
+
+// Boolean assertions. Condition can be either a Boolean expression or an
+// AssertionResult. For more information on how to use AssertionResult with
+// these macros see comments on that class.
+#define EXPECT_TRUE(condition) \
+  GTEST_TEST_BOOLEAN_((condition), #condition, false, true, \
+                      GTEST_NONFATAL_FAILURE_)
+#define EXPECT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
+                      GTEST_NONFATAL_FAILURE_)
+#define ASSERT_TRUE(condition) \
+  GTEST_TEST_BOOLEAN_((condition), #condition, false, true, \
+                      GTEST_FATAL_FAILURE_)
+#define ASSERT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
+                      GTEST_FATAL_FAILURE_)
+
+// Includes the auto-generated header that implements a family of
+// generic predicate assertion macros.
+#include "gtest/gtest_pred_impl.h"
+
+// Macros for testing equalities and inequalities.
+//
+//    * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2
+//    * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2
+//    * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2
+//    * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2
+//    * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2
+//    * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2
+//
+// When they are not, Google Test prints both the tested expressions and
+// their actual values.  The values must be compatible built-in types,
+// or you will get a compiler error.  By "compatible" we mean that the
+// values can be compared by the respective operator.
+//
+// Note:
+//
+//   1. It is possible to make a user-defined type work with
+//   {ASSERT|EXPECT}_??(), but that requires overloading the
+//   comparison operators and is thus discouraged by the Google C++
+//   Usage Guide.  Therefore, you are advised to use the
+//   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
+//   equal.
+//
+//   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
+//   pointers (in particular, C strings).  Therefore, if you use it
+//   with two C strings, you are testing how their locations in memory
+//   are related, not how their content is related.  To compare two C
+//   strings by content, use {ASSERT|EXPECT}_STR*().
+//
+//   3. {ASSERT|EXPECT}_EQ(v1, v2) is preferred to
+//   {ASSERT|EXPECT}_TRUE(v1 == v2), as the former tells you
+//   what the actual value is when it fails, and similarly for the
+//   other comparisons.
+//
+//   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
+//   evaluate their arguments, which is undefined.
+//
+//   5. These macros evaluate their arguments exactly once.
+//
+// Examples:
+//
+//   EXPECT_NE(5, Foo());
+//   EXPECT_EQ(NULL, a_pointer);
+//   ASSERT_LT(i, array_size);
+//   ASSERT_GT(records.size(), 0) << "There is no record left.";
+
+#define EXPECT_EQ(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal:: \
+                      EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
+                      val1, val2)
+#define EXPECT_NE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
+#define EXPECT_LE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
+#define EXPECT_LT(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
+#define EXPECT_GE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
+#define EXPECT_GT(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
+
+#define GTEST_ASSERT_EQ(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal:: \
+                      EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
+                      val1, val2)
+#define GTEST_ASSERT_NE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
+#define GTEST_ASSERT_LE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
+#define GTEST_ASSERT_LT(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
+#define GTEST_ASSERT_GE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
+#define GTEST_ASSERT_GT(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
+
+// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
+// ASSERT_XY(), which clashes with some users' own code.
+
+#if !GTEST_DONT_DEFINE_ASSERT_EQ
+# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_NE
+# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_LE
+# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_LT
+# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_GE
+# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_GT
+# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
+#endif
+
+// C-string Comparisons.  All tests treat NULL and any non-NULL string
+// as different.  Two NULLs are equal.
+//
+//    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
+//    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
+//    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
+//    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
+//
+// For wide or narrow string objects, you can use the
+// {ASSERT|EXPECT}_??() macros.
+//
+// Don't depend on the order in which the arguments are evaluated,
+// which is undefined.
+//
+// These macros evaluate their arguments exactly once.
+
+#define EXPECT_STREQ(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
+#define EXPECT_STRNE(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
+#define EXPECT_STRCASEEQ(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
+#define EXPECT_STRCASENE(s1, s2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
+
+#define ASSERT_STREQ(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
+#define ASSERT_STRNE(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
+#define ASSERT_STRCASEEQ(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
+#define ASSERT_STRCASENE(s1, s2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
+
+// Macros for comparing floating-point numbers.
+//
+//    * {ASSERT|EXPECT}_FLOAT_EQ(val1, val2):
+//         Tests that two float values are almost equal.
+//    * {ASSERT|EXPECT}_DOUBLE_EQ(val1, val2):
+//         Tests that two double values are almost equal.
+//    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
+//         Tests that v1 and v2 are within the given distance to each other.
+//
+// Google Test uses ULP-based comparison to automatically pick a default
+// error bound that is appropriate for the operands.  See the
+// FloatingPoint template class in gtest-internal.h if you are
+// interested in the implementation details.
+
+#define EXPECT_FLOAT_EQ(val1, val2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
+                      val1, val2)
+
+#define EXPECT_DOUBLE_EQ(val1, val2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
+                      val1, val2)
+
+#define ASSERT_FLOAT_EQ(val1, val2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
+                      val1, val2)
+
+#define ASSERT_DOUBLE_EQ(val1, val2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
+                      val1, val2)
+
+#define EXPECT_NEAR(val1, val2, abs_error)\
+  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
+                      val1, val2, abs_error)
+
+#define ASSERT_NEAR(val1, val2, abs_error)\
+  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
+                      val1, val2, abs_error)
+
+// These predicate format functions work on floating-point values, and
+// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
+//
+//   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
+                                   float val1, float val2);
+GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
+                                    double val1, double val2);
+
+
+#if GTEST_OS_WINDOWS
+
+// Macros that test for HRESULT failure and success, these are only useful
+// on Windows, and rely on Windows SDK macros and APIs to compile.
+//
+//    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
+//
+// When expr unexpectedly fails or succeeds, Google Test prints the
+// expected result and the actual result with both a human-readable
+// string representation of the error, if available, as well as the
+// hex result code.
+# define EXPECT_HRESULT_SUCCEEDED(expr) \
+    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+
+# define ASSERT_HRESULT_SUCCEEDED(expr) \
+    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+
+# define EXPECT_HRESULT_FAILED(expr) \
+    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+
+# define ASSERT_HRESULT_FAILED(expr) \
+    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+
+#endif  // GTEST_OS_WINDOWS
+
+// Macros that execute statement and check that it doesn't generate new fatal
+// failures in the current thread.
+//
+//   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
+//
+// Examples:
+//
+//   EXPECT_NO_FATAL_FAILURE(Process());
+//   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
+//
+#define ASSERT_NO_FATAL_FAILURE(statement) \
+    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
+#define EXPECT_NO_FATAL_FAILURE(statement) \
+    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
+
+// Causes a trace (including the source file path, the current line
+// number, and the given message) to be included in every test failure
+// message generated by code in the current scope.  The effect is
+// undone when the control leaves the current scope.
+//
+// The message argument can be anything streamable to std::ostream.
+//
+// In the implementation, we include the current line number as part
+// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
+// to appear in the same block - as long as they are on different
+// lines.
+#define SCOPED_TRACE(message) \
+  ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
+    __FILE__, __LINE__, ::testing::Message() << (message))
+
+// Compile-time assertion for type equality.
+// StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
+// the same type.  The value it returns is not interesting.
+//
+// Instead of making StaticAssertTypeEq a class template, we make it a
+// function template that invokes a helper class template.  This
+// prevents a user from misusing StaticAssertTypeEq<T1, T2> by
+// defining objects of that type.
+//
+// CAVEAT:
+//
+// When used inside a method of a class template,
+// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
+// instantiated.  For example, given:
+//
+//   template <typename T> class Foo {
+//    public:
+//     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
+//   };
+//
+// the code:
+//
+//   void Test1() { Foo<bool> foo; }
+//
+// will NOT generate a compiler error, as Foo<bool>::Bar() is never
+// actually instantiated.  Instead, you need:
+//
+//   void Test2() { Foo<bool> foo; foo.Bar(); }
+//
+// to cause a compiler error.
+template <typename T1, typename T2>
+bool StaticAssertTypeEq() {
+  (void)internal::StaticAssertTypeEqHelper<T1, T2>();
+  return true;
+}
+
+// Defines a test.
+//
+// The first parameter is the name of the test case, and the second
+// parameter is the name of the test within the test case.
+//
+// The convention is to end the test case name with "Test".  For
+// example, a test case for the Foo class can be named FooTest.
+//
+// Test code should appear between braces after an invocation of
+// this macro.  Example:
+//
+//   TEST(FooTest, InitializesCorrectly) {
+//     Foo foo;
+//     EXPECT_TRUE(foo.StatusIsOK());
+//   }
+
+// Note that we call GetTestTypeId() instead of GetTypeId<
+// ::testing::Test>() here to get the type ID of testing::Test.  This
+// is to work around a suspected linker bug when using Google Test as
+// a framework on Mac OS X.  The bug causes GetTypeId<
+// ::testing::Test>() to return different values depending on whether
+// the call is from the Google Test framework itself or from user test
+// code.  GetTestTypeId() is guaranteed to always return the same
+// value, as it always calls GetTypeId<>() from the Google Test
+// framework.
+#define GTEST_TEST(test_case_name, test_name)\
+  GTEST_TEST_(test_case_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_case_name, test_name) GTEST_TEST(test_case_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 case name.  The second parameter is the
+// name of the test within the test case.
+//
+// A test fixture class must be declared earlier.  The user should put
+// his test code between braces after using this macro.  Example:
+//
+//   class FooTest : public testing::Test {
+//    protected:
+//     virtual void SetUp() { b_.AddElement(3); }
+//
+//     Foo a_;
+//     Foo b_;
+//   };
+//
+//   TEST_F(FooTest, InitializesCorrectly) {
+//     EXPECT_TRUE(a_.StatusIsOK());
+//   }
+//
+//   TEST_F(FooTest, ReturnsElementCountCorrectly) {
+//     EXPECT_EQ(0, a_.size());
+//     EXPECT_EQ(1, b_.size());
+//   }
+
+#define TEST_F(test_fixture, test_name)\
+  GTEST_TEST_(test_fixture, test_name, test_fixture, \
+              ::testing::internal::GetTypeId<test_fixture>())
+
+}  // namespace testing
+
+// Use this function in main() to run all tests.  It returns 0 if all
+// tests are successful, or 1 otherwise.
+//
+// RUN_ALL_TESTS() should be invoked after the command line has been
+// parsed by InitGoogleTest().
+//
+// This function was formerly a macro; thus, it is in the global
+// namespace and has an all-caps name.
+int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
+
+inline int RUN_ALL_TESTS() {
+  return ::testing::UnitTest::GetInstance()->Run();
+}
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_pred_impl.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_pred_impl.h
new file mode 100644
index 00000000..30ae712f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_pred_impl.h
@@ -0,0 +1,358 @@
+// Copyright 2006, 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.
+
+// This file is AUTOMATICALLY GENERATED on 10/31/2011 by command
+// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
+//
+// Implements a family of generic predicate assertion macros.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+
+// Makes sure this header is not included before gtest.h.
+#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
+# error Do not include gtest_pred_impl.h directly.  Include gtest.h instead.
+#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
+
+// This header implements a family of generic predicate assertion
+// macros:
+//
+//   ASSERT_PRED_FORMAT1(pred_format, v1)
+//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
+//   ...
+//
+// where pred_format is a function or functor that takes n (in the
+// case of ASSERT_PRED_FORMATn) values and their source expression
+// text, and returns a testing::AssertionResult.  See the definition
+// of ASSERT_EQ in gtest.h for an example.
+//
+// If you don't care about formatting, you can use the more
+// restrictive version:
+//
+//   ASSERT_PRED1(pred, v1)
+//   ASSERT_PRED2(pred, v1, v2)
+//   ...
+//
+// where pred is an n-ary function or functor that returns bool,
+// and the values v1, v2, ..., must support the << operator for
+// streaming to std::ostream.
+//
+// We also define the EXPECT_* variations.
+//
+// For now we only support predicates whose arity is at most 5.
+// Please email googletestframework@googlegroups.com if you need
+// support for higher arities.
+
+// GTEST_ASSERT_ is the basic statement to which all of the assertions
+// in this file reduce.  Don't use this in your code.
+
+#define GTEST_ASSERT_(expression, on_failure) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (const ::testing::AssertionResult gtest_ar = (expression)) \
+    ; \
+  else \
+    on_failure(gtest_ar.failure_message())
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1>
+AssertionResult AssertPred1Helper(const char* pred_text,
+                                  const char* e1,
+                                  Pred pred,
+                                  const T1& v1) {
+  if (pred(v1)) return AssertionSuccess();
+
+  return AssertionFailure() << pred_text << "("
+                            << e1 << ") evaluates to false, where"
+                            << "\n" << e1 << " evaluates to " << v1;
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, v1), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
+// this in your code.
+#define GTEST_PRED1_(pred, v1, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
+                                             #v1, \
+                                             pred, \
+                                             v1), on_failure)
+
+// Unary predicate assertion macros.
+#define EXPECT_PRED_FORMAT1(pred_format, v1) \
+  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED1(pred, v1) \
+  GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT1(pred_format, v1) \
+  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED1(pred, v1) \
+  GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2>
+AssertionResult AssertPred2Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2) {
+  if (pred(v1, v2)) return AssertionSuccess();
+
+  return AssertionFailure() << pred_text << "("
+                            << e1 << ", "
+                            << e2 << ") evaluates to false, where"
+                            << "\n" << e1 << " evaluates to " << v1
+                            << "\n" << e2 << " evaluates to " << v2;
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
+// this in your code.
+#define GTEST_PRED2_(pred, v1, v2, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             pred, \
+                                             v1, \
+                                             v2), on_failure)
+
+// Binary predicate assertion macros.
+#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
+  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED2(pred, v1, v2) \
+  GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
+  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED2(pred, v1, v2) \
+  GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3>
+AssertionResult AssertPred3Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  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 " << v1
+                            << "\n" << e2 << " evaluates to " << v2
+                            << "\n" << e3 << " evaluates to " << v3;
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
+// this in your code.
+#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3), on_failure)
+
+// Ternary predicate assertion macros.
+#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
+  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED3(pred, v1, v2, v3) \
+  GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
+  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED3(pred, v1, v2, v3) \
+  GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4>
+AssertionResult AssertPred4Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  const char* e4,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3,
+                                  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 " << v1
+                            << "\n" << e2 << " evaluates to " << v2
+                            << "\n" << e3 << " evaluates to " << v3
+                            << "\n" << e4 << " evaluates to " << v4;
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
+// this in your code.
+#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             #v4, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3, \
+                                             v4), on_failure)
+
+// 4-ary predicate assertion macros.
+#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
+  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED4(pred, v1, v2, v3, v4) \
+  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
+  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED4(pred, v1, v2, v3, v4) \
+  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5>
+AssertionResult AssertPred5Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  const char* e4,
+                                  const char* e5,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3,
+                                  const T4& v4,
+                                  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 " << v1
+                            << "\n" << e2 << " evaluates to " << v2
+                            << "\n" << e3 << " evaluates to " << v3
+                            << "\n" << e4 << " evaluates to " << v4
+                            << "\n" << e5 << " evaluates to " << v5;
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
+// this in your code.
+#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             #v4, \
+                                             #v5, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3, \
+                                             v4, \
+                                             v5), on_failure)
+
+// 5-ary predicate assertion macros.
+#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
+  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
+  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
+  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
+  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
+
+
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_prod.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_prod.h
new file mode 100644
index 00000000..da80ddc6
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_prod.h
@@ -0,0 +1,58 @@
+// Copyright 2006, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Google C++ Testing Framework definitions useful in production code.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_
+#define GTEST_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
+// class.  For example:
+//
+// class MyClass {
+//  private:
+//   void MyMethod();
+//   FRIEND_TEST(MyClassTest, MyMethod);
+// };
+//
+// class MyClassTest : public testing::Test {
+//   // ...
+// };
+//
+// TEST_F(MyClassTest, MyMethod) {
+//   // Can call MyClass::MyMethod() here.
+// }
+
+#define FRIEND_TEST(test_case_name, test_name)\
+friend class test_case_name##_##test_name##_Test
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_PROD_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-port.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-port.h
new file mode 100644
index 00000000..7e744bd3
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-port.h
@@ -0,0 +1,69 @@
+// Copyright 2015, 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.
+//
+// Injection point for custom user configurations.
+// The following macros can be defined:
+//
+//   Flag related macros:
+//     GTEST_FLAG(flag_name)
+//     GTEST_USE_OWN_FLAGFILE_FLAG_  - Define to 0 when the system provides its
+//                                     own flagfile flag parsing.
+//     GTEST_DECLARE_bool_(name)
+//     GTEST_DECLARE_int32_(name)
+//     GTEST_DECLARE_string_(name)
+//     GTEST_DEFINE_bool_(name, default_val, doc)
+//     GTEST_DEFINE_int32_(name, default_val, doc)
+//     GTEST_DEFINE_string_(name, default_val, doc)
+//
+//   Test filtering:
+//     GTEST_TEST_FILTER_ENV_VAR_ - The name of an environment variable that
+//                                  will be used if --GTEST_FLAG(test_filter)
+//                                  is not provided.
+//
+//   Logging:
+//     GTEST_LOG_(severity)
+//     GTEST_CHECK_(condition)
+//     Functions LogToStderr() and FlushInfoLog() have to be provided too.
+//
+//   Threading:
+//     GTEST_HAS_NOTIFICATION_ - Enabled if Notification is already provided.
+//     GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ - Enabled if Mutex and ThreadLocal are
+//                                         already provided.
+//     Must also provide GTEST_DECLARE_STATIC_MUTEX_(mutex) and
+//     GTEST_DEFINE_STATIC_MUTEX_(mutex)
+//
+//     GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
+//     GTEST_LOCK_EXCLUDED_(locks)
+//
+// ** Custom implementation starts here **
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-printers.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-printers.h
new file mode 100644
index 00000000..60c1ea05
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-printers.h
@@ -0,0 +1,42 @@
+// Copyright 2015, 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.
+//
+// This file provides an injection point for custom printers in a local
+// installation of gTest.
+// It will be included from gtest-printers.h and the overrides in this file
+// will be visible to everyone.
+// See documentation at gtest/gtest-printers.h for details on how to define a
+// custom printer.
+//
+// ** Custom implementation starts here **
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest.h
new file mode 100644
index 00000000..c27412a8
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest.h
@@ -0,0 +1,41 @@
+// Copyright 2015, 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.
+//
+// Injection point for custom user configurations.
+// The following macros can be defined:
+//
+// GTEST_OS_STACK_TRACE_GETTER_  - The name of an implementation of
+//                                 OsStackTraceGetterInterface.
+//
+// ** Custom implementation starts here **
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
new file mode 100644
index 00000000..2b3a78f5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
@@ -0,0 +1,319 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file defines internal utilities needed for implementing
+// death tests.  They are subject to change without notice.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+
+#include "gtest/internal/gtest-internal.h"
+
+#include <stdio.h>
+
+namespace testing {
+namespace internal {
+
+GTEST_DECLARE_string_(internal_run_death_test);
+
+// Names of the flags (needed for parsing Google Test flags).
+const char kDeathTestStyleFlag[] = "death_test_style";
+const char kDeathTestUseFork[] = "death_test_use_fork";
+const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
+
+#if GTEST_HAS_DEATH_TEST
+
+// 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
+// style, as defined by the --gtest_death_test_style and/or
+// --gtest_internal_run_death_test flags.
+
+// In describing the results of death tests, these terms are used with
+// the corresponding definitions:
+//
+// exit status:  The integer exit information in the format specified
+//               by wait(2)
+// exit code:    The integer code passed to exit(3), _exit(2), or
+//               returned from main()
+class GTEST_API_ DeathTest {
+ public:
+  // Create returns false if there was an error determining the
+  // appropriate action to take for the current death test; for example,
+  // if the gtest_death_test_style flag is set to an invalid value.
+  // The LastMessage method will return a more detailed message in that
+  // case.  Otherwise, the DeathTest pointer pointed to by the "test"
+  // 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, const RE* regex,
+                     const char* file, int line, DeathTest** test);
+  DeathTest();
+  virtual ~DeathTest() { }
+
+  // A helper class that aborts a death test when it's deleted.
+  class ReturnSentinel {
+   public:
+    explicit ReturnSentinel(DeathTest* test) : test_(test) { }
+    ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
+   private:
+    DeathTest* const test_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
+  } GTEST_ATTRIBUTE_UNUSED_;
+
+  // An enumeration of possible roles that may be taken when a death
+  // test is encountered.  EXECUTE means that the death test logic should
+  // be executed immediately.  OVERSEE means that the program should prepare
+  // the appropriate environment for a child process to execute the death
+  // test, then wait for it to complete.
+  enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
+
+  // An enumeration of the three reasons that a test might be aborted.
+  enum AbortReason {
+    TEST_ENCOUNTERED_RETURN_STATEMENT,
+    TEST_THREW_EXCEPTION,
+    TEST_DID_NOT_DIE
+  };
+
+  // Assumes one of the above roles.
+  virtual TestRole AssumeRole() = 0;
+
+  // Waits for the death test to finish and returns its status.
+  virtual int Wait() = 0;
+
+  // Returns true if the death test passed; that is, the test process
+  // exited during the test, its exit status matches a user-supplied
+  // predicate, and its stderr output matches a user-supplied regular
+  // expression.
+  // The user-supplied predicate may be a macro expression rather
+  // than a function pointer or functor, or else Wait and Passed could
+  // be combined.
+  virtual bool Passed(bool exit_status_ok) = 0;
+
+  // Signals that the death test did not die as expected.
+  virtual void Abort(AbortReason reason) = 0;
+
+  // Returns a human-readable outcome message regarding the outcome of
+  // the last death test.
+  static const char* LastMessage();
+
+  static void set_last_death_test_message(const std::string& message);
+
+ private:
+  // A string containing a description of the outcome of the last death test.
+  static std::string last_death_test_message_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
+};
+
+// Factory interface for death tests.  May be mocked out for testing.
+class DeathTestFactory {
+ public:
+  virtual ~DeathTestFactory() { }
+  virtual bool Create(const char* statement, const RE* regex,
+                      const char* file, int line, DeathTest** test) = 0;
+};
+
+// A concrete DeathTestFactory implementation for normal use.
+class DefaultDeathTestFactory : public DeathTestFactory {
+ public:
+  virtual bool Create(const char* statement, const RE* regex,
+                      const char* file, int line, DeathTest** test);
+};
+
+// 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);
+
+// Traps C++ exceptions escaping statement and reports them as test
+// failures. Note that trapping SEH exceptions is not implemented here.
+# if GTEST_HAS_EXCEPTIONS
+#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
+  try { \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+  } catch (const ::std::exception& gtest_exception) { \
+    fprintf(\
+        stderr, \
+        "\n%s: Caught std::exception-derived exception escaping the " \
+        "death test statement. Exception message: %s\n", \
+        ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
+        gtest_exception.what()); \
+    fflush(stderr); \
+    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
+  } catch (...) { \
+    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
+  }
+
+# else
+#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
+  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+
+# endif
+
+// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
+// ASSERT_EXIT*, and EXPECT_EXIT*.
+# define GTEST_DEATH_TEST_(statement, predicate, regex, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    const ::testing::internal::RE& gtest_regex = (regex); \
+    ::testing::internal::DeathTest* gtest_dt; \
+    if (!::testing::internal::DeathTest::Create(#statement, &gtest_regex, \
+        __FILE__, __LINE__, &gtest_dt)) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
+    } \
+    if (gtest_dt != NULL) { \
+      ::testing::internal::scoped_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, the regex is
+// ignored, and the macro must accept a streamed message even though the message
+// is never printed.
+# define GTEST_EXECUTE_STATEMENT_(statement, regex) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+     GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+  } else \
+    ::testing::Message()
+
+// A class representing the parsed contents of the
+// --gtest_internal_run_death_test flag, as it existed when
+// RUN_ALL_TESTS was called.
+class InternalRunDeathTestFlag {
+ public:
+  InternalRunDeathTestFlag(const std::string& a_file,
+                           int a_line,
+                           int an_index,
+                           int a_write_fd)
+      : file_(a_file), line_(a_line), index_(an_index),
+        write_fd_(a_write_fd) {}
+
+  ~InternalRunDeathTestFlag() {
+    if (write_fd_ >= 0)
+      posix::Close(write_fd_);
+  }
+
+  const std::string& file() const { return file_; }
+  int line() const { return line_; }
+  int index() const { return index_; }
+  int write_fd() const { return write_fd_; }
+
+ private:
+  std::string file_;
+  int line_;
+  int index_;
+  int write_fd_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
+};
+
+// Returns a newly created InternalRunDeathTestFlag object with fields
+// initialized from the GTEST_FLAG(internal_run_death_test) flag if
+// the flag is specified; otherwise returns NULL.
+InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
+
+#else  // 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
+// iff 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.
+//
+// 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 iff 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()
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-filepath.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-filepath.h
new file mode 100644
index 00000000..7a13b4b0
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-filepath.h
@@ -0,0 +1,206 @@
+// 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.
+//
+// Author: keith.ray@gmail.com (Keith Ray)
+//
+// Google Test filepath utilities
+//
+// 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>.
+// Do not include this header file separately!
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+
+#include "gtest/internal/gtest-string.h"
+
+namespace testing {
+namespace internal {
+
+// FilePath - a class for file and directory pathname manipulation which
+// handles platform-specific conventions (like the pathname separator).
+// Used for helper functions for naming files in a directory for xml output.
+// Except for Set methods, all methods are const or static, which provides an
+// "immutable value object" -- useful for peace of mind.
+// A FilePath with a value ending in a path separator ("like/this/") represents
+// a directory, otherwise it is assumed to represent a file. In either case,
+// it may or may not represent an actual file or directory in the file system.
+// Names are NOT checked for syntax correctness -- no checking for illegal
+// characters, malformed paths, etc.
+
+class GTEST_API_ FilePath {
+ public:
+  FilePath() : pathname_("") { }
+  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
+
+  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
+    Normalize();
+  }
+
+  FilePath& operator=(const FilePath& rhs) {
+    Set(rhs);
+    return *this;
+  }
+
+  void Set(const FilePath& rhs) {
+    pathname_ = rhs.pathname_;
+  }
+
+  const std::string& string() const { return pathname_; }
+  const char* c_str() const { return pathname_.c_str(); }
+
+  // Returns the current working directory, or "" if unsuccessful.
+  static FilePath GetCurrentDir();
+
+  // Given directory = "dir", base_name = "test", number = 0,
+  // extension = "xml", returns "dir/test.xml". If number is greater
+  // than zero (e.g., 12), returns "dir/test_12.xml".
+  // On Windows platform, uses \ as the separator rather than /.
+  static FilePath MakeFileName(const FilePath& directory,
+                               const FilePath& base_name,
+                               int number,
+                               const char* extension);
+
+  // Given directory = "dir", relative_path = "test.xml",
+  // returns "dir/test.xml".
+  // On Windows, uses \ as the separator rather than /.
+  static FilePath ConcatPaths(const FilePath& directory,
+                              const FilePath& relative_path);
+
+  // Returns a pathname for a file that does not currently exist. The pathname
+  // will be directory/base_name.extension or
+  // directory/base_name_<number>.extension if directory/base_name.extension
+  // already exists. The number will be incremented until a pathname is found
+  // that does not already exist.
+  // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
+  // There could be a race condition if two or more processes are calling this
+  // function at the same time -- they could both pick the same filename.
+  static FilePath GenerateUniqueFileName(const FilePath& directory,
+                                         const FilePath& base_name,
+                                         const char* extension);
+
+  // Returns true iff the path is "".
+  bool IsEmpty() const { return pathname_.empty(); }
+
+  // If input name has a trailing separator character, removes it and returns
+  // the name, otherwise return the name string unmodified.
+  // On Windows platform, uses \ as the separator, other platforms use /.
+  FilePath RemoveTrailingPathSeparator() const;
+
+  // Returns a copy of the FilePath with the directory part removed.
+  // Example: FilePath("path/to/file").RemoveDirectoryName() returns
+  // FilePath("file"). If there is no directory part ("just_a_file"), it returns
+  // the FilePath unmodified. If there is no file part ("just_a_dir/") it
+  // returns an empty FilePath ("").
+  // On Windows platform, '\' is the path separator, otherwise it is '/'.
+  FilePath RemoveDirectoryName() const;
+
+  // RemoveFileName returns the directory path with the filename removed.
+  // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
+  // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
+  // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
+  // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
+  // On Windows platform, '\' is the path separator, otherwise it is '/'.
+  FilePath RemoveFileName() const;
+
+  // Returns a copy of the FilePath with the case-insensitive extension removed.
+  // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
+  // FilePath("dir/file"). If a case-insensitive extension is not
+  // found, returns a copy of the original FilePath.
+  FilePath RemoveExtension(const char* extension) const;
+
+  // Creates directories so that path exists. Returns true if successful or if
+  // the directories already exist; returns false if unable to create
+  // directories for any reason. Will also return false if the FilePath does
+  // not represent a directory (that is, it doesn't end with a path separator).
+  bool CreateDirectoriesRecursively() const;
+
+  // Create the directory so that path exists. Returns true if successful or
+  // if the directory already exists; returns false if unable to create the
+  // directory for any reason, including if the parent directory does not
+  // exist. Not named "CreateDirectory" because that's a macro on Windows.
+  bool CreateFolder() const;
+
+  // Returns true if FilePath describes something in the file-system,
+  // either a file, directory, or whatever, and that something exists.
+  bool FileOrDirectoryExists() const;
+
+  // Returns true if pathname describes a directory in the file-system
+  // that exists.
+  bool DirectoryExists() const;
+
+  // Returns true if FilePath ends with a path separator, which indicates that
+  // it is intended to represent a directory. Returns false otherwise.
+  // This does NOT check that a directory (or file) actually exists.
+  bool IsDirectory() const;
+
+  // Returns true if pathname describes a root directory. (Windows has one
+  // root directory per disk drive.)
+  bool IsRootDirectory() const;
+
+  // Returns true if pathname describes an absolute path.
+  bool IsAbsolutePath() const;
+
+ private:
+  // Replaces multiple consecutive separators with a single separator.
+  // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
+  // redundancies that might be in a pathname involving "." or "..".
+  //
+  // A pathname with multiple consecutive separators may occur either through
+  // user error or as a result of some scripts or APIs that generate a pathname
+  // with a trailing separator. On other platforms the same API or script
+  // may NOT generate a pathname with a trailing "/". Then elsewhere that
+  // pathname may have another "/" and pathname components added to it,
+  // without checking for the separator already being there.
+  // The script language and operating system may allow paths like "foo//bar"
+  // but some of the functions in FilePath will not handle that correctly. In
+  // particular, RemoveTrailingPathSeparator() only removes one separator, and
+  // it is called in CreateDirectoriesRecursively() assuming that it will change
+  // a pathname from directory syntax (trailing separator) to filename syntax.
+  //
+  // On Windows this method also replaces the alternate path separator '/' with
+  // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
+  // "bar\\foo".
+
+  void Normalize();
+
+  // Returns a pointer to the last occurence 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;
+
+  std::string pathname_;
+};  // class FilePath
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-internal.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-internal.h
new file mode 100644
index 00000000..ebd1cf61
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-internal.h
@@ -0,0 +1,1238 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file declares functions and macros used internally by
+// Google Test.  They are subject to change without notice.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+
+#include "gtest/internal/gtest-port.h"
+
+#if GTEST_OS_LINUX
+# include <stdlib.h>
+# include <sys/types.h>
+# include <sys/wait.h>
+# include <unistd.h>
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>
+#endif
+
+#include <ctype.h>
+#include <float.h>
+#include <string.h>
+#include <iomanip>
+#include <limits>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "gtest/gtest-message.h"
+#include "gtest/internal/gtest-string.h"
+#include "gtest/internal/gtest-filepath.h"
+#include "gtest/internal/gtest-type-util.h"
+
+// Due to C++ preprocessor weirdness, we need double indirection to
+// concatenate two tokens when one of them is __LINE__.  Writing
+//
+//   foo ## __LINE__
+//
+// will result in the token foo__LINE__, instead of foo followed by
+// the current line number.  For more details, see
+// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
+#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
+#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
+
+class ProtocolMessage;
+namespace proto2 { class Message; }
+
+namespace testing {
+
+// Forward declarations.
+
+class AssertionResult;                 // Result of an assertion.
+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 cases.
+
+template <typename T>
+::std::string PrintToString(const T& value);
+
+namespace internal {
+
+struct TraceInfo;                      // Information about a trace point.
+class ScopedTrace;                     // Implements scoped trace.
+class TestInfoImpl;                    // Opaque implementation of TestInfo
+class UnitTestImpl;                    // Opaque implementation of UnitTest
+
+// The text used in failure messages to indicate the start of the
+// stack trace.
+GTEST_API_ extern const char kStackTraceMarker[];
+
+// Two overloaded helpers for checking at compile time whether an
+// expression is a null pointer literal (i.e. NULL or any 0-valued
+// compile-time integral constant).  Their return values have
+// different sizes, so we can use sizeof() to test which version is
+// picked by the compiler.  These helpers have no implementations, as
+// we only need their signatures.
+//
+// Given IsNullLiteralHelper(x), the compiler will pick the first
+// version if x can be implicitly converted to Secret*, and pick the
+// second version otherwise.  Since Secret is a secret and incomplete
+// type, the only expression a user can write that has type Secret* is
+// a null pointer literal.  Therefore, we know that x is a null
+// pointer literal if and only if the first version is picked by the
+// compiler.
+char IsNullLiteralHelper(Secret* p);
+char (&IsNullLiteralHelper(...))[2];  // NOLINT
+
+// A compile-time bool constant that is true if and only if x is a
+// null pointer literal (i.e. NULL or any 0-valued compile-time
+// integral constant).
+#ifdef GTEST_ELLIPSIS_NEEDS_POD_
+// We lose support for NULL detection where the compiler doesn't like
+// passing non-POD classes through ellipsis (...).
+# define GTEST_IS_NULL_LITERAL_(x) false
+#else
+# define GTEST_IS_NULL_LITERAL_(x) \
+    (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1)
+#endif  // GTEST_ELLIPSIS_NEEDS_POD_
+
+// Appends the user-supplied message to the Google-Test-generated message.
+GTEST_API_ std::string AppendUserMessage(
+    const std::string& gtest_msg, const Message& user_msg);
+
+#if GTEST_HAS_EXCEPTIONS
+
+// 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
+// errors presumably detectable only at run time.  Since
+// std::runtime_error inherits from std::exception, many testing
+// frameworks know how to extract and print the message inside it.
+class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
+ public:
+  explicit GoogleTestFailureException(const TestPartResult& failure);
+};
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// A helper class for creating scoped traces in user programs.
+class GTEST_API_ ScopedTrace {
+ public:
+  // The c'tor pushes the given source file location and message onto
+  // a trace stack maintained by Google Test.
+  ScopedTrace(const char* file, int line, const Message& 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:
+  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.
+
+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.
+// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
+enum EditType { kMatch, kAdd, kRemove, kReplace };
+GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<size_t>& left, const std::vector<size_t>& right);
+
+// Same as above, but the input is represented as strings.
+GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<std::string>& left,
+    const std::vector<std::string>& right);
+
+// Create a diff of the input strings in Unified diff format.
+GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
+                                         const std::vector<std::string>& right,
+                                         size_t context = 2);
+
+}  // namespace edit_distance
+
+// Calculate the diff between 'left' and 'right' and return it in unified diff
+// format.
+// If not null, stores in 'total_line_count' the total number of lines found
+// in left + right.
+GTEST_API_ std::string DiffStrings(const std::string& left,
+                                   const std::string& right,
+                                   size_t* total_line_count);
+
+// Constructs and returns the message for an equality assertion
+// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
+//
+// The first four parameters are the expressions used in the assertion
+// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
+// where foo is 5 and bar is 6, we have:
+//
+//   expected_expression: "foo"
+//   actual_expression:   "bar"
+//   expected_value:      "5"
+//   actual_value:        "6"
+//
+// The ignoring_case parameter is true iff 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,
+                                     const char* actual_expression,
+                                     const std::string& expected_value,
+                                     const std::string& actual_value,
+                                     bool ignoring_case);
+
+// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
+GTEST_API_ std::string GetBoolAssertionFailureMessage(
+    const AssertionResult& assertion_result,
+    const char* expression_text,
+    const char* actual_predicate_value,
+    const char* expected_predicate_value);
+
+// This template class represents an IEEE floating-point number
+// (either single-precision or double-precision, depending on the
+// template parameters).
+//
+// The purpose of this class is to do more sophisticated number
+// comparison.  (Due to round-off error, etc, it's very unlikely that
+// two floating-points will be equal exactly.  Hence a naive
+// comparison by the == operation often doesn't work.)
+//
+// Format of IEEE floating-point:
+//
+//   The most-significant bit being the leftmost, an IEEE
+//   floating-point looks like
+//
+//     sign_bit exponent_bits fraction_bits
+//
+//   Here, sign_bit is a single bit that designates the sign of the
+//   number.
+//
+//   For float, there are 8 exponent bits and 23 fraction bits.
+//
+//   For double, there are 11 exponent bits and 52 fraction bits.
+//
+//   More details can be found at
+//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
+//
+// Template parameter:
+//
+//   RawType: the raw floating-point type (either float or double)
+template <typename RawType>
+class FloatingPoint {
+ public:
+  // Defines the unsigned integer type that has the same size as the
+  // floating point number.
+  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
+
+  // Constants.
+
+  // # of bits in a number.
+  static const size_t kBitCount = 8*sizeof(RawType);
+
+  // # of fraction bits in a number.
+  static const size_t kFractionBitCount =
+    std::numeric_limits<RawType>::digits - 1;
+
+  // # of exponent bits in a number.
+  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
+
+  // The mask for the sign bit.
+  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
+
+  // The mask for the fraction bits.
+  static const Bits kFractionBitMask =
+    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
+
+  // The mask for the exponent bits.
+  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
+
+  // How many ULP's (Units in the Last Place) we want to tolerate when
+  // comparing two numbers.  The larger the value, the more error we
+  // allow.  A 0 value means that two numbers must be exactly the same
+  // to be considered equal.
+  //
+  // The maximum error of a single floating-point operation is 0.5
+  // units in the last place.  On Intel CPU's, all floating-point
+  // calculations are done with 80-bit precision, while double has 64
+  // bits.  Therefore, 4 should be enough for ordinary use.
+  //
+  // See the following article for more details on ULP:
+  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+  static const size_t kMaxUlps = 4;
+
+  // Constructs a FloatingPoint from a raw floating-point number.
+  //
+  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
+  // around may change its bits, although the new value is guaranteed
+  // to be also a NAN.  Therefore, don't expect this constructor to
+  // preserve the bits in x when x is a NAN.
+  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
+
+  // Static methods
+
+  // Reinterprets a bit pattern as a floating-point number.
+  //
+  // This function is needed to test the AlmostEquals() method.
+  static RawType ReinterpretBits(const Bits bits) {
+    FloatingPoint fp(0);
+    fp.u_.bits_ = bits;
+    return fp.u_.value_;
+  }
+
+  // Returns the floating-point number that represent positive infinity.
+  static RawType Infinity() {
+    return ReinterpretBits(kExponentBitMask);
+  }
+
+  // Returns the maximum representable finite floating-point number.
+  static RawType Max();
+
+  // Non-static methods
+
+  // Returns the bits that represents this number.
+  const Bits &bits() const { return u_.bits_; }
+
+  // Returns the exponent bits of this number.
+  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
+
+  // Returns the fraction bits of this number.
+  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }
+
+  // Returns the sign bit of this number.
+  Bits sign_bit() const { return kSignBitMask & u_.bits_; }
+
+  // Returns true iff 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 iff 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.
+  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
+  bool AlmostEquals(const FloatingPoint& rhs) const {
+    // The IEEE standard says that any comparison operation involving
+    // a NAN must return false.
+    if (is_nan() || rhs.is_nan()) return false;
+
+    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
+        <= kMaxUlps;
+  }
+
+ private:
+  // The data type used to store the actual floating-point number.
+  union FloatingPointUnion {
+    RawType value_;  // The raw floating-point number.
+    Bits bits_;      // The bits that represent the number.
+  };
+
+  // Converts an integer from the sign-and-magnitude representation to
+  // the biased representation.  More precisely, let N be 2 to the
+  // power of (kBitCount - 1), an integer x is represented by the
+  // unsigned number x + N.
+  //
+  // For instance,
+  //
+  //   -N + 1 (the most negative number representable using
+  //          sign-and-magnitude) is represented by 1;
+  //   0      is represented by N; and
+  //   N - 1  (the biggest number representable using
+  //          sign-and-magnitude) is represented by 2N - 1.
+  //
+  // Read http://en.wikipedia.org/wiki/Signed_number_representations
+  // for more details on signed number representations.
+  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
+    if (kSignBitMask & sam) {
+      // sam represents a negative number.
+      return ~sam + 1;
+    } else {
+      // sam represents a positive number.
+      return kSignBitMask | sam;
+    }
+  }
+
+  // Given two numbers in the sign-and-magnitude representation,
+  // returns the distance between them as an unsigned number.
+  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
+                                                     const Bits &sam2) {
+    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
+    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
+    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
+  }
+
+  FloatingPointUnion u_;
+};
+
+// We cannot use std::numeric_limits<T>::max() as it clashes with the max()
+// macro defined by <windows.h>.
+template <>
+inline float FloatingPoint<float>::Max() { return FLT_MAX; }
+template <>
+inline double FloatingPoint<double>::Max() { return DBL_MAX; }
+
+// Typedefs the instances of the FloatingPoint template class that we
+// care to use.
+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 case, 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
+// them for equality using the == operator.
+typedef const void* TypeId;
+
+template <typename T>
+class TypeIdHelper {
+ public:
+  // dummy_ must not have a const type.  Otherwise an overly eager
+  // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
+  // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
+  static bool dummy_;
+};
+
+template <typename T>
+bool TypeIdHelper<T>::dummy_ = false;
+
+// GetTypeId<T>() returns the ID of type T.  Different values will be
+// returned for different types.  Calling the function twice with the
+// same type argument is guaranteed to return the same ID.
+template <typename T>
+TypeId GetTypeId() {
+  // The compiler is required to allocate a different
+  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
+  // the template.  Therefore, the address of dummy_ is guaranteed to
+  // be unique.
+  return &(TypeIdHelper<T>::dummy_);
+}
+
+// Returns the type ID of ::testing::Test.  Always call this instead
+// of GetTypeId< ::testing::Test>() to get the type ID of
+// ::testing::Test, as the latter may give the wrong result due to a
+// suspected linker bug when compiling Google Test as a Mac OS X
+// framework.
+GTEST_API_ TypeId GetTestTypeId();
+
+// Defines the abstract factory interface that creates instances
+// of a Test object.
+class TestFactoryBase {
+ public:
+  virtual ~TestFactoryBase() {}
+
+  // Creates a test instance to run. The instance is both created and destroyed
+  // within TestInfoImpl::Run()
+  virtual Test* CreateTest() = 0;
+
+ protected:
+  TestFactoryBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
+};
+
+// This class provides implementation of TeastFactoryBase interface.
+// It is used in TEST and TEST_F macros.
+template <class TestClass>
+class TestFactoryImpl : public TestFactoryBase {
+ public:
+  virtual Test* CreateTest() { return new TestClass; }
+};
+
+#if GTEST_OS_WINDOWS
+
+// Predicate-formatters for implementing the HRESULT checking macros
+// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
+// We pass a long instead of HRESULT to avoid causing an
+// include dependency for the HRESULT type.
+GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
+                                            long hr);  // NOLINT
+GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
+                                            long hr);  // NOLINT
+
+#endif  // GTEST_OS_WINDOWS
+
+// Types of SetUpTestCase() and TearDownTestCase() functions.
+typedef void (*SetUpTestCaseFunc)();
+typedef void (*TearDownTestCaseFunc)();
+
+struct CodeLocation {
+  CodeLocation(const string& a_file, int a_line) : file(a_file), line(a_line) {}
+
+  string file;
+  int line;
+};
+
+// Creates a new TestInfo object and registers it with Google Test;
+// returns the created object.
+//
+// Arguments:
+//
+//   test_case_name:   name of the test case
+//   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.
+//   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 case
+//   tear_down_tc:     pointer to the function that tears down the test case
+//   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_case_name,
+    const char* name,
+    const char* type_param,
+    const char* value_param,
+    CodeLocation code_location,
+    TypeId fixture_class_id,
+    SetUpTestCaseFunc set_up_tc,
+    TearDownTestCaseFunc 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);
+
+#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+
+// State of the definition of a type-parameterized test case.
+class GTEST_API_ TypedTestCasePState {
+ public:
+  TypedTestCasePState() : registered_(false) {}
+
+  // Adds the given test name to defined_test_names_ and return true
+  // if the test case 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_CASE_P(%s, ...).\n",
+              FormatFileLocation(file, line).c_str(), test_name, case_name);
+      fflush(stderr);
+      posix::Abort();
+    }
+    registered_tests_.insert(
+        ::std::make_pair(test_name, CodeLocation(file, line)));
+    return true;
+  }
+
+  bool TestExists(const std::string& test_name) const {
+    return registered_tests_.count(test_name) > 0;
+  }
+
+  const CodeLocation& GetCodeLocation(const std::string& test_name) const {
+    RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name);
+    GTEST_CHECK_(it != registered_tests_.end());
+    return it->second;
+  }
+
+  // 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* file, int line, const char* registered_tests);
+
+ private:
+  typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;
+
+  bool registered_;
+  RegisteredTestsMap registered_tests_;
+};
+
+// 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 == NULL) {
+    return NULL;
+  }
+  while (IsSpace(*(++comma))) {}
+  return comma;
+}
+
+// Returns the prefix of 'str' before the first comma in it; returns
+// the entire string if it contains no comma.
+inline std::string GetPrefixUntilComma(const char* str) {
+  const char* comma = strchr(str, ',');
+  return comma == NULL ? str : std::string(str, comma);
+}
+
+// Splits a given string on a given delimiter, populating a given
+// vector with the fields.
+void SplitString(const ::std::string& str, char delimiter,
+                 ::std::vector< ::std::string>* dest);
+
+// 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
+// such that we can call this function in a namespace scope.
+//
+// Implementation note: The GTEST_TEMPLATE_ macro declares a template
+// template parameter.  It's defined in gtest-type-util.h.
+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_CASE_P(Prefix, TestCase,
+  // Types).  Valid values for 'index' are [0, N - 1] where N is the
+  // length of Types.
+  static bool Register(const char* prefix,
+                       CodeLocation code_location,
+                       const char* case_name, const char* test_names,
+                       int index) {
+    typedef typename Types::Head Type;
+    typedef Fixture<Type> FixtureClass;
+    typedef typename GTEST_BIND_(TestSel, Type) TestClass;
+
+    // First, registers the first type-parameterized test in the type
+    // list.
+    MakeAndRegisterTestInfo(
+        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
+         + StreamableToString(index)).c_str(),
+        StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
+        GetTypeName<Type>().c_str(),
+        NULL,  // No value parameter.
+        code_location,
+        GetTypeId<FixtureClass>(),
+        TestClass::SetUpTestCase,
+        TestClass::TearDownTestCase,
+        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);
+  }
+};
+
+// The base case for the compile time recursion.
+template <GTEST_TEMPLATE_ Fixture, class TestSel>
+class TypeParameterizedTest<Fixture, TestSel, Types0> {
+ public:
+  static bool Register(const char* /*prefix*/, CodeLocation,
+                       const char* /*case_name*/, const char* /*test_names*/,
+                       int /*index*/) {
+    return true;
+  }
+};
+
+// TypeParameterizedTestCase<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 TypeParameterizedTestCase {
+ public:
+  static bool Register(const char* prefix, CodeLocation code_location,
+                       const TypedTestCasePState* state,
+                       const char* case_name, const char* test_names) {
+    std::string test_name = StripTrailingSpaces(
+        GetPrefixUntilComma(test_names));
+    if (!state->TestExists(test_name)) {
+      fprintf(stderr, "Failed to get code location for test %s.%s at %s.",
+              case_name, test_name.c_str(),
+              FormatFileLocation(code_location.file.c_str(),
+                                 code_location.line).c_str());
+      fflush(stderr);
+      posix::Abort();
+    }
+    const CodeLocation& test_location = state->GetCodeLocation(test_name);
+
+    typedef typename Tests::Head Head;
+
+    // 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);
+
+    // Next, recurses (at compile time) with the tail of the test list.
+    return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types>
+        ::Register(prefix, code_location, state,
+                   case_name, SkipComma(test_names));
+  }
+};
+
+// The base case for the compile time recursion.
+template <GTEST_TEMPLATE_ Fixture, typename Types>
+class TypeParameterizedTestCase<Fixture, Templates0, Types> {
+ public:
+  static bool Register(const char* /*prefix*/, CodeLocation,
+                       const TypedTestCasePState* /*state*/,
+                       const char* /*case_name*/, const char* /*test_names*/) {
+    return true;
+  }
+};
+
+#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
+// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
+GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
+    UnitTest* unit_test, int skip_count);
+
+// Helpers for suppressing warnings on unreachable code or constant
+// condition.
+
+// Always returns true.
+GTEST_API_ bool AlwaysTrue();
+
+// Always returns false.
+inline bool AlwaysFalse() { return !AlwaysTrue(); }
+
+// Helper for suppressing false warning from Clang on a const char*
+// variable declared in a conditional expression always being NULL in
+// the else branch.
+struct GTEST_API_ ConstCharPtr {
+  ConstCharPtr(const char* str) : value(str) {}
+  operator bool() const { return true; }
+  const char* 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
+// code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
+// but it's good enough for our purposes.
+class GTEST_API_ Random {
+ public:
+  static const UInt32 kMaxRange = 1u << 31;
+
+  explicit Random(UInt32 seed) : state_(seed) {}
+
+  void Reseed(UInt32 seed) { state_ = seed; }
+
+  // Generates a random number from [0, range).  Crashes if 'range' is
+  // 0 or greater than kMaxRange.
+  UInt32 Generate(UInt32 range);
+
+ private:
+  UInt32 state_;
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
+};
+
+// Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a
+// compiler error iff T1 and T2 are different types.
+template <typename T1, typename T2>
+struct CompileAssertTypesEqual;
+
+template <typename T>
+struct CompileAssertTypesEqual<T, T> {
+};
+
+// Removes the reference from a type if it is a reference type,
+// otherwise leaves it unchanged.  This is the same as
+// tr1::remove_reference, which is not widely available yet.
+template <typename T>
+struct RemoveReference { typedef T type; };  // NOLINT
+template <typename T>
+struct RemoveReference<T&> { typedef T type; };  // NOLINT
+
+// A handy wrapper around RemoveReference that works when the argument
+// T depends on template parameters.
+#define GTEST_REMOVE_REFERENCE_(T) \
+    typename ::testing::internal::RemoveReference<T>::type
+
+// Removes const from a type if it is a const type, otherwise leaves
+// it unchanged.  This is the same as tr1::remove_const, which is not
+// widely available yet.
+template <typename T>
+struct RemoveConst { typedef T type; };  // NOLINT
+template <typename T>
+struct RemoveConst<const T> { typedef T type; };  // NOLINT
+
+// MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
+// definition to fail to remove the const in 'const int[3]' and 'const
+// char[3][4]'.  The following specialization works around the bug.
+template <typename T, size_t N>
+struct RemoveConst<const T[N]> {
+  typedef typename RemoveConst<T>::type type[N];
+};
+
+#if defined(_MSC_VER) && _MSC_VER < 1400
+// This is the only specialization that allows VC++ 7.1 to remove const in
+// 'const int[3] and 'const int[3][4]'.  However, it causes trouble with GCC
+// and thus needs to be conditionally compiled.
+template <typename T, size_t N>
+struct RemoveConst<T[N]> {
+  typedef typename RemoveConst<T>::type type[N];
+};
+#endif
+
+// A handy wrapper around RemoveConst that works when the argument
+// T depends on template parameters.
+#define GTEST_REMOVE_CONST_(T) \
+    typename ::testing::internal::RemoveConst<T>::type
+
+// Turns const U&, U&, const U, and U all into U.
+#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
+    GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))
+
+// Adds reference to a type if it is not a reference type,
+// otherwise leaves it unchanged.  This is the same as
+// tr1::add_reference, which is not widely available yet.
+template <typename T>
+struct AddReference { typedef T& type; };  // NOLINT
+template <typename T>
+struct AddReference<T&> { typedef T& type; };  // NOLINT
+
+// A handy wrapper around AddReference that works when the argument T
+// depends on template parameters.
+#define GTEST_ADD_REFERENCE_(T) \
+    typename ::testing::internal::AddReference<T>::type
+
+// Adds a reference to const on top of T as necessary.  For example,
+// it transforms
+//
+//   char         ==> const char&
+//   const char   ==> const char&
+//   char&        ==> const char&
+//   const char&  ==> const char&
+//
+// The argument T must depend on some template parameters.
+#define GTEST_REFERENCE_TO_CONST_(T) \
+    GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T))
+
+// ImplicitlyConvertible<From, To>::value is a compile-time bool
+// constant that's true iff type From can be implicitly converted to
+// type To.
+template <typename From, typename To>
+class ImplicitlyConvertible {
+ private:
+  // We need the following helper functions only for their types.
+  // They have no implementations.
+
+  // MakeFrom() is an expression whose type is From.  We cannot simply
+  // use From(), as the type From may not have a public default
+  // constructor.
+  static typename AddReference<From>::type MakeFrom();
+
+  // These two functions are overloaded.  Given an expression
+  // Helper(x), the compiler will pick the first version if x can be
+  // implicitly converted to type To; otherwise it will pick the
+  // second version.
+  //
+  // The first version returns a value of size 1, and the second
+  // version returns a value of size 2.  Therefore, by checking the
+  // size of Helper(x), which can be done at compile time, we can tell
+  // which version of Helper() is used, and hence whether x can be
+  // implicitly converted to type To.
+  static char Helper(To);
+  static char (&Helper(...))[2];  // NOLINT
+
+  // We have to put the 'public' section after the 'private' section,
+  // or MSVC refuses to compile the code.
+ public:
+#if defined(__BORLANDC__)
+  // C++Builder cannot use member overload resolution during template
+  // instantiation.  The simplest workaround is to use its C++0x type traits
+  // functions (C++Builder 2009 and above only).
+  static const bool value = __is_convertible(From, To);
+#else
+  // MSVC warns about implicitly converting from double to int for
+  // possible loss of data, so we need to temporarily disable the
+  // warning.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4244)
+  static const bool value =
+      sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif  // __BORLANDC__
+};
+template <typename From, typename To>
+const bool ImplicitlyConvertible<From, To>::value;
+
+// IsAProtocolMessage<T>::value is a compile-time bool constant that's
+// true iff T is type ProtocolMessage, proto2::Message, or a subclass
+// of those.
+template <typename T>
+struct IsAProtocolMessage
+    : public bool_constant<
+  ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value ||
+  ImplicitlyConvertible<const T*, const ::proto2::Message*>::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
+// valid types and NULL can be implicitly converted to them).  It will
+// be picked over the second overload as 'int' is a perfect match for
+// the type of argument 0.  If C::iterator or C::const_iterator is not
+// a valid type, the first overload is not viable, and the second
+// overload will be picked.  Therefore, we can determine whether C is
+// a container class by checking the type of IsContainerTest<C>(0).
+// The value of the expression is insignificant.
+//
+// Note 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
+// iterator is an STL container.
+//
+// Also note that the simpler approach of overloading
+// IsContainerTest(typename C::const_iterator*) and
+// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
+typedef int IsContainer;
+template <class C>
+IsContainer IsContainerTest(int /* dummy */,
+                            typename C::iterator* /* it */ = NULL,
+                            typename C::const_iterator* /* const_it */ = NULL) {
+  return 0;
+}
+
+typedef char IsNotContainer;
+template <class C>
+IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
+
+// EnableIf<condition>::type is void when 'Cond' is true, and
+// undefined when 'Cond' is false.  To use SFINAE to make a function
+// overload only apply when a particular expression is true, add
+// "typename EnableIf<expression>::type* = 0" as the last parameter.
+template<bool> struct EnableIf;
+template<> struct EnableIf<true> { typedef void type; };  // NOLINT
+
+// Utilities for native arrays.
+
+// ArrayEq() compares two k-dimensional native arrays using the
+// elements' operator==, where k can be any integer >= 0.  When k is
+// 0, ArrayEq() degenerates into comparing a single pair of values.
+
+template <typename T, typename U>
+bool ArrayEq(const T* lhs, size_t size, const U* rhs);
+
+// This generic version is used when k is 0.
+template <typename T, typename U>
+inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
+
+// This overload is used when k >= 1.
+template <typename T, typename U, size_t N>
+inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
+  return internal::ArrayEq(lhs, N, rhs);
+}
+
+// This helper reduces code bloat.  If we instead put its logic inside
+// the previous ArrayEq() function, arrays with different sizes would
+// lead to different copies of the template code.
+template <typename T, typename U>
+bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
+  for (size_t i = 0; i != size; i++) {
+    if (!internal::ArrayEq(lhs[i], rhs[i]))
+      return false;
+  }
+  return true;
+}
+
+// Finds the first element in the iterator range [begin, end) that
+// equals elem.  Element may be a native array type itself.
+template <typename Iter, typename Element>
+Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
+  for (Iter it = begin; it != end; ++it) {
+    if (internal::ArrayEq(*it, elem))
+      return it;
+  }
+  return end;
+}
+
+// CopyArray() copies a k-dimensional native array using the elements'
+// operator=, where k can be any integer >= 0.  When k is 0,
+// CopyArray() degenerates into copying a single value.
+
+template <typename T, typename U>
+void CopyArray(const T* from, size_t size, U* to);
+
+// This generic version is used when k is 0.
+template <typename T, typename U>
+inline void CopyArray(const T& from, U* to) { *to = from; }
+
+// This overload is used when k >= 1.
+template <typename T, typename U, size_t N>
+inline void CopyArray(const T(&from)[N], U(*to)[N]) {
+  internal::CopyArray(from, N, *to);
+}
+
+// This helper reduces code bloat.  If we instead put its logic inside
+// the previous CopyArray() function, arrays with different sizes
+// would lead to different copies of the template code.
+template <typename T, typename U>
+void CopyArray(const T* from, size_t size, U* to) {
+  for (size_t i = 0; i != size; i++) {
+    internal::CopyArray(from[i], to + i);
+  }
+}
+
+// The relation between an NativeArray object (see below) and the
+// native array it represents.
+// We use 2 different structs to allow non-copyable types to be used, as long
+// as RelationToSourceReference() is passed.
+struct RelationToSourceReference {};
+struct RelationToSourceCopy {};
+
+// Adapts a native array to a read-only STL-style container.  Instead
+// of the complete STL container concept, this adaptor only implements
+// members useful for Google Mock's container matchers.  New members
+// should be added as needed.  To simplify the implementation, we only
+// support Element being a raw type (i.e. having no top-level const or
+// reference modifier).  It's the client's responsibility to satisfy
+// this requirement.  Element can be an array type itself (hence
+// multi-dimensional arrays are supported).
+template <typename Element>
+class NativeArray {
+ public:
+  // STL-style container typedefs.
+  typedef Element value_type;
+  typedef Element* iterator;
+  typedef const Element* const_iterator;
+
+  // Constructs from a native array. References the source.
+  NativeArray(const Element* array, size_t count, RelationToSourceReference) {
+    InitRef(array, count);
+  }
+
+  // Constructs from a native array. Copies the source.
+  NativeArray(const Element* array, size_t count, RelationToSourceCopy) {
+    InitCopy(array, count);
+  }
+
+  // Copy constructor.
+  NativeArray(const NativeArray& rhs) {
+    (this->*rhs.clone_)(rhs.array_, rhs.size_);
+  }
+
+  ~NativeArray() {
+    if (clone_ != &NativeArray::InitRef)
+      delete[] array_;
+  }
+
+  // STL-style container methods.
+  size_t size() const { return size_; }
+  const_iterator begin() const { return array_; }
+  const_iterator end() const { return array_ + size_; }
+  bool operator==(const NativeArray& rhs) const {
+    return size() == rhs.size() &&
+        ArrayEq(begin(), size(), rhs.begin());
+  }
+
+ private:
+  enum {
+    kCheckTypeIsNotConstOrAReference = StaticAssertTypeEqHelper<
+        Element, GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>::value,
+  };
+
+  // Initializes this object with a copy of the input.
+  void InitCopy(const Element* array, size_t a_size) {
+    Element* const copy = new Element[a_size];
+    CopyArray(array, a_size, copy);
+    array_ = copy;
+    size_ = a_size;
+    clone_ = &NativeArray::InitCopy;
+  }
+
+  // Initializes this object with a reference of the input.
+  void InitRef(const Element* array, size_t a_size) {
+    array_ = array;
+    size_ = a_size;
+    clone_ = &NativeArray::InitRef;
+  }
+
+  const Element* array_;
+  size_t size_;
+  void (NativeArray::*clone_)(const Element*, size_t);
+
+  GTEST_DISALLOW_ASSIGN_(NativeArray);
+};
+
+}  // namespace internal
+}  // namespace testing
+
+#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
+  ::testing::internal::AssertHelper(result_type, file, line, message) \
+    = ::testing::Message()
+
+#define GTEST_MESSAGE_(message, result_type) \
+  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
+
+#define GTEST_FATAL_FAILURE_(message) \
+  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
+
+#define GTEST_NONFATAL_FAILURE_(message) \
+  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
+
+#define GTEST_SUCCESS_(message) \
+  GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
+
+// Suppresses MSVC warnings 4072 (unreachable code) for the code following
+// statement if it returns or throws (or doesn't return or throw in some
+// situations).
+#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
+  if (::testing::internal::AlwaysTrue()) { statement; }
+
+#define GTEST_TEST_THROW_(statement, expected_exception, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::ConstCharPtr gtest_msg = "") { \
+    bool gtest_caught_expected = false; \
+    try { \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    } \
+    catch (expected_exception const&) { \
+      gtest_caught_expected = true; \
+    } \
+    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 \
+    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
+      fail(gtest_msg.value)
+
+#define GTEST_TEST_NO_THROW_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    try { \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    } \
+    catch (...) { \
+      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: it throws.")
+
+#define GTEST_TEST_ANY_THROW_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    bool gtest_caught_any = false; \
+    try { \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    } \
+    catch (...) { \
+      gtest_caught_any = true; \
+    } \
+    if (!gtest_caught_any) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
+      fail("Expected: " #statement " throws an exception.\n" \
+           "  Actual: it doesn't.")
+
+
+// Implements Boolean test assertions such as EXPECT_TRUE. expression can be
+// either a boolean expression or an AssertionResult. text is a textual
+// represenation 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_ = \
+      ::testing::AssertionResult(expression)) \
+    ; \
+  else \
+    fail(::testing::internal::GetBoolAssertionFailureMessage(\
+        gtest_ar_, text, #actual, #expected).c_str())
+
+#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
+      fail("Expected: " #statement " doesn't generate new fatal " \
+           "failures in the current thread.\n" \
+           "  Actual: it does.")
+
+// Expands to the name of the class that implements the given test.
+#define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
+  test_case_name##_##test_name##_Test
+
+// Helper macro for defining tests.
+#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
+class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
+ public:\
+  GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\
+ private:\
+  virtual void TestBody();\
+  static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(\
+      GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
+};\
+\
+::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
+  ::test_info_ =\
+    ::testing::internal::MakeAndRegisterTestInfo(\
+        #test_case_name, #test_name, NULL, NULL, \
+        ::testing::internal::CodeLocation(__FILE__, __LINE__), \
+        (parent_id), \
+        parent_class::SetUpTestCase, \
+        parent_class::TearDownTestCase, \
+        new ::testing::internal::TestFactoryImpl<\
+            GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
+void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-linked_ptr.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-linked_ptr.h
new file mode 100644
index 00000000..36029422
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-linked_ptr.h
@@ -0,0 +1,243 @@
+// Copyright 2003 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.
+//
+// Authors: Dan Egnor (egnor@google.com)
+//
+// A "smart" pointer type with reference tracking.  Every pointer to a
+// particular object is kept on a circular linked list.  When the last pointer
+// to an object is destroyed or reassigned, the object is deleted.
+//
+// Used properly, this deletes the object when the last reference goes away.
+// There are several caveats:
+// - Like all reference counting schemes, cycles lead to leaks.
+// - Each smart pointer is actually two pointers (8 bytes instead of 4).
+// - Every time a pointer is assigned, the entire list of pointers to that
+//   object is traversed.  This class is therefore NOT SUITABLE when there
+//   will often be more than two or three pointers to a particular object.
+// - References are only tracked as long as linked_ptr<> objects are copied.
+//   If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
+//   will happen (double deletion).
+//
+// A good use of this class is storing object references in STL containers.
+// You can safely put linked_ptr<> in a vector<>.
+// Other uses may not be as good.
+//
+// Note: If you use an incomplete type with linked_ptr<>, the class
+// *containing* linked_ptr<> must have a constructor and destructor (even
+// if they do nothing!).
+//
+// Bill Gibbons suggested we use something like this.
+//
+// Thread Safety:
+//   Unlike other linked_ptr implementations, in this implementation
+//   a linked_ptr object is thread-safe in the sense that:
+//     - it's safe to copy linked_ptr objects concurrently,
+//     - it's safe to copy *from* a linked_ptr and read its underlying
+//       raw pointer (e.g. via get()) concurrently, and
+//     - it's safe to write to two linked_ptrs that point to the same
+//       shared object concurrently.
+// TODO(wan@google.com): rename this to safe_linked_ptr to avoid
+// confusion with normal linked_ptr.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
+
+#include <stdlib.h>
+#include <assert.h>
+
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+namespace internal {
+
+// Protects copying of all linked_ptr objects.
+GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_linked_ptr_mutex);
+
+// This is used internally by all instances of linked_ptr<>.  It needs to be
+// a non-template class because different types of linked_ptr<> can refer to
+// the same object (linked_ptr<Superclass>(obj) vs linked_ptr<Subclass>(obj)).
+// So, it needs to be possible for different types of linked_ptr to participate
+// in the same circular linked list, so we need a single class type here.
+//
+// DO NOT USE THIS CLASS DIRECTLY YOURSELF.  Use linked_ptr<T>.
+class linked_ptr_internal {
+ public:
+  // Create a new circle that includes only this instance.
+  void join_new() {
+    next_ = this;
+  }
+
+  // Many linked_ptr operations may change p.link_ for some linked_ptr
+  // variable p in the same circle as this object.  Therefore we need
+  // to prevent two such operations from occurring concurrently.
+  //
+  // Note that different types of linked_ptr objects can coexist in a
+  // circle (e.g. linked_ptr<Base>, linked_ptr<Derived1>, and
+  // linked_ptr<Derived2>).  Therefore we must use a single mutex to
+  // protect all linked_ptr objects.  This can create serious
+  // contention in production code, but is acceptable in a testing
+  // framework.
+
+  // Join an existing circle.
+  void join(linked_ptr_internal const* ptr)
+      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
+    MutexLock lock(&g_linked_ptr_mutex);
+
+    linked_ptr_internal const* p = ptr;
+    while (p->next_ != ptr) {
+      assert(p->next_ != this &&
+             "Trying to join() a linked ring we are already in. "
+             "Is GMock thread safety enabled?");
+      p = p->next_;
+    }
+    p->next_ = this;
+    next_ = ptr;
+  }
+
+  // Leave whatever circle we're part of.  Returns true if we were the
+  // last member of the circle.  Once this is done, you can join() another.
+  bool depart()
+      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
+    MutexLock lock(&g_linked_ptr_mutex);
+
+    if (next_ == this) return true;
+    linked_ptr_internal const* p = next_;
+    while (p->next_ != this) {
+      assert(p->next_ != next_ &&
+             "Trying to depart() a linked ring we are not in. "
+             "Is GMock thread safety enabled?");
+      p = p->next_;
+    }
+    p->next_ = next_;
+    return false;
+  }
+
+ private:
+  mutable linked_ptr_internal const* next_;
+};
+
+template <typename T>
+class linked_ptr {
+ public:
+  typedef T element_type;
+
+  // Take over ownership of a raw pointer.  This should happen as soon as
+  // possible after the object is created.
+  explicit linked_ptr(T* ptr = NULL) { capture(ptr); }
+  ~linked_ptr() { depart(); }
+
+  // Copy an existing linked_ptr<>, adding ourselves to the list of references.
+  template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); }
+  linked_ptr(linked_ptr const& ptr) {  // NOLINT
+    assert(&ptr != this);
+    copy(&ptr);
+  }
+
+  // Assignment releases the old value and acquires the new.
+  template <typename U> linked_ptr& operator=(linked_ptr<U> const& ptr) {
+    depart();
+    copy(&ptr);
+    return *this;
+  }
+
+  linked_ptr& operator=(linked_ptr const& ptr) {
+    if (&ptr != this) {
+      depart();
+      copy(&ptr);
+    }
+    return *this;
+  }
+
+  // Smart pointer members.
+  void reset(T* ptr = NULL) {
+    depart();
+    capture(ptr);
+  }
+  T* get() const { return value_; }
+  T* operator->() const { return value_; }
+  T& operator*() const { return *value_; }
+
+  bool operator==(T* p) const { return value_ == p; }
+  bool operator!=(T* p) const { return value_ != p; }
+  template <typename U>
+  bool operator==(linked_ptr<U> const& ptr) const {
+    return value_ == ptr.get();
+  }
+  template <typename U>
+  bool operator!=(linked_ptr<U> const& ptr) const {
+    return value_ != ptr.get();
+  }
+
+ private:
+  template <typename U>
+  friend class linked_ptr;
+
+  T* value_;
+  linked_ptr_internal link_;
+
+  void depart() {
+    if (link_.depart()) delete value_;
+  }
+
+  void capture(T* ptr) {
+    value_ = ptr;
+    link_.join_new();
+  }
+
+  template <typename U> void copy(linked_ptr<U> const* ptr) {
+    value_ = ptr->get();
+    if (value_)
+      link_.join(&ptr->link_);
+    else
+      link_.join_new();
+  }
+};
+
+template<typename T> inline
+bool operator==(T* ptr, const linked_ptr<T>& x) {
+  return ptr == x.get();
+}
+
+template<typename T> inline
+bool operator!=(T* ptr, const linked_ptr<T>& x) {
+  return ptr != x.get();
+}
+
+// A function to convert T* into linked_ptr<T>
+// Doing e.g. make_linked_ptr(new FooBarBaz<type>(arg)) is a shorter notation
+// for linked_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
+template <typename T>
+linked_ptr<T> make_linked_ptr(T* ptr) {
+  return linked_ptr<T>(ptr);
+}
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h
new file mode 100644
index 00000000..4d1d81d2
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h
@@ -0,0 +1,5146 @@
+// This file was GENERATED by command:
+//     pump.py gtest-param-util-generated.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+
+// Type and function utilities for implementing parameterized tests.
+// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
+//
+// Currently Google Test supports at most 50 arguments in Values,
+// and at most 10 arguments in Combine. Please contact
+// googletestframework@googlegroups.com if you need more.
+// Please note that the number of arguments to Combine is limited
+// by the maximum arity of the implementation of tuple which is
+// currently set at 10.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
+
+// scripts/fuse_gtest.py depends on gtest's own header being #included
+// *unconditionally*.  Therefore these #includes cannot be moved
+// inside #if GTEST_HAS_PARAM_TEST.
+#include "gtest/internal/gtest-param-util.h"
+#include "gtest/internal/gtest-port.h"
+
+#if GTEST_HAS_PARAM_TEST
+
+namespace testing {
+
+// Forward declarations of ValuesIn(), which is implemented in
+// include/gtest/gtest-param-test.h.
+template <typename ForwardIterator>
+internal::ParamGenerator<
+  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
+ValuesIn(ForwardIterator begin, ForwardIterator end);
+
+template <typename T, size_t N>
+internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);
+
+template <class Container>
+internal::ParamGenerator<typename Container::value_type> ValuesIn(
+    const Container& container);
+
+namespace internal {
+
+// Used in the Values() function to provide polymorphic capabilities.
+template <typename T1>
+class ValueArray1 {
+ public:
+  explicit ValueArray1(T1 v1) : v1_(v1) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray1& other);
+
+  const T1 v1_;
+};
+
+template <typename T1, typename T2>
+class ValueArray2 {
+ public:
+  ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray2& other);
+
+  const T1 v1_;
+  const T2 v2_;
+};
+
+template <typename T1, typename T2, typename T3>
+class ValueArray3 {
+ public:
+  ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray3& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4>
+class ValueArray4 {
+ public:
+  ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray4& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+class ValueArray5 {
+ public:
+  ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4), v5_(v5) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray5& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+class ValueArray6 {
+ public:
+  ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1), v2_(v2),
+      v3_(v3), v4_(v4), v5_(v5), v6_(v6) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray6& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+class ValueArray7 {
+ public:
+  ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1),
+      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray7& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+class ValueArray8 {
+ public:
+  ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
+      T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray8& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+class ValueArray9 {
+ public:
+  ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
+      T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray9& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+class ValueArray10 {
+ public:
+  ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray10& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11>
+class ValueArray11 {
+ public:
+  ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
+      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray11& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12>
+class ValueArray12 {
+ public:
+  ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
+      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray12& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13>
+class ValueArray13 {
+ public:
+  ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
+      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
+      v12_(v12), v13_(v13) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray13& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14>
+class ValueArray14 {
+ public:
+  ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray14& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15>
+class ValueArray15 {
+ public:
+  ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1), v2_(v2),
+      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray15& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16>
+class ValueArray16 {
+ public:
+  ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) : v1_(v1),
+      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
+      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
+      v16_(v16) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray16& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17>
+class ValueArray17 {
+ public:
+  ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
+      T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray17& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18>
+class ValueArray18 {
+ public:
+  ValueArray18(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray18& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19>
+class ValueArray19 {
+ public:
+  ValueArray19(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
+      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
+      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray19& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20>
+class ValueArray20 {
+ public:
+  ValueArray20(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
+      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
+      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
+      v19_(v19), v20_(v20) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray20& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21>
+class ValueArray21 {
+ public:
+  ValueArray21(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
+      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
+      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
+      v18_(v18), v19_(v19), v20_(v20), v21_(v21) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray21& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22>
+class ValueArray22 {
+ public:
+  ValueArray22(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray22& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23>
+class ValueArray23 {
+ public:
+  ValueArray23(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) : v1_(v1), v2_(v2),
+      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray23& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24>
+class ValueArray24 {
+ public:
+  ValueArray24(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) : v1_(v1),
+      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
+      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
+      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
+      v22_(v22), v23_(v23), v24_(v24) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray24& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25>
+class ValueArray25 {
+ public:
+  ValueArray25(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
+      T25 v25) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray25& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26>
+class ValueArray26 {
+ public:
+  ValueArray26(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray26& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27>
+class ValueArray27 {
+ public:
+  ValueArray27(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
+      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
+      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
+      v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
+      v26_(v26), v27_(v27) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray27& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28>
+class ValueArray28 {
+ public:
+  ValueArray28(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
+      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
+      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
+      v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
+      v25_(v25), v26_(v26), v27_(v27), v28_(v28) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray28& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29>
+class ValueArray29 {
+ public:
+  ValueArray29(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
+      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
+      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
+      v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
+      v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray29& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30>
+class ValueArray30 {
+ public:
+  ValueArray30(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
+      v29_(v29), v30_(v30) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray30& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31>
+class ValueArray31 {
+ public:
+  ValueArray31(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) : v1_(v1), v2_(v2),
+      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
+      v29_(v29), v30_(v30), v31_(v31) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray31& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32>
+class ValueArray32 {
+ public:
+  ValueArray32(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32) : v1_(v1),
+      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
+      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
+      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
+      v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
+      v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray32& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33>
+class ValueArray33 {
+ public:
+  ValueArray33(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
+      T33 v33) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
+      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
+      v33_(v33) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray33& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34>
+class ValueArray34 {
+ public:
+  ValueArray34(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
+      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
+      v33_(v33), v34_(v34) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray34& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35>
+class ValueArray35 {
+ public:
+  ValueArray35(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
+      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
+      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
+      v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
+      v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
+      v32_(v32), v33_(v33), v34_(v34), v35_(v35) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray35& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36>
+class ValueArray36 {
+ public:
+  ValueArray36(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
+      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
+      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
+      v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
+      v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
+      v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray36& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37>
+class ValueArray37 {
+ public:
+  ValueArray37(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
+      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
+      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
+      v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
+      v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
+      v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
+      v36_(v36), v37_(v37) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray37& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38>
+class ValueArray38 {
+ public:
+  ValueArray38(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
+      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
+      v35_(v35), v36_(v36), v37_(v37), v38_(v38) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray38& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39>
+class ValueArray39 {
+ public:
+  ValueArray39(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39) : v1_(v1), v2_(v2),
+      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
+      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
+      v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray39& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40>
+class ValueArray40 {
+ public:
+  ValueArray40(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) : v1_(v1),
+      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
+      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
+      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
+      v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
+      v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
+      v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
+      v40_(v40) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray40& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41>
+class ValueArray41 {
+ public:
+  ValueArray41(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
+      T41 v41) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
+      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
+      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
+      v39_(v39), v40_(v40), v41_(v41) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray41& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42>
+class ValueArray42 {
+ public:
+  ValueArray42(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
+      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
+      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
+      v39_(v39), v40_(v40), v41_(v41), v42_(v42) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray42& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43>
+class ValueArray43 {
+ public:
+  ValueArray43(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
+      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
+      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
+      v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
+      v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
+      v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37),
+      v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray43& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44>
+class ValueArray44 {
+ public:
+  ValueArray44(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
+      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
+      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
+      v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
+      v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
+      v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36),
+      v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42),
+      v43_(v43), v44_(v44) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray44& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45>
+class ValueArray45 {
+ public:
+  ValueArray45(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44, T45 v45) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
+      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
+      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
+      v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
+      v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
+      v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
+      v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41),
+      v42_(v42), v43_(v43), v44_(v44), v45_(v45) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray45& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+  const T45 v45_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46>
+class ValueArray46 {
+ public:
+  ValueArray46(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) : v1_(v1), v2_(v2), v3_(v3),
+      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
+      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
+      v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
+      v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray46& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+  const T45 v45_;
+  const T46 v46_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47>
+class ValueArray47 {
+ public:
+  ValueArray47(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) : v1_(v1), v2_(v2),
+      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
+      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
+      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
+      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
+      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
+      v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
+      v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46),
+      v47_(v47) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray47& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+  const T45 v45_;
+  const T46 v46_;
+  const T47 v47_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48>
+class ValueArray48 {
+ public:
+  ValueArray48(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48) : v1_(v1),
+      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
+      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
+      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
+      v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
+      v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
+      v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
+      v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45),
+      v46_(v46), v47_(v47), v48_(v48) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
+        static_cast<T>(v48_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray48& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+  const T45 v45_;
+  const T46 v46_;
+  const T47 v47_;
+  const T48 v48_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49>
+class ValueArray49 {
+ public:
+  ValueArray49(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48,
+      T49 v49) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
+      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
+      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
+      v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
+      v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
+        static_cast<T>(v48_), static_cast<T>(v49_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray49& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+  const T45 v45_;
+  const T46 v46_;
+  const T47 v47_;
+  const T48 v48_;
+  const T49 v49_;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49, typename T50>
+class ValueArray50 {
+ public:
+  ValueArray50(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
+      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
+      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
+      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
+      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
+      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49,
+      T50 v50) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
+      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
+      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
+      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
+      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
+      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
+      v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
+      v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49), v50_(v50) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
+        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
+        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
+        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
+        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
+        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
+        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
+        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
+        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
+        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
+        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
+        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
+        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
+        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
+        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
+        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
+        static_cast<T>(v48_), static_cast<T>(v49_), static_cast<T>(v50_)};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray50& other);
+
+  const T1 v1_;
+  const T2 v2_;
+  const T3 v3_;
+  const T4 v4_;
+  const T5 v5_;
+  const T6 v6_;
+  const T7 v7_;
+  const T8 v8_;
+  const T9 v9_;
+  const T10 v10_;
+  const T11 v11_;
+  const T12 v12_;
+  const T13 v13_;
+  const T14 v14_;
+  const T15 v15_;
+  const T16 v16_;
+  const T17 v17_;
+  const T18 v18_;
+  const T19 v19_;
+  const T20 v20_;
+  const T21 v21_;
+  const T22 v22_;
+  const T23 v23_;
+  const T24 v24_;
+  const T25 v25_;
+  const T26 v26_;
+  const T27 v27_;
+  const T28 v28_;
+  const T29 v29_;
+  const T30 v30_;
+  const T31 v31_;
+  const T32 v32_;
+  const T33 v33_;
+  const T34 v34_;
+  const T35 v35_;
+  const T36 v36_;
+  const T37 v37_;
+  const T38 v38_;
+  const T39 v39_;
+  const T40 v40_;
+  const T41 v41_;
+  const T42 v42_;
+  const T43 v43_;
+  const T44 v44_;
+  const T45 v45_;
+  const T46 v46_;
+  const T47 v47_;
+  const T48 v48_;
+  const T49 v49_;
+  const T50 v50_;
+};
+
+# if GTEST_HAS_COMBINE
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Generates values from the Cartesian product of values produced
+// by the argument generators.
+//
+template <typename T1, typename T2>
+class CartesianProductGenerator2
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2> > {
+ public:
+  typedef ::testing::tuple<T1, T2> ParamType;
+
+  CartesianProductGenerator2(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2)
+      : g1_(g1), g2_(g2) {}
+  virtual ~CartesianProductGenerator2() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current2_;
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // 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 Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&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().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator2::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator2& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+};  // class CartesianProductGenerator2
+
+
+template <typename T1, typename T2, typename T3>
+class CartesianProductGenerator3
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3> ParamType;
+
+  CartesianProductGenerator3(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3)
+      : g1_(g1), g2_(g2), g3_(g3) {}
+  virtual ~CartesianProductGenerator3() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current3_;
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // 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 Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&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().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator3::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator3& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+};  // class CartesianProductGenerator3
+
+
+template <typename T1, typename T2, typename T3, typename T4>
+class CartesianProductGenerator4
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4> ParamType;
+
+  CartesianProductGenerator4(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
+  virtual ~CartesianProductGenerator4() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current4_;
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // 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 Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&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().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator4::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator4& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+};  // class CartesianProductGenerator4
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+class CartesianProductGenerator5
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4, T5> ParamType;
+
+  CartesianProductGenerator5(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
+  virtual ~CartesianProductGenerator5() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end(), g5_, g5_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4,
+      const ParamGenerator<T5>& g5,
+      const typename ParamGenerator<T5>::iterator& current5)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
+          begin5_(g5.begin()), end5_(g5.end()), current5_(current5)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current5_;
+      if (current5_ == end5_) {
+        current5_ = begin5_;
+        ++current4_;
+      }
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // 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 Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&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().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_ &&
+          current5_ == typed_other->current5_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_),
+        begin5_(other.begin5_),
+        end5_(other.end5_),
+        current5_(other.current5_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_, *current5_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_ ||
+          current5_ == end5_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    const typename ParamGenerator<T5>::iterator begin5_;
+    const typename ParamGenerator<T5>::iterator end5_;
+    typename ParamGenerator<T5>::iterator current5_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator5::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator5& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+  const ParamGenerator<T5> g5_;
+};  // class CartesianProductGenerator5
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+class CartesianProductGenerator6
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5,
+        T6> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6> ParamType;
+
+  CartesianProductGenerator6(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
+      const ParamGenerator<T6>& g6)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
+  virtual ~CartesianProductGenerator6() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4,
+      const ParamGenerator<T5>& g5,
+      const typename ParamGenerator<T5>::iterator& current5,
+      const ParamGenerator<T6>& g6,
+      const typename ParamGenerator<T6>::iterator& current6)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
+          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
+          begin6_(g6.begin()), end6_(g6.end()), current6_(current6)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current6_;
+      if (current6_ == end6_) {
+        current6_ = begin6_;
+        ++current5_;
+      }
+      if (current5_ == end5_) {
+        current5_ = begin5_;
+        ++current4_;
+      }
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // 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 Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&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().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_ &&
+          current5_ == typed_other->current5_ &&
+          current6_ == typed_other->current6_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_),
+        begin5_(other.begin5_),
+        end5_(other.end5_),
+        current5_(other.current5_),
+        begin6_(other.begin6_),
+        end6_(other.end6_),
+        current6_(other.current6_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_, *current5_, *current6_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_ ||
+          current5_ == end5_ ||
+          current6_ == end6_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    const typename ParamGenerator<T5>::iterator begin5_;
+    const typename ParamGenerator<T5>::iterator end5_;
+    typename ParamGenerator<T5>::iterator current5_;
+    const typename ParamGenerator<T6>::iterator begin6_;
+    const typename ParamGenerator<T6>::iterator end6_;
+    typename ParamGenerator<T6>::iterator current6_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator6::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator6& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+  const ParamGenerator<T5> g5_;
+  const ParamGenerator<T6> g6_;
+};  // class CartesianProductGenerator6
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+class CartesianProductGenerator7
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
+        T7> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
+
+  CartesianProductGenerator7(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
+      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
+  virtual ~CartesianProductGenerator7() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
+        g7_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4,
+      const ParamGenerator<T5>& g5,
+      const typename ParamGenerator<T5>::iterator& current5,
+      const ParamGenerator<T6>& g6,
+      const typename ParamGenerator<T6>::iterator& current6,
+      const ParamGenerator<T7>& g7,
+      const typename ParamGenerator<T7>::iterator& current7)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
+          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
+          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
+          begin7_(g7.begin()), end7_(g7.end()), current7_(current7)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current7_;
+      if (current7_ == end7_) {
+        current7_ = begin7_;
+        ++current6_;
+      }
+      if (current6_ == end6_) {
+        current6_ = begin6_;
+        ++current5_;
+      }
+      if (current5_ == end5_) {
+        current5_ = begin5_;
+        ++current4_;
+      }
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // 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 Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&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().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_ &&
+          current5_ == typed_other->current5_ &&
+          current6_ == typed_other->current6_ &&
+          current7_ == typed_other->current7_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_),
+        begin5_(other.begin5_),
+        end5_(other.end5_),
+        current5_(other.current5_),
+        begin6_(other.begin6_),
+        end6_(other.end6_),
+        current6_(other.current6_),
+        begin7_(other.begin7_),
+        end7_(other.end7_),
+        current7_(other.current7_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_, *current5_, *current6_, *current7_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_ ||
+          current5_ == end5_ ||
+          current6_ == end6_ ||
+          current7_ == end7_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    const typename ParamGenerator<T5>::iterator begin5_;
+    const typename ParamGenerator<T5>::iterator end5_;
+    typename ParamGenerator<T5>::iterator current5_;
+    const typename ParamGenerator<T6>::iterator begin6_;
+    const typename ParamGenerator<T6>::iterator end6_;
+    typename ParamGenerator<T6>::iterator current6_;
+    const typename ParamGenerator<T7>::iterator begin7_;
+    const typename ParamGenerator<T7>::iterator end7_;
+    typename ParamGenerator<T7>::iterator current7_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator7::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator7& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+  const ParamGenerator<T5> g5_;
+  const ParamGenerator<T6> g6_;
+  const ParamGenerator<T7> g7_;
+};  // class CartesianProductGenerator7
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+class CartesianProductGenerator8
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
+        T7, T8> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType;
+
+  CartesianProductGenerator8(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
+      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
+      const ParamGenerator<T8>& g8)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
+          g8_(g8) {}
+  virtual ~CartesianProductGenerator8() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
+        g7_.begin(), g8_, g8_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
+        g8_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4,
+      const ParamGenerator<T5>& g5,
+      const typename ParamGenerator<T5>::iterator& current5,
+      const ParamGenerator<T6>& g6,
+      const typename ParamGenerator<T6>::iterator& current6,
+      const ParamGenerator<T7>& g7,
+      const typename ParamGenerator<T7>::iterator& current7,
+      const ParamGenerator<T8>& g8,
+      const typename ParamGenerator<T8>::iterator& current8)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
+          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
+          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
+          begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
+          begin8_(g8.begin()), end8_(g8.end()), current8_(current8)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current8_;
+      if (current8_ == end8_) {
+        current8_ = begin8_;
+        ++current7_;
+      }
+      if (current7_ == end7_) {
+        current7_ = begin7_;
+        ++current6_;
+      }
+      if (current6_ == end6_) {
+        current6_ = begin6_;
+        ++current5_;
+      }
+      if (current5_ == end5_) {
+        current5_ = begin5_;
+        ++current4_;
+      }
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // 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 Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&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().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_ &&
+          current5_ == typed_other->current5_ &&
+          current6_ == typed_other->current6_ &&
+          current7_ == typed_other->current7_ &&
+          current8_ == typed_other->current8_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_),
+        begin5_(other.begin5_),
+        end5_(other.end5_),
+        current5_(other.current5_),
+        begin6_(other.begin6_),
+        end6_(other.end6_),
+        current6_(other.current6_),
+        begin7_(other.begin7_),
+        end7_(other.end7_),
+        current7_(other.current7_),
+        begin8_(other.begin8_),
+        end8_(other.end8_),
+        current8_(other.current8_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_, *current5_, *current6_, *current7_, *current8_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_ ||
+          current5_ == end5_ ||
+          current6_ == end6_ ||
+          current7_ == end7_ ||
+          current8_ == end8_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    const typename ParamGenerator<T5>::iterator begin5_;
+    const typename ParamGenerator<T5>::iterator end5_;
+    typename ParamGenerator<T5>::iterator current5_;
+    const typename ParamGenerator<T6>::iterator begin6_;
+    const typename ParamGenerator<T6>::iterator end6_;
+    typename ParamGenerator<T6>::iterator current6_;
+    const typename ParamGenerator<T7>::iterator begin7_;
+    const typename ParamGenerator<T7>::iterator end7_;
+    typename ParamGenerator<T7>::iterator current7_;
+    const typename ParamGenerator<T8>::iterator begin8_;
+    const typename ParamGenerator<T8>::iterator end8_;
+    typename ParamGenerator<T8>::iterator current8_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator8::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator8& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+  const ParamGenerator<T5> g5_;
+  const ParamGenerator<T6> g6_;
+  const ParamGenerator<T7> g7_;
+  const ParamGenerator<T8> g8_;
+};  // class CartesianProductGenerator8
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+class CartesianProductGenerator9
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
+        T7, T8, T9> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType;
+
+  CartesianProductGenerator9(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
+      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
+      const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
+          g9_(g9) {}
+  virtual ~CartesianProductGenerator9() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
+        g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
+        g8_.end(), g9_, g9_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4,
+      const ParamGenerator<T5>& g5,
+      const typename ParamGenerator<T5>::iterator& current5,
+      const ParamGenerator<T6>& g6,
+      const typename ParamGenerator<T6>::iterator& current6,
+      const ParamGenerator<T7>& g7,
+      const typename ParamGenerator<T7>::iterator& current7,
+      const ParamGenerator<T8>& g8,
+      const typename ParamGenerator<T8>::iterator& current8,
+      const ParamGenerator<T9>& g9,
+      const typename ParamGenerator<T9>::iterator& current9)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
+          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
+          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
+          begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
+          begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
+          begin9_(g9.begin()), end9_(g9.end()), current9_(current9)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current9_;
+      if (current9_ == end9_) {
+        current9_ = begin9_;
+        ++current8_;
+      }
+      if (current8_ == end8_) {
+        current8_ = begin8_;
+        ++current7_;
+      }
+      if (current7_ == end7_) {
+        current7_ = begin7_;
+        ++current6_;
+      }
+      if (current6_ == end6_) {
+        current6_ = begin6_;
+        ++current5_;
+      }
+      if (current5_ == end5_) {
+        current5_ = begin5_;
+        ++current4_;
+      }
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // 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 Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&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().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_ &&
+          current5_ == typed_other->current5_ &&
+          current6_ == typed_other->current6_ &&
+          current7_ == typed_other->current7_ &&
+          current8_ == typed_other->current8_ &&
+          current9_ == typed_other->current9_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_),
+        begin5_(other.begin5_),
+        end5_(other.end5_),
+        current5_(other.current5_),
+        begin6_(other.begin6_),
+        end6_(other.end6_),
+        current6_(other.current6_),
+        begin7_(other.begin7_),
+        end7_(other.end7_),
+        current7_(other.current7_),
+        begin8_(other.begin8_),
+        end8_(other.end8_),
+        current8_(other.current8_),
+        begin9_(other.begin9_),
+        end9_(other.end9_),
+        current9_(other.current9_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_, *current5_, *current6_, *current7_, *current8_,
+            *current9_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_ ||
+          current5_ == end5_ ||
+          current6_ == end6_ ||
+          current7_ == end7_ ||
+          current8_ == end8_ ||
+          current9_ == end9_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    const typename ParamGenerator<T5>::iterator begin5_;
+    const typename ParamGenerator<T5>::iterator end5_;
+    typename ParamGenerator<T5>::iterator current5_;
+    const typename ParamGenerator<T6>::iterator begin6_;
+    const typename ParamGenerator<T6>::iterator end6_;
+    typename ParamGenerator<T6>::iterator current6_;
+    const typename ParamGenerator<T7>::iterator begin7_;
+    const typename ParamGenerator<T7>::iterator end7_;
+    typename ParamGenerator<T7>::iterator current7_;
+    const typename ParamGenerator<T8>::iterator begin8_;
+    const typename ParamGenerator<T8>::iterator end8_;
+    typename ParamGenerator<T8>::iterator current8_;
+    const typename ParamGenerator<T9>::iterator begin9_;
+    const typename ParamGenerator<T9>::iterator end9_;
+    typename ParamGenerator<T9>::iterator current9_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator9::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator9& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+  const ParamGenerator<T5> g5_;
+  const ParamGenerator<T6> g6_;
+  const ParamGenerator<T7> g7_;
+  const ParamGenerator<T8> g8_;
+  const ParamGenerator<T9> g9_;
+};  // class CartesianProductGenerator9
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+class CartesianProductGenerator10
+    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
+        T7, T8, T9, T10> > {
+ public:
+  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ParamType;
+
+  CartesianProductGenerator10(const ParamGenerator<T1>& g1,
+      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
+      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
+      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
+      const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9,
+      const ParamGenerator<T10>& g10)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
+          g9_(g9), g10_(g10) {}
+  virtual ~CartesianProductGenerator10() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
+        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
+        g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin(), g10_, g10_.begin());
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
+        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
+        g8_.end(), g9_, g9_.end(), g10_, g10_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base,
+      const ParamGenerator<T1>& g1,
+      const typename ParamGenerator<T1>::iterator& current1,
+      const ParamGenerator<T2>& g2,
+      const typename ParamGenerator<T2>::iterator& current2,
+      const ParamGenerator<T3>& g3,
+      const typename ParamGenerator<T3>::iterator& current3,
+      const ParamGenerator<T4>& g4,
+      const typename ParamGenerator<T4>::iterator& current4,
+      const ParamGenerator<T5>& g5,
+      const typename ParamGenerator<T5>::iterator& current5,
+      const ParamGenerator<T6>& g6,
+      const typename ParamGenerator<T6>::iterator& current6,
+      const ParamGenerator<T7>& g7,
+      const typename ParamGenerator<T7>::iterator& current7,
+      const ParamGenerator<T8>& g8,
+      const typename ParamGenerator<T8>::iterator& current8,
+      const ParamGenerator<T9>& g9,
+      const typename ParamGenerator<T9>::iterator& current9,
+      const ParamGenerator<T10>& g10,
+      const typename ParamGenerator<T10>::iterator& current10)
+        : base_(base),
+          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
+          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
+          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
+          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
+          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
+          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
+          begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
+          begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
+          begin9_(g9.begin()), end9_(g9.end()), current9_(current9),
+          begin10_(g10.begin()), end10_(g10.end()), current10_(current10)    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current10_;
+      if (current10_ == end10_) {
+        current10_ = begin10_;
+        ++current9_;
+      }
+      if (current9_ == end9_) {
+        current9_ = begin9_;
+        ++current8_;
+      }
+      if (current8_ == end8_) {
+        current8_ = begin8_;
+        ++current7_;
+      }
+      if (current7_ == end7_) {
+        current7_ = begin7_;
+        ++current6_;
+      }
+      if (current6_ == end6_) {
+        current6_ = begin6_;
+        ++current5_;
+      }
+      if (current5_ == end5_) {
+        current5_ = begin5_;
+        ++current4_;
+      }
+      if (current4_ == end4_) {
+        current4_ = begin4_;
+        ++current3_;
+      }
+      if (current3_ == end3_) {
+        current3_ = begin3_;
+        ++current2_;
+      }
+      if (current2_ == end2_) {
+        current2_ = begin2_;
+        ++current1_;
+      }
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // 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 Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&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().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         (
+          current1_ == typed_other->current1_ &&
+          current2_ == typed_other->current2_ &&
+          current3_ == typed_other->current3_ &&
+          current4_ == typed_other->current4_ &&
+          current5_ == typed_other->current5_ &&
+          current6_ == typed_other->current6_ &&
+          current7_ == typed_other->current7_ &&
+          current8_ == typed_other->current8_ &&
+          current9_ == typed_other->current9_ &&
+          current10_ == typed_other->current10_);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_),
+        begin1_(other.begin1_),
+        end1_(other.end1_),
+        current1_(other.current1_),
+        begin2_(other.begin2_),
+        end2_(other.end2_),
+        current2_(other.current2_),
+        begin3_(other.begin3_),
+        end3_(other.end3_),
+        current3_(other.current3_),
+        begin4_(other.begin4_),
+        end4_(other.end4_),
+        current4_(other.current4_),
+        begin5_(other.begin5_),
+        end5_(other.end5_),
+        current5_(other.current5_),
+        begin6_(other.begin6_),
+        end6_(other.end6_),
+        current6_(other.current6_),
+        begin7_(other.begin7_),
+        end7_(other.end7_),
+        current7_(other.current7_),
+        begin8_(other.begin8_),
+        end8_(other.end8_),
+        current8_(other.current8_),
+        begin9_(other.begin9_),
+        end9_(other.end9_),
+        current9_(other.current9_),
+        begin10_(other.begin10_),
+        end10_(other.end10_),
+        current10_(other.current10_) {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType(*current1_, *current2_, *current3_,
+            *current4_, *current5_, *current6_, *current7_, *current8_,
+            *current9_, *current10_);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+          current1_ == end1_ ||
+          current2_ == end2_ ||
+          current3_ == end3_ ||
+          current4_ == end4_ ||
+          current5_ == end5_ ||
+          current6_ == end6_ ||
+          current7_ == end7_ ||
+          current8_ == end8_ ||
+          current9_ == end9_ ||
+          current10_ == end10_;
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+    const typename ParamGenerator<T1>::iterator begin1_;
+    const typename ParamGenerator<T1>::iterator end1_;
+    typename ParamGenerator<T1>::iterator current1_;
+    const typename ParamGenerator<T2>::iterator begin2_;
+    const typename ParamGenerator<T2>::iterator end2_;
+    typename ParamGenerator<T2>::iterator current2_;
+    const typename ParamGenerator<T3>::iterator begin3_;
+    const typename ParamGenerator<T3>::iterator end3_;
+    typename ParamGenerator<T3>::iterator current3_;
+    const typename ParamGenerator<T4>::iterator begin4_;
+    const typename ParamGenerator<T4>::iterator end4_;
+    typename ParamGenerator<T4>::iterator current4_;
+    const typename ParamGenerator<T5>::iterator begin5_;
+    const typename ParamGenerator<T5>::iterator end5_;
+    typename ParamGenerator<T5>::iterator current5_;
+    const typename ParamGenerator<T6>::iterator begin6_;
+    const typename ParamGenerator<T6>::iterator end6_;
+    typename ParamGenerator<T6>::iterator current6_;
+    const typename ParamGenerator<T7>::iterator begin7_;
+    const typename ParamGenerator<T7>::iterator end7_;
+    typename ParamGenerator<T7>::iterator current7_;
+    const typename ParamGenerator<T8>::iterator begin8_;
+    const typename ParamGenerator<T8>::iterator end8_;
+    typename ParamGenerator<T8>::iterator current8_;
+    const typename ParamGenerator<T9>::iterator begin9_;
+    const typename ParamGenerator<T9>::iterator end9_;
+    typename ParamGenerator<T9>::iterator current9_;
+    const typename ParamGenerator<T10>::iterator begin10_;
+    const typename ParamGenerator<T10>::iterator end10_;
+    typename ParamGenerator<T10>::iterator current10_;
+    ParamType current_value_;
+  };  // class CartesianProductGenerator10::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator10& other);
+
+  const ParamGenerator<T1> g1_;
+  const ParamGenerator<T2> g2_;
+  const ParamGenerator<T3> g3_;
+  const ParamGenerator<T4> g4_;
+  const ParamGenerator<T5> g5_;
+  const ParamGenerator<T6> g6_;
+  const ParamGenerator<T7> g7_;
+  const ParamGenerator<T8> g8_;
+  const ParamGenerator<T9> g9_;
+  const ParamGenerator<T10> g10_;
+};  // class CartesianProductGenerator10
+
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Helper classes providing Combine() with polymorphic features. They allow
+// casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is
+// convertible to U.
+//
+template <class Generator1, class Generator2>
+class CartesianProductHolder2 {
+ public:
+CartesianProductHolder2(const Generator1& g1, const Generator2& g2)
+      : g1_(g1), g2_(g2) {}
+  template <typename T1, typename T2>
+  operator ParamGenerator< ::testing::tuple<T1, T2> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2> >(
+        new CartesianProductGenerator2<T1, T2>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder2& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+};  // class CartesianProductHolder2
+
+template <class Generator1, class Generator2, class Generator3>
+class CartesianProductHolder3 {
+ public:
+CartesianProductHolder3(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3)
+      : g1_(g1), g2_(g2), g3_(g3) {}
+  template <typename T1, typename T2, typename T3>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3> >(
+        new CartesianProductGenerator3<T1, T2, T3>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder3& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+};  // class CartesianProductHolder3
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4>
+class CartesianProductHolder4 {
+ public:
+CartesianProductHolder4(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
+  template <typename T1, typename T2, typename T3, typename T4>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4> >(
+        new CartesianProductGenerator4<T1, T2, T3, T4>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder4& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+};  // class CartesianProductHolder4
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4, class Generator5>
+class CartesianProductHolder5 {
+ public:
+CartesianProductHolder5(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4, const Generator5& g5)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
+  template <typename T1, typename T2, typename T3, typename T4, typename T5>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5> >(
+        new CartesianProductGenerator5<T1, T2, T3, T4, T5>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_),
+        static_cast<ParamGenerator<T5> >(g5_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder5& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+  const Generator5 g5_;
+};  // class CartesianProductHolder5
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4, class Generator5, class Generator6>
+class CartesianProductHolder6 {
+ public:
+CartesianProductHolder6(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4, const Generator5& g5,
+    const Generator6& g6)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
+  template <typename T1, typename T2, typename T3, typename T4, typename T5,
+      typename T6>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >(
+        new CartesianProductGenerator6<T1, T2, T3, T4, T5, T6>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_),
+        static_cast<ParamGenerator<T5> >(g5_),
+        static_cast<ParamGenerator<T6> >(g6_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder6& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+  const Generator5 g5_;
+  const Generator6 g6_;
+};  // class CartesianProductHolder6
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4, class Generator5, class Generator6, class Generator7>
+class CartesianProductHolder7 {
+ public:
+CartesianProductHolder7(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4, const Generator5& g5,
+    const Generator6& g6, const Generator7& g7)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
+  template <typename T1, typename T2, typename T3, typename T4, typename T5,
+      typename T6, typename T7>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6,
+      T7> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7> >(
+        new CartesianProductGenerator7<T1, T2, T3, T4, T5, T6, T7>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_),
+        static_cast<ParamGenerator<T5> >(g5_),
+        static_cast<ParamGenerator<T6> >(g6_),
+        static_cast<ParamGenerator<T7> >(g7_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder7& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+  const Generator5 g5_;
+  const Generator6 g6_;
+  const Generator7 g7_;
+};  // class CartesianProductHolder7
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4, class Generator5, class Generator6, class Generator7,
+    class Generator8>
+class CartesianProductHolder8 {
+ public:
+CartesianProductHolder8(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4, const Generator5& g5,
+    const Generator6& g6, const Generator7& g7, const Generator8& g8)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
+          g8_(g8) {}
+  template <typename T1, typename T2, typename T3, typename T4, typename T5,
+      typename T6, typename T7, typename T8>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7,
+      T8> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8> >(
+        new CartesianProductGenerator8<T1, T2, T3, T4, T5, T6, T7, T8>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_),
+        static_cast<ParamGenerator<T5> >(g5_),
+        static_cast<ParamGenerator<T6> >(g6_),
+        static_cast<ParamGenerator<T7> >(g7_),
+        static_cast<ParamGenerator<T8> >(g8_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder8& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+  const Generator5 g5_;
+  const Generator6 g6_;
+  const Generator7 g7_;
+  const Generator8 g8_;
+};  // class CartesianProductHolder8
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4, class Generator5, class Generator6, class Generator7,
+    class Generator8, class Generator9>
+class CartesianProductHolder9 {
+ public:
+CartesianProductHolder9(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4, const Generator5& g5,
+    const Generator6& g6, const Generator7& g7, const Generator8& g8,
+    const Generator9& g9)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
+          g9_(g9) {}
+  template <typename T1, typename T2, typename T3, typename T4, typename T5,
+      typename T6, typename T7, typename T8, typename T9>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
+      T9> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
+        T9> >(
+        new CartesianProductGenerator9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_),
+        static_cast<ParamGenerator<T5> >(g5_),
+        static_cast<ParamGenerator<T6> >(g6_),
+        static_cast<ParamGenerator<T7> >(g7_),
+        static_cast<ParamGenerator<T8> >(g8_),
+        static_cast<ParamGenerator<T9> >(g9_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder9& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+  const Generator5 g5_;
+  const Generator6 g6_;
+  const Generator7 g7_;
+  const Generator8 g8_;
+  const Generator9 g9_;
+};  // class CartesianProductHolder9
+
+template <class Generator1, class Generator2, class Generator3,
+    class Generator4, class Generator5, class Generator6, class Generator7,
+    class Generator8, class Generator9, class Generator10>
+class CartesianProductHolder10 {
+ public:
+CartesianProductHolder10(const Generator1& g1, const Generator2& g2,
+    const Generator3& g3, const Generator4& g4, const Generator5& g5,
+    const Generator6& g6, const Generator7& g7, const Generator8& g8,
+    const Generator9& g9, const Generator10& g10)
+      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
+          g9_(g9), g10_(g10) {}
+  template <typename T1, typename T2, typename T3, typename T4, typename T5,
+      typename T6, typename T7, typename T8, typename T9, typename T10>
+  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9,
+      T10> >() const {
+    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9,
+        T10> >(
+        new CartesianProductGenerator10<T1, T2, T3, T4, T5, T6, T7, T8, T9,
+            T10>(
+        static_cast<ParamGenerator<T1> >(g1_),
+        static_cast<ParamGenerator<T2> >(g2_),
+        static_cast<ParamGenerator<T3> >(g3_),
+        static_cast<ParamGenerator<T4> >(g4_),
+        static_cast<ParamGenerator<T5> >(g5_),
+        static_cast<ParamGenerator<T6> >(g6_),
+        static_cast<ParamGenerator<T7> >(g7_),
+        static_cast<ParamGenerator<T8> >(g8_),
+        static_cast<ParamGenerator<T9> >(g9_),
+        static_cast<ParamGenerator<T10> >(g10_)));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder10& other);
+
+  const Generator1 g1_;
+  const Generator2 g2_;
+  const Generator3 g3_;
+  const Generator4 g4_;
+  const Generator5 g5_;
+  const Generator6 g6_;
+  const Generator7 g7_;
+  const Generator8 g8_;
+  const Generator9 g9_;
+  const Generator10 g10_;
+};  // class CartesianProductHolder10
+
+# endif  // GTEST_HAS_COMBINE
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  //  GTEST_HAS_PARAM_TEST
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h.pump b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h.pump
new file mode 100644
index 00000000..5c7c47af
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h.pump
@@ -0,0 +1,286 @@
+$$ -*- mode: c++; -*-
+$var n = 50  $$ Maximum length of Values arguments we want to support.
+$var maxtuple = 10  $$ Maximum number of Combine arguments we want to support.
+// 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+
+// Type and function utilities for implementing parameterized tests.
+// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
+//
+// Currently Google Test supports at most $n arguments in Values,
+// and at most $maxtuple arguments in Combine. Please contact
+// googletestframework@googlegroups.com if you need more.
+// Please note that the number of arguments to Combine is limited
+// by the maximum arity of the implementation of tuple which is
+// currently set at $maxtuple.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
+
+// scripts/fuse_gtest.py depends on gtest's own header being #included
+// *unconditionally*.  Therefore these #includes cannot be moved
+// inside #if GTEST_HAS_PARAM_TEST.
+#include "gtest/internal/gtest-param-util.h"
+#include "gtest/internal/gtest-port.h"
+
+#if GTEST_HAS_PARAM_TEST
+
+namespace testing {
+
+// Forward declarations of ValuesIn(), which is implemented in
+// include/gtest/gtest-param-test.h.
+template <typename ForwardIterator>
+internal::ParamGenerator<
+  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
+ValuesIn(ForwardIterator begin, ForwardIterator end);
+
+template <typename T, size_t N>
+internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);
+
+template <class Container>
+internal::ParamGenerator<typename Container::value_type> ValuesIn(
+    const Container& container);
+
+namespace internal {
+
+// Used in the Values() function to provide polymorphic capabilities.
+$range i 1..n
+$for i [[
+$range j 1..i
+
+template <$for j, [[typename T$j]]>
+class ValueArray$i {
+ public:
+  $if i==1 [[explicit ]]ValueArray$i($for j, [[T$j v$j]]) : $for j, [[v$(j)_(v$j)]] {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {
+    const T array[] = {$for j, [[static_cast<T>(v$(j)_)]]};
+    return ValuesIn(array);
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const ValueArray$i& other);
+
+$for j [[
+
+  const T$j v$(j)_;
+]]
+
+};
+
+]]
+
+# if GTEST_HAS_COMBINE
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Generates values from the Cartesian product of values produced
+// by the argument generators.
+//
+$range i 2..maxtuple
+$for i [[
+$range j 1..i
+$range k 2..i
+
+template <$for j, [[typename T$j]]>
+class CartesianProductGenerator$i
+    : public ParamGeneratorInterface< ::testing::tuple<$for j, [[T$j]]> > {
+ public:
+  typedef ::testing::tuple<$for j, [[T$j]]> ParamType;
+
+  CartesianProductGenerator$i($for j, [[const ParamGenerator<T$j>& g$j]])
+      : $for j, [[g$(j)_(g$j)]] {}
+  virtual ~CartesianProductGenerator$i() {}
+
+  virtual ParamIteratorInterface<ParamType>* Begin() const {
+    return new Iterator(this, $for j, [[g$(j)_, g$(j)_.begin()]]);
+  }
+  virtual ParamIteratorInterface<ParamType>* End() const {
+    return new Iterator(this, $for j, [[g$(j)_, g$(j)_.end()]]);
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<ParamType> {
+   public:
+    Iterator(const ParamGeneratorInterface<ParamType>* base, $for j, [[
+
+      const ParamGenerator<T$j>& g$j,
+      const typename ParamGenerator<T$j>::iterator& current$(j)]])
+        : base_(base),
+$for j, [[
+
+          begin$(j)_(g$j.begin()), end$(j)_(g$j.end()), current$(j)_(current$j)
+]]    {
+      ComputeCurrentValue();
+    }
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    virtual void Advance() {
+      assert(!AtEnd());
+      ++current$(i)_;
+
+$for k [[
+      if (current$(i+2-k)_ == end$(i+2-k)_) {
+        current$(i+2-k)_ = begin$(i+2-k)_;
+        ++current$(i+2-k-1)_;
+      }
+
+]]
+      ComputeCurrentValue();
+    }
+    virtual ParamIteratorInterface<ParamType>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const ParamType* Current() const { return &current_value_; }
+    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
+      // 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 Iterator* typed_other =
+          CheckedDowncastToActualType<const Iterator>(&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().
+      return (AtEnd() && typed_other->AtEnd()) ||
+         ($for j  && [[
+
+          current$(j)_ == typed_other->current$(j)_
+]]);
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : base_(other.base_), $for j, [[
+
+        begin$(j)_(other.begin$(j)_),
+        end$(j)_(other.end$(j)_),
+        current$(j)_(other.current$(j)_)
+]] {
+      ComputeCurrentValue();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = ParamType($for j, [[*current$(j)_]]);
+    }
+    bool AtEnd() const {
+      // We must report iterator past the end of the range when either of the
+      // component iterators has reached the end of its range.
+      return
+$for j  || [[
+
+          current$(j)_ == end$(j)_
+]];
+    }
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
+    // current[i]_ is the actual traversing iterator.
+$for j [[
+
+    const typename ParamGenerator<T$j>::iterator begin$(j)_;
+    const typename ParamGenerator<T$j>::iterator end$(j)_;
+    typename ParamGenerator<T$j>::iterator current$(j)_;
+]]
+
+    ParamType current_value_;
+  };  // class CartesianProductGenerator$i::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductGenerator$i& other);
+
+
+$for j [[
+  const ParamGenerator<T$j> g$(j)_;
+
+]]
+};  // class CartesianProductGenerator$i
+
+
+]]
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Helper classes providing Combine() with polymorphic features. They allow
+// casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is
+// convertible to U.
+//
+$range i 2..maxtuple
+$for i [[
+$range j 1..i
+
+template <$for j, [[class Generator$j]]>
+class CartesianProductHolder$i {
+ public:
+CartesianProductHolder$i($for j, [[const Generator$j& g$j]])
+      : $for j, [[g$(j)_(g$j)]] {}
+  template <$for j, [[typename T$j]]>
+  operator ParamGenerator< ::testing::tuple<$for j, [[T$j]]> >() const {
+    return ParamGenerator< ::testing::tuple<$for j, [[T$j]]> >(
+        new CartesianProductGenerator$i<$for j, [[T$j]]>(
+$for j,[[
+
+        static_cast<ParamGenerator<T$j> >(g$(j)_)
+]]));
+  }
+
+ private:
+  // No implementation - assignment is unsupported.
+  void operator=(const CartesianProductHolder$i& other);
+
+
+$for j [[
+  const Generator$j g$(j)_;
+
+]]
+};  // class CartesianProductHolder$i
+
+]]
+
+# endif  // GTEST_HAS_COMBINE
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  //  GTEST_HAS_PARAM_TEST
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util.h
new file mode 100644
index 00000000..82cab9b0
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util.h
@@ -0,0 +1,731 @@
+// 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+
+// Type and function utilities for implementing parameterized tests.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+
+#include <ctype.h>
+
+#include <iterator>
+#include <set>
+#include <utility>
+#include <vector>
+
+// scripts/fuse_gtest.py depends on gtest's own header being #included
+// *unconditionally*.  Therefore these #includes cannot be moved
+// inside #if GTEST_HAS_PARAM_TEST.
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-linked_ptr.h"
+#include "gtest/internal/gtest-port.h"
+#include "gtest/gtest-printers.h"
+
+#if GTEST_HAS_PARAM_TEST
+
+namespace testing {
+
+// Input to a parameterized test name generator, describing a test parameter.
+// Consists of the parameter value and the integer parameter index.
+template <class ParamType>
+struct TestParamInfo {
+  TestParamInfo(const ParamType& a_param, size_t an_index) :
+    param(a_param),
+    index(an_index) {}
+  ParamType param;
+  size_t index;
+};
+
+// A builtin parameterized test name generator which returns the result of
+// testing::PrintToString.
+struct PrintToStringParamName {
+  template <class ParamType>
+  std::string operator()(const TestParamInfo<ParamType>& info) const {
+    return PrintToString(info.param);
+  }
+};
+
+namespace internal {
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Outputs a message explaining invalid registration of different
+// fixture class for the same test case. This may happen when
+// TEST_P macro is used to define two tests with the same name
+// but in different namespaces.
+GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name,
+                                          CodeLocation code_location);
+
+template <typename> class ParamGeneratorInterface;
+template <typename> class ParamGenerator;
+
+// Interface for iterating over elements provided by an implementation
+// of ParamGeneratorInterface<T>.
+template <typename T>
+class ParamIteratorInterface {
+ public:
+  virtual ~ParamIteratorInterface() {}
+  // A pointer to the base generator instance.
+  // Used only for the purposes of iterator comparison
+  // to make sure that two iterators belong to the same generator.
+  virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
+  // Advances iterator to point to the next element
+  // provided by the generator. The caller is responsible
+  // for not calling Advance() on an iterator equal to
+  // BaseGenerator()->End().
+  virtual void Advance() = 0;
+  // Clones the iterator object. Used for implementing copy semantics
+  // of ParamIterator<T>.
+  virtual ParamIteratorInterface* Clone() const = 0;
+  // Dereferences the current iterator and provides (read-only) access
+  // to the pointed value. It is the caller's responsibility not to call
+  // Current() on an iterator equal to BaseGenerator()->End().
+  // Used for implementing ParamGenerator<T>::operator*().
+  virtual const T* Current() const = 0;
+  // Determines whether the given iterator and other point to the same
+  // element in the sequence generated by the generator.
+  // Used for implementing ParamGenerator<T>::operator==().
+  virtual bool Equals(const ParamIteratorInterface& other) const = 0;
+};
+
+// Class iterating over elements provided by an implementation of
+// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
+// and implements the const forward iterator concept.
+template <typename T>
+class ParamIterator {
+ public:
+  typedef T value_type;
+  typedef const T& reference;
+  typedef ptrdiff_t difference_type;
+
+  // ParamIterator assumes ownership of the impl_ pointer.
+  ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
+  ParamIterator& operator=(const ParamIterator& other) {
+    if (this != &other)
+      impl_.reset(other.impl_->Clone());
+    return *this;
+  }
+
+  const T& operator*() const { return *impl_->Current(); }
+  const T* operator->() const { return impl_->Current(); }
+  // Prefix version of operator++.
+  ParamIterator& operator++() {
+    impl_->Advance();
+    return *this;
+  }
+  // Postfix version of operator++.
+  ParamIterator operator++(int /*unused*/) {
+    ParamIteratorInterface<T>* clone = impl_->Clone();
+    impl_->Advance();
+    return ParamIterator(clone);
+  }
+  bool operator==(const ParamIterator& other) const {
+    return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
+  }
+  bool operator!=(const ParamIterator& other) const {
+    return !(*this == other);
+  }
+
+ private:
+  friend class ParamGenerator<T>;
+  explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
+  scoped_ptr<ParamIteratorInterface<T> > impl_;
+};
+
+// ParamGeneratorInterface<T> is the binary interface to access generators
+// defined in other translation units.
+template <typename T>
+class ParamGeneratorInterface {
+ public:
+  typedef T ParamType;
+
+  virtual ~ParamGeneratorInterface() {}
+
+  // Generator interface definition
+  virtual ParamIteratorInterface<T>* Begin() const = 0;
+  virtual ParamIteratorInterface<T>* End() const = 0;
+};
+
+// Wraps ParamGeneratorInterface<T> and provides general generator syntax
+// compatible with the STL Container concept.
+// This class implements copy initialization semantics and the contained
+// ParamGeneratorInterface<T> instance is shared among all copies
+// of the original object. This is possible because that instance is immutable.
+template<typename T>
+class ParamGenerator {
+ public:
+  typedef ParamIterator<T> iterator;
+
+  explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
+  ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}
+
+  ParamGenerator& operator=(const ParamGenerator& other) {
+    impl_ = other.impl_;
+    return *this;
+  }
+
+  iterator begin() const { return iterator(impl_->Begin()); }
+  iterator end() const { return iterator(impl_->End()); }
+
+ private:
+  linked_ptr<const ParamGeneratorInterface<T> > impl_;
+};
+
+// Generates values from a range of two comparable values. Can be used to
+// generate sequences of user-defined types that implement operator+() and
+// operator<().
+// This class is used in the Range() function.
+template <typename T, typename IncrementT>
+class RangeGenerator : public ParamGeneratorInterface<T> {
+ public:
+  RangeGenerator(T begin, T end, IncrementT step)
+      : begin_(begin), end_(end),
+        step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
+  virtual ~RangeGenerator() {}
+
+  virtual ParamIteratorInterface<T>* Begin() const {
+    return new Iterator(this, begin_, 0, step_);
+  }
+  virtual ParamIteratorInterface<T>* End() const {
+    return new Iterator(this, end_, end_index_, step_);
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<T> {
+   public:
+    Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
+             IncrementT step)
+        : base_(base), value_(value), index_(index), step_(step) {}
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
+      return base_;
+    }
+    virtual void Advance() {
+      value_ = static_cast<T>(value_ + step_);
+      index_++;
+    }
+    virtual ParamIteratorInterface<T>* Clone() const {
+      return new Iterator(*this);
+    }
+    virtual const T* Current() const { return &value_; }
+    virtual bool Equals(const ParamIteratorInterface<T>& other) const {
+      // 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 int other_index =
+          CheckedDowncastToActualType<const Iterator>(&other)->index_;
+      return index_ == other_index;
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : ParamIteratorInterface<T>(),
+          base_(other.base_), value_(other.value_), index_(other.index_),
+          step_(other.step_) {}
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<T>* const base_;
+    T value_;
+    int index_;
+    const IncrementT step_;
+  };  // class RangeGenerator::Iterator
+
+  static int CalculateEndIndex(const T& begin,
+                               const T& end,
+                               const IncrementT& step) {
+    int end_index = 0;
+    for (T i = begin; i < end; i = static_cast<T>(i + step))
+      end_index++;
+    return end_index;
+  }
+
+  // No implementation - assignment is unsupported.
+  void operator=(const RangeGenerator& other);
+
+  const T begin_;
+  const T end_;
+  const IncrementT step_;
+  // The index for the end() iterator. All the elements in the generated
+  // sequence are indexed (0-based) to aid iterator comparison.
+  const int end_index_;
+};  // class RangeGenerator
+
+
+// Generates values from a pair of STL-style iterators. Used in the
+// ValuesIn() function. The elements are copied from the source range
+// since the source can be located on the stack, and the generator
+// is likely to persist beyond that stack frame.
+template <typename T>
+class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
+ public:
+  template <typename ForwardIterator>
+  ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
+      : container_(begin, end) {}
+  virtual ~ValuesInIteratorRangeGenerator() {}
+
+  virtual ParamIteratorInterface<T>* Begin() const {
+    return new Iterator(this, container_.begin());
+  }
+  virtual ParamIteratorInterface<T>* End() const {
+    return new Iterator(this, container_.end());
+  }
+
+ private:
+  typedef typename ::std::vector<T> ContainerType;
+
+  class Iterator : public ParamIteratorInterface<T> {
+   public:
+    Iterator(const ParamGeneratorInterface<T>* base,
+             typename ContainerType::const_iterator iterator)
+        : base_(base), iterator_(iterator) {}
+    virtual ~Iterator() {}
+
+    virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
+      return base_;
+    }
+    virtual void Advance() {
+      ++iterator_;
+      value_.reset();
+    }
+    virtual ParamIteratorInterface<T>* Clone() const {
+      return new Iterator(*this);
+    }
+    // We need to use cached value referenced by iterator_ because *iterator_
+    // can return a temporary object (and of type other then T), so just
+    // having "return &*iterator_;" doesn't work.
+    // value_ is updated here and not in Advance() because Advance()
+    // 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.
+    virtual const T* Current() const {
+      if (value_.get() == NULL)
+        value_.reset(new T(*iterator_));
+      return value_.get();
+    }
+    virtual bool Equals(const ParamIteratorInterface<T>& other) const {
+      // 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;
+      return iterator_ ==
+          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
+    }
+
+   private:
+    Iterator(const Iterator& other)
+          // The explicit constructor call suppresses a false warning
+          // emitted by gcc when supplied with the -Wextra option.
+        : ParamIteratorInterface<T>(),
+          base_(other.base_),
+          iterator_(other.iterator_) {}
+
+    const ParamGeneratorInterface<T>* const base_;
+    typename ContainerType::const_iterator iterator_;
+    // 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 scoped_ptr helps manage cached value's lifetime,
+    // which is bound by the lifespan of the iterator itself.
+    mutable scoped_ptr<const T> value_;
+  };  // class ValuesInIteratorRangeGenerator::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const ValuesInIteratorRangeGenerator& other);
+
+  const ContainerType container_;
+};  // class ValuesInIteratorRangeGenerator
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Default parameterized test name generator, returns a string containing the
+// integer test parameter index.
+template <class ParamType>
+std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
+  Message name_stream;
+  name_stream << info.index;
+  return name_stream.GetString();
+}
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Parameterized test name overload helpers, which help the
+// INSTANTIATE_TEST_CASE_P macro choose between the default parameterized
+// test name generator and user param name generator.
+template <class ParamType, class ParamNameGenFunctor>
+ParamNameGenFunctor GetParamNameGen(ParamNameGenFunctor func) {
+  return func;
+}
+
+template <class ParamType>
+struct ParamNameGenFunc {
+  typedef std::string Type(const TestParamInfo<ParamType>&);
+};
+
+template <class ParamType>
+typename ParamNameGenFunc<ParamType>::Type *GetParamNameGen() {
+  return DefaultParamName;
+}
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Stores a parameter value and later creates tests parameterized with that
+// value.
+template <class TestClass>
+class ParameterizedTestFactory : public TestFactoryBase {
+ public:
+  typedef typename TestClass::ParamType ParamType;
+  explicit ParameterizedTestFactory(ParamType parameter) :
+      parameter_(parameter) {}
+  virtual Test* CreateTest() {
+    TestClass::SetParam(&parameter_);
+    return new TestClass();
+  }
+
+ private:
+  const ParamType parameter_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// TestMetaFactoryBase is a base class for meta-factories that create
+// test factories for passing into MakeAndRegisterTestInfo function.
+template <class ParamType>
+class TestMetaFactoryBase {
+ public:
+  virtual ~TestMetaFactoryBase() {}
+
+  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// 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 ParameterizedTestCaseInfo is going to call
+// it for each Test/Parameter value combination. Thus it needs meta factory
+// creator class.
+template <class TestCase>
+class TestMetaFactory
+    : public TestMetaFactoryBase<typename TestCase::ParamType> {
+ public:
+  typedef typename TestCase::ParamType ParamType;
+
+  TestMetaFactory() {}
+
+  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) {
+    return new ParameterizedTestFactory<TestCase>(parameter);
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestCaseInfoBase is a generic interface
+// to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase
+// accumulates test information provided by TEST_P macro invocations
+// and generators provided by INSTANTIATE_TEST_CASE_P macro invocations
+// and uses that information to register all resulting test instances
+// in RegisterTests method. The ParameterizeTestCaseRegistry class holds
+// a collection of pointers to the ParameterizedTestCaseInfo objects
+// and calls RegisterTests() on each of them when asked.
+class ParameterizedTestCaseInfoBase {
+ public:
+  virtual ~ParameterizedTestCaseInfoBase() {}
+
+  // Base part of test case name for display purposes.
+  virtual const string& GetTestCaseName() const = 0;
+  // Test case id to verify identity.
+  virtual TypeId GetTestCaseTypeId() const = 0;
+  // UnitTest class invokes this method to register tests in this
+  // test case right before running them in RUN_ALL_TESTS macro.
+  // This method should not be called more then once on any single
+  // instance of a ParameterizedTestCaseInfoBase derived class.
+  virtual void RegisterTests() = 0;
+
+ protected:
+  ParameterizedTestCaseInfoBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestCaseInfo accumulates tests obtained from TEST_P
+// macro invocations for a particular test case and generators
+// obtained from INSTANTIATE_TEST_CASE_P macro invocations for that
+// test case. It registers tests with all values generated by all
+// generators when asked.
+template <class TestCase>
+class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
+ public:
+  // ParamType and GeneratorCreationFunc are private types but are required
+  // for declarations of public methods AddTestPattern() and
+  // AddTestCaseInstantiation().
+  typedef typename TestCase::ParamType ParamType;
+  // A function that returns an instance of appropriate generator type.
+  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
+  typedef typename ParamNameGenFunc<ParamType>::Type ParamNameGeneratorFunc;
+
+  explicit ParameterizedTestCaseInfo(
+      const char* name, CodeLocation code_location)
+      : test_case_name_(name), code_location_(code_location) {}
+
+  // Test case base name for display purposes.
+  virtual const string& GetTestCaseName() const { return test_case_name_; }
+  // Test case id to verify identity.
+  virtual TypeId GetTestCaseTypeId() const { return GetTypeId<TestCase>(); }
+  // TEST_P macro uses AddTestPattern() to record information
+  // about a single test in a LocalTestInfo structure.
+  // test_case_name is the base name of the test case (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 case base name and DoBar is test base name.
+  void AddTestPattern(const char* test_case_name,
+                      const char* test_base_name,
+                      TestMetaFactoryBase<ParamType>* meta_factory) {
+    tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name,
+                                                       test_base_name,
+                                                       meta_factory)));
+  }
+  // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information
+  // about a generator.
+  int AddTestCaseInstantiation(const 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 case
+  // test cases right before running tests in RUN_ALL_TESTS macro.
+  // This method should not be called more then once on any single
+  // instance of a ParameterizedTestCaseInfoBase derived class.
+  // UnitTest has a guard to prevent from calling this method more then once.
+  virtual void RegisterTests() {
+    for (typename TestInfoContainer::iterator test_it = tests_.begin();
+         test_it != tests_.end(); ++test_it) {
+      linked_ptr<TestInfo> test_info = *test_it;
+      for (typename InstantiationContainer::iterator gen_it =
+               instantiations_.begin(); gen_it != instantiations_.end();
+               ++gen_it) {
+        const 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;
+
+        string test_case_name;
+        if ( !instantiation_name.empty() )
+          test_case_name = instantiation_name + "/";
+        test_case_name += test_info->test_case_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) {
+          Message test_name_stream;
+
+          std::string param_name = name_func(
+              TestParamInfo<ParamType>(*param_it, i));
+
+          GTEST_CHECK_(IsValidParamName(param_name))
+              << "Parameterized test name '" << param_name
+              << "' is invalid, in " << file
+              << " line " << line << std::endl;
+
+          GTEST_CHECK_(test_param_names.count(param_name) == 0)
+              << "Duplicate parameterized test name '" << param_name
+              << "', in " << file << " line " << line << std::endl;
+
+          test_param_names.insert(param_name);
+
+          test_name_stream << test_info->test_base_name << "/" << param_name;
+          MakeAndRegisterTestInfo(
+              test_case_name.c_str(),
+              test_name_stream.GetString().c_str(),
+              NULL,  // No type parameter.
+              PrintToString(*param_it).c_str(),
+              code_location_,
+              GetTestCaseTypeId(),
+              TestCase::SetUpTestCase,
+              TestCase::TearDownTestCase,
+              test_info->test_meta_factory->CreateTestFactory(*param_it));
+        }  // for param_it
+      }  // for gen_it
+    }  // for test_it
+  }  // RegisterTests
+
+ private:
+  // LocalTestInfo structure keeps information about a single test registered
+  // with TEST_P macro.
+  struct TestInfo {
+    TestInfo(const char* a_test_case_base_name,
+             const char* a_test_base_name,
+             TestMetaFactoryBase<ParamType>* a_test_meta_factory) :
+        test_case_base_name(a_test_case_base_name),
+        test_base_name(a_test_base_name),
+        test_meta_factory(a_test_meta_factory) {}
+
+    const string test_case_base_name;
+    const string test_base_name;
+    const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
+  };
+  typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
+  // Records data received from INSTANTIATE_TEST_CASE_P macros:
+  //  <Instantiation name, Sequence generator creation function,
+  //     Name generator function, Source file, Source line>
+  struct InstantiationInfo {
+      InstantiationInfo(const std::string &name_in,
+                        GeneratorCreationFunc* generator_in,
+                        ParamNameGeneratorFunc* name_func_in,
+                        const char* file_in,
+                        int line_in)
+          : name(name_in),
+            generator(generator_in),
+            name_func(name_func_in),
+            file(file_in),
+            line(line_in) {}
+
+      std::string name;
+      GeneratorCreationFunc* generator;
+      ParamNameGeneratorFunc* name_func;
+      const char* file;
+      int line;
+  };
+  typedef ::std::vector<InstantiationInfo> InstantiationContainer;
+
+  static bool IsValidParamName(const std::string& name) {
+    // Check for empty string
+    if (name.empty())
+      return false;
+
+    // Check for invalid characters
+    for (std::string::size_type index = 0; index < name.size(); ++index) {
+      if (!isalnum(name[index]) && name[index] != '_')
+        return false;
+    }
+
+    return true;
+  }
+
+  const string test_case_name_;
+  CodeLocation code_location_;
+  TestInfoContainer tests_;
+  InstantiationContainer instantiations_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo);
+};  // class ParameterizedTestCaseInfo
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase
+// classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
+// macros use it to locate their corresponding ParameterizedTestCaseInfo
+// descriptors.
+class ParameterizedTestCaseRegistry {
+ public:
+  ParameterizedTestCaseRegistry() {}
+  ~ParameterizedTestCaseRegistry() {
+    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
+         it != test_case_infos_.end(); ++it) {
+      delete *it;
+    }
+  }
+
+  // Looks up or creates and returns a structure containing information about
+  // tests and instantiations of a particular test case.
+  template <class TestCase>
+  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
+      const char* test_case_name,
+      CodeLocation code_location) {
+    ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL;
+    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
+         it != test_case_infos_.end(); ++it) {
+      if ((*it)->GetTestCaseName() == test_case_name) {
+        if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) {
+          // Complain about incorrect usage of Google Test facilities
+          // and terminate the program since we cannot guaranty correct
+          // test case setup and tear-down in this case.
+          ReportInvalidTestCaseType(test_case_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<
+              ParameterizedTestCaseInfo<TestCase> >(*it);
+        }
+        break;
+      }
+    }
+    if (typed_test_info == NULL) {
+      typed_test_info = new ParameterizedTestCaseInfo<TestCase>(
+          test_case_name, code_location);
+      test_case_infos_.push_back(typed_test_info);
+    }
+    return typed_test_info;
+  }
+  void RegisterTests() {
+    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
+         it != test_case_infos_.end(); ++it) {
+      (*it)->RegisterTests();
+    }
+  }
+
+ private:
+  typedef ::std::vector<ParameterizedTestCaseInfoBase*> TestCaseInfoContainer;
+
+  TestCaseInfoContainer test_case_infos_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry);
+};
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  //  GTEST_HAS_PARAM_TEST
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port-arch.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port-arch.h
new file mode 100644
index 00000000..74ab9490
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port-arch.h
@@ -0,0 +1,93 @@
+// Copyright 2015, 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 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 GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+#define GTEST_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 __SYMBIAN32__
+# define GTEST_OS_SYMBIAN 1
+#elif defined _WIN32
+# define GTEST_OS_WINDOWS 1
+# ifdef _WIN32_WCE
+#  define GTEST_OS_WINDOWS_MOBILE 1
+# elif defined(__MINGW__) || defined(__MINGW32__)
+#  define GTEST_OS_WINDOWS_MINGW 1
+# elif defined(WINAPI_FAMILY)
+#  include <winapifamily.h>
+#  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#   define GTEST_OS_WINDOWS_DESKTOP 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
+#   define GTEST_OS_WINDOWS_PHONE 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+#   define GTEST_OS_WINDOWS_RT 1
+#  else
+    // WINAPI_FAMILY defined but no known partition matched.
+    // Default to desktop.
+#   define GTEST_OS_WINDOWS_DESKTOP 1
+#  endif
+# else
+#  define GTEST_OS_WINDOWS_DESKTOP 1
+# endif  // _WIN32_WCE
+#elif defined __APPLE__
+# define GTEST_OS_MAC 1
+# if TARGET_OS_IPHONE
+#  define GTEST_OS_IOS 1
+# endif
+#elif defined __FreeBSD__
+# define GTEST_OS_FREEBSD 1
+#elif defined __linux__
+# define GTEST_OS_LINUX 1
+# if defined __ANDROID__
+#  define GTEST_OS_LINUX_ANDROID 1
+# endif
+#elif defined __MVS__
+# define GTEST_OS_ZOS 1
+#elif defined(__sun) && defined(__SVR4)
+# define GTEST_OS_SOLARIS 1
+#elif defined(_AIX)
+# define GTEST_OS_AIX 1
+#elif defined(__hpux)
+# define GTEST_OS_HPUX 1
+#elif defined __native_client__
+# define GTEST_OS_NACL 1
+#elif defined __OpenBSD__
+# define GTEST_OS_OPENBSD 1
+#elif defined __QNX__
+# define GTEST_OS_QNX 1
+#endif  // __CYGWIN__
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port.h
new file mode 100644
index 00000000..860aaaf5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port.h
@@ -0,0 +1,2560 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Authors: wan@google.com (Zhanyong Wan)
+//
+// Low-level types and utilities for porting Google Test to various
+// platforms.  All macros ending with _ and symbols defined in an
+// internal namespace are subject to change without notice.  Code
+// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't
+// end with _ are part of Google Test's public API and can be used by
+// code outside Google Test.
+//
+// This file is fundamental to Google Test.  All other Google Test source
+// files are expected to #include this.  Therefore, it cannot #include
+// any other Google Test header.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+
+// Environment-describing macros
+// -----------------------------
+//
+// Google Test can be used in many different environments.  Macros in
+// this section tell Google Test what kind of environment it is being
+// used in, such that Google Test can provide environment-specific
+// features and implementations.
+//
+// Google Test tries to automatically detect the properties of its
+// environment, so users usually don't need to worry about these
+// macros.  However, the automatic detection is not perfect.
+// Sometimes it's necessary for a user to define some of the following
+// macros in the build script to override Google Test's decisions.
+//
+// If the user doesn't define a macro in the list, Google Test will
+// provide a default definition.  After this header is #included, all
+// macros in this list will be defined to either 1 or 0.
+//
+// Notes to maintainers:
+//   - Each macro here is a user-tweakable knob; do not grow the list
+//     lightly.
+//   - Use #if to key off these macros.  Don't use #ifdef or "#if
+//     defined(...)", which will not work as these macros are ALWAYS
+//     defined.
+//
+//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
+//                              is/isn't available.
+//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
+//                              are enabled.
+//   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
+//                              is/isn't available (some systems define
+//                              ::string, which is different to std::string).
+//   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
+//                              is/isn't available (some systems define
+//                              ::wstring, which is different to std::wstring).
+//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
+//                              expressions are/aren't available.
+//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
+//                              is/isn't available.
+//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
+//                              enabled.
+//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
+//                              std::wstring does/doesn't work (Google Test can
+//                              be used where std::wstring is unavailable).
+//   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple
+//                              is/isn't available.
+//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
+//                              compiler supports Microsoft's "Structured
+//                              Exception Handling".
+//   GTEST_HAS_STREAM_REDIRECTION
+//                            - Define it to 1/0 to indicate whether the
+//                              platform supports I/O stream redirection using
+//                              dup() and dup2().
+//   GTEST_USE_OWN_TR1_TUPLE  - Define it to 1/0 to indicate whether Google
+//                              Test's own tr1 tuple implementation should be
+//                              used.  Unused when the user sets
+//                              GTEST_HAS_TR1_TUPLE to 0.
+//   GTEST_LANG_CXX11         - Define it to 1/0 to indicate that Google Test
+//                              is building in C++11/C++98 mode.
+//   GTEST_LINKED_AS_SHARED_LIBRARY
+//                            - Define to 1 when compiling tests that use
+//                              Google Test as a shared library (known as
+//                              DLL on Windows).
+//   GTEST_CREATE_SHARED_LIBRARY
+//                            - Define to 1 when compiling Google Test itself
+//                              as a shared library.
+
+// Platform-indicating macros
+// --------------------------
+//
+// Macros indicating the platform on which Google Test is being used
+// (a macro is defined to 1 if compiled on the given platform;
+// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
+// defines these macros automatically.  Code outside Google Test MUST
+// NOT define them.
+//
+//   GTEST_OS_AIX      - IBM AIX
+//   GTEST_OS_CYGWIN   - Cygwin
+//   GTEST_OS_FREEBSD  - FreeBSD
+//   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_OPENBSD  - OpenBSD
+//   GTEST_OS_QNX      - QNX
+//   GTEST_OS_SOLARIS  - Sun Solaris
+//   GTEST_OS_SYMBIAN  - Symbian
+//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
+//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
+//     GTEST_OS_WINDOWS_MINGW    - MinGW
+//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
+//     GTEST_OS_WINDOWS_PHONE    - Windows Phone
+//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
+//   GTEST_OS_ZOS      - z/OS
+//
+// Among the platforms, Cygwin, Linux, Max 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
+// googletestframework@googlegroups.com (patches for fixing them are
+// even more welcome!).
+//
+// It is possible that none of the GTEST_OS_* macros are defined.
+
+// Feature-indicating macros
+// -------------------------
+//
+// Macros indicating which Google Test features are available (a macro
+// is defined to 1 if the corresponding feature is supported;
+// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
+// defines these macros automatically.  Code outside Google Test MUST
+// NOT define them.
+//
+// These macros are public so that portable tests can be written.
+// Such tests typically surround code using a feature with an #if
+// which controls that code.  For example:
+//
+// #if GTEST_HAS_DEATH_TEST
+//   EXPECT_DEATH(DoSomethingDeadly());
+// #endif
+//
+//   GTEST_HAS_COMBINE      - the Combine() function (for value-parameterized
+//                            tests)
+//   GTEST_HAS_DEATH_TEST   - death tests
+//   GTEST_HAS_PARAM_TEST   - value-parameterized tests
+//   GTEST_HAS_TYPED_TEST   - typed tests
+//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
+//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
+//   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 two are mutually exclusive.
+//   GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().
+
+// Misc public macros
+// ------------------
+//
+//   GTEST_FLAG(flag_name)  - references the variable corresponding to
+//                            the given Google Test flag.
+
+// Internal utilities
+// ------------------
+//
+// The following macros and utilities are for Google Test's INTERNAL
+// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.
+//
+// Macros for basic C++ coding:
+//   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 operator=.
+//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy 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.
+//
+// C++11 feature wrappers:
+//
+//   testing::internal::move  - portability wrapper for std::move.
+//
+// Synchronization:
+//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
+//                            - synchronization primitives.
+//
+// Template meta programming:
+//   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
+//   IteratorTraits - partial implementation of std::iterator_traits, which
+//                    is not available in libCstd when compiled with Sun C++.
+//
+// Smart pointers:
+//   scoped_ptr     - as in TR2.
+//
+// Regular expressions:
+//   RE             - a simple regular expression class using the POSIX
+//                    Extended Regular Expression syntax on UNIX-like
+//                    platforms, 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.
+//   FlushInfoLog() - flushes informational log messages.
+//
+// Stdout and stderr capturing:
+//   CaptureStdout()     - starts capturing stdout.
+//   GetCapturedStdout() - stops capturing stdout and returns the captured
+//                         string.
+//   CaptureStderr()     - starts capturing stderr.
+//   GetCapturedStderr() - stops capturing stderr and returns the captured
+//                         string.
+//
+// Integer types:
+//   TypeWithSize   - maps an integer to a int type.
+//   Int32, UInt32, Int64, UInt64, TimeInMillis
+//                  - integers of known sizes.
+//   BiggestInt     - the biggest signed integer type.
+//
+// Command-line utilities:
+//   GTEST_DECLARE_*()  - declares a flag.
+//   GTEST_DEFINE_*()   - defines a flag.
+//   GetInjectableArgvs() - returns the command line as a vector of strings.
+//
+// Environment variable utilities:
+//   GetEnv()             - gets the value of an environment variable.
+//   BoolFromGTestEnv()   - parses a bool environment variable.
+//   Int32FromGTestEnv()  - parses an Int32 environment variable.
+//   StringFromGTestEnv() - parses a string environment variable.
+
+#include <ctype.h>   // for isspace, etc
+#include <stddef.h>  // for ptrdiff_t
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#ifndef _WIN32_WCE
+# include <sys/types.h>
+# include <sys/stat.h>
+#endif  // !_WIN32_WCE
+
+#if defined __APPLE__
+# include <AvailabilityMacros.h>
+# include <TargetConditionals.h>
+#endif
+
+#include <algorithm>  // NOLINT
+#include <iostream>  // NOLINT
+#include <sstream>  // NOLINT
+#include <string>  // NOLINT
+#include <utility>
+#include <vector>  // NOLINT
+
+#include "gtest/internal/gtest-port-arch.h"
+#include "gtest/internal/custom/gtest-port.h"
+
+#if !defined(GTEST_DEV_EMAIL_)
+# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
+# define GTEST_FLAG_PREFIX_ "gtest_"
+# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
+# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
+# define GTEST_NAME_ "Google Test"
+# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
+#endif  // !defined(GTEST_DEV_EMAIL_)
+
+#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
+# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
+#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
+
+// Determines the version of gcc that is used to compile this.
+#ifdef __GNUC__
+// 40302 means version 4.3.2.
+# define GTEST_GCC_VER_ \
+    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
+#endif  // __GNUC__
+
+// Macros for disabling Microsoft Visual C++ warnings.
+//
+//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
+//   /* code that triggers warnings C4800 and C4385 */
+//   GTEST_DISABLE_MSC_WARNINGS_POP_()
+#if _MSC_VER >= 1500
+# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
+    __pragma(warning(push))                        \
+    __pragma(warning(disable: warnings))
+# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
+    __pragma(warning(pop))
+#else
+// Older versions of MSVC don't have __pragma.
+# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
+# define GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif
+
+#ifndef GTEST_LANG_CXX11
+// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
+// -std={c,gnu}++{0x,11} is passed.  The C++11 standard specifies a
+// value for __cplusplus, and recent versions of clang, gcc, and
+// probably other compilers set that too in C++11 mode.
+# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L
+// Compiling in at least C++11 mode.
+#  define GTEST_LANG_CXX11 1
+# else
+#  define GTEST_LANG_CXX11 0
+# endif
+#endif
+
+// Distinct from C++11 language support, some environments don't provide
+// proper C++11 library support. Notably, it's possible to build in
+// C++11 mode when targeting Mac OS X 10.6, which has an old libstdc++
+// with no C++11 support.
+//
+// libstdc++ has sufficient C++11 support as of GCC 4.6.0, __GLIBCXX__
+// 20110325, but maintenance releases in the 4.4 and 4.5 series followed
+// this date, so check for those versions by their date stamps.
+// https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html#abi.versioning
+#if GTEST_LANG_CXX11 && \
+    (!defined(__GLIBCXX__) || ( \
+        __GLIBCXX__ >= 20110325ul &&  /* GCC >= 4.6.0 */ \
+        /* Blacklist of patch releases of older branches: */ \
+        __GLIBCXX__ != 20110416ul &&  /* GCC 4.4.6 */ \
+        __GLIBCXX__ != 20120313ul &&  /* GCC 4.4.7 */ \
+        __GLIBCXX__ != 20110428ul &&  /* GCC 4.5.3 */ \
+        __GLIBCXX__ != 20120702ul))   /* GCC 4.5.4 */
+# define GTEST_STDLIB_CXX11 1
+#endif
+
+// Only use C++11 library features if the library provides them.
+#if GTEST_STDLIB_CXX11
+# define GTEST_HAS_STD_BEGIN_AND_END_ 1
+# define GTEST_HAS_STD_FORWARD_LIST_ 1
+# define GTEST_HAS_STD_FUNCTION_ 1
+# define GTEST_HAS_STD_INITIALIZER_LIST_ 1
+# define GTEST_HAS_STD_MOVE_ 1
+# define GTEST_HAS_STD_SHARED_PTR_ 1
+# define GTEST_HAS_STD_TYPE_TRAITS_ 1
+# define GTEST_HAS_STD_UNIQUE_PTR_ 1
+#endif
+
+// C++11 specifies that <tuple> provides std::tuple.
+// Some platforms still might not have it, however.
+#if GTEST_LANG_CXX11
+# define GTEST_HAS_STD_TUPLE_ 1
+# if defined(__clang__)
+// Inspired by http://clang.llvm.org/docs/LanguageExtensions.html#__has_include
+#  if defined(__has_include) && !__has_include(<tuple>)
+#   undef GTEST_HAS_STD_TUPLE_
+#  endif
+# elif defined(_MSC_VER)
+// Inspired by boost/config/stdlib/dinkumware.hpp
+#  if defined(_CPPLIB_VER) && _CPPLIB_VER < 520
+#   undef GTEST_HAS_STD_TUPLE_
+#  endif
+# elif defined(__GLIBCXX__)
+// Inspired by boost/config/stdlib/libstdcpp3.hpp,
+// http://gcc.gnu.org/gcc-4.2/changes.html and
+// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt01ch01.html#manual.intro.status.standard.200x
+#  if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2)
+#   undef GTEST_HAS_STD_TUPLE_
+#  endif
+# endif
+#endif
+
+// Brings in definitions for functions used in the testing::internal::posix
+// namespace (read, write, close, chdir, isatty, stat). We do not currently
+// use them on Windows Mobile.
+#if GTEST_OS_WINDOWS
+# if !GTEST_OS_WINDOWS_MOBILE
+#  include <direct.h>
+#  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.
+// This assumption is verified by
+// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
+typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
+#endif
+#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
+// mentioned above.
+# include <unistd.h>
+# include <strings.h>
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_LINUX_ANDROID
+// Used to define __ANDROID_API__ matching the target NDK API level.
+#  include <android/api-level.h>  // NOLINT
+#endif
+
+// Defines this to true iff 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)
+# endif
+#endif
+
+#if GTEST_USES_PCRE
+// The appropriate headers have already been included.
+
+#elif GTEST_HAS_POSIX_RE
+
+// On some platforms, <regex.h> needs someone to define size_t, and
+// 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>.
+# include <regex.h>  // NOLINT
+
+# define GTEST_USES_POSIX_RE 1
+
+#elif GTEST_OS_WINDOWS
+
+// <regex.h> is not available on Windows.  Use our own simple regex
+// implementation instead.
+# define GTEST_USES_SIMPLE_RE 1
+
+#else
+
+// <regex.h> may not be available on this platform.  Use our own
+// simple regex implementation instead.
+# define GTEST_USES_SIMPLE_RE 1
+
+#endif  // GTEST_USES_PCRE
+
+#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(__BORLANDC__)
+// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
+// macro to enable exceptions, so we'll do the same.
+// Assumes that exceptions are enabled by default.
+#  ifndef _HAS_EXCEPTIONS
+#   define _HAS_EXCEPTIONS 1
+#  endif  // _HAS_EXCEPTIONS
+#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
+# elif defined(__clang__)
+// clang defines __EXCEPTIONS iff exceptions are enabled before clang 220714,
+// but iff 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 iff 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
+// detecting whether they are enabled or not.  Therefore, we assume that
+// they are enabled unless the user tells us otherwise.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__IBMCPP__) && __EXCEPTIONS
+// xlC defines __EXCEPTIONS to 1 iff 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
+// be turned of by +noeh compiler option if desired.
+#  define GTEST_HAS_EXCEPTIONS 1
+# else
+// For other compilers, we assume exceptions are disabled to be
+// conservative.
+#  define GTEST_HAS_EXCEPTIONS 0
+# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#if !defined(GTEST_HAS_STD_STRING)
+// Even though we don't use this macro any longer, we keep it in case
+// some clients still depend on it.
+# define GTEST_HAS_STD_STRING 1
+#elif !GTEST_HAS_STD_STRING
+// The user told us that ::std::string isn't available.
+# error "Google Test cannot be used where ::std::string isn't available."
+#endif  // !defined(GTEST_HAS_STD_STRING)
+
+#ifndef GTEST_HAS_GLOBAL_STRING
+// The user didn't tell us whether ::string is available, so we need
+// to figure it out.
+
+# define GTEST_HAS_GLOBAL_STRING 0
+
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+#ifndef GTEST_HAS_STD_WSTRING
+// The user didn't tell us whether ::std::wstring is available, so we need
+// to figure it out.
+// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
+//   is available.
+
+// 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))
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+#ifndef GTEST_HAS_GLOBAL_WSTRING
+// The user didn't tell us whether ::wstring is available, so we need
+// to figure it out.
+# define GTEST_HAS_GLOBAL_WSTRING \
+    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+// Determines whether RTTI is available.
+#ifndef GTEST_HAS_RTTI
+// The user didn't tell us whether RTTI is enabled, so we need to
+// figure it out.
+
+# ifdef _MSC_VER
+
+#  ifdef _CPPRTTI  // MSVC defines this macro iff 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 iff RTTI is enabled.
+# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
+
+#  ifdef __GXX_RTTI
+// When building against STLport with the Android NDK and with
+// -frtti -fno-exceptions, the build fails at link time with undefined
+// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
+// so disable RTTI when detected.
+#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
+       !defined(__EXCEPTIONS)
+#    define GTEST_HAS_RTTI 0
+#   else
+#    define GTEST_HAS_RTTI 1
+#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif  // __GXX_RTTI
+
+// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
+// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
+// first version with C++ support.
+# elif defined(__clang__)
+
+#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
+
+// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
+// both the typeid and dynamic_cast features are present.
+# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
+
+#  ifdef __RTTI_ALL__
+#   define GTEST_HAS_RTTI 1
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif
+
+# else
+
+// For all other compilers, we assume RTTI is enabled.
+#  define GTEST_HAS_RTTI 1
+
+# endif  // _MSC_VER
+
+#endif  // GTEST_HAS_RTTI
+
+// It's this header's responsibility to #include <typeinfo> when RTTI
+// is enabled.
+#if GTEST_HAS_RTTI
+# include <typeinfo>
+#endif
+
+// Determines whether Google Test can use the pthreads library.
+#ifndef GTEST_HAS_PTHREAD
+// The user didn't tell us explicitly, so we make reasonable assumptions about
+// which platforms have pthreads support.
+//
+// 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)
+#endif  // GTEST_HAS_PTHREAD
+
+#if GTEST_HAS_PTHREAD
+// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
+// true.
+# include <pthread.h>  // NOLINT
+
+// For timespec and nanosleep, used below.
+# include <time.h>  // NOLINT
+#endif
+
+// Determines if hash_map/hash_set are available.
+// Only used for testing against those containers.
+#if !defined(GTEST_HAS_HASH_MAP_)
+# if _MSC_VER
+#  define GTEST_HAS_HASH_MAP_ 1  // Indicates that hash_map is available.
+#  define GTEST_HAS_HASH_SET_ 1  // Indicates that hash_set is available.
+# endif  // _MSC_VER
+#endif  // !defined(GTEST_HAS_HASH_MAP_)
+
+// Determines whether Google Test can use tr1/tuple.  You can define
+// this macro to 0 to prevent Google Test from using tuple (any
+// feature depending on tuple with be disabled in this mode).
+#ifndef GTEST_HAS_TR1_TUPLE
+# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
+// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
+#  define GTEST_HAS_TR1_TUPLE 0
+# else
+// The user didn't tell us not to do it, so we assume it's OK.
+#  define GTEST_HAS_TR1_TUPLE 1
+# endif
+#endif  // GTEST_HAS_TR1_TUPLE
+
+// Determines whether Google Test's own tr1 tuple implementation
+// should be used.
+#ifndef GTEST_USE_OWN_TR1_TUPLE
+// The user didn't tell us, so we need to figure it out.
+
+// We use our own TR1 tuple if we aren't sure the user has an
+// implementation of it already.  At this time, libstdc++ 4.0.0+ and
+// MSVC 2010 are the only mainstream standard libraries that come
+// with a TR1 tuple implementation.  NVIDIA's CUDA NVCC compiler
+// pretends to be GCC by defining __GNUC__ and friends, but cannot
+// compile GCC's tuple implementation.  MSVC 2008 (9.0) provides TR1
+// tuple in a 323 MB Feature Pack download, which we cannot assume the
+// user has.  QNX's QCC compiler is a modified GCC but it doesn't
+// support TR1 tuple.  libc++ only provides std::tuple, in C++11 mode,
+// and it can be used with some compilers that define __GNUC__.
+# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
+      && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600
+#  define GTEST_ENV_HAS_TR1_TUPLE_ 1
+# endif
+
+// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
+// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6
+// can build with clang but need to use gcc4.2's libstdc++).
+# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
+#  define GTEST_ENV_HAS_STD_TUPLE_ 1
+# endif
+
+# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
+#  define GTEST_USE_OWN_TR1_TUPLE 0
+# else
+#  define GTEST_USE_OWN_TR1_TUPLE 1
+# endif
+
+#endif  // GTEST_USE_OWN_TR1_TUPLE
+
+// To avoid conditional compilation everywhere, we make it
+// gtest-port.h's responsibility to #include the header implementing
+// tuple.
+#if GTEST_HAS_STD_TUPLE_
+# include <tuple>  // IWYU pragma: export
+# define GTEST_TUPLE_NAMESPACE_ ::std
+#endif  // GTEST_HAS_STD_TUPLE_
+
+// We include tr1::tuple even if std::tuple is available to define printers for
+// them.
+#if GTEST_HAS_TR1_TUPLE
+# ifndef GTEST_TUPLE_NAMESPACE_
+#  define GTEST_TUPLE_NAMESPACE_ ::std::tr1
+# endif  // GTEST_TUPLE_NAMESPACE_
+
+# if GTEST_USE_OWN_TR1_TUPLE
+#  include "gtest/internal/gtest-tuple.h"  // IWYU pragma: export  // NOLINT
+# elif GTEST_ENV_HAS_STD_TUPLE_
+#  include <tuple>
+// C++11 puts its tuple into the ::std namespace rather than
+// ::std::tr1.  gtest expects tuple to live in ::std::tr1, so put it there.
+// This causes undefined behavior, but supported compilers react in
+// the way we intend.
+namespace std {
+namespace tr1 {
+using ::std::get;
+using ::std::make_tuple;
+using ::std::tuple;
+using ::std::tuple_element;
+using ::std::tuple_size;
+}
+}
+
+# elif GTEST_OS_SYMBIAN
+
+// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
+// use STLport's tuple implementation, which unfortunately doesn't
+// work as the copy of STLport distributed with Symbian is incomplete.
+// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
+// use its own tuple implementation.
+#  ifdef BOOST_HAS_TR1_TUPLE
+#   undef BOOST_HAS_TR1_TUPLE
+#  endif  // BOOST_HAS_TR1_TUPLE
+
+// This prevents <boost/tr1/detail/config.hpp>, which defines
+// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
+#  define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
+#  include <tuple>  // IWYU pragma: export  // NOLINT
+
+# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
+// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header.  This does
+// not conform to the TR1 spec, which requires the header to be <tuple>.
+
+#  if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
+// Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
+// which is #included by <tr1/tuple>, to not compile when RTTI is
+// disabled.  _TR1_FUNCTIONAL is the header guard for
+// <tr1/functional>.  Hence the following #define is a hack to prevent
+// <tr1/functional> from being included.
+#   define _TR1_FUNCTIONAL 1
+#   include <tr1/tuple>
+#   undef _TR1_FUNCTIONAL  // Allows the user to #include
+                        // <tr1/functional> if he chooses to.
+#  else
+#   include <tr1/tuple>  // NOLINT
+#  endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
+
+# else
+// If the compiler is not GCC 4.0+, we assume the user is using a
+// spec-conforming TR1 implementation.
+#  include <tuple>  // IWYU pragma: export  // NOLINT
+# endif  // GTEST_USE_OWN_TR1_TUPLE
+
+#endif  // GTEST_HAS_TR1_TUPLE
+
+// Determines whether clone(2) is supported.
+// Usually it will only be available on Linux, excluding
+// Linux on the Itanium architecture.
+// Also see http://linux.die.net/man/2/clone.
+#ifndef GTEST_HAS_CLONE
+// The user didn't tell us, so we need to figure it out.
+
+# if GTEST_OS_LINUX && !defined(__ia64__)
+#  if GTEST_OS_LINUX_ANDROID
+// On Android, clone() is only available on ARM starting with Gingerbread.
+#    if defined(__arm__) && __ANDROID_API__ >= 9
+#     define GTEST_HAS_CLONE 1
+#    else
+#     define GTEST_HAS_CLONE 0
+#    endif
+#  else
+#   define GTEST_HAS_CLONE 1
+#  endif
+# else
+#  define GTEST_HAS_CLONE 0
+# endif  // GTEST_OS_LINUX && !defined(__ia64__)
+
+#endif  // GTEST_HAS_CLONE
+
+// Determines whether to support stream redirection. This is used to test
+// output correctness and to implement death tests.
+#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_SYMBIAN || \
+    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
+#  define GTEST_HAS_STREAM_REDIRECTION 0
+# else
+#  define GTEST_HAS_STREAM_REDIRECTION 1
+# endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// Determines whether to support death tests.
+// Google Test does not support death tests for VC 7.1 and earlier as
+// abort() in a VC 7.1 application compiled as GUI in debug config
+// 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 >= 1400) || \
+     GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
+     GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD)
+# define GTEST_HAS_DEATH_TEST 1
+#endif
+
+// We don't support MSVC 7.1 with exceptions disabled now.  Therefore
+// all the compilers we care about are adequate for supporting
+// value-parameterized tests.
+#define GTEST_HAS_PARAM_TEST 1
+
+// Determines whether to support type-driven tests.
+
+// 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__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \
+    defined(__IBMCPP__) || defined(__HP_aCC)
+# define GTEST_HAS_TYPED_TEST 1
+# define GTEST_HAS_TYPED_TEST_P 1
+#endif
+
+// Determines whether to support Combine(). This only makes sense when
+// value-parameterized tests are enabled.  The implementation doesn't
+// work on Sun Studio since it doesn't understand templated conversion
+// operators.
+#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC)
+# define GTEST_HAS_COMBINE 1
+#endif
+
+// 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_SYMBIAN || GTEST_OS_AIX)
+
+// Determines whether test results can be streamed to a socket.
+#if GTEST_OS_LINUX
+# define GTEST_CAN_STREAM_RESULTS_ 1
+#endif
+
+// Defines some utility macros.
+
+// The GNU compiler emits a warning if nested "if" statements are followed by
+// an "else" statement and braces are not used to explicitly disambiguate the
+// "else" binding.  This leads to problems with code like:
+//
+//   if (gate)
+//     ASSERT_*(condition) << "Some message";
+//
+// The "switch (0) case 0:" idiom is used to suppress this.
+#ifdef __INTEL_COMPILER
+# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
+#else
+# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
+#endif
+
+// Use this annotation at the end of a struct/class definition to
+// prevent the compiler from optimizing away instances that are never
+// used.  This is useful when all interesting logic happens inside the
+// c'tor and / or d'tor.  Example:
+//
+//   struct Foo {
+//     Foo() { ... }
+//   } GTEST_ATTRIBUTE_UNUSED_;
+//
+// Also use it after a variable or parameter declaration to tell the
+// compiler the variable/parameter does not have to be used.
+#if defined(__GNUC__) && !defined(COMPILER_ICC)
+# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
+#elif defined(__clang__)
+# if __has_attribute(unused)
+#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
+# endif
+#endif
+#ifndef GTEST_ATTRIBUTE_UNUSED_
+# define GTEST_ATTRIBUTE_UNUSED_
+#endif
+
+// A macro to disallow operator=
+// This should be used in the private: declarations for a class.
+#define GTEST_DISALLOW_ASSIGN_(type)\
+  void operator=(type const &)
+
+// 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 &);\
+  GTEST_DISALLOW_ASSIGN_(type)
+
+// 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__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
+# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
+#else
+# define GTEST_MUST_USE_RESULT_
+#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !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
+// suppressed. Use the following two macros in such cases:
+//
+// GTEST_INTENTIONAL_CONST_COND_PUSH_()
+// while (true) {
+// GTEST_INTENTIONAL_CONST_COND_POP_()
+// }
+# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
+    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
+# define GTEST_INTENTIONAL_CONST_COND_POP_() \
+    GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+// Determine whether the compiler supports Microsoft's Structured Exception
+// Handling.  This is supported by several Windows compilers but generally
+// does not exist on any other system.
+#ifndef GTEST_HAS_SEH
+// The user didn't tell us, so we need to figure it out.
+
+# if defined(_MSC_VER) || defined(__BORLANDC__)
+// These two compilers are known to support SEH.
+#  define GTEST_HAS_SEH 1
+# else
+// Assume no SEH.
+#  define GTEST_HAS_SEH 0
+# endif
+
+#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_HAS_SEH
+
+#ifdef _MSC_VER
+# if GTEST_LINKED_AS_SHARED_LIBRARY
+#  define GTEST_API_ __declspec(dllimport)
+# elif GTEST_CREATE_SHARED_LIBRARY
+#  define GTEST_API_ __declspec(dllexport)
+# endif
+#elif __GNUC__ >= 4 || defined(__clang__)
+# define GTEST_API_ __attribute__((visibility ("default")))
+#endif // _MSC_VER
+
+#ifndef GTEST_API_
+# define GTEST_API_
+#endif
+
+#ifdef __GNUC__
+// Ask the compiler to never inline a given function.
+# define GTEST_NO_INLINE_ __attribute__((noinline))
+#else
+# define GTEST_NO_INLINE_
+#endif
+
+// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
+#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
+# define GTEST_HAS_CXXABI_H_ 1
+#else
+# define GTEST_HAS_CXXABI_H_ 0
+#endif
+
+// A function level attribute to disable checking for use of uninitialized
+// memory when built with MemorySanitizer.
+#if defined(__clang__)
+# if __has_feature(memory_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
+       __attribute__((no_sanitize_memory))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+# endif  // __has_feature(memory_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+#endif  // __clang__
+
+// A function level attribute to disable AddressSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(address_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
+       __attribute__((no_sanitize_address))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+# endif  // __has_feature(address_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+#endif  // __clang__
+
+// A function level attribute to disable ThreadSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(thread_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
+       __attribute__((no_sanitize_thread))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+# endif  // __has_feature(thread_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+#endif  // __clang__
+
+namespace testing {
+
+class Message;
+
+#if defined(GTEST_TUPLE_NAMESPACE_)
+// Import tuple and friends into the ::testing namespace.
+// It is part of our interface, having them in ::testing allows us to change
+// their types as needed.
+using GTEST_TUPLE_NAMESPACE_::get;
+using GTEST_TUPLE_NAMESPACE_::make_tuple;
+using GTEST_TUPLE_NAMESPACE_::tuple;
+using GTEST_TUPLE_NAMESPACE_::tuple_size;
+using GTEST_TUPLE_NAMESPACE_::tuple_element;
+#endif  // defined(GTEST_TUPLE_NAMESPACE_)
+
+namespace internal {
+
+// A secret type that Google Test users don't know about.  It has no
+// definition on purpose.  Therefore it's impossible to create a
+// Secret object, which is what we want.
+class Secret;
+
+// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
+// expression is true. 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);
+//
+// or to make sure a struct is smaller than a certain size:
+//
+//   GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
+//
+// The second argument to the macro is the name of the variable. If
+// the expression is false, most compilers will issue a warning/error
+// containing the name of the variable.
+
+#if GTEST_LANG_CXX11
+# define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
+#else  // !GTEST_LANG_CXX11
+template <bool>
+  struct CompileAssert {
+};
+
+# define GTEST_COMPILE_ASSERT_(expr, msg) \
+  typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
+      msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
+#endif  // !GTEST_LANG_CXX11
+
+// Implementation details of GTEST_COMPILE_ASSERT_:
+//
+// (In C++11, we simply use static_assert instead of the following)
+//
+// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
+//   elements (and thus is invalid) when the expression is false.
+//
+// - The simpler definition
+//
+//    #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
+//
+//   does not work, as gcc supports variable-length arrays whose sizes
+//   are determined at run-time (this is gcc's extension and not part
+//   of the C++ standard).  As a result, gcc fails to reject the
+//   following code with the simple definition:
+//
+//     int foo;
+//     GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
+//                                      // not a compile-time constant.
+//
+// - By using the type CompileAssert<(bool(expr))>, we ensures that
+//   expr is a compile-time constant.  (Template arguments must be
+//   determined at compile-time.)
+//
+// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
+//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
+//
+//     CompileAssert<bool(expr)>
+//
+//   instead, these compilers will refuse to compile
+//
+//     GTEST_COMPILE_ASSERT_(5 > 0, some_message);
+//
+//   (They seem to think the ">" in "5 > 0" marks the end of the
+//   template argument list.)
+//
+// - The array size is (bool(expr) ? 1 : -1), instead of simply
+//
+//     ((expr) ? 1 : -1).
+//
+//   This is to avoid running into a bug in MS VC 7.1, which
+//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
+
+// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
+//
+// This template is declared, but intentionally undefined.
+template <typename T1, typename T2>
+struct StaticAssertTypeEqHelper;
+
+template <typename T>
+struct StaticAssertTypeEqHelper<T, T> {
+  enum { value = true };
+};
+
+// Evaluates to the number of elements in 'array'.
+#define GTEST_ARRAY_SIZE_(array) (sizeof(array) / sizeof(array[0]))
+
+#if GTEST_HAS_GLOBAL_STRING
+typedef ::string string;
+#else
+typedef ::std::string string;
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+#if GTEST_HAS_GLOBAL_WSTRING
+typedef ::wstring wstring;
+#elif GTEST_HAS_STD_WSTRING
+typedef ::std::wstring wstring;
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+// A helper for suppressing warnings on constant condition.  It just
+// returns 'condition'.
+GTEST_API_ bool IsTrue(bool condition);
+
+// Defines scoped_ptr.
+
+// This implementation of scoped_ptr is PARTIAL - it only contains
+// enough stuff to satisfy Google Test's need.
+template <typename T>
+class scoped_ptr {
+ public:
+  typedef T element_type;
+
+  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
+  ~scoped_ptr() { reset(); }
+
+  T& operator*() const { return *ptr_; }
+  T* operator->() const { return ptr_; }
+  T* get() const { return ptr_; }
+
+  T* release() {
+    T* const ptr = ptr_;
+    ptr_ = NULL;
+    return ptr;
+  }
+
+  void reset(T* p = NULL) {
+    if (p != ptr_) {
+      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
+        delete ptr_;
+      }
+      ptr_ = p;
+    }
+  }
+
+  friend void swap(scoped_ptr& a, scoped_ptr& b) {
+    using std::swap;
+    swap(a.ptr_, b.ptr_);
+  }
+
+ private:
+  T* ptr_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
+};
+
+// Defines RE.
+
+// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
+// Regular Expression syntax.
+class GTEST_API_ RE {
+ public:
+  // A copy constructor is required by the Standard to initialize object
+  // references from r-values.
+  RE(const RE& other) { Init(other.pattern()); }
+
+  // Constructs an RE from a string.
+  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
+
+#if GTEST_HAS_GLOBAL_STRING
+
+  RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
+
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+  RE(const char* regex) { Init(regex); }  // NOLINT
+  ~RE();
+
+  // Returns the string representation of the regex.
+  const char* pattern() const { return pattern_; }
+
+  // FullMatch(str, re) returns true iff regular expression re matches
+  // the entire str.
+  // PartialMatch(str, re) returns true iff regular expression re
+  // matches a substring of str (including str itself).
+  //
+  // TODO(wan@google.com): make FullMatch() and PartialMatch() work
+  // when str contains NUL characters.
+  static bool FullMatch(const ::std::string& str, const RE& re) {
+    return FullMatch(str.c_str(), re);
+  }
+  static bool PartialMatch(const ::std::string& str, const RE& re) {
+    return PartialMatch(str.c_str(), re);
+  }
+
+#if GTEST_HAS_GLOBAL_STRING
+
+  static bool FullMatch(const ::string& str, const RE& re) {
+    return FullMatch(str.c_str(), re);
+  }
+  static bool PartialMatch(const ::string& str, const RE& re) {
+    return PartialMatch(str.c_str(), re);
+  }
+
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+  static bool FullMatch(const char* str, const RE& re);
+  static bool PartialMatch(const char* str, const RE& re);
+
+ private:
+  void Init(const char* regex);
+
+  // We use a const char* instead of an std::string, as Google Test used to be
+  // used where std::string is not available.  TODO(wan@google.com): change to
+  // std::string.
+  const char* pattern_;
+  bool is_valid_;
+
+#if GTEST_USES_POSIX_RE
+
+  regex_t full_regex_;     // For FullMatch().
+  regex_t partial_regex_;  // For PartialMatch().
+
+#else  // GTEST_USES_SIMPLE_RE
+
+  const char* full_pattern_;  // For FullMatch();
+
+#endif
+
+  GTEST_DISALLOW_ASSIGN_(RE);
+};
+
+// 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);
+
+// Formats a file location for compiler-independent XML output.
+// Although this function is not platform dependent, we put it next to
+// FormatFileLocation in order to contrast the two functions.
+GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
+                                                               int line);
+
+// Defines logging utilities:
+//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
+//                          message itself is streamed into the macro.
+//   LogToStderr()  - directs all log messages to stderr.
+//   FlushInfoLog() - flushes informational log messages.
+
+enum GTestLogSeverity {
+  GTEST_INFO,
+  GTEST_WARNING,
+  GTEST_ERROR,
+  GTEST_FATAL
+};
+
+// Formats log entry severity, provides a stream object for streaming the
+// log message, and terminates the message with a newline when going out of
+// scope.
+class GTEST_API_ GTestLog {
+ public:
+  GTestLog(GTestLogSeverity severity, const char* file, int line);
+
+  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
+  ~GTestLog();
+
+  ::std::ostream& GetStream() { return ::std::cerr; }
+
+ private:
+  const GTestLogSeverity severity_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
+};
+
+#if !defined(GTEST_LOG_)
+
+# define GTEST_LOG_(severity) \
+    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
+                                  __FILE__, __LINE__).GetStream()
+
+inline void LogToStderr() {}
+inline void FlushInfoLog() { fflush(NULL); }
+
+#endif  // !defined(GTEST_LOG_)
+
+#if !defined(GTEST_CHECK_)
+// INTERNAL IMPLEMENTATION - DO NOT USE.
+//
+// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
+// is not satisfied.
+//  Synopsys:
+//    GTEST_CHECK_(boolean_condition);
+//     or
+//    GTEST_CHECK_(boolean_condition) << "Additional message";
+//
+//    This checks the condition and if the condition is not satisfied
+//    it prints message about the condition violation, including the
+//    condition itself, plus additional message streamed into it, if any,
+//    and then it aborts the program. It aborts the program irrespective of
+//    whether it is built in the debug mode or not.
+# define GTEST_CHECK_(condition) \
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+    if (::testing::internal::IsTrue(condition)) \
+      ; \
+    else \
+      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
+#endif  // !defined(GTEST_CHECK_)
+
+// An all-mode assert to verify that the given POSIX-style function
+// call returns 0 (indicating success).  Known limitation: this
+// doesn't expand to a balanced 'if' statement, so enclose the macro
+// in {} if you need to use it as the only statement in an 'if'
+// branch.
+#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
+  if (const int gtest_error = (posix_call)) \
+    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
+                      << gtest_error
+
+#if GTEST_HAS_STD_MOVE_
+using std::move;
+#else  // GTEST_HAS_STD_MOVE_
+template <typename T>
+const T& move(const T& t) {
+  return t;
+}
+#endif  // GTEST_HAS_STD_MOVE_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Use ImplicitCast_ as a safe version of static_cast for upcasting in
+// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
+// const Foo*).  When you use ImplicitCast_, the compiler checks that
+// the cast is safe.  Such explicit ImplicitCast_s are necessary in
+// surprisingly many situations where C++ demands an exact type match
+// instead of an argument type convertable to a target type.
+//
+// The syntax for using ImplicitCast_ is the same as for static_cast:
+//
+//   ImplicitCast_<ToType>(expr)
+//
+// ImplicitCast_ would have been part of the C++ standard library,
+// but the proposal was submitted too late.  It will probably make
+// its way into the language in the future.
+//
+// This relatively ugly name is intentional. It prevents clashes with
+// similar functions users may have (e.g., implicit_cast). The internal
+// namespace alone is not enough because the function can be found by ADL.
+template<typename To>
+inline To ImplicitCast_(To x) { return x; }
+
+// When you upcast (that is, cast a pointer from type Foo to type
+// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
+// always succeed.  When you downcast (that is, cast a pointer from
+// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
+// how do you know the pointer is really of type SubclassOfFoo?  It
+// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
+// when you downcast, you should use this macro.  In debug mode, we
+// use dynamic_cast<> to double-check the downcast is legal (we die
+// if it's not).  In normal mode, we do the efficient static_cast<>
+// instead.  Thus, it's important to test in debug mode to make sure
+// the cast is legal!
+//    This is the only place in the code we should use dynamic_cast<>.
+// In particular, you SHOULDN'T be using dynamic_cast<> in order to
+// do RTTI (eg code like this:
+//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
+//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
+// You should design the code some other way not to need this.
+//
+// This relatively ugly name is intentional. It prevents clashes with
+// similar functions users may have (e.g., down_cast). The internal
+// namespace alone is not enough because the function can be found by ADL.
+template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
+inline To DownCast_(From* f) {  // so we only accept pointers
+  // Ensures that To is a sub-type of From *.  This test is here only
+  // for compile-time type checking, and has no overhead in an
+  // optimized build at run-time, as it will be optimized away
+  // completely.
+  GTEST_INTENTIONAL_CONST_COND_PUSH_()
+  if (false) {
+  GTEST_INTENTIONAL_CONST_COND_POP_()
+    const To to = NULL;
+    ::testing::internal::ImplicitCast_<From*>(to);
+  }
+
+#if GTEST_HAS_RTTI
+  // RTTI: debug mode only!
+  GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
+#endif
+  return static_cast<To>(f);
+}
+
+// Downcasts the pointer of type Base to Derived.
+// Derived must be a subclass of Base. The parameter MUST
+// point to a class of type Derived, not any subclass of it.
+// When RTTI is available, the function performs a runtime
+// check to enforce this.
+template <class Derived, class Base>
+Derived* CheckedDowncastToActualType(Base* base) {
+#if GTEST_HAS_RTTI
+  GTEST_CHECK_(typeid(*base) == typeid(Derived));
+#endif
+
+#if GTEST_HAS_DOWNCAST_
+  return ::down_cast<Derived*>(base);
+#elif GTEST_HAS_RTTI
+  return dynamic_cast<Derived*>(base);  // NOLINT
+#else
+  return static_cast<Derived*>(base);  // Poor man's downcast.
+#endif
+}
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Defines the stderr capturer:
+//   CaptureStdout     - starts capturing stdout.
+//   GetCapturedStdout - stops capturing stdout and returns the captured string.
+//   CaptureStderr     - starts capturing stderr.
+//   GetCapturedStderr - stops capturing stderr and returns the captured string.
+//
+GTEST_API_ void CaptureStdout();
+GTEST_API_ std::string GetCapturedStdout();
+GTEST_API_ void CaptureStderr();
+GTEST_API_ std::string GetCapturedStderr();
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// Returns a path to temporary directory.
+GTEST_API_ std::string TempDir();
+
+// Returns the size (in bytes) of a file.
+GTEST_API_ size_t GetFileSize(FILE* file);
+
+// Reads the entire content of a file as a string.
+GTEST_API_ std::string ReadEntireFile(FILE* file);
+
+// All command line arguments.
+GTEST_API_ const ::std::vector<testing::internal::string>& GetArgvs();
+
+#if GTEST_HAS_DEATH_TEST
+
+const ::std::vector<testing::internal::string>& GetInjectableArgvs();
+void SetInjectableArgvs(const ::std::vector<testing::internal::string>*
+                             new_argvs);
+
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Defines synchronization primitives.
+#if GTEST_IS_THREADSAFE
+# if GTEST_HAS_PTHREAD
+// Sleeps for (roughly) n milliseconds.  This function is only for testing
+// Google Test's own constructs.  Don't use it in user tests, either
+// directly or indirectly.
+inline void SleepMilliseconds(int n) {
+  const timespec time = {
+    0,                  // 0 seconds.
+    n * 1000L * 1000L,  // And n ms.
+  };
+  nanosleep(&time, NULL);
+}
+# endif  // GTEST_HAS_PTHREAD
+
+# if GTEST_HAS_NOTIFICATION_
+// Notification has already been imported into the namespace.
+// Nothing to do here.
+
+# elif GTEST_HAS_PTHREAD
+// Allows a controller thread to pause execution of newly created
+// threads until notified.  Instances of this class must be created
+// and destroyed in the controller thread.
+//
+// This class is only for testing Google Test's own constructs. Do not
+// use it in user tests, either directly or indirectly.
+class Notification {
+ public:
+  Notification() : notified_(false) {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
+  }
+  ~Notification() {
+    pthread_mutex_destroy(&mutex_);
+  }
+
+  // Notifies all threads created with this notification to start. Must
+  // be called from the controller thread.
+  void Notify() {
+    pthread_mutex_lock(&mutex_);
+    notified_ = true;
+    pthread_mutex_unlock(&mutex_);
+  }
+
+  // Blocks until the controller thread notifies. Must be called from a test
+  // thread.
+  void WaitForNotification() {
+    for (;;) {
+      pthread_mutex_lock(&mutex_);
+      const bool notified = notified_;
+      pthread_mutex_unlock(&mutex_);
+      if (notified)
+        break;
+      SleepMilliseconds(10);
+    }
+  }
+
+ private:
+  pthread_mutex_t mutex_;
+  bool notified_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
+};
+
+# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+
+GTEST_API_ void SleepMilliseconds(int n);
+
+// Provides leak-safe Windows kernel handle ownership.
+// Used in death tests and in threading support.
+class GTEST_API_ AutoHandle {
+ public:
+  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to
+  // avoid including <windows.h> in this header file. Including <windows.h> is
+  // undesirable because it defines a lot of symbols and macros that tend to
+  // conflict with client code. This assumption is verified by
+  // WindowsTypesTest.HANDLEIsVoidStar.
+  typedef void* Handle;
+  AutoHandle();
+  explicit AutoHandle(Handle handle);
+
+  ~AutoHandle();
+
+  Handle Get() const;
+  void Reset();
+  void Reset(Handle handle);
+
+ private:
+  // Returns true iff the handle is a valid handle object that can be closed.
+  bool IsCloseable() const;
+
+  Handle handle_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
+};
+
+// Allows a controller thread to pause execution of newly created
+// threads until notified.  Instances of this class must be created
+// and destroyed in the controller thread.
+//
+// This class is only for testing Google Test's own constructs. Do not
+// use it in user tests, either directly or indirectly.
+class GTEST_API_ Notification {
+ public:
+  Notification();
+  void Notify();
+  void WaitForNotification();
+
+ private:
+  AutoHandle event_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
+};
+# endif  // GTEST_HAS_NOTIFICATION_
+
+// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
+// defined, but we don't want to use MinGW's pthreads implementation, which
+// has conformance problems with some versions of the POSIX standard.
+# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
+
+// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
+// Consequently, it cannot select a correct instantiation of ThreadWithParam
+// in order to call its Run(). Introducing ThreadWithParamBase as a
+// non-templated base class for ThreadWithParam allows us to bypass this
+// problem.
+class ThreadWithParamBase {
+ public:
+  virtual ~ThreadWithParamBase() {}
+  virtual void Run() = 0;
+};
+
+// pthread_create() accepts a pointer to a function type with the C linkage.
+// According to the Standard (7.5/1), function types with different linkages
+// are different even if they are otherwise identical.  Some compilers (for
+// example, SunStudio) treat them as different types.  Since class methods
+// cannot be defined with C-linkage we need to define a free C-function to
+// pass into pthread_create().
+extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
+  static_cast<ThreadWithParamBase*>(thread)->Run();
+  return NULL;
+}
+
+// Helper class for testing Google Test's multi-threading constructs.
+// To use it, write:
+//
+//   void ThreadFunc(int param) { /* Do things with param */ }
+//   Notification thread_can_start;
+//   ...
+//   // The thread_can_start parameter is optional; you can supply NULL.
+//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
+//   thread_can_start.Notify();
+//
+// These classes are only for testing Google Test's own constructs. Do
+// not use them in user tests, either directly or indirectly.
+template <typename T>
+class ThreadWithParam : public ThreadWithParamBase {
+ public:
+  typedef void UserThreadFunc(T);
+
+  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
+      : func_(func),
+        param_(param),
+        thread_can_start_(thread_can_start),
+        finished_(false) {
+    ThreadWithParamBase* const base = this;
+    // The thread can be created only after all fields except thread_
+    // have been initialized.
+    GTEST_CHECK_POSIX_SUCCESS_(
+        pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
+  }
+  ~ThreadWithParam() { Join(); }
+
+  void Join() {
+    if (!finished_) {
+      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
+      finished_ = true;
+    }
+  }
+
+  virtual void Run() {
+    if (thread_can_start_ != NULL)
+      thread_can_start_->WaitForNotification();
+    func_(param_);
+  }
+
+ private:
+  UserThreadFunc* const func_;  // User-supplied thread function.
+  const T param_;  // User-supplied parameter to the thread function.
+  // When non-NULL, used to block execution until the controller thread
+  // notifies.
+  Notification* const thread_can_start_;
+  bool finished_;  // true iff we know that the thread function has finished.
+  pthread_t thread_;  // The native thread object.
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
+};
+# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
+         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+
+# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+// Mutex and ThreadLocal have already been imported into the namespace.
+// Nothing to do here.
+
+# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+
+// Mutex implements mutex on Windows platforms.  It is used in conjunction
+// with class MutexLock:
+//
+//   Mutex mutex;
+//   ...
+//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the
+//                            // end of the current scope.
+//
+// A static Mutex *must* be defined or declared using one of the following
+// macros:
+//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
+//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
+//
+// (A non-static Mutex is defined/declared in the usual way).
+class GTEST_API_ Mutex {
+ public:
+  enum MutexType { kStatic = 0, kDynamic = 1 };
+  // We rely on kStaticMutex being 0 as it is to what the linker initializes
+  // type_ in static mutexes.  critical_section_ will be initialized lazily
+  // in ThreadSafeLazyInit().
+  enum StaticConstructorSelector { kStaticMutex = 0 };
+
+  // This constructor intentionally does nothing.  It relies on type_ being
+  // statically initialized to 0 (effectively setting it to kStatic) and on
+  // ThreadSafeLazyInit() to lazily initialize the rest of the members.
+  explicit Mutex(StaticConstructorSelector /*dummy*/) {}
+
+  Mutex();
+  ~Mutex();
+
+  void Lock();
+
+  void Unlock();
+
+  // Does nothing if the current thread holds the mutex. Otherwise, crashes
+  // with high probability.
+  void AssertHeld();
+
+ private:
+  // Initializes owner_thread_id_ and critical_section_ in static mutexes.
+  void ThreadSafeLazyInit();
+
+  // Per http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx,
+  // we assume that 0 is an invalid value for thread IDs.
+  unsigned int owner_thread_id_;
+
+  // For static mutexes, we rely on these members being initialized to zeros
+  // by the linker.
+  MutexType type_;
+  long critical_section_init_phase_;  // NOLINT
+  GTEST_CRITICAL_SECTION* critical_section_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
+};
+
+# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+    extern ::testing::internal::Mutex mutex
+
+# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
+    ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(Mutex* mutex)
+      : mutex_(mutex) { mutex_->Lock(); }
+
+  ~GTestMutexLock() { mutex_->Unlock(); }
+
+ private:
+  Mutex* const mutex_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
+};
+
+typedef GTestMutexLock MutexLock;
+
+// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value
+// without knowing its type.
+class ThreadLocalValueHolderBase {
+ public:
+  virtual ~ThreadLocalValueHolderBase() {}
+};
+
+// Provides a way for a thread to send notifications to a ThreadLocal
+// regardless of its parameter type.
+class ThreadLocalBase {
+ public:
+  // Creates a new ValueHolder<T> object holding a default value passed to
+  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's
+  // responsibility not to call this when the ThreadLocal<T> instance already
+  // has a value on the current thread.
+  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;
+
+ protected:
+  ThreadLocalBase() {}
+  virtual ~ThreadLocalBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
+};
+
+// Maps a thread to a set of ThreadLocals that have values instantiated on that
+// thread and notifies them when the thread exits.  A ThreadLocal instance is
+// expected to persist until all threads it has values on have terminated.
+class GTEST_API_ ThreadLocalRegistry {
+ public:
+  // Registers thread_local_instance as having value on the current thread.
+  // Returns a value that can be used to identify the thread from other threads.
+  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance);
+
+  // Invoked when a ThreadLocal instance is destroyed.
+  static void OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance);
+};
+
+class GTEST_API_ ThreadWithParamBase {
+ public:
+  void Join();
+
+ protected:
+  class Runnable {
+   public:
+    virtual ~Runnable() {}
+    virtual void Run() = 0;
+  };
+
+  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
+  virtual ~ThreadWithParamBase();
+
+ private:
+  AutoHandle thread_;
+};
+
+// Helper class for testing Google Test's multi-threading constructs.
+template <typename T>
+class ThreadWithParam : public ThreadWithParamBase {
+ public:
+  typedef void UserThreadFunc(T);
+
+  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
+      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
+  }
+  virtual ~ThreadWithParam() {}
+
+ private:
+  class RunnableImpl : public Runnable {
+   public:
+    RunnableImpl(UserThreadFunc* func, T param)
+        : func_(func),
+          param_(param) {
+    }
+    virtual ~RunnableImpl() {}
+    virtual void Run() {
+      func_(param_);
+    }
+
+   private:
+    UserThreadFunc* const func_;
+    const T param_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
+  };
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
+};
+
+// Implements thread-local storage on Windows systems.
+//
+//   // Thread 1
+//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
+//
+//   // Thread 2
+//   tl.set(150);  // Changes the value for thread 2 only.
+//   EXPECT_EQ(150, tl.get());
+//
+//   // Thread 1
+//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
+//   tl.set(200);
+//   EXPECT_EQ(200, tl.get());
+//
+// The template type argument T must have a public copy constructor.
+// In addition, the default ThreadLocal constructor requires T to have
+// a public default constructor.
+//
+// The users of a TheadLocal instance have to make sure that all but one
+// threads (including the main one) using that instance have exited before
+// destroying it. Otherwise, the per-thread objects managed for them by the
+// ThreadLocal instance are not guaranteed to be destroyed on all platforms.
+//
+// Google Test only uses global ThreadLocal objects.  That means they
+// will die after main() has returned.  Therefore, no per-thread
+// object managed by Google Test will be leaked as long as all threads
+// using Google Test have exited when main() returns.
+template <typename T>
+class ThreadLocal : public ThreadLocalBase {
+ public:
+  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
+  explicit ThreadLocal(const T& value)
+      : default_factory_(new InstanceValueHolderFactory(value)) {}
+
+  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
+
+  T* pointer() { return GetOrCreateValue(); }
+  const T* pointer() const { return GetOrCreateValue(); }
+  const T& get() const { return *pointer(); }
+  void set(const T& value) { *pointer() = value; }
+
+ private:
+  // Holds a value of T.  Can be deleted via its base class without the caller
+  // knowing the type of T.
+  class ValueHolder : public ThreadLocalValueHolderBase {
+   public:
+    ValueHolder() : value_() {}
+    explicit ValueHolder(const T& value) : value_(value) {}
+
+    T* pointer() { return &value_; }
+
+   private:
+    T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
+  };
+
+
+  T* GetOrCreateValue() const {
+    return static_cast<ValueHolder*>(
+        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
+  }
+
+  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
+    return default_factory_->MakeNewHolder();
+  }
+
+  class ValueHolderFactory {
+   public:
+    ValueHolderFactory() {}
+    virtual ~ValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const = 0;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
+  };
+
+  class DefaultValueHolderFactory : public ValueHolderFactory {
+   public:
+    DefaultValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
+  };
+
+  class InstanceValueHolderFactory : public ValueHolderFactory {
+   public:
+    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
+    virtual ValueHolder* MakeNewHolder() const {
+      return new ValueHolder(value_);
+    }
+
+   private:
+    const T value_;  // The value for each thread.
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
+  };
+
+  scoped_ptr<ValueHolderFactory> default_factory_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
+};
+
+# elif GTEST_HAS_PTHREAD
+
+// MutexBase and Mutex implement mutex on pthreads-based platforms.
+class MutexBase {
+ public:
+  // Acquires this mutex.
+  void Lock() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
+    owner_ = pthread_self();
+    has_owner_ = true;
+  }
+
+  // Releases this mutex.
+  void Unlock() {
+    // Since the lock is being released the owner_ field should no longer be
+    // considered valid. We don't protect writing to has_owner_ here, as it's
+    // the caller's responsibility to ensure that the current thread holds the
+    // mutex when this is called.
+    has_owner_ = false;
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
+  }
+
+  // Does nothing if the current thread holds the mutex. Otherwise, crashes
+  // with high probability.
+  void AssertHeld() const {
+    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
+        << "The current thread is not holding the mutex @" << this;
+  }
+
+  // A static mutex may be used before main() is entered.  It may even
+  // be used before the dynamic initialization stage.  Therefore we
+  // must be able to initialize a static mutex object at link time.
+  // This means MutexBase has to be a POD and its member variables
+  // have to be public.
+ public:
+  pthread_mutex_t mutex_;  // The underlying pthread mutex.
+  // has_owner_ indicates whether the owner_ field below contains a valid thread
+  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
+  // accesses to the owner_ field should be protected by a check of this field.
+  // An alternative might be to memset() owner_ to all zeros, but there's no
+  // guarantee that a zero'd pthread_t is necessarily invalid or even different
+  // from pthread_self().
+  bool has_owner_;
+  pthread_t owner_;  // The thread holding the mutex.
+};
+
+// Forward-declares a static mutex.
+#  define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+     extern ::testing::internal::MutexBase mutex
+
+// Defines and statically (i.e. at link time) initializes a static mutex.
+#  define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
+     ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false, pthread_t() }
+
+// 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_, NULL));
+    has_owner_ = false;
+  }
+  ~Mutex() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
+};
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(MutexBase* mutex)
+      : mutex_(mutex) { mutex_->Lock(); }
+
+  ~GTestMutexLock() { mutex_->Unlock(); }
+
+ private:
+  MutexBase* const mutex_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
+};
+
+typedef GTestMutexLock MutexLock;
+
+// Helpers for ThreadLocal.
+
+// pthread_key_create() requires DeleteThreadLocalValue() to have
+// C-linkage.  Therefore it cannot be templatized to access
+// ThreadLocal<T>.  Hence the need for class
+// ThreadLocalValueHolderBase.
+class ThreadLocalValueHolderBase {
+ public:
+  virtual ~ThreadLocalValueHolderBase() {}
+};
+
+// Called by pthread to delete thread-local data stored by
+// pthread_setspecific().
+extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
+  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
+}
+
+// Implements thread-local storage on pthreads-based systems.
+template <typename T>
+class ThreadLocal {
+ public:
+  ThreadLocal()
+      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
+  explicit ThreadLocal(const T& value)
+      : key_(CreateKey()),
+        default_factory_(new InstanceValueHolderFactory(value)) {}
+
+  ~ThreadLocal() {
+    // Destroys the managed object for the current thread, if any.
+    DeleteThreadLocalValue(pthread_getspecific(key_));
+
+    // Releases resources associated with the key.  This will *not*
+    // delete managed objects for other threads.
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
+  }
+
+  T* pointer() { return GetOrCreateValue(); }
+  const T* pointer() const { return GetOrCreateValue(); }
+  const T& get() const { return *pointer(); }
+  void set(const T& value) { *pointer() = value; }
+
+ private:
+  // Holds a value of type T.
+  class ValueHolder : public ThreadLocalValueHolderBase {
+   public:
+    ValueHolder() : value_() {}
+    explicit ValueHolder(const T& value) : value_(value) {}
+
+    T* pointer() { return &value_; }
+
+   private:
+    T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
+  };
+
+  static pthread_key_t CreateKey() {
+    pthread_key_t key;
+    // When a thread exits, DeleteThreadLocalValue() will be called on
+    // the object managed for that thread.
+    GTEST_CHECK_POSIX_SUCCESS_(
+        pthread_key_create(&key, &DeleteThreadLocalValue));
+    return key;
+  }
+
+  T* GetOrCreateValue() const {
+    ThreadLocalValueHolderBase* const holder =
+        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
+    if (holder != NULL) {
+      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
+    }
+
+    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
+    ThreadLocalValueHolderBase* const holder_base = new_holder;
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
+    return new_holder->pointer();
+  }
+
+  class ValueHolderFactory {
+   public:
+    ValueHolderFactory() {}
+    virtual ~ValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const = 0;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
+  };
+
+  class DefaultValueHolderFactory : public ValueHolderFactory {
+   public:
+    DefaultValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
+  };
+
+  class InstanceValueHolderFactory : public ValueHolderFactory {
+   public:
+    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
+    virtual ValueHolder* MakeNewHolder() const {
+      return new ValueHolder(value_);
+    }
+
+   private:
+    const T value_;  // The value for each thread.
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
+  };
+
+  // A key pthreads uses for looking up per-thread values.
+  const pthread_key_t key_;
+  scoped_ptr<ValueHolderFactory> default_factory_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
+};
+
+# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+
+#else  // GTEST_IS_THREADSAFE
+
+// A dummy implementation of synchronization primitives (mutex, lock,
+// and thread-local variable).  Necessary for compiling Google Test where
+// mutex is not supported - using Google Test in multiple threads is not
+// supported on such platforms.
+
+class Mutex {
+ public:
+  Mutex() {}
+  void Lock() {}
+  void Unlock() {}
+  void AssertHeld() const {}
+};
+
+# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+  extern ::testing::internal::Mutex mutex
+
+# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(Mutex*) {}  // NOLINT
+};
+
+typedef GTestMutexLock MutexLock;
+
+template <typename T>
+class ThreadLocal {
+ public:
+  ThreadLocal() : value_() {}
+  explicit ThreadLocal(const T& value) : value_(value) {}
+  T* pointer() { return &value_; }
+  const T* pointer() const { return &value_; }
+  const T& get() const { return value_; }
+  void set(const T& value) { value_ = value; }
+ private:
+  T value_;
+};
+
+#endif  // GTEST_IS_THREADSAFE
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+GTEST_API_ size_t GetThreadCount();
+
+// Passing non-POD classes through ellipsis (...) crashes the ARM
+// compiler and generates a warning in Sun Studio.  The Nokia Symbian
+// and the IBM XL C/C++ compiler try to instantiate a copy constructor
+// for objects passed through ellipsis (...), failing for uncopyable
+// objects.  We define this to ensure that only POD is passed through
+// ellipsis on these systems.
+#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
+// We lose support for NULL detection where the compiler doesn't like
+// passing non-POD classes through ellipsis (...).
+# define GTEST_ELLIPSIS_NEEDS_POD_ 1
+#else
+# define GTEST_CAN_COMPARE_NULL 1
+#endif
+
+// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
+// const T& and const T* in a function template.  These compilers
+// _can_ decide between class template specializations for T and T*,
+// so a tr1::type_traits-like is_pointer works.
+#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
+# define GTEST_NEEDS_IS_POINTER_ 1
+#endif
+
+template <bool bool_value>
+struct bool_constant {
+  typedef bool_constant<bool_value> type;
+  static const bool value = bool_value;
+};
+template <bool bool_value> const bool bool_constant<bool_value>::value;
+
+typedef bool_constant<false> false_type;
+typedef bool_constant<true> true_type;
+
+template <typename T>
+struct is_pointer : public false_type {};
+
+template <typename T>
+struct is_pointer<T*> : public true_type {};
+
+template <typename Iterator>
+struct IteratorTraits {
+  typedef typename Iterator::value_type value_type;
+};
+
+template <typename T>
+struct IteratorTraits<T*> {
+  typedef T value_type;
+};
+
+template <typename T>
+struct IteratorTraits<const T*> {
+  typedef T value_type;
+};
+
+#if GTEST_OS_WINDOWS
+# define GTEST_PATH_SEP_ "\\"
+# define GTEST_HAS_ALT_PATH_SEP_ 1
+// The biggest signed integer type the compiler supports.
+typedef __int64 BiggestInt;
+#else
+# define GTEST_PATH_SEP_ "/"
+# define GTEST_HAS_ALT_PATH_SEP_ 0
+typedef long long BiggestInt;  // NOLINT
+#endif  // GTEST_OS_WINDOWS
+
+// Utilities for char.
+
+// isspace(int ch) and friends accept an unsigned char or EOF.  char
+// may be signed, depending on the compiler (or compiler flags).
+// Therefore we need to cast a char to unsigned char before calling
+// isspace(), etc.
+
+inline bool IsAlpha(char ch) {
+  return isalpha(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsAlNum(char ch) {
+  return isalnum(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsDigit(char ch) {
+  return isdigit(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsLower(char ch) {
+  return islower(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsSpace(char ch) {
+  return isspace(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsUpper(char ch) {
+  return isupper(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsXDigit(char ch) {
+  return isxdigit(static_cast<unsigned char>(ch)) != 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;
+}
+
+inline char ToLower(char ch) {
+  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
+}
+inline char ToUpper(char ch) {
+  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
+}
+
+inline std::string StripTrailingSpaces(std::string str) {
+  std::string::iterator it = str.end();
+  while (it != str.begin() && IsSpace(*--it))
+    it = str.erase(it);
+  return str;
+}
+
+// The testing::internal::posix namespace holds wrappers for common
+// POSIX functions.  These wrappers hide the differences between
+// Windows/MSVC and POSIX systems.  Since some compilers define these
+// standard functions as macros, the wrapper cannot have the same name
+// as the wrapped function.
+
+namespace posix {
+
+// Functions with a different name on Windows.
+
+#if GTEST_OS_WINDOWS
+
+typedef struct _stat StatStruct;
+
+# ifdef __BORLANDC__
+inline int IsATTY(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 IsATTY(int /* fd */) { return 0; }
+#  else
+inline int IsATTY(int fd) { return _isatty(fd); }
+#  endif  // GTEST_OS_WINDOWS_MOBILE
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return _stricmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return _strdup(src); }
+# endif  // __BORLANDC__
+
+# if GTEST_OS_WINDOWS_MOBILE
+inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
+// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
+// time and thus not defined there.
+# else
+inline int FileNo(FILE* file) { return _fileno(file); }
+inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
+inline int RmDir(const char* dir) { return _rmdir(dir); }
+inline bool IsDir(const StatStruct& st) {
+  return (_S_IFDIR & st.st_mode) != 0;
+}
+# endif  // GTEST_OS_WINDOWS_MOBILE
+
+#else
+
+typedef struct stat StatStruct;
+
+inline int FileNo(FILE* file) { return fileno(file); }
+inline int IsATTY(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);
+}
+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); }
+
+#endif  // GTEST_OS_WINDOWS
+
+// Functions deprecated by MSVC 8.0.
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */)
+
+inline const char* StrNCpy(char* dest, const char* src, size_t n) {
+  return strncpy(dest, src, n);
+}
+
+// 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
+inline int ChDir(const char* dir) { return chdir(dir); }
+#endif
+inline FILE* FOpen(const char* path, const char* mode) {
+  return fopen(path, mode);
+}
+#if !GTEST_OS_WINDOWS_MOBILE
+inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
+  return freopen(path, mode, stream);
+}
+inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
+#endif
+inline int FClose(FILE* fp) { return fclose(fp); }
+#if !GTEST_OS_WINDOWS_MOBILE
+inline int Read(int fd, void* buf, unsigned int count) {
+  return static_cast<int>(read(fd, buf, count));
+}
+inline int Write(int fd, const void* buf, unsigned int count) {
+  return static_cast<int>(write(fd, buf, count));
+}
+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
+  // We are on Windows CE, which has no environment variables.
+  static_cast<void>(name);  // To prevent 'unused argument' warning.
+  return NULL;
+#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 != NULL && env[0] != '\0') ? env : NULL;
+#else
+  return getenv(name);
+#endif
+}
+
+GTEST_DISABLE_MSC_WARNINGS_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.
+void Abort();
+#else
+inline void Abort() { abort(); }
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+}  // namespace posix
+
+// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
+// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
+// 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 >= 1400 && !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 and MSVC prior to 2005 doesn't
+// complain about _snprintf.
+# define GTEST_SNPRINTF_ _snprintf
+#else
+# define GTEST_SNPRINTF_ snprintf
+#endif
+
+// The maximum number a BiggestInt can represent.  This definition
+// works no matter BiggestInt is represented in one's complement or
+// two's complement.
+//
+// We cannot rely on numeric_limits in STL, as __int64 and long long
+// are not part of standard C++ and numeric_limits doesn't need to be
+// defined for them.
+const BiggestInt kMaxBiggestInt =
+    ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
+
+// 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.
+//
+//   TypeWithSize<4>::UInt
+//
+// is typedef-ed to be unsigned int (unsigned integer made up of 4
+// bytes).
+//
+// Such functionality should belong to STL, but I cannot find it
+// there.
+//
+// Google Test uses this class in the implementation of floating-point
+// comparison.
+//
+// For now it only handles UInt (unsigned int) as that's all Google Test
+// needs.  Other types can be easily added in the future if need
+// arises.
+template <size_t size>
+class TypeWithSize {
+ public:
+  // This prevents the user from using TypeWithSize<N> with incorrect
+  // values of N.
+  typedef void UInt;
+};
+
+// The specialization for size 4.
+template <>
+class TypeWithSize<4> {
+ public:
+  // unsigned int has size 4 in both gcc and MSVC.
+  //
+  // As base/basictypes.h doesn't compile on Windows, we cannot use
+  // uint32, uint64, and etc here.
+  typedef int Int;
+  typedef unsigned int UInt;
+};
+
+// The specialization for size 8.
+template <>
+class TypeWithSize<8> {
+ public:
+#if GTEST_OS_WINDOWS
+  typedef __int64 Int;
+  typedef unsigned __int64 UInt;
+#else
+  typedef long long Int;  // NOLINT
+  typedef unsigned long long UInt;  // NOLINT
+#endif  // GTEST_OS_WINDOWS
+};
+
+// Integer types of known sizes.
+typedef TypeWithSize<4>::Int Int32;
+typedef TypeWithSize<4>::UInt UInt32;
+typedef TypeWithSize<8>::Int Int64;
+typedef TypeWithSize<8>::UInt UInt64;
+typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
+
+// Utilities for command line flags and environment variables.
+
+// Macro for referencing flags.
+#if !defined(GTEST_FLAG)
+# define GTEST_FLAG(name) FLAGS_gtest_##name
+#endif  // !defined(GTEST_FLAG)
+
+#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
+# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
+#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
+
+#if !defined(GTEST_DECLARE_bool_)
+# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
+
+// Macros for declaring flags.
+# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
+# define GTEST_DECLARE_int32_(name) \
+    GTEST_API_ extern ::testing::internal::Int32 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) \
+    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
+#define GTEST_DEFINE_int32_(name, default_val, doc) \
+    GTEST_API_ ::testing::internal::Int32 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_)
+
+// Thread annotations
+#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
+# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
+# define GTEST_LOCK_EXCLUDED_(locks)
+#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
+
+// 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.
+// TODO(chandlerc): Find a better way to refactor flag and environment parsing
+// out of both gtest-port.cc and gtest.cc to avoid exporting this utility
+// function.
+bool ParseInt32(const Message& src_text, const char* str, Int32* value);
+
+// Parses a bool/Int32/string from the environment variable
+// corresponding to the given Google Test flag.
+bool BoolFromGTestEnv(const char* flag, bool default_val);
+GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
+std::string StringFromGTestEnv(const char* flag, const char* default_val);
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-string.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-string.h
new file mode 100644
index 00000000..97f1a7fd
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-string.h
@@ -0,0 +1,167 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
+//
+// The Google C++ Testing 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/gtest-internal.h>.
+// It should not be #included by other files.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+
+#ifdef __BORLANDC__
+// string.h is not guaranteed to provide strcpy on C++ Builder.
+# include <mem.h>
+#endif
+
+#include <string.h>
+#include <string>
+
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+namespace internal {
+
+// String - an abstract class holding static string utilities.
+class GTEST_API_ String {
+ public:
+  // Static utility methods
+
+  // Clones a 0-terminated C string, allocating memory using new.  The
+  // caller is responsible for deleting the return value using
+  // delete[].  Returns the cloned string, or NULL if the input is
+  // NULL.
+  //
+  // This is different from strdup() in string.h, which allocates
+  // memory using malloc().
+  static const char* CloneCString(const char* c_str);
+
+#if GTEST_OS_WINDOWS_MOBILE
+  // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
+  // able to pass strings to Win32 APIs on CE we need to convert them
+  // to 'Unicode', UTF-16.
+
+  // Creates a UTF-16 wide string from the given ANSI string, allocating
+  // memory using new. The caller is responsible for deleting the return
+  // value using delete[]. Returns the wide string, or NULL if the
+  // input is NULL.
+  //
+  // The wide string is created using the ANSI codepage (CP_ACP) to
+  // match the behaviour of the ANSI versions of Win32 calls and the
+  // C runtime.
+  static LPCWSTR AnsiToUtf16(const char* c_str);
+
+  // Creates an ANSI string from the given wide string, allocating
+  // memory using new. The caller is responsible for deleting the return
+  // value using delete[]. Returns the ANSI string, or NULL if the
+  // input is NULL.
+  //
+  // The returned string is created using the ANSI codepage (CP_ACP) to
+  // match the behaviour of the ANSI versions of Win32 calls and the
+  // C runtime.
+  static const char* Utf16ToAnsi(LPCWSTR utf16_str);
+#endif
+
+  // Compares two C strings.  Returns true iff 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.
+  static bool CStringEquals(const char* lhs, const char* rhs);
+
+  // Converts a wide C string to a String using the UTF-8 encoding.
+  // NULL will be converted to "(null)".  If an error occurred during
+  // the conversion, "(failed to convert from wide string)" is
+  // returned.
+  static std::string ShowWideCString(const wchar_t* wide_c_str);
+
+  // Compares two wide C strings.  Returns true iff 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 iff 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.
+  static bool CaseInsensitiveCStringEquals(const char* lhs,
+                                           const char* rhs);
+
+  // Compares two wide C strings, ignoring case.  Returns true iff 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.
+  static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
+                                               const wchar_t* rhs);
+
+  // Returns true iff 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 as "%X".
+  static std::string FormatHexInt(int value);
+
+  // Formats a byte as "%02X".
+  static std::string FormatByte(unsigned char value);
+
+ private:
+  String();  // Not meant to be instantiated.
+};  // class String
+
+// Gets the content of the stringstream's buffer as an std::string.  Each '\0'
+// character in the buffer is replaced with "\\0".
+GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h
new file mode 100644
index 00000000..e9b40534
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h
@@ -0,0 +1,1020 @@
+// This file was GENERATED by command:
+//     pump.py gtest-tuple.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// Copyright 2009 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Implements a subset of TR1 tuple needed by Google Test and Google Mock.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
+
+#include <utility>  // For ::std::pair.
+
+// The compiler used in Symbian has a bug that prevents us from declaring the
+// tuple template as a friend (it complains that tuple is redefined).  This
+// hack bypasses the bug by declaring the members that should otherwise be
+// private as public.
+// Sun Studio versions < 12 also have the above bug.
+#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
+# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
+#else
+# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
+    template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
+   private:
+#endif
+
+// Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that conflict
+// with our own definitions. Therefore using our own tuple does not work on
+// those compilers.
+#if defined(_MSC_VER) && _MSC_VER >= 1600  /* 1600 is Visual Studio 2010 */
+# error "gtest's tuple doesn't compile on Visual Studio 2010 or later. \
+GTEST_USE_OWN_TR1_TUPLE must be set to 0 on those compilers."
+#endif
+
+// GTEST_n_TUPLE_(T) is the type of an n-tuple.
+#define GTEST_0_TUPLE_(T) tuple<>
+#define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \
+    void, void, void>
+#define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \
+    void, void, void>
+#define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \
+    void, void, void>
+#define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \
+    void, void, void>
+#define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
+    void, void, void>
+#define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
+    void, void, void>
+#define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
+    void, void, void>
+#define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
+    T##7, void, void>
+#define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
+    T##7, T##8, void>
+#define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
+    T##7, T##8, T##9>
+
+// GTEST_n_TYPENAMES_(T) declares a list of n typenames.
+#define GTEST_0_TYPENAMES_(T)
+#define GTEST_1_TYPENAMES_(T) typename T##0
+#define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1
+#define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2
+#define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3
+#define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3, typename T##4
+#define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3, typename T##4, typename T##5
+#define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3, typename T##4, typename T##5, typename T##6
+#define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3, typename T##4, typename T##5, typename T##6, typename T##7
+#define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3, typename T##4, typename T##5, typename T##6, \
+    typename T##7, typename T##8
+#define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
+    typename T##3, typename T##4, typename T##5, typename T##6, \
+    typename T##7, typename T##8, typename T##9
+
+// In theory, defining stuff in the ::std namespace is undefined
+// behavior.  We can do this as we are playing the role of a standard
+// library vendor.
+namespace std {
+namespace tr1 {
+
+template <typename T0 = void, typename T1 = void, typename T2 = void,
+    typename T3 = void, typename T4 = void, typename T5 = void,
+    typename T6 = void, typename T7 = void, typename T8 = void,
+    typename T9 = void>
+class tuple;
+
+// Anything in namespace gtest_internal is Google Test's INTERNAL
+// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
+namespace gtest_internal {
+
+// ByRef<T>::type is T if T is a reference; otherwise it's const T&.
+template <typename T>
+struct ByRef { typedef const T& type; };  // NOLINT
+template <typename T>
+struct ByRef<T&> { typedef T& type; };  // NOLINT
+
+// A handy wrapper for ByRef.
+#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
+
+// AddRef<T>::type is T if T is a reference; otherwise it's T&.  This
+// is the same as tr1::add_reference<T>::type.
+template <typename T>
+struct AddRef { typedef T& type; };  // NOLINT
+template <typename T>
+struct AddRef<T&> { typedef T& type; };  // NOLINT
+
+// A handy wrapper for AddRef.
+#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
+
+// A helper for implementing get<k>().
+template <int k> class Get;
+
+// A helper for implementing tuple_element<k, T>.  kIndexValid is true
+// iff k < the number of fields in tuple type T.
+template <bool kIndexValid, int kIndex, class Tuple>
+struct TupleElement;
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > {
+  typedef T0 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > {
+  typedef T1 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > {
+  typedef T2 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > {
+  typedef T3 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > {
+  typedef T4 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > {
+  typedef T5 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > {
+  typedef T6 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > {
+  typedef T7 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > {
+  typedef T8 type;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > {
+  typedef T9 type;
+};
+
+}  // namespace gtest_internal
+
+template <>
+class tuple<> {
+ public:
+  tuple() {}
+  tuple(const tuple& /* t */)  {}
+  tuple& operator=(const tuple& /* t */) { return *this; }
+};
+
+template <GTEST_1_TYPENAMES_(T)>
+class GTEST_1_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
+
+  tuple(const tuple& t) : f0_(t.f0_) {}
+
+  template <GTEST_1_TYPENAMES_(U)>
+  tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_1_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_1_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    return *this;
+  }
+
+  T0 f0_;
+};
+
+template <GTEST_2_TYPENAMES_(T)>
+class GTEST_2_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
+      f1_(f1) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
+
+  template <GTEST_2_TYPENAMES_(U)>
+  tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
+  template <typename U0, typename U1>
+  tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_2_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+  template <typename U0, typename U1>
+  tuple& operator=(const ::std::pair<U0, U1>& p) {
+    f0_ = p.first;
+    f1_ = p.second;
+    return *this;
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_2_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+};
+
+template <GTEST_3_TYPENAMES_(T)>
+class GTEST_3_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
+
+  template <GTEST_3_TYPENAMES_(U)>
+  tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_3_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_3_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+};
+
+template <GTEST_4_TYPENAMES_(T)>
+class GTEST_4_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2),
+      f3_(f3) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
+
+  template <GTEST_4_TYPENAMES_(U)>
+  tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_4_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_4_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+};
+
+template <GTEST_5_TYPENAMES_(T)>
+class GTEST_5_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3,
+      GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
+      f4_(t.f4_) {}
+
+  template <GTEST_5_TYPENAMES_(U)>
+  tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_), f4_(t.f4_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_5_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_5_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    f4_ = t.f4_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+  T4 f4_;
+};
+
+template <GTEST_6_TYPENAMES_(T)>
+class GTEST_6_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
+      GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
+      f5_(f5) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
+      f4_(t.f4_), f5_(t.f5_) {}
+
+  template <GTEST_6_TYPENAMES_(U)>
+  tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_6_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_6_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    f4_ = t.f4_;
+    f5_ = t.f5_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+  T4 f4_;
+  T5 f5_;
+};
+
+template <GTEST_7_TYPENAMES_(T)>
+class GTEST_7_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
+      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2),
+      f3_(f3), f4_(f4), f5_(f5), f6_(f6) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
+      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
+
+  template <GTEST_7_TYPENAMES_(U)>
+  tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_7_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_7_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    f4_ = t.f4_;
+    f5_ = t.f5_;
+    f6_ = t.f6_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+  T4 f4_;
+  T5 f5_;
+  T6 f6_;
+};
+
+template <GTEST_8_TYPENAMES_(T)>
+class GTEST_8_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
+      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6,
+      GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
+      f5_(f5), f6_(f6), f7_(f7) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
+      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
+
+  template <GTEST_8_TYPENAMES_(U)>
+  tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_8_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_8_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    f4_ = t.f4_;
+    f5_ = t.f5_;
+    f6_ = t.f6_;
+    f7_ = t.f7_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+  T4 f4_;
+  T5 f5_;
+  T6 f6_;
+  T7 f7_;
+};
+
+template <GTEST_9_TYPENAMES_(T)>
+class GTEST_9_TUPLE_(T) {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
+      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
+      GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
+      f5_(f5), f6_(f6), f7_(f7), f8_(f8) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
+      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
+
+  template <GTEST_9_TYPENAMES_(U)>
+  tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_9_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_9_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    f4_ = t.f4_;
+    f5_ = t.f5_;
+    f6_ = t.f6_;
+    f7_ = t.f7_;
+    f8_ = t.f8_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+  T4 f4_;
+  T5 f5_;
+  T6 f6_;
+  T7 f7_;
+  T8 f8_;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+class tuple {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(),
+      f9_() {}
+
+  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
+      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
+      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
+      GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2),
+      f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {}
+
+  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
+      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {}
+
+  template <GTEST_10_TYPENAMES_(U)>
+  tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
+      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
+      f9_(t.f9_) {}
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_10_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_10_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
+    f0_ = t.f0_;
+    f1_ = t.f1_;
+    f2_ = t.f2_;
+    f3_ = t.f3_;
+    f4_ = t.f4_;
+    f5_ = t.f5_;
+    f6_ = t.f6_;
+    f7_ = t.f7_;
+    f8_ = t.f8_;
+    f9_ = t.f9_;
+    return *this;
+  }
+
+  T0 f0_;
+  T1 f1_;
+  T2 f2_;
+  T3 f3_;
+  T4 f4_;
+  T5 f5_;
+  T6 f6_;
+  T7 f7_;
+  T8 f8_;
+  T9 f9_;
+};
+
+// 6.1.3.2 Tuple creation functions.
+
+// Known limitations: we don't support passing an
+// std::tr1::reference_wrapper<T> to make_tuple().  And we don't
+// implement tie().
+
+inline tuple<> make_tuple() { return tuple<>(); }
+
+template <GTEST_1_TYPENAMES_(T)>
+inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) {
+  return GTEST_1_TUPLE_(T)(f0);
+}
+
+template <GTEST_2_TYPENAMES_(T)>
+inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
+  return GTEST_2_TUPLE_(T)(f0, f1);
+}
+
+template <GTEST_3_TYPENAMES_(T)>
+inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
+  return GTEST_3_TUPLE_(T)(f0, f1, f2);
+}
+
+template <GTEST_4_TYPENAMES_(T)>
+inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3) {
+  return GTEST_4_TUPLE_(T)(f0, f1, f2, f3);
+}
+
+template <GTEST_5_TYPENAMES_(T)>
+inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3, const T4& f4) {
+  return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4);
+}
+
+template <GTEST_6_TYPENAMES_(T)>
+inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3, const T4& f4, const T5& f5) {
+  return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5);
+}
+
+template <GTEST_7_TYPENAMES_(T)>
+inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3, const T4& f4, const T5& f5, const T6& f6) {
+  return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6);
+}
+
+template <GTEST_8_TYPENAMES_(T)>
+inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) {
+  return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7);
+}
+
+template <GTEST_9_TYPENAMES_(T)>
+inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
+    const T8& f8) {
+  return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8);
+}
+
+template <GTEST_10_TYPENAMES_(T)>
+inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
+    const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
+    const T8& f8, const T9& f9) {
+  return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
+}
+
+// 6.1.3.3 Tuple helper classes.
+
+template <typename Tuple> struct tuple_size;
+
+template <GTEST_0_TYPENAMES_(T)>
+struct tuple_size<GTEST_0_TUPLE_(T) > {
+  static const int value = 0;
+};
+
+template <GTEST_1_TYPENAMES_(T)>
+struct tuple_size<GTEST_1_TUPLE_(T) > {
+  static const int value = 1;
+};
+
+template <GTEST_2_TYPENAMES_(T)>
+struct tuple_size<GTEST_2_TUPLE_(T) > {
+  static const int value = 2;
+};
+
+template <GTEST_3_TYPENAMES_(T)>
+struct tuple_size<GTEST_3_TUPLE_(T) > {
+  static const int value = 3;
+};
+
+template <GTEST_4_TYPENAMES_(T)>
+struct tuple_size<GTEST_4_TUPLE_(T) > {
+  static const int value = 4;
+};
+
+template <GTEST_5_TYPENAMES_(T)>
+struct tuple_size<GTEST_5_TUPLE_(T) > {
+  static const int value = 5;
+};
+
+template <GTEST_6_TYPENAMES_(T)>
+struct tuple_size<GTEST_6_TUPLE_(T) > {
+  static const int value = 6;
+};
+
+template <GTEST_7_TYPENAMES_(T)>
+struct tuple_size<GTEST_7_TUPLE_(T) > {
+  static const int value = 7;
+};
+
+template <GTEST_8_TYPENAMES_(T)>
+struct tuple_size<GTEST_8_TUPLE_(T) > {
+  static const int value = 8;
+};
+
+template <GTEST_9_TYPENAMES_(T)>
+struct tuple_size<GTEST_9_TUPLE_(T) > {
+  static const int value = 9;
+};
+
+template <GTEST_10_TYPENAMES_(T)>
+struct tuple_size<GTEST_10_TUPLE_(T) > {
+  static const int value = 10;
+};
+
+template <int k, class Tuple>
+struct tuple_element {
+  typedef typename gtest_internal::TupleElement<
+      k < (tuple_size<Tuple>::value), k, Tuple>::type type;
+};
+
+#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
+
+// 6.1.3.4 Element access.
+
+namespace gtest_internal {
+
+template <>
+class Get<0> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
+  Field(Tuple& t) { return t.f0_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
+  ConstField(const Tuple& t) { return t.f0_; }
+};
+
+template <>
+class Get<1> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
+  Field(Tuple& t) { return t.f1_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
+  ConstField(const Tuple& t) { return t.f1_; }
+};
+
+template <>
+class Get<2> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
+  Field(Tuple& t) { return t.f2_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
+  ConstField(const Tuple& t) { return t.f2_; }
+};
+
+template <>
+class Get<3> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
+  Field(Tuple& t) { return t.f3_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
+  ConstField(const Tuple& t) { return t.f3_; }
+};
+
+template <>
+class Get<4> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
+  Field(Tuple& t) { return t.f4_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
+  ConstField(const Tuple& t) { return t.f4_; }
+};
+
+template <>
+class Get<5> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
+  Field(Tuple& t) { return t.f5_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
+  ConstField(const Tuple& t) { return t.f5_; }
+};
+
+template <>
+class Get<6> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
+  Field(Tuple& t) { return t.f6_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
+  ConstField(const Tuple& t) { return t.f6_; }
+};
+
+template <>
+class Get<7> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
+  Field(Tuple& t) { return t.f7_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
+  ConstField(const Tuple& t) { return t.f7_; }
+};
+
+template <>
+class Get<8> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
+  Field(Tuple& t) { return t.f8_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
+  ConstField(const Tuple& t) { return t.f8_; }
+};
+
+template <>
+class Get<9> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
+  Field(Tuple& t) { return t.f9_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
+  ConstField(const Tuple& t) { return t.f9_; }
+};
+
+}  // namespace gtest_internal
+
+template <int k, GTEST_10_TYPENAMES_(T)>
+GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
+get(GTEST_10_TUPLE_(T)& t) {
+  return gtest_internal::Get<k>::Field(t);
+}
+
+template <int k, GTEST_10_TYPENAMES_(T)>
+GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k,  GTEST_10_TUPLE_(T)))
+get(const GTEST_10_TUPLE_(T)& t) {
+  return gtest_internal::Get<k>::ConstField(t);
+}
+
+// 6.1.3.5 Relational operators
+
+// We only implement == and !=, as we don't have a need for the rest yet.
+
+namespace gtest_internal {
+
+// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
+// first k fields of t1 equals the first k fields of t2.
+// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
+// k1 != k2.
+template <int kSize1, int kSize2>
+struct SameSizeTuplePrefixComparator;
+
+template <>
+struct SameSizeTuplePrefixComparator<0, 0> {
+  template <class Tuple1, class Tuple2>
+  static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
+    return true;
+  }
+};
+
+template <int k>
+struct SameSizeTuplePrefixComparator<k, k> {
+  template <class Tuple1, class Tuple2>
+  static bool Eq(const Tuple1& t1, const Tuple2& t2) {
+    return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
+        ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
+  }
+};
+
+}  // namespace gtest_internal
+
+template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
+inline bool operator==(const GTEST_10_TUPLE_(T)& t,
+                       const GTEST_10_TUPLE_(U)& u) {
+  return gtest_internal::SameSizeTuplePrefixComparator<
+      tuple_size<GTEST_10_TUPLE_(T) >::value,
+      tuple_size<GTEST_10_TUPLE_(U) >::value>::Eq(t, u);
+}
+
+template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
+inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
+                       const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
+
+// 6.1.4 Pairs.
+// Unimplemented.
+
+}  // namespace tr1
+}  // namespace std
+
+#undef GTEST_0_TUPLE_
+#undef GTEST_1_TUPLE_
+#undef GTEST_2_TUPLE_
+#undef GTEST_3_TUPLE_
+#undef GTEST_4_TUPLE_
+#undef GTEST_5_TUPLE_
+#undef GTEST_6_TUPLE_
+#undef GTEST_7_TUPLE_
+#undef GTEST_8_TUPLE_
+#undef GTEST_9_TUPLE_
+#undef GTEST_10_TUPLE_
+
+#undef GTEST_0_TYPENAMES_
+#undef GTEST_1_TYPENAMES_
+#undef GTEST_2_TYPENAMES_
+#undef GTEST_3_TYPENAMES_
+#undef GTEST_4_TYPENAMES_
+#undef GTEST_5_TYPENAMES_
+#undef GTEST_6_TYPENAMES_
+#undef GTEST_7_TYPENAMES_
+#undef GTEST_8_TYPENAMES_
+#undef GTEST_9_TYPENAMES_
+#undef GTEST_10_TYPENAMES_
+
+#undef GTEST_DECLARE_TUPLE_AS_FRIEND_
+#undef GTEST_BY_REF_
+#undef GTEST_ADD_REF_
+#undef GTEST_TUPLE_ELEMENT_
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h.pump b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h.pump
new file mode 100644
index 00000000..429ddfee
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h.pump
@@ -0,0 +1,347 @@
+$$ -*- mode: c++; -*-
+$var n = 10  $$ Maximum number of tuple fields we want to support.
+$$ This meta comment fixes auto-indentation in Emacs. }}
+// Copyright 2009 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Implements a subset of TR1 tuple needed by Google Test and Google Mock.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
+
+#include <utility>  // For ::std::pair.
+
+// The compiler used in Symbian has a bug that prevents us from declaring the
+// tuple template as a friend (it complains that tuple is redefined).  This
+// hack bypasses the bug by declaring the members that should otherwise be
+// private as public.
+// Sun Studio versions < 12 also have the above bug.
+#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
+# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
+#else
+# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
+    template <GTEST_$(n)_TYPENAMES_(U)> friend class tuple; \
+   private:
+#endif
+
+// Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that conflict
+// with our own definitions. Therefore using our own tuple does not work on
+// those compilers.
+#if defined(_MSC_VER) && _MSC_VER >= 1600  /* 1600 is Visual Studio 2010 */
+# error "gtest's tuple doesn't compile on Visual Studio 2010 or later. \
+GTEST_USE_OWN_TR1_TUPLE must be set to 0 on those compilers."
+#endif
+
+
+$range i 0..n-1
+$range j 0..n
+$range k 1..n
+// GTEST_n_TUPLE_(T) is the type of an n-tuple.
+#define GTEST_0_TUPLE_(T) tuple<>
+
+$for k [[
+$range m 0..k-1
+$range m2 k..n-1
+#define GTEST_$(k)_TUPLE_(T) tuple<$for m, [[T##$m]]$for m2 [[, void]]>
+
+]]
+
+// GTEST_n_TYPENAMES_(T) declares a list of n typenames.
+
+$for j [[
+$range m 0..j-1
+#define GTEST_$(j)_TYPENAMES_(T) $for m, [[typename T##$m]]
+
+
+]]
+
+// In theory, defining stuff in the ::std namespace is undefined
+// behavior.  We can do this as we are playing the role of a standard
+// library vendor.
+namespace std {
+namespace tr1 {
+
+template <$for i, [[typename T$i = void]]>
+class tuple;
+
+// Anything in namespace gtest_internal is Google Test's INTERNAL
+// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
+namespace gtest_internal {
+
+// ByRef<T>::type is T if T is a reference; otherwise it's const T&.
+template <typename T>
+struct ByRef { typedef const T& type; };  // NOLINT
+template <typename T>
+struct ByRef<T&> { typedef T& type; };  // NOLINT
+
+// A handy wrapper for ByRef.
+#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
+
+// AddRef<T>::type is T if T is a reference; otherwise it's T&.  This
+// is the same as tr1::add_reference<T>::type.
+template <typename T>
+struct AddRef { typedef T& type; };  // NOLINT
+template <typename T>
+struct AddRef<T&> { typedef T& type; };  // NOLINT
+
+// A handy wrapper for AddRef.
+#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
+
+// A helper for implementing get<k>().
+template <int k> class Get;
+
+// A helper for implementing tuple_element<k, T>.  kIndexValid is true
+// iff k < the number of fields in tuple type T.
+template <bool kIndexValid, int kIndex, class Tuple>
+struct TupleElement;
+
+
+$for i [[
+template <GTEST_$(n)_TYPENAMES_(T)>
+struct TupleElement<true, $i, GTEST_$(n)_TUPLE_(T) > {
+  typedef T$i type;
+};
+
+
+]]
+}  // namespace gtest_internal
+
+template <>
+class tuple<> {
+ public:
+  tuple() {}
+  tuple(const tuple& /* t */)  {}
+  tuple& operator=(const tuple& /* t */) { return *this; }
+};
+
+
+$for k [[
+$range m 0..k-1
+template <GTEST_$(k)_TYPENAMES_(T)>
+class $if k < n [[GTEST_$(k)_TUPLE_(T)]] $else [[tuple]] {
+ public:
+  template <int k> friend class gtest_internal::Get;
+
+  tuple() : $for m, [[f$(m)_()]] {}
+
+  explicit tuple($for m, [[GTEST_BY_REF_(T$m) f$m]]) : [[]]
+$for m, [[f$(m)_(f$m)]] {}
+
+  tuple(const tuple& t) : $for m, [[f$(m)_(t.f$(m)_)]] {}
+
+  template <GTEST_$(k)_TYPENAMES_(U)>
+  tuple(const GTEST_$(k)_TUPLE_(U)& t) : $for m, [[f$(m)_(t.f$(m)_)]] {}
+
+$if k == 2 [[
+  template <typename U0, typename U1>
+  tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
+
+]]
+
+  tuple& operator=(const tuple& t) { return CopyFrom(t); }
+
+  template <GTEST_$(k)_TYPENAMES_(U)>
+  tuple& operator=(const GTEST_$(k)_TUPLE_(U)& t) {
+    return CopyFrom(t);
+  }
+
+$if k == 2 [[
+  template <typename U0, typename U1>
+  tuple& operator=(const ::std::pair<U0, U1>& p) {
+    f0_ = p.first;
+    f1_ = p.second;
+    return *this;
+  }
+
+]]
+
+  GTEST_DECLARE_TUPLE_AS_FRIEND_
+
+  template <GTEST_$(k)_TYPENAMES_(U)>
+  tuple& CopyFrom(const GTEST_$(k)_TUPLE_(U)& t) {
+
+$for m [[
+    f$(m)_ = t.f$(m)_;
+
+]]
+    return *this;
+  }
+
+
+$for m [[
+  T$m f$(m)_;
+
+]]
+};
+
+
+]]
+// 6.1.3.2 Tuple creation functions.
+
+// Known limitations: we don't support passing an
+// std::tr1::reference_wrapper<T> to make_tuple().  And we don't
+// implement tie().
+
+inline tuple<> make_tuple() { return tuple<>(); }
+
+$for k [[
+$range m 0..k-1
+
+template <GTEST_$(k)_TYPENAMES_(T)>
+inline GTEST_$(k)_TUPLE_(T) make_tuple($for m, [[const T$m& f$m]]) {
+  return GTEST_$(k)_TUPLE_(T)($for m, [[f$m]]);
+}
+
+]]
+
+// 6.1.3.3 Tuple helper classes.
+
+template <typename Tuple> struct tuple_size;
+
+
+$for j [[
+template <GTEST_$(j)_TYPENAMES_(T)>
+struct tuple_size<GTEST_$(j)_TUPLE_(T) > {
+  static const int value = $j;
+};
+
+
+]]
+template <int k, class Tuple>
+struct tuple_element {
+  typedef typename gtest_internal::TupleElement<
+      k < (tuple_size<Tuple>::value), k, Tuple>::type type;
+};
+
+#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
+
+// 6.1.3.4 Element access.
+
+namespace gtest_internal {
+
+
+$for i [[
+template <>
+class Get<$i> {
+ public:
+  template <class Tuple>
+  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple))
+  Field(Tuple& t) { return t.f$(i)_; }  // NOLINT
+
+  template <class Tuple>
+  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple))
+  ConstField(const Tuple& t) { return t.f$(i)_; }
+};
+
+
+]]
+}  // namespace gtest_internal
+
+template <int k, GTEST_$(n)_TYPENAMES_(T)>
+GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T)))
+get(GTEST_$(n)_TUPLE_(T)& t) {
+  return gtest_internal::Get<k>::Field(t);
+}
+
+template <int k, GTEST_$(n)_TYPENAMES_(T)>
+GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k,  GTEST_$(n)_TUPLE_(T)))
+get(const GTEST_$(n)_TUPLE_(T)& t) {
+  return gtest_internal::Get<k>::ConstField(t);
+}
+
+// 6.1.3.5 Relational operators
+
+// We only implement == and !=, as we don't have a need for the rest yet.
+
+namespace gtest_internal {
+
+// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
+// first k fields of t1 equals the first k fields of t2.
+// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
+// k1 != k2.
+template <int kSize1, int kSize2>
+struct SameSizeTuplePrefixComparator;
+
+template <>
+struct SameSizeTuplePrefixComparator<0, 0> {
+  template <class Tuple1, class Tuple2>
+  static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
+    return true;
+  }
+};
+
+template <int k>
+struct SameSizeTuplePrefixComparator<k, k> {
+  template <class Tuple1, class Tuple2>
+  static bool Eq(const Tuple1& t1, const Tuple2& t2) {
+    return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
+        ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
+  }
+};
+
+}  // namespace gtest_internal
+
+template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)>
+inline bool operator==(const GTEST_$(n)_TUPLE_(T)& t,
+                       const GTEST_$(n)_TUPLE_(U)& u) {
+  return gtest_internal::SameSizeTuplePrefixComparator<
+      tuple_size<GTEST_$(n)_TUPLE_(T) >::value,
+      tuple_size<GTEST_$(n)_TUPLE_(U) >::value>::Eq(t, u);
+}
+
+template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)>
+inline bool operator!=(const GTEST_$(n)_TUPLE_(T)& t,
+                       const GTEST_$(n)_TUPLE_(U)& u) { return !(t == u); }
+
+// 6.1.4 Pairs.
+// Unimplemented.
+
+}  // namespace tr1
+}  // namespace std
+
+
+$for j [[
+#undef GTEST_$(j)_TUPLE_
+
+]]
+
+
+$for j [[
+#undef GTEST_$(j)_TYPENAMES_
+
+]]
+
+#undef GTEST_DECLARE_TUPLE_AS_FRIEND_
+#undef GTEST_BY_REF_
+#undef GTEST_ADD_REF_
+#undef GTEST_TUPLE_ELEMENT_
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h
new file mode 100644
index 00000000..e46f7cfc
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h
@@ -0,0 +1,3331 @@
+// This file was GENERATED by command:
+//     pump.py gtest-type-util.h.pump
+// DO NOT EDIT BY HAND!!!
+
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Type utilities needed for implementing typed and type-parameterized
+// tests.  This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
+//
+// Currently we support at most 50 types in a list, and at most 50
+// type-parameterized tests in one type-parameterized test case.
+// Please contact googletestframework@googlegroups.com if you need
+// more.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+
+#include "gtest/internal/gtest-port.h"
+
+// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
+// libstdc++ (which is where cxxabi.h comes from).
+# if GTEST_HAS_CXXABI_H_
+#  include <cxxabi.h>
+# elif defined(__HP_aCC)
+#  include <acxx_demangle.h>
+# endif  // GTEST_HASH_CXXABI_H_
+
+namespace testing {
+namespace internal {
+
+// GetTypeName<T>() returns a human-readable name of type T.
+// 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
+
+  const char* const name = typeid(T).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_
+  using abi::__cxa_demangle;
+#   endif  // GTEST_HAS_CXXABI_H_
+  char* const readable_name = __cxa_demangle(name, 0, 0, &status);
+  const std::string name_str(status == 0 ? readable_name : name);
+  free(readable_name);
+  return name_str;
+#  else
+  return name;
+#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
+
+# else
+
+  return "<type>";
+
+# endif  // GTEST_HAS_RTTI
+}
+
+#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+
+// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
+// type.  This can be used as a compile-time assertion to ensure that
+// two types are equal.
+
+template <typename T1, typename T2>
+struct AssertTypeEq;
+
+template <typename T>
+struct AssertTypeEq<T, T> {
+  typedef bool type;
+};
+
+// A unique type used as the default value for the arguments of class
+// template Types.  This allows us to simulate variadic templates
+// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
+// support directly.
+struct None {};
+
+// The following family of struct and struct templates are used to
+// represent type lists.  In particular, TypesN<T1, T2, ..., TN>
+// represents a type list with N types (T1, T2, ..., and TN) in it.
+// Except for Types0, every struct in the family has two member types:
+// Head for the first type in the list, and Tail for the rest of the
+// list.
+
+// The empty type list.
+struct Types0 {};
+
+// Type lists of length 1, 2, 3, and so on.
+
+template <typename T1>
+struct Types1 {
+  typedef T1 Head;
+  typedef Types0 Tail;
+};
+template <typename T1, typename T2>
+struct Types2 {
+  typedef T1 Head;
+  typedef Types1<T2> Tail;
+};
+
+template <typename T1, typename T2, typename T3>
+struct Types3 {
+  typedef T1 Head;
+  typedef Types2<T2, T3> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4>
+struct Types4 {
+  typedef T1 Head;
+  typedef Types3<T2, T3, T4> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+struct Types5 {
+  typedef T1 Head;
+  typedef Types4<T2, T3, T4, T5> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+struct Types6 {
+  typedef T1 Head;
+  typedef Types5<T2, T3, T4, T5, T6> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+struct Types7 {
+  typedef T1 Head;
+  typedef Types6<T2, T3, T4, T5, T6, T7> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+struct Types8 {
+  typedef T1 Head;
+  typedef Types7<T2, T3, T4, T5, T6, T7, T8> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+struct Types9 {
+  typedef T1 Head;
+  typedef Types8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+struct Types10 {
+  typedef T1 Head;
+  typedef Types9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11>
+struct Types11 {
+  typedef T1 Head;
+  typedef Types10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12>
+struct Types12 {
+  typedef T1 Head;
+  typedef Types11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13>
+struct Types13 {
+  typedef T1 Head;
+  typedef Types12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14>
+struct Types14 {
+  typedef T1 Head;
+  typedef Types13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15>
+struct Types15 {
+  typedef T1 Head;
+  typedef Types14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16>
+struct Types16 {
+  typedef T1 Head;
+  typedef Types15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17>
+struct Types17 {
+  typedef T1 Head;
+  typedef Types16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18>
+struct Types18 {
+  typedef T1 Head;
+  typedef Types17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19>
+struct Types19 {
+  typedef T1 Head;
+  typedef Types18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20>
+struct Types20 {
+  typedef T1 Head;
+  typedef Types19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21>
+struct Types21 {
+  typedef T1 Head;
+  typedef Types20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22>
+struct Types22 {
+  typedef T1 Head;
+  typedef Types21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23>
+struct Types23 {
+  typedef T1 Head;
+  typedef Types22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24>
+struct Types24 {
+  typedef T1 Head;
+  typedef Types23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25>
+struct Types25 {
+  typedef T1 Head;
+  typedef Types24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26>
+struct Types26 {
+  typedef T1 Head;
+  typedef Types25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27>
+struct Types27 {
+  typedef T1 Head;
+  typedef Types26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28>
+struct Types28 {
+  typedef T1 Head;
+  typedef Types27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29>
+struct Types29 {
+  typedef T1 Head;
+  typedef Types28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30>
+struct Types30 {
+  typedef T1 Head;
+  typedef Types29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31>
+struct Types31 {
+  typedef T1 Head;
+  typedef Types30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32>
+struct Types32 {
+  typedef T1 Head;
+  typedef Types31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33>
+struct Types33 {
+  typedef T1 Head;
+  typedef Types32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34>
+struct Types34 {
+  typedef T1 Head;
+  typedef Types33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35>
+struct Types35 {
+  typedef T1 Head;
+  typedef Types34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36>
+struct Types36 {
+  typedef T1 Head;
+  typedef Types35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37>
+struct Types37 {
+  typedef T1 Head;
+  typedef Types36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38>
+struct Types38 {
+  typedef T1 Head;
+  typedef Types37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39>
+struct Types39 {
+  typedef T1 Head;
+  typedef Types38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40>
+struct Types40 {
+  typedef T1 Head;
+  typedef Types39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41>
+struct Types41 {
+  typedef T1 Head;
+  typedef Types40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42>
+struct Types42 {
+  typedef T1 Head;
+  typedef Types41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43>
+struct Types43 {
+  typedef T1 Head;
+  typedef Types42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44>
+struct Types44 {
+  typedef T1 Head;
+  typedef Types43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45>
+struct Types45 {
+  typedef T1 Head;
+  typedef Types44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44, T45> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46>
+struct Types46 {
+  typedef T1 Head;
+  typedef Types45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44, T45, T46> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47>
+struct Types47 {
+  typedef T1 Head;
+  typedef Types46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44, T45, T46, T47> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48>
+struct Types48 {
+  typedef T1 Head;
+  typedef Types47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44, T45, T46, T47, T48> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49>
+struct Types49 {
+  typedef T1 Head;
+  typedef Types48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44, T45, T46, T47, T48, T49> Tail;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49, typename T50>
+struct Types50 {
+  typedef T1 Head;
+  typedef Types49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+      T44, T45, T46, T47, T48, T49, T50> Tail;
+};
+
+
+}  // namespace internal
+
+// We don't want to require the users to write TypesN<...> directly,
+// as that would require them to count the length.  Types<...> is much
+// easier to write, but generates horrible messages when there is a
+// compiler error, as gcc insists on printing out each template
+// argument, even if it has the default value (this means Types<int>
+// will appear as Types<int, None, None, ..., None> in the compiler
+// errors).
+//
+// Our solution is to combine the best part of the two approaches: a
+// user would write Types<T1, ..., TN>, and Google Test will translate
+// that to TypesN<T1, ..., TN> internally to make error messages
+// readable.  The translation is done by the 'type' member of the
+// Types template.
+template <typename T1 = internal::None, typename T2 = internal::None,
+    typename T3 = internal::None, typename T4 = internal::None,
+    typename T5 = internal::None, typename T6 = internal::None,
+    typename T7 = internal::None, typename T8 = internal::None,
+    typename T9 = internal::None, typename T10 = internal::None,
+    typename T11 = internal::None, typename T12 = internal::None,
+    typename T13 = internal::None, typename T14 = internal::None,
+    typename T15 = internal::None, typename T16 = internal::None,
+    typename T17 = internal::None, typename T18 = internal::None,
+    typename T19 = internal::None, typename T20 = internal::None,
+    typename T21 = internal::None, typename T22 = internal::None,
+    typename T23 = internal::None, typename T24 = internal::None,
+    typename T25 = internal::None, typename T26 = internal::None,
+    typename T27 = internal::None, typename T28 = internal::None,
+    typename T29 = internal::None, typename T30 = internal::None,
+    typename T31 = internal::None, typename T32 = internal::None,
+    typename T33 = internal::None, typename T34 = internal::None,
+    typename T35 = internal::None, typename T36 = internal::None,
+    typename T37 = internal::None, typename T38 = internal::None,
+    typename T39 = internal::None, typename T40 = internal::None,
+    typename T41 = internal::None, typename T42 = internal::None,
+    typename T43 = internal::None, typename T44 = internal::None,
+    typename T45 = internal::None, typename T46 = internal::None,
+    typename T47 = internal::None, typename T48 = internal::None,
+    typename T49 = internal::None, typename T50 = internal::None>
+struct Types {
+  typedef internal::Types50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
+};
+
+template <>
+struct Types<internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types0 type;
+};
+template <typename T1>
+struct Types<T1, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types1<T1> type;
+};
+template <typename T1, typename T2>
+struct Types<T1, T2, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types2<T1, T2> type;
+};
+template <typename T1, typename T2, typename T3>
+struct Types<T1, T2, T3, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types3<T1, T2, T3> type;
+};
+template <typename T1, typename T2, typename T3, typename T4>
+struct Types<T1, T2, T3, T4, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types4<T1, T2, T3, T4> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+struct Types<T1, T2, T3, T4, T5, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types5<T1, T2, T3, T4, T5> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6>
+struct Types<T1, T2, T3, T4, T5, T6, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types6<T1, T2, T3, T4, T5, T6> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7>
+struct Types<T1, T2, T3, T4, T5, T6, T7, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types7<T1, T2, T3, T4, T5, T6, T7> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types8<T1, T2, T3, T4, T5, T6, T7, T8> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
+      T12> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
+      T26> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
+      T40> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, internal::None,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None, internal::None> {
+  typedef internal::Types43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None, internal::None> {
+  typedef internal::Types44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
+    internal::None, internal::None, internal::None, internal::None,
+    internal::None> {
+  typedef internal::Types45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
+    T46, internal::None, internal::None, internal::None, internal::None> {
+  typedef internal::Types46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45, T46> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
+    T46, T47, internal::None, internal::None, internal::None> {
+  typedef internal::Types47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45, T46, T47> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
+    T46, T47, T48, internal::None, internal::None> {
+  typedef internal::Types48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45, T46, T47, T48> type;
+};
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49>
+struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
+    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
+    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
+    T46, T47, T48, T49, internal::None> {
+  typedef internal::Types49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45, T46, T47, T48, T49> type;
+};
+
+namespace internal {
+
+# define GTEST_TEMPLATE_ template <typename T> class
+
+// The template "selector" struct TemplateSel<Tmpl> is used to
+// represent Tmpl, which must be a class template with one type
+// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
+// as the type Tmpl<T>.  This allows us to actually instantiate the
+// template "selected" by TemplateSel<Tmpl>.
+//
+// This trick is necessary for simulating typedef for class templates,
+// which C++ doesn't support directly.
+template <GTEST_TEMPLATE_ Tmpl>
+struct TemplateSel {
+  template <typename T>
+  struct Bind {
+    typedef Tmpl<T> type;
+  };
+};
+
+# define GTEST_BIND_(TmplSel, T) \
+  TmplSel::template Bind<T>::type
+
+// A unique struct template used as the default value for the
+// arguments of class template Templates.  This allows us to simulate
+// variadic templates (e.g. Templates<int>, Templates<int, double>,
+// and etc), which C++ doesn't support directly.
+template <typename T>
+struct NoneT {};
+
+// The following family of struct and struct templates are used to
+// represent template lists.  In particular, TemplatesN<T1, T2, ...,
+// TN> represents a list of N templates (T1, T2, ..., and TN).  Except
+// for Templates0, every struct in the family has two member types:
+// Head for the selector of the first template in the list, and Tail
+// for the rest of the list.
+
+// The empty template list.
+struct Templates0 {};
+
+// Template lists of length 1, 2, 3, and so on.
+
+template <GTEST_TEMPLATE_ T1>
+struct Templates1 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates0 Tail;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
+struct Templates2 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates1<T2> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
+struct Templates3 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates2<T2, T3> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4>
+struct Templates4 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates3<T2, T3, T4> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
+struct Templates5 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates4<T2, T3, T4, T5> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
+struct Templates6 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates5<T2, T3, T4, T5, T6> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7>
+struct Templates7 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates6<T2, T3, T4, T5, T6, T7> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
+struct Templates8 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates7<T2, T3, T4, T5, T6, T7, T8> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
+struct Templates9 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10>
+struct Templates10 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
+struct Templates11 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
+struct Templates12 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13>
+struct Templates13 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
+struct Templates14 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
+struct Templates15 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16>
+struct Templates16 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
+struct Templates17 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
+struct Templates18 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19>
+struct Templates19 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
+struct Templates20 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
+struct Templates21 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22>
+struct Templates22 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
+struct Templates23 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
+struct Templates24 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25>
+struct Templates25 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
+struct Templates26 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
+struct Templates27 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28>
+struct Templates28 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
+struct Templates29 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
+struct Templates30 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31>
+struct Templates31 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
+struct Templates32 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
+struct Templates33 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34>
+struct Templates34 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
+struct Templates35 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
+struct Templates36 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37>
+struct Templates37 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
+struct Templates38 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
+struct Templates39 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40>
+struct Templates40 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
+struct Templates41 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42>
+struct Templates42 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43>
+struct Templates43 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44>
+struct Templates44 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45>
+struct Templates45 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44, T45> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46>
+struct Templates46 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44, T45, T46> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47>
+struct Templates47 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44, T45, T46, T47> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48>
+struct Templates48 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44, T45, T46, T47, T48> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
+    GTEST_TEMPLATE_ T49>
+struct Templates49 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44, T45, T46, T47, T48, T49> Tail;
+};
+
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
+    GTEST_TEMPLATE_ T49, GTEST_TEMPLATE_ T50>
+struct Templates50 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
+      T43, T44, T45, T46, T47, T48, T49, T50> Tail;
+};
+
+
+// We don't want to require the users to write TemplatesN<...> directly,
+// as that would require them to count the length.  Templates<...> is much
+// easier to write, but generates horrible messages when there is a
+// compiler error, as gcc insists on printing out each template
+// argument, even if it has the default value (this means Templates<list>
+// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler
+// errors).
+//
+// Our solution is to combine the best part of the two approaches: a
+// user would write Templates<T1, ..., TN>, and Google Test will translate
+// that to TemplatesN<T1, ..., TN> internally to make error messages
+// readable.  The translation is done by the 'type' member of the
+// Templates template.
+template <GTEST_TEMPLATE_ T1 = NoneT, GTEST_TEMPLATE_ T2 = NoneT,
+    GTEST_TEMPLATE_ T3 = NoneT, GTEST_TEMPLATE_ T4 = NoneT,
+    GTEST_TEMPLATE_ T5 = NoneT, GTEST_TEMPLATE_ T6 = NoneT,
+    GTEST_TEMPLATE_ T7 = NoneT, GTEST_TEMPLATE_ T8 = NoneT,
+    GTEST_TEMPLATE_ T9 = NoneT, GTEST_TEMPLATE_ T10 = NoneT,
+    GTEST_TEMPLATE_ T11 = NoneT, GTEST_TEMPLATE_ T12 = NoneT,
+    GTEST_TEMPLATE_ T13 = NoneT, GTEST_TEMPLATE_ T14 = NoneT,
+    GTEST_TEMPLATE_ T15 = NoneT, GTEST_TEMPLATE_ T16 = NoneT,
+    GTEST_TEMPLATE_ T17 = NoneT, GTEST_TEMPLATE_ T18 = NoneT,
+    GTEST_TEMPLATE_ T19 = NoneT, GTEST_TEMPLATE_ T20 = NoneT,
+    GTEST_TEMPLATE_ T21 = NoneT, GTEST_TEMPLATE_ T22 = NoneT,
+    GTEST_TEMPLATE_ T23 = NoneT, GTEST_TEMPLATE_ T24 = NoneT,
+    GTEST_TEMPLATE_ T25 = NoneT, GTEST_TEMPLATE_ T26 = NoneT,
+    GTEST_TEMPLATE_ T27 = NoneT, GTEST_TEMPLATE_ T28 = NoneT,
+    GTEST_TEMPLATE_ T29 = NoneT, GTEST_TEMPLATE_ T30 = NoneT,
+    GTEST_TEMPLATE_ T31 = NoneT, GTEST_TEMPLATE_ T32 = NoneT,
+    GTEST_TEMPLATE_ T33 = NoneT, GTEST_TEMPLATE_ T34 = NoneT,
+    GTEST_TEMPLATE_ T35 = NoneT, GTEST_TEMPLATE_ T36 = NoneT,
+    GTEST_TEMPLATE_ T37 = NoneT, GTEST_TEMPLATE_ T38 = NoneT,
+    GTEST_TEMPLATE_ T39 = NoneT, GTEST_TEMPLATE_ T40 = NoneT,
+    GTEST_TEMPLATE_ T41 = NoneT, GTEST_TEMPLATE_ T42 = NoneT,
+    GTEST_TEMPLATE_ T43 = NoneT, GTEST_TEMPLATE_ T44 = NoneT,
+    GTEST_TEMPLATE_ T45 = NoneT, GTEST_TEMPLATE_ T46 = NoneT,
+    GTEST_TEMPLATE_ T47 = NoneT, GTEST_TEMPLATE_ T48 = NoneT,
+    GTEST_TEMPLATE_ T49 = NoneT, GTEST_TEMPLATE_ T50 = NoneT>
+struct Templates {
+  typedef Templates50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
+};
+
+template <>
+struct Templates<NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT> {
+  typedef Templates0 type;
+};
+template <GTEST_TEMPLATE_ T1>
+struct Templates<T1, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT> {
+  typedef Templates1<T1> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
+struct Templates<T1, T2, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT> {
+  typedef Templates2<T1, T2> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
+struct Templates<T1, T2, T3, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates3<T1, T2, T3> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4>
+struct Templates<T1, T2, T3, T4, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates4<T1, T2, T3, T4> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
+struct Templates<T1, T2, T3, T4, T5, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates5<T1, T2, T3, T4, T5> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
+struct Templates<T1, T2, T3, T4, T5, T6, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates6<T1, T2, T3, T4, T5, T6> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates7<T1, T2, T3, T4, T5, T6, T7> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates8<T1, T2, T3, T4, T5, T6, T7, T8> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT> {
+  typedef Templates22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT> {
+  typedef Templates23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT> {
+  typedef Templates24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT> {
+  typedef Templates25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT> {
+  typedef Templates26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT> {
+  typedef Templates27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT> {
+  typedef Templates28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT> {
+  typedef Templates29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, NoneT, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, NoneT, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, NoneT, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, NoneT, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, NoneT,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    T45, NoneT, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44, T45> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    T45, T46, NoneT, NoneT, NoneT, NoneT> {
+  typedef Templates46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44, T45, T46> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    T45, T46, T47, NoneT, NoneT, NoneT> {
+  typedef Templates47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44, T45, T46, T47> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    T45, T46, T47, T48, NoneT, NoneT> {
+  typedef Templates48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44, T45, T46, T47, T48> type;
+};
+template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
+    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
+    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
+    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
+    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
+    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
+    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
+    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
+    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
+    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
+    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
+    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
+    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
+    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
+    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
+    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
+    GTEST_TEMPLATE_ T49>
+struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
+    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
+    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
+    T45, T46, T47, T48, T49, NoneT> {
+  typedef Templates49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
+      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
+      T42, T43, T44, T45, T46, T47, T48, T49> type;
+};
+
+// The TypeList template makes it possible to use either a single type
+// or a Types<...> list in TYPED_TEST_CASE() and
+// INSTANTIATE_TYPED_TEST_CASE_P().
+
+template <typename T>
+struct TypeList {
+  typedef Types1<T> type;
+};
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+    typename T6, typename T7, typename T8, typename T9, typename T10,
+    typename T11, typename T12, typename T13, typename T14, typename T15,
+    typename T16, typename T17, typename T18, typename T19, typename T20,
+    typename T21, typename T22, typename T23, typename T24, typename T25,
+    typename T26, typename T27, typename T28, typename T29, typename T30,
+    typename T31, typename T32, typename T33, typename T34, typename T35,
+    typename T36, typename T37, typename T38, typename T39, typename T40,
+    typename T41, typename T42, typename T43, typename T44, typename T45,
+    typename T46, typename T47, typename T48, typename T49, typename T50>
+struct TypeList<Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
+    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
+    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
+    T44, T45, T46, T47, T48, T49, T50> > {
+  typedef typename Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
+      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
+      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
+      T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>::type type;
+};
+
+#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h.pump b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h.pump
new file mode 100644
index 00000000..251fdf02
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h.pump
@@ -0,0 +1,297 @@
+$$ -*- mode: c++; -*-
+$var n = 50  $$ Maximum length of type lists we want to support.
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Type utilities needed for implementing typed and type-parameterized
+// tests.  This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
+//
+// Currently we support at most $n types in a list, and at most $n
+// type-parameterized tests in one type-parameterized test case.
+// Please contact googletestframework@googlegroups.com if you need
+// more.
+
+#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+
+#include "gtest/internal/gtest-port.h"
+
+// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
+// libstdc++ (which is where cxxabi.h comes from).
+# if GTEST_HAS_CXXABI_H_
+#  include <cxxabi.h>
+# elif defined(__HP_aCC)
+#  include <acxx_demangle.h>
+# endif  // GTEST_HASH_CXXABI_H_
+
+namespace testing {
+namespace internal {
+
+// GetTypeName<T>() returns a human-readable name of type T.
+// 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
+
+  const char* const name = typeid(T).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_
+  using abi::__cxa_demangle;
+#   endif  // GTEST_HAS_CXXABI_H_
+  char* const readable_name = __cxa_demangle(name, 0, 0, &status);
+  const std::string name_str(status == 0 ? readable_name : name);
+  free(readable_name);
+  return name_str;
+#  else
+  return name;
+#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
+
+# else
+
+  return "<type>";
+
+# endif  // GTEST_HAS_RTTI
+}
+
+#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+
+// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
+// type.  This can be used as a compile-time assertion to ensure that
+// two types are equal.
+
+template <typename T1, typename T2>
+struct AssertTypeEq;
+
+template <typename T>
+struct AssertTypeEq<T, T> {
+  typedef bool type;
+};
+
+// A unique type used as the default value for the arguments of class
+// template Types.  This allows us to simulate variadic templates
+// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
+// support directly.
+struct None {};
+
+// The following family of struct and struct templates are used to
+// represent type lists.  In particular, TypesN<T1, T2, ..., TN>
+// represents a type list with N types (T1, T2, ..., and TN) in it.
+// Except for Types0, every struct in the family has two member types:
+// Head for the first type in the list, and Tail for the rest of the
+// list.
+
+// The empty type list.
+struct Types0 {};
+
+// Type lists of length 1, 2, 3, and so on.
+
+template <typename T1>
+struct Types1 {
+  typedef T1 Head;
+  typedef Types0 Tail;
+};
+
+$range i 2..n
+
+$for i [[
+$range j 1..i
+$range k 2..i
+template <$for j, [[typename T$j]]>
+struct Types$i {
+  typedef T1 Head;
+  typedef Types$(i-1)<$for k, [[T$k]]> Tail;
+};
+
+
+]]
+
+}  // namespace internal
+
+// We don't want to require the users to write TypesN<...> directly,
+// as that would require them to count the length.  Types<...> is much
+// easier to write, but generates horrible messages when there is a
+// compiler error, as gcc insists on printing out each template
+// argument, even if it has the default value (this means Types<int>
+// will appear as Types<int, None, None, ..., None> in the compiler
+// errors).
+//
+// Our solution is to combine the best part of the two approaches: a
+// user would write Types<T1, ..., TN>, and Google Test will translate
+// that to TypesN<T1, ..., TN> internally to make error messages
+// readable.  The translation is done by the 'type' member of the
+// Types template.
+
+$range i 1..n
+template <$for i, [[typename T$i = internal::None]]>
+struct Types {
+  typedef internal::Types$n<$for i, [[T$i]]> type;
+};
+
+template <>
+struct Types<$for i, [[internal::None]]> {
+  typedef internal::Types0 type;
+};
+
+$range i 1..n-1
+$for i [[
+$range j 1..i
+$range k i+1..n
+template <$for j, [[typename T$j]]>
+struct Types<$for j, [[T$j]]$for k[[, internal::None]]> {
+  typedef internal::Types$i<$for j, [[T$j]]> type;
+};
+
+]]
+
+namespace internal {
+
+# define GTEST_TEMPLATE_ template <typename T> class
+
+// The template "selector" struct TemplateSel<Tmpl> is used to
+// represent Tmpl, which must be a class template with one type
+// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
+// as the type Tmpl<T>.  This allows us to actually instantiate the
+// template "selected" by TemplateSel<Tmpl>.
+//
+// This trick is necessary for simulating typedef for class templates,
+// which C++ doesn't support directly.
+template <GTEST_TEMPLATE_ Tmpl>
+struct TemplateSel {
+  template <typename T>
+  struct Bind {
+    typedef Tmpl<T> type;
+  };
+};
+
+# define GTEST_BIND_(TmplSel, T) \
+  TmplSel::template Bind<T>::type
+
+// A unique struct template used as the default value for the
+// arguments of class template Templates.  This allows us to simulate
+// variadic templates (e.g. Templates<int>, Templates<int, double>,
+// and etc), which C++ doesn't support directly.
+template <typename T>
+struct NoneT {};
+
+// The following family of struct and struct templates are used to
+// represent template lists.  In particular, TemplatesN<T1, T2, ...,
+// TN> represents a list of N templates (T1, T2, ..., and TN).  Except
+// for Templates0, every struct in the family has two member types:
+// Head for the selector of the first template in the list, and Tail
+// for the rest of the list.
+
+// The empty template list.
+struct Templates0 {};
+
+// Template lists of length 1, 2, 3, and so on.
+
+template <GTEST_TEMPLATE_ T1>
+struct Templates1 {
+  typedef TemplateSel<T1> Head;
+  typedef Templates0 Tail;
+};
+
+$range i 2..n
+
+$for i [[
+$range j 1..i
+$range k 2..i
+template <$for j, [[GTEST_TEMPLATE_ T$j]]>
+struct Templates$i {
+  typedef TemplateSel<T1> Head;
+  typedef Templates$(i-1)<$for k, [[T$k]]> Tail;
+};
+
+
+]]
+
+// We don't want to require the users to write TemplatesN<...> directly,
+// as that would require them to count the length.  Templates<...> is much
+// easier to write, but generates horrible messages when there is a
+// compiler error, as gcc insists on printing out each template
+// argument, even if it has the default value (this means Templates<list>
+// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler
+// errors).
+//
+// Our solution is to combine the best part of the two approaches: a
+// user would write Templates<T1, ..., TN>, and Google Test will translate
+// that to TemplatesN<T1, ..., TN> internally to make error messages
+// readable.  The translation is done by the 'type' member of the
+// Templates template.
+
+$range i 1..n
+template <$for i, [[GTEST_TEMPLATE_ T$i = NoneT]]>
+struct Templates {
+  typedef Templates$n<$for i, [[T$i]]> type;
+};
+
+template <>
+struct Templates<$for i, [[NoneT]]> {
+  typedef Templates0 type;
+};
+
+$range i 1..n-1
+$for i [[
+$range j 1..i
+$range k i+1..n
+template <$for j, [[GTEST_TEMPLATE_ T$j]]>
+struct Templates<$for j, [[T$j]]$for k[[, NoneT]]> {
+  typedef Templates$i<$for j, [[T$j]]> type;
+};
+
+]]
+
+// The TypeList template makes it possible to use either a single type
+// or a Types<...> list in TYPED_TEST_CASE() and
+// INSTANTIATE_TYPED_TEST_CASE_P().
+
+template <typename T>
+struct TypeList {
+  typedef Types1<T> type;
+};
+
+
+$range i 1..n
+template <$for i, [[typename T$i]]>
+struct TypeList<Types<$for i, [[T$i]]> > {
+  typedef typename Types<$for i, [[T$i]]>::type type;
+};
+
+#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/m4/acx_pthread.m4 b/week4/softwareEng_9_4/vendor/googletest/googletest/m4/acx_pthread.m4
new file mode 100644
index 00000000..2cf20de1
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/m4/acx_pthread.m4
@@ -0,0 +1,363 @@
+# This was retrieved from
+#    http://svn.0pointer.de/viewvc/trunk/common/acx_pthread.m4?revision=1277&root=avahi
+# See also (perhaps for new versions?)
+#    http://svn.0pointer.de/viewvc/trunk/common/acx_pthread.m4?root=avahi
+#
+# We've rewritten the inconsistency check code (from avahi), to work
+# more broadly.  In particular, it no longer assumes ld accepts -zdefs.
+# This caused a restructing of the code, but the functionality has only
+# changed a little.
+
+dnl @synopsis ACX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+dnl
+dnl @summary figure out how to build C programs using POSIX threads
+dnl
+dnl This macro figures out how to build C programs using POSIX threads.
+dnl It sets the PTHREAD_LIBS output variable to the threads library and
+dnl linker flags, and the PTHREAD_CFLAGS output variable to any special
+dnl C compiler flags that are needed. (The user can also force certain
+dnl compiler flags/libs to be tested by setting these environment
+dnl variables.)
+dnl
+dnl Also sets PTHREAD_CC to any special C compiler that is needed for
+dnl multi-threaded programs (defaults to the value of CC otherwise).
+dnl (This is necessary on AIX to use the special cc_r compiler alias.)
+dnl
+dnl NOTE: You are assumed to not only compile your program with these
+dnl flags, but also link it with them as well. e.g. you should link
+dnl with $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS
+dnl $LIBS
+dnl
+dnl If you are only building threads programs, you may wish to use
+dnl these variables in your default LIBS, CFLAGS, and CC:
+dnl
+dnl        LIBS="$PTHREAD_LIBS $LIBS"
+dnl        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+dnl        CC="$PTHREAD_CC"
+dnl
+dnl In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute
+dnl constant has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to
+dnl that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
+dnl
+dnl ACTION-IF-FOUND is a list of shell commands to run if a threads
+dnl library is found, and ACTION-IF-NOT-FOUND is a list of commands to
+dnl run it if it is not found. If ACTION-IF-FOUND is not specified, the
+dnl default action will define HAVE_PTHREAD.
+dnl
+dnl Please let the authors know if this macro fails on any platform, or
+dnl if you have any other suggestions or comments. This macro was based
+dnl on work by SGJ on autoconf scripts for FFTW (www.fftw.org) (with
+dnl help from M. Frigo), as well as ac_pthread and hb_pthread macros
+dnl posted by Alejandro Forero Cuervo to the autoconf macro repository.
+dnl We are also grateful for the helpful feedback of numerous users.
+dnl
+dnl @category InstalledPackages
+dnl @author Steven G. Johnson <stevenj@alum.mit.edu>
+dnl @version 2006-05-29
+dnl @license GPLWithACException
+dnl 
+dnl Checks for GCC shared/pthread inconsistency based on work by
+dnl Marcin Owsiany <marcin@owsiany.pl>
+
+
+AC_DEFUN([ACX_PTHREAD], [
+AC_REQUIRE([AC_CANONICAL_HOST])
+AC_LANG_SAVE
+AC_LANG_C
+acx_pthread_ok=no
+
+# We used to check for pthread.h first, but this fails if pthread.h
+# requires special compiler flags (e.g. on True64 or Sequent).
+# It gets checked for in the link test anyway.
+
+# First of all, check if the user has set any of the PTHREAD_LIBS,
+# etcetera environment variables, and if threads linking works using
+# them:
+if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
+        save_CFLAGS="$CFLAGS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        save_LIBS="$LIBS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
+        AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes)
+        AC_MSG_RESULT($acx_pthread_ok)
+        if test x"$acx_pthread_ok" = xno; then
+                PTHREAD_LIBS=""
+                PTHREAD_CFLAGS=""
+        fi
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+fi
+
+# We must check for the threads library under a number of different
+# names; the ordering is very important because some systems
+# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
+# libraries is broken (non-POSIX).
+
+# Create a list of thread flags to try.  Items starting with a "-" are
+# C compiler flags, and other items are library names, except for "none"
+# which indicates that we try without any flags at all, and "pthread-config"
+# which is a program returning the flags for the Pth emulation library.
+
+acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
+
+# The ordering *is* (sometimes) important.  Some notes on the
+# individual items follow:
+
+# pthreads: AIX (must check this before -lpthread)
+# none: in case threads are in libc; should be tried before -Kthread and
+#       other compiler flags to prevent continual compiler warnings
+# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
+# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
+# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
+# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
+# -pthreads: Solaris/gcc
+# -mthreads: Mingw32/gcc, Lynx/gcc
+# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
+#      doesn't hurt to check since this sometimes defines pthreads too;
+#      also defines -D_REENTRANT)
+#      ... -mt is also the pthreads flag for HP/aCC
+# pthread: Linux, etcetera
+# --thread-safe: KAI C++
+# pthread-config: use pthread-config program (for GNU Pth library)
+
+case "${host_cpu}-${host_os}" in
+        *solaris*)
+
+        # On Solaris (at least, for some versions), libc contains stubbed
+        # (non-functional) versions of the pthreads routines, so link-based
+        # tests will erroneously succeed.  (We need to link with -pthreads/-mt/
+        # -lpthread.)  (The stubs are missing pthread_cleanup_push, or rather
+        # a function called by this macro, so we could check for that, but
+        # who knows whether they'll stub that too in a future libc.)  So,
+        # we'll just look for -pthreads and -lpthread first:
+
+        acx_pthread_flags="-pthreads pthread -mt -pthread $acx_pthread_flags"
+        ;;
+esac
+
+if test x"$acx_pthread_ok" = xno; then
+for flag in $acx_pthread_flags; do
+
+        case $flag in
+                none)
+                AC_MSG_CHECKING([whether pthreads work without any flags])
+                ;;
+
+                -*)
+                AC_MSG_CHECKING([whether pthreads work with $flag])
+                PTHREAD_CFLAGS="$flag"
+                ;;
+
+		pthread-config)
+		AC_CHECK_PROG(acx_pthread_config, pthread-config, yes, no)
+		if test x"$acx_pthread_config" = xno; then continue; fi
+		PTHREAD_CFLAGS="`pthread-config --cflags`"
+		PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
+		;;
+
+                *)
+                AC_MSG_CHECKING([for the pthreads library -l$flag])
+                PTHREAD_LIBS="-l$flag"
+                ;;
+        esac
+
+        save_LIBS="$LIBS"
+        save_CFLAGS="$CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+
+        # Check for various functions.  We must include pthread.h,
+        # since some functions may be macros.  (On the Sequent, we
+        # need a special flag -Kthread to make this header compile.)
+        # We check for pthread_join because it is in -lpthread on IRIX
+        # while pthread_create is in libc.  We check for pthread_attr_init
+        # due to DEC craziness with -lpthreads.  We check for
+        # pthread_cleanup_push because it is one of the few pthread
+        # functions on Solaris that doesn't have a non-functional libc stub.
+        # We try pthread_create on general principles.
+        AC_TRY_LINK([#include <pthread.h>],
+                    [pthread_t th; pthread_join(th, 0);
+                     pthread_attr_init(0); pthread_cleanup_push(0, 0);
+                     pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
+                    [acx_pthread_ok=yes])
+
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+
+        AC_MSG_RESULT($acx_pthread_ok)
+        if test "x$acx_pthread_ok" = xyes; then
+                break;
+        fi
+
+        PTHREAD_LIBS=""
+        PTHREAD_CFLAGS=""
+done
+fi
+
+# Various other checks:
+if test "x$acx_pthread_ok" = xyes; then
+        save_LIBS="$LIBS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        save_CFLAGS="$CFLAGS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+
+        # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
+	AC_MSG_CHECKING([for joinable pthread attribute])
+	attr_name=unknown
+	for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
+	    AC_TRY_LINK([#include <pthread.h>], [int attr=$attr; return attr;],
+                        [attr_name=$attr; break])
+	done
+        AC_MSG_RESULT($attr_name)
+        if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then
+            AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name,
+                               [Define to necessary symbol if this constant
+                                uses a non-standard name on your system.])
+        fi
+
+        AC_MSG_CHECKING([if more special flags are required for pthreads])
+        flag=no
+        case "${host_cpu}-${host_os}" in
+            *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";;
+            *solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";;
+        esac
+        AC_MSG_RESULT(${flag})
+        if test "x$flag" != xno; then
+            PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
+        fi
+
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+        # More AIX lossage: must compile with xlc_r or cc_r
+	if test x"$GCC" != xyes; then
+          AC_CHECK_PROGS(PTHREAD_CC, xlc_r cc_r, ${CC})
+        else
+          PTHREAD_CC=$CC
+	fi
+
+	# The next part tries to detect GCC inconsistency with -shared on some
+	# architectures and systems. The problem is that in certain
+	# configurations, when -shared is specified, GCC "forgets" to
+	# internally use various flags which are still necessary.
+	
+	#
+	# Prepare the flags
+	#
+	save_CFLAGS="$CFLAGS"
+	save_LIBS="$LIBS"
+	save_CC="$CC"
+	
+	# Try with the flags determined by the earlier checks.
+	#
+	# -Wl,-z,defs forces link-time symbol resolution, so that the
+	# linking checks with -shared actually have any value
+	#
+	# FIXME: -fPIC is required for -shared on many architectures,
+	# so we specify it here, but the right way would probably be to
+	# properly detect whether it is actually required.
+	CFLAGS="-shared -fPIC -Wl,-z,defs $CFLAGS $PTHREAD_CFLAGS"
+	LIBS="$PTHREAD_LIBS $LIBS"
+	CC="$PTHREAD_CC"
+	
+	# In order not to create several levels of indentation, we test
+	# the value of "$done" until we find the cure or run out of ideas.
+	done="no"
+	
+	# First, make sure the CFLAGS we added are actually accepted by our
+	# compiler.  If not (and OS X's ld, for instance, does not accept -z),
+	# then we can't do this test.
+	if test x"$done" = xno; then
+	   AC_MSG_CHECKING([whether to check for GCC pthread/shared inconsistencies])
+	   AC_TRY_LINK(,, , [done=yes])
+	
+	   if test "x$done" = xyes ; then
+	      AC_MSG_RESULT([no])
+	   else
+	      AC_MSG_RESULT([yes])
+	   fi
+	fi
+	
+	if test x"$done" = xno; then
+	   AC_MSG_CHECKING([whether -pthread is sufficient with -shared])
+	   AC_TRY_LINK([#include <pthread.h>],
+	      [pthread_t th; pthread_join(th, 0);
+	      pthread_attr_init(0); pthread_cleanup_push(0, 0);
+	      pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
+	      [done=yes])
+	   
+	   if test "x$done" = xyes; then
+	      AC_MSG_RESULT([yes])
+	   else
+	      AC_MSG_RESULT([no])
+	   fi
+	fi
+	
+	#
+	# Linux gcc on some architectures such as mips/mipsel forgets
+	# about -lpthread
+	#
+	if test x"$done" = xno; then
+	   AC_MSG_CHECKING([whether -lpthread fixes that])
+	   LIBS="-lpthread $PTHREAD_LIBS $save_LIBS"
+	   AC_TRY_LINK([#include <pthread.h>],
+	      [pthread_t th; pthread_join(th, 0);
+	      pthread_attr_init(0); pthread_cleanup_push(0, 0);
+	      pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
+	      [done=yes])
+	
+	   if test "x$done" = xyes; then
+	      AC_MSG_RESULT([yes])
+	      PTHREAD_LIBS="-lpthread $PTHREAD_LIBS"
+	   else
+	      AC_MSG_RESULT([no])
+	   fi
+	fi
+	#
+	# FreeBSD 4.10 gcc forgets to use -lc_r instead of -lc
+	#
+	if test x"$done" = xno; then
+	   AC_MSG_CHECKING([whether -lc_r fixes that])
+	   LIBS="-lc_r $PTHREAD_LIBS $save_LIBS"
+	   AC_TRY_LINK([#include <pthread.h>],
+	       [pthread_t th; pthread_join(th, 0);
+	        pthread_attr_init(0); pthread_cleanup_push(0, 0);
+	        pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
+	       [done=yes])
+	
+	   if test "x$done" = xyes; then
+	      AC_MSG_RESULT([yes])
+	      PTHREAD_LIBS="-lc_r $PTHREAD_LIBS"
+	   else
+	      AC_MSG_RESULT([no])
+	   fi
+	fi
+	if test x"$done" = xno; then
+	   # OK, we have run out of ideas
+	   AC_MSG_WARN([Impossible to determine how to use pthreads with shared libraries])
+	
+	   # so it's not safe to assume that we may use pthreads
+	   acx_pthread_ok=no
+	fi
+	
+	CFLAGS="$save_CFLAGS"
+	LIBS="$save_LIBS"
+	CC="$save_CC"
+else
+        PTHREAD_CC="$CC"
+fi
+
+AC_SUBST(PTHREAD_LIBS)
+AC_SUBST(PTHREAD_CFLAGS)
+AC_SUBST(PTHREAD_CC)
+
+# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
+if test x"$acx_pthread_ok" = xyes; then
+        ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
+        :
+else
+        acx_pthread_ok=no
+        $2
+fi
+AC_LANG_RESTORE
+])dnl ACX_PTHREAD
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/m4/gtest.m4 b/week4/softwareEng_9_4/vendor/googletest/googletest/m4/gtest.m4
new file mode 100644
index 00000000..6598ba75
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/m4/gtest.m4
@@ -0,0 +1,74 @@
+dnl GTEST_LIB_CHECK([minimum version [,
+dnl                  action if found [,action if not found]]])
+dnl
+dnl Check for the presence of the Google Test library, optionally at a minimum
+dnl version, and indicate a viable version with the HAVE_GTEST flag. It defines
+dnl standard variables for substitution including GTEST_CPPFLAGS,
+dnl GTEST_CXXFLAGS, GTEST_LDFLAGS, and GTEST_LIBS. It also defines
+dnl GTEST_VERSION as the version of Google Test found. Finally, it provides
+dnl optional custom action slots in the event GTEST is found or not.
+AC_DEFUN([GTEST_LIB_CHECK],
+[
+dnl Provide a flag to enable or disable Google Test usage.
+AC_ARG_ENABLE([gtest],
+  [AS_HELP_STRING([--enable-gtest],
+                  [Enable tests using the Google C++ Testing Framework.
+                  (Default is enabled.)])],
+  [],
+  [enable_gtest=])
+AC_ARG_VAR([GTEST_CONFIG],
+           [The exact path of Google Test's 'gtest-config' script.])
+AC_ARG_VAR([GTEST_CPPFLAGS],
+           [C-like preprocessor flags for Google Test.])
+AC_ARG_VAR([GTEST_CXXFLAGS],
+           [C++ compile flags for Google Test.])
+AC_ARG_VAR([GTEST_LDFLAGS],
+           [Linker path and option flags for Google Test.])
+AC_ARG_VAR([GTEST_LIBS],
+           [Library linking flags for Google Test.])
+AC_ARG_VAR([GTEST_VERSION],
+           [The version of Google Test available.])
+HAVE_GTEST="no"
+AS_IF([test "x${enable_gtest}" != "xno"],
+  [AC_MSG_CHECKING([for 'gtest-config'])
+   AS_IF([test "x${enable_gtest}" != "xyes"],
+     [AS_IF([test -x "${enable_gtest}/scripts/gtest-config"],
+        [GTEST_CONFIG="${enable_gtest}/scripts/gtest-config"],
+        [GTEST_CONFIG="${enable_gtest}/bin/gtest-config"])
+      AS_IF([test -x "${GTEST_CONFIG}"], [],
+        [AC_MSG_RESULT([no])
+         AC_MSG_ERROR([dnl
+Unable to locate either a built or installed Google Test.
+The specific location '${enable_gtest}' was provided for a built or installed
+Google Test, but no 'gtest-config' script could be found at this location.])
+         ])],
+     [AC_PATH_PROG([GTEST_CONFIG], [gtest-config])])
+   AS_IF([test -x "${GTEST_CONFIG}"],
+     [AC_MSG_RESULT([${GTEST_CONFIG}])
+      m4_ifval([$1],
+        [_gtest_min_version="--min-version=$1"
+         AC_MSG_CHECKING([for Google Test at least version >= $1])],
+        [_gtest_min_version="--min-version=0"
+         AC_MSG_CHECKING([for Google Test])])
+      AS_IF([${GTEST_CONFIG} ${_gtest_min_version}],
+        [AC_MSG_RESULT([yes])
+         HAVE_GTEST='yes'],
+        [AC_MSG_RESULT([no])])],
+     [AC_MSG_RESULT([no])])
+   AS_IF([test "x${HAVE_GTEST}" = "xyes"],
+     [GTEST_CPPFLAGS=`${GTEST_CONFIG} --cppflags`
+      GTEST_CXXFLAGS=`${GTEST_CONFIG} --cxxflags`
+      GTEST_LDFLAGS=`${GTEST_CONFIG} --ldflags`
+      GTEST_LIBS=`${GTEST_CONFIG} --libs`
+      GTEST_VERSION=`${GTEST_CONFIG} --version`
+      AC_DEFINE([HAVE_GTEST],[1],[Defined when Google Test is available.])],
+     [AS_IF([test "x${enable_gtest}" = "xyes"],
+        [AC_MSG_ERROR([dnl
+Google Test was enabled, but no viable version could be found.])
+         ])])])
+AC_SUBST([HAVE_GTEST])
+AM_CONDITIONAL([HAVE_GTEST],[test "x$HAVE_GTEST" = "xyes"])
+AS_IF([test "x$HAVE_GTEST" = "xyes"],
+  [m4_ifval([$2], [$2])],
+  [m4_ifval([$3], [$3])])
+])
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/make/Makefile b/week4/softwareEng_9_4/vendor/googletest/googletest/make/Makefile
new file mode 100644
index 00000000..9ac74493
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/make/Makefile
@@ -0,0 +1,82 @@
+# A sample Makefile for building Google Test and using it in user
+# tests.  Please tweak it to suit your environment and project.  You
+# may want to move it to your project's root directory.
+#
+# SYNOPSIS:
+#
+#   make [all]  - makes everything.
+#   make TARGET - makes the given target.
+#   make clean  - removes all files generated by make.
+
+# Please tweak the following variable definitions as needed by your
+# project, except GTEST_HEADERS, which you can use in your own targets
+# but shouldn't modify.
+
+# Points to the root of Google Test, relative to where this file is.
+# Remember to tweak this if you move this file.
+GTEST_DIR = ..
+
+# Where to find user code.
+USER_DIR = ../samples
+
+# Flags passed to the preprocessor.
+# Set Google Test's header directory as a system directory, such that
+# the compiler doesn't generate warnings in Google Test headers.
+CPPFLAGS += -isystem $(GTEST_DIR)/include
+
+# Flags passed to the C++ compiler.
+CXXFLAGS += -g -Wall -Wextra -pthread
+
+# All tests produced by this Makefile.  Remember to add new tests you
+# created to the list.
+TESTS = sample1_unittest
+
+# All Google Test headers.  Usually you shouldn't change this
+# definition.
+GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
+                $(GTEST_DIR)/include/gtest/internal/*.h
+
+# House-keeping build targets.
+
+all : $(TESTS)
+
+clean :
+	rm -f $(TESTS) gtest.a gtest_main.a *.o
+
+# Builds gtest.a and gtest_main.a.
+
+# Usually you shouldn't tweak such internal variables, indicated by a
+# trailing _.
+GTEST_SRCS_ = $(GTEST_DIR)/src/*.cc $(GTEST_DIR)/src/*.h $(GTEST_HEADERS)
+
+# For simplicity and to avoid depending on Google Test's
+# implementation details, the dependencies specified below are
+# conservative and not optimized.  This is fine as Google Test
+# compiles fast and for ordinary users its source rarely changes.
+gtest-all.o : $(GTEST_SRCS_)
+	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
+            $(GTEST_DIR)/src/gtest-all.cc
+
+gtest_main.o : $(GTEST_SRCS_)
+	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
+            $(GTEST_DIR)/src/gtest_main.cc
+
+gtest.a : gtest-all.o
+	$(AR) $(ARFLAGS) $@ $^
+
+gtest_main.a : gtest-all.o gtest_main.o
+	$(AR) $(ARFLAGS) $@ $^
+
+# Builds a sample test.  A test should link with either gtest.a or
+# gtest_main.a, depending on whether it defines its own main()
+# function.
+
+sample1.o : $(USER_DIR)/sample1.cc $(USER_DIR)/sample1.h $(GTEST_HEADERS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/sample1.cc
+
+sample1_unittest.o : $(USER_DIR)/sample1_unittest.cc \
+                     $(USER_DIR)/sample1.h $(GTEST_HEADERS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/sample1_unittest.cc
+
+sample1_unittest : sample1.o sample1_unittest.o gtest_main.a
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.sln b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.sln
new file mode 100644
index 00000000..f7908da1
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.sln
@@ -0,0 +1,45 @@
+Microsoft Visual Studio Solution File, Format Version 8.00
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest-md", "gtest-md.vcproj", "{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_main-md", "gtest_main-md.vcproj", "{3AF54C8A-10BF-4332-9147-F68ED9862033}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_prod_test-md", "gtest_prod_test-md.vcproj", "{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_unittest-md", "gtest_unittest-md.vcproj", "{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfiguration) = preSolution
+		Debug = Debug
+		Release = Release
+	EndGlobalSection
+	GlobalSection(ProjectConfiguration) = postSolution
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Debug.ActiveCfg = Debug|Win32
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Debug.Build.0 = Debug|Win32
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Release.ActiveCfg = Release|Win32
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Release.Build.0 = Release|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Debug.ActiveCfg = Debug|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Debug.Build.0 = Debug|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Release.ActiveCfg = Release|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Release.Build.0 = Release|Win32
+		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}.Debug.ActiveCfg = Debug|Win32
+		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}.Debug.Build.0 = Debug|Win32
+		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}.Release.ActiveCfg = Release|Win32
+		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}.Release.Build.0 = Release|Win32
+		{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}.Debug.ActiveCfg = Debug|Win32
+		{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}.Debug.Build.0 = Debug|Win32
+		{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}.Release.ActiveCfg = Release|Win32
+		{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}.Release.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+	EndGlobalSection
+	GlobalSection(ExtensibilityAddIns) = postSolution
+	EndGlobalSection
+EndGlobal
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.vcproj
new file mode 100644
index 00000000..1c35c3a5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.vcproj
@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="gtest-md"
+	ProjectGUID="{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			ReferencesPath="">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/gtestd.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			ReferencesPath="&quot;..\include&quot;;&quot;..&quot;">
+			<Tool
+				Name="VCCLCompilerTool"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/gtest.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\src\gtest-all.cc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.sln b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.sln
new file mode 100644
index 00000000..ef4b057f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.sln
@@ -0,0 +1,45 @@
+Microsoft Visual Studio Solution File, Format Version 8.00
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest", "gtest.vcproj", "{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_main", "gtest_main.vcproj", "{3AF54C8A-10BF-4332-9147-F68ED9862032}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_unittest", "gtest_unittest.vcproj", "{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_prod_test", "gtest_prod_test.vcproj", "{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfiguration) = preSolution
+		Debug = Debug
+		Release = Release
+	EndGlobalSection
+	GlobalSection(ProjectConfiguration) = postSolution
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}.Debug.ActiveCfg = Debug|Win32
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}.Debug.Build.0 = Debug|Win32
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}.Release.ActiveCfg = Release|Win32
+		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}.Release.Build.0 = Release|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862032}.Debug.ActiveCfg = Debug|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862032}.Debug.Build.0 = Debug|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862032}.Release.ActiveCfg = Release|Win32
+		{3AF54C8A-10BF-4332-9147-F68ED9862032}.Release.Build.0 = Release|Win32
+		{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}.Debug.ActiveCfg = Debug|Win32
+		{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}.Debug.Build.0 = Debug|Win32
+		{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}.Release.ActiveCfg = Release|Win32
+		{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}.Release.Build.0 = Release|Win32
+		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}.Debug.ActiveCfg = Debug|Win32
+		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}.Debug.Build.0 = Debug|Win32
+		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}.Release.ActiveCfg = Release|Win32
+		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}.Release.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+	EndGlobalSection
+	GlobalSection(ExtensibilityAddIns) = postSolution
+	EndGlobalSection
+EndGlobal
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.vcproj
new file mode 100644
index 00000000..a8373ce9
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.vcproj
@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="gtest"
+	ProjectGUID="{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			ReferencesPath="">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/gtestd.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			ReferencesPath="&quot;..\include&quot;;&quot;..&quot;">
+			<Tool
+				Name="VCCLCompilerTool"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+				RuntimeLibrary="4"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/gtest.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\src\gtest-all.cc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main-md.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main-md.vcproj
new file mode 100644
index 00000000..b5379fe6
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main-md.vcproj
@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="gtest_main-md"
+	ProjectGUID="{3AF54C8A-10BF-4332-9147-F68ED9862033}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			ReferencesPath="">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/$(ProjectName)d.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			ReferencesPath="&quot;..\include&quot;;&quot;..&quot;">
+			<Tool
+				Name="VCCLCompilerTool"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/$(ProjectName).lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+		<ProjectReference
+			ReferencedProjectIdentifier="{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}"
+			Name="gtest-md"/>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\src\gtest_main.cc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main.vcproj
new file mode 100644
index 00000000..e8b763c5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main.vcproj
@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="gtest_main"
+	ProjectGUID="{3AF54C8A-10BF-4332-9147-F68ED9862032}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			ReferencesPath="">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/$(ProjectName)d.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			ReferencesPath="&quot;..\include&quot;;&quot;..&quot;">
+			<Tool
+				Name="VCCLCompilerTool"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+				RuntimeLibrary="4"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/$(ProjectName).lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+		<ProjectReference
+			ReferencedProjectIdentifier="{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}"
+			Name="gtest"/>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\src\gtest_main.cc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test-md.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test-md.vcproj
new file mode 100644
index 00000000..05b05d9e
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test-md.vcproj
@@ -0,0 +1,164 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="gtest_prod_test-md"
+	ProjectGUID="{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="3"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/gtest_prod_test.exe"
+				LinkIncremental="2"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/gtest_prod_test.pdb"
+				SubSystem="1"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="3"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/gtest_prod_test.exe"
+				LinkIncremental="1"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+		<ProjectReference
+			ReferencedProjectIdentifier="{3AF54C8A-10BF-4332-9147-F68ED9862033}"
+			Name="gtest_main-md"/>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\test\gtest_prod_test.cc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\test\production.cc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+			<File
+				RelativePath="..\test\production.h">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test.vcproj
new file mode 100644
index 00000000..6d7a2f02
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test.vcproj
@@ -0,0 +1,164 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="gtest_prod_test"
+	ProjectGUID="{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="3"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/gtest_prod_test.exe"
+				LinkIncremental="2"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/gtest_prod_test.pdb"
+				SubSystem="1"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="4"
+				UsePrecompiledHeader="3"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/gtest_prod_test.exe"
+				LinkIncremental="1"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+		<ProjectReference
+			ReferencedProjectIdentifier="{3AF54C8A-10BF-4332-9147-F68ED9862032}"
+			Name="gtest_main"/>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\test\gtest_prod_test.cc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\test\production.cc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+			<File
+				RelativePath="..\test\production.h">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest-md.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest-md.vcproj
new file mode 100644
index 00000000..38a5e566
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest-md.vcproj
@@ -0,0 +1,147 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="gtest_unittest-md"
+	ProjectGUID="{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="3"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/gtest_unittest.exe"
+				LinkIncremental="2"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/gtest_unittest.pdb"
+				SubSystem="1"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="3"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/gtest_unittest.exe"
+				LinkIncremental="1"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+		<ProjectReference
+			ReferencedProjectIdentifier="{3AF54C8A-10BF-4332-9147-F68ED9862033}"
+			Name="gtest_main-md"/>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\test\gtest_unittest.cc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						Optimization="1"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
+						BasicRuntimeChecks="0"
+						UsePrecompiledHeader="0"
+						DebugInformationFormat="3"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest.vcproj
new file mode 100644
index 00000000..cb1f52b1
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest.vcproj
@@ -0,0 +1,147 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="gtest_unittest"
+	ProjectGUID="{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="3"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/gtest_unittest.exe"
+				LinkIncremental="2"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/gtest_unittest.pdb"
+				SubSystem="1"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)/$(ProjectName)"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="4"
+				UsePrecompiledHeader="3"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/gtest_unittest.exe"
+				LinkIncremental="1"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+		<ProjectReference
+			ReferencedProjectIdentifier="{3AF54C8A-10BF-4332-9147-F68ED9862032}"
+			Name="gtest_main"/>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\test\gtest_unittest.cc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						Optimization="1"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
+						BasicRuntimeChecks="0"
+						UsePrecompiledHeader="0"
+						DebugInformationFormat="3"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/prime_tables.h b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/prime_tables.h
new file mode 100644
index 00000000..92ce16a0
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/prime_tables.h
@@ -0,0 +1,123 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+// Author: vladl@google.com (Vlad Losev)
+
+// This provides interface PrimeTable that determines whether a number is a
+// prime and determines a next prime number. This interface is used
+// in Google Test samples demonstrating use of parameterized tests.
+
+#ifndef GTEST_SAMPLES_PRIME_TABLES_H_
+#define GTEST_SAMPLES_PRIME_TABLES_H_
+
+#include <algorithm>
+
+// The prime table interface.
+class PrimeTable {
+ public:
+  virtual ~PrimeTable() {}
+
+  // Returns true iff n is a prime number.
+  virtual bool IsPrime(int n) const = 0;
+
+  // Returns the smallest prime number greater than p; or returns -1
+  // if the next prime is beyond the capacity of the table.
+  virtual int GetNextPrime(int p) const = 0;
+};
+
+// Implementation #1 calculates the primes on-the-fly.
+class OnTheFlyPrimeTable : public PrimeTable {
+ public:
+  virtual bool IsPrime(int n) const {
+    if (n <= 1) return false;
+
+    for (int i = 2; i*i <= n; i++) {
+      // n is divisible by an integer other than 1 and itself.
+      if ((n % i) == 0) return false;
+    }
+
+    return true;
+  }
+
+  virtual int GetNextPrime(int p) const {
+    for (int n = p + 1; n > 0; n++) {
+      if (IsPrime(n)) return n;
+    }
+
+    return -1;
+  }
+};
+
+// Implementation #2 pre-calculates the primes and stores the result
+// in an array.
+class PreCalculatedPrimeTable : public PrimeTable {
+ public:
+  // 'max' specifies the maximum number the prime table holds.
+  explicit PreCalculatedPrimeTable(int max)
+      : is_prime_size_(max + 1), is_prime_(new bool[max + 1]) {
+    CalculatePrimesUpTo(max);
+  }
+  virtual ~PreCalculatedPrimeTable() { delete[] is_prime_; }
+
+  virtual bool IsPrime(int n) const {
+    return 0 <= n && n < is_prime_size_ && is_prime_[n];
+  }
+
+  virtual int GetNextPrime(int p) const {
+    for (int n = p + 1; n < is_prime_size_; n++) {
+      if (is_prime_[n]) return n;
+    }
+
+    return -1;
+  }
+
+ private:
+  void CalculatePrimesUpTo(int max) {
+    ::std::fill(is_prime_, is_prime_ + is_prime_size_, true);
+    is_prime_[0] = is_prime_[1] = false;
+
+    for (int i = 2; i <= max; i++) {
+      if (!is_prime_[i]) continue;
+
+      // Marks all multiples of i (except i itself) as non-prime.
+      for (int j = 2*i; j <= max; j += i) {
+        is_prime_[j] = false;
+      }
+    }
+  }
+
+  const int is_prime_size_;
+  bool* const is_prime_;
+
+  // Disables compiler warning "assignment operator could not be generated."
+  void operator=(const PreCalculatedPrimeTable& rhs);
+};
+
+#endif  // GTEST_SAMPLES_PRIME_TABLES_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.cc
new file mode 100644
index 00000000..f171e260
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.cc
@@ -0,0 +1,68 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A sample program demonstrating using Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "sample1.h"
+
+// Returns n! (the factorial of n).  For negative n, n! is defined to be 1.
+int Factorial(int n) {
+  int result = 1;
+  for (int i = 1; i <= n; i++) {
+    result *= i;
+  }
+
+  return result;
+}
+
+// Returns true iff n is a prime number.
+bool IsPrime(int n) {
+  // Trivial case 1: small numbers
+  if (n <= 1) return false;
+
+  // Trivial case 2: even numbers
+  if (n % 2 == 0) return n == 2;
+
+  // Now, we have that n is odd and n >= 3.
+
+  // Try to divide n by every odd number i, starting from 3
+  for (int i = 3; ; i += 2) {
+    // We only have to try i up to the squre root of n
+    if (i > n/i) break;
+
+    // Now, we have i <= n/i < n.
+    // If n is divisible by i, n is not prime.
+    if (n % i == 0) return false;
+  }
+
+  // n has no integer factor in the range (1, n), and thus is prime.
+  return true;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.h b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.h
new file mode 100644
index 00000000..3dfeb98c
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.h
@@ -0,0 +1,43 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A sample program demonstrating using Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#ifndef GTEST_SAMPLES_SAMPLE1_H_
+#define GTEST_SAMPLES_SAMPLE1_H_
+
+// Returns n! (the factorial of n).  For negative n, n! is defined to be 1.
+int Factorial(int n);
+
+// Returns true iff n is a prime number.
+bool IsPrime(int n);
+
+#endif  // GTEST_SAMPLES_SAMPLE1_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample10_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample10_unittest.cc
new file mode 100644
index 00000000..0051cd5d
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample10_unittest.cc
@@ -0,0 +1,144 @@
+// Copyright 2009 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+
+// This sample shows how to use Google Test listener API to implement
+// a primitive leak checker.
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "gtest/gtest.h"
+
+using ::testing::EmptyTestEventListener;
+using ::testing::InitGoogleTest;
+using ::testing::Test;
+using ::testing::TestCase;
+using ::testing::TestEventListeners;
+using ::testing::TestInfo;
+using ::testing::TestPartResult;
+using ::testing::UnitTest;
+
+namespace {
+
+// We will track memory used by this class.
+class Water {
+ public:
+  // Normal Water declarations go here.
+
+  // operator new and operator delete help us control water allocation.
+  void* operator new(size_t allocation_size) {
+    allocated_++;
+    return malloc(allocation_size);
+  }
+
+  void operator delete(void* block, size_t /* allocation_size */) {
+    allocated_--;
+    free(block);
+  }
+
+  static int allocated() { return allocated_; }
+
+ private:
+  static int allocated_;
+};
+
+int Water::allocated_ = 0;
+
+// This event listener monitors how many Water objects are created and
+// destroyed by each test, and reports a failure if a test leaks some Water
+// objects. It does this by comparing the number of live Water objects at
+// the beginning of a test and at the end of a test.
+class LeakChecker : public EmptyTestEventListener {
+ private:
+  // Called before a test starts.
+  virtual void OnTestStart(const TestInfo& /* test_info */) {
+    initially_allocated_ = Water::allocated();
+  }
+
+  // Called after a test ends.
+  virtual void OnTestEnd(const TestInfo& /* test_info */) {
+    int difference = Water::allocated() - initially_allocated_;
+
+    // You can generate a failure in any event handler except
+    // OnTestPartResult. Just use an appropriate Google Test assertion to do
+    // it.
+    EXPECT_LE(difference, 0) << "Leaked " << difference << " unit(s) of Water!";
+  }
+
+  int initially_allocated_;
+};
+
+TEST(ListenersTest, DoesNotLeak) {
+  Water* water = new Water;
+  delete water;
+}
+
+// This should fail when the --check_for_leaks command line flag is
+// specified.
+TEST(ListenersTest, LeaksWater) {
+  Water* water = new Water;
+  EXPECT_TRUE(water != NULL);
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  InitGoogleTest(&argc, argv);
+
+  bool check_for_leaks = false;
+  if (argc > 1 && strcmp(argv[1], "--check_for_leaks") == 0 )
+    check_for_leaks = true;
+  else
+    printf("%s\n", "Run this program with --check_for_leaks to enable "
+           "custom leak checking in the tests.");
+
+  // If we are given the --check_for_leaks command line flag, installs the
+  // leak checker.
+  if (check_for_leaks) {
+    TestEventListeners& listeners = UnitTest::GetInstance()->listeners();
+
+    // Adds the leak checker to the end of the test event listener list,
+    // after the default text output printer and the default XML report
+    // generator.
+    //
+    // The order is important - it ensures that failures generated in the
+    // leak checker's OnTestEnd() method are processed by the text and XML
+    // printers *before* their OnTestEnd() methods are called, such that
+    // they are attributed to the right test. Remember that a listener
+    // receives an OnXyzStart event *after* listeners preceding it in the
+    // list received that event, and receives an OnXyzEnd event *before*
+    // listeners preceding it.
+    //
+    // We don't need to worry about deleting the new listener later, as
+    // Google Test will do it.
+    listeners.Append(new LeakChecker);
+  }
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1_unittest.cc
new file mode 100644
index 00000000..aefc4f1d
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1_unittest.cc
@@ -0,0 +1,153 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A sample program demonstrating using Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+
+// This sample shows how to write a simple unit test for a function,
+// using Google C++ testing framework.
+//
+// Writing a unit test using Google C++ testing framework is easy as 1-2-3:
+
+
+// Step 1. Include necessary header files such that the stuff your
+// test logic needs is declared.
+//
+// Don't forget gtest.h, which declares the testing framework.
+
+#include <limits.h>
+#include "sample1.h"
+#include "gtest/gtest.h"
+
+
+// Step 2. Use the TEST macro to define your tests.
+//
+// TEST has two parameters: the test case name and the test name.
+// After using the macro, you should define your test logic between a
+// pair of braces.  You can use a bunch of macros to indicate the
+// success or failure of a test.  EXPECT_TRUE and EXPECT_EQ are
+// examples of such macros.  For a complete list, see gtest.h.
+//
+// <TechnicalDetails>
+//
+// In Google Test, tests are grouped into test cases.  This is how we
+// keep test code organized.  You should put logically related tests
+// into the same test case.
+//
+// The test case name and the test name should both be valid C++
+// identifiers.  And you should not use underscore (_) in the names.
+//
+// Google Test guarantees that each test you define is run exactly
+// once, but it makes no guarantee on the order the tests are
+// executed.  Therefore, you should write your tests in such a way
+// that their results don't depend on their order.
+//
+// </TechnicalDetails>
+
+
+// Tests Factorial().
+
+// Tests factorial of negative numbers.
+TEST(FactorialTest, Negative) {
+  // This test is named "Negative", and belongs to the "FactorialTest"
+  // test case.
+  EXPECT_EQ(1, Factorial(-5));
+  EXPECT_EQ(1, Factorial(-1));
+  EXPECT_GT(Factorial(-10), 0);
+
+  // <TechnicalDetails>
+  //
+  // EXPECT_EQ(expected, actual) is the same as
+  //
+  //   EXPECT_TRUE((expected) == (actual))
+  //
+  // except that it will print both the expected value and the actual
+  // value when the assertion fails.  This is very helpful for
+  // debugging.  Therefore in this case EXPECT_EQ is preferred.
+  //
+  // On the other hand, EXPECT_TRUE accepts any Boolean expression,
+  // and is thus more general.
+  //
+  // </TechnicalDetails>
+}
+
+// Tests factorial of 0.
+TEST(FactorialTest, Zero) {
+  EXPECT_EQ(1, Factorial(0));
+}
+
+// Tests factorial of positive numbers.
+TEST(FactorialTest, Positive) {
+  EXPECT_EQ(1, Factorial(1));
+  EXPECT_EQ(2, Factorial(2));
+  EXPECT_EQ(6, Factorial(3));
+  EXPECT_EQ(40320, Factorial(8));
+}
+
+
+// Tests IsPrime()
+
+// Tests negative input.
+TEST(IsPrimeTest, Negative) {
+  // This test belongs to the IsPrimeTest test case.
+
+  EXPECT_FALSE(IsPrime(-1));
+  EXPECT_FALSE(IsPrime(-2));
+  EXPECT_FALSE(IsPrime(INT_MIN));
+}
+
+// Tests some trivial cases.
+TEST(IsPrimeTest, Trivial) {
+  EXPECT_FALSE(IsPrime(0));
+  EXPECT_FALSE(IsPrime(1));
+  EXPECT_TRUE(IsPrime(2));
+  EXPECT_TRUE(IsPrime(3));
+}
+
+// Tests positive input.
+TEST(IsPrimeTest, Positive) {
+  EXPECT_FALSE(IsPrime(4));
+  EXPECT_TRUE(IsPrime(5));
+  EXPECT_FALSE(IsPrime(6));
+  EXPECT_TRUE(IsPrime(23));
+}
+
+// Step 3. Call RUN_ALL_TESTS() in main().
+//
+// We do this by linking in src/gtest_main.cc file, which consists of
+// a main() function which calls RUN_ALL_TESTS() for us.
+//
+// This runs all the tests you've defined, prints the result, and
+// returns 0 if successful, or 1 otherwise.
+//
+// Did you notice that we didn't register the tests?  The
+// RUN_ALL_TESTS() macro magically knows about all the tests we
+// defined.  Isn't this convenient?
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.cc
new file mode 100644
index 00000000..5f763b9b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.cc
@@ -0,0 +1,56 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A sample program demonstrating using Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "sample2.h"
+
+#include <string.h>
+
+// Clones a 0-terminated C string, allocating memory using new.
+const char* MyString::CloneCString(const char* a_c_string) {
+  if (a_c_string == NULL) return NULL;
+
+  const size_t len = strlen(a_c_string);
+  char* const clone = new char[ len + 1 ];
+  memcpy(clone, a_c_string, len + 1);
+
+  return clone;
+}
+
+// Sets the 0-terminated C string this MyString object
+// represents.
+void MyString::Set(const char* a_c_string) {
+  // Makes sure this works when c_string == c_string_
+  const char* const temp = MyString::CloneCString(a_c_string);
+  delete[] c_string_;
+  c_string_ = temp;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.h b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.h
new file mode 100644
index 00000000..cb485c70
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.h
@@ -0,0 +1,85 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A sample program demonstrating using Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#ifndef GTEST_SAMPLES_SAMPLE2_H_
+#define GTEST_SAMPLES_SAMPLE2_H_
+
+#include <string.h>
+
+
+// A simple string class.
+class MyString {
+ private:
+  const char* c_string_;
+  const MyString& operator=(const MyString& rhs);
+
+ public:
+  // Clones a 0-terminated C string, allocating memory using new.
+  static const char* CloneCString(const char* a_c_string);
+
+  ////////////////////////////////////////////////////////////
+  //
+  // C'tors
+
+  // The default c'tor constructs a NULL string.
+  MyString() : c_string_(NULL) {}
+
+  // Constructs a MyString by cloning a 0-terminated C string.
+  explicit MyString(const char* a_c_string) : c_string_(NULL) {
+    Set(a_c_string);
+  }
+
+  // Copy c'tor
+  MyString(const MyString& string) : c_string_(NULL) {
+    Set(string.c_string_);
+  }
+
+  ////////////////////////////////////////////////////////////
+  //
+  // D'tor.  MyString is intended to be a final class, so the d'tor
+  // doesn't need to be virtual.
+  ~MyString() { delete[] c_string_; }
+
+  // Gets the 0-terminated C string this MyString object represents.
+  const char* c_string() const { return c_string_; }
+
+  size_t Length() const {
+    return c_string_ == NULL ? 0 : strlen(c_string_);
+  }
+
+  // Sets the 0-terminated C string this MyString object represents.
+  void Set(const char* c_string);
+};
+
+
+#endif  // GTEST_SAMPLES_SAMPLE2_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2_unittest.cc
new file mode 100644
index 00000000..4fa19b71
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2_unittest.cc
@@ -0,0 +1,109 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A sample program demonstrating using Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+
+// This sample shows how to write a more complex unit test for a class
+// that has multiple member functions.
+//
+// Usually, it's a good idea to have one test for each method in your
+// class.  You don't have to do that exactly, but it helps to keep
+// your tests organized.  You may also throw in additional tests as
+// needed.
+
+#include "sample2.h"
+#include "gtest/gtest.h"
+
+// In this example, we test the MyString class (a simple string).
+
+// Tests the default c'tor.
+TEST(MyString, DefaultConstructor) {
+  const MyString s;
+
+  // Asserts that s.c_string() returns NULL.
+  //
+  // <TechnicalDetails>
+  //
+  // If we write NULL instead of
+  //
+  //   static_cast<const char *>(NULL)
+  //
+  // in this assertion, it will generate a warning on gcc 3.4.  The
+  // reason is that EXPECT_EQ needs to know the types of its
+  // arguments in order to print them when it fails.  Since NULL is
+  // #defined as 0, the compiler will use the formatter function for
+  // int to print it.  However, gcc thinks that NULL should be used as
+  // a pointer, not an int, and therefore complains.
+  //
+  // The root of the problem is C++'s lack of distinction between the
+  // integer number 0 and the null pointer constant.  Unfortunately,
+  // we have to live with this fact.
+  //
+  // </TechnicalDetails>
+  EXPECT_STREQ(NULL, s.c_string());
+
+  EXPECT_EQ(0u, s.Length());
+}
+
+const char kHelloString[] = "Hello, world!";
+
+// Tests the c'tor that accepts a C string.
+TEST(MyString, ConstructorFromCString) {
+  const MyString s(kHelloString);
+  EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
+  EXPECT_EQ(sizeof(kHelloString)/sizeof(kHelloString[0]) - 1,
+            s.Length());
+}
+
+// Tests the copy c'tor.
+TEST(MyString, CopyConstructor) {
+  const MyString s1(kHelloString);
+  const MyString s2 = s1;
+  EXPECT_EQ(0, strcmp(s2.c_string(), kHelloString));
+}
+
+// Tests the Set method.
+TEST(MyString, Set) {
+  MyString s;
+
+  s.Set(kHelloString);
+  EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
+
+  // Set should work when the input pointer is the same as the one
+  // already in the MyString object.
+  s.Set(s.c_string());
+  EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
+
+  // Can we set the MyString to NULL?
+  s.Set(NULL);
+  EXPECT_STREQ(NULL, s.c_string());
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3-inl.h b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3-inl.h
new file mode 100644
index 00000000..7e3084d6
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3-inl.h
@@ -0,0 +1,172 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A sample program demonstrating using Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#ifndef GTEST_SAMPLES_SAMPLE3_INL_H_
+#define GTEST_SAMPLES_SAMPLE3_INL_H_
+
+#include <stddef.h>
+
+
+// Queue is a simple queue implemented as a singled-linked list.
+//
+// The element type must support copy constructor.
+template <typename E>  // E is the element type
+class Queue;
+
+// QueueNode is a node in a Queue, which consists of an element of
+// type E and a pointer to the next node.
+template <typename E>  // E is the element type
+class QueueNode {
+  friend class Queue<E>;
+
+ public:
+  // Gets the element in this node.
+  const E& element() const { return element_; }
+
+  // Gets the next node in the queue.
+  QueueNode* next() { return next_; }
+  const QueueNode* next() const { return next_; }
+
+ private:
+  // Creates a node with a given element value.  The next pointer is
+  // set to NULL.
+  explicit QueueNode(const E& an_element) : element_(an_element), next_(NULL) {}
+
+  // We disable the default assignment operator and copy c'tor.
+  const QueueNode& operator = (const QueueNode&);
+  QueueNode(const QueueNode&);
+
+  E element_;
+  QueueNode* next_;
+};
+
+template <typename E>  // E is the element type.
+class Queue {
+ public:
+  // Creates an empty queue.
+  Queue() : head_(NULL), last_(NULL), size_(0) {}
+
+  // D'tor.  Clears the queue.
+  ~Queue() { Clear(); }
+
+  // Clears the queue.
+  void Clear() {
+    if (size_ > 0) {
+      // 1. Deletes every node.
+      QueueNode<E>* node = head_;
+      QueueNode<E>* next = node->next();
+      for (; ;) {
+        delete node;
+        node = next;
+        if (node == NULL) break;
+        next = node->next();
+      }
+
+      // 2. Resets the member variables.
+      head_ = last_ = NULL;
+      size_ = 0;
+    }
+  }
+
+  // Gets the number of elements.
+  size_t Size() const { return size_; }
+
+  // Gets the first element of the queue, or NULL if the queue is empty.
+  QueueNode<E>* Head() { return head_; }
+  const QueueNode<E>* Head() const { return head_; }
+
+  // Gets the last element of the queue, or NULL if the queue is empty.
+  QueueNode<E>* Last() { return last_; }
+  const QueueNode<E>* Last() const { return last_; }
+
+  // Adds an element to the end of the queue.  A copy of the element is
+  // created using the copy constructor, and then stored in the queue.
+  // Changes made to the element in the queue doesn't affect the source
+  // object, and vice versa.
+  void Enqueue(const E& element) {
+    QueueNode<E>* new_node = new QueueNode<E>(element);
+
+    if (size_ == 0) {
+      head_ = last_ = new_node;
+      size_ = 1;
+    } else {
+      last_->next_ = new_node;
+      last_ = new_node;
+      size_++;
+    }
+  }
+
+  // Removes the head of the queue and returns it.  Returns NULL if
+  // the queue is empty.
+  E* Dequeue() {
+    if (size_ == 0) {
+      return NULL;
+    }
+
+    const QueueNode<E>* const old_head = head_;
+    head_ = head_->next_;
+    size_--;
+    if (size_ == 0) {
+      last_ = NULL;
+    }
+
+    E* element = new E(old_head->element());
+    delete old_head;
+
+    return element;
+  }
+
+  // Applies a function/functor on each element of the queue, and
+  // returns the result in a new queue.  The original queue is not
+  // affected.
+  template <typename F>
+  Queue* Map(F function) const {
+    Queue* new_queue = new Queue();
+    for (const QueueNode<E>* node = head_; node != NULL; node = node->next_) {
+      new_queue->Enqueue(function(node->element()));
+    }
+
+    return new_queue;
+  }
+
+ private:
+  QueueNode<E>* head_;  // The first node of the queue.
+  QueueNode<E>* last_;  // The last node of the queue.
+  size_t size_;  // The number of elements in the queue.
+
+  // We disallow copying a queue.
+  Queue(const Queue&);
+  const Queue& operator = (const Queue&);
+};
+
+#endif  // GTEST_SAMPLES_SAMPLE3_INL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3_unittest.cc
new file mode 100644
index 00000000..bf3877d0
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3_unittest.cc
@@ -0,0 +1,151 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A sample program demonstrating using Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+
+// In this example, we use a more advanced feature of Google Test called
+// test fixture.
+//
+// A test fixture is a place to hold objects and functions shared by
+// all tests in a test case.  Using a test fixture avoids duplicating
+// the test code necessary to initialize and cleanup those common
+// objects for each test.  It is also useful for defining sub-routines
+// that your tests need to invoke a lot.
+//
+// <TechnicalDetails>
+//
+// The tests share the test fixture in the sense of code sharing, not
+// data sharing.  Each test is given its own fresh copy of the
+// fixture.  You cannot expect the data modified by one test to be
+// passed on to another test, which is a bad idea.
+//
+// The reason for this design is that tests should be independent and
+// repeatable.  In particular, a test should not fail as the result of
+// another test's failure.  If one test depends on info produced by
+// another test, then the two tests should really be one big test.
+//
+// The macros for indicating the success/failure of a test
+// (EXPECT_TRUE, FAIL, etc) need to know what the current test is
+// (when Google Test prints the test result, it tells you which test
+// each failure belongs to).  Technically, these macros invoke a
+// member function of the Test class.  Therefore, you cannot use them
+// in a global function.  That's why you should put test sub-routines
+// in a test fixture.
+//
+// </TechnicalDetails>
+
+#include "sample3-inl.h"
+#include "gtest/gtest.h"
+
+// To use a test fixture, derive a class from testing::Test.
+class QueueTest : public testing::Test {
+ protected:  // You should make the members protected s.t. they can be
+             // accessed from sub-classes.
+
+  // virtual void SetUp() will be called before each test is run.  You
+  // should define it if you need to initialize the varaibles.
+  // Otherwise, this can be skipped.
+  virtual void SetUp() {
+    q1_.Enqueue(1);
+    q2_.Enqueue(2);
+    q2_.Enqueue(3);
+  }
+
+  // virtual void TearDown() will be called after each test is run.
+  // You should define it if there is cleanup work to do.  Otherwise,
+  // you don't have to provide it.
+  //
+  // virtual void TearDown() {
+  // }
+
+  // A helper function that some test uses.
+  static int Double(int n) {
+    return 2*n;
+  }
+
+  // A helper function for testing Queue::Map().
+  void MapTester(const Queue<int> * q) {
+    // Creates a new queue, where each element is twice as big as the
+    // corresponding one in q.
+    const Queue<int> * const new_q = q->Map(Double);
+
+    // Verifies that the new queue has the same size as q.
+    ASSERT_EQ(q->Size(), new_q->Size());
+
+    // Verifies the relationship between the elements of the two queues.
+    for ( const QueueNode<int> * n1 = q->Head(), * n2 = new_q->Head();
+          n1 != NULL; n1 = n1->next(), n2 = n2->next() ) {
+      EXPECT_EQ(2 * n1->element(), n2->element());
+    }
+
+    delete new_q;
+  }
+
+  // Declares the variables your tests want to use.
+  Queue<int> q0_;
+  Queue<int> q1_;
+  Queue<int> q2_;
+};
+
+// When you have a test fixture, you define a test using TEST_F
+// instead of TEST.
+
+// Tests the default c'tor.
+TEST_F(QueueTest, DefaultConstructor) {
+  // You can access data in the test fixture here.
+  EXPECT_EQ(0u, q0_.Size());
+}
+
+// Tests Dequeue().
+TEST_F(QueueTest, Dequeue) {
+  int * n = q0_.Dequeue();
+  EXPECT_TRUE(n == NULL);
+
+  n = q1_.Dequeue();
+  ASSERT_TRUE(n != NULL);
+  EXPECT_EQ(1, *n);
+  EXPECT_EQ(0u, q1_.Size());
+  delete n;
+
+  n = q2_.Dequeue();
+  ASSERT_TRUE(n != NULL);
+  EXPECT_EQ(2, *n);
+  EXPECT_EQ(1u, q2_.Size());
+  delete n;
+}
+
+// Tests the Queue::Map() function.
+TEST_F(QueueTest, Map) {
+  MapTester(&q0_);
+  MapTester(&q1_);
+  MapTester(&q2_);
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.cc
new file mode 100644
index 00000000..ae44bda6
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.cc
@@ -0,0 +1,46 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A sample program demonstrating using Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include <stdio.h>
+
+#include "sample4.h"
+
+// Returns the current counter value, and increments it.
+int Counter::Increment() {
+  return counter_++;
+}
+
+// Prints the current counter value to STDOUT.
+void Counter::Print() const {
+  printf("%d", counter_);
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.h b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.h
new file mode 100644
index 00000000..cd60f0dd
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.h
@@ -0,0 +1,53 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A sample program demonstrating using Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#ifndef GTEST_SAMPLES_SAMPLE4_H_
+#define GTEST_SAMPLES_SAMPLE4_H_
+
+// A simple monotonic counter.
+class Counter {
+ private:
+  int counter_;
+
+ public:
+  // Creates a counter that starts at 0.
+  Counter() : counter_(0) {}
+
+  // Returns the current counter value, and increments it.
+  int Increment();
+
+  // Prints the current counter value to STDOUT.
+  void Print() const;
+};
+
+#endif  // GTEST_SAMPLES_SAMPLE4_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4_unittest.cc
new file mode 100644
index 00000000..fa5afc7d
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4_unittest.cc
@@ -0,0 +1,45 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "gtest/gtest.h"
+#include "sample4.h"
+
+// Tests the Increment() method.
+TEST(Counter, Increment) {
+  Counter c;
+
+  // EXPECT_EQ() evaluates its arguments exactly once, so they
+  // can have side effects.
+
+  EXPECT_EQ(0, c.Increment());
+  EXPECT_EQ(1, c.Increment());
+  EXPECT_EQ(2, c.Increment());
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample5_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample5_unittest.cc
new file mode 100644
index 00000000..43d8e577
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample5_unittest.cc
@@ -0,0 +1,199 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// This sample teaches how to reuse a test fixture in multiple test
+// cases by deriving sub-fixtures from it.
+//
+// When you define a test fixture, you specify the name of the test
+// case that will use this fixture.  Therefore, a test fixture can
+// be used by only one test case.
+//
+// Sometimes, more than one test cases may want to use the same or
+// slightly different test fixtures.  For example, you may want to
+// make sure that all tests for a GUI library don't leak important
+// system resources like fonts and brushes.  In Google Test, you do
+// this by putting the shared logic in a super (as in "super class")
+// test fixture, and then have each test case use a fixture derived
+// from this super fixture.
+
+#include <limits.h>
+#include <time.h>
+#include "sample3-inl.h"
+#include "gtest/gtest.h"
+#include "sample1.h"
+
+// In this sample, we want to ensure that every test finishes within
+// ~5 seconds.  If a test takes longer to run, we consider it a
+// failure.
+//
+// We put the code for timing a test in a test fixture called
+// "QuickTest".  QuickTest is intended to be the super fixture that
+// other fixtures derive from, therefore there is no test case with
+// the name "QuickTest".  This is OK.
+//
+// Later, we will derive multiple test fixtures from QuickTest.
+class QuickTest : public testing::Test {
+ protected:
+  // Remember that SetUp() is run immediately before a test starts.
+  // This is a good place to record the start time.
+  virtual void SetUp() {
+    start_time_ = time(NULL);
+  }
+
+  // TearDown() is invoked immediately after a test finishes.  Here we
+  // check if the test was too slow.
+  virtual void TearDown() {
+    // Gets the time when the test finishes
+    const time_t end_time = time(NULL);
+
+    // Asserts that the test took no more than ~5 seconds.  Did you
+    // know that you can use assertions in SetUp() and TearDown() as
+    // well?
+    EXPECT_TRUE(end_time - start_time_ <= 5) << "The test took too long.";
+  }
+
+  // The UTC time (in seconds) when the test starts
+  time_t start_time_;
+};
+
+
+// We derive a fixture named IntegerFunctionTest from the QuickTest
+// fixture.  All tests using this fixture will be automatically
+// required to be quick.
+class IntegerFunctionTest : public QuickTest {
+  // We don't need any more logic than already in the QuickTest fixture.
+  // Therefore the body is empty.
+};
+
+
+// Now we can write tests in the IntegerFunctionTest test case.
+
+// Tests Factorial()
+TEST_F(IntegerFunctionTest, Factorial) {
+  // Tests factorial of negative numbers.
+  EXPECT_EQ(1, Factorial(-5));
+  EXPECT_EQ(1, Factorial(-1));
+  EXPECT_GT(Factorial(-10), 0);
+
+  // Tests factorial of 0.
+  EXPECT_EQ(1, Factorial(0));
+
+  // Tests factorial of positive numbers.
+  EXPECT_EQ(1, Factorial(1));
+  EXPECT_EQ(2, Factorial(2));
+  EXPECT_EQ(6, Factorial(3));
+  EXPECT_EQ(40320, Factorial(8));
+}
+
+
+// Tests IsPrime()
+TEST_F(IntegerFunctionTest, IsPrime) {
+  // Tests negative input.
+  EXPECT_FALSE(IsPrime(-1));
+  EXPECT_FALSE(IsPrime(-2));
+  EXPECT_FALSE(IsPrime(INT_MIN));
+
+  // Tests some trivial cases.
+  EXPECT_FALSE(IsPrime(0));
+  EXPECT_FALSE(IsPrime(1));
+  EXPECT_TRUE(IsPrime(2));
+  EXPECT_TRUE(IsPrime(3));
+
+  // Tests positive input.
+  EXPECT_FALSE(IsPrime(4));
+  EXPECT_TRUE(IsPrime(5));
+  EXPECT_FALSE(IsPrime(6));
+  EXPECT_TRUE(IsPrime(23));
+}
+
+
+// The next test case (named "QueueTest") also needs to be quick, so
+// we derive another fixture from QuickTest.
+//
+// The QueueTest test fixture has some logic and shared objects in
+// addition to what's in QuickTest already.  We define the additional
+// stuff inside the body of the test fixture, as usual.
+class QueueTest : public QuickTest {
+ protected:
+  virtual void SetUp() {
+    // First, we need to set up the super fixture (QuickTest).
+    QuickTest::SetUp();
+
+    // Second, some additional setup for this fixture.
+    q1_.Enqueue(1);
+    q2_.Enqueue(2);
+    q2_.Enqueue(3);
+  }
+
+  // By default, TearDown() inherits the behavior of
+  // QuickTest::TearDown().  As we have no additional cleaning work
+  // for QueueTest, we omit it here.
+  //
+  // virtual void TearDown() {
+  //   QuickTest::TearDown();
+  // }
+
+  Queue<int> q0_;
+  Queue<int> q1_;
+  Queue<int> q2_;
+};
+
+
+// Now, let's write tests using the QueueTest fixture.
+
+// Tests the default constructor.
+TEST_F(QueueTest, DefaultConstructor) {
+  EXPECT_EQ(0u, q0_.Size());
+}
+
+// Tests Dequeue().
+TEST_F(QueueTest, Dequeue) {
+  int* n = q0_.Dequeue();
+  EXPECT_TRUE(n == NULL);
+
+  n = q1_.Dequeue();
+  EXPECT_TRUE(n != NULL);
+  EXPECT_EQ(1, *n);
+  EXPECT_EQ(0u, q1_.Size());
+  delete n;
+
+  n = q2_.Dequeue();
+  EXPECT_TRUE(n != NULL);
+  EXPECT_EQ(2, *n);
+  EXPECT_EQ(1u, q2_.Size());
+  delete n;
+}
+
+// If necessary, you can derive further test fixtures from a derived
+// fixture itself.  For example, you can derive another fixture from
+// QueueTest.  Google Test imposes no limit on how deep the hierarchy
+// can be.  In practice, however, you probably don't want it to be too
+// deep as to be confusing.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample6_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample6_unittest.cc
new file mode 100644
index 00000000..8f2036a5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample6_unittest.cc
@@ -0,0 +1,224 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// This sample shows how to test common properties of multiple
+// implementations of the same interface (aka interface tests).
+
+// The interface and its implementations are in this header.
+#include "prime_tables.h"
+
+#include "gtest/gtest.h"
+
+// First, we define some factory functions for creating instances of
+// the implementations.  You may be able to skip this step if all your
+// implementations can be constructed the same way.
+
+template <class T>
+PrimeTable* CreatePrimeTable();
+
+template <>
+PrimeTable* CreatePrimeTable<OnTheFlyPrimeTable>() {
+  return new OnTheFlyPrimeTable;
+}
+
+template <>
+PrimeTable* CreatePrimeTable<PreCalculatedPrimeTable>() {
+  return new PreCalculatedPrimeTable(10000);
+}
+
+// Then we define a test fixture class template.
+template <class T>
+class PrimeTableTest : public testing::Test {
+ protected:
+  // The ctor calls the factory function to create a prime table
+  // implemented by T.
+  PrimeTableTest() : table_(CreatePrimeTable<T>()) {}
+
+  virtual ~PrimeTableTest() { delete table_; }
+
+  // Note that we test an implementation via the base interface
+  // instead of the actual implementation class.  This is important
+  // for keeping the tests close to the real world scenario, where the
+  // implementation is invoked via the base interface.  It avoids
+  // got-yas where the implementation class has a method that shadows
+  // a method with the same name (but slightly different argument
+  // types) in the base interface, for example.
+  PrimeTable* const table_;
+};
+
+#if GTEST_HAS_TYPED_TEST
+
+using testing::Types;
+
+// Google Test offers two ways for reusing tests for different types.
+// The first is called "typed tests".  You should use it if you
+// already know *all* the types you are gonna exercise when you write
+// the tests.
+
+// To write a typed test case, first use
+//
+//   TYPED_TEST_CASE(TestCaseName, TypeList);
+//
+// to declare it and specify the type parameters.  As with TEST_F,
+// TestCaseName must match the test fixture name.
+
+// The list of types we want to test.
+typedef Types<OnTheFlyPrimeTable, PreCalculatedPrimeTable> Implementations;
+
+TYPED_TEST_CASE(PrimeTableTest, Implementations);
+
+// Then use TYPED_TEST(TestCaseName, TestName) to define a typed test,
+// similar to TEST_F.
+TYPED_TEST(PrimeTableTest, ReturnsFalseForNonPrimes) {
+  // Inside the test body, you can refer to the type parameter by
+  // TypeParam, and refer to the fixture class by TestFixture.  We
+  // don't need them in this example.
+
+  // Since we are in the template world, C++ requires explicitly
+  // writing 'this->' when referring to members of the fixture class.
+  // This is something you have to learn to live with.
+  EXPECT_FALSE(this->table_->IsPrime(-5));
+  EXPECT_FALSE(this->table_->IsPrime(0));
+  EXPECT_FALSE(this->table_->IsPrime(1));
+  EXPECT_FALSE(this->table_->IsPrime(4));
+  EXPECT_FALSE(this->table_->IsPrime(6));
+  EXPECT_FALSE(this->table_->IsPrime(100));
+}
+
+TYPED_TEST(PrimeTableTest, ReturnsTrueForPrimes) {
+  EXPECT_TRUE(this->table_->IsPrime(2));
+  EXPECT_TRUE(this->table_->IsPrime(3));
+  EXPECT_TRUE(this->table_->IsPrime(5));
+  EXPECT_TRUE(this->table_->IsPrime(7));
+  EXPECT_TRUE(this->table_->IsPrime(11));
+  EXPECT_TRUE(this->table_->IsPrime(131));
+}
+
+TYPED_TEST(PrimeTableTest, CanGetNextPrime) {
+  EXPECT_EQ(2, this->table_->GetNextPrime(0));
+  EXPECT_EQ(3, this->table_->GetNextPrime(2));
+  EXPECT_EQ(5, this->table_->GetNextPrime(3));
+  EXPECT_EQ(7, this->table_->GetNextPrime(5));
+  EXPECT_EQ(11, this->table_->GetNextPrime(7));
+  EXPECT_EQ(131, this->table_->GetNextPrime(128));
+}
+
+// That's it!  Google Test will repeat each TYPED_TEST for each type
+// in the type list specified in TYPED_TEST_CASE.  Sit back and be
+// happy that you don't have to define them multiple times.
+
+#endif  // GTEST_HAS_TYPED_TEST
+
+#if GTEST_HAS_TYPED_TEST_P
+
+using testing::Types;
+
+// Sometimes, however, you don't yet know all the types that you want
+// to test when you write the tests.  For example, if you are the
+// author of an interface and expect other people to implement it, you
+// might want to write a set of tests to make sure each implementation
+// conforms to some basic requirements, but you don't know what
+// implementations will be written in the future.
+//
+// How can you write the tests without committing to the type
+// parameters?  That's what "type-parameterized tests" can do for you.
+// It is a bit more involved than typed tests, but in return you get a
+// test pattern that can be reused in many contexts, which is a big
+// win.  Here's how you do it:
+
+// First, define a test fixture class template.  Here we just reuse
+// the PrimeTableTest fixture defined earlier:
+
+template <class T>
+class PrimeTableTest2 : public PrimeTableTest<T> {
+};
+
+// Then, declare the test case.  The argument is the name of the test
+// fixture, and also the name of the test case (as usual).  The _P
+// suffix is for "parameterized" or "pattern".
+TYPED_TEST_CASE_P(PrimeTableTest2);
+
+// Next, use TYPED_TEST_P(TestCaseName, TestName) to define a test,
+// similar to what you do with TEST_F.
+TYPED_TEST_P(PrimeTableTest2, ReturnsFalseForNonPrimes) {
+  EXPECT_FALSE(this->table_->IsPrime(-5));
+  EXPECT_FALSE(this->table_->IsPrime(0));
+  EXPECT_FALSE(this->table_->IsPrime(1));
+  EXPECT_FALSE(this->table_->IsPrime(4));
+  EXPECT_FALSE(this->table_->IsPrime(6));
+  EXPECT_FALSE(this->table_->IsPrime(100));
+}
+
+TYPED_TEST_P(PrimeTableTest2, ReturnsTrueForPrimes) {
+  EXPECT_TRUE(this->table_->IsPrime(2));
+  EXPECT_TRUE(this->table_->IsPrime(3));
+  EXPECT_TRUE(this->table_->IsPrime(5));
+  EXPECT_TRUE(this->table_->IsPrime(7));
+  EXPECT_TRUE(this->table_->IsPrime(11));
+  EXPECT_TRUE(this->table_->IsPrime(131));
+}
+
+TYPED_TEST_P(PrimeTableTest2, CanGetNextPrime) {
+  EXPECT_EQ(2, this->table_->GetNextPrime(0));
+  EXPECT_EQ(3, this->table_->GetNextPrime(2));
+  EXPECT_EQ(5, this->table_->GetNextPrime(3));
+  EXPECT_EQ(7, this->table_->GetNextPrime(5));
+  EXPECT_EQ(11, this->table_->GetNextPrime(7));
+  EXPECT_EQ(131, this->table_->GetNextPrime(128));
+}
+
+// Type-parameterized tests involve one extra step: you have to
+// enumerate the tests you defined:
+REGISTER_TYPED_TEST_CASE_P(
+    PrimeTableTest2,  // The first argument is the test case name.
+    // The rest of the arguments are the test names.
+    ReturnsFalseForNonPrimes, ReturnsTrueForPrimes, CanGetNextPrime);
+
+// At this point the test pattern is done.  However, you don't have
+// any real test yet as you haven't said which types you want to run
+// the tests with.
+
+// To turn the abstract test pattern into real tests, you instantiate
+// it with a list of types.  Usually the test pattern will be defined
+// in a .h file, and anyone can #include and instantiate it.  You can
+// even instantiate it more than once in the same program.  To tell
+// different instances apart, you give each of them a name, which will
+// become part of the test case name and can be used in test filters.
+
+// The list of types we want to test.  Note that it doesn't have to be
+// defined at the time we write the TYPED_TEST_P()s.
+typedef Types<OnTheFlyPrimeTable, PreCalculatedPrimeTable>
+    PrimeTableImplementations;
+INSTANTIATE_TYPED_TEST_CASE_P(OnTheFlyAndPreCalculated,    // Instance name
+                              PrimeTableTest2,             // Test case name
+                              PrimeTableImplementations);  // Type list
+
+#endif  // GTEST_HAS_TYPED_TEST_P
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample7_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample7_unittest.cc
new file mode 100644
index 00000000..1b651a21
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample7_unittest.cc
@@ -0,0 +1,130 @@
+// 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+
+// This sample shows how to test common properties of multiple
+// implementations of an interface (aka interface tests) using
+// value-parameterized tests. Each test in the test case has
+// a parameter that is an interface pointer to an implementation
+// tested.
+
+// The interface and its implementations are in this header.
+#include "prime_tables.h"
+
+#include "gtest/gtest.h"
+
+#if GTEST_HAS_PARAM_TEST
+
+using ::testing::TestWithParam;
+using ::testing::Values;
+
+// As a general rule, to prevent a test from affecting the tests that come
+// after it, you should create and destroy the tested objects for each test
+// instead of reusing them.  In this sample we will define a simple factory
+// function for PrimeTable objects.  We will instantiate objects in test's
+// SetUp() method and delete them in TearDown() method.
+typedef PrimeTable* CreatePrimeTableFunc();
+
+PrimeTable* CreateOnTheFlyPrimeTable() {
+  return new OnTheFlyPrimeTable();
+}
+
+template <size_t max_precalculated>
+PrimeTable* CreatePreCalculatedPrimeTable() {
+  return new PreCalculatedPrimeTable(max_precalculated);
+}
+
+// Inside the test body, fixture constructor, SetUp(), and TearDown() you
+// can refer to the test parameter by GetParam().  In this case, the test
+// parameter is a factory function which we call in fixture's SetUp() to
+// create and store an instance of PrimeTable.
+class PrimeTableTest : public TestWithParam<CreatePrimeTableFunc*> {
+ public:
+  virtual ~PrimeTableTest() { delete table_; }
+  virtual void SetUp() { table_ = (*GetParam())(); }
+  virtual void TearDown() {
+    delete table_;
+    table_ = NULL;
+  }
+
+ protected:
+  PrimeTable* table_;
+};
+
+TEST_P(PrimeTableTest, ReturnsFalseForNonPrimes) {
+  EXPECT_FALSE(table_->IsPrime(-5));
+  EXPECT_FALSE(table_->IsPrime(0));
+  EXPECT_FALSE(table_->IsPrime(1));
+  EXPECT_FALSE(table_->IsPrime(4));
+  EXPECT_FALSE(table_->IsPrime(6));
+  EXPECT_FALSE(table_->IsPrime(100));
+}
+
+TEST_P(PrimeTableTest, ReturnsTrueForPrimes) {
+  EXPECT_TRUE(table_->IsPrime(2));
+  EXPECT_TRUE(table_->IsPrime(3));
+  EXPECT_TRUE(table_->IsPrime(5));
+  EXPECT_TRUE(table_->IsPrime(7));
+  EXPECT_TRUE(table_->IsPrime(11));
+  EXPECT_TRUE(table_->IsPrime(131));
+}
+
+TEST_P(PrimeTableTest, CanGetNextPrime) {
+  EXPECT_EQ(2, table_->GetNextPrime(0));
+  EXPECT_EQ(3, table_->GetNextPrime(2));
+  EXPECT_EQ(5, table_->GetNextPrime(3));
+  EXPECT_EQ(7, table_->GetNextPrime(5));
+  EXPECT_EQ(11, table_->GetNextPrime(7));
+  EXPECT_EQ(131, table_->GetNextPrime(128));
+}
+
+// In order to run value-parameterized tests, you need to instantiate them,
+// or bind them to a list of values which will be used as test parameters.
+// You can instantiate them in a different translation module, or even
+// instantiate them several times.
+//
+// Here, we instantiate our tests with a list of two PrimeTable object
+// factory functions:
+INSTANTIATE_TEST_CASE_P(
+    OnTheFlyAndPreCalculated,
+    PrimeTableTest,
+    Values(&CreateOnTheFlyPrimeTable, &CreatePreCalculatedPrimeTable<1000>));
+
+#else
+
+// Google Test may not support value-parameterized tests with some
+// compilers. If we use conditional compilation to compile out all
+// code referring to the gtest_main library, MSVC linker will not link
+// that library at all and consequently complain about missing entry
+// point defined in that library (fatal error LNK1561: entry point
+// must be defined). This dummy test keeps gtest_main linked in.
+TEST(DummyTest, ValueParameterizedTestsAreNotSupportedOnThisPlatform) {}
+
+#endif  // GTEST_HAS_PARAM_TEST
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample8_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample8_unittest.cc
new file mode 100644
index 00000000..72743340
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample8_unittest.cc
@@ -0,0 +1,173 @@
+// 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+
+// This sample shows how to test code relying on some global flag variables.
+// Combine() helps with generating all possible combinations of such flags,
+// and each test is given one combination as a parameter.
+
+// Use class definitions to test from this header.
+#include "prime_tables.h"
+
+#include "gtest/gtest.h"
+
+#if GTEST_HAS_COMBINE
+
+// Suppose we want to introduce a new, improved implementation of PrimeTable
+// which combines speed of PrecalcPrimeTable and versatility of
+// OnTheFlyPrimeTable (see prime_tables.h). Inside it instantiates both
+// PrecalcPrimeTable and OnTheFlyPrimeTable and uses the one that is more
+// appropriate under the circumstances. But in low memory conditions, it can be
+// told to instantiate without PrecalcPrimeTable instance at all and use only
+// OnTheFlyPrimeTable.
+class HybridPrimeTable : public PrimeTable {
+ public:
+  HybridPrimeTable(bool force_on_the_fly, int max_precalculated)
+      : on_the_fly_impl_(new OnTheFlyPrimeTable),
+        precalc_impl_(force_on_the_fly ? NULL :
+                          new PreCalculatedPrimeTable(max_precalculated)),
+        max_precalculated_(max_precalculated) {}
+  virtual ~HybridPrimeTable() {
+    delete on_the_fly_impl_;
+    delete precalc_impl_;
+  }
+
+  virtual bool IsPrime(int n) const {
+    if (precalc_impl_ != NULL && n < max_precalculated_)
+      return precalc_impl_->IsPrime(n);
+    else
+      return on_the_fly_impl_->IsPrime(n);
+  }
+
+  virtual int GetNextPrime(int p) const {
+    int next_prime = -1;
+    if (precalc_impl_ != NULL && p < max_precalculated_)
+      next_prime = precalc_impl_->GetNextPrime(p);
+
+    return next_prime != -1 ? next_prime : on_the_fly_impl_->GetNextPrime(p);
+  }
+
+ private:
+  OnTheFlyPrimeTable* on_the_fly_impl_;
+  PreCalculatedPrimeTable* precalc_impl_;
+  int max_precalculated_;
+};
+
+using ::testing::TestWithParam;
+using ::testing::Bool;
+using ::testing::Values;
+using ::testing::Combine;
+
+// To test all code paths for HybridPrimeTable we must test it with numbers
+// both within and outside PreCalculatedPrimeTable's capacity and also with
+// PreCalculatedPrimeTable disabled. We do this by defining fixture which will
+// accept different combinations of parameters for instantiating a
+// HybridPrimeTable instance.
+class PrimeTableTest : public TestWithParam< ::testing::tuple<bool, int> > {
+ protected:
+  virtual void SetUp() {
+    // This can be written as
+    //
+    // bool force_on_the_fly;
+    // int max_precalculated;
+    // tie(force_on_the_fly, max_precalculated) = GetParam();
+    //
+    // once the Google C++ Style Guide allows use of ::std::tr1::tie.
+    //
+    bool force_on_the_fly = ::testing::get<0>(GetParam());
+    int max_precalculated = ::testing::get<1>(GetParam());
+    table_ = new HybridPrimeTable(force_on_the_fly, max_precalculated);
+  }
+  virtual void TearDown() {
+    delete table_;
+    table_ = NULL;
+  }
+  HybridPrimeTable* table_;
+};
+
+TEST_P(PrimeTableTest, ReturnsFalseForNonPrimes) {
+  // Inside the test body, you can refer to the test parameter by GetParam().
+  // In this case, the test parameter is a PrimeTable interface pointer which
+  // we can use directly.
+  // Please note that you can also save it in the fixture's SetUp() method
+  // or constructor and use saved copy in the tests.
+
+  EXPECT_FALSE(table_->IsPrime(-5));
+  EXPECT_FALSE(table_->IsPrime(0));
+  EXPECT_FALSE(table_->IsPrime(1));
+  EXPECT_FALSE(table_->IsPrime(4));
+  EXPECT_FALSE(table_->IsPrime(6));
+  EXPECT_FALSE(table_->IsPrime(100));
+}
+
+TEST_P(PrimeTableTest, ReturnsTrueForPrimes) {
+  EXPECT_TRUE(table_->IsPrime(2));
+  EXPECT_TRUE(table_->IsPrime(3));
+  EXPECT_TRUE(table_->IsPrime(5));
+  EXPECT_TRUE(table_->IsPrime(7));
+  EXPECT_TRUE(table_->IsPrime(11));
+  EXPECT_TRUE(table_->IsPrime(131));
+}
+
+TEST_P(PrimeTableTest, CanGetNextPrime) {
+  EXPECT_EQ(2, table_->GetNextPrime(0));
+  EXPECT_EQ(3, table_->GetNextPrime(2));
+  EXPECT_EQ(5, table_->GetNextPrime(3));
+  EXPECT_EQ(7, table_->GetNextPrime(5));
+  EXPECT_EQ(11, table_->GetNextPrime(7));
+  EXPECT_EQ(131, table_->GetNextPrime(128));
+}
+
+// In order to run value-parameterized tests, you need to instantiate them,
+// or bind them to a list of values which will be used as test parameters.
+// You can instantiate them in a different translation module, or even
+// instantiate them several times.
+//
+// Here, we instantiate our tests with a list of parameters. We must combine
+// all variations of the boolean flag suppressing PrecalcPrimeTable and some
+// meaningful values for tests. We choose a small value (1), and a value that
+// will put some of the tested numbers beyond the capability of the
+// PrecalcPrimeTable instance and some inside it (10). Combine will produce all
+// possible combinations.
+INSTANTIATE_TEST_CASE_P(MeaningfulTestParameters,
+                        PrimeTableTest,
+                        Combine(Bool(), Values(1, 10)));
+
+#else
+
+// Google Test may not support Combine() with some compilers. If we
+// use conditional compilation to compile out all code referring to
+// the gtest_main library, MSVC linker will not link that library at
+// all and consequently complain about missing entry point defined in
+// that library (fatal error LNK1561: entry point must be
+// defined). This dummy test keeps gtest_main linked in.
+TEST(DummyTest, CombineIsNotSupportedOnThisPlatform) {}
+
+#endif  // GTEST_HAS_COMBINE
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample9_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample9_unittest.cc
new file mode 100644
index 00000000..b2e2079b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample9_unittest.cc
@@ -0,0 +1,160 @@
+// Copyright 2009 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+
+// This sample shows how to use Google Test listener API to implement
+// an alternative console output and how to use the UnitTest reflection API
+// to enumerate test cases and tests and to inspect their results.
+
+#include <stdio.h>
+
+#include "gtest/gtest.h"
+
+using ::testing::EmptyTestEventListener;
+using ::testing::InitGoogleTest;
+using ::testing::Test;
+using ::testing::TestCase;
+using ::testing::TestEventListeners;
+using ::testing::TestInfo;
+using ::testing::TestPartResult;
+using ::testing::UnitTest;
+
+namespace {
+
+// Provides alternative output mode which produces minimal amount of
+// information about tests.
+class TersePrinter : public EmptyTestEventListener {
+ private:
+  // Called before any test activity starts.
+  virtual void OnTestProgramStart(const UnitTest& /* unit_test */) {}
+
+  // Called after all test activities have ended.
+  virtual void OnTestProgramEnd(const UnitTest& unit_test) {
+    fprintf(stdout, "TEST %s\n", unit_test.Passed() ? "PASSED" : "FAILED");
+    fflush(stdout);
+  }
+
+  // Called before a test starts.
+  virtual void OnTestStart(const TestInfo& test_info) {
+    fprintf(stdout,
+            "*** Test %s.%s starting.\n",
+            test_info.test_case_name(),
+            test_info.name());
+    fflush(stdout);
+  }
+
+  // Called after a failed assertion or a SUCCEED() invocation.
+  virtual void OnTestPartResult(const TestPartResult& test_part_result) {
+    fprintf(stdout,
+            "%s in %s:%d\n%s\n",
+            test_part_result.failed() ? "*** Failure" : "Success",
+            test_part_result.file_name(),
+            test_part_result.line_number(),
+            test_part_result.summary());
+    fflush(stdout);
+  }
+
+  // Called after a test ends.
+  virtual void OnTestEnd(const TestInfo& test_info) {
+    fprintf(stdout,
+            "*** Test %s.%s ending.\n",
+            test_info.test_case_name(),
+            test_info.name());
+    fflush(stdout);
+  }
+};  // class TersePrinter
+
+TEST(CustomOutputTest, PrintsMessage) {
+  printf("Printing something from the test body...\n");
+}
+
+TEST(CustomOutputTest, Succeeds) {
+  SUCCEED() << "SUCCEED() has been invoked from here";
+}
+
+TEST(CustomOutputTest, Fails) {
+  EXPECT_EQ(1, 2)
+      << "This test fails in order to demonstrate alternative failure messages";
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  InitGoogleTest(&argc, argv);
+
+  bool terse_output = false;
+  if (argc > 1 && strcmp(argv[1], "--terse_output") == 0 )
+    terse_output = true;
+  else
+    printf("%s\n", "Run this program with --terse_output to change the way "
+           "it prints its output.");
+
+  UnitTest& unit_test = *UnitTest::GetInstance();
+
+  // If we are given the --terse_output command line flag, suppresses the
+  // standard output and attaches own result printer.
+  if (terse_output) {
+    TestEventListeners& listeners = unit_test.listeners();
+
+    // Removes the default console output listener from the list so it will
+    // not receive events from Google Test and won't print any output. Since
+    // this operation transfers ownership of the listener to the caller we
+    // have to delete it as well.
+    delete listeners.Release(listeners.default_result_printer());
+
+    // Adds the custom output listener to the list. It will now receive
+    // events from Google Test and print the alternative output. We don't
+    // have to worry about deleting it since Google Test assumes ownership
+    // over it after adding it to the list.
+    listeners.Append(new TersePrinter);
+  }
+  int ret_val = RUN_ALL_TESTS();
+
+  // This is an example of using the UnitTest reflection API to inspect test
+  // results. Here we discount failures from the tests we expected to fail.
+  int unexpectedly_failed_tests = 0;
+  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
+    const TestCase& test_case = *unit_test.GetTestCase(i);
+    for (int j = 0; j < test_case.total_test_count(); ++j) {
+      const TestInfo& test_info = *test_case.GetTestInfo(j);
+      // Counts failed tests that were not meant to fail (those without
+      // 'Fails' in the name).
+      if (test_info.result()->Failed() &&
+          strcmp(test_info.name(), "Fails") != 0) {
+        unexpectedly_failed_tests++;
+      }
+    }
+  }
+
+  // Test that were meant to fail should not affect the test program outcome.
+  if (unexpectedly_failed_tests == 0)
+    ret_val = 0;
+
+  return ret_val;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/common.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/common.py
new file mode 100644
index 00000000..3c0347a7
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/common.py
@@ -0,0 +1,83 @@
+# Copyright 2013 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.
+
+"""Shared utilities for writing scripts for Google Test/Mock."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+
+import os
+import re
+
+
+# Matches the line from 'svn info .' output that describes what SVN
+# path the current local directory corresponds to.  For example, in
+# a googletest SVN workspace's trunk/test directory, the output will be:
+#
+# URL: https://googletest.googlecode.com/svn/trunk/test
+_SVN_INFO_URL_RE = re.compile(r'^URL: https://(\w+)\.googlecode\.com/svn(.*)')
+
+
+def GetCommandOutput(command):
+  """Runs the shell command and returns its stdout as a list of lines."""
+
+  f = os.popen(command, 'r')
+  lines = [line.strip() for line in f.readlines()]
+  f.close()
+  return lines
+
+
+def GetSvnInfo():
+  """Returns the project name and the current SVN workspace's root path."""
+
+  for line in GetCommandOutput('svn info .'):
+    m = _SVN_INFO_URL_RE.match(line)
+    if m:
+      project = m.group(1)  # googletest or googlemock
+      rel_path = m.group(2)
+      root = os.path.realpath(rel_path.count('/') * '../')
+      return project, root
+
+  return None, None
+
+
+def GetSvnTrunk():
+  """Returns the current SVN workspace's trunk root path."""
+
+  _, root = GetSvnInfo()
+  return root + '/trunk' if root else None
+
+
+def IsInGTestSvn():
+  project, _ = GetSvnInfo()
+  return project == 'googletest'
+
+
+def IsInGMockSvn():
+  project, _ = GetSvnInfo()
+  return project == 'googlemock'
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/fuse_gtest_files.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/fuse_gtest_files.py
new file mode 100755
index 00000000..3f3e9f36
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/fuse_gtest_files.py
@@ -0,0 +1,253 @@
+#!/usr/bin/env python
+#
+# Copyright 2009, 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.
+
+"""fuse_gtest_files.py v0.2.0
+Fuses Google Test source code into a .h file and a .cc file.
+
+SYNOPSIS
+       fuse_gtest_files.py [GTEST_ROOT_DIR] OUTPUT_DIR
+
+       Scans GTEST_ROOT_DIR for Google Test source code, and generates
+       two files: OUTPUT_DIR/gtest/gtest.h and OUTPUT_DIR/gtest/gtest-all.cc.
+       Then you can build your tests by adding OUTPUT_DIR to the include
+       search path and linking with OUTPUT_DIR/gtest/gtest-all.cc.  These
+       two files contain everything you need to use Google Test.  Hence
+       you can "install" Google Test by copying them to wherever you want.
+
+       GTEST_ROOT_DIR can be omitted and defaults to the parent
+       directory of the directory holding this script.
+
+EXAMPLES
+       ./fuse_gtest_files.py fused_gtest
+       ./fuse_gtest_files.py path/to/unpacked/gtest fused_gtest
+
+This tool is experimental.  In particular, it assumes that there is no
+conditional inclusion of Google Test headers.  Please report any
+problems to googletestframework@googlegroups.com.  You can read
+http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide for
+more information.
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import re
+try:
+  from sets import Set as set  # For Python 2.3 compatibility
+except ImportError:
+  pass
+import sys
+
+# We assume that this file is in the scripts/ directory in the Google
+# Test root directory.
+DEFAULT_GTEST_ROOT_DIR = os.path.join(os.path.dirname(__file__), '..')
+
+# Regex for matching '#include "gtest/..."'.
+INCLUDE_GTEST_FILE_REGEX = re.compile(r'^\s*#\s*include\s*"(gtest/.+)"')
+
+# Regex for matching '#include "src/..."'.
+INCLUDE_SRC_FILE_REGEX = re.compile(r'^\s*#\s*include\s*"(src/.+)"')
+
+# Where to find the source seed files.
+GTEST_H_SEED = 'include/gtest/gtest.h'
+GTEST_SPI_H_SEED = 'include/gtest/gtest-spi.h'
+GTEST_ALL_CC_SEED = 'src/gtest-all.cc'
+
+# Where to put the generated files.
+GTEST_H_OUTPUT = 'gtest/gtest.h'
+GTEST_ALL_CC_OUTPUT = 'gtest/gtest-all.cc'
+
+
+def VerifyFileExists(directory, relative_path):
+  """Verifies that the given file exists; aborts on failure.
+
+  relative_path is the file path relative to the given directory.
+  """
+
+  if not os.path.isfile(os.path.join(directory, relative_path)):
+    print('ERROR: Cannot find %s in directory %s.' % (relative_path,
+                                                      directory))
+    print('Please either specify a valid project root directory '
+          'or omit it on the command line.')
+    sys.exit(1)
+
+
+def ValidateGTestRootDir(gtest_root):
+  """Makes sure gtest_root points to a valid gtest root directory.
+
+  The function aborts the program on failure.
+  """
+
+  VerifyFileExists(gtest_root, GTEST_H_SEED)
+  VerifyFileExists(gtest_root, GTEST_ALL_CC_SEED)
+
+
+def VerifyOutputFile(output_dir, relative_path):
+  """Verifies that the given output file path is valid.
+
+  relative_path is relative to the output_dir directory.
+  """
+
+  # Makes sure the output file either doesn't exist or can be overwritten.
+  output_file = os.path.join(output_dir, relative_path)
+  if os.path.exists(output_file):
+    # TODO(wan@google.com): The following user-interaction doesn't
+    # work with automated processes.  We should provide a way for the
+    # Makefile to force overwriting the files.
+    print('%s already exists in directory %s - overwrite it? (y/N) ' %
+          (relative_path, output_dir))
+    answer = sys.stdin.readline().strip()
+    if answer not in ['y', 'Y']:
+      print('ABORTED.')
+      sys.exit(1)
+
+  # Makes sure the directory holding the output file exists; creates
+  # it and all its ancestors if necessary.
+  parent_directory = os.path.dirname(output_file)
+  if not os.path.isdir(parent_directory):
+    os.makedirs(parent_directory)
+
+
+def ValidateOutputDir(output_dir):
+  """Makes sure output_dir points to a valid output directory.
+
+  The function aborts the program on failure.
+  """
+
+  VerifyOutputFile(output_dir, GTEST_H_OUTPUT)
+  VerifyOutputFile(output_dir, GTEST_ALL_CC_OUTPUT)
+
+
+def FuseGTestH(gtest_root, output_dir):
+  """Scans folder gtest_root to generate gtest/gtest.h in output_dir."""
+
+  output_file = open(os.path.join(output_dir, GTEST_H_OUTPUT), 'w')
+  processed_files = set()  # Holds all gtest headers we've processed.
+
+  def ProcessFile(gtest_header_path):
+    """Processes the given gtest header file."""
+
+    # We don't process the same header twice.
+    if gtest_header_path in processed_files:
+      return
+
+    processed_files.add(gtest_header_path)
+
+    # Reads each line in the given gtest header.
+    for line in open(os.path.join(gtest_root, gtest_header_path), 'r'):
+      m = INCLUDE_GTEST_FILE_REGEX.match(line)
+      if m:
+        # It's '#include "gtest/..."' - let's process it recursively.
+        ProcessFile('include/' + m.group(1))
+      else:
+        # Otherwise we copy the line unchanged to the output file.
+        output_file.write(line)
+
+  ProcessFile(GTEST_H_SEED)
+  output_file.close()
+
+
+def FuseGTestAllCcToFile(gtest_root, output_file):
+  """Scans folder gtest_root to generate gtest/gtest-all.cc in output_file."""
+
+  processed_files = set()
+
+  def ProcessFile(gtest_source_file):
+    """Processes the given gtest source file."""
+
+    # We don't process the same #included file twice.
+    if gtest_source_file in processed_files:
+      return
+
+    processed_files.add(gtest_source_file)
+
+    # Reads each line in the given gtest source file.
+    for line in open(os.path.join(gtest_root, gtest_source_file), 'r'):
+      m = INCLUDE_GTEST_FILE_REGEX.match(line)
+      if m:
+        if 'include/' + m.group(1) == GTEST_SPI_H_SEED:
+          # It's '#include "gtest/gtest-spi.h"'.  This file is not
+          # #included by "gtest/gtest.h", so we need to process it.
+          ProcessFile(GTEST_SPI_H_SEED)
+        else:
+          # It's '#include "gtest/foo.h"' where foo is not gtest-spi.
+          # We treat it as '#include "gtest/gtest.h"', as all other
+          # gtest headers are being fused into gtest.h and cannot be
+          # #included directly.
+
+          # There is no need to #include "gtest/gtest.h" more than once.
+          if not GTEST_H_SEED in processed_files:
+            processed_files.add(GTEST_H_SEED)
+            output_file.write('#include "%s"\n' % (GTEST_H_OUTPUT,))
+      else:
+        m = INCLUDE_SRC_FILE_REGEX.match(line)
+        if m:
+          # It's '#include "src/foo"' - let's process it recursively.
+          ProcessFile(m.group(1))
+        else:
+          output_file.write(line)
+
+  ProcessFile(GTEST_ALL_CC_SEED)
+
+
+def FuseGTestAllCc(gtest_root, output_dir):
+  """Scans folder gtest_root to generate gtest/gtest-all.cc in output_dir."""
+
+  output_file = open(os.path.join(output_dir, GTEST_ALL_CC_OUTPUT), 'w')
+  FuseGTestAllCcToFile(gtest_root, output_file)
+  output_file.close()
+
+
+def FuseGTest(gtest_root, output_dir):
+  """Fuses gtest.h and gtest-all.cc."""
+
+  ValidateGTestRootDir(gtest_root)
+  ValidateOutputDir(output_dir)
+
+  FuseGTestH(gtest_root, output_dir)
+  FuseGTestAllCc(gtest_root, output_dir)
+
+
+def main():
+  argc = len(sys.argv)
+  if argc == 2:
+    # fuse_gtest_files.py OUTPUT_DIR
+    FuseGTest(DEFAULT_GTEST_ROOT_DIR, sys.argv[1])
+  elif argc == 3:
+    # fuse_gtest_files.py GTEST_ROOT_DIR OUTPUT_DIR
+    FuseGTest(sys.argv[1], sys.argv[2])
+  else:
+    print(__doc__)
+    sys.exit(1)
+
+
+if __name__ == '__main__':
+  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gen_gtest_pred_impl.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gen_gtest_pred_impl.py
new file mode 100755
index 00000000..3e7ab042
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gen_gtest_pred_impl.py
@@ -0,0 +1,730 @@
+#!/usr/bin/env python
+#
+# Copyright 2006, 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.
+
+"""gen_gtest_pred_impl.py v0.1
+
+Generates the implementation of Google Test predicate assertions and
+accompanying tests.
+
+Usage:
+
+  gen_gtest_pred_impl.py MAX_ARITY
+
+where MAX_ARITY is a positive integer.
+
+The command generates the implementation of up-to MAX_ARITY-ary
+predicate assertions, and writes it to file gtest_pred_impl.h in the
+directory where the script is.  It also generates the accompanying
+unit test in file gtest_pred_impl_unittest.cc.
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import sys
+import time
+
+# Where this script is.
+SCRIPT_DIR = os.path.dirname(sys.argv[0])
+
+# Where to store the generated header.
+HEADER = os.path.join(SCRIPT_DIR, '../include/gtest/gtest_pred_impl.h')
+
+# Where to store the generated unit test.
+UNIT_TEST = os.path.join(SCRIPT_DIR, '../test/gtest_pred_impl_unittest.cc')
+
+
+def HeaderPreamble(n):
+  """Returns the preamble for the header file.
+
+  Args:
+    n:  the maximum arity of the predicate macros to be generated.
+  """
+
+  # A map that defines the values used in the preamble template.
+  DEFS = {
+    'today' : time.strftime('%m/%d/%Y'),
+    'year' : time.strftime('%Y'),
+    'command' : '%s %s' % (os.path.basename(sys.argv[0]), n),
+    'n' : n
+    }
+
+  return (
+"""// Copyright 2006, 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.
+
+// This file is AUTOMATICALLY GENERATED on %(today)s by command
+// '%(command)s'.  DO NOT EDIT BY HAND!
+//
+// Implements a family of generic predicate assertion macros.
+
+#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+
+// Makes sure this header is not included before gtest.h.
+#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
+# error Do not include gtest_pred_impl.h directly.  Include gtest.h instead.
+#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
+
+// This header implements a family of generic predicate assertion
+// macros:
+//
+//   ASSERT_PRED_FORMAT1(pred_format, v1)
+//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
+//   ...
+//
+// where pred_format is a function or functor that takes n (in the
+// case of ASSERT_PRED_FORMATn) values and their source expression
+// text, and returns a testing::AssertionResult.  See the definition
+// of ASSERT_EQ in gtest.h for an example.
+//
+// If you don't care about formatting, you can use the more
+// restrictive version:
+//
+//   ASSERT_PRED1(pred, v1)
+//   ASSERT_PRED2(pred, v1, v2)
+//   ...
+//
+// where pred is an n-ary function or functor that returns bool,
+// and the values v1, v2, ..., must support the << operator for
+// streaming to std::ostream.
+//
+// We also define the EXPECT_* variations.
+//
+// For now we only support predicates whose arity is at most %(n)s.
+// Please email googletestframework@googlegroups.com if you need
+// support for higher arities.
+
+// GTEST_ASSERT_ is the basic statement to which all of the assertions
+// in this file reduce.  Don't use this in your code.
+
+#define GTEST_ASSERT_(expression, on_failure) \\
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \\
+  if (const ::testing::AssertionResult gtest_ar = (expression)) \\
+    ; \\
+  else \\
+    on_failure(gtest_ar.failure_message())
+""" % DEFS)
+
+
+def Arity(n):
+  """Returns the English name of the given arity."""
+
+  if n < 0:
+    return None
+  elif n <= 3:
+    return ['nullary', 'unary', 'binary', 'ternary'][n]
+  else:
+    return '%s-ary' % n
+
+
+def Title(word):
+  """Returns the given word in title case.  The difference between
+  this and string's title() method is that Title('4-ary') is '4-ary'
+  while '4-ary'.title() is '4-Ary'."""
+
+  return word[0].upper() + word[1:]
+
+
+def OneTo(n):
+  """Returns the list [1, 2, 3, ..., n]."""
+
+  return range(1, n + 1)
+
+
+def Iter(n, format, sep=''):
+  """Given a positive integer n, a format string that contains 0 or
+  more '%s' format specs, and optionally a separator string, returns
+  the join of n strings, each formatted with the format string on an
+  iterator ranged from 1 to n.
+
+  Example:
+
+  Iter(3, 'v%s', sep=', ') returns 'v1, v2, v3'.
+  """
+
+  # How many '%s' specs are in format?
+  spec_count = len(format.split('%s')) - 1
+  return sep.join([format % (spec_count * (i,)) for i in OneTo(n)])
+
+
+def ImplementationForArity(n):
+  """Returns the implementation of n-ary predicate assertions."""
+
+  # A map the defines the values used in the implementation template.
+  DEFS = {
+    'n' : str(n),
+    'vs' : Iter(n, 'v%s', sep=', '),
+    'vts' : Iter(n, '#v%s', sep=', '),
+    'arity' : Arity(n),
+    'Arity' : Title(Arity(n))
+    }
+
+  impl = """
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED%(n)s.  Don't use
+// this in your code.
+template <typename Pred""" % DEFS
+
+  impl += Iter(n, """,
+          typename T%s""")
+
+  impl += """>
+AssertionResult AssertPred%(n)sHelper(const char* pred_text""" % DEFS
+
+  impl += Iter(n, """,
+                                  const char* e%s""")
+
+  impl += """,
+                                  Pred pred"""
+
+  impl += Iter(n, """,
+                                  const T%s& v%s""")
+
+  impl += """) {
+  if (pred(%(vs)s)) return AssertionSuccess();
+
+""" % DEFS
+
+  impl += '  return AssertionFailure() << pred_text << "("'
+
+  impl += Iter(n, """
+                            << e%s""", sep=' << ", "')
+
+  impl += ' << ") evaluates to false, where"'
+
+  impl += Iter(n, """
+                            << "\\n" << e%s << " evaluates to " << v%s""")
+
+  impl += """;
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT%(n)s.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT%(n)s_(pred_format, %(vs)s, on_failure)\\
+  GTEST_ASSERT_(pred_format(%(vts)s, %(vs)s), \\
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED%(n)s.  Don't use
+// this in your code.
+#define GTEST_PRED%(n)s_(pred, %(vs)s, on_failure)\\
+  GTEST_ASSERT_(::testing::AssertPred%(n)sHelper(#pred""" % DEFS
+
+  impl += Iter(n, """, \\
+                                             #v%s""")
+
+  impl += """, \\
+                                             pred"""
+
+  impl += Iter(n, """, \\
+                                             v%s""")
+
+  impl += """), on_failure)
+
+// %(Arity)s predicate assertion macros.
+#define EXPECT_PRED_FORMAT%(n)s(pred_format, %(vs)s) \\
+  GTEST_PRED_FORMAT%(n)s_(pred_format, %(vs)s, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED%(n)s(pred, %(vs)s) \\
+  GTEST_PRED%(n)s_(pred, %(vs)s, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT%(n)s(pred_format, %(vs)s) \\
+  GTEST_PRED_FORMAT%(n)s_(pred_format, %(vs)s, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED%(n)s(pred, %(vs)s) \\
+  GTEST_PRED%(n)s_(pred, %(vs)s, GTEST_FATAL_FAILURE_)
+
+""" % DEFS
+
+  return impl
+
+
+def HeaderPostamble():
+  """Returns the postamble for the header file."""
+
+  return """
+
+#endif  // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+"""
+
+
+def GenerateFile(path, content):
+  """Given a file path and a content string, overwrites it with the
+  given content."""
+
+  print 'Updating file %s . . .' % path
+
+  f = file(path, 'w+')
+  print >>f, content,
+  f.close()
+
+  print 'File %s has been updated.' % path
+
+
+def GenerateHeader(n):
+  """Given the maximum arity n, updates the header file that implements
+  the predicate assertions."""
+
+  GenerateFile(HEADER,
+               HeaderPreamble(n)
+               + ''.join([ImplementationForArity(i) for i in OneTo(n)])
+               + HeaderPostamble())
+
+
+def UnitTestPreamble():
+  """Returns the preamble for the unit test file."""
+
+  # A map that defines the values used in the preamble template.
+  DEFS = {
+    'today' : time.strftime('%m/%d/%Y'),
+    'year' : time.strftime('%Y'),
+    'command' : '%s %s' % (os.path.basename(sys.argv[0]), sys.argv[1]),
+    }
+
+  return (
+"""// Copyright 2006, 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.
+
+// This file is AUTOMATICALLY GENERATED on %(today)s by command
+// '%(command)s'.  DO NOT EDIT BY HAND!
+
+// Regression test for gtest_pred_impl.h
+//
+// This file is generated by a script and quite long.  If you intend to
+// learn how Google Test works by reading its unit tests, read
+// gtest_unittest.cc instead.
+//
+// This is intended as a regression test for the Google Test predicate
+// assertions.  We compile it as part of the gtest_unittest target
+// only to keep the implementation tidy and compact, as it is quite
+// involved to set up the stage for testing Google Test using Google
+// Test itself.
+//
+// Currently, gtest_unittest takes ~11 seconds to run in the testing
+// daemon.  In the future, if it grows too large and needs much more
+// time to finish, we should consider separating this file into a
+// stand-alone regression test.
+
+#include <iostream>
+
+#include "gtest/gtest.h"
+#include "gtest/gtest-spi.h"
+
+// A user-defined data type.
+struct Bool {
+  explicit Bool(int val) : value(val != 0) {}
+
+  bool operator>(int n) const { return value > Bool(n).value; }
+
+  Bool operator+(const Bool& rhs) const { return Bool(value + rhs.value); }
+
+  bool operator==(const Bool& rhs) const { return value == rhs.value; }
+
+  bool value;
+};
+
+// Enables Bool to be used in assertions.
+std::ostream& operator<<(std::ostream& os, const Bool& x) {
+  return os << (x.value ? "true" : "false");
+}
+
+""" % DEFS)
+
+
+def TestsForArity(n):
+  """Returns the tests for n-ary predicate assertions."""
+
+  # A map that defines the values used in the template for the tests.
+  DEFS = {
+    'n' : n,
+    'es' : Iter(n, 'e%s', sep=', '),
+    'vs' : Iter(n, 'v%s', sep=', '),
+    'vts' : Iter(n, '#v%s', sep=', '),
+    'tvs' : Iter(n, 'T%s v%s', sep=', '),
+    'int_vs' : Iter(n, 'int v%s', sep=', '),
+    'Bool_vs' : Iter(n, 'Bool v%s', sep=', '),
+    'types' : Iter(n, 'typename T%s', sep=', '),
+    'v_sum' : Iter(n, 'v%s', sep=' + '),
+    'arity' : Arity(n),
+    'Arity' : Title(Arity(n)),
+    }
+
+  tests = (
+"""// Sample functions/functors for testing %(arity)s predicate assertions.
+
+// A %(arity)s predicate function.
+template <%(types)s>
+bool PredFunction%(n)s(%(tvs)s) {
+  return %(v_sum)s > 0;
+}
+
+// The following two functions are needed to circumvent a bug in
+// gcc 2.95.3, which sometimes has problem with the above template
+// function.
+bool PredFunction%(n)sInt(%(int_vs)s) {
+  return %(v_sum)s > 0;
+}
+bool PredFunction%(n)sBool(%(Bool_vs)s) {
+  return %(v_sum)s > 0;
+}
+""" % DEFS)
+
+  tests += """
+// A %(arity)s predicate functor.
+struct PredFunctor%(n)s {
+  template <%(types)s>
+  bool operator()(""" % DEFS
+
+  tests += Iter(n, 'const T%s& v%s', sep=""",
+                  """)
+
+  tests += """) {
+    return %(v_sum)s > 0;
+  }
+};
+""" % DEFS
+
+  tests += """
+// A %(arity)s predicate-formatter function.
+template <%(types)s>
+testing::AssertionResult PredFormatFunction%(n)s(""" % DEFS
+
+  tests += Iter(n, 'const char* e%s', sep=""",
+                                             """)
+
+  tests += Iter(n, """,
+                                             const T%s& v%s""")
+
+  tests += """) {
+  if (PredFunction%(n)s(%(vs)s))
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure()
+      << """ % DEFS
+
+  tests += Iter(n, 'e%s', sep=' << " + " << ')
+
+  tests += """
+      << " is expected to be positive, but evaluates to "
+      << %(v_sum)s << ".";
+}
+""" % DEFS
+
+  tests += """
+// A %(arity)s predicate-formatter functor.
+struct PredFormatFunctor%(n)s {
+  template <%(types)s>
+  testing::AssertionResult operator()(""" % DEFS
+
+  tests += Iter(n, 'const char* e%s', sep=""",
+                                      """)
+
+  tests += Iter(n, """,
+                                      const T%s& v%s""")
+
+  tests += """) const {
+    return PredFormatFunction%(n)s(%(es)s, %(vs)s);
+  }
+};
+""" % DEFS
+
+  tests += """
+// Tests for {EXPECT|ASSERT}_PRED_FORMAT%(n)s.
+
+class Predicate%(n)sTest : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    expected_to_finish_ = true;
+    finished_ = false;""" % DEFS
+
+  tests += """
+    """ + Iter(n, 'n%s_ = ') + """0;
+  }
+"""
+
+  tests += """
+  virtual void TearDown() {
+    // Verifies that each of the predicate's arguments was evaluated
+    // exactly once."""
+
+  tests += ''.join(["""
+    EXPECT_EQ(1, n%s_) <<
+        "The predicate assertion didn't evaluate argument %s "
+        "exactly once.";""" % (i, i + 1) for i in OneTo(n)])
+
+  tests += """
+
+    // Verifies that the control flow in the test function is expected.
+    if (expected_to_finish_ && !finished_) {
+      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+    } else if (!expected_to_finish_ && finished_) {
+      FAIL() << "The failed predicate assertion didn't abort the test "
+                "as expected.";
+    }
+  }
+
+  // true iff the test function is expected to run to finish.
+  static bool expected_to_finish_;
+
+  // true iff the test function did run to finish.
+  static bool finished_;
+""" % DEFS
+
+  tests += Iter(n, """
+  static int n%s_;""")
+
+  tests += """
+};
+
+bool Predicate%(n)sTest::expected_to_finish_;
+bool Predicate%(n)sTest::finished_;
+""" % DEFS
+
+  tests += Iter(n, """int Predicate%%(n)sTest::n%s_;
+""") % DEFS
+
+  tests += """
+typedef Predicate%(n)sTest EXPECT_PRED_FORMAT%(n)sTest;
+typedef Predicate%(n)sTest ASSERT_PRED_FORMAT%(n)sTest;
+typedef Predicate%(n)sTest EXPECT_PRED%(n)sTest;
+typedef Predicate%(n)sTest ASSERT_PRED%(n)sTest;
+""" % DEFS
+
+  def GenTest(use_format, use_assert, expect_failure,
+              use_functor, use_user_type):
+    """Returns the test for a predicate assertion macro.
+
+    Args:
+      use_format:     true iff the assertion is a *_PRED_FORMAT*.
+      use_assert:     true iff the assertion is a ASSERT_*.
+      expect_failure: true iff the assertion is expected to fail.
+      use_functor:    true iff the first argument of the assertion is
+                      a functor (as opposed to a function)
+      use_user_type:  true iff the predicate functor/function takes
+                      argument(s) of a user-defined type.
+
+    Example:
+
+      GenTest(1, 0, 0, 1, 0) returns a test that tests the behavior
+      of a successful EXPECT_PRED_FORMATn() that takes a functor
+      whose arguments have built-in types."""
+
+    if use_assert:
+      assrt = 'ASSERT'  # 'assert' is reserved, so we cannot use
+                        # that identifier here.
+    else:
+      assrt = 'EXPECT'
+
+    assertion = assrt + '_PRED'
+
+    if use_format:
+      pred_format = 'PredFormat'
+      assertion += '_FORMAT'
+    else:
+      pred_format = 'Pred'
+
+    assertion += '%(n)s' % DEFS
+
+    if use_functor:
+      pred_format_type = 'functor'
+      pred_format += 'Functor%(n)s()'
+    else:
+      pred_format_type = 'function'
+      pred_format += 'Function%(n)s'
+      if not use_format:
+        if use_user_type:
+          pred_format += 'Bool'
+        else:
+          pred_format += 'Int'
+
+    test_name = pred_format_type.title()
+
+    if use_user_type:
+      arg_type = 'user-defined type (Bool)'
+      test_name += 'OnUserType'
+      if expect_failure:
+        arg = 'Bool(n%s_++)'
+      else:
+        arg = 'Bool(++n%s_)'
+    else:
+      arg_type = 'built-in type (int)'
+      test_name += 'OnBuiltInType'
+      if expect_failure:
+        arg = 'n%s_++'
+      else:
+        arg = '++n%s_'
+
+    if expect_failure:
+      successful_or_failed = 'failed'
+      expected_or_not = 'expected.'
+      test_name +=  'Failure'
+    else:
+      successful_or_failed = 'successful'
+      expected_or_not = 'UNEXPECTED!'
+      test_name +=  'Success'
+
+    # A map that defines the values used in the test template.
+    defs = DEFS.copy()
+    defs.update({
+      'assert' : assrt,
+      'assertion' : assertion,
+      'test_name' : test_name,
+      'pf_type' : pred_format_type,
+      'pf' : pred_format,
+      'arg_type' : arg_type,
+      'arg' : arg,
+      'successful' : successful_or_failed,
+      'expected' : expected_or_not,
+      })
+
+    test = """
+// Tests a %(successful)s %(assertion)s where the
+// predicate-formatter is a %(pf_type)s on a %(arg_type)s.
+TEST_F(%(assertion)sTest, %(test_name)s) {""" % defs
+
+    indent = (len(assertion) + 3)*' '
+    extra_indent = ''
+
+    if expect_failure:
+      extra_indent = '  '
+      if use_assert:
+        test += """
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT"""
+      else:
+        test += """
+  EXPECT_NONFATAL_FAILURE({  // NOLINT"""
+
+    test += '\n' + extra_indent + """  %(assertion)s(%(pf)s""" % defs
+
+    test = test % defs
+    test += Iter(n, ',\n' + indent + extra_indent + '%(arg)s' % defs)
+    test += ');\n' + extra_indent + '  finished_ = true;\n'
+
+    if expect_failure:
+      test += '  }, "");\n'
+
+    test += '}\n'
+    return test
+
+  # Generates tests for all 2**6 = 64 combinations.
+  tests += ''.join([GenTest(use_format, use_assert, expect_failure,
+                            use_functor, use_user_type)
+                    for use_format in [0, 1]
+                    for use_assert in [0, 1]
+                    for expect_failure in [0, 1]
+                    for use_functor in [0, 1]
+                    for use_user_type in [0, 1]
+                    ])
+
+  return tests
+
+
+def UnitTestPostamble():
+  """Returns the postamble for the tests."""
+
+  return ''
+
+
+def GenerateUnitTest(n):
+  """Returns the tests for up-to n-ary predicate assertions."""
+
+  GenerateFile(UNIT_TEST,
+               UnitTestPreamble()
+               + ''.join([TestsForArity(i) for i in OneTo(n)])
+               + UnitTestPostamble())
+
+
+def _Main():
+  """The entry point of the script.  Generates the header file and its
+  unit test."""
+
+  if len(sys.argv) != 2:
+    print __doc__
+    print 'Author: ' + __author__
+    sys.exit(1)
+
+  n = int(sys.argv[1])
+  GenerateHeader(n)
+  GenerateUnitTest(n)
+
+
+if __name__ == '__main__':
+  _Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gtest-config.in b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gtest-config.in
new file mode 100755
index 00000000..780f8432
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gtest-config.in
@@ -0,0 +1,274 @@
+#!/bin/sh
+
+# These variables are automatically filled in by the configure script.
+name="@PACKAGE_TARNAME@"
+version="@PACKAGE_VERSION@"
+
+show_usage()
+{
+  echo "Usage: gtest-config [OPTIONS...]"
+}
+
+show_help()
+{
+  show_usage
+  cat <<\EOF
+
+The `gtest-config' script provides access to the necessary compile and linking
+flags to connect with Google C++ Testing Framework, both in a build prior to
+installation, and on the system proper after installation. The installation
+overrides may be issued in combination with any other queries, but will only
+affect installation queries if called on a built but not installed gtest. The
+installation queries may not be issued with any other types of queries, and
+only one installation query may be made at a time. The version queries and
+compiler flag queries may be combined as desired but not mixed. Different
+version queries are always combined with logical "and" semantics, and only the
+last of any particular query is used while all previous ones ignored. All
+versions must be specified as a sequence of numbers separated by periods.
+Compiler flag queries output the union of the sets of flags when combined.
+
+ Examples:
+  gtest-config --min-version=1.0 || echo "Insufficient Google Test version."
+
+  g++ $(gtest-config --cppflags --cxxflags) -o foo.o -c foo.cpp
+  g++ $(gtest-config --ldflags --libs) -o foo foo.o
+
+  # When using a built but not installed Google Test:
+  g++ $(../../my_gtest_build/scripts/gtest-config ...) ...
+
+  # When using an installed Google Test, but with installation overrides:
+  export GTEST_PREFIX="/opt"
+  g++ $(gtest-config --libdir="/opt/lib64" ...) ...
+
+ Help:
+  --usage                    brief usage information
+  --help                     display this help message
+
+ Installation Overrides:
+  --prefix=<dir>             overrides the installation prefix
+  --exec-prefix=<dir>        overrides the executable installation prefix
+  --libdir=<dir>             overrides the library installation prefix
+  --includedir=<dir>         overrides the header file installation prefix
+
+ Installation Queries:
+  --prefix                   installation prefix
+  --exec-prefix              executable installation prefix
+  --libdir                   library installation directory
+  --includedir               header file installation directory
+  --version                  the version of the Google Test installation
+
+ Version Queries:
+  --min-version=VERSION      return 0 if the version is at least VERSION
+  --exact-version=VERSION    return 0 if the version is exactly VERSION
+  --max-version=VERSION      return 0 if the version is at most VERSION
+
+ Compilation Flag Queries:
+  --cppflags                 compile flags specific to the C-like preprocessors
+  --cxxflags                 compile flags appropriate for C++ programs
+  --ldflags                  linker flags
+  --libs                     libraries for linking
+
+EOF
+}
+
+# This function bounds our version with a min and a max. It uses some clever
+# POSIX-compliant variable expansion to portably do all the work in the shell
+# and avoid any dependency on a particular "sed" or "awk" implementation.
+# Notable is that it will only ever compare the first 3 components of versions.
+# Further components will be cleanly stripped off. All versions must be
+# unadorned, so "v1.0" will *not* work. The minimum version must be in $1, and
+# the max in $2. TODO(chandlerc@google.com): If this ever breaks, we should
+# investigate expanding this via autom4te from AS_VERSION_COMPARE rather than
+# continuing to maintain our own shell version.
+check_versions()
+{
+  major_version=${version%%.*}
+  minor_version="0"
+  point_version="0"
+  if test "${version#*.}" != "${version}"; then
+    minor_version=${version#*.}
+    minor_version=${minor_version%%.*}
+  fi
+  if test "${version#*.*.}" != "${version}"; then
+    point_version=${version#*.*.}
+    point_version=${point_version%%.*}
+  fi
+
+  min_version="$1"
+  min_major_version=${min_version%%.*}
+  min_minor_version="0"
+  min_point_version="0"
+  if test "${min_version#*.}" != "${min_version}"; then
+    min_minor_version=${min_version#*.}
+    min_minor_version=${min_minor_version%%.*}
+  fi
+  if test "${min_version#*.*.}" != "${min_version}"; then
+    min_point_version=${min_version#*.*.}
+    min_point_version=${min_point_version%%.*}
+  fi
+
+  max_version="$2"
+  max_major_version=${max_version%%.*}
+  max_minor_version="0"
+  max_point_version="0"
+  if test "${max_version#*.}" != "${max_version}"; then
+    max_minor_version=${max_version#*.}
+    max_minor_version=${max_minor_version%%.*}
+  fi
+  if test "${max_version#*.*.}" != "${max_version}"; then
+    max_point_version=${max_version#*.*.}
+    max_point_version=${max_point_version%%.*}
+  fi
+
+  test $(($major_version)) -lt $(($min_major_version)) && exit 1
+  if test $(($major_version)) -eq $(($min_major_version)); then
+    test $(($minor_version)) -lt $(($min_minor_version)) && exit 1
+    if test $(($minor_version)) -eq $(($min_minor_version)); then
+      test $(($point_version)) -lt $(($min_point_version)) && exit 1
+    fi
+  fi
+
+  test $(($major_version)) -gt $(($max_major_version)) && exit 1
+  if test $(($major_version)) -eq $(($max_major_version)); then
+    test $(($minor_version)) -gt $(($max_minor_version)) && exit 1
+    if test $(($minor_version)) -eq $(($max_minor_version)); then
+      test $(($point_version)) -gt $(($max_point_version)) && exit 1
+    fi
+  fi
+
+  exit 0
+}
+
+# Show the usage line when no arguments are specified.
+if test $# -eq 0; then
+  show_usage
+  exit 1
+fi
+
+while test $# -gt 0; do
+  case $1 in
+    --usage)          show_usage;         exit 0;;
+    --help)           show_help;          exit 0;;
+
+    # Installation overrides
+    --prefix=*)       GTEST_PREFIX=${1#--prefix=};;
+    --exec-prefix=*)  GTEST_EXEC_PREFIX=${1#--exec-prefix=};;
+    --libdir=*)       GTEST_LIBDIR=${1#--libdir=};;
+    --includedir=*)   GTEST_INCLUDEDIR=${1#--includedir=};;
+
+    # Installation queries
+    --prefix|--exec-prefix|--libdir|--includedir|--version)
+      if test -n "${do_query}"; then
+        show_usage
+        exit 1
+      fi
+      do_query=${1#--}
+      ;;
+
+    # Version checking
+    --min-version=*)
+      do_check_versions=yes
+      min_version=${1#--min-version=}
+      ;;
+    --max-version=*)
+      do_check_versions=yes
+      max_version=${1#--max-version=}
+      ;;
+    --exact-version=*)
+      do_check_versions=yes
+      exact_version=${1#--exact-version=}
+      ;;
+
+    # Compiler flag output
+    --cppflags)       echo_cppflags=yes;;
+    --cxxflags)       echo_cxxflags=yes;;
+    --ldflags)        echo_ldflags=yes;;
+    --libs)           echo_libs=yes;;
+
+    # Everything else is an error
+    *)                show_usage;         exit 1;;
+  esac
+  shift
+done
+
+# These have defaults filled in by the configure script but can also be
+# overridden by environment variables or command line parameters.
+prefix="${GTEST_PREFIX:-@prefix@}"
+exec_prefix="${GTEST_EXEC_PREFIX:-@exec_prefix@}"
+libdir="${GTEST_LIBDIR:-@libdir@}"
+includedir="${GTEST_INCLUDEDIR:-@includedir@}"
+
+# We try and detect if our binary is not located at its installed location. If
+# it's not, we provide variables pointing to the source and build tree rather
+# than to the install tree. This allows building against a just-built gtest
+# rather than an installed gtest.
+bindir="@bindir@"
+this_relative_bindir=`dirname $0`
+this_bindir=`cd ${this_relative_bindir}; pwd -P`
+if test "${this_bindir}" = "${this_bindir%${bindir}}"; then
+  # The path to the script doesn't end in the bindir sequence from Autoconf,
+  # assume that we are in a build tree.
+  build_dir=`dirname ${this_bindir}`
+  src_dir=`cd ${this_bindir}; cd @top_srcdir@; pwd -P`
+
+  # TODO(chandlerc@google.com): This is a dangerous dependency on libtool, we
+  # should work to remove it, and/or remove libtool altogether, replacing it
+  # with direct references to the library and a link path.
+  gtest_libs="${build_dir}/lib/libgtest.la @PTHREAD_CFLAGS@ @PTHREAD_LIBS@"
+  gtest_ldflags=""
+
+  # We provide hooks to include from either the source or build dir, where the
+  # build dir is always preferred. This will potentially allow us to write
+  # build rules for generated headers and have them automatically be preferred
+  # over provided versions.
+  gtest_cppflags="-I${build_dir}/include -I${src_dir}/include"
+  gtest_cxxflags="@PTHREAD_CFLAGS@"
+else
+  # We're using an installed gtest, although it may be staged under some
+  # prefix. Assume (as our own libraries do) that we can resolve the prefix,
+  # and are present in the dynamic link paths.
+  gtest_ldflags="-L${libdir}"
+  gtest_libs="-l${name} @PTHREAD_CFLAGS@ @PTHREAD_LIBS@"
+  gtest_cppflags="-I${includedir}"
+  gtest_cxxflags="@PTHREAD_CFLAGS@"
+fi
+
+# Do an installation query if requested.
+if test -n "$do_query"; then
+  case $do_query in
+    prefix)           echo $prefix;       exit 0;;
+    exec-prefix)      echo $exec_prefix;  exit 0;;
+    libdir)           echo $libdir;       exit 0;;
+    includedir)       echo $includedir;   exit 0;;
+    version)          echo $version;      exit 0;;
+    *)                show_usage;         exit 1;;
+  esac
+fi
+
+# Do a version check if requested.
+if test "$do_check_versions" = "yes"; then
+  # Make sure we didn't receive a bad combination of parameters.
+  test "$echo_cppflags" = "yes" && show_usage && exit 1
+  test "$echo_cxxflags" = "yes" && show_usage && exit 1
+  test "$echo_ldflags" = "yes"  && show_usage && exit 1
+  test "$echo_libs" = "yes"     && show_usage && exit 1
+
+  if test "$exact_version" != ""; then
+    check_versions $exact_version $exact_version
+    # unreachable
+  else
+    check_versions ${min_version:-0.0.0} ${max_version:-9999.9999.9999}
+    # unreachable
+  fi
+fi
+
+# Do the output in the correct order so that these can be used in-line of
+# a compiler invocation.
+output=""
+test "$echo_cppflags" = "yes" && output="$output $gtest_cppflags"
+test "$echo_cxxflags" = "yes" && output="$output $gtest_cxxflags"
+test "$echo_ldflags" = "yes"  && output="$output $gtest_ldflags"
+test "$echo_libs" = "yes"     && output="$output $gtest_libs"
+echo $output
+
+exit 0
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/pump.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/pump.py
new file mode 100755
index 00000000..5efb653c
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/pump.py
@@ -0,0 +1,855 @@
+#!/usr/bin/env python
+#
+# 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.
+
+"""pump v0.2.0 - Pretty Useful for Meta Programming.
+
+A tool for preprocessor meta programming.  Useful for generating
+repetitive boilerplate code.  Especially useful for writing C++
+classes, functions, macros, and templates that need to work with
+various number of arguments.
+
+USAGE:
+       pump.py SOURCE_FILE
+
+EXAMPLES:
+       pump.py foo.cc.pump
+         Converts foo.cc.pump to foo.cc.
+
+GRAMMAR:
+       CODE ::= ATOMIC_CODE*
+       ATOMIC_CODE ::= $var ID = EXPRESSION
+           | $var ID = [[ CODE ]]
+           | $range ID EXPRESSION..EXPRESSION
+           | $for ID SEPARATOR [[ CODE ]]
+           | $($)
+           | $ID
+           | $(EXPRESSION)
+           | $if EXPRESSION [[ CODE ]] ELSE_BRANCH
+           | [[ CODE ]]
+           | RAW_CODE
+       SEPARATOR ::= RAW_CODE | EMPTY
+       ELSE_BRANCH ::= $else [[ CODE ]]
+           | $elif EXPRESSION [[ CODE ]] ELSE_BRANCH
+           | EMPTY
+       EXPRESSION has Python syntax.
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import re
+import sys
+
+
+TOKEN_TABLE = [
+    (re.compile(r'\$var\s+'), '$var'),
+    (re.compile(r'\$elif\s+'), '$elif'),
+    (re.compile(r'\$else\s+'), '$else'),
+    (re.compile(r'\$for\s+'), '$for'),
+    (re.compile(r'\$if\s+'), '$if'),
+    (re.compile(r'\$range\s+'), '$range'),
+    (re.compile(r'\$[_A-Za-z]\w*'), '$id'),
+    (re.compile(r'\$\(\$\)'), '$($)'),
+    (re.compile(r'\$'), '$'),
+    (re.compile(r'\[\[\n?'), '[['),
+    (re.compile(r'\]\]\n?'), ']]'),
+    ]
+
+
+class Cursor:
+  """Represents a position (line and column) in a text file."""
+
+  def __init__(self, line=-1, column=-1):
+    self.line = line
+    self.column = column
+
+  def __eq__(self, rhs):
+    return self.line == rhs.line and self.column == rhs.column
+
+  def __ne__(self, rhs):
+    return not self == rhs
+
+  def __lt__(self, rhs):
+    return self.line < rhs.line or (
+        self.line == rhs.line and self.column < rhs.column)
+
+  def __le__(self, rhs):
+    return self < rhs or self == rhs
+
+  def __gt__(self, rhs):
+    return rhs < self
+
+  def __ge__(self, rhs):
+    return rhs <= self
+
+  def __str__(self):
+    if self == Eof():
+      return 'EOF'
+    else:
+      return '%s(%s)' % (self.line + 1, self.column)
+
+  def __add__(self, offset):
+    return Cursor(self.line, self.column + offset)
+
+  def __sub__(self, offset):
+    return Cursor(self.line, self.column - offset)
+
+  def Clone(self):
+    """Returns a copy of self."""
+
+    return Cursor(self.line, self.column)
+
+
+# Special cursor to indicate the end-of-file.
+def Eof():
+  """Returns the special cursor to denote the end-of-file."""
+  return Cursor(-1, -1)
+
+
+class Token:
+  """Represents a token in a Pump source file."""
+
+  def __init__(self, start=None, end=None, value=None, token_type=None):
+    if start is None:
+      self.start = Eof()
+    else:
+      self.start = start
+    if end is None:
+      self.end = Eof()
+    else:
+      self.end = end
+    self.value = value
+    self.token_type = token_type
+
+  def __str__(self):
+    return 'Token @%s: \'%s\' type=%s' % (
+        self.start, self.value, self.token_type)
+
+  def Clone(self):
+    """Returns a copy of self."""
+
+    return Token(self.start.Clone(), self.end.Clone(), self.value,
+                 self.token_type)
+
+
+def StartsWith(lines, pos, string):
+  """Returns True iff the given position in lines starts with 'string'."""
+
+  return lines[pos.line][pos.column:].startswith(string)
+
+
+def FindFirstInLine(line, token_table):
+  best_match_start = -1
+  for (regex, token_type) in token_table:
+    m = regex.search(line)
+    if m:
+      # We found regex in lines
+      if best_match_start < 0 or m.start() < best_match_start:
+        best_match_start = m.start()
+        best_match_length = m.end() - m.start()
+        best_match_token_type = token_type
+
+  if best_match_start < 0:
+    return None
+
+  return (best_match_start, best_match_length, best_match_token_type)
+
+
+def FindFirst(lines, token_table, cursor):
+  """Finds the first occurrence of any string in strings in lines."""
+
+  start = cursor.Clone()
+  cur_line_number = cursor.line
+  for line in lines[start.line:]:
+    if cur_line_number == start.line:
+      line = line[start.column:]
+    m = FindFirstInLine(line, token_table)
+    if m:
+      # We found a regex in line.
+      (start_column, length, token_type) = m
+      if cur_line_number == start.line:
+        start_column += start.column
+      found_start = Cursor(cur_line_number, start_column)
+      found_end = found_start + length
+      return MakeToken(lines, found_start, found_end, token_type)
+    cur_line_number += 1
+  # We failed to find str in lines
+  return None
+
+
+def SubString(lines, start, end):
+  """Returns a substring in lines."""
+
+  if end == Eof():
+    end = Cursor(len(lines) - 1, len(lines[-1]))
+
+  if start >= end:
+    return ''
+
+  if start.line == end.line:
+    return lines[start.line][start.column:end.column]
+
+  result_lines = ([lines[start.line][start.column:]] +
+                  lines[start.line + 1:end.line] +
+                  [lines[end.line][:end.column]])
+  return ''.join(result_lines)
+
+
+def StripMetaComments(str):
+  """Strip meta comments from each line in the given string."""
+
+  # First, completely remove lines containing nothing but a meta
+  # comment, including the trailing \n.
+  str = re.sub(r'^\s*\$\$.*\n', '', str)
+
+  # Then, remove meta comments from contentful lines.
+  return re.sub(r'\s*\$\$.*', '', str)
+
+
+def MakeToken(lines, start, end, token_type):
+  """Creates a new instance of Token."""
+
+  return Token(start, end, SubString(lines, start, end), token_type)
+
+
+def ParseToken(lines, pos, regex, token_type):
+  line = lines[pos.line][pos.column:]
+  m = regex.search(line)
+  if m and not m.start():
+    return MakeToken(lines, pos, pos + m.end(), token_type)
+  else:
+    print 'ERROR: %s expected at %s.' % (token_type, pos)
+    sys.exit(1)
+
+
+ID_REGEX = re.compile(r'[_A-Za-z]\w*')
+EQ_REGEX = re.compile(r'=')
+REST_OF_LINE_REGEX = re.compile(r'.*?(?=$|\$\$)')
+OPTIONAL_WHITE_SPACES_REGEX = re.compile(r'\s*')
+WHITE_SPACE_REGEX = re.compile(r'\s')
+DOT_DOT_REGEX = re.compile(r'\.\.')
+
+
+def Skip(lines, pos, regex):
+  line = lines[pos.line][pos.column:]
+  m = re.search(regex, line)
+  if m and not m.start():
+    return pos + m.end()
+  else:
+    return pos
+
+
+def SkipUntil(lines, pos, regex, token_type):
+  line = lines[pos.line][pos.column:]
+  m = re.search(regex, line)
+  if m:
+    return pos + m.start()
+  else:
+    print ('ERROR: %s expected on line %s after column %s.' %
+           (token_type, pos.line + 1, pos.column))
+    sys.exit(1)
+
+
+def ParseExpTokenInParens(lines, pos):
+  def ParseInParens(pos):
+    pos = Skip(lines, pos, OPTIONAL_WHITE_SPACES_REGEX)
+    pos = Skip(lines, pos, r'\(')
+    pos = Parse(pos)
+    pos = Skip(lines, pos, r'\)')
+    return pos
+
+  def Parse(pos):
+    pos = SkipUntil(lines, pos, r'\(|\)', ')')
+    if SubString(lines, pos, pos + 1) == '(':
+      pos = Parse(pos + 1)
+      pos = Skip(lines, pos, r'\)')
+      return Parse(pos)
+    else:
+      return pos
+
+  start = pos.Clone()
+  pos = ParseInParens(pos)
+  return MakeToken(lines, start, pos, 'exp')
+
+
+def RStripNewLineFromToken(token):
+  if token.value.endswith('\n'):
+    return Token(token.start, token.end, token.value[:-1], token.token_type)
+  else:
+    return token
+
+
+def TokenizeLines(lines, pos):
+  while True:
+    found = FindFirst(lines, TOKEN_TABLE, pos)
+    if not found:
+      yield MakeToken(lines, pos, Eof(), 'code')
+      return
+
+    if found.start == pos:
+      prev_token = None
+      prev_token_rstripped = None
+    else:
+      prev_token = MakeToken(lines, pos, found.start, 'code')
+      prev_token_rstripped = RStripNewLineFromToken(prev_token)
+
+    if found.token_type == '$var':
+      if prev_token_rstripped:
+        yield prev_token_rstripped
+      yield found
+      id_token = ParseToken(lines, found.end, ID_REGEX, 'id')
+      yield id_token
+      pos = Skip(lines, id_token.end, OPTIONAL_WHITE_SPACES_REGEX)
+
+      eq_token = ParseToken(lines, pos, EQ_REGEX, '=')
+      yield eq_token
+      pos = Skip(lines, eq_token.end, r'\s*')
+
+      if SubString(lines, pos, pos + 2) != '[[':
+        exp_token = ParseToken(lines, pos, REST_OF_LINE_REGEX, 'exp')
+        yield exp_token
+        pos = Cursor(exp_token.end.line + 1, 0)
+    elif found.token_type == '$for':
+      if prev_token_rstripped:
+        yield prev_token_rstripped
+      yield found
+      id_token = ParseToken(lines, found.end, ID_REGEX, 'id')
+      yield id_token
+      pos = Skip(lines, id_token.end, WHITE_SPACE_REGEX)
+    elif found.token_type == '$range':
+      if prev_token_rstripped:
+        yield prev_token_rstripped
+      yield found
+      id_token = ParseToken(lines, found.end, ID_REGEX, 'id')
+      yield id_token
+      pos = Skip(lines, id_token.end, OPTIONAL_WHITE_SPACES_REGEX)
+
+      dots_pos = SkipUntil(lines, pos, DOT_DOT_REGEX, '..')
+      yield MakeToken(lines, pos, dots_pos, 'exp')
+      yield MakeToken(lines, dots_pos, dots_pos + 2, '..')
+      pos = dots_pos + 2
+      new_pos = Cursor(pos.line + 1, 0)
+      yield MakeToken(lines, pos, new_pos, 'exp')
+      pos = new_pos
+    elif found.token_type == '$':
+      if prev_token:
+        yield prev_token
+      yield found
+      exp_token = ParseExpTokenInParens(lines, found.end)
+      yield exp_token
+      pos = exp_token.end
+    elif (found.token_type == ']]' or found.token_type == '$if' or
+          found.token_type == '$elif' or found.token_type == '$else'):
+      if prev_token_rstripped:
+        yield prev_token_rstripped
+      yield found
+      pos = found.end
+    else:
+      if prev_token:
+        yield prev_token
+      yield found
+      pos = found.end
+
+
+def Tokenize(s):
+  """A generator that yields the tokens in the given string."""
+  if s != '':
+    lines = s.splitlines(True)
+    for token in TokenizeLines(lines, Cursor(0, 0)):
+      yield token
+
+
+class CodeNode:
+  def __init__(self, atomic_code_list=None):
+    self.atomic_code = atomic_code_list
+
+
+class VarNode:
+  def __init__(self, identifier=None, atomic_code=None):
+    self.identifier = identifier
+    self.atomic_code = atomic_code
+
+
+class RangeNode:
+  def __init__(self, identifier=None, exp1=None, exp2=None):
+    self.identifier = identifier
+    self.exp1 = exp1
+    self.exp2 = exp2
+
+
+class ForNode:
+  def __init__(self, identifier=None, sep=None, code=None):
+    self.identifier = identifier
+    self.sep = sep
+    self.code = code
+
+
+class ElseNode:
+  def __init__(self, else_branch=None):
+    self.else_branch = else_branch
+
+
+class IfNode:
+  def __init__(self, exp=None, then_branch=None, else_branch=None):
+    self.exp = exp
+    self.then_branch = then_branch
+    self.else_branch = else_branch
+
+
+class RawCodeNode:
+  def __init__(self, token=None):
+    self.raw_code = token
+
+
+class LiteralDollarNode:
+  def __init__(self, token):
+    self.token = token
+
+
+class ExpNode:
+  def __init__(self, token, python_exp):
+    self.token = token
+    self.python_exp = python_exp
+
+
+def PopFront(a_list):
+  head = a_list[0]
+  a_list[:1] = []
+  return head
+
+
+def PushFront(a_list, elem):
+  a_list[:0] = [elem]
+
+
+def PopToken(a_list, token_type=None):
+  token = PopFront(a_list)
+  if token_type is not None and token.token_type != token_type:
+    print 'ERROR: %s expected at %s' % (token_type, token.start)
+    print 'ERROR: %s found instead' % (token,)
+    sys.exit(1)
+
+  return token
+
+
+def PeekToken(a_list):
+  if not a_list:
+    return None
+
+  return a_list[0]
+
+
+def ParseExpNode(token):
+  python_exp = re.sub(r'([_A-Za-z]\w*)', r'self.GetValue("\1")', token.value)
+  return ExpNode(token, python_exp)
+
+
+def ParseElseNode(tokens):
+  def Pop(token_type=None):
+    return PopToken(tokens, token_type)
+
+  next = PeekToken(tokens)
+  if not next:
+    return None
+  if next.token_type == '$else':
+    Pop('$else')
+    Pop('[[')
+    code_node = ParseCodeNode(tokens)
+    Pop(']]')
+    return code_node
+  elif next.token_type == '$elif':
+    Pop('$elif')
+    exp = Pop('code')
+    Pop('[[')
+    code_node = ParseCodeNode(tokens)
+    Pop(']]')
+    inner_else_node = ParseElseNode(tokens)
+    return CodeNode([IfNode(ParseExpNode(exp), code_node, inner_else_node)])
+  elif not next.value.strip():
+    Pop('code')
+    return ParseElseNode(tokens)
+  else:
+    return None
+
+
+def ParseAtomicCodeNode(tokens):
+  def Pop(token_type=None):
+    return PopToken(tokens, token_type)
+
+  head = PopFront(tokens)
+  t = head.token_type
+  if t == 'code':
+    return RawCodeNode(head)
+  elif t == '$var':
+    id_token = Pop('id')
+    Pop('=')
+    next = PeekToken(tokens)
+    if next.token_type == 'exp':
+      exp_token = Pop()
+      return VarNode(id_token, ParseExpNode(exp_token))
+    Pop('[[')
+    code_node = ParseCodeNode(tokens)
+    Pop(']]')
+    return VarNode(id_token, code_node)
+  elif t == '$for':
+    id_token = Pop('id')
+    next_token = PeekToken(tokens)
+    if next_token.token_type == 'code':
+      sep_token = next_token
+      Pop('code')
+    else:
+      sep_token = None
+    Pop('[[')
+    code_node = ParseCodeNode(tokens)
+    Pop(']]')
+    return ForNode(id_token, sep_token, code_node)
+  elif t == '$if':
+    exp_token = Pop('code')
+    Pop('[[')
+    code_node = ParseCodeNode(tokens)
+    Pop(']]')
+    else_node = ParseElseNode(tokens)
+    return IfNode(ParseExpNode(exp_token), code_node, else_node)
+  elif t == '$range':
+    id_token = Pop('id')
+    exp1_token = Pop('exp')
+    Pop('..')
+    exp2_token = Pop('exp')
+    return RangeNode(id_token, ParseExpNode(exp1_token),
+                     ParseExpNode(exp2_token))
+  elif t == '$id':
+    return ParseExpNode(Token(head.start + 1, head.end, head.value[1:], 'id'))
+  elif t == '$($)':
+    return LiteralDollarNode(head)
+  elif t == '$':
+    exp_token = Pop('exp')
+    return ParseExpNode(exp_token)
+  elif t == '[[':
+    code_node = ParseCodeNode(tokens)
+    Pop(']]')
+    return code_node
+  else:
+    PushFront(tokens, head)
+    return None
+
+
+def ParseCodeNode(tokens):
+  atomic_code_list = []
+  while True:
+    if not tokens:
+      break
+    atomic_code_node = ParseAtomicCodeNode(tokens)
+    if atomic_code_node:
+      atomic_code_list.append(atomic_code_node)
+    else:
+      break
+  return CodeNode(atomic_code_list)
+
+
+def ParseToAST(pump_src_text):
+  """Convert the given Pump source text into an AST."""
+  tokens = list(Tokenize(pump_src_text))
+  code_node = ParseCodeNode(tokens)
+  return code_node
+
+
+class Env:
+  def __init__(self):
+    self.variables = []
+    self.ranges = []
+
+  def Clone(self):
+    clone = Env()
+    clone.variables = self.variables[:]
+    clone.ranges = self.ranges[:]
+    return clone
+
+  def PushVariable(self, var, value):
+    # If value looks like an int, store it as an int.
+    try:
+      int_value = int(value)
+      if ('%s' % int_value) == value:
+        value = int_value
+    except Exception:
+      pass
+    self.variables[:0] = [(var, value)]
+
+  def PopVariable(self):
+    self.variables[:1] = []
+
+  def PushRange(self, var, lower, upper):
+    self.ranges[:0] = [(var, lower, upper)]
+
+  def PopRange(self):
+    self.ranges[:1] = []
+
+  def GetValue(self, identifier):
+    for (var, value) in self.variables:
+      if identifier == var:
+        return value
+
+    print 'ERROR: meta variable %s is undefined.' % (identifier,)
+    sys.exit(1)
+
+  def EvalExp(self, exp):
+    try:
+      result = eval(exp.python_exp)
+    except Exception, e:
+      print 'ERROR: caught exception %s: %s' % (e.__class__.__name__, e)
+      print ('ERROR: failed to evaluate meta expression %s at %s' %
+             (exp.python_exp, exp.token.start))
+      sys.exit(1)
+    return result
+
+  def GetRange(self, identifier):
+    for (var, lower, upper) in self.ranges:
+      if identifier == var:
+        return (lower, upper)
+
+    print 'ERROR: range %s is undefined.' % (identifier,)
+    sys.exit(1)
+
+
+class Output:
+  def __init__(self):
+    self.string = ''
+
+  def GetLastLine(self):
+    index = self.string.rfind('\n')
+    if index < 0:
+      return ''
+
+    return self.string[index + 1:]
+
+  def Append(self, s):
+    self.string += s
+
+
+def RunAtomicCode(env, node, output):
+  if isinstance(node, VarNode):
+    identifier = node.identifier.value.strip()
+    result = Output()
+    RunAtomicCode(env.Clone(), node.atomic_code, result)
+    value = result.string
+    env.PushVariable(identifier, value)
+  elif isinstance(node, RangeNode):
+    identifier = node.identifier.value.strip()
+    lower = int(env.EvalExp(node.exp1))
+    upper = int(env.EvalExp(node.exp2))
+    env.PushRange(identifier, lower, upper)
+  elif isinstance(node, ForNode):
+    identifier = node.identifier.value.strip()
+    if node.sep is None:
+      sep = ''
+    else:
+      sep = node.sep.value
+    (lower, upper) = env.GetRange(identifier)
+    for i in range(lower, upper + 1):
+      new_env = env.Clone()
+      new_env.PushVariable(identifier, i)
+      RunCode(new_env, node.code, output)
+      if i != upper:
+        output.Append(sep)
+  elif isinstance(node, RawCodeNode):
+    output.Append(node.raw_code.value)
+  elif isinstance(node, IfNode):
+    cond = env.EvalExp(node.exp)
+    if cond:
+      RunCode(env.Clone(), node.then_branch, output)
+    elif node.else_branch is not None:
+      RunCode(env.Clone(), node.else_branch, output)
+  elif isinstance(node, ExpNode):
+    value = env.EvalExp(node)
+    output.Append('%s' % (value,))
+  elif isinstance(node, LiteralDollarNode):
+    output.Append('$')
+  elif isinstance(node, CodeNode):
+    RunCode(env.Clone(), node, output)
+  else:
+    print 'BAD'
+    print node
+    sys.exit(1)
+
+
+def RunCode(env, code_node, output):
+  for atomic_code in code_node.atomic_code:
+    RunAtomicCode(env, atomic_code, output)
+
+
+def IsSingleLineComment(cur_line):
+  return '//' in cur_line
+
+
+def IsInPreprocessorDirective(prev_lines, cur_line):
+  if cur_line.lstrip().startswith('#'):
+    return True
+  return prev_lines and prev_lines[-1].endswith('\\')
+
+
+def WrapComment(line, output):
+  loc = line.find('//')
+  before_comment = line[:loc].rstrip()
+  if before_comment == '':
+    indent = loc
+  else:
+    output.append(before_comment)
+    indent = len(before_comment) - len(before_comment.lstrip())
+  prefix = indent*' ' + '// '
+  max_len = 80 - len(prefix)
+  comment = line[loc + 2:].strip()
+  segs = [seg for seg in re.split(r'(\w+\W*)', comment) if seg != '']
+  cur_line = ''
+  for seg in segs:
+    if len((cur_line + seg).rstrip()) < max_len:
+      cur_line += seg
+    else:
+      if cur_line.strip() != '':
+        output.append(prefix + cur_line.rstrip())
+      cur_line = seg.lstrip()
+  if cur_line.strip() != '':
+    output.append(prefix + cur_line.strip())
+
+
+def WrapCode(line, line_concat, output):
+  indent = len(line) - len(line.lstrip())
+  prefix = indent*' '  # Prefix of the current line
+  max_len = 80 - indent - len(line_concat)  # Maximum length of the current line
+  new_prefix = prefix + 4*' '  # Prefix of a continuation line
+  new_max_len = max_len - 4  # Maximum length of a continuation line
+  # Prefers to wrap a line after a ',' or ';'.
+  segs = [seg for seg in re.split(r'([^,;]+[,;]?)', line.strip()) if seg != '']
+  cur_line = ''  # The current line without leading spaces.
+  for seg in segs:
+    # If the line is still too long, wrap at a space.
+    while cur_line == '' and len(seg.strip()) > max_len:
+      seg = seg.lstrip()
+      split_at = seg.rfind(' ', 0, max_len)
+      output.append(prefix + seg[:split_at].strip() + line_concat)
+      seg = seg[split_at + 1:]
+      prefix = new_prefix
+      max_len = new_max_len
+
+    if len((cur_line + seg).rstrip()) < max_len:
+      cur_line = (cur_line + seg).lstrip()
+    else:
+      output.append(prefix + cur_line.rstrip() + line_concat)
+      prefix = new_prefix
+      max_len = new_max_len
+      cur_line = seg.lstrip()
+  if cur_line.strip() != '':
+    output.append(prefix + cur_line.strip())
+
+
+def WrapPreprocessorDirective(line, output):
+  WrapCode(line, ' \\', output)
+
+
+def WrapPlainCode(line, output):
+  WrapCode(line, '', output)
+
+
+def IsMultiLineIWYUPragma(line):
+  return re.search(r'/\* IWYU pragma: ', line)
+
+
+def IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
+  return (re.match(r'^#(ifndef|define|endif\s*//)\s*[\w_]+\s*$', line) or
+          re.match(r'^#include\s', line) or
+          # Don't break IWYU pragmas, either; that causes iwyu.py problems.
+          re.search(r'// IWYU pragma: ', line))
+
+
+def WrapLongLine(line, output):
+  line = line.rstrip()
+  if len(line) <= 80:
+    output.append(line)
+  elif IsSingleLineComment(line):
+    if IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
+      # The style guide made an exception to allow long header guard lines,
+      # includes and IWYU pragmas.
+      output.append(line)
+    else:
+      WrapComment(line, output)
+  elif IsInPreprocessorDirective(output, line):
+    if IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
+      # The style guide made an exception to allow long header guard lines,
+      # includes and IWYU pragmas.
+      output.append(line)
+    else:
+      WrapPreprocessorDirective(line, output)
+  elif IsMultiLineIWYUPragma(line):
+    output.append(line)
+  else:
+    WrapPlainCode(line, output)
+
+
+def BeautifyCode(string):
+  lines = string.splitlines()
+  output = []
+  for line in lines:
+    WrapLongLine(line, output)
+  output2 = [line.rstrip() for line in output]
+  return '\n'.join(output2) + '\n'
+
+
+def ConvertFromPumpSource(src_text):
+  """Return the text generated from the given Pump source text."""
+  ast = ParseToAST(StripMetaComments(src_text))
+  output = Output()
+  RunCode(Env(), ast, output)
+  return BeautifyCode(output.string)
+
+
+def main(argv):
+  if len(argv) == 1:
+    print __doc__
+    sys.exit(1)
+
+  file_path = argv[-1]
+  output_str = ConvertFromPumpSource(file(file_path, 'r').read())
+  if file_path.endswith('.pump'):
+    output_file_path = file_path[:-5]
+  else:
+    output_file_path = '-'
+  if output_file_path == '-':
+    print output_str,
+  else:
+    output_file = file(output_file_path, 'w')
+    output_file.write('// This file was GENERATED by command:\n')
+    output_file.write('//     %s %s\n' %
+                      (os.path.basename(__file__), os.path.basename(file_path)))
+    output_file.write('// DO NOT EDIT BY HAND!!!\n\n')
+    output_file.write(output_str)
+    output_file.close()
+
+
+if __name__ == '__main__':
+  main(sys.argv)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/release_docs.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/release_docs.py
new file mode 100755
index 00000000..1291347f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/release_docs.py
@@ -0,0 +1,158 @@
+#!/usr/bin/env python
+#
+# Copyright 2013 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.
+
+"""Script for branching Google Test/Mock wiki pages for a new version.
+
+SYNOPSIS
+       release_docs.py NEW_RELEASE_VERSION
+
+       Google Test and Google Mock's external user documentation is in
+       interlinked wiki files.  When we release a new version of
+       Google Test or Google Mock, we need to branch the wiki files
+       such that users of a specific version of Google Test/Mock can
+       look up documenation relevant for that version.  This script
+       automates that process by:
+
+         - branching the current wiki pages (which document the
+           behavior of the SVN trunk head) to pages for the specified
+           version (e.g. branching FAQ.wiki to V2_6_FAQ.wiki when
+           NEW_RELEASE_VERSION is 2.6);
+         - updating the links in the branched files to point to the branched
+           version (e.g. a link in V2_6_FAQ.wiki that pointed to
+           Primer.wiki#Anchor will now point to V2_6_Primer.wiki#Anchor).
+
+       NOTE: NEW_RELEASE_VERSION must be a NEW version number for
+       which the wiki pages don't yet exist; otherwise you'll get SVN
+       errors like "svn: Path 'V1_7_PumpManual.wiki' is not a
+       directory" when running the script.
+
+EXAMPLE
+       $ cd PATH/TO/GTEST_SVN_WORKSPACE/trunk
+       $ scripts/release_docs.py 2.6  # create wiki pages for v2.6
+       $ svn status                   # verify the file list
+       $ svn diff                     # verify the file contents
+       $ svn commit -m "release wiki pages for v2.6"
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import re
+import sys
+
+import common
+
+
+# Wiki pages that shouldn't be branched for every gtest/gmock release.
+GTEST_UNVERSIONED_WIKIS = ['DevGuide.wiki']
+GMOCK_UNVERSIONED_WIKIS = [
+    'DesignDoc.wiki',
+    'DevGuide.wiki',
+    'KnownIssues.wiki'
+    ]
+
+
+def DropWikiSuffix(wiki_filename):
+  """Removes the .wiki suffix (if any) from the given filename."""
+
+  return (wiki_filename[:-len('.wiki')] if wiki_filename.endswith('.wiki')
+          else wiki_filename)
+
+
+class WikiBrancher(object):
+  """Branches ..."""
+
+  def __init__(self, dot_version):
+    self.project, svn_root_path = common.GetSvnInfo()
+    if self.project not in ('googletest', 'googlemock'):
+      sys.exit('This script must be run in a gtest or gmock SVN workspace.')
+    self.wiki_dir = svn_root_path + '/wiki'
+    # Turn '2.6' to 'V2_6_'.
+    self.version_prefix = 'V' + dot_version.replace('.', '_') + '_'
+    self.files_to_branch = self.GetFilesToBranch()
+    page_names = [DropWikiSuffix(f) for f in self.files_to_branch]
+    # A link to Foo.wiki is in one of the following forms:
+    #   [Foo words]
+    #   [Foo#Anchor words]
+    #   [http://code.google.com/.../wiki/Foo words]
+    #   [http://code.google.com/.../wiki/Foo#Anchor words]
+    # We want to replace 'Foo' with 'V2_6_Foo' in the above cases.
+    self.search_for_re = re.compile(
+        # This regex matches either
+        #   [Foo
+        # or
+        #   /wiki/Foo
+        # followed by a space or a #, where Foo is the name of an
+        # unversioned wiki page.
+        r'(\[|/wiki/)(%s)([ #])' % '|'.join(page_names))
+    self.replace_with = r'\1%s\2\3' % (self.version_prefix,)
+
+  def GetFilesToBranch(self):
+    """Returns a list of .wiki file names that need to be branched."""
+
+    unversioned_wikis = (GTEST_UNVERSIONED_WIKIS if self.project == 'googletest'
+                         else GMOCK_UNVERSIONED_WIKIS)
+    return [f for f in os.listdir(self.wiki_dir)
+            if (f.endswith('.wiki') and
+                not re.match(r'^V\d', f) and  # Excluded versioned .wiki files.
+                f not in unversioned_wikis)]
+
+  def BranchFiles(self):
+    """Branches the .wiki files needed to be branched."""
+
+    print 'Branching %d .wiki files:' % (len(self.files_to_branch),)
+    os.chdir(self.wiki_dir)
+    for f in self.files_to_branch:
+      command = 'svn cp %s %s%s' % (f, self.version_prefix, f)
+      print command
+      os.system(command)
+
+  def UpdateLinksInBranchedFiles(self):
+
+    for f in self.files_to_branch:
+      source_file = os.path.join(self.wiki_dir, f)
+      versioned_file = os.path.join(self.wiki_dir, self.version_prefix + f)
+      print 'Updating links in %s.' % (versioned_file,)
+      text = file(source_file, 'r').read()
+      new_text = self.search_for_re.sub(self.replace_with, text)
+      file(versioned_file, 'w').write(new_text)
+
+
+def main():
+  if len(sys.argv) != 2:
+    sys.exit(__doc__)
+
+  brancher = WikiBrancher(sys.argv[1])
+  brancher.BranchFiles()
+  brancher.UpdateLinksInBranchedFiles()
+
+
+if __name__ == '__main__':
+  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/test/Makefile b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/test/Makefile
new file mode 100644
index 00000000..cdff5846
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/test/Makefile
@@ -0,0 +1,59 @@
+# A Makefile for fusing Google Test and building a sample test against it.
+#
+# SYNOPSIS:
+#
+#   make [all]  - makes everything.
+#   make TARGET - makes the given target.
+#   make check  - makes everything and runs the built sample test.
+#   make clean  - removes all files generated by make.
+
+# Points to the root of fused Google Test, relative to where this file is.
+FUSED_GTEST_DIR = output
+
+# Paths to the fused gtest files.
+FUSED_GTEST_H = $(FUSED_GTEST_DIR)/gtest/gtest.h
+FUSED_GTEST_ALL_CC = $(FUSED_GTEST_DIR)/gtest/gtest-all.cc
+
+# Where to find the sample test.
+SAMPLE_DIR = ../../samples
+
+# Where to find gtest_main.cc.
+GTEST_MAIN_CC = ../../src/gtest_main.cc
+
+# Flags passed to the preprocessor.
+# We have no idea here whether pthreads is available in the system, so
+# disable its use.
+CPPFLAGS += -I$(FUSED_GTEST_DIR) -DGTEST_HAS_PTHREAD=0
+
+# Flags passed to the C++ compiler.
+CXXFLAGS += -g
+
+all : sample1_unittest
+
+check : all
+	./sample1_unittest
+
+clean :
+	rm -rf $(FUSED_GTEST_DIR) sample1_unittest *.o
+
+$(FUSED_GTEST_H) :
+	../fuse_gtest_files.py $(FUSED_GTEST_DIR)
+
+$(FUSED_GTEST_ALL_CC) :
+	../fuse_gtest_files.py $(FUSED_GTEST_DIR)
+
+gtest-all.o : $(FUSED_GTEST_H) $(FUSED_GTEST_ALL_CC)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(FUSED_GTEST_DIR)/gtest/gtest-all.cc
+
+gtest_main.o : $(FUSED_GTEST_H) $(GTEST_MAIN_CC)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(GTEST_MAIN_CC)
+
+sample1.o : $(SAMPLE_DIR)/sample1.cc $(SAMPLE_DIR)/sample1.h
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(SAMPLE_DIR)/sample1.cc
+
+sample1_unittest.o : $(SAMPLE_DIR)/sample1_unittest.cc \
+                     $(SAMPLE_DIR)/sample1.h $(FUSED_GTEST_H)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(SAMPLE_DIR)/sample1_unittest.cc
+
+sample1_unittest : sample1.o sample1_unittest.o gtest-all.o gtest_main.o
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) $^ -o $@
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload.py
new file mode 100755
index 00000000..6e6f9a14
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload.py
@@ -0,0 +1,1387 @@
+#!/usr/bin/env python
+#
+# Copyright 2007 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tool for uploading diffs from a version control system to the codereview app.
+
+Usage summary: upload.py [options] [-- diff_options]
+
+Diff options are passed to the diff command of the underlying system.
+
+Supported version control systems:
+  Git
+  Mercurial
+  Subversion
+
+It is important for Git/Mercurial users to specify a tree/node/branch to diff
+against by using the '--rev' option.
+"""
+# This code is derived from appcfg.py in the App Engine SDK (open source),
+# and from ASPN recipe #146306.
+
+import cookielib
+import getpass
+import logging
+import md5
+import mimetypes
+import optparse
+import os
+import re
+import socket
+import subprocess
+import sys
+import urllib
+import urllib2
+import urlparse
+
+try:
+  import readline
+except ImportError:
+  pass
+
+# The logging verbosity:
+#  0: Errors only.
+#  1: Status messages.
+#  2: Info logs.
+#  3: Debug logs.
+verbosity = 1
+
+# Max size of patch or base file.
+MAX_UPLOAD_SIZE = 900 * 1024
+
+
+def GetEmail(prompt):
+  """Prompts the user for their email address and returns it.
+
+  The last used email address is saved to a file and offered up as a suggestion
+  to the user. If the user presses enter without typing in anything the last
+  used email address is used. If the user enters a new address, it is saved
+  for next time we prompt.
+
+  """
+  last_email_file_name = os.path.expanduser("~/.last_codereview_email_address")
+  last_email = ""
+  if os.path.exists(last_email_file_name):
+    try:
+      last_email_file = open(last_email_file_name, "r")
+      last_email = last_email_file.readline().strip("\n")
+      last_email_file.close()
+      prompt += " [%s]" % last_email
+    except IOError, e:
+      pass
+  email = raw_input(prompt + ": ").strip()
+  if email:
+    try:
+      last_email_file = open(last_email_file_name, "w")
+      last_email_file.write(email)
+      last_email_file.close()
+    except IOError, e:
+      pass
+  else:
+    email = last_email
+  return email
+
+
+def StatusUpdate(msg):
+  """Print a status message to stdout.
+
+  If 'verbosity' is greater than 0, print the message.
+
+  Args:
+    msg: The string to print.
+  """
+  if verbosity > 0:
+    print msg
+
+
+def ErrorExit(msg):
+  """Print an error message to stderr and exit."""
+  print >>sys.stderr, msg
+  sys.exit(1)
+
+
+class ClientLoginError(urllib2.HTTPError):
+  """Raised to indicate there was an error authenticating with ClientLogin."""
+
+  def __init__(self, url, code, msg, headers, args):
+    urllib2.HTTPError.__init__(self, url, code, msg, headers, None)
+    self.args = args
+    self.reason = args["Error"]
+
+
+class AbstractRpcServer(object):
+  """Provides a common interface for a simple RPC server."""
+
+  def __init__(self, host, auth_function, host_override=None, extra_headers={},
+               save_cookies=False):
+    """Creates a new HttpRpcServer.
+
+    Args:
+      host: The host to send requests to.
+      auth_function: A function that takes no arguments and returns an
+        (email, password) tuple when called. Will be called if authentication
+        is required.
+      host_override: The host header to send to the server (defaults to host).
+      extra_headers: A dict of extra headers to append to every request.
+      save_cookies: If True, save the authentication cookies to local disk.
+        If False, use an in-memory cookiejar instead.  Subclasses must
+        implement this functionality.  Defaults to False.
+    """
+    self.host = host
+    self.host_override = host_override
+    self.auth_function = auth_function
+    self.authenticated = False
+    self.extra_headers = extra_headers
+    self.save_cookies = save_cookies
+    self.opener = self._GetOpener()
+    if self.host_override:
+      logging.info("Server: %s; Host: %s", self.host, self.host_override)
+    else:
+      logging.info("Server: %s", self.host)
+
+  def _GetOpener(self):
+    """Returns an OpenerDirector for making HTTP requests.
+
+    Returns:
+      A urllib2.OpenerDirector object.
+    """
+    raise NotImplementedError()
+
+  def _CreateRequest(self, url, data=None):
+    """Creates a new urllib request."""
+    logging.debug("Creating request for: '%s' with payload:\n%s", url, data)
+    req = urllib2.Request(url, data=data)
+    if self.host_override:
+      req.add_header("Host", self.host_override)
+    for key, value in self.extra_headers.iteritems():
+      req.add_header(key, value)
+    return req
+
+  def _GetAuthToken(self, email, password):
+    """Uses ClientLogin to authenticate the user, returning an auth token.
+
+    Args:
+      email:    The user's email address
+      password: The user's password
+
+    Raises:
+      ClientLoginError: If there was an error authenticating with ClientLogin.
+      HTTPError: If there was some other form of HTTP error.
+
+    Returns:
+      The authentication token returned by ClientLogin.
+    """
+    account_type = "GOOGLE"
+    if self.host.endswith(".google.com"):
+      # Needed for use inside Google.
+      account_type = "HOSTED"
+    req = self._CreateRequest(
+        url="https://www.google.com/accounts/ClientLogin",
+        data=urllib.urlencode({
+            "Email": email,
+            "Passwd": password,
+            "service": "ah",
+            "source": "rietveld-codereview-upload",
+            "accountType": account_type,
+        }),
+    )
+    try:
+      response = self.opener.open(req)
+      response_body = response.read()
+      response_dict = dict(x.split("=")
+                           for x in response_body.split("\n") if x)
+      return response_dict["Auth"]
+    except urllib2.HTTPError, e:
+      if e.code == 403:
+        body = e.read()
+        response_dict = dict(x.split("=", 1) for x in body.split("\n") if x)
+        raise ClientLoginError(req.get_full_url(), e.code, e.msg,
+                               e.headers, response_dict)
+      else:
+        raise
+
+  def _GetAuthCookie(self, auth_token):
+    """Fetches authentication cookies for an authentication token.
+
+    Args:
+      auth_token: The authentication token returned by ClientLogin.
+
+    Raises:
+      HTTPError: If there was an error fetching the authentication cookies.
+    """
+    # This is a dummy value to allow us to identify when we're successful.
+    continue_location = "http://localhost/"
+    args = {"continue": continue_location, "auth": auth_token}
+    req = self._CreateRequest("http://%s/_ah/login?%s" %
+                              (self.host, urllib.urlencode(args)))
+    try:
+      response = self.opener.open(req)
+    except urllib2.HTTPError, e:
+      response = e
+    if (response.code != 302 or
+        response.info()["location"] != continue_location):
+      raise urllib2.HTTPError(req.get_full_url(), response.code, response.msg,
+                              response.headers, response.fp)
+    self.authenticated = True
+
+  def _Authenticate(self):
+    """Authenticates the user.
+
+    The authentication process works as follows:
+     1) We get a username and password from the user
+     2) We use ClientLogin to obtain an AUTH token for the user
+        (see http://code.google.com/apis/accounts/AuthForInstalledApps.html).
+     3) We pass the auth token to /_ah/login on the server to obtain an
+        authentication cookie. If login was successful, it tries to redirect
+        us to the URL we provided.
+
+    If we attempt to access the upload API without first obtaining an
+    authentication cookie, it returns a 401 response and directs us to
+    authenticate ourselves with ClientLogin.
+    """
+    for i in range(3):
+      credentials = self.auth_function()
+      try:
+        auth_token = self._GetAuthToken(credentials[0], credentials[1])
+      except ClientLoginError, e:
+        if e.reason == "BadAuthentication":
+          print >>sys.stderr, "Invalid username or password."
+          continue
+        if e.reason == "CaptchaRequired":
+          print >>sys.stderr, (
+              "Please go to\n"
+              "https://www.google.com/accounts/DisplayUnlockCaptcha\n"
+              "and verify you are a human.  Then try again.")
+          break
+        if e.reason == "NotVerified":
+          print >>sys.stderr, "Account not verified."
+          break
+        if e.reason == "TermsNotAgreed":
+          print >>sys.stderr, "User has not agreed to TOS."
+          break
+        if e.reason == "AccountDeleted":
+          print >>sys.stderr, "The user account has been deleted."
+          break
+        if e.reason == "AccountDisabled":
+          print >>sys.stderr, "The user account has been disabled."
+          break
+        if e.reason == "ServiceDisabled":
+          print >>sys.stderr, ("The user's access to the service has been "
+                               "disabled.")
+          break
+        if e.reason == "ServiceUnavailable":
+          print >>sys.stderr, "The service is not available; try again later."
+          break
+        raise
+      self._GetAuthCookie(auth_token)
+      return
+
+  def Send(self, request_path, payload=None,
+           content_type="application/octet-stream",
+           timeout=None,
+           **kwargs):
+    """Sends an RPC and returns the response.
+
+    Args:
+      request_path: The path to send the request to, eg /api/appversion/create.
+      payload: The body of the request, or None to send an empty request.
+      content_type: The Content-Type header to use.
+      timeout: timeout in seconds; default None i.e. no timeout.
+        (Note: for large requests on OS X, the timeout doesn't work right.)
+      kwargs: Any keyword arguments are converted into query string parameters.
+
+    Returns:
+      The response body, as a string.
+    """
+    # TODO: Don't require authentication.  Let the server say
+    # whether it is necessary.
+    if not self.authenticated:
+      self._Authenticate()
+
+    old_timeout = socket.getdefaulttimeout()
+    socket.setdefaulttimeout(timeout)
+    try:
+      tries = 0
+      while True:
+        tries += 1
+        args = dict(kwargs)
+        url = "http://%s%s" % (self.host, request_path)
+        if args:
+          url += "?" + urllib.urlencode(args)
+        req = self._CreateRequest(url=url, data=payload)
+        req.add_header("Content-Type", content_type)
+        try:
+          f = self.opener.open(req)
+          response = f.read()
+          f.close()
+          return response
+        except urllib2.HTTPError, e:
+          if tries > 3:
+            raise
+          elif e.code == 401:
+            self._Authenticate()
+##           elif e.code >= 500 and e.code < 600:
+##             # Server Error - try again.
+##             continue
+          else:
+            raise
+    finally:
+      socket.setdefaulttimeout(old_timeout)
+
+
+class HttpRpcServer(AbstractRpcServer):
+  """Provides a simplified RPC-style interface for HTTP requests."""
+
+  def _Authenticate(self):
+    """Save the cookie jar after authentication."""
+    super(HttpRpcServer, self)._Authenticate()
+    if self.save_cookies:
+      StatusUpdate("Saving authentication cookies to %s" % self.cookie_file)
+      self.cookie_jar.save()
+
+  def _GetOpener(self):
+    """Returns an OpenerDirector that supports cookies and ignores redirects.
+
+    Returns:
+      A urllib2.OpenerDirector object.
+    """
+    opener = urllib2.OpenerDirector()
+    opener.add_handler(urllib2.ProxyHandler())
+    opener.add_handler(urllib2.UnknownHandler())
+    opener.add_handler(urllib2.HTTPHandler())
+    opener.add_handler(urllib2.HTTPDefaultErrorHandler())
+    opener.add_handler(urllib2.HTTPSHandler())
+    opener.add_handler(urllib2.HTTPErrorProcessor())
+    if self.save_cookies:
+      self.cookie_file = os.path.expanduser("~/.codereview_upload_cookies")
+      self.cookie_jar = cookielib.MozillaCookieJar(self.cookie_file)
+      if os.path.exists(self.cookie_file):
+        try:
+          self.cookie_jar.load()
+          self.authenticated = True
+          StatusUpdate("Loaded authentication cookies from %s" %
+                       self.cookie_file)
+        except (cookielib.LoadError, IOError):
+          # Failed to load cookies - just ignore them.
+          pass
+      else:
+        # Create an empty cookie file with mode 600
+        fd = os.open(self.cookie_file, os.O_CREAT, 0600)
+        os.close(fd)
+      # Always chmod the cookie file
+      os.chmod(self.cookie_file, 0600)
+    else:
+      # Don't save cookies across runs of update.py.
+      self.cookie_jar = cookielib.CookieJar()
+    opener.add_handler(urllib2.HTTPCookieProcessor(self.cookie_jar))
+    return opener
+
+
+parser = optparse.OptionParser(usage="%prog [options] [-- diff_options]")
+parser.add_option("-y", "--assume_yes", action="store_true",
+                  dest="assume_yes", default=False,
+                  help="Assume that the answer to yes/no questions is 'yes'.")
+# Logging
+group = parser.add_option_group("Logging options")
+group.add_option("-q", "--quiet", action="store_const", const=0,
+                 dest="verbose", help="Print errors only.")
+group.add_option("-v", "--verbose", action="store_const", const=2,
+                 dest="verbose", default=1,
+                 help="Print info level logs (default).")
+group.add_option("--noisy", action="store_const", const=3,
+                 dest="verbose", help="Print all logs.")
+# Review server
+group = parser.add_option_group("Review server options")
+group.add_option("-s", "--server", action="store", dest="server",
+                 default="codereview.appspot.com",
+                 metavar="SERVER",
+                 help=("The server to upload to. The format is host[:port]. "
+                       "Defaults to 'codereview.appspot.com'."))
+group.add_option("-e", "--email", action="store", dest="email",
+                 metavar="EMAIL", default=None,
+                 help="The username to use. Will prompt if omitted.")
+group.add_option("-H", "--host", action="store", dest="host",
+                 metavar="HOST", default=None,
+                 help="Overrides the Host header sent with all RPCs.")
+group.add_option("--no_cookies", action="store_false",
+                 dest="save_cookies", default=True,
+                 help="Do not save authentication cookies to local disk.")
+# Issue
+group = parser.add_option_group("Issue options")
+group.add_option("-d", "--description", action="store", dest="description",
+                 metavar="DESCRIPTION", default=None,
+                 help="Optional description when creating an issue.")
+group.add_option("-f", "--description_file", action="store",
+                 dest="description_file", metavar="DESCRIPTION_FILE",
+                 default=None,
+                 help="Optional path of a file that contains "
+                      "the description when creating an issue.")
+group.add_option("-r", "--reviewers", action="store", dest="reviewers",
+                 metavar="REVIEWERS", default=None,
+                 help="Add reviewers (comma separated email addresses).")
+group.add_option("--cc", action="store", dest="cc",
+                 metavar="CC", default=None,
+                 help="Add CC (comma separated email addresses).")
+# Upload options
+group = parser.add_option_group("Patch options")
+group.add_option("-m", "--message", action="store", dest="message",
+                 metavar="MESSAGE", default=None,
+                 help="A message to identify the patch. "
+                      "Will prompt if omitted.")
+group.add_option("-i", "--issue", type="int", action="store",
+                 metavar="ISSUE", default=None,
+                 help="Issue number to which to add. Defaults to new issue.")
+group.add_option("--download_base", action="store_true",
+                 dest="download_base", default=False,
+                 help="Base files will be downloaded by the server "
+                 "(side-by-side diffs may not work on files with CRs).")
+group.add_option("--rev", action="store", dest="revision",
+                 metavar="REV", default=None,
+                 help="Branch/tree/revision to diff against (used by DVCS).")
+group.add_option("--send_mail", action="store_true",
+                 dest="send_mail", default=False,
+                 help="Send notification email to reviewers.")
+
+
+def GetRpcServer(options):
+  """Returns an instance of an AbstractRpcServer.
+
+  Returns:
+    A new AbstractRpcServer, on which RPC calls can be made.
+  """
+
+  rpc_server_class = HttpRpcServer
+
+  def GetUserCredentials():
+    """Prompts the user for a username and password."""
+    email = options.email
+    if email is None:
+      email = GetEmail("Email (login for uploading to %s)" % options.server)
+    password = getpass.getpass("Password for %s: " % email)
+    return (email, password)
+
+  # If this is the dev_appserver, use fake authentication.
+  host = (options.host or options.server).lower()
+  if host == "localhost" or host.startswith("localhost:"):
+    email = options.email
+    if email is None:
+      email = "test@example.com"
+      logging.info("Using debug user %s.  Override with --email" % email)
+    server = rpc_server_class(
+        options.server,
+        lambda: (email, "password"),
+        host_override=options.host,
+        extra_headers={"Cookie":
+                       'dev_appserver_login="%s:False"' % email},
+        save_cookies=options.save_cookies)
+    # Don't try to talk to ClientLogin.
+    server.authenticated = True
+    return server
+
+  return rpc_server_class(options.server, GetUserCredentials,
+                          host_override=options.host,
+                          save_cookies=options.save_cookies)
+
+
+def EncodeMultipartFormData(fields, files):
+  """Encode form fields for multipart/form-data.
+
+  Args:
+    fields: A sequence of (name, value) elements for regular form fields.
+    files: A sequence of (name, filename, value) elements for data to be
+           uploaded as files.
+  Returns:
+    (content_type, body) ready for httplib.HTTP instance.
+
+  Source:
+    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/146306
+  """
+  BOUNDARY = '-M-A-G-I-C---B-O-U-N-D-A-R-Y-'
+  CRLF = '\r\n'
+  lines = []
+  for (key, value) in fields:
+    lines.append('--' + BOUNDARY)
+    lines.append('Content-Disposition: form-data; name="%s"' % key)
+    lines.append('')
+    lines.append(value)
+  for (key, filename, value) in files:
+    lines.append('--' + BOUNDARY)
+    lines.append('Content-Disposition: form-data; name="%s"; filename="%s"' %
+             (key, filename))
+    lines.append('Content-Type: %s' % GetContentType(filename))
+    lines.append('')
+    lines.append(value)
+  lines.append('--' + BOUNDARY + '--')
+  lines.append('')
+  body = CRLF.join(lines)
+  content_type = 'multipart/form-data; boundary=%s' % BOUNDARY
+  return content_type, body
+
+
+def GetContentType(filename):
+  """Helper to guess the content-type from the filename."""
+  return mimetypes.guess_type(filename)[0] or 'application/octet-stream'
+
+
+# Use a shell for subcommands on Windows to get a PATH search.
+use_shell = sys.platform.startswith("win")
+
+def RunShellWithReturnCode(command, print_output=False,
+                           universal_newlines=True):
+  """Executes a command and returns the output from stdout and the return code.
+
+  Args:
+    command: Command to execute.
+    print_output: If True, the output is printed to stdout.
+                  If False, both stdout and stderr are ignored.
+    universal_newlines: Use universal_newlines flag (default: True).
+
+  Returns:
+    Tuple (output, return code)
+  """
+  logging.info("Running %s", command)
+  p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                       shell=use_shell, universal_newlines=universal_newlines)
+  if print_output:
+    output_array = []
+    while True:
+      line = p.stdout.readline()
+      if not line:
+        break
+      print line.strip("\n")
+      output_array.append(line)
+    output = "".join(output_array)
+  else:
+    output = p.stdout.read()
+  p.wait()
+  errout = p.stderr.read()
+  if print_output and errout:
+    print >>sys.stderr, errout
+  p.stdout.close()
+  p.stderr.close()
+  return output, p.returncode
+
+
+def RunShell(command, silent_ok=False, universal_newlines=True,
+             print_output=False):
+  data, retcode = RunShellWithReturnCode(command, print_output,
+                                         universal_newlines)
+  if retcode:
+    ErrorExit("Got error status from %s:\n%s" % (command, data))
+  if not silent_ok and not data:
+    ErrorExit("No output from %s" % command)
+  return data
+
+
+class VersionControlSystem(object):
+  """Abstract base class providing an interface to the VCS."""
+
+  def __init__(self, options):
+    """Constructor.
+
+    Args:
+      options: Command line options.
+    """
+    self.options = options
+
+  def GenerateDiff(self, args):
+    """Return the current diff as a string.
+
+    Args:
+      args: Extra arguments to pass to the diff command.
+    """
+    raise NotImplementedError(
+        "abstract method -- subclass %s must override" % self.__class__)
+
+  def GetUnknownFiles(self):
+    """Return a list of files unknown to the VCS."""
+    raise NotImplementedError(
+        "abstract method -- subclass %s must override" % self.__class__)
+
+  def CheckForUnknownFiles(self):
+    """Show an "are you sure?" prompt if there are unknown files."""
+    unknown_files = self.GetUnknownFiles()
+    if unknown_files:
+      print "The following files are not added to version control:"
+      for line in unknown_files:
+        print line
+      prompt = "Are you sure to continue?(y/N) "
+      answer = raw_input(prompt).strip()
+      if answer != "y":
+        ErrorExit("User aborted")
+
+  def GetBaseFile(self, filename):
+    """Get the content of the upstream version of a file.
+
+    Returns:
+      A tuple (base_content, new_content, is_binary, status)
+        base_content: The contents of the base file.
+        new_content: For text files, this is empty.  For binary files, this is
+          the contents of the new file, since the diff output won't contain
+          information to reconstruct the current file.
+        is_binary: True iff the file is binary.
+        status: The status of the file.
+    """
+
+    raise NotImplementedError(
+        "abstract method -- subclass %s must override" % self.__class__)
+
+
+  def GetBaseFiles(self, diff):
+    """Helper that calls GetBase file for each file in the patch.
+
+    Returns:
+      A dictionary that maps from filename to GetBaseFile's tuple.  Filenames
+      are retrieved based on lines that start with "Index:" or
+      "Property changes on:".
+    """
+    files = {}
+    for line in diff.splitlines(True):
+      if line.startswith('Index:') or line.startswith('Property changes on:'):
+        unused, filename = line.split(':', 1)
+        # On Windows if a file has property changes its filename uses '\'
+        # instead of '/'.
+        filename = filename.strip().replace('\\', '/')
+        files[filename] = self.GetBaseFile(filename)
+    return files
+
+
+  def UploadBaseFiles(self, issue, rpc_server, patch_list, patchset, options,
+                      files):
+    """Uploads the base files (and if necessary, the current ones as well)."""
+
+    def UploadFile(filename, file_id, content, is_binary, status, is_base):
+      """Uploads a file to the server."""
+      file_too_large = False
+      if is_base:
+        type = "base"
+      else:
+        type = "current"
+      if len(content) > MAX_UPLOAD_SIZE:
+        print ("Not uploading the %s file for %s because it's too large." %
+               (type, filename))
+        file_too_large = True
+        content = ""
+      checksum = md5.new(content).hexdigest()
+      if options.verbose > 0 and not file_too_large:
+        print "Uploading %s file for %s" % (type, filename)
+      url = "/%d/upload_content/%d/%d" % (int(issue), int(patchset), file_id)
+      form_fields = [("filename", filename),
+                     ("status", status),
+                     ("checksum", checksum),
+                     ("is_binary", str(is_binary)),
+                     ("is_current", str(not is_base)),
+                    ]
+      if file_too_large:
+        form_fields.append(("file_too_large", "1"))
+      if options.email:
+        form_fields.append(("user", options.email))
+      ctype, body = EncodeMultipartFormData(form_fields,
+                                            [("data", filename, content)])
+      response_body = rpc_server.Send(url, body,
+                                      content_type=ctype)
+      if not response_body.startswith("OK"):
+        StatusUpdate("  --> %s" % response_body)
+        sys.exit(1)
+
+    patches = dict()
+    [patches.setdefault(v, k) for k, v in patch_list]
+    for filename in patches.keys():
+      base_content, new_content, is_binary, status = files[filename]
+      file_id_str = patches.get(filename)
+      if file_id_str.find("nobase") != -1:
+        base_content = None
+        file_id_str = file_id_str[file_id_str.rfind("_") + 1:]
+      file_id = int(file_id_str)
+      if base_content != None:
+        UploadFile(filename, file_id, base_content, is_binary, status, True)
+      if new_content != None:
+        UploadFile(filename, file_id, new_content, is_binary, status, False)
+
+  def IsImage(self, filename):
+    """Returns true if the filename has an image extension."""
+    mimetype =  mimetypes.guess_type(filename)[0]
+    if not mimetype:
+      return False
+    return mimetype.startswith("image/")
+
+
+class SubversionVCS(VersionControlSystem):
+  """Implementation of the VersionControlSystem interface for Subversion."""
+
+  def __init__(self, options):
+    super(SubversionVCS, self).__init__(options)
+    if self.options.revision:
+      match = re.match(r"(\d+)(:(\d+))?", self.options.revision)
+      if not match:
+        ErrorExit("Invalid Subversion revision %s." % self.options.revision)
+      self.rev_start = match.group(1)
+      self.rev_end = match.group(3)
+    else:
+      self.rev_start = self.rev_end = None
+    # Cache output from "svn list -r REVNO dirname".
+    # Keys: dirname, Values: 2-tuple (ouput for start rev and end rev).
+    self.svnls_cache = {}
+    # SVN base URL is required to fetch files deleted in an older revision.
+    # Result is cached to not guess it over and over again in GetBaseFile().
+    required = self.options.download_base or self.options.revision is not None
+    self.svn_base = self._GuessBase(required)
+
+  def GuessBase(self, required):
+    """Wrapper for _GuessBase."""
+    return self.svn_base
+
+  def _GuessBase(self, required):
+    """Returns the SVN base URL.
+
+    Args:
+      required: If true, exits if the url can't be guessed, otherwise None is
+        returned.
+    """
+    info = RunShell(["svn", "info"])
+    for line in info.splitlines():
+      words = line.split()
+      if len(words) == 2 and words[0] == "URL:":
+        url = words[1]
+        scheme, netloc, path, params, query, fragment = urlparse.urlparse(url)
+        username, netloc = urllib.splituser(netloc)
+        if username:
+          logging.info("Removed username from base URL")
+        if netloc.endswith("svn.python.org"):
+          if netloc == "svn.python.org":
+            if path.startswith("/projects/"):
+              path = path[9:]
+          elif netloc != "pythondev@svn.python.org":
+            ErrorExit("Unrecognized Python URL: %s" % url)
+          base = "http://svn.python.org/view/*checkout*%s/" % path
+          logging.info("Guessed Python base = %s", base)
+        elif netloc.endswith("svn.collab.net"):
+          if path.startswith("/repos/"):
+            path = path[6:]
+          base = "http://svn.collab.net/viewvc/*checkout*%s/" % path
+          logging.info("Guessed CollabNet base = %s", base)
+        elif netloc.endswith(".googlecode.com"):
+          path = path + "/"
+          base = urlparse.urlunparse(("http", netloc, path, params,
+                                      query, fragment))
+          logging.info("Guessed Google Code base = %s", base)
+        else:
+          path = path + "/"
+          base = urlparse.urlunparse((scheme, netloc, path, params,
+                                      query, fragment))
+          logging.info("Guessed base = %s", base)
+        return base
+    if required:
+      ErrorExit("Can't find URL in output from svn info")
+    return None
+
+  def GenerateDiff(self, args):
+    cmd = ["svn", "diff"]
+    if self.options.revision:
+      cmd += ["-r", self.options.revision]
+    cmd.extend(args)
+    data = RunShell(cmd)
+    count = 0
+    for line in data.splitlines():
+      if line.startswith("Index:") or line.startswith("Property changes on:"):
+        count += 1
+        logging.info(line)
+    if not count:
+      ErrorExit("No valid patches found in output from svn diff")
+    return data
+
+  def _CollapseKeywords(self, content, keyword_str):
+    """Collapses SVN keywords."""
+    # svn cat translates keywords but svn diff doesn't. As a result of this
+    # behavior patching.PatchChunks() fails with a chunk mismatch error.
+    # This part was originally written by the Review Board development team
+    # who had the same problem (http://reviews.review-board.org/r/276/).
+    # Mapping of keywords to known aliases
+    svn_keywords = {
+      # Standard keywords
+      'Date':                ['Date', 'LastChangedDate'],
+      'Revision':            ['Revision', 'LastChangedRevision', 'Rev'],
+      'Author':              ['Author', 'LastChangedBy'],
+      'HeadURL':             ['HeadURL', 'URL'],
+      'Id':                  ['Id'],
+
+      # Aliases
+      'LastChangedDate':     ['LastChangedDate', 'Date'],
+      'LastChangedRevision': ['LastChangedRevision', 'Rev', 'Revision'],
+      'LastChangedBy':       ['LastChangedBy', 'Author'],
+      'URL':                 ['URL', 'HeadURL'],
+    }
+
+    def repl(m):
+       if m.group(2):
+         return "$%s::%s$" % (m.group(1), " " * len(m.group(3)))
+       return "$%s$" % m.group(1)
+    keywords = [keyword
+                for name in keyword_str.split(" ")
+                for keyword in svn_keywords.get(name, [])]
+    return re.sub(r"\$(%s):(:?)([^\$]+)\$" % '|'.join(keywords), repl, content)
+
+  def GetUnknownFiles(self):
+    status = RunShell(["svn", "status", "--ignore-externals"], silent_ok=True)
+    unknown_files = []
+    for line in status.split("\n"):
+      if line and line[0] == "?":
+        unknown_files.append(line)
+    return unknown_files
+
+  def ReadFile(self, filename):
+    """Returns the contents of a file."""
+    file = open(filename, 'rb')
+    result = ""
+    try:
+      result = file.read()
+    finally:
+      file.close()
+    return result
+
+  def GetStatus(self, filename):
+    """Returns the status of a file."""
+    if not self.options.revision:
+      status = RunShell(["svn", "status", "--ignore-externals", filename])
+      if not status:
+        ErrorExit("svn status returned no output for %s" % filename)
+      status_lines = status.splitlines()
+      # If file is in a cl, the output will begin with
+      # "\n--- Changelist 'cl_name':\n".  See
+      # http://svn.collab.net/repos/svn/trunk/notes/changelist-design.txt
+      if (len(status_lines) == 3 and
+          not status_lines[0] and
+          status_lines[1].startswith("--- Changelist")):
+        status = status_lines[2]
+      else:
+        status = status_lines[0]
+    # If we have a revision to diff against we need to run "svn list"
+    # for the old and the new revision and compare the results to get
+    # the correct status for a file.
+    else:
+      dirname, relfilename = os.path.split(filename)
+      if dirname not in self.svnls_cache:
+        cmd = ["svn", "list", "-r", self.rev_start, dirname or "."]
+        out, returncode = RunShellWithReturnCode(cmd)
+        if returncode:
+          ErrorExit("Failed to get status for %s." % filename)
+        old_files = out.splitlines()
+        args = ["svn", "list"]
+        if self.rev_end:
+          args += ["-r", self.rev_end]
+        cmd = args + [dirname or "."]
+        out, returncode = RunShellWithReturnCode(cmd)
+        if returncode:
+          ErrorExit("Failed to run command %s" % cmd)
+        self.svnls_cache[dirname] = (old_files, out.splitlines())
+      old_files, new_files = self.svnls_cache[dirname]
+      if relfilename in old_files and relfilename not in new_files:
+        status = "D   "
+      elif relfilename in old_files and relfilename in new_files:
+        status = "M   "
+      else:
+        status = "A   "
+    return status
+
+  def GetBaseFile(self, filename):
+    status = self.GetStatus(filename)
+    base_content = None
+    new_content = None
+
+    # If a file is copied its status will be "A  +", which signifies
+    # "addition-with-history".  See "svn st" for more information.  We need to
+    # upload the original file or else diff parsing will fail if the file was
+    # edited.
+    if status[0] == "A" and status[3] != "+":
+      # We'll need to upload the new content if we're adding a binary file
+      # since diff's output won't contain it.
+      mimetype = RunShell(["svn", "propget", "svn:mime-type", filename],
+                          silent_ok=True)
+      base_content = ""
+      is_binary = mimetype and not mimetype.startswith("text/")
+      if is_binary and self.IsImage(filename):
+        new_content = self.ReadFile(filename)
+    elif (status[0] in ("M", "D", "R") or
+          (status[0] == "A" and status[3] == "+") or  # Copied file.
+          (status[0] == " " and status[1] == "M")):  # Property change.
+      args = []
+      if self.options.revision:
+        url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
+      else:
+        # Don't change filename, it's needed later.
+        url = filename
+        args += ["-r", "BASE"]
+      cmd = ["svn"] + args + ["propget", "svn:mime-type", url]
+      mimetype, returncode = RunShellWithReturnCode(cmd)
+      if returncode:
+        # File does not exist in the requested revision.
+        # Reset mimetype, it contains an error message.
+        mimetype = ""
+      get_base = False
+      is_binary = mimetype and not mimetype.startswith("text/")
+      if status[0] == " ":
+        # Empty base content just to force an upload.
+        base_content = ""
+      elif is_binary:
+        if self.IsImage(filename):
+          get_base = True
+          if status[0] == "M":
+            if not self.rev_end:
+              new_content = self.ReadFile(filename)
+            else:
+              url = "%s/%s@%s" % (self.svn_base, filename, self.rev_end)
+              new_content = RunShell(["svn", "cat", url],
+                                     universal_newlines=True, silent_ok=True)
+        else:
+          base_content = ""
+      else:
+        get_base = True
+
+      if get_base:
+        if is_binary:
+          universal_newlines = False
+        else:
+          universal_newlines = True
+        if self.rev_start:
+          # "svn cat -r REV delete_file.txt" doesn't work. cat requires
+          # the full URL with "@REV" appended instead of using "-r" option.
+          url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
+          base_content = RunShell(["svn", "cat", url],
+                                  universal_newlines=universal_newlines,
+                                  silent_ok=True)
+        else:
+          base_content = RunShell(["svn", "cat", filename],
+                                  universal_newlines=universal_newlines,
+                                  silent_ok=True)
+        if not is_binary:
+          args = []
+          if self.rev_start:
+            url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
+          else:
+            url = filename
+            args += ["-r", "BASE"]
+          cmd = ["svn"] + args + ["propget", "svn:keywords", url]
+          keywords, returncode = RunShellWithReturnCode(cmd)
+          if keywords and not returncode:
+            base_content = self._CollapseKeywords(base_content, keywords)
+    else:
+      StatusUpdate("svn status returned unexpected output: %s" % status)
+      sys.exit(1)
+    return base_content, new_content, is_binary, status[0:5]
+
+
+class GitVCS(VersionControlSystem):
+  """Implementation of the VersionControlSystem interface for Git."""
+
+  def __init__(self, options):
+    super(GitVCS, self).__init__(options)
+    # Map of filename -> hash of base file.
+    self.base_hashes = {}
+
+  def GenerateDiff(self, extra_args):
+    # This is more complicated than svn's GenerateDiff because we must convert
+    # the diff output to include an svn-style "Index:" line as well as record
+    # the hashes of the base files, so we can upload them along with our diff.
+    if self.options.revision:
+      extra_args = [self.options.revision] + extra_args
+    gitdiff = RunShell(["git", "diff", "--full-index"] + extra_args)
+    svndiff = []
+    filecount = 0
+    filename = None
+    for line in gitdiff.splitlines():
+      match = re.match(r"diff --git a/(.*) b/.*$", line)
+      if match:
+        filecount += 1
+        filename = match.group(1)
+        svndiff.append("Index: %s\n" % filename)
+      else:
+        # The "index" line in a git diff looks like this (long hashes elided):
+        #   index 82c0d44..b2cee3f 100755
+        # We want to save the left hash, as that identifies the base file.
+        match = re.match(r"index (\w+)\.\.", line)
+        if match:
+          self.base_hashes[filename] = match.group(1)
+      svndiff.append(line + "\n")
+    if not filecount:
+      ErrorExit("No valid patches found in output from git diff")
+    return "".join(svndiff)
+
+  def GetUnknownFiles(self):
+    status = RunShell(["git", "ls-files", "--exclude-standard", "--others"],
+                      silent_ok=True)
+    return status.splitlines()
+
+  def GetBaseFile(self, filename):
+    hash = self.base_hashes[filename]
+    base_content = None
+    new_content = None
+    is_binary = False
+    if hash == "0" * 40:  # All-zero hash indicates no base file.
+      status = "A"
+      base_content = ""
+    else:
+      status = "M"
+      base_content, returncode = RunShellWithReturnCode(["git", "show", hash])
+      if returncode:
+        ErrorExit("Got error status from 'git show %s'" % hash)
+    return (base_content, new_content, is_binary, status)
+
+
+class MercurialVCS(VersionControlSystem):
+  """Implementation of the VersionControlSystem interface for Mercurial."""
+
+  def __init__(self, options, repo_dir):
+    super(MercurialVCS, self).__init__(options)
+    # Absolute path to repository (we can be in a subdir)
+    self.repo_dir = os.path.normpath(repo_dir)
+    # Compute the subdir
+    cwd = os.path.normpath(os.getcwd())
+    assert cwd.startswith(self.repo_dir)
+    self.subdir = cwd[len(self.repo_dir):].lstrip(r"\/")
+    if self.options.revision:
+      self.base_rev = self.options.revision
+    else:
+      self.base_rev = RunShell(["hg", "parent", "-q"]).split(':')[1].strip()
+
+  def _GetRelPath(self, filename):
+    """Get relative path of a file according to the current directory,
+    given its logical path in the repo."""
+    assert filename.startswith(self.subdir), filename
+    return filename[len(self.subdir):].lstrip(r"\/")
+
+  def GenerateDiff(self, extra_args):
+    # If no file specified, restrict to the current subdir
+    extra_args = extra_args or ["."]
+    cmd = ["hg", "diff", "--git", "-r", self.base_rev] + extra_args
+    data = RunShell(cmd, silent_ok=True)
+    svndiff = []
+    filecount = 0
+    for line in data.splitlines():
+      m = re.match("diff --git a/(\S+) b/(\S+)", line)
+      if m:
+        # Modify line to make it look like as it comes from svn diff.
+        # With this modification no changes on the server side are required
+        # to make upload.py work with Mercurial repos.
+        # NOTE: for proper handling of moved/copied files, we have to use
+        # the second filename.
+        filename = m.group(2)
+        svndiff.append("Index: %s" % filename)
+        svndiff.append("=" * 67)
+        filecount += 1
+        logging.info(line)
+      else:
+        svndiff.append(line)
+    if not filecount:
+      ErrorExit("No valid patches found in output from hg diff")
+    return "\n".join(svndiff) + "\n"
+
+  def GetUnknownFiles(self):
+    """Return a list of files unknown to the VCS."""
+    args = []
+    status = RunShell(["hg", "status", "--rev", self.base_rev, "-u", "."],
+        silent_ok=True)
+    unknown_files = []
+    for line in status.splitlines():
+      st, fn = line.split(" ", 1)
+      if st == "?":
+        unknown_files.append(fn)
+    return unknown_files
+
+  def GetBaseFile(self, filename):
+    # "hg status" and "hg cat" both take a path relative to the current subdir
+    # rather than to the repo root, but "hg diff" has given us the full path
+    # to the repo root.
+    base_content = ""
+    new_content = None
+    is_binary = False
+    oldrelpath = relpath = self._GetRelPath(filename)
+    # "hg status -C" returns two lines for moved/copied files, one otherwise
+    out = RunShell(["hg", "status", "-C", "--rev", self.base_rev, relpath])
+    out = out.splitlines()
+    # HACK: strip error message about missing file/directory if it isn't in
+    # the working copy
+    if out[0].startswith('%s: ' % relpath):
+      out = out[1:]
+    if len(out) > 1:
+      # Moved/copied => considered as modified, use old filename to
+      # retrieve base contents
+      oldrelpath = out[1].strip()
+      status = "M"
+    else:
+      status, _ = out[0].split(' ', 1)
+    if status != "A":
+      base_content = RunShell(["hg", "cat", "-r", self.base_rev, oldrelpath],
+        silent_ok=True)
+      is_binary = "\0" in base_content  # Mercurial's heuristic
+    if status != "R":
+      new_content = open(relpath, "rb").read()
+      is_binary = is_binary or "\0" in new_content
+    if is_binary and base_content:
+      # Fetch again without converting newlines
+      base_content = RunShell(["hg", "cat", "-r", self.base_rev, oldrelpath],
+        silent_ok=True, universal_newlines=False)
+    if not is_binary or not self.IsImage(relpath):
+      new_content = None
+    return base_content, new_content, is_binary, status
+
+
+# NOTE: The SplitPatch function is duplicated in engine.py, keep them in sync.
+def SplitPatch(data):
+  """Splits a patch into separate pieces for each file.
+
+  Args:
+    data: A string containing the output of svn diff.
+
+  Returns:
+    A list of 2-tuple (filename, text) where text is the svn diff output
+      pertaining to filename.
+  """
+  patches = []
+  filename = None
+  diff = []
+  for line in data.splitlines(True):
+    new_filename = None
+    if line.startswith('Index:'):
+      unused, new_filename = line.split(':', 1)
+      new_filename = new_filename.strip()
+    elif line.startswith('Property changes on:'):
+      unused, temp_filename = line.split(':', 1)
+      # When a file is modified, paths use '/' between directories, however
+      # when a property is modified '\' is used on Windows.  Make them the same
+      # otherwise the file shows up twice.
+      temp_filename = temp_filename.strip().replace('\\', '/')
+      if temp_filename != filename:
+        # File has property changes but no modifications, create a new diff.
+        new_filename = temp_filename
+    if new_filename:
+      if filename and diff:
+        patches.append((filename, ''.join(diff)))
+      filename = new_filename
+      diff = [line]
+      continue
+    if diff is not None:
+      diff.append(line)
+  if filename and diff:
+    patches.append((filename, ''.join(diff)))
+  return patches
+
+
+def UploadSeparatePatches(issue, rpc_server, patchset, data, options):
+  """Uploads a separate patch for each file in the diff output.
+
+  Returns a list of [patch_key, filename] for each file.
+  """
+  patches = SplitPatch(data)
+  rv = []
+  for patch in patches:
+    if len(patch[1]) > MAX_UPLOAD_SIZE:
+      print ("Not uploading the patch for " + patch[0] +
+             " because the file is too large.")
+      continue
+    form_fields = [("filename", patch[0])]
+    if not options.download_base:
+      form_fields.append(("content_upload", "1"))
+    files = [("data", "data.diff", patch[1])]
+    ctype, body = EncodeMultipartFormData(form_fields, files)
+    url = "/%d/upload_patch/%d" % (int(issue), int(patchset))
+    print "Uploading patch for " + patch[0]
+    response_body = rpc_server.Send(url, body, content_type=ctype)
+    lines = response_body.splitlines()
+    if not lines or lines[0] != "OK":
+      StatusUpdate("  --> %s" % response_body)
+      sys.exit(1)
+    rv.append([lines[1], patch[0]])
+  return rv
+
+
+def GuessVCS(options):
+  """Helper to guess the version control system.
+
+  This examines the current directory, guesses which VersionControlSystem
+  we're using, and returns an instance of the appropriate class.  Exit with an
+  error if we can't figure it out.
+
+  Returns:
+    A VersionControlSystem instance. Exits if the VCS can't be guessed.
+  """
+  # Mercurial has a command to get the base directory of a repository
+  # Try running it, but don't die if we don't have hg installed.
+  # NOTE: we try Mercurial first as it can sit on top of an SVN working copy.
+  try:
+    out, returncode = RunShellWithReturnCode(["hg", "root"])
+    if returncode == 0:
+      return MercurialVCS(options, out.strip())
+  except OSError, (errno, message):
+    if errno != 2:  # ENOENT -- they don't have hg installed.
+      raise
+
+  # Subversion has a .svn in all working directories.
+  if os.path.isdir('.svn'):
+    logging.info("Guessed VCS = Subversion")
+    return SubversionVCS(options)
+
+  # Git has a command to test if you're in a git tree.
+  # Try running it, but don't die if we don't have git installed.
+  try:
+    out, returncode = RunShellWithReturnCode(["git", "rev-parse",
+                                              "--is-inside-work-tree"])
+    if returncode == 0:
+      return GitVCS(options)
+  except OSError, (errno, message):
+    if errno != 2:  # ENOENT -- they don't have git installed.
+      raise
+
+  ErrorExit(("Could not guess version control system. "
+             "Are you in a working copy directory?"))
+
+
+def RealMain(argv, data=None):
+  """The real main function.
+
+  Args:
+    argv: Command line arguments.
+    data: Diff contents. If None (default) the diff is generated by
+      the VersionControlSystem implementation returned by GuessVCS().
+
+  Returns:
+    A 2-tuple (issue id, patchset id).
+    The patchset id is None if the base files are not uploaded by this
+    script (applies only to SVN checkouts).
+  """
+  logging.basicConfig(format=("%(asctime).19s %(levelname)s %(filename)s:"
+                              "%(lineno)s %(message)s "))
+  os.environ['LC_ALL'] = 'C'
+  options, args = parser.parse_args(argv[1:])
+  global verbosity
+  verbosity = options.verbose
+  if verbosity >= 3:
+    logging.getLogger().setLevel(logging.DEBUG)
+  elif verbosity >= 2:
+    logging.getLogger().setLevel(logging.INFO)
+  vcs = GuessVCS(options)
+  if isinstance(vcs, SubversionVCS):
+    # base field is only allowed for Subversion.
+    # Note: Fetching base files may become deprecated in future releases.
+    base = vcs.GuessBase(options.download_base)
+  else:
+    base = None
+  if not base and options.download_base:
+    options.download_base = True
+    logging.info("Enabled upload of base file")
+  if not options.assume_yes:
+    vcs.CheckForUnknownFiles()
+  if data is None:
+    data = vcs.GenerateDiff(args)
+  files = vcs.GetBaseFiles(data)
+  if verbosity >= 1:
+    print "Upload server:", options.server, "(change with -s/--server)"
+  if options.issue:
+    prompt = "Message describing this patch set: "
+  else:
+    prompt = "New issue subject: "
+  message = options.message or raw_input(prompt).strip()
+  if not message:
+    ErrorExit("A non-empty message is required")
+  rpc_server = GetRpcServer(options)
+  form_fields = [("subject", message)]
+  if base:
+    form_fields.append(("base", base))
+  if options.issue:
+    form_fields.append(("issue", str(options.issue)))
+  if options.email:
+    form_fields.append(("user", options.email))
+  if options.reviewers:
+    for reviewer in options.reviewers.split(','):
+      if "@" in reviewer and not reviewer.split("@")[1].count(".") == 1:
+        ErrorExit("Invalid email address: %s" % reviewer)
+    form_fields.append(("reviewers", options.reviewers))
+  if options.cc:
+    for cc in options.cc.split(','):
+      if "@" in cc and not cc.split("@")[1].count(".") == 1:
+        ErrorExit("Invalid email address: %s" % cc)
+    form_fields.append(("cc", options.cc))
+  description = options.description
+  if options.description_file:
+    if options.description:
+      ErrorExit("Can't specify description and description_file")
+    file = open(options.description_file, 'r')
+    description = file.read()
+    file.close()
+  if description:
+    form_fields.append(("description", description))
+  # Send a hash of all the base file so the server can determine if a copy
+  # already exists in an earlier patchset.
+  base_hashes = ""
+  for file, info in files.iteritems():
+    if not info[0] is None:
+      checksum = md5.new(info[0]).hexdigest()
+      if base_hashes:
+        base_hashes += "|"
+      base_hashes += checksum + ":" + file
+  form_fields.append(("base_hashes", base_hashes))
+  # If we're uploading base files, don't send the email before the uploads, so
+  # that it contains the file status.
+  if options.send_mail and options.download_base:
+    form_fields.append(("send_mail", "1"))
+  if not options.download_base:
+    form_fields.append(("content_upload", "1"))
+  if len(data) > MAX_UPLOAD_SIZE:
+    print "Patch is large, so uploading file patches separately."
+    uploaded_diff_file = []
+    form_fields.append(("separate_patches", "1"))
+  else:
+    uploaded_diff_file = [("data", "data.diff", data)]
+  ctype, body = EncodeMultipartFormData(form_fields, uploaded_diff_file)
+  response_body = rpc_server.Send("/upload", body, content_type=ctype)
+  patchset = None
+  if not options.download_base or not uploaded_diff_file:
+    lines = response_body.splitlines()
+    if len(lines) >= 2:
+      msg = lines[0]
+      patchset = lines[1].strip()
+      patches = [x.split(" ", 1) for x in lines[2:]]
+    else:
+      msg = response_body
+  else:
+    msg = response_body
+  StatusUpdate(msg)
+  if not response_body.startswith("Issue created.") and \
+  not response_body.startswith("Issue updated."):
+    sys.exit(0)
+  issue = msg[msg.rfind("/")+1:]
+
+  if not uploaded_diff_file:
+    result = UploadSeparatePatches(issue, rpc_server, patchset, data, options)
+    if not options.download_base:
+      patches = result
+
+  if not options.download_base:
+    vcs.UploadBaseFiles(issue, rpc_server, patches, patchset, options, files)
+    if options.send_mail:
+      rpc_server.Send("/" + issue + "/mail", payload="")
+  return issue, patchset
+
+
+def main():
+  try:
+    RealMain(sys.argv)
+  except KeyboardInterrupt:
+    print
+    StatusUpdate("Interrupted.")
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload_gtest.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload_gtest.py
new file mode 100755
index 00000000..be19ae80
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload_gtest.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+#
+# Copyright 2009, 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.
+
+"""upload_gtest.py v0.1.0 -- uploads a Google Test patch for review.
+
+This simple wrapper passes all command line flags and
+--cc=googletestframework@googlegroups.com to upload.py.
+
+USAGE: upload_gtest.py [options for upload.py]
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import sys
+
+CC_FLAG = '--cc='
+GTEST_GROUP = 'googletestframework@googlegroups.com'
+
+
+def main():
+  # Finds the path to upload.py, assuming it is in the same directory
+  # as this file.
+  my_dir = os.path.dirname(os.path.abspath(__file__))
+  upload_py_path = os.path.join(my_dir, 'upload.py')
+
+  # Adds Google Test discussion group to the cc line if it's not there
+  # already.
+  upload_py_argv = [upload_py_path]
+  found_cc_flag = False
+  for arg in sys.argv[1:]:
+    if arg.startswith(CC_FLAG):
+      found_cc_flag = True
+      cc_line = arg[len(CC_FLAG):]
+      cc_list = [addr for addr in cc_line.split(',') if addr]
+      if GTEST_GROUP not in cc_list:
+        cc_list.append(GTEST_GROUP)
+      upload_py_argv.append(CC_FLAG + ','.join(cc_list))
+    else:
+      upload_py_argv.append(arg)
+
+  if not found_cc_flag:
+    upload_py_argv.append(CC_FLAG + GTEST_GROUP)
+
+  # Invokes upload.py with the modified command line flags.
+  os.execv(upload_py_path, upload_py_argv)
+
+
+if __name__ == '__main__':
+  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-all.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-all.cc
new file mode 100644
index 00000000..0a9cee52
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-all.cc
@@ -0,0 +1,48 @@
+// 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.
+//
+// Author: mheule@google.com (Markus Heule)
+//
+// Google C++ Testing Framework (Google Test)
+//
+// Sometimes it's desirable to build Google Test by compiling a single file.
+// This file serves this purpose.
+
+// This line ensures that gtest.h can be compiled on its own, even
+// when it's fused.
+#include "gtest/gtest.h"
+
+// The following lines pull in the real gtest *.cc files.
+#include "src/gtest.cc"
+#include "src/gtest-death-test.cc"
+#include "src/gtest-filepath.cc"
+#include "src/gtest-port.cc"
+#include "src/gtest-printers.cc"
+#include "src/gtest-test-part.cc"
+#include "src/gtest-typed-test.cc"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-death-test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-death-test.cc
new file mode 100644
index 00000000..a01a3698
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-death-test.cc
@@ -0,0 +1,1342 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev)
+//
+// This file implements death tests.
+
+#include "gtest/gtest-death-test.h"
+#include "gtest/internal/gtest-port.h"
+#include "gtest/internal/custom/gtest.h"
+
+#if GTEST_HAS_DEATH_TEST
+
+# if GTEST_OS_MAC
+#  include <crt_externs.h>
+# endif  // GTEST_OS_MAC
+
+# include <errno.h>
+# include <fcntl.h>
+# include <limits.h>
+
+# if GTEST_OS_LINUX
+#  include <signal.h>
+# endif  // GTEST_OS_LINUX
+
+# include <stdarg.h>
+
+# if GTEST_OS_WINDOWS
+#  include <windows.h>
+# else
+#  include <sys/mman.h>
+#  include <sys/wait.h>
+# endif  // GTEST_OS_WINDOWS
+
+# if GTEST_OS_QNX
+#  include <spawn.h>
+# endif  // GTEST_OS_QNX
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+#include "gtest/gtest-message.h"
+#include "gtest/internal/gtest-string.h"
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick exists to
+// prevent the accidental inclusion of gtest-internal-inl.h in the
+// user's code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+namespace testing {
+
+// Constants.
+
+// The default death test style.
+static const char kDefaultDeathTestStyle[] = "fast";
+
+GTEST_DEFINE_string_(
+    death_test_style,
+    internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),
+    "Indicates how to run a death test in a forked child process: "
+    "\"threadsafe\" (child process re-executes the test binary "
+    "from the beginning, running only the specific death test) or "
+    "\"fast\" (child process runs the death test immediately "
+    "after forking).");
+
+GTEST_DEFINE_bool_(
+    death_test_use_fork,
+    internal::BoolFromGTestEnv("death_test_use_fork", false),
+    "Instructs to use fork()/_exit() instead of clone() in death tests. "
+    "Ignored and always uses fork() on POSIX systems where clone() is not "
+    "implemented. Useful when running under valgrind or similar tools if "
+    "those do not support clone(). Valgrind 3.3.1 will just fail if "
+    "it sees an unsupported combination of clone() flags. "
+    "It is not recommended to use this flag w/o valgrind though it will "
+    "work in 99% of the cases. Once valgrind is fixed, this flag will "
+    "most likely be removed.");
+
+namespace internal {
+GTEST_DEFINE_string_(
+    internal_run_death_test, "",
+    "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 "
+    "death test.  FOR INTERNAL USE ONLY.");
+}  // namespace internal
+
+#if GTEST_HAS_DEATH_TEST
+
+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
+static bool g_in_fast_death_test_child = false;
+# endif
+
+// Returns a Boolean value indicating whether the caller is currently
+// executing in the context of the death test child process.  Tools such as
+// Valgrind heap checkers may need this to modify their behavior in death
+// 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
+
+  // On Windows, death tests are thread-safe regardless of the value of the
+  // death_test_style flag.
+  return !GTEST_FLAG(internal_run_death_test).empty();
+
+# else
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe")
+    return !GTEST_FLAG(internal_run_death_test).empty();
+  else
+    return g_in_fast_death_test_child;
+#endif
+}
+
+}  // namespace internal
+
+// ExitedWithCode constructor.
+ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
+}
+
+// ExitedWithCode function-call operator.
+bool ExitedWithCode::operator()(int exit_status) const {
+# if GTEST_OS_WINDOWS
+
+  return exit_status == exit_code_;
+
+# else
+
+  return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
+
+# endif  // GTEST_OS_WINDOWS
+}
+
+# if !GTEST_OS_WINDOWS
+// KilledBySignal constructor.
+KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
+}
+
+// KilledBySignal function-call operator.
+bool KilledBySignal::operator()(int exit_status) const {
+#  if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
+  {
+    bool result;
+    if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
+      return result;
+    }
+  }
+#  endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
+  return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
+}
+# endif  // !GTEST_OS_WINDOWS
+
+namespace internal {
+
+// Utilities needed for death tests.
+
+// Generates a textual description of a given exit code, in the format
+// specified by wait(2).
+static std::string ExitSummary(int exit_code) {
+  Message m;
+
+# if GTEST_OS_WINDOWS
+
+  m << "Exited with exit status " << exit_code;
+
+# else
+
+  if (WIFEXITED(exit_code)) {
+    m << "Exited with exit status " << WEXITSTATUS(exit_code);
+  } else if (WIFSIGNALED(exit_code)) {
+    m << "Terminated by signal " << WTERMSIG(exit_code);
+  }
+#  ifdef WCOREDUMP
+  if (WCOREDUMP(exit_code)) {
+    m << " (core dumped)";
+  }
+#  endif
+# endif  // GTEST_OS_WINDOWS
+
+  return m.GetString();
+}
+
+// Returns true if exit_status describes a process that was terminated
+// by a signal, or exited normally with a nonzero exit code.
+bool ExitedUnsuccessfully(int exit_status) {
+  return !ExitedWithCode(0)(exit_status);
+}
+
+# if !GTEST_OS_WINDOWS
+// 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
+// caller not to pass a thread_count of 1.
+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)
+    msg << "couldn't detect the number of threads.";
+  else
+    msg << "detected " << thread_count << " threads.";
+  return msg.GetString();
+}
+# endif  // !GTEST_OS_WINDOWS
+
+// Flag characters for reporting a death test that did not die.
+static const char kDeathTestLived = 'L';
+static const char kDeathTestReturned = 'R';
+static const char kDeathTestThrew = 'T';
+static const char kDeathTestInternalError = 'I';
+
+// 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;
+// RETURNED means that the test statement attempted to execute a return
+// statement, which is not allowed; THREW means that the test statement
+// returned control by throwing an exception.  IN_PROGRESS means the test
+// has not yet concluded.
+// TODO(vladl@google.com): Unify names and possibly values for
+// AbortReason, DeathTestOutcome, and flag characters above.
+enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
+
+// Routine for aborting the program which is safe to call from an
+// exec-style death test child process, in which case the error
+// 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.
+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 != NULL) {
+    FILE* parent = posix::FDOpen(flag->write_fd(), "w");
+    fputc(kDeathTestInternalError, parent);
+    fprintf(parent, "%s", message.c_str());
+    fflush(parent);
+    _exit(1);
+  } else {
+    fprintf(stderr, "%s", message.c_str());
+    fflush(stderr);
+    posix::Abort();
+  }
+}
+
+// A replacement for CHECK that calls DeathTestAbort if the assertion
+// fails.
+# define GTEST_DEATH_TEST_CHECK_(expression) \
+  do { \
+    if (!::testing::internal::IsTrue(expression)) { \
+      DeathTestAbort( \
+          ::std::string("CHECK failed: File ") + __FILE__ +  ", line " \
+          + ::testing::internal::StreamableToString(__LINE__) + ": " \
+          + #expression); \
+    } \
+  } while (::testing::internal::AlwaysFalse())
+
+// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for
+// evaluating any system call that fulfills two conditions: it must return
+// -1 on failure, and set errno to EINTR when it is interrupted and
+// should be tried again.  The macro expands to a loop that repeatedly
+// evaluates the expression as long as it evaluates to -1 and sets
+// errno to EINTR.  If the expression evaluates to -1 but errno is
+// something other than EINTR, DeathTestAbort is called.
+# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \
+  do { \
+    int gtest_retval; \
+    do { \
+      gtest_retval = (expression); \
+    } while (gtest_retval == -1 && errno == EINTR); \
+    if (gtest_retval == -1) { \
+      DeathTestAbort( \
+          ::std::string("CHECK failed: File ") + __FILE__ + ", line " \
+          + ::testing::internal::StreamableToString(__LINE__) + ": " \
+          + #expression + " != -1"); \
+    } \
+  } while (::testing::internal::AlwaysFalse())
+
+// Returns the message describing the last system error in errno.
+std::string GetLastErrnoDescription() {
+    return errno == 0 ? "" : posix::StrError(errno);
+}
+
+// This is called from a death test parent process to read a failure
+// message from the death test child process and log it with the FATAL
+// severity. On Windows, the message is read from a pipe handle. On other
+// platforms, it is read from a file descriptor.
+static void FailFromInternalError(int fd) {
+  Message error;
+  char buffer[256];
+  int num_read;
+
+  do {
+    while ((num_read = posix::Read(fd, buffer, 255)) > 0) {
+      buffer[num_read] = '\0';
+      error << buffer;
+    }
+  } while (num_read == -1 && errno == EINTR);
+
+  if (num_read == 0) {
+    GTEST_LOG_(FATAL) << error.GetString();
+  } else {
+    const int last_error = errno;
+    GTEST_LOG_(FATAL) << "Error while reading death test internal: "
+                      << GetLastErrnoDescription() << " [" << last_error << "]";
+  }
+}
+
+// Death test constructor.  Increments the running death test count
+// for the current test.
+DeathTest::DeathTest() {
+  TestInfo* const info = GetUnitTestImpl()->current_test_info();
+  if (info == NULL) {
+    DeathTestAbort("Cannot run a death test outside of a TEST or "
+                   "TEST_F construct");
+  }
+}
+
+// Creates and returns a death test by dispatching to the current
+// death test factory.
+bool DeathTest::Create(const char* statement, const RE* regex,
+                       const char* file, int line, DeathTest** test) {
+  return GetUnitTestImpl()->death_test_factory()->Create(
+      statement, regex, file, line, test);
+}
+
+const char* DeathTest::LastMessage() {
+  return last_death_test_message_.c_str();
+}
+
+void DeathTest::set_last_death_test_message(const std::string& message) {
+  last_death_test_message_ = message;
+}
+
+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, const RE* a_regex)
+      : statement_(a_statement),
+        regex_(a_regex),
+        spawned_(false),
+        status_(-1),
+        outcome_(IN_PROGRESS),
+        read_fd_(-1),
+        write_fd_(-1) {}
+
+  // read_fd_ is expected to be closed and cleared by a derived class.
+  ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
+
+  void Abort(AbortReason reason);
+  virtual bool Passed(bool status_ok);
+
+  const char* statement() const { return statement_; }
+  const RE* regex() const { return regex_; }
+  bool spawned() const { return spawned_; }
+  void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
+  int status() const { return status_; }
+  void set_status(int a_status) { status_ = a_status; }
+  DeathTestOutcome outcome() const { return outcome_; }
+  void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; }
+  int read_fd() const { return read_fd_; }
+  void set_read_fd(int fd) { read_fd_ = fd; }
+  int write_fd() const { return write_fd_; }
+  void set_write_fd(int fd) { write_fd_ = fd; }
+
+  // Called in the parent process only. Reads the result code of the death
+  // test child process via a pipe, interprets it to set the outcome_
+  // member, and closes read_fd_.  Outputs diagnostics and terminates in
+  // case of unexpected codes.
+  void ReadAndInterpretStatusByte();
+
+ 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_;
+  // The regular expression which test output must match.  DeathTestImpl
+  // doesn't own this object and should not attempt to delete it.
+  const RE* const regex_;
+  // True if the death test child process has been successfully spawned.
+  bool spawned_;
+  // The exit status of the child process.
+  int status_;
+  // How the death test concluded.
+  DeathTestOutcome outcome_;
+  // Descriptor to the read end of the pipe to the child process.  It is
+  // always -1 in the child process.  The child keeps its write end of the
+  // pipe in write_fd_.
+  int read_fd_;
+  // Descriptor to the child's write end of the pipe to the parent process.
+  // It is always -1 in the parent process.  The parent keeps its end of the
+  // pipe in read_fd_.
+  int write_fd_;
+};
+
+// Called in the parent process only. Reads the result code of the death
+// test child process via a pipe, interprets it to set the outcome_
+// member, and closes read_fd_.  Outputs diagnostics and terminates in
+// case of unexpected codes.
+void DeathTestImpl::ReadAndInterpretStatusByte() {
+  char flag;
+  int bytes_read;
+
+  // The read() here blocks until data is available (signifying the
+  // failure of the death test) or until the pipe is closed (signifying
+  // its success), so it's okay to call this in the parent before
+  // the child process has exited.
+  do {
+    bytes_read = posix::Read(read_fd(), &flag, 1);
+  } while (bytes_read == -1 && errno == EINTR);
+
+  if (bytes_read == 0) {
+    set_outcome(DIED);
+  } else if (bytes_read == 1) {
+    switch (flag) {
+      case kDeathTestReturned:
+        set_outcome(RETURNED);
+        break;
+      case kDeathTestThrew:
+        set_outcome(THREW);
+        break;
+      case kDeathTestLived:
+        set_outcome(LIVED);
+        break;
+      case kDeathTestInternalError:
+        FailFromInternalError(read_fd());  // Does not return.
+        break;
+      default:
+        GTEST_LOG_(FATAL) << "Death test child process reported "
+                          << "unexpected status byte ("
+                          << static_cast<unsigned int>(flag) << ")";
+    }
+  } else {
+    GTEST_LOG_(FATAL) << "Read from death test child process failed: "
+                      << GetLastErrnoDescription();
+  }
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
+  set_read_fd(-1);
+}
+
+// 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
+// calls _exit(1).
+void DeathTestImpl::Abort(AbortReason reason) {
+  // The parent process considers the death test to be a failure if
+  // it finds any data in our pipe.  So, here we write a single flag byte
+  // to the pipe, then exit.
+  const char status_ch =
+      reason == TEST_DID_NOT_DIE ? kDeathTestLived :
+      reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;
+
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
+  // We are leaking the descriptor here because on some platforms (i.e.,
+  // when built as Windows DLL), destructors of global objects will still
+  // run after calling _exit(). On such systems, write_fd_ will be
+  // indirectly closed from the destructor of UnitTestImpl, causing double
+  // close if it is also closed here. On debug configurations, double close
+  // may assert. As there are no in-process buffers to flush here, we are
+  // relying on the OS to close the descriptor after the process terminates
+  // when the destructors are not run.
+  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
+}
+
+// Returns an indented copy of stderr output for a death test.
+// This makes distinguishing death test output lines from regular log lines
+// much easier.
+static ::std::string FormatDeathTestOutput(const ::std::string& output) {
+  ::std::string ret;
+  for (size_t at = 0; ; ) {
+    const size_t line_end = output.find('\n', at);
+    ret += "[  DEATH   ] ";
+    if (line_end == ::std::string::npos) {
+      ret += output.substr(at);
+      break;
+    }
+    ret += output.substr(at, line_end + 1 - at);
+    at = line_end + 1;
+  }
+  return ret;
+}
+
+// Assesses the success or failure of a death test, using both private
+// members which have previously been set, and one argument:
+//
+// Private data members:
+//   outcome:  An enumeration describing how the death test
+//             concluded: DIED, LIVED, THREW, or RETURNED.  The death test
+//             fails in the latter three cases.
+//   status:   The exit status of the child process. On *nix, it is in the
+//             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.
+//   regex:    A regular expression object to be applied to
+//             the test's captured standard error output; the death test
+//             fails if it does not match.
+//
+// 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 iff 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 = GetCapturedStderr();
+
+  bool success = false;
+  Message buffer;
+
+  buffer << "Death test: " << statement() << "\n";
+  switch (outcome()) {
+    case LIVED:
+      buffer << "    Result: failed to die.\n"
+             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+      break;
+    case THREW:
+      buffer << "    Result: threw an exception.\n"
+             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+      break;
+    case RETURNED:
+      buffer << "    Result: illegal return in test statement.\n"
+             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+      break;
+    case DIED:
+      if (status_ok) {
+        const bool matched = RE::PartialMatch(error_message.c_str(), *regex());
+        if (matched) {
+          success = true;
+        } else {
+          buffer << "    Result: died but not with expected error.\n"
+                 << "  Expected: " << regex()->pattern() << "\n"
+                 << "Actual msg:\n" << FormatDeathTestOutput(error_message);
+        }
+      } else {
+        buffer << "    Result: died but not with expected exit code:\n"
+               << "            " << ExitSummary(status()) << "\n"
+               << "Actual msg:\n" << FormatDeathTestOutput(error_message);
+      }
+      break;
+    case IN_PROGRESS:
+    default:
+      GTEST_LOG_(FATAL)
+          << "DeathTest::Passed somehow called before conclusion of test";
+  }
+
+  DeathTest::set_last_death_test_message(buffer.GetString());
+  return success;
+}
+
+# if GTEST_OS_WINDOWS
+// WindowsDeathTest implements death tests on Windows. Due to the
+// specifics of starting new processes on Windows, death tests there are
+// always threadsafe, and Google Test considers the
+// --gtest_death_test_style=fast setting to be equivalent to
+// --gtest_death_test_style=threadsafe there.
+//
+// A few implementation notes:  Like the Linux version, the Windows
+// implementation uses pipes for child-to-parent communication. But due to
+// the specifics of pipes on Windows, some extra steps are required:
+//
+// 1. The parent creates a communication pipe and stores handles to both
+//    ends of it.
+// 2. The parent starts the child and provides it with the information
+//    necessary to acquire the handle to the write end of the pipe.
+// 3. The child acquires the write end of the pipe and signals the parent
+//    using a Windows event.
+// 4. Now the parent can release the write end of the pipe on its side. If
+//    this is done before step 3, the object's reference count goes down to
+//    0 and it is destroyed, preventing the child from acquiring it. The
+//    parent now has to release it, or read operations on the read end of
+//    the pipe will not return when the child terminates.
+// 5. The parent reads child's output through the pipe (outcome code and
+//    any possible error messages) from the pipe, and its stderr and then
+//    determines whether to fail the test.
+//
+// Note: to distinguish Win32 API calls from the local method and function
+// calls, the former are explicitly resolved in the global namespace.
+//
+class WindowsDeathTest : public DeathTestImpl {
+ public:
+  WindowsDeathTest(const char* a_statement,
+                   const RE* a_regex,
+                   const char* file,
+                   int line)
+      : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {}
+
+  // All of these virtual functions are inherited from DeathTest.
+  virtual int Wait();
+  virtual TestRole AssumeRole();
+
+ 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_;
+  // Handle to the write end of the pipe to the child process.
+  AutoHandle write_handle_;
+  // Child process handle.
+  AutoHandle child_handle_;
+  // Event the child process uses to signal the parent that it has
+  // acquired the handle to the write end of the pipe. After seeing this
+  // event the parent can release its own handles to make sure its
+  // ReadFile() calls return when the child terminates.
+  AutoHandle event_handle_;
+};
+
+// 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 WindowsDeathTest::Wait() {
+  if (!spawned())
+    return 0;
+
+  // Wait until the child either signals that it has acquired the write end
+  // of the pipe or it dies.
+  const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() };
+  switch (::WaitForMultipleObjects(2,
+                                   wait_handles,
+                                   FALSE,  // Waits for any of the handles.
+                                   INFINITE)) {
+    case WAIT_OBJECT_0:
+    case WAIT_OBJECT_0 + 1:
+      break;
+    default:
+      GTEST_DEATH_TEST_CHECK_(false);  // Should not get here.
+  }
+
+  // The child has acquired the write end of the pipe or exited.
+  // We release the handle on our side and continue.
+  write_handle_.Reset();
+  event_handle_.Reset();
+
+  ReadAndInterpretStatusByte();
+
+  // Waits for the child process to exit if it haven't already. This
+  // returns immediately if the child has already exited, regardless of
+  // whether previous calls to WaitForMultipleObjects synchronized on this
+  // handle or not.
+  GTEST_DEATH_TEST_CHECK_(
+      WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(),
+                                             INFINITE));
+  DWORD status_code;
+  GTEST_DEATH_TEST_CHECK_(
+      ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE);
+  child_handle_.Reset();
+  set_status(static_cast<int>(status_code));
+  return status();
+}
+
+// The AssumeRole process for a Windows 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 WindowsDeathTest::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 != NULL) {
+    // ParseInternalRunDeathTestFlag() has performed all the necessary
+    // processing.
+    set_write_fd(flag->write_fd());
+    return EXECUTE_TEST;
+  }
+
+  // WindowsDeathTest uses an anonymous pipe to communicate results of
+  // a death test.
+  SECURITY_ATTRIBUTES handles_are_inheritable = {
+    sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
+  HANDLE read_handle, write_handle;
+  GTEST_DEATH_TEST_CHECK_(
+      ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
+                   0)  // Default buffer size.
+      != FALSE);
+  set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle),
+                                O_RDONLY));
+  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.
+      NULL));  // The even is unnamed.
+  GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL);
+  const std::string filter_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" +
+      info->test_case_name() + "." + info->name();
+  const std::string internal_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
+      "=" + file_ + "|" + StreamableToString(line_) + "|" +
+      StreamableToString(death_test_index) + "|" +
+      StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
+      // size_t has the same width as pointers on both 32-bit and 64-bit
+      // Windows platforms.
+      // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
+      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) +
+      "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
+
+  char executable_path[_MAX_PATH + 1];  // NOLINT
+  GTEST_DEATH_TEST_CHECK_(
+      _MAX_PATH + 1 != ::GetModuleFileNameA(NULL,
+                                            executable_path,
+                                            _MAX_PATH));
+
+  std::string command_line =
+      std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
+      internal_flag + "\"";
+
+  DeathTest::set_last_death_test_message("");
+
+  CaptureStderr();
+  // Flush the log buffers since the log streams are shared with the child.
+  FlushInfoLog();
+
+  // The child process will share the standard handles with the parent.
+  STARTUPINFOA startup_info;
+  memset(&startup_info, 0, sizeof(STARTUPINFO));
+  startup_info.dwFlags = STARTF_USESTDHANDLES;
+  startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE);
+  startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
+  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()),
+      NULL,   // Retuned process handle is not inheritable.
+      NULL,   // Retuned thread handle is not inheritable.
+      TRUE,   // Child inherits all inheritable handles (for write_handle_).
+      0x0,    // Default creation flags.
+      NULL,   // 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;
+}
+# else  // We are not on Windows.
+
+// 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, const RE* regex);
+
+  // All of these virtual functions are inherited from DeathTest.
+  virtual int Wait();
+
+ protected:
+  void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
+
+ private:
+  // PID of child process during death test; 0 in the child process itself.
+  pid_t child_pid_;
+};
+
+// Constructs a ForkingDeathTest.
+ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex)
+    : DeathTestImpl(a_statement, a_regex),
+      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
+// outcome data member.
+int ForkingDeathTest::Wait() {
+  if (!spawned())
+    return 0;
+
+  ReadAndInterpretStatusByte();
+
+  int status_value;
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
+  set_status(status_value);
+  return status_value;
+}
+
+// A concrete death test class that forks, then immediately runs the test
+// in the child process.
+class NoExecDeathTest : public ForkingDeathTest {
+ public:
+  NoExecDeathTest(const char* a_statement, const RE* a_regex) :
+      ForkingDeathTest(a_statement, a_regex) { }
+  virtual TestRole AssumeRole();
+};
+
+// The AssumeRole process for a fork-and-run death test.  It implements a
+// straightforward fork, with a simple pipe to transmit the status byte.
+DeathTest::TestRole NoExecDeathTest::AssumeRole() {
+  const size_t thread_count = GetThreadCount();
+  if (thread_count != 1) {
+    GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
+  }
+
+  int pipe_fd[2];
+  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
+
+  DeathTest::set_last_death_test_message("");
+  CaptureStderr();
+  // When we fork the process below, the log file buffers are copied, but the
+  // file descriptors are shared.  We flush all log files here so that closing
+  // the file descriptors in the child process doesn't throw off the
+  // synchronization between descriptors and buffers in the parent process.
+  // This is as close to the fork as possible to avoid a race condition in case
+  // there are multiple threads running before the death test, and another
+  // thread writes to the log file.
+  FlushInfoLog();
+
+  const pid_t child_pid = fork();
+  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
+  set_child_pid(child_pid);
+  if (child_pid == 0) {
+    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0]));
+    set_write_fd(pipe_fd[1]);
+    // Redirects all logging to stderr in the child process to prevent
+    // concurrent writes to the log files.  We capture stderr in the parent
+    // process and append the child process' output to a log.
+    LogToStderr();
+    // Event forwarding to the listeners of event listener API mush be shut
+    // down in death test subprocesses.
+    GetUnitTestImpl()->listeners()->SuppressEventForwarding();
+    g_in_fast_death_test_child = true;
+    return EXECUTE_TEST;
+  } else {
+    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
+    set_read_fd(pipe_fd[0]);
+    set_spawned(true);
+    return OVERSEE_TEST;
+  }
+}
+
+// A concrete death test class that forks and re-executes the main
+// program from the beginning, with command-line flags set that cause
+// only this specific death test to be run.
+class ExecDeathTest : public ForkingDeathTest {
+ public:
+  ExecDeathTest(const char* a_statement, const RE* a_regex,
+                const char* file, int line) :
+      ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { }
+  virtual TestRole AssumeRole();
+ private:
+  static ::std::vector<testing::internal::string>
+  GetArgvsForDeathTestChildProcess() {
+    ::std::vector<testing::internal::string> args = GetInjectableArgvs();
+#  if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
+    ::std::vector<testing::internal::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_)
+    return args;
+  }
+  // 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_;
+};
+
+// Utility class for accumulating command-line arguments.
+class Arguments {
+ public:
+  Arguments() {
+    args_.push_back(NULL);
+  }
+
+  ~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];
+  }
+
+ private:
+  std::vector<char*> args_;
+};
+
+// A struct that encompasses the arguments to the child process of a
+// threadsafe-style death test process.
+struct ExecDeathTestArgs {
+  char* const* argv;  // Command-line arguments for the child's call to exec
+  int close_fd;       // File descriptor to close; the read end of a pipe
+};
+
+#  if GTEST_OS_MAC
+inline char** GetEnviron() {
+  // When Google Test is built as a framework on MacOS X, the environ variable
+  // is unavailable. Apple's documentation (man environ) recommends using
+  // _NSGetEnviron() instead.
+  return *_NSGetEnviron();
+}
+#  else
+// Some POSIX platforms expect you to declare environ. extern "C" makes
+// it reside in the global namespace.
+extern "C" char** environ;
+inline char** GetEnviron() { return environ; }
+#  endif  // GTEST_OS_MAC
+
+#  if !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.
+static int ExecDeathTestChildMain(void* child_arg) {
+  ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
+
+  // We need to execute the test program in the same environment where
+  // it was originally invoked.  Therefore we change to the original
+  // working directory first.
+  const char* const original_dir =
+      UnitTest::GetInstance()->original_working_dir();
+  // We can safely call chdir() as it's a direct system call.
+  if (chdir(original_dir) != 0) {
+    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
+                   GetLastErrnoDescription());
+    return EXIT_FAILURE;
+  }
+
+  // We can safely call execve() as it's a direct system call.  We
+  // cannot use execvp() as it's a libc function and thus potentially
+  // unsafe.  Since execve() doesn't search the PATH, the user must
+  // invoke the test program via a valid path that contains at least
+  // one path separator.
+  execve(args->argv[0], args->argv, GetEnviron());
+  DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " +
+                 original_dir + " failed: " +
+                 GetLastErrnoDescription());
+  return EXIT_FAILURE;
+}
+#  endif  // !GTEST_OS_QNX
+
+// Two utility routines that together determine the direction the stack
+// grows.
+// This could be accomplished more elegantly by a single recursive
+// function, but we want to guard against the unlikely possibility of
+// a smart compiler optimizing the recursion away.
+//
+// GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining
+// StackLowerThanAddress into StackGrowsDown, which then doesn't give
+// correct answer.
+void StackLowerThanAddress(const void* ptr, bool* result) GTEST_NO_INLINE_;
+void StackLowerThanAddress(const void* ptr, bool* result) {
+  int dummy;
+  *result = (&dummy < ptr);
+}
+
+// Make sure AddressSanitizer does not tamper with the stack here.
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+bool StackGrowsDown() {
+  int dummy;
+  bool result;
+  StackLowerThanAddress(&dummy, &result);
+  return result;
+}
+
+// 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
+// implementation uses fork(2) + exec.  On systems where clone(2) is
+// available, it is used instead, being slightly more thread-safe.  On QNX,
+// fork supports only single-threaded environments, so this function uses
+// spawn(2) there instead.  The function dies with an error message if
+// anything goes wrong.
+static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
+  ExecDeathTestArgs args = { argv, close_fd };
+  pid_t child_pid = -1;
+
+#  if GTEST_OS_QNX
+  // Obtains the current directory and sets it to be closed in the child
+  // process.
+  const int cwd_fd = open(".", O_RDONLY);
+  GTEST_DEATH_TEST_CHECK_(cwd_fd != -1);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC));
+  // We need to execute the test program in the same environment where
+  // it was originally invoked.  Therefore we change to the original
+  // working directory first.
+  const char* const original_dir =
+      UnitTest::GetInstance()->original_working_dir();
+  // We can safely call chdir() as it's a direct system call.
+  if (chdir(original_dir) != 0) {
+    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
+                   GetLastErrnoDescription());
+    return EXIT_FAILURE;
+  }
+
+  int fd_flags;
+  // Set close_fd to be closed after spawn.
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD));
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD,
+                                        fd_flags | FD_CLOEXEC));
+  struct inheritance inherit = {0};
+  // spawn is a system call.
+  child_pid = spawn(args.argv[0], 0, NULL, &inherit, args.argv, GetEnviron());
+  // Restores the current working directory.
+  GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
+
+#  else   // GTEST_OS_QNX
+#   if GTEST_OS_LINUX
+  // When a SIGPROF signal is received while fork() or clone() are executing,
+  // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
+  // it after the call to fork()/clone() is complete.
+  struct sigaction saved_sigprof_action;
+  struct sigaction ignore_sigprof_action;
+  memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action));
+  sigemptyset(&ignore_sigprof_action.sa_mask);
+  ignore_sigprof_action.sa_handler = SIG_IGN;
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction(
+      SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
+#   endif  // GTEST_OS_LINUX
+
+#   if GTEST_HAS_CLONE
+  const bool use_fork = GTEST_FLAG(death_test_use_fork);
+
+  if (!use_fork) {
+    static const bool stack_grows_down = StackGrowsDown();
+    const size_t stack_size = getpagesize();
+    // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
+    void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE,
+                             MAP_ANON | MAP_PRIVATE, -1, 0);
+    GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
+
+    // Maximum stack alignment in bytes:  For a downward-growing stack, this
+    // amount is subtracted from size of the stack space to get an address
+    // that is within the stack space and is aligned on all systems we care
+    // about.  As far as I know there is no ABI with stack alignment greater
+    // than 64.  We assume stack and stack_size already have alignment of
+    // kMaxStackAlignment.
+    const size_t kMaxStackAlignment = 64;
+    void* const stack_top =
+        static_cast<char*>(stack) +
+            (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
+    GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment &&
+        reinterpret_cast<intptr_t>(stack_top) % kMaxStackAlignment == 0);
+
+    child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
+
+    GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
+  }
+#   else
+  const bool use_fork = true;
+#   endif  // GTEST_HAS_CLONE
+
+  if (use_fork && (child_pid = fork()) == 0) {
+      ExecDeathTestChildMain(&args);
+      _exit(0);
+  }
+#  endif  // GTEST_OS_QNX
+#  if GTEST_OS_LINUX
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(
+      sigaction(SIGPROF, &saved_sigprof_action, NULL));
+#  endif  // GTEST_OS_LINUX
+
+  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
+  return child_pid;
+}
+
+// The AssumeRole process for a fork-and-exec death test.  It re-executes the
+// main program from the beginning, setting the --gtest_filter
+// and --gtest_internal_run_death_test flags to cause only the current
+// death test to be re-run.
+DeathTest::TestRole ExecDeathTest::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 != NULL) {
+    set_write_fd(flag->write_fd());
+    return EXECUTE_TEST;
+  }
+
+  int pipe_fd[2];
+  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
+  // Clear the close-on-exec flag on the write end of the pipe, lest
+  // 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_case_name() + "." + info->name();
+  const std::string internal_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
+      + file_ + "|" + StreamableToString(line_) + "|"
+      + StreamableToString(death_test_index) + "|"
+      + StreamableToString(pipe_fd[1]);
+  Arguments args;
+  args.AddArguments(GetArgvsForDeathTestChildProcess());
+  args.AddArgument(filter_flag.c_str());
+  args.AddArgument(internal_flag.c_str());
+
+  DeathTest::set_last_death_test_message("");
+
+  CaptureStderr();
+  // See the comment in NoExecDeathTest::AssumeRole for why the next line
+  // is necessary.
+  FlushInfoLog();
+
+  const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
+  set_child_pid(child_pid);
+  set_read_fd(pipe_fd[0]);
+  set_spawned(true);
+  return OVERSEE_TEST;
+}
+
+# endif  // !GTEST_OS_WINDOWS
+
+// Creates a concrete DeathTest-derived class that depends on the
+// --gtest_death_test_style flag, and sets the pointer pointed to
+// 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, const RE* regex,
+                                     const char* file, int line,
+                                     DeathTest** test) {
+  UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const int death_test_index = impl->current_test_info()
+      ->increment_death_test_count();
+
+  if (flag != NULL) {
+    if (death_test_index > flag->index()) {
+      DeathTest::set_last_death_test_message(
+          "Death test count (" + StreamableToString(death_test_index)
+          + ") somehow exceeded expected maximum ("
+          + StreamableToString(flag->index()) + ")");
+      return false;
+    }
+
+    if (!(flag->file() == file && flag->line() == line &&
+          flag->index() == death_test_index)) {
+      *test = NULL;
+      return true;
+    }
+  }
+
+# if GTEST_OS_WINDOWS
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
+      GTEST_FLAG(death_test_style) == "fast") {
+    *test = new WindowsDeathTest(statement, regex, file, line);
+  }
+
+# else
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe") {
+    *test = new ExecDeathTest(statement, regex, file, line);
+  } else if (GTEST_FLAG(death_test_style) == "fast") {
+    *test = new NoExecDeathTest(statement, regex);
+  }
+
+# endif  // GTEST_OS_WINDOWS
+
+  else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
+    DeathTest::set_last_death_test_message(
+        "Unknown death test style \"" + GTEST_FLAG(death_test_style)
+        + "\" encountered");
+    return false;
+  }
+
+  return true;
+}
+
+# if GTEST_OS_WINDOWS
+// 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.
+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,
+                                                   FALSE,  // Non-inheritable.
+                                                   parent_process_id));
+  if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
+    DeathTestAbort("Unable to open parent process " +
+                   StreamableToString(parent_process_id));
+  }
+
+  // TODO(vladl@google.com): Replace the following check with a
+  // compile-time assertion when available.
+  GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));
+
+  const HANDLE write_handle =
+      reinterpret_cast<HANDLE>(write_handle_as_size_t);
+  HANDLE dup_write_handle;
+
+  // The newly initialized handle is accessible only in in the parent
+  // process. To obtain one accessible within the child, we need to use
+  // DuplicateHandle.
+  if (!::DuplicateHandle(parent_process_handle.Get(), write_handle,
+                         ::GetCurrentProcess(), &dup_write_handle,
+                         0x0,    // Requested privileges ignored since
+                                 // DUPLICATE_SAME_ACCESS is used.
+                         FALSE,  // Request non-inheritable handler.
+                         DUPLICATE_SAME_ACCESS)) {
+    DeathTestAbort("Unable to duplicate the pipe handle " +
+                   StreamableToString(write_handle_as_size_t) +
+                   " from the parent process " +
+                   StreamableToString(parent_process_id));
+  }
+
+  const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t);
+  HANDLE dup_event_handle;
+
+  if (!::DuplicateHandle(parent_process_handle.Get(), event_handle,
+                         ::GetCurrentProcess(), &dup_event_handle,
+                         0x0,
+                         FALSE,
+                         DUPLICATE_SAME_ACCESS)) {
+    DeathTestAbort("Unable to duplicate the event handle " +
+                   StreamableToString(event_handle_as_size_t) +
+                   " from the parent process " +
+                   StreamableToString(parent_process_id));
+  }
+
+  const int write_fd =
+      ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND);
+  if (write_fd == -1) {
+    DeathTestAbort("Unable to convert pipe handle " +
+                   StreamableToString(write_handle_as_size_t) +
+                   " to a file descriptor");
+  }
+
+  // Signals the parent that the write end of the pipe has been acquired
+  // so the parent can release its own write end.
+  ::SetEvent(dup_event_handle);
+
+  return write_fd;
+}
+# endif  // GTEST_OS_WINDOWS
+
+// Returns a newly created InternalRunDeathTestFlag object with fields
+// 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 NULL;
+
+  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
+  // can use it here.
+  int line = -1;
+  int index = -1;
+  ::std::vector< ::std::string> fields;
+  SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields);
+  int write_fd = -1;
+
+# if GTEST_OS_WINDOWS
+
+  unsigned int parent_process_id = 0;
+  size_t write_handle_as_size_t = 0;
+  size_t event_handle_as_size_t = 0;
+
+  if (fields.size() != 6
+      || !ParseNaturalNumber(fields[1], &line)
+      || !ParseNaturalNumber(fields[2], &index)
+      || !ParseNaturalNumber(fields[3], &parent_process_id)
+      || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
+      || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
+                   GTEST_FLAG(internal_run_death_test));
+  }
+  write_fd = GetStatusFileDescriptor(parent_process_id,
+                                     write_handle_as_size_t,
+                                     event_handle_as_size_t);
+# else
+
+  if (fields.size() != 4
+      || !ParseNaturalNumber(fields[1], &line)
+      || !ParseNaturalNumber(fields[2], &index)
+      || !ParseNaturalNumber(fields[3], &write_fd)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
+        + GTEST_FLAG(internal_run_death_test));
+  }
+
+# endif  // GTEST_OS_WINDOWS
+
+  return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
+}
+
+}  // namespace internal
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-filepath.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-filepath.cc
new file mode 100644
index 00000000..0292dc11
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-filepath.cc
@@ -0,0 +1,387 @@
+// 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.
+//
+// Authors: keith.ray@gmail.com (Keith Ray)
+
+#include "gtest/gtest-message.h"
+#include "gtest/internal/gtest-filepath.h"
+#include "gtest/internal/gtest-port.h"
+
+#include <stdlib.h>
+
+#if GTEST_OS_WINDOWS_MOBILE
+# include <windows.h>
+#elif GTEST_OS_WINDOWS
+# include <direct.h>
+# include <io.h>
+#elif GTEST_OS_SYMBIAN
+// Symbian OpenC has PATH_MAX in sys/syslimits.h
+# include <sys/syslimits.h>
+#else
+# include <limits.h>
+# include <climits>  // Some Linux distributions define PATH_MAX here.
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+#if GTEST_OS_WINDOWS
+# define GTEST_PATH_MAX_ _MAX_PATH
+#elif defined(PATH_MAX)
+# define GTEST_PATH_MAX_ PATH_MAX
+#elif defined(_XOPEN_PATH_MAX)
+# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX
+#else
+# define GTEST_PATH_MAX_ _POSIX_PATH_MAX
+#endif  // GTEST_OS_WINDOWS
+
+#include "gtest/internal/gtest-string.h"
+
+namespace testing {
+namespace internal {
+
+#if GTEST_OS_WINDOWS
+// On Windows, '\\' is the standard path separator, but many tools and the
+// Windows API also accept '/' as an alternate path separator. Unless otherwise
+// noted, a file path can contain either kind of path separators, or a mixture
+// of them.
+const char kPathSeparator = '\\';
+const char kAlternatePathSeparator = '/';
+const char kAlternatePathSeparatorString[] = "/";
+# if GTEST_OS_WINDOWS_MOBILE
+// Windows CE doesn't have a current directory. You should not use
+// the current directory in tests on Windows CE, but this at least
+// provides a reasonable fallback.
+const char kCurrentDirectoryString[] = "\\";
+// Windows CE doesn't define INVALID_FILE_ATTRIBUTES
+const DWORD kInvalidFileAttributes = 0xffffffff;
+# else
+const char kCurrentDirectoryString[] = ".\\";
+# endif  // GTEST_OS_WINDOWS_MOBILE
+#else
+const char kPathSeparator = '/';
+const char kCurrentDirectoryString[] = "./";
+#endif  // GTEST_OS_WINDOWS
+
+// Returns whether the given character is a valid path separator.
+static bool IsPathSeparator(char c) {
+#if GTEST_HAS_ALT_PATH_SEP_
+  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
+#else
+  return c == kPathSeparator;
+#endif
+}
+
+// Returns the current working directory, or "" if unsuccessful.
+FilePath FilePath::GetCurrentDir() {
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
+  // Windows CE doesn't 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)) == NULL ? "" : cwd);
+#else
+  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
+  char* result = getcwd(cwd, sizeof(cwd));
+# if GTEST_OS_NACL
+  // 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 == NULL ? kCurrentDirectoryString : cwd);
+# endif  // GTEST_OS_NACL
+  return FilePath(result == NULL ? "" : cwd);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+// Returns a copy of the FilePath with the case-insensitive extension removed.
+// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
+// FilePath("dir/file"). If a case-insensitive extension is not
+// found, returns a copy of the original FilePath.
+FilePath FilePath::RemoveExtension(const char* extension) const {
+  const std::string dot_extension = std::string(".") + extension;
+  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
+    return FilePath(pathname_.substr(
+        0, pathname_.length() - dot_extension.length()));
+  }
+  return *this;
+}
+
+// Returns a pointer to the last occurence 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 {
+  const char* const last_sep = strrchr(c_str(), kPathSeparator);
+#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 != NULL &&
+      (last_sep == NULL || last_alt_sep > last_sep)) {
+    return last_alt_sep;
+  }
+#endif
+  return last_sep;
+}
+
+// Returns a copy of the FilePath with the directory part removed.
+// Example: FilePath("path/to/file").RemoveDirectoryName() returns
+// FilePath("file"). If there is no directory part ("just_a_file"), it returns
+// the FilePath unmodified. If there is no file part ("just_a_dir/") it
+// returns an empty FilePath ("").
+// On Windows platform, '\' is the path separator, otherwise it is '/'.
+FilePath FilePath::RemoveDirectoryName() const {
+  const char* const last_sep = FindLastPathSeparator();
+  return last_sep ? FilePath(last_sep + 1) : *this;
+}
+
+// RemoveFileName returns the directory path with the filename removed.
+// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
+// If the FilePath is "a_file" or "/a_file", RemoveFileName returns
+// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
+// not have a file, like "just/a/dir/", it returns the FilePath unmodified.
+// On Windows platform, '\' is the path separator, otherwise it is '/'.
+FilePath FilePath::RemoveFileName() const {
+  const char* const last_sep = FindLastPathSeparator();
+  std::string dir;
+  if (last_sep) {
+    dir = std::string(c_str(), last_sep + 1 - c_str());
+  } else {
+    dir = kCurrentDirectoryString;
+  }
+  return FilePath(dir);
+}
+
+// Helper functions for naming files in a directory for xml output.
+
+// Given directory = "dir", base_name = "test", number = 0,
+// extension = "xml", returns "dir/test.xml". If number is greater
+// than zero (e.g., 12), returns "dir/test_12.xml".
+// On Windows platform, uses \ as the separator rather than /.
+FilePath FilePath::MakeFileName(const FilePath& directory,
+                                const FilePath& base_name,
+                                int number,
+                                const char* extension) {
+  std::string file;
+  if (number == 0) {
+    file = base_name.string() + "." + extension;
+  } else {
+    file = base_name.string() + "_" + StreamableToString(number)
+        + "." + extension;
+  }
+  return ConcatPaths(directory, FilePath(file));
+}
+
+// Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml".
+// On Windows, uses \ as the separator rather than /.
+FilePath FilePath::ConcatPaths(const FilePath& directory,
+                               const FilePath& relative_path) {
+  if (directory.IsEmpty())
+    return relative_path;
+  const FilePath dir(directory.RemoveTrailingPathSeparator());
+  return FilePath(dir.string() + kPathSeparator + relative_path.string());
+}
+
+// Returns true if pathname describes something findable in the file-system,
+// either a file, directory, or whatever.
+bool FilePath::FileOrDirectoryExists() const {
+#if GTEST_OS_WINDOWS_MOBILE
+  LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
+  const DWORD attributes = GetFileAttributes(unicode);
+  delete [] unicode;
+  return attributes != kInvalidFileAttributes;
+#else
+  posix::StatStruct file_stat;
+  return posix::Stat(pathname_.c_str(), &file_stat) == 0;
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+// Returns true if pathname describes a directory in the file-system
+// that exists.
+bool FilePath::DirectoryExists() const {
+  bool result = false;
+#if GTEST_OS_WINDOWS
+  // Don't strip off trailing separator if path is a root directory on
+  // Windows (like "C:\\").
+  const FilePath& path(IsRootDirectory() ? *this :
+                                           RemoveTrailingPathSeparator());
+#else
+  const FilePath& path(*this);
+#endif
+
+#if GTEST_OS_WINDOWS_MOBILE
+  LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
+  const DWORD attributes = GetFileAttributes(unicode);
+  delete [] unicode;
+  if ((attributes != kInvalidFileAttributes) &&
+      (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
+    result = true;
+  }
+#else
+  posix::StatStruct file_stat;
+  result = posix::Stat(path.c_str(), &file_stat) == 0 &&
+      posix::IsDir(file_stat);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+  return result;
+}
+
+// Returns true if pathname describes a root directory. (Windows has one
+// root directory per disk drive.)
+bool FilePath::IsRootDirectory() const {
+#if GTEST_OS_WINDOWS
+  // TODO(wan@google.com): on Windows a network share like
+  // \\server\share can be a root directory, although it cannot be the
+  // current directory.  Handle this properly.
+  return pathname_.length() == 3 && IsAbsolutePath();
+#else
+  return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
+#endif
+}
+
+// Returns true if pathname describes an absolute path.
+bool FilePath::IsAbsolutePath() const {
+  const char* const name = pathname_.c_str();
+#if GTEST_OS_WINDOWS
+  return pathname_.length() >= 3 &&
+     ((name[0] >= 'a' && name[0] <= 'z') ||
+      (name[0] >= 'A' && name[0] <= 'Z')) &&
+     name[1] == ':' &&
+     IsPathSeparator(name[2]);
+#else
+  return IsPathSeparator(name[0]);
+#endif
+}
+
+// Returns a pathname for a file that does not currently exist. The pathname
+// will be directory/base_name.extension or
+// directory/base_name_<number>.extension if directory/base_name.extension
+// already exists. The number will be incremented until a pathname is found
+// that does not already exist.
+// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
+// There could be a race condition if two or more processes are calling this
+// function at the same time -- they could both pick the same filename.
+FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
+                                          const FilePath& base_name,
+                                          const char* extension) {
+  FilePath full_pathname;
+  int number = 0;
+  do {
+    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
+  } while (full_pathname.FileOrDirectoryExists());
+  return full_pathname;
+}
+
+// Returns true if FilePath ends with a path separator, which indicates that
+// it is intended to represent a directory. Returns false otherwise.
+// This does NOT check that a directory (or file) actually exists.
+bool FilePath::IsDirectory() const {
+  return !pathname_.empty() &&
+         IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]);
+}
+
+// Create directories so that path exists. Returns true if successful or if
+// the directories already exist; returns false if unable to create directories
+// for any reason.
+bool FilePath::CreateDirectoriesRecursively() const {
+  if (!this->IsDirectory()) {
+    return false;
+  }
+
+  if (pathname_.length() == 0 || this->DirectoryExists()) {
+    return true;
+  }
+
+  const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
+  return parent.CreateDirectoriesRecursively() && this->CreateFolder();
+}
+
+// Create the directory so that path exists. Returns true if successful or
+// if the directory already exists; returns false if unable to create the
+// directory for any reason, including if the parent directory does not
+// exist. Not named "CreateDirectory" because that's a macro on Windows.
+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, NULL) ? 0 : -1;
+  delete [] unicode;
+#elif GTEST_OS_WINDOWS
+  int result = _mkdir(pathname_.c_str());
+#else
+  int result = mkdir(pathname_.c_str(), 0777);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+  if (result == -1) {
+    return this->DirectoryExists();  // An error is OK if the directory exists.
+  }
+  return true;  // No error.
+}
+
+// If input name has a trailing separator character, remove it and return the
+// name, otherwise return the name string unmodified.
+// On Windows platform, uses \ as the separator, other platforms use /.
+FilePath FilePath::RemoveTrailingPathSeparator() const {
+  return IsDirectory()
+      ? FilePath(pathname_.substr(0, pathname_.length() - 1))
+      : *this;
+}
+
+// Removes any redundant separators that might be in the pathname.
+// For example, "bar///foo" becomes "bar/foo". Does not eliminate other
+// redundancies that might be in a pathname involving "." or "..".
+// TODO(wan@google.com): handle Windows network shares (e.g. \\server\share).
+void FilePath::Normalize() {
+  if (pathname_.c_str() == NULL) {
+    pathname_ = "";
+    return;
+  }
+  const char* src = pathname_.c_str();
+  char* const dest = new char[pathname_.length() + 1];
+  char* dest_ptr = dest;
+  memset(dest_ptr, 0, pathname_.length() + 1);
+
+  while (*src != '\0') {
+    *dest_ptr = *src;
+    if (!IsPathSeparator(*src)) {
+      src++;
+    } else {
+#if GTEST_HAS_ALT_PATH_SEP_
+      if (*dest_ptr == kAlternatePathSeparator) {
+        *dest_ptr = kPathSeparator;
+      }
+#endif
+      while (IsPathSeparator(*src))
+        src++;
+    }
+    dest_ptr++;
+  }
+  *dest_ptr = '\0';
+  pathname_ = dest;
+  delete[] dest;
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-internal-inl.h b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-internal-inl.h
new file mode 100644
index 00000000..ed8a682a
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-internal-inl.h
@@ -0,0 +1,1183 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Utility functions and classes used by the Google C++ testing framework.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// This file contains purely Google Test's internal implementation.  Please
+// DO NOT #INCLUDE IT IN A USER PROGRAM.
+
+#ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_
+#define GTEST_SRC_GTEST_INTERNAL_INL_H_
+
+// GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is
+// part of Google Test's implementation; otherwise it's undefined.
+#if !GTEST_IMPLEMENTATION_
+// If this file is included from the user's code, just say no.
+# error "gtest-internal-inl.h is part of Google Test's internal implementation."
+# error "It must not be included except by Google Test itself."
+#endif  // GTEST_IMPLEMENTATION_
+
+#ifndef _WIN32_WCE
+# include <errno.h>
+#endif  // !_WIN32_WCE
+#include <stddef.h>
+#include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
+#include <string.h>  // For memmove.
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include "gtest/internal/gtest-port.h"
+
+#if GTEST_CAN_STREAM_RESULTS_
+# include <arpa/inet.h>  // NOLINT
+# include <netdb.h>  // NOLINT
+#endif
+
+#if GTEST_OS_WINDOWS
+# include <windows.h>  // NOLINT
+#endif  // GTEST_OS_WINDOWS
+
+#include "gtest/gtest.h"  // NOLINT
+#include "gtest/gtest-spi.h"
+
+namespace testing {
+
+// Declares the flags.
+//
+// We don't want the users to modify this flag in the code, but want
+// Google Test's own unit tests to be able to access it. Therefore we
+// declare it here as opposed to in gtest.h.
+GTEST_DECLARE_bool_(death_test_use_fork);
+
+namespace internal {
+
+// The value of GetTestTypeId() as seen from within the Google Test
+// library.  This is solely for testing GetTestTypeId().
+GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;
+
+// Names of the flags (needed for parsing Google Test flags).
+const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
+const char kBreakOnFailureFlag[] = "break_on_failure";
+const char kCatchExceptionsFlag[] = "catch_exceptions";
+const char kColorFlag[] = "color";
+const char kFilterFlag[] = "filter";
+const char kListTestsFlag[] = "list_tests";
+const char kOutputFlag[] = "output";
+const char kPrintTimeFlag[] = "print_time";
+const char kRandomSeedFlag[] = "random_seed";
+const char kRepeatFlag[] = "repeat";
+const char kShuffleFlag[] = "shuffle";
+const char kStackTraceDepthFlag[] = "stack_trace_depth";
+const char kStreamResultToFlag[] = "stream_result_to";
+const char kThrowOnFailureFlag[] = "throw_on_failure";
+const char kFlagfileFlag[] = "flagfile";
+
+// A valid random seed must be in [1, kMaxRandomSeed].
+const int kMaxRandomSeed = 99999;
+
+// g_help_flag is true iff 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 iff Google Test should use colors in the output.
+GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
+
+// Formats the given time in milliseconds as seconds.
+GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);
+
+// Converts the given time in milliseconds to a date string in the ISO 8601
+// format, without the timezone information.  N.B.: due to the use the
+// non-reentrant localtime() function, this function is not thread safe.  Do
+// not use it in any code that can be called from multiple threads.
+GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);
+
+// Parses a string for an Int32 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.
+GTEST_API_ bool ParseInt32Flag(
+    const char* str, const char* flag, Int32* value);
+
+// Returns a random seed in range [1, kMaxRandomSeed] based on the
+// given --gtest_random_seed flag value.
+inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
+  const unsigned int raw_seed = (random_seed_flag == 0) ?
+      static_cast<unsigned int>(GetTimeInMillis()) :
+      static_cast<unsigned int>(random_seed_flag);
+
+  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
+  // it's easy to type.
+  const int normalized_seed =
+      static_cast<int>((raw_seed - 1U) %
+                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
+  return normalized_seed;
+}
+
+// Returns the first valid random seed after 'seed'.  The behavior is
+// undefined if 'seed' is invalid.  The seed after kMaxRandomSeed is
+// considered to be 1.
+inline int GetNextRandomSeed(int seed) {
+  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
+      << "Invalid random seed " << seed << " - must be in [1, "
+      << kMaxRandomSeed << "].";
+  const int next_seed = seed + 1;
+  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
+}
+
+// This class saves the values of all Google Test flags in its c'tor, and
+// restores them in its d'tor.
+class GTestFlagSaver {
+ public:
+  // The c'tor.
+  GTestFlagSaver() {
+    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
+    break_on_failure_ = GTEST_FLAG(break_on_failure);
+    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
+    color_ = GTEST_FLAG(color);
+    death_test_style_ = GTEST_FLAG(death_test_style);
+    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
+    filter_ = GTEST_FLAG(filter);
+    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
+    list_tests_ = GTEST_FLAG(list_tests);
+    output_ = GTEST_FLAG(output);
+    print_time_ = GTEST_FLAG(print_time);
+    random_seed_ = GTEST_FLAG(random_seed);
+    repeat_ = GTEST_FLAG(repeat);
+    shuffle_ = GTEST_FLAG(shuffle);
+    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
+    stream_result_to_ = GTEST_FLAG(stream_result_to);
+    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
+  }
+
+  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
+  ~GTestFlagSaver() {
+    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
+    GTEST_FLAG(break_on_failure) = break_on_failure_;
+    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
+    GTEST_FLAG(color) = color_;
+    GTEST_FLAG(death_test_style) = death_test_style_;
+    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
+    GTEST_FLAG(filter) = filter_;
+    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
+    GTEST_FLAG(list_tests) = list_tests_;
+    GTEST_FLAG(output) = output_;
+    GTEST_FLAG(print_time) = print_time_;
+    GTEST_FLAG(random_seed) = random_seed_;
+    GTEST_FLAG(repeat) = repeat_;
+    GTEST_FLAG(shuffle) = shuffle_;
+    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
+    GTEST_FLAG(stream_result_to) = stream_result_to_;
+    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
+  }
+
+ private:
+  // Fields for saving the original values of flags.
+  bool also_run_disabled_tests_;
+  bool break_on_failure_;
+  bool catch_exceptions_;
+  std::string color_;
+  std::string death_test_style_;
+  bool death_test_use_fork_;
+  std::string filter_;
+  std::string internal_run_death_test_;
+  bool list_tests_;
+  std::string output_;
+  bool print_time_;
+  internal::Int32 random_seed_;
+  internal::Int32 repeat_;
+  bool shuffle_;
+  internal::Int32 stack_trace_depth_;
+  std::string stream_result_to_;
+  bool throw_on_failure_;
+} GTEST_ATTRIBUTE_UNUSED_;
+
+// Converts a Unicode code point to a narrow string in UTF-8 encoding.
+// code_point parameter is of type UInt32 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)".
+GTEST_API_ std::string CodePointToUtf8(UInt32 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, Symbian OS)
+//   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
+// of wchar_t characters processed. -1 is used when the entire string
+// should be processed.
+// If the string contains code points that are not valid Unicode code points
+// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
+// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
+// and contains invalid UTF-16 surrogate pairs, values in those pairs
+// will be encoded as individual Unicode characters from Basic Normal Plane.
+GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars);
+
+// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
+// if the variable is present. If a file already exists at this location, this
+// function will write over it. If the variable is present, but the file cannot
+// be created, prints an error and exits.
+void WriteToShardStatusFileIfNeeded();
+
+// Checks whether sharding is enabled by examining the relevant
+// environment variable values. If the variables are present,
+// but inconsistent (e.g., shard_index >= total_shards), prints
+// an error and exits. If in_subprocess_for_death_test, sharding is
+// disabled because it must only be applied to the original test
+// process. Otherwise, we could filter out death tests we intended to execute.
+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 an Int32. If it is unset,
+// returns default_val. If it is not an Int32, prints an error and
+// and aborts.
+GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val);
+
+// Given the total number of shards, the shard index, and the test id,
+// returns true iff 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);
+
+// STL container utilities.
+
+// Returns the number of elements in the given container that satisfy
+// the given predicate.
+template <class Container, typename Predicate>
+inline int CountIf(const Container& c, Predicate predicate) {
+  // Implemented as an explicit loop since std::count_if() in libCstd on
+  // Solaris has a non-standard signature.
+  int count = 0;
+  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
+    if (predicate(*it))
+      ++count;
+  }
+  return count;
+}
+
+// Applies a function/functor to each element in the container.
+template <class Container, typename Functor>
+void ForEach(const Container& c, Functor functor) {
+  std::for_each(c.begin(), c.end(), functor);
+}
+
+// Returns the i-th element of the vector, or default_value if i is not
+// 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[i];
+}
+
+// Performs an in-place shuffle of a range of the vector's elements.
+// 'begin' and 'end' are element indices as an STL-style range;
+// i.e. [begin, end) are shuffled, where 'end' == size() means to
+// shuffle to the end of the vector.
+template <typename E>
+void ShuffleRange(internal::Random* random, int begin, int end,
+                  std::vector<E>* v) {
+  const int size = static_cast<int>(v->size());
+  GTEST_CHECK_(0 <= begin && begin <= size)
+      << "Invalid shuffle range start " << begin << ": must be in range [0, "
+      << size << "].";
+  GTEST_CHECK_(begin <= end && end <= size)
+      << "Invalid shuffle range finish " << end << ": must be in range ["
+      << begin << ", " << size << "].";
+
+  // Fisher-Yates shuffle, from
+  // 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 + random->Generate(range_width);
+    std::swap((*v)[selected], (*v)[last_in_range]);
+  }
+}
+
+// Performs an in-place shuffle of the vector's elements.
+template <typename E>
+inline void Shuffle(internal::Random* random, std::vector<E>* v) {
+  ShuffleRange(random, 0, static_cast<int>(v->size()), v);
+}
+
+// A function for deleting an object.  Handy for being used as a
+// functor.
+template <typename T>
+static void Delete(T* x) {
+  delete x;
+}
+
+// A predicate that checks the key of a TestProperty against a known key.
+//
+// TestPropertyKeyIs is copyable.
+class TestPropertyKeyIs {
+ public:
+  // Constructor.
+  //
+  // TestPropertyKeyIs has NO default constructor.
+  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
+
+  // Returns true iff the test name of test property matches on key_.
+  bool operator()(const TestProperty& test_property) const {
+    return test_property.key() == key_;
+  }
+
+ private:
+  std::string key_;
+};
+
+// Class UnitTestOptions.
+//
+// This class contains functions for processing options the user
+// specifies when running the tests.  It has only static members.
+//
+// In most cases, the user can specify an option using either an
+// environment variable or a command line flag.  E.g. you can set the
+// test filter using either GTEST_FILTER or --gtest_filter.  If both
+// the variable and the flag are present, the latter overrides the
+// former.
+class GTEST_API_ UnitTestOptions {
+ public:
+  // Functions for processing the gtest_output flag.
+
+  // Returns the output format, or "" for normal printed output.
+  static std::string GetOutputFormat();
+
+  // Returns the absolute path of the requested output file, or the
+  // default (test_detail.xml in the original working directory) if
+  // none was explicitly specified.
+  static std::string GetAbsolutePathToOutputFile();
+
+  // Functions for processing the gtest_filter flag.
+
+  // Returns true iff the wildcard pattern matches the string.  The
+  // first ':' or '\0' character in pattern marks the end of it.
+  //
+  // This recursive algorithm isn't very efficient, but is clear and
+  // works well enough for matching test names, which are short.
+  static bool PatternMatchesString(const char *pattern, const char *str);
+
+  // Returns true iff the user-specified filter matches the test case
+  // name and the test name.
+  static bool FilterMatchesTest(const std::string &test_case_name,
+                                const std::string &test_name);
+
+#if GTEST_OS_WINDOWS
+  // Function for supporting the gtest_catch_exception flag.
+
+  // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
+  // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
+  // This function is useful as an __except condition.
+  static int GTestShouldProcessSEH(DWORD exception_code);
+#endif  // GTEST_OS_WINDOWS
+
+  // Returns true if "name" matches the ':' separated list of glob-style
+  // filters in "filter".
+  static bool MatchesFilter(const std::string& name, const char* filter);
+};
+
+// Returns the current application's name, removing directory path if that
+// is present.  Used by UnitTestOptions::GetOutputFile.
+GTEST_API_ FilePath GetCurrentExecutableName();
+
+// The role interface for getting the OS stack trace as a string.
+class OsStackTraceGetterInterface {
+ public:
+  OsStackTraceGetterInterface() {}
+  virtual ~OsStackTraceGetterInterface() {}
+
+  // Returns the current OS stack trace as an std::string.  Parameters:
+  //
+  //   max_depth  - the maximum number of stack frames to be included
+  //                in the trace.
+  //   skip_count - the number of top frames to be skipped; doesn't count
+  //                against max_depth.
+  virtual 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
+  // CurrentStackTrace() will use to find and hide Google Test stack frames.
+  virtual void UponLeavingGTest() = 0;
+
+  // This string is inserted in place of stack frames that are part of
+  // Google Test's implementation.
+  static const char* const kElidedFramesMarker;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
+};
+
+// A working implementation of the OsStackTraceGetterInterface interface.
+class OsStackTraceGetter : public OsStackTraceGetterInterface {
+ public:
+  OsStackTraceGetter() {}
+
+  virtual string CurrentStackTrace(int max_depth, int skip_count);
+  virtual void UponLeavingGTest();
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
+};
+
+// Information about a Google Test trace point.
+struct TraceInfo {
+  const char* file;
+  int line;
+  std::string message;
+};
+
+// This is the default global test part result reporter used in UnitTestImpl.
+// This class should only be used by UnitTestImpl.
+class DefaultGlobalTestPartResultReporter
+  : public TestPartResultReporterInterface {
+ public:
+  explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
+  // Implements the TestPartResultReporterInterface. Reports the test part
+  // result in the current test.
+  virtual void ReportTestPartResult(const TestPartResult& result);
+
+ private:
+  UnitTestImpl* const unit_test_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
+};
+
+// This is the default per thread test part result reporter used in
+// UnitTestImpl. This class should only be used by UnitTestImpl.
+class DefaultPerThreadTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test);
+  // Implements the TestPartResultReporterInterface. The implementation just
+  // delegates to the current global test part result reporter of *unit_test_.
+  virtual void ReportTestPartResult(const TestPartResult& result);
+
+ private:
+  UnitTestImpl* const unit_test_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
+};
+
+// The private implementation of the UnitTest class.  We don't protect
+// the methods under a mutex, as this class is not accessible by a
+// user and the UnitTest class that delegates work to this class does
+// proper locking.
+class GTEST_API_ UnitTestImpl {
+ public:
+  explicit UnitTestImpl(UnitTest* parent);
+  virtual ~UnitTestImpl();
+
+  // There are two different ways to register your own TestPartResultReporter.
+  // You can register your own repoter to listen either only for test results
+  // from the current thread or for results from all threads.
+  // By default, each per-thread test result repoter just passes a new
+  // TestPartResult to the global test result reporter, which registers the
+  // test part result for the currently running test.
+
+  // Returns the global test part result reporter.
+  TestPartResultReporterInterface* GetGlobalTestPartResultReporter();
+
+  // Sets the global test part result reporter.
+  void SetGlobalTestPartResultReporter(
+      TestPartResultReporterInterface* reporter);
+
+  // Returns the test part result reporter for the current thread.
+  TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread();
+
+  // Sets the test part result reporter for the current thread.
+  void SetTestPartResultReporterForCurrentThread(
+      TestPartResultReporterInterface* reporter);
+
+  // Gets the number of successful test cases.
+  int successful_test_case_count() const;
+
+  // Gets the number of failed test cases.
+  int failed_test_case_count() const;
+
+  // Gets the number of all test cases.
+  int total_test_case_count() const;
+
+  // Gets the number of all test cases that contain at least one test
+  // that should run.
+  int test_case_to_run_count() const;
+
+  // Gets the number of successful tests.
+  int successful_test_count() const;
+
+  // Gets the number of failed tests.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Gets the number of all tests.
+  int total_test_count() const;
+
+  // Gets the number of tests that should run.
+  int test_to_run_count() const;
+
+  // Gets the time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const { return start_timestamp_; }
+
+  // Gets the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Returns true iff the unit test passed (i.e. all test cases passed).
+  bool Passed() const { return !Failed(); }
+
+  // Returns true iff the unit test failed (i.e. some test case failed
+  // or something outside of all tests failed).
+  bool Failed() const {
+    return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed();
+  }
+
+  // Gets the i-th test case among all the test cases. i can range from 0 to
+  // total_test_case_count() - 1. If i is not in that range, returns NULL.
+  const TestCase* GetTestCase(int i) const {
+    const int index = GetElementOr(test_case_indices_, i, -1);
+    return index < 0 ? NULL : test_cases_[i];
+  }
+
+  // Gets the i-th test case among all the test cases. i can range from 0 to
+  // total_test_case_count() - 1. If i is not in that range, returns NULL.
+  TestCase* GetMutableTestCase(int i) {
+    const int index = GetElementOr(test_case_indices_, i, -1);
+    return index < 0 ? NULL : test_cases_[index];
+  }
+
+  // Provides access to the event listener list.
+  TestEventListeners* listeners() { return &listeners_; }
+
+  // Returns the TestResult for the test that's currently running, or
+  // the TestResult for the ad hoc test if no test is running.
+  TestResult* current_test_result();
+
+  // Returns the TestResult for the ad hoc test.
+  const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }
+
+  // Sets the OS stack trace getter.
+  //
+  // Does nothing if the input and the current OS stack trace getter
+  // are the same; otherwise, deletes the old getter and makes the
+  // input the current getter.
+  void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);
+
+  // Returns the current OS stack trace getter if it is not NULL;
+  // otherwise, creates an OsStackTraceGetter, makes it the current
+  // getter, and returns it.
+  OsStackTraceGetterInterface* os_stack_trace_getter();
+
+  // Returns the current OS stack trace as an std::string.
+  //
+  // The maximum number of stack frames to be included is specified by
+  // the gtest_stack_trace_depth flag.  The skip_count parameter
+  // specifies the number of top frames to be skipped, which doesn't
+  // count against the number of frames to be included.
+  //
+  // For example, if Foo() calls Bar(), which in turn calls
+  // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
+  // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
+  std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_;
+
+  // Finds and returns a TestCase with the given name.  If one doesn't
+  // exist, creates one and returns it.
+  //
+  // Arguments:
+  //
+  //   test_case_name: name of the test case
+  //   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 case
+  //   tear_down_tc:   pointer to the function that tears down the test case
+  TestCase* GetTestCase(const char* test_case_name,
+                        const char* type_param,
+                        Test::SetUpTestCaseFunc set_up_tc,
+                        Test::TearDownTestCaseFunc tear_down_tc);
+
+  // Adds a TestInfo to the unit test.
+  //
+  // Arguments:
+  //
+  //   set_up_tc:    pointer to the function that sets up the test case
+  //   tear_down_tc: pointer to the function that tears down the test case
+  //   test_info:    the TestInfo object
+  void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
+                   Test::TearDownTestCaseFunc tear_down_tc,
+                   TestInfo* test_info) {
+    // 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
+    // the user may have changed the current directory before calling
+    // RUN_ALL_TESTS().  Therefore we capture the current directory in
+    // AddTestInfo(), which is called to register a TEST or TEST_F
+    // before main() is reached.
+    if (original_working_dir_.IsEmpty()) {
+      original_working_dir_.Set(FilePath::GetCurrentDir());
+      GTEST_CHECK_(!original_working_dir_.IsEmpty())
+          << "Failed to get the current working directory.";
+    }
+
+    GetTestCase(test_info->test_case_name(),
+                test_info->type_param(),
+                set_up_tc,
+                tear_down_tc)->AddTestInfo(test_info);
+  }
+
+#if GTEST_HAS_PARAM_TEST
+  // Returns ParameterizedTestCaseRegistry object used to keep track of
+  // value-parameterized tests and instantiate and register them.
+  internal::ParameterizedTestCaseRegistry& parameterized_test_registry() {
+    return parameterized_test_registry_;
+  }
+#endif  // GTEST_HAS_PARAM_TEST
+
+  // Sets the TestCase object for the test that's currently running.
+  void set_current_test_case(TestCase* a_current_test_case) {
+    current_test_case_ = a_current_test_case;
+  }
+
+  // Sets the TestInfo object for the test that's currently running.  If
+  // current_test_info is NULL, the assertion results will be stored in
+  // ad_hoc_test_result_.
+  void set_current_test_info(TestInfo* a_current_test_info) {
+    current_test_info_ = a_current_test_info;
+  }
+
+  // Registers all parameterized tests defined using TEST_P and
+  // INSTANTIATE_TEST_CASE_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
+  // present but does nothing.
+  void RegisterParameterizedTests();
+
+  // Runs all tests in this UnitTest object, prints the result, and
+  // returns true if all tests are successful.  If any exception is
+  // thrown during a test, this test is considered to be failed, but
+  // the rest of the tests will still be run.
+  bool RunAllTests();
+
+  // Clears the results of all tests, except the ad hoc tests.
+  void ClearNonAdHocTestResult() {
+    ForEach(test_cases_, TestCase::ClearTestCaseResult);
+  }
+
+  // Clears the results of ad-hoc test assertions.
+  void ClearAdHocTestResult() {
+    ad_hoc_test_result_.Clear();
+  }
+
+  // Adds a TestProperty to the current TestResult object when invoked in a
+  // context of a test or a test case, 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);
+
+  enum ReactionToSharding {
+    HONOR_SHARDING_PROTOCOL,
+    IGNORE_SHARDING_PROTOCOL
+  };
+
+  // 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 TestCase 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.
+  int FilterTests(ReactionToSharding shard_tests);
+
+  // Prints the names of the tests matching the user-specified filter flag.
+  void ListTestsMatchingFilter();
+
+  const TestCase* current_test_case() const { return current_test_case_; }
+  TestInfo* current_test_info() { return current_test_info_; }
+  const TestInfo* current_test_info() const { return current_test_info_; }
+
+  // Returns the vector of environments that need to be set-up/torn-down
+  // before/after the tests are run.
+  std::vector<Environment*>& environments() { return environments_; }
+
+  // Getters for the per-thread Google Test trace stack.
+  std::vector<TraceInfo>& gtest_trace_stack() {
+    return *(gtest_trace_stack_.pointer());
+  }
+  const std::vector<TraceInfo>& gtest_trace_stack() const {
+    return gtest_trace_stack_.get();
+  }
+
+#if GTEST_HAS_DEATH_TEST
+  void InitDeathTestSubprocessControlInfo() {
+    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
+  }
+  // Returns a pointer to the parsed --gtest_internal_run_death_test
+  // flag, or NULL if that flag was not specified.
+  // This information is useful only in a death test child process.
+  // Must not be called before a call to InitGoogleTest.
+  const InternalRunDeathTestFlag* internal_run_death_test_flag() const {
+    return internal_run_death_test_flag_.get();
+  }
+
+  // Returns a pointer to the current death test factory.
+  internal::DeathTestFactory* death_test_factory() {
+    return death_test_factory_.get();
+  }
+
+  void SuppressTestEventsIfInSubprocess();
+
+  friend class ReplaceDeathTestFactory;
+#endif  // GTEST_HAS_DEATH_TEST
+
+  // Initializes the event listener performing XML output as specified by
+  // UnitTestOptions. Must not be called before InitGoogleTest.
+  void ConfigureXmlOutput();
+
+#if GTEST_CAN_STREAM_RESULTS_
+  // Initializes the event listener for streaming test results to a socket.
+  // Must not be called before InitGoogleTest.
+  void ConfigureStreamingOutput();
+#endif
+
+  // Performs initialization dependent upon flag values obtained in
+  // ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
+  // ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
+  // this function is also called from RunAllTests.  Since this function can be
+  // called more than once, it has to be idempotent.
+  void PostFlagParsingInit();
+
+  // Gets the random seed used at the start of the current test iteration.
+  int random_seed() const { return random_seed_; }
+
+  // Gets the random number generator.
+  internal::Random* random() { return &random_; }
+
+  // Shuffles all test cases, and the tests within each test case,
+  // making sure that death tests are still run first.
+  void ShuffleTests();
+
+  // Restores the test cases and tests to their order before the first shuffle.
+  void UnshuffleTests();
+
+  // Returns the value of GTEST_FLAG(catch_exceptions) at the moment
+  // UnitTest::Run() starts.
+  bool catch_exceptions() const { return catch_exceptions_; }
+
+ private:
+  friend class ::testing::UnitTest;
+
+  // Used by UnitTest::Run() to capture the state of
+  // GTEST_FLAG(catch_exceptions) at the moment it starts.
+  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }
+
+  // The UnitTest object that owns this implementation object.
+  UnitTest* const parent_;
+
+  // The working directory when the first TEST() or TEST_F() was
+  // executed.
+  internal::FilePath original_working_dir_;
+
+  // The default test part result reporters.
+  DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_;
+  DefaultPerThreadTestPartResultReporter
+      default_per_thread_test_part_result_reporter_;
+
+  // Points to (but doesn't own) the global test part result reporter.
+  TestPartResultReporterInterface* global_test_part_result_repoter_;
+
+  // Protects read and write access to global_test_part_result_reporter_.
+  internal::Mutex global_test_part_result_reporter_mutex_;
+
+  // Points to (but doesn't own) the per-thread test part result reporter.
+  internal::ThreadLocal<TestPartResultReporterInterface*>
+      per_thread_test_part_result_reporter_;
+
+  // The vector of environments that need to be set-up/torn-down
+  // before/after the tests are run.
+  std::vector<Environment*> environments_;
+
+  // The vector of TestCases in their original order.  It owns the
+  // elements in the vector.
+  std::vector<TestCase*> test_cases_;
+
+  // Provides a level of indirection for the test case list to allow
+  // easy shuffling and restoring the test case order.  The i-th
+  // element of this vector is the index of the i-th test case in the
+  // shuffled order.
+  std::vector<int> test_case_indices_;
+
+#if GTEST_HAS_PARAM_TEST
+  // ParameterizedTestRegistry object used to register value-parameterized
+  // tests.
+  internal::ParameterizedTestCaseRegistry parameterized_test_registry_;
+
+  // Indicates whether RegisterParameterizedTests() has been called already.
+  bool parameterized_tests_registered_;
+#endif  // GTEST_HAS_PARAM_TEST
+
+  // Index of the last death test case registered.  Initially -1.
+  int last_death_test_case_;
+
+  // This points to the TestCase for the currently running test.  It
+  // changes as Google Test goes through one test case 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.
+  TestCase* current_test_case_;
+
+  // This points to the TestInfo for the currently running test.  It
+  // changes as Google Test goes through one test 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.
+  TestInfo* current_test_info_;
+
+  // Normally, a user only writes assertions inside a TEST or TEST_F,
+  // or inside a function called by a TEST or TEST_F.  Since Google
+  // Test keeps track of which test is current running, it can
+  // associate such an assertion with the test it belongs to.
+  //
+  // If an assertion is encountered when no TEST or TEST_F is running,
+  // Google Test attributes the assertion result to an imaginary "ad hoc"
+  // test, and records the result in ad_hoc_test_result_.
+  TestResult ad_hoc_test_result_;
+
+  // The list of event listeners that can be used to track events inside
+  // Google Test.
+  TestEventListeners listeners_;
+
+  // The OS stack trace getter.  Will be deleted when the UnitTest
+  // object is destructed.  By default, an OsStackTraceGetter is used,
+  // but the user can set this field to use a custom getter if that is
+  // desired.
+  OsStackTraceGetterInterface* os_stack_trace_getter_;
+
+  // True iff PostFlagParsingInit() has been called.
+  bool post_flag_parse_init_performed_;
+
+  // The random number seed used at the beginning of the test run.
+  int random_seed_;
+
+  // Our random number generator.
+  internal::Random random_;
+
+  // The time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp_;
+
+  // How long the test took to run, in milliseconds.
+  TimeInMillis elapsed_time_;
+
+#if GTEST_HAS_DEATH_TEST
+  // The decomposed components of the gtest_internal_run_death_test flag,
+  // parsed when RUN_ALL_TESTS is called.
+  internal::scoped_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
+  internal::scoped_ptr<internal::DeathTestFactory> death_test_factory_;
+#endif  // GTEST_HAS_DEATH_TEST
+
+  // A per-thread stack of traces created by the SCOPED_TRACE() macro.
+  internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_;
+
+  // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests()
+  // starts.
+  bool catch_exceptions_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
+};  // class UnitTestImpl
+
+// Convenience function for accessing the global UnitTest
+// implementation object.
+inline UnitTestImpl* GetUnitTestImpl() {
+  return UnitTest::GetInstance()->impl();
+}
+
+#if GTEST_USES_SIMPLE_RE
+
+// Internal helper functions for implementing the simple regular
+// expression matcher.
+GTEST_API_ bool IsInSet(char ch, const char* str);
+GTEST_API_ bool IsAsciiDigit(char ch);
+GTEST_API_ bool IsAsciiPunct(char ch);
+GTEST_API_ bool IsRepeat(char ch);
+GTEST_API_ bool IsAsciiWhiteSpace(char ch);
+GTEST_API_ bool IsAsciiWordChar(char ch);
+GTEST_API_ bool IsValidEscape(char ch);
+GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch);
+GTEST_API_ bool ValidateRegex(const char* regex);
+GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str);
+GTEST_API_ bool MatchRepetitionAndRegexAtHead(
+    bool escaped, char ch, char repeat, const char* regex, const char* str);
+GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);
+
+#endif  // GTEST_USES_SIMPLE_RE
+
+// Parses the command line for Google Test flags, without initializing
+// other parts of Google Test.
+GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv);
+GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
+
+#if GTEST_HAS_DEATH_TEST
+
+// Returns the message describing the last system error, regardless of the
+// platform.
+GTEST_API_ std::string GetLastErrnoDescription();
+
+// Attempts to parse a string into a positive integer pointed to by the
+// number parameter.  Returns true if that is possible.
+// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use
+// it here.
+template <typename Integer>
+bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
+  // Fail fast if the given string does not begin with a digit;
+  // this bypasses strtoXXX's "optional leading whitespace and plus
+  // or minus sign" semantics, which are undesirable here.
+  if (str.empty() || !IsDigit(str[0])) {
+    return false;
+  }
+  errno = 0;
+
+  char* end;
+  // BiggestConvertible is the largest integer type that system-provided
+  // string-to-number conversion routines can return.
+
+# if GTEST_OS_WINDOWS && !defined(__GNUC__)
+
+  // MSVC and C++ Builder define __int64 instead of the standard long long.
+  typedef unsigned __int64 BiggestConvertible;
+  const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10);
+
+# else
+
+  typedef unsigned long long BiggestConvertible;  // NOLINT
+  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);
+
+# endif  // GTEST_OS_WINDOWS && !defined(__GNUC__)
+
+  const bool parse_success = *end == '\0' && errno == 0;
+
+  // TODO(vladl@google.com): Convert this to compile time assertion when it is
+  // available.
+  GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
+
+  const Integer result = static_cast<Integer>(parsed);
+  if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
+    *number = result;
+    return true;
+  }
+  return false;
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+// TestResult contains some private methods that should be hidden from
+// Google Test user but are required for testing. This class allow our tests
+// to access them.
+//
+// This class is supplied only for the purpose of testing Google Test's own
+// constructs. Do not use it in user tests, either directly or indirectly.
+class TestResultAccessor {
+ public:
+  static void RecordProperty(TestResult* test_result,
+                             const std::string& xml_element,
+                             const TestProperty& property) {
+    test_result->RecordProperty(xml_element, property);
+  }
+
+  static void ClearTestPartResults(TestResult* test_result) {
+    test_result->ClearTestPartResults();
+  }
+
+  static const std::vector<testing::TestPartResult>& test_part_results(
+      const TestResult& test_result) {
+    return test_result.test_part_results();
+  }
+};
+
+#if GTEST_CAN_STREAM_RESULTS_
+
+// Streams test results to the given port on the given host machine.
+class GTEST_API_ StreamingListener : public EmptyTestEventListener {
+ public:
+  // Abstract base class for writing strings to a socket.
+  class AbstractSocketWriter {
+   public:
+    virtual ~AbstractSocketWriter() {}
+
+    // Sends a string to the socket.
+    virtual void Send(const string& message) = 0;
+
+    // Closes the socket.
+    virtual void CloseConnection() {}
+
+    // Sends a string and a newline to the socket.
+    void SendLn(const string& message) {
+      Send(message + "\n");
+    }
+  };
+
+  // Concrete class for actually writing strings to a socket.
+  class SocketWriter : public AbstractSocketWriter {
+   public:
+    SocketWriter(const string& host, const string& port)
+        : sockfd_(-1), host_name_(host), port_num_(port) {
+      MakeConnection();
+    }
+
+    virtual ~SocketWriter() {
+      if (sockfd_ != -1)
+        CloseConnection();
+    }
+
+    // Sends a string to the socket.
+    virtual void Send(const string& message) {
+      GTEST_CHECK_(sockfd_ != -1)
+          << "Send() can be called only when there is a connection.";
+
+      const int len = static_cast<int>(message.length());
+      if (write(sockfd_, message.c_str(), len) != len) {
+        GTEST_LOG_(WARNING)
+            << "stream_result_to: failed to stream to "
+            << host_name_ << ":" << port_num_;
+      }
+    }
+
+   private:
+    // Creates a client socket and connects to the server.
+    void MakeConnection();
+
+    // Closes the socket.
+    void CloseConnection() {
+      GTEST_CHECK_(sockfd_ != -1)
+          << "CloseConnection() can be called only when there is a connection.";
+
+      close(sockfd_);
+      sockfd_ = -1;
+    }
+
+    int sockfd_;  // socket file descriptor
+    const string host_name_;
+    const string port_num_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
+  };  // class SocketWriter
+
+  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
+  static string UrlEncode(const char* str);
+
+  StreamingListener(const string& host, const 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 */) {
+    SendLn("event=TestProgramStart");
+  }
+
+  void OnTestProgramEnd(const UnitTest& unit_test) {
+    // 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()));
+
+    // Notify the streaming server to stop.
+    socket_writer_->CloseConnection();
+  }
+
+  void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) {
+    SendLn("event=TestIterationStart&iteration=" +
+           StreamableToString(iteration));
+  }
+
+  void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) {
+    SendLn("event=TestIterationEnd&passed=" +
+           FormatBool(unit_test.Passed()) + "&elapsed_time=" +
+           StreamableToString(unit_test.elapsed_time()) + "ms");
+  }
+
+  void OnTestCaseStart(const TestCase& test_case) {
+    SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
+  }
+
+  void OnTestCaseEnd(const TestCase& test_case) {
+    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed())
+           + "&elapsed_time=" + StreamableToString(test_case.elapsed_time())
+           + "ms");
+  }
+
+  void OnTestStart(const TestInfo& test_info) {
+    SendLn(std::string("event=TestStart&name=") + test_info.name());
+  }
+
+  void OnTestEnd(const TestInfo& test_info) {
+    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) {
+    const char* file_name = test_part_result.file_name();
+    if (file_name == NULL)
+      file_name = "";
+    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
+           "&line=" + StreamableToString(test_part_result.line_number()) +
+           "&message=" + UrlEncode(test_part_result.message()));
+  }
+
+ private:
+  // Sends the given message and a newline to the socket.
+  void SendLn(const 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"); }
+
+  string FormatBool(bool value) { return value ? "1" : "0"; }
+
+  const scoped_ptr<AbstractSocketWriter> socket_writer_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
+};  // class StreamingListener
+
+#endif  // GTEST_CAN_STREAM_RESULTS_
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GTEST_SRC_GTEST_INTERNAL_INL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-port.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-port.cc
new file mode 100644
index 00000000..e5bf3dd2
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-port.cc
@@ -0,0 +1,1259 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "gtest/internal/gtest-port.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fstream>
+
+#if GTEST_OS_WINDOWS
+# include <windows.h>
+# include <io.h>
+# include <sys/stat.h>
+# include <map>  // Used in ThreadLocal.
+#else
+# include <unistd.h>
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_MAC
+# include <mach/mach_init.h>
+# include <mach/task.h>
+# include <mach/vm_map.h>
+#endif  // GTEST_OS_MAC
+
+#if GTEST_OS_QNX
+# include <devctl.h>
+# include <fcntl.h>
+# include <sys/procfs.h>
+#endif  // GTEST_OS_QNX
+
+#if GTEST_OS_AIX
+# include <procinfo.h>
+# include <sys/types.h>
+#endif  // GTEST_OS_AIX
+
+#include "gtest/gtest-spi.h"
+#include "gtest/gtest-message.h"
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-string.h"
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick exists to
+// prevent the accidental inclusion of gtest-internal-inl.h in the
+// user's code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+namespace testing {
+namespace internal {
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
+const int kStdOutFileno = 1;
+const int kStdErrFileno = 2;
+#else
+const int kStdOutFileno = STDOUT_FILENO;
+const int kStdErrFileno = STDERR_FILENO;
+#endif  // _MSC_VER
+
+#if GTEST_OS_LINUX
+
+namespace {
+template <typename T>
+T ReadProcFileField(const string& filename, int field) {
+  std::string dummy;
+  std::ifstream file(filename.c_str());
+  while (field-- > 0) {
+    file >> dummy;
+  }
+  T output = 0;
+  file >> output;
+  return output;
+}
+}  // namespace
+
+// Returns the number of active threads, or 0 when there is an error.
+size_t GetThreadCount() {
+  const string filename =
+      (Message() << "/proc/" << getpid() << "/stat").GetString();
+  return ReadProcFileField<int>(filename, 19);
+}
+
+#elif GTEST_OS_MAC
+
+size_t GetThreadCount() {
+  const task_t task = mach_task_self();
+  mach_msg_type_number_t thread_count;
+  thread_act_array_t thread_list;
+  const kern_return_t status = task_threads(task, &thread_list, &thread_count);
+  if (status == KERN_SUCCESS) {
+    // task_threads allocates resources in thread_list and we need to free them
+    // to avoid leaks.
+    vm_deallocate(task,
+                  reinterpret_cast<vm_address_t>(thread_list),
+                  sizeof(thread_t) * thread_count);
+    return static_cast<size_t>(thread_count);
+  } else {
+    return 0;
+  }
+}
+
+#elif GTEST_OS_QNX
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+size_t GetThreadCount() {
+  const int fd = open("/proc/self/as", O_RDONLY);
+  if (fd < 0) {
+    return 0;
+  }
+  procfs_info process_info;
+  const int status =
+      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), NULL);
+  close(fd);
+  if (status == EOK) {
+    return static_cast<size_t>(process_info.num_threads);
+  } else {
+    return 0;
+  }
+}
+
+#elif GTEST_OS_AIX
+
+size_t GetThreadCount() {
+  struct procentry64 entry;
+  pid_t pid = getpid();
+  int status = getprocs64(&entry, sizeof(entry), NULL, 0, &pid, 1);
+  if (status == 1) {
+    return entry.pi_thcount;
+  } else {
+    return 0;
+  }
+}
+
+#else
+
+size_t GetThreadCount() {
+  // There's no portable way to detect the number of threads, so we just
+  // return 0 to indicate that we cannot detect it.
+  return 0;
+}
+
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
+
+void SleepMilliseconds(int n) {
+  ::Sleep(n);
+}
+
+AutoHandle::AutoHandle()
+    : handle_(INVALID_HANDLE_VALUE) {}
+
+AutoHandle::AutoHandle(Handle handle)
+    : handle_(handle) {}
+
+AutoHandle::~AutoHandle() {
+  Reset();
+}
+
+AutoHandle::Handle AutoHandle::Get() const {
+  return handle_;
+}
+
+void AutoHandle::Reset() {
+  Reset(INVALID_HANDLE_VALUE);
+}
+
+void AutoHandle::Reset(HANDLE handle) {
+  // Resetting with the same handle we already own is invalid.
+  if (handle_ != handle) {
+    if (IsCloseable()) {
+      ::CloseHandle(handle_);
+    }
+    handle_ = handle;
+  } else {
+    GTEST_CHECK_(!IsCloseable())
+        << "Resetting a valid handle to itself is likely a programmer error "
+            "and thus not allowed.";
+  }
+}
+
+bool AutoHandle::IsCloseable() const {
+  // Different Windows APIs may use either of these values to represent an
+  // invalid handle.
+  return handle_ != NULL && handle_ != INVALID_HANDLE_VALUE;
+}
+
+Notification::Notification()
+    : event_(::CreateEvent(NULL,   // Default security attributes.
+                           TRUE,   // Do not reset automatically.
+                           FALSE,  // Initially unset.
+                           NULL)) {  // Anonymous event.
+  GTEST_CHECK_(event_.Get() != NULL);
+}
+
+void Notification::Notify() {
+  GTEST_CHECK_(::SetEvent(event_.Get()) != FALSE);
+}
+
+void Notification::WaitForNotification() {
+  GTEST_CHECK_(
+      ::WaitForSingleObject(event_.Get(), INFINITE) == WAIT_OBJECT_0);
+}
+
+Mutex::Mutex()
+    : owner_thread_id_(0),
+      type_(kDynamic),
+      critical_section_init_phase_(0),
+      critical_section_(new CRITICAL_SECTION) {
+  ::InitializeCriticalSection(critical_section_);
+}
+
+Mutex::~Mutex() {
+  // Static mutexes are leaked intentionally. It is not thread-safe to try
+  // to clean them up.
+  // TODO(yukawa): Switch to Slim Reader/Writer (SRW) Locks, which requires
+  // nothing to clean it up but is available only on Vista and later.
+  // http://msdn.microsoft.com/en-us/library/windows/desktop/aa904937.aspx
+  if (type_ == kDynamic) {
+    ::DeleteCriticalSection(critical_section_);
+    delete critical_section_;
+    critical_section_ = NULL;
+  }
+}
+
+void Mutex::Lock() {
+  ThreadSafeLazyInit();
+  ::EnterCriticalSection(critical_section_);
+  owner_thread_id_ = ::GetCurrentThreadId();
+}
+
+void Mutex::Unlock() {
+  ThreadSafeLazyInit();
+  // We don't protect writing to owner_thread_id_ here, as it's the
+  // caller's responsibility to ensure that the current thread holds the
+  // mutex when this is called.
+  owner_thread_id_ = 0;
+  ::LeaveCriticalSection(critical_section_);
+}
+
+// Does nothing if the current thread holds the mutex. Otherwise, crashes
+// with high probability.
+void Mutex::AssertHeld() {
+  ThreadSafeLazyInit();
+  GTEST_CHECK_(owner_thread_id_ == ::GetCurrentThreadId())
+      << "The current thread is not holding the mutex @" << this;
+}
+
+// Initializes owner_thread_id_ and critical_section_ in static mutexes.
+void Mutex::ThreadSafeLazyInit() {
+  // Dynamic mutexes are initialized in the constructor.
+  if (type_ == kStatic) {
+    switch (
+        ::InterlockedCompareExchange(&critical_section_init_phase_, 1L, 0L)) {
+      case 0:
+        // 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;
+        critical_section_ = new CRITICAL_SECTION;
+        ::InitializeCriticalSection(critical_section_);
+        // Updates the critical_section_init_phase_ to 2 to signal
+        // initialization complete.
+        GTEST_CHECK_(::InterlockedCompareExchange(
+                          &critical_section_init_phase_, 2L, 1L) ==
+                      1L);
+        break;
+      case 1:
+        // Somebody else is already initializing the mutex; spin until they
+        // are done.
+        while (::InterlockedCompareExchange(&critical_section_init_phase_,
+                                            2L,
+                                            2L) != 2L) {
+          // Possibly yields the rest of the thread's time slice to other
+          // threads.
+          ::Sleep(0);
+        }
+        break;
+
+      case 2:
+        break;  // The mutex is already initialized and ready for use.
+
+      default:
+        GTEST_CHECK_(false)
+            << "Unexpected value of critical_section_init_phase_ "
+            << "while initializing a static mutex.";
+    }
+  }
+}
+
+namespace {
+
+class ThreadWithParamSupport : public ThreadWithParamBase {
+ public:
+  static HANDLE CreateThread(Runnable* runnable,
+                             Notification* thread_can_start) {
+    ThreadMainParam* param = new ThreadMainParam(runnable, thread_can_start);
+    DWORD thread_id;
+    // TODO(yukawa): Consider to use _beginthreadex instead.
+    HANDLE thread_handle = ::CreateThread(
+        NULL,    // Default security.
+        0,       // Default stack size.
+        &ThreadWithParamSupport::ThreadMain,
+        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 != NULL) << "CreateThread failed with error "
+                                        << ::GetLastError() << ".";
+    if (thread_handle == NULL) {
+      delete param;
+    }
+    return thread_handle;
+  }
+
+ private:
+  struct ThreadMainParam {
+    ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
+        : runnable_(runnable),
+          thread_can_start_(thread_can_start) {
+    }
+    scoped_ptr<Runnable> runnable_;
+    // Does not own.
+    Notification* thread_can_start_;
+  };
+
+  static DWORD WINAPI ThreadMain(void* ptr) {
+    // Transfers ownership.
+    scoped_ptr<ThreadMainParam> param(static_cast<ThreadMainParam*>(ptr));
+    if (param->thread_can_start_ != NULL)
+      param->thread_can_start_->WaitForNotification();
+    param->runnable_->Run();
+    return 0;
+  }
+
+  // Prohibit instantiation.
+  ThreadWithParamSupport();
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParamSupport);
+};
+
+}  // namespace
+
+ThreadWithParamBase::ThreadWithParamBase(Runnable *runnable,
+                                         Notification* thread_can_start)
+      : thread_(ThreadWithParamSupport::CreateThread(runnable,
+                                                     thread_can_start)) {
+}
+
+ThreadWithParamBase::~ThreadWithParamBase() {
+  Join();
+}
+
+void ThreadWithParamBase::Join() {
+  GTEST_CHECK_(::WaitForSingleObject(thread_.Get(), INFINITE) == WAIT_OBJECT_0)
+      << "Failed to join the thread with error " << ::GetLastError() << ".";
+}
+
+// Maps a thread to a set of ThreadIdToThreadLocals that have values
+// instantiated on that thread and notifies them when the thread exits.  A
+// ThreadLocal instance is expected to persist until all threads it has
+// values on have terminated.
+class ThreadLocalRegistryImpl {
+ public:
+  // Registers thread_local_instance as having value on the current thread.
+  // Returns a value that can be used to identify the thread from other threads.
+  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance) {
+    DWORD current_thread = ::GetCurrentThreadId();
+    MutexLock lock(&mutex_);
+    ThreadIdToThreadLocals* const thread_to_thread_locals =
+        GetThreadLocalsMapLocked();
+    ThreadIdToThreadLocals::iterator thread_local_pos =
+        thread_to_thread_locals->find(current_thread);
+    if (thread_local_pos == thread_to_thread_locals->end()) {
+      thread_local_pos = thread_to_thread_locals->insert(
+          std::make_pair(current_thread, ThreadLocalValues())).first;
+      StartWatcherThreadFor(current_thread);
+    }
+    ThreadLocalValues& thread_local_values = thread_local_pos->second;
+    ThreadLocalValues::iterator value_pos =
+        thread_local_values.find(thread_local_instance);
+    if (value_pos == thread_local_values.end()) {
+      value_pos =
+          thread_local_values
+              .insert(std::make_pair(
+                  thread_local_instance,
+                  linked_ptr<ThreadLocalValueHolderBase>(
+                      thread_local_instance->NewValueForCurrentThread())))
+              .first;
+    }
+    return value_pos->second.get();
+  }
+
+  static void OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance) {
+    std::vector<linked_ptr<ThreadLocalValueHolderBase> > value_holders;
+    // Clean up the ThreadLocalValues data structure while holding the lock, but
+    // defer the destruction of the ThreadLocalValueHolderBases.
+    {
+      MutexLock lock(&mutex_);
+      ThreadIdToThreadLocals* const thread_to_thread_locals =
+          GetThreadLocalsMapLocked();
+      for (ThreadIdToThreadLocals::iterator it =
+          thread_to_thread_locals->begin();
+          it != thread_to_thread_locals->end();
+          ++it) {
+        ThreadLocalValues& thread_local_values = it->second;
+        ThreadLocalValues::iterator value_pos =
+            thread_local_values.find(thread_local_instance);
+        if (value_pos != thread_local_values.end()) {
+          value_holders.push_back(value_pos->second);
+          thread_local_values.erase(value_pos);
+          // This 'if' can only be successful at most once, so theoretically we
+          // could break out of the loop here, but we don't bother doing so.
+        }
+      }
+    }
+    // Outside the lock, let the destructor for 'value_holders' deallocate the
+    // ThreadLocalValueHolderBases.
+  }
+
+  static void OnThreadExit(DWORD thread_id) {
+    GTEST_CHECK_(thread_id != 0) << ::GetLastError();
+    std::vector<linked_ptr<ThreadLocalValueHolderBase> > value_holders;
+    // Clean up the ThreadIdToThreadLocals data structure while holding the
+    // lock, but defer the destruction of the ThreadLocalValueHolderBases.
+    {
+      MutexLock lock(&mutex_);
+      ThreadIdToThreadLocals* const thread_to_thread_locals =
+          GetThreadLocalsMapLocked();
+      ThreadIdToThreadLocals::iterator thread_local_pos =
+          thread_to_thread_locals->find(thread_id);
+      if (thread_local_pos != thread_to_thread_locals->end()) {
+        ThreadLocalValues& thread_local_values = thread_local_pos->second;
+        for (ThreadLocalValues::iterator value_pos =
+            thread_local_values.begin();
+            value_pos != thread_local_values.end();
+            ++value_pos) {
+          value_holders.push_back(value_pos->second);
+        }
+        thread_to_thread_locals->erase(thread_local_pos);
+      }
+    }
+    // Outside the lock, let the destructor for 'value_holders' deallocate the
+    // ThreadLocalValueHolderBases.
+  }
+
+ private:
+  // In a particular thread, maps a ThreadLocal object to its value.
+  typedef std::map<const ThreadLocalBase*,
+                   linked_ptr<ThreadLocalValueHolderBase> > ThreadLocalValues;
+  // Stores all ThreadIdToThreadLocals having values in a thread, indexed by
+  // thread's ID.
+  typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;
+
+  // Holds the thread id and thread handle that we pass from
+  // StartWatcherThreadFor to WatcherThreadFunc.
+  typedef std::pair<DWORD, HANDLE> ThreadIdAndHandle;
+
+  static void StartWatcherThreadFor(DWORD thread_id) {
+    // The returned handle will be kept in thread_map and closed by
+    // watcher_thread in WatcherThreadFunc.
+    HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION,
+                                 FALSE,
+                                 thread_id);
+    GTEST_CHECK_(thread != NULL);
+    // We need to to pass a valid thread ID pointer into CreateThread for it
+    // to work correctly under Win98.
+    DWORD watcher_thread_id;
+    HANDLE watcher_thread = ::CreateThread(
+        NULL,   // 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 != NULL);
+    // Give the watcher thread the same priority as ours to avoid being
+    // blocked by it.
+    ::SetThreadPriority(watcher_thread,
+                        ::GetThreadPriority(::GetCurrentThread()));
+    ::ResumeThread(watcher_thread);
+    ::CloseHandle(watcher_thread);
+  }
+
+  // Monitors exit from a given thread and notifies those
+  // ThreadIdToThreadLocals about thread termination.
+  static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
+    const ThreadIdAndHandle* tah =
+        reinterpret_cast<const ThreadIdAndHandle*>(param);
+    GTEST_CHECK_(
+        ::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0);
+    OnThreadExit(tah->first);
+    ::CloseHandle(tah->second);
+    delete tah;
+    return 0;
+  }
+
+  // Returns map of thread local instances.
+  static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
+    mutex_.AssertHeld();
+    static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals;
+    return map;
+  }
+
+  // Protects access to GetThreadLocalsMapLocked() and its return value.
+  static Mutex mutex_;
+  // Protects access to GetThreadMapLocked() and its return value.
+  static Mutex thread_map_mutex_;
+};
+
+Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex);
+Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex);
+
+ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance) {
+  return ThreadLocalRegistryImpl::GetValueOnCurrentThread(
+      thread_local_instance);
+}
+
+void ThreadLocalRegistry::OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance) {
+  ThreadLocalRegistryImpl::OnThreadLocalDestroyed(thread_local_instance);
+}
+
+#endif  // GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
+
+#if GTEST_USES_POSIX_RE
+
+// Implements RE.  Currently only needed for death tests.
+
+RE::~RE() {
+  if (is_valid_) {
+    // regfree'ing an invalid regex might crash because the content
+    // of the regex is undefined. Since the regex's are essentially
+    // the same, one cannot be valid (or invalid) without the other
+    // being so too.
+    regfree(&partial_regex_);
+    regfree(&full_regex_);
+  }
+  free(const_cast<char*>(pattern_));
+}
+
+// Returns true iff regular expression re matches the entire str.
+bool RE::FullMatch(const char* str, const RE& re) {
+  if (!re.is_valid_) return false;
+
+  regmatch_t match;
+  return regexec(&re.full_regex_, str, 1, &match, 0) == 0;
+}
+
+// Returns true iff 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;
+
+  regmatch_t match;
+  return regexec(&re.partial_regex_, str, 1, &match, 0) == 0;
+}
+
+// Initializes an RE from its string representation.
+void RE::Init(const char* regex) {
+  pattern_ = posix::StrDup(regex);
+
+  // Reserves enough bytes to hold the regular expression used for a
+  // full match.
+  const size_t full_regex_len = strlen(regex) + 10;
+  char* const full_pattern = new char[full_regex_len];
+
+  snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
+  is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
+  // We want to call regcomp(&partial_regex_, ...) even if the
+  // previous expression returns false.  Otherwise partial_regex_ may
+  // not be properly initialized can may cause trouble when it's
+  // freed.
+  //
+  // Some implementation of POSIX regex (e.g. on at least some
+  // versions of Cygwin) doesn't accept the empty string as a valid
+  // regex.  We change it to an equivalent form "()" to be safe.
+  if (is_valid_) {
+    const char* const partial_regex = (*regex == '\0') ? "()" : regex;
+    is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
+  }
+  EXPECT_TRUE(is_valid_)
+      << "Regular expression \"" << regex
+      << "\" is not a valid POSIX Extended regular expression.";
+
+  delete[] full_pattern;
+}
+
+#elif GTEST_USES_SIMPLE_RE
+
+// Returns true iff ch appears anywhere in str (excluding the
+// terminating '\0' character).
+bool IsInSet(char ch, const char* str) {
+  return ch != '\0' && strchr(str, ch) != NULL;
+}
+
+// Returns true iff 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) {
+  return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~");
+}
+bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
+bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
+bool IsAsciiWordChar(char ch) {
+  return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') ||
+      ('0' <= ch && ch <= '9') || ch == '_';
+}
+
+// Returns true iff "\\c" is a supported escape sequence.
+bool IsValidEscape(char c) {
+  return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW"));
+}
+
+// Returns true iff 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) {
+      case 'd': return IsAsciiDigit(ch);
+      case 'D': return !IsAsciiDigit(ch);
+      case 'f': return ch == '\f';
+      case 'n': return ch == '\n';
+      case 'r': return ch == '\r';
+      case 's': return IsAsciiWhiteSpace(ch);
+      case 'S': return !IsAsciiWhiteSpace(ch);
+      case 't': return ch == '\t';
+      case 'v': return ch == '\v';
+      case 'w': return IsAsciiWordChar(ch);
+      case 'W': return !IsAsciiWordChar(ch);
+    }
+    return IsAsciiPunct(pattern_char) && pattern_char == ch;
+  }
+
+  return (pattern_char == '.' && ch != '\n') || pattern_char == ch;
+}
+
+// Helper function used by ValidateRegex() to format error messages.
+std::string FormatRegexSyntaxError(const char* regex, int index) {
+  return (Message() << "Syntax error at index " << index
+          << " in simple regular expression \"" << regex << "\": ").GetString();
+}
+
+// Generates non-fatal failures and returns false if regex is invalid;
+// otherwise returns true.
+bool ValidateRegex(const char* regex) {
+  if (regex == NULL) {
+    // TODO(wan@google.com): fix the source file location in the
+    // assertion failures to match where the regex is used in user
+    // code.
+    ADD_FAILURE() << "NULL is not a valid simple regular expression.";
+    return false;
+  }
+
+  bool is_valid = true;
+
+  // True iff ?, *, or + can follow the previous atom.
+  bool prev_repeatable = false;
+  for (int i = 0; regex[i]; i++) {
+    if (regex[i] == '\\') {  // An escape sequence
+      i++;
+      if (regex[i] == '\0') {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
+                      << "'\\' cannot appear at the end.";
+        return false;
+      }
+
+      if (!IsValidEscape(regex[i])) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
+                      << "invalid escape sequence \"\\" << regex[i] << "\".";
+        is_valid = false;
+      }
+      prev_repeatable = true;
+    } else {  // Not an escape sequence.
+      const char ch = regex[i];
+
+      if (ch == '^' && i > 0) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'^' can only appear at the beginning.";
+        is_valid = false;
+      } else if (ch == '$' && regex[i + 1] != '\0') {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'$' can only appear at the end.";
+        is_valid = false;
+      } else if (IsInSet(ch, "()[]{}|")) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'" << ch << "' is unsupported.";
+        is_valid = false;
+      } else if (IsRepeat(ch) && !prev_repeatable) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'" << ch << "' can only follow a repeatable token.";
+        is_valid = false;
+      }
+
+      prev_repeatable = !IsInSet(ch, "^$?*+");
+    }
+  }
+
+  return is_valid;
+}
+
+// Matches a repeated regex atom followed by a valid simple regular
+// expression.  The regex atom is defined as c if escaped is false,
+// or \c otherwise.  repeat is the repetition meta character (?, *,
+// or +).  The behavior is undefined if str contains too many
+// characters to be indexable by size_t, in which case the test will
+// probably time out anyway.  We are fine with this limitation as
+// std::string has it too.
+bool MatchRepetitionAndRegexAtHead(
+    bool escaped, char c, char repeat, const char* regex,
+    const char* str) {
+  const size_t min_count = (repeat == '+') ? 1 : 0;
+  const size_t max_count = (repeat == '?') ? 1 :
+      static_cast<size_t>(-1) - 1;
+  // We cannot call numeric_limits::max() as it conflicts with the
+  // max() macro on Windows.
+
+  for (size_t i = 0; i <= max_count; ++i) {
+    // We know that the atom matches each of the first i characters in str.
+    if (i >= min_count && MatchRegexAtHead(regex, str + i)) {
+      // We have enough matches at the head, and the tail matches too.
+      // Since we only care about *whether* the pattern matches str
+      // (as opposed to *how* it matches), there is no need to find a
+      // greedy match.
+      return true;
+    }
+    if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i]))
+      return false;
+  }
+  return false;
+}
+
+// Returns true iff 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.
+    return true;
+
+  // "$" only matches the end of a string.  Note that regex being
+  // valid guarantees that there's nothing after "$" in it.
+  if (*regex == '$')
+    return *str == '\0';
+
+  // Is the first thing in regex an escape sequence?
+  const bool escaped = *regex == '\\';
+  if (escaped)
+    ++regex;
+  if (IsRepeat(regex[1])) {
+    // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so
+    // here's an indirect recursion.  It terminates as the regex gets
+    // shorter in each recursion.
+    return MatchRepetitionAndRegexAtHead(
+        escaped, regex[0], regex[1], regex + 2, str);
+  } else {
+    // regex isn't empty, isn't "$", and doesn't start with a
+    // repetition.  We match the first atom of regex with the first
+    // character of str and recurse.
+    return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) &&
+        MatchRegexAtHead(regex + 1, str + 1);
+  }
+}
+
+// Returns true iff 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
+// stack space normally.  In rare cases the time complexity can be
+// 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 == NULL || str == NULL)
+    return false;
+
+  if (*regex == '^')
+    return MatchRegexAtHead(regex + 1, str);
+
+  // A successful match can be anywhere in str.
+  do {
+    if (MatchRegexAtHead(regex, str))
+      return true;
+  } while (*str++ != '\0');
+  return false;
+}
+
+// Implements the RE class.
+
+RE::~RE() {
+  free(const_cast<char*>(pattern_));
+  free(const_cast<char*>(full_pattern_));
+}
+
+// Returns true iff 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 iff 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_ = NULL;
+  if (regex != NULL) {
+    pattern_ = posix::StrDup(regex);
+  }
+
+  is_valid_ = ValidateRegex(regex);
+  if (!is_valid_) {
+    // No need to calculate the full pattern when the regex is invalid.
+    return;
+  }
+
+  const size_t len = strlen(regex);
+  // Reserves enough bytes to hold the regular expression used for a
+  // full match: we need space to prepend a '^', append a '$', and
+  // terminate the string with '\0'.
+  char* buffer = static_cast<char*>(malloc(len + 3));
+  full_pattern_ = buffer;
+
+  if (*regex != '^')
+    *buffer++ = '^';  // Makes sure full_pattern_ starts with '^'.
+
+  // We don't use snprintf or strncpy, as they trigger a warning when
+  // compiled with VC++ 8.0.
+  memcpy(buffer, regex, len);
+  buffer += len;
+
+  if (len == 0 || regex[len - 1] != '$')
+    *buffer++ = '$';  // Makes sure full_pattern_ ends with '$'.
+
+  *buffer = '\0';
+}
+
+#endif  // GTEST_USES_POSIX_RE
+
+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 == NULL ? kUnknownFile : file);
+
+  if (line < 0) {
+    return file_name + ":";
+  }
+#ifdef _MSC_VER
+  return file_name + "(" + StreamableToString(line) + "):";
+#else
+  return file_name + ":" + StreamableToString(line) + ":";
+#endif  // _MSC_VER
+}
+
+// Formats a file location for compiler-independent XML output.
+// Although this function is not platform dependent, we put it next to
+// FormatFileLocation in order to contrast the two functions.
+// Note that FormatCompilerIndependentFileLocation() does NOT append colon
+// to the file location it produces, unlike FormatFileLocation().
+GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
+    const char* file, int line) {
+  const std::string file_name(file == NULL ? kUnknownFile : file);
+
+  if (line < 0)
+    return file_name;
+  else
+    return file_name + ":" + StreamableToString(line);
+}
+
+GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
+    : severity_(severity) {
+  const char* const marker =
+      severity == GTEST_INFO ?    "[  INFO ]" :
+      severity == GTEST_WARNING ? "[WARNING]" :
+      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
+  GetStream() << ::std::endl << marker << " "
+              << FormatFileLocation(file, line).c_str() << ": ";
+}
+
+// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
+GTestLog::~GTestLog() {
+  GetStream() << ::std::endl;
+  if (severity_ == GTEST_FATAL) {
+    fflush(stderr);
+    posix::Abort();
+  }
+}
+// Disable Microsoft deprecation warnings for POSIX functions called from
+// this class (creat, dup, dup2, and close)
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Object that captures an output stream (stdout/stderr).
+class CapturedStream {
+ public:
+  // The ctor redirects the stream to a temporary file.
+  explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
+# if GTEST_OS_WINDOWS
+    char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
+    char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT
+
+    ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
+    const UINT success = ::GetTempFileNameA(temp_dir_path,
+                                            "gtest_redir",
+                                            0,  // Generate unique file name.
+                                            temp_file_path);
+    GTEST_CHECK_(success != 0)
+        << "Unable to create a temporary file in " << temp_dir_path;
+    const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
+    GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file "
+                                    << temp_file_path;
+    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 the /tmp directory
+    // instead. We use /tmp on most systems, and /sdcard on Android.
+    // That's because Android doesn't have /tmp.
+#  if GTEST_OS_LINUX_ANDROID
+    // Note: Android applications are expected to call the framework's
+    // Context.getExternalStorageDirectory() method through JNI to get
+    // the location of the world-writable SD Card directory. However,
+    // this requires a Context handle, which cannot be retrieved
+    // globally from native code. Doing so also precludes running the
+    // 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 /sdcard is directly accessible from native code
+    // and is the only location (unofficially) supported by the Android
+    // team. It's generally a symlink to the real SD Card mount point
+    // which can be /mnt/sdcard, /mnt/sdcard0, /system/media/sdcard, or
+    // other OEM-customized locations. Never rely on these, and always
+    // use /sdcard.
+    char name_template[] = "/sdcard/gtest_captured_stream.XXXXXX";
+#  else
+    char name_template[] = "/tmp/captured_stream.XXXXXX";
+#  endif  // GTEST_OS_LINUX_ANDROID
+    const int captured_fd = mkstemp(name_template);
+    filename_ = name_template;
+# endif  // GTEST_OS_WINDOWS
+    fflush(NULL);
+    dup2(captured_fd, fd_);
+    close(captured_fd);
+  }
+
+  ~CapturedStream() {
+    remove(filename_.c_str());
+  }
+
+  std::string GetCapturedString() {
+    if (uncaptured_fd_ != -1) {
+      // Restores the original stream.
+      fflush(NULL);
+      dup2(uncaptured_fd_, fd_);
+      close(uncaptured_fd_);
+      uncaptured_fd_ = -1;
+    }
+
+    FILE* const file = posix::FOpen(filename_.c_str(), "r");
+    const std::string content = ReadEntireFile(file);
+    posix::FClose(file);
+    return content;
+  }
+
+ private:
+  const int fd_;  // A stream to capture.
+  int uncaptured_fd_;
+  // Name of the temporary file holding the stderr output.
+  ::std::string filename_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
+};
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+static CapturedStream* g_captured_stderr = NULL;
+static CapturedStream* g_captured_stdout = NULL;
+
+// Starts capturing an output stream (stdout/stderr).
+void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {
+  if (*stream != NULL) {
+    GTEST_LOG_(FATAL) << "Only one " << stream_name
+                      << " capturer can exist at a time.";
+  }
+  *stream = new CapturedStream(fd);
+}
+
+// Stops capturing the output stream and returns the captured string.
+std::string GetCapturedStream(CapturedStream** captured_stream) {
+  const std::string content = (*captured_stream)->GetCapturedString();
+
+  delete *captured_stream;
+  *captured_stream = NULL;
+
+  return content;
+}
+
+// Starts capturing stdout.
+void CaptureStdout() {
+  CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout);
+}
+
+// Starts capturing stderr.
+void CaptureStderr() {
+  CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr);
+}
+
+// Stops capturing stdout and returns the captured string.
+std::string GetCapturedStdout() {
+  return GetCapturedStream(&g_captured_stdout);
+}
+
+// Stops capturing stderr and returns the captured string.
+std::string GetCapturedStderr() {
+  return GetCapturedStream(&g_captured_stderr);
+}
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+std::string TempDir() {
+#if GTEST_OS_WINDOWS_MOBILE
+  return "\\temp\\";
+#elif GTEST_OS_WINDOWS
+  const char* temp_dir = posix::GetEnv("TEMP");
+  if (temp_dir == NULL || 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
+  return "/sdcard/";
+#else
+  return "/tmp/";
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+size_t GetFileSize(FILE* file) {
+  fseek(file, 0, SEEK_END);
+  return static_cast<size_t>(ftell(file));
+}
+
+std::string ReadEntireFile(FILE* file) {
+  const size_t file_size = GetFileSize(file);
+  char* const buffer = new char[file_size];
+
+  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
+  size_t bytes_read = 0;       // # of bytes read so far
+
+  fseek(file, 0, SEEK_SET);
+
+  // Keeps reading the file until we cannot read further or the
+  // pre-determined file size is reached.
+  do {
+    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
+    bytes_read += bytes_last_read;
+  } while (bytes_last_read > 0 && bytes_read < file_size);
+
+  const std::string content(buffer, bytes_read);
+  delete[] buffer;
+
+  return content;
+}
+
+#if GTEST_HAS_DEATH_TEST
+
+static const ::std::vector<testing::internal::string>* g_injected_test_argvs =
+                                        NULL;  // Owned.
+
+void SetInjectableArgvs(const ::std::vector<testing::internal::string>* argvs) {
+  if (g_injected_test_argvs != argvs)
+    delete g_injected_test_argvs;
+  g_injected_test_argvs = argvs;
+}
+
+const ::std::vector<testing::internal::string>& GetInjectableArgvs() {
+  if (g_injected_test_argvs != NULL) {
+    return *g_injected_test_argvs;
+  }
+  return GetArgvs();
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+#if GTEST_OS_WINDOWS_MOBILE
+namespace posix {
+void Abort() {
+  DebugBreak();
+  TerminateProcess(GetCurrentProcess(), 1);
+}
+}  // namespace posix
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+// Returns the name of the environment variable corresponding to the
+// given flag.  For example, FlagToEnvVar("foo") will return
+// "GTEST_FOO" in the open-source version.
+static std::string FlagToEnvVar(const char* flag) {
+  const std::string full_flag =
+      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
+
+  Message env_var;
+  for (size_t i = 0; i != full_flag.length(); i++) {
+    env_var << ToUpper(full_flag.c_str()[i]);
+  }
+
+  return env_var.GetString();
+}
+
+// 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* value) {
+  // Parses the environment variable as a decimal integer.
+  char* end = NULL;
+  const long long_value = strtol(str, &end, 10);  // NOLINT
+
+  // Has strtol() consumed all characters in the string?
+  if (*end != '\0') {
+    // No - an invalid character was encountered.
+    Message msg;
+    msg << "WARNING: " << src_text
+        << " is expected to be a 32-bit integer, but actually"
+        << " has value \"" << str << "\".\n";
+    printf("%s", msg.GetString().c_str());
+    fflush(stdout);
+    return false;
+  }
+
+  // Is the parsed value in the range of an Int32?
+  const Int32 result = static_cast<Int32>(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.
+      ) {
+    Message msg;
+    msg << "WARNING: " << src_text
+        << " is expected to be a 32-bit integer, but actually"
+        << " has value " << str << ", which overflows.\n";
+    printf("%s", msg.GetString().c_str());
+    fflush(stdout);
+    return false;
+  }
+
+  *value = result;
+  return true;
+}
+
+// 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 iff 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);
+#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
+  const std::string env_var = FlagToEnvVar(flag);
+  const char* const string_value = posix::GetEnv(env_var.c_str());
+  return string_value == NULL ?
+      default_value : strcmp(string_value, "0") != 0;
+}
+
+// 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 Int32FromGTestEnv(const char* flag, Int32 default_value) {
+#if defined(GTEST_GET_INT32_FROM_ENV_)
+  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
+#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
+  const std::string env_var = FlagToEnvVar(flag);
+  const char* const string_value = posix::GetEnv(env_var.c_str());
+  if (string_value == NULL) {
+    // The environment variable is not set.
+    return default_value;
+  }
+
+  Int32 result = default_value;
+  if (!ParseInt32(Message() << "Environment variable " << env_var,
+                  string_value, &result)) {
+    printf("The default value %s is used.\n",
+           (Message() << default_value).GetString().c_str());
+    fflush(stdout);
+    return default_value;
+  }
+
+  return result;
+}
+
+// Reads and returns the string environment variable corresponding to
+// the given flag; if it's not set, returns default_value.
+std::string StringFromGTestEnv(const char* flag, const char* default_value) {
+#if defined(GTEST_GET_STRING_FROM_ENV_)
+  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
+#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
+  const std::string env_var = FlagToEnvVar(flag);
+  const char* value = posix::GetEnv(env_var.c_str());
+  if (value != NULL) {
+    return value;
+  }
+
+  // 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.
+  //
+  // The net priority order after flag processing is thus:
+  //   --gtest_output command line flag
+  //   GTEST_OUTPUT environment variable
+  //   XML_OUTPUT_FILE environment variable
+  //   'default_value'
+  if (strcmp(flag, "output") == 0) {
+    value = posix::GetEnv("XML_OUTPUT_FILE");
+    if (value != NULL) {
+      return std::string("xml:") + value;
+    }
+  }
+  return default_value;
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-printers.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-printers.cc
new file mode 100644
index 00000000..a2df412f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-printers.cc
@@ -0,0 +1,373 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Test - The Google C++ Testing Framework
+//
+// This file implements a universal value printer that can print a
+// value of any type T:
+//
+//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
+//
+// It uses the << operator when possible, and prints the bytes in the
+// object otherwise.  A user can override its behavior for a class
+// type Foo by defining either operator<<(::std::ostream&, const Foo&)
+// or void PrintTo(const Foo&, ::std::ostream*) in the namespace that
+// defines Foo.
+
+#include "gtest/gtest-printers.h"
+#include <ctype.h>
+#include <stdio.h>
+#include <cwchar>
+#include <ostream>  // NOLINT
+#include <string>
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+
+namespace {
+
+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_THREAD_
+void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
+                                size_t count, ostream* os) {
+  char text[5] = "";
+  for (size_t i = 0; i != count; i++) {
+    const size_t j = start + i;
+    if (i != 0) {
+      // Organizes the bytes into groups of 2 for easy parsing by
+      // human.
+      if ((j % 2) == 0)
+        *os << ' ';
+      else
+        *os << '-';
+    }
+    GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
+    *os << text;
+  }
+}
+
+// Prints the bytes in the given value to the given ostream.
+void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
+                              ostream* os) {
+  // Tells the user how big the object is.
+  *os << count << "-byte object <";
+
+  const size_t kThreshold = 132;
+  const size_t kChunkSize = 64;
+  // If the object size is bigger than kThreshold, we'll have to omit
+  // some details by printing only the first and the last kChunkSize
+  // bytes.
+  // TODO(wan): let the user control the threshold using a flag.
+  if (count < kThreshold) {
+    PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
+  } else {
+    PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os);
+    *os << " ... ";
+    // Rounds up to 2-byte boundary.
+    const size_t resume_pos = (count - kChunkSize + 1)/2*2;
+    PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os);
+  }
+  *os << ">";
+}
+
+}  // namespace
+
+namespace internal2 {
+
+// Delegates to PrintBytesInObjectToImpl() to print the bytes in the
+// given object.  The delegation simplifies the implementation, which
+// uses the << operator and thus is easier done outside of the
+// ::testing::internal namespace, which contains a << operator that
+// sometimes conflicts with the one in STL.
+void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
+                          ostream* os) {
+  PrintBytesInObjectToImpl(obj_bytes, count, os);
+}
+
+}  // namespace internal2
+
+namespace internal {
+
+// 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 hexidecimal escape sequence (e.g. '\x7F'), or
+//   - as a special escape sequence (e.g. '\r', '\n').
+enum CharFormat {
+  kAsIs,
+  kHexEscape,
+  kSpecialEscape
+};
+
+// 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(wchar_t c) {
+  return 0x20 <= c && c <= 0x7E;
+}
+
+// Prints a wide or narrow char c as a character literal without the
+// quotes, escaping it when necessary; returns how c was formatted.
+// The template argument UnsignedChar is the unsigned version of Char,
+// which is the type of c.
+template <typename UnsignedChar, typename Char>
+static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
+  switch (static_cast<wchar_t>(c)) {
+    case L'\0':
+      *os << "\\0";
+      break;
+    case L'\'':
+      *os << "\\'";
+      break;
+    case L'\\':
+      *os << "\\\\";
+      break;
+    case L'\a':
+      *os << "\\a";
+      break;
+    case L'\b':
+      *os << "\\b";
+      break;
+    case L'\f':
+      *os << "\\f";
+      break;
+    case L'\n':
+      *os << "\\n";
+      break;
+    case L'\r':
+      *os << "\\r";
+      break;
+    case L'\t':
+      *os << "\\t";
+      break;
+    case L'\v':
+      *os << "\\v";
+      break;
+    default:
+      if (IsPrintableAscii(c)) {
+        *os << static_cast<char>(c);
+        return kAsIs;
+      } else {
+        *os << "\\x" + String::FormatHexInt(static_cast<UnsignedChar>(c));
+        return kHexEscape;
+      }
+  }
+  return kSpecialEscape;
+}
+
+// Prints a wchar_t c as if it's part of a string literal, escaping it when
+// necessary; returns how c was formatted.
+static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
+  switch (c) {
+    case L'\'':
+      *os << "'";
+      return kAsIs;
+    case L'"':
+      *os << "\\\"";
+      return kSpecialEscape;
+    default:
+      return PrintAsCharLiteralTo<wchar_t>(c, os);
+  }
+}
+
+// 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(
+      static_cast<wchar_t>(static_cast<unsigned char>(c)), os);
+}
+
+// Prints a wide or narrow character c and its code.  '\0' is printed
+// as "'\\0'", other unprintable characters are also properly escaped
+// using the standard C++ escape sequence.  The template argument
+// UnsignedChar is the unsigned version of Char, which is the type of c.
+template <typename UnsignedChar, typename Char>
+void PrintCharAndCodeTo(Char c, ostream* os) {
+  // First, print c as a literal in the most readable form we can find.
+  *os << ((sizeof(c) > 1) ? "L'" : "'");
+  const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
+  *os << "'";
+
+  // To aid user debugging, we also print c's code in decimal, unless
+  // it's 0 (in which case c was printed as '\\0', making the code
+  // obvious).
+  if (c == 0)
+    return;
+  *os << " (" << static_cast<int>(c);
+
+  // For more convenience, we print c's code again in hexidecimal,
+  // 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<UnsignedChar>(c));
+  }
+  *os << ")";
+}
+
+void PrintTo(unsigned char c, ::std::ostream* os) {
+  PrintCharAndCodeTo<unsigned char>(c, os);
+}
+void PrintTo(signed char c, ::std::ostream* os) {
+  PrintCharAndCodeTo<unsigned char>(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<wchar_t>(wc, os);
+}
+
+// Prints the given array of characters to the ostream.  CharType must be either
+// char 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_THREAD_
+static void PrintCharsAsStringTo(
+    const CharType* begin, size_t len, ostream* os) {
+  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
+  *os << kQuoteBegin;
+  bool is_previous_hex = false;
+  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 << "\" " << kQuoteBegin;
+    }
+    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
+  }
+  *os << "\"";
+}
+
+// Prints a (const) char/wchar_t array of 'len' elements, starting at address
+// 'begin'.  CharType must be either char or wchar_t.
+template <typename CharType>
+GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+static void UniversalPrintCharArray(
+    const CharType* begin, size_t len, ostream* os) {
+  // The code
+  //   const char kFoo[] = "foo";
+  // generates an array of 4, not 3, elements, with the last one being '\0'.
+  //
+  // Therefore when printing a char array, we don't print the last element if
+  // it's '\0', such that the output matches the string literal as it's
+  // written in the source code.
+  if (len > 0 && begin[len - 1] == '\0') {
+    PrintCharsAsStringTo(begin, len - 1, os);
+    return;
+  }
+
+  // If, however, the last element in the array is not '\0', e.g.
+  //    const char kFoo[] = { 'f', 'o', 'o' };
+  // we must print the entire array.  We also print a message to indicate
+  // that the array is not NUL-terminated.
+  PrintCharsAsStringTo(begin, len, os);
+  *os << " (no terminating NUL)";
+}
+
+// Prints a (const) char array of 'len' elements, starting at address 'begin'.
+void UniversalPrintArray(const char* 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);
+}
+
+// Prints the given C string to the ostream.
+void PrintTo(const char* s, ostream* os) {
+  if (s == NULL) {
+    *os << "NULL";
+  } else {
+    *os << ImplicitCast_<const void*>(s) << " pointing to ";
+    PrintCharsAsStringTo(s, strlen(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,
+// possibly accessing more memory than intended and causing invalid
+// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
+// 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) {
+  if (s == NULL) {
+    *os << "NULL";
+  } else {
+    *os << ImplicitCast_<const void*>(s) << " pointing to ";
+    PrintCharsAsStringTo(s, std::wcslen(s), os);
+  }
+}
+#endif  // wchar_t is native
+
+// Prints a ::string object.
+#if GTEST_HAS_GLOBAL_STRING
+void PrintStringTo(const ::string& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+void PrintStringTo(const ::std::string& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+
+// Prints a ::wstring object.
+#if GTEST_HAS_GLOBAL_WSTRING
+void PrintWideStringTo(const ::wstring& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+#if GTEST_HAS_STD_WSTRING
+void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+}  // namespace internal
+
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-test-part.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-test-part.cc
new file mode 100644
index 00000000..fb0e3542
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-test-part.cc
@@ -0,0 +1,110 @@
+// 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.
+//
+// Author: mheule@google.com (Markus Heule)
+//
+// The Google C++ Testing Framework (Google Test)
+
+#include "gtest/gtest-test-part.h"
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick exists to
+// prevent the accidental inclusion of gtest-internal-inl.h in the
+// user's code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+namespace testing {
+
+using internal::GetUnitTestImpl;
+
+// Gets the summary of the failure message by omitting the stack trace
+// in it.
+std::string TestPartResult::ExtractSummary(const char* message) {
+  const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
+  return stack_trace == NULL ? message :
+      std::string(message, stack_trace);
+}
+
+// Prints a TestPartResult object.
+std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
+  return os
+      << result.file_name() << ":" << result.line_number() << ": "
+      << (result.type() == TestPartResult::kSuccess ? "Success" :
+          result.type() == TestPartResult::kFatalFailure ? "Fatal failure" :
+          "Non-fatal failure") << ":\n"
+      << result.message() << std::endl;
+}
+
+// Appends a TestPartResult to the array.
+void TestPartResultArray::Append(const TestPartResult& result) {
+  array_.push_back(result);
+}
+
+// Returns the TestPartResult at the given index (0-based).
+const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
+  if (index < 0 || index >= size()) {
+    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
+    internal::posix::Abort();
+  }
+
+  return array_[index];
+}
+
+// Returns the number of TestPartResult objects in the array.
+int TestPartResultArray::size() const {
+  return static_cast<int>(array_.size());
+}
+
+namespace internal {
+
+HasNewFatalFailureHelper::HasNewFatalFailureHelper()
+    : has_new_fatal_failure_(false),
+      original_reporter_(GetUnitTestImpl()->
+                         GetTestPartResultReporterForCurrentThread()) {
+  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
+}
+
+HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
+  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
+      original_reporter_);
+}
+
+void HasNewFatalFailureHelper::ReportTestPartResult(
+    const TestPartResult& result) {
+  if (result.fatally_failed())
+    has_new_fatal_failure_ = true;
+  original_reporter_->ReportTestPartResult(result);
+}
+
+}  // namespace internal
+
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-typed-test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-typed-test.cc
new file mode 100644
index 00000000..df1eef47
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-typed-test.cc
@@ -0,0 +1,118 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "gtest/gtest-typed-test.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+namespace internal {
+
+#if GTEST_HAS_TYPED_TEST_P
+
+// Skips to the first non-space char in str. Returns an empty string if str
+// contains only whitespace characters.
+static const char* SkipSpaces(const char* str) {
+  while (IsSpace(*str))
+    str++;
+  return str;
+}
+
+static std::vector<std::string> SplitIntoTestNames(const char* src) {
+  std::vector<std::string> name_vec;
+  src = SkipSpaces(src);
+  for (; src != NULL; src = SkipComma(src)) {
+    name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
+  }
+  return name_vec;
+}
+
+// Verifies that registered_tests match the test names in
+// registered_tests_; returns registered_tests if successful, or
+// aborts the program otherwise.
+const char* TypedTestCasePState::VerifyRegisteredTestNames(
+    const char* file, int line, const char* registered_tests) {
+  typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
+  registered_ = true;
+
+  std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests);
+
+  Message errors;
+
+  std::set<std::string> tests;
+  for (std::vector<std::string>::const_iterator name_it = name_vec.begin();
+       name_it != name_vec.end(); ++name_it) {
+    const std::string& name = *name_it;
+    if (tests.count(name) != 0) {
+      errors << "Test " << name << " is listed more than once.\n";
+      continue;
+    }
+
+    bool found = false;
+    for (RegisteredTestIter it = registered_tests_.begin();
+         it != registered_tests_.end();
+         ++it) {
+      if (name == it->first) {
+        found = true;
+        break;
+      }
+    }
+
+    if (found) {
+      tests.insert(name);
+    } else {
+      errors << "No test named " << name
+             << " can be found in this test case.\n";
+    }
+  }
+
+  for (RegisteredTestIter it = registered_tests_.begin();
+       it != registered_tests_.end();
+       ++it) {
+    if (tests.count(it->first) == 0) {
+      errors << "You forgot to list test " << it->first << ".\n";
+    }
+  }
+
+  const std::string& errors_str = errors.GetString();
+  if (errors_str != "") {
+    fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
+            errors_str.c_str());
+    fflush(stderr);
+    posix::Abort();
+  }
+
+  return registered_tests;
+}
+
+#endif  // GTEST_HAS_TYPED_TEST_P
+
+}  // namespace internal
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest.cc
new file mode 100644
index 00000000..d882ab2e
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest.cc
@@ -0,0 +1,5388 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// The Google C++ Testing Framework (Google Test)
+
+#include "gtest/gtest.h"
+#include "gtest/internal/custom/gtest.h"
+#include "gtest/gtest-spi.h"
+
+#include <ctype.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <wchar.h>
+#include <wctype.h>
+
+#include <algorithm>
+#include <iomanip>
+#include <limits>
+#include <list>
+#include <map>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <vector>
+
+#if GTEST_OS_LINUX
+
+// TODO(kenton@google.com): Use autoconf to detect availability of
+// gettimeofday().
+# define GTEST_HAS_GETTIMEOFDAY_ 1
+
+# include <fcntl.h>  // NOLINT
+# include <limits.h>  // NOLINT
+# include <sched.h>  // NOLINT
+// Declares vsnprintf().  This header is not available on Windows.
+# include <strings.h>  // NOLINT
+# include <sys/mman.h>  // NOLINT
+# include <sys/time.h>  // NOLINT
+# include <unistd.h>  // NOLINT
+# include <string>
+
+#elif GTEST_OS_SYMBIAN
+# define GTEST_HAS_GETTIMEOFDAY_ 1
+# include <sys/time.h>  // NOLINT
+
+#elif GTEST_OS_ZOS
+# define GTEST_HAS_GETTIMEOFDAY_ 1
+# include <sys/time.h>  // NOLINT
+
+// On z/OS we additionally need strings.h for strcasecmp.
+# include <strings.h>  // NOLINT
+
+#elif GTEST_OS_WINDOWS_MOBILE  // We are on Windows CE.
+
+# include <windows.h>  // NOLINT
+# undef min
+
+#elif GTEST_OS_WINDOWS  // We are on Windows proper.
+
+# include <io.h>  // NOLINT
+# include <sys/timeb.h>  // NOLINT
+# include <sys/types.h>  // NOLINT
+# include <sys/stat.h>  // NOLINT
+
+# if GTEST_OS_WINDOWS_MINGW
+// MinGW has gettimeofday() but not _ftime64().
+// TODO(kenton@google.com): Use autoconf to detect availability of
+//   gettimeofday().
+// TODO(kenton@google.com): There are other ways to get the time on
+//   Windows, like GetTickCount() or GetSystemTimeAsFileTime().  MinGW
+//   supports these.  consider using them instead.
+#  define GTEST_HAS_GETTIMEOFDAY_ 1
+#  include <sys/time.h>  // NOLINT
+# endif  // GTEST_OS_WINDOWS_MINGW
+
+// cpplint thinks that the header is already included, so we want to
+// silence it.
+# include <windows.h>  // NOLINT
+# undef min
+
+#else
+
+// Assume other platforms have gettimeofday().
+// TODO(kenton@google.com): Use autoconf to detect availability of
+//   gettimeofday().
+# define GTEST_HAS_GETTIMEOFDAY_ 1
+
+// cpplint thinks that the header is already included, so we want to
+// silence it.
+# include <sys/time.h>  // NOLINT
+# include <unistd.h>  // NOLINT
+
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>
+#endif
+
+#if GTEST_CAN_STREAM_RESULTS_
+# include <arpa/inet.h>  // NOLINT
+# include <netdb.h>  // NOLINT
+# include <sys/socket.h>  // NOLINT
+# include <sys/types.h>  // NOLINT
+#endif
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+#if GTEST_OS_WINDOWS
+# define vsnprintf _vsnprintf
+#endif  // GTEST_OS_WINDOWS
+
+namespace testing {
+
+using internal::CountIf;
+using internal::ForEach;
+using internal::GetElementOr;
+using internal::Shuffle;
+
+// Constants.
+
+// A test whose test case name or test name matches this filter is
+// disabled and not run.
+static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";
+
+// A test case whose name matches this filter is considered a death
+// test case and will be run before test cases whose name doesn't
+// match this filter.
+static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*";
+
+// A test filter that matches everything.
+static const char kUniversalFilter[] = "*";
+
+// The default output file for XML output.
+static const char kDefaultOutputFile[] = "test_detail.xml";
+
+// The environment variable name for the test shard index.
+static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
+// The environment variable name for the total number of test shards.
+static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
+// The environment variable name for the test shard status file.
+static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";
+
+namespace internal {
+
+// The text used in failure messages to indicate the start of the
+// stack trace.
+const char kStackTraceMarker[] = "\nStack trace:\n";
+
+// g_help_flag is true iff the --help flag or an equivalent form is
+// specified on the command line.
+bool g_help_flag = false;
+
+}  // namespace internal
+
+static const char* GetDefaultFilter() {
+#ifdef GTEST_TEST_FILTER_ENV_VAR_
+  const char* const testbridge_test_only = getenv(GTEST_TEST_FILTER_ENV_VAR_);
+  if (testbridge_test_only != NULL) {
+    return testbridge_test_only;
+  }
+#endif  // GTEST_TEST_FILTER_ENV_VAR_
+  return kUniversalFilter;
+}
+
+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 iff a failed assertion should be a debugger break-point.");
+
+GTEST_DEFINE_bool_(
+    catch_exceptions,
+    internal::BoolFromGTestEnv("catch_exceptions", true),
+    "True iff " GTEST_NAME_
+    " should catch exceptions and treat them as test failures.");
+
+GTEST_DEFINE_string_(
+    color,
+    internal::StringFromGTestEnv("color", "auto"),
+    "Whether to use colors in the output.  Valid values: yes, no, "
+    "and auto.  'auto' means to use colors if the output is "
+    "being sent to a terminal and the TERM environment variable "
+    "is set to a terminal type that supports colors.");
+
+GTEST_DEFINE_string_(
+    filter,
+    internal::StringFromGTestEnv("filter", GetDefaultFilter()),
+    "A colon-separated list of glob (not regex) patterns "
+    "for filtering the tests to run, optionally followed by a "
+    "'-' and a : separated list of negative patterns (tests to "
+    "exclude).  A test is run if it matches one of the positive "
+    "patterns and does not match any of the negative patterns.");
+
+GTEST_DEFINE_bool_(list_tests, false,
+                   "List all tests without running them.");
+
+GTEST_DEFINE_string_(
+    output,
+    internal::StringFromGTestEnv("output", ""),
+    "A format (currently must be \"xml\"), 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_(
+    print_time,
+    internal::BoolFromGTestEnv("print_time", true),
+    "True iff " GTEST_NAME_
+    " should display elapsed time in text output.");
+
+GTEST_DEFINE_int32_(
+    random_seed,
+    internal::Int32FromGTestEnv("random_seed", 0),
+    "Random number seed to use when shuffling test orders.  Must be in range "
+    "[1, 99999], or 0 to use a seed based on the current time.");
+
+GTEST_DEFINE_int32_(
+    repeat,
+    internal::Int32FromGTestEnv("repeat", 1),
+    "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 iff " GTEST_NAME_ " should include internal stack frames when "
+    "printing test failure stack traces.");
+
+GTEST_DEFINE_bool_(
+    shuffle,
+    internal::BoolFromGTestEnv("shuffle", false),
+    "True iff " GTEST_NAME_
+    " should randomize tests' order on every run.");
+
+GTEST_DEFINE_int32_(
+    stack_trace_depth,
+    internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),
+    "The maximum number of stack frames to print when an "
+    "assertion fails.  The valid range is 0 through 100, inclusive.");
+
+GTEST_DEFINE_string_(
+    stream_result_to,
+    internal::StringFromGTestEnv("stream_result_to", ""),
+    "This flag specifies the host name and the port number on which to stream "
+    "test results. Example: \"localhost:555\". The flag is effective only on "
+    "Linux.");
+
+GTEST_DEFINE_bool_(
+    throw_on_failure,
+    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.");
+
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+GTEST_DEFINE_string_(
+    flagfile,
+    internal::StringFromGTestEnv("flagfile", ""),
+    "This flag specifies the flagfile to read command-line flags from.");
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+
+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 Random::Generate(UInt32 range) {
+  // These constants are the same as are used in glibc's rand(3).
+  state_ = (1103515245U*state_ + 12345U) % kMaxRange;
+
+  GTEST_CHECK_(range > 0)
+      << "Cannot generate a number in the range [0, 0).";
+  GTEST_CHECK_(range <= kMaxRange)
+      << "Generation of a number in [0, " << range << ") was requested, "
+      << "but this can only generate numbers in [0, " << kMaxRange << ").";
+
+  // Converting via modulus introduces a bit of downward bias, but
+  // it's simple, and a linear congruential generator isn't too good
+  // to begin with.
+  return state_ % range;
+}
+
+// GTestIsInitialized() returns true iff 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 TestCases, keeping a running sum of the
+// results of calling a given int-returning method on each.
+// Returns the sum.
+static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
+                               int (TestCase::*method)() const) {
+  int sum = 0;
+  for (size_t i = 0; i < case_list.size(); i++) {
+    sum += (case_list[i]->*method)();
+  }
+  return sum;
+}
+
+// Returns true iff the test case passed.
+static bool TestCasePassed(const TestCase* test_case) {
+  return test_case->should_run() && test_case->Passed();
+}
+
+// Returns true iff the test case failed.
+static bool TestCaseFailed(const TestCase* test_case) {
+  return test_case->should_run() && test_case->Failed();
+}
+
+// Returns true iff test_case contains at least one test that should
+// run.
+static bool ShouldRunTestCase(const TestCase* test_case) {
+  return test_case->should_run();
+}
+
+// AssertHelper constructor.
+AssertHelper::AssertHelper(TestPartResult::Type type,
+                           const char* file,
+                           int line,
+                           const char* message)
+    : data_(new AssertHelperData(type, file, line, message)) {
+}
+
+AssertHelper::~AssertHelper() {
+  delete data_;
+}
+
+// Message assignment, for assertion streaming support.
+void AssertHelper::operator=(const Message& message) const {
+  UnitTest::GetInstance()->
+    AddTestPartResult(data_->type, data_->file, data_->line,
+                      AppendUserMessage(data_->message, message),
+                      UnitTest::GetInstance()->impl()
+                      ->CurrentOsStackTraceExceptTop(1)
+                      // Skips the stack frame for this function itself.
+                      );  // NOLINT
+}
+
+// Mutex for linked pointers.
+GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
+
+// A copy of all command line arguments.  Set by InitGoogleTest().
+::std::vector<testing::internal::string> g_argvs;
+
+const ::std::vector<testing::internal::string>& GetArgvs() {
+#if defined(GTEST_CUSTOM_GET_ARGVS_)
+  return GTEST_CUSTOM_GET_ARGVS_();
+#else  // defined(GTEST_CUSTOM_GET_ARGVS_)
+  return g_argvs;
+#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
+}
+
+// Returns the current application's name, removing directory path if that
+// is present.
+FilePath GetCurrentExecutableName() {
+  FilePath result;
+
+#if GTEST_OS_WINDOWS
+  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
+#else
+  result.Set(FilePath(GetArgvs()[0]));
+#endif  // GTEST_OS_WINDOWS
+
+  return result.RemoveDirectoryName();
+}
+
+// Functions for processing the gtest_output flag.
+
+// Returns the output format, or "" for normal printed output.
+std::string UnitTestOptions::GetOutputFormat() {
+  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
+  if (gtest_output_flag == NULL) return std::string("");
+
+  const char* const colon = strchr(gtest_output_flag, ':');
+  return (colon == NULL) ?
+      std::string(gtest_output_flag) :
+      std::string(gtest_output_flag, colon - gtest_output_flag);
+}
+
+// Returns the name of the requested output file, or the default if none
+// was explicitly specified.
+std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
+  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
+  if (gtest_output_flag == NULL)
+    return "";
+
+  const char* const colon = strchr(gtest_output_flag, ':');
+  if (colon == NULL)
+    return internal::FilePath::ConcatPaths(
+        internal::FilePath(
+            UnitTest::GetInstance()->original_working_dir()),
+        internal::FilePath(kDefaultOutputFile)).string();
+
+  internal::FilePath output_name(colon + 1);
+  if (!output_name.IsAbsolutePath())
+    // TODO(wan@google.com): on Windows \some\path is not an absolute
+    // path (as its meaning depends on the current drive), yet the
+    // following logic for turning it into an absolute path is wrong.
+    // Fix it.
+    output_name = internal::FilePath::ConcatPaths(
+        internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
+        internal::FilePath(colon + 1));
+
+  if (!output_name.IsDirectory())
+    return output_name.string();
+
+  internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
+      output_name, internal::GetCurrentExecutableName(),
+      GetOutputFormat().c_str()));
+  return result.string();
+}
+
+// Returns true iff the wildcard pattern matches the string.  The
+// first ':' or '\0' character in pattern marks the end of it.
+//
+// This recursive algorithm isn't very efficient, but is clear and
+// works well enough for matching test names, which are short.
+bool UnitTestOptions::PatternMatchesString(const char *pattern,
+                                           const char *str) {
+  switch (*pattern) {
+    case '\0':
+    case ':':  // Either ':' or '\0' marks the end of the pattern.
+      return *str == '\0';
+    case '?':  // Matches any single character.
+      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
+    case '*':  // Matches any string (possibly empty) of characters.
+      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
+          PatternMatchesString(pattern + 1, str);
+    default:  // Non-special character.  Matches itself.
+      return *pattern == *str &&
+          PatternMatchesString(pattern + 1, str + 1);
+  }
+}
+
+bool UnitTestOptions::MatchesFilter(
+    const std::string& name, const char* filter) {
+  const char *cur_pattern = filter;
+  for (;;) {
+    if (PatternMatchesString(cur_pattern, name.c_str())) {
+      return true;
+    }
+
+    // Finds the next pattern in the filter.
+    cur_pattern = strchr(cur_pattern, ':');
+
+    // Returns if no more pattern can be found.
+    if (cur_pattern == NULL) {
+      return false;
+    }
+
+    // Skips the pattern separater (the ':' character).
+    cur_pattern++;
+  }
+}
+
+// Returns true iff the user-specified filter matches the test case
+// name and the test name.
+bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name,
+                                        const std::string &test_name) {
+  const std::string& full_name = test_case_name + "." + test_name.c_str();
+
+  // Split --gtest_filter at '-', if there is one, to separate into
+  // positive filter and negative filter portions
+  const char* const p = GTEST_FLAG(filter).c_str();
+  const char* const dash = strchr(p, '-');
+  std::string positive;
+  std::string negative;
+  if (dash == NULL) {
+    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
+    negative = "";
+  } else {
+    positive = std::string(p, dash);   // Everything up to the dash
+    negative = std::string(dash + 1);  // Everything after the dash
+    if (positive.empty()) {
+      // Treat '-test1' as the same as '*-test1'
+      positive = kUniversalFilter;
+    }
+  }
+
+  // A filter is a colon-separated list of patterns.  It matches a
+  // test if any pattern in it matches the test.
+  return (MatchesFilter(full_name, positive.c_str()) &&
+          !MatchesFilter(full_name, negative.c_str()));
+}
+
+#if GTEST_HAS_SEH
+// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
+// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
+// This function is useful as an __except condition.
+int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
+  // Google Test should handle a SEH exception if:
+  //   1. the user wants it to, AND
+  //   2. this is not a breakpoint exception, AND
+  //   3. this is not a C++ exception (VC++ implements them via SEH,
+  //      apparently).
+  //
+  // SEH exception code for C++ exceptions.
+  // (see http://support.microsoft.com/kb/185294 for more information).
+  const DWORD kCxxExceptionCode = 0xe06d7363;
+
+  bool should_handle = true;
+
+  if (!GTEST_FLAG(catch_exceptions))
+    should_handle = false;
+  else if (exception_code == EXCEPTION_BREAKPOINT)
+    should_handle = false;
+  else if (exception_code == kCxxExceptionCode)
+    should_handle = false;
+
+  return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
+}
+#endif  // GTEST_HAS_SEH
+
+}  // namespace internal
+
+// The c'tor sets this object as the test part result reporter used by
+// Google Test.  The 'result' parameter specifies where to report the
+// results. Intercepts only failures from the current thread.
+ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
+    TestPartResultArray* result)
+    : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
+      result_(result) {
+  Init();
+}
+
+// The c'tor sets this object as the test part result reporter used by
+// Google Test.  The 'result' parameter specifies where to report the
+// results.
+ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
+    InterceptMode intercept_mode, TestPartResultArray* result)
+    : intercept_mode_(intercept_mode),
+      result_(result) {
+  Init();
+}
+
+void ScopedFakeTestPartResultReporter::Init() {
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
+    old_reporter_ = impl->GetGlobalTestPartResultReporter();
+    impl->SetGlobalTestPartResultReporter(this);
+  } else {
+    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
+    impl->SetTestPartResultReporterForCurrentThread(this);
+  }
+}
+
+// The d'tor restores the test part result reporter used by Google Test
+// before.
+ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
+    impl->SetGlobalTestPartResultReporter(old_reporter_);
+  } else {
+    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
+  }
+}
+
+// Increments the test part result count and remembers the result.
+// This method is from the TestPartResultReporterInterface interface.
+void ScopedFakeTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  result_->Append(result);
+}
+
+namespace internal {
+
+// Returns the type ID of ::testing::Test.  We should always call this
+// instead of GetTypeId< ::testing::Test>() to get the type ID of
+// testing::Test.  This is to work around a suspected linker bug when
+// using Google Test as a framework on Mac OS X.  The bug causes
+// GetTypeId< ::testing::Test>() to return different values depending
+// on whether the call is from the Google Test framework itself or
+// from user test code.  GetTestTypeId() is guaranteed to always
+// return the same value, as it always calls GetTypeId<>() from the
+// gtest.cc, which is within the Google Test framework.
+TypeId GetTestTypeId() {
+  return GetTypeId<Test>();
+}
+
+// The value of GetTestTypeId() as seen from within the Google Test
+// library.  This is solely for testing GetTestTypeId().
+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.
+AssertionResult HasOneFailure(const char* /* results_expr */,
+                              const char* /* type_expr */,
+                              const char* /* substr_expr */,
+                              const TestPartResultArray& results,
+                              TestPartResult::Type type,
+                              const string& substr) {
+  const std::string expected(type == TestPartResult::kFatalFailure ?
+                        "1 fatal failure" :
+                        "1 non-fatal failure");
+  Message msg;
+  if (results.size() != 1) {
+    msg << "Expected: " << expected << "\n"
+        << "  Actual: " << results.size() << " failures";
+    for (int i = 0; i < results.size(); i++) {
+      msg << "\n" << results.GetTestPartResult(i);
+    }
+    return AssertionFailure() << msg;
+  }
+
+  const TestPartResult& r = results.GetTestPartResult(0);
+  if (r.type() != type) {
+    return AssertionFailure() << "Expected: " << expected << "\n"
+                              << "  Actual:\n"
+                              << r;
+  }
+
+  if (strstr(r.message(), substr.c_str()) == NULL) {
+    return AssertionFailure() << "Expected: " << expected << " containing \""
+                              << substr << "\"\n"
+                              << "  Actual:\n"
+                              << r;
+  }
+
+  return AssertionSuccess();
+}
+
+// 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 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
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+SingleFailureChecker::~SingleFailureChecker() {
+  EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
+}
+
+DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
+    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
+
+void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  unit_test_->current_test_result()->AddTestPartResult(result);
+  unit_test_->listeners()->repeater()->OnTestPartResult(result);
+}
+
+DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
+    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
+
+void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
+}
+
+// Returns the global test part result reporter.
+TestPartResultReporterInterface*
+UnitTestImpl::GetGlobalTestPartResultReporter() {
+  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
+  return global_test_part_result_repoter_;
+}
+
+// Sets the global test part result reporter.
+void UnitTestImpl::SetGlobalTestPartResultReporter(
+    TestPartResultReporterInterface* reporter) {
+  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
+  global_test_part_result_repoter_ = reporter;
+}
+
+// Returns the test part result reporter for the current thread.
+TestPartResultReporterInterface*
+UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
+  return per_thread_test_part_result_reporter_.get();
+}
+
+// Sets the test part result reporter for the current thread.
+void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
+    TestPartResultReporterInterface* reporter) {
+  per_thread_test_part_result_reporter_.set(reporter);
+}
+
+// Gets the number of successful test cases.
+int UnitTestImpl::successful_test_case_count() const {
+  return CountIf(test_cases_, TestCasePassed);
+}
+
+// Gets the number of failed test cases.
+int UnitTestImpl::failed_test_case_count() const {
+  return CountIf(test_cases_, TestCaseFailed);
+}
+
+// Gets the number of all test cases.
+int UnitTestImpl::total_test_case_count() const {
+  return static_cast<int>(test_cases_.size());
+}
+
+// Gets the number of all test cases that contain at least one test
+// that should run.
+int UnitTestImpl::test_case_to_run_count() const {
+  return CountIf(test_cases_, ShouldRunTestCase);
+}
+
+// Gets the number of successful tests.
+int UnitTestImpl::successful_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count);
+}
+
+// Gets the number of failed tests.
+int UnitTestImpl::failed_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::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 SumOverTestCaseList(test_cases_,
+                             &TestCase::reportable_disabled_test_count);
+}
+
+// Gets the number of disabled tests.
+int UnitTestImpl::disabled_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count);
+}
+
+// Gets the number of tests to be printed in the XML report.
+int UnitTestImpl::reportable_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::reportable_test_count);
+}
+
+// Gets the number of all tests.
+int UnitTestImpl::total_test_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::total_test_count);
+}
+
+// Gets the number of tests that should run.
+int UnitTestImpl::test_to_run_count() const {
+  return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count);
+}
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// CurrentOsStackTraceExceptTop(1), Foo() will be included in the
+// trace but Bar() and CurrentOsStackTraceExceptTop() won't.
+std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
+  return os_stack_trace_getter()->CurrentStackTrace(
+      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
+      skip_count + 1
+      // Skips the user-specified number of frames plus this function
+      // itself.
+      );  // NOLINT
+}
+
+// Returns the current time in milliseconds.
+TimeInMillis GetTimeInMillis() {
+#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__)
+  // Difference between 1970-01-01 and 1601-01-01 in milliseconds.
+  // http://analogous.blogspot.com/2005/04/epoch.html
+  const TimeInMillis kJavaEpochToWinFileTimeDelta =
+    static_cast<TimeInMillis>(116444736UL) * 100000UL;
+  const DWORD kTenthMicrosInMilliSecond = 10000;
+
+  SYSTEMTIME now_systime;
+  FILETIME now_filetime;
+  ULARGE_INTEGER now_int64;
+  // TODO(kenton@google.com): Shouldn't this just use
+  //   GetSystemTimeAsFileTime()?
+  GetSystemTime(&now_systime);
+  if (SystemTimeToFileTime(&now_systime, &now_filetime)) {
+    now_int64.LowPart = now_filetime.dwLowDateTime;
+    now_int64.HighPart = now_filetime.dwHighDateTime;
+    now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) -
+      kJavaEpochToWinFileTimeDelta;
+    return now_int64.QuadPart;
+  }
+  return 0;
+#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_
+  __timeb64 now;
+
+  // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996
+  // (deprecated function) there.
+  // TODO(kenton@google.com): Use GetTickCount()?  Or use
+  //   SystemTimeToFileTime()
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
+  _ftime64(&now);
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+  return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm;
+#elif GTEST_HAS_GETTIMEOFDAY_
+  struct timeval now;
+  gettimeofday(&now, NULL);
+  return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000;
+#else
+# error "Don't know how to get the current time on your system."
+#endif
+}
+
+// Utilities
+
+// class String.
+
+#if GTEST_OS_WINDOWS_MOBILE
+// Creates a UTF-16 wide string from the given ANSI string, allocating
+// memory using new. The caller is responsible for deleting the return
+// value using delete[]. Returns the wide string, or NULL if the
+// input is NULL.
+LPCWSTR String::AnsiToUtf16(const char* ansi) {
+  if (!ansi) return NULL;
+  const int length = strlen(ansi);
+  const int unicode_length =
+      MultiByteToWideChar(CP_ACP, 0, ansi, length,
+                          NULL, 0);
+  WCHAR* unicode = new WCHAR[unicode_length + 1];
+  MultiByteToWideChar(CP_ACP, 0, ansi, length,
+                      unicode, unicode_length);
+  unicode[unicode_length] = 0;
+  return unicode;
+}
+
+// Creates an ANSI string from the given wide string, allocating
+// memory using new. The caller is responsible for deleting the return
+// 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 NULL;
+  const int ansi_length =
+      WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
+                          NULL, 0, NULL, NULL);
+  char* ansi = new char[ansi_length + 1];
+  WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
+                      ansi, ansi_length, NULL, NULL);
+  ansi[ansi_length] = 0;
+  return ansi;
+}
+
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+// Compares two C strings.  Returns true iff 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 == NULL ) return rhs == NULL;
+
+  if ( rhs == NULL ) return false;
+
+  return strcmp(lhs, rhs) == 0;
+}
+
+#if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_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.
+static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
+                                     Message* msg) {
+  for (size_t i = 0; i != length; ) {  // NOLINT
+    if (wstr[i] != L'\0') {
+      *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
+      while (i != length && wstr[i] != L'\0')
+        i++;
+    } else {
+      *msg << '\0';
+      i++;
+    }
+  }
+}
+
+#endif  // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
+
+void SplitString(const ::std::string& str, char delimiter,
+                 ::std::vector< ::std::string>* dest) {
+  ::std::vector< ::std::string> parsed;
+  ::std::string::size_type pos = 0;
+  while (::testing::internal::AlwaysTrue()) {
+    const ::std::string::size_type colon = str.find(delimiter, pos);
+    if (colon == ::std::string::npos) {
+      parsed.push_back(str.substr(pos));
+      break;
+    } else {
+      parsed.push_back(str.substr(pos, colon - pos));
+      pos = colon + 1;
+    }
+  }
+  dest->swap(parsed);
+}
+
+}  // namespace internal
+
+// Constructs an empty Message.
+// We allocate the stringstream separately because otherwise each use of
+// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
+// stack frame leading to huge stack frames in some cases; gcc does not reuse
+// the stack space.
+Message::Message() : ss_(new ::std::stringstream) {
+  // By default, we want there to be enough precision when printing
+  // a double to a Message.
+  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
+}
+
+// These two overloads allow streaming a wide C string to a Message
+// using the UTF-8 encoding.
+Message& Message::operator <<(const wchar_t* wide_c_str) {
+  return *this << internal::String::ShowWideCString(wide_c_str);
+}
+Message& Message::operator <<(wchar_t* wide_c_str) {
+  return *this << internal::String::ShowWideCString(wide_c_str);
+}
+
+#if GTEST_HAS_STD_WSTRING
+// Converts the given wide string to a narrow string using the UTF-8
+// encoding, and streams the result to this Message object.
+Message& Message::operator <<(const ::std::wstring& wstr) {
+  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
+  return *this;
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_HAS_GLOBAL_WSTRING
+// Converts the given wide string to a narrow string using the UTF-8
+// encoding, and streams the result to this Message object.
+Message& Message::operator <<(const ::wstring& wstr) {
+  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
+  return *this;
+}
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+// Gets the text streamed to this object so far as an std::string.
+// Each '\0' character in the buffer is replaced with "\\0".
+std::string Message::GetString() const {
+  return internal::StringStreamToString(ss_.get());
+}
+
+// AssertionResult constructors.
+// Used in EXPECT_TRUE/FALSE(assertion_result).
+AssertionResult::AssertionResult(const AssertionResult& other)
+    : success_(other.success_),
+      message_(other.message_.get() != NULL ?
+               new ::std::string(*other.message_) :
+               static_cast< ::std::string*>(NULL)) {
+}
+
+// Swaps two AssertionResults.
+void AssertionResult::swap(AssertionResult& other) {
+  using std::swap;
+  swap(success_, other.success_);
+  swap(message_, other.message_);
+}
+
+// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
+AssertionResult AssertionResult::operator!() const {
+  AssertionResult negation(!success_);
+  if (message_.get() != NULL)
+    negation << *message_;
+  return negation;
+}
+
+// Makes a successful assertion result.
+AssertionResult AssertionSuccess() {
+  return AssertionResult(true);
+}
+
+// Makes a failed assertion result.
+AssertionResult AssertionFailure() {
+  return AssertionResult(false);
+}
+
+// Makes a failed assertion result with the given failure message.
+// Deprecated; use AssertionFailure() << message.
+AssertionResult AssertionFailure(const Message& message) {
+  return AssertionFailure() << message;
+}
+
+namespace internal {
+
+namespace edit_distance {
+std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
+                                            const std::vector<size_t>& right) {
+  std::vector<std::vector<double> > costs(
+      left.size() + 1, std::vector<double>(right.size() + 1));
+  std::vector<std::vector<EditType> > best_move(
+      left.size() + 1, std::vector<EditType>(right.size() + 1));
+
+  // Populate for empty right.
+  for (size_t l_i = 0; l_i < costs.size(); ++l_i) {
+    costs[l_i][0] = static_cast<double>(l_i);
+    best_move[l_i][0] = kRemove;
+  }
+  // Populate for empty left.
+  for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) {
+    costs[0][r_i] = static_cast<double>(r_i);
+    best_move[0][r_i] = kAdd;
+  }
+
+  for (size_t l_i = 0; l_i < left.size(); ++l_i) {
+    for (size_t r_i = 0; r_i < right.size(); ++r_i) {
+      if (left[l_i] == right[r_i]) {
+        // Found a match. Consume it.
+        costs[l_i + 1][r_i + 1] = costs[l_i][r_i];
+        best_move[l_i + 1][r_i + 1] = kMatch;
+        continue;
+      }
+
+      const double add = costs[l_i + 1][r_i];
+      const double remove = costs[l_i][r_i + 1];
+      const double replace = costs[l_i][r_i];
+      if (add < remove && add < replace) {
+        costs[l_i + 1][r_i + 1] = add + 1;
+        best_move[l_i + 1][r_i + 1] = kAdd;
+      } else if (remove < add && remove < replace) {
+        costs[l_i + 1][r_i + 1] = remove + 1;
+        best_move[l_i + 1][r_i + 1] = kRemove;
+      } else {
+        // We make replace a little more expensive than add/remove to lower
+        // their priority.
+        costs[l_i + 1][r_i + 1] = replace + 1.00001;
+        best_move[l_i + 1][r_i + 1] = kReplace;
+      }
+    }
+  }
+
+  // Reconstruct the best path. We do it in reverse order.
+  std::vector<EditType> best_path;
+  for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) {
+    EditType move = best_move[l_i][r_i];
+    best_path.push_back(move);
+    l_i -= move != kAdd;
+    r_i -= move != kRemove;
+  }
+  std::reverse(best_path.begin(), best_path.end());
+  return best_path;
+}
+
+namespace {
+
+// Helper class to convert string into ids with deduplication.
+class InternalStrings {
+ public:
+  size_t GetId(const std::string& str) {
+    IdMap::iterator it = ids_.find(str);
+    if (it != ids_.end()) return it->second;
+    size_t id = ids_.size();
+    return ids_[str] = id;
+  }
+
+ private:
+  typedef std::map<std::string, size_t> IdMap;
+  IdMap ids_;
+};
+
+}  // namespace
+
+std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<std::string>& left,
+    const std::vector<std::string>& right) {
+  std::vector<size_t> left_ids, right_ids;
+  {
+    InternalStrings intern_table;
+    for (size_t i = 0; i < left.size(); ++i) {
+      left_ids.push_back(intern_table.GetId(left[i]));
+    }
+    for (size_t i = 0; i < right.size(); ++i) {
+      right_ids.push_back(intern_table.GetId(right[i]));
+    }
+  }
+  return CalculateOptimalEdits(left_ids, right_ids);
+}
+
+namespace {
+
+// Helper class that holds the state for one hunk and prints it out to the
+// stream.
+// It reorders adds/removes when possible to group all removes before all
+// adds. It also adds the hunk header before printint into the stream.
+class Hunk {
+ public:
+  Hunk(size_t left_start, size_t right_start)
+      : left_start_(left_start),
+        right_start_(right_start),
+        adds_(),
+        removes_(),
+        common_() {}
+
+  void PushLine(char edit, const char* line) {
+    switch (edit) {
+      case ' ':
+        ++common_;
+        FlushEdits();
+        hunk_.push_back(std::make_pair(' ', line));
+        break;
+      case '-':
+        ++removes_;
+        hunk_removes_.push_back(std::make_pair('-', line));
+        break;
+      case '+':
+        ++adds_;
+        hunk_adds_.push_back(std::make_pair('+', line));
+        break;
+    }
+  }
+
+  void PrintTo(std::ostream* os) {
+    PrintHeader(os);
+    FlushEdits();
+    for (std::list<std::pair<char, const char*> >::const_iterator it =
+             hunk_.begin();
+         it != hunk_.end(); ++it) {
+      *os << it->first << it->second << "\n";
+    }
+  }
+
+  bool has_edits() const { return adds_ || removes_; }
+
+ private:
+  void FlushEdits() {
+    hunk_.splice(hunk_.end(), hunk_removes_);
+    hunk_.splice(hunk_.end(), hunk_adds_);
+  }
+
+  // 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 ommitted if unnecessary.
+  void PrintHeader(std::ostream* ss) const {
+    *ss << "@@ ";
+    if (removes_) {
+      *ss << "-" << left_start_ << "," << (removes_ + common_);
+    }
+    if (removes_ && adds_) {
+      *ss << " ";
+    }
+    if (adds_) {
+      *ss << "+" << right_start_ << "," << (adds_ + common_);
+    }
+    *ss << " @@\n";
+  }
+
+  size_t left_start_, right_start_;
+  size_t adds_, removes_, common_;
+  std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_;
+};
+
+}  // namespace
+
+// Create a list of diff hunks in Unified diff format.
+// Each hunk has a header generated by PrintHeader above plus a body with
+// lines prefixed with ' ' for no change, '-' for deletion and '+' for
+// addition.
+// 'context' represents the desired unchanged prefix/suffix around the diff.
+// If two hunks are close enough that their contexts overlap, then they are
+// joined into one hunk.
+std::string CreateUnifiedDiff(const std::vector<std::string>& left,
+                              const std::vector<std::string>& right,
+                              size_t context) {
+  const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
+
+  size_t l_i = 0, r_i = 0, edit_i = 0;
+  std::stringstream ss;
+  while (edit_i < edits.size()) {
+    // Find first edit.
+    while (edit_i < edits.size() && edits[edit_i] == kMatch) {
+      ++l_i;
+      ++r_i;
+      ++edit_i;
+    }
+
+    // Find the first line to include in the hunk.
+    const size_t prefix_context = std::min(l_i, context);
+    Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
+    for (size_t i = prefix_context; i > 0; --i) {
+      hunk.PushLine(' ', left[l_i - i].c_str());
+    }
+
+    // Iterate the edits until we found enough suffix for the hunk or the input
+    // is over.
+    size_t n_suffix = 0;
+    for (; edit_i < edits.size(); ++edit_i) {
+      if (n_suffix >= context) {
+        // Continue only if the next hunk is very close.
+        std::vector<EditType>::const_iterator it = edits.begin() + edit_i;
+        while (it != edits.end() && *it == kMatch) ++it;
+        if (it == edits.end() || (it - edits.begin()) - edit_i >= context) {
+          // There is no next edit or it is too far away.
+          break;
+        }
+      }
+
+      EditType edit = edits[edit_i];
+      // Reset count when a non match is found.
+      n_suffix = edit == kMatch ? n_suffix + 1 : 0;
+
+      if (edit == kMatch || edit == kRemove || edit == kReplace) {
+        hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());
+      }
+      if (edit == kAdd || edit == kReplace) {
+        hunk.PushLine('+', right[r_i].c_str());
+      }
+
+      // Advance indices, depending on edit type.
+      l_i += edit != kAdd;
+      r_i += edit != kRemove;
+    }
+
+    if (!hunk.has_edits()) {
+      // We are done. We don't want this hunk.
+      break;
+    }
+
+    hunk.PrintTo(&ss);
+  }
+  return ss.str();
+}
+
+}  // namespace edit_distance
+
+namespace {
+
+// The string representation of the values received in EqFailure() are already
+// escaped. Split them on escaped '\n' boundaries. Leave all other escaped
+// characters the same.
+std::vector<std::string> SplitEscapedString(const std::string& str) {
+  std::vector<std::string> lines;
+  size_t start = 0, end = str.size();
+  if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
+    ++start;
+    --end;
+  }
+  bool escaped = false;
+  for (size_t i = start; i + 1 < end; ++i) {
+    if (escaped) {
+      escaped = false;
+      if (str[i] == 'n') {
+        lines.push_back(str.substr(start, i - start - 1));
+        start = i + 1;
+      }
+    } else {
+      escaped = str[i] == '\\';
+    }
+  }
+  lines.push_back(str.substr(start, end - start));
+  return lines;
+}
+
+}  // namespace
+
+// Constructs and returns the message for an equality assertion
+// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
+//
+// The first four parameters are the expressions used in the assertion
+// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
+// where foo is 5 and bar is 6, we have:
+//
+//   lhs_expression: "foo"
+//   rhs_expression: "bar"
+//   lhs_value:      "5"
+//   rhs_value:      "6"
+//
+// The ignoring_case parameter is true iff 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,
+                          const char* rhs_expression,
+                          const std::string& lhs_value,
+                          const std::string& rhs_value,
+                          bool ignoring_case) {
+  Message msg;
+  msg << "      Expected: " << lhs_expression;
+  if (lhs_value != lhs_expression) {
+    msg << "\n      Which is: " << lhs_value;
+  }
+  msg << "\nTo be equal to: " << rhs_expression;
+  if (rhs_value != rhs_expression) {
+    msg << "\n      Which is: " << rhs_value;
+  }
+
+  if (ignoring_case) {
+    msg << "\nIgnoring case";
+  }
+
+  if (!lhs_value.empty() && !rhs_value.empty()) {
+    const std::vector<std::string> lhs_lines =
+        SplitEscapedString(lhs_value);
+    const std::vector<std::string> rhs_lines =
+        SplitEscapedString(rhs_value);
+    if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
+      msg << "\nWith diff:\n"
+          << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
+    }
+  }
+
+  return AssertionFailure() << msg;
+}
+
+// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
+std::string GetBoolAssertionFailureMessage(
+    const AssertionResult& assertion_result,
+    const char* expression_text,
+    const char* actual_predicate_value,
+    const char* expected_predicate_value) {
+  const char* actual_message = assertion_result.message();
+  Message msg;
+  msg << "Value of: " << expression_text
+      << "\n  Actual: " << actual_predicate_value;
+  if (actual_message[0] != '\0')
+    msg << " (" << actual_message << ")";
+  msg << "\nExpected: " << expected_predicate_value;
+  return msg.GetString();
+}
+
+// Helper function for implementing ASSERT_NEAR.
+AssertionResult DoubleNearPredFormat(const char* expr1,
+                                     const char* expr2,
+                                     const char* abs_error_expr,
+                                     double val1,
+                                     double val2,
+                                     double abs_error) {
+  const double diff = fabs(val1 - val2);
+  if (diff <= abs_error) return AssertionSuccess();
+
+  // TODO(wan): do not print the value of an expression if it's
+  // already a literal.
+  return AssertionFailure()
+      << "The difference between " << expr1 << " and " << expr2
+      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
+      << expr1 << " evaluates to " << val1 << ",\n"
+      << expr2 << " evaluates to " << val2 << ", and\n"
+      << abs_error_expr << " evaluates to " << abs_error << ".";
+}
+
+
+// Helper template for implementing FloatLE() and DoubleLE().
+template <typename RawType>
+AssertionResult FloatingPointLE(const char* expr1,
+                                const char* expr2,
+                                RawType val1,
+                                RawType val2) {
+  // Returns success if val1 is less than val2,
+  if (val1 < val2) {
+    return AssertionSuccess();
+  }
+
+  // or if val1 is almost equal to val2.
+  const FloatingPoint<RawType> lhs(val1), rhs(val2);
+  if (lhs.AlmostEquals(rhs)) {
+    return AssertionSuccess();
+  }
+
+  // Note that the above two checks will both fail if either val1 or
+  // val2 is NaN, as the IEEE floating-point standard requires that
+  // any predicate involving a NaN must return false.
+
+  ::std::stringstream val1_ss;
+  val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+          << val1;
+
+  ::std::stringstream val2_ss;
+  val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+          << val2;
+
+  return AssertionFailure()
+      << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
+      << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
+      << StringStreamToString(&val2_ss);
+}
+
+}  // namespace internal
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+AssertionResult FloatLE(const char* expr1, const char* expr2,
+                        float val1, float val2) {
+  return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
+}
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+AssertionResult DoubleLE(const char* expr1, const char* expr2,
+                         double val1, double val2) {
+  return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
+}
+
+namespace internal {
+
+// The helper function for {ASSERT|EXPECT}_EQ with int or enum
+// arguments.
+AssertionResult CmpHelperEQ(const char* lhs_expression,
+                            const char* rhs_expression,
+                            BiggestInt lhs,
+                            BiggestInt rhs) {
+  if (lhs == rhs) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   FormatForComparisonFailureMessage(lhs, rhs),
+                   FormatForComparisonFailureMessage(rhs, lhs),
+                   false);
+}
+
+// A macro for implementing the helper functions needed to implement
+// ASSERT_?? and EXPECT_?? with integer or enum arguments.  It is here
+// just to avoid copy-and-paste of similar code.
+#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
+AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                   BiggestInt val1, BiggestInt val2) {\
+  if (val1 op val2) {\
+    return AssertionSuccess();\
+  } else {\
+    return AssertionFailure() \
+        << "Expected: (" << expr1 << ") " #op " (" << expr2\
+        << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
+        << " vs " << FormatForComparisonFailureMessage(val2, val1);\
+  }\
+}
+
+// Implements the helper function for {ASSERT|EXPECT}_NE with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER_(NE, !=)
+// Implements the helper function for {ASSERT|EXPECT}_LE with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER_(LE, <=)
+// Implements the helper function for {ASSERT|EXPECT}_LT with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER_(LT, < )
+// Implements the helper function for {ASSERT|EXPECT}_GE with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER_(GE, >=)
+// Implements the helper function for {ASSERT|EXPECT}_GT with int or
+// enum arguments.
+GTEST_IMPL_CMP_HELPER_(GT, > )
+
+#undef GTEST_IMPL_CMP_HELPER_
+
+// The helper function for {ASSERT|EXPECT}_STREQ.
+AssertionResult CmpHelperSTREQ(const char* lhs_expression,
+                               const char* rhs_expression,
+                               const char* lhs,
+                               const char* rhs) {
+  if (String::CStringEquals(lhs, rhs)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   PrintToString(lhs),
+                   PrintToString(rhs),
+                   false);
+}
+
+// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
+AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
+                                   const char* rhs_expression,
+                                   const char* lhs,
+                                   const char* rhs) {
+  if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   PrintToString(lhs),
+                   PrintToString(rhs),
+                   true);
+}
+
+// The helper function for {ASSERT|EXPECT}_STRNE.
+AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                               const char* s2_expression,
+                               const char* s1,
+                               const char* s2) {
+  if (!String::CStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  } else {
+    return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
+                              << s2_expression << "), actual: \""
+                              << s1 << "\" vs \"" << s2 << "\"";
+  }
+}
+
+// The helper function for {ASSERT|EXPECT}_STRCASENE.
+AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
+                                   const char* s2_expression,
+                                   const char* s1,
+                                   const char* s2) {
+  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  } else {
+    return AssertionFailure()
+        << "Expected: (" << s1_expression << ") != ("
+        << s2_expression << ") (ignoring case), actual: \""
+        << s1 << "\" vs \"" << s2 << "\"";
+  }
+}
+
+}  // namespace internal
+
+namespace {
+
+// Helper functions for implementing IsSubString() and IsNotSubstring().
+
+// This group of overloaded functions return true iff needle is a
+// substring of haystack.  NULL is considered a substring of itself
+// only.
+
+bool IsSubstringPred(const char* needle, const char* haystack) {
+  if (needle == NULL || haystack == NULL)
+    return needle == haystack;
+
+  return strstr(haystack, needle) != NULL;
+}
+
+bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
+  if (needle == NULL || haystack == NULL)
+    return needle == haystack;
+
+  return wcsstr(haystack, needle) != NULL;
+}
+
+// StringType here can be either ::std::string or ::std::wstring.
+template <typename StringType>
+bool IsSubstringPred(const StringType& needle,
+                     const StringType& haystack) {
+  return haystack.find(needle) != StringType::npos;
+}
+
+// This function implements either IsSubstring() or IsNotSubstring(),
+// depending on the value of the expected_to_be_substring parameter.
+// StringType here can be const char*, const wchar_t*, ::std::string,
+// or ::std::wstring.
+template <typename StringType>
+AssertionResult IsSubstringImpl(
+    bool expected_to_be_substring,
+    const char* needle_expr, const char* haystack_expr,
+    const StringType& needle, const StringType& haystack) {
+  if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
+    return AssertionSuccess();
+
+  const bool is_wide_string = sizeof(needle[0]) > 1;
+  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
+  return AssertionFailure()
+      << "Value of: " << needle_expr << "\n"
+      << "  Actual: " << begin_string_quote << needle << "\"\n"
+      << "Expected: " << (expected_to_be_substring ? "" : "not ")
+      << "a substring of " << haystack_expr << "\n"
+      << "Which is: " << begin_string_quote << haystack << "\"";
+}
+
+}  // namespace
+
+// IsSubstring() and IsNotSubstring() check whether needle is a
+// substring of haystack (NULL is considered a substring of itself
+// only), and return an appropriate error message when they fail.
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+#if GTEST_HAS_STD_WSTRING
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+namespace internal {
+
+#if GTEST_OS_WINDOWS
+
+namespace {
+
+// Helper function for IsHRESULT{SuccessFailure} predicates
+AssertionResult HRESULTFailureHelper(const char* expr,
+                                     const char* expected,
+                                     long hr) {  // NOLINT
+# if GTEST_OS_WINDOWS_MOBILE
+
+  // Windows CE doesn't support FormatMessage.
+  const char error_text[] = "";
+
+# else
+
+  // Looks up the human-readable system message for the HRESULT code
+  // and since we're not passing any params to FormatMessage, we don't
+  // want inserts expanded.
+  const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
+                       FORMAT_MESSAGE_IGNORE_INSERTS;
+  const DWORD kBufSize = 4096;
+  // 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
+                                          hr,  // the error
+                                          0,  // no line width restrictions
+                                          error_text,  // output buffer
+                                          kBufSize,  // buf size
+                                          NULL);  // 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) {
+    error_text[message_length - 1] = '\0';
+  }
+
+# endif  // GTEST_OS_WINDOWS_MOBILE
+
+  const std::string error_hex("0x" + String::FormatHexInt(hr));
+  return ::testing::AssertionFailure()
+      << "Expected: " << expr << " " << expected << ".\n"
+      << "  Actual: " << error_hex << " " << error_text << "\n";
+}
+
+}  // namespace
+
+AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
+  if (SUCCEEDED(hr)) {
+    return AssertionSuccess();
+  }
+  return HRESULTFailureHelper(expr, "succeeds", hr);
+}
+
+AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
+  if (FAILED(hr)) {
+    return AssertionSuccess();
+  }
+  return HRESULTFailureHelper(expr, "fails", hr);
+}
+
+#endif  // GTEST_OS_WINDOWS
+
+// Utility functions for encoding Unicode text (wide strings) in
+// UTF-8.
+
+// A Unicode code-point can have upto 21 bits, and is encoded in UTF-8
+// like this:
+//
+// Code-point length   Encoding
+//   0 -  7 bits       0xxxxxxx
+//   8 - 11 bits       110xxxxx 10xxxxxx
+//  12 - 16 bits       1110xxxx 10xxxxxx 10xxxxxx
+//  17 - 21 bits       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+
+// The maximum code-point a one-byte UTF-8 sequence can represent.
+const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) <<  7) - 1;
+
+// The maximum code-point a two-byte UTF-8 sequence can represent.
+const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1;
+
+// The maximum code-point a three-byte UTF-8 sequence can represent.
+const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1;
+
+// The maximum code-point a four-byte UTF-8 sequence can represent.
+const UInt32 kMaxCodePoint4 = (static_cast<UInt32>(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 ChopLowBits(UInt32* bits, int n) {
+  const UInt32 low_bits = *bits & ((static_cast<UInt32>(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 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 code_point) {
+  if (code_point > kMaxCodePoint4) {
+    return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
+  }
+
+  char str[5];  // Big enough for the largest valid code point.
+  if (code_point <= kMaxCodePoint1) {
+    str[1] = '\0';
+    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
+  } else if (code_point <= kMaxCodePoint2) {
+    str[2] = '\0';
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
+  } else if (code_point <= kMaxCodePoint3) {
+    str[3] = '\0';
+    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
+  } else {  // code_point <= kMaxCodePoint4
+    str[4] = '\0';
+    str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
+  }
+  return str;
+}
+
+// The following two functions only make sense if the the system
+// uses UTF-16 for wide string encoding. All supported systems
+// with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16.
+
+// Determines if the arguments constitute UTF-16 surrogate pair
+// and thus should be combined into a single Unicode code point
+// using CreateCodePointFromUtf16SurrogatePair.
+inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
+  return sizeof(wchar_t) == 2 &&
+      (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
+}
+
+// Creates a Unicode code point from UTF16 surrogate pair.
+inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
+                                                    wchar_t second) {
+  const UInt32 mask = (1 << 10) - 1;
+  return (sizeof(wchar_t) == 2) ?
+      (((first & mask) << 10) | (second & mask)) + 0x10000 :
+      // This function should not be called when the condition is
+      // false, but we provide a sensible default in case it is.
+      static_cast<UInt32>(first);
+}
+
+// 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, Symbian OS)
+//   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
+// of wchar_t characters processed. -1 is used when the entire string
+// should be processed.
+// If the string contains code points that are not valid Unicode code points
+// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
+// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
+// and contains invalid UTF-16 surrogate pairs, values in those pairs
+// will be encoded as individual Unicode characters from Basic Normal Plane.
+std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
+  if (num_chars == -1)
+    num_chars = static_cast<int>(wcslen(str));
+
+  ::std::stringstream stream;
+  for (int i = 0; i < num_chars; ++i) {
+    UInt32 unicode_code_point;
+
+    if (str[i] == L'\0') {
+      break;
+    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
+      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
+                                                                 str[i + 1]);
+      i++;
+    } else {
+      unicode_code_point = static_cast<UInt32>(str[i]);
+    }
+
+    stream << CodePointToUtf8(unicode_code_point);
+  }
+  return StringStreamToString(&stream);
+}
+
+// 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 == NULL)  return "(null)";
+
+  return internal::WideStringToUtf8(wide_c_str, -1);
+}
+
+// Compares two wide C strings.  Returns true iff 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 == NULL) return rhs == NULL;
+
+  if (rhs == NULL) return false;
+
+  return wcscmp(lhs, rhs) == 0;
+}
+
+// Helper function for *_STREQ on wide strings.
+AssertionResult CmpHelperSTREQ(const char* lhs_expression,
+                               const char* rhs_expression,
+                               const wchar_t* lhs,
+                               const wchar_t* rhs) {
+  if (String::WideCStringEquals(lhs, rhs)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   PrintToString(lhs),
+                   PrintToString(rhs),
+                   false);
+}
+
+// Helper function for *_STRNE on wide strings.
+AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                               const char* s2_expression,
+                               const wchar_t* s1,
+                               const wchar_t* s2) {
+  if (!String::WideCStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  }
+
+  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
+                            << s2_expression << "), actual: "
+                            << PrintToString(s1)
+                            << " vs " << PrintToString(s2);
+}
+
+// Compares two C strings, ignoring case.  Returns true iff 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 == NULL)
+    return rhs == NULL;
+  if (rhs == NULL)
+    return false;
+  return posix::StrCaseCmp(lhs, rhs) == 0;
+}
+
+  // Compares two wide C strings, ignoring case.  Returns true iff 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 == NULL) return rhs == NULL;
+
+  if (rhs == NULL) return false;
+
+#if GTEST_OS_WINDOWS
+  return _wcsicmp(lhs, rhs) == 0;
+#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
+  return wcscasecmp(lhs, rhs) == 0;
+#else
+  // Android, Mac OS X and Cygwin don't define wcscasecmp.
+  // Other unknown OSes may not define it either.
+  wint_t left, right;
+  do {
+    left = towlower(*lhs++);
+    right = towlower(*rhs++);
+  } while (left && left == right);
+  return left == right;
+#endif  // OS selector
+}
+
+// Returns true iff 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) {
+  const size_t str_len = str.length();
+  const size_t suffix_len = suffix.length();
+  return (str_len >= suffix_len) &&
+         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
+                                      suffix.c_str());
+}
+
+// Formats an int value as "%02d".
+std::string String::FormatIntWidth2(int value) {
+  std::stringstream ss;
+  ss << std::setfill('0') << std::setw(2) << value;
+  return ss.str();
+}
+
+// Formats an int value as "%X".
+std::string String::FormatHexInt(int value) {
+  std::stringstream ss;
+  ss << std::hex << std::uppercase << value;
+  return ss.str();
+}
+
+// Formats a byte as "%02X".
+std::string String::FormatByte(unsigned char value) {
+  std::stringstream ss;
+  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
+     << static_cast<unsigned int>(value);
+  return ss.str();
+}
+
+// Converts the buffer in a stringstream to an std::string, converting NUL
+// bytes to "\\0" along the way.
+std::string StringStreamToString(::std::stringstream* ss) {
+  const ::std::string& str = ss->str();
+  const char* const start = str.c_str();
+  const char* const end = start + str.length();
+
+  std::string result;
+  result.reserve(2 * (end - start));
+  for (const char* ch = start; ch != end; ++ch) {
+    if (*ch == '\0') {
+      result += "\\0";  // Replaces NUL with "\\0";
+    } else {
+      result += *ch;
+    }
+  }
+
+  return result;
+}
+
+// Appends the user-supplied message to the Google-Test-generated message.
+std::string AppendUserMessage(const std::string& gtest_msg,
+                              const Message& user_msg) {
+  // Appends the user message if it's non-empty.
+  const std::string user_msg_string = user_msg.GetString();
+  if (user_msg_string.empty()) {
+    return gtest_msg;
+  }
+
+  return gtest_msg + "\n" + user_msg_string;
+}
+
+}  // namespace internal
+
+// class TestResult
+
+// Creates an empty TestResult.
+TestResult::TestResult()
+    : death_test_count_(0),
+      elapsed_time_(0) {
+}
+
+// D'tor.
+TestResult::~TestResult() {
+}
+
+// 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& TestResult::GetTestPartResult(int i) const {
+  if (i < 0 || i >= total_part_count())
+    internal::posix::Abort();
+  return test_part_results_.at(i);
+}
+
+// Returns the i-th test property. i can range from 0 to
+// test_property_count() - 1. If i is not in that range, aborts the
+// program.
+const TestProperty& TestResult::GetTestProperty(int i) const {
+  if (i < 0 || i >= test_property_count())
+    internal::posix::Abort();
+  return test_properties_.at(i);
+}
+
+// Clears the test part results.
+void TestResult::ClearTestPartResults() {
+  test_part_results_.clear();
+}
+
+// Adds a test part result to the list.
+void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
+  test_part_results_.push_back(test_part_result);
+}
+
+// Adds a test property to the list. If a property with the same key as the
+// supplied property is already represented, the value of this test_property
+// replaces the old value for that key.
+void TestResult::RecordProperty(const std::string& xml_element,
+                                const TestProperty& test_property) {
+  if (!ValidateTestProperty(xml_element, test_property)) {
+    return;
+  }
+  internal::MutexLock lock(&test_properites_mutex_);
+  const std::vector<TestProperty>::iterator property_with_matching_key =
+      std::find_if(test_properties_.begin(), test_properties_.end(),
+                   internal::TestPropertyKeyIs(test_property.key()));
+  if (property_with_matching_key == test_properties_.end()) {
+    test_properties_.push_back(test_property);
+    return;
+  }
+  property_with_matching_key->SetValue(test_property.value());
+}
+
+// The list of reserved attributes used in the <testsuites> element of XML
+// output.
+static const char* const kReservedTestSuitesAttributes[] = {
+  "disabled",
+  "errors",
+  "failures",
+  "name",
+  "random_seed",
+  "tests",
+  "time",
+  "timestamp"
+};
+
+// The list of reserved attributes used in the <testsuite> element of XML
+// output.
+static const char* const kReservedTestSuiteAttributes[] = {
+  "disabled",
+  "errors",
+  "failures",
+  "name",
+  "tests",
+  "time"
+};
+
+// 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"
+};
+
+template <int kSize>
+std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
+  return std::vector<std::string>(array, array + kSize);
+}
+
+static std::vector<std::string> GetReservedAttributesForElement(
+    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(kReservedTestCaseAttributes);
+  } 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) {
+    if (i > 0 && words.size() > 2) {
+      word_list << ", ";
+    }
+    if (i == words.size() - 1) {
+      word_list << "and ";
+    }
+    word_list << "'" << words[i] << "'";
+  }
+  return word_list.GetString();
+}
+
+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
+                  << " (" << FormatWordList(reserved_names)
+                  << " are reserved by " << GTEST_NAME_ << ")";
+    return false;
+  }
+  return true;
+}
+
+// Adds a failure if the key is a reserved attribute of the element named
+// xml_element.  Returns true if the property is valid.
+bool TestResult::ValidateTestProperty(const std::string& xml_element,
+                                      const TestProperty& test_property) {
+  return ValidateTestPropertyName(test_property.key(),
+                                  GetReservedAttributesForElement(xml_element));
+}
+
+// Clears the object.
+void TestResult::Clear() {
+  test_part_results_.clear();
+  test_properties_.clear();
+  death_test_count_ = 0;
+  elapsed_time_ = 0;
+}
+
+// Returns true iff the test failed.
+bool TestResult::Failed() const {
+  for (int i = 0; i < total_part_count(); ++i) {
+    if (GetTestPartResult(i).failed())
+      return true;
+  }
+  return false;
+}
+
+// Returns true iff the test part fatally failed.
+static bool TestPartFatallyFailed(const TestPartResult& result) {
+  return result.fatally_failed();
+}
+
+// Returns true iff the test fatally failed.
+bool TestResult::HasFatalFailure() const {
+  return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
+}
+
+// Returns true iff the test part non-fatally failed.
+static bool TestPartNonfatallyFailed(const TestPartResult& result) {
+  return result.nonfatally_failed();
+}
+
+// Returns true iff the test has a non-fatal failure.
+bool TestResult::HasNonfatalFailure() const {
+  return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
+}
+
+// Gets the number of all test parts.  This is the sum of the number
+// of successful test parts and the number of failed test parts.
+int TestResult::total_part_count() const {
+  return static_cast<int>(test_part_results_.size());
+}
+
+// Returns the number of the test properties.
+int TestResult::test_property_count() const {
+  return static_cast<int>(test_properties_.size());
+}
+
+// class Test
+
+// Creates a Test object.
+
+// The c'tor saves the states of all flags.
+Test::Test()
+    : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {
+}
+
+// The d'tor restores the states of all flags.  The actual work is
+// done by the d'tor of the gtest_flag_saver_ field, and thus not
+// visible here.
+Test::~Test() {
+}
+
+// Sets up the test fixture.
+//
+// A sub-class may override this.
+void Test::SetUp() {
+}
+
+// Tears down the test fixture.
+//
+// A sub-class may override this.
+void Test::TearDown() {
+}
+
+// Allows user supplied key value pairs to be recorded for later output.
+void Test::RecordProperty(const std::string& key, const std::string& value) {
+  UnitTest::GetInstance()->RecordProperty(key, value);
+}
+
+// Allows user supplied key value pairs to be recorded for later output.
+void Test::RecordProperty(const std::string& key, int value) {
+  Message value_message;
+  value_message << value;
+  RecordProperty(key, value_message.GetString().c_str());
+}
+
+namespace internal {
+
+void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
+                                    const std::string& message) {
+  // This function is a friend of UnitTest and as such has access to
+  // AddTestPartResult.
+  UnitTest::GetInstance()->AddTestPartResult(
+      result_type,
+      NULL,  // 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.
+}
+
+}  // namespace internal
+
+// Google Test requires all tests in the same test case 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 case.  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 TestCase* const test_case = impl->current_test_case();
+
+  // Info about the first test in the current test case.
+  const TestInfo* const first_test_info = test_case->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();
+
+  // Info about the current test.
+  const TestInfo* const this_test_info = impl->current_test_info();
+  const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
+  const char* const this_test_name = this_test_info->name();
+
+  if (this_fixture_id != first_fixture_id) {
+    // Is the first test defined using TEST?
+    const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
+    // Is this test defined using TEST?
+    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 case, which is incorrect.
+      // Tell the user how to fix this.
+
+      // Gets the name of the TEST and the name of the TEST_F.  Note
+      // that first_is_TEST and this_is_TEST cannot both be true, as
+      // the fixture IDs are different for the two tests.
+      const char* const TEST_name =
+          first_is_TEST ? first_test_name : this_test_name;
+      const char* const TEST_F_name =
+          first_is_TEST ? this_test_name : first_test_name;
+
+      ADD_FAILURE()
+          << "All tests in the same test case must use the same test fixture\n"
+          << "class, so mixing TEST_F and TEST in the same test case is\n"
+          << "illegal.  In test case " << this_test_info->test_case_name()
+          << ",\n"
+          << "test " << TEST_F_name << " is defined using TEST_F but\n"
+          << "test " << TEST_name << " is defined using TEST.  You probably\n"
+          << "want to change the TEST to TEST_F or move it to another test\n"
+          << "case.";
+    } else {
+      // 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 case must use the same test fixture\n"
+          << "class.  However, in test case "
+          << this_test_info->test_case_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 cases.";
+    }
+    return false;
+  }
+
+  return true;
+}
+
+#if GTEST_HAS_SEH
+
+// Adds an "exception thrown" fatal failure to the current test.  This
+// function returns its result via an output parameter pointer because VC++
+// prohibits creation of objects with destructors on stack in functions
+// using __try (see error C2712).
+static std::string* FormatSehExceptionMessage(DWORD exception_code,
+                                              const char* location) {
+  Message message;
+  message << "SEH exception with code 0x" << std::setbase(16) <<
+    exception_code << std::setbase(10) << " thrown in " << location << ".";
+
+  return new std::string(message.GetString());
+}
+
+#endif  // GTEST_HAS_SEH
+
+namespace internal {
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Adds an "exception thrown" fatal failure to the current test.
+static std::string FormatCxxExceptionMessage(const char* description,
+                                             const char* location) {
+  Message message;
+  if (description != NULL) {
+    message << "C++ exception with description \"" << description << "\"";
+  } else {
+    message << "Unknown C++ exception";
+  }
+  message << " thrown in " << location << ".";
+
+  return message.GetString();
+}
+
+static std::string PrintTestPartResultToString(
+    const TestPartResult& test_part_result);
+
+GoogleTestFailureException::GoogleTestFailureException(
+    const TestPartResult& failure)
+    : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// We put these helper functions in the internal namespace as IBM's xlC
+// compiler rejects the code if they were declared static.
+
+// Runs the given method and handles SEH exceptions it throws, when
+// SEH is supported; returns the 0-value for type Result in case of an
+// SEH exception.  (Microsoft compilers cannot handle SEH and C++
+// exceptions in the same function.  Therefore, we provide a separate
+// wrapper function for handling SEH exceptions.)
+template <class T, typename Result>
+Result HandleSehExceptionsInMethodIfSupported(
+    T* object, Result (T::*method)(), const char* location) {
+#if GTEST_HAS_SEH
+  __try {
+    return (object->*method)();
+  } __except (internal::UnitTestOptions::GTestShouldProcessSEH(  // NOLINT
+      GetExceptionCode())) {
+    // We create the exception message on the heap because VC++ prohibits
+    // creation of objects with destructors on stack in functions using __try
+    // (see error C2712).
+    std::string* exception_message = FormatSehExceptionMessage(
+        GetExceptionCode(), location);
+    internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
+                                             *exception_message);
+    delete exception_message;
+    return static_cast<Result>(0);
+  }
+#else
+  (void)location;
+  return (object->*method)();
+#endif  // GTEST_HAS_SEH
+}
+
+// Runs the given method and catches and reports C++ and/or SEH-style
+// exceptions, if they are supported; returns the 0-value for type
+// Result in case of an SEH exception.
+template <class T, typename Result>
+Result HandleExceptionsInMethodIfSupported(
+    T* object, Result (T::*method)(), const char* location) {
+  // NOTE: The user code can affect the way in which Google Test handles
+  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
+  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
+  // after the exception is caught and either report or re-throw the
+  // exception based on the flag's value:
+  //
+  // try {
+  //   // Perform the test method.
+  // } catch (...) {
+  //   if (GTEST_FLAG(catch_exceptions))
+  //     // Report the exception as failure.
+  //   else
+  //     throw;  // Re-throws the original exception.
+  // }
+  //
+  // However, the purpose of this flag is to allow the program to drop into
+  // the debugger when the exception is thrown. On most platforms, once the
+  // control enters the catch block, the exception origin information is
+  // lost and the debugger will stop the program at the point of the
+  // re-throw in this function -- instead of at the point of the original
+  // throw statement in the code under test.  For this reason, we perform
+  // the check early, sacrificing the ability to affect Google Test's
+  // exception handling in the method where the exception is thrown.
+  if (internal::GetUnitTestImpl()->catch_exceptions()) {
+#if GTEST_HAS_EXCEPTIONS
+    try {
+      return HandleSehExceptionsInMethodIfSupported(object, method, location);
+    } 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
+      // framework catch it.  Therefore we just re-throw it.
+      throw;
+    } catch (const std::exception& e) {  // NOLINT
+      internal::ReportFailureInUnknownLocation(
+          TestPartResult::kFatalFailure,
+          FormatCxxExceptionMessage(e.what(), location));
+    } catch (...) {  // NOLINT
+      internal::ReportFailureInUnknownLocation(
+          TestPartResult::kFatalFailure,
+          FormatCxxExceptionMessage(NULL, location));
+    }
+    return static_cast<Result>(0);
+#else
+    return HandleSehExceptionsInMethodIfSupported(object, method, location);
+#endif  // GTEST_HAS_EXCEPTIONS
+  } else {
+    return (object->*method)();
+  }
+}
+
+}  // namespace internal
+
+// Runs the test and updates the test result.
+void Test::Run() {
+  if (!HasSameFixtureClass()) return;
+
+  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.
+  if (!HasFatalFailure()) {
+    impl->os_stack_trace_getter()->UponLeavingGTest();
+    internal::HandleExceptionsInMethodIfSupported(
+        this, &Test::TestBody, "the test body");
+  }
+
+  // However, we want to clean up as much as possible.  Hence we will
+  // always call TearDown(), even if SetUp() or the test body has
+  // failed.
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      this, &Test::TearDown, "TearDown()");
+}
+
+// Returns true iff the current test has a fatal failure.
+bool Test::HasFatalFailure() {
+  return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
+}
+
+// Returns true iff the current test has a non-fatal failure.
+bool Test::HasNonfatalFailure() {
+  return internal::GetUnitTestImpl()->current_test_result()->
+      HasNonfatalFailure();
+}
+
+// class TestInfo
+
+// Constructs a TestInfo object. It assumes ownership of the test factory
+// object.
+TestInfo::TestInfo(const std::string& a_test_case_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_case_name_(a_test_case_name),
+      name_(a_name),
+      type_param_(a_type_param ? new std::string(a_type_param) : NULL),
+      value_param_(a_value_param ? new std::string(a_value_param) : NULL),
+      location_(a_code_location),
+      fixture_class_id_(fixture_class_id),
+      should_run_(false),
+      is_disabled_(false),
+      matches_filter_(false),
+      factory_(factory),
+      result_() {}
+
+// Destructs a TestInfo object.
+TestInfo::~TestInfo() { delete factory_; }
+
+namespace internal {
+
+// Creates a new TestInfo object and registers it with Google Test;
+// returns the created object.
+//
+// Arguments:
+//
+//   test_case_name:   name of the test case
+//   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.
+//   value_param:      text representation of the test's value parameter,
+//                     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 case
+//   tear_down_tc:     pointer to the function that tears down the test case
+//   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_case_name,
+    const char* name,
+    const char* type_param,
+    const char* value_param,
+    CodeLocation code_location,
+    TypeId fixture_class_id,
+    SetUpTestCaseFunc set_up_tc,
+    TearDownTestCaseFunc tear_down_tc,
+    TestFactoryBase* factory) {
+  TestInfo* const test_info =
+      new TestInfo(test_case_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;
+}
+
+#if GTEST_HAS_PARAM_TEST
+void ReportInvalidTestCaseType(const char* test_case_name,
+                               CodeLocation code_location) {
+  Message errors;
+  errors
+      << "Attempted redefinition of test case " << test_case_name << ".\n"
+      << "All tests in the same test case must use the same test fixture\n"
+      << "class.  However, in test case " << test_case_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 cases.";
+
+  fprintf(stderr, "%s %s",
+          FormatFileLocation(code_location.file.c_str(),
+                             code_location.line).c_str(),
+          errors.GetString().c_str());
+}
+#endif  // GTEST_HAS_PARAM_TEST
+
+}  // namespace internal
+
+namespace {
+
+// A predicate that checks the test name of a TestInfo against a known
+// value.
+//
+// This is used for implementation of the TestCase class only.  We put
+// it in the anonymous namespace to prevent polluting the outer
+// namespace.
+//
+// TestNameIs is copyable.
+class TestNameIs {
+ public:
+  // Constructor.
+  //
+  // TestNameIs has NO default constructor.
+  explicit TestNameIs(const char* name)
+      : name_(name) {}
+
+  // Returns true iff the test name of test_info matches name_.
+  bool operator()(const TestInfo * test_info) const {
+    return test_info && test_info->name() == name_;
+  }
+
+ private:
+  std::string name_;
+};
+
+}  // namespace
+
+namespace internal {
+
+// This method expands all parameterized tests registered with macros TEST_P
+// and INSTANTIATE_TEST_CASE_P into regular tests and registers those.
+// This will be done just once during the program runtime.
+void UnitTestImpl::RegisterParameterizedTests() {
+#if GTEST_HAS_PARAM_TEST
+  if (!parameterized_tests_registered_) {
+    parameterized_test_registry_.RegisterTests();
+    parameterized_tests_registered_ = true;
+  }
+#endif
+}
+
+}  // namespace internal
+
+// Creates the test object, runs it, records its result, and then
+// deletes it.
+void TestInfo::Run() {
+  if (!should_run_) return;
+
+  // Tells UnitTest where to store test result.
+  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 TimeInMillis start = internal::GetTimeInMillis();
+
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+
+  // Creates the test object.
+  Test* const test = internal::HandleExceptionsInMethodIfSupported(
+      factory_, &internal::TestFactoryBase::CreateTest,
+      "the test fixture's constructor");
+
+  // Runs the test only if the test object was created and its
+  // constructor didn't generate a fatal failure.
+  if ((test != NULL) && !Test::HasFatalFailure()) {
+    // This doesn't throw as all user code that can throw are wrapped into
+    // exception handling code.
+    test->Run();
+  }
+
+  // Deletes the test object.
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      test, &Test::DeleteSelf_, "the test fixture's destructor");
+
+  result_.set_elapsed_time(internal::GetTimeInMillis() - start);
+
+  // 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(NULL);
+}
+
+// class TestCase
+
+// Gets the number of successful tests in this test case.
+int TestCase::successful_test_count() const {
+  return CountIf(test_info_list_, TestPassed);
+}
+
+// Gets the number of failed tests in this test case.
+int TestCase::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 TestCase::reportable_disabled_test_count() const {
+  return CountIf(test_info_list_, TestReportableDisabled);
+}
+
+// Gets the number of disabled tests in this test case.
+int TestCase::disabled_test_count() const {
+  return CountIf(test_info_list_, TestDisabled);
+}
+
+// Gets the number of tests to be printed in the XML report.
+int TestCase::reportable_test_count() const {
+  return CountIf(test_info_list_, TestReportable);
+}
+
+// Get the number of tests in this test case that should run.
+int TestCase::test_to_run_count() const {
+  return CountIf(test_info_list_, ShouldRunTest);
+}
+
+// Gets the number of all tests.
+int TestCase::total_test_count() const {
+  return static_cast<int>(test_info_list_.size());
+}
+
+// Creates a TestCase with the given name.
+//
+// Arguments:
+//
+//   name:         name of the test case
+//   a_type_param: the name of the test case's type parameter, or NULL if
+//                 this is not a typed or a type-parameterized test case.
+//   set_up_tc:    pointer to the function that sets up the test case
+//   tear_down_tc: pointer to the function that tears down the test case
+TestCase::TestCase(const char* a_name, const char* a_type_param,
+                   Test::SetUpTestCaseFunc set_up_tc,
+                   Test::TearDownTestCaseFunc tear_down_tc)
+    : name_(a_name),
+      type_param_(a_type_param ? new std::string(a_type_param) : NULL),
+      set_up_tc_(set_up_tc),
+      tear_down_tc_(tear_down_tc),
+      should_run_(false),
+      elapsed_time_(0) {
+}
+
+// Destructor of TestCase.
+TestCase::~TestCase() {
+  // 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* TestCase::GetTestInfo(int i) const {
+  const int index = GetElementOr(test_indices_, i, -1);
+  return index < 0 ? NULL : test_info_list_[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* TestCase::GetMutableTestInfo(int i) {
+  const int index = GetElementOr(test_indices_, i, -1);
+  return index < 0 ? NULL : test_info_list_[index];
+}
+
+// Adds a test to this test case.  Will delete the test upon
+// destruction of the TestCase object.
+void TestCase::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 TestCase.
+void TestCase::Run() {
+  if (!should_run_) return;
+
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_case(this);
+
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
+
+  repeater->OnTestCaseStart(*this);
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      this, &TestCase::RunSetUpTestCase, "SetUpTestCase()");
+
+  const internal::TimeInMillis start = internal::GetTimeInMillis();
+  for (int i = 0; i < total_test_count(); i++) {
+    GetMutableTestInfo(i)->Run();
+  }
+  elapsed_time_ = internal::GetTimeInMillis() - start;
+
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      this, &TestCase::RunTearDownTestCase, "TearDownTestCase()");
+
+  repeater->OnTestCaseEnd(*this);
+  impl->set_current_test_case(NULL);
+}
+
+// Clears the results of all tests in this test case.
+void TestCase::ClearResult() {
+  ad_hoc_test_result_.Clear();
+  ForEach(test_info_list_, TestInfo::ClearTestResult);
+}
+
+// Shuffles the tests in this test case.
+void TestCase::ShuffleTests(internal::Random* random) {
+  Shuffle(random, &test_indices_);
+}
+
+// Restores the test order to before the first shuffle.
+void TestCase::UnshuffleTests() {
+  for (size_t i = 0; i < test_indices_.size(); i++) {
+    test_indices_[i] = static_cast<int>(i);
+  }
+}
+
+// Formats a countable noun.  Depending on its quantity, either the
+// singular form or the plural form is used. e.g.
+//
+// FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
+// FormatCountableNoun(5, "book", "books") returns "5 books".
+static std::string FormatCountableNoun(int count,
+                                       const char * singular_form,
+                                       const char * plural_form) {
+  return internal::StreamableToString(count) + " " +
+      (count == 1 ? singular_form : plural_form);
+}
+
+// Formats the count of tests.
+static std::string FormatTestCount(int test_count) {
+  return FormatCountableNoun(test_count, "test", "tests");
+}
+
+// Formats the count of test cases.
+static std::string FormatTestCaseCount(int test_case_count) {
+  return FormatCountableNoun(test_case_count, "test case", "test cases");
+}
+
+// Converts a TestPartResult::Type enum to human-friendly string
+// representation.  Both kNonFatalFailure and kFatalFailure are translated
+// to "Failure", as the user usually doesn't care about the difference
+// between the two when viewing the test result.
+static const char * TestPartResultTypeToString(TestPartResult::Type type) {
+  switch (type) {
+    case TestPartResult::kSuccess:
+      return "Success";
+
+    case TestPartResult::kNonFatalFailure:
+    case TestPartResult::kFatalFailure:
+#ifdef _MSC_VER
+      return "error: ";
+#else
+      return "Failure\n";
+#endif
+    default:
+      return "Unknown result type";
+  }
+}
+
+namespace internal {
+
+// Prints a TestPartResult to an std::string.
+static std::string PrintTestPartResultToString(
+    const TestPartResult& test_part_result) {
+  return (Message()
+          << internal::FormatFileLocation(test_part_result.file_name(),
+                                          test_part_result.line_number())
+          << " " << TestPartResultTypeToString(test_part_result.type())
+          << test_part_result.message()).GetString();
+}
+
+// Prints a TestPartResult.
+static void PrintTestPartResult(const TestPartResult& test_part_result) {
+  const std::string& result =
+      PrintTestPartResultToString(test_part_result);
+  printf("%s\n", result.c_str());
+  fflush(stdout);
+  // If the test program runs in Visual Studio or a debugger, the
+  // following statements add the test part result message to the Output
+  // window such that the user can double-click on it to jump to the
+  // corresponding source code location; otherwise they do nothing.
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
+  // We don't call OutputDebugString*() on Windows Mobile, as printing
+  // to stdout is done by OutputDebugString() there already - we don't
+  // want the same message printed twice.
+  ::OutputDebugStringA(result.c_str());
+  ::OutputDebugStringA("\n");
+#endif
+}
+
+// class PrettyUnitTestResultPrinter
+
+enum GTestColor {
+  COLOR_DEFAULT,
+  COLOR_RED,
+  COLOR_GREEN,
+  COLOR_YELLOW
+};
+
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
+    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+
+// Returns the character attribute for the given color.
+WORD GetColorAttribute(GTestColor color) {
+  switch (color) {
+    case COLOR_RED:    return FOREGROUND_RED;
+    case COLOR_GREEN:  return FOREGROUND_GREEN;
+    case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN;
+    default:           return 0;
+  }
+}
+
+#else
+
+// Returns the ANSI color code for the given color.  COLOR_DEFAULT is
+// an invalid input.
+const char* GetAnsiColorCode(GTestColor color) {
+  switch (color) {
+    case COLOR_RED:     return "1";
+    case COLOR_GREEN:   return "2";
+    case COLOR_YELLOW:  return "3";
+    default:            return NULL;
+  };
+}
+
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
+
+// Returns true iff 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
+    // On Windows the TERM variable is usually not set, but the
+    // console there does support colors.
+    return stdout_is_tty;
+#else
+    // On non-Windows platforms, we rely on the TERM variable.
+    const char* const term = posix::GetEnv("TERM");
+    const bool term_supports_color =
+        String::CStringEquals(term, "xterm") ||
+        String::CStringEquals(term, "xterm-color") ||
+        String::CStringEquals(term, "xterm-256color") ||
+        String::CStringEquals(term, "screen") ||
+        String::CStringEquals(term, "screen-256color") ||
+        String::CStringEquals(term, "tmux") ||
+        String::CStringEquals(term, "tmux-256color") ||
+        String::CStringEquals(term, "rxvt-unicode") ||
+        String::CStringEquals(term, "rxvt-unicode-256color") ||
+        String::CStringEquals(term, "linux") ||
+        String::CStringEquals(term, "cygwin");
+    return stdout_is_tty && term_supports_color;
+#endif  // GTEST_OS_WINDOWS
+  }
+
+  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
+      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
+      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
+      String::CStringEquals(gtest_color, "1");
+  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
+  // value is neither one of these nor "auto", we treat it as "no" to
+  // be conservative.
+}
+
+// Helpers for printing colored strings to stdout. Note that on Windows, we
+// 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.
+void ColoredPrintf(GTestColor color, const char* fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || \
+    GTEST_OS_IOS || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
+  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 != COLOR_DEFAULT);
+#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
+  // The '!= 0' comparison is necessary to satisfy MSVC 7.1.
+
+  if (!use_color) {
+    vprintf(fmt, args);
+    va_end(args);
+    return;
+  }
+
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
+    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+  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;
+
+  // 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,
+                          GetColorAttribute(color) | FOREGROUND_INTENSITY);
+  vprintf(fmt, args);
+
+  fflush(stdout);
+  // Restores the text color.
+  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
+#else
+  printf("\033[0;3%sm", GetAnsiColorCode(color));
+  vprintf(fmt, args);
+  printf("\033[m");  // Resets the terminal to default.
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
+  va_end(args);
+}
+
+// Text printed in Google Test's text output and --gunit_list_tests
+// output to label the type parameter and value parameter for a test.
+static const char kTypeParamLabel[] = "TypeParam";
+static const char kValueParamLabel[] = "GetParam()";
+
+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 != NULL || value_param != NULL) {
+    printf(", where ");
+    if (type_param != NULL) {
+      printf("%s = %s", kTypeParamLabel, type_param);
+      if (value_param != NULL)
+        printf(" and ");
+    }
+    if (value_param != NULL) {
+      printf("%s = %s", kValueParamLabel, value_param);
+    }
+  }
+}
+
+// This class implements the TestEventListener interface.
+//
+// Class PrettyUnitTestResultPrinter is copyable.
+class PrettyUnitTestResultPrinter : public TestEventListener {
+ public:
+  PrettyUnitTestResultPrinter() {}
+  static void PrintTestName(const char * test_case, const char * test) {
+    printf("%s.%s", test_case, test);
+  }
+
+  // The following methods override what's in the TestEventListener class.
+  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
+  virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration);
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
+  virtual void OnTestCaseStart(const TestCase& test_case);
+  virtual void OnTestStart(const TestInfo& test_info);
+  virtual void OnTestPartResult(const TestPartResult& result);
+  virtual void OnTestEnd(const TestInfo& test_info);
+  virtual void OnTestCaseEnd(const TestCase& test_case);
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
+  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
+  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
+
+ private:
+  static void PrintFailedTests(const UnitTest& unit_test);
+};
+
+  // Fired before each iteration of tests starts.
+void PrettyUnitTestResultPrinter::OnTestIterationStart(
+    const UnitTest& unit_test, int iteration) {
+  if (GTEST_FLAG(repeat) != 1)
+    printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
+
+  const char* const filter = GTEST_FLAG(filter).c_str();
+
+  // Prints the filter if it's not *.  This reminds the user that some
+  // tests may be skipped.
+  if (!String::CStringEquals(filter, kUniversalFilter)) {
+    ColoredPrintf(COLOR_YELLOW,
+                  "Note: %s filter = %s\n", GTEST_NAME_, filter);
+  }
+
+  if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
+    const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
+    ColoredPrintf(COLOR_YELLOW,
+                  "Note: This is test shard %d of %s.\n",
+                  static_cast<int>(shard_index) + 1,
+                  internal::posix::GetEnv(kTestTotalShards));
+  }
+
+  if (GTEST_FLAG(shuffle)) {
+    ColoredPrintf(COLOR_YELLOW,
+                  "Note: Randomizing tests' orders with a seed of %d .\n",
+                  unit_test.random_seed());
+  }
+
+  ColoredPrintf(COLOR_GREEN,  "[==========] ");
+  printf("Running %s from %s.\n",
+         FormatTestCount(unit_test.test_to_run_count()).c_str(),
+         FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str());
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
+    const UnitTest& /*unit_test*/) {
+  ColoredPrintf(COLOR_GREEN,  "[----------] ");
+  printf("Global test environment set-up.\n");
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
+  const std::string counts =
+      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
+  ColoredPrintf(COLOR_GREEN, "[----------] ");
+  printf("%s from %s", counts.c_str(), test_case.name());
+  if (test_case.type_param() == NULL) {
+    printf("\n");
+  } else {
+    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
+  }
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
+  ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
+  PrintTestName(test_info.test_case_name(), test_info.name());
+  printf("\n");
+  fflush(stdout);
+}
+
+// Called after an assertion failure.
+void PrettyUnitTestResultPrinter::OnTestPartResult(
+    const TestPartResult& result) {
+  // If the test part succeeded, we don't need to do anything.
+  if (result.type() == TestPartResult::kSuccess)
+    return;
+
+  // 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(COLOR_GREEN, "[       OK ] ");
+  } else {
+    ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
+  }
+  PrintTestName(test_info.test_case_name(), test_info.name());
+  if (test_info.result()->Failed())
+    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 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(COLOR_GREEN, "[----------] ");
+  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);
+}
+
+void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
+    const UnitTest& /*unit_test*/) {
+  ColoredPrintf(COLOR_GREEN,  "[----------] ");
+  printf("Global test environment tear-down\n");
+  fflush(stdout);
+}
+
+// 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();
+  if (failed_test_count == 0) {
+    return;
+  }
+
+  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
+    const TestCase& test_case = *unit_test.GetTestCase(i);
+    if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
+      continue;
+    }
+    for (int j = 0; j < test_case.total_test_count(); ++j) {
+      const TestInfo& test_info = *test_case.GetTestInfo(j);
+      if (!test_info.should_run() || test_info.result()->Passed()) {
+        continue;
+      }
+      ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
+      printf("%s.%s", test_case.name(), test_info.name());
+      PrintFullTestCommentIfPresent(test_info);
+      printf("\n");
+    }
+  }
+}
+
+void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
+                                                     int /*iteration*/) {
+  ColoredPrintf(COLOR_GREEN,  "[==========] ");
+  printf("%s from %s ran.",
+         FormatTestCount(unit_test.test_to_run_count()).c_str(),
+         FormatTestCaseCount(unit_test.test_case_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(COLOR_GREEN,  "[  PASSED  ] ");
+  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
+
+  int num_failures = unit_test.failed_test_count();
+  if (!unit_test.Passed()) {
+    const int failed_test_count = unit_test.failed_test_count();
+    ColoredPrintf(COLOR_RED,  "[  FAILED  ] ");
+    printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
+    PrintFailedTests(unit_test);
+    printf("\n%2d FAILED %s\n", num_failures,
+                        num_failures == 1 ? "TEST" : "TESTS");
+  }
+
+  int num_disabled = unit_test.reportable_disabled_test_count();
+  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
+    if (!num_failures) {
+      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
+    }
+    ColoredPrintf(COLOR_YELLOW,
+                  "  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 PrettyUnitTestResultPrinter
+
+// class TestEventRepeater
+//
+// This class forwards events to other event listeners.
+class TestEventRepeater : public TestEventListener {
+ public:
+  TestEventRepeater() : forwarding_enabled_(true) {}
+  virtual ~TestEventRepeater();
+  void Append(TestEventListener *listener);
+  TestEventListener* Release(TestEventListener* listener);
+
+  // Controls whether events will be forwarded to listeners_. Set to false
+  // in death test child processes.
+  bool forwarding_enabled() const { return forwarding_enabled_; }
+  void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }
+
+  virtual void OnTestProgramStart(const UnitTest& unit_test);
+  virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration);
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test);
+  virtual void OnTestCaseStart(const TestCase& test_case);
+  virtual void OnTestStart(const TestInfo& test_info);
+  virtual void OnTestPartResult(const TestPartResult& result);
+  virtual void OnTestEnd(const TestInfo& test_info);
+  virtual void OnTestCaseEnd(const TestCase& test_case);
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test);
+  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
+  virtual void OnTestProgramEnd(const UnitTest& unit_test);
+
+ private:
+  // Controls whether events will be forwarded to listeners_. Set to false
+  // in death test child processes.
+  bool forwarding_enabled_;
+  // The list of listeners that receive events.
+  std::vector<TestEventListener*> listeners_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
+};
+
+TestEventRepeater::~TestEventRepeater() {
+  ForEach(listeners_, Delete<TestEventListener>);
+}
+
+void TestEventRepeater::Append(TestEventListener *listener) {
+  listeners_.push_back(listener);
+}
+
+// TODO(vladl@google.com): Factor the search functionality into Vector::Find.
+TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
+  for (size_t i = 0; i < listeners_.size(); ++i) {
+    if (listeners_[i] == listener) {
+      listeners_.erase(listeners_.begin() + i);
+      return listener;
+    }
+  }
+
+  return NULL;
+}
+
+// Since most methods are very similar, use macros to reduce boilerplate.
+// This defines a member that forwards the call to all listeners.
+#define GTEST_REPEATER_METHOD_(Name, Type) \
+void TestEventRepeater::Name(const Type& parameter) { \
+  if (forwarding_enabled_) { \
+    for (size_t i = 0; i < listeners_.size(); i++) { \
+      listeners_[i]->Name(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 (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \
+      listeners_[i]->Name(parameter); \
+    } \
+  } \
+}
+
+GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
+GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
+GTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase)
+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)
+GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase)
+GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
+
+#undef GTEST_REPEATER_METHOD_
+#undef GTEST_REVERSE_REPEATER_METHOD_
+
+void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
+                                             int iteration) {
+  if (forwarding_enabled_) {
+    for (size_t i = 0; i < listeners_.size(); i++) {
+      listeners_[i]->OnTestIterationStart(unit_test, iteration);
+    }
+  }
+}
+
+void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
+                                           int iteration) {
+  if (forwarding_enabled_) {
+    for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) {
+      listeners_[i]->OnTestIterationEnd(unit_test, iteration);
+    }
+  }
+}
+
+// End TestEventRepeater
+
+// This class generates an XML output file.
+class XmlUnitTestResultPrinter : public EmptyTestEventListener {
+ public:
+  explicit XmlUnitTestResultPrinter(const char* output_file);
+
+  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
+
+ private:
+  // Is c a whitespace character that is normalized to a space character
+  // when it appears in an XML attribute value?
+  static bool IsNormalizableWhitespace(char c) {
+    return c == 0x9 || c == 0xA || c == 0xD;
+  }
+
+  // May c appear in a well-formed XML document?
+  static bool IsValidXmlCharacter(char c) {
+    return IsNormalizableWhitespace(c) || c >= 0x20;
+  }
+
+  // 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 references.
+  static std::string EscapeXml(const std::string& str, bool is_attribute);
+
+  // Returns the given string with all characters invalid in XML removed.
+  static std::string RemoveInvalidXmlCharacters(const std::string& str);
+
+  // Convenience wrapper around EscapeXml when str is an attribute value.
+  static std::string EscapeXmlAttribute(const std::string& str) {
+    return EscapeXml(str, true);
+  }
+
+  // Convenience wrapper around EscapeXml when str is not an attribute value.
+  static std::string EscapeXmlText(const char* str) {
+    return EscapeXml(str, false);
+  }
+
+  // Verifies that the given attribute belongs to the given element and
+  // streams the attribute as XML.
+  static void OutputXmlAttribute(std::ostream* stream,
+                                 const std::string& element_name,
+                                 const std::string& name,
+                                 const std::string& value);
+
+  // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
+  static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
+
+  // Streams an XML representation of a TestInfo object.
+  static void OutputXmlTestInfo(::std::ostream* stream,
+                                const char* test_case_name,
+                                const TestInfo& test_info);
+
+  // Prints an XML representation of a TestCase object
+  static void PrintXmlTestCase(::std::ostream* stream,
+                               const TestCase& test_case);
+
+  // Prints an XML summary of unit_test to output stream out.
+  static void PrintXmlUnitTest(::std::ostream* stream,
+                               const UnitTest& unit_test);
+
+  // Produces a string representing the test properties in a result as space
+  // delimited XML attributes based on the property key="value" pairs.
+  // When the std::string is not empty, it includes a space at the beginning,
+  // to delimit this attribute from prior attributes.
+  static std::string TestPropertiesAsXmlAttributes(const TestResult& result);
+
+  // The output file.
+  const std::string output_file_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
+};
+
+// Creates a new XmlUnitTestResultPrinter.
+XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
+    : output_file_(output_file) {
+  if (output_file_.c_str() == NULL || output_file_.empty()) {
+    fprintf(stderr, "XML output file may not be null\n");
+    fflush(stderr);
+    exit(EXIT_FAILURE);
+  }
+}
+
+// Called after the unit test ends.
+void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
+                                                  int /*iteration*/) {
+  FILE* xmlout = NULL;
+  FilePath output_file(output_file_);
+  FilePath output_dir(output_file.RemoveFileName());
+
+  if (output_dir.CreateDirectoriesRecursively()) {
+    xmlout = posix::FOpen(output_file_.c_str(), "w");
+  }
+  if (xmlout == NULL) {
+    // TODO(wan): report the reason of the failure.
+    //
+    // We don't do it for now as:
+    //
+    //   1. There is no urgent need for it.
+    //   2. It's a bit involved to make the errno variable thread-safe on
+    //      all three operating systems (Linux, Windows, and Mac OS).
+    //   3. To interpret the meaning of errno in a thread-safe way,
+    //      we need the strerror_r() function, which is not available on
+    //      Windows.
+    fprintf(stderr,
+            "Unable to open file \"%s\"\n",
+            output_file_.c_str());
+    fflush(stderr);
+    exit(EXIT_FAILURE);
+  }
+  std::stringstream stream;
+  PrintXmlUnitTest(&stream, unit_test);
+  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
+// references.
+//
+// Invalid XML characters in str, if any, are stripped from the output.
+// It is expected that most, if not all, of the text processed by this
+// module will consist of ordinary English text.
+// If this module is ever modified to produce version 1.1 XML output,
+// most invalid characters can be retained using character references.
+// TODO(wan): It might be nice to have a minimally invasive, human-readable
+// escaping scheme for invalid characters, rather than dropping them.
+std::string XmlUnitTestResultPrinter::EscapeXml(
+    const std::string& str, bool is_attribute) {
+  Message m;
+
+  for (size_t i = 0; i < str.size(); ++i) {
+    const char ch = str[i];
+    switch (ch) {
+      case '<':
+        m << "&lt;";
+        break;
+      case '>':
+        m << "&gt;";
+        break;
+      case '&':
+        m << "&amp;";
+        break;
+      case '\'':
+        if (is_attribute)
+          m << "&apos;";
+        else
+          m << '\'';
+        break;
+      case '"':
+        if (is_attribute)
+          m << "&quot;";
+        else
+          m << '"';
+        break;
+      default:
+        if (IsValidXmlCharacter(ch)) {
+          if (is_attribute && IsNormalizableWhitespace(ch))
+            m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
+              << ";";
+          else
+            m << ch;
+        }
+        break;
+    }
+  }
+
+  return m.GetString();
+}
+
+// Returns the given string with all characters invalid in XML removed.
+// Currently invalid characters are dropped from the string. An
+// alternative is to replace them with certain characters such as . or ?.
+std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
+    const std::string& str) {
+  std::string output;
+  output.reserve(str.size());
+  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
+    if (IsValidXmlCharacter(*it))
+      output.push_back(*it);
+
+  return output;
+}
+
+// The following routines generate an XML representation of a UnitTest
+// object.
+//
+// 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 TestCase object
+//     <testcase name="test-name">     <-- corresponds to a TestInfo object
+//       <failure message="...">...</failure>
+//       <failure message="...">...</failure>
+//       <failure message="...">...</failure>
+//                                     <-- individual assertion failures
+//     </testcase>
+//   </testsuite>
+// </testsuites>
+
+// Formats the given time in milliseconds as seconds.
+std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
+  ::std::stringstream ss;
+  ss << (static_cast<double>(ms) * 1e-3);
+  return ss.str();
+}
+
+static bool PortableLocaltime(time_t seconds, struct tm* out) {
+#if defined(_MSC_VER)
+  return localtime_s(out, &seconds) == 0;
+#elif defined(__MINGW32__) || defined(__MINGW64__)
+  // 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 == NULL)
+    return false;
+  *out = *tm_ptr;
+  return true;
+#else
+  return localtime_r(&seconds, out) != NULL;
+#endif
+}
+
+// Converts the given epoch time in milliseconds to a date string in the ISO
+// 8601 format, without the timezone information.
+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
+  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);
+}
+
+// Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
+void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
+                                                     const char* data) {
+  const char* segment = data;
+  *stream << "<![CDATA[";
+  for (;;) {
+    const char* const next_segment = strstr(segment, "]]>");
+    if (next_segment != NULL) {
+      stream->write(
+          segment, static_cast<std::streamsize>(next_segment - segment));
+      *stream << "]]>]]&gt;<![CDATA[";
+      segment = next_segment + strlen("]]>");
+    } else {
+      *stream << segment;
+      break;
+    }
+  }
+  *stream << "]]>";
+}
+
+void XmlUnitTestResultPrinter::OutputXmlAttribute(
+    std::ostream* stream,
+    const std::string& element_name,
+    const std::string& name,
+    const std::string& value) {
+  const std::vector<std::string>& allowed_names =
+      GetReservedAttributesForElement(element_name);
+
+  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
+                   allowed_names.end())
+      << "Attribute " << name << " is not allowed for element <" << element_name
+      << ">.";
+
+  *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
+}
+
+// Prints an XML representation of a TestInfo object.
+// TODO(wan): There is also value in printing properties with the plain printer.
+void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
+                                                 const char* test_case_name,
+                                                 const TestInfo& test_info) {
+  const TestResult& result = *test_info.result();
+  const std::string kTestcase = "testcase";
+
+  *stream << "    <testcase";
+  OutputXmlAttribute(stream, kTestcase, "name", test_info.name());
+
+  if (test_info.value_param() != NULL) {
+    OutputXmlAttribute(stream, kTestcase, "value_param",
+                       test_info.value_param());
+  }
+  if (test_info.type_param() != NULL) {
+    OutputXmlAttribute(stream, kTestcase, "type_param", test_info.type_param());
+  }
+
+  OutputXmlAttribute(stream, kTestcase, "status",
+                     test_info.should_run() ? "run" : "notrun");
+  OutputXmlAttribute(stream, kTestcase, "time",
+                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
+  OutputXmlAttribute(stream, kTestcase, "classname", test_case_name);
+  *stream << TestPropertiesAsXmlAttributes(result);
+
+  int failures = 0;
+  for (int i = 0; i < result.total_part_count(); ++i) {
+    const TestPartResult& part = result.GetTestPartResult(i);
+    if (part.failed()) {
+      if (++failures == 1) {
+        *stream << ">\n";
+      }
+      const string location = internal::FormatCompilerIndependentFileLocation(
+          part.file_name(), part.line_number());
+      const string summary = location + "\n" + part.summary();
+      *stream << "      <failure message=\""
+              << EscapeXmlAttribute(summary.c_str())
+              << "\" type=\"\">";
+      const string detail = location + "\n" + part.message();
+      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
+      *stream << "</failure>\n";
+    }
+  }
+
+  if (failures == 0)
+    *stream << " />\n";
+  else
+    *stream << "    </testcase>\n";
+}
+
+// Prints an XML representation of a TestCase object
+void XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream,
+                                                const TestCase& test_case) {
+  const std::string kTestsuite = "testsuite";
+  *stream << "  <" << kTestsuite;
+  OutputXmlAttribute(stream, kTestsuite, "name", test_case.name());
+  OutputXmlAttribute(stream, kTestsuite, "tests",
+                     StreamableToString(test_case.reportable_test_count()));
+  OutputXmlAttribute(stream, kTestsuite, "failures",
+                     StreamableToString(test_case.failed_test_count()));
+  OutputXmlAttribute(
+      stream, kTestsuite, "disabled",
+      StreamableToString(test_case.reportable_disabled_test_count()));
+  OutputXmlAttribute(stream, kTestsuite, "errors", "0");
+  OutputXmlAttribute(stream, kTestsuite, "time",
+                     FormatTimeInMillisAsSeconds(test_case.elapsed_time()));
+  *stream << TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result())
+          << ">\n";
+
+  for (int i = 0; i < test_case.total_test_count(); ++i) {
+    if (test_case.GetTestInfo(i)->is_reportable())
+      OutputXmlTestInfo(stream, test_case.name(), *test_case.GetTestInfo(i));
+  }
+  *stream << "  </" << kTestsuite << ">\n";
+}
+
+// Prints an XML summary of unit_test to output stream out.
+void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
+                                                const UnitTest& unit_test) {
+  const std::string kTestsuites = "testsuites";
+
+  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+  *stream << "<" << kTestsuites;
+
+  OutputXmlAttribute(stream, kTestsuites, "tests",
+                     StreamableToString(unit_test.reportable_test_count()));
+  OutputXmlAttribute(stream, kTestsuites, "failures",
+                     StreamableToString(unit_test.failed_test_count()));
+  OutputXmlAttribute(
+      stream, kTestsuites, "disabled",
+      StreamableToString(unit_test.reportable_disabled_test_count()));
+  OutputXmlAttribute(stream, kTestsuites, "errors", "0");
+  OutputXmlAttribute(
+      stream, kTestsuites, "timestamp",
+      FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
+  OutputXmlAttribute(stream, kTestsuites, "time",
+                     FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
+
+  if (GTEST_FLAG(shuffle)) {
+    OutputXmlAttribute(stream, kTestsuites, "random_seed",
+                       StreamableToString(unit_test.random_seed()));
+  }
+
+  *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
+
+  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
+  *stream << ">\n";
+
+  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
+    if (unit_test.GetTestCase(i)->reportable_test_count() > 0)
+      PrintXmlTestCase(stream, *unit_test.GetTestCase(i));
+  }
+  *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(
+    const TestResult& result) {
+  Message attributes;
+  for (int i = 0; i < result.test_property_count(); ++i) {
+    const TestProperty& property = result.GetTestProperty(i);
+    attributes << " " << property.key() << "="
+        << "\"" << EscapeXmlAttribute(property.value()) << "\"";
+  }
+  return attributes.GetString();
+}
+
+// End XmlUnitTestResultPrinter
+
+#if GTEST_CAN_STREAM_RESULTS_
+
+// Checks if str contains '=', '&', '%' or '\n' characters. If yes,
+// replaces them by "%xx" where xx is their hexadecimal value. For
+// 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.
+string StreamingListener::UrlEncode(const char* str) {
+  string result;
+  result.reserve(strlen(str) + 1);
+  for (char ch = *str; ch != '\0'; ch = *++str) {
+    switch (ch) {
+      case '%':
+      case '=':
+      case '&':
+      case '\n':
+        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
+        break;
+      default:
+        result.push_back(ch);
+        break;
+    }
+  }
+  return result;
+}
+
+void StreamingListener::SocketWriter::MakeConnection() {
+  GTEST_CHECK_(sockfd_ == -1)
+      << "MakeConnection() can't be called when there is already a connection.";
+
+  addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;    // To allow both IPv4 and IPv6 addresses.
+  hints.ai_socktype = SOCK_STREAM;
+  addrinfo* servinfo = NULL;
+
+  // Use the getaddrinfo() to get a linked list of IP addresses for
+  // the given host name.
+  const int error_num = getaddrinfo(
+      host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
+  if (error_num != 0) {
+    GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
+                        << gai_strerror(error_num);
+  }
+
+  // Loop through all the results and connect to the first we can.
+  for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL;
+       cur_addr = cur_addr->ai_next) {
+    sockfd_ = socket(
+        cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
+    if (sockfd_ != -1) {
+      // Connect the client socket to the server socket.
+      if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
+        close(sockfd_);
+        sockfd_ = -1;
+      }
+    }
+  }
+
+  freeaddrinfo(servinfo);  // all done with this structure
+
+  if (sockfd_ == -1) {
+    GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
+                        << host_name_ << ":" << port_num_;
+  }
+}
+
+// End of class Streaming Listener
+#endif  // GTEST_CAN_STREAM_RESULTS__
+
+// Class ScopedTrace
+
+// Pushes the given source file location and message onto a per-thread
+// trace stack maintained by Google Test.
+ScopedTrace::ScopedTrace(const char* file, int line, const Message& message)
+    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
+  TraceInfo trace;
+  trace.file = file;
+  trace.line = line;
+  trace.message = message.GetString();
+
+  UnitTest::GetInstance()->PushGTestTrace(trace);
+}
+
+// Pops the info pushed by the c'tor.
+ScopedTrace::~ScopedTrace()
+    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
+  UnitTest::GetInstance()->PopGTestTrace();
+}
+
+
+// class OsStackTraceGetter
+
+const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
+    "... " GTEST_NAME_ " internal frames ...";
+
+string OsStackTraceGetter::CurrentStackTrace(int /*max_depth*/,
+                                             int /*skip_count*/) {
+  return "";
+}
+
+void OsStackTraceGetter::UponLeavingGTest() {}
+
+// 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) {
+    // If a path to the premature-exit file is specified...
+    if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
+      // 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.
+      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
+      fwrite("0", 1, 1, pfile);
+      fclose(pfile);
+    }
+  }
+
+  ~ScopedPrematureExitFile() {
+    if (premature_exit_filepath_ != NULL && *premature_exit_filepath_ != '\0') {
+      remove(premature_exit_filepath_);
+    }
+  }
+
+ private:
+  const char* const premature_exit_filepath_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
+};
+
+}  // namespace internal
+
+// class TestEventListeners
+
+TestEventListeners::TestEventListeners()
+    : repeater_(new internal::TestEventRepeater()),
+      default_result_printer_(NULL),
+      default_xml_generator_(NULL) {
+}
+
+TestEventListeners::~TestEventListeners() { delete repeater_; }
+
+// Returns the standard listener responsible for the default console
+// output.  Can be removed from the listeners list to shut down default
+// console output.  Note that removing this object from the listener list
+// with Release transfers its ownership to the user.
+void TestEventListeners::Append(TestEventListener* listener) {
+  repeater_->Append(listener);
+}
+
+// Removes the given event listener from the list and returns it.  It then
+// becomes the caller's responsibility to delete the listener. Returns
+// NULL if the listener is not found in the list.
+TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
+  if (listener == default_result_printer_)
+    default_result_printer_ = NULL;
+  else if (listener == default_xml_generator_)
+    default_xml_generator_ = NULL;
+  return repeater_->Release(listener);
+}
+
+// Returns repeater that broadcasts the TestEventListener events to all
+// subscribers.
+TestEventListener* TestEventListeners::repeater() { return repeater_; }
+
+// Sets the default_result_printer attribute to the provided listener.
+// The listener is also added to the listener list and previous
+// default_result_printer is removed from it and deleted. The listener can
+// also be NULL in which case it will not be added to the list. Does
+// nothing if the previous and the current listener objects are the same.
+void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
+  if (default_result_printer_ != listener) {
+    // It is an error to pass this method a listener that is already in the
+    // list.
+    delete Release(default_result_printer_);
+    default_result_printer_ = listener;
+    if (listener != NULL)
+      Append(listener);
+  }
+}
+
+// Sets the default_xml_generator attribute to the provided listener.  The
+// listener is also added to the listener list and previous
+// default_xml_generator is removed from it and deleted. The listener can
+// also be NULL in which case it will not be added to the list. Does
+// nothing if the previous and the current listener objects are the same.
+void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
+  if (default_xml_generator_ != listener) {
+    // It is an error to pass this method a listener that is already in the
+    // list.
+    delete Release(default_xml_generator_);
+    default_xml_generator_ = listener;
+    if (listener != NULL)
+      Append(listener);
+  }
+}
+
+// Controls whether events will be forwarded by the repeater to the
+// listeners in the list.
+bool TestEventListeners::EventForwardingEnabled() const {
+  return repeater_->forwarding_enabled();
+}
+
+void TestEventListeners::SuppressEventForwarding() {
+  repeater_->set_forwarding_enabled(false);
+}
+
+// class UnitTest
+
+// Gets the singleton UnitTest object.  The first time this method is
+// called, a UnitTest object is constructed and returned.  Consecutive
+// calls will return the same object.
+//
+// We don't protect this under mutex_ as a user is not supposed to
+// call this before main() starts, from which point on the return
+// value will never change.
+UnitTest* UnitTest::GetInstance() {
+  // When compiled with MSVC 7.1 in optimized mode, destroying the
+  // UnitTest object upon exiting the program messes up the exit code,
+  // causing successful tests to appear failed.  We have to use a
+  // different implementation in this case to bypass the compiler bug.
+  // This implementation makes the compiler happy, at the cost of
+  // leaking the UnitTest object.
+
+  // CodeGear C++Builder insists on a public destructor for the
+  // default implementation.  Use this implementation to keep good OO
+  // design with private destructor.
+
+#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
+  static UnitTest* const instance = new UnitTest;
+  return instance;
+#else
+  static UnitTest instance;
+  return &instance;
+#endif  // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
+}
+
+// Gets the number of successful test cases.
+int UnitTest::successful_test_case_count() const {
+  return impl()->successful_test_case_count();
+}
+
+// Gets the number of failed test cases.
+int UnitTest::failed_test_case_count() const {
+  return impl()->failed_test_case_count();
+}
+
+// Gets the number of all test cases.
+int UnitTest::total_test_case_count() const {
+  return impl()->total_test_case_count();
+}
+
+// Gets the number of all test cases that contain at least one test
+// that should run.
+int UnitTest::test_case_to_run_count() const {
+  return impl()->test_case_to_run_count();
+}
+
+// Gets the number of successful tests.
+int UnitTest::successful_test_count() const {
+  return impl()->successful_test_count();
+}
+
+// Gets the number of failed tests.
+int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
+
+// Gets the number of disabled tests that will be reported in the XML report.
+int UnitTest::reportable_disabled_test_count() const {
+  return impl()->reportable_disabled_test_count();
+}
+
+// Gets the number of disabled tests.
+int UnitTest::disabled_test_count() const {
+  return impl()->disabled_test_count();
+}
+
+// Gets the number of tests to be printed in the XML report.
+int UnitTest::reportable_test_count() const {
+  return impl()->reportable_test_count();
+}
+
+// Gets the number of all tests.
+int UnitTest::total_test_count() const { return impl()->total_test_count(); }
+
+// Gets the number of tests that should run.
+int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
+
+// Gets the time of the test program start, in ms from the start of the
+// UNIX epoch.
+internal::TimeInMillis UnitTest::start_timestamp() const {
+    return impl()->start_timestamp();
+}
+
+// Gets the elapsed time, in milliseconds.
+internal::TimeInMillis UnitTest::elapsed_time() const {
+  return impl()->elapsed_time();
+}
+
+// Returns true iff the unit test passed (i.e. all test cases passed).
+bool UnitTest::Passed() const { return impl()->Passed(); }
+
+// Returns true iff the unit test failed (i.e. some test case failed
+// or something outside of all tests failed).
+bool UnitTest::Failed() const { return impl()->Failed(); }
+
+// Gets the i-th test case among all the test cases. i can range from 0 to
+// total_test_case_count() - 1. If i is not in that range, returns NULL.
+const TestCase* UnitTest::GetTestCase(int i) const {
+  return impl()->GetTestCase(i);
+}
+
+// Returns the TestResult containing information on test failures and
+// properties logged outside of individual test cases.
+const TestResult& UnitTest::ad_hoc_test_result() const {
+  return *impl()->ad_hoc_test_result();
+}
+
+// Gets the i-th test case among all the test cases. i can range from 0 to
+// total_test_case_count() - 1. If i is not in that range, returns NULL.
+TestCase* UnitTest::GetMutableTestCase(int i) {
+  return impl()->GetMutableTestCase(i);
+}
+
+// Returns the list of event listeners that can be used to track events
+// inside Google Test.
+TestEventListeners& UnitTest::listeners() {
+  return *impl()->listeners();
+}
+
+// Registers and returns a global test environment.  When a test
+// program is run, all global test environments will be set-up in the
+// order they were registered.  After all tests in the program have
+// finished, all global test environments will be torn-down in the
+// *reverse* order they were registered.
+//
+// The UnitTest object takes ownership of the given environment.
+//
+// We don't protect this under mutex_, as we only support calling it
+// from the main thread.
+Environment* UnitTest::AddEnvironment(Environment* env) {
+  if (env == NULL) {
+    return NULL;
+  }
+
+  impl_->environments().push_back(env);
+  return env;
+}
+
+// Adds a TestPartResult to the current TestResult object.  All Google Test
+// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
+// this to report their results.  The user code should use the
+// assertion macros instead of calling this directly.
+void UnitTest::AddTestPartResult(
+    TestPartResult::Type result_type,
+    const char* file_name,
+    int line_number,
+    const std::string& message,
+    const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
+  Message msg;
+  msg << message;
+
+  internal::MutexLock lock(&mutex_);
+  if (impl_->gtest_trace_stack().size() > 0) {
+    msg << "\n" << GTEST_NAME_ << " trace:";
+
+    for (int i = static_cast<int>(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() != NULL && !os_stack_trace.empty()) {
+    msg << internal::kStackTraceMarker << os_stack_trace;
+  }
+
+  const TestPartResult result =
+    TestPartResult(result_type, file_name, line_number,
+                   msg.GetString().c_str());
+  impl_->GetTestPartResultReporterForCurrentThread()->
+      ReportTestPartResult(result);
+
+  if (result_type != TestPartResult::kSuccess) {
+    // 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
+    // with another testing framework) and specify the former on the
+    // command line for debugging.
+    if (GTEST_FLAG(break_on_failure)) {
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+      // Using DebugBreak on Windows allows gtest to still break into a debugger
+      // when a failure happens and both the --gtest_break_on_failure and
+      // the --gtest_catch_exceptions flags are specified.
+      DebugBreak();
+#else
+      // Dereference NULL through a volatile pointer to prevent the compiler
+      // from removing. We use this rather than abort() or __builtin_trap() for
+      // portability: Symbian doesn't implement abort() well, and some debuggers
+      // don't correctly trap abort().
+      *static_cast<volatile int*>(NULL) = 1;
+#endif  // GTEST_OS_WINDOWS
+    } else if (GTEST_FLAG(throw_on_failure)) {
+#if GTEST_HAS_EXCEPTIONS
+      throw internal::GoogleTestFailureException(result);
+#else
+      // We cannot call abort() as it generates a pop-up in debug mode
+      // that cannot be suppressed in VC 7.1 or below.
+      exit(1);
+#endif
+    }
+  }
+}
+
+// Adds a TestProperty to the current TestResult object when invoked from
+// inside a test, to current TestCase's ad_hoc_test_result_ when invoked
+// from SetUpTestCase or TearDownTestCase, 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,
+                              const std::string& value) {
+  impl_->RecordProperty(TestProperty(key, value));
+}
+
+// Runs all tests in this UnitTest object and prints the result.
+// Returns 0 if successful, or 1 otherwise.
+//
+// We don't protect this under mutex_, as we only support calling it
+// from the main thread.
+int UnitTest::Run() {
+  const bool in_death_test_child_process =
+      internal::GTEST_FLAG(internal_run_death_test).length() > 0;
+
+  // Google Test implements this protocol for catching that a test
+  // program exits before returning control to Google Test:
+  //
+  //   1. Upon start, Google Test creates a file whose absolute path
+  //      is specified by the environment variable
+  //      TEST_PREMATURE_EXIT_FILE.
+  //   2. When Google Test has finished its work, it deletes the file.
+  //
+  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
+  // running a Google-Test-based test program and check the existence
+  // of the file at the end of the test execution to see if it has
+  // exited prematurely.
+
+  // If we are in the child process of a death test, don't
+  // create/delete the premature exit file, as doing so is unnecessary
+  // and will confuse the parent process.  Otherwise, create/delete
+  // the file upon entering/leaving this function.  If the program
+  // somehow exits before this function has a chance to return, the
+  // premature-exit file will be left undeleted, causing a test runner
+  // 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 ?
+      NULL : 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_HAS_SEH
+  // 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
+  // about crashes - they are expected.
+  if (impl()->catch_exceptions() || in_death_test_child_process) {
+# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+    // SetErrorMode doesn't exist on CE.
+    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
+                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
+# endif  // !GTEST_OS_WINDOWS_MOBILE
+
+# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
+    // Death test children can be terminated with _abort().  On Windows,
+    // _abort() can show a dialog with a warning message.  This forces the
+    // abort message to go to stderr instead.
+    _set_error_mode(_OUT_TO_STDERR);
+# endif
+
+# if _MSC_VER >= 1400 && !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
+    // executed. Google Test will notify the user of any unexpected
+    // failure via stderr.
+    //
+    // VC++ doesn't define _set_abort_behavior() prior to the version 8.0.
+    // Users of prior VC versions shall suffer the agony and pain of
+    // clicking through the countless debug dialogs.
+    // TODO(vladl@google.com): find a way to suppress the abort dialog() in the
+    // debug mode when compiled with VC 7.1 or lower.
+    if (!GTEST_FLAG(break_on_failure))
+      _set_abort_behavior(
+          0x0,                                    // Clear the following flags:
+          _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
+# endif
+  }
+#endif  // GTEST_HAS_SEH
+
+  return internal::HandleExceptionsInMethodIfSupported(
+      impl(),
+      &internal::UnitTestImpl::RunAllTests,
+      "auxiliary test code (environments or event listeners)") ? 0 : 1;
+}
+
+// Returns the working directory when the first TEST() or TEST_F() was
+// executed.
+const char* UnitTest::original_working_dir() const {
+  return impl_->original_working_dir_.c_str();
+}
+
+// Returns the TestCase object for the test that's currently running,
+// or NULL if no test is running.
+const TestCase* UnitTest::current_test_case() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  return impl_->current_test_case();
+}
+
+// Returns the TestInfo object for the test that's currently running,
+// or NULL if no test is running.
+const TestInfo* UnitTest::current_test_info() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  return impl_->current_test_info();
+}
+
+// Returns the random seed used at the start of the current test run.
+int UnitTest::random_seed() const { return impl_->random_seed(); }
+
+#if GTEST_HAS_PARAM_TEST
+// Returns ParameterizedTestCaseRegistry object used to keep track of
+// value-parameterized tests and instantiate and register them.
+internal::ParameterizedTestCaseRegistry&
+    UnitTest::parameterized_test_registry()
+        GTEST_LOCK_EXCLUDED_(mutex_) {
+  return impl_->parameterized_test_registry();
+}
+#endif  // GTEST_HAS_PARAM_TEST
+
+// Creates an empty UnitTest.
+UnitTest::UnitTest() {
+  impl_ = new internal::UnitTestImpl(this);
+}
+
+// Destructor of UnitTest.
+UnitTest::~UnitTest() {
+  delete impl_;
+}
+
+// Pushes a trace defined by SCOPED_TRACE() on to the per-thread
+// Google Test trace stack.
+void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  impl_->gtest_trace_stack().push_back(trace);
+}
+
+// Pops a trace from the per-thread Google Test trace stack.
+void UnitTest::PopGTestTrace()
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  impl_->gtest_trace_stack().pop_back();
+}
+
+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_per_thread_test_part_result_reporter_(this),
+      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_),
+#if GTEST_HAS_PARAM_TEST
+      parameterized_test_registry_(),
+      parameterized_tests_registered_(false),
+#endif  // GTEST_HAS_PARAM_TEST
+      last_death_test_case_(-1),
+      current_test_case_(NULL),
+      current_test_info_(NULL),
+      ad_hoc_test_result_(),
+      os_stack_trace_getter_(NULL),
+      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.
+      start_timestamp_(0),
+      elapsed_time_(0),
+#if GTEST_HAS_DEATH_TEST
+      death_test_factory_(new DefaultDeathTestFactory),
+#endif
+      // Will be overridden by the flag before first use.
+      catch_exceptions_(false) {
+  listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
+}
+
+UnitTestImpl::~UnitTestImpl() {
+  // Deletes every TestCase.
+  ForEach(test_cases_, internal::Delete<TestCase>);
+
+  // Deletes every Environment.
+  ForEach(environments_, internal::Delete<Environment>);
+
+  delete os_stack_trace_getter_;
+}
+
+// Adds a TestProperty to the current TestResult object when invoked in a
+// context of a test, to current test case's ad_hoc_test_result when invoke
+// from SetUpTestCase/TearDownTestCase, 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_ != NULL) {
+    xml_element = "testcase";
+    test_result = &(current_test_info_->result_);
+  } else if (current_test_case_ != NULL) {
+    xml_element = "testsuite";
+    test_result = &(current_test_case_->ad_hoc_test_result_);
+  } else {
+    xml_element = "testsuites";
+    test_result = &ad_hoc_test_result_;
+  }
+  test_result->RecordProperty(xml_element, test_property);
+}
+
+#if GTEST_HAS_DEATH_TEST
+// 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() != NULL)
+    listeners()->SuppressEventForwarding();
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Initializes event listeners performing XML output as specified by
+// UnitTestOptions. Must not be called before InitGoogleTest.
+void UnitTestImpl::ConfigureXmlOutput() {
+  const std::string& output_format = UnitTestOptions::GetOutputFormat();
+  if (output_format == "xml") {
+    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
+        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
+  } else if (output_format != "") {
+    printf("WARNING: unrecognized output format \"%s\" ignored.\n",
+           output_format.c_str());
+    fflush(stdout);
+  }
+}
+
+#if GTEST_CAN_STREAM_RESULTS_
+// Initializes event listeners for streaming test results in string form.
+// Must not be called before InitGoogleTest.
+void UnitTestImpl::ConfigureStreamingOutput() {
+  const std::string& target = GTEST_FLAG(stream_result_to);
+  if (!target.empty()) {
+    const size_t pos = target.find(':');
+    if (pos != std::string::npos) {
+      listeners()->Append(new StreamingListener(target.substr(0, pos),
+                                                target.substr(pos+1)));
+    } else {
+      printf("WARNING: unrecognized streaming target \"%s\" ignored.\n",
+             target.c_str());
+      fflush(stdout);
+    }
+  }
+}
+#endif  // GTEST_CAN_STREAM_RESULTS_
+
+// Performs initialization dependent upon flag values obtained in
+// ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
+// ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
+// this function is also called from RunAllTests.  Since this function can be
+// called more than once, it has to be idempotent.
+void UnitTestImpl::PostFlagParsingInit() {
+  // Ensures that this function does not execute more than once.
+  if (!post_flag_parse_init_performed_) {
+    post_flag_parse_init_performed_ = true;
+
+#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
+    // Register to send notifications about key process state changes.
+    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
+#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
+
+#if GTEST_HAS_DEATH_TEST
+    InitDeathTestSubprocessControlInfo();
+    SuppressTestEventsIfInSubprocess();
+#endif  // GTEST_HAS_DEATH_TEST
+
+    // Registers parameterized tests. This makes parameterized tests
+    // available to the UnitTest reflection API without running
+    // RUN_ALL_TESTS.
+    RegisterParameterizedTests();
+
+    // Configures listeners for XML output. This makes it possible for users
+    // to shut down the default XML output before invoking RUN_ALL_TESTS.
+    ConfigureXmlOutput();
+
+#if GTEST_CAN_STREAM_RESULTS_
+    // Configures listeners for streaming test results to the specified server.
+    ConfigureStreamingOutput();
+#endif  // GTEST_CAN_STREAM_RESULTS_
+  }
+}
+
+// A predicate that checks the name of a TestCase 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.
+//
+// TestCaseNameIs is copyable.
+class TestCaseNameIs {
+ public:
+  // Constructor.
+  explicit TestCaseNameIs(const std::string& name)
+      : name_(name) {}
+
+  // Returns true iff the name of test_case matches name_.
+  bool operator()(const TestCase* test_case) const {
+    return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0;
+  }
+
+ private:
+  std::string name_;
+};
+
+// Finds and returns a TestCase 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_case_name: name of the test case
+//   type_param:     the name of the test case's type parameter, or NULL if
+//                   this is not a typed or a type-parameterized test case.
+//   set_up_tc:      pointer to the function that sets up the test case
+//   tear_down_tc:   pointer to the function that tears down the test case
+TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
+                                    const char* type_param,
+                                    Test::SetUpTestCaseFunc set_up_tc,
+                                    Test::TearDownTestCaseFunc tear_down_tc) {
+  // Can we find a TestCase with the given name?
+  const std::vector<TestCase*>::const_iterator test_case =
+      std::find_if(test_cases_.begin(), test_cases_.end(),
+                   TestCaseNameIs(test_case_name));
+
+  if (test_case != test_cases_.end())
+    return *test_case;
+
+  // No.  Let's create one.
+  TestCase* const new_test_case =
+      new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc);
+
+  // Is this a death test case?
+  if (internal::UnitTestOptions::MatchesFilter(test_case_name,
+                                               kDeathTestCaseFilter)) {
+    // Yes.  Inserts the test case after the last death test case
+    // defined so far.  This only works when the test cases haven't
+    // been shuffled.  Otherwise we may end up running a death test
+    // after a non-death test.
+    ++last_death_test_case_;
+    test_cases_.insert(test_cases_.begin() + last_death_test_case_,
+                       new_test_case);
+  } else {
+    // No.  Appends to the end of the list.
+    test_cases_.push_back(new_test_case);
+  }
+
+  test_case_indices_.push_back(static_cast<int>(test_case_indices_.size()));
+  return new_test_case;
+}
+
+// Helpers for setting up / tearing down the given environment.  They
+// are for use in the ForEach() function.
+static void SetUpEnvironment(Environment* env) { env->SetUp(); }
+static void TearDownEnvironment(Environment* env) { env->TearDown(); }
+
+// Runs all tests in this UnitTest object, prints the result, and
+// returns true if all tests are successful.  If any exception is
+// thrown during a test, the test is considered to be failed, but the
+// rest of the tests will still be run.
+//
+// When parameterized tests are enabled, it expands and registers
+// parameterized tests first in RegisterParameterizedTests().
+// All other functions called from RunAllTests() may safely assume that
+// parameterized tests are ready to be counted and run.
+bool UnitTestImpl::RunAllTests() {
+  // Makes sure InitGoogleTest() was called.
+  if (!GTestIsInitialized()) {
+    printf("%s",
+           "\nThis test program did NOT call ::testing::InitGoogleTest "
+           "before calling RUN_ALL_TESTS().  Please fix it.\n");
+    return false;
+  }
+
+  // Do not run any test if the --help flag was specified.
+  if (g_help_flag)
+    return true;
+
+  // Repeats the call to the post-flag parsing initialization in case the
+  // user didn't call InitGoogleTest.
+  PostFlagParsingInit();
+
+  // Even if sharding is not on, test runners may want to use the
+  // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
+  // protocol.
+  internal::WriteToShardStatusFileIfNeeded();
+
+  // True iff 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() != NULL);
+# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
+  if (in_subprocess_for_death_test) {
+    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
+  }
+# endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
+#endif  // GTEST_HAS_DEATH_TEST
+
+  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
+                                        in_subprocess_for_death_test);
+
+  // Compares the full test names with the filter to decide which
+  // tests to run.
+  const bool has_tests_to_run = FilterTests(should_shard
+                                              ? HONOR_SHARDING_PROTOCOL
+                                              : IGNORE_SHARDING_PROTOCOL) > 0;
+
+  // Lists the tests and exits if the --gtest_list_tests flag was specified.
+  if (GTEST_FLAG(list_tests)) {
+    // This must be called *after* FilterTests() has been called.
+    ListTestsMatchingFilter();
+    return true;
+  }
+
+  random_seed_ = GTEST_FLAG(shuffle) ?
+      GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
+
+  // True iff at least one test has failed.
+  bool failed = false;
+
+  TestEventListener* repeater = listeners()->repeater();
+
+  start_timestamp_ = GetTimeInMillis();
+  repeater->OnTestProgramStart(*parent_);
+
+  // How many times to repeat the tests?  We don't want to repeat them
+  // 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 forever = repeat < 0;
+  for (int i = 0; forever || i != repeat; i++) {
+    // We want to preserve failures generated by ad-hoc test
+    // assertions executed before RUN_ALL_TESTS().
+    ClearNonAdHocTestResult();
+
+    const TimeInMillis start = GetTimeInMillis();
+
+    // Shuffles test cases and tests if requested.
+    if (has_tests_to_run && GTEST_FLAG(shuffle)) {
+      random()->Reseed(random_seed_);
+      // This should be done before calling OnTestIterationStart(),
+      // such that a test event listener can see the actual test order
+      // in the event.
+      ShuffleTests();
+    }
+
+    // Tells the unit test event listeners that the tests are about to start.
+    repeater->OnTestIterationStart(*parent_, i);
+
+    // Runs each test case 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 during global
+      // set-up.
+      if (!Test::HasFatalFailure()) {
+        for (int test_index = 0; test_index < total_test_case_count();
+             test_index++) {
+          GetMutableTestCase(test_index)->Run();
+        }
+      }
+
+      // Tears down all environments in reverse order afterwards.
+      repeater->OnEnvironmentsTearDownStart(*parent_);
+      std::for_each(environments_.rbegin(), environments_.rend(),
+                    TearDownEnvironment);
+      repeater->OnEnvironmentsTearDownEnd(*parent_);
+    }
+
+    elapsed_time_ = GetTimeInMillis() - start;
+
+    // Tells the unit test event listener that the tests have just finished.
+    repeater->OnTestIterationEnd(*parent_, i);
+
+    // Gets the result and clears it.
+    if (!Passed()) {
+      failed = true;
+    }
+
+    // Restores the original test order after the iteration.  This
+    // allows the user to quickly repro a failure that happens in the
+    // N-th iteration without repeating the first (N - 1) iterations.
+    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
+    // case the user somehow changes the value of the flag somewhere
+    // (it's always safe to unshuffle the tests).
+    UnshuffleTests();
+
+    if (GTEST_FLAG(shuffle)) {
+      // Picks a new random seed for each iteration.
+      random_seed_ = GetNextRandomSeed(random_seed_);
+    }
+  }
+
+  repeater->OnTestProgramEnd(*parent_);
+
+  return !failed;
+}
+
+// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
+// if the variable is present. If a file already exists at this location, this
+// function will write over it. If the variable is present, but the file cannot
+// be created, prints an error and exits.
+void WriteToShardStatusFileIfNeeded() {
+  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
+  if (test_shard_file != NULL) {
+    FILE* const file = posix::FOpen(test_shard_file, "w");
+    if (file == NULL) {
+      ColoredPrintf(COLOR_RED,
+                    "Could not write to the test shard status file \"%s\" "
+                    "specified by the %s environment variable.\n",
+                    test_shard_file, kTestShardStatusFile);
+      fflush(stdout);
+      exit(EXIT_FAILURE);
+    }
+    fclose(file);
+  }
+}
+
+// Checks whether sharding is enabled by examining the relevant
+// environment variable values. If the variables are present,
+// but inconsistent (i.e., shard_index >= total_shards), prints
+// an error and exits. If in_subprocess_for_death_test, sharding is
+// disabled because it must only be applied to the original test
+// process. Otherwise, we could filter out death tests we intended to execute.
+bool ShouldShard(const char* total_shards_env,
+                 const char* shard_index_env,
+                 bool in_subprocess_for_death_test) {
+  if (in_subprocess_for_death_test) {
+    return false;
+  }
+
+  const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1);
+  const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1);
+
+  if (total_shards == -1 && shard_index == -1) {
+    return false;
+  } else if (total_shards == -1 && shard_index != -1) {
+    const Message msg = Message()
+      << "Invalid environment variables: you have "
+      << kTestShardIndex << " = " << shard_index
+      << ", but have left " << kTestTotalShards << " unset.\n";
+    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
+    fflush(stdout);
+    exit(EXIT_FAILURE);
+  } else if (total_shards != -1 && shard_index == -1) {
+    const Message msg = Message()
+      << "Invalid environment variables: you have "
+      << kTestTotalShards << " = " << total_shards
+      << ", but have left " << kTestShardIndex << " unset.\n";
+    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
+    fflush(stdout);
+    exit(EXIT_FAILURE);
+  } else if (shard_index < 0 || shard_index >= total_shards) {
+    const Message msg = Message()
+      << "Invalid environment variables: we require 0 <= "
+      << kTestShardIndex << " < " << kTestTotalShards
+      << ", but you have " << kTestShardIndex << "=" << shard_index
+      << ", " << kTestTotalShards << "=" << total_shards << ".\n";
+    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
+    fflush(stdout);
+    exit(EXIT_FAILURE);
+  }
+
+  return total_shards > 1;
+}
+
+// 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 Int32FromEnvOrDie(const char* var, Int32 default_val) {
+  const char* str_val = posix::GetEnv(var);
+  if (str_val == NULL) {
+    return default_val;
+  }
+
+  Int32 result;
+  if (!ParseInt32(Message() << "The value of environment variable " << var,
+                  str_val, &result)) {
+    exit(EXIT_FAILURE);
+  }
+  return result;
+}
+
+// Given the total number of shards, the shard index, and the test id,
+// returns true iff 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;
+}
+
+// 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 TestCase and TestInfo object.
+// If shard_tests == true, further filters tests based on sharding
+// variables in the environment - see
+// http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide.
+// Returns the number of tests that should run.
+int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
+  const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
+      Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
+  const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
+      Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
+
+  // num_runnable_tests are the number of tests that will
+  // run across all shards (i.e., match filter and are not disabled).
+  // num_selected_tests are the number of tests to be run on
+  // this shard.
+  int num_runnable_tests = 0;
+  int num_selected_tests = 0;
+  for (size_t i = 0; i < test_cases_.size(); i++) {
+    TestCase* const test_case = test_cases_[i];
+    const std::string &test_case_name = test_case->name();
+    test_case->set_should_run(false);
+
+    for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
+      TestInfo* const test_info = test_case->test_info_list()[j];
+      const std::string test_name(test_info->name());
+      // A test is disabled if test case name or test name matches
+      // kDisableTestFilter.
+      const bool is_disabled =
+          internal::UnitTestOptions::MatchesFilter(test_case_name,
+                                                   kDisableTestFilter) ||
+          internal::UnitTestOptions::MatchesFilter(test_name,
+                                                   kDisableTestFilter);
+      test_info->is_disabled_ = is_disabled;
+
+      const bool matches_filter =
+          internal::UnitTestOptions::FilterMatchesTest(test_case_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_selected = is_runnable &&
+          (shard_tests == IGNORE_SHARDING_PROTOCOL ||
+           ShouldRunTestOnShard(total_shards, shard_index,
+                                num_runnable_tests));
+
+      num_runnable_tests += is_runnable;
+      num_selected_tests += is_selected;
+
+      test_info->should_run_ = is_selected;
+      test_case->set_should_run(test_case->should_run() || is_selected);
+    }
+  }
+  return num_selected_tests;
+}
+
+// Prints the given C-string on a single line by replacing all '\n'
+// characters with string "\\n".  If the output takes more than
+// max_length characters, only prints the first max_length characters
+// and "...".
+static void PrintOnOneLine(const char* str, int max_length) {
+  if (str != NULL) {
+    for (int i = 0; *str != '\0'; ++str) {
+      if (i >= max_length) {
+        printf("...");
+        break;
+      }
+      if (*str == '\n') {
+        printf("\\n");
+        i += 2;
+      } else {
+        printf("%c", *str);
+        ++i;
+      }
+    }
+  }
+}
+
+// Prints the names of the tests matching the user-specified filter flag.
+void UnitTestImpl::ListTestsMatchingFilter() {
+  // Print at most this many characters for each type/value parameter.
+  const int kMaxParamLength = 250;
+
+  for (size_t i = 0; i < test_cases_.size(); i++) {
+    const TestCase* const test_case = test_cases_[i];
+    bool printed_test_case_name = false;
+
+    for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
+      const TestInfo* const test_info =
+          test_case->test_info_list()[j];
+      if (test_info->matches_filter_) {
+        if (!printed_test_case_name) {
+          printed_test_case_name = true;
+          printf("%s.", test_case->name());
+          if (test_case->type_param() != NULL) {
+            printf("  # %s = ", kTypeParamLabel);
+            // We print the type parameter on a single line to make
+            // the output easy to parse by a program.
+            PrintOnOneLine(test_case->type_param(), kMaxParamLength);
+          }
+          printf("\n");
+        }
+        printf("  %s", test_info->name());
+        if (test_info->value_param() != NULL) {
+          printf("  # %s = ", kValueParamLabel);
+          // We print the value parameter on a single line to make the
+          // output easy to parse by a program.
+          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
+        }
+        printf("\n");
+      }
+    }
+  }
+  fflush(stdout);
+}
+
+// Sets the OS stack trace getter.
+//
+// Does nothing if the input and the current OS stack trace getter are
+// the same; otherwise, deletes the old getter and makes the input the
+// current getter.
+void UnitTestImpl::set_os_stack_trace_getter(
+    OsStackTraceGetterInterface* getter) {
+  if (os_stack_trace_getter_ != getter) {
+    delete os_stack_trace_getter_;
+    os_stack_trace_getter_ = getter;
+  }
+}
+
+// Returns the current OS stack trace getter if it is not NULL;
+// otherwise, creates an OsStackTraceGetter, makes it the current
+// getter, and returns it.
+OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
+  if (os_stack_trace_getter_ == NULL) {
+#ifdef GTEST_OS_STACK_TRACE_GETTER_
+    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
+#else
+    os_stack_trace_getter_ = new OsStackTraceGetter;
+#endif  // GTEST_OS_STACK_TRACE_GETTER_
+  }
+
+  return os_stack_trace_getter_;
+}
+
+// Returns the TestResult for the test that's currently running, or
+// the TestResult for the ad hoc test if no test is running.
+TestResult* UnitTestImpl::current_test_result() {
+  return current_test_info_ ?
+      &(current_test_info_->result_) : &ad_hoc_test_result_;
+}
+
+// Shuffles all test cases, and the tests within each test case,
+// making sure that death tests are still run first.
+void UnitTestImpl::ShuffleTests() {
+  // Shuffles the death test cases.
+  ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_);
+
+  // Shuffles the non-death test cases.
+  ShuffleRange(random(), last_death_test_case_ + 1,
+               static_cast<int>(test_cases_.size()), &test_case_indices_);
+
+  // Shuffles the tests inside each test case.
+  for (size_t i = 0; i < test_cases_.size(); i++) {
+    test_cases_[i]->ShuffleTests(random());
+  }
+}
+
+// Restores the test cases and tests to their order before the first shuffle.
+void UnitTestImpl::UnshuffleTests() {
+  for (size_t i = 0; i < test_cases_.size(); i++) {
+    // Unshuffles the tests in each test case.
+    test_cases_[i]->UnshuffleTests();
+    // Resets the index of each test case.
+    test_case_indices_[i] = static_cast<int>(i);
+  }
+}
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
+// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
+std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
+                                            int skip_count) {
+  // We pass skip_count + 1 to skip this wrapper function in addition
+  // to what the user really wants to skip.
+  return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
+}
+
+// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to
+// suppress unreachable code warnings.
+namespace {
+class ClassUniqueToAlwaysTrue {};
+}
+
+bool IsTrue(bool condition) { return condition; }
+
+bool AlwaysTrue() {
+#if GTEST_HAS_EXCEPTIONS
+  // This condition is always false so AlwaysTrue() never actually throws,
+  // but it makes the compiler think that it may throw.
+  if (IsTrue(false))
+    throw ClassUniqueToAlwaysTrue();
+#endif  // GTEST_HAS_EXCEPTIONS
+  return true;
+}
+
+// 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.
+bool SkipPrefix(const char* prefix, const char** pstr) {
+  const size_t prefix_len = strlen(prefix);
+  if (strncmp(*pstr, prefix, prefix_len) == 0) {
+    *pstr += prefix_len;
+    return true;
+  }
+  return false;
+}
+
+// Parses a string as a command line flag.  The string should have
+// the format "--flag=value".  When def_optional is true, the "=value"
+// part can be omitted.
+//
+// Returns the value of the flag, or NULL if the parsing failed.
+const char* ParseFlagValue(const char* str,
+                           const char* flag,
+                           bool def_optional) {
+  // str and flag must not be NULL.
+  if (str == NULL || flag == NULL) return NULL;
+
+  // 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 NULL;
+
+  // Skips the flag name.
+  const char* flag_end = str + flag_len;
+
+  // When def_optional is true, it's OK to not have a "=value" part.
+  if (def_optional && (flag_end[0] == '\0')) {
+    return flag_end;
+  }
+
+  // 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 NULL;
+
+  // Returns the string after "=".
+  return flag_end + 1;
+}
+
+// Parses a string for a bool flag, in the form of either
+// "--flag=value" or "--flag".
+//
+// In the former case, the value is taken as true as long as it does
+// not start with '0', 'f', or 'F'.
+//
+// In the latter case, the value is taken as true.
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+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 == NULL) 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 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* 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 == NULL) 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".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+bool ParseStringFlag(const char* str, const char* flag, std::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 == NULL) return false;
+
+  // Sets *value to the value of the flag.
+  *value = value_str;
+  return true;
+}
+
+// Determines whether a string has a prefix that Google Test uses for its
+// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_.
+// If Google Test detects that a command line flag has its prefix but is not
+// recognized, it will print its help message. Flags starting with
+// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test
+// internal flags and do not trigger the help message.
+static bool HasGoogleTestFlagPrefix(const char* str) {
+  return (SkipPrefix("--", &str) ||
+          SkipPrefix("-", &str) ||
+          SkipPrefix("/", &str)) &&
+         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
+         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
+          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
+}
+
+// Prints a string containing code-encoded text.  The following escape
+// sequences can be used in the string to control the text color:
+//
+//   @@    prints a single '@' character.
+//   @R    changes the color to red.
+//   @G    changes the color to green.
+//   @Y    changes the color to yellow.
+//   @D    changes to the default terminal text color.
+//
+// TODO(wan@google.com): Write tests for this once we add stdout
+// capturing to Google Test.
+static void PrintColorEncoded(const char* str) {
+  GTestColor color = COLOR_DEFAULT;  // 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
+  // each iteration, the str pointer advances to the beginning of the
+  // next segment.
+  for (;;) {
+    const char* p = strchr(str, '@');
+    if (p == NULL) {
+      ColoredPrintf(color, "%s", str);
+      return;
+    }
+
+    ColoredPrintf(color, "%s", std::string(str, p).c_str());
+
+    const char ch = p[1];
+    str = p + 2;
+    if (ch == '@') {
+      ColoredPrintf(color, "@");
+    } else if (ch == 'D') {
+      color = COLOR_DEFAULT;
+    } else if (ch == 'R') {
+      color = COLOR_RED;
+    } else if (ch == 'G') {
+      color = COLOR_GREEN;
+    } else if (ch == 'Y') {
+      color = COLOR_YELLOW;
+    } else {
+      --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=@YPOSTIVE_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_ "print_time=0@D\n"
+"      Don't print the elapsed time of each test.\n"
+"  @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G"
+    GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n"
+"      Generate an XML report in the given directory or with the given file\n"
+"      name. @YFILE_PATH@D defaults to @Gtest_details.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.\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_
+    "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";
+
+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)) ||
+      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, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
+      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_
+void LoadFlagsFromFile(const std::string& path) {
+  FILE* flagfile = posix::FOpen(path.c_str(), "r");
+  if (!flagfile) {
+    fprintf(stderr,
+            "Unable to open file \"%s\"\n",
+            GTEST_FLAG(flagfile).c_str());
+    fflush(stderr);
+    exit(EXIT_FAILURE);
+  }
+  std::string contents(ReadEntireFile(flagfile));
+  posix::FClose(flagfile);
+  std::vector<std::string> lines;
+  SplitString(contents, '\n', &lines);
+  for (size_t i = 0; i < lines.size(); ++i) {
+    if (lines[i].empty())
+      continue;
+    if (!ParseGoogleTestFlag(lines[i].c_str()))
+      g_help_flag = true;
+  }
+}
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+
+// Parses the command line for Google Test flags, without initializing
+// other parts of Google Test.  The type parameter CharType can be
+// instantiated to either char or wchar_t.
+template <typename CharType>
+void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
+  for (int i = 1; i < *argc; i++) {
+    const std::string arg_string = StreamableToString(argv[i]);
+    const char* const arg = arg_string.c_str();
+
+    using internal::ParseBoolFlag;
+    using internal::ParseInt32Flag;
+    using internal::ParseStringFlag;
+
+    bool remove_flag = false;
+    if (ParseGoogleTestFlag(arg)) {
+      remove_flag = true;
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+    } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) {
+      LoadFlagsFromFile(GTEST_FLAG(flagfile));
+      remove_flag = true;
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+    } else if (arg_string == "--help" || arg_string == "-h" ||
+               arg_string == "-?" || arg_string == "/?" ||
+               HasGoogleTestFlagPrefix(arg)) {
+      // Both help flag and unrecognized Google Test flags (excluding
+      // internal ones) trigger help display.
+      g_help_flag = true;
+    }
+
+    if (remove_flag) {
+      // 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
+      // well.
+      for (int j = i; j != *argc; j++) {
+        argv[j] = argv[j + 1];
+      }
+
+      // Decrements the argument count.
+      (*argc)--;
+
+      // We also need to decrement the iterator as we just removed
+      // an element.
+      i--;
+    }
+  }
+
+  if (g_help_flag) {
+    // We print the help here instead of in RUN_ALL_TESTS(), as the
+    // latter may not be called at all if the user is using Google
+    // Test with another testing framework.
+    PrintColorEncoded(kColorEncodedHelpMessage);
+  }
+}
+
+// Parses the command line for Google Test flags, without initializing
+// other parts of Google Test.
+void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
+  ParseGoogleTestFlagsOnlyImpl(argc, argv);
+}
+void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
+  ParseGoogleTestFlagsOnlyImpl(argc, argv);
+}
+
+// The internal implementation of InitGoogleTest().
+//
+// The type parameter CharType can be instantiated to either char or
+// wchar_t.
+template <typename CharType>
+void InitGoogleTestImpl(int* argc, CharType** argv) {
+  // We don't want to run the initialization code twice.
+  if (GTestIsInitialized()) return;
+
+  if (*argc <= 0) return;
+
+  g_argvs.clear();
+  for (int i = 0; i != *argc; i++) {
+    g_argvs.push_back(StreamableToString(argv[i]));
+  }
+
+  ParseGoogleTestFlagsOnly(argc, argv);
+  GetUnitTestImpl()->PostFlagParsingInit();
+}
+
+}  // namespace internal
+
+// Initializes Google Test.  This must be called before calling
+// RUN_ALL_TESTS().  In particular, it parses a command line for the
+// flags that Google Test recognizes.  Whenever a Google Test flag is
+// seen, it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Test flag variables are
+// updated.
+//
+// Calling the function for the second time has no user-visible effect.
+void InitGoogleTest(int* argc, char** argv) {
+#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_)
+}
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+void InitGoogleTest(int* argc, wchar_t** argv) {
+#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_)
+}
+
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest_main.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest_main.cc
new file mode 100644
index 00000000..f3028225
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest_main.cc
@@ -0,0 +1,38 @@
+// Copyright 2006, 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.
+
+#include <stdio.h>
+
+#include "gtest/gtest.h"
+
+GTEST_API_ int main(int argc, char **argv) {
+  printf("Running main() from gtest_main.cc\n");
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_ex_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_ex_test.cc
new file mode 100644
index 00000000..b50a13d5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_ex_test.cc
@@ -0,0 +1,93 @@
+// Copyright 2010, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: vladl@google.com (Vlad Losev)
+//
+// Tests that verify interaction of exceptions and death tests.
+
+#include "gtest/gtest-death-test.h"
+#include "gtest/gtest.h"
+
+#if GTEST_HAS_DEATH_TEST
+
+# if GTEST_HAS_SEH
+#  include <windows.h>          // For RaiseException().
+# endif
+
+# include "gtest/gtest-spi.h"
+
+# if GTEST_HAS_EXCEPTIONS
+
+#  include <exception>  // For std::exception.
+
+// Tests that death tests report thrown exceptions as failures and that the
+// exceptions do not escape death test macros.
+TEST(CxxExceptionDeathTest, ExceptionIsFailure) {
+  try {
+    EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(throw 1, ""), "threw an exception");
+  } catch (...) {  // NOLINT
+    FAIL() << "An exception escaped a death test macro invocation "
+           << "with catch_exceptions "
+           << (testing::GTEST_FLAG(catch_exceptions) ? "enabled" : "disabled");
+  }
+}
+
+class TestException : public std::exception {
+ public:
+  virtual const char* what() const throw() { return "exceptional message"; }
+};
+
+TEST(CxxExceptionDeathTest, PrintsMessageForStdExceptions) {
+  // Verifies that the exception message is quoted in the failure text.
+  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(throw TestException(), ""),
+                          "exceptional message");
+  // Verifies that the location is mentioned in the failure text.
+  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(throw TestException(), ""),
+                          "gtest-death-test_ex_test.cc");
+}
+# endif  // GTEST_HAS_EXCEPTIONS
+
+# if GTEST_HAS_SEH
+// Tests that enabling interception of SEH exceptions with the
+// catch_exceptions flag does not interfere with SEH exceptions being
+// treated as death by death tests.
+TEST(SehExceptionDeasTest, CatchExceptionsDoesNotInterfere) {
+  EXPECT_DEATH(RaiseException(42, 0x0, 0, NULL), "")
+      << "with catch_exceptions "
+      << (testing::GTEST_FLAG(catch_exceptions) ? "enabled" : "disabled");
+}
+# endif
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  testing::GTEST_FLAG(catch_exceptions) = GTEST_ENABLE_CATCH_EXCEPTIONS_ != 0;
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_test.cc
new file mode 100644
index 00000000..bb4a3d1b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_test.cc
@@ -0,0 +1,1427 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Tests for death tests.
+
+#include "gtest/gtest-death-test.h"
+#include "gtest/gtest.h"
+#include "gtest/internal/gtest-filepath.h"
+
+using testing::internal::AlwaysFalse;
+using testing::internal::AlwaysTrue;
+
+#if GTEST_HAS_DEATH_TEST
+
+# if GTEST_OS_WINDOWS
+#  include <direct.h>          // For chdir().
+# else
+#  include <unistd.h>
+#  include <sys/wait.h>        // For waitpid.
+# endif  // GTEST_OS_WINDOWS
+
+# include <limits.h>
+# include <signal.h>
+# include <stdio.h>
+
+# if GTEST_OS_LINUX
+#  include <sys/time.h>
+# endif  // GTEST_OS_LINUX
+
+# include "gtest/gtest-spi.h"
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+# define GTEST_IMPLEMENTATION_ 1
+# include "src/gtest-internal-inl.h"
+# undef GTEST_IMPLEMENTATION_
+
+namespace posix = ::testing::internal::posix;
+
+using testing::Message;
+using testing::internal::DeathTest;
+using testing::internal::DeathTestFactory;
+using testing::internal::FilePath;
+using testing::internal::GetLastErrnoDescription;
+using testing::internal::GetUnitTestImpl;
+using testing::internal::InDeathTestChild;
+using testing::internal::ParseNaturalNumber;
+
+namespace testing {
+namespace internal {
+
+// A helper class whose objects replace the death test factory for a
+// single UnitTest object during their lifetimes.
+class ReplaceDeathTestFactory {
+ public:
+  explicit ReplaceDeathTestFactory(DeathTestFactory* new_factory)
+      : unit_test_impl_(GetUnitTestImpl()) {
+    old_factory_ = unit_test_impl_->death_test_factory_.release();
+    unit_test_impl_->death_test_factory_.reset(new_factory);
+  }
+
+  ~ReplaceDeathTestFactory() {
+    unit_test_impl_->death_test_factory_.release();
+    unit_test_impl_->death_test_factory_.reset(old_factory_);
+  }
+ private:
+  // Prevents copying ReplaceDeathTestFactory objects.
+  ReplaceDeathTestFactory(const ReplaceDeathTestFactory&);
+  void operator=(const ReplaceDeathTestFactory&);
+
+  UnitTestImpl* unit_test_impl_;
+  DeathTestFactory* old_factory_;
+};
+
+}  // namespace internal
+}  // namespace testing
+
+void DieWithMessage(const ::std::string& message) {
+  fprintf(stderr, "%s", message.c_str());
+  fflush(stderr);  // Make sure the text is printed before the process exits.
+
+  // We call _exit() instead of exit(), as the former is a direct
+  // system call and thus safer in the presence of threads.  exit()
+  // will invoke user-defined exit-hooks, which may do dangerous
+  // things that conflict with death tests.
+  //
+  // Some compilers can recognize that _exit() never returns and issue the
+  // 'unreachable code' warning for code following this function, unless
+  // fooled by a fake condition.
+  if (AlwaysTrue())
+    _exit(1);
+}
+
+void DieInside(const ::std::string& function) {
+  DieWithMessage("death inside " + function + "().");
+}
+
+// Tests that death tests work.
+
+class TestForDeathTest : public testing::Test {
+ protected:
+  TestForDeathTest() : original_dir_(FilePath::GetCurrentDir()) {}
+
+  virtual ~TestForDeathTest() {
+    posix::ChDir(original_dir_.c_str());
+  }
+
+  // A static member function that's expected to die.
+  static void StaticMemberFunction() { DieInside("StaticMemberFunction"); }
+
+  // A method of the test fixture that may die.
+  void MemberFunction() {
+    if (should_die_)
+      DieInside("MemberFunction");
+  }
+
+  // True iff MemberFunction() should die.
+  bool should_die_;
+  const FilePath original_dir_;
+};
+
+// A class with a member function that may die.
+class MayDie {
+ public:
+  explicit MayDie(bool should_die) : should_die_(should_die) {}
+
+  // A member function that may die.
+  void MemberFunction() const {
+    if (should_die_)
+      DieInside("MayDie::MemberFunction");
+  }
+
+ private:
+  // True iff MemberFunction() should die.
+  bool should_die_;
+};
+
+// A global function that's expected to die.
+void GlobalFunction() { DieInside("GlobalFunction"); }
+
+// A non-void function that's expected to die.
+int NonVoidFunction() {
+  DieInside("NonVoidFunction");
+  return 1;
+}
+
+// A unary function that may die.
+void DieIf(bool should_die) {
+  if (should_die)
+    DieInside("DieIf");
+}
+
+// A binary function that may die.
+bool DieIfLessThan(int x, int y) {
+  if (x < y) {
+    DieInside("DieIfLessThan");
+  }
+  return true;
+}
+
+// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.
+void DeathTestSubroutine() {
+  EXPECT_DEATH(GlobalFunction(), "death.*GlobalFunction");
+  ASSERT_DEATH(GlobalFunction(), "death.*GlobalFunction");
+}
+
+// Death in dbg, not opt.
+int DieInDebugElse12(int* sideeffect) {
+  if (sideeffect) *sideeffect = 12;
+
+# ifndef NDEBUG
+
+  DieInside("DieInDebugElse12");
+
+# endif  // NDEBUG
+
+  return 12;
+}
+
+# if GTEST_OS_WINDOWS
+
+// Tests the ExitedWithCode predicate.
+TEST(ExitStatusPredicateTest, ExitedWithCode) {
+  // On Windows, the process's exit code is the same as its exit status,
+  // so the predicate just compares the its input with its parameter.
+  EXPECT_TRUE(testing::ExitedWithCode(0)(0));
+  EXPECT_TRUE(testing::ExitedWithCode(1)(1));
+  EXPECT_TRUE(testing::ExitedWithCode(42)(42));
+  EXPECT_FALSE(testing::ExitedWithCode(0)(1));
+  EXPECT_FALSE(testing::ExitedWithCode(1)(0));
+}
+
+# else
+
+// Returns the exit status of a process that calls _exit(2) with a
+// given exit code.  This is a helper function for the
+// ExitStatusPredicateTest test suite.
+static int NormalExitStatus(int exit_code) {
+  pid_t child_pid = fork();
+  if (child_pid == 0) {
+    _exit(exit_code);
+  }
+  int status;
+  waitpid(child_pid, &status, 0);
+  return status;
+}
+
+// Returns the exit status of a process that raises a given signal.
+// If the signal does not cause the process to die, then it returns
+// instead the exit status of a process that exits normally with exit
+// code 1.  This is a helper function for the ExitStatusPredicateTest
+// test suite.
+static int KilledExitStatus(int signum) {
+  pid_t child_pid = fork();
+  if (child_pid == 0) {
+    raise(signum);
+    _exit(1);
+  }
+  int status;
+  waitpid(child_pid, &status, 0);
+  return status;
+}
+
+// Tests the ExitedWithCode predicate.
+TEST(ExitStatusPredicateTest, ExitedWithCode) {
+  const int status0  = NormalExitStatus(0);
+  const int status1  = NormalExitStatus(1);
+  const int status42 = NormalExitStatus(42);
+  const testing::ExitedWithCode pred0(0);
+  const testing::ExitedWithCode pred1(1);
+  const testing::ExitedWithCode pred42(42);
+  EXPECT_PRED1(pred0,  status0);
+  EXPECT_PRED1(pred1,  status1);
+  EXPECT_PRED1(pred42, status42);
+  EXPECT_FALSE(pred0(status1));
+  EXPECT_FALSE(pred42(status0));
+  EXPECT_FALSE(pred1(status42));
+}
+
+// Tests the KilledBySignal predicate.
+TEST(ExitStatusPredicateTest, KilledBySignal) {
+  const int status_segv = KilledExitStatus(SIGSEGV);
+  const int status_kill = KilledExitStatus(SIGKILL);
+  const testing::KilledBySignal pred_segv(SIGSEGV);
+  const testing::KilledBySignal pred_kill(SIGKILL);
+  EXPECT_PRED1(pred_segv, status_segv);
+  EXPECT_PRED1(pred_kill, status_kill);
+  EXPECT_FALSE(pred_segv(status_kill));
+  EXPECT_FALSE(pred_kill(status_segv));
+}
+
+# endif  // GTEST_OS_WINDOWS
+
+// Tests that the death test macros expand to code which may or may not
+// be followed by operator<<, and that in either case the complete text
+// comprises only a single C++ statement.
+TEST_F(TestForDeathTest, SingleStatement) {
+  if (AlwaysFalse())
+    // This would fail if executed; this is a compilation test only
+    ASSERT_DEATH(return, "");
+
+  if (AlwaysTrue())
+    EXPECT_DEATH(_exit(1), "");
+  else
+    // This empty "else" branch is meant to ensure that EXPECT_DEATH
+    // doesn't expand into an "if" statement without an "else"
+    ;
+
+  if (AlwaysFalse())
+    ASSERT_DEATH(return, "") << "did not die";
+
+  if (AlwaysFalse())
+    ;
+  else
+    EXPECT_DEATH(_exit(1), "") << 1 << 2 << 3;
+}
+
+void DieWithEmbeddedNul() {
+  fprintf(stderr, "Hello%cmy null world.\n", '\0');
+  fflush(stderr);
+  _exit(1);
+}
+
+# if GTEST_USES_PCRE
+// Tests that EXPECT_DEATH and ASSERT_DEATH work when the error
+// message has a NUL character in it.
+TEST_F(TestForDeathTest, EmbeddedNulInMessage) {
+  // TODO(wan@google.com): <regex.h> doesn't support matching strings
+  // with embedded NUL characters - find a way to workaround it.
+  EXPECT_DEATH(DieWithEmbeddedNul(), "my null world");
+  ASSERT_DEATH(DieWithEmbeddedNul(), "my null world");
+}
+# endif  // GTEST_USES_PCRE
+
+// Tests that death test macros expand to code which interacts well with switch
+// statements.
+TEST_F(TestForDeathTest, SwitchStatement) {
+  // Microsoft compiler usually complains about switch statements without
+  // case labels. We suppress that warning for this test.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4065)
+
+  switch (0)
+    default:
+      ASSERT_DEATH(_exit(1), "") << "exit in default switch handler";
+
+  switch (0)
+    case 0:
+      EXPECT_DEATH(_exit(1), "") << "exit in switch case";
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+}
+
+// Tests that a static member function can be used in a "fast" style
+// death test.
+TEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");
+}
+
+// Tests that a method of the test fixture can be used in a "fast"
+// style death test.
+TEST_F(TestForDeathTest, MemberFunctionFastStyle) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  should_die_ = true;
+  EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
+}
+
+void ChangeToRootDir() { posix::ChDir(GTEST_PATH_SEP_); }
+
+// Tests that death tests work even if the current directory has been
+// changed.
+TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+
+  ChangeToRootDir();
+  EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
+
+  ChangeToRootDir();
+  ASSERT_DEATH(_exit(1), "");
+}
+
+# if GTEST_OS_LINUX
+void SigprofAction(int, siginfo_t*, void*) { /* no op */ }
+
+// Sets SIGPROF action and ITIMER_PROF timer (interval: 1ms).
+void SetSigprofActionAndTimer() {
+  struct itimerval timer;
+  timer.it_interval.tv_sec = 0;
+  timer.it_interval.tv_usec = 1;
+  timer.it_value = timer.it_interval;
+  ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL));
+  struct sigaction signal_action;
+  memset(&signal_action, 0, sizeof(signal_action));
+  sigemptyset(&signal_action.sa_mask);
+  signal_action.sa_sigaction = SigprofAction;
+  signal_action.sa_flags = SA_RESTART | SA_SIGINFO;
+  ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, NULL));
+}
+
+// Disables ITIMER_PROF timer and ignores SIGPROF signal.
+void DisableSigprofActionAndTimer(struct sigaction* old_signal_action) {
+  struct itimerval timer;
+  timer.it_interval.tv_sec = 0;
+  timer.it_interval.tv_usec = 0;
+  timer.it_value = timer.it_interval;
+  ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL));
+  struct sigaction signal_action;
+  memset(&signal_action, 0, sizeof(signal_action));
+  sigemptyset(&signal_action.sa_mask);
+  signal_action.sa_handler = SIG_IGN;
+  ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, old_signal_action));
+}
+
+// Tests that death tests work when SIGPROF handler and timer are set.
+TEST_F(TestForDeathTest, FastSigprofActionSet) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  SetSigprofActionAndTimer();
+  EXPECT_DEATH(_exit(1), "");
+  struct sigaction old_signal_action;
+  DisableSigprofActionAndTimer(&old_signal_action);
+  EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
+}
+
+TEST_F(TestForDeathTest, ThreadSafeSigprofActionSet) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  SetSigprofActionAndTimer();
+  EXPECT_DEATH(_exit(1), "");
+  struct sigaction old_signal_action;
+  DisableSigprofActionAndTimer(&old_signal_action);
+  EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
+}
+# endif  // GTEST_OS_LINUX
+
+// Repeats a representative sample of death tests in the "threadsafe" style:
+
+TEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");
+}
+
+TEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  should_die_ = true;
+  EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
+}
+
+TEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+
+  for (int i = 0; i < 3; ++i)
+    EXPECT_EXIT(_exit(i), testing::ExitedWithCode(i), "") << ": i = " << i;
+}
+
+TEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+
+  ChangeToRootDir();
+  EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
+
+  ChangeToRootDir();
+  ASSERT_DEATH(_exit(1), "");
+}
+
+TEST_F(TestForDeathTest, MixedStyles) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  EXPECT_DEATH(_exit(1), "");
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  EXPECT_DEATH(_exit(1), "");
+}
+
+# if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
+
+namespace {
+
+bool pthread_flag;
+
+void SetPthreadFlag() {
+  pthread_flag = true;
+}
+
+}  // namespace
+
+TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
+  if (!testing::GTEST_FLAG(death_test_use_fork)) {
+    testing::GTEST_FLAG(death_test_style) = "threadsafe";
+    pthread_flag = false;
+    ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, NULL, NULL));
+    ASSERT_DEATH(_exit(1), "");
+    ASSERT_FALSE(pthread_flag);
+  }
+}
+
+# endif  // GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
+
+// Tests that a method of another class can be used in a death test.
+TEST_F(TestForDeathTest, MethodOfAnotherClass) {
+  const MayDie x(true);
+  ASSERT_DEATH(x.MemberFunction(), "MayDie\\:\\:MemberFunction");
+}
+
+// Tests that a global function can be used in a death test.
+TEST_F(TestForDeathTest, GlobalFunction) {
+  EXPECT_DEATH(GlobalFunction(), "GlobalFunction");
+}
+
+// Tests that any value convertible to an RE works as a second
+// argument to EXPECT_DEATH.
+TEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) {
+  static const char regex_c_str[] = "GlobalFunction";
+  EXPECT_DEATH(GlobalFunction(), regex_c_str);
+
+  const testing::internal::RE regex(regex_c_str);
+  EXPECT_DEATH(GlobalFunction(), regex);
+
+# if GTEST_HAS_GLOBAL_STRING
+
+  const string regex_str(regex_c_str);
+  EXPECT_DEATH(GlobalFunction(), regex_str);
+
+# endif  // GTEST_HAS_GLOBAL_STRING
+
+# if !GTEST_USES_PCRE
+
+  const ::std::string regex_std_str(regex_c_str);
+  EXPECT_DEATH(GlobalFunction(), regex_std_str);
+
+# endif  // !GTEST_USES_PCRE
+}
+
+// Tests that a non-void function can be used in a death test.
+TEST_F(TestForDeathTest, NonVoidFunction) {
+  ASSERT_DEATH(NonVoidFunction(), "NonVoidFunction");
+}
+
+// Tests that functions that take parameter(s) can be used in a death test.
+TEST_F(TestForDeathTest, FunctionWithParameter) {
+  EXPECT_DEATH(DieIf(true), "DieIf\\(\\)");
+  EXPECT_DEATH(DieIfLessThan(2, 3), "DieIfLessThan");
+}
+
+// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.
+TEST_F(TestForDeathTest, OutsideFixture) {
+  DeathTestSubroutine();
+}
+
+// Tests that death tests can be done inside a loop.
+TEST_F(TestForDeathTest, InsideLoop) {
+  for (int i = 0; i < 5; i++) {
+    EXPECT_DEATH(DieIfLessThan(-1, i), "DieIfLessThan") << "where i == " << i;
+  }
+}
+
+// Tests that a compound statement can be used in a death test.
+TEST_F(TestForDeathTest, CompoundStatement) {
+  EXPECT_DEATH({  // NOLINT
+    const int x = 2;
+    const int y = x + 1;
+    DieIfLessThan(x, y);
+  },
+  "DieIfLessThan");
+}
+
+// Tests that code that doesn't die causes a death test to fail.
+TEST_F(TestForDeathTest, DoesNotDie) {
+  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(DieIf(false), "DieIf"),
+                          "failed to die");
+}
+
+// Tests that a death test fails when the error message isn't expected.
+TEST_F(TestForDeathTest, ErrorMessageMismatch) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_DEATH(DieIf(true), "DieIfLessThan") << "End of death test message.";
+  }, "died but not with expected error");
+}
+
+// On exit, *aborted will be true iff the EXPECT_DEATH() statement
+// aborted the function.
+void ExpectDeathTestHelper(bool* aborted) {
+  *aborted = true;
+  EXPECT_DEATH(DieIf(false), "DieIf");  // This assertion should fail.
+  *aborted = false;
+}
+
+// Tests that EXPECT_DEATH doesn't abort the test on failure.
+TEST_F(TestForDeathTest, EXPECT_DEATH) {
+  bool aborted = true;
+  EXPECT_NONFATAL_FAILURE(ExpectDeathTestHelper(&aborted),
+                          "failed to die");
+  EXPECT_FALSE(aborted);
+}
+
+// Tests that ASSERT_DEATH does abort the test on failure.
+TEST_F(TestForDeathTest, ASSERT_DEATH) {
+  static bool aborted;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    aborted = true;
+    ASSERT_DEATH(DieIf(false), "DieIf");  // This assertion should fail.
+    aborted = false;
+  }, "failed to die");
+  EXPECT_TRUE(aborted);
+}
+
+// Tests that EXPECT_DEATH evaluates the arguments exactly once.
+TEST_F(TestForDeathTest, SingleEvaluation) {
+  int x = 3;
+  EXPECT_DEATH(DieIf((++x) == 4), "DieIf");
+
+  const char* regex = "DieIf";
+  const char* regex_save = regex;
+  EXPECT_DEATH(DieIfLessThan(3, 4), regex++);
+  EXPECT_EQ(regex_save + 1, regex);
+}
+
+// Tests that run-away death tests are reported as failures.
+TEST_F(TestForDeathTest, RunawayIsFailure) {
+  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(static_cast<void>(0), "Foo"),
+                          "failed to die.");
+}
+
+// Tests that death tests report executing 'return' in the statement as
+// failure.
+TEST_F(TestForDeathTest, ReturnIsFailure) {
+  EXPECT_FATAL_FAILURE(ASSERT_DEATH(return, "Bar"),
+                       "illegal return in test statement.");
+}
+
+// Tests that EXPECT_DEBUG_DEATH works as expected, that is, you can stream a
+// message to it, and in debug mode it:
+// 1. Asserts on death.
+// 2. Has no side effect.
+//
+// And in opt mode, it:
+// 1.  Has side effects but does not assert.
+TEST_F(TestForDeathTest, TestExpectDebugDeath) {
+  int sideeffect = 0;
+
+  EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12")
+      << "Must accept a streamed message";
+
+# ifdef NDEBUG
+
+  // Checks that the assignment occurs in opt mode (sideeffect).
+  EXPECT_EQ(12, sideeffect);
+
+# else
+
+  // Checks that the assignment does not occur in dbg mode (no sideeffect).
+  EXPECT_EQ(0, sideeffect);
+
+# endif
+}
+
+// Tests that ASSERT_DEBUG_DEATH works as expected, that is, you can stream a
+// message to it, and in debug mode it:
+// 1. Asserts on death.
+// 2. Has no side effect.
+//
+// And in opt mode, it:
+// 1.  Has side effects but does not assert.
+TEST_F(TestForDeathTest, TestAssertDebugDeath) {
+  int sideeffect = 0;
+
+  ASSERT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12")
+      << "Must accept a streamed message";
+
+# ifdef NDEBUG
+
+  // Checks that the assignment occurs in opt mode (sideeffect).
+  EXPECT_EQ(12, sideeffect);
+
+# else
+
+  // Checks that the assignment does not occur in dbg mode (no sideeffect).
+  EXPECT_EQ(0, sideeffect);
+
+# endif
+}
+
+# ifndef NDEBUG
+
+void ExpectDebugDeathHelper(bool* aborted) {
+  *aborted = true;
+  EXPECT_DEBUG_DEATH(return, "") << "This is expected to fail.";
+  *aborted = false;
+}
+
+#  if GTEST_OS_WINDOWS
+TEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) {
+  printf("This test should be considered failing if it shows "
+         "any pop-up dialogs.\n");
+  fflush(stdout);
+
+  EXPECT_DEATH({
+    testing::GTEST_FLAG(catch_exceptions) = false;
+    abort();
+  }, "");
+}
+#  endif  // GTEST_OS_WINDOWS
+
+// Tests that EXPECT_DEBUG_DEATH in debug mode does not abort
+// the function.
+TEST_F(TestForDeathTest, ExpectDebugDeathDoesNotAbort) {
+  bool aborted = true;
+  EXPECT_NONFATAL_FAILURE(ExpectDebugDeathHelper(&aborted), "");
+  EXPECT_FALSE(aborted);
+}
+
+void AssertDebugDeathHelper(bool* aborted) {
+  *aborted = true;
+  GTEST_LOG_(INFO) << "Before ASSERT_DEBUG_DEATH";
+  ASSERT_DEBUG_DEATH(GTEST_LOG_(INFO) << "In ASSERT_DEBUG_DEATH"; return, "")
+      << "This is expected to fail.";
+  GTEST_LOG_(INFO) << "After ASSERT_DEBUG_DEATH";
+  *aborted = false;
+}
+
+// Tests that ASSERT_DEBUG_DEATH in debug mode aborts the function on
+// failure.
+TEST_F(TestForDeathTest, AssertDebugDeathAborts) {
+  static bool aborted;
+  aborted = false;
+  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
+  EXPECT_TRUE(aborted);
+}
+
+TEST_F(TestForDeathTest, AssertDebugDeathAborts2) {
+  static bool aborted;
+  aborted = false;
+  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
+  EXPECT_TRUE(aborted);
+}
+
+TEST_F(TestForDeathTest, AssertDebugDeathAborts3) {
+  static bool aborted;
+  aborted = false;
+  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
+  EXPECT_TRUE(aborted);
+}
+
+TEST_F(TestForDeathTest, AssertDebugDeathAborts4) {
+  static bool aborted;
+  aborted = false;
+  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
+  EXPECT_TRUE(aborted);
+}
+
+TEST_F(TestForDeathTest, AssertDebugDeathAborts5) {
+  static bool aborted;
+  aborted = false;
+  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
+  EXPECT_TRUE(aborted);
+}
+
+TEST_F(TestForDeathTest, AssertDebugDeathAborts6) {
+  static bool aborted;
+  aborted = false;
+  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
+  EXPECT_TRUE(aborted);
+}
+
+TEST_F(TestForDeathTest, AssertDebugDeathAborts7) {
+  static bool aborted;
+  aborted = false;
+  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
+  EXPECT_TRUE(aborted);
+}
+
+TEST_F(TestForDeathTest, AssertDebugDeathAborts8) {
+  static bool aborted;
+  aborted = false;
+  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
+  EXPECT_TRUE(aborted);
+}
+
+TEST_F(TestForDeathTest, AssertDebugDeathAborts9) {
+  static bool aborted;
+  aborted = false;
+  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
+  EXPECT_TRUE(aborted);
+}
+
+TEST_F(TestForDeathTest, AssertDebugDeathAborts10) {
+  static bool aborted;
+  aborted = false;
+  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
+  EXPECT_TRUE(aborted);
+}
+
+# endif  // _NDEBUG
+
+// Tests the *_EXIT family of macros, using a variety of predicates.
+static void TestExitMacros() {
+  EXPECT_EXIT(_exit(1),  testing::ExitedWithCode(1),  "");
+  ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), "");
+
+# if GTEST_OS_WINDOWS
+
+  // Of all signals effects on the process exit code, only those of SIGABRT
+  // are documented on Windows.
+  // See http://msdn.microsoft.com/en-us/library/dwwzkt4c(VS.71).aspx.
+  EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "") << "b_ar";
+
+# else
+
+  EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo";
+  ASSERT_EXIT(raise(SIGUSR2), testing::KilledBySignal(SIGUSR2), "") << "bar";
+
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "")
+      << "This failure is expected, too.";
+  }, "This failure is expected, too.");
+
+# endif  // GTEST_OS_WINDOWS
+
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "")
+      << "This failure is expected.";
+  }, "This failure is expected.");
+}
+
+TEST_F(TestForDeathTest, ExitMacros) {
+  TestExitMacros();
+}
+
+TEST_F(TestForDeathTest, ExitMacrosUsingFork) {
+  testing::GTEST_FLAG(death_test_use_fork) = true;
+  TestExitMacros();
+}
+
+TEST_F(TestForDeathTest, InvalidStyle) {
+  testing::GTEST_FLAG(death_test_style) = "rococo";
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_DEATH(_exit(0), "") << "This failure is expected.";
+  }, "This failure is expected.");
+}
+
+TEST_F(TestForDeathTest, DeathTestFailedOutput) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_DEATH(DieWithMessage("death\n"),
+                   "expected message"),
+      "Actual msg:\n"
+      "[  DEATH   ] death\n");
+}
+
+TEST_F(TestForDeathTest, DeathTestUnexpectedReturnOutput) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_DEATH({
+          fprintf(stderr, "returning\n");
+          fflush(stderr);
+          return;
+        }, ""),
+      "    Result: illegal return in test statement.\n"
+      " Error msg:\n"
+      "[  DEATH   ] returning\n");
+}
+
+TEST_F(TestForDeathTest, DeathTestBadExitCodeOutput) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_EXIT(DieWithMessage("exiting with rc 1\n"),
+                  testing::ExitedWithCode(3),
+                  "expected message"),
+      "    Result: died but not with expected exit code:\n"
+      "            Exited with exit status 1\n"
+      "Actual msg:\n"
+      "[  DEATH   ] exiting with rc 1\n");
+}
+
+TEST_F(TestForDeathTest, DeathTestMultiLineMatchFail) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"),
+                   "line 1\nxyz\nline 3\n"),
+      "Actual msg:\n"
+      "[  DEATH   ] line 1\n"
+      "[  DEATH   ] line 2\n"
+      "[  DEATH   ] line 3\n");
+}
+
+TEST_F(TestForDeathTest, DeathTestMultiLineMatchPass) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"),
+               "line 1\nline 2\nline 3\n");
+}
+
+// A DeathTestFactory that returns MockDeathTests.
+class MockDeathTestFactory : public DeathTestFactory {
+ public:
+  MockDeathTestFactory();
+  virtual bool Create(const char* statement,
+                      const ::testing::internal::RE* regex,
+                      const char* file, int line, DeathTest** test);
+
+  // Sets the parameters for subsequent calls to Create.
+  void SetParameters(bool create, DeathTest::TestRole role,
+                     int status, bool passed);
+
+  // Accessors.
+  int AssumeRoleCalls() const { return assume_role_calls_; }
+  int WaitCalls() const { return wait_calls_; }
+  size_t PassedCalls() const { return passed_args_.size(); }
+  bool PassedArgument(int n) const { return passed_args_[n]; }
+  size_t AbortCalls() const { return abort_args_.size(); }
+  DeathTest::AbortReason AbortArgument(int n) const {
+    return abort_args_[n];
+  }
+  bool TestDeleted() const { return test_deleted_; }
+
+ private:
+  friend class MockDeathTest;
+  // If true, Create will return a MockDeathTest; otherwise it returns
+  // NULL.
+  bool create_;
+  // The value a MockDeathTest will return from its AssumeRole method.
+  DeathTest::TestRole role_;
+  // The value a MockDeathTest will return from its Wait method.
+  int status_;
+  // The value a MockDeathTest will return from its Passed method.
+  bool passed_;
+
+  // Number of times AssumeRole was called.
+  int assume_role_calls_;
+  // Number of times Wait was called.
+  int wait_calls_;
+  // The arguments to the calls to Passed since the last call to
+  // SetParameters.
+  std::vector<bool> passed_args_;
+  // The arguments to the calls to Abort since the last call to
+  // SetParameters.
+  std::vector<DeathTest::AbortReason> abort_args_;
+  // True if the last MockDeathTest returned by Create has been
+  // deleted.
+  bool test_deleted_;
+};
+
+
+// A DeathTest implementation useful in testing.  It returns values set
+// at its creation from its various inherited DeathTest methods, and
+// reports calls to those methods to its parent MockDeathTestFactory
+// object.
+class MockDeathTest : public DeathTest {
+ public:
+  MockDeathTest(MockDeathTestFactory *parent,
+                TestRole role, int status, bool passed) :
+      parent_(parent), role_(role), status_(status), passed_(passed) {
+  }
+  virtual ~MockDeathTest() {
+    parent_->test_deleted_ = true;
+  }
+  virtual TestRole AssumeRole() {
+    ++parent_->assume_role_calls_;
+    return role_;
+  }
+  virtual int Wait() {
+    ++parent_->wait_calls_;
+    return status_;
+  }
+  virtual bool Passed(bool exit_status_ok) {
+    parent_->passed_args_.push_back(exit_status_ok);
+    return passed_;
+  }
+  virtual void Abort(AbortReason reason) {
+    parent_->abort_args_.push_back(reason);
+  }
+
+ private:
+  MockDeathTestFactory* const parent_;
+  const TestRole role_;
+  const int status_;
+  const bool passed_;
+};
+
+
+// MockDeathTestFactory constructor.
+MockDeathTestFactory::MockDeathTestFactory()
+    : create_(true),
+      role_(DeathTest::OVERSEE_TEST),
+      status_(0),
+      passed_(true),
+      assume_role_calls_(0),
+      wait_calls_(0),
+      passed_args_(),
+      abort_args_() {
+}
+
+
+// Sets the parameters for subsequent calls to Create.
+void MockDeathTestFactory::SetParameters(bool create,
+                                         DeathTest::TestRole role,
+                                         int status, bool passed) {
+  create_ = create;
+  role_ = role;
+  status_ = status;
+  passed_ = passed;
+
+  assume_role_calls_ = 0;
+  wait_calls_ = 0;
+  passed_args_.clear();
+  abort_args_.clear();
+}
+
+
+// Sets test to NULL (if create_ is false) or to the address of a new
+// MockDeathTest object with parameters taken from the last call
+// to SetParameters (if create_ is true).  Always returns true.
+bool MockDeathTestFactory::Create(const char* /*statement*/,
+                                  const ::testing::internal::RE* /*regex*/,
+                                  const char* /*file*/,
+                                  int /*line*/,
+                                  DeathTest** test) {
+  test_deleted_ = false;
+  if (create_) {
+    *test = new MockDeathTest(this, role_, status_, passed_);
+  } else {
+    *test = NULL;
+  }
+  return true;
+}
+
+// A test fixture for testing the logic of the GTEST_DEATH_TEST_ macro.
+// It installs a MockDeathTestFactory that is used for the duration
+// of the test case.
+class MacroLogicDeathTest : public testing::Test {
+ protected:
+  static testing::internal::ReplaceDeathTestFactory* replacer_;
+  static MockDeathTestFactory* factory_;
+
+  static void SetUpTestCase() {
+    factory_ = new MockDeathTestFactory;
+    replacer_ = new testing::internal::ReplaceDeathTestFactory(factory_);
+  }
+
+  static void TearDownTestCase() {
+    delete replacer_;
+    replacer_ = NULL;
+    delete factory_;
+    factory_ = NULL;
+  }
+
+  // Runs a death test that breaks the rules by returning.  Such a death
+  // test cannot be run directly from a test routine that uses a
+  // MockDeathTest, or the remainder of the routine will not be executed.
+  static void RunReturningDeathTest(bool* flag) {
+    ASSERT_DEATH({  // NOLINT
+      *flag = true;
+      return;
+    }, "");
+  }
+};
+
+testing::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_
+    = NULL;
+MockDeathTestFactory* MacroLogicDeathTest::factory_ = NULL;
+
+
+// Test that nothing happens when the factory doesn't return a DeathTest:
+TEST_F(MacroLogicDeathTest, NothingHappens) {
+  bool flag = false;
+  factory_->SetParameters(false, DeathTest::OVERSEE_TEST, 0, true);
+  EXPECT_DEATH(flag = true, "");
+  EXPECT_FALSE(flag);
+  EXPECT_EQ(0, factory_->AssumeRoleCalls());
+  EXPECT_EQ(0, factory_->WaitCalls());
+  EXPECT_EQ(0U, factory_->PassedCalls());
+  EXPECT_EQ(0U, factory_->AbortCalls());
+  EXPECT_FALSE(factory_->TestDeleted());
+}
+
+// Test that the parent process doesn't run the death test code,
+// and that the Passed method returns false when the (simulated)
+// child process exits with status 0:
+TEST_F(MacroLogicDeathTest, ChildExitsSuccessfully) {
+  bool flag = false;
+  factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 0, true);
+  EXPECT_DEATH(flag = true, "");
+  EXPECT_FALSE(flag);
+  EXPECT_EQ(1, factory_->AssumeRoleCalls());
+  EXPECT_EQ(1, factory_->WaitCalls());
+  ASSERT_EQ(1U, factory_->PassedCalls());
+  EXPECT_FALSE(factory_->PassedArgument(0));
+  EXPECT_EQ(0U, factory_->AbortCalls());
+  EXPECT_TRUE(factory_->TestDeleted());
+}
+
+// Tests that the Passed method was given the argument "true" when
+// the (simulated) child process exits with status 1:
+TEST_F(MacroLogicDeathTest, ChildExitsUnsuccessfully) {
+  bool flag = false;
+  factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 1, true);
+  EXPECT_DEATH(flag = true, "");
+  EXPECT_FALSE(flag);
+  EXPECT_EQ(1, factory_->AssumeRoleCalls());
+  EXPECT_EQ(1, factory_->WaitCalls());
+  ASSERT_EQ(1U, factory_->PassedCalls());
+  EXPECT_TRUE(factory_->PassedArgument(0));
+  EXPECT_EQ(0U, factory_->AbortCalls());
+  EXPECT_TRUE(factory_->TestDeleted());
+}
+
+// Tests that the (simulated) child process executes the death test
+// code, and is aborted with the correct AbortReason if it
+// executes a return statement.
+TEST_F(MacroLogicDeathTest, ChildPerformsReturn) {
+  bool flag = false;
+  factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true);
+  RunReturningDeathTest(&flag);
+  EXPECT_TRUE(flag);
+  EXPECT_EQ(1, factory_->AssumeRoleCalls());
+  EXPECT_EQ(0, factory_->WaitCalls());
+  EXPECT_EQ(0U, factory_->PassedCalls());
+  EXPECT_EQ(1U, factory_->AbortCalls());
+  EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
+            factory_->AbortArgument(0));
+  EXPECT_TRUE(factory_->TestDeleted());
+}
+
+// Tests that the (simulated) child process is aborted with the
+// correct AbortReason if it does not die.
+TEST_F(MacroLogicDeathTest, ChildDoesNotDie) {
+  bool flag = false;
+  factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true);
+  EXPECT_DEATH(flag = true, "");
+  EXPECT_TRUE(flag);
+  EXPECT_EQ(1, factory_->AssumeRoleCalls());
+  EXPECT_EQ(0, factory_->WaitCalls());
+  EXPECT_EQ(0U, factory_->PassedCalls());
+  // This time there are two calls to Abort: one since the test didn't
+  // die, and another from the ReturnSentinel when it's destroyed.  The
+  // sentinel normally isn't destroyed if a test doesn't die, since
+  // _exit(2) is called in that case by ForkingDeathTest, but not by
+  // our MockDeathTest.
+  ASSERT_EQ(2U, factory_->AbortCalls());
+  EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE,
+            factory_->AbortArgument(0));
+  EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
+            factory_->AbortArgument(1));
+  EXPECT_TRUE(factory_->TestDeleted());
+}
+
+// Tests that a successful death test does not register a successful
+// test part.
+TEST(SuccessRegistrationDeathTest, NoSuccessPart) {
+  EXPECT_DEATH(_exit(1), "");
+  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
+}
+
+TEST(StreamingAssertionsDeathTest, DeathTest) {
+  EXPECT_DEATH(_exit(1), "") << "unexpected failure";
+  ASSERT_DEATH(_exit(1), "") << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_DEATH(_exit(0), "") << "expected failure";
+  }, "expected failure");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_DEATH(_exit(0), "") << "expected failure";
+  }, "expected failure");
+}
+
+// Tests that GetLastErrnoDescription returns an empty string when the
+// last error is 0 and non-empty string when it is non-zero.
+TEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) {
+  errno = ENOENT;
+  EXPECT_STRNE("", GetLastErrnoDescription().c_str());
+  errno = 0;
+  EXPECT_STREQ("", GetLastErrnoDescription().c_str());
+}
+
+# if GTEST_OS_WINDOWS
+TEST(AutoHandleTest, AutoHandleWorks) {
+  HANDLE handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
+  ASSERT_NE(INVALID_HANDLE_VALUE, handle);
+
+  // Tests that the AutoHandle is correctly initialized with a handle.
+  testing::internal::AutoHandle auto_handle(handle);
+  EXPECT_EQ(handle, auto_handle.Get());
+
+  // Tests that Reset assigns INVALID_HANDLE_VALUE.
+  // Note that this cannot verify whether the original handle is closed.
+  auto_handle.Reset();
+  EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle.Get());
+
+  // Tests that Reset assigns the new handle.
+  // Note that this cannot verify whether the original handle is closed.
+  handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
+  ASSERT_NE(INVALID_HANDLE_VALUE, handle);
+  auto_handle.Reset(handle);
+  EXPECT_EQ(handle, auto_handle.Get());
+
+  // Tests that AutoHandle contains INVALID_HANDLE_VALUE by default.
+  testing::internal::AutoHandle auto_handle2;
+  EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle2.Get());
+}
+# endif  // GTEST_OS_WINDOWS
+
+# if GTEST_OS_WINDOWS
+typedef unsigned __int64 BiggestParsable;
+typedef signed __int64 BiggestSignedParsable;
+# else
+typedef unsigned long long BiggestParsable;
+typedef signed long long BiggestSignedParsable;
+# endif  // GTEST_OS_WINDOWS
+
+// We cannot use std::numeric_limits<T>::max() as it clashes with the
+// max() macro defined by <windows.h>.
+const BiggestParsable kBiggestParsableMax = ULLONG_MAX;
+const BiggestSignedParsable kBiggestSignedParsableMax = LLONG_MAX;
+
+TEST(ParseNaturalNumberTest, RejectsInvalidFormat) {
+  BiggestParsable result = 0;
+
+  // Rejects non-numbers.
+  EXPECT_FALSE(ParseNaturalNumber("non-number string", &result));
+
+  // Rejects numbers with whitespace prefix.
+  EXPECT_FALSE(ParseNaturalNumber(" 123", &result));
+
+  // Rejects negative numbers.
+  EXPECT_FALSE(ParseNaturalNumber("-123", &result));
+
+  // Rejects numbers starting with a plus sign.
+  EXPECT_FALSE(ParseNaturalNumber("+123", &result));
+  errno = 0;
+}
+
+TEST(ParseNaturalNumberTest, RejectsOverflownNumbers) {
+  BiggestParsable result = 0;
+
+  EXPECT_FALSE(ParseNaturalNumber("99999999999999999999999", &result));
+
+  signed char char_result = 0;
+  EXPECT_FALSE(ParseNaturalNumber("200", &char_result));
+  errno = 0;
+}
+
+TEST(ParseNaturalNumberTest, AcceptsValidNumbers) {
+  BiggestParsable result = 0;
+
+  result = 0;
+  ASSERT_TRUE(ParseNaturalNumber("123", &result));
+  EXPECT_EQ(123U, result);
+
+  // Check 0 as an edge case.
+  result = 1;
+  ASSERT_TRUE(ParseNaturalNumber("0", &result));
+  EXPECT_EQ(0U, result);
+
+  result = 1;
+  ASSERT_TRUE(ParseNaturalNumber("00000", &result));
+  EXPECT_EQ(0U, result);
+}
+
+TEST(ParseNaturalNumberTest, AcceptsTypeLimits) {
+  Message msg;
+  msg << kBiggestParsableMax;
+
+  BiggestParsable result = 0;
+  EXPECT_TRUE(ParseNaturalNumber(msg.GetString(), &result));
+  EXPECT_EQ(kBiggestParsableMax, result);
+
+  Message msg2;
+  msg2 << kBiggestSignedParsableMax;
+
+  BiggestSignedParsable signed_result = 0;
+  EXPECT_TRUE(ParseNaturalNumber(msg2.GetString(), &signed_result));
+  EXPECT_EQ(kBiggestSignedParsableMax, signed_result);
+
+  Message msg3;
+  msg3 << INT_MAX;
+
+  int int_result = 0;
+  EXPECT_TRUE(ParseNaturalNumber(msg3.GetString(), &int_result));
+  EXPECT_EQ(INT_MAX, int_result);
+
+  Message msg4;
+  msg4 << UINT_MAX;
+
+  unsigned int uint_result = 0;
+  EXPECT_TRUE(ParseNaturalNumber(msg4.GetString(), &uint_result));
+  EXPECT_EQ(UINT_MAX, uint_result);
+}
+
+TEST(ParseNaturalNumberTest, WorksForShorterIntegers) {
+  short short_result = 0;
+  ASSERT_TRUE(ParseNaturalNumber("123", &short_result));
+  EXPECT_EQ(123, short_result);
+
+  signed char char_result = 0;
+  ASSERT_TRUE(ParseNaturalNumber("123", &char_result));
+  EXPECT_EQ(123, char_result);
+}
+
+# if GTEST_OS_WINDOWS
+TEST(EnvironmentTest, HandleFitsIntoSizeT) {
+  // TODO(vladl@google.com): Remove this test after this condition is verified
+  // in a static assertion in gtest-death-test.cc in the function
+  // GetStatusFileDescriptor.
+  ASSERT_TRUE(sizeof(HANDLE) <= sizeof(size_t));
+}
+# endif  // GTEST_OS_WINDOWS
+
+// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED trigger
+// failures when death tests are available on the system.
+TEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) {
+  EXPECT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestExpectMacro"),
+                            "death inside CondDeathTestExpectMacro");
+  ASSERT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestAssertMacro"),
+                            "death inside CondDeathTestAssertMacro");
+
+  // Empty statement will not crash, which must trigger a failure.
+  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH_IF_SUPPORTED(;, ""), "");
+  EXPECT_FATAL_FAILURE(ASSERT_DEATH_IF_SUPPORTED(;, ""), "");
+}
+
+TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInFastStyle) {
+  testing::GTEST_FLAG(death_test_style) = "fast";
+  EXPECT_FALSE(InDeathTestChild());
+  EXPECT_DEATH({
+    fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
+    fflush(stderr);
+    _exit(1);
+  }, "Inside");
+}
+
+TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeStyle) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  EXPECT_FALSE(InDeathTestChild());
+  EXPECT_DEATH({
+    fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
+    fflush(stderr);
+    _exit(1);
+  }, "Inside");
+}
+
+#else  // !GTEST_HAS_DEATH_TEST follows
+
+using testing::internal::CaptureStderr;
+using testing::internal::GetCapturedStderr;
+
+// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED are still
+// defined but do not trigger failures when death tests are not available on
+// the system.
+TEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) {
+  // Empty statement will not crash, but that should not trigger a failure
+  // when death tests are not supported.
+  CaptureStderr();
+  EXPECT_DEATH_IF_SUPPORTED(;, "");
+  std::string output = GetCapturedStderr();
+  ASSERT_TRUE(NULL != strstr(output.c_str(),
+                             "Death tests are not supported on this platform"));
+  ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));
+
+  // The streamed message should not be printed as there is no test failure.
+  CaptureStderr();
+  EXPECT_DEATH_IF_SUPPORTED(;, "") << "streamed message";
+  output = GetCapturedStderr();
+  ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message"));
+
+  CaptureStderr();
+  ASSERT_DEATH_IF_SUPPORTED(;, "");  // NOLINT
+  output = GetCapturedStderr();
+  ASSERT_TRUE(NULL != strstr(output.c_str(),
+                             "Death tests are not supported on this platform"));
+  ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));
+
+  CaptureStderr();
+  ASSERT_DEATH_IF_SUPPORTED(;, "") << "streamed message";  // NOLINT
+  output = GetCapturedStderr();
+  ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message"));
+}
+
+void FuncWithAssert(int* n) {
+  ASSERT_DEATH_IF_SUPPORTED(return;, "");
+  (*n)++;
+}
+
+// Tests that ASSERT_DEATH_IF_SUPPORTED does not return from the current
+// function (as ASSERT_DEATH does) if death tests are not supported.
+TEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) {
+  int n = 0;
+  FuncWithAssert(&n);
+  EXPECT_EQ(1, n);
+}
+
+#endif  // !GTEST_HAS_DEATH_TEST
+
+// Tests that the death test macros expand to code which may or may not
+// be followed by operator<<, and that in either case the complete text
+// comprises only a single C++ statement.
+//
+// The syntax should work whether death tests are available or not.
+TEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) {
+  if (AlwaysFalse())
+    // This would fail if executed; this is a compilation test only
+    ASSERT_DEATH_IF_SUPPORTED(return, "");
+
+  if (AlwaysTrue())
+    EXPECT_DEATH_IF_SUPPORTED(_exit(1), "");
+  else
+    // This empty "else" branch is meant to ensure that EXPECT_DEATH
+    // doesn't expand into an "if" statement without an "else"
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    ASSERT_DEATH_IF_SUPPORTED(return, "") << "did not die";
+
+  if (AlwaysFalse())
+    ;  // NOLINT
+  else
+    EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << 1 << 2 << 3;
+}
+
+// Tests that conditional death test macros expand to code which interacts
+// well with switch statements.
+TEST(ConditionalDeathMacrosSyntaxDeathTest, SwitchStatement) {
+  // Microsoft compiler usually complains about switch statements without
+  // case labels. We suppress that warning for this test.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4065)
+
+  switch (0)
+    default:
+      ASSERT_DEATH_IF_SUPPORTED(_exit(1), "")
+          << "exit in default switch handler";
+
+  switch (0)
+    case 0:
+      EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case";
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+}
+
+// Tests that a test case whose name ends with "DeathTest" works fine
+// on Windows.
+TEST(NotADeathTest, Test) {
+  SUCCEED();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-filepath_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-filepath_test.cc
new file mode 100644
index 00000000..da729869
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-filepath_test.cc
@@ -0,0 +1,662 @@
+// 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.
+//
+// Authors: keith.ray@gmail.com (Keith Ray)
+//
+// Google Test filepath utilities
+//
+// This file tests classes and functions used internally by
+// Google Test.  They are subject to change without notice.
+//
+// This file is #included from gtest_unittest.cc, to avoid changing
+// build or make-files for some existing Google Test clients. Do not
+// #include this file anywhere else!
+
+#include "gtest/internal/gtest-filepath.h"
+#include "gtest/gtest.h"
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+#if GTEST_OS_WINDOWS_MOBILE
+# include <windows.h>  // NOLINT
+#elif GTEST_OS_WINDOWS
+# include <direct.h>  // NOLINT
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+namespace testing {
+namespace internal {
+namespace {
+
+#if GTEST_OS_WINDOWS_MOBILE
+// TODO(wan@google.com): Move these to the POSIX adapter section in
+// gtest-port.h.
+
+// Windows CE doesn't have the remove C function.
+int remove(const char* path) {
+  LPCWSTR wpath = String::AnsiToUtf16(path);
+  int ret = DeleteFile(wpath) ? 0 : -1;
+  delete [] wpath;
+  return ret;
+}
+// Windows CE doesn't have the _rmdir C function.
+int _rmdir(const char* path) {
+  FilePath filepath(path);
+  LPCWSTR wpath = String::AnsiToUtf16(
+      filepath.RemoveTrailingPathSeparator().c_str());
+  int ret = RemoveDirectory(wpath) ? 0 : -1;
+  delete [] wpath;
+  return ret;
+}
+
+#else
+
+TEST(GetCurrentDirTest, ReturnsCurrentDir) {
+  const FilePath original_dir = FilePath::GetCurrentDir();
+  EXPECT_FALSE(original_dir.IsEmpty());
+
+  posix::ChDir(GTEST_PATH_SEP_);
+  const FilePath cwd = FilePath::GetCurrentDir();
+  posix::ChDir(original_dir.c_str());
+
+# if GTEST_OS_WINDOWS
+
+  // Skips the ":".
+  const char* const cwd_without_drive = strchr(cwd.c_str(), ':');
+  ASSERT_TRUE(cwd_without_drive != NULL);
+  EXPECT_STREQ(GTEST_PATH_SEP_, cwd_without_drive + 1);
+
+# else
+
+  EXPECT_EQ(GTEST_PATH_SEP_, cwd.string());
+
+# endif
+}
+
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+TEST(IsEmptyTest, ReturnsTrueForEmptyPath) {
+  EXPECT_TRUE(FilePath("").IsEmpty());
+}
+
+TEST(IsEmptyTest, ReturnsFalseForNonEmptyPath) {
+  EXPECT_FALSE(FilePath("a").IsEmpty());
+  EXPECT_FALSE(FilePath(".").IsEmpty());
+  EXPECT_FALSE(FilePath("a/b").IsEmpty());
+  EXPECT_FALSE(FilePath("a\\b\\").IsEmpty());
+}
+
+// RemoveDirectoryName "" -> ""
+TEST(RemoveDirectoryNameTest, WhenEmptyName) {
+  EXPECT_EQ("", FilePath("").RemoveDirectoryName().string());
+}
+
+// RemoveDirectoryName "afile" -> "afile"
+TEST(RemoveDirectoryNameTest, ButNoDirectory) {
+  EXPECT_EQ("afile",
+      FilePath("afile").RemoveDirectoryName().string());
+}
+
+// RemoveDirectoryName "/afile" -> "afile"
+TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileName) {
+  EXPECT_EQ("afile",
+      FilePath(GTEST_PATH_SEP_ "afile").RemoveDirectoryName().string());
+}
+
+// RemoveDirectoryName "adir/" -> ""
+TEST(RemoveDirectoryNameTest, WhereThereIsNoFileName) {
+  EXPECT_EQ("",
+      FilePath("adir" GTEST_PATH_SEP_).RemoveDirectoryName().string());
+}
+
+// RemoveDirectoryName "adir/afile" -> "afile"
+TEST(RemoveDirectoryNameTest, ShouldGiveFileName) {
+  EXPECT_EQ("afile",
+      FilePath("adir" GTEST_PATH_SEP_ "afile").RemoveDirectoryName().string());
+}
+
+// RemoveDirectoryName "adir/subdir/afile" -> "afile"
+TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileName) {
+  EXPECT_EQ("afile",
+      FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
+      .RemoveDirectoryName().string());
+}
+
+#if GTEST_HAS_ALT_PATH_SEP_
+
+// Tests that RemoveDirectoryName() works with the alternate separator
+// on Windows.
+
+// RemoveDirectoryName("/afile") -> "afile"
+TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileNameForAlternateSeparator) {
+  EXPECT_EQ("afile", FilePath("/afile").RemoveDirectoryName().string());
+}
+
+// RemoveDirectoryName("adir/") -> ""
+TEST(RemoveDirectoryNameTest, WhereThereIsNoFileNameForAlternateSeparator) {
+  EXPECT_EQ("", FilePath("adir/").RemoveDirectoryName().string());
+}
+
+// RemoveDirectoryName("adir/afile") -> "afile"
+TEST(RemoveDirectoryNameTest, ShouldGiveFileNameForAlternateSeparator) {
+  EXPECT_EQ("afile", FilePath("adir/afile").RemoveDirectoryName().string());
+}
+
+// RemoveDirectoryName("adir/subdir/afile") -> "afile"
+TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileNameForAlternateSeparator) {
+  EXPECT_EQ("afile",
+            FilePath("adir/subdir/afile").RemoveDirectoryName().string());
+}
+
+#endif
+
+// RemoveFileName "" -> "./"
+TEST(RemoveFileNameTest, EmptyName) {
+#if GTEST_OS_WINDOWS_MOBILE
+  // On Windows CE, we use the root as the current directory.
+  EXPECT_EQ(GTEST_PATH_SEP_, FilePath("").RemoveFileName().string());
+#else
+  EXPECT_EQ("." GTEST_PATH_SEP_, FilePath("").RemoveFileName().string());
+#endif
+}
+
+// RemoveFileName "adir/" -> "adir/"
+TEST(RemoveFileNameTest, ButNoFile) {
+  EXPECT_EQ("adir" GTEST_PATH_SEP_,
+      FilePath("adir" GTEST_PATH_SEP_).RemoveFileName().string());
+}
+
+// RemoveFileName "adir/afile" -> "adir/"
+TEST(RemoveFileNameTest, GivesDirName) {
+  EXPECT_EQ("adir" GTEST_PATH_SEP_,
+            FilePath("adir" GTEST_PATH_SEP_ "afile").RemoveFileName().string());
+}
+
+// RemoveFileName "adir/subdir/afile" -> "adir/subdir/"
+TEST(RemoveFileNameTest, GivesDirAndSubDirName) {
+  EXPECT_EQ("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_,
+      FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
+      .RemoveFileName().string());
+}
+
+// RemoveFileName "/afile" -> "/"
+TEST(RemoveFileNameTest, GivesRootDir) {
+  EXPECT_EQ(GTEST_PATH_SEP_,
+      FilePath(GTEST_PATH_SEP_ "afile").RemoveFileName().string());
+}
+
+#if GTEST_HAS_ALT_PATH_SEP_
+
+// Tests that RemoveFileName() works with the alternate separator on
+// Windows.
+
+// RemoveFileName("adir/") -> "adir/"
+TEST(RemoveFileNameTest, ButNoFileForAlternateSeparator) {
+  EXPECT_EQ("adir" GTEST_PATH_SEP_,
+            FilePath("adir/").RemoveFileName().string());
+}
+
+// RemoveFileName("adir/afile") -> "adir/"
+TEST(RemoveFileNameTest, GivesDirNameForAlternateSeparator) {
+  EXPECT_EQ("adir" GTEST_PATH_SEP_,
+            FilePath("adir/afile").RemoveFileName().string());
+}
+
+// RemoveFileName("adir/subdir/afile") -> "adir/subdir/"
+TEST(RemoveFileNameTest, GivesDirAndSubDirNameForAlternateSeparator) {
+  EXPECT_EQ("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_,
+            FilePath("adir/subdir/afile").RemoveFileName().string());
+}
+
+// RemoveFileName("/afile") -> "\"
+TEST(RemoveFileNameTest, GivesRootDirForAlternateSeparator) {
+  EXPECT_EQ(GTEST_PATH_SEP_, FilePath("/afile").RemoveFileName().string());
+}
+
+#endif
+
+TEST(MakeFileNameTest, GenerateWhenNumberIsZero) {
+  FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
+      0, "xml");
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
+}
+
+TEST(MakeFileNameTest, GenerateFileNameNumberGtZero) {
+  FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
+      12, "xml");
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.string());
+}
+
+TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberIsZero) {
+  FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
+      FilePath("bar"), 0, "xml");
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
+}
+
+TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberGtZero) {
+  FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
+      FilePath("bar"), 12, "xml");
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.string());
+}
+
+TEST(MakeFileNameTest, GenerateWhenNumberIsZeroAndDirIsEmpty) {
+  FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),
+      0, "xml");
+  EXPECT_EQ("bar.xml", actual.string());
+}
+
+TEST(MakeFileNameTest, GenerateWhenNumberIsNotZeroAndDirIsEmpty) {
+  FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),
+      14, "xml");
+  EXPECT_EQ("bar_14.xml", actual.string());
+}
+
+TEST(ConcatPathsTest, WorksWhenDirDoesNotEndWithPathSep) {
+  FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
+                                          FilePath("bar.xml"));
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
+}
+
+TEST(ConcatPathsTest, WorksWhenPath1EndsWithPathSep) {
+  FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_),
+                                          FilePath("bar.xml"));
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
+}
+
+TEST(ConcatPathsTest, Path1BeingEmpty) {
+  FilePath actual = FilePath::ConcatPaths(FilePath(""),
+                                          FilePath("bar.xml"));
+  EXPECT_EQ("bar.xml", actual.string());
+}
+
+TEST(ConcatPathsTest, Path2BeingEmpty) {
+  FilePath actual = FilePath::ConcatPaths(FilePath("foo"), FilePath(""));
+  EXPECT_EQ("foo" GTEST_PATH_SEP_, actual.string());
+}
+
+TEST(ConcatPathsTest, BothPathBeingEmpty) {
+  FilePath actual = FilePath::ConcatPaths(FilePath(""),
+                                          FilePath(""));
+  EXPECT_EQ("", actual.string());
+}
+
+TEST(ConcatPathsTest, Path1ContainsPathSep) {
+  FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_ "bar"),
+                                          FilePath("foobar.xml"));
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "foobar.xml",
+            actual.string());
+}
+
+TEST(ConcatPathsTest, Path2ContainsPathSep) {
+  FilePath actual = FilePath::ConcatPaths(
+      FilePath("foo" GTEST_PATH_SEP_),
+      FilePath("bar" GTEST_PATH_SEP_ "bar.xml"));
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "bar.xml",
+            actual.string());
+}
+
+TEST(ConcatPathsTest, Path2EndsWithPathSep) {
+  FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
+                                          FilePath("bar" GTEST_PATH_SEP_));
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_, actual.string());
+}
+
+// RemoveTrailingPathSeparator "" -> ""
+TEST(RemoveTrailingPathSeparatorTest, EmptyString) {
+  EXPECT_EQ("", FilePath("").RemoveTrailingPathSeparator().string());
+}
+
+// RemoveTrailingPathSeparator "foo" -> "foo"
+TEST(RemoveTrailingPathSeparatorTest, FileNoSlashString) {
+  EXPECT_EQ("foo", FilePath("foo").RemoveTrailingPathSeparator().string());
+}
+
+// RemoveTrailingPathSeparator "foo/" -> "foo"
+TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveTrailingSeparator) {
+  EXPECT_EQ("foo",
+      FilePath("foo" GTEST_PATH_SEP_).RemoveTrailingPathSeparator().string());
+#if GTEST_HAS_ALT_PATH_SEP_
+  EXPECT_EQ("foo", FilePath("foo/").RemoveTrailingPathSeparator().string());
+#endif
+}
+
+// RemoveTrailingPathSeparator "foo/bar/" -> "foo/bar/"
+TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveLastSeparator) {
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
+            FilePath("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_)
+                .RemoveTrailingPathSeparator().string());
+}
+
+// RemoveTrailingPathSeparator "foo/bar" -> "foo/bar"
+TEST(RemoveTrailingPathSeparatorTest, ShouldReturnUnmodified) {
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
+            FilePath("foo" GTEST_PATH_SEP_ "bar")
+                .RemoveTrailingPathSeparator().string());
+}
+
+TEST(DirectoryTest, RootDirectoryExists) {
+#if GTEST_OS_WINDOWS  // We are on Windows.
+  char current_drive[_MAX_PATH];  // NOLINT
+  current_drive[0] = static_cast<char>(_getdrive() + 'A' - 1);
+  current_drive[1] = ':';
+  current_drive[2] = '\\';
+  current_drive[3] = '\0';
+  EXPECT_TRUE(FilePath(current_drive).DirectoryExists());
+#else
+  EXPECT_TRUE(FilePath("/").DirectoryExists());
+#endif  // GTEST_OS_WINDOWS
+}
+
+#if GTEST_OS_WINDOWS
+TEST(DirectoryTest, RootOfWrongDriveDoesNotExists) {
+  const int saved_drive_ = _getdrive();
+  // Find a drive that doesn't exist. Start with 'Z' to avoid common ones.
+  for (char drive = 'Z'; drive >= 'A'; drive--)
+    if (_chdrive(drive - 'A' + 1) == -1) {
+      char non_drive[_MAX_PATH];  // NOLINT
+      non_drive[0] = drive;
+      non_drive[1] = ':';
+      non_drive[2] = '\\';
+      non_drive[3] = '\0';
+      EXPECT_FALSE(FilePath(non_drive).DirectoryExists());
+      break;
+    }
+  _chdrive(saved_drive_);
+}
+#endif  // GTEST_OS_WINDOWS
+
+#if !GTEST_OS_WINDOWS_MOBILE
+// Windows CE _does_ consider an empty directory to exist.
+TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) {
+  EXPECT_FALSE(FilePath("").DirectoryExists());
+}
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+TEST(DirectoryTest, CurrentDirectoryExists) {
+#if GTEST_OS_WINDOWS  // We are on Windows.
+# ifndef _WIN32_CE  // Windows CE doesn't have a current directory.
+
+  EXPECT_TRUE(FilePath(".").DirectoryExists());
+  EXPECT_TRUE(FilePath(".\\").DirectoryExists());
+
+# endif  // _WIN32_CE
+#else
+  EXPECT_TRUE(FilePath(".").DirectoryExists());
+  EXPECT_TRUE(FilePath("./").DirectoryExists());
+#endif  // GTEST_OS_WINDOWS
+}
+
+// "foo/bar" == foo//bar" == "foo///bar"
+TEST(NormalizeTest, MultipleConsecutiveSepaparatorsInMidstring) {
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
+            FilePath("foo" GTEST_PATH_SEP_ "bar").string());
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
+            FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
+            FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_
+                     GTEST_PATH_SEP_ "bar").string());
+}
+
+// "/bar" == //bar" == "///bar"
+TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringStart) {
+  EXPECT_EQ(GTEST_PATH_SEP_ "bar",
+    FilePath(GTEST_PATH_SEP_ "bar").string());
+  EXPECT_EQ(GTEST_PATH_SEP_ "bar",
+    FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
+  EXPECT_EQ(GTEST_PATH_SEP_ "bar",
+    FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
+}
+
+// "foo/" == foo//" == "foo///"
+TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringEnd) {
+  EXPECT_EQ("foo" GTEST_PATH_SEP_,
+    FilePath("foo" GTEST_PATH_SEP_).string());
+  EXPECT_EQ("foo" GTEST_PATH_SEP_,
+    FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_).string());
+  EXPECT_EQ("foo" GTEST_PATH_SEP_,
+    FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_).string());
+}
+
+#if GTEST_HAS_ALT_PATH_SEP_
+
+// Tests that separators at the end of the string are normalized
+// regardless of their combination (e.g. "foo\" =="foo/\" ==
+// "foo\\/").
+TEST(NormalizeTest, MixAlternateSeparatorAtStringEnd) {
+  EXPECT_EQ("foo" GTEST_PATH_SEP_,
+            FilePath("foo/").string());
+  EXPECT_EQ("foo" GTEST_PATH_SEP_,
+            FilePath("foo" GTEST_PATH_SEP_ "/").string());
+  EXPECT_EQ("foo" GTEST_PATH_SEP_,
+            FilePath("foo//" GTEST_PATH_SEP_).string());
+}
+
+#endif
+
+TEST(AssignmentOperatorTest, DefaultAssignedToNonDefault) {
+  FilePath default_path;
+  FilePath non_default_path("path");
+  non_default_path = default_path;
+  EXPECT_EQ("", non_default_path.string());
+  EXPECT_EQ("", default_path.string());  // RHS var is unchanged.
+}
+
+TEST(AssignmentOperatorTest, NonDefaultAssignedToDefault) {
+  FilePath non_default_path("path");
+  FilePath default_path;
+  default_path = non_default_path;
+  EXPECT_EQ("path", default_path.string());
+  EXPECT_EQ("path", non_default_path.string());  // RHS var is unchanged.
+}
+
+TEST(AssignmentOperatorTest, ConstAssignedToNonConst) {
+  const FilePath const_default_path("const_path");
+  FilePath non_default_path("path");
+  non_default_path = const_default_path;
+  EXPECT_EQ("const_path", non_default_path.string());
+}
+
+class DirectoryCreationTest : public Test {
+ protected:
+  virtual void SetUp() {
+    testdata_path_.Set(FilePath(
+        TempDir() + GetCurrentExecutableName().string() +
+        "_directory_creation" GTEST_PATH_SEP_ "test" GTEST_PATH_SEP_));
+    testdata_file_.Set(testdata_path_.RemoveTrailingPathSeparator());
+
+    unique_file0_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
+        0, "txt"));
+    unique_file1_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
+        1, "txt"));
+
+    remove(testdata_file_.c_str());
+    remove(unique_file0_.c_str());
+    remove(unique_file1_.c_str());
+    posix::RmDir(testdata_path_.c_str());
+  }
+
+  virtual void TearDown() {
+    remove(testdata_file_.c_str());
+    remove(unique_file0_.c_str());
+    remove(unique_file1_.c_str());
+    posix::RmDir(testdata_path_.c_str());
+  }
+
+  void CreateTextFile(const char* filename) {
+    FILE* f = posix::FOpen(filename, "w");
+    fprintf(f, "text\n");
+    fclose(f);
+  }
+
+  // Strings representing a directory and a file, with identical paths
+  // except for the trailing separator character that distinquishes
+  // a directory named 'test' from a file named 'test'. Example names:
+  FilePath testdata_path_;  // "/tmp/directory_creation/test/"
+  FilePath testdata_file_;  // "/tmp/directory_creation/test"
+  FilePath unique_file0_;  // "/tmp/directory_creation/test/unique.txt"
+  FilePath unique_file1_;  // "/tmp/directory_creation/test/unique_1.txt"
+};
+
+TEST_F(DirectoryCreationTest, CreateDirectoriesRecursively) {
+  EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.string();
+  EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
+  EXPECT_TRUE(testdata_path_.DirectoryExists());
+}
+
+TEST_F(DirectoryCreationTest, CreateDirectoriesForAlreadyExistingPath) {
+  EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.string();
+  EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
+  // Call 'create' again... should still succeed.
+  EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
+}
+
+TEST_F(DirectoryCreationTest, CreateDirectoriesAndUniqueFilename) {
+  FilePath file_path(FilePath::GenerateUniqueFileName(testdata_path_,
+      FilePath("unique"), "txt"));
+  EXPECT_EQ(unique_file0_.string(), file_path.string());
+  EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file not there
+
+  testdata_path_.CreateDirectoriesRecursively();
+  EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file still not there
+  CreateTextFile(file_path.c_str());
+  EXPECT_TRUE(file_path.FileOrDirectoryExists());
+
+  FilePath file_path2(FilePath::GenerateUniqueFileName(testdata_path_,
+      FilePath("unique"), "txt"));
+  EXPECT_EQ(unique_file1_.string(), file_path2.string());
+  EXPECT_FALSE(file_path2.FileOrDirectoryExists());  // file not there
+  CreateTextFile(file_path2.c_str());
+  EXPECT_TRUE(file_path2.FileOrDirectoryExists());
+}
+
+TEST_F(DirectoryCreationTest, CreateDirectoriesFail) {
+  // force a failure by putting a file where we will try to create a directory.
+  CreateTextFile(testdata_file_.c_str());
+  EXPECT_TRUE(testdata_file_.FileOrDirectoryExists());
+  EXPECT_FALSE(testdata_file_.DirectoryExists());
+  EXPECT_FALSE(testdata_file_.CreateDirectoriesRecursively());
+}
+
+TEST(NoDirectoryCreationTest, CreateNoDirectoriesForDefaultXmlFile) {
+  const FilePath test_detail_xml("test_detail.xml");
+  EXPECT_FALSE(test_detail_xml.CreateDirectoriesRecursively());
+}
+
+TEST(FilePathTest, DefaultConstructor) {
+  FilePath fp;
+  EXPECT_EQ("", fp.string());
+}
+
+TEST(FilePathTest, CharAndCopyConstructors) {
+  const FilePath fp("spicy");
+  EXPECT_EQ("spicy", fp.string());
+
+  const FilePath fp_copy(fp);
+  EXPECT_EQ("spicy", fp_copy.string());
+}
+
+TEST(FilePathTest, StringConstructor) {
+  const FilePath fp(std::string("cider"));
+  EXPECT_EQ("cider", fp.string());
+}
+
+TEST(FilePathTest, Set) {
+  const FilePath apple("apple");
+  FilePath mac("mac");
+  mac.Set(apple);  // Implement Set() since overloading operator= is forbidden.
+  EXPECT_EQ("apple", mac.string());
+  EXPECT_EQ("apple", apple.string());
+}
+
+TEST(FilePathTest, ToString) {
+  const FilePath file("drink");
+  EXPECT_EQ("drink", file.string());
+}
+
+TEST(FilePathTest, RemoveExtension) {
+  EXPECT_EQ("app", FilePath("app.cc").RemoveExtension("cc").string());
+  EXPECT_EQ("app", FilePath("app.exe").RemoveExtension("exe").string());
+  EXPECT_EQ("APP", FilePath("APP.EXE").RemoveExtension("exe").string());
+}
+
+TEST(FilePathTest, RemoveExtensionWhenThereIsNoExtension) {
+  EXPECT_EQ("app", FilePath("app").RemoveExtension("exe").string());
+}
+
+TEST(FilePathTest, IsDirectory) {
+  EXPECT_FALSE(FilePath("cola").IsDirectory());
+  EXPECT_TRUE(FilePath("koala" GTEST_PATH_SEP_).IsDirectory());
+#if GTEST_HAS_ALT_PATH_SEP_
+  EXPECT_TRUE(FilePath("koala/").IsDirectory());
+#endif
+}
+
+TEST(FilePathTest, IsAbsolutePath) {
+  EXPECT_FALSE(FilePath("is" GTEST_PATH_SEP_ "relative").IsAbsolutePath());
+  EXPECT_FALSE(FilePath("").IsAbsolutePath());
+#if GTEST_OS_WINDOWS
+  EXPECT_TRUE(FilePath("c:\\" GTEST_PATH_SEP_ "is_not"
+                       GTEST_PATH_SEP_ "relative").IsAbsolutePath());
+  EXPECT_FALSE(FilePath("c:foo" GTEST_PATH_SEP_ "bar").IsAbsolutePath());
+  EXPECT_TRUE(FilePath("c:/" GTEST_PATH_SEP_ "is_not"
+                       GTEST_PATH_SEP_ "relative").IsAbsolutePath());
+#else
+  EXPECT_TRUE(FilePath(GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative")
+              .IsAbsolutePath());
+#endif  // GTEST_OS_WINDOWS
+}
+
+TEST(FilePathTest, IsRootDirectory) {
+#if GTEST_OS_WINDOWS
+  EXPECT_TRUE(FilePath("a:\\").IsRootDirectory());
+  EXPECT_TRUE(FilePath("Z:/").IsRootDirectory());
+  EXPECT_TRUE(FilePath("e://").IsRootDirectory());
+  EXPECT_FALSE(FilePath("").IsRootDirectory());
+  EXPECT_FALSE(FilePath("b:").IsRootDirectory());
+  EXPECT_FALSE(FilePath("b:a").IsRootDirectory());
+  EXPECT_FALSE(FilePath("8:/").IsRootDirectory());
+  EXPECT_FALSE(FilePath("c|/").IsRootDirectory());
+#else
+  EXPECT_TRUE(FilePath("/").IsRootDirectory());
+  EXPECT_TRUE(FilePath("//").IsRootDirectory());
+  EXPECT_FALSE(FilePath("").IsRootDirectory());
+  EXPECT_FALSE(FilePath("\\").IsRootDirectory());
+  EXPECT_FALSE(FilePath("/x").IsRootDirectory());
+#endif
+}
+
+}  // namespace
+}  // namespace internal
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-linked_ptr_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-linked_ptr_test.cc
new file mode 100644
index 00000000..6fcf5124
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-linked_ptr_test.cc
@@ -0,0 +1,154 @@
+// Copyright 2003, 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.
+//
+// Authors: Dan Egnor (egnor@google.com)
+// Ported to Windows: Vadim Berman (vadimb@google.com)
+
+#include "gtest/internal/gtest-linked_ptr.h"
+
+#include <stdlib.h>
+#include "gtest/gtest.h"
+
+namespace {
+
+using testing::Message;
+using testing::internal::linked_ptr;
+
+int num;
+Message* history = NULL;
+
+// Class which tracks allocation/deallocation
+class A {
+ public:
+  A(): mynum(num++) { *history << "A" << mynum << " ctor\n"; }
+  virtual ~A() { *history << "A" << mynum << " dtor\n"; }
+  virtual void Use() { *history << "A" << mynum << " use\n"; }
+ protected:
+  int mynum;
+};
+
+// Subclass
+class B : public A {
+ public:
+  B() { *history << "B" << mynum << " ctor\n"; }
+  ~B() { *history << "B" << mynum << " dtor\n"; }
+  virtual void Use() { *history << "B" << mynum << " use\n"; }
+};
+
+class LinkedPtrTest : public testing::Test {
+ public:
+  LinkedPtrTest() {
+    num = 0;
+    history = new Message;
+  }
+
+  virtual ~LinkedPtrTest() {
+    delete history;
+    history = NULL;
+  }
+};
+
+TEST_F(LinkedPtrTest, GeneralTest) {
+  {
+    linked_ptr<A> a0, a1, a2;
+    // Use explicit function call notation here to suppress self-assign warning.
+    a0.operator=(a0);
+    a1 = a2;
+    ASSERT_EQ(a0.get(), static_cast<A*>(NULL));
+    ASSERT_EQ(a1.get(), static_cast<A*>(NULL));
+    ASSERT_EQ(a2.get(), static_cast<A*>(NULL));
+    ASSERT_TRUE(a0 == NULL);
+    ASSERT_TRUE(a1 == NULL);
+    ASSERT_TRUE(a2 == NULL);
+
+    {
+      linked_ptr<A> a3(new A);
+      a0 = a3;
+      ASSERT_TRUE(a0 == a3);
+      ASSERT_TRUE(a0 != NULL);
+      ASSERT_TRUE(a0.get() == a3);
+      ASSERT_TRUE(a0 == a3.get());
+      linked_ptr<A> a4(a0);
+      a1 = a4;
+      linked_ptr<A> a5(new A);
+      ASSERT_TRUE(a5.get() != a3);
+      ASSERT_TRUE(a5 != a3.get());
+      a2 = a5;
+      linked_ptr<B> b0(new B);
+      linked_ptr<A> a6(b0);
+      ASSERT_TRUE(b0 == a6);
+      ASSERT_TRUE(a6 == b0);
+      ASSERT_TRUE(b0 != NULL);
+      a5 = b0;
+      a5 = b0;
+      a3->Use();
+      a4->Use();
+      a5->Use();
+      a6->Use();
+      b0->Use();
+      (*b0).Use();
+      b0.get()->Use();
+    }
+
+    a0->Use();
+    a1->Use();
+    a2->Use();
+
+    a1 = a2;
+    a2.reset(new A);
+    a0.reset();
+
+    linked_ptr<A> a7;
+  }
+
+  ASSERT_STREQ(
+    "A0 ctor\n"
+    "A1 ctor\n"
+    "A2 ctor\n"
+    "B2 ctor\n"
+    "A0 use\n"
+    "A0 use\n"
+    "B2 use\n"
+    "B2 use\n"
+    "B2 use\n"
+    "B2 use\n"
+    "B2 use\n"
+    "B2 dtor\n"
+    "A2 dtor\n"
+    "A0 use\n"
+    "A0 use\n"
+    "A1 use\n"
+    "A3 ctor\n"
+    "A0 dtor\n"
+    "A3 dtor\n"
+    "A1 dtor\n",
+    history->GetString().c_str());
+}
+
+}  // Unnamed namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-listener_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-listener_test.cc
new file mode 100644
index 00000000..90747685
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-listener_test.cc
@@ -0,0 +1,311 @@
+// Copyright 2009 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This file verifies Google Test event listeners receive events at the
+// right times.
+
+#include "gtest/gtest.h"
+#include <vector>
+
+using ::testing::AddGlobalTestEnvironment;
+using ::testing::Environment;
+using ::testing::InitGoogleTest;
+using ::testing::Test;
+using ::testing::TestCase;
+using ::testing::TestEventListener;
+using ::testing::TestInfo;
+using ::testing::TestPartResult;
+using ::testing::UnitTest;
+
+// Used by tests to register their events.
+std::vector<std::string>* g_events = NULL;
+
+namespace testing {
+namespace internal {
+
+class EventRecordingListener : public TestEventListener {
+ public:
+  explicit EventRecordingListener(const char* name) : name_(name) {}
+
+ protected:
+  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
+    g_events->push_back(GetFullMethodName("OnTestProgramStart"));
+  }
+
+  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
+                                    int iteration) {
+    Message message;
+    message << GetFullMethodName("OnTestIterationStart")
+            << "(" << iteration << ")";
+    g_events->push_back(message.GetString());
+  }
+
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {
+    g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpStart"));
+  }
+
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {
+    g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpEnd"));
+  }
+
+  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {
+    g_events->push_back(GetFullMethodName("OnTestCaseStart"));
+  }
+
+  virtual void OnTestStart(const TestInfo& /*test_info*/) {
+    g_events->push_back(GetFullMethodName("OnTestStart"));
+  }
+
+  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {
+    g_events->push_back(GetFullMethodName("OnTestPartResult"));
+  }
+
+  virtual void OnTestEnd(const TestInfo& /*test_info*/) {
+    g_events->push_back(GetFullMethodName("OnTestEnd"));
+  }
+
+  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {
+    g_events->push_back(GetFullMethodName("OnTestCaseEnd"));
+  }
+
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {
+    g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownStart"));
+  }
+
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {
+    g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownEnd"));
+  }
+
+  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
+                                  int iteration) {
+    Message message;
+    message << GetFullMethodName("OnTestIterationEnd")
+            << "("  << iteration << ")";
+    g_events->push_back(message.GetString());
+  }
+
+  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
+    g_events->push_back(GetFullMethodName("OnTestProgramEnd"));
+  }
+
+ private:
+  std::string GetFullMethodName(const char* name) {
+    return name_ + "." + name;
+  }
+
+  std::string name_;
+};
+
+class EnvironmentInvocationCatcher : public Environment {
+ protected:
+  virtual void SetUp() {
+    g_events->push_back("Environment::SetUp");
+  }
+
+  virtual void TearDown() {
+    g_events->push_back("Environment::TearDown");
+  }
+};
+
+class ListenerTest : public Test {
+ protected:
+  static void SetUpTestCase() {
+    g_events->push_back("ListenerTest::SetUpTestCase");
+  }
+
+  static void TearDownTestCase() {
+    g_events->push_back("ListenerTest::TearDownTestCase");
+  }
+
+  virtual void SetUp() {
+    g_events->push_back("ListenerTest::SetUp");
+  }
+
+  virtual void TearDown() {
+    g_events->push_back("ListenerTest::TearDown");
+  }
+};
+
+TEST_F(ListenerTest, DoesFoo) {
+  // Test execution order within a test case is not guaranteed so we are not
+  // recording the test name.
+  g_events->push_back("ListenerTest::* Test Body");
+  SUCCEED();  // Triggers OnTestPartResult.
+}
+
+TEST_F(ListenerTest, DoesBar) {
+  g_events->push_back("ListenerTest::* Test Body");
+  SUCCEED();  // Triggers OnTestPartResult.
+}
+
+}  // namespace internal
+
+}  // namespace testing
+
+using ::testing::internal::EnvironmentInvocationCatcher;
+using ::testing::internal::EventRecordingListener;
+
+void VerifyResults(const std::vector<std::string>& data,
+                   const char* const* expected_data,
+                   size_t expected_data_size) {
+  const size_t actual_size = data.size();
+  // If the following assertion fails, a new entry will be appended to
+  // data.  Hence we save data.size() first.
+  EXPECT_EQ(expected_data_size, actual_size);
+
+  // Compares the common prefix.
+  const size_t shorter_size = expected_data_size <= actual_size ?
+      expected_data_size : actual_size;
+  size_t i = 0;
+  for (; i < shorter_size; ++i) {
+    ASSERT_STREQ(expected_data[i], data[i].c_str())
+        << "at position " << i;
+  }
+
+  // Prints extra elements in the actual data.
+  for (; i < actual_size; ++i) {
+    printf("  Actual event #%lu: %s\n",
+        static_cast<unsigned long>(i), data[i].c_str());
+  }
+}
+
+int main(int argc, char **argv) {
+  std::vector<std::string> events;
+  g_events = &events;
+  InitGoogleTest(&argc, argv);
+
+  UnitTest::GetInstance()->listeners().Append(
+      new EventRecordingListener("1st"));
+  UnitTest::GetInstance()->listeners().Append(
+      new EventRecordingListener("2nd"));
+
+  AddGlobalTestEnvironment(new EnvironmentInvocationCatcher);
+
+  GTEST_CHECK_(events.size() == 0)
+      << "AddGlobalTestEnvironment should not generate any events itself.";
+
+  ::testing::GTEST_FLAG(repeat) = 2;
+  int ret_val = RUN_ALL_TESTS();
+
+  const char* const expected_events[] = {
+    "1st.OnTestProgramStart",
+    "2nd.OnTestProgramStart",
+    "1st.OnTestIterationStart(0)",
+    "2nd.OnTestIterationStart(0)",
+    "1st.OnEnvironmentsSetUpStart",
+    "2nd.OnEnvironmentsSetUpStart",
+    "Environment::SetUp",
+    "2nd.OnEnvironmentsSetUpEnd",
+    "1st.OnEnvironmentsSetUpEnd",
+    "1st.OnTestCaseStart",
+    "2nd.OnTestCaseStart",
+    "ListenerTest::SetUpTestCase",
+    "1st.OnTestStart",
+    "2nd.OnTestStart",
+    "ListenerTest::SetUp",
+    "ListenerTest::* Test Body",
+    "1st.OnTestPartResult",
+    "2nd.OnTestPartResult",
+    "ListenerTest::TearDown",
+    "2nd.OnTestEnd",
+    "1st.OnTestEnd",
+    "1st.OnTestStart",
+    "2nd.OnTestStart",
+    "ListenerTest::SetUp",
+    "ListenerTest::* Test Body",
+    "1st.OnTestPartResult",
+    "2nd.OnTestPartResult",
+    "ListenerTest::TearDown",
+    "2nd.OnTestEnd",
+    "1st.OnTestEnd",
+    "ListenerTest::TearDownTestCase",
+    "2nd.OnTestCaseEnd",
+    "1st.OnTestCaseEnd",
+    "1st.OnEnvironmentsTearDownStart",
+    "2nd.OnEnvironmentsTearDownStart",
+    "Environment::TearDown",
+    "2nd.OnEnvironmentsTearDownEnd",
+    "1st.OnEnvironmentsTearDownEnd",
+    "2nd.OnTestIterationEnd(0)",
+    "1st.OnTestIterationEnd(0)",
+    "1st.OnTestIterationStart(1)",
+    "2nd.OnTestIterationStart(1)",
+    "1st.OnEnvironmentsSetUpStart",
+    "2nd.OnEnvironmentsSetUpStart",
+    "Environment::SetUp",
+    "2nd.OnEnvironmentsSetUpEnd",
+    "1st.OnEnvironmentsSetUpEnd",
+    "1st.OnTestCaseStart",
+    "2nd.OnTestCaseStart",
+    "ListenerTest::SetUpTestCase",
+    "1st.OnTestStart",
+    "2nd.OnTestStart",
+    "ListenerTest::SetUp",
+    "ListenerTest::* Test Body",
+    "1st.OnTestPartResult",
+    "2nd.OnTestPartResult",
+    "ListenerTest::TearDown",
+    "2nd.OnTestEnd",
+    "1st.OnTestEnd",
+    "1st.OnTestStart",
+    "2nd.OnTestStart",
+    "ListenerTest::SetUp",
+    "ListenerTest::* Test Body",
+    "1st.OnTestPartResult",
+    "2nd.OnTestPartResult",
+    "ListenerTest::TearDown",
+    "2nd.OnTestEnd",
+    "1st.OnTestEnd",
+    "ListenerTest::TearDownTestCase",
+    "2nd.OnTestCaseEnd",
+    "1st.OnTestCaseEnd",
+    "1st.OnEnvironmentsTearDownStart",
+    "2nd.OnEnvironmentsTearDownStart",
+    "Environment::TearDown",
+    "2nd.OnEnvironmentsTearDownEnd",
+    "1st.OnEnvironmentsTearDownEnd",
+    "2nd.OnTestIterationEnd(1)",
+    "1st.OnTestIterationEnd(1)",
+    "2nd.OnTestProgramEnd",
+    "1st.OnTestProgramEnd"
+  };
+  VerifyResults(events,
+                expected_events,
+                sizeof(expected_events)/sizeof(expected_events[0]));
+
+  // We need to check manually for ad hoc test failures that happen after
+  // RUN_ALL_TESTS finishes.
+  if (UnitTest::GetInstance()->Failed())
+    ret_val = 1;
+
+  return ret_val;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-message_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-message_test.cc
new file mode 100644
index 00000000..175238ef
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-message_test.cc
@@ -0,0 +1,159 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Tests for the Message class.
+
+#include "gtest/gtest-message.h"
+
+#include "gtest/gtest.h"
+
+namespace {
+
+using ::testing::Message;
+
+// Tests the testing::Message class
+
+// Tests the default constructor.
+TEST(MessageTest, DefaultConstructor) {
+  const Message msg;
+  EXPECT_EQ("", msg.GetString());
+}
+
+// Tests the copy constructor.
+TEST(MessageTest, CopyConstructor) {
+  const Message msg1("Hello");
+  const Message msg2(msg1);
+  EXPECT_EQ("Hello", msg2.GetString());
+}
+
+// Tests constructing a Message from a C-string.
+TEST(MessageTest, ConstructsFromCString) {
+  Message msg("Hello");
+  EXPECT_EQ("Hello", msg.GetString());
+}
+
+// Tests streaming a float.
+TEST(MessageTest, StreamsFloat) {
+  const std::string s = (Message() << 1.23456F << " " << 2.34567F).GetString();
+  // Both numbers should be printed with enough precision.
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "1.234560", s.c_str());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, " 2.345669", s.c_str());
+}
+
+// Tests streaming a double.
+TEST(MessageTest, StreamsDouble) {
+  const std::string s = (Message() << 1260570880.4555497 << " "
+                                  << 1260572265.1954534).GetString();
+  // Both numbers should be printed with enough precision.
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "1260570880.45", s.c_str());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, " 1260572265.19", s.c_str());
+}
+
+// Tests streaming a non-char pointer.
+TEST(MessageTest, StreamsPointer) {
+  int n = 0;
+  int* p = &n;
+  EXPECT_NE("(null)", (Message() << p).GetString());
+}
+
+// Tests streaming a NULL non-char pointer.
+TEST(MessageTest, StreamsNullPointer) {
+  int* p = NULL;
+  EXPECT_EQ("(null)", (Message() << p).GetString());
+}
+
+// Tests streaming a C string.
+TEST(MessageTest, StreamsCString) {
+  EXPECT_EQ("Foo", (Message() << "Foo").GetString());
+}
+
+// Tests streaming a NULL C string.
+TEST(MessageTest, StreamsNullCString) {
+  char* p = NULL;
+  EXPECT_EQ("(null)", (Message() << p).GetString());
+}
+
+// Tests streaming std::string.
+TEST(MessageTest, StreamsString) {
+  const ::std::string str("Hello");
+  EXPECT_EQ("Hello", (Message() << str).GetString());
+}
+
+// Tests that we can output strings containing embedded NULs.
+TEST(MessageTest, StreamsStringWithEmbeddedNUL) {
+  const char char_array_with_nul[] =
+      "Here's a NUL\0 and some more string";
+  const ::std::string string_with_nul(char_array_with_nul,
+                                      sizeof(char_array_with_nul) - 1);
+  EXPECT_EQ("Here's a NUL\\0 and some more string",
+            (Message() << string_with_nul).GetString());
+}
+
+// Tests streaming a NUL char.
+TEST(MessageTest, StreamsNULChar) {
+  EXPECT_EQ("\\0", (Message() << '\0').GetString());
+}
+
+// Tests streaming int.
+TEST(MessageTest, StreamsInt) {
+  EXPECT_EQ("123", (Message() << 123).GetString());
+}
+
+// Tests that basic IO manipulators (endl, ends, and flush) can be
+// streamed to Message.
+TEST(MessageTest, StreamsBasicIoManip) {
+  EXPECT_EQ("Line 1.\nA NUL char \\0 in line 2.",
+               (Message() << "Line 1." << std::endl
+                         << "A NUL char " << std::ends << std::flush
+                         << " in line 2.").GetString());
+}
+
+// Tests Message::GetString()
+TEST(MessageTest, GetString) {
+  Message msg;
+  msg << 1 << " lamb";
+  EXPECT_EQ("1 lamb", msg.GetString());
+}
+
+// Tests streaming a Message object to an ostream.
+TEST(MessageTest, StreamsToOStream) {
+  Message msg("Hello");
+  ::std::stringstream ss;
+  ss << msg;
+  EXPECT_EQ("Hello", testing::internal::StringStreamToString(&ss));
+}
+
+// Tests that a Message object doesn't take up too much stack space.
+TEST(MessageTest, DoesNotTakeUpMuchStackSpace) {
+  EXPECT_LE(sizeof(Message), 16U);
+}
+
+}  // namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-options_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-options_test.cc
new file mode 100644
index 00000000..5586dc3b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-options_test.cc
@@ -0,0 +1,215 @@
+// 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.
+//
+// Authors: keith.ray@gmail.com (Keith Ray)
+//
+// Google Test UnitTestOptions tests
+//
+// This file tests classes and functions used internally by
+// Google Test.  They are subject to change without notice.
+//
+// This file is #included from gtest.cc, to avoid changing build or
+// make-files on Windows and other platforms. Do not #include this file
+// anywhere else!
+
+#include "gtest/gtest.h"
+
+#if GTEST_OS_WINDOWS_MOBILE
+# include <windows.h>
+#elif GTEST_OS_WINDOWS
+# include <direct.h>
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+namespace testing {
+namespace internal {
+namespace {
+
+// Turns the given relative path into an absolute path.
+FilePath GetAbsolutePathOf(const FilePath& relative_path) {
+  return FilePath::ConcatPaths(FilePath::GetCurrentDir(), relative_path);
+}
+
+// Testing UnitTestOptions::GetOutputFormat/GetOutputFile.
+
+TEST(XmlOutputTest, GetOutputFormatDefault) {
+  GTEST_FLAG(output) = "";
+  EXPECT_STREQ("", UnitTestOptions::GetOutputFormat().c_str());
+}
+
+TEST(XmlOutputTest, GetOutputFormat) {
+  GTEST_FLAG(output) = "xml:filename";
+  EXPECT_STREQ("xml", UnitTestOptions::GetOutputFormat().c_str());
+}
+
+TEST(XmlOutputTest, GetOutputFileDefault) {
+  GTEST_FLAG(output) = "";
+  EXPECT_EQ(GetAbsolutePathOf(FilePath("test_detail.xml")).string(),
+            UnitTestOptions::GetAbsolutePathToOutputFile());
+}
+
+TEST(XmlOutputTest, GetOutputFileSingleFile) {
+  GTEST_FLAG(output) = "xml:filename.abc";
+  EXPECT_EQ(GetAbsolutePathOf(FilePath("filename.abc")).string(),
+            UnitTestOptions::GetAbsolutePathToOutputFile());
+}
+
+TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) {
+  GTEST_FLAG(output) = "xml:path" GTEST_PATH_SEP_;
+  const std::string expected_output_file =
+      GetAbsolutePathOf(
+          FilePath(std::string("path") + GTEST_PATH_SEP_ +
+                   GetCurrentExecutableName().string() + ".xml")).string();
+  const std::string& output_file =
+      UnitTestOptions::GetAbsolutePathToOutputFile();
+#if GTEST_OS_WINDOWS
+  EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
+#else
+  EXPECT_EQ(expected_output_file, output_file.c_str());
+#endif
+}
+
+TEST(OutputFileHelpersTest, GetCurrentExecutableName) {
+  const std::string exe_str = GetCurrentExecutableName().string();
+#if GTEST_OS_WINDOWS
+  const bool success =
+      _strcmpi("gtest-options_test", exe_str.c_str()) == 0 ||
+      _strcmpi("gtest-options-ex_test", exe_str.c_str()) == 0 ||
+      _strcmpi("gtest_all_test", exe_str.c_str()) == 0 ||
+      _strcmpi("gtest_dll_test", exe_str.c_str()) == 0;
+#else
+  // TODO(wan@google.com): remove the hard-coded "lt-" prefix when
+  //   Chandler Carruth's libtool replacement is ready.
+  const bool success =
+      exe_str == "gtest-options_test" ||
+      exe_str == "gtest_all_test" ||
+      exe_str == "lt-gtest_all_test" ||
+      exe_str == "gtest_dll_test";
+#endif  // GTEST_OS_WINDOWS
+  if (!success)
+    FAIL() << "GetCurrentExecutableName() returns " << exe_str;
+}
+
+class XmlOutputChangeDirTest : public Test {
+ protected:
+  virtual void SetUp() {
+    original_working_dir_ = FilePath::GetCurrentDir();
+    posix::ChDir("..");
+    // This will make the test fail if run from the root directory.
+    EXPECT_NE(original_working_dir_.string(),
+              FilePath::GetCurrentDir().string());
+  }
+
+  virtual void TearDown() {
+    posix::ChDir(original_working_dir_.string().c_str());
+  }
+
+  FilePath original_working_dir_;
+};
+
+TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefault) {
+  GTEST_FLAG(output) = "";
+  EXPECT_EQ(FilePath::ConcatPaths(original_working_dir_,
+                                  FilePath("test_detail.xml")).string(),
+            UnitTestOptions::GetAbsolutePathToOutputFile());
+}
+
+TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefaultXML) {
+  GTEST_FLAG(output) = "xml";
+  EXPECT_EQ(FilePath::ConcatPaths(original_working_dir_,
+                                  FilePath("test_detail.xml")).string(),
+            UnitTestOptions::GetAbsolutePathToOutputFile());
+}
+
+TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativeFile) {
+  GTEST_FLAG(output) = "xml:filename.abc";
+  EXPECT_EQ(FilePath::ConcatPaths(original_working_dir_,
+                                  FilePath("filename.abc")).string(),
+            UnitTestOptions::GetAbsolutePathToOutputFile());
+}
+
+TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) {
+  GTEST_FLAG(output) = "xml:path" GTEST_PATH_SEP_;
+  const std::string expected_output_file =
+      FilePath::ConcatPaths(
+          original_working_dir_,
+          FilePath(std::string("path") + GTEST_PATH_SEP_ +
+                   GetCurrentExecutableName().string() + ".xml")).string();
+  const std::string& output_file =
+      UnitTestOptions::GetAbsolutePathToOutputFile();
+#if GTEST_OS_WINDOWS
+  EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
+#else
+  EXPECT_EQ(expected_output_file, output_file.c_str());
+#endif
+}
+
+TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) {
+#if GTEST_OS_WINDOWS
+  GTEST_FLAG(output) = "xml:c:\\tmp\\filename.abc";
+  EXPECT_EQ(FilePath("c:\\tmp\\filename.abc").string(),
+            UnitTestOptions::GetAbsolutePathToOutputFile());
+#else
+  GTEST_FLAG(output) ="xml:/tmp/filename.abc";
+  EXPECT_EQ(FilePath("/tmp/filename.abc").string(),
+            UnitTestOptions::GetAbsolutePathToOutputFile());
+#endif
+}
+
+TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsolutePath) {
+#if GTEST_OS_WINDOWS
+  const std::string path = "c:\\tmp\\";
+#else
+  const std::string path = "/tmp/";
+#endif
+
+  GTEST_FLAG(output) = "xml:" + path;
+  const std::string expected_output_file =
+      path + GetCurrentExecutableName().string() + ".xml";
+  const std::string& output_file =
+      UnitTestOptions::GetAbsolutePathToOutputFile();
+
+#if GTEST_OS_WINDOWS
+  EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
+#else
+  EXPECT_EQ(expected_output_file, output_file.c_str());
+#endif
+}
+
+}  // namespace
+}  // namespace internal
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test2_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test2_test.cc
new file mode 100644
index 00000000..4a782fe7
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test2_test.cc
@@ -0,0 +1,65 @@
+// 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+//
+// Tests for Google Test itself.  This verifies that the basic constructs of
+// Google Test work.
+
+#include "gtest/gtest.h"
+
+#include "test/gtest-param-test_test.h"
+
+#if GTEST_HAS_PARAM_TEST
+
+using ::testing::Values;
+using ::testing::internal::ParamGenerator;
+
+// Tests that generators defined in a different translation unit
+// are functional. The test using extern_gen is defined
+// in gtest-param-test_test.cc.
+ParamGenerator<int> extern_gen = Values(33);
+
+// Tests that a parameterized test case can be defined in one translation unit
+// and instantiated in another. The test is defined in gtest-param-test_test.cc
+// and ExternalInstantiationTest fixture class is defined in
+// gtest-param-test_test.h.
+INSTANTIATE_TEST_CASE_P(MultiplesOf33,
+                        ExternalInstantiationTest,
+                        Values(33, 66));
+
+// Tests that a parameterized test case can be instantiated
+// in multiple translation units. Another instantiation is defined
+// in gtest-param-test_test.cc and InstantiationInMultipleTranslaionUnitsTest
+// fixture is defined in gtest-param-test_test.h
+INSTANTIATE_TEST_CASE_P(Sequence2,
+                        InstantiationInMultipleTranslaionUnitsTest,
+                        Values(42*3, 42*4, 42*5));
+
+#endif  // GTEST_HAS_PARAM_TEST
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.cc
new file mode 100644
index 00000000..8b278bb9
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.cc
@@ -0,0 +1,1055 @@
+// 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+//
+// Tests for Google Test itself. This file verifies that the parameter
+// generators objects produce correct parameter sequences and that
+// Google Test runtime instantiates correct tests from those sequences.
+
+#include "gtest/gtest.h"
+
+#if GTEST_HAS_PARAM_TEST
+
+# include <algorithm>
+# include <iostream>
+# include <list>
+# include <sstream>
+# include <string>
+# include <vector>
+
+// To include gtest-internal-inl.h.
+# define GTEST_IMPLEMENTATION_ 1
+# include "src/gtest-internal-inl.h"  // for UnitTestOptions
+# undef GTEST_IMPLEMENTATION_
+
+# include "test/gtest-param-test_test.h"
+
+using ::std::vector;
+using ::std::sort;
+
+using ::testing::AddGlobalTestEnvironment;
+using ::testing::Bool;
+using ::testing::Message;
+using ::testing::Range;
+using ::testing::TestWithParam;
+using ::testing::Values;
+using ::testing::ValuesIn;
+
+# if GTEST_HAS_COMBINE
+using ::testing::Combine;
+using ::testing::get;
+using ::testing::make_tuple;
+using ::testing::tuple;
+# endif  // GTEST_HAS_COMBINE
+
+using ::testing::internal::ParamGenerator;
+using ::testing::internal::UnitTestOptions;
+
+// Prints a value to a string.
+//
+// TODO(wan@google.com): remove PrintValue() when we move matchers and
+// EXPECT_THAT() from Google Mock to Google Test.  At that time, we
+// can write EXPECT_THAT(x, Eq(y)) to compare two tuples x and y, as
+// EXPECT_THAT() and the matchers know how to print tuples.
+template <typename T>
+::std::string PrintValue(const T& value) {
+  ::std::stringstream stream;
+  stream << value;
+  return stream.str();
+}
+
+# if GTEST_HAS_COMBINE
+
+// These overloads allow printing tuples in our tests.  We cannot
+// define an operator<< for tuples, as that definition needs to be in
+// the std namespace in order to be picked up by Google Test via
+// Argument-Dependent Lookup, yet defining anything in the std
+// namespace in non-STL code is undefined behavior.
+
+template <typename T1, typename T2>
+::std::string PrintValue(const tuple<T1, T2>& value) {
+  ::std::stringstream stream;
+  stream << "(" << get<0>(value) << ", " << get<1>(value) << ")";
+  return stream.str();
+}
+
+template <typename T1, typename T2, typename T3>
+::std::string PrintValue(const tuple<T1, T2, T3>& value) {
+  ::std::stringstream stream;
+  stream << "(" << get<0>(value) << ", " << get<1>(value)
+         << ", "<< get<2>(value) << ")";
+  return stream.str();
+}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9, typename T10>
+::std::string PrintValue(
+    const tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& value) {
+  ::std::stringstream stream;
+  stream << "(" << get<0>(value) << ", " << get<1>(value)
+         << ", "<< get<2>(value) << ", " << get<3>(value)
+         << ", "<< get<4>(value) << ", " << get<5>(value)
+         << ", "<< get<6>(value) << ", " << get<7>(value)
+         << ", "<< get<8>(value) << ", " << get<9>(value) << ")";
+  return stream.str();
+}
+
+# endif  // GTEST_HAS_COMBINE
+
+// Verifies that a sequence generated by the generator and accessed
+// via the iterator object matches the expected one using Google Test
+// assertions.
+template <typename T, size_t N>
+void VerifyGenerator(const ParamGenerator<T>& generator,
+                     const T (&expected_values)[N]) {
+  typename ParamGenerator<T>::iterator it = generator.begin();
+  for (size_t i = 0; i < N; ++i) {
+    ASSERT_FALSE(it == generator.end())
+        << "At element " << i << " when accessing via an iterator "
+        << "created with the copy constructor.\n";
+    // We cannot use EXPECT_EQ() here as the values may be tuples,
+    // which don't support <<.
+    EXPECT_TRUE(expected_values[i] == *it)
+        << "where i is " << i
+        << ", expected_values[i] is " << PrintValue(expected_values[i])
+        << ", *it is " << PrintValue(*it)
+        << ", and 'it' is an iterator created with the copy constructor.\n";
+    it++;
+  }
+  EXPECT_TRUE(it == generator.end())
+        << "At the presumed end of sequence when accessing via an iterator "
+        << "created with the copy constructor.\n";
+
+  // Test the iterator assignment. The following lines verify that
+  // the sequence accessed via an iterator initialized via the
+  // assignment operator (as opposed to a copy constructor) matches
+  // just the same.
+  it = generator.begin();
+  for (size_t i = 0; i < N; ++i) {
+    ASSERT_FALSE(it == generator.end())
+        << "At element " << i << " when accessing via an iterator "
+        << "created with the assignment operator.\n";
+    EXPECT_TRUE(expected_values[i] == *it)
+        << "where i is " << i
+        << ", expected_values[i] is " << PrintValue(expected_values[i])
+        << ", *it is " << PrintValue(*it)
+        << ", and 'it' is an iterator created with the copy constructor.\n";
+    it++;
+  }
+  EXPECT_TRUE(it == generator.end())
+        << "At the presumed end of sequence when accessing via an iterator "
+        << "created with the assignment operator.\n";
+}
+
+template <typename T>
+void VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) {
+  typename ParamGenerator<T>::iterator it = generator.begin();
+  EXPECT_TRUE(it == generator.end());
+
+  it = generator.begin();
+  EXPECT_TRUE(it == generator.end());
+}
+
+// Generator tests. They test that each of the provided generator functions
+// generates an expected sequence of values. The general test pattern
+// instantiates a generator using one of the generator functions,
+// checks the sequence produced by the generator using its iterator API,
+// and then resets the iterator back to the beginning of the sequence
+// and checks the sequence again.
+
+// Tests that iterators produced by generator functions conform to the
+// ForwardIterator concept.
+TEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) {
+  const ParamGenerator<int> gen = Range(0, 10);
+  ParamGenerator<int>::iterator it = gen.begin();
+
+  // Verifies that iterator initialization works as expected.
+  ParamGenerator<int>::iterator it2 = it;
+  EXPECT_TRUE(*it == *it2) << "Initialized iterators must point to the "
+                           << "element same as its source points to";
+
+  // Verifies that iterator assignment works as expected.
+  it++;
+  EXPECT_FALSE(*it == *it2);
+  it2 = it;
+  EXPECT_TRUE(*it == *it2) << "Assigned iterators must point to the "
+                           << "element same as its source points to";
+
+  // Verifies that prefix operator++() returns *this.
+  EXPECT_EQ(&it, &(++it)) << "Result of the prefix operator++ must be "
+                          << "refer to the original object";
+
+  // Verifies that the result of the postfix operator++ points to the value
+  // pointed to by the original iterator.
+  int original_value = *it;  // Have to compute it outside of macro call to be
+                             // unaffected by the parameter evaluation order.
+  EXPECT_EQ(original_value, *(it++));
+
+  // Verifies that prefix and postfix operator++() advance an iterator
+  // all the same.
+  it2 = it;
+  it++;
+  ++it2;
+  EXPECT_TRUE(*it == *it2);
+}
+
+// Tests that Range() generates the expected sequence.
+TEST(RangeTest, IntRangeWithDefaultStep) {
+  const ParamGenerator<int> gen = Range(0, 3);
+  const int expected_values[] = {0, 1, 2};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Edge case. Tests that Range() generates the single element sequence
+// as expected when provided with range limits that are equal.
+TEST(RangeTest, IntRangeSingleValue) {
+  const ParamGenerator<int> gen = Range(0, 1);
+  const int expected_values[] = {0};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Edge case. Tests that Range() with generates empty sequence when
+// supplied with an empty range.
+TEST(RangeTest, IntRangeEmpty) {
+  const ParamGenerator<int> gen = Range(0, 0);
+  VerifyGeneratorIsEmpty(gen);
+}
+
+// Tests that Range() with custom step (greater then one) generates
+// the expected sequence.
+TEST(RangeTest, IntRangeWithCustomStep) {
+  const ParamGenerator<int> gen = Range(0, 9, 3);
+  const int expected_values[] = {0, 3, 6};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that Range() with custom step (greater then one) generates
+// the expected sequence when the last element does not fall on the
+// upper range limit. Sequences generated by Range() must not have
+// elements beyond the range limits.
+TEST(RangeTest, IntRangeWithCustomStepOverUpperBound) {
+  const ParamGenerator<int> gen = Range(0, 4, 3);
+  const int expected_values[] = {0, 3};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Verifies that Range works with user-defined types that define
+// copy constructor, operator=(), operator+(), and operator<().
+class DogAdder {
+ public:
+  explicit DogAdder(const char* a_value) : value_(a_value) {}
+  DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {}
+
+  DogAdder operator=(const DogAdder& other) {
+    if (this != &other)
+      value_ = other.value_;
+    return *this;
+  }
+  DogAdder operator+(const DogAdder& other) const {
+    Message msg;
+    msg << value_.c_str() << other.value_.c_str();
+    return DogAdder(msg.GetString().c_str());
+  }
+  bool operator<(const DogAdder& other) const {
+    return value_ < other.value_;
+  }
+  const std::string& value() const { return value_; }
+
+ private:
+  std::string value_;
+};
+
+TEST(RangeTest, WorksWithACustomType) {
+  const ParamGenerator<DogAdder> gen =
+      Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog"));
+  ParamGenerator<DogAdder>::iterator it = gen.begin();
+
+  ASSERT_FALSE(it == gen.end());
+  EXPECT_STREQ("cat", it->value().c_str());
+
+  ASSERT_FALSE(++it == gen.end());
+  EXPECT_STREQ("catdog", it->value().c_str());
+
+  EXPECT_TRUE(++it == gen.end());
+}
+
+class IntWrapper {
+ public:
+  explicit IntWrapper(int a_value) : value_(a_value) {}
+  IntWrapper(const IntWrapper& other) : value_(other.value_) {}
+
+  IntWrapper operator=(const IntWrapper& other) {
+    value_ = other.value_;
+    return *this;
+  }
+  // operator+() adds a different type.
+  IntWrapper operator+(int other) const { return IntWrapper(value_ + other); }
+  bool operator<(const IntWrapper& other) const {
+    return value_ < other.value_;
+  }
+  int value() const { return value_; }
+
+ private:
+  int value_;
+};
+
+TEST(RangeTest, WorksWithACustomTypeWithDifferentIncrementType) {
+  const ParamGenerator<IntWrapper> gen = Range(IntWrapper(0), IntWrapper(2));
+  ParamGenerator<IntWrapper>::iterator it = gen.begin();
+
+  ASSERT_FALSE(it == gen.end());
+  EXPECT_EQ(0, it->value());
+
+  ASSERT_FALSE(++it == gen.end());
+  EXPECT_EQ(1, it->value());
+
+  EXPECT_TRUE(++it == gen.end());
+}
+
+// Tests that ValuesIn() with an array parameter generates
+// the expected sequence.
+TEST(ValuesInTest, ValuesInArray) {
+  int array[] = {3, 5, 8};
+  const ParamGenerator<int> gen = ValuesIn(array);
+  VerifyGenerator(gen, array);
+}
+
+// Tests that ValuesIn() with a const array parameter generates
+// the expected sequence.
+TEST(ValuesInTest, ValuesInConstArray) {
+  const int array[] = {3, 5, 8};
+  const ParamGenerator<int> gen = ValuesIn(array);
+  VerifyGenerator(gen, array);
+}
+
+// Edge case. Tests that ValuesIn() with an array parameter containing a
+// single element generates the single element sequence.
+TEST(ValuesInTest, ValuesInSingleElementArray) {
+  int array[] = {42};
+  const ParamGenerator<int> gen = ValuesIn(array);
+  VerifyGenerator(gen, array);
+}
+
+// Tests that ValuesIn() generates the expected sequence for an STL
+// container (vector).
+TEST(ValuesInTest, ValuesInVector) {
+  typedef ::std::vector<int> ContainerType;
+  ContainerType values;
+  values.push_back(3);
+  values.push_back(5);
+  values.push_back(8);
+  const ParamGenerator<int> gen = ValuesIn(values);
+
+  const int expected_values[] = {3, 5, 8};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that ValuesIn() generates the expected sequence.
+TEST(ValuesInTest, ValuesInIteratorRange) {
+  typedef ::std::vector<int> ContainerType;
+  ContainerType values;
+  values.push_back(3);
+  values.push_back(5);
+  values.push_back(8);
+  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
+
+  const int expected_values[] = {3, 5, 8};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Edge case. Tests that ValuesIn() provided with an iterator range specifying a
+// single value generates a single-element sequence.
+TEST(ValuesInTest, ValuesInSingleElementIteratorRange) {
+  typedef ::std::vector<int> ContainerType;
+  ContainerType values;
+  values.push_back(42);
+  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
+
+  const int expected_values[] = {42};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Edge case. Tests that ValuesIn() provided with an empty iterator range
+// generates an empty sequence.
+TEST(ValuesInTest, ValuesInEmptyIteratorRange) {
+  typedef ::std::vector<int> ContainerType;
+  ContainerType values;
+  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
+
+  VerifyGeneratorIsEmpty(gen);
+}
+
+// Tests that the Values() generates the expected sequence.
+TEST(ValuesTest, ValuesWorks) {
+  const ParamGenerator<int> gen = Values(3, 5, 8);
+
+  const int expected_values[] = {3, 5, 8};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that Values() generates the expected sequences from elements of
+// different types convertible to ParamGenerator's parameter type.
+TEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) {
+  const ParamGenerator<double> gen = Values(3, 5.0f, 8.0);
+
+  const double expected_values[] = {3.0, 5.0, 8.0};
+  VerifyGenerator(gen, expected_values);
+}
+
+TEST(ValuesTest, ValuesWorksForMaxLengthList) {
+  const ParamGenerator<int> gen = Values(
+      10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
+      110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
+      210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
+      310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
+      410, 420, 430, 440, 450, 460, 470, 480, 490, 500);
+
+  const int expected_values[] = {
+      10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
+      110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
+      210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
+      310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
+      410, 420, 430, 440, 450, 460, 470, 480, 490, 500};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Edge case test. Tests that single-parameter Values() generates the sequence
+// with the single value.
+TEST(ValuesTest, ValuesWithSingleParameter) {
+  const ParamGenerator<int> gen = Values(42);
+
+  const int expected_values[] = {42};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that Bool() generates sequence (false, true).
+TEST(BoolTest, BoolWorks) {
+  const ParamGenerator<bool> gen = Bool();
+
+  const bool expected_values[] = {false, true};
+  VerifyGenerator(gen, expected_values);
+}
+
+# if GTEST_HAS_COMBINE
+
+// Tests that Combine() with two parameters generates the expected sequence.
+TEST(CombineTest, CombineWithTwoParameters) {
+  const char* foo = "foo";
+  const char* bar = "bar";
+  const ParamGenerator<tuple<const char*, int> > gen =
+      Combine(Values(foo, bar), Values(3, 4));
+
+  tuple<const char*, int> expected_values[] = {
+    make_tuple(foo, 3), make_tuple(foo, 4),
+    make_tuple(bar, 3), make_tuple(bar, 4)};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that Combine() with three parameters generates the expected sequence.
+TEST(CombineTest, CombineWithThreeParameters) {
+  const ParamGenerator<tuple<int, int, int> > gen = Combine(Values(0, 1),
+                                                            Values(3, 4),
+                                                            Values(5, 6));
+  tuple<int, int, int> expected_values[] = {
+    make_tuple(0, 3, 5), make_tuple(0, 3, 6),
+    make_tuple(0, 4, 5), make_tuple(0, 4, 6),
+    make_tuple(1, 3, 5), make_tuple(1, 3, 6),
+    make_tuple(1, 4, 5), make_tuple(1, 4, 6)};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that the Combine() with the first parameter generating a single value
+// sequence generates a sequence with the number of elements equal to the
+// number of elements in the sequence generated by the second parameter.
+TEST(CombineTest, CombineWithFirstParameterSingleValue) {
+  const ParamGenerator<tuple<int, int> > gen = Combine(Values(42),
+                                                       Values(0, 1));
+
+  tuple<int, int> expected_values[] = {make_tuple(42, 0), make_tuple(42, 1)};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that the Combine() with the second parameter generating a single value
+// sequence generates a sequence with the number of elements equal to the
+// number of elements in the sequence generated by the first parameter.
+TEST(CombineTest, CombineWithSecondParameterSingleValue) {
+  const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),
+                                                       Values(42));
+
+  tuple<int, int> expected_values[] = {make_tuple(0, 42), make_tuple(1, 42)};
+  VerifyGenerator(gen, expected_values);
+}
+
+// Tests that when the first parameter produces an empty sequence,
+// Combine() produces an empty sequence, too.
+TEST(CombineTest, CombineWithFirstParameterEmptyRange) {
+  const ParamGenerator<tuple<int, int> > gen = Combine(Range(0, 0),
+                                                       Values(0, 1));
+  VerifyGeneratorIsEmpty(gen);
+}
+
+// Tests that when the second parameter produces an empty sequence,
+// Combine() produces an empty sequence, too.
+TEST(CombineTest, CombineWithSecondParameterEmptyRange) {
+  const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),
+                                                       Range(1, 1));
+  VerifyGeneratorIsEmpty(gen);
+}
+
+// Edge case. Tests that combine works with the maximum number
+// of parameters supported by Google Test (currently 10).
+TEST(CombineTest, CombineWithMaxNumberOfParameters) {
+  const char* foo = "foo";
+  const char* bar = "bar";
+  const ParamGenerator<tuple<const char*, int, int, int, int, int, int, int,
+                             int, int> > gen = Combine(Values(foo, bar),
+                                                       Values(1), Values(2),
+                                                       Values(3), Values(4),
+                                                       Values(5), Values(6),
+                                                       Values(7), Values(8),
+                                                       Values(9));
+
+  tuple<const char*, int, int, int, int, int, int, int, int, int>
+      expected_values[] = {make_tuple(foo, 1, 2, 3, 4, 5, 6, 7, 8, 9),
+                           make_tuple(bar, 1, 2, 3, 4, 5, 6, 7, 8, 9)};
+  VerifyGenerator(gen, expected_values);
+}
+
+# endif  // GTEST_HAS_COMBINE
+
+// Tests that an generator produces correct sequence after being
+// assigned from another generator.
+TEST(ParamGeneratorTest, AssignmentWorks) {
+  ParamGenerator<int> gen = Values(1, 2);
+  const ParamGenerator<int> gen2 = Values(3, 4);
+  gen = gen2;
+
+  const int expected_values[] = {3, 4};
+  VerifyGenerator(gen, expected_values);
+}
+
+// This test verifies that the tests are expanded and run as specified:
+// one test per element from the sequence produced by the generator
+// specified in INSTANTIATE_TEST_CASE_P. It also verifies that the test's
+// fixture constructor, SetUp(), and TearDown() have run and have been
+// supplied with the correct parameters.
+
+// The use of environment object allows detection of the case where no test
+// case functionality is run at all. In this case TestCaseTearDown will not
+// be able to detect missing tests, naturally.
+template <int kExpectedCalls>
+class TestGenerationEnvironment : public ::testing::Environment {
+ public:
+  static TestGenerationEnvironment* Instance() {
+    static TestGenerationEnvironment* instance = new TestGenerationEnvironment;
+    return instance;
+  }
+
+  void FixtureConstructorExecuted() { fixture_constructor_count_++; }
+  void SetUpExecuted() { set_up_count_++; }
+  void TearDownExecuted() { tear_down_count_++; }
+  void TestBodyExecuted() { test_body_count_++; }
+
+  virtual void TearDown() {
+    // If all MultipleTestGenerationTest tests have been de-selected
+    // by the filter flag, the following checks make no sense.
+    bool perform_check = false;
+
+    for (int i = 0; i < kExpectedCalls; ++i) {
+      Message msg;
+      msg << "TestsExpandedAndRun/" << i;
+      if (UnitTestOptions::FilterMatchesTest(
+             "TestExpansionModule/MultipleTestGenerationTest",
+              msg.GetString().c_str())) {
+        perform_check = true;
+      }
+    }
+    if (perform_check) {
+      EXPECT_EQ(kExpectedCalls, fixture_constructor_count_)
+          << "Fixture constructor of ParamTestGenerationTest test case "
+          << "has not been run as expected.";
+      EXPECT_EQ(kExpectedCalls, set_up_count_)
+          << "Fixture SetUp method of ParamTestGenerationTest test case "
+          << "has not been run as expected.";
+      EXPECT_EQ(kExpectedCalls, tear_down_count_)
+          << "Fixture TearDown method of ParamTestGenerationTest test case "
+          << "has not been run as expected.";
+      EXPECT_EQ(kExpectedCalls, test_body_count_)
+          << "Test in ParamTestGenerationTest test case "
+          << "has not been run as expected.";
+    }
+  }
+
+ private:
+  TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0),
+                                tear_down_count_(0), test_body_count_(0) {}
+
+  int fixture_constructor_count_;
+  int set_up_count_;
+  int tear_down_count_;
+  int test_body_count_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment);
+};
+
+const int test_generation_params[] = {36, 42, 72};
+
+class TestGenerationTest : public TestWithParam<int> {
+ public:
+  enum {
+    PARAMETER_COUNT =
+        sizeof(test_generation_params)/sizeof(test_generation_params[0])
+  };
+
+  typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment;
+
+  TestGenerationTest() {
+    Environment::Instance()->FixtureConstructorExecuted();
+    current_parameter_ = GetParam();
+  }
+  virtual void SetUp() {
+    Environment::Instance()->SetUpExecuted();
+    EXPECT_EQ(current_parameter_, GetParam());
+  }
+  virtual void TearDown() {
+    Environment::Instance()->TearDownExecuted();
+    EXPECT_EQ(current_parameter_, GetParam());
+  }
+
+  static void SetUpTestCase() {
+    bool all_tests_in_test_case_selected = true;
+
+    for (int i = 0; i < PARAMETER_COUNT; ++i) {
+      Message test_name;
+      test_name << "TestsExpandedAndRun/" << i;
+      if ( !UnitTestOptions::FilterMatchesTest(
+                "TestExpansionModule/MultipleTestGenerationTest",
+                test_name.GetString())) {
+        all_tests_in_test_case_selected = false;
+      }
+    }
+    EXPECT_TRUE(all_tests_in_test_case_selected)
+        << "When running the TestGenerationTest test case all of its tests\n"
+        << "must be selected by the filter flag for the test case to pass.\n"
+        << "If not all of them are enabled, we can't reliably conclude\n"
+        << "that the correct number of tests have been generated.";
+
+    collected_parameters_.clear();
+  }
+
+  static void TearDownTestCase() {
+    vector<int> expected_values(test_generation_params,
+                                test_generation_params + PARAMETER_COUNT);
+    // Test execution order is not guaranteed by Google Test,
+    // so the order of values in collected_parameters_ can be
+    // different and we have to sort to compare.
+    sort(expected_values.begin(), expected_values.end());
+    sort(collected_parameters_.begin(), collected_parameters_.end());
+
+    EXPECT_TRUE(collected_parameters_ == expected_values);
+  }
+
+ protected:
+  int current_parameter_;
+  static vector<int> collected_parameters_;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest);
+};
+vector<int> TestGenerationTest::collected_parameters_;
+
+TEST_P(TestGenerationTest, TestsExpandedAndRun) {
+  Environment::Instance()->TestBodyExecuted();
+  EXPECT_EQ(current_parameter_, GetParam());
+  collected_parameters_.push_back(GetParam());
+}
+INSTANTIATE_TEST_CASE_P(TestExpansionModule, TestGenerationTest,
+                        ValuesIn(test_generation_params));
+
+// This test verifies that the element sequence (third parameter of
+// INSTANTIATE_TEST_CASE_P) is evaluated in InitGoogleTest() and neither at
+// the call site of INSTANTIATE_TEST_CASE_P nor in RUN_ALL_TESTS().  For
+// that, we declare param_value_ to be a static member of
+// GeneratorEvaluationTest and initialize it to 0.  We set it to 1 in
+// main(), just before invocation of InitGoogleTest().  After calling
+// InitGoogleTest(), we set the value to 2.  If the sequence is evaluated
+// before or after InitGoogleTest, INSTANTIATE_TEST_CASE_P will create a
+// test with parameter other than 1, and the test body will fail the
+// assertion.
+class GeneratorEvaluationTest : public TestWithParam<int> {
+ public:
+  static int param_value() { return param_value_; }
+  static void set_param_value(int param_value) { param_value_ = param_value; }
+
+ private:
+  static int param_value_;
+};
+int GeneratorEvaluationTest::param_value_ = 0;
+
+TEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) {
+  EXPECT_EQ(1, GetParam());
+}
+INSTANTIATE_TEST_CASE_P(GenEvalModule,
+                        GeneratorEvaluationTest,
+                        Values(GeneratorEvaluationTest::param_value()));
+
+// Tests that generators defined in a different translation unit are
+// functional. Generator extern_gen is defined in gtest-param-test_test2.cc.
+extern ParamGenerator<int> extern_gen;
+class ExternalGeneratorTest : public TestWithParam<int> {};
+TEST_P(ExternalGeneratorTest, ExternalGenerator) {
+  // Sequence produced by extern_gen contains only a single value
+  // which we verify here.
+  EXPECT_EQ(GetParam(), 33);
+}
+INSTANTIATE_TEST_CASE_P(ExternalGeneratorModule,
+                        ExternalGeneratorTest,
+                        extern_gen);
+
+// Tests that a parameterized test case can be defined in one translation
+// unit and instantiated in another. This test will be instantiated in
+// gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is
+// defined in gtest-param-test_test.h.
+TEST_P(ExternalInstantiationTest, IsMultipleOf33) {
+  EXPECT_EQ(0, GetParam() % 33);
+}
+
+// Tests that a parameterized test case can be instantiated with multiple
+// generators.
+class MultipleInstantiationTest : public TestWithParam<int> {};
+TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {
+}
+INSTANTIATE_TEST_CASE_P(Sequence1, MultipleInstantiationTest, Values(1, 2));
+INSTANTIATE_TEST_CASE_P(Sequence2, MultipleInstantiationTest, Range(3, 5));
+
+// Tests that a parameterized test case can be instantiated
+// in multiple translation units. This test will be instantiated
+// here and in gtest-param-test_test2.cc.
+// InstantiationInMultipleTranslationUnitsTest fixture class
+// is defined in gtest-param-test_test.h.
+TEST_P(InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42) {
+  EXPECT_EQ(0, GetParam() % 42);
+}
+INSTANTIATE_TEST_CASE_P(Sequence1,
+                        InstantiationInMultipleTranslaionUnitsTest,
+                        Values(42, 42*2));
+
+// Tests that each iteration of parameterized test runs in a separate test
+// object.
+class SeparateInstanceTest : public TestWithParam<int> {
+ public:
+  SeparateInstanceTest() : count_(0) {}
+
+  static void TearDownTestCase() {
+    EXPECT_GE(global_count_, 2)
+        << "If some (but not all) SeparateInstanceTest tests have been "
+        << "filtered out this test will fail. Make sure that all "
+        << "GeneratorEvaluationTest are selected or de-selected together "
+        << "by the test filter.";
+  }
+
+ protected:
+  int count_;
+  static int global_count_;
+};
+int SeparateInstanceTest::global_count_ = 0;
+
+TEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) {
+  EXPECT_EQ(0, count_++);
+  global_count_++;
+}
+INSTANTIATE_TEST_CASE_P(FourElemSequence, SeparateInstanceTest, Range(1, 4));
+
+// Tests that all instantiations of a test have named appropriately. Test
+// defined with TEST_P(TestCaseName, TestName) and instantiated with
+// INSTANTIATE_TEST_CASE_P(SequenceName, TestCaseName, generator) must be named
+// SequenceName/TestCaseName.TestName/i, where i is the 0-based index of the
+// sequence element used to instantiate the test.
+class NamingTest : public TestWithParam<int> {};
+
+TEST_P(NamingTest, TestsReportCorrectNamesAndParameters) {
+  const ::testing::TestInfo* const test_info =
+     ::testing::UnitTest::GetInstance()->current_test_info();
+
+  EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_case_name());
+
+  Message index_stream;
+  index_stream << "TestsReportCorrectNamesAndParameters/" << GetParam();
+  EXPECT_STREQ(index_stream.GetString().c_str(), test_info->name());
+
+  EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
+}
+
+INSTANTIATE_TEST_CASE_P(ZeroToFiveSequence, NamingTest, Range(0, 5));
+
+// Tests that user supplied custom parameter names are working correctly.
+// Runs the test with a builtin helper method which uses PrintToString,
+// as well as a custom function and custom functor to ensure all possible
+// uses work correctly.
+class CustomFunctorNamingTest : public TestWithParam<std::string> {};
+TEST_P(CustomFunctorNamingTest, CustomTestNames) {}
+
+struct CustomParamNameFunctor {
+  std::string operator()(const ::testing::TestParamInfo<std::string>& info) {
+    return info.param;
+  }
+};
+
+INSTANTIATE_TEST_CASE_P(CustomParamNameFunctor,
+                        CustomFunctorNamingTest,
+                        Values(std::string("FunctorName")),
+                        CustomParamNameFunctor());
+
+INSTANTIATE_TEST_CASE_P(AllAllowedCharacters,
+                        CustomFunctorNamingTest,
+                        Values("abcdefghijklmnopqrstuvwxyz",
+                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+                               "01234567890_"),
+                        CustomParamNameFunctor());
+
+inline std::string CustomParamNameFunction(
+    const ::testing::TestParamInfo<std::string>& info) {
+  return info.param;
+}
+
+class CustomFunctionNamingTest : public TestWithParam<std::string> {};
+TEST_P(CustomFunctionNamingTest, CustomTestNames) {}
+
+INSTANTIATE_TEST_CASE_P(CustomParamNameFunction,
+                        CustomFunctionNamingTest,
+                        Values(std::string("FunctionName")),
+                        CustomParamNameFunction);
+
+#if GTEST_LANG_CXX11
+
+// Test custom naming with a lambda
+
+class CustomLambdaNamingTest : public TestWithParam<std::string> {};
+TEST_P(CustomLambdaNamingTest, CustomTestNames) {}
+
+INSTANTIATE_TEST_CASE_P(CustomParamNameLambda,
+                        CustomLambdaNamingTest,
+                        Values(std::string("LambdaName")),
+                        [](const ::testing::TestParamInfo<std::string>& info) {
+                          return info.param;
+                        });
+
+#endif  // GTEST_LANG_CXX11
+
+TEST(CustomNamingTest, CheckNameRegistry) {
+  ::testing::UnitTest* unit_test = ::testing::UnitTest::GetInstance();
+  std::set<std::string> test_names;
+  for (int case_num = 0;
+       case_num < unit_test->total_test_case_count();
+       ++case_num) {
+    const ::testing::TestCase* test_case = unit_test->GetTestCase(case_num);
+    for (int test_num = 0;
+         test_num < test_case->total_test_count();
+         ++test_num) {
+      const ::testing::TestInfo* test_info = test_case->GetTestInfo(test_num);
+      test_names.insert(std::string(test_info->name()));
+    }
+  }
+  EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctorName"));
+  EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctionName"));
+#if GTEST_LANG_CXX11
+  EXPECT_EQ(1u, test_names.count("CustomTestNames/LambdaName"));
+#endif  // GTEST_LANG_CXX11
+}
+
+// Test a numeric name to ensure PrintToStringParamName works correctly.
+
+class CustomIntegerNamingTest : public TestWithParam<int> {};
+
+TEST_P(CustomIntegerNamingTest, TestsReportCorrectNames) {
+  const ::testing::TestInfo* const test_info =
+     ::testing::UnitTest::GetInstance()->current_test_info();
+  Message test_name_stream;
+  test_name_stream << "TestsReportCorrectNames/" << GetParam();
+  EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
+}
+
+INSTANTIATE_TEST_CASE_P(PrintToString,
+                        CustomIntegerNamingTest,
+                        Range(0, 5),
+                        ::testing::PrintToStringParamName());
+
+// Test a custom struct with PrintToString.
+
+struct CustomStruct {
+  explicit CustomStruct(int value) : x(value) {}
+  int x;
+};
+
+std::ostream& operator<<(std::ostream& stream, const CustomStruct& val) {
+  stream << val.x;
+  return stream;
+}
+
+class CustomStructNamingTest : public TestWithParam<CustomStruct> {};
+
+TEST_P(CustomStructNamingTest, TestsReportCorrectNames) {
+  const ::testing::TestInfo* const test_info =
+     ::testing::UnitTest::GetInstance()->current_test_info();
+  Message test_name_stream;
+  test_name_stream << "TestsReportCorrectNames/" << GetParam();
+  EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
+}
+
+INSTANTIATE_TEST_CASE_P(PrintToString,
+                        CustomStructNamingTest,
+                        Values(CustomStruct(0), CustomStruct(1)),
+                        ::testing::PrintToStringParamName());
+
+// Test that using a stateful parameter naming function works as expected.
+
+struct StatefulNamingFunctor {
+  StatefulNamingFunctor() : sum(0) {}
+  std::string operator()(const ::testing::TestParamInfo<int>& info) {
+    int value = info.param + sum;
+    sum += info.param;
+    return ::testing::PrintToString(value);
+  }
+  int sum;
+};
+
+class StatefulNamingTest : public ::testing::TestWithParam<int> {
+ protected:
+  StatefulNamingTest() : sum_(0) {}
+  int sum_;
+};
+
+TEST_P(StatefulNamingTest, TestsReportCorrectNames) {
+  const ::testing::TestInfo* const test_info =
+     ::testing::UnitTest::GetInstance()->current_test_info();
+  sum_ += GetParam();
+  Message test_name_stream;
+  test_name_stream << "TestsReportCorrectNames/" << sum_;
+  EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
+}
+
+INSTANTIATE_TEST_CASE_P(StatefulNamingFunctor,
+                        StatefulNamingTest,
+                        Range(0, 5),
+                        StatefulNamingFunctor());
+
+// Class that cannot be streamed into an ostream.  It needs to be copyable
+// (and, in case of MSVC, also assignable) in order to be a test parameter
+// type.  Its default copy constructor and assignment operator do exactly
+// what we need.
+class Unstreamable {
+ public:
+  explicit Unstreamable(int value) : value_(value) {}
+
+ private:
+  int value_;
+};
+
+class CommentTest : public TestWithParam<Unstreamable> {};
+
+TEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) {
+  const ::testing::TestInfo* const test_info =
+     ::testing::UnitTest::GetInstance()->current_test_info();
+
+  EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
+}
+
+INSTANTIATE_TEST_CASE_P(InstantiationWithComments,
+                        CommentTest,
+                        Values(Unstreamable(1)));
+
+// Verify that we can create a hierarchy of test fixtures, where the base
+// class fixture is not parameterized and the derived class is. In this case
+// ParameterizedDerivedTest inherits from NonParameterizedBaseTest.  We
+// perform simple tests on both.
+class NonParameterizedBaseTest : public ::testing::Test {
+ public:
+  NonParameterizedBaseTest() : n_(17) { }
+ protected:
+  int n_;
+};
+
+class ParameterizedDerivedTest : public NonParameterizedBaseTest,
+                                 public ::testing::WithParamInterface<int> {
+ protected:
+  ParameterizedDerivedTest() : count_(0) { }
+  int count_;
+  static int global_count_;
+};
+
+int ParameterizedDerivedTest::global_count_ = 0;
+
+TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) {
+  EXPECT_EQ(17, n_);
+}
+
+TEST_P(ParameterizedDerivedTest, SeesSequence) {
+  EXPECT_EQ(17, n_);
+  EXPECT_EQ(0, count_++);
+  EXPECT_EQ(GetParam(), global_count_++);
+}
+
+class ParameterizedDeathTest : public ::testing::TestWithParam<int> { };
+
+TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) {
+  EXPECT_DEATH_IF_SUPPORTED(GetParam(),
+                            ".* value-parameterized test .*");
+}
+
+INSTANTIATE_TEST_CASE_P(RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5));
+
+#endif  // GTEST_HAS_PARAM_TEST
+
+TEST(CompileTest, CombineIsDefinedOnlyWhenGtestHasParamTestIsDefined) {
+#if GTEST_HAS_COMBINE && !GTEST_HAS_PARAM_TEST
+  FAIL() << "GTEST_HAS_COMBINE is defined while GTEST_HAS_PARAM_TEST is not\n"
+#endif
+}
+
+int main(int argc, char **argv) {
+#if GTEST_HAS_PARAM_TEST
+  // Used in TestGenerationTest test case.
+  AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
+  // Used in GeneratorEvaluationTest test case. Tests that the updated value
+  // will be picked up for instantiating tests in GeneratorEvaluationTest.
+  GeneratorEvaluationTest::set_param_value(1);
+#endif  // GTEST_HAS_PARAM_TEST
+
+  ::testing::InitGoogleTest(&argc, argv);
+
+#if GTEST_HAS_PARAM_TEST
+  // Used in GeneratorEvaluationTest test case. Tests that value updated
+  // here will NOT be used for instantiating tests in
+  // GeneratorEvaluationTest.
+  GeneratorEvaluationTest::set_param_value(2);
+#endif  // GTEST_HAS_PARAM_TEST
+
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.h b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.h
new file mode 100644
index 00000000..26ea122b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.h
@@ -0,0 +1,57 @@
+// 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.
+//
+// Authors: vladl@google.com (Vlad Losev)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This header file provides classes and functions used internally
+// for testing Google Test itself.
+
+#ifndef GTEST_TEST_GTEST_PARAM_TEST_TEST_H_
+#define GTEST_TEST_GTEST_PARAM_TEST_TEST_H_
+
+#include "gtest/gtest.h"
+
+#if GTEST_HAS_PARAM_TEST
+
+// Test fixture for testing definition and instantiation of a test
+// in separate translation units.
+class ExternalInstantiationTest : public ::testing::TestWithParam<int> {
+};
+
+// Test fixture for testing instantiation of a test in multiple
+// translation units.
+class InstantiationInMultipleTranslaionUnitsTest
+    : public ::testing::TestWithParam<int> {
+};
+
+#endif  // GTEST_HAS_PARAM_TEST
+
+#endif  // GTEST_TEST_GTEST_PARAM_TEST_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-port_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-port_test.cc
new file mode 100644
index 00000000..c5067a40
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-port_test.cc
@@ -0,0 +1,1311 @@
+// 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.
+//
+// Authors: vladl@google.com (Vlad Losev), wan@google.com (Zhanyong Wan)
+//
+// This file tests the internal cross-platform support utilities.
+
+#include "gtest/internal/gtest-port.h"
+
+#include <stdio.h>
+
+#if GTEST_OS_MAC
+# include <time.h>
+#endif  // GTEST_OS_MAC
+
+#include <list>
+#include <utility>  // For std::pair and std::make_pair.
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "gtest/gtest-spi.h"
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+using std::make_pair;
+using std::pair;
+
+namespace testing {
+namespace internal {
+
+TEST(IsXDigitTest, WorksForNarrowAscii) {
+  EXPECT_TRUE(IsXDigit('0'));
+  EXPECT_TRUE(IsXDigit('9'));
+  EXPECT_TRUE(IsXDigit('A'));
+  EXPECT_TRUE(IsXDigit('F'));
+  EXPECT_TRUE(IsXDigit('a'));
+  EXPECT_TRUE(IsXDigit('f'));
+
+  EXPECT_FALSE(IsXDigit('-'));
+  EXPECT_FALSE(IsXDigit('g'));
+  EXPECT_FALSE(IsXDigit('G'));
+}
+
+TEST(IsXDigitTest, ReturnsFalseForNarrowNonAscii) {
+  EXPECT_FALSE(IsXDigit('\x80'));
+  EXPECT_FALSE(IsXDigit(static_cast<char>('0' | '\x80')));
+}
+
+TEST(IsXDigitTest, WorksForWideAscii) {
+  EXPECT_TRUE(IsXDigit(L'0'));
+  EXPECT_TRUE(IsXDigit(L'9'));
+  EXPECT_TRUE(IsXDigit(L'A'));
+  EXPECT_TRUE(IsXDigit(L'F'));
+  EXPECT_TRUE(IsXDigit(L'a'));
+  EXPECT_TRUE(IsXDigit(L'f'));
+
+  EXPECT_FALSE(IsXDigit(L'-'));
+  EXPECT_FALSE(IsXDigit(L'g'));
+  EXPECT_FALSE(IsXDigit(L'G'));
+}
+
+TEST(IsXDigitTest, ReturnsFalseForWideNonAscii) {
+  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(0x80)));
+  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x80)));
+  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x100)));
+}
+
+class Base {
+ public:
+  // Copy constructor and assignment operator do exactly what we need, so we
+  // use them.
+  Base() : member_(0) {}
+  explicit Base(int n) : member_(n) {}
+  virtual ~Base() {}
+  int member() { return member_; }
+
+ private:
+  int member_;
+};
+
+class Derived : public Base {
+ public:
+  explicit Derived(int n) : Base(n) {}
+};
+
+TEST(ImplicitCastTest, ConvertsPointers) {
+  Derived derived(0);
+  EXPECT_TRUE(&derived == ::testing::internal::ImplicitCast_<Base*>(&derived));
+}
+
+TEST(ImplicitCastTest, CanUseInheritance) {
+  Derived derived(1);
+  Base base = ::testing::internal::ImplicitCast_<Base>(derived);
+  EXPECT_EQ(derived.member(), base.member());
+}
+
+class Castable {
+ public:
+  explicit Castable(bool* converted) : converted_(converted) {}
+  operator Base() {
+    *converted_ = true;
+    return Base();
+  }
+
+ private:
+  bool* converted_;
+};
+
+TEST(ImplicitCastTest, CanUseNonConstCastOperator) {
+  bool converted = false;
+  Castable castable(&converted);
+  Base base = ::testing::internal::ImplicitCast_<Base>(castable);
+  EXPECT_TRUE(converted);
+}
+
+class ConstCastable {
+ public:
+  explicit ConstCastable(bool* converted) : converted_(converted) {}
+  operator Base() const {
+    *converted_ = true;
+    return Base();
+  }
+
+ private:
+  bool* converted_;
+};
+
+TEST(ImplicitCastTest, CanUseConstCastOperatorOnConstValues) {
+  bool converted = false;
+  const ConstCastable const_castable(&converted);
+  Base base = ::testing::internal::ImplicitCast_<Base>(const_castable);
+  EXPECT_TRUE(converted);
+}
+
+class ConstAndNonConstCastable {
+ public:
+  ConstAndNonConstCastable(bool* converted, bool* const_converted)
+      : converted_(converted), const_converted_(const_converted) {}
+  operator Base() {
+    *converted_ = true;
+    return Base();
+  }
+  operator Base() const {
+    *const_converted_ = true;
+    return Base();
+  }
+
+ private:
+  bool* converted_;
+  bool* const_converted_;
+};
+
+TEST(ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately) {
+  bool converted = false;
+  bool const_converted = false;
+  ConstAndNonConstCastable castable(&converted, &const_converted);
+  Base base = ::testing::internal::ImplicitCast_<Base>(castable);
+  EXPECT_TRUE(converted);
+  EXPECT_FALSE(const_converted);
+
+  converted = false;
+  const_converted = false;
+  const ConstAndNonConstCastable const_castable(&converted, &const_converted);
+  base = ::testing::internal::ImplicitCast_<Base>(const_castable);
+  EXPECT_FALSE(converted);
+  EXPECT_TRUE(const_converted);
+}
+
+class To {
+ public:
+  To(bool* converted) { *converted = true; }  // NOLINT
+};
+
+TEST(ImplicitCastTest, CanUseImplicitConstructor) {
+  bool converted = false;
+  To to = ::testing::internal::ImplicitCast_<To>(&converted);
+  (void)to;
+  EXPECT_TRUE(converted);
+}
+
+TEST(IteratorTraitsTest, WorksForSTLContainerIterators) {
+  StaticAssertTypeEq<int,
+      IteratorTraits< ::std::vector<int>::const_iterator>::value_type>();
+  StaticAssertTypeEq<bool,
+      IteratorTraits< ::std::list<bool>::iterator>::value_type>();
+}
+
+TEST(IteratorTraitsTest, WorksForPointerToNonConst) {
+  StaticAssertTypeEq<char, IteratorTraits<char*>::value_type>();
+  StaticAssertTypeEq<const void*, IteratorTraits<const void**>::value_type>();
+}
+
+TEST(IteratorTraitsTest, WorksForPointerToConst) {
+  StaticAssertTypeEq<char, IteratorTraits<const char*>::value_type>();
+  StaticAssertTypeEq<const void*,
+      IteratorTraits<const void* const*>::value_type>();
+}
+
+// Tests that the element_type typedef is available in scoped_ptr and refers
+// to the parameter type.
+TEST(ScopedPtrTest, DefinesElementType) {
+  StaticAssertTypeEq<int, ::testing::internal::scoped_ptr<int>::element_type>();
+}
+
+// TODO(vladl@google.com): Implement THE REST of scoped_ptr tests.
+
+TEST(GtestCheckSyntaxTest, BehavesLikeASingleStatement) {
+  if (AlwaysFalse())
+    GTEST_CHECK_(false) << "This should never be executed; "
+                           "It's a compilation test only.";
+
+  if (AlwaysTrue())
+    GTEST_CHECK_(true);
+  else
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    ;  // NOLINT
+  else
+    GTEST_CHECK_(true) << "";
+}
+
+TEST(GtestCheckSyntaxTest, WorksWithSwitch) {
+  switch (0) {
+    case 1:
+      break;
+    default:
+      GTEST_CHECK_(true);
+  }
+
+  switch (0)
+    case 0:
+      GTEST_CHECK_(true) << "Check failed in switch case";
+}
+
+// Verifies behavior of FormatFileLocation.
+TEST(FormatFileLocationTest, FormatsFileLocation) {
+  EXPECT_PRED_FORMAT2(IsSubstring, "foo.cc", FormatFileLocation("foo.cc", 42));
+  EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation("foo.cc", 42));
+}
+
+TEST(FormatFileLocationTest, FormatsUnknownFile) {
+  EXPECT_PRED_FORMAT2(
+      IsSubstring, "unknown file", FormatFileLocation(NULL, 42));
+  EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation(NULL, 42));
+}
+
+TEST(FormatFileLocationTest, FormatsUknownLine) {
+  EXPECT_EQ("foo.cc:", FormatFileLocation("foo.cc", -1));
+}
+
+TEST(FormatFileLocationTest, FormatsUknownFileAndLine) {
+  EXPECT_EQ("unknown file:", FormatFileLocation(NULL, -1));
+}
+
+// Verifies behavior of FormatCompilerIndependentFileLocation.
+TEST(FormatCompilerIndependentFileLocationTest, FormatsFileLocation) {
+  EXPECT_EQ("foo.cc:42", FormatCompilerIndependentFileLocation("foo.cc", 42));
+}
+
+TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFile) {
+  EXPECT_EQ("unknown file:42",
+            FormatCompilerIndependentFileLocation(NULL, 42));
+}
+
+TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownLine) {
+  EXPECT_EQ("foo.cc", FormatCompilerIndependentFileLocation("foo.cc", -1));
+}
+
+TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine) {
+  EXPECT_EQ("unknown file", FormatCompilerIndependentFileLocation(NULL, -1));
+}
+
+#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX
+void* ThreadFunc(void* data) {
+  internal::Mutex* mutex = static_cast<internal::Mutex*>(data);
+  mutex->Lock();
+  mutex->Unlock();
+  return NULL;
+}
+
+TEST(GetThreadCountTest, ReturnsCorrectValue) {
+  const size_t starting_count = GetThreadCount();
+  pthread_t       thread_id;
+
+  internal::Mutex mutex;
+  {
+    internal::MutexLock lock(&mutex);
+    pthread_attr_t  attr;
+    ASSERT_EQ(0, pthread_attr_init(&attr));
+    ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));
+
+    const int status = pthread_create(&thread_id, &attr, &ThreadFunc, &mutex);
+    ASSERT_EQ(0, pthread_attr_destroy(&attr));
+    ASSERT_EQ(0, status);
+    EXPECT_EQ(starting_count + 1, GetThreadCount());
+  }
+
+  void* dummy;
+  ASSERT_EQ(0, pthread_join(thread_id, &dummy));
+
+  // The OS may not immediately report the updated thread count after
+  // joining a thread, causing flakiness in this test. To counter that, we
+  // wait for up to .5 seconds for the OS to report the correct value.
+  for (int i = 0; i < 5; ++i) {
+    if (GetThreadCount() == starting_count)
+      break;
+
+    SleepMilliseconds(100);
+  }
+
+  EXPECT_EQ(starting_count, GetThreadCount());
+}
+#else
+TEST(GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads) {
+  EXPECT_EQ(0U, GetThreadCount());
+}
+#endif  // GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX
+
+TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
+  const bool a_false_condition = false;
+  const char regex[] =
+#ifdef _MSC_VER
+     "gtest-port_test\\.cc\\(\\d+\\):"
+#elif GTEST_USES_POSIX_RE
+     "gtest-port_test\\.cc:[0-9]+"
+#else
+     "gtest-port_test\\.cc:\\d+"
+#endif  // _MSC_VER
+     ".*a_false_condition.*Extra info.*";
+
+  EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(a_false_condition) << "Extra info",
+                            regex);
+}
+
+#if GTEST_HAS_DEATH_TEST
+
+TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {
+  EXPECT_EXIT({
+      GTEST_CHECK_(true) << "Extra info";
+      ::std::cerr << "Success\n";
+      exit(0); },
+      ::testing::ExitedWithCode(0), "Success");
+}
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Verifies that Google Test choose regular expression engine appropriate to
+// the platform. The test will produce compiler errors in case of failure.
+// For simplicity, we only cover the most important platforms here.
+TEST(RegexEngineSelectionTest, SelectsCorrectRegexEngine) {
+#if !GTEST_USES_PCRE
+# if GTEST_HAS_POSIX_RE
+
+  EXPECT_TRUE(GTEST_USES_POSIX_RE);
+
+# else
+
+  EXPECT_TRUE(GTEST_USES_SIMPLE_RE);
+
+# endif
+#endif  // !GTEST_USES_PCRE
+}
+
+#if GTEST_USES_POSIX_RE
+
+# if GTEST_HAS_TYPED_TEST
+
+template <typename Str>
+class RETest : public ::testing::Test {};
+
+// Defines StringTypes as the list of all string types that class RE
+// supports.
+typedef testing::Types<
+    ::std::string,
+#  if GTEST_HAS_GLOBAL_STRING
+    ::string,
+#  endif  // GTEST_HAS_GLOBAL_STRING
+    const char*> StringTypes;
+
+TYPED_TEST_CASE(RETest, StringTypes);
+
+// Tests RE's implicit constructors.
+TYPED_TEST(RETest, ImplicitConstructorWorks) {
+  const RE empty(TypeParam(""));
+  EXPECT_STREQ("", empty.pattern());
+
+  const RE simple(TypeParam("hello"));
+  EXPECT_STREQ("hello", simple.pattern());
+
+  const RE normal(TypeParam(".*(\\w+)"));
+  EXPECT_STREQ(".*(\\w+)", normal.pattern());
+}
+
+// Tests that RE's constructors reject invalid regular expressions.
+TYPED_TEST(RETest, RejectsInvalidRegex) {
+  EXPECT_NONFATAL_FAILURE({
+    const RE invalid(TypeParam("?"));
+  }, "\"?\" is not a valid POSIX Extended regular expression.");
+}
+
+// Tests RE::FullMatch().
+TYPED_TEST(RETest, FullMatchWorks) {
+  const RE empty(TypeParam(""));
+  EXPECT_TRUE(RE::FullMatch(TypeParam(""), empty));
+  EXPECT_FALSE(RE::FullMatch(TypeParam("a"), empty));
+
+  const RE re(TypeParam("a.*z"));
+  EXPECT_TRUE(RE::FullMatch(TypeParam("az"), re));
+  EXPECT_TRUE(RE::FullMatch(TypeParam("axyz"), re));
+  EXPECT_FALSE(RE::FullMatch(TypeParam("baz"), re));
+  EXPECT_FALSE(RE::FullMatch(TypeParam("azy"), re));
+}
+
+// Tests RE::PartialMatch().
+TYPED_TEST(RETest, PartialMatchWorks) {
+  const RE empty(TypeParam(""));
+  EXPECT_TRUE(RE::PartialMatch(TypeParam(""), empty));
+  EXPECT_TRUE(RE::PartialMatch(TypeParam("a"), empty));
+
+  const RE re(TypeParam("a.*z"));
+  EXPECT_TRUE(RE::PartialMatch(TypeParam("az"), re));
+  EXPECT_TRUE(RE::PartialMatch(TypeParam("axyz"), re));
+  EXPECT_TRUE(RE::PartialMatch(TypeParam("baz"), re));
+  EXPECT_TRUE(RE::PartialMatch(TypeParam("azy"), re));
+  EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re));
+}
+
+# endif  // GTEST_HAS_TYPED_TEST
+
+#elif GTEST_USES_SIMPLE_RE
+
+TEST(IsInSetTest, NulCharIsNotInAnySet) {
+  EXPECT_FALSE(IsInSet('\0', ""));
+  EXPECT_FALSE(IsInSet('\0', "\0"));
+  EXPECT_FALSE(IsInSet('\0', "a"));
+}
+
+TEST(IsInSetTest, WorksForNonNulChars) {
+  EXPECT_FALSE(IsInSet('a', "Ab"));
+  EXPECT_FALSE(IsInSet('c', ""));
+
+  EXPECT_TRUE(IsInSet('b', "bcd"));
+  EXPECT_TRUE(IsInSet('b', "ab"));
+}
+
+TEST(IsAsciiDigitTest, IsFalseForNonDigit) {
+  EXPECT_FALSE(IsAsciiDigit('\0'));
+  EXPECT_FALSE(IsAsciiDigit(' '));
+  EXPECT_FALSE(IsAsciiDigit('+'));
+  EXPECT_FALSE(IsAsciiDigit('-'));
+  EXPECT_FALSE(IsAsciiDigit('.'));
+  EXPECT_FALSE(IsAsciiDigit('a'));
+}
+
+TEST(IsAsciiDigitTest, IsTrueForDigit) {
+  EXPECT_TRUE(IsAsciiDigit('0'));
+  EXPECT_TRUE(IsAsciiDigit('1'));
+  EXPECT_TRUE(IsAsciiDigit('5'));
+  EXPECT_TRUE(IsAsciiDigit('9'));
+}
+
+TEST(IsAsciiPunctTest, IsFalseForNonPunct) {
+  EXPECT_FALSE(IsAsciiPunct('\0'));
+  EXPECT_FALSE(IsAsciiPunct(' '));
+  EXPECT_FALSE(IsAsciiPunct('\n'));
+  EXPECT_FALSE(IsAsciiPunct('a'));
+  EXPECT_FALSE(IsAsciiPunct('0'));
+}
+
+TEST(IsAsciiPunctTest, IsTrueForPunct) {
+  for (const char* p = "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"; *p; p++) {
+    EXPECT_PRED1(IsAsciiPunct, *p);
+  }
+}
+
+TEST(IsRepeatTest, IsFalseForNonRepeatChar) {
+  EXPECT_FALSE(IsRepeat('\0'));
+  EXPECT_FALSE(IsRepeat(' '));
+  EXPECT_FALSE(IsRepeat('a'));
+  EXPECT_FALSE(IsRepeat('1'));
+  EXPECT_FALSE(IsRepeat('-'));
+}
+
+TEST(IsRepeatTest, IsTrueForRepeatChar) {
+  EXPECT_TRUE(IsRepeat('?'));
+  EXPECT_TRUE(IsRepeat('*'));
+  EXPECT_TRUE(IsRepeat('+'));
+}
+
+TEST(IsAsciiWhiteSpaceTest, IsFalseForNonWhiteSpace) {
+  EXPECT_FALSE(IsAsciiWhiteSpace('\0'));
+  EXPECT_FALSE(IsAsciiWhiteSpace('a'));
+  EXPECT_FALSE(IsAsciiWhiteSpace('1'));
+  EXPECT_FALSE(IsAsciiWhiteSpace('+'));
+  EXPECT_FALSE(IsAsciiWhiteSpace('_'));
+}
+
+TEST(IsAsciiWhiteSpaceTest, IsTrueForWhiteSpace) {
+  EXPECT_TRUE(IsAsciiWhiteSpace(' '));
+  EXPECT_TRUE(IsAsciiWhiteSpace('\n'));
+  EXPECT_TRUE(IsAsciiWhiteSpace('\r'));
+  EXPECT_TRUE(IsAsciiWhiteSpace('\t'));
+  EXPECT_TRUE(IsAsciiWhiteSpace('\v'));
+  EXPECT_TRUE(IsAsciiWhiteSpace('\f'));
+}
+
+TEST(IsAsciiWordCharTest, IsFalseForNonWordChar) {
+  EXPECT_FALSE(IsAsciiWordChar('\0'));
+  EXPECT_FALSE(IsAsciiWordChar('+'));
+  EXPECT_FALSE(IsAsciiWordChar('.'));
+  EXPECT_FALSE(IsAsciiWordChar(' '));
+  EXPECT_FALSE(IsAsciiWordChar('\n'));
+}
+
+TEST(IsAsciiWordCharTest, IsTrueForLetter) {
+  EXPECT_TRUE(IsAsciiWordChar('a'));
+  EXPECT_TRUE(IsAsciiWordChar('b'));
+  EXPECT_TRUE(IsAsciiWordChar('A'));
+  EXPECT_TRUE(IsAsciiWordChar('Z'));
+}
+
+TEST(IsAsciiWordCharTest, IsTrueForDigit) {
+  EXPECT_TRUE(IsAsciiWordChar('0'));
+  EXPECT_TRUE(IsAsciiWordChar('1'));
+  EXPECT_TRUE(IsAsciiWordChar('7'));
+  EXPECT_TRUE(IsAsciiWordChar('9'));
+}
+
+TEST(IsAsciiWordCharTest, IsTrueForUnderscore) {
+  EXPECT_TRUE(IsAsciiWordChar('_'));
+}
+
+TEST(IsValidEscapeTest, IsFalseForNonPrintable) {
+  EXPECT_FALSE(IsValidEscape('\0'));
+  EXPECT_FALSE(IsValidEscape('\007'));
+}
+
+TEST(IsValidEscapeTest, IsFalseForDigit) {
+  EXPECT_FALSE(IsValidEscape('0'));
+  EXPECT_FALSE(IsValidEscape('9'));
+}
+
+TEST(IsValidEscapeTest, IsFalseForWhiteSpace) {
+  EXPECT_FALSE(IsValidEscape(' '));
+  EXPECT_FALSE(IsValidEscape('\n'));
+}
+
+TEST(IsValidEscapeTest, IsFalseForSomeLetter) {
+  EXPECT_FALSE(IsValidEscape('a'));
+  EXPECT_FALSE(IsValidEscape('Z'));
+}
+
+TEST(IsValidEscapeTest, IsTrueForPunct) {
+  EXPECT_TRUE(IsValidEscape('.'));
+  EXPECT_TRUE(IsValidEscape('-'));
+  EXPECT_TRUE(IsValidEscape('^'));
+  EXPECT_TRUE(IsValidEscape('$'));
+  EXPECT_TRUE(IsValidEscape('('));
+  EXPECT_TRUE(IsValidEscape(']'));
+  EXPECT_TRUE(IsValidEscape('{'));
+  EXPECT_TRUE(IsValidEscape('|'));
+}
+
+TEST(IsValidEscapeTest, IsTrueForSomeLetter) {
+  EXPECT_TRUE(IsValidEscape('d'));
+  EXPECT_TRUE(IsValidEscape('D'));
+  EXPECT_TRUE(IsValidEscape('s'));
+  EXPECT_TRUE(IsValidEscape('S'));
+  EXPECT_TRUE(IsValidEscape('w'));
+  EXPECT_TRUE(IsValidEscape('W'));
+}
+
+TEST(AtomMatchesCharTest, EscapedPunct) {
+  EXPECT_FALSE(AtomMatchesChar(true, '\\', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, '\\', ' '));
+  EXPECT_FALSE(AtomMatchesChar(true, '_', '.'));
+  EXPECT_FALSE(AtomMatchesChar(true, '.', 'a'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, '\\', '\\'));
+  EXPECT_TRUE(AtomMatchesChar(true, '_', '_'));
+  EXPECT_TRUE(AtomMatchesChar(true, '+', '+'));
+  EXPECT_TRUE(AtomMatchesChar(true, '.', '.'));
+}
+
+TEST(AtomMatchesCharTest, Escaped_d) {
+  EXPECT_FALSE(AtomMatchesChar(true, 'd', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'd', 'a'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'd', '.'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 'd', '0'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'd', '9'));
+}
+
+TEST(AtomMatchesCharTest, Escaped_D) {
+  EXPECT_FALSE(AtomMatchesChar(true, 'D', '0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'D', '9'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 'D', '\0'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'D', 'a'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'D', '-'));
+}
+
+TEST(AtomMatchesCharTest, Escaped_s) {
+  EXPECT_FALSE(AtomMatchesChar(true, 's', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 's', 'a'));
+  EXPECT_FALSE(AtomMatchesChar(true, 's', '.'));
+  EXPECT_FALSE(AtomMatchesChar(true, 's', '9'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 's', ' '));
+  EXPECT_TRUE(AtomMatchesChar(true, 's', '\n'));
+  EXPECT_TRUE(AtomMatchesChar(true, 's', '\t'));
+}
+
+TEST(AtomMatchesCharTest, Escaped_S) {
+  EXPECT_FALSE(AtomMatchesChar(true, 'S', ' '));
+  EXPECT_FALSE(AtomMatchesChar(true, 'S', '\r'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 'S', '\0'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'S', 'a'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'S', '9'));
+}
+
+TEST(AtomMatchesCharTest, Escaped_w) {
+  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'w', '+'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'w', ' '));
+  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\n'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 'w', '0'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'b'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'C'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'w', '_'));
+}
+
+TEST(AtomMatchesCharTest, Escaped_W) {
+  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'A'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'b'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'W', '9'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'W', '_'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\0'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'W', '*'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\n'));
+}
+
+TEST(AtomMatchesCharTest, EscapedWhiteSpace) {
+  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\n'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\r'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'r', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'r', 'a'));
+  EXPECT_FALSE(AtomMatchesChar(true, 't', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 't', 't'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\f'));
+
+  EXPECT_TRUE(AtomMatchesChar(true, 'f', '\f'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'n', '\n'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'r', '\r'));
+  EXPECT_TRUE(AtomMatchesChar(true, 't', '\t'));
+  EXPECT_TRUE(AtomMatchesChar(true, 'v', '\v'));
+}
+
+TEST(AtomMatchesCharTest, UnescapedDot) {
+  EXPECT_FALSE(AtomMatchesChar(false, '.', '\n'));
+
+  EXPECT_TRUE(AtomMatchesChar(false, '.', '\0'));
+  EXPECT_TRUE(AtomMatchesChar(false, '.', '.'));
+  EXPECT_TRUE(AtomMatchesChar(false, '.', 'a'));
+  EXPECT_TRUE(AtomMatchesChar(false, '.', ' '));
+}
+
+TEST(AtomMatchesCharTest, UnescapedChar) {
+  EXPECT_FALSE(AtomMatchesChar(false, 'a', '\0'));
+  EXPECT_FALSE(AtomMatchesChar(false, 'a', 'b'));
+  EXPECT_FALSE(AtomMatchesChar(false, '$', 'a'));
+
+  EXPECT_TRUE(AtomMatchesChar(false, '$', '$'));
+  EXPECT_TRUE(AtomMatchesChar(false, '5', '5'));
+  EXPECT_TRUE(AtomMatchesChar(false, 'Z', 'Z'));
+}
+
+TEST(ValidateRegexTest, GeneratesFailureAndReturnsFalseForInvalid) {
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(NULL)),
+                          "NULL is not a valid simple regular expression");
+  EXPECT_NONFATAL_FAILURE(
+      ASSERT_FALSE(ValidateRegex("a\\")),
+      "Syntax error at index 1 in simple regular expression \"a\\\": ");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a\\")),
+                          "'\\' cannot appear at the end");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\n\\")),
+                          "'\\' cannot appear at the end");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\s\\hb")),
+                          "invalid escape sequence \"\\h\"");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^^")),
+                          "'^' can only appear at the beginning");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(".*^b")),
+                          "'^' can only appear at the beginning");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("$$")),
+                          "'$' can only appear at the end");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^$a")),
+                          "'$' can only appear at the end");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a(b")),
+                          "'(' is unsupported");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("ab)")),
+                          "')' is unsupported");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("[ab")),
+                          "'[' is unsupported");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a{2")),
+                          "'{' is unsupported");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("?")),
+                          "'?' can only follow a repeatable token");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^*")),
+                          "'*' can only follow a repeatable token");
+  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("5*+")),
+                          "'+' can only follow a repeatable token");
+}
+
+TEST(ValidateRegexTest, ReturnsTrueForValid) {
+  EXPECT_TRUE(ValidateRegex(""));
+  EXPECT_TRUE(ValidateRegex("a"));
+  EXPECT_TRUE(ValidateRegex(".*"));
+  EXPECT_TRUE(ValidateRegex("^a_+"));
+  EXPECT_TRUE(ValidateRegex("^a\\t\\&?"));
+  EXPECT_TRUE(ValidateRegex("09*$"));
+  EXPECT_TRUE(ValidateRegex("^Z$"));
+  EXPECT_TRUE(ValidateRegex("a\\^Z\\$\\(\\)\\|\\[\\]\\{\\}"));
+}
+
+TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrOne) {
+  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "a", "ba"));
+  // Repeating more than once.
+  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "aab"));
+
+  // Repeating zero times.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ba"));
+  // Repeating once.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ab"));
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '#', '?', ".", "##"));
+}
+
+TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrMany) {
+  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '*', "a$", "baab"));
+
+  // Repeating zero times.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "bc"));
+  // Repeating once.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "abc"));
+  // Repeating more than once.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '*', "-", "ab_1-g"));
+}
+
+TEST(MatchRepetitionAndRegexAtHeadTest, WorksForOneOrMany) {
+  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "a$", "baab"));
+  // Repeating zero times.
+  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "bc"));
+
+  // Repeating once.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "abc"));
+  // Repeating more than once.
+  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '+', "-", "ab_1-g"));
+}
+
+TEST(MatchRegexAtHeadTest, ReturnsTrueForEmptyRegex) {
+  EXPECT_TRUE(MatchRegexAtHead("", ""));
+  EXPECT_TRUE(MatchRegexAtHead("", "ab"));
+}
+
+TEST(MatchRegexAtHeadTest, WorksWhenDollarIsInRegex) {
+  EXPECT_FALSE(MatchRegexAtHead("$", "a"));
+
+  EXPECT_TRUE(MatchRegexAtHead("$", ""));
+  EXPECT_TRUE(MatchRegexAtHead("a$", "a"));
+}
+
+TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithEscapeSequence) {
+  EXPECT_FALSE(MatchRegexAtHead("\\w", "+"));
+  EXPECT_FALSE(MatchRegexAtHead("\\W", "ab"));
+
+  EXPECT_TRUE(MatchRegexAtHead("\\sa", "\nab"));
+  EXPECT_TRUE(MatchRegexAtHead("\\d", "1a"));
+}
+
+TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetition) {
+  EXPECT_FALSE(MatchRegexAtHead(".+a", "abc"));
+  EXPECT_FALSE(MatchRegexAtHead("a?b", "aab"));
+
+  EXPECT_TRUE(MatchRegexAtHead(".*a", "bc12-ab"));
+  EXPECT_TRUE(MatchRegexAtHead("a?b", "b"));
+  EXPECT_TRUE(MatchRegexAtHead("a?b", "ab"));
+}
+
+TEST(MatchRegexAtHeadTest,
+     WorksWhenRegexStartsWithRepetionOfEscapeSequence) {
+  EXPECT_FALSE(MatchRegexAtHead("\\.+a", "abc"));
+  EXPECT_FALSE(MatchRegexAtHead("\\s?b", "  b"));
+
+  EXPECT_TRUE(MatchRegexAtHead("\\(*a", "((((ab"));
+  EXPECT_TRUE(MatchRegexAtHead("\\^?b", "^b"));
+  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "b"));
+  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "\\b"));
+}
+
+TEST(MatchRegexAtHeadTest, MatchesSequentially) {
+  EXPECT_FALSE(MatchRegexAtHead("ab.*c", "acabc"));
+
+  EXPECT_TRUE(MatchRegexAtHead("ab.*c", "ab-fsc"));
+}
+
+TEST(MatchRegexAnywhereTest, ReturnsFalseWhenStringIsNull) {
+  EXPECT_FALSE(MatchRegexAnywhere("", NULL));
+}
+
+TEST(MatchRegexAnywhereTest, WorksWhenRegexStartsWithCaret) {
+  EXPECT_FALSE(MatchRegexAnywhere("^a", "ba"));
+  EXPECT_FALSE(MatchRegexAnywhere("^$", "a"));
+
+  EXPECT_TRUE(MatchRegexAnywhere("^a", "ab"));
+  EXPECT_TRUE(MatchRegexAnywhere("^", "ab"));
+  EXPECT_TRUE(MatchRegexAnywhere("^$", ""));
+}
+
+TEST(MatchRegexAnywhereTest, ReturnsFalseWhenNoMatch) {
+  EXPECT_FALSE(MatchRegexAnywhere("a", "bcde123"));
+  EXPECT_FALSE(MatchRegexAnywhere("a.+a", "--aa88888888"));
+}
+
+TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingPrefix) {
+  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "ab1_ - 5"));
+  EXPECT_TRUE(MatchRegexAnywhere(".*=", "="));
+  EXPECT_TRUE(MatchRegexAnywhere("x.*ab?.*bc", "xaaabc"));
+}
+
+TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingNonPrefix) {
+  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "$$$ ab1_ - 5"));
+  EXPECT_TRUE(MatchRegexAnywhere("\\.+=", "=  ...="));
+}
+
+// Tests RE's implicit constructors.
+TEST(RETest, ImplicitConstructorWorks) {
+  const RE empty("");
+  EXPECT_STREQ("", empty.pattern());
+
+  const RE simple("hello");
+  EXPECT_STREQ("hello", simple.pattern());
+}
+
+// Tests that RE's constructors reject invalid regular expressions.
+TEST(RETest, RejectsInvalidRegex) {
+  EXPECT_NONFATAL_FAILURE({
+    const RE normal(NULL);
+  }, "NULL is not a valid simple regular expression");
+
+  EXPECT_NONFATAL_FAILURE({
+    const RE normal(".*(\\w+");
+  }, "'(' is unsupported");
+
+  EXPECT_NONFATAL_FAILURE({
+    const RE invalid("^?");
+  }, "'?' can only follow a repeatable token");
+}
+
+// Tests RE::FullMatch().
+TEST(RETest, FullMatchWorks) {
+  const RE empty("");
+  EXPECT_TRUE(RE::FullMatch("", empty));
+  EXPECT_FALSE(RE::FullMatch("a", empty));
+
+  const RE re1("a");
+  EXPECT_TRUE(RE::FullMatch("a", re1));
+
+  const RE re("a.*z");
+  EXPECT_TRUE(RE::FullMatch("az", re));
+  EXPECT_TRUE(RE::FullMatch("axyz", re));
+  EXPECT_FALSE(RE::FullMatch("baz", re));
+  EXPECT_FALSE(RE::FullMatch("azy", re));
+}
+
+// Tests RE::PartialMatch().
+TEST(RETest, PartialMatchWorks) {
+  const RE empty("");
+  EXPECT_TRUE(RE::PartialMatch("", empty));
+  EXPECT_TRUE(RE::PartialMatch("a", empty));
+
+  const RE re("a.*z");
+  EXPECT_TRUE(RE::PartialMatch("az", re));
+  EXPECT_TRUE(RE::PartialMatch("axyz", re));
+  EXPECT_TRUE(RE::PartialMatch("baz", re));
+  EXPECT_TRUE(RE::PartialMatch("azy", re));
+  EXPECT_FALSE(RE::PartialMatch("zza", re));
+}
+
+#endif  // GTEST_USES_POSIX_RE
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+TEST(CaptureTest, CapturesStdout) {
+  CaptureStdout();
+  fprintf(stdout, "abc");
+  EXPECT_STREQ("abc", GetCapturedStdout().c_str());
+
+  CaptureStdout();
+  fprintf(stdout, "def%cghi", '\0');
+  EXPECT_EQ(::std::string("def\0ghi", 7), ::std::string(GetCapturedStdout()));
+}
+
+TEST(CaptureTest, CapturesStderr) {
+  CaptureStderr();
+  fprintf(stderr, "jkl");
+  EXPECT_STREQ("jkl", GetCapturedStderr().c_str());
+
+  CaptureStderr();
+  fprintf(stderr, "jkl%cmno", '\0');
+  EXPECT_EQ(::std::string("jkl\0mno", 7), ::std::string(GetCapturedStderr()));
+}
+
+// Tests that stdout and stderr capture don't interfere with each other.
+TEST(CaptureTest, CapturesStdoutAndStderr) {
+  CaptureStdout();
+  CaptureStderr();
+  fprintf(stdout, "pqr");
+  fprintf(stderr, "stu");
+  EXPECT_STREQ("pqr", GetCapturedStdout().c_str());
+  EXPECT_STREQ("stu", GetCapturedStderr().c_str());
+}
+
+TEST(CaptureDeathTest, CannotReenterStdoutCapture) {
+  CaptureStdout();
+  EXPECT_DEATH_IF_SUPPORTED(CaptureStdout(),
+                            "Only one stdout capturer can exist at a time");
+  GetCapturedStdout();
+
+  // We cannot test stderr capturing using death tests as they use it
+  // themselves.
+}
+
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+TEST(ThreadLocalTest, DefaultConstructorInitializesToDefaultValues) {
+  ThreadLocal<int> t1;
+  EXPECT_EQ(0, t1.get());
+
+  ThreadLocal<void*> t2;
+  EXPECT_TRUE(t2.get() == NULL);
+}
+
+TEST(ThreadLocalTest, SingleParamConstructorInitializesToParam) {
+  ThreadLocal<int> t1(123);
+  EXPECT_EQ(123, t1.get());
+
+  int i = 0;
+  ThreadLocal<int*> t2(&i);
+  EXPECT_EQ(&i, t2.get());
+}
+
+class NoDefaultContructor {
+ public:
+  explicit NoDefaultContructor(const char*) {}
+  NoDefaultContructor(const NoDefaultContructor&) {}
+};
+
+TEST(ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVersion) {
+  ThreadLocal<NoDefaultContructor> bar(NoDefaultContructor("foo"));
+  bar.pointer();
+}
+
+TEST(ThreadLocalTest, GetAndPointerReturnSameValue) {
+  ThreadLocal<std::string> thread_local_string;
+
+  EXPECT_EQ(thread_local_string.pointer(), &(thread_local_string.get()));
+
+  // Verifies the condition still holds after calling set.
+  thread_local_string.set("foo");
+  EXPECT_EQ(thread_local_string.pointer(), &(thread_local_string.get()));
+}
+
+TEST(ThreadLocalTest, PointerAndConstPointerReturnSameValue) {
+  ThreadLocal<std::string> thread_local_string;
+  const ThreadLocal<std::string>& const_thread_local_string =
+      thread_local_string;
+
+  EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer());
+
+  thread_local_string.set("foo");
+  EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer());
+}
+
+#if GTEST_IS_THREADSAFE
+
+void AddTwo(int* param) { *param += 2; }
+
+TEST(ThreadWithParamTest, ConstructorExecutesThreadFunc) {
+  int i = 40;
+  ThreadWithParam<int*> thread(&AddTwo, &i, NULL);
+  thread.Join();
+  EXPECT_EQ(42, i);
+}
+
+TEST(MutexDeathTest, AssertHeldShouldAssertWhenNotLocked) {
+  // AssertHeld() is flaky only in the presence of multiple threads accessing
+  // the lock. In this case, the test is robust.
+  EXPECT_DEATH_IF_SUPPORTED({
+    Mutex m;
+    { MutexLock lock(&m); }
+    m.AssertHeld();
+  },
+  "thread .*hold");
+}
+
+TEST(MutexTest, AssertHeldShouldNotAssertWhenLocked) {
+  Mutex m;
+  MutexLock lock(&m);
+  m.AssertHeld();
+}
+
+class AtomicCounterWithMutex {
+ public:
+  explicit AtomicCounterWithMutex(Mutex* mutex) :
+    value_(0), mutex_(mutex), random_(42) {}
+
+  void Increment() {
+    MutexLock lock(mutex_);
+    int temp = value_;
+    {
+      // We need to put up a memory barrier to prevent reads and writes to
+      // value_ rearranged with the call to SleepMilliseconds when observed
+      // from other threads.
+#if GTEST_HAS_PTHREAD
+      // On POSIX, locking a mutex puts up a memory barrier.  We cannot use
+      // Mutex and MutexLock here or rely on their memory barrier
+      // functionality as we are testing them here.
+      pthread_mutex_t memory_barrier_mutex;
+      GTEST_CHECK_POSIX_SUCCESS_(
+          pthread_mutex_init(&memory_barrier_mutex, NULL));
+      GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&memory_barrier_mutex));
+
+      SleepMilliseconds(random_.Generate(30));
+
+      GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&memory_barrier_mutex));
+      GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&memory_barrier_mutex));
+#elif GTEST_OS_WINDOWS
+      // On Windows, performing an interlocked access puts up a memory barrier.
+      volatile LONG dummy = 0;
+      ::InterlockedIncrement(&dummy);
+      SleepMilliseconds(random_.Generate(30));
+      ::InterlockedIncrement(&dummy);
+#else
+# error "Memory barrier not implemented on this platform."
+#endif  // GTEST_HAS_PTHREAD
+    }
+    value_ = temp + 1;
+  }
+  int value() const { return value_; }
+
+ private:
+  volatile int value_;
+  Mutex* const mutex_;  // Protects value_.
+  Random       random_;
+};
+
+void CountingThreadFunc(pair<AtomicCounterWithMutex*, int> param) {
+  for (int i = 0; i < param.second; ++i)
+      param.first->Increment();
+}
+
+// Tests that the mutex only lets one thread at a time to lock it.
+TEST(MutexTest, OnlyOneThreadCanLockAtATime) {
+  Mutex mutex;
+  AtomicCounterWithMutex locked_counter(&mutex);
+
+  typedef ThreadWithParam<pair<AtomicCounterWithMutex*, int> > ThreadType;
+  const int kCycleCount = 20;
+  const int kThreadCount = 7;
+  scoped_ptr<ThreadType> counting_threads[kThreadCount];
+  Notification threads_can_start;
+  // Creates and runs kThreadCount threads that increment locked_counter
+  // kCycleCount times each.
+  for (int i = 0; i < kThreadCount; ++i) {
+    counting_threads[i].reset(new ThreadType(&CountingThreadFunc,
+                                             make_pair(&locked_counter,
+                                                       kCycleCount),
+                                             &threads_can_start));
+  }
+  threads_can_start.Notify();
+  for (int i = 0; i < kThreadCount; ++i)
+    counting_threads[i]->Join();
+
+  // If the mutex lets more than one thread to increment the counter at a
+  // time, they are likely to encounter a race condition and have some
+  // increments overwritten, resulting in the lower then expected counter
+  // value.
+  EXPECT_EQ(kCycleCount * kThreadCount, locked_counter.value());
+}
+
+template <typename T>
+void RunFromThread(void (func)(T), T param) {
+  ThreadWithParam<T> thread(func, param, NULL);
+  thread.Join();
+}
+
+void RetrieveThreadLocalValue(
+    pair<ThreadLocal<std::string>*, std::string*> param) {
+  *param.second = param.first->get();
+}
+
+TEST(ThreadLocalTest, ParameterizedConstructorSetsDefault) {
+  ThreadLocal<std::string> thread_local_string("foo");
+  EXPECT_STREQ("foo", thread_local_string.get().c_str());
+
+  thread_local_string.set("bar");
+  EXPECT_STREQ("bar", thread_local_string.get().c_str());
+
+  std::string result;
+  RunFromThread(&RetrieveThreadLocalValue,
+                make_pair(&thread_local_string, &result));
+  EXPECT_STREQ("foo", result.c_str());
+}
+
+// Keeps track of whether of destructors being called on instances of
+// DestructorTracker.  On Windows, waits for the destructor call reports.
+class DestructorCall {
+ public:
+  DestructorCall() {
+    invoked_ = false;
+#if GTEST_OS_WINDOWS
+    wait_event_.Reset(::CreateEvent(NULL, TRUE, FALSE, NULL));
+    GTEST_CHECK_(wait_event_.Get() != NULL);
+#endif
+  }
+
+  bool CheckDestroyed() const {
+#if GTEST_OS_WINDOWS
+    if (::WaitForSingleObject(wait_event_.Get(), 1000) != WAIT_OBJECT_0)
+      return false;
+#endif
+    return invoked_;
+  }
+
+  void ReportDestroyed() {
+    invoked_ = true;
+#if GTEST_OS_WINDOWS
+    ::SetEvent(wait_event_.Get());
+#endif
+  }
+
+  static std::vector<DestructorCall*>& List() { return *list_; }
+
+  static void ResetList() {
+    for (size_t i = 0; i < list_->size(); ++i) {
+      delete list_->at(i);
+    }
+    list_->clear();
+  }
+
+ private:
+  bool invoked_;
+#if GTEST_OS_WINDOWS
+  AutoHandle wait_event_;
+#endif
+  static std::vector<DestructorCall*>* const list_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DestructorCall);
+};
+
+std::vector<DestructorCall*>* const DestructorCall::list_ =
+    new std::vector<DestructorCall*>;
+
+// DestructorTracker keeps track of whether its instances have been
+// destroyed.
+class DestructorTracker {
+ public:
+  DestructorTracker() : index_(GetNewIndex()) {}
+  DestructorTracker(const DestructorTracker& /* rhs */)
+      : index_(GetNewIndex()) {}
+  ~DestructorTracker() {
+    // We never access DestructorCall::List() concurrently, so we don't need
+    // to protect this acccess with a mutex.
+    DestructorCall::List()[index_]->ReportDestroyed();
+  }
+
+ private:
+  static size_t GetNewIndex() {
+    DestructorCall::List().push_back(new DestructorCall);
+    return DestructorCall::List().size() - 1;
+  }
+  const size_t index_;
+
+  GTEST_DISALLOW_ASSIGN_(DestructorTracker);
+};
+
+typedef ThreadLocal<DestructorTracker>* ThreadParam;
+
+void CallThreadLocalGet(ThreadParam thread_local_param) {
+  thread_local_param->get();
+}
+
+// Tests that when a ThreadLocal object dies in a thread, it destroys
+// the managed object for that thread.
+TEST(ThreadLocalTest, DestroysManagedObjectForOwnThreadWhenDying) {
+  DestructorCall::ResetList();
+
+  {
+    ThreadLocal<DestructorTracker> thread_local_tracker;
+    ASSERT_EQ(0U, DestructorCall::List().size());
+
+    // This creates another DestructorTracker object for the main thread.
+    thread_local_tracker.get();
+    ASSERT_EQ(1U, DestructorCall::List().size());
+    ASSERT_FALSE(DestructorCall::List()[0]->CheckDestroyed());
+  }
+
+  // Now thread_local_tracker has died.
+  ASSERT_EQ(1U, DestructorCall::List().size());
+  EXPECT_TRUE(DestructorCall::List()[0]->CheckDestroyed());
+
+  DestructorCall::ResetList();
+}
+
+// Tests that when a thread exits, the thread-local object for that
+// thread is destroyed.
+TEST(ThreadLocalTest, DestroysManagedObjectAtThreadExit) {
+  DestructorCall::ResetList();
+
+  {
+    ThreadLocal<DestructorTracker> thread_local_tracker;
+    ASSERT_EQ(0U, DestructorCall::List().size());
+
+    // This creates another DestructorTracker object in the new thread.
+    ThreadWithParam<ThreadParam> thread(
+        &CallThreadLocalGet, &thread_local_tracker, NULL);
+    thread.Join();
+
+    // The thread has exited, and we should have a DestroyedTracker
+    // instance created for it. But it may not have been destroyed yet.
+    ASSERT_EQ(1U, DestructorCall::List().size());
+  }
+
+  // The thread has exited and thread_local_tracker has died.
+  ASSERT_EQ(1U, DestructorCall::List().size());
+  EXPECT_TRUE(DestructorCall::List()[0]->CheckDestroyed());
+
+  DestructorCall::ResetList();
+}
+
+TEST(ThreadLocalTest, ThreadLocalMutationsAffectOnlyCurrentThread) {
+  ThreadLocal<std::string> thread_local_string;
+  thread_local_string.set("Foo");
+  EXPECT_STREQ("Foo", thread_local_string.get().c_str());
+
+  std::string result;
+  RunFromThread(&RetrieveThreadLocalValue,
+                make_pair(&thread_local_string, &result));
+  EXPECT_TRUE(result.empty());
+}
+
+#endif  // GTEST_IS_THREADSAFE
+
+#if GTEST_OS_WINDOWS
+TEST(WindowsTypesTest, HANDLEIsVoidStar) {
+  StaticAssertTypeEq<HANDLE, void*>();
+}
+
+#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR)
+TEST(WindowsTypesTest, _CRITICAL_SECTIONIs_CRITICAL_SECTION) {
+  StaticAssertTypeEq<CRITICAL_SECTION, _CRITICAL_SECTION>();
+}
+#else
+TEST(WindowsTypesTest, CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION) {
+  StaticAssertTypeEq<CRITICAL_SECTION, _RTL_CRITICAL_SECTION>();
+}
+#endif
+
+#endif  // GTEST_OS_WINDOWS
+
+}  // namespace internal
+}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-printers_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-printers_test.cc
new file mode 100644
index 00000000..3e97cc24
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-printers_test.cc
@@ -0,0 +1,1635 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Test - The Google C++ Testing Framework
+//
+// This file tests the universal value printer.
+
+#include "gtest/gtest-printers.h"
+
+#include <ctype.h>
+#include <limits.h>
+#include <string.h>
+#include <algorithm>
+#include <deque>
+#include <list>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "gtest/gtest.h"
+
+// hash_map and hash_set are available under Visual C++, or on Linux.
+#if GTEST_HAS_HASH_MAP_
+# include <hash_map>            // NOLINT
+#endif  // GTEST_HAS_HASH_MAP_
+#if GTEST_HAS_HASH_SET_
+# include <hash_set>            // NOLINT
+#endif  // GTEST_HAS_HASH_SET_
+
+#if GTEST_HAS_STD_FORWARD_LIST_
+# include <forward_list> // NOLINT
+#endif  // GTEST_HAS_STD_FORWARD_LIST_
+
+// Some user-defined types for testing the universal value printer.
+
+// An anonymous enum type.
+enum AnonymousEnum {
+  kAE1 = -1,
+  kAE2 = 1
+};
+
+// An enum without a user-defined printer.
+enum EnumWithoutPrinter {
+  kEWP1 = -2,
+  kEWP2 = 42
+};
+
+// An enum with a << operator.
+enum EnumWithStreaming {
+  kEWS1 = 10
+};
+
+std::ostream& operator<<(std::ostream& os, EnumWithStreaming e) {
+  return os << (e == kEWS1 ? "kEWS1" : "invalid");
+}
+
+// An enum with a PrintTo() function.
+enum EnumWithPrintTo {
+  kEWPT1 = 1
+};
+
+void PrintTo(EnumWithPrintTo e, std::ostream* os) {
+  *os << (e == kEWPT1 ? "kEWPT1" : "invalid");
+}
+
+// A class implicitly convertible to BiggestInt.
+class BiggestIntConvertible {
+ public:
+  operator ::testing::internal::BiggestInt() const { return 42; }
+};
+
+// A user-defined unprintable class template in the global namespace.
+template <typename T>
+class UnprintableTemplateInGlobal {
+ public:
+  UnprintableTemplateInGlobal() : value_() {}
+ private:
+  T value_;
+};
+
+// A user-defined streamable type in the global namespace.
+class StreamableInGlobal {
+ public:
+  virtual ~StreamableInGlobal() {}
+};
+
+inline void operator<<(::std::ostream& os, const StreamableInGlobal& /* x */) {
+  os << "StreamableInGlobal";
+}
+
+void operator<<(::std::ostream& os, const StreamableInGlobal* /* x */) {
+  os << "StreamableInGlobal*";
+}
+
+namespace foo {
+
+// A user-defined unprintable type in a user namespace.
+class UnprintableInFoo {
+ public:
+  UnprintableInFoo() : z_(0) { memcpy(xy_, "\xEF\x12\x0\x0\x34\xAB\x0\x0", 8); }
+  double z() const { return z_; }
+ private:
+  char xy_[8];
+  double z_;
+};
+
+// A user-defined printable type in a user-chosen namespace.
+struct PrintableViaPrintTo {
+  PrintableViaPrintTo() : value() {}
+  int value;
+};
+
+void PrintTo(const PrintableViaPrintTo& x, ::std::ostream* os) {
+  *os << "PrintableViaPrintTo: " << x.value;
+}
+
+// A type with a user-defined << for printing its pointer.
+struct PointerPrintable {
+};
+
+::std::ostream& operator<<(::std::ostream& os,
+                           const PointerPrintable* /* x */) {
+  return os << "PointerPrintable*";
+}
+
+// A user-defined printable class template in a user-chosen namespace.
+template <typename T>
+class PrintableViaPrintToTemplate {
+ public:
+  explicit PrintableViaPrintToTemplate(const T& a_value) : value_(a_value) {}
+
+  const T& value() const { return value_; }
+ private:
+  T value_;
+};
+
+template <typename T>
+void PrintTo(const PrintableViaPrintToTemplate<T>& x, ::std::ostream* os) {
+  *os << "PrintableViaPrintToTemplate: " << x.value();
+}
+
+// A user-defined streamable class template in a user namespace.
+template <typename T>
+class StreamableTemplateInFoo {
+ public:
+  StreamableTemplateInFoo() : value_() {}
+
+  const T& value() const { return value_; }
+ private:
+  T value_;
+};
+
+template <typename T>
+inline ::std::ostream& operator<<(::std::ostream& os,
+                                  const StreamableTemplateInFoo<T>& x) {
+  return os << "StreamableTemplateInFoo: " << x.value();
+}
+
+}  // namespace foo
+
+namespace testing {
+namespace gtest_printers_test {
+
+using ::std::deque;
+using ::std::list;
+using ::std::make_pair;
+using ::std::map;
+using ::std::multimap;
+using ::std::multiset;
+using ::std::pair;
+using ::std::set;
+using ::std::vector;
+using ::testing::PrintToString;
+using ::testing::internal::FormatForComparisonFailureMessage;
+using ::testing::internal::ImplicitCast_;
+using ::testing::internal::NativeArray;
+using ::testing::internal::RE;
+using ::testing::internal::RelationToSourceReference;
+using ::testing::internal::Strings;
+using ::testing::internal::UniversalPrint;
+using ::testing::internal::UniversalPrinter;
+using ::testing::internal::UniversalTersePrint;
+using ::testing::internal::UniversalTersePrintTupleFieldsToStrings;
+using ::testing::internal::string;
+
+// The hash_* classes are not part of the C++ standard.  STLport
+// defines them in namespace std.  MSVC defines them in ::stdext.  GCC
+// defines them in ::.
+#ifdef _STLP_HASH_MAP  // We got <hash_map> from STLport.
+using ::std::hash_map;
+using ::std::hash_set;
+using ::std::hash_multimap;
+using ::std::hash_multiset;
+#elif _MSC_VER
+using ::stdext::hash_map;
+using ::stdext::hash_set;
+using ::stdext::hash_multimap;
+using ::stdext::hash_multiset;
+#endif
+
+// Prints a value to a string using the universal value printer.  This
+// is a helper for testing UniversalPrinter<T>::Print() for various types.
+template <typename T>
+string Print(const T& value) {
+  ::std::stringstream ss;
+  UniversalPrinter<T>::Print(value, &ss);
+  return ss.str();
+}
+
+// Prints a value passed by reference to a string, using the universal
+// value printer.  This is a helper for testing
+// UniversalPrinter<T&>::Print() for various types.
+template <typename T>
+string PrintByRef(const T& value) {
+  ::std::stringstream ss;
+  UniversalPrinter<T&>::Print(value, &ss);
+  return ss.str();
+}
+
+// Tests printing various enum types.
+
+TEST(PrintEnumTest, AnonymousEnum) {
+  EXPECT_EQ("-1", Print(kAE1));
+  EXPECT_EQ("1", Print(kAE2));
+}
+
+TEST(PrintEnumTest, EnumWithoutPrinter) {
+  EXPECT_EQ("-2", Print(kEWP1));
+  EXPECT_EQ("42", Print(kEWP2));
+}
+
+TEST(PrintEnumTest, EnumWithStreaming) {
+  EXPECT_EQ("kEWS1", Print(kEWS1));
+  EXPECT_EQ("invalid", Print(static_cast<EnumWithStreaming>(0)));
+}
+
+TEST(PrintEnumTest, EnumWithPrintTo) {
+  EXPECT_EQ("kEWPT1", Print(kEWPT1));
+  EXPECT_EQ("invalid", Print(static_cast<EnumWithPrintTo>(0)));
+}
+
+// Tests printing a class implicitly convertible to BiggestInt.
+
+TEST(PrintClassTest, BiggestIntConvertible) {
+  EXPECT_EQ("42", Print(BiggestIntConvertible()));
+}
+
+// Tests printing various char types.
+
+// char.
+TEST(PrintCharTest, PlainChar) {
+  EXPECT_EQ("'\\0'", Print('\0'));
+  EXPECT_EQ("'\\'' (39, 0x27)", Print('\''));
+  EXPECT_EQ("'\"' (34, 0x22)", Print('"'));
+  EXPECT_EQ("'?' (63, 0x3F)", Print('?'));
+  EXPECT_EQ("'\\\\' (92, 0x5C)", Print('\\'));
+  EXPECT_EQ("'\\a' (7)", Print('\a'));
+  EXPECT_EQ("'\\b' (8)", Print('\b'));
+  EXPECT_EQ("'\\f' (12, 0xC)", Print('\f'));
+  EXPECT_EQ("'\\n' (10, 0xA)", Print('\n'));
+  EXPECT_EQ("'\\r' (13, 0xD)", Print('\r'));
+  EXPECT_EQ("'\\t' (9)", Print('\t'));
+  EXPECT_EQ("'\\v' (11, 0xB)", Print('\v'));
+  EXPECT_EQ("'\\x7F' (127)", Print('\x7F'));
+  EXPECT_EQ("'\\xFF' (255)", Print('\xFF'));
+  EXPECT_EQ("' ' (32, 0x20)", Print(' '));
+  EXPECT_EQ("'a' (97, 0x61)", Print('a'));
+}
+
+// signed char.
+TEST(PrintCharTest, SignedChar) {
+  EXPECT_EQ("'\\0'", Print(static_cast<signed char>('\0')));
+  EXPECT_EQ("'\\xCE' (-50)",
+            Print(static_cast<signed char>(-50)));
+}
+
+// unsigned char.
+TEST(PrintCharTest, UnsignedChar) {
+  EXPECT_EQ("'\\0'", Print(static_cast<unsigned char>('\0')));
+  EXPECT_EQ("'b' (98, 0x62)",
+            Print(static_cast<unsigned char>('b')));
+}
+
+// Tests printing other simple, built-in types.
+
+// bool.
+TEST(PrintBuiltInTypeTest, Bool) {
+  EXPECT_EQ("false", Print(false));
+  EXPECT_EQ("true", Print(true));
+}
+
+// wchar_t.
+TEST(PrintBuiltInTypeTest, Wchar_t) {
+  EXPECT_EQ("L'\\0'", Print(L'\0'));
+  EXPECT_EQ("L'\\'' (39, 0x27)", Print(L'\''));
+  EXPECT_EQ("L'\"' (34, 0x22)", Print(L'"'));
+  EXPECT_EQ("L'?' (63, 0x3F)", Print(L'?'));
+  EXPECT_EQ("L'\\\\' (92, 0x5C)", Print(L'\\'));
+  EXPECT_EQ("L'\\a' (7)", Print(L'\a'));
+  EXPECT_EQ("L'\\b' (8)", Print(L'\b'));
+  EXPECT_EQ("L'\\f' (12, 0xC)", Print(L'\f'));
+  EXPECT_EQ("L'\\n' (10, 0xA)", Print(L'\n'));
+  EXPECT_EQ("L'\\r' (13, 0xD)", Print(L'\r'));
+  EXPECT_EQ("L'\\t' (9)", Print(L'\t'));
+  EXPECT_EQ("L'\\v' (11, 0xB)", Print(L'\v'));
+  EXPECT_EQ("L'\\x7F' (127)", Print(L'\x7F'));
+  EXPECT_EQ("L'\\xFF' (255)", Print(L'\xFF'));
+  EXPECT_EQ("L' ' (32, 0x20)", Print(L' '));
+  EXPECT_EQ("L'a' (97, 0x61)", Print(L'a'));
+  EXPECT_EQ("L'\\x576' (1398)", Print(static_cast<wchar_t>(0x576)));
+  EXPECT_EQ("L'\\xC74D' (51021)", Print(static_cast<wchar_t>(0xC74D)));
+}
+
+// Test that Int64 provides more storage than wchar_t.
+TEST(PrintTypeSizeTest, Wchar_t) {
+  EXPECT_LT(sizeof(wchar_t), sizeof(testing::internal::Int64));
+}
+
+// Various integer types.
+TEST(PrintBuiltInTypeTest, Integer) {
+  EXPECT_EQ("'\\xFF' (255)", Print(static_cast<unsigned char>(255)));  // uint8
+  EXPECT_EQ("'\\x80' (-128)", Print(static_cast<signed char>(-128)));  // int8
+  EXPECT_EQ("65535", Print(USHRT_MAX));  // uint16
+  EXPECT_EQ("-32768", Print(SHRT_MIN));  // int16
+  EXPECT_EQ("4294967295", Print(UINT_MAX));  // uint32
+  EXPECT_EQ("-2147483648", Print(INT_MIN));  // int32
+  EXPECT_EQ("18446744073709551615",
+            Print(static_cast<testing::internal::UInt64>(-1)));  // uint64
+  EXPECT_EQ("-9223372036854775808",
+            Print(static_cast<testing::internal::Int64>(1) << 63));  // int64
+}
+
+// Size types.
+TEST(PrintBuiltInTypeTest, Size_t) {
+  EXPECT_EQ("1", Print(sizeof('a')));  // size_t.
+#if !GTEST_OS_WINDOWS
+  // Windows has no ssize_t type.
+  EXPECT_EQ("-2", Print(static_cast<ssize_t>(-2)));  // ssize_t.
+#endif  // !GTEST_OS_WINDOWS
+}
+
+// Floating-points.
+TEST(PrintBuiltInTypeTest, FloatingPoints) {
+  EXPECT_EQ("1.5", Print(1.5f));   // float
+  EXPECT_EQ("-2.5", Print(-2.5));  // double
+}
+
+// Since ::std::stringstream::operator<<(const void *) formats the pointer
+// output differently with different compilers, we have to create the expected
+// output first and use it as our expectation.
+static string PrintPointer(const void *p) {
+  ::std::stringstream expected_result_stream;
+  expected_result_stream << p;
+  return expected_result_stream.str();
+}
+
+// Tests printing C strings.
+
+// const char*.
+TEST(PrintCStringTest, Const) {
+  const char* p = "World";
+  EXPECT_EQ(PrintPointer(p) + " pointing to \"World\"", Print(p));
+}
+
+// char*.
+TEST(PrintCStringTest, NonConst) {
+  char p[] = "Hi";
+  EXPECT_EQ(PrintPointer(p) + " pointing to \"Hi\"",
+            Print(static_cast<char*>(p)));
+}
+
+// NULL C string.
+TEST(PrintCStringTest, Null) {
+  const char* p = NULL;
+  EXPECT_EQ("NULL", Print(p));
+}
+
+// Tests that C strings are escaped properly.
+TEST(PrintCStringTest, EscapesProperly) {
+  const char* p = "'\"?\\\a\b\f\n\r\t\v\x7F\xFF a";
+  EXPECT_EQ(PrintPointer(p) + " pointing to \"'\\\"?\\\\\\a\\b\\f"
+            "\\n\\r\\t\\v\\x7F\\xFF a\"",
+            Print(p));
+}
+
+// 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,
+// possibly accessing more memory than intended and causing invalid
+// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
+// wchar_t is implemented as a native type.
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+
+// const wchar_t*.
+TEST(PrintWideCStringTest, Const) {
+  const wchar_t* p = L"World";
+  EXPECT_EQ(PrintPointer(p) + " pointing to L\"World\"", Print(p));
+}
+
+// wchar_t*.
+TEST(PrintWideCStringTest, NonConst) {
+  wchar_t p[] = L"Hi";
+  EXPECT_EQ(PrintPointer(p) + " pointing to L\"Hi\"",
+            Print(static_cast<wchar_t*>(p)));
+}
+
+// NULL wide C string.
+TEST(PrintWideCStringTest, Null) {
+  const wchar_t* p = NULL;
+  EXPECT_EQ("NULL", Print(p));
+}
+
+// Tests that wide C strings are escaped properly.
+TEST(PrintWideCStringTest, EscapesProperly) {
+  const wchar_t s[] = {'\'', '"', '?', '\\', '\a', '\b', '\f', '\n', '\r',
+                       '\t', '\v', 0xD3, 0x576, 0x8D3, 0xC74D, ' ', 'a', '\0'};
+  EXPECT_EQ(PrintPointer(s) + " pointing to L\"'\\\"?\\\\\\a\\b\\f"
+            "\\n\\r\\t\\v\\xD3\\x576\\x8D3\\xC74D a\"",
+            Print(static_cast<const wchar_t*>(s)));
+}
+#endif  // native wchar_t
+
+// Tests printing pointers to other char types.
+
+// signed char*.
+TEST(PrintCharPointerTest, SignedChar) {
+  signed char* p = reinterpret_cast<signed char*>(0x1234);
+  EXPECT_EQ(PrintPointer(p), Print(p));
+  p = NULL;
+  EXPECT_EQ("NULL", Print(p));
+}
+
+// const signed char*.
+TEST(PrintCharPointerTest, ConstSignedChar) {
+  signed char* p = reinterpret_cast<signed char*>(0x1234);
+  EXPECT_EQ(PrintPointer(p), Print(p));
+  p = NULL;
+  EXPECT_EQ("NULL", Print(p));
+}
+
+// unsigned char*.
+TEST(PrintCharPointerTest, UnsignedChar) {
+  unsigned char* p = reinterpret_cast<unsigned char*>(0x1234);
+  EXPECT_EQ(PrintPointer(p), Print(p));
+  p = NULL;
+  EXPECT_EQ("NULL", Print(p));
+}
+
+// const unsigned char*.
+TEST(PrintCharPointerTest, ConstUnsignedChar) {
+  const unsigned char* p = reinterpret_cast<const unsigned char*>(0x1234);
+  EXPECT_EQ(PrintPointer(p), Print(p));
+  p = NULL;
+  EXPECT_EQ("NULL", Print(p));
+}
+
+// Tests printing pointers to simple, built-in types.
+
+// bool*.
+TEST(PrintPointerToBuiltInTypeTest, Bool) {
+  bool* p = reinterpret_cast<bool*>(0xABCD);
+  EXPECT_EQ(PrintPointer(p), Print(p));
+  p = NULL;
+  EXPECT_EQ("NULL", Print(p));
+}
+
+// void*.
+TEST(PrintPointerToBuiltInTypeTest, Void) {
+  void* p = reinterpret_cast<void*>(0xABCD);
+  EXPECT_EQ(PrintPointer(p), Print(p));
+  p = NULL;
+  EXPECT_EQ("NULL", Print(p));
+}
+
+// const void*.
+TEST(PrintPointerToBuiltInTypeTest, ConstVoid) {
+  const void* p = reinterpret_cast<const void*>(0xABCD);
+  EXPECT_EQ(PrintPointer(p), Print(p));
+  p = NULL;
+  EXPECT_EQ("NULL", Print(p));
+}
+
+// Tests printing pointers to pointers.
+TEST(PrintPointerToPointerTest, IntPointerPointer) {
+  int** p = reinterpret_cast<int**>(0xABCD);
+  EXPECT_EQ(PrintPointer(p), Print(p));
+  p = NULL;
+  EXPECT_EQ("NULL", Print(p));
+}
+
+// Tests printing (non-member) function pointers.
+
+void MyFunction(int /* n */) {}
+
+TEST(PrintPointerTest, NonMemberFunctionPointer) {
+  // We cannot directly cast &MyFunction to const void* because the
+  // standard disallows casting between pointers to functions and
+  // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
+  // this limitation.
+  EXPECT_EQ(
+      PrintPointer(reinterpret_cast<const void*>(
+          reinterpret_cast<internal::BiggestInt>(&MyFunction))),
+      Print(&MyFunction));
+  int (*p)(bool) = NULL;  // NOLINT
+  EXPECT_EQ("NULL", Print(p));
+}
+
+// An assertion predicate determining whether a one string is a prefix for
+// another.
+template <typename StringType>
+AssertionResult HasPrefix(const StringType& str, const StringType& prefix) {
+  if (str.find(prefix, 0) == 0)
+    return AssertionSuccess();
+
+  const bool is_wide_string = sizeof(prefix[0]) > 1;
+  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
+  return AssertionFailure()
+      << begin_string_quote << prefix << "\" is not a prefix of "
+      << begin_string_quote << str << "\"\n";
+}
+
+// Tests printing member variable pointers.  Although they are called
+// pointers, they don't point to a location in the address space.
+// Their representation is implementation-defined.  Thus they will be
+// printed as raw bytes.
+
+struct Foo {
+ public:
+  virtual ~Foo() {}
+  int MyMethod(char x) { return x + 1; }
+  virtual char MyVirtualMethod(int /* n */) { return 'a'; }
+
+  int value;
+};
+
+TEST(PrintPointerTest, MemberVariablePointer) {
+  EXPECT_TRUE(HasPrefix(Print(&Foo::value),
+                        Print(sizeof(&Foo::value)) + "-byte object "));
+  int (Foo::*p) = NULL;  // NOLINT
+  EXPECT_TRUE(HasPrefix(Print(p),
+                        Print(sizeof(p)) + "-byte object "));
+}
+
+// Tests printing member function pointers.  Although they are called
+// pointers, they don't point to a location in the address space.
+// Their representation is implementation-defined.  Thus they will be
+// printed as raw bytes.
+TEST(PrintPointerTest, MemberFunctionPointer) {
+  EXPECT_TRUE(HasPrefix(Print(&Foo::MyMethod),
+                        Print(sizeof(&Foo::MyMethod)) + "-byte object "));
+  EXPECT_TRUE(
+      HasPrefix(Print(&Foo::MyVirtualMethod),
+                Print(sizeof((&Foo::MyVirtualMethod))) + "-byte object "));
+  int (Foo::*p)(char) = NULL;  // NOLINT
+  EXPECT_TRUE(HasPrefix(Print(p),
+                        Print(sizeof(p)) + "-byte object "));
+}
+
+// Tests printing C arrays.
+
+// The difference between this and Print() is that it ensures that the
+// argument is a reference to an array.
+template <typename T, size_t N>
+string PrintArrayHelper(T (&a)[N]) {
+  return Print(a);
+}
+
+// One-dimensional array.
+TEST(PrintArrayTest, OneDimensionalArray) {
+  int a[5] = { 1, 2, 3, 4, 5 };
+  EXPECT_EQ("{ 1, 2, 3, 4, 5 }", PrintArrayHelper(a));
+}
+
+// Two-dimensional array.
+TEST(PrintArrayTest, TwoDimensionalArray) {
+  int a[2][5] = {
+    { 1, 2, 3, 4, 5 },
+    { 6, 7, 8, 9, 0 }
+  };
+  EXPECT_EQ("{ { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 0 } }", PrintArrayHelper(a));
+}
+
+// Array of const elements.
+TEST(PrintArrayTest, ConstArray) {
+  const bool a[1] = { false };
+  EXPECT_EQ("{ false }", PrintArrayHelper(a));
+}
+
+// char array without terminating NUL.
+TEST(PrintArrayTest, CharArrayWithNoTerminatingNul) {
+  // Array a contains '\0' in the middle and doesn't end with '\0'.
+  char a[] = { 'H', '\0', 'i' };
+  EXPECT_EQ("\"H\\0i\" (no terminating NUL)", PrintArrayHelper(a));
+}
+
+// const char array with terminating NUL.
+TEST(PrintArrayTest, ConstCharArrayWithTerminatingNul) {
+  const char a[] = "\0Hi";
+  EXPECT_EQ("\"\\0Hi\"", PrintArrayHelper(a));
+}
+
+// const wchar_t array without terminating NUL.
+TEST(PrintArrayTest, WCharArrayWithNoTerminatingNul) {
+  // Array a contains '\0' in the middle and doesn't end with '\0'.
+  const wchar_t a[] = { L'H', L'\0', L'i' };
+  EXPECT_EQ("L\"H\\0i\" (no terminating NUL)", PrintArrayHelper(a));
+}
+
+// wchar_t array with terminating NUL.
+TEST(PrintArrayTest, WConstCharArrayWithTerminatingNul) {
+  const wchar_t a[] = L"\0Hi";
+  EXPECT_EQ("L\"\\0Hi\"", PrintArrayHelper(a));
+}
+
+// Array of objects.
+TEST(PrintArrayTest, ObjectArray) {
+  string a[3] = { "Hi", "Hello", "Ni hao" };
+  EXPECT_EQ("{ \"Hi\", \"Hello\", \"Ni hao\" }", PrintArrayHelper(a));
+}
+
+// Array with many elements.
+TEST(PrintArrayTest, BigArray) {
+  int a[100] = { 1, 2, 3 };
+  EXPECT_EQ("{ 1, 2, 3, 0, 0, 0, 0, 0, ..., 0, 0, 0, 0, 0, 0, 0, 0 }",
+            PrintArrayHelper(a));
+}
+
+// Tests printing ::string and ::std::string.
+
+#if GTEST_HAS_GLOBAL_STRING
+// ::string.
+TEST(PrintStringTest, StringInGlobalNamespace) {
+  const char s[] = "'\"?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
+  const ::string str(s, sizeof(s));
+  EXPECT_EQ("\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
+            Print(str));
+}
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+// ::std::string.
+TEST(PrintStringTest, StringInStdNamespace) {
+  const char s[] = "'\"?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
+  const ::std::string str(s, sizeof(s));
+  EXPECT_EQ("\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
+            Print(str));
+}
+
+TEST(PrintStringTest, StringAmbiguousHex) {
+  // "\x6BANANA" is ambiguous, it can be interpreted as starting with either of:
+  // '\x6', '\x6B', or '\x6BA'.
+
+  // a hex escaping sequence following by a decimal digit
+  EXPECT_EQ("\"0\\x12\" \"3\"", Print(::std::string("0\x12" "3")));
+  // a hex escaping sequence following by a hex digit (lower-case)
+  EXPECT_EQ("\"mm\\x6\" \"bananas\"", Print(::std::string("mm\x6" "bananas")));
+  // a hex escaping sequence following by a hex digit (upper-case)
+  EXPECT_EQ("\"NOM\\x6\" \"BANANA\"", Print(::std::string("NOM\x6" "BANANA")));
+  // a hex escaping sequence following by a non-xdigit
+  EXPECT_EQ("\"!\\x5-!\"", Print(::std::string("!\x5-!")));
+}
+
+// Tests printing ::wstring and ::std::wstring.
+
+#if GTEST_HAS_GLOBAL_WSTRING
+// ::wstring.
+TEST(PrintWideStringTest, StringInGlobalNamespace) {
+  const wchar_t s[] = L"'\"?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
+  const ::wstring str(s, sizeof(s)/sizeof(wchar_t));
+  EXPECT_EQ("L\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v"
+            "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
+            Print(str));
+}
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+#if GTEST_HAS_STD_WSTRING
+// ::std::wstring.
+TEST(PrintWideStringTest, StringInStdNamespace) {
+  const wchar_t s[] = L"'\"?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
+  const ::std::wstring str(s, sizeof(s)/sizeof(wchar_t));
+  EXPECT_EQ("L\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v"
+            "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
+            Print(str));
+}
+
+TEST(PrintWideStringTest, StringAmbiguousHex) {
+  // same for wide strings.
+  EXPECT_EQ("L\"0\\x12\" L\"3\"", Print(::std::wstring(L"0\x12" L"3")));
+  EXPECT_EQ("L\"mm\\x6\" L\"bananas\"",
+            Print(::std::wstring(L"mm\x6" L"bananas")));
+  EXPECT_EQ("L\"NOM\\x6\" L\"BANANA\"",
+            Print(::std::wstring(L"NOM\x6" L"BANANA")));
+  EXPECT_EQ("L\"!\\x5-!\"", Print(::std::wstring(L"!\x5-!")));
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Tests printing types that support generic streaming (i.e. streaming
+// to std::basic_ostream<Char, CharTraits> for any valid Char and
+// CharTraits types).
+
+// Tests printing a non-template type that supports generic streaming.
+
+class AllowsGenericStreaming {};
+
+template <typename Char, typename CharTraits>
+std::basic_ostream<Char, CharTraits>& operator<<(
+    std::basic_ostream<Char, CharTraits>& os,
+    const AllowsGenericStreaming& /* a */) {
+  return os << "AllowsGenericStreaming";
+}
+
+TEST(PrintTypeWithGenericStreamingTest, NonTemplateType) {
+  AllowsGenericStreaming a;
+  EXPECT_EQ("AllowsGenericStreaming", Print(a));
+}
+
+// Tests printing a template type that supports generic streaming.
+
+template <typename T>
+class AllowsGenericStreamingTemplate {};
+
+template <typename Char, typename CharTraits, typename T>
+std::basic_ostream<Char, CharTraits>& operator<<(
+    std::basic_ostream<Char, CharTraits>& os,
+    const AllowsGenericStreamingTemplate<T>& /* a */) {
+  return os << "AllowsGenericStreamingTemplate";
+}
+
+TEST(PrintTypeWithGenericStreamingTest, TemplateType) {
+  AllowsGenericStreamingTemplate<int> a;
+  EXPECT_EQ("AllowsGenericStreamingTemplate", Print(a));
+}
+
+// Tests printing a type that supports generic streaming and can be
+// implicitly converted to another printable type.
+
+template <typename T>
+class AllowsGenericStreamingAndImplicitConversionTemplate {
+ public:
+  operator bool() const { return false; }
+};
+
+template <typename Char, typename CharTraits, typename T>
+std::basic_ostream<Char, CharTraits>& operator<<(
+    std::basic_ostream<Char, CharTraits>& os,
+    const AllowsGenericStreamingAndImplicitConversionTemplate<T>& /* a */) {
+  return os << "AllowsGenericStreamingAndImplicitConversionTemplate";
+}
+
+TEST(PrintTypeWithGenericStreamingTest, TypeImplicitlyConvertible) {
+  AllowsGenericStreamingAndImplicitConversionTemplate<int> a;
+  EXPECT_EQ("AllowsGenericStreamingAndImplicitConversionTemplate", Print(a));
+}
+
+#if GTEST_HAS_STRING_PIECE_
+
+// Tests printing StringPiece.
+
+TEST(PrintStringPieceTest, SimpleStringPiece) {
+  const StringPiece sp = "Hello";
+  EXPECT_EQ("\"Hello\"", Print(sp));
+}
+
+TEST(PrintStringPieceTest, UnprintableCharacters) {
+  const char str[] = "NUL (\0) and \r\t";
+  const StringPiece sp(str, sizeof(str) - 1);
+  EXPECT_EQ("\"NUL (\\0) and \\r\\t\"", Print(sp));
+}
+
+#endif  // GTEST_HAS_STRING_PIECE_
+
+// Tests printing STL containers.
+
+TEST(PrintStlContainerTest, EmptyDeque) {
+  deque<char> empty;
+  EXPECT_EQ("{}", Print(empty));
+}
+
+TEST(PrintStlContainerTest, NonEmptyDeque) {
+  deque<int> non_empty;
+  non_empty.push_back(1);
+  non_empty.push_back(3);
+  EXPECT_EQ("{ 1, 3 }", Print(non_empty));
+}
+
+#if GTEST_HAS_HASH_MAP_
+
+TEST(PrintStlContainerTest, OneElementHashMap) {
+  hash_map<int, char> map1;
+  map1[1] = 'a';
+  EXPECT_EQ("{ (1, 'a' (97, 0x61)) }", Print(map1));
+}
+
+TEST(PrintStlContainerTest, HashMultiMap) {
+  hash_multimap<int, bool> map1;
+  map1.insert(make_pair(5, true));
+  map1.insert(make_pair(5, false));
+
+  // Elements of hash_multimap can be printed in any order.
+  const string result = Print(map1);
+  EXPECT_TRUE(result == "{ (5, true), (5, false) }" ||
+              result == "{ (5, false), (5, true) }")
+                  << " where Print(map1) returns \"" << result << "\".";
+}
+
+#endif  // GTEST_HAS_HASH_MAP_
+
+#if GTEST_HAS_HASH_SET_
+
+TEST(PrintStlContainerTest, HashSet) {
+  hash_set<string> set1;
+  set1.insert("hello");
+  EXPECT_EQ("{ \"hello\" }", Print(set1));
+}
+
+TEST(PrintStlContainerTest, HashMultiSet) {
+  const int kSize = 5;
+  int a[kSize] = { 1, 1, 2, 5, 1 };
+  hash_multiset<int> set1(a, a + kSize);
+
+  // Elements of hash_multiset can be printed in any order.
+  const string result = Print(set1);
+  const string expected_pattern = "{ d, d, d, d, d }";  // d means a digit.
+
+  // Verifies the result matches the expected pattern; also extracts
+  // the numbers in the result.
+  ASSERT_EQ(expected_pattern.length(), result.length());
+  std::vector<int> numbers;
+  for (size_t i = 0; i != result.length(); i++) {
+    if (expected_pattern[i] == 'd') {
+      ASSERT_NE(isdigit(static_cast<unsigned char>(result[i])), 0);
+      numbers.push_back(result[i] - '0');
+    } else {
+      EXPECT_EQ(expected_pattern[i], result[i]) << " where result is "
+                                                << result;
+    }
+  }
+
+  // Makes sure the result contains the right numbers.
+  std::sort(numbers.begin(), numbers.end());
+  std::sort(a, a + kSize);
+  EXPECT_TRUE(std::equal(a, a + kSize, numbers.begin()));
+}
+
+#endif  // GTEST_HAS_HASH_SET_
+
+TEST(PrintStlContainerTest, List) {
+  const string a[] = {
+    "hello",
+    "world"
+  };
+  const list<string> strings(a, a + 2);
+  EXPECT_EQ("{ \"hello\", \"world\" }", Print(strings));
+}
+
+TEST(PrintStlContainerTest, Map) {
+  map<int, bool> map1;
+  map1[1] = true;
+  map1[5] = false;
+  map1[3] = true;
+  EXPECT_EQ("{ (1, true), (3, true), (5, false) }", Print(map1));
+}
+
+TEST(PrintStlContainerTest, MultiMap) {
+  multimap<bool, int> map1;
+  // The make_pair template function would deduce the type as
+  // pair<bool, int> here, and since the key part in a multimap has to
+  // be constant, without a templated ctor in the pair class (as in
+  // libCstd on Solaris), make_pair call would fail to compile as no
+  // implicit conversion is found.  Thus explicit typename is used
+  // here instead.
+  map1.insert(pair<const bool, int>(true, 0));
+  map1.insert(pair<const bool, int>(true, 1));
+  map1.insert(pair<const bool, int>(false, 2));
+  EXPECT_EQ("{ (false, 2), (true, 0), (true, 1) }", Print(map1));
+}
+
+TEST(PrintStlContainerTest, Set) {
+  const unsigned int a[] = { 3, 0, 5 };
+  set<unsigned int> set1(a, a + 3);
+  EXPECT_EQ("{ 0, 3, 5 }", Print(set1));
+}
+
+TEST(PrintStlContainerTest, MultiSet) {
+  const int a[] = { 1, 1, 2, 5, 1 };
+  multiset<int> set1(a, a + 5);
+  EXPECT_EQ("{ 1, 1, 1, 2, 5 }", Print(set1));
+}
+
+#if GTEST_HAS_STD_FORWARD_LIST_
+// <slist> is available on Linux in the google3 mode, but not on
+// Windows or Mac OS X.
+
+TEST(PrintStlContainerTest, SinglyLinkedList) {
+  int a[] = { 9, 2, 8 };
+  const std::forward_list<int> ints(a, a + 3);
+  EXPECT_EQ("{ 9, 2, 8 }", Print(ints));
+}
+#endif  // GTEST_HAS_STD_FORWARD_LIST_
+
+TEST(PrintStlContainerTest, Pair) {
+  pair<const bool, int> p(true, 5);
+  EXPECT_EQ("(true, 5)", Print(p));
+}
+
+TEST(PrintStlContainerTest, Vector) {
+  vector<int> v;
+  v.push_back(1);
+  v.push_back(2);
+  EXPECT_EQ("{ 1, 2 }", Print(v));
+}
+
+TEST(PrintStlContainerTest, LongSequence) {
+  const int a[100] = { 1, 2, 3 };
+  const vector<int> v(a, a + 100);
+  EXPECT_EQ("{ 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
+            "0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... }", Print(v));
+}
+
+TEST(PrintStlContainerTest, NestedContainer) {
+  const int a1[] = { 1, 2 };
+  const int a2[] = { 3, 4, 5 };
+  const list<int> l1(a1, a1 + 2);
+  const list<int> l2(a2, a2 + 3);
+
+  vector<list<int> > v;
+  v.push_back(l1);
+  v.push_back(l2);
+  EXPECT_EQ("{ { 1, 2 }, { 3, 4, 5 } }", Print(v));
+}
+
+TEST(PrintStlContainerTest, OneDimensionalNativeArray) {
+  const int a[3] = { 1, 2, 3 };
+  NativeArray<int> b(a, 3, RelationToSourceReference());
+  EXPECT_EQ("{ 1, 2, 3 }", Print(b));
+}
+
+TEST(PrintStlContainerTest, TwoDimensionalNativeArray) {
+  const int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
+  NativeArray<int[3]> b(a, 2, RelationToSourceReference());
+  EXPECT_EQ("{ { 1, 2, 3 }, { 4, 5, 6 } }", Print(b));
+}
+
+// Tests that a class named iterator isn't treated as a container.
+
+struct iterator {
+  char x;
+};
+
+TEST(PrintStlContainerTest, Iterator) {
+  iterator it = {};
+  EXPECT_EQ("1-byte object <00>", Print(it));
+}
+
+// Tests that a class named const_iterator isn't treated as a container.
+
+struct const_iterator {
+  char x;
+};
+
+TEST(PrintStlContainerTest, ConstIterator) {
+  const_iterator it = {};
+  EXPECT_EQ("1-byte object <00>", Print(it));
+}
+
+#if GTEST_HAS_TR1_TUPLE
+// Tests printing ::std::tr1::tuples.
+
+// Tuples of various arities.
+TEST(PrintTr1TupleTest, VariousSizes) {
+  ::std::tr1::tuple<> t0;
+  EXPECT_EQ("()", Print(t0));
+
+  ::std::tr1::tuple<int> t1(5);
+  EXPECT_EQ("(5)", Print(t1));
+
+  ::std::tr1::tuple<char, bool> t2('a', true);
+  EXPECT_EQ("('a' (97, 0x61), true)", Print(t2));
+
+  ::std::tr1::tuple<bool, int, int> t3(false, 2, 3);
+  EXPECT_EQ("(false, 2, 3)", Print(t3));
+
+  ::std::tr1::tuple<bool, int, int, int> t4(false, 2, 3, 4);
+  EXPECT_EQ("(false, 2, 3, 4)", Print(t4));
+
+  ::std::tr1::tuple<bool, int, int, int, bool> t5(false, 2, 3, 4, true);
+  EXPECT_EQ("(false, 2, 3, 4, true)", Print(t5));
+
+  ::std::tr1::tuple<bool, int, int, int, bool, int> t6(false, 2, 3, 4, true, 6);
+  EXPECT_EQ("(false, 2, 3, 4, true, 6)", Print(t6));
+
+  ::std::tr1::tuple<bool, int, int, int, bool, int, int> t7(
+      false, 2, 3, 4, true, 6, 7);
+  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7)", Print(t7));
+
+  ::std::tr1::tuple<bool, int, int, int, bool, int, int, bool> t8(
+      false, 2, 3, 4, true, 6, 7, true);
+  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7, true)", Print(t8));
+
+  ::std::tr1::tuple<bool, int, int, int, bool, int, int, bool, int> t9(
+      false, 2, 3, 4, true, 6, 7, true, 9);
+  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7, true, 9)", Print(t9));
+
+  const char* const str = "8";
+  // VC++ 2010's implementation of tuple of C++0x is deficient, requiring
+  // an explicit type cast of NULL to be used.
+  ::std::tr1::tuple<bool, char, short, testing::internal::Int32,  // NOLINT
+      testing::internal::Int64, float, double, const char*, void*, string>
+      t10(false, 'a', 3, 4, 5, 1.5F, -2.5, str,
+          ImplicitCast_<void*>(NULL), "10");
+  EXPECT_EQ("(false, 'a' (97, 0x61), 3, 4, 5, 1.5, -2.5, " + PrintPointer(str) +
+            " pointing to \"8\", NULL, \"10\")",
+            Print(t10));
+}
+
+// Nested tuples.
+TEST(PrintTr1TupleTest, NestedTuple) {
+  ::std::tr1::tuple< ::std::tr1::tuple<int, bool>, char> nested(
+      ::std::tr1::make_tuple(5, true), 'a');
+  EXPECT_EQ("((5, true), 'a' (97, 0x61))", Print(nested));
+}
+
+#endif  // GTEST_HAS_TR1_TUPLE
+
+#if GTEST_HAS_STD_TUPLE_
+// Tests printing ::std::tuples.
+
+// Tuples of various arities.
+TEST(PrintStdTupleTest, VariousSizes) {
+  ::std::tuple<> t0;
+  EXPECT_EQ("()", Print(t0));
+
+  ::std::tuple<int> t1(5);
+  EXPECT_EQ("(5)", Print(t1));
+
+  ::std::tuple<char, bool> t2('a', true);
+  EXPECT_EQ("('a' (97, 0x61), true)", Print(t2));
+
+  ::std::tuple<bool, int, int> t3(false, 2, 3);
+  EXPECT_EQ("(false, 2, 3)", Print(t3));
+
+  ::std::tuple<bool, int, int, int> t4(false, 2, 3, 4);
+  EXPECT_EQ("(false, 2, 3, 4)", Print(t4));
+
+  ::std::tuple<bool, int, int, int, bool> t5(false, 2, 3, 4, true);
+  EXPECT_EQ("(false, 2, 3, 4, true)", Print(t5));
+
+  ::std::tuple<bool, int, int, int, bool, int> t6(false, 2, 3, 4, true, 6);
+  EXPECT_EQ("(false, 2, 3, 4, true, 6)", Print(t6));
+
+  ::std::tuple<bool, int, int, int, bool, int, int> t7(
+      false, 2, 3, 4, true, 6, 7);
+  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7)", Print(t7));
+
+  ::std::tuple<bool, int, int, int, bool, int, int, bool> t8(
+      false, 2, 3, 4, true, 6, 7, true);
+  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7, true)", Print(t8));
+
+  ::std::tuple<bool, int, int, int, bool, int, int, bool, int> t9(
+      false, 2, 3, 4, true, 6, 7, true, 9);
+  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7, true, 9)", Print(t9));
+
+  const char* const str = "8";
+  // VC++ 2010's implementation of tuple of C++0x is deficient, requiring
+  // an explicit type cast of NULL to be used.
+  ::std::tuple<bool, char, short, testing::internal::Int32,  // NOLINT
+      testing::internal::Int64, float, double, const char*, void*, string>
+      t10(false, 'a', 3, 4, 5, 1.5F, -2.5, str,
+          ImplicitCast_<void*>(NULL), "10");
+  EXPECT_EQ("(false, 'a' (97, 0x61), 3, 4, 5, 1.5, -2.5, " + PrintPointer(str) +
+            " pointing to \"8\", NULL, \"10\")",
+            Print(t10));
+}
+
+// Nested tuples.
+TEST(PrintStdTupleTest, NestedTuple) {
+  ::std::tuple< ::std::tuple<int, bool>, char> nested(
+      ::std::make_tuple(5, true), 'a');
+  EXPECT_EQ("((5, true), 'a' (97, 0x61))", Print(nested));
+}
+
+#endif  // GTEST_LANG_CXX11
+
+// Tests printing user-defined unprintable types.
+
+// Unprintable types in the global namespace.
+TEST(PrintUnprintableTypeTest, InGlobalNamespace) {
+  EXPECT_EQ("1-byte object <00>",
+            Print(UnprintableTemplateInGlobal<char>()));
+}
+
+// Unprintable types in a user namespace.
+TEST(PrintUnprintableTypeTest, InUserNamespace) {
+  EXPECT_EQ("16-byte object <EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
+            Print(::foo::UnprintableInFoo()));
+}
+
+// Unprintable types are that too big to be printed completely.
+
+struct Big {
+  Big() { memset(array, 0, sizeof(array)); }
+  char array[257];
+};
+
+TEST(PrintUnpritableTypeTest, BigObject) {
+  EXPECT_EQ("257-byte object <00-00 00-00 00-00 00-00 00-00 00-00 "
+            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
+            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
+            "00-00 00-00 00-00 00-00 00-00 00-00 ... 00-00 00-00 00-00 "
+            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
+            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
+            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00>",
+            Print(Big()));
+}
+
+// Tests printing user-defined streamable types.
+
+// Streamable types in the global namespace.
+TEST(PrintStreamableTypeTest, InGlobalNamespace) {
+  StreamableInGlobal x;
+  EXPECT_EQ("StreamableInGlobal", Print(x));
+  EXPECT_EQ("StreamableInGlobal*", Print(&x));
+}
+
+// Printable template types in a user namespace.
+TEST(PrintStreamableTypeTest, TemplateTypeInUserNamespace) {
+  EXPECT_EQ("StreamableTemplateInFoo: 0",
+            Print(::foo::StreamableTemplateInFoo<int>()));
+}
+
+// Tests printing user-defined types that have a PrintTo() function.
+TEST(PrintPrintableTypeTest, InUserNamespace) {
+  EXPECT_EQ("PrintableViaPrintTo: 0",
+            Print(::foo::PrintableViaPrintTo()));
+}
+
+// Tests printing a pointer to a user-defined type that has a <<
+// operator for its pointer.
+TEST(PrintPrintableTypeTest, PointerInUserNamespace) {
+  ::foo::PointerPrintable x;
+  EXPECT_EQ("PointerPrintable*", Print(&x));
+}
+
+// Tests printing user-defined class template that have a PrintTo() function.
+TEST(PrintPrintableTypeTest, TemplateInUserNamespace) {
+  EXPECT_EQ("PrintableViaPrintToTemplate: 5",
+            Print(::foo::PrintableViaPrintToTemplate<int>(5)));
+}
+
+// Tests that the universal printer prints both the address and the
+// value of a reference.
+TEST(PrintReferenceTest, PrintsAddressAndValue) {
+  int n = 5;
+  EXPECT_EQ("@" + PrintPointer(&n) + " 5", PrintByRef(n));
+
+  int a[2][3] = {
+    { 0, 1, 2 },
+    { 3, 4, 5 }
+  };
+  EXPECT_EQ("@" + PrintPointer(a) + " { { 0, 1, 2 }, { 3, 4, 5 } }",
+            PrintByRef(a));
+
+  const ::foo::UnprintableInFoo x;
+  EXPECT_EQ("@" + PrintPointer(&x) + " 16-byte object "
+            "<EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
+            PrintByRef(x));
+}
+
+// Tests that the universal printer prints a function pointer passed by
+// reference.
+TEST(PrintReferenceTest, HandlesFunctionPointer) {
+  void (*fp)(int n) = &MyFunction;
+  const string fp_pointer_string =
+      PrintPointer(reinterpret_cast<const void*>(&fp));
+  // We cannot directly cast &MyFunction to const void* because the
+  // standard disallows casting between pointers to functions and
+  // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
+  // this limitation.
+  const string fp_string = PrintPointer(reinterpret_cast<const void*>(
+      reinterpret_cast<internal::BiggestInt>(fp)));
+  EXPECT_EQ("@" + fp_pointer_string + " " + fp_string,
+            PrintByRef(fp));
+}
+
+// Tests that the universal printer prints a member function pointer
+// passed by reference.
+TEST(PrintReferenceTest, HandlesMemberFunctionPointer) {
+  int (Foo::*p)(char ch) = &Foo::MyMethod;
+  EXPECT_TRUE(HasPrefix(
+      PrintByRef(p),
+      "@" + PrintPointer(reinterpret_cast<const void*>(&p)) + " " +
+          Print(sizeof(p)) + "-byte object "));
+
+  char (Foo::*p2)(int n) = &Foo::MyVirtualMethod;
+  EXPECT_TRUE(HasPrefix(
+      PrintByRef(p2),
+      "@" + PrintPointer(reinterpret_cast<const void*>(&p2)) + " " +
+          Print(sizeof(p2)) + "-byte object "));
+}
+
+// Tests that the universal printer prints a member variable pointer
+// passed by reference.
+TEST(PrintReferenceTest, HandlesMemberVariablePointer) {
+  int (Foo::*p) = &Foo::value;  // NOLINT
+  EXPECT_TRUE(HasPrefix(
+      PrintByRef(p),
+      "@" + PrintPointer(&p) + " " + Print(sizeof(p)) + "-byte object "));
+}
+
+// Tests that FormatForComparisonFailureMessage(), which is used to print
+// an operand in a comparison assertion (e.g. ASSERT_EQ) when the assertion
+// fails, formats the operand in the desired way.
+
+// scalar
+TEST(FormatForComparisonFailureMessageTest, WorksForScalar) {
+  EXPECT_STREQ("123",
+               FormatForComparisonFailureMessage(123, 124).c_str());
+}
+
+// non-char pointer
+TEST(FormatForComparisonFailureMessageTest, WorksForNonCharPointer) {
+  int n = 0;
+  EXPECT_EQ(PrintPointer(&n),
+            FormatForComparisonFailureMessage(&n, &n).c_str());
+}
+
+// non-char array
+TEST(FormatForComparisonFailureMessageTest, FormatsNonCharArrayAsPointer) {
+  // In expression 'array == x', 'array' is compared by pointer.
+  // Therefore we want to print an array operand as a pointer.
+  int n[] = { 1, 2, 3 };
+  EXPECT_EQ(PrintPointer(n),
+            FormatForComparisonFailureMessage(n, n).c_str());
+}
+
+// Tests formatting a char pointer when it's compared with another pointer.
+// In this case we want to print it as a raw pointer, as the comparision is by
+// pointer.
+
+// char pointer vs pointer
+TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsPointer) {
+  // In expression 'p == x', where 'p' and 'x' are (const or not) char
+  // pointers, the operands are compared by pointer.  Therefore we
+  // want to print 'p' as a pointer instead of a C string (we don't
+  // even know if it's supposed to point to a valid C string).
+
+  // const char*
+  const char* s = "hello";
+  EXPECT_EQ(PrintPointer(s),
+            FormatForComparisonFailureMessage(s, s).c_str());
+
+  // char*
+  char ch = 'a';
+  EXPECT_EQ(PrintPointer(&ch),
+            FormatForComparisonFailureMessage(&ch, &ch).c_str());
+}
+
+// wchar_t pointer vs pointer
+TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsPointer) {
+  // In expression 'p == x', where 'p' and 'x' are (const or not) char
+  // pointers, the operands are compared by pointer.  Therefore we
+  // want to print 'p' as a pointer instead of a wide C string (we don't
+  // even know if it's supposed to point to a valid wide C string).
+
+  // const wchar_t*
+  const wchar_t* s = L"hello";
+  EXPECT_EQ(PrintPointer(s),
+            FormatForComparisonFailureMessage(s, s).c_str());
+
+  // wchar_t*
+  wchar_t ch = L'a';
+  EXPECT_EQ(PrintPointer(&ch),
+            FormatForComparisonFailureMessage(&ch, &ch).c_str());
+}
+
+// Tests formatting a char pointer when it's compared to a string object.
+// In this case we want to print the char pointer as a C string.
+
+#if GTEST_HAS_GLOBAL_STRING
+// char pointer vs ::string
+TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsString) {
+  const char* s = "hello \"world";
+  EXPECT_STREQ("\"hello \\\"world\"",  // The string content should be escaped.
+               FormatForComparisonFailureMessage(s, ::string()).c_str());
+
+  // char*
+  char str[] = "hi\1";
+  char* p = str;
+  EXPECT_STREQ("\"hi\\x1\"",  // The string content should be escaped.
+               FormatForComparisonFailureMessage(p, ::string()).c_str());
+}
+#endif
+
+// char pointer vs std::string
+TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsStdString) {
+  const char* s = "hello \"world";
+  EXPECT_STREQ("\"hello \\\"world\"",  // The string content should be escaped.
+               FormatForComparisonFailureMessage(s, ::std::string()).c_str());
+
+  // char*
+  char str[] = "hi\1";
+  char* p = str;
+  EXPECT_STREQ("\"hi\\x1\"",  // The string content should be escaped.
+               FormatForComparisonFailureMessage(p, ::std::string()).c_str());
+}
+
+#if GTEST_HAS_GLOBAL_WSTRING
+// wchar_t pointer vs ::wstring
+TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsWString) {
+  const wchar_t* s = L"hi \"world";
+  EXPECT_STREQ("L\"hi \\\"world\"",  // The string content should be escaped.
+               FormatForComparisonFailureMessage(s, ::wstring()).c_str());
+
+  // wchar_t*
+  wchar_t str[] = L"hi\1";
+  wchar_t* p = str;
+  EXPECT_STREQ("L\"hi\\x1\"",  // The string content should be escaped.
+               FormatForComparisonFailureMessage(p, ::wstring()).c_str());
+}
+#endif
+
+#if GTEST_HAS_STD_WSTRING
+// wchar_t pointer vs std::wstring
+TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsStdWString) {
+  const wchar_t* s = L"hi \"world";
+  EXPECT_STREQ("L\"hi \\\"world\"",  // The string content should be escaped.
+               FormatForComparisonFailureMessage(s, ::std::wstring()).c_str());
+
+  // wchar_t*
+  wchar_t str[] = L"hi\1";
+  wchar_t* p = str;
+  EXPECT_STREQ("L\"hi\\x1\"",  // The string content should be escaped.
+               FormatForComparisonFailureMessage(p, ::std::wstring()).c_str());
+}
+#endif
+
+// Tests formatting a char array when it's compared with a pointer or array.
+// In this case we want to print the array as a row pointer, as the comparison
+// is by pointer.
+
+// char array vs pointer
+TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsPointer) {
+  char str[] = "hi \"world\"";
+  char* p = NULL;
+  EXPECT_EQ(PrintPointer(str),
+            FormatForComparisonFailureMessage(str, p).c_str());
+}
+
+// char array vs char array
+TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsCharArray) {
+  const char str[] = "hi \"world\"";
+  EXPECT_EQ(PrintPointer(str),
+            FormatForComparisonFailureMessage(str, str).c_str());
+}
+
+// wchar_t array vs pointer
+TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsPointer) {
+  wchar_t str[] = L"hi \"world\"";
+  wchar_t* p = NULL;
+  EXPECT_EQ(PrintPointer(str),
+            FormatForComparisonFailureMessage(str, p).c_str());
+}
+
+// wchar_t array vs wchar_t array
+TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsWCharArray) {
+  const wchar_t str[] = L"hi \"world\"";
+  EXPECT_EQ(PrintPointer(str),
+            FormatForComparisonFailureMessage(str, str).c_str());
+}
+
+// Tests formatting a char array when it's compared with a string object.
+// In this case we want to print the array as a C string.
+
+#if GTEST_HAS_GLOBAL_STRING
+// char array vs string
+TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsString) {
+  const char str[] = "hi \"w\0rld\"";
+  EXPECT_STREQ("\"hi \\\"w\"",  // The content should be escaped.
+                                // Embedded NUL terminates the string.
+               FormatForComparisonFailureMessage(str, ::string()).c_str());
+}
+#endif
+
+// char array vs std::string
+TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsStdString) {
+  const char str[] = "hi \"world\"";
+  EXPECT_STREQ("\"hi \\\"world\\\"\"",  // The content should be escaped.
+               FormatForComparisonFailureMessage(str, ::std::string()).c_str());
+}
+
+#if GTEST_HAS_GLOBAL_WSTRING
+// wchar_t array vs wstring
+TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsWString) {
+  const wchar_t str[] = L"hi \"world\"";
+  EXPECT_STREQ("L\"hi \\\"world\\\"\"",  // The content should be escaped.
+               FormatForComparisonFailureMessage(str, ::wstring()).c_str());
+}
+#endif
+
+#if GTEST_HAS_STD_WSTRING
+// wchar_t array vs std::wstring
+TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsStdWString) {
+  const wchar_t str[] = L"hi \"w\0rld\"";
+  EXPECT_STREQ(
+      "L\"hi \\\"w\"",  // The content should be escaped.
+                        // Embedded NUL terminates the string.
+      FormatForComparisonFailureMessage(str, ::std::wstring()).c_str());
+}
+#endif
+
+// Useful for testing PrintToString().  We cannot use EXPECT_EQ()
+// there as its implementation uses PrintToString().  The caller must
+// ensure that 'value' has no side effect.
+#define EXPECT_PRINT_TO_STRING_(value, expected_string)         \
+  EXPECT_TRUE(PrintToString(value) == (expected_string))        \
+      << " where " #value " prints as " << (PrintToString(value))
+
+TEST(PrintToStringTest, WorksForScalar) {
+  EXPECT_PRINT_TO_STRING_(123, "123");
+}
+
+TEST(PrintToStringTest, WorksForPointerToConstChar) {
+  const char* p = "hello";
+  EXPECT_PRINT_TO_STRING_(p, "\"hello\"");
+}
+
+TEST(PrintToStringTest, WorksForPointerToNonConstChar) {
+  char s[] = "hello";
+  char* p = s;
+  EXPECT_PRINT_TO_STRING_(p, "\"hello\"");
+}
+
+TEST(PrintToStringTest, EscapesForPointerToConstChar) {
+  const char* p = "hello\n";
+  EXPECT_PRINT_TO_STRING_(p, "\"hello\\n\"");
+}
+
+TEST(PrintToStringTest, EscapesForPointerToNonConstChar) {
+  char s[] = "hello\1";
+  char* p = s;
+  EXPECT_PRINT_TO_STRING_(p, "\"hello\\x1\"");
+}
+
+TEST(PrintToStringTest, WorksForArray) {
+  int n[3] = { 1, 2, 3 };
+  EXPECT_PRINT_TO_STRING_(n, "{ 1, 2, 3 }");
+}
+
+TEST(PrintToStringTest, WorksForCharArray) {
+  char s[] = "hello";
+  EXPECT_PRINT_TO_STRING_(s, "\"hello\"");
+}
+
+TEST(PrintToStringTest, WorksForCharArrayWithEmbeddedNul) {
+  const char str_with_nul[] = "hello\0 world";
+  EXPECT_PRINT_TO_STRING_(str_with_nul, "\"hello\\0 world\"");
+
+  char mutable_str_with_nul[] = "hello\0 world";
+  EXPECT_PRINT_TO_STRING_(mutable_str_with_nul, "\"hello\\0 world\"");
+}
+
+#undef EXPECT_PRINT_TO_STRING_
+
+TEST(UniversalTersePrintTest, WorksForNonReference) {
+  ::std::stringstream ss;
+  UniversalTersePrint(123, &ss);
+  EXPECT_EQ("123", ss.str());
+}
+
+TEST(UniversalTersePrintTest, WorksForReference) {
+  const int& n = 123;
+  ::std::stringstream ss;
+  UniversalTersePrint(n, &ss);
+  EXPECT_EQ("123", ss.str());
+}
+
+TEST(UniversalTersePrintTest, WorksForCString) {
+  const char* s1 = "abc";
+  ::std::stringstream ss1;
+  UniversalTersePrint(s1, &ss1);
+  EXPECT_EQ("\"abc\"", ss1.str());
+
+  char* s2 = const_cast<char*>(s1);
+  ::std::stringstream ss2;
+  UniversalTersePrint(s2, &ss2);
+  EXPECT_EQ("\"abc\"", ss2.str());
+
+  const char* s3 = NULL;
+  ::std::stringstream ss3;
+  UniversalTersePrint(s3, &ss3);
+  EXPECT_EQ("NULL", ss3.str());
+}
+
+TEST(UniversalPrintTest, WorksForNonReference) {
+  ::std::stringstream ss;
+  UniversalPrint(123, &ss);
+  EXPECT_EQ("123", ss.str());
+}
+
+TEST(UniversalPrintTest, WorksForReference) {
+  const int& n = 123;
+  ::std::stringstream ss;
+  UniversalPrint(n, &ss);
+  EXPECT_EQ("123", ss.str());
+}
+
+TEST(UniversalPrintTest, WorksForCString) {
+  const char* s1 = "abc";
+  ::std::stringstream ss1;
+  UniversalPrint(s1, &ss1);
+  EXPECT_EQ(PrintPointer(s1) + " pointing to \"abc\"", string(ss1.str()));
+
+  char* s2 = const_cast<char*>(s1);
+  ::std::stringstream ss2;
+  UniversalPrint(s2, &ss2);
+  EXPECT_EQ(PrintPointer(s2) + " pointing to \"abc\"", string(ss2.str()));
+
+  const char* s3 = NULL;
+  ::std::stringstream ss3;
+  UniversalPrint(s3, &ss3);
+  EXPECT_EQ("NULL", ss3.str());
+}
+
+TEST(UniversalPrintTest, WorksForCharArray) {
+  const char str[] = "\"Line\0 1\"\nLine 2";
+  ::std::stringstream ss1;
+  UniversalPrint(str, &ss1);
+  EXPECT_EQ("\"\\\"Line\\0 1\\\"\\nLine 2\"", ss1.str());
+
+  const char mutable_str[] = "\"Line\0 1\"\nLine 2";
+  ::std::stringstream ss2;
+  UniversalPrint(mutable_str, &ss2);
+  EXPECT_EQ("\"\\\"Line\\0 1\\\"\\nLine 2\"", ss2.str());
+}
+
+#if GTEST_HAS_TR1_TUPLE
+
+TEST(UniversalTersePrintTupleFieldsToStringsTestWithTr1, PrintsEmptyTuple) {
+  Strings result = UniversalTersePrintTupleFieldsToStrings(
+      ::std::tr1::make_tuple());
+  EXPECT_EQ(0u, result.size());
+}
+
+TEST(UniversalTersePrintTupleFieldsToStringsTestWithTr1, PrintsOneTuple) {
+  Strings result = UniversalTersePrintTupleFieldsToStrings(
+      ::std::tr1::make_tuple(1));
+  ASSERT_EQ(1u, result.size());
+  EXPECT_EQ("1", result[0]);
+}
+
+TEST(UniversalTersePrintTupleFieldsToStringsTestWithTr1, PrintsTwoTuple) {
+  Strings result = UniversalTersePrintTupleFieldsToStrings(
+      ::std::tr1::make_tuple(1, 'a'));
+  ASSERT_EQ(2u, result.size());
+  EXPECT_EQ("1", result[0]);
+  EXPECT_EQ("'a' (97, 0x61)", result[1]);
+}
+
+TEST(UniversalTersePrintTupleFieldsToStringsTestWithTr1, PrintsTersely) {
+  const int n = 1;
+  Strings result = UniversalTersePrintTupleFieldsToStrings(
+      ::std::tr1::tuple<const int&, const char*>(n, "a"));
+  ASSERT_EQ(2u, result.size());
+  EXPECT_EQ("1", result[0]);
+  EXPECT_EQ("\"a\"", result[1]);
+}
+
+#endif  // GTEST_HAS_TR1_TUPLE
+
+#if GTEST_HAS_STD_TUPLE_
+
+TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsEmptyTuple) {
+  Strings result = UniversalTersePrintTupleFieldsToStrings(::std::make_tuple());
+  EXPECT_EQ(0u, result.size());
+}
+
+TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsOneTuple) {
+  Strings result = UniversalTersePrintTupleFieldsToStrings(
+      ::std::make_tuple(1));
+  ASSERT_EQ(1u, result.size());
+  EXPECT_EQ("1", result[0]);
+}
+
+TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTwoTuple) {
+  Strings result = UniversalTersePrintTupleFieldsToStrings(
+      ::std::make_tuple(1, 'a'));
+  ASSERT_EQ(2u, result.size());
+  EXPECT_EQ("1", result[0]);
+  EXPECT_EQ("'a' (97, 0x61)", result[1]);
+}
+
+TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTersely) {
+  const int n = 1;
+  Strings result = UniversalTersePrintTupleFieldsToStrings(
+      ::std::tuple<const int&, const char*>(n, "a"));
+  ASSERT_EQ(2u, result.size());
+  EXPECT_EQ("1", result[0]);
+  EXPECT_EQ("\"a\"", result[1]);
+}
+
+#endif  // GTEST_HAS_STD_TUPLE_
+
+}  // namespace gtest_printers_test
+}  // namespace testing
+
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-test-part_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-test-part_test.cc
new file mode 100644
index 00000000..ca8ba933
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-test-part_test.cc
@@ -0,0 +1,208 @@
+// 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.
+//
+// Author: mheule@google.com (Markus Heule)
+//
+
+#include "gtest/gtest-test-part.h"
+
+#include "gtest/gtest.h"
+
+using testing::Message;
+using testing::Test;
+using testing::TestPartResult;
+using testing::TestPartResultArray;
+
+namespace {
+
+// Tests the TestPartResult class.
+
+// The test fixture for testing TestPartResult.
+class TestPartResultTest : public Test {
+ protected:
+  TestPartResultTest()
+      : r1_(TestPartResult::kSuccess, "foo/bar.cc", 10, "Success!"),
+        r2_(TestPartResult::kNonFatalFailure, "foo/bar.cc", -1, "Failure!"),
+        r3_(TestPartResult::kFatalFailure, NULL, -1, "Failure!") {}
+
+  TestPartResult r1_, r2_, r3_;
+};
+
+
+TEST_F(TestPartResultTest, ConstructorWorks) {
+  Message message;
+  message << "something is terribly wrong";
+  message << static_cast<const char*>(testing::internal::kStackTraceMarker);
+  message << "some unimportant stack trace";
+
+  const TestPartResult result(TestPartResult::kNonFatalFailure,
+                              "some_file.cc",
+                              42,
+                              message.GetString().c_str());
+
+  EXPECT_EQ(TestPartResult::kNonFatalFailure, result.type());
+  EXPECT_STREQ("some_file.cc", result.file_name());
+  EXPECT_EQ(42, result.line_number());
+  EXPECT_STREQ(message.GetString().c_str(), result.message());
+  EXPECT_STREQ("something is terribly wrong", result.summary());
+}
+
+TEST_F(TestPartResultTest, ResultAccessorsWork) {
+  const TestPartResult success(TestPartResult::kSuccess,
+                               "file.cc",
+                               42,
+                               "message");
+  EXPECT_TRUE(success.passed());
+  EXPECT_FALSE(success.failed());
+  EXPECT_FALSE(success.nonfatally_failed());
+  EXPECT_FALSE(success.fatally_failed());
+
+  const TestPartResult nonfatal_failure(TestPartResult::kNonFatalFailure,
+                                        "file.cc",
+                                        42,
+                                        "message");
+  EXPECT_FALSE(nonfatal_failure.passed());
+  EXPECT_TRUE(nonfatal_failure.failed());
+  EXPECT_TRUE(nonfatal_failure.nonfatally_failed());
+  EXPECT_FALSE(nonfatal_failure.fatally_failed());
+
+  const TestPartResult fatal_failure(TestPartResult::kFatalFailure,
+                                     "file.cc",
+                                     42,
+                                     "message");
+  EXPECT_FALSE(fatal_failure.passed());
+  EXPECT_TRUE(fatal_failure.failed());
+  EXPECT_FALSE(fatal_failure.nonfatally_failed());
+  EXPECT_TRUE(fatal_failure.fatally_failed());
+}
+
+// Tests TestPartResult::type().
+TEST_F(TestPartResultTest, type) {
+  EXPECT_EQ(TestPartResult::kSuccess, r1_.type());
+  EXPECT_EQ(TestPartResult::kNonFatalFailure, r2_.type());
+  EXPECT_EQ(TestPartResult::kFatalFailure, r3_.type());
+}
+
+// Tests TestPartResult::file_name().
+TEST_F(TestPartResultTest, file_name) {
+  EXPECT_STREQ("foo/bar.cc", r1_.file_name());
+  EXPECT_STREQ(NULL, r3_.file_name());
+}
+
+// Tests TestPartResult::line_number().
+TEST_F(TestPartResultTest, line_number) {
+  EXPECT_EQ(10, r1_.line_number());
+  EXPECT_EQ(-1, r2_.line_number());
+}
+
+// Tests TestPartResult::message().
+TEST_F(TestPartResultTest, message) {
+  EXPECT_STREQ("Success!", r1_.message());
+}
+
+// Tests TestPartResult::passed().
+TEST_F(TestPartResultTest, Passed) {
+  EXPECT_TRUE(r1_.passed());
+  EXPECT_FALSE(r2_.passed());
+  EXPECT_FALSE(r3_.passed());
+}
+
+// Tests TestPartResult::failed().
+TEST_F(TestPartResultTest, Failed) {
+  EXPECT_FALSE(r1_.failed());
+  EXPECT_TRUE(r2_.failed());
+  EXPECT_TRUE(r3_.failed());
+}
+
+// Tests TestPartResult::fatally_failed().
+TEST_F(TestPartResultTest, FatallyFailed) {
+  EXPECT_FALSE(r1_.fatally_failed());
+  EXPECT_FALSE(r2_.fatally_failed());
+  EXPECT_TRUE(r3_.fatally_failed());
+}
+
+// Tests TestPartResult::nonfatally_failed().
+TEST_F(TestPartResultTest, NonfatallyFailed) {
+  EXPECT_FALSE(r1_.nonfatally_failed());
+  EXPECT_TRUE(r2_.nonfatally_failed());
+  EXPECT_FALSE(r3_.nonfatally_failed());
+}
+
+// Tests the TestPartResultArray class.
+
+class TestPartResultArrayTest : public Test {
+ protected:
+  TestPartResultArrayTest()
+      : r1_(TestPartResult::kNonFatalFailure, "foo/bar.cc", -1, "Failure 1"),
+        r2_(TestPartResult::kFatalFailure, "foo/bar.cc", -1, "Failure 2") {}
+
+  const TestPartResult r1_, r2_;
+};
+
+// Tests that TestPartResultArray initially has size 0.
+TEST_F(TestPartResultArrayTest, InitialSizeIsZero) {
+  TestPartResultArray results;
+  EXPECT_EQ(0, results.size());
+}
+
+// Tests that TestPartResultArray contains the given TestPartResult
+// after one Append() operation.
+TEST_F(TestPartResultArrayTest, ContainsGivenResultAfterAppend) {
+  TestPartResultArray results;
+  results.Append(r1_);
+  EXPECT_EQ(1, results.size());
+  EXPECT_STREQ("Failure 1", results.GetTestPartResult(0).message());
+}
+
+// Tests that TestPartResultArray contains the given TestPartResults
+// after two Append() operations.
+TEST_F(TestPartResultArrayTest, ContainsGivenResultsAfterTwoAppends) {
+  TestPartResultArray results;
+  results.Append(r1_);
+  results.Append(r2_);
+  EXPECT_EQ(2, results.size());
+  EXPECT_STREQ("Failure 1", results.GetTestPartResult(0).message());
+  EXPECT_STREQ("Failure 2", results.GetTestPartResult(1).message());
+}
+
+typedef TestPartResultArrayTest TestPartResultArrayDeathTest;
+
+// Tests that the program dies when GetTestPartResult() is called with
+// an invalid index.
+TEST_F(TestPartResultArrayDeathTest, DiesWhenIndexIsOutOfBound) {
+  TestPartResultArray results;
+  results.Append(r1_);
+
+  EXPECT_DEATH_IF_SUPPORTED(results.GetTestPartResult(-1), "");
+  EXPECT_DEATH_IF_SUPPORTED(results.GetTestPartResult(1), "");
+}
+
+// TODO(mheule@google.com): Add a test for the class HasNewFatalFailureHelper.
+
+}  // namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-tuple_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-tuple_test.cc
new file mode 100644
index 00000000..bfaa3e0a
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-tuple_test.cc
@@ -0,0 +1,320 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "gtest/internal/gtest-tuple.h"
+#include <utility>
+#include "gtest/gtest.h"
+
+namespace {
+
+using ::std::tr1::get;
+using ::std::tr1::make_tuple;
+using ::std::tr1::tuple;
+using ::std::tr1::tuple_element;
+using ::std::tr1::tuple_size;
+using ::testing::StaticAssertTypeEq;
+
+// Tests that tuple_element<K, tuple<T0, T1, ..., TN> >::type returns TK.
+TEST(tuple_element_Test, ReturnsElementType) {
+  StaticAssertTypeEq<int, tuple_element<0, tuple<int, char> >::type>();
+  StaticAssertTypeEq<int&, tuple_element<1, tuple<double, int&> >::type>();
+  StaticAssertTypeEq<bool, tuple_element<2, tuple<double, int, bool> >::type>();
+}
+
+// Tests that tuple_size<T>::value gives the number of fields in tuple
+// type T.
+TEST(tuple_size_Test, ReturnsNumberOfFields) {
+  EXPECT_EQ(0, +tuple_size<tuple<> >::value);
+  EXPECT_EQ(1, +tuple_size<tuple<void*> >::value);
+  EXPECT_EQ(1, +tuple_size<tuple<char> >::value);
+  EXPECT_EQ(1, +(tuple_size<tuple<tuple<int, double> > >::value));
+  EXPECT_EQ(2, +(tuple_size<tuple<int&, const char> >::value));
+  EXPECT_EQ(3, +(tuple_size<tuple<char*, void, const bool&> >::value));
+}
+
+// Tests comparing a tuple with itself.
+TEST(ComparisonTest, ComparesWithSelf) {
+  const tuple<int, char, bool> a(5, 'a', false);
+
+  EXPECT_TRUE(a == a);
+  EXPECT_FALSE(a != a);
+}
+
+// Tests comparing two tuples with the same value.
+TEST(ComparisonTest, ComparesEqualTuples) {
+  const tuple<int, bool> a(5, true), b(5, true);
+
+  EXPECT_TRUE(a == b);
+  EXPECT_FALSE(a != b);
+}
+
+// Tests comparing two different tuples that have no reference fields.
+TEST(ComparisonTest, ComparesUnequalTuplesWithoutReferenceFields) {
+  typedef tuple<const int, char> FooTuple;
+
+  const FooTuple a(0, 'x');
+  const FooTuple b(1, 'a');
+
+  EXPECT_TRUE(a != b);
+  EXPECT_FALSE(a == b);
+
+  const FooTuple c(1, 'b');
+
+  EXPECT_TRUE(b != c);
+  EXPECT_FALSE(b == c);
+}
+
+// Tests comparing two different tuples that have reference fields.
+TEST(ComparisonTest, ComparesUnequalTuplesWithReferenceFields) {
+  typedef tuple<int&, const char&> FooTuple;
+
+  int i = 5;
+  const char ch = 'a';
+  const FooTuple a(i, ch);
+
+  int j = 6;
+  const FooTuple b(j, ch);
+
+  EXPECT_TRUE(a != b);
+  EXPECT_FALSE(a == b);
+
+  j = 5;
+  const char ch2 = 'b';
+  const FooTuple c(j, ch2);
+
+  EXPECT_TRUE(b != c);
+  EXPECT_FALSE(b == c);
+}
+
+// Tests that a tuple field with a reference type is an alias of the
+// variable it's supposed to reference.
+TEST(ReferenceFieldTest, IsAliasOfReferencedVariable) {
+  int n = 0;
+  tuple<bool, int&> t(true, n);
+
+  n = 1;
+  EXPECT_EQ(n, get<1>(t))
+      << "Changing a underlying variable should update the reference field.";
+
+  // Makes sure that the implementation doesn't do anything funny with
+  // the & operator for the return type of get<>().
+  EXPECT_EQ(&n, &(get<1>(t)))
+      << "The address of a reference field should equal the address of "
+      << "the underlying variable.";
+
+  get<1>(t) = 2;
+  EXPECT_EQ(2, n)
+      << "Changing a reference field should update the underlying variable.";
+}
+
+// Tests that tuple's default constructor default initializes each field.
+// This test needs to compile without generating warnings.
+TEST(TupleConstructorTest, DefaultConstructorDefaultInitializesEachField) {
+  // The TR1 report requires that tuple's default constructor default
+  // initializes each field, even if it's a primitive type.  If the
+  // implementation forgets to do this, this test will catch it by
+  // generating warnings about using uninitialized variables (assuming
+  // a decent compiler).
+
+  tuple<> empty;
+
+  tuple<int> a1, b1;
+  b1 = a1;
+  EXPECT_EQ(0, get<0>(b1));
+
+  tuple<int, double> a2, b2;
+  b2 = a2;
+  EXPECT_EQ(0, get<0>(b2));
+  EXPECT_EQ(0.0, get<1>(b2));
+
+  tuple<double, char, bool*> a3, b3;
+  b3 = a3;
+  EXPECT_EQ(0.0, get<0>(b3));
+  EXPECT_EQ('\0', get<1>(b3));
+  EXPECT_TRUE(get<2>(b3) == NULL);
+
+  tuple<int, int, int, int, int, int, int, int, int, int> a10, b10;
+  b10 = a10;
+  EXPECT_EQ(0, get<0>(b10));
+  EXPECT_EQ(0, get<1>(b10));
+  EXPECT_EQ(0, get<2>(b10));
+  EXPECT_EQ(0, get<3>(b10));
+  EXPECT_EQ(0, get<4>(b10));
+  EXPECT_EQ(0, get<5>(b10));
+  EXPECT_EQ(0, get<6>(b10));
+  EXPECT_EQ(0, get<7>(b10));
+  EXPECT_EQ(0, get<8>(b10));
+  EXPECT_EQ(0, get<9>(b10));
+}
+
+// Tests constructing a tuple from its fields.
+TEST(TupleConstructorTest, ConstructsFromFields) {
+  int n = 1;
+  // Reference field.
+  tuple<int&> a(n);
+  EXPECT_EQ(&n, &(get<0>(a)));
+
+  // Non-reference fields.
+  tuple<int, char> b(5, 'a');
+  EXPECT_EQ(5, get<0>(b));
+  EXPECT_EQ('a', get<1>(b));
+
+  // Const reference field.
+  const int m = 2;
+  tuple<bool, const int&> c(true, m);
+  EXPECT_TRUE(get<0>(c));
+  EXPECT_EQ(&m, &(get<1>(c)));
+}
+
+// Tests tuple's copy constructor.
+TEST(TupleConstructorTest, CopyConstructor) {
+  tuple<double, bool> a(0.0, true);
+  tuple<double, bool> b(a);
+
+  EXPECT_DOUBLE_EQ(0.0, get<0>(b));
+  EXPECT_TRUE(get<1>(b));
+}
+
+// Tests constructing a tuple from another tuple that has a compatible
+// but different type.
+TEST(TupleConstructorTest, ConstructsFromDifferentTupleType) {
+  tuple<int, int, char> a(0, 1, 'a');
+  tuple<double, long, int> b(a);
+
+  EXPECT_DOUBLE_EQ(0.0, get<0>(b));
+  EXPECT_EQ(1, get<1>(b));
+  EXPECT_EQ('a', get<2>(b));
+}
+
+// Tests constructing a 2-tuple from an std::pair.
+TEST(TupleConstructorTest, ConstructsFromPair) {
+  ::std::pair<int, char> a(1, 'a');
+  tuple<int, char> b(a);
+  tuple<int, const char&> c(a);
+}
+
+// Tests assigning a tuple to another tuple with the same type.
+TEST(TupleAssignmentTest, AssignsToSameTupleType) {
+  const tuple<int, long> a(5, 7L);
+  tuple<int, long> b;
+  b = a;
+  EXPECT_EQ(5, get<0>(b));
+  EXPECT_EQ(7L, get<1>(b));
+}
+
+// Tests assigning a tuple to another tuple with a different but
+// compatible type.
+TEST(TupleAssignmentTest, AssignsToDifferentTupleType) {
+  const tuple<int, long, bool> a(1, 7L, true);
+  tuple<long, int, bool> b;
+  b = a;
+  EXPECT_EQ(1L, get<0>(b));
+  EXPECT_EQ(7, get<1>(b));
+  EXPECT_TRUE(get<2>(b));
+}
+
+// Tests assigning an std::pair to a 2-tuple.
+TEST(TupleAssignmentTest, AssignsFromPair) {
+  const ::std::pair<int, bool> a(5, true);
+  tuple<int, bool> b;
+  b = a;
+  EXPECT_EQ(5, get<0>(b));
+  EXPECT_TRUE(get<1>(b));
+
+  tuple<long, bool> c;
+  c = a;
+  EXPECT_EQ(5L, get<0>(c));
+  EXPECT_TRUE(get<1>(c));
+}
+
+// A fixture for testing big tuples.
+class BigTupleTest : public testing::Test {
+ protected:
+  typedef tuple<int, int, int, int, int, int, int, int, int, int> BigTuple;
+
+  BigTupleTest() :
+      a_(1, 0, 0, 0, 0, 0, 0, 0, 0, 2),
+      b_(1, 0, 0, 0, 0, 0, 0, 0, 0, 3) {}
+
+  BigTuple a_, b_;
+};
+
+// Tests constructing big tuples.
+TEST_F(BigTupleTest, Construction) {
+  BigTuple a;
+  BigTuple b(b_);
+}
+
+// Tests that get<N>(t) returns the N-th (0-based) field of tuple t.
+TEST_F(BigTupleTest, get) {
+  EXPECT_EQ(1, get<0>(a_));
+  EXPECT_EQ(2, get<9>(a_));
+
+  // Tests that get() works on a const tuple too.
+  const BigTuple a(a_);
+  EXPECT_EQ(1, get<0>(a));
+  EXPECT_EQ(2, get<9>(a));
+}
+
+// Tests comparing big tuples.
+TEST_F(BigTupleTest, Comparisons) {
+  EXPECT_TRUE(a_ == a_);
+  EXPECT_FALSE(a_ != a_);
+
+  EXPECT_TRUE(a_ != b_);
+  EXPECT_FALSE(a_ == b_);
+}
+
+TEST(MakeTupleTest, WorksForScalarTypes) {
+  tuple<bool, int> a;
+  a = make_tuple(true, 5);
+  EXPECT_TRUE(get<0>(a));
+  EXPECT_EQ(5, get<1>(a));
+
+  tuple<char, int, long> b;
+  b = make_tuple('a', 'b', 5);
+  EXPECT_EQ('a', get<0>(b));
+  EXPECT_EQ('b', get<1>(b));
+  EXPECT_EQ(5, get<2>(b));
+}
+
+TEST(MakeTupleTest, WorksForPointers) {
+  int a[] = { 1, 2, 3, 4 };
+  const char* const str = "hi";
+  int* const p = a;
+
+  tuple<const char*, int*> t;
+  t = make_tuple(str, p);
+  EXPECT_EQ(str, get<0>(t));
+  EXPECT_EQ(p, get<1>(t));
+}
+
+}  // namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test2_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test2_test.cc
new file mode 100644
index 00000000..c284700b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test2_test.cc
@@ -0,0 +1,45 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include <vector>
+
+#include "test/gtest-typed-test_test.h"
+#include "gtest/gtest.h"
+
+#if GTEST_HAS_TYPED_TEST_P
+
+// Tests that the same type-parameterized test case can be
+// instantiated in different translation units linked together.
+// (ContainerTest is also instantiated in gtest-typed-test_test.cc.)
+INSTANTIATE_TYPED_TEST_CASE_P(Vector, ContainerTest,
+                              testing::Types<std::vector<int> >);
+
+#endif  // GTEST_HAS_TYPED_TEST_P
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.cc
new file mode 100644
index 00000000..93628ba0
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.cc
@@ -0,0 +1,380 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "test/gtest-typed-test_test.h"
+
+#include <set>
+#include <vector>
+
+#include "gtest/gtest.h"
+
+using testing::Test;
+
+// Used for testing that SetUpTestCase()/TearDownTestCase(), fixture
+// ctor/dtor, and SetUp()/TearDown() work correctly in typed tests and
+// type-parameterized test.
+template <typename T>
+class CommonTest : public Test {
+  // For some technical reason, SetUpTestCase() and TearDownTestCase()
+  // must be public.
+ public:
+  static void SetUpTestCase() {
+    shared_ = new T(5);
+  }
+
+  static void TearDownTestCase() {
+    delete shared_;
+    shared_ = NULL;
+  }
+
+  // This 'protected:' is optional.  There's no harm in making all
+  // members of this fixture class template public.
+ protected:
+  // We used to use std::list here, but switched to std::vector since
+  // MSVC's <list> doesn't compile cleanly with /W4.
+  typedef std::vector<T> Vector;
+  typedef std::set<int> IntSet;
+
+  CommonTest() : value_(1) {}
+
+  virtual ~CommonTest() { EXPECT_EQ(3, value_); }
+
+  virtual void SetUp() {
+    EXPECT_EQ(1, value_);
+    value_++;
+  }
+
+  virtual void TearDown() {
+    EXPECT_EQ(2, value_);
+    value_++;
+  }
+
+  T value_;
+  static T* shared_;
+};
+
+template <typename T>
+T* CommonTest<T>::shared_ = NULL;
+
+// This #ifdef block tests typed tests.
+#if GTEST_HAS_TYPED_TEST
+
+using testing::Types;
+
+// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor,
+// and SetUp()/TearDown() work correctly in typed tests
+
+typedef Types<char, int> TwoTypes;
+TYPED_TEST_CASE(CommonTest, TwoTypes);
+
+TYPED_TEST(CommonTest, ValuesAreCorrect) {
+  // Static members of the fixture class template can be visited via
+  // the TestFixture:: prefix.
+  EXPECT_EQ(5, *TestFixture::shared_);
+
+  // Typedefs in the fixture class template can be visited via the
+  // "typename TestFixture::" prefix.
+  typename TestFixture::Vector empty;
+  EXPECT_EQ(0U, empty.size());
+
+  typename TestFixture::IntSet empty2;
+  EXPECT_EQ(0U, empty2.size());
+
+  // Non-static members of the fixture class must be visited via
+  // 'this', as required by C++ for class templates.
+  EXPECT_EQ(2, this->value_);
+}
+
+// The second test makes sure shared_ is not deleted after the first
+// test.
+TYPED_TEST(CommonTest, ValuesAreStillCorrect) {
+  // Static members of the fixture class template can also be visited
+  // via 'this'.
+  ASSERT_TRUE(this->shared_ != NULL);
+  EXPECT_EQ(5, *this->shared_);
+
+  // TypeParam can be used to refer to the type parameter.
+  EXPECT_EQ(static_cast<TypeParam>(2), this->value_);
+}
+
+// Tests that multiple TYPED_TEST_CASE's can be defined in the same
+// translation unit.
+
+template <typename T>
+class TypedTest1 : public Test {
+};
+
+// Verifies that the second argument of TYPED_TEST_CASE can be a
+// single type.
+TYPED_TEST_CASE(TypedTest1, int);
+TYPED_TEST(TypedTest1, A) {}
+
+template <typename T>
+class TypedTest2 : public Test {
+};
+
+// Verifies that the second argument of TYPED_TEST_CASE can be a
+// Types<...> type list.
+TYPED_TEST_CASE(TypedTest2, Types<int>);
+
+// This also verifies that tests from different typed test cases can
+// share the same name.
+TYPED_TEST(TypedTest2, A) {}
+
+// Tests that a typed test case can be defined in a namespace.
+
+namespace library1 {
+
+template <typename T>
+class NumericTest : public Test {
+};
+
+typedef Types<int, long> NumericTypes;
+TYPED_TEST_CASE(NumericTest, NumericTypes);
+
+TYPED_TEST(NumericTest, DefaultIsZero) {
+  EXPECT_EQ(0, TypeParam());
+}
+
+}  // namespace library1
+
+#endif  // GTEST_HAS_TYPED_TEST
+
+// This #ifdef block tests type-parameterized tests.
+#if GTEST_HAS_TYPED_TEST_P
+
+using testing::Types;
+using testing::internal::TypedTestCasePState;
+
+// Tests TypedTestCasePState.
+
+class TypedTestCasePStateTest : public Test {
+ protected:
+  virtual void SetUp() {
+    state_.AddTestName("foo.cc", 0, "FooTest", "A");
+    state_.AddTestName("foo.cc", 0, "FooTest", "B");
+    state_.AddTestName("foo.cc", 0, "FooTest", "C");
+  }
+
+  TypedTestCasePState state_;
+};
+
+TEST_F(TypedTestCasePStateTest, SucceedsForMatchingList) {
+  const char* tests = "A, B, C";
+  EXPECT_EQ(tests,
+            state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
+}
+
+// Makes sure that the order of the tests and spaces around the names
+// don't matter.
+TEST_F(TypedTestCasePStateTest, IgnoresOrderAndSpaces) {
+  const char* tests = "A,C,   B";
+  EXPECT_EQ(tests,
+            state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
+}
+
+typedef TypedTestCasePStateTest TypedTestCasePStateDeathTest;
+
+TEST_F(TypedTestCasePStateDeathTest, DetectsDuplicates) {
+  EXPECT_DEATH_IF_SUPPORTED(
+      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, A, C"),
+      "foo\\.cc.1.?: Test A is listed more than once\\.");
+}
+
+TEST_F(TypedTestCasePStateDeathTest, DetectsExtraTest) {
+  EXPECT_DEATH_IF_SUPPORTED(
+      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C, D"),
+      "foo\\.cc.1.?: No test named D can be found in this test case\\.");
+}
+
+TEST_F(TypedTestCasePStateDeathTest, DetectsMissedTest) {
+  EXPECT_DEATH_IF_SUPPORTED(
+      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, C"),
+      "foo\\.cc.1.?: You forgot to list test B\\.");
+}
+
+// Tests that defining a test for a parameterized test case generates
+// a run-time error if the test case has been registered.
+TEST_F(TypedTestCasePStateDeathTest, DetectsTestAfterRegistration) {
+  state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C");
+  EXPECT_DEATH_IF_SUPPORTED(
+      state_.AddTestName("foo.cc", 2, "FooTest", "D"),
+      "foo\\.cc.2.?: Test D must be defined before REGISTER_TYPED_TEST_CASE_P"
+      "\\(FooTest, \\.\\.\\.\\)\\.");
+}
+
+// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor,
+// and SetUp()/TearDown() work correctly in type-parameterized tests.
+
+template <typename T>
+class DerivedTest : public CommonTest<T> {
+};
+
+TYPED_TEST_CASE_P(DerivedTest);
+
+TYPED_TEST_P(DerivedTest, ValuesAreCorrect) {
+  // Static members of the fixture class template can be visited via
+  // the TestFixture:: prefix.
+  EXPECT_EQ(5, *TestFixture::shared_);
+
+  // Non-static members of the fixture class must be visited via
+  // 'this', as required by C++ for class templates.
+  EXPECT_EQ(2, this->value_);
+}
+
+// The second test makes sure shared_ is not deleted after the first
+// test.
+TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) {
+  // Static members of the fixture class template can also be visited
+  // via 'this'.
+  ASSERT_TRUE(this->shared_ != NULL);
+  EXPECT_EQ(5, *this->shared_);
+  EXPECT_EQ(2, this->value_);
+}
+
+REGISTER_TYPED_TEST_CASE_P(DerivedTest,
+                           ValuesAreCorrect, ValuesAreStillCorrect);
+
+typedef Types<short, long> MyTwoTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(My, DerivedTest, MyTwoTypes);
+
+// Tests that multiple TYPED_TEST_CASE_P's can be defined in the same
+// translation unit.
+
+template <typename T>
+class TypedTestP1 : public Test {
+};
+
+TYPED_TEST_CASE_P(TypedTestP1);
+
+// For testing that the code between TYPED_TEST_CASE_P() and
+// TYPED_TEST_P() is not enclosed in a namespace.
+typedef int IntAfterTypedTestCaseP;
+
+TYPED_TEST_P(TypedTestP1, A) {}
+TYPED_TEST_P(TypedTestP1, B) {}
+
+// For testing that the code between TYPED_TEST_P() and
+// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace.
+typedef int IntBeforeRegisterTypedTestCaseP;
+
+REGISTER_TYPED_TEST_CASE_P(TypedTestP1, A, B);
+
+template <typename T>
+class TypedTestP2 : public Test {
+};
+
+TYPED_TEST_CASE_P(TypedTestP2);
+
+// This also verifies that tests from different type-parameterized
+// test cases can share the same name.
+TYPED_TEST_P(TypedTestP2, A) {}
+
+REGISTER_TYPED_TEST_CASE_P(TypedTestP2, A);
+
+// Verifies that the code between TYPED_TEST_CASE_P() and
+// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace.
+IntAfterTypedTestCaseP after = 0;
+IntBeforeRegisterTypedTestCaseP before = 0;
+
+// Verifies that the last argument of INSTANTIATE_TYPED_TEST_CASE_P()
+// can be either a single type or a Types<...> type list.
+INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP1, int);
+INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP2, Types<int>);
+
+// Tests that the same type-parameterized test case can be
+// instantiated more than once in the same translation unit.
+INSTANTIATE_TYPED_TEST_CASE_P(Double, TypedTestP2, Types<double>);
+
+// Tests that the same type-parameterized test case can be
+// instantiated in different translation units linked together.
+// (ContainerTest is also instantiated in gtest-typed-test_test.cc.)
+typedef Types<std::vector<double>, std::set<char> > MyContainers;
+INSTANTIATE_TYPED_TEST_CASE_P(My, ContainerTest, MyContainers);
+
+// Tests that a type-parameterized test case can be defined and
+// instantiated in a namespace.
+
+namespace library2 {
+
+template <typename T>
+class NumericTest : public Test {
+};
+
+TYPED_TEST_CASE_P(NumericTest);
+
+TYPED_TEST_P(NumericTest, DefaultIsZero) {
+  EXPECT_EQ(0, TypeParam());
+}
+
+TYPED_TEST_P(NumericTest, ZeroIsLessThanOne) {
+  EXPECT_LT(TypeParam(0), TypeParam(1));
+}
+
+REGISTER_TYPED_TEST_CASE_P(NumericTest,
+                           DefaultIsZero, ZeroIsLessThanOne);
+typedef Types<int, double> NumericTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(My, NumericTest, NumericTypes);
+
+static const char* GetTestName() {
+  return testing::UnitTest::GetInstance()->current_test_info()->name();
+}
+// Test the stripping of space from test names
+template <typename T> class TrimmedTest : public Test { };
+TYPED_TEST_CASE_P(TrimmedTest);
+TYPED_TEST_P(TrimmedTest, Test1) { EXPECT_STREQ("Test1", GetTestName()); }
+TYPED_TEST_P(TrimmedTest, Test2) { EXPECT_STREQ("Test2", GetTestName()); }
+TYPED_TEST_P(TrimmedTest, Test3) { EXPECT_STREQ("Test3", GetTestName()); }
+TYPED_TEST_P(TrimmedTest, Test4) { EXPECT_STREQ("Test4", GetTestName()); }
+TYPED_TEST_P(TrimmedTest, Test5) { EXPECT_STREQ("Test5", GetTestName()); }
+REGISTER_TYPED_TEST_CASE_P(
+    TrimmedTest,
+    Test1, Test2,Test3 , Test4 ,Test5 );  // NOLINT
+template <typename T1, typename T2> struct MyPair {};
+// Be sure to try a type with a comma in its name just in case it matters.
+typedef Types<int, double, MyPair<int, int> > TrimTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(My, TrimmedTest, TrimTypes);
+
+}  // namespace library2
+
+#endif  // GTEST_HAS_TYPED_TEST_P
+
+#if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)
+
+// Google Test may not support type-parameterized tests with some
+// compilers. If we use conditional compilation to compile out all
+// code referring to the gtest_main library, MSVC linker will not link
+// that library at all and consequently complain about missing entry
+// point defined in that library (fatal error LNK1561: entry point
+// must be defined). This dummy test keeps gtest_main linked in.
+TEST(DummyTest, TypedTestsAreNotSupportedOnThisPlatform) {}
+
+#endif  // #if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.h b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.h
new file mode 100644
index 00000000..41d75704
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.h
@@ -0,0 +1,66 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#ifndef GTEST_TEST_GTEST_TYPED_TEST_TEST_H_
+#define GTEST_TEST_GTEST_TYPED_TEST_TEST_H_
+
+#include "gtest/gtest.h"
+
+#if GTEST_HAS_TYPED_TEST_P
+
+using testing::Test;
+
+// For testing that the same type-parameterized test case can be
+// instantiated in different translation units linked together.
+// ContainerTest will be instantiated in both gtest-typed-test_test.cc
+// and gtest-typed-test2_test.cc.
+
+template <typename T>
+class ContainerTest : public Test {
+};
+
+TYPED_TEST_CASE_P(ContainerTest);
+
+TYPED_TEST_P(ContainerTest, CanBeDefaultConstructed) {
+  TypeParam container;
+}
+
+TYPED_TEST_P(ContainerTest, InitialSizeIsZero) {
+  TypeParam container;
+  EXPECT_EQ(0U, container.size());
+}
+
+REGISTER_TYPED_TEST_CASE_P(ContainerTest,
+                           CanBeDefaultConstructed, InitialSizeIsZero);
+
+#endif  // GTEST_HAS_TYPED_TEST_P
+
+#endif  // GTEST_TEST_GTEST_TYPED_TEST_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-unittest-api_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-unittest-api_test.cc
new file mode 100644
index 00000000..b1f51688
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-unittest-api_test.cc
@@ -0,0 +1,341 @@
+// Copyright 2009 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.
+//
+// Author: vladl@google.com (Vlad Losev)
+//
+// The Google C++ Testing Framework (Google Test)
+//
+// This file contains tests verifying correctness of data provided via
+// UnitTest's public methods.
+
+#include "gtest/gtest.h"
+
+#include <string.h>  // For strcmp.
+#include <algorithm>
+
+using ::testing::InitGoogleTest;
+
+namespace testing {
+namespace internal {
+
+template <typename T>
+struct LessByName {
+  bool operator()(const T* a, const T* b) {
+    return strcmp(a->name(), b->name()) < 0;
+  }
+};
+
+class UnitTestHelper {
+ public:
+  // Returns the array of pointers to all test cases sorted by the test case
+  // name.  The caller is responsible for deleting the array.
+  static TestCase const** GetSortedTestCases() {
+    UnitTest& unit_test = *UnitTest::GetInstance();
+    TestCase const** const test_cases =
+        new const TestCase*[unit_test.total_test_case_count()];
+
+    for (int i = 0; i < unit_test.total_test_case_count(); ++i)
+      test_cases[i] = unit_test.GetTestCase(i);
+
+    std::sort(test_cases,
+              test_cases + unit_test.total_test_case_count(),
+              LessByName<TestCase>());
+    return test_cases;
+  }
+
+  // Returns the test case by its name.  The caller doesn't own the returned
+  // pointer.
+  static const TestCase* FindTestCase(const char* name) {
+    UnitTest& unit_test = *UnitTest::GetInstance();
+    for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
+      const TestCase* test_case = unit_test.GetTestCase(i);
+      if (0 == strcmp(test_case->name(), name))
+        return test_case;
+    }
+    return NULL;
+  }
+
+  // Returns the array of pointers to all tests in a particular test case
+  // sorted by the test name.  The caller is responsible for deleting the
+  // array.
+  static TestInfo const** GetSortedTests(const TestCase* test_case) {
+    TestInfo const** const tests =
+        new const TestInfo*[test_case->total_test_count()];
+
+    for (int i = 0; i < test_case->total_test_count(); ++i)
+      tests[i] = test_case->GetTestInfo(i);
+
+    std::sort(tests, tests + test_case->total_test_count(),
+              LessByName<TestInfo>());
+    return tests;
+  }
+};
+
+#if GTEST_HAS_TYPED_TEST
+template <typename T> class TestCaseWithCommentTest : public Test {};
+TYPED_TEST_CASE(TestCaseWithCommentTest, Types<int>);
+TYPED_TEST(TestCaseWithCommentTest, Dummy) {}
+
+const int kTypedTestCases = 1;
+const int kTypedTests = 1;
+#else
+const int kTypedTestCases = 0;
+const int kTypedTests = 0;
+#endif  // GTEST_HAS_TYPED_TEST
+
+// We can only test the accessors that do not change value while tests run.
+// Since tests can be run in any order, the values the accessors that track
+// test execution (such as failed_test_count) can not be predicted.
+TEST(ApiTest, UnitTestImmutableAccessorsWork) {
+  UnitTest* unit_test = UnitTest::GetInstance();
+
+  ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
+  EXPECT_EQ(1 + kTypedTestCases, unit_test->test_case_to_run_count());
+  EXPECT_EQ(2, unit_test->disabled_test_count());
+  EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count());
+  EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count());
+
+  const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();
+
+  EXPECT_STREQ("ApiTest", test_cases[0]->name());
+  EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
+#if GTEST_HAS_TYPED_TEST
+  EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
+#endif  // GTEST_HAS_TYPED_TEST
+
+  delete[] test_cases;
+
+  // The following lines initiate actions to verify certain methods in
+  // FinalSuccessChecker::TearDown.
+
+  // Records a test property to verify TestResult::GetTestProperty().
+  RecordProperty("key", "value");
+}
+
+AssertionResult IsNull(const char* str) {
+  if (str != NULL) {
+    return testing::AssertionFailure() << "argument is " << str;
+  }
+  return AssertionSuccess();
+}
+
+TEST(ApiTest, TestCaseImmutableAccessorsWork) {
+  const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
+  ASSERT_TRUE(test_case != NULL);
+
+  EXPECT_STREQ("ApiTest", test_case->name());
+  EXPECT_TRUE(IsNull(test_case->type_param()));
+  EXPECT_TRUE(test_case->should_run());
+  EXPECT_EQ(1, test_case->disabled_test_count());
+  EXPECT_EQ(3, test_case->test_to_run_count());
+  ASSERT_EQ(4, test_case->total_test_count());
+
+  const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
+
+  EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
+  EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
+  EXPECT_TRUE(IsNull(tests[0]->value_param()));
+  EXPECT_TRUE(IsNull(tests[0]->type_param()));
+  EXPECT_FALSE(tests[0]->should_run());
+
+  EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
+  EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
+  EXPECT_TRUE(IsNull(tests[1]->value_param()));
+  EXPECT_TRUE(IsNull(tests[1]->type_param()));
+  EXPECT_TRUE(tests[1]->should_run());
+
+  EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
+  EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
+  EXPECT_TRUE(IsNull(tests[2]->value_param()));
+  EXPECT_TRUE(IsNull(tests[2]->type_param()));
+  EXPECT_TRUE(tests[2]->should_run());
+
+  EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
+  EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
+  EXPECT_TRUE(IsNull(tests[3]->value_param()));
+  EXPECT_TRUE(IsNull(tests[3]->type_param()));
+  EXPECT_TRUE(tests[3]->should_run());
+
+  delete[] tests;
+  tests = NULL;
+
+#if GTEST_HAS_TYPED_TEST
+  test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
+  ASSERT_TRUE(test_case != NULL);
+
+  EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name());
+  EXPECT_STREQ(GetTypeName<int>().c_str(), test_case->type_param());
+  EXPECT_TRUE(test_case->should_run());
+  EXPECT_EQ(0, test_case->disabled_test_count());
+  EXPECT_EQ(1, test_case->test_to_run_count());
+  ASSERT_EQ(1, test_case->total_test_count());
+
+  tests = UnitTestHelper::GetSortedTests(test_case);
+
+  EXPECT_STREQ("Dummy", tests[0]->name());
+  EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
+  EXPECT_TRUE(IsNull(tests[0]->value_param()));
+  EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
+  EXPECT_TRUE(tests[0]->should_run());
+
+  delete[] tests;
+#endif  // GTEST_HAS_TYPED_TEST
+}
+
+TEST(ApiTest, TestCaseDisabledAccessorsWork) {
+  const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test");
+  ASSERT_TRUE(test_case != NULL);
+
+  EXPECT_STREQ("DISABLED_Test", test_case->name());
+  EXPECT_TRUE(IsNull(test_case->type_param()));
+  EXPECT_FALSE(test_case->should_run());
+  EXPECT_EQ(1, test_case->disabled_test_count());
+  EXPECT_EQ(0, test_case->test_to_run_count());
+  ASSERT_EQ(1, test_case->total_test_count());
+
+  const TestInfo* const test_info = test_case->GetTestInfo(0);
+  EXPECT_STREQ("Dummy2", test_info->name());
+  EXPECT_STREQ("DISABLED_Test", test_info->test_case_name());
+  EXPECT_TRUE(IsNull(test_info->value_param()));
+  EXPECT_TRUE(IsNull(test_info->type_param()));
+  EXPECT_FALSE(test_info->should_run());
+}
+
+// These two tests are here to provide support for testing
+// test_case_to_run_count, disabled_test_count, and test_to_run_count.
+TEST(ApiTest, DISABLED_Dummy1) {}
+TEST(DISABLED_Test, Dummy2) {}
+
+class FinalSuccessChecker : public Environment {
+ protected:
+  virtual void TearDown() {
+    UnitTest* unit_test = UnitTest::GetInstance();
+
+    EXPECT_EQ(1 + kTypedTestCases, unit_test->successful_test_case_count());
+    EXPECT_EQ(3 + kTypedTests, unit_test->successful_test_count());
+    EXPECT_EQ(0, unit_test->failed_test_case_count());
+    EXPECT_EQ(0, unit_test->failed_test_count());
+    EXPECT_TRUE(unit_test->Passed());
+    EXPECT_FALSE(unit_test->Failed());
+    ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
+
+    const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();
+
+    EXPECT_STREQ("ApiTest", test_cases[0]->name());
+    EXPECT_TRUE(IsNull(test_cases[0]->type_param()));
+    EXPECT_TRUE(test_cases[0]->should_run());
+    EXPECT_EQ(1, test_cases[0]->disabled_test_count());
+    ASSERT_EQ(4, test_cases[0]->total_test_count());
+    EXPECT_EQ(3, test_cases[0]->successful_test_count());
+    EXPECT_EQ(0, test_cases[0]->failed_test_count());
+    EXPECT_TRUE(test_cases[0]->Passed());
+    EXPECT_FALSE(test_cases[0]->Failed());
+
+    EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
+    EXPECT_TRUE(IsNull(test_cases[1]->type_param()));
+    EXPECT_FALSE(test_cases[1]->should_run());
+    EXPECT_EQ(1, test_cases[1]->disabled_test_count());
+    ASSERT_EQ(1, test_cases[1]->total_test_count());
+    EXPECT_EQ(0, test_cases[1]->successful_test_count());
+    EXPECT_EQ(0, test_cases[1]->failed_test_count());
+
+#if GTEST_HAS_TYPED_TEST
+    EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
+    EXPECT_STREQ(GetTypeName<int>().c_str(), test_cases[2]->type_param());
+    EXPECT_TRUE(test_cases[2]->should_run());
+    EXPECT_EQ(0, test_cases[2]->disabled_test_count());
+    ASSERT_EQ(1, test_cases[2]->total_test_count());
+    EXPECT_EQ(1, test_cases[2]->successful_test_count());
+    EXPECT_EQ(0, test_cases[2]->failed_test_count());
+    EXPECT_TRUE(test_cases[2]->Passed());
+    EXPECT_FALSE(test_cases[2]->Failed());
+#endif  // GTEST_HAS_TYPED_TEST
+
+    const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
+    const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
+    EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
+    EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
+    EXPECT_FALSE(tests[0]->should_run());
+
+    EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
+    EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
+    EXPECT_TRUE(IsNull(tests[1]->value_param()));
+    EXPECT_TRUE(IsNull(tests[1]->type_param()));
+    EXPECT_TRUE(tests[1]->should_run());
+    EXPECT_TRUE(tests[1]->result()->Passed());
+    EXPECT_EQ(0, tests[1]->result()->test_property_count());
+
+    EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
+    EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
+    EXPECT_TRUE(IsNull(tests[2]->value_param()));
+    EXPECT_TRUE(IsNull(tests[2]->type_param()));
+    EXPECT_TRUE(tests[2]->should_run());
+    EXPECT_TRUE(tests[2]->result()->Passed());
+    EXPECT_EQ(0, tests[2]->result()->test_property_count());
+
+    EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
+    EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
+    EXPECT_TRUE(IsNull(tests[3]->value_param()));
+    EXPECT_TRUE(IsNull(tests[3]->type_param()));
+    EXPECT_TRUE(tests[3]->should_run());
+    EXPECT_TRUE(tests[3]->result()->Passed());
+    EXPECT_EQ(1, tests[3]->result()->test_property_count());
+    const TestProperty& property = tests[3]->result()->GetTestProperty(0);
+    EXPECT_STREQ("key", property.key());
+    EXPECT_STREQ("value", property.value());
+
+    delete[] tests;
+
+#if GTEST_HAS_TYPED_TEST
+    test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
+    tests = UnitTestHelper::GetSortedTests(test_case);
+
+    EXPECT_STREQ("Dummy", tests[0]->name());
+    EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
+    EXPECT_TRUE(IsNull(tests[0]->value_param()));
+    EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
+    EXPECT_TRUE(tests[0]->should_run());
+    EXPECT_TRUE(tests[0]->result()->Passed());
+    EXPECT_EQ(0, tests[0]->result()->test_property_count());
+
+    delete[] tests;
+#endif  // GTEST_HAS_TYPED_TEST
+    delete[] test_cases;
+  }
+};
+
+}  // namespace internal
+}  // namespace testing
+
+int main(int argc, char **argv) {
+  InitGoogleTest(&argc, argv);
+
+  AddGlobalTestEnvironment(new testing::internal::FinalSuccessChecker());
+
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_all_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_all_test.cc
new file mode 100644
index 00000000..955aa628
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_all_test.cc
@@ -0,0 +1,47 @@
+// Copyright 2009, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Tests for Google C++ Testing Framework (Google Test)
+//
+// Sometimes it's desirable to build most of Google Test's own tests
+// by compiling a single file.  This file serves this purpose.
+#include "test/gtest-filepath_test.cc"
+#include "test/gtest-linked_ptr_test.cc"
+#include "test/gtest-message_test.cc"
+#include "test/gtest-options_test.cc"
+#include "test/gtest-port_test.cc"
+#include "test/gtest_pred_impl_unittest.cc"
+#include "test/gtest_prod_test.cc"
+#include "test/gtest-test-part_test.cc"
+#include "test/gtest-typed-test_test.cc"
+#include "test/gtest-typed-test2_test.cc"
+#include "test/gtest_unittest.cc"
+#include "test/production.cc"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest.py
new file mode 100755
index 00000000..78f3e0f5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest.py
@@ -0,0 +1,212 @@
+#!/usr/bin/env python
+#
+# Copyright 2006, 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.
+
+"""Unit test for Google Test's break-on-failure mode.
+
+A user can ask Google Test to seg-fault when an assertion fails, using
+either the GTEST_BREAK_ON_FAILURE environment variable or the
+--gtest_break_on_failure flag.  This script tests such functionality
+by invoking gtest_break_on_failure_unittest_ (a program written with
+Google Test) with different environments and command line flags.
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import gtest_test_utils
+import os
+import sys
+
+
+# Constants.
+
+IS_WINDOWS = os.name == 'nt'
+
+# The environment variable for enabling/disabling the break-on-failure mode.
+BREAK_ON_FAILURE_ENV_VAR = 'GTEST_BREAK_ON_FAILURE'
+
+# The command line flag for enabling/disabling the break-on-failure mode.
+BREAK_ON_FAILURE_FLAG = 'gtest_break_on_failure'
+
+# The environment variable for enabling/disabling the throw-on-failure mode.
+THROW_ON_FAILURE_ENV_VAR = 'GTEST_THROW_ON_FAILURE'
+
+# The environment variable for enabling/disabling the catch-exceptions mode.
+CATCH_EXCEPTIONS_ENV_VAR = 'GTEST_CATCH_EXCEPTIONS'
+
+# Path to the gtest_break_on_failure_unittest_ program.
+EXE_PATH = gtest_test_utils.GetTestExecutablePath(
+    'gtest_break_on_failure_unittest_')
+
+
+environ = gtest_test_utils.environ
+SetEnvVar = gtest_test_utils.SetEnvVar
+
+# Tests in this file run a Google-Test-based test program and expect it
+# to terminate prematurely.  Therefore they are incompatible with
+# the premature-exit-file protocol by design.  Unset the
+# premature-exit filepath to prevent Google Test from creating
+# the file.
+SetEnvVar(gtest_test_utils.PREMATURE_EXIT_FILE_ENV_VAR, None)
+
+
+def Run(command):
+  """Runs a command; returns 1 if it was killed by a signal, or 0 otherwise."""
+
+  p = gtest_test_utils.Subprocess(command, env=environ)
+  if p.terminated_by_signal:
+    return 1
+  else:
+    return 0
+
+
+# The tests.
+
+
+class GTestBreakOnFailureUnitTest(gtest_test_utils.TestCase):
+  """Tests using the GTEST_BREAK_ON_FAILURE environment variable or
+  the --gtest_break_on_failure flag to turn assertion failures into
+  segmentation faults.
+  """
+
+  def RunAndVerify(self, env_var_value, flag_value, expect_seg_fault):
+    """Runs gtest_break_on_failure_unittest_ and verifies that it does
+    (or does not) have a seg-fault.
+
+    Args:
+      env_var_value:    value of the GTEST_BREAK_ON_FAILURE environment
+                        variable; None if the variable should be unset.
+      flag_value:       value of the --gtest_break_on_failure flag;
+                        None if the flag should not be present.
+      expect_seg_fault: 1 if the program is expected to generate a seg-fault;
+                        0 otherwise.
+    """
+
+    SetEnvVar(BREAK_ON_FAILURE_ENV_VAR, env_var_value)
+
+    if env_var_value is None:
+      env_var_value_msg = ' is not set'
+    else:
+      env_var_value_msg = '=' + env_var_value
+
+    if flag_value is None:
+      flag = ''
+    elif flag_value == '0':
+      flag = '--%s=0' % BREAK_ON_FAILURE_FLAG
+    else:
+      flag = '--%s' % BREAK_ON_FAILURE_FLAG
+
+    command = [EXE_PATH]
+    if flag:
+      command.append(flag)
+
+    if expect_seg_fault:
+      should_or_not = 'should'
+    else:
+      should_or_not = 'should not'
+
+    has_seg_fault = Run(command)
+
+    SetEnvVar(BREAK_ON_FAILURE_ENV_VAR, None)
+
+    msg = ('when %s%s, an assertion failure in "%s" %s cause a seg-fault.' %
+           (BREAK_ON_FAILURE_ENV_VAR, env_var_value_msg, ' '.join(command),
+            should_or_not))
+    self.assert_(has_seg_fault == expect_seg_fault, msg)
+
+  def testDefaultBehavior(self):
+    """Tests the behavior of the default mode."""
+
+    self.RunAndVerify(env_var_value=None,
+                      flag_value=None,
+                      expect_seg_fault=0)
+
+  def testEnvVar(self):
+    """Tests using the GTEST_BREAK_ON_FAILURE environment variable."""
+
+    self.RunAndVerify(env_var_value='0',
+                      flag_value=None,
+                      expect_seg_fault=0)
+    self.RunAndVerify(env_var_value='1',
+                      flag_value=None,
+                      expect_seg_fault=1)
+
+  def testFlag(self):
+    """Tests using the --gtest_break_on_failure flag."""
+
+    self.RunAndVerify(env_var_value=None,
+                      flag_value='0',
+                      expect_seg_fault=0)
+    self.RunAndVerify(env_var_value=None,
+                      flag_value='1',
+                      expect_seg_fault=1)
+
+  def testFlagOverridesEnvVar(self):
+    """Tests that the flag overrides the environment variable."""
+
+    self.RunAndVerify(env_var_value='0',
+                      flag_value='0',
+                      expect_seg_fault=0)
+    self.RunAndVerify(env_var_value='0',
+                      flag_value='1',
+                      expect_seg_fault=1)
+    self.RunAndVerify(env_var_value='1',
+                      flag_value='0',
+                      expect_seg_fault=0)
+    self.RunAndVerify(env_var_value='1',
+                      flag_value='1',
+                      expect_seg_fault=1)
+
+  def testBreakOnFailureOverridesThrowOnFailure(self):
+    """Tests that gtest_break_on_failure overrides gtest_throw_on_failure."""
+
+    SetEnvVar(THROW_ON_FAILURE_ENV_VAR, '1')
+    try:
+      self.RunAndVerify(env_var_value=None,
+                        flag_value='1',
+                        expect_seg_fault=1)
+    finally:
+      SetEnvVar(THROW_ON_FAILURE_ENV_VAR, None)
+
+  if IS_WINDOWS:
+    def testCatchExceptionsDoesNotInterfere(self):
+      """Tests that gtest_catch_exceptions doesn't interfere."""
+
+      SetEnvVar(CATCH_EXCEPTIONS_ENV_VAR, '1')
+      try:
+        self.RunAndVerify(env_var_value='1',
+                          flag_value='1',
+                          expect_seg_fault=1)
+      finally:
+        SetEnvVar(CATCH_EXCEPTIONS_ENV_VAR, None)
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest_.cc
new file mode 100644
index 00000000..dd07478c
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest_.cc
@@ -0,0 +1,88 @@
+// Copyright 2006, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Unit test for Google Test's break-on-failure mode.
+//
+// A user can ask Google Test to seg-fault when an assertion fails, using
+// either the GTEST_BREAK_ON_FAILURE environment variable or the
+// --gtest_break_on_failure flag.  This file is used for testing such
+// functionality.
+//
+// This program will be invoked from a Python unit test.  It is
+// expected to fail.  Don't run it directly.
+
+#include "gtest/gtest.h"
+
+#if GTEST_OS_WINDOWS
+# include <windows.h>
+# include <stdlib.h>
+#endif
+
+namespace {
+
+// A test that's expected to fail.
+TEST(Foo, Bar) {
+  EXPECT_EQ(2, 3);
+}
+
+#if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE
+// On Windows Mobile global exception handlers are not supported.
+LONG WINAPI ExitWithExceptionCode(
+    struct _EXCEPTION_POINTERS* exception_pointers) {
+  exit(exception_pointers->ExceptionRecord->ExceptionCode);
+}
+#endif
+
+}  // namespace
+
+int main(int argc, char **argv) {
+#if GTEST_OS_WINDOWS
+  // Suppresses display of the Windows error dialog upon encountering
+  // a general protection fault (segment violation).
+  SetErrorMode(SEM_NOGPFAULTERRORBOX | SEM_FAILCRITICALERRORS);
+
+# if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE
+
+  // The default unhandled exception filter does not always exit
+  // with the exception code as exit code - for example it exits with
+  // 0 for EXCEPTION_ACCESS_VIOLATION and 1 for EXCEPTION_BREAKPOINT
+  // if the application is compiled in debug mode. Thus we use our own
+  // filter which always exits with the exception code for unhandled
+  // exceptions.
+  SetUnhandledExceptionFilter(ExitWithExceptionCode);
+
+# endif
+#endif
+
+  testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test.py
new file mode 100755
index 00000000..e6fc22fd
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test.py
@@ -0,0 +1,237 @@
+#!/usr/bin/env python
+#
+# Copyright 2010 Google Inc.  All Rights Reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Tests Google Test's exception catching behavior.
+
+This script invokes gtest_catch_exceptions_test_ and
+gtest_catch_exceptions_ex_test_ (programs written with
+Google Test) and verifies their output.
+"""
+
+__author__ = 'vladl@google.com (Vlad Losev)'
+
+import os
+
+import gtest_test_utils
+
+# Constants.
+FLAG_PREFIX = '--gtest_'
+LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'
+NO_CATCH_EXCEPTIONS_FLAG = FLAG_PREFIX + 'catch_exceptions=0'
+FILTER_FLAG = FLAG_PREFIX + 'filter'
+
+# Path to the gtest_catch_exceptions_ex_test_ binary, compiled with
+# exceptions enabled.
+EX_EXE_PATH = gtest_test_utils.GetTestExecutablePath(
+    'gtest_catch_exceptions_ex_test_')
+
+# Path to the gtest_catch_exceptions_test_ binary, compiled with
+# exceptions disabled.
+EXE_PATH = gtest_test_utils.GetTestExecutablePath(
+    'gtest_catch_exceptions_no_ex_test_')
+
+environ = gtest_test_utils.environ
+SetEnvVar = gtest_test_utils.SetEnvVar
+
+# Tests in this file run a Google-Test-based test program and expect it
+# to terminate prematurely.  Therefore they are incompatible with
+# the premature-exit-file protocol by design.  Unset the
+# premature-exit filepath to prevent Google Test from creating
+# the file.
+SetEnvVar(gtest_test_utils.PREMATURE_EXIT_FILE_ENV_VAR, None)
+
+TEST_LIST = gtest_test_utils.Subprocess(
+    [EXE_PATH, LIST_TESTS_FLAG], env=environ).output
+
+SUPPORTS_SEH_EXCEPTIONS = 'ThrowsSehException' in TEST_LIST
+
+if SUPPORTS_SEH_EXCEPTIONS:
+  BINARY_OUTPUT = gtest_test_utils.Subprocess([EXE_PATH], env=environ).output
+
+EX_BINARY_OUTPUT = gtest_test_utils.Subprocess(
+    [EX_EXE_PATH], env=environ).output
+
+
+# The tests.
+if SUPPORTS_SEH_EXCEPTIONS:
+  # pylint:disable-msg=C6302
+  class CatchSehExceptionsTest(gtest_test_utils.TestCase):
+    """Tests exception-catching behavior."""
+
+
+    def TestSehExceptions(self, test_output):
+      self.assert_('SEH exception with code 0x2a thrown '
+                   'in the test fixture\'s constructor'
+                   in test_output)
+      self.assert_('SEH exception with code 0x2a thrown '
+                   'in the test fixture\'s destructor'
+                   in test_output)
+      self.assert_('SEH exception with code 0x2a thrown in SetUpTestCase()'
+                   in test_output)
+      self.assert_('SEH exception with code 0x2a thrown in TearDownTestCase()'
+                   in test_output)
+      self.assert_('SEH exception with code 0x2a thrown in SetUp()'
+                   in test_output)
+      self.assert_('SEH exception with code 0x2a thrown in TearDown()'
+                   in test_output)
+      self.assert_('SEH exception with code 0x2a thrown in the test body'
+                   in test_output)
+
+    def testCatchesSehExceptionsWithCxxExceptionsEnabled(self):
+      self.TestSehExceptions(EX_BINARY_OUTPUT)
+
+    def testCatchesSehExceptionsWithCxxExceptionsDisabled(self):
+      self.TestSehExceptions(BINARY_OUTPUT)
+
+
+class CatchCxxExceptionsTest(gtest_test_utils.TestCase):
+  """Tests C++ exception-catching behavior.
+
+     Tests in this test case verify that:
+     * C++ exceptions are caught and logged as C++ (not SEH) exceptions
+     * Exception thrown affect the remainder of the test work flow in the
+       expected manner.
+  """
+
+  def testCatchesCxxExceptionsInFixtureConstructor(self):
+    self.assert_('C++ exception with description '
+                 '"Standard C++ exception" thrown '
+                 'in the test fixture\'s constructor'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('unexpected' not in EX_BINARY_OUTPUT,
+                 'This failure belongs in this test only if '
+                 '"CxxExceptionInConstructorTest" (no quotes) '
+                 'appears on the same line as words "called unexpectedly"')
+
+  if ('CxxExceptionInDestructorTest.ThrowsExceptionInDestructor' in
+      EX_BINARY_OUTPUT):
+
+    def testCatchesCxxExceptionsInFixtureDestructor(self):
+      self.assert_('C++ exception with description '
+                   '"Standard C++ exception" thrown '
+                   'in the test fixture\'s destructor'
+                   in EX_BINARY_OUTPUT)
+      self.assert_('CxxExceptionInDestructorTest::TearDownTestCase() '
+                   'called as expected.'
+                   in EX_BINARY_OUTPUT)
+
+  def testCatchesCxxExceptionsInSetUpTestCase(self):
+    self.assert_('C++ exception with description "Standard C++ exception"'
+                 ' thrown in SetUpTestCase()'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInConstructorTest::TearDownTestCase() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTestCaseTest constructor '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTestCaseTest destructor '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTestCaseTest::SetUp() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTestCaseTest::TearDown() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTestCaseTest test body '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+
+  def testCatchesCxxExceptionsInTearDownTestCase(self):
+    self.assert_('C++ exception with description "Standard C++ exception"'
+                 ' thrown in TearDownTestCase()'
+                 in EX_BINARY_OUTPUT)
+
+  def testCatchesCxxExceptionsInSetUp(self):
+    self.assert_('C++ exception with description "Standard C++ exception"'
+                 ' thrown in SetUp()'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTest::TearDownTestCase() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTest destructor '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInSetUpTest::TearDown() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('unexpected' not in EX_BINARY_OUTPUT,
+                 'This failure belongs in this test only if '
+                 '"CxxExceptionInSetUpTest" (no quotes) '
+                 'appears on the same line as words "called unexpectedly"')
+
+  def testCatchesCxxExceptionsInTearDown(self):
+    self.assert_('C++ exception with description "Standard C++ exception"'
+                 ' thrown in TearDown()'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInTearDownTest::TearDownTestCase() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInTearDownTest destructor '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+
+  def testCatchesCxxExceptionsInTestBody(self):
+    self.assert_('C++ exception with description "Standard C++ exception"'
+                 ' thrown in the test body'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInTestBodyTest::TearDownTestCase() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInTestBodyTest destructor '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+    self.assert_('CxxExceptionInTestBodyTest::TearDown() '
+                 'called as expected.'
+                 in EX_BINARY_OUTPUT)
+
+  def testCatchesNonStdCxxExceptions(self):
+    self.assert_('Unknown C++ exception thrown in the test body'
+                 in EX_BINARY_OUTPUT)
+
+  def testUnhandledCxxExceptionsAbortTheProgram(self):
+    # Filters out SEH exception tests on Windows. Unhandled SEH exceptions
+    # cause tests to show pop-up windows there.
+    FITLER_OUT_SEH_TESTS_FLAG = FILTER_FLAG + '=-*Seh*'
+    # By default, Google Test doesn't catch the exceptions.
+    uncaught_exceptions_ex_binary_output = gtest_test_utils.Subprocess(
+        [EX_EXE_PATH,
+         NO_CATCH_EXCEPTIONS_FLAG,
+         FITLER_OUT_SEH_TESTS_FLAG],
+        env=environ).output
+
+    self.assert_('Unhandled C++ exception terminating the program'
+                 in uncaught_exceptions_ex_binary_output)
+    self.assert_('unexpected' not in uncaught_exceptions_ex_binary_output)
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test_.cc
new file mode 100644
index 00000000..d0fc82c9
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test_.cc
@@ -0,0 +1,311 @@
+// Copyright 2010, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: vladl@google.com (Vlad Losev)
+//
+// Tests for Google Test itself. Tests in this file throw C++ or SEH
+// exceptions, and the output is verified by gtest_catch_exceptions_test.py.
+
+#include "gtest/gtest.h"
+
+#include <stdio.h>  // NOLINT
+#include <stdlib.h>  // For exit().
+
+#if GTEST_HAS_SEH
+# include <windows.h>
+#endif
+
+#if GTEST_HAS_EXCEPTIONS
+# include <exception>  // For set_terminate().
+# include <stdexcept>
+#endif
+
+using testing::Test;
+
+#if GTEST_HAS_SEH
+
+class SehExceptionInConstructorTest : public Test {
+ public:
+  SehExceptionInConstructorTest() { RaiseException(42, 0, 0, NULL); }
+};
+
+TEST_F(SehExceptionInConstructorTest, ThrowsExceptionInConstructor) {}
+
+class SehExceptionInDestructorTest : public Test {
+ public:
+  ~SehExceptionInDestructorTest() { RaiseException(42, 0, 0, NULL); }
+};
+
+TEST_F(SehExceptionInDestructorTest, ThrowsExceptionInDestructor) {}
+
+class SehExceptionInSetUpTestCaseTest : public Test {
+ public:
+  static void SetUpTestCase() { RaiseException(42, 0, 0, NULL); }
+};
+
+TEST_F(SehExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) {}
+
+class SehExceptionInTearDownTestCaseTest : public Test {
+ public:
+  static void TearDownTestCase() { RaiseException(42, 0, 0, NULL); }
+};
+
+TEST_F(SehExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {}
+
+class SehExceptionInSetUpTest : public Test {
+ protected:
+  virtual void SetUp() { RaiseException(42, 0, 0, NULL); }
+};
+
+TEST_F(SehExceptionInSetUpTest, ThrowsExceptionInSetUp) {}
+
+class SehExceptionInTearDownTest : public Test {
+ protected:
+  virtual void TearDown() { RaiseException(42, 0, 0, NULL); }
+};
+
+TEST_F(SehExceptionInTearDownTest, ThrowsExceptionInTearDown) {}
+
+TEST(SehExceptionTest, ThrowsSehException) {
+  RaiseException(42, 0, 0, NULL);
+}
+
+#endif  // GTEST_HAS_SEH
+
+#if GTEST_HAS_EXCEPTIONS
+
+class CxxExceptionInConstructorTest : public Test {
+ public:
+  CxxExceptionInConstructorTest() {
+    // Without this macro VC++ complains about unreachable code at the end of
+    // the constructor.
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
+        throw std::runtime_error("Standard C++ exception"));
+  }
+
+  static void TearDownTestCase() {
+    printf("%s",
+           "CxxExceptionInConstructorTest::TearDownTestCase() "
+           "called as expected.\n");
+  }
+
+ protected:
+  ~CxxExceptionInConstructorTest() {
+    ADD_FAILURE() << "CxxExceptionInConstructorTest destructor "
+                  << "called unexpectedly.";
+  }
+
+  virtual void SetUp() {
+    ADD_FAILURE() << "CxxExceptionInConstructorTest::SetUp() "
+                  << "called unexpectedly.";
+  }
+
+  virtual void TearDown() {
+    ADD_FAILURE() << "CxxExceptionInConstructorTest::TearDown() "
+                  << "called unexpectedly.";
+  }
+};
+
+TEST_F(CxxExceptionInConstructorTest, ThrowsExceptionInConstructor) {
+  ADD_FAILURE() << "CxxExceptionInConstructorTest test body "
+                << "called unexpectedly.";
+}
+
+// Exceptions in destructors are not supported in C++11.
+#if !defined(__GXX_EXPERIMENTAL_CXX0X__) &&  __cplusplus < 201103L
+class CxxExceptionInDestructorTest : public Test {
+ public:
+  static void TearDownTestCase() {
+    printf("%s",
+           "CxxExceptionInDestructorTest::TearDownTestCase() "
+           "called as expected.\n");
+  }
+
+ protected:
+  ~CxxExceptionInDestructorTest() {
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
+        throw std::runtime_error("Standard C++ exception"));
+  }
+};
+
+TEST_F(CxxExceptionInDestructorTest, ThrowsExceptionInDestructor) {}
+#endif  // C++11 mode
+
+class CxxExceptionInSetUpTestCaseTest : public Test {
+ public:
+  CxxExceptionInSetUpTestCaseTest() {
+    printf("%s",
+           "CxxExceptionInSetUpTestCaseTest constructor "
+           "called as expected.\n");
+  }
+
+  static void SetUpTestCase() {
+    throw std::runtime_error("Standard C++ exception");
+  }
+
+  static void TearDownTestCase() {
+    printf("%s",
+           "CxxExceptionInSetUpTestCaseTest::TearDownTestCase() "
+           "called as expected.\n");
+  }
+
+ protected:
+  ~CxxExceptionInSetUpTestCaseTest() {
+    printf("%s",
+           "CxxExceptionInSetUpTestCaseTest destructor "
+           "called as expected.\n");
+  }
+
+  virtual void SetUp() {
+    printf("%s",
+           "CxxExceptionInSetUpTestCaseTest::SetUp() "
+           "called as expected.\n");
+  }
+
+  virtual void TearDown() {
+    printf("%s",
+           "CxxExceptionInSetUpTestCaseTest::TearDown() "
+           "called as expected.\n");
+  }
+};
+
+TEST_F(CxxExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) {
+  printf("%s",
+         "CxxExceptionInSetUpTestCaseTest test body "
+         "called as expected.\n");
+}
+
+class CxxExceptionInTearDownTestCaseTest : public Test {
+ public:
+  static void TearDownTestCase() {
+    throw std::runtime_error("Standard C++ exception");
+  }
+};
+
+TEST_F(CxxExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {}
+
+class CxxExceptionInSetUpTest : public Test {
+ public:
+  static void TearDownTestCase() {
+    printf("%s",
+           "CxxExceptionInSetUpTest::TearDownTestCase() "
+           "called as expected.\n");
+  }
+
+ protected:
+  ~CxxExceptionInSetUpTest() {
+    printf("%s",
+           "CxxExceptionInSetUpTest destructor "
+           "called as expected.\n");
+  }
+
+  virtual void SetUp() { throw std::runtime_error("Standard C++ exception"); }
+
+  virtual void TearDown() {
+    printf("%s",
+           "CxxExceptionInSetUpTest::TearDown() "
+           "called as expected.\n");
+  }
+};
+
+TEST_F(CxxExceptionInSetUpTest, ThrowsExceptionInSetUp) {
+  ADD_FAILURE() << "CxxExceptionInSetUpTest test body "
+                << "called unexpectedly.";
+}
+
+class CxxExceptionInTearDownTest : public Test {
+ public:
+  static void TearDownTestCase() {
+    printf("%s",
+           "CxxExceptionInTearDownTest::TearDownTestCase() "
+           "called as expected.\n");
+  }
+
+ protected:
+  ~CxxExceptionInTearDownTest() {
+    printf("%s",
+           "CxxExceptionInTearDownTest destructor "
+           "called as expected.\n");
+  }
+
+  virtual void TearDown() {
+    throw std::runtime_error("Standard C++ exception");
+  }
+};
+
+TEST_F(CxxExceptionInTearDownTest, ThrowsExceptionInTearDown) {}
+
+class CxxExceptionInTestBodyTest : public Test {
+ public:
+  static void TearDownTestCase() {
+    printf("%s",
+           "CxxExceptionInTestBodyTest::TearDownTestCase() "
+           "called as expected.\n");
+  }
+
+ protected:
+  ~CxxExceptionInTestBodyTest() {
+    printf("%s",
+           "CxxExceptionInTestBodyTest destructor "
+           "called as expected.\n");
+  }
+
+  virtual void TearDown() {
+    printf("%s",
+           "CxxExceptionInTestBodyTest::TearDown() "
+           "called as expected.\n");
+  }
+};
+
+TEST_F(CxxExceptionInTestBodyTest, ThrowsStdCxxException) {
+  throw std::runtime_error("Standard C++ exception");
+}
+
+TEST(CxxExceptionTest, ThrowsNonStdCxxException) {
+  throw "C-string";
+}
+
+// This terminate handler aborts the program using exit() rather than abort().
+// This avoids showing pop-ups on Windows systems and core dumps on Unix-like
+// ones.
+void TerminateHandler() {
+  fprintf(stderr, "%s\n", "Unhandled C++ exception terminating the program.");
+  fflush(NULL);
+  exit(3);
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+int main(int argc, char** argv) {
+#if GTEST_HAS_EXCEPTIONS
+  std::set_terminate(&TerminateHandler);
+#endif
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test.py
new file mode 100755
index 00000000..d02a53ed
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test.py
@@ -0,0 +1,130 @@
+#!/usr/bin/env python
+#
+# 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.
+
+"""Verifies that Google Test correctly determines whether to use colors."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import gtest_test_utils
+
+
+IS_WINDOWS = os.name = 'nt'
+
+COLOR_ENV_VAR = 'GTEST_COLOR'
+COLOR_FLAG = 'gtest_color'
+COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_color_test_')
+
+
+def SetEnvVar(env_var, value):
+  """Sets the env variable to 'value'; unsets it when 'value' is None."""
+
+  if value is not None:
+    os.environ[env_var] = value
+  elif env_var in os.environ:
+    del os.environ[env_var]
+
+
+def UsesColor(term, color_env_var, color_flag):
+  """Runs gtest_color_test_ and returns its exit code."""
+
+  SetEnvVar('TERM', term)
+  SetEnvVar(COLOR_ENV_VAR, color_env_var)
+
+  if color_flag is None:
+    args = []
+  else:
+    args = ['--%s=%s' % (COLOR_FLAG, color_flag)]
+  p = gtest_test_utils.Subprocess([COMMAND] + args)
+  return not p.exited or p.exit_code
+
+
+class GTestColorTest(gtest_test_utils.TestCase):
+  def testNoEnvVarNoFlag(self):
+    """Tests the case when there's neither GTEST_COLOR nor --gtest_color."""
+
+    if not IS_WINDOWS:
+      self.assert_(not UsesColor('dumb', None, None))
+      self.assert_(not UsesColor('emacs', None, None))
+      self.assert_(not UsesColor('xterm-mono', None, None))
+      self.assert_(not UsesColor('unknown', None, None))
+      self.assert_(not UsesColor(None, None, None))
+    self.assert_(UsesColor('linux', None, None))
+    self.assert_(UsesColor('cygwin', None, None))
+    self.assert_(UsesColor('xterm', None, None))
+    self.assert_(UsesColor('xterm-color', None, None))
+    self.assert_(UsesColor('xterm-256color', None, None))
+
+  def testFlagOnly(self):
+    """Tests the case when there's --gtest_color but not GTEST_COLOR."""
+
+    self.assert_(not UsesColor('dumb', None, 'no'))
+    self.assert_(not UsesColor('xterm-color', None, 'no'))
+    if not IS_WINDOWS:
+      self.assert_(not UsesColor('emacs', None, 'auto'))
+    self.assert_(UsesColor('xterm', None, 'auto'))
+    self.assert_(UsesColor('dumb', None, 'yes'))
+    self.assert_(UsesColor('xterm', None, 'yes'))
+
+  def testEnvVarOnly(self):
+    """Tests the case when there's GTEST_COLOR but not --gtest_color."""
+
+    self.assert_(not UsesColor('dumb', 'no', None))
+    self.assert_(not UsesColor('xterm-color', 'no', None))
+    if not IS_WINDOWS:
+      self.assert_(not UsesColor('dumb', 'auto', None))
+    self.assert_(UsesColor('xterm-color', 'auto', None))
+    self.assert_(UsesColor('dumb', 'yes', None))
+    self.assert_(UsesColor('xterm-color', 'yes', None))
+
+  def testEnvVarAndFlag(self):
+    """Tests the case when there are both GTEST_COLOR and --gtest_color."""
+
+    self.assert_(not UsesColor('xterm-color', 'no', 'no'))
+    self.assert_(UsesColor('dumb', 'no', 'yes'))
+    self.assert_(UsesColor('xterm-color', 'no', 'auto'))
+
+  def testAliasesOfYesAndNo(self):
+    """Tests using aliases in specifying --gtest_color."""
+
+    self.assert_(UsesColor('dumb', None, 'true'))
+    self.assert_(UsesColor('dumb', None, 'YES'))
+    self.assert_(UsesColor('dumb', None, 'T'))
+    self.assert_(UsesColor('dumb', None, '1'))
+
+    self.assert_(not UsesColor('xterm', None, 'f'))
+    self.assert_(not UsesColor('xterm', None, 'false'))
+    self.assert_(not UsesColor('xterm', None, '0'))
+    self.assert_(not UsesColor('xterm', None, 'unknown'))
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test_.cc
new file mode 100644
index 00000000..f61ebb89
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test_.cc
@@ -0,0 +1,71 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// A helper program for testing how Google Test determines whether to use
+// colors in the output.  It prints "YES" and returns 1 if Google Test
+// decides to use colors, and prints "NO" and returns 0 otherwise.
+
+#include <stdio.h>
+
+#include "gtest/gtest.h"
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+using testing::internal::ShouldUseColor;
+
+// The purpose of this is to ensure that the UnitTest singleton is
+// created before main() is entered, and thus that ShouldUseColor()
+// works the same way as in a real Google-Test-based test.  We don't actual
+// run the TEST itself.
+TEST(GTestColorTest, Dummy) {
+}
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  if (ShouldUseColor(true)) {
+    // Google Test decides to use colors in the output (assuming it
+    // goes to a TTY).
+    printf("YES\n");
+    return 1;
+  } else {
+    // Google Test decides not to use colors in the output.
+    printf("NO\n");
+    return 0;
+  }
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test.py
new file mode 100755
index 00000000..424075cf
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+#
+# 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.
+
+"""Verifies that Google Test correctly parses environment variables."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import gtest_test_utils
+
+
+IS_WINDOWS = os.name == 'nt'
+IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'
+
+COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_env_var_test_')
+
+environ = os.environ.copy()
+
+
+def AssertEq(expected, actual):
+  if expected != actual:
+    print('Expected: %s' % (expected,))
+    print('  Actual: %s' % (actual,))
+    raise AssertionError
+
+
+def SetEnvVar(env_var, value):
+  """Sets the env variable to 'value'; unsets it when 'value' is None."""
+
+  if value is not None:
+    environ[env_var] = value
+  elif env_var in environ:
+    del environ[env_var]
+
+
+def GetFlag(flag):
+  """Runs gtest_env_var_test_ and returns its output."""
+
+  args = [COMMAND]
+  if flag is not None:
+    args += [flag]
+  return gtest_test_utils.Subprocess(args, env=environ).output
+
+
+def TestFlag(flag, test_val, default_val):
+  """Verifies that the given flag is affected by the corresponding env var."""
+
+  env_var = 'GTEST_' + flag.upper()
+  SetEnvVar(env_var, test_val)
+  AssertEq(test_val, GetFlag(flag))
+  SetEnvVar(env_var, None)
+  AssertEq(default_val, GetFlag(flag))
+
+
+class GTestEnvVarTest(gtest_test_utils.TestCase):
+  def testEnvVarAffectsFlag(self):
+    """Tests that environment variable should affect the corresponding flag."""
+
+    TestFlag('break_on_failure', '1', '0')
+    TestFlag('color', 'yes', 'auto')
+    TestFlag('filter', 'FooTest.Bar', '*')
+    SetEnvVar('XML_OUTPUT_FILE', None) # For 'output' test
+    TestFlag('output', 'xml:tmp/foo.xml', '')
+    TestFlag('print_time', '0', '1')
+    TestFlag('repeat', '999', '1')
+    TestFlag('throw_on_failure', '1', '0')
+    TestFlag('death_test_style', 'threadsafe', 'fast')
+    TestFlag('catch_exceptions', '0', '1')
+
+    if IS_LINUX:
+      TestFlag('death_test_use_fork', '1', '0')
+      TestFlag('stack_trace_depth', '0', '100')
+
+  def testXmlOutputFile(self):
+    """Tests that $XML_OUTPUT_FILE affects the output flag."""
+
+    SetEnvVar('GTEST_OUTPUT', None)
+    SetEnvVar('XML_OUTPUT_FILE', 'tmp/bar.xml')
+    AssertEq('xml:tmp/bar.xml', GetFlag('output'))
+
+  def testXmlOutputFileOverride(self):
+    """Tests that $XML_OUTPUT_FILE is overridden by $GTEST_OUTPUT"""
+
+    SetEnvVar('GTEST_OUTPUT', 'xml:tmp/foo.xml')
+    SetEnvVar('XML_OUTPUT_FILE', 'tmp/bar.xml')
+    AssertEq('xml:tmp/foo.xml', GetFlag('output'))
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test_.cc
new file mode 100644
index 00000000..539afc96
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test_.cc
@@ -0,0 +1,126 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// A helper program for testing that Google Test parses the environment
+// variables correctly.
+
+#include "gtest/gtest.h"
+
+#include <iostream>
+
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+using ::std::cout;
+
+namespace testing {
+
+// The purpose of this is to make the test more realistic by ensuring
+// that the UnitTest singleton is created before main() is entered.
+// We don't actual run the TEST itself.
+TEST(GTestEnvVarTest, Dummy) {
+}
+
+void PrintFlag(const char* flag) {
+  if (strcmp(flag, "break_on_failure") == 0) {
+    cout << GTEST_FLAG(break_on_failure);
+    return;
+  }
+
+  if (strcmp(flag, "catch_exceptions") == 0) {
+    cout << GTEST_FLAG(catch_exceptions);
+    return;
+  }
+
+  if (strcmp(flag, "color") == 0) {
+    cout << GTEST_FLAG(color);
+    return;
+  }
+
+  if (strcmp(flag, "death_test_style") == 0) {
+    cout << GTEST_FLAG(death_test_style);
+    return;
+  }
+
+  if (strcmp(flag, "death_test_use_fork") == 0) {
+    cout << GTEST_FLAG(death_test_use_fork);
+    return;
+  }
+
+  if (strcmp(flag, "filter") == 0) {
+    cout << GTEST_FLAG(filter);
+    return;
+  }
+
+  if (strcmp(flag, "output") == 0) {
+    cout << GTEST_FLAG(output);
+    return;
+  }
+
+  if (strcmp(flag, "print_time") == 0) {
+    cout << GTEST_FLAG(print_time);
+    return;
+  }
+
+  if (strcmp(flag, "repeat") == 0) {
+    cout << GTEST_FLAG(repeat);
+    return;
+  }
+
+  if (strcmp(flag, "stack_trace_depth") == 0) {
+    cout << GTEST_FLAG(stack_trace_depth);
+    return;
+  }
+
+  if (strcmp(flag, "throw_on_failure") == 0) {
+    cout << GTEST_FLAG(throw_on_failure);
+    return;
+  }
+
+  cout << "Invalid flag name " << flag
+       << ".  Valid names are break_on_failure, color, filter, etc.\n";
+  exit(1);
+}
+
+}  // namespace testing
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  if (argc != 2) {
+    cout << "Usage: gtest_env_var_test_ NAME_OF_FLAG\n";
+    return 1;
+  }
+
+  testing::PrintFlag(argv[1]);
+  return 0;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_environment_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_environment_test.cc
new file mode 100644
index 00000000..3cff19e7
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_environment_test.cc
@@ -0,0 +1,192 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Tests using global test environments.
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "gtest/gtest.h"
+
+#define GTEST_IMPLEMENTATION_ 1  // Required for the next #include.
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+namespace testing {
+GTEST_DECLARE_string_(filter);
+}
+
+namespace {
+
+enum FailureType {
+  NO_FAILURE, NON_FATAL_FAILURE, FATAL_FAILURE
+};
+
+// For testing using global test environments.
+class MyEnvironment : public testing::Environment {
+ public:
+  MyEnvironment() { Reset(); }
+
+  // Depending on the value of failure_in_set_up_, SetUp() will
+  // generate a non-fatal failure, generate a fatal failure, or
+  // succeed.
+  virtual void SetUp() {
+    set_up_was_run_ = true;
+
+    switch (failure_in_set_up_) {
+      case NON_FATAL_FAILURE:
+        ADD_FAILURE() << "Expected non-fatal failure in global set-up.";
+        break;
+      case FATAL_FAILURE:
+        FAIL() << "Expected fatal failure in global set-up.";
+        break;
+      default:
+        break;
+    }
+  }
+
+  // Generates a non-fatal failure.
+  virtual void TearDown() {
+    tear_down_was_run_ = true;
+    ADD_FAILURE() << "Expected non-fatal failure in global tear-down.";
+  }
+
+  // Resets the state of the environment s.t. it can be reused.
+  void Reset() {
+    failure_in_set_up_ = NO_FAILURE;
+    set_up_was_run_ = false;
+    tear_down_was_run_ = false;
+  }
+
+  // We call this function to set the type of failure SetUp() should
+  // generate.
+  void set_failure_in_set_up(FailureType type) {
+    failure_in_set_up_ = type;
+  }
+
+  // Was SetUp() run?
+  bool set_up_was_run() const { return set_up_was_run_; }
+
+  // Was TearDown() run?
+  bool tear_down_was_run() const { return tear_down_was_run_; }
+
+ private:
+  FailureType failure_in_set_up_;
+  bool set_up_was_run_;
+  bool tear_down_was_run_;
+};
+
+// Was the TEST run?
+bool test_was_run;
+
+// The sole purpose of this TEST is to enable us to check whether it
+// was run.
+TEST(FooTest, Bar) {
+  test_was_run = true;
+}
+
+// Prints the message and aborts the program if condition is false.
+void Check(bool condition, const char* msg) {
+  if (!condition) {
+    printf("FAILED: %s\n", msg);
+    testing::internal::posix::Abort();
+  }
+}
+
+// Runs the tests.  Return true iff successful.
+//
+// The 'failure' parameter specifies the type of failure that should
+// be generated by the global set-up.
+int RunAllTests(MyEnvironment* env, FailureType failure) {
+  env->Reset();
+  env->set_failure_in_set_up(failure);
+  test_was_run = false;
+  testing::internal::GetUnitTestImpl()->ClearAdHocTestResult();
+  return RUN_ALL_TESTS();
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  // Registers a global test environment, and verifies that the
+  // registration function returns its argument.
+  MyEnvironment* const env = new MyEnvironment;
+  Check(testing::AddGlobalTestEnvironment(env) == env,
+        "AddGlobalTestEnvironment() should return its argument.");
+
+  // Verifies that RUN_ALL_TESTS() runs the tests when the global
+  // set-up is successful.
+  Check(RunAllTests(env, NO_FAILURE) != 0,
+        "RUN_ALL_TESTS() should return non-zero, as the global tear-down "
+        "should generate a failure.");
+  Check(test_was_run,
+        "The tests should run, as the global set-up should generate no "
+        "failure");
+  Check(env->tear_down_was_run(),
+        "The global tear-down should run, as the global set-up was run.");
+
+  // Verifies that RUN_ALL_TESTS() runs the tests when the global
+  // set-up generates no fatal failure.
+  Check(RunAllTests(env, NON_FATAL_FAILURE) != 0,
+        "RUN_ALL_TESTS() should return non-zero, as both the global set-up "
+        "and the global tear-down should generate a non-fatal failure.");
+  Check(test_was_run,
+        "The tests should run, as the global set-up should generate no "
+        "fatal failure.");
+  Check(env->tear_down_was_run(),
+        "The global tear-down should run, as the global set-up was run.");
+
+  // Verifies that RUN_ALL_TESTS() runs no test when the global set-up
+  // generates a fatal failure.
+  Check(RunAllTests(env, FATAL_FAILURE) != 0,
+        "RUN_ALL_TESTS() should return non-zero, as the global set-up "
+        "should generate a fatal failure.");
+  Check(!test_was_run,
+        "The tests should not run, as the global set-up should generate "
+        "a fatal failure.");
+  Check(env->tear_down_was_run(),
+        "The global tear-down should run, as the global set-up was run.");
+
+  // Verifies that RUN_ALL_TESTS() doesn't do global set-up or
+  // tear-down when there is no test to run.
+  testing::GTEST_FLAG(filter) = "-*";
+  Check(RunAllTests(env, NO_FAILURE) == 0,
+        "RUN_ALL_TESTS() should return zero, as there is no test to run.");
+  Check(!env->set_up_was_run(),
+        "The global set-up should not run, as there is no test to run.");
+  Check(!env->tear_down_was_run(),
+        "The global tear-down should not run, "
+        "as the global set-up was not run.");
+
+  printf("PASS\n");
+  return 0;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest.py
new file mode 100755
index 00000000..ec0b151b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest.py
@@ -0,0 +1,636 @@
+#!/usr/bin/env python
+#
+# Copyright 2005 Google Inc. All Rights Reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Unit test for Google Test test filters.
+
+A user can specify which test(s) in a Google Test program to run via either
+the GTEST_FILTER environment variable or the --gtest_filter flag.
+This script tests such functionality by invoking
+gtest_filter_unittest_ (a program written with Google Test) with different
+environments and command line flags.
+
+Note that test sharding may also influence which tests are filtered. Therefore,
+we test that here also.
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import re
+try:
+  from sets import Set as set  # For Python 2.3 compatibility
+except ImportError:
+  pass
+import sys
+
+import gtest_test_utils
+
+# Constants.
+
+# Checks if this platform can pass empty environment variables to child
+# processes.  We set an env variable to an empty string and invoke a python
+# script in a subprocess to print whether the variable is STILL in
+# os.environ.  We then use 'eval' to parse the child's output so that an
+# exception is thrown if the input is anything other than 'True' nor 'False'.
+os.environ['EMPTY_VAR'] = ''
+child = gtest_test_utils.Subprocess(
+    [sys.executable, '-c', 'import os; print(\'EMPTY_VAR\' in os.environ)'])
+CAN_PASS_EMPTY_ENV = eval(child.output)
+
+
+# Check if this platform can unset environment variables in child processes.
+# We set an env variable to a non-empty string, unset it, and invoke
+# a python script in a subprocess to print whether the variable
+# is NO LONGER in os.environ.
+# We use 'eval' to parse the child's output so that an exception
+# is thrown if the input is neither 'True' nor 'False'.
+os.environ['UNSET_VAR'] = 'X'
+del os.environ['UNSET_VAR']
+child = gtest_test_utils.Subprocess(
+    [sys.executable, '-c', 'import os; print(\'UNSET_VAR\' not in os.environ)'])
+CAN_UNSET_ENV = eval(child.output)
+
+
+# Checks if we should test with an empty filter. This doesn't
+# make sense on platforms that cannot pass empty env variables (Win32)
+# and on platforms that cannot unset variables (since we cannot tell
+# the difference between "" and NULL -- Borland and Solaris < 5.10)
+CAN_TEST_EMPTY_FILTER = (CAN_PASS_EMPTY_ENV and CAN_UNSET_ENV)
+
+
+# The environment variable for specifying the test filters.
+FILTER_ENV_VAR = 'GTEST_FILTER'
+
+# The environment variables for test sharding.
+TOTAL_SHARDS_ENV_VAR = 'GTEST_TOTAL_SHARDS'
+SHARD_INDEX_ENV_VAR = 'GTEST_SHARD_INDEX'
+SHARD_STATUS_FILE_ENV_VAR = 'GTEST_SHARD_STATUS_FILE'
+
+# The command line flag for specifying the test filters.
+FILTER_FLAG = 'gtest_filter'
+
+# The command line flag for including disabled tests.
+ALSO_RUN_DISABED_TESTS_FLAG = 'gtest_also_run_disabled_tests'
+
+# Command to run the gtest_filter_unittest_ program.
+COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_filter_unittest_')
+
+# Regex for determining whether parameterized tests are enabled in the binary.
+PARAM_TEST_REGEX = re.compile(r'/ParamTest')
+
+# Regex for parsing test case names from Google Test's output.
+TEST_CASE_REGEX = re.compile(r'^\[\-+\] \d+ tests? from (\w+(/\w+)?)')
+
+# Regex for parsing test names from Google Test's output.
+TEST_REGEX = re.compile(r'^\[\s*RUN\s*\].*\.(\w+(/\w+)?)')
+
+# The command line flag to tell Google Test to output the list of tests it
+# will run.
+LIST_TESTS_FLAG = '--gtest_list_tests'
+
+# Indicates whether Google Test supports death tests.
+SUPPORTS_DEATH_TESTS = 'HasDeathTest' in gtest_test_utils.Subprocess(
+    [COMMAND, LIST_TESTS_FLAG]).output
+
+# Full names of all tests in gtest_filter_unittests_.
+PARAM_TESTS = [
+    'SeqP/ParamTest.TestX/0',
+    'SeqP/ParamTest.TestX/1',
+    'SeqP/ParamTest.TestY/0',
+    'SeqP/ParamTest.TestY/1',
+    'SeqQ/ParamTest.TestX/0',
+    'SeqQ/ParamTest.TestX/1',
+    'SeqQ/ParamTest.TestY/0',
+    'SeqQ/ParamTest.TestY/1',
+    ]
+
+DISABLED_TESTS = [
+    'BarTest.DISABLED_TestFour',
+    'BarTest.DISABLED_TestFive',
+    'BazTest.DISABLED_TestC',
+    'DISABLED_FoobarTest.Test1',
+    'DISABLED_FoobarTest.DISABLED_Test2',
+    'DISABLED_FoobarbazTest.TestA',
+    ]
+
+if SUPPORTS_DEATH_TESTS:
+  DEATH_TESTS = [
+    'HasDeathTest.Test1',
+    'HasDeathTest.Test2',
+    ]
+else:
+  DEATH_TESTS = []
+
+# All the non-disabled tests.
+ACTIVE_TESTS = [
+    'FooTest.Abc',
+    'FooTest.Xyz',
+
+    'BarTest.TestOne',
+    'BarTest.TestTwo',
+    'BarTest.TestThree',
+
+    'BazTest.TestOne',
+    'BazTest.TestA',
+    'BazTest.TestB',
+    ] + DEATH_TESTS + PARAM_TESTS
+
+param_tests_present = None
+
+# Utilities.
+
+environ = os.environ.copy()
+
+
+def SetEnvVar(env_var, value):
+  """Sets the env variable to 'value'; unsets it when 'value' is None."""
+
+  if value is not None:
+    environ[env_var] = value
+  elif env_var in environ:
+    del environ[env_var]
+
+
+def RunAndReturnOutput(args = None):
+  """Runs the test program and returns its output."""
+
+  return gtest_test_utils.Subprocess([COMMAND] + (args or []),
+                                     env=environ).output
+
+
+def RunAndExtractTestList(args = None):
+  """Runs the test program and returns its exit code and a list of tests run."""
+
+  p = gtest_test_utils.Subprocess([COMMAND] + (args or []), env=environ)
+  tests_run = []
+  test_case = ''
+  test = ''
+  for line in p.output.split('\n'):
+    match = TEST_CASE_REGEX.match(line)
+    if match is not None:
+      test_case = match.group(1)
+    else:
+      match = TEST_REGEX.match(line)
+      if match is not None:
+        test = match.group(1)
+        tests_run.append(test_case + '.' + test)
+  return (tests_run, p.exit_code)
+
+
+def InvokeWithModifiedEnv(extra_env, function, *args, **kwargs):
+  """Runs the given function and arguments in a modified environment."""
+  try:
+    original_env = environ.copy()
+    environ.update(extra_env)
+    return function(*args, **kwargs)
+  finally:
+    environ.clear()
+    environ.update(original_env)
+
+
+def RunWithSharding(total_shards, shard_index, command):
+  """Runs a test program shard and returns exit code and a list of tests run."""
+
+  extra_env = {SHARD_INDEX_ENV_VAR: str(shard_index),
+               TOTAL_SHARDS_ENV_VAR: str(total_shards)}
+  return InvokeWithModifiedEnv(extra_env, RunAndExtractTestList, command)
+
+# The unit test.
+
+
+class GTestFilterUnitTest(gtest_test_utils.TestCase):
+  """Tests the env variable or the command line flag to filter tests."""
+
+  # Utilities.
+
+  def AssertSetEqual(self, lhs, rhs):
+    """Asserts that two sets are equal."""
+
+    for elem in lhs:
+      self.assert_(elem in rhs, '%s in %s' % (elem, rhs))
+
+    for elem in rhs:
+      self.assert_(elem in lhs, '%s in %s' % (elem, lhs))
+
+  def AssertPartitionIsValid(self, set_var, list_of_sets):
+    """Asserts that list_of_sets is a valid partition of set_var."""
+
+    full_partition = []
+    for slice_var in list_of_sets:
+      full_partition.extend(slice_var)
+    self.assertEqual(len(set_var), len(full_partition))
+    self.assertEqual(set(set_var), set(full_partition))
+
+  def AdjustForParameterizedTests(self, tests_to_run):
+    """Adjust tests_to_run in case value parameterized tests are disabled."""
+
+    global param_tests_present
+    if not param_tests_present:
+      return list(set(tests_to_run) - set(PARAM_TESTS))
+    else:
+      return tests_to_run
+
+  def RunAndVerify(self, gtest_filter, tests_to_run):
+    """Checks that the binary runs correct set of tests for a given filter."""
+
+    tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
+
+    # First, tests using the environment variable.
+
+    # Windows removes empty variables from the environment when passing it
+    # to a new process.  This means it is impossible to pass an empty filter
+    # into a process using the environment variable.  However, we can still
+    # test the case when the variable is not supplied (i.e., gtest_filter is
+    # None).
+    # pylint: disable-msg=C6403
+    if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
+      SetEnvVar(FILTER_ENV_VAR, gtest_filter)
+      tests_run = RunAndExtractTestList()[0]
+      SetEnvVar(FILTER_ENV_VAR, None)
+      self.AssertSetEqual(tests_run, tests_to_run)
+    # pylint: enable-msg=C6403
+
+    # Next, tests using the command line flag.
+
+    if gtest_filter is None:
+      args = []
+    else:
+      args = ['--%s=%s' % (FILTER_FLAG, gtest_filter)]
+
+    tests_run = RunAndExtractTestList(args)[0]
+    self.AssertSetEqual(tests_run, tests_to_run)
+
+  def RunAndVerifyWithSharding(self, gtest_filter, total_shards, tests_to_run,
+                               args=None, check_exit_0=False):
+    """Checks that binary runs correct tests for the given filter and shard.
+
+    Runs all shards of gtest_filter_unittest_ with the given filter, and
+    verifies that the right set of tests were run. The union of tests run
+    on each shard should be identical to tests_to_run, without duplicates.
+
+    Args:
+      gtest_filter: A filter to apply to the tests.
+      total_shards: A total number of shards to split test run into.
+      tests_to_run: A set of tests expected to run.
+      args   :      Arguments to pass to the to the test binary.
+      check_exit_0: When set to a true value, make sure that all shards
+                    return 0.
+    """
+
+    tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
+
+    # Windows removes empty variables from the environment when passing it
+    # to a new process.  This means it is impossible to pass an empty filter
+    # into a process using the environment variable.  However, we can still
+    # test the case when the variable is not supplied (i.e., gtest_filter is
+    # None).
+    # pylint: disable-msg=C6403
+    if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
+      SetEnvVar(FILTER_ENV_VAR, gtest_filter)
+      partition = []
+      for i in range(0, total_shards):
+        (tests_run, exit_code) = RunWithSharding(total_shards, i, args)
+        if check_exit_0:
+          self.assertEqual(0, exit_code)
+        partition.append(tests_run)
+
+      self.AssertPartitionIsValid(tests_to_run, partition)
+      SetEnvVar(FILTER_ENV_VAR, None)
+    # pylint: enable-msg=C6403
+
+  def RunAndVerifyAllowingDisabled(self, gtest_filter, tests_to_run):
+    """Checks that the binary runs correct set of tests for the given filter.
+
+    Runs gtest_filter_unittest_ with the given filter, and enables
+    disabled tests. Verifies that the right set of tests were run.
+
+    Args:
+      gtest_filter: A filter to apply to the tests.
+      tests_to_run: A set of tests expected to run.
+    """
+
+    tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
+
+    # Construct the command line.
+    args = ['--%s' % ALSO_RUN_DISABED_TESTS_FLAG]
+    if gtest_filter is not None:
+      args.append('--%s=%s' % (FILTER_FLAG, gtest_filter))
+
+    tests_run = RunAndExtractTestList(args)[0]
+    self.AssertSetEqual(tests_run, tests_to_run)
+
+  def setUp(self):
+    """Sets up test case.
+
+    Determines whether value-parameterized tests are enabled in the binary and
+    sets the flags accordingly.
+    """
+
+    global param_tests_present
+    if param_tests_present is None:
+      param_tests_present = PARAM_TEST_REGEX.search(
+          RunAndReturnOutput()) is not None
+
+  def testDefaultBehavior(self):
+    """Tests the behavior of not specifying the filter."""
+
+    self.RunAndVerify(None, ACTIVE_TESTS)
+
+  def testDefaultBehaviorWithShards(self):
+    """Tests the behavior without the filter, with sharding enabled."""
+
+    self.RunAndVerifyWithSharding(None, 1, ACTIVE_TESTS)
+    self.RunAndVerifyWithSharding(None, 2, ACTIVE_TESTS)
+    self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) - 1, ACTIVE_TESTS)
+    self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS), ACTIVE_TESTS)
+    self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) + 1, ACTIVE_TESTS)
+
+  def testEmptyFilter(self):
+    """Tests an empty filter."""
+
+    self.RunAndVerify('', [])
+    self.RunAndVerifyWithSharding('', 1, [])
+    self.RunAndVerifyWithSharding('', 2, [])
+
+  def testBadFilter(self):
+    """Tests a filter that matches nothing."""
+
+    self.RunAndVerify('BadFilter', [])
+    self.RunAndVerifyAllowingDisabled('BadFilter', [])
+
+  def testFullName(self):
+    """Tests filtering by full name."""
+
+    self.RunAndVerify('FooTest.Xyz', ['FooTest.Xyz'])
+    self.RunAndVerifyAllowingDisabled('FooTest.Xyz', ['FooTest.Xyz'])
+    self.RunAndVerifyWithSharding('FooTest.Xyz', 5, ['FooTest.Xyz'])
+
+  def testUniversalFilters(self):
+    """Tests filters that match everything."""
+
+    self.RunAndVerify('*', ACTIVE_TESTS)
+    self.RunAndVerify('*.*', ACTIVE_TESTS)
+    self.RunAndVerifyWithSharding('*.*', len(ACTIVE_TESTS) - 3, ACTIVE_TESTS)
+    self.RunAndVerifyAllowingDisabled('*', ACTIVE_TESTS + DISABLED_TESTS)
+    self.RunAndVerifyAllowingDisabled('*.*', ACTIVE_TESTS + DISABLED_TESTS)
+
+  def testFilterByTestCase(self):
+    """Tests filtering by test case name."""
+
+    self.RunAndVerify('FooTest.*', ['FooTest.Abc', 'FooTest.Xyz'])
+
+    BAZ_TESTS = ['BazTest.TestOne', 'BazTest.TestA', 'BazTest.TestB']
+    self.RunAndVerify('BazTest.*', BAZ_TESTS)
+    self.RunAndVerifyAllowingDisabled('BazTest.*',
+                                      BAZ_TESTS + ['BazTest.DISABLED_TestC'])
+
+  def testFilterByTest(self):
+    """Tests filtering by test name."""
+
+    self.RunAndVerify('*.TestOne', ['BarTest.TestOne', 'BazTest.TestOne'])
+
+  def testFilterDisabledTests(self):
+    """Select only the disabled tests to run."""
+
+    self.RunAndVerify('DISABLED_FoobarTest.Test1', [])
+    self.RunAndVerifyAllowingDisabled('DISABLED_FoobarTest.Test1',
+                                      ['DISABLED_FoobarTest.Test1'])
+
+    self.RunAndVerify('*DISABLED_*', [])
+    self.RunAndVerifyAllowingDisabled('*DISABLED_*', DISABLED_TESTS)
+
+    self.RunAndVerify('*.DISABLED_*', [])
+    self.RunAndVerifyAllowingDisabled('*.DISABLED_*', [
+        'BarTest.DISABLED_TestFour',
+        'BarTest.DISABLED_TestFive',
+        'BazTest.DISABLED_TestC',
+        'DISABLED_FoobarTest.DISABLED_Test2',
+        ])
+
+    self.RunAndVerify('DISABLED_*', [])
+    self.RunAndVerifyAllowingDisabled('DISABLED_*', [
+        'DISABLED_FoobarTest.Test1',
+        'DISABLED_FoobarTest.DISABLED_Test2',
+        'DISABLED_FoobarbazTest.TestA',
+        ])
+
+  def testWildcardInTestCaseName(self):
+    """Tests using wildcard in the test case name."""
+
+    self.RunAndVerify('*a*.*', [
+        'BarTest.TestOne',
+        'BarTest.TestTwo',
+        'BarTest.TestThree',
+
+        'BazTest.TestOne',
+        'BazTest.TestA',
+        'BazTest.TestB', ] + DEATH_TESTS + PARAM_TESTS)
+
+  def testWildcardInTestName(self):
+    """Tests using wildcard in the test name."""
+
+    self.RunAndVerify('*.*A*', ['FooTest.Abc', 'BazTest.TestA'])
+
+  def testFilterWithoutDot(self):
+    """Tests a filter that has no '.' in it."""
+
+    self.RunAndVerify('*z*', [
+        'FooTest.Xyz',
+
+        'BazTest.TestOne',
+        'BazTest.TestA',
+        'BazTest.TestB',
+        ])
+
+  def testTwoPatterns(self):
+    """Tests filters that consist of two patterns."""
+
+    self.RunAndVerify('Foo*.*:*A*', [
+        'FooTest.Abc',
+        'FooTest.Xyz',
+
+        'BazTest.TestA',
+        ])
+
+    # An empty pattern + a non-empty one
+    self.RunAndVerify(':*A*', ['FooTest.Abc', 'BazTest.TestA'])
+
+  def testThreePatterns(self):
+    """Tests filters that consist of three patterns."""
+
+    self.RunAndVerify('*oo*:*A*:*One', [
+        'FooTest.Abc',
+        'FooTest.Xyz',
+
+        'BarTest.TestOne',
+
+        'BazTest.TestOne',
+        'BazTest.TestA',
+        ])
+
+    # The 2nd pattern is empty.
+    self.RunAndVerify('*oo*::*One', [
+        'FooTest.Abc',
+        'FooTest.Xyz',
+
+        'BarTest.TestOne',
+
+        'BazTest.TestOne',
+        ])
+
+    # The last 2 patterns are empty.
+    self.RunAndVerify('*oo*::', [
+        'FooTest.Abc',
+        'FooTest.Xyz',
+        ])
+
+  def testNegativeFilters(self):
+    self.RunAndVerify('*-BazTest.TestOne', [
+        'FooTest.Abc',
+        'FooTest.Xyz',
+
+        'BarTest.TestOne',
+        'BarTest.TestTwo',
+        'BarTest.TestThree',
+
+        'BazTest.TestA',
+        'BazTest.TestB',
+        ] + DEATH_TESTS + PARAM_TESTS)
+
+    self.RunAndVerify('*-FooTest.Abc:BazTest.*', [
+        'FooTest.Xyz',
+
+        'BarTest.TestOne',
+        'BarTest.TestTwo',
+        'BarTest.TestThree',
+        ] + DEATH_TESTS + PARAM_TESTS)
+
+    self.RunAndVerify('BarTest.*-BarTest.TestOne', [
+        'BarTest.TestTwo',
+        'BarTest.TestThree',
+        ])
+
+    # Tests without leading '*'.
+    self.RunAndVerify('-FooTest.Abc:FooTest.Xyz:BazTest.*', [
+        'BarTest.TestOne',
+        'BarTest.TestTwo',
+        'BarTest.TestThree',
+        ] + DEATH_TESTS + PARAM_TESTS)
+
+    # Value parameterized tests.
+    self.RunAndVerify('*/*', PARAM_TESTS)
+
+    # Value parameterized tests filtering by the sequence name.
+    self.RunAndVerify('SeqP/*', [
+        'SeqP/ParamTest.TestX/0',
+        'SeqP/ParamTest.TestX/1',
+        'SeqP/ParamTest.TestY/0',
+        'SeqP/ParamTest.TestY/1',
+        ])
+
+    # Value parameterized tests filtering by the test name.
+    self.RunAndVerify('*/0', [
+        'SeqP/ParamTest.TestX/0',
+        'SeqP/ParamTest.TestY/0',
+        'SeqQ/ParamTest.TestX/0',
+        'SeqQ/ParamTest.TestY/0',
+        ])
+
+  def testFlagOverridesEnvVar(self):
+    """Tests that the filter flag overrides the filtering env. variable."""
+
+    SetEnvVar(FILTER_ENV_VAR, 'Foo*')
+    args = ['--%s=%s' % (FILTER_FLAG, '*One')]
+    tests_run = RunAndExtractTestList(args)[0]
+    SetEnvVar(FILTER_ENV_VAR, None)
+
+    self.AssertSetEqual(tests_run, ['BarTest.TestOne', 'BazTest.TestOne'])
+
+  def testShardStatusFileIsCreated(self):
+    """Tests that the shard file is created if specified in the environment."""
+
+    shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
+                                     'shard_status_file')
+    self.assert_(not os.path.exists(shard_status_file))
+
+    extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
+    try:
+      InvokeWithModifiedEnv(extra_env, RunAndReturnOutput)
+    finally:
+      self.assert_(os.path.exists(shard_status_file))
+      os.remove(shard_status_file)
+
+  def testShardStatusFileIsCreatedWithListTests(self):
+    """Tests that the shard file is created with the "list_tests" flag."""
+
+    shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
+                                     'shard_status_file2')
+    self.assert_(not os.path.exists(shard_status_file))
+
+    extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
+    try:
+      output = InvokeWithModifiedEnv(extra_env,
+                                     RunAndReturnOutput,
+                                     [LIST_TESTS_FLAG])
+    finally:
+      # This assertion ensures that Google Test enumerated the tests as
+      # opposed to running them.
+      self.assert_('[==========]' not in output,
+                   'Unexpected output during test enumeration.\n'
+                   'Please ensure that LIST_TESTS_FLAG is assigned the\n'
+                   'correct flag value for listing Google Test tests.')
+
+      self.assert_(os.path.exists(shard_status_file))
+      os.remove(shard_status_file)
+
+  if SUPPORTS_DEATH_TESTS:
+    def testShardingWorksWithDeathTests(self):
+      """Tests integration with death tests and sharding."""
+
+      gtest_filter = 'HasDeathTest.*:SeqP/*'
+      expected_tests = [
+          'HasDeathTest.Test1',
+          'HasDeathTest.Test2',
+
+          'SeqP/ParamTest.TestX/0',
+          'SeqP/ParamTest.TestX/1',
+          'SeqP/ParamTest.TestY/0',
+          'SeqP/ParamTest.TestY/1',
+          ]
+
+      for flag in ['--gtest_death_test_style=threadsafe',
+                   '--gtest_death_test_style=fast']:
+        self.RunAndVerifyWithSharding(gtest_filter, 3, expected_tests,
+                                      check_exit_0=True, args=[flag])
+        self.RunAndVerifyWithSharding(gtest_filter, 5, expected_tests,
+                                      check_exit_0=True, args=[flag])
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest_.cc
new file mode 100644
index 00000000..77deffc3
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest_.cc
@@ -0,0 +1,140 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Unit test for Google Test test filters.
+//
+// A user can specify which test(s) in a Google Test program to run via
+// either the GTEST_FILTER environment variable or the --gtest_filter
+// flag.  This is used for testing such functionality.
+//
+// The program will be invoked from a Python unit test.  Don't run it
+// directly.
+
+#include "gtest/gtest.h"
+
+namespace {
+
+// Test case FooTest.
+
+class FooTest : public testing::Test {
+};
+
+TEST_F(FooTest, Abc) {
+}
+
+TEST_F(FooTest, Xyz) {
+  FAIL() << "Expected failure.";
+}
+
+// Test case BarTest.
+
+TEST(BarTest, TestOne) {
+}
+
+TEST(BarTest, TestTwo) {
+}
+
+TEST(BarTest, TestThree) {
+}
+
+TEST(BarTest, DISABLED_TestFour) {
+  FAIL() << "Expected failure.";
+}
+
+TEST(BarTest, DISABLED_TestFive) {
+  FAIL() << "Expected failure.";
+}
+
+// Test case BazTest.
+
+TEST(BazTest, TestOne) {
+  FAIL() << "Expected failure.";
+}
+
+TEST(BazTest, TestA) {
+}
+
+TEST(BazTest, TestB) {
+}
+
+TEST(BazTest, DISABLED_TestC) {
+  FAIL() << "Expected failure.";
+}
+
+// Test case HasDeathTest
+
+TEST(HasDeathTest, Test1) {
+  EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*");
+}
+
+// We need at least two death tests to make sure that the all death tests
+// aren't on the first shard.
+TEST(HasDeathTest, Test2) {
+  EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*");
+}
+
+// Test case FoobarTest
+
+TEST(DISABLED_FoobarTest, Test1) {
+  FAIL() << "Expected failure.";
+}
+
+TEST(DISABLED_FoobarTest, DISABLED_Test2) {
+  FAIL() << "Expected failure.";
+}
+
+// Test case FoobarbazTest
+
+TEST(DISABLED_FoobarbazTest, TestA) {
+  FAIL() << "Expected failure.";
+}
+
+#if GTEST_HAS_PARAM_TEST
+class ParamTest : public testing::TestWithParam<int> {
+};
+
+TEST_P(ParamTest, TestX) {
+}
+
+TEST_P(ParamTest, TestY) {
+}
+
+INSTANTIATE_TEST_CASE_P(SeqP, ParamTest, testing::Values(1, 2));
+INSTANTIATE_TEST_CASE_P(SeqQ, ParamTest, testing::Values(5, 6));
+#endif  // GTEST_HAS_PARAM_TEST
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test.py
new file mode 100755
index 00000000..093c838d
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test.py
@@ -0,0 +1,172 @@
+#!/usr/bin/env python
+#
+# Copyright 2009, 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.
+
+"""Tests the --help flag of Google C++ Testing Framework.
+
+SYNOPSIS
+       gtest_help_test.py --build_dir=BUILD/DIR
+         # where BUILD/DIR contains the built gtest_help_test_ file.
+       gtest_help_test.py
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import re
+import gtest_test_utils
+
+
+IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'
+IS_WINDOWS = os.name == 'nt'
+
+PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_help_test_')
+FLAG_PREFIX = '--gtest_'
+DEATH_TEST_STYLE_FLAG = FLAG_PREFIX + 'death_test_style'
+STREAM_RESULT_TO_FLAG = FLAG_PREFIX + 'stream_result_to'
+UNKNOWN_FLAG = FLAG_PREFIX + 'unknown_flag_for_testing'
+LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'
+INCORRECT_FLAG_VARIANTS = [re.sub('^--', '-', LIST_TESTS_FLAG),
+                           re.sub('^--', '/', LIST_TESTS_FLAG),
+                           re.sub('_', '-', LIST_TESTS_FLAG)]
+INTERNAL_FLAG_FOR_TESTING = FLAG_PREFIX + 'internal_flag_for_testing'
+
+SUPPORTS_DEATH_TESTS = "DeathTest" in gtest_test_utils.Subprocess(
+    [PROGRAM_PATH, LIST_TESTS_FLAG]).output
+
+# The help message must match this regex.
+HELP_REGEX = re.compile(
+    FLAG_PREFIX + r'list_tests.*' +
+    FLAG_PREFIX + r'filter=.*' +
+    FLAG_PREFIX + r'also_run_disabled_tests.*' +
+    FLAG_PREFIX + r'repeat=.*' +
+    FLAG_PREFIX + r'shuffle.*' +
+    FLAG_PREFIX + r'random_seed=.*' +
+    FLAG_PREFIX + r'color=.*' +
+    FLAG_PREFIX + r'print_time.*' +
+    FLAG_PREFIX + r'output=.*' +
+    FLAG_PREFIX + r'break_on_failure.*' +
+    FLAG_PREFIX + r'throw_on_failure.*' +
+    FLAG_PREFIX + r'catch_exceptions=0.*',
+    re.DOTALL)
+
+
+def RunWithFlag(flag):
+  """Runs gtest_help_test_ with the given flag.
+
+  Returns:
+    the exit code and the text output as a tuple.
+  Args:
+    flag: the command-line flag to pass to gtest_help_test_, or None.
+  """
+
+  if flag is None:
+    command = [PROGRAM_PATH]
+  else:
+    command = [PROGRAM_PATH, flag]
+  child = gtest_test_utils.Subprocess(command)
+  return child.exit_code, child.output
+
+
+class GTestHelpTest(gtest_test_utils.TestCase):
+  """Tests the --help flag and its equivalent forms."""
+
+  def TestHelpFlag(self, flag):
+    """Verifies correct behavior when help flag is specified.
+
+    The right message must be printed and the tests must
+    skipped when the given flag is specified.
+
+    Args:
+      flag:  A flag to pass to the binary or None.
+    """
+
+    exit_code, output = RunWithFlag(flag)
+    self.assertEquals(0, exit_code)
+    self.assert_(HELP_REGEX.search(output), output)
+
+    if IS_LINUX:
+      self.assert_(STREAM_RESULT_TO_FLAG in output, output)
+    else:
+      self.assert_(STREAM_RESULT_TO_FLAG not in output, output)
+
+    if SUPPORTS_DEATH_TESTS and not IS_WINDOWS:
+      self.assert_(DEATH_TEST_STYLE_FLAG in output, output)
+    else:
+      self.assert_(DEATH_TEST_STYLE_FLAG not in output, output)
+
+  def TestNonHelpFlag(self, flag):
+    """Verifies correct behavior when no help flag is specified.
+
+    Verifies that when no help flag is specified, the tests are run
+    and the help message is not printed.
+
+    Args:
+      flag:  A flag to pass to the binary or None.
+    """
+
+    exit_code, output = RunWithFlag(flag)
+    self.assert_(exit_code != 0)
+    self.assert_(not HELP_REGEX.search(output), output)
+
+  def testPrintsHelpWithFullFlag(self):
+    self.TestHelpFlag('--help')
+
+  def testPrintsHelpWithShortFlag(self):
+    self.TestHelpFlag('-h')
+
+  def testPrintsHelpWithQuestionFlag(self):
+    self.TestHelpFlag('-?')
+
+  def testPrintsHelpWithWindowsStyleQuestionFlag(self):
+    self.TestHelpFlag('/?')
+
+  def testPrintsHelpWithUnrecognizedGoogleTestFlag(self):
+    self.TestHelpFlag(UNKNOWN_FLAG)
+
+  def testPrintsHelpWithIncorrectFlagStyle(self):
+    for incorrect_flag in INCORRECT_FLAG_VARIANTS:
+      self.TestHelpFlag(incorrect_flag)
+
+  def testRunsTestsWithoutHelpFlag(self):
+    """Verifies that when no help flag is specified, the tests are run
+    and the help message is not printed."""
+
+    self.TestNonHelpFlag(None)
+
+  def testRunsTestsWithGtestInternalFlag(self):
+    """Verifies that the tests are run and no help message is printed when
+    a flag starting with Google Test prefix and 'internal_' is supplied."""
+
+    self.TestNonHelpFlag(INTERNAL_FLAG_FOR_TESTING)
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test_.cc
new file mode 100644
index 00000000..31f78c24
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test_.cc
@@ -0,0 +1,46 @@
+// Copyright 2009, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// This program is meant to be run by gtest_help_test.py.  Do not run
+// it directly.
+
+#include "gtest/gtest.h"
+
+// When a help flag is specified, this program should skip the tests
+// and exit with 0; otherwise the following test will be executed,
+// causing this program to exit with a non-zero code.
+TEST(HelpFlagTest, ShouldNotBeRun) {
+  ASSERT_TRUE(false) << "Tests shouldn't be run when --help is specified.";
+}
+
+#if GTEST_HAS_DEATH_TEST
+TEST(DeathTest, UsedByPythonScriptToDetectSupportForDeathTestsInThisBinary) {}
+#endif
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest.py
new file mode 100755
index 00000000..f2d2fd1b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest.py
@@ -0,0 +1,207 @@
+#!/usr/bin/env python
+#
+# Copyright 2006, 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.
+
+"""Unit test for Google Test's --gtest_list_tests flag.
+
+A user can ask Google Test to list all tests by specifying the
+--gtest_list_tests flag.  This script tests such functionality
+by invoking gtest_list_tests_unittest_ (a program written with
+Google Test) the command line flags.
+"""
+
+__author__ = 'phanna@google.com (Patrick Hanna)'
+
+import gtest_test_utils
+import re
+
+
+# Constants.
+
+# The command line flag for enabling/disabling listing all tests.
+LIST_TESTS_FLAG = 'gtest_list_tests'
+
+# Path to the gtest_list_tests_unittest_ program.
+EXE_PATH = gtest_test_utils.GetTestExecutablePath('gtest_list_tests_unittest_')
+
+# The expected output when running gtest_list_tests_unittest_ with
+# --gtest_list_tests
+EXPECTED_OUTPUT_NO_FILTER_RE = re.compile(r"""FooDeathTest\.
+  Test1
+Foo\.
+  Bar1
+  Bar2
+  DISABLED_Bar3
+Abc\.
+  Xyz
+  Def
+FooBar\.
+  Baz
+FooTest\.
+  Test1
+  DISABLED_Test2
+  Test3
+TypedTest/0\.  # TypeParam = (VeryLo{245}|class VeryLo{239})\.\.\.
+  TestA
+  TestB
+TypedTest/1\.  # TypeParam = int\s*\*( __ptr64)?
+  TestA
+  TestB
+TypedTest/2\.  # TypeParam = .*MyArray<bool,\s*42>
+  TestA
+  TestB
+My/TypeParamTest/0\.  # TypeParam = (VeryLo{245}|class VeryLo{239})\.\.\.
+  TestA
+  TestB
+My/TypeParamTest/1\.  # TypeParam = int\s*\*( __ptr64)?
+  TestA
+  TestB
+My/TypeParamTest/2\.  # TypeParam = .*MyArray<bool,\s*42>
+  TestA
+  TestB
+MyInstantiation/ValueParamTest\.
+  TestA/0  # GetParam\(\) = one line
+  TestA/1  # GetParam\(\) = two\\nlines
+  TestA/2  # GetParam\(\) = a very\\nlo{241}\.\.\.
+  TestB/0  # GetParam\(\) = one line
+  TestB/1  # GetParam\(\) = two\\nlines
+  TestB/2  # GetParam\(\) = a very\\nlo{241}\.\.\.
+""")
+
+# The expected output when running gtest_list_tests_unittest_ with
+# --gtest_list_tests and --gtest_filter=Foo*.
+EXPECTED_OUTPUT_FILTER_FOO_RE = re.compile(r"""FooDeathTest\.
+  Test1
+Foo\.
+  Bar1
+  Bar2
+  DISABLED_Bar3
+FooBar\.
+  Baz
+FooTest\.
+  Test1
+  DISABLED_Test2
+  Test3
+""")
+
+# Utilities.
+
+
+def Run(args):
+  """Runs gtest_list_tests_unittest_ and returns the list of tests printed."""
+
+  return gtest_test_utils.Subprocess([EXE_PATH] + args,
+                                     capture_stderr=False).output
+
+
+# The unit test.
+
+class GTestListTestsUnitTest(gtest_test_utils.TestCase):
+  """Tests using the --gtest_list_tests flag to list all tests."""
+
+  def RunAndVerify(self, flag_value, expected_output_re, other_flag):
+    """Runs gtest_list_tests_unittest_ and verifies that it prints
+    the correct tests.
+
+    Args:
+      flag_value:         value of the --gtest_list_tests flag;
+                          None if the flag should not be present.
+      expected_output_re: regular expression that matches the expected
+                          output after running command;
+      other_flag:         a different flag to be passed to command
+                          along with gtest_list_tests;
+                          None if the flag should not be present.
+    """
+
+    if flag_value is None:
+      flag = ''
+      flag_expression = 'not set'
+    elif flag_value == '0':
+      flag = '--%s=0' % LIST_TESTS_FLAG
+      flag_expression = '0'
+    else:
+      flag = '--%s' % LIST_TESTS_FLAG
+      flag_expression = '1'
+
+    args = [flag]
+
+    if other_flag is not None:
+      args += [other_flag]
+
+    output = Run(args)
+
+    if expected_output_re:
+      self.assert_(
+          expected_output_re.match(output),
+          ('when %s is %s, the output of "%s" is "%s",\n'
+           'which does not match regex "%s"' %
+           (LIST_TESTS_FLAG, flag_expression, ' '.join(args), output,
+            expected_output_re.pattern)))
+    else:
+      self.assert_(
+          not EXPECTED_OUTPUT_NO_FILTER_RE.match(output),
+          ('when %s is %s, the output of "%s" is "%s"'%
+           (LIST_TESTS_FLAG, flag_expression, ' '.join(args), output)))
+
+  def testDefaultBehavior(self):
+    """Tests the behavior of the default mode."""
+
+    self.RunAndVerify(flag_value=None,
+                      expected_output_re=None,
+                      other_flag=None)
+
+  def testFlag(self):
+    """Tests using the --gtest_list_tests flag."""
+
+    self.RunAndVerify(flag_value='0',
+                      expected_output_re=None,
+                      other_flag=None)
+    self.RunAndVerify(flag_value='1',
+                      expected_output_re=EXPECTED_OUTPUT_NO_FILTER_RE,
+                      other_flag=None)
+
+  def testOverrideNonFilterFlags(self):
+    """Tests that --gtest_list_tests overrides the non-filter flags."""
+
+    self.RunAndVerify(flag_value='1',
+                      expected_output_re=EXPECTED_OUTPUT_NO_FILTER_RE,
+                      other_flag='--gtest_break_on_failure')
+
+  def testWithFilterFlags(self):
+    """Tests that --gtest_list_tests takes into account the
+    --gtest_filter flag."""
+
+    self.RunAndVerify(flag_value='1',
+                      expected_output_re=EXPECTED_OUTPUT_FILTER_FOO_RE,
+                      other_flag='--gtest_filter=Foo*')
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest_.cc
new file mode 100644
index 00000000..907c176b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest_.cc
@@ -0,0 +1,157 @@
+// Copyright 2006, 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.
+//
+// Author: phanna@google.com (Patrick Hanna)
+
+// Unit test for Google Test's --gtest_list_tests flag.
+//
+// A user can ask Google Test to list all tests that will run
+// so that when using a filter, a user will know what
+// tests to look for. The tests will not be run after listing.
+//
+// This program will be invoked from a Python unit test.
+// Don't run it directly.
+
+#include "gtest/gtest.h"
+
+// Several different test cases and tests that will be listed.
+TEST(Foo, Bar1) {
+}
+
+TEST(Foo, Bar2) {
+}
+
+TEST(Foo, DISABLED_Bar3) {
+}
+
+TEST(Abc, Xyz) {
+}
+
+TEST(Abc, Def) {
+}
+
+TEST(FooBar, Baz) {
+}
+
+class FooTest : public testing::Test {
+};
+
+TEST_F(FooTest, Test1) {
+}
+
+TEST_F(FooTest, DISABLED_Test2) {
+}
+
+TEST_F(FooTest, Test3) {
+}
+
+TEST(FooDeathTest, Test1) {
+}
+
+// A group of value-parameterized tests.
+
+class MyType {
+ public:
+  explicit MyType(const std::string& a_value) : value_(a_value) {}
+
+  const std::string& value() const { return value_; }
+
+ private:
+  std::string value_;
+};
+
+// Teaches Google Test how to print a MyType.
+void PrintTo(const MyType& x, std::ostream* os) {
+  *os << x.value();
+}
+
+class ValueParamTest : public testing::TestWithParam<MyType> {
+};
+
+TEST_P(ValueParamTest, TestA) {
+}
+
+TEST_P(ValueParamTest, TestB) {
+}
+
+INSTANTIATE_TEST_CASE_P(
+    MyInstantiation, ValueParamTest,
+    testing::Values(MyType("one line"),
+                    MyType("two\nlines"),
+                    MyType("a very\nloooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong line")));  // NOLINT
+
+// A group of typed tests.
+
+// A deliberately long type name for testing the line-truncating
+// behavior when printing a type parameter.
+class VeryLoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooogName {  // NOLINT
+};
+
+template <typename T>
+class TypedTest : public testing::Test {
+};
+
+template <typename T, int kSize>
+class MyArray {
+};
+
+typedef testing::Types<VeryLoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooogName,  // NOLINT
+                       int*, MyArray<bool, 42> > MyTypes;
+
+TYPED_TEST_CASE(TypedTest, MyTypes);
+
+TYPED_TEST(TypedTest, TestA) {
+}
+
+TYPED_TEST(TypedTest, TestB) {
+}
+
+// A group of type-parameterized tests.
+
+template <typename T>
+class TypeParamTest : public testing::Test {
+};
+
+TYPED_TEST_CASE_P(TypeParamTest);
+
+TYPED_TEST_P(TypeParamTest, TestA) {
+}
+
+TYPED_TEST_P(TypeParamTest, TestB) {
+}
+
+REGISTER_TYPED_TEST_CASE_P(TypeParamTest, TestA, TestB);
+
+INSTANTIATE_TYPED_TEST_CASE_P(My, TypeParamTest, MyTypes);
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_main_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_main_unittest.cc
new file mode 100644
index 00000000..ecd9bb87
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_main_unittest.cc
@@ -0,0 +1,45 @@
+// Copyright 2006, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "gtest/gtest.h"
+
+// Tests that we don't have to define main() when we link to
+// gtest_main instead of gtest.
+
+namespace {
+
+TEST(GTestMainTest, ShouldSucceed) {
+}
+
+}  // namespace
+
+// We are using the main() function defined in src/gtest_main.cc, so
+// we don't define it here.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_no_test_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_no_test_unittest.cc
new file mode 100644
index 00000000..292599af
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_no_test_unittest.cc
@@ -0,0 +1,56 @@
+// Copyright 2006, 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.
+
+// Tests that a Google Test program that has no test defined can run
+// successfully.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "gtest/gtest.h"
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  // An ad-hoc assertion outside of all tests.
+  //
+  // This serves three purposes:
+  //
+  // 1. It verifies that an ad-hoc assertion can be executed even if
+  //    no test is defined.
+  // 2. It verifies that a failed ad-hoc assertion causes the test
+  //    program to fail.
+  // 3. We had a bug where the XML output won't be generated if an
+  //    assertion is executed before RUN_ALL_TESTS() is called, even
+  //    though --gtest_output=xml is specified.  This makes sure the
+  //    bug is fixed and doesn't regress.
+  EXPECT_EQ(1, 2);
+
+  // The above EXPECT_EQ() should cause RUN_ALL_TESTS() to return non-zero.
+  return RUN_ALL_TESTS() ? 0 : 1;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test.py
new file mode 100755
index 00000000..06dbee09
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test.py
@@ -0,0 +1,340 @@
+#!/usr/bin/env python
+#
+# 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.
+
+"""Tests the text output of Google C++ Testing Framework.
+
+SYNOPSIS
+       gtest_output_test.py --build_dir=BUILD/DIR --gengolden
+         # where BUILD/DIR contains the built gtest_output_test_ file.
+       gtest_output_test.py --gengolden
+       gtest_output_test.py
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import difflib
+import os
+import re
+import sys
+import gtest_test_utils
+
+
+# The flag for generating the golden file
+GENGOLDEN_FLAG = '--gengolden'
+CATCH_EXCEPTIONS_ENV_VAR_NAME = 'GTEST_CATCH_EXCEPTIONS'
+
+IS_WINDOWS = os.name == 'nt'
+
+# TODO(vladl@google.com): remove the _lin suffix.
+GOLDEN_NAME = 'gtest_output_test_golden_lin.txt'
+
+PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_output_test_')
+
+# At least one command we exercise must not have the
+# 'internal_skip_environment_and_ad_hoc_tests' argument.
+COMMAND_LIST_TESTS = ({}, [PROGRAM_PATH, '--gtest_list_tests'])
+COMMAND_WITH_COLOR = ({}, [PROGRAM_PATH, '--gtest_color=yes'])
+COMMAND_WITH_TIME = ({}, [PROGRAM_PATH,
+                          '--gtest_print_time',
+                          'internal_skip_environment_and_ad_hoc_tests',
+                          '--gtest_filter=FatalFailureTest.*:LoggingTest.*'])
+COMMAND_WITH_DISABLED = (
+    {}, [PROGRAM_PATH,
+         '--gtest_also_run_disabled_tests',
+         'internal_skip_environment_and_ad_hoc_tests',
+         '--gtest_filter=*DISABLED_*'])
+COMMAND_WITH_SHARDING = (
+    {'GTEST_SHARD_INDEX': '1', 'GTEST_TOTAL_SHARDS': '2'},
+    [PROGRAM_PATH,
+     'internal_skip_environment_and_ad_hoc_tests',
+     '--gtest_filter=PassingTest.*'])
+
+GOLDEN_PATH = os.path.join(gtest_test_utils.GetSourceDir(), GOLDEN_NAME)
+
+
+def ToUnixLineEnding(s):
+  """Changes all Windows/Mac line endings in s to UNIX line endings."""
+
+  return s.replace('\r\n', '\n').replace('\r', '\n')
+
+
+def RemoveLocations(test_output):
+  """Removes all file location info from a Google Test program's output.
+
+  Args:
+       test_output:  the output of a Google Test program.
+
+  Returns:
+       output with all file location info (in the form of
+       'DIRECTORY/FILE_NAME:LINE_NUMBER: 'or
+       'DIRECTORY\\FILE_NAME(LINE_NUMBER): ') replaced by
+       'FILE_NAME:#: '.
+  """
+
+  return re.sub(r'.*[/\\](.+)(\:\d+|\(\d+\))\: ', r'\1:#: ', test_output)
+
+
+def RemoveStackTraceDetails(output):
+  """Removes all stack traces from a Google Test program's output."""
+
+  # *? means "find the shortest string that matches".
+  return re.sub(r'Stack trace:(.|\n)*?\n\n',
+                'Stack trace: (omitted)\n\n', output)
+
+
+def RemoveStackTraces(output):
+  """Removes all traces of stack traces from a Google Test program's output."""
+
+  # *? means "find the shortest string that matches".
+  return re.sub(r'Stack trace:(.|\n)*?\n\n', '', output)
+
+
+def RemoveTime(output):
+  """Removes all time information from a Google Test program's output."""
+
+  return re.sub(r'\(\d+ ms', '(? ms', output)
+
+
+def RemoveTypeInfoDetails(test_output):
+  """Removes compiler-specific type info from Google Test program's output.
+
+  Args:
+       test_output:  the output of a Google Test program.
+
+  Returns:
+       output with type information normalized to canonical form.
+  """
+
+  # some compilers output the name of type 'unsigned int' as 'unsigned'
+  return re.sub(r'unsigned int', 'unsigned', test_output)
+
+
+def NormalizeToCurrentPlatform(test_output):
+  """Normalizes platform specific output details for easier comparison."""
+
+  if IS_WINDOWS:
+    # Removes the color information that is not present on Windows.
+    test_output = re.sub('\x1b\\[(0;3\d)?m', '', test_output)
+    # Changes failure message headers into the Windows format.
+    test_output = re.sub(r': Failure\n', r': error: ', test_output)
+    # Changes file(line_number) to file:line_number.
+    test_output = re.sub(r'((\w|\.)+)\((\d+)\):', r'\1:\3:', test_output)
+
+  return test_output
+
+
+def RemoveTestCounts(output):
+  """Removes test counts from a Google Test program's output."""
+
+  output = re.sub(r'\d+ tests?, listed below',
+                  '? tests, listed below', output)
+  output = re.sub(r'\d+ FAILED TESTS',
+                  '? FAILED TESTS', output)
+  output = re.sub(r'\d+ tests? from \d+ test cases?',
+                  '? tests from ? test cases', output)
+  output = re.sub(r'\d+ tests? from ([a-zA-Z_])',
+                  r'? tests from \1', output)
+  return re.sub(r'\d+ tests?\.', '? tests.', output)
+
+
+def RemoveMatchingTests(test_output, pattern):
+  """Removes output of specified tests from a Google Test program's output.
+
+  This function strips not only the beginning and the end of a test but also
+  all output in between.
+
+  Args:
+    test_output:       A string containing the test output.
+    pattern:           A regex string that matches names of test cases or
+                       tests to remove.
+
+  Returns:
+    Contents of test_output with tests whose names match pattern removed.
+  """
+
+  test_output = re.sub(
+      r'.*\[ RUN      \] .*%s(.|\n)*?\[(  FAILED  |       OK )\] .*%s.*\n' % (
+          pattern, pattern),
+      '',
+      test_output)
+  return re.sub(r'.*%s.*\n' % pattern, '', test_output)
+
+
+def NormalizeOutput(output):
+  """Normalizes output (the output of gtest_output_test_.exe)."""
+
+  output = ToUnixLineEnding(output)
+  output = RemoveLocations(output)
+  output = RemoveStackTraceDetails(output)
+  output = RemoveTime(output)
+  return output
+
+
+def GetShellCommandOutput(env_cmd):
+  """Runs a command in a sub-process, and returns its output in a string.
+
+  Args:
+    env_cmd: The shell command. A 2-tuple where element 0 is a dict of extra
+             environment variables to set, and element 1 is a string with
+             the command and any flags.
+
+  Returns:
+    A string with the command's combined standard and diagnostic output.
+  """
+
+  # Spawns cmd in a sub-process, and gets its standard I/O file objects.
+  # Set and save the environment properly.
+  environ = os.environ.copy()
+  environ.update(env_cmd[0])
+  p = gtest_test_utils.Subprocess(env_cmd[1], env=environ)
+
+  return p.output
+
+
+def GetCommandOutput(env_cmd):
+  """Runs a command and returns its output with all file location
+  info stripped off.
+
+  Args:
+    env_cmd:  The shell command. A 2-tuple where element 0 is a dict of extra
+              environment variables to set, and element 1 is a string with
+              the command and any flags.
+  """
+
+  # Disables exception pop-ups on Windows.
+  environ, cmdline = env_cmd
+  environ = dict(environ)  # Ensures we are modifying a copy.
+  environ[CATCH_EXCEPTIONS_ENV_VAR_NAME] = '1'
+  return NormalizeOutput(GetShellCommandOutput((environ, cmdline)))
+
+
+def GetOutputOfAllCommands():
+  """Returns concatenated output from several representative commands."""
+
+  return (GetCommandOutput(COMMAND_WITH_COLOR) +
+          GetCommandOutput(COMMAND_WITH_TIME) +
+          GetCommandOutput(COMMAND_WITH_DISABLED) +
+          GetCommandOutput(COMMAND_WITH_SHARDING))
+
+
+test_list = GetShellCommandOutput(COMMAND_LIST_TESTS)
+SUPPORTS_DEATH_TESTS = 'DeathTest' in test_list
+SUPPORTS_TYPED_TESTS = 'TypedTest' in test_list
+SUPPORTS_THREADS = 'ExpectFailureWithThreadsTest' in test_list
+SUPPORTS_STACK_TRACES = False
+
+CAN_GENERATE_GOLDEN_FILE = (SUPPORTS_DEATH_TESTS and
+                            SUPPORTS_TYPED_TESTS and
+                            SUPPORTS_THREADS and
+                            not IS_WINDOWS)
+
+class GTestOutputTest(gtest_test_utils.TestCase):
+  def RemoveUnsupportedTests(self, test_output):
+    if not SUPPORTS_DEATH_TESTS:
+      test_output = RemoveMatchingTests(test_output, 'DeathTest')
+    if not SUPPORTS_TYPED_TESTS:
+      test_output = RemoveMatchingTests(test_output, 'TypedTest')
+      test_output = RemoveMatchingTests(test_output, 'TypedDeathTest')
+      test_output = RemoveMatchingTests(test_output, 'TypeParamDeathTest')
+    if not SUPPORTS_THREADS:
+      test_output = RemoveMatchingTests(test_output,
+                                        'ExpectFailureWithThreadsTest')
+      test_output = RemoveMatchingTests(test_output,
+                                        'ScopedFakeTestPartResultReporterTest')
+      test_output = RemoveMatchingTests(test_output,
+                                        'WorksConcurrently')
+    if not SUPPORTS_STACK_TRACES:
+      test_output = RemoveStackTraces(test_output)
+
+    return test_output
+
+  def testOutput(self):
+    output = GetOutputOfAllCommands()
+
+    golden_file = open(GOLDEN_PATH, 'r')
+    # A mis-configured source control system can cause \r appear in EOL
+    # sequences when we read the golden file irrespective of an operating
+    # system used. Therefore, we need to strip those \r's from newlines
+    # unconditionally.
+    golden = ToUnixLineEnding(golden_file.read())
+    golden_file.close()
+
+    # We want the test to pass regardless of certain features being
+    # supported or not.
+
+    # We still have to remove type name specifics in all cases.
+    normalized_actual = RemoveTypeInfoDetails(output)
+    normalized_golden = RemoveTypeInfoDetails(golden)
+
+    if CAN_GENERATE_GOLDEN_FILE:
+      self.assertEqual(normalized_golden, normalized_actual,
+                       '\n'.join(difflib.unified_diff(
+                           normalized_golden.split('\n'),
+                           normalized_actual.split('\n'),
+                           'golden', 'actual')))
+    else:
+      normalized_actual = NormalizeToCurrentPlatform(
+          RemoveTestCounts(normalized_actual))
+      normalized_golden = NormalizeToCurrentPlatform(
+          RemoveTestCounts(self.RemoveUnsupportedTests(normalized_golden)))
+
+      # This code is very handy when debugging golden file differences:
+      if os.getenv('DEBUG_GTEST_OUTPUT_TEST'):
+        open(os.path.join(
+            gtest_test_utils.GetSourceDir(),
+            '_gtest_output_test_normalized_actual.txt'), 'wb').write(
+                normalized_actual)
+        open(os.path.join(
+            gtest_test_utils.GetSourceDir(),
+            '_gtest_output_test_normalized_golden.txt'), 'wb').write(
+                normalized_golden)
+
+      self.assertEqual(normalized_golden, normalized_actual)
+
+
+if __name__ == '__main__':
+  if sys.argv[1:] == [GENGOLDEN_FLAG]:
+    if CAN_GENERATE_GOLDEN_FILE:
+      output = GetOutputOfAllCommands()
+      golden_file = open(GOLDEN_PATH, 'wb')
+      golden_file.write(output)
+      golden_file.close()
+    else:
+      message = (
+          """Unable to write a golden file when compiled in an environment
+that does not support all the required features (death tests, typed tests,
+and multiple threads).  Please generate the golden file using a binary built
+with those features enabled.""")
+
+      sys.stderr.write(message)
+      sys.exit(1)
+  else:
+    gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_.cc
new file mode 100644
index 00000000..1070a9f2
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_.cc
@@ -0,0 +1,1062 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// The purpose of this file is to generate Google Test output under
+// various conditions.  The output will then be verified by
+// gtest_output_test.py to ensure that Google Test generates the
+// desired messages.  Therefore, most tests in this file are MEANT TO
+// FAIL.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+#include <stdlib.h>
+
+#if GTEST_IS_THREADSAFE
+using testing::ScopedFakeTestPartResultReporter;
+using testing::TestPartResultArray;
+
+using testing::internal::Notification;
+using testing::internal::ThreadWithParam;
+#endif
+
+namespace posix = ::testing::internal::posix;
+
+// Tests catching fatal failures.
+
+// A subroutine used by the following test.
+void TestEq1(int x) {
+  ASSERT_EQ(1, x);
+}
+
+// This function calls a test subroutine, catches the fatal failure it
+// generates, and then returns early.
+void TryTestSubroutine() {
+  // Calls a subrountine that yields a fatal failure.
+  TestEq1(2);
+
+  // Catches the fatal failure and aborts the test.
+  //
+  // The testing::Test:: prefix is necessary when calling
+  // HasFatalFailure() outside of a TEST, TEST_F, or test fixture.
+  if (testing::Test::HasFatalFailure()) return;
+
+  // If we get here, something is wrong.
+  FAIL() << "This should never be reached.";
+}
+
+TEST(PassingTest, PassingTest1) {
+}
+
+TEST(PassingTest, PassingTest2) {
+}
+
+// Tests that parameters of failing parameterized tests are printed in the
+// failing test summary.
+class FailingParamTest : public testing::TestWithParam<int> {};
+
+TEST_P(FailingParamTest, Fails) {
+  EXPECT_EQ(1, GetParam());
+}
+
+// This generates a test which will fail. Google Test is expected to print
+// its parameter when it outputs the list of all failed tests.
+INSTANTIATE_TEST_CASE_P(PrintingFailingParams,
+                        FailingParamTest,
+                        testing::Values(2));
+
+static const char kGoldenString[] = "\"Line\0 1\"\nLine 2";
+
+TEST(NonfatalFailureTest, EscapesStringOperands) {
+  std::string actual = "actual \"string\"";
+  EXPECT_EQ(kGoldenString, actual);
+
+  const char* golden = kGoldenString;
+  EXPECT_EQ(golden, actual);
+}
+
+TEST(NonfatalFailureTest, DiffForLongStrings) {
+  std::string golden_str(kGoldenString, sizeof(kGoldenString) - 1);
+  EXPECT_EQ(golden_str, "Line 2");
+}
+
+// Tests catching a fatal failure in a subroutine.
+TEST(FatalFailureTest, FatalFailureInSubroutine) {
+  printf("(expecting a failure that x should be 1)\n");
+
+  TryTestSubroutine();
+}
+
+// Tests catching a fatal failure in a nested subroutine.
+TEST(FatalFailureTest, FatalFailureInNestedSubroutine) {
+  printf("(expecting a failure that x should be 1)\n");
+
+  // Calls a subrountine that yields a fatal failure.
+  TryTestSubroutine();
+
+  // Catches the fatal failure and aborts the test.
+  //
+  // When calling HasFatalFailure() inside a TEST, TEST_F, or test
+  // fixture, the testing::Test:: prefix is not needed.
+  if (HasFatalFailure()) return;
+
+  // If we get here, something is wrong.
+  FAIL() << "This should never be reached.";
+}
+
+// Tests HasFatalFailure() after a failed EXPECT check.
+TEST(FatalFailureTest, NonfatalFailureInSubroutine) {
+  printf("(expecting a failure on false)\n");
+  EXPECT_TRUE(false);  // Generates a nonfatal failure
+  ASSERT_FALSE(HasFatalFailure());  // This should succeed.
+}
+
+// Tests interleaving user logging and Google Test assertions.
+TEST(LoggingTest, InterleavingLoggingAndAssertions) {
+  static const int a[4] = {
+    3, 9, 2, 6
+  };
+
+  printf("(expecting 2 failures on (3) >= (a[i]))\n");
+  for (int i = 0; i < static_cast<int>(sizeof(a)/sizeof(*a)); i++) {
+    printf("i == %d\n", i);
+    EXPECT_GE(3, a[i]);
+  }
+}
+
+// Tests the SCOPED_TRACE macro.
+
+// A helper function for testing SCOPED_TRACE.
+void SubWithoutTrace(int n) {
+  EXPECT_EQ(1, n);
+  ASSERT_EQ(2, n);
+}
+
+// Another helper function for testing SCOPED_TRACE.
+void SubWithTrace(int n) {
+  SCOPED_TRACE(testing::Message() << "n = " << n);
+
+  SubWithoutTrace(n);
+}
+
+// Tests that SCOPED_TRACE() obeys lexical scopes.
+TEST(SCOPED_TRACETest, ObeysScopes) {
+  printf("(expected to fail)\n");
+
+  // There should be no trace before SCOPED_TRACE() is invoked.
+  ADD_FAILURE() << "This failure is expected, and shouldn't have a trace.";
+
+  {
+    SCOPED_TRACE("Expected trace");
+    // After SCOPED_TRACE(), a failure in the current scope should contain
+    // the trace.
+    ADD_FAILURE() << "This failure is expected, and should have a trace.";
+  }
+
+  // Once the control leaves the scope of the SCOPED_TRACE(), there
+  // should be no trace again.
+  ADD_FAILURE() << "This failure is expected, and shouldn't have a trace.";
+}
+
+// Tests that SCOPED_TRACE works inside a loop.
+TEST(SCOPED_TRACETest, WorksInLoop) {
+  printf("(expected to fail)\n");
+
+  for (int i = 1; i <= 2; i++) {
+    SCOPED_TRACE(testing::Message() << "i = " << i);
+
+    SubWithoutTrace(i);
+  }
+}
+
+// Tests that SCOPED_TRACE works in a subroutine.
+TEST(SCOPED_TRACETest, WorksInSubroutine) {
+  printf("(expected to fail)\n");
+
+  SubWithTrace(1);
+  SubWithTrace(2);
+}
+
+// Tests that SCOPED_TRACE can be nested.
+TEST(SCOPED_TRACETest, CanBeNested) {
+  printf("(expected to fail)\n");
+
+  SCOPED_TRACE("");  // A trace without a message.
+
+  SubWithTrace(2);
+}
+
+// Tests that multiple SCOPED_TRACEs can be used in the same scope.
+TEST(SCOPED_TRACETest, CanBeRepeated) {
+  printf("(expected to fail)\n");
+
+  SCOPED_TRACE("A");
+  ADD_FAILURE()
+      << "This failure is expected, and should contain trace point A.";
+
+  SCOPED_TRACE("B");
+  ADD_FAILURE()
+      << "This failure is expected, and should contain trace point A and B.";
+
+  {
+    SCOPED_TRACE("C");
+    ADD_FAILURE() << "This failure is expected, and should "
+                  << "contain trace point A, B, and C.";
+  }
+
+  SCOPED_TRACE("D");
+  ADD_FAILURE() << "This failure is expected, and should "
+                << "contain trace point A, B, and D.";
+}
+
+#if GTEST_IS_THREADSAFE
+// Tests that SCOPED_TRACE()s can be used concurrently from multiple
+// threads.  Namely, an assertion should be affected by
+// SCOPED_TRACE()s in its own thread only.
+
+// Here's the sequence of actions that happen in the test:
+//
+//   Thread A (main)                | Thread B (spawned)
+//   ===============================|================================
+//   spawns thread B                |
+//   -------------------------------+--------------------------------
+//   waits for n1                   | SCOPED_TRACE("Trace B");
+//                                  | generates failure #1
+//                                  | notifies n1
+//   -------------------------------+--------------------------------
+//   SCOPED_TRACE("Trace A");       | waits for n2
+//   generates failure #2           |
+//   notifies n2                    |
+//   -------------------------------|--------------------------------
+//   waits for n3                   | generates failure #3
+//                                  | trace B dies
+//                                  | generates failure #4
+//                                  | notifies n3
+//   -------------------------------|--------------------------------
+//   generates failure #5           | finishes
+//   trace A dies                   |
+//   generates failure #6           |
+//   -------------------------------|--------------------------------
+//   waits for thread B to finish   |
+
+struct CheckPoints {
+  Notification n1;
+  Notification n2;
+  Notification n3;
+};
+
+static void ThreadWithScopedTrace(CheckPoints* check_points) {
+  {
+    SCOPED_TRACE("Trace B");
+    ADD_FAILURE()
+        << "Expected failure #1 (in thread B, only trace B alive).";
+    check_points->n1.Notify();
+    check_points->n2.WaitForNotification();
+
+    ADD_FAILURE()
+        << "Expected failure #3 (in thread B, trace A & B both alive).";
+  }  // Trace B dies here.
+  ADD_FAILURE()
+      << "Expected failure #4 (in thread B, only trace A alive).";
+  check_points->n3.Notify();
+}
+
+TEST(SCOPED_TRACETest, WorksConcurrently) {
+  printf("(expecting 6 failures)\n");
+
+  CheckPoints check_points;
+  ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace,
+                                       &check_points,
+                                       NULL);
+  check_points.n1.WaitForNotification();
+
+  {
+    SCOPED_TRACE("Trace A");
+    ADD_FAILURE()
+        << "Expected failure #2 (in thread A, trace A & B both alive).";
+    check_points.n2.Notify();
+    check_points.n3.WaitForNotification();
+
+    ADD_FAILURE()
+        << "Expected failure #5 (in thread A, only trace A alive).";
+  }  // Trace A dies here.
+  ADD_FAILURE()
+      << "Expected failure #6 (in thread A, no trace alive).";
+  thread.Join();
+}
+#endif  // GTEST_IS_THREADSAFE
+
+TEST(DisabledTestsWarningTest,
+     DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning) {
+  // This test body is intentionally empty.  Its sole purpose is for
+  // verifying that the --gtest_also_run_disabled_tests flag
+  // suppresses the "YOU HAVE 12 DISABLED TESTS" warning at the end of
+  // the test output.
+}
+
+// Tests using assertions outside of TEST and TEST_F.
+//
+// This function creates two failures intentionally.
+void AdHocTest() {
+  printf("The non-test part of the code is expected to have 2 failures.\n\n");
+  EXPECT_TRUE(false);
+  EXPECT_EQ(2, 3);
+}
+
+// Runs all TESTs, all TEST_Fs, and the ad hoc test.
+int RunAllTests() {
+  AdHocTest();
+  return RUN_ALL_TESTS();
+}
+
+// Tests non-fatal failures in the fixture constructor.
+class NonFatalFailureInFixtureConstructorTest : public testing::Test {
+ protected:
+  NonFatalFailureInFixtureConstructorTest() {
+    printf("(expecting 5 failures)\n");
+    ADD_FAILURE() << "Expected failure #1, in the test fixture c'tor.";
+  }
+
+  ~NonFatalFailureInFixtureConstructorTest() {
+    ADD_FAILURE() << "Expected failure #5, in the test fixture d'tor.";
+  }
+
+  virtual void SetUp() {
+    ADD_FAILURE() << "Expected failure #2, in SetUp().";
+  }
+
+  virtual void TearDown() {
+    ADD_FAILURE() << "Expected failure #4, in TearDown.";
+  }
+};
+
+TEST_F(NonFatalFailureInFixtureConstructorTest, FailureInConstructor) {
+  ADD_FAILURE() << "Expected failure #3, in the test body.";
+}
+
+// Tests fatal failures in the fixture constructor.
+class FatalFailureInFixtureConstructorTest : public testing::Test {
+ protected:
+  FatalFailureInFixtureConstructorTest() {
+    printf("(expecting 2 failures)\n");
+    Init();
+  }
+
+  ~FatalFailureInFixtureConstructorTest() {
+    ADD_FAILURE() << "Expected failure #2, in the test fixture d'tor.";
+  }
+
+  virtual void SetUp() {
+    ADD_FAILURE() << "UNEXPECTED failure in SetUp().  "
+                  << "We should never get here, as the test fixture c'tor "
+                  << "had a fatal failure.";
+  }
+
+  virtual void TearDown() {
+    ADD_FAILURE() << "UNEXPECTED failure in TearDown().  "
+                  << "We should never get here, as the test fixture c'tor "
+                  << "had a fatal failure.";
+  }
+
+ private:
+  void Init() {
+    FAIL() << "Expected failure #1, in the test fixture c'tor.";
+  }
+};
+
+TEST_F(FatalFailureInFixtureConstructorTest, FailureInConstructor) {
+  ADD_FAILURE() << "UNEXPECTED failure in the test body.  "
+                << "We should never get here, as the test fixture c'tor "
+                << "had a fatal failure.";
+}
+
+// Tests non-fatal failures in SetUp().
+class NonFatalFailureInSetUpTest : public testing::Test {
+ protected:
+  virtual ~NonFatalFailureInSetUpTest() {
+    Deinit();
+  }
+
+  virtual void SetUp() {
+    printf("(expecting 4 failures)\n");
+    ADD_FAILURE() << "Expected failure #1, in SetUp().";
+  }
+
+  virtual void TearDown() {
+    FAIL() << "Expected failure #3, in TearDown().";
+  }
+ private:
+  void Deinit() {
+    FAIL() << "Expected failure #4, in the test fixture d'tor.";
+  }
+};
+
+TEST_F(NonFatalFailureInSetUpTest, FailureInSetUp) {
+  FAIL() << "Expected failure #2, in the test function.";
+}
+
+// Tests fatal failures in SetUp().
+class FatalFailureInSetUpTest : public testing::Test {
+ protected:
+  virtual ~FatalFailureInSetUpTest() {
+    Deinit();
+  }
+
+  virtual void SetUp() {
+    printf("(expecting 3 failures)\n");
+    FAIL() << "Expected failure #1, in SetUp().";
+  }
+
+  virtual void TearDown() {
+    FAIL() << "Expected failure #2, in TearDown().";
+  }
+ private:
+  void Deinit() {
+    FAIL() << "Expected failure #3, in the test fixture d'tor.";
+  }
+};
+
+TEST_F(FatalFailureInSetUpTest, FailureInSetUp) {
+  FAIL() << "UNEXPECTED failure in the test function.  "
+         << "We should never get here, as SetUp() failed.";
+}
+
+TEST(AddFailureAtTest, MessageContainsSpecifiedFileAndLineNumber) {
+  ADD_FAILURE_AT("foo.cc", 42) << "Expected failure in foo.cc";
+}
+
+#if GTEST_IS_THREADSAFE
+
+// A unary function that may die.
+void DieIf(bool should_die) {
+  GTEST_CHECK_(!should_die) << " - death inside DieIf().";
+}
+
+// Tests running death tests in a multi-threaded context.
+
+// Used for coordination between the main and the spawn thread.
+struct SpawnThreadNotifications {
+  SpawnThreadNotifications() {}
+
+  Notification spawn_thread_started;
+  Notification spawn_thread_ok_to_terminate;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SpawnThreadNotifications);
+};
+
+// The function to be executed in the thread spawn by the
+// MultipleThreads test (below).
+static void ThreadRoutine(SpawnThreadNotifications* notifications) {
+  // Signals the main thread that this thread has started.
+  notifications->spawn_thread_started.Notify();
+
+  // Waits for permission to finish from the main thread.
+  notifications->spawn_thread_ok_to_terminate.WaitForNotification();
+}
+
+// This is a death-test test, but it's not named with a DeathTest
+// suffix.  It starts threads which might interfere with later
+// death tests, so it must run after all other death tests.
+class DeathTestAndMultiThreadsTest : public testing::Test {
+ protected:
+  // Starts a thread and waits for it to begin.
+  virtual void SetUp() {
+    thread_.reset(new ThreadWithParam<SpawnThreadNotifications*>(
+        &ThreadRoutine, &notifications_, NULL));
+    notifications_.spawn_thread_started.WaitForNotification();
+  }
+  // Tells the thread to finish, and reaps it.
+  // Depending on the version of the thread library in use,
+  // a manager thread might still be left running that will interfere
+  // with later death tests.  This is unfortunate, but this class
+  // cleans up after itself as best it can.
+  virtual void TearDown() {
+    notifications_.spawn_thread_ok_to_terminate.Notify();
+  }
+
+ private:
+  SpawnThreadNotifications notifications_;
+  testing::internal::scoped_ptr<ThreadWithParam<SpawnThreadNotifications*> >
+      thread_;
+};
+
+#endif  // GTEST_IS_THREADSAFE
+
+// The MixedUpTestCaseTest test case verifies that Google Test will fail a
+// test if it uses a different fixture class than what other tests in
+// the same test case use.  It deliberately contains two fixture
+// classes with the same name but defined in different namespaces.
+
+// The MixedUpTestCaseWithSameTestNameTest test case verifies that
+// when the user defines two tests with the same test case name AND
+// same test name (but in different namespaces), the second test will
+// fail.
+
+namespace foo {
+
+class MixedUpTestCaseTest : public testing::Test {
+};
+
+TEST_F(MixedUpTestCaseTest, FirstTestFromNamespaceFoo) {}
+TEST_F(MixedUpTestCaseTest, SecondTestFromNamespaceFoo) {}
+
+class MixedUpTestCaseWithSameTestNameTest : public testing::Test {
+};
+
+TEST_F(MixedUpTestCaseWithSameTestNameTest,
+       TheSecondTestWithThisNameShouldFail) {}
+
+}  // namespace foo
+
+namespace bar {
+
+class MixedUpTestCaseTest : public testing::Test {
+};
+
+// The following two tests are expected to fail.  We rely on the
+// golden file to check that Google Test generates the right error message.
+TEST_F(MixedUpTestCaseTest, ThisShouldFail) {}
+TEST_F(MixedUpTestCaseTest, ThisShouldFailToo) {}
+
+class MixedUpTestCaseWithSameTestNameTest : public testing::Test {
+};
+
+// Expected to fail.  We rely on the golden file to check that Google Test
+// generates the right error message.
+TEST_F(MixedUpTestCaseWithSameTestNameTest,
+       TheSecondTestWithThisNameShouldFail) {}
+
+}  // namespace bar
+
+// The following two test cases verify that Google Test catches the user
+// error of mixing TEST and TEST_F in the same test case.  The first
+// test case checks the scenario where TEST_F appears before TEST, and
+// the second one checks where TEST appears before TEST_F.
+
+class TEST_F_before_TEST_in_same_test_case : public testing::Test {
+};
+
+TEST_F(TEST_F_before_TEST_in_same_test_case, DefinedUsingTEST_F) {}
+
+// Expected to fail.  We rely on the golden file to check that Google Test
+// generates the right error message.
+TEST(TEST_F_before_TEST_in_same_test_case, DefinedUsingTESTAndShouldFail) {}
+
+class TEST_before_TEST_F_in_same_test_case : public testing::Test {
+};
+
+TEST(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST) {}
+
+// Expected to fail.  We rely on the golden file to check that Google Test
+// generates the right error message.
+TEST_F(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShouldFail) {
+}
+
+// Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE().
+int global_integer = 0;
+
+// Tests that EXPECT_NONFATAL_FAILURE() can reference global variables.
+TEST(ExpectNonfatalFailureTest, CanReferenceGlobalVariables) {
+  global_integer = 0;
+  EXPECT_NONFATAL_FAILURE({
+    EXPECT_EQ(1, global_integer) << "Expected non-fatal failure.";
+  }, "Expected non-fatal failure.");
+}
+
+// Tests that EXPECT_NONFATAL_FAILURE() can reference local variables
+// (static or not).
+TEST(ExpectNonfatalFailureTest, CanReferenceLocalVariables) {
+  int m = 0;
+  static int n;
+  n = 1;
+  EXPECT_NONFATAL_FAILURE({
+    EXPECT_EQ(m, n) << "Expected non-fatal failure.";
+  }, "Expected non-fatal failure.");
+}
+
+// Tests that EXPECT_NONFATAL_FAILURE() succeeds when there is exactly
+// one non-fatal failure and no fatal failure.
+TEST(ExpectNonfatalFailureTest, SucceedsWhenThereIsOneNonfatalFailure) {
+  EXPECT_NONFATAL_FAILURE({
+    ADD_FAILURE() << "Expected non-fatal failure.";
+  }, "Expected non-fatal failure.");
+}
+
+// Tests that EXPECT_NONFATAL_FAILURE() fails when there is no
+// non-fatal failure.
+TEST(ExpectNonfatalFailureTest, FailsWhenThereIsNoNonfatalFailure) {
+  printf("(expecting a failure)\n");
+  EXPECT_NONFATAL_FAILURE({
+  }, "");
+}
+
+// Tests that EXPECT_NONFATAL_FAILURE() fails when there are two
+// non-fatal failures.
+TEST(ExpectNonfatalFailureTest, FailsWhenThereAreTwoNonfatalFailures) {
+  printf("(expecting a failure)\n");
+  EXPECT_NONFATAL_FAILURE({
+    ADD_FAILURE() << "Expected non-fatal failure 1.";
+    ADD_FAILURE() << "Expected non-fatal failure 2.";
+  }, "");
+}
+
+// Tests that EXPECT_NONFATAL_FAILURE() fails when there is one fatal
+// failure.
+TEST(ExpectNonfatalFailureTest, FailsWhenThereIsOneFatalFailure) {
+  printf("(expecting a failure)\n");
+  EXPECT_NONFATAL_FAILURE({
+    FAIL() << "Expected fatal failure.";
+  }, "");
+}
+
+// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
+// tested returns.
+TEST(ExpectNonfatalFailureTest, FailsWhenStatementReturns) {
+  printf("(expecting a failure)\n");
+  EXPECT_NONFATAL_FAILURE({
+    return;
+  }, "");
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
+// tested throws.
+TEST(ExpectNonfatalFailureTest, FailsWhenStatementThrows) {
+  printf("(expecting a failure)\n");
+  try {
+    EXPECT_NONFATAL_FAILURE({
+      throw 0;
+    }, "");
+  } catch(int) {  // NOLINT
+  }
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// Tests that EXPECT_FATAL_FAILURE() can reference global variables.
+TEST(ExpectFatalFailureTest, CanReferenceGlobalVariables) {
+  global_integer = 0;
+  EXPECT_FATAL_FAILURE({
+    ASSERT_EQ(1, global_integer) << "Expected fatal failure.";
+  }, "Expected fatal failure.");
+}
+
+// Tests that EXPECT_FATAL_FAILURE() can reference local static
+// variables.
+TEST(ExpectFatalFailureTest, CanReferenceLocalStaticVariables) {
+  static int n;
+  n = 1;
+  EXPECT_FATAL_FAILURE({
+    ASSERT_EQ(0, n) << "Expected fatal failure.";
+  }, "Expected fatal failure.");
+}
+
+// Tests that EXPECT_FATAL_FAILURE() succeeds when there is exactly
+// one fatal failure and no non-fatal failure.
+TEST(ExpectFatalFailureTest, SucceedsWhenThereIsOneFatalFailure) {
+  EXPECT_FATAL_FAILURE({
+    FAIL() << "Expected fatal failure.";
+  }, "Expected fatal failure.");
+}
+
+// Tests that EXPECT_FATAL_FAILURE() fails when there is no fatal
+// failure.
+TEST(ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure) {
+  printf("(expecting a failure)\n");
+  EXPECT_FATAL_FAILURE({
+  }, "");
+}
+
+// A helper for generating a fatal failure.
+void FatalFailure() {
+  FAIL() << "Expected fatal failure.";
+}
+
+// Tests that EXPECT_FATAL_FAILURE() fails when there are two
+// fatal failures.
+TEST(ExpectFatalFailureTest, FailsWhenThereAreTwoFatalFailures) {
+  printf("(expecting a failure)\n");
+  EXPECT_FATAL_FAILURE({
+    FatalFailure();
+    FatalFailure();
+  }, "");
+}
+
+// Tests that EXPECT_FATAL_FAILURE() fails when there is one non-fatal
+// failure.
+TEST(ExpectFatalFailureTest, FailsWhenThereIsOneNonfatalFailure) {
+  printf("(expecting a failure)\n");
+  EXPECT_FATAL_FAILURE({
+    ADD_FAILURE() << "Expected non-fatal failure.";
+  }, "");
+}
+
+// Tests that EXPECT_FATAL_FAILURE() fails when the statement being
+// tested returns.
+TEST(ExpectFatalFailureTest, FailsWhenStatementReturns) {
+  printf("(expecting a failure)\n");
+  EXPECT_FATAL_FAILURE({
+    return;
+  }, "");
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Tests that EXPECT_FATAL_FAILURE() fails when the statement being
+// tested throws.
+TEST(ExpectFatalFailureTest, FailsWhenStatementThrows) {
+  printf("(expecting a failure)\n");
+  try {
+    EXPECT_FATAL_FAILURE({
+      throw 0;
+    }, "");
+  } catch(int) {  // NOLINT
+  }
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// This #ifdef block tests the output of value-parameterized tests.
+
+#if GTEST_HAS_PARAM_TEST
+
+std::string ParamNameFunc(const testing::TestParamInfo<std::string>& info) {
+  return info.param;
+}
+
+class ParamTest : public testing::TestWithParam<std::string> {
+};
+
+TEST_P(ParamTest, Success) {
+  EXPECT_EQ("a", GetParam());
+}
+
+TEST_P(ParamTest, Failure) {
+  EXPECT_EQ("b", GetParam()) << "Expected failure";
+}
+
+INSTANTIATE_TEST_CASE_P(PrintingStrings,
+                        ParamTest,
+                        testing::Values(std::string("a")),
+                        ParamNameFunc);
+
+#endif  // GTEST_HAS_PARAM_TEST
+
+// This #ifdef block tests the output of typed tests.
+#if GTEST_HAS_TYPED_TEST
+
+template <typename T>
+class TypedTest : public testing::Test {
+};
+
+TYPED_TEST_CASE(TypedTest, testing::Types<int>);
+
+TYPED_TEST(TypedTest, Success) {
+  EXPECT_EQ(0, TypeParam());
+}
+
+TYPED_TEST(TypedTest, Failure) {
+  EXPECT_EQ(1, TypeParam()) << "Expected failure";
+}
+
+#endif  // GTEST_HAS_TYPED_TEST
+
+// This #ifdef block tests the output of type-parameterized tests.
+#if GTEST_HAS_TYPED_TEST_P
+
+template <typename T>
+class TypedTestP : public testing::Test {
+};
+
+TYPED_TEST_CASE_P(TypedTestP);
+
+TYPED_TEST_P(TypedTestP, Success) {
+  EXPECT_EQ(0U, TypeParam());
+}
+
+TYPED_TEST_P(TypedTestP, Failure) {
+  EXPECT_EQ(1U, TypeParam()) << "Expected failure";
+}
+
+REGISTER_TYPED_TEST_CASE_P(TypedTestP, Success, Failure);
+
+typedef testing::Types<unsigned char, unsigned int> UnsignedTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(Unsigned, TypedTestP, UnsignedTypes);
+
+#endif  // GTEST_HAS_TYPED_TEST_P
+
+#if GTEST_HAS_DEATH_TEST
+
+// We rely on the golden file to verify that tests whose test case
+// name ends with DeathTest are run first.
+
+TEST(ADeathTest, ShouldRunFirst) {
+}
+
+# if GTEST_HAS_TYPED_TEST
+
+// We rely on the golden file to verify that typed tests whose test
+// case name ends with DeathTest are run first.
+
+template <typename T>
+class ATypedDeathTest : public testing::Test {
+};
+
+typedef testing::Types<int, double> NumericTypes;
+TYPED_TEST_CASE(ATypedDeathTest, NumericTypes);
+
+TYPED_TEST(ATypedDeathTest, ShouldRunFirst) {
+}
+
+# endif  // GTEST_HAS_TYPED_TEST
+
+# if GTEST_HAS_TYPED_TEST_P
+
+
+// We rely on the golden file to verify that type-parameterized tests
+// whose test case name ends with DeathTest are run first.
+
+template <typename T>
+class ATypeParamDeathTest : public testing::Test {
+};
+
+TYPED_TEST_CASE_P(ATypeParamDeathTest);
+
+TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) {
+}
+
+REGISTER_TYPED_TEST_CASE_P(ATypeParamDeathTest, ShouldRunFirst);
+
+INSTANTIATE_TYPED_TEST_CASE_P(My, ATypeParamDeathTest, NumericTypes);
+
+# endif  // GTEST_HAS_TYPED_TEST_P
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Tests various failure conditions of
+// EXPECT_{,NON}FATAL_FAILURE{,_ON_ALL_THREADS}.
+class ExpectFailureTest : public testing::Test {
+ public:  // Must be public and not protected due to a bug in g++ 3.4.2.
+  enum FailureMode {
+    FATAL_FAILURE,
+    NONFATAL_FAILURE
+  };
+  static void AddFailure(FailureMode failure) {
+    if (failure == FATAL_FAILURE) {
+      FAIL() << "Expected fatal failure.";
+    } else {
+      ADD_FAILURE() << "Expected non-fatal failure.";
+    }
+  }
+};
+
+TEST_F(ExpectFailureTest, ExpectFatalFailure) {
+  // Expected fatal failure, but succeeds.
+  printf("(expecting 1 failure)\n");
+  EXPECT_FATAL_FAILURE(SUCCEED(), "Expected fatal failure.");
+  // Expected fatal failure, but got a non-fatal failure.
+  printf("(expecting 1 failure)\n");
+  EXPECT_FATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Expected non-fatal "
+                       "failure.");
+  // Wrong message.
+  printf("(expecting 1 failure)\n");
+  EXPECT_FATAL_FAILURE(AddFailure(FATAL_FAILURE), "Some other fatal failure "
+                       "expected.");
+}
+
+TEST_F(ExpectFailureTest, ExpectNonFatalFailure) {
+  // Expected non-fatal failure, but succeeds.
+  printf("(expecting 1 failure)\n");
+  EXPECT_NONFATAL_FAILURE(SUCCEED(), "Expected non-fatal failure.");
+  // Expected non-fatal failure, but got a fatal failure.
+  printf("(expecting 1 failure)\n");
+  EXPECT_NONFATAL_FAILURE(AddFailure(FATAL_FAILURE), "Expected fatal failure.");
+  // Wrong message.
+  printf("(expecting 1 failure)\n");
+  EXPECT_NONFATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Some other non-fatal "
+                          "failure.");
+}
+
+#if GTEST_IS_THREADSAFE
+
+class ExpectFailureWithThreadsTest : public ExpectFailureTest {
+ protected:
+  static void AddFailureInOtherThread(FailureMode failure) {
+    ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL);
+    thread.Join();
+  }
+};
+
+TEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailure) {
+  // We only intercept the current thread.
+  printf("(expecting 2 failures)\n");
+  EXPECT_FATAL_FAILURE(AddFailureInOtherThread(FATAL_FAILURE),
+                       "Expected fatal failure.");
+}
+
+TEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailure) {
+  // We only intercept the current thread.
+  printf("(expecting 2 failures)\n");
+  EXPECT_NONFATAL_FAILURE(AddFailureInOtherThread(NONFATAL_FAILURE),
+                          "Expected non-fatal failure.");
+}
+
+typedef ExpectFailureWithThreadsTest ScopedFakeTestPartResultReporterTest;
+
+// Tests that the ScopedFakeTestPartResultReporter only catches failures from
+// the current thread if it is instantiated with INTERCEPT_ONLY_CURRENT_THREAD.
+TEST_F(ScopedFakeTestPartResultReporterTest, InterceptOnlyCurrentThread) {
+  printf("(expecting 2 failures)\n");
+  TestPartResultArray results;
+  {
+    ScopedFakeTestPartResultReporter reporter(
+        ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD,
+        &results);
+    AddFailureInOtherThread(FATAL_FAILURE);
+    AddFailureInOtherThread(NONFATAL_FAILURE);
+  }
+  // The two failures should not have been intercepted.
+  EXPECT_EQ(0, results.size()) << "This shouldn't fail.";
+}
+
+#endif  // GTEST_IS_THREADSAFE
+
+TEST_F(ExpectFailureTest, ExpectFatalFailureOnAllThreads) {
+  // Expected fatal failure, but succeeds.
+  printf("(expecting 1 failure)\n");
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected fatal failure.");
+  // Expected fatal failure, but got a non-fatal failure.
+  printf("(expecting 1 failure)\n");
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE),
+                                      "Expected non-fatal failure.");
+  // Wrong message.
+  printf("(expecting 1 failure)\n");
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),
+                                      "Some other fatal failure expected.");
+}
+
+TEST_F(ExpectFailureTest, ExpectNonFatalFailureOnAllThreads) {
+  // Expected non-fatal failure, but succeeds.
+  printf("(expecting 1 failure)\n");
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected non-fatal "
+                                         "failure.");
+  // Expected non-fatal failure, but got a fatal failure.
+  printf("(expecting 1 failure)\n");
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),
+                                         "Expected fatal failure.");
+  // Wrong message.
+  printf("(expecting 1 failure)\n");
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE),
+                                         "Some other non-fatal failure.");
+}
+
+
+// Two test environments for testing testing::AddGlobalTestEnvironment().
+
+class FooEnvironment : public testing::Environment {
+ public:
+  virtual void SetUp() {
+    printf("%s", "FooEnvironment::SetUp() called.\n");
+  }
+
+  virtual void TearDown() {
+    printf("%s", "FooEnvironment::TearDown() called.\n");
+    FAIL() << "Expected fatal failure.";
+  }
+};
+
+class BarEnvironment : public testing::Environment {
+ public:
+  virtual void SetUp() {
+    printf("%s", "BarEnvironment::SetUp() called.\n");
+  }
+
+  virtual void TearDown() {
+    printf("%s", "BarEnvironment::TearDown() called.\n");
+    ADD_FAILURE() << "Expected non-fatal failure.";
+  }
+};
+
+// The main function.
+//
+// The idea is to use Google Test to run all the tests we have defined (some
+// of them are intended to fail), and then compare the test results
+// with the "golden" file.
+int main(int argc, char **argv) {
+  testing::GTEST_FLAG(print_time) = false;
+
+  // We just run the tests, knowing some of them are intended to fail.
+  // We will use a separate Python script to compare the output of
+  // this program with the golden file.
+
+  // It's hard to test InitGoogleTest() directly, as it has many
+  // global side effects.  The following line serves as a sanity test
+  // for it.
+  testing::InitGoogleTest(&argc, argv);
+  bool internal_skip_environment_and_ad_hoc_tests =
+      std::count(argv, argv + argc,
+                 std::string("internal_skip_environment_and_ad_hoc_tests")) > 0;
+
+#if GTEST_HAS_DEATH_TEST
+  if (testing::internal::GTEST_FLAG(internal_run_death_test) != "") {
+    // Skip the usual output capturing if we're running as the child
+    // process of an threadsafe-style death test.
+# if GTEST_OS_WINDOWS
+    posix::FReopen("nul:", "w", stdout);
+# else
+    posix::FReopen("/dev/null", "w", stdout);
+# endif  // GTEST_OS_WINDOWS
+    return RUN_ALL_TESTS();
+  }
+#endif  // GTEST_HAS_DEATH_TEST
+
+  if (internal_skip_environment_and_ad_hoc_tests)
+    return RUN_ALL_TESTS();
+
+  // Registers two global test environments.
+  // The golden file verifies that they are set up in the order they
+  // are registered, and torn down in the reverse order.
+  testing::AddGlobalTestEnvironment(new FooEnvironment);
+  testing::AddGlobalTestEnvironment(new BarEnvironment);
+
+  return RunAllTests();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_golden_lin.txt b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_golden_lin.txt
new file mode 100644
index 00000000..2223d560
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_golden_lin.txt
@@ -0,0 +1,743 @@
+The non-test part of the code is expected to have 2 failures.
+
+gtest_output_test_.cc:#: Failure
+Value of: false
+  Actual: false
+Expected: true
+gtest_output_test_.cc:#: Failure
+      Expected: 2
+To be equal to: 3
+[==========] Running 66 tests from 29 test cases.
+[----------] Global test environment set-up.
+FooEnvironment::SetUp() called.
+BarEnvironment::SetUp() called.
+[----------] 1 test from ADeathTest
+[ RUN      ] ADeathTest.ShouldRunFirst
+[       OK ] ADeathTest.ShouldRunFirst
+[----------] 1 test from ATypedDeathTest/0, where TypeParam = int
+[ RUN      ] ATypedDeathTest/0.ShouldRunFirst
+[       OK ] ATypedDeathTest/0.ShouldRunFirst
+[----------] 1 test from ATypedDeathTest/1, where TypeParam = double
+[ RUN      ] ATypedDeathTest/1.ShouldRunFirst
+[       OK ] ATypedDeathTest/1.ShouldRunFirst
+[----------] 1 test from My/ATypeParamDeathTest/0, where TypeParam = int
+[ RUN      ] My/ATypeParamDeathTest/0.ShouldRunFirst
+[       OK ] My/ATypeParamDeathTest/0.ShouldRunFirst
+[----------] 1 test from My/ATypeParamDeathTest/1, where TypeParam = double
+[ RUN      ] My/ATypeParamDeathTest/1.ShouldRunFirst
+[       OK ] My/ATypeParamDeathTest/1.ShouldRunFirst
+[----------] 2 tests from PassingTest
+[ RUN      ] PassingTest.PassingTest1
+[       OK ] PassingTest.PassingTest1
+[ RUN      ] PassingTest.PassingTest2
+[       OK ] PassingTest.PassingTest2
+[----------] 2 tests from NonfatalFailureTest
+[ RUN      ] NonfatalFailureTest.EscapesStringOperands
+gtest_output_test_.cc:#: Failure
+      Expected: kGoldenString
+      Which is: "\"Line"
+To be equal to: actual
+      Which is: "actual \"string\""
+gtest_output_test_.cc:#: Failure
+      Expected: golden
+      Which is: "\"Line"
+To be equal to: actual
+      Which is: "actual \"string\""
+[  FAILED  ] NonfatalFailureTest.EscapesStringOperands
+[ RUN      ] NonfatalFailureTest.DiffForLongStrings
+gtest_output_test_.cc:#: Failure
+      Expected: golden_str
+      Which is: "\"Line\0 1\"\nLine 2"
+To be equal to: "Line 2"
+With diff:
+@@ -1,2 @@
+-\"Line\0 1\"
+ Line 2
+
+[  FAILED  ] NonfatalFailureTest.DiffForLongStrings
+[----------] 3 tests from FatalFailureTest
+[ RUN      ] FatalFailureTest.FatalFailureInSubroutine
+(expecting a failure that x should be 1)
+gtest_output_test_.cc:#: Failure
+      Expected: 1
+To be equal to: x
+      Which is: 2
+[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine
+[ RUN      ] FatalFailureTest.FatalFailureInNestedSubroutine
+(expecting a failure that x should be 1)
+gtest_output_test_.cc:#: Failure
+      Expected: 1
+To be equal to: x
+      Which is: 2
+[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine
+[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine
+(expecting a failure on false)
+gtest_output_test_.cc:#: Failure
+Value of: false
+  Actual: false
+Expected: true
+[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine
+[----------] 1 test from LoggingTest
+[ RUN      ] LoggingTest.InterleavingLoggingAndAssertions
+(expecting 2 failures on (3) >= (a[i]))
+i == 0
+i == 1
+gtest_output_test_.cc:#: Failure
+Expected: (3) >= (a[i]), actual: 3 vs 9
+i == 2
+i == 3
+gtest_output_test_.cc:#: Failure
+Expected: (3) >= (a[i]), actual: 3 vs 6
+[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions
+[----------] 6 tests from SCOPED_TRACETest
+[ RUN      ] SCOPED_TRACETest.ObeysScopes
+(expected to fail)
+gtest_output_test_.cc:#: Failure
+Failed
+This failure is expected, and shouldn't have a trace.
+gtest_output_test_.cc:#: Failure
+Failed
+This failure is expected, and should have a trace.
+Google Test trace:
+gtest_output_test_.cc:#: Expected trace
+gtest_output_test_.cc:#: Failure
+Failed
+This failure is expected, and shouldn't have a trace.
+[  FAILED  ] SCOPED_TRACETest.ObeysScopes
+[ RUN      ] SCOPED_TRACETest.WorksInLoop
+(expected to fail)
+gtest_output_test_.cc:#: Failure
+      Expected: 2
+To be equal to: n
+      Which is: 1
+Google Test trace:
+gtest_output_test_.cc:#: i = 1
+gtest_output_test_.cc:#: Failure
+      Expected: 1
+To be equal to: n
+      Which is: 2
+Google Test trace:
+gtest_output_test_.cc:#: i = 2
+[  FAILED  ] SCOPED_TRACETest.WorksInLoop
+[ RUN      ] SCOPED_TRACETest.WorksInSubroutine
+(expected to fail)
+gtest_output_test_.cc:#: Failure
+      Expected: 2
+To be equal to: n
+      Which is: 1
+Google Test trace:
+gtest_output_test_.cc:#: n = 1
+gtest_output_test_.cc:#: Failure
+      Expected: 1
+To be equal to: n
+      Which is: 2
+Google Test trace:
+gtest_output_test_.cc:#: n = 2
+[  FAILED  ] SCOPED_TRACETest.WorksInSubroutine
+[ RUN      ] SCOPED_TRACETest.CanBeNested
+(expected to fail)
+gtest_output_test_.cc:#: Failure
+      Expected: 1
+To be equal to: n
+      Which is: 2
+Google Test trace:
+gtest_output_test_.cc:#: n = 2
+gtest_output_test_.cc:#: 
+[  FAILED  ] SCOPED_TRACETest.CanBeNested
+[ RUN      ] SCOPED_TRACETest.CanBeRepeated
+(expected to fail)
+gtest_output_test_.cc:#: Failure
+Failed
+This failure is expected, and should contain trace point A.
+Google Test trace:
+gtest_output_test_.cc:#: A
+gtest_output_test_.cc:#: Failure
+Failed
+This failure is expected, and should contain trace point A and B.
+Google Test trace:
+gtest_output_test_.cc:#: B
+gtest_output_test_.cc:#: A
+gtest_output_test_.cc:#: Failure
+Failed
+This failure is expected, and should contain trace point A, B, and C.
+Google Test trace:
+gtest_output_test_.cc:#: C
+gtest_output_test_.cc:#: B
+gtest_output_test_.cc:#: A
+gtest_output_test_.cc:#: Failure
+Failed
+This failure is expected, and should contain trace point A, B, and D.
+Google Test trace:
+gtest_output_test_.cc:#: D
+gtest_output_test_.cc:#: B
+gtest_output_test_.cc:#: A
+[  FAILED  ] SCOPED_TRACETest.CanBeRepeated
+[ RUN      ] SCOPED_TRACETest.WorksConcurrently
+(expecting 6 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #1 (in thread B, only trace B alive).
+Google Test trace:
+gtest_output_test_.cc:#: Trace B
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #2 (in thread A, trace A & B both alive).
+Google Test trace:
+gtest_output_test_.cc:#: Trace A
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #3 (in thread B, trace A & B both alive).
+Google Test trace:
+gtest_output_test_.cc:#: Trace B
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #4 (in thread B, only trace A alive).
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #5 (in thread A, only trace A alive).
+Google Test trace:
+gtest_output_test_.cc:#: Trace A
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #6 (in thread A, no trace alive).
+[  FAILED  ] SCOPED_TRACETest.WorksConcurrently
+[----------] 1 test from NonFatalFailureInFixtureConstructorTest
+[ RUN      ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor
+(expecting 5 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #1, in the test fixture c'tor.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #2, in SetUp().
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #3, in the test body.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #4, in TearDown.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #5, in the test fixture d'tor.
+[  FAILED  ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor
+[----------] 1 test from FatalFailureInFixtureConstructorTest
+[ RUN      ] FatalFailureInFixtureConstructorTest.FailureInConstructor
+(expecting 2 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #1, in the test fixture c'tor.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #2, in the test fixture d'tor.
+[  FAILED  ] FatalFailureInFixtureConstructorTest.FailureInConstructor
+[----------] 1 test from NonFatalFailureInSetUpTest
+[ RUN      ] NonFatalFailureInSetUpTest.FailureInSetUp
+(expecting 4 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #1, in SetUp().
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #2, in the test function.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #3, in TearDown().
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #4, in the test fixture d'tor.
+[  FAILED  ] NonFatalFailureInSetUpTest.FailureInSetUp
+[----------] 1 test from FatalFailureInSetUpTest
+[ RUN      ] FatalFailureInSetUpTest.FailureInSetUp
+(expecting 3 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #1, in SetUp().
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #2, in TearDown().
+gtest_output_test_.cc:#: Failure
+Failed
+Expected failure #3, in the test fixture d'tor.
+[  FAILED  ] FatalFailureInSetUpTest.FailureInSetUp
+[----------] 1 test from AddFailureAtTest
+[ RUN      ] AddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
+foo.cc:42: Failure
+Failed
+Expected failure in foo.cc
+[  FAILED  ] AddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
+[----------] 4 tests from MixedUpTestCaseTest
+[ RUN      ] MixedUpTestCaseTest.FirstTestFromNamespaceFoo
+[       OK ] MixedUpTestCaseTest.FirstTestFromNamespaceFoo
+[ RUN      ] MixedUpTestCaseTest.SecondTestFromNamespaceFoo
+[       OK ] MixedUpTestCaseTest.SecondTestFromNamespaceFoo
+[ RUN      ] MixedUpTestCaseTest.ThisShouldFail
+gtest.cc:#: Failure
+Failed
+All tests in the same test case must use the same test fixture
+class.  However, in test case MixedUpTestCaseTest,
+you defined test FirstTestFromNamespaceFoo and test ThisShouldFail
+using two different test fixture classes.  This can happen if
+the two classes are from different namespaces or translation
+units and have the same name.  You should probably rename one
+of the classes to put the tests into different test cases.
+[  FAILED  ] MixedUpTestCaseTest.ThisShouldFail
+[ RUN      ] MixedUpTestCaseTest.ThisShouldFailToo
+gtest.cc:#: Failure
+Failed
+All tests in the same test case must use the same test fixture
+class.  However, in test case MixedUpTestCaseTest,
+you defined test FirstTestFromNamespaceFoo and test ThisShouldFailToo
+using two different test fixture classes.  This can happen if
+the two classes are from different namespaces or translation
+units and have the same name.  You should probably rename one
+of the classes to put the tests into different test cases.
+[  FAILED  ] MixedUpTestCaseTest.ThisShouldFailToo
+[----------] 2 tests from MixedUpTestCaseWithSameTestNameTest
+[ RUN      ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
+[       OK ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
+[ RUN      ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
+gtest.cc:#: Failure
+Failed
+All tests in the same test case must use the same test fixture
+class.  However, in test case MixedUpTestCaseWithSameTestNameTest,
+you defined test TheSecondTestWithThisNameShouldFail and test TheSecondTestWithThisNameShouldFail
+using two different test fixture classes.  This can happen if
+the two classes are from different namespaces or translation
+units and have the same name.  You should probably rename one
+of the classes to put the tests into different test cases.
+[  FAILED  ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
+[----------] 2 tests from TEST_F_before_TEST_in_same_test_case
+[ RUN      ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F
+[       OK ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F
+[ RUN      ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
+gtest.cc:#: Failure
+Failed
+All tests in the same test case must use the same test fixture
+class, so mixing TEST_F and TEST in the same test case is
+illegal.  In test case TEST_F_before_TEST_in_same_test_case,
+test DefinedUsingTEST_F is defined using TEST_F but
+test DefinedUsingTESTAndShouldFail is defined using TEST.  You probably
+want to change the TEST to TEST_F or move it to another test
+case.
+[  FAILED  ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
+[----------] 2 tests from TEST_before_TEST_F_in_same_test_case
+[ RUN      ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST
+[       OK ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST
+[ RUN      ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
+gtest.cc:#: Failure
+Failed
+All tests in the same test case must use the same test fixture
+class, so mixing TEST_F and TEST in the same test case is
+illegal.  In test case TEST_before_TEST_F_in_same_test_case,
+test DefinedUsingTEST_FAndShouldFail is defined using TEST_F but
+test DefinedUsingTEST is defined using TEST.  You probably
+want to change the TEST to TEST_F or move it to another test
+case.
+[  FAILED  ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
+[----------] 8 tests from ExpectNonfatalFailureTest
+[ RUN      ] ExpectNonfatalFailureTest.CanReferenceGlobalVariables
+[       OK ] ExpectNonfatalFailureTest.CanReferenceGlobalVariables
+[ RUN      ] ExpectNonfatalFailureTest.CanReferenceLocalVariables
+[       OK ] ExpectNonfatalFailureTest.CanReferenceLocalVariables
+[ RUN      ] ExpectNonfatalFailureTest.SucceedsWhenThereIsOneNonfatalFailure
+[       OK ] ExpectNonfatalFailureTest.SucceedsWhenThereIsOneNonfatalFailure
+[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
+(expecting a failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
+[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
+(expecting a failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual: 2 failures
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure 1.
+
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure 2.
+
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
+[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
+(expecting a failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
+[ RUN      ] ExpectNonfatalFailureTest.FailsWhenStatementReturns
+(expecting a failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementReturns
+[ RUN      ] ExpectNonfatalFailureTest.FailsWhenStatementThrows
+(expecting a failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementThrows
+[----------] 8 tests from ExpectFatalFailureTest
+[ RUN      ] ExpectFatalFailureTest.CanReferenceGlobalVariables
+[       OK ] ExpectFatalFailureTest.CanReferenceGlobalVariables
+[ RUN      ] ExpectFatalFailureTest.CanReferenceLocalStaticVariables
+[       OK ] ExpectFatalFailureTest.CanReferenceLocalStaticVariables
+[ RUN      ] ExpectFatalFailureTest.SucceedsWhenThereIsOneFatalFailure
+[       OK ] ExpectFatalFailureTest.SucceedsWhenThereIsOneFatalFailure
+[ RUN      ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
+(expecting a failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
+[ RUN      ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
+(expecting a failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual: 2 failures
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
+[ RUN      ] ExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
+(expecting a failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure.
+
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
+[ RUN      ] ExpectFatalFailureTest.FailsWhenStatementReturns
+(expecting a failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementReturns
+[ RUN      ] ExpectFatalFailureTest.FailsWhenStatementThrows
+(expecting a failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementThrows
+[----------] 2 tests from TypedTest/0, where TypeParam = int
+[ RUN      ] TypedTest/0.Success
+[       OK ] TypedTest/0.Success
+[ RUN      ] TypedTest/0.Failure
+gtest_output_test_.cc:#: Failure
+      Expected: 1
+To be equal to: TypeParam()
+      Which is: 0
+Expected failure
+[  FAILED  ] TypedTest/0.Failure, where TypeParam = int
+[----------] 2 tests from Unsigned/TypedTestP/0, where TypeParam = unsigned char
+[ RUN      ] Unsigned/TypedTestP/0.Success
+[       OK ] Unsigned/TypedTestP/0.Success
+[ RUN      ] Unsigned/TypedTestP/0.Failure
+gtest_output_test_.cc:#: Failure
+      Expected: 1U
+      Which is: 1
+To be equal to: TypeParam()
+      Which is: '\0'
+Expected failure
+[  FAILED  ] Unsigned/TypedTestP/0.Failure, where TypeParam = unsigned char
+[----------] 2 tests from Unsigned/TypedTestP/1, where TypeParam = unsigned int
+[ RUN      ] Unsigned/TypedTestP/1.Success
+[       OK ] Unsigned/TypedTestP/1.Success
+[ RUN      ] Unsigned/TypedTestP/1.Failure
+gtest_output_test_.cc:#: Failure
+      Expected: 1U
+      Which is: 1
+To be equal to: TypeParam()
+      Which is: 0
+Expected failure
+[  FAILED  ] Unsigned/TypedTestP/1.Failure, where TypeParam = unsigned int
+[----------] 4 tests from ExpectFailureTest
+[ RUN      ] ExpectFailureTest.ExpectFatalFailure
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Success:
+Succeeded
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure.
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure containing "Some other fatal failure expected."
+  Actual:
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+[  FAILED  ] ExpectFailureTest.ExpectFatalFailure
+[ RUN      ] ExpectFailureTest.ExpectNonFatalFailure
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Success:
+Succeeded
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure containing "Some other non-fatal failure."
+  Actual:
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure.
+
+[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailure
+[ RUN      ] ExpectFailureTest.ExpectFatalFailureOnAllThreads
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Success:
+Succeeded
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual:
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure.
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 fatal failure containing "Some other fatal failure expected."
+  Actual:
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+[  FAILED  ] ExpectFailureTest.ExpectFatalFailureOnAllThreads
+[ RUN      ] ExpectFailureTest.ExpectNonFatalFailureOnAllThreads
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Success:
+Succeeded
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual:
+gtest_output_test_.cc:#: Fatal failure:
+Failed
+Expected fatal failure.
+
+(expecting 1 failure)
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure containing "Some other non-fatal failure."
+  Actual:
+gtest_output_test_.cc:#: Non-fatal failure:
+Failed
+Expected non-fatal failure.
+
+[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailureOnAllThreads
+[----------] 2 tests from ExpectFailureWithThreadsTest
+[ RUN      ] ExpectFailureWithThreadsTest.ExpectFatalFailure
+(expecting 2 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected fatal failure.
+gtest.cc:#: Failure
+Expected: 1 fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectFailureWithThreadsTest.ExpectFatalFailure
+[ RUN      ] ExpectFailureWithThreadsTest.ExpectNonFatalFailure
+(expecting 2 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected non-fatal failure.
+gtest.cc:#: Failure
+Expected: 1 non-fatal failure
+  Actual: 0 failures
+[  FAILED  ] ExpectFailureWithThreadsTest.ExpectNonFatalFailure
+[----------] 1 test from ScopedFakeTestPartResultReporterTest
+[ RUN      ] ScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
+(expecting 2 failures)
+gtest_output_test_.cc:#: Failure
+Failed
+Expected fatal failure.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected non-fatal failure.
+[  FAILED  ] ScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
+[----------] 1 test from PrintingFailingParams/FailingParamTest
+[ RUN      ] PrintingFailingParams/FailingParamTest.Fails/0
+gtest_output_test_.cc:#: Failure
+      Expected: 1
+To be equal to: GetParam()
+      Which is: 2
+[  FAILED  ] PrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2
+[----------] 2 tests from PrintingStrings/ParamTest
+[ RUN      ] PrintingStrings/ParamTest.Success/a
+[       OK ] PrintingStrings/ParamTest.Success/a
+[ RUN      ] PrintingStrings/ParamTest.Failure/a
+gtest_output_test_.cc:#: Failure
+      Expected: "b"
+To be equal to: GetParam()
+      Which is: "a"
+Expected failure
+[  FAILED  ] PrintingStrings/ParamTest.Failure/a, where GetParam() = "a"
+[----------] Global test environment tear-down
+BarEnvironment::TearDown() called.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected non-fatal failure.
+FooEnvironment::TearDown() called.
+gtest_output_test_.cc:#: Failure
+Failed
+Expected fatal failure.
+[==========] 66 tests from 29 test cases ran.
+[  PASSED  ] 22 tests.
+[  FAILED  ] 44 tests, listed below:
+[  FAILED  ] NonfatalFailureTest.EscapesStringOperands
+[  FAILED  ] NonfatalFailureTest.DiffForLongStrings
+[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine
+[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine
+[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine
+[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions
+[  FAILED  ] SCOPED_TRACETest.ObeysScopes
+[  FAILED  ] SCOPED_TRACETest.WorksInLoop
+[  FAILED  ] SCOPED_TRACETest.WorksInSubroutine
+[  FAILED  ] SCOPED_TRACETest.CanBeNested
+[  FAILED  ] SCOPED_TRACETest.CanBeRepeated
+[  FAILED  ] SCOPED_TRACETest.WorksConcurrently
+[  FAILED  ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor
+[  FAILED  ] FatalFailureInFixtureConstructorTest.FailureInConstructor
+[  FAILED  ] NonFatalFailureInSetUpTest.FailureInSetUp
+[  FAILED  ] FatalFailureInSetUpTest.FailureInSetUp
+[  FAILED  ] AddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
+[  FAILED  ] MixedUpTestCaseTest.ThisShouldFail
+[  FAILED  ] MixedUpTestCaseTest.ThisShouldFailToo
+[  FAILED  ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
+[  FAILED  ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
+[  FAILED  ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementReturns
+[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementThrows
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementReturns
+[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementThrows
+[  FAILED  ] TypedTest/0.Failure, where TypeParam = int
+[  FAILED  ] Unsigned/TypedTestP/0.Failure, where TypeParam = unsigned char
+[  FAILED  ] Unsigned/TypedTestP/1.Failure, where TypeParam = unsigned int
+[  FAILED  ] ExpectFailureTest.ExpectFatalFailure
+[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailure
+[  FAILED  ] ExpectFailureTest.ExpectFatalFailureOnAllThreads
+[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailureOnAllThreads
+[  FAILED  ] ExpectFailureWithThreadsTest.ExpectFatalFailure
+[  FAILED  ] ExpectFailureWithThreadsTest.ExpectNonFatalFailure
+[  FAILED  ] ScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
+[  FAILED  ] PrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2
+[  FAILED  ] PrintingStrings/ParamTest.Failure/a, where GetParam() = "a"
+
+44 FAILED TESTS
+  YOU HAVE 1 DISABLED TEST
+
+Note: Google Test filter = FatalFailureTest.*:LoggingTest.*
+[==========] Running 4 tests from 2 test cases.
+[----------] Global test environment set-up.
+[----------] 3 tests from FatalFailureTest
+[ RUN      ] FatalFailureTest.FatalFailureInSubroutine
+(expecting a failure that x should be 1)
+gtest_output_test_.cc:#: Failure
+      Expected: 1
+To be equal to: x
+      Which is: 2
+[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine (? ms)
+[ RUN      ] FatalFailureTest.FatalFailureInNestedSubroutine
+(expecting a failure that x should be 1)
+gtest_output_test_.cc:#: Failure
+      Expected: 1
+To be equal to: x
+      Which is: 2
+[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine (? ms)
+[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine
+(expecting a failure on false)
+gtest_output_test_.cc:#: Failure
+Value of: false
+  Actual: false
+Expected: true
+[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine (? ms)
+[----------] 3 tests from FatalFailureTest (? ms total)
+
+[----------] 1 test from LoggingTest
+[ RUN      ] LoggingTest.InterleavingLoggingAndAssertions
+(expecting 2 failures on (3) >= (a[i]))
+i == 0
+i == 1
+gtest_output_test_.cc:#: Failure
+Expected: (3) >= (a[i]), actual: 3 vs 9
+i == 2
+i == 3
+gtest_output_test_.cc:#: Failure
+Expected: (3) >= (a[i]), actual: 3 vs 6
+[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions (? ms)
+[----------] 1 test from LoggingTest (? ms total)
+
+[----------] Global test environment tear-down
+[==========] 4 tests from 2 test cases ran. (? ms total)
+[  PASSED  ] 0 tests.
+[  FAILED  ] 4 tests, listed below:
+[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine
+[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine
+[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine
+[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions
+
+ 4 FAILED TESTS
+Note: Google Test filter = *DISABLED_*
+[==========] Running 1 test from 1 test case.
+[----------] Global test environment set-up.
+[----------] 1 test from DisabledTestsWarningTest
+[ RUN      ] DisabledTestsWarningTest.DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
+[       OK ] DisabledTestsWarningTest.DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
+[----------] Global test environment tear-down
+[==========] 1 test from 1 test case ran.
+[  PASSED  ] 1 test.
+Note: Google Test filter = PassingTest.*
+Note: This is test shard 2 of 2.
+[==========] Running 1 test from 1 test case.
+[----------] Global test environment set-up.
+[----------] 1 test from PassingTest
+[ RUN      ] PassingTest.PassingTest2
+[       OK ] PassingTest.PassingTest2
+[----------] Global test environment tear-down
+[==========] 1 test from 1 test case ran.
+[  PASSED  ] 1 test.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_pred_impl_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_pred_impl_unittest.cc
new file mode 100644
index 00000000..a84eff86
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_pred_impl_unittest.cc
@@ -0,0 +1,2427 @@
+// Copyright 2006, 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.
+
+// This file is AUTOMATICALLY GENERATED on 10/31/2011 by command
+// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
+
+// Regression test for gtest_pred_impl.h
+//
+// This file is generated by a script and quite long.  If you intend to
+// learn how Google Test works by reading its unit tests, read
+// gtest_unittest.cc instead.
+//
+// This is intended as a regression test for the Google Test predicate
+// assertions.  We compile it as part of the gtest_unittest target
+// only to keep the implementation tidy and compact, as it is quite
+// involved to set up the stage for testing Google Test using Google
+// Test itself.
+//
+// Currently, gtest_unittest takes ~11 seconds to run in the testing
+// daemon.  In the future, if it grows too large and needs much more
+// time to finish, we should consider separating this file into a
+// stand-alone regression test.
+
+#include <iostream>
+
+#include "gtest/gtest.h"
+#include "gtest/gtest-spi.h"
+
+// A user-defined data type.
+struct Bool {
+  explicit Bool(int val) : value(val != 0) {}
+
+  bool operator>(int n) const { return value > Bool(n).value; }
+
+  Bool operator+(const Bool& rhs) const { return Bool(value + rhs.value); }
+
+  bool operator==(const Bool& rhs) const { return value == rhs.value; }
+
+  bool value;
+};
+
+// Enables Bool to be used in assertions.
+std::ostream& operator<<(std::ostream& os, const Bool& x) {
+  return os << (x.value ? "true" : "false");
+}
+
+// Sample functions/functors for testing unary predicate assertions.
+
+// A unary predicate function.
+template <typename T1>
+bool PredFunction1(T1 v1) {
+  return v1 > 0;
+}
+
+// The following two functions are needed to circumvent a bug in
+// gcc 2.95.3, which sometimes has problem with the above template
+// function.
+bool PredFunction1Int(int v1) {
+  return v1 > 0;
+}
+bool PredFunction1Bool(Bool v1) {
+  return v1 > 0;
+}
+
+// A unary predicate functor.
+struct PredFunctor1 {
+  template <typename T1>
+  bool operator()(const T1& v1) {
+    return v1 > 0;
+  }
+};
+
+// A unary predicate-formatter function.
+template <typename T1>
+testing::AssertionResult PredFormatFunction1(const char* e1,
+                                             const T1& v1) {
+  if (PredFunction1(v1))
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure()
+      << e1
+      << " is expected to be positive, but evaluates to "
+      << v1 << ".";
+}
+
+// A unary predicate-formatter functor.
+struct PredFormatFunctor1 {
+  template <typename T1>
+  testing::AssertionResult operator()(const char* e1,
+                                      const T1& v1) const {
+    return PredFormatFunction1(e1, v1);
+  }
+};
+
+// Tests for {EXPECT|ASSERT}_PRED_FORMAT1.
+
+class Predicate1Test : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    expected_to_finish_ = true;
+    finished_ = false;
+    n1_ = 0;
+  }
+
+  virtual void TearDown() {
+    // Verifies that each of the predicate's arguments was evaluated
+    // exactly once.
+    EXPECT_EQ(1, n1_) <<
+        "The predicate assertion didn't evaluate argument 2 "
+        "exactly once.";
+
+    // Verifies that the control flow in the test function is expected.
+    if (expected_to_finish_ && !finished_) {
+      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+    } else if (!expected_to_finish_ && finished_) {
+      FAIL() << "The failed predicate assertion didn't abort the test "
+                "as expected.";
+    }
+  }
+
+  // true iff the test function is expected to run to finish.
+  static bool expected_to_finish_;
+
+  // true iff the test function did run to finish.
+  static bool finished_;
+
+  static int n1_;
+};
+
+bool Predicate1Test::expected_to_finish_;
+bool Predicate1Test::finished_;
+int Predicate1Test::n1_;
+
+typedef Predicate1Test EXPECT_PRED_FORMAT1Test;
+typedef Predicate1Test ASSERT_PRED_FORMAT1Test;
+typedef Predicate1Test EXPECT_PRED1Test;
+typedef Predicate1Test ASSERT_PRED1Test;
+
+// Tests a successful EXPECT_PRED1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED1(PredFunction1Int,
+               ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED1(PredFunction1Bool,
+               Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED1(PredFunctor1(),
+               ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED1(PredFunctor1(),
+               Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED1(PredFunction1Int,
+                 n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED1(PredFunction1Bool,
+                 Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED1(PredFunctor1(),
+                 n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED1(PredFunctor1(),
+                 Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED1(PredFunction1Int,
+               ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED1(PredFunction1Bool,
+               Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED1(PredFunctor1(),
+               ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED1(PredFunctor1(),
+               Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED1(PredFunction1Int,
+                 n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED1(PredFunction1Bool,
+                 Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED1(PredFunctor1(),
+                 n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED1(PredFunctor1(),
+                 Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT1(PredFormatFunction1,
+                      ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT1(PredFormatFunction1,
+                      Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
+                      ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
+                      Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT1(PredFormatFunction1,
+                        n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT1(PredFormatFunction1,
+                        Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
+                        n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
+                        Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT1(PredFormatFunction1,
+                      ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT1(PredFormatFunction1,
+                      Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
+                      ++n1_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
+                      Bool(++n1_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT1(PredFormatFunction1,
+                        n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT1(PredFormatFunction1,
+                        Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
+                        n1_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT1 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
+                        Bool(n1_++));
+    finished_ = true;
+  }, "");
+}
+// Sample functions/functors for testing binary predicate assertions.
+
+// A binary predicate function.
+template <typename T1, typename T2>
+bool PredFunction2(T1 v1, T2 v2) {
+  return v1 + v2 > 0;
+}
+
+// The following two functions are needed to circumvent a bug in
+// gcc 2.95.3, which sometimes has problem with the above template
+// function.
+bool PredFunction2Int(int v1, int v2) {
+  return v1 + v2 > 0;
+}
+bool PredFunction2Bool(Bool v1, Bool v2) {
+  return v1 + v2 > 0;
+}
+
+// A binary predicate functor.
+struct PredFunctor2 {
+  template <typename T1, typename T2>
+  bool operator()(const T1& v1,
+                  const T2& v2) {
+    return v1 + v2 > 0;
+  }
+};
+
+// A binary predicate-formatter function.
+template <typename T1, typename T2>
+testing::AssertionResult PredFormatFunction2(const char* e1,
+                                             const char* e2,
+                                             const T1& v1,
+                                             const T2& v2) {
+  if (PredFunction2(v1, v2))
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure()
+      << e1 << " + " << e2
+      << " is expected to be positive, but evaluates to "
+      << v1 + v2 << ".";
+}
+
+// A binary predicate-formatter functor.
+struct PredFormatFunctor2 {
+  template <typename T1, typename T2>
+  testing::AssertionResult operator()(const char* e1,
+                                      const char* e2,
+                                      const T1& v1,
+                                      const T2& v2) const {
+    return PredFormatFunction2(e1, e2, v1, v2);
+  }
+};
+
+// Tests for {EXPECT|ASSERT}_PRED_FORMAT2.
+
+class Predicate2Test : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    expected_to_finish_ = true;
+    finished_ = false;
+    n1_ = n2_ = 0;
+  }
+
+  virtual void TearDown() {
+    // Verifies that each of the predicate's arguments was evaluated
+    // exactly once.
+    EXPECT_EQ(1, n1_) <<
+        "The predicate assertion didn't evaluate argument 2 "
+        "exactly once.";
+    EXPECT_EQ(1, n2_) <<
+        "The predicate assertion didn't evaluate argument 3 "
+        "exactly once.";
+
+    // Verifies that the control flow in the test function is expected.
+    if (expected_to_finish_ && !finished_) {
+      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+    } else if (!expected_to_finish_ && finished_) {
+      FAIL() << "The failed predicate assertion didn't abort the test "
+                "as expected.";
+    }
+  }
+
+  // true iff the test function is expected to run to finish.
+  static bool expected_to_finish_;
+
+  // true iff the test function did run to finish.
+  static bool finished_;
+
+  static int n1_;
+  static int n2_;
+};
+
+bool Predicate2Test::expected_to_finish_;
+bool Predicate2Test::finished_;
+int Predicate2Test::n1_;
+int Predicate2Test::n2_;
+
+typedef Predicate2Test EXPECT_PRED_FORMAT2Test;
+typedef Predicate2Test ASSERT_PRED_FORMAT2Test;
+typedef Predicate2Test EXPECT_PRED2Test;
+typedef Predicate2Test ASSERT_PRED2Test;
+
+// Tests a successful EXPECT_PRED2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED2(PredFunction2Int,
+               ++n1_,
+               ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED2(PredFunction2Bool,
+               Bool(++n1_),
+               Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED2(PredFunctor2(),
+               ++n1_,
+               ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED2(PredFunctor2(),
+               Bool(++n1_),
+               Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED2(PredFunction2Int,
+                 n1_++,
+                 n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED2(PredFunction2Bool,
+                 Bool(n1_++),
+                 Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED2(PredFunctor2(),
+                 n1_++,
+                 n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED2(PredFunctor2(),
+                 Bool(n1_++),
+                 Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED2(PredFunction2Int,
+               ++n1_,
+               ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED2(PredFunction2Bool,
+               Bool(++n1_),
+               Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED2(PredFunctor2(),
+               ++n1_,
+               ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED2(PredFunctor2(),
+               Bool(++n1_),
+               Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED2(PredFunction2Int,
+                 n1_++,
+                 n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED2(PredFunction2Bool,
+                 Bool(n1_++),
+                 Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED2(PredFunctor2(),
+                 n1_++,
+                 n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED2(PredFunctor2(),
+                 Bool(n1_++),
+                 Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT2(PredFormatFunction2,
+                      ++n1_,
+                      ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT2(PredFormatFunction2,
+                      Bool(++n1_),
+                      Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
+                      ++n1_,
+                      ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
+                      Bool(++n1_),
+                      Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(PredFormatFunction2,
+                        n1_++,
+                        n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(PredFormatFunction2,
+                        Bool(n1_++),
+                        Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
+                        n1_++,
+                        n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
+                        Bool(n1_++),
+                        Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT2(PredFormatFunction2,
+                      ++n1_,
+                      ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT2(PredFormatFunction2,
+                      Bool(++n1_),
+                      Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
+                      ++n1_,
+                      ++n2_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
+                      Bool(++n1_),
+                      Bool(++n2_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT2(PredFormatFunction2,
+                        n1_++,
+                        n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT2(PredFormatFunction2,
+                        Bool(n1_++),
+                        Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
+                        n1_++,
+                        n2_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT2 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
+                        Bool(n1_++),
+                        Bool(n2_++));
+    finished_ = true;
+  }, "");
+}
+// Sample functions/functors for testing ternary predicate assertions.
+
+// A ternary predicate function.
+template <typename T1, typename T2, typename T3>
+bool PredFunction3(T1 v1, T2 v2, T3 v3) {
+  return v1 + v2 + v3 > 0;
+}
+
+// The following two functions are needed to circumvent a bug in
+// gcc 2.95.3, which sometimes has problem with the above template
+// function.
+bool PredFunction3Int(int v1, int v2, int v3) {
+  return v1 + v2 + v3 > 0;
+}
+bool PredFunction3Bool(Bool v1, Bool v2, Bool v3) {
+  return v1 + v2 + v3 > 0;
+}
+
+// A ternary predicate functor.
+struct PredFunctor3 {
+  template <typename T1, typename T2, typename T3>
+  bool operator()(const T1& v1,
+                  const T2& v2,
+                  const T3& v3) {
+    return v1 + v2 + v3 > 0;
+  }
+};
+
+// A ternary predicate-formatter function.
+template <typename T1, typename T2, typename T3>
+testing::AssertionResult PredFormatFunction3(const char* e1,
+                                             const char* e2,
+                                             const char* e3,
+                                             const T1& v1,
+                                             const T2& v2,
+                                             const T3& v3) {
+  if (PredFunction3(v1, v2, v3))
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure()
+      << e1 << " + " << e2 << " + " << e3
+      << " is expected to be positive, but evaluates to "
+      << v1 + v2 + v3 << ".";
+}
+
+// A ternary predicate-formatter functor.
+struct PredFormatFunctor3 {
+  template <typename T1, typename T2, typename T3>
+  testing::AssertionResult operator()(const char* e1,
+                                      const char* e2,
+                                      const char* e3,
+                                      const T1& v1,
+                                      const T2& v2,
+                                      const T3& v3) const {
+    return PredFormatFunction3(e1, e2, e3, v1, v2, v3);
+  }
+};
+
+// Tests for {EXPECT|ASSERT}_PRED_FORMAT3.
+
+class Predicate3Test : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    expected_to_finish_ = true;
+    finished_ = false;
+    n1_ = n2_ = n3_ = 0;
+  }
+
+  virtual void TearDown() {
+    // Verifies that each of the predicate's arguments was evaluated
+    // exactly once.
+    EXPECT_EQ(1, n1_) <<
+        "The predicate assertion didn't evaluate argument 2 "
+        "exactly once.";
+    EXPECT_EQ(1, n2_) <<
+        "The predicate assertion didn't evaluate argument 3 "
+        "exactly once.";
+    EXPECT_EQ(1, n3_) <<
+        "The predicate assertion didn't evaluate argument 4 "
+        "exactly once.";
+
+    // Verifies that the control flow in the test function is expected.
+    if (expected_to_finish_ && !finished_) {
+      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+    } else if (!expected_to_finish_ && finished_) {
+      FAIL() << "The failed predicate assertion didn't abort the test "
+                "as expected.";
+    }
+  }
+
+  // true iff the test function is expected to run to finish.
+  static bool expected_to_finish_;
+
+  // true iff the test function did run to finish.
+  static bool finished_;
+
+  static int n1_;
+  static int n2_;
+  static int n3_;
+};
+
+bool Predicate3Test::expected_to_finish_;
+bool Predicate3Test::finished_;
+int Predicate3Test::n1_;
+int Predicate3Test::n2_;
+int Predicate3Test::n3_;
+
+typedef Predicate3Test EXPECT_PRED_FORMAT3Test;
+typedef Predicate3Test ASSERT_PRED_FORMAT3Test;
+typedef Predicate3Test EXPECT_PRED3Test;
+typedef Predicate3Test ASSERT_PRED3Test;
+
+// Tests a successful EXPECT_PRED3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED3(PredFunction3Int,
+               ++n1_,
+               ++n2_,
+               ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED3(PredFunction3Bool,
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED3(PredFunctor3(),
+               ++n1_,
+               ++n2_,
+               ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED3(PredFunctor3(),
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED3(PredFunction3Int,
+                 n1_++,
+                 n2_++,
+                 n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED3(PredFunction3Bool,
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED3(PredFunctor3(),
+                 n1_++,
+                 n2_++,
+                 n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED3(PredFunctor3(),
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED3(PredFunction3Int,
+               ++n1_,
+               ++n2_,
+               ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED3(PredFunction3Bool,
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED3(PredFunctor3(),
+               ++n1_,
+               ++n2_,
+               ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED3(PredFunctor3(),
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED3(PredFunction3Int,
+                 n1_++,
+                 n2_++,
+                 n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED3(PredFunction3Bool,
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED3(PredFunctor3(),
+                 n1_++,
+                 n2_++,
+                 n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED3(PredFunctor3(),
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT3(PredFormatFunction3,
+                      ++n1_,
+                      ++n2_,
+                      ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT3(PredFormatFunction3,
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
+                      ++n1_,
+                      ++n2_,
+                      ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT3(PredFormatFunction3,
+                        n1_++,
+                        n2_++,
+                        n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT3(PredFormatFunction3,
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
+                        n1_++,
+                        n2_++,
+                        n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT3(PredFormatFunction3,
+                      ++n1_,
+                      ++n2_,
+                      ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT3(PredFormatFunction3,
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
+                      ++n1_,
+                      ++n2_,
+                      ++n3_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT3(PredFormatFunction3,
+                        n1_++,
+                        n2_++,
+                        n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT3(PredFormatFunction3,
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
+                        n1_++,
+                        n2_++,
+                        n3_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT3 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++));
+    finished_ = true;
+  }, "");
+}
+// Sample functions/functors for testing 4-ary predicate assertions.
+
+// A 4-ary predicate function.
+template <typename T1, typename T2, typename T3, typename T4>
+bool PredFunction4(T1 v1, T2 v2, T3 v3, T4 v4) {
+  return v1 + v2 + v3 + v4 > 0;
+}
+
+// The following two functions are needed to circumvent a bug in
+// gcc 2.95.3, which sometimes has problem with the above template
+// function.
+bool PredFunction4Int(int v1, int v2, int v3, int v4) {
+  return v1 + v2 + v3 + v4 > 0;
+}
+bool PredFunction4Bool(Bool v1, Bool v2, Bool v3, Bool v4) {
+  return v1 + v2 + v3 + v4 > 0;
+}
+
+// A 4-ary predicate functor.
+struct PredFunctor4 {
+  template <typename T1, typename T2, typename T3, typename T4>
+  bool operator()(const T1& v1,
+                  const T2& v2,
+                  const T3& v3,
+                  const T4& v4) {
+    return v1 + v2 + v3 + v4 > 0;
+  }
+};
+
+// A 4-ary predicate-formatter function.
+template <typename T1, typename T2, typename T3, typename T4>
+testing::AssertionResult PredFormatFunction4(const char* e1,
+                                             const char* e2,
+                                             const char* e3,
+                                             const char* e4,
+                                             const T1& v1,
+                                             const T2& v2,
+                                             const T3& v3,
+                                             const T4& v4) {
+  if (PredFunction4(v1, v2, v3, v4))
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure()
+      << e1 << " + " << e2 << " + " << e3 << " + " << e4
+      << " is expected to be positive, but evaluates to "
+      << v1 + v2 + v3 + v4 << ".";
+}
+
+// A 4-ary predicate-formatter functor.
+struct PredFormatFunctor4 {
+  template <typename T1, typename T2, typename T3, typename T4>
+  testing::AssertionResult operator()(const char* e1,
+                                      const char* e2,
+                                      const char* e3,
+                                      const char* e4,
+                                      const T1& v1,
+                                      const T2& v2,
+                                      const T3& v3,
+                                      const T4& v4) const {
+    return PredFormatFunction4(e1, e2, e3, e4, v1, v2, v3, v4);
+  }
+};
+
+// Tests for {EXPECT|ASSERT}_PRED_FORMAT4.
+
+class Predicate4Test : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    expected_to_finish_ = true;
+    finished_ = false;
+    n1_ = n2_ = n3_ = n4_ = 0;
+  }
+
+  virtual void TearDown() {
+    // Verifies that each of the predicate's arguments was evaluated
+    // exactly once.
+    EXPECT_EQ(1, n1_) <<
+        "The predicate assertion didn't evaluate argument 2 "
+        "exactly once.";
+    EXPECT_EQ(1, n2_) <<
+        "The predicate assertion didn't evaluate argument 3 "
+        "exactly once.";
+    EXPECT_EQ(1, n3_) <<
+        "The predicate assertion didn't evaluate argument 4 "
+        "exactly once.";
+    EXPECT_EQ(1, n4_) <<
+        "The predicate assertion didn't evaluate argument 5 "
+        "exactly once.";
+
+    // Verifies that the control flow in the test function is expected.
+    if (expected_to_finish_ && !finished_) {
+      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+    } else if (!expected_to_finish_ && finished_) {
+      FAIL() << "The failed predicate assertion didn't abort the test "
+                "as expected.";
+    }
+  }
+
+  // true iff the test function is expected to run to finish.
+  static bool expected_to_finish_;
+
+  // true iff the test function did run to finish.
+  static bool finished_;
+
+  static int n1_;
+  static int n2_;
+  static int n3_;
+  static int n4_;
+};
+
+bool Predicate4Test::expected_to_finish_;
+bool Predicate4Test::finished_;
+int Predicate4Test::n1_;
+int Predicate4Test::n2_;
+int Predicate4Test::n3_;
+int Predicate4Test::n4_;
+
+typedef Predicate4Test EXPECT_PRED_FORMAT4Test;
+typedef Predicate4Test ASSERT_PRED_FORMAT4Test;
+typedef Predicate4Test EXPECT_PRED4Test;
+typedef Predicate4Test ASSERT_PRED4Test;
+
+// Tests a successful EXPECT_PRED4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED4(PredFunction4Int,
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED4(PredFunction4Bool,
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED4(PredFunctor4(),
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED4(PredFunctor4(),
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED4(PredFunction4Int,
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED4(PredFunction4Bool,
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED4(PredFunctor4(),
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED4(PredFunctor4(),
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED4(PredFunction4Int,
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED4(PredFunction4Bool,
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED4(PredFunctor4(),
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED4(PredFunctor4(),
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED4(PredFunction4Int,
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED4(PredFunction4Bool,
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED4(PredFunctor4(),
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED4(PredFunctor4(),
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT4(PredFormatFunction4,
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT4(PredFormatFunction4,
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT4(PredFormatFunction4,
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT4(PredFormatFunction4,
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT4(PredFormatFunction4,
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT4(PredFormatFunction4,
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT4(PredFormatFunction4,
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT4(PredFormatFunction4,
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT4 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++));
+    finished_ = true;
+  }, "");
+}
+// Sample functions/functors for testing 5-ary predicate assertions.
+
+// A 5-ary predicate function.
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+bool PredFunction5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
+  return v1 + v2 + v3 + v4 + v5 > 0;
+}
+
+// The following two functions are needed to circumvent a bug in
+// gcc 2.95.3, which sometimes has problem with the above template
+// function.
+bool PredFunction5Int(int v1, int v2, int v3, int v4, int v5) {
+  return v1 + v2 + v3 + v4 + v5 > 0;
+}
+bool PredFunction5Bool(Bool v1, Bool v2, Bool v3, Bool v4, Bool v5) {
+  return v1 + v2 + v3 + v4 + v5 > 0;
+}
+
+// A 5-ary predicate functor.
+struct PredFunctor5 {
+  template <typename T1, typename T2, typename T3, typename T4, typename T5>
+  bool operator()(const T1& v1,
+                  const T2& v2,
+                  const T3& v3,
+                  const T4& v4,
+                  const T5& v5) {
+    return v1 + v2 + v3 + v4 + v5 > 0;
+  }
+};
+
+// A 5-ary predicate-formatter function.
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+testing::AssertionResult PredFormatFunction5(const char* e1,
+                                             const char* e2,
+                                             const char* e3,
+                                             const char* e4,
+                                             const char* e5,
+                                             const T1& v1,
+                                             const T2& v2,
+                                             const T3& v3,
+                                             const T4& v4,
+                                             const T5& v5) {
+  if (PredFunction5(v1, v2, v3, v4, v5))
+    return testing::AssertionSuccess();
+
+  return testing::AssertionFailure()
+      << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
+      << " is expected to be positive, but evaluates to "
+      << v1 + v2 + v3 + v4 + v5 << ".";
+}
+
+// A 5-ary predicate-formatter functor.
+struct PredFormatFunctor5 {
+  template <typename T1, typename T2, typename T3, typename T4, typename T5>
+  testing::AssertionResult operator()(const char* e1,
+                                      const char* e2,
+                                      const char* e3,
+                                      const char* e4,
+                                      const char* e5,
+                                      const T1& v1,
+                                      const T2& v2,
+                                      const T3& v3,
+                                      const T4& v4,
+                                      const T5& v5) const {
+    return PredFormatFunction5(e1, e2, e3, e4, e5, v1, v2, v3, v4, v5);
+  }
+};
+
+// Tests for {EXPECT|ASSERT}_PRED_FORMAT5.
+
+class Predicate5Test : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    expected_to_finish_ = true;
+    finished_ = false;
+    n1_ = n2_ = n3_ = n4_ = n5_ = 0;
+  }
+
+  virtual void TearDown() {
+    // Verifies that each of the predicate's arguments was evaluated
+    // exactly once.
+    EXPECT_EQ(1, n1_) <<
+        "The predicate assertion didn't evaluate argument 2 "
+        "exactly once.";
+    EXPECT_EQ(1, n2_) <<
+        "The predicate assertion didn't evaluate argument 3 "
+        "exactly once.";
+    EXPECT_EQ(1, n3_) <<
+        "The predicate assertion didn't evaluate argument 4 "
+        "exactly once.";
+    EXPECT_EQ(1, n4_) <<
+        "The predicate assertion didn't evaluate argument 5 "
+        "exactly once.";
+    EXPECT_EQ(1, n5_) <<
+        "The predicate assertion didn't evaluate argument 6 "
+        "exactly once.";
+
+    // Verifies that the control flow in the test function is expected.
+    if (expected_to_finish_ && !finished_) {
+      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+    } else if (!expected_to_finish_ && finished_) {
+      FAIL() << "The failed predicate assertion didn't abort the test "
+                "as expected.";
+    }
+  }
+
+  // true iff the test function is expected to run to finish.
+  static bool expected_to_finish_;
+
+  // true iff the test function did run to finish.
+  static bool finished_;
+
+  static int n1_;
+  static int n2_;
+  static int n3_;
+  static int n4_;
+  static int n5_;
+};
+
+bool Predicate5Test::expected_to_finish_;
+bool Predicate5Test::finished_;
+int Predicate5Test::n1_;
+int Predicate5Test::n2_;
+int Predicate5Test::n3_;
+int Predicate5Test::n4_;
+int Predicate5Test::n5_;
+
+typedef Predicate5Test EXPECT_PRED_FORMAT5Test;
+typedef Predicate5Test ASSERT_PRED_FORMAT5Test;
+typedef Predicate5Test EXPECT_PRED5Test;
+typedef Predicate5Test ASSERT_PRED5Test;
+
+// Tests a successful EXPECT_PRED5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED5(PredFunction5Int,
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_,
+               ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED5(PredFunction5Bool,
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_),
+               Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED5(PredFunctor5(),
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_,
+               ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED5(PredFunctor5(),
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_),
+               Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED5(PredFunction5Int,
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++,
+                 n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED5(PredFunction5Bool,
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++),
+                 Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED5(PredFunctor5(),
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++,
+                 n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED5(PredFunctor5(),
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++),
+                 Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED5(PredFunction5Int,
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_,
+               ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED5(PredFunction5Bool,
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_),
+               Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED5(PredFunctor5(),
+               ++n1_,
+               ++n2_,
+               ++n3_,
+               ++n4_,
+               ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED5(PredFunctor5(),
+               Bool(++n1_),
+               Bool(++n2_),
+               Bool(++n3_),
+               Bool(++n4_),
+               Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED5(PredFunction5Int,
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++,
+                 n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED5(PredFunction5Bool,
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++),
+                 Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED5(PredFunctor5(),
+                 n1_++,
+                 n2_++,
+                 n3_++,
+                 n4_++,
+                 n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED5(PredFunctor5(),
+                 Bool(n1_++),
+                 Bool(n2_++),
+                 Bool(n3_++),
+                 Bool(n4_++),
+                 Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT5(PredFormatFunction5,
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_,
+                      ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT5(PredFormatFunction5,
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_),
+                      Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
+  EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_,
+                      ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
+  EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_),
+                      Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a failed EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT5(PredFormatFunction5,
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++,
+                        n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT5(PredFormatFunction5,
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++),
+                        Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++,
+                        n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed EXPECT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++),
+                        Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a successful ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT5(PredFormatFunction5,
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_,
+                      ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT5(PredFormatFunction5,
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_),
+                      Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
+  ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
+                      ++n1_,
+                      ++n2_,
+                      ++n3_,
+                      ++n4_,
+                      ++n5_);
+  finished_ = true;
+}
+
+// Tests a successful ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
+  ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
+                      Bool(++n1_),
+                      Bool(++n2_),
+                      Bool(++n3_),
+                      Bool(++n4_),
+                      Bool(++n5_));
+  finished_ = true;
+}
+
+// Tests a failed ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT5(PredFormatFunction5,
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++,
+                        n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a function on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT5(PredFormatFunction5,
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++),
+                        Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a built-in type (int).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
+                        n1_++,
+                        n2_++,
+                        n3_++,
+                        n4_++,
+                        n5_++);
+    finished_ = true;
+  }, "");
+}
+
+// Tests a failed ASSERT_PRED_FORMAT5 where the
+// predicate-formatter is a functor on a user-defined type (Bool).
+TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
+  expected_to_finish_ = false;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
+                        Bool(n1_++),
+                        Bool(n2_++),
+                        Bool(n3_++),
+                        Bool(n4_++),
+                        Bool(n5_++));
+    finished_ = true;
+  }, "");
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_premature_exit_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_premature_exit_test.cc
new file mode 100644
index 00000000..3b4dc7d4
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_premature_exit_test.cc
@@ -0,0 +1,127 @@
+// Copyright 2013, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Tests that Google Test manipulates the premature-exit-detection
+// file correctly.
+
+#include <stdio.h>
+
+#include "gtest/gtest.h"
+
+using ::testing::InitGoogleTest;
+using ::testing::Test;
+using ::testing::internal::posix::GetEnv;
+using ::testing::internal::posix::Stat;
+using ::testing::internal::posix::StatStruct;
+
+namespace {
+
+class PrematureExitTest : public Test {
+ public:
+  // Returns true iff the given file exists.
+  static bool FileExists(const char* filepath) {
+    StatStruct stat;
+    return Stat(filepath, &stat) == 0;
+  }
+
+ protected:
+  PrematureExitTest() {
+    premature_exit_file_path_ = GetEnv("TEST_PREMATURE_EXIT_FILE");
+
+    // Normalize NULL to "" for ease of handling.
+    if (premature_exit_file_path_ == NULL) {
+      premature_exit_file_path_ = "";
+    }
+  }
+
+  // Returns true iff the premature-exit file exists.
+  bool PrematureExitFileExists() const {
+    return FileExists(premature_exit_file_path_);
+  }
+
+  const char* premature_exit_file_path_;
+};
+
+typedef PrematureExitTest PrematureExitDeathTest;
+
+// Tests that:
+//   - the premature-exit file exists during the execution of a
+//     death test (EXPECT_DEATH*), and
+//   - a death test doesn't interfere with the main test process's
+//     handling of the premature-exit file.
+TEST_F(PrematureExitDeathTest, FileExistsDuringExecutionOfDeathTest) {
+  if (*premature_exit_file_path_ == '\0') {
+    return;
+  }
+
+  EXPECT_DEATH_IF_SUPPORTED({
+      // If the file exists, crash the process such that the main test
+      // process will catch the (expected) crash and report a success;
+      // otherwise don't crash, which will cause the main test process
+      // to report that the death test has failed.
+      if (PrematureExitFileExists()) {
+        exit(1);
+      }
+    }, "");
+}
+
+// Tests that the premature-exit file exists during the execution of a
+// normal (non-death) test.
+TEST_F(PrematureExitTest, PrematureExitFileExistsDuringTestExecution) {
+  if (*premature_exit_file_path_ == '\0') {
+    return;
+  }
+
+  EXPECT_TRUE(PrematureExitFileExists())
+      << " file " << premature_exit_file_path_
+      << " should exist during test execution, but doesn't.";
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  InitGoogleTest(&argc, argv);
+  const int exit_code = RUN_ALL_TESTS();
+
+  // Test that the premature-exit file is deleted upon return from
+  // RUN_ALL_TESTS().
+  const char* const filepath = GetEnv("TEST_PREMATURE_EXIT_FILE");
+  if (filepath != NULL && *filepath != '\0') {
+    if (PrematureExitTest::FileExists(filepath)) {
+      printf(
+          "File %s shouldn't exist after the test program finishes, but does.",
+          filepath);
+      return 1;
+    }
+  }
+
+  return exit_code;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_prod_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_prod_test.cc
new file mode 100644
index 00000000..060abce1
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_prod_test.cc
@@ -0,0 +1,57 @@
+// Copyright 2006, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Unit test for include/gtest/gtest_prod.h.
+
+#include "gtest/gtest.h"
+#include "test/production.h"
+
+// Tests that private members can be accessed from a TEST declared as
+// a friend of the class.
+TEST(PrivateCodeTest, CanAccessPrivateMembers) {
+  PrivateCode a;
+  EXPECT_EQ(0, a.x_);
+
+  a.set_x(1);
+  EXPECT_EQ(1, a.x_);
+}
+
+typedef testing::Test PrivateCodeFixtureTest;
+
+// Tests that private members can be accessed from a TEST_F declared
+// as a friend of the class.
+TEST_F(PrivateCodeFixtureTest, CanAccessPrivateMembers) {
+  PrivateCode a;
+  EXPECT_EQ(0, a.x_);
+
+  a.set_x(2);
+  EXPECT_EQ(2, a.x_);
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_repeat_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_repeat_test.cc
new file mode 100644
index 00000000..481012ad
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_repeat_test.cc
@@ -0,0 +1,253 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Tests the --gtest_repeat=number flag.
+
+#include <stdlib.h>
+#include <iostream>
+#include "gtest/gtest.h"
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+namespace testing {
+
+GTEST_DECLARE_string_(death_test_style);
+GTEST_DECLARE_string_(filter);
+GTEST_DECLARE_int32_(repeat);
+
+}  // namespace testing
+
+using testing::GTEST_FLAG(death_test_style);
+using testing::GTEST_FLAG(filter);
+using testing::GTEST_FLAG(repeat);
+
+namespace {
+
+// We need this when we are testing Google Test itself and therefore
+// cannot use Google Test assertions.
+#define GTEST_CHECK_INT_EQ_(expected, actual) \
+  do {\
+    const int expected_val = (expected);\
+    const int actual_val = (actual);\
+    if (::testing::internal::IsTrue(expected_val != actual_val)) {\
+      ::std::cout << "Value of: " #actual "\n"\
+                  << "  Actual: " << actual_val << "\n"\
+                  << "Expected: " #expected "\n"\
+                  << "Which is: " << expected_val << "\n";\
+      ::testing::internal::posix::Abort();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+
+// Used for verifying that global environment set-up and tear-down are
+// inside the gtest_repeat loop.
+
+int g_environment_set_up_count = 0;
+int g_environment_tear_down_count = 0;
+
+class MyEnvironment : public testing::Environment {
+ public:
+  MyEnvironment() {}
+  virtual void SetUp() { g_environment_set_up_count++; }
+  virtual void TearDown() { g_environment_tear_down_count++; }
+};
+
+// A test that should fail.
+
+int g_should_fail_count = 0;
+
+TEST(FooTest, ShouldFail) {
+  g_should_fail_count++;
+  EXPECT_EQ(0, 1) << "Expected failure.";
+}
+
+// A test that should pass.
+
+int g_should_pass_count = 0;
+
+TEST(FooTest, ShouldPass) {
+  g_should_pass_count++;
+}
+
+// A test that contains a thread-safe death test and a fast death
+// test.  It should pass.
+
+int g_death_test_count = 0;
+
+TEST(BarDeathTest, ThreadSafeAndFast) {
+  g_death_test_count++;
+
+  GTEST_FLAG(death_test_style) = "threadsafe";
+  EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::Abort(), "");
+
+  GTEST_FLAG(death_test_style) = "fast";
+  EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::Abort(), "");
+}
+
+#if GTEST_HAS_PARAM_TEST
+int g_param_test_count = 0;
+
+const int kNumberOfParamTests = 10;
+
+class MyParamTest : public testing::TestWithParam<int> {};
+
+TEST_P(MyParamTest, ShouldPass) {
+  // TODO(vladl@google.com): Make parameter value checking robust
+  //                         WRT order of tests.
+  GTEST_CHECK_INT_EQ_(g_param_test_count % kNumberOfParamTests, GetParam());
+  g_param_test_count++;
+}
+INSTANTIATE_TEST_CASE_P(MyParamSequence,
+                        MyParamTest,
+                        testing::Range(0, kNumberOfParamTests));
+#endif  // GTEST_HAS_PARAM_TEST
+
+// Resets the count for each test.
+void ResetCounts() {
+  g_environment_set_up_count = 0;
+  g_environment_tear_down_count = 0;
+  g_should_fail_count = 0;
+  g_should_pass_count = 0;
+  g_death_test_count = 0;
+#if GTEST_HAS_PARAM_TEST
+  g_param_test_count = 0;
+#endif  // GTEST_HAS_PARAM_TEST
+}
+
+// Checks that the count for each test is expected.
+void CheckCounts(int expected) {
+  GTEST_CHECK_INT_EQ_(expected, g_environment_set_up_count);
+  GTEST_CHECK_INT_EQ_(expected, g_environment_tear_down_count);
+  GTEST_CHECK_INT_EQ_(expected, g_should_fail_count);
+  GTEST_CHECK_INT_EQ_(expected, g_should_pass_count);
+  GTEST_CHECK_INT_EQ_(expected, g_death_test_count);
+#if GTEST_HAS_PARAM_TEST
+  GTEST_CHECK_INT_EQ_(expected * kNumberOfParamTests, g_param_test_count);
+#endif  // GTEST_HAS_PARAM_TEST
+}
+
+// Tests the behavior of Google Test when --gtest_repeat is not specified.
+void TestRepeatUnspecified() {
+  ResetCounts();
+  GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
+  CheckCounts(1);
+}
+
+// Tests the behavior of Google Test when --gtest_repeat has the given value.
+void TestRepeat(int repeat) {
+  GTEST_FLAG(repeat) = repeat;
+
+  ResetCounts();
+  GTEST_CHECK_INT_EQ_(repeat > 0 ? 1 : 0, RUN_ALL_TESTS());
+  CheckCounts(repeat);
+}
+
+// Tests using --gtest_repeat when --gtest_filter specifies an empty
+// set of tests.
+void TestRepeatWithEmptyFilter(int repeat) {
+  GTEST_FLAG(repeat) = repeat;
+  GTEST_FLAG(filter) = "None";
+
+  ResetCounts();
+  GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
+  CheckCounts(0);
+}
+
+// Tests using --gtest_repeat when --gtest_filter specifies a set of
+// successful tests.
+void TestRepeatWithFilterForSuccessfulTests(int repeat) {
+  GTEST_FLAG(repeat) = repeat;
+  GTEST_FLAG(filter) = "*-*ShouldFail";
+
+  ResetCounts();
+  GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
+  GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);
+  GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);
+  GTEST_CHECK_INT_EQ_(0, g_should_fail_count);
+  GTEST_CHECK_INT_EQ_(repeat, g_should_pass_count);
+  GTEST_CHECK_INT_EQ_(repeat, g_death_test_count);
+#if GTEST_HAS_PARAM_TEST
+  GTEST_CHECK_INT_EQ_(repeat * kNumberOfParamTests, g_param_test_count);
+#endif  // GTEST_HAS_PARAM_TEST
+}
+
+// Tests using --gtest_repeat when --gtest_filter specifies a set of
+// failed tests.
+void TestRepeatWithFilterForFailedTests(int repeat) {
+  GTEST_FLAG(repeat) = repeat;
+  GTEST_FLAG(filter) = "*ShouldFail";
+
+  ResetCounts();
+  GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
+  GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);
+  GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);
+  GTEST_CHECK_INT_EQ_(repeat, g_should_fail_count);
+  GTEST_CHECK_INT_EQ_(0, g_should_pass_count);
+  GTEST_CHECK_INT_EQ_(0, g_death_test_count);
+#if GTEST_HAS_PARAM_TEST
+  GTEST_CHECK_INT_EQ_(0, g_param_test_count);
+#endif  // GTEST_HAS_PARAM_TEST
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+  testing::AddGlobalTestEnvironment(new MyEnvironment);
+
+  TestRepeatUnspecified();
+  TestRepeat(0);
+  TestRepeat(1);
+  TestRepeat(5);
+
+  TestRepeatWithEmptyFilter(2);
+  TestRepeatWithEmptyFilter(3);
+
+  TestRepeatWithFilterForSuccessfulTests(3);
+
+  TestRepeatWithFilterForFailedTests(4);
+
+  // It would be nice to verify that the tests indeed loop forever
+  // when GTEST_FLAG(repeat) is negative, but this test will be quite
+  // complicated to write.  Since this flag is for interactive
+  // debugging only and doesn't affect the normal test result, such a
+  // test would be an overkill.
+
+  printf("PASS\n");
+  return 0;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test.py
new file mode 100755
index 00000000..30d0303d
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test.py
@@ -0,0 +1,325 @@
+#!/usr/bin/env python
+#
+# Copyright 2009 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.
+
+"""Verifies that test shuffling works."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import gtest_test_utils
+
+# Command to run the gtest_shuffle_test_ program.
+COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_shuffle_test_')
+
+# The environment variables for test sharding.
+TOTAL_SHARDS_ENV_VAR = 'GTEST_TOTAL_SHARDS'
+SHARD_INDEX_ENV_VAR = 'GTEST_SHARD_INDEX'
+
+TEST_FILTER = 'A*.A:A*.B:C*'
+
+ALL_TESTS = []
+ACTIVE_TESTS = []
+FILTERED_TESTS = []
+SHARDED_TESTS = []
+
+SHUFFLED_ALL_TESTS = []
+SHUFFLED_ACTIVE_TESTS = []
+SHUFFLED_FILTERED_TESTS = []
+SHUFFLED_SHARDED_TESTS = []
+
+
+def AlsoRunDisabledTestsFlag():
+  return '--gtest_also_run_disabled_tests'
+
+
+def FilterFlag(test_filter):
+  return '--gtest_filter=%s' % (test_filter,)
+
+
+def RepeatFlag(n):
+  return '--gtest_repeat=%s' % (n,)
+
+
+def ShuffleFlag():
+  return '--gtest_shuffle'
+
+
+def RandomSeedFlag(n):
+  return '--gtest_random_seed=%s' % (n,)
+
+
+def RunAndReturnOutput(extra_env, args):
+  """Runs the test program and returns its output."""
+
+  environ_copy = os.environ.copy()
+  environ_copy.update(extra_env)
+
+  return gtest_test_utils.Subprocess([COMMAND] + args, env=environ_copy).output
+
+
+def GetTestsForAllIterations(extra_env, args):
+  """Runs the test program and returns a list of test lists.
+
+  Args:
+    extra_env: a map from environment variables to their values
+    args: command line flags to pass to gtest_shuffle_test_
+
+  Returns:
+    A list where the i-th element is the list of tests run in the i-th
+    test iteration.
+  """
+
+  test_iterations = []
+  for line in RunAndReturnOutput(extra_env, args).split('\n'):
+    if line.startswith('----'):
+      tests = []
+      test_iterations.append(tests)
+    elif line.strip():
+      tests.append(line.strip())  # 'TestCaseName.TestName'
+
+  return test_iterations
+
+
+def GetTestCases(tests):
+  """Returns a list of test cases in the given full test names.
+
+  Args:
+    tests: a list of full test names
+
+  Returns:
+    A list of test cases from 'tests', in their original order.
+    Consecutive duplicates are removed.
+  """
+
+  test_cases = []
+  for test in tests:
+    test_case = test.split('.')[0]
+    if not test_case in test_cases:
+      test_cases.append(test_case)
+
+  return test_cases
+
+
+def CalculateTestLists():
+  """Calculates the list of tests run under different flags."""
+
+  if not ALL_TESTS:
+    ALL_TESTS.extend(
+        GetTestsForAllIterations({}, [AlsoRunDisabledTestsFlag()])[0])
+
+  if not ACTIVE_TESTS:
+    ACTIVE_TESTS.extend(GetTestsForAllIterations({}, [])[0])
+
+  if not FILTERED_TESTS:
+    FILTERED_TESTS.extend(
+        GetTestsForAllIterations({}, [FilterFlag(TEST_FILTER)])[0])
+
+  if not SHARDED_TESTS:
+    SHARDED_TESTS.extend(
+        GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
+                                  SHARD_INDEX_ENV_VAR: '1'},
+                                 [])[0])
+
+  if not SHUFFLED_ALL_TESTS:
+    SHUFFLED_ALL_TESTS.extend(GetTestsForAllIterations(
+        {}, [AlsoRunDisabledTestsFlag(), ShuffleFlag(), RandomSeedFlag(1)])[0])
+
+  if not SHUFFLED_ACTIVE_TESTS:
+    SHUFFLED_ACTIVE_TESTS.extend(GetTestsForAllIterations(
+        {}, [ShuffleFlag(), RandomSeedFlag(1)])[0])
+
+  if not SHUFFLED_FILTERED_TESTS:
+    SHUFFLED_FILTERED_TESTS.extend(GetTestsForAllIterations(
+        {}, [ShuffleFlag(), RandomSeedFlag(1), FilterFlag(TEST_FILTER)])[0])
+
+  if not SHUFFLED_SHARDED_TESTS:
+    SHUFFLED_SHARDED_TESTS.extend(
+        GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
+                                  SHARD_INDEX_ENV_VAR: '1'},
+                                 [ShuffleFlag(), RandomSeedFlag(1)])[0])
+
+
+class GTestShuffleUnitTest(gtest_test_utils.TestCase):
+  """Tests test shuffling."""
+
+  def setUp(self):
+    CalculateTestLists()
+
+  def testShufflePreservesNumberOfTests(self):
+    self.assertEqual(len(ALL_TESTS), len(SHUFFLED_ALL_TESTS))
+    self.assertEqual(len(ACTIVE_TESTS), len(SHUFFLED_ACTIVE_TESTS))
+    self.assertEqual(len(FILTERED_TESTS), len(SHUFFLED_FILTERED_TESTS))
+    self.assertEqual(len(SHARDED_TESTS), len(SHUFFLED_SHARDED_TESTS))
+
+  def testShuffleChangesTestOrder(self):
+    self.assert_(SHUFFLED_ALL_TESTS != ALL_TESTS, SHUFFLED_ALL_TESTS)
+    self.assert_(SHUFFLED_ACTIVE_TESTS != ACTIVE_TESTS, SHUFFLED_ACTIVE_TESTS)
+    self.assert_(SHUFFLED_FILTERED_TESTS != FILTERED_TESTS,
+                 SHUFFLED_FILTERED_TESTS)
+    self.assert_(SHUFFLED_SHARDED_TESTS != SHARDED_TESTS,
+                 SHUFFLED_SHARDED_TESTS)
+
+  def testShuffleChangesTestCaseOrder(self):
+    self.assert_(GetTestCases(SHUFFLED_ALL_TESTS) != GetTestCases(ALL_TESTS),
+                 GetTestCases(SHUFFLED_ALL_TESTS))
+    self.assert_(
+        GetTestCases(SHUFFLED_ACTIVE_TESTS) != GetTestCases(ACTIVE_TESTS),
+        GetTestCases(SHUFFLED_ACTIVE_TESTS))
+    self.assert_(
+        GetTestCases(SHUFFLED_FILTERED_TESTS) != GetTestCases(FILTERED_TESTS),
+        GetTestCases(SHUFFLED_FILTERED_TESTS))
+    self.assert_(
+        GetTestCases(SHUFFLED_SHARDED_TESTS) != GetTestCases(SHARDED_TESTS),
+        GetTestCases(SHUFFLED_SHARDED_TESTS))
+
+  def testShuffleDoesNotRepeatTest(self):
+    for test in SHUFFLED_ALL_TESTS:
+      self.assertEqual(1, SHUFFLED_ALL_TESTS.count(test),
+                       '%s appears more than once' % (test,))
+    for test in SHUFFLED_ACTIVE_TESTS:
+      self.assertEqual(1, SHUFFLED_ACTIVE_TESTS.count(test),
+                       '%s appears more than once' % (test,))
+    for test in SHUFFLED_FILTERED_TESTS:
+      self.assertEqual(1, SHUFFLED_FILTERED_TESTS.count(test),
+                       '%s appears more than once' % (test,))
+    for test in SHUFFLED_SHARDED_TESTS:
+      self.assertEqual(1, SHUFFLED_SHARDED_TESTS.count(test),
+                       '%s appears more than once' % (test,))
+
+  def testShuffleDoesNotCreateNewTest(self):
+    for test in SHUFFLED_ALL_TESTS:
+      self.assert_(test in ALL_TESTS, '%s is an invalid test' % (test,))
+    for test in SHUFFLED_ACTIVE_TESTS:
+      self.assert_(test in ACTIVE_TESTS, '%s is an invalid test' % (test,))
+    for test in SHUFFLED_FILTERED_TESTS:
+      self.assert_(test in FILTERED_TESTS, '%s is an invalid test' % (test,))
+    for test in SHUFFLED_SHARDED_TESTS:
+      self.assert_(test in SHARDED_TESTS, '%s is an invalid test' % (test,))
+
+  def testShuffleIncludesAllTests(self):
+    for test in ALL_TESTS:
+      self.assert_(test in SHUFFLED_ALL_TESTS, '%s is missing' % (test,))
+    for test in ACTIVE_TESTS:
+      self.assert_(test in SHUFFLED_ACTIVE_TESTS, '%s is missing' % (test,))
+    for test in FILTERED_TESTS:
+      self.assert_(test in SHUFFLED_FILTERED_TESTS, '%s is missing' % (test,))
+    for test in SHARDED_TESTS:
+      self.assert_(test in SHUFFLED_SHARDED_TESTS, '%s is missing' % (test,))
+
+  def testShuffleLeavesDeathTestsAtFront(self):
+    non_death_test_found = False
+    for test in SHUFFLED_ACTIVE_TESTS:
+      if 'DeathTest.' in test:
+        self.assert_(not non_death_test_found,
+                     '%s appears after a non-death test' % (test,))
+      else:
+        non_death_test_found = True
+
+  def _VerifyTestCasesDoNotInterleave(self, tests):
+    test_cases = []
+    for test in tests:
+      [test_case, _] = test.split('.')
+      if test_cases and test_cases[-1] != test_case:
+        test_cases.append(test_case)
+        self.assertEqual(1, test_cases.count(test_case),
+                         'Test case %s is not grouped together in %s' %
+                         (test_case, tests))
+
+  def testShuffleDoesNotInterleaveTestCases(self):
+    self._VerifyTestCasesDoNotInterleave(SHUFFLED_ALL_TESTS)
+    self._VerifyTestCasesDoNotInterleave(SHUFFLED_ACTIVE_TESTS)
+    self._VerifyTestCasesDoNotInterleave(SHUFFLED_FILTERED_TESTS)
+    self._VerifyTestCasesDoNotInterleave(SHUFFLED_SHARDED_TESTS)
+
+  def testShuffleRestoresOrderAfterEachIteration(self):
+    # Get the test lists in all 3 iterations, using random seed 1, 2,
+    # and 3 respectively.  Google Test picks a different seed in each
+    # iteration, and this test depends on the current implementation
+    # picking successive numbers.  This dependency is not ideal, but
+    # makes the test much easier to write.
+    [tests_in_iteration1, tests_in_iteration2, tests_in_iteration3] = (
+        GetTestsForAllIterations(
+            {}, [ShuffleFlag(), RandomSeedFlag(1), RepeatFlag(3)]))
+
+    # Make sure running the tests with random seed 1 gets the same
+    # order as in iteration 1 above.
+    [tests_with_seed1] = GetTestsForAllIterations(
+        {}, [ShuffleFlag(), RandomSeedFlag(1)])
+    self.assertEqual(tests_in_iteration1, tests_with_seed1)
+
+    # Make sure running the tests with random seed 2 gets the same
+    # order as in iteration 2 above.  Success means that Google Test
+    # correctly restores the test order before re-shuffling at the
+    # beginning of iteration 2.
+    [tests_with_seed2] = GetTestsForAllIterations(
+        {}, [ShuffleFlag(), RandomSeedFlag(2)])
+    self.assertEqual(tests_in_iteration2, tests_with_seed2)
+
+    # Make sure running the tests with random seed 3 gets the same
+    # order as in iteration 3 above.  Success means that Google Test
+    # correctly restores the test order before re-shuffling at the
+    # beginning of iteration 3.
+    [tests_with_seed3] = GetTestsForAllIterations(
+        {}, [ShuffleFlag(), RandomSeedFlag(3)])
+    self.assertEqual(tests_in_iteration3, tests_with_seed3)
+
+  def testShuffleGeneratesNewOrderInEachIteration(self):
+    [tests_in_iteration1, tests_in_iteration2, tests_in_iteration3] = (
+        GetTestsForAllIterations(
+            {}, [ShuffleFlag(), RandomSeedFlag(1), RepeatFlag(3)]))
+
+    self.assert_(tests_in_iteration1 != tests_in_iteration2,
+                 tests_in_iteration1)
+    self.assert_(tests_in_iteration1 != tests_in_iteration3,
+                 tests_in_iteration1)
+    self.assert_(tests_in_iteration2 != tests_in_iteration3,
+                 tests_in_iteration2)
+
+  def testShuffleShardedTestsPreservesPartition(self):
+    # If we run M tests on N shards, the same M tests should be run in
+    # total, regardless of the random seeds used by the shards.
+    [tests1] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
+                                         SHARD_INDEX_ENV_VAR: '0'},
+                                        [ShuffleFlag(), RandomSeedFlag(1)])
+    [tests2] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
+                                         SHARD_INDEX_ENV_VAR: '1'},
+                                        [ShuffleFlag(), RandomSeedFlag(20)])
+    [tests3] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
+                                         SHARD_INDEX_ENV_VAR: '2'},
+                                        [ShuffleFlag(), RandomSeedFlag(25)])
+    sorted_sharded_tests = tests1 + tests2 + tests3
+    sorted_sharded_tests.sort()
+    sorted_active_tests = []
+    sorted_active_tests.extend(ACTIVE_TESTS)
+    sorted_active_tests.sort()
+    self.assertEqual(sorted_active_tests, sorted_sharded_tests)
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test_.cc
new file mode 100644
index 00000000..6fb441bd
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test_.cc
@@ -0,0 +1,103 @@
+// Copyright 2009, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Verifies that test shuffling works.
+
+#include "gtest/gtest.h"
+
+namespace {
+
+using ::testing::EmptyTestEventListener;
+using ::testing::InitGoogleTest;
+using ::testing::Message;
+using ::testing::Test;
+using ::testing::TestEventListeners;
+using ::testing::TestInfo;
+using ::testing::UnitTest;
+using ::testing::internal::scoped_ptr;
+
+// The test methods are empty, as the sole purpose of this program is
+// to print the test names before/after shuffling.
+
+class A : public Test {};
+TEST_F(A, A) {}
+TEST_F(A, B) {}
+
+TEST(ADeathTest, A) {}
+TEST(ADeathTest, B) {}
+TEST(ADeathTest, C) {}
+
+TEST(B, A) {}
+TEST(B, B) {}
+TEST(B, C) {}
+TEST(B, DISABLED_D) {}
+TEST(B, DISABLED_E) {}
+
+TEST(BDeathTest, A) {}
+TEST(BDeathTest, B) {}
+
+TEST(C, A) {}
+TEST(C, B) {}
+TEST(C, C) {}
+TEST(C, DISABLED_D) {}
+
+TEST(CDeathTest, A) {}
+
+TEST(DISABLED_D, A) {}
+TEST(DISABLED_D, DISABLED_B) {}
+
+// This printer prints the full test names only, starting each test
+// iteration with a "----" marker.
+class TestNamePrinter : public EmptyTestEventListener {
+ public:
+  virtual void OnTestIterationStart(const UnitTest& /* unit_test */,
+                                    int /* iteration */) {
+    printf("----\n");
+  }
+
+  virtual void OnTestStart(const TestInfo& test_info) {
+    printf("%s.%s\n", test_info.test_case_name(), test_info.name());
+  }
+};
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  InitGoogleTest(&argc, argv);
+
+  // Replaces the default printer with TestNamePrinter, which prints
+  // the test name only.
+  TestEventListeners& listeners = UnitTest::GetInstance()->listeners();
+  delete listeners.Release(listeners.default_result_printer());
+  listeners.Append(new TestNamePrinter);
+
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_sole_header_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_sole_header_test.cc
new file mode 100644
index 00000000..ccd091a2
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_sole_header_test.cc
@@ -0,0 +1,57 @@
+// 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.
+//
+// Author: mheule@google.com (Markus Heule)
+//
+// This test verifies that it's possible to use Google Test by including
+// the gtest.h header file alone.
+
+#include "gtest/gtest.h"
+
+namespace {
+
+void Subroutine() {
+  EXPECT_EQ(42, 42);
+}
+
+TEST(NoFatalFailureTest, ExpectNoFatalFailure) {
+  EXPECT_NO_FATAL_FAILURE(;);
+  EXPECT_NO_FATAL_FAILURE(SUCCEED());
+  EXPECT_NO_FATAL_FAILURE(Subroutine());
+  EXPECT_NO_FATAL_FAILURE({ SUCCEED(); });
+}
+
+TEST(NoFatalFailureTest, AssertNoFatalFailure) {
+  ASSERT_NO_FATAL_FAILURE(;);
+  ASSERT_NO_FATAL_FAILURE(SUCCEED());
+  ASSERT_NO_FATAL_FAILURE(Subroutine());
+  ASSERT_NO_FATAL_FAILURE({ SUCCEED(); });
+}
+
+}  // namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_stress_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_stress_test.cc
new file mode 100644
index 00000000..e7daa430
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_stress_test.cc
@@ -0,0 +1,256 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Tests that SCOPED_TRACE() and various Google Test assertions can be
+// used in a large number of threads concurrently.
+
+#include "gtest/gtest.h"
+
+#include <iostream>
+#include <vector>
+
+// We must define this macro in order to #include
+// gtest-internal-inl.h.  This is how Google Test prevents a user from
+// accidentally depending on its internal implementation.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+#if GTEST_IS_THREADSAFE
+
+namespace testing {
+namespace {
+
+using internal::Notification;
+using internal::TestPropertyKeyIs;
+using internal::ThreadWithParam;
+using internal::scoped_ptr;
+
+// In order to run tests in this file, for platforms where Google Test is
+// thread safe, implement ThreadWithParam. See the description of its API
+// in gtest-port.h, where it is defined for already supported platforms.
+
+// How many threads to create?
+const int kThreadCount = 50;
+
+std::string IdToKey(int id, const char* suffix) {
+  Message key;
+  key << "key_" << id << "_" << suffix;
+  return key.GetString();
+}
+
+std::string IdToString(int id) {
+  Message id_message;
+  id_message << id;
+  return id_message.GetString();
+}
+
+void ExpectKeyAndValueWereRecordedForId(
+    const std::vector<TestProperty>& properties,
+    int id, const char* suffix) {
+  TestPropertyKeyIs matches_key(IdToKey(id, suffix).c_str());
+  const std::vector<TestProperty>::const_iterator property =
+      std::find_if(properties.begin(), properties.end(), matches_key);
+  ASSERT_TRUE(property != properties.end())
+      << "expecting " << suffix << " value for id " << id;
+  EXPECT_STREQ(IdToString(id).c_str(), property->value());
+}
+
+// Calls a large number of Google Test assertions, where exactly one of them
+// will fail.
+void ManyAsserts(int id) {
+  GTEST_LOG_(INFO) << "Thread #" << id << " running...";
+
+  SCOPED_TRACE(Message() << "Thread #" << id);
+
+  for (int i = 0; i < kThreadCount; i++) {
+    SCOPED_TRACE(Message() << "Iteration #" << i);
+
+    // A bunch of assertions that should succeed.
+    EXPECT_TRUE(true);
+    ASSERT_FALSE(false) << "This shouldn't fail.";
+    EXPECT_STREQ("a", "a");
+    ASSERT_LE(5, 6);
+    EXPECT_EQ(i, i) << "This shouldn't fail.";
+
+    // RecordProperty() should interact safely with other threads as well.
+    // The shared_key forces property updates.
+    Test::RecordProperty(IdToKey(id, "string").c_str(), IdToString(id).c_str());
+    Test::RecordProperty(IdToKey(id, "int").c_str(), id);
+    Test::RecordProperty("shared_key", IdToString(id).c_str());
+
+    // This assertion should fail kThreadCount times per thread.  It
+    // is for testing whether Google Test can handle failed assertions in a
+    // multi-threaded context.
+    EXPECT_LT(i, 0) << "This should always fail.";
+  }
+}
+
+void CheckTestFailureCount(int expected_failures) {
+  const TestInfo* const info = UnitTest::GetInstance()->current_test_info();
+  const TestResult* const result = info->result();
+  GTEST_CHECK_(expected_failures == result->total_part_count())
+      << "Logged " << result->total_part_count() << " failures "
+      << " vs. " << expected_failures << " expected";
+}
+
+// Tests using SCOPED_TRACE() and Google Test assertions in many threads
+// concurrently.
+TEST(StressTest, CanUseScopedTraceAndAssertionsInManyThreads) {
+  {
+    scoped_ptr<ThreadWithParam<int> > threads[kThreadCount];
+    Notification threads_can_start;
+    for (int i = 0; i != kThreadCount; i++)
+      threads[i].reset(new ThreadWithParam<int>(&ManyAsserts,
+                                                i,
+                                                &threads_can_start));
+
+    threads_can_start.Notify();
+
+    // Blocks until all the threads are done.
+    for (int i = 0; i != kThreadCount; i++)
+      threads[i]->Join();
+  }
+
+  // Ensures that kThreadCount*kThreadCount failures have been reported.
+  const TestInfo* const info = UnitTest::GetInstance()->current_test_info();
+  const TestResult* const result = info->result();
+
+  std::vector<TestProperty> properties;
+  // We have no access to the TestResult's list of properties but we can
+  // copy them one by one.
+  for (int i = 0; i < result->test_property_count(); ++i)
+    properties.push_back(result->GetTestProperty(i));
+
+  EXPECT_EQ(kThreadCount * 2 + 1, result->test_property_count())
+      << "String and int values recorded on each thread, "
+      << "as well as one shared_key";
+  for (int i = 0; i < kThreadCount; ++i) {
+    ExpectKeyAndValueWereRecordedForId(properties, i, "string");
+    ExpectKeyAndValueWereRecordedForId(properties, i, "int");
+  }
+  CheckTestFailureCount(kThreadCount*kThreadCount);
+}
+
+void FailingThread(bool is_fatal) {
+  if (is_fatal)
+    FAIL() << "Fatal failure in some other thread. "
+           << "(This failure is expected.)";
+  else
+    ADD_FAILURE() << "Non-fatal failure in some other thread. "
+                  << "(This failure is expected.)";
+}
+
+void GenerateFatalFailureInAnotherThread(bool is_fatal) {
+  ThreadWithParam<bool> thread(&FailingThread, is_fatal, NULL);
+  thread.Join();
+}
+
+TEST(NoFatalFailureTest, ExpectNoFatalFailureIgnoresFailuresInOtherThreads) {
+  EXPECT_NO_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true));
+  // We should only have one failure (the one from
+  // GenerateFatalFailureInAnotherThread()), since the EXPECT_NO_FATAL_FAILURE
+  // should succeed.
+  CheckTestFailureCount(1);
+}
+
+void AssertNoFatalFailureIgnoresFailuresInOtherThreads() {
+  ASSERT_NO_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true));
+}
+TEST(NoFatalFailureTest, AssertNoFatalFailureIgnoresFailuresInOtherThreads) {
+  // Using a subroutine, to make sure, that the test continues.
+  AssertNoFatalFailureIgnoresFailuresInOtherThreads();
+  // We should only have one failure (the one from
+  // GenerateFatalFailureInAnotherThread()), since the EXPECT_NO_FATAL_FAILURE
+  // should succeed.
+  CheckTestFailureCount(1);
+}
+
+TEST(FatalFailureTest, ExpectFatalFailureIgnoresFailuresInOtherThreads) {
+  // This statement should fail, since the current thread doesn't generate a
+  // fatal failure, only another one does.
+  EXPECT_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true), "expected");
+  CheckTestFailureCount(2);
+}
+
+TEST(FatalFailureOnAllThreadsTest, ExpectFatalFailureOnAllThreads) {
+  // This statement should succeed, because failures in all threads are
+  // considered.
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(
+      GenerateFatalFailureInAnotherThread(true), "expected");
+  CheckTestFailureCount(0);
+  // We need to add a failure, because main() checks that there are failures.
+  // But when only this test is run, we shouldn't have any failures.
+  ADD_FAILURE() << "This is an expected non-fatal failure.";
+}
+
+TEST(NonFatalFailureTest, ExpectNonFatalFailureIgnoresFailuresInOtherThreads) {
+  // This statement should fail, since the current thread doesn't generate a
+  // fatal failure, only another one does.
+  EXPECT_NONFATAL_FAILURE(GenerateFatalFailureInAnotherThread(false),
+                          "expected");
+  CheckTestFailureCount(2);
+}
+
+TEST(NonFatalFailureOnAllThreadsTest, ExpectNonFatalFailureOnAllThreads) {
+  // This statement should succeed, because failures in all threads are
+  // considered.
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(
+      GenerateFatalFailureInAnotherThread(false), "expected");
+  CheckTestFailureCount(0);
+  // We need to add a failure, because main() checks that there are failures,
+  // But when only this test is run, we shouldn't have any failures.
+  ADD_FAILURE() << "This is an expected non-fatal failure.";
+}
+
+}  // namespace
+}  // namespace testing
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  const int result = RUN_ALL_TESTS();  // Expected to fail.
+  GTEST_CHECK_(result == 1) << "RUN_ALL_TESTS() did not fail as expected";
+
+  printf("\nPASS\n");
+  return 0;
+}
+
+#else
+TEST(StressTest,
+     DISABLED_ThreadSafetyTestsAreSkippedWhenGoogleTestIsNotThreadSafe) {
+}
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+#endif  // GTEST_IS_THREADSAFE
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_test_utils.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_test_utils.py
new file mode 100755
index 00000000..4acd36c9
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_test_utils.py
@@ -0,0 +1,320 @@
+#!/usr/bin/env python
+#
+# Copyright 2006, 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.
+
+"""Unit test utilities for Google C++ Testing Framework."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import atexit
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+_test_module = unittest
+
+# Suppresses the 'Import not at the top of the file' lint complaint.
+# pylint: disable-msg=C6204
+try:
+  import subprocess
+  _SUBPROCESS_MODULE_AVAILABLE = True
+except:
+  import popen2
+  _SUBPROCESS_MODULE_AVAILABLE = False
+# pylint: enable-msg=C6204
+
+GTEST_OUTPUT_VAR_NAME = 'GTEST_OUTPUT'
+
+IS_WINDOWS = os.name == 'nt'
+IS_CYGWIN = os.name == 'posix' and 'CYGWIN' in os.uname()[0]
+
+# The environment variable for specifying the path to the premature-exit file.
+PREMATURE_EXIT_FILE_ENV_VAR = 'TEST_PREMATURE_EXIT_FILE'
+
+environ = os.environ.copy()
+
+
+def SetEnvVar(env_var, value):
+  """Sets/unsets an environment variable to a given value."""
+
+  if value is not None:
+    environ[env_var] = value
+  elif env_var in environ:
+    del environ[env_var]
+
+
+# Here we expose a class from a particular module, depending on the
+# environment. The comment suppresses the 'Invalid variable name' lint
+# complaint.
+TestCase = _test_module.TestCase  # pylint: disable-msg=C6409
+
+# Initially maps a flag to its default value. After
+# _ParseAndStripGTestFlags() is called, maps a flag to its actual value.
+_flag_map = {'source_dir': os.path.dirname(sys.argv[0]),
+             'build_dir': os.path.dirname(sys.argv[0])}
+_gtest_flags_are_parsed = False
+
+
+def _ParseAndStripGTestFlags(argv):
+  """Parses and strips Google Test flags from argv.  This is idempotent."""
+
+  # Suppresses the lint complaint about a global variable since we need it
+  # here to maintain module-wide state.
+  global _gtest_flags_are_parsed  # pylint: disable-msg=W0603
+  if _gtest_flags_are_parsed:
+    return
+
+  _gtest_flags_are_parsed = True
+  for flag in _flag_map:
+    # The environment variable overrides the default value.
+    if flag.upper() in os.environ:
+      _flag_map[flag] = os.environ[flag.upper()]
+
+    # The command line flag overrides the environment variable.
+    i = 1  # Skips the program name.
+    while i < len(argv):
+      prefix = '--' + flag + '='
+      if argv[i].startswith(prefix):
+        _flag_map[flag] = argv[i][len(prefix):]
+        del argv[i]
+        break
+      else:
+        # We don't increment i in case we just found a --gtest_* flag
+        # and removed it from argv.
+        i += 1
+
+
+def GetFlag(flag):
+  """Returns the value of the given flag."""
+
+  # In case GetFlag() is called before Main(), we always call
+  # _ParseAndStripGTestFlags() here to make sure the --gtest_* flags
+  # are parsed.
+  _ParseAndStripGTestFlags(sys.argv)
+
+  return _flag_map[flag]
+
+
+def GetSourceDir():
+  """Returns the absolute path of the directory where the .py files are."""
+
+  return os.path.abspath(GetFlag('source_dir'))
+
+
+def GetBuildDir():
+  """Returns the absolute path of the directory where the test binaries are."""
+
+  return os.path.abspath(GetFlag('build_dir'))
+
+
+_temp_dir = None
+
+def _RemoveTempDir():
+  if _temp_dir:
+    shutil.rmtree(_temp_dir, ignore_errors=True)
+
+atexit.register(_RemoveTempDir)
+
+
+def GetTempDir():
+  """Returns a directory for temporary files."""
+
+  global _temp_dir
+  if not _temp_dir:
+    _temp_dir = tempfile.mkdtemp()
+  return _temp_dir
+
+
+def GetTestExecutablePath(executable_name, build_dir=None):
+  """Returns the absolute path of the test binary given its name.
+
+  The function will print a message and abort the program if the resulting file
+  doesn't exist.
+
+  Args:
+    executable_name: name of the test binary that the test script runs.
+    build_dir:       directory where to look for executables, by default
+                     the result of GetBuildDir().
+
+  Returns:
+    The absolute path of the test binary.
+  """
+
+  path = os.path.abspath(os.path.join(build_dir or GetBuildDir(),
+                                      executable_name))
+  if (IS_WINDOWS or IS_CYGWIN) and not path.endswith('.exe'):
+    path += '.exe'
+
+  if not os.path.exists(path):
+    message = (
+        'Unable to find the test binary "%s". Please make sure to provide\n'
+        'a path to the binary via the --build_dir flag or the BUILD_DIR\n'
+        'environment variable.' % path)
+    sys.stdout.write(message)
+    sys.exit(1)
+
+  return path
+
+
+def GetExitStatus(exit_code):
+  """Returns the argument to exit(), or -1 if exit() wasn't called.
+
+  Args:
+    exit_code: the result value of os.system(command).
+  """
+
+  if os.name == 'nt':
+    # On Windows, os.WEXITSTATUS() doesn't work and os.system() returns
+    # the argument to exit() directly.
+    return exit_code
+  else:
+    # On Unix, os.WEXITSTATUS() must be used to extract the exit status
+    # from the result of os.system().
+    if os.WIFEXITED(exit_code):
+      return os.WEXITSTATUS(exit_code)
+    else:
+      return -1
+
+
+class Subprocess:
+  def __init__(self, command, working_dir=None, capture_stderr=True, env=None):
+    """Changes into a specified directory, if provided, and executes a command.
+
+    Restores the old directory afterwards.
+
+    Args:
+      command:        The command to run, in the form of sys.argv.
+      working_dir:    The directory to change into.
+      capture_stderr: Determines whether to capture stderr in the output member
+                      or to discard it.
+      env:            Dictionary with environment to pass to the subprocess.
+
+    Returns:
+      An object that represents outcome of the executed process. It has the
+      following attributes:
+        terminated_by_signal   True iff the child process has been terminated
+                               by a signal.
+        signal                 Sygnal that terminated the child process.
+        exited                 True iff the child process exited normally.
+        exit_code              The code with which the child process exited.
+        output                 Child process's stdout and stderr output
+                               combined in a string.
+    """
+
+    # The subprocess module is the preferrable way of running programs
+    # since it is available and behaves consistently on all platforms,
+    # including Windows. But it is only available starting in python 2.4.
+    # In earlier python versions, we revert to the popen2 module, which is
+    # available in python 2.0 and later but doesn't provide required
+    # functionality (Popen4) under Windows. This allows us to support Mac
+    # OS X 10.4 Tiger, which has python 2.3 installed.
+    if _SUBPROCESS_MODULE_AVAILABLE:
+      if capture_stderr:
+        stderr = subprocess.STDOUT
+      else:
+        stderr = subprocess.PIPE
+
+      p = subprocess.Popen(command,
+                           stdout=subprocess.PIPE, stderr=stderr,
+                           cwd=working_dir, universal_newlines=True, env=env)
+      # communicate returns a tuple with the file obect for the child's
+      # output.
+      self.output = p.communicate()[0]
+      self._return_code = p.returncode
+    else:
+      old_dir = os.getcwd()
+
+      def _ReplaceEnvDict(dest, src):
+        # Changes made by os.environ.clear are not inheritable by child
+        # processes until Python 2.6. To produce inheritable changes we have
+        # to delete environment items with the del statement.
+        for key in dest.keys():
+          del dest[key]
+        dest.update(src)
+
+      # When 'env' is not None, backup the environment variables and replace
+      # them with the passed 'env'. When 'env' is None, we simply use the
+      # current 'os.environ' for compatibility with the subprocess.Popen
+      # semantics used above.
+      if env is not None:
+        old_environ = os.environ.copy()
+        _ReplaceEnvDict(os.environ, env)
+
+      try:
+        if working_dir is not None:
+          os.chdir(working_dir)
+        if capture_stderr:
+          p = popen2.Popen4(command)
+        else:
+          p = popen2.Popen3(command)
+        p.tochild.close()
+        self.output = p.fromchild.read()
+        ret_code = p.wait()
+      finally:
+        os.chdir(old_dir)
+
+        # Restore the old environment variables
+        # if they were replaced.
+        if env is not None:
+          _ReplaceEnvDict(os.environ, old_environ)
+
+      # Converts ret_code to match the semantics of
+      # subprocess.Popen.returncode.
+      if os.WIFSIGNALED(ret_code):
+        self._return_code = -os.WTERMSIG(ret_code)
+      else:  # os.WIFEXITED(ret_code) should return True here.
+        self._return_code = os.WEXITSTATUS(ret_code)
+
+    if self._return_code < 0:
+      self.terminated_by_signal = True
+      self.exited = False
+      self.signal = -self._return_code
+    else:
+      self.terminated_by_signal = False
+      self.exited = True
+      self.exit_code = self._return_code
+
+
+def Main():
+  """Runs the unit test."""
+
+  # We must call _ParseAndStripGTestFlags() before calling
+  # unittest.main().  Otherwise the latter will be confused by the
+  # --gtest_* flags.
+  _ParseAndStripGTestFlags(sys.argv)
+  # The tested binaries should not be writing XML output files unless the
+  # script explicitly instructs them to.
+  # TODO(vladl@google.com): Move this into Subprocess when we implement
+  # passing environment into it as a parameter.
+  if GTEST_OUTPUT_VAR_NAME in os.environ:
+    del os.environ[GTEST_OUTPUT_VAR_NAME]
+
+  _test_module.main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc
new file mode 100644
index 00000000..8d46c76f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc
@@ -0,0 +1,92 @@
+// Copyright 2009, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Tests Google Test's throw-on-failure mode with exceptions enabled.
+
+#include "gtest/gtest.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdexcept>
+
+// Prints the given failure message and exits the program with
+// non-zero.  We use this instead of a Google Test assertion to
+// indicate a failure, as the latter is been tested and cannot be
+// relied on.
+void Fail(const char* msg) {
+  printf("FAILURE: %s\n", msg);
+  fflush(stdout);
+  exit(1);
+}
+
+// Tests that an assertion failure throws a subclass of
+// std::runtime_error.
+void TestFailureThrowsRuntimeError() {
+  testing::GTEST_FLAG(throw_on_failure) = true;
+
+  // A successful assertion shouldn't throw.
+  try {
+    EXPECT_EQ(3, 3);
+  } catch(...) {
+    Fail("A successful assertion wrongfully threw.");
+  }
+
+  // A failed assertion should throw a subclass of std::runtime_error.
+  try {
+    EXPECT_EQ(2, 3) << "Expected failure";
+  } catch(const std::runtime_error& e) {
+    if (strstr(e.what(), "Expected failure") != NULL)
+      return;
+
+    printf("%s",
+           "A failed assertion did throw an exception of the right type, "
+           "but the message is incorrect.  Instead of containing \"Expected "
+           "failure\", it is:\n");
+    Fail(e.what());
+  } catch(...) {
+    Fail("A failed assertion threw the wrong type of exception.");
+  }
+  Fail("A failed assertion should've thrown but didn't.");
+}
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  // We want to ensure that people can use Google Test assertions in
+  // other testing frameworks, as long as they initialize Google Test
+  // properly and set the thrown-on-failure mode.  Therefore, we don't
+  // use Google Test's constructs for defining and running tests
+  // (e.g. TEST and RUN_ALL_TESTS) here.
+
+  TestFailureThrowsRuntimeError();
+  return 0;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test.py
new file mode 100755
index 00000000..3e7740ca
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test.py
@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+#
+# Copyright 2009, 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.
+
+"""Tests Google Test's throw-on-failure mode with exceptions disabled.
+
+This script invokes gtest_throw_on_failure_test_ (a program written with
+Google Test) with different environments and command line flags.
+"""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import os
+import gtest_test_utils
+
+
+# Constants.
+
+# The command line flag for enabling/disabling the throw-on-failure mode.
+THROW_ON_FAILURE = 'gtest_throw_on_failure'
+
+# Path to the gtest_throw_on_failure_test_ program, compiled with
+# exceptions disabled.
+EXE_PATH = gtest_test_utils.GetTestExecutablePath(
+    'gtest_throw_on_failure_test_')
+
+
+# Utilities.
+
+
+def SetEnvVar(env_var, value):
+  """Sets an environment variable to a given value; unsets it when the
+  given value is None.
+  """
+
+  env_var = env_var.upper()
+  if value is not None:
+    os.environ[env_var] = value
+  elif env_var in os.environ:
+    del os.environ[env_var]
+
+
+def Run(command):
+  """Runs a command; returns True/False if its exit code is/isn't 0."""
+
+  print('Running "%s". . .' % ' '.join(command))
+  p = gtest_test_utils.Subprocess(command)
+  return p.exited and p.exit_code == 0
+
+
+# The tests.  TODO(wan@google.com): refactor the class to share common
+# logic with code in gtest_break_on_failure_unittest.py.
+class ThrowOnFailureTest(gtest_test_utils.TestCase):
+  """Tests the throw-on-failure mode."""
+
+  def RunAndVerify(self, env_var_value, flag_value, should_fail):
+    """Runs gtest_throw_on_failure_test_ and verifies that it does
+    (or does not) exit with a non-zero code.
+
+    Args:
+      env_var_value:    value of the GTEST_BREAK_ON_FAILURE environment
+                        variable; None if the variable should be unset.
+      flag_value:       value of the --gtest_break_on_failure flag;
+                        None if the flag should not be present.
+      should_fail:      True iff the program is expected to fail.
+    """
+
+    SetEnvVar(THROW_ON_FAILURE, env_var_value)
+
+    if env_var_value is None:
+      env_var_value_msg = ' is not set'
+    else:
+      env_var_value_msg = '=' + env_var_value
+
+    if flag_value is None:
+      flag = ''
+    elif flag_value == '0':
+      flag = '--%s=0' % THROW_ON_FAILURE
+    else:
+      flag = '--%s' % THROW_ON_FAILURE
+
+    command = [EXE_PATH]
+    if flag:
+      command.append(flag)
+
+    if should_fail:
+      should_or_not = 'should'
+    else:
+      should_or_not = 'should not'
+
+    failed = not Run(command)
+
+    SetEnvVar(THROW_ON_FAILURE, None)
+
+    msg = ('when %s%s, an assertion failure in "%s" %s cause a non-zero '
+           'exit code.' %
+           (THROW_ON_FAILURE, env_var_value_msg, ' '.join(command),
+            should_or_not))
+    self.assert_(failed == should_fail, msg)
+
+  def testDefaultBehavior(self):
+    """Tests the behavior of the default mode."""
+
+    self.RunAndVerify(env_var_value=None, flag_value=None, should_fail=False)
+
+  def testThrowOnFailureEnvVar(self):
+    """Tests using the GTEST_THROW_ON_FAILURE environment variable."""
+
+    self.RunAndVerify(env_var_value='0',
+                      flag_value=None,
+                      should_fail=False)
+    self.RunAndVerify(env_var_value='1',
+                      flag_value=None,
+                      should_fail=True)
+
+  def testThrowOnFailureFlag(self):
+    """Tests using the --gtest_throw_on_failure flag."""
+
+    self.RunAndVerify(env_var_value=None,
+                      flag_value='0',
+                      should_fail=False)
+    self.RunAndVerify(env_var_value=None,
+                      flag_value='1',
+                      should_fail=True)
+
+  def testThrowOnFailureFlagOverridesEnvVar(self):
+    """Tests that --gtest_throw_on_failure overrides GTEST_THROW_ON_FAILURE."""
+
+    self.RunAndVerify(env_var_value='0',
+                      flag_value='0',
+                      should_fail=False)
+    self.RunAndVerify(env_var_value='0',
+                      flag_value='1',
+                      should_fail=True)
+    self.RunAndVerify(env_var_value='1',
+                      flag_value='0',
+                      should_fail=False)
+    self.RunAndVerify(env_var_value='1',
+                      flag_value='1',
+                      should_fail=True)
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test_.cc
new file mode 100644
index 00000000..2b88fe3d
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test_.cc
@@ -0,0 +1,72 @@
+// Copyright 2009, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Tests Google Test's throw-on-failure mode with exceptions disabled.
+//
+// This program must be compiled with exceptions disabled.  It will be
+// invoked by gtest_throw_on_failure_test.py, and is expected to exit
+// with non-zero in the throw-on-failure mode or 0 otherwise.
+
+#include "gtest/gtest.h"
+
+#include <stdio.h>                      // for fflush, fprintf, NULL, etc.
+#include <stdlib.h>                     // for exit
+#include <exception>                    // for set_terminate
+
+// This terminate handler aborts the program using exit() rather than abort().
+// This avoids showing pop-ups on Windows systems and core dumps on Unix-like
+// ones.
+void TerminateHandler() {
+  fprintf(stderr, "%s\n", "Unhandled C++ exception terminating the program.");
+  fflush(NULL);
+  exit(1);
+}
+
+int main(int argc, char** argv) {
+#if GTEST_HAS_EXCEPTIONS
+  std::set_terminate(&TerminateHandler);
+#endif
+  testing::InitGoogleTest(&argc, argv);
+
+  // We want to ensure that people can use Google Test assertions in
+  // other testing frameworks, as long as they initialize Google Test
+  // properly and set the throw-on-failure mode.  Therefore, we don't
+  // use Google Test's constructs for defining and running tests
+  // (e.g. TEST and RUN_ALL_TESTS) here.
+
+  // In the throw-on-failure mode with exceptions disabled, this
+  // assertion will cause the program to exit with a non-zero code.
+  EXPECT_EQ(2, 3);
+
+  // When not in the throw-on-failure mode, the control will reach
+  // here.
+  return 0;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test.py
new file mode 100755
index 00000000..43583700
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test.py
@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+#
+# 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.
+
+"""Verifies that Google Test warns the user when not initialized properly."""
+
+__author__ = 'wan@google.com (Zhanyong Wan)'
+
+import gtest_test_utils
+
+
+COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_uninitialized_test_')
+
+
+def Assert(condition):
+  if not condition:
+    raise AssertionError
+
+
+def AssertEq(expected, actual):
+  if expected != actual:
+    print('Expected: %s' % (expected,))
+    print('  Actual: %s' % (actual,))
+    raise AssertionError
+
+
+def TestExitCodeAndOutput(command):
+  """Runs the given command and verifies its exit code and output."""
+
+  # Verifies that 'command' exits with code 1.
+  p = gtest_test_utils.Subprocess(command)
+  Assert(p.exited)
+  AssertEq(1, p.exit_code)
+  Assert('InitGoogleTest' in p.output)
+
+
+class GTestUninitializedTest(gtest_test_utils.TestCase):
+  def testExitCodeAndOutput(self):
+    TestExitCodeAndOutput(COMMAND)
+
+
+if __name__ == '__main__':
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test_.cc
new file mode 100644
index 00000000..44316987
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test_.cc
@@ -0,0 +1,43 @@
+// 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+#include "gtest/gtest.h"
+
+TEST(DummyTest, Dummy) {
+  // This test doesn't verify anything.  We just need it to create a
+  // realistic stage for testing the behavior of Google Test when
+  // RUN_ALL_TESTS() is called without testing::InitGoogleTest() being
+  // called first.
+}
+
+int main() {
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_unittest.cc
new file mode 100644
index 00000000..97fcd5a8
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_unittest.cc
@@ -0,0 +1,7706 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// Tests for Google Test itself.  This verifies that the basic constructs of
+// Google Test work.
+
+#include "gtest/gtest.h"
+
+// Verifies that the command line flag variables can be accessed
+// in code once <gtest/gtest.h> has been #included.
+// Do not move it after other #includes.
+TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
+  bool dummy = testing::GTEST_FLAG(also_run_disabled_tests)
+      || testing::GTEST_FLAG(break_on_failure)
+      || testing::GTEST_FLAG(catch_exceptions)
+      || testing::GTEST_FLAG(color) != "unknown"
+      || testing::GTEST_FLAG(filter) != "unknown"
+      || testing::GTEST_FLAG(list_tests)
+      || testing::GTEST_FLAG(output) != "unknown"
+      || testing::GTEST_FLAG(print_time)
+      || testing::GTEST_FLAG(random_seed)
+      || testing::GTEST_FLAG(repeat) > 0
+      || testing::GTEST_FLAG(show_internal_stack_frames)
+      || testing::GTEST_FLAG(shuffle)
+      || testing::GTEST_FLAG(stack_trace_depth) > 0
+      || testing::GTEST_FLAG(stream_result_to) != "unknown"
+      || testing::GTEST_FLAG(throw_on_failure);
+  EXPECT_TRUE(dummy || !dummy);  // Suppresses warning that dummy is unused.
+}
+
+#include <limits.h>  // For INT_MAX.
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <map>
+#include <vector>
+#include <ostream>
+
+#include "gtest/gtest-spi.h"
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"
+#undef GTEST_IMPLEMENTATION_
+
+namespace testing {
+namespace internal {
+
+#if GTEST_CAN_STREAM_RESULTS_
+
+class StreamingListenerTest : public Test {
+ public:
+  class FakeSocketWriter : public StreamingListener::AbstractSocketWriter {
+   public:
+    // Sends a string to the socket.
+    virtual void Send(const string& message) { output_ += message; }
+
+    string output_;
+  };
+
+  StreamingListenerTest()
+      : fake_sock_writer_(new FakeSocketWriter),
+        streamer_(fake_sock_writer_),
+        test_info_obj_("FooTest", "Bar", NULL, NULL,
+                       CodeLocation(__FILE__, __LINE__), 0, NULL) {}
+
+ protected:
+  string* output() { return &(fake_sock_writer_->output_); }
+
+  FakeSocketWriter* const fake_sock_writer_;
+  StreamingListener streamer_;
+  UnitTest unit_test_;
+  TestInfo test_info_obj_;  // The name test_info_ was taken by testing::Test.
+};
+
+TEST_F(StreamingListenerTest, OnTestProgramEnd) {
+  *output() = "";
+  streamer_.OnTestProgramEnd(unit_test_);
+  EXPECT_EQ("event=TestProgramEnd&passed=1\n", *output());
+}
+
+TEST_F(StreamingListenerTest, OnTestIterationEnd) {
+  *output() = "";
+  streamer_.OnTestIterationEnd(unit_test_, 42);
+  EXPECT_EQ("event=TestIterationEnd&passed=1&elapsed_time=0ms\n", *output());
+}
+
+TEST_F(StreamingListenerTest, OnTestCaseStart) {
+  *output() = "";
+  streamer_.OnTestCaseStart(TestCase("FooTest", "Bar", NULL, NULL));
+  EXPECT_EQ("event=TestCaseStart&name=FooTest\n", *output());
+}
+
+TEST_F(StreamingListenerTest, OnTestCaseEnd) {
+  *output() = "";
+  streamer_.OnTestCaseEnd(TestCase("FooTest", "Bar", NULL, NULL));
+  EXPECT_EQ("event=TestCaseEnd&passed=1&elapsed_time=0ms\n", *output());
+}
+
+TEST_F(StreamingListenerTest, OnTestStart) {
+  *output() = "";
+  streamer_.OnTestStart(test_info_obj_);
+  EXPECT_EQ("event=TestStart&name=Bar\n", *output());
+}
+
+TEST_F(StreamingListenerTest, OnTestEnd) {
+  *output() = "";
+  streamer_.OnTestEnd(test_info_obj_);
+  EXPECT_EQ("event=TestEnd&passed=1&elapsed_time=0ms\n", *output());
+}
+
+TEST_F(StreamingListenerTest, OnTestPartResult) {
+  *output() = "";
+  streamer_.OnTestPartResult(TestPartResult(
+      TestPartResult::kFatalFailure, "foo.cc", 42, "failed=\n&%"));
+
+  // Meta characters in the failure message should be properly escaped.
+  EXPECT_EQ(
+      "event=TestPartResult&file=foo.cc&line=42&message=failed%3D%0A%26%25\n",
+      *output());
+}
+
+#endif  // GTEST_CAN_STREAM_RESULTS_
+
+// Provides access to otherwise private parts of the TestEventListeners class
+// that are needed to test it.
+class TestEventListenersAccessor {
+ public:
+  static TestEventListener* GetRepeater(TestEventListeners* listeners) {
+    return listeners->repeater();
+  }
+
+  static void SetDefaultResultPrinter(TestEventListeners* listeners,
+                                      TestEventListener* listener) {
+    listeners->SetDefaultResultPrinter(listener);
+  }
+  static void SetDefaultXmlGenerator(TestEventListeners* listeners,
+                                     TestEventListener* listener) {
+    listeners->SetDefaultXmlGenerator(listener);
+  }
+
+  static bool EventForwardingEnabled(const TestEventListeners& listeners) {
+    return listeners.EventForwardingEnabled();
+  }
+
+  static void SuppressEventForwarding(TestEventListeners* listeners) {
+    listeners->SuppressEventForwarding();
+  }
+};
+
+class UnitTestRecordPropertyTestHelper : public Test {
+ protected:
+  UnitTestRecordPropertyTestHelper() {}
+
+  // Forwards to UnitTest::RecordProperty() to bypass access controls.
+  void UnitTestRecordProperty(const char* key, const std::string& value) {
+    unit_test_.RecordProperty(key, value);
+  }
+
+  UnitTest unit_test_;
+};
+
+}  // namespace internal
+}  // namespace testing
+
+using testing::AssertionFailure;
+using testing::AssertionResult;
+using testing::AssertionSuccess;
+using testing::DoubleLE;
+using testing::EmptyTestEventListener;
+using testing::Environment;
+using testing::FloatLE;
+using testing::GTEST_FLAG(also_run_disabled_tests);
+using testing::GTEST_FLAG(break_on_failure);
+using testing::GTEST_FLAG(catch_exceptions);
+using testing::GTEST_FLAG(color);
+using testing::GTEST_FLAG(death_test_use_fork);
+using testing::GTEST_FLAG(filter);
+using testing::GTEST_FLAG(list_tests);
+using testing::GTEST_FLAG(output);
+using testing::GTEST_FLAG(print_time);
+using testing::GTEST_FLAG(random_seed);
+using testing::GTEST_FLAG(repeat);
+using testing::GTEST_FLAG(show_internal_stack_frames);
+using testing::GTEST_FLAG(shuffle);
+using testing::GTEST_FLAG(stack_trace_depth);
+using testing::GTEST_FLAG(stream_result_to);
+using testing::GTEST_FLAG(throw_on_failure);
+using testing::IsNotSubstring;
+using testing::IsSubstring;
+using testing::Message;
+using testing::ScopedFakeTestPartResultReporter;
+using testing::StaticAssertTypeEq;
+using testing::Test;
+using testing::TestCase;
+using testing::TestEventListeners;
+using testing::TestInfo;
+using testing::TestPartResult;
+using testing::TestPartResultArray;
+using testing::TestProperty;
+using testing::TestResult;
+using testing::TimeInMillis;
+using testing::UnitTest;
+using testing::internal::AddReference;
+using testing::internal::AlwaysFalse;
+using testing::internal::AlwaysTrue;
+using testing::internal::AppendUserMessage;
+using testing::internal::ArrayAwareFind;
+using testing::internal::ArrayEq;
+using testing::internal::CodePointToUtf8;
+using testing::internal::CompileAssertTypesEqual;
+using testing::internal::CopyArray;
+using testing::internal::CountIf;
+using testing::internal::EqFailure;
+using testing::internal::FloatingPoint;
+using testing::internal::ForEach;
+using testing::internal::FormatEpochTimeInMillisAsIso8601;
+using testing::internal::FormatTimeInMillisAsSeconds;
+using testing::internal::GTestFlagSaver;
+using testing::internal::GetCurrentOsStackTraceExceptTop;
+using testing::internal::GetElementOr;
+using testing::internal::GetNextRandomSeed;
+using testing::internal::GetRandomSeedFromFlag;
+using testing::internal::GetTestTypeId;
+using testing::internal::GetTimeInMillis;
+using testing::internal::GetTypeId;
+using testing::internal::GetUnitTestImpl;
+using testing::internal::ImplicitlyConvertible;
+using testing::internal::Int32;
+using testing::internal::Int32FromEnvOrDie;
+using testing::internal::IsAProtocolMessage;
+using testing::internal::IsContainer;
+using testing::internal::IsContainerTest;
+using testing::internal::IsNotContainer;
+using testing::internal::NativeArray;
+using testing::internal::ParseInt32Flag;
+using testing::internal::RelationToSourceCopy;
+using testing::internal::RelationToSourceReference;
+using testing::internal::RemoveConst;
+using testing::internal::RemoveReference;
+using testing::internal::ShouldRunTestOnShard;
+using testing::internal::ShouldShard;
+using testing::internal::ShouldUseColor;
+using testing::internal::Shuffle;
+using testing::internal::ShuffleRange;
+using testing::internal::SkipPrefix;
+using testing::internal::StreamableToString;
+using testing::internal::String;
+using testing::internal::TestEventListenersAccessor;
+using testing::internal::TestResultAccessor;
+using testing::internal::UInt32;
+using testing::internal::WideStringToUtf8;
+using testing::internal::edit_distance::CalculateOptimalEdits;
+using testing::internal::edit_distance::CreateUnifiedDiff;
+using testing::internal::edit_distance::EditType;
+using testing::internal::kMaxRandomSeed;
+using testing::internal::kTestTypeIdInGoogleTest;
+using testing::kMaxStackTraceDepth;
+
+#if GTEST_HAS_STREAM_REDIRECTION
+using testing::internal::CaptureStdout;
+using testing::internal::GetCapturedStdout;
+#endif
+
+#if GTEST_IS_THREADSAFE
+using testing::internal::ThreadWithParam;
+#endif
+
+class TestingVector : public std::vector<int> {
+};
+
+::std::ostream& operator<<(::std::ostream& os,
+                           const TestingVector& vector) {
+  os << "{ ";
+  for (size_t i = 0; i < vector.size(); i++) {
+    os << vector[i] << " ";
+  }
+  os << "}";
+  return os;
+}
+
+// This line tests that we can define tests in an unnamed namespace.
+namespace {
+
+TEST(GetRandomSeedFromFlagTest, HandlesZero) {
+  const int seed = GetRandomSeedFromFlag(0);
+  EXPECT_LE(1, seed);
+  EXPECT_LE(seed, static_cast<int>(kMaxRandomSeed));
+}
+
+TEST(GetRandomSeedFromFlagTest, PreservesValidSeed) {
+  EXPECT_EQ(1, GetRandomSeedFromFlag(1));
+  EXPECT_EQ(2, GetRandomSeedFromFlag(2));
+  EXPECT_EQ(kMaxRandomSeed - 1, GetRandomSeedFromFlag(kMaxRandomSeed - 1));
+  EXPECT_EQ(static_cast<int>(kMaxRandomSeed),
+            GetRandomSeedFromFlag(kMaxRandomSeed));
+}
+
+TEST(GetRandomSeedFromFlagTest, NormalizesInvalidSeed) {
+  const int seed1 = GetRandomSeedFromFlag(-1);
+  EXPECT_LE(1, seed1);
+  EXPECT_LE(seed1, static_cast<int>(kMaxRandomSeed));
+
+  const int seed2 = GetRandomSeedFromFlag(kMaxRandomSeed + 1);
+  EXPECT_LE(1, seed2);
+  EXPECT_LE(seed2, static_cast<int>(kMaxRandomSeed));
+}
+
+TEST(GetNextRandomSeedTest, WorksForValidInput) {
+  EXPECT_EQ(2, GetNextRandomSeed(1));
+  EXPECT_EQ(3, GetNextRandomSeed(2));
+  EXPECT_EQ(static_cast<int>(kMaxRandomSeed),
+            GetNextRandomSeed(kMaxRandomSeed - 1));
+  EXPECT_EQ(1, GetNextRandomSeed(kMaxRandomSeed));
+
+  // We deliberately don't test GetNextRandomSeed() with invalid
+  // inputs, as that requires death tests, which are expensive.  This
+  // is fine as GetNextRandomSeed() is internal and has a
+  // straightforward definition.
+}
+
+static void ClearCurrentTestPartResults() {
+  TestResultAccessor::ClearTestPartResults(
+      GetUnitTestImpl()->current_test_result());
+}
+
+// Tests GetTypeId.
+
+TEST(GetTypeIdTest, ReturnsSameValueForSameType) {
+  EXPECT_EQ(GetTypeId<int>(), GetTypeId<int>());
+  EXPECT_EQ(GetTypeId<Test>(), GetTypeId<Test>());
+}
+
+class SubClassOfTest : public Test {};
+class AnotherSubClassOfTest : public Test {};
+
+TEST(GetTypeIdTest, ReturnsDifferentValuesForDifferentTypes) {
+  EXPECT_NE(GetTypeId<int>(), GetTypeId<const int>());
+  EXPECT_NE(GetTypeId<int>(), GetTypeId<char>());
+  EXPECT_NE(GetTypeId<int>(), GetTestTypeId());
+  EXPECT_NE(GetTypeId<SubClassOfTest>(), GetTestTypeId());
+  EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTestTypeId());
+  EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTypeId<SubClassOfTest>());
+}
+
+// Verifies that GetTestTypeId() returns the same value, no matter it
+// is called from inside Google Test or outside of it.
+TEST(GetTestTypeIdTest, ReturnsTheSameValueInsideOrOutsideOfGoogleTest) {
+  EXPECT_EQ(kTestTypeIdInGoogleTest, GetTestTypeId());
+}
+
+// Tests FormatTimeInMillisAsSeconds().
+
+TEST(FormatTimeInMillisAsSecondsTest, FormatsZero) {
+  EXPECT_EQ("0", FormatTimeInMillisAsSeconds(0));
+}
+
+TEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) {
+  EXPECT_EQ("0.003", FormatTimeInMillisAsSeconds(3));
+  EXPECT_EQ("0.01", FormatTimeInMillisAsSeconds(10));
+  EXPECT_EQ("0.2", FormatTimeInMillisAsSeconds(200));
+  EXPECT_EQ("1.2", FormatTimeInMillisAsSeconds(1200));
+  EXPECT_EQ("3", FormatTimeInMillisAsSeconds(3000));
+}
+
+TEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) {
+  EXPECT_EQ("-0.003", FormatTimeInMillisAsSeconds(-3));
+  EXPECT_EQ("-0.01", FormatTimeInMillisAsSeconds(-10));
+  EXPECT_EQ("-0.2", FormatTimeInMillisAsSeconds(-200));
+  EXPECT_EQ("-1.2", FormatTimeInMillisAsSeconds(-1200));
+  EXPECT_EQ("-3", FormatTimeInMillisAsSeconds(-3000));
+}
+
+// Tests FormatEpochTimeInMillisAsIso8601().  The correctness of conversion
+// for particular dates below was verified in Python using
+// datetime.datetime.fromutctimestamp(<timetamp>/1000).
+
+// FormatEpochTimeInMillisAsIso8601 depends on the current timezone, so we
+// have to set up a particular timezone to obtain predictable results.
+class FormatEpochTimeInMillisAsIso8601Test : public Test {
+ public:
+  // On Cygwin, GCC doesn't allow unqualified integer literals to exceed
+  // 32 bits, even when 64-bit integer types are available.  We have to
+  // force the constants to have a 64-bit type here.
+  static const TimeInMillis kMillisPerSec = 1000;
+
+ private:
+  virtual void SetUp() {
+    saved_tz_ = NULL;
+
+    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* getenv, strdup: deprecated */)
+    if (getenv("TZ"))
+      saved_tz_ = strdup(getenv("TZ"));
+    GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+    // Set up the time zone for FormatEpochTimeInMillisAsIso8601 to use.  We
+    // cannot use the local time zone because the function's output depends
+    // on the time zone.
+    SetTimeZone("UTC+00");
+  }
+
+  virtual void TearDown() {
+    SetTimeZone(saved_tz_);
+    free(const_cast<char*>(saved_tz_));
+    saved_tz_ = NULL;
+  }
+
+  static void SetTimeZone(const char* time_zone) {
+    // tzset() distinguishes between the TZ variable being present and empty
+    // and not being present, so we have to consider the case of time_zone
+    // being NULL.
+#if _MSC_VER || GTEST_OS_WINDOWS_MINGW
+    // ...Unless it's MSVC, whose standard library's _putenv doesn't
+    // distinguish between an empty and a missing variable.
+    const std::string env_var =
+        std::string("TZ=") + (time_zone ? time_zone : "");
+    _putenv(env_var.c_str());
+    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */)
+    tzset();
+    GTEST_DISABLE_MSC_WARNINGS_POP_()
+#else
+    if (time_zone) {
+      setenv(("TZ"), time_zone, 1);
+    } else {
+      unsetenv("TZ");
+    }
+    tzset();
+#endif
+  }
+
+  const char* saved_tz_;
+};
+
+const TimeInMillis FormatEpochTimeInMillisAsIso8601Test::kMillisPerSec;
+
+TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsTwoDigitSegments) {
+  EXPECT_EQ("2011-10-31T18:52:42",
+            FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec));
+}
+
+TEST_F(FormatEpochTimeInMillisAsIso8601Test, MillisecondsDoNotAffectResult) {
+  EXPECT_EQ(
+      "2011-10-31T18:52:42",
+      FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec + 234));
+}
+
+TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsLeadingZeroes) {
+  EXPECT_EQ("2011-09-03T05:07:02",
+            FormatEpochTimeInMillisAsIso8601(1315026422 * kMillisPerSec));
+}
+
+TEST_F(FormatEpochTimeInMillisAsIso8601Test, Prints24HourTime) {
+  EXPECT_EQ("2011-09-28T17:08:22",
+            FormatEpochTimeInMillisAsIso8601(1317229702 * kMillisPerSec));
+}
+
+TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsEpochStart) {
+  EXPECT_EQ("1970-01-01T00:00:00", FormatEpochTimeInMillisAsIso8601(0));
+}
+
+#if GTEST_CAN_COMPARE_NULL
+
+# ifdef __BORLANDC__
+// Silences warnings: "Condition is always true", "Unreachable code"
+#  pragma option push -w-ccc -w-rch
+# endif
+
+// Tests that GTEST_IS_NULL_LITERAL_(x) is true when x is a null
+// pointer literal.
+TEST(NullLiteralTest, IsTrueForNullLiterals) {
+  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(NULL));
+  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0));
+  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0U));
+  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0L));
+}
+
+// Tests that GTEST_IS_NULL_LITERAL_(x) is false when x is not a null
+// pointer literal.
+TEST(NullLiteralTest, IsFalseForNonNullLiterals) {
+  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(1));
+  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(0.0));
+  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_('a'));
+  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(static_cast<void*>(NULL)));
+}
+
+# ifdef __BORLANDC__
+// Restores warnings after previous "#pragma option push" suppressed them.
+#  pragma option pop
+# endif
+
+#endif  // GTEST_CAN_COMPARE_NULL
+//
+// Tests CodePointToUtf8().
+
+// Tests that the NUL character L'\0' is encoded correctly.
+TEST(CodePointToUtf8Test, CanEncodeNul) {
+  EXPECT_EQ("", CodePointToUtf8(L'\0'));
+}
+
+// Tests that ASCII characters are encoded correctly.
+TEST(CodePointToUtf8Test, CanEncodeAscii) {
+  EXPECT_EQ("a", CodePointToUtf8(L'a'));
+  EXPECT_EQ("Z", CodePointToUtf8(L'Z'));
+  EXPECT_EQ("&", CodePointToUtf8(L'&'));
+  EXPECT_EQ("\x7F", CodePointToUtf8(L'\x7F'));
+}
+
+// Tests that Unicode code-points that have 8 to 11 bits are encoded
+// as 110xxxxx 10xxxxxx.
+TEST(CodePointToUtf8Test, CanEncode8To11Bits) {
+  // 000 1101 0011 => 110-00011 10-010011
+  EXPECT_EQ("\xC3\x93", CodePointToUtf8(L'\xD3'));
+
+  // 101 0111 0110 => 110-10101 10-110110
+  // Some compilers (e.g., GCC on MinGW) cannot handle non-ASCII codepoints
+  // in wide strings and wide chars. In order to accomodate them, we have to
+  // introduce such character constants as integers.
+  EXPECT_EQ("\xD5\xB6",
+            CodePointToUtf8(static_cast<wchar_t>(0x576)));
+}
+
+// Tests that Unicode code-points that have 12 to 16 bits are encoded
+// as 1110xxxx 10xxxxxx 10xxxxxx.
+TEST(CodePointToUtf8Test, CanEncode12To16Bits) {
+  // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
+  EXPECT_EQ("\xE0\xA3\x93",
+            CodePointToUtf8(static_cast<wchar_t>(0x8D3)));
+
+  // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
+  EXPECT_EQ("\xEC\x9D\x8D",
+            CodePointToUtf8(static_cast<wchar_t>(0xC74D)));
+}
+
+#if !GTEST_WIDE_STRING_USES_UTF16_
+// Tests in this group require a wchar_t to hold > 16 bits, and thus
+// are skipped on Windows, Cygwin, and Symbian, where a wchar_t is
+// 16-bit wide. This code may not compile on those systems.
+
+// Tests that Unicode code-points that have 17 to 21 bits are encoded
+// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx.
+TEST(CodePointToUtf8Test, CanEncode17To21Bits) {
+  // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011
+  EXPECT_EQ("\xF0\x90\xA3\x93", CodePointToUtf8(L'\x108D3'));
+
+  // 0 0001 0000 0100 0000 0000 => 11110-000 10-010000 10-010000 10-000000
+  EXPECT_EQ("\xF0\x90\x90\x80", CodePointToUtf8(L'\x10400'));
+
+  // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100
+  EXPECT_EQ("\xF4\x88\x98\xB4", CodePointToUtf8(L'\x108634'));
+}
+
+// Tests that encoding an invalid code-point generates the expected result.
+TEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) {
+  EXPECT_EQ("(Invalid Unicode 0x1234ABCD)", CodePointToUtf8(L'\x1234ABCD'));
+}
+
+#endif  // !GTEST_WIDE_STRING_USES_UTF16_
+
+// Tests WideStringToUtf8().
+
+// Tests that the NUL character L'\0' is encoded correctly.
+TEST(WideStringToUtf8Test, CanEncodeNul) {
+  EXPECT_STREQ("", WideStringToUtf8(L"", 0).c_str());
+  EXPECT_STREQ("", WideStringToUtf8(L"", -1).c_str());
+}
+
+// Tests that ASCII strings are encoded correctly.
+TEST(WideStringToUtf8Test, CanEncodeAscii) {
+  EXPECT_STREQ("a", WideStringToUtf8(L"a", 1).c_str());
+  EXPECT_STREQ("ab", WideStringToUtf8(L"ab", 2).c_str());
+  EXPECT_STREQ("a", WideStringToUtf8(L"a", -1).c_str());
+  EXPECT_STREQ("ab", WideStringToUtf8(L"ab", -1).c_str());
+}
+
+// Tests that Unicode code-points that have 8 to 11 bits are encoded
+// as 110xxxxx 10xxxxxx.
+TEST(WideStringToUtf8Test, CanEncode8To11Bits) {
+  // 000 1101 0011 => 110-00011 10-010011
+  EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", 1).c_str());
+  EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str());
+
+  // 101 0111 0110 => 110-10101 10-110110
+  const wchar_t s[] = { 0x576, '\0' };
+  EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, 1).c_str());
+  EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, -1).c_str());
+}
+
+// Tests that Unicode code-points that have 12 to 16 bits are encoded
+// as 1110xxxx 10xxxxxx 10xxxxxx.
+TEST(WideStringToUtf8Test, CanEncode12To16Bits) {
+  // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
+  const wchar_t s1[] = { 0x8D3, '\0' };
+  EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, 1).c_str());
+  EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, -1).c_str());
+
+  // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
+  const wchar_t s2[] = { 0xC74D, '\0' };
+  EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, 1).c_str());
+  EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, -1).c_str());
+}
+
+// Tests that the conversion stops when the function encounters \0 character.
+TEST(WideStringToUtf8Test, StopsOnNulCharacter) {
+  EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str());
+}
+
+// Tests that the conversion stops when the function reaches the limit
+// specified by the 'length' parameter.
+TEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) {
+  EXPECT_STREQ("ABC", WideStringToUtf8(L"ABCDEF", 3).c_str());
+}
+
+#if !GTEST_WIDE_STRING_USES_UTF16_
+// Tests that Unicode code-points that have 17 to 21 bits are encoded
+// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. This code may not compile
+// on the systems using UTF-16 encoding.
+TEST(WideStringToUtf8Test, CanEncode17To21Bits) {
+  // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011
+  EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", 1).c_str());
+  EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", -1).c_str());
+
+  // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100
+  EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", 1).c_str());
+  EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", -1).c_str());
+}
+
+// Tests that encoding an invalid code-point generates the expected result.
+TEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) {
+  EXPECT_STREQ("(Invalid Unicode 0xABCDFF)",
+               WideStringToUtf8(L"\xABCDFF", -1).c_str());
+}
+#else  // !GTEST_WIDE_STRING_USES_UTF16_
+// Tests that surrogate pairs are encoded correctly on the systems using
+// UTF-16 encoding in the wide strings.
+TEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) {
+  const wchar_t s[] = { 0xD801, 0xDC00, '\0' };
+  EXPECT_STREQ("\xF0\x90\x90\x80", WideStringToUtf8(s, -1).c_str());
+}
+
+// Tests that encoding an invalid UTF-16 surrogate pair
+// generates the expected result.
+TEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) {
+  // Leading surrogate is at the end of the string.
+  const wchar_t s1[] = { 0xD800, '\0' };
+  EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(s1, -1).c_str());
+  // Leading surrogate is not followed by the trailing surrogate.
+  const wchar_t s2[] = { 0xD800, 'M', '\0' };
+  EXPECT_STREQ("\xED\xA0\x80M", WideStringToUtf8(s2, -1).c_str());
+  // Trailing surrogate appearas without a leading surrogate.
+  const wchar_t s3[] = { 0xDC00, 'P', 'Q', 'R', '\0' };
+  EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(s3, -1).c_str());
+}
+#endif  // !GTEST_WIDE_STRING_USES_UTF16_
+
+// Tests that codepoint concatenation works correctly.
+#if !GTEST_WIDE_STRING_USES_UTF16_
+TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
+  const wchar_t s[] = { 0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'};
+  EXPECT_STREQ(
+      "\xF4\x88\x98\xB4"
+          "\xEC\x9D\x8D"
+          "\n"
+          "\xD5\xB6"
+          "\xE0\xA3\x93"
+          "\xF4\x88\x98\xB4",
+      WideStringToUtf8(s, -1).c_str());
+}
+#else
+TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
+  const wchar_t s[] = { 0xC74D, '\n', 0x576, 0x8D3, '\0'};
+  EXPECT_STREQ(
+      "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93",
+      WideStringToUtf8(s, -1).c_str());
+}
+#endif  // !GTEST_WIDE_STRING_USES_UTF16_
+
+// Tests the Random class.
+
+TEST(RandomDeathTest, GeneratesCrashesOnInvalidRange) {
+  testing::internal::Random random(42);
+  EXPECT_DEATH_IF_SUPPORTED(
+      random.Generate(0),
+      "Cannot generate a number in the range \\[0, 0\\)");
+  EXPECT_DEATH_IF_SUPPORTED(
+      random.Generate(testing::internal::Random::kMaxRange + 1),
+      "Generation of a number in \\[0, 2147483649\\) was requested, "
+      "but this can only generate numbers in \\[0, 2147483648\\)");
+}
+
+TEST(RandomTest, GeneratesNumbersWithinRange) {
+  const UInt32 kRange = 10000;
+  testing::internal::Random random(12345);
+  for (int i = 0; i < 10; i++) {
+    EXPECT_LT(random.Generate(kRange), kRange) << " for iteration " << i;
+  }
+
+  testing::internal::Random random2(testing::internal::Random::kMaxRange);
+  for (int i = 0; i < 10; i++) {
+    EXPECT_LT(random2.Generate(kRange), kRange) << " for iteration " << i;
+  }
+}
+
+TEST(RandomTest, RepeatsWhenReseeded) {
+  const int kSeed = 123;
+  const int kArraySize = 10;
+  const UInt32 kRange = 10000;
+  UInt32 values[kArraySize];
+
+  testing::internal::Random random(kSeed);
+  for (int i = 0; i < kArraySize; i++) {
+    values[i] = random.Generate(kRange);
+  }
+
+  random.Reseed(kSeed);
+  for (int i = 0; i < kArraySize; i++) {
+    EXPECT_EQ(values[i], random.Generate(kRange)) << " for iteration " << i;
+  }
+}
+
+// Tests STL container utilities.
+
+// Tests CountIf().
+
+static bool IsPositive(int n) { return n > 0; }
+
+TEST(ContainerUtilityTest, CountIf) {
+  std::vector<int> v;
+  EXPECT_EQ(0, CountIf(v, IsPositive));  // Works for an empty container.
+
+  v.push_back(-1);
+  v.push_back(0);
+  EXPECT_EQ(0, CountIf(v, IsPositive));  // Works when no value satisfies.
+
+  v.push_back(2);
+  v.push_back(-10);
+  v.push_back(10);
+  EXPECT_EQ(2, CountIf(v, IsPositive));
+}
+
+// Tests ForEach().
+
+static int g_sum = 0;
+static void Accumulate(int n) { g_sum += n; }
+
+TEST(ContainerUtilityTest, ForEach) {
+  std::vector<int> v;
+  g_sum = 0;
+  ForEach(v, Accumulate);
+  EXPECT_EQ(0, g_sum);  // Works for an empty container;
+
+  g_sum = 0;
+  v.push_back(1);
+  ForEach(v, Accumulate);
+  EXPECT_EQ(1, g_sum);  // Works for a container with one element.
+
+  g_sum = 0;
+  v.push_back(20);
+  v.push_back(300);
+  ForEach(v, Accumulate);
+  EXPECT_EQ(321, g_sum);
+}
+
+// Tests GetElementOr().
+TEST(ContainerUtilityTest, GetElementOr) {
+  std::vector<char> a;
+  EXPECT_EQ('x', GetElementOr(a, 0, 'x'));
+
+  a.push_back('a');
+  a.push_back('b');
+  EXPECT_EQ('a', GetElementOr(a, 0, 'x'));
+  EXPECT_EQ('b', GetElementOr(a, 1, 'x'));
+  EXPECT_EQ('x', GetElementOr(a, -2, 'x'));
+  EXPECT_EQ('x', GetElementOr(a, 2, 'x'));
+}
+
+TEST(ContainerUtilityDeathTest, ShuffleRange) {
+  std::vector<int> a;
+  a.push_back(0);
+  a.push_back(1);
+  a.push_back(2);
+  testing::internal::Random random(1);
+
+  EXPECT_DEATH_IF_SUPPORTED(
+      ShuffleRange(&random, -1, 1, &a),
+      "Invalid shuffle range start -1: must be in range \\[0, 3\\]");
+  EXPECT_DEATH_IF_SUPPORTED(
+      ShuffleRange(&random, 4, 4, &a),
+      "Invalid shuffle range start 4: must be in range \\[0, 3\\]");
+  EXPECT_DEATH_IF_SUPPORTED(
+      ShuffleRange(&random, 3, 2, &a),
+      "Invalid shuffle range finish 2: must be in range \\[3, 3\\]");
+  EXPECT_DEATH_IF_SUPPORTED(
+      ShuffleRange(&random, 3, 4, &a),
+      "Invalid shuffle range finish 4: must be in range \\[3, 3\\]");
+}
+
+class VectorShuffleTest : public Test {
+ protected:
+  static const int kVectorSize = 20;
+
+  VectorShuffleTest() : random_(1) {
+    for (int i = 0; i < kVectorSize; i++) {
+      vector_.push_back(i);
+    }
+  }
+
+  static bool VectorIsCorrupt(const TestingVector& vector) {
+    if (kVectorSize != static_cast<int>(vector.size())) {
+      return true;
+    }
+
+    bool found_in_vector[kVectorSize] = { false };
+    for (size_t i = 0; i < vector.size(); i++) {
+      const int e = vector[i];
+      if (e < 0 || e >= kVectorSize || found_in_vector[e]) {
+        return true;
+      }
+      found_in_vector[e] = true;
+    }
+
+    // Vector size is correct, elements' range is correct, no
+    // duplicate elements.  Therefore no corruption has occurred.
+    return false;
+  }
+
+  static bool VectorIsNotCorrupt(const TestingVector& vector) {
+    return !VectorIsCorrupt(vector);
+  }
+
+  static bool RangeIsShuffled(const TestingVector& vector, int begin, int end) {
+    for (int i = begin; i < end; i++) {
+      if (i != vector[i]) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  static bool RangeIsUnshuffled(
+      const TestingVector& vector, int begin, int end) {
+    return !RangeIsShuffled(vector, begin, end);
+  }
+
+  static bool VectorIsShuffled(const TestingVector& vector) {
+    return RangeIsShuffled(vector, 0, static_cast<int>(vector.size()));
+  }
+
+  static bool VectorIsUnshuffled(const TestingVector& vector) {
+    return !VectorIsShuffled(vector);
+  }
+
+  testing::internal::Random random_;
+  TestingVector vector_;
+};  // class VectorShuffleTest
+
+const int VectorShuffleTest::kVectorSize;
+
+TEST_F(VectorShuffleTest, HandlesEmptyRange) {
+  // Tests an empty range at the beginning...
+  ShuffleRange(&random_, 0, 0, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...in the middle...
+  ShuffleRange(&random_, kVectorSize/2, kVectorSize/2, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...at the end...
+  ShuffleRange(&random_, kVectorSize - 1, kVectorSize - 1, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...and past the end.
+  ShuffleRange(&random_, kVectorSize, kVectorSize, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+}
+
+TEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) {
+  // Tests a size one range at the beginning...
+  ShuffleRange(&random_, 0, 1, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...in the middle...
+  ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+
+  // ...and at the end.
+  ShuffleRange(&random_, kVectorSize - 1, kVectorSize, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsUnshuffled, vector_);
+}
+
+// Because we use our own random number generator and a fixed seed,
+// we can guarantee that the following "random" tests will succeed.
+
+TEST_F(VectorShuffleTest, ShufflesEntireVector) {
+  Shuffle(&random_, &vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  EXPECT_FALSE(VectorIsUnshuffled(vector_)) << vector_;
+
+  // Tests the first and last elements in particular to ensure that
+  // there are no off-by-one problems in our shuffle algorithm.
+  EXPECT_NE(0, vector_[0]);
+  EXPECT_NE(kVectorSize - 1, vector_[kVectorSize - 1]);
+}
+
+TEST_F(VectorShuffleTest, ShufflesStartOfVector) {
+  const int kRangeSize = kVectorSize/2;
+
+  ShuffleRange(&random_, 0, kRangeSize, &vector_);
+
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  EXPECT_PRED3(RangeIsShuffled, vector_, 0, kRangeSize);
+  EXPECT_PRED3(RangeIsUnshuffled, vector_, kRangeSize, kVectorSize);
+}
+
+TEST_F(VectorShuffleTest, ShufflesEndOfVector) {
+  const int kRangeSize = kVectorSize / 2;
+  ShuffleRange(&random_, kRangeSize, kVectorSize, &vector_);
+
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
+  EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, kVectorSize);
+}
+
+TEST_F(VectorShuffleTest, ShufflesMiddleOfVector) {
+  int kRangeSize = kVectorSize/3;
+  ShuffleRange(&random_, kRangeSize, 2*kRangeSize, &vector_);
+
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
+  EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2*kRangeSize);
+  EXPECT_PRED3(RangeIsUnshuffled, vector_, 2*kRangeSize, kVectorSize);
+}
+
+TEST_F(VectorShuffleTest, ShufflesRepeatably) {
+  TestingVector vector2;
+  for (int i = 0; i < kVectorSize; i++) {
+    vector2.push_back(i);
+  }
+
+  random_.Reseed(1234);
+  Shuffle(&random_, &vector_);
+  random_.Reseed(1234);
+  Shuffle(&random_, &vector2);
+
+  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
+  ASSERT_PRED1(VectorIsNotCorrupt, vector2);
+
+  for (int i = 0; i < kVectorSize; i++) {
+    EXPECT_EQ(vector_[i], vector2[i]) << " where i is " << i;
+  }
+}
+
+// Tests the size of the AssertHelper class.
+
+TEST(AssertHelperTest, AssertHelperIsSmall) {
+  // To avoid breaking clients that use lots of assertions in one
+  // function, we cannot grow the size of AssertHelper.
+  EXPECT_LE(sizeof(testing::internal::AssertHelper), sizeof(void*));
+}
+
+// Tests String::EndsWithCaseInsensitive().
+TEST(StringTest, EndsWithCaseInsensitive) {
+  EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", "BAR"));
+  EXPECT_TRUE(String::EndsWithCaseInsensitive("foobaR", "bar"));
+  EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", ""));
+  EXPECT_TRUE(String::EndsWithCaseInsensitive("", ""));
+
+  EXPECT_FALSE(String::EndsWithCaseInsensitive("Foobar", "foo"));
+  EXPECT_FALSE(String::EndsWithCaseInsensitive("foobar", "Foo"));
+  EXPECT_FALSE(String::EndsWithCaseInsensitive("", "foo"));
+}
+
+// C++Builder's preprocessor is buggy; it fails to expand macros that
+// appear in macro parameters after wide char literals.  Provide an alias
+// for NULL as a workaround.
+static const wchar_t* const kNull = NULL;
+
+// Tests String::CaseInsensitiveWideCStringEquals
+TEST(StringTest, CaseInsensitiveWideCStringEquals) {
+  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(NULL, NULL));
+  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L""));
+  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"", kNull));
+  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"foobar"));
+  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"foobar", kNull));
+  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"foobar"));
+  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"FOOBAR"));
+  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar"));
+}
+
+#if GTEST_OS_WINDOWS
+
+// Tests String::ShowWideCString().
+TEST(StringTest, ShowWideCString) {
+  EXPECT_STREQ("(null)",
+               String::ShowWideCString(NULL).c_str());
+  EXPECT_STREQ("", String::ShowWideCString(L"").c_str());
+  EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str());
+}
+
+# if GTEST_OS_WINDOWS_MOBILE
+TEST(StringTest, AnsiAndUtf16Null) {
+  EXPECT_EQ(NULL, String::AnsiToUtf16(NULL));
+  EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL));
+}
+
+TEST(StringTest, AnsiAndUtf16ConvertBasic) {
+  const char* ansi = String::Utf16ToAnsi(L"str");
+  EXPECT_STREQ("str", ansi);
+  delete [] ansi;
+  const WCHAR* utf16 = String::AnsiToUtf16("str");
+  EXPECT_EQ(0, wcsncmp(L"str", utf16, 3));
+  delete [] utf16;
+}
+
+TEST(StringTest, AnsiAndUtf16ConvertPathChars) {
+  const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?");
+  EXPECT_STREQ(".:\\ \"*?", ansi);
+  delete [] ansi;
+  const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?");
+  EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3));
+  delete [] utf16;
+}
+# endif  // GTEST_OS_WINDOWS_MOBILE
+
+#endif  // GTEST_OS_WINDOWS
+
+// Tests TestProperty construction.
+TEST(TestPropertyTest, StringValue) {
+  TestProperty property("key", "1");
+  EXPECT_STREQ("key", property.key());
+  EXPECT_STREQ("1", property.value());
+}
+
+// Tests TestProperty replacing a value.
+TEST(TestPropertyTest, ReplaceStringValue) {
+  TestProperty property("key", "1");
+  EXPECT_STREQ("1", property.value());
+  property.SetValue("2");
+  EXPECT_STREQ("2", property.value());
+}
+
+// AddFatalFailure() and AddNonfatalFailure() must be stand-alone
+// functions (i.e. their definitions cannot be inlined at the call
+// sites), or C++Builder won't compile the code.
+static void AddFatalFailure() {
+  FAIL() << "Expected fatal failure.";
+}
+
+static void AddNonfatalFailure() {
+  ADD_FAILURE() << "Expected non-fatal failure.";
+}
+
+class ScopedFakeTestPartResultReporterTest : public Test {
+ public:  // Must be public and not protected due to a bug in g++ 3.4.2.
+  enum FailureMode {
+    FATAL_FAILURE,
+    NONFATAL_FAILURE
+  };
+  static void AddFailure(FailureMode failure) {
+    if (failure == FATAL_FAILURE) {
+      AddFatalFailure();
+    } else {
+      AddNonfatalFailure();
+    }
+  }
+};
+
+// Tests that ScopedFakeTestPartResultReporter intercepts test
+// failures.
+TEST_F(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) {
+  TestPartResultArray results;
+  {
+    ScopedFakeTestPartResultReporter reporter(
+        ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD,
+        &results);
+    AddFailure(NONFATAL_FAILURE);
+    AddFailure(FATAL_FAILURE);
+  }
+
+  EXPECT_EQ(2, results.size());
+  EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed());
+  EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed());
+}
+
+TEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) {
+  TestPartResultArray results;
+  {
+    // Tests, that the deprecated constructor still works.
+    ScopedFakeTestPartResultReporter reporter(&results);
+    AddFailure(NONFATAL_FAILURE);
+  }
+  EXPECT_EQ(1, results.size());
+}
+
+#if GTEST_IS_THREADSAFE
+
+class ScopedFakeTestPartResultReporterWithThreadsTest
+  : public ScopedFakeTestPartResultReporterTest {
+ protected:
+  static void AddFailureInOtherThread(FailureMode failure) {
+    ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL);
+    thread.Join();
+  }
+};
+
+TEST_F(ScopedFakeTestPartResultReporterWithThreadsTest,
+       InterceptsTestFailuresInAllThreads) {
+  TestPartResultArray results;
+  {
+    ScopedFakeTestPartResultReporter reporter(
+        ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, &results);
+    AddFailure(NONFATAL_FAILURE);
+    AddFailure(FATAL_FAILURE);
+    AddFailureInOtherThread(NONFATAL_FAILURE);
+    AddFailureInOtherThread(FATAL_FAILURE);
+  }
+
+  EXPECT_EQ(4, results.size());
+  EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed());
+  EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed());
+  EXPECT_TRUE(results.GetTestPartResult(2).nonfatally_failed());
+  EXPECT_TRUE(results.GetTestPartResult(3).fatally_failed());
+}
+
+#endif  // GTEST_IS_THREADSAFE
+
+// Tests EXPECT_FATAL_FAILURE{,ON_ALL_THREADS}.  Makes sure that they
+// work even if the failure is generated in a called function rather than
+// the current context.
+
+typedef ScopedFakeTestPartResultReporterTest ExpectFatalFailureTest;
+
+TEST_F(ExpectFatalFailureTest, CatchesFatalFaliure) {
+  EXPECT_FATAL_FAILURE(AddFatalFailure(), "Expected fatal failure.");
+}
+
+#if GTEST_HAS_GLOBAL_STRING
+TEST_F(ExpectFatalFailureTest, AcceptsStringObject) {
+  EXPECT_FATAL_FAILURE(AddFatalFailure(), ::string("Expected fatal failure."));
+}
+#endif
+
+TEST_F(ExpectFatalFailureTest, AcceptsStdStringObject) {
+  EXPECT_FATAL_FAILURE(AddFatalFailure(),
+                       ::std::string("Expected fatal failure."));
+}
+
+TEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) {
+  // We have another test below to verify that the macro catches fatal
+  // failures generated on another thread.
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFatalFailure(),
+                                      "Expected fatal failure.");
+}
+
+#ifdef __BORLANDC__
+// Silences warnings: "Condition is always true"
+# pragma option push -w-ccc
+#endif
+
+// Tests that EXPECT_FATAL_FAILURE() can be used in a non-void
+// function even when the statement in it contains ASSERT_*.
+
+int NonVoidFunction() {
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), "");
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), "");
+  return 0;
+}
+
+TEST_F(ExpectFatalFailureTest, CanBeUsedInNonVoidFunction) {
+  NonVoidFunction();
+}
+
+// Tests that EXPECT_FATAL_FAILURE(statement, ...) doesn't abort the
+// current function even though 'statement' generates a fatal failure.
+
+void DoesNotAbortHelper(bool* aborted) {
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), "");
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), "");
+
+  *aborted = false;
+}
+
+#ifdef __BORLANDC__
+// Restores warnings after previous "#pragma option push" suppressed them.
+# pragma option pop
+#endif
+
+TEST_F(ExpectFatalFailureTest, DoesNotAbort) {
+  bool aborted = true;
+  DoesNotAbortHelper(&aborted);
+  EXPECT_FALSE(aborted);
+}
+
+// Tests that the EXPECT_FATAL_FAILURE{,_ON_ALL_THREADS} accepts a
+// statement that contains a macro which expands to code containing an
+// unprotected comma.
+
+static int global_var = 0;
+#define GTEST_USE_UNPROTECTED_COMMA_ global_var++, global_var++
+
+TEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
+#ifndef __BORLANDC__
+  // ICE's in C++Builder.
+  EXPECT_FATAL_FAILURE({
+    GTEST_USE_UNPROTECTED_COMMA_;
+    AddFatalFailure();
+  }, "");
+#endif
+
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS({
+    GTEST_USE_UNPROTECTED_COMMA_;
+    AddFatalFailure();
+  }, "");
+}
+
+// Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}.
+
+typedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest;
+
+TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) {
+  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
+                          "Expected non-fatal failure.");
+}
+
+#if GTEST_HAS_GLOBAL_STRING
+TEST_F(ExpectNonfatalFailureTest, AcceptsStringObject) {
+  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
+                          ::string("Expected non-fatal failure."));
+}
+#endif
+
+TEST_F(ExpectNonfatalFailureTest, AcceptsStdStringObject) {
+  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
+                          ::std::string("Expected non-fatal failure."));
+}
+
+TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) {
+  // We have another test below to verify that the macro catches
+  // non-fatal failures generated on another thread.
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddNonfatalFailure(),
+                                         "Expected non-fatal failure.");
+}
+
+// Tests that the EXPECT_NONFATAL_FAILURE{,_ON_ALL_THREADS} accepts a
+// statement that contains a macro which expands to code containing an
+// unprotected comma.
+TEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
+  EXPECT_NONFATAL_FAILURE({
+    GTEST_USE_UNPROTECTED_COMMA_;
+    AddNonfatalFailure();
+  }, "");
+
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({
+    GTEST_USE_UNPROTECTED_COMMA_;
+    AddNonfatalFailure();
+  }, "");
+}
+
+#if GTEST_IS_THREADSAFE
+
+typedef ScopedFakeTestPartResultReporterWithThreadsTest
+    ExpectFailureWithThreadsTest;
+
+TEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailureOnAllThreads) {
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailureInOtherThread(FATAL_FAILURE),
+                                      "Expected fatal failure.");
+}
+
+TEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailureOnAllThreads) {
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(
+      AddFailureInOtherThread(NONFATAL_FAILURE), "Expected non-fatal failure.");
+}
+
+#endif  // GTEST_IS_THREADSAFE
+
+// Tests the TestProperty class.
+
+TEST(TestPropertyTest, ConstructorWorks) {
+  const TestProperty property("key", "value");
+  EXPECT_STREQ("key", property.key());
+  EXPECT_STREQ("value", property.value());
+}
+
+TEST(TestPropertyTest, SetValue) {
+  TestProperty property("key", "value_1");
+  EXPECT_STREQ("key", property.key());
+  property.SetValue("value_2");
+  EXPECT_STREQ("key", property.key());
+  EXPECT_STREQ("value_2", property.value());
+}
+
+// Tests the TestResult class
+
+// The test fixture for testing TestResult.
+class TestResultTest : public Test {
+ protected:
+  typedef std::vector<TestPartResult> TPRVector;
+
+  // We make use of 2 TestPartResult objects,
+  TestPartResult * pr1, * pr2;
+
+  // ... and 3 TestResult objects.
+  TestResult * r0, * r1, * r2;
+
+  virtual void SetUp() {
+    // pr1 is for success.
+    pr1 = new TestPartResult(TestPartResult::kSuccess,
+                             "foo/bar.cc",
+                             10,
+                             "Success!");
+
+    // pr2 is for fatal failure.
+    pr2 = new TestPartResult(TestPartResult::kFatalFailure,
+                             "foo/bar.cc",
+                             -1,  // This line number means "unknown"
+                             "Failure!");
+
+    // Creates the TestResult objects.
+    r0 = new TestResult();
+    r1 = new TestResult();
+    r2 = new TestResult();
+
+    // In order to test TestResult, we need to modify its internal
+    // state, in particular the TestPartResult vector it holds.
+    // test_part_results() returns a const reference to this vector.
+    // We cast it to a non-const object s.t. it can be modified (yes,
+    // this is a hack).
+    TPRVector* results1 = const_cast<TPRVector*>(
+        &TestResultAccessor::test_part_results(*r1));
+    TPRVector* results2 = const_cast<TPRVector*>(
+        &TestResultAccessor::test_part_results(*r2));
+
+    // r0 is an empty TestResult.
+
+    // r1 contains a single SUCCESS TestPartResult.
+    results1->push_back(*pr1);
+
+    // r2 contains a SUCCESS, and a FAILURE.
+    results2->push_back(*pr1);
+    results2->push_back(*pr2);
+  }
+
+  virtual void TearDown() {
+    delete pr1;
+    delete pr2;
+
+    delete r0;
+    delete r1;
+    delete r2;
+  }
+
+  // Helper that compares two two TestPartResults.
+  static void CompareTestPartResult(const TestPartResult& expected,
+                                    const TestPartResult& actual) {
+    EXPECT_EQ(expected.type(), actual.type());
+    EXPECT_STREQ(expected.file_name(), actual.file_name());
+    EXPECT_EQ(expected.line_number(), actual.line_number());
+    EXPECT_STREQ(expected.summary(), actual.summary());
+    EXPECT_STREQ(expected.message(), actual.message());
+    EXPECT_EQ(expected.passed(), actual.passed());
+    EXPECT_EQ(expected.failed(), actual.failed());
+    EXPECT_EQ(expected.nonfatally_failed(), actual.nonfatally_failed());
+    EXPECT_EQ(expected.fatally_failed(), actual.fatally_failed());
+  }
+};
+
+// Tests TestResult::total_part_count().
+TEST_F(TestResultTest, total_part_count) {
+  ASSERT_EQ(0, r0->total_part_count());
+  ASSERT_EQ(1, r1->total_part_count());
+  ASSERT_EQ(2, r2->total_part_count());
+}
+
+// Tests TestResult::Passed().
+TEST_F(TestResultTest, Passed) {
+  ASSERT_TRUE(r0->Passed());
+  ASSERT_TRUE(r1->Passed());
+  ASSERT_FALSE(r2->Passed());
+}
+
+// Tests TestResult::Failed().
+TEST_F(TestResultTest, Failed) {
+  ASSERT_FALSE(r0->Failed());
+  ASSERT_FALSE(r1->Failed());
+  ASSERT_TRUE(r2->Failed());
+}
+
+// Tests TestResult::GetTestPartResult().
+
+typedef TestResultTest TestResultDeathTest;
+
+TEST_F(TestResultDeathTest, GetTestPartResult) {
+  CompareTestPartResult(*pr1, r2->GetTestPartResult(0));
+  CompareTestPartResult(*pr2, r2->GetTestPartResult(1));
+  EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(2), "");
+  EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(-1), "");
+}
+
+// Tests TestResult has no properties when none are added.
+TEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) {
+  TestResult test_result;
+  ASSERT_EQ(0, test_result.test_property_count());
+}
+
+// Tests TestResult has the expected property when added.
+TEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) {
+  TestResult test_result;
+  TestProperty property("key_1", "1");
+  TestResultAccessor::RecordProperty(&test_result, "testcase", property);
+  ASSERT_EQ(1, test_result.test_property_count());
+  const TestProperty& actual_property = test_result.GetTestProperty(0);
+  EXPECT_STREQ("key_1", actual_property.key());
+  EXPECT_STREQ("1", actual_property.value());
+}
+
+// Tests TestResult has multiple properties when added.
+TEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) {
+  TestResult test_result;
+  TestProperty property_1("key_1", "1");
+  TestProperty property_2("key_2", "2");
+  TestResultAccessor::RecordProperty(&test_result, "testcase", property_1);
+  TestResultAccessor::RecordProperty(&test_result, "testcase", property_2);
+  ASSERT_EQ(2, test_result.test_property_count());
+  const TestProperty& actual_property_1 = test_result.GetTestProperty(0);
+  EXPECT_STREQ("key_1", actual_property_1.key());
+  EXPECT_STREQ("1", actual_property_1.value());
+
+  const TestProperty& actual_property_2 = test_result.GetTestProperty(1);
+  EXPECT_STREQ("key_2", actual_property_2.key());
+  EXPECT_STREQ("2", actual_property_2.value());
+}
+
+// Tests TestResult::RecordProperty() overrides values for duplicate keys.
+TEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) {
+  TestResult test_result;
+  TestProperty property_1_1("key_1", "1");
+  TestProperty property_2_1("key_2", "2");
+  TestProperty property_1_2("key_1", "12");
+  TestProperty property_2_2("key_2", "22");
+  TestResultAccessor::RecordProperty(&test_result, "testcase", property_1_1);
+  TestResultAccessor::RecordProperty(&test_result, "testcase", property_2_1);
+  TestResultAccessor::RecordProperty(&test_result, "testcase", property_1_2);
+  TestResultAccessor::RecordProperty(&test_result, "testcase", property_2_2);
+
+  ASSERT_EQ(2, test_result.test_property_count());
+  const TestProperty& actual_property_1 = test_result.GetTestProperty(0);
+  EXPECT_STREQ("key_1", actual_property_1.key());
+  EXPECT_STREQ("12", actual_property_1.value());
+
+  const TestProperty& actual_property_2 = test_result.GetTestProperty(1);
+  EXPECT_STREQ("key_2", actual_property_2.key());
+  EXPECT_STREQ("22", actual_property_2.value());
+}
+
+// Tests TestResult::GetTestProperty().
+TEST(TestResultPropertyTest, GetTestProperty) {
+  TestResult test_result;
+  TestProperty property_1("key_1", "1");
+  TestProperty property_2("key_2", "2");
+  TestProperty property_3("key_3", "3");
+  TestResultAccessor::RecordProperty(&test_result, "testcase", property_1);
+  TestResultAccessor::RecordProperty(&test_result, "testcase", property_2);
+  TestResultAccessor::RecordProperty(&test_result, "testcase", property_3);
+
+  const TestProperty& fetched_property_1 = test_result.GetTestProperty(0);
+  const TestProperty& fetched_property_2 = test_result.GetTestProperty(1);
+  const TestProperty& fetched_property_3 = test_result.GetTestProperty(2);
+
+  EXPECT_STREQ("key_1", fetched_property_1.key());
+  EXPECT_STREQ("1", fetched_property_1.value());
+
+  EXPECT_STREQ("key_2", fetched_property_2.key());
+  EXPECT_STREQ("2", fetched_property_2.value());
+
+  EXPECT_STREQ("key_3", fetched_property_3.key());
+  EXPECT_STREQ("3", fetched_property_3.value());
+
+  EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(3), "");
+  EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(-1), "");
+}
+
+// Tests the Test class.
+//
+// It's difficult to test every public method of this class (we are
+// already stretching the limit of Google Test by using it to test itself!).
+// Fortunately, we don't have to do that, as we are already testing
+// the functionalities of the Test class extensively by using Google Test
+// alone.
+//
+// Therefore, this section only contains one test.
+
+// Tests that GTestFlagSaver works on Windows and Mac.
+
+class GTestFlagSaverTest : public Test {
+ protected:
+  // Saves the Google Test flags such that we can restore them later, and
+  // then sets them to their default values.  This will be called
+  // before the first test in this test case is run.
+  static void SetUpTestCase() {
+    saver_ = new GTestFlagSaver;
+
+    GTEST_FLAG(also_run_disabled_tests) = false;
+    GTEST_FLAG(break_on_failure) = false;
+    GTEST_FLAG(catch_exceptions) = false;
+    GTEST_FLAG(death_test_use_fork) = false;
+    GTEST_FLAG(color) = "auto";
+    GTEST_FLAG(filter) = "";
+    GTEST_FLAG(list_tests) = false;
+    GTEST_FLAG(output) = "";
+    GTEST_FLAG(print_time) = true;
+    GTEST_FLAG(random_seed) = 0;
+    GTEST_FLAG(repeat) = 1;
+    GTEST_FLAG(shuffle) = false;
+    GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
+    GTEST_FLAG(stream_result_to) = "";
+    GTEST_FLAG(throw_on_failure) = false;
+  }
+
+  // Restores the Google Test flags that the tests have modified.  This will
+  // be called after the last test in this test case is run.
+  static void TearDownTestCase() {
+    delete saver_;
+    saver_ = NULL;
+  }
+
+  // Verifies that the Google Test flags have their default values, and then
+  // modifies each of them.
+  void VerifyAndModifyFlags() {
+    EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests));
+    EXPECT_FALSE(GTEST_FLAG(break_on_failure));
+    EXPECT_FALSE(GTEST_FLAG(catch_exceptions));
+    EXPECT_STREQ("auto", GTEST_FLAG(color).c_str());
+    EXPECT_FALSE(GTEST_FLAG(death_test_use_fork));
+    EXPECT_STREQ("", GTEST_FLAG(filter).c_str());
+    EXPECT_FALSE(GTEST_FLAG(list_tests));
+    EXPECT_STREQ("", GTEST_FLAG(output).c_str());
+    EXPECT_TRUE(GTEST_FLAG(print_time));
+    EXPECT_EQ(0, GTEST_FLAG(random_seed));
+    EXPECT_EQ(1, GTEST_FLAG(repeat));
+    EXPECT_FALSE(GTEST_FLAG(shuffle));
+    EXPECT_EQ(kMaxStackTraceDepth, GTEST_FLAG(stack_trace_depth));
+    EXPECT_STREQ("", GTEST_FLAG(stream_result_to).c_str());
+    EXPECT_FALSE(GTEST_FLAG(throw_on_failure));
+
+    GTEST_FLAG(also_run_disabled_tests) = true;
+    GTEST_FLAG(break_on_failure) = true;
+    GTEST_FLAG(catch_exceptions) = true;
+    GTEST_FLAG(color) = "no";
+    GTEST_FLAG(death_test_use_fork) = true;
+    GTEST_FLAG(filter) = "abc";
+    GTEST_FLAG(list_tests) = true;
+    GTEST_FLAG(output) = "xml:foo.xml";
+    GTEST_FLAG(print_time) = false;
+    GTEST_FLAG(random_seed) = 1;
+    GTEST_FLAG(repeat) = 100;
+    GTEST_FLAG(shuffle) = true;
+    GTEST_FLAG(stack_trace_depth) = 1;
+    GTEST_FLAG(stream_result_to) = "localhost:1234";
+    GTEST_FLAG(throw_on_failure) = true;
+  }
+
+ private:
+  // For saving Google Test flags during this test case.
+  static GTestFlagSaver* saver_;
+};
+
+GTestFlagSaver* GTestFlagSaverTest::saver_ = NULL;
+
+// Google Test doesn't guarantee the order of tests.  The following two
+// tests are designed to work regardless of their order.
+
+// Modifies the Google Test flags in the test body.
+TEST_F(GTestFlagSaverTest, ModifyGTestFlags) {
+  VerifyAndModifyFlags();
+}
+
+// Verifies that the Google Test flags in the body of the previous test were
+// restored to their original values.
+TEST_F(GTestFlagSaverTest, VerifyGTestFlags) {
+  VerifyAndModifyFlags();
+}
+
+// Sets an environment variable with the given name to the given
+// value.  If the value argument is "", unsets the environment
+// variable.  The caller must ensure that both arguments are not NULL.
+static void SetEnv(const char* name, const char* value) {
+#if GTEST_OS_WINDOWS_MOBILE
+  // Environment variables are not supported on Windows CE.
+  return;
+#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
+  // C++Builder's putenv only stores a pointer to its parameter; we have to
+  // ensure that the string remains valid as long as it might be needed.
+  // We use an std::map to do so.
+  static std::map<std::string, std::string*> added_env;
+
+  // Because putenv stores a pointer to the string buffer, we can't delete the
+  // previous string (if present) until after it's replaced.
+  std::string *prev_env = NULL;
+  if (added_env.find(name) != added_env.end()) {
+    prev_env = added_env[name];
+  }
+  added_env[name] = new std::string(
+      (Message() << name << "=" << value).GetString());
+
+  // The standard signature of putenv accepts a 'char*' argument. Other
+  // implementations, like C++Builder's, accept a 'const char*'.
+  // We cast away the 'const' since that would work for both variants.
+  putenv(const_cast<char*>(added_env[name]->c_str()));
+  delete prev_env;
+#elif GTEST_OS_WINDOWS  // If we are on Windows proper.
+  _putenv((Message() << name << "=" << value).GetString().c_str());
+#else
+  if (*value == '\0') {
+    unsetenv(name);
+  } else {
+    setenv(name, value, 1);
+  }
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+#if !GTEST_OS_WINDOWS_MOBILE
+// Environment variables are not supported on Windows CE.
+
+using testing::internal::Int32FromGTestEnv;
+
+// Tests Int32FromGTestEnv().
+
+// Tests that Int32FromGTestEnv() returns the default value when the
+// environment variable is not set.
+TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) {
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "");
+  EXPECT_EQ(10, Int32FromGTestEnv("temp", 10));
+}
+
+# if !defined(GTEST_GET_INT32_FROM_ENV_)
+
+// Tests that Int32FromGTestEnv() returns the default value when the
+// environment variable overflows as an Int32.
+TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) {
+  printf("(expecting 2 warnings)\n");
+
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12345678987654321");
+  EXPECT_EQ(20, Int32FromGTestEnv("temp", 20));
+
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-12345678987654321");
+  EXPECT_EQ(30, Int32FromGTestEnv("temp", 30));
+}
+
+// Tests that Int32FromGTestEnv() returns the default value when the
+// environment variable does not represent a valid decimal integer.
+TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) {
+  printf("(expecting 2 warnings)\n");
+
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "A1");
+  EXPECT_EQ(40, Int32FromGTestEnv("temp", 40));
+
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12X");
+  EXPECT_EQ(50, Int32FromGTestEnv("temp", 50));
+}
+
+# endif  // !defined(GTEST_GET_INT32_FROM_ENV_)
+
+// Tests that Int32FromGTestEnv() parses and returns the value of the
+// environment variable when it represents a valid decimal integer in
+// the range of an Int32.
+TEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) {
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "123");
+  EXPECT_EQ(123, Int32FromGTestEnv("temp", 0));
+
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-321");
+  EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0));
+}
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Tests ParseInt32Flag().
+
+// Tests that ParseInt32Flag() returns false and doesn't change the
+// output value when the flag has wrong format
+TEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) {
+  Int32 value = 123;
+  EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value));
+  EXPECT_EQ(123, value);
+
+  EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value));
+  EXPECT_EQ(123, value);
+}
+
+// Tests that ParseInt32Flag() returns false and doesn't change the
+// output value when the flag overflows as an Int32.
+TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) {
+  printf("(expecting 2 warnings)\n");
+
+  Int32 value = 123;
+  EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value));
+  EXPECT_EQ(123, value);
+
+  EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value));
+  EXPECT_EQ(123, value);
+}
+
+// Tests that ParseInt32Flag() returns false and doesn't change the
+// output value when the flag does not represent a valid decimal
+// integer.
+TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) {
+  printf("(expecting 2 warnings)\n");
+
+  Int32 value = 123;
+  EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value));
+  EXPECT_EQ(123, value);
+
+  EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value));
+  EXPECT_EQ(123, value);
+}
+
+// Tests that ParseInt32Flag() parses the value of the flag and
+// returns true when the flag represents a valid decimal integer in
+// the range of an Int32.
+TEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) {
+  Int32 value = 123;
+  EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value));
+  EXPECT_EQ(456, value);
+
+  EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=-789",
+                             "abc", &value));
+  EXPECT_EQ(-789, value);
+}
+
+// Tests that Int32FromEnvOrDie() parses the value of the var or
+// returns the correct default.
+// Environment variables are not supported on Windows CE.
+#if !GTEST_OS_WINDOWS_MOBILE
+TEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) {
+  EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "123");
+  EXPECT_EQ(123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "-123");
+  EXPECT_EQ(-123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
+}
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Tests that Int32FromEnvOrDie() aborts with an error message
+// if the variable is not an Int32.
+TEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) {
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "xxx");
+  EXPECT_DEATH_IF_SUPPORTED(
+      Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
+      ".*");
+}
+
+// Tests that Int32FromEnvOrDie() aborts with an error message
+// if the variable cannot be represnted by an Int32.
+TEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) {
+  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234");
+  EXPECT_DEATH_IF_SUPPORTED(
+      Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
+      ".*");
+}
+
+// Tests that ShouldRunTestOnShard() selects all tests
+// where there is 1 shard.
+TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) {
+  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 0));
+  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 1));
+  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 2));
+  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 3));
+  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 4));
+}
+
+class ShouldShardTest : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    index_var_ = GTEST_FLAG_PREFIX_UPPER_ "INDEX";
+    total_var_ = GTEST_FLAG_PREFIX_UPPER_ "TOTAL";
+  }
+
+  virtual void TearDown() {
+    SetEnv(index_var_, "");
+    SetEnv(total_var_, "");
+  }
+
+  const char* index_var_;
+  const char* total_var_;
+};
+
+// Tests that sharding is disabled if neither of the environment variables
+// are set.
+TEST_F(ShouldShardTest, ReturnsFalseWhenNeitherEnvVarIsSet) {
+  SetEnv(index_var_, "");
+  SetEnv(total_var_, "");
+
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, false));
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
+}
+
+// Tests that sharding is not enabled if total_shards  == 1.
+TEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) {
+  SetEnv(index_var_, "0");
+  SetEnv(total_var_, "1");
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, false));
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
+}
+
+// Tests that sharding is enabled if total_shards > 1 and
+// we are not in a death test subprocess.
+// Environment variables are not supported on Windows CE.
+#if !GTEST_OS_WINDOWS_MOBILE
+TEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) {
+  SetEnv(index_var_, "4");
+  SetEnv(total_var_, "22");
+  EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
+
+  SetEnv(index_var_, "8");
+  SetEnv(total_var_, "9");
+  EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
+
+  SetEnv(index_var_, "0");
+  SetEnv(total_var_, "9");
+  EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
+  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
+}
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Tests that we exit in error if the sharding values are not valid.
+
+typedef ShouldShardTest ShouldShardDeathTest;
+
+TEST_F(ShouldShardDeathTest, AbortsWhenShardingEnvVarsAreInvalid) {
+  SetEnv(index_var_, "4");
+  SetEnv(total_var_, "4");
+  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
+
+  SetEnv(index_var_, "4");
+  SetEnv(total_var_, "-2");
+  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
+
+  SetEnv(index_var_, "5");
+  SetEnv(total_var_, "");
+  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
+
+  SetEnv(index_var_, "");
+  SetEnv(total_var_, "5");
+  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
+}
+
+// Tests that ShouldRunTestOnShard is a partition when 5
+// shards are used.
+TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) {
+  // Choose an arbitrary number of tests and shards.
+  const int num_tests = 17;
+  const int num_shards = 5;
+
+  // Check partitioning: each test should be on exactly 1 shard.
+  for (int test_id = 0; test_id < num_tests; test_id++) {
+    int prev_selected_shard_index = -1;
+    for (int shard_index = 0; shard_index < num_shards; shard_index++) {
+      if (ShouldRunTestOnShard(num_shards, shard_index, test_id)) {
+        if (prev_selected_shard_index < 0) {
+          prev_selected_shard_index = shard_index;
+        } else {
+          ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and "
+            << shard_index << " are both selected to run test " << test_id;
+        }
+      }
+    }
+  }
+
+  // Check balance: This is not required by the sharding protocol, but is a
+  // desirable property for performance.
+  for (int shard_index = 0; shard_index < num_shards; shard_index++) {
+    int num_tests_on_shard = 0;
+    for (int test_id = 0; test_id < num_tests; test_id++) {
+      num_tests_on_shard +=
+        ShouldRunTestOnShard(num_shards, shard_index, test_id);
+    }
+    EXPECT_GE(num_tests_on_shard, num_tests / num_shards);
+  }
+}
+
+// For the same reason we are not explicitly testing everything in the
+// Test class, there are no separate tests for the following classes
+// (except for some trivial cases):
+//
+//   TestCase, UnitTest, UnitTestResultPrinter.
+//
+// Similarly, there are no separate tests for the following macros:
+//
+//   TEST, TEST_F, RUN_ALL_TESTS
+
+TEST(UnitTestTest, CanGetOriginalWorkingDir) {
+  ASSERT_TRUE(UnitTest::GetInstance()->original_working_dir() != NULL);
+  EXPECT_STRNE(UnitTest::GetInstance()->original_working_dir(), "");
+}
+
+TEST(UnitTestTest, ReturnsPlausibleTimestamp) {
+  EXPECT_LT(0, UnitTest::GetInstance()->start_timestamp());
+  EXPECT_LE(UnitTest::GetInstance()->start_timestamp(), GetTimeInMillis());
+}
+
+// When a property using a reserved key is supplied to this function, it
+// tests that a non-fatal failure is added, a fatal failure is not added,
+// and that the property is not recorded.
+void ExpectNonFatalFailureRecordingPropertyWithReservedKey(
+    const TestResult& test_result, const char* key) {
+  EXPECT_NONFATAL_FAILURE(Test::RecordProperty(key, "1"), "Reserved key");
+  ASSERT_EQ(0, test_result.test_property_count()) << "Property for key '" << key
+                                                  << "' recorded unexpectedly.";
+}
+
+void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
+    const char* key) {
+  const TestInfo* test_info = UnitTest::GetInstance()->current_test_info();
+  ASSERT_TRUE(test_info != NULL);
+  ExpectNonFatalFailureRecordingPropertyWithReservedKey(*test_info->result(),
+                                                        key);
+}
+
+void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
+    const char* key) {
+  const TestCase* test_case = UnitTest::GetInstance()->current_test_case();
+  ASSERT_TRUE(test_case != NULL);
+  ExpectNonFatalFailureRecordingPropertyWithReservedKey(
+      test_case->ad_hoc_test_result(), key);
+}
+
+void ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
+    const char* key) {
+  ExpectNonFatalFailureRecordingPropertyWithReservedKey(
+      UnitTest::GetInstance()->ad_hoc_test_result(), key);
+}
+
+// Tests that property recording functions in UnitTest outside of tests
+// functions correcly.  Creating a separate instance of UnitTest ensures it
+// is in a state similar to the UnitTest's singleton's between tests.
+class UnitTestRecordPropertyTest :
+    public testing::internal::UnitTestRecordPropertyTestHelper {
+ public:
+  static void SetUpTestCase() {
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
+        "disabled");
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
+        "errors");
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
+        "failures");
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
+        "name");
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
+        "tests");
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
+        "time");
+
+    Test::RecordProperty("test_case_key_1", "1");
+    const TestCase* test_case = UnitTest::GetInstance()->current_test_case();
+    ASSERT_TRUE(test_case != NULL);
+
+    ASSERT_EQ(1, test_case->ad_hoc_test_result().test_property_count());
+    EXPECT_STREQ("test_case_key_1",
+                 test_case->ad_hoc_test_result().GetTestProperty(0).key());
+    EXPECT_STREQ("1",
+                 test_case->ad_hoc_test_result().GetTestProperty(0).value());
+  }
+};
+
+// Tests TestResult has the expected property when added.
+TEST_F(UnitTestRecordPropertyTest, OnePropertyFoundWhenAdded) {
+  UnitTestRecordProperty("key_1", "1");
+
+  ASSERT_EQ(1, unit_test_.ad_hoc_test_result().test_property_count());
+
+  EXPECT_STREQ("key_1",
+               unit_test_.ad_hoc_test_result().GetTestProperty(0).key());
+  EXPECT_STREQ("1",
+               unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
+}
+
+// Tests TestResult has multiple properties when added.
+TEST_F(UnitTestRecordPropertyTest, MultiplePropertiesFoundWhenAdded) {
+  UnitTestRecordProperty("key_1", "1");
+  UnitTestRecordProperty("key_2", "2");
+
+  ASSERT_EQ(2, unit_test_.ad_hoc_test_result().test_property_count());
+
+  EXPECT_STREQ("key_1",
+               unit_test_.ad_hoc_test_result().GetTestProperty(0).key());
+  EXPECT_STREQ("1", unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
+
+  EXPECT_STREQ("key_2",
+               unit_test_.ad_hoc_test_result().GetTestProperty(1).key());
+  EXPECT_STREQ("2", unit_test_.ad_hoc_test_result().GetTestProperty(1).value());
+}
+
+// Tests TestResult::RecordProperty() overrides values for duplicate keys.
+TEST_F(UnitTestRecordPropertyTest, OverridesValuesForDuplicateKeys) {
+  UnitTestRecordProperty("key_1", "1");
+  UnitTestRecordProperty("key_2", "2");
+  UnitTestRecordProperty("key_1", "12");
+  UnitTestRecordProperty("key_2", "22");
+
+  ASSERT_EQ(2, unit_test_.ad_hoc_test_result().test_property_count());
+
+  EXPECT_STREQ("key_1",
+               unit_test_.ad_hoc_test_result().GetTestProperty(0).key());
+  EXPECT_STREQ("12",
+               unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
+
+  EXPECT_STREQ("key_2",
+               unit_test_.ad_hoc_test_result().GetTestProperty(1).key());
+  EXPECT_STREQ("22",
+               unit_test_.ad_hoc_test_result().GetTestProperty(1).value());
+}
+
+TEST_F(UnitTestRecordPropertyTest,
+       AddFailureInsideTestsWhenUsingTestCaseReservedKeys) {
+  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
+      "name");
+  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
+      "value_param");
+  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
+      "type_param");
+  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
+      "status");
+  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
+      "time");
+  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
+      "classname");
+}
+
+TEST_F(UnitTestRecordPropertyTest,
+       AddRecordWithReservedKeysGeneratesCorrectPropertyList) {
+  EXPECT_NONFATAL_FAILURE(
+      Test::RecordProperty("name", "1"),
+      "'classname', 'name', 'status', 'time', 'type_param', and 'value_param'"
+      " are reserved");
+}
+
+class UnitTestRecordPropertyTestEnvironment : public Environment {
+ public:
+  virtual void TearDown() {
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
+        "tests");
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
+        "failures");
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
+        "disabled");
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
+        "errors");
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
+        "name");
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
+        "timestamp");
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
+        "time");
+    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
+        "random_seed");
+  }
+};
+
+// This will test property recording outside of any test or test case.
+static Environment* record_property_env =
+    AddGlobalTestEnvironment(new UnitTestRecordPropertyTestEnvironment);
+
+// This group of tests is for predicate assertions (ASSERT_PRED*, etc)
+// of various arities.  They do not attempt to be exhaustive.  Rather,
+// view them as smoke tests that can be easily reviewed and verified.
+// A more complete set of tests for predicate assertions can be found
+// in gtest_pred_impl_unittest.cc.
+
+// First, some predicates and predicate-formatters needed by the tests.
+
+// Returns true iff the argument is an even number.
+bool IsEven(int n) {
+  return (n % 2) == 0;
+}
+
+// A functor that returns true iff the argument is an even number.
+struct IsEvenFunctor {
+  bool operator()(int n) { return IsEven(n); }
+};
+
+// A predicate-formatter function that asserts the argument is an even
+// number.
+AssertionResult AssertIsEven(const char* expr, int n) {
+  if (IsEven(n)) {
+    return AssertionSuccess();
+  }
+
+  Message msg;
+  msg << expr << " evaluates to " << n << ", which is not even.";
+  return AssertionFailure(msg);
+}
+
+// A predicate function that returns AssertionResult for use in
+// EXPECT/ASSERT_TRUE/FALSE.
+AssertionResult ResultIsEven(int n) {
+  if (IsEven(n))
+    return AssertionSuccess() << n << " is even";
+  else
+    return AssertionFailure() << n << " is odd";
+}
+
+// A predicate function that returns AssertionResult but gives no
+// explanation why it succeeds. Needed for testing that
+// EXPECT/ASSERT_FALSE handles such functions correctly.
+AssertionResult ResultIsEvenNoExplanation(int n) {
+  if (IsEven(n))
+    return AssertionSuccess();
+  else
+    return AssertionFailure() << n << " is odd";
+}
+
+// A predicate-formatter functor that asserts the argument is an even
+// number.
+struct AssertIsEvenFunctor {
+  AssertionResult operator()(const char* expr, int n) {
+    return AssertIsEven(expr, n);
+  }
+};
+
+// Returns true iff the sum of the arguments is an even number.
+bool SumIsEven2(int n1, int n2) {
+  return IsEven(n1 + n2);
+}
+
+// A functor that returns true iff the sum of the arguments is an even
+// number.
+struct SumIsEven3Functor {
+  bool operator()(int n1, int n2, int n3) {
+    return IsEven(n1 + n2 + n3);
+  }
+};
+
+// A predicate-formatter function that asserts the sum of the
+// arguments is an even number.
+AssertionResult AssertSumIsEven4(
+    const char* e1, const char* e2, const char* e3, const char* e4,
+    int n1, int n2, int n3, int n4) {
+  const int sum = n1 + n2 + n3 + n4;
+  if (IsEven(sum)) {
+    return AssertionSuccess();
+  }
+
+  Message msg;
+  msg << e1 << " + " << e2 << " + " << e3 << " + " << e4
+      << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4
+      << ") evaluates to " << sum << ", which is not even.";
+  return AssertionFailure(msg);
+}
+
+// A predicate-formatter functor that asserts the sum of the arguments
+// is an even number.
+struct AssertSumIsEven5Functor {
+  AssertionResult operator()(
+      const char* e1, const char* e2, const char* e3, const char* e4,
+      const char* e5, int n1, int n2, int n3, int n4, int n5) {
+    const int sum = n1 + n2 + n3 + n4 + n5;
+    if (IsEven(sum)) {
+      return AssertionSuccess();
+    }
+
+    Message msg;
+    msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
+        << " ("
+        << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5
+        << ") evaluates to " << sum << ", which is not even.";
+    return AssertionFailure(msg);
+  }
+};
+
+
+// Tests unary predicate assertions.
+
+// Tests unary predicate assertions that don't use a custom formatter.
+TEST(Pred1Test, WithoutFormat) {
+  // Success cases.
+  EXPECT_PRED1(IsEvenFunctor(), 2) << "This failure is UNEXPECTED!";
+  ASSERT_PRED1(IsEven, 4);
+
+  // Failure cases.
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED1(IsEven, 5) << "This failure is expected.";
+  }, "This failure is expected.");
+  EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5),
+                       "evaluates to false");
+}
+
+// Tests unary predicate assertions that use a custom formatter.
+TEST(Pred1Test, WithFormat) {
+  // Success cases.
+  EXPECT_PRED_FORMAT1(AssertIsEven, 2);
+  ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4)
+    << "This failure is UNEXPECTED!";
+
+  // Failure cases.
+  const int n = 5;
+  EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n),
+                          "n evaluates to 5, which is not even.");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected.";
+  }, "This failure is expected.");
+}
+
+// Tests that unary predicate assertions evaluates their arguments
+// exactly once.
+TEST(Pred1Test, SingleEvaluationOnFailure) {
+  // A success case.
+  static int n = 0;
+  EXPECT_PRED1(IsEven, n++);
+  EXPECT_EQ(1, n) << "The argument is not evaluated exactly once.";
+
+  // A failure case.
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++)
+        << "This failure is expected.";
+  }, "This failure is expected.");
+  EXPECT_EQ(2, n) << "The argument is not evaluated exactly once.";
+}
+
+
+// Tests predicate assertions whose arity is >= 2.
+
+// Tests predicate assertions that don't use a custom formatter.
+TEST(PredTest, WithoutFormat) {
+  // Success cases.
+  ASSERT_PRED2(SumIsEven2, 2, 4) << "This failure is UNEXPECTED!";
+  EXPECT_PRED3(SumIsEven3Functor(), 4, 6, 8);
+
+  // Failure cases.
+  const int n1 = 1;
+  const int n2 = 2;
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected.";
+  }, "This failure is expected.");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4);
+  }, "evaluates to false");
+}
+
+// Tests predicate assertions that use a custom formatter.
+TEST(PredTest, WithFormat) {
+  // Success cases.
+  ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) <<
+    "This failure is UNEXPECTED!";
+  EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10);
+
+  // Failure cases.
+  const int n1 = 1;
+  const int n2 = 2;
+  const int n3 = 4;
+  const int n4 = 6;
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4);
+  }, "evaluates to 13, which is not even.");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8)
+        << "This failure is expected.";
+  }, "This failure is expected.");
+}
+
+// Tests that predicate assertions evaluates their arguments
+// exactly once.
+TEST(PredTest, SingleEvaluationOnFailure) {
+  // A success case.
+  int n1 = 0;
+  int n2 = 0;
+  EXPECT_PRED2(SumIsEven2, n1++, n2++);
+  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
+  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
+
+  // Another success case.
+  n1 = n2 = 0;
+  int n3 = 0;
+  int n4 = 0;
+  int n5 = 0;
+  ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(),
+                      n1++, n2++, n3++, n4++, n5++)
+                        << "This failure is UNEXPECTED!";
+  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
+  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
+  EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
+  EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once.";
+  EXPECT_EQ(1, n5) << "Argument 5 is not evaluated exactly once.";
+
+  // A failure case.
+  n1 = n2 = n3 = 0;
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++)
+        << "This failure is expected.";
+  }, "This failure is expected.");
+  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
+  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
+  EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
+
+  // Another failure case.
+  n1 = n2 = n3 = n4 = 0;
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++);
+  }, "evaluates to 1, which is not even.");
+  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
+  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
+  EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
+  EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once.";
+}
+
+
+// Some helper functions for testing using overloaded/template
+// functions with ASSERT_PREDn and EXPECT_PREDn.
+
+bool IsPositive(double x) {
+  return x > 0;
+}
+
+template <typename T>
+bool IsNegative(T x) {
+  return x < 0;
+}
+
+template <typename T1, typename T2>
+bool GreaterThan(T1 x1, T2 x2) {
+  return x1 > x2;
+}
+
+// Tests that overloaded functions can be used in *_PRED* as long as
+// their types are explicitly specified.
+TEST(PredicateAssertionTest, AcceptsOverloadedFunction) {
+  // C++Builder requires C-style casts rather than static_cast.
+  EXPECT_PRED1((bool (*)(int))(IsPositive), 5);  // NOLINT
+  ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0);  // NOLINT
+}
+
+// Tests that template functions can be used in *_PRED* as long as
+// their types are explicitly specified.
+TEST(PredicateAssertionTest, AcceptsTemplateFunction) {
+  EXPECT_PRED1(IsNegative<int>, -5);
+  // Makes sure that we can handle templates with more than one
+  // parameter.
+  ASSERT_PRED2((GreaterThan<int, int>), 5, 0);
+}
+
+
+// Some helper functions for testing using overloaded/template
+// functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn.
+
+AssertionResult IsPositiveFormat(const char* /* expr */, int n) {
+  return n > 0 ? AssertionSuccess() :
+      AssertionFailure(Message() << "Failure");
+}
+
+AssertionResult IsPositiveFormat(const char* /* expr */, double x) {
+  return x > 0 ? AssertionSuccess() :
+      AssertionFailure(Message() << "Failure");
+}
+
+template <typename T>
+AssertionResult IsNegativeFormat(const char* /* expr */, T x) {
+  return x < 0 ? AssertionSuccess() :
+      AssertionFailure(Message() << "Failure");
+}
+
+template <typename T1, typename T2>
+AssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */,
+                             const T1& x1, const T2& x2) {
+  return x1 == x2 ? AssertionSuccess() :
+      AssertionFailure(Message() << "Failure");
+}
+
+// Tests that overloaded functions can be used in *_PRED_FORMAT*
+// without explicitly specifying their types.
+TEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) {
+  EXPECT_PRED_FORMAT1(IsPositiveFormat, 5);
+  ASSERT_PRED_FORMAT1(IsPositiveFormat, 6.0);
+}
+
+// Tests that template functions can be used in *_PRED_FORMAT* without
+// explicitly specifying their types.
+TEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) {
+  EXPECT_PRED_FORMAT1(IsNegativeFormat, -5);
+  ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3);
+}
+
+
+// Tests string assertions.
+
+// Tests ASSERT_STREQ with non-NULL arguments.
+TEST(StringAssertionTest, ASSERT_STREQ) {
+  const char * const p1 = "good";
+  ASSERT_STREQ(p1, p1);
+
+  // Let p2 have the same content as p1, but be at a different address.
+  const char p2[] = "good";
+  ASSERT_STREQ(p1, p2);
+
+  EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"),
+                       "Expected: \"bad\"");
+}
+
+// Tests ASSERT_STREQ with NULL arguments.
+TEST(StringAssertionTest, ASSERT_STREQ_Null) {
+  ASSERT_STREQ(static_cast<const char *>(NULL), NULL);
+  EXPECT_FATAL_FAILURE(ASSERT_STREQ(NULL, "non-null"),
+                       "non-null");
+}
+
+// Tests ASSERT_STREQ with NULL arguments.
+TEST(StringAssertionTest, ASSERT_STREQ_Null2) {
+  EXPECT_FATAL_FAILURE(ASSERT_STREQ("non-null", NULL),
+                       "non-null");
+}
+
+// Tests ASSERT_STRNE.
+TEST(StringAssertionTest, ASSERT_STRNE) {
+  ASSERT_STRNE("hi", "Hi");
+  ASSERT_STRNE("Hi", NULL);
+  ASSERT_STRNE(NULL, "Hi");
+  ASSERT_STRNE("", NULL);
+  ASSERT_STRNE(NULL, "");
+  ASSERT_STRNE("", "Hi");
+  ASSERT_STRNE("Hi", "");
+  EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"),
+                       "\"Hi\" vs \"Hi\"");
+}
+
+// Tests ASSERT_STRCASEEQ.
+TEST(StringAssertionTest, ASSERT_STRCASEEQ) {
+  ASSERT_STRCASEEQ("hi", "Hi");
+  ASSERT_STRCASEEQ(static_cast<const char *>(NULL), NULL);
+
+  ASSERT_STRCASEEQ("", "");
+  EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"),
+                       "Ignoring case");
+}
+
+// Tests ASSERT_STRCASENE.
+TEST(StringAssertionTest, ASSERT_STRCASENE) {
+  ASSERT_STRCASENE("hi1", "Hi2");
+  ASSERT_STRCASENE("Hi", NULL);
+  ASSERT_STRCASENE(NULL, "Hi");
+  ASSERT_STRCASENE("", NULL);
+  ASSERT_STRCASENE(NULL, "");
+  ASSERT_STRCASENE("", "Hi");
+  ASSERT_STRCASENE("Hi", "");
+  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"),
+                       "(ignoring case)");
+}
+
+// Tests *_STREQ on wide strings.
+TEST(StringAssertionTest, STREQ_Wide) {
+  // NULL strings.
+  ASSERT_STREQ(static_cast<const wchar_t *>(NULL), NULL);
+
+  // Empty strings.
+  ASSERT_STREQ(L"", L"");
+
+  // Non-null vs NULL.
+  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"non-null", NULL),
+                          "non-null");
+
+  // Equal strings.
+  EXPECT_STREQ(L"Hi", L"Hi");
+
+  // Unequal strings.
+  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"),
+                          "Abc");
+
+  // Strings containing wide characters.
+  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"),
+                          "abc");
+
+  // The streaming variation.
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_STREQ(L"abc\x8119", L"abc\x8121") << "Expected failure";
+  }, "Expected failure");
+}
+
+// Tests *_STRNE on wide strings.
+TEST(StringAssertionTest, STRNE_Wide) {
+  // NULL strings.
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_STRNE(static_cast<const wchar_t *>(NULL), NULL);
+  }, "");
+
+  // Empty strings.
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""),
+                          "L\"\"");
+
+  // Non-null vs NULL.
+  ASSERT_STRNE(L"non-null", NULL);
+
+  // Equal strings.
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"),
+                          "L\"Hi\"");
+
+  // Unequal strings.
+  EXPECT_STRNE(L"abc", L"Abc");
+
+  // Strings containing wide characters.
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"),
+                          "abc");
+
+  // The streaming variation.
+  ASSERT_STRNE(L"abc\x8119", L"abc\x8120") << "This shouldn't happen";
+}
+
+// Tests for ::testing::IsSubstring().
+
+// Tests that IsSubstring() returns the correct result when the input
+// argument type is const char*.
+TEST(IsSubstringTest, ReturnsCorrectResultForCString) {
+  EXPECT_FALSE(IsSubstring("", "", NULL, "a"));
+  EXPECT_FALSE(IsSubstring("", "", "b", NULL));
+  EXPECT_FALSE(IsSubstring("", "", "needle", "haystack"));
+
+  EXPECT_TRUE(IsSubstring("", "", static_cast<const char*>(NULL), NULL));
+  EXPECT_TRUE(IsSubstring("", "", "needle", "two needles"));
+}
+
+// Tests that IsSubstring() returns the correct result when the input
+// argument type is const wchar_t*.
+TEST(IsSubstringTest, ReturnsCorrectResultForWideCString) {
+  EXPECT_FALSE(IsSubstring("", "", kNull, L"a"));
+  EXPECT_FALSE(IsSubstring("", "", L"b", kNull));
+  EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack"));
+
+  EXPECT_TRUE(IsSubstring("", "", static_cast<const wchar_t*>(NULL), NULL));
+  EXPECT_TRUE(IsSubstring("", "", L"needle", L"two needles"));
+}
+
+// Tests that IsSubstring() generates the correct message when the input
+// argument type is const char*.
+TEST(IsSubstringTest, GeneratesCorrectMessageForCString) {
+  EXPECT_STREQ("Value of: needle_expr\n"
+               "  Actual: \"needle\"\n"
+               "Expected: a substring of haystack_expr\n"
+               "Which is: \"haystack\"",
+               IsSubstring("needle_expr", "haystack_expr",
+                           "needle", "haystack").failure_message());
+}
+
+// Tests that IsSubstring returns the correct result when the input
+// argument type is ::std::string.
+TEST(IsSubstringTest, ReturnsCorrectResultsForStdString) {
+  EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob"));
+  EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world")));
+}
+
+#if GTEST_HAS_STD_WSTRING
+// Tests that IsSubstring returns the correct result when the input
+// argument type is ::std::wstring.
+TEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) {
+  EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles"));
+  EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack")));
+}
+
+// Tests that IsSubstring() generates the correct message when the input
+// argument type is ::std::wstring.
+TEST(IsSubstringTest, GeneratesCorrectMessageForWstring) {
+  EXPECT_STREQ("Value of: needle_expr\n"
+               "  Actual: L\"needle\"\n"
+               "Expected: a substring of haystack_expr\n"
+               "Which is: L\"haystack\"",
+               IsSubstring(
+                   "needle_expr", "haystack_expr",
+                   ::std::wstring(L"needle"), L"haystack").failure_message());
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Tests for ::testing::IsNotSubstring().
+
+// Tests that IsNotSubstring() returns the correct result when the input
+// argument type is const char*.
+TEST(IsNotSubstringTest, ReturnsCorrectResultForCString) {
+  EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack"));
+  EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles"));
+}
+
+// Tests that IsNotSubstring() returns the correct result when the input
+// argument type is const wchar_t*.
+TEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) {
+  EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack"));
+  EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles"));
+}
+
+// Tests that IsNotSubstring() generates the correct message when the input
+// argument type is const wchar_t*.
+TEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) {
+  EXPECT_STREQ("Value of: needle_expr\n"
+               "  Actual: L\"needle\"\n"
+               "Expected: not a substring of haystack_expr\n"
+               "Which is: L\"two needles\"",
+               IsNotSubstring(
+                   "needle_expr", "haystack_expr",
+                   L"needle", L"two needles").failure_message());
+}
+
+// Tests that IsNotSubstring returns the correct result when the input
+// argument type is ::std::string.
+TEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) {
+  EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob"));
+  EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world")));
+}
+
+// Tests that IsNotSubstring() generates the correct message when the input
+// argument type is ::std::string.
+TEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) {
+  EXPECT_STREQ("Value of: needle_expr\n"
+               "  Actual: \"needle\"\n"
+               "Expected: not a substring of haystack_expr\n"
+               "Which is: \"two needles\"",
+               IsNotSubstring(
+                   "needle_expr", "haystack_expr",
+                   ::std::string("needle"), "two needles").failure_message());
+}
+
+#if GTEST_HAS_STD_WSTRING
+
+// Tests that IsNotSubstring returns the correct result when the input
+// argument type is ::std::wstring.
+TEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) {
+  EXPECT_FALSE(
+      IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles"));
+  EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack")));
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Tests floating-point assertions.
+
+template <typename RawType>
+class FloatingPointTest : public Test {
+ protected:
+  // Pre-calculated numbers to be used by the tests.
+  struct TestValues {
+    RawType close_to_positive_zero;
+    RawType close_to_negative_zero;
+    RawType further_from_negative_zero;
+
+    RawType close_to_one;
+    RawType further_from_one;
+
+    RawType infinity;
+    RawType close_to_infinity;
+    RawType further_from_infinity;
+
+    RawType nan1;
+    RawType nan2;
+  };
+
+  typedef typename testing::internal::FloatingPoint<RawType> Floating;
+  typedef typename Floating::Bits Bits;
+
+  virtual void SetUp() {
+    const size_t max_ulps = Floating::kMaxUlps;
+
+    // The bits that represent 0.0.
+    const Bits zero_bits = Floating(0).bits();
+
+    // Makes some numbers close to 0.0.
+    values_.close_to_positive_zero = Floating::ReinterpretBits(
+        zero_bits + max_ulps/2);
+    values_.close_to_negative_zero = -Floating::ReinterpretBits(
+        zero_bits + max_ulps - max_ulps/2);
+    values_.further_from_negative_zero = -Floating::ReinterpretBits(
+        zero_bits + max_ulps + 1 - max_ulps/2);
+
+    // The bits that represent 1.0.
+    const Bits one_bits = Floating(1).bits();
+
+    // Makes some numbers close to 1.0.
+    values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps);
+    values_.further_from_one = Floating::ReinterpretBits(
+        one_bits + max_ulps + 1);
+
+    // +infinity.
+    values_.infinity = Floating::Infinity();
+
+    // The bits that represent +infinity.
+    const Bits infinity_bits = Floating(values_.infinity).bits();
+
+    // Makes some numbers close to infinity.
+    values_.close_to_infinity = Floating::ReinterpretBits(
+        infinity_bits - max_ulps);
+    values_.further_from_infinity = Floating::ReinterpretBits(
+        infinity_bits - max_ulps - 1);
+
+    // Makes some NAN's.  Sets the most significant bit of the fraction so that
+    // our NaN's are quiet; trying to process a signaling NaN would raise an
+    // exception if our environment enables floating point exceptions.
+    values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask
+        | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1);
+    values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask
+        | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200);
+  }
+
+  void TestSize() {
+    EXPECT_EQ(sizeof(RawType), sizeof(Bits));
+  }
+
+  static TestValues values_;
+};
+
+template <typename RawType>
+typename FloatingPointTest<RawType>::TestValues
+    FloatingPointTest<RawType>::values_;
+
+// Instantiates FloatingPointTest for testing *_FLOAT_EQ.
+typedef FloatingPointTest<float> FloatTest;
+
+// Tests that the size of Float::Bits matches the size of float.
+TEST_F(FloatTest, Size) {
+  TestSize();
+}
+
+// Tests comparing with +0 and -0.
+TEST_F(FloatTest, Zeros) {
+  EXPECT_FLOAT_EQ(0.0, -0.0);
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0),
+                          "1.0");
+  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5),
+                       "1.5");
+}
+
+// Tests comparing numbers close to 0.
+//
+// This ensures that *_FLOAT_EQ handles the sign correctly and no
+// overflow occurs when comparing numbers whose absolute value is very
+// small.
+TEST_F(FloatTest, AlmostZeros) {
+  // In C++Builder, names within local classes (such as used by
+  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
+  // scoping class.  Use a static local alias as a workaround.
+  // We use the assignment syntax since some compilers, like Sun Studio,
+  // don't allow initializing references using construction syntax
+  // (parentheses).
+  static const FloatTest::TestValues& v = this->values_;
+
+  EXPECT_FLOAT_EQ(0.0, v.close_to_positive_zero);
+  EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero);
+  EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
+
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_FLOAT_EQ(v.close_to_positive_zero,
+                    v.further_from_negative_zero);
+  }, "v.further_from_negative_zero");
+}
+
+// Tests comparing numbers close to each other.
+TEST_F(FloatTest, SmallDiff) {
+  EXPECT_FLOAT_EQ(1.0, values_.close_to_one);
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, values_.further_from_one),
+                          "values_.further_from_one");
+}
+
+// Tests comparing numbers far apart.
+TEST_F(FloatTest, LargeDiff) {
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0),
+                          "3.0");
+}
+
+// Tests comparing with infinity.
+//
+// This ensures that no overflow occurs when comparing numbers whose
+// absolute value is very large.
+TEST_F(FloatTest, Infinity) {
+  EXPECT_FLOAT_EQ(values_.infinity, values_.close_to_infinity);
+  EXPECT_FLOAT_EQ(-values_.infinity, -values_.close_to_infinity);
+#if !GTEST_OS_SYMBIAN
+  // Nokia's STLport crashes if we try to output infinity or NaN.
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, -values_.infinity),
+                          "-values_.infinity");
+
+  // This is interesting as the representations of infinity and nan1
+  // are only 1 DLP apart.
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, values_.nan1),
+                          "values_.nan1");
+#endif  // !GTEST_OS_SYMBIAN
+}
+
+// Tests that comparing with NAN always returns false.
+TEST_F(FloatTest, NaN) {
+#if !GTEST_OS_SYMBIAN
+// Nokia's STLport crashes if we try to output infinity or NaN.
+
+  // In C++Builder, names within local classes (such as used by
+  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
+  // scoping class.  Use a static local alias as a workaround.
+  // We use the assignment syntax since some compilers, like Sun Studio,
+  // don't allow initializing references using construction syntax
+  // (parentheses).
+  static const FloatTest::TestValues& v = this->values_;
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1),
+                          "v.nan1");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2),
+                          "v.nan2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1),
+                          "v.nan1");
+
+  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity),
+                       "v.infinity");
+#endif  // !GTEST_OS_SYMBIAN
+}
+
+// Tests that *_FLOAT_EQ are reflexive.
+TEST_F(FloatTest, Reflexive) {
+  EXPECT_FLOAT_EQ(0.0, 0.0);
+  EXPECT_FLOAT_EQ(1.0, 1.0);
+  ASSERT_FLOAT_EQ(values_.infinity, values_.infinity);
+}
+
+// Tests that *_FLOAT_EQ are commutative.
+TEST_F(FloatTest, Commutative) {
+  // We already tested EXPECT_FLOAT_EQ(1.0, values_.close_to_one).
+  EXPECT_FLOAT_EQ(values_.close_to_one, 1.0);
+
+  // We already tested EXPECT_FLOAT_EQ(1.0, values_.further_from_one).
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.further_from_one, 1.0),
+                          "1.0");
+}
+
+// Tests EXPECT_NEAR.
+TEST_F(FloatTest, EXPECT_NEAR) {
+  EXPECT_NEAR(-1.0f, -1.1f, 0.2f);
+  EXPECT_NEAR(2.0f, 3.0f, 1.0f);
+  EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f,1.5f, 0.25f),  // NOLINT
+                          "The difference between 1.0f and 1.5f is 0.5, "
+                          "which exceeds 0.25f");
+  // To work around a bug in gcc 2.95.0, there is intentionally no
+  // space after the first comma in the previous line.
+}
+
+// Tests ASSERT_NEAR.
+TEST_F(FloatTest, ASSERT_NEAR) {
+  ASSERT_NEAR(-1.0f, -1.1f, 0.2f);
+  ASSERT_NEAR(2.0f, 3.0f, 1.0f);
+  EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0f,1.5f, 0.25f),  // NOLINT
+                       "The difference between 1.0f and 1.5f is 0.5, "
+                       "which exceeds 0.25f");
+  // To work around a bug in gcc 2.95.0, there is intentionally no
+  // space after the first comma in the previous line.
+}
+
+// Tests the cases where FloatLE() should succeed.
+TEST_F(FloatTest, FloatLESucceeds) {
+  EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f);  // When val1 < val2,
+  ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f);  // val1 == val2,
+
+  // or when val1 is greater than, but almost equals to, val2.
+  EXPECT_PRED_FORMAT2(FloatLE, values_.close_to_positive_zero, 0.0f);
+}
+
+// Tests the cases where FloatLE() should fail.
+TEST_F(FloatTest, FloatLEFails) {
+  // When val1 is greater than val2 by a large margin,
+  EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f),
+                          "(2.0f) <= (1.0f)");
+
+  // or by a small yet non-negligible margin,
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f);
+  }, "(values_.further_from_one) <= (1.0f)");
+
+#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
+  // Nokia's STLport crashes if we try to output infinity or NaN.
+  // C++Builder gives bad results for ordered comparisons involving NaNs
+  // due to compiler bugs.
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity);
+  }, "(values_.nan1) <= (values_.infinity)");
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1);
+  }, "(-values_.infinity) <= (values_.nan1)");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1);
+  }, "(values_.nan1) <= (values_.nan1)");
+#endif  // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
+}
+
+// Instantiates FloatingPointTest for testing *_DOUBLE_EQ.
+typedef FloatingPointTest<double> DoubleTest;
+
+// Tests that the size of Double::Bits matches the size of double.
+TEST_F(DoubleTest, Size) {
+  TestSize();
+}
+
+// Tests comparing with +0 and -0.
+TEST_F(DoubleTest, Zeros) {
+  EXPECT_DOUBLE_EQ(0.0, -0.0);
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0),
+                          "1.0");
+  EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0),
+                       "1.0");
+}
+
+// Tests comparing numbers close to 0.
+//
+// This ensures that *_DOUBLE_EQ handles the sign correctly and no
+// overflow occurs when comparing numbers whose absolute value is very
+// small.
+TEST_F(DoubleTest, AlmostZeros) {
+  // In C++Builder, names within local classes (such as used by
+  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
+  // scoping class.  Use a static local alias as a workaround.
+  // We use the assignment syntax since some compilers, like Sun Studio,
+  // don't allow initializing references using construction syntax
+  // (parentheses).
+  static const DoubleTest::TestValues& v = this->values_;
+
+  EXPECT_DOUBLE_EQ(0.0, v.close_to_positive_zero);
+  EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero);
+  EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
+
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_DOUBLE_EQ(v.close_to_positive_zero,
+                     v.further_from_negative_zero);
+  }, "v.further_from_negative_zero");
+}
+
+// Tests comparing numbers close to each other.
+TEST_F(DoubleTest, SmallDiff) {
+  EXPECT_DOUBLE_EQ(1.0, values_.close_to_one);
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, values_.further_from_one),
+                          "values_.further_from_one");
+}
+
+// Tests comparing numbers far apart.
+TEST_F(DoubleTest, LargeDiff) {
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0),
+                          "3.0");
+}
+
+// Tests comparing with infinity.
+//
+// This ensures that no overflow occurs when comparing numbers whose
+// absolute value is very large.
+TEST_F(DoubleTest, Infinity) {
+  EXPECT_DOUBLE_EQ(values_.infinity, values_.close_to_infinity);
+  EXPECT_DOUBLE_EQ(-values_.infinity, -values_.close_to_infinity);
+#if !GTEST_OS_SYMBIAN
+  // Nokia's STLport crashes if we try to output infinity or NaN.
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, -values_.infinity),
+                          "-values_.infinity");
+
+  // This is interesting as the representations of infinity_ and nan1_
+  // are only 1 DLP apart.
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, values_.nan1),
+                          "values_.nan1");
+#endif  // !GTEST_OS_SYMBIAN
+}
+
+// Tests that comparing with NAN always returns false.
+TEST_F(DoubleTest, NaN) {
+#if !GTEST_OS_SYMBIAN
+  // In C++Builder, names within local classes (such as used by
+  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
+  // scoping class.  Use a static local alias as a workaround.
+  // We use the assignment syntax since some compilers, like Sun Studio,
+  // don't allow initializing references using construction syntax
+  // (parentheses).
+  static const DoubleTest::TestValues& v = this->values_;
+
+  // Nokia's STLport crashes if we try to output infinity or NaN.
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1),
+                          "v.nan1");
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1");
+  EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity),
+                       "v.infinity");
+#endif  // !GTEST_OS_SYMBIAN
+}
+
+// Tests that *_DOUBLE_EQ are reflexive.
+TEST_F(DoubleTest, Reflexive) {
+  EXPECT_DOUBLE_EQ(0.0, 0.0);
+  EXPECT_DOUBLE_EQ(1.0, 1.0);
+#if !GTEST_OS_SYMBIAN
+  // Nokia's STLport crashes if we try to output infinity or NaN.
+  ASSERT_DOUBLE_EQ(values_.infinity, values_.infinity);
+#endif  // !GTEST_OS_SYMBIAN
+}
+
+// Tests that *_DOUBLE_EQ are commutative.
+TEST_F(DoubleTest, Commutative) {
+  // We already tested EXPECT_DOUBLE_EQ(1.0, values_.close_to_one).
+  EXPECT_DOUBLE_EQ(values_.close_to_one, 1.0);
+
+  // We already tested EXPECT_DOUBLE_EQ(1.0, values_.further_from_one).
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.further_from_one, 1.0),
+                          "1.0");
+}
+
+// Tests EXPECT_NEAR.
+TEST_F(DoubleTest, EXPECT_NEAR) {
+  EXPECT_NEAR(-1.0, -1.1, 0.2);
+  EXPECT_NEAR(2.0, 3.0, 1.0);
+  EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.5, 0.25),  // NOLINT
+                          "The difference between 1.0 and 1.5 is 0.5, "
+                          "which exceeds 0.25");
+  // To work around a bug in gcc 2.95.0, there is intentionally no
+  // space after the first comma in the previous statement.
+}
+
+// Tests ASSERT_NEAR.
+TEST_F(DoubleTest, ASSERT_NEAR) {
+  ASSERT_NEAR(-1.0, -1.1, 0.2);
+  ASSERT_NEAR(2.0, 3.0, 1.0);
+  EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.5, 0.25),  // NOLINT
+                       "The difference between 1.0 and 1.5 is 0.5, "
+                       "which exceeds 0.25");
+  // To work around a bug in gcc 2.95.0, there is intentionally no
+  // space after the first comma in the previous statement.
+}
+
+// Tests the cases where DoubleLE() should succeed.
+TEST_F(DoubleTest, DoubleLESucceeds) {
+  EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0);  // When val1 < val2,
+  ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0);  // val1 == val2,
+
+  // or when val1 is greater than, but almost equals to, val2.
+  EXPECT_PRED_FORMAT2(DoubleLE, values_.close_to_positive_zero, 0.0);
+}
+
+// Tests the cases where DoubleLE() should fail.
+TEST_F(DoubleTest, DoubleLEFails) {
+  // When val1 is greater than val2 by a large margin,
+  EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0),
+                          "(2.0) <= (1.0)");
+
+  // or by a small yet non-negligible margin,
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0);
+  }, "(values_.further_from_one) <= (1.0)");
+
+#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
+  // Nokia's STLport crashes if we try to output infinity or NaN.
+  // C++Builder gives bad results for ordered comparisons involving NaNs
+  // due to compiler bugs.
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity);
+  }, "(values_.nan1) <= (values_.infinity)");
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1);
+  }, " (-values_.infinity) <= (values_.nan1)");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1);
+  }, "(values_.nan1) <= (values_.nan1)");
+#endif  // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
+}
+
+
+// Verifies that a test or test case whose name starts with DISABLED_ is
+// not run.
+
+// A test whose name starts with DISABLED_.
+// Should not run.
+TEST(DisabledTest, DISABLED_TestShouldNotRun) {
+  FAIL() << "Unexpected failure: Disabled test should not be run.";
+}
+
+// A test whose name does not start with DISABLED_.
+// Should run.
+TEST(DisabledTest, NotDISABLED_TestShouldRun) {
+  EXPECT_EQ(1, 1);
+}
+
+// A test case whose name starts with DISABLED_.
+// Should not run.
+TEST(DISABLED_TestCase, TestShouldNotRun) {
+  FAIL() << "Unexpected failure: Test in disabled test case should not be run.";
+}
+
+// A test case and test whose names start with DISABLED_.
+// Should not run.
+TEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) {
+  FAIL() << "Unexpected failure: Test in disabled test case should not be run.";
+}
+
+// Check that when all tests in a test case are disabled, SetupTestCase() and
+// TearDownTestCase() are not called.
+class DisabledTestsTest : public Test {
+ protected:
+  static void SetUpTestCase() {
+    FAIL() << "Unexpected failure: All tests disabled in test case. "
+              "SetupTestCase() should not be called.";
+  }
+
+  static void TearDownTestCase() {
+    FAIL() << "Unexpected failure: All tests disabled in test case. "
+              "TearDownTestCase() should not be called.";
+  }
+};
+
+TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) {
+  FAIL() << "Unexpected failure: Disabled test should not be run.";
+}
+
+TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) {
+  FAIL() << "Unexpected failure: Disabled test should not be run.";
+}
+
+// Tests that disabled typed tests aren't run.
+
+#if GTEST_HAS_TYPED_TEST
+
+template <typename T>
+class TypedTest : public Test {
+};
+
+typedef testing::Types<int, double> NumericTypes;
+TYPED_TEST_CASE(TypedTest, NumericTypes);
+
+TYPED_TEST(TypedTest, DISABLED_ShouldNotRun) {
+  FAIL() << "Unexpected failure: Disabled typed test should not run.";
+}
+
+template <typename T>
+class DISABLED_TypedTest : public Test {
+};
+
+TYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes);
+
+TYPED_TEST(DISABLED_TypedTest, ShouldNotRun) {
+  FAIL() << "Unexpected failure: Disabled typed test should not run.";
+}
+
+#endif  // GTEST_HAS_TYPED_TEST
+
+// Tests that disabled type-parameterized tests aren't run.
+
+#if GTEST_HAS_TYPED_TEST_P
+
+template <typename T>
+class TypedTestP : public Test {
+};
+
+TYPED_TEST_CASE_P(TypedTestP);
+
+TYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) {
+  FAIL() << "Unexpected failure: "
+         << "Disabled type-parameterized test should not run.";
+}
+
+REGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun);
+
+INSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes);
+
+template <typename T>
+class DISABLED_TypedTestP : public Test {
+};
+
+TYPED_TEST_CASE_P(DISABLED_TypedTestP);
+
+TYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) {
+  FAIL() << "Unexpected failure: "
+         << "Disabled type-parameterized test should not run.";
+}
+
+REGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun);
+
+INSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes);
+
+#endif  // GTEST_HAS_TYPED_TEST_P
+
+// Tests that assertion macros evaluate their arguments exactly once.
+
+class SingleEvaluationTest : public Test {
+ public:  // Must be public and not protected due to a bug in g++ 3.4.2.
+  // This helper function is needed by the FailedASSERT_STREQ test
+  // below.  It's public to work around C++Builder's bug with scoping local
+  // classes.
+  static void CompareAndIncrementCharPtrs() {
+    ASSERT_STREQ(p1_++, p2_++);
+  }
+
+  // This helper function is needed by the FailedASSERT_NE test below.  It's
+  // public to work around C++Builder's bug with scoping local classes.
+  static void CompareAndIncrementInts() {
+    ASSERT_NE(a_++, b_++);
+  }
+
+ protected:
+  SingleEvaluationTest() {
+    p1_ = s1_;
+    p2_ = s2_;
+    a_ = 0;
+    b_ = 0;
+  }
+
+  static const char* const s1_;
+  static const char* const s2_;
+  static const char* p1_;
+  static const char* p2_;
+
+  static int a_;
+  static int b_;
+};
+
+const char* const SingleEvaluationTest::s1_ = "01234";
+const char* const SingleEvaluationTest::s2_ = "abcde";
+const char* SingleEvaluationTest::p1_;
+const char* SingleEvaluationTest::p2_;
+int SingleEvaluationTest::a_;
+int SingleEvaluationTest::b_;
+
+// Tests that when ASSERT_STREQ fails, it evaluates its arguments
+// exactly once.
+TEST_F(SingleEvaluationTest, FailedASSERT_STREQ) {
+  EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementCharPtrs(),
+                       "p2_++");
+  EXPECT_EQ(s1_ + 1, p1_);
+  EXPECT_EQ(s2_ + 1, p2_);
+}
+
+// Tests that string assertion arguments are evaluated exactly once.
+TEST_F(SingleEvaluationTest, ASSERT_STR) {
+  // successful EXPECT_STRNE
+  EXPECT_STRNE(p1_++, p2_++);
+  EXPECT_EQ(s1_ + 1, p1_);
+  EXPECT_EQ(s2_ + 1, p2_);
+
+  // failed EXPECT_STRCASEEQ
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++),
+                          "Ignoring case");
+  EXPECT_EQ(s1_ + 2, p1_);
+  EXPECT_EQ(s2_ + 2, p2_);
+}
+
+// Tests that when ASSERT_NE fails, it evaluates its arguments exactly
+// once.
+TEST_F(SingleEvaluationTest, FailedASSERT_NE) {
+  EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementInts(),
+                       "(a_++) != (b_++)");
+  EXPECT_EQ(1, a_);
+  EXPECT_EQ(1, b_);
+}
+
+// Tests that assertion arguments are evaluated exactly once.
+TEST_F(SingleEvaluationTest, OtherCases) {
+  // successful EXPECT_TRUE
+  EXPECT_TRUE(0 == a_++);  // NOLINT
+  EXPECT_EQ(1, a_);
+
+  // failed EXPECT_TRUE
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(-1 == a_++), "-1 == a_++");
+  EXPECT_EQ(2, a_);
+
+  // successful EXPECT_GT
+  EXPECT_GT(a_++, b_++);
+  EXPECT_EQ(3, a_);
+  EXPECT_EQ(1, b_);
+
+  // failed EXPECT_LT
+  EXPECT_NONFATAL_FAILURE(EXPECT_LT(a_++, b_++), "(a_++) < (b_++)");
+  EXPECT_EQ(4, a_);
+  EXPECT_EQ(2, b_);
+
+  // successful ASSERT_TRUE
+  ASSERT_TRUE(0 < a_++);  // NOLINT
+  EXPECT_EQ(5, a_);
+
+  // successful ASSERT_GT
+  ASSERT_GT(a_++, b_++);
+  EXPECT_EQ(6, a_);
+  EXPECT_EQ(3, b_);
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+void ThrowAnInteger() {
+  throw 1;
+}
+
+// Tests that assertion arguments are evaluated exactly once.
+TEST_F(SingleEvaluationTest, ExceptionTests) {
+  // successful EXPECT_THROW
+  EXPECT_THROW({  // NOLINT
+    a_++;
+    ThrowAnInteger();
+  }, int);
+  EXPECT_EQ(1, a_);
+
+  // failed EXPECT_THROW, throws different
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW({  // NOLINT
+    a_++;
+    ThrowAnInteger();
+  }, bool), "throws a different type");
+  EXPECT_EQ(2, a_);
+
+  // failed EXPECT_THROW, throws nothing
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing");
+  EXPECT_EQ(3, a_);
+
+  // successful EXPECT_NO_THROW
+  EXPECT_NO_THROW(a_++);
+  EXPECT_EQ(4, a_);
+
+  // failed EXPECT_NO_THROW
+  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({  // NOLINT
+    a_++;
+    ThrowAnInteger();
+  }), "it throws");
+  EXPECT_EQ(5, a_);
+
+  // successful EXPECT_ANY_THROW
+  EXPECT_ANY_THROW({  // NOLINT
+    a_++;
+    ThrowAnInteger();
+  });
+  EXPECT_EQ(6, a_);
+
+  // failed EXPECT_ANY_THROW
+  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't");
+  EXPECT_EQ(7, a_);
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// Tests {ASSERT|EXPECT}_NO_FATAL_FAILURE.
+class NoFatalFailureTest : public Test {
+ protected:
+  void Succeeds() {}
+  void FailsNonFatal() {
+    ADD_FAILURE() << "some non-fatal failure";
+  }
+  void Fails() {
+    FAIL() << "some fatal failure";
+  }
+
+  void DoAssertNoFatalFailureOnFails() {
+    ASSERT_NO_FATAL_FAILURE(Fails());
+    ADD_FAILURE() << "shold not reach here.";
+  }
+
+  void DoExpectNoFatalFailureOnFails() {
+    EXPECT_NO_FATAL_FAILURE(Fails());
+    ADD_FAILURE() << "other failure";
+  }
+};
+
+TEST_F(NoFatalFailureTest, NoFailure) {
+  EXPECT_NO_FATAL_FAILURE(Succeeds());
+  ASSERT_NO_FATAL_FAILURE(Succeeds());
+}
+
+TEST_F(NoFatalFailureTest, NonFatalIsNoFailure) {
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_NO_FATAL_FAILURE(FailsNonFatal()),
+      "some non-fatal failure");
+  EXPECT_NONFATAL_FAILURE(
+      ASSERT_NO_FATAL_FAILURE(FailsNonFatal()),
+      "some non-fatal failure");
+}
+
+TEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) {
+  TestPartResultArray gtest_failures;
+  {
+    ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
+    DoAssertNoFatalFailureOnFails();
+  }
+  ASSERT_EQ(2, gtest_failures.size());
+  EXPECT_EQ(TestPartResult::kFatalFailure,
+            gtest_failures.GetTestPartResult(0).type());
+  EXPECT_EQ(TestPartResult::kFatalFailure,
+            gtest_failures.GetTestPartResult(1).type());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure",
+                      gtest_failures.GetTestPartResult(0).message());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does",
+                      gtest_failures.GetTestPartResult(1).message());
+}
+
+TEST_F(NoFatalFailureTest, ExpectNoFatalFailureOnFatalFailure) {
+  TestPartResultArray gtest_failures;
+  {
+    ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
+    DoExpectNoFatalFailureOnFails();
+  }
+  ASSERT_EQ(3, gtest_failures.size());
+  EXPECT_EQ(TestPartResult::kFatalFailure,
+            gtest_failures.GetTestPartResult(0).type());
+  EXPECT_EQ(TestPartResult::kNonFatalFailure,
+            gtest_failures.GetTestPartResult(1).type());
+  EXPECT_EQ(TestPartResult::kNonFatalFailure,
+            gtest_failures.GetTestPartResult(2).type());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure",
+                      gtest_failures.GetTestPartResult(0).message());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does",
+                      gtest_failures.GetTestPartResult(1).message());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "other failure",
+                      gtest_failures.GetTestPartResult(2).message());
+}
+
+TEST_F(NoFatalFailureTest, MessageIsStreamable) {
+  TestPartResultArray gtest_failures;
+  {
+    ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
+    EXPECT_NO_FATAL_FAILURE(FAIL() << "foo") << "my message";
+  }
+  ASSERT_EQ(2, gtest_failures.size());
+  EXPECT_EQ(TestPartResult::kNonFatalFailure,
+            gtest_failures.GetTestPartResult(0).type());
+  EXPECT_EQ(TestPartResult::kNonFatalFailure,
+            gtest_failures.GetTestPartResult(1).type());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "foo",
+                      gtest_failures.GetTestPartResult(0).message());
+  EXPECT_PRED_FORMAT2(testing::IsSubstring, "my message",
+                      gtest_failures.GetTestPartResult(1).message());
+}
+
+// Tests non-string assertions.
+
+std::string EditsToString(const std::vector<EditType>& edits) {
+  std::string out;
+  for (size_t i = 0; i < edits.size(); ++i) {
+    static const char kEdits[] = " +-/";
+    out.append(1, kEdits[edits[i]]);
+  }
+  return out;
+}
+
+std::vector<size_t> CharsToIndices(const std::string& str) {
+  std::vector<size_t> out;
+  for (size_t i = 0; i < str.size(); ++i) {
+    out.push_back(str[i]);
+  }
+  return out;
+}
+
+std::vector<std::string> CharsToLines(const std::string& str) {
+  std::vector<std::string> out;
+  for (size_t i = 0; i < str.size(); ++i) {
+    out.push_back(str.substr(i, 1));
+  }
+  return out;
+}
+
+TEST(EditDistance, TestCases) {
+  struct Case {
+    int line;
+    const char* left;
+    const char* right;
+    const char* expected_edits;
+    const char* expected_diff;
+  };
+  static const Case kCases[] = {
+      // No change.
+      {__LINE__, "A", "A", " ", ""},
+      {__LINE__, "ABCDE", "ABCDE", "     ", ""},
+      // Simple adds.
+      {__LINE__, "X", "XA", " +", "@@ +1,2 @@\n X\n+A\n"},
+      {__LINE__, "X", "XABCD", " ++++", "@@ +1,5 @@\n X\n+A\n+B\n+C\n+D\n"},
+      // Simple removes.
+      {__LINE__, "XA", "X", " -", "@@ -1,2 @@\n X\n-A\n"},
+      {__LINE__, "XABCD", "X", " ----", "@@ -1,5 @@\n X\n-A\n-B\n-C\n-D\n"},
+      // Simple replaces.
+      {__LINE__, "A", "a", "/", "@@ -1,1 +1,1 @@\n-A\n+a\n"},
+      {__LINE__, "ABCD", "abcd", "////",
+       "@@ -1,4 +1,4 @@\n-A\n-B\n-C\n-D\n+a\n+b\n+c\n+d\n"},
+      // Path finding.
+      {__LINE__, "ABCDEFGH", "ABXEGH1", "  -/ -  +",
+       "@@ -1,8 +1,7 @@\n A\n B\n-C\n-D\n+X\n E\n-F\n G\n H\n+1\n"},
+      {__LINE__, "AAAABCCCC", "ABABCDCDC", "- /   + / ",
+       "@@ -1,9 +1,9 @@\n-A\n A\n-A\n+B\n A\n B\n C\n+D\n C\n-C\n+D\n C\n"},
+      {__LINE__, "ABCDE", "BCDCD", "-   +/",
+       "@@ -1,5 +1,5 @@\n-A\n B\n C\n D\n-E\n+C\n+D\n"},
+      {__LINE__, "ABCDEFGHIJKL", "BCDCDEFGJKLJK", "- ++     --   ++",
+       "@@ -1,4 +1,5 @@\n-A\n B\n+C\n+D\n C\n D\n"
+       "@@ -6,7 +7,7 @@\n F\n G\n-H\n-I\n J\n K\n L\n+J\n+K\n"},
+      {}};
+  for (const Case* c = kCases; c->left; ++c) {
+    EXPECT_TRUE(c->expected_edits ==
+                EditsToString(CalculateOptimalEdits(CharsToIndices(c->left),
+                                                    CharsToIndices(c->right))))
+        << "Left <" << c->left << "> Right <" << c->right << "> Edits <"
+        << EditsToString(CalculateOptimalEdits(
+               CharsToIndices(c->left), CharsToIndices(c->right))) << ">";
+    EXPECT_TRUE(c->expected_diff == CreateUnifiedDiff(CharsToLines(c->left),
+                                                      CharsToLines(c->right)))
+        << "Left <" << c->left << "> Right <" << c->right << "> Diff <"
+        << CreateUnifiedDiff(CharsToLines(c->left), CharsToLines(c->right))
+        << ">";
+  }
+}
+
+// Tests EqFailure(), used for implementing *EQ* assertions.
+TEST(AssertionTest, EqFailure) {
+  const std::string foo_val("5"), bar_val("6");
+  const std::string msg1(
+      EqFailure("foo", "bar", foo_val, bar_val, false)
+      .failure_message());
+  EXPECT_STREQ(
+      "      Expected: foo\n"
+      "      Which is: 5\n"
+      "To be equal to: bar\n"
+      "      Which is: 6",
+      msg1.c_str());
+
+  const std::string msg2(
+      EqFailure("foo", "6", foo_val, bar_val, false)
+      .failure_message());
+  EXPECT_STREQ(
+      "      Expected: foo\n"
+      "      Which is: 5\n"
+      "To be equal to: 6",
+      msg2.c_str());
+
+  const std::string msg3(
+      EqFailure("5", "bar", foo_val, bar_val, false)
+      .failure_message());
+  EXPECT_STREQ(
+      "      Expected: 5\n"
+      "To be equal to: bar\n"
+      "      Which is: 6",
+      msg3.c_str());
+
+  const std::string msg4(
+      EqFailure("5", "6", foo_val, bar_val, false).failure_message());
+  EXPECT_STREQ(
+      "      Expected: 5\n"
+      "To be equal to: 6",
+      msg4.c_str());
+
+  const std::string msg5(
+      EqFailure("foo", "bar",
+                std::string("\"x\""), std::string("\"y\""),
+                true).failure_message());
+  EXPECT_STREQ(
+      "      Expected: foo\n"
+      "      Which is: \"x\"\n"
+      "To be equal to: bar\n"
+      "      Which is: \"y\"\n"
+      "Ignoring case",
+      msg5.c_str());
+}
+
+TEST(AssertionTest, EqFailureWithDiff) {
+  const std::string left(
+      "1\\n2XXX\\n3\\n5\\n6\\n7\\n8\\n9\\n10\\n11\\n12XXX\\n13\\n14\\n15");
+  const std::string right(
+      "1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14");
+  const std::string msg1(
+      EqFailure("left", "right", left, right, false).failure_message());
+  EXPECT_STREQ(
+      "      Expected: left\n"
+      "      Which is: "
+      "1\\n2XXX\\n3\\n5\\n6\\n7\\n8\\n9\\n10\\n11\\n12XXX\\n13\\n14\\n15\n"
+      "To be equal to: right\n"
+      "      Which is: 1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14\n"
+      "With diff:\n@@ -1,5 +1,6 @@\n 1\n-2XXX\n+2\n 3\n+4\n 5\n 6\n"
+      "@@ -7,8 +8,6 @@\n 8\n 9\n-10\n 11\n-12XXX\n+12\n 13\n 14\n-15\n",
+      msg1.c_str());
+}
+
+// Tests AppendUserMessage(), used for implementing the *EQ* macros.
+TEST(AssertionTest, AppendUserMessage) {
+  const std::string foo("foo");
+
+  Message msg;
+  EXPECT_STREQ("foo",
+               AppendUserMessage(foo, msg).c_str());
+
+  msg << "bar";
+  EXPECT_STREQ("foo\nbar",
+               AppendUserMessage(foo, msg).c_str());
+}
+
+#ifdef __BORLANDC__
+// Silences warnings: "Condition is always true", "Unreachable code"
+# pragma option push -w-ccc -w-rch
+#endif
+
+// Tests ASSERT_TRUE.
+TEST(AssertionTest, ASSERT_TRUE) {
+  ASSERT_TRUE(2 > 1);  // NOLINT
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1),
+                       "2 < 1");
+}
+
+// Tests ASSERT_TRUE(predicate) for predicates returning AssertionResult.
+TEST(AssertionTest, AssertTrueWithAssertionResult) {
+  ASSERT_TRUE(ResultIsEven(2));
+#ifndef __BORLANDC__
+  // ICE's in C++Builder.
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEven(3)),
+                       "Value of: ResultIsEven(3)\n"
+                       "  Actual: false (3 is odd)\n"
+                       "Expected: true");
+#endif
+  ASSERT_TRUE(ResultIsEvenNoExplanation(2));
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEvenNoExplanation(3)),
+                       "Value of: ResultIsEvenNoExplanation(3)\n"
+                       "  Actual: false (3 is odd)\n"
+                       "Expected: true");
+}
+
+// Tests ASSERT_FALSE.
+TEST(AssertionTest, ASSERT_FALSE) {
+  ASSERT_FALSE(2 < 1);  // NOLINT
+  EXPECT_FATAL_FAILURE(ASSERT_FALSE(2 > 1),
+                       "Value of: 2 > 1\n"
+                       "  Actual: true\n"
+                       "Expected: false");
+}
+
+// Tests ASSERT_FALSE(predicate) for predicates returning AssertionResult.
+TEST(AssertionTest, AssertFalseWithAssertionResult) {
+  ASSERT_FALSE(ResultIsEven(3));
+#ifndef __BORLANDC__
+  // ICE's in C++Builder.
+  EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEven(2)),
+                       "Value of: ResultIsEven(2)\n"
+                       "  Actual: true (2 is even)\n"
+                       "Expected: false");
+#endif
+  ASSERT_FALSE(ResultIsEvenNoExplanation(3));
+  EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEvenNoExplanation(2)),
+                       "Value of: ResultIsEvenNoExplanation(2)\n"
+                       "  Actual: true\n"
+                       "Expected: false");
+}
+
+#ifdef __BORLANDC__
+// Restores warnings after previous "#pragma option push" supressed them
+# pragma option pop
+#endif
+
+// Tests using ASSERT_EQ on double values.  The purpose is to make
+// sure that the specialization we did for integer and anonymous enums
+// isn't used for double arguments.
+TEST(ExpectTest, ASSERT_EQ_Double) {
+  // A success.
+  ASSERT_EQ(5.6, 5.6);
+
+  // A failure.
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2),
+                       "5.1");
+}
+
+// Tests ASSERT_EQ.
+TEST(AssertionTest, ASSERT_EQ) {
+  ASSERT_EQ(5, 2 + 3);
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3),
+                       "      Expected: 5\n"
+                       "To be equal to: 2*3\n"
+                       "      Which is: 6");
+}
+
+// Tests ASSERT_EQ(NULL, pointer).
+#if GTEST_CAN_COMPARE_NULL
+TEST(AssertionTest, ASSERT_EQ_NULL) {
+  // A success.
+  const char* p = NULL;
+  // Some older GCC versions may issue a spurious waring in this or the next
+  // assertion statement. This warning should not be suppressed with
+  // static_cast since the test verifies the ability to use bare NULL as the
+  // expected parameter to the macro.
+  ASSERT_EQ(NULL, p);
+
+  // A failure.
+  static int n = 0;
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n),
+                       "To be equal to: &n\n");
+}
+#endif  // GTEST_CAN_COMPARE_NULL
+
+// Tests ASSERT_EQ(0, non_pointer).  Since the literal 0 can be
+// treated as a null pointer by the compiler, we need to make sure
+// that ASSERT_EQ(0, non_pointer) isn't interpreted by Google Test as
+// ASSERT_EQ(static_cast<void*>(NULL), non_pointer).
+TEST(ExpectTest, ASSERT_EQ_0) {
+  int n = 0;
+
+  // A success.
+  ASSERT_EQ(0, n);
+
+  // A failure.
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6),
+                       "Expected: 0");
+}
+
+// Tests ASSERT_NE.
+TEST(AssertionTest, ASSERT_NE) {
+  ASSERT_NE(6, 7);
+  EXPECT_FATAL_FAILURE(ASSERT_NE('a', 'a'),
+                       "Expected: ('a') != ('a'), "
+                       "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");
+}
+
+// Tests ASSERT_LE.
+TEST(AssertionTest, ASSERT_LE) {
+  ASSERT_LE(2, 3);
+  ASSERT_LE(2, 2);
+  EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0),
+                       "Expected: (2) <= (0), actual: 2 vs 0");
+}
+
+// Tests ASSERT_LT.
+TEST(AssertionTest, ASSERT_LT) {
+  ASSERT_LT(2, 3);
+  EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2),
+                       "Expected: (2) < (2), actual: 2 vs 2");
+}
+
+// Tests ASSERT_GE.
+TEST(AssertionTest, ASSERT_GE) {
+  ASSERT_GE(2, 1);
+  ASSERT_GE(2, 2);
+  EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3),
+                       "Expected: (2) >= (3), actual: 2 vs 3");
+}
+
+// Tests ASSERT_GT.
+TEST(AssertionTest, ASSERT_GT) {
+  ASSERT_GT(2, 1);
+  EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2),
+                       "Expected: (2) > (2), actual: 2 vs 2");
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+void ThrowNothing() {}
+
+// Tests ASSERT_THROW.
+TEST(AssertionTest, ASSERT_THROW) {
+  ASSERT_THROW(ThrowAnInteger(), int);
+
+# ifndef __BORLANDC__
+
+  // ICE's in C++Builder 2007 and 2009.
+  EXPECT_FATAL_FAILURE(
+      ASSERT_THROW(ThrowAnInteger(), bool),
+      "Expected: ThrowAnInteger() throws an exception of type bool.\n"
+      "  Actual: it throws a different type.");
+# endif
+
+  EXPECT_FATAL_FAILURE(
+      ASSERT_THROW(ThrowNothing(), bool),
+      "Expected: ThrowNothing() throws an exception of type bool.\n"
+      "  Actual: it throws nothing.");
+}
+
+// Tests ASSERT_NO_THROW.
+TEST(AssertionTest, ASSERT_NO_THROW) {
+  ASSERT_NO_THROW(ThrowNothing());
+  EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()),
+                       "Expected: ThrowAnInteger() doesn't throw an exception."
+                       "\n  Actual: it throws.");
+}
+
+// Tests ASSERT_ANY_THROW.
+TEST(AssertionTest, ASSERT_ANY_THROW) {
+  ASSERT_ANY_THROW(ThrowAnInteger());
+  EXPECT_FATAL_FAILURE(
+      ASSERT_ANY_THROW(ThrowNothing()),
+      "Expected: ThrowNothing() throws an exception.\n"
+      "  Actual: it doesn't.");
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// Makes sure we deal with the precedence of <<.  This test should
+// compile.
+TEST(AssertionTest, AssertPrecedence) {
+  ASSERT_EQ(1 < 2, true);
+  bool false_value = false;
+  ASSERT_EQ(true && false_value, false);
+}
+
+// A subroutine used by the following test.
+void TestEq1(int x) {
+  ASSERT_EQ(1, x);
+}
+
+// Tests calling a test subroutine that's not part of a fixture.
+TEST(AssertionTest, NonFixtureSubroutine) {
+  EXPECT_FATAL_FAILURE(TestEq1(2),
+                       "To be equal to: x");
+}
+
+// An uncopyable class.
+class Uncopyable {
+ public:
+  explicit Uncopyable(int a_value) : value_(a_value) {}
+
+  int value() const { return value_; }
+  bool operator==(const Uncopyable& rhs) const {
+    return value() == rhs.value();
+  }
+ private:
+  // This constructor deliberately has no implementation, as we don't
+  // want this class to be copyable.
+  Uncopyable(const Uncopyable&);  // NOLINT
+
+  int value_;
+};
+
+::std::ostream& operator<<(::std::ostream& os, const Uncopyable& value) {
+  return os << value.value();
+}
+
+
+bool IsPositiveUncopyable(const Uncopyable& x) {
+  return x.value() > 0;
+}
+
+// A subroutine used by the following test.
+void TestAssertNonPositive() {
+  Uncopyable y(-1);
+  ASSERT_PRED1(IsPositiveUncopyable, y);
+}
+// A subroutine used by the following test.
+void TestAssertEqualsUncopyable() {
+  Uncopyable x(5);
+  Uncopyable y(-1);
+  ASSERT_EQ(x, y);
+}
+
+// Tests that uncopyable objects can be used in assertions.
+TEST(AssertionTest, AssertWorksWithUncopyableObject) {
+  Uncopyable x(5);
+  ASSERT_PRED1(IsPositiveUncopyable, x);
+  ASSERT_EQ(x, x);
+  EXPECT_FATAL_FAILURE(TestAssertNonPositive(),
+    "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
+  EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(),
+    "Expected: x\n      Which is: 5\nTo be equal to: y\n      Which is: -1");
+}
+
+// Tests that uncopyable objects can be used in expects.
+TEST(AssertionTest, ExpectWorksWithUncopyableObject) {
+  Uncopyable x(5);
+  EXPECT_PRED1(IsPositiveUncopyable, x);
+  Uncopyable y(-1);
+  EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y),
+    "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
+  EXPECT_EQ(x, x);
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y),
+    "Expected: x\n      Which is: 5\nTo be equal to: y\n      Which is: -1");
+}
+
+enum NamedEnum {
+  kE1 = 0,
+  kE2 = 1
+};
+
+TEST(AssertionTest, NamedEnum) {
+  EXPECT_EQ(kE1, kE1);
+  EXPECT_LT(kE1, kE2);
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Which is: 0");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Which is: 1");
+}
+
+// The version of gcc used in XCode 2.2 has a bug and doesn't allow
+// anonymous enums in assertions.  Therefore the following test is not
+// done on Mac.
+// Sun Studio and HP aCC also reject this code.
+#if !GTEST_OS_MAC && !defined(__SUNPRO_CC) && !defined(__HP_aCC)
+
+// Tests using assertions with anonymous enums.
+enum {
+  kCaseA = -1,
+
+# if GTEST_OS_LINUX
+
+  // We want to test the case where the size of the anonymous enum is
+  // larger than sizeof(int), to make sure our implementation of the
+  // assertions doesn't truncate the enums.  However, MSVC
+  // (incorrectly) doesn't allow an enum value to exceed the range of
+  // an int, so this has to be conditionally compiled.
+  //
+  // On Linux, kCaseB and kCaseA have the same value when truncated to
+  // int size.  We want to test whether this will confuse the
+  // assertions.
+  kCaseB = testing::internal::kMaxBiggestInt,
+
+# else
+
+  kCaseB = INT_MAX,
+
+# endif  // GTEST_OS_LINUX
+
+  kCaseC = 42
+};
+
+TEST(AssertionTest, AnonymousEnum) {
+# if GTEST_OS_LINUX
+
+  EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB));
+
+# endif  // GTEST_OS_LINUX
+
+  EXPECT_EQ(kCaseA, kCaseA);
+  EXPECT_NE(kCaseA, kCaseB);
+  EXPECT_LT(kCaseA, kCaseB);
+  EXPECT_LE(kCaseA, kCaseB);
+  EXPECT_GT(kCaseB, kCaseA);
+  EXPECT_GE(kCaseA, kCaseA);
+  EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB),
+                          "(kCaseA) >= (kCaseB)");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC),
+                          "-1 vs 42");
+
+  ASSERT_EQ(kCaseA, kCaseA);
+  ASSERT_NE(kCaseA, kCaseB);
+  ASSERT_LT(kCaseA, kCaseB);
+  ASSERT_LE(kCaseA, kCaseB);
+  ASSERT_GT(kCaseB, kCaseA);
+  ASSERT_GE(kCaseA, kCaseA);
+
+# ifndef __BORLANDC__
+
+  // ICE's in C++Builder.
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB),
+                       "To be equal to: kCaseB");
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
+                       "Which is: 42");
+# endif
+
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
+                       "Which is: -1");
+}
+
+#endif  // !GTEST_OS_MAC && !defined(__SUNPRO_CC)
+
+#if GTEST_OS_WINDOWS
+
+static HRESULT UnexpectedHRESULTFailure() {
+  return E_UNEXPECTED;
+}
+
+static HRESULT OkHRESULTSuccess() {
+  return S_OK;
+}
+
+static HRESULT FalseHRESULTSuccess() {
+  return S_FALSE;
+}
+
+// HRESULT assertion tests test both zero and non-zero
+// success codes as well as failure message for each.
+//
+// Windows CE doesn't support message texts.
+TEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) {
+  EXPECT_HRESULT_SUCCEEDED(S_OK);
+  EXPECT_HRESULT_SUCCEEDED(S_FALSE);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
+    "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
+    "  Actual: 0x8000FFFF");
+}
+
+TEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) {
+  ASSERT_HRESULT_SUCCEEDED(S_OK);
+  ASSERT_HRESULT_SUCCEEDED(S_FALSE);
+
+  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
+    "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
+    "  Actual: 0x8000FFFF");
+}
+
+TEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) {
+  EXPECT_HRESULT_FAILED(E_UNEXPECTED);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()),
+    "Expected: (OkHRESULTSuccess()) fails.\n"
+    "  Actual: 0x0");
+  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()),
+    "Expected: (FalseHRESULTSuccess()) fails.\n"
+    "  Actual: 0x1");
+}
+
+TEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) {
+  ASSERT_HRESULT_FAILED(E_UNEXPECTED);
+
+# ifndef __BORLANDC__
+
+  // ICE's in C++Builder 2007 and 2009.
+  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()),
+    "Expected: (OkHRESULTSuccess()) fails.\n"
+    "  Actual: 0x0");
+# endif
+
+  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()),
+    "Expected: (FalseHRESULTSuccess()) fails.\n"
+    "  Actual: 0x1");
+}
+
+// Tests that streaming to the HRESULT macros works.
+TEST(HRESULTAssertionTest, Streaming) {
+  EXPECT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure";
+  ASSERT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure";
+  EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
+  ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
+
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
+      "expected failure");
+
+# ifndef __BORLANDC__
+
+  // ICE's in C++Builder 2007 and 2009.
+  EXPECT_FATAL_FAILURE(
+      ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
+      "expected failure");
+# endif
+
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_HRESULT_FAILED(S_OK) << "expected failure",
+      "expected failure");
+
+  EXPECT_FATAL_FAILURE(
+      ASSERT_HRESULT_FAILED(S_OK) << "expected failure",
+      "expected failure");
+}
+
+#endif  // GTEST_OS_WINDOWS
+
+#ifdef __BORLANDC__
+// Silences warnings: "Condition is always true", "Unreachable code"
+# pragma option push -w-ccc -w-rch
+#endif
+
+// Tests that the assertion macros behave like single statements.
+TEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) {
+  if (AlwaysFalse())
+    ASSERT_TRUE(false) << "This should never be executed; "
+                          "It's a compilation test only.";
+
+  if (AlwaysTrue())
+    EXPECT_FALSE(false);
+  else
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    ASSERT_LT(1, 3);
+
+  if (AlwaysFalse())
+    ;  // NOLINT
+  else
+    EXPECT_GT(3, 2) << "";
+}
+
+#if GTEST_HAS_EXCEPTIONS
+// Tests that the compiler will not complain about unreachable code in the
+// EXPECT_THROW/EXPECT_ANY_THROW/EXPECT_NO_THROW macros.
+TEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) {
+  int n = 0;
+
+  EXPECT_THROW(throw 1, int);
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(n++, int), "");
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(throw 1, const char*), "");
+  EXPECT_NO_THROW(n++);
+  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(throw 1), "");
+  EXPECT_ANY_THROW(throw 1);
+  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(n++), "");
+}
+
+TEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) {
+  if (AlwaysFalse())
+    EXPECT_THROW(ThrowNothing(), bool);
+
+  if (AlwaysTrue())
+    EXPECT_THROW(ThrowAnInteger(), int);
+  else
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    EXPECT_NO_THROW(ThrowAnInteger());
+
+  if (AlwaysTrue())
+    EXPECT_NO_THROW(ThrowNothing());
+  else
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    EXPECT_ANY_THROW(ThrowNothing());
+
+  if (AlwaysTrue())
+    EXPECT_ANY_THROW(ThrowAnInteger());
+  else
+    ;  // NOLINT
+}
+#endif  // GTEST_HAS_EXCEPTIONS
+
+TEST(AssertionSyntaxTest, NoFatalFailureAssertionsBehavesLikeSingleStatement) {
+  if (AlwaysFalse())
+    EXPECT_NO_FATAL_FAILURE(FAIL()) << "This should never be executed. "
+                                    << "It's a compilation test only.";
+  else
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    ASSERT_NO_FATAL_FAILURE(FAIL()) << "";
+  else
+    ;  // NOLINT
+
+  if (AlwaysTrue())
+    EXPECT_NO_FATAL_FAILURE(SUCCEED());
+  else
+    ;  // NOLINT
+
+  if (AlwaysFalse())
+    ;  // NOLINT
+  else
+    ASSERT_NO_FATAL_FAILURE(SUCCEED());
+}
+
+// Tests that the assertion macros work well with switch statements.
+TEST(AssertionSyntaxTest, WorksWithSwitch) {
+  switch (0) {
+    case 1:
+      break;
+    default:
+      ASSERT_TRUE(true);
+  }
+
+  switch (0)
+    case 0:
+      EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case";
+
+  // Binary assertions are implemented using a different code path
+  // than the Boolean assertions.  Hence we test them separately.
+  switch (0) {
+    case 1:
+    default:
+      ASSERT_EQ(1, 1) << "ASSERT_EQ failed in default switch handler";
+  }
+
+  switch (0)
+    case 0:
+      EXPECT_NE(1, 2);
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+void ThrowAString() {
+    throw "std::string";
+}
+
+// Test that the exception assertion macros compile and work with const
+// type qualifier.
+TEST(AssertionSyntaxTest, WorksWithConst) {
+    ASSERT_THROW(ThrowAString(), const char*);
+
+    EXPECT_THROW(ThrowAString(), const char*);
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+}  // namespace
+
+namespace testing {
+
+// Tests that Google Test tracks SUCCEED*.
+TEST(SuccessfulAssertionTest, SUCCEED) {
+  SUCCEED();
+  SUCCEED() << "OK";
+  EXPECT_EQ(2, GetUnitTestImpl()->current_test_result()->total_part_count());
+}
+
+// Tests that Google Test doesn't track successful EXPECT_*.
+TEST(SuccessfulAssertionTest, EXPECT) {
+  EXPECT_TRUE(true);
+  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
+}
+
+// Tests that Google Test doesn't track successful EXPECT_STR*.
+TEST(SuccessfulAssertionTest, EXPECT_STR) {
+  EXPECT_STREQ("", "");
+  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
+}
+
+// Tests that Google Test doesn't track successful ASSERT_*.
+TEST(SuccessfulAssertionTest, ASSERT) {
+  ASSERT_TRUE(true);
+  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
+}
+
+// Tests that Google Test doesn't track successful ASSERT_STR*.
+TEST(SuccessfulAssertionTest, ASSERT_STR) {
+  ASSERT_STREQ("", "");
+  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
+}
+
+}  // namespace testing
+
+namespace {
+
+// Tests the message streaming variation of assertions.
+
+TEST(AssertionWithMessageTest, EXPECT) {
+  EXPECT_EQ(1, 1) << "This should succeed.";
+  EXPECT_NONFATAL_FAILURE(EXPECT_NE(1, 1) << "Expected failure #1.",
+                          "Expected failure #1");
+  EXPECT_LE(1, 2) << "This should succeed.";
+  EXPECT_NONFATAL_FAILURE(EXPECT_LT(1, 0) << "Expected failure #2.",
+                          "Expected failure #2.");
+  EXPECT_GE(1, 0) << "This should succeed.";
+  EXPECT_NONFATAL_FAILURE(EXPECT_GT(1, 2) << "Expected failure #3.",
+                          "Expected failure #3.");
+
+  EXPECT_STREQ("1", "1") << "This should succeed.";
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("1", "1") << "Expected failure #4.",
+                          "Expected failure #4.");
+  EXPECT_STRCASEEQ("a", "A") << "This should succeed.";
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("a", "A") << "Expected failure #5.",
+                          "Expected failure #5.");
+
+  EXPECT_FLOAT_EQ(1, 1) << "This should succeed.";
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1, 1.2) << "Expected failure #6.",
+                          "Expected failure #6.");
+  EXPECT_NEAR(1, 1.1, 0.2) << "This should succeed.";
+}
+
+TEST(AssertionWithMessageTest, ASSERT) {
+  ASSERT_EQ(1, 1) << "This should succeed.";
+  ASSERT_NE(1, 2) << "This should succeed.";
+  ASSERT_LE(1, 2) << "This should succeed.";
+  ASSERT_LT(1, 2) << "This should succeed.";
+  ASSERT_GE(1, 0) << "This should succeed.";
+  EXPECT_FATAL_FAILURE(ASSERT_GT(1, 2) << "Expected failure.",
+                       "Expected failure.");
+}
+
+TEST(AssertionWithMessageTest, ASSERT_STR) {
+  ASSERT_STREQ("1", "1") << "This should succeed.";
+  ASSERT_STRNE("1", "2") << "This should succeed.";
+  ASSERT_STRCASEEQ("a", "A") << "This should succeed.";
+  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("a", "A") << "Expected failure.",
+                       "Expected failure.");
+}
+
+TEST(AssertionWithMessageTest, ASSERT_FLOATING) {
+  ASSERT_FLOAT_EQ(1, 1) << "This should succeed.";
+  ASSERT_DOUBLE_EQ(1, 1) << "This should succeed.";
+  EXPECT_FATAL_FAILURE(ASSERT_NEAR(1,1.2, 0.1) << "Expect failure.",  // NOLINT
+                       "Expect failure.");
+  // To work around a bug in gcc 2.95.0, there is intentionally no
+  // space after the first comma in the previous statement.
+}
+
+// Tests using ASSERT_FALSE with a streamed message.
+TEST(AssertionWithMessageTest, ASSERT_FALSE) {
+  ASSERT_FALSE(false) << "This shouldn't fail.";
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_FALSE(true) << "Expected failure: " << 2 << " > " << 1
+                       << " evaluates to " << true;
+  }, "Expected failure");
+}
+
+// Tests using FAIL with a streamed message.
+TEST(AssertionWithMessageTest, FAIL) {
+  EXPECT_FATAL_FAILURE(FAIL() << 0,
+                       "0");
+}
+
+// Tests using SUCCEED with a streamed message.
+TEST(AssertionWithMessageTest, SUCCEED) {
+  SUCCEED() << "Success == " << 1;
+}
+
+// Tests using ASSERT_TRUE with a streamed message.
+TEST(AssertionWithMessageTest, ASSERT_TRUE) {
+  ASSERT_TRUE(true) << "This should succeed.";
+  ASSERT_TRUE(true) << true;
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_TRUE(false) << static_cast<const char *>(NULL)
+                       << static_cast<char *>(NULL);
+  }, "(null)(null)");
+}
+
+#if GTEST_OS_WINDOWS
+// Tests using wide strings in assertion messages.
+TEST(AssertionWithMessageTest, WideStringMessage) {
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_TRUE(false) << L"This failure is expected.\x8119";
+  }, "This failure is expected.");
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_EQ(1, 2) << "This failure is "
+                    << L"expected too.\x8120";
+  }, "This failure is expected too.");
+}
+#endif  // GTEST_OS_WINDOWS
+
+// Tests EXPECT_TRUE.
+TEST(ExpectTest, EXPECT_TRUE) {
+  EXPECT_TRUE(true) << "Intentional success";
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "Intentional failure #1.",
+                          "Intentional failure #1.");
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "Intentional failure #2.",
+                          "Intentional failure #2.");
+  EXPECT_TRUE(2 > 1);  // NOLINT
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 < 1),
+                          "Value of: 2 < 1\n"
+                          "  Actual: false\n"
+                          "Expected: true");
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3),
+                          "2 > 3");
+}
+
+// Tests EXPECT_TRUE(predicate) for predicates returning AssertionResult.
+TEST(ExpectTest, ExpectTrueWithAssertionResult) {
+  EXPECT_TRUE(ResultIsEven(2));
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEven(3)),
+                          "Value of: ResultIsEven(3)\n"
+                          "  Actual: false (3 is odd)\n"
+                          "Expected: true");
+  EXPECT_TRUE(ResultIsEvenNoExplanation(2));
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEvenNoExplanation(3)),
+                          "Value of: ResultIsEvenNoExplanation(3)\n"
+                          "  Actual: false (3 is odd)\n"
+                          "Expected: true");
+}
+
+// Tests EXPECT_FALSE with a streamed message.
+TEST(ExpectTest, EXPECT_FALSE) {
+  EXPECT_FALSE(2 < 1);  // NOLINT
+  EXPECT_FALSE(false) << "Intentional success";
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "Intentional failure #1.",
+                          "Intentional failure #1.");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "Intentional failure #2.",
+                          "Intentional failure #2.");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 > 1),
+                          "Value of: 2 > 1\n"
+                          "  Actual: true\n"
+                          "Expected: false");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3),
+                          "2 < 3");
+}
+
+// Tests EXPECT_FALSE(predicate) for predicates returning AssertionResult.
+TEST(ExpectTest, ExpectFalseWithAssertionResult) {
+  EXPECT_FALSE(ResultIsEven(3));
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEven(2)),
+                          "Value of: ResultIsEven(2)\n"
+                          "  Actual: true (2 is even)\n"
+                          "Expected: false");
+  EXPECT_FALSE(ResultIsEvenNoExplanation(3));
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEvenNoExplanation(2)),
+                          "Value of: ResultIsEvenNoExplanation(2)\n"
+                          "  Actual: true\n"
+                          "Expected: false");
+}
+
+#ifdef __BORLANDC__
+// Restores warnings after previous "#pragma option push" supressed them
+# pragma option pop
+#endif
+
+// Tests EXPECT_EQ.
+TEST(ExpectTest, EXPECT_EQ) {
+  EXPECT_EQ(5, 2 + 3);
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3),
+                          "      Expected: 5\n"
+                          "To be equal to: 2*3\n"
+                          "      Which is: 6");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3),
+                          "2 - 3");
+}
+
+// Tests using EXPECT_EQ on double values.  The purpose is to make
+// sure that the specialization we did for integer and anonymous enums
+// isn't used for double arguments.
+TEST(ExpectTest, EXPECT_EQ_Double) {
+  // A success.
+  EXPECT_EQ(5.6, 5.6);
+
+  // A failure.
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2),
+                          "5.1");
+}
+
+#if GTEST_CAN_COMPARE_NULL
+// Tests EXPECT_EQ(NULL, pointer).
+TEST(ExpectTest, EXPECT_EQ_NULL) {
+  // A success.
+  const char* p = NULL;
+  // Some older GCC versions may issue a spurious warning in this or the next
+  // assertion statement. This warning should not be suppressed with
+  // static_cast since the test verifies the ability to use bare NULL as the
+  // expected parameter to the macro.
+  EXPECT_EQ(NULL, p);
+
+  // A failure.
+  int n = 0;
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n),
+                          "To be equal to: &n\n");
+}
+#endif  // GTEST_CAN_COMPARE_NULL
+
+// Tests EXPECT_EQ(0, non_pointer).  Since the literal 0 can be
+// treated as a null pointer by the compiler, we need to make sure
+// that EXPECT_EQ(0, non_pointer) isn't interpreted by Google Test as
+// EXPECT_EQ(static_cast<void*>(NULL), non_pointer).
+TEST(ExpectTest, EXPECT_EQ_0) {
+  int n = 0;
+
+  // A success.
+  EXPECT_EQ(0, n);
+
+  // A failure.
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6),
+                          "Expected: 0");
+}
+
+// Tests EXPECT_NE.
+TEST(ExpectTest, EXPECT_NE) {
+  EXPECT_NE(6, 7);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'),
+                          "Expected: ('a') != ('a'), "
+                          "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");
+  EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2),
+                          "2");
+  char* const p0 = NULL;
+  EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0),
+                          "p0");
+  // Only way to get the Nokia compiler to compile the cast
+  // is to have a separate void* variable first. Putting
+  // the two casts on the same line doesn't work, neither does
+  // a direct C-style to char*.
+  void* pv1 = (void*)0x1234;  // NOLINT
+  char* const p1 = reinterpret_cast<char*>(pv1);
+  EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1),
+                          "p1");
+}
+
+// Tests EXPECT_LE.
+TEST(ExpectTest, EXPECT_LE) {
+  EXPECT_LE(2, 3);
+  EXPECT_LE(2, 2);
+  EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0),
+                          "Expected: (2) <= (0), actual: 2 vs 0");
+  EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9),
+                          "(1.1) <= (0.9)");
+}
+
+// Tests EXPECT_LT.
+TEST(ExpectTest, EXPECT_LT) {
+  EXPECT_LT(2, 3);
+  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2),
+                          "Expected: (2) < (2), actual: 2 vs 2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1),
+                          "(2) < (1)");
+}
+
+// Tests EXPECT_GE.
+TEST(ExpectTest, EXPECT_GE) {
+  EXPECT_GE(2, 1);
+  EXPECT_GE(2, 2);
+  EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3),
+                          "Expected: (2) >= (3), actual: 2 vs 3");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1),
+                          "(0.9) >= (1.1)");
+}
+
+// Tests EXPECT_GT.
+TEST(ExpectTest, EXPECT_GT) {
+  EXPECT_GT(2, 1);
+  EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2),
+                          "Expected: (2) > (2), actual: 2 vs 2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3),
+                          "(2) > (3)");
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Tests EXPECT_THROW.
+TEST(ExpectTest, EXPECT_THROW) {
+  EXPECT_THROW(ThrowAnInteger(), int);
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool),
+                          "Expected: ThrowAnInteger() throws an exception of "
+                          "type bool.\n  Actual: it throws a different type.");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW(ThrowNothing(), bool),
+      "Expected: ThrowNothing() throws an exception of type bool.\n"
+      "  Actual: it throws nothing.");
+}
+
+// Tests EXPECT_NO_THROW.
+TEST(ExpectTest, EXPECT_NO_THROW) {
+  EXPECT_NO_THROW(ThrowNothing());
+  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()),
+                          "Expected: ThrowAnInteger() doesn't throw an "
+                          "exception.\n  Actual: it throws.");
+}
+
+// Tests EXPECT_ANY_THROW.
+TEST(ExpectTest, EXPECT_ANY_THROW) {
+  EXPECT_ANY_THROW(ThrowAnInteger());
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_ANY_THROW(ThrowNothing()),
+      "Expected: ThrowNothing() throws an exception.\n"
+      "  Actual: it doesn't.");
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// Make sure we deal with the precedence of <<.
+TEST(ExpectTest, ExpectPrecedence) {
+  EXPECT_EQ(1 < 2, true);
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false),
+                          "To be equal to: true && false");
+}
+
+
+// Tests the StreamableToString() function.
+
+// Tests using StreamableToString() on a scalar.
+TEST(StreamableToStringTest, Scalar) {
+  EXPECT_STREQ("5", StreamableToString(5).c_str());
+}
+
+// Tests using StreamableToString() on a non-char pointer.
+TEST(StreamableToStringTest, Pointer) {
+  int n = 0;
+  int* p = &n;
+  EXPECT_STRNE("(null)", StreamableToString(p).c_str());
+}
+
+// Tests using StreamableToString() on a NULL non-char pointer.
+TEST(StreamableToStringTest, NullPointer) {
+  int* p = NULL;
+  EXPECT_STREQ("(null)", StreamableToString(p).c_str());
+}
+
+// Tests using StreamableToString() on a C string.
+TEST(StreamableToStringTest, CString) {
+  EXPECT_STREQ("Foo", StreamableToString("Foo").c_str());
+}
+
+// Tests using StreamableToString() on a NULL C string.
+TEST(StreamableToStringTest, NullCString) {
+  char* p = NULL;
+  EXPECT_STREQ("(null)", StreamableToString(p).c_str());
+}
+
+// Tests using streamable values as assertion messages.
+
+// Tests using std::string as an assertion message.
+TEST(StreamableTest, string) {
+  static const std::string str(
+      "This failure message is a std::string, and is expected.");
+  EXPECT_FATAL_FAILURE(FAIL() << str,
+                       str.c_str());
+}
+
+// Tests that we can output strings containing embedded NULs.
+// Limited to Linux because we can only do this with std::string's.
+TEST(StreamableTest, stringWithEmbeddedNUL) {
+  static const char char_array_with_nul[] =
+      "Here's a NUL\0 and some more string";
+  static const std::string string_with_nul(char_array_with_nul,
+                                           sizeof(char_array_with_nul)
+                                           - 1);  // drops the trailing NUL
+  EXPECT_FATAL_FAILURE(FAIL() << string_with_nul,
+                       "Here's a NUL\\0 and some more string");
+}
+
+// Tests that we can output a NUL char.
+TEST(StreamableTest, NULChar) {
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    FAIL() << "A NUL" << '\0' << " and some more string";
+  }, "A NUL\\0 and some more string");
+}
+
+// Tests using int as an assertion message.
+TEST(StreamableTest, int) {
+  EXPECT_FATAL_FAILURE(FAIL() << 900913,
+                       "900913");
+}
+
+// Tests using NULL char pointer as an assertion message.
+//
+// In MSVC, streaming a NULL char * causes access violation.  Google Test
+// implemented a workaround (substituting "(null)" for NULL).  This
+// tests whether the workaround works.
+TEST(StreamableTest, NullCharPtr) {
+  EXPECT_FATAL_FAILURE(FAIL() << static_cast<const char*>(NULL),
+                       "(null)");
+}
+
+// Tests that basic IO manipulators (endl, ends, and flush) can be
+// streamed to testing::Message.
+TEST(StreamableTest, BasicIoManip) {
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    FAIL() << "Line 1." << std::endl
+           << "A NUL char " << std::ends << std::flush << " in line 2.";
+  }, "Line 1.\nA NUL char \\0 in line 2.");
+}
+
+// Tests the macros that haven't been covered so far.
+
+void AddFailureHelper(bool* aborted) {
+  *aborted = true;
+  ADD_FAILURE() << "Intentional failure.";
+  *aborted = false;
+}
+
+// Tests ADD_FAILURE.
+TEST(MacroTest, ADD_FAILURE) {
+  bool aborted = true;
+  EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted),
+                          "Intentional failure.");
+  EXPECT_FALSE(aborted);
+}
+
+// Tests ADD_FAILURE_AT.
+TEST(MacroTest, ADD_FAILURE_AT) {
+  // Verifies that ADD_FAILURE_AT does generate a nonfatal failure and
+  // the failure message contains the user-streamed part.
+  EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42) << "Wrong!", "Wrong!");
+
+  // Verifies that the user-streamed part is optional.
+  EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42), "Failed");
+
+  // Unfortunately, we cannot verify that the failure message contains
+  // the right file path and line number the same way, as
+  // EXPECT_NONFATAL_FAILURE() doesn't get to see the file path and
+  // line number.  Instead, we do that in gtest_output_test_.cc.
+}
+
+// Tests FAIL.
+TEST(MacroTest, FAIL) {
+  EXPECT_FATAL_FAILURE(FAIL(),
+                       "Failed");
+  EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.",
+                       "Intentional failure.");
+}
+
+// Tests SUCCEED
+TEST(MacroTest, SUCCEED) {
+  SUCCEED();
+  SUCCEED() << "Explicit success.";
+}
+
+// Tests for EXPECT_EQ() and ASSERT_EQ().
+//
+// These tests fail *intentionally*, s.t. the failure messages can be
+// generated and tested.
+//
+// We have different tests for different argument types.
+
+// Tests using bool values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, Bool) {
+  EXPECT_EQ(true,  true);
+  EXPECT_FATAL_FAILURE({
+      bool false_value = false;
+      ASSERT_EQ(false_value, true);
+    }, "To be equal to: true");
+}
+
+// Tests using int values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, Int) {
+  ASSERT_EQ(32, 32);
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33),
+                          "33");
+}
+
+// Tests using time_t values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, Time_T) {
+  EXPECT_EQ(static_cast<time_t>(0),
+            static_cast<time_t>(0));
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0),
+                                 static_cast<time_t>(1234)),
+                       "1234");
+}
+
+// Tests using char values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, Char) {
+  ASSERT_EQ('z', 'z');
+  const char ch = 'b';
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch),
+                          "ch");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch),
+                          "ch");
+}
+
+// Tests using wchar_t values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, WideChar) {
+  EXPECT_EQ(L'b', L'b');
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'),
+                          "      Expected: L'\0'\n"
+                          "      Which is: L'\0' (0, 0x0)\n"
+                          "To be equal to: L'x'\n"
+                          "      Which is: L'x' (120, 0x78)");
+
+  static wchar_t wchar;
+  wchar = L'b';
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar),
+                          "wchar");
+  wchar = 0x8119;
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar),
+                       "To be equal to: wchar");
+}
+
+// Tests using ::std::string values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, StdString) {
+  // Compares a const char* to an std::string that has identical
+  // content.
+  ASSERT_EQ("Test", ::std::string("Test"));
+
+  // Compares two identical std::strings.
+  static const ::std::string str1("A * in the middle");
+  static const ::std::string str2(str1);
+  EXPECT_EQ(str1, str2);
+
+  // Compares a const char* to an std::string that has different
+  // content
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")),
+                          "\"test\"");
+
+  // Compares an std::string to a char* that has different content.
+  char* const p1 = const_cast<char*>("foo");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1),
+                          "p1");
+
+  // Compares two std::strings that have different contents, one of
+  // which having a NUL character in the middle.  This should fail.
+  static ::std::string str3(str1);
+  str3.at(2) = '\0';
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3),
+                       "To be equal to: str3\n"
+                       "      Which is: \"A \\0 in the middle\"");
+}
+
+#if GTEST_HAS_STD_WSTRING
+
+// Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, StdWideString) {
+  // Compares two identical std::wstrings.
+  const ::std::wstring wstr1(L"A * in the middle");
+  const ::std::wstring wstr2(wstr1);
+  ASSERT_EQ(wstr1, wstr2);
+
+  // Compares an std::wstring to a const wchar_t* that has identical
+  // content.
+  const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };
+  EXPECT_EQ(::std::wstring(kTestX8119), kTestX8119);
+
+  // Compares an std::wstring to a const wchar_t* that has different
+  // content.
+  const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120);
+  }, "kTestX8120");
+
+  // Compares two std::wstrings that have different contents, one of
+  // which having a NUL character in the middle.
+  ::std::wstring wstr3(wstr1);
+  wstr3.at(2) = L'\0';
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3),
+                          "wstr3");
+
+  // Compares a wchar_t* to an std::wstring that has different
+  // content.
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar"));
+  }, "");
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_HAS_GLOBAL_STRING
+// Tests using ::string values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, GlobalString) {
+  // Compares a const char* to a ::string that has identical content.
+  EXPECT_EQ("Test", ::string("Test"));
+
+  // Compares two identical ::strings.
+  const ::string str1("A * in the middle");
+  const ::string str2(str1);
+  ASSERT_EQ(str1, str2);
+
+  // Compares a ::string to a const char* that has different content.
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::string("Test"), "test"),
+                          "test");
+
+  // Compares two ::strings that have different contents, one of which
+  // having a NUL character in the middle.
+  ::string str3(str1);
+  str3.at(2) = '\0';
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(str1, str3),
+                          "str3");
+
+  // Compares a ::string to a char* that has different content.
+  EXPECT_FATAL_FAILURE({  // NOLINT
+    ASSERT_EQ(::string("bar"), const_cast<char*>("foo"));
+  }, "");
+}
+
+#endif  // GTEST_HAS_GLOBAL_STRING
+
+#if GTEST_HAS_GLOBAL_WSTRING
+
+// Tests using ::wstring values in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, GlobalWideString) {
+  // Compares two identical ::wstrings.
+  static const ::wstring wstr1(L"A * in the middle");
+  static const ::wstring wstr2(wstr1);
+  EXPECT_EQ(wstr1, wstr2);
+
+  // Compares a const wchar_t* to a ::wstring that has identical content.
+  const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };
+  ASSERT_EQ(kTestX8119, ::wstring(kTestX8119));
+
+  // Compares a const wchar_t* to a ::wstring that has different
+  // content.
+  const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };
+  EXPECT_NONFATAL_FAILURE({  // NOLINT
+    EXPECT_EQ(kTestX8120, ::wstring(kTestX8119));
+  }, "Test\\x8119");
+
+  // Compares a wchar_t* to a ::wstring that has different content.
+  wchar_t* const p1 = const_cast<wchar_t*>(L"foo");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, ::wstring(L"bar")),
+                          "bar");
+
+  // Compares two ::wstrings that have different contents, one of which
+  // having a NUL character in the middle.
+  static ::wstring wstr3;
+  wstr3 = wstr1;
+  wstr3.at(2) = L'\0';
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(wstr1, wstr3),
+                       "wstr3");
+}
+
+#endif  // GTEST_HAS_GLOBAL_WSTRING
+
+// Tests using char pointers in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, CharPointer) {
+  char* const p0 = NULL;
+  // Only way to get the Nokia compiler to compile the cast
+  // is to have a separate void* variable first. Putting
+  // the two casts on the same line doesn't work, neither does
+  // a direct C-style to char*.
+  void* pv1 = (void*)0x1234;  // NOLINT
+  void* pv2 = (void*)0xABC0;  // NOLINT
+  char* const p1 = reinterpret_cast<char*>(pv1);
+  char* const p2 = reinterpret_cast<char*>(pv2);
+  ASSERT_EQ(p1, p1);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
+                          "To be equal to: p2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
+                          "p2");
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234),
+                                 reinterpret_cast<char*>(0xABC0)),
+                       "ABC0");
+}
+
+// Tests using wchar_t pointers in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, WideCharPointer) {
+  wchar_t* const p0 = NULL;
+  // Only way to get the Nokia compiler to compile the cast
+  // is to have a separate void* variable first. Putting
+  // the two casts on the same line doesn't work, neither does
+  // a direct C-style to char*.
+  void* pv1 = (void*)0x1234;  // NOLINT
+  void* pv2 = (void*)0xABC0;  // NOLINT
+  wchar_t* const p1 = reinterpret_cast<wchar_t*>(pv1);
+  wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2);
+  EXPECT_EQ(p0, p0);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
+                          "To be equal to: p2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
+                          "p2");
+  void* pv3 = (void*)0x1234;  // NOLINT
+  void* pv4 = (void*)0xABC0;  // NOLINT
+  const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3);
+  const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4);
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4),
+                          "p4");
+}
+
+// Tests using other types of pointers in {EXPECT|ASSERT}_EQ.
+TEST(EqAssertionTest, OtherPointer) {
+  ASSERT_EQ(static_cast<const int*>(NULL),
+            static_cast<const int*>(NULL));
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<const int*>(NULL),
+                                 reinterpret_cast<const int*>(0x1234)),
+                       "0x1234");
+}
+
+// A class that supports binary comparison operators but not streaming.
+class UnprintableChar {
+ public:
+  explicit UnprintableChar(char ch) : char_(ch) {}
+
+  bool operator==(const UnprintableChar& rhs) const {
+    return char_ == rhs.char_;
+  }
+  bool operator!=(const UnprintableChar& rhs) const {
+    return char_ != rhs.char_;
+  }
+  bool operator<(const UnprintableChar& rhs) const {
+    return char_ < rhs.char_;
+  }
+  bool operator<=(const UnprintableChar& rhs) const {
+    return char_ <= rhs.char_;
+  }
+  bool operator>(const UnprintableChar& rhs) const {
+    return char_ > rhs.char_;
+  }
+  bool operator>=(const UnprintableChar& rhs) const {
+    return char_ >= rhs.char_;
+  }
+
+ private:
+  char char_;
+};
+
+// Tests that ASSERT_EQ() and friends don't require the arguments to
+// be printable.
+TEST(ComparisonAssertionTest, AcceptsUnprintableArgs) {
+  const UnprintableChar x('x'), y('y');
+  ASSERT_EQ(x, x);
+  EXPECT_NE(x, y);
+  ASSERT_LT(x, y);
+  EXPECT_LE(x, y);
+  ASSERT_GT(y, x);
+  EXPECT_GE(x, x);
+
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <78>");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <79>");
+  EXPECT_NONFATAL_FAILURE(EXPECT_LT(y, y), "1-byte object <79>");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <78>");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <79>");
+
+  // Code tested by EXPECT_FATAL_FAILURE cannot reference local
+  // variables, so we have to write UnprintableChar('x') instead of x.
+#ifndef __BORLANDC__
+  // ICE's in C++Builder.
+  EXPECT_FATAL_FAILURE(ASSERT_NE(UnprintableChar('x'), UnprintableChar('x')),
+                       "1-byte object <78>");
+  EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')),
+                       "1-byte object <78>");
+#endif
+  EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')),
+                       "1-byte object <79>");
+  EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')),
+                       "1-byte object <78>");
+  EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')),
+                       "1-byte object <79>");
+}
+
+// Tests the FRIEND_TEST macro.
+
+// This class has a private member we want to test.  We will test it
+// both in a TEST and in a TEST_F.
+class Foo {
+ public:
+  Foo() {}
+
+ private:
+  int Bar() const { return 1; }
+
+  // Declares the friend tests that can access the private member
+  // Bar().
+  FRIEND_TEST(FRIEND_TEST_Test, TEST);
+  FRIEND_TEST(FRIEND_TEST_Test2, TEST_F);
+};
+
+// Tests that the FRIEND_TEST declaration allows a TEST to access a
+// class's private members.  This should compile.
+TEST(FRIEND_TEST_Test, TEST) {
+  ASSERT_EQ(1, Foo().Bar());
+}
+
+// The fixture needed to test using FRIEND_TEST with TEST_F.
+class FRIEND_TEST_Test2 : public Test {
+ protected:
+  Foo foo;
+};
+
+// Tests that the FRIEND_TEST declaration allows a TEST_F to access a
+// class's private members.  This should compile.
+TEST_F(FRIEND_TEST_Test2, TEST_F) {
+  ASSERT_EQ(1, foo.Bar());
+}
+
+// Tests the life cycle of Test objects.
+
+// The test fixture for testing the life cycle of Test objects.
+//
+// This class counts the number of live test objects that uses this
+// fixture.
+class TestLifeCycleTest : public Test {
+ protected:
+  // Constructor.  Increments the number of test objects that uses
+  // this fixture.
+  TestLifeCycleTest() { count_++; }
+
+  // Destructor.  Decrements the number of test objects that uses this
+  // fixture.
+  ~TestLifeCycleTest() { count_--; }
+
+  // Returns the number of live test objects that uses this fixture.
+  int count() const { return count_; }
+
+ private:
+  static int count_;
+};
+
+int TestLifeCycleTest::count_ = 0;
+
+// Tests the life cycle of test objects.
+TEST_F(TestLifeCycleTest, Test1) {
+  // There should be only one test object in this test case that's
+  // currently alive.
+  ASSERT_EQ(1, count());
+}
+
+// Tests the life cycle of test objects.
+TEST_F(TestLifeCycleTest, Test2) {
+  // After Test1 is done and Test2 is started, there should still be
+  // only one live test object, as the object for Test1 should've been
+  // deleted.
+  ASSERT_EQ(1, count());
+}
+
+}  // namespace
+
+// Tests that the copy constructor works when it is NOT optimized away by
+// the compiler.
+TEST(AssertionResultTest, CopyConstructorWorksWhenNotOptimied) {
+  // Checks that the copy constructor doesn't try to dereference NULL pointers
+  // in the source object.
+  AssertionResult r1 = AssertionSuccess();
+  AssertionResult r2 = r1;
+  // The following line is added to prevent the compiler from optimizing
+  // away the constructor call.
+  r1 << "abc";
+
+  AssertionResult r3 = r1;
+  EXPECT_EQ(static_cast<bool>(r3), static_cast<bool>(r1));
+  EXPECT_STREQ("abc", r1.message());
+}
+
+// Tests that AssertionSuccess and AssertionFailure construct
+// AssertionResult objects as expected.
+TEST(AssertionResultTest, ConstructionWorks) {
+  AssertionResult r1 = AssertionSuccess();
+  EXPECT_TRUE(r1);
+  EXPECT_STREQ("", r1.message());
+
+  AssertionResult r2 = AssertionSuccess() << "abc";
+  EXPECT_TRUE(r2);
+  EXPECT_STREQ("abc", r2.message());
+
+  AssertionResult r3 = AssertionFailure();
+  EXPECT_FALSE(r3);
+  EXPECT_STREQ("", r3.message());
+
+  AssertionResult r4 = AssertionFailure() << "def";
+  EXPECT_FALSE(r4);
+  EXPECT_STREQ("def", r4.message());
+
+  AssertionResult r5 = AssertionFailure(Message() << "ghi");
+  EXPECT_FALSE(r5);
+  EXPECT_STREQ("ghi", r5.message());
+}
+
+// Tests that the negation flips the predicate result but keeps the message.
+TEST(AssertionResultTest, NegationWorks) {
+  AssertionResult r1 = AssertionSuccess() << "abc";
+  EXPECT_FALSE(!r1);
+  EXPECT_STREQ("abc", (!r1).message());
+
+  AssertionResult r2 = AssertionFailure() << "def";
+  EXPECT_TRUE(!r2);
+  EXPECT_STREQ("def", (!r2).message());
+}
+
+TEST(AssertionResultTest, StreamingWorks) {
+  AssertionResult r = AssertionSuccess();
+  r << "abc" << 'd' << 0 << true;
+  EXPECT_STREQ("abcd0true", r.message());
+}
+
+TEST(AssertionResultTest, CanStreamOstreamManipulators) {
+  AssertionResult r = AssertionSuccess();
+  r << "Data" << std::endl << std::flush << std::ends << "Will be visible";
+  EXPECT_STREQ("Data\n\\0Will be visible", r.message());
+}
+
+// The next test uses explicit conversion operators -- a C++11 feature.
+#if GTEST_LANG_CXX11
+
+TEST(AssertionResultTest, ConstructibleFromContextuallyConvertibleToBool) {
+  struct ExplicitlyConvertibleToBool {
+    explicit operator bool() const { return value; }
+    bool value;
+  };
+  ExplicitlyConvertibleToBool v1 = {false};
+  ExplicitlyConvertibleToBool v2 = {true};
+  EXPECT_FALSE(v1);
+  EXPECT_TRUE(v2);
+}
+
+#endif  // GTEST_LANG_CXX11
+
+struct ConvertibleToAssertionResult {
+  operator AssertionResult() const { return AssertionResult(true); }
+};
+
+TEST(AssertionResultTest, ConstructibleFromImplicitlyConvertible) {
+  ConvertibleToAssertionResult obj;
+  EXPECT_TRUE(obj);
+}
+
+// Tests streaming a user type whose definition and operator << are
+// both in the global namespace.
+class Base {
+ public:
+  explicit Base(int an_x) : x_(an_x) {}
+  int x() const { return x_; }
+ private:
+  int x_;
+};
+std::ostream& operator<<(std::ostream& os,
+                         const Base& val) {
+  return os << val.x();
+}
+std::ostream& operator<<(std::ostream& os,
+                         const Base* pointer) {
+  return os << "(" << pointer->x() << ")";
+}
+
+TEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) {
+  Message msg;
+  Base a(1);
+
+  msg << a << &a;  // Uses ::operator<<.
+  EXPECT_STREQ("1(1)", msg.GetString().c_str());
+}
+
+// Tests streaming a user type whose definition and operator<< are
+// both in an unnamed namespace.
+namespace {
+class MyTypeInUnnamedNameSpace : public Base {
+ public:
+  explicit MyTypeInUnnamedNameSpace(int an_x): Base(an_x) {}
+};
+std::ostream& operator<<(std::ostream& os,
+                         const MyTypeInUnnamedNameSpace& val) {
+  return os << val.x();
+}
+std::ostream& operator<<(std::ostream& os,
+                         const MyTypeInUnnamedNameSpace* pointer) {
+  return os << "(" << pointer->x() << ")";
+}
+}  // namespace
+
+TEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) {
+  Message msg;
+  MyTypeInUnnamedNameSpace a(1);
+
+  msg << a << &a;  // Uses <unnamed_namespace>::operator<<.
+  EXPECT_STREQ("1(1)", msg.GetString().c_str());
+}
+
+// Tests streaming a user type whose definition and operator<< are
+// both in a user namespace.
+namespace namespace1 {
+class MyTypeInNameSpace1 : public Base {
+ public:
+  explicit MyTypeInNameSpace1(int an_x): Base(an_x) {}
+};
+std::ostream& operator<<(std::ostream& os,
+                         const MyTypeInNameSpace1& val) {
+  return os << val.x();
+}
+std::ostream& operator<<(std::ostream& os,
+                         const MyTypeInNameSpace1* pointer) {
+  return os << "(" << pointer->x() << ")";
+}
+}  // namespace namespace1
+
+TEST(MessageTest, CanStreamUserTypeInUserNameSpace) {
+  Message msg;
+  namespace1::MyTypeInNameSpace1 a(1);
+
+  msg << a << &a;  // Uses namespace1::operator<<.
+  EXPECT_STREQ("1(1)", msg.GetString().c_str());
+}
+
+// Tests streaming a user type whose definition is in a user namespace
+// but whose operator<< is in the global namespace.
+namespace namespace2 {
+class MyTypeInNameSpace2 : public ::Base {
+ public:
+  explicit MyTypeInNameSpace2(int an_x): Base(an_x) {}
+};
+}  // namespace namespace2
+std::ostream& operator<<(std::ostream& os,
+                         const namespace2::MyTypeInNameSpace2& val) {
+  return os << val.x();
+}
+std::ostream& operator<<(std::ostream& os,
+                         const namespace2::MyTypeInNameSpace2* pointer) {
+  return os << "(" << pointer->x() << ")";
+}
+
+TEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) {
+  Message msg;
+  namespace2::MyTypeInNameSpace2 a(1);
+
+  msg << a << &a;  // Uses ::operator<<.
+  EXPECT_STREQ("1(1)", msg.GetString().c_str());
+}
+
+// Tests streaming NULL pointers to testing::Message.
+TEST(MessageTest, NullPointers) {
+  Message msg;
+  char* const p1 = NULL;
+  unsigned char* const p2 = NULL;
+  int* p3 = NULL;
+  double* p4 = NULL;
+  bool* p5 = NULL;
+  Message* p6 = NULL;
+
+  msg << p1 << p2 << p3 << p4 << p5 << p6;
+  ASSERT_STREQ("(null)(null)(null)(null)(null)(null)",
+               msg.GetString().c_str());
+}
+
+// Tests streaming wide strings to testing::Message.
+TEST(MessageTest, WideStrings) {
+  // Streams a NULL of type const wchar_t*.
+  const wchar_t* const_wstr = NULL;
+  EXPECT_STREQ("(null)",
+               (Message() << const_wstr).GetString().c_str());
+
+  // Streams a NULL of type wchar_t*.
+  wchar_t* wstr = NULL;
+  EXPECT_STREQ("(null)",
+               (Message() << wstr).GetString().c_str());
+
+  // Streams a non-NULL of type const wchar_t*.
+  const_wstr = L"abc\x8119";
+  EXPECT_STREQ("abc\xe8\x84\x99",
+               (Message() << const_wstr).GetString().c_str());
+
+  // Streams a non-NULL of type wchar_t*.
+  wstr = const_cast<wchar_t*>(const_wstr);
+  EXPECT_STREQ("abc\xe8\x84\x99",
+               (Message() << wstr).GetString().c_str());
+}
+
+
+// This line tests that we can define tests in the testing namespace.
+namespace testing {
+
+// Tests the TestInfo class.
+
+class TestInfoTest : public Test {
+ protected:
+  static const TestInfo* GetTestInfo(const char* test_name) {
+    const TestCase* const test_case = GetUnitTestImpl()->
+        GetTestCase("TestInfoTest", "", NULL, NULL);
+
+    for (int i = 0; i < test_case->total_test_count(); ++i) {
+      const TestInfo* const test_info = test_case->GetTestInfo(i);
+      if (strcmp(test_name, test_info->name()) == 0)
+        return test_info;
+    }
+    return NULL;
+  }
+
+  static const TestResult* GetTestResult(
+      const TestInfo* test_info) {
+    return test_info->result();
+  }
+};
+
+// Tests TestInfo::test_case_name() and TestInfo::name().
+TEST_F(TestInfoTest, Names) {
+  const TestInfo* const test_info = GetTestInfo("Names");
+
+  ASSERT_STREQ("TestInfoTest", test_info->test_case_name());
+  ASSERT_STREQ("Names", test_info->name());
+}
+
+// Tests TestInfo::result().
+TEST_F(TestInfoTest, result) {
+  const TestInfo* const test_info = GetTestInfo("result");
+
+  // Initially, there is no TestPartResult for this test.
+  ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
+
+  // After the previous assertion, there is still none.
+  ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
+}
+
+#define VERIFY_CODE_LOCATION \
+  const int expected_line = __LINE__ - 1; \
+  const TestInfo* const test_info = GetUnitTestImpl()->current_test_info(); \
+  ASSERT_TRUE(test_info); \
+  EXPECT_STREQ(__FILE__, test_info->file()); \
+  EXPECT_EQ(expected_line, test_info->line())
+
+TEST(CodeLocationForTEST, Verify) {
+  VERIFY_CODE_LOCATION;
+}
+
+class CodeLocationForTESTF : public Test {
+};
+
+TEST_F(CodeLocationForTESTF, Verify) {
+  VERIFY_CODE_LOCATION;
+}
+
+class CodeLocationForTESTP : public TestWithParam<int> {
+};
+
+TEST_P(CodeLocationForTESTP, Verify) {
+  VERIFY_CODE_LOCATION;
+}
+
+INSTANTIATE_TEST_CASE_P(, CodeLocationForTESTP, Values(0));
+
+template <typename T>
+class CodeLocationForTYPEDTEST : public Test {
+};
+
+TYPED_TEST_CASE(CodeLocationForTYPEDTEST, int);
+
+TYPED_TEST(CodeLocationForTYPEDTEST, Verify) {
+  VERIFY_CODE_LOCATION;
+}
+
+template <typename T>
+class CodeLocationForTYPEDTESTP : public Test {
+};
+
+TYPED_TEST_CASE_P(CodeLocationForTYPEDTESTP);
+
+TYPED_TEST_P(CodeLocationForTYPEDTESTP, Verify) {
+  VERIFY_CODE_LOCATION;
+}
+
+REGISTER_TYPED_TEST_CASE_P(CodeLocationForTYPEDTESTP, Verify);
+
+INSTANTIATE_TYPED_TEST_CASE_P(My, CodeLocationForTYPEDTESTP, int);
+
+#undef VERIFY_CODE_LOCATION
+
+// Tests setting up and tearing down a test case.
+
+class SetUpTestCaseTest : public Test {
+ protected:
+  // This will be called once before the first test in this test case
+  // is run.
+  static void SetUpTestCase() {
+    printf("Setting up the test case . . .\n");
+
+    // Initializes some shared resource.  In this simple example, we
+    // just create a C string.  More complex stuff can be done if
+    // desired.
+    shared_resource_ = "123";
+
+    // Increments the number of test cases that have been set up.
+    counter_++;
+
+    // SetUpTestCase() should be called only once.
+    EXPECT_EQ(1, counter_);
+  }
+
+  // This will be called once after the last test in this test case is
+  // run.
+  static void TearDownTestCase() {
+    printf("Tearing down the test case . . .\n");
+
+    // Decrements the number of test cases that have been set up.
+    counter_--;
+
+    // TearDownTestCase() should be called only once.
+    EXPECT_EQ(0, counter_);
+
+    // Cleans up the shared resource.
+    shared_resource_ = NULL;
+  }
+
+  // This will be called before each test in this test case.
+  virtual void SetUp() {
+    // SetUpTestCase() should be called only once, so counter_ should
+    // always be 1.
+    EXPECT_EQ(1, counter_);
+  }
+
+  // Number of test cases that have been set up.
+  static int counter_;
+
+  // Some resource to be shared by all tests in this test case.
+  static const char* shared_resource_;
+};
+
+int SetUpTestCaseTest::counter_ = 0;
+const char* SetUpTestCaseTest::shared_resource_ = NULL;
+
+// A test that uses the shared resource.
+TEST_F(SetUpTestCaseTest, Test1) {
+  EXPECT_STRNE(NULL, shared_resource_);
+}
+
+// Another test that uses the shared resource.
+TEST_F(SetUpTestCaseTest, Test2) {
+  EXPECT_STREQ("123", shared_resource_);
+}
+
+// The InitGoogleTestTest test case tests testing::InitGoogleTest().
+
+// The Flags struct stores a copy of all Google Test flags.
+struct Flags {
+  // Constructs a Flags struct where each flag has its default value.
+  Flags() : also_run_disabled_tests(false),
+            break_on_failure(false),
+            catch_exceptions(false),
+            death_test_use_fork(false),
+            filter(""),
+            list_tests(false),
+            output(""),
+            print_time(true),
+            random_seed(0),
+            repeat(1),
+            shuffle(false),
+            stack_trace_depth(kMaxStackTraceDepth),
+            stream_result_to(""),
+            throw_on_failure(false) {}
+
+  // Factory methods.
+
+  // Creates a Flags struct where the gtest_also_run_disabled_tests flag has
+  // the given value.
+  static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) {
+    Flags flags;
+    flags.also_run_disabled_tests = also_run_disabled_tests;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_break_on_failure flag has
+  // the given value.
+  static Flags BreakOnFailure(bool break_on_failure) {
+    Flags flags;
+    flags.break_on_failure = break_on_failure;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_catch_exceptions flag has
+  // the given value.
+  static Flags CatchExceptions(bool catch_exceptions) {
+    Flags flags;
+    flags.catch_exceptions = catch_exceptions;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_death_test_use_fork flag has
+  // the given value.
+  static Flags DeathTestUseFork(bool death_test_use_fork) {
+    Flags flags;
+    flags.death_test_use_fork = death_test_use_fork;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_filter flag has the given
+  // value.
+  static Flags Filter(const char* filter) {
+    Flags flags;
+    flags.filter = filter;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_list_tests flag has the
+  // given value.
+  static Flags ListTests(bool list_tests) {
+    Flags flags;
+    flags.list_tests = list_tests;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_output flag has the given
+  // value.
+  static Flags Output(const char* output) {
+    Flags flags;
+    flags.output = output;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_print_time flag has the given
+  // value.
+  static Flags PrintTime(bool print_time) {
+    Flags flags;
+    flags.print_time = print_time;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_random_seed flag has
+  // the given value.
+  static Flags RandomSeed(Int32 random_seed) {
+    Flags flags;
+    flags.random_seed = random_seed;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_repeat flag has the given
+  // value.
+  static Flags Repeat(Int32 repeat) {
+    Flags flags;
+    flags.repeat = repeat;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_shuffle flag has
+  // the given value.
+  static Flags Shuffle(bool shuffle) {
+    Flags flags;
+    flags.shuffle = shuffle;
+    return flags;
+  }
+
+  // Creates a Flags struct where the GTEST_FLAG(stack_trace_depth) flag has
+  // the given value.
+  static Flags StackTraceDepth(Int32 stack_trace_depth) {
+    Flags flags;
+    flags.stack_trace_depth = stack_trace_depth;
+    return flags;
+  }
+
+  // Creates a Flags struct where the GTEST_FLAG(stream_result_to) flag has
+  // the given value.
+  static Flags StreamResultTo(const char* stream_result_to) {
+    Flags flags;
+    flags.stream_result_to = stream_result_to;
+    return flags;
+  }
+
+  // Creates a Flags struct where the gtest_throw_on_failure flag has
+  // the given value.
+  static Flags ThrowOnFailure(bool throw_on_failure) {
+    Flags flags;
+    flags.throw_on_failure = throw_on_failure;
+    return flags;
+  }
+
+  // These fields store the flag values.
+  bool also_run_disabled_tests;
+  bool break_on_failure;
+  bool catch_exceptions;
+  bool death_test_use_fork;
+  const char* filter;
+  bool list_tests;
+  const char* output;
+  bool print_time;
+  Int32 random_seed;
+  Int32 repeat;
+  bool shuffle;
+  Int32 stack_trace_depth;
+  const char* stream_result_to;
+  bool throw_on_failure;
+};
+
+// Fixture for testing InitGoogleTest().
+class InitGoogleTestTest : public Test {
+ protected:
+  // Clears the flags before each test.
+  virtual void SetUp() {
+    GTEST_FLAG(also_run_disabled_tests) = false;
+    GTEST_FLAG(break_on_failure) = false;
+    GTEST_FLAG(catch_exceptions) = false;
+    GTEST_FLAG(death_test_use_fork) = false;
+    GTEST_FLAG(filter) = "";
+    GTEST_FLAG(list_tests) = false;
+    GTEST_FLAG(output) = "";
+    GTEST_FLAG(print_time) = true;
+    GTEST_FLAG(random_seed) = 0;
+    GTEST_FLAG(repeat) = 1;
+    GTEST_FLAG(shuffle) = false;
+    GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
+    GTEST_FLAG(stream_result_to) = "";
+    GTEST_FLAG(throw_on_failure) = false;
+  }
+
+  // Asserts that two narrow or wide string arrays are equal.
+  template <typename CharType>
+  static void AssertStringArrayEq(size_t size1, CharType** array1,
+                                  size_t size2, CharType** array2) {
+    ASSERT_EQ(size1, size2) << " Array sizes different.";
+
+    for (size_t i = 0; i != size1; i++) {
+      ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i;
+    }
+  }
+
+  // Verifies that the flag values match the expected values.
+  static void CheckFlags(const Flags& expected) {
+    EXPECT_EQ(expected.also_run_disabled_tests,
+              GTEST_FLAG(also_run_disabled_tests));
+    EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure));
+    EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions));
+    EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork));
+    EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str());
+    EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests));
+    EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str());
+    EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time));
+    EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed));
+    EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat));
+    EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle));
+    EXPECT_EQ(expected.stack_trace_depth, GTEST_FLAG(stack_trace_depth));
+    EXPECT_STREQ(expected.stream_result_to,
+                 GTEST_FLAG(stream_result_to).c_str());
+    EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure));
+  }
+
+  // Parses a command line (specified by argc1 and argv1), then
+  // verifies that the flag values are expected and that the
+  // recognized flags are removed from the command line.
+  template <typename CharType>
+  static void TestParsingFlags(int argc1, const CharType** argv1,
+                               int argc2, const CharType** argv2,
+                               const Flags& expected, bool should_print_help) {
+    const bool saved_help_flag = ::testing::internal::g_help_flag;
+    ::testing::internal::g_help_flag = false;
+
+#if GTEST_HAS_STREAM_REDIRECTION
+    CaptureStdout();
+#endif
+
+    // Parses the command line.
+    internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));
+
+#if GTEST_HAS_STREAM_REDIRECTION
+    const std::string captured_stdout = GetCapturedStdout();
+#endif
+
+    // Verifies the flag values.
+    CheckFlags(expected);
+
+    // Verifies that the recognized flags are removed from the command
+    // line.
+    AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2);
+
+    // ParseGoogleTestFlagsOnly should neither set g_help_flag nor print the
+    // help message for the flags it recognizes.
+    EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag);
+
+#if GTEST_HAS_STREAM_REDIRECTION
+    const char* const expected_help_fragment =
+        "This program contains tests written using";
+    if (should_print_help) {
+      EXPECT_PRED_FORMAT2(IsSubstring, expected_help_fragment, captured_stdout);
+    } else {
+      EXPECT_PRED_FORMAT2(IsNotSubstring,
+                          expected_help_fragment, captured_stdout);
+    }
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+    ::testing::internal::g_help_flag = saved_help_flag;
+  }
+
+  // This macro wraps TestParsingFlags s.t. the user doesn't need
+  // to specify the array sizes.
+
+#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \
+  TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \
+                   sizeof(argv2)/sizeof(*argv2) - 1, argv2, \
+                   expected, should_print_help)
+};
+
+// Tests parsing an empty command line.
+TEST_F(InitGoogleTestTest, Empty) {
+  const char* argv[] = {
+    NULL
+  };
+
+  const char* argv2[] = {
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
+}
+
+// Tests parsing a command line that has no flag.
+TEST_F(InitGoogleTestTest, NoFlag) {
+  const char* argv[] = {
+    "foo.exe",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
+}
+
+// Tests parsing a bad --gtest_filter flag.
+TEST_F(InitGoogleTestTest, FilterBad) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_filter",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    "--gtest_filter",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true);
+}
+
+// Tests parsing an empty --gtest_filter flag.
+TEST_F(InitGoogleTestTest, FilterEmpty) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_filter=",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), false);
+}
+
+// Tests parsing a non-empty --gtest_filter flag.
+TEST_F(InitGoogleTestTest, FilterNonEmpty) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_filter=abc",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
+}
+
+// Tests parsing --gtest_break_on_failure.
+TEST_F(InitGoogleTestTest, BreakOnFailureWithoutValue) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_break_on_failure",
+    NULL
+};
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
+}
+
+// Tests parsing --gtest_break_on_failure=0.
+TEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_break_on_failure=0",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
+}
+
+// Tests parsing --gtest_break_on_failure=f.
+TEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_break_on_failure=f",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
+}
+
+// Tests parsing --gtest_break_on_failure=F.
+TEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_break_on_failure=F",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
+}
+
+// Tests parsing a --gtest_break_on_failure flag that has a "true"
+// definition.
+TEST_F(InitGoogleTestTest, BreakOnFailureTrue) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_break_on_failure=1",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
+}
+
+// Tests parsing --gtest_catch_exceptions.
+TEST_F(InitGoogleTestTest, CatchExceptions) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_catch_exceptions",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true), false);
+}
+
+// Tests parsing --gtest_death_test_use_fork.
+TEST_F(InitGoogleTestTest, DeathTestUseFork) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_death_test_use_fork",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true), false);
+}
+
+// Tests having the same flag twice with different values.  The
+// expected behavior is that the one coming last takes precedence.
+TEST_F(InitGoogleTestTest, DuplicatedFlags) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_filter=a",
+    "--gtest_filter=b",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b"), false);
+}
+
+// Tests having an unrecognized flag on the command line.
+TEST_F(InitGoogleTestTest, UnrecognizedFlag) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_break_on_failure",
+    "bar",  // Unrecognized by Google Test.
+    "--gtest_filter=b",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    "bar",
+    NULL
+  };
+
+  Flags flags;
+  flags.break_on_failure = true;
+  flags.filter = "b";
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags, false);
+}
+
+// Tests having a --gtest_list_tests flag
+TEST_F(InitGoogleTestTest, ListTestsFlag) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_list_tests",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
+}
+
+// Tests having a --gtest_list_tests flag with a "true" value
+TEST_F(InitGoogleTestTest, ListTestsTrue) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_list_tests=1",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
+}
+
+// Tests having a --gtest_list_tests flag with a "false" value
+TEST_F(InitGoogleTestTest, ListTestsFalse) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_list_tests=0",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
+}
+
+// Tests parsing --gtest_list_tests=f.
+TEST_F(InitGoogleTestTest, ListTestsFalse_f) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_list_tests=f",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
+}
+
+// Tests parsing --gtest_list_tests=F.
+TEST_F(InitGoogleTestTest, ListTestsFalse_F) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_list_tests=F",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
+}
+
+// Tests parsing --gtest_output (invalid).
+TEST_F(InitGoogleTestTest, OutputEmpty) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_output",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    "--gtest_output",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true);
+}
+
+// Tests parsing --gtest_output=xml
+TEST_F(InitGoogleTestTest, OutputXml) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_output=xml",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"), false);
+}
+
+// Tests parsing --gtest_output=xml:file
+TEST_F(InitGoogleTestTest, OutputXmlFile) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_output=xml:file",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"), false);
+}
+
+// Tests parsing --gtest_output=xml:directory/path/
+TEST_F(InitGoogleTestTest, OutputXmlDirectory) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_output=xml:directory/path/",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2,
+                            Flags::Output("xml:directory/path/"), false);
+}
+
+// Tests having a --gtest_print_time flag
+TEST_F(InitGoogleTestTest, PrintTimeFlag) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_print_time",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
+}
+
+// Tests having a --gtest_print_time flag with a "true" value
+TEST_F(InitGoogleTestTest, PrintTimeTrue) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_print_time=1",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
+}
+
+// Tests having a --gtest_print_time flag with a "false" value
+TEST_F(InitGoogleTestTest, PrintTimeFalse) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_print_time=0",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
+}
+
+// Tests parsing --gtest_print_time=f.
+TEST_F(InitGoogleTestTest, PrintTimeFalse_f) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_print_time=f",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
+}
+
+// Tests parsing --gtest_print_time=F.
+TEST_F(InitGoogleTestTest, PrintTimeFalse_F) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_print_time=F",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
+}
+
+// Tests parsing --gtest_random_seed=number
+TEST_F(InitGoogleTestTest, RandomSeed) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_random_seed=1000",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000), false);
+}
+
+// Tests parsing --gtest_repeat=number
+TEST_F(InitGoogleTestTest, Repeat) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_repeat=1000",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false);
+}
+
+// Tests having a --gtest_also_run_disabled_tests flag
+TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_also_run_disabled_tests",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2,
+                              Flags::AlsoRunDisabledTests(true), false);
+}
+
+// Tests having a --gtest_also_run_disabled_tests flag with a "true" value
+TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_also_run_disabled_tests=1",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2,
+                              Flags::AlsoRunDisabledTests(true), false);
+}
+
+// Tests having a --gtest_also_run_disabled_tests flag with a "false" value
+TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) {
+    const char* argv[] = {
+      "foo.exe",
+      "--gtest_also_run_disabled_tests=0",
+      NULL
+    };
+
+    const char* argv2[] = {
+      "foo.exe",
+      NULL
+    };
+
+    GTEST_TEST_PARSING_FLAGS_(argv, argv2,
+                              Flags::AlsoRunDisabledTests(false), false);
+}
+
+// Tests parsing --gtest_shuffle.
+TEST_F(InitGoogleTestTest, ShuffleWithoutValue) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_shuffle",
+    NULL
+};
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
+}
+
+// Tests parsing --gtest_shuffle=0.
+TEST_F(InitGoogleTestTest, ShuffleFalse_0) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_shuffle=0",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false);
+}
+
+// Tests parsing a --gtest_shuffle flag that has a "true"
+// definition.
+TEST_F(InitGoogleTestTest, ShuffleTrue) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_shuffle=1",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
+}
+
+// Tests parsing --gtest_stack_trace_depth=number.
+TEST_F(InitGoogleTestTest, StackTraceDepth) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_stack_trace_depth=5",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false);
+}
+
+TEST_F(InitGoogleTestTest, StreamResultTo) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_stream_result_to=localhost:1234",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(
+      argv, argv2, Flags::StreamResultTo("localhost:1234"), false);
+}
+
+// Tests parsing --gtest_throw_on_failure.
+TEST_F(InitGoogleTestTest, ThrowOnFailureWithoutValue) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_throw_on_failure",
+    NULL
+};
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
+}
+
+// Tests parsing --gtest_throw_on_failure=0.
+TEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_throw_on_failure=0",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false), false);
+}
+
+// Tests parsing a --gtest_throw_on_failure flag that has a "true"
+// definition.
+TEST_F(InitGoogleTestTest, ThrowOnFailureTrue) {
+  const char* argv[] = {
+    "foo.exe",
+    "--gtest_throw_on_failure=1",
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
+}
+
+#if GTEST_OS_WINDOWS
+// Tests parsing wide strings.
+TEST_F(InitGoogleTestTest, WideStrings) {
+  const wchar_t* argv[] = {
+    L"foo.exe",
+    L"--gtest_filter=Foo*",
+    L"--gtest_list_tests=1",
+    L"--gtest_break_on_failure",
+    L"--non_gtest_flag",
+    NULL
+  };
+
+  const wchar_t* argv2[] = {
+    L"foo.exe",
+    L"--non_gtest_flag",
+    NULL
+  };
+
+  Flags expected_flags;
+  expected_flags.break_on_failure = true;
+  expected_flags.filter = "Foo*";
+  expected_flags.list_tests = true;
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false);
+}
+# endif  // GTEST_OS_WINDOWS
+
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+class FlagfileTest : public InitGoogleTestTest {
+ public:
+  virtual void SetUp() {
+    InitGoogleTestTest::SetUp();
+
+    testdata_path_.Set(internal::FilePath(
+        internal::TempDir() + internal::GetCurrentExecutableName().string() +
+        "_flagfile_test"));
+    testing::internal::posix::RmDir(testdata_path_.c_str());
+    EXPECT_TRUE(testdata_path_.CreateFolder());
+  }
+
+  virtual void TearDown() {
+    testing::internal::posix::RmDir(testdata_path_.c_str());
+    InitGoogleTestTest::TearDown();
+  }
+
+  internal::FilePath CreateFlagfile(const char* contents) {
+    internal::FilePath file_path(internal::FilePath::GenerateUniqueFileName(
+        testdata_path_, internal::FilePath("unique"), "txt"));
+    FILE* f = testing::internal::posix::FOpen(file_path.c_str(), "w");
+    fprintf(f, "%s", contents);
+    fclose(f);
+    return file_path;
+  }
+
+ private:
+  internal::FilePath testdata_path_;
+};
+
+// Tests an empty flagfile.
+TEST_F(FlagfileTest, Empty) {
+  internal::FilePath flagfile_path(CreateFlagfile(""));
+  std::string flagfile_flag =
+      std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
+
+  const char* argv[] = {
+    "foo.exe",
+    flagfile_flag.c_str(),
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
+}
+
+// Tests passing a non-empty --gtest_filter flag via --gtest_flagfile.
+TEST_F(FlagfileTest, FilterNonEmpty) {
+  internal::FilePath flagfile_path(CreateFlagfile(
+      "--"  GTEST_FLAG_PREFIX_  "filter=abc"));
+  std::string flagfile_flag =
+      std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
+
+  const char* argv[] = {
+    "foo.exe",
+    flagfile_flag.c_str(),
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
+}
+
+// Tests passing several flags via --gtest_flagfile.
+TEST_F(FlagfileTest, SeveralFlags) {
+  internal::FilePath flagfile_path(CreateFlagfile(
+      "--"  GTEST_FLAG_PREFIX_  "filter=abc\n"
+      "--"  GTEST_FLAG_PREFIX_  "break_on_failure\n"
+      "--"  GTEST_FLAG_PREFIX_  "list_tests"));
+  std::string flagfile_flag =
+      std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
+
+  const char* argv[] = {
+    "foo.exe",
+    flagfile_flag.c_str(),
+    NULL
+  };
+
+  const char* argv2[] = {
+    "foo.exe",
+    NULL
+  };
+
+  Flags expected_flags;
+  expected_flags.break_on_failure = true;
+  expected_flags.filter = "abc";
+  expected_flags.list_tests = true;
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false);
+}
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+
+// Tests current_test_info() in UnitTest.
+class CurrentTestInfoTest : public Test {
+ protected:
+  // Tests that current_test_info() returns NULL before the first test in
+  // the test case is run.
+  static void SetUpTestCase() {
+    // There should be no tests running at this point.
+    const TestInfo* test_info =
+      UnitTest::GetInstance()->current_test_info();
+    EXPECT_TRUE(test_info == NULL)
+        << "There should be no tests running at this point.";
+  }
+
+  // Tests that current_test_info() returns NULL after the last test in
+  // the test case has run.
+  static void TearDownTestCase() {
+    const TestInfo* test_info =
+      UnitTest::GetInstance()->current_test_info();
+    EXPECT_TRUE(test_info == NULL)
+        << "There should be no tests running at this point.";
+  }
+};
+
+// Tests that current_test_info() returns TestInfo for currently running
+// test by checking the expected test name against the actual one.
+TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) {
+  const TestInfo* test_info =
+    UnitTest::GetInstance()->current_test_info();
+  ASSERT_TRUE(NULL != test_info)
+      << "There is a test running so we should have a valid TestInfo.";
+  EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())
+      << "Expected the name of the currently running test case.";
+  EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name())
+      << "Expected the name of the currently running test.";
+}
+
+// Tests that current_test_info() returns TestInfo for currently running
+// test by checking the expected test name against the actual one.  We
+// use this test to see that the TestInfo object actually changed from
+// the previous invocation.
+TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) {
+  const TestInfo* test_info =
+    UnitTest::GetInstance()->current_test_info();
+  ASSERT_TRUE(NULL != test_info)
+      << "There is a test running so we should have a valid TestInfo.";
+  EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())
+      << "Expected the name of the currently running test case.";
+  EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name())
+      << "Expected the name of the currently running test.";
+}
+
+}  // namespace testing
+
+// These two lines test that we can define tests in a namespace that
+// has the name "testing" and is nested in another namespace.
+namespace my_namespace {
+namespace testing {
+
+// Makes sure that TEST knows to use ::testing::Test instead of
+// ::my_namespace::testing::Test.
+class Test {};
+
+// Makes sure that an assertion knows to use ::testing::Message instead of
+// ::my_namespace::testing::Message.
+class Message {};
+
+// Makes sure that an assertion knows to use
+// ::testing::AssertionResult instead of
+// ::my_namespace::testing::AssertionResult.
+class AssertionResult {};
+
+// Tests that an assertion that should succeed works as expected.
+TEST(NestedTestingNamespaceTest, Success) {
+  EXPECT_EQ(1, 1) << "This shouldn't fail.";
+}
+
+// Tests that an assertion that should fail works as expected.
+TEST(NestedTestingNamespaceTest, Failure) {
+  EXPECT_FATAL_FAILURE(FAIL() << "This failure is expected.",
+                       "This failure is expected.");
+}
+
+}  // namespace testing
+}  // namespace my_namespace
+
+// Tests that one can call superclass SetUp and TearDown methods--
+// that is, that they are not private.
+// No tests are based on this fixture; the test "passes" if it compiles
+// successfully.
+class ProtectedFixtureMethodsTest : public Test {
+ protected:
+  virtual void SetUp() {
+    Test::SetUp();
+  }
+  virtual void TearDown() {
+    Test::TearDown();
+  }
+};
+
+// StreamingAssertionsTest tests the streaming versions of a representative
+// sample of assertions.
+TEST(StreamingAssertionsTest, Unconditional) {
+  SUCCEED() << "expected success";
+  EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(FAIL() << "expected failure",
+                       "expected failure");
+}
+
+#ifdef __BORLANDC__
+// Silences warnings: "Condition is always true", "Unreachable code"
+# pragma option push -w-ccc -w-rch
+#endif
+
+TEST(StreamingAssertionsTest, Truth) {
+  EXPECT_TRUE(true) << "unexpected failure";
+  ASSERT_TRUE(true) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, Truth2) {
+  EXPECT_FALSE(false) << "unexpected failure";
+  ASSERT_FALSE(false) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure",
+                       "expected failure");
+}
+
+#ifdef __BORLANDC__
+// Restores warnings after previous "#pragma option push" supressed them
+# pragma option pop
+#endif
+
+TEST(StreamingAssertionsTest, IntegerEquals) {
+  EXPECT_EQ(1, 1) << "unexpected failure";
+  ASSERT_EQ(1, 1) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, IntegerLessThan) {
+  EXPECT_LT(1, 2) << "unexpected failure";
+  ASSERT_LT(1, 2) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, StringsEqual) {
+  EXPECT_STREQ("foo", "foo") << "unexpected failure";
+  ASSERT_STREQ("foo", "foo") << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, StringsNotEqual) {
+  EXPECT_STRNE("foo", "bar") << "unexpected failure";
+  ASSERT_STRNE("foo", "bar") << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, StringsEqualIgnoringCase) {
+  EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure";
+  ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) {
+  EXPECT_STRCASENE("foo", "bar") << "unexpected failure";
+  ASSERT_STRCASENE("foo", "bar") << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure",
+                       "expected failure");
+}
+
+TEST(StreamingAssertionsTest, FloatingPointEquals) {
+  EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";
+  ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure",
+                       "expected failure");
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+TEST(StreamingAssertionsTest, Throw) {
+  EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure";
+  ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) <<
+                          "expected failure", "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) <<
+                       "expected failure", "expected failure");
+}
+
+TEST(StreamingAssertionsTest, NoThrow) {
+  EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure";
+  ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) <<
+                          "expected failure", "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) <<
+                       "expected failure", "expected failure");
+}
+
+TEST(StreamingAssertionsTest, AnyThrow) {
+  EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
+  ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) <<
+                          "expected failure", "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) <<
+                       "expected failure", "expected failure");
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// Tests that Google Test correctly decides whether to use colors in the output.
+
+TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) {
+  GTEST_FLAG(color) = "yes";
+
+  SetEnv("TERM", "xterm");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
+
+  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
+}
+
+TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) {
+  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
+
+  GTEST_FLAG(color) = "True";
+  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
+
+  GTEST_FLAG(color) = "t";
+  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
+
+  GTEST_FLAG(color) = "1";
+  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
+}
+
+TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) {
+  GTEST_FLAG(color) = "no";
+
+  SetEnv("TERM", "xterm");  // TERM supports colors.
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
+
+  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
+}
+
+TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) {
+  SetEnv("TERM", "xterm");  // TERM supports colors.
+
+  GTEST_FLAG(color) = "F";
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  GTEST_FLAG(color) = "0";
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  GTEST_FLAG(color) = "unknown";
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+}
+
+TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {
+  GTEST_FLAG(color) = "auto";
+
+  SetEnv("TERM", "xterm");  // TERM supports colors.
+  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
+  EXPECT_TRUE(ShouldUseColor(true));    // Stdout is a TTY.
+}
+
+TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
+  GTEST_FLAG(color) = "auto";
+
+#if GTEST_OS_WINDOWS
+  // On Windows, we ignore the TERM variable as it's usually not set.
+
+  SetEnv("TERM", "dumb");
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "");
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "xterm");
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+#else
+  // On non-Windows platforms, we rely on TERM to determine if the
+  // terminal supports colors.
+
+  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "emacs");  // TERM doesn't support colors.
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "vt100");  // TERM doesn't support colors.
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "xterm-mono");  // TERM doesn't support colors.
+  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "xterm");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "xterm-color");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "xterm-256color");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "screen");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "screen-256color");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "tmux");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "tmux-256color");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "rxvt-unicode");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "rxvt-unicode-256color");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "linux");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "cygwin");  // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+#endif  // GTEST_OS_WINDOWS
+}
+
+// Verifies that StaticAssertTypeEq works in a namespace scope.
+
+static bool dummy1 GTEST_ATTRIBUTE_UNUSED_ = StaticAssertTypeEq<bool, bool>();
+static bool dummy2 GTEST_ATTRIBUTE_UNUSED_ =
+    StaticAssertTypeEq<const int, const int>();
+
+// Verifies that StaticAssertTypeEq works in a class.
+
+template <typename T>
+class StaticAssertTypeEqTestHelper {
+ public:
+  StaticAssertTypeEqTestHelper() { StaticAssertTypeEq<bool, T>(); }
+};
+
+TEST(StaticAssertTypeEqTest, WorksInClass) {
+  StaticAssertTypeEqTestHelper<bool>();
+}
+
+// Verifies that StaticAssertTypeEq works inside a function.
+
+typedef int IntAlias;
+
+TEST(StaticAssertTypeEqTest, CompilesForEqualTypes) {
+  StaticAssertTypeEq<int, IntAlias>();
+  StaticAssertTypeEq<int*, IntAlias*>();
+}
+
+TEST(GetCurrentOsStackTraceExceptTopTest, ReturnsTheStackTrace) {
+  testing::UnitTest* const unit_test = testing::UnitTest::GetInstance();
+
+  // We don't have a stack walker in Google Test yet.
+  EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 0).c_str());
+  EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 1).c_str());
+}
+
+TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) {
+  EXPECT_FALSE(HasNonfatalFailure());
+}
+
+static void FailFatally() { FAIL(); }
+
+TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure) {
+  FailFatally();
+  const bool has_nonfatal_failure = HasNonfatalFailure();
+  ClearCurrentTestPartResults();
+  EXPECT_FALSE(has_nonfatal_failure);
+}
+
+TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {
+  ADD_FAILURE();
+  const bool has_nonfatal_failure = HasNonfatalFailure();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_nonfatal_failure);
+}
+
+TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {
+  FailFatally();
+  ADD_FAILURE();
+  const bool has_nonfatal_failure = HasNonfatalFailure();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_nonfatal_failure);
+}
+
+// A wrapper for calling HasNonfatalFailure outside of a test body.
+static bool HasNonfatalFailureHelper() {
+  return testing::Test::HasNonfatalFailure();
+}
+
+TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody) {
+  EXPECT_FALSE(HasNonfatalFailureHelper());
+}
+
+TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody2) {
+  ADD_FAILURE();
+  const bool has_nonfatal_failure = HasNonfatalFailureHelper();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_nonfatal_failure);
+}
+
+TEST(HasFailureTest, ReturnsFalseWhenThereIsNoFailure) {
+  EXPECT_FALSE(HasFailure());
+}
+
+TEST(HasFailureTest, ReturnsTrueWhenThereIsFatalFailure) {
+  FailFatally();
+  const bool has_failure = HasFailure();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_failure);
+}
+
+TEST(HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {
+  ADD_FAILURE();
+  const bool has_failure = HasFailure();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_failure);
+}
+
+TEST(HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {
+  FailFatally();
+  ADD_FAILURE();
+  const bool has_failure = HasFailure();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_failure);
+}
+
+// A wrapper for calling HasFailure outside of a test body.
+static bool HasFailureHelper() { return testing::Test::HasFailure(); }
+
+TEST(HasFailureTest, WorksOutsideOfTestBody) {
+  EXPECT_FALSE(HasFailureHelper());
+}
+
+TEST(HasFailureTest, WorksOutsideOfTestBody2) {
+  ADD_FAILURE();
+  const bool has_failure = HasFailureHelper();
+  ClearCurrentTestPartResults();
+  EXPECT_TRUE(has_failure);
+}
+
+class TestListener : public EmptyTestEventListener {
+ public:
+  TestListener() : on_start_counter_(NULL), is_destroyed_(NULL) {}
+  TestListener(int* on_start_counter, bool* is_destroyed)
+      : on_start_counter_(on_start_counter),
+        is_destroyed_(is_destroyed) {}
+
+  virtual ~TestListener() {
+    if (is_destroyed_)
+      *is_destroyed_ = true;
+  }
+
+ protected:
+  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
+    if (on_start_counter_ != NULL)
+      (*on_start_counter_)++;
+  }
+
+ private:
+  int* on_start_counter_;
+  bool* is_destroyed_;
+};
+
+// Tests the constructor.
+TEST(TestEventListenersTest, ConstructionWorks) {
+  TestEventListeners listeners;
+
+  EXPECT_TRUE(TestEventListenersAccessor::GetRepeater(&listeners) != NULL);
+  EXPECT_TRUE(listeners.default_result_printer() == NULL);
+  EXPECT_TRUE(listeners.default_xml_generator() == NULL);
+}
+
+// Tests that the TestEventListeners destructor deletes all the listeners it
+// owns.
+TEST(TestEventListenersTest, DestructionWorks) {
+  bool default_result_printer_is_destroyed = false;
+  bool default_xml_printer_is_destroyed = false;
+  bool extra_listener_is_destroyed = false;
+  TestListener* default_result_printer = new TestListener(
+      NULL, &default_result_printer_is_destroyed);
+  TestListener* default_xml_printer = new TestListener(
+      NULL, &default_xml_printer_is_destroyed);
+  TestListener* extra_listener = new TestListener(
+      NULL, &extra_listener_is_destroyed);
+
+  {
+    TestEventListeners listeners;
+    TestEventListenersAccessor::SetDefaultResultPrinter(&listeners,
+                                                        default_result_printer);
+    TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners,
+                                                       default_xml_printer);
+    listeners.Append(extra_listener);
+  }
+  EXPECT_TRUE(default_result_printer_is_destroyed);
+  EXPECT_TRUE(default_xml_printer_is_destroyed);
+  EXPECT_TRUE(extra_listener_is_destroyed);
+}
+
+// Tests that a listener Append'ed to a TestEventListeners list starts
+// receiving events.
+TEST(TestEventListenersTest, Append) {
+  int on_start_counter = 0;
+  bool is_destroyed = false;
+  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
+  {
+    TestEventListeners listeners;
+    listeners.Append(listener);
+    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+        *UnitTest::GetInstance());
+    EXPECT_EQ(1, on_start_counter);
+  }
+  EXPECT_TRUE(is_destroyed);
+}
+
+// Tests that listeners receive events in the order they were appended to
+// the list, except for *End requests, which must be received in the reverse
+// order.
+class SequenceTestingListener : public EmptyTestEventListener {
+ public:
+  SequenceTestingListener(std::vector<std::string>* vector, const char* id)
+      : vector_(vector), id_(id) {}
+
+ protected:
+  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
+    vector_->push_back(GetEventDescription("OnTestProgramStart"));
+  }
+
+  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
+    vector_->push_back(GetEventDescription("OnTestProgramEnd"));
+  }
+
+  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
+                                    int /*iteration*/) {
+    vector_->push_back(GetEventDescription("OnTestIterationStart"));
+  }
+
+  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
+                                  int /*iteration*/) {
+    vector_->push_back(GetEventDescription("OnTestIterationEnd"));
+  }
+
+ private:
+  std::string GetEventDescription(const char* method) {
+    Message message;
+    message << id_ << "." << method;
+    return message.GetString();
+  }
+
+  std::vector<std::string>* vector_;
+  const char* const id_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener);
+};
+
+TEST(EventListenerTest, AppendKeepsOrder) {
+  std::vector<std::string> vec;
+  TestEventListeners listeners;
+  listeners.Append(new SequenceTestingListener(&vec, "1st"));
+  listeners.Append(new SequenceTestingListener(&vec, "2nd"));
+  listeners.Append(new SequenceTestingListener(&vec, "3rd"));
+
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+      *UnitTest::GetInstance());
+  ASSERT_EQ(3U, vec.size());
+  EXPECT_STREQ("1st.OnTestProgramStart", vec[0].c_str());
+  EXPECT_STREQ("2nd.OnTestProgramStart", vec[1].c_str());
+  EXPECT_STREQ("3rd.OnTestProgramStart", vec[2].c_str());
+
+  vec.clear();
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd(
+      *UnitTest::GetInstance());
+  ASSERT_EQ(3U, vec.size());
+  EXPECT_STREQ("3rd.OnTestProgramEnd", vec[0].c_str());
+  EXPECT_STREQ("2nd.OnTestProgramEnd", vec[1].c_str());
+  EXPECT_STREQ("1st.OnTestProgramEnd", vec[2].c_str());
+
+  vec.clear();
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart(
+      *UnitTest::GetInstance(), 0);
+  ASSERT_EQ(3U, vec.size());
+  EXPECT_STREQ("1st.OnTestIterationStart", vec[0].c_str());
+  EXPECT_STREQ("2nd.OnTestIterationStart", vec[1].c_str());
+  EXPECT_STREQ("3rd.OnTestIterationStart", vec[2].c_str());
+
+  vec.clear();
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd(
+      *UnitTest::GetInstance(), 0);
+  ASSERT_EQ(3U, vec.size());
+  EXPECT_STREQ("3rd.OnTestIterationEnd", vec[0].c_str());
+  EXPECT_STREQ("2nd.OnTestIterationEnd", vec[1].c_str());
+  EXPECT_STREQ("1st.OnTestIterationEnd", vec[2].c_str());
+}
+
+// Tests that a listener removed from a TestEventListeners list stops receiving
+// events and is not deleted when the list is destroyed.
+TEST(TestEventListenersTest, Release) {
+  int on_start_counter = 0;
+  bool is_destroyed = false;
+  // Although Append passes the ownership of this object to the list,
+  // the following calls release it, and we need to delete it before the
+  // test ends.
+  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
+  {
+    TestEventListeners listeners;
+    listeners.Append(listener);
+    EXPECT_EQ(listener, listeners.Release(listener));
+    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+        *UnitTest::GetInstance());
+    EXPECT_TRUE(listeners.Release(listener) == NULL);
+  }
+  EXPECT_EQ(0, on_start_counter);
+  EXPECT_FALSE(is_destroyed);
+  delete listener;
+}
+
+// Tests that no events are forwarded when event forwarding is disabled.
+TEST(EventListenerTest, SuppressEventForwarding) {
+  int on_start_counter = 0;
+  TestListener* listener = new TestListener(&on_start_counter, NULL);
+
+  TestEventListeners listeners;
+  listeners.Append(listener);
+  ASSERT_TRUE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
+  TestEventListenersAccessor::SuppressEventForwarding(&listeners);
+  ASSERT_FALSE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+      *UnitTest::GetInstance());
+  EXPECT_EQ(0, on_start_counter);
+}
+
+// Tests that events generated by Google Test are not forwarded in
+// death test subprocesses.
+TEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses) {
+  EXPECT_DEATH_IF_SUPPORTED({
+      GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled(
+          *GetUnitTestImpl()->listeners())) << "expected failure";},
+      "expected failure");
+}
+
+// Tests that a listener installed via SetDefaultResultPrinter() starts
+// receiving events and is returned via default_result_printer() and that
+// the previous default_result_printer is removed from the list and deleted.
+TEST(EventListenerTest, default_result_printer) {
+  int on_start_counter = 0;
+  bool is_destroyed = false;
+  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
+
+  TestEventListeners listeners;
+  TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);
+
+  EXPECT_EQ(listener, listeners.default_result_printer());
+
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+      *UnitTest::GetInstance());
+
+  EXPECT_EQ(1, on_start_counter);
+
+  // Replacing default_result_printer with something else should remove it
+  // from the list and destroy it.
+  TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, NULL);
+
+  EXPECT_TRUE(listeners.default_result_printer() == NULL);
+  EXPECT_TRUE(is_destroyed);
+
+  // After broadcasting an event the counter is still the same, indicating
+  // the listener is not in the list anymore.
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+      *UnitTest::GetInstance());
+  EXPECT_EQ(1, on_start_counter);
+}
+
+// Tests that the default_result_printer listener stops receiving events
+// when removed via Release and that is not owned by the list anymore.
+TEST(EventListenerTest, RemovingDefaultResultPrinterWorks) {
+  int on_start_counter = 0;
+  bool is_destroyed = false;
+  // Although Append passes the ownership of this object to the list,
+  // the following calls release it, and we need to delete it before the
+  // test ends.
+  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
+  {
+    TestEventListeners listeners;
+    TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);
+
+    EXPECT_EQ(listener, listeners.Release(listener));
+    EXPECT_TRUE(listeners.default_result_printer() == NULL);
+    EXPECT_FALSE(is_destroyed);
+
+    // Broadcasting events now should not affect default_result_printer.
+    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+        *UnitTest::GetInstance());
+    EXPECT_EQ(0, on_start_counter);
+  }
+  // Destroying the list should not affect the listener now, too.
+  EXPECT_FALSE(is_destroyed);
+  delete listener;
+}
+
+// Tests that a listener installed via SetDefaultXmlGenerator() starts
+// receiving events and is returned via default_xml_generator() and that
+// the previous default_xml_generator is removed from the list and deleted.
+TEST(EventListenerTest, default_xml_generator) {
+  int on_start_counter = 0;
+  bool is_destroyed = false;
+  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
+
+  TestEventListeners listeners;
+  TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);
+
+  EXPECT_EQ(listener, listeners.default_xml_generator());
+
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+      *UnitTest::GetInstance());
+
+  EXPECT_EQ(1, on_start_counter);
+
+  // Replacing default_xml_generator with something else should remove it
+  // from the list and destroy it.
+  TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, NULL);
+
+  EXPECT_TRUE(listeners.default_xml_generator() == NULL);
+  EXPECT_TRUE(is_destroyed);
+
+  // After broadcasting an event the counter is still the same, indicating
+  // the listener is not in the list anymore.
+  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+      *UnitTest::GetInstance());
+  EXPECT_EQ(1, on_start_counter);
+}
+
+// Tests that the default_xml_generator listener stops receiving events
+// when removed via Release and that is not owned by the list anymore.
+TEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) {
+  int on_start_counter = 0;
+  bool is_destroyed = false;
+  // Although Append passes the ownership of this object to the list,
+  // the following calls release it, and we need to delete it before the
+  // test ends.
+  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
+  {
+    TestEventListeners listeners;
+    TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);
+
+    EXPECT_EQ(listener, listeners.Release(listener));
+    EXPECT_TRUE(listeners.default_xml_generator() == NULL);
+    EXPECT_FALSE(is_destroyed);
+
+    // Broadcasting events now should not affect default_xml_generator.
+    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
+        *UnitTest::GetInstance());
+    EXPECT_EQ(0, on_start_counter);
+  }
+  // Destroying the list should not affect the listener now, too.
+  EXPECT_FALSE(is_destroyed);
+  delete listener;
+}
+
+// Sanity tests to ensure that the alternative, verbose spellings of
+// some of the macros work.  We don't test them thoroughly as that
+// would be quite involved.  Since their implementations are
+// straightforward, and they are rarely used, we'll just rely on the
+// users to tell us when they are broken.
+GTEST_TEST(AlternativeNameTest, Works) {  // GTEST_TEST is the same as TEST.
+  GTEST_SUCCEED() << "OK";  // GTEST_SUCCEED is the same as SUCCEED.
+
+  // GTEST_FAIL is the same as FAIL.
+  EXPECT_FATAL_FAILURE(GTEST_FAIL() << "An expected failure",
+                       "An expected failure");
+
+  // GTEST_ASSERT_XY is the same as ASSERT_XY.
+
+  GTEST_ASSERT_EQ(0, 0);
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(0, 1) << "An expected failure",
+                       "An expected failure");
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(1, 0) << "An expected failure",
+                       "An expected failure");
+
+  GTEST_ASSERT_NE(0, 1);
+  GTEST_ASSERT_NE(1, 0);
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_NE(0, 0) << "An expected failure",
+                       "An expected failure");
+
+  GTEST_ASSERT_LE(0, 0);
+  GTEST_ASSERT_LE(0, 1);
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LE(1, 0) << "An expected failure",
+                       "An expected failure");
+
+  GTEST_ASSERT_LT(0, 1);
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(0, 0) << "An expected failure",
+                       "An expected failure");
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(1, 0) << "An expected failure",
+                       "An expected failure");
+
+  GTEST_ASSERT_GE(0, 0);
+  GTEST_ASSERT_GE(1, 0);
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GE(0, 1) << "An expected failure",
+                       "An expected failure");
+
+  GTEST_ASSERT_GT(1, 0);
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(0, 1) << "An expected failure",
+                       "An expected failure");
+  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(1, 1) << "An expected failure",
+                       "An expected failure");
+}
+
+// Tests for internal utilities necessary for implementation of the universal
+// printing.
+// TODO(vladl@google.com): Find a better home for them.
+
+class ConversionHelperBase {};
+class ConversionHelperDerived : public ConversionHelperBase {};
+
+// Tests that IsAProtocolMessage<T>::value is a compile-time constant.
+TEST(IsAProtocolMessageTest, ValueIsCompileTimeConstant) {
+  GTEST_COMPILE_ASSERT_(IsAProtocolMessage<ProtocolMessage>::value,
+                        const_true);
+  GTEST_COMPILE_ASSERT_(!IsAProtocolMessage<int>::value, const_false);
+}
+
+// Tests that IsAProtocolMessage<T>::value is true when T is
+// proto2::Message or a sub-class of it.
+TEST(IsAProtocolMessageTest, ValueIsTrueWhenTypeIsAProtocolMessage) {
+  EXPECT_TRUE(IsAProtocolMessage< ::proto2::Message>::value);
+  EXPECT_TRUE(IsAProtocolMessage<ProtocolMessage>::value);
+}
+
+// Tests that IsAProtocolMessage<T>::value is false when T is neither
+// ProtocolMessage nor a sub-class of it.
+TEST(IsAProtocolMessageTest, ValueIsFalseWhenTypeIsNotAProtocolMessage) {
+  EXPECT_FALSE(IsAProtocolMessage<int>::value);
+  EXPECT_FALSE(IsAProtocolMessage<const ConversionHelperBase>::value);
+}
+
+// Tests that CompileAssertTypesEqual compiles when the type arguments are
+// equal.
+TEST(CompileAssertTypesEqual, CompilesWhenTypesAreEqual) {
+  CompileAssertTypesEqual<void, void>();
+  CompileAssertTypesEqual<int*, int*>();
+}
+
+// Tests that RemoveReference does not affect non-reference types.
+TEST(RemoveReferenceTest, DoesNotAffectNonReferenceType) {
+  CompileAssertTypesEqual<int, RemoveReference<int>::type>();
+  CompileAssertTypesEqual<const char, RemoveReference<const char>::type>();
+}
+
+// Tests that RemoveReference removes reference from reference types.
+TEST(RemoveReferenceTest, RemovesReference) {
+  CompileAssertTypesEqual<int, RemoveReference<int&>::type>();
+  CompileAssertTypesEqual<const char, RemoveReference<const char&>::type>();
+}
+
+// Tests GTEST_REMOVE_REFERENCE_.
+
+template <typename T1, typename T2>
+void TestGTestRemoveReference() {
+  CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_(T2)>();
+}
+
+TEST(RemoveReferenceTest, MacroVersion) {
+  TestGTestRemoveReference<int, int>();
+  TestGTestRemoveReference<const char, const char&>();
+}
+
+
+// Tests that RemoveConst does not affect non-const types.
+TEST(RemoveConstTest, DoesNotAffectNonConstType) {
+  CompileAssertTypesEqual<int, RemoveConst<int>::type>();
+  CompileAssertTypesEqual<char&, RemoveConst<char&>::type>();
+}
+
+// Tests that RemoveConst removes const from const types.
+TEST(RemoveConstTest, RemovesConst) {
+  CompileAssertTypesEqual<int, RemoveConst<const int>::type>();
+  CompileAssertTypesEqual<char[2], RemoveConst<const char[2]>::type>();
+  CompileAssertTypesEqual<char[2][3], RemoveConst<const char[2][3]>::type>();
+}
+
+// Tests GTEST_REMOVE_CONST_.
+
+template <typename T1, typename T2>
+void TestGTestRemoveConst() {
+  CompileAssertTypesEqual<T1, GTEST_REMOVE_CONST_(T2)>();
+}
+
+TEST(RemoveConstTest, MacroVersion) {
+  TestGTestRemoveConst<int, int>();
+  TestGTestRemoveConst<double&, double&>();
+  TestGTestRemoveConst<char, const char>();
+}
+
+// Tests GTEST_REMOVE_REFERENCE_AND_CONST_.
+
+template <typename T1, typename T2>
+void TestGTestRemoveReferenceAndConst() {
+  CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_AND_CONST_(T2)>();
+}
+
+TEST(RemoveReferenceToConstTest, Works) {
+  TestGTestRemoveReferenceAndConst<int, int>();
+  TestGTestRemoveReferenceAndConst<double, double&>();
+  TestGTestRemoveReferenceAndConst<char, const char>();
+  TestGTestRemoveReferenceAndConst<char, const char&>();
+  TestGTestRemoveReferenceAndConst<const char*, const char*>();
+}
+
+// Tests that AddReference does not affect reference types.
+TEST(AddReferenceTest, DoesNotAffectReferenceType) {
+  CompileAssertTypesEqual<int&, AddReference<int&>::type>();
+  CompileAssertTypesEqual<const char&, AddReference<const char&>::type>();
+}
+
+// Tests that AddReference adds reference to non-reference types.
+TEST(AddReferenceTest, AddsReference) {
+  CompileAssertTypesEqual<int&, AddReference<int>::type>();
+  CompileAssertTypesEqual<const char&, AddReference<const char>::type>();
+}
+
+// Tests GTEST_ADD_REFERENCE_.
+
+template <typename T1, typename T2>
+void TestGTestAddReference() {
+  CompileAssertTypesEqual<T1, GTEST_ADD_REFERENCE_(T2)>();
+}
+
+TEST(AddReferenceTest, MacroVersion) {
+  TestGTestAddReference<int&, int>();
+  TestGTestAddReference<const char&, const char&>();
+}
+
+// Tests GTEST_REFERENCE_TO_CONST_.
+
+template <typename T1, typename T2>
+void TestGTestReferenceToConst() {
+  CompileAssertTypesEqual<T1, GTEST_REFERENCE_TO_CONST_(T2)>();
+}
+
+TEST(GTestReferenceToConstTest, Works) {
+  TestGTestReferenceToConst<const char&, char>();
+  TestGTestReferenceToConst<const int&, const int>();
+  TestGTestReferenceToConst<const double&, double>();
+  TestGTestReferenceToConst<const std::string&, const std::string&>();
+}
+
+// Tests that ImplicitlyConvertible<T1, T2>::value is a compile-time constant.
+TEST(ImplicitlyConvertibleTest, ValueIsCompileTimeConstant) {
+  GTEST_COMPILE_ASSERT_((ImplicitlyConvertible<int, int>::value), const_true);
+  GTEST_COMPILE_ASSERT_((!ImplicitlyConvertible<void*, int*>::value),
+                        const_false);
+}
+
+// Tests that ImplicitlyConvertible<T1, T2>::value is true when T1 can
+// be implicitly converted to T2.
+TEST(ImplicitlyConvertibleTest, ValueIsTrueWhenConvertible) {
+  EXPECT_TRUE((ImplicitlyConvertible<int, double>::value));
+  EXPECT_TRUE((ImplicitlyConvertible<double, int>::value));
+  EXPECT_TRUE((ImplicitlyConvertible<int*, void*>::value));
+  EXPECT_TRUE((ImplicitlyConvertible<int*, const int*>::value));
+  EXPECT_TRUE((ImplicitlyConvertible<ConversionHelperDerived&,
+                                     const ConversionHelperBase&>::value));
+  EXPECT_TRUE((ImplicitlyConvertible<const ConversionHelperBase,
+                                     ConversionHelperBase>::value));
+}
+
+// Tests that ImplicitlyConvertible<T1, T2>::value is false when T1
+// cannot be implicitly converted to T2.
+TEST(ImplicitlyConvertibleTest, ValueIsFalseWhenNotConvertible) {
+  EXPECT_FALSE((ImplicitlyConvertible<double, int*>::value));
+  EXPECT_FALSE((ImplicitlyConvertible<void*, int*>::value));
+  EXPECT_FALSE((ImplicitlyConvertible<const int*, int*>::value));
+  EXPECT_FALSE((ImplicitlyConvertible<ConversionHelperBase&,
+                                      ConversionHelperDerived&>::value));
+}
+
+// Tests IsContainerTest.
+
+class NonContainer {};
+
+TEST(IsContainerTestTest, WorksForNonContainer) {
+  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<int>(0)));
+  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<char[5]>(0)));
+  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<NonContainer>(0)));
+}
+
+TEST(IsContainerTestTest, WorksForContainer) {
+  EXPECT_EQ(sizeof(IsContainer),
+            sizeof(IsContainerTest<std::vector<bool> >(0)));
+  EXPECT_EQ(sizeof(IsContainer),
+            sizeof(IsContainerTest<std::map<int, double> >(0)));
+}
+
+// Tests ArrayEq().
+
+TEST(ArrayEqTest, WorksForDegeneratedArrays) {
+  EXPECT_TRUE(ArrayEq(5, 5L));
+  EXPECT_FALSE(ArrayEq('a', 0));
+}
+
+TEST(ArrayEqTest, WorksForOneDimensionalArrays) {
+  // Note that a and b are distinct but compatible types.
+  const int a[] = { 0, 1 };
+  long b[] = { 0, 1 };
+  EXPECT_TRUE(ArrayEq(a, b));
+  EXPECT_TRUE(ArrayEq(a, 2, b));
+
+  b[0] = 2;
+  EXPECT_FALSE(ArrayEq(a, b));
+  EXPECT_FALSE(ArrayEq(a, 1, b));
+}
+
+TEST(ArrayEqTest, WorksForTwoDimensionalArrays) {
+  const char a[][3] = { "hi", "lo" };
+  const char b[][3] = { "hi", "lo" };
+  const char c[][3] = { "hi", "li" };
+
+  EXPECT_TRUE(ArrayEq(a, b));
+  EXPECT_TRUE(ArrayEq(a, 2, b));
+
+  EXPECT_FALSE(ArrayEq(a, c));
+  EXPECT_FALSE(ArrayEq(a, 2, c));
+}
+
+// Tests ArrayAwareFind().
+
+TEST(ArrayAwareFindTest, WorksForOneDimensionalArray) {
+  const char a[] = "hello";
+  EXPECT_EQ(a + 4, ArrayAwareFind(a, a + 5, 'o'));
+  EXPECT_EQ(a + 5, ArrayAwareFind(a, a + 5, 'x'));
+}
+
+TEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) {
+  int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };
+  const int b[2] = { 2, 3 };
+  EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b));
+
+  const int c[2] = { 6, 7 };
+  EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c));
+}
+
+// Tests CopyArray().
+
+TEST(CopyArrayTest, WorksForDegeneratedArrays) {
+  int n = 0;
+  CopyArray('a', &n);
+  EXPECT_EQ('a', n);
+}
+
+TEST(CopyArrayTest, WorksForOneDimensionalArrays) {
+  const char a[3] = "hi";
+  int b[3];
+#ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.
+  CopyArray(a, &b);
+  EXPECT_TRUE(ArrayEq(a, b));
+#endif
+
+  int c[3];
+  CopyArray(a, 3, c);
+  EXPECT_TRUE(ArrayEq(a, c));
+}
+
+TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {
+  const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } };
+  int b[2][3];
+#ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.
+  CopyArray(a, &b);
+  EXPECT_TRUE(ArrayEq(a, b));
+#endif
+
+  int c[2][3];
+  CopyArray(a, 2, c);
+  EXPECT_TRUE(ArrayEq(a, c));
+}
+
+// Tests NativeArray.
+
+TEST(NativeArrayTest, ConstructorFromArrayWorks) {
+  const int a[3] = { 0, 1, 2 };
+  NativeArray<int> na(a, 3, RelationToSourceReference());
+  EXPECT_EQ(3U, na.size());
+  EXPECT_EQ(a, na.begin());
+}
+
+TEST(NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo) {
+  typedef int Array[2];
+  Array* a = new Array[1];
+  (*a)[0] = 0;
+  (*a)[1] = 1;
+  NativeArray<int> na(*a, 2, RelationToSourceCopy());
+  EXPECT_NE(*a, na.begin());
+  delete[] a;
+  EXPECT_EQ(0, na.begin()[0]);
+  EXPECT_EQ(1, na.begin()[1]);
+
+  // We rely on the heap checker to verify that na deletes the copy of
+  // array.
+}
+
+TEST(NativeArrayTest, TypeMembersAreCorrect) {
+  StaticAssertTypeEq<char, NativeArray<char>::value_type>();
+  StaticAssertTypeEq<int[2], NativeArray<int[2]>::value_type>();
+
+  StaticAssertTypeEq<const char*, NativeArray<char>::const_iterator>();
+  StaticAssertTypeEq<const bool(*)[2], NativeArray<bool[2]>::const_iterator>();
+}
+
+TEST(NativeArrayTest, MethodsWork) {
+  const int a[3] = { 0, 1, 2 };
+  NativeArray<int> na(a, 3, RelationToSourceCopy());
+  ASSERT_EQ(3U, na.size());
+  EXPECT_EQ(3, na.end() - na.begin());
+
+  NativeArray<int>::const_iterator it = na.begin();
+  EXPECT_EQ(0, *it);
+  ++it;
+  EXPECT_EQ(1, *it);
+  it++;
+  EXPECT_EQ(2, *it);
+  ++it;
+  EXPECT_EQ(na.end(), it);
+
+  EXPECT_TRUE(na == na);
+
+  NativeArray<int> na2(a, 3, RelationToSourceReference());
+  EXPECT_TRUE(na == na2);
+
+  const int b1[3] = { 0, 1, 1 };
+  const int b2[4] = { 0, 1, 2, 3 };
+  EXPECT_FALSE(na == NativeArray<int>(b1, 3, RelationToSourceReference()));
+  EXPECT_FALSE(na == NativeArray<int>(b2, 4, RelationToSourceCopy()));
+}
+
+TEST(NativeArrayTest, WorksForTwoDimensionalArray) {
+  const char a[2][3] = { "hi", "lo" };
+  NativeArray<char[3]> na(a, 2, RelationToSourceReference());
+  ASSERT_EQ(2U, na.size());
+  EXPECT_EQ(a, na.begin());
+}
+
+// Tests SkipPrefix().
+
+TEST(SkipPrefixTest, SkipsWhenPrefixMatches) {
+  const char* const str = "hello";
+
+  const char* p = str;
+  EXPECT_TRUE(SkipPrefix("", &p));
+  EXPECT_EQ(str, p);
+
+  p = str;
+  EXPECT_TRUE(SkipPrefix("hell", &p));
+  EXPECT_EQ(str + 4, p);
+}
+
+TEST(SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch) {
+  const char* const str = "world";
+
+  const char* p = str;
+  EXPECT_FALSE(SkipPrefix("W", &p));
+  EXPECT_EQ(str, p);
+
+  p = str;
+  EXPECT_FALSE(SkipPrefix("world!", &p));
+  EXPECT_EQ(str, p);
+}
+
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile1_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile1_test_.cc
new file mode 100644
index 00000000..531ced49
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile1_test_.cc
@@ -0,0 +1,49 @@
+// 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.
+//
+// Author: keith.ray@gmail.com (Keith Ray)
+//
+// gtest_xml_outfile1_test_ writes some xml via TestProperty used by
+// gtest_xml_outfiles_test.py
+
+#include "gtest/gtest.h"
+
+class PropertyOne : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    RecordProperty("SetUpProp", 1);
+  }
+  virtual void TearDown() {
+    RecordProperty("TearDownProp", 1);
+  }
+};
+
+TEST_F(PropertyOne, TestSomeProperties) {
+  RecordProperty("TestSomeProperty", 1);
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile2_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile2_test_.cc
new file mode 100644
index 00000000..7b400b27
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile2_test_.cc
@@ -0,0 +1,49 @@
+// 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.
+//
+// Author: keith.ray@gmail.com (Keith Ray)
+//
+// gtest_xml_outfile2_test_ writes some xml via TestProperty used by
+// gtest_xml_outfiles_test.py
+
+#include "gtest/gtest.h"
+
+class PropertyTwo : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    RecordProperty("SetUpProp", 2);
+  }
+  virtual void TearDown() {
+    RecordProperty("TearDownProp", 2);
+  }
+};
+
+TEST_F(PropertyTwo, TestSomeProperties) {
+  RecordProperty("TestSomeProperty", 2);
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfiles_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfiles_test.py
new file mode 100755
index 00000000..524e437e
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfiles_test.py
@@ -0,0 +1,132 @@
+#!/usr/bin/env python
+#
+# 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.
+
+"""Unit test for the gtest_xml_output module."""
+
+__author__ = "keith.ray@gmail.com (Keith Ray)"
+
+import os
+from xml.dom import minidom, Node
+
+import gtest_test_utils
+import gtest_xml_test_utils
+
+
+GTEST_OUTPUT_SUBDIR = "xml_outfiles"
+GTEST_OUTPUT_1_TEST = "gtest_xml_outfile1_test_"
+GTEST_OUTPUT_2_TEST = "gtest_xml_outfile2_test_"
+
+EXPECTED_XML_1 = """<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="1" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests">
+  <testsuite name="PropertyOne" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="TestSomeProperties" status="run" time="*" classname="PropertyOne" SetUpProp="1" TestSomeProperty="1" TearDownProp="1" />
+  </testsuite>
+</testsuites>
+"""
+
+EXPECTED_XML_2 = """<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="1" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests">
+  <testsuite name="PropertyTwo" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="TestSomeProperties" status="run" time="*" classname="PropertyTwo" SetUpProp="2" TestSomeProperty="2" TearDownProp="2" />
+  </testsuite>
+</testsuites>
+"""
+
+
+class GTestXMLOutFilesTest(gtest_xml_test_utils.GTestXMLTestCase):
+  """Unit test for Google Test's XML output functionality."""
+
+  def setUp(self):
+    # We want the trailing '/' that the last "" provides in os.path.join, for
+    # telling Google Test to create an output directory instead of a single file
+    # for xml output.
+    self.output_dir_ = os.path.join(gtest_test_utils.GetTempDir(),
+                                    GTEST_OUTPUT_SUBDIR, "")
+    self.DeleteFilesAndDir()
+
+  def tearDown(self):
+    self.DeleteFilesAndDir()
+
+  def DeleteFilesAndDir(self):
+    try:
+      os.remove(os.path.join(self.output_dir_, GTEST_OUTPUT_1_TEST + ".xml"))
+    except os.error:
+      pass
+    try:
+      os.remove(os.path.join(self.output_dir_, GTEST_OUTPUT_2_TEST + ".xml"))
+    except os.error:
+      pass
+    try:
+      os.rmdir(self.output_dir_)
+    except os.error:
+      pass
+
+  def testOutfile1(self):
+    self._TestOutFile(GTEST_OUTPUT_1_TEST, EXPECTED_XML_1)
+
+  def testOutfile2(self):
+    self._TestOutFile(GTEST_OUTPUT_2_TEST, EXPECTED_XML_2)
+
+  def _TestOutFile(self, test_name, expected_xml):
+    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(test_name)
+    command = [gtest_prog_path, "--gtest_output=xml:%s" % self.output_dir_]
+    p = gtest_test_utils.Subprocess(command,
+                                    working_dir=gtest_test_utils.GetTempDir())
+    self.assert_(p.exited)
+    self.assertEquals(0, p.exit_code)
+
+    # TODO(wan@google.com): libtool causes the built test binary to be
+    #   named lt-gtest_xml_outfiles_test_ instead of
+    #   gtest_xml_outfiles_test_.  To account for this possibillity, we
+    #   allow both names in the following code.  We should remove this
+    #   hack when Chandler Carruth's libtool replacement tool is ready.
+    output_file_name1 = test_name + ".xml"
+    output_file1 = os.path.join(self.output_dir_, output_file_name1)
+    output_file_name2 = 'lt-' + output_file_name1
+    output_file2 = os.path.join(self.output_dir_, output_file_name2)
+    self.assert_(os.path.isfile(output_file1) or os.path.isfile(output_file2),
+                 output_file1)
+
+    expected = minidom.parseString(expected_xml)
+    if os.path.isfile(output_file1):
+      actual = minidom.parse(output_file1)
+    else:
+      actual = minidom.parse(output_file2)
+    self.NormalizeXml(actual.documentElement)
+    self.AssertEquivalentNodes(expected.documentElement,
+                               actual.documentElement)
+    expected.unlink()
+    actual.unlink()
+
+
+if __name__ == "__main__":
+  os.environ["GTEST_STACK_TRACE_DEPTH"] = "0"
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest.py
new file mode 100755
index 00000000..bcd59759
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest.py
@@ -0,0 +1,308 @@
+#!/usr/bin/env python
+#
+# Copyright 2006, 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.
+
+"""Unit test for the gtest_xml_output module"""
+
+__author__ = 'eefacm@gmail.com (Sean Mcafee)'
+
+import datetime
+import errno
+import os
+import re
+import sys
+from xml.dom import minidom, Node
+
+import gtest_test_utils
+import gtest_xml_test_utils
+
+
+GTEST_FILTER_FLAG = '--gtest_filter'
+GTEST_LIST_TESTS_FLAG = '--gtest_list_tests'
+GTEST_OUTPUT_FLAG         = "--gtest_output"
+GTEST_DEFAULT_OUTPUT_FILE = "test_detail.xml"
+GTEST_PROGRAM_NAME = "gtest_xml_output_unittest_"
+
+SUPPORTS_STACK_TRACES = False
+
+if SUPPORTS_STACK_TRACES:
+  STACK_TRACE_TEMPLATE = '\nStack trace:\n*'
+else:
+  STACK_TRACE_TEMPLATE = ''
+
+EXPECTED_NON_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="23" failures="4" disabled="2" errors="0" time="*" timestamp="*" name="AllTests" ad_hoc_property="42">
+  <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="Succeeds" status="run" time="*" classname="SuccessfulTest"/>
+  </testsuite>
+  <testsuite name="FailedTest" tests="1" failures="1" disabled="0" errors="0" time="*">
+    <testcase name="Fails" status="run" time="*" classname="FailedTest">
+      <failure message="gtest_xml_output_unittest_.cc:*&#x0A;      Expected: 1&#x0A;To be equal to: 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
+      Expected: 1
+To be equal to: 2%(stack)s]]></failure>
+    </testcase>
+  </testsuite>
+  <testsuite name="MixedResultTest" tests="3" failures="1" disabled="1" errors="0" time="*">
+    <testcase name="Succeeds" status="run" time="*" classname="MixedResultTest"/>
+    <testcase name="Fails" status="run" time="*" classname="MixedResultTest">
+      <failure message="gtest_xml_output_unittest_.cc:*&#x0A;      Expected: 1&#x0A;To be equal to: 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
+      Expected: 1
+To be equal to: 2%(stack)s]]></failure>
+      <failure message="gtest_xml_output_unittest_.cc:*&#x0A;      Expected: 2&#x0A;To be equal to: 3" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
+      Expected: 2
+To be equal to: 3%(stack)s]]></failure>
+    </testcase>
+    <testcase name="DISABLED_test" status="notrun" time="*" classname="MixedResultTest"/>
+  </testsuite>
+  <testsuite name="XmlQuotingTest" tests="1" failures="1" disabled="0" errors="0" time="*">
+    <testcase name="OutputsCData" status="run" time="*" classname="XmlQuotingTest">
+      <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Failed&#x0A;XML output: &lt;?xml encoding=&quot;utf-8&quot;&gt;&lt;top&gt;&lt;![CDATA[cdata text]]&gt;&lt;/top&gt;" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
+Failed
+XML output: <?xml encoding="utf-8"><top><![CDATA[cdata text]]>]]&gt;<![CDATA[</top>%(stack)s]]></failure>
+    </testcase>
+  </testsuite>
+  <testsuite name="InvalidCharactersTest" tests="1" failures="1" disabled="0" errors="0" time="*">
+    <testcase name="InvalidCharactersInMessage" status="run" time="*" classname="InvalidCharactersTest">
+      <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Failed&#x0A;Invalid characters in brackets []" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
+Failed
+Invalid characters in brackets []%(stack)s]]></failure>
+    </testcase>
+  </testsuite>
+  <testsuite name="DisabledTest" tests="1" failures="0" disabled="1" errors="0" time="*">
+    <testcase name="DISABLED_test_not_run" status="notrun" time="*" classname="DisabledTest"/>
+  </testsuite>
+  <testsuite name="PropertyRecordingTest" tests="4" failures="0" disabled="0" errors="0" time="*" SetUpTestCase="yes" TearDownTestCase="aye">
+    <testcase name="OneProperty" status="run" time="*" classname="PropertyRecordingTest" key_1="1"/>
+    <testcase name="IntValuedProperty" status="run" time="*" classname="PropertyRecordingTest" key_int="1"/>
+    <testcase name="ThreeProperties" status="run" time="*" classname="PropertyRecordingTest" key_1="1" key_2="2" key_3="3"/>
+    <testcase name="TwoValuesForOneKeyUsesLastValue" status="run" time="*" classname="PropertyRecordingTest" key_1="2"/>
+  </testsuite>
+  <testsuite name="NoFixtureTest" tests="3" failures="0" disabled="0" errors="0" time="*">
+     <testcase name="RecordProperty" status="run" time="*" classname="NoFixtureTest" key="1"/>
+     <testcase name="ExternalUtilityThatCallsRecordIntValuedProperty" status="run" time="*" classname="NoFixtureTest" key_for_utility_int="1"/>
+     <testcase name="ExternalUtilityThatCallsRecordStringValuedProperty" status="run" time="*" classname="NoFixtureTest" key_for_utility_string="1"/>
+  </testsuite>
+  <testsuite name="Single/ValueParamTest" tests="4" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="HasValueParamAttribute/0" value_param="33" status="run" time="*" classname="Single/ValueParamTest" />
+    <testcase name="HasValueParamAttribute/1" value_param="42" status="run" time="*" classname="Single/ValueParamTest" />
+    <testcase name="AnotherTestThatHasValueParamAttribute/0" value_param="33" status="run" time="*" classname="Single/ValueParamTest" />
+    <testcase name="AnotherTestThatHasValueParamAttribute/1" value_param="42" status="run" time="*" classname="Single/ValueParamTest" />
+  </testsuite>
+  <testsuite name="TypedTest/0" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="TypedTest/0" />
+  </testsuite>
+  <testsuite name="TypedTest/1" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="TypedTest/1" />
+  </testsuite>
+  <testsuite name="Single/TypeParameterizedTestCase/0" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestCase/0" />
+  </testsuite>
+  <testsuite name="Single/TypeParameterizedTestCase/1" tests="1" failures="0" disabled="0" errors="0" time="*">
+    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestCase/1" />
+  </testsuite>
+</testsuites>""" % {'stack': STACK_TRACE_TEMPLATE}
+
+EXPECTED_FILTERED_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="1" failures="0" disabled="0" errors="0" time="*"
+            timestamp="*" name="AllTests" ad_hoc_property="42">
+  <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0"
+             errors="0" time="*">
+    <testcase name="Succeeds" status="run" time="*" classname="SuccessfulTest"/>
+  </testsuite>
+</testsuites>"""
+
+EXPECTED_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
+<testsuites tests="0" failures="0" disabled="0" errors="0" time="*"
+            timestamp="*" name="AllTests">
+</testsuites>"""
+
+GTEST_PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath(GTEST_PROGRAM_NAME)
+
+SUPPORTS_TYPED_TESTS = 'TypedTest' in gtest_test_utils.Subprocess(
+    [GTEST_PROGRAM_PATH, GTEST_LIST_TESTS_FLAG], capture_stderr=False).output
+
+
+class GTestXMLOutputUnitTest(gtest_xml_test_utils.GTestXMLTestCase):
+  """
+  Unit test for Google Test's XML output functionality.
+  """
+
+  # This test currently breaks on platforms that do not support typed and
+  # type-parameterized tests, so we don't run it under them.
+  if SUPPORTS_TYPED_TESTS:
+    def testNonEmptyXmlOutput(self):
+      """
+      Runs a test program that generates a non-empty XML output, and
+      tests that the XML output is expected.
+      """
+      self._TestXmlOutput(GTEST_PROGRAM_NAME, EXPECTED_NON_EMPTY_XML, 1)
+
+  def testEmptyXmlOutput(self):
+    """Verifies XML output for a Google Test binary without actual tests.
+
+    Runs a test program that generates an empty XML output, and
+    tests that the XML output is expected.
+    """
+
+    self._TestXmlOutput('gtest_no_test_unittest', EXPECTED_EMPTY_XML, 0)
+
+  def testTimestampValue(self):
+    """Checks whether the timestamp attribute in the XML output is valid.
+
+    Runs a test program that generates an empty XML output, and checks if
+    the timestamp attribute in the testsuites tag is valid.
+    """
+    actual = self._GetXmlOutput('gtest_no_test_unittest', [], 0)
+    date_time_str = actual.documentElement.getAttributeNode('timestamp').value
+    # datetime.strptime() is only available in Python 2.5+ so we have to
+    # parse the expected datetime manually.
+    match = re.match(r'(\d+)-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)', date_time_str)
+    self.assertTrue(
+        re.match,
+        'XML datettime string %s has incorrect format' % date_time_str)
+    date_time_from_xml = datetime.datetime(
+        year=int(match.group(1)), month=int(match.group(2)),
+        day=int(match.group(3)), hour=int(match.group(4)),
+        minute=int(match.group(5)), second=int(match.group(6)))
+
+    time_delta = abs(datetime.datetime.now() - date_time_from_xml)
+    # timestamp value should be near the current local time
+    self.assertTrue(time_delta < datetime.timedelta(seconds=600),
+                    'time_delta is %s' % time_delta)
+    actual.unlink()
+
+  def testDefaultOutputFile(self):
+    """
+    Confirms that Google Test produces an XML output file with the expected
+    default name if no name is explicitly specified.
+    """
+    output_file = os.path.join(gtest_test_utils.GetTempDir(),
+                               GTEST_DEFAULT_OUTPUT_FILE)
+    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(
+        'gtest_no_test_unittest')
+    try:
+      os.remove(output_file)
+    except OSError:
+      e = sys.exc_info()[1]
+      if e.errno != errno.ENOENT:
+        raise
+
+    p = gtest_test_utils.Subprocess(
+        [gtest_prog_path, '%s=xml' % GTEST_OUTPUT_FLAG],
+        working_dir=gtest_test_utils.GetTempDir())
+    self.assert_(p.exited)
+    self.assertEquals(0, p.exit_code)
+    self.assert_(os.path.isfile(output_file))
+
+  def testSuppressedXmlOutput(self):
+    """
+    Tests that no XML file is generated if the default XML listener is
+    shut down before RUN_ALL_TESTS is invoked.
+    """
+
+    xml_path = os.path.join(gtest_test_utils.GetTempDir(),
+                            GTEST_PROGRAM_NAME + 'out.xml')
+    if os.path.isfile(xml_path):
+      os.remove(xml_path)
+
+    command = [GTEST_PROGRAM_PATH,
+               '%s=xml:%s' % (GTEST_OUTPUT_FLAG, xml_path),
+               '--shut_down_xml']
+    p = gtest_test_utils.Subprocess(command)
+    if p.terminated_by_signal:
+      # p.signal is avalable only if p.terminated_by_signal is True.
+      self.assertFalse(
+          p.terminated_by_signal,
+          '%s was killed by signal %d' % (GTEST_PROGRAM_NAME, p.signal))
+    else:
+      self.assert_(p.exited)
+      self.assertEquals(1, p.exit_code,
+                        "'%s' exited with code %s, which doesn't match "
+                        'the expected exit code %s.'
+                        % (command, p.exit_code, 1))
+
+    self.assert_(not os.path.isfile(xml_path))
+
+  def testFilteredTestXmlOutput(self):
+    """Verifies XML output when a filter is applied.
+
+    Runs a test program that executes only some tests and verifies that
+    non-selected tests do not show up in the XML output.
+    """
+
+    self._TestXmlOutput(GTEST_PROGRAM_NAME, EXPECTED_FILTERED_TEST_XML, 0,
+                        extra_args=['%s=SuccessfulTest.*' % GTEST_FILTER_FLAG])
+
+  def _GetXmlOutput(self, gtest_prog_name, extra_args, expected_exit_code):
+    """
+    Returns the xml output generated by running the program gtest_prog_name.
+    Furthermore, the program's exit code must be expected_exit_code.
+    """
+    xml_path = os.path.join(gtest_test_utils.GetTempDir(),
+                            gtest_prog_name + 'out.xml')
+    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(gtest_prog_name)
+
+    command = ([gtest_prog_path, '%s=xml:%s' % (GTEST_OUTPUT_FLAG, xml_path)] +
+               extra_args)
+    p = gtest_test_utils.Subprocess(command)
+    if p.terminated_by_signal:
+      self.assert_(False,
+                   '%s was killed by signal %d' % (gtest_prog_name, p.signal))
+    else:
+      self.assert_(p.exited)
+      self.assertEquals(expected_exit_code, p.exit_code,
+                        "'%s' exited with code %s, which doesn't match "
+                        'the expected exit code %s.'
+                        % (command, p.exit_code, expected_exit_code))
+    actual = minidom.parse(xml_path)
+    return actual
+
+  def _TestXmlOutput(self, gtest_prog_name, expected_xml,
+                     expected_exit_code, extra_args=None):
+    """
+    Asserts that the XML document generated by running the program
+    gtest_prog_name matches expected_xml, a string containing another
+    XML document.  Furthermore, the program's exit code must be
+    expected_exit_code.
+    """
+
+    actual = self._GetXmlOutput(gtest_prog_name, extra_args or [],
+                                expected_exit_code)
+    expected = minidom.parseString(expected_xml)
+    self.NormalizeXml(actual.documentElement)
+    self.AssertEquivalentNodes(expected.documentElement,
+                               actual.documentElement)
+    expected.unlink()
+    actual.unlink()
+
+
+if __name__ == '__main__':
+  os.environ['GTEST_STACK_TRACE_DEPTH'] = '1'
+  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest_.cc
new file mode 100644
index 00000000..48b8771b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest_.cc
@@ -0,0 +1,181 @@
+// Copyright 2006, 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.
+
+// Author: eefacm@gmail.com (Sean Mcafee)
+
+// Unit test for Google Test XML output.
+//
+// A user can specify XML output in a Google Test program to run via
+// either the GTEST_OUTPUT environment variable or the --gtest_output
+// flag.  This is used for testing such functionality.
+//
+// This program will be invoked from a Python unit test.  Don't run it
+// directly.
+
+#include "gtest/gtest.h"
+
+using ::testing::InitGoogleTest;
+using ::testing::TestEventListeners;
+using ::testing::TestWithParam;
+using ::testing::UnitTest;
+using ::testing::Test;
+using ::testing::Values;
+
+class SuccessfulTest : public Test {
+};
+
+TEST_F(SuccessfulTest, Succeeds) {
+  SUCCEED() << "This is a success.";
+  ASSERT_EQ(1, 1);
+}
+
+class FailedTest : public Test {
+};
+
+TEST_F(FailedTest, Fails) {
+  ASSERT_EQ(1, 2);
+}
+
+class DisabledTest : public Test {
+};
+
+TEST_F(DisabledTest, DISABLED_test_not_run) {
+  FAIL() << "Unexpected failure: Disabled test should not be run";
+}
+
+TEST(MixedResultTest, Succeeds) {
+  EXPECT_EQ(1, 1);
+  ASSERT_EQ(1, 1);
+}
+
+TEST(MixedResultTest, Fails) {
+  EXPECT_EQ(1, 2);
+  ASSERT_EQ(2, 3);
+}
+
+TEST(MixedResultTest, DISABLED_test) {
+  FAIL() << "Unexpected failure: Disabled test should not be run";
+}
+
+TEST(XmlQuotingTest, OutputsCData) {
+  FAIL() << "XML output: "
+            "<?xml encoding=\"utf-8\"><top><![CDATA[cdata text]]></top>";
+}
+
+// Helps to test that invalid characters produced by test code do not make
+// it into the XML file.
+TEST(InvalidCharactersTest, InvalidCharactersInMessage) {
+  FAIL() << "Invalid characters in brackets [\x1\x2]";
+}
+
+class PropertyRecordingTest : public Test {
+ public:
+  static void SetUpTestCase() { RecordProperty("SetUpTestCase", "yes"); }
+  static void TearDownTestCase() { RecordProperty("TearDownTestCase", "aye"); }
+};
+
+TEST_F(PropertyRecordingTest, OneProperty) {
+  RecordProperty("key_1", "1");
+}
+
+TEST_F(PropertyRecordingTest, IntValuedProperty) {
+  RecordProperty("key_int", 1);
+}
+
+TEST_F(PropertyRecordingTest, ThreeProperties) {
+  RecordProperty("key_1", "1");
+  RecordProperty("key_2", "2");
+  RecordProperty("key_3", "3");
+}
+
+TEST_F(PropertyRecordingTest, TwoValuesForOneKeyUsesLastValue) {
+  RecordProperty("key_1", "1");
+  RecordProperty("key_1", "2");
+}
+
+TEST(NoFixtureTest, RecordProperty) {
+  RecordProperty("key", "1");
+}
+
+void ExternalUtilityThatCallsRecordProperty(const std::string& key, int value) {
+  testing::Test::RecordProperty(key, value);
+}
+
+void ExternalUtilityThatCallsRecordProperty(const std::string& key,
+                                            const std::string& value) {
+  testing::Test::RecordProperty(key, value);
+}
+
+TEST(NoFixtureTest, ExternalUtilityThatCallsRecordIntValuedProperty) {
+  ExternalUtilityThatCallsRecordProperty("key_for_utility_int", 1);
+}
+
+TEST(NoFixtureTest, ExternalUtilityThatCallsRecordStringValuedProperty) {
+  ExternalUtilityThatCallsRecordProperty("key_for_utility_string", "1");
+}
+
+// Verifies that the test parameter value is output in the 'value_param'
+// XML attribute for value-parameterized tests.
+class ValueParamTest : public TestWithParam<int> {};
+TEST_P(ValueParamTest, HasValueParamAttribute) {}
+TEST_P(ValueParamTest, AnotherTestThatHasValueParamAttribute) {}
+INSTANTIATE_TEST_CASE_P(Single, ValueParamTest, Values(33, 42));
+
+#if GTEST_HAS_TYPED_TEST
+// Verifies that the type parameter name is output in the 'type_param'
+// XML attribute for typed tests.
+template <typename T> class TypedTest : public Test {};
+typedef testing::Types<int, long> TypedTestTypes;
+TYPED_TEST_CASE(TypedTest, TypedTestTypes);
+TYPED_TEST(TypedTest, HasTypeParamAttribute) {}
+#endif
+
+#if GTEST_HAS_TYPED_TEST_P
+// Verifies that the type parameter name is output in the 'type_param'
+// XML attribute for type-parameterized tests.
+template <typename T> class TypeParameterizedTestCase : public Test {};
+TYPED_TEST_CASE_P(TypeParameterizedTestCase);
+TYPED_TEST_P(TypeParameterizedTestCase, HasTypeParamAttribute) {}
+REGISTER_TYPED_TEST_CASE_P(TypeParameterizedTestCase, HasTypeParamAttribute);
+typedef testing::Types<int, long> TypeParameterizedTestCaseTypes;
+INSTANTIATE_TYPED_TEST_CASE_P(Single,
+                              TypeParameterizedTestCase,
+                              TypeParameterizedTestCaseTypes);
+#endif
+
+int main(int argc, char** argv) {
+  InitGoogleTest(&argc, argv);
+
+  if (argc > 1 && strcmp(argv[1], "--shut_down_xml") == 0) {
+    TestEventListeners& listeners = UnitTest::GetInstance()->listeners();
+    delete listeners.Release(listeners.default_xml_generator());
+  }
+  testing::Test::RecordProperty("ad_hoc_property", "42");
+  return RUN_ALL_TESTS();
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_test_utils.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_test_utils.py
new file mode 100755
index 00000000..341956b5
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_test_utils.py
@@ -0,0 +1,194 @@
+#!/usr/bin/env python
+#
+# Copyright 2006, 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.
+
+"""Unit test utilities for gtest_xml_output"""
+
+__author__ = 'eefacm@gmail.com (Sean Mcafee)'
+
+import re
+from xml.dom import minidom, Node
+
+import gtest_test_utils
+
+
+GTEST_OUTPUT_FLAG         = '--gtest_output'
+GTEST_DEFAULT_OUTPUT_FILE = 'test_detail.xml'
+
+class GTestXMLTestCase(gtest_test_utils.TestCase):
+  """
+  Base class for tests of Google Test's XML output functionality.
+  """
+
+
+  def AssertEquivalentNodes(self, expected_node, actual_node):
+    """
+    Asserts that actual_node (a DOM node object) is equivalent to
+    expected_node (another DOM node object), in that either both of
+    them are CDATA nodes and have the same value, or both are DOM
+    elements and actual_node meets all of the following conditions:
+
+    *  It has the same tag name as expected_node.
+    *  It has the same set of attributes as expected_node, each with
+       the same value as the corresponding attribute of expected_node.
+       Exceptions are any attribute named "time", which needs only be
+       convertible to a floating-point number and any attribute named
+       "type_param" which only has to be non-empty.
+    *  It has an equivalent set of child nodes (including elements and
+       CDATA sections) as expected_node.  Note that we ignore the
+       order of the children as they are not guaranteed to be in any
+       particular order.
+    """
+
+    if expected_node.nodeType == Node.CDATA_SECTION_NODE:
+      self.assertEquals(Node.CDATA_SECTION_NODE, actual_node.nodeType)
+      self.assertEquals(expected_node.nodeValue, actual_node.nodeValue)
+      return
+
+    self.assertEquals(Node.ELEMENT_NODE, actual_node.nodeType)
+    self.assertEquals(Node.ELEMENT_NODE, expected_node.nodeType)
+    self.assertEquals(expected_node.tagName, actual_node.tagName)
+
+    expected_attributes = expected_node.attributes
+    actual_attributes   = actual_node  .attributes
+    self.assertEquals(
+        expected_attributes.length, actual_attributes.length,
+        'attribute numbers differ in element %s:\nExpected: %r\nActual: %r' % (
+            actual_node.tagName, expected_attributes.keys(),
+            actual_attributes.keys()))
+    for i in range(expected_attributes.length):
+      expected_attr = expected_attributes.item(i)
+      actual_attr   = actual_attributes.get(expected_attr.name)
+      self.assert_(
+          actual_attr is not None,
+          'expected attribute %s not found in element %s' %
+          (expected_attr.name, actual_node.tagName))
+      self.assertEquals(
+          expected_attr.value, actual_attr.value,
+          ' values of attribute %s in element %s differ: %s vs %s' %
+          (expected_attr.name, actual_node.tagName,
+           expected_attr.value, actual_attr.value))
+
+    expected_children = self._GetChildren(expected_node)
+    actual_children = self._GetChildren(actual_node)
+    self.assertEquals(
+        len(expected_children), len(actual_children),
+        'number of child elements differ in element ' + actual_node.tagName)
+    for child_id, child in expected_children.items():
+      self.assert_(child_id in actual_children,
+                   '<%s> is not in <%s> (in element %s)' %
+                   (child_id, actual_children, actual_node.tagName))
+      self.AssertEquivalentNodes(child, actual_children[child_id])
+
+  identifying_attribute = {
+    'testsuites': 'name',
+    'testsuite': 'name',
+    'testcase':  'name',
+    'failure':   'message',
+    }
+
+  def _GetChildren(self, element):
+    """
+    Fetches all of the child nodes of element, a DOM Element object.
+    Returns them as the values of a dictionary keyed by the IDs of the
+    children.  For <testsuites>, <testsuite> and <testcase> elements, the ID
+    is the value of their "name" attribute; for <failure> elements, it is
+    the value of the "message" attribute; CDATA sections and non-whitespace
+    text nodes are concatenated into a single CDATA section with ID
+    "detail".  An exception is raised if any element other than the above
+    four is encountered, if two child elements with the same identifying
+    attributes are encountered, or if any other type of node is encountered.
+    """
+
+    children = {}
+    for child in element.childNodes:
+      if child.nodeType == Node.ELEMENT_NODE:
+        self.assert_(child.tagName in self.identifying_attribute,
+                     'Encountered unknown element <%s>' % child.tagName)
+        childID = child.getAttribute(self.identifying_attribute[child.tagName])
+        self.assert_(childID not in children)
+        children[childID] = child
+      elif child.nodeType in [Node.TEXT_NODE, Node.CDATA_SECTION_NODE]:
+        if 'detail' not in children:
+          if (child.nodeType == Node.CDATA_SECTION_NODE or
+              not child.nodeValue.isspace()):
+            children['detail'] = child.ownerDocument.createCDATASection(
+                child.nodeValue)
+        else:
+          children['detail'].nodeValue += child.nodeValue
+      else:
+        self.fail('Encountered unexpected node type %d' % child.nodeType)
+    return children
+
+  def NormalizeXml(self, element):
+    """
+    Normalizes Google Test's XML output to eliminate references to transient
+    information that may change from run to run.
+
+    *  The "time" attribute of <testsuites>, <testsuite> and <testcase>
+       elements is replaced with a single asterisk, if it contains
+       only digit characters.
+    *  The "timestamp" attribute of <testsuites> elements is replaced with a
+       single asterisk, if it contains a valid ISO8601 datetime value.
+    *  The "type_param" attribute of <testcase> elements is replaced with a
+       single asterisk (if it sn non-empty) as it is the type name returned
+       by the compiler and is platform dependent.
+    *  The line info reported in the first line of the "message"
+       attribute and CDATA section of <failure> elements is replaced with the
+       file's basename and a single asterisk for the line number.
+    *  The directory names in file paths are removed.
+    *  The stack traces are removed.
+    """
+
+    if element.tagName == 'testsuites':
+      timestamp = element.getAttributeNode('timestamp')
+      timestamp.value = re.sub(r'^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d$',
+                               '*', timestamp.value)
+    if element.tagName in ('testsuites', 'testsuite', 'testcase'):
+      time = element.getAttributeNode('time')
+      time.value = re.sub(r'^\d+(\.\d+)?$', '*', time.value)
+      type_param = element.getAttributeNode('type_param')
+      if type_param and type_param.value:
+        type_param.value = '*'
+    elif element.tagName == 'failure':
+      source_line_pat = r'^.*[/\\](.*:)\d+\n'
+      # Replaces the source line information with a normalized form.
+      message = element.getAttributeNode('message')
+      message.value = re.sub(source_line_pat, '\\1*\n', message.value)
+      for child in element.childNodes:
+        if child.nodeType == Node.CDATA_SECTION_NODE:
+          # Replaces the source line information with a normalized form.
+          cdata = re.sub(source_line_pat, '\\1*\n', child.nodeValue)
+          # Removes the actual stack trace.
+          child.nodeValue = re.sub(r'\nStack trace:\n(.|\n)*',
+                                   '', cdata)
+    for child in element.childNodes:
+      if child.nodeType == Node.ELEMENT_NODE:
+        self.NormalizeXml(child)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/production.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/production.cc
new file mode 100644
index 00000000..8b8a40b4
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/production.cc
@@ -0,0 +1,36 @@
+// Copyright 2006, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// This is part of the unit test for include/gtest/gtest_prod.h.
+
+#include "production.h"
+
+PrivateCode::PrivateCode() : x_(0) {}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/production.h b/week4/softwareEng_9_4/vendor/googletest/googletest/test/production.h
new file mode 100644
index 00000000..98fd5e47
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/test/production.h
@@ -0,0 +1,55 @@
+// Copyright 2006, 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.
+//
+// Author: wan@google.com (Zhanyong Wan)
+//
+// This is part of the unit test for include/gtest/gtest_prod.h.
+
+#ifndef GTEST_TEST_PRODUCTION_H_
+#define GTEST_TEST_PRODUCTION_H_
+
+#include "gtest/gtest_prod.h"
+
+class PrivateCode {
+ public:
+  // Declares a friend test that does not use a fixture.
+  FRIEND_TEST(PrivateCodeTest, CanAccessPrivateMembers);
+
+  // Declares a friend test that uses a fixture.
+  FRIEND_TEST(PrivateCodeFixtureTest, CanAccessPrivateMembers);
+
+  PrivateCode();
+
+  int x() const { return x_; }
+ private:
+  void set_x(int an_x) { x_ = an_x; }
+  int x_;
+};
+
+#endif  // GTEST_TEST_PRODUCTION_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/DebugProject.xcconfig b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/DebugProject.xcconfig
new file mode 100644
index 00000000..3d68157d
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/DebugProject.xcconfig
@@ -0,0 +1,30 @@
+//
+//  DebugProject.xcconfig
+//
+//  These are Debug Configuration project settings for the gtest framework and
+//  examples. It is set in the "Based On:" dropdown in the "Project" info
+//  dialog.
+//  This file is based on the Xcode Configuration files in:
+//  http://code.google.com/p/google-toolbox-for-mac/
+// 
+
+#include "General.xcconfig"
+
+// No optimization
+GCC_OPTIMIZATION_LEVEL = 0
+
+// Deployment postprocessing is what triggers Xcode to strip, turn it off
+DEPLOYMENT_POSTPROCESSING = NO
+
+// Dead code stripping off
+DEAD_CODE_STRIPPING = NO
+
+// Debug symbols should be on obviously
+GCC_GENERATE_DEBUGGING_SYMBOLS = YES
+
+// Define the DEBUG macro in all debug builds
+OTHER_CFLAGS = $(OTHER_CFLAGS) -DDEBUG=1
+
+// These are turned off to avoid STL incompatibilities with client code
+// // Turns on special C++ STL checks to "encourage" good STL use
+// GCC_PREPROCESSOR_DEFINITIONS = $(GCC_PREPROCESSOR_DEFINITIONS) _GLIBCXX_DEBUG_PEDANTIC _GLIBCXX_DEBUG _GLIBCPP_CONCEPT_CHECKS
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/FrameworkTarget.xcconfig b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/FrameworkTarget.xcconfig
new file mode 100644
index 00000000..357b1c8f
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/FrameworkTarget.xcconfig
@@ -0,0 +1,17 @@
+//
+//  FrameworkTarget.xcconfig
+//
+//  These are Framework target settings for the gtest framework and examples. It
+//  is set in the "Based On:" dropdown in the "Target" info dialog.
+//  This file is based on the Xcode Configuration files in:
+//  http://code.google.com/p/google-toolbox-for-mac/
+// 
+
+// Dynamic libs need to be position independent
+GCC_DYNAMIC_NO_PIC = NO
+
+// Dynamic libs should not have their external symbols stripped.
+STRIP_STYLE = non-global
+
+// Let the user install by specifying the $DSTROOT with xcodebuild
+SKIP_INSTALL = NO
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/General.xcconfig b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/General.xcconfig
new file mode 100644
index 00000000..f23e3222
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/General.xcconfig
@@ -0,0 +1,41 @@
+//
+//  General.xcconfig
+//
+//  These are General configuration settings for the gtest framework and
+//  examples.
+//  This file is based on the Xcode Configuration files in:
+//  http://code.google.com/p/google-toolbox-for-mac/
+// 
+
+// Build for PPC and Intel, 32- and 64-bit
+ARCHS = i386 x86_64 ppc ppc64
+
+// Zerolink prevents link warnings so turn it off
+ZERO_LINK = NO
+
+// Prebinding considered unhelpful in 10.3 and later
+PREBINDING = NO
+
+// Strictest warning policy
+WARNING_CFLAGS = -Wall -Werror -Wendif-labels -Wnewline-eof -Wno-sign-compare -Wshadow
+
+// Work around Xcode bugs by using external strip. See:
+// http://lists.apple.com/archives/Xcode-users/2006/Feb/msg00050.html
+SEPARATE_STRIP = YES
+
+// Force C99 dialect
+GCC_C_LANGUAGE_STANDARD = c99
+
+// not sure why apple defaults this on, but it's pretty risky
+ALWAYS_SEARCH_USER_PATHS = NO
+
+// Turn on position dependent code for most cases (overridden where appropriate)
+GCC_DYNAMIC_NO_PIC = YES
+
+// Default SDK and minimum OS version is 10.4
+SDKROOT = $(DEVELOPER_SDK_DIR)/MacOSX10.4u.sdk
+MACOSX_DEPLOYMENT_TARGET = 10.4
+GCC_VERSION = 4.0
+
+// VERSIONING BUILD SETTINGS (used in Info.plist)
+GTEST_VERSIONINFO_ABOUT =  © 2008 Google Inc.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/ReleaseProject.xcconfig b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/ReleaseProject.xcconfig
new file mode 100644
index 00000000..5349f0a0
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/ReleaseProject.xcconfig
@@ -0,0 +1,32 @@
+//
+//  ReleaseProject.xcconfig
+//
+//  These are Release Configuration project settings for the gtest framework
+//  and examples. It is set in the "Based On:" dropdown in the "Project" info
+//  dialog.
+//  This file is based on the Xcode Configuration files in:
+//  http://code.google.com/p/google-toolbox-for-mac/
+// 
+
+#include "General.xcconfig"
+
+// subconfig/Release.xcconfig
+
+// Optimize for space and size (Apple recommendation)
+GCC_OPTIMIZATION_LEVEL = s
+
+// Deploment postprocessing is what triggers Xcode to strip
+DEPLOYMENT_POSTPROCESSING = YES
+
+// No symbols
+GCC_GENERATE_DEBUGGING_SYMBOLS = NO
+
+// Dead code strip does not affect ObjC code but can help for C
+DEAD_CODE_STRIPPING = YES
+
+// NDEBUG is used by things like assert.h, so define it for general compat.
+// ASSERT going away in release tends to create unused vars.
+OTHER_CFLAGS = $(OTHER_CFLAGS) -DNDEBUG=1 -Wno-unused-variable
+
+// When we strip we want to strip all symbols in release, but save externals.
+STRIP_STYLE = all
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/StaticLibraryTarget.xcconfig b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/StaticLibraryTarget.xcconfig
new file mode 100644
index 00000000..3922fa51
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/StaticLibraryTarget.xcconfig
@@ -0,0 +1,18 @@
+//
+//  StaticLibraryTarget.xcconfig
+//
+//  These are static library target settings for libgtest.a. It
+//  is set in the "Based On:" dropdown in the "Target" info dialog.
+//  This file is based on the Xcode Configuration files in:
+//  http://code.google.com/p/google-toolbox-for-mac/
+// 
+
+// Static libs can be included in bundles so make them position independent
+GCC_DYNAMIC_NO_PIC = NO
+
+// Static libs should not have their internal globals or external symbols
+// stripped.
+STRIP_STYLE = debugging
+
+// Let the user install by specifying the $DSTROOT with xcodebuild
+SKIP_INSTALL = NO
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/TestTarget.xcconfig b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/TestTarget.xcconfig
new file mode 100644
index 00000000..e6652ba8
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/TestTarget.xcconfig
@@ -0,0 +1,8 @@
+//
+//  TestTarget.xcconfig
+//
+//  These are Test target settings for the gtest framework and examples. It
+//  is set in the "Based On:" dropdown in the "Target" info dialog.
+
+PRODUCT_NAME = $(TARGET_NAME)
+HEADER_SEARCH_PATHS = ../include
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Resources/Info.plist b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Resources/Info.plist
new file mode 100644
index 00000000..9dd28ea1
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Resources/Info.plist
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>com.google.${PRODUCT_NAME}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>GTEST_VERSIONINFO_LONG</string>
+	<key>CFBundleShortVersionString</key>
+	<string>GTEST_VERSIONINFO_SHORT</string>
+	<key>CFBundleGetInfoString</key>
+	<string>${PRODUCT_NAME} GTEST_VERSIONINFO_LONG, ${GTEST_VERSIONINFO_ABOUT}</string>
+	<key>NSHumanReadableCopyright</key>
+	<string>${GTEST_VERSIONINFO_ABOUT}</string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+</dict>
+</plist>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/Info.plist b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/Info.plist
new file mode 100644
index 00000000..f3852ede
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/Info.plist
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>com.google.gtest.${PRODUCT_NAME:identifier}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>${PRODUCT_NAME}</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1.0</string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+</dict>
+</plist>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj
new file mode 100644
index 00000000..497617eb
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj
@@ -0,0 +1,457 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 42;
+	objects = {
+
+/* Begin PBXAggregateTarget section */
+		4024D162113D7D2400C7059E /* Test */ = {
+			isa = PBXAggregateTarget;
+			buildConfigurationList = 4024D169113D7D4600C7059E /* Build configuration list for PBXAggregateTarget "Test" */;
+			buildPhases = (
+				4024D161113D7D2400C7059E /* ShellScript */,
+			);
+			dependencies = (
+				4024D166113D7D3100C7059E /* PBXTargetDependency */,
+			);
+			name = Test;
+			productName = TestAndBuild;
+		};
+		4024D1E9113D83FF00C7059E /* TestAndBuild */ = {
+			isa = PBXAggregateTarget;
+			buildConfigurationList = 4024D1F0113D842B00C7059E /* Build configuration list for PBXAggregateTarget "TestAndBuild" */;
+			buildPhases = (
+			);
+			dependencies = (
+				4024D1ED113D840900C7059E /* PBXTargetDependency */,
+				4024D1EF113D840D00C7059E /* PBXTargetDependency */,
+			);
+			name = TestAndBuild;
+			productName = TestAndBuild;
+		};
+/* End PBXAggregateTarget section */
+
+/* Begin PBXBuildFile section */
+		3B7EB1250E5AEE3500C7F239 /* widget.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B7EB1230E5AEE3500C7F239 /* widget.cc */; };
+		3B7EB1260E5AEE3500C7F239 /* widget.h in Headers */ = {isa = PBXBuildFile; fileRef = 3B7EB1240E5AEE3500C7F239 /* widget.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		3B7EB1280E5AEE4600C7F239 /* widget_test.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B7EB1270E5AEE4600C7F239 /* widget_test.cc */; };
+		3B7EB1480E5AF3B400C7F239 /* Widget.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8D07F2C80486CC7A007CD1D0 /* Widget.framework */; };
+		4024D188113D7D7800C7059E /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 4024D185113D7D5500C7059E /* libgtest.a */; };
+		4024D189113D7D7A00C7059E /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 4024D183113D7D5500C7059E /* libgtest_main.a */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		3B07BDF00E3F3FAE00647869 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
+			remoteInfo = gTestExample;
+		};
+		4024D165113D7D3100C7059E /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 3B07BDE90E3F3F9E00647869;
+			remoteInfo = WidgetFrameworkTest;
+		};
+		4024D1EC113D840900C7059E /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
+			remoteInfo = WidgetFramework;
+		};
+		4024D1EE113D840D00C7059E /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 4024D162113D7D2400C7059E;
+			remoteInfo = Test;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXFileReference section */
+		3B07BDEA0E3F3F9E00647869 /* WidgetFrameworkTest */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = WidgetFrameworkTest; sourceTree = BUILT_PRODUCTS_DIR; };
+		3B7EB1230E5AEE3500C7F239 /* widget.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = widget.cc; sourceTree = "<group>"; };
+		3B7EB1240E5AEE3500C7F239 /* widget.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = widget.h; sourceTree = "<group>"; };
+		3B7EB1270E5AEE4600C7F239 /* widget_test.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = widget_test.cc; sourceTree = "<group>"; };
+		4024D183113D7D5500C7059E /* libgtest_main.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libgtest_main.a; path = /usr/local/lib/libgtest_main.a; sourceTree = "<absolute>"; };
+		4024D185113D7D5500C7059E /* libgtest.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libgtest.a; path = /usr/local/lib/libgtest.a; sourceTree = "<absolute>"; };
+		4024D1E2113D838200C7059E /* runtests.sh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.sh; path = runtests.sh; sourceTree = "<group>"; };
+		8D07F2C70486CC7A007CD1D0 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist; path = Info.plist; sourceTree = "<group>"; };
+		8D07F2C80486CC7A007CD1D0 /* Widget.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Widget.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		3B07BDE80E3F3F9E00647869 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				4024D189113D7D7A00C7059E /* libgtest_main.a in Frameworks */,
+				4024D188113D7D7800C7059E /* libgtest.a in Frameworks */,
+				3B7EB1480E5AF3B400C7F239 /* Widget.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		8D07F2C30486CC7A007CD1D0 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		034768DDFF38A45A11DB9C8B /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				8D07F2C80486CC7A007CD1D0 /* Widget.framework */,
+				3B07BDEA0E3F3F9E00647869 /* WidgetFrameworkTest */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		0867D691FE84028FC02AAC07 /* gTestExample */ = {
+			isa = PBXGroup;
+			children = (
+				4024D1E1113D836C00C7059E /* Scripts */,
+				08FB77ACFE841707C02AAC07 /* Source */,
+				089C1665FE841158C02AAC07 /* Resources */,
+				3B07BE350E4094E400647869 /* Test */,
+				0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */,
+				034768DDFF38A45A11DB9C8B /* Products */,
+			);
+			name = gTestExample;
+			sourceTree = "<group>";
+		};
+		0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */ = {
+			isa = PBXGroup;
+			children = (
+				4024D183113D7D5500C7059E /* libgtest_main.a */,
+				4024D185113D7D5500C7059E /* libgtest.a */,
+			);
+			name = "External Frameworks and Libraries";
+			sourceTree = "<group>";
+		};
+		089C1665FE841158C02AAC07 /* Resources */ = {
+			isa = PBXGroup;
+			children = (
+				8D07F2C70486CC7A007CD1D0 /* Info.plist */,
+			);
+			name = Resources;
+			sourceTree = "<group>";
+		};
+		08FB77ACFE841707C02AAC07 /* Source */ = {
+			isa = PBXGroup;
+			children = (
+				3B7EB1230E5AEE3500C7F239 /* widget.cc */,
+				3B7EB1240E5AEE3500C7F239 /* widget.h */,
+			);
+			name = Source;
+			sourceTree = "<group>";
+		};
+		3B07BE350E4094E400647869 /* Test */ = {
+			isa = PBXGroup;
+			children = (
+				3B7EB1270E5AEE4600C7F239 /* widget_test.cc */,
+			);
+			name = Test;
+			sourceTree = "<group>";
+		};
+		4024D1E1113D836C00C7059E /* Scripts */ = {
+			isa = PBXGroup;
+			children = (
+				4024D1E2113D838200C7059E /* runtests.sh */,
+			);
+			name = Scripts;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+		8D07F2BD0486CC7A007CD1D0 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				3B7EB1260E5AEE3500C7F239 /* widget.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+		3B07BDE90E3F3F9E00647869 /* WidgetFrameworkTest */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 3B07BDF40E3F3FB600647869 /* Build configuration list for PBXNativeTarget "WidgetFrameworkTest" */;
+			buildPhases = (
+				3B07BDE70E3F3F9E00647869 /* Sources */,
+				3B07BDE80E3F3F9E00647869 /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				3B07BDF10E3F3FAE00647869 /* PBXTargetDependency */,
+			);
+			name = WidgetFrameworkTest;
+			productName = gTestExampleTest;
+			productReference = 3B07BDEA0E3F3F9E00647869 /* WidgetFrameworkTest */;
+			productType = "com.apple.product-type.tool";
+		};
+		8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "WidgetFramework" */;
+			buildPhases = (
+				8D07F2C10486CC7A007CD1D0 /* Sources */,
+				8D07F2C30486CC7A007CD1D0 /* Frameworks */,
+				8D07F2BD0486CC7A007CD1D0 /* Headers */,
+				8D07F2BF0486CC7A007CD1D0 /* Resources */,
+				8D07F2C50486CC7A007CD1D0 /* Rez */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = WidgetFramework;
+			productInstallPath = "$(HOME)/Library/Frameworks";
+			productName = gTestExample;
+			productReference = 8D07F2C80486CC7A007CD1D0 /* Widget.framework */;
+			productType = "com.apple.product-type.framework";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		0867D690FE84028FC02AAC07 /* Project object */ = {
+			isa = PBXProject;
+			buildConfigurationList = 4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "WidgetFramework" */;
+			compatibilityVersion = "Xcode 2.4";
+			hasScannedForEncodings = 1;
+			mainGroup = 0867D691FE84028FC02AAC07 /* gTestExample */;
+			productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */,
+				3B07BDE90E3F3F9E00647869 /* WidgetFrameworkTest */,
+				4024D162113D7D2400C7059E /* Test */,
+				4024D1E9113D83FF00C7059E /* TestAndBuild */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		8D07F2BF0486CC7A007CD1D0 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXRezBuildPhase section */
+		8D07F2C50486CC7A007CD1D0 /* Rez */ = {
+			isa = PBXRezBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXRezBuildPhase section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		4024D161113D7D2400C7059E /* ShellScript */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "/bin/bash $SRCROOT/runtests.sh $BUILT_PRODUCTS_DIR/WidgetFrameworkTest\n";
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		3B07BDE70E3F3F9E00647869 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				3B7EB1280E5AEE4600C7F239 /* widget_test.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		8D07F2C10486CC7A007CD1D0 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				3B7EB1250E5AEE3500C7F239 /* widget.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		3B07BDF10E3F3FAE00647869 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */;
+			targetProxy = 3B07BDF00E3F3FAE00647869 /* PBXContainerItemProxy */;
+		};
+		4024D166113D7D3100C7059E /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 3B07BDE90E3F3F9E00647869 /* WidgetFrameworkTest */;
+			targetProxy = 4024D165113D7D3100C7059E /* PBXContainerItemProxy */;
+		};
+		4024D1ED113D840900C7059E /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */;
+			targetProxy = 4024D1EC113D840900C7059E /* PBXContainerItemProxy */;
+		};
+		4024D1EF113D840D00C7059E /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 4024D162113D7D2400C7059E /* Test */;
+			targetProxy = 4024D1EE113D840D00C7059E /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin XCBuildConfiguration section */
+		3B07BDEC0E3F3F9F00647869 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = WidgetFrameworkTest;
+			};
+			name = Debug;
+		};
+		3B07BDED0E3F3F9F00647869 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = WidgetFrameworkTest;
+			};
+			name = Release;
+		};
+		4024D163113D7D2400C7059E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = TestAndBuild;
+			};
+			name = Debug;
+		};
+		4024D164113D7D2400C7059E /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = TestAndBuild;
+			};
+			name = Release;
+		};
+		4024D1EA113D83FF00C7059E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = TestAndBuild;
+			};
+			name = Debug;
+		};
+		4024D1EB113D83FF00C7059E /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = TestAndBuild;
+			};
+			name = Release;
+		};
+		4FADC24308B4156D00ABE55E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				DYLIB_COMPATIBILITY_VERSION = 1;
+				DYLIB_CURRENT_VERSION = 1;
+				FRAMEWORK_VERSION = A;
+				INFOPLIST_FILE = Info.plist;
+				INSTALL_PATH = "@loader_path/../Frameworks";
+				PRODUCT_NAME = Widget;
+			};
+			name = Debug;
+		};
+		4FADC24408B4156D00ABE55E /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				DYLIB_COMPATIBILITY_VERSION = 1;
+				DYLIB_CURRENT_VERSION = 1;
+				FRAMEWORK_VERSION = A;
+				INFOPLIST_FILE = Info.plist;
+				INSTALL_PATH = "@loader_path/../Frameworks";
+				PRODUCT_NAME = Widget;
+			};
+			name = Release;
+		};
+		4FADC24708B4156D00ABE55E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_VERSION = 4.0;
+				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
+			};
+			name = Debug;
+		};
+		4FADC24808B4156D00ABE55E /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_VERSION = 4.0;
+				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		3B07BDF40E3F3FB600647869 /* Build configuration list for PBXNativeTarget "WidgetFrameworkTest" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				3B07BDEC0E3F3F9F00647869 /* Debug */,
+				3B07BDED0E3F3F9F00647869 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4024D169113D7D4600C7059E /* Build configuration list for PBXAggregateTarget "Test" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4024D163113D7D2400C7059E /* Debug */,
+				4024D164113D7D2400C7059E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4024D1F0113D842B00C7059E /* Build configuration list for PBXAggregateTarget "TestAndBuild" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4024D1EA113D83FF00C7059E /* Debug */,
+				4024D1EB113D83FF00C7059E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "WidgetFramework" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4FADC24308B4156D00ABE55E /* Debug */,
+				4FADC24408B4156D00ABE55E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "WidgetFramework" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4FADC24708B4156D00ABE55E /* Debug */,
+				4FADC24808B4156D00ABE55E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 0867D690FE84028FC02AAC07 /* Project object */;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/runtests.sh b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/runtests.sh
new file mode 100644
index 00000000..4a0d413e
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/runtests.sh
@@ -0,0 +1,62 @@
+#!/bin/bash
+#
+# 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.
+
+# Executes the samples and tests for the Google Test Framework.
+
+# Help the dynamic linker find the path to the libraries.
+export DYLD_FRAMEWORK_PATH=$BUILT_PRODUCTS_DIR
+export DYLD_LIBRARY_PATH=$BUILT_PRODUCTS_DIR
+
+# Create some executables.
+test_executables=$@
+
+# Now execute each one in turn keeping track of how many succeeded and failed.
+succeeded=0
+failed=0
+failed_list=()
+for test in ${test_executables[*]}; do
+  "$test"
+  result=$?
+  if [ $result -eq 0 ]; then
+    succeeded=$(( $succeeded + 1 ))
+  else
+    failed=$(( failed + 1 ))
+    failed_list="$failed_list $test"
+  fi
+done
+
+# Report the successes and failures to the console.
+echo "Tests complete with $succeeded successes and $failed failures."
+if [ $failed -ne 0 ]; then
+  echo "The following tests failed:"
+  echo $failed_list
+fi
+exit $failed
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.cc
new file mode 100644
index 00000000..bfc4e7fc
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.cc
@@ -0,0 +1,63 @@
+// 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.
+//
+// Author: preston.a.jackson@gmail.com (Preston Jackson)
+//
+// Google Test - FrameworkSample
+// widget.cc
+//
+
+// Widget is a very simple class used for demonstrating the use of gtest
+
+#include "widget.h"
+
+Widget::Widget(int number, const std::string& name)
+    : number_(number),
+      name_(name) {}
+
+Widget::~Widget() {}
+
+float Widget::GetFloatValue() const {
+  return number_;
+}
+
+int Widget::GetIntValue() const {
+  return static_cast<int>(number_);
+}
+
+std::string Widget::GetStringValue() const {
+  return name_;
+}
+
+void Widget::GetCharPtrValue(char* buffer, size_t max_size) const {
+  // Copy the char* representation of name_ into buffer, up to max_size.
+  strncpy(buffer, name_.c_str(), max_size-1);
+  buffer[max_size-1] = '\0';
+  return;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.h b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.h
new file mode 100644
index 00000000..0c55cdc8
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.h
@@ -0,0 +1,59 @@
+// 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.
+//
+// Author: preston.a.jackson@gmail.com (Preston Jackson)
+//
+// Google Test - FrameworkSample
+// widget.h
+//
+
+// Widget is a very simple class used for demonstrating the use of gtest. It
+// simply stores two values a string and an integer, which are returned via
+// public accessors in multiple forms.
+
+#import <string>
+
+class Widget {
+ public:
+  Widget(int number, const std::string& name);
+  ~Widget();
+
+  // Public accessors to number data
+  float GetFloatValue() const;
+  int GetIntValue() const;
+
+  // Public accessors to the string data
+  std::string GetStringValue() const;
+  void GetCharPtrValue(char* buffer, size_t max_size) const;
+
+ private:
+  // Data members
+  float number_;
+  std::string name_;
+};
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget_test.cc
new file mode 100644
index 00000000..87259942
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget_test.cc
@@ -0,0 +1,68 @@
+// 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.
+//
+// Author: preston.a.jackson@gmail.com (Preston Jackson)
+//
+// Google Test - FrameworkSample
+// widget_test.cc
+//
+
+// This is a simple test file for the Widget class in the Widget.framework
+
+#include <string>
+#include "gtest/gtest.h"
+
+#include <Widget/widget.h>
+
+// This test verifies that the constructor sets the internal state of the
+// Widget class correctly.
+TEST(WidgetInitializerTest, TestConstructor) {
+  Widget widget(1.0f, "name");
+  EXPECT_FLOAT_EQ(1.0f, widget.GetFloatValue());
+  EXPECT_EQ(std::string("name"), widget.GetStringValue());
+}
+
+// This test verifies the conversion of the float and string values to int and
+// char*, respectively.
+TEST(WidgetInitializerTest, TestConversion) {
+  Widget widget(1.0f, "name");
+  EXPECT_EQ(1, widget.GetIntValue());
+
+  size_t max_size = 128;
+  char buffer[max_size];
+  widget.GetCharPtrValue(buffer, max_size);
+  EXPECT_STREQ("name", buffer);
+}
+
+// Use the Google Test main that is linked into the framework. It does something
+// like this:
+// int main(int argc, char** argv) {
+//   testing::InitGoogleTest(&argc, argv);
+//   return RUN_ALL_TESTS();
+// }
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/runtests.sh b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/runtests.sh
new file mode 100644
index 00000000..3fc229f1
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/runtests.sh
@@ -0,0 +1,65 @@
+#!/bin/bash
+#
+# 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.
+
+# Executes the samples and tests for the Google Test Framework.
+
+# Help the dynamic linker find the path to the libraries.
+export DYLD_FRAMEWORK_PATH=$BUILT_PRODUCTS_DIR
+export DYLD_LIBRARY_PATH=$BUILT_PRODUCTS_DIR
+
+# Create some executables.
+test_executables=("$BUILT_PRODUCTS_DIR/gtest_unittest-framework"
+                  "$BUILT_PRODUCTS_DIR/gtest_unittest"
+                  "$BUILT_PRODUCTS_DIR/sample1_unittest-framework"
+                  "$BUILT_PRODUCTS_DIR/sample1_unittest-static")
+
+# Now execute each one in turn keeping track of how many succeeded and failed. 
+succeeded=0
+failed=0
+failed_list=()
+for test in ${test_executables[*]}; do
+  "$test"
+  result=$?
+  if [ $result -eq 0 ]; then
+    succeeded=$(( $succeeded + 1 ))
+  else
+    failed=$(( failed + 1 ))
+    failed_list="$failed_list $test"
+  fi
+done
+
+# Report the successes and failures to the console.
+echo "Tests complete with $succeeded successes and $failed failures."
+if [ $failed -ne 0 ]; then
+  echo "The following tests failed:"
+  echo $failed_list
+fi
+exit $failed
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/versiongenerate.py b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/versiongenerate.py
new file mode 100755
index 00000000..81de8c96
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/versiongenerate.py
@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+#
+# 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.
+
+"""A script to prepare version informtion for use the gtest Info.plist file.
+
+  This script extracts the version information from the configure.ac file and
+  uses it to generate a header file containing the same information. The
+  #defines in this header file will be included in during the generation of
+  the Info.plist of the framework, giving the correct value to the version
+  shown in the Finder.
+
+  This script makes the following assumptions (these are faults of the script,
+  not problems with the Autoconf):
+    1. The AC_INIT macro will be contained within the first 1024 characters
+       of configure.ac
+    2. The version string will be 3 integers separated by periods and will be
+       surrounded by squre brackets, "[" and "]" (e.g. [1.0.1]). The first
+       segment represents the major version, the second represents the minor
+       version and the third represents the fix version.
+    3. No ")" character exists between the opening "(" and closing ")" of
+       AC_INIT, including in comments and character strings.
+"""
+
+import sys
+import re
+
+# Read the command line argument (the output directory for Version.h)
+if (len(sys.argv) < 3):
+  print "Usage: versiongenerate.py input_dir output_dir"
+  sys.exit(1)
+else:
+  input_dir = sys.argv[1]
+  output_dir = sys.argv[2]
+
+# Read the first 1024 characters of the configure.ac file
+config_file = open("%s/configure.ac" % input_dir, 'r')
+buffer_size = 1024
+opening_string = config_file.read(buffer_size)
+config_file.close()
+
+# Extract the version string from the AC_INIT macro
+#   The following init_expression means:
+#     Extract three integers separated by periods and surrounded by squre
+#     brackets(e.g. "[1.0.1]") between "AC_INIT(" and ")". Do not be greedy
+#     (*? is the non-greedy flag) since that would pull in everything between
+#     the first "(" and the last ")" in the file.
+version_expression = re.compile(r"AC_INIT\(.*?\[(\d+)\.(\d+)\.(\d+)\].*?\)",
+                                re.DOTALL)
+version_values = version_expression.search(opening_string)
+major_version = version_values.group(1)
+minor_version = version_values.group(2)
+fix_version = version_values.group(3)
+
+# Write the version information to a header file to be included in the
+# Info.plist file.
+file_data = """//
+// DO NOT MODIFY THIS FILE (but you can delete it)
+//
+// This file is autogenerated by the versiongenerate.py script. This script
+// is executed in a "Run Script" build phase when creating gtest.framework. This
+// header file is not used during compilation of C-source. Rather, it simply
+// defines some version strings for substitution in the Info.plist. Because of
+// this, we are not not restricted to C-syntax nor are we using include guards.
+//
+
+#define GTEST_VERSIONINFO_SHORT %s.%s
+#define GTEST_VERSIONINFO_LONG %s.%s.%s
+
+""" % (major_version, minor_version, major_version, minor_version, fix_version)
+version_file = open("%s/Version.h" % output_dir, 'w')
+version_file.write(file_data)
+version_file.close()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/gtest.xcodeproj/project.pbxproj b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/gtest.xcodeproj/project.pbxproj
new file mode 100644
index 00000000..aefaa88b
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/gtest.xcodeproj/project.pbxproj
@@ -0,0 +1,1135 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXAggregateTarget section */
+		3B238F5F0E828B5400846E11 /* Check */ = {
+			isa = PBXAggregateTarget;
+			buildConfigurationList = 3B238FA30E828BB600846E11 /* Build configuration list for PBXAggregateTarget "Check" */;
+			buildPhases = (
+				3B238F5E0E828B5400846E11 /* ShellScript */,
+			);
+			dependencies = (
+				40899F9D0FFA740F000B29AE /* PBXTargetDependency */,
+				40C849F7101A43440083642A /* PBXTargetDependency */,
+				4089A0980FFAD34A000B29AE /* PBXTargetDependency */,
+				40C849F9101A43490083642A /* PBXTargetDependency */,
+			);
+			name = Check;
+			productName = Check;
+		};
+		40C44ADC0E3798F4008FCC51 /* Version Info */ = {
+			isa = PBXAggregateTarget;
+			buildConfigurationList = 40C44AE40E379905008FCC51 /* Build configuration list for PBXAggregateTarget "Version Info" */;
+			buildPhases = (
+				40C44ADB0E3798F4008FCC51 /* Generate Version.h */,
+			);
+			comments = "The generation of Version.h must be performed in its own target. Since the Info.plist is preprocessed before any of the other build phases in gtest, the Version.h file would not be ready if included as a build phase of that target.";
+			dependencies = (
+			);
+			name = "Version Info";
+			productName = Version.h;
+		};
+/* End PBXAggregateTarget section */
+
+/* Begin PBXBuildFile section */
+		224A12A30E9EADCC00BD17FD /* gtest-test-part.h in Headers */ = {isa = PBXBuildFile; fileRef = 224A12A20E9EADCC00BD17FD /* gtest-test-part.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		3BF6F2A00E79B5AD000F2EEE /* gtest-type-util.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */; };
+		3BF6F2A50E79B616000F2EEE /* gtest-typed-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		404884380E2F799B00CF7658 /* gtest-death-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DB0E2F799B00CF7658 /* gtest-death-test.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		404884390E2F799B00CF7658 /* gtest-message.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DC0E2F799B00CF7658 /* gtest-message.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		4048843A0E2F799B00CF7658 /* gtest-spi.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DD0E2F799B00CF7658 /* gtest-spi.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		4048843B0E2F799B00CF7658 /* gtest.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DE0E2F799B00CF7658 /* gtest.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		4048843C0E2F799B00CF7658 /* gtest_pred_impl.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		4048843D0E2F799B00CF7658 /* gtest_prod.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883E00E2F799B00CF7658 /* gtest_prod.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		404884500E2F799B00CF7658 /* README.md in Resources */ = {isa = PBXBuildFile; fileRef = 404883F60E2F799B00CF7658 /* README.md */; };
+		404884A00E2F7BE600CF7658 /* gtest-death-test-internal.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */; };
+		404884A10E2F7BE600CF7658 /* gtest-filepath.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E30E2F799B00CF7658 /* gtest-filepath.h */; };
+		404884A20E2F7BE600CF7658 /* gtest-internal.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E40E2F799B00CF7658 /* gtest-internal.h */; };
+		404884A30E2F7BE600CF7658 /* gtest-port.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E50E2F799B00CF7658 /* gtest-port.h */; };
+		404884A40E2F7BE600CF7658 /* gtest-string.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E60E2F799B00CF7658 /* gtest-string.h */; };
+		404884AC0E2F7CD900CF7658 /* CHANGES in Resources */ = {isa = PBXBuildFile; fileRef = 404884A90E2F7CD900CF7658 /* CHANGES */; };
+		404884AD0E2F7CD900CF7658 /* CONTRIBUTORS in Resources */ = {isa = PBXBuildFile; fileRef = 404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */; };
+		404884AE0E2F7CD900CF7658 /* LICENSE in Resources */ = {isa = PBXBuildFile; fileRef = 404884AB0E2F7CD900CF7658 /* LICENSE */; };
+		40899F3A0FFA70D4000B29AE /* gtest-all.cc in Sources */ = {isa = PBXBuildFile; fileRef = 224A12A10E9EADA700BD17FD /* gtest-all.cc */; };
+		40899F500FFA7281000B29AE /* gtest-tuple.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 40899F4D0FFA7271000B29AE /* gtest-tuple.h */; };
+		40899F530FFA72A0000B29AE /* gtest_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B238C120E7FE13C00846E11 /* gtest_unittest.cc */; };
+		4089A0440FFAD1BE000B29AE /* sample1.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02C0FFACF7F000B29AE /* sample1.cc */; };
+		4089A0460FFAD1BE000B29AE /* sample1_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */; };
+		40C848FF101A21150083642A /* gtest-all.cc in Sources */ = {isa = PBXBuildFile; fileRef = 224A12A10E9EADA700BD17FD /* gtest-all.cc */; };
+		40C84915101A21DF0083642A /* gtest_main.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4048840D0E2F799B00CF7658 /* gtest_main.cc */; };
+		40C84916101A235B0083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
+		40C84921101A23AD0083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
+		40C84978101A36540083642A /* libgtest_main.a in Resources */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
+		40C84980101A36850083642A /* gtest_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B238C120E7FE13C00846E11 /* gtest_unittest.cc */; };
+		40C84982101A36850083642A /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C848FA101A209C0083642A /* libgtest.a */; };
+		40C84983101A36850083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
+		40C8498F101A36A60083642A /* sample1.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02C0FFACF7F000B29AE /* sample1.cc */; };
+		40C84990101A36A60083642A /* sample1_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */; };
+		40C84992101A36A60083642A /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C848FA101A209C0083642A /* libgtest.a */; };
+		40C84993101A36A60083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
+		40C849A2101A37050083642A /* gtest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4539C8FF0EC27F6400A70F4C /* gtest.framework */; };
+		40C849A4101A37150083642A /* gtest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4539C8FF0EC27F6400A70F4C /* gtest.framework */; };
+		4539C9340EC280AE00A70F4C /* gtest-param-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 4539C9330EC280AE00A70F4C /* gtest-param-test.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		4539C9380EC280E200A70F4C /* gtest-linked_ptr.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */; };
+		4539C9390EC280E200A70F4C /* gtest-param-util-generated.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */; };
+		4539C93A0EC280E200A70F4C /* gtest-param-util.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9370EC280E200A70F4C /* gtest-param-util.h */; };
+		4567C8181264FF71007740BE /* gtest-printers.h in Headers */ = {isa = PBXBuildFile; fileRef = 4567C8171264FF71007740BE /* gtest-printers.h */; settings = {ATTRIBUTES = (Public, ); }; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		40899F9C0FFA740F000B29AE /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40899F420FFA7184000B29AE;
+			remoteInfo = gtest_unittest;
+		};
+		4089A0970FFAD34A000B29AE /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 4089A0120FFACEFC000B29AE;
+			remoteInfo = sample1_unittest;
+		};
+		408BEC0F1046CFE900DEF522 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C848F9101A209C0083642A;
+			remoteInfo = "gtest-static";
+		};
+		40C44AE50E379922008FCC51 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C44ADC0E3798F4008FCC51;
+			remoteInfo = Version.h;
+		};
+		40C8497C101A36850083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C848F9101A209C0083642A;
+			remoteInfo = "gtest-static";
+		};
+		40C8497E101A36850083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C8490A101A217E0083642A;
+			remoteInfo = "gtest_main-static";
+		};
+		40C8498B101A36A60083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C848F9101A209C0083642A;
+			remoteInfo = "gtest-static";
+		};
+		40C8498D101A36A60083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C8490A101A217E0083642A;
+			remoteInfo = "gtest_main-static";
+		};
+		40C8499B101A36DC0083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C8490A101A217E0083642A;
+			remoteInfo = "gtest_main-static";
+		};
+		40C8499D101A36E50083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
+			remoteInfo = "gtest-framework";
+		};
+		40C8499F101A36F10083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
+			remoteInfo = "gtest-framework";
+		};
+		40C849F6101A43440083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C8497A101A36850083642A;
+			remoteInfo = "gtest_unittest-static";
+		};
+		40C849F8101A43490083642A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 40C84989101A36A60083642A;
+			remoteInfo = "sample1_unittest-static";
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		404884A50E2F7C0400CF7658 /* Copy Headers Internal */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = Headers/internal;
+			dstSubfolderSpec = 6;
+			files = (
+				404884A00E2F7BE600CF7658 /* gtest-death-test-internal.h in Copy Headers Internal */,
+				404884A10E2F7BE600CF7658 /* gtest-filepath.h in Copy Headers Internal */,
+				404884A20E2F7BE600CF7658 /* gtest-internal.h in Copy Headers Internal */,
+				4539C9380EC280E200A70F4C /* gtest-linked_ptr.h in Copy Headers Internal */,
+				4539C9390EC280E200A70F4C /* gtest-param-util-generated.h in Copy Headers Internal */,
+				4539C93A0EC280E200A70F4C /* gtest-param-util.h in Copy Headers Internal */,
+				404884A30E2F7BE600CF7658 /* gtest-port.h in Copy Headers Internal */,
+				404884A40E2F7BE600CF7658 /* gtest-string.h in Copy Headers Internal */,
+				40899F500FFA7281000B29AE /* gtest-tuple.h in Copy Headers Internal */,
+				3BF6F2A00E79B5AD000F2EEE /* gtest-type-util.h in Copy Headers Internal */,
+			);
+			name = "Copy Headers Internal";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		224A12A10E9EADA700BD17FD /* gtest-all.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = "gtest-all.cc"; sourceTree = "<group>"; };
+		224A12A20E9EADCC00BD17FD /* gtest-test-part.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = "gtest-test-part.h"; sourceTree = "<group>"; };
+		3B238C120E7FE13C00846E11 /* gtest_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gtest_unittest.cc; sourceTree = "<group>"; };
+		3B87D2100E96B92E000D1852 /* runtests.sh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.sh; path = runtests.sh; sourceTree = "<group>"; };
+		3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-type-util.h"; sourceTree = "<group>"; };
+		3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-typed-test.h"; sourceTree = "<group>"; };
+		403EE37C0E377822004BD1E2 /* versiongenerate.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = versiongenerate.py; sourceTree = "<group>"; };
+		404883DB0E2F799B00CF7658 /* gtest-death-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-death-test.h"; sourceTree = "<group>"; };
+		404883DC0E2F799B00CF7658 /* gtest-message.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-message.h"; sourceTree = "<group>"; };
+		404883DD0E2F799B00CF7658 /* gtest-spi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-spi.h"; sourceTree = "<group>"; };
+		404883DE0E2F799B00CF7658 /* gtest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest.h; sourceTree = "<group>"; };
+		404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest_pred_impl.h; sourceTree = "<group>"; };
+		404883E00E2F799B00CF7658 /* gtest_prod.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest_prod.h; sourceTree = "<group>"; };
+		404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-death-test-internal.h"; sourceTree = "<group>"; };
+		404883E30E2F799B00CF7658 /* gtest-filepath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-filepath.h"; sourceTree = "<group>"; };
+		404883E40E2F799B00CF7658 /* gtest-internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-internal.h"; sourceTree = "<group>"; };
+		404883E50E2F799B00CF7658 /* gtest-port.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-port.h"; sourceTree = "<group>"; };
+		404883E60E2F799B00CF7658 /* gtest-string.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-string.h"; sourceTree = "<group>"; };
+		404883F60E2F799B00CF7658 /* README.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = README.md; path = ../README.md; sourceTree = SOURCE_ROOT; };
+		4048840D0E2F799B00CF7658 /* gtest_main.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gtest_main.cc; sourceTree = "<group>"; };
+		404884A90E2F7CD900CF7658 /* CHANGES */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CHANGES; path = ../CHANGES; sourceTree = SOURCE_ROOT; };
+		404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CONTRIBUTORS; path = ../CONTRIBUTORS; sourceTree = SOURCE_ROOT; };
+		404884AB0E2F7CD900CF7658 /* LICENSE */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = LICENSE; path = ../LICENSE; sourceTree = SOURCE_ROOT; };
+		40899F430FFA7184000B29AE /* gtest_unittest-framework */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "gtest_unittest-framework"; sourceTree = BUILT_PRODUCTS_DIR; };
+		40899F4D0FFA7271000B29AE /* gtest-tuple.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-tuple.h"; sourceTree = "<group>"; };
+		40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = StaticLibraryTarget.xcconfig; sourceTree = "<group>"; };
+		4089A0130FFACEFC000B29AE /* sample1_unittest-framework */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "sample1_unittest-framework"; sourceTree = BUILT_PRODUCTS_DIR; };
+		4089A02C0FFACF7F000B29AE /* sample1.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sample1.cc; sourceTree = "<group>"; };
+		4089A02D0FFACF7F000B29AE /* sample1.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sample1.h; sourceTree = "<group>"; };
+		4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sample1_unittest.cc; sourceTree = "<group>"; };
+		40C848FA101A209C0083642A /* libgtest.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgtest.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		40C8490B101A217E0083642A /* libgtest_main.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgtest_main.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		40C84987101A36850083642A /* gtest_unittest */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = gtest_unittest; sourceTree = BUILT_PRODUCTS_DIR; };
+		40C84997101A36A60083642A /* sample1_unittest-static */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "sample1_unittest-static"; sourceTree = BUILT_PRODUCTS_DIR; };
+		40D4CDF10E30E07400294801 /* DebugProject.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = DebugProject.xcconfig; sourceTree = "<group>"; };
+		40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = FrameworkTarget.xcconfig; sourceTree = "<group>"; };
+		40D4CDF30E30E07400294801 /* General.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = General.xcconfig; sourceTree = "<group>"; };
+		40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = ReleaseProject.xcconfig; sourceTree = "<group>"; };
+		40D4CF510E30F5E200294801 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		4539C8FF0EC27F6400A70F4C /* gtest.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = gtest.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+		4539C9330EC280AE00A70F4C /* gtest-param-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-test.h"; sourceTree = "<group>"; };
+		4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-linked_ptr.h"; sourceTree = "<group>"; };
+		4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-util-generated.h"; sourceTree = "<group>"; };
+		4539C9370EC280E200A70F4C /* gtest-param-util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-util.h"; sourceTree = "<group>"; };
+		4567C8171264FF71007740BE /* gtest-printers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-printers.h"; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		40899F410FFA7184000B29AE /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C849A4101A37150083642A /* gtest.framework in Frameworks */,
+				40C84916101A235B0083642A /* libgtest_main.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		4089A0110FFACEFC000B29AE /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C849A2101A37050083642A /* gtest.framework in Frameworks */,
+				40C84921101A23AD0083642A /* libgtest_main.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		40C84981101A36850083642A /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C84982101A36850083642A /* libgtest.a in Frameworks */,
+				40C84983101A36850083642A /* libgtest_main.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		40C84991101A36A60083642A /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C84992101A36A60083642A /* libgtest.a in Frameworks */,
+				40C84993101A36A60083642A /* libgtest_main.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		034768DDFF38A45A11DB9C8B /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				4539C8FF0EC27F6400A70F4C /* gtest.framework */,
+				40C848FA101A209C0083642A /* libgtest.a */,
+				40C8490B101A217E0083642A /* libgtest_main.a */,
+				40899F430FFA7184000B29AE /* gtest_unittest-framework */,
+				40C84987101A36850083642A /* gtest_unittest */,
+				4089A0130FFACEFC000B29AE /* sample1_unittest-framework */,
+				40C84997101A36A60083642A /* sample1_unittest-static */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		0867D691FE84028FC02AAC07 /* gtest */ = {
+			isa = PBXGroup;
+			children = (
+				40D4CDF00E30E07400294801 /* Config */,
+				08FB77ACFE841707C02AAC07 /* Source */,
+				40D4CF4E0E30F5E200294801 /* Resources */,
+				403EE37B0E377822004BD1E2 /* Scripts */,
+				034768DDFF38A45A11DB9C8B /* Products */,
+			);
+			name = gtest;
+			sourceTree = "<group>";
+		};
+		08FB77ACFE841707C02AAC07 /* Source */ = {
+			isa = PBXGroup;
+			children = (
+				404884A90E2F7CD900CF7658 /* CHANGES */,
+				404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */,
+				404884AB0E2F7CD900CF7658 /* LICENSE */,
+				404883F60E2F799B00CF7658 /* README.md */,
+				404883D90E2F799B00CF7658 /* include */,
+				4089A02F0FFACF84000B29AE /* samples */,
+				404884070E2F799B00CF7658 /* src */,
+				3B238BF00E7FE13B00846E11 /* test */,
+			);
+			name = Source;
+			sourceTree = "<group>";
+		};
+		3B238BF00E7FE13B00846E11 /* test */ = {
+			isa = PBXGroup;
+			children = (
+				3B238C120E7FE13C00846E11 /* gtest_unittest.cc */,
+			);
+			name = test;
+			path = ../test;
+			sourceTree = SOURCE_ROOT;
+		};
+		403EE37B0E377822004BD1E2 /* Scripts */ = {
+			isa = PBXGroup;
+			children = (
+				403EE37C0E377822004BD1E2 /* versiongenerate.py */,
+				3B87D2100E96B92E000D1852 /* runtests.sh */,
+			);
+			path = Scripts;
+			sourceTree = "<group>";
+		};
+		404883D90E2F799B00CF7658 /* include */ = {
+			isa = PBXGroup;
+			children = (
+				404883DA0E2F799B00CF7658 /* gtest */,
+			);
+			name = include;
+			path = ../include;
+			sourceTree = SOURCE_ROOT;
+		};
+		404883DA0E2F799B00CF7658 /* gtest */ = {
+			isa = PBXGroup;
+			children = (
+				404883E10E2F799B00CF7658 /* internal */,
+				224A12A20E9EADCC00BD17FD /* gtest-test-part.h */,
+				404883DB0E2F799B00CF7658 /* gtest-death-test.h */,
+				404883DC0E2F799B00CF7658 /* gtest-message.h */,
+				4539C9330EC280AE00A70F4C /* gtest-param-test.h */,
+				4567C8171264FF71007740BE /* gtest-printers.h */,
+				404883DD0E2F799B00CF7658 /* gtest-spi.h */,
+				404883DE0E2F799B00CF7658 /* gtest.h */,
+				404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */,
+				404883E00E2F799B00CF7658 /* gtest_prod.h */,
+				3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */,
+			);
+			path = gtest;
+			sourceTree = "<group>";
+		};
+		404883E10E2F799B00CF7658 /* internal */ = {
+			isa = PBXGroup;
+			children = (
+				404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */,
+				404883E30E2F799B00CF7658 /* gtest-filepath.h */,
+				404883E40E2F799B00CF7658 /* gtest-internal.h */,
+				4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */,
+				4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */,
+				4539C9370EC280E200A70F4C /* gtest-param-util.h */,
+				404883E50E2F799B00CF7658 /* gtest-port.h */,
+				404883E60E2F799B00CF7658 /* gtest-string.h */,
+				40899F4D0FFA7271000B29AE /* gtest-tuple.h */,
+				3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */,
+			);
+			path = internal;
+			sourceTree = "<group>";
+		};
+		404884070E2F799B00CF7658 /* src */ = {
+			isa = PBXGroup;
+			children = (
+				224A12A10E9EADA700BD17FD /* gtest-all.cc */,
+				4048840D0E2F799B00CF7658 /* gtest_main.cc */,
+			);
+			name = src;
+			path = ../src;
+			sourceTree = SOURCE_ROOT;
+		};
+		4089A02F0FFACF84000B29AE /* samples */ = {
+			isa = PBXGroup;
+			children = (
+				4089A02C0FFACF7F000B29AE /* sample1.cc */,
+				4089A02D0FFACF7F000B29AE /* sample1.h */,
+				4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */,
+			);
+			name = samples;
+			path = ../samples;
+			sourceTree = SOURCE_ROOT;
+		};
+		40D4CDF00E30E07400294801 /* Config */ = {
+			isa = PBXGroup;
+			children = (
+				40D4CDF10E30E07400294801 /* DebugProject.xcconfig */,
+				40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */,
+				40D4CDF30E30E07400294801 /* General.xcconfig */,
+				40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */,
+				40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */,
+			);
+			path = Config;
+			sourceTree = "<group>";
+		};
+		40D4CF4E0E30F5E200294801 /* Resources */ = {
+			isa = PBXGroup;
+			children = (
+				40D4CF510E30F5E200294801 /* Info.plist */,
+			);
+			path = Resources;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+		8D07F2BD0486CC7A007CD1D0 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				404884380E2F799B00CF7658 /* gtest-death-test.h in Headers */,
+				404884390E2F799B00CF7658 /* gtest-message.h in Headers */,
+				4539C9340EC280AE00A70F4C /* gtest-param-test.h in Headers */,
+				4567C8181264FF71007740BE /* gtest-printers.h in Headers */,
+				3BF6F2A50E79B616000F2EEE /* gtest-typed-test.h in Headers */,
+				4048843A0E2F799B00CF7658 /* gtest-spi.h in Headers */,
+				4048843B0E2F799B00CF7658 /* gtest.h in Headers */,
+				4048843C0E2F799B00CF7658 /* gtest_pred_impl.h in Headers */,
+				4048843D0E2F799B00CF7658 /* gtest_prod.h in Headers */,
+				224A12A30E9EADCC00BD17FD /* gtest-test-part.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+		40899F420FFA7184000B29AE /* gtest_unittest-framework */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 40899F4A0FFA71BC000B29AE /* Build configuration list for PBXNativeTarget "gtest_unittest-framework" */;
+			buildPhases = (
+				40899F400FFA7184000B29AE /* Sources */,
+				40899F410FFA7184000B29AE /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				40C849A0101A36F10083642A /* PBXTargetDependency */,
+			);
+			name = "gtest_unittest-framework";
+			productName = gtest_unittest;
+			productReference = 40899F430FFA7184000B29AE /* gtest_unittest-framework */;
+			productType = "com.apple.product-type.tool";
+		};
+		4089A0120FFACEFC000B29AE /* sample1_unittest-framework */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 4089A0240FFACF01000B29AE /* Build configuration list for PBXNativeTarget "sample1_unittest-framework" */;
+			buildPhases = (
+				4089A0100FFACEFC000B29AE /* Sources */,
+				4089A0110FFACEFC000B29AE /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				40C8499E101A36E50083642A /* PBXTargetDependency */,
+			);
+			name = "sample1_unittest-framework";
+			productName = sample1_unittest;
+			productReference = 4089A0130FFACEFC000B29AE /* sample1_unittest-framework */;
+			productType = "com.apple.product-type.tool";
+		};
+		40C848F9101A209C0083642A /* gtest-static */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 40C84902101A212E0083642A /* Build configuration list for PBXNativeTarget "gtest-static" */;
+			buildPhases = (
+				40C848F7101A209C0083642A /* Sources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = "gtest-static";
+			productName = "gtest-static";
+			productReference = 40C848FA101A209C0083642A /* libgtest.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+		40C8490A101A217E0083642A /* gtest_main-static */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 40C84912101A21D20083642A /* Build configuration list for PBXNativeTarget "gtest_main-static" */;
+			buildPhases = (
+				40C84908101A217E0083642A /* Sources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = "gtest_main-static";
+			productName = "gtest_main-static";
+			productReference = 40C8490B101A217E0083642A /* libgtest_main.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+		40C8497A101A36850083642A /* gtest_unittest-static */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 40C84984101A36850083642A /* Build configuration list for PBXNativeTarget "gtest_unittest-static" */;
+			buildPhases = (
+				40C8497F101A36850083642A /* Sources */,
+				40C84981101A36850083642A /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				40C8497B101A36850083642A /* PBXTargetDependency */,
+				40C8497D101A36850083642A /* PBXTargetDependency */,
+			);
+			name = "gtest_unittest-static";
+			productName = gtest_unittest;
+			productReference = 40C84987101A36850083642A /* gtest_unittest */;
+			productType = "com.apple.product-type.tool";
+		};
+		40C84989101A36A60083642A /* sample1_unittest-static */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 40C84994101A36A60083642A /* Build configuration list for PBXNativeTarget "sample1_unittest-static" */;
+			buildPhases = (
+				40C8498E101A36A60083642A /* Sources */,
+				40C84991101A36A60083642A /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				40C8498A101A36A60083642A /* PBXTargetDependency */,
+				40C8498C101A36A60083642A /* PBXTargetDependency */,
+			);
+			name = "sample1_unittest-static";
+			productName = sample1_unittest;
+			productReference = 40C84997101A36A60083642A /* sample1_unittest-static */;
+			productType = "com.apple.product-type.tool";
+		};
+		8D07F2BC0486CC7A007CD1D0 /* gtest-framework */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "gtest-framework" */;
+			buildPhases = (
+				8D07F2C10486CC7A007CD1D0 /* Sources */,
+				8D07F2BD0486CC7A007CD1D0 /* Headers */,
+				404884A50E2F7C0400CF7658 /* Copy Headers Internal */,
+				8D07F2BF0486CC7A007CD1D0 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				40C44AE60E379922008FCC51 /* PBXTargetDependency */,
+				408BEC101046CFE900DEF522 /* PBXTargetDependency */,
+				40C8499C101A36DC0083642A /* PBXTargetDependency */,
+			);
+			name = "gtest-framework";
+			productInstallPath = "$(HOME)/Library/Frameworks";
+			productName = gtest;
+			productReference = 4539C8FF0EC27F6400A70F4C /* gtest.framework */;
+			productType = "com.apple.product-type.framework";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		0867D690FE84028FC02AAC07 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0460;
+			};
+			buildConfigurationList = 4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "gtest" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 1;
+			knownRegions = (
+				English,
+				Japanese,
+				French,
+				German,
+				en,
+			);
+			mainGroup = 0867D691FE84028FC02AAC07 /* gtest */;
+			productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				8D07F2BC0486CC7A007CD1D0 /* gtest-framework */,
+				40C848F9101A209C0083642A /* gtest-static */,
+				40C8490A101A217E0083642A /* gtest_main-static */,
+				40899F420FFA7184000B29AE /* gtest_unittest-framework */,
+				40C8497A101A36850083642A /* gtest_unittest-static */,
+				4089A0120FFACEFC000B29AE /* sample1_unittest-framework */,
+				40C84989101A36A60083642A /* sample1_unittest-static */,
+				3B238F5F0E828B5400846E11 /* Check */,
+				40C44ADC0E3798F4008FCC51 /* Version Info */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		8D07F2BF0486CC7A007CD1D0 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				404884500E2F799B00CF7658 /* README.md in Resources */,
+				404884AC0E2F7CD900CF7658 /* CHANGES in Resources */,
+				404884AD0E2F7CD900CF7658 /* CONTRIBUTORS in Resources */,
+				404884AE0E2F7CD900CF7658 /* LICENSE in Resources */,
+				40C84978101A36540083642A /* libgtest_main.a in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		3B238F5E0E828B5400846E11 /* ShellScript */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "# Remember, this \"Run Script\" build phase will be executed from $SRCROOT\n/bin/bash Scripts/runtests.sh";
+		};
+		40C44ADB0E3798F4008FCC51 /* Generate Version.h */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+				"$(SRCROOT)/Scripts/versiongenerate.py",
+				"$(SRCROOT)/../configure.ac",
+			);
+			name = "Generate Version.h";
+			outputPaths = (
+				"$(PROJECT_TEMP_DIR)/Version.h",
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "# Remember, this \"Run Script\" build phase will be executed from $SRCROOT\n/usr/bin/python Scripts/versiongenerate.py ../ $PROJECT_TEMP_DIR";
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		40899F400FFA7184000B29AE /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40899F530FFA72A0000B29AE /* gtest_unittest.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		4089A0100FFACEFC000B29AE /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				4089A0440FFAD1BE000B29AE /* sample1.cc in Sources */,
+				4089A0460FFAD1BE000B29AE /* sample1_unittest.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		40C848F7101A209C0083642A /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C848FF101A21150083642A /* gtest-all.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		40C84908101A217E0083642A /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C84915101A21DF0083642A /* gtest_main.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		40C8497F101A36850083642A /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C84980101A36850083642A /* gtest_unittest.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		40C8498E101A36A60083642A /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40C8498F101A36A60083642A /* sample1.cc in Sources */,
+				40C84990101A36A60083642A /* sample1_unittest.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		8D07F2C10486CC7A007CD1D0 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				40899F3A0FFA70D4000B29AE /* gtest-all.cc in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		40899F9D0FFA740F000B29AE /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40899F420FFA7184000B29AE /* gtest_unittest-framework */;
+			targetProxy = 40899F9C0FFA740F000B29AE /* PBXContainerItemProxy */;
+		};
+		4089A0980FFAD34A000B29AE /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 4089A0120FFACEFC000B29AE /* sample1_unittest-framework */;
+			targetProxy = 4089A0970FFAD34A000B29AE /* PBXContainerItemProxy */;
+		};
+		408BEC101046CFE900DEF522 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C848F9101A209C0083642A /* gtest-static */;
+			targetProxy = 408BEC0F1046CFE900DEF522 /* PBXContainerItemProxy */;
+		};
+		40C44AE60E379922008FCC51 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C44ADC0E3798F4008FCC51 /* Version Info */;
+			targetProxy = 40C44AE50E379922008FCC51 /* PBXContainerItemProxy */;
+		};
+		40C8497B101A36850083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C848F9101A209C0083642A /* gtest-static */;
+			targetProxy = 40C8497C101A36850083642A /* PBXContainerItemProxy */;
+		};
+		40C8497D101A36850083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C8490A101A217E0083642A /* gtest_main-static */;
+			targetProxy = 40C8497E101A36850083642A /* PBXContainerItemProxy */;
+		};
+		40C8498A101A36A60083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C848F9101A209C0083642A /* gtest-static */;
+			targetProxy = 40C8498B101A36A60083642A /* PBXContainerItemProxy */;
+		};
+		40C8498C101A36A60083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C8490A101A217E0083642A /* gtest_main-static */;
+			targetProxy = 40C8498D101A36A60083642A /* PBXContainerItemProxy */;
+		};
+		40C8499C101A36DC0083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C8490A101A217E0083642A /* gtest_main-static */;
+			targetProxy = 40C8499B101A36DC0083642A /* PBXContainerItemProxy */;
+		};
+		40C8499E101A36E50083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 8D07F2BC0486CC7A007CD1D0 /* gtest-framework */;
+			targetProxy = 40C8499D101A36E50083642A /* PBXContainerItemProxy */;
+		};
+		40C849A0101A36F10083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 8D07F2BC0486CC7A007CD1D0 /* gtest-framework */;
+			targetProxy = 40C8499F101A36F10083642A /* PBXContainerItemProxy */;
+		};
+		40C849F7101A43440083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C8497A101A36850083642A /* gtest_unittest-static */;
+			targetProxy = 40C849F6101A43440083642A /* PBXContainerItemProxy */;
+		};
+		40C849F9101A43490083642A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 40C84989101A36A60083642A /* sample1_unittest-static */;
+			targetProxy = 40C849F8101A43490083642A /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin XCBuildConfiguration section */
+		3B238F600E828B5400846E11 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COMBINE_HIDPI_IMAGES = YES;
+				COPY_PHASE_STRIP = NO;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				PRODUCT_NAME = Check;
+				SDKROOT = macosx;
+			};
+			name = Debug;
+		};
+		3B238F610E828B5400846E11 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COMBINE_HIDPI_IMAGES = YES;
+				COPY_PHASE_STRIP = YES;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				PRODUCT_NAME = Check;
+				SDKROOT = macosx;
+				ZERO_LINK = NO;
+			};
+			name = Release;
+		};
+		40899F450FFA7185000B29AE /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				HEADER_SEARCH_PATHS = ../;
+				PRODUCT_NAME = "gtest_unittest-framework";
+				SDKROOT = macosx;
+			};
+			name = Debug;
+		};
+		40899F460FFA7185000B29AE /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				HEADER_SEARCH_PATHS = ../;
+				PRODUCT_NAME = "gtest_unittest-framework";
+				SDKROOT = macosx;
+			};
+			name = Release;
+		};
+		4089A0150FFACEFD000B29AE /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				PRODUCT_NAME = "sample1_unittest-framework";
+				SDKROOT = macosx;
+			};
+			name = Debug;
+		};
+		4089A0160FFACEFD000B29AE /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				PRODUCT_NAME = "sample1_unittest-framework";
+				SDKROOT = macosx;
+			};
+			name = Release;
+		};
+		40C44ADF0E3798F4008FCC51 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COMBINE_HIDPI_IMAGES = YES;
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				MACOSX_DEPLOYMENT_TARGET = 10.7;
+				PRODUCT_NAME = gtest;
+				SDKROOT = macosx;
+				TARGET_NAME = gtest;
+			};
+			name = Debug;
+		};
+		40C44AE00E3798F4008FCC51 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COMBINE_HIDPI_IMAGES = YES;
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				MACOSX_DEPLOYMENT_TARGET = 10.7;
+				PRODUCT_NAME = gtest;
+				SDKROOT = macosx;
+				TARGET_NAME = gtest;
+			};
+			name = Release;
+		};
+		40C848FB101A209D0083642A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
+			buildSettings = {
+				COMBINE_HIDPI_IMAGES = YES;
+				GCC_INLINES_ARE_PRIVATE_EXTERN = YES;
+				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				HEADER_SEARCH_PATHS = (
+					../,
+					../include/,
+				);
+				PRODUCT_NAME = gtest;
+				SDKROOT = macosx;
+			};
+			name = Debug;
+		};
+		40C848FC101A209D0083642A /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
+			buildSettings = {
+				COMBINE_HIDPI_IMAGES = YES;
+				GCC_INLINES_ARE_PRIVATE_EXTERN = YES;
+				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				HEADER_SEARCH_PATHS = (
+					../,
+					../include/,
+				);
+				PRODUCT_NAME = gtest;
+				SDKROOT = macosx;
+			};
+			name = Release;
+		};
+		40C8490E101A217F0083642A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
+			buildSettings = {
+				COMBINE_HIDPI_IMAGES = YES;
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				HEADER_SEARCH_PATHS = (
+					../,
+					../include/,
+				);
+				PRODUCT_NAME = gtest_main;
+				SDKROOT = macosx;
+			};
+			name = Debug;
+		};
+		40C8490F101A217F0083642A /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
+			buildSettings = {
+				COMBINE_HIDPI_IMAGES = YES;
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				HEADER_SEARCH_PATHS = (
+					../,
+					../include/,
+				);
+				PRODUCT_NAME = gtest_main;
+				SDKROOT = macosx;
+			};
+			name = Release;
+		};
+		40C84985101A36850083642A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				HEADER_SEARCH_PATHS = ../;
+				PRODUCT_NAME = gtest_unittest;
+				SDKROOT = macosx;
+			};
+			name = Debug;
+		};
+		40C84986101A36850083642A /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				HEADER_SEARCH_PATHS = ../;
+				PRODUCT_NAME = gtest_unittest;
+				SDKROOT = macosx;
+			};
+			name = Release;
+		};
+		40C84995101A36A60083642A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				PRODUCT_NAME = "sample1_unittest-static";
+				SDKROOT = macosx;
+			};
+			name = Debug;
+		};
+		40C84996101A36A60083642A /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				PRODUCT_NAME = "sample1_unittest-static";
+				SDKROOT = macosx;
+			};
+			name = Release;
+		};
+		4FADC24308B4156D00ABE55E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */;
+			buildSettings = {
+				COMBINE_HIDPI_IMAGES = YES;
+				DYLIB_COMPATIBILITY_VERSION = 1;
+				DYLIB_CURRENT_VERSION = 1;
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				HEADER_SEARCH_PATHS = (
+					../,
+					../include/,
+				);
+				INFOPLIST_FILE = Resources/Info.plist;
+				INFOPLIST_PREFIX_HEADER = "$(PROJECT_TEMP_DIR)/Version.h";
+				INFOPLIST_PREPROCESS = YES;
+				PRODUCT_NAME = gtest;
+				SDKROOT = macosx;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Debug;
+		};
+		4FADC24408B4156D00ABE55E /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */;
+			buildSettings = {
+				COMBINE_HIDPI_IMAGES = YES;
+				DYLIB_COMPATIBILITY_VERSION = 1;
+				DYLIB_CURRENT_VERSION = 1;
+				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				HEADER_SEARCH_PATHS = (
+					../,
+					../include/,
+				);
+				INFOPLIST_FILE = Resources/Info.plist;
+				INFOPLIST_PREFIX_HEADER = "$(PROJECT_TEMP_DIR)/Version.h";
+				INFOPLIST_PREPROCESS = YES;
+				PRODUCT_NAME = gtest;
+				SDKROOT = macosx;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Release;
+		};
+		4FADC24708B4156D00ABE55E /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40D4CDF10E30E07400294801 /* DebugProject.xcconfig */;
+			buildSettings = {
+			};
+			name = Debug;
+		};
+		4FADC24808B4156D00ABE55E /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */;
+			buildSettings = {
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		3B238FA30E828BB600846E11 /* Build configuration list for PBXAggregateTarget "Check" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				3B238F600E828B5400846E11 /* Debug */,
+				3B238F610E828B5400846E11 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		40899F4A0FFA71BC000B29AE /* Build configuration list for PBXNativeTarget "gtest_unittest-framework" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				40899F450FFA7185000B29AE /* Debug */,
+				40899F460FFA7185000B29AE /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4089A0240FFACF01000B29AE /* Build configuration list for PBXNativeTarget "sample1_unittest-framework" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4089A0150FFACEFD000B29AE /* Debug */,
+				4089A0160FFACEFD000B29AE /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		40C44AE40E379905008FCC51 /* Build configuration list for PBXAggregateTarget "Version Info" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				40C44ADF0E3798F4008FCC51 /* Debug */,
+				40C44AE00E3798F4008FCC51 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		40C84902101A212E0083642A /* Build configuration list for PBXNativeTarget "gtest-static" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				40C848FB101A209D0083642A /* Debug */,
+				40C848FC101A209D0083642A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		40C84912101A21D20083642A /* Build configuration list for PBXNativeTarget "gtest_main-static" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				40C8490E101A217F0083642A /* Debug */,
+				40C8490F101A217F0083642A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		40C84984101A36850083642A /* Build configuration list for PBXNativeTarget "gtest_unittest-static" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				40C84985101A36850083642A /* Debug */,
+				40C84986101A36850083642A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		40C84994101A36A60083642A /* Build configuration list for PBXNativeTarget "sample1_unittest-static" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				40C84995101A36A60083642A /* Debug */,
+				40C84996101A36A60083642A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "gtest-framework" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4FADC24308B4156D00ABE55E /* Debug */,
+				4FADC24408B4156D00ABE55E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "gtest" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4FADC24708B4156D00ABE55E /* Debug */,
+				4FADC24808B4156D00ABE55E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 0867D690FE84028FC02AAC07 /* Project object */;
+}
diff --git a/week4/softwareEng_9_4/vendor/googletest/travis.sh b/week4/softwareEng_9_4/vendor/googletest/travis.sh
new file mode 100755
index 00000000..bdecbd96
--- /dev/null
+++ b/week4/softwareEng_9_4/vendor/googletest/travis.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env sh
+set -evx
+env | sort
+
+mkdir build || true
+mkdir build/$GTEST_TARGET || true
+cd build/$GTEST_TARGET
+cmake -Dgtest_build_samples=ON \
+      -Dgmock_build_samples=ON \
+      -Dgtest_build_tests=ON \
+      -Dgmock_build_tests=ON \
+      -DCMAKE_CXX_FLAGS=$CXX_FLAGS \
+      ../../$GTEST_TARGET
+make
+CTEST_OUTPUT_ON_FAILURE=1 make test

From 3cda1d172e27cfb9094abb3d3ac361cbec2576d5 Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Sat, 25 Sep 2021 23:57:12 -0400
Subject: [PATCH 08/15] deleting vendor files in week4

---
 readme.md                                     |  111 +-
 softwareEng_9_4/app/CMakeLists.txt            |    4 -
 softwareEng_9_4/app/main.cpp                  |    8 -
 softwareEng_9_4/app/softwareEng_9_4.cpp       |   38 -
 softwareEng_9_4/include/softwareEng_9_4.hpp   |   35 -
 .../vendor/googletest/.gitignore              |    2 -
 .../vendor/googletest/.travis.yml             |   46 -
 .../vendor/googletest/CMakeLists.txt          |   16 -
 .../vendor/googletest/README.md               |  142 -
 .../vendor/googletest/appveyor.yml            |   71 -
 .../vendor/googletest/googlemock/CHANGES      |  126 -
 .../googletest/googlemock/CMakeLists.txt      |  202 -
 .../vendor/googletest/googlemock/CONTRIBUTORS |   40 -
 .../vendor/googletest/googlemock/LICENSE      |   28 -
 .../vendor/googletest/googlemock/Makefile.am  |  224 -
 .../vendor/googletest/googlemock/README.md    |  333 -
 .../googletest/googlemock/build-aux/.keep     |    0
 .../vendor/googletest/googlemock/configure.ac |  146 -
 .../googletest/googlemock/docs/CheatSheet.md  |  562 --
 .../googletest/googlemock/docs/CookBook.md    | 3675 --------
 .../googletest/googlemock/docs/DesignDoc.md   |  280 -
 .../googletest/googlemock/docs/DevGuide.md    |  132 -
 .../googlemock/docs/Documentation.md          |   12 -
 .../googletest/googlemock/docs/ForDummies.md  |  439 -
 .../docs/FrequentlyAskedQuestions.md          |  628 --
 .../googletest/googlemock/docs/KnownIssues.md |   19 -
 .../googlemock/docs/v1_5/CheatSheet.md        |  525 --
 .../googlemock/docs/v1_5/CookBook.md          | 3250 -------
 .../googlemock/docs/v1_5/Documentation.md     |   11 -
 .../googlemock/docs/v1_5/ForDummies.md        |  439 -
 .../docs/v1_5/FrequentlyAskedQuestions.md     |  624 --
 .../googlemock/docs/v1_6/CheatSheet.md        |  534 --
 .../googlemock/docs/v1_6/CookBook.md          | 3342 -------
 .../googlemock/docs/v1_6/Documentation.md     |   12 -
 .../googlemock/docs/v1_6/ForDummies.md        |  439 -
 .../docs/v1_6/FrequentlyAskedQuestions.md     |  628 --
 .../googlemock/docs/v1_7/CheatSheet.md        |  556 --
 .../googlemock/docs/v1_7/CookBook.md          | 3432 --------
 .../googlemock/docs/v1_7/Documentation.md     |   12 -
 .../googlemock/docs/v1_7/ForDummies.md        |  439 -
 .../docs/v1_7/FrequentlyAskedQuestions.md     |  628 --
 .../googlemock/include/gmock/gmock-actions.h  | 1205 ---
 .../include/gmock/gmock-cardinalities.h       |  147 -
 .../include/gmock/gmock-generated-actions.h   | 2377 -----
 .../gmock/gmock-generated-actions.h.pump      |  794 --
 .../gmock/gmock-generated-function-mockers.h  | 1095 ---
 .../gmock-generated-function-mockers.h.pump   |  291 -
 .../include/gmock/gmock-generated-matchers.h  | 2179 -----
 .../gmock/gmock-generated-matchers.h.pump     |  672 --
 .../gmock/gmock-generated-nice-strict.h       |  397 -
 .../gmock/gmock-generated-nice-strict.h.pump  |  161 -
 .../googlemock/include/gmock/gmock-matchers.h | 4399 ----------
 .../include/gmock/gmock-more-actions.h        |  246 -
 .../include/gmock/gmock-more-matchers.h       |   58 -
 .../include/gmock/gmock-spec-builders.h       | 1847 ----
 .../googlemock/include/gmock/gmock.h          |   94 -
 .../internal/custom/gmock-generated-actions.h |    8 -
 .../custom/gmock-generated-actions.h.pump     |   10 -
 .../gmock/internal/custom/gmock-matchers.h    |   39 -
 .../gmock/internal/custom/gmock-port.h        |   46 -
 .../internal/gmock-generated-internal-utils.h |  279 -
 .../gmock-generated-internal-utils.h.pump     |  136 -
 .../gmock/internal/gmock-internal-utils.h     |  511 --
 .../include/gmock/internal/gmock-port.h       |   91 -
 .../googletest/googlemock/make/Makefile       |  101 -
 .../googletest/googlemock/msvc/2005/gmock.sln |   32 -
 .../googlemock/msvc/2005/gmock.vcproj         |  191 -
 .../googlemock/msvc/2005/gmock_config.vsprops |   15 -
 .../googlemock/msvc/2005/gmock_main.vcproj    |  187 -
 .../googlemock/msvc/2005/gmock_test.vcproj    |  201 -
 .../googletest/googlemock/msvc/2010/gmock.sln |   32 -
 .../googlemock/msvc/2010/gmock.vcxproj        |   82 -
 .../googlemock/msvc/2010/gmock_config.props   |   19 -
 .../googlemock/msvc/2010/gmock_main.vcxproj   |   88 -
 .../googlemock/msvc/2010/gmock_test.vcxproj   |  101 -
 .../googletest/googlemock/msvc/2015/gmock.sln |   32 -
 .../googlemock/msvc/2015/gmock.vcxproj        |   84 -
 .../googlemock/msvc/2015/gmock_config.props   |   19 -
 .../googlemock/msvc/2015/gmock_main.vcxproj   |   90 -
 .../googlemock/msvc/2015/gmock_test.vcxproj   |  103 -
 .../googlemock/scripts/fuse_gmock_files.py    |  240 -
 .../googlemock/scripts/generator/LICENSE      |  203 -
 .../googlemock/scripts/generator/README       |   35 -
 .../scripts/generator/README.cppclean         |  115 -
 .../scripts/generator/cpp/__init__.py         |    0
 .../googlemock/scripts/generator/cpp/ast.py   | 1733 ----
 .../scripts/generator/cpp/gmock_class.py      |  227 -
 .../scripts/generator/cpp/gmock_class_test.py |  448 -
 .../scripts/generator/cpp/keywords.py         |   59 -
 .../scripts/generator/cpp/tokenize.py         |  287 -
 .../googlemock/scripts/generator/cpp/utils.py |   41 -
 .../googlemock/scripts/generator/gmock_gen.py |   31 -
 .../googlemock/scripts/gmock-config.in        |  303 -
 .../googlemock/scripts/gmock_doctor.py        |  640 --
 .../googletest/googlemock/scripts/upload.py   | 1387 ---
 .../googlemock/scripts/upload_gmock.py        |   78 -
 .../googletest/googlemock/src/gmock-all.cc    |   47 -
 .../googlemock/src/gmock-cardinalities.cc     |  156 -
 .../googlemock/src/gmock-internal-utils.cc    |  174 -
 .../googlemock/src/gmock-matchers.cc          |  498 --
 .../googlemock/src/gmock-spec-builders.cc     |  823 --
 .../vendor/googletest/googlemock/src/gmock.cc |  183 -
 .../googletest/googlemock/src/gmock_main.cc   |   54 -
 .../googlemock/test/gmock-actions_test.cc     | 1411 ---
 .../test/gmock-cardinalities_test.cc          |  428 -
 .../test/gmock-generated-actions_test.cc      | 1228 ---
 .../gmock-generated-function-mockers_test.cc  |  622 --
 .../gmock-generated-internal-utils_test.cc    |  127 -
 .../test/gmock-generated-matchers_test.cc     | 1286 ---
 .../test/gmock-internal-utils_test.cc         |  699 --
 .../googlemock/test/gmock-matchers_test.cc    | 5652 ------------
 .../test/gmock-more-actions_test.cc           |  708 --
 .../googlemock/test/gmock-nice-strict_test.cc |  424 -
 .../googlemock/test/gmock-port_test.cc        |   43 -
 .../test/gmock-spec-builders_test.cc          | 2644 ------
 .../googlemock/test/gmock_all_test.cc         |   51 -
 .../googlemock/test/gmock_ex_test.cc          |   81 -
 .../googlemock/test/gmock_leak_test.py        |  108 -
 .../googlemock/test/gmock_leak_test_.cc       |  100 -
 .../googlemock/test/gmock_link2_test.cc       |   40 -
 .../googlemock/test/gmock_link_test.cc        |   40 -
 .../googlemock/test/gmock_link_test.h         |  669 --
 .../googlemock/test/gmock_output_test.py      |  180 -
 .../googlemock/test/gmock_output_test_.cc     |  291 -
 .../test/gmock_output_test_golden.txt         |  310 -
 .../googlemock/test/gmock_stress_test.cc      |  322 -
 .../googletest/googlemock/test/gmock_test.cc  |  220 -
 .../googlemock/test/gmock_test_utils.py       |  112 -
 .../vendor/googletest/googletest/.gitignore   |    2 -
 .../vendor/googletest/googletest/CHANGES      |  157 -
 .../googletest/googletest/CMakeLists.txt      |  286 -
 .../vendor/googletest/googletest/CONTRIBUTORS |   37 -
 .../vendor/googletest/googletest/LICENSE      |   28 -
 .../vendor/googletest/googletest/Makefile.am  |  310 -
 .../vendor/googletest/googletest/README.md    |  280 -
 .../googletest/googletest/build-aux/.keep     |    0
 .../googletest/cmake/internal_utils.cmake     |  256 -
 .../googletest/codegear/gtest.cbproj          |  138 -
 .../googletest/codegear/gtest.groupproj       |   54 -
 .../googletest/codegear/gtest_all.cc          |   38 -
 .../googletest/codegear/gtest_link.cc         |   40 -
 .../googletest/codegear/gtest_main.cbproj     |   82 -
 .../googletest/codegear/gtest_unittest.cbproj |   88 -
 .../vendor/googletest/googletest/configure.ac |   68 -
 .../googletest/docs/AdvancedGuide.md          | 2182 -----
 .../googletest/googletest/docs/DevGuide.md    |  126 -
 .../googletest/docs/Documentation.md          |   14 -
 .../vendor/googletest/googletest/docs/FAQ.md  | 1087 ---
 .../googletest/googletest/docs/Primer.md      |  502 --
 .../googletest/googletest/docs/PumpManual.md  |  177 -
 .../googletest/googletest/docs/Samples.md     |   14 -
 .../googletest/docs/V1_5_AdvancedGuide.md     | 2096 -----
 .../googletest/docs/V1_5_Documentation.md     |   12 -
 .../googletest/googletest/docs/V1_5_FAQ.md    |  886 --
 .../googletest/googletest/docs/V1_5_Primer.md |  497 --
 .../googletest/docs/V1_5_PumpManual.md        |  177 -
 .../googletest/docs/V1_5_XcodeGuide.md        |   93 -
 .../googletest/docs/V1_6_AdvancedGuide.md     | 2178 -----
 .../googletest/docs/V1_6_Documentation.md     |   14 -
 .../googletest/googletest/docs/V1_6_FAQ.md    | 1038 ---
 .../googletest/googletest/docs/V1_6_Primer.md |  501 --
 .../googletest/docs/V1_6_PumpManual.md        |  177 -
 .../googletest/docs/V1_6_Samples.md           |   14 -
 .../googletest/docs/V1_6_XcodeGuide.md        |   93 -
 .../googletest/docs/V1_7_AdvancedGuide.md     | 2181 -----
 .../googletest/docs/V1_7_Documentation.md     |   14 -
 .../googletest/googletest/docs/V1_7_FAQ.md    | 1082 ---
 .../googletest/googletest/docs/V1_7_Primer.md |  501 --
 .../googletest/docs/V1_7_PumpManual.md        |  177 -
 .../googletest/docs/V1_7_Samples.md           |   14 -
 .../googletest/docs/V1_7_XcodeGuide.md        |   93 -
 .../googletest/googletest/docs/XcodeGuide.md  |   93 -
 .../include/gtest/gtest-death-test.h          |  294 -
 .../googletest/include/gtest/gtest-message.h  |  250 -
 .../include/gtest/gtest-param-test.h          | 1444 ---
 .../include/gtest/gtest-param-test.h.pump     |  510 --
 .../googletest/include/gtest/gtest-printers.h |  993 ---
 .../googletest/include/gtest/gtest-spi.h      |  232 -
 .../include/gtest/gtest-test-part.h           |  179 -
 .../include/gtest/gtest-typed-test.h          |  263 -
 .../googletest/include/gtest/gtest.h          | 2236 -----
 .../include/gtest/gtest_pred_impl.h           |  358 -
 .../googletest/include/gtest/gtest_prod.h     |   58 -
 .../gtest/internal/custom/gtest-port.h        |   69 -
 .../gtest/internal/custom/gtest-printers.h    |   42 -
 .../include/gtest/internal/custom/gtest.h     |   41 -
 .../internal/gtest-death-test-internal.h      |  319 -
 .../include/gtest/internal/gtest-filepath.h   |  206 -
 .../include/gtest/internal/gtest-internal.h   | 1238 ---
 .../include/gtest/internal/gtest-linked_ptr.h |  243 -
 .../internal/gtest-param-util-generated.h     | 5146 -----------
 .../gtest-param-util-generated.h.pump         |  286 -
 .../include/gtest/internal/gtest-param-util.h |  731 --
 .../include/gtest/internal/gtest-port-arch.h  |   93 -
 .../include/gtest/internal/gtest-port.h       | 2560 ------
 .../include/gtest/internal/gtest-string.h     |  167 -
 .../include/gtest/internal/gtest-tuple.h      | 1020 ---
 .../include/gtest/internal/gtest-tuple.h.pump |  347 -
 .../include/gtest/internal/gtest-type-util.h  | 3331 -------
 .../gtest/internal/gtest-type-util.h.pump     |  297 -
 .../googletest/googletest/m4/acx_pthread.m4   |  363 -
 .../vendor/googletest/googletest/m4/gtest.m4  |   74 -
 .../googletest/googletest/make/Makefile       |   82 -
 .../googletest/googletest/msvc/gtest-md.sln   |   45 -
 .../googletest/msvc/gtest-md.vcproj           |  126 -
 .../googletest/googletest/msvc/gtest.sln      |   45 -
 .../googletest/googletest/msvc/gtest.vcproj   |  126 -
 .../googletest/msvc/gtest_main-md.vcproj      |  129 -
 .../googletest/msvc/gtest_main.vcproj         |  129 -
 .../googletest/msvc/gtest_prod_test-md.vcproj |  164 -
 .../googletest/msvc/gtest_prod_test.vcproj    |  164 -
 .../googletest/msvc/gtest_unittest-md.vcproj  |  147 -
 .../googletest/msvc/gtest_unittest.vcproj     |  147 -
 .../googletest/samples/prime_tables.h         |  123 -
 .../googletest/googletest/samples/sample1.cc  |   68 -
 .../googletest/googletest/samples/sample1.h   |   43 -
 .../googletest/samples/sample10_unittest.cc   |  144 -
 .../googletest/samples/sample1_unittest.cc    |  153 -
 .../googletest/googletest/samples/sample2.cc  |   56 -
 .../googletest/googletest/samples/sample2.h   |   85 -
 .../googletest/samples/sample2_unittest.cc    |  109 -
 .../googletest/samples/sample3-inl.h          |  172 -
 .../googletest/samples/sample3_unittest.cc    |  151 -
 .../googletest/googletest/samples/sample4.cc  |   46 -
 .../googletest/googletest/samples/sample4.h   |   53 -
 .../googletest/samples/sample4_unittest.cc    |   45 -
 .../googletest/samples/sample5_unittest.cc    |  199 -
 .../googletest/samples/sample6_unittest.cc    |  224 -
 .../googletest/samples/sample7_unittest.cc    |  130 -
 .../googletest/samples/sample8_unittest.cc    |  173 -
 .../googletest/samples/sample9_unittest.cc    |  160 -
 .../googletest/googletest/scripts/common.py   |   83 -
 .../googletest/scripts/fuse_gtest_files.py    |  253 -
 .../googletest/scripts/gen_gtest_pred_impl.py |  730 --
 .../googletest/scripts/gtest-config.in        |  274 -
 .../googletest/googletest/scripts/pump.py     |  855 --
 .../googletest/scripts/release_docs.py        |  158 -
 .../googletest/scripts/test/Makefile          |   59 -
 .../googletest/googletest/scripts/upload.py   | 1387 ---
 .../googletest/scripts/upload_gtest.py        |   78 -
 .../googletest/googletest/src/gtest-all.cc    |   48 -
 .../googletest/src/gtest-death-test.cc        | 1342 ---
 .../googletest/src/gtest-filepath.cc          |  387 -
 .../googletest/src/gtest-internal-inl.h       | 1183 ---
 .../googletest/googletest/src/gtest-port.cc   | 1259 ---
 .../googletest/src/gtest-printers.cc          |  373 -
 .../googletest/src/gtest-test-part.cc         |  110 -
 .../googletest/src/gtest-typed-test.cc        |  118 -
 .../vendor/googletest/googletest/src/gtest.cc | 5388 ------------
 .../googletest/googletest/src/gtest_main.cc   |   38 -
 .../test/gtest-death-test_ex_test.cc          |   93 -
 .../googletest/test/gtest-death-test_test.cc  | 1427 ---
 .../googletest/test/gtest-filepath_test.cc    |  662 --
 .../googletest/test/gtest-linked_ptr_test.cc  |  154 -
 .../googletest/test/gtest-listener_test.cc    |  311 -
 .../googletest/test/gtest-message_test.cc     |  159 -
 .../googletest/test/gtest-options_test.cc     |  215 -
 .../googletest/test/gtest-param-test2_test.cc |   65 -
 .../googletest/test/gtest-param-test_test.cc  | 1055 ---
 .../googletest/test/gtest-param-test_test.h   |   57 -
 .../googletest/test/gtest-port_test.cc        | 1311 ---
 .../googletest/test/gtest-printers_test.cc    | 1635 ----
 .../googletest/test/gtest-test-part_test.cc   |  208 -
 .../googletest/test/gtest-tuple_test.cc       |  320 -
 .../googletest/test/gtest-typed-test2_test.cc |   45 -
 .../googletest/test/gtest-typed-test_test.cc  |  380 -
 .../googletest/test/gtest-typed-test_test.h   |   66 -
 .../test/gtest-unittest-api_test.cc           |  341 -
 .../googletest/test/gtest_all_test.cc         |   47 -
 .../test/gtest_break_on_failure_unittest.py   |  212 -
 .../test/gtest_break_on_failure_unittest_.cc  |   88 -
 .../test/gtest_catch_exceptions_test.py       |  237 -
 .../test/gtest_catch_exceptions_test_.cc      |  311 -
 .../googletest/test/gtest_color_test.py       |  130 -
 .../googletest/test/gtest_color_test_.cc      |   71 -
 .../googletest/test/gtest_env_var_test.py     |  117 -
 .../googletest/test/gtest_env_var_test_.cc    |  126 -
 .../googletest/test/gtest_environment_test.cc |  192 -
 .../googletest/test/gtest_filter_unittest.py  |  636 --
 .../googletest/test/gtest_filter_unittest_.cc |  140 -
 .../googletest/test/gtest_help_test.py        |  172 -
 .../googletest/test/gtest_help_test_.cc       |   46 -
 .../test/gtest_list_tests_unittest.py         |  207 -
 .../test/gtest_list_tests_unittest_.cc        |  157 -
 .../googletest/test/gtest_main_unittest.cc    |   45 -
 .../googletest/test/gtest_no_test_unittest.cc |   56 -
 .../googletest/test/gtest_output_test.py      |  340 -
 .../googletest/test/gtest_output_test_.cc     | 1062 ---
 .../test/gtest_output_test_golden_lin.txt     |  743 --
 .../test/gtest_pred_impl_unittest.cc          | 2427 ------
 .../test/gtest_premature_exit_test.cc         |  127 -
 .../googletest/test/gtest_prod_test.cc        |   57 -
 .../googletest/test/gtest_repeat_test.cc      |  253 -
 .../googletest/test/gtest_shuffle_test.py     |  325 -
 .../googletest/test/gtest_shuffle_test_.cc    |  103 -
 .../googletest/test/gtest_sole_header_test.cc |   57 -
 .../googletest/test/gtest_stress_test.cc      |  256 -
 .../googletest/test/gtest_test_utils.py       |  320 -
 .../test/gtest_throw_on_failure_ex_test.cc    |   92 -
 .../test/gtest_throw_on_failure_test.py       |  171 -
 .../test/gtest_throw_on_failure_test_.cc      |   72 -
 .../test/gtest_uninitialized_test.py          |   70 -
 .../test/gtest_uninitialized_test_.cc         |   43 -
 .../googletest/test/gtest_unittest.cc         | 7706 -----------------
 .../test/gtest_xml_outfile1_test_.cc          |   49 -
 .../test/gtest_xml_outfile2_test_.cc          |   49 -
 .../test/gtest_xml_outfiles_test.py           |  132 -
 .../test/gtest_xml_output_unittest.py         |  308 -
 .../test/gtest_xml_output_unittest_.cc        |  181 -
 .../googletest/test/gtest_xml_test_utils.py   |  194 -
 .../googletest/googletest/test/production.cc  |   36 -
 .../googletest/googletest/test/production.h   |   55 -
 .../xcode/Config/DebugProject.xcconfig        |   30 -
 .../xcode/Config/FrameworkTarget.xcconfig     |   17 -
 .../googletest/xcode/Config/General.xcconfig  |   41 -
 .../xcode/Config/ReleaseProject.xcconfig      |   32 -
 .../xcode/Config/StaticLibraryTarget.xcconfig |   18 -
 .../xcode/Config/TestTarget.xcconfig          |    8 -
 .../googletest/xcode/Resources/Info.plist     |   30 -
 .../xcode/Samples/FrameworkSample/Info.plist  |   28 -
 .../WidgetFramework.xcodeproj/project.pbxproj |  457 -
 .../xcode/Samples/FrameworkSample/runtests.sh |   62 -
 .../xcode/Samples/FrameworkSample/widget.cc   |   63 -
 .../xcode/Samples/FrameworkSample/widget.h    |   59 -
 .../Samples/FrameworkSample/widget_test.cc    |   68 -
 .../googletest/xcode/Scripts/runtests.sh      |   65 -
 .../xcode/Scripts/versiongenerate.py          |  100 -
 .../xcode/gtest.xcodeproj/project.pbxproj     | 1135 ---
 .../vendor/googletest/travis.sh               |   15 -
 329 files changed, 34 insertions(+), 153971 deletions(-)
 delete mode 100644 softwareEng_9_4/app/CMakeLists.txt
 delete mode 100644 softwareEng_9_4/app/main.cpp
 delete mode 100644 softwareEng_9_4/app/softwareEng_9_4.cpp
 delete mode 100644 softwareEng_9_4/include/softwareEng_9_4.hpp
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/.gitignore
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/.travis.yml
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/CMakeLists.txt
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/README.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/appveyor.yml
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/CHANGES
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/CMakeLists.txt
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/CONTRIBUTORS
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/LICENSE
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/Makefile.am
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/README.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/build-aux/.keep
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/configure.ac
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CheatSheet.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CookBook.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DesignDoc.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DevGuide.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/Documentation.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/ForDummies.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/FrequentlyAskedQuestions.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/KnownIssues.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CheatSheet.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CookBook.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/Documentation.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/ForDummies.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/FrequentlyAskedQuestions.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CheatSheet.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CookBook.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/Documentation.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/ForDummies.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/FrequentlyAskedQuestions.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CheatSheet.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CookBook.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/Documentation.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/ForDummies.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/FrequentlyAskedQuestions.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-actions.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-cardinalities.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h.pump
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.pump
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h.pump
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h.pump
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-matchers.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-actions.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-matchers.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-spec-builders.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-port.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h.pump
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-port.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/make/Makefile
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.sln
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.vcproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_config.vsprops
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_main.vcproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_test.vcproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.sln
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.vcxproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_config.props
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_main.vcxproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_test.vcxproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.sln
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.vcxproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_config.props
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_main.vcxproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_test.vcxproj
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/fuse_gmock_files.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/LICENSE
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README.cppclean
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/__init__.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/ast.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class_test.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/keywords.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/tokenize.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/utils.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/gmock_gen.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock-config.in
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock_doctor.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload_gmock.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-all.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-cardinalities.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-internal-utils.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-matchers.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-spec-builders.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock_main.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-actions_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-cardinalities_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-actions_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-function-mockers_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-internal-utils_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-matchers_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-internal-utils_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-matchers_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-more-actions_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-nice-strict_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-port_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-spec-builders_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_all_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_ex_test.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test_.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link2_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.h
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_golden.txt
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_stress_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test_utils.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/.gitignore
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/CHANGES
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/CMakeLists.txt
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/CONTRIBUTORS
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/LICENSE
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/Makefile.am
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/README.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/build-aux/.keep
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/cmake/internal_utils.cmake
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.cbproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.groupproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_all.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_link.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_main.cbproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_unittest.cbproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/configure.ac
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/AdvancedGuide.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/DevGuide.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/Documentation.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/FAQ.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/Primer.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/PumpManual.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/Samples.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_AdvancedGuide.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Documentation.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_FAQ.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Primer.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_PumpManual.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_XcodeGuide.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_AdvancedGuide.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Documentation.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_FAQ.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Primer.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_PumpManual.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Samples.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_XcodeGuide.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_AdvancedGuide.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Documentation.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_FAQ.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Primer.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_PumpManual.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Samples.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_XcodeGuide.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/docs/XcodeGuide.md
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-death-test.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-message.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h.pump
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-printers.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-spi.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-test-part.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-typed-test.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_pred_impl.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_prod.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-port.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-printers.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-filepath.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-internal.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-linked_ptr.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h.pump
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port-arch.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-string.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h.pump
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h.pump
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/m4/acx_pthread.m4
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/m4/gtest.m4
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/make/Makefile
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.sln
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.vcproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.sln
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.vcproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main-md.vcproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main.vcproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test-md.vcproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test.vcproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest-md.vcproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest.vcproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/prime_tables.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample10_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3-inl.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample5_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample6_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample7_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample8_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample9_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/common.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/fuse_gtest_files.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gen_gtest_pred_impl.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gtest-config.in
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/pump.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/release_docs.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/test/Makefile
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload_gtest.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-all.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-death-test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-filepath.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-internal-inl.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-port.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-printers.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-test-part.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-typed-test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest_main.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_ex_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-filepath_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-linked_ptr_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-listener_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-message_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-options_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test2_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-port_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-printers_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-test-part_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-tuple_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test2_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-unittest-api_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_all_test.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest_.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test_.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test_.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test_.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_environment_test.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest_.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test_.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest_.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_main_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_no_test_unittest.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_golden_lin.txt
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_pred_impl_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_premature_exit_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_prod_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_repeat_test.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test_.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_sole_header_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_stress_test.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_test_utils.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test_.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test_.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_unittest.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile1_test_.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile2_test_.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfiles_test.py
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest_.cc
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_test_utils.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/production.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/test/production.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/DebugProject.xcconfig
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/FrameworkTarget.xcconfig
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/General.xcconfig
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/ReleaseProject.xcconfig
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/StaticLibraryTarget.xcconfig
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/TestTarget.xcconfig
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Resources/Info.plist
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/Info.plist
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/runtests.sh
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.h
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget_test.cc
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/runtests.sh
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/versiongenerate.py
 delete mode 100644 week4/softwareEng_9_4/vendor/googletest/googletest/xcode/gtest.xcodeproj/project.pbxproj
 delete mode 100755 week4/softwareEng_9_4/vendor/googletest/travis.sh

diff --git a/readme.md b/readme.md
index aadd5b41..95d55d1f 100644
--- a/readme.md
+++ b/readme.md
@@ -2,98 +2,55 @@
 [![Build Status](https://travis-ci.org/dpiet/cpp-boilerplate.svg?branch=master)](https://travis-ci.org/dpiet/cpp-boilerplate)
 [![Coverage Status](https://coveralls.io/repos/github/dpiet/cpp-boilerplate/badge.svg?branch=master)](https://coveralls.io/github/dpiet/cpp-boilerplate?branch=master)
 ---
+## Week 4 Assignment
 
-## Overview
+Name: Sumedh Reddy Koppula
+UID: 117386066
 
-Simple starter C++ project with:
+In week4 directory please find invidual folder with programming assignment exercise names with UML diagram. On each folder please perform below executions in command-line to get the ouput.
+1. mkdir build
+2. cd build
+3. cmake ..
+4. make
+5. cd app
+6. ./shell-app
 
-- cmake
-- googletest
+Please find the wrting assignment .pdf and output screenshots in the root folder.
 
-## Standard install via command-line
-```
-git clone --recursive https://github.com/dpiet/cpp-boilerplate
-cd <path to repository>
-mkdir build
-cd build
-cmake ..
-make
-Run tests: ./test/cpp-test
-Run program: ./app/shell-app
-```
+## Sample Outputs for week4
 
-## Building for code coverage (for assignments beginning in Week 4)
-```
-sudo apt-get install lcov
-cmake -D COVERAGE=ON -D CMAKE_BUILD_TYPE=Debug ../
-make
-make code_coverage
-```
-This generates a index.html page in the build/coverage sub-directory that can be viewed locally in a web browser.
 
-## Working with Eclipse IDE ##
+## Week 3 Assignment
 
-## Installation
+Name: Sumedh Reddy Koppula
+UID: 117386066
 
-In your Eclipse workspace directory (or create a new one), checkout the repo (and submodules)
-```
-mkdir -p ~/workspace
-cd ~/workspace
-git clone --recursive https://github.com/dpiet/cpp-boilerplate
-```
+In week3 directory please find invidual folders with programming assignment exercise names with UML diagram. On each folder please perform below executions in command-line to get the ouput.
+1. mkdir build
+2. cd build
+3. cmake ..
+4. make
+5. cd app
+6. ./shell-app
 
-In your work directory, use cmake to create an Eclipse project for an [out-of-source build] of cpp-boilerplate
+Please find the wrting assignment .pdf and output screenshots in the root folder.
 
-```
-cd ~/workspace
-mkdir -p boilerplate-eclipse
-cd boilerplate-eclipse
-cmake -G "Eclipse CDT4 - Unix Makefiles" -D CMAKE_BUILD_TYPE=Debug -D CMAKE_ECLIPSE_VERSION=4.7.0 -D CMAKE_CXX_COMPILER_ARG1=-std=c++14 ../cpp-boilerplate/
-```
+## Sample Outputs for week3
 
-## Import
+**3_5_output:**
+<img width="1440" alt="3_5_output" src="https://user-images.githubusercontent.com/24978535/134241123-d9610cf4-2ae0-4322-820f-425c45c30bf8.png">
 
-Open Eclipse, go to File -> Import -> General -> Existing Projects into Workspace -> 
-Select "boilerplate-eclipse" directory created previously as root directory -> Finish
+**3_10_output**
+<img width="1440" alt="3_10_output" src="https://user-images.githubusercontent.com/24978535/134241137-175cd18d-fc65-4356-8da8-1db0e48745f6.png">
 
-# Edit
+**4_5_output**
+<img width="1440" alt="4_5_output" src="https://user-images.githubusercontent.com/24978535/134241148-fc224652-9a5d-4677-ba38-72c8c49edf82.png">
 
-Source files may be edited under the "[Source Directory]" label in the Project Explorer.
+**4_7_output**
+<img width="1440" alt="4_7_output" src="https://user-images.githubusercontent.com/24978535/134241159-7d6bbba5-0372-4a08-9d61-3b99a946ac17.png">
 
-
-## Build
-
-To build the project, in Eclipse, unfold boilerplate-eclipse project in Project Explorer,
-unfold Build Targets, double click on "all" to build all projects.
-
-## Run
-
-1. In Eclipse, right click on the boilerplate-eclipse in Project Explorer,
-select Run As -> Local C/C++ Application
-
-2. Choose the binaries to run (e.g. shell-app, cpp-test for unit testing)
-
-
-## Debug
-
-
-1. Set breakpoint in source file (i.e. double click in the left margin on the line you want 
-the program to break).
-
-2. In Eclipse, right click on the boilerplate-eclipse in Project Explorer, select Debug As -> 
-Local C/C++ Application, choose the binaries to run (e.g. shell-app).
-
-3. If prompt to "Confirm Perspective Switch", select yes.
-
-4. Program will break at the breakpoint you set.
-
-5. Press Step Into (F5), Step Over (F6), Step Return (F7) to step/debug your program.
-
-6. Right click on the variable in editor to add watch expression to watch the variable in 
-debugger window.
-
-7. Press Terminate icon to terminate debugging and press C/C++ icon to switch back to C/C++ 
-perspetive view (or Windows->Perspective->Open Perspective->C/C++).
+**6_9_output**
+<img width="1440" alt="6_9_output" src="https://user-images.githubusercontent.com/24978535/134241172-0b6f06dd-5258-424f-a2dc-46b1d90b581b.png">
 
 
 ## Plugins
diff --git a/softwareEng_9_4/app/CMakeLists.txt b/softwareEng_9_4/app/CMakeLists.txt
deleted file mode 100644
index 6b16684e..00000000
--- a/softwareEng_9_4/app/CMakeLists.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-add_executable(shell-app softwareEng_9_4.cpp)
-include_directories(
-    ${CMAKE_SOURCE_DIR}/include
-)
diff --git a/softwareEng_9_4/app/main.cpp b/softwareEng_9_4/app/main.cpp
deleted file mode 100644
index 74232ade..00000000
--- a/softwareEng_9_4/app/main.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <iostream>
-#include <lib.hpp>
-
-int main()
-{
-    dummy();
-    return 0;
-}
diff --git a/softwareEng_9_4/app/softwareEng_9_4.cpp b/softwareEng_9_4/app/softwareEng_9_4.cpp
deleted file mode 100644
index df7ea2e9..00000000
--- a/softwareEng_9_4/app/softwareEng_9_4.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- *  @copyright (c) 2021 Sumedh Reddy
- *  @file    softwareEngineering_9_4.cpp
- *  @author  SumedhReddy
- *
- *  @brief solution
- *
- */
-
-#include "softwareEng_9_4.hpp"
-
-/**
- * @brief initial function without extraction
- */
-void printer::printPosition() {
-int i, j;
-char text[1024] = "1234567890";
-int text_length = 10;
-char array_to_search1[4] = "23";
-int array_to_search1_length = 2;
-int position1 = -1;
-for (i = 0; i < text_length - array_to_search1_length + 1; i++) {
-  bool found = true;
-  for (j = 0; j < array_to_search1_length; j++)
-    if (text[i + j] != array_to_search1[j])
-      found = false;
-  if (found) {
-    position1 = i;
-    break;
-  }
-}
-std::cout<<position1;
-}
-
-int main() {
-    printer printObj;
-    printObj.printPosition();
-}
\ No newline at end of file
diff --git a/softwareEng_9_4/include/softwareEng_9_4.hpp b/softwareEng_9_4/include/softwareEng_9_4.hpp
deleted file mode 100644
index 0b425fd6..00000000
--- a/softwareEng_9_4/include/softwareEng_9_4.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/**
- *  @copyright (c) 2021 Sumedh Reddy Koppula
- *  @file    SoftwareEngineering9-4.hpp
- *  @author  SumedhReddy 
- *
- *  @brief Header
- *
- */
-
-#pragma once
-
-#include <iostream>
-
-#include <string>
-
-#include <vector>
-
-#include <numeric>
-
-/**
- * @brief 
- * printer is a class to extract a new method from printposition, 
- * The motivation behind solving this problem
- * is to implement method extraction for code refractory
- */
-class printer {
- public:
-    void inputs();
-    void printPosition();
-    printer();
-}; 
-
- printer::printer(void){
-
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/.gitignore b/week4/softwareEng_9_4/vendor/googletest/.gitignore
deleted file mode 100644
index ce310bc3..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-# Ignore CI build directory
-build/
diff --git a/week4/softwareEng_9_4/vendor/googletest/.travis.yml b/week4/softwareEng_9_4/vendor/googletest/.travis.yml
deleted file mode 100644
index 3204dfac..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/.travis.yml
+++ /dev/null
@@ -1,46 +0,0 @@
-# Build matrix / environment variable are explained on:
-# http://about.travis-ci.org/docs/user/build-configuration/
-# This file can be validated on:
-# http://lint.travis-ci.org/
-
-install:
-# /usr/bin/gcc is 4.6 always, but gcc-X.Y is available.
-- if [ "$CXX" = "g++" ]; then export CXX="g++-4.9" CC="gcc-4.9"; fi
-# /usr/bin/clang is 3.4, lets override with modern one.
-- if [ "$CXX" = "clang++" ] && [ "$TRAVIS_OS_NAME" = "linux" ]; then export CXX="clang++-3.7" CC="clang-3.7"; fi
-- echo ${PATH}
-- echo ${CXX}
-- ${CXX} --version
-- ${CXX} -v
-addons:
-  apt:
-    # List of whitelisted in travis packages for ubuntu-precise can be found here:
-    #   https://github.com/travis-ci/apt-package-whitelist/blob/master/ubuntu-precise
-    # List of whitelisted in travis apt-sources:
-    #   https://github.com/travis-ci/apt-source-whitelist/blob/master/ubuntu.json
-    sources:
-    - ubuntu-toolchain-r-test
-    - llvm-toolchain-precise-3.7
-    packages:
-    - gcc-4.9
-    - g++-4.9
-    - clang-3.7
-    - valgrind
-os:
-  - linux
-  - osx
-language: cpp
-compiler:
-  - gcc
-  - clang
-script: ./travis.sh
-env:
-  matrix:
-    - GTEST_TARGET=googletest SHARED_LIB=OFF STATIC_LIB=ON CMAKE_PKG=OFF BUILD_TYPE=debug   VERBOSE_MAKE=true VERBOSE
-    - GTEST_TARGET=googlemock SHARED_LIB=OFF STATIC_LIB=ON CMAKE_PKG=OFF BUILD_TYPE=debug   VERBOSE_MAKE=true VERBOSE
-    - GTEST_TARGET=googlemock SHARED_LIB=OFF STATIC_LIB=ON CMAKE_PKG=OFF BUILD_TYPE=debug CXX_FLAGS=-std=c++11  VERBOSE_MAKE=true VERBOSE
-#    - GTEST_TARGET=googletest SHARED_LIB=ON  STATIC_LIB=ON CMAKE_PKG=ON  BUILD_TYPE=release VERBOSE_MAKE=false
-#    - GTEST_TARGET=googlemock SHARED_LIB=ON  STATIC_LIB=ON CMAKE_PKG=ON  BUILD_TYPE=release VERBOSE_MAKE=false
-notifications:
-  email: false
-sudo: false
diff --git a/week4/softwareEng_9_4/vendor/googletest/CMakeLists.txt b/week4/softwareEng_9_4/vendor/googletest/CMakeLists.txt
deleted file mode 100644
index 8d2b552e..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-cmake_minimum_required(VERSION 2.6.2)
-
-project( googletest-distribution )
-
-enable_testing()
-
-option(BUILD_GTEST "Builds the googletest subproject" OFF)
-
-#Note that googlemock target already builds googletest
-option(BUILD_GMOCK "Builds the googlemock subproject" ON)
-
-if(BUILD_GMOCK)
-  add_subdirectory( googlemock )
-elseif(BUILD_GTEST)
-  add_subdirectory( googletest )
-endif()
diff --git a/week4/softwareEng_9_4/vendor/googletest/README.md b/week4/softwareEng_9_4/vendor/googletest/README.md
deleted file mode 100644
index 076484e4..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/README.md
+++ /dev/null
@@ -1,142 +0,0 @@
-
-# Google Test #
-
-[![Build Status](https://travis-ci.org/google/googletest.svg?branch=master)](https://travis-ci.org/google/googletest)
-[![Build status](https://ci.appveyor.com/api/projects/status/4o38plt0xbo1ubc8/branch/master?svg=true)](https://ci.appveyor.com/project/BillyDonahue/googletest/branch/master)
-
-Welcome to **Google Test**, Google's C++ test framework!
-
-This repository is a merger of the formerly separate GoogleTest and
-GoogleMock projects. These were so closely related that it makes sense to
-maintain and release them together.
-
-Please see the project page above for more information as well as the
-mailing list for questions, discussions, and development.  There is
-also an IRC channel on OFTC (irc.oftc.net) #gtest available.  Please
-join us!
-
-Getting started information for **Google Test** is available in the 
-[Google Test Primer](googletest/docs/Primer.md) documentation.
-
-**Google Mock** is an extension to Google Test for writing and using C++ mock
-classes.  See the separate [Google Mock documentation](googlemock/README.md).
-
-More detailed documentation for googletest (including build instructions) are
-in its interior [googletest/README.md](googletest/README.md) file.
-
-## Features ##
-
-  * An [XUnit](https://en.wikipedia.org/wiki/XUnit) test framework.
-  * Test discovery.
-  * A rich set of assertions.
-  * User-defined assertions.
-  * Death tests.
-  * Fatal and non-fatal failures.
-  * Value-parameterized tests.
-  * Type-parameterized tests.
-  * Various options for running the tests.
-  * XML test report generation.
-
-## Platforms ##
-
-Google test has been used on a variety of platforms:
-
-  * Linux
-  * Mac OS X
-  * Windows
-  * Cygwin
-  * MinGW
-  * Windows Mobile
-  * Symbian
-
-## Who Is Using Google Test? ##
-
-In addition to many internal projects at Google, Google Test is also used by
-the following notable projects:
-
-  * The [Chromium projects](http://www.chromium.org/) (behind the Chrome
-    browser and Chrome OS).
-  * The [LLVM](http://llvm.org/) compiler.
-  * [Protocol Buffers](https://github.com/google/protobuf), Google's data
-    interchange format.
-  * The [OpenCV](http://opencv.org/) computer vision library.
-
-## Related Open Source Projects ##
-
-[Google Test UI](https://github.com/ospector/gtest-gbar) is test runner that runs
-your test binary, allows you to track its progress via a progress bar, and
-displays a list of test failures. Clicking on one shows failure text. Google
-Test UI is written in C#.
-
-[GTest TAP Listener](https://github.com/kinow/gtest-tap-listener) is an event
-listener for Google Test that implements the
-[TAP protocol](https://en.wikipedia.org/wiki/Test_Anything_Protocol) for test
-result output. If your test runner understands TAP, you may find it useful.
-
-## Requirements ##
-
-Google Test is designed to have fairly minimal requirements to build
-and use with your projects, but there are some.  Currently, we support
-Linux, Windows, Mac OS X, and Cygwin.  We will also make our best
-effort to support other platforms (e.g. Solaris, AIX, and z/OS).
-However, since core members of the Google Test project have no access
-to these platforms, Google Test may have outstanding issues there.  If
-you notice any problems on your platform, please notify
-<googletestframework@googlegroups.com>. Patches for fixing them are
-even more welcome!
-
-### Linux Requirements ###
-
-These are the base requirements to build and use Google Test from a source
-package (as described below):
-
-  * GNU-compatible Make or gmake
-  * POSIX-standard shell
-  * POSIX(-2) Regular Expressions (regex.h)
-  * A C++98-standard-compliant compiler
-
-### Windows Requirements ###
-
-  * Microsoft Visual C++ v7.1 or newer
-
-### Cygwin Requirements ###
-
-  * Cygwin v1.5.25-14 or newer
-
-### Mac OS X Requirements ###
-
-  * Mac OS X v10.4 Tiger or newer
-  * Xcode Developer Tools
-
-### Requirements for Contributors ###
-
-We welcome patches.  If you plan to contribute a patch, you need to
-build Google Test and its own tests from a git checkout (described
-below), 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.6.4 or newer
-
-## Regenerating Source Files ##
-
-Some of Google Test's source files are generated from templates (not
-in the C++ sense) using a script.
-For example, the
-file include/gtest/internal/gtest-type-util.h.pump is used to generate
-gtest-type-util.h in the same directory.
-
-You don't need to worry about regenerating the source files
-unless you need to modify them.  You would then modify the
-corresponding `.pump` files and run the '[pump.py](googletest/scripts/pump.py)'
-generator script.  See the [Pump Manual](googletest/docs/PumpManual.md).
-
-### Contributing Code ###
-
-We welcome patches.  Please read the
-[Developer's Guide](googletest/docs/DevGuide.md)
-for how you can contribute. In particular, make sure you have signed
-the Contributor License Agreement, or we won't be able to accept the
-patch.
-
-Happy testing!
diff --git a/week4/softwareEng_9_4/vendor/googletest/appveyor.yml b/week4/softwareEng_9_4/vendor/googletest/appveyor.yml
deleted file mode 100644
index d613fd60..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/appveyor.yml
+++ /dev/null
@@ -1,71 +0,0 @@
-version: '{build}'
-
-os: Visual Studio 2015
-
-environment:
-  matrix:
-  - Toolset: v140
-  - Toolset: v120
-  - Toolset: v110
-  - Toolset: v100
-
-platform:
-  - Win32
-  - x64
-
-configuration:
-#  - Release
-  - Debug
-
-build:
-  verbosity: minimal
-
-artifacts:
-  - path: '_build/Testing/Temporary/*'
-    name: test_results
-
-before_build:
-- ps: |
-    Write-Output "Configuration: $env:CONFIGURATION"
-    Write-Output "Platform: $env:PLATFORM"
-    $generator = switch ($env:TOOLSET)
-    {
-        "v140" {"Visual Studio 14 2015"}
-        "v120" {"Visual Studio 12 2013"}
-        "v110" {"Visual Studio 11 2012"}
-        "v100" {"Visual Studio 10 2010"}
-    }
-    if ($env:PLATFORM -eq "x64")
-    {
-        $generator = "$generator Win64"
-    }
-
-build_script:
-- ps: |
-    if (($env:TOOLSET -eq "v100") -and ($env:PLATFORM -eq "x64"))
-    {
-        return
-    }
-    md _build -Force | Out-Null
-    cd _build
-
-    & cmake -G "$generator" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -Dgtest_build_tests=ON -Dgtest_build_samples=ON -Dgmock_build_tests=ON ..
-    if ($LastExitCode -ne 0) {
-        throw "Exec: $ErrorMessage"
-    }
-    & cmake --build . --config $env:CONFIGURATION
-    if ($LastExitCode -ne 0) {
-        throw "Exec: $ErrorMessage"
-    }
-
-test_script:
-- ps: |
-    if (($env:Toolset -eq "v100") -and ($env:PLATFORM -eq "x64"))
-    {
-        return
-    }
-
-    & ctest -C $env:CONFIGURATION --output-on-failure
-    if ($LastExitCode -ne 0) {
-        throw "Exec: $ErrorMessage"
-    }
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/CHANGES b/week4/softwareEng_9_4/vendor/googletest/googlemock/CHANGES
deleted file mode 100644
index d6f2f760..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/CHANGES
+++ /dev/null
@@ -1,126 +0,0 @@
-Changes for 1.7.0:
-
-* All new improvements in Google Test 1.7.0.
-* New feature: matchers DoubleNear(), FloatNear(),
-  NanSensitiveDoubleNear(), NanSensitiveFloatNear(),
-  UnorderedElementsAre(), UnorderedElementsAreArray(), WhenSorted(),
-  WhenSortedBy(), IsEmpty(), and SizeIs().
-* Improvement: Google Mock can now be built as a DLL.
-* Improvement: when compiled by a C++11 compiler, matchers AllOf()
-  and AnyOf() can accept an arbitrary number of matchers.
-* Improvement: when compiled by a C++11 compiler, matchers
-  ElementsAreArray() can accept an initializer list.
-* Improvement: when exceptions are enabled, a mock method with no
-  default action now throws instead crashing the test.
-* Improvement: added class testing::StringMatchResultListener to aid
-  definition of composite matchers.
-* Improvement: function return types used in MOCK_METHOD*() macros can
-  now contain unprotected commas.
-* Improvement (potentially breaking): EXPECT_THAT() and ASSERT_THAT()
-  are now more strict in ensuring that the value type and the matcher
-  type are compatible, catching potential bugs in tests.
-* Improvement: Pointee() now works on an optional<T>.
-* Improvement: the ElementsAreArray() matcher can now take a vector or
-  iterator range as input, and makes a copy of its input elements
-  before the conversion to a Matcher.
-* Improvement: the Google Mock Generator can now generate mocks for
-  some class templates.
-* Bug fix: mock object destruction triggerred by another mock object's
-  destruction no longer hangs.
-* Improvement: Google Mock Doctor works better with newer Clang and
-  GCC now.
-* Compatibility fixes.
-* Bug/warning fixes.
-
-Changes for 1.6.0:
-
-* Compilation is much faster and uses much less memory, especially
-  when the constructor and destructor of a mock class are moved out of
-  the class body.
-* New matchers: Pointwise(), Each().
-* New actions: ReturnPointee() and ReturnRefOfCopy().
-* CMake support.
-* Project files for Visual Studio 2010.
-* AllOf() and AnyOf() can handle up-to 10 arguments now.
-* Google Mock doctor understands Clang error messages now.
-* SetArgPointee<> now accepts string literals.
-* gmock_gen.py handles storage specifier macros and template return
-  types now.
-* Compatibility fixes.
-* Bug fixes and implementation clean-ups.
-* Potentially incompatible changes: disables the harmful 'make install'
-  command in autotools.
-
-Potentially breaking changes:
-
-* The description string for MATCHER*() changes from Python-style
-  interpolation to an ordinary C++ string expression.
-* SetArgumentPointee is deprecated in favor of SetArgPointee.
-* Some non-essential project files for Visual Studio 2005 are removed.
-
-Changes for 1.5.0:
-
- * New feature: Google Mock can be safely used in multi-threaded tests
-   on platforms having pthreads.
- * New feature: function for printing a value of arbitrary type.
- * New feature: function ExplainMatchResult() for easy definition of
-   composite matchers.
- * The new matcher API lets user-defined matchers generate custom
-   explanations more directly and efficiently.
- * Better failure messages all around.
- * NotNull() and IsNull() now work with smart pointers.
- * Field() and Property() now work when the matcher argument is a pointer
-   passed by reference.
- * Regular expression matchers on all platforms.
- * Added GCC 4.0 support for Google Mock Doctor.
- * Added gmock_all_test.cc for compiling most Google Mock tests
-   in a single file.
- * Significantly cleaned up compiler warnings.
- * Bug fixes, better test coverage, and implementation clean-ups.
-
- Potentially breaking changes:
-
- * Custom matchers defined using MatcherInterface or MakePolymorphicMatcher()
-   need to be updated after upgrading to Google Mock 1.5.0; matchers defined
-   using MATCHER or MATCHER_P* aren't affected.
- * Dropped support for 'make install'.
-
-Changes for 1.4.0 (we skipped 1.2.* and 1.3.* to match the version of
-Google Test):
-
- * Works in more environments: Symbian and minGW, Visual C++ 7.1.
- * Lighter weight: comes with our own implementation of TR1 tuple (no
-   more dependency on Boost!).
- * New feature: --gmock_catch_leaked_mocks for detecting leaked mocks.
- * New feature: ACTION_TEMPLATE for defining templatized actions.
- * New feature: the .After() clause for specifying expectation order.
- * New feature: the .With() clause for for specifying inter-argument
-   constraints.
- * New feature: actions ReturnArg<k>(), ReturnNew<T>(...), and
-   DeleteArg<k>().
- * New feature: matchers Key(), Pair(), Args<...>(), AllArgs(), IsNull(),
-   and Contains().
- * New feature: utility class MockFunction<F>, useful for checkpoints, etc.
- * New feature: functions Value(x, m) and SafeMatcherCast<T>(m).
- * New feature: copying a mock object is rejected at compile time.
- * New feature: a script for fusing all Google Mock and Google Test
-   source files for easy deployment.
- * Improved the Google Mock doctor to diagnose more diseases.
- * Improved the Google Mock generator script.
- * Compatibility fixes for Mac OS X and gcc.
- * Bug fixes and implementation clean-ups.
-
-Changes for 1.1.0:
-
- * New feature: ability to use Google Mock with any testing framework.
- * New feature: macros for easily defining new matchers
- * New feature: macros for easily defining new actions.
- * New feature: more container matchers.
- * New feature: actions for accessing function arguments and throwing
-   exceptions.
- * Improved the Google Mock doctor script for diagnosing compiler errors.
- * Bug fixes and implementation clean-ups.
-
-Changes for 1.0.0:
-
- * Initial Open Source release of Google Mock
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/CMakeLists.txt b/week4/softwareEng_9_4/vendor/googletest/googlemock/CMakeLists.txt
deleted file mode 100644
index beb259a2..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/CMakeLists.txt
+++ /dev/null
@@ -1,202 +0,0 @@
-########################################################################
-# CMake build script for Google Mock.
-#
-# To run the tests for Google Mock itself on Linux, use 'make test' or
-# ctest.  You can select which tests to run using 'ctest -R regex'.
-# For more options, run 'ctest --help'.
-
-# BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to
-# make it prominent in the GUI.
-option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF)
-
-option(gmock_build_tests "Build all of Google Mock's own tests." OFF)
-
-# A directory to find Google Test sources.
-if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/gtest/CMakeLists.txt")
-  set(gtest_dir gtest)
-else()
-  set(gtest_dir ../googletest)
-endif()
-
-# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build().
-include("${gtest_dir}/cmake/hermetic_build.cmake" OPTIONAL)
-
-if (COMMAND pre_project_set_up_hermetic_build)
-  # Google Test also calls hermetic setup functions from add_subdirectory,
-  # although its changes will not affect things at the current scope.
-  pre_project_set_up_hermetic_build()
-endif()
-
-########################################################################
-#
-# Project-wide settings
-
-# Name of the project.
-#
-# CMake files in this project can refer to the root source directory
-# as ${gmock_SOURCE_DIR} and to the root binary directory as
-# ${gmock_BINARY_DIR}.
-# Language "C" is required for find_package(Threads).
-project(gmock CXX C)
-cmake_minimum_required(VERSION 2.6.2)
-
-if (COMMAND set_up_hermetic_build)
-  set_up_hermetic_build()
-endif()
-
-# Instructs CMake to process Google Test's CMakeLists.txt and add its
-# targets to the current scope.  We are placing Google Test's binary
-# directory in a subdirectory of our own as VC compilation may break
-# if they are the same (the default).
-add_subdirectory("${gtest_dir}" "${gmock_BINARY_DIR}/gtest")
-
-# Although Google Test's CMakeLists.txt calls this function, the
-# changes there don't affect the current scope.  Therefore we have to
-# call it again here.
-config_compiler_and_linker()  # from ${gtest_dir}/cmake/internal_utils.cmake
-
-# Adds Google Mock's and Google Test's header directories to the search path.
-include_directories("${gmock_SOURCE_DIR}/include"
-                    "${gmock_SOURCE_DIR}"
-                    "${gtest_SOURCE_DIR}/include"
-                    # This directory is needed to build directly from Google
-                    # Test sources.
-                    "${gtest_SOURCE_DIR}")
-
-# Summary of tuple support for Microsoft Visual Studio:
-# Compiler    version(MS)  version(cmake)  Support
-# ----------  -----------  --------------  -----------------------------
-# <= VS 2010  <= 10        <= 1600         Use Google Tests's own tuple.
-# VS 2012     11           1700            std::tr1::tuple + _VARIADIC_MAX=10
-# VS 2013     12           1800            std::tr1::tuple
-if (MSVC AND MSVC_VERSION EQUAL 1700)
-  add_definitions(/D _VARIADIC_MAX=10)
-endif()
-
-########################################################################
-#
-# Defines the gmock & gmock_main libraries.  User tests should link
-# with one of them.
-
-# Google Mock libraries.  We build them using more strict warnings than what
-# are used for other targets, to ensure that Google Mock can be compiled by
-# a user aggressive about warnings.
-cxx_library(gmock
-            "${cxx_strict}"
-            "${gtest_dir}/src/gtest-all.cc"
-            src/gmock-all.cc)
-
-cxx_library(gmock_main
-            "${cxx_strict}"
-            "${gtest_dir}/src/gtest-all.cc"
-            src/gmock-all.cc
-            src/gmock_main.cc)
-
-# If the CMake version supports it, attach header directory information
-# to the targets for when we are part of a parent build (ie being pulled
-# in via add_subdirectory() rather than being a standalone build).
-if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
-  target_include_directories(gmock      INTERFACE "${gmock_SOURCE_DIR}/include")
-  target_include_directories(gmock_main INTERFACE "${gmock_SOURCE_DIR}/include")
-endif()
-
-########################################################################
-#
-# Install rules
-install(TARGETS gmock gmock_main
-  DESTINATION lib)
-install(DIRECTORY ${gmock_SOURCE_DIR}/include/gmock
-  DESTINATION include)
-
-########################################################################
-#
-# Google Mock's own tests.
-#
-# You can skip this section if you aren't interested in testing
-# Google Mock itself.
-#
-# The tests are not built by default.  To build them, set the
-# gmock_build_tests option to ON.  You can do it by running ccmake
-# or specifying the -Dgmock_build_tests=ON flag when running cmake.
-
-if (gmock_build_tests)
-  # This must be set in the root directory for the tests to be run by
-  # 'make test' or ctest.
-  enable_testing()
-
-  ############################################################
-  # C++ tests built with standard compiler flags.
-
-  cxx_test(gmock-actions_test gmock_main)
-  cxx_test(gmock-cardinalities_test gmock_main)
-  cxx_test(gmock_ex_test gmock_main)
-  cxx_test(gmock-generated-actions_test gmock_main)
-  cxx_test(gmock-generated-function-mockers_test gmock_main)
-  cxx_test(gmock-generated-internal-utils_test gmock_main)
-  cxx_test(gmock-generated-matchers_test gmock_main)
-  cxx_test(gmock-internal-utils_test gmock_main)
-  cxx_test(gmock-matchers_test gmock_main)
-  cxx_test(gmock-more-actions_test gmock_main)
-  cxx_test(gmock-nice-strict_test gmock_main)
-  cxx_test(gmock-port_test gmock_main)
-  cxx_test(gmock-spec-builders_test gmock_main)
-  cxx_test(gmock_link_test gmock_main test/gmock_link2_test.cc)
-  cxx_test(gmock_test gmock_main)
-
-  if (CMAKE_USE_PTHREADS_INIT)
-    cxx_test(gmock_stress_test gmock)
-  endif()
-
-  # gmock_all_test is commented to save time building and running tests.
-  # Uncomment if necessary.
-  # cxx_test(gmock_all_test gmock_main)
-
-  ############################################################
-  # C++ tests built with non-standard compiler flags.
-
-  cxx_library(gmock_main_no_exception "${cxx_no_exception}"
-    "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
-
-  cxx_library(gmock_main_no_rtti "${cxx_no_rtti}"
-    "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
-
-  if (NOT MSVC OR MSVC_VERSION LESS 1600)  # 1600 is Visual Studio 2010.
-    # Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that
-    # conflict with our own definitions. Therefore using our own tuple does not
-    # work on those compilers.
-    cxx_library(gmock_main_use_own_tuple "${cxx_use_own_tuple}"
-      "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
-
-    cxx_test_with_flags(gmock_use_own_tuple_test "${cxx_use_own_tuple}"
-      gmock_main_use_own_tuple test/gmock-spec-builders_test.cc)
-  endif()
-
-  cxx_test_with_flags(gmock-more-actions_no_exception_test "${cxx_no_exception}"
-    gmock_main_no_exception test/gmock-more-actions_test.cc)
-
-  cxx_test_with_flags(gmock_no_rtti_test "${cxx_no_rtti}"
-    gmock_main_no_rtti test/gmock-spec-builders_test.cc)
-
-  cxx_shared_library(shared_gmock_main "${cxx_default}"
-    "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
-
-  # Tests that a binary can be built with Google Mock as a shared library.  On
-  # some system configurations, it may not possible to run the binary without
-  # knowing more details about the system configurations. We do not try to run
-  # this binary. To get a more robust shared library coverage, configure with
-  # -DBUILD_SHARED_LIBS=ON.
-  cxx_executable_with_flags(shared_gmock_test_ "${cxx_default}"
-    shared_gmock_main test/gmock-spec-builders_test.cc)
-  set_target_properties(shared_gmock_test_
-    PROPERTIES
-    COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
-
-  ############################################################
-  # Python tests.
-
-  cxx_executable(gmock_leak_test_ test gmock_main)
-  py_test(gmock_leak_test)
-
-  cxx_executable(gmock_output_test_ test gmock)
-  py_test(gmock_output_test)
-endif()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/CONTRIBUTORS b/week4/softwareEng_9_4/vendor/googletest/googlemock/CONTRIBUTORS
deleted file mode 100644
index 6e9ae362..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/CONTRIBUTORS
+++ /dev/null
@@ -1,40 +0,0 @@
-# This file contains a list of people who've made non-trivial
-# contribution to the Google C++ Mocking Framework project.  People
-# who commit code to the project are encouraged to add their names
-# here.  Please keep the list sorted by first names.
-
-Benoit Sigoure <tsuna@google.com>
-Bogdan Piloca <boo@google.com>
-Chandler Carruth <chandlerc@google.com>
-Dave MacLachlan <dmaclach@gmail.com>
-David Anderson <danderson@google.com>
-Dean Sturtevant
-Gene Volovich <gv@cite.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>
-Keir Mierle <mierle@gmail.com>
-Keith Ray <keith.ray@gmail.com>
-Kostya Serebryany <kcc@google.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>
-Mike Bland <mbland@google.com>
-Neal Norwitz <nnorwitz@gmail.com>
-Nermin Ozkiranartli <nermin@google.com>
-Owen Carlsen <ocarlsen@google.com>
-Paneendra Ba <paneendra@google.com>
-Paul Menage <menage@google.com>
-Piotr Kaminski <piotrk@google.com>
-Russ Rufer <russ@pentad.com>
-Sverre Sundsdal <sundsdal@gmail.com>
-Takeshi Yoshino <tyoshino@google.com>
-Vadim Berman <vadimb@google.com>
-Vlad Losev <vladl@google.com>
-Wolfgang Klier <wklier@google.com>
-Zhanyong Wan <wan@google.com>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/LICENSE b/week4/softwareEng_9_4/vendor/googletest/googlemock/LICENSE
deleted file mode 100644
index 1941a11f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/LICENSE
+++ /dev/null
@@ -1,28 +0,0 @@
-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/week4/softwareEng_9_4/vendor/googletest/googlemock/Makefile.am b/week4/softwareEng_9_4/vendor/googletest/googlemock/Makefile.am
deleted file mode 100644
index 9adbc516..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/Makefile.am
+++ /dev/null
@@ -1,224 +0,0 @@
-# Automake file
-
-# Nonstandard package files for distribution.
-EXTRA_DIST = LICENSE
-
-# We may need to build our internally packaged gtest. If so, it will be
-# included in the 'subdirs' variable.
-SUBDIRS = $(subdirs)
-
-# This is generated by the configure script, so clean it for distribution.
-DISTCLEANFILES = scripts/gmock-config
-
-# We define the global AM_CPPFLAGS as everything we compile includes from these
-# directories.
-AM_CPPFLAGS = $(GTEST_CPPFLAGS) -I$(srcdir)/include
-
-# Modifies compiler and linker flags for pthreads compatibility.
-if HAVE_PTHREADS
-  AM_CXXFLAGS = @PTHREAD_CFLAGS@ -DGTEST_HAS_PTHREAD=1
-  AM_LIBS = @PTHREAD_LIBS@
-endif
-
-# Build rules for libraries.
-lib_LTLIBRARIES = lib/libgmock.la lib/libgmock_main.la
-
-lib_libgmock_la_SOURCES = src/gmock-all.cc
-
-pkginclude_HEADERS = \
-  include/gmock/gmock-actions.h \
-  include/gmock/gmock-cardinalities.h \
-  include/gmock/gmock-generated-actions.h \
-  include/gmock/gmock-generated-function-mockers.h \
-  include/gmock/gmock-generated-matchers.h \
-  include/gmock/gmock-generated-nice-strict.h \
-  include/gmock/gmock-matchers.h \
-  include/gmock/gmock-more-actions.h \
-  include/gmock/gmock-more-matchers.h \
-  include/gmock/gmock-spec-builders.h \
-  include/gmock/gmock.h
-
-pkginclude_internaldir = $(pkgincludedir)/internal
-pkginclude_internal_HEADERS = \
-  include/gmock/internal/gmock-generated-internal-utils.h \
-  include/gmock/internal/gmock-internal-utils.h \
-  include/gmock/internal/gmock-port.h \
-  include/gmock/internal/custom/gmock-generated-actions.h \
-  include/gmock/internal/custom/gmock-matchers.h \
-  include/gmock/internal/custom/gmock-port.h
-
-lib_libgmock_main_la_SOURCES = src/gmock_main.cc
-lib_libgmock_main_la_LIBADD = lib/libgmock.la
-
-# Build rules for tests. Automake's naming for some of these variables isn't
-# terribly obvious, so this is a brief reference:
-#
-# TESTS -- Programs run automatically by "make check"
-# check_PROGRAMS -- Programs built by "make check" but not necessarily run
-
-TESTS=
-check_PROGRAMS=
-AM_LDFLAGS = $(GTEST_LDFLAGS)
-
-# This exercises all major components of Google Mock.  It also
-# verifies that libgmock works.
-TESTS += test/gmock-spec-builders_test
-check_PROGRAMS += test/gmock-spec-builders_test
-test_gmock_spec_builders_test_SOURCES = test/gmock-spec-builders_test.cc
-test_gmock_spec_builders_test_LDADD = $(GTEST_LIBS) lib/libgmock.la
-
-# This tests using Google Mock in multiple translation units.  It also
-# verifies that libgmock_main and libgmock work.
-TESTS += test/gmock_link_test
-check_PROGRAMS += test/gmock_link_test
-test_gmock_link_test_SOURCES = \
-  test/gmock_link2_test.cc \
-  test/gmock_link_test.cc \
-  test/gmock_link_test.h
-test_gmock_link_test_LDADD = $(GTEST_LIBS) lib/libgmock_main.la  lib/libgmock.la
-
-if HAVE_PYTHON
-  # Tests that fused gmock files compile and work.
-  TESTS += test/gmock_fused_test
-  check_PROGRAMS += test/gmock_fused_test
-  test_gmock_fused_test_SOURCES = \
-    fused-src/gmock-gtest-all.cc \
-    fused-src/gmock/gmock.h \
-    fused-src/gmock_main.cc \
-    fused-src/gtest/gtest.h \
-    test/gmock_test.cc
-  test_gmock_fused_test_CPPFLAGS = -I"$(srcdir)/fused-src"
-endif
-
-# Google Mock source files that we don't compile directly.
-GMOCK_SOURCE_INGLUDES = \
-  src/gmock-cardinalities.cc \
-  src/gmock-internal-utils.cc \
-  src/gmock-matchers.cc \
-  src/gmock-spec-builders.cc \
-  src/gmock.cc
-
-EXTRA_DIST += $(GMOCK_SOURCE_INGLUDES)
-
-# C++ tests that we don't compile using autotools.
-EXTRA_DIST += \
-  test/gmock-actions_test.cc \
-  test/gmock_all_test.cc \
-  test/gmock-cardinalities_test.cc \
-  test/gmock_ex_test.cc \
-  test/gmock-generated-actions_test.cc \
-  test/gmock-generated-function-mockers_test.cc \
-  test/gmock-generated-internal-utils_test.cc \
-  test/gmock-generated-matchers_test.cc \
-  test/gmock-internal-utils_test.cc \
-  test/gmock-matchers_test.cc \
-  test/gmock-more-actions_test.cc \
-  test/gmock-nice-strict_test.cc \
-  test/gmock-port_test.cc \
-  test/gmock_stress_test.cc
-
-# Python tests, which we don't run using autotools.
-EXTRA_DIST += \
-  test/gmock_leak_test.py \
-  test/gmock_leak_test_.cc \
-  test/gmock_output_test.py \
-  test/gmock_output_test_.cc \
-  test/gmock_output_test_golden.txt \
-  test/gmock_test_utils.py
-
-# Nonstandard package files for distribution.
-EXTRA_DIST += \
-  CHANGES \
-  CONTRIBUTORS \
-  make/Makefile
-
-# Pump scripts for generating Google Mock headers.
-# TODO(chandlerc@google.com): automate the generation of *.h from *.h.pump.
-EXTRA_DIST += \
-  include/gmock/gmock-generated-actions.h.pump \
-  include/gmock/gmock-generated-function-mockers.h.pump \
-  include/gmock/gmock-generated-matchers.h.pump \
-  include/gmock/gmock-generated-nice-strict.h.pump \
-  include/gmock/internal/gmock-generated-internal-utils.h.pump \
-  include/gmock/internal/custom/gmock-generated-actions.h.pump
-
-# Script for fusing Google Mock and Google Test source files.
-EXTRA_DIST += scripts/fuse_gmock_files.py
-
-# The Google Mock Generator tool from the cppclean project.
-EXTRA_DIST += \
-  scripts/generator/LICENSE \
-  scripts/generator/README \
-  scripts/generator/README.cppclean \
-  scripts/generator/cpp/__init__.py \
-  scripts/generator/cpp/ast.py \
-  scripts/generator/cpp/gmock_class.py \
-  scripts/generator/cpp/keywords.py \
-  scripts/generator/cpp/tokenize.py \
-  scripts/generator/cpp/utils.py \
-  scripts/generator/gmock_gen.py
-
-# Script for diagnosing compiler errors in programs that use Google
-# Mock.
-EXTRA_DIST += scripts/gmock_doctor.py
-
-# CMake scripts.
-EXTRA_DIST += \
-  CMakeLists.txt
-
-# Microsoft Visual Studio 2005 projects.
-EXTRA_DIST += \
-  msvc/2005/gmock.sln \
-  msvc/2005/gmock.vcproj \
-  msvc/2005/gmock_config.vsprops \
-  msvc/2005/gmock_main.vcproj \
-  msvc/2005/gmock_test.vcproj
-
-# Microsoft Visual Studio 2010 projects.
-EXTRA_DIST += \
-  msvc/2010/gmock.sln \
-  msvc/2010/gmock.vcxproj \
-  msvc/2010/gmock_config.props \
-  msvc/2010/gmock_main.vcxproj \
-  msvc/2010/gmock_test.vcxproj
-
-if HAVE_PYTHON
-# gmock_test.cc does not really depend on files generated by the
-# fused-gmock-internal rule.  However, gmock_test.o does, and it is
-# important to include test/gmock_test.cc as part of this rule in order to
-# prevent compiling gmock_test.o until all dependent files have been
-# generated.
-$(test_gmock_fused_test_SOURCES): fused-gmock-internal
-
-# TODO(vladl@google.com): Find a way to add Google Tests's sources here.
-fused-gmock-internal: $(pkginclude_HEADERS) $(pkginclude_internal_HEADERS) \
-                      $(lib_libgmock_la_SOURCES) $(GMOCK_SOURCE_INGLUDES) \
-                      $(lib_libgmock_main_la_SOURCES) \
-                      scripts/fuse_gmock_files.py
-	mkdir -p "$(srcdir)/fused-src"
-	chmod -R u+w "$(srcdir)/fused-src"
-	rm -f "$(srcdir)/fused-src/gtest/gtest.h"
-	rm -f "$(srcdir)/fused-src/gmock/gmock.h"
-	rm -f "$(srcdir)/fused-src/gmock-gtest-all.cc"
-	"$(srcdir)/scripts/fuse_gmock_files.py" "$(srcdir)/fused-src"
-	cp -f "$(srcdir)/src/gmock_main.cc" "$(srcdir)/fused-src"
-
-maintainer-clean-local:
-	rm -rf "$(srcdir)/fused-src"
-endif
-
-# Death tests may produce core dumps in the build directory. In case
-# this happens, clean them to keep distcleancheck happy.
-CLEANFILES = core
-
-# Disables 'make install' as installing a compiled version of Google
-# Mock can lead to undefined behavior due to violation of the
-# One-Definition Rule.
-
-install-exec-local:
-	echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Mock into your build system."
-	false
-
-install-data-local:
-	echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Mock into your build system."
-	false
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/README.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/README.md
deleted file mode 100644
index 332beab3..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/README.md
+++ /dev/null
@@ -1,333 +0,0 @@
-## Google Mock ##
-
-The Google C++ mocking 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/), and
-  * [Hamcrest](http://code.google.com/p/hamcrest/),
-
-and designed with C++'s specifics in mind.
-
-Google mock:
-
-  * lets you create mock classes trivially using simple macros.
-  * supports a rich set of matchers and actions.
-  * handles unordered, partially ordered, or completely ordered expectations.
-  * is extensible by users.
-
-We hope you find it useful!
-
-### Features ###
-
-  * Provides a declarative syntax for defining mocks.
-  * Can easily 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.
-
-Please see the project page above for more information as well as the
-mailing list for questions, discussions, and development.  There is
-also an IRC channel on OFTC (irc.oftc.net) #gtest available.  Please
-join us!
-
-Please note that code under [scripts/generator](scripts/generator/) is
-from [cppclean](http://code.google.com/p/cppclean/) and released under
-the Apache License, which is different from Google Mock's license.
-
-## Getting Started ##
-
-If you are new to the project, we suggest that you read the user
-documentation in the following order:
-
-  * Learn the [basics](../googletest/docs/Primer.md) of
-    Google Test, if you choose to use Google Mock with it (recommended).
-  * Read [Google Mock for Dummies](docs/ForDummies.md).
-  * Read the instructions below on how to build Google Mock.
-
-You can also watch Zhanyong's [talk](http://www.youtube.com/watch?v=sYpCyLI47rM) on Google Mock's usage and implementation.
-
-Once you understand the basics, check out the rest of the docs:
-
-  * [CheatSheet](docs/CheatSheet.md) - all the commonly used stuff
-    at a glance.
-  * [CookBook](docs/CookBook.md) - recipes for getting things done,
-    including advanced techniques.
-
-If you need help, please check the
-[KnownIssues](docs/KnownIssues.md) and
-[FrequentlyAskedQuestions](docs/FrequentlyAskedQuestions.md) before
-posting a question on the
-[discussion group](http://groups.google.com/group/googlemock).
-
-
-### Using Google Mock Without Google Test ###
-
-Google Mock is not a testing framework itself.  Instead, it needs a
-testing framework for writing tests.  Google Mock works seamlessly
-with [Google Test](http://code.google.com/p/googletest/), but
-you can also use it with [any C++ testing framework](googlemock/ForDummies.md#Using_Google_Mock_with_Any_Testing_Framework).
-
-### Requirements for End Users ###
-
-Google Mock is implemented on top of [Google Test](
-http://github.com/google/googletest/), and depends on it.
-You must use the bundled version of Google Test when using Google Mock.
-
-You can also easily configure Google Mock to work with another testing
-framework, although it will still need Google Test.  Please read
-["Using_Google_Mock_with_Any_Testing_Framework"](
-    docs/ForDummies.md#Using_Google_Mock_with_Any_Testing_Framework)
-for instructions.
-
-Google Mock depends on advanced C++ features and thus requires a more
-modern compiler. The following are needed to use Google Mock:
-
-#### Linux Requirements ####
-
-  * GNU-compatible Make or "gmake"
-  * POSIX-standard shell
-  * POSIX(-2) Regular Expressions (regex.h)
-  * C++98-standard-compliant compiler (e.g. GCC 3.4 or newer)
-
-#### Windows Requirements ####
-
-  * Microsoft Visual C++ 8.0 SP1 or newer
-
-#### Mac OS X Requirements ####
-
-  * Mac OS X 10.4 Tiger or newer
-  * Developer Tools Installed
-
-### Requirements for Contributors ###
-
-We welcome patches. If you plan to contribute a patch, you need to
-build Google Mock and its tests, which has further requirements:
-
-  * Automake version 1.9 or newer
-  * Autoconf version 2.59 or newer
-  * Libtool / Libtoolize
-  * Python version 2.3 or newer (for running some of the tests and
-    re-generating certain source files from templates)
-
-### Building Google Mock ###
-
-#### Preparing to Build (Unix only) ####
-
-If you are using a Unix system and plan to use the GNU Autotools build
-system to build Google Mock (described below), you'll need to
-configure it now.
-
-To prepare the Autotools build system:
-
-    cd googlemock
-    autoreconf -fvi
-
-To build Google Mock 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.
-
-This section shows how you can integrate Google Mock into your
-existing build system.
-
-Suppose you put Google Mock in directory `${GMOCK_DIR}` and Google Test
-in `${GTEST_DIR}` (the latter is `${GMOCK_DIR}/gtest` by default).  To
-build Google Mock, create a library build target (or a project as
-called by Visual Studio and Xcode) to compile
-
-    ${GTEST_DIR}/src/gtest-all.cc and ${GMOCK_DIR}/src/gmock-all.cc
-
-with
-
-    ${GTEST_DIR}/include and ${GMOCK_DIR}/include
-
-in the system header search path, and
-
-    ${GTEST_DIR} and ${GMOCK_DIR}
-
-in the normal header search path.  Assuming a Linux-like system and gcc,
-something like the following will do:
-
-    g++ -isystem ${GTEST_DIR}/include -I${GTEST_DIR} \
-        -isystem ${GMOCK_DIR}/include -I${GMOCK_DIR} \
-        -pthread -c ${GTEST_DIR}/src/gtest-all.cc
-    g++ -isystem ${GTEST_DIR}/include -I${GTEST_DIR} \
-        -isystem ${GMOCK_DIR}/include -I${GMOCK_DIR} \
-        -pthread -c ${GMOCK_DIR}/src/gmock-all.cc
-    ar -rv libgmock.a gtest-all.o gmock-all.o
-
-(We need -pthread as Google Test and Google Mock use threads.)
-
-Next, you should compile your test source file with
-${GTEST\_DIR}/include and ${GMOCK\_DIR}/include in the header search
-path, and link it with gmock and any other necessary libraries:
-
-    g++ -isystem ${GTEST_DIR}/include -isystem ${GMOCK_DIR}/include \
-        -pthread path/to/your_test.cc libgmock.a -o your_test
-
-As an example, the make/ directory contains a Makefile that you can
-use to build Google Mock on systems where GNU make is available
-(e.g. Linux, Mac OS X, and Cygwin).  It doesn't try to build Google
-Mock's own tests.  Instead, it just builds the Google Mock library and
-a sample test.  You can use it as a starting point for your own build
-script.
-
-If the default settings are correct for your environment, the
-following commands should succeed:
-
-    cd ${GMOCK_DIR}/make
-    make
-    ./gmock_test
-
-If you see errors, try to tweak the contents of
-[make/Makefile](make/Makefile) to make them go away.
-
-### Windows ###
-
-The msvc/2005 directory contains VC++ 2005 projects and the msvc/2010
-directory contains VC++ 2010 projects for building Google Mock and
-selected tests.
-
-Change to the appropriate directory and run "msbuild gmock.sln" to
-build the library and tests (or open the gmock.sln in the MSVC IDE).
-If you want to create your own project to use with Google Mock, you'll
-have to configure it to use the `gmock_config` propety sheet.  For that:
-
- * Open the Property Manager window (View | Other Windows | Property Manager)
- * Right-click on your project and select "Add Existing Property Sheet..."
- * Navigate to `gmock_config.vsprops` or `gmock_config.props` and select it.
- * In Project Properties | Configuration Properties | General | Additional
-   Include Directories, type <path to Google Mock>/include.
-
-### Tweaking Google Mock ###
-
-Google Mock 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 Google Mock 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 [${GTEST\_DIR}/include/gtest/internal/gtest-port.h](
-../googletest/include/gtest/internal/gtest-port.h).
-
-### Choosing a TR1 Tuple Library ###
-
-Google Mock uses the C++ Technical Report 1 (TR1) tuple library
-heavily.  Unfortunately TR1 tuple is not yet widely available with all
-compilers.  The good news is that Google Test 1.4.0+ implements a
-subset of TR1 tuple that's enough for Google Mock's need.  Google Mock
-will automatically use that implementation when the compiler doesn't
-provide TR1 tuple.
-
-Usually you don't need to care about which tuple library Google Test
-and Google Mock use.  However, if your project already uses TR1 tuple,
-you need to tell Google Test and Google Mock to use the same TR1 tuple
-library the rest of your project uses, or the two tuple
-implementations will clash.  To do that, add
-
-    -DGTEST_USE_OWN_TR1_TUPLE=0
-
-to the compiler flags while compiling Google Test, Google Mock, and
-your tests.  If you want to force Google Test and Google Mock to use
-their own tuple library, just add
-
-    -DGTEST_USE_OWN_TR1_TUPLE=1
-
-to the compiler flags instead.
-
-If you want to use Boost's TR1 tuple library with Google Mock, please
-refer to the Boost website (http://www.boost.org/) for how to obtain
-it and set it up.
-
-### As a Shared Library (DLL) ###
-
-Google Mock is compact, so most users can build and link it as a static
-library for the simplicity.  Google Mock can be used as a DLL, but the
-same DLL must contain Google Test as well.  See
-[Google Test's README][gtest_readme]
-for instructions on how to set up necessary compiler settings.
-
-### Tweaking Google Mock ###
-
-Most of Google Test's control macros apply to Google Mock as well.
-Please see [Google Test's README][gtest_readme] for how to tweak them.
-
-### Upgrading from an Earlier Version ###
-
-We strive to keep Google Mock releases backward compatible.
-Sometimes, though, we have to make some breaking changes for the
-users' long-term benefits.  This section describes what you'll need to
-do if you are upgrading from an earlier version of Google Mock.
-
-#### Upgrading from 1.1.0 or Earlier ####
-
-You may need to explicitly enable or disable Google Test's own TR1
-tuple library.  See the instructions in section "[Choosing a TR1 Tuple
-Library](../googletest/#choosing-a-tr1-tuple-library)".
-
-#### Upgrading from 1.4.0 or Earlier ####
-
-On platforms where the pthread library is available, Google Test and
-Google Mock use it in order to be thread-safe.  For this to work, you
-may need to tweak your compiler and/or linker flags.  Please see the
-"[Multi-threaded Tests](../googletest#multi-threaded-tests
-)" section in file Google Test's README for what you may need to do.
-
-If you have custom matchers defined using `MatcherInterface` or
-`MakePolymorphicMatcher()`, you'll need to update their definitions to
-use the new matcher API (
-[monomorphic](http://code.google.com/p/googlemock/wiki/CookBook#Writing_New_Monomorphic_Matchers),
-[polymorphic](http://code.google.com/p/googlemock/wiki/CookBook#Writing_New_Polymorphic_Matchers)).
-Matchers defined using `MATCHER()` or `MATCHER_P*()` aren't affected.
-
-### Developing Google Mock ###
-
-This section discusses how to make your own changes to Google Mock.
-
-#### Testing Google Mock Itself ####
-
-To make sure your changes work as intended and don't break existing
-functionality, you'll want to compile and run Google Test's own tests.
-For that you'll need Autotools.  First, make sure you have followed
-the instructions above to configure Google Mock.
-Then, create a build output directory and enter it.  Next,
-
-    ${GMOCK_DIR}/configure  # try --help for more info
-
-Once you have successfully configured Google Mock, the build steps are
-standard for GNU-style OSS packages.
-
-    make        # Standard makefile following GNU conventions
-    make check  # Builds and runs all tests - all should pass.
-
-Note that when building your project against Google Mock, you are building
-against Google Test as well.  There is no need to configure Google Test
-separately.
-
-#### Contributing a Patch ####
-
-We welcome patches.
-Please read the [Developer's Guide](docs/DevGuide.md)
-for how you can contribute. In particular, make sure you have signed
-the Contributor License Agreement, or we won't be able to accept the
-patch.
-
-Happy testing!
-
-[gtest_readme]: ../googletest/README.md "googletest"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/build-aux/.keep b/week4/softwareEng_9_4/vendor/googletest/googlemock/build-aux/.keep
deleted file mode 100644
index e69de29b..00000000
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/configure.ac b/week4/softwareEng_9_4/vendor/googletest/googlemock/configure.ac
deleted file mode 100644
index 3b740f20..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/configure.ac
+++ /dev/null
@@ -1,146 +0,0 @@
-m4_include(../googletest/m4/acx_pthread.m4)
-
-AC_INIT([Google C++ Mocking Framework],
-        [1.7.0],
-        [googlemock@googlegroups.com],
-        [gmock])
-
-# Provide various options to initialize the Autoconf and configure processes.
-AC_PREREQ([2.59])
-AC_CONFIG_SRCDIR([./LICENSE])
-AC_CONFIG_AUX_DIR([build-aux])
-AC_CONFIG_HEADERS([build-aux/config.h])
-AC_CONFIG_FILES([Makefile])
-AC_CONFIG_FILES([scripts/gmock-config], [chmod +x scripts/gmock-config])
-
-# Initialize Automake with various options. We require at least v1.9, prevent
-# pedantic complaints about package files, and enable various distribution
-# targets.
-AM_INIT_AUTOMAKE([1.9 dist-bzip2 dist-zip foreign subdir-objects])
-
-# Check for programs used in building Google Test.
-AC_PROG_CC
-AC_PROG_CXX
-AC_LANG([C++])
-AC_PROG_LIBTOOL
-
-# TODO(chandlerc@google.com): Currently we aren't running the Python tests
-# against the interpreter detected by AM_PATH_PYTHON, and so we condition
-# HAVE_PYTHON by requiring "python" to be in the PATH, and that interpreter's
-# version to be >= 2.3. This will allow the scripts to use a "/usr/bin/env"
-# hashbang.
-PYTHON=  # We *do not* allow the user to specify a python interpreter
-AC_PATH_PROG([PYTHON],[python],[:])
-AS_IF([test "$PYTHON" != ":"],
-      [AM_PYTHON_CHECK_VERSION([$PYTHON],[2.3],[:],[PYTHON=":"])])
-AM_CONDITIONAL([HAVE_PYTHON],[test "$PYTHON" != ":"])
-
-# TODO(chandlerc@google.com) Check for the necessary system headers.
-
-# Configure pthreads.
-AC_ARG_WITH([pthreads],
-            [AS_HELP_STRING([--with-pthreads],
-               [use pthreads (default is yes)])],
-            [with_pthreads=$withval],
-            [with_pthreads=check])
-
-have_pthreads=no
-AS_IF([test "x$with_pthreads" != "xno"],
-      [ACX_PTHREAD(
-        [],
-        [AS_IF([test "x$with_pthreads" != "xcheck"],
-               [AC_MSG_FAILURE(
-                 [--with-pthreads was specified, but unable to be used])])])
-       have_pthreads="$acx_pthread_ok"])
-AM_CONDITIONAL([HAVE_PTHREADS],[test "x$have_pthreads" == "xyes"])
-AC_SUBST(PTHREAD_CFLAGS)
-AC_SUBST(PTHREAD_LIBS)
-
-# GoogleMock currently has hard dependencies upon GoogleTest above and beyond
-# running its own test suite, so we both provide our own version in
-# a subdirectory and provide some logic to use a custom version or a system
-# installed version.
-AC_ARG_WITH([gtest],
-            [AS_HELP_STRING([--with-gtest],
-                            [Specifies how to find the gtest package. If no
-                            arguments are given, the default behavior, a
-                            system installed gtest will be used if present,
-                            and an internal version built otherwise. If a
-                            path is provided, the gtest built or installed at
-                            that prefix will be used.])],
-            [],
-            [with_gtest=yes])
-AC_ARG_ENABLE([external-gtest],
-              [AS_HELP_STRING([--disable-external-gtest],
-                              [Disables any detection or use of a system
-                              installed or user provided gtest. Any option to
-                              '--with-gtest' is ignored. (Default is enabled.)])
-              ], [], [enable_external_gtest=yes])
-AS_IF([test "x$with_gtest" == "xno"],
-      [AC_MSG_ERROR([dnl
-Support for GoogleTest was explicitly disabled. Currently GoogleMock has a hard
-dependency upon GoogleTest to build, please provide a version, or allow
-GoogleMock to use any installed version and fall back upon its internal
-version.])])
-
-# Setup various GTEST variables. TODO(chandlerc@google.com): When these are
-# used below, they should be used such that any pre-existing values always
-# trump values we set them to, so that they can be used to selectively override
-# details of the detection process.
-AC_ARG_VAR([GTEST_CONFIG],
-           [The exact path of Google Test's 'gtest-config' script.])
-AC_ARG_VAR([GTEST_CPPFLAGS],
-           [C-like preprocessor flags for Google Test.])
-AC_ARG_VAR([GTEST_CXXFLAGS],
-           [C++ compile flags for Google Test.])
-AC_ARG_VAR([GTEST_LDFLAGS],
-           [Linker path and option flags for Google Test.])
-AC_ARG_VAR([GTEST_LIBS],
-           [Library linking flags for Google Test.])
-AC_ARG_VAR([GTEST_VERSION],
-           [The version of Google Test available.])
-HAVE_BUILT_GTEST="no"
-
-GTEST_MIN_VERSION="1.7.0"
-
-AS_IF([test "x${enable_external_gtest}" = "xyes"],
-      [# Begin filling in variables as we are able.
-      AS_IF([test "x${with_gtest}" != "xyes"],
-            [AS_IF([test -x "${with_gtest}/scripts/gtest-config"],
-                   [GTEST_CONFIG="${with_gtest}/scripts/gtest-config"],
-                   [GTEST_CONFIG="${with_gtest}/bin/gtest-config"])
-            AS_IF([test -x "${GTEST_CONFIG}"], [],
-                  [AC_MSG_ERROR([dnl
-Unable to locate either a built or installed Google Test at '${with_gtest}'.])
-                  ])])
-
-      AS_IF([test -x "${GTEST_CONFIG}"], [],
-            [AC_PATH_PROG([GTEST_CONFIG], [gtest-config])])
-      AS_IF([test -x "${GTEST_CONFIG}"],
-            [AC_MSG_CHECKING([for Google Test version >= ${GTEST_MIN_VERSION}])
-            AS_IF([${GTEST_CONFIG} --min-version=${GTEST_MIN_VERSION}],
-                  [AC_MSG_RESULT([yes])
-                  HAVE_BUILT_GTEST="yes"],
-                  [AC_MSG_RESULT([no])])])])
-
-AS_IF([test "x${HAVE_BUILT_GTEST}" = "xyes"],
-      [GTEST_CPPFLAGS=`${GTEST_CONFIG} --cppflags`
-      GTEST_CXXFLAGS=`${GTEST_CONFIG} --cxxflags`
-      GTEST_LDFLAGS=`${GTEST_CONFIG} --ldflags`
-      GTEST_LIBS=`${GTEST_CONFIG} --libs`
-      GTEST_VERSION=`${GTEST_CONFIG} --version`],
-      [AC_CONFIG_SUBDIRS([../googletest])
-      # GTEST_CONFIG needs to be executable both in a Makefile environmont and
-      # in a shell script environment, so resolve an absolute path for it here.
-      GTEST_CONFIG="`pwd -P`/../googletest/scripts/gtest-config"
-      GTEST_CPPFLAGS='-I$(top_srcdir)/../googletest/include'
-      GTEST_CXXFLAGS='-g'
-      GTEST_LDFLAGS=''
-      GTEST_LIBS='$(top_builddir)/../googletest/lib/libgtest.la'
-      GTEST_VERSION="${GTEST_MIN_VERSION}"])
-
-# TODO(chandlerc@google.com) Check the types, structures, and other compiler
-# and architecture characteristics.
-
-# Output the generated files. No further autoconf macros may be used.
-AC_OUTPUT
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CheatSheet.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CheatSheet.md
deleted file mode 100644
index ef4451b8..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CheatSheet.md
+++ /dev/null
@@ -1,562 +0,0 @@
-
-
-# Defining a Mock Class #
-
-## Mocking a Normal Class ##
-
-Given
-```
-class Foo {
-  ...
-  virtual ~Foo();
-  virtual int GetSize() const = 0;
-  virtual string Describe(const char* name) = 0;
-  virtual string Describe(int type) = 0;
-  virtual bool Process(Bar elem, int count) = 0;
-};
-```
-(note that `~Foo()` **must** be virtual) we can define its mock as
-```
-#include "gmock/gmock.h"
-
-class MockFoo : public Foo {
-  MOCK_CONST_METHOD0(GetSize, int());
-  MOCK_METHOD1(Describe, string(const char* name));
-  MOCK_METHOD1(Describe, string(int type));
-  MOCK_METHOD2(Process, bool(Bar elem, int count));
-};
-```
-
-To create a "nice" mock object which ignores all uninteresting calls,
-or a "strict" mock object, which treats them as failures:
-```
-NiceMock<MockFoo> nice_foo;     // The type is a subclass of MockFoo.
-StrictMock<MockFoo> strict_foo; // The type is a subclass of MockFoo.
-```
-
-## Mocking a Class Template ##
-
-To mock
-```
-template <typename Elem>
-class StackInterface {
- public:
-  ...
-  virtual ~StackInterface();
-  virtual int GetSize() const = 0;
-  virtual void Push(const Elem& x) = 0;
-};
-```
-(note that `~StackInterface()` **must** be virtual) just append `_T` to the `MOCK_*` macros:
-```
-template <typename Elem>
-class MockStack : public StackInterface<Elem> {
- public:
-  ...
-  MOCK_CONST_METHOD0_T(GetSize, int());
-  MOCK_METHOD1_T(Push, void(const Elem& x));
-};
-```
-
-## Specifying Calling Conventions for Mock Functions ##
-
-If your mock function doesn't use the default calling convention, you
-can specify it by appending `_WITH_CALLTYPE` to any of the macros
-described in the previous two sections and supplying the calling
-convention as the first argument to the macro. For example,
-```
-  MOCK_METHOD_1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int n));
-  MOCK_CONST_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, Bar, int(double x, double y));
-```
-where `STDMETHODCALLTYPE` is defined by `<objbase.h>` on Windows.
-
-# Using Mocks in Tests #
-
-The typical flow is:
-  1. Import the Google Mock names you need to use. All Google Mock names are in the `testing` namespace unless they are macros or otherwise noted.
-  1. Create the mock objects.
-  1. Optionally, set the default actions of the mock objects.
-  1. Set your expectations on the mock objects (How will they be called? What wil they do?).
-  1. Exercise code that uses the mock objects; if necessary, check the result using [Google Test](../../googletest/) assertions.
-  1. When a mock objects is destructed, Google Mock automatically verifies that all expectations on it have been satisfied.
-
-Here is an example:
-```
-using ::testing::Return;                            // #1
-
-TEST(BarTest, DoesThis) {
-  MockFoo foo;                                    // #2
-
-  ON_CALL(foo, GetSize())                         // #3
-      .WillByDefault(Return(1));
-  // ... other default actions ...
-
-  EXPECT_CALL(foo, Describe(5))                   // #4
-      .Times(3)
-      .WillRepeatedly(Return("Category 5"));
-  // ... other expectations ...
-
-  EXPECT_EQ("good", MyProductionFunction(&foo));  // #5
-}                                                 // #6
-```
-
-# Setting Default Actions #
-
-Google Mock has a **built-in default action** for any function that
-returns `void`, `bool`, a numeric value, or a pointer.
-
-To customize the default action for functions with return type `T` globally:
-```
-using ::testing::DefaultValue;
-
-// Sets the default value to be returned. T must be CopyConstructible.
-DefaultValue<T>::Set(value);
-// Sets a factory. Will be invoked on demand. T must be MoveConstructible.
-//   T MakeT();
-DefaultValue<T>::SetFactory(&MakeT);
-// ... use the mocks ...
-// Resets the default value.
-DefaultValue<T>::Clear();
-```
-
-To customize the default action for a particular method, use `ON_CALL()`:
-```
-ON_CALL(mock_object, method(matchers))
-    .With(multi_argument_matcher)  ?
-    .WillByDefault(action);
-```
-
-# Setting Expectations #
-
-`EXPECT_CALL()` sets **expectations** on a mock method (How will it be
-called? What will it do?):
-```
-EXPECT_CALL(mock_object, method(matchers))
-    .With(multi_argument_matcher)  ?
-    .Times(cardinality)            ?
-    .InSequence(sequences)         *
-    .After(expectations)           *
-    .WillOnce(action)              *
-    .WillRepeatedly(action)        ?
-    .RetiresOnSaturation();        ?
-```
-
-If `Times()` is omitted, the cardinality is assumed to be:
-
-  * `Times(1)` when there is neither `WillOnce()` nor `WillRepeatedly()`;
-  * `Times(n)` when there are `n WillOnce()`s but no `WillRepeatedly()`, where `n` >= 1; or
-  * `Times(AtLeast(n))` when there are `n WillOnce()`s and a `WillRepeatedly()`, where `n` >= 0.
-
-A method with no `EXPECT_CALL()` is free to be invoked _any number of times_, and the default action will be taken each time.
-
-# Matchers #
-
-A **matcher** matches a _single_ argument.  You can use it inside
-`ON_CALL()` or `EXPECT_CALL()`, or use it to validate a value
-directly:
-
-| `EXPECT_THAT(value, matcher)` | Asserts that `value` matches `matcher`. |
-|:------------------------------|:----------------------------------------|
-| `ASSERT_THAT(value, matcher)` | The same as `EXPECT_THAT(value, matcher)`, except that it generates a **fatal** failure. |
-
-Built-in matchers (where `argument` is the function argument) are
-divided into several categories:
-
-## Wildcard ##
-|`_`|`argument` can be any value of the correct type.|
-|:--|:-----------------------------------------------|
-|`A<type>()` or `An<type>()`|`argument` can be any value of type `type`.     |
-
-## Generic Comparison ##
-
-|`Eq(value)` or `value`|`argument == value`|
-|:---------------------|:------------------|
-|`Ge(value)`           |`argument >= value`|
-|`Gt(value)`           |`argument > value` |
-|`Le(value)`           |`argument <= value`|
-|`Lt(value)`           |`argument < value` |
-|`Ne(value)`           |`argument != value`|
-|`IsNull()`            |`argument` is a `NULL` pointer (raw or smart).|
-|`NotNull()`           |`argument` is a non-null pointer (raw or smart).|
-|`Ref(variable)`       |`argument` is a reference to `variable`.|
-|`TypedEq<type>(value)`|`argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded.|
-
-Except `Ref()`, these matchers make a _copy_ of `value` in case it's
-modified or destructed later. If the compiler complains that `value`
-doesn't have a public copy constructor, try wrap it in `ByRef()`,
-e.g. `Eq(ByRef(non_copyable_value))`. If you do that, make sure
-`non_copyable_value` is not changed afterwards, or the meaning of your
-matcher will be changed.
-
-## Floating-Point Matchers ##
-
-|`DoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as unequal.|
-|:-------------------|:----------------------------------------------------------------------------------------------|
-|`FloatEq(a_float)`  |`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal.  |
-|`NanSensitiveDoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal.  |
-|`NanSensitiveFloatEq(a_float)`|`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal.    |
-
-The above matchers use ULP-based comparison (the same as used in
-[Google Test](../../googletest/)). They
-automatically pick a reasonable error bound based on the absolute
-value of the expected value.  `DoubleEq()` and `FloatEq()` conform to
-the IEEE standard, which requires comparing two NaNs for equality to
-return false. The `NanSensitive*` version instead treats two NaNs as
-equal, which is often what a user wants.
-
-|`DoubleNear(a_double, max_abs_error)`|`argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as unequal.|
-|:------------------------------------|:--------------------------------------------------------------------------------------------------------------------|
-|`FloatNear(a_float, max_abs_error)`  |`argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as unequal.  |
-|`NanSensitiveDoubleNear(a_double, max_abs_error)`|`argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as equal.  |
-|`NanSensitiveFloatNear(a_float, max_abs_error)`|`argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as equal.    |
-
-## String Matchers ##
-
-The `argument` can be either a C string or a C++ string object:
-
-|`ContainsRegex(string)`|`argument` matches the given regular expression.|
-|:----------------------|:-----------------------------------------------|
-|`EndsWith(suffix)`     |`argument` ends with string `suffix`.           |
-|`HasSubstr(string)`    |`argument` contains `string` as a sub-string.   |
-|`MatchesRegex(string)` |`argument` matches the given regular expression with the match starting at the first character and ending at the last character.|
-|`StartsWith(prefix)`   |`argument` starts with string `prefix`.         |
-|`StrCaseEq(string)`    |`argument` is equal to `string`, ignoring case. |
-|`StrCaseNe(string)`    |`argument` is not equal to `string`, ignoring case.|
-|`StrEq(string)`        |`argument` is equal to `string`.                |
-|`StrNe(string)`        |`argument` is not equal to `string`.            |
-
-`ContainsRegex()` and `MatchesRegex()` use the regular expression
-syntax defined
-[here](../../googletest/docs/AdvancedGuide.md#regular-expression-syntax).
-`StrCaseEq()`, `StrCaseNe()`, `StrEq()`, and `StrNe()` work for wide
-strings as well.
-
-## Container Matchers ##
-
-Most STL-style containers support `==`, so you can use
-`Eq(expected_container)` or simply `expected_container` to match a
-container exactly.   If you want to write the elements in-line,
-match them more flexibly, or get more informative messages, you can use:
-
-| `ContainerEq(container)` | The same as `Eq(container)` except that the failure message also includes which elements are in one container but not the other. |
-|:-------------------------|:---------------------------------------------------------------------------------------------------------------------------------|
-| `Contains(e)`            | `argument` contains an element that matches `e`, which can be either a value or a matcher.                                       |
-| `Each(e)`                | `argument` is a container where _every_ element matches `e`, which can be either a value or a matcher.                           |
-| `ElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, where the i-th element matches `ei`, which can be a value or a matcher. 0 to 10 arguments are allowed. |
-| `ElementsAreArray({ e0, e1, ..., en })`, `ElementsAreArray(array)`, or `ElementsAreArray(array, count)` | The same as `ElementsAre()` except that the expected element values/matchers come from an initializer list, STL-style container, or C-style array. |
-| `IsEmpty()`              | `argument` is an empty container (`container.empty()`).                                                                          |
-| `Pointwise(m, container)` | `argument` contains the same number of elements as in `container`, and for all i, (the i-th element in `argument`, the i-th element in `container`) match `m`, which is a matcher on 2-tuples. E.g. `Pointwise(Le(), upper_bounds)` verifies that each element in `argument` doesn't exceed the corresponding element in `upper_bounds`. See more detail below. |
-| `SizeIs(m)`              | `argument` is a container whose size matches `m`. E.g. `SizeIs(2)` or `SizeIs(Lt(2))`.                                           |
-| `UnorderedElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, and under some permutation each element matches an `ei` (for a different `i`), which can be a value or a matcher. 0 to 10 arguments are allowed. |
-| `UnorderedElementsAreArray({ e0, e1, ..., en })`, `UnorderedElementsAreArray(array)`, or `UnorderedElementsAreArray(array, count)` | The same as `UnorderedElementsAre()` except that the expected element values/matchers come from an initializer list, STL-style container, or C-style array. |
-| `WhenSorted(m)`          | When `argument` is sorted using the `<` operator, it matches container matcher `m`. E.g. `WhenSorted(UnorderedElementsAre(1, 2, 3))` verifies that `argument` contains elements `1`, `2`, and `3`, ignoring order. |
-| `WhenSortedBy(comparator, m)` | The same as `WhenSorted(m)`, except that the given comparator instead of `<` is used to sort `argument`. E.g. `WhenSortedBy(std::greater<int>(), ElementsAre(3, 2, 1))`. |
-
-Notes:
-
-  * These matchers can also match:
-    1. a native array passed by reference (e.g. in `Foo(const int (&a)[5])`), and
-    1. an array passed as a pointer and a count (e.g. in `Bar(const T* buffer, int len)` -- see [Multi-argument Matchers](#Multiargument_Matchers.md)).
-  * The array being matched may be multi-dimensional (i.e. its elements can be arrays).
-  * `m` in `Pointwise(m, ...)` should be a matcher for `::testing::tuple<T, U>` where `T` and `U` are the element type of the actual container and the expected container, respectively. For example, to compare two `Foo` containers where `Foo` doesn't support `operator==` but has an `Equals()` method, one might write:
-
-```
-using ::testing::get;
-MATCHER(FooEq, "") {
-  return get<0>(arg).Equals(get<1>(arg));
-}
-...
-EXPECT_THAT(actual_foos, Pointwise(FooEq(), expected_foos));
-```
-
-## Member Matchers ##
-
-|`Field(&class::field, m)`|`argument.field` (or `argument->field` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
-|:------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------|
-|`Key(e)`                 |`argument.first` matches `e`, which can be either a value or a matcher. E.g. `Contains(Key(Le(5)))` can verify that a `map` contains a key `<= 5`.|
-|`Pair(m1, m2)`           |`argument` is an `std::pair` whose `first` field matches `m1` and `second` field matches `m2`.                                                |
-|`Property(&class::property, m)`|`argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
-
-## Matching the Result of a Function or Functor ##
-
-|`ResultOf(f, m)`|`f(argument)` matches matcher `m`, where `f` is a function or functor.|
-|:---------------|:---------------------------------------------------------------------|
-
-## Pointer Matchers ##
-
-|`Pointee(m)`|`argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`.|
-|:-----------|:-----------------------------------------------------------------------------------------------|
-|`WhenDynamicCastTo<T>(m)`| when `argument` is passed through `dynamic_cast<T>()`, it matches matcher `m`.                 |
-
-## Multiargument Matchers ##
-
-Technically, all matchers match a _single_ value. A "multi-argument"
-matcher is just one that matches a _tuple_. The following matchers can
-be used to match a tuple `(x, y)`:
-
-|`Eq()`|`x == y`|
-|:-----|:-------|
-|`Ge()`|`x >= y`|
-|`Gt()`|`x > y` |
-|`Le()`|`x <= y`|
-|`Lt()`|`x < y` |
-|`Ne()`|`x != y`|
-
-You can use the following selectors to pick a subset of the arguments
-(or reorder them) to participate in the matching:
-
-|`AllArgs(m)`|Equivalent to `m`. Useful as syntactic sugar in `.With(AllArgs(m))`.|
-|:-----------|:-------------------------------------------------------------------|
-|`Args<N1, N2, ..., Nk>(m)`|The tuple of the `k` selected (using 0-based indices) arguments matches `m`, e.g. `Args<1, 2>(Eq())`.|
-
-## Composite Matchers ##
-
-You can make a matcher from one or more other matchers:
-
-|`AllOf(m1, m2, ..., mn)`|`argument` matches all of the matchers `m1` to `mn`.|
-|:-----------------------|:---------------------------------------------------|
-|`AnyOf(m1, m2, ..., mn)`|`argument` matches at least one of the matchers `m1` to `mn`.|
-|`Not(m)`                |`argument` doesn't match matcher `m`.               |
-
-## Adapters for Matchers ##
-
-|`MatcherCast<T>(m)`|casts matcher `m` to type `Matcher<T>`.|
-|:------------------|:--------------------------------------|
-|`SafeMatcherCast<T>(m)`| [safely casts](CookBook.md#casting-matchers) matcher `m` to type `Matcher<T>`. |
-|`Truly(predicate)` |`predicate(argument)` returns something considered by C++ to be true, where `predicate` is a function or functor.|
-
-## Matchers as Predicates ##
-
-|`Matches(m)(value)`|evaluates to `true` if `value` matches `m`. You can use `Matches(m)` alone as a unary functor.|
-|:------------------|:---------------------------------------------------------------------------------------------|
-|`ExplainMatchResult(m, value, result_listener)`|evaluates to `true` if `value` matches `m`, explaining the result to `result_listener`.       |
-|`Value(value, m)`  |evaluates to `true` if `value` matches `m`.                                                   |
-
-## Defining Matchers ##
-
-| `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. |
-|:-------------------------------------------------|:------------------------------------------------------|
-| `MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; }` | Defines a macher `IsDivisibleBy(n)` to match a number divisible by `n`. |
-| `MATCHER_P2(IsBetween, a, b, std::string(negation ? "isn't" : "is") + " between " + PrintToString(a) + " and " + PrintToString(b)) { return a <= arg && arg <= b; }` | Defines a matcher `IsBetween(a, b)` to match a value in the range [`a`, `b`]. |
-
-**Notes:**
-
-  1. The `MATCHER*` macros cannot be used inside a function or class.
-  1. The matcher body must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters).
-  1. You can use `PrintToString(x)` to convert a value `x` of any type to a string.
-
-## Matchers as Test Assertions ##
-
-|`ASSERT_THAT(expression, m)`|Generates a [fatal failure](../../googletest/docs/Primer.md#assertions) if the value of `expression` doesn't match matcher `m`.|
-|:---------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------|
-|`EXPECT_THAT(expression, m)`|Generates a non-fatal failure if the value of `expression` doesn't match matcher `m`.                                                          |
-
-# Actions #
-
-**Actions** specify what a mock function should do when invoked.
-
-## Returning a Value ##
-
-|`Return()`|Return from a `void` mock function.|
-|:---------|:----------------------------------|
-|`Return(value)`|Return `value`. If the type of `value` is different to the mock function's return type, `value` is converted to the latter type <i>at the time the expectation is set</i>, not when the action is executed.|
-|`ReturnArg<N>()`|Return the `N`-th (0-based) argument.|
-|`ReturnNew<T>(a1, ..., ak)`|Return `new T(a1, ..., ak)`; a different object is created each time.|
-|`ReturnNull()`|Return a null pointer.             |
-|`ReturnPointee(ptr)`|Return the value pointed to by `ptr`.|
-|`ReturnRef(variable)`|Return a reference to `variable`.  |
-|`ReturnRefOfCopy(value)`|Return a reference to a copy of `value`; the copy lives as long as the action.|
-
-## Side Effects ##
-
-|`Assign(&variable, value)`|Assign `value` to variable.|
-|:-------------------------|:--------------------------|
-| `DeleteArg<N>()`         | Delete the `N`-th (0-based) argument, which must be a pointer. |
-| `SaveArg<N>(pointer)`    | Save the `N`-th (0-based) argument to `*pointer`. |
-| `SaveArgPointee<N>(pointer)` | Save the value pointed to by the `N`-th (0-based) argument to `*pointer`. |
-| `SetArgReferee<N>(value)` |	Assign value to the variable referenced by the `N`-th (0-based) argument. |
-|`SetArgPointee<N>(value)` |Assign `value` to the variable pointed by the `N`-th (0-based) argument.|
-|`SetArgumentPointee<N>(value)`|Same as `SetArgPointee<N>(value)`. Deprecated. Will be removed in v1.7.0.|
-|`SetArrayArgument<N>(first, last)`|Copies the elements in source range [`first`, `last`) to the array pointed to by the `N`-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.|
-|`SetErrnoAndReturn(error, value)`|Set `errno` to `error` and return `value`.|
-|`Throw(exception)`        |Throws the given exception, which can be any copyable value. Available since v1.1.0.|
-
-## Using a Function or a Functor as an Action ##
-
-|`Invoke(f)`|Invoke `f` with the arguments passed to the mock function, where `f` can be a global/static function or a functor.|
-|:----------|:-----------------------------------------------------------------------------------------------------------------|
-|`Invoke(object_pointer, &class::method)`|Invoke the {method on the object with the arguments passed to the mock function.                                  |
-|`InvokeWithoutArgs(f)`|Invoke `f`, which can be a global/static function or a functor. `f` must take no arguments.                       |
-|`InvokeWithoutArgs(object_pointer, &class::method)`|Invoke the method on the object, which takes no arguments.                                                        |
-|`InvokeArgument<N>(arg1, arg2, ..., argk)`|Invoke the mock function's `N`-th (0-based) argument, which must be a function or a functor, with the `k` arguments.|
-
-The return value of the invoked function is used as the return value
-of the action.
-
-When defining a function or functor to be used with `Invoke*()`, you can declare any unused parameters as `Unused`:
-```
-  double Distance(Unused, double x, double y) { return sqrt(x*x + y*y); }
-  ...
-  EXPECT_CALL(mock, Foo("Hi", _, _)).WillOnce(Invoke(Distance));
-```
-
-In `InvokeArgument<N>(...)`, if an argument needs to be passed by reference, wrap it inside `ByRef()`. For example,
-```
-  InvokeArgument<2>(5, string("Hi"), ByRef(foo))
-```
-calls the mock function's #2 argument, passing to it `5` and `string("Hi")` by value, and `foo` by reference.
-
-## Default Action ##
-
-|`DoDefault()`|Do the default action (specified by `ON_CALL()` or the built-in one).|
-|:------------|:--------------------------------------------------------------------|
-
-**Note:** due to technical reasons, `DoDefault()` cannot be used inside  a composite action - trying to do so will result in a run-time error.
-
-## Composite Actions ##
-
-|`DoAll(a1, a2, ..., an)`|Do all actions `a1` to `an` and return the result of `an` in each invocation. The first `n - 1` sub-actions must return void. |
-|:-----------------------|:-----------------------------------------------------------------------------------------------------------------------------|
-|`IgnoreResult(a)`       |Perform action `a` and ignore its result. `a` must not return void.                                                           |
-|`WithArg<N>(a)`         |Pass the `N`-th (0-based) argument of the mock function to action `a` and perform it.                                         |
-|`WithArgs<N1, N2, ..., Nk>(a)`|Pass the selected (0-based) arguments of the mock function to action `a` and perform it.                                      |
-|`WithoutArgs(a)`        |Perform action `a` without any arguments.                                                                                     |
-
-## Defining Actions ##
-
-| `ACTION(Sum) { return arg0 + arg1; }` | Defines an action `Sum()` to return the sum of the mock function's argument #0 and #1. |
-|:--------------------------------------|:---------------------------------------------------------------------------------------|
-| `ACTION_P(Plus, n) { return arg0 + n; }` | Defines an action `Plus(n)` to return the sum of the mock function's argument #0 and `n`. |
-| `ACTION_Pk(Foo, p1, ..., pk) { statements; }` | Defines a parameterized action `Foo(p1, ..., pk)` to execute the given `statements`.   |
-
-The `ACTION*` macros cannot be used inside a function or class.
-
-# Cardinalities #
-
-These are used in `Times()` to specify how many times a mock function will be called:
-
-|`AnyNumber()`|The function can be called any number of times.|
-|:------------|:----------------------------------------------|
-|`AtLeast(n)` |The call is expected at least `n` times.       |
-|`AtMost(n)`  |The call is expected at most `n` times.        |
-|`Between(m, n)`|The call is expected between `m` and `n` (inclusive) times.|
-|`Exactly(n) or n`|The call is expected exactly `n` times. In particular, the call should never happen when `n` is 0.|
-
-# Expectation Order #
-
-By default, the expectations can be matched in _any_ order.  If some
-or all expectations must be matched in a given order, there are two
-ways to specify it.  They can be used either independently or
-together.
-
-## The After Clause ##
-
-```
-using ::testing::Expectation;
-...
-Expectation init_x = EXPECT_CALL(foo, InitX());
-Expectation init_y = EXPECT_CALL(foo, InitY());
-EXPECT_CALL(foo, Bar())
-    .After(init_x, init_y);
-```
-says that `Bar()` can be called only after both `InitX()` and
-`InitY()` have been called.
-
-If you don't know how many pre-requisites an expectation has when you
-write it, you can use an `ExpectationSet` to collect them:
-
-```
-using ::testing::ExpectationSet;
-...
-ExpectationSet all_inits;
-for (int i = 0; i < element_count; i++) {
-  all_inits += EXPECT_CALL(foo, InitElement(i));
-}
-EXPECT_CALL(foo, Bar())
-    .After(all_inits);
-```
-says that `Bar()` can be called only after all elements have been
-initialized (but we don't care about which elements get initialized
-before the others).
-
-Modifying an `ExpectationSet` after using it in an `.After()` doesn't
-affect the meaning of the `.After()`.
-
-## Sequences ##
-
-When you have a long chain of sequential expectations, it's easier to
-specify the order using **sequences**, which don't require you to given
-each expectation in the chain a different name.  <i>All expected<br>
-calls</i> in the same sequence must occur in the order they are
-specified.
-
-```
-using ::testing::Sequence;
-Sequence s1, s2;
-...
-EXPECT_CALL(foo, Reset())
-    .InSequence(s1, s2)
-    .WillOnce(Return(true));
-EXPECT_CALL(foo, GetSize())
-    .InSequence(s1)
-    .WillOnce(Return(1));
-EXPECT_CALL(foo, Describe(A<const char*>()))
-    .InSequence(s2)
-    .WillOnce(Return("dummy"));
-```
-says that `Reset()` must be called before _both_ `GetSize()` _and_
-`Describe()`, and the latter two can occur in any order.
-
-To put many expectations in a sequence conveniently:
-```
-using ::testing::InSequence;
-{
-  InSequence dummy;
-
-  EXPECT_CALL(...)...;
-  EXPECT_CALL(...)...;
-  ...
-  EXPECT_CALL(...)...;
-}
-```
-says that all expected calls in the scope of `dummy` must occur in
-strict order. The name `dummy` is irrelevant.)
-
-# Verifying and Resetting a Mock #
-
-Google Mock will verify the expectations on a mock object when it is destructed, or you can do it earlier:
-```
-using ::testing::Mock;
-...
-// Verifies and removes the expectations on mock_obj;
-// returns true iff successful.
-Mock::VerifyAndClearExpectations(&mock_obj);
-...
-// Verifies and removes the expectations on mock_obj;
-// also removes the default actions set by ON_CALL();
-// returns true iff successful.
-Mock::VerifyAndClear(&mock_obj);
-```
-
-You can also tell Google Mock that a mock object can be leaked and doesn't
-need to be verified:
-```
-Mock::AllowLeak(&mock_obj);
-```
-
-# Mock Classes #
-
-Google Mock defines a convenient mock class template
-```
-class MockFunction<R(A1, ..., An)> {
- public:
-  MOCK_METHODn(Call, R(A1, ..., An));
-};
-```
-See this [recipe](CookBook.md#using-check-points) for one application of it.
-
-# Flags #
-
-| `--gmock_catch_leaked_mocks=0` | Don't report leaked mock objects as failures. |
-|:-------------------------------|:----------------------------------------------|
-| `--gmock_verbose=LEVEL`        | Sets the default verbosity level (`info`, `warning`, or `error`) of Google Mock messages. |
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CookBook.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CookBook.md
deleted file mode 100644
index 0460d357..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/CookBook.md
+++ /dev/null
@@ -1,3675 +0,0 @@
-
-
-You can find recipes for using Google Mock here. If you haven't yet,
-please read the [ForDummies](ForDummies.md) document first to make sure you understand
-the basics.
-
-**Note:** Google Mock lives in the `testing` name space. For
-readability, it is recommended to write `using ::testing::Foo;` once in
-your file before using the name `Foo` defined by Google Mock. We omit
-such `using` statements in this page for brevity, but you should do it
-in your own code.
-
-# Creating Mock Classes #
-
-## Mocking Private or Protected Methods ##
-
-You must always put a mock method definition (`MOCK_METHOD*`) in a
-`public:` section of the mock class, regardless of the method being
-mocked being `public`, `protected`, or `private` in the base class.
-This allows `ON_CALL` and `EXPECT_CALL` to reference the mock function
-from outside of the mock class.  (Yes, C++ allows a subclass to change
-the access level of a virtual function in the base class.)  Example:
-
-```
-class Foo {
- public:
-  ...
-  virtual bool Transform(Gadget* g) = 0;
-
- protected:
-  virtual void Resume();
-
- private:
-  virtual int GetTimeOut();
-};
-
-class MockFoo : public Foo {
- public:
-  ...
-  MOCK_METHOD1(Transform, bool(Gadget* g));
-
-  // The following must be in the public section, even though the
-  // methods are protected or private in the base class.
-  MOCK_METHOD0(Resume, void());
-  MOCK_METHOD0(GetTimeOut, int());
-};
-```
-
-## Mocking Overloaded Methods ##
-
-You can mock overloaded functions as usual. No special attention is required:
-
-```
-class Foo {
-  ...
-
-  // Must be virtual as we'll inherit from Foo.
-  virtual ~Foo();
-
-  // Overloaded on the types and/or numbers of arguments.
-  virtual int Add(Element x);
-  virtual int Add(int times, Element x);
-
-  // Overloaded on the const-ness of this object.
-  virtual Bar& GetBar();
-  virtual const Bar& GetBar() const;
-};
-
-class MockFoo : public Foo {
-  ...
-  MOCK_METHOD1(Add, int(Element x));
-  MOCK_METHOD2(Add, int(int times, Element x);
-
-  MOCK_METHOD0(GetBar, Bar&());
-  MOCK_CONST_METHOD0(GetBar, const Bar&());
-};
-```
-
-**Note:** if you don't mock all versions of the overloaded method, the
-compiler will give you a warning about some methods in the base class
-being hidden. To fix that, use `using` to bring them in scope:
-
-```
-class MockFoo : public Foo {
-  ...
-  using Foo::Add;
-  MOCK_METHOD1(Add, int(Element x));
-  // We don't want to mock int Add(int times, Element x);
-  ...
-};
-```
-
-## Mocking Class Templates ##
-
-To mock a class template, append `_T` to the `MOCK_*` macros:
-
-```
-template <typename Elem>
-class StackInterface {
-  ...
-  // Must be virtual as we'll inherit from StackInterface.
-  virtual ~StackInterface();
-
-  virtual int GetSize() const = 0;
-  virtual void Push(const Elem& x) = 0;
-};
-
-template <typename Elem>
-class MockStack : public StackInterface<Elem> {
-  ...
-  MOCK_CONST_METHOD0_T(GetSize, int());
-  MOCK_METHOD1_T(Push, void(const Elem& x));
-};
-```
-
-## Mocking Nonvirtual Methods ##
-
-Google Mock can mock non-virtual functions to be used in what we call _hi-perf
-dependency injection_.
-
-In this case, instead of sharing a common base class with the real
-class, your mock class will be _unrelated_ to the real class, but
-contain methods with the same signatures.  The syntax for mocking
-non-virtual methods is the _same_ as mocking virtual methods:
-
-```
-// A simple packet stream class.  None of its members is virtual.
-class ConcretePacketStream {
- public:
-  void AppendPacket(Packet* new_packet);
-  const Packet* GetPacket(size_t packet_number) const;
-  size_t NumberOfPackets() const;
-  ...
-};
-
-// A mock packet stream class.  It inherits from no other, but defines
-// GetPacket() and NumberOfPackets().
-class MockPacketStream {
- public:
-  MOCK_CONST_METHOD1(GetPacket, const Packet*(size_t packet_number));
-  MOCK_CONST_METHOD0(NumberOfPackets, size_t());
-  ...
-};
-```
-
-Note that the mock class doesn't define `AppendPacket()`, unlike the
-real class. That's fine as long as the test doesn't need to call it.
-
-Next, you need a way to say that you want to use
-`ConcretePacketStream` in production code, and use `MockPacketStream`
-in tests.  Since the functions are not virtual and the two classes are
-unrelated, you must specify your choice at _compile time_ (as opposed
-to run time).
-
-One way to do it is to templatize your code that needs to use a packet
-stream.  More specifically, you will give your code a template type
-argument for the type of the packet stream.  In production, you will
-instantiate your template with `ConcretePacketStream` as the type
-argument.  In tests, you will instantiate the same template with
-`MockPacketStream`.  For example, you may write:
-
-```
-template <class PacketStream>
-void CreateConnection(PacketStream* stream) { ... }
-
-template <class PacketStream>
-class PacketReader {
- public:
-  void ReadPackets(PacketStream* stream, size_t packet_num);
-};
-```
-
-Then you can use `CreateConnection<ConcretePacketStream>()` and
-`PacketReader<ConcretePacketStream>` in production code, and use
-`CreateConnection<MockPacketStream>()` and
-`PacketReader<MockPacketStream>` in tests.
-
-```
-  MockPacketStream mock_stream;
-  EXPECT_CALL(mock_stream, ...)...;
-  .. set more expectations on mock_stream ...
-  PacketReader<MockPacketStream> reader(&mock_stream);
-  ... exercise reader ...
-```
-
-## Mocking Free Functions ##
-
-It's possible to use Google Mock to mock a free function (i.e. a
-C-style function or a static method).  You just need to rewrite your
-code to use an interface (abstract class).
-
-Instead of calling a free function (say, `OpenFile`) directly,
-introduce an interface for it and have a concrete subclass that calls
-the free function:
-
-```
-class FileInterface {
- public:
-  ...
-  virtual bool Open(const char* path, const char* mode) = 0;
-};
-
-class File : public FileInterface {
- public:
-  ...
-  virtual bool Open(const char* path, const char* mode) {
-    return OpenFile(path, mode);
-  }
-};
-```
-
-Your code should talk to `FileInterface` to open a file.  Now it's
-easy to mock out the function.
-
-This may seem much hassle, but in practice you often have multiple
-related functions that you can put in the same interface, so the
-per-function syntactic overhead will be much lower.
-
-If you are concerned about the performance overhead incurred by
-virtual functions, and profiling confirms your concern, you can
-combine this with the recipe for [mocking non-virtual methods](#mocking-nonvirtual-methods).
-
-## The Nice, the Strict, and the Naggy ##
-
-If a mock method has no `EXPECT_CALL` spec but is called, Google Mock
-will print a warning about the "uninteresting call". The rationale is:
-
-  * New methods may be added to an interface after a test is written. We shouldn't fail a test just because a method it doesn't know about is called.
-  * However, this may also mean there's a bug in the test, so Google Mock shouldn't be silent either. If the user believes these calls are harmless, he can add an `EXPECT_CALL()` to suppress the warning.
-
-However, sometimes you may want to suppress all "uninteresting call"
-warnings, while sometimes you may want the opposite, i.e. to treat all
-of them as errors. Google Mock lets you make the decision on a
-per-mock-object basis.
-
-Suppose your test uses a mock class `MockFoo`:
-
-```
-TEST(...) {
-  MockFoo mock_foo;
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-}
-```
-
-If a method of `mock_foo` other than `DoThis()` is called, it will be
-reported by Google Mock as a warning. However, if you rewrite your
-test to use `NiceMock<MockFoo>` instead, the warning will be gone,
-resulting in a cleaner test output:
-
-```
-using ::testing::NiceMock;
-
-TEST(...) {
-  NiceMock<MockFoo> mock_foo;
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-}
-```
-
-`NiceMock<MockFoo>` is a subclass of `MockFoo`, so it can be used
-wherever `MockFoo` is accepted.
-
-It also works if `MockFoo`'s constructor takes some arguments, as
-`NiceMock<MockFoo>` "inherits" `MockFoo`'s constructors:
-
-```
-using ::testing::NiceMock;
-
-TEST(...) {
-  NiceMock<MockFoo> mock_foo(5, "hi");  // Calls MockFoo(5, "hi").
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-}
-```
-
-The usage of `StrictMock` is similar, except that it makes all
-uninteresting calls failures:
-
-```
-using ::testing::StrictMock;
-
-TEST(...) {
-  StrictMock<MockFoo> mock_foo;
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-
-  // The test will fail if a method of mock_foo other than DoThis()
-  // is called.
-}
-```
-
-There are some caveats though (I don't like them just as much as the
-next guy, but sadly they are side effects of C++'s limitations):
-
-  1. `NiceMock<MockFoo>` and `StrictMock<MockFoo>` only work 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` and `StrictMock` (e.g. `NiceMock<StrictMock<MockFoo> >`) is **not** supported.
-  1. The constructors of the base mock (`MockFoo`) cannot have arguments passed by non-const reference, which happens to be banned by the [Google C++ style guide](http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml).
-  1. During the constructor or destructor of `MockFoo`, the mock object is _not_ nice or strict.  This may cause surprises if the constructor or destructor calls a mock method on `this` object. (This behavior, however, is consistent with C++'s general rule: if a constructor or destructor calls a virtual method of `this` object, that method is treated as non-virtual.  In other words, to the base class's constructor or destructor, `this` object behaves like an instance of the base class, not the derived class.  This rule is required for safety.  Otherwise a base constructor may use members of a derived class before they are initialized, or a base destructor may use members of a derived class after they have been destroyed.)
-
-Finally, you should be **very cautious** about when to use naggy or strict mocks, as they tend to make tests more brittle and harder to maintain. When you refactor your code without changing its externally visible behavior, ideally you should't need to update any tests. If your code interacts with a naggy mock, however, you may start to get spammed with warnings as the result of your change. Worse, if your code interacts with a strict mock, your tests may start to fail and you'll be forced to fix them. Our general recommendation is to use nice mocks (not yet the default) most of the time, use naggy mocks (the current default) when developing or debugging tests, and use strict mocks only as the last resort.
-
-## Simplifying the Interface without Breaking Existing Code ##
-
-Sometimes a method has a long list of arguments that is mostly
-uninteresting. For example,
-
-```
-class LogSink {
- public:
-  ...
-  virtual void send(LogSeverity severity, const char* full_filename,
-                    const char* base_filename, int line,
-                    const struct tm* tm_time,
-                    const char* message, size_t message_len) = 0;
-};
-```
-
-This method's argument list is lengthy and hard to work with (let's
-say that the `message` argument is not even 0-terminated). If we mock
-it as is, using the mock will be awkward. If, however, we try to
-simplify this interface, we'll need to fix all clients depending on
-it, which is often infeasible.
-
-The trick is to re-dispatch the method in the mock class:
-
-```
-class ScopedMockLog : public LogSink {
- public:
-  ...
-  virtual void send(LogSeverity severity, const char* full_filename,
-                    const char* base_filename, int line, const tm* tm_time,
-                    const char* message, size_t message_len) {
-    // We are only interested in the log severity, full file name, and
-    // log message.
-    Log(severity, full_filename, std::string(message, message_len));
-  }
-
-  // Implements the mock method:
-  //
-  //   void Log(LogSeverity severity,
-  //            const string& file_path,
-  //            const string& message);
-  MOCK_METHOD3(Log, void(LogSeverity severity, const string& file_path,
-                         const string& message));
-};
-```
-
-By defining a new mock method with a trimmed argument list, we make
-the mock class much more user-friendly.
-
-## Alternative to Mocking Concrete Classes ##
-
-Often you may find yourself using classes that don't implement
-interfaces. In order to test your code that uses such a class (let's
-call it `Concrete`), you may be tempted to make the methods of
-`Concrete` virtual and then mock it.
-
-Try not to do that.
-
-Making a non-virtual function virtual is a big decision. It creates an
-extension point where subclasses can tweak your class' behavior. This
-weakens your control on the class because now it's harder to maintain
-the class' invariants. You should make a function virtual only when
-there is a valid reason for a subclass to override it.
-
-Mocking concrete classes directly is problematic as it creates a tight
-coupling between the class and the tests - any small change in the
-class may invalidate your tests and make test maintenance a pain.
-
-To avoid such problems, many programmers have been practicing "coding
-to interfaces": instead of talking to the `Concrete` class, your code
-would define an interface and talk to it. Then you implement that
-interface as an adaptor on top of `Concrete`. In tests, you can easily
-mock that interface to observe how your code is doing.
-
-This technique incurs some overhead:
-
-  * You pay the cost of virtual function calls (usually not a problem).
-  * There is more abstraction for the programmers to learn.
-
-However, it can also bring significant benefits in addition to better
-testability:
-
-  * `Concrete`'s API may not fit your problem domain very well, as you may not be the only client it tries to serve. By designing your own interface, you have a chance to tailor it to your need - you may add higher-level functionalities, rename stuff, etc instead of just trimming the class. This allows you to write your code (user of the interface) in a more natural way, which means it will be more readable, more maintainable, and you'll be more productive.
-  * If `Concrete`'s implementation ever has to change, you don't have to rewrite everywhere it is used. Instead, you can absorb the change in your implementation of the interface, and your other code and tests will be insulated from this change.
-
-Some people worry that if everyone is practicing this technique, they
-will end up writing lots of redundant code. This concern is totally
-understandable. However, there are two reasons why it may not be the
-case:
-
-  * Different projects may need to use `Concrete` in different ways, so the best interfaces for them will be different. Therefore, each of them will have its own domain-specific interface on top of `Concrete`, and they will not be the same code.
-  * If enough projects want to use the same interface, they can always share it, just like they have been sharing `Concrete`. You can check in the interface and the adaptor somewhere near `Concrete` (perhaps in a `contrib` sub-directory) and let many projects use it.
-
-You need to weigh the pros and cons carefully for your particular
-problem, but I'd like to assure you that the Java community has been
-practicing this for a long time and it's a proven effective technique
-applicable in a wide variety of situations. :-)
-
-## Delegating Calls to a Fake ##
-
-Some times you have a non-trivial fake implementation of an
-interface. For example:
-
-```
-class Foo {
- public:
-  virtual ~Foo() {}
-  virtual char DoThis(int n) = 0;
-  virtual void DoThat(const char* s, int* p) = 0;
-};
-
-class FakeFoo : public Foo {
- public:
-  virtual char DoThis(int n) {
-    return (n > 0) ? '+' :
-        (n < 0) ? '-' : '0';
-  }
-
-  virtual void DoThat(const char* s, int* p) {
-    *p = strlen(s);
-  }
-};
-```
-
-Now you want to mock this interface such that you can set expectations
-on it. However, you also want to use `FakeFoo` for the default
-behavior, as duplicating it in the mock object is, well, a lot of
-work.
-
-When you define the mock class using Google Mock, you can have it
-delegate its default action to a fake class you already have, using
-this pattern:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-class MockFoo : public Foo {
- public:
-  // Normal mock method definitions using Google Mock.
-  MOCK_METHOD1(DoThis, char(int n));
-  MOCK_METHOD2(DoThat, void(const char* s, int* p));
-
-  // Delegates the default actions of the methods to a FakeFoo object.
-  // This must be called *before* the custom ON_CALL() statements.
-  void DelegateToFake() {
-    ON_CALL(*this, DoThis(_))
-        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThis));
-    ON_CALL(*this, DoThat(_, _))
-        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThat));
-  }
- private:
-  FakeFoo fake_;  // Keeps an instance of the fake in the mock.
-};
-```
-
-With that, you can use `MockFoo` in your tests as usual. Just remember
-that if you don't explicitly set an action in an `ON_CALL()` or
-`EXPECT_CALL()`, the fake will be called upon to do it:
-
-```
-using ::testing::_;
-
-TEST(AbcTest, Xyz) {
-  MockFoo foo;
-  foo.DelegateToFake(); // Enables the fake for delegation.
-
-  // Put your ON_CALL(foo, ...)s here, if any.
-
-  // No action specified, meaning to use the default action.
-  EXPECT_CALL(foo, DoThis(5));
-  EXPECT_CALL(foo, DoThat(_, _));
-
-  int n = 0;
-  EXPECT_EQ('+', foo.DoThis(5));  // FakeFoo::DoThis() is invoked.
-  foo.DoThat("Hi", &n);           // FakeFoo::DoThat() is invoked.
-  EXPECT_EQ(2, n);
-}
-```
-
-**Some tips:**
-
-  * If you want, you can still override the default action by providing your own `ON_CALL()` or using `.WillOnce()` / `.WillRepeatedly()` in `EXPECT_CALL()`.
-  * In `DelegateToFake()`, you only need to delegate the methods whose fake implementation you intend to use.
-  * The general technique discussed here works for overloaded methods, but you'll need to tell the compiler which version you mean. To disambiguate a mock function (the one you specify inside the parentheses of `ON_CALL()`), see the "Selecting Between Overloaded Functions" section on this page; to disambiguate a fake function (the one you place inside `Invoke()`), use a `static_cast` to specify the function's type. For instance, if class `Foo` has methods `char DoThis(int n)` and `bool DoThis(double x) const`, and you want to invoke the latter, you need to write `Invoke(&fake_, static_cast<bool (FakeFoo::*)(double) const>(&FakeFoo::DoThis))` instead of `Invoke(&fake_, &FakeFoo::DoThis)` (The strange-looking thing inside the angled brackets of `static_cast` is the type of a function pointer to the second `DoThis()` method.).
-  * Having to mix a mock and a fake is often a sign of something gone wrong. Perhaps you haven't got used to the interaction-based way of testing yet. Or perhaps your interface is taking on too many roles and should be split up. Therefore, **don't abuse this**. We would only recommend to do it as an intermediate step when you are refactoring your code.
-
-Regarding the tip on mixing a mock and a fake, here's an example on
-why it may be a bad sign: Suppose you have a class `System` for
-low-level system operations. In particular, it does file and I/O
-operations. And suppose you want to test how your code uses `System`
-to do I/O, and you just want the file operations to work normally. If
-you mock out the entire `System` class, you'll have to provide a fake
-implementation for the file operation part, which suggests that
-`System` is taking on too many roles.
-
-Instead, you can define a `FileOps` interface and an `IOOps` interface
-and split `System`'s functionalities into the two. Then you can mock
-`IOOps` without mocking `FileOps`.
-
-## Delegating Calls to a Real Object ##
-
-When using testing doubles (mocks, fakes, stubs, and etc), sometimes
-their behaviors will differ from those of the real objects. This
-difference could be either intentional (as in simulating an error such
-that you can test the error handling code) or unintentional. If your
-mocks have different behaviors than the real objects by mistake, you
-could end up with code that passes the tests but fails in production.
-
-You can use the _delegating-to-real_ technique to ensure that your
-mock has the same behavior as the real object while retaining the
-ability to validate calls. This technique is very similar to the
-delegating-to-fake technique, the difference being that we use a real
-object instead of a fake. Here's an example:
-
-```
-using ::testing::_;
-using ::testing::AtLeast;
-using ::testing::Invoke;
-
-class MockFoo : public Foo {
- public:
-  MockFoo() {
-    // By default, all calls are delegated to the real object.
-    ON_CALL(*this, DoThis())
-        .WillByDefault(Invoke(&real_, &Foo::DoThis));
-    ON_CALL(*this, DoThat(_))
-        .WillByDefault(Invoke(&real_, &Foo::DoThat));
-    ...
-  }
-  MOCK_METHOD0(DoThis, ...);
-  MOCK_METHOD1(DoThat, ...);
-  ...
- private:
-  Foo real_;
-};
-...
-
-  MockFoo mock;
-
-  EXPECT_CALL(mock, DoThis())
-      .Times(3);
-  EXPECT_CALL(mock, DoThat("Hi"))
-      .Times(AtLeast(1));
-  ... use mock in test ...
-```
-
-With this, Google Mock will verify that your code made the right calls
-(with the right arguments, in the right order, called the right number
-of times, etc), and a real object will answer the calls (so the
-behavior will be the same as in production). This gives you the best
-of both worlds.
-
-## Delegating Calls to a Parent Class ##
-
-Ideally, you should code to interfaces, whose methods are all pure
-virtual. In reality, sometimes you do need to mock a virtual method
-that is not pure (i.e, it already has an implementation). For example:
-
-```
-class Foo {
- public:
-  virtual ~Foo();
-
-  virtual void Pure(int n) = 0;
-  virtual int Concrete(const char* str) { ... }
-};
-
-class MockFoo : public Foo {
- public:
-  // Mocking a pure method.
-  MOCK_METHOD1(Pure, void(int n));
-  // Mocking a concrete method.  Foo::Concrete() is shadowed.
-  MOCK_METHOD1(Concrete, int(const char* str));
-};
-```
-
-Sometimes you may want to call `Foo::Concrete()` instead of
-`MockFoo::Concrete()`. Perhaps you want to do it as part of a stub
-action, or perhaps your test doesn't need to mock `Concrete()` at all
-(but it would be oh-so painful to have to define a new mock class
-whenever you don't need to mock one of its methods).
-
-The trick is to leave a back door in your mock class for accessing the
-real methods in the base class:
-
-```
-class MockFoo : public Foo {
- public:
-  // Mocking a pure method.
-  MOCK_METHOD1(Pure, void(int n));
-  // Mocking a concrete method.  Foo::Concrete() is shadowed.
-  MOCK_METHOD1(Concrete, int(const char* str));
-
-  // Use this to call Concrete() defined in Foo.
-  int FooConcrete(const char* str) { return Foo::Concrete(str); }
-};
-```
-
-Now, you can call `Foo::Concrete()` inside an action by:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-...
-  EXPECT_CALL(foo, Concrete(_))
-      .WillOnce(Invoke(&foo, &MockFoo::FooConcrete));
-```
-
-or tell the mock object that you don't want to mock `Concrete()`:
-
-```
-using ::testing::Invoke;
-...
-  ON_CALL(foo, Concrete(_))
-      .WillByDefault(Invoke(&foo, &MockFoo::FooConcrete));
-```
-
-(Why don't we just write `Invoke(&foo, &Foo::Concrete)`? If you do
-that, `MockFoo::Concrete()` will be called (and cause an infinite
-recursion) since `Foo::Concrete()` is virtual. That's just how C++
-works.)
-
-# Using Matchers #
-
-## Matching Argument Values Exactly ##
-
-You can specify exactly which arguments a mock method is expecting:
-
-```
-using ::testing::Return;
-...
-  EXPECT_CALL(foo, DoThis(5))
-      .WillOnce(Return('a'));
-  EXPECT_CALL(foo, DoThat("Hello", bar));
-```
-
-## Using Simple Matchers ##
-
-You can use matchers to match arguments that have a certain property:
-
-```
-using ::testing::Ge;
-using ::testing::NotNull;
-using ::testing::Return;
-...
-  EXPECT_CALL(foo, DoThis(Ge(5)))  // The argument must be >= 5.
-      .WillOnce(Return('a'));
-  EXPECT_CALL(foo, DoThat("Hello", NotNull()));
-  // The second argument must not be NULL.
-```
-
-A frequently used matcher is `_`, which matches anything:
-
-```
-using ::testing::_;
-using ::testing::NotNull;
-...
-  EXPECT_CALL(foo, DoThat(_, NotNull()));
-```
-
-## Combining Matchers ##
-
-You can build complex matchers from existing ones using `AllOf()`,
-`AnyOf()`, and `Not()`:
-
-```
-using ::testing::AllOf;
-using ::testing::Gt;
-using ::testing::HasSubstr;
-using ::testing::Ne;
-using ::testing::Not;
-...
-  // The argument must be > 5 and != 10.
-  EXPECT_CALL(foo, DoThis(AllOf(Gt(5),
-                                Ne(10))));
-
-  // The first argument must not contain sub-string "blah".
-  EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")),
-                          NULL));
-```
-
-## Casting Matchers ##
-
-Google Mock matchers are statically typed, meaning that the compiler
-can catch your mistake if you use a matcher of the wrong type (for
-example, if you use `Eq(5)` to match a `string` argument). Good for
-you!
-
-Sometimes, however, you know what you're doing and want the compiler
-to give you some slack. One example is that you have a matcher for
-`long` and the argument you want to match is `int`. While the two
-types aren't exactly the same, there is nothing really wrong with
-using a `Matcher<long>` to match an `int` - after all, we can first
-convert the `int` argument to a `long` before giving it to the
-matcher.
-
-To support this need, Google Mock gives you the
-`SafeMatcherCast<T>(m)` function. It casts a matcher `m` to type
-`Matcher<T>`. To ensure safety, Google Mock checks that (let `U` be the
-type `m` accepts):
-
-  1. Type `T` can be implicitly cast to type `U`;
-  1. When both `T` and `U` are built-in arithmetic types (`bool`, integers, and floating-point numbers), the conversion from `T` to `U` is not lossy (in other words, any value representable by `T` can also be represented by `U`); and
-  1. When `U` is a reference, `T` must also be a reference (as the underlying matcher may be interested in the address of the `U` value).
-
-The code won't compile if any of these conditions isn't met.
-
-Here's one example:
-
-```
-using ::testing::SafeMatcherCast;
-
-// A base class and a child class.
-class Base { ... };
-class Derived : public Base { ... };
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(DoThis, void(Derived* derived));
-};
-...
-
-  MockFoo foo;
-  // m is a Matcher<Base*> we got from somewhere.
-  EXPECT_CALL(foo, DoThis(SafeMatcherCast<Derived*>(m)));
-```
-
-If you find `SafeMatcherCast<T>(m)` too limiting, you can use a similar
-function `MatcherCast<T>(m)`. The difference is that `MatcherCast` works
-as long as you can `static_cast` type `T` to type `U`.
-
-`MatcherCast` essentially lets you bypass C++'s type system
-(`static_cast` isn't always safe as it could throw away information,
-for example), so be careful not to misuse/abuse it.
-
-## Selecting Between Overloaded Functions ##
-
-If you expect an overloaded function to be called, the compiler may
-need some help on which overloaded version it is.
-
-To disambiguate functions overloaded on the const-ness of this object,
-use the `Const()` argument wrapper.
-
-```
-using ::testing::ReturnRef;
-
-class MockFoo : public Foo {
-  ...
-  MOCK_METHOD0(GetBar, Bar&());
-  MOCK_CONST_METHOD0(GetBar, const Bar&());
-};
-...
-
-  MockFoo foo;
-  Bar bar1, bar2;
-  EXPECT_CALL(foo, GetBar())         // The non-const GetBar().
-      .WillOnce(ReturnRef(bar1));
-  EXPECT_CALL(Const(foo), GetBar())  // The const GetBar().
-      .WillOnce(ReturnRef(bar2));
-```
-
-(`Const()` is defined by Google Mock and returns a `const` reference
-to its argument.)
-
-To disambiguate overloaded functions with the same number of arguments
-but different argument types, you may need to specify the exact type
-of a matcher, either by wrapping your matcher in `Matcher<type>()`, or
-using a matcher whose type is fixed (`TypedEq<type>`, `An<type>()`,
-etc):
-
-```
-using ::testing::An;
-using ::testing::Lt;
-using ::testing::Matcher;
-using ::testing::TypedEq;
-
-class MockPrinter : public Printer {
- public:
-  MOCK_METHOD1(Print, void(int n));
-  MOCK_METHOD1(Print, void(char c));
-};
-
-TEST(PrinterTest, Print) {
-  MockPrinter printer;
-
-  EXPECT_CALL(printer, Print(An<int>()));            // void Print(int);
-  EXPECT_CALL(printer, Print(Matcher<int>(Lt(5))));  // void Print(int);
-  EXPECT_CALL(printer, Print(TypedEq<char>('a')));   // void Print(char);
-
-  printer.Print(3);
-  printer.Print(6);
-  printer.Print('a');
-}
-```
-
-## Performing Different Actions Based on the Arguments ##
-
-When a mock method is called, the _last_ matching expectation that's
-still active will be selected (think "newer overrides older"). So, you
-can make a method do different things depending on its argument values
-like this:
-
-```
-using ::testing::_;
-using ::testing::Lt;
-using ::testing::Return;
-...
-  // The default case.
-  EXPECT_CALL(foo, DoThis(_))
-      .WillRepeatedly(Return('b'));
-
-  // The more specific case.
-  EXPECT_CALL(foo, DoThis(Lt(5)))
-      .WillRepeatedly(Return('a'));
-```
-
-Now, if `foo.DoThis()` is called with a value less than 5, `'a'` will
-be returned; otherwise `'b'` will be returned.
-
-## Matching Multiple Arguments as a Whole ##
-
-Sometimes it's not enough to match the arguments individually. For
-example, we may want to say that the first argument must be less than
-the second argument. The `With()` clause allows us to match
-all arguments of a mock function as a whole. For example,
-
-```
-using ::testing::_;
-using ::testing::Lt;
-using ::testing::Ne;
-...
-  EXPECT_CALL(foo, InRange(Ne(0), _))
-      .With(Lt());
-```
-
-says that the first argument of `InRange()` must not be 0, and must be
-less than the second argument.
-
-The expression inside `With()` must be a matcher of type
-`Matcher< ::testing::tuple<A1, ..., An> >`, where `A1`, ..., `An` are the
-types of the function arguments.
-
-You can also write `AllArgs(m)` instead of `m` inside `.With()`. The
-two forms are equivalent, but `.With(AllArgs(Lt()))` is more readable
-than `.With(Lt())`.
-
-You can use `Args<k1, ..., kn>(m)` to match the `n` selected arguments
-(as a tuple) against `m`. For example,
-
-```
-using ::testing::_;
-using ::testing::AllOf;
-using ::testing::Args;
-using ::testing::Lt;
-...
-  EXPECT_CALL(foo, Blah(_, _, _))
-      .With(AllOf(Args<0, 1>(Lt()), Args<1, 2>(Lt())));
-```
-
-says that `Blah()` will be called with arguments `x`, `y`, and `z` where
-`x < y < z`.
-
-As a convenience and example, Google Mock provides some matchers for
-2-tuples, including the `Lt()` matcher above. See the [CheatSheet](CheatSheet.md) for
-the complete list.
-
-Note that if you want to pass the arguments to a predicate of your own
-(e.g. `.With(Args<0, 1>(Truly(&MyPredicate)))`), that predicate MUST be
-written to take a `::testing::tuple` as its argument; Google Mock will pass the `n` selected arguments as _one_ single tuple to the predicate.
-
-## Using Matchers as Predicates ##
-
-Have you noticed that a matcher is just a fancy predicate that also
-knows how to describe itself? Many existing algorithms take predicates
-as arguments (e.g. those defined in STL's `<algorithm>` header), and
-it would be a shame if Google Mock matchers are not allowed to
-participate.
-
-Luckily, you can use a matcher where a unary predicate functor is
-expected by wrapping it inside the `Matches()` function. For example,
-
-```
-#include <algorithm>
-#include <vector>
-
-std::vector<int> v;
-...
-// How many elements in v are >= 10?
-const int count = count_if(v.begin(), v.end(), Matches(Ge(10)));
-```
-
-Since you can build complex matchers from simpler ones easily using
-Google Mock, this gives you a way to conveniently construct composite
-predicates (doing the same using STL's `<functional>` header is just
-painful). For example, here's a predicate that's satisfied by any
-number that is >= 0, <= 100, and != 50:
-
-```
-Matches(AllOf(Ge(0), Le(100), Ne(50)))
-```
-
-## Using Matchers in Google Test Assertions ##
-
-Since matchers are basically predicates that also know how to describe
-themselves, there is a way to take advantage of them in
-[Google Test](../../googletest/) assertions. It's
-called `ASSERT_THAT` and `EXPECT_THAT`:
-
-```
-  ASSERT_THAT(value, matcher);  // Asserts that value matches matcher.
-  EXPECT_THAT(value, matcher);  // The non-fatal version.
-```
-
-For example, in a Google Test test you can write:
-
-```
-#include "gmock/gmock.h"
-
-using ::testing::AllOf;
-using ::testing::Ge;
-using ::testing::Le;
-using ::testing::MatchesRegex;
-using ::testing::StartsWith;
-...
-
-  EXPECT_THAT(Foo(), StartsWith("Hello"));
-  EXPECT_THAT(Bar(), MatchesRegex("Line \\d+"));
-  ASSERT_THAT(Baz(), AllOf(Ge(5), Le(10)));
-```
-
-which (as you can probably guess) executes `Foo()`, `Bar()`, and
-`Baz()`, and verifies that:
-
-  * `Foo()` returns a string that starts with `"Hello"`.
-  * `Bar()` returns a string that matches regular expression `"Line \\d+"`.
-  * `Baz()` returns a number in the range [5, 10].
-
-The nice thing about these macros is that _they read like
-English_. They generate informative messages too. For example, if the
-first `EXPECT_THAT()` above fails, the message will be something like:
-
-```
-Value of: Foo()
-  Actual: "Hi, world!"
-Expected: starts with "Hello"
-```
-
-**Credit:** The idea of `(ASSERT|EXPECT)_THAT` was stolen from the
-[Hamcrest](https://github.com/hamcrest/) project, which adds
-`assertThat()` to JUnit.
-
-## Using Predicates as Matchers ##
-
-Google Mock provides a built-in set of matchers. In case you find them
-lacking, you can use an arbitray unary predicate function or functor
-as a matcher - as long as the predicate accepts a value of the type
-you want. You do this by wrapping the predicate inside the `Truly()`
-function, for example:
-
-```
-using ::testing::Truly;
-
-int IsEven(int n) { return (n % 2) == 0 ? 1 : 0; }
-...
-
-  // Bar() must be called with an even number.
-  EXPECT_CALL(foo, Bar(Truly(IsEven)));
-```
-
-Note that the predicate function / functor doesn't have to return
-`bool`. It works as long as the return value can be used as the
-condition in statement `if (condition) ...`.
-
-## Matching Arguments that Are Not Copyable ##
-
-When you do an `EXPECT_CALL(mock_obj, Foo(bar))`, Google Mock saves
-away a copy of `bar`. When `Foo()` is called later, Google Mock
-compares the argument to `Foo()` with the saved copy of `bar`. This
-way, you don't need to worry about `bar` being modified or destroyed
-after the `EXPECT_CALL()` is executed. The same is true when you use
-matchers like `Eq(bar)`, `Le(bar)`, and so on.
-
-But what if `bar` cannot be copied (i.e. has no copy constructor)? You
-could define your own matcher function and use it with `Truly()`, as
-the previous couple of recipes have shown. Or, you may be able to get
-away from it if you can guarantee that `bar` won't be changed after
-the `EXPECT_CALL()` is executed. Just tell Google Mock that it should
-save a reference to `bar`, instead of a copy of it. Here's how:
-
-```
-using ::testing::Eq;
-using ::testing::ByRef;
-using ::testing::Lt;
-...
-  // Expects that Foo()'s argument == bar.
-  EXPECT_CALL(mock_obj, Foo(Eq(ByRef(bar))));
-
-  // Expects that Foo()'s argument < bar.
-  EXPECT_CALL(mock_obj, Foo(Lt(ByRef(bar))));
-```
-
-Remember: if you do this, don't change `bar` after the
-`EXPECT_CALL()`, or the result is undefined.
-
-## Validating a Member of an Object ##
-
-Often a mock function takes a reference to object as an argument. When
-matching the argument, you may not want to compare the entire object
-against a fixed object, as that may be over-specification. Instead,
-you may need to validate a certain member variable or the result of a
-certain getter method of the object. You can do this with `Field()`
-and `Property()`. More specifically,
-
-```
-Field(&Foo::bar, m)
-```
-
-is a matcher that matches a `Foo` object whose `bar` member variable
-satisfies matcher `m`.
-
-```
-Property(&Foo::baz, m)
-```
-
-is a matcher that matches a `Foo` object whose `baz()` method returns
-a value that satisfies matcher `m`.
-
-For example:
-
-> | `Field(&Foo::number, Ge(3))` | Matches `x` where `x.number >= 3`. |
-|:-----------------------------|:-----------------------------------|
-> | `Property(&Foo::name, StartsWith("John "))` | Matches `x` where `x.name()` starts with `"John "`. |
-
-Note that in `Property(&Foo::baz, ...)`, method `baz()` must take no
-argument and be declared as `const`.
-
-BTW, `Field()` and `Property()` can also match plain pointers to
-objects. For instance,
-
-```
-Field(&Foo::number, Ge(3))
-```
-
-matches a plain pointer `p` where `p->number >= 3`. If `p` is `NULL`,
-the match will always fail regardless of the inner matcher.
-
-What if you want to validate more than one members at the same time?
-Remember that there is `AllOf()`.
-
-## Validating the Value Pointed to by a Pointer Argument ##
-
-C++ functions often take pointers as arguments. You can use matchers
-like `IsNull()`, `NotNull()`, and other comparison matchers to match a
-pointer, but what if you want to make sure the value _pointed to_ by
-the pointer, instead of the pointer itself, has a certain property?
-Well, you can use the `Pointee(m)` matcher.
-
-`Pointee(m)` matches a pointer iff `m` matches the value the pointer
-points to. For example:
-
-```
-using ::testing::Ge;
-using ::testing::Pointee;
-...
-  EXPECT_CALL(foo, Bar(Pointee(Ge(3))));
-```
-
-expects `foo.Bar()` to be called with a pointer that points to a value
-greater than or equal to 3.
-
-One nice thing about `Pointee()` is that it treats a `NULL` pointer as
-a match failure, so you can write `Pointee(m)` instead of
-
-```
-  AllOf(NotNull(), Pointee(m))
-```
-
-without worrying that a `NULL` pointer will crash your test.
-
-Also, did we tell you that `Pointee()` works with both raw pointers
-**and** smart pointers (`linked_ptr`, `shared_ptr`, `scoped_ptr`, and
-etc)?
-
-What if you have a pointer to pointer? You guessed it - you can use
-nested `Pointee()` to probe deeper inside the value. For example,
-`Pointee(Pointee(Lt(3)))` matches a pointer that points to a pointer
-that points to a number less than 3 (what a mouthful...).
-
-## Testing a Certain Property of an Object ##
-
-Sometimes you want to specify that an object argument has a certain
-property, but there is no existing matcher that does this. If you want
-good error messages, you should define a matcher. If you want to do it
-quick and dirty, you could get away with writing an ordinary function.
-
-Let's say you have a mock function that takes an object of type `Foo`,
-which has an `int bar()` method and an `int baz()` method, and you
-want to constrain that the argument's `bar()` value plus its `baz()`
-value is a given number. Here's how you can define a matcher to do it:
-
-```
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-
-class BarPlusBazEqMatcher : public MatcherInterface<const Foo&> {
- public:
-  explicit BarPlusBazEqMatcher(int expected_sum)
-      : expected_sum_(expected_sum) {}
-
-  virtual bool MatchAndExplain(const Foo& foo,
-                               MatchResultListener* listener) const {
-    return (foo.bar() + foo.baz()) == expected_sum_;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "bar() + baz() equals " << expected_sum_;
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "bar() + baz() does not equal " << expected_sum_;
-  }
- private:
-  const int expected_sum_;
-};
-
-inline Matcher<const Foo&> BarPlusBazEq(int expected_sum) {
-  return MakeMatcher(new BarPlusBazEqMatcher(expected_sum));
-}
-
-...
-
-  EXPECT_CALL(..., DoThis(BarPlusBazEq(5)))...;
-```
-
-## Matching Containers ##
-
-Sometimes an STL container (e.g. list, vector, map, ...) is passed to
-a mock function and you may want to validate it. Since most STL
-containers support the `==` operator, you can write
-`Eq(expected_container)` or simply `expected_container` to match a
-container exactly.
-
-Sometimes, though, you may want to be more flexible (for example, the
-first element must be an exact match, but the second element can be
-any positive number, and so on). Also, containers used in tests often
-have a small number of elements, and having to define the expected
-container out-of-line is a bit of a hassle.
-
-You can use the `ElementsAre()` or `UnorderedElementsAre()` matcher in
-such cases:
-
-```
-using ::testing::_;
-using ::testing::ElementsAre;
-using ::testing::Gt;
-...
-
-  MOCK_METHOD1(Foo, void(const vector<int>& numbers));
-...
-
-  EXPECT_CALL(mock, Foo(ElementsAre(1, Gt(0), _, 5)));
-```
-
-The above matcher says that the container must have 4 elements, which
-must be 1, greater than 0, anything, and 5 respectively.
-
-If you instead write:
-
-```
-using ::testing::_;
-using ::testing::Gt;
-using ::testing::UnorderedElementsAre;
-...
-
-  MOCK_METHOD1(Foo, void(const vector<int>& numbers));
-...
-
-  EXPECT_CALL(mock, Foo(UnorderedElementsAre(1, Gt(0), _, 5)));
-```
-
-It means that the container must have 4 elements, which under some
-permutation must be 1, greater than 0, anything, and 5 respectively.
-
-`ElementsAre()` and `UnorderedElementsAre()` are overloaded to take 0
-to 10 arguments. If more are needed, you can place them in a C-style
-array and use `ElementsAreArray()` or `UnorderedElementsAreArray()`
-instead:
-
-```
-using ::testing::ElementsAreArray;
-...
-
-  // ElementsAreArray accepts an array of element values.
-  const int expected_vector1[] = { 1, 5, 2, 4, ... };
-  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector1)));
-
-  // Or, an array of element matchers.
-  Matcher<int> expected_vector2 = { 1, Gt(2), _, 3, ... };
-  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector2)));
-```
-
-In case the array needs to be dynamically created (and therefore the
-array size cannot be inferred by the compiler), you can give
-`ElementsAreArray()` an additional argument to specify the array size:
-
-```
-using ::testing::ElementsAreArray;
-...
-  int* const expected_vector3 = new int[count];
-  ... fill expected_vector3 with values ...
-  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector3, count)));
-```
-
-**Tips:**
-
-  * `ElementsAre*()` can be used to match _any_ container that implements the STL iterator pattern (i.e. it has a `const_iterator` type and supports `begin()/end()`), not just the ones defined in STL. It will even work with container types yet to be written - as long as they follows the above pattern.
-  * You can use nested `ElementsAre*()` to match nested (multi-dimensional) containers.
-  * If the container is passed by pointer instead of by reference, just write `Pointee(ElementsAre*(...))`.
-  * The order of elements _matters_ for `ElementsAre*()`. Therefore don't use it with containers whose element order is undefined (e.g. `hash_map`).
-
-## Sharing Matchers ##
-
-Under the hood, a Google Mock matcher object consists of a pointer to
-a ref-counted implementation object. Copying matchers is allowed and
-very efficient, as only the pointer is copied. When the last matcher
-that references the implementation object dies, the implementation
-object will be deleted.
-
-Therefore, if you have some complex matcher that you want to use again
-and again, there is no need to build it everytime. Just assign it to a
-matcher variable and use that variable repeatedly! For example,
-
-```
-  Matcher<int> in_range = AllOf(Gt(5), Le(10));
-  ... use in_range as a matcher in multiple EXPECT_CALLs ...
-```
-
-# Setting Expectations #
-
-## Knowing When to Expect ##
-
-`ON_CALL` is likely the single most under-utilized construct in Google Mock.
-
-There are basically two constructs for defining the behavior of a mock object: `ON_CALL` and `EXPECT_CALL`. The difference? `ON_CALL` defines what happens when a mock method is called, but _doesn't imply any expectation on the method being called._ `EXPECT_CALL` not only defines the behavior, but also sets an expectation that _the method will be called with the given arguments, for the given number of times_ (and _in the given order_ when you specify the order too).
-
-Since `EXPECT_CALL` does more, isn't it better than `ON_CALL`? Not really. Every `EXPECT_CALL` adds a constraint on the behavior of the code under test. Having more constraints than necessary is _baaad_ - even worse than not having enough constraints.
-
-This may be counter-intuitive. How could tests that verify more be worse than tests that verify less? Isn't verification the whole point of tests?
-
-The answer, lies in _what_ a test should verify. **A good test verifies the contract of the code.** If a test over-specifies, it doesn't leave enough freedom to the implementation. As a result, changing the implementation without breaking the contract (e.g. refactoring and optimization), which should be perfectly fine to do, can break such tests. Then you have to spend time fixing them, only to see them broken again the next time the implementation is changed.
-
-Keep in mind that one doesn't have to verify more than one property in one test. In fact, **it's a good style to verify only one thing in one test.** If you do that, a bug will likely break only one or two tests instead of dozens (which case would you rather debug?). If you are also in the habit of giving tests descriptive names that tell what they verify, you can often easily guess what's wrong just from the test log itself.
-
-So use `ON_CALL` by default, and only use `EXPECT_CALL` when you actually intend to verify that the call is made. For example, you may have a bunch of `ON_CALL`s in your test fixture to set the common mock behavior shared by all tests in the same group, and write (scarcely) different `EXPECT_CALL`s in different `TEST_F`s to verify different aspects of the code's behavior. Compared with the style where each `TEST` has many `EXPECT_CALL`s, this leads to tests that are more resilient to implementational changes (and thus less likely to require maintenance) and makes the intent of the tests more obvious (so they are easier to maintain when you do need to maintain them).
-
-If you are bothered by the "Uninteresting mock function call" message printed when a mock method without an `EXPECT_CALL` is called, you may use a `NiceMock` instead to suppress all such messages for the mock object, or suppress the message for specific methods by adding `EXPECT_CALL(...).Times(AnyNumber())`. DO NOT suppress it by blindly adding an `EXPECT_CALL(...)`, or you'll have a test that's a pain to maintain.
-
-## Ignoring Uninteresting Calls ##
-
-If you are not interested in how a mock method is called, just don't
-say anything about it. In this case, if the method is ever called,
-Google Mock will perform its default action to allow the test program
-to continue. If you are not happy with the default action taken by
-Google Mock, you can override it using `DefaultValue<T>::Set()`
-(described later in this document) or `ON_CALL()`.
-
-Please note that once you expressed interest in a particular mock
-method (via `EXPECT_CALL()`), all invocations to it must match some
-expectation. If this function is called but the arguments don't match
-any `EXPECT_CALL()` statement, it will be an error.
-
-## Disallowing Unexpected Calls ##
-
-If a mock method shouldn't be called at all, explicitly say so:
-
-```
-using ::testing::_;
-...
-  EXPECT_CALL(foo, Bar(_))
-      .Times(0);
-```
-
-If some calls to the method are allowed, but the rest are not, just
-list all the expected calls:
-
-```
-using ::testing::AnyNumber;
-using ::testing::Gt;
-...
-  EXPECT_CALL(foo, Bar(5));
-  EXPECT_CALL(foo, Bar(Gt(10)))
-      .Times(AnyNumber());
-```
-
-A call to `foo.Bar()` that doesn't match any of the `EXPECT_CALL()`
-statements will be an error.
-
-## Understanding Uninteresting vs Unexpected Calls ##
-
-_Uninteresting_ calls and _unexpected_ calls are different concepts in Google Mock. _Very_ different.
-
-A call `x.Y(...)` is **uninteresting** if there's _not even a single_ `EXPECT_CALL(x, Y(...))` set. In other words, the test isn't interested in the `x.Y()` method at all, as evident in that the test doesn't care to say anything about it.
-
-A call `x.Y(...)` is **unexpected** if there are some `EXPECT_CALL(x, Y(...))s` set, but none of them matches the call. Put another way, the test is interested in the `x.Y()` method (therefore it _explicitly_ sets some `EXPECT_CALL` to verify how it's called); however, the verification fails as the test doesn't expect this particular call to happen.
-
-**An unexpected call is always an error,** as the code under test doesn't behave the way the test expects it to behave.
-
-**By default, an uninteresting call is not an error,** as it violates no constraint specified by the test. (Google Mock's philosophy is that saying nothing means there is no constraint.) However, it leads to a warning, as it _might_ indicate a problem (e.g. the test author might have forgotten to specify a constraint).
-
-In Google Mock, `NiceMock` and `StrictMock` can be used to make a mock class "nice" or "strict". How does this affect uninteresting calls and unexpected calls?
-
-A **nice mock** suppresses uninteresting call warnings. It is less chatty than the default mock, but otherwise is the same. If a test fails with a default mock, it will also fail using a nice mock instead. And vice versa. Don't expect making a mock nice to change the test's result.
-
-A **strict mock** turns uninteresting call warnings into errors. So making a mock strict may change the test's result.
-
-Let's look at an example:
-
-```
-TEST(...) {
-  NiceMock<MockDomainRegistry> mock_registry;
-  EXPECT_CALL(mock_registry, GetDomainOwner("google.com"))
-          .WillRepeatedly(Return("Larry Page"));
-
-  // Use mock_registry in code under test.
-  ... &mock_registry ...
-}
-```
-
-The sole `EXPECT_CALL` here says that all calls to `GetDomainOwner()` must have `"google.com"` as the argument. If `GetDomainOwner("yahoo.com")` is called, it will be an unexpected call, and thus an error. Having a nice mock doesn't change the severity of an unexpected call.
-
-So how do we tell Google Mock that `GetDomainOwner()` can be called with some other arguments as well? The standard technique is to add a "catch all" `EXPECT_CALL`:
-
-```
-  EXPECT_CALL(mock_registry, GetDomainOwner(_))
-        .Times(AnyNumber());  // catches all other calls to this method.
-  EXPECT_CALL(mock_registry, GetDomainOwner("google.com"))
-        .WillRepeatedly(Return("Larry Page"));
-```
-
-Remember that `_` is the wildcard matcher that matches anything. With this, if `GetDomainOwner("google.com")` is called, it will do what the second `EXPECT_CALL` says; if it is called with a different argument, it will do what the first `EXPECT_CALL` says.
-
-Note that the order of the two `EXPECT_CALLs` is important, as a newer `EXPECT_CALL` takes precedence over an older one.
-
-For more on uninteresting calls, nice mocks, and strict mocks, read ["The Nice, the Strict, and the Naggy"](#the-nice-the-strict-and-the-naggy).
-
-## Expecting Ordered Calls ##
-
-Although an `EXPECT_CALL()` statement defined earlier takes precedence
-when Google Mock tries to match a function call with an expectation,
-by default calls don't have to happen in the order `EXPECT_CALL()`
-statements are written. For example, if the arguments match the
-matchers in the third `EXPECT_CALL()`, but not those in the first two,
-then the third expectation will be used.
-
-If you would rather have all calls occur in the order of the
-expectations, put the `EXPECT_CALL()` statements in a block where you
-define a variable of type `InSequence`:
-
-```
-  using ::testing::_;
-  using ::testing::InSequence;
-
-  {
-    InSequence s;
-
-    EXPECT_CALL(foo, DoThis(5));
-    EXPECT_CALL(bar, DoThat(_))
-        .Times(2);
-    EXPECT_CALL(foo, DoThis(6));
-  }
-```
-
-In this example, we expect a call to `foo.DoThis(5)`, followed by two
-calls to `bar.DoThat()` where the argument can be anything, which are
-in turn followed by a call to `foo.DoThis(6)`. If a call occurred
-out-of-order, Google Mock will report an error.
-
-## Expecting Partially Ordered Calls ##
-
-Sometimes requiring everything to occur in a predetermined order can
-lead to brittle tests. For example, we may care about `A` occurring
-before both `B` and `C`, but aren't interested in the relative order
-of `B` and `C`. In this case, the test should reflect our real intent,
-instead of being overly constraining.
-
-Google Mock allows you to impose an arbitrary DAG (directed acyclic
-graph) on the calls. One way to express the DAG is to use the
-[After](CheatSheet.md#the-after-clause) clause of `EXPECT_CALL`.
-
-Another way is via the `InSequence()` clause (not the same as the
-`InSequence` class), which we borrowed from jMock 2. It's less
-flexible than `After()`, but more convenient when you have long chains
-of sequential calls, as it doesn't require you to come up with
-different names for the expectations in the chains.  Here's how it
-works:
-
-If we view `EXPECT_CALL()` statements as nodes in a graph, and add an
-edge from node A to node B wherever A must occur before B, we can get
-a DAG. We use the term "sequence" to mean a directed path in this
-DAG. Now, if we decompose the DAG into sequences, we just need to know
-which sequences each `EXPECT_CALL()` belongs to in order to be able to
-reconstruct the orginal DAG.
-
-So, to specify the partial order on the expectations we need to do two
-things: first to define some `Sequence` objects, and then for each
-`EXPECT_CALL()` say which `Sequence` objects it is part
-of. Expectations in the same sequence must occur in the order they are
-written. For example,
-
-```
-  using ::testing::Sequence;
-
-  Sequence s1, s2;
-
-  EXPECT_CALL(foo, A())
-      .InSequence(s1, s2);
-  EXPECT_CALL(bar, B())
-      .InSequence(s1);
-  EXPECT_CALL(bar, C())
-      .InSequence(s2);
-  EXPECT_CALL(foo, D())
-      .InSequence(s2);
-```
-
-specifies the following DAG (where `s1` is `A -> B`, and `s2` is `A ->
-C -> D`):
-
-```
-       +---> B
-       |
-  A ---|
-       |
-       +---> C ---> D
-```
-
-This means that A must occur before B and C, and C must occur before
-D. There's no restriction about the order other than these.
-
-## Controlling When an Expectation Retires ##
-
-When a mock method is called, Google Mock only consider expectations
-that are still active. An expectation is active when created, and
-becomes inactive (aka _retires_) when a call that has to occur later
-has occurred. For example, in
-
-```
-  using ::testing::_;
-  using ::testing::Sequence;
-
-  Sequence s1, s2;
-
-  EXPECT_CALL(log, Log(WARNING, _, "File too large."))     // #1
-      .Times(AnyNumber())
-      .InSequence(s1, s2);
-  EXPECT_CALL(log, Log(WARNING, _, "Data set is empty."))  // #2
-      .InSequence(s1);
-  EXPECT_CALL(log, Log(WARNING, _, "User not found."))     // #3
-      .InSequence(s2);
-```
-
-as soon as either #2 or #3 is matched, #1 will retire. If a warning
-`"File too large."` is logged after this, it will be an error.
-
-Note that an expectation doesn't retire automatically when it's
-saturated. For example,
-
-```
-using ::testing::_;
-...
-  EXPECT_CALL(log, Log(WARNING, _, _));                  // #1
-  EXPECT_CALL(log, Log(WARNING, _, "File too large."));  // #2
-```
-
-says that there will be exactly one warning with the message `"File
-too large."`. If the second warning contains this message too, #2 will
-match again and result in an upper-bound-violated error.
-
-If this is not what you want, you can ask an expectation to retire as
-soon as it becomes saturated:
-
-```
-using ::testing::_;
-...
-  EXPECT_CALL(log, Log(WARNING, _, _));                 // #1
-  EXPECT_CALL(log, Log(WARNING, _, "File too large."))  // #2
-      .RetiresOnSaturation();
-```
-
-Here #2 can be used only once, so if you have two warnings with the
-message `"File too large."`, the first will match #2 and the second
-will match #1 - there will be no error.
-
-# Using Actions #
-
-## Returning References from Mock Methods ##
-
-If a mock function's return type is a reference, you need to use
-`ReturnRef()` instead of `Return()` to return a result:
-
-```
-using ::testing::ReturnRef;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD0(GetBar, Bar&());
-};
-...
-
-  MockFoo foo;
-  Bar bar;
-  EXPECT_CALL(foo, GetBar())
-      .WillOnce(ReturnRef(bar));
-```
-
-## Returning Live Values from Mock Methods ##
-
-The `Return(x)` action saves a copy of `x` when the action is
-_created_, and always returns the same value whenever it's
-executed. Sometimes you may want to instead return the _live_ value of
-`x` (i.e. its value at the time when the action is _executed_.).
-
-If the mock function's return type is a reference, you can do it using
-`ReturnRef(x)`, as shown in the previous recipe ("Returning References
-from Mock Methods"). However, Google Mock doesn't let you use
-`ReturnRef()` in a mock function whose return type is not a reference,
-as doing that usually indicates a user error. So, what shall you do?
-
-You may be tempted to try `ByRef()`:
-
-```
-using testing::ByRef;
-using testing::Return;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD0(GetValue, int());
-};
-...
-  int x = 0;
-  MockFoo foo;
-  EXPECT_CALL(foo, GetValue())
-      .WillRepeatedly(Return(ByRef(x)));
-  x = 42;
-  EXPECT_EQ(42, foo.GetValue());
-```
-
-Unfortunately, it doesn't work here. The above code will fail with error:
-
-```
-Value of: foo.GetValue()
-  Actual: 0
-Expected: 42
-```
-
-The reason is that `Return(value)` converts `value` to the actual
-return type of the mock function at the time when the action is
-_created_, not when it is _executed_. (This behavior was chosen for
-the action to be safe when `value` is a proxy object that references
-some temporary objects.) As a result, `ByRef(x)` is converted to an
-`int` value (instead of a `const int&`) when the expectation is set,
-and `Return(ByRef(x))` will always return 0.
-
-`ReturnPointee(pointer)` was provided to solve this problem
-specifically. It returns the value pointed to by `pointer` at the time
-the action is _executed_:
-
-```
-using testing::ReturnPointee;
-...
-  int x = 0;
-  MockFoo foo;
-  EXPECT_CALL(foo, GetValue())
-      .WillRepeatedly(ReturnPointee(&x));  // Note the & here.
-  x = 42;
-  EXPECT_EQ(42, foo.GetValue());  // This will succeed now.
-```
-
-## Combining Actions ##
-
-Want to do more than one thing when a function is called? That's
-fine. `DoAll()` allow you to do sequence of actions every time. Only
-the return value of the last action in the sequence will be used.
-
-```
-using ::testing::DoAll;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(Bar, bool(int n));
-};
-...
-
-  EXPECT_CALL(foo, Bar(_))
-      .WillOnce(DoAll(action_1,
-                      action_2,
-                      ...
-                      action_n));
-```
-
-## Mocking Side Effects ##
-
-Sometimes a method exhibits its effect not via returning a value but
-via side effects. For example, it may change some global state or
-modify an output argument. To mock side effects, in general you can
-define your own action by implementing `::testing::ActionInterface`.
-
-If all you need to do is to change an output argument, the built-in
-`SetArgPointee()` action is convenient:
-
-```
-using ::testing::SetArgPointee;
-
-class MockMutator : public Mutator {
- public:
-  MOCK_METHOD2(Mutate, void(bool mutate, int* value));
-  ...
-};
-...
-
-  MockMutator mutator;
-  EXPECT_CALL(mutator, Mutate(true, _))
-      .WillOnce(SetArgPointee<1>(5));
-```
-
-In this example, when `mutator.Mutate()` is called, we will assign 5
-to the `int` variable pointed to by argument #1
-(0-based).
-
-`SetArgPointee()` conveniently makes an internal copy of the
-value you pass to it, removing the need to keep the value in scope and
-alive. The implication however is that the value must have a copy
-constructor and assignment operator.
-
-If the mock method also needs to return a value as well, you can chain
-`SetArgPointee()` with `Return()` using `DoAll()`:
-
-```
-using ::testing::_;
-using ::testing::Return;
-using ::testing::SetArgPointee;
-
-class MockMutator : public Mutator {
- public:
-  ...
-  MOCK_METHOD1(MutateInt, bool(int* value));
-};
-...
-
-  MockMutator mutator;
-  EXPECT_CALL(mutator, MutateInt(_))
-      .WillOnce(DoAll(SetArgPointee<0>(5),
-                      Return(true)));
-```
-
-If the output argument is an array, use the
-`SetArrayArgument<N>(first, last)` action instead. It copies the
-elements in source range `[first, last)` to the array pointed to by
-the `N`-th (0-based) argument:
-
-```
-using ::testing::NotNull;
-using ::testing::SetArrayArgument;
-
-class MockArrayMutator : public ArrayMutator {
- public:
-  MOCK_METHOD2(Mutate, void(int* values, int num_values));
-  ...
-};
-...
-
-  MockArrayMutator mutator;
-  int values[5] = { 1, 2, 3, 4, 5 };
-  EXPECT_CALL(mutator, Mutate(NotNull(), 5))
-      .WillOnce(SetArrayArgument<0>(values, values + 5));
-```
-
-This also works when the argument is an output iterator:
-
-```
-using ::testing::_;
-using ::testing::SeArrayArgument;
-
-class MockRolodex : public Rolodex {
- public:
-  MOCK_METHOD1(GetNames, void(std::back_insert_iterator<vector<string> >));
-  ...
-};
-...
-
-  MockRolodex rolodex;
-  vector<string> names;
-  names.push_back("George");
-  names.push_back("John");
-  names.push_back("Thomas");
-  EXPECT_CALL(rolodex, GetNames(_))
-      .WillOnce(SetArrayArgument<0>(names.begin(), names.end()));
-```
-
-## Changing a Mock Object's Behavior Based on the State ##
-
-If you expect a call to change the behavior of a mock object, you can use `::testing::InSequence` to specify different behaviors before and after the call:
-
-```
-using ::testing::InSequence;
-using ::testing::Return;
-
-...
-  {
-    InSequence seq;
-    EXPECT_CALL(my_mock, IsDirty())
-        .WillRepeatedly(Return(true));
-    EXPECT_CALL(my_mock, Flush());
-    EXPECT_CALL(my_mock, IsDirty())
-        .WillRepeatedly(Return(false));
-  }
-  my_mock.FlushIfDirty();
-```
-
-This makes `my_mock.IsDirty()` return `true` before `my_mock.Flush()` is called and return `false` afterwards.
-
-If the behavior change is more complex, you can store the effects in a variable and make a mock method get its return value from that variable:
-
-```
-using ::testing::_;
-using ::testing::SaveArg;
-using ::testing::Return;
-
-ACTION_P(ReturnPointee, p) { return *p; }
-...
-  int previous_value = 0;
-  EXPECT_CALL(my_mock, GetPrevValue())
-      .WillRepeatedly(ReturnPointee(&previous_value));
-  EXPECT_CALL(my_mock, UpdateValue(_))
-      .WillRepeatedly(SaveArg<0>(&previous_value));
-  my_mock.DoSomethingToUpdateValue();
-```
-
-Here `my_mock.GetPrevValue()` will always return the argument of the last `UpdateValue()` call.
-
-## Setting the Default Value for a Return Type ##
-
-If a mock method's return type is a built-in C++ type or pointer, by
-default it will return 0 when invoked. Also, in C++ 11 and above, a mock
-method whose return type has a default constructor will return a default-constructed
-value by default.  You only need to specify an
-action if this default value doesn't work for you.
-
-Sometimes, you may want to change this default value, or you may want
-to specify a default value for types Google Mock doesn't know
-about. You can do this using the `::testing::DefaultValue` class
-template:
-
-```
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD0(CalculateBar, Bar());
-};
-...
-
-  Bar default_bar;
-  // Sets the default return value for type Bar.
-  DefaultValue<Bar>::Set(default_bar);
-
-  MockFoo foo;
-
-  // We don't need to specify an action here, as the default
-  // return value works for us.
-  EXPECT_CALL(foo, CalculateBar());
-
-  foo.CalculateBar();  // This should return default_bar.
-
-  // Unsets the default return value.
-  DefaultValue<Bar>::Clear();
-```
-
-Please note that changing the default value for a type can make you
-tests hard to understand. We recommend you to use this feature
-judiciously. For example, you may want to make sure the `Set()` and
-`Clear()` calls are right next to the code that uses your mock.
-
-## Setting the Default Actions for a Mock Method ##
-
-You've learned how to change the default value of a given
-type. However, this may be too coarse for your purpose: perhaps you
-have two mock methods with the same return type and you want them to
-have different behaviors. The `ON_CALL()` macro allows you to
-customize your mock's behavior at the method level:
-
-```
-using ::testing::_;
-using ::testing::AnyNumber;
-using ::testing::Gt;
-using ::testing::Return;
-...
-  ON_CALL(foo, Sign(_))
-      .WillByDefault(Return(-1));
-  ON_CALL(foo, Sign(0))
-      .WillByDefault(Return(0));
-  ON_CALL(foo, Sign(Gt(0)))
-      .WillByDefault(Return(1));
-
-  EXPECT_CALL(foo, Sign(_))
-      .Times(AnyNumber());
-
-  foo.Sign(5);   // This should return 1.
-  foo.Sign(-9);  // This should return -1.
-  foo.Sign(0);   // This should return 0.
-```
-
-As you may have guessed, when there are more than one `ON_CALL()`
-statements, the news order take precedence over the older ones. In
-other words, the **last** one that matches the function arguments will
-be used. This matching order allows you to set up the common behavior
-in a mock object's constructor or the test fixture's set-up phase and
-specialize the mock's behavior later.
-
-## Using Functions/Methods/Functors as Actions ##
-
-If the built-in actions don't suit you, you can easily use an existing
-function, method, or functor as an action:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD2(Sum, int(int x, int y));
-  MOCK_METHOD1(ComplexJob, bool(int x));
-};
-
-int CalculateSum(int x, int y) { return x + y; }
-
-class Helper {
- public:
-  bool ComplexJob(int x);
-};
-...
-
-  MockFoo foo;
-  Helper helper;
-  EXPECT_CALL(foo, Sum(_, _))
-      .WillOnce(Invoke(CalculateSum));
-  EXPECT_CALL(foo, ComplexJob(_))
-      .WillOnce(Invoke(&helper, &Helper::ComplexJob));
-
-  foo.Sum(5, 6);       // Invokes CalculateSum(5, 6).
-  foo.ComplexJob(10);  // Invokes helper.ComplexJob(10);
-```
-
-The only requirement is that the type of the function, etc must be
-_compatible_ with the signature of the mock function, meaning that the
-latter's arguments can be implicitly converted to the corresponding
-arguments of the former, and the former's return type can be
-implicitly converted to that of the latter. So, you can invoke
-something whose type is _not_ exactly the same as the mock function,
-as long as it's safe to do so - nice, huh?
-
-## Invoking a Function/Method/Functor Without Arguments ##
-
-`Invoke()` is very useful for doing actions that are more complex. It
-passes the mock function's arguments to the function or functor being
-invoked such that the callee has the full context of the call to work
-with. If the invoked function is not interested in some or all of the
-arguments, it can simply ignore them.
-
-Yet, a common pattern is that a test author wants to invoke a function
-without the arguments of the mock function. `Invoke()` allows her to
-do that using a wrapper function that throws away the arguments before
-invoking an underlining nullary function. Needless to say, this can be
-tedious and obscures the intent of the test.
-
-`InvokeWithoutArgs()` solves this problem. It's like `Invoke()` except
-that it doesn't pass the mock function's arguments to the
-callee. Here's an example:
-
-```
-using ::testing::_;
-using ::testing::InvokeWithoutArgs;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(ComplexJob, bool(int n));
-};
-
-bool Job1() { ... }
-...
-
-  MockFoo foo;
-  EXPECT_CALL(foo, ComplexJob(_))
-      .WillOnce(InvokeWithoutArgs(Job1));
-
-  foo.ComplexJob(10);  // Invokes Job1().
-```
-
-## Invoking an Argument of the Mock Function ##
-
-Sometimes a mock function will receive a function pointer or a functor
-(in other words, a "callable") as an argument, e.g.
-
-```
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD2(DoThis, bool(int n, bool (*fp)(int)));
-};
-```
-
-and you may want to invoke this callable argument:
-
-```
-using ::testing::_;
-...
-  MockFoo foo;
-  EXPECT_CALL(foo, DoThis(_, _))
-      .WillOnce(...);
-  // Will execute (*fp)(5), where fp is the
-  // second argument DoThis() receives.
-```
-
-Arghh, you need to refer to a mock function argument but C++ has no
-lambda (yet), so you have to define your own action. :-( Or do you
-really?
-
-Well, Google Mock has an action to solve _exactly_ this problem:
-
-```
-  InvokeArgument<N>(arg_1, arg_2, ..., arg_m)
-```
-
-will invoke the `N`-th (0-based) argument the mock function receives,
-with `arg_1`, `arg_2`, ..., and `arg_m`. No matter if the argument is
-a function pointer or a functor, Google Mock handles them both.
-
-With that, you could write:
-
-```
-using ::testing::_;
-using ::testing::InvokeArgument;
-...
-  EXPECT_CALL(foo, DoThis(_, _))
-      .WillOnce(InvokeArgument<1>(5));
-  // Will execute (*fp)(5), where fp is the
-  // second argument DoThis() receives.
-```
-
-What if the callable takes an argument by reference? No problem - just
-wrap it inside `ByRef()`:
-
-```
-...
-  MOCK_METHOD1(Bar, bool(bool (*fp)(int, const Helper&)));
-...
-using ::testing::_;
-using ::testing::ByRef;
-using ::testing::InvokeArgument;
-...
-
-  MockFoo foo;
-  Helper helper;
-  ...
-  EXPECT_CALL(foo, Bar(_))
-      .WillOnce(InvokeArgument<0>(5, ByRef(helper)));
-  // ByRef(helper) guarantees that a reference to helper, not a copy of it,
-  // will be passed to the callable.
-```
-
-What if the callable takes an argument by reference and we do **not**
-wrap the argument in `ByRef()`? Then `InvokeArgument()` will _make a
-copy_ of the argument, and pass a _reference to the copy_, instead of
-a reference to the original value, to the callable. This is especially
-handy when the argument is a temporary value:
-
-```
-...
-  MOCK_METHOD1(DoThat, bool(bool (*f)(const double& x, const string& s)));
-...
-using ::testing::_;
-using ::testing::InvokeArgument;
-...
-
-  MockFoo foo;
-  ...
-  EXPECT_CALL(foo, DoThat(_))
-      .WillOnce(InvokeArgument<0>(5.0, string("Hi")));
-  // Will execute (*f)(5.0, string("Hi")), where f is the function pointer
-  // DoThat() receives.  Note that the values 5.0 and string("Hi") are
-  // temporary and dead once the EXPECT_CALL() statement finishes.  Yet
-  // it's fine to perform this action later, since a copy of the values
-  // are kept inside the InvokeArgument action.
-```
-
-## Ignoring an Action's Result ##
-
-Sometimes you have an action that returns _something_, but you need an
-action that returns `void` (perhaps you want to use it in a mock
-function that returns `void`, or perhaps it needs to be used in
-`DoAll()` and it's not the last in the list). `IgnoreResult()` lets
-you do that. For example:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::Return;
-
-int Process(const MyData& data);
-string DoSomething();
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(Abc, void(const MyData& data));
-  MOCK_METHOD0(Xyz, bool());
-};
-...
-
-  MockFoo foo;
-  EXPECT_CALL(foo, Abc(_))
-  // .WillOnce(Invoke(Process));
-  // The above line won't compile as Process() returns int but Abc() needs
-  // to return void.
-      .WillOnce(IgnoreResult(Invoke(Process)));
-
-  EXPECT_CALL(foo, Xyz())
-      .WillOnce(DoAll(IgnoreResult(Invoke(DoSomething)),
-      // Ignores the string DoSomething() returns.
-                      Return(true)));
-```
-
-Note that you **cannot** use `IgnoreResult()` on an action that already
-returns `void`. Doing so will lead to ugly compiler errors.
-
-## Selecting an Action's Arguments ##
-
-Say you have a mock function `Foo()` that takes seven arguments, and
-you have a custom action that you want to invoke when `Foo()` is
-called. Trouble is, the custom action only wants three arguments:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-...
-  MOCK_METHOD7(Foo, bool(bool visible, const string& name, int x, int y,
-                         const map<pair<int, int>, double>& weight,
-                         double min_weight, double max_wight));
-...
-
-bool IsVisibleInQuadrant1(bool visible, int x, int y) {
-  return visible && x >= 0 && y >= 0;
-}
-...
-
-  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
-      .WillOnce(Invoke(IsVisibleInQuadrant1));  // Uh, won't compile. :-(
-```
-
-To please the compiler God, you can to define an "adaptor" that has
-the same signature as `Foo()` and calls the custom action with the
-right arguments:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-bool MyIsVisibleInQuadrant1(bool visible, const string& name, int x, int y,
-                            const map<pair<int, int>, double>& weight,
-                            double min_weight, double max_wight) {
-  return IsVisibleInQuadrant1(visible, x, y);
-}
-...
-
-  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
-      .WillOnce(Invoke(MyIsVisibleInQuadrant1));  // Now it works.
-```
-
-But isn't this awkward?
-
-Google Mock provides a generic _action adaptor_, so you can spend your
-time minding more important business than writing your own
-adaptors. Here's the syntax:
-
-```
-  WithArgs<N1, N2, ..., Nk>(action)
-```
-
-creates an action that passes the arguments of the mock function at
-the given indices (0-based) to the inner `action` and performs
-it. Using `WithArgs`, our original example can be written as:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::WithArgs;
-...
-  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
-      .WillOnce(WithArgs<0, 2, 3>(Invoke(IsVisibleInQuadrant1)));
-      // No need to define your own adaptor.
-```
-
-For better readability, Google Mock also gives you:
-
-  * `WithoutArgs(action)` when the inner `action` takes _no_ argument, and
-  * `WithArg<N>(action)` (no `s` after `Arg`) when the inner `action` takes _one_ argument.
-
-As you may have realized, `InvokeWithoutArgs(...)` is just syntactic
-sugar for `WithoutArgs(Invoke(...))`.
-
-Here are more tips:
-
-  * The inner action used in `WithArgs` and friends does not have to be `Invoke()` -- it can be anything.
-  * You can repeat an argument in the argument list if necessary, e.g. `WithArgs<2, 3, 3, 5>(...)`.
-  * You can change the order of the arguments, e.g. `WithArgs<3, 2, 1>(...)`.
-  * The types of the selected arguments do _not_ have to match the signature of the inner action exactly. It works as long as they can be implicitly converted to the corresponding arguments of the inner action. For example, if the 4-th argument of the mock function is an `int` and `my_action` takes a `double`, `WithArg<4>(my_action)` will work.
-
-## Ignoring Arguments in Action Functions ##
-
-The selecting-an-action's-arguments recipe showed us one way to make a
-mock function and an action with incompatible argument lists fit
-together. The downside is that wrapping the action in
-`WithArgs<...>()` can get tedious for people writing the tests.
-
-If you are defining a function, method, or functor to be used with
-`Invoke*()`, and you are not interested in some of its arguments, an
-alternative to `WithArgs` is to declare the uninteresting arguments as
-`Unused`. This makes the definition less cluttered and less fragile in
-case the types of the uninteresting arguments change. It could also
-increase the chance the action function can be reused. For example,
-given
-
-```
-  MOCK_METHOD3(Foo, double(const string& label, double x, double y));
-  MOCK_METHOD3(Bar, double(int index, double x, double y));
-```
-
-instead of
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-double DistanceToOriginWithLabel(const string& label, double x, double y) {
-  return sqrt(x*x + y*y);
-}
-
-double DistanceToOriginWithIndex(int index, double x, double y) {
-  return sqrt(x*x + y*y);
-}
-...
-
-  EXEPCT_CALL(mock, Foo("abc", _, _))
-      .WillOnce(Invoke(DistanceToOriginWithLabel));
-  EXEPCT_CALL(mock, Bar(5, _, _))
-      .WillOnce(Invoke(DistanceToOriginWithIndex));
-```
-
-you could write
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::Unused;
-
-double DistanceToOrigin(Unused, double x, double y) {
-  return sqrt(x*x + y*y);
-}
-...
-
-  EXEPCT_CALL(mock, Foo("abc", _, _))
-      .WillOnce(Invoke(DistanceToOrigin));
-  EXEPCT_CALL(mock, Bar(5, _, _))
-      .WillOnce(Invoke(DistanceToOrigin));
-```
-
-## Sharing Actions ##
-
-Just like matchers, a Google Mock action object consists of a pointer
-to a ref-counted implementation object. Therefore copying actions is
-also allowed and very efficient. When the last action that references
-the implementation object dies, the implementation object will be
-deleted.
-
-If you have some complex action that you want to use again and again,
-you may not have to build it from scratch everytime. If the action
-doesn't have an internal state (i.e. if it always does the same thing
-no matter how many times it has been called), you can assign it to an
-action variable and use that variable repeatedly. For example:
-
-```
-  Action<bool(int*)> set_flag = DoAll(SetArgPointee<0>(5),
-                                      Return(true));
-  ... use set_flag in .WillOnce() and .WillRepeatedly() ...
-```
-
-However, if the action has its own state, you may be surprised if you
-share the action object. Suppose you have an action factory
-`IncrementCounter(init)` which creates an action that increments and
-returns a counter whose initial value is `init`, using two actions
-created from the same expression and using a shared action will
-exihibit different behaviors. Example:
-
-```
-  EXPECT_CALL(foo, DoThis())
-      .WillRepeatedly(IncrementCounter(0));
-  EXPECT_CALL(foo, DoThat())
-      .WillRepeatedly(IncrementCounter(0));
-  foo.DoThis();  // Returns 1.
-  foo.DoThis();  // Returns 2.
-  foo.DoThat();  // Returns 1 - Blah() uses a different
-                 // counter than Bar()'s.
-```
-
-versus
-
-```
-  Action<int()> increment = IncrementCounter(0);
-
-  EXPECT_CALL(foo, DoThis())
-      .WillRepeatedly(increment);
-  EXPECT_CALL(foo, DoThat())
-      .WillRepeatedly(increment);
-  foo.DoThis();  // Returns 1.
-  foo.DoThis();  // Returns 2.
-  foo.DoThat();  // Returns 3 - the counter is shared.
-```
-
-# Misc Recipes on Using Google Mock #
-
-## Mocking Methods That Use Move-Only Types ##
-
-C++11 introduced <em>move-only types</em>.  A move-only-typed value can be moved from one object to another, but cannot be copied.  `std::unique_ptr<T>` is probably the most commonly used move-only type.
-
-Mocking a method that takes and/or returns move-only types presents some challenges, but nothing insurmountable.  This recipe shows you how you can do it.
-
-Let’s say we are working on a fictional project that lets one post and share snippets called “buzzes”.  Your code uses these types:
-
-```
-enum class AccessLevel { kInternal, kPublic };
-
-class Buzz {
- public:
-  explicit Buzz(AccessLevel access) { … }
-  ...
-};
-
-class Buzzer {
- public:
-  virtual ~Buzzer() {}
-  virtual std::unique_ptr<Buzz> MakeBuzz(const std::string& text) = 0;
-  virtual bool ShareBuzz(std::unique_ptr<Buzz> buzz, Time timestamp) = 0;
-  ...
-};
-```
-
-A `Buzz` object represents a snippet being posted.  A class that implements the `Buzzer` interface is capable of creating and sharing `Buzz`.  Methods in `Buzzer` may return a `unique_ptr<Buzz>` or take a `unique_ptr<Buzz>`.  Now we need to mock `Buzzer` in our tests.
-
-To mock a method that returns a move-only type, you just use the familiar `MOCK_METHOD` syntax as usual:
-
-```
-class MockBuzzer : public Buzzer {
- public:
-  MOCK_METHOD1(MakeBuzz, std::unique_ptr<Buzz>(const std::string& text));
-  …
-};
-```
-
-However, if you attempt to use the same `MOCK_METHOD` pattern to mock a method that takes a move-only parameter, you’ll get a compiler error currently:
-
-```
-  // Does NOT compile!
-  MOCK_METHOD2(ShareBuzz, bool(std::unique_ptr<Buzz> buzz, Time timestamp));
-```
-
-While it’s highly desirable to make this syntax just work, it’s not trivial and the work hasn’t been done yet.  Fortunately, there is a trick you can apply today to get something that works nearly as well as this.
-
-The trick, is to delegate the `ShareBuzz()` method to a mock method (let’s call it `DoShareBuzz()`) that does not take move-only parameters:
-
-```
-class MockBuzzer : public Buzzer {
- public:
-  MOCK_METHOD1(MakeBuzz, std::unique_ptr<Buzz>(const std::string& text));
-  MOCK_METHOD2(DoShareBuzz, bool(Buzz* buzz, Time timestamp));
-  bool ShareBuzz(std::unique_ptr<Buzz> buzz, Time timestamp) {
-    return DoShareBuzz(buzz.get(), timestamp);
-  }
-};
-```
-
-Note that there's no need to define or declare `DoShareBuzz()` in a base class.  You only need to define it as a `MOCK_METHOD` in the mock class.
-
-Now that we have the mock class defined, we can use it in tests.  In the following code examples, we assume that we have defined a `MockBuzzer` object named `mock_buzzer_`:
-
-```
-  MockBuzzer mock_buzzer_;
-```
-
-First let’s see how we can set expectations on the `MakeBuzz()` method, which returns a `unique_ptr<Buzz>`.
-
-As usual, if you set an expectation without an action (i.e. the `.WillOnce()` or `.WillRepeated()` clause), when that expectation fires, the default action for that method will be taken.  Since `unique_ptr<>` has a default constructor that returns a null `unique_ptr`, that’s what you’ll get if you don’t specify an action:
-
-```
-  // Use the default action.
-  EXPECT_CALL(mock_buzzer_, MakeBuzz("hello"));
-
-  // Triggers the previous EXPECT_CALL.
-  EXPECT_EQ(nullptr, mock_buzzer_.MakeBuzz("hello"));
-```
-
-If you are not happy with the default action, you can tweak it.  Depending on what you need, you may either tweak the default action for a specific (mock object, mock method) combination using `ON_CALL()`, or you may tweak the default action for all mock methods that return a specific type.  The usage of `ON_CALL()` is similar to `EXPECT_CALL()`, so we’ll skip it and just explain how to do the latter (tweaking the default action for a specific return type).  You do this via the `DefaultValue<>::SetFactory()` and `DefaultValue<>::Clear()` API:
-
-```
-  // Sets the default action for return type std::unique_ptr<Buzz> to
-  // creating a new Buzz every time.
-  DefaultValue<std::unique_ptr<Buzz>>::SetFactory(
-      [] { return MakeUnique<Buzz>(AccessLevel::kInternal); });
-
-  // When this fires, the default action of MakeBuzz() will run, which
-  // will return a new Buzz object.
-  EXPECT_CALL(mock_buzzer_, MakeBuzz("hello")).Times(AnyNumber());
-
-  auto buzz1 = mock_buzzer_.MakeBuzz("hello");
-  auto buzz2 = mock_buzzer_.MakeBuzz("hello");
-  EXPECT_NE(nullptr, buzz1);
-  EXPECT_NE(nullptr, buzz2);
-  EXPECT_NE(buzz1, buzz2);
-
-  // Resets the default action for return type std::unique_ptr<Buzz>,
-  // to avoid interfere with other tests.
-  DefaultValue<std::unique_ptr<Buzz>>::Clear();
-```
-
-What if you want the method to do something other than the default action?  If you just need to return a pre-defined move-only value, you can use the `Return(ByMove(...))` action:
-
-```
-  // When this fires, the unique_ptr<> specified by ByMove(...) will
-  // be returned.
-  EXPECT_CALL(mock_buzzer_, MakeBuzz("world"))
-      .WillOnce(Return(ByMove(MakeUnique<Buzz>(AccessLevel::kInternal))));
-
-  EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("world"));
-```
-
-Note that `ByMove()` is essential here - if you drop it, the code won’t compile.
-
-Quiz time!  What do you think will happen if a `Return(ByMove(...))` action is performed more than once (e.g. you write `….WillRepeatedly(Return(ByMove(...)));`)?  Come think of it, after the first time the action runs, the source value will be consumed (since it’s a move-only value), so the next time around, there’s no value to move from -- you’ll get a run-time error that `Return(ByMove(...))` can only be run once.
-
-If you need your mock method to do more than just moving a pre-defined value, remember that you can always use `Invoke()` to call a lambda or a callable object, which can do pretty much anything you want:
-
-```
-  EXPECT_CALL(mock_buzzer_, MakeBuzz("x"))
-      .WillRepeatedly(Invoke([](const std::string& text) {
-        return std::make_unique<Buzz>(AccessLevel::kInternal);
-      }));
-
-  EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("x"));
-  EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("x"));
-```
-
-Every time this `EXPECT_CALL` fires, a new `unique_ptr<Buzz>` will be created and returned.  You cannot do this with `Return(ByMove(...))`.
-
-Now there’s one topic we haven’t covered: how do you set expectations on `ShareBuzz()`, which takes a move-only-typed parameter?  The answer is you don’t.  Instead, you set expectations on the `DoShareBuzz()` mock method (remember that we defined a `MOCK_METHOD` for `DoShareBuzz()`, not `ShareBuzz()`):
-
-```
-  EXPECT_CALL(mock_buzzer_, DoShareBuzz(NotNull(), _));
-
-  // When one calls ShareBuzz() on the MockBuzzer like this, the call is
-  // forwarded to DoShareBuzz(), which is mocked.  Therefore this statement
-  // will trigger the above EXPECT_CALL.
-  mock_buzzer_.ShareBuzz(MakeUnique&lt;Buzz&gt;(AccessLevel::kInternal),
-                         ::base::Now());
-```
-
-Some of you may have spotted one problem with this approach: the `DoShareBuzz()` mock method differs from the real `ShareBuzz()` method in that it cannot take ownership of the buzz parameter - `ShareBuzz()` will always delete buzz after `DoShareBuzz()` returns.  What if you need to save the buzz object somewhere for later use when `ShareBuzz()` is called?  Indeed, you'd be stuck.
-
-Another problem with the `DoShareBuzz()` we had is that it can surprise people reading or maintaining the test, as one would expect that `DoShareBuzz()` has (logically) the same contract as `ShareBuzz()`.
-
-Fortunately, these problems can be fixed with a bit more code.  Let's try to get it right this time:
-
-```
-class MockBuzzer : public Buzzer {
- public:
-  MockBuzzer() {
-    // Since DoShareBuzz(buzz, time) is supposed to take ownership of
-    // buzz, define a default behavior for DoShareBuzz(buzz, time) to
-    // delete buzz.
-    ON_CALL(*this, DoShareBuzz(_, _))
-        .WillByDefault(Invoke([](Buzz* buzz, Time timestamp) {
-          delete buzz;
-          return true;
-        }));
-  }
-
-  MOCK_METHOD1(MakeBuzz, std::unique_ptr<Buzz>(const std::string& text));
-
-  // Takes ownership of buzz.
-  MOCK_METHOD2(DoShareBuzz, bool(Buzz* buzz, Time timestamp));
-  bool ShareBuzz(std::unique_ptr<Buzz> buzz, Time timestamp) {
-    return DoShareBuzz(buzz.release(), timestamp);
-  }
-};
-```
-
-Now, the mock `DoShareBuzz()` method is free to save the buzz argument for later use if this is what you want:
-
-```
-  std::unique_ptr<Buzz> intercepted_buzz;
-  EXPECT_CALL(mock_buzzer_, DoShareBuzz(NotNull(), _))
-      .WillOnce(Invoke([&amp;intercepted_buzz](Buzz* buzz, Time timestamp) {
-        // Save buzz in intercepted_buzz for analysis later.
-        intercepted_buzz.reset(buzz);
-        return false;
-      }));
-
-  mock_buzzer_.ShareBuzz(std::make_unique<Buzz>(AccessLevel::kInternal),
-                         Now());
-  EXPECT_NE(nullptr, intercepted_buzz);
-```
-
-Using the tricks covered in this recipe, you are now able to mock methods that take and/or return move-only types.  Put your newly-acquired power to good use - when you design a new API, you can now feel comfortable using `unique_ptrs` as appropriate, without fearing that doing so will compromise your tests.
-
-## Making the Compilation Faster ##
-
-Believe it or not, the _vast majority_ of the time spent on compiling
-a mock class is in generating its constructor and destructor, as they
-perform non-trivial tasks (e.g. verification of the
-expectations). What's more, mock methods with different signatures
-have different types and thus their constructors/destructors need to
-be generated by the compiler separately. As a result, if you mock many
-different types of methods, compiling your mock class can get really
-slow.
-
-If you are experiencing slow compilation, you can move the definition
-of your mock class' constructor and destructor out of the class body
-and into a `.cpp` file. This way, even if you `#include` your mock
-class in N files, the compiler only needs to generate its constructor
-and destructor once, resulting in a much faster compilation.
-
-Let's illustrate the idea using an example. Here's the definition of a
-mock class before applying this recipe:
-
-```
-// File mock_foo.h.
-...
-class MockFoo : public Foo {
- public:
-  // Since we don't declare the constructor or the destructor,
-  // the compiler will generate them in every translation unit
-  // where this mock class is used.
-
-  MOCK_METHOD0(DoThis, int());
-  MOCK_METHOD1(DoThat, bool(const char* str));
-  ... more mock methods ...
-};
-```
-
-After the change, it would look like:
-
-```
-// File mock_foo.h.
-...
-class MockFoo : public Foo {
- public:
-  // The constructor and destructor are declared, but not defined, here.
-  MockFoo();
-  virtual ~MockFoo();
-
-  MOCK_METHOD0(DoThis, int());
-  MOCK_METHOD1(DoThat, bool(const char* str));
-  ... more mock methods ...
-};
-```
-and
-```
-// File mock_foo.cpp.
-#include "path/to/mock_foo.h"
-
-// The definitions may appear trivial, but the functions actually do a
-// lot of things through the constructors/destructors of the member
-// variables used to implement the mock methods.
-MockFoo::MockFoo() {}
-MockFoo::~MockFoo() {}
-```
-
-## Forcing a Verification ##
-
-When it's being destoyed, your friendly mock object will automatically
-verify that all expectations on it have been satisfied, and will
-generate [Google Test](../../googletest/) failures
-if not. This is convenient as it leaves you with one less thing to
-worry about. That is, unless you are not sure if your mock object will
-be destoyed.
-
-How could it be that your mock object won't eventually be destroyed?
-Well, it might be created on the heap and owned by the code you are
-testing. Suppose there's a bug in that code and it doesn't delete the
-mock object properly - you could end up with a passing test when
-there's actually a bug.
-
-Using a heap checker is a good idea and can alleviate the concern, but
-its implementation may not be 100% reliable. So, sometimes you do want
-to _force_ Google Mock to verify a mock object before it is
-(hopefully) destructed. You can do this with
-`Mock::VerifyAndClearExpectations(&mock_object)`:
-
-```
-TEST(MyServerTest, ProcessesRequest) {
-  using ::testing::Mock;
-
-  MockFoo* const foo = new MockFoo;
-  EXPECT_CALL(*foo, ...)...;
-  // ... other expectations ...
-
-  // server now owns foo.
-  MyServer server(foo);
-  server.ProcessRequest(...);
-
-  // In case that server's destructor will forget to delete foo,
-  // this will verify the expectations anyway.
-  Mock::VerifyAndClearExpectations(foo);
-}  // server is destroyed when it goes out of scope here.
-```
-
-**Tip:** The `Mock::VerifyAndClearExpectations()` function returns a
-`bool` to indicate whether the verification was successful (`true` for
-yes), so you can wrap that function call inside a `ASSERT_TRUE()` if
-there is no point going further when the verification has failed.
-
-## Using Check Points ##
-
-Sometimes you may want to "reset" a mock object at various check
-points in your test: at each check point, you verify that all existing
-expectations on the mock object have been satisfied, and then you set
-some new expectations on it as if it's newly created. This allows you
-to work with a mock object in "phases" whose sizes are each
-manageable.
-
-One such scenario is that in your test's `SetUp()` function, you may
-want to put the object you are testing into a certain state, with the
-help from a mock object. Once in the desired state, you want to clear
-all expectations on the mock, such that in the `TEST_F` body you can
-set fresh expectations on it.
-
-As you may have figured out, the `Mock::VerifyAndClearExpectations()`
-function we saw in the previous recipe can help you here. Or, if you
-are using `ON_CALL()` to set default actions on the mock object and
-want to clear the default actions as well, use
-`Mock::VerifyAndClear(&mock_object)` instead. This function does what
-`Mock::VerifyAndClearExpectations(&mock_object)` does and returns the
-same `bool`, **plus** it clears the `ON_CALL()` statements on
-`mock_object` too.
-
-Another trick you can use to achieve the same effect is to put the
-expectations in sequences and insert calls to a dummy "check-point"
-function at specific places. Then you can verify that the mock
-function calls do happen at the right time. 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:
-
-```
-using ::testing::MockFunction;
-
-TEST(FooTest, InvokesBarCorrectly) {
-  MyMock mock;
-  // Class MockFunction<F> has exactly one mock method.  It is named
-  // Call() and has type F.
-  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()`.
-
-## Mocking Destructors ##
-
-Sometimes you want to make sure a mock object is destructed at the
-right time, e.g. after `bar->A()` is called but before `bar->B()` is
-called. We already know that you can specify constraints on the order
-of mock function calls, so all we need to do is to mock the destructor
-of the mock function.
-
-This sounds simple, except for one problem: a destructor is a special
-function with special syntax and special semantics, and the
-`MOCK_METHOD0` macro doesn't work for it:
-
-```
-  MOCK_METHOD0(~MockFoo, void());  // Won't compile!
-```
-
-The good news is that you can use a simple pattern to achieve the same
-effect. First, add a mock function `Die()` to your mock class and call
-it in the destructor, like this:
-
-```
-class MockFoo : public Foo {
-  ...
-  // Add the following two lines to the mock class.
-  MOCK_METHOD0(Die, void());
-  virtual ~MockFoo() { Die(); }
-};
-```
-
-(If the name `Die()` clashes with an existing symbol, choose another
-name.) Now, we have translated the problem of testing when a `MockFoo`
-object dies to testing when its `Die()` method is called:
-
-```
-  MockFoo* foo = new MockFoo;
-  MockBar* bar = new MockBar;
-  ...
-  {
-    InSequence s;
-
-    // Expects *foo to die after bar->A() and before bar->B().
-    EXPECT_CALL(*bar, A());
-    EXPECT_CALL(*foo, Die());
-    EXPECT_CALL(*bar, B());
-  }
-```
-
-And that's that.
-
-## Using Google Mock and Threads ##
-
-**IMPORTANT NOTE:** What we describe in this recipe is **ONLY** true on
-platforms where Google Mock is thread-safe. Currently these are only
-platforms that support the pthreads library (this includes Linux and Mac).
-To make it thread-safe on other platforms we only need to implement
-some synchronization operations in `"gtest/internal/gtest-port.h"`.
-
-In a **unit** test, it's best if you could isolate and test a piece of
-code in a single-threaded context. That avoids race conditions and
-dead locks, and makes debugging your test much easier.
-
-Yet many programs are multi-threaded, and sometimes to test something
-we need to pound on it from more than one thread. Google Mock works
-for this purpose too.
-
-Remember the steps for using a mock:
-
-  1. Create a mock object `foo`.
-  1. Set its default actions and expectations using `ON_CALL()` and `EXPECT_CALL()`.
-  1. The code under test calls methods of `foo`.
-  1. Optionally, verify and reset the mock.
-  1. Destroy the mock yourself, or let the code under test destroy it. The destructor will automatically verify it.
-
-If you follow the following simple rules, your mocks and threads can
-live happily together:
-
-  * Execute your _test code_ (as opposed to the code being tested) in _one_ thread. This makes your test easy to follow.
-  * Obviously, you can do step #1 without locking.
-  * When doing step #2 and #5, make sure no other thread is accessing `foo`. Obvious too, huh?
-  * #3 and #4 can be done either in one thread or in multiple threads - anyway you want. Google Mock takes care of the locking, so you don't have to do any - unless required by your test logic.
-
-If you violate the rules (for example, if you set expectations on a
-mock while another thread is calling its methods), you get undefined
-behavior. That's not fun, so don't do it.
-
-Google Mock guarantees that the action for a mock function is done in
-the same thread that called the mock function. For example, in
-
-```
-  EXPECT_CALL(mock, Foo(1))
-      .WillOnce(action1);
-  EXPECT_CALL(mock, Foo(2))
-      .WillOnce(action2);
-```
-
-if `Foo(1)` is called in thread 1 and `Foo(2)` is called in thread 2,
-Google Mock will execute `action1` in thread 1 and `action2` in thread
-2.
-
-Google Mock does _not_ impose a sequence on actions performed in
-different threads (doing so may create deadlocks as the actions may
-need to cooperate). This means that the execution of `action1` and
-`action2` in the above example _may_ interleave. If this is a problem,
-you should add proper synchronization logic to `action1` and `action2`
-to make the test thread-safe.
-
-
-Also, remember that `DefaultValue<T>` is a global resource that
-potentially affects _all_ living mock objects in your
-program. Naturally, you won't want to mess with it from multiple
-threads or when there still are mocks in action.
-
-## Controlling How Much Information Google Mock Prints ##
-
-When Google Mock sees something that has the potential of being an
-error (e.g. a mock function with no expectation is called, a.k.a. an
-uninteresting call, which is allowed but perhaps you forgot to
-explicitly ban the call), it prints some warning messages, including
-the arguments of the function and the return value. Hopefully this
-will remind you to take a look and see if there is indeed a problem.
-
-Sometimes you are confident that your tests are correct and may not
-appreciate such friendly messages. Some other times, you are debugging
-your tests or learning about the behavior of the code you are testing,
-and wish you could observe every mock call that happens (including
-argument values and the return value). Clearly, one size doesn't fit
-all.
-
-You can control how much Google Mock tells you using the
-`--gmock_verbose=LEVEL` command-line flag, where `LEVEL` is a string
-with three possible values:
-
-  * `info`: Google Mock will print all informational messages, warnings, and errors (most verbose). At this setting, Google Mock will also log any calls to the `ON_CALL/EXPECT_CALL` macros.
-  * `warning`: Google Mock will print both warnings and errors (less verbose). This is the default.
-  * `error`: Google Mock will print errors only (least verbose).
-
-Alternatively, you can adjust the value of that flag from within your
-tests like so:
-
-```
-  ::testing::FLAGS_gmock_verbose = "error";
-```
-
-Now, judiciously use the right flag to enable Google Mock serve you better!
-
-## Gaining Super Vision into Mock Calls ##
-
-You have a test using Google Mock. It fails: Google Mock tells you
-that some expectations aren't satisfied. However, you aren't sure why:
-Is there a typo somewhere in the matchers? Did you mess up the order
-of the `EXPECT_CALL`s? Or is the code under test doing something
-wrong?  How can you find out the cause?
-
-Won't it be nice if you have X-ray vision and can actually see the
-trace of all `EXPECT_CALL`s and mock method calls as they are made?
-For each call, would you like to see its actual argument values and
-which `EXPECT_CALL` Google Mock thinks it matches?
-
-You can unlock this power by running your test with the
-`--gmock_verbose=info` flag. For example, given the test program:
-
-```
-using testing::_;
-using testing::HasSubstr;
-using testing::Return;
-
-class MockFoo {
- public:
-  MOCK_METHOD2(F, void(const string& x, const string& y));
-};
-
-TEST(Foo, Bar) {
-  MockFoo mock;
-  EXPECT_CALL(mock, F(_, _)).WillRepeatedly(Return());
-  EXPECT_CALL(mock, F("a", "b"));
-  EXPECT_CALL(mock, F("c", HasSubstr("d")));
-
-  mock.F("a", "good");
-  mock.F("a", "b");
-}
-```
-
-if you run it with `--gmock_verbose=info`, you will see this output:
-
-```
-[ RUN      ] Foo.Bar
-
-foo_test.cc:14: EXPECT_CALL(mock, F(_, _)) invoked
-foo_test.cc:15: EXPECT_CALL(mock, F("a", "b")) invoked
-foo_test.cc:16: EXPECT_CALL(mock, F("c", HasSubstr("d"))) invoked
-foo_test.cc:14: Mock function call matches EXPECT_CALL(mock, F(_, _))...
-    Function call: F(@0x7fff7c8dad40"a", @0x7fff7c8dad10"good")
-foo_test.cc:15: Mock function call matches EXPECT_CALL(mock, F("a", "b"))...
-    Function call: F(@0x7fff7c8dada0"a", @0x7fff7c8dad70"b")
-foo_test.cc:16: Failure
-Actual function call count doesn't match EXPECT_CALL(mock, F("c", HasSubstr("d")))...
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] Foo.Bar
-```
-
-Suppose the bug is that the `"c"` in the third `EXPECT_CALL` is a typo
-and should actually be `"a"`. With the above message, you should see
-that the actual `F("a", "good")` call is matched by the first
-`EXPECT_CALL`, not the third as you thought. From that it should be
-obvious that the third `EXPECT_CALL` is written wrong. Case solved.
-
-## Running Tests in Emacs ##
-
-If you build and run your tests in Emacs, the source file locations of
-Google Mock and [Google Test](../../googletest/)
-errors will be highlighted. Just press `<Enter>` on one of them and
-you'll be taken to the offending line. Or, you can just type `C-x ``
-to jump to the next error.
-
-To make it even easier, you can add the following lines to your
-`~/.emacs` file:
-
-```
-(global-set-key "\M-m"   'compile)  ; m is for make
-(global-set-key [M-down] 'next-error)
-(global-set-key [M-up]   '(lambda () (interactive) (next-error -1)))
-```
-
-Then you can type `M-m` to start a build, or `M-up`/`M-down` to move
-back and forth between errors.
-
-## Fusing Google Mock Source Files ##
-
-Google Mock's implementation consists of dozens of files (excluding
-its own tests).  Sometimes you may want them to be packaged up in
-fewer files instead, such that you can easily copy them to a new
-machine and start hacking there.  For this we provide an experimental
-Python script `fuse_gmock_files.py` in the `scripts/` directory
-(starting with release 1.2.0).  Assuming you have Python 2.4 or above
-installed on your machine, just go to that directory and run
-```
-python fuse_gmock_files.py OUTPUT_DIR
-```
-
-and you should see an `OUTPUT_DIR` directory being created with files
-`gtest/gtest.h`, `gmock/gmock.h`, and `gmock-gtest-all.cc` in it.
-These three files contain everything you need to use Google Mock (and
-Google Test).  Just copy them to anywhere you want and you are ready
-to write tests and use mocks.  You can use the
-[scrpts/test/Makefile](../scripts/test/Makefile) file as an example on how to compile your tests
-against them.
-
-# Extending Google Mock #
-
-## Writing New Matchers Quickly ##
-
-The `MATCHER*` family of macros can be used to define custom matchers
-easily.  The syntax:
-
-```
-MATCHER(name, description_string_expression) { statements; }
-```
-
-will define 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 is a `string`-typed expression that documents
-what the matcher does, and is used to generate the failure message
-when the match fails.  It can (and should) reference the special
-`bool` variable `negation`, and should evaluate to the description of
-the matcher when `negation` is `false`, or that of the matcher's
-negation when `negation` is `true`.
-
-For convenience, we allow the description string to be empty (`""`),
-in which case Google Mock will use the sequence of words in the
-matcher name as the description.
-
-For example:
-```
-MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; }
-```
-allows you to write
-```
-  // Expects mock_foo.Bar(n) to be called where n is divisible by 7.
-  EXPECT_CALL(mock_foo, Bar(IsDivisibleBy7()));
-```
-or,
-```
-using ::testing::Not;
-...
-  EXPECT_THAT(some_expression, IsDivisibleBy7());
-  EXPECT_THAT(some_other_expression, Not(IsDivisibleBy7()));
-```
-If the above assertions fail, they will print something like:
-```
-  Value of: some_expression
-  Expected: is divisible by 7
-    Actual: 27
-...
-  Value of: some_other_expression
-  Expected: not (is divisible by 7)
-    Actual: 21
-```
-where the descriptions `"is divisible by 7"` and `"not (is divisible
-by 7)"` are automatically calculated from the matcher name
-`IsDivisibleBy7`.
-
-As you may have noticed, the auto-generated descriptions (especially
-those for the negation) may not be so great. You can always override
-them with a string expression of your own:
-```
-MATCHER(IsDivisibleBy7, std::string(negation ? "isn't" : "is") +
-                        " divisible by 7") {
-  return (arg % 7) == 0;
-}
-```
-
-Optionally, you can stream additional information to a hidden argument
-named `result_listener` to explain the match result. For example, a
-better definition of `IsDivisibleBy7` is:
-```
-MATCHER(IsDivisibleBy7, "") {
-  if ((arg % 7) == 0)
-    return true;
-
-  *result_listener << "the remainder is " << (arg % 7);
-  return false;
-}
-```
-
-With this definition, the above assertion will give a better message:
-```
-  Value of: some_expression
-  Expected: is divisible by 7
-    Actual: 27 (the remainder is 6)
-```
-
-You should let `MatchAndExplain()` print _any additional information_
-that can help a user understand the match result. Note that it should
-explain why the match succeeds in case of a success (unless it's
-obvious) - this is useful when the matcher is used inside
-`Not()`. There is no need to print the argument value itself, as
-Google Mock already prints it for you.
-
-**Notes:**
-
-  1. 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, `IsDivisibleBy7()` can be used to match any type where the value of `(arg % 7) == 0` can be implicitly converted to a `bool`.  In the `Bar(IsDivisibleBy7())` 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.
-  1. Google Mock doesn't guarantee when or how many times a matcher will be invoked. Therefore the matcher logic must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters). This requirement must be satisfied no matter how you define the matcher (e.g. using one of the methods described in the following recipes). In particular, a matcher can never call a mock function, as that will affect the state of the mock object and Google Mock.
-
-## Writing New Parameterized Matchers Quickly ##
-
-Sometimes you'll want to define a matcher that has parameters.  For that you
-can use the macro:
-```
-MATCHER_P(name, param_name, description_string) { statements; }
-```
-where the description string can be either `""` or a string expression
-that references `negation` and `param_name`.
-
-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`.
-
-Google Mock also provides `MATCHER_P2`, `MATCHER_P3`, ..., up to
-`MATCHER_P10` to support multi-parameter matchers:
-```
-MATCHER_Pk(name, param_1, ..., param_k, description_string) { statements; }
-```
-
-Please note that the custom description string is for a particular
-**instance** of the matcher, where the parameters have been bound to
-actual values.  Therefore usually you'll want the parameter values to
-be part of the description.  Google Mock lets you do that by
-referencing the matcher parameters in the description string
-expression.
-
-For example,
-```
-  using ::testing::PrintToString;
-  MATCHER_P2(InClosedRange, low, hi,
-             std::string(negation ? "isn't" : "is") + " in range [" +
-             PrintToString(low) + ", " + PrintToString(hi) + "]") {
-    return low <= arg && arg <= hi;
-  }
-  ...
-  EXPECT_THAT(3, InClosedRange(4, 6));
-```
-would generate a failure that contains the message:
-```
-  Expected: is in range [4, 6]
-```
-
-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));
-```
-would generate a failure that contains the text:
-```
-  Expected: in closed range (4, 6)
-```
-
-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.  Matchers that don't have a parameter
-or have only one parameter have special types: you can assign `Foo()`
-to a `FooMatcher`-typed variable, and assign `Foo(p)` to a
-`FooMatcherP<p_type>`-typed variable.
-
-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.
-
-You can overload matchers with different numbers of parameters:
-```
-MATCHER_P(Blah, a, description_string_1) { ... }
-MATCHER_P2(Blah, a, b, description_string_2) { ... }
-```
-
-While it's tempting to always use the `MATCHER*` macros when defining
-a new matcher, you should also consider implementing
-`MatcherInterface` or using `MakePolymorphicMatcher()` instead (see
-the recipes that follow), especially if you need to use the matcher a
-lot.  While these approaches require more work, they give you more
-control on the types of the value being matched and the matcher
-parameters, which in general leads to better compiler error messages
-that pay off in the long run.  They also allow overloading matchers
-based on parameter types (as opposed to just based on the number of
-parameters).
-
-## Writing New Monomorphic Matchers ##
-
-A matcher of argument type `T` implements
-`::testing::MatcherInterface<T>` and does two things: it tests whether a
-value of type `T` matches the matcher, and can describe what kind of
-values it matches. The latter ability is used for generating readable
-error messages when expectations are violated.
-
-The interface looks like this:
-
-```
-class MatchResultListener {
- public:
-  ...
-  // Streams x to the underlying ostream; does nothing if the ostream
-  // is NULL.
-  template <typename T>
-  MatchResultListener& operator<<(const T& x);
-
-  // Returns the underlying ostream.
-  ::std::ostream* stream();
-};
-
-template <typename T>
-class MatcherInterface {
- public:
-  virtual ~MatcherInterface();
-
-  // Returns true iff the matcher matches x; also explains the match
-  // result to 'listener'.
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
-
-  // Describes this matcher to an ostream.
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-
-  // Describes the negation of this matcher to an ostream.
-  virtual void DescribeNegationTo(::std::ostream* os) const;
-};
-```
-
-If you need a custom matcher but `Truly()` is not a good option (for
-example, you may not be happy with the way `Truly(predicate)`
-describes itself, or you may want your matcher to be polymorphic as
-`Eq(value)` is), you can define a matcher to do whatever you want in
-two steps: first implement the matcher interface, and then define a
-factory function to create a matcher instance. The second step is not
-strictly needed but it makes the syntax of using the matcher nicer.
-
-For example, you can define a matcher to test whether an `int` is
-divisible by 7 and then use it like this:
-```
-using ::testing::MakeMatcher;
-using ::testing::Matcher;
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-
-class DivisibleBy7Matcher : public MatcherInterface<int> {
- public:
-  virtual bool MatchAndExplain(int n, MatchResultListener* listener) const {
-    return (n % 7) == 0;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "is divisible by 7";
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is not divisible by 7";
-  }
-};
-
-inline Matcher<int> DivisibleBy7() {
-  return MakeMatcher(new DivisibleBy7Matcher);
-}
-...
-
-  EXPECT_CALL(foo, Bar(DivisibleBy7()));
-```
-
-You may improve the matcher message by streaming additional
-information to the `listener` argument in `MatchAndExplain()`:
-
-```
-class DivisibleBy7Matcher : public MatcherInterface<int> {
- public:
-  virtual bool MatchAndExplain(int n,
-                               MatchResultListener* listener) const {
-    const int remainder = n % 7;
-    if (remainder != 0) {
-      *listener << "the remainder is " << remainder;
-    }
-    return remainder == 0;
-  }
-  ...
-};
-```
-
-Then, `EXPECT_THAT(x, DivisibleBy7());` may general a message like this:
-```
-Value of: x
-Expected: is divisible by 7
-  Actual: 23 (the remainder is 2)
-```
-
-## Writing New Polymorphic Matchers ##
-
-You've learned how to write your own matchers in the previous
-recipe. Just one problem: a matcher created using `MakeMatcher()` only
-works for one particular type of arguments. If you want a
-_polymorphic_ matcher that works with arguments of several types (for
-instance, `Eq(x)` can be used to match a `value` as long as `value` ==
-`x` compiles -- `value` and `x` don't have to share the same type),
-you can learn the trick from `"gmock/gmock-matchers.h"` but it's a bit
-involved.
-
-Fortunately, most of the time you can define a polymorphic matcher
-easily with the help of `MakePolymorphicMatcher()`. Here's how you can
-define `NotNull()` as an example:
-
-```
-using ::testing::MakePolymorphicMatcher;
-using ::testing::MatchResultListener;
-using ::testing::NotNull;
-using ::testing::PolymorphicMatcher;
-
-class NotNullMatcher {
- public:
-  // To implement a polymorphic matcher, first define a COPYABLE class
-  // that has three members MatchAndExplain(), DescribeTo(), and
-  // DescribeNegationTo(), like the following.
-
-  // In this example, we want to use NotNull() with any pointer, so
-  // MatchAndExplain() accepts a pointer of any type as its first argument.
-  // In general, you can define MatchAndExplain() as an ordinary method or
-  // a method template, or even overload it.
-  template <typename T>
-  bool MatchAndExplain(T* p,
-                       MatchResultListener* /* listener */) const {
-    return p != NULL;
-  }
-
-  // Describes the property of a value matching this matcher.
-  void DescribeTo(::std::ostream* os) const { *os << "is not NULL"; }
-
-  // Describes the property of a value NOT matching this matcher.
-  void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
-};
-
-// To construct a polymorphic matcher, pass an instance of the class
-// to MakePolymorphicMatcher().  Note the return type.
-inline PolymorphicMatcher<NotNullMatcher> NotNull() {
-  return MakePolymorphicMatcher(NotNullMatcher());
-}
-...
-
-  EXPECT_CALL(foo, Bar(NotNull()));  // The argument must be a non-NULL pointer.
-```
-
-**Note:** Your polymorphic matcher class does **not** need to inherit from
-`MatcherInterface` or any other class, and its methods do **not** need
-to be virtual.
-
-Like in a monomorphic matcher, you may explain the match result by
-streaming additional information to the `listener` argument in
-`MatchAndExplain()`.
-
-## Writing New Cardinalities ##
-
-A cardinality is used in `Times()` to tell Google Mock how many times
-you expect a call to occur. It doesn't have to be exact. For example,
-you can say `AtLeast(5)` or `Between(2, 4)`.
-
-If the built-in set of cardinalities doesn't suit you, you are free to
-define your own by implementing the following interface (in namespace
-`testing`):
-
-```
-class CardinalityInterface {
- public:
-  virtual ~CardinalityInterface();
-
-  // Returns true iff call_count calls will satisfy this cardinality.
-  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
-
-  // Returns true iff call_count calls will saturate this cardinality.
-  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
-
-  // Describes self to an ostream.
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-};
-```
-
-For example, to specify that a call must occur even number of times,
-you can write
-
-```
-using ::testing::Cardinality;
-using ::testing::CardinalityInterface;
-using ::testing::MakeCardinality;
-
-class EvenNumberCardinality : public CardinalityInterface {
- public:
-  virtual bool IsSatisfiedByCallCount(int call_count) const {
-    return (call_count % 2) == 0;
-  }
-
-  virtual bool IsSaturatedByCallCount(int call_count) const {
-    return false;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "called even number of times";
-  }
-};
-
-Cardinality EvenNumber() {
-  return MakeCardinality(new EvenNumberCardinality);
-}
-...
-
-  EXPECT_CALL(foo, Bar(3))
-      .Times(EvenNumber());
-```
-
-## Writing New Actions Quickly ##
-
-If the built-in actions don't work for you, and you find it
-inconvenient to use `Invoke()`, you can use a macro from the `ACTION*`
-family to quickly define a new action that can be used in your code as
-if it's a built-in action.
-
-By writing
-```
-ACTION(name) { statements; }
-```
-in a namespace scope (i.e. not inside a class or function), you will
-define an action with the given name that executes the statements.
-The value returned by `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 as `argK`.  For example:
-```
-ACTION(IncrementArg1) { return ++(*arg1); }
-```
-allows you to write
-```
-... WillOnce(IncrementArg1());
-```
-
-Note that you don't need to specify the types of the mock function
-arguments.  Rest assured that your code is type-safe though:
-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.
-
-Another example:
-```
-ACTION(Foo) {
-  (*arg2)(5);
-  Blah();
-  *arg1 = 0;
-  return arg0;
-}
-```
-defines an action `Foo()` that invokes argument #2 (a function pointer)
-with 5, calls function `Blah()`, sets the value pointed to by argument
-#1 to 0, and returns argument #0.
-
-For more convenience and flexibility, you can also use the following
-pre-defined symbols in the body of `ACTION`:
-
-| `argK_type` | The type of the K-th (0-based) argument of the mock function |
-|:------------|:-------------------------------------------------------------|
-| `args`      | All arguments of the mock function as a tuple                |
-| `args_type` | The type of all arguments of the mock function as a tuple    |
-| `return_type` | The return type of the mock function                         |
-| `function_type` | The type of the mock function                                |
-
-For example, when using an `ACTION` as a stub action for mock function:
-```
-int DoSomething(bool flag, int* ptr);
-```
-we have:
-| **Pre-defined Symbol** | **Is Bound To** |
-|:-----------------------|:----------------|
-| `arg0`                 | the value of `flag` |
-| `arg0_type`            | the type `bool` |
-| `arg1`                 | the value of `ptr` |
-| `arg1_type`            | the type `int*` |
-| `args`                 | the tuple `(flag, ptr)` |
-| `args_type`            | the type `::testing::tuple<bool, int*>` |
-| `return_type`          | the type `int`  |
-| `function_type`        | the type `int(bool, int*)` |
-
-## Writing New Parameterized Actions Quickly ##
-
-Sometimes you'll want to parameterize an action you define.  For that
-we have another macro
-```
-ACTION_P(name, param) { statements; }
-```
-
-For example,
-```
-ACTION_P(Add, n) { return arg0 + n; }
-```
-will allow you to write
-```
-// Returns argument #0 + 5.
-... WillOnce(Add(5));
-```
-
-For convenience, we use the term _arguments_ for the values used to
-invoke the mock function, and the term _parameters_ for the values
-used to instantiate an action.
-
-Note that you don't need to provide the type of the parameter either.
-Suppose the parameter is named `param`, you can also use the
-Google-Mock-defined symbol `param_type` to refer to the type of the
-parameter as inferred by the compiler.  For example, in the body of
-`ACTION_P(Add, n)` above, you can write `n_type` for the type of `n`.
-
-Google Mock also provides `ACTION_P2`, `ACTION_P3`, and etc to support
-multi-parameter actions.  For example,
-```
-ACTION_P2(ReturnDistanceTo, x, y) {
-  double dx = arg0 - x;
-  double dy = arg1 - y;
-  return sqrt(dx*dx + dy*dy);
-}
-```
-lets you write
-```
-... WillOnce(ReturnDistanceTo(5.0, 26.5));
-```
-
-You can view `ACTION` as a degenerated parameterized action where the
-number of parameters is 0.
-
-You can also easily define actions overloaded on the number of parameters:
-```
-ACTION_P(Plus, a) { ... }
-ACTION_P2(Plus, a, b) { ... }
-```
-
-## Restricting the Type of an Argument or Parameter in an ACTION ##
-
-For maximum brevity and reusability, the `ACTION*` macros don't ask
-you to provide the types of the mock function arguments and the action
-parameters.  Instead, we let the compiler infer the types for us.
-
-Sometimes, however, we may want to be more explicit about the types.
-There are several tricks to do that.  For example:
-```
-ACTION(Foo) {
-  // Makes sure arg0 can be converted to int.
-  int n = arg0;
-  ... use n instead of arg0 here ...
-}
-
-ACTION_P(Bar, param) {
-  // Makes sure the type of arg1 is const char*.
-  ::testing::StaticAssertTypeEq<const char*, arg1_type>();
-
-  // Makes sure param can be converted to bool.
-  bool flag = param;
-}
-```
-where `StaticAssertTypeEq` is a compile-time assertion in Google Test
-that verifies two types are the same.
-
-## Writing New Action Templates Quickly ##
-
-Sometimes you want to give an action explicit template parameters that
-cannot be inferred from its value parameters.  `ACTION_TEMPLATE()`
-supports 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, where _m_ is between 1 and 10, and _n_ is
-between 0 and 10.  `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,
-                // Note the comma between int and k:
-                HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
-                AND_1_VALUE_PARAMS(output)) {
-  *output = T(::testing::get<k>(args));
-}
-```
-
-To create an instance of an action template, write:
-```
-  ActionName<t1, ..., t_m>(v1, ..., v_n)
-```
-where the `t`s are the template arguments and the
-`v`s are the value arguments.  The value argument
-types are inferred by the compiler.  For example:
-```
-using ::testing::_;
-...
-  int n;
-  EXPECT_CALL(mock, Foo(_, _))
-      .WillOnce(DuplicateArg<1, unsigned char>(&n));
-```
-
-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 a two-template-parameter action where the compiler
-is asked to infer the type of `x`?
-
-## Using the ACTION Object's Type ##
-
-If you are writing a function that returns an `ACTION` object, you'll
-need to know its type.  The type depends on the macro used to define
-the action and the parameter types.  The rule is relatively simple:
-| **Given Definition** | **Expression** | **Has Type** |
-|:---------------------|:---------------|:-------------|
-| `ACTION(Foo)`        | `Foo()`        | `FooAction`  |
-| `ACTION_TEMPLATE(Foo, HAS_m_TEMPLATE_PARAMS(...), AND_0_VALUE_PARAMS())` |	`Foo<t1, ..., t_m>()` | `FooAction<t1, ..., t_m>` |
-| `ACTION_P(Bar, param)` | `Bar(int_value)` | `BarActionP<int>` |
-| `ACTION_TEMPLATE(Bar, HAS_m_TEMPLATE_PARAMS(...), AND_1_VALUE_PARAMS(p1))` | `Bar<t1, ..., t_m>(int_value)` | `FooActionP<t1, ..., t_m, int>` |
-| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value, int_value)` | `BazActionP2<bool, int>` |
-| `ACTION_TEMPLATE(Baz, HAS_m_TEMPLATE_PARAMS(...), AND_2_VALUE_PARAMS(p1, p2))` | `Baz<t1, ..., t_m>(bool_value, int_value)` | `FooActionP2<t1, ..., t_m, bool, int>` |
-| ...                  | ...            | ...          |
-
-Note that we have to pick different suffixes (`Action`, `ActionP`,
-`ActionP2`, and etc) for actions with different numbers of value
-parameters, or the action definitions cannot be overloaded on the
-number of them.
-
-## Writing New Monomorphic Actions ##
-
-While the `ACTION*` macros are very convenient, sometimes they are
-inappropriate.  For example, despite the tricks shown in the previous
-recipes, they don't let you directly specify the types of the mock
-function arguments and the action parameters, which in general leads
-to unoptimized compiler error messages that can baffle unfamiliar
-users.  They also don't allow overloading actions based on parameter
-types without jumping through some hoops.
-
-An alternative to the `ACTION*` macros is to implement
-`::testing::ActionInterface<F>`, where `F` is the type of the mock
-function in which the action will be used. For example:
-
-```
-template <typename F>class ActionInterface {
- public:
-  virtual ~ActionInterface();
-
-  // Performs the action.  Result is the return type of function type
-  // F, and ArgumentTuple is the tuple of arguments of F.
-  //
-  // For example, if F is int(bool, const string&), then Result would
-  // be int, and ArgumentTuple would be ::testing::tuple<bool, const string&>.
-  virtual Result Perform(const ArgumentTuple& args) = 0;
-};
-
-using ::testing::_;
-using ::testing::Action;
-using ::testing::ActionInterface;
-using ::testing::MakeAction;
-
-typedef int IncrementMethod(int*);
-
-class IncrementArgumentAction : public ActionInterface<IncrementMethod> {
- public:
-  virtual int Perform(const ::testing::tuple<int*>& args) {
-    int* p = ::testing::get<0>(args);  // Grabs the first argument.
-    return *p++;
-  }
-};
-
-Action<IncrementMethod> IncrementArgument() {
-  return MakeAction(new IncrementArgumentAction);
-}
-...
-
-  EXPECT_CALL(foo, Baz(_))
-      .WillOnce(IncrementArgument());
-
-  int n = 5;
-  foo.Baz(&n);  // Should return 5 and change n to 6.
-```
-
-## Writing New Polymorphic Actions ##
-
-The previous recipe showed you how to define your own action. This is
-all good, except that you need to know the type of the function in
-which the action will be used. Sometimes that can be a problem. For
-example, if you want to use the action in functions with _different_
-types (e.g. like `Return()` and `SetArgPointee()`).
-
-If an action can be used in several types of mock functions, we say
-it's _polymorphic_. The `MakePolymorphicAction()` function template
-makes it easy to define such an action:
-
-```
-namespace testing {
-
-template <typename Impl>
-PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl);
-
-}  // namespace testing
-```
-
-As an example, let's define an action that returns the second argument
-in the mock function's argument list. The first step is to define an
-implementation class:
-
-```
-class ReturnSecondArgumentAction {
- public:
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) const {
-    // To get the i-th (0-based) argument, use ::testing::get<i>(args).
-    return ::testing::get<1>(args);
-  }
-};
-```
-
-This implementation class does _not_ need to inherit from any
-particular class. What matters is that it must have a `Perform()`
-method template. This method template takes the mock function's
-arguments as a tuple in a **single** argument, and returns the result of
-the action. It can be either `const` or not, but must be invokable
-with exactly one template argument, which is the result type. In other
-words, you must be able to call `Perform<R>(args)` where `R` is the
-mock function's return type and `args` is its arguments in a tuple.
-
-Next, we use `MakePolymorphicAction()` to turn an instance of the
-implementation class into the polymorphic action we need. It will be
-convenient to have a wrapper for this:
-
-```
-using ::testing::MakePolymorphicAction;
-using ::testing::PolymorphicAction;
-
-PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
-  return MakePolymorphicAction(ReturnSecondArgumentAction());
-}
-```
-
-Now, you can use this polymorphic action the same way you use the
-built-in ones:
-
-```
-using ::testing::_;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD2(DoThis, int(bool flag, int n));
-  MOCK_METHOD3(DoThat, string(int x, const char* str1, const char* str2));
-};
-...
-
-  MockFoo foo;
-  EXPECT_CALL(foo, DoThis(_, _))
-      .WillOnce(ReturnSecondArgument());
-  EXPECT_CALL(foo, DoThat(_, _, _))
-      .WillOnce(ReturnSecondArgument());
-  ...
-  foo.DoThis(true, 5);         // Will return 5.
-  foo.DoThat(1, "Hi", "Bye");  // Will return "Hi".
-```
-
-## Teaching Google Mock How to Print Your Values ##
-
-When an uninteresting or unexpected call occurs, Google Mock prints the
-argument values and the stack trace to help you debug.  Assertion
-macros like `EXPECT_THAT` and `EXPECT_EQ` also print the values in
-question when the assertion fails.  Google Mock and Google Test do this using
-Google Test's user-extensible value printer.
-
-This printer knows how to print built-in C++ types, native arrays, STL
-containers, and any type that supports the `<<` operator.  For other
-types, it prints the raw bytes in the value and hopes that you the
-user can figure it out.
-[Google Test's advanced guide](../../googletest/docs/AdvancedGuide.md#teaching-google-test-how-to-print-your-values)
-explains how to extend the printer to do a better job at
-printing your particular type than to dump the bytes.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DesignDoc.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DesignDoc.md
deleted file mode 100644
index 3f515c3b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DesignDoc.md
+++ /dev/null
@@ -1,280 +0,0 @@
-This page discusses the design of new Google Mock features.
-
-
-
-# Macros for Defining Actions #
-
-## Problem ##
-
-Due to the lack of closures in C++, it currently requires some
-non-trivial effort to define a custom action in Google Mock.  For
-example, suppose you want to "increment the value pointed to by the
-second argument of the mock function and return it", you could write:
-
-```
-int IncrementArg1(Unused, int* p, Unused) {
-  return ++(*p);
-}
-
-... WillOnce(Invoke(IncrementArg1));
-```
-
-There are several things unsatisfactory about this approach:
-
-  * Even though the action only cares about the second argument of the mock function, its definition needs to list other arguments as dummies.  This is tedious.
-  * The defined action is usable only in mock functions that takes exactly 3 arguments - an unnecessary restriction.
-  * To use the action, one has to say `Invoke(IncrementArg1)`, which isn't as nice as `IncrementArg1()`.
-
-The latter two problems can be overcome using `MakePolymorphicAction()`,
-but it requires much more boilerplate code:
-
-```
-class IncrementArg1Action {
- public:
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) const {
-    return ++(*tr1::get<1>(args));
-  }
-};
-
-PolymorphicAction<IncrementArg1Action> IncrementArg1() {
-  return MakePolymorphicAction(IncrementArg1Action());
-}
-
-... WillOnce(IncrementArg1());
-```
-
-Our goal is to allow defining custom actions with the least amount of
-boiler-plate C++ requires.
-
-## Solution ##
-
-We propose to introduce a new macro:
-```
-ACTION(name) { statements; }
-```
-
-Using this in a namespace scope will define an action with the given
-name that executes the statements.  Inside the statements, you can
-refer to the K-th (0-based) argument of the mock function as `argK`.
-For example:
-```
-ACTION(IncrementArg1) { return ++(*arg1); }
-```
-allows you to write
-```
-... WillOnce(IncrementArg1());
-```
-
-Note that you don't need to specify the types of the mock function
-arguments, as brevity is a top design goal here.  Rest assured that
-your code is still type-safe though: 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.
-
-Another example:
-```
-ACTION(Foo) {
-  (*arg2)(5);
-  Blah();
-  *arg1 = 0;
-  return arg0;
-}
-```
-defines an action `Foo()` that invokes argument #2 (a function pointer)
-with 5, calls function `Blah()`, sets the value pointed to by argument
-#1 to 0, and returns argument #0.
-
-For more convenience and flexibility, you can also use the following
-pre-defined symbols in the body of `ACTION`:
-
-| `argK_type` | The type of the K-th (0-based) argument of the mock function |
-|:------------|:-------------------------------------------------------------|
-| `args`      | All arguments of the mock function as a tuple                |
-| `args_type` | The type of all arguments of the mock function as a tuple    |
-| `return_type` | The return type of the mock function                         |
-| `function_type` | The type of the mock function                                |
-
-For example, when using an `ACTION` as a stub action for mock function:
-```
-int DoSomething(bool flag, int* ptr);
-```
-we have:
-| **Pre-defined Symbol** | **Is Bound To** |
-|:-----------------------|:----------------|
-| `arg0`                 | the value of `flag` |
-| `arg0_type`            | the type `bool` |
-| `arg1`                 | the value of `ptr` |
-| `arg1_type`            | the type `int*` |
-| `args`                 | the tuple `(flag, ptr)` |
-| `args_type`            | the type `std::tr1::tuple<bool, int*>` |
-| `return_type`          | the type `int`  |
-| `function_type`        | the type `int(bool, int*)` |
-
-## Parameterized actions ##
-
-Sometimes you'll want to parameterize the action.   For that we propose
-another macro
-```
-ACTION_P(name, param) { statements; }
-```
-
-For example,
-```
-ACTION_P(Add, n) { return arg0 + n; }
-```
-will allow you to write
-```
-// Returns argument #0 + 5.
-... WillOnce(Add(5));
-```
-
-For convenience, we use the term _arguments_ for the values used to
-invoke the mock function, and the term _parameters_ for the values
-used to instantiate an action.
-
-Note that you don't need to provide the type of the parameter either.
-Suppose the parameter is named `param`, you can also use the
-Google-Mock-defined symbol `param_type` to refer to the type of the
-parameter as inferred by the compiler.
-
-We will also provide `ACTION_P2`, `ACTION_P3`, and etc to support
-multi-parameter actions.  For example,
-```
-ACTION_P2(ReturnDistanceTo, x, y) {
-  double dx = arg0 - x;
-  double dy = arg1 - y;
-  return sqrt(dx*dx + dy*dy);
-}
-```
-lets you write
-```
-... WillOnce(ReturnDistanceTo(5.0, 26.5));
-```
-
-You can view `ACTION` as a degenerated parameterized action where the
-number of parameters is 0.
-
-## Advanced Usages ##
-
-### Overloading Actions ###
-
-You can easily define actions overloaded on the number of parameters:
-```
-ACTION_P(Plus, a) { ... }
-ACTION_P2(Plus, a, b) { ... }
-```
-
-### Restricting the Type of an Argument or Parameter ###
-
-For maximum brevity and reusability, the `ACTION*` macros don't let
-you specify the types of the mock function arguments and the action
-parameters.  Instead, we let the compiler infer the types for us.
-
-Sometimes, however, we may want to be more explicit about the types.
-There are several tricks to do that.  For example:
-```
-ACTION(Foo) {
-  // Makes sure arg0 can be converted to int.
-  int n = arg0;
-  ... use n instead of arg0 here ...
-}
-
-ACTION_P(Bar, param) {
-  // Makes sure the type of arg1 is const char*.
-  ::testing::StaticAssertTypeEq<const char*, arg1_type>();
-
-  // Makes sure param can be converted to bool.
-  bool flag = param;
-}
-```
-where `StaticAssertTypeEq` is a compile-time assertion we plan to add to
-Google Test (the name is chosen to match `static_assert` in C++0x).
-
-### Using the ACTION Object's Type ###
-
-If you are writing a function that returns an `ACTION` object, you'll
-need to know its type.  The type depends on the macro used to define
-the action and the parameter types.  The rule is relatively simple:
-| **Given Definition** | **Expression** | **Has Type** |
-|:---------------------|:---------------|:-------------|
-| `ACTION(Foo)`        | `Foo()`        | `FooAction`  |
-| `ACTION_P(Bar, param)` | `Bar(int_value)` | `BarActionP<int>` |
-| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value, int_value)` | `BazActionP2<bool, int>` |
-| ...                  | ...            | ...          |
-
-Note that we have to pick different suffixes (`Action`, `ActionP`,
-`ActionP2`, and etc) for actions with different numbers of parameters,
-or the action definitions cannot be overloaded on the number of
-parameters.
-
-## When to Use ##
-
-While the new macros are very convenient, please also consider other
-means of implementing actions (e.g. via `ActionInterface` or
-`MakePolymorphicAction()`), especially if you need to use the defined
-action a lot.  While the other 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 the number of
-parameters.
-
-## Related Work ##
-
-As you may have realized, the `ACTION*` macros resemble closures (also
-known as lambda expressions or anonymous functions).  Indeed, both of
-them seek to lower the syntactic overhead for defining a function.
-
-C++0x will support lambdas, but they are not part of C++ right now.
-Some non-standard libraries (most notably BLL or Boost Lambda Library)
-try to alleviate this problem.  However, they are not a good choice
-for defining actions as:
-
-  * They are non-standard and not widely installed.  Google Mock only depends on standard libraries and `tr1::tuple`, which is part of the new C++ standard and comes with gcc 4+.  We want to keep it that way.
-  * They are not trivial to learn.
-  * They will become obsolete when C++0x's lambda feature is widely supported.  We don't want to make our users use a dying library.
-  * Since they are based on operators, they are rather ad hoc: you cannot use statements, and you cannot pass the lambda arguments to a function, for example.
-  * They have subtle semantics that easily confuses new users.  For example, in expression `_1++ + foo++`, `foo` will be incremented only once where the expression is evaluated, while `_1` will be incremented every time the unnamed function is invoked.  This is far from intuitive.
-
-`ACTION*` avoid all these problems.
-
-## Future Improvements ##
-
-There may be a need for composing `ACTION*` definitions (i.e. invoking
-another `ACTION` inside the definition of one `ACTION*`).  We are not
-sure we want it yet, as one can get a similar effect by putting
-`ACTION` definitions in function templates and composing the function
-templates.  We'll revisit this based on user feedback.
-
-The reason we don't allow `ACTION*()` inside a function body is that
-the current C++ standard doesn't allow function-local types to be used
-to instantiate templates.  The upcoming C++0x standard will lift this
-restriction.  Once this feature is widely supported by compilers, we
-can revisit the implementation and add support for using `ACTION*()`
-inside a function.
-
-C++0x will also support lambda expressions.  When they become
-available, we may want to support using lambdas as actions.
-
-# Macros for Defining Matchers #
-
-Once the macros for defining actions are implemented, we plan to do
-the same for matchers:
-
-```
-MATCHER(name) { statements; }
-```
-
-where you can refer to the value being matched as `arg`.  For example,
-given:
-
-```
-MATCHER(IsPositive) { return arg > 0; }
-```
-
-you can use `IsPositive()` as a matcher that matches a value iff it is
-greater than 0.
-
-We will also add `MATCHER_P`, `MATCHER_P2`, and etc for parameterized
-matchers.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DevGuide.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DevGuide.md
deleted file mode 100644
index f4bab75c..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/DevGuide.md
+++ /dev/null
@@ -1,132 +0,0 @@
-
-
-If you are interested in understanding the internals of Google Mock,
-building from source, or contributing ideas or modifications to the
-project, then this document is for you.
-
-# Introduction #
-
-First, let's give you some background of the project.
-
-## Licensing ##
-
-All Google Mock source and pre-built packages are provided under the [New BSD License](http://www.opensource.org/licenses/bsd-license.php).
-
-## The Google Mock Community ##
-
-The Google Mock community exists primarily through the [discussion group](http://groups.google.com/group/googlemock), the
-[issue tracker](https://github.com/google/googletest/issues) and, to a lesser extent, the [source control repository](../). 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
-Mock 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.
-
-### Where to Discuss Google Mock ###
-
-As always, discuss Google Mock in the official [Google C++ Mocking Framework discussion group](http://groups.google.com/group/googlemock).  You don't have to actually submit
-code in order to sign up. Your participation itself is a valuable
-contribution.
-
-# Working with the Code #
-
-If you want to get your hands dirty with the code inside Google Mock,
-this is the section for you.
-
-## Checking Out the Source from Subversion ##
-
-Checking out the Google Mock source is most useful if you plan to
-tweak it yourself.  You check out the source for Google Mock using a
-[Subversion](http://subversion.tigris.org/) client as you would for any
-other project hosted on Google Code.  Please see the instruction on
-the [source code access page](../) for how to do it.
-
-## Compiling from Source ##
-
-Once you check out the code, you can find instructions on how to
-compile it in the [README](../README.md) file.
-
-## Testing ##
-
-A mocking framework is of no good if itself is not thoroughly tested.
-Tests should be written for any new code, and changes should be
-verified to not break existing tests before they are submitted for
-review. To perform the tests, follow the instructions in [README](http://code.google.com/p/googlemock/source/browse/trunk/README) and
-verify that there are no failures.
-
-# Contributing Code #
-
-We are excited that Google Mock is now open source, and hope to get
-great patches from the community. Before you fire up your favorite IDE
-and begin hammering away at that new feature, though, please take the
-time to read this section and understand the process. While it seems
-rigorous, we want to keep a high standard of quality in the code
-base.
-
-## Contributor License Agreements ##
-
-You must sign a Contributor License Agreement (CLA) before we can
-accept any code.  The CLA protects you and us.
-
-  * 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](http://code.google.com/legal/individual-cla-v1.0.html).
-  * If you work for a company that wants to allow you to contribute your work to Google Mock, then you'll need to sign a [corporate CLA](http://code.google.com/legal/corporate-cla-v1.0.html).
-
-Follow either of the two links above to access the appropriate CLA and
-instructions for how to sign and return it.
-
-## Coding 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://github.com/google/styleguide/blob/gh-pages/cppguide.xml).
-
-## Submitting Patches ##
-
-Please do submit code. Here's what you need to do:
-
-  1. Normally you should make your change against the SVN trunk instead of a branch or a tag, as the latter two are for release control and should be treated mostly as read-only.
-  1. Decide which code you want to submit. A submission should be a set of changes that addresses one issue in the [Google Mock issue tracker](http://code.google.com/p/googlemock/issues/list). 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.
-  1. 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.
-  1. Ensure that your code adheres to the [Google Mock source code style](#Coding_Style.md).
-  1. Ensure that there are unit tests for your code.
-  1. Sign a Contributor License Agreement.
-  1. Create a patch file using `svn diff`.
-  1. We use [Rietveld](http://codereview.appspot.com/) to do web-based code reviews.  You can read about the tool [here](https://github.com/rietveld-codereview/rietveld/wiki).  When you are ready, upload your patch via Rietveld and notify `googlemock@googlegroups.com` to review it.  There are several ways to upload the patch.  We recommend using the [upload\_gmock.py](../scripts/upload_gmock.py) script, which you can find in the `scripts/` folder in the SVN trunk.
-
-## Google Mock Committers ##
-
-The current members of the Google Mock engineering team are the only
-committers at present. In the great tradition of eating one's own
-dogfood, we will be requiring each new Google Mock engineering team
-member to earn the right to become a committer by following the
-procedures in this document, writing consistently great code, and
-demonstrating repeatedly that he or she truly gets the zen of Google
-Mock.
-
-# Release Process #
-
-We follow the typical release process for Subversion-based projects:
-
-  1. A release branch named `release-X.Y` is created.
-  1. Bugs are fixed and features are added in trunk; those individual patches are merged into the release branch until it's stable.
-  1. An individual point release (the `Z` in `X.Y.Z`) is made by creating a tag from the branch.
-  1. Repeat steps 2 and 3 throughout one release cycle (as determined by features or time).
-  1. Go back to step 1 to create another release branch and so on.
-
-
----
-
-This page is based on the [Making GWT Better](http://code.google.com/webtoolkit/makinggwtbetter.html) guide from the [Google Web Toolkit](http://code.google.com/webtoolkit/) project.  Except as otherwise [noted](http://code.google.com/policies.html#restrictions), the content of this page is licensed under the [Creative Commons Attribution 2.5 License](http://creativecommons.org/licenses/by/2.5/).
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/Documentation.md
deleted file mode 100644
index 444151ee..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/Documentation.md
+++ /dev/null
@@ -1,12 +0,0 @@
-This page lists all documentation wiki pages for Google Mock **(the SVN trunk version)**
-- **if you use a released version of Google Mock, please read the documentation for that specific version instead.**
-
-  * [ForDummies](ForDummies.md) -- start here if you are new to Google Mock.
-  * [CheatSheet](CheatSheet.md) -- a quick reference.
-  * [CookBook](CookBook.md) -- recipes for doing various tasks using Google Mock.
-  * [FrequentlyAskedQuestions](FrequentlyAskedQuestions.md) -- check here before asking a question on the mailing list.
-
-To contribute code to Google Mock, read:
-
-  * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
-  * [Pump Manual](../googletest/docs/PumpManual.md) -- how we generate some of Google Mock's source files.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/ForDummies.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/ForDummies.md
deleted file mode 100644
index 0da4cbe2..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/ForDummies.md
+++ /dev/null
@@ -1,439 +0,0 @@
-
-
-(**Note:** If you get compiler errors that you don't understand, be sure to consult [Google Mock Doctor](FrequentlyAskedQuestions.md#how-am-i-supposed-to-make-sense-of-these-horrible-template-errors).)
-
-# What Is Google C++ Mocking Framework? #
-When you write a prototype or test, often it's not feasible or wise to rely on real objects entirely. A **mock object** implements the same interface as a real object (so it can be used as one), but lets you specify at run time how it will be used and what it should do (which methods will be called? in which order? how many times? with what arguments? what will they return? etc).
-
-**Note:** It is easy to confuse the term _fake objects_ with mock objects. Fakes and mocks actually mean very different things in the Test-Driven Development (TDD) community:
-
-  * **Fake** objects have working implementations, but usually take some shortcut (perhaps to make the operations less expensive), which makes them not suitable for production. An in-memory file system would be an example of a fake.
-  * **Mocks** are objects pre-programmed with _expectations_, which form a specification of the calls they are expected to receive.
-
-If all this seems too abstract for you, don't worry - the most important thing to remember is that a mock allows you to check the _interaction_ between itself and code that uses it. The difference between fakes and mocks will become much clearer once you start to use mocks.
-
-**Google C++ Mocking Framework** (or **Google Mock** for short) is a library (sometimes we also call it a "framework" to make it sound cool) for creating mock classes and using them. It does to C++ what [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/) do to Java.
-
-Using Google Mock involves three basic steps:
-
-  1. Use some simple macros to describe the interface you want to mock, and they will expand to the implementation of your mock class;
-  1. Create some mock objects and specify its expectations and behavior using an intuitive syntax;
-  1. Exercise code that uses the mock objects. Google Mock will catch any violation of the expectations as soon as it arises.
-
-# Why Google Mock? #
-While mock objects help you remove unnecessary dependencies in tests and make them fast and reliable, using mocks manually in C++ is _hard_:
-
-  * Someone has to implement the mocks. The job is usually tedious and error-prone. No wonder people go great distance to avoid it.
-  * The quality of those manually written mocks is a bit, uh, unpredictable. You may see some really polished ones, but you may also see some that were hacked up in a hurry and have all sorts of ad hoc restrictions.
-  * The knowledge you gained from using one mock doesn't transfer to the next.
-
-In contrast, Java and Python programmers have some fine mock frameworks, which automate the creation of mocks. As a result, mocking is a proven effective technique and widely adopted practice in those communities. Having the right tool absolutely makes the difference.
-
-Google Mock was built to help C++ programmers. It was inspired by [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/), but designed with C++'s specifics in mind. It is your friend if any of the following problems is bothering you:
-
-  * You are stuck with a sub-optimal design and wish you had done more prototyping before it was too late, but prototyping in C++ is by no means "rapid".
-  * Your tests are slow as they depend on too many libraries or use expensive resources (e.g. a database).
-  * Your tests are brittle as some resources they use are unreliable (e.g. the network).
-  * You want to test how your code handles a failure (e.g. a file checksum error), but it's not easy to cause one.
-  * You need to make sure that your module interacts with other modules in the right way, but it's hard to observe the interaction; therefore you resort to observing the side effects at the end of the action, which is awkward at best.
-  * You want to "mock out" your dependencies, except that they don't have mock implementations yet; and, frankly, you aren't thrilled by some of those hand-written mocks.
-
-We encourage you to use Google Mock as:
-
-  * a _design_ tool, for it lets you experiment with your interface design early and often. More iterations lead to better designs!
-  * a _testing_ tool to cut your tests' outbound dependencies and probe the interaction between your module and its collaborators.
-
-# Getting Started #
-Using Google Mock is easy! Inside your C++ source file, just `#include` `"gtest/gtest.h"` and `"gmock/gmock.h"`, and you are ready to go.
-
-# A Case for Mock Turtles #
-Let's look at an example. Suppose you are developing a graphics program that relies on a LOGO-like API for drawing. How would you test that it does the right thing? Well, you can run it and compare the screen with a golden screen snapshot, but let's admit it: tests like this are expensive to run and fragile (What if you just upgraded to a shiny new graphics card that has better anti-aliasing? Suddenly you have to update all your golden images.). It would be too painful if all your tests are like this. Fortunately, you learned about Dependency Injection and know the right thing to do: instead of having your application talk to the drawing API directly, wrap the API in an interface (say, `Turtle`) and code to that interface:
-
-```
-class Turtle {
-  ...
-  virtual ~Turtle() {}
-  virtual void PenUp() = 0;
-  virtual void PenDown() = 0;
-  virtual void Forward(int distance) = 0;
-  virtual void Turn(int degrees) = 0;
-  virtual void GoTo(int x, int y) = 0;
-  virtual int GetX() const = 0;
-  virtual int GetY() const = 0;
-};
-```
-
-(Note that the destructor of `Turtle` **must** be virtual, as is the case for **all** classes you intend to inherit from - otherwise the destructor of the derived class will not be called when you delete an object through a base pointer, and you'll get corrupted program states like memory leaks.)
-
-You can control whether the turtle's movement will leave a trace using `PenUp()` and `PenDown()`, and control its movement using `Forward()`, `Turn()`, and `GoTo()`. Finally, `GetX()` and `GetY()` tell you the current position of the turtle.
-
-Your program will normally use a real implementation of this interface. In tests, you can use a mock implementation instead. This allows you to easily check what drawing primitives your program is calling, with what arguments, and in which order. Tests written this way are much more robust (they won't break because your new machine does anti-aliasing differently), easier to read and maintain (the intent of a test is expressed in the code, not in some binary images), and run _much, much faster_.
-
-# Writing the Mock Class #
-If you are lucky, the mocks you need to use have already been implemented by some nice people. If, however, you find yourself in the position to write a mock class, relax - Google Mock turns this task into a fun game! (Well, almost.)
-
-## How to Define It ##
-Using the `Turtle` interface as example, here are the simple steps you need to follow:
-
-  1. Derive a class `MockTurtle` from `Turtle`.
-  1. Take a _virtual_ function of `Turtle` (while it's possible to [mock non-virtual methods using templates](CookBook.md#mocking-nonvirtual-methods), it's much more involved). Count how many arguments it has.
-  1. In the `public:` section of the child class, write `MOCK_METHODn();` (or `MOCK_CONST_METHODn();` if you are mocking a `const` method), where `n` is the number of the arguments; if you counted wrong, shame on you, and a compiler error will tell you so.
-  1. Now comes the fun part: you take the function signature, cut-and-paste the _function name_ as the _first_ argument to the macro, and leave what's left as the _second_ argument (in case you're curious, this is the _type of the function_).
-  1. Repeat until all virtual functions you want to mock are done.
-
-After the process, you should have something like:
-
-```
-#include "gmock/gmock.h"  // Brings in Google Mock.
-class MockTurtle : public Turtle {
- public:
-  ...
-  MOCK_METHOD0(PenUp, void());
-  MOCK_METHOD0(PenDown, void());
-  MOCK_METHOD1(Forward, void(int distance));
-  MOCK_METHOD1(Turn, void(int degrees));
-  MOCK_METHOD2(GoTo, void(int x, int y));
-  MOCK_CONST_METHOD0(GetX, int());
-  MOCK_CONST_METHOD0(GetY, int());
-};
-```
-
-You don't need to define these mock methods somewhere else - the `MOCK_METHOD*` macros will generate the definitions for you. It's that simple! Once you get the hang of it, you can pump out mock classes faster than your source-control system can handle your check-ins.
-
-**Tip:** If even this is too much work for you, you'll find the
-`gmock_gen.py` tool in Google Mock's `scripts/generator/` directory (courtesy of the [cppclean](http://code.google.com/p/cppclean/) project) useful.  This command-line
-tool requires that you have Python 2.4 installed.  You give it a C++ file and the name of an abstract class defined in it,
-and it will print the definition of the mock class for you.  Due to the
-complexity of the C++ language, this script may not always work, but
-it can be quite handy when it does.  For more details, read the [user documentation](../scripts/generator/README).
-
-## Where to Put It ##
-When you define a mock class, you need to decide where to put its definition. Some people put it in a `*_test.cc`. This is fine when the interface being mocked (say, `Foo`) is owned by the same person or team. Otherwise, when the owner of `Foo` changes it, your test could break. (You can't really expect `Foo`'s maintainer to fix every test that uses `Foo`, can you?)
-
-So, the rule of thumb is: if you need to mock `Foo` and it's owned by others, define the mock class in `Foo`'s package (better, in a `testing` sub-package such that you can clearly separate production code and testing utilities), and put it in a `mock_foo.h`. Then everyone can reference `mock_foo.h` from their tests. If `Foo` ever changes, there is only one copy of `MockFoo` to change, and only tests that depend on the changed methods need to be fixed.
-
-Another way to do it: you can introduce a thin layer `FooAdaptor` on top of `Foo` and code to this new interface. Since you own `FooAdaptor`, you can absorb changes in `Foo` much more easily. While this is more work initially, carefully choosing the adaptor interface can make your code easier to write and more readable (a net win in the long run), as you can choose `FooAdaptor` to fit your specific domain much better than `Foo` does.
-
-# Using Mocks in Tests #
-Once you have a mock class, using it is easy. The typical work flow is:
-
-  1. Import the Google Mock names from the `testing` namespace such that you can use them unqualified (You only have to do it once per file. Remember that namespaces are a good idea and good for your health.).
-  1. Create some mock objects.
-  1. Specify your expectations on them (How many times will a method be called? With what arguments? What should it do? etc.).
-  1. Exercise some code that uses the mocks; optionally, check the result using Google Test assertions. If a mock method is called more than expected or with wrong arguments, you'll get an error immediately.
-  1. When a mock is destructed, Google Mock will automatically check whether all expectations on it have been satisfied.
-
-Here's an example:
-
-```
-#include "path/to/mock-turtle.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-using ::testing::AtLeast;                     // #1
-
-TEST(PainterTest, CanDrawSomething) {
-  MockTurtle turtle;                          // #2
-  EXPECT_CALL(turtle, PenDown())              // #3
-      .Times(AtLeast(1));
-
-  Painter painter(&turtle);                   // #4
-
-  EXPECT_TRUE(painter.DrawCircle(0, 0, 10));
-}                                             // #5
-
-int main(int argc, char** argv) {
-  // The following line must be executed to initialize Google Mock
-  // (and Google Test) before running the tests.
-  ::testing::InitGoogleMock(&argc, argv);
-  return RUN_ALL_TESTS();
-}
-```
-
-As you might have guessed, this test checks that `PenDown()` is called at least once. If the `painter` object didn't call this method, your test will fail with a message like this:
-
-```
-path/to/my_test.cc:119: Failure
-Actual function call count doesn't match this expectation:
-Actually: never called;
-Expected: called at least once.
-```
-
-**Tip 1:** If you run the test from an Emacs buffer, you can hit `<Enter>` on the line number displayed in the error message to jump right to the failed expectation.
-
-**Tip 2:** If your mock objects are never deleted, the final verification won't happen. Therefore it's a good idea to use a heap leak checker in your tests when you allocate mocks on the heap.
-
-**Important note:** Google Mock requires expectations to be set **before** the mock functions are called, otherwise the behavior is **undefined**. In particular, you mustn't interleave `EXPECT_CALL()`s and calls to the mock functions.
-
-This means `EXPECT_CALL()` should be read as expecting that a call will occur _in the future_, not that a call has occurred. Why does Google Mock work like that? Well, specifying the expectation beforehand allows Google Mock to report a violation as soon as it arises, when the context (stack trace, etc) is still available. This makes debugging much easier.
-
-Admittedly, this test is contrived and doesn't do much. You can easily achieve the same effect without using Google Mock. However, as we shall reveal soon, Google Mock allows you to do _much more_ with the mocks.
-
-## Using Google Mock with Any Testing Framework ##
-If you want to use something other than Google Test (e.g. [CppUnit](http://sourceforge.net/projects/cppunit/) or
-[CxxTest](http://cxxtest.tigris.org/)) as your testing framework, just change the `main()` function in the previous section to:
-```
-int main(int argc, char** argv) {
-  // The following line causes Google Mock to throw an exception on failure,
-  // which will be interpreted by your testing framework as a test failure.
-  ::testing::GTEST_FLAG(throw_on_failure) = true;
-  ::testing::InitGoogleMock(&argc, argv);
-  ... whatever your testing framework requires ...
-}
-```
-
-This approach has a catch: it makes Google Mock throw an exception
-from a mock object's destructor sometimes.  With some compilers, this
-sometimes causes the test program to crash.  You'll still be able to
-notice that the test has failed, but it's not a graceful failure.
-
-A better solution is to use Google Test's
-[event listener API](../../googletest/docs/AdvancedGuide.md#extending-google-test-by-handling-test-events)
-to report a test failure to your testing framework properly.  You'll need to
-implement the `OnTestPartResult()` method of the event listener interface, but it
-should be straightforward.
-
-If this turns out to be too much work, we suggest that you stick with
-Google Test, which works with Google Mock seamlessly (in fact, it is
-technically part of Google Mock.).  If there is a reason that you
-cannot use Google Test, please let us know.
-
-# Setting Expectations #
-The key to using a mock object successfully is to set the _right expectations_ on it. If you set the expectations too strict, your test will fail as the result of unrelated changes. If you set them too loose, bugs can slip through. You want to do it just right such that your test can catch exactly the kind of bugs you intend it to catch. Google Mock provides the necessary means for you to do it "just right."
-
-## General Syntax ##
-In Google Mock we use the `EXPECT_CALL()` macro to set an expectation on a mock method. The general syntax is:
-
-```
-EXPECT_CALL(mock_object, method(matchers))
-    .Times(cardinality)
-    .WillOnce(action)
-    .WillRepeatedly(action);
-```
-
-The macro has two arguments: first the mock object, and then the method and its arguments. Note that the two are separated by a comma (`,`), not a period (`.`). (Why using a comma? The answer is that it was necessary for technical reasons.)
-
-The macro can be followed by some optional _clauses_ that provide more information about the expectation. We'll discuss how each clause works in the coming sections.
-
-This syntax is designed to make an expectation read like English. For example, you can probably guess that
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetX())
-    .Times(5)
-    .WillOnce(Return(100))
-    .WillOnce(Return(150))
-    .WillRepeatedly(Return(200));
-```
-
-says that the `turtle` object's `GetX()` method will be called five times, it will return 100 the first time, 150 the second time, and then 200 every time. Some people like to call this style of syntax a Domain-Specific Language (DSL).
-
-**Note:** Why do we use a macro to do this? It serves two purposes: first it makes expectations easily identifiable (either by `grep` or by a human reader), and second it allows Google Mock to include the source file location of a failed expectation in messages, making debugging easier.
-
-## Matchers: What Arguments Do We Expect? ##
-When a mock function takes arguments, we must specify what arguments we are expecting; for example:
-
-```
-// Expects the turtle to move forward by 100 units.
-EXPECT_CALL(turtle, Forward(100));
-```
-
-Sometimes you may not want to be too specific (Remember that talk about tests being too rigid? Over specification leads to brittle tests and obscures the intent of tests. Therefore we encourage you to specify only what's necessary - no more, no less.). If you care to check that `Forward()` will be called but aren't interested in its actual argument, write `_` as the argument, which means "anything goes":
-
-```
-using ::testing::_;
-...
-// Expects the turtle to move forward.
-EXPECT_CALL(turtle, Forward(_));
-```
-
-`_` is an instance of what we call **matchers**. A matcher is like a predicate and can test whether an argument is what we'd expect. You can use a matcher inside `EXPECT_CALL()` wherever a function argument is expected.
-
-A list of built-in matchers can be found in the [CheatSheet](CheatSheet.md). For example, here's the `Ge` (greater than or equal) matcher:
-
-```
-using ::testing::Ge;...
-EXPECT_CALL(turtle, Forward(Ge(100)));
-```
-
-This checks that the turtle will be told to go forward by at least 100 units.
-
-## Cardinalities: How Many Times Will It Be Called? ##
-The first clause we can specify following an `EXPECT_CALL()` is `Times()`. We call its argument a **cardinality** as it tells _how many times_ the call should occur. It allows us to repeat an expectation many times without actually writing it as many times. More importantly, a cardinality can be "fuzzy", just like a matcher can be. This allows a user to express the intent of a test exactly.
-
-An interesting special case is when we say `Times(0)`. You may have guessed - it means that the function shouldn't be called with the given arguments at all, and Google Mock will report a Google Test failure whenever the function is (wrongfully) called.
-
-We've seen `AtLeast(n)` as an example of fuzzy cardinalities earlier. For the list of built-in cardinalities you can use, see the [CheatSheet](CheatSheet.md).
-
-The `Times()` clause can be omitted. **If you omit `Times()`, Google Mock will infer the cardinality for you.** The rules are easy to remember:
-
-  * If **neither** `WillOnce()` **nor** `WillRepeatedly()` is in the `EXPECT_CALL()`, the inferred cardinality is `Times(1)`.
-  * If there are `n WillOnce()`'s but **no** `WillRepeatedly()`, where `n` >= 1, the cardinality is `Times(n)`.
-  * If there are `n WillOnce()`'s and **one** `WillRepeatedly()`, where `n` >= 0, the cardinality is `Times(AtLeast(n))`.
-
-**Quick quiz:** what do you think will happen if a function is expected to be called twice but actually called four times?
-
-## Actions: What Should It Do? ##
-Remember that a mock object doesn't really have a working implementation? We as users have to tell it what to do when a method is invoked. This is easy in Google Mock.
-
-First, if the return type of a mock function is a built-in type or a pointer, the function has a **default action** (a `void` function will just return, a `bool` function will return `false`, and other functions will return 0). In addition, in C++ 11 and above, a mock function whose return type is default-constructible (i.e. has a default constructor) has a default action of returning a default-constructed value.  If you don't say anything, this behavior will be used.
-
-Second, if a mock function doesn't have a default action, or the default action doesn't suit you, you can specify the action to be taken each time the expectation matches using a series of `WillOnce()` clauses followed by an optional `WillRepeatedly()`. For example,
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetX())
-    .WillOnce(Return(100))
-    .WillOnce(Return(200))
-    .WillOnce(Return(300));
-```
-
-This says that `turtle.GetX()` will be called _exactly three times_ (Google Mock inferred this from how many `WillOnce()` clauses we've written, since we didn't explicitly write `Times()`), and will return 100, 200, and 300 respectively.
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetY())
-    .WillOnce(Return(100))
-    .WillOnce(Return(200))
-    .WillRepeatedly(Return(300));
-```
-
-says that `turtle.GetY()` will be called _at least twice_ (Google Mock knows this as we've written two `WillOnce()` clauses and a `WillRepeatedly()` while having no explicit `Times()`), will return 100 the first time, 200 the second time, and 300 from the third time on.
-
-Of course, if you explicitly write a `Times()`, Google Mock will not try to infer the cardinality itself. What if the number you specified is larger than there are `WillOnce()` clauses? Well, after all `WillOnce()`s are used up, Google Mock will do the _default_ action for the function every time (unless, of course, you have a `WillRepeatedly()`.).
-
-What can we do inside `WillOnce()` besides `Return()`? You can return a reference using `ReturnRef(variable)`, or invoke a pre-defined function, among [others](CheatSheet.md#actions).
-
-**Important note:** The `EXPECT_CALL()` statement evaluates the action clause only once, even though the action may be performed many times. Therefore you must be careful about side effects. The following may not do what you want:
-
-```
-int n = 100;
-EXPECT_CALL(turtle, GetX())
-.Times(4)
-.WillRepeatedly(Return(n++));
-```
-
-Instead of returning 100, 101, 102, ..., consecutively, this mock function will always return 100 as `n++` is only evaluated once. Similarly, `Return(new Foo)` will create a new `Foo` object when the `EXPECT_CALL()` is executed, and will return the same pointer every time. If you want the side effect to happen every time, you need to define a custom action, which we'll teach in the [CookBook](CookBook.md).
-
-Time for another quiz! What do you think the following means?
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetY())
-.Times(4)
-.WillOnce(Return(100));
-```
-
-Obviously `turtle.GetY()` is expected to be called four times. But if you think it will return 100 every time, think twice! Remember that one `WillOnce()` clause will be consumed each time the function is invoked and the default action will be taken afterwards. So the right answer is that `turtle.GetY()` will return 100 the first time, but **return 0 from the second time on**, as returning 0 is the default action for `int` functions.
-
-## Using Multiple Expectations ##
-So far we've only shown examples where you have a single expectation. More realistically, you're going to specify expectations on multiple mock methods, which may be from multiple mock objects.
-
-By default, when a mock method is invoked, Google Mock will search the expectations in the **reverse order** they are defined, and stop when an active expectation that matches the arguments is found (you can think of it as "newer rules override older ones."). If the matching expectation cannot take any more calls, you will get an upper-bound-violated failure. Here's an example:
-
-```
-using ::testing::_;...
-EXPECT_CALL(turtle, Forward(_));  // #1
-EXPECT_CALL(turtle, Forward(10))  // #2
-    .Times(2);
-```
-
-If `Forward(10)` is called three times in a row, the third time it will be an error, as the last matching expectation (#2) has been saturated. If, however, the third `Forward(10)` call is replaced by `Forward(20)`, then it would be OK, as now #1 will be the matching expectation.
-
-**Side note:** Why does Google Mock search for a match in the _reverse_ order of the expectations? The reason is that this allows a user to set up the default expectations in a mock object's constructor or the test fixture's set-up phase and then customize the mock by writing more specific expectations in the test body. So, if you have two expectations on the same method, you want to put the one with more specific matchers **after** the other, or the more specific rule would be shadowed by the more general one that comes after it.
-
-## Ordered vs Unordered Calls ##
-By default, an expectation can match a call even though an earlier expectation hasn't been satisfied. In other words, the calls don't have to occur in the order the expectations are specified.
-
-Sometimes, you may want all the expected calls to occur in a strict order. To say this in Google Mock is easy:
-
-```
-using ::testing::InSequence;...
-TEST(FooTest, DrawsLineSegment) {
-  ...
-  {
-    InSequence dummy;
-
-    EXPECT_CALL(turtle, PenDown());
-    EXPECT_CALL(turtle, Forward(100));
-    EXPECT_CALL(turtle, PenUp());
-  }
-  Foo();
-}
-```
-
-By creating an object of type `InSequence`, all expectations in its scope are put into a _sequence_ and have to occur _sequentially_. Since we are just relying on the constructor and destructor of this object to do the actual work, its name is really irrelevant.
-
-In this example, we test that `Foo()` calls the three expected functions in the order as written. If a call is made out-of-order, it will be an error.
-
-(What if you care about the relative order of some of the calls, but not all of them? Can you specify an arbitrary partial order? The answer is ... yes! If you are impatient, the details can be found in the [CookBook](CookBook#Expecting_Partially_Ordered_Calls.md).)
-
-## All Expectations Are Sticky (Unless Said Otherwise) ##
-Now let's do a quick quiz to see how well you can use this mock stuff already. How would you test that the turtle is asked to go to the origin _exactly twice_ (you want to ignore any other instructions it receives)?
-
-After you've come up with your answer, take a look at ours and compare notes (solve it yourself first - don't cheat!):
-
-```
-using ::testing::_;...
-EXPECT_CALL(turtle, GoTo(_, _))  // #1
-    .Times(AnyNumber());
-EXPECT_CALL(turtle, GoTo(0, 0))  // #2
-    .Times(2);
-```
-
-Suppose `turtle.GoTo(0, 0)` is called three times. In the third time, Google Mock will see that the arguments match expectation #2 (remember that we always pick the last matching expectation). Now, since we said that there should be only two such calls, Google Mock will report an error immediately. This is basically what we've told you in the "Using Multiple Expectations" section above.
-
-This example shows that **expectations in Google Mock are "sticky" by default**, in the sense that they remain active even after we have reached their invocation upper bounds. This is an important rule to remember, as it affects the meaning of the spec, and is **different** to how it's done in many other mocking frameworks (Why'd we do that? Because we think our rule makes the common cases easier to express and understand.).
-
-Simple? Let's see if you've really understood it: what does the following code say?
-
-```
-using ::testing::Return;
-...
-for (int i = n; i > 0; i--) {
-  EXPECT_CALL(turtle, GetX())
-      .WillOnce(Return(10*i));
-}
-```
-
-If you think it says that `turtle.GetX()` will be called `n` times and will return 10, 20, 30, ..., consecutively, think twice! The problem is that, as we said, expectations are sticky. So, the second time `turtle.GetX()` is called, the last (latest) `EXPECT_CALL()` statement will match, and will immediately lead to an "upper bound exceeded" error - this piece of code is not very useful!
-
-One correct way of saying that `turtle.GetX()` will return 10, 20, 30, ..., is to explicitly say that the expectations are _not_ sticky. In other words, they should _retire_ as soon as they are saturated:
-
-```
-using ::testing::Return;
-...
-for (int i = n; i > 0; i--) {
-  EXPECT_CALL(turtle, GetX())
-    .WillOnce(Return(10*i))
-    .RetiresOnSaturation();
-}
-```
-
-And, there's a better way to do it: in this case, we expect the calls to occur in a specific order, and we line up the actions to match the order. Since the order is important here, we should make it explicit using a sequence:
-
-```
-using ::testing::InSequence;
-using ::testing::Return;
-...
-{
-  InSequence s;
-
-  for (int i = 1; i <= n; i++) {
-    EXPECT_CALL(turtle, GetX())
-        .WillOnce(Return(10*i))
-        .RetiresOnSaturation();
-  }
-}
-```
-
-By the way, the other situation where an expectation may _not_ be sticky is when it's in a sequence - as soon as another expectation that comes after it in the sequence has been used, it automatically retires (and will never be used to match any call).
-
-## Uninteresting Calls ##
-A mock object may have many methods, and not all of them are that interesting. For example, in some tests we may not care about how many times `GetX()` and `GetY()` get called.
-
-In Google Mock, if you are not interested in a method, just don't say anything about it. If a call to this method occurs, you'll see a warning in the test output, but it won't be a failure.
-
-# What Now? #
-Congratulations! You've learned enough about Google Mock to start using it. Now, you might want to join the [googlemock](http://groups.google.com/group/googlemock) discussion group and actually write some tests using Google Mock - it will be fun. Hey, it may even be addictive - you've been warned.
-
-Then, if you feel like increasing your mock quotient, you should move on to the [CookBook](CookBook.md). You can learn many advanced features of Google Mock there -- and advance your level of enjoyment and testing bliss.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/FrequentlyAskedQuestions.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/FrequentlyAskedQuestions.md
deleted file mode 100644
index 5eac83f4..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/FrequentlyAskedQuestions.md
+++ /dev/null
@@ -1,628 +0,0 @@
-
-
-Please send your questions to the
-[googlemock](http://groups.google.com/group/googlemock) discussion
-group. If you need help with compiler errors, make sure you have
-tried [Google Mock Doctor](#How_am_I_supposed_to_make_sense_of_these_horrible_template_error.md) first.
-
-## When I call a method on my mock object, the method for the real object is invoked instead.  What's the problem? ##
-
-In order for a method to be mocked, it must be _virtual_, unless you use the [high-perf dependency injection technique](CookBook.md#mocking-nonvirtual-methods).
-
-## I wrote some matchers.  After I upgraded to a new version of Google Mock, they no longer compile.  What's going on? ##
-
-After version 1.4.0 of Google Mock was released, we had an idea on how
-to make it easier to write matchers that can generate informative
-messages efficiently.  We experimented with this idea and liked what
-we saw.  Therefore we decided to implement it.
-
-Unfortunately, this means that if you have defined your own matchers
-by implementing `MatcherInterface` or using `MakePolymorphicMatcher()`,
-your definitions will no longer compile.  Matchers defined using the
-`MATCHER*` family of macros are not affected.
-
-Sorry for the hassle if your matchers are affected.  We believe it's
-in everyone's long-term interest to make this change sooner than
-later.  Fortunately, it's usually not hard to migrate an existing
-matcher to the new API.  Here's what you need to do:
-
-If you wrote your matcher like this:
-```
-// Old matcher definition that doesn't work with the latest
-// Google Mock.
-using ::testing::MatcherInterface;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetFoo() > 5;
-  }
-  ...
-};
-```
-
-you'll need to change it to:
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool MatchAndExplain(MyType value,
-                               MatchResultListener* listener) const {
-    // Returns true if value matches.
-    return value.GetFoo() > 5;
-  }
-  ...
-};
-```
-(i.e. rename `Matches()` to `MatchAndExplain()` and give it a second
-argument of type `MatchResultListener*`.)
-
-If you were also using `ExplainMatchResultTo()` to improve the matcher
-message:
-```
-// Old matcher definition that doesn't work with the lastest
-// Google Mock.
-using ::testing::MatcherInterface;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetFoo() > 5;
-  }
-
-  virtual void ExplainMatchResultTo(MyType value,
-                                    ::std::ostream* os) const {
-    // Prints some helpful information to os to help
-    // a user understand why value matches (or doesn't match).
-    *os << "the Foo property is " << value.GetFoo();
-  }
-  ...
-};
-```
-
-you should move the logic of `ExplainMatchResultTo()` into
-`MatchAndExplain()`, using the `MatchResultListener` argument where
-the `::std::ostream` was used:
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool MatchAndExplain(MyType value,
-                               MatchResultListener* listener) const {
-    // Returns true if value matches.
-    *listener << "the Foo property is " << value.GetFoo();
-    return value.GetFoo() > 5;
-  }
-  ...
-};
-```
-
-If your matcher is defined using `MakePolymorphicMatcher()`:
-```
-// Old matcher definition that doesn't work with the latest
-// Google Mock.
-using ::testing::MakePolymorphicMatcher;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetBar() < 42;
-  }
-  ...
-};
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-you should rename the `Matches()` method to `MatchAndExplain()` and
-add a `MatchResultListener*` argument (the same as what you need to do
-for matchers defined by implementing `MatcherInterface`):
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MakePolymorphicMatcher;
-using ::testing::MatchResultListener;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool MatchAndExplain(MyType value,
-                       MatchResultListener* listener) const {
-    // Returns true if value matches.
-    return value.GetBar() < 42;
-  }
-  ...
-};
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-If your polymorphic matcher uses `ExplainMatchResultTo()` for better
-failure messages:
-```
-// Old matcher definition that doesn't work with the latest
-// Google Mock.
-using ::testing::MakePolymorphicMatcher;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetBar() < 42;
-  }
-  ...
-};
-void ExplainMatchResultTo(const MyGreatMatcher& matcher,
-                          MyType value,
-                          ::std::ostream* os) {
-  // Prints some helpful information to os to help
-  // a user understand why value matches (or doesn't match).
-  *os << "the Bar property is " << value.GetBar();
-}
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-you'll need to move the logic inside `ExplainMatchResultTo()` to
-`MatchAndExplain()`:
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MakePolymorphicMatcher;
-using ::testing::MatchResultListener;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool MatchAndExplain(MyType value,
-                       MatchResultListener* listener) const {
-    // Returns true if value matches.
-    *listener << "the Bar property is " << value.GetBar();
-    return value.GetBar() < 42;
-  }
-  ...
-};
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-For more information, you can read these
-[two](CookBook.md#writing-new-monomorphic-matchers)
-[recipes](CookBook.md#writing-new-polymorphic-matchers)
-from the cookbook.  As always, you
-are welcome to post questions on `googlemock@googlegroups.com` if you
-need any help.
-
-## When using Google Mock, do I have to use Google Test as the testing framework?  I have my favorite testing framework and don't want to switch. ##
-
-Google Mock works out of the box with Google Test.  However, it's easy
-to configure it to work with any testing framework of your choice.
-[Here](ForDummies.md#using-google-mock-with-any-testing-framework) is how.
-
-## How am I supposed to make sense of these horrible template errors? ##
-
-If you are confused by the compiler errors gcc threw at you,
-try consulting the _Google Mock Doctor_ tool first.  What it does is to
-scan stdin for gcc error messages, and spit out diagnoses on the
-problems (we call them diseases) your code has.
-
-To "install", run command:
-```
-alias gmd='<path to googlemock>/scripts/gmock_doctor.py'
-```
-
-To use it, do:
-```
-<your-favorite-build-command> <your-test> 2>&1 | gmd
-```
-
-For example:
-```
-make my_test 2>&1 | gmd
-```
-
-Or you can run `gmd` and copy-n-paste gcc's error messages to it.
-
-## Can I mock a variadic function? ##
-
-You cannot mock a variadic function (i.e. a function taking ellipsis
-(`...`) arguments) directly in Google Mock.
-
-The problem is that in general, there is _no way_ for a mock object to
-know how many arguments are passed to the variadic method, and what
-the arguments' types are.  Only the _author of the base class_ knows
-the protocol, and we cannot look into his head.
-
-Therefore, to mock such a function, the _user_ must teach the mock
-object how to figure out the number of arguments and their types.  One
-way to do it is to provide overloaded versions of the function.
-
-Ellipsis arguments are inherited from C and not really a C++ feature.
-They are unsafe to use and don't work with arguments that have
-constructors or destructors.  Therefore we recommend to avoid them in
-C++ as much as possible.
-
-## MSVC gives me warning C4301 or C4373 when I define a mock method with a const parameter.  Why? ##
-
-If you compile this using Microsoft Visual C++ 2005 SP1:
-```
-class Foo {
-  ...
-  virtual void Bar(const int i) = 0;
-};
-
-class MockFoo : public Foo {
-  ...
-  MOCK_METHOD1(Bar, void(const int i));
-};
-```
-You may get the following warning:
-```
-warning C4301: 'MockFoo::Bar': overriding virtual function only differs from 'Foo::Bar' by const/volatile qualifier
-```
-
-This is a MSVC bug.  The same code compiles fine with gcc ,for
-example.  If you use Visual C++ 2008 SP1, you would get the warning:
-```
-warning C4373: 'MockFoo::Bar': virtual function overrides 'Foo::Bar', previous versions of the compiler did not override when parameters only differed by const/volatile qualifiers
-```
-
-In C++, if you _declare_ a function with a `const` parameter, the
-`const` modifier is _ignored_.  Therefore, the `Foo` base class above
-is equivalent to:
-```
-class Foo {
-  ...
-  virtual void Bar(int i) = 0;  // int or const int?  Makes no difference.
-};
-```
-
-In fact, you can _declare_ Bar() with an `int` parameter, and _define_
-it with a `const int` parameter.  The compiler will still match them
-up.
-
-Since making a parameter `const` is meaningless in the method
-_declaration_, we recommend to remove it in both `Foo` and `MockFoo`.
-That should workaround the VC bug.
-
-Note that we are talking about the _top-level_ `const` modifier here.
-If the function parameter is passed by pointer or reference, declaring
-the _pointee_ or _referee_ as `const` is still meaningful.  For
-example, the following two declarations are _not_ equivalent:
-```
-void Bar(int* p);        // Neither p nor *p is const.
-void Bar(const int* p);  // p is not const, but *p is.
-```
-
-## I have a huge mock class, and Microsoft Visual C++ runs out of memory when compiling it.  What can I do? ##
-
-We've noticed that when the `/clr` compiler flag is used, Visual C++
-uses 5~6 times as much memory when compiling a mock class.  We suggest
-to avoid `/clr` when compiling native C++ mocks.
-
-## I can't figure out why Google Mock thinks my expectations are not satisfied.  What should I do? ##
-
-You might want to run your test with
-`--gmock_verbose=info`.  This flag lets Google Mock print a trace
-of every mock function call it receives.  By studying the trace,
-you'll gain insights on why the expectations you set are not met.
-
-## How can I assert that a function is NEVER called? ##
-
-```
-EXPECT_CALL(foo, Bar(_))
-    .Times(0);
-```
-
-## I have a failed test where Google Mock tells me TWICE that a particular expectation is not satisfied.  Isn't this redundant? ##
-
-When Google Mock detects a failure, it prints relevant information
-(the mock function arguments, the state of relevant expectations, and
-etc) to help the user debug.  If another failure is detected, Google
-Mock will do the same, including printing the state of relevant
-expectations.
-
-Sometimes an expectation's state didn't change between two failures,
-and you'll see the same description of the state twice.  They are
-however _not_ redundant, as they refer to _different points in time_.
-The fact they are the same _is_ interesting information.
-
-## I get a heap check failure when using a mock object, but using a real object is fine.  What can be wrong? ##
-
-Does the class (hopefully a pure interface) you are mocking have a
-virtual destructor?
-
-Whenever you derive from a base class, make sure its destructor is
-virtual.  Otherwise Bad Things will happen.  Consider the following
-code:
-
-```
-class Base {
- public:
-  // Not virtual, but should be.
-  ~Base() { ... }
-  ...
-};
-
-class Derived : public Base {
- public:
-  ...
- private:
-  std::string value_;
-};
-
-...
-  Base* p = new Derived;
-  ...
-  delete p;  // Surprise! ~Base() will be called, but ~Derived() will not
-             // - value_ is leaked.
-```
-
-By changing `~Base()` to virtual, `~Derived()` will be correctly
-called when `delete p` is executed, and the heap checker
-will be happy.
-
-## The "newer expectations override older ones" rule makes writing expectations awkward.  Why does Google Mock do that? ##
-
-When people complain about this, often they are referring to code like:
-
-```
-// foo.Bar() should be called twice, return 1 the first time, and return
-// 2 the second time.  However, I have to write the expectations in the
-// reverse order.  This sucks big time!!!
-EXPECT_CALL(foo, Bar())
-    .WillOnce(Return(2))
-    .RetiresOnSaturation();
-EXPECT_CALL(foo, Bar())
-    .WillOnce(Return(1))
-    .RetiresOnSaturation();
-```
-
-The problem is that they didn't pick the **best** way to express the test's
-intent.
-
-By default, expectations don't have to be matched in _any_ particular
-order.  If you want them to match in a certain order, you need to be
-explicit.  This is Google Mock's (and jMock's) fundamental philosophy: it's
-easy to accidentally over-specify your tests, and we want to make it
-harder to do so.
-
-There are two better ways to write the test spec.  You could either
-put the expectations in sequence:
-
-```
-// foo.Bar() should be called twice, return 1 the first time, and return
-// 2 the second time.  Using a sequence, we can write the expectations
-// in their natural order.
-{
-  InSequence s;
-  EXPECT_CALL(foo, Bar())
-      .WillOnce(Return(1))
-      .RetiresOnSaturation();
-  EXPECT_CALL(foo, Bar())
-      .WillOnce(Return(2))
-      .RetiresOnSaturation();
-}
-```
-
-or you can put the sequence of actions in the same expectation:
-
-```
-// foo.Bar() should be called twice, return 1 the first time, and return
-// 2 the second time.
-EXPECT_CALL(foo, Bar())
-    .WillOnce(Return(1))
-    .WillOnce(Return(2))
-    .RetiresOnSaturation();
-```
-
-Back to the original questions: why does Google Mock search the
-expectations (and `ON_CALL`s) from back to front?  Because this
-allows a user to set up a mock's behavior for the common case early
-(e.g. in the mock's constructor or the test fixture's set-up phase)
-and customize it with more specific rules later.  If Google Mock
-searches from front to back, this very useful pattern won't be
-possible.
-
-## Google Mock prints a warning when a function without EXPECT\_CALL is called, even if I have set its behavior using ON\_CALL.  Would it be reasonable not to show the warning in this case? ##
-
-When choosing between being neat and being safe, we lean toward the
-latter.  So the answer is that we think it's better to show the
-warning.
-
-Often people write `ON_CALL`s in the mock object's
-constructor or `SetUp()`, as the default behavior rarely changes from
-test to test.  Then in the test body they set the expectations, which
-are often different for each test.  Having an `ON_CALL` in the set-up
-part of a test doesn't mean that the calls are expected.  If there's
-no `EXPECT_CALL` and the method is called, it's possibly an error.  If
-we quietly let the call go through without notifying the user, bugs
-may creep in unnoticed.
-
-If, however, you are sure that the calls are OK, you can write
-
-```
-EXPECT_CALL(foo, Bar(_))
-    .WillRepeatedly(...);
-```
-
-instead of
-
-```
-ON_CALL(foo, Bar(_))
-    .WillByDefault(...);
-```
-
-This tells Google Mock that you do expect the calls and no warning should be
-printed.
-
-Also, you can control the verbosity using the `--gmock_verbose` flag.
-If you find the output too noisy when debugging, just choose a less
-verbose level.
-
-## How can I delete the mock function's argument in an action? ##
-
-If you find yourself needing to perform some action that's not
-supported by Google Mock directly, remember that you can define your own
-actions using
-[MakeAction()](CookBook.md#writing-new-actions) or
-[MakePolymorphicAction()](CookBook.md#writing_new_polymorphic_actions),
-or you can write a stub function and invoke it using
-[Invoke()](CookBook.md#using-functions_methods_functors).
-
-## MOCK\_METHODn()'s second argument looks funny.  Why don't you use the MOCK\_METHODn(Method, return\_type, arg\_1, ..., arg\_n) syntax? ##
-
-What?!  I think it's beautiful. :-)
-
-While which syntax looks more natural is a subjective matter to some
-extent, Google Mock's syntax was chosen for several practical advantages it
-has.
-
-Try to mock a function that takes a map as an argument:
-```
-virtual int GetSize(const map<int, std::string>& m);
-```
-
-Using the proposed syntax, it would be:
-```
-MOCK_METHOD1(GetSize, int, const map<int, std::string>& m);
-```
-
-Guess what?  You'll get a compiler error as the compiler thinks that
-`const map<int, std::string>& m` are **two**, not one, arguments. To work
-around this you can use `typedef` to give the map type a name, but
-that gets in the way of your work.  Google Mock's syntax avoids this
-problem as the function's argument types are protected inside a pair
-of parentheses:
-```
-// This compiles fine.
-MOCK_METHOD1(GetSize, int(const map<int, std::string>& m));
-```
-
-You still need a `typedef` if the return type contains an unprotected
-comma, but that's much rarer.
-
-Other advantages include:
-  1. `MOCK_METHOD1(Foo, int, bool)` can leave a reader wonder whether the method returns `int` or `bool`, while there won't be such confusion using Google Mock's syntax.
-  1. The way Google Mock describes a function type is nothing new, although many people may not be familiar with it.  The same syntax was used in C, and the `function` library in `tr1` uses this syntax extensively.  Since `tr1` will become a part of the new version of STL, we feel very comfortable to be consistent with it.
-  1. The function type syntax is also used in other parts of Google Mock's API (e.g. the action interface) in order to make the implementation tractable. A user needs to learn it anyway in order to utilize Google Mock's more advanced features.  We'd as well stick to the same syntax in `MOCK_METHOD*`!
-
-## My code calls a static/global function.  Can I mock it? ##
-
-You can, but you need to make some changes.
-
-In general, if you find yourself needing to mock a static function,
-it's a sign that your modules are too tightly coupled (and less
-flexible, less reusable, less testable, etc).  You are probably better
-off defining a small interface and call the function through that
-interface, which then can be easily mocked.  It's a bit of work
-initially, but usually pays for itself quickly.
-
-This Google Testing Blog
-[post](http://googletesting.blogspot.com/2008/06/defeat-static-cling.html)
-says it excellently.  Check it out.
-
-## My mock object needs to do complex stuff.  It's a lot of pain to specify the actions.  Google Mock sucks! ##
-
-I know it's not a question, but you get an answer for free any way. :-)
-
-With Google Mock, you can create mocks in C++ easily.  And people might be
-tempted to use them everywhere. Sometimes they work great, and
-sometimes you may find them, well, a pain to use. So, what's wrong in
-the latter case?
-
-When you write a test without using mocks, you exercise the code and
-assert that it returns the correct value or that the system is in an
-expected state.  This is sometimes called "state-based testing".
-
-Mocks are great for what some call "interaction-based" testing:
-instead of checking the system state at the very end, mock objects
-verify that they are invoked the right way and report an error as soon
-as it arises, giving you a handle on the precise context in which the
-error was triggered.  This is often more effective and economical to
-do than state-based testing.
-
-If you are doing state-based testing and using a test double just to
-simulate the real object, you are probably better off using a fake.
-Using a mock in this case causes pain, as it's not a strong point for
-mocks to perform complex actions.  If you experience this and think
-that mocks suck, you are just not using the right tool for your
-problem. Or, you might be trying to solve the wrong problem. :-)
-
-## I got a warning "Uninteresting function call encountered - default action taken.."  Should I panic? ##
-
-By all means, NO!  It's just an FYI.
-
-What it means is that you have a mock function, you haven't set any
-expectations on it (by Google Mock's rule this means that you are not
-interested in calls to this function and therefore it can be called
-any number of times), and it is called.  That's OK - you didn't say
-it's not OK to call the function!
-
-What if you actually meant to disallow this function to be called, but
-forgot to write `EXPECT_CALL(foo, Bar()).Times(0)`?  While
-one can argue that it's the user's fault, Google Mock tries to be nice and
-prints you a note.
-
-So, when you see the message and believe that there shouldn't be any
-uninteresting calls, you should investigate what's going on.  To make
-your life easier, Google Mock prints the function name and arguments
-when an uninteresting call is encountered.
-
-## I want to define a custom action.  Should I use Invoke() or implement the action interface? ##
-
-Either way is fine - you want to choose the one that's more convenient
-for your circumstance.
-
-Usually, if your action is for a particular function type, defining it
-using `Invoke()` should be easier; if your action can be used in
-functions of different types (e.g. if you are defining
-`Return(value)`), `MakePolymorphicAction()` is
-easiest.  Sometimes you want precise control on what types of
-functions the action can be used in, and implementing
-`ActionInterface` is the way to go here. See the implementation of
-`Return()` in `include/gmock/gmock-actions.h` for an example.
-
-## I'm using the set-argument-pointee action, and the compiler complains about "conflicting return type specified".  What does it mean? ##
-
-You got this error as Google Mock has no idea what value it should return
-when the mock method is called.  `SetArgPointee()` says what the
-side effect is, but doesn't say what the return value should be.  You
-need `DoAll()` to chain a `SetArgPointee()` with a `Return()`.
-
-See this [recipe](CookBook.md#mocking_side_effects) for more details and an example.
-
-
-## My question is not in your FAQ! ##
-
-If you cannot find the answer to your question in this FAQ, there are
-some other resources you can use:
-
-  1. read other [documentation](Documentation.md),
-  1. search the mailing list [archive](http://groups.google.com/group/googlemock/topics),
-  1. ask it on [googlemock@googlegroups.com](mailto:googlemock@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googlemock) before you can post.).
-
-Please note that creating an issue in the
-[issue tracker](https://github.com/google/googletest/issues) is _not_
-a good way to get your answer, as it is monitored infrequently by a
-very small number of people.
-
-When asking a question, it's helpful to provide as much of the
-following information as possible (people cannot help you if there's
-not enough information in your question):
-
-  * the version (or the revision number if you check out from SVN directly) of Google Mock you use (Google Mock is under active development, so it's possible that your problem has been solved in a later version),
-  * your operating system,
-  * the name and version of your compiler,
-  * the complete command line flags you give to your compiler,
-  * the complete compiler error messages (if the question is about compilation),
-  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/KnownIssues.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/KnownIssues.md
deleted file mode 100644
index adadf514..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/KnownIssues.md
+++ /dev/null
@@ -1,19 +0,0 @@
-As any non-trivial software system, Google Mock has some known limitations and problems.  We are working on improving it, and welcome your help!  The follow is a list of issues we know about.
-
-
-
-## README contains outdated information on Google Mock's compatibility with other testing frameworks ##
-
-The `README` file in release 1.1.0 still says that Google Mock only works with Google Test.  Actually, you can configure Google Mock to work with any testing framework you choose.
-
-## Tests failing on machines using Power PC CPUs (e.g. some Macs) ##
-
-`gmock_output_test` and `gmock-printers_test` are known to fail with Power PC CPUs.  This is due to portability issues with these tests, and is not an indication of problems in Google Mock itself.  You can safely ignore them.
-
-## Failed to resolve libgtest.so.0 in tests when built against installed Google Test ##
-
-This only applies if you manually built and installed Google Test, and then built a Google Mock against it (either explicitly, or because gtest-config was in your path post-install). In this situation, Libtool has a known issue with certain systems' ldconfig setup:
-
-http://article.gmane.org/gmane.comp.sysutils.automake.general/9025
-
-This requires a manual run of "sudo ldconfig" after the "sudo make install" for Google Test before any binaries which link against it can be executed. This isn't a bug in our install, but we should at least have documented it or hacked a work-around into our install. We should have one of these solutions in our next release.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CheatSheet.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CheatSheet.md
deleted file mode 100644
index 3c7bed4c..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CheatSheet.md
+++ /dev/null
@@ -1,525 +0,0 @@
-
-
-# Defining a Mock Class #
-
-## Mocking a Normal Class ##
-
-Given
-```
-class Foo {
-  ...
-  virtual ~Foo();
-  virtual int GetSize() const = 0;
-  virtual string Describe(const char* name) = 0;
-  virtual string Describe(int type) = 0;
-  virtual bool Process(Bar elem, int count) = 0;
-};
-```
-(note that `~Foo()` **must** be virtual) we can define its mock as
-```
-#include <gmock/gmock.h>
-
-class MockFoo : public Foo {
-  MOCK_CONST_METHOD0(GetSize, int());
-  MOCK_METHOD1(Describe, string(const char* name));
-  MOCK_METHOD1(Describe, string(int type));
-  MOCK_METHOD2(Process, bool(Bar elem, int count));
-};
-```
-
-To create a "nice" mock object which ignores all uninteresting calls,
-or a "strict" mock object, which treats them as failures:
-```
-NiceMock<MockFoo> nice_foo;     // The type is a subclass of MockFoo.
-StrictMock<MockFoo> strict_foo; // The type is a subclass of MockFoo.
-```
-
-## Mocking a Class Template ##
-
-To mock
-```
-template <typename Elem>
-class StackInterface {
- public:
-  ...
-  virtual ~StackInterface();
-  virtual int GetSize() const = 0;
-  virtual void Push(const Elem& x) = 0;
-};
-```
-(note that `~StackInterface()` **must** be virtual) just append `_T` to the `MOCK_*` macros:
-```
-template <typename Elem>
-class MockStack : public StackInterface<Elem> {
- public:
-  ...
-  MOCK_CONST_METHOD0_T(GetSize, int());
-  MOCK_METHOD1_T(Push, void(const Elem& x));
-};
-```
-
-## Specifying Calling Conventions for Mock Functions ##
-
-If your mock function doesn't use the default calling convention, you
-can specify it by appending `_WITH_CALLTYPE` to any of the macros
-described in the previous two sections and supplying the calling
-convention as the first argument to the macro. For example,
-```
-  MOCK_METHOD_1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int n));
-  MOCK_CONST_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, Bar, int(double x, double y));
-```
-where `STDMETHODCALLTYPE` is defined by `<objbase.h>` on Windows.
-
-# Using Mocks in Tests #
-
-The typical flow is:
-  1. Import the Google Mock names you need to use. All Google Mock names are in the `testing` namespace unless they are macros or otherwise noted.
-  1. Create the mock objects.
-  1. Optionally, set the default actions of the mock objects.
-  1. Set your expectations on the mock objects (How will they be called? What wil they do?).
-  1. Exercise code that uses the mock objects; if necessary, check the result using [Google Test](http://code.google.com/p/googletest/) assertions.
-  1. When a mock objects is destructed, Google Mock automatically verifies that all expectations on it have been satisfied.
-
-Here is an example:
-```
-using ::testing::Return;                            // #1
-
-TEST(BarTest, DoesThis) {
-  MockFoo foo;                                    // #2
-
-  ON_CALL(foo, GetSize())                         // #3
-      .WillByDefault(Return(1));
-  // ... other default actions ...
-
-  EXPECT_CALL(foo, Describe(5))                   // #4
-      .Times(3)
-      .WillRepeatedly(Return("Category 5"));
-  // ... other expectations ...
-
-  EXPECT_EQ("good", MyProductionFunction(&foo));  // #5
-}                                                 // #6
-```
-
-# Setting Default Actions #
-
-Google Mock has a **built-in default action** for any function that
-returns `void`, `bool`, a numeric value, or a pointer.
-
-To customize the default action for functions with return type `T` globally:
-```
-using ::testing::DefaultValue;
-
-DefaultValue<T>::Set(value);  // Sets the default value to be returned.
-// ... use the mocks ...
-DefaultValue<T>::Clear();     // Resets the default value.
-```
-
-To customize the default action for a particular method, use `ON_CALL()`:
-```
-ON_CALL(mock_object, method(matchers))
-    .With(multi_argument_matcher)  ?
-    .WillByDefault(action);
-```
-
-# Setting Expectations #
-
-`EXPECT_CALL()` sets **expectations** on a mock method (How will it be
-called? What will it do?):
-```
-EXPECT_CALL(mock_object, method(matchers))
-    .With(multi_argument_matcher)  ?
-    .Times(cardinality)            ?
-    .InSequence(sequences)         *
-    .After(expectations)           *
-    .WillOnce(action)              *
-    .WillRepeatedly(action)        ?
-    .RetiresOnSaturation();        ?
-```
-
-If `Times()` is omitted, the cardinality is assumed to be:
-
-  * `Times(1)` when there is neither `WillOnce()` nor `WillRepeatedly()`;
-  * `Times(n)` when there are `n WillOnce()`s but no `WillRepeatedly()`, where `n` >= 1; or
-  * `Times(AtLeast(n))` when there are `n WillOnce()`s and a `WillRepeatedly()`, where `n` >= 0.
-
-A method with no `EXPECT_CALL()` is free to be invoked _any number of times_, and the default action will be taken each time.
-
-# Matchers #
-
-A **matcher** matches a _single_ argument.  You can use it inside
-`ON_CALL()` or `EXPECT_CALL()`, or use it to validate a value
-directly:
-
-| `EXPECT_THAT(value, matcher)` | Asserts that `value` matches `matcher`. |
-|:------------------------------|:----------------------------------------|
-| `ASSERT_THAT(value, matcher)` | The same as `EXPECT_THAT(value, matcher)`, except that it generates a **fatal** failure. |
-
-Built-in matchers (where `argument` is the function argument) are
-divided into several categories:
-
-## Wildcard ##
-|`_`|`argument` can be any value of the correct type.|
-|:--|:-----------------------------------------------|
-|`A<type>()` or `An<type>()`|`argument` can be any value of type `type`.     |
-
-## Generic Comparison ##
-
-|`Eq(value)` or `value`|`argument == value`|
-|:---------------------|:------------------|
-|`Ge(value)`           |`argument >= value`|
-|`Gt(value)`           |`argument > value` |
-|`Le(value)`           |`argument <= value`|
-|`Lt(value)`           |`argument < value` |
-|`Ne(value)`           |`argument != value`|
-|`IsNull()`            |`argument` is a `NULL` pointer (raw or smart).|
-|`NotNull()`           |`argument` is a non-null pointer (raw or smart).|
-|`Ref(variable)`       |`argument` is a reference to `variable`.|
-|`TypedEq<type>(value)`|`argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded.|
-
-Except `Ref()`, these matchers make a _copy_ of `value` in case it's
-modified or destructed later. If the compiler complains that `value`
-doesn't have a public copy constructor, try wrap it in `ByRef()`,
-e.g. `Eq(ByRef(non_copyable_value))`. If you do that, make sure
-`non_copyable_value` is not changed afterwards, or the meaning of your
-matcher will be changed.
-
-## Floating-Point Matchers ##
-
-|`DoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as unequal.|
-|:-------------------|:----------------------------------------------------------------------------------------------|
-|`FloatEq(a_float)`  |`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal.  |
-|`NanSensitiveDoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal.  |
-|`NanSensitiveFloatEq(a_float)`|`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal.    |
-
-The above matchers use ULP-based comparison (the same as used in
-[Google Test](http://code.google.com/p/googletest/)). They
-automatically pick a reasonable error bound based on the absolute
-value of the expected value.  `DoubleEq()` and `FloatEq()` conform to
-the IEEE standard, which requires comparing two NaNs for equality to
-return false. The `NanSensitive*` version instead treats two NaNs as
-equal, which is often what a user wants.
-
-## String Matchers ##
-
-The `argument` can be either a C string or a C++ string object:
-
-|`ContainsRegex(string)`|`argument` matches the given regular expression.|
-|:----------------------|:-----------------------------------------------|
-|`EndsWith(suffix)`     |`argument` ends with string `suffix`.           |
-|`HasSubstr(string)`    |`argument` contains `string` as a sub-string.   |
-|`MatchesRegex(string)` |`argument` matches the given regular expression with the match starting at the first character and ending at the last character.|
-|`StartsWith(prefix)`   |`argument` starts with string `prefix`.         |
-|`StrCaseEq(string)`    |`argument` is equal to `string`, ignoring case. |
-|`StrCaseNe(string)`    |`argument` is not equal to `string`, ignoring case.|
-|`StrEq(string)`        |`argument` is equal to `string`.                |
-|`StrNe(string)`        |`argument` is not equal to `string`.            |
-
-`StrCaseEq()`, `StrCaseNe()`, `StrEq()`, and `StrNe()` work for wide
-strings as well.
-
-## Container Matchers ##
-
-Most STL-style containers support `==`, so you can use
-`Eq(expected_container)` or simply `expected_container` to match a
-container exactly.   If you want to write the elements in-line,
-match them more flexibly, or get more informative messages, you can use:
-
-| `Contains(e)` | `argument` contains an element that matches `e`, which can be either a value or a matcher. |
-|:--------------|:-------------------------------------------------------------------------------------------|
-|`ElementsAre(e0, e1, ..., en)`|`argument` has `n + 1` elements, where the i-th element matches `ei`, which can be a value or a matcher. 0 to 10 arguments are allowed.|
-|`ElementsAreArray(array)` or `ElementsAreArray(array, count)`|The same as `ElementsAre()` except that the expected element values/matchers come from a C-style array.|
-| `ContainerEq(container)` | The same as `Eq(container)` except that the failure message also includes which elements are in one container but not the other. |
-
-These matchers can also match:
-
-  1. a native array passed by reference (e.g. in `Foo(const int (&a)[5])`), and
-  1. an array passed as a pointer and a count (e.g. in `Bar(const T* buffer, int len)` -- see [Multi-argument Matchers](#Multiargument_Matchers.md)).
-
-where the array may be multi-dimensional (i.e. its elements can be arrays).
-
-## Member Matchers ##
-
-|`Field(&class::field, m)`|`argument.field` (or `argument->field` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
-|:------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------|
-|`Key(e)`                 |`argument.first` matches `e`, which can be either a value or a matcher. E.g. `Contains(Key(Le(5)))` can verify that a `map` contains a key `<= 5`.|
-|`Pair(m1, m2)`           |`argument` is an `std::pair` whose `first` field matches `m1` and `second` field matches `m2`.                                                |
-|`Property(&class::property, m)`|`argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
-
-## Matching the Result of a Function or Functor ##
-
-|`ResultOf(f, m)`|`f(argument)` matches matcher `m`, where `f` is a function or functor.|
-|:---------------|:---------------------------------------------------------------------|
-
-## Pointer Matchers ##
-
-|`Pointee(m)`|`argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`.|
-|:-----------|:-----------------------------------------------------------------------------------------------|
-
-## Multiargument Matchers ##
-
-These are matchers on tuple types. They can be used in
-`.With()`. The following can be used on functions with <i>two<br>
-arguments</i> `x` and `y`:
-
-|`Eq()`|`x == y`|
-|:-----|:-------|
-|`Ge()`|`x >= y`|
-|`Gt()`|`x > y` |
-|`Le()`|`x <= y`|
-|`Lt()`|`x < y` |
-|`Ne()`|`x != y`|
-
-You can use the following selectors to pick a subset of the arguments
-(or reorder them) to participate in the matching:
-
-|`AllArgs(m)`|Equivalent to `m`. Useful as syntactic sugar in `.With(AllArgs(m))`.|
-|:-----------|:-------------------------------------------------------------------|
-|`Args<N1, N2, ..., Nk>(m)`|The `k` selected (using 0-based indices) arguments match `m`, e.g. `Args<1, 2>(Contains(5))`.|
-
-## Composite Matchers ##
-
-You can make a matcher from one or more other matchers:
-
-|`AllOf(m1, m2, ..., mn)`|`argument` matches all of the matchers `m1` to `mn`.|
-|:-----------------------|:---------------------------------------------------|
-|`AnyOf(m1, m2, ..., mn)`|`argument` matches at least one of the matchers `m1` to `mn`.|
-|`Not(m)`                |`argument` doesn't match matcher `m`.               |
-
-## Adapters for Matchers ##
-
-|`MatcherCast<T>(m)`|casts matcher `m` to type `Matcher<T>`.|
-|:------------------|:--------------------------------------|
-|`SafeMatcherCast<T>(m)`| [safely casts](V1_5_CookBook#Casting_Matchers.md) matcher `m` to type `Matcher<T>`. |
-|`Truly(predicate)` |`predicate(argument)` returns something considered by C++ to be true, where `predicate` is a function or functor.|
-
-## Matchers as Predicates ##
-
-|`Matches(m)`|a unary functor that returns `true` if the argument matches `m`.|
-|:-----------|:---------------------------------------------------------------|
-|`ExplainMatchResult(m, value, result_listener)`|returns `true` if `value` matches `m`, explaining the result to `result_listener`.|
-|`Value(x, m)`|returns `true` if the value of `x` matches `m`.                 |
-
-## Defining Matchers ##
-
-| `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. |
-|:-------------------------------------------------|:------------------------------------------------------|
-| `MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; }` | Defines a macher `IsDivisibleBy(n)` to match a number divisible by `n`. |
-| `MATCHER_P2(IsBetween, a, b, "is between %(a)s and %(b)s") { return a <= arg && arg <= b; }` | Defines a matcher `IsBetween(a, b)` to match a value in the range [`a`, `b`]. |
-
-**Notes:**
-
-  1. The `MATCHER*` macros cannot be used inside a function or class.
-  1. The matcher body must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters).
-  1. You can use `PrintToString(x)` to convert a value `x` of any type to a string.
-
-## Matchers as Test Assertions ##
-
-|`ASSERT_THAT(expression, m)`|Generates a [fatal failure](http://code.google.com/p/googletest/wiki/GoogleTestPrimer#Assertions) if the value of `expression` doesn't match matcher `m`.|
-|:---------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------|
-|`EXPECT_THAT(expression, m)`|Generates a non-fatal failure if the value of `expression` doesn't match matcher `m`.                                                                    |
-
-# Actions #
-
-**Actions** specify what a mock function should do when invoked.
-
-## Returning a Value ##
-
-|`Return()`|Return from a `void` mock function.|
-|:---------|:----------------------------------|
-|`Return(value)`|Return `value`.                    |
-|`ReturnArg<N>()`|Return the `N`-th (0-based) argument.|
-|`ReturnNew<T>(a1, ..., ak)`|Return `new T(a1, ..., ak)`; a different object is created each time.|
-|`ReturnNull()`|Return a null pointer.             |
-|`ReturnRef(variable)`|Return a reference to `variable`.  |
-
-## Side Effects ##
-
-|`Assign(&variable, value)`|Assign `value` to variable.|
-|:-------------------------|:--------------------------|
-| `DeleteArg<N>()`         | Delete the `N`-th (0-based) argument, which must be a pointer. |
-| `SaveArg<N>(pointer)`    | Save the `N`-th (0-based) argument to `*pointer`. |
-| `SetArgReferee<N>(value)` |	Assign value to the variable referenced by the `N`-th (0-based) argument. |
-|`SetArgumentPointee<N>(value)`|Assign `value` to the variable pointed by the `N`-th (0-based) argument.|
-|`SetArrayArgument<N>(first, last)`|Copies the elements in source range [`first`, `last`) to the array pointed to by the `N`-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.|
-|`SetErrnoAndReturn(error, value)`|Set `errno` to `error` and return `value`.|
-|`Throw(exception)`        |Throws the given exception, which can be any copyable value. Available since v1.1.0.|
-
-## Using a Function or a Functor as an Action ##
-
-|`Invoke(f)`|Invoke `f` with the arguments passed to the mock function, where `f` can be a global/static function or a functor.|
-|:----------|:-----------------------------------------------------------------------------------------------------------------|
-|`Invoke(object_pointer, &class::method)`|Invoke the {method on the object with the arguments passed to the mock function.                                  |
-|`InvokeWithoutArgs(f)`|Invoke `f`, which can be a global/static function or a functor. `f` must take no arguments.                       |
-|`InvokeWithoutArgs(object_pointer, &class::method)`|Invoke the method on the object, which takes no arguments.                                                        |
-|`InvokeArgument<N>(arg1, arg2, ..., argk)`|Invoke the mock function's `N`-th (0-based) argument, which must be a function or a functor, with the `k` arguments.|
-
-The return value of the invoked function is used as the return value
-of the action.
-
-When defining a function or functor to be used with `Invoke*()`, you can declare any unused parameters as `Unused`:
-```
-  double Distance(Unused, double x, double y) { return sqrt(x*x + y*y); }
-  ...
-  EXPECT_CALL(mock, Foo("Hi", _, _)).WillOnce(Invoke(Distance));
-```
-
-In `InvokeArgument<N>(...)`, if an argument needs to be passed by reference, wrap it inside `ByRef()`. For example,
-```
-  InvokeArgument<2>(5, string("Hi"), ByRef(foo))
-```
-calls the mock function's #2 argument, passing to it `5` and `string("Hi")` by value, and `foo` by reference.
-
-## Default Action ##
-
-|`DoDefault()`|Do the default action (specified by `ON_CALL()` or the built-in one).|
-|:------------|:--------------------------------------------------------------------|
-
-**Note:** due to technical reasons, `DoDefault()` cannot be used inside  a composite action - trying to do so will result in a run-time error.
-
-## Composite Actions ##
-
-|`DoAll(a1, a2, ..., an)`|Do all actions `a1` to `an` and return the result of `an` in each invocation. The first `n - 1` sub-actions must return void. |
-|:-----------------------|:-----------------------------------------------------------------------------------------------------------------------------|
-|`IgnoreResult(a)`       |Perform action `a` and ignore its result. `a` must not return void.                                                           |
-|`WithArg<N>(a)`         |Pass the `N`-th (0-based) argument of the mock function to action `a` and perform it.                                         |
-|`WithArgs<N1, N2, ..., Nk>(a)`|Pass the selected (0-based) arguments of the mock function to action `a` and perform it.                                      |
-|`WithoutArgs(a)`        |Perform action `a` without any arguments.                                                                                     |
-
-## Defining Actions ##
-
-| `ACTION(Sum) { return arg0 + arg1; }` | Defines an action `Sum()` to return the sum of the mock function's argument #0 and #1. |
-|:--------------------------------------|:---------------------------------------------------------------------------------------|
-| `ACTION_P(Plus, n) { return arg0 + n; }` | Defines an action `Plus(n)` to return the sum of the mock function's argument #0 and `n`. |
-| `ACTION_Pk(Foo, p1, ..., pk) { statements; }` | Defines a parameterized action `Foo(p1, ..., pk)` to execute the given `statements`.   |
-
-The `ACTION*` macros cannot be used inside a function or class.
-
-# Cardinalities #
-
-These are used in `Times()` to specify how many times a mock function will be called:
-
-|`AnyNumber()`|The function can be called any number of times.|
-|:------------|:----------------------------------------------|
-|`AtLeast(n)` |The call is expected at least `n` times.       |
-|`AtMost(n)`  |The call is expected at most `n` times.        |
-|`Between(m, n)`|The call is expected between `m` and `n` (inclusive) times.|
-|`Exactly(n) or n`|The call is expected exactly `n` times. In particular, the call should never happen when `n` is 0.|
-
-# Expectation Order #
-
-By default, the expectations can be matched in _any_ order.  If some
-or all expectations must be matched in a given order, there are two
-ways to specify it.  They can be used either independently or
-together.
-
-## The After Clause ##
-
-```
-using ::testing::Expectation;
-...
-Expectation init_x = EXPECT_CALL(foo, InitX());
-Expectation init_y = EXPECT_CALL(foo, InitY());
-EXPECT_CALL(foo, Bar())
-    .After(init_x, init_y);
-```
-says that `Bar()` can be called only after both `InitX()` and
-`InitY()` have been called.
-
-If you don't know how many pre-requisites an expectation has when you
-write it, you can use an `ExpectationSet` to collect them:
-
-```
-using ::testing::ExpectationSet;
-...
-ExpectationSet all_inits;
-for (int i = 0; i < element_count; i++) {
-  all_inits += EXPECT_CALL(foo, InitElement(i));
-}
-EXPECT_CALL(foo, Bar())
-    .After(all_inits);
-```
-says that `Bar()` can be called only after all elements have been
-initialized (but we don't care about which elements get initialized
-before the others).
-
-Modifying an `ExpectationSet` after using it in an `.After()` doesn't
-affect the meaning of the `.After()`.
-
-## Sequences ##
-
-When you have a long chain of sequential expectations, it's easier to
-specify the order using **sequences**, which don't require you to given
-each expectation in the chain a different name.  <i>All expected<br>
-calls</i> in the same sequence must occur in the order they are
-specified.
-
-```
-using ::testing::Sequence;
-Sequence s1, s2;
-...
-EXPECT_CALL(foo, Reset())
-    .InSequence(s1, s2)
-    .WillOnce(Return(true));
-EXPECT_CALL(foo, GetSize())
-    .InSequence(s1)
-    .WillOnce(Return(1));
-EXPECT_CALL(foo, Describe(A<const char*>()))
-    .InSequence(s2)
-    .WillOnce(Return("dummy"));
-```
-says that `Reset()` must be called before _both_ `GetSize()` _and_
-`Describe()`, and the latter two can occur in any order.
-
-To put many expectations in a sequence conveniently:
-```
-using ::testing::InSequence;
-{
-  InSequence dummy;
-
-  EXPECT_CALL(...)...;
-  EXPECT_CALL(...)...;
-  ...
-  EXPECT_CALL(...)...;
-}
-```
-says that all expected calls in the scope of `dummy` must occur in
-strict order. The name `dummy` is irrelevant.)
-
-# Verifying and Resetting a Mock #
-
-Google Mock will verify the expectations on a mock object when it is destructed, or you can do it earlier:
-```
-using ::testing::Mock;
-...
-// Verifies and removes the expectations on mock_obj;
-// returns true iff successful.
-Mock::VerifyAndClearExpectations(&mock_obj);
-...
-// Verifies and removes the expectations on mock_obj;
-// also removes the default actions set by ON_CALL();
-// returns true iff successful.
-Mock::VerifyAndClear(&mock_obj);
-```
-
-You can also tell Google Mock that a mock object can be leaked and doesn't
-need to be verified:
-```
-Mock::AllowLeak(&mock_obj);
-```
-
-# Mock Classes #
-
-Google Mock defines a convenient mock class template
-```
-class MockFunction<R(A1, ..., An)> {
- public:
-  MOCK_METHODn(Call, R(A1, ..., An));
-};
-```
-See this [recipe](V1_5_CookBook#Using_Check_Points.md) for one application of it.
-
-# Flags #
-
-| `--gmock_catch_leaked_mocks=0` | Don't report leaked mock objects as failures. |
-|:-------------------------------|:----------------------------------------------|
-| `--gmock_verbose=LEVEL`        | Sets the default verbosity level (`info`, `warning`, or `error`) of Google Mock messages. |
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CookBook.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CookBook.md
deleted file mode 100644
index 26e153c6..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/CookBook.md
+++ /dev/null
@@ -1,3250 +0,0 @@
-
-
-You can find recipes for using Google Mock here. If you haven't yet,
-please read the [ForDummies](V1_5_ForDummies.md) document first to make sure you understand
-the basics.
-
-**Note:** Google Mock lives in the `testing` name space. For
-readability, it is recommended to write `using ::testing::Foo;` once in
-your file before using the name `Foo` defined by Google Mock. We omit
-such `using` statements in this page for brevity, but you should do it
-in your own code.
-
-# Creating Mock Classes #
-
-## Mocking Private or Protected Methods ##
-
-You must always put a mock method definition (`MOCK_METHOD*`) in a
-`public:` section of the mock class, regardless of the method being
-mocked being `public`, `protected`, or `private` in the base class.
-This allows `ON_CALL` and `EXPECT_CALL` to reference the mock function
-from outside of the mock class.  (Yes, C++ allows a subclass to change
-the access level of a virtual function in the base class.)  Example:
-
-```
-class Foo {
- public:
-  ...
-  virtual bool Transform(Gadget* g) = 0;
-
- protected:
-  virtual void Resume();
-
- private:
-  virtual int GetTimeOut();
-};
-
-class MockFoo : public Foo {
- public:
-  ...
-  MOCK_METHOD1(Transform, bool(Gadget* g));
-
-  // The following must be in the public section, even though the
-  // methods are protected or private in the base class.
-  MOCK_METHOD0(Resume, void());
-  MOCK_METHOD0(GetTimeOut, int());
-};
-```
-
-## Mocking Overloaded Methods ##
-
-You can mock overloaded functions as usual. No special attention is required:
-
-```
-class Foo {
-  ...
-
-  // Must be virtual as we'll inherit from Foo.
-  virtual ~Foo();
-
-  // Overloaded on the types and/or numbers of arguments.
-  virtual int Add(Element x);
-  virtual int Add(int times, Element x);
-
-  // Overloaded on the const-ness of this object.
-  virtual Bar& GetBar();
-  virtual const Bar& GetBar() const;
-};
-
-class MockFoo : public Foo {
-  ...
-  MOCK_METHOD1(Add, int(Element x));
-  MOCK_METHOD2(Add, int(int times, Element x);
-
-  MOCK_METHOD0(GetBar, Bar&());
-  MOCK_CONST_METHOD0(GetBar, const Bar&());
-};
-```
-
-**Note:** if you don't mock all versions of the overloaded method, the
-compiler will give you a warning about some methods in the base class
-being hidden. To fix that, use `using` to bring them in scope:
-
-```
-class MockFoo : public Foo {
-  ...
-  using Foo::Add;
-  MOCK_METHOD1(Add, int(Element x));
-  // We don't want to mock int Add(int times, Element x);
-  ...
-};
-```
-
-## Mocking Class Templates ##
-
-To mock a class template, append `_T` to the `MOCK_*` macros:
-
-```
-template <typename Elem>
-class StackInterface {
-  ...
-  // Must be virtual as we'll inherit from StackInterface.
-  virtual ~StackInterface();
-
-  virtual int GetSize() const = 0;
-  virtual void Push(const Elem& x) = 0;
-};
-
-template <typename Elem>
-class MockStack : public StackInterface<Elem> {
-  ...
-  MOCK_CONST_METHOD0_T(GetSize, int());
-  MOCK_METHOD1_T(Push, void(const Elem& x));
-};
-```
-
-## Mocking Nonvirtual Methods ##
-
-Google Mock can mock non-virtual functions to be used in what we call _hi-perf
-dependency injection_.
-
-In this case, instead of sharing a common base class with the real
-class, your mock class will be _unrelated_ to the real class, but
-contain methods with the same signatures.  The syntax for mocking
-non-virtual methods is the _same_ as mocking virtual methods:
-
-```
-// A simple packet stream class.  None of its members is virtual.
-class ConcretePacketStream {
- public:
-  void AppendPacket(Packet* new_packet);
-  const Packet* GetPacket(size_t packet_number) const;
-  size_t NumberOfPackets() const;
-  ...
-};
-
-// A mock packet stream class.  It inherits from no other, but defines
-// GetPacket() and NumberOfPackets().
-class MockPacketStream {
- public:
-  MOCK_CONST_METHOD1(GetPacket, const Packet*(size_t packet_number));
-  MOCK_CONST_METHOD0(NumberOfPackets, size_t());
-  ...
-};
-```
-
-Note that the mock class doesn't define `AppendPacket()`, unlike the
-real class. That's fine as long as the test doesn't need to call it.
-
-Next, you need a way to say that you want to use
-`ConcretePacketStream` in production code, and use `MockPacketStream`
-in tests.  Since the functions are not virtual and the two classes are
-unrelated, you must specify your choice at _compile time_ (as opposed
-to run time).
-
-One way to do it is to templatize your code that needs to use a packet
-stream.  More specifically, you will give your code a template type
-argument for the type of the packet stream.  In production, you will
-instantiate your template with `ConcretePacketStream` as the type
-argument.  In tests, you will instantiate the same template with
-`MockPacketStream`.  For example, you may write:
-
-```
-template <class PacketStream>
-void CreateConnection(PacketStream* stream) { ... }
-
-template <class PacketStream>
-class PacketReader {
- public:
-  void ReadPackets(PacketStream* stream, size_t packet_num);
-};
-```
-
-Then you can use `CreateConnection<ConcretePacketStream>()` and
-`PacketReader<ConcretePacketStream>` in production code, and use
-`CreateConnection<MockPacketStream>()` and
-`PacketReader<MockPacketStream>` in tests.
-
-```
-  MockPacketStream mock_stream;
-  EXPECT_CALL(mock_stream, ...)...;
-  .. set more expectations on mock_stream ...
-  PacketReader<MockPacketStream> reader(&mock_stream);
-  ... exercise reader ...
-```
-
-## Mocking Free Functions ##
-
-It's possible to use Google Mock to mock a free function (i.e. a
-C-style function or a static method).  You just need to rewrite your
-code to use an interface (abstract class).
-
-Instead of calling a free function (say, `OpenFile`) directly,
-introduce an interface for it and have a concrete subclass that calls
-the free function:
-
-```
-class FileInterface {
- public:
-  ...
-  virtual bool Open(const char* path, const char* mode) = 0;
-};
-
-class File : public FileInterface {
- public:
-  ...
-  virtual bool Open(const char* path, const char* mode) {
-    return OpenFile(path, mode);
-  }
-};
-```
-
-Your code should talk to `FileInterface` to open a file.  Now it's
-easy to mock out the function.
-
-This may seem much hassle, but in practice you often have multiple
-related functions that you can put in the same interface, so the
-per-function syntactic overhead will be much lower.
-
-If you are concerned about the performance overhead incurred by
-virtual functions, and profiling confirms your concern, you can
-combine this with the recipe for [mocking non-virtual methods](#Mocking_Nonvirtual_Methods.md).
-
-## Nice Mocks and Strict Mocks ##
-
-If a mock method has no `EXPECT_CALL` spec but is called, Google Mock
-will print a warning about the "uninteresting call". The rationale is:
-
-  * New methods may be added to an interface after a test is written. We shouldn't fail a test just because a method it doesn't know about is called.
-  * However, this may also mean there's a bug in the test, so Google Mock shouldn't be silent either. If the user believes these calls are harmless, he can add an `EXPECT_CALL()` to suppress the warning.
-
-However, sometimes you may want to suppress all "uninteresting call"
-warnings, while sometimes you may want the opposite, i.e. to treat all
-of them as errors. Google Mock lets you make the decision on a
-per-mock-object basis.
-
-Suppose your test uses a mock class `MockFoo`:
-
-```
-TEST(...) {
-  MockFoo mock_foo;
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-}
-```
-
-If a method of `mock_foo` other than `DoThis()` is called, it will be
-reported by Google Mock as a warning. However, if you rewrite your
-test to use `NiceMock<MockFoo>` instead, the warning will be gone,
-resulting in a cleaner test output:
-
-```
-using ::testing::NiceMock;
-
-TEST(...) {
-  NiceMock<MockFoo> mock_foo;
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-}
-```
-
-`NiceMock<MockFoo>` is a subclass of `MockFoo`, so it can be used
-wherever `MockFoo` is accepted.
-
-It also works if `MockFoo`'s constructor takes some arguments, as
-`NiceMock<MockFoo>` "inherits" `MockFoo`'s constructors:
-
-```
-using ::testing::NiceMock;
-
-TEST(...) {
-  NiceMock<MockFoo> mock_foo(5, "hi");  // Calls MockFoo(5, "hi").
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-}
-```
-
-The usage of `StrictMock` is similar, except that it makes all
-uninteresting calls failures:
-
-```
-using ::testing::StrictMock;
-
-TEST(...) {
-  StrictMock<MockFoo> mock_foo;
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-
-  // The test will fail if a method of mock_foo other than DoThis()
-  // is called.
-}
-```
-
-There are some caveats though (I don't like them just as much as the
-next guy, but sadly they are side effects of C++'s limitations):
-
-  1. `NiceMock<MockFoo>` and `StrictMock<MockFoo>` only work 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` and `StrictMock` (e.g. `NiceMock<StrictMock<MockFoo> >`) is **not** supported.
-  1. The constructors of the base mock (`MockFoo`) cannot have arguments passed by non-const reference, which happens to be banned by the [Google C++ style guide](http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml).
-  1. During the constructor or destructor of `MockFoo`, the mock object is _not_ nice or strict.  This may cause surprises if the constructor or destructor calls a mock method on `this` object. (This behavior, however, is consistent with C++'s general rule: if a constructor or destructor calls a virtual method of `this` object, that method is treated as non-virtual.  In other words, to the base class's constructor or destructor, `this` object behaves like an instance of the base class, not the derived class.  This rule is required for safety.  Otherwise a base constructor may use members of a derived class before they are initialized, or a base destructor may use members of a derived class after they have been destroyed.)
-
-Finally, you should be **very cautious** when using this feature, as the
-decision you make applies to **all** future changes to the mock
-class. If an important change is made in the interface you are mocking
-(and thus in the mock class), it could break your tests (if you use
-`StrictMock`) or let bugs pass through without a warning (if you use
-`NiceMock`). Therefore, try to specify the mock's behavior using
-explicit `EXPECT_CALL` first, and only turn to `NiceMock` or
-`StrictMock` as the last resort.
-
-## Simplifying the Interface without Breaking Existing Code ##
-
-Sometimes a method has a long list of arguments that is mostly
-uninteresting. For example,
-
-```
-class LogSink {
- public:
-  ...
-  virtual void send(LogSeverity severity, const char* full_filename,
-                    const char* base_filename, int line,
-                    const struct tm* tm_time,
-                    const char* message, size_t message_len) = 0;
-};
-```
-
-This method's argument list is lengthy and hard to work with (let's
-say that the `message` argument is not even 0-terminated). If we mock
-it as is, using the mock will be awkward. If, however, we try to
-simplify this interface, we'll need to fix all clients depending on
-it, which is often infeasible.
-
-The trick is to re-dispatch the method in the mock class:
-
-```
-class ScopedMockLog : public LogSink {
- public:
-  ...
-  virtual void send(LogSeverity severity, const char* full_filename,
-                    const char* base_filename, int line, const tm* tm_time,
-                    const char* message, size_t message_len) {
-    // We are only interested in the log severity, full file name, and
-    // log message.
-    Log(severity, full_filename, std::string(message, message_len));
-  }
-
-  // Implements the mock method:
-  //
-  //   void Log(LogSeverity severity,
-  //            const string& file_path,
-  //            const string& message);
-  MOCK_METHOD3(Log, void(LogSeverity severity, const string& file_path,
-                         const string& message));
-};
-```
-
-By defining a new mock method with a trimmed argument list, we make
-the mock class much more user-friendly.
-
-## Alternative to Mocking Concrete Classes ##
-
-Often you may find yourself using classes that don't implement
-interfaces. In order to test your code that uses such a class (let's
-call it `Concrete`), you may be tempted to make the methods of
-`Concrete` virtual and then mock it.
-
-Try not to do that.
-
-Making a non-virtual function virtual is a big decision. It creates an
-extension point where subclasses can tweak your class' behavior. This
-weakens your control on the class because now it's harder to maintain
-the class' invariants. You should make a function virtual only when
-there is a valid reason for a subclass to override it.
-
-Mocking concrete classes directly is problematic as it creates a tight
-coupling between the class and the tests - any small change in the
-class may invalidate your tests and make test maintenance a pain.
-
-To avoid such problems, many programmers have been practicing "coding
-to interfaces": instead of talking to the `Concrete` class, your code
-would define an interface and talk to it. Then you implement that
-interface as an adaptor on top of `Concrete`. In tests, you can easily
-mock that interface to observe how your code is doing.
-
-This technique incurs some overhead:
-
-  * You pay the cost of virtual function calls (usually not a problem).
-  * There is more abstraction for the programmers to learn.
-
-However, it can also bring significant benefits in addition to better
-testability:
-
-  * `Concrete`'s API may not fit your problem domain very well, as you may not be the only client it tries to serve. By designing your own interface, you have a chance to tailor it to your need - you may add higher-level functionalities, rename stuff, etc instead of just trimming the class. This allows you to write your code (user of the interface) in a more natural way, which means it will be more readable, more maintainable, and you'll be more productive.
-  * If `Concrete`'s implementation ever has to change, you don't have to rewrite everywhere it is used. Instead, you can absorb the change in your implementation of the interface, and your other code and tests will be insulated from this change.
-
-Some people worry that if everyone is practicing this technique, they
-will end up writing lots of redundant code. This concern is totally
-understandable. However, there are two reasons why it may not be the
-case:
-
-  * Different projects may need to use `Concrete` in different ways, so the best interfaces for them will be different. Therefore, each of them will have its own domain-specific interface on top of `Concrete`, and they will not be the same code.
-  * If enough projects want to use the same interface, they can always share it, just like they have been sharing `Concrete`. You can check in the interface and the adaptor somewhere near `Concrete` (perhaps in a `contrib` sub-directory) and let many projects use it.
-
-You need to weigh the pros and cons carefully for your particular
-problem, but I'd like to assure you that the Java community has been
-practicing this for a long time and it's a proven effective technique
-applicable in a wide variety of situations. :-)
-
-## Delegating Calls to a Fake ##
-
-Some times you have a non-trivial fake implementation of an
-interface. For example:
-
-```
-class Foo {
- public:
-  virtual ~Foo() {}
-  virtual char DoThis(int n) = 0;
-  virtual void DoThat(const char* s, int* p) = 0;
-};
-
-class FakeFoo : public Foo {
- public:
-  virtual char DoThis(int n) {
-    return (n > 0) ? '+' :
-        (n < 0) ? '-' : '0';
-  }
-
-  virtual void DoThat(const char* s, int* p) {
-    *p = strlen(s);
-  }
-};
-```
-
-Now you want to mock this interface such that you can set expectations
-on it. However, you also want to use `FakeFoo` for the default
-behavior, as duplicating it in the mock object is, well, a lot of
-work.
-
-When you define the mock class using Google Mock, you can have it
-delegate its default action to a fake class you already have, using
-this pattern:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-class MockFoo : public Foo {
- public:
-  // Normal mock method definitions using Google Mock.
-  MOCK_METHOD1(DoThis, char(int n));
-  MOCK_METHOD2(DoThat, void(const char* s, int* p));
-
-  // Delegates the default actions of the methods to a FakeFoo object.
-  // This must be called *before* the custom ON_CALL() statements.
-  void DelegateToFake() {
-    ON_CALL(*this, DoThis(_))
-        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThis));
-    ON_CALL(*this, DoThat(_, _))
-        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThat));
-  }
- private:
-  FakeFoo fake_;  // Keeps an instance of the fake in the mock.
-};
-```
-
-With that, you can use `MockFoo` in your tests as usual. Just remember
-that if you don't explicitly set an action in an `ON_CALL()` or
-`EXPECT_CALL()`, the fake will be called upon to do it:
-
-```
-using ::testing::_;
-
-TEST(AbcTest, Xyz) {
-  MockFoo foo;
-  foo.DelegateToFake(); // Enables the fake for delegation.
-
-  // Put your ON_CALL(foo, ...)s here, if any.
-
-  // No action specified, meaning to use the default action.
-  EXPECT_CALL(foo, DoThis(5));
-  EXPECT_CALL(foo, DoThat(_, _));
-
-  int n = 0;
-  EXPECT_EQ('+', foo.DoThis(5));  // FakeFoo::DoThis() is invoked.
-  foo.DoThat("Hi", &n);           // FakeFoo::DoThat() is invoked.
-  EXPECT_EQ(2, n);
-}
-```
-
-**Some tips:**
-
-  * If you want, you can still override the default action by providing your own `ON_CALL()` or using `.WillOnce()` / `.WillRepeatedly()` in `EXPECT_CALL()`.
-  * In `DelegateToFake()`, you only need to delegate the methods whose fake implementation you intend to use.
-  * The general technique discussed here works for overloaded methods, but you'll need to tell the compiler which version you mean. To disambiguate a mock function (the one you specify inside the parentheses of `ON_CALL()`), see the "Selecting Between Overloaded Functions" section on this page; to disambiguate a fake function (the one you place inside `Invoke()`), use a `static_cast` to specify the function's type.
-  * Having to mix a mock and a fake is often a sign of something gone wrong. Perhaps you haven't got used to the interaction-based way of testing yet. Or perhaps your interface is taking on too many roles and should be split up. Therefore, **don't abuse this**. We would only recommend to do it as an intermediate step when you are refactoring your code.
-
-Regarding the tip on mixing a mock and a fake, here's an example on
-why it may be a bad sign: Suppose you have a class `System` for
-low-level system operations. In particular, it does file and I/O
-operations. And suppose you want to test how your code uses `System`
-to do I/O, and you just want the file operations to work normally. If
-you mock out the entire `System` class, you'll have to provide a fake
-implementation for the file operation part, which suggests that
-`System` is taking on too many roles.
-
-Instead, you can define a `FileOps` interface and an `IOOps` interface
-and split `System`'s functionalities into the two. Then you can mock
-`IOOps` without mocking `FileOps`.
-
-## Delegating Calls to a Real Object ##
-
-When using testing doubles (mocks, fakes, stubs, and etc), sometimes
-their behaviors will differ from those of the real objects. This
-difference could be either intentional (as in simulating an error such
-that you can test the error handling code) or unintentional. If your
-mocks have different behaviors than the real objects by mistake, you
-could end up with code that passes the tests but fails in production.
-
-You can use the _delegating-to-real_ technique to ensure that your
-mock has the same behavior as the real object while retaining the
-ability to validate calls. This technique is very similar to the
-delegating-to-fake technique, the difference being that we use a real
-object instead of a fake. Here's an example:
-
-```
-using ::testing::_;
-using ::testing::AtLeast;
-using ::testing::Invoke;
-
-class MockFoo : public Foo {
- public:
-  MockFoo() {
-    // By default, all calls are delegated to the real object.
-    ON_CALL(*this, DoThis())
-        .WillByDefault(Invoke(&real_, &Foo::DoThis));
-    ON_CALL(*this, DoThat(_))
-        .WillByDefault(Invoke(&real_, &Foo::DoThat));
-    ...
-  }
-  MOCK_METHOD0(DoThis, ...);
-  MOCK_METHOD1(DoThat, ...);
-  ...
- private:
-  Foo real_;
-};
-...
-
-  MockFoo mock;
-
-  EXPECT_CALL(mock, DoThis())
-      .Times(3);
-  EXPECT_CALL(mock, DoThat("Hi"))
-      .Times(AtLeast(1));
-  ... use mock in test ...
-```
-
-With this, Google Mock will verify that your code made the right calls
-(with the right arguments, in the right order, called the right number
-of times, etc), and a real object will answer the calls (so the
-behavior will be the same as in production). This gives you the best
-of both worlds.
-
-## Delegating Calls to a Parent Class ##
-
-Ideally, you should code to interfaces, whose methods are all pure
-virtual. In reality, sometimes you do need to mock a virtual method
-that is not pure (i.e, it already has an implementation). For example:
-
-```
-class Foo {
- public:
-  virtual ~Foo();
-
-  virtual void Pure(int n) = 0;
-  virtual int Concrete(const char* str) { ... }
-};
-
-class MockFoo : public Foo {
- public:
-  // Mocking a pure method.
-  MOCK_METHOD1(Pure, void(int n));
-  // Mocking a concrete method.  Foo::Concrete() is shadowed.
-  MOCK_METHOD1(Concrete, int(const char* str));
-};
-```
-
-Sometimes you may want to call `Foo::Concrete()` instead of
-`MockFoo::Concrete()`. Perhaps you want to do it as part of a stub
-action, or perhaps your test doesn't need to mock `Concrete()` at all
-(but it would be oh-so painful to have to define a new mock class
-whenever you don't need to mock one of its methods).
-
-The trick is to leave a back door in your mock class for accessing the
-real methods in the base class:
-
-```
-class MockFoo : public Foo {
- public:
-  // Mocking a pure method.
-  MOCK_METHOD1(Pure, void(int n));
-  // Mocking a concrete method.  Foo::Concrete() is shadowed.
-  MOCK_METHOD1(Concrete, int(const char* str));
-
-  // Use this to call Concrete() defined in Foo.
-  int FooConcrete(const char* str) { return Foo::Concrete(str); }
-};
-```
-
-Now, you can call `Foo::Concrete()` inside an action by:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-...
-  EXPECT_CALL(foo, Concrete(_))
-      .WillOnce(Invoke(&foo, &MockFoo::FooConcrete));
-```
-
-or tell the mock object that you don't want to mock `Concrete()`:
-
-```
-using ::testing::Invoke;
-...
-  ON_CALL(foo, Concrete(_))
-      .WillByDefault(Invoke(&foo, &MockFoo::FooConcrete));
-```
-
-(Why don't we just write `Invoke(&foo, &Foo::Concrete)`? If you do
-that, `MockFoo::Concrete()` will be called (and cause an infinite
-recursion) since `Foo::Concrete()` is virtual. That's just how C++
-works.)
-
-# Using Matchers #
-
-## Matching Argument Values Exactly ##
-
-You can specify exactly which arguments a mock method is expecting:
-
-```
-using ::testing::Return;
-...
-  EXPECT_CALL(foo, DoThis(5))
-      .WillOnce(Return('a'));
-  EXPECT_CALL(foo, DoThat("Hello", bar));
-```
-
-## Using Simple Matchers ##
-
-You can use matchers to match arguments that have a certain property:
-
-```
-using ::testing::Ge;
-using ::testing::NotNull;
-using ::testing::Return;
-...
-  EXPECT_CALL(foo, DoThis(Ge(5)))  // The argument must be >= 5.
-      .WillOnce(Return('a'));
-  EXPECT_CALL(foo, DoThat("Hello", NotNull()));
-  // The second argument must not be NULL.
-```
-
-A frequently used matcher is `_`, which matches anything:
-
-```
-using ::testing::_;
-using ::testing::NotNull;
-...
-  EXPECT_CALL(foo, DoThat(_, NotNull()));
-```
-
-## Combining Matchers ##
-
-You can build complex matchers from existing ones using `AllOf()`,
-`AnyOf()`, and `Not()`:
-
-```
-using ::testing::AllOf;
-using ::testing::Gt;
-using ::testing::HasSubstr;
-using ::testing::Ne;
-using ::testing::Not;
-...
-  // The argument must be > 5 and != 10.
-  EXPECT_CALL(foo, DoThis(AllOf(Gt(5),
-                                Ne(10))));
-
-  // The first argument must not contain sub-string "blah".
-  EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")),
-                          NULL));
-```
-
-## Casting Matchers ##
-
-Google Mock matchers are statically typed, meaning that the compiler
-can catch your mistake if you use a matcher of the wrong type (for
-example, if you use `Eq(5)` to match a `string` argument). Good for
-you!
-
-Sometimes, however, you know what you're doing and want the compiler
-to give you some slack. One example is that you have a matcher for
-`long` and the argument you want to match is `int`. While the two
-types aren't exactly the same, there is nothing really wrong with
-using a `Matcher<long>` to match an `int` - after all, we can first
-convert the `int` argument to a `long` before giving it to the
-matcher.
-
-To support this need, Google Mock gives you the
-`SafeMatcherCast<T>(m)` function. It casts a matcher `m` to type
-`Matcher<T>`. To ensure safety, Google Mock checks that (let `U` be the
-type `m` accepts):
-
-  1. Type `T` can be implicitly cast to type `U`;
-  1. When both `T` and `U` are built-in arithmetic types (`bool`, integers, and floating-point numbers), the conversion from `T` to `U` is not lossy (in other words, any value representable by `T` can also be represented by `U`); and
-  1. When `U` is a reference, `T` must also be a reference (as the underlying matcher may be interested in the address of the `U` value).
-
-The code won't compile if any of these conditions isn't met.
-
-Here's one example:
-
-```
-using ::testing::SafeMatcherCast;
-
-// A base class and a child class.
-class Base { ... };
-class Derived : public Base { ... };
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(DoThis, void(Derived* derived));
-};
-...
-
-  MockFoo foo;
-  // m is a Matcher<Base*> we got from somewhere.
-  EXPECT_CALL(foo, DoThis(SafeMatcherCast<Derived*>(m)));
-```
-
-If you find `SafeMatcherCast<T>(m)` too limiting, you can use a similar
-function `MatcherCast<T>(m)`. The difference is that `MatcherCast` works
-as long as you can `static_cast` type `T` to type `U`.
-
-`MatcherCast` essentially lets you bypass C++'s type system
-(`static_cast` isn't always safe as it could throw away information,
-for example), so be careful not to misuse/abuse it.
-
-## Selecting Between Overloaded Functions ##
-
-If you expect an overloaded function to be called, the compiler may
-need some help on which overloaded version it is.
-
-To disambiguate functions overloaded on the const-ness of this object,
-use the `Const()` argument wrapper.
-
-```
-using ::testing::ReturnRef;
-
-class MockFoo : public Foo {
-  ...
-  MOCK_METHOD0(GetBar, Bar&());
-  MOCK_CONST_METHOD0(GetBar, const Bar&());
-};
-...
-
-  MockFoo foo;
-  Bar bar1, bar2;
-  EXPECT_CALL(foo, GetBar())         // The non-const GetBar().
-      .WillOnce(ReturnRef(bar1));
-  EXPECT_CALL(Const(foo), GetBar())  // The const GetBar().
-      .WillOnce(ReturnRef(bar2));
-```
-
-(`Const()` is defined by Google Mock and returns a `const` reference
-to its argument.)
-
-To disambiguate overloaded functions with the same number of arguments
-but different argument types, you may need to specify the exact type
-of a matcher, either by wrapping your matcher in `Matcher<type>()`, or
-using a matcher whose type is fixed (`TypedEq<type>`, `An<type>()`,
-etc):
-
-```
-using ::testing::An;
-using ::testing::Lt;
-using ::testing::Matcher;
-using ::testing::TypedEq;
-
-class MockPrinter : public Printer {
- public:
-  MOCK_METHOD1(Print, void(int n));
-  MOCK_METHOD1(Print, void(char c));
-};
-
-TEST(PrinterTest, Print) {
-  MockPrinter printer;
-
-  EXPECT_CALL(printer, Print(An<int>()));            // void Print(int);
-  EXPECT_CALL(printer, Print(Matcher<int>(Lt(5))));  // void Print(int);
-  EXPECT_CALL(printer, Print(TypedEq<char>('a')));   // void Print(char);
-
-  printer.Print(3);
-  printer.Print(6);
-  printer.Print('a');
-}
-```
-
-## Performing Different Actions Based on the Arguments ##
-
-When a mock method is called, the _last_ matching expectation that's
-still active will be selected (think "newer overrides older"). So, you
-can make a method do different things depending on its argument values
-like this:
-
-```
-using ::testing::_;
-using ::testing::Lt;
-using ::testing::Return;
-...
-  // The default case.
-  EXPECT_CALL(foo, DoThis(_))
-      .WillRepeatedly(Return('b'));
-
-  // The more specific case.
-  EXPECT_CALL(foo, DoThis(Lt(5)))
-      .WillRepeatedly(Return('a'));
-```
-
-Now, if `foo.DoThis()` is called with a value less than 5, `'a'` will
-be returned; otherwise `'b'` will be returned.
-
-## Matching Multiple Arguments as a Whole ##
-
-Sometimes it's not enough to match the arguments individually. For
-example, we may want to say that the first argument must be less than
-the second argument. The `With()` clause allows us to match
-all arguments of a mock function as a whole. For example,
-
-```
-using ::testing::_;
-using ::testing::Lt;
-using ::testing::Ne;
-...
-  EXPECT_CALL(foo, InRange(Ne(0), _))
-      .With(Lt());
-```
-
-says that the first argument of `InRange()` must not be 0, and must be
-less than the second argument.
-
-The expression inside `With()` must be a matcher of type
-`Matcher<tr1::tuple<A1, ..., An> >`, where `A1`, ..., `An` are the
-types of the function arguments.
-
-You can also write `AllArgs(m)` instead of `m` inside `.With()`. The
-two forms are equivalent, but `.With(AllArgs(Lt()))` is more readable
-than `.With(Lt())`.
-
-You can use `Args<k1, ..., kn>(m)` to match the `n` selected arguments
-against `m`. For example,
-
-```
-using ::testing::_;
-using ::testing::AllOf;
-using ::testing::Args;
-using ::testing::Lt;
-...
-  EXPECT_CALL(foo, Blah(_, _, _))
-      .With(AllOf(Args<0, 1>(Lt()), Args<1, 2>(Lt())));
-```
-
-says that `Blah()` will be called with arguments `x`, `y`, and `z` where
-`x < y < z`.
-
-As a convenience and example, Google Mock provides some matchers for
-2-tuples, including the `Lt()` matcher above. See the [CheatSheet](V1_5_CheatSheet.md) for
-the complete list.
-
-## Using Matchers as Predicates ##
-
-Have you noticed that a matcher is just a fancy predicate that also
-knows how to describe itself? Many existing algorithms take predicates
-as arguments (e.g. those defined in STL's `<algorithm>` header), and
-it would be a shame if Google Mock matchers are not allowed to
-participate.
-
-Luckily, you can use a matcher where a unary predicate functor is
-expected by wrapping it inside the `Matches()` function. For example,
-
-```
-#include <algorithm>
-#include <vector>
-
-std::vector<int> v;
-...
-// How many elements in v are >= 10?
-const int count = count_if(v.begin(), v.end(), Matches(Ge(10)));
-```
-
-Since you can build complex matchers from simpler ones easily using
-Google Mock, this gives you a way to conveniently construct composite
-predicates (doing the same using STL's `<functional>` header is just
-painful). For example, here's a predicate that's satisfied by any
-number that is >= 0, <= 100, and != 50:
-
-```
-Matches(AllOf(Ge(0), Le(100), Ne(50)))
-```
-
-## Using Matchers in Google Test Assertions ##
-
-Since matchers are basically predicates that also know how to describe
-themselves, there is a way to take advantage of them in
-[Google Test](http://code.google.com/p/googletest/) assertions. It's
-called `ASSERT_THAT` and `EXPECT_THAT`:
-
-```
-  ASSERT_THAT(value, matcher);  // Asserts that value matches matcher.
-  EXPECT_THAT(value, matcher);  // The non-fatal version.
-```
-
-For example, in a Google Test test you can write:
-
-```
-#include <gmock/gmock.h>
-
-using ::testing::AllOf;
-using ::testing::Ge;
-using ::testing::Le;
-using ::testing::MatchesRegex;
-using ::testing::StartsWith;
-...
-
-  EXPECT_THAT(Foo(), StartsWith("Hello"));
-  EXPECT_THAT(Bar(), MatchesRegex("Line \\d+"));
-  ASSERT_THAT(Baz(), AllOf(Ge(5), Le(10)));
-```
-
-which (as you can probably guess) executes `Foo()`, `Bar()`, and
-`Baz()`, and verifies that:
-
-  * `Foo()` returns a string that starts with `"Hello"`.
-  * `Bar()` returns a string that matches regular expression `"Line \\d+"`.
-  * `Baz()` returns a number in the range [5, 10].
-
-The nice thing about these macros is that _they read like
-English_. They generate informative messages too. For example, if the
-first `EXPECT_THAT()` above fails, the message will be something like:
-
-```
-Value of: Foo()
-  Actual: "Hi, world!"
-Expected: starts with "Hello"
-```
-
-**Credit:** The idea of `(ASSERT|EXPECT)_THAT` was stolen from the
-[Hamcrest](http://code.google.com/p/hamcrest/) project, which adds
-`assertThat()` to JUnit.
-
-## Using Predicates as Matchers ##
-
-Google Mock provides a built-in set of matchers. In case you find them
-lacking, you can use an arbitray unary predicate function or functor
-as a matcher - as long as the predicate accepts a value of the type
-you want. You do this by wrapping the predicate inside the `Truly()`
-function, for example:
-
-```
-using ::testing::Truly;
-
-int IsEven(int n) { return (n % 2) == 0 ? 1 : 0; }
-...
-
-  // Bar() must be called with an even number.
-  EXPECT_CALL(foo, Bar(Truly(IsEven)));
-```
-
-Note that the predicate function / functor doesn't have to return
-`bool`. It works as long as the return value can be used as the
-condition in statement `if (condition) ...`.
-
-## Matching Arguments that Are Not Copyable ##
-
-When you do an `EXPECT_CALL(mock_obj, Foo(bar))`, Google Mock saves
-away a copy of `bar`. When `Foo()` is called later, Google Mock
-compares the argument to `Foo()` with the saved copy of `bar`. This
-way, you don't need to worry about `bar` being modified or destroyed
-after the `EXPECT_CALL()` is executed. The same is true when you use
-matchers like `Eq(bar)`, `Le(bar)`, and so on.
-
-But what if `bar` cannot be copied (i.e. has no copy constructor)? You
-could define your own matcher function and use it with `Truly()`, as
-the previous couple of recipes have shown. Or, you may be able to get
-away from it if you can guarantee that `bar` won't be changed after
-the `EXPECT_CALL()` is executed. Just tell Google Mock that it should
-save a reference to `bar`, instead of a copy of it. Here's how:
-
-```
-using ::testing::Eq;
-using ::testing::ByRef;
-using ::testing::Lt;
-...
-  // Expects that Foo()'s argument == bar.
-  EXPECT_CALL(mock_obj, Foo(Eq(ByRef(bar))));
-
-  // Expects that Foo()'s argument < bar.
-  EXPECT_CALL(mock_obj, Foo(Lt(ByRef(bar))));
-```
-
-Remember: if you do this, don't change `bar` after the
-`EXPECT_CALL()`, or the result is undefined.
-
-## Validating a Member of an Object ##
-
-Often a mock function takes a reference to object as an argument. When
-matching the argument, you may not want to compare the entire object
-against a fixed object, as that may be over-specification. Instead,
-you may need to validate a certain member variable or the result of a
-certain getter method of the object. You can do this with `Field()`
-and `Property()`. More specifically,
-
-```
-Field(&Foo::bar, m)
-```
-
-is a matcher that matches a `Foo` object whose `bar` member variable
-satisfies matcher `m`.
-
-```
-Property(&Foo::baz, m)
-```
-
-is a matcher that matches a `Foo` object whose `baz()` method returns
-a value that satisfies matcher `m`.
-
-For example:
-
-> | `Field(&Foo::number, Ge(3))` | Matches `x` where `x.number >= 3`. |
-|:-----------------------------|:-----------------------------------|
-> | `Property(&Foo::name, StartsWith("John "))` | Matches `x` where `x.name()` starts with `"John "`. |
-
-Note that in `Property(&Foo::baz, ...)`, method `baz()` must take no
-argument and be declared as `const`.
-
-BTW, `Field()` and `Property()` can also match plain pointers to
-objects. For instance,
-
-```
-Field(&Foo::number, Ge(3))
-```
-
-matches a plain pointer `p` where `p->number >= 3`. If `p` is `NULL`,
-the match will always fail regardless of the inner matcher.
-
-What if you want to validate more than one members at the same time?
-Remember that there is `AllOf()`.
-
-## Validating the Value Pointed to by a Pointer Argument ##
-
-C++ functions often take pointers as arguments. You can use matchers
-like `NULL`, `NotNull()`, and other comparison matchers to match a
-pointer, but what if you want to make sure the value _pointed to_ by
-the pointer, instead of the pointer itself, has a certain property?
-Well, you can use the `Pointee(m)` matcher.
-
-`Pointee(m)` matches a pointer iff `m` matches the value the pointer
-points to. For example:
-
-```
-using ::testing::Ge;
-using ::testing::Pointee;
-...
-  EXPECT_CALL(foo, Bar(Pointee(Ge(3))));
-```
-
-expects `foo.Bar()` to be called with a pointer that points to a value
-greater than or equal to 3.
-
-One nice thing about `Pointee()` is that it treats a `NULL` pointer as
-a match failure, so you can write `Pointee(m)` instead of
-
-```
-  AllOf(NotNull(), Pointee(m))
-```
-
-without worrying that a `NULL` pointer will crash your test.
-
-Also, did we tell you that `Pointee()` works with both raw pointers
-**and** smart pointers (`linked_ptr`, `shared_ptr`, `scoped_ptr`, and
-etc)?
-
-What if you have a pointer to pointer? You guessed it - you can use
-nested `Pointee()` to probe deeper inside the value. For example,
-`Pointee(Pointee(Lt(3)))` matches a pointer that points to a pointer
-that points to a number less than 3 (what a mouthful...).
-
-## Testing a Certain Property of an Object ##
-
-Sometimes you want to specify that an object argument has a certain
-property, but there is no existing matcher that does this. If you want
-good error messages, you should define a matcher. If you want to do it
-quick and dirty, you could get away with writing an ordinary function.
-
-Let's say you have a mock function that takes an object of type `Foo`,
-which has an `int bar()` method and an `int baz()` method, and you
-want to constrain that the argument's `bar()` value plus its `baz()`
-value is a given number. Here's how you can define a matcher to do it:
-
-```
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-
-class BarPlusBazEqMatcher : public MatcherInterface<const Foo&> {
- public:
-  explicit BarPlusBazEqMatcher(int expected_sum)
-      : expected_sum_(expected_sum) {}
-
-  virtual bool MatchAndExplain(const Foo& foo,
-                               MatchResultListener* listener) const {
-    return (foo.bar() + foo.baz()) == expected_sum_;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "bar() + baz() equals " << expected_sum_;
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "bar() + baz() does not equal " << expected_sum_;
-  }
- private:
-  const int expected_sum_;
-};
-
-inline Matcher<const Foo&> BarPlusBazEq(int expected_sum) {
-  return MakeMatcher(new BarPlusBazEqMatcher(expected_sum));
-}
-
-...
-
-  EXPECT_CALL(..., DoThis(BarPlusBazEq(5)))...;
-```
-
-## Matching Containers ##
-
-Sometimes an STL container (e.g. list, vector, map, ...) is passed to
-a mock function and you may want to validate it. Since most STL
-containers support the `==` operator, you can write
-`Eq(expected_container)` or simply `expected_container` to match a
-container exactly.
-
-Sometimes, though, you may want to be more flexible (for example, the
-first element must be an exact match, but the second element can be
-any positive number, and so on). Also, containers used in tests often
-have a small number of elements, and having to define the expected
-container out-of-line is a bit of a hassle.
-
-You can use the `ElementsAre()` matcher in such cases:
-
-```
-using ::testing::_;
-using ::testing::ElementsAre;
-using ::testing::Gt;
-...
-
-  MOCK_METHOD1(Foo, void(const vector<int>& numbers));
-...
-
-  EXPECT_CALL(mock, Foo(ElementsAre(1, Gt(0), _, 5)));
-```
-
-The above matcher says that the container must have 4 elements, which
-must be 1, greater than 0, anything, and 5 respectively.
-
-`ElementsAre()` is overloaded to take 0 to 10 arguments. If more are
-needed, you can place them in a C-style array and use
-`ElementsAreArray()` instead:
-
-```
-using ::testing::ElementsAreArray;
-...
-
-  // ElementsAreArray accepts an array of element values.
-  const int expected_vector1[] = { 1, 5, 2, 4, ... };
-  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector1)));
-
-  // Or, an array of element matchers.
-  Matcher<int> expected_vector2 = { 1, Gt(2), _, 3, ... };
-  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector2)));
-```
-
-In case the array needs to be dynamically created (and therefore the
-array size cannot be inferred by the compiler), you can give
-`ElementsAreArray()` an additional argument to specify the array size:
-
-```
-using ::testing::ElementsAreArray;
-...
-  int* const expected_vector3 = new int[count];
-  ... fill expected_vector3 with values ...
-  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector3, count)));
-```
-
-**Tips:**
-
-  * `ElementAre*()` works with _any_ container that implements the STL iterator concept (i.e. it has a `const_iterator` type and supports `begin()/end()`) and supports `size()`, not just the ones defined in STL. It will even work with container types yet to be written - as long as they follows the above pattern.
-  * You can use nested `ElementAre*()` to match nested (multi-dimensional) containers.
-  * If the container is passed by pointer instead of by reference, just write `Pointee(ElementsAre*(...))`.
-  * The order of elements _matters_ for `ElementsAre*()`. Therefore don't use it with containers whose element order is undefined (e.g. `hash_map`).
-
-## Sharing Matchers ##
-
-Under the hood, a Google Mock matcher object consists of a pointer to
-a ref-counted implementation object. Copying matchers is allowed and
-very efficient, as only the pointer is copied. When the last matcher
-that references the implementation object dies, the implementation
-object will be deleted.
-
-Therefore, if you have some complex matcher that you want to use again
-and again, there is no need to build it everytime. Just assign it to a
-matcher variable and use that variable repeatedly! For example,
-
-```
-  Matcher<int> in_range = AllOf(Gt(5), Le(10));
-  ... use in_range as a matcher in multiple EXPECT_CALLs ...
-```
-
-# Setting Expectations #
-
-## Ignoring Uninteresting Calls ##
-
-If you are not interested in how a mock method is called, just don't
-say anything about it. In this case, if the method is ever called,
-Google Mock will perform its default action to allow the test program
-to continue. If you are not happy with the default action taken by
-Google Mock, you can override it using `DefaultValue<T>::Set()`
-(described later in this document) or `ON_CALL()`.
-
-Please note that once you expressed interest in a particular mock
-method (via `EXPECT_CALL()`), all invocations to it must match some
-expectation. If this function is called but the arguments don't match
-any `EXPECT_CALL()` statement, it will be an error.
-
-## Disallowing Unexpected Calls ##
-
-If a mock method shouldn't be called at all, explicitly say so:
-
-```
-using ::testing::_;
-...
-  EXPECT_CALL(foo, Bar(_))
-      .Times(0);
-```
-
-If some calls to the method are allowed, but the rest are not, just
-list all the expected calls:
-
-```
-using ::testing::AnyNumber;
-using ::testing::Gt;
-...
-  EXPECT_CALL(foo, Bar(5));
-  EXPECT_CALL(foo, Bar(Gt(10)))
-      .Times(AnyNumber());
-```
-
-A call to `foo.Bar()` that doesn't match any of the `EXPECT_CALL()`
-statements will be an error.
-
-## Expecting Ordered Calls ##
-
-Although an `EXPECT_CALL()` statement defined earlier takes precedence
-when Google Mock tries to match a function call with an expectation,
-by default calls don't have to happen in the order `EXPECT_CALL()`
-statements are written. For example, if the arguments match the
-matchers in the third `EXPECT_CALL()`, but not those in the first two,
-then the third expectation will be used.
-
-If you would rather have all calls occur in the order of the
-expectations, put the `EXPECT_CALL()` statements in a block where you
-define a variable of type `InSequence`:
-
-```
-  using ::testing::_;
-  using ::testing::InSequence;
-
-  {
-    InSequence s;
-
-    EXPECT_CALL(foo, DoThis(5));
-    EXPECT_CALL(bar, DoThat(_))
-        .Times(2);
-    EXPECT_CALL(foo, DoThis(6));
-  }
-```
-
-In this example, we expect a call to `foo.DoThis(5)`, followed by two
-calls to `bar.DoThat()` where the argument can be anything, which are
-in turn followed by a call to `foo.DoThis(6)`. If a call occurred
-out-of-order, Google Mock will report an error.
-
-## Expecting Partially Ordered Calls ##
-
-Sometimes requiring everything to occur in a predetermined order can
-lead to brittle tests. For example, we may care about `A` occurring
-before both `B` and `C`, but aren't interested in the relative order
-of `B` and `C`. In this case, the test should reflect our real intent,
-instead of being overly constraining.
-
-Google Mock allows you to impose an arbitrary DAG (directed acyclic
-graph) on the calls. One way to express the DAG is to use the
-[After](V1_5_CheatSheet#The_After_Clause.md) clause of `EXPECT_CALL`.
-
-Another way is via the `InSequence()` clause (not the same as the
-`InSequence` class), which we borrowed from jMock 2. It's less
-flexible than `After()`, but more convenient when you have long chains
-of sequential calls, as it doesn't require you to come up with
-different names for the expectations in the chains.  Here's how it
-works:
-
-If we view `EXPECT_CALL()` statements as nodes in a graph, and add an
-edge from node A to node B wherever A must occur before B, we can get
-a DAG. We use the term "sequence" to mean a directed path in this
-DAG. Now, if we decompose the DAG into sequences, we just need to know
-which sequences each `EXPECT_CALL()` belongs to in order to be able to
-reconstruct the orginal DAG.
-
-So, to specify the partial order on the expectations we need to do two
-things: first to define some `Sequence` objects, and then for each
-`EXPECT_CALL()` say which `Sequence` objects it is part
-of. Expectations in the same sequence must occur in the order they are
-written. For example,
-
-```
-  using ::testing::Sequence;
-
-  Sequence s1, s2;
-
-  EXPECT_CALL(foo, A())
-      .InSequence(s1, s2);
-  EXPECT_CALL(bar, B())
-      .InSequence(s1);
-  EXPECT_CALL(bar, C())
-      .InSequence(s2);
-  EXPECT_CALL(foo, D())
-      .InSequence(s2);
-```
-
-specifies the following DAG (where `s1` is `A -> B`, and `s2` is `A ->
-C -> D`):
-
-```
-       +---> B
-       |
-  A ---|
-       |
-       +---> C ---> D
-```
-
-This means that A must occur before B and C, and C must occur before
-D. There's no restriction about the order other than these.
-
-## Controlling When an Expectation Retires ##
-
-When a mock method is called, Google Mock only consider expectations
-that are still active. An expectation is active when created, and
-becomes inactive (aka _retires_) when a call that has to occur later
-has occurred. For example, in
-
-```
-  using ::testing::_;
-  using ::testing::Sequence;
-
-  Sequence s1, s2;
-
-  EXPECT_CALL(log, Log(WARNING, _, "File too large."))     // #1
-      .Times(AnyNumber())
-      .InSequence(s1, s2);
-  EXPECT_CALL(log, Log(WARNING, _, "Data set is empty."))  // #2
-      .InSequence(s1);
-  EXPECT_CALL(log, Log(WARNING, _, "User not found."))     // #3
-      .InSequence(s2);
-```
-
-as soon as either #2 or #3 is matched, #1 will retire. If a warning
-`"File too large."` is logged after this, it will be an error.
-
-Note that an expectation doesn't retire automatically when it's
-saturated. For example,
-
-```
-using ::testing::_;
-...
-  EXPECT_CALL(log, Log(WARNING, _, _));                  // #1
-  EXPECT_CALL(log, Log(WARNING, _, "File too large."));  // #2
-```
-
-says that there will be exactly one warning with the message `"File
-too large."`. If the second warning contains this message too, #2 will
-match again and result in an upper-bound-violated error.
-
-If this is not what you want, you can ask an expectation to retire as
-soon as it becomes saturated:
-
-```
-using ::testing::_;
-...
-  EXPECT_CALL(log, Log(WARNING, _, _));                 // #1
-  EXPECT_CALL(log, Log(WARNING, _, "File too large."))  // #2
-      .RetiresOnSaturation();
-```
-
-Here #2 can be used only once, so if you have two warnings with the
-message `"File too large."`, the first will match #2 and the second
-will match #1 - there will be no error.
-
-# Using Actions #
-
-## Returning References from Mock Methods ##
-
-If a mock function's return type is a reference, you need to use
-`ReturnRef()` instead of `Return()` to return a result:
-
-```
-using ::testing::ReturnRef;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD0(GetBar, Bar&());
-};
-...
-
-  MockFoo foo;
-  Bar bar;
-  EXPECT_CALL(foo, GetBar())
-      .WillOnce(ReturnRef(bar));
-```
-
-## Combining Actions ##
-
-Want to do more than one thing when a function is called? That's
-fine. `DoAll()` allow you to do sequence of actions every time. Only
-the return value of the last action in the sequence will be used.
-
-```
-using ::testing::DoAll;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(Bar, bool(int n));
-};
-...
-
-  EXPECT_CALL(foo, Bar(_))
-      .WillOnce(DoAll(action_1,
-                      action_2,
-                      ...
-                      action_n));
-```
-
-## Mocking Side Effects ##
-
-Sometimes a method exhibits its effect not via returning a value but
-via side effects. For example, it may change some global state or
-modify an output argument. To mock side effects, in general you can
-define your own action by implementing `::testing::ActionInterface`.
-
-If all you need to do is to change an output argument, the built-in
-`SetArgumentPointee()` action is convenient:
-
-```
-using ::testing::SetArgumentPointee;
-
-class MockMutator : public Mutator {
- public:
-  MOCK_METHOD2(Mutate, void(bool mutate, int* value));
-  ...
-};
-...
-
-  MockMutator mutator;
-  EXPECT_CALL(mutator, Mutate(true, _))
-      .WillOnce(SetArgumentPointee<1>(5));
-```
-
-In this example, when `mutator.Mutate()` is called, we will assign 5
-to the `int` variable pointed to by argument #1
-(0-based).
-
-`SetArgumentPointee()` conveniently makes an internal copy of the
-value you pass to it, removing the need to keep the value in scope and
-alive. The implication however is that the value must have a copy
-constructor and assignment operator.
-
-If the mock method also needs to return a value as well, you can chain
-`SetArgumentPointee()` with `Return()` using `DoAll()`:
-
-```
-using ::testing::_;
-using ::testing::Return;
-using ::testing::SetArgumentPointee;
-
-class MockMutator : public Mutator {
- public:
-  ...
-  MOCK_METHOD1(MutateInt, bool(int* value));
-};
-...
-
-  MockMutator mutator;
-  EXPECT_CALL(mutator, MutateInt(_))
-      .WillOnce(DoAll(SetArgumentPointee<0>(5),
-                      Return(true)));
-```
-
-If the output argument is an array, use the
-`SetArrayArgument<N>(first, last)` action instead. It copies the
-elements in source range `[first, last)` to the array pointed to by
-the `N`-th (0-based) argument:
-
-```
-using ::testing::NotNull;
-using ::testing::SetArrayArgument;
-
-class MockArrayMutator : public ArrayMutator {
- public:
-  MOCK_METHOD2(Mutate, void(int* values, int num_values));
-  ...
-};
-...
-
-  MockArrayMutator mutator;
-  int values[5] = { 1, 2, 3, 4, 5 };
-  EXPECT_CALL(mutator, Mutate(NotNull(), 5))
-      .WillOnce(SetArrayArgument<0>(values, values + 5));
-```
-
-This also works when the argument is an output iterator:
-
-```
-using ::testing::_;
-using ::testing::SeArrayArgument;
-
-class MockRolodex : public Rolodex {
- public:
-  MOCK_METHOD1(GetNames, void(std::back_insert_iterator<vector<string> >));
-  ...
-};
-...
-
-  MockRolodex rolodex;
-  vector<string> names;
-  names.push_back("George");
-  names.push_back("John");
-  names.push_back("Thomas");
-  EXPECT_CALL(rolodex, GetNames(_))
-      .WillOnce(SetArrayArgument<0>(names.begin(), names.end()));
-```
-
-## Changing a Mock Object's Behavior Based on the State ##
-
-If you expect a call to change the behavior of a mock object, you can use `::testing::InSequence` to specify different behaviors before and after the call:
-
-```
-using ::testing::InSequence;
-using ::testing::Return;
-
-...
-  {
-    InSequence seq;
-    EXPECT_CALL(my_mock, IsDirty())
-        .WillRepeatedly(Return(true));
-    EXPECT_CALL(my_mock, Flush());
-    EXPECT_CALL(my_mock, IsDirty())
-        .WillRepeatedly(Return(false));
-  }
-  my_mock.FlushIfDirty();
-```
-
-This makes `my_mock.IsDirty()` return `true` before `my_mock.Flush()` is called and return `false` afterwards.
-
-If the behavior change is more complex, you can store the effects in a variable and make a mock method get its return value from that variable:
-
-```
-using ::testing::_;
-using ::testing::SaveArg;
-using ::testing::Return;
-
-ACTION_P(ReturnPointee, p) { return *p; }
-...
-  int previous_value = 0;
-  EXPECT_CALL(my_mock, GetPrevValue())
-      .WillRepeatedly(ReturnPointee(&previous_value));
-  EXPECT_CALL(my_mock, UpdateValue(_))
-      .WillRepeatedly(SaveArg<0>(&previous_value));
-  my_mock.DoSomethingToUpdateValue();
-```
-
-Here `my_mock.GetPrevValue()` will always return the argument of the last `UpdateValue()` call.
-
-## Setting the Default Value for a Return Type ##
-
-If a mock method's return type is a built-in C++ type or pointer, by
-default it will return 0 when invoked. You only need to specify an
-action if this default value doesn't work for you.
-
-Sometimes, you may want to change this default value, or you may want
-to specify a default value for types Google Mock doesn't know
-about. You can do this using the `::testing::DefaultValue` class
-template:
-
-```
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD0(CalculateBar, Bar());
-};
-...
-
-  Bar default_bar;
-  // Sets the default return value for type Bar.
-  DefaultValue<Bar>::Set(default_bar);
-
-  MockFoo foo;
-
-  // We don't need to specify an action here, as the default
-  // return value works for us.
-  EXPECT_CALL(foo, CalculateBar());
-
-  foo.CalculateBar();  // This should return default_bar.
-
-  // Unsets the default return value.
-  DefaultValue<Bar>::Clear();
-```
-
-Please note that changing the default value for a type can make you
-tests hard to understand. We recommend you to use this feature
-judiciously. For example, you may want to make sure the `Set()` and
-`Clear()` calls are right next to the code that uses your mock.
-
-## Setting the Default Actions for a Mock Method ##
-
-You've learned how to change the default value of a given
-type. However, this may be too coarse for your purpose: perhaps you
-have two mock methods with the same return type and you want them to
-have different behaviors. The `ON_CALL()` macro allows you to
-customize your mock's behavior at the method level:
-
-```
-using ::testing::_;
-using ::testing::AnyNumber;
-using ::testing::Gt;
-using ::testing::Return;
-...
-  ON_CALL(foo, Sign(_))
-      .WillByDefault(Return(-1));
-  ON_CALL(foo, Sign(0))
-      .WillByDefault(Return(0));
-  ON_CALL(foo, Sign(Gt(0)))
-      .WillByDefault(Return(1));
-
-  EXPECT_CALL(foo, Sign(_))
-      .Times(AnyNumber());
-
-  foo.Sign(5);   // This should return 1.
-  foo.Sign(-9);  // This should return -1.
-  foo.Sign(0);   // This should return 0.
-```
-
-As you may have guessed, when there are more than one `ON_CALL()`
-statements, the news order take precedence over the older ones. In
-other words, the **last** one that matches the function arguments will
-be used. This matching order allows you to set up the common behavior
-in a mock object's constructor or the test fixture's set-up phase and
-specialize the mock's behavior later.
-
-## Using Functions/Methods/Functors as Actions ##
-
-If the built-in actions don't suit you, you can easily use an existing
-function, method, or functor as an action:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD2(Sum, int(int x, int y));
-  MOCK_METHOD1(ComplexJob, bool(int x));
-};
-
-int CalculateSum(int x, int y) { return x + y; }
-
-class Helper {
- public:
-  bool ComplexJob(int x);
-};
-...
-
-  MockFoo foo;
-  Helper helper;
-  EXPECT_CALL(foo, Sum(_, _))
-      .WillOnce(Invoke(CalculateSum));
-  EXPECT_CALL(foo, ComplexJob(_))
-      .WillOnce(Invoke(&helper, &Helper::ComplexJob));
-
-  foo.Sum(5, 6);       // Invokes CalculateSum(5, 6).
-  foo.ComplexJob(10);  // Invokes helper.ComplexJob(10);
-```
-
-The only requirement is that the type of the function, etc must be
-_compatible_ with the signature of the mock function, meaning that the
-latter's arguments can be implicitly converted to the corresponding
-arguments of the former, and the former's return type can be
-implicitly converted to that of the latter. So, you can invoke
-something whose type is _not_ exactly the same as the mock function,
-as long as it's safe to do so - nice, huh?
-
-## Invoking a Function/Method/Functor Without Arguments ##
-
-`Invoke()` is very useful for doing actions that are more complex. It
-passes the mock function's arguments to the function or functor being
-invoked such that the callee has the full context of the call to work
-with. If the invoked function is not interested in some or all of the
-arguments, it can simply ignore them.
-
-Yet, a common pattern is that a test author wants to invoke a function
-without the arguments of the mock function. `Invoke()` allows her to
-do that using a wrapper function that throws away the arguments before
-invoking an underlining nullary function. Needless to say, this can be
-tedious and obscures the intent of the test.
-
-`InvokeWithoutArgs()` solves this problem. It's like `Invoke()` except
-that it doesn't pass the mock function's arguments to the
-callee. Here's an example:
-
-```
-using ::testing::_;
-using ::testing::InvokeWithoutArgs;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(ComplexJob, bool(int n));
-};
-
-bool Job1() { ... }
-...
-
-  MockFoo foo;
-  EXPECT_CALL(foo, ComplexJob(_))
-      .WillOnce(InvokeWithoutArgs(Job1));
-
-  foo.ComplexJob(10);  // Invokes Job1().
-```
-
-## Invoking an Argument of the Mock Function ##
-
-Sometimes a mock function will receive a function pointer or a functor
-(in other words, a "callable") as an argument, e.g.
-
-```
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD2(DoThis, bool(int n, bool (*fp)(int)));
-};
-```
-
-and you may want to invoke this callable argument:
-
-```
-using ::testing::_;
-...
-  MockFoo foo;
-  EXPECT_CALL(foo, DoThis(_, _))
-      .WillOnce(...);
-  // Will execute (*fp)(5), where fp is the
-  // second argument DoThis() receives.
-```
-
-Arghh, you need to refer to a mock function argument but C++ has no
-lambda (yet), so you have to define your own action. :-( Or do you
-really?
-
-Well, Google Mock has an action to solve _exactly_ this problem:
-
-```
-  InvokeArgument<N>(arg_1, arg_2, ..., arg_m)
-```
-
-will invoke the `N`-th (0-based) argument the mock function receives,
-with `arg_1`, `arg_2`, ..., and `arg_m`. No matter if the argument is
-a function pointer or a functor, Google Mock handles them both.
-
-With that, you could write:
-
-```
-using ::testing::_;
-using ::testing::InvokeArgument;
-...
-  EXPECT_CALL(foo, DoThis(_, _))
-      .WillOnce(InvokeArgument<1>(5));
-  // Will execute (*fp)(5), where fp is the
-  // second argument DoThis() receives.
-```
-
-What if the callable takes an argument by reference? No problem - just
-wrap it inside `ByRef()`:
-
-```
-...
-  MOCK_METHOD1(Bar, bool(bool (*fp)(int, const Helper&)));
-...
-using ::testing::_;
-using ::testing::ByRef;
-using ::testing::InvokeArgument;
-...
-
-  MockFoo foo;
-  Helper helper;
-  ...
-  EXPECT_CALL(foo, Bar(_))
-      .WillOnce(InvokeArgument<0>(5, ByRef(helper)));
-  // ByRef(helper) guarantees that a reference to helper, not a copy of it,
-  // will be passed to the callable.
-```
-
-What if the callable takes an argument by reference and we do **not**
-wrap the argument in `ByRef()`? Then `InvokeArgument()` will _make a
-copy_ of the argument, and pass a _reference to the copy_, instead of
-a reference to the original value, to the callable. This is especially
-handy when the argument is a temporary value:
-
-```
-...
-  MOCK_METHOD1(DoThat, bool(bool (*f)(const double& x, const string& s)));
-...
-using ::testing::_;
-using ::testing::InvokeArgument;
-...
-
-  MockFoo foo;
-  ...
-  EXPECT_CALL(foo, DoThat(_))
-      .WillOnce(InvokeArgument<0>(5.0, string("Hi")));
-  // Will execute (*f)(5.0, string("Hi")), where f is the function pointer
-  // DoThat() receives.  Note that the values 5.0 and string("Hi") are
-  // temporary and dead once the EXPECT_CALL() statement finishes.  Yet
-  // it's fine to perform this action later, since a copy of the values
-  // are kept inside the InvokeArgument action.
-```
-
-## Ignoring an Action's Result ##
-
-Sometimes you have an action that returns _something_, but you need an
-action that returns `void` (perhaps you want to use it in a mock
-function that returns `void`, or perhaps it needs to be used in
-`DoAll()` and it's not the last in the list). `IgnoreResult()` lets
-you do that. For example:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::Return;
-
-int Process(const MyData& data);
-string DoSomething();
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(Abc, void(const MyData& data));
-  MOCK_METHOD0(Xyz, bool());
-};
-...
-
-  MockFoo foo;
-  EXPECT_CALL(foo, Abc(_))
-  // .WillOnce(Invoke(Process));
-  // The above line won't compile as Process() returns int but Abc() needs
-  // to return void.
-      .WillOnce(IgnoreResult(Invoke(Process)));
-
-  EXPECT_CALL(foo, Xyz())
-      .WillOnce(DoAll(IgnoreResult(Invoke(DoSomething)),
-      // Ignores the string DoSomething() returns.
-                      Return(true)));
-```
-
-Note that you **cannot** use `IgnoreResult()` on an action that already
-returns `void`. Doing so will lead to ugly compiler errors.
-
-## Selecting an Action's Arguments ##
-
-Say you have a mock function `Foo()` that takes seven arguments, and
-you have a custom action that you want to invoke when `Foo()` is
-called. Trouble is, the custom action only wants three arguments:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-...
-  MOCK_METHOD7(Foo, bool(bool visible, const string& name, int x, int y,
-                         const map<pair<int, int>, double>& weight,
-                         double min_weight, double max_wight));
-...
-
-bool IsVisibleInQuadrant1(bool visible, int x, int y) {
-  return visible && x >= 0 && y >= 0;
-}
-...
-
-  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
-      .WillOnce(Invoke(IsVisibleInQuadrant1));  // Uh, won't compile. :-(
-```
-
-To please the compiler God, you can to define an "adaptor" that has
-the same signature as `Foo()` and calls the custom action with the
-right arguments:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-bool MyIsVisibleInQuadrant1(bool visible, const string& name, int x, int y,
-                            const map<pair<int, int>, double>& weight,
-                            double min_weight, double max_wight) {
-  return IsVisibleInQuadrant1(visible, x, y);
-}
-...
-
-  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
-      .WillOnce(Invoke(MyIsVisibleInQuadrant1));  // Now it works.
-```
-
-But isn't this awkward?
-
-Google Mock provides a generic _action adaptor_, so you can spend your
-time minding more important business than writing your own
-adaptors. Here's the syntax:
-
-```
-  WithArgs<N1, N2, ..., Nk>(action)
-```
-
-creates an action that passes the arguments of the mock function at
-the given indices (0-based) to the inner `action` and performs
-it. Using `WithArgs`, our original example can be written as:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::WithArgs;
-...
-  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
-      .WillOnce(WithArgs<0, 2, 3>(Invoke(IsVisibleInQuadrant1)));
-      // No need to define your own adaptor.
-```
-
-For better readability, Google Mock also gives you:
-
-  * `WithoutArgs(action)` when the inner `action` takes _no_ argument, and
-  * `WithArg<N>(action)` (no `s` after `Arg`) when the inner `action` takes _one_ argument.
-
-As you may have realized, `InvokeWithoutArgs(...)` is just syntactic
-sugar for `WithoutArgs(Inovke(...))`.
-
-Here are more tips:
-
-  * The inner action used in `WithArgs` and friends does not have to be `Invoke()` -- it can be anything.
-  * You can repeat an argument in the argument list if necessary, e.g. `WithArgs<2, 3, 3, 5>(...)`.
-  * You can change the order of the arguments, e.g. `WithArgs<3, 2, 1>(...)`.
-  * The types of the selected arguments do _not_ have to match the signature of the inner action exactly. It works as long as they can be implicitly converted to the corresponding arguments of the inner action. For example, if the 4-th argument of the mock function is an `int` and `my_action` takes a `double`, `WithArg<4>(my_action)` will work.
-
-## Ignoring Arguments in Action Functions ##
-
-The selecting-an-action's-arguments recipe showed us one way to make a
-mock function and an action with incompatible argument lists fit
-together. The downside is that wrapping the action in
-`WithArgs<...>()` can get tedious for people writing the tests.
-
-If you are defining a function, method, or functor to be used with
-`Invoke*()`, and you are not interested in some of its arguments, an
-alternative to `WithArgs` is to declare the uninteresting arguments as
-`Unused`. This makes the definition less cluttered and less fragile in
-case the types of the uninteresting arguments change. It could also
-increase the chance the action function can be reused. For example,
-given
-
-```
-  MOCK_METHOD3(Foo, double(const string& label, double x, double y));
-  MOCK_METHOD3(Bar, double(int index, double x, double y));
-```
-
-instead of
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-double DistanceToOriginWithLabel(const string& label, double x, double y) {
-  return sqrt(x*x + y*y);
-}
-
-double DistanceToOriginWithIndex(int index, double x, double y) {
-  return sqrt(x*x + y*y);
-}
-...
-
-  EXEPCT_CALL(mock, Foo("abc", _, _))
-      .WillOnce(Invoke(DistanceToOriginWithLabel));
-  EXEPCT_CALL(mock, Bar(5, _, _))
-      .WillOnce(Invoke(DistanceToOriginWithIndex));
-```
-
-you could write
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::Unused;
-
-double DistanceToOrigin(Unused, double x, double y) {
-  return sqrt(x*x + y*y);
-}
-...
-
-  EXEPCT_CALL(mock, Foo("abc", _, _))
-      .WillOnce(Invoke(DistanceToOrigin));
-  EXEPCT_CALL(mock, Bar(5, _, _))
-      .WillOnce(Invoke(DistanceToOrigin));
-```
-
-## Sharing Actions ##
-
-Just like matchers, a Google Mock action object consists of a pointer
-to a ref-counted implementation object. Therefore copying actions is
-also allowed and very efficient. When the last action that references
-the implementation object dies, the implementation object will be
-deleted.
-
-If you have some complex action that you want to use again and again,
-you may not have to build it from scratch everytime. If the action
-doesn't have an internal state (i.e. if it always does the same thing
-no matter how many times it has been called), you can assign it to an
-action variable and use that variable repeatedly. For example:
-
-```
-  Action<bool(int*)> set_flag = DoAll(SetArgumentPointee<0>(5),
-                                      Return(true));
-  ... use set_flag in .WillOnce() and .WillRepeatedly() ...
-```
-
-However, if the action has its own state, you may be surprised if you
-share the action object. Suppose you have an action factory
-`IncrementCounter(init)` which creates an action that increments and
-returns a counter whose initial value is `init`, using two actions
-created from the same expression and using a shared action will
-exihibit different behaviors. Example:
-
-```
-  EXPECT_CALL(foo, DoThis())
-      .WillRepeatedly(IncrementCounter(0));
-  EXPECT_CALL(foo, DoThat())
-      .WillRepeatedly(IncrementCounter(0));
-  foo.DoThis();  // Returns 1.
-  foo.DoThis();  // Returns 2.
-  foo.DoThat();  // Returns 1 - Blah() uses a different
-                 // counter than Bar()'s.
-```
-
-versus
-
-```
-  Action<int()> increment = IncrementCounter(0);
-
-  EXPECT_CALL(foo, DoThis())
-      .WillRepeatedly(increment);
-  EXPECT_CALL(foo, DoThat())
-      .WillRepeatedly(increment);
-  foo.DoThis();  // Returns 1.
-  foo.DoThis();  // Returns 2.
-  foo.DoThat();  // Returns 3 - the counter is shared.
-```
-
-# Misc Recipes on Using Google Mock #
-
-## Forcing a Verification ##
-
-When it's being destoyed, your friendly mock object will automatically
-verify that all expectations on it have been satisfied, and will
-generate [Google Test](http://code.google.com/p/googletest/) failures
-if not. This is convenient as it leaves you with one less thing to
-worry about. That is, unless you are not sure if your mock object will
-be destoyed.
-
-How could it be that your mock object won't eventually be destroyed?
-Well, it might be created on the heap and owned by the code you are
-testing. Suppose there's a bug in that code and it doesn't delete the
-mock object properly - you could end up with a passing test when
-there's actually a bug.
-
-Using a heap checker is a good idea and can alleviate the concern, but
-its implementation may not be 100% reliable. So, sometimes you do want
-to _force_ Google Mock to verify a mock object before it is
-(hopefully) destructed. You can do this with
-`Mock::VerifyAndClearExpectations(&mock_object)`:
-
-```
-TEST(MyServerTest, ProcessesRequest) {
-  using ::testing::Mock;
-
-  MockFoo* const foo = new MockFoo;
-  EXPECT_CALL(*foo, ...)...;
-  // ... other expectations ...
-
-  // server now owns foo.
-  MyServer server(foo);
-  server.ProcessRequest(...);
-
-  // In case that server's destructor will forget to delete foo,
-  // this will verify the expectations anyway.
-  Mock::VerifyAndClearExpectations(foo);
-}  // server is destroyed when it goes out of scope here.
-```
-
-**Tip:** The `Mock::VerifyAndClearExpectations()` function returns a
-`bool` to indicate whether the verification was successful (`true` for
-yes), so you can wrap that function call inside a `ASSERT_TRUE()` if
-there is no point going further when the verification has failed.
-
-## Using Check Points ##
-
-Sometimes you may want to "reset" a mock object at various check
-points in your test: at each check point, you verify that all existing
-expectations on the mock object have been satisfied, and then you set
-some new expectations on it as if it's newly created. This allows you
-to work with a mock object in "phases" whose sizes are each
-manageable.
-
-One such scenario is that in your test's `SetUp()` function, you may
-want to put the object you are testing into a certain state, with the
-help from a mock object. Once in the desired state, you want to clear
-all expectations on the mock, such that in the `TEST_F` body you can
-set fresh expectations on it.
-
-As you may have figured out, the `Mock::VerifyAndClearExpectations()`
-function we saw in the previous recipe can help you here. Or, if you
-are using `ON_CALL()` to set default actions on the mock object and
-want to clear the default actions as well, use
-`Mock::VerifyAndClear(&mock_object)` instead. This function does what
-`Mock::VerifyAndClearExpectations(&mock_object)` does and returns the
-same `bool`, **plus** it clears the `ON_CALL()` statements on
-`mock_object` too.
-
-Another trick you can use to achieve the same effect is to put the
-expectations in sequences and insert calls to a dummy "check-point"
-function at specific places. Then you can verify that the mock
-function calls do happen at the right time. 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:
-
-```
-using ::testing::MockFunction;
-
-TEST(FooTest, InvokesBarCorrectly) {
-  MyMock mock;
-  // Class MockFunction<F> has exactly one mock method.  It is named
-  // Call() and has type F.
-  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()`.
-
-## Mocking Destructors ##
-
-Sometimes you want to make sure a mock object is destructed at the
-right time, e.g. after `bar->A()` is called but before `bar->B()` is
-called. We already know that you can specify constraints on the order
-of mock function calls, so all we need to do is to mock the destructor
-of the mock function.
-
-This sounds simple, except for one problem: a destructor is a special
-function with special syntax and special semantics, and the
-`MOCK_METHOD0` macro doesn't work for it:
-
-```
-  MOCK_METHOD0(~MockFoo, void());  // Won't compile!
-```
-
-The good news is that you can use a simple pattern to achieve the same
-effect. First, add a mock function `Die()` to your mock class and call
-it in the destructor, like this:
-
-```
-class MockFoo : public Foo {
-  ...
-  // Add the following two lines to the mock class.
-  MOCK_METHOD0(Die, void());
-  virtual ~MockFoo() { Die(); }
-};
-```
-
-(If the name `Die()` clashes with an existing symbol, choose another
-name.) Now, we have translated the problem of testing when a `MockFoo`
-object dies to testing when its `Die()` method is called:
-
-```
-  MockFoo* foo = new MockFoo;
-  MockBar* bar = new MockBar;
-  ...
-  {
-    InSequence s;
-
-    // Expects *foo to die after bar->A() and before bar->B().
-    EXPECT_CALL(*bar, A());
-    EXPECT_CALL(*foo, Die());
-    EXPECT_CALL(*bar, B());
-  }
-```
-
-And that's that.
-
-## Using Google Mock and Threads ##
-
-**IMPORTANT NOTE:** What we describe in this recipe is **NOT** true yet,
-as Google Mock is not currently thread-safe.  However, all we need to
-make it thread-safe is to implement some synchronization operations in
-`<gtest/internal/gtest-port.h>` - and then the information below will
-become true.
-
-In a **unit** test, it's best if you could isolate and test a piece of
-code in a single-threaded context. That avoids race conditions and
-dead locks, and makes debugging your test much easier.
-
-Yet many programs are multi-threaded, and sometimes to test something
-we need to pound on it from more than one thread. Google Mock works
-for this purpose too.
-
-Remember the steps for using a mock:
-
-  1. Create a mock object `foo`.
-  1. Set its default actions and expectations using `ON_CALL()` and `EXPECT_CALL()`.
-  1. The code under test calls methods of `foo`.
-  1. Optionally, verify and reset the mock.
-  1. Destroy the mock yourself, or let the code under test destroy it. The destructor will automatically verify it.
-
-If you follow the following simple rules, your mocks and threads can
-live happily togeter:
-
-  * Execute your _test code_ (as opposed to the code being tested) in _one_ thread. This makes your test easy to follow.
-  * Obviously, you can do step #1 without locking.
-  * When doing step #2 and #5, make sure no other thread is accessing `foo`. Obvious too, huh?
-  * #3 and #4 can be done either in one thread or in multiple threads - anyway you want. Google Mock takes care of the locking, so you don't have to do any - unless required by your test logic.
-
-If you violate the rules (for example, if you set expectations on a
-mock while another thread is calling its methods), you get undefined
-behavior. That's not fun, so don't do it.
-
-Google Mock guarantees that the action for a mock function is done in
-the same thread that called the mock function. For example, in
-
-```
-  EXPECT_CALL(mock, Foo(1))
-      .WillOnce(action1);
-  EXPECT_CALL(mock, Foo(2))
-      .WillOnce(action2);
-```
-
-if `Foo(1)` is called in thread 1 and `Foo(2)` is called in thread 2,
-Google Mock will execute `action1` in thread 1 and `action2` in thread
-2.
-
-Google Mock does _not_ impose a sequence on actions performed in
-different threads (doing so may create deadlocks as the actions may
-need to cooperate). This means that the execution of `action1` and
-`action2` in the above example _may_ interleave. If this is a problem,
-you should add proper synchronization logic to `action1` and `action2`
-to make the test thread-safe.
-
-
-Also, remember that `DefaultValue<T>` is a global resource that
-potentially affects _all_ living mock objects in your
-program. Naturally, you won't want to mess with it from multiple
-threads or when there still are mocks in action.
-
-## Controlling How Much Information Google Mock Prints ##
-
-When Google Mock sees something that has the potential of being an
-error (e.g. a mock function with no expectation is called, a.k.a. an
-uninteresting call, which is allowed but perhaps you forgot to
-explicitly ban the call), it prints some warning messages, including
-the arguments of the function and the return value. Hopefully this
-will remind you to take a look and see if there is indeed a problem.
-
-Sometimes you are confident that your tests are correct and may not
-appreciate such friendly messages. Some other times, you are debugging
-your tests or learning about the behavior of the code you are testing,
-and wish you could observe every mock call that happens (including
-argument values and the return value). Clearly, one size doesn't fit
-all.
-
-You can control how much Google Mock tells you using the
-`--gmock_verbose=LEVEL` command-line flag, where `LEVEL` is a string
-with three possible values:
-
-  * `info`: Google Mock will print all informational messages, warnings, and errors (most verbose). At this setting, Google Mock will also log any calls to the `ON_CALL/EXPECT_CALL` macros.
-  * `warning`: Google Mock will print both warnings and errors (less verbose). This is the default.
-  * `error`: Google Mock will print errors only (least verbose).
-
-Alternatively, you can adjust the value of that flag from within your
-tests like so:
-
-```
-  ::testing::FLAGS_gmock_verbose = "error";
-```
-
-Now, judiciously use the right flag to enable Google Mock serve you better!
-
-## Running Tests in Emacs ##
-
-If you build and run your tests in Emacs, the source file locations of
-Google Mock and [Google Test](http://code.google.com/p/googletest/)
-errors will be highlighted. Just press `<Enter>` on one of them and
-you'll be taken to the offending line. Or, you can just type `C-x ``
-to jump to the next error.
-
-To make it even easier, you can add the following lines to your
-`~/.emacs` file:
-
-```
-(global-set-key "\M-m"   'compile)  ; m is for make
-(global-set-key [M-down] 'next-error)
-(global-set-key [M-up]   '(lambda () (interactive) (next-error -1)))
-```
-
-Then you can type `M-m` to start a build, or `M-up`/`M-down` to move
-back and forth between errors.
-
-## Fusing Google Mock Source Files ##
-
-Google Mock's implementation consists of dozens of files (excluding
-its own tests).  Sometimes you may want them to be packaged up in
-fewer files instead, such that you can easily copy them to a new
-machine and start hacking there.  For this we provide an experimental
-Python script `fuse_gmock_files.py` in the `scripts/` directory
-(starting with release 1.2.0).  Assuming you have Python 2.4 or above
-installed on your machine, just go to that directory and run
-```
-python fuse_gmock_files.py OUTPUT_DIR
-```
-
-and you should see an `OUTPUT_DIR` directory being created with files
-`gtest/gtest.h`, `gmock/gmock.h`, and `gmock-gtest-all.cc` in it.
-These three files contain everything you need to use Google Mock (and
-Google Test).  Just copy them to anywhere you want and you are ready
-to write tests and use mocks.  You can use the
-[scrpts/test/Makefile](http://code.google.com/p/googlemock/source/browse/trunk/scripts/test/Makefile) file as an example on how to compile your tests
-against them.
-
-# Extending Google Mock #
-
-## Writing New Matchers Quickly ##
-
-The `MATCHER*` family of macros can be used to define custom matchers
-easily.  The syntax:
-
-```
-MATCHER(name, "description string") { statements; }
-```
-
-will define 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
-Google Mock will use the sequence of words in the matcher name as the
-description.
-
-For example:
-```
-MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; }
-```
-allows you to write
-```
-  // Expects mock_foo.Bar(n) to be called where n is divisible by 7.
-  EXPECT_CALL(mock_foo, Bar(IsDivisibleBy7()));
-```
-or,
-```
-  // Verifies that the value of some_expression is divisible by 7.
-  EXPECT_THAT(some_expression, IsDivisibleBy7());
-```
-If the above assertion fails, it will print something like:
-```
-  Value of: some_expression
-  Expected: is divisible by 7
-    Actual: 27
-```
-where the description `"is divisible by 7"` is automatically calculated from the
-matcher name `IsDivisibleBy7`.
-
-Optionally, you can stream additional information to a hidden argument
-named `result_listener` to explain the match result. For example, a
-better definition of `IsDivisibleBy7` is:
-```
-MATCHER(IsDivisibleBy7, "") {
-  if ((arg % 7) == 0)
-    return true;
-
-  *result_listener << "the remainder is " << (arg % 7);
-  return false;
-}
-```
-
-With this definition, the above assertion will give a better message:
-```
-  Value of: some_expression
-  Expected: is divisible by 7
-    Actual: 27 (the remainder is 6)
-```
-
-You should let `MatchAndExplain()` print _any additional information_
-that can help a user understand the match result. Note that it should
-explain why the match succeeds in case of a success (unless it's
-obvious) - this is useful when the matcher is used inside
-`Not()`. There is no need to print the argument value itself, as
-Google Mock already prints it for you.
-
-**Notes:**
-
-  1. 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, `IsDivisibleBy7()` can be used to match any type where the value of `(arg % 7) == 0` can be implicitly converted to a `bool`.  In the `Bar(IsDivisibleBy7())` 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.
-  1. Google Mock doesn't guarantee when or how many times a matcher will be invoked. Therefore the matcher logic must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters). This requirement must be satisfied no matter how you define the matcher (e.g. using one of the methods described in the following recipes). In particular, a matcher can never call a mock function, as that will affect the state of the mock object and Google Mock.
-
-## Writing New Parameterized Matchers Quickly ##
-
-Sometimes you'll want to define a matcher that has parameters.  For that you
-can use the 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`.
-
-Google Mock also provides `MATCHER_P2`, `MATCHER_P3`, ..., up to
-`MATCHER_P10` to support multi-parameter matchers:
-```
-MATCHER_Pk(name, param_1, ..., param_k, "description string") { statements; }
-```
-
-Please note that the custom description string is for a particular
-**instance** of the matcher, where the parameters have been bound to
-actual values.  Therefore usually you'll want the parameter values to
-be part of the description.  Google Mock lets you do that using
-Python-style interpolations.  The following syntaxes are supported
-currently:
-
-| `%%` | a single `%` character |
-|:-----|:-----------------------|
-| `%(*)s` | all parameters of the matcher printed as a tuple |
-| `%(foo)s` | value of the matcher parameter named `foo` |
-
-For example,
-```
-  MATCHER_P2(InClosedRange, low, hi, "is in range [%(low)s, %(hi)s]") {
-    return low <= arg && arg <= hi;
-  }
-  ...
-  EXPECT_THAT(3, InClosedRange(4, 6));
-```
-would generate a failure that contains the message:
-```
-  Expected: is in range [4, 6]
-```
-
-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));
-```
-would generate a failure that contains the text:
-```
-  Expected: in closed range (4, 6)
-```
-
-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.  Matchers that don't have a parameter
-or have only one parameter have special types: you can assign `Foo()`
-to a `FooMatcher`-typed variable, and assign `Foo(p)` to a
-`FooMatcherP<p_type>`-typed variable.
-
-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.
-
-You can overload matchers with different numbers of parameters:
-```
-MATCHER_P(Blah, a, "description string 1") { ... }
-MATCHER_P2(Blah, a, b, "description string 2") { ... }
-```
-
-While it's tempting to always use the `MATCHER*` macros when defining
-a new matcher, you should also consider implementing
-`MatcherInterface` or using `MakePolymorphicMatcher()` instead (see
-the recipes that follow), especially if you need to use the matcher a
-lot.  While these approaches require more work, they give you more
-control on the types of the value being matched and the matcher
-parameters, which in general leads to better compiler error messages
-that pay off in the long run.  They also allow overloading matchers
-based on parameter types (as opposed to just based on the number of
-parameters).
-
-## Writing New Monomorphic Matchers ##
-
-A matcher of argument type `T` implements
-`::testing::MatcherInterface<T>` and does two things: it tests whether a
-value of type `T` matches the matcher, and can describe what kind of
-values it matches. The latter ability is used for generating readable
-error messages when expectations are violated.
-
-The interface looks like this:
-
-```
-class MatchResultListener {
- public:
-  ...
-  // Streams x to the underlying ostream; does nothing if the ostream
-  // is NULL.
-  template <typename T>
-  MatchResultListener& operator<<(const T& x);
-
-  // Returns the underlying ostream.
-  ::std::ostream* stream();
-};
-
-template <typename T>
-class MatcherInterface {
- public:
-  virtual ~MatcherInterface();
-
-  // Returns true iff the matcher matches x; also explains the match
-  // result to 'listener'.
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
-
-  // Describes this matcher to an ostream.
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-
-  // Describes the negation of this matcher to an ostream.
-  virtual void DescribeNegationTo(::std::ostream* os) const;
-};
-```
-
-If you need a custom matcher but `Truly()` is not a good option (for
-example, you may not be happy with the way `Truly(predicate)`
-describes itself, or you may want your matcher to be polymorphic as
-`Eq(value)` is), you can define a matcher to do whatever you want in
-two steps: first implement the matcher interface, and then define a
-factory function to create a matcher instance. The second step is not
-strictly needed but it makes the syntax of using the matcher nicer.
-
-For example, you can define a matcher to test whether an `int` is
-divisible by 7 and then use it like this:
-```
-using ::testing::MakeMatcher;
-using ::testing::Matcher;
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-
-class DivisibleBy7Matcher : public MatcherInterface<int> {
- public:
-  virtual bool MatchAndExplain(int n, MatchResultListener* listener) const {
-    return (n % 7) == 0;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "is divisible by 7";
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is not divisible by 7";
-  }
-};
-
-inline Matcher<int> DivisibleBy7() {
-  return MakeMatcher(new DivisibleBy7Matcher);
-}
-...
-
-  EXPECT_CALL(foo, Bar(DivisibleBy7()));
-```
-
-You may improve the matcher message by streaming additional
-information to the `listener` argument in `MatchAndExplain()`:
-
-```
-class DivisibleBy7Matcher : public MatcherInterface<int> {
- public:
-  virtual bool MatchAndExplain(int n,
-                               MatchResultListener* listener) const {
-    const int remainder = n % 7;
-    if (remainder != 0) {
-      *listener << "the remainder is " << remainder;
-    }
-    return remainder == 0;
-  }
-  ...
-};
-```
-
-Then, `EXPECT_THAT(x, DivisibleBy7());` may general a message like this:
-```
-Value of: x
-Expected: is divisible by 7
-  Actual: 23 (the remainder is 2)
-```
-
-## Writing New Polymorphic Matchers ##
-
-You've learned how to write your own matchers in the previous
-recipe. Just one problem: a matcher created using `MakeMatcher()` only
-works for one particular type of arguments. If you want a
-_polymorphic_ matcher that works with arguments of several types (for
-instance, `Eq(x)` can be used to match a `value` as long as `value` ==
-`x` compiles -- `value` and `x` don't have to share the same type),
-you can learn the trick from `<gmock/gmock-matchers.h>` but it's a bit
-involved.
-
-Fortunately, most of the time you can define a polymorphic matcher
-easily with the help of `MakePolymorphicMatcher()`. Here's how you can
-define `NotNull()` as an example:
-
-```
-using ::testing::MakePolymorphicMatcher;
-using ::testing::MatchResultListener;
-using ::testing::NotNull;
-using ::testing::PolymorphicMatcher;
-
-class NotNullMatcher {
- public:
-  // To implement a polymorphic matcher, first define a COPYABLE class
-  // that has three members MatchAndExplain(), DescribeTo(), and
-  // DescribeNegationTo(), like the following.
-
-  // In this example, we want to use NotNull() with any pointer, so
-  // MatchAndExplain() accepts a pointer of any type as its first argument.
-  // In general, you can define MatchAndExplain() as an ordinary method or
-  // a method template, or even overload it.
-  template <typename T>
-  bool MatchAndExplain(T* p,
-                       MatchResultListener* /* listener */) const {
-    return p != NULL;
-  }
-
-  // Describes the property of a value matching this matcher.
-  void DescribeTo(::std::ostream* os) const { *os << "is not NULL"; }
-
-  // Describes the property of a value NOT matching this matcher.
-  void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
-};
-
-// To construct a polymorphic matcher, pass an instance of the class
-// to MakePolymorphicMatcher().  Note the return type.
-inline PolymorphicMatcher<NotNullMatcher> NotNull() {
-  return MakePolymorphicMatcher(NotNullMatcher());
-}
-...
-
-  EXPECT_CALL(foo, Bar(NotNull()));  // The argument must be a non-NULL pointer.
-```
-
-**Note:** Your polymorphic matcher class does **not** need to inherit from
-`MatcherInterface` or any other class, and its methods do **not** need
-to be virtual.
-
-Like in a monomorphic matcher, you may explain the match result by
-streaming additional information to the `listener` argument in
-`MatchAndExplain()`.
-
-## Writing New Cardinalities ##
-
-A cardinality is used in `Times()` to tell Google Mock how many times
-you expect a call to occur. It doesn't have to be exact. For example,
-you can say `AtLeast(5)` or `Between(2, 4)`.
-
-If the built-in set of cardinalities doesn't suit you, you are free to
-define your own by implementing the following interface (in namespace
-`testing`):
-
-```
-class CardinalityInterface {
- public:
-  virtual ~CardinalityInterface();
-
-  // Returns true iff call_count calls will satisfy this cardinality.
-  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
-
-  // Returns true iff call_count calls will saturate this cardinality.
-  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
-
-  // Describes self to an ostream.
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-};
-```
-
-For example, to specify that a call must occur even number of times,
-you can write
-
-```
-using ::testing::Cardinality;
-using ::testing::CardinalityInterface;
-using ::testing::MakeCardinality;
-
-class EvenNumberCardinality : public CardinalityInterface {
- public:
-  virtual bool IsSatisfiedByCallCount(int call_count) const {
-    return (call_count % 2) == 0;
-  }
-
-  virtual bool IsSaturatedByCallCount(int call_count) const {
-    return false;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "called even number of times";
-  }
-};
-
-Cardinality EvenNumber() {
-  return MakeCardinality(new EvenNumberCardinality);
-}
-...
-
-  EXPECT_CALL(foo, Bar(3))
-      .Times(EvenNumber());
-```
-
-## Writing New Actions Quickly ##
-
-If the built-in actions don't work for you, and you find it
-inconvenient to use `Invoke()`, you can use a macro from the `ACTION*`
-family to quickly define a new action that can be used in your code as
-if it's a built-in action.
-
-By writing
-```
-ACTION(name) { statements; }
-```
-in a namespace scope (i.e. not inside a class or function), you will
-define an action with the given name that executes the statements.
-The value returned by `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 as `argK`.  For example:
-```
-ACTION(IncrementArg1) { return ++(*arg1); }
-```
-allows you to write
-```
-... WillOnce(IncrementArg1());
-```
-
-Note that you don't need to specify the types of the mock function
-arguments.  Rest assured that your code is type-safe though:
-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.
-
-Another example:
-```
-ACTION(Foo) {
-  (*arg2)(5);
-  Blah();
-  *arg1 = 0;
-  return arg0;
-}
-```
-defines an action `Foo()` that invokes argument #2 (a function pointer)
-with 5, calls function `Blah()`, sets the value pointed to by argument
-#1 to 0, and returns argument #0.
-
-For more convenience and flexibility, you can also use the following
-pre-defined symbols in the body of `ACTION`:
-
-| `argK_type` | The type of the K-th (0-based) argument of the mock function |
-|:------------|:-------------------------------------------------------------|
-| `args`      | All arguments of the mock function as a tuple                |
-| `args_type` | The type of all arguments of the mock function as a tuple    |
-| `return_type` | The return type of the mock function                         |
-| `function_type` | The type of the mock function                                |
-
-For example, when using an `ACTION` as a stub action for mock function:
-```
-int DoSomething(bool flag, int* ptr);
-```
-we have:
-| **Pre-defined Symbol** | **Is Bound To** |
-|:-----------------------|:----------------|
-| `arg0`                 | the value of `flag` |
-| `arg0_type`            | the type `bool` |
-| `arg1`                 | the value of `ptr` |
-| `arg1_type`            | the type `int*` |
-| `args`                 | the tuple `(flag, ptr)` |
-| `args_type`            | the type `std::tr1::tuple<bool, int*>` |
-| `return_type`          | the type `int`  |
-| `function_type`        | the type `int(bool, int*)` |
-
-## Writing New Parameterized Actions Quickly ##
-
-Sometimes you'll want to parameterize an action you define.  For that
-we have another macro
-```
-ACTION_P(name, param) { statements; }
-```
-
-For example,
-```
-ACTION_P(Add, n) { return arg0 + n; }
-```
-will allow you to write
-```
-// Returns argument #0 + 5.
-... WillOnce(Add(5));
-```
-
-For convenience, we use the term _arguments_ for the values used to
-invoke the mock function, and the term _parameters_ for the values
-used to instantiate an action.
-
-Note that you don't need to provide the type of the parameter either.
-Suppose the parameter is named `param`, you can also use the
-Google-Mock-defined symbol `param_type` to refer to the type of the
-parameter as inferred by the compiler.  For example, in the body of
-`ACTION_P(Add, n)` above, you can write `n_type` for the type of `n`.
-
-Google Mock also provides `ACTION_P2`, `ACTION_P3`, and etc to support
-multi-parameter actions.  For example,
-```
-ACTION_P2(ReturnDistanceTo, x, y) {
-  double dx = arg0 - x;
-  double dy = arg1 - y;
-  return sqrt(dx*dx + dy*dy);
-}
-```
-lets you write
-```
-... WillOnce(ReturnDistanceTo(5.0, 26.5));
-```
-
-You can view `ACTION` as a degenerated parameterized action where the
-number of parameters is 0.
-
-You can also easily define actions overloaded on the number of parameters:
-```
-ACTION_P(Plus, a) { ... }
-ACTION_P2(Plus, a, b) { ... }
-```
-
-## Restricting the Type of an Argument or Parameter in an ACTION ##
-
-For maximum brevity and reusability, the `ACTION*` macros don't ask
-you to provide the types of the mock function arguments and the action
-parameters.  Instead, we let the compiler infer the types for us.
-
-Sometimes, however, we may want to be more explicit about the types.
-There are several tricks to do that.  For example:
-```
-ACTION(Foo) {
-  // Makes sure arg0 can be converted to int.
-  int n = arg0;
-  ... use n instead of arg0 here ...
-}
-
-ACTION_P(Bar, param) {
-  // Makes sure the type of arg1 is const char*.
-  ::testing::StaticAssertTypeEq<const char*, arg1_type>();
-
-  // Makes sure param can be converted to bool.
-  bool flag = param;
-}
-```
-where `StaticAssertTypeEq` is a compile-time assertion in Google Test
-that verifies two types are the same.
-
-## Writing New Action Templates Quickly ##
-
-Sometimes you want to give an action explicit template parameters that
-cannot be inferred from its value parameters.  `ACTION_TEMPLATE()`
-supports 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, where _m_ is between 1 and 10, and _n_ is
-between 0 and 10.  `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,
-                // Note the comma between int and k:
-                HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
-                AND_1_VALUE_PARAMS(output)) {
-  *output = T(std::tr1::get<k>(args));
-}
-```
-
-To create an instance of an action template, write:
-```
-  ActionName<t1, ..., t_m>(v1, ..., v_n)
-```
-where the `t`s are the template arguments and the
-`v`s are the value arguments.  The value argument
-types are inferred by the compiler.  For example:
-```
-using ::testing::_;
-...
-  int n;
-  EXPECT_CALL(mock, Foo(_, _))
-      .WillOnce(DuplicateArg<1, unsigned char>(&n));
-```
-
-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 a two-template-parameter action where the compiler
-is asked to infer the type of `x`?
-
-## Using the ACTION Object's Type ##
-
-If you are writing a function that returns an `ACTION` object, you'll
-need to know its type.  The type depends on the macro used to define
-the action and the parameter types.  The rule is relatively simple:
-| **Given Definition** | **Expression** | **Has Type** |
-|:---------------------|:---------------|:-------------|
-| `ACTION(Foo)`        | `Foo()`        | `FooAction`  |
-| `ACTION_TEMPLATE(Foo, HAS_m_TEMPLATE_PARAMS(...), AND_0_VALUE_PARAMS())` |	`Foo<t1, ..., t_m>()` | `FooAction<t1, ..., t_m>` |
-| `ACTION_P(Bar, param)` | `Bar(int_value)` | `BarActionP<int>` |
-| `ACTION_TEMPLATE(Bar, HAS_m_TEMPLATE_PARAMS(...), AND_1_VALUE_PARAMS(p1))` | `Bar<t1, ..., t_m>(int_value)` | `FooActionP<t1, ..., t_m, int>` |
-| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value, int_value)` | `BazActionP2<bool, int>` |
-| `ACTION_TEMPLATE(Baz, HAS_m_TEMPLATE_PARAMS(...), AND_2_VALUE_PARAMS(p1, p2))` | `Baz<t1, ..., t_m>(bool_value, int_value)` | `FooActionP2<t1, ..., t_m, bool, int>` |
-| ...                  | ...            | ...          |
-
-Note that we have to pick different suffixes (`Action`, `ActionP`,
-`ActionP2`, and etc) for actions with different numbers of value
-parameters, or the action definitions cannot be overloaded on the
-number of them.
-
-## Writing New Monomorphic Actions ##
-
-While the `ACTION*` macros are very convenient, sometimes they are
-inappropriate.  For example, despite the tricks shown in the previous
-recipes, they don't let you directly specify the types of the mock
-function arguments and the action parameters, which in general leads
-to unoptimized compiler error messages that can baffle unfamiliar
-users.  They also don't allow overloading actions based on parameter
-types without jumping through some hoops.
-
-An alternative to the `ACTION*` macros is to implement
-`::testing::ActionInterface<F>`, where `F` is the type of the mock
-function in which the action will be used. For example:
-
-```
-template <typename F>class ActionInterface {
- public:
-  virtual ~ActionInterface();
-
-  // Performs the action.  Result is the return type of function type
-  // F, and ArgumentTuple is the tuple of arguments of F.
-  //
-  // For example, if F is int(bool, const string&), then Result would
-  // be int, and ArgumentTuple would be tr1::tuple<bool, const string&>.
-  virtual Result Perform(const ArgumentTuple& args) = 0;
-};
-
-using ::testing::_;
-using ::testing::Action;
-using ::testing::ActionInterface;
-using ::testing::MakeAction;
-
-typedef int IncrementMethod(int*);
-
-class IncrementArgumentAction : public ActionInterface<IncrementMethod> {
- public:
-  virtual int Perform(const tr1::tuple<int*>& args) {
-    int* p = tr1::get<0>(args);  // Grabs the first argument.
-    return *p++;
-  }
-};
-
-Action<IncrementMethod> IncrementArgument() {
-  return MakeAction(new IncrementArgumentAction);
-}
-...
-
-  EXPECT_CALL(foo, Baz(_))
-      .WillOnce(IncrementArgument());
-
-  int n = 5;
-  foo.Baz(&n);  // Should return 5 and change n to 6.
-```
-
-## Writing New Polymorphic Actions ##
-
-The previous recipe showed you how to define your own action. This is
-all good, except that you need to know the type of the function in
-which the action will be used. Sometimes that can be a problem. For
-example, if you want to use the action in functions with _different_
-types (e.g. like `Return()` and `SetArgumentPointee()`).
-
-If an action can be used in several types of mock functions, we say
-it's _polymorphic_. The `MakePolymorphicAction()` function template
-makes it easy to define such an action:
-
-```
-namespace testing {
-
-template <typename Impl>
-PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl);
-
-}  // namespace testing
-```
-
-As an example, let's define an action that returns the second argument
-in the mock function's argument list. The first step is to define an
-implementation class:
-
-```
-class ReturnSecondArgumentAction {
- public:
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) const {
-    // To get the i-th (0-based) argument, use tr1::get<i>(args).
-    return tr1::get<1>(args);
-  }
-};
-```
-
-This implementation class does _not_ need to inherit from any
-particular class. What matters is that it must have a `Perform()`
-method template. This method template takes the mock function's
-arguments as a tuple in a **single** argument, and returns the result of
-the action. It can be either `const` or not, but must be invokable
-with exactly one template argument, which is the result type. In other
-words, you must be able to call `Perform<R>(args)` where `R` is the
-mock function's return type and `args` is its arguments in a tuple.
-
-Next, we use `MakePolymorphicAction()` to turn an instance of the
-implementation class into the polymorphic action we need. It will be
-convenient to have a wrapper for this:
-
-```
-using ::testing::MakePolymorphicAction;
-using ::testing::PolymorphicAction;
-
-PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
-  return MakePolymorphicAction(ReturnSecondArgumentAction());
-}
-```
-
-Now, you can use this polymorphic action the same way you use the
-built-in ones:
-
-```
-using ::testing::_;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD2(DoThis, int(bool flag, int n));
-  MOCK_METHOD3(DoThat, string(int x, const char* str1, const char* str2));
-};
-...
-
-  MockFoo foo;
-  EXPECT_CALL(foo, DoThis(_, _))
-      .WillOnce(ReturnSecondArgument());
-  EXPECT_CALL(foo, DoThat(_, _, _))
-      .WillOnce(ReturnSecondArgument());
-  ...
-  foo.DoThis(true, 5);         // Will return 5.
-  foo.DoThat(1, "Hi", "Bye");  // Will return "Hi".
-```
-
-## Teaching Google Mock How to Print Your Values ##
-
-When an uninteresting or unexpected call occurs, Google Mock prints
-the argument values to help you debug.  The `EXPECT_THAT` and
-`ASSERT_THAT` assertions also print the value being validated when the
-test fails.  Google Mock does this using the user-extensible value
-printer defined in `<gmock/gmock-printers.h>`.
-
-This printer knows how to print the built-in C++ types, native arrays,
-STL containers, and any type that supports the `<<` operator. For
-other types, it prints the raw bytes in the value and hope you the
-user can figure it out.
-
-Did I say that the printer is `extensible`? That means you can teach
-it to do a better job at printing your particular type than to dump
-the bytes. To do that, you just need to define `<<` for your type:
-
-```
-#include <iostream>
-
-namespace foo {
-
-class Foo { ... };
-
-// It's important that the << operator is defined in the SAME
-// namespace that defines Foo.  C++'s look-up rules rely on that.
-::std::ostream& operator<<(::std::ostream& os, const Foo& foo) {
-  return os << foo.DebugString();  // Whatever needed to print foo to os.
-}
-
-}  // namespace foo
-```
-
-Sometimes, this might not be an option. For example, your team may
-consider it dangerous or bad style to have a `<<` operator for `Foo`,
-or `Foo` may already have a `<<` operator that doesn't do what you
-want (and you cannot change it). Don't despair though - Google Mock
-gives you a second chance to get it right. Namely, you can define a
-`PrintTo()` function like this:
-
-```
-#include <iostream>
-
-namespace foo {
-
-class Foo { ... };
-
-// It's important that PrintTo() is defined in the SAME
-// namespace that defines Foo.  C++'s look-up rules rely on that.
-void PrintTo(const Foo& foo, ::std::ostream* os) {
-  *os << foo.DebugString();  // Whatever needed to print foo to os.
-}
-
-}  // namespace foo
-```
-
-What if you have both `<<` and `PrintTo()`? In this case, the latter
-will override the former when Google Mock is concerned. This allows
-you to customize how the value should appear in Google Mock's output
-without affecting code that relies on the behavior of its `<<`
-operator.
-
-**Note:** When printing a pointer of type `T*`, Google Mock calls
-`PrintTo(T*, std::ostream* os)` instead of `operator<<(std::ostream&, T*)`.
-Therefore the only way to affect how a pointer is printed by Google
-Mock is to define `PrintTo()` for it. Also note that `T*` and `const T*`
-are different types, so you may need to define `PrintTo()` for both.
-
-Why does Google Mock treat pointers specially? There are several reasons:
-
-  * We cannot use `operator<<` to print a `signed char*` or `unsigned char*`, since it will print the pointer as a NUL-terminated C string, which likely will cause an access violation.
-  * We want `NULL` pointers to be printed as `"NULL"`, but `operator<<` prints it as `"0"`, `"nullptr"`, or something else, depending on the compiler.
-  * With some compilers, printing a `NULL` `char*` using `operator<<` will segfault.
-  * `operator<<` prints a function pointer as a `bool` (hence it always prints `"1"`), which is not very useful.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/Documentation.md
deleted file mode 100644
index 315b0a29..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/Documentation.md
+++ /dev/null
@@ -1,11 +0,0 @@
-This page lists all documentation wiki pages for Google Mock **version 1.5.0** -- **if you use a different version of Google Mock, please read the documentation for that specific version instead.**
-
-  * [ForDummies](V1_5_ForDummies.md) -- start here if you are new to Google Mock.
-  * [CheatSheet](V1_5_CheatSheet.md) -- a quick reference.
-  * [CookBook](V1_5_CookBook.md) -- recipes for doing various tasks using Google Mock.
-  * [FrequentlyAskedQuestions](V1_5_FrequentlyAskedQuestions.md) -- check here before asking a question on the mailing list.
-
-To contribute code to Google Mock, read:
-
-  * DevGuide -- read this _before_ writing your first patch.
-  * [Pump Manual](http://code.google.com/p/googletest/wiki/PumpManual) -- how we generate some of Google Mock's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/ForDummies.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/ForDummies.md
deleted file mode 100644
index fcc3b561..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/ForDummies.md
+++ /dev/null
@@ -1,439 +0,0 @@
-
-
-(**Note:** If you get compiler errors that you don't understand, be sure to consult [Google Mock Doctor](V1_5_FrequentlyAskedQuestions#How_am_I_supposed_to_make_sense_of_these_horrible_template_error.md).)
-
-# What Is Google C++ Mocking Framework? #
-When you write a prototype or test, often it's not feasible or wise to rely on real objects entirely. A **mock object** implements the same interface as a real object (so it can be used as one), but lets you specify at run time how it will be used and what it should do (which methods will be called? in which order? how many times? with what arguments? what will they return? etc).
-
-**Note:** It is easy to confuse the term _fake objects_ with mock objects. Fakes and mocks actually mean very different things in the Test-Driven Development (TDD) community:
-
-  * **Fake** objects have working implementations, but usually take some shortcut (perhaps to make the operations less expensive), which makes them not suitable for production. An in-memory file system would be an example of a fake.
-  * **Mocks** are objects pre-programmed with _expectations_, which form a specification of the calls they are expected to receive.
-
-If all this seems too abstract for you, don't worry - the most important thing to remember is that a mock allows you to check the _interaction_ between itself and code that uses it. The difference between fakes and mocks will become much clearer once you start to use mocks.
-
-**Google C++ Mocking Framework** (or **Google Mock** for short) is a library (sometimes we also call it a "framework" to make it sound cool) for creating mock classes and using them. It does to C++ what [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/) do to Java.
-
-Using Google Mock involves three basic steps:
-
-  1. Use some simple macros to describe the interface you want to mock, and they will expand to the implementation of your mock class;
-  1. Create some mock objects and specify its expectations and behavior using an intuitive syntax;
-  1. Exercise code that uses the mock objects. Google Mock will catch any violation of the expectations as soon as it arises.
-
-# Why Google Mock? #
-While mock objects help you remove unnecessary dependencies in tests and make them fast and reliable, using mocks manually in C++ is _hard_:
-
-  * Someone has to implement the mocks. The job is usually tedious and error-prone. No wonder people go great distance to avoid it.
-  * The quality of those manually written mocks is a bit, uh, unpredictable. You may see some really polished ones, but you may also see some that were hacked up in a hurry and have all sorts of ad hoc restrictions.
-  * The knowledge you gained from using one mock doesn't transfer to the next.
-
-In contrast, Java and Python programmers have some fine mock frameworks, which automate the creation of mocks. As a result, mocking is a proven effective technique and widely adopted practice in those communities. Having the right tool absolutely makes the difference.
-
-Google Mock was built to help C++ programmers. It was inspired by [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/), but designed with C++'s specifics in mind. It is your friend if any of the following problems is bothering you:
-
-  * You are stuck with a sub-optimal design and wish you had done more prototyping before it was too late, but prototyping in C++ is by no means "rapid".
-  * Your tests are slow as they depend on too many libraries or use expensive resources (e.g. a database).
-  * Your tests are brittle as some resources they use are unreliable (e.g. the network).
-  * You want to test how your code handles a failure (e.g. a file checksum error), but it's not easy to cause one.
-  * You need to make sure that your module interacts with other modules in the right way, but it's hard to observe the interaction; therefore you resort to observing the side effects at the end of the action, which is awkward at best.
-  * You want to "mock out" your dependencies, except that they don't have mock implementations yet; and, frankly, you aren't thrilled by some of those hand-written mocks.
-
-We encourage you to use Google Mock as:
-
-  * a _design_ tool, for it lets you experiment with your interface design early and often. More iterations lead to better designs!
-  * a _testing_ tool to cut your tests' outbound dependencies and probe the interaction between your module and its collaborators.
-
-# Getting Started #
-Using Google Mock is easy! Inside your C++ source file, just `#include` `<gtest/gtest.h>` and `<gmock/gmock.h>`, and you are ready to go.
-
-# A Case for Mock Turtles #
-Let's look at an example. Suppose you are developing a graphics program that relies on a LOGO-like API for drawing. How would you test that it does the right thing? Well, you can run it and compare the screen with a golden screen snapshot, but let's admit it: tests like this are expensive to run and fragile (What if you just upgraded to a shiny new graphics card that has better anti-aliasing? Suddenly you have to update all your golden images.). It would be too painful if all your tests are like this. Fortunately, you learned about Dependency Injection and know the right thing to do: instead of having your application talk to the drawing API directly, wrap the API in an interface (say, `Turtle`) and code to that interface:
-
-```
-class Turtle {
-  ...
-  virtual ~Turtle() {}
-  virtual void PenUp() = 0;
-  virtual void PenDown() = 0;
-  virtual void Forward(int distance) = 0;
-  virtual void Turn(int degrees) = 0;
-  virtual void GoTo(int x, int y) = 0;
-  virtual int GetX() const = 0;
-  virtual int GetY() const = 0;
-};
-```
-
-(Note that the destructor of `Turtle` **must** be virtual, as is the case for **all** classes you intend to inherit from - otherwise the destructor of the derived class will not be called when you delete an object through a base pointer, and you'll get corrupted program states like memory leaks.)
-
-You can control whether the turtle's movement will leave a trace using `PenUp()` and `PenDown()`, and control its movement using `Forward()`, `Turn()`, and `GoTo()`. Finally, `GetX()` and `GetY()` tell you the current position of the turtle.
-
-Your program will normally use a real implementation of this interface. In tests, you can use a mock implementation instead. This allows you to easily check what drawing primitives your program is calling, with what arguments, and in which order. Tests written this way are much more robust (they won't break because your new machine does anti-aliasing differently), easier to read and maintain (the intent of a test is expressed in the code, not in some binary images), and run _much, much faster_.
-
-# Writing the Mock Class #
-If you are lucky, the mocks you need to use have already been implemented by some nice people. If, however, you find yourself in the position to write a mock class, relax - Google Mock turns this task into a fun game! (Well, almost.)
-
-## How to Define It ##
-Using the `Turtle` interface as example, here are the simple steps you need to follow:
-
-  1. Derive a class `MockTurtle` from `Turtle`.
-  1. Take a virtual function of `Turtle`. Count how many arguments it has.
-  1. In the `public:` section of the child class, write `MOCK_METHODn();` (or `MOCK_CONST_METHODn();` if you are mocking a `const` method), where `n` is the number of the arguments; if you counted wrong, shame on you, and a compiler error will tell you so.
-  1. Now comes the fun part: you take the function signature, cut-and-paste the _function name_ as the _first_ argument to the macro, and leave what's left as the _second_ argument (in case you're curious, this is the _type of the function_).
-  1. Repeat until all virtual functions you want to mock are done.
-
-After the process, you should have something like:
-
-```
-#include <gmock/gmock.h>  // Brings in Google Mock.
-class MockTurtle : public Turtle {
- public:
-  ...
-  MOCK_METHOD0(PenUp, void());
-  MOCK_METHOD0(PenDown, void());
-  MOCK_METHOD1(Forward, void(int distance));
-  MOCK_METHOD1(Turn, void(int degrees));
-  MOCK_METHOD2(GoTo, void(int x, int y));
-  MOCK_CONST_METHOD0(GetX, int());
-  MOCK_CONST_METHOD0(GetY, int());
-};
-```
-
-You don't need to define these mock methods somewhere else - the `MOCK_METHOD*` macros will generate the definitions for you. It's that simple! Once you get the hang of it, you can pump out mock classes faster than your source-control system can handle your check-ins.
-
-**Tip:** If even this is too much work for you, you'll find the
-`gmock_gen.py` tool in Google Mock's `scripts/generator/` directory (courtesy of the [cppclean](http://code.google.com/p/cppclean/) project) useful.  This command-line
-tool requires that you have Python 2.4 installed.  You give it a C++ file and the name of an abstract class defined in it,
-and it will print the definition of the mock class for you.  Due to the
-complexity of the C++ language, this script may not always work, but
-it can be quite handy when it does.  For more details, read the [user documentation](http://code.google.com/p/googlemock/source/browse/trunk/scripts/generator/README).
-
-## Where to Put It ##
-When you define a mock class, you need to decide where to put its definition. Some people put it in a `*_test.cc`. This is fine when the interface being mocked (say, `Foo`) is owned by the same person or team. Otherwise, when the owner of `Foo` changes it, your test could break. (You can't really expect `Foo`'s maintainer to fix every test that uses `Foo`, can you?)
-
-So, the rule of thumb is: if you need to mock `Foo` and it's owned by others, define the mock class in `Foo`'s package (better, in a `testing` sub-package such that you can clearly separate production code and testing utilities), and put it in a `mock_foo.h`. Then everyone can reference `mock_foo.h` from their tests. If `Foo` ever changes, there is only one copy of `MockFoo` to change, and only tests that depend on the changed methods need to be fixed.
-
-Another way to do it: you can introduce a thin layer `FooAdaptor` on top of `Foo` and code to this new interface. Since you own `FooAdaptor`, you can absorb changes in `Foo` much more easily. While this is more work initially, carefully choosing the adaptor interface can make your code easier to write and more readable (a net win in the long run), as you can choose `FooAdaptor` to fit your specific domain much better than `Foo` does.
-
-# Using Mocks in Tests #
-Once you have a mock class, using it is easy. The typical work flow is:
-
-  1. Import the Google Mock names from the `testing` namespace such that you can use them unqualified (You only have to do it once per file. Remember that namespaces are a good idea and good for your health.).
-  1. Create some mock objects.
-  1. Specify your expectations on them (How many times will a method be called? With what arguments? What should it do? etc.).
-  1. Exercise some code that uses the mocks; optionally, check the result using Google Test assertions. If a mock method is called more than expected or with wrong arguments, you'll get an error immediately.
-  1. When a mock is destructed, Google Mock will automatically check whether all expectations on it have been satisfied.
-
-Here's an example:
-
-```
-#include "path/to/mock-turtle.h"
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-using ::testing::AtLeast;                     // #1
-
-TEST(PainterTest, CanDrawSomething) {
-  MockTurtle turtle;                          // #2
-  EXPECT_CALL(turtle, PenDown())              // #3
-      .Times(AtLeast(1));
-
-  Painter painter(&turtle);                   // #4
-
-  EXPECT_TRUE(painter.DrawCircle(0, 0, 10));
-}                                             // #5
-
-int main(int argc, char** argv) {
-  // The following line must be executed to initialize Google Mock
-  // (and Google Test) before running the tests.
-  ::testing::InitGoogleMock(&argc, argv);
-  return RUN_ALL_TESTS();
-}
-```
-
-As you might have guessed, this test checks that `PenDown()` is called at least once. If the `painter` object didn't call this method, your test will fail with a message like this:
-
-```
-path/to/my_test.cc:119: Failure
-Actual function call count doesn't match this expectation:
-Actually: never called;
-Expected: called at least once.
-```
-
-**Tip 1:** If you run the test from an Emacs buffer, you can hit `<Enter>` on the line number displayed in the error message to jump right to the failed expectation.
-
-**Tip 2:** If your mock objects are never deleted, the final verification won't happen. Therefore it's a good idea to use a heap leak checker in your tests when you allocate mocks on the heap.
-
-**Important note:** Google Mock requires expectations to be set **before** the mock functions are called, otherwise the behavior is **undefined**. In particular, you mustn't interleave `EXPECT_CALL()`s and calls to the mock functions.
-
-This means `EXPECT_CALL()` should be read as expecting that a call will occur _in the future_, not that a call has occurred. Why does Google Mock work like that? Well, specifying the expectation beforehand allows Google Mock to report a violation as soon as it arises, when the context (stack trace, etc) is still available. This makes debugging much easier.
-
-Admittedly, this test is contrived and doesn't do much. You can easily achieve the same effect without using Google Mock. However, as we shall reveal soon, Google Mock allows you to do _much more_ with the mocks.
-
-## Using Google Mock with Any Testing Framework ##
-If you want to use something other than Google Test (e.g. [CppUnit](http://apps.sourceforge.net/mediawiki/cppunit/index.php?title=Main_Page) or
-[CxxTest](http://cxxtest.tigris.org/)) as your testing framework, just change the `main()` function in the previous section to:
-```
-int main(int argc, char** argv) {
-  // The following line causes Google Mock to throw an exception on failure,
-  // which will be interpreted by your testing framework as a test failure.
-  ::testing::GTEST_FLAG(throw_on_failure) = true;
-  ::testing::InitGoogleMock(&argc, argv);
-  ... whatever your testing framework requires ...
-}
-```
-
-This approach has a catch: it makes Google Mock throw an exception
-from a mock object's destructor sometimes.  With some compilers, this
-sometimes causes the test program to crash.  You'll still be able to
-notice that the test has failed, but it's not a graceful failure.
-
-A better solution is to use Google Test's
-[event listener API](http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide#Extending_Google_Test_by_Handling_Test_Events)
-to report a test failure to your testing framework properly.  You'll need to
-implement the `OnTestPartResult()` method of the event listener interface, but it
-should be straightforward.
-
-If this turns out to be too much work, we suggest that you stick with
-Google Test, which works with Google Mock seamlessly (in fact, it is
-technically part of Google Mock.).  If there is a reason that you
-cannot use Google Test, please let us know.
-
-# Setting Expectations #
-The key to using a mock object successfully is to set the _right expectations_ on it. If you set the expectations too strict, your test will fail as the result of unrelated changes. If you set them too loose, bugs can slip through. You want to do it just right such that your test can catch exactly the kind of bugs you intend it to catch. Google Mock provides the necessary means for you to do it "just right."
-
-## General Syntax ##
-In Google Mock we use the `EXPECT_CALL()` macro to set an expectation on a mock method. The general syntax is:
-
-```
-EXPECT_CALL(mock_object, method(matchers))
-    .Times(cardinality)
-    .WillOnce(action)
-    .WillRepeatedly(action);
-```
-
-The macro has two arguments: first the mock object, and then the method and its arguments. Note that the two are separated by a comma (`,`), not a period (`.`). (Why using a comma? The answer is that it was necessary for technical reasons.)
-
-The macro can be followed by some optional _clauses_ that provide more information about the expectation. We'll discuss how each clause works in the coming sections.
-
-This syntax is designed to make an expectation read like English. For example, you can probably guess that
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetX())
-    .Times(5)
-    .WillOnce(Return(100))
-    .WillOnce(Return(150))
-    .WillRepeatedly(Return(200));
-```
-
-says that the `turtle` object's `GetX()` method will be called five times, it will return 100 the first time, 150 the second time, and then 200 every time. Some people like to call this style of syntax a Domain-Specific Language (DSL).
-
-**Note:** Why do we use a macro to do this? It serves two purposes: first it makes expectations easily identifiable (either by `grep` or by a human reader), and second it allows Google Mock to include the source file location of a failed expectation in messages, making debugging easier.
-
-## Matchers: What Arguments Do We Expect? ##
-When a mock function takes arguments, we must specify what arguments we are expecting; for example:
-
-```
-// Expects the turtle to move forward by 100 units.
-EXPECT_CALL(turtle, Forward(100));
-```
-
-Sometimes you may not want to be too specific (Remember that talk about tests being too rigid? Over specification leads to brittle tests and obscures the intent of tests. Therefore we encourage you to specify only what's necessary - no more, no less.). If you care to check that `Forward()` will be called but aren't interested in its actual argument, write `_` as the argument, which means "anything goes":
-
-```
-using ::testing::_;
-...
-// Expects the turtle to move forward.
-EXPECT_CALL(turtle, Forward(_));
-```
-
-`_` is an instance of what we call **matchers**. A matcher is like a predicate and can test whether an argument is what we'd expect. You can use a matcher inside `EXPECT_CALL()` wherever a function argument is expected.
-
-A list of built-in matchers can be found in the [CheatSheet](V1_5_CheatSheet.md). For example, here's the `Ge` (greater than or equal) matcher:
-
-```
-using ::testing::Ge;...
-EXPECT_CALL(turtle, Forward(Ge(100)));
-```
-
-This checks that the turtle will be told to go forward by at least 100 units.
-
-## Cardinalities: How Many Times Will It Be Called? ##
-The first clause we can specify following an `EXPECT_CALL()` is `Times()`. We call its argument a **cardinality** as it tells _how many times_ the call should occur. It allows us to repeat an expectation many times without actually writing it as many times. More importantly, a cardinality can be "fuzzy", just like a matcher can be. This allows a user to express the intent of a test exactly.
-
-An interesting special case is when we say `Times(0)`. You may have guessed - it means that the function shouldn't be called with the given arguments at all, and Google Mock will report a Google Test failure whenever the function is (wrongfully) called.
-
-We've seen `AtLeast(n)` as an example of fuzzy cardinalities earlier. For the list of built-in cardinalities you can use, see the [CheatSheet](V1_5_CheatSheet.md).
-
-The `Times()` clause can be omitted. **If you omit `Times()`, Google Mock will infer the cardinality for you.** The rules are easy to remember:
-
-  * If **neither** `WillOnce()` **nor** `WillRepeatedly()` is in the `EXPECT_CALL()`, the inferred cardinality is `Times(1)`.
-  * If there are `n WillOnce()`'s but **no** `WillRepeatedly()`, where `n` >= 1, the cardinality is `Times(n)`.
-  * If there are `n WillOnce()`'s and **one** `WillRepeatedly()`, where `n` >= 0, the cardinality is `Times(AtLeast(n))`.
-
-**Quick quiz:** what do you think will happen if a function is expected to be called twice but actually called four times?
-
-## Actions: What Should It Do? ##
-Remember that a mock object doesn't really have a working implementation? We as users have to tell it what to do when a method is invoked. This is easy in Google Mock.
-
-First, if the return type of a mock function is a built-in type or a pointer, the function has a **default action** (a `void` function will just return, a `bool` function will return `false`, and other functions will return 0). If you don't say anything, this behavior will be used.
-
-Second, if a mock function doesn't have a default action, or the default action doesn't suit you, you can specify the action to be taken each time the expectation matches using a series of `WillOnce()` clauses followed by an optional `WillRepeatedly()`. For example,
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetX())
-    .WillOnce(Return(100))
-    .WillOnce(Return(200))
-    .WillOnce(Return(300));
-```
-
-This says that `turtle.GetX()` will be called _exactly three times_ (Google Mock inferred this from how many `WillOnce()` clauses we've written, since we didn't explicitly write `Times()`), and will return 100, 200, and 300 respectively.
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetY())
-    .WillOnce(Return(100))
-    .WillOnce(Return(200))
-    .WillRepeatedly(Return(300));
-```
-
-says that `turtle.GetY()` will be called _at least twice_ (Google Mock knows this as we've written two `WillOnce()` clauses and a `WillRepeatedly()` while having no explicit `Times()`), will return 100 the first time, 200 the second time, and 300 from the third time on.
-
-Of course, if you explicitly write a `Times()`, Google Mock will not try to infer the cardinality itself. What if the number you specified is larger than there are `WillOnce()` clauses? Well, after all `WillOnce()`s are used up, Google Mock will do the _default_ action for the function every time (unless, of course, you have a `WillRepeatedly()`.).
-
-What can we do inside `WillOnce()` besides `Return()`? You can return a reference using `ReturnRef(variable)`, or invoke a pre-defined function, among [others](V1_5_CheatSheet#Actions.md).
-
-**Important note:** The `EXPECT_CALL()` statement evaluates the action clause only once, even though the action may be performed many times. Therefore you must be careful about side effects. The following may not do what you want:
-
-```
-int n = 100;
-EXPECT_CALL(turtle, GetX())
-.Times(4)
-.WillOnce(Return(n++));
-```
-
-Instead of returning 100, 101, 102, ..., consecutively, this mock function will always return 100 as `n++` is only evaluated once. Similarly, `Return(new Foo)` will create a new `Foo` object when the `EXPECT_CALL()` is executed, and will return the same pointer every time. If you want the side effect to happen every time, you need to define a custom action, which we'll teach in the [CookBook](V1_5_CookBook.md).
-
-Time for another quiz! What do you think the following means?
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetY())
-.Times(4)
-.WillOnce(Return(100));
-```
-
-Obviously `turtle.GetY()` is expected to be called four times. But if you think it will return 100 every time, think twice! Remember that one `WillOnce()` clause will be consumed each time the function is invoked and the default action will be taken afterwards. So the right answer is that `turtle.GetY()` will return 100 the first time, but **return 0 from the second time on**, as returning 0 is the default action for `int` functions.
-
-## Using Multiple Expectations ##
-So far we've only shown examples where you have a single expectation. More realistically, you're going to specify expectations on multiple mock methods, which may be from multiple mock objects.
-
-By default, when a mock method is invoked, Google Mock will search the expectations in the **reverse order** they are defined, and stop when an active expectation that matches the arguments is found (you can think of it as "newer rules override older ones."). If the matching expectation cannot take any more calls, you will get an upper-bound-violated failure. Here's an example:
-
-```
-using ::testing::_;...
-EXPECT_CALL(turtle, Forward(_));  // #1
-EXPECT_CALL(turtle, Forward(10))  // #2
-    .Times(2);
-```
-
-If `Forward(10)` is called three times in a row, the third time it will be an error, as the last matching expectation (#2) has been saturated. If, however, the third `Forward(10)` call is replaced by `Forward(20)`, then it would be OK, as now #1 will be the matching expectation.
-
-**Side note:** Why does Google Mock search for a match in the _reverse_ order of the expectations? The reason is that this allows a user to set up the default expectations in a mock object's constructor or the test fixture's set-up phase and then customize the mock by writing more specific expectations in the test body. So, if you have two expectations on the same method, you want to put the one with more specific matchers **after** the other, or the more specific rule would be shadowed by the more general one that comes after it.
-
-## Ordered vs Unordered Calls ##
-By default, an expectation can match a call even though an earlier expectation hasn't been satisfied. In other words, the calls don't have to occur in the order the expectations are specified.
-
-Sometimes, you may want all the expected calls to occur in a strict order. To say this in Google Mock is easy:
-
-```
-using ::testing::InSequence;...
-TEST(FooTest, DrawsLineSegment) {
-  ...
-  {
-    InSequence dummy;
-
-    EXPECT_CALL(turtle, PenDown());
-    EXPECT_CALL(turtle, Forward(100));
-    EXPECT_CALL(turtle, PenUp());
-  }
-  Foo();
-}
-```
-
-By creating an object of type `InSequence`, all expectations in its scope are put into a _sequence_ and have to occur _sequentially_. Since we are just relying on the constructor and destructor of this object to do the actual work, its name is really irrelevant.
-
-In this example, we test that `Foo()` calls the three expected functions in the order as written. If a call is made out-of-order, it will be an error.
-
-(What if you care about the relative order of some of the calls, but not all of them? Can you specify an arbitrary partial order? The answer is ... yes! If you are impatient, the details can be found in the [CookBook](V1_5_CookBook.md).)
-
-## All Expectations Are Sticky (Unless Said Otherwise) ##
-Now let's do a quick quiz to see how well you can use this mock stuff already. How would you test that the turtle is asked to go to the origin _exactly twice_ (you want to ignore any other instructions it receives)?
-
-After you've come up with your answer, take a look at ours and compare notes (solve it yourself first - don't cheat!):
-
-```
-using ::testing::_;...
-EXPECT_CALL(turtle, GoTo(_, _))  // #1
-    .Times(AnyNumber());
-EXPECT_CALL(turtle, GoTo(0, 0))  // #2
-    .Times(2);
-```
-
-Suppose `turtle.GoTo(0, 0)` is called three times. In the third time, Google Mock will see that the arguments match expectation #2 (remember that we always pick the last matching expectation). Now, since we said that there should be only two such calls, Google Mock will report an error immediately. This is basically what we've told you in the "Using Multiple Expectations" section above.
-
-This example shows that **expectations in Google Mock are "sticky" by default**, in the sense that they remain active even after we have reached their invocation upper bounds. This is an important rule to remember, as it affects the meaning of the spec, and is **different** to how it's done in many other mocking frameworks (Why'd we do that? Because we think our rule makes the common cases easier to express and understand.).
-
-Simple? Let's see if you've really understood it: what does the following code say?
-
-```
-using ::testing::Return;
-...
-for (int i = n; i > 0; i--) {
-  EXPECT_CALL(turtle, GetX())
-      .WillOnce(Return(10*i));
-}
-```
-
-If you think it says that `turtle.GetX()` will be called `n` times and will return 10, 20, 30, ..., consecutively, think twice! The problem is that, as we said, expectations are sticky. So, the second time `turtle.GetX()` is called, the last (latest) `EXPECT_CALL()` statement will match, and will immediately lead to an "upper bound exceeded" error - this piece of code is not very useful!
-
-One correct way of saying that `turtle.GetX()` will return 10, 20, 30, ..., is to explicitly say that the expectations are _not_ sticky. In other words, they should _retire_ as soon as they are saturated:
-
-```
-using ::testing::Return;
-...
-for (int i = n; i > 0; i--) {
-  EXPECT_CALL(turtle, GetX())
-    .WillOnce(Return(10*i))
-    .RetiresOnSaturation();
-}
-```
-
-And, there's a better way to do it: in this case, we expect the calls to occur in a specific order, and we line up the actions to match the order. Since the order is important here, we should make it explicit using a sequence:
-
-```
-using ::testing::InSequence;
-using ::testing::Return;
-...
-{
-  InSequence s;
-
-  for (int i = 1; i <= n; i++) {
-    EXPECT_CALL(turtle, GetX())
-        .WillOnce(Return(10*i))
-        .RetiresOnSaturation();
-  }
-}
-```
-
-By the way, the other situation where an expectation may _not_ be sticky is when it's in a sequence - as soon as another expectation that comes after it in the sequence has been used, it automatically retires (and will never be used to match any call).
-
-## Uninteresting Calls ##
-A mock object may have many methods, and not all of them are that interesting. For example, in some tests we may not care about how many times `GetX()` and `GetY()` get called.
-
-In Google Mock, if you are not interested in a method, just don't say anything about it. If a call to this method occurs, you'll see a warning in the test output, but it won't be a failure.
-
-# What Now? #
-Congratulations! You've learned enough about Google Mock to start using it. Now, you might want to join the [googlemock](http://groups.google.com/group/googlemock) discussion group and actually write some tests using Google Mock - it will be fun. Hey, it may even be addictive - you've been warned.
-
-Then, if you feel like increasing your mock quotient, you should move on to the [CookBook](V1_5_CookBook.md). You can learn many advanced features of Google Mock there -- and advance your level of enjoyment and testing bliss.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/FrequentlyAskedQuestions.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/FrequentlyAskedQuestions.md
deleted file mode 100644
index 7593243c..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_5/FrequentlyAskedQuestions.md
+++ /dev/null
@@ -1,624 +0,0 @@
-
-
-Please send your questions to the
-[googlemock](http://groups.google.com/group/googlemock) discussion
-group. If you need help with compiler errors, make sure you have
-tried [Google Mock Doctor](#How_am_I_supposed_to_make_sense_of_these_horrible_template_error.md) first.
-
-## I wrote some matchers.  After I upgraded to a new version of Google Mock, they no longer compile.  What's going on? ##
-
-After version 1.4.0 of Google Mock was released, we had an idea on how
-to make it easier to write matchers that can generate informative
-messages efficiently.  We experimented with this idea and liked what
-we saw.  Therefore we decided to implement it.
-
-Unfortunately, this means that if you have defined your own matchers
-by implementing `MatcherInterface` or using `MakePolymorphicMatcher()`,
-your definitions will no longer compile.  Matchers defined using the
-`MATCHER*` family of macros are not affected.
-
-Sorry for the hassle if your matchers are affected.  We believe it's
-in everyone's long-term interest to make this change sooner than
-later.  Fortunately, it's usually not hard to migrate an existing
-matcher to the new API.  Here's what you need to do:
-
-If you wrote your matcher like this:
-```
-// Old matcher definition that doesn't work with the latest
-// Google Mock.
-using ::testing::MatcherInterface;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetFoo() > 5;
-  }
-  ...
-};
-```
-
-you'll need to change it to:
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool MatchAndExplain(MyType value,
-                               MatchResultListener* listener) const {
-    // Returns true if value matches.
-    return value.GetFoo() > 5;
-  }
-  ...
-};
-```
-(i.e. rename `Matches()` to `MatchAndExplain()` and give it a second
-argument of type `MatchResultListener*`.)
-
-If you were also using `ExplainMatchResultTo()` to improve the matcher
-message:
-```
-// Old matcher definition that doesn't work with the lastest
-// Google Mock.
-using ::testing::MatcherInterface;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetFoo() > 5;
-  }
-
-  virtual void ExplainMatchResultTo(MyType value,
-                                    ::std::ostream* os) const {
-    // Prints some helpful information to os to help
-    // a user understand why value matches (or doesn't match).
-    *os << "the Foo property is " << value.GetFoo();
-  }
-  ...
-};
-```
-
-you should move the logic of `ExplainMatchResultTo()` into
-`MatchAndExplain()`, using the `MatchResultListener` argument where
-the `::std::ostream` was used:
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool MatchAndExplain(MyType value,
-                               MatchResultListener* listener) const {
-    // Returns true if value matches.
-    *listener << "the Foo property is " << value.GetFoo();
-    return value.GetFoo() > 5;
-  }
-  ...
-};
-```
-
-If your matcher is defined using `MakePolymorphicMatcher()`:
-```
-// Old matcher definition that doesn't work with the latest
-// Google Mock.
-using ::testing::MakePolymorphicMatcher;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetBar() < 42;
-  }
-  ...
-};
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-you should rename the `Matches()` method to `MatchAndExplain()` and
-add a `MatchResultListener*` argument (the same as what you need to do
-for matchers defined by implementing `MatcherInterface`):
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MakePolymorphicMatcher;
-using ::testing::MatchResultListener;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool MatchAndExplain(MyType value,
-                       MatchResultListener* listener) const {
-    // Returns true if value matches.
-    return value.GetBar() < 42;
-  }
-  ...
-};
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-If your polymorphic matcher uses `ExplainMatchResultTo()` for better
-failure messages:
-```
-// Old matcher definition that doesn't work with the latest
-// Google Mock.
-using ::testing::MakePolymorphicMatcher;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetBar() < 42;
-  }
-  ...
-};
-void ExplainMatchResultTo(const MyGreatMatcher& matcher,
-                          MyType value,
-                          ::std::ostream* os) {
-  // Prints some helpful information to os to help
-  // a user understand why value matches (or doesn't match).
-  *os << "the Bar property is " << value.GetBar();
-}
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-you'll need to move the logic inside `ExplainMatchResultTo()` to
-`MatchAndExplain()`:
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MakePolymorphicMatcher;
-using ::testing::MatchResultListener;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool MatchAndExplain(MyType value,
-                       MatchResultListener* listener) const {
-    // Returns true if value matches.
-    *listener << "the Bar property is " << value.GetBar();
-    return value.GetBar() < 42;
-  }
-  ...
-};
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-For more information, you can read these
-[two](V1_5_CookBook#Writing_New_Monomorphic_Matchers.md)
-[recipes](V1_5_CookBook#Writing_New_Polymorphic_Matchers.md)
-from the cookbook.  As always, you
-are welcome to post questions on `googlemock@googlegroups.com` if you
-need any help.
-
-## When using Google Mock, do I have to use Google Test as the testing framework?  I have my favorite testing framework and don't want to switch. ##
-
-Google Mock works out of the box with Google Test.  However, it's easy
-to configure it to work with any testing framework of your choice.
-[Here](V1_5_ForDummies#Using_Google_Mock_with_Any_Testing_Framework.md) is how.
-
-## How am I supposed to make sense of these horrible template errors? ##
-
-If you are confused by the compiler errors gcc threw at you,
-try consulting the _Google Mock Doctor_ tool first.  What it does is to
-scan stdin for gcc error messages, and spit out diagnoses on the
-problems (we call them diseases) your code has.
-
-To "install", run command:
-```
-alias gmd='<path to googlemock>/scripts/gmock_doctor.py'
-```
-
-To use it, do:
-```
-<your-favorite-build-command> <your-test> 2>&1 | gmd
-```
-
-For example:
-```
-make my_test 2>&1 | gmd
-```
-
-Or you can run `gmd` and copy-n-paste gcc's error messages to it.
-
-## Can I mock a variadic function? ##
-
-You cannot mock a variadic function (i.e. a function taking ellipsis
-(`...`) arguments) directly in Google Mock.
-
-The problem is that in general, there is _no way_ for a mock object to
-know how many arguments are passed to the variadic method, and what
-the arguments' types are.  Only the _author of the base class_ knows
-the protocol, and we cannot look into his head.
-
-Therefore, to mock such a function, the _user_ must teach the mock
-object how to figure out the number of arguments and their types.  One
-way to do it is to provide overloaded versions of the function.
-
-Ellipsis arguments are inherited from C and not really a C++ feature.
-They are unsafe to use and don't work with arguments that have
-constructors or destructors.  Therefore we recommend to avoid them in
-C++ as much as possible.
-
-## MSVC gives me warning C4301 or C4373 when I define a mock method with a const parameter.  Why? ##
-
-If you compile this using Microsoft Visual C++ 2005 SP1:
-```
-class Foo {
-  ...
-  virtual void Bar(const int i) = 0;
-};
-
-class MockFoo : public Foo {
-  ...
-  MOCK_METHOD1(Bar, void(const int i));
-};
-```
-You may get the following warning:
-```
-warning C4301: 'MockFoo::Bar': overriding virtual function only differs from 'Foo::Bar' by const/volatile qualifier
-```
-
-This is a MSVC bug.  The same code compiles fine with gcc ,for
-example.  If you use Visual C++ 2008 SP1, you would get the warning:
-```
-warning C4373: 'MockFoo::Bar': virtual function overrides 'Foo::Bar', previous versions of the compiler did not override when parameters only differed by const/volatile qualifiers
-```
-
-In C++, if you _declare_ a function with a `const` parameter, the
-`const` modifier is _ignored_.  Therefore, the `Foo` base class above
-is equivalent to:
-```
-class Foo {
-  ...
-  virtual void Bar(int i) = 0;  // int or const int?  Makes no difference.
-};
-```
-
-In fact, you can _declare_ Bar() with an `int` parameter, and _define_
-it with a `const int` parameter.  The compiler will still match them
-up.
-
-Since making a parameter `const` is meaningless in the method
-_declaration_, we recommend to remove it in both `Foo` and `MockFoo`.
-That should workaround the VC bug.
-
-Note that we are talking about the _top-level_ `const` modifier here.
-If the function parameter is passed by pointer or reference, declaring
-the _pointee_ or _referee_ as `const` is still meaningful.  For
-example, the following two declarations are _not_ equivalent:
-```
-void Bar(int* p);        // Neither p nor *p is const.
-void Bar(const int* p);  // p is not const, but *p is.
-```
-
-## I have a huge mock class, and Microsoft Visual C++ runs out of memory when compiling it.  What can I do? ##
-
-We've noticed that when the `/clr` compiler flag is used, Visual C++
-uses 5~6 times as much memory when compiling a mock class.  We suggest
-to avoid `/clr` when compiling native C++ mocks.
-
-## I can't figure out why Google Mock thinks my expectations are not satisfied.  What should I do? ##
-
-You might want to run your test with
-`--gmock_verbose=info`.  This flag lets Google Mock print a trace
-of every mock function call it receives.  By studying the trace,
-you'll gain insights on why the expectations you set are not met.
-
-## How can I assert that a function is NEVER called? ##
-
-```
-EXPECT_CALL(foo, Bar(_))
-    .Times(0);
-```
-
-## I have a failed test where Google Mock tells me TWICE that a particular expectation is not satisfied.  Isn't this redundant? ##
-
-When Google Mock detects a failure, it prints relevant information
-(the mock function arguments, the state of relevant expectations, and
-etc) to help the user debug.  If another failure is detected, Google
-Mock will do the same, including printing the state of relevant
-expectations.
-
-Sometimes an expectation's state didn't change between two failures,
-and you'll see the same description of the state twice.  They are
-however _not_ redundant, as they refer to _different points in time_.
-The fact they are the same _is_ interesting information.
-
-## I get a heap check failure when using a mock object, but using a real object is fine.  What can be wrong? ##
-
-Does the class (hopefully a pure interface) you are mocking have a
-virtual destructor?
-
-Whenever you derive from a base class, make sure its destructor is
-virtual.  Otherwise Bad Things will happen.  Consider the following
-code:
-
-```
-class Base {
- public:
-  // Not virtual, but should be.
-  ~Base() { ... }
-  ...
-};
-
-class Derived : public Base {
- public:
-  ...
- private:
-  std::string value_;
-};
-
-...
-  Base* p = new Derived;
-  ...
-  delete p;  // Surprise! ~Base() will be called, but ~Derived() will not
-             // - value_ is leaked.
-```
-
-By changing `~Base()` to virtual, `~Derived()` will be correctly
-called when `delete p` is executed, and the heap checker
-will be happy.
-
-## The "newer expectations override older ones" rule makes writing expectations awkward.  Why does Google Mock do that? ##
-
-When people complain about this, often they are referring to code like:
-
-```
-// foo.Bar() should be called twice, return 1 the first time, and return
-// 2 the second time.  However, I have to write the expectations in the
-// reverse order.  This sucks big time!!!
-EXPECT_CALL(foo, Bar())
-    .WillOnce(Return(2))
-    .RetiresOnSaturation();
-EXPECT_CALL(foo, Bar())
-    .WillOnce(Return(1))
-    .RetiresOnSaturation();
-```
-
-The problem is that they didn't pick the **best** way to express the test's
-intent.
-
-By default, expectations don't have to be matched in _any_ particular
-order.  If you want them to match in a certain order, you need to be
-explicit.  This is Google Mock's (and jMock's) fundamental philosophy: it's
-easy to accidentally over-specify your tests, and we want to make it
-harder to do so.
-
-There are two better ways to write the test spec.  You could either
-put the expectations in sequence:
-
-```
-// foo.Bar() should be called twice, return 1 the first time, and return
-// 2 the second time.  Using a sequence, we can write the expectations
-// in their natural order.
-{
-  InSequence s;
-  EXPECT_CALL(foo, Bar())
-      .WillOnce(Return(1))
-      .RetiresOnSaturation();
-  EXPECT_CALL(foo, Bar())
-      .WillOnce(Return(2))
-      .RetiresOnSaturation();
-}
-```
-
-or you can put the sequence of actions in the same expectation:
-
-```
-// foo.Bar() should be called twice, return 1 the first time, and return
-// 2 the second time.
-EXPECT_CALL(foo, Bar())
-    .WillOnce(Return(1))
-    .WillOnce(Return(2))
-    .RetiresOnSaturation();
-```
-
-Back to the original questions: why does Google Mock search the
-expectations (and `ON_CALL`s) from back to front?  Because this
-allows a user to set up a mock's behavior for the common case early
-(e.g. in the mock's constructor or the test fixture's set-up phase)
-and customize it with more specific rules later.  If Google Mock
-searches from front to back, this very useful pattern won't be
-possible.
-
-## Google Mock prints a warning when a function without EXPECT\_CALL is called, even if I have set its behavior using ON\_CALL.  Would it be reasonable not to show the warning in this case? ##
-
-When choosing between being neat and being safe, we lean toward the
-latter.  So the answer is that we think it's better to show the
-warning.
-
-Often people write `ON_CALL`s in the mock object's
-constructor or `SetUp()`, as the default behavior rarely changes from
-test to test.  Then in the test body they set the expectations, which
-are often different for each test.  Having an `ON_CALL` in the set-up
-part of a test doesn't mean that the calls are expected.  If there's
-no `EXPECT_CALL` and the method is called, it's possibly an error.  If
-we quietly let the call go through without notifying the user, bugs
-may creep in unnoticed.
-
-If, however, you are sure that the calls are OK, you can write
-
-```
-EXPECT_CALL(foo, Bar(_))
-    .WillRepeatedly(...);
-```
-
-instead of
-
-```
-ON_CALL(foo, Bar(_))
-    .WillByDefault(...);
-```
-
-This tells Google Mock that you do expect the calls and no warning should be
-printed.
-
-Also, you can control the verbosity using the `--gmock_verbose` flag.
-If you find the output too noisy when debugging, just choose a less
-verbose level.
-
-## How can I delete the mock function's argument in an action? ##
-
-If you find yourself needing to perform some action that's not
-supported by Google Mock directly, remember that you can define your own
-actions using
-[MakeAction()](V1_5_CookBook#Writing_New_Actions.md) or
-[MakePolymorphicAction()](V1_5_CookBook#Writing_New_Polymorphic_Actions.md),
-or you can write a stub function and invoke it using
-[Invoke()](V1_5_CookBook#Using_Functions_Methods_Functors.md).
-
-## MOCK\_METHODn()'s second argument looks funny.  Why don't you use the MOCK\_METHODn(Method, return\_type, arg\_1, ..., arg\_n) syntax? ##
-
-What?!  I think it's beautiful. :-)
-
-While which syntax looks more natural is a subjective matter to some
-extent, Google Mock's syntax was chosen for several practical advantages it
-has.
-
-Try to mock a function that takes a map as an argument:
-```
-virtual int GetSize(const map<int, std::string>& m);
-```
-
-Using the proposed syntax, it would be:
-```
-MOCK_METHOD1(GetSize, int, const map<int, std::string>& m);
-```
-
-Guess what?  You'll get a compiler error as the compiler thinks that
-`const map<int, std::string>& m` are **two**, not one, arguments. To work
-around this you can use `typedef` to give the map type a name, but
-that gets in the way of your work.  Google Mock's syntax avoids this
-problem as the function's argument types are protected inside a pair
-of parentheses:
-```
-// This compiles fine.
-MOCK_METHOD1(GetSize, int(const map<int, std::string>& m));
-```
-
-You still need a `typedef` if the return type contains an unprotected
-comma, but that's much rarer.
-
-Other advantages include:
-  1. `MOCK_METHOD1(Foo, int, bool)` can leave a reader wonder whether the method returns `int` or `bool`, while there won't be such confusion using Google Mock's syntax.
-  1. The way Google Mock describes a function type is nothing new, although many people may not be familiar with it.  The same syntax was used in C, and the `function` library in `tr1` uses this syntax extensively.  Since `tr1` will become a part of the new version of STL, we feel very comfortable to be consistent with it.
-  1. The function type syntax is also used in other parts of Google Mock's API (e.g. the action interface) in order to make the implementation tractable. A user needs to learn it anyway in order to utilize Google Mock's more advanced features.  We'd as well stick to the same syntax in `MOCK_METHOD*`!
-
-## My code calls a static/global function.  Can I mock it? ##
-
-You can, but you need to make some changes.
-
-In general, if you find yourself needing to mock a static function,
-it's a sign that your modules are too tightly coupled (and less
-flexible, less reusable, less testable, etc).  You are probably better
-off defining a small interface and call the function through that
-interface, which then can be easily mocked.  It's a bit of work
-initially, but usually pays for itself quickly.
-
-This Google Testing Blog
-[post](http://googletesting.blogspot.com/2008/06/defeat-static-cling.html)
-says it excellently.  Check it out.
-
-## My mock object needs to do complex stuff.  It's a lot of pain to specify the actions.  Google Mock sucks! ##
-
-I know it's not a question, but you get an answer for free any way. :-)
-
-With Google Mock, you can create mocks in C++ easily.  And people might be
-tempted to use them everywhere. Sometimes they work great, and
-sometimes you may find them, well, a pain to use. So, what's wrong in
-the latter case?
-
-When you write a test without using mocks, you exercise the code and
-assert that it returns the correct value or that the system is in an
-expected state.  This is sometimes called "state-based testing".
-
-Mocks are great for what some call "interaction-based" testing:
-instead of checking the system state at the very end, mock objects
-verify that they are invoked the right way and report an error as soon
-as it arises, giving you a handle on the precise context in which the
-error was triggered.  This is often more effective and economical to
-do than state-based testing.
-
-If you are doing state-based testing and using a test double just to
-simulate the real object, you are probably better off using a fake.
-Using a mock in this case causes pain, as it's not a strong point for
-mocks to perform complex actions.  If you experience this and think
-that mocks suck, you are just not using the right tool for your
-problem. Or, you might be trying to solve the wrong problem. :-)
-
-## I got a warning "Uninteresting function call encountered - default action taken.."  Should I panic? ##
-
-By all means, NO!  It's just an FYI.
-
-What it means is that you have a mock function, you haven't set any
-expectations on it (by Google Mock's rule this means that you are not
-interested in calls to this function and therefore it can be called
-any number of times), and it is called.  That's OK - you didn't say
-it's not OK to call the function!
-
-What if you actually meant to disallow this function to be called, but
-forgot to write `EXPECT_CALL(foo, Bar()).Times(0)`?  While
-one can argue that it's the user's fault, Google Mock tries to be nice and
-prints you a note.
-
-So, when you see the message and believe that there shouldn't be any
-uninteresting calls, you should investigate what's going on.  To make
-your life easier, Google Mock prints the function name and arguments
-when an uninteresting call is encountered.
-
-## I want to define a custom action.  Should I use Invoke() or implement the action interface? ##
-
-Either way is fine - you want to choose the one that's more convenient
-for your circumstance.
-
-Usually, if your action is for a particular function type, defining it
-using `Invoke()` should be easier; if your action can be used in
-functions of different types (e.g. if you are defining
-`Return(value)`), `MakePolymorphicAction()` is
-easiest.  Sometimes you want precise control on what types of
-functions the action can be used in, and implementing
-`ActionInterface` is the way to go here. See the implementation of
-`Return()` in `include/gmock/gmock-actions.h` for an example.
-
-## I'm using the set-argument-pointee action, and the compiler complains about "conflicting return type specified".  What does it mean? ##
-
-You got this error as Google Mock has no idea what value it should return
-when the mock method is called.  `SetArgumentPointee()` says what the
-side effect is, but doesn't say what the return value should be.  You
-need `DoAll()` to chain a `SetArgumentPointee()` with a `Return()`.
-
-See this [recipe](V1_5_CookBook#Mocking_Side_Effects.md) for more details and an example.
-
-
-## My question is not in your FAQ! ##
-
-If you cannot find the answer to your question in this FAQ, there are
-some other resources you can use:
-
-  1. read other [wiki pages](http://code.google.com/p/googlemock/w/list),
-  1. search the mailing list [archive](http://groups.google.com/group/googlemock/topics),
-  1. ask it on [googlemock@googlegroups.com](mailto:googlemock@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googlemock) before you can post.).
-
-Please note that creating an issue in the
-[issue tracker](http://code.google.com/p/googlemock/issues/list) is _not_
-a good way to get your answer, as it is monitored infrequently by a
-very small number of people.
-
-When asking a question, it's helpful to provide as much of the
-following information as possible (people cannot help you if there's
-not enough information in your question):
-
-  * the version (or the revision number if you check out from SVN directly) of Google Mock you use (Google Mock is under active development, so it's possible that your problem has been solved in a later version),
-  * your operating system,
-  * the name and version of your compiler,
-  * the complete command line flags you give to your compiler,
-  * the complete compiler error messages (if the question is about compilation),
-  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CheatSheet.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CheatSheet.md
deleted file mode 100644
index 91de1d21..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CheatSheet.md
+++ /dev/null
@@ -1,534 +0,0 @@
-
-
-# Defining a Mock Class #
-
-## Mocking a Normal Class ##
-
-Given
-```
-class Foo {
-  ...
-  virtual ~Foo();
-  virtual int GetSize() const = 0;
-  virtual string Describe(const char* name) = 0;
-  virtual string Describe(int type) = 0;
-  virtual bool Process(Bar elem, int count) = 0;
-};
-```
-(note that `~Foo()` **must** be virtual) we can define its mock as
-```
-#include "gmock/gmock.h"
-
-class MockFoo : public Foo {
-  MOCK_CONST_METHOD0(GetSize, int());
-  MOCK_METHOD1(Describe, string(const char* name));
-  MOCK_METHOD1(Describe, string(int type));
-  MOCK_METHOD2(Process, bool(Bar elem, int count));
-};
-```
-
-To create a "nice" mock object which ignores all uninteresting calls,
-or a "strict" mock object, which treats them as failures:
-```
-NiceMock<MockFoo> nice_foo;     // The type is a subclass of MockFoo.
-StrictMock<MockFoo> strict_foo; // The type is a subclass of MockFoo.
-```
-
-## Mocking a Class Template ##
-
-To mock
-```
-template <typename Elem>
-class StackInterface {
- public:
-  ...
-  virtual ~StackInterface();
-  virtual int GetSize() const = 0;
-  virtual void Push(const Elem& x) = 0;
-};
-```
-(note that `~StackInterface()` **must** be virtual) just append `_T` to the `MOCK_*` macros:
-```
-template <typename Elem>
-class MockStack : public StackInterface<Elem> {
- public:
-  ...
-  MOCK_CONST_METHOD0_T(GetSize, int());
-  MOCK_METHOD1_T(Push, void(const Elem& x));
-};
-```
-
-## Specifying Calling Conventions for Mock Functions ##
-
-If your mock function doesn't use the default calling convention, you
-can specify it by appending `_WITH_CALLTYPE` to any of the macros
-described in the previous two sections and supplying the calling
-convention as the first argument to the macro. For example,
-```
-  MOCK_METHOD_1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int n));
-  MOCK_CONST_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, Bar, int(double x, double y));
-```
-where `STDMETHODCALLTYPE` is defined by `<objbase.h>` on Windows.
-
-# Using Mocks in Tests #
-
-The typical flow is:
-  1. Import the Google Mock names you need to use. All Google Mock names are in the `testing` namespace unless they are macros or otherwise noted.
-  1. Create the mock objects.
-  1. Optionally, set the default actions of the mock objects.
-  1. Set your expectations on the mock objects (How will they be called? What wil they do?).
-  1. Exercise code that uses the mock objects; if necessary, check the result using [Google Test](http://code.google.com/p/googletest/) assertions.
-  1. When a mock objects is destructed, Google Mock automatically verifies that all expectations on it have been satisfied.
-
-Here is an example:
-```
-using ::testing::Return;                            // #1
-
-TEST(BarTest, DoesThis) {
-  MockFoo foo;                                    // #2
-
-  ON_CALL(foo, GetSize())                         // #3
-      .WillByDefault(Return(1));
-  // ... other default actions ...
-
-  EXPECT_CALL(foo, Describe(5))                   // #4
-      .Times(3)
-      .WillRepeatedly(Return("Category 5"));
-  // ... other expectations ...
-
-  EXPECT_EQ("good", MyProductionFunction(&foo));  // #5
-}                                                 // #6
-```
-
-# Setting Default Actions #
-
-Google Mock has a **built-in default action** for any function that
-returns `void`, `bool`, a numeric value, or a pointer.
-
-To customize the default action for functions with return type `T` globally:
-```
-using ::testing::DefaultValue;
-
-DefaultValue<T>::Set(value);  // Sets the default value to be returned.
-// ... use the mocks ...
-DefaultValue<T>::Clear();     // Resets the default value.
-```
-
-To customize the default action for a particular method, use `ON_CALL()`:
-```
-ON_CALL(mock_object, method(matchers))
-    .With(multi_argument_matcher)  ?
-    .WillByDefault(action);
-```
-
-# Setting Expectations #
-
-`EXPECT_CALL()` sets **expectations** on a mock method (How will it be
-called? What will it do?):
-```
-EXPECT_CALL(mock_object, method(matchers))
-    .With(multi_argument_matcher)  ?
-    .Times(cardinality)            ?
-    .InSequence(sequences)         *
-    .After(expectations)           *
-    .WillOnce(action)              *
-    .WillRepeatedly(action)        ?
-    .RetiresOnSaturation();        ?
-```
-
-If `Times()` is omitted, the cardinality is assumed to be:
-
-  * `Times(1)` when there is neither `WillOnce()` nor `WillRepeatedly()`;
-  * `Times(n)` when there are `n WillOnce()`s but no `WillRepeatedly()`, where `n` >= 1; or
-  * `Times(AtLeast(n))` when there are `n WillOnce()`s and a `WillRepeatedly()`, where `n` >= 0.
-
-A method with no `EXPECT_CALL()` is free to be invoked _any number of times_, and the default action will be taken each time.
-
-# Matchers #
-
-A **matcher** matches a _single_ argument.  You can use it inside
-`ON_CALL()` or `EXPECT_CALL()`, or use it to validate a value
-directly:
-
-| `EXPECT_THAT(value, matcher)` | Asserts that `value` matches `matcher`. |
-|:------------------------------|:----------------------------------------|
-| `ASSERT_THAT(value, matcher)` | The same as `EXPECT_THAT(value, matcher)`, except that it generates a **fatal** failure. |
-
-Built-in matchers (where `argument` is the function argument) are
-divided into several categories:
-
-## Wildcard ##
-|`_`|`argument` can be any value of the correct type.|
-|:--|:-----------------------------------------------|
-|`A<type>()` or `An<type>()`|`argument` can be any value of type `type`.     |
-
-## Generic Comparison ##
-
-|`Eq(value)` or `value`|`argument == value`|
-|:---------------------|:------------------|
-|`Ge(value)`           |`argument >= value`|
-|`Gt(value)`           |`argument > value` |
-|`Le(value)`           |`argument <= value`|
-|`Lt(value)`           |`argument < value` |
-|`Ne(value)`           |`argument != value`|
-|`IsNull()`            |`argument` is a `NULL` pointer (raw or smart).|
-|`NotNull()`           |`argument` is a non-null pointer (raw or smart).|
-|`Ref(variable)`       |`argument` is a reference to `variable`.|
-|`TypedEq<type>(value)`|`argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded.|
-
-Except `Ref()`, these matchers make a _copy_ of `value` in case it's
-modified or destructed later. If the compiler complains that `value`
-doesn't have a public copy constructor, try wrap it in `ByRef()`,
-e.g. `Eq(ByRef(non_copyable_value))`. If you do that, make sure
-`non_copyable_value` is not changed afterwards, or the meaning of your
-matcher will be changed.
-
-## Floating-Point Matchers ##
-
-|`DoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as unequal.|
-|:-------------------|:----------------------------------------------------------------------------------------------|
-|`FloatEq(a_float)`  |`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal.  |
-|`NanSensitiveDoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal.  |
-|`NanSensitiveFloatEq(a_float)`|`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal.    |
-
-These matchers use ULP-based comparison (the same as used in
-[Google Test](http://code.google.com/p/googletest/)). They
-automatically pick a reasonable error bound based on the absolute
-value of the expected value.  `DoubleEq()` and `FloatEq()` conform to
-the IEEE standard, which requires comparing two NaNs for equality to
-return false. The `NanSensitive*` version instead treats two NaNs as
-equal, which is often what a user wants.
-
-## String Matchers ##
-
-The `argument` can be either a C string or a C++ string object:
-
-|`ContainsRegex(string)`|`argument` matches the given regular expression.|
-|:----------------------|:-----------------------------------------------|
-|`EndsWith(suffix)`     |`argument` ends with string `suffix`.           |
-|`HasSubstr(string)`    |`argument` contains `string` as a sub-string.   |
-|`MatchesRegex(string)` |`argument` matches the given regular expression with the match starting at the first character and ending at the last character.|
-|`StartsWith(prefix)`   |`argument` starts with string `prefix`.         |
-|`StrCaseEq(string)`    |`argument` is equal to `string`, ignoring case. |
-|`StrCaseNe(string)`    |`argument` is not equal to `string`, ignoring case.|
-|`StrEq(string)`        |`argument` is equal to `string`.                |
-|`StrNe(string)`        |`argument` is not equal to `string`.            |
-
-`ContainsRegex()` and `MatchesRegex()` use the regular expression
-syntax defined
-[here](http://code.google.com/p/googletest/wiki/V1_6_AdvancedGuide#Regular_Expression_Syntax).
-`StrCaseEq()`, `StrCaseNe()`, `StrEq()`, and `StrNe()` work for wide
-strings as well.
-
-## Container Matchers ##
-
-Most STL-style containers support `==`, so you can use
-`Eq(expected_container)` or simply `expected_container` to match a
-container exactly.   If you want to write the elements in-line,
-match them more flexibly, or get more informative messages, you can use:
-
-| `Contains(e)` | `argument` contains an element that matches `e`, which can be either a value or a matcher. |
-|:--------------|:-------------------------------------------------------------------------------------------|
-| `Each(e)`     | `argument` is a container where _every_ element matches `e`, which can be either a value or a matcher. |
-| `ElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, where the i-th element matches `ei`, which can be a value or a matcher. 0 to 10 arguments are allowed. |
-| `ElementsAreArray(array)` or `ElementsAreArray(array, count)` | The same as `ElementsAre()` except that the expected element values/matchers come from a C-style array. |
-| `ContainerEq(container)` | The same as `Eq(container)` except that the failure message also includes which elements are in one container but not the other. |
-| `Pointwise(m, container)` | `argument` contains the same number of elements as in `container`, and for all i, (the i-th element in `argument`, the i-th element in `container`) match `m`, which is a matcher on 2-tuples. E.g. `Pointwise(Le(), upper_bounds)` verifies that each element in `argument` doesn't exceed the corresponding element in `upper_bounds`. |
-
-These matchers can also match:
-
-  1. a native array passed by reference (e.g. in `Foo(const int (&a)[5])`), and
-  1. an array passed as a pointer and a count (e.g. in `Bar(const T* buffer, int len)` -- see [Multi-argument Matchers](#Multiargument_Matchers.md)).
-
-where the array may be multi-dimensional (i.e. its elements can be arrays).
-
-## Member Matchers ##
-
-|`Field(&class::field, m)`|`argument.field` (or `argument->field` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
-|:------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------|
-|`Key(e)`                 |`argument.first` matches `e`, which can be either a value or a matcher. E.g. `Contains(Key(Le(5)))` can verify that a `map` contains a key `<= 5`.|
-|`Pair(m1, m2)`           |`argument` is an `std::pair` whose `first` field matches `m1` and `second` field matches `m2`.                                                |
-|`Property(&class::property, m)`|`argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
-
-## Matching the Result of a Function or Functor ##
-
-|`ResultOf(f, m)`|`f(argument)` matches matcher `m`, where `f` is a function or functor.|
-|:---------------|:---------------------------------------------------------------------|
-
-## Pointer Matchers ##
-
-|`Pointee(m)`|`argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`.|
-|:-----------|:-----------------------------------------------------------------------------------------------|
-
-## Multiargument Matchers ##
-
-Technically, all matchers match a _single_ value. A "multi-argument"
-matcher is just one that matches a _tuple_. The following matchers can
-be used to match a tuple `(x, y)`:
-
-|`Eq()`|`x == y`|
-|:-----|:-------|
-|`Ge()`|`x >= y`|
-|`Gt()`|`x > y` |
-|`Le()`|`x <= y`|
-|`Lt()`|`x < y` |
-|`Ne()`|`x != y`|
-
-You can use the following selectors to pick a subset of the arguments
-(or reorder them) to participate in the matching:
-
-|`AllArgs(m)`|Equivalent to `m`. Useful as syntactic sugar in `.With(AllArgs(m))`.|
-|:-----------|:-------------------------------------------------------------------|
-|`Args<N1, N2, ..., Nk>(m)`|The tuple of the `k` selected (using 0-based indices) arguments matches `m`, e.g. `Args<1, 2>(Eq())`.|
-
-## Composite Matchers ##
-
-You can make a matcher from one or more other matchers:
-
-|`AllOf(m1, m2, ..., mn)`|`argument` matches all of the matchers `m1` to `mn`.|
-|:-----------------------|:---------------------------------------------------|
-|`AnyOf(m1, m2, ..., mn)`|`argument` matches at least one of the matchers `m1` to `mn`.|
-|`Not(m)`                |`argument` doesn't match matcher `m`.               |
-
-## Adapters for Matchers ##
-
-|`MatcherCast<T>(m)`|casts matcher `m` to type `Matcher<T>`.|
-|:------------------|:--------------------------------------|
-|`SafeMatcherCast<T>(m)`| [safely casts](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Casting_Matchers) matcher `m` to type `Matcher<T>`. |
-|`Truly(predicate)` |`predicate(argument)` returns something considered by C++ to be true, where `predicate` is a function or functor.|
-
-## Matchers as Predicates ##
-
-|`Matches(m)(value)`|evaluates to `true` if `value` matches `m`. You can use `Matches(m)` alone as a unary functor.|
-|:------------------|:---------------------------------------------------------------------------------------------|
-|`ExplainMatchResult(m, value, result_listener)`|evaluates to `true` if `value` matches `m`, explaining the result to `result_listener`.       |
-|`Value(value, m)`  |evaluates to `true` if `value` matches `m`.                                                   |
-
-## Defining Matchers ##
-
-| `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. |
-|:-------------------------------------------------|:------------------------------------------------------|
-| `MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; }` | Defines a macher `IsDivisibleBy(n)` to match a number divisible by `n`. |
-| `MATCHER_P2(IsBetween, a, b, std::string(negation ? "isn't" : "is") + " between " + PrintToString(a) + " and " + PrintToString(b)) { return a <= arg && arg <= b; }` | Defines a matcher `IsBetween(a, b)` to match a value in the range [`a`, `b`]. |
-
-**Notes:**
-
-  1. The `MATCHER*` macros cannot be used inside a function or class.
-  1. The matcher body must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters).
-  1. You can use `PrintToString(x)` to convert a value `x` of any type to a string.
-
-## Matchers as Test Assertions ##
-
-|`ASSERT_THAT(expression, m)`|Generates a [fatal failure](http://code.google.com/p/googletest/wiki/V1_6_Primer#Assertions) if the value of `expression` doesn't match matcher `m`.|
-|:---------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------|
-|`EXPECT_THAT(expression, m)`|Generates a non-fatal failure if the value of `expression` doesn't match matcher `m`.                                                               |
-
-# Actions #
-
-**Actions** specify what a mock function should do when invoked.
-
-## Returning a Value ##
-
-|`Return()`|Return from a `void` mock function.|
-|:---------|:----------------------------------|
-|`Return(value)`|Return `value`. If the type of `value` is different to the mock function's return type, `value` is converted to the latter type <i>at the time the expectation is set</i>, not when the action is executed.|
-|`ReturnArg<N>()`|Return the `N`-th (0-based) argument.|
-|`ReturnNew<T>(a1, ..., ak)`|Return `new T(a1, ..., ak)`; a different object is created each time.|
-|`ReturnNull()`|Return a null pointer.             |
-|`ReturnPointee(ptr)`|Return the value pointed to by `ptr`.|
-|`ReturnRef(variable)`|Return a reference to `variable`.  |
-|`ReturnRefOfCopy(value)`|Return a reference to a copy of `value`; the copy lives as long as the action.|
-
-## Side Effects ##
-
-|`Assign(&variable, value)`|Assign `value` to variable.|
-|:-------------------------|:--------------------------|
-| `DeleteArg<N>()`         | Delete the `N`-th (0-based) argument, which must be a pointer. |
-| `SaveArg<N>(pointer)`    | Save the `N`-th (0-based) argument to `*pointer`. |
-| `SaveArgPointee<N>(pointer)` | Save the value pointed to by the `N`-th (0-based) argument to `*pointer`. |
-| `SetArgReferee<N>(value)` |	Assign value to the variable referenced by the `N`-th (0-based) argument. |
-|`SetArgPointee<N>(value)` |Assign `value` to the variable pointed by the `N`-th (0-based) argument.|
-|`SetArgumentPointee<N>(value)`|Same as `SetArgPointee<N>(value)`. Deprecated. Will be removed in v1.7.0.|
-|`SetArrayArgument<N>(first, last)`|Copies the elements in source range [`first`, `last`) to the array pointed to by the `N`-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.|
-|`SetErrnoAndReturn(error, value)`|Set `errno` to `error` and return `value`.|
-|`Throw(exception)`        |Throws the given exception, which can be any copyable value. Available since v1.1.0.|
-
-## Using a Function or a Functor as an Action ##
-
-|`Invoke(f)`|Invoke `f` with the arguments passed to the mock function, where `f` can be a global/static function or a functor.|
-|:----------|:-----------------------------------------------------------------------------------------------------------------|
-|`Invoke(object_pointer, &class::method)`|Invoke the {method on the object with the arguments passed to the mock function.                                  |
-|`InvokeWithoutArgs(f)`|Invoke `f`, which can be a global/static function or a functor. `f` must take no arguments.                       |
-|`InvokeWithoutArgs(object_pointer, &class::method)`|Invoke the method on the object, which takes no arguments.                                                        |
-|`InvokeArgument<N>(arg1, arg2, ..., argk)`|Invoke the mock function's `N`-th (0-based) argument, which must be a function or a functor, with the `k` arguments.|
-
-The return value of the invoked function is used as the return value
-of the action.
-
-When defining a function or functor to be used with `Invoke*()`, you can declare any unused parameters as `Unused`:
-```
-  double Distance(Unused, double x, double y) { return sqrt(x*x + y*y); }
-  ...
-  EXPECT_CALL(mock, Foo("Hi", _, _)).WillOnce(Invoke(Distance));
-```
-
-In `InvokeArgument<N>(...)`, if an argument needs to be passed by reference, wrap it inside `ByRef()`. For example,
-```
-  InvokeArgument<2>(5, string("Hi"), ByRef(foo))
-```
-calls the mock function's #2 argument, passing to it `5` and `string("Hi")` by value, and `foo` by reference.
-
-## Default Action ##
-
-|`DoDefault()`|Do the default action (specified by `ON_CALL()` or the built-in one).|
-|:------------|:--------------------------------------------------------------------|
-
-**Note:** due to technical reasons, `DoDefault()` cannot be used inside  a composite action - trying to do so will result in a run-time error.
-
-## Composite Actions ##
-
-|`DoAll(a1, a2, ..., an)`|Do all actions `a1` to `an` and return the result of `an` in each invocation. The first `n - 1` sub-actions must return void. |
-|:-----------------------|:-----------------------------------------------------------------------------------------------------------------------------|
-|`IgnoreResult(a)`       |Perform action `a` and ignore its result. `a` must not return void.                                                           |
-|`WithArg<N>(a)`         |Pass the `N`-th (0-based) argument of the mock function to action `a` and perform it.                                         |
-|`WithArgs<N1, N2, ..., Nk>(a)`|Pass the selected (0-based) arguments of the mock function to action `a` and perform it.                                      |
-|`WithoutArgs(a)`        |Perform action `a` without any arguments.                                                                                     |
-
-## Defining Actions ##
-
-| `ACTION(Sum) { return arg0 + arg1; }` | Defines an action `Sum()` to return the sum of the mock function's argument #0 and #1. |
-|:--------------------------------------|:---------------------------------------------------------------------------------------|
-| `ACTION_P(Plus, n) { return arg0 + n; }` | Defines an action `Plus(n)` to return the sum of the mock function's argument #0 and `n`. |
-| `ACTION_Pk(Foo, p1, ..., pk) { statements; }` | Defines a parameterized action `Foo(p1, ..., pk)` to execute the given `statements`.   |
-
-The `ACTION*` macros cannot be used inside a function or class.
-
-# Cardinalities #
-
-These are used in `Times()` to specify how many times a mock function will be called:
-
-|`AnyNumber()`|The function can be called any number of times.|
-|:------------|:----------------------------------------------|
-|`AtLeast(n)` |The call is expected at least `n` times.       |
-|`AtMost(n)`  |The call is expected at most `n` times.        |
-|`Between(m, n)`|The call is expected between `m` and `n` (inclusive) times.|
-|`Exactly(n) or n`|The call is expected exactly `n` times. In particular, the call should never happen when `n` is 0.|
-
-# Expectation Order #
-
-By default, the expectations can be matched in _any_ order.  If some
-or all expectations must be matched in a given order, there are two
-ways to specify it.  They can be used either independently or
-together.
-
-## The After Clause ##
-
-```
-using ::testing::Expectation;
-...
-Expectation init_x = EXPECT_CALL(foo, InitX());
-Expectation init_y = EXPECT_CALL(foo, InitY());
-EXPECT_CALL(foo, Bar())
-    .After(init_x, init_y);
-```
-says that `Bar()` can be called only after both `InitX()` and
-`InitY()` have been called.
-
-If you don't know how many pre-requisites an expectation has when you
-write it, you can use an `ExpectationSet` to collect them:
-
-```
-using ::testing::ExpectationSet;
-...
-ExpectationSet all_inits;
-for (int i = 0; i < element_count; i++) {
-  all_inits += EXPECT_CALL(foo, InitElement(i));
-}
-EXPECT_CALL(foo, Bar())
-    .After(all_inits);
-```
-says that `Bar()` can be called only after all elements have been
-initialized (but we don't care about which elements get initialized
-before the others).
-
-Modifying an `ExpectationSet` after using it in an `.After()` doesn't
-affect the meaning of the `.After()`.
-
-## Sequences ##
-
-When you have a long chain of sequential expectations, it's easier to
-specify the order using **sequences**, which don't require you to given
-each expectation in the chain a different name.  <i>All expected<br>
-calls</i> in the same sequence must occur in the order they are
-specified.
-
-```
-using ::testing::Sequence;
-Sequence s1, s2;
-...
-EXPECT_CALL(foo, Reset())
-    .InSequence(s1, s2)
-    .WillOnce(Return(true));
-EXPECT_CALL(foo, GetSize())
-    .InSequence(s1)
-    .WillOnce(Return(1));
-EXPECT_CALL(foo, Describe(A<const char*>()))
-    .InSequence(s2)
-    .WillOnce(Return("dummy"));
-```
-says that `Reset()` must be called before _both_ `GetSize()` _and_
-`Describe()`, and the latter two can occur in any order.
-
-To put many expectations in a sequence conveniently:
-```
-using ::testing::InSequence;
-{
-  InSequence dummy;
-
-  EXPECT_CALL(...)...;
-  EXPECT_CALL(...)...;
-  ...
-  EXPECT_CALL(...)...;
-}
-```
-says that all expected calls in the scope of `dummy` must occur in
-strict order. The name `dummy` is irrelevant.)
-
-# Verifying and Resetting a Mock #
-
-Google Mock will verify the expectations on a mock object when it is destructed, or you can do it earlier:
-```
-using ::testing::Mock;
-...
-// Verifies and removes the expectations on mock_obj;
-// returns true iff successful.
-Mock::VerifyAndClearExpectations(&mock_obj);
-...
-// Verifies and removes the expectations on mock_obj;
-// also removes the default actions set by ON_CALL();
-// returns true iff successful.
-Mock::VerifyAndClear(&mock_obj);
-```
-
-You can also tell Google Mock that a mock object can be leaked and doesn't
-need to be verified:
-```
-Mock::AllowLeak(&mock_obj);
-```
-
-# Mock Classes #
-
-Google Mock defines a convenient mock class template
-```
-class MockFunction<R(A1, ..., An)> {
- public:
-  MOCK_METHODn(Call, R(A1, ..., An));
-};
-```
-See this [recipe](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Using_Check_Points) for one application of it.
-
-# Flags #
-
-| `--gmock_catch_leaked_mocks=0` | Don't report leaked mock objects as failures. |
-|:-------------------------------|:----------------------------------------------|
-| `--gmock_verbose=LEVEL`        | Sets the default verbosity level (`info`, `warning`, or `error`) of Google Mock messages. |
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CookBook.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CookBook.md
deleted file mode 100644
index f5975a00..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/CookBook.md
+++ /dev/null
@@ -1,3342 +0,0 @@
-
-
-You can find recipes for using Google Mock here. If you haven't yet,
-please read the [ForDummies](V1_6_ForDummies.md) document first to make sure you understand
-the basics.
-
-**Note:** Google Mock lives in the `testing` name space. For
-readability, it is recommended to write `using ::testing::Foo;` once in
-your file before using the name `Foo` defined by Google Mock. We omit
-such `using` statements in this page for brevity, but you should do it
-in your own code.
-
-# Creating Mock Classes #
-
-## Mocking Private or Protected Methods ##
-
-You must always put a mock method definition (`MOCK_METHOD*`) in a
-`public:` section of the mock class, regardless of the method being
-mocked being `public`, `protected`, or `private` in the base class.
-This allows `ON_CALL` and `EXPECT_CALL` to reference the mock function
-from outside of the mock class.  (Yes, C++ allows a subclass to change
-the access level of a virtual function in the base class.)  Example:
-
-```
-class Foo {
- public:
-  ...
-  virtual bool Transform(Gadget* g) = 0;
-
- protected:
-  virtual void Resume();
-
- private:
-  virtual int GetTimeOut();
-};
-
-class MockFoo : public Foo {
- public:
-  ...
-  MOCK_METHOD1(Transform, bool(Gadget* g));
-
-  // The following must be in the public section, even though the
-  // methods are protected or private in the base class.
-  MOCK_METHOD0(Resume, void());
-  MOCK_METHOD0(GetTimeOut, int());
-};
-```
-
-## Mocking Overloaded Methods ##
-
-You can mock overloaded functions as usual. No special attention is required:
-
-```
-class Foo {
-  ...
-
-  // Must be virtual as we'll inherit from Foo.
-  virtual ~Foo();
-
-  // Overloaded on the types and/or numbers of arguments.
-  virtual int Add(Element x);
-  virtual int Add(int times, Element x);
-
-  // Overloaded on the const-ness of this object.
-  virtual Bar& GetBar();
-  virtual const Bar& GetBar() const;
-};
-
-class MockFoo : public Foo {
-  ...
-  MOCK_METHOD1(Add, int(Element x));
-  MOCK_METHOD2(Add, int(int times, Element x);
-
-  MOCK_METHOD0(GetBar, Bar&());
-  MOCK_CONST_METHOD0(GetBar, const Bar&());
-};
-```
-
-**Note:** if you don't mock all versions of the overloaded method, the
-compiler will give you a warning about some methods in the base class
-being hidden. To fix that, use `using` to bring them in scope:
-
-```
-class MockFoo : public Foo {
-  ...
-  using Foo::Add;
-  MOCK_METHOD1(Add, int(Element x));
-  // We don't want to mock int Add(int times, Element x);
-  ...
-};
-```
-
-## Mocking Class Templates ##
-
-To mock a class template, append `_T` to the `MOCK_*` macros:
-
-```
-template <typename Elem>
-class StackInterface {
-  ...
-  // Must be virtual as we'll inherit from StackInterface.
-  virtual ~StackInterface();
-
-  virtual int GetSize() const = 0;
-  virtual void Push(const Elem& x) = 0;
-};
-
-template <typename Elem>
-class MockStack : public StackInterface<Elem> {
-  ...
-  MOCK_CONST_METHOD0_T(GetSize, int());
-  MOCK_METHOD1_T(Push, void(const Elem& x));
-};
-```
-
-## Mocking Nonvirtual Methods ##
-
-Google Mock can mock non-virtual functions to be used in what we call _hi-perf
-dependency injection_.
-
-In this case, instead of sharing a common base class with the real
-class, your mock class will be _unrelated_ to the real class, but
-contain methods with the same signatures.  The syntax for mocking
-non-virtual methods is the _same_ as mocking virtual methods:
-
-```
-// A simple packet stream class.  None of its members is virtual.
-class ConcretePacketStream {
- public:
-  void AppendPacket(Packet* new_packet);
-  const Packet* GetPacket(size_t packet_number) const;
-  size_t NumberOfPackets() const;
-  ...
-};
-
-// A mock packet stream class.  It inherits from no other, but defines
-// GetPacket() and NumberOfPackets().
-class MockPacketStream {
- public:
-  MOCK_CONST_METHOD1(GetPacket, const Packet*(size_t packet_number));
-  MOCK_CONST_METHOD0(NumberOfPackets, size_t());
-  ...
-};
-```
-
-Note that the mock class doesn't define `AppendPacket()`, unlike the
-real class. That's fine as long as the test doesn't need to call it.
-
-Next, you need a way to say that you want to use
-`ConcretePacketStream` in production code, and use `MockPacketStream`
-in tests.  Since the functions are not virtual and the two classes are
-unrelated, you must specify your choice at _compile time_ (as opposed
-to run time).
-
-One way to do it is to templatize your code that needs to use a packet
-stream.  More specifically, you will give your code a template type
-argument for the type of the packet stream.  In production, you will
-instantiate your template with `ConcretePacketStream` as the type
-argument.  In tests, you will instantiate the same template with
-`MockPacketStream`.  For example, you may write:
-
-```
-template <class PacketStream>
-void CreateConnection(PacketStream* stream) { ... }
-
-template <class PacketStream>
-class PacketReader {
- public:
-  void ReadPackets(PacketStream* stream, size_t packet_num);
-};
-```
-
-Then you can use `CreateConnection<ConcretePacketStream>()` and
-`PacketReader<ConcretePacketStream>` in production code, and use
-`CreateConnection<MockPacketStream>()` and
-`PacketReader<MockPacketStream>` in tests.
-
-```
-  MockPacketStream mock_stream;
-  EXPECT_CALL(mock_stream, ...)...;
-  .. set more expectations on mock_stream ...
-  PacketReader<MockPacketStream> reader(&mock_stream);
-  ... exercise reader ...
-```
-
-## Mocking Free Functions ##
-
-It's possible to use Google Mock to mock a free function (i.e. a
-C-style function or a static method).  You just need to rewrite your
-code to use an interface (abstract class).
-
-Instead of calling a free function (say, `OpenFile`) directly,
-introduce an interface for it and have a concrete subclass that calls
-the free function:
-
-```
-class FileInterface {
- public:
-  ...
-  virtual bool Open(const char* path, const char* mode) = 0;
-};
-
-class File : public FileInterface {
- public:
-  ...
-  virtual bool Open(const char* path, const char* mode) {
-    return OpenFile(path, mode);
-  }
-};
-```
-
-Your code should talk to `FileInterface` to open a file.  Now it's
-easy to mock out the function.
-
-This may seem much hassle, but in practice you often have multiple
-related functions that you can put in the same interface, so the
-per-function syntactic overhead will be much lower.
-
-If you are concerned about the performance overhead incurred by
-virtual functions, and profiling confirms your concern, you can
-combine this with the recipe for [mocking non-virtual methods](#Mocking_Nonvirtual_Methods.md).
-
-## Nice Mocks and Strict Mocks ##
-
-If a mock method has no `EXPECT_CALL` spec but is called, Google Mock
-will print a warning about the "uninteresting call". The rationale is:
-
-  * New methods may be added to an interface after a test is written. We shouldn't fail a test just because a method it doesn't know about is called.
-  * However, this may also mean there's a bug in the test, so Google Mock shouldn't be silent either. If the user believes these calls are harmless, he can add an `EXPECT_CALL()` to suppress the warning.
-
-However, sometimes you may want to suppress all "uninteresting call"
-warnings, while sometimes you may want the opposite, i.e. to treat all
-of them as errors. Google Mock lets you make the decision on a
-per-mock-object basis.
-
-Suppose your test uses a mock class `MockFoo`:
-
-```
-TEST(...) {
-  MockFoo mock_foo;
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-}
-```
-
-If a method of `mock_foo` other than `DoThis()` is called, it will be
-reported by Google Mock as a warning. However, if you rewrite your
-test to use `NiceMock<MockFoo>` instead, the warning will be gone,
-resulting in a cleaner test output:
-
-```
-using ::testing::NiceMock;
-
-TEST(...) {
-  NiceMock<MockFoo> mock_foo;
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-}
-```
-
-`NiceMock<MockFoo>` is a subclass of `MockFoo`, so it can be used
-wherever `MockFoo` is accepted.
-
-It also works if `MockFoo`'s constructor takes some arguments, as
-`NiceMock<MockFoo>` "inherits" `MockFoo`'s constructors:
-
-```
-using ::testing::NiceMock;
-
-TEST(...) {
-  NiceMock<MockFoo> mock_foo(5, "hi");  // Calls MockFoo(5, "hi").
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-}
-```
-
-The usage of `StrictMock` is similar, except that it makes all
-uninteresting calls failures:
-
-```
-using ::testing::StrictMock;
-
-TEST(...) {
-  StrictMock<MockFoo> mock_foo;
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-
-  // The test will fail if a method of mock_foo other than DoThis()
-  // is called.
-}
-```
-
-There are some caveats though (I don't like them just as much as the
-next guy, but sadly they are side effects of C++'s limitations):
-
-  1. `NiceMock<MockFoo>` and `StrictMock<MockFoo>` only work 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` and `StrictMock` (e.g. `NiceMock<StrictMock<MockFoo> >`) is **not** supported.
-  1. The constructors of the base mock (`MockFoo`) cannot have arguments passed by non-const reference, which happens to be banned by the [Google C++ style guide](http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml).
-  1. During the constructor or destructor of `MockFoo`, the mock object is _not_ nice or strict.  This may cause surprises if the constructor or destructor calls a mock method on `this` object. (This behavior, however, is consistent with C++'s general rule: if a constructor or destructor calls a virtual method of `this` object, that method is treated as non-virtual.  In other words, to the base class's constructor or destructor, `this` object behaves like an instance of the base class, not the derived class.  This rule is required for safety.  Otherwise a base constructor may use members of a derived class before they are initialized, or a base destructor may use members of a derived class after they have been destroyed.)
-
-Finally, you should be **very cautious** when using this feature, as the
-decision you make applies to **all** future changes to the mock
-class. If an important change is made in the interface you are mocking
-(and thus in the mock class), it could break your tests (if you use
-`StrictMock`) or let bugs pass through without a warning (if you use
-`NiceMock`). Therefore, try to specify the mock's behavior using
-explicit `EXPECT_CALL` first, and only turn to `NiceMock` or
-`StrictMock` as the last resort.
-
-## Simplifying the Interface without Breaking Existing Code ##
-
-Sometimes a method has a long list of arguments that is mostly
-uninteresting. For example,
-
-```
-class LogSink {
- public:
-  ...
-  virtual void send(LogSeverity severity, const char* full_filename,
-                    const char* base_filename, int line,
-                    const struct tm* tm_time,
-                    const char* message, size_t message_len) = 0;
-};
-```
-
-This method's argument list is lengthy and hard to work with (let's
-say that the `message` argument is not even 0-terminated). If we mock
-it as is, using the mock will be awkward. If, however, we try to
-simplify this interface, we'll need to fix all clients depending on
-it, which is often infeasible.
-
-The trick is to re-dispatch the method in the mock class:
-
-```
-class ScopedMockLog : public LogSink {
- public:
-  ...
-  virtual void send(LogSeverity severity, const char* full_filename,
-                    const char* base_filename, int line, const tm* tm_time,
-                    const char* message, size_t message_len) {
-    // We are only interested in the log severity, full file name, and
-    // log message.
-    Log(severity, full_filename, std::string(message, message_len));
-  }
-
-  // Implements the mock method:
-  //
-  //   void Log(LogSeverity severity,
-  //            const string& file_path,
-  //            const string& message);
-  MOCK_METHOD3(Log, void(LogSeverity severity, const string& file_path,
-                         const string& message));
-};
-```
-
-By defining a new mock method with a trimmed argument list, we make
-the mock class much more user-friendly.
-
-## Alternative to Mocking Concrete Classes ##
-
-Often you may find yourself using classes that don't implement
-interfaces. In order to test your code that uses such a class (let's
-call it `Concrete`), you may be tempted to make the methods of
-`Concrete` virtual and then mock it.
-
-Try not to do that.
-
-Making a non-virtual function virtual is a big decision. It creates an
-extension point where subclasses can tweak your class' behavior. This
-weakens your control on the class because now it's harder to maintain
-the class' invariants. You should make a function virtual only when
-there is a valid reason for a subclass to override it.
-
-Mocking concrete classes directly is problematic as it creates a tight
-coupling between the class and the tests - any small change in the
-class may invalidate your tests and make test maintenance a pain.
-
-To avoid such problems, many programmers have been practicing "coding
-to interfaces": instead of talking to the `Concrete` class, your code
-would define an interface and talk to it. Then you implement that
-interface as an adaptor on top of `Concrete`. In tests, you can easily
-mock that interface to observe how your code is doing.
-
-This technique incurs some overhead:
-
-  * You pay the cost of virtual function calls (usually not a problem).
-  * There is more abstraction for the programmers to learn.
-
-However, it can also bring significant benefits in addition to better
-testability:
-
-  * `Concrete`'s API may not fit your problem domain very well, as you may not be the only client it tries to serve. By designing your own interface, you have a chance to tailor it to your need - you may add higher-level functionalities, rename stuff, etc instead of just trimming the class. This allows you to write your code (user of the interface) in a more natural way, which means it will be more readable, more maintainable, and you'll be more productive.
-  * If `Concrete`'s implementation ever has to change, you don't have to rewrite everywhere it is used. Instead, you can absorb the change in your implementation of the interface, and your other code and tests will be insulated from this change.
-
-Some people worry that if everyone is practicing this technique, they
-will end up writing lots of redundant code. This concern is totally
-understandable. However, there are two reasons why it may not be the
-case:
-
-  * Different projects may need to use `Concrete` in different ways, so the best interfaces for them will be different. Therefore, each of them will have its own domain-specific interface on top of `Concrete`, and they will not be the same code.
-  * If enough projects want to use the same interface, they can always share it, just like they have been sharing `Concrete`. You can check in the interface and the adaptor somewhere near `Concrete` (perhaps in a `contrib` sub-directory) and let many projects use it.
-
-You need to weigh the pros and cons carefully for your particular
-problem, but I'd like to assure you that the Java community has been
-practicing this for a long time and it's a proven effective technique
-applicable in a wide variety of situations. :-)
-
-## Delegating Calls to a Fake ##
-
-Some times you have a non-trivial fake implementation of an
-interface. For example:
-
-```
-class Foo {
- public:
-  virtual ~Foo() {}
-  virtual char DoThis(int n) = 0;
-  virtual void DoThat(const char* s, int* p) = 0;
-};
-
-class FakeFoo : public Foo {
- public:
-  virtual char DoThis(int n) {
-    return (n > 0) ? '+' :
-        (n < 0) ? '-' : '0';
-  }
-
-  virtual void DoThat(const char* s, int* p) {
-    *p = strlen(s);
-  }
-};
-```
-
-Now you want to mock this interface such that you can set expectations
-on it. However, you also want to use `FakeFoo` for the default
-behavior, as duplicating it in the mock object is, well, a lot of
-work.
-
-When you define the mock class using Google Mock, you can have it
-delegate its default action to a fake class you already have, using
-this pattern:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-class MockFoo : public Foo {
- public:
-  // Normal mock method definitions using Google Mock.
-  MOCK_METHOD1(DoThis, char(int n));
-  MOCK_METHOD2(DoThat, void(const char* s, int* p));
-
-  // Delegates the default actions of the methods to a FakeFoo object.
-  // This must be called *before* the custom ON_CALL() statements.
-  void DelegateToFake() {
-    ON_CALL(*this, DoThis(_))
-        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThis));
-    ON_CALL(*this, DoThat(_, _))
-        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThat));
-  }
- private:
-  FakeFoo fake_;  // Keeps an instance of the fake in the mock.
-};
-```
-
-With that, you can use `MockFoo` in your tests as usual. Just remember
-that if you don't explicitly set an action in an `ON_CALL()` or
-`EXPECT_CALL()`, the fake will be called upon to do it:
-
-```
-using ::testing::_;
-
-TEST(AbcTest, Xyz) {
-  MockFoo foo;
-  foo.DelegateToFake(); // Enables the fake for delegation.
-
-  // Put your ON_CALL(foo, ...)s here, if any.
-
-  // No action specified, meaning to use the default action.
-  EXPECT_CALL(foo, DoThis(5));
-  EXPECT_CALL(foo, DoThat(_, _));
-
-  int n = 0;
-  EXPECT_EQ('+', foo.DoThis(5));  // FakeFoo::DoThis() is invoked.
-  foo.DoThat("Hi", &n);           // FakeFoo::DoThat() is invoked.
-  EXPECT_EQ(2, n);
-}
-```
-
-**Some tips:**
-
-  * If you want, you can still override the default action by providing your own `ON_CALL()` or using `.WillOnce()` / `.WillRepeatedly()` in `EXPECT_CALL()`.
-  * In `DelegateToFake()`, you only need to delegate the methods whose fake implementation you intend to use.
-  * The general technique discussed here works for overloaded methods, but you'll need to tell the compiler which version you mean. To disambiguate a mock function (the one you specify inside the parentheses of `ON_CALL()`), see the "Selecting Between Overloaded Functions" section on this page; to disambiguate a fake function (the one you place inside `Invoke()`), use a `static_cast` to specify the function's type.
-  * Having to mix a mock and a fake is often a sign of something gone wrong. Perhaps you haven't got used to the interaction-based way of testing yet. Or perhaps your interface is taking on too many roles and should be split up. Therefore, **don't abuse this**. We would only recommend to do it as an intermediate step when you are refactoring your code.
-
-Regarding the tip on mixing a mock and a fake, here's an example on
-why it may be a bad sign: Suppose you have a class `System` for
-low-level system operations. In particular, it does file and I/O
-operations. And suppose you want to test how your code uses `System`
-to do I/O, and you just want the file operations to work normally. If
-you mock out the entire `System` class, you'll have to provide a fake
-implementation for the file operation part, which suggests that
-`System` is taking on too many roles.
-
-Instead, you can define a `FileOps` interface and an `IOOps` interface
-and split `System`'s functionalities into the two. Then you can mock
-`IOOps` without mocking `FileOps`.
-
-## Delegating Calls to a Real Object ##
-
-When using testing doubles (mocks, fakes, stubs, and etc), sometimes
-their behaviors will differ from those of the real objects. This
-difference could be either intentional (as in simulating an error such
-that you can test the error handling code) or unintentional. If your
-mocks have different behaviors than the real objects by mistake, you
-could end up with code that passes the tests but fails in production.
-
-You can use the _delegating-to-real_ technique to ensure that your
-mock has the same behavior as the real object while retaining the
-ability to validate calls. This technique is very similar to the
-delegating-to-fake technique, the difference being that we use a real
-object instead of a fake. Here's an example:
-
-```
-using ::testing::_;
-using ::testing::AtLeast;
-using ::testing::Invoke;
-
-class MockFoo : public Foo {
- public:
-  MockFoo() {
-    // By default, all calls are delegated to the real object.
-    ON_CALL(*this, DoThis())
-        .WillByDefault(Invoke(&real_, &Foo::DoThis));
-    ON_CALL(*this, DoThat(_))
-        .WillByDefault(Invoke(&real_, &Foo::DoThat));
-    ...
-  }
-  MOCK_METHOD0(DoThis, ...);
-  MOCK_METHOD1(DoThat, ...);
-  ...
- private:
-  Foo real_;
-};
-...
-
-  MockFoo mock;
-
-  EXPECT_CALL(mock, DoThis())
-      .Times(3);
-  EXPECT_CALL(mock, DoThat("Hi"))
-      .Times(AtLeast(1));
-  ... use mock in test ...
-```
-
-With this, Google Mock will verify that your code made the right calls
-(with the right arguments, in the right order, called the right number
-of times, etc), and a real object will answer the calls (so the
-behavior will be the same as in production). This gives you the best
-of both worlds.
-
-## Delegating Calls to a Parent Class ##
-
-Ideally, you should code to interfaces, whose methods are all pure
-virtual. In reality, sometimes you do need to mock a virtual method
-that is not pure (i.e, it already has an implementation). For example:
-
-```
-class Foo {
- public:
-  virtual ~Foo();
-
-  virtual void Pure(int n) = 0;
-  virtual int Concrete(const char* str) { ... }
-};
-
-class MockFoo : public Foo {
- public:
-  // Mocking a pure method.
-  MOCK_METHOD1(Pure, void(int n));
-  // Mocking a concrete method.  Foo::Concrete() is shadowed.
-  MOCK_METHOD1(Concrete, int(const char* str));
-};
-```
-
-Sometimes you may want to call `Foo::Concrete()` instead of
-`MockFoo::Concrete()`. Perhaps you want to do it as part of a stub
-action, or perhaps your test doesn't need to mock `Concrete()` at all
-(but it would be oh-so painful to have to define a new mock class
-whenever you don't need to mock one of its methods).
-
-The trick is to leave a back door in your mock class for accessing the
-real methods in the base class:
-
-```
-class MockFoo : public Foo {
- public:
-  // Mocking a pure method.
-  MOCK_METHOD1(Pure, void(int n));
-  // Mocking a concrete method.  Foo::Concrete() is shadowed.
-  MOCK_METHOD1(Concrete, int(const char* str));
-
-  // Use this to call Concrete() defined in Foo.
-  int FooConcrete(const char* str) { return Foo::Concrete(str); }
-};
-```
-
-Now, you can call `Foo::Concrete()` inside an action by:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-...
-  EXPECT_CALL(foo, Concrete(_))
-      .WillOnce(Invoke(&foo, &MockFoo::FooConcrete));
-```
-
-or tell the mock object that you don't want to mock `Concrete()`:
-
-```
-using ::testing::Invoke;
-...
-  ON_CALL(foo, Concrete(_))
-      .WillByDefault(Invoke(&foo, &MockFoo::FooConcrete));
-```
-
-(Why don't we just write `Invoke(&foo, &Foo::Concrete)`? If you do
-that, `MockFoo::Concrete()` will be called (and cause an infinite
-recursion) since `Foo::Concrete()` is virtual. That's just how C++
-works.)
-
-# Using Matchers #
-
-## Matching Argument Values Exactly ##
-
-You can specify exactly which arguments a mock method is expecting:
-
-```
-using ::testing::Return;
-...
-  EXPECT_CALL(foo, DoThis(5))
-      .WillOnce(Return('a'));
-  EXPECT_CALL(foo, DoThat("Hello", bar));
-```
-
-## Using Simple Matchers ##
-
-You can use matchers to match arguments that have a certain property:
-
-```
-using ::testing::Ge;
-using ::testing::NotNull;
-using ::testing::Return;
-...
-  EXPECT_CALL(foo, DoThis(Ge(5)))  // The argument must be >= 5.
-      .WillOnce(Return('a'));
-  EXPECT_CALL(foo, DoThat("Hello", NotNull()));
-  // The second argument must not be NULL.
-```
-
-A frequently used matcher is `_`, which matches anything:
-
-```
-using ::testing::_;
-using ::testing::NotNull;
-...
-  EXPECT_CALL(foo, DoThat(_, NotNull()));
-```
-
-## Combining Matchers ##
-
-You can build complex matchers from existing ones using `AllOf()`,
-`AnyOf()`, and `Not()`:
-
-```
-using ::testing::AllOf;
-using ::testing::Gt;
-using ::testing::HasSubstr;
-using ::testing::Ne;
-using ::testing::Not;
-...
-  // The argument must be > 5 and != 10.
-  EXPECT_CALL(foo, DoThis(AllOf(Gt(5),
-                                Ne(10))));
-
-  // The first argument must not contain sub-string "blah".
-  EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")),
-                          NULL));
-```
-
-## Casting Matchers ##
-
-Google Mock matchers are statically typed, meaning that the compiler
-can catch your mistake if you use a matcher of the wrong type (for
-example, if you use `Eq(5)` to match a `string` argument). Good for
-you!
-
-Sometimes, however, you know what you're doing and want the compiler
-to give you some slack. One example is that you have a matcher for
-`long` and the argument you want to match is `int`. While the two
-types aren't exactly the same, there is nothing really wrong with
-using a `Matcher<long>` to match an `int` - after all, we can first
-convert the `int` argument to a `long` before giving it to the
-matcher.
-
-To support this need, Google Mock gives you the
-`SafeMatcherCast<T>(m)` function. It casts a matcher `m` to type
-`Matcher<T>`. To ensure safety, Google Mock checks that (let `U` be the
-type `m` accepts):
-
-  1. Type `T` can be implicitly cast to type `U`;
-  1. When both `T` and `U` are built-in arithmetic types (`bool`, integers, and floating-point numbers), the conversion from `T` to `U` is not lossy (in other words, any value representable by `T` can also be represented by `U`); and
-  1. When `U` is a reference, `T` must also be a reference (as the underlying matcher may be interested in the address of the `U` value).
-
-The code won't compile if any of these conditions isn't met.
-
-Here's one example:
-
-```
-using ::testing::SafeMatcherCast;
-
-// A base class and a child class.
-class Base { ... };
-class Derived : public Base { ... };
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(DoThis, void(Derived* derived));
-};
-...
-
-  MockFoo foo;
-  // m is a Matcher<Base*> we got from somewhere.
-  EXPECT_CALL(foo, DoThis(SafeMatcherCast<Derived*>(m)));
-```
-
-If you find `SafeMatcherCast<T>(m)` too limiting, you can use a similar
-function `MatcherCast<T>(m)`. The difference is that `MatcherCast` works
-as long as you can `static_cast` type `T` to type `U`.
-
-`MatcherCast` essentially lets you bypass C++'s type system
-(`static_cast` isn't always safe as it could throw away information,
-for example), so be careful not to misuse/abuse it.
-
-## Selecting Between Overloaded Functions ##
-
-If you expect an overloaded function to be called, the compiler may
-need some help on which overloaded version it is.
-
-To disambiguate functions overloaded on the const-ness of this object,
-use the `Const()` argument wrapper.
-
-```
-using ::testing::ReturnRef;
-
-class MockFoo : public Foo {
-  ...
-  MOCK_METHOD0(GetBar, Bar&());
-  MOCK_CONST_METHOD0(GetBar, const Bar&());
-};
-...
-
-  MockFoo foo;
-  Bar bar1, bar2;
-  EXPECT_CALL(foo, GetBar())         // The non-const GetBar().
-      .WillOnce(ReturnRef(bar1));
-  EXPECT_CALL(Const(foo), GetBar())  // The const GetBar().
-      .WillOnce(ReturnRef(bar2));
-```
-
-(`Const()` is defined by Google Mock and returns a `const` reference
-to its argument.)
-
-To disambiguate overloaded functions with the same number of arguments
-but different argument types, you may need to specify the exact type
-of a matcher, either by wrapping your matcher in `Matcher<type>()`, or
-using a matcher whose type is fixed (`TypedEq<type>`, `An<type>()`,
-etc):
-
-```
-using ::testing::An;
-using ::testing::Lt;
-using ::testing::Matcher;
-using ::testing::TypedEq;
-
-class MockPrinter : public Printer {
- public:
-  MOCK_METHOD1(Print, void(int n));
-  MOCK_METHOD1(Print, void(char c));
-};
-
-TEST(PrinterTest, Print) {
-  MockPrinter printer;
-
-  EXPECT_CALL(printer, Print(An<int>()));            // void Print(int);
-  EXPECT_CALL(printer, Print(Matcher<int>(Lt(5))));  // void Print(int);
-  EXPECT_CALL(printer, Print(TypedEq<char>('a')));   // void Print(char);
-
-  printer.Print(3);
-  printer.Print(6);
-  printer.Print('a');
-}
-```
-
-## Performing Different Actions Based on the Arguments ##
-
-When a mock method is called, the _last_ matching expectation that's
-still active will be selected (think "newer overrides older"). So, you
-can make a method do different things depending on its argument values
-like this:
-
-```
-using ::testing::_;
-using ::testing::Lt;
-using ::testing::Return;
-...
-  // The default case.
-  EXPECT_CALL(foo, DoThis(_))
-      .WillRepeatedly(Return('b'));
-
-  // The more specific case.
-  EXPECT_CALL(foo, DoThis(Lt(5)))
-      .WillRepeatedly(Return('a'));
-```
-
-Now, if `foo.DoThis()` is called with a value less than 5, `'a'` will
-be returned; otherwise `'b'` will be returned.
-
-## Matching Multiple Arguments as a Whole ##
-
-Sometimes it's not enough to match the arguments individually. For
-example, we may want to say that the first argument must be less than
-the second argument. The `With()` clause allows us to match
-all arguments of a mock function as a whole. For example,
-
-```
-using ::testing::_;
-using ::testing::Lt;
-using ::testing::Ne;
-...
-  EXPECT_CALL(foo, InRange(Ne(0), _))
-      .With(Lt());
-```
-
-says that the first argument of `InRange()` must not be 0, and must be
-less than the second argument.
-
-The expression inside `With()` must be a matcher of type
-`Matcher<tr1::tuple<A1, ..., An> >`, where `A1`, ..., `An` are the
-types of the function arguments.
-
-You can also write `AllArgs(m)` instead of `m` inside `.With()`. The
-two forms are equivalent, but `.With(AllArgs(Lt()))` is more readable
-than `.With(Lt())`.
-
-You can use `Args<k1, ..., kn>(m)` to match the `n` selected arguments
-(as a tuple) against `m`. For example,
-
-```
-using ::testing::_;
-using ::testing::AllOf;
-using ::testing::Args;
-using ::testing::Lt;
-...
-  EXPECT_CALL(foo, Blah(_, _, _))
-      .With(AllOf(Args<0, 1>(Lt()), Args<1, 2>(Lt())));
-```
-
-says that `Blah()` will be called with arguments `x`, `y`, and `z` where
-`x < y < z`.
-
-As a convenience and example, Google Mock provides some matchers for
-2-tuples, including the `Lt()` matcher above. See the [CheatSheet](V1_6_CheatSheet.md) for
-the complete list.
-
-Note that if you want to pass the arguments to a predicate of your own
-(e.g. `.With(Args<0, 1>(Truly(&MyPredicate)))`), that predicate MUST be
-written to take a `tr1::tuple` as its argument; Google Mock will pass the `n`
-selected arguments as _one_ single tuple to the predicate.
-
-## Using Matchers as Predicates ##
-
-Have you noticed that a matcher is just a fancy predicate that also
-knows how to describe itself? Many existing algorithms take predicates
-as arguments (e.g. those defined in STL's `<algorithm>` header), and
-it would be a shame if Google Mock matchers are not allowed to
-participate.
-
-Luckily, you can use a matcher where a unary predicate functor is
-expected by wrapping it inside the `Matches()` function. For example,
-
-```
-#include <algorithm>
-#include <vector>
-
-std::vector<int> v;
-...
-// How many elements in v are >= 10?
-const int count = count_if(v.begin(), v.end(), Matches(Ge(10)));
-```
-
-Since you can build complex matchers from simpler ones easily using
-Google Mock, this gives you a way to conveniently construct composite
-predicates (doing the same using STL's `<functional>` header is just
-painful). For example, here's a predicate that's satisfied by any
-number that is >= 0, <= 100, and != 50:
-
-```
-Matches(AllOf(Ge(0), Le(100), Ne(50)))
-```
-
-## Using Matchers in Google Test Assertions ##
-
-Since matchers are basically predicates that also know how to describe
-themselves, there is a way to take advantage of them in
-[Google Test](http://code.google.com/p/googletest/) assertions. It's
-called `ASSERT_THAT` and `EXPECT_THAT`:
-
-```
-  ASSERT_THAT(value, matcher);  // Asserts that value matches matcher.
-  EXPECT_THAT(value, matcher);  // The non-fatal version.
-```
-
-For example, in a Google Test test you can write:
-
-```
-#include "gmock/gmock.h"
-
-using ::testing::AllOf;
-using ::testing::Ge;
-using ::testing::Le;
-using ::testing::MatchesRegex;
-using ::testing::StartsWith;
-...
-
-  EXPECT_THAT(Foo(), StartsWith("Hello"));
-  EXPECT_THAT(Bar(), MatchesRegex("Line \\d+"));
-  ASSERT_THAT(Baz(), AllOf(Ge(5), Le(10)));
-```
-
-which (as you can probably guess) executes `Foo()`, `Bar()`, and
-`Baz()`, and verifies that:
-
-  * `Foo()` returns a string that starts with `"Hello"`.
-  * `Bar()` returns a string that matches regular expression `"Line \\d+"`.
-  * `Baz()` returns a number in the range [5, 10].
-
-The nice thing about these macros is that _they read like
-English_. They generate informative messages too. For example, if the
-first `EXPECT_THAT()` above fails, the message will be something like:
-
-```
-Value of: Foo()
-  Actual: "Hi, world!"
-Expected: starts with "Hello"
-```
-
-**Credit:** The idea of `(ASSERT|EXPECT)_THAT` was stolen from the
-[Hamcrest](http://code.google.com/p/hamcrest/) project, which adds
-`assertThat()` to JUnit.
-
-## Using Predicates as Matchers ##
-
-Google Mock provides a built-in set of matchers. In case you find them
-lacking, you can use an arbitray unary predicate function or functor
-as a matcher - as long as the predicate accepts a value of the type
-you want. You do this by wrapping the predicate inside the `Truly()`
-function, for example:
-
-```
-using ::testing::Truly;
-
-int IsEven(int n) { return (n % 2) == 0 ? 1 : 0; }
-...
-
-  // Bar() must be called with an even number.
-  EXPECT_CALL(foo, Bar(Truly(IsEven)));
-```
-
-Note that the predicate function / functor doesn't have to return
-`bool`. It works as long as the return value can be used as the
-condition in statement `if (condition) ...`.
-
-## Matching Arguments that Are Not Copyable ##
-
-When you do an `EXPECT_CALL(mock_obj, Foo(bar))`, Google Mock saves
-away a copy of `bar`. When `Foo()` is called later, Google Mock
-compares the argument to `Foo()` with the saved copy of `bar`. This
-way, you don't need to worry about `bar` being modified or destroyed
-after the `EXPECT_CALL()` is executed. The same is true when you use
-matchers like `Eq(bar)`, `Le(bar)`, and so on.
-
-But what if `bar` cannot be copied (i.e. has no copy constructor)? You
-could define your own matcher function and use it with `Truly()`, as
-the previous couple of recipes have shown. Or, you may be able to get
-away from it if you can guarantee that `bar` won't be changed after
-the `EXPECT_CALL()` is executed. Just tell Google Mock that it should
-save a reference to `bar`, instead of a copy of it. Here's how:
-
-```
-using ::testing::Eq;
-using ::testing::ByRef;
-using ::testing::Lt;
-...
-  // Expects that Foo()'s argument == bar.
-  EXPECT_CALL(mock_obj, Foo(Eq(ByRef(bar))));
-
-  // Expects that Foo()'s argument < bar.
-  EXPECT_CALL(mock_obj, Foo(Lt(ByRef(bar))));
-```
-
-Remember: if you do this, don't change `bar` after the
-`EXPECT_CALL()`, or the result is undefined.
-
-## Validating a Member of an Object ##
-
-Often a mock function takes a reference to object as an argument. When
-matching the argument, you may not want to compare the entire object
-against a fixed object, as that may be over-specification. Instead,
-you may need to validate a certain member variable or the result of a
-certain getter method of the object. You can do this with `Field()`
-and `Property()`. More specifically,
-
-```
-Field(&Foo::bar, m)
-```
-
-is a matcher that matches a `Foo` object whose `bar` member variable
-satisfies matcher `m`.
-
-```
-Property(&Foo::baz, m)
-```
-
-is a matcher that matches a `Foo` object whose `baz()` method returns
-a value that satisfies matcher `m`.
-
-For example:
-
-> | `Field(&Foo::number, Ge(3))` | Matches `x` where `x.number >= 3`. |
-|:-----------------------------|:-----------------------------------|
-> | `Property(&Foo::name, StartsWith("John "))` | Matches `x` where `x.name()` starts with `"John "`. |
-
-Note that in `Property(&Foo::baz, ...)`, method `baz()` must take no
-argument and be declared as `const`.
-
-BTW, `Field()` and `Property()` can also match plain pointers to
-objects. For instance,
-
-```
-Field(&Foo::number, Ge(3))
-```
-
-matches a plain pointer `p` where `p->number >= 3`. If `p` is `NULL`,
-the match will always fail regardless of the inner matcher.
-
-What if you want to validate more than one members at the same time?
-Remember that there is `AllOf()`.
-
-## Validating the Value Pointed to by a Pointer Argument ##
-
-C++ functions often take pointers as arguments. You can use matchers
-like `NULL`, `NotNull()`, and other comparison matchers to match a
-pointer, but what if you want to make sure the value _pointed to_ by
-the pointer, instead of the pointer itself, has a certain property?
-Well, you can use the `Pointee(m)` matcher.
-
-`Pointee(m)` matches a pointer iff `m` matches the value the pointer
-points to. For example:
-
-```
-using ::testing::Ge;
-using ::testing::Pointee;
-...
-  EXPECT_CALL(foo, Bar(Pointee(Ge(3))));
-```
-
-expects `foo.Bar()` to be called with a pointer that points to a value
-greater than or equal to 3.
-
-One nice thing about `Pointee()` is that it treats a `NULL` pointer as
-a match failure, so you can write `Pointee(m)` instead of
-
-```
-  AllOf(NotNull(), Pointee(m))
-```
-
-without worrying that a `NULL` pointer will crash your test.
-
-Also, did we tell you that `Pointee()` works with both raw pointers
-**and** smart pointers (`linked_ptr`, `shared_ptr`, `scoped_ptr`, and
-etc)?
-
-What if you have a pointer to pointer? You guessed it - you can use
-nested `Pointee()` to probe deeper inside the value. For example,
-`Pointee(Pointee(Lt(3)))` matches a pointer that points to a pointer
-that points to a number less than 3 (what a mouthful...).
-
-## Testing a Certain Property of an Object ##
-
-Sometimes you want to specify that an object argument has a certain
-property, but there is no existing matcher that does this. If you want
-good error messages, you should define a matcher. If you want to do it
-quick and dirty, you could get away with writing an ordinary function.
-
-Let's say you have a mock function that takes an object of type `Foo`,
-which has an `int bar()` method and an `int baz()` method, and you
-want to constrain that the argument's `bar()` value plus its `baz()`
-value is a given number. Here's how you can define a matcher to do it:
-
-```
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-
-class BarPlusBazEqMatcher : public MatcherInterface<const Foo&> {
- public:
-  explicit BarPlusBazEqMatcher(int expected_sum)
-      : expected_sum_(expected_sum) {}
-
-  virtual bool MatchAndExplain(const Foo& foo,
-                               MatchResultListener* listener) const {
-    return (foo.bar() + foo.baz()) == expected_sum_;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "bar() + baz() equals " << expected_sum_;
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "bar() + baz() does not equal " << expected_sum_;
-  }
- private:
-  const int expected_sum_;
-};
-
-inline Matcher<const Foo&> BarPlusBazEq(int expected_sum) {
-  return MakeMatcher(new BarPlusBazEqMatcher(expected_sum));
-}
-
-...
-
-  EXPECT_CALL(..., DoThis(BarPlusBazEq(5)))...;
-```
-
-## Matching Containers ##
-
-Sometimes an STL container (e.g. list, vector, map, ...) is passed to
-a mock function and you may want to validate it. Since most STL
-containers support the `==` operator, you can write
-`Eq(expected_container)` or simply `expected_container` to match a
-container exactly.
-
-Sometimes, though, you may want to be more flexible (for example, the
-first element must be an exact match, but the second element can be
-any positive number, and so on). Also, containers used in tests often
-have a small number of elements, and having to define the expected
-container out-of-line is a bit of a hassle.
-
-You can use the `ElementsAre()` matcher in such cases:
-
-```
-using ::testing::_;
-using ::testing::ElementsAre;
-using ::testing::Gt;
-...
-
-  MOCK_METHOD1(Foo, void(const vector<int>& numbers));
-...
-
-  EXPECT_CALL(mock, Foo(ElementsAre(1, Gt(0), _, 5)));
-```
-
-The above matcher says that the container must have 4 elements, which
-must be 1, greater than 0, anything, and 5 respectively.
-
-`ElementsAre()` is overloaded to take 0 to 10 arguments. If more are
-needed, you can place them in a C-style array and use
-`ElementsAreArray()` instead:
-
-```
-using ::testing::ElementsAreArray;
-...
-
-  // ElementsAreArray accepts an array of element values.
-  const int expected_vector1[] = { 1, 5, 2, 4, ... };
-  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector1)));
-
-  // Or, an array of element matchers.
-  Matcher<int> expected_vector2 = { 1, Gt(2), _, 3, ... };
-  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector2)));
-```
-
-In case the array needs to be dynamically created (and therefore the
-array size cannot be inferred by the compiler), you can give
-`ElementsAreArray()` an additional argument to specify the array size:
-
-```
-using ::testing::ElementsAreArray;
-...
-  int* const expected_vector3 = new int[count];
-  ... fill expected_vector3 with values ...
-  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector3, count)));
-```
-
-**Tips:**
-
-  * `ElementAre*()` works with _any_ container that implements the STL iterator concept (i.e. it has a `const_iterator` type and supports `begin()/end()`) and supports `size()`, not just the ones defined in STL. It will even work with container types yet to be written - as long as they follows the above pattern.
-  * You can use nested `ElementAre*()` to match nested (multi-dimensional) containers.
-  * If the container is passed by pointer instead of by reference, just write `Pointee(ElementsAre*(...))`.
-  * The order of elements _matters_ for `ElementsAre*()`. Therefore don't use it with containers whose element order is undefined (e.g. `hash_map`).
-
-## Sharing Matchers ##
-
-Under the hood, a Google Mock matcher object consists of a pointer to
-a ref-counted implementation object. Copying matchers is allowed and
-very efficient, as only the pointer is copied. When the last matcher
-that references the implementation object dies, the implementation
-object will be deleted.
-
-Therefore, if you have some complex matcher that you want to use again
-and again, there is no need to build it everytime. Just assign it to a
-matcher variable and use that variable repeatedly! For example,
-
-```
-  Matcher<int> in_range = AllOf(Gt(5), Le(10));
-  ... use in_range as a matcher in multiple EXPECT_CALLs ...
-```
-
-# Setting Expectations #
-
-## Ignoring Uninteresting Calls ##
-
-If you are not interested in how a mock method is called, just don't
-say anything about it. In this case, if the method is ever called,
-Google Mock will perform its default action to allow the test program
-to continue. If you are not happy with the default action taken by
-Google Mock, you can override it using `DefaultValue<T>::Set()`
-(described later in this document) or `ON_CALL()`.
-
-Please note that once you expressed interest in a particular mock
-method (via `EXPECT_CALL()`), all invocations to it must match some
-expectation. If this function is called but the arguments don't match
-any `EXPECT_CALL()` statement, it will be an error.
-
-## Disallowing Unexpected Calls ##
-
-If a mock method shouldn't be called at all, explicitly say so:
-
-```
-using ::testing::_;
-...
-  EXPECT_CALL(foo, Bar(_))
-      .Times(0);
-```
-
-If some calls to the method are allowed, but the rest are not, just
-list all the expected calls:
-
-```
-using ::testing::AnyNumber;
-using ::testing::Gt;
-...
-  EXPECT_CALL(foo, Bar(5));
-  EXPECT_CALL(foo, Bar(Gt(10)))
-      .Times(AnyNumber());
-```
-
-A call to `foo.Bar()` that doesn't match any of the `EXPECT_CALL()`
-statements will be an error.
-
-## Expecting Ordered Calls ##
-
-Although an `EXPECT_CALL()` statement defined earlier takes precedence
-when Google Mock tries to match a function call with an expectation,
-by default calls don't have to happen in the order `EXPECT_CALL()`
-statements are written. For example, if the arguments match the
-matchers in the third `EXPECT_CALL()`, but not those in the first two,
-then the third expectation will be used.
-
-If you would rather have all calls occur in the order of the
-expectations, put the `EXPECT_CALL()` statements in a block where you
-define a variable of type `InSequence`:
-
-```
-  using ::testing::_;
-  using ::testing::InSequence;
-
-  {
-    InSequence s;
-
-    EXPECT_CALL(foo, DoThis(5));
-    EXPECT_CALL(bar, DoThat(_))
-        .Times(2);
-    EXPECT_CALL(foo, DoThis(6));
-  }
-```
-
-In this example, we expect a call to `foo.DoThis(5)`, followed by two
-calls to `bar.DoThat()` where the argument can be anything, which are
-in turn followed by a call to `foo.DoThis(6)`. If a call occurred
-out-of-order, Google Mock will report an error.
-
-## Expecting Partially Ordered Calls ##
-
-Sometimes requiring everything to occur in a predetermined order can
-lead to brittle tests. For example, we may care about `A` occurring
-before both `B` and `C`, but aren't interested in the relative order
-of `B` and `C`. In this case, the test should reflect our real intent,
-instead of being overly constraining.
-
-Google Mock allows you to impose an arbitrary DAG (directed acyclic
-graph) on the calls. One way to express the DAG is to use the
-[After](http://code.google.com/p/googlemock/wiki/V1_6_CheatSheet#The_After_Clause) clause of `EXPECT_CALL`.
-
-Another way is via the `InSequence()` clause (not the same as the
-`InSequence` class), which we borrowed from jMock 2. It's less
-flexible than `After()`, but more convenient when you have long chains
-of sequential calls, as it doesn't require you to come up with
-different names for the expectations in the chains.  Here's how it
-works:
-
-If we view `EXPECT_CALL()` statements as nodes in a graph, and add an
-edge from node A to node B wherever A must occur before B, we can get
-a DAG. We use the term "sequence" to mean a directed path in this
-DAG. Now, if we decompose the DAG into sequences, we just need to know
-which sequences each `EXPECT_CALL()` belongs to in order to be able to
-reconstruct the orginal DAG.
-
-So, to specify the partial order on the expectations we need to do two
-things: first to define some `Sequence` objects, and then for each
-`EXPECT_CALL()` say which `Sequence` objects it is part
-of. Expectations in the same sequence must occur in the order they are
-written. For example,
-
-```
-  using ::testing::Sequence;
-
-  Sequence s1, s2;
-
-  EXPECT_CALL(foo, A())
-      .InSequence(s1, s2);
-  EXPECT_CALL(bar, B())
-      .InSequence(s1);
-  EXPECT_CALL(bar, C())
-      .InSequence(s2);
-  EXPECT_CALL(foo, D())
-      .InSequence(s2);
-```
-
-specifies the following DAG (where `s1` is `A -> B`, and `s2` is `A ->
-C -> D`):
-
-```
-       +---> B
-       |
-  A ---|
-       |
-       +---> C ---> D
-```
-
-This means that A must occur before B and C, and C must occur before
-D. There's no restriction about the order other than these.
-
-## Controlling When an Expectation Retires ##
-
-When a mock method is called, Google Mock only consider expectations
-that are still active. An expectation is active when created, and
-becomes inactive (aka _retires_) when a call that has to occur later
-has occurred. For example, in
-
-```
-  using ::testing::_;
-  using ::testing::Sequence;
-
-  Sequence s1, s2;
-
-  EXPECT_CALL(log, Log(WARNING, _, "File too large."))     // #1
-      .Times(AnyNumber())
-      .InSequence(s1, s2);
-  EXPECT_CALL(log, Log(WARNING, _, "Data set is empty."))  // #2
-      .InSequence(s1);
-  EXPECT_CALL(log, Log(WARNING, _, "User not found."))     // #3
-      .InSequence(s2);
-```
-
-as soon as either #2 or #3 is matched, #1 will retire. If a warning
-`"File too large."` is logged after this, it will be an error.
-
-Note that an expectation doesn't retire automatically when it's
-saturated. For example,
-
-```
-using ::testing::_;
-...
-  EXPECT_CALL(log, Log(WARNING, _, _));                  // #1
-  EXPECT_CALL(log, Log(WARNING, _, "File too large."));  // #2
-```
-
-says that there will be exactly one warning with the message `"File
-too large."`. If the second warning contains this message too, #2 will
-match again and result in an upper-bound-violated error.
-
-If this is not what you want, you can ask an expectation to retire as
-soon as it becomes saturated:
-
-```
-using ::testing::_;
-...
-  EXPECT_CALL(log, Log(WARNING, _, _));                 // #1
-  EXPECT_CALL(log, Log(WARNING, _, "File too large."))  // #2
-      .RetiresOnSaturation();
-```
-
-Here #2 can be used only once, so if you have two warnings with the
-message `"File too large."`, the first will match #2 and the second
-will match #1 - there will be no error.
-
-# Using Actions #
-
-## Returning References from Mock Methods ##
-
-If a mock function's return type is a reference, you need to use
-`ReturnRef()` instead of `Return()` to return a result:
-
-```
-using ::testing::ReturnRef;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD0(GetBar, Bar&());
-};
-...
-
-  MockFoo foo;
-  Bar bar;
-  EXPECT_CALL(foo, GetBar())
-      .WillOnce(ReturnRef(bar));
-```
-
-## Returning Live Values from Mock Methods ##
-
-The `Return(x)` action saves a copy of `x` when the action is
-_created_, and always returns the same value whenever it's
-executed. Sometimes you may want to instead return the _live_ value of
-`x` (i.e. its value at the time when the action is _executed_.).
-
-If the mock function's return type is a reference, you can do it using
-`ReturnRef(x)`, as shown in the previous recipe ("Returning References
-from Mock Methods"). However, Google Mock doesn't let you use
-`ReturnRef()` in a mock function whose return type is not a reference,
-as doing that usually indicates a user error. So, what shall you do?
-
-You may be tempted to try `ByRef()`:
-
-```
-using testing::ByRef;
-using testing::Return;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD0(GetValue, int());
-};
-...
-  int x = 0;
-  MockFoo foo;
-  EXPECT_CALL(foo, GetValue())
-      .WillRepeatedly(Return(ByRef(x)));
-  x = 42;
-  EXPECT_EQ(42, foo.GetValue());
-```
-
-Unfortunately, it doesn't work here. The above code will fail with error:
-
-```
-Value of: foo.GetValue()
-  Actual: 0
-Expected: 42
-```
-
-The reason is that `Return(value)` converts `value` to the actual
-return type of the mock function at the time when the action is
-_created_, not when it is _executed_. (This behavior was chosen for
-the action to be safe when `value` is a proxy object that references
-some temporary objects.) As a result, `ByRef(x)` is converted to an
-`int` value (instead of a `const int&`) when the expectation is set,
-and `Return(ByRef(x))` will always return 0.
-
-`ReturnPointee(pointer)` was provided to solve this problem
-specifically. It returns the value pointed to by `pointer` at the time
-the action is _executed_:
-
-```
-using testing::ReturnPointee;
-...
-  int x = 0;
-  MockFoo foo;
-  EXPECT_CALL(foo, GetValue())
-      .WillRepeatedly(ReturnPointee(&x));  // Note the & here.
-  x = 42;
-  EXPECT_EQ(42, foo.GetValue());  // This will succeed now.
-```
-
-## Combining Actions ##
-
-Want to do more than one thing when a function is called? That's
-fine. `DoAll()` allow you to do sequence of actions every time. Only
-the return value of the last action in the sequence will be used.
-
-```
-using ::testing::DoAll;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(Bar, bool(int n));
-};
-...
-
-  EXPECT_CALL(foo, Bar(_))
-      .WillOnce(DoAll(action_1,
-                      action_2,
-                      ...
-                      action_n));
-```
-
-## Mocking Side Effects ##
-
-Sometimes a method exhibits its effect not via returning a value but
-via side effects. For example, it may change some global state or
-modify an output argument. To mock side effects, in general you can
-define your own action by implementing `::testing::ActionInterface`.
-
-If all you need to do is to change an output argument, the built-in
-`SetArgPointee()` action is convenient:
-
-```
-using ::testing::SetArgPointee;
-
-class MockMutator : public Mutator {
- public:
-  MOCK_METHOD2(Mutate, void(bool mutate, int* value));
-  ...
-};
-...
-
-  MockMutator mutator;
-  EXPECT_CALL(mutator, Mutate(true, _))
-      .WillOnce(SetArgPointee<1>(5));
-```
-
-In this example, when `mutator.Mutate()` is called, we will assign 5
-to the `int` variable pointed to by argument #1
-(0-based).
-
-`SetArgPointee()` conveniently makes an internal copy of the
-value you pass to it, removing the need to keep the value in scope and
-alive. The implication however is that the value must have a copy
-constructor and assignment operator.
-
-If the mock method also needs to return a value as well, you can chain
-`SetArgPointee()` with `Return()` using `DoAll()`:
-
-```
-using ::testing::_;
-using ::testing::Return;
-using ::testing::SetArgPointee;
-
-class MockMutator : public Mutator {
- public:
-  ...
-  MOCK_METHOD1(MutateInt, bool(int* value));
-};
-...
-
-  MockMutator mutator;
-  EXPECT_CALL(mutator, MutateInt(_))
-      .WillOnce(DoAll(SetArgPointee<0>(5),
-                      Return(true)));
-```
-
-If the output argument is an array, use the
-`SetArrayArgument<N>(first, last)` action instead. It copies the
-elements in source range `[first, last)` to the array pointed to by
-the `N`-th (0-based) argument:
-
-```
-using ::testing::NotNull;
-using ::testing::SetArrayArgument;
-
-class MockArrayMutator : public ArrayMutator {
- public:
-  MOCK_METHOD2(Mutate, void(int* values, int num_values));
-  ...
-};
-...
-
-  MockArrayMutator mutator;
-  int values[5] = { 1, 2, 3, 4, 5 };
-  EXPECT_CALL(mutator, Mutate(NotNull(), 5))
-      .WillOnce(SetArrayArgument<0>(values, values + 5));
-```
-
-This also works when the argument is an output iterator:
-
-```
-using ::testing::_;
-using ::testing::SeArrayArgument;
-
-class MockRolodex : public Rolodex {
- public:
-  MOCK_METHOD1(GetNames, void(std::back_insert_iterator<vector<string> >));
-  ...
-};
-...
-
-  MockRolodex rolodex;
-  vector<string> names;
-  names.push_back("George");
-  names.push_back("John");
-  names.push_back("Thomas");
-  EXPECT_CALL(rolodex, GetNames(_))
-      .WillOnce(SetArrayArgument<0>(names.begin(), names.end()));
-```
-
-## Changing a Mock Object's Behavior Based on the State ##
-
-If you expect a call to change the behavior of a mock object, you can use `::testing::InSequence` to specify different behaviors before and after the call:
-
-```
-using ::testing::InSequence;
-using ::testing::Return;
-
-...
-  {
-    InSequence seq;
-    EXPECT_CALL(my_mock, IsDirty())
-        .WillRepeatedly(Return(true));
-    EXPECT_CALL(my_mock, Flush());
-    EXPECT_CALL(my_mock, IsDirty())
-        .WillRepeatedly(Return(false));
-  }
-  my_mock.FlushIfDirty();
-```
-
-This makes `my_mock.IsDirty()` return `true` before `my_mock.Flush()` is called and return `false` afterwards.
-
-If the behavior change is more complex, you can store the effects in a variable and make a mock method get its return value from that variable:
-
-```
-using ::testing::_;
-using ::testing::SaveArg;
-using ::testing::Return;
-
-ACTION_P(ReturnPointee, p) { return *p; }
-...
-  int previous_value = 0;
-  EXPECT_CALL(my_mock, GetPrevValue())
-      .WillRepeatedly(ReturnPointee(&previous_value));
-  EXPECT_CALL(my_mock, UpdateValue(_))
-      .WillRepeatedly(SaveArg<0>(&previous_value));
-  my_mock.DoSomethingToUpdateValue();
-```
-
-Here `my_mock.GetPrevValue()` will always return the argument of the last `UpdateValue()` call.
-
-## Setting the Default Value for a Return Type ##
-
-If a mock method's return type is a built-in C++ type or pointer, by
-default it will return 0 when invoked. You only need to specify an
-action if this default value doesn't work for you.
-
-Sometimes, you may want to change this default value, or you may want
-to specify a default value for types Google Mock doesn't know
-about. You can do this using the `::testing::DefaultValue` class
-template:
-
-```
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD0(CalculateBar, Bar());
-};
-...
-
-  Bar default_bar;
-  // Sets the default return value for type Bar.
-  DefaultValue<Bar>::Set(default_bar);
-
-  MockFoo foo;
-
-  // We don't need to specify an action here, as the default
-  // return value works for us.
-  EXPECT_CALL(foo, CalculateBar());
-
-  foo.CalculateBar();  // This should return default_bar.
-
-  // Unsets the default return value.
-  DefaultValue<Bar>::Clear();
-```
-
-Please note that changing the default value for a type can make you
-tests hard to understand. We recommend you to use this feature
-judiciously. For example, you may want to make sure the `Set()` and
-`Clear()` calls are right next to the code that uses your mock.
-
-## Setting the Default Actions for a Mock Method ##
-
-You've learned how to change the default value of a given
-type. However, this may be too coarse for your purpose: perhaps you
-have two mock methods with the same return type and you want them to
-have different behaviors. The `ON_CALL()` macro allows you to
-customize your mock's behavior at the method level:
-
-```
-using ::testing::_;
-using ::testing::AnyNumber;
-using ::testing::Gt;
-using ::testing::Return;
-...
-  ON_CALL(foo, Sign(_))
-      .WillByDefault(Return(-1));
-  ON_CALL(foo, Sign(0))
-      .WillByDefault(Return(0));
-  ON_CALL(foo, Sign(Gt(0)))
-      .WillByDefault(Return(1));
-
-  EXPECT_CALL(foo, Sign(_))
-      .Times(AnyNumber());
-
-  foo.Sign(5);   // This should return 1.
-  foo.Sign(-9);  // This should return -1.
-  foo.Sign(0);   // This should return 0.
-```
-
-As you may have guessed, when there are more than one `ON_CALL()`
-statements, the news order take precedence over the older ones. In
-other words, the **last** one that matches the function arguments will
-be used. This matching order allows you to set up the common behavior
-in a mock object's constructor or the test fixture's set-up phase and
-specialize the mock's behavior later.
-
-## Using Functions/Methods/Functors as Actions ##
-
-If the built-in actions don't suit you, you can easily use an existing
-function, method, or functor as an action:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD2(Sum, int(int x, int y));
-  MOCK_METHOD1(ComplexJob, bool(int x));
-};
-
-int CalculateSum(int x, int y) { return x + y; }
-
-class Helper {
- public:
-  bool ComplexJob(int x);
-};
-...
-
-  MockFoo foo;
-  Helper helper;
-  EXPECT_CALL(foo, Sum(_, _))
-      .WillOnce(Invoke(CalculateSum));
-  EXPECT_CALL(foo, ComplexJob(_))
-      .WillOnce(Invoke(&helper, &Helper::ComplexJob));
-
-  foo.Sum(5, 6);       // Invokes CalculateSum(5, 6).
-  foo.ComplexJob(10);  // Invokes helper.ComplexJob(10);
-```
-
-The only requirement is that the type of the function, etc must be
-_compatible_ with the signature of the mock function, meaning that the
-latter's arguments can be implicitly converted to the corresponding
-arguments of the former, and the former's return type can be
-implicitly converted to that of the latter. So, you can invoke
-something whose type is _not_ exactly the same as the mock function,
-as long as it's safe to do so - nice, huh?
-
-## Invoking a Function/Method/Functor Without Arguments ##
-
-`Invoke()` is very useful for doing actions that are more complex. It
-passes the mock function's arguments to the function or functor being
-invoked such that the callee has the full context of the call to work
-with. If the invoked function is not interested in some or all of the
-arguments, it can simply ignore them.
-
-Yet, a common pattern is that a test author wants to invoke a function
-without the arguments of the mock function. `Invoke()` allows her to
-do that using a wrapper function that throws away the arguments before
-invoking an underlining nullary function. Needless to say, this can be
-tedious and obscures the intent of the test.
-
-`InvokeWithoutArgs()` solves this problem. It's like `Invoke()` except
-that it doesn't pass the mock function's arguments to the
-callee. Here's an example:
-
-```
-using ::testing::_;
-using ::testing::InvokeWithoutArgs;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(ComplexJob, bool(int n));
-};
-
-bool Job1() { ... }
-...
-
-  MockFoo foo;
-  EXPECT_CALL(foo, ComplexJob(_))
-      .WillOnce(InvokeWithoutArgs(Job1));
-
-  foo.ComplexJob(10);  // Invokes Job1().
-```
-
-## Invoking an Argument of the Mock Function ##
-
-Sometimes a mock function will receive a function pointer or a functor
-(in other words, a "callable") as an argument, e.g.
-
-```
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD2(DoThis, bool(int n, bool (*fp)(int)));
-};
-```
-
-and you may want to invoke this callable argument:
-
-```
-using ::testing::_;
-...
-  MockFoo foo;
-  EXPECT_CALL(foo, DoThis(_, _))
-      .WillOnce(...);
-  // Will execute (*fp)(5), where fp is the
-  // second argument DoThis() receives.
-```
-
-Arghh, you need to refer to a mock function argument but C++ has no
-lambda (yet), so you have to define your own action. :-( Or do you
-really?
-
-Well, Google Mock has an action to solve _exactly_ this problem:
-
-```
-  InvokeArgument<N>(arg_1, arg_2, ..., arg_m)
-```
-
-will invoke the `N`-th (0-based) argument the mock function receives,
-with `arg_1`, `arg_2`, ..., and `arg_m`. No matter if the argument is
-a function pointer or a functor, Google Mock handles them both.
-
-With that, you could write:
-
-```
-using ::testing::_;
-using ::testing::InvokeArgument;
-...
-  EXPECT_CALL(foo, DoThis(_, _))
-      .WillOnce(InvokeArgument<1>(5));
-  // Will execute (*fp)(5), where fp is the
-  // second argument DoThis() receives.
-```
-
-What if the callable takes an argument by reference? No problem - just
-wrap it inside `ByRef()`:
-
-```
-...
-  MOCK_METHOD1(Bar, bool(bool (*fp)(int, const Helper&)));
-...
-using ::testing::_;
-using ::testing::ByRef;
-using ::testing::InvokeArgument;
-...
-
-  MockFoo foo;
-  Helper helper;
-  ...
-  EXPECT_CALL(foo, Bar(_))
-      .WillOnce(InvokeArgument<0>(5, ByRef(helper)));
-  // ByRef(helper) guarantees that a reference to helper, not a copy of it,
-  // will be passed to the callable.
-```
-
-What if the callable takes an argument by reference and we do **not**
-wrap the argument in `ByRef()`? Then `InvokeArgument()` will _make a
-copy_ of the argument, and pass a _reference to the copy_, instead of
-a reference to the original value, to the callable. This is especially
-handy when the argument is a temporary value:
-
-```
-...
-  MOCK_METHOD1(DoThat, bool(bool (*f)(const double& x, const string& s)));
-...
-using ::testing::_;
-using ::testing::InvokeArgument;
-...
-
-  MockFoo foo;
-  ...
-  EXPECT_CALL(foo, DoThat(_))
-      .WillOnce(InvokeArgument<0>(5.0, string("Hi")));
-  // Will execute (*f)(5.0, string("Hi")), where f is the function pointer
-  // DoThat() receives.  Note that the values 5.0 and string("Hi") are
-  // temporary and dead once the EXPECT_CALL() statement finishes.  Yet
-  // it's fine to perform this action later, since a copy of the values
-  // are kept inside the InvokeArgument action.
-```
-
-## Ignoring an Action's Result ##
-
-Sometimes you have an action that returns _something_, but you need an
-action that returns `void` (perhaps you want to use it in a mock
-function that returns `void`, or perhaps it needs to be used in
-`DoAll()` and it's not the last in the list). `IgnoreResult()` lets
-you do that. For example:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::Return;
-
-int Process(const MyData& data);
-string DoSomething();
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(Abc, void(const MyData& data));
-  MOCK_METHOD0(Xyz, bool());
-};
-...
-
-  MockFoo foo;
-  EXPECT_CALL(foo, Abc(_))
-  // .WillOnce(Invoke(Process));
-  // The above line won't compile as Process() returns int but Abc() needs
-  // to return void.
-      .WillOnce(IgnoreResult(Invoke(Process)));
-
-  EXPECT_CALL(foo, Xyz())
-      .WillOnce(DoAll(IgnoreResult(Invoke(DoSomething)),
-      // Ignores the string DoSomething() returns.
-                      Return(true)));
-```
-
-Note that you **cannot** use `IgnoreResult()` on an action that already
-returns `void`. Doing so will lead to ugly compiler errors.
-
-## Selecting an Action's Arguments ##
-
-Say you have a mock function `Foo()` that takes seven arguments, and
-you have a custom action that you want to invoke when `Foo()` is
-called. Trouble is, the custom action only wants three arguments:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-...
-  MOCK_METHOD7(Foo, bool(bool visible, const string& name, int x, int y,
-                         const map<pair<int, int>, double>& weight,
-                         double min_weight, double max_wight));
-...
-
-bool IsVisibleInQuadrant1(bool visible, int x, int y) {
-  return visible && x >= 0 && y >= 0;
-}
-...
-
-  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
-      .WillOnce(Invoke(IsVisibleInQuadrant1));  // Uh, won't compile. :-(
-```
-
-To please the compiler God, you can to define an "adaptor" that has
-the same signature as `Foo()` and calls the custom action with the
-right arguments:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-bool MyIsVisibleInQuadrant1(bool visible, const string& name, int x, int y,
-                            const map<pair<int, int>, double>& weight,
-                            double min_weight, double max_wight) {
-  return IsVisibleInQuadrant1(visible, x, y);
-}
-...
-
-  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
-      .WillOnce(Invoke(MyIsVisibleInQuadrant1));  // Now it works.
-```
-
-But isn't this awkward?
-
-Google Mock provides a generic _action adaptor_, so you can spend your
-time minding more important business than writing your own
-adaptors. Here's the syntax:
-
-```
-  WithArgs<N1, N2, ..., Nk>(action)
-```
-
-creates an action that passes the arguments of the mock function at
-the given indices (0-based) to the inner `action` and performs
-it. Using `WithArgs`, our original example can be written as:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::WithArgs;
-...
-  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
-      .WillOnce(WithArgs<0, 2, 3>(Invoke(IsVisibleInQuadrant1)));
-      // No need to define your own adaptor.
-```
-
-For better readability, Google Mock also gives you:
-
-  * `WithoutArgs(action)` when the inner `action` takes _no_ argument, and
-  * `WithArg<N>(action)` (no `s` after `Arg`) when the inner `action` takes _one_ argument.
-
-As you may have realized, `InvokeWithoutArgs(...)` is just syntactic
-sugar for `WithoutArgs(Inovke(...))`.
-
-Here are more tips:
-
-  * The inner action used in `WithArgs` and friends does not have to be `Invoke()` -- it can be anything.
-  * You can repeat an argument in the argument list if necessary, e.g. `WithArgs<2, 3, 3, 5>(...)`.
-  * You can change the order of the arguments, e.g. `WithArgs<3, 2, 1>(...)`.
-  * The types of the selected arguments do _not_ have to match the signature of the inner action exactly. It works as long as they can be implicitly converted to the corresponding arguments of the inner action. For example, if the 4-th argument of the mock function is an `int` and `my_action` takes a `double`, `WithArg<4>(my_action)` will work.
-
-## Ignoring Arguments in Action Functions ##
-
-The selecting-an-action's-arguments recipe showed us one way to make a
-mock function and an action with incompatible argument lists fit
-together. The downside is that wrapping the action in
-`WithArgs<...>()` can get tedious for people writing the tests.
-
-If you are defining a function, method, or functor to be used with
-`Invoke*()`, and you are not interested in some of its arguments, an
-alternative to `WithArgs` is to declare the uninteresting arguments as
-`Unused`. This makes the definition less cluttered and less fragile in
-case the types of the uninteresting arguments change. It could also
-increase the chance the action function can be reused. For example,
-given
-
-```
-  MOCK_METHOD3(Foo, double(const string& label, double x, double y));
-  MOCK_METHOD3(Bar, double(int index, double x, double y));
-```
-
-instead of
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-double DistanceToOriginWithLabel(const string& label, double x, double y) {
-  return sqrt(x*x + y*y);
-}
-
-double DistanceToOriginWithIndex(int index, double x, double y) {
-  return sqrt(x*x + y*y);
-}
-...
-
-  EXEPCT_CALL(mock, Foo("abc", _, _))
-      .WillOnce(Invoke(DistanceToOriginWithLabel));
-  EXEPCT_CALL(mock, Bar(5, _, _))
-      .WillOnce(Invoke(DistanceToOriginWithIndex));
-```
-
-you could write
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::Unused;
-
-double DistanceToOrigin(Unused, double x, double y) {
-  return sqrt(x*x + y*y);
-}
-...
-
-  EXEPCT_CALL(mock, Foo("abc", _, _))
-      .WillOnce(Invoke(DistanceToOrigin));
-  EXEPCT_CALL(mock, Bar(5, _, _))
-      .WillOnce(Invoke(DistanceToOrigin));
-```
-
-## Sharing Actions ##
-
-Just like matchers, a Google Mock action object consists of a pointer
-to a ref-counted implementation object. Therefore copying actions is
-also allowed and very efficient. When the last action that references
-the implementation object dies, the implementation object will be
-deleted.
-
-If you have some complex action that you want to use again and again,
-you may not have to build it from scratch everytime. If the action
-doesn't have an internal state (i.e. if it always does the same thing
-no matter how many times it has been called), you can assign it to an
-action variable and use that variable repeatedly. For example:
-
-```
-  Action<bool(int*)> set_flag = DoAll(SetArgPointee<0>(5),
-                                      Return(true));
-  ... use set_flag in .WillOnce() and .WillRepeatedly() ...
-```
-
-However, if the action has its own state, you may be surprised if you
-share the action object. Suppose you have an action factory
-`IncrementCounter(init)` which creates an action that increments and
-returns a counter whose initial value is `init`, using two actions
-created from the same expression and using a shared action will
-exihibit different behaviors. Example:
-
-```
-  EXPECT_CALL(foo, DoThis())
-      .WillRepeatedly(IncrementCounter(0));
-  EXPECT_CALL(foo, DoThat())
-      .WillRepeatedly(IncrementCounter(0));
-  foo.DoThis();  // Returns 1.
-  foo.DoThis();  // Returns 2.
-  foo.DoThat();  // Returns 1 - Blah() uses a different
-                 // counter than Bar()'s.
-```
-
-versus
-
-```
-  Action<int()> increment = IncrementCounter(0);
-
-  EXPECT_CALL(foo, DoThis())
-      .WillRepeatedly(increment);
-  EXPECT_CALL(foo, DoThat())
-      .WillRepeatedly(increment);
-  foo.DoThis();  // Returns 1.
-  foo.DoThis();  // Returns 2.
-  foo.DoThat();  // Returns 3 - the counter is shared.
-```
-
-# Misc Recipes on Using Google Mock #
-
-## Making the Compilation Faster ##
-
-Believe it or not, the _vast majority_ of the time spent on compiling
-a mock class is in generating its constructor and destructor, as they
-perform non-trivial tasks (e.g. verification of the
-expectations). What's more, mock methods with different signatures
-have different types and thus their constructors/destructors need to
-be generated by the compiler separately. As a result, if you mock many
-different types of methods, compiling your mock class can get really
-slow.
-
-If you are experiencing slow compilation, you can move the definition
-of your mock class' constructor and destructor out of the class body
-and into a `.cpp` file. This way, even if you `#include` your mock
-class in N files, the compiler only needs to generate its constructor
-and destructor once, resulting in a much faster compilation.
-
-Let's illustrate the idea using an example. Here's the definition of a
-mock class before applying this recipe:
-
-```
-// File mock_foo.h.
-...
-class MockFoo : public Foo {
- public:
-  // Since we don't declare the constructor or the destructor,
-  // the compiler will generate them in every translation unit
-  // where this mock class is used.
-
-  MOCK_METHOD0(DoThis, int());
-  MOCK_METHOD1(DoThat, bool(const char* str));
-  ... more mock methods ...
-};
-```
-
-After the change, it would look like:
-
-```
-// File mock_foo.h.
-...
-class MockFoo : public Foo {
- public:
-  // The constructor and destructor are declared, but not defined, here.
-  MockFoo();
-  virtual ~MockFoo();
-
-  MOCK_METHOD0(DoThis, int());
-  MOCK_METHOD1(DoThat, bool(const char* str));
-  ... more mock methods ...
-};
-```
-and
-```
-// File mock_foo.cpp.
-#include "path/to/mock_foo.h"
-
-// The definitions may appear trivial, but the functions actually do a
-// lot of things through the constructors/destructors of the member
-// variables used to implement the mock methods.
-MockFoo::MockFoo() {}
-MockFoo::~MockFoo() {}
-```
-
-## Forcing a Verification ##
-
-When it's being destoyed, your friendly mock object will automatically
-verify that all expectations on it have been satisfied, and will
-generate [Google Test](http://code.google.com/p/googletest/) failures
-if not. This is convenient as it leaves you with one less thing to
-worry about. That is, unless you are not sure if your mock object will
-be destoyed.
-
-How could it be that your mock object won't eventually be destroyed?
-Well, it might be created on the heap and owned by the code you are
-testing. Suppose there's a bug in that code and it doesn't delete the
-mock object properly - you could end up with a passing test when
-there's actually a bug.
-
-Using a heap checker is a good idea and can alleviate the concern, but
-its implementation may not be 100% reliable. So, sometimes you do want
-to _force_ Google Mock to verify a mock object before it is
-(hopefully) destructed. You can do this with
-`Mock::VerifyAndClearExpectations(&mock_object)`:
-
-```
-TEST(MyServerTest, ProcessesRequest) {
-  using ::testing::Mock;
-
-  MockFoo* const foo = new MockFoo;
-  EXPECT_CALL(*foo, ...)...;
-  // ... other expectations ...
-
-  // server now owns foo.
-  MyServer server(foo);
-  server.ProcessRequest(...);
-
-  // In case that server's destructor will forget to delete foo,
-  // this will verify the expectations anyway.
-  Mock::VerifyAndClearExpectations(foo);
-}  // server is destroyed when it goes out of scope here.
-```
-
-**Tip:** The `Mock::VerifyAndClearExpectations()` function returns a
-`bool` to indicate whether the verification was successful (`true` for
-yes), so you can wrap that function call inside a `ASSERT_TRUE()` if
-there is no point going further when the verification has failed.
-
-## Using Check Points ##
-
-Sometimes you may want to "reset" a mock object at various check
-points in your test: at each check point, you verify that all existing
-expectations on the mock object have been satisfied, and then you set
-some new expectations on it as if it's newly created. This allows you
-to work with a mock object in "phases" whose sizes are each
-manageable.
-
-One such scenario is that in your test's `SetUp()` function, you may
-want to put the object you are testing into a certain state, with the
-help from a mock object. Once in the desired state, you want to clear
-all expectations on the mock, such that in the `TEST_F` body you can
-set fresh expectations on it.
-
-As you may have figured out, the `Mock::VerifyAndClearExpectations()`
-function we saw in the previous recipe can help you here. Or, if you
-are using `ON_CALL()` to set default actions on the mock object and
-want to clear the default actions as well, use
-`Mock::VerifyAndClear(&mock_object)` instead. This function does what
-`Mock::VerifyAndClearExpectations(&mock_object)` does and returns the
-same `bool`, **plus** it clears the `ON_CALL()` statements on
-`mock_object` too.
-
-Another trick you can use to achieve the same effect is to put the
-expectations in sequences and insert calls to a dummy "check-point"
-function at specific places. Then you can verify that the mock
-function calls do happen at the right time. 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:
-
-```
-using ::testing::MockFunction;
-
-TEST(FooTest, InvokesBarCorrectly) {
-  MyMock mock;
-  // Class MockFunction<F> has exactly one mock method.  It is named
-  // Call() and has type F.
-  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()`.
-
-## Mocking Destructors ##
-
-Sometimes you want to make sure a mock object is destructed at the
-right time, e.g. after `bar->A()` is called but before `bar->B()` is
-called. We already know that you can specify constraints on the order
-of mock function calls, so all we need to do is to mock the destructor
-of the mock function.
-
-This sounds simple, except for one problem: a destructor is a special
-function with special syntax and special semantics, and the
-`MOCK_METHOD0` macro doesn't work for it:
-
-```
-  MOCK_METHOD0(~MockFoo, void());  // Won't compile!
-```
-
-The good news is that you can use a simple pattern to achieve the same
-effect. First, add a mock function `Die()` to your mock class and call
-it in the destructor, like this:
-
-```
-class MockFoo : public Foo {
-  ...
-  // Add the following two lines to the mock class.
-  MOCK_METHOD0(Die, void());
-  virtual ~MockFoo() { Die(); }
-};
-```
-
-(If the name `Die()` clashes with an existing symbol, choose another
-name.) Now, we have translated the problem of testing when a `MockFoo`
-object dies to testing when its `Die()` method is called:
-
-```
-  MockFoo* foo = new MockFoo;
-  MockBar* bar = new MockBar;
-  ...
-  {
-    InSequence s;
-
-    // Expects *foo to die after bar->A() and before bar->B().
-    EXPECT_CALL(*bar, A());
-    EXPECT_CALL(*foo, Die());
-    EXPECT_CALL(*bar, B());
-  }
-```
-
-And that's that.
-
-## Using Google Mock and Threads ##
-
-**IMPORTANT NOTE:** What we describe in this recipe is **ONLY** true on
-platforms where Google Mock is thread-safe. Currently these are only
-platforms that support the pthreads library (this includes Linux and Mac).
-To make it thread-safe on other platforms we only need to implement
-some synchronization operations in `"gtest/internal/gtest-port.h"`.
-
-In a **unit** test, it's best if you could isolate and test a piece of
-code in a single-threaded context. That avoids race conditions and
-dead locks, and makes debugging your test much easier.
-
-Yet many programs are multi-threaded, and sometimes to test something
-we need to pound on it from more than one thread. Google Mock works
-for this purpose too.
-
-Remember the steps for using a mock:
-
-  1. Create a mock object `foo`.
-  1. Set its default actions and expectations using `ON_CALL()` and `EXPECT_CALL()`.
-  1. The code under test calls methods of `foo`.
-  1. Optionally, verify and reset the mock.
-  1. Destroy the mock yourself, or let the code under test destroy it. The destructor will automatically verify it.
-
-If you follow the following simple rules, your mocks and threads can
-live happily togeter:
-
-  * Execute your _test code_ (as opposed to the code being tested) in _one_ thread. This makes your test easy to follow.
-  * Obviously, you can do step #1 without locking.
-  * When doing step #2 and #5, make sure no other thread is accessing `foo`. Obvious too, huh?
-  * #3 and #4 can be done either in one thread or in multiple threads - anyway you want. Google Mock takes care of the locking, so you don't have to do any - unless required by your test logic.
-
-If you violate the rules (for example, if you set expectations on a
-mock while another thread is calling its methods), you get undefined
-behavior. That's not fun, so don't do it.
-
-Google Mock guarantees that the action for a mock function is done in
-the same thread that called the mock function. For example, in
-
-```
-  EXPECT_CALL(mock, Foo(1))
-      .WillOnce(action1);
-  EXPECT_CALL(mock, Foo(2))
-      .WillOnce(action2);
-```
-
-if `Foo(1)` is called in thread 1 and `Foo(2)` is called in thread 2,
-Google Mock will execute `action1` in thread 1 and `action2` in thread
-2.
-
-Google Mock does _not_ impose a sequence on actions performed in
-different threads (doing so may create deadlocks as the actions may
-need to cooperate). This means that the execution of `action1` and
-`action2` in the above example _may_ interleave. If this is a problem,
-you should add proper synchronization logic to `action1` and `action2`
-to make the test thread-safe.
-
-
-Also, remember that `DefaultValue<T>` is a global resource that
-potentially affects _all_ living mock objects in your
-program. Naturally, you won't want to mess with it from multiple
-threads or when there still are mocks in action.
-
-## Controlling How Much Information Google Mock Prints ##
-
-When Google Mock sees something that has the potential of being an
-error (e.g. a mock function with no expectation is called, a.k.a. an
-uninteresting call, which is allowed but perhaps you forgot to
-explicitly ban the call), it prints some warning messages, including
-the arguments of the function and the return value. Hopefully this
-will remind you to take a look and see if there is indeed a problem.
-
-Sometimes you are confident that your tests are correct and may not
-appreciate such friendly messages. Some other times, you are debugging
-your tests or learning about the behavior of the code you are testing,
-and wish you could observe every mock call that happens (including
-argument values and the return value). Clearly, one size doesn't fit
-all.
-
-You can control how much Google Mock tells you using the
-`--gmock_verbose=LEVEL` command-line flag, where `LEVEL` is a string
-with three possible values:
-
-  * `info`: Google Mock will print all informational messages, warnings, and errors (most verbose). At this setting, Google Mock will also log any calls to the `ON_CALL/EXPECT_CALL` macros.
-  * `warning`: Google Mock will print both warnings and errors (less verbose). This is the default.
-  * `error`: Google Mock will print errors only (least verbose).
-
-Alternatively, you can adjust the value of that flag from within your
-tests like so:
-
-```
-  ::testing::FLAGS_gmock_verbose = "error";
-```
-
-Now, judiciously use the right flag to enable Google Mock serve you better!
-
-## Running Tests in Emacs ##
-
-If you build and run your tests in Emacs, the source file locations of
-Google Mock and [Google Test](http://code.google.com/p/googletest/)
-errors will be highlighted. Just press `<Enter>` on one of them and
-you'll be taken to the offending line. Or, you can just type `C-x ``
-to jump to the next error.
-
-To make it even easier, you can add the following lines to your
-`~/.emacs` file:
-
-```
-(global-set-key "\M-m"   'compile)  ; m is for make
-(global-set-key [M-down] 'next-error)
-(global-set-key [M-up]   '(lambda () (interactive) (next-error -1)))
-```
-
-Then you can type `M-m` to start a build, or `M-up`/`M-down` to move
-back and forth between errors.
-
-## Fusing Google Mock Source Files ##
-
-Google Mock's implementation consists of dozens of files (excluding
-its own tests).  Sometimes you may want them to be packaged up in
-fewer files instead, such that you can easily copy them to a new
-machine and start hacking there.  For this we provide an experimental
-Python script `fuse_gmock_files.py` in the `scripts/` directory
-(starting with release 1.2.0).  Assuming you have Python 2.4 or above
-installed on your machine, just go to that directory and run
-```
-python fuse_gmock_files.py OUTPUT_DIR
-```
-
-and you should see an `OUTPUT_DIR` directory being created with files
-`gtest/gtest.h`, `gmock/gmock.h`, and `gmock-gtest-all.cc` in it.
-These three files contain everything you need to use Google Mock (and
-Google Test).  Just copy them to anywhere you want and you are ready
-to write tests and use mocks.  You can use the
-[scrpts/test/Makefile](http://code.google.com/p/googlemock/source/browse/trunk/scripts/test/Makefile) file as an example on how to compile your tests
-against them.
-
-# Extending Google Mock #
-
-## Writing New Matchers Quickly ##
-
-The `MATCHER*` family of macros can be used to define custom matchers
-easily.  The syntax:
-
-```
-MATCHER(name, description_string_expression) { statements; }
-```
-
-will define 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 is a `string`-typed expression that documents
-what the matcher does, and is used to generate the failure message
-when the match fails.  It can (and should) reference the special
-`bool` variable `negation`, and should evaluate to the description of
-the matcher when `negation` is `false`, or that of the matcher's
-negation when `negation` is `true`.
-
-For convenience, we allow the description string to be empty (`""`),
-in which case Google Mock will use the sequence of words in the
-matcher name as the description.
-
-For example:
-```
-MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; }
-```
-allows you to write
-```
-  // Expects mock_foo.Bar(n) to be called where n is divisible by 7.
-  EXPECT_CALL(mock_foo, Bar(IsDivisibleBy7()));
-```
-or,
-```
-using ::testing::Not;
-...
-  EXPECT_THAT(some_expression, IsDivisibleBy7());
-  EXPECT_THAT(some_other_expression, Not(IsDivisibleBy7()));
-```
-If the above assertions fail, they will print something like:
-```
-  Value of: some_expression
-  Expected: is divisible by 7
-    Actual: 27
-...
-  Value of: some_other_expression
-  Expected: not (is divisible by 7)
-    Actual: 21
-```
-where the descriptions `"is divisible by 7"` and `"not (is divisible
-by 7)"` are automatically calculated from the matcher name
-`IsDivisibleBy7`.
-
-As you may have noticed, the auto-generated descriptions (especially
-those for the negation) may not be so great. You can always override
-them with a string expression of your own:
-```
-MATCHER(IsDivisibleBy7, std::string(negation ? "isn't" : "is") +
-                        " divisible by 7") {
-  return (arg % 7) == 0;
-}
-```
-
-Optionally, you can stream additional information to a hidden argument
-named `result_listener` to explain the match result. For example, a
-better definition of `IsDivisibleBy7` is:
-```
-MATCHER(IsDivisibleBy7, "") {
-  if ((arg % 7) == 0)
-    return true;
-
-  *result_listener << "the remainder is " << (arg % 7);
-  return false;
-}
-```
-
-With this definition, the above assertion will give a better message:
-```
-  Value of: some_expression
-  Expected: is divisible by 7
-    Actual: 27 (the remainder is 6)
-```
-
-You should let `MatchAndExplain()` print _any additional information_
-that can help a user understand the match result. Note that it should
-explain why the match succeeds in case of a success (unless it's
-obvious) - this is useful when the matcher is used inside
-`Not()`. There is no need to print the argument value itself, as
-Google Mock already prints it for you.
-
-**Notes:**
-
-  1. 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, `IsDivisibleBy7()` can be used to match any type where the value of `(arg % 7) == 0` can be implicitly converted to a `bool`.  In the `Bar(IsDivisibleBy7())` 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.
-  1. Google Mock doesn't guarantee when or how many times a matcher will be invoked. Therefore the matcher logic must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters). This requirement must be satisfied no matter how you define the matcher (e.g. using one of the methods described in the following recipes). In particular, a matcher can never call a mock function, as that will affect the state of the mock object and Google Mock.
-
-## Writing New Parameterized Matchers Quickly ##
-
-Sometimes you'll want to define a matcher that has parameters.  For that you
-can use the macro:
-```
-MATCHER_P(name, param_name, description_string) { statements; }
-```
-where the description string can be either `""` or a string expression
-that references `negation` and `param_name`.
-
-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`.
-
-Google Mock also provides `MATCHER_P2`, `MATCHER_P3`, ..., up to
-`MATCHER_P10` to support multi-parameter matchers:
-```
-MATCHER_Pk(name, param_1, ..., param_k, description_string) { statements; }
-```
-
-Please note that the custom description string is for a particular
-**instance** of the matcher, where the parameters have been bound to
-actual values.  Therefore usually you'll want the parameter values to
-be part of the description.  Google Mock lets you do that by
-referencing the matcher parameters in the description string
-expression.
-
-For example,
-```
-  using ::testing::PrintToString;
-  MATCHER_P2(InClosedRange, low, hi,
-             std::string(negation ? "isn't" : "is") + " in range [" +
-             PrintToString(low) + ", " + PrintToString(hi) + "]") {
-    return low <= arg && arg <= hi;
-  }
-  ...
-  EXPECT_THAT(3, InClosedRange(4, 6));
-```
-would generate a failure that contains the message:
-```
-  Expected: is in range [4, 6]
-```
-
-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));
-```
-would generate a failure that contains the text:
-```
-  Expected: in closed range (4, 6)
-```
-
-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.  Matchers that don't have a parameter
-or have only one parameter have special types: you can assign `Foo()`
-to a `FooMatcher`-typed variable, and assign `Foo(p)` to a
-`FooMatcherP<p_type>`-typed variable.
-
-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.
-
-You can overload matchers with different numbers of parameters:
-```
-MATCHER_P(Blah, a, description_string_1) { ... }
-MATCHER_P2(Blah, a, b, description_string_2) { ... }
-```
-
-While it's tempting to always use the `MATCHER*` macros when defining
-a new matcher, you should also consider implementing
-`MatcherInterface` or using `MakePolymorphicMatcher()` instead (see
-the recipes that follow), especially if you need to use the matcher a
-lot.  While these approaches require more work, they give you more
-control on the types of the value being matched and the matcher
-parameters, which in general leads to better compiler error messages
-that pay off in the long run.  They also allow overloading matchers
-based on parameter types (as opposed to just based on the number of
-parameters).
-
-## Writing New Monomorphic Matchers ##
-
-A matcher of argument type `T` implements
-`::testing::MatcherInterface<T>` and does two things: it tests whether a
-value of type `T` matches the matcher, and can describe what kind of
-values it matches. The latter ability is used for generating readable
-error messages when expectations are violated.
-
-The interface looks like this:
-
-```
-class MatchResultListener {
- public:
-  ...
-  // Streams x to the underlying ostream; does nothing if the ostream
-  // is NULL.
-  template <typename T>
-  MatchResultListener& operator<<(const T& x);
-
-  // Returns the underlying ostream.
-  ::std::ostream* stream();
-};
-
-template <typename T>
-class MatcherInterface {
- public:
-  virtual ~MatcherInterface();
-
-  // Returns true iff the matcher matches x; also explains the match
-  // result to 'listener'.
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
-
-  // Describes this matcher to an ostream.
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-
-  // Describes the negation of this matcher to an ostream.
-  virtual void DescribeNegationTo(::std::ostream* os) const;
-};
-```
-
-If you need a custom matcher but `Truly()` is not a good option (for
-example, you may not be happy with the way `Truly(predicate)`
-describes itself, or you may want your matcher to be polymorphic as
-`Eq(value)` is), you can define a matcher to do whatever you want in
-two steps: first implement the matcher interface, and then define a
-factory function to create a matcher instance. The second step is not
-strictly needed but it makes the syntax of using the matcher nicer.
-
-For example, you can define a matcher to test whether an `int` is
-divisible by 7 and then use it like this:
-```
-using ::testing::MakeMatcher;
-using ::testing::Matcher;
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-
-class DivisibleBy7Matcher : public MatcherInterface<int> {
- public:
-  virtual bool MatchAndExplain(int n, MatchResultListener* listener) const {
-    return (n % 7) == 0;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "is divisible by 7";
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is not divisible by 7";
-  }
-};
-
-inline Matcher<int> DivisibleBy7() {
-  return MakeMatcher(new DivisibleBy7Matcher);
-}
-...
-
-  EXPECT_CALL(foo, Bar(DivisibleBy7()));
-```
-
-You may improve the matcher message by streaming additional
-information to the `listener` argument in `MatchAndExplain()`:
-
-```
-class DivisibleBy7Matcher : public MatcherInterface<int> {
- public:
-  virtual bool MatchAndExplain(int n,
-                               MatchResultListener* listener) const {
-    const int remainder = n % 7;
-    if (remainder != 0) {
-      *listener << "the remainder is " << remainder;
-    }
-    return remainder == 0;
-  }
-  ...
-};
-```
-
-Then, `EXPECT_THAT(x, DivisibleBy7());` may general a message like this:
-```
-Value of: x
-Expected: is divisible by 7
-  Actual: 23 (the remainder is 2)
-```
-
-## Writing New Polymorphic Matchers ##
-
-You've learned how to write your own matchers in the previous
-recipe. Just one problem: a matcher created using `MakeMatcher()` only
-works for one particular type of arguments. If you want a
-_polymorphic_ matcher that works with arguments of several types (for
-instance, `Eq(x)` can be used to match a `value` as long as `value` ==
-`x` compiles -- `value` and `x` don't have to share the same type),
-you can learn the trick from `"gmock/gmock-matchers.h"` but it's a bit
-involved.
-
-Fortunately, most of the time you can define a polymorphic matcher
-easily with the help of `MakePolymorphicMatcher()`. Here's how you can
-define `NotNull()` as an example:
-
-```
-using ::testing::MakePolymorphicMatcher;
-using ::testing::MatchResultListener;
-using ::testing::NotNull;
-using ::testing::PolymorphicMatcher;
-
-class NotNullMatcher {
- public:
-  // To implement a polymorphic matcher, first define a COPYABLE class
-  // that has three members MatchAndExplain(), DescribeTo(), and
-  // DescribeNegationTo(), like the following.
-
-  // In this example, we want to use NotNull() with any pointer, so
-  // MatchAndExplain() accepts a pointer of any type as its first argument.
-  // In general, you can define MatchAndExplain() as an ordinary method or
-  // a method template, or even overload it.
-  template <typename T>
-  bool MatchAndExplain(T* p,
-                       MatchResultListener* /* listener */) const {
-    return p != NULL;
-  }
-
-  // Describes the property of a value matching this matcher.
-  void DescribeTo(::std::ostream* os) const { *os << "is not NULL"; }
-
-  // Describes the property of a value NOT matching this matcher.
-  void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
-};
-
-// To construct a polymorphic matcher, pass an instance of the class
-// to MakePolymorphicMatcher().  Note the return type.
-inline PolymorphicMatcher<NotNullMatcher> NotNull() {
-  return MakePolymorphicMatcher(NotNullMatcher());
-}
-...
-
-  EXPECT_CALL(foo, Bar(NotNull()));  // The argument must be a non-NULL pointer.
-```
-
-**Note:** Your polymorphic matcher class does **not** need to inherit from
-`MatcherInterface` or any other class, and its methods do **not** need
-to be virtual.
-
-Like in a monomorphic matcher, you may explain the match result by
-streaming additional information to the `listener` argument in
-`MatchAndExplain()`.
-
-## Writing New Cardinalities ##
-
-A cardinality is used in `Times()` to tell Google Mock how many times
-you expect a call to occur. It doesn't have to be exact. For example,
-you can say `AtLeast(5)` or `Between(2, 4)`.
-
-If the built-in set of cardinalities doesn't suit you, you are free to
-define your own by implementing the following interface (in namespace
-`testing`):
-
-```
-class CardinalityInterface {
- public:
-  virtual ~CardinalityInterface();
-
-  // Returns true iff call_count calls will satisfy this cardinality.
-  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
-
-  // Returns true iff call_count calls will saturate this cardinality.
-  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
-
-  // Describes self to an ostream.
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-};
-```
-
-For example, to specify that a call must occur even number of times,
-you can write
-
-```
-using ::testing::Cardinality;
-using ::testing::CardinalityInterface;
-using ::testing::MakeCardinality;
-
-class EvenNumberCardinality : public CardinalityInterface {
- public:
-  virtual bool IsSatisfiedByCallCount(int call_count) const {
-    return (call_count % 2) == 0;
-  }
-
-  virtual bool IsSaturatedByCallCount(int call_count) const {
-    return false;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "called even number of times";
-  }
-};
-
-Cardinality EvenNumber() {
-  return MakeCardinality(new EvenNumberCardinality);
-}
-...
-
-  EXPECT_CALL(foo, Bar(3))
-      .Times(EvenNumber());
-```
-
-## Writing New Actions Quickly ##
-
-If the built-in actions don't work for you, and you find it
-inconvenient to use `Invoke()`, you can use a macro from the `ACTION*`
-family to quickly define a new action that can be used in your code as
-if it's a built-in action.
-
-By writing
-```
-ACTION(name) { statements; }
-```
-in a namespace scope (i.e. not inside a class or function), you will
-define an action with the given name that executes the statements.
-The value returned by `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 as `argK`.  For example:
-```
-ACTION(IncrementArg1) { return ++(*arg1); }
-```
-allows you to write
-```
-... WillOnce(IncrementArg1());
-```
-
-Note that you don't need to specify the types of the mock function
-arguments.  Rest assured that your code is type-safe though:
-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.
-
-Another example:
-```
-ACTION(Foo) {
-  (*arg2)(5);
-  Blah();
-  *arg1 = 0;
-  return arg0;
-}
-```
-defines an action `Foo()` that invokes argument #2 (a function pointer)
-with 5, calls function `Blah()`, sets the value pointed to by argument
-#1 to 0, and returns argument #0.
-
-For more convenience and flexibility, you can also use the following
-pre-defined symbols in the body of `ACTION`:
-
-| `argK_type` | The type of the K-th (0-based) argument of the mock function |
-|:------------|:-------------------------------------------------------------|
-| `args`      | All arguments of the mock function as a tuple                |
-| `args_type` | The type of all arguments of the mock function as a tuple    |
-| `return_type` | The return type of the mock function                         |
-| `function_type` | The type of the mock function                                |
-
-For example, when using an `ACTION` as a stub action for mock function:
-```
-int DoSomething(bool flag, int* ptr);
-```
-we have:
-| **Pre-defined Symbol** | **Is Bound To** |
-|:-----------------------|:----------------|
-| `arg0`                 | the value of `flag` |
-| `arg0_type`            | the type `bool` |
-| `arg1`                 | the value of `ptr` |
-| `arg1_type`            | the type `int*` |
-| `args`                 | the tuple `(flag, ptr)` |
-| `args_type`            | the type `std::tr1::tuple<bool, int*>` |
-| `return_type`          | the type `int`  |
-| `function_type`        | the type `int(bool, int*)` |
-
-## Writing New Parameterized Actions Quickly ##
-
-Sometimes you'll want to parameterize an action you define.  For that
-we have another macro
-```
-ACTION_P(name, param) { statements; }
-```
-
-For example,
-```
-ACTION_P(Add, n) { return arg0 + n; }
-```
-will allow you to write
-```
-// Returns argument #0 + 5.
-... WillOnce(Add(5));
-```
-
-For convenience, we use the term _arguments_ for the values used to
-invoke the mock function, and the term _parameters_ for the values
-used to instantiate an action.
-
-Note that you don't need to provide the type of the parameter either.
-Suppose the parameter is named `param`, you can also use the
-Google-Mock-defined symbol `param_type` to refer to the type of the
-parameter as inferred by the compiler.  For example, in the body of
-`ACTION_P(Add, n)` above, you can write `n_type` for the type of `n`.
-
-Google Mock also provides `ACTION_P2`, `ACTION_P3`, and etc to support
-multi-parameter actions.  For example,
-```
-ACTION_P2(ReturnDistanceTo, x, y) {
-  double dx = arg0 - x;
-  double dy = arg1 - y;
-  return sqrt(dx*dx + dy*dy);
-}
-```
-lets you write
-```
-... WillOnce(ReturnDistanceTo(5.0, 26.5));
-```
-
-You can view `ACTION` as a degenerated parameterized action where the
-number of parameters is 0.
-
-You can also easily define actions overloaded on the number of parameters:
-```
-ACTION_P(Plus, a) { ... }
-ACTION_P2(Plus, a, b) { ... }
-```
-
-## Restricting the Type of an Argument or Parameter in an ACTION ##
-
-For maximum brevity and reusability, the `ACTION*` macros don't ask
-you to provide the types of the mock function arguments and the action
-parameters.  Instead, we let the compiler infer the types for us.
-
-Sometimes, however, we may want to be more explicit about the types.
-There are several tricks to do that.  For example:
-```
-ACTION(Foo) {
-  // Makes sure arg0 can be converted to int.
-  int n = arg0;
-  ... use n instead of arg0 here ...
-}
-
-ACTION_P(Bar, param) {
-  // Makes sure the type of arg1 is const char*.
-  ::testing::StaticAssertTypeEq<const char*, arg1_type>();
-
-  // Makes sure param can be converted to bool.
-  bool flag = param;
-}
-```
-where `StaticAssertTypeEq` is a compile-time assertion in Google Test
-that verifies two types are the same.
-
-## Writing New Action Templates Quickly ##
-
-Sometimes you want to give an action explicit template parameters that
-cannot be inferred from its value parameters.  `ACTION_TEMPLATE()`
-supports 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, where _m_ is between 1 and 10, and _n_ is
-between 0 and 10.  `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,
-                // Note the comma between int and k:
-                HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
-                AND_1_VALUE_PARAMS(output)) {
-  *output = T(std::tr1::get<k>(args));
-}
-```
-
-To create an instance of an action template, write:
-```
-  ActionName<t1, ..., t_m>(v1, ..., v_n)
-```
-where the `t`s are the template arguments and the
-`v`s are the value arguments.  The value argument
-types are inferred by the compiler.  For example:
-```
-using ::testing::_;
-...
-  int n;
-  EXPECT_CALL(mock, Foo(_, _))
-      .WillOnce(DuplicateArg<1, unsigned char>(&n));
-```
-
-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 a two-template-parameter action where the compiler
-is asked to infer the type of `x`?
-
-## Using the ACTION Object's Type ##
-
-If you are writing a function that returns an `ACTION` object, you'll
-need to know its type.  The type depends on the macro used to define
-the action and the parameter types.  The rule is relatively simple:
-| **Given Definition** | **Expression** | **Has Type** |
-|:---------------------|:---------------|:-------------|
-| `ACTION(Foo)`        | `Foo()`        | `FooAction`  |
-| `ACTION_TEMPLATE(Foo, HAS_m_TEMPLATE_PARAMS(...), AND_0_VALUE_PARAMS())` |	`Foo<t1, ..., t_m>()` | `FooAction<t1, ..., t_m>` |
-| `ACTION_P(Bar, param)` | `Bar(int_value)` | `BarActionP<int>` |
-| `ACTION_TEMPLATE(Bar, HAS_m_TEMPLATE_PARAMS(...), AND_1_VALUE_PARAMS(p1))` | `Bar<t1, ..., t_m>(int_value)` | `FooActionP<t1, ..., t_m, int>` |
-| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value, int_value)` | `BazActionP2<bool, int>` |
-| `ACTION_TEMPLATE(Baz, HAS_m_TEMPLATE_PARAMS(...), AND_2_VALUE_PARAMS(p1, p2))` | `Baz<t1, ..., t_m>(bool_value, int_value)` | `FooActionP2<t1, ..., t_m, bool, int>` |
-| ...                  | ...            | ...          |
-
-Note that we have to pick different suffixes (`Action`, `ActionP`,
-`ActionP2`, and etc) for actions with different numbers of value
-parameters, or the action definitions cannot be overloaded on the
-number of them.
-
-## Writing New Monomorphic Actions ##
-
-While the `ACTION*` macros are very convenient, sometimes they are
-inappropriate.  For example, despite the tricks shown in the previous
-recipes, they don't let you directly specify the types of the mock
-function arguments and the action parameters, which in general leads
-to unoptimized compiler error messages that can baffle unfamiliar
-users.  They also don't allow overloading actions based on parameter
-types without jumping through some hoops.
-
-An alternative to the `ACTION*` macros is to implement
-`::testing::ActionInterface<F>`, where `F` is the type of the mock
-function in which the action will be used. For example:
-
-```
-template <typename F>class ActionInterface {
- public:
-  virtual ~ActionInterface();
-
-  // Performs the action.  Result is the return type of function type
-  // F, and ArgumentTuple is the tuple of arguments of F.
-  //
-  // For example, if F is int(bool, const string&), then Result would
-  // be int, and ArgumentTuple would be tr1::tuple<bool, const string&>.
-  virtual Result Perform(const ArgumentTuple& args) = 0;
-};
-
-using ::testing::_;
-using ::testing::Action;
-using ::testing::ActionInterface;
-using ::testing::MakeAction;
-
-typedef int IncrementMethod(int*);
-
-class IncrementArgumentAction : public ActionInterface<IncrementMethod> {
- public:
-  virtual int Perform(const tr1::tuple<int*>& args) {
-    int* p = tr1::get<0>(args);  // Grabs the first argument.
-    return *p++;
-  }
-};
-
-Action<IncrementMethod> IncrementArgument() {
-  return MakeAction(new IncrementArgumentAction);
-}
-...
-
-  EXPECT_CALL(foo, Baz(_))
-      .WillOnce(IncrementArgument());
-
-  int n = 5;
-  foo.Baz(&n);  // Should return 5 and change n to 6.
-```
-
-## Writing New Polymorphic Actions ##
-
-The previous recipe showed you how to define your own action. This is
-all good, except that you need to know the type of the function in
-which the action will be used. Sometimes that can be a problem. For
-example, if you want to use the action in functions with _different_
-types (e.g. like `Return()` and `SetArgPointee()`).
-
-If an action can be used in several types of mock functions, we say
-it's _polymorphic_. The `MakePolymorphicAction()` function template
-makes it easy to define such an action:
-
-```
-namespace testing {
-
-template <typename Impl>
-PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl);
-
-}  // namespace testing
-```
-
-As an example, let's define an action that returns the second argument
-in the mock function's argument list. The first step is to define an
-implementation class:
-
-```
-class ReturnSecondArgumentAction {
- public:
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) const {
-    // To get the i-th (0-based) argument, use tr1::get<i>(args).
-    return tr1::get<1>(args);
-  }
-};
-```
-
-This implementation class does _not_ need to inherit from any
-particular class. What matters is that it must have a `Perform()`
-method template. This method template takes the mock function's
-arguments as a tuple in a **single** argument, and returns the result of
-the action. It can be either `const` or not, but must be invokable
-with exactly one template argument, which is the result type. In other
-words, you must be able to call `Perform<R>(args)` where `R` is the
-mock function's return type and `args` is its arguments in a tuple.
-
-Next, we use `MakePolymorphicAction()` to turn an instance of the
-implementation class into the polymorphic action we need. It will be
-convenient to have a wrapper for this:
-
-```
-using ::testing::MakePolymorphicAction;
-using ::testing::PolymorphicAction;
-
-PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
-  return MakePolymorphicAction(ReturnSecondArgumentAction());
-}
-```
-
-Now, you can use this polymorphic action the same way you use the
-built-in ones:
-
-```
-using ::testing::_;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD2(DoThis, int(bool flag, int n));
-  MOCK_METHOD3(DoThat, string(int x, const char* str1, const char* str2));
-};
-...
-
-  MockFoo foo;
-  EXPECT_CALL(foo, DoThis(_, _))
-      .WillOnce(ReturnSecondArgument());
-  EXPECT_CALL(foo, DoThat(_, _, _))
-      .WillOnce(ReturnSecondArgument());
-  ...
-  foo.DoThis(true, 5);         // Will return 5.
-  foo.DoThat(1, "Hi", "Bye");  // Will return "Hi".
-```
-
-## Teaching Google Mock How to Print Your Values ##
-
-When an uninteresting or unexpected call occurs, Google Mock prints the
-argument values and the stack trace to help you debug.  Assertion
-macros like `EXPECT_THAT` and `EXPECT_EQ` also print the values in
-question when the assertion fails.  Google Mock and Google Test do this using
-Google Test's user-extensible value printer.
-
-This printer knows how to print built-in C++ types, native arrays, STL
-containers, and any type that supports the `<<` operator.  For other
-types, it prints the raw bytes in the value and hopes that you the
-user can figure it out.
-[Google Test's advanced guide](http://code.google.com/p/googletest/wiki/V1_6_AdvancedGuide#Teaching_Google_Test_How_to_Print_Your_Values)
-explains how to extend the printer to do a better job at
-printing your particular type than to dump the bytes.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/Documentation.md
deleted file mode 100644
index dcc9156c..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/Documentation.md
+++ /dev/null
@@ -1,12 +0,0 @@
-This page lists all documentation wiki pages for Google Mock **1.6**
-- **if you use a released version of Google Mock, please read the documentation for that specific version instead.**
-
-  * [ForDummies](V1_6_ForDummies.md) -- start here if you are new to Google Mock.
-  * [CheatSheet](V1_6_CheatSheet.md) -- a quick reference.
-  * [CookBook](V1_6_CookBook.md) -- recipes for doing various tasks using Google Mock.
-  * [FrequentlyAskedQuestions](V1_6_FrequentlyAskedQuestions.md) -- check here before asking a question on the mailing list.
-
-To contribute code to Google Mock, read:
-
-  * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
-  * [Pump Manual](http://code.google.com/p/googletest/wiki/V1_6_PumpManual) -- how we generate some of Google Mock's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/ForDummies.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/ForDummies.md
deleted file mode 100644
index 19ee63ab..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/ForDummies.md
+++ /dev/null
@@ -1,439 +0,0 @@
-
-
-(**Note:** If you get compiler errors that you don't understand, be sure to consult [Google Mock Doctor](http://code.google.com/p/googlemock/wiki/V1_6_FrequentlyAskedQuestions#How_am_I_supposed_to_make_sense_of_these_horrible_template_error).)
-
-# What Is Google C++ Mocking Framework? #
-When you write a prototype or test, often it's not feasible or wise to rely on real objects entirely. A **mock object** implements the same interface as a real object (so it can be used as one), but lets you specify at run time how it will be used and what it should do (which methods will be called? in which order? how many times? with what arguments? what will they return? etc).
-
-**Note:** It is easy to confuse the term _fake objects_ with mock objects. Fakes and mocks actually mean very different things in the Test-Driven Development (TDD) community:
-
-  * **Fake** objects have working implementations, but usually take some shortcut (perhaps to make the operations less expensive), which makes them not suitable for production. An in-memory file system would be an example of a fake.
-  * **Mocks** are objects pre-programmed with _expectations_, which form a specification of the calls they are expected to receive.
-
-If all this seems too abstract for you, don't worry - the most important thing to remember is that a mock allows you to check the _interaction_ between itself and code that uses it. The difference between fakes and mocks will become much clearer once you start to use mocks.
-
-**Google C++ Mocking Framework** (or **Google Mock** for short) is a library (sometimes we also call it a "framework" to make it sound cool) for creating mock classes and using them. It does to C++ what [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/) do to Java.
-
-Using Google Mock involves three basic steps:
-
-  1. Use some simple macros to describe the interface you want to mock, and they will expand to the implementation of your mock class;
-  1. Create some mock objects and specify its expectations and behavior using an intuitive syntax;
-  1. Exercise code that uses the mock objects. Google Mock will catch any violation of the expectations as soon as it arises.
-
-# Why Google Mock? #
-While mock objects help you remove unnecessary dependencies in tests and make them fast and reliable, using mocks manually in C++ is _hard_:
-
-  * Someone has to implement the mocks. The job is usually tedious and error-prone. No wonder people go great distance to avoid it.
-  * The quality of those manually written mocks is a bit, uh, unpredictable. You may see some really polished ones, but you may also see some that were hacked up in a hurry and have all sorts of ad hoc restrictions.
-  * The knowledge you gained from using one mock doesn't transfer to the next.
-
-In contrast, Java and Python programmers have some fine mock frameworks, which automate the creation of mocks. As a result, mocking is a proven effective technique and widely adopted practice in those communities. Having the right tool absolutely makes the difference.
-
-Google Mock was built to help C++ programmers. It was inspired by [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/), but designed with C++'s specifics in mind. It is your friend if any of the following problems is bothering you:
-
-  * You are stuck with a sub-optimal design and wish you had done more prototyping before it was too late, but prototyping in C++ is by no means "rapid".
-  * Your tests are slow as they depend on too many libraries or use expensive resources (e.g. a database).
-  * Your tests are brittle as some resources they use are unreliable (e.g. the network).
-  * You want to test how your code handles a failure (e.g. a file checksum error), but it's not easy to cause one.
-  * You need to make sure that your module interacts with other modules in the right way, but it's hard to observe the interaction; therefore you resort to observing the side effects at the end of the action, which is awkward at best.
-  * You want to "mock out" your dependencies, except that they don't have mock implementations yet; and, frankly, you aren't thrilled by some of those hand-written mocks.
-
-We encourage you to use Google Mock as:
-
-  * a _design_ tool, for it lets you experiment with your interface design early and often. More iterations lead to better designs!
-  * a _testing_ tool to cut your tests' outbound dependencies and probe the interaction between your module and its collaborators.
-
-# Getting Started #
-Using Google Mock is easy! Inside your C++ source file, just `#include` `"gtest/gtest.h"` and `"gmock/gmock.h"`, and you are ready to go.
-
-# A Case for Mock Turtles #
-Let's look at an example. Suppose you are developing a graphics program that relies on a LOGO-like API for drawing. How would you test that it does the right thing? Well, you can run it and compare the screen with a golden screen snapshot, but let's admit it: tests like this are expensive to run and fragile (What if you just upgraded to a shiny new graphics card that has better anti-aliasing? Suddenly you have to update all your golden images.). It would be too painful if all your tests are like this. Fortunately, you learned about Dependency Injection and know the right thing to do: instead of having your application talk to the drawing API directly, wrap the API in an interface (say, `Turtle`) and code to that interface:
-
-```
-class Turtle {
-  ...
-  virtual ~Turtle() {}
-  virtual void PenUp() = 0;
-  virtual void PenDown() = 0;
-  virtual void Forward(int distance) = 0;
-  virtual void Turn(int degrees) = 0;
-  virtual void GoTo(int x, int y) = 0;
-  virtual int GetX() const = 0;
-  virtual int GetY() const = 0;
-};
-```
-
-(Note that the destructor of `Turtle` **must** be virtual, as is the case for **all** classes you intend to inherit from - otherwise the destructor of the derived class will not be called when you delete an object through a base pointer, and you'll get corrupted program states like memory leaks.)
-
-You can control whether the turtle's movement will leave a trace using `PenUp()` and `PenDown()`, and control its movement using `Forward()`, `Turn()`, and `GoTo()`. Finally, `GetX()` and `GetY()` tell you the current position of the turtle.
-
-Your program will normally use a real implementation of this interface. In tests, you can use a mock implementation instead. This allows you to easily check what drawing primitives your program is calling, with what arguments, and in which order. Tests written this way are much more robust (they won't break because your new machine does anti-aliasing differently), easier to read and maintain (the intent of a test is expressed in the code, not in some binary images), and run _much, much faster_.
-
-# Writing the Mock Class #
-If you are lucky, the mocks you need to use have already been implemented by some nice people. If, however, you find yourself in the position to write a mock class, relax - Google Mock turns this task into a fun game! (Well, almost.)
-
-## How to Define It ##
-Using the `Turtle` interface as example, here are the simple steps you need to follow:
-
-  1. Derive a class `MockTurtle` from `Turtle`.
-  1. Take a _virtual_ function of `Turtle` (while it's possible to [mock non-virtual methods using templates](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Mocking_Nonvirtual_Methods), it's much more involved). Count how many arguments it has.
-  1. In the `public:` section of the child class, write `MOCK_METHODn();` (or `MOCK_CONST_METHODn();` if you are mocking a `const` method), where `n` is the number of the arguments; if you counted wrong, shame on you, and a compiler error will tell you so.
-  1. Now comes the fun part: you take the function signature, cut-and-paste the _function name_ as the _first_ argument to the macro, and leave what's left as the _second_ argument (in case you're curious, this is the _type of the function_).
-  1. Repeat until all virtual functions you want to mock are done.
-
-After the process, you should have something like:
-
-```
-#include "gmock/gmock.h"  // Brings in Google Mock.
-class MockTurtle : public Turtle {
- public:
-  ...
-  MOCK_METHOD0(PenUp, void());
-  MOCK_METHOD0(PenDown, void());
-  MOCK_METHOD1(Forward, void(int distance));
-  MOCK_METHOD1(Turn, void(int degrees));
-  MOCK_METHOD2(GoTo, void(int x, int y));
-  MOCK_CONST_METHOD0(GetX, int());
-  MOCK_CONST_METHOD0(GetY, int());
-};
-```
-
-You don't need to define these mock methods somewhere else - the `MOCK_METHOD*` macros will generate the definitions for you. It's that simple! Once you get the hang of it, you can pump out mock classes faster than your source-control system can handle your check-ins.
-
-**Tip:** If even this is too much work for you, you'll find the
-`gmock_gen.py` tool in Google Mock's `scripts/generator/` directory (courtesy of the [cppclean](http://code.google.com/p/cppclean/) project) useful.  This command-line
-tool requires that you have Python 2.4 installed.  You give it a C++ file and the name of an abstract class defined in it,
-and it will print the definition of the mock class for you.  Due to the
-complexity of the C++ language, this script may not always work, but
-it can be quite handy when it does.  For more details, read the [user documentation](http://code.google.com/p/googlemock/source/browse/trunk/scripts/generator/README).
-
-## Where to Put It ##
-When you define a mock class, you need to decide where to put its definition. Some people put it in a `*_test.cc`. This is fine when the interface being mocked (say, `Foo`) is owned by the same person or team. Otherwise, when the owner of `Foo` changes it, your test could break. (You can't really expect `Foo`'s maintainer to fix every test that uses `Foo`, can you?)
-
-So, the rule of thumb is: if you need to mock `Foo` and it's owned by others, define the mock class in `Foo`'s package (better, in a `testing` sub-package such that you can clearly separate production code and testing utilities), and put it in a `mock_foo.h`. Then everyone can reference `mock_foo.h` from their tests. If `Foo` ever changes, there is only one copy of `MockFoo` to change, and only tests that depend on the changed methods need to be fixed.
-
-Another way to do it: you can introduce a thin layer `FooAdaptor` on top of `Foo` and code to this new interface. Since you own `FooAdaptor`, you can absorb changes in `Foo` much more easily. While this is more work initially, carefully choosing the adaptor interface can make your code easier to write and more readable (a net win in the long run), as you can choose `FooAdaptor` to fit your specific domain much better than `Foo` does.
-
-# Using Mocks in Tests #
-Once you have a mock class, using it is easy. The typical work flow is:
-
-  1. Import the Google Mock names from the `testing` namespace such that you can use them unqualified (You only have to do it once per file. Remember that namespaces are a good idea and good for your health.).
-  1. Create some mock objects.
-  1. Specify your expectations on them (How many times will a method be called? With what arguments? What should it do? etc.).
-  1. Exercise some code that uses the mocks; optionally, check the result using Google Test assertions. If a mock method is called more than expected or with wrong arguments, you'll get an error immediately.
-  1. When a mock is destructed, Google Mock will automatically check whether all expectations on it have been satisfied.
-
-Here's an example:
-
-```
-#include "path/to/mock-turtle.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-using ::testing::AtLeast;                     // #1
-
-TEST(PainterTest, CanDrawSomething) {
-  MockTurtle turtle;                          // #2
-  EXPECT_CALL(turtle, PenDown())              // #3
-      .Times(AtLeast(1));
-
-  Painter painter(&turtle);                   // #4
-
-  EXPECT_TRUE(painter.DrawCircle(0, 0, 10));
-}                                             // #5
-
-int main(int argc, char** argv) {
-  // The following line must be executed to initialize Google Mock
-  // (and Google Test) before running the tests.
-  ::testing::InitGoogleMock(&argc, argv);
-  return RUN_ALL_TESTS();
-}
-```
-
-As you might have guessed, this test checks that `PenDown()` is called at least once. If the `painter` object didn't call this method, your test will fail with a message like this:
-
-```
-path/to/my_test.cc:119: Failure
-Actual function call count doesn't match this expectation:
-Actually: never called;
-Expected: called at least once.
-```
-
-**Tip 1:** If you run the test from an Emacs buffer, you can hit `<Enter>` on the line number displayed in the error message to jump right to the failed expectation.
-
-**Tip 2:** If your mock objects are never deleted, the final verification won't happen. Therefore it's a good idea to use a heap leak checker in your tests when you allocate mocks on the heap.
-
-**Important note:** Google Mock requires expectations to be set **before** the mock functions are called, otherwise the behavior is **undefined**. In particular, you mustn't interleave `EXPECT_CALL()`s and calls to the mock functions.
-
-This means `EXPECT_CALL()` should be read as expecting that a call will occur _in the future_, not that a call has occurred. Why does Google Mock work like that? Well, specifying the expectation beforehand allows Google Mock to report a violation as soon as it arises, when the context (stack trace, etc) is still available. This makes debugging much easier.
-
-Admittedly, this test is contrived and doesn't do much. You can easily achieve the same effect without using Google Mock. However, as we shall reveal soon, Google Mock allows you to do _much more_ with the mocks.
-
-## Using Google Mock with Any Testing Framework ##
-If you want to use something other than Google Test (e.g. [CppUnit](http://apps.sourceforge.net/mediawiki/cppunit/index.php?title=Main_Page) or
-[CxxTest](http://cxxtest.tigris.org/)) as your testing framework, just change the `main()` function in the previous section to:
-```
-int main(int argc, char** argv) {
-  // The following line causes Google Mock to throw an exception on failure,
-  // which will be interpreted by your testing framework as a test failure.
-  ::testing::GTEST_FLAG(throw_on_failure) = true;
-  ::testing::InitGoogleMock(&argc, argv);
-  ... whatever your testing framework requires ...
-}
-```
-
-This approach has a catch: it makes Google Mock throw an exception
-from a mock object's destructor sometimes.  With some compilers, this
-sometimes causes the test program to crash.  You'll still be able to
-notice that the test has failed, but it's not a graceful failure.
-
-A better solution is to use Google Test's
-[event listener API](http://code.google.com/p/googletest/wiki/V1_6_AdvancedGuide#Extending_Google_Test_by_Handling_Test_Events)
-to report a test failure to your testing framework properly.  You'll need to
-implement the `OnTestPartResult()` method of the event listener interface, but it
-should be straightforward.
-
-If this turns out to be too much work, we suggest that you stick with
-Google Test, which works with Google Mock seamlessly (in fact, it is
-technically part of Google Mock.).  If there is a reason that you
-cannot use Google Test, please let us know.
-
-# Setting Expectations #
-The key to using a mock object successfully is to set the _right expectations_ on it. If you set the expectations too strict, your test will fail as the result of unrelated changes. If you set them too loose, bugs can slip through. You want to do it just right such that your test can catch exactly the kind of bugs you intend it to catch. Google Mock provides the necessary means for you to do it "just right."
-
-## General Syntax ##
-In Google Mock we use the `EXPECT_CALL()` macro to set an expectation on a mock method. The general syntax is:
-
-```
-EXPECT_CALL(mock_object, method(matchers))
-    .Times(cardinality)
-    .WillOnce(action)
-    .WillRepeatedly(action);
-```
-
-The macro has two arguments: first the mock object, and then the method and its arguments. Note that the two are separated by a comma (`,`), not a period (`.`). (Why using a comma? The answer is that it was necessary for technical reasons.)
-
-The macro can be followed by some optional _clauses_ that provide more information about the expectation. We'll discuss how each clause works in the coming sections.
-
-This syntax is designed to make an expectation read like English. For example, you can probably guess that
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetX())
-    .Times(5)
-    .WillOnce(Return(100))
-    .WillOnce(Return(150))
-    .WillRepeatedly(Return(200));
-```
-
-says that the `turtle` object's `GetX()` method will be called five times, it will return 100 the first time, 150 the second time, and then 200 every time. Some people like to call this style of syntax a Domain-Specific Language (DSL).
-
-**Note:** Why do we use a macro to do this? It serves two purposes: first it makes expectations easily identifiable (either by `grep` or by a human reader), and second it allows Google Mock to include the source file location of a failed expectation in messages, making debugging easier.
-
-## Matchers: What Arguments Do We Expect? ##
-When a mock function takes arguments, we must specify what arguments we are expecting; for example:
-
-```
-// Expects the turtle to move forward by 100 units.
-EXPECT_CALL(turtle, Forward(100));
-```
-
-Sometimes you may not want to be too specific (Remember that talk about tests being too rigid? Over specification leads to brittle tests and obscures the intent of tests. Therefore we encourage you to specify only what's necessary - no more, no less.). If you care to check that `Forward()` will be called but aren't interested in its actual argument, write `_` as the argument, which means "anything goes":
-
-```
-using ::testing::_;
-...
-// Expects the turtle to move forward.
-EXPECT_CALL(turtle, Forward(_));
-```
-
-`_` is an instance of what we call **matchers**. A matcher is like a predicate and can test whether an argument is what we'd expect. You can use a matcher inside `EXPECT_CALL()` wherever a function argument is expected.
-
-A list of built-in matchers can be found in the [CheatSheet](V1_6_CheatSheet.md). For example, here's the `Ge` (greater than or equal) matcher:
-
-```
-using ::testing::Ge;...
-EXPECT_CALL(turtle, Forward(Ge(100)));
-```
-
-This checks that the turtle will be told to go forward by at least 100 units.
-
-## Cardinalities: How Many Times Will It Be Called? ##
-The first clause we can specify following an `EXPECT_CALL()` is `Times()`. We call its argument a **cardinality** as it tells _how many times_ the call should occur. It allows us to repeat an expectation many times without actually writing it as many times. More importantly, a cardinality can be "fuzzy", just like a matcher can be. This allows a user to express the intent of a test exactly.
-
-An interesting special case is when we say `Times(0)`. You may have guessed - it means that the function shouldn't be called with the given arguments at all, and Google Mock will report a Google Test failure whenever the function is (wrongfully) called.
-
-We've seen `AtLeast(n)` as an example of fuzzy cardinalities earlier. For the list of built-in cardinalities you can use, see the [CheatSheet](V1_6_CheatSheet.md).
-
-The `Times()` clause can be omitted. **If you omit `Times()`, Google Mock will infer the cardinality for you.** The rules are easy to remember:
-
-  * If **neither** `WillOnce()` **nor** `WillRepeatedly()` is in the `EXPECT_CALL()`, the inferred cardinality is `Times(1)`.
-  * If there are `n WillOnce()`'s but **no** `WillRepeatedly()`, where `n` >= 1, the cardinality is `Times(n)`.
-  * If there are `n WillOnce()`'s and **one** `WillRepeatedly()`, where `n` >= 0, the cardinality is `Times(AtLeast(n))`.
-
-**Quick quiz:** what do you think will happen if a function is expected to be called twice but actually called four times?
-
-## Actions: What Should It Do? ##
-Remember that a mock object doesn't really have a working implementation? We as users have to tell it what to do when a method is invoked. This is easy in Google Mock.
-
-First, if the return type of a mock function is a built-in type or a pointer, the function has a **default action** (a `void` function will just return, a `bool` function will return `false`, and other functions will return 0). If you don't say anything, this behavior will be used.
-
-Second, if a mock function doesn't have a default action, or the default action doesn't suit you, you can specify the action to be taken each time the expectation matches using a series of `WillOnce()` clauses followed by an optional `WillRepeatedly()`. For example,
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetX())
-    .WillOnce(Return(100))
-    .WillOnce(Return(200))
-    .WillOnce(Return(300));
-```
-
-This says that `turtle.GetX()` will be called _exactly three times_ (Google Mock inferred this from how many `WillOnce()` clauses we've written, since we didn't explicitly write `Times()`), and will return 100, 200, and 300 respectively.
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetY())
-    .WillOnce(Return(100))
-    .WillOnce(Return(200))
-    .WillRepeatedly(Return(300));
-```
-
-says that `turtle.GetY()` will be called _at least twice_ (Google Mock knows this as we've written two `WillOnce()` clauses and a `WillRepeatedly()` while having no explicit `Times()`), will return 100 the first time, 200 the second time, and 300 from the third time on.
-
-Of course, if you explicitly write a `Times()`, Google Mock will not try to infer the cardinality itself. What if the number you specified is larger than there are `WillOnce()` clauses? Well, after all `WillOnce()`s are used up, Google Mock will do the _default_ action for the function every time (unless, of course, you have a `WillRepeatedly()`.).
-
-What can we do inside `WillOnce()` besides `Return()`? You can return a reference using `ReturnRef(variable)`, or invoke a pre-defined function, among [others](http://code.google.com/p/googlemock/wiki/V1_6_CheatSheet#Actions).
-
-**Important note:** The `EXPECT_CALL()` statement evaluates the action clause only once, even though the action may be performed many times. Therefore you must be careful about side effects. The following may not do what you want:
-
-```
-int n = 100;
-EXPECT_CALL(turtle, GetX())
-.Times(4)
-.WillRepeatedly(Return(n++));
-```
-
-Instead of returning 100, 101, 102, ..., consecutively, this mock function will always return 100 as `n++` is only evaluated once. Similarly, `Return(new Foo)` will create a new `Foo` object when the `EXPECT_CALL()` is executed, and will return the same pointer every time. If you want the side effect to happen every time, you need to define a custom action, which we'll teach in the [CookBook](V1_6_CookBook.md).
-
-Time for another quiz! What do you think the following means?
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetY())
-.Times(4)
-.WillOnce(Return(100));
-```
-
-Obviously `turtle.GetY()` is expected to be called four times. But if you think it will return 100 every time, think twice! Remember that one `WillOnce()` clause will be consumed each time the function is invoked and the default action will be taken afterwards. So the right answer is that `turtle.GetY()` will return 100 the first time, but **return 0 from the second time on**, as returning 0 is the default action for `int` functions.
-
-## Using Multiple Expectations ##
-So far we've only shown examples where you have a single expectation. More realistically, you're going to specify expectations on multiple mock methods, which may be from multiple mock objects.
-
-By default, when a mock method is invoked, Google Mock will search the expectations in the **reverse order** they are defined, and stop when an active expectation that matches the arguments is found (you can think of it as "newer rules override older ones."). If the matching expectation cannot take any more calls, you will get an upper-bound-violated failure. Here's an example:
-
-```
-using ::testing::_;...
-EXPECT_CALL(turtle, Forward(_));  // #1
-EXPECT_CALL(turtle, Forward(10))  // #2
-    .Times(2);
-```
-
-If `Forward(10)` is called three times in a row, the third time it will be an error, as the last matching expectation (#2) has been saturated. If, however, the third `Forward(10)` call is replaced by `Forward(20)`, then it would be OK, as now #1 will be the matching expectation.
-
-**Side note:** Why does Google Mock search for a match in the _reverse_ order of the expectations? The reason is that this allows a user to set up the default expectations in a mock object's constructor or the test fixture's set-up phase and then customize the mock by writing more specific expectations in the test body. So, if you have two expectations on the same method, you want to put the one with more specific matchers **after** the other, or the more specific rule would be shadowed by the more general one that comes after it.
-
-## Ordered vs Unordered Calls ##
-By default, an expectation can match a call even though an earlier expectation hasn't been satisfied. In other words, the calls don't have to occur in the order the expectations are specified.
-
-Sometimes, you may want all the expected calls to occur in a strict order. To say this in Google Mock is easy:
-
-```
-using ::testing::InSequence;...
-TEST(FooTest, DrawsLineSegment) {
-  ...
-  {
-    InSequence dummy;
-
-    EXPECT_CALL(turtle, PenDown());
-    EXPECT_CALL(turtle, Forward(100));
-    EXPECT_CALL(turtle, PenUp());
-  }
-  Foo();
-}
-```
-
-By creating an object of type `InSequence`, all expectations in its scope are put into a _sequence_ and have to occur _sequentially_. Since we are just relying on the constructor and destructor of this object to do the actual work, its name is really irrelevant.
-
-In this example, we test that `Foo()` calls the three expected functions in the order as written. If a call is made out-of-order, it will be an error.
-
-(What if you care about the relative order of some of the calls, but not all of them? Can you specify an arbitrary partial order? The answer is ... yes! If you are impatient, the details can be found in the [CookBook](V1_6_CookBook.md).)
-
-## All Expectations Are Sticky (Unless Said Otherwise) ##
-Now let's do a quick quiz to see how well you can use this mock stuff already. How would you test that the turtle is asked to go to the origin _exactly twice_ (you want to ignore any other instructions it receives)?
-
-After you've come up with your answer, take a look at ours and compare notes (solve it yourself first - don't cheat!):
-
-```
-using ::testing::_;...
-EXPECT_CALL(turtle, GoTo(_, _))  // #1
-    .Times(AnyNumber());
-EXPECT_CALL(turtle, GoTo(0, 0))  // #2
-    .Times(2);
-```
-
-Suppose `turtle.GoTo(0, 0)` is called three times. In the third time, Google Mock will see that the arguments match expectation #2 (remember that we always pick the last matching expectation). Now, since we said that there should be only two such calls, Google Mock will report an error immediately. This is basically what we've told you in the "Using Multiple Expectations" section above.
-
-This example shows that **expectations in Google Mock are "sticky" by default**, in the sense that they remain active even after we have reached their invocation upper bounds. This is an important rule to remember, as it affects the meaning of the spec, and is **different** to how it's done in many other mocking frameworks (Why'd we do that? Because we think our rule makes the common cases easier to express and understand.).
-
-Simple? Let's see if you've really understood it: what does the following code say?
-
-```
-using ::testing::Return;
-...
-for (int i = n; i > 0; i--) {
-  EXPECT_CALL(turtle, GetX())
-      .WillOnce(Return(10*i));
-}
-```
-
-If you think it says that `turtle.GetX()` will be called `n` times and will return 10, 20, 30, ..., consecutively, think twice! The problem is that, as we said, expectations are sticky. So, the second time `turtle.GetX()` is called, the last (latest) `EXPECT_CALL()` statement will match, and will immediately lead to an "upper bound exceeded" error - this piece of code is not very useful!
-
-One correct way of saying that `turtle.GetX()` will return 10, 20, 30, ..., is to explicitly say that the expectations are _not_ sticky. In other words, they should _retire_ as soon as they are saturated:
-
-```
-using ::testing::Return;
-...
-for (int i = n; i > 0; i--) {
-  EXPECT_CALL(turtle, GetX())
-    .WillOnce(Return(10*i))
-    .RetiresOnSaturation();
-}
-```
-
-And, there's a better way to do it: in this case, we expect the calls to occur in a specific order, and we line up the actions to match the order. Since the order is important here, we should make it explicit using a sequence:
-
-```
-using ::testing::InSequence;
-using ::testing::Return;
-...
-{
-  InSequence s;
-
-  for (int i = 1; i <= n; i++) {
-    EXPECT_CALL(turtle, GetX())
-        .WillOnce(Return(10*i))
-        .RetiresOnSaturation();
-  }
-}
-```
-
-By the way, the other situation where an expectation may _not_ be sticky is when it's in a sequence - as soon as another expectation that comes after it in the sequence has been used, it automatically retires (and will never be used to match any call).
-
-## Uninteresting Calls ##
-A mock object may have many methods, and not all of them are that interesting. For example, in some tests we may not care about how many times `GetX()` and `GetY()` get called.
-
-In Google Mock, if you are not interested in a method, just don't say anything about it. If a call to this method occurs, you'll see a warning in the test output, but it won't be a failure.
-
-# What Now? #
-Congratulations! You've learned enough about Google Mock to start using it. Now, you might want to join the [googlemock](http://groups.google.com/group/googlemock) discussion group and actually write some tests using Google Mock - it will be fun. Hey, it may even be addictive - you've been warned.
-
-Then, if you feel like increasing your mock quotient, you should move on to the [CookBook](V1_6_CookBook.md). You can learn many advanced features of Google Mock there -- and advance your level of enjoyment and testing bliss.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/FrequentlyAskedQuestions.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/FrequentlyAskedQuestions.md
deleted file mode 100644
index f74715d2..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_6/FrequentlyAskedQuestions.md
+++ /dev/null
@@ -1,628 +0,0 @@
-
-
-Please send your questions to the
-[googlemock](http://groups.google.com/group/googlemock) discussion
-group. If you need help with compiler errors, make sure you have
-tried [Google Mock Doctor](#How_am_I_supposed_to_make_sense_of_these_horrible_template_error.md) first.
-
-## When I call a method on my mock object, the method for the real object is invoked instead.  What's the problem? ##
-
-In order for a method to be mocked, it must be _virtual_, unless you use the [high-perf dependency injection technique](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Mocking_Nonvirtual_Methods).
-
-## I wrote some matchers.  After I upgraded to a new version of Google Mock, they no longer compile.  What's going on? ##
-
-After version 1.4.0 of Google Mock was released, we had an idea on how
-to make it easier to write matchers that can generate informative
-messages efficiently.  We experimented with this idea and liked what
-we saw.  Therefore we decided to implement it.
-
-Unfortunately, this means that if you have defined your own matchers
-by implementing `MatcherInterface` or using `MakePolymorphicMatcher()`,
-your definitions will no longer compile.  Matchers defined using the
-`MATCHER*` family of macros are not affected.
-
-Sorry for the hassle if your matchers are affected.  We believe it's
-in everyone's long-term interest to make this change sooner than
-later.  Fortunately, it's usually not hard to migrate an existing
-matcher to the new API.  Here's what you need to do:
-
-If you wrote your matcher like this:
-```
-// Old matcher definition that doesn't work with the latest
-// Google Mock.
-using ::testing::MatcherInterface;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetFoo() > 5;
-  }
-  ...
-};
-```
-
-you'll need to change it to:
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool MatchAndExplain(MyType value,
-                               MatchResultListener* listener) const {
-    // Returns true if value matches.
-    return value.GetFoo() > 5;
-  }
-  ...
-};
-```
-(i.e. rename `Matches()` to `MatchAndExplain()` and give it a second
-argument of type `MatchResultListener*`.)
-
-If you were also using `ExplainMatchResultTo()` to improve the matcher
-message:
-```
-// Old matcher definition that doesn't work with the lastest
-// Google Mock.
-using ::testing::MatcherInterface;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetFoo() > 5;
-  }
-
-  virtual void ExplainMatchResultTo(MyType value,
-                                    ::std::ostream* os) const {
-    // Prints some helpful information to os to help
-    // a user understand why value matches (or doesn't match).
-    *os << "the Foo property is " << value.GetFoo();
-  }
-  ...
-};
-```
-
-you should move the logic of `ExplainMatchResultTo()` into
-`MatchAndExplain()`, using the `MatchResultListener` argument where
-the `::std::ostream` was used:
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool MatchAndExplain(MyType value,
-                               MatchResultListener* listener) const {
-    // Returns true if value matches.
-    *listener << "the Foo property is " << value.GetFoo();
-    return value.GetFoo() > 5;
-  }
-  ...
-};
-```
-
-If your matcher is defined using `MakePolymorphicMatcher()`:
-```
-// Old matcher definition that doesn't work with the latest
-// Google Mock.
-using ::testing::MakePolymorphicMatcher;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetBar() < 42;
-  }
-  ...
-};
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-you should rename the `Matches()` method to `MatchAndExplain()` and
-add a `MatchResultListener*` argument (the same as what you need to do
-for matchers defined by implementing `MatcherInterface`):
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MakePolymorphicMatcher;
-using ::testing::MatchResultListener;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool MatchAndExplain(MyType value,
-                       MatchResultListener* listener) const {
-    // Returns true if value matches.
-    return value.GetBar() < 42;
-  }
-  ...
-};
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-If your polymorphic matcher uses `ExplainMatchResultTo()` for better
-failure messages:
-```
-// Old matcher definition that doesn't work with the latest
-// Google Mock.
-using ::testing::MakePolymorphicMatcher;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetBar() < 42;
-  }
-  ...
-};
-void ExplainMatchResultTo(const MyGreatMatcher& matcher,
-                          MyType value,
-                          ::std::ostream* os) {
-  // Prints some helpful information to os to help
-  // a user understand why value matches (or doesn't match).
-  *os << "the Bar property is " << value.GetBar();
-}
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-you'll need to move the logic inside `ExplainMatchResultTo()` to
-`MatchAndExplain()`:
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MakePolymorphicMatcher;
-using ::testing::MatchResultListener;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool MatchAndExplain(MyType value,
-                       MatchResultListener* listener) const {
-    // Returns true if value matches.
-    *listener << "the Bar property is " << value.GetBar();
-    return value.GetBar() < 42;
-  }
-  ...
-};
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-For more information, you can read these
-[two](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Writing_New_Monomorphic_Matchers)
-[recipes](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Writing_New_Polymorphic_Matchers)
-from the cookbook.  As always, you
-are welcome to post questions on `googlemock@googlegroups.com` if you
-need any help.
-
-## When using Google Mock, do I have to use Google Test as the testing framework?  I have my favorite testing framework and don't want to switch. ##
-
-Google Mock works out of the box with Google Test.  However, it's easy
-to configure it to work with any testing framework of your choice.
-[Here](http://code.google.com/p/googlemock/wiki/V1_6_ForDummies#Using_Google_Mock_with_Any_Testing_Framework) is how.
-
-## How am I supposed to make sense of these horrible template errors? ##
-
-If you are confused by the compiler errors gcc threw at you,
-try consulting the _Google Mock Doctor_ tool first.  What it does is to
-scan stdin for gcc error messages, and spit out diagnoses on the
-problems (we call them diseases) your code has.
-
-To "install", run command:
-```
-alias gmd='<path to googlemock>/scripts/gmock_doctor.py'
-```
-
-To use it, do:
-```
-<your-favorite-build-command> <your-test> 2>&1 | gmd
-```
-
-For example:
-```
-make my_test 2>&1 | gmd
-```
-
-Or you can run `gmd` and copy-n-paste gcc's error messages to it.
-
-## Can I mock a variadic function? ##
-
-You cannot mock a variadic function (i.e. a function taking ellipsis
-(`...`) arguments) directly in Google Mock.
-
-The problem is that in general, there is _no way_ for a mock object to
-know how many arguments are passed to the variadic method, and what
-the arguments' types are.  Only the _author of the base class_ knows
-the protocol, and we cannot look into his head.
-
-Therefore, to mock such a function, the _user_ must teach the mock
-object how to figure out the number of arguments and their types.  One
-way to do it is to provide overloaded versions of the function.
-
-Ellipsis arguments are inherited from C and not really a C++ feature.
-They are unsafe to use and don't work with arguments that have
-constructors or destructors.  Therefore we recommend to avoid them in
-C++ as much as possible.
-
-## MSVC gives me warning C4301 or C4373 when I define a mock method with a const parameter.  Why? ##
-
-If you compile this using Microsoft Visual C++ 2005 SP1:
-```
-class Foo {
-  ...
-  virtual void Bar(const int i) = 0;
-};
-
-class MockFoo : public Foo {
-  ...
-  MOCK_METHOD1(Bar, void(const int i));
-};
-```
-You may get the following warning:
-```
-warning C4301: 'MockFoo::Bar': overriding virtual function only differs from 'Foo::Bar' by const/volatile qualifier
-```
-
-This is a MSVC bug.  The same code compiles fine with gcc ,for
-example.  If you use Visual C++ 2008 SP1, you would get the warning:
-```
-warning C4373: 'MockFoo::Bar': virtual function overrides 'Foo::Bar', previous versions of the compiler did not override when parameters only differed by const/volatile qualifiers
-```
-
-In C++, if you _declare_ a function with a `const` parameter, the
-`const` modifier is _ignored_.  Therefore, the `Foo` base class above
-is equivalent to:
-```
-class Foo {
-  ...
-  virtual void Bar(int i) = 0;  // int or const int?  Makes no difference.
-};
-```
-
-In fact, you can _declare_ Bar() with an `int` parameter, and _define_
-it with a `const int` parameter.  The compiler will still match them
-up.
-
-Since making a parameter `const` is meaningless in the method
-_declaration_, we recommend to remove it in both `Foo` and `MockFoo`.
-That should workaround the VC bug.
-
-Note that we are talking about the _top-level_ `const` modifier here.
-If the function parameter is passed by pointer or reference, declaring
-the _pointee_ or _referee_ as `const` is still meaningful.  For
-example, the following two declarations are _not_ equivalent:
-```
-void Bar(int* p);        // Neither p nor *p is const.
-void Bar(const int* p);  // p is not const, but *p is.
-```
-
-## I have a huge mock class, and Microsoft Visual C++ runs out of memory when compiling it.  What can I do? ##
-
-We've noticed that when the `/clr` compiler flag is used, Visual C++
-uses 5~6 times as much memory when compiling a mock class.  We suggest
-to avoid `/clr` when compiling native C++ mocks.
-
-## I can't figure out why Google Mock thinks my expectations are not satisfied.  What should I do? ##
-
-You might want to run your test with
-`--gmock_verbose=info`.  This flag lets Google Mock print a trace
-of every mock function call it receives.  By studying the trace,
-you'll gain insights on why the expectations you set are not met.
-
-## How can I assert that a function is NEVER called? ##
-
-```
-EXPECT_CALL(foo, Bar(_))
-    .Times(0);
-```
-
-## I have a failed test where Google Mock tells me TWICE that a particular expectation is not satisfied.  Isn't this redundant? ##
-
-When Google Mock detects a failure, it prints relevant information
-(the mock function arguments, the state of relevant expectations, and
-etc) to help the user debug.  If another failure is detected, Google
-Mock will do the same, including printing the state of relevant
-expectations.
-
-Sometimes an expectation's state didn't change between two failures,
-and you'll see the same description of the state twice.  They are
-however _not_ redundant, as they refer to _different points in time_.
-The fact they are the same _is_ interesting information.
-
-## I get a heap check failure when using a mock object, but using a real object is fine.  What can be wrong? ##
-
-Does the class (hopefully a pure interface) you are mocking have a
-virtual destructor?
-
-Whenever you derive from a base class, make sure its destructor is
-virtual.  Otherwise Bad Things will happen.  Consider the following
-code:
-
-```
-class Base {
- public:
-  // Not virtual, but should be.
-  ~Base() { ... }
-  ...
-};
-
-class Derived : public Base {
- public:
-  ...
- private:
-  std::string value_;
-};
-
-...
-  Base* p = new Derived;
-  ...
-  delete p;  // Surprise! ~Base() will be called, but ~Derived() will not
-             // - value_ is leaked.
-```
-
-By changing `~Base()` to virtual, `~Derived()` will be correctly
-called when `delete p` is executed, and the heap checker
-will be happy.
-
-## The "newer expectations override older ones" rule makes writing expectations awkward.  Why does Google Mock do that? ##
-
-When people complain about this, often they are referring to code like:
-
-```
-// foo.Bar() should be called twice, return 1 the first time, and return
-// 2 the second time.  However, I have to write the expectations in the
-// reverse order.  This sucks big time!!!
-EXPECT_CALL(foo, Bar())
-    .WillOnce(Return(2))
-    .RetiresOnSaturation();
-EXPECT_CALL(foo, Bar())
-    .WillOnce(Return(1))
-    .RetiresOnSaturation();
-```
-
-The problem is that they didn't pick the **best** way to express the test's
-intent.
-
-By default, expectations don't have to be matched in _any_ particular
-order.  If you want them to match in a certain order, you need to be
-explicit.  This is Google Mock's (and jMock's) fundamental philosophy: it's
-easy to accidentally over-specify your tests, and we want to make it
-harder to do so.
-
-There are two better ways to write the test spec.  You could either
-put the expectations in sequence:
-
-```
-// foo.Bar() should be called twice, return 1 the first time, and return
-// 2 the second time.  Using a sequence, we can write the expectations
-// in their natural order.
-{
-  InSequence s;
-  EXPECT_CALL(foo, Bar())
-      .WillOnce(Return(1))
-      .RetiresOnSaturation();
-  EXPECT_CALL(foo, Bar())
-      .WillOnce(Return(2))
-      .RetiresOnSaturation();
-}
-```
-
-or you can put the sequence of actions in the same expectation:
-
-```
-// foo.Bar() should be called twice, return 1 the first time, and return
-// 2 the second time.
-EXPECT_CALL(foo, Bar())
-    .WillOnce(Return(1))
-    .WillOnce(Return(2))
-    .RetiresOnSaturation();
-```
-
-Back to the original questions: why does Google Mock search the
-expectations (and `ON_CALL`s) from back to front?  Because this
-allows a user to set up a mock's behavior for the common case early
-(e.g. in the mock's constructor or the test fixture's set-up phase)
-and customize it with more specific rules later.  If Google Mock
-searches from front to back, this very useful pattern won't be
-possible.
-
-## Google Mock prints a warning when a function without EXPECT\_CALL is called, even if I have set its behavior using ON\_CALL.  Would it be reasonable not to show the warning in this case? ##
-
-When choosing between being neat and being safe, we lean toward the
-latter.  So the answer is that we think it's better to show the
-warning.
-
-Often people write `ON_CALL`s in the mock object's
-constructor or `SetUp()`, as the default behavior rarely changes from
-test to test.  Then in the test body they set the expectations, which
-are often different for each test.  Having an `ON_CALL` in the set-up
-part of a test doesn't mean that the calls are expected.  If there's
-no `EXPECT_CALL` and the method is called, it's possibly an error.  If
-we quietly let the call go through without notifying the user, bugs
-may creep in unnoticed.
-
-If, however, you are sure that the calls are OK, you can write
-
-```
-EXPECT_CALL(foo, Bar(_))
-    .WillRepeatedly(...);
-```
-
-instead of
-
-```
-ON_CALL(foo, Bar(_))
-    .WillByDefault(...);
-```
-
-This tells Google Mock that you do expect the calls and no warning should be
-printed.
-
-Also, you can control the verbosity using the `--gmock_verbose` flag.
-If you find the output too noisy when debugging, just choose a less
-verbose level.
-
-## How can I delete the mock function's argument in an action? ##
-
-If you find yourself needing to perform some action that's not
-supported by Google Mock directly, remember that you can define your own
-actions using
-[MakeAction()](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Writing_New_Actions) or
-[MakePolymorphicAction()](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Writing_New_Polymorphic_Actions),
-or you can write a stub function and invoke it using
-[Invoke()](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Using_Functions_Methods_Functors).
-
-## MOCK\_METHODn()'s second argument looks funny.  Why don't you use the MOCK\_METHODn(Method, return\_type, arg\_1, ..., arg\_n) syntax? ##
-
-What?!  I think it's beautiful. :-)
-
-While which syntax looks more natural is a subjective matter to some
-extent, Google Mock's syntax was chosen for several practical advantages it
-has.
-
-Try to mock a function that takes a map as an argument:
-```
-virtual int GetSize(const map<int, std::string>& m);
-```
-
-Using the proposed syntax, it would be:
-```
-MOCK_METHOD1(GetSize, int, const map<int, std::string>& m);
-```
-
-Guess what?  You'll get a compiler error as the compiler thinks that
-`const map<int, std::string>& m` are **two**, not one, arguments. To work
-around this you can use `typedef` to give the map type a name, but
-that gets in the way of your work.  Google Mock's syntax avoids this
-problem as the function's argument types are protected inside a pair
-of parentheses:
-```
-// This compiles fine.
-MOCK_METHOD1(GetSize, int(const map<int, std::string>& m));
-```
-
-You still need a `typedef` if the return type contains an unprotected
-comma, but that's much rarer.
-
-Other advantages include:
-  1. `MOCK_METHOD1(Foo, int, bool)` can leave a reader wonder whether the method returns `int` or `bool`, while there won't be such confusion using Google Mock's syntax.
-  1. The way Google Mock describes a function type is nothing new, although many people may not be familiar with it.  The same syntax was used in C, and the `function` library in `tr1` uses this syntax extensively.  Since `tr1` will become a part of the new version of STL, we feel very comfortable to be consistent with it.
-  1. The function type syntax is also used in other parts of Google Mock's API (e.g. the action interface) in order to make the implementation tractable. A user needs to learn it anyway in order to utilize Google Mock's more advanced features.  We'd as well stick to the same syntax in `MOCK_METHOD*`!
-
-## My code calls a static/global function.  Can I mock it? ##
-
-You can, but you need to make some changes.
-
-In general, if you find yourself needing to mock a static function,
-it's a sign that your modules are too tightly coupled (and less
-flexible, less reusable, less testable, etc).  You are probably better
-off defining a small interface and call the function through that
-interface, which then can be easily mocked.  It's a bit of work
-initially, but usually pays for itself quickly.
-
-This Google Testing Blog
-[post](http://googletesting.blogspot.com/2008/06/defeat-static-cling.html)
-says it excellently.  Check it out.
-
-## My mock object needs to do complex stuff.  It's a lot of pain to specify the actions.  Google Mock sucks! ##
-
-I know it's not a question, but you get an answer for free any way. :-)
-
-With Google Mock, you can create mocks in C++ easily.  And people might be
-tempted to use them everywhere. Sometimes they work great, and
-sometimes you may find them, well, a pain to use. So, what's wrong in
-the latter case?
-
-When you write a test without using mocks, you exercise the code and
-assert that it returns the correct value or that the system is in an
-expected state.  This is sometimes called "state-based testing".
-
-Mocks are great for what some call "interaction-based" testing:
-instead of checking the system state at the very end, mock objects
-verify that they are invoked the right way and report an error as soon
-as it arises, giving you a handle on the precise context in which the
-error was triggered.  This is often more effective and economical to
-do than state-based testing.
-
-If you are doing state-based testing and using a test double just to
-simulate the real object, you are probably better off using a fake.
-Using a mock in this case causes pain, as it's not a strong point for
-mocks to perform complex actions.  If you experience this and think
-that mocks suck, you are just not using the right tool for your
-problem. Or, you might be trying to solve the wrong problem. :-)
-
-## I got a warning "Uninteresting function call encountered - default action taken.."  Should I panic? ##
-
-By all means, NO!  It's just an FYI.
-
-What it means is that you have a mock function, you haven't set any
-expectations on it (by Google Mock's rule this means that you are not
-interested in calls to this function and therefore it can be called
-any number of times), and it is called.  That's OK - you didn't say
-it's not OK to call the function!
-
-What if you actually meant to disallow this function to be called, but
-forgot to write `EXPECT_CALL(foo, Bar()).Times(0)`?  While
-one can argue that it's the user's fault, Google Mock tries to be nice and
-prints you a note.
-
-So, when you see the message and believe that there shouldn't be any
-uninteresting calls, you should investigate what's going on.  To make
-your life easier, Google Mock prints the function name and arguments
-when an uninteresting call is encountered.
-
-## I want to define a custom action.  Should I use Invoke() or implement the action interface? ##
-
-Either way is fine - you want to choose the one that's more convenient
-for your circumstance.
-
-Usually, if your action is for a particular function type, defining it
-using `Invoke()` should be easier; if your action can be used in
-functions of different types (e.g. if you are defining
-`Return(value)`), `MakePolymorphicAction()` is
-easiest.  Sometimes you want precise control on what types of
-functions the action can be used in, and implementing
-`ActionInterface` is the way to go here. See the implementation of
-`Return()` in `include/gmock/gmock-actions.h` for an example.
-
-## I'm using the set-argument-pointee action, and the compiler complains about "conflicting return type specified".  What does it mean? ##
-
-You got this error as Google Mock has no idea what value it should return
-when the mock method is called.  `SetArgPointee()` says what the
-side effect is, but doesn't say what the return value should be.  You
-need `DoAll()` to chain a `SetArgPointee()` with a `Return()`.
-
-See this [recipe](http://code.google.com/p/googlemock/wiki/V1_6_CookBook#Mocking_Side_Effects) for more details and an example.
-
-
-## My question is not in your FAQ! ##
-
-If you cannot find the answer to your question in this FAQ, there are
-some other resources you can use:
-
-  1. read other [wiki pages](http://code.google.com/p/googlemock/w/list),
-  1. search the mailing list [archive](http://groups.google.com/group/googlemock/topics),
-  1. ask it on [googlemock@googlegroups.com](mailto:googlemock@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googlemock) before you can post.).
-
-Please note that creating an issue in the
-[issue tracker](http://code.google.com/p/googlemock/issues/list) is _not_
-a good way to get your answer, as it is monitored infrequently by a
-very small number of people.
-
-When asking a question, it's helpful to provide as much of the
-following information as possible (people cannot help you if there's
-not enough information in your question):
-
-  * the version (or the revision number if you check out from SVN directly) of Google Mock you use (Google Mock is under active development, so it's possible that your problem has been solved in a later version),
-  * your operating system,
-  * the name and version of your compiler,
-  * the complete command line flags you give to your compiler,
-  * the complete compiler error messages (if the question is about compilation),
-  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CheatSheet.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CheatSheet.md
deleted file mode 100644
index db421e51..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CheatSheet.md
+++ /dev/null
@@ -1,556 +0,0 @@
-
-
-# Defining a Mock Class #
-
-## Mocking a Normal Class ##
-
-Given
-```
-class Foo {
-  ...
-  virtual ~Foo();
-  virtual int GetSize() const = 0;
-  virtual string Describe(const char* name) = 0;
-  virtual string Describe(int type) = 0;
-  virtual bool Process(Bar elem, int count) = 0;
-};
-```
-(note that `~Foo()` **must** be virtual) we can define its mock as
-```
-#include "gmock/gmock.h"
-
-class MockFoo : public Foo {
-  MOCK_CONST_METHOD0(GetSize, int());
-  MOCK_METHOD1(Describe, string(const char* name));
-  MOCK_METHOD1(Describe, string(int type));
-  MOCK_METHOD2(Process, bool(Bar elem, int count));
-};
-```
-
-To create a "nice" mock object which ignores all uninteresting calls,
-or a "strict" mock object, which treats them as failures:
-```
-NiceMock<MockFoo> nice_foo;     // The type is a subclass of MockFoo.
-StrictMock<MockFoo> strict_foo; // The type is a subclass of MockFoo.
-```
-
-## Mocking a Class Template ##
-
-To mock
-```
-template <typename Elem>
-class StackInterface {
- public:
-  ...
-  virtual ~StackInterface();
-  virtual int GetSize() const = 0;
-  virtual void Push(const Elem& x) = 0;
-};
-```
-(note that `~StackInterface()` **must** be virtual) just append `_T` to the `MOCK_*` macros:
-```
-template <typename Elem>
-class MockStack : public StackInterface<Elem> {
- public:
-  ...
-  MOCK_CONST_METHOD0_T(GetSize, int());
-  MOCK_METHOD1_T(Push, void(const Elem& x));
-};
-```
-
-## Specifying Calling Conventions for Mock Functions ##
-
-If your mock function doesn't use the default calling convention, you
-can specify it by appending `_WITH_CALLTYPE` to any of the macros
-described in the previous two sections and supplying the calling
-convention as the first argument to the macro. For example,
-```
-  MOCK_METHOD_1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int n));
-  MOCK_CONST_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, Bar, int(double x, double y));
-```
-where `STDMETHODCALLTYPE` is defined by `<objbase.h>` on Windows.
-
-# Using Mocks in Tests #
-
-The typical flow is:
-  1. Import the Google Mock names you need to use. All Google Mock names are in the `testing` namespace unless they are macros or otherwise noted.
-  1. Create the mock objects.
-  1. Optionally, set the default actions of the mock objects.
-  1. Set your expectations on the mock objects (How will they be called? What wil they do?).
-  1. Exercise code that uses the mock objects; if necessary, check the result using [Google Test](http://code.google.com/p/googletest/) assertions.
-  1. When a mock objects is destructed, Google Mock automatically verifies that all expectations on it have been satisfied.
-
-Here is an example:
-```
-using ::testing::Return;                            // #1
-
-TEST(BarTest, DoesThis) {
-  MockFoo foo;                                    // #2
-
-  ON_CALL(foo, GetSize())                         // #3
-      .WillByDefault(Return(1));
-  // ... other default actions ...
-
-  EXPECT_CALL(foo, Describe(5))                   // #4
-      .Times(3)
-      .WillRepeatedly(Return("Category 5"));
-  // ... other expectations ...
-
-  EXPECT_EQ("good", MyProductionFunction(&foo));  // #5
-}                                                 // #6
-```
-
-# Setting Default Actions #
-
-Google Mock has a **built-in default action** for any function that
-returns `void`, `bool`, a numeric value, or a pointer.
-
-To customize the default action for functions with return type `T` globally:
-```
-using ::testing::DefaultValue;
-
-DefaultValue<T>::Set(value);  // Sets the default value to be returned.
-// ... use the mocks ...
-DefaultValue<T>::Clear();     // Resets the default value.
-```
-
-To customize the default action for a particular method, use `ON_CALL()`:
-```
-ON_CALL(mock_object, method(matchers))
-    .With(multi_argument_matcher)  ?
-    .WillByDefault(action);
-```
-
-# Setting Expectations #
-
-`EXPECT_CALL()` sets **expectations** on a mock method (How will it be
-called? What will it do?):
-```
-EXPECT_CALL(mock_object, method(matchers))
-    .With(multi_argument_matcher)  ?
-    .Times(cardinality)            ?
-    .InSequence(sequences)         *
-    .After(expectations)           *
-    .WillOnce(action)              *
-    .WillRepeatedly(action)        ?
-    .RetiresOnSaturation();        ?
-```
-
-If `Times()` is omitted, the cardinality is assumed to be:
-
-  * `Times(1)` when there is neither `WillOnce()` nor `WillRepeatedly()`;
-  * `Times(n)` when there are `n WillOnce()`s but no `WillRepeatedly()`, where `n` >= 1; or
-  * `Times(AtLeast(n))` when there are `n WillOnce()`s and a `WillRepeatedly()`, where `n` >= 0.
-
-A method with no `EXPECT_CALL()` is free to be invoked _any number of times_, and the default action will be taken each time.
-
-# Matchers #
-
-A **matcher** matches a _single_ argument.  You can use it inside
-`ON_CALL()` or `EXPECT_CALL()`, or use it to validate a value
-directly:
-
-| `EXPECT_THAT(value, matcher)` | Asserts that `value` matches `matcher`. |
-|:------------------------------|:----------------------------------------|
-| `ASSERT_THAT(value, matcher)` | The same as `EXPECT_THAT(value, matcher)`, except that it generates a **fatal** failure. |
-
-Built-in matchers (where `argument` is the function argument) are
-divided into several categories:
-
-## Wildcard ##
-|`_`|`argument` can be any value of the correct type.|
-|:--|:-----------------------------------------------|
-|`A<type>()` or `An<type>()`|`argument` can be any value of type `type`.     |
-
-## Generic Comparison ##
-
-|`Eq(value)` or `value`|`argument == value`|
-|:---------------------|:------------------|
-|`Ge(value)`           |`argument >= value`|
-|`Gt(value)`           |`argument > value` |
-|`Le(value)`           |`argument <= value`|
-|`Lt(value)`           |`argument < value` |
-|`Ne(value)`           |`argument != value`|
-|`IsNull()`            |`argument` is a `NULL` pointer (raw or smart).|
-|`NotNull()`           |`argument` is a non-null pointer (raw or smart).|
-|`Ref(variable)`       |`argument` is a reference to `variable`.|
-|`TypedEq<type>(value)`|`argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded.|
-
-Except `Ref()`, these matchers make a _copy_ of `value` in case it's
-modified or destructed later. If the compiler complains that `value`
-doesn't have a public copy constructor, try wrap it in `ByRef()`,
-e.g. `Eq(ByRef(non_copyable_value))`. If you do that, make sure
-`non_copyable_value` is not changed afterwards, or the meaning of your
-matcher will be changed.
-
-## Floating-Point Matchers ##
-
-|`DoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as unequal.|
-|:-------------------|:----------------------------------------------------------------------------------------------|
-|`FloatEq(a_float)`  |`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal.  |
-|`NanSensitiveDoubleEq(a_double)`|`argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal.  |
-|`NanSensitiveFloatEq(a_float)`|`argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal.    |
-
-The above matchers use ULP-based comparison (the same as used in
-[Google Test](http://code.google.com/p/googletest/)). They
-automatically pick a reasonable error bound based on the absolute
-value of the expected value.  `DoubleEq()` and `FloatEq()` conform to
-the IEEE standard, which requires comparing two NaNs for equality to
-return false. The `NanSensitive*` version instead treats two NaNs as
-equal, which is often what a user wants.
-
-|`DoubleNear(a_double, max_abs_error)`|`argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as unequal.|
-|:------------------------------------|:--------------------------------------------------------------------------------------------------------------------|
-|`FloatNear(a_float, max_abs_error)`  |`argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as unequal.  |
-|`NanSensitiveDoubleNear(a_double, max_abs_error)`|`argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as equal.  |
-|`NanSensitiveFloatNear(a_float, max_abs_error)`|`argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as equal.    |
-
-## String Matchers ##
-
-The `argument` can be either a C string or a C++ string object:
-
-|`ContainsRegex(string)`|`argument` matches the given regular expression.|
-|:----------------------|:-----------------------------------------------|
-|`EndsWith(suffix)`     |`argument` ends with string `suffix`.           |
-|`HasSubstr(string)`    |`argument` contains `string` as a sub-string.   |
-|`MatchesRegex(string)` |`argument` matches the given regular expression with the match starting at the first character and ending at the last character.|
-|`StartsWith(prefix)`   |`argument` starts with string `prefix`.         |
-|`StrCaseEq(string)`    |`argument` is equal to `string`, ignoring case. |
-|`StrCaseNe(string)`    |`argument` is not equal to `string`, ignoring case.|
-|`StrEq(string)`        |`argument` is equal to `string`.                |
-|`StrNe(string)`        |`argument` is not equal to `string`.            |
-
-`ContainsRegex()` and `MatchesRegex()` use the regular expression
-syntax defined
-[here](http://code.google.com/p/googletest/wiki/AdvancedGuide#Regular_Expression_Syntax).
-`StrCaseEq()`, `StrCaseNe()`, `StrEq()`, and `StrNe()` work for wide
-strings as well.
-
-## Container Matchers ##
-
-Most STL-style containers support `==`, so you can use
-`Eq(expected_container)` or simply `expected_container` to match a
-container exactly.   If you want to write the elements in-line,
-match them more flexibly, or get more informative messages, you can use:
-
-| `ContainerEq(container)` | The same as `Eq(container)` except that the failure message also includes which elements are in one container but not the other. |
-|:-------------------------|:---------------------------------------------------------------------------------------------------------------------------------|
-| `Contains(e)`            | `argument` contains an element that matches `e`, which can be either a value or a matcher.                                       |
-| `Each(e)`                | `argument` is a container where _every_ element matches `e`, which can be either a value or a matcher.                           |
-| `ElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, where the i-th element matches `ei`, which can be a value or a matcher. 0 to 10 arguments are allowed. |
-| `ElementsAreArray({ e0, e1, ..., en })`, `ElementsAreArray(array)`, or `ElementsAreArray(array, count)` | The same as `ElementsAre()` except that the expected element values/matchers come from an initializer list, vector, or C-style array. |
-| `IsEmpty()`              | `argument` is an empty container (`container.empty()`).                                                                          |
-| `Pointwise(m, container)` | `argument` contains the same number of elements as in `container`, and for all i, (the i-th element in `argument`, the i-th element in `container`) match `m`, which is a matcher on 2-tuples. E.g. `Pointwise(Le(), upper_bounds)` verifies that each element in `argument` doesn't exceed the corresponding element in `upper_bounds`. See more detail below. |
-| `SizeIs(m)`              | `argument` is a container whose size matches `m`. E.g. `SizeIs(2)` or `SizeIs(Lt(2))`.                                           |
-| `UnorderedElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, and under some permutation each element matches an `ei` (for a different `i`), which can be a value or a matcher. 0 to 10 arguments are allowed. |
-| `UnorderedElementsAreArray({ e0, e1, ..., en })`, `UnorderedElementsAreArray(array)`, or `UnorderedElementsAreArray(array, count)` | The same as `UnorderedElementsAre()` except that the expected element values/matchers come from an initializer list, vector, or C-style array. |
-| `WhenSorted(m)`          | When `argument` is sorted using the `<` operator, it matches container matcher `m`. E.g. `WhenSorted(UnorderedElementsAre(1, 2, 3))` verifies that `argument` contains elements `1`, `2`, and `3`, ignoring order. |
-| `WhenSortedBy(comparator, m)` | The same as `WhenSorted(m)`, except that the given comparator instead of `<` is used to sort `argument`. E.g. `WhenSortedBy(std::greater<int>(), ElementsAre(3, 2, 1))`. |
-
-Notes:
-
-  * These matchers can also match:
-    1. a native array passed by reference (e.g. in `Foo(const int (&a)[5])`), and
-    1. an array passed as a pointer and a count (e.g. in `Bar(const T* buffer, int len)` -- see [Multi-argument Matchers](#Multiargument_Matchers.md)).
-  * The array being matched may be multi-dimensional (i.e. its elements can be arrays).
-  * `m` in `Pointwise(m, ...)` should be a matcher for `std::tr1::tuple<T, U>` where `T` and `U` are the element type of the actual container and the expected container, respectively. For example, to compare two `Foo` containers where `Foo` doesn't support `operator==` but has an `Equals()` method, one might write:
-
-```
-using ::std::tr1::get;
-MATCHER(FooEq, "") {
-  return get<0>(arg).Equals(get<1>(arg));
-}
-...
-EXPECT_THAT(actual_foos, Pointwise(FooEq(), expected_foos));
-```
-
-## Member Matchers ##
-
-|`Field(&class::field, m)`|`argument.field` (or `argument->field` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
-|:------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------|
-|`Key(e)`                 |`argument.first` matches `e`, which can be either a value or a matcher. E.g. `Contains(Key(Le(5)))` can verify that a `map` contains a key `<= 5`.|
-|`Pair(m1, m2)`           |`argument` is an `std::pair` whose `first` field matches `m1` and `second` field matches `m2`.                                                |
-|`Property(&class::property, m)`|`argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_.|
-
-## Matching the Result of a Function or Functor ##
-
-|`ResultOf(f, m)`|`f(argument)` matches matcher `m`, where `f` is a function or functor.|
-|:---------------|:---------------------------------------------------------------------|
-
-## Pointer Matchers ##
-
-|`Pointee(m)`|`argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`.|
-|:-----------|:-----------------------------------------------------------------------------------------------|
-
-## Multiargument Matchers ##
-
-Technically, all matchers match a _single_ value. A "multi-argument"
-matcher is just one that matches a _tuple_. The following matchers can
-be used to match a tuple `(x, y)`:
-
-|`Eq()`|`x == y`|
-|:-----|:-------|
-|`Ge()`|`x >= y`|
-|`Gt()`|`x > y` |
-|`Le()`|`x <= y`|
-|`Lt()`|`x < y` |
-|`Ne()`|`x != y`|
-
-You can use the following selectors to pick a subset of the arguments
-(or reorder them) to participate in the matching:
-
-|`AllArgs(m)`|Equivalent to `m`. Useful as syntactic sugar in `.With(AllArgs(m))`.|
-|:-----------|:-------------------------------------------------------------------|
-|`Args<N1, N2, ..., Nk>(m)`|The tuple of the `k` selected (using 0-based indices) arguments matches `m`, e.g. `Args<1, 2>(Eq())`.|
-
-## Composite Matchers ##
-
-You can make a matcher from one or more other matchers:
-
-|`AllOf(m1, m2, ..., mn)`|`argument` matches all of the matchers `m1` to `mn`.|
-|:-----------------------|:---------------------------------------------------|
-|`AnyOf(m1, m2, ..., mn)`|`argument` matches at least one of the matchers `m1` to `mn`.|
-|`Not(m)`                |`argument` doesn't match matcher `m`.               |
-
-## Adapters for Matchers ##
-
-|`MatcherCast<T>(m)`|casts matcher `m` to type `Matcher<T>`.|
-|:------------------|:--------------------------------------|
-|`SafeMatcherCast<T>(m)`| [safely casts](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Casting_Matchers) matcher `m` to type `Matcher<T>`. |
-|`Truly(predicate)` |`predicate(argument)` returns something considered by C++ to be true, where `predicate` is a function or functor.|
-
-## Matchers as Predicates ##
-
-|`Matches(m)(value)`|evaluates to `true` if `value` matches `m`. You can use `Matches(m)` alone as a unary functor.|
-|:------------------|:---------------------------------------------------------------------------------------------|
-|`ExplainMatchResult(m, value, result_listener)`|evaluates to `true` if `value` matches `m`, explaining the result to `result_listener`.       |
-|`Value(value, m)`  |evaluates to `true` if `value` matches `m`.                                                   |
-
-## Defining Matchers ##
-
-| `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. |
-|:-------------------------------------------------|:------------------------------------------------------|
-| `MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; }` | Defines a macher `IsDivisibleBy(n)` to match a number divisible by `n`. |
-| `MATCHER_P2(IsBetween, a, b, std::string(negation ? "isn't" : "is") + " between " + PrintToString(a) + " and " + PrintToString(b)) { return a <= arg && arg <= b; }` | Defines a matcher `IsBetween(a, b)` to match a value in the range [`a`, `b`]. |
-
-**Notes:**
-
-  1. The `MATCHER*` macros cannot be used inside a function or class.
-  1. The matcher body must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters).
-  1. You can use `PrintToString(x)` to convert a value `x` of any type to a string.
-
-## Matchers as Test Assertions ##
-
-|`ASSERT_THAT(expression, m)`|Generates a [fatal failure](http://code.google.com/p/googletest/wiki/Primer#Assertions) if the value of `expression` doesn't match matcher `m`.|
-|:---------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------|
-|`EXPECT_THAT(expression, m)`|Generates a non-fatal failure if the value of `expression` doesn't match matcher `m`.                                                          |
-
-# Actions #
-
-**Actions** specify what a mock function should do when invoked.
-
-## Returning a Value ##
-
-|`Return()`|Return from a `void` mock function.|
-|:---------|:----------------------------------|
-|`Return(value)`|Return `value`. If the type of `value` is different to the mock function's return type, `value` is converted to the latter type <i>at the time the expectation is set</i>, not when the action is executed.|
-|`ReturnArg<N>()`|Return the `N`-th (0-based) argument.|
-|`ReturnNew<T>(a1, ..., ak)`|Return `new T(a1, ..., ak)`; a different object is created each time.|
-|`ReturnNull()`|Return a null pointer.             |
-|`ReturnPointee(ptr)`|Return the value pointed to by `ptr`.|
-|`ReturnRef(variable)`|Return a reference to `variable`.  |
-|`ReturnRefOfCopy(value)`|Return a reference to a copy of `value`; the copy lives as long as the action.|
-
-## Side Effects ##
-
-|`Assign(&variable, value)`|Assign `value` to variable.|
-|:-------------------------|:--------------------------|
-| `DeleteArg<N>()`         | Delete the `N`-th (0-based) argument, which must be a pointer. |
-| `SaveArg<N>(pointer)`    | Save the `N`-th (0-based) argument to `*pointer`. |
-| `SaveArgPointee<N>(pointer)` | Save the value pointed to by the `N`-th (0-based) argument to `*pointer`. |
-| `SetArgReferee<N>(value)` |	Assign value to the variable referenced by the `N`-th (0-based) argument. |
-|`SetArgPointee<N>(value)` |Assign `value` to the variable pointed by the `N`-th (0-based) argument.|
-|`SetArgumentPointee<N>(value)`|Same as `SetArgPointee<N>(value)`. Deprecated. Will be removed in v1.7.0.|
-|`SetArrayArgument<N>(first, last)`|Copies the elements in source range [`first`, `last`) to the array pointed to by the `N`-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.|
-|`SetErrnoAndReturn(error, value)`|Set `errno` to `error` and return `value`.|
-|`Throw(exception)`        |Throws the given exception, which can be any copyable value. Available since v1.1.0.|
-
-## Using a Function or a Functor as an Action ##
-
-|`Invoke(f)`|Invoke `f` with the arguments passed to the mock function, where `f` can be a global/static function or a functor.|
-|:----------|:-----------------------------------------------------------------------------------------------------------------|
-|`Invoke(object_pointer, &class::method)`|Invoke the {method on the object with the arguments passed to the mock function.                                  |
-|`InvokeWithoutArgs(f)`|Invoke `f`, which can be a global/static function or a functor. `f` must take no arguments.                       |
-|`InvokeWithoutArgs(object_pointer, &class::method)`|Invoke the method on the object, which takes no arguments.                                                        |
-|`InvokeArgument<N>(arg1, arg2, ..., argk)`|Invoke the mock function's `N`-th (0-based) argument, which must be a function or a functor, with the `k` arguments.|
-
-The return value of the invoked function is used as the return value
-of the action.
-
-When defining a function or functor to be used with `Invoke*()`, you can declare any unused parameters as `Unused`:
-```
-  double Distance(Unused, double x, double y) { return sqrt(x*x + y*y); }
-  ...
-  EXPECT_CALL(mock, Foo("Hi", _, _)).WillOnce(Invoke(Distance));
-```
-
-In `InvokeArgument<N>(...)`, if an argument needs to be passed by reference, wrap it inside `ByRef()`. For example,
-```
-  InvokeArgument<2>(5, string("Hi"), ByRef(foo))
-```
-calls the mock function's #2 argument, passing to it `5` and `string("Hi")` by value, and `foo` by reference.
-
-## Default Action ##
-
-|`DoDefault()`|Do the default action (specified by `ON_CALL()` or the built-in one).|
-|:------------|:--------------------------------------------------------------------|
-
-**Note:** due to technical reasons, `DoDefault()` cannot be used inside  a composite action - trying to do so will result in a run-time error.
-
-## Composite Actions ##
-
-|`DoAll(a1, a2, ..., an)`|Do all actions `a1` to `an` and return the result of `an` in each invocation. The first `n - 1` sub-actions must return void. |
-|:-----------------------|:-----------------------------------------------------------------------------------------------------------------------------|
-|`IgnoreResult(a)`       |Perform action `a` and ignore its result. `a` must not return void.                                                           |
-|`WithArg<N>(a)`         |Pass the `N`-th (0-based) argument of the mock function to action `a` and perform it.                                         |
-|`WithArgs<N1, N2, ..., Nk>(a)`|Pass the selected (0-based) arguments of the mock function to action `a` and perform it.                                      |
-|`WithoutArgs(a)`        |Perform action `a` without any arguments.                                                                                     |
-
-## Defining Actions ##
-
-| `ACTION(Sum) { return arg0 + arg1; }` | Defines an action `Sum()` to return the sum of the mock function's argument #0 and #1. |
-|:--------------------------------------|:---------------------------------------------------------------------------------------|
-| `ACTION_P(Plus, n) { return arg0 + n; }` | Defines an action `Plus(n)` to return the sum of the mock function's argument #0 and `n`. |
-| `ACTION_Pk(Foo, p1, ..., pk) { statements; }` | Defines a parameterized action `Foo(p1, ..., pk)` to execute the given `statements`.   |
-
-The `ACTION*` macros cannot be used inside a function or class.
-
-# Cardinalities #
-
-These are used in `Times()` to specify how many times a mock function will be called:
-
-|`AnyNumber()`|The function can be called any number of times.|
-|:------------|:----------------------------------------------|
-|`AtLeast(n)` |The call is expected at least `n` times.       |
-|`AtMost(n)`  |The call is expected at most `n` times.        |
-|`Between(m, n)`|The call is expected between `m` and `n` (inclusive) times.|
-|`Exactly(n) or n`|The call is expected exactly `n` times. In particular, the call should never happen when `n` is 0.|
-
-# Expectation Order #
-
-By default, the expectations can be matched in _any_ order.  If some
-or all expectations must be matched in a given order, there are two
-ways to specify it.  They can be used either independently or
-together.
-
-## The After Clause ##
-
-```
-using ::testing::Expectation;
-...
-Expectation init_x = EXPECT_CALL(foo, InitX());
-Expectation init_y = EXPECT_CALL(foo, InitY());
-EXPECT_CALL(foo, Bar())
-    .After(init_x, init_y);
-```
-says that `Bar()` can be called only after both `InitX()` and
-`InitY()` have been called.
-
-If you don't know how many pre-requisites an expectation has when you
-write it, you can use an `ExpectationSet` to collect them:
-
-```
-using ::testing::ExpectationSet;
-...
-ExpectationSet all_inits;
-for (int i = 0; i < element_count; i++) {
-  all_inits += EXPECT_CALL(foo, InitElement(i));
-}
-EXPECT_CALL(foo, Bar())
-    .After(all_inits);
-```
-says that `Bar()` can be called only after all elements have been
-initialized (but we don't care about which elements get initialized
-before the others).
-
-Modifying an `ExpectationSet` after using it in an `.After()` doesn't
-affect the meaning of the `.After()`.
-
-## Sequences ##
-
-When you have a long chain of sequential expectations, it's easier to
-specify the order using **sequences**, which don't require you to given
-each expectation in the chain a different name.  <i>All expected<br>
-calls</i> in the same sequence must occur in the order they are
-specified.
-
-```
-using ::testing::Sequence;
-Sequence s1, s2;
-...
-EXPECT_CALL(foo, Reset())
-    .InSequence(s1, s2)
-    .WillOnce(Return(true));
-EXPECT_CALL(foo, GetSize())
-    .InSequence(s1)
-    .WillOnce(Return(1));
-EXPECT_CALL(foo, Describe(A<const char*>()))
-    .InSequence(s2)
-    .WillOnce(Return("dummy"));
-```
-says that `Reset()` must be called before _both_ `GetSize()` _and_
-`Describe()`, and the latter two can occur in any order.
-
-To put many expectations in a sequence conveniently:
-```
-using ::testing::InSequence;
-{
-  InSequence dummy;
-
-  EXPECT_CALL(...)...;
-  EXPECT_CALL(...)...;
-  ...
-  EXPECT_CALL(...)...;
-}
-```
-says that all expected calls in the scope of `dummy` must occur in
-strict order. The name `dummy` is irrelevant.)
-
-# Verifying and Resetting a Mock #
-
-Google Mock will verify the expectations on a mock object when it is destructed, or you can do it earlier:
-```
-using ::testing::Mock;
-...
-// Verifies and removes the expectations on mock_obj;
-// returns true iff successful.
-Mock::VerifyAndClearExpectations(&mock_obj);
-...
-// Verifies and removes the expectations on mock_obj;
-// also removes the default actions set by ON_CALL();
-// returns true iff successful.
-Mock::VerifyAndClear(&mock_obj);
-```
-
-You can also tell Google Mock that a mock object can be leaked and doesn't
-need to be verified:
-```
-Mock::AllowLeak(&mock_obj);
-```
-
-# Mock Classes #
-
-Google Mock defines a convenient mock class template
-```
-class MockFunction<R(A1, ..., An)> {
- public:
-  MOCK_METHODn(Call, R(A1, ..., An));
-};
-```
-See this [recipe](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Using_Check_Points) for one application of it.
-
-# Flags #
-
-| `--gmock_catch_leaked_mocks=0` | Don't report leaked mock objects as failures. |
-|:-------------------------------|:----------------------------------------------|
-| `--gmock_verbose=LEVEL`        | Sets the default verbosity level (`info`, `warning`, or `error`) of Google Mock messages. |
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CookBook.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CookBook.md
deleted file mode 100644
index 419a0010..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/CookBook.md
+++ /dev/null
@@ -1,3432 +0,0 @@
-
-
-You can find recipes for using Google Mock here. If you haven't yet,
-please read the [ForDummies](V1_7_ForDummies.md) document first to make sure you understand
-the basics.
-
-**Note:** Google Mock lives in the `testing` name space. For
-readability, it is recommended to write `using ::testing::Foo;` once in
-your file before using the name `Foo` defined by Google Mock. We omit
-such `using` statements in this page for brevity, but you should do it
-in your own code.
-
-# Creating Mock Classes #
-
-## Mocking Private or Protected Methods ##
-
-You must always put a mock method definition (`MOCK_METHOD*`) in a
-`public:` section of the mock class, regardless of the method being
-mocked being `public`, `protected`, or `private` in the base class.
-This allows `ON_CALL` and `EXPECT_CALL` to reference the mock function
-from outside of the mock class.  (Yes, C++ allows a subclass to change
-the access level of a virtual function in the base class.)  Example:
-
-```
-class Foo {
- public:
-  ...
-  virtual bool Transform(Gadget* g) = 0;
-
- protected:
-  virtual void Resume();
-
- private:
-  virtual int GetTimeOut();
-};
-
-class MockFoo : public Foo {
- public:
-  ...
-  MOCK_METHOD1(Transform, bool(Gadget* g));
-
-  // The following must be in the public section, even though the
-  // methods are protected or private in the base class.
-  MOCK_METHOD0(Resume, void());
-  MOCK_METHOD0(GetTimeOut, int());
-};
-```
-
-## Mocking Overloaded Methods ##
-
-You can mock overloaded functions as usual. No special attention is required:
-
-```
-class Foo {
-  ...
-
-  // Must be virtual as we'll inherit from Foo.
-  virtual ~Foo();
-
-  // Overloaded on the types and/or numbers of arguments.
-  virtual int Add(Element x);
-  virtual int Add(int times, Element x);
-
-  // Overloaded on the const-ness of this object.
-  virtual Bar& GetBar();
-  virtual const Bar& GetBar() const;
-};
-
-class MockFoo : public Foo {
-  ...
-  MOCK_METHOD1(Add, int(Element x));
-  MOCK_METHOD2(Add, int(int times, Element x);
-
-  MOCK_METHOD0(GetBar, Bar&());
-  MOCK_CONST_METHOD0(GetBar, const Bar&());
-};
-```
-
-**Note:** if you don't mock all versions of the overloaded method, the
-compiler will give you a warning about some methods in the base class
-being hidden. To fix that, use `using` to bring them in scope:
-
-```
-class MockFoo : public Foo {
-  ...
-  using Foo::Add;
-  MOCK_METHOD1(Add, int(Element x));
-  // We don't want to mock int Add(int times, Element x);
-  ...
-};
-```
-
-## Mocking Class Templates ##
-
-To mock a class template, append `_T` to the `MOCK_*` macros:
-
-```
-template <typename Elem>
-class StackInterface {
-  ...
-  // Must be virtual as we'll inherit from StackInterface.
-  virtual ~StackInterface();
-
-  virtual int GetSize() const = 0;
-  virtual void Push(const Elem& x) = 0;
-};
-
-template <typename Elem>
-class MockStack : public StackInterface<Elem> {
-  ...
-  MOCK_CONST_METHOD0_T(GetSize, int());
-  MOCK_METHOD1_T(Push, void(const Elem& x));
-};
-```
-
-## Mocking Nonvirtual Methods ##
-
-Google Mock can mock non-virtual functions to be used in what we call _hi-perf
-dependency injection_.
-
-In this case, instead of sharing a common base class with the real
-class, your mock class will be _unrelated_ to the real class, but
-contain methods with the same signatures.  The syntax for mocking
-non-virtual methods is the _same_ as mocking virtual methods:
-
-```
-// A simple packet stream class.  None of its members is virtual.
-class ConcretePacketStream {
- public:
-  void AppendPacket(Packet* new_packet);
-  const Packet* GetPacket(size_t packet_number) const;
-  size_t NumberOfPackets() const;
-  ...
-};
-
-// A mock packet stream class.  It inherits from no other, but defines
-// GetPacket() and NumberOfPackets().
-class MockPacketStream {
- public:
-  MOCK_CONST_METHOD1(GetPacket, const Packet*(size_t packet_number));
-  MOCK_CONST_METHOD0(NumberOfPackets, size_t());
-  ...
-};
-```
-
-Note that the mock class doesn't define `AppendPacket()`, unlike the
-real class. That's fine as long as the test doesn't need to call it.
-
-Next, you need a way to say that you want to use
-`ConcretePacketStream` in production code, and use `MockPacketStream`
-in tests.  Since the functions are not virtual and the two classes are
-unrelated, you must specify your choice at _compile time_ (as opposed
-to run time).
-
-One way to do it is to templatize your code that needs to use a packet
-stream.  More specifically, you will give your code a template type
-argument for the type of the packet stream.  In production, you will
-instantiate your template with `ConcretePacketStream` as the type
-argument.  In tests, you will instantiate the same template with
-`MockPacketStream`.  For example, you may write:
-
-```
-template <class PacketStream>
-void CreateConnection(PacketStream* stream) { ... }
-
-template <class PacketStream>
-class PacketReader {
- public:
-  void ReadPackets(PacketStream* stream, size_t packet_num);
-};
-```
-
-Then you can use `CreateConnection<ConcretePacketStream>()` and
-`PacketReader<ConcretePacketStream>` in production code, and use
-`CreateConnection<MockPacketStream>()` and
-`PacketReader<MockPacketStream>` in tests.
-
-```
-  MockPacketStream mock_stream;
-  EXPECT_CALL(mock_stream, ...)...;
-  .. set more expectations on mock_stream ...
-  PacketReader<MockPacketStream> reader(&mock_stream);
-  ... exercise reader ...
-```
-
-## Mocking Free Functions ##
-
-It's possible to use Google Mock to mock a free function (i.e. a
-C-style function or a static method).  You just need to rewrite your
-code to use an interface (abstract class).
-
-Instead of calling a free function (say, `OpenFile`) directly,
-introduce an interface for it and have a concrete subclass that calls
-the free function:
-
-```
-class FileInterface {
- public:
-  ...
-  virtual bool Open(const char* path, const char* mode) = 0;
-};
-
-class File : public FileInterface {
- public:
-  ...
-  virtual bool Open(const char* path, const char* mode) {
-    return OpenFile(path, mode);
-  }
-};
-```
-
-Your code should talk to `FileInterface` to open a file.  Now it's
-easy to mock out the function.
-
-This may seem much hassle, but in practice you often have multiple
-related functions that you can put in the same interface, so the
-per-function syntactic overhead will be much lower.
-
-If you are concerned about the performance overhead incurred by
-virtual functions, and profiling confirms your concern, you can
-combine this with the recipe for [mocking non-virtual methods](#Mocking_Nonvirtual_Methods.md).
-
-## The Nice, the Strict, and the Naggy ##
-
-If a mock method has no `EXPECT_CALL` spec but is called, Google Mock
-will print a warning about the "uninteresting call". The rationale is:
-
-  * New methods may be added to an interface after a test is written. We shouldn't fail a test just because a method it doesn't know about is called.
-  * However, this may also mean there's a bug in the test, so Google Mock shouldn't be silent either. If the user believes these calls are harmless, he can add an `EXPECT_CALL()` to suppress the warning.
-
-However, sometimes you may want to suppress all "uninteresting call"
-warnings, while sometimes you may want the opposite, i.e. to treat all
-of them as errors. Google Mock lets you make the decision on a
-per-mock-object basis.
-
-Suppose your test uses a mock class `MockFoo`:
-
-```
-TEST(...) {
-  MockFoo mock_foo;
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-}
-```
-
-If a method of `mock_foo` other than `DoThis()` is called, it will be
-reported by Google Mock as a warning. However, if you rewrite your
-test to use `NiceMock<MockFoo>` instead, the warning will be gone,
-resulting in a cleaner test output:
-
-```
-using ::testing::NiceMock;
-
-TEST(...) {
-  NiceMock<MockFoo> mock_foo;
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-}
-```
-
-`NiceMock<MockFoo>` is a subclass of `MockFoo`, so it can be used
-wherever `MockFoo` is accepted.
-
-It also works if `MockFoo`'s constructor takes some arguments, as
-`NiceMock<MockFoo>` "inherits" `MockFoo`'s constructors:
-
-```
-using ::testing::NiceMock;
-
-TEST(...) {
-  NiceMock<MockFoo> mock_foo(5, "hi");  // Calls MockFoo(5, "hi").
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-}
-```
-
-The usage of `StrictMock` is similar, except that it makes all
-uninteresting calls failures:
-
-```
-using ::testing::StrictMock;
-
-TEST(...) {
-  StrictMock<MockFoo> mock_foo;
-  EXPECT_CALL(mock_foo, DoThis());
-  ... code that uses mock_foo ...
-
-  // The test will fail if a method of mock_foo other than DoThis()
-  // is called.
-}
-```
-
-There are some caveats though (I don't like them just as much as the
-next guy, but sadly they are side effects of C++'s limitations):
-
-  1. `NiceMock<MockFoo>` and `StrictMock<MockFoo>` only work 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` and `StrictMock` (e.g. `NiceMock<StrictMock<MockFoo> >`) is **not** supported.
-  1. The constructors of the base mock (`MockFoo`) cannot have arguments passed by non-const reference, which happens to be banned by the [Google C++ style guide](http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml).
-  1. During the constructor or destructor of `MockFoo`, the mock object is _not_ nice or strict.  This may cause surprises if the constructor or destructor calls a mock method on `this` object. (This behavior, however, is consistent with C++'s general rule: if a constructor or destructor calls a virtual method of `this` object, that method is treated as non-virtual.  In other words, to the base class's constructor or destructor, `this` object behaves like an instance of the base class, not the derived class.  This rule is required for safety.  Otherwise a base constructor may use members of a derived class before they are initialized, or a base destructor may use members of a derived class after they have been destroyed.)
-
-Finally, you should be **very cautious** about when to use naggy or strict mocks, as they tend to make tests more brittle and harder to maintain. When you refactor your code without changing its externally visible behavior, ideally you should't need to update any tests. If your code interacts with a naggy mock, however, you may start to get spammed with warnings as the result of your change. Worse, if your code interacts with a strict mock, your tests may start to fail and you'll be forced to fix them. Our general recommendation is to use nice mocks (not yet the default) most of the time, use naggy mocks (the current default) when developing or debugging tests, and use strict mocks only as the last resort.
-
-## Simplifying the Interface without Breaking Existing Code ##
-
-Sometimes a method has a long list of arguments that is mostly
-uninteresting. For example,
-
-```
-class LogSink {
- public:
-  ...
-  virtual void send(LogSeverity severity, const char* full_filename,
-                    const char* base_filename, int line,
-                    const struct tm* tm_time,
-                    const char* message, size_t message_len) = 0;
-};
-```
-
-This method's argument list is lengthy and hard to work with (let's
-say that the `message` argument is not even 0-terminated). If we mock
-it as is, using the mock will be awkward. If, however, we try to
-simplify this interface, we'll need to fix all clients depending on
-it, which is often infeasible.
-
-The trick is to re-dispatch the method in the mock class:
-
-```
-class ScopedMockLog : public LogSink {
- public:
-  ...
-  virtual void send(LogSeverity severity, const char* full_filename,
-                    const char* base_filename, int line, const tm* tm_time,
-                    const char* message, size_t message_len) {
-    // We are only interested in the log severity, full file name, and
-    // log message.
-    Log(severity, full_filename, std::string(message, message_len));
-  }
-
-  // Implements the mock method:
-  //
-  //   void Log(LogSeverity severity,
-  //            const string& file_path,
-  //            const string& message);
-  MOCK_METHOD3(Log, void(LogSeverity severity, const string& file_path,
-                         const string& message));
-};
-```
-
-By defining a new mock method with a trimmed argument list, we make
-the mock class much more user-friendly.
-
-## Alternative to Mocking Concrete Classes ##
-
-Often you may find yourself using classes that don't implement
-interfaces. In order to test your code that uses such a class (let's
-call it `Concrete`), you may be tempted to make the methods of
-`Concrete` virtual and then mock it.
-
-Try not to do that.
-
-Making a non-virtual function virtual is a big decision. It creates an
-extension point where subclasses can tweak your class' behavior. This
-weakens your control on the class because now it's harder to maintain
-the class' invariants. You should make a function virtual only when
-there is a valid reason for a subclass to override it.
-
-Mocking concrete classes directly is problematic as it creates a tight
-coupling between the class and the tests - any small change in the
-class may invalidate your tests and make test maintenance a pain.
-
-To avoid such problems, many programmers have been practicing "coding
-to interfaces": instead of talking to the `Concrete` class, your code
-would define an interface and talk to it. Then you implement that
-interface as an adaptor on top of `Concrete`. In tests, you can easily
-mock that interface to observe how your code is doing.
-
-This technique incurs some overhead:
-
-  * You pay the cost of virtual function calls (usually not a problem).
-  * There is more abstraction for the programmers to learn.
-
-However, it can also bring significant benefits in addition to better
-testability:
-
-  * `Concrete`'s API may not fit your problem domain very well, as you may not be the only client it tries to serve. By designing your own interface, you have a chance to tailor it to your need - you may add higher-level functionalities, rename stuff, etc instead of just trimming the class. This allows you to write your code (user of the interface) in a more natural way, which means it will be more readable, more maintainable, and you'll be more productive.
-  * If `Concrete`'s implementation ever has to change, you don't have to rewrite everywhere it is used. Instead, you can absorb the change in your implementation of the interface, and your other code and tests will be insulated from this change.
-
-Some people worry that if everyone is practicing this technique, they
-will end up writing lots of redundant code. This concern is totally
-understandable. However, there are two reasons why it may not be the
-case:
-
-  * Different projects may need to use `Concrete` in different ways, so the best interfaces for them will be different. Therefore, each of them will have its own domain-specific interface on top of `Concrete`, and they will not be the same code.
-  * If enough projects want to use the same interface, they can always share it, just like they have been sharing `Concrete`. You can check in the interface and the adaptor somewhere near `Concrete` (perhaps in a `contrib` sub-directory) and let many projects use it.
-
-You need to weigh the pros and cons carefully for your particular
-problem, but I'd like to assure you that the Java community has been
-practicing this for a long time and it's a proven effective technique
-applicable in a wide variety of situations. :-)
-
-## Delegating Calls to a Fake ##
-
-Some times you have a non-trivial fake implementation of an
-interface. For example:
-
-```
-class Foo {
- public:
-  virtual ~Foo() {}
-  virtual char DoThis(int n) = 0;
-  virtual void DoThat(const char* s, int* p) = 0;
-};
-
-class FakeFoo : public Foo {
- public:
-  virtual char DoThis(int n) {
-    return (n > 0) ? '+' :
-        (n < 0) ? '-' : '0';
-  }
-
-  virtual void DoThat(const char* s, int* p) {
-    *p = strlen(s);
-  }
-};
-```
-
-Now you want to mock this interface such that you can set expectations
-on it. However, you also want to use `FakeFoo` for the default
-behavior, as duplicating it in the mock object is, well, a lot of
-work.
-
-When you define the mock class using Google Mock, you can have it
-delegate its default action to a fake class you already have, using
-this pattern:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-class MockFoo : public Foo {
- public:
-  // Normal mock method definitions using Google Mock.
-  MOCK_METHOD1(DoThis, char(int n));
-  MOCK_METHOD2(DoThat, void(const char* s, int* p));
-
-  // Delegates the default actions of the methods to a FakeFoo object.
-  // This must be called *before* the custom ON_CALL() statements.
-  void DelegateToFake() {
-    ON_CALL(*this, DoThis(_))
-        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThis));
-    ON_CALL(*this, DoThat(_, _))
-        .WillByDefault(Invoke(&fake_, &FakeFoo::DoThat));
-  }
- private:
-  FakeFoo fake_;  // Keeps an instance of the fake in the mock.
-};
-```
-
-With that, you can use `MockFoo` in your tests as usual. Just remember
-that if you don't explicitly set an action in an `ON_CALL()` or
-`EXPECT_CALL()`, the fake will be called upon to do it:
-
-```
-using ::testing::_;
-
-TEST(AbcTest, Xyz) {
-  MockFoo foo;
-  foo.DelegateToFake(); // Enables the fake for delegation.
-
-  // Put your ON_CALL(foo, ...)s here, if any.
-
-  // No action specified, meaning to use the default action.
-  EXPECT_CALL(foo, DoThis(5));
-  EXPECT_CALL(foo, DoThat(_, _));
-
-  int n = 0;
-  EXPECT_EQ('+', foo.DoThis(5));  // FakeFoo::DoThis() is invoked.
-  foo.DoThat("Hi", &n);           // FakeFoo::DoThat() is invoked.
-  EXPECT_EQ(2, n);
-}
-```
-
-**Some tips:**
-
-  * If you want, you can still override the default action by providing your own `ON_CALL()` or using `.WillOnce()` / `.WillRepeatedly()` in `EXPECT_CALL()`.
-  * In `DelegateToFake()`, you only need to delegate the methods whose fake implementation you intend to use.
-  * The general technique discussed here works for overloaded methods, but you'll need to tell the compiler which version you mean. To disambiguate a mock function (the one you specify inside the parentheses of `ON_CALL()`), see the "Selecting Between Overloaded Functions" section on this page; to disambiguate a fake function (the one you place inside `Invoke()`), use a `static_cast` to specify the function's type. For instance, if class `Foo` has methods `char DoThis(int n)` and `bool DoThis(double x) const`, and you want to invoke the latter, you need to write `Invoke(&fake_, static_cast<bool (FakeFoo::*)(double) const>(&FakeFoo::DoThis))` instead of `Invoke(&fake_, &FakeFoo::DoThis)` (The strange-looking thing inside the angled brackets of `static_cast` is the type of a function pointer to the second `DoThis()` method.).
-  * Having to mix a mock and a fake is often a sign of something gone wrong. Perhaps you haven't got used to the interaction-based way of testing yet. Or perhaps your interface is taking on too many roles and should be split up. Therefore, **don't abuse this**. We would only recommend to do it as an intermediate step when you are refactoring your code.
-
-Regarding the tip on mixing a mock and a fake, here's an example on
-why it may be a bad sign: Suppose you have a class `System` for
-low-level system operations. In particular, it does file and I/O
-operations. And suppose you want to test how your code uses `System`
-to do I/O, and you just want the file operations to work normally. If
-you mock out the entire `System` class, you'll have to provide a fake
-implementation for the file operation part, which suggests that
-`System` is taking on too many roles.
-
-Instead, you can define a `FileOps` interface and an `IOOps` interface
-and split `System`'s functionalities into the two. Then you can mock
-`IOOps` without mocking `FileOps`.
-
-## Delegating Calls to a Real Object ##
-
-When using testing doubles (mocks, fakes, stubs, and etc), sometimes
-their behaviors will differ from those of the real objects. This
-difference could be either intentional (as in simulating an error such
-that you can test the error handling code) or unintentional. If your
-mocks have different behaviors than the real objects by mistake, you
-could end up with code that passes the tests but fails in production.
-
-You can use the _delegating-to-real_ technique to ensure that your
-mock has the same behavior as the real object while retaining the
-ability to validate calls. This technique is very similar to the
-delegating-to-fake technique, the difference being that we use a real
-object instead of a fake. Here's an example:
-
-```
-using ::testing::_;
-using ::testing::AtLeast;
-using ::testing::Invoke;
-
-class MockFoo : public Foo {
- public:
-  MockFoo() {
-    // By default, all calls are delegated to the real object.
-    ON_CALL(*this, DoThis())
-        .WillByDefault(Invoke(&real_, &Foo::DoThis));
-    ON_CALL(*this, DoThat(_))
-        .WillByDefault(Invoke(&real_, &Foo::DoThat));
-    ...
-  }
-  MOCK_METHOD0(DoThis, ...);
-  MOCK_METHOD1(DoThat, ...);
-  ...
- private:
-  Foo real_;
-};
-...
-
-  MockFoo mock;
-
-  EXPECT_CALL(mock, DoThis())
-      .Times(3);
-  EXPECT_CALL(mock, DoThat("Hi"))
-      .Times(AtLeast(1));
-  ... use mock in test ...
-```
-
-With this, Google Mock will verify that your code made the right calls
-(with the right arguments, in the right order, called the right number
-of times, etc), and a real object will answer the calls (so the
-behavior will be the same as in production). This gives you the best
-of both worlds.
-
-## Delegating Calls to a Parent Class ##
-
-Ideally, you should code to interfaces, whose methods are all pure
-virtual. In reality, sometimes you do need to mock a virtual method
-that is not pure (i.e, it already has an implementation). For example:
-
-```
-class Foo {
- public:
-  virtual ~Foo();
-
-  virtual void Pure(int n) = 0;
-  virtual int Concrete(const char* str) { ... }
-};
-
-class MockFoo : public Foo {
- public:
-  // Mocking a pure method.
-  MOCK_METHOD1(Pure, void(int n));
-  // Mocking a concrete method.  Foo::Concrete() is shadowed.
-  MOCK_METHOD1(Concrete, int(const char* str));
-};
-```
-
-Sometimes you may want to call `Foo::Concrete()` instead of
-`MockFoo::Concrete()`. Perhaps you want to do it as part of a stub
-action, or perhaps your test doesn't need to mock `Concrete()` at all
-(but it would be oh-so painful to have to define a new mock class
-whenever you don't need to mock one of its methods).
-
-The trick is to leave a back door in your mock class for accessing the
-real methods in the base class:
-
-```
-class MockFoo : public Foo {
- public:
-  // Mocking a pure method.
-  MOCK_METHOD1(Pure, void(int n));
-  // Mocking a concrete method.  Foo::Concrete() is shadowed.
-  MOCK_METHOD1(Concrete, int(const char* str));
-
-  // Use this to call Concrete() defined in Foo.
-  int FooConcrete(const char* str) { return Foo::Concrete(str); }
-};
-```
-
-Now, you can call `Foo::Concrete()` inside an action by:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-...
-  EXPECT_CALL(foo, Concrete(_))
-      .WillOnce(Invoke(&foo, &MockFoo::FooConcrete));
-```
-
-or tell the mock object that you don't want to mock `Concrete()`:
-
-```
-using ::testing::Invoke;
-...
-  ON_CALL(foo, Concrete(_))
-      .WillByDefault(Invoke(&foo, &MockFoo::FooConcrete));
-```
-
-(Why don't we just write `Invoke(&foo, &Foo::Concrete)`? If you do
-that, `MockFoo::Concrete()` will be called (and cause an infinite
-recursion) since `Foo::Concrete()` is virtual. That's just how C++
-works.)
-
-# Using Matchers #
-
-## Matching Argument Values Exactly ##
-
-You can specify exactly which arguments a mock method is expecting:
-
-```
-using ::testing::Return;
-...
-  EXPECT_CALL(foo, DoThis(5))
-      .WillOnce(Return('a'));
-  EXPECT_CALL(foo, DoThat("Hello", bar));
-```
-
-## Using Simple Matchers ##
-
-You can use matchers to match arguments that have a certain property:
-
-```
-using ::testing::Ge;
-using ::testing::NotNull;
-using ::testing::Return;
-...
-  EXPECT_CALL(foo, DoThis(Ge(5)))  // The argument must be >= 5.
-      .WillOnce(Return('a'));
-  EXPECT_CALL(foo, DoThat("Hello", NotNull()));
-  // The second argument must not be NULL.
-```
-
-A frequently used matcher is `_`, which matches anything:
-
-```
-using ::testing::_;
-using ::testing::NotNull;
-...
-  EXPECT_CALL(foo, DoThat(_, NotNull()));
-```
-
-## Combining Matchers ##
-
-You can build complex matchers from existing ones using `AllOf()`,
-`AnyOf()`, and `Not()`:
-
-```
-using ::testing::AllOf;
-using ::testing::Gt;
-using ::testing::HasSubstr;
-using ::testing::Ne;
-using ::testing::Not;
-...
-  // The argument must be > 5 and != 10.
-  EXPECT_CALL(foo, DoThis(AllOf(Gt(5),
-                                Ne(10))));
-
-  // The first argument must not contain sub-string "blah".
-  EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")),
-                          NULL));
-```
-
-## Casting Matchers ##
-
-Google Mock matchers are statically typed, meaning that the compiler
-can catch your mistake if you use a matcher of the wrong type (for
-example, if you use `Eq(5)` to match a `string` argument). Good for
-you!
-
-Sometimes, however, you know what you're doing and want the compiler
-to give you some slack. One example is that you have a matcher for
-`long` and the argument you want to match is `int`. While the two
-types aren't exactly the same, there is nothing really wrong with
-using a `Matcher<long>` to match an `int` - after all, we can first
-convert the `int` argument to a `long` before giving it to the
-matcher.
-
-To support this need, Google Mock gives you the
-`SafeMatcherCast<T>(m)` function. It casts a matcher `m` to type
-`Matcher<T>`. To ensure safety, Google Mock checks that (let `U` be the
-type `m` accepts):
-
-  1. Type `T` can be implicitly cast to type `U`;
-  1. When both `T` and `U` are built-in arithmetic types (`bool`, integers, and floating-point numbers), the conversion from `T` to `U` is not lossy (in other words, any value representable by `T` can also be represented by `U`); and
-  1. When `U` is a reference, `T` must also be a reference (as the underlying matcher may be interested in the address of the `U` value).
-
-The code won't compile if any of these conditions isn't met.
-
-Here's one example:
-
-```
-using ::testing::SafeMatcherCast;
-
-// A base class and a child class.
-class Base { ... };
-class Derived : public Base { ... };
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(DoThis, void(Derived* derived));
-};
-...
-
-  MockFoo foo;
-  // m is a Matcher<Base*> we got from somewhere.
-  EXPECT_CALL(foo, DoThis(SafeMatcherCast<Derived*>(m)));
-```
-
-If you find `SafeMatcherCast<T>(m)` too limiting, you can use a similar
-function `MatcherCast<T>(m)`. The difference is that `MatcherCast` works
-as long as you can `static_cast` type `T` to type `U`.
-
-`MatcherCast` essentially lets you bypass C++'s type system
-(`static_cast` isn't always safe as it could throw away information,
-for example), so be careful not to misuse/abuse it.
-
-## Selecting Between Overloaded Functions ##
-
-If you expect an overloaded function to be called, the compiler may
-need some help on which overloaded version it is.
-
-To disambiguate functions overloaded on the const-ness of this object,
-use the `Const()` argument wrapper.
-
-```
-using ::testing::ReturnRef;
-
-class MockFoo : public Foo {
-  ...
-  MOCK_METHOD0(GetBar, Bar&());
-  MOCK_CONST_METHOD0(GetBar, const Bar&());
-};
-...
-
-  MockFoo foo;
-  Bar bar1, bar2;
-  EXPECT_CALL(foo, GetBar())         // The non-const GetBar().
-      .WillOnce(ReturnRef(bar1));
-  EXPECT_CALL(Const(foo), GetBar())  // The const GetBar().
-      .WillOnce(ReturnRef(bar2));
-```
-
-(`Const()` is defined by Google Mock and returns a `const` reference
-to its argument.)
-
-To disambiguate overloaded functions with the same number of arguments
-but different argument types, you may need to specify the exact type
-of a matcher, either by wrapping your matcher in `Matcher<type>()`, or
-using a matcher whose type is fixed (`TypedEq<type>`, `An<type>()`,
-etc):
-
-```
-using ::testing::An;
-using ::testing::Lt;
-using ::testing::Matcher;
-using ::testing::TypedEq;
-
-class MockPrinter : public Printer {
- public:
-  MOCK_METHOD1(Print, void(int n));
-  MOCK_METHOD1(Print, void(char c));
-};
-
-TEST(PrinterTest, Print) {
-  MockPrinter printer;
-
-  EXPECT_CALL(printer, Print(An<int>()));            // void Print(int);
-  EXPECT_CALL(printer, Print(Matcher<int>(Lt(5))));  // void Print(int);
-  EXPECT_CALL(printer, Print(TypedEq<char>('a')));   // void Print(char);
-
-  printer.Print(3);
-  printer.Print(6);
-  printer.Print('a');
-}
-```
-
-## Performing Different Actions Based on the Arguments ##
-
-When a mock method is called, the _last_ matching expectation that's
-still active will be selected (think "newer overrides older"). So, you
-can make a method do different things depending on its argument values
-like this:
-
-```
-using ::testing::_;
-using ::testing::Lt;
-using ::testing::Return;
-...
-  // The default case.
-  EXPECT_CALL(foo, DoThis(_))
-      .WillRepeatedly(Return('b'));
-
-  // The more specific case.
-  EXPECT_CALL(foo, DoThis(Lt(5)))
-      .WillRepeatedly(Return('a'));
-```
-
-Now, if `foo.DoThis()` is called with a value less than 5, `'a'` will
-be returned; otherwise `'b'` will be returned.
-
-## Matching Multiple Arguments as a Whole ##
-
-Sometimes it's not enough to match the arguments individually. For
-example, we may want to say that the first argument must be less than
-the second argument. The `With()` clause allows us to match
-all arguments of a mock function as a whole. For example,
-
-```
-using ::testing::_;
-using ::testing::Lt;
-using ::testing::Ne;
-...
-  EXPECT_CALL(foo, InRange(Ne(0), _))
-      .With(Lt());
-```
-
-says that the first argument of `InRange()` must not be 0, and must be
-less than the second argument.
-
-The expression inside `With()` must be a matcher of type
-`Matcher<tr1::tuple<A1, ..., An> >`, where `A1`, ..., `An` are the
-types of the function arguments.
-
-You can also write `AllArgs(m)` instead of `m` inside `.With()`. The
-two forms are equivalent, but `.With(AllArgs(Lt()))` is more readable
-than `.With(Lt())`.
-
-You can use `Args<k1, ..., kn>(m)` to match the `n` selected arguments
-(as a tuple) against `m`. For example,
-
-```
-using ::testing::_;
-using ::testing::AllOf;
-using ::testing::Args;
-using ::testing::Lt;
-...
-  EXPECT_CALL(foo, Blah(_, _, _))
-      .With(AllOf(Args<0, 1>(Lt()), Args<1, 2>(Lt())));
-```
-
-says that `Blah()` will be called with arguments `x`, `y`, and `z` where
-`x < y < z`.
-
-As a convenience and example, Google Mock provides some matchers for
-2-tuples, including the `Lt()` matcher above. See the [CheatSheet](V1_7_CheatSheet.md) for
-the complete list.
-
-Note that if you want to pass the arguments to a predicate of your own
-(e.g. `.With(Args<0, 1>(Truly(&MyPredicate)))`), that predicate MUST be
-written to take a `tr1::tuple` as its argument; Google Mock will pass the `n`
-selected arguments as _one_ single tuple to the predicate.
-
-## Using Matchers as Predicates ##
-
-Have you noticed that a matcher is just a fancy predicate that also
-knows how to describe itself? Many existing algorithms take predicates
-as arguments (e.g. those defined in STL's `<algorithm>` header), and
-it would be a shame if Google Mock matchers are not allowed to
-participate.
-
-Luckily, you can use a matcher where a unary predicate functor is
-expected by wrapping it inside the `Matches()` function. For example,
-
-```
-#include <algorithm>
-#include <vector>
-
-std::vector<int> v;
-...
-// How many elements in v are >= 10?
-const int count = count_if(v.begin(), v.end(), Matches(Ge(10)));
-```
-
-Since you can build complex matchers from simpler ones easily using
-Google Mock, this gives you a way to conveniently construct composite
-predicates (doing the same using STL's `<functional>` header is just
-painful). For example, here's a predicate that's satisfied by any
-number that is >= 0, <= 100, and != 50:
-
-```
-Matches(AllOf(Ge(0), Le(100), Ne(50)))
-```
-
-## Using Matchers in Google Test Assertions ##
-
-Since matchers are basically predicates that also know how to describe
-themselves, there is a way to take advantage of them in
-[Google Test](http://code.google.com/p/googletest/) assertions. It's
-called `ASSERT_THAT` and `EXPECT_THAT`:
-
-```
-  ASSERT_THAT(value, matcher);  // Asserts that value matches matcher.
-  EXPECT_THAT(value, matcher);  // The non-fatal version.
-```
-
-For example, in a Google Test test you can write:
-
-```
-#include "gmock/gmock.h"
-
-using ::testing::AllOf;
-using ::testing::Ge;
-using ::testing::Le;
-using ::testing::MatchesRegex;
-using ::testing::StartsWith;
-...
-
-  EXPECT_THAT(Foo(), StartsWith("Hello"));
-  EXPECT_THAT(Bar(), MatchesRegex("Line \\d+"));
-  ASSERT_THAT(Baz(), AllOf(Ge(5), Le(10)));
-```
-
-which (as you can probably guess) executes `Foo()`, `Bar()`, and
-`Baz()`, and verifies that:
-
-  * `Foo()` returns a string that starts with `"Hello"`.
-  * `Bar()` returns a string that matches regular expression `"Line \\d+"`.
-  * `Baz()` returns a number in the range [5, 10].
-
-The nice thing about these macros is that _they read like
-English_. They generate informative messages too. For example, if the
-first `EXPECT_THAT()` above fails, the message will be something like:
-
-```
-Value of: Foo()
-  Actual: "Hi, world!"
-Expected: starts with "Hello"
-```
-
-**Credit:** The idea of `(ASSERT|EXPECT)_THAT` was stolen from the
-[Hamcrest](http://code.google.com/p/hamcrest/) project, which adds
-`assertThat()` to JUnit.
-
-## Using Predicates as Matchers ##
-
-Google Mock provides a built-in set of matchers. In case you find them
-lacking, you can use an arbitray unary predicate function or functor
-as a matcher - as long as the predicate accepts a value of the type
-you want. You do this by wrapping the predicate inside the `Truly()`
-function, for example:
-
-```
-using ::testing::Truly;
-
-int IsEven(int n) { return (n % 2) == 0 ? 1 : 0; }
-...
-
-  // Bar() must be called with an even number.
-  EXPECT_CALL(foo, Bar(Truly(IsEven)));
-```
-
-Note that the predicate function / functor doesn't have to return
-`bool`. It works as long as the return value can be used as the
-condition in statement `if (condition) ...`.
-
-## Matching Arguments that Are Not Copyable ##
-
-When you do an `EXPECT_CALL(mock_obj, Foo(bar))`, Google Mock saves
-away a copy of `bar`. When `Foo()` is called later, Google Mock
-compares the argument to `Foo()` with the saved copy of `bar`. This
-way, you don't need to worry about `bar` being modified or destroyed
-after the `EXPECT_CALL()` is executed. The same is true when you use
-matchers like `Eq(bar)`, `Le(bar)`, and so on.
-
-But what if `bar` cannot be copied (i.e. has no copy constructor)? You
-could define your own matcher function and use it with `Truly()`, as
-the previous couple of recipes have shown. Or, you may be able to get
-away from it if you can guarantee that `bar` won't be changed after
-the `EXPECT_CALL()` is executed. Just tell Google Mock that it should
-save a reference to `bar`, instead of a copy of it. Here's how:
-
-```
-using ::testing::Eq;
-using ::testing::ByRef;
-using ::testing::Lt;
-...
-  // Expects that Foo()'s argument == bar.
-  EXPECT_CALL(mock_obj, Foo(Eq(ByRef(bar))));
-
-  // Expects that Foo()'s argument < bar.
-  EXPECT_CALL(mock_obj, Foo(Lt(ByRef(bar))));
-```
-
-Remember: if you do this, don't change `bar` after the
-`EXPECT_CALL()`, or the result is undefined.
-
-## Validating a Member of an Object ##
-
-Often a mock function takes a reference to object as an argument. When
-matching the argument, you may not want to compare the entire object
-against a fixed object, as that may be over-specification. Instead,
-you may need to validate a certain member variable or the result of a
-certain getter method of the object. You can do this with `Field()`
-and `Property()`. More specifically,
-
-```
-Field(&Foo::bar, m)
-```
-
-is a matcher that matches a `Foo` object whose `bar` member variable
-satisfies matcher `m`.
-
-```
-Property(&Foo::baz, m)
-```
-
-is a matcher that matches a `Foo` object whose `baz()` method returns
-a value that satisfies matcher `m`.
-
-For example:
-
-> | `Field(&Foo::number, Ge(3))` | Matches `x` where `x.number >= 3`. |
-|:-----------------------------|:-----------------------------------|
-> | `Property(&Foo::name, StartsWith("John "))` | Matches `x` where `x.name()` starts with `"John "`. |
-
-Note that in `Property(&Foo::baz, ...)`, method `baz()` must take no
-argument and be declared as `const`.
-
-BTW, `Field()` and `Property()` can also match plain pointers to
-objects. For instance,
-
-```
-Field(&Foo::number, Ge(3))
-```
-
-matches a plain pointer `p` where `p->number >= 3`. If `p` is `NULL`,
-the match will always fail regardless of the inner matcher.
-
-What if you want to validate more than one members at the same time?
-Remember that there is `AllOf()`.
-
-## Validating the Value Pointed to by a Pointer Argument ##
-
-C++ functions often take pointers as arguments. You can use matchers
-like `IsNull()`, `NotNull()`, and other comparison matchers to match a
-pointer, but what if you want to make sure the value _pointed to_ by
-the pointer, instead of the pointer itself, has a certain property?
-Well, you can use the `Pointee(m)` matcher.
-
-`Pointee(m)` matches a pointer iff `m` matches the value the pointer
-points to. For example:
-
-```
-using ::testing::Ge;
-using ::testing::Pointee;
-...
-  EXPECT_CALL(foo, Bar(Pointee(Ge(3))));
-```
-
-expects `foo.Bar()` to be called with a pointer that points to a value
-greater than or equal to 3.
-
-One nice thing about `Pointee()` is that it treats a `NULL` pointer as
-a match failure, so you can write `Pointee(m)` instead of
-
-```
-  AllOf(NotNull(), Pointee(m))
-```
-
-without worrying that a `NULL` pointer will crash your test.
-
-Also, did we tell you that `Pointee()` works with both raw pointers
-**and** smart pointers (`linked_ptr`, `shared_ptr`, `scoped_ptr`, and
-etc)?
-
-What if you have a pointer to pointer? You guessed it - you can use
-nested `Pointee()` to probe deeper inside the value. For example,
-`Pointee(Pointee(Lt(3)))` matches a pointer that points to a pointer
-that points to a number less than 3 (what a mouthful...).
-
-## Testing a Certain Property of an Object ##
-
-Sometimes you want to specify that an object argument has a certain
-property, but there is no existing matcher that does this. If you want
-good error messages, you should define a matcher. If you want to do it
-quick and dirty, you could get away with writing an ordinary function.
-
-Let's say you have a mock function that takes an object of type `Foo`,
-which has an `int bar()` method and an `int baz()` method, and you
-want to constrain that the argument's `bar()` value plus its `baz()`
-value is a given number. Here's how you can define a matcher to do it:
-
-```
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-
-class BarPlusBazEqMatcher : public MatcherInterface<const Foo&> {
- public:
-  explicit BarPlusBazEqMatcher(int expected_sum)
-      : expected_sum_(expected_sum) {}
-
-  virtual bool MatchAndExplain(const Foo& foo,
-                               MatchResultListener* listener) const {
-    return (foo.bar() + foo.baz()) == expected_sum_;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "bar() + baz() equals " << expected_sum_;
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "bar() + baz() does not equal " << expected_sum_;
-  }
- private:
-  const int expected_sum_;
-};
-
-inline Matcher<const Foo&> BarPlusBazEq(int expected_sum) {
-  return MakeMatcher(new BarPlusBazEqMatcher(expected_sum));
-}
-
-...
-
-  EXPECT_CALL(..., DoThis(BarPlusBazEq(5)))...;
-```
-
-## Matching Containers ##
-
-Sometimes an STL container (e.g. list, vector, map, ...) is passed to
-a mock function and you may want to validate it. Since most STL
-containers support the `==` operator, you can write
-`Eq(expected_container)` or simply `expected_container` to match a
-container exactly.
-
-Sometimes, though, you may want to be more flexible (for example, the
-first element must be an exact match, but the second element can be
-any positive number, and so on). Also, containers used in tests often
-have a small number of elements, and having to define the expected
-container out-of-line is a bit of a hassle.
-
-You can use the `ElementsAre()` or `UnorderedElementsAre()` matcher in
-such cases:
-
-```
-using ::testing::_;
-using ::testing::ElementsAre;
-using ::testing::Gt;
-...
-
-  MOCK_METHOD1(Foo, void(const vector<int>& numbers));
-...
-
-  EXPECT_CALL(mock, Foo(ElementsAre(1, Gt(0), _, 5)));
-```
-
-The above matcher says that the container must have 4 elements, which
-must be 1, greater than 0, anything, and 5 respectively.
-
-If you instead write:
-
-```
-using ::testing::_;
-using ::testing::Gt;
-using ::testing::UnorderedElementsAre;
-...
-
-  MOCK_METHOD1(Foo, void(const vector<int>& numbers));
-...
-
-  EXPECT_CALL(mock, Foo(UnorderedElementsAre(1, Gt(0), _, 5)));
-```
-
-It means that the container must have 4 elements, which under some
-permutation must be 1, greater than 0, anything, and 5 respectively.
-
-`ElementsAre()` and `UnorderedElementsAre()` are overloaded to take 0
-to 10 arguments. If more are needed, you can place them in a C-style
-array and use `ElementsAreArray()` or `UnorderedElementsAreArray()`
-instead:
-
-```
-using ::testing::ElementsAreArray;
-...
-
-  // ElementsAreArray accepts an array of element values.
-  const int expected_vector1[] = { 1, 5, 2, 4, ... };
-  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector1)));
-
-  // Or, an array of element matchers.
-  Matcher<int> expected_vector2 = { 1, Gt(2), _, 3, ... };
-  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector2)));
-```
-
-In case the array needs to be dynamically created (and therefore the
-array size cannot be inferred by the compiler), you can give
-`ElementsAreArray()` an additional argument to specify the array size:
-
-```
-using ::testing::ElementsAreArray;
-...
-  int* const expected_vector3 = new int[count];
-  ... fill expected_vector3 with values ...
-  EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector3, count)));
-```
-
-**Tips:**
-
-  * `ElementsAre*()` can be used to match _any_ container that implements the STL iterator pattern (i.e. it has a `const_iterator` type and supports `begin()/end()`), not just the ones defined in STL. It will even work with container types yet to be written - as long as they follows the above pattern.
-  * You can use nested `ElementsAre*()` to match nested (multi-dimensional) containers.
-  * If the container is passed by pointer instead of by reference, just write `Pointee(ElementsAre*(...))`.
-  * The order of elements _matters_ for `ElementsAre*()`. Therefore don't use it with containers whose element order is undefined (e.g. `hash_map`).
-
-## Sharing Matchers ##
-
-Under the hood, a Google Mock matcher object consists of a pointer to
-a ref-counted implementation object. Copying matchers is allowed and
-very efficient, as only the pointer is copied. When the last matcher
-that references the implementation object dies, the implementation
-object will be deleted.
-
-Therefore, if you have some complex matcher that you want to use again
-and again, there is no need to build it everytime. Just assign it to a
-matcher variable and use that variable repeatedly! For example,
-
-```
-  Matcher<int> in_range = AllOf(Gt(5), Le(10));
-  ... use in_range as a matcher in multiple EXPECT_CALLs ...
-```
-
-# Setting Expectations #
-
-## Knowing When to Expect ##
-
-`ON_CALL` is likely the single most under-utilized construct in Google Mock.
-
-There are basically two constructs for defining the behavior of a mock object: `ON_CALL` and `EXPECT_CALL`. The difference? `ON_CALL` defines what happens when a mock method is called, but _doesn't imply any expectation on the method being called._ `EXPECT_CALL` not only defines the behavior, but also sets an expectation that _the method will be called with the given arguments, for the given number of times_ (and _in the given order_ when you specify the order too).
-
-Since `EXPECT_CALL` does more, isn't it better than `ON_CALL`? Not really. Every `EXPECT_CALL` adds a constraint on the behavior of the code under test. Having more constraints than necessary is _baaad_ - even worse than not having enough constraints.
-
-This may be counter-intuitive. How could tests that verify more be worse than tests that verify less? Isn't verification the whole point of tests?
-
-The answer, lies in _what_ a test should verify. **A good test verifies the contract of the code.** If a test over-specifies, it doesn't leave enough freedom to the implementation. As a result, changing the implementation without breaking the contract (e.g. refactoring and optimization), which should be perfectly fine to do, can break such tests. Then you have to spend time fixing them, only to see them broken again the next time the implementation is changed.
-
-Keep in mind that one doesn't have to verify more than one property in one test. In fact, **it's a good style to verify only one thing in one test.** If you do that, a bug will likely break only one or two tests instead of dozens (which case would you rather debug?). If you are also in the habit of giving tests descriptive names that tell what they verify, you can often easily guess what's wrong just from the test log itself.
-
-So use `ON_CALL` by default, and only use `EXPECT_CALL` when you actually intend to verify that the call is made. For example, you may have a bunch of `ON_CALL`s in your test fixture to set the common mock behavior shared by all tests in the same group, and write (scarcely) different `EXPECT_CALL`s in different `TEST_F`s to verify different aspects of the code's behavior. Compared with the style where each `TEST` has many `EXPECT_CALL`s, this leads to tests that are more resilient to implementational changes (and thus less likely to require maintenance) and makes the intent of the tests more obvious (so they are easier to maintain when you do need to maintain them).
-
-## Ignoring Uninteresting Calls ##
-
-If you are not interested in how a mock method is called, just don't
-say anything about it. In this case, if the method is ever called,
-Google Mock will perform its default action to allow the test program
-to continue. If you are not happy with the default action taken by
-Google Mock, you can override it using `DefaultValue<T>::Set()`
-(described later in this document) or `ON_CALL()`.
-
-Please note that once you expressed interest in a particular mock
-method (via `EXPECT_CALL()`), all invocations to it must match some
-expectation. If this function is called but the arguments don't match
-any `EXPECT_CALL()` statement, it will be an error.
-
-## Disallowing Unexpected Calls ##
-
-If a mock method shouldn't be called at all, explicitly say so:
-
-```
-using ::testing::_;
-...
-  EXPECT_CALL(foo, Bar(_))
-      .Times(0);
-```
-
-If some calls to the method are allowed, but the rest are not, just
-list all the expected calls:
-
-```
-using ::testing::AnyNumber;
-using ::testing::Gt;
-...
-  EXPECT_CALL(foo, Bar(5));
-  EXPECT_CALL(foo, Bar(Gt(10)))
-      .Times(AnyNumber());
-```
-
-A call to `foo.Bar()` that doesn't match any of the `EXPECT_CALL()`
-statements will be an error.
-
-## Expecting Ordered Calls ##
-
-Although an `EXPECT_CALL()` statement defined earlier takes precedence
-when Google Mock tries to match a function call with an expectation,
-by default calls don't have to happen in the order `EXPECT_CALL()`
-statements are written. For example, if the arguments match the
-matchers in the third `EXPECT_CALL()`, but not those in the first two,
-then the third expectation will be used.
-
-If you would rather have all calls occur in the order of the
-expectations, put the `EXPECT_CALL()` statements in a block where you
-define a variable of type `InSequence`:
-
-```
-  using ::testing::_;
-  using ::testing::InSequence;
-
-  {
-    InSequence s;
-
-    EXPECT_CALL(foo, DoThis(5));
-    EXPECT_CALL(bar, DoThat(_))
-        .Times(2);
-    EXPECT_CALL(foo, DoThis(6));
-  }
-```
-
-In this example, we expect a call to `foo.DoThis(5)`, followed by two
-calls to `bar.DoThat()` where the argument can be anything, which are
-in turn followed by a call to `foo.DoThis(6)`. If a call occurred
-out-of-order, Google Mock will report an error.
-
-## Expecting Partially Ordered Calls ##
-
-Sometimes requiring everything to occur in a predetermined order can
-lead to brittle tests. For example, we may care about `A` occurring
-before both `B` and `C`, but aren't interested in the relative order
-of `B` and `C`. In this case, the test should reflect our real intent,
-instead of being overly constraining.
-
-Google Mock allows you to impose an arbitrary DAG (directed acyclic
-graph) on the calls. One way to express the DAG is to use the
-[After](http://code.google.com/p/googlemock/wiki/V1_7_CheatSheet#The_After_Clause) clause of `EXPECT_CALL`.
-
-Another way is via the `InSequence()` clause (not the same as the
-`InSequence` class), which we borrowed from jMock 2. It's less
-flexible than `After()`, but more convenient when you have long chains
-of sequential calls, as it doesn't require you to come up with
-different names for the expectations in the chains.  Here's how it
-works:
-
-If we view `EXPECT_CALL()` statements as nodes in a graph, and add an
-edge from node A to node B wherever A must occur before B, we can get
-a DAG. We use the term "sequence" to mean a directed path in this
-DAG. Now, if we decompose the DAG into sequences, we just need to know
-which sequences each `EXPECT_CALL()` belongs to in order to be able to
-reconstruct the orginal DAG.
-
-So, to specify the partial order on the expectations we need to do two
-things: first to define some `Sequence` objects, and then for each
-`EXPECT_CALL()` say which `Sequence` objects it is part
-of. Expectations in the same sequence must occur in the order they are
-written. For example,
-
-```
-  using ::testing::Sequence;
-
-  Sequence s1, s2;
-
-  EXPECT_CALL(foo, A())
-      .InSequence(s1, s2);
-  EXPECT_CALL(bar, B())
-      .InSequence(s1);
-  EXPECT_CALL(bar, C())
-      .InSequence(s2);
-  EXPECT_CALL(foo, D())
-      .InSequence(s2);
-```
-
-specifies the following DAG (where `s1` is `A -> B`, and `s2` is `A ->
-C -> D`):
-
-```
-       +---> B
-       |
-  A ---|
-       |
-       +---> C ---> D
-```
-
-This means that A must occur before B and C, and C must occur before
-D. There's no restriction about the order other than these.
-
-## Controlling When an Expectation Retires ##
-
-When a mock method is called, Google Mock only consider expectations
-that are still active. An expectation is active when created, and
-becomes inactive (aka _retires_) when a call that has to occur later
-has occurred. For example, in
-
-```
-  using ::testing::_;
-  using ::testing::Sequence;
-
-  Sequence s1, s2;
-
-  EXPECT_CALL(log, Log(WARNING, _, "File too large."))     // #1
-      .Times(AnyNumber())
-      .InSequence(s1, s2);
-  EXPECT_CALL(log, Log(WARNING, _, "Data set is empty."))  // #2
-      .InSequence(s1);
-  EXPECT_CALL(log, Log(WARNING, _, "User not found."))     // #3
-      .InSequence(s2);
-```
-
-as soon as either #2 or #3 is matched, #1 will retire. If a warning
-`"File too large."` is logged after this, it will be an error.
-
-Note that an expectation doesn't retire automatically when it's
-saturated. For example,
-
-```
-using ::testing::_;
-...
-  EXPECT_CALL(log, Log(WARNING, _, _));                  // #1
-  EXPECT_CALL(log, Log(WARNING, _, "File too large."));  // #2
-```
-
-says that there will be exactly one warning with the message `"File
-too large."`. If the second warning contains this message too, #2 will
-match again and result in an upper-bound-violated error.
-
-If this is not what you want, you can ask an expectation to retire as
-soon as it becomes saturated:
-
-```
-using ::testing::_;
-...
-  EXPECT_CALL(log, Log(WARNING, _, _));                 // #1
-  EXPECT_CALL(log, Log(WARNING, _, "File too large."))  // #2
-      .RetiresOnSaturation();
-```
-
-Here #2 can be used only once, so if you have two warnings with the
-message `"File too large."`, the first will match #2 and the second
-will match #1 - there will be no error.
-
-# Using Actions #
-
-## Returning References from Mock Methods ##
-
-If a mock function's return type is a reference, you need to use
-`ReturnRef()` instead of `Return()` to return a result:
-
-```
-using ::testing::ReturnRef;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD0(GetBar, Bar&());
-};
-...
-
-  MockFoo foo;
-  Bar bar;
-  EXPECT_CALL(foo, GetBar())
-      .WillOnce(ReturnRef(bar));
-```
-
-## Returning Live Values from Mock Methods ##
-
-The `Return(x)` action saves a copy of `x` when the action is
-_created_, and always returns the same value whenever it's
-executed. Sometimes you may want to instead return the _live_ value of
-`x` (i.e. its value at the time when the action is _executed_.).
-
-If the mock function's return type is a reference, you can do it using
-`ReturnRef(x)`, as shown in the previous recipe ("Returning References
-from Mock Methods"). However, Google Mock doesn't let you use
-`ReturnRef()` in a mock function whose return type is not a reference,
-as doing that usually indicates a user error. So, what shall you do?
-
-You may be tempted to try `ByRef()`:
-
-```
-using testing::ByRef;
-using testing::Return;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD0(GetValue, int());
-};
-...
-  int x = 0;
-  MockFoo foo;
-  EXPECT_CALL(foo, GetValue())
-      .WillRepeatedly(Return(ByRef(x)));
-  x = 42;
-  EXPECT_EQ(42, foo.GetValue());
-```
-
-Unfortunately, it doesn't work here. The above code will fail with error:
-
-```
-Value of: foo.GetValue()
-  Actual: 0
-Expected: 42
-```
-
-The reason is that `Return(value)` converts `value` to the actual
-return type of the mock function at the time when the action is
-_created_, not when it is _executed_. (This behavior was chosen for
-the action to be safe when `value` is a proxy object that references
-some temporary objects.) As a result, `ByRef(x)` is converted to an
-`int` value (instead of a `const int&`) when the expectation is set,
-and `Return(ByRef(x))` will always return 0.
-
-`ReturnPointee(pointer)` was provided to solve this problem
-specifically. It returns the value pointed to by `pointer` at the time
-the action is _executed_:
-
-```
-using testing::ReturnPointee;
-...
-  int x = 0;
-  MockFoo foo;
-  EXPECT_CALL(foo, GetValue())
-      .WillRepeatedly(ReturnPointee(&x));  // Note the & here.
-  x = 42;
-  EXPECT_EQ(42, foo.GetValue());  // This will succeed now.
-```
-
-## Combining Actions ##
-
-Want to do more than one thing when a function is called? That's
-fine. `DoAll()` allow you to do sequence of actions every time. Only
-the return value of the last action in the sequence will be used.
-
-```
-using ::testing::DoAll;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(Bar, bool(int n));
-};
-...
-
-  EXPECT_CALL(foo, Bar(_))
-      .WillOnce(DoAll(action_1,
-                      action_2,
-                      ...
-                      action_n));
-```
-
-## Mocking Side Effects ##
-
-Sometimes a method exhibits its effect not via returning a value but
-via side effects. For example, it may change some global state or
-modify an output argument. To mock side effects, in general you can
-define your own action by implementing `::testing::ActionInterface`.
-
-If all you need to do is to change an output argument, the built-in
-`SetArgPointee()` action is convenient:
-
-```
-using ::testing::SetArgPointee;
-
-class MockMutator : public Mutator {
- public:
-  MOCK_METHOD2(Mutate, void(bool mutate, int* value));
-  ...
-};
-...
-
-  MockMutator mutator;
-  EXPECT_CALL(mutator, Mutate(true, _))
-      .WillOnce(SetArgPointee<1>(5));
-```
-
-In this example, when `mutator.Mutate()` is called, we will assign 5
-to the `int` variable pointed to by argument #1
-(0-based).
-
-`SetArgPointee()` conveniently makes an internal copy of the
-value you pass to it, removing the need to keep the value in scope and
-alive. The implication however is that the value must have a copy
-constructor and assignment operator.
-
-If the mock method also needs to return a value as well, you can chain
-`SetArgPointee()` with `Return()` using `DoAll()`:
-
-```
-using ::testing::_;
-using ::testing::Return;
-using ::testing::SetArgPointee;
-
-class MockMutator : public Mutator {
- public:
-  ...
-  MOCK_METHOD1(MutateInt, bool(int* value));
-};
-...
-
-  MockMutator mutator;
-  EXPECT_CALL(mutator, MutateInt(_))
-      .WillOnce(DoAll(SetArgPointee<0>(5),
-                      Return(true)));
-```
-
-If the output argument is an array, use the
-`SetArrayArgument<N>(first, last)` action instead. It copies the
-elements in source range `[first, last)` to the array pointed to by
-the `N`-th (0-based) argument:
-
-```
-using ::testing::NotNull;
-using ::testing::SetArrayArgument;
-
-class MockArrayMutator : public ArrayMutator {
- public:
-  MOCK_METHOD2(Mutate, void(int* values, int num_values));
-  ...
-};
-...
-
-  MockArrayMutator mutator;
-  int values[5] = { 1, 2, 3, 4, 5 };
-  EXPECT_CALL(mutator, Mutate(NotNull(), 5))
-      .WillOnce(SetArrayArgument<0>(values, values + 5));
-```
-
-This also works when the argument is an output iterator:
-
-```
-using ::testing::_;
-using ::testing::SeArrayArgument;
-
-class MockRolodex : public Rolodex {
- public:
-  MOCK_METHOD1(GetNames, void(std::back_insert_iterator<vector<string> >));
-  ...
-};
-...
-
-  MockRolodex rolodex;
-  vector<string> names;
-  names.push_back("George");
-  names.push_back("John");
-  names.push_back("Thomas");
-  EXPECT_CALL(rolodex, GetNames(_))
-      .WillOnce(SetArrayArgument<0>(names.begin(), names.end()));
-```
-
-## Changing a Mock Object's Behavior Based on the State ##
-
-If you expect a call to change the behavior of a mock object, you can use `::testing::InSequence` to specify different behaviors before and after the call:
-
-```
-using ::testing::InSequence;
-using ::testing::Return;
-
-...
-  {
-    InSequence seq;
-    EXPECT_CALL(my_mock, IsDirty())
-        .WillRepeatedly(Return(true));
-    EXPECT_CALL(my_mock, Flush());
-    EXPECT_CALL(my_mock, IsDirty())
-        .WillRepeatedly(Return(false));
-  }
-  my_mock.FlushIfDirty();
-```
-
-This makes `my_mock.IsDirty()` return `true` before `my_mock.Flush()` is called and return `false` afterwards.
-
-If the behavior change is more complex, you can store the effects in a variable and make a mock method get its return value from that variable:
-
-```
-using ::testing::_;
-using ::testing::SaveArg;
-using ::testing::Return;
-
-ACTION_P(ReturnPointee, p) { return *p; }
-...
-  int previous_value = 0;
-  EXPECT_CALL(my_mock, GetPrevValue())
-      .WillRepeatedly(ReturnPointee(&previous_value));
-  EXPECT_CALL(my_mock, UpdateValue(_))
-      .WillRepeatedly(SaveArg<0>(&previous_value));
-  my_mock.DoSomethingToUpdateValue();
-```
-
-Here `my_mock.GetPrevValue()` will always return the argument of the last `UpdateValue()` call.
-
-## Setting the Default Value for a Return Type ##
-
-If a mock method's return type is a built-in C++ type or pointer, by
-default it will return 0 when invoked. You only need to specify an
-action if this default value doesn't work for you.
-
-Sometimes, you may want to change this default value, or you may want
-to specify a default value for types Google Mock doesn't know
-about. You can do this using the `::testing::DefaultValue` class
-template:
-
-```
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD0(CalculateBar, Bar());
-};
-...
-
-  Bar default_bar;
-  // Sets the default return value for type Bar.
-  DefaultValue<Bar>::Set(default_bar);
-
-  MockFoo foo;
-
-  // We don't need to specify an action here, as the default
-  // return value works for us.
-  EXPECT_CALL(foo, CalculateBar());
-
-  foo.CalculateBar();  // This should return default_bar.
-
-  // Unsets the default return value.
-  DefaultValue<Bar>::Clear();
-```
-
-Please note that changing the default value for a type can make you
-tests hard to understand. We recommend you to use this feature
-judiciously. For example, you may want to make sure the `Set()` and
-`Clear()` calls are right next to the code that uses your mock.
-
-## Setting the Default Actions for a Mock Method ##
-
-You've learned how to change the default value of a given
-type. However, this may be too coarse for your purpose: perhaps you
-have two mock methods with the same return type and you want them to
-have different behaviors. The `ON_CALL()` macro allows you to
-customize your mock's behavior at the method level:
-
-```
-using ::testing::_;
-using ::testing::AnyNumber;
-using ::testing::Gt;
-using ::testing::Return;
-...
-  ON_CALL(foo, Sign(_))
-      .WillByDefault(Return(-1));
-  ON_CALL(foo, Sign(0))
-      .WillByDefault(Return(0));
-  ON_CALL(foo, Sign(Gt(0)))
-      .WillByDefault(Return(1));
-
-  EXPECT_CALL(foo, Sign(_))
-      .Times(AnyNumber());
-
-  foo.Sign(5);   // This should return 1.
-  foo.Sign(-9);  // This should return -1.
-  foo.Sign(0);   // This should return 0.
-```
-
-As you may have guessed, when there are more than one `ON_CALL()`
-statements, the news order take precedence over the older ones. In
-other words, the **last** one that matches the function arguments will
-be used. This matching order allows you to set up the common behavior
-in a mock object's constructor or the test fixture's set-up phase and
-specialize the mock's behavior later.
-
-## Using Functions/Methods/Functors as Actions ##
-
-If the built-in actions don't suit you, you can easily use an existing
-function, method, or functor as an action:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD2(Sum, int(int x, int y));
-  MOCK_METHOD1(ComplexJob, bool(int x));
-};
-
-int CalculateSum(int x, int y) { return x + y; }
-
-class Helper {
- public:
-  bool ComplexJob(int x);
-};
-...
-
-  MockFoo foo;
-  Helper helper;
-  EXPECT_CALL(foo, Sum(_, _))
-      .WillOnce(Invoke(CalculateSum));
-  EXPECT_CALL(foo, ComplexJob(_))
-      .WillOnce(Invoke(&helper, &Helper::ComplexJob));
-
-  foo.Sum(5, 6);       // Invokes CalculateSum(5, 6).
-  foo.ComplexJob(10);  // Invokes helper.ComplexJob(10);
-```
-
-The only requirement is that the type of the function, etc must be
-_compatible_ with the signature of the mock function, meaning that the
-latter's arguments can be implicitly converted to the corresponding
-arguments of the former, and the former's return type can be
-implicitly converted to that of the latter. So, you can invoke
-something whose type is _not_ exactly the same as the mock function,
-as long as it's safe to do so - nice, huh?
-
-## Invoking a Function/Method/Functor Without Arguments ##
-
-`Invoke()` is very useful for doing actions that are more complex. It
-passes the mock function's arguments to the function or functor being
-invoked such that the callee has the full context of the call to work
-with. If the invoked function is not interested in some or all of the
-arguments, it can simply ignore them.
-
-Yet, a common pattern is that a test author wants to invoke a function
-without the arguments of the mock function. `Invoke()` allows her to
-do that using a wrapper function that throws away the arguments before
-invoking an underlining nullary function. Needless to say, this can be
-tedious and obscures the intent of the test.
-
-`InvokeWithoutArgs()` solves this problem. It's like `Invoke()` except
-that it doesn't pass the mock function's arguments to the
-callee. Here's an example:
-
-```
-using ::testing::_;
-using ::testing::InvokeWithoutArgs;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(ComplexJob, bool(int n));
-};
-
-bool Job1() { ... }
-...
-
-  MockFoo foo;
-  EXPECT_CALL(foo, ComplexJob(_))
-      .WillOnce(InvokeWithoutArgs(Job1));
-
-  foo.ComplexJob(10);  // Invokes Job1().
-```
-
-## Invoking an Argument of the Mock Function ##
-
-Sometimes a mock function will receive a function pointer or a functor
-(in other words, a "callable") as an argument, e.g.
-
-```
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD2(DoThis, bool(int n, bool (*fp)(int)));
-};
-```
-
-and you may want to invoke this callable argument:
-
-```
-using ::testing::_;
-...
-  MockFoo foo;
-  EXPECT_CALL(foo, DoThis(_, _))
-      .WillOnce(...);
-  // Will execute (*fp)(5), where fp is the
-  // second argument DoThis() receives.
-```
-
-Arghh, you need to refer to a mock function argument but C++ has no
-lambda (yet), so you have to define your own action. :-( Or do you
-really?
-
-Well, Google Mock has an action to solve _exactly_ this problem:
-
-```
-  InvokeArgument<N>(arg_1, arg_2, ..., arg_m)
-```
-
-will invoke the `N`-th (0-based) argument the mock function receives,
-with `arg_1`, `arg_2`, ..., and `arg_m`. No matter if the argument is
-a function pointer or a functor, Google Mock handles them both.
-
-With that, you could write:
-
-```
-using ::testing::_;
-using ::testing::InvokeArgument;
-...
-  EXPECT_CALL(foo, DoThis(_, _))
-      .WillOnce(InvokeArgument<1>(5));
-  // Will execute (*fp)(5), where fp is the
-  // second argument DoThis() receives.
-```
-
-What if the callable takes an argument by reference? No problem - just
-wrap it inside `ByRef()`:
-
-```
-...
-  MOCK_METHOD1(Bar, bool(bool (*fp)(int, const Helper&)));
-...
-using ::testing::_;
-using ::testing::ByRef;
-using ::testing::InvokeArgument;
-...
-
-  MockFoo foo;
-  Helper helper;
-  ...
-  EXPECT_CALL(foo, Bar(_))
-      .WillOnce(InvokeArgument<0>(5, ByRef(helper)));
-  // ByRef(helper) guarantees that a reference to helper, not a copy of it,
-  // will be passed to the callable.
-```
-
-What if the callable takes an argument by reference and we do **not**
-wrap the argument in `ByRef()`? Then `InvokeArgument()` will _make a
-copy_ of the argument, and pass a _reference to the copy_, instead of
-a reference to the original value, to the callable. This is especially
-handy when the argument is a temporary value:
-
-```
-...
-  MOCK_METHOD1(DoThat, bool(bool (*f)(const double& x, const string& s)));
-...
-using ::testing::_;
-using ::testing::InvokeArgument;
-...
-
-  MockFoo foo;
-  ...
-  EXPECT_CALL(foo, DoThat(_))
-      .WillOnce(InvokeArgument<0>(5.0, string("Hi")));
-  // Will execute (*f)(5.0, string("Hi")), where f is the function pointer
-  // DoThat() receives.  Note that the values 5.0 and string("Hi") are
-  // temporary and dead once the EXPECT_CALL() statement finishes.  Yet
-  // it's fine to perform this action later, since a copy of the values
-  // are kept inside the InvokeArgument action.
-```
-
-## Ignoring an Action's Result ##
-
-Sometimes you have an action that returns _something_, but you need an
-action that returns `void` (perhaps you want to use it in a mock
-function that returns `void`, or perhaps it needs to be used in
-`DoAll()` and it's not the last in the list). `IgnoreResult()` lets
-you do that. For example:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::Return;
-
-int Process(const MyData& data);
-string DoSomething();
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD1(Abc, void(const MyData& data));
-  MOCK_METHOD0(Xyz, bool());
-};
-...
-
-  MockFoo foo;
-  EXPECT_CALL(foo, Abc(_))
-  // .WillOnce(Invoke(Process));
-  // The above line won't compile as Process() returns int but Abc() needs
-  // to return void.
-      .WillOnce(IgnoreResult(Invoke(Process)));
-
-  EXPECT_CALL(foo, Xyz())
-      .WillOnce(DoAll(IgnoreResult(Invoke(DoSomething)),
-      // Ignores the string DoSomething() returns.
-                      Return(true)));
-```
-
-Note that you **cannot** use `IgnoreResult()` on an action that already
-returns `void`. Doing so will lead to ugly compiler errors.
-
-## Selecting an Action's Arguments ##
-
-Say you have a mock function `Foo()` that takes seven arguments, and
-you have a custom action that you want to invoke when `Foo()` is
-called. Trouble is, the custom action only wants three arguments:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-...
-  MOCK_METHOD7(Foo, bool(bool visible, const string& name, int x, int y,
-                         const map<pair<int, int>, double>& weight,
-                         double min_weight, double max_wight));
-...
-
-bool IsVisibleInQuadrant1(bool visible, int x, int y) {
-  return visible && x >= 0 && y >= 0;
-}
-...
-
-  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
-      .WillOnce(Invoke(IsVisibleInQuadrant1));  // Uh, won't compile. :-(
-```
-
-To please the compiler God, you can to define an "adaptor" that has
-the same signature as `Foo()` and calls the custom action with the
-right arguments:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-bool MyIsVisibleInQuadrant1(bool visible, const string& name, int x, int y,
-                            const map<pair<int, int>, double>& weight,
-                            double min_weight, double max_wight) {
-  return IsVisibleInQuadrant1(visible, x, y);
-}
-...
-
-  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
-      .WillOnce(Invoke(MyIsVisibleInQuadrant1));  // Now it works.
-```
-
-But isn't this awkward?
-
-Google Mock provides a generic _action adaptor_, so you can spend your
-time minding more important business than writing your own
-adaptors. Here's the syntax:
-
-```
-  WithArgs<N1, N2, ..., Nk>(action)
-```
-
-creates an action that passes the arguments of the mock function at
-the given indices (0-based) to the inner `action` and performs
-it. Using `WithArgs`, our original example can be written as:
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::WithArgs;
-...
-  EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
-      .WillOnce(WithArgs<0, 2, 3>(Invoke(IsVisibleInQuadrant1)));
-      // No need to define your own adaptor.
-```
-
-For better readability, Google Mock also gives you:
-
-  * `WithoutArgs(action)` when the inner `action` takes _no_ argument, and
-  * `WithArg<N>(action)` (no `s` after `Arg`) when the inner `action` takes _one_ argument.
-
-As you may have realized, `InvokeWithoutArgs(...)` is just syntactic
-sugar for `WithoutArgs(Inovke(...))`.
-
-Here are more tips:
-
-  * The inner action used in `WithArgs` and friends does not have to be `Invoke()` -- it can be anything.
-  * You can repeat an argument in the argument list if necessary, e.g. `WithArgs<2, 3, 3, 5>(...)`.
-  * You can change the order of the arguments, e.g. `WithArgs<3, 2, 1>(...)`.
-  * The types of the selected arguments do _not_ have to match the signature of the inner action exactly. It works as long as they can be implicitly converted to the corresponding arguments of the inner action. For example, if the 4-th argument of the mock function is an `int` and `my_action` takes a `double`, `WithArg<4>(my_action)` will work.
-
-## Ignoring Arguments in Action Functions ##
-
-The selecting-an-action's-arguments recipe showed us one way to make a
-mock function and an action with incompatible argument lists fit
-together. The downside is that wrapping the action in
-`WithArgs<...>()` can get tedious for people writing the tests.
-
-If you are defining a function, method, or functor to be used with
-`Invoke*()`, and you are not interested in some of its arguments, an
-alternative to `WithArgs` is to declare the uninteresting arguments as
-`Unused`. This makes the definition less cluttered and less fragile in
-case the types of the uninteresting arguments change. It could also
-increase the chance the action function can be reused. For example,
-given
-
-```
-  MOCK_METHOD3(Foo, double(const string& label, double x, double y));
-  MOCK_METHOD3(Bar, double(int index, double x, double y));
-```
-
-instead of
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-
-double DistanceToOriginWithLabel(const string& label, double x, double y) {
-  return sqrt(x*x + y*y);
-}
-
-double DistanceToOriginWithIndex(int index, double x, double y) {
-  return sqrt(x*x + y*y);
-}
-...
-
-  EXEPCT_CALL(mock, Foo("abc", _, _))
-      .WillOnce(Invoke(DistanceToOriginWithLabel));
-  EXEPCT_CALL(mock, Bar(5, _, _))
-      .WillOnce(Invoke(DistanceToOriginWithIndex));
-```
-
-you could write
-
-```
-using ::testing::_;
-using ::testing::Invoke;
-using ::testing::Unused;
-
-double DistanceToOrigin(Unused, double x, double y) {
-  return sqrt(x*x + y*y);
-}
-...
-
-  EXEPCT_CALL(mock, Foo("abc", _, _))
-      .WillOnce(Invoke(DistanceToOrigin));
-  EXEPCT_CALL(mock, Bar(5, _, _))
-      .WillOnce(Invoke(DistanceToOrigin));
-```
-
-## Sharing Actions ##
-
-Just like matchers, a Google Mock action object consists of a pointer
-to a ref-counted implementation object. Therefore copying actions is
-also allowed and very efficient. When the last action that references
-the implementation object dies, the implementation object will be
-deleted.
-
-If you have some complex action that you want to use again and again,
-you may not have to build it from scratch everytime. If the action
-doesn't have an internal state (i.e. if it always does the same thing
-no matter how many times it has been called), you can assign it to an
-action variable and use that variable repeatedly. For example:
-
-```
-  Action<bool(int*)> set_flag = DoAll(SetArgPointee<0>(5),
-                                      Return(true));
-  ... use set_flag in .WillOnce() and .WillRepeatedly() ...
-```
-
-However, if the action has its own state, you may be surprised if you
-share the action object. Suppose you have an action factory
-`IncrementCounter(init)` which creates an action that increments and
-returns a counter whose initial value is `init`, using two actions
-created from the same expression and using a shared action will
-exihibit different behaviors. Example:
-
-```
-  EXPECT_CALL(foo, DoThis())
-      .WillRepeatedly(IncrementCounter(0));
-  EXPECT_CALL(foo, DoThat())
-      .WillRepeatedly(IncrementCounter(0));
-  foo.DoThis();  // Returns 1.
-  foo.DoThis();  // Returns 2.
-  foo.DoThat();  // Returns 1 - Blah() uses a different
-                 // counter than Bar()'s.
-```
-
-versus
-
-```
-  Action<int()> increment = IncrementCounter(0);
-
-  EXPECT_CALL(foo, DoThis())
-      .WillRepeatedly(increment);
-  EXPECT_CALL(foo, DoThat())
-      .WillRepeatedly(increment);
-  foo.DoThis();  // Returns 1.
-  foo.DoThis();  // Returns 2.
-  foo.DoThat();  // Returns 3 - the counter is shared.
-```
-
-# Misc Recipes on Using Google Mock #
-
-## Making the Compilation Faster ##
-
-Believe it or not, the _vast majority_ of the time spent on compiling
-a mock class is in generating its constructor and destructor, as they
-perform non-trivial tasks (e.g. verification of the
-expectations). What's more, mock methods with different signatures
-have different types and thus their constructors/destructors need to
-be generated by the compiler separately. As a result, if you mock many
-different types of methods, compiling your mock class can get really
-slow.
-
-If you are experiencing slow compilation, you can move the definition
-of your mock class' constructor and destructor out of the class body
-and into a `.cpp` file. This way, even if you `#include` your mock
-class in N files, the compiler only needs to generate its constructor
-and destructor once, resulting in a much faster compilation.
-
-Let's illustrate the idea using an example. Here's the definition of a
-mock class before applying this recipe:
-
-```
-// File mock_foo.h.
-...
-class MockFoo : public Foo {
- public:
-  // Since we don't declare the constructor or the destructor,
-  // the compiler will generate them in every translation unit
-  // where this mock class is used.
-
-  MOCK_METHOD0(DoThis, int());
-  MOCK_METHOD1(DoThat, bool(const char* str));
-  ... more mock methods ...
-};
-```
-
-After the change, it would look like:
-
-```
-// File mock_foo.h.
-...
-class MockFoo : public Foo {
- public:
-  // The constructor and destructor are declared, but not defined, here.
-  MockFoo();
-  virtual ~MockFoo();
-
-  MOCK_METHOD0(DoThis, int());
-  MOCK_METHOD1(DoThat, bool(const char* str));
-  ... more mock methods ...
-};
-```
-and
-```
-// File mock_foo.cpp.
-#include "path/to/mock_foo.h"
-
-// The definitions may appear trivial, but the functions actually do a
-// lot of things through the constructors/destructors of the member
-// variables used to implement the mock methods.
-MockFoo::MockFoo() {}
-MockFoo::~MockFoo() {}
-```
-
-## Forcing a Verification ##
-
-When it's being destoyed, your friendly mock object will automatically
-verify that all expectations on it have been satisfied, and will
-generate [Google Test](http://code.google.com/p/googletest/) failures
-if not. This is convenient as it leaves you with one less thing to
-worry about. That is, unless you are not sure if your mock object will
-be destoyed.
-
-How could it be that your mock object won't eventually be destroyed?
-Well, it might be created on the heap and owned by the code you are
-testing. Suppose there's a bug in that code and it doesn't delete the
-mock object properly - you could end up with a passing test when
-there's actually a bug.
-
-Using a heap checker is a good idea and can alleviate the concern, but
-its implementation may not be 100% reliable. So, sometimes you do want
-to _force_ Google Mock to verify a mock object before it is
-(hopefully) destructed. You can do this with
-`Mock::VerifyAndClearExpectations(&mock_object)`:
-
-```
-TEST(MyServerTest, ProcessesRequest) {
-  using ::testing::Mock;
-
-  MockFoo* const foo = new MockFoo;
-  EXPECT_CALL(*foo, ...)...;
-  // ... other expectations ...
-
-  // server now owns foo.
-  MyServer server(foo);
-  server.ProcessRequest(...);
-
-  // In case that server's destructor will forget to delete foo,
-  // this will verify the expectations anyway.
-  Mock::VerifyAndClearExpectations(foo);
-}  // server is destroyed when it goes out of scope here.
-```
-
-**Tip:** The `Mock::VerifyAndClearExpectations()` function returns a
-`bool` to indicate whether the verification was successful (`true` for
-yes), so you can wrap that function call inside a `ASSERT_TRUE()` if
-there is no point going further when the verification has failed.
-
-## Using Check Points ##
-
-Sometimes you may want to "reset" a mock object at various check
-points in your test: at each check point, you verify that all existing
-expectations on the mock object have been satisfied, and then you set
-some new expectations on it as if it's newly created. This allows you
-to work with a mock object in "phases" whose sizes are each
-manageable.
-
-One such scenario is that in your test's `SetUp()` function, you may
-want to put the object you are testing into a certain state, with the
-help from a mock object. Once in the desired state, you want to clear
-all expectations on the mock, such that in the `TEST_F` body you can
-set fresh expectations on it.
-
-As you may have figured out, the `Mock::VerifyAndClearExpectations()`
-function we saw in the previous recipe can help you here. Or, if you
-are using `ON_CALL()` to set default actions on the mock object and
-want to clear the default actions as well, use
-`Mock::VerifyAndClear(&mock_object)` instead. This function does what
-`Mock::VerifyAndClearExpectations(&mock_object)` does and returns the
-same `bool`, **plus** it clears the `ON_CALL()` statements on
-`mock_object` too.
-
-Another trick you can use to achieve the same effect is to put the
-expectations in sequences and insert calls to a dummy "check-point"
-function at specific places. Then you can verify that the mock
-function calls do happen at the right time. 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:
-
-```
-using ::testing::MockFunction;
-
-TEST(FooTest, InvokesBarCorrectly) {
-  MyMock mock;
-  // Class MockFunction<F> has exactly one mock method.  It is named
-  // Call() and has type F.
-  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()`.
-
-## Mocking Destructors ##
-
-Sometimes you want to make sure a mock object is destructed at the
-right time, e.g. after `bar->A()` is called but before `bar->B()` is
-called. We already know that you can specify constraints on the order
-of mock function calls, so all we need to do is to mock the destructor
-of the mock function.
-
-This sounds simple, except for one problem: a destructor is a special
-function with special syntax and special semantics, and the
-`MOCK_METHOD0` macro doesn't work for it:
-
-```
-  MOCK_METHOD0(~MockFoo, void());  // Won't compile!
-```
-
-The good news is that you can use a simple pattern to achieve the same
-effect. First, add a mock function `Die()` to your mock class and call
-it in the destructor, like this:
-
-```
-class MockFoo : public Foo {
-  ...
-  // Add the following two lines to the mock class.
-  MOCK_METHOD0(Die, void());
-  virtual ~MockFoo() { Die(); }
-};
-```
-
-(If the name `Die()` clashes with an existing symbol, choose another
-name.) Now, we have translated the problem of testing when a `MockFoo`
-object dies to testing when its `Die()` method is called:
-
-```
-  MockFoo* foo = new MockFoo;
-  MockBar* bar = new MockBar;
-  ...
-  {
-    InSequence s;
-
-    // Expects *foo to die after bar->A() and before bar->B().
-    EXPECT_CALL(*bar, A());
-    EXPECT_CALL(*foo, Die());
-    EXPECT_CALL(*bar, B());
-  }
-```
-
-And that's that.
-
-## Using Google Mock and Threads ##
-
-**IMPORTANT NOTE:** What we describe in this recipe is **ONLY** true on
-platforms where Google Mock is thread-safe. Currently these are only
-platforms that support the pthreads library (this includes Linux and Mac).
-To make it thread-safe on other platforms we only need to implement
-some synchronization operations in `"gtest/internal/gtest-port.h"`.
-
-In a **unit** test, it's best if you could isolate and test a piece of
-code in a single-threaded context. That avoids race conditions and
-dead locks, and makes debugging your test much easier.
-
-Yet many programs are multi-threaded, and sometimes to test something
-we need to pound on it from more than one thread. Google Mock works
-for this purpose too.
-
-Remember the steps for using a mock:
-
-  1. Create a mock object `foo`.
-  1. Set its default actions and expectations using `ON_CALL()` and `EXPECT_CALL()`.
-  1. The code under test calls methods of `foo`.
-  1. Optionally, verify and reset the mock.
-  1. Destroy the mock yourself, or let the code under test destroy it. The destructor will automatically verify it.
-
-If you follow the following simple rules, your mocks and threads can
-live happily togeter:
-
-  * Execute your _test code_ (as opposed to the code being tested) in _one_ thread. This makes your test easy to follow.
-  * Obviously, you can do step #1 without locking.
-  * When doing step #2 and #5, make sure no other thread is accessing `foo`. Obvious too, huh?
-  * #3 and #4 can be done either in one thread or in multiple threads - anyway you want. Google Mock takes care of the locking, so you don't have to do any - unless required by your test logic.
-
-If you violate the rules (for example, if you set expectations on a
-mock while another thread is calling its methods), you get undefined
-behavior. That's not fun, so don't do it.
-
-Google Mock guarantees that the action for a mock function is done in
-the same thread that called the mock function. For example, in
-
-```
-  EXPECT_CALL(mock, Foo(1))
-      .WillOnce(action1);
-  EXPECT_CALL(mock, Foo(2))
-      .WillOnce(action2);
-```
-
-if `Foo(1)` is called in thread 1 and `Foo(2)` is called in thread 2,
-Google Mock will execute `action1` in thread 1 and `action2` in thread
-2.
-
-Google Mock does _not_ impose a sequence on actions performed in
-different threads (doing so may create deadlocks as the actions may
-need to cooperate). This means that the execution of `action1` and
-`action2` in the above example _may_ interleave. If this is a problem,
-you should add proper synchronization logic to `action1` and `action2`
-to make the test thread-safe.
-
-
-Also, remember that `DefaultValue<T>` is a global resource that
-potentially affects _all_ living mock objects in your
-program. Naturally, you won't want to mess with it from multiple
-threads or when there still are mocks in action.
-
-## Controlling How Much Information Google Mock Prints ##
-
-When Google Mock sees something that has the potential of being an
-error (e.g. a mock function with no expectation is called, a.k.a. an
-uninteresting call, which is allowed but perhaps you forgot to
-explicitly ban the call), it prints some warning messages, including
-the arguments of the function and the return value. Hopefully this
-will remind you to take a look and see if there is indeed a problem.
-
-Sometimes you are confident that your tests are correct and may not
-appreciate such friendly messages. Some other times, you are debugging
-your tests or learning about the behavior of the code you are testing,
-and wish you could observe every mock call that happens (including
-argument values and the return value). Clearly, one size doesn't fit
-all.
-
-You can control how much Google Mock tells you using the
-`--gmock_verbose=LEVEL` command-line flag, where `LEVEL` is a string
-with three possible values:
-
-  * `info`: Google Mock will print all informational messages, warnings, and errors (most verbose). At this setting, Google Mock will also log any calls to the `ON_CALL/EXPECT_CALL` macros.
-  * `warning`: Google Mock will print both warnings and errors (less verbose). This is the default.
-  * `error`: Google Mock will print errors only (least verbose).
-
-Alternatively, you can adjust the value of that flag from within your
-tests like so:
-
-```
-  ::testing::FLAGS_gmock_verbose = "error";
-```
-
-Now, judiciously use the right flag to enable Google Mock serve you better!
-
-## Gaining Super Vision into Mock Calls ##
-
-You have a test using Google Mock. It fails: Google Mock tells you
-that some expectations aren't satisfied. However, you aren't sure why:
-Is there a typo somewhere in the matchers? Did you mess up the order
-of the `EXPECT_CALL`s? Or is the code under test doing something
-wrong?  How can you find out the cause?
-
-Won't it be nice if you have X-ray vision and can actually see the
-trace of all `EXPECT_CALL`s and mock method calls as they are made?
-For each call, would you like to see its actual argument values and
-which `EXPECT_CALL` Google Mock thinks it matches?
-
-You can unlock this power by running your test with the
-`--gmock_verbose=info` flag. For example, given the test program:
-
-```
-using testing::_;
-using testing::HasSubstr;
-using testing::Return;
-
-class MockFoo {
- public:
-  MOCK_METHOD2(F, void(const string& x, const string& y));
-};
-
-TEST(Foo, Bar) {
-  MockFoo mock;
-  EXPECT_CALL(mock, F(_, _)).WillRepeatedly(Return());
-  EXPECT_CALL(mock, F("a", "b"));
-  EXPECT_CALL(mock, F("c", HasSubstr("d")));
-
-  mock.F("a", "good");
-  mock.F("a", "b");
-}
-```
-
-if you run it with `--gmock_verbose=info`, you will see this output:
-
-```
-[ RUN      ] Foo.Bar
-
-foo_test.cc:14: EXPECT_CALL(mock, F(_, _)) invoked
-foo_test.cc:15: EXPECT_CALL(mock, F("a", "b")) invoked
-foo_test.cc:16: EXPECT_CALL(mock, F("c", HasSubstr("d"))) invoked
-foo_test.cc:14: Mock function call matches EXPECT_CALL(mock, F(_, _))...
-    Function call: F(@0x7fff7c8dad40"a", @0x7fff7c8dad10"good")
-foo_test.cc:15: Mock function call matches EXPECT_CALL(mock, F("a", "b"))...
-    Function call: F(@0x7fff7c8dada0"a", @0x7fff7c8dad70"b")
-foo_test.cc:16: Failure
-Actual function call count doesn't match EXPECT_CALL(mock, F("c", HasSubstr("d")))...
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] Foo.Bar
-```
-
-Suppose the bug is that the `"c"` in the third `EXPECT_CALL` is a typo
-and should actually be `"a"`. With the above message, you should see
-that the actual `F("a", "good")` call is matched by the first
-`EXPECT_CALL`, not the third as you thought. From that it should be
-obvious that the third `EXPECT_CALL` is written wrong. Case solved.
-
-## Running Tests in Emacs ##
-
-If you build and run your tests in Emacs, the source file locations of
-Google Mock and [Google Test](http://code.google.com/p/googletest/)
-errors will be highlighted. Just press `<Enter>` on one of them and
-you'll be taken to the offending line. Or, you can just type `C-x ``
-to jump to the next error.
-
-To make it even easier, you can add the following lines to your
-`~/.emacs` file:
-
-```
-(global-set-key "\M-m"   'compile)  ; m is for make
-(global-set-key [M-down] 'next-error)
-(global-set-key [M-up]   '(lambda () (interactive) (next-error -1)))
-```
-
-Then you can type `M-m` to start a build, or `M-up`/`M-down` to move
-back and forth between errors.
-
-## Fusing Google Mock Source Files ##
-
-Google Mock's implementation consists of dozens of files (excluding
-its own tests).  Sometimes you may want them to be packaged up in
-fewer files instead, such that you can easily copy them to a new
-machine and start hacking there.  For this we provide an experimental
-Python script `fuse_gmock_files.py` in the `scripts/` directory
-(starting with release 1.2.0).  Assuming you have Python 2.4 or above
-installed on your machine, just go to that directory and run
-```
-python fuse_gmock_files.py OUTPUT_DIR
-```
-
-and you should see an `OUTPUT_DIR` directory being created with files
-`gtest/gtest.h`, `gmock/gmock.h`, and `gmock-gtest-all.cc` in it.
-These three files contain everything you need to use Google Mock (and
-Google Test).  Just copy them to anywhere you want and you are ready
-to write tests and use mocks.  You can use the
-[scrpts/test/Makefile](http://code.google.com/p/googlemock/source/browse/trunk/scripts/test/Makefile) file as an example on how to compile your tests
-against them.
-
-# Extending Google Mock #
-
-## Writing New Matchers Quickly ##
-
-The `MATCHER*` family of macros can be used to define custom matchers
-easily.  The syntax:
-
-```
-MATCHER(name, description_string_expression) { statements; }
-```
-
-will define 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 is a `string`-typed expression that documents
-what the matcher does, and is used to generate the failure message
-when the match fails.  It can (and should) reference the special
-`bool` variable `negation`, and should evaluate to the description of
-the matcher when `negation` is `false`, or that of the matcher's
-negation when `negation` is `true`.
-
-For convenience, we allow the description string to be empty (`""`),
-in which case Google Mock will use the sequence of words in the
-matcher name as the description.
-
-For example:
-```
-MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; }
-```
-allows you to write
-```
-  // Expects mock_foo.Bar(n) to be called where n is divisible by 7.
-  EXPECT_CALL(mock_foo, Bar(IsDivisibleBy7()));
-```
-or,
-```
-using ::testing::Not;
-...
-  EXPECT_THAT(some_expression, IsDivisibleBy7());
-  EXPECT_THAT(some_other_expression, Not(IsDivisibleBy7()));
-```
-If the above assertions fail, they will print something like:
-```
-  Value of: some_expression
-  Expected: is divisible by 7
-    Actual: 27
-...
-  Value of: some_other_expression
-  Expected: not (is divisible by 7)
-    Actual: 21
-```
-where the descriptions `"is divisible by 7"` and `"not (is divisible
-by 7)"` are automatically calculated from the matcher name
-`IsDivisibleBy7`.
-
-As you may have noticed, the auto-generated descriptions (especially
-those for the negation) may not be so great. You can always override
-them with a string expression of your own:
-```
-MATCHER(IsDivisibleBy7, std::string(negation ? "isn't" : "is") +
-                        " divisible by 7") {
-  return (arg % 7) == 0;
-}
-```
-
-Optionally, you can stream additional information to a hidden argument
-named `result_listener` to explain the match result. For example, a
-better definition of `IsDivisibleBy7` is:
-```
-MATCHER(IsDivisibleBy7, "") {
-  if ((arg % 7) == 0)
-    return true;
-
-  *result_listener << "the remainder is " << (arg % 7);
-  return false;
-}
-```
-
-With this definition, the above assertion will give a better message:
-```
-  Value of: some_expression
-  Expected: is divisible by 7
-    Actual: 27 (the remainder is 6)
-```
-
-You should let `MatchAndExplain()` print _any additional information_
-that can help a user understand the match result. Note that it should
-explain why the match succeeds in case of a success (unless it's
-obvious) - this is useful when the matcher is used inside
-`Not()`. There is no need to print the argument value itself, as
-Google Mock already prints it for you.
-
-**Notes:**
-
-  1. 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, `IsDivisibleBy7()` can be used to match any type where the value of `(arg % 7) == 0` can be implicitly converted to a `bool`.  In the `Bar(IsDivisibleBy7())` 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.
-  1. Google Mock doesn't guarantee when or how many times a matcher will be invoked. Therefore the matcher logic must be _purely functional_ (i.e. it cannot have any side effect, and the result must not depend on anything other than the value being matched and the matcher parameters). This requirement must be satisfied no matter how you define the matcher (e.g. using one of the methods described in the following recipes). In particular, a matcher can never call a mock function, as that will affect the state of the mock object and Google Mock.
-
-## Writing New Parameterized Matchers Quickly ##
-
-Sometimes you'll want to define a matcher that has parameters.  For that you
-can use the macro:
-```
-MATCHER_P(name, param_name, description_string) { statements; }
-```
-where the description string can be either `""` or a string expression
-that references `negation` and `param_name`.
-
-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`.
-
-Google Mock also provides `MATCHER_P2`, `MATCHER_P3`, ..., up to
-`MATCHER_P10` to support multi-parameter matchers:
-```
-MATCHER_Pk(name, param_1, ..., param_k, description_string) { statements; }
-```
-
-Please note that the custom description string is for a particular
-**instance** of the matcher, where the parameters have been bound to
-actual values.  Therefore usually you'll want the parameter values to
-be part of the description.  Google Mock lets you do that by
-referencing the matcher parameters in the description string
-expression.
-
-For example,
-```
-  using ::testing::PrintToString;
-  MATCHER_P2(InClosedRange, low, hi,
-             std::string(negation ? "isn't" : "is") + " in range [" +
-             PrintToString(low) + ", " + PrintToString(hi) + "]") {
-    return low <= arg && arg <= hi;
-  }
-  ...
-  EXPECT_THAT(3, InClosedRange(4, 6));
-```
-would generate a failure that contains the message:
-```
-  Expected: is in range [4, 6]
-```
-
-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));
-```
-would generate a failure that contains the text:
-```
-  Expected: in closed range (4, 6)
-```
-
-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.  Matchers that don't have a parameter
-or have only one parameter have special types: you can assign `Foo()`
-to a `FooMatcher`-typed variable, and assign `Foo(p)` to a
-`FooMatcherP<p_type>`-typed variable.
-
-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.
-
-You can overload matchers with different numbers of parameters:
-```
-MATCHER_P(Blah, a, description_string_1) { ... }
-MATCHER_P2(Blah, a, b, description_string_2) { ... }
-```
-
-While it's tempting to always use the `MATCHER*` macros when defining
-a new matcher, you should also consider implementing
-`MatcherInterface` or using `MakePolymorphicMatcher()` instead (see
-the recipes that follow), especially if you need to use the matcher a
-lot.  While these approaches require more work, they give you more
-control on the types of the value being matched and the matcher
-parameters, which in general leads to better compiler error messages
-that pay off in the long run.  They also allow overloading matchers
-based on parameter types (as opposed to just based on the number of
-parameters).
-
-## Writing New Monomorphic Matchers ##
-
-A matcher of argument type `T` implements
-`::testing::MatcherInterface<T>` and does two things: it tests whether a
-value of type `T` matches the matcher, and can describe what kind of
-values it matches. The latter ability is used for generating readable
-error messages when expectations are violated.
-
-The interface looks like this:
-
-```
-class MatchResultListener {
- public:
-  ...
-  // Streams x to the underlying ostream; does nothing if the ostream
-  // is NULL.
-  template <typename T>
-  MatchResultListener& operator<<(const T& x);
-
-  // Returns the underlying ostream.
-  ::std::ostream* stream();
-};
-
-template <typename T>
-class MatcherInterface {
- public:
-  virtual ~MatcherInterface();
-
-  // Returns true iff the matcher matches x; also explains the match
-  // result to 'listener'.
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
-
-  // Describes this matcher to an ostream.
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-
-  // Describes the negation of this matcher to an ostream.
-  virtual void DescribeNegationTo(::std::ostream* os) const;
-};
-```
-
-If you need a custom matcher but `Truly()` is not a good option (for
-example, you may not be happy with the way `Truly(predicate)`
-describes itself, or you may want your matcher to be polymorphic as
-`Eq(value)` is), you can define a matcher to do whatever you want in
-two steps: first implement the matcher interface, and then define a
-factory function to create a matcher instance. The second step is not
-strictly needed but it makes the syntax of using the matcher nicer.
-
-For example, you can define a matcher to test whether an `int` is
-divisible by 7 and then use it like this:
-```
-using ::testing::MakeMatcher;
-using ::testing::Matcher;
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-
-class DivisibleBy7Matcher : public MatcherInterface<int> {
- public:
-  virtual bool MatchAndExplain(int n, MatchResultListener* listener) const {
-    return (n % 7) == 0;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "is divisible by 7";
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is not divisible by 7";
-  }
-};
-
-inline Matcher<int> DivisibleBy7() {
-  return MakeMatcher(new DivisibleBy7Matcher);
-}
-...
-
-  EXPECT_CALL(foo, Bar(DivisibleBy7()));
-```
-
-You may improve the matcher message by streaming additional
-information to the `listener` argument in `MatchAndExplain()`:
-
-```
-class DivisibleBy7Matcher : public MatcherInterface<int> {
- public:
-  virtual bool MatchAndExplain(int n,
-                               MatchResultListener* listener) const {
-    const int remainder = n % 7;
-    if (remainder != 0) {
-      *listener << "the remainder is " << remainder;
-    }
-    return remainder == 0;
-  }
-  ...
-};
-```
-
-Then, `EXPECT_THAT(x, DivisibleBy7());` may general a message like this:
-```
-Value of: x
-Expected: is divisible by 7
-  Actual: 23 (the remainder is 2)
-```
-
-## Writing New Polymorphic Matchers ##
-
-You've learned how to write your own matchers in the previous
-recipe. Just one problem: a matcher created using `MakeMatcher()` only
-works for one particular type of arguments. If you want a
-_polymorphic_ matcher that works with arguments of several types (for
-instance, `Eq(x)` can be used to match a `value` as long as `value` ==
-`x` compiles -- `value` and `x` don't have to share the same type),
-you can learn the trick from `"gmock/gmock-matchers.h"` but it's a bit
-involved.
-
-Fortunately, most of the time you can define a polymorphic matcher
-easily with the help of `MakePolymorphicMatcher()`. Here's how you can
-define `NotNull()` as an example:
-
-```
-using ::testing::MakePolymorphicMatcher;
-using ::testing::MatchResultListener;
-using ::testing::NotNull;
-using ::testing::PolymorphicMatcher;
-
-class NotNullMatcher {
- public:
-  // To implement a polymorphic matcher, first define a COPYABLE class
-  // that has three members MatchAndExplain(), DescribeTo(), and
-  // DescribeNegationTo(), like the following.
-
-  // In this example, we want to use NotNull() with any pointer, so
-  // MatchAndExplain() accepts a pointer of any type as its first argument.
-  // In general, you can define MatchAndExplain() as an ordinary method or
-  // a method template, or even overload it.
-  template <typename T>
-  bool MatchAndExplain(T* p,
-                       MatchResultListener* /* listener */) const {
-    return p != NULL;
-  }
-
-  // Describes the property of a value matching this matcher.
-  void DescribeTo(::std::ostream* os) const { *os << "is not NULL"; }
-
-  // Describes the property of a value NOT matching this matcher.
-  void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
-};
-
-// To construct a polymorphic matcher, pass an instance of the class
-// to MakePolymorphicMatcher().  Note the return type.
-inline PolymorphicMatcher<NotNullMatcher> NotNull() {
-  return MakePolymorphicMatcher(NotNullMatcher());
-}
-...
-
-  EXPECT_CALL(foo, Bar(NotNull()));  // The argument must be a non-NULL pointer.
-```
-
-**Note:** Your polymorphic matcher class does **not** need to inherit from
-`MatcherInterface` or any other class, and its methods do **not** need
-to be virtual.
-
-Like in a monomorphic matcher, you may explain the match result by
-streaming additional information to the `listener` argument in
-`MatchAndExplain()`.
-
-## Writing New Cardinalities ##
-
-A cardinality is used in `Times()` to tell Google Mock how many times
-you expect a call to occur. It doesn't have to be exact. For example,
-you can say `AtLeast(5)` or `Between(2, 4)`.
-
-If the built-in set of cardinalities doesn't suit you, you are free to
-define your own by implementing the following interface (in namespace
-`testing`):
-
-```
-class CardinalityInterface {
- public:
-  virtual ~CardinalityInterface();
-
-  // Returns true iff call_count calls will satisfy this cardinality.
-  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
-
-  // Returns true iff call_count calls will saturate this cardinality.
-  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
-
-  // Describes self to an ostream.
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-};
-```
-
-For example, to specify that a call must occur even number of times,
-you can write
-
-```
-using ::testing::Cardinality;
-using ::testing::CardinalityInterface;
-using ::testing::MakeCardinality;
-
-class EvenNumberCardinality : public CardinalityInterface {
- public:
-  virtual bool IsSatisfiedByCallCount(int call_count) const {
-    return (call_count % 2) == 0;
-  }
-
-  virtual bool IsSaturatedByCallCount(int call_count) const {
-    return false;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "called even number of times";
-  }
-};
-
-Cardinality EvenNumber() {
-  return MakeCardinality(new EvenNumberCardinality);
-}
-...
-
-  EXPECT_CALL(foo, Bar(3))
-      .Times(EvenNumber());
-```
-
-## Writing New Actions Quickly ##
-
-If the built-in actions don't work for you, and you find it
-inconvenient to use `Invoke()`, you can use a macro from the `ACTION*`
-family to quickly define a new action that can be used in your code as
-if it's a built-in action.
-
-By writing
-```
-ACTION(name) { statements; }
-```
-in a namespace scope (i.e. not inside a class or function), you will
-define an action with the given name that executes the statements.
-The value returned by `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 as `argK`.  For example:
-```
-ACTION(IncrementArg1) { return ++(*arg1); }
-```
-allows you to write
-```
-... WillOnce(IncrementArg1());
-```
-
-Note that you don't need to specify the types of the mock function
-arguments.  Rest assured that your code is type-safe though:
-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.
-
-Another example:
-```
-ACTION(Foo) {
-  (*arg2)(5);
-  Blah();
-  *arg1 = 0;
-  return arg0;
-}
-```
-defines an action `Foo()` that invokes argument #2 (a function pointer)
-with 5, calls function `Blah()`, sets the value pointed to by argument
-#1 to 0, and returns argument #0.
-
-For more convenience and flexibility, you can also use the following
-pre-defined symbols in the body of `ACTION`:
-
-| `argK_type` | The type of the K-th (0-based) argument of the mock function |
-|:------------|:-------------------------------------------------------------|
-| `args`      | All arguments of the mock function as a tuple                |
-| `args_type` | The type of all arguments of the mock function as a tuple    |
-| `return_type` | The return type of the mock function                         |
-| `function_type` | The type of the mock function                                |
-
-For example, when using an `ACTION` as a stub action for mock function:
-```
-int DoSomething(bool flag, int* ptr);
-```
-we have:
-| **Pre-defined Symbol** | **Is Bound To** |
-|:-----------------------|:----------------|
-| `arg0`                 | the value of `flag` |
-| `arg0_type`            | the type `bool` |
-| `arg1`                 | the value of `ptr` |
-| `arg1_type`            | the type `int*` |
-| `args`                 | the tuple `(flag, ptr)` |
-| `args_type`            | the type `std::tr1::tuple<bool, int*>` |
-| `return_type`          | the type `int`  |
-| `function_type`        | the type `int(bool, int*)` |
-
-## Writing New Parameterized Actions Quickly ##
-
-Sometimes you'll want to parameterize an action you define.  For that
-we have another macro
-```
-ACTION_P(name, param) { statements; }
-```
-
-For example,
-```
-ACTION_P(Add, n) { return arg0 + n; }
-```
-will allow you to write
-```
-// Returns argument #0 + 5.
-... WillOnce(Add(5));
-```
-
-For convenience, we use the term _arguments_ for the values used to
-invoke the mock function, and the term _parameters_ for the values
-used to instantiate an action.
-
-Note that you don't need to provide the type of the parameter either.
-Suppose the parameter is named `param`, you can also use the
-Google-Mock-defined symbol `param_type` to refer to the type of the
-parameter as inferred by the compiler.  For example, in the body of
-`ACTION_P(Add, n)` above, you can write `n_type` for the type of `n`.
-
-Google Mock also provides `ACTION_P2`, `ACTION_P3`, and etc to support
-multi-parameter actions.  For example,
-```
-ACTION_P2(ReturnDistanceTo, x, y) {
-  double dx = arg0 - x;
-  double dy = arg1 - y;
-  return sqrt(dx*dx + dy*dy);
-}
-```
-lets you write
-```
-... WillOnce(ReturnDistanceTo(5.0, 26.5));
-```
-
-You can view `ACTION` as a degenerated parameterized action where the
-number of parameters is 0.
-
-You can also easily define actions overloaded on the number of parameters:
-```
-ACTION_P(Plus, a) { ... }
-ACTION_P2(Plus, a, b) { ... }
-```
-
-## Restricting the Type of an Argument or Parameter in an ACTION ##
-
-For maximum brevity and reusability, the `ACTION*` macros don't ask
-you to provide the types of the mock function arguments and the action
-parameters.  Instead, we let the compiler infer the types for us.
-
-Sometimes, however, we may want to be more explicit about the types.
-There are several tricks to do that.  For example:
-```
-ACTION(Foo) {
-  // Makes sure arg0 can be converted to int.
-  int n = arg0;
-  ... use n instead of arg0 here ...
-}
-
-ACTION_P(Bar, param) {
-  // Makes sure the type of arg1 is const char*.
-  ::testing::StaticAssertTypeEq<const char*, arg1_type>();
-
-  // Makes sure param can be converted to bool.
-  bool flag = param;
-}
-```
-where `StaticAssertTypeEq` is a compile-time assertion in Google Test
-that verifies two types are the same.
-
-## Writing New Action Templates Quickly ##
-
-Sometimes you want to give an action explicit template parameters that
-cannot be inferred from its value parameters.  `ACTION_TEMPLATE()`
-supports 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, where _m_ is between 1 and 10, and _n_ is
-between 0 and 10.  `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,
-                // Note the comma between int and k:
-                HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
-                AND_1_VALUE_PARAMS(output)) {
-  *output = T(std::tr1::get<k>(args));
-}
-```
-
-To create an instance of an action template, write:
-```
-  ActionName<t1, ..., t_m>(v1, ..., v_n)
-```
-where the `t`s are the template arguments and the
-`v`s are the value arguments.  The value argument
-types are inferred by the compiler.  For example:
-```
-using ::testing::_;
-...
-  int n;
-  EXPECT_CALL(mock, Foo(_, _))
-      .WillOnce(DuplicateArg<1, unsigned char>(&n));
-```
-
-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 a two-template-parameter action where the compiler
-is asked to infer the type of `x`?
-
-## Using the ACTION Object's Type ##
-
-If you are writing a function that returns an `ACTION` object, you'll
-need to know its type.  The type depends on the macro used to define
-the action and the parameter types.  The rule is relatively simple:
-| **Given Definition** | **Expression** | **Has Type** |
-|:---------------------|:---------------|:-------------|
-| `ACTION(Foo)`        | `Foo()`        | `FooAction`  |
-| `ACTION_TEMPLATE(Foo, HAS_m_TEMPLATE_PARAMS(...), AND_0_VALUE_PARAMS())` |	`Foo<t1, ..., t_m>()` | `FooAction<t1, ..., t_m>` |
-| `ACTION_P(Bar, param)` | `Bar(int_value)` | `BarActionP<int>` |
-| `ACTION_TEMPLATE(Bar, HAS_m_TEMPLATE_PARAMS(...), AND_1_VALUE_PARAMS(p1))` | `Bar<t1, ..., t_m>(int_value)` | `FooActionP<t1, ..., t_m, int>` |
-| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value, int_value)` | `BazActionP2<bool, int>` |
-| `ACTION_TEMPLATE(Baz, HAS_m_TEMPLATE_PARAMS(...), AND_2_VALUE_PARAMS(p1, p2))` | `Baz<t1, ..., t_m>(bool_value, int_value)` | `FooActionP2<t1, ..., t_m, bool, int>` |
-| ...                  | ...            | ...          |
-
-Note that we have to pick different suffixes (`Action`, `ActionP`,
-`ActionP2`, and etc) for actions with different numbers of value
-parameters, or the action definitions cannot be overloaded on the
-number of them.
-
-## Writing New Monomorphic Actions ##
-
-While the `ACTION*` macros are very convenient, sometimes they are
-inappropriate.  For example, despite the tricks shown in the previous
-recipes, they don't let you directly specify the types of the mock
-function arguments and the action parameters, which in general leads
-to unoptimized compiler error messages that can baffle unfamiliar
-users.  They also don't allow overloading actions based on parameter
-types without jumping through some hoops.
-
-An alternative to the `ACTION*` macros is to implement
-`::testing::ActionInterface<F>`, where `F` is the type of the mock
-function in which the action will be used. For example:
-
-```
-template <typename F>class ActionInterface {
- public:
-  virtual ~ActionInterface();
-
-  // Performs the action.  Result is the return type of function type
-  // F, and ArgumentTuple is the tuple of arguments of F.
-  //
-  // For example, if F is int(bool, const string&), then Result would
-  // be int, and ArgumentTuple would be tr1::tuple<bool, const string&>.
-  virtual Result Perform(const ArgumentTuple& args) = 0;
-};
-
-using ::testing::_;
-using ::testing::Action;
-using ::testing::ActionInterface;
-using ::testing::MakeAction;
-
-typedef int IncrementMethod(int*);
-
-class IncrementArgumentAction : public ActionInterface<IncrementMethod> {
- public:
-  virtual int Perform(const tr1::tuple<int*>& args) {
-    int* p = tr1::get<0>(args);  // Grabs the first argument.
-    return *p++;
-  }
-};
-
-Action<IncrementMethod> IncrementArgument() {
-  return MakeAction(new IncrementArgumentAction);
-}
-...
-
-  EXPECT_CALL(foo, Baz(_))
-      .WillOnce(IncrementArgument());
-
-  int n = 5;
-  foo.Baz(&n);  // Should return 5 and change n to 6.
-```
-
-## Writing New Polymorphic Actions ##
-
-The previous recipe showed you how to define your own action. This is
-all good, except that you need to know the type of the function in
-which the action will be used. Sometimes that can be a problem. For
-example, if you want to use the action in functions with _different_
-types (e.g. like `Return()` and `SetArgPointee()`).
-
-If an action can be used in several types of mock functions, we say
-it's _polymorphic_. The `MakePolymorphicAction()` function template
-makes it easy to define such an action:
-
-```
-namespace testing {
-
-template <typename Impl>
-PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl);
-
-}  // namespace testing
-```
-
-As an example, let's define an action that returns the second argument
-in the mock function's argument list. The first step is to define an
-implementation class:
-
-```
-class ReturnSecondArgumentAction {
- public:
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) const {
-    // To get the i-th (0-based) argument, use tr1::get<i>(args).
-    return tr1::get<1>(args);
-  }
-};
-```
-
-This implementation class does _not_ need to inherit from any
-particular class. What matters is that it must have a `Perform()`
-method template. This method template takes the mock function's
-arguments as a tuple in a **single** argument, and returns the result of
-the action. It can be either `const` or not, but must be invokable
-with exactly one template argument, which is the result type. In other
-words, you must be able to call `Perform<R>(args)` where `R` is the
-mock function's return type and `args` is its arguments in a tuple.
-
-Next, we use `MakePolymorphicAction()` to turn an instance of the
-implementation class into the polymorphic action we need. It will be
-convenient to have a wrapper for this:
-
-```
-using ::testing::MakePolymorphicAction;
-using ::testing::PolymorphicAction;
-
-PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
-  return MakePolymorphicAction(ReturnSecondArgumentAction());
-}
-```
-
-Now, you can use this polymorphic action the same way you use the
-built-in ones:
-
-```
-using ::testing::_;
-
-class MockFoo : public Foo {
- public:
-  MOCK_METHOD2(DoThis, int(bool flag, int n));
-  MOCK_METHOD3(DoThat, string(int x, const char* str1, const char* str2));
-};
-...
-
-  MockFoo foo;
-  EXPECT_CALL(foo, DoThis(_, _))
-      .WillOnce(ReturnSecondArgument());
-  EXPECT_CALL(foo, DoThat(_, _, _))
-      .WillOnce(ReturnSecondArgument());
-  ...
-  foo.DoThis(true, 5);         // Will return 5.
-  foo.DoThat(1, "Hi", "Bye");  // Will return "Hi".
-```
-
-## Teaching Google Mock How to Print Your Values ##
-
-When an uninteresting or unexpected call occurs, Google Mock prints the
-argument values and the stack trace to help you debug.  Assertion
-macros like `EXPECT_THAT` and `EXPECT_EQ` also print the values in
-question when the assertion fails.  Google Mock and Google Test do this using
-Google Test's user-extensible value printer.
-
-This printer knows how to print built-in C++ types, native arrays, STL
-containers, and any type that supports the `<<` operator.  For other
-types, it prints the raw bytes in the value and hopes that you the
-user can figure it out.
-[Google Test's advanced guide](http://code.google.com/p/googletest/wiki/AdvancedGuide#Teaching_Google_Test_How_to_Print_Your_Values)
-explains how to extend the printer to do a better job at
-printing your particular type than to dump the bytes.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/Documentation.md
deleted file mode 100644
index d9181f28..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/Documentation.md
+++ /dev/null
@@ -1,12 +0,0 @@
-This page lists all documentation wiki pages for Google Mock **(the SVN trunk version)**
-- **if you use a released version of Google Mock, please read the documentation for that specific version instead.**
-
-  * [ForDummies](V1_7_ForDummies.md) -- start here if you are new to Google Mock.
-  * [CheatSheet](V1_7_CheatSheet.md) -- a quick reference.
-  * [CookBook](V1_7_CookBook.md) -- recipes for doing various tasks using Google Mock.
-  * [FrequentlyAskedQuestions](V1_7_FrequentlyAskedQuestions.md) -- check here before asking a question on the mailing list.
-
-To contribute code to Google Mock, read:
-
-  * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
-  * [Pump Manual](http://code.google.com/p/googletest/wiki/PumpManual) -- how we generate some of Google Mock's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/ForDummies.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/ForDummies.md
deleted file mode 100644
index ee03c5b9..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/ForDummies.md
+++ /dev/null
@@ -1,439 +0,0 @@
-
-
-(**Note:** If you get compiler errors that you don't understand, be sure to consult [Google Mock Doctor](http://code.google.com/p/googlemock/wiki/V1_7_FrequentlyAskedQuestions#How_am_I_supposed_to_make_sense_of_these_horrible_template_error).)
-
-# What Is Google C++ Mocking Framework? #
-When you write a prototype or test, often it's not feasible or wise to rely on real objects entirely. A **mock object** implements the same interface as a real object (so it can be used as one), but lets you specify at run time how it will be used and what it should do (which methods will be called? in which order? how many times? with what arguments? what will they return? etc).
-
-**Note:** It is easy to confuse the term _fake objects_ with mock objects. Fakes and mocks actually mean very different things in the Test-Driven Development (TDD) community:
-
-  * **Fake** objects have working implementations, but usually take some shortcut (perhaps to make the operations less expensive), which makes them not suitable for production. An in-memory file system would be an example of a fake.
-  * **Mocks** are objects pre-programmed with _expectations_, which form a specification of the calls they are expected to receive.
-
-If all this seems too abstract for you, don't worry - the most important thing to remember is that a mock allows you to check the _interaction_ between itself and code that uses it. The difference between fakes and mocks will become much clearer once you start to use mocks.
-
-**Google C++ Mocking Framework** (or **Google Mock** for short) is a library (sometimes we also call it a "framework" to make it sound cool) for creating mock classes and using them. It does to C++ what [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/) do to Java.
-
-Using Google Mock involves three basic steps:
-
-  1. Use some simple macros to describe the interface you want to mock, and they will expand to the implementation of your mock class;
-  1. Create some mock objects and specify its expectations and behavior using an intuitive syntax;
-  1. Exercise code that uses the mock objects. Google Mock will catch any violation of the expectations as soon as it arises.
-
-# Why Google Mock? #
-While mock objects help you remove unnecessary dependencies in tests and make them fast and reliable, using mocks manually in C++ is _hard_:
-
-  * Someone has to implement the mocks. The job is usually tedious and error-prone. No wonder people go great distance to avoid it.
-  * The quality of those manually written mocks is a bit, uh, unpredictable. You may see some really polished ones, but you may also see some that were hacked up in a hurry and have all sorts of ad hoc restrictions.
-  * The knowledge you gained from using one mock doesn't transfer to the next.
-
-In contrast, Java and Python programmers have some fine mock frameworks, which automate the creation of mocks. As a result, mocking is a proven effective technique and widely adopted practice in those communities. Having the right tool absolutely makes the difference.
-
-Google Mock was built to help C++ programmers. It was inspired by [jMock](http://www.jmock.org/) and [EasyMock](http://www.easymock.org/), but designed with C++'s specifics in mind. It is your friend if any of the following problems is bothering you:
-
-  * You are stuck with a sub-optimal design and wish you had done more prototyping before it was too late, but prototyping in C++ is by no means "rapid".
-  * Your tests are slow as they depend on too many libraries or use expensive resources (e.g. a database).
-  * Your tests are brittle as some resources they use are unreliable (e.g. the network).
-  * You want to test how your code handles a failure (e.g. a file checksum error), but it's not easy to cause one.
-  * You need to make sure that your module interacts with other modules in the right way, but it's hard to observe the interaction; therefore you resort to observing the side effects at the end of the action, which is awkward at best.
-  * You want to "mock out" your dependencies, except that they don't have mock implementations yet; and, frankly, you aren't thrilled by some of those hand-written mocks.
-
-We encourage you to use Google Mock as:
-
-  * a _design_ tool, for it lets you experiment with your interface design early and often. More iterations lead to better designs!
-  * a _testing_ tool to cut your tests' outbound dependencies and probe the interaction between your module and its collaborators.
-
-# Getting Started #
-Using Google Mock is easy! Inside your C++ source file, just `#include` `"gtest/gtest.h"` and `"gmock/gmock.h"`, and you are ready to go.
-
-# A Case for Mock Turtles #
-Let's look at an example. Suppose you are developing a graphics program that relies on a LOGO-like API for drawing. How would you test that it does the right thing? Well, you can run it and compare the screen with a golden screen snapshot, but let's admit it: tests like this are expensive to run and fragile (What if you just upgraded to a shiny new graphics card that has better anti-aliasing? Suddenly you have to update all your golden images.). It would be too painful if all your tests are like this. Fortunately, you learned about Dependency Injection and know the right thing to do: instead of having your application talk to the drawing API directly, wrap the API in an interface (say, `Turtle`) and code to that interface:
-
-```
-class Turtle {
-  ...
-  virtual ~Turtle() {}
-  virtual void PenUp() = 0;
-  virtual void PenDown() = 0;
-  virtual void Forward(int distance) = 0;
-  virtual void Turn(int degrees) = 0;
-  virtual void GoTo(int x, int y) = 0;
-  virtual int GetX() const = 0;
-  virtual int GetY() const = 0;
-};
-```
-
-(Note that the destructor of `Turtle` **must** be virtual, as is the case for **all** classes you intend to inherit from - otherwise the destructor of the derived class will not be called when you delete an object through a base pointer, and you'll get corrupted program states like memory leaks.)
-
-You can control whether the turtle's movement will leave a trace using `PenUp()` and `PenDown()`, and control its movement using `Forward()`, `Turn()`, and `GoTo()`. Finally, `GetX()` and `GetY()` tell you the current position of the turtle.
-
-Your program will normally use a real implementation of this interface. In tests, you can use a mock implementation instead. This allows you to easily check what drawing primitives your program is calling, with what arguments, and in which order. Tests written this way are much more robust (they won't break because your new machine does anti-aliasing differently), easier to read and maintain (the intent of a test is expressed in the code, not in some binary images), and run _much, much faster_.
-
-# Writing the Mock Class #
-If you are lucky, the mocks you need to use have already been implemented by some nice people. If, however, you find yourself in the position to write a mock class, relax - Google Mock turns this task into a fun game! (Well, almost.)
-
-## How to Define It ##
-Using the `Turtle` interface as example, here are the simple steps you need to follow:
-
-  1. Derive a class `MockTurtle` from `Turtle`.
-  1. Take a _virtual_ function of `Turtle` (while it's possible to [mock non-virtual methods using templates](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Mocking_Nonvirtual_Methods), it's much more involved). Count how many arguments it has.
-  1. In the `public:` section of the child class, write `MOCK_METHODn();` (or `MOCK_CONST_METHODn();` if you are mocking a `const` method), where `n` is the number of the arguments; if you counted wrong, shame on you, and a compiler error will tell you so.
-  1. Now comes the fun part: you take the function signature, cut-and-paste the _function name_ as the _first_ argument to the macro, and leave what's left as the _second_ argument (in case you're curious, this is the _type of the function_).
-  1. Repeat until all virtual functions you want to mock are done.
-
-After the process, you should have something like:
-
-```
-#include "gmock/gmock.h"  // Brings in Google Mock.
-class MockTurtle : public Turtle {
- public:
-  ...
-  MOCK_METHOD0(PenUp, void());
-  MOCK_METHOD0(PenDown, void());
-  MOCK_METHOD1(Forward, void(int distance));
-  MOCK_METHOD1(Turn, void(int degrees));
-  MOCK_METHOD2(GoTo, void(int x, int y));
-  MOCK_CONST_METHOD0(GetX, int());
-  MOCK_CONST_METHOD0(GetY, int());
-};
-```
-
-You don't need to define these mock methods somewhere else - the `MOCK_METHOD*` macros will generate the definitions for you. It's that simple! Once you get the hang of it, you can pump out mock classes faster than your source-control system can handle your check-ins.
-
-**Tip:** If even this is too much work for you, you'll find the
-`gmock_gen.py` tool in Google Mock's `scripts/generator/` directory (courtesy of the [cppclean](http://code.google.com/p/cppclean/) project) useful.  This command-line
-tool requires that you have Python 2.4 installed.  You give it a C++ file and the name of an abstract class defined in it,
-and it will print the definition of the mock class for you.  Due to the
-complexity of the C++ language, this script may not always work, but
-it can be quite handy when it does.  For more details, read the [user documentation](http://code.google.com/p/googlemock/source/browse/trunk/scripts/generator/README).
-
-## Where to Put It ##
-When you define a mock class, you need to decide where to put its definition. Some people put it in a `*_test.cc`. This is fine when the interface being mocked (say, `Foo`) is owned by the same person or team. Otherwise, when the owner of `Foo` changes it, your test could break. (You can't really expect `Foo`'s maintainer to fix every test that uses `Foo`, can you?)
-
-So, the rule of thumb is: if you need to mock `Foo` and it's owned by others, define the mock class in `Foo`'s package (better, in a `testing` sub-package such that you can clearly separate production code and testing utilities), and put it in a `mock_foo.h`. Then everyone can reference `mock_foo.h` from their tests. If `Foo` ever changes, there is only one copy of `MockFoo` to change, and only tests that depend on the changed methods need to be fixed.
-
-Another way to do it: you can introduce a thin layer `FooAdaptor` on top of `Foo` and code to this new interface. Since you own `FooAdaptor`, you can absorb changes in `Foo` much more easily. While this is more work initially, carefully choosing the adaptor interface can make your code easier to write and more readable (a net win in the long run), as you can choose `FooAdaptor` to fit your specific domain much better than `Foo` does.
-
-# Using Mocks in Tests #
-Once you have a mock class, using it is easy. The typical work flow is:
-
-  1. Import the Google Mock names from the `testing` namespace such that you can use them unqualified (You only have to do it once per file. Remember that namespaces are a good idea and good for your health.).
-  1. Create some mock objects.
-  1. Specify your expectations on them (How many times will a method be called? With what arguments? What should it do? etc.).
-  1. Exercise some code that uses the mocks; optionally, check the result using Google Test assertions. If a mock method is called more than expected or with wrong arguments, you'll get an error immediately.
-  1. When a mock is destructed, Google Mock will automatically check whether all expectations on it have been satisfied.
-
-Here's an example:
-
-```
-#include "path/to/mock-turtle.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-using ::testing::AtLeast;                     // #1
-
-TEST(PainterTest, CanDrawSomething) {
-  MockTurtle turtle;                          // #2
-  EXPECT_CALL(turtle, PenDown())              // #3
-      .Times(AtLeast(1));
-
-  Painter painter(&turtle);                   // #4
-
-  EXPECT_TRUE(painter.DrawCircle(0, 0, 10));
-}                                             // #5
-
-int main(int argc, char** argv) {
-  // The following line must be executed to initialize Google Mock
-  // (and Google Test) before running the tests.
-  ::testing::InitGoogleMock(&argc, argv);
-  return RUN_ALL_TESTS();
-}
-```
-
-As you might have guessed, this test checks that `PenDown()` is called at least once. If the `painter` object didn't call this method, your test will fail with a message like this:
-
-```
-path/to/my_test.cc:119: Failure
-Actual function call count doesn't match this expectation:
-Actually: never called;
-Expected: called at least once.
-```
-
-**Tip 1:** If you run the test from an Emacs buffer, you can hit `<Enter>` on the line number displayed in the error message to jump right to the failed expectation.
-
-**Tip 2:** If your mock objects are never deleted, the final verification won't happen. Therefore it's a good idea to use a heap leak checker in your tests when you allocate mocks on the heap.
-
-**Important note:** Google Mock requires expectations to be set **before** the mock functions are called, otherwise the behavior is **undefined**. In particular, you mustn't interleave `EXPECT_CALL()`s and calls to the mock functions.
-
-This means `EXPECT_CALL()` should be read as expecting that a call will occur _in the future_, not that a call has occurred. Why does Google Mock work like that? Well, specifying the expectation beforehand allows Google Mock to report a violation as soon as it arises, when the context (stack trace, etc) is still available. This makes debugging much easier.
-
-Admittedly, this test is contrived and doesn't do much. You can easily achieve the same effect without using Google Mock. However, as we shall reveal soon, Google Mock allows you to do _much more_ with the mocks.
-
-## Using Google Mock with Any Testing Framework ##
-If you want to use something other than Google Test (e.g. [CppUnit](http://apps.sourceforge.net/mediawiki/cppunit/index.php?title=Main_Page) or
-[CxxTest](http://cxxtest.tigris.org/)) as your testing framework, just change the `main()` function in the previous section to:
-```
-int main(int argc, char** argv) {
-  // The following line causes Google Mock to throw an exception on failure,
-  // which will be interpreted by your testing framework as a test failure.
-  ::testing::GTEST_FLAG(throw_on_failure) = true;
-  ::testing::InitGoogleMock(&argc, argv);
-  ... whatever your testing framework requires ...
-}
-```
-
-This approach has a catch: it makes Google Mock throw an exception
-from a mock object's destructor sometimes.  With some compilers, this
-sometimes causes the test program to crash.  You'll still be able to
-notice that the test has failed, but it's not a graceful failure.
-
-A better solution is to use Google Test's
-[event listener API](http://code.google.com/p/googletest/wiki/AdvancedGuide#Extending_Google_Test_by_Handling_Test_Events)
-to report a test failure to your testing framework properly.  You'll need to
-implement the `OnTestPartResult()` method of the event listener interface, but it
-should be straightforward.
-
-If this turns out to be too much work, we suggest that you stick with
-Google Test, which works with Google Mock seamlessly (in fact, it is
-technically part of Google Mock.).  If there is a reason that you
-cannot use Google Test, please let us know.
-
-# Setting Expectations #
-The key to using a mock object successfully is to set the _right expectations_ on it. If you set the expectations too strict, your test will fail as the result of unrelated changes. If you set them too loose, bugs can slip through. You want to do it just right such that your test can catch exactly the kind of bugs you intend it to catch. Google Mock provides the necessary means for you to do it "just right."
-
-## General Syntax ##
-In Google Mock we use the `EXPECT_CALL()` macro to set an expectation on a mock method. The general syntax is:
-
-```
-EXPECT_CALL(mock_object, method(matchers))
-    .Times(cardinality)
-    .WillOnce(action)
-    .WillRepeatedly(action);
-```
-
-The macro has two arguments: first the mock object, and then the method and its arguments. Note that the two are separated by a comma (`,`), not a period (`.`). (Why using a comma? The answer is that it was necessary for technical reasons.)
-
-The macro can be followed by some optional _clauses_ that provide more information about the expectation. We'll discuss how each clause works in the coming sections.
-
-This syntax is designed to make an expectation read like English. For example, you can probably guess that
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetX())
-    .Times(5)
-    .WillOnce(Return(100))
-    .WillOnce(Return(150))
-    .WillRepeatedly(Return(200));
-```
-
-says that the `turtle` object's `GetX()` method will be called five times, it will return 100 the first time, 150 the second time, and then 200 every time. Some people like to call this style of syntax a Domain-Specific Language (DSL).
-
-**Note:** Why do we use a macro to do this? It serves two purposes: first it makes expectations easily identifiable (either by `grep` or by a human reader), and second it allows Google Mock to include the source file location of a failed expectation in messages, making debugging easier.
-
-## Matchers: What Arguments Do We Expect? ##
-When a mock function takes arguments, we must specify what arguments we are expecting; for example:
-
-```
-// Expects the turtle to move forward by 100 units.
-EXPECT_CALL(turtle, Forward(100));
-```
-
-Sometimes you may not want to be too specific (Remember that talk about tests being too rigid? Over specification leads to brittle tests and obscures the intent of tests. Therefore we encourage you to specify only what's necessary - no more, no less.). If you care to check that `Forward()` will be called but aren't interested in its actual argument, write `_` as the argument, which means "anything goes":
-
-```
-using ::testing::_;
-...
-// Expects the turtle to move forward.
-EXPECT_CALL(turtle, Forward(_));
-```
-
-`_` is an instance of what we call **matchers**. A matcher is like a predicate and can test whether an argument is what we'd expect. You can use a matcher inside `EXPECT_CALL()` wherever a function argument is expected.
-
-A list of built-in matchers can be found in the [CheatSheet](V1_7_CheatSheet.md). For example, here's the `Ge` (greater than or equal) matcher:
-
-```
-using ::testing::Ge;...
-EXPECT_CALL(turtle, Forward(Ge(100)));
-```
-
-This checks that the turtle will be told to go forward by at least 100 units.
-
-## Cardinalities: How Many Times Will It Be Called? ##
-The first clause we can specify following an `EXPECT_CALL()` is `Times()`. We call its argument a **cardinality** as it tells _how many times_ the call should occur. It allows us to repeat an expectation many times without actually writing it as many times. More importantly, a cardinality can be "fuzzy", just like a matcher can be. This allows a user to express the intent of a test exactly.
-
-An interesting special case is when we say `Times(0)`. You may have guessed - it means that the function shouldn't be called with the given arguments at all, and Google Mock will report a Google Test failure whenever the function is (wrongfully) called.
-
-We've seen `AtLeast(n)` as an example of fuzzy cardinalities earlier. For the list of built-in cardinalities you can use, see the [CheatSheet](V1_7_CheatSheet.md).
-
-The `Times()` clause can be omitted. **If you omit `Times()`, Google Mock will infer the cardinality for you.** The rules are easy to remember:
-
-  * If **neither** `WillOnce()` **nor** `WillRepeatedly()` is in the `EXPECT_CALL()`, the inferred cardinality is `Times(1)`.
-  * If there are `n WillOnce()`'s but **no** `WillRepeatedly()`, where `n` >= 1, the cardinality is `Times(n)`.
-  * If there are `n WillOnce()`'s and **one** `WillRepeatedly()`, where `n` >= 0, the cardinality is `Times(AtLeast(n))`.
-
-**Quick quiz:** what do you think will happen if a function is expected to be called twice but actually called four times?
-
-## Actions: What Should It Do? ##
-Remember that a mock object doesn't really have a working implementation? We as users have to tell it what to do when a method is invoked. This is easy in Google Mock.
-
-First, if the return type of a mock function is a built-in type or a pointer, the function has a **default action** (a `void` function will just return, a `bool` function will return `false`, and other functions will return 0). If you don't say anything, this behavior will be used.
-
-Second, if a mock function doesn't have a default action, or the default action doesn't suit you, you can specify the action to be taken each time the expectation matches using a series of `WillOnce()` clauses followed by an optional `WillRepeatedly()`. For example,
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetX())
-    .WillOnce(Return(100))
-    .WillOnce(Return(200))
-    .WillOnce(Return(300));
-```
-
-This says that `turtle.GetX()` will be called _exactly three times_ (Google Mock inferred this from how many `WillOnce()` clauses we've written, since we didn't explicitly write `Times()`), and will return 100, 200, and 300 respectively.
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetY())
-    .WillOnce(Return(100))
-    .WillOnce(Return(200))
-    .WillRepeatedly(Return(300));
-```
-
-says that `turtle.GetY()` will be called _at least twice_ (Google Mock knows this as we've written two `WillOnce()` clauses and a `WillRepeatedly()` while having no explicit `Times()`), will return 100 the first time, 200 the second time, and 300 from the third time on.
-
-Of course, if you explicitly write a `Times()`, Google Mock will not try to infer the cardinality itself. What if the number you specified is larger than there are `WillOnce()` clauses? Well, after all `WillOnce()`s are used up, Google Mock will do the _default_ action for the function every time (unless, of course, you have a `WillRepeatedly()`.).
-
-What can we do inside `WillOnce()` besides `Return()`? You can return a reference using `ReturnRef(variable)`, or invoke a pre-defined function, among [others](http://code.google.com/p/googlemock/wiki/V1_7_CheatSheet#Actions).
-
-**Important note:** The `EXPECT_CALL()` statement evaluates the action clause only once, even though the action may be performed many times. Therefore you must be careful about side effects. The following may not do what you want:
-
-```
-int n = 100;
-EXPECT_CALL(turtle, GetX())
-.Times(4)
-.WillRepeatedly(Return(n++));
-```
-
-Instead of returning 100, 101, 102, ..., consecutively, this mock function will always return 100 as `n++` is only evaluated once. Similarly, `Return(new Foo)` will create a new `Foo` object when the `EXPECT_CALL()` is executed, and will return the same pointer every time. If you want the side effect to happen every time, you need to define a custom action, which we'll teach in the [CookBook](V1_7_CookBook.md).
-
-Time for another quiz! What do you think the following means?
-
-```
-using ::testing::Return;...
-EXPECT_CALL(turtle, GetY())
-.Times(4)
-.WillOnce(Return(100));
-```
-
-Obviously `turtle.GetY()` is expected to be called four times. But if you think it will return 100 every time, think twice! Remember that one `WillOnce()` clause will be consumed each time the function is invoked and the default action will be taken afterwards. So the right answer is that `turtle.GetY()` will return 100 the first time, but **return 0 from the second time on**, as returning 0 is the default action for `int` functions.
-
-## Using Multiple Expectations ##
-So far we've only shown examples where you have a single expectation. More realistically, you're going to specify expectations on multiple mock methods, which may be from multiple mock objects.
-
-By default, when a mock method is invoked, Google Mock will search the expectations in the **reverse order** they are defined, and stop when an active expectation that matches the arguments is found (you can think of it as "newer rules override older ones."). If the matching expectation cannot take any more calls, you will get an upper-bound-violated failure. Here's an example:
-
-```
-using ::testing::_;...
-EXPECT_CALL(turtle, Forward(_));  // #1
-EXPECT_CALL(turtle, Forward(10))  // #2
-    .Times(2);
-```
-
-If `Forward(10)` is called three times in a row, the third time it will be an error, as the last matching expectation (#2) has been saturated. If, however, the third `Forward(10)` call is replaced by `Forward(20)`, then it would be OK, as now #1 will be the matching expectation.
-
-**Side note:** Why does Google Mock search for a match in the _reverse_ order of the expectations? The reason is that this allows a user to set up the default expectations in a mock object's constructor or the test fixture's set-up phase and then customize the mock by writing more specific expectations in the test body. So, if you have two expectations on the same method, you want to put the one with more specific matchers **after** the other, or the more specific rule would be shadowed by the more general one that comes after it.
-
-## Ordered vs Unordered Calls ##
-By default, an expectation can match a call even though an earlier expectation hasn't been satisfied. In other words, the calls don't have to occur in the order the expectations are specified.
-
-Sometimes, you may want all the expected calls to occur in a strict order. To say this in Google Mock is easy:
-
-```
-using ::testing::InSequence;...
-TEST(FooTest, DrawsLineSegment) {
-  ...
-  {
-    InSequence dummy;
-
-    EXPECT_CALL(turtle, PenDown());
-    EXPECT_CALL(turtle, Forward(100));
-    EXPECT_CALL(turtle, PenUp());
-  }
-  Foo();
-}
-```
-
-By creating an object of type `InSequence`, all expectations in its scope are put into a _sequence_ and have to occur _sequentially_. Since we are just relying on the constructor and destructor of this object to do the actual work, its name is really irrelevant.
-
-In this example, we test that `Foo()` calls the three expected functions in the order as written. If a call is made out-of-order, it will be an error.
-
-(What if you care about the relative order of some of the calls, but not all of them? Can you specify an arbitrary partial order? The answer is ... yes! If you are impatient, the details can be found in the [CookBook](V1_7_CookBook#Expecting_Partially_Ordered_Calls.md).)
-
-## All Expectations Are Sticky (Unless Said Otherwise) ##
-Now let's do a quick quiz to see how well you can use this mock stuff already. How would you test that the turtle is asked to go to the origin _exactly twice_ (you want to ignore any other instructions it receives)?
-
-After you've come up with your answer, take a look at ours and compare notes (solve it yourself first - don't cheat!):
-
-```
-using ::testing::_;...
-EXPECT_CALL(turtle, GoTo(_, _))  // #1
-    .Times(AnyNumber());
-EXPECT_CALL(turtle, GoTo(0, 0))  // #2
-    .Times(2);
-```
-
-Suppose `turtle.GoTo(0, 0)` is called three times. In the third time, Google Mock will see that the arguments match expectation #2 (remember that we always pick the last matching expectation). Now, since we said that there should be only two such calls, Google Mock will report an error immediately. This is basically what we've told you in the "Using Multiple Expectations" section above.
-
-This example shows that **expectations in Google Mock are "sticky" by default**, in the sense that they remain active even after we have reached their invocation upper bounds. This is an important rule to remember, as it affects the meaning of the spec, and is **different** to how it's done in many other mocking frameworks (Why'd we do that? Because we think our rule makes the common cases easier to express and understand.).
-
-Simple? Let's see if you've really understood it: what does the following code say?
-
-```
-using ::testing::Return;
-...
-for (int i = n; i > 0; i--) {
-  EXPECT_CALL(turtle, GetX())
-      .WillOnce(Return(10*i));
-}
-```
-
-If you think it says that `turtle.GetX()` will be called `n` times and will return 10, 20, 30, ..., consecutively, think twice! The problem is that, as we said, expectations are sticky. So, the second time `turtle.GetX()` is called, the last (latest) `EXPECT_CALL()` statement will match, and will immediately lead to an "upper bound exceeded" error - this piece of code is not very useful!
-
-One correct way of saying that `turtle.GetX()` will return 10, 20, 30, ..., is to explicitly say that the expectations are _not_ sticky. In other words, they should _retire_ as soon as they are saturated:
-
-```
-using ::testing::Return;
-...
-for (int i = n; i > 0; i--) {
-  EXPECT_CALL(turtle, GetX())
-    .WillOnce(Return(10*i))
-    .RetiresOnSaturation();
-}
-```
-
-And, there's a better way to do it: in this case, we expect the calls to occur in a specific order, and we line up the actions to match the order. Since the order is important here, we should make it explicit using a sequence:
-
-```
-using ::testing::InSequence;
-using ::testing::Return;
-...
-{
-  InSequence s;
-
-  for (int i = 1; i <= n; i++) {
-    EXPECT_CALL(turtle, GetX())
-        .WillOnce(Return(10*i))
-        .RetiresOnSaturation();
-  }
-}
-```
-
-By the way, the other situation where an expectation may _not_ be sticky is when it's in a sequence - as soon as another expectation that comes after it in the sequence has been used, it automatically retires (and will never be used to match any call).
-
-## Uninteresting Calls ##
-A mock object may have many methods, and not all of them are that interesting. For example, in some tests we may not care about how many times `GetX()` and `GetY()` get called.
-
-In Google Mock, if you are not interested in a method, just don't say anything about it. If a call to this method occurs, you'll see a warning in the test output, but it won't be a failure.
-
-# What Now? #
-Congratulations! You've learned enough about Google Mock to start using it. Now, you might want to join the [googlemock](http://groups.google.com/group/googlemock) discussion group and actually write some tests using Google Mock - it will be fun. Hey, it may even be addictive - you've been warned.
-
-Then, if you feel like increasing your mock quotient, you should move on to the [CookBook](V1_7_CookBook.md). You can learn many advanced features of Google Mock there -- and advance your level of enjoyment and testing bliss.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/FrequentlyAskedQuestions.md b/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/FrequentlyAskedQuestions.md
deleted file mode 100644
index fa21233a..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/docs/v1_7/FrequentlyAskedQuestions.md
+++ /dev/null
@@ -1,628 +0,0 @@
-
-
-Please send your questions to the
-[googlemock](http://groups.google.com/group/googlemock) discussion
-group. If you need help with compiler errors, make sure you have
-tried [Google Mock Doctor](#How_am_I_supposed_to_make_sense_of_these_horrible_template_error.md) first.
-
-## When I call a method on my mock object, the method for the real object is invoked instead.  What's the problem? ##
-
-In order for a method to be mocked, it must be _virtual_, unless you use the [high-perf dependency injection technique](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Mocking_Nonvirtual_Methods).
-
-## I wrote some matchers.  After I upgraded to a new version of Google Mock, they no longer compile.  What's going on? ##
-
-After version 1.4.0 of Google Mock was released, we had an idea on how
-to make it easier to write matchers that can generate informative
-messages efficiently.  We experimented with this idea and liked what
-we saw.  Therefore we decided to implement it.
-
-Unfortunately, this means that if you have defined your own matchers
-by implementing `MatcherInterface` or using `MakePolymorphicMatcher()`,
-your definitions will no longer compile.  Matchers defined using the
-`MATCHER*` family of macros are not affected.
-
-Sorry for the hassle if your matchers are affected.  We believe it's
-in everyone's long-term interest to make this change sooner than
-later.  Fortunately, it's usually not hard to migrate an existing
-matcher to the new API.  Here's what you need to do:
-
-If you wrote your matcher like this:
-```
-// Old matcher definition that doesn't work with the latest
-// Google Mock.
-using ::testing::MatcherInterface;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetFoo() > 5;
-  }
-  ...
-};
-```
-
-you'll need to change it to:
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool MatchAndExplain(MyType value,
-                               MatchResultListener* listener) const {
-    // Returns true if value matches.
-    return value.GetFoo() > 5;
-  }
-  ...
-};
-```
-(i.e. rename `Matches()` to `MatchAndExplain()` and give it a second
-argument of type `MatchResultListener*`.)
-
-If you were also using `ExplainMatchResultTo()` to improve the matcher
-message:
-```
-// Old matcher definition that doesn't work with the lastest
-// Google Mock.
-using ::testing::MatcherInterface;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetFoo() > 5;
-  }
-
-  virtual void ExplainMatchResultTo(MyType value,
-                                    ::std::ostream* os) const {
-    // Prints some helpful information to os to help
-    // a user understand why value matches (or doesn't match).
-    *os << "the Foo property is " << value.GetFoo();
-  }
-  ...
-};
-```
-
-you should move the logic of `ExplainMatchResultTo()` into
-`MatchAndExplain()`, using the `MatchResultListener` argument where
-the `::std::ostream` was used:
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MatcherInterface;
-using ::testing::MatchResultListener;
-...
-class MyWonderfulMatcher : public MatcherInterface<MyType> {
- public:
-  ...
-  virtual bool MatchAndExplain(MyType value,
-                               MatchResultListener* listener) const {
-    // Returns true if value matches.
-    *listener << "the Foo property is " << value.GetFoo();
-    return value.GetFoo() > 5;
-  }
-  ...
-};
-```
-
-If your matcher is defined using `MakePolymorphicMatcher()`:
-```
-// Old matcher definition that doesn't work with the latest
-// Google Mock.
-using ::testing::MakePolymorphicMatcher;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetBar() < 42;
-  }
-  ...
-};
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-you should rename the `Matches()` method to `MatchAndExplain()` and
-add a `MatchResultListener*` argument (the same as what you need to do
-for matchers defined by implementing `MatcherInterface`):
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MakePolymorphicMatcher;
-using ::testing::MatchResultListener;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool MatchAndExplain(MyType value,
-                       MatchResultListener* listener) const {
-    // Returns true if value matches.
-    return value.GetBar() < 42;
-  }
-  ...
-};
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-If your polymorphic matcher uses `ExplainMatchResultTo()` for better
-failure messages:
-```
-// Old matcher definition that doesn't work with the latest
-// Google Mock.
-using ::testing::MakePolymorphicMatcher;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool Matches(MyType value) const {
-    // Returns true if value matches.
-    return value.GetBar() < 42;
-  }
-  ...
-};
-void ExplainMatchResultTo(const MyGreatMatcher& matcher,
-                          MyType value,
-                          ::std::ostream* os) {
-  // Prints some helpful information to os to help
-  // a user understand why value matches (or doesn't match).
-  *os << "the Bar property is " << value.GetBar();
-}
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-you'll need to move the logic inside `ExplainMatchResultTo()` to
-`MatchAndExplain()`:
-```
-// New matcher definition that works with the latest Google Mock.
-using ::testing::MakePolymorphicMatcher;
-using ::testing::MatchResultListener;
-...
-class MyGreatMatcher {
- public:
-  ...
-  bool MatchAndExplain(MyType value,
-                       MatchResultListener* listener) const {
-    // Returns true if value matches.
-    *listener << "the Bar property is " << value.GetBar();
-    return value.GetBar() < 42;
-  }
-  ...
-};
-... MakePolymorphicMatcher(MyGreatMatcher()) ...
-```
-
-For more information, you can read these
-[two](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Writing_New_Monomorphic_Matchers)
-[recipes](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Writing_New_Polymorphic_Matchers)
-from the cookbook.  As always, you
-are welcome to post questions on `googlemock@googlegroups.com` if you
-need any help.
-
-## When using Google Mock, do I have to use Google Test as the testing framework?  I have my favorite testing framework and don't want to switch. ##
-
-Google Mock works out of the box with Google Test.  However, it's easy
-to configure it to work with any testing framework of your choice.
-[Here](http://code.google.com/p/googlemock/wiki/V1_7_ForDummies#Using_Google_Mock_with_Any_Testing_Framework) is how.
-
-## How am I supposed to make sense of these horrible template errors? ##
-
-If you are confused by the compiler errors gcc threw at you,
-try consulting the _Google Mock Doctor_ tool first.  What it does is to
-scan stdin for gcc error messages, and spit out diagnoses on the
-problems (we call them diseases) your code has.
-
-To "install", run command:
-```
-alias gmd='<path to googlemock>/scripts/gmock_doctor.py'
-```
-
-To use it, do:
-```
-<your-favorite-build-command> <your-test> 2>&1 | gmd
-```
-
-For example:
-```
-make my_test 2>&1 | gmd
-```
-
-Or you can run `gmd` and copy-n-paste gcc's error messages to it.
-
-## Can I mock a variadic function? ##
-
-You cannot mock a variadic function (i.e. a function taking ellipsis
-(`...`) arguments) directly in Google Mock.
-
-The problem is that in general, there is _no way_ for a mock object to
-know how many arguments are passed to the variadic method, and what
-the arguments' types are.  Only the _author of the base class_ knows
-the protocol, and we cannot look into his head.
-
-Therefore, to mock such a function, the _user_ must teach the mock
-object how to figure out the number of arguments and their types.  One
-way to do it is to provide overloaded versions of the function.
-
-Ellipsis arguments are inherited from C and not really a C++ feature.
-They are unsafe to use and don't work with arguments that have
-constructors or destructors.  Therefore we recommend to avoid them in
-C++ as much as possible.
-
-## MSVC gives me warning C4301 or C4373 when I define a mock method with a const parameter.  Why? ##
-
-If you compile this using Microsoft Visual C++ 2005 SP1:
-```
-class Foo {
-  ...
-  virtual void Bar(const int i) = 0;
-};
-
-class MockFoo : public Foo {
-  ...
-  MOCK_METHOD1(Bar, void(const int i));
-};
-```
-You may get the following warning:
-```
-warning C4301: 'MockFoo::Bar': overriding virtual function only differs from 'Foo::Bar' by const/volatile qualifier
-```
-
-This is a MSVC bug.  The same code compiles fine with gcc ,for
-example.  If you use Visual C++ 2008 SP1, you would get the warning:
-```
-warning C4373: 'MockFoo::Bar': virtual function overrides 'Foo::Bar', previous versions of the compiler did not override when parameters only differed by const/volatile qualifiers
-```
-
-In C++, if you _declare_ a function with a `const` parameter, the
-`const` modifier is _ignored_.  Therefore, the `Foo` base class above
-is equivalent to:
-```
-class Foo {
-  ...
-  virtual void Bar(int i) = 0;  // int or const int?  Makes no difference.
-};
-```
-
-In fact, you can _declare_ Bar() with an `int` parameter, and _define_
-it with a `const int` parameter.  The compiler will still match them
-up.
-
-Since making a parameter `const` is meaningless in the method
-_declaration_, we recommend to remove it in both `Foo` and `MockFoo`.
-That should workaround the VC bug.
-
-Note that we are talking about the _top-level_ `const` modifier here.
-If the function parameter is passed by pointer or reference, declaring
-the _pointee_ or _referee_ as `const` is still meaningful.  For
-example, the following two declarations are _not_ equivalent:
-```
-void Bar(int* p);        // Neither p nor *p is const.
-void Bar(const int* p);  // p is not const, but *p is.
-```
-
-## I have a huge mock class, and Microsoft Visual C++ runs out of memory when compiling it.  What can I do? ##
-
-We've noticed that when the `/clr` compiler flag is used, Visual C++
-uses 5~6 times as much memory when compiling a mock class.  We suggest
-to avoid `/clr` when compiling native C++ mocks.
-
-## I can't figure out why Google Mock thinks my expectations are not satisfied.  What should I do? ##
-
-You might want to run your test with
-`--gmock_verbose=info`.  This flag lets Google Mock print a trace
-of every mock function call it receives.  By studying the trace,
-you'll gain insights on why the expectations you set are not met.
-
-## How can I assert that a function is NEVER called? ##
-
-```
-EXPECT_CALL(foo, Bar(_))
-    .Times(0);
-```
-
-## I have a failed test where Google Mock tells me TWICE that a particular expectation is not satisfied.  Isn't this redundant? ##
-
-When Google Mock detects a failure, it prints relevant information
-(the mock function arguments, the state of relevant expectations, and
-etc) to help the user debug.  If another failure is detected, Google
-Mock will do the same, including printing the state of relevant
-expectations.
-
-Sometimes an expectation's state didn't change between two failures,
-and you'll see the same description of the state twice.  They are
-however _not_ redundant, as they refer to _different points in time_.
-The fact they are the same _is_ interesting information.
-
-## I get a heap check failure when using a mock object, but using a real object is fine.  What can be wrong? ##
-
-Does the class (hopefully a pure interface) you are mocking have a
-virtual destructor?
-
-Whenever you derive from a base class, make sure its destructor is
-virtual.  Otherwise Bad Things will happen.  Consider the following
-code:
-
-```
-class Base {
- public:
-  // Not virtual, but should be.
-  ~Base() { ... }
-  ...
-};
-
-class Derived : public Base {
- public:
-  ...
- private:
-  std::string value_;
-};
-
-...
-  Base* p = new Derived;
-  ...
-  delete p;  // Surprise! ~Base() will be called, but ~Derived() will not
-             // - value_ is leaked.
-```
-
-By changing `~Base()` to virtual, `~Derived()` will be correctly
-called when `delete p` is executed, and the heap checker
-will be happy.
-
-## The "newer expectations override older ones" rule makes writing expectations awkward.  Why does Google Mock do that? ##
-
-When people complain about this, often they are referring to code like:
-
-```
-// foo.Bar() should be called twice, return 1 the first time, and return
-// 2 the second time.  However, I have to write the expectations in the
-// reverse order.  This sucks big time!!!
-EXPECT_CALL(foo, Bar())
-    .WillOnce(Return(2))
-    .RetiresOnSaturation();
-EXPECT_CALL(foo, Bar())
-    .WillOnce(Return(1))
-    .RetiresOnSaturation();
-```
-
-The problem is that they didn't pick the **best** way to express the test's
-intent.
-
-By default, expectations don't have to be matched in _any_ particular
-order.  If you want them to match in a certain order, you need to be
-explicit.  This is Google Mock's (and jMock's) fundamental philosophy: it's
-easy to accidentally over-specify your tests, and we want to make it
-harder to do so.
-
-There are two better ways to write the test spec.  You could either
-put the expectations in sequence:
-
-```
-// foo.Bar() should be called twice, return 1 the first time, and return
-// 2 the second time.  Using a sequence, we can write the expectations
-// in their natural order.
-{
-  InSequence s;
-  EXPECT_CALL(foo, Bar())
-      .WillOnce(Return(1))
-      .RetiresOnSaturation();
-  EXPECT_CALL(foo, Bar())
-      .WillOnce(Return(2))
-      .RetiresOnSaturation();
-}
-```
-
-or you can put the sequence of actions in the same expectation:
-
-```
-// foo.Bar() should be called twice, return 1 the first time, and return
-// 2 the second time.
-EXPECT_CALL(foo, Bar())
-    .WillOnce(Return(1))
-    .WillOnce(Return(2))
-    .RetiresOnSaturation();
-```
-
-Back to the original questions: why does Google Mock search the
-expectations (and `ON_CALL`s) from back to front?  Because this
-allows a user to set up a mock's behavior for the common case early
-(e.g. in the mock's constructor or the test fixture's set-up phase)
-and customize it with more specific rules later.  If Google Mock
-searches from front to back, this very useful pattern won't be
-possible.
-
-## Google Mock prints a warning when a function without EXPECT\_CALL is called, even if I have set its behavior using ON\_CALL.  Would it be reasonable not to show the warning in this case? ##
-
-When choosing between being neat and being safe, we lean toward the
-latter.  So the answer is that we think it's better to show the
-warning.
-
-Often people write `ON_CALL`s in the mock object's
-constructor or `SetUp()`, as the default behavior rarely changes from
-test to test.  Then in the test body they set the expectations, which
-are often different for each test.  Having an `ON_CALL` in the set-up
-part of a test doesn't mean that the calls are expected.  If there's
-no `EXPECT_CALL` and the method is called, it's possibly an error.  If
-we quietly let the call go through without notifying the user, bugs
-may creep in unnoticed.
-
-If, however, you are sure that the calls are OK, you can write
-
-```
-EXPECT_CALL(foo, Bar(_))
-    .WillRepeatedly(...);
-```
-
-instead of
-
-```
-ON_CALL(foo, Bar(_))
-    .WillByDefault(...);
-```
-
-This tells Google Mock that you do expect the calls and no warning should be
-printed.
-
-Also, you can control the verbosity using the `--gmock_verbose` flag.
-If you find the output too noisy when debugging, just choose a less
-verbose level.
-
-## How can I delete the mock function's argument in an action? ##
-
-If you find yourself needing to perform some action that's not
-supported by Google Mock directly, remember that you can define your own
-actions using
-[MakeAction()](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Writing_New_Actions) or
-[MakePolymorphicAction()](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Writing_New_Polymorphic_Actions),
-or you can write a stub function and invoke it using
-[Invoke()](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Using_Functions_Methods_Functors).
-
-## MOCK\_METHODn()'s second argument looks funny.  Why don't you use the MOCK\_METHODn(Method, return\_type, arg\_1, ..., arg\_n) syntax? ##
-
-What?!  I think it's beautiful. :-)
-
-While which syntax looks more natural is a subjective matter to some
-extent, Google Mock's syntax was chosen for several practical advantages it
-has.
-
-Try to mock a function that takes a map as an argument:
-```
-virtual int GetSize(const map<int, std::string>& m);
-```
-
-Using the proposed syntax, it would be:
-```
-MOCK_METHOD1(GetSize, int, const map<int, std::string>& m);
-```
-
-Guess what?  You'll get a compiler error as the compiler thinks that
-`const map<int, std::string>& m` are **two**, not one, arguments. To work
-around this you can use `typedef` to give the map type a name, but
-that gets in the way of your work.  Google Mock's syntax avoids this
-problem as the function's argument types are protected inside a pair
-of parentheses:
-```
-// This compiles fine.
-MOCK_METHOD1(GetSize, int(const map<int, std::string>& m));
-```
-
-You still need a `typedef` if the return type contains an unprotected
-comma, but that's much rarer.
-
-Other advantages include:
-  1. `MOCK_METHOD1(Foo, int, bool)` can leave a reader wonder whether the method returns `int` or `bool`, while there won't be such confusion using Google Mock's syntax.
-  1. The way Google Mock describes a function type is nothing new, although many people may not be familiar with it.  The same syntax was used in C, and the `function` library in `tr1` uses this syntax extensively.  Since `tr1` will become a part of the new version of STL, we feel very comfortable to be consistent with it.
-  1. The function type syntax is also used in other parts of Google Mock's API (e.g. the action interface) in order to make the implementation tractable. A user needs to learn it anyway in order to utilize Google Mock's more advanced features.  We'd as well stick to the same syntax in `MOCK_METHOD*`!
-
-## My code calls a static/global function.  Can I mock it? ##
-
-You can, but you need to make some changes.
-
-In general, if you find yourself needing to mock a static function,
-it's a sign that your modules are too tightly coupled (and less
-flexible, less reusable, less testable, etc).  You are probably better
-off defining a small interface and call the function through that
-interface, which then can be easily mocked.  It's a bit of work
-initially, but usually pays for itself quickly.
-
-This Google Testing Blog
-[post](http://googletesting.blogspot.com/2008/06/defeat-static-cling.html)
-says it excellently.  Check it out.
-
-## My mock object needs to do complex stuff.  It's a lot of pain to specify the actions.  Google Mock sucks! ##
-
-I know it's not a question, but you get an answer for free any way. :-)
-
-With Google Mock, you can create mocks in C++ easily.  And people might be
-tempted to use them everywhere. Sometimes they work great, and
-sometimes you may find them, well, a pain to use. So, what's wrong in
-the latter case?
-
-When you write a test without using mocks, you exercise the code and
-assert that it returns the correct value or that the system is in an
-expected state.  This is sometimes called "state-based testing".
-
-Mocks are great for what some call "interaction-based" testing:
-instead of checking the system state at the very end, mock objects
-verify that they are invoked the right way and report an error as soon
-as it arises, giving you a handle on the precise context in which the
-error was triggered.  This is often more effective and economical to
-do than state-based testing.
-
-If you are doing state-based testing and using a test double just to
-simulate the real object, you are probably better off using a fake.
-Using a mock in this case causes pain, as it's not a strong point for
-mocks to perform complex actions.  If you experience this and think
-that mocks suck, you are just not using the right tool for your
-problem. Or, you might be trying to solve the wrong problem. :-)
-
-## I got a warning "Uninteresting function call encountered - default action taken.."  Should I panic? ##
-
-By all means, NO!  It's just an FYI.
-
-What it means is that you have a mock function, you haven't set any
-expectations on it (by Google Mock's rule this means that you are not
-interested in calls to this function and therefore it can be called
-any number of times), and it is called.  That's OK - you didn't say
-it's not OK to call the function!
-
-What if you actually meant to disallow this function to be called, but
-forgot to write `EXPECT_CALL(foo, Bar()).Times(0)`?  While
-one can argue that it's the user's fault, Google Mock tries to be nice and
-prints you a note.
-
-So, when you see the message and believe that there shouldn't be any
-uninteresting calls, you should investigate what's going on.  To make
-your life easier, Google Mock prints the function name and arguments
-when an uninteresting call is encountered.
-
-## I want to define a custom action.  Should I use Invoke() or implement the action interface? ##
-
-Either way is fine - you want to choose the one that's more convenient
-for your circumstance.
-
-Usually, if your action is for a particular function type, defining it
-using `Invoke()` should be easier; if your action can be used in
-functions of different types (e.g. if you are defining
-`Return(value)`), `MakePolymorphicAction()` is
-easiest.  Sometimes you want precise control on what types of
-functions the action can be used in, and implementing
-`ActionInterface` is the way to go here. See the implementation of
-`Return()` in `include/gmock/gmock-actions.h` for an example.
-
-## I'm using the set-argument-pointee action, and the compiler complains about "conflicting return type specified".  What does it mean? ##
-
-You got this error as Google Mock has no idea what value it should return
-when the mock method is called.  `SetArgPointee()` says what the
-side effect is, but doesn't say what the return value should be.  You
-need `DoAll()` to chain a `SetArgPointee()` with a `Return()`.
-
-See this [recipe](http://code.google.com/p/googlemock/wiki/V1_7_CookBook#Mocking_Side_Effects) for more details and an example.
-
-
-## My question is not in your FAQ! ##
-
-If you cannot find the answer to your question in this FAQ, there are
-some other resources you can use:
-
-  1. read other [wiki pages](http://code.google.com/p/googlemock/w/list),
-  1. search the mailing list [archive](http://groups.google.com/group/googlemock/topics),
-  1. ask it on [googlemock@googlegroups.com](mailto:googlemock@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googlemock) before you can post.).
-
-Please note that creating an issue in the
-[issue tracker](http://code.google.com/p/googlemock/issues/list) is _not_
-a good way to get your answer, as it is monitored infrequently by a
-very small number of people.
-
-When asking a question, it's helpful to provide as much of the
-following information as possible (people cannot help you if there's
-not enough information in your question):
-
-  * the version (or the revision number if you check out from SVN directly) of Google Mock you use (Google Mock is under active development, so it's possible that your problem has been solved in a later version),
-  * your operating system,
-  * the name and version of your compiler,
-  * the complete command line flags you give to your compiler,
-  * the complete compiler error messages (if the question is about compilation),
-  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-actions.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-actions.h
deleted file mode 100644
index b3f654af..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-actions.h
+++ /dev/null
@@ -1,1205 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some commonly used actions.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
-
-#ifndef _WIN32_WCE
-# include <errno.h>
-#endif
-
-#include <algorithm>
-#include <string>
-
-#include "gmock/internal/gmock-internal-utils.h"
-#include "gmock/internal/gmock-port.h"
-
-#if GTEST_HAS_STD_TYPE_TRAITS_  // Defined by gtest-port.h via gmock-port.h.
-#include <type_traits>
-#endif
-
-namespace testing {
-
-// To implement an action Foo, define:
-//   1. a class FooAction that implements the ActionInterface interface, and
-//   2. a factory function that creates an Action object from a
-//      const FooAction*.
-//
-// The two-level delegation design follows that of Matcher, providing
-// consistency for extension developers.  It also eases ownership
-// management as Action objects can now be copied like plain values.
-
-namespace internal {
-
-template <typename F1, typename F2>
-class ActionAdaptor;
-
-// BuiltInDefaultValueGetter<T, true>::Get() returns a
-// default-constructed T value.  BuiltInDefaultValueGetter<T,
-// false>::Get() crashes with an error.
-//
-// This primary template is used when kDefaultConstructible is true.
-template <typename T, bool kDefaultConstructible>
-struct BuiltInDefaultValueGetter {
-  static T Get() { return T(); }
-};
-template <typename T>
-struct BuiltInDefaultValueGetter<T, false> {
-  static T Get() {
-    Assert(false, __FILE__, __LINE__,
-           "Default action undefined for the function return type.");
-    return internal::Invalid<T>();
-    // The above statement will never be reached, but is required in
-    // order for this function to compile.
-  }
-};
-
-// BuiltInDefaultValue<T>::Get() returns the "built-in" default value
-// for type T, which is NULL when T is a raw pointer type, 0 when T is
-// a numeric type, false when T is bool, or "" when T is string or
-// std::string.  In addition, in C++11 and above, it turns a
-// default-constructed T value if T is default constructible.  For any
-// other type T, the built-in default T value is undefined, and the
-// function will abort the process.
-template <typename T>
-class BuiltInDefaultValue {
- public:
-#if GTEST_HAS_STD_TYPE_TRAITS_
-  // This function returns true iff type T has a built-in default value.
-  static bool Exists() {
-    return ::std::is_default_constructible<T>::value;
-  }
-
-  static T Get() {
-    return BuiltInDefaultValueGetter<
-        T, ::std::is_default_constructible<T>::value>::Get();
-  }
-
-#else  // GTEST_HAS_STD_TYPE_TRAITS_
-  // This function returns true iff type T has a built-in default value.
-  static bool Exists() {
-    return false;
-  }
-
-  static T Get() {
-    return BuiltInDefaultValueGetter<T, false>::Get();
-  }
-
-#endif  // GTEST_HAS_STD_TYPE_TRAITS_
-};
-
-// This partial specialization says that we use the same built-in
-// default value for T and const T.
-template <typename T>
-class BuiltInDefaultValue<const T> {
- public:
-  static bool Exists() { return BuiltInDefaultValue<T>::Exists(); }
-  static T Get() { return BuiltInDefaultValue<T>::Get(); }
-};
-
-// This partial specialization defines the default values for pointer
-// types.
-template <typename T>
-class BuiltInDefaultValue<T*> {
- public:
-  static bool Exists() { return true; }
-  static T* Get() { return NULL; }
-};
-
-// The following specializations define the default values for
-// specific types we care about.
-#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
-  template <> \
-  class BuiltInDefaultValue<type> { \
-   public: \
-    static bool Exists() { return true; } \
-    static type Get() { return value; } \
-  }
-
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, );  // NOLINT
-#if GTEST_HAS_GLOBAL_STRING
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::string, "");
-#endif  // GTEST_HAS_GLOBAL_STRING
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, "");
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false);
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0');
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0');
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0');
-
-// There's no need for a default action for signed wchar_t, as that
-// type is the same as wchar_t for gcc, and invalid for MSVC.
-//
-// There's also no need for a default action for unsigned wchar_t, as
-// that type is the same as unsigned int for gcc, and invalid for
-// MSVC.
-#if GMOCK_WCHAR_T_IS_NATIVE_
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U);  // NOLINT
-#endif
-
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U);  // NOLINT
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0);     // NOLINT
-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_(UInt64, 0);
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(Int64, 0);
-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_
-
-}  // namespace internal
-
-// When an unexpected function call is encountered, Google Mock will
-// let it return a default value if the user has specified one for its
-// return type, or if the return type has a built-in default value;
-// otherwise Google Mock won't know what value to return and will have
-// to abort the process.
-//
-// The DefaultValue<T> class allows a user to specify the
-// default value for a type T that is both copyable and publicly
-// destructible (i.e. anything that can be used as a function return
-// type).  The usage is:
-//
-//   // Sets the default value for type T to be foo.
-//   DefaultValue<T>::Set(foo);
-template <typename T>
-class DefaultValue {
- public:
-  // Sets the default value for type T; requires T to be
-  // copy-constructable and have a public destructor.
-  static void Set(T x) {
-    delete producer_;
-    producer_ = new FixedValueProducer(x);
-  }
-
-  // Provides a factory function to be called to generate the default value.
-  // This method can be used even if T is only move-constructible, but it is not
-  // limited to that case.
-  typedef T (*FactoryFunction)();
-  static void SetFactory(FactoryFunction factory) {
-    delete producer_;
-    producer_ = new FactoryValueProducer(factory);
-  }
-
-  // Unsets the default value for type T.
-  static void Clear() {
-    delete producer_;
-    producer_ = NULL;
-  }
-
-  // Returns true iff the user has set the default value for type T.
-  static bool IsSet() { return producer_ != NULL; }
-
-  // Returns true if T has a default return value set by the user or there
-  // exists a built-in default value.
-  static bool Exists() {
-    return IsSet() || internal::BuiltInDefaultValue<T>::Exists();
-  }
-
-  // Returns the default value for type T if the user has set one;
-  // 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_ == NULL ?
-        internal::BuiltInDefaultValue<T>::Get() : producer_->Produce();
-  }
-
- private:
-  class ValueProducer {
-   public:
-    virtual ~ValueProducer() {}
-    virtual T Produce() = 0;
-  };
-
-  class FixedValueProducer : public ValueProducer {
-   public:
-    explicit FixedValueProducer(T value) : value_(value) {}
-    virtual T Produce() { return value_; }
-
-   private:
-    const T value_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer);
-  };
-
-  class FactoryValueProducer : public ValueProducer {
-   public:
-    explicit FactoryValueProducer(FactoryFunction factory)
-        : factory_(factory) {}
-    virtual T Produce() { return factory_(); }
-
-   private:
-    const FactoryFunction factory_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer);
-  };
-
-  static ValueProducer* producer_;
-};
-
-// This partial specialization allows a user to set default values for
-// reference types.
-template <typename T>
-class DefaultValue<T&> {
- public:
-  // Sets the default value for type T&.
-  static void Set(T& x) {  // NOLINT
-    address_ = &x;
-  }
-
-  // Unsets the default value for type T&.
-  static void Clear() {
-    address_ = NULL;
-  }
-
-  // Returns true iff the user has set the default value for type T&.
-  static bool IsSet() { return address_ != NULL; }
-
-  // Returns true if T has a default return value set by the user or there
-  // exists a built-in default value.
-  static bool Exists() {
-    return IsSet() || internal::BuiltInDefaultValue<T&>::Exists();
-  }
-
-  // Returns the default value for type T& if the user has set one;
-  // otherwise returns the built-in default value if there is one;
-  // otherwise aborts the process.
-  static T& Get() {
-    return address_ == NULL ?
-        internal::BuiltInDefaultValue<T&>::Get() : *address_;
-  }
-
- private:
-  static T* address_;
-};
-
-// This specialization allows DefaultValue<void>::Get() to
-// compile.
-template <>
-class DefaultValue<void> {
- public:
-  static bool Exists() { return true; }
-  static void Get() {}
-};
-
-// Points to the user-set default value for type T.
-template <typename T>
-typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = NULL;
-
-// Points to the user-set default value for type T&.
-template <typename T>
-T* DefaultValue<T&>::address_ = NULL;
-
-// Implement this interface to define an action for function type F.
-template <typename F>
-class ActionInterface {
- public:
-  typedef typename internal::Function<F>::Result Result;
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  ActionInterface() {}
-  virtual ~ActionInterface() {}
-
-  // Performs the action.  This method is not const, as in general an
-  // action can have side effects and be stateful.  For example, a
-  // get-the-next-element-from-the-collection action will need to
-  // remember the current element.
-  virtual Result Perform(const ArgumentTuple& args) = 0;
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(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
-// linked_ptr to const ActionInterface<T>, so copying is fairly cheap.
-// 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 {
- 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() : impl_(NULL) {}
-
-  // Constructs an Action from its implementation.  A NULL impl is
-  // used to represent the "do-default" action.
-  explicit Action(ActionInterface<F>* impl) : impl_(impl) {}
-
-  // Copy constructor.
-  Action(const Action& action) : impl_(action.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.
-  template <typename Func>
-  explicit Action(const Action<Func>& action);
-
-  // Returns true iff this is the DoDefault() action.
-  bool IsDoDefault() const { return impl_.get() == NULL; }
-
-  // Performs the action.  Note that this method is const even though
-  // the corresponding method in ActionInterface is not.  The reason
-  // is that a const Action<F> means that it cannot be re-bound to
-  // 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(const ArgumentTuple& args) const {
-    internal::Assert(
-        !IsDoDefault(), __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.");
-    return impl_->Perform(args);
-  }
-
- private:
-  template <typename F1, typename F2>
-  friend class internal::ActionAdaptor;
-
-  internal::linked_ptr<ActionInterface<F> > impl_;
-};
-
-// The PolymorphicAction class template makes it easy to implement a
-// polymorphic action (i.e. an action that can be used in mock
-// functions of than one type, e.g. Return()).
-//
-// To define a polymorphic action, a user first provides a COPYABLE
-// implementation class that has a Perform() method template:
-//
-//   class FooAction {
-//    public:
-//     template <typename Result, typename ArgumentTuple>
-//     Result Perform(const ArgumentTuple& args) const {
-//       // Processes the arguments and returns a result, using
-//       // tr1::get<N>(args) to get the N-th (0-based) argument in the tuple.
-//     }
-//     ...
-//   };
-//
-// Then the user creates the polymorphic action using
-// MakePolymorphicAction(object) where object has type FooAction.  See
-// the definition of Return(void) and SetArgumentPointee<N>(value) for
-// complete examples.
-template <typename Impl>
-class PolymorphicAction {
- public:
-  explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}
-
-  template <typename F>
-  operator Action<F>() const {
-    return Action<F>(new MonomorphicImpl<F>(impl_));
-  }
-
- private:
-  template <typename F>
-  class MonomorphicImpl : public ActionInterface<F> {
-   public:
-    typedef typename internal::Function<F>::Result Result;
-    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
-
-    virtual Result Perform(const ArgumentTuple& args) {
-      return impl_.template Perform<Result>(args);
-    }
-
-   private:
-    Impl impl_;
-
-    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
-  };
-
-  Impl impl_;
-
-  GTEST_DISALLOW_ASSIGN_(PolymorphicAction);
-};
-
-// Creates an Action from its implementation and returns it.  The
-// created Action object owns the implementation.
-template <typename F>
-Action<F> MakeAction(ActionInterface<F>* impl) {
-  return Action<F>(impl);
-}
-
-// Creates a polymorphic action from its implementation.  This is
-// easier to use than the PolymorphicAction<Impl> constructor as it
-// doesn't require you to explicitly write the template argument, e.g.
-//
-//   MakePolymorphicAction(foo);
-// vs
-//   PolymorphicAction<TypeOfFoo>(foo);
-template <typename Impl>
-inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) {
-  return PolymorphicAction<Impl>(impl);
-}
-
-namespace internal {
-
-// Allows an Action<F2> object to pose as an Action<F1>, as long as F2
-// and F1 are compatible.
-template <typename F1, typename F2>
-class ActionAdaptor : public ActionInterface<F1> {
- public:
-  typedef typename internal::Function<F1>::Result Result;
-  typedef typename internal::Function<F1>::ArgumentTuple ArgumentTuple;
-
-  explicit ActionAdaptor(const Action<F2>& from) : impl_(from.impl_) {}
-
-  virtual Result Perform(const ArgumentTuple& args) {
-    return impl_->Perform(args);
-  }
-
- private:
-  const internal::linked_ptr<ActionInterface<F2> > impl_;
-
-  GTEST_DISALLOW_ASSIGN_(ActionAdaptor);
-};
-
-// Helper struct to specialize ReturnAction to execute a move instead of a copy
-// on return. Useful for move-only types, but could be used on any type.
-template <typename T>
-struct ByMoveWrapper {
-  explicit ByMoveWrapper(T value) : payload(internal::move(value)) {}
-  T payload;
-};
-
-// Implements the polymorphic Return(x) action, which can be used in
-// any function that returns the type of x, regardless of the argument
-// types.
-//
-// Note: The value passed into Return must be converted into
-// Function<F>::Result when this action is cast to Action<F> rather than
-// when that action is performed. This is important in scenarios like
-//
-// MOCK_METHOD1(Method, T(U));
-// ...
-// {
-//   Foo foo;
-//   X x(&foo);
-//   EXPECT_CALL(mock, Method(_)).WillOnce(Return(x));
-// }
-//
-// In the example above the variable x holds reference to foo which leaves
-// scope and gets destroyed.  If copying X just copies a reference to foo,
-// that copy will be left with a hanging reference.  If conversion to T
-// makes a copy of foo, the above code is safe. To support that scenario, we
-// need to make sure that the type conversion happens inside the EXPECT_CALL
-// statement, and conversion of the result of Return to Action<T(U)> is a
-// good place for that.
-//
-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(internal::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 {
-    // Assert statement belongs here because this is the best place to verify
-    // conditions on F. It produces the clearest error messages
-    // in most compilers.
-    // Impl really belongs in this scope as a local class but can't
-    // because MSVC produces duplicate symbols in different translation units
-    // in this case. Until MS fixes that bug we put Impl into the class scope
-    // and put the typedef both here (for use in assert statement) and
-    // in the Impl class. But both definitions must be the same.
-    typedef typename Function<F>::Result Result;
-    GTEST_COMPILE_ASSERT_(
-        !is_reference<Result>::value,
-        use_ReturnRef_instead_of_Return_to_return_a_reference);
-    return Action<F>(new Impl<R, F>(value_));
-  }
-
- private:
-  // Implements the Return(x) action for a particular function type F.
-  template <typename R_, typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-
-    // The implicit cast is necessary when Result has more than one
-    // single-argument constructor (e.g. Result is std::vector<int>) and R
-    // has a type conversion operator template.  In that case, value_(value)
-    // won't compile as the compiler doesn't known which constructor of
-    // 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 linked_ptr<R>& value)
-        : value_before_cast_(*value),
-          value_(ImplicitCast_<Result>(value_before_cast_)) {}
-
-    virtual Result Perform(const ArgumentTuple&) { return value_; }
-
-   private:
-    GTEST_COMPILE_ASSERT_(!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.
-    R value_before_cast_;
-    Result value_;
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
-  };
-
-  // Partially specialize for ByMoveWrapper. This version of ReturnAction will
-  // move its contents instead.
-  template <typename R_, typename F>
-  class Impl<ByMoveWrapper<R_>, F> : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit Impl(const linked_ptr<R>& wrapper)
-        : performed_(false), wrapper_(wrapper) {}
-
-    virtual Result Perform(const ArgumentTuple&) {
-      GTEST_CHECK_(!performed_)
-          << "A ByMove() action should only be performed once.";
-      performed_ = true;
-      return internal::move(wrapper_->payload);
-    }
-
-   private:
-    bool performed_;
-    const linked_ptr<R> wrapper_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  const linked_ptr<R> value_;
-
-  GTEST_DISALLOW_ASSIGN_(ReturnAction);
-};
-
-// Implements the ReturnNull() action.
-class ReturnNullAction {
- public:
-  // Allows ReturnNull() to be used in any pointer-returning function. In C++11
-  // this is enforced by returning nullptr, and in non-C++11 by asserting a
-  // pointer type on compile time.
-  template <typename Result, typename ArgumentTuple>
-  static Result Perform(const ArgumentTuple&) {
-#if GTEST_LANG_CXX11
-    return nullptr;
-#else
-    GTEST_COMPILE_ASSERT_(internal::is_pointer<Result>::value,
-                          ReturnNull_can_be_used_to_return_a_pointer_only);
-    return NULL;
-#endif  // GTEST_LANG_CXX11
-  }
-};
-
-// Implements the Return() action.
-class ReturnVoidAction {
- public:
-  // Allows Return() to be used in any void-returning function.
-  template <typename Result, typename ArgumentTuple>
-  static void Perform(const ArgumentTuple&) {
-    CompileAssertTypesEqual<void, Result>();
-  }
-};
-
-// Implements the polymorphic ReturnRef(x) action, which can be used
-// in any function that returns a reference to the type of x,
-// regardless of the argument types.
-template <typename T>
-class ReturnRefAction {
- public:
-  // Constructs a ReturnRefAction object from the reference to be returned.
-  explicit ReturnRefAction(T& ref) : ref_(ref) {}  // NOLINT
-
-  // This template type conversion operator allows ReturnRef(x) to be
-  // used in ANY function that returns a reference to x's type.
-  template <typename F>
-  operator Action<F>() const {
-    typedef typename Function<F>::Result Result;
-    // 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_(internal::is_reference<Result>::value,
-                          use_Return_instead_of_ReturnRef_to_return_a_value);
-    return Action<F>(new Impl<F>(ref_));
-  }
-
- private:
-  // Implements the ReturnRef(x) action for a particular function type F.
-  template <typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit Impl(T& ref) : ref_(ref) {}  // NOLINT
-
-    virtual Result Perform(const ArgumentTuple&) {
-      return ref_;
-    }
-
-   private:
-    T& ref_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  T& ref_;
-
-  GTEST_DISALLOW_ASSIGN_(ReturnRefAction);
-};
-
-// Implements the polymorphic ReturnRefOfCopy(x) action, which can be
-// used in any function that returns a reference to the type of x,
-// regardless of the argument types.
-template <typename T>
-class ReturnRefOfCopyAction {
- public:
-  // Constructs a ReturnRefOfCopyAction object from the reference to
-  // be returned.
-  explicit ReturnRefOfCopyAction(const T& value) : value_(value) {}  // NOLINT
-
-  // This template type conversion operator allows ReturnRefOfCopy(x) to be
-  // used in ANY function that returns a reference to x's type.
-  template <typename F>
-  operator Action<F>() const {
-    typedef typename Function<F>::Result Result;
-    // Asserts that the function return type is a reference.  This
-    // catches the user error of using ReturnRefOfCopy(x) when Return(x)
-    // should be used, and generates some helpful error message.
-    GTEST_COMPILE_ASSERT_(
-        internal::is_reference<Result>::value,
-        use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
-    return Action<F>(new Impl<F>(value_));
-  }
-
- private:
-  // Implements the ReturnRefOfCopy(x) action for a particular function type F.
-  template <typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit Impl(const T& value) : value_(value) {}  // NOLINT
-
-    virtual Result Perform(const ArgumentTuple&) {
-      return value_;
-    }
-
-   private:
-    T value_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  const T value_;
-
-  GTEST_DISALLOW_ASSIGN_(ReturnRefOfCopyAction);
-};
-
-// Implements the polymorphic DoDefault() action.
-class DoDefaultAction {
- public:
-  // This template type conversion operator allows DoDefault() to be
-  // used in any function.
-  template <typename F>
-  operator Action<F>() const { return Action<F>(NULL); }
-};
-
-// Implements the Assign action to set a given pointer referent to a
-// particular value.
-template <typename T1, typename T2>
-class AssignAction {
- public:
-  AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}
-
-  template <typename Result, typename ArgumentTuple>
-  void Perform(const ArgumentTuple& /* args */) const {
-    *ptr_ = value_;
-  }
-
- private:
-  T1* const ptr_;
-  const T2 value_;
-
-  GTEST_DISALLOW_ASSIGN_(AssignAction);
-};
-
-#if !GTEST_OS_WINDOWS_MOBILE
-
-// Implements the SetErrnoAndReturn action to simulate return from
-// various system calls and libc functions.
-template <typename T>
-class SetErrnoAndReturnAction {
- public:
-  SetErrnoAndReturnAction(int errno_value, T result)
-      : errno_(errno_value),
-        result_(result) {}
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& /* args */) const {
-    errno = errno_;
-    return result_;
-  }
-
- private:
-  const int errno_;
-  const T result_;
-
-  GTEST_DISALLOW_ASSIGN_(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.  The
-// template parameter kIsProto is true iff type A is ProtocolMessage,
-// proto2::Message, or a sub-class of those.
-template <size_t N, typename A, bool kIsProto>
-class SetArgumentPointeeAction {
- public:
-  // Constructs an action that sets the variable pointed to by the
-  // N-th function argument to 'value'.
-  explicit SetArgumentPointeeAction(const A& value) : value_(value) {}
-
-  template <typename Result, typename ArgumentTuple>
-  void Perform(const ArgumentTuple& args) const {
-    CompileAssertTypesEqual<void, Result>();
-    *::testing::get<N>(args) = value_;
-  }
-
- private:
-  const A value_;
-
-  GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
-};
-
-template <size_t N, typename Proto>
-class SetArgumentPointeeAction<N, Proto, true> {
- public:
-  // Constructs an action that sets the variable pointed to by the
-  // N-th function argument to 'proto'.  Both ProtocolMessage and
-  // proto2::Message have the CopyFrom() method, so the same
-  // implementation works for both.
-  explicit SetArgumentPointeeAction(const Proto& proto) : proto_(new Proto) {
-    proto_->CopyFrom(proto);
-  }
-
-  template <typename Result, typename ArgumentTuple>
-  void Perform(const ArgumentTuple& args) const {
-    CompileAssertTypesEqual<void, Result>();
-    ::testing::get<N>(args)->CopyFrom(*proto_);
-  }
-
- private:
-  const internal::linked_ptr<Proto> proto_;
-
-  GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
-};
-
-// 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 (i.e. f can be
-// assigned to a tr1::function<F>).
-template <typename FunctionImpl>
-class InvokeWithoutArgsAction {
- public:
-  // The c'tor makes a copy of function_impl (either a function
-  // pointer or a functor).
-  explicit InvokeWithoutArgsAction(FunctionImpl function_impl)
-      : function_impl_(function_impl) {}
-
-  // Allows InvokeWithoutArgs(f) to be used as any action whose type is
-  // compatible with f.
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple&) { return function_impl_(); }
-
- private:
-  FunctionImpl function_impl_;
-
-  GTEST_DISALLOW_ASSIGN_(InvokeWithoutArgsAction);
-};
-
-// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
-template <class Class, typename MethodPtr>
-class InvokeMethodWithoutArgsAction {
- public:
-  InvokeMethodWithoutArgsAction(Class* obj_ptr, MethodPtr method_ptr)
-      : obj_ptr_(obj_ptr), method_ptr_(method_ptr) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple&) const {
-    return (obj_ptr_->*method_ptr_)();
-  }
-
- private:
-  Class* const obj_ptr_;
-  const MethodPtr method_ptr_;
-
-  GTEST_DISALLOW_ASSIGN_(InvokeMethodWithoutArgsAction);
-};
-
-// Implements the IgnoreResult(action) action.
-template <typename A>
-class IgnoreResultAction {
- public:
-  explicit IgnoreResultAction(const A& action) : action_(action) {}
-
-  template <typename F>
-  operator Action<F>() const {
-    // Assert statement belongs here because this is the best place to verify
-    // conditions on F. It produces the clearest error messages
-    // in most compilers.
-    // Impl really belongs in this scope as a local class but can't
-    // because MSVC produces duplicate symbols in different translation units
-    // in this case. Until MS fixes that bug we put Impl into the class scope
-    // and put the typedef both here (for use in assert statement) and
-    // in the Impl class. But both definitions must be the same.
-    typedef typename internal::Function<F>::Result Result;
-
-    // Asserts at compile time that F returns void.
-    CompileAssertTypesEqual<void, Result>();
-
-    return Action<F>(new Impl<F>(action_));
-  }
-
- private:
-  template <typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename internal::Function<F>::Result Result;
-    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit Impl(const A& action) : action_(action) {}
-
-    virtual void Perform(const ArgumentTuple& args) {
-      // Performs the action and ignores its result.
-      action_.Perform(args);
-    }
-
-   private:
-    // Type OriginalFunction is the same as F except that its return
-    // type is IgnoredValue.
-    typedef typename internal::Function<F>::MakeResultIgnoredValue
-        OriginalFunction;
-
-    const Action<OriginalFunction> action_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  const A action_;
-
-  GTEST_DISALLOW_ASSIGN_(IgnoreResultAction);
-};
-
-// A ReferenceWrapper<T> object represents a reference to type T,
-// which can be either const or not.  It can be explicitly converted
-// from, and implicitly converted to, a T&.  Unlike a reference,
-// ReferenceWrapper<T> can be copied and can survive template type
-// inference.  This is used to support by-reference arguments in the
-// InvokeArgument<N>(...) action.  The idea was from "reference
-// wrappers" in tr1, which we don't have in our source tree yet.
-template <typename T>
-class ReferenceWrapper {
- public:
-  // Constructs a ReferenceWrapper<T> object from a T&.
-  explicit ReferenceWrapper(T& l_value) : pointer_(&l_value) {}  // NOLINT
-
-  // Allows a ReferenceWrapper<T> object to be implicitly converted to
-  // a T&.
-  operator T&() const { return *pointer_; }
- private:
-  T* pointer_;
-};
-
-// Allows the expression ByRef(x) to be printed as a reference to x.
-template <typename T>
-void PrintTo(const ReferenceWrapper<T>& ref, ::std::ostream* os) {
-  T& value = ref;
-  UniversalPrinter<T&>::Print(value, os);
-}
-
-// Does two actions sequentially.  Used for implementing the DoAll(a1,
-// a2, ...) action.
-template <typename Action1, typename Action2>
-class DoBothAction {
- public:
-  DoBothAction(Action1 action1, Action2 action2)
-      : action1_(action1), action2_(action2) {}
-
-  // This template type conversion operator allows DoAll(a1, ..., a_n)
-  // to be used in ANY function of compatible type.
-  template <typename F>
-  operator Action<F>() const {
-    return Action<F>(new Impl<F>(action1_, action2_));
-  }
-
- private:
-  // Implements the DoAll(...) action for a particular function type F.
-  template <typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-    typedef typename Function<F>::MakeResultVoid VoidResult;
-
-    Impl(const Action<VoidResult>& action1, const Action<F>& action2)
-        : action1_(action1), action2_(action2) {}
-
-    virtual Result Perform(const ArgumentTuple& args) {
-      action1_.Perform(args);
-      return action2_.Perform(args);
-    }
-
-   private:
-    const Action<VoidResult> action1_;
-    const Action<F> action2_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  Action1 action1_;
-  Action2 action2_;
-
-  GTEST_DISALLOW_ASSIGN_(DoBothAction);
-};
-
-}  // namespace internal
-
-// An Unused object can be implicitly constructed from ANY value.
-// This is handy when defining actions that ignore some or all of the
-// mock function arguments.  For example, given
-//
-//   MOCK_METHOD3(Foo, double(const string& label, double x, double y));
-//   MOCK_METHOD3(Bar, double(int index, double x, double y));
-//
-// instead of
-//
-//   double DistanceToOriginWithLabel(const string& label, double x, double y) {
-//     return sqrt(x*x + y*y);
-//   }
-//   double DistanceToOriginWithIndex(int index, double x, double y) {
-//     return sqrt(x*x + y*y);
-//   }
-//   ...
-//   EXEPCT_CALL(mock, Foo("abc", _, _))
-//       .WillOnce(Invoke(DistanceToOriginWithLabel));
-//   EXEPCT_CALL(mock, Bar(5, _, _))
-//       .WillOnce(Invoke(DistanceToOriginWithIndex));
-//
-// you could write
-//
-//   // We can declare any uninteresting argument as Unused.
-//   double DistanceToOrigin(Unused, double x, double y) {
-//     return sqrt(x*x + y*y);
-//   }
-//   ...
-//   EXEPCT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
-//   EXEPCT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
-typedef internal::IgnoredValue Unused;
-
-// This constructor allows us to turn an Action<From> object into an
-// Action<To>, as long as To's arguments can be implicitly converted
-// to From's and From's return type cann be implicitly converted to
-// To's.
-template <typename To>
-template <typename From>
-Action<To>::Action(const Action<From>& from)
-    : impl_(new internal::ActionAdaptor<To, From>(from)) {}
-
-// 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>(internal::move(value));
-}
-
-// Creates an action that returns NULL.
-inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
-  return MakePolymorphicAction(internal::ReturnNullAction());
-}
-
-// Creates an action that returns from a void function.
-inline PolymorphicAction<internal::ReturnVoidAction> Return() {
-  return MakePolymorphicAction(internal::ReturnVoidAction());
-}
-
-// Creates an action that returns the reference to a variable.
-template <typename R>
-inline internal::ReturnRefAction<R> ReturnRef(R& x) {  // NOLINT
-  return internal::ReturnRefAction<R>(x);
-}
-
-// 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.
-template <typename R>
-inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) {
-  return internal::ReturnRefOfCopyAction<R>(x);
-}
-
-// Modifies the parent action (a Return() action) to perform a move of the
-// argument instead of a copy.
-// Return(ByMove()) actions can only be executed once and will assert this
-// invariant.
-template <typename R>
-internal::ByMoveWrapper<R> ByMove(R x) {
-  return internal::ByMoveWrapper<R>(internal::move(x));
-}
-
-// Creates an action that does the default action for the give mock function.
-inline internal::DoDefaultAction DoDefault() {
-  return internal::DoDefaultAction();
-}
-
-// Creates an action that sets the variable pointed by the N-th
-// (0-based) function argument to 'value'.
-template <size_t N, typename T>
-PolymorphicAction<
-  internal::SetArgumentPointeeAction<
-    N, T, internal::IsAProtocolMessage<T>::value> >
-SetArgPointee(const T& x) {
-  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
-      N, T, internal::IsAProtocolMessage<T>::value>(x));
-}
-
-#if !((GTEST_GCC_VER_ && GTEST_GCC_VER_ < 40000) || GTEST_OS_SYMBIAN)
-// This overload allows SetArgPointee() to accept a string literal.
-// GCC prior to the version 4.0 and Symbian C++ compiler cannot distinguish
-// this overload from the templated version and emit a compile error.
-template <size_t N>
-PolymorphicAction<
-  internal::SetArgumentPointeeAction<N, const char*, false> >
-SetArgPointee(const char* p) {
-  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
-      N, const char*, false>(p));
-}
-
-template <size_t N>
-PolymorphicAction<
-  internal::SetArgumentPointeeAction<N, const wchar_t*, false> >
-SetArgPointee(const wchar_t* p) {
-  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
-      N, const wchar_t*, false>(p));
-}
-#endif
-
-// The following version is DEPRECATED.
-template <size_t N, typename T>
-PolymorphicAction<
-  internal::SetArgumentPointeeAction<
-    N, T, internal::IsAProtocolMessage<T>::value> >
-SetArgumentPointee(const T& x) {
-  return MakePolymorphicAction(internal::SetArgumentPointeeAction<
-      N, T, internal::IsAProtocolMessage<T>::value>(x));
-}
-
-// Creates an action that sets a pointer referent to a given value.
-template <typename T1, typename T2>
-PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
-  return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
-}
-
-#if !GTEST_OS_WINDOWS_MOBILE
-
-// Creates an action that sets errno and returns the appropriate error.
-template <typename T>
-PolymorphicAction<internal::SetErrnoAndReturnAction<T> >
-SetErrnoAndReturn(int errval, T result) {
-  return MakePolymorphicAction(
-      internal::SetErrnoAndReturnAction<T>(errval, result));
-}
-
-#endif  // !GTEST_OS_WINDOWS_MOBILE
-
-// Various overloads for InvokeWithoutArgs().
-
-// Creates an action that invokes 'function_impl' with no argument.
-template <typename FunctionImpl>
-PolymorphicAction<internal::InvokeWithoutArgsAction<FunctionImpl> >
-InvokeWithoutArgs(FunctionImpl function_impl) {
-  return MakePolymorphicAction(
-      internal::InvokeWithoutArgsAction<FunctionImpl>(function_impl));
-}
-
-// Creates an action that invokes the given method on the given object
-// with no argument.
-template <class Class, typename MethodPtr>
-PolymorphicAction<internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> >
-InvokeWithoutArgs(Class* obj_ptr, MethodPtr method_ptr) {
-  return MakePolymorphicAction(
-      internal::InvokeMethodWithoutArgsAction<Class, MethodPtr>(
-          obj_ptr, method_ptr));
-}
-
-// Creates an action that performs an_action and throws away its
-// result.  In other words, it changes the return type of an_action to
-// void.  an_action MUST NOT return void, or the code won't compile.
-template <typename A>
-inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) {
-  return internal::IgnoreResultAction<A>(an_action);
-}
-
-// Creates a reference wrapper for the given L-value.  If necessary,
-// you can explicitly specify the type of the reference.  For example,
-// suppose 'derived' is an object of type Derived, ByRef(derived)
-// would wrap a Derived&.  If you want to wrap a const Base& instead,
-// where Base is a base class of Derived, just write:
-//
-//   ByRef<const Base>(derived)
-template <typename T>
-inline internal::ReferenceWrapper<T> ByRef(T& l_value) {  // NOLINT
-  return internal::ReferenceWrapper<T>(l_value);
-}
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-cardinalities.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-cardinalities.h
deleted file mode 100644
index fc315f92..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-cardinalities.h
+++ /dev/null
@@ -1,147 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// 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.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
-
-#include <limits.h>
-#include <ostream>  // NOLINT
-#include "gmock/internal/gmock-port.h"
-#include "gtest/gtest.h"
-
-namespace testing {
-
-// To implement a cardinality Foo, define:
-//   1. a class FooCardinality that implements the
-//      CardinalityInterface interface, and
-//   2. a factory function that creates a Cardinality object from a
-//      const FooCardinality*.
-//
-// The two-level delegation design follows that of Matcher, providing
-// consistency for extension developers.  It also eases ownership
-// management as Cardinality objects can now be copied like plain values.
-
-// The implementation of a cardinality.
-class CardinalityInterface {
- public:
-  virtual ~CardinalityInterface() {}
-
-  // Conservative estimate on the lower/upper bound of the number of
-  // calls allowed.
-  virtual int ConservativeLowerBound() const { return 0; }
-  virtual int ConservativeUpperBound() const { return INT_MAX; }
-
-  // Returns true iff call_count calls will satisfy this cardinality.
-  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
-
-  // Returns true iff call_count calls will saturate this cardinality.
-  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
-
-  // Describes self to an ostream.
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-};
-
-// 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 linked_ptr
-// to const CardinalityInterface, so copying is fairly cheap.
-// Don't inherit from Cardinality!
-class GTEST_API_ Cardinality {
- public:
-  // Constructs a null cardinality.  Needed for storing Cardinality
-  // objects in STL containers.
-  Cardinality() {}
-
-  // Constructs a Cardinality from its implementation.
-  explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}
-
-  // Conservative estimate on the lower/upper bound of the number of
-  // calls allowed.
-  int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); }
-  int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); }
-
-  // Returns true iff call_count calls will satisfy this cardinality.
-  bool IsSatisfiedByCallCount(int call_count) const {
-    return impl_->IsSatisfiedByCallCount(call_count);
-  }
-
-  // Returns true iff call_count calls will saturate this cardinality.
-  bool IsSaturatedByCallCount(int call_count) const {
-    return impl_->IsSaturatedByCallCount(call_count);
-  }
-
-  // Returns true iff 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) &&
-        !impl_->IsSatisfiedByCallCount(call_count);
-  }
-
-  // Describes self to an ostream
-  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
-
-  // Describes the given actual call count to an ostream.
-  static void DescribeActualCallCountTo(int actual_call_count,
-                                        ::std::ostream* os);
-
- private:
-  internal::linked_ptr<const CardinalityInterface> impl_;
-};
-
-// Creates a cardinality that allows at least n calls.
-GTEST_API_ Cardinality AtLeast(int n);
-
-// Creates a cardinality that allows at most n calls.
-GTEST_API_ Cardinality AtMost(int n);
-
-// Creates a cardinality that allows any number of calls.
-GTEST_API_ Cardinality AnyNumber();
-
-// Creates a cardinality that allows between min and max calls.
-GTEST_API_ Cardinality Between(int min, int max);
-
-// Creates a cardinality that allows exactly n calls.
-GTEST_API_ Cardinality Exactly(int n);
-
-// Creates a cardinality from its implementation.
-inline Cardinality MakeCardinality(const CardinalityInterface* c) {
-  return Cardinality(c);
-}
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h
deleted file mode 100644
index b5a889c0..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h
+++ /dev/null
@@ -1,2377 +0,0 @@
-// This file was GENERATED by a script.  DO NOT EDIT BY HAND!!!
-
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some commonly used variadic actions.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
-
-#include "gmock/gmock-actions.h"
-#include "gmock/internal/gmock-port.h"
-
-namespace testing {
-namespace internal {
-
-// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary
-// function or method with the unpacked values, where F is a function
-// type that takes N arguments.
-template <typename Result, typename ArgumentTuple>
-class InvokeHelper;
-
-template <typename R>
-class InvokeHelper<R, ::testing::tuple<> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<>&) {
-           return function();
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<>&) {
-           return (obj_ptr->*method_ptr)();
-  }
-};
-
-template <typename R, typename A1>
-class InvokeHelper<R, ::testing::tuple<A1> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1>& args) {
-           return function(get<0>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2>
-class InvokeHelper<R, ::testing::tuple<A1, A2> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2>& args) {
-           return function(get<0>(args), get<1>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
-      A4>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4,
-      A5>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args), get<4>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4, A5>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args), get<4>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
-      A6>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args), get<4>(args), get<5>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4, A5, A6>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args), get<4>(args), get<5>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
-      A6, A7>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args), get<4>(args), get<5>(args), get<6>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4, A5, A6,
-                            A7>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
-               get<6>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
-      A6, A7, A8>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
-               get<7>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7,
-                            A8>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
-               get<6>(args), get<7>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
-      A6, A7, A8, A9>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
-               get<7>(args), get<8>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
-                            A9>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
-               get<6>(args), get<7>(args), get<8>(args));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9,
-    typename A10>
-class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
-    A10> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
-      A6, A7, A8, A9, A10>& args) {
-           return function(get<0>(args), get<1>(args), get<2>(args),
-               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
-               get<7>(args), get<8>(args), get<9>(args));
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
-                            A9, A10>& args) {
-           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
-               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
-               get<6>(args), get<7>(args), get<8>(args), get<9>(args));
-  }
-};
-
-// An INTERNAL macro for extracting the type of a tuple field.  It's
-// subject to change without notice - DO NOT USE IN USER CODE!
-#define GMOCK_FIELD_(Tuple, N) \
-    typename ::testing::tuple_element<N, Tuple>::type
-
-// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the
-// type of an n-ary function whose i-th (1-based) argument type is the
-// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple
-// type, and whose return type is Result.  For example,
-//   SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type
-// is int(bool, long).
-//
-// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args)
-// returns the selected fields (k1, k2, ..., k_n) of args as a tuple.
-// For example,
-//   SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select(
-//       ::testing::make_tuple(true, 'a', 2.5))
-// returns tuple (2.5, true).
-//
-// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be
-// in the range [0, 10].  Duplicates are allowed and they don't have
-// to be in an ascending or descending order.
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4, int k5, int k6, int k7, int k8, int k9, int k10>
-class SelectArgs {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
-      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
-      GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9),
-      GMOCK_FIELD_(ArgumentTuple, k10));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
-        get<k8>(args), get<k9>(args), get<k10>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple>
-class SelectArgs<Result, ArgumentTuple,
-                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef Result type();
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& /* args */) {
-    return SelectedArgs();
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, -1, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, k4, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4, int k5>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, k4, k5, -1, -1, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args), get<k5>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4, int k5, int k6>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, k4, k5, k6, -1, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
-      GMOCK_FIELD_(ArgumentTuple, k6));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args), get<k5>(args), get<k6>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4, int k5, int k6, int k7>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, k4, k5, k6, k7, -1, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
-      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4, int k5, int k6, int k7, int k8>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, k4, k5, k6, k7, k8, -1, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
-      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
-      GMOCK_FIELD_(ArgumentTuple, k8));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
-        get<k8>(args));
-  }
-};
-
-template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
-    int k4, int k5, int k6, int k7, int k8, int k9>
-class SelectArgs<Result, ArgumentTuple,
-                 k1, k2, k3, k4, k5, k6, k7, k8, k9, -1> {
- public:
-  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
-      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
-      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
-      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
-      GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9));
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
-        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
-        get<k8>(args), get<k9>(args));
-  }
-};
-
-#undef GMOCK_FIELD_
-
-// Implements the WithArgs action.
-template <typename InnerAction, int k1 = -1, int k2 = -1, int k3 = -1,
-    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
-    int k9 = -1, int k10 = -1>
-class WithArgsAction {
- public:
-  explicit WithArgsAction(const InnerAction& action) : action_(action) {}
-
-  template <typename F>
-  operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
-
- private:
-  template <typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit Impl(const InnerAction& action) : action_(action) {}
-
-    virtual Result Perform(const ArgumentTuple& args) {
-      return action_.Perform(SelectArgs<Result, ArgumentTuple, k1, k2, k3, k4,
-          k5, k6, k7, k8, k9, k10>::Select(args));
-    }
-
-   private:
-    typedef typename SelectArgs<Result, ArgumentTuple,
-        k1, k2, k3, k4, k5, k6, k7, k8, k9, k10>::type InnerFunctionType;
-
-    Action<InnerFunctionType> action_;
-  };
-
-  const InnerAction action_;
-
-  GTEST_DISALLOW_ASSIGN_(WithArgsAction);
-};
-
-// A macro from the ACTION* family (defined later in this file)
-// 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 {};
-
-// A helper class needed for implementing the ACTION* macros.
-template <typename Result, class Impl>
-class ActionHelper {
- public:
-  static Result Perform(Impl* impl, const ::testing::tuple<>& args) {
-    return impl->template gmock_PerformImpl<>(args, ExcessiveArg(),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0>& args) {
-    return impl->template gmock_PerformImpl<A0>(args, get<0>(args),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1>& args) {
-    return impl->template gmock_PerformImpl<A0, A1>(args, get<0>(args),
-        get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2>(args, get<0>(args),
-        get<1>(args), get<2>(args), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
-      A3>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3>(args, get<0>(args),
-        get<1>(args), get<2>(args), get<3>(args), ExcessiveArg(),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3, typename A4>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3,
-      A4>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4>(args,
-        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
-        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3, typename A4,
-      typename A5>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
-      A5>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5>(args,
-        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
-        get<5>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3, typename A4,
-      typename A5, typename A6>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
-      A5, A6>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6>(args,
-        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
-        get<5>(args), get<6>(args), ExcessiveArg(), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3, typename A4,
-      typename A5, typename A6, typename A7>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
-      A5, A6, A7>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6,
-        A7>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
-        get<4>(args), get<5>(args), get<6>(args), get<7>(args), ExcessiveArg(),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3, typename A4,
-      typename A5, typename A6, typename A7, typename A8>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
-      A5, A6, A7, A8>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7,
-        A8>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
-        get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
-        ExcessiveArg());
-  }
-
-  template <typename A0, typename A1, typename A2, typename A3, typename A4,
-      typename A5, typename A6, typename A7, typename A8, typename A9>
-  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
-      A5, A6, A7, A8, A9>& args) {
-    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7, A8,
-        A9>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
-        get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
-        get<9>(args));
-  }
-};
-
-}  // namespace internal
-
-// Various overloads for Invoke().
-
-// 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.  C++ doesn't support default arguments for
-// function templates, so we have to overload it.
-template <int k1, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1>(action);
-}
-
-template <int k1, int k2, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2>(action);
-}
-
-template <int k1, int k2, int k3, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3>(action);
-}
-
-template <int k1, int k2, int k3, int k4, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>(action);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>(action);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
-    typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
-      k7>(action);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
-    typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
-      k8>(action);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
-    int k9, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
-      k9>(action);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
-    int k9, int k10, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
-    k9, k10>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
-      k9, k10>(action);
-}
-
-// Creates an action that does actions a1, a2, ..., sequentially in
-// each invocation.
-template <typename Action1, typename Action2>
-inline internal::DoBothAction<Action1, Action2>
-DoAll(Action1 a1, Action2 a2) {
-  return internal::DoBothAction<Action1, Action2>(a1, a2);
-}
-
-template <typename Action1, typename Action2, typename Action3>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    Action3> >
-DoAll(Action1 a1, Action2 a2, Action3 a3) {
-  return DoAll(a1, DoAll(a2, a3));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, Action4> > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) {
-  return DoAll(a1, DoAll(a2, a3, a4));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4, typename Action5>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
-    Action5> > > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) {
-  return DoAll(a1, DoAll(a2, a3, a4, a5));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4, typename Action5, typename Action6>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
-    internal::DoBothAction<Action5, Action6> > > > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6) {
-  return DoAll(a1, DoAll(a2, a3, a4, a5, a6));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4, typename Action5, typename Action6, typename Action7>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
-    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
-    Action7> > > > > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
-    Action7 a7) {
-  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4, typename Action5, typename Action6, typename Action7,
-    typename Action8>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
-    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
-    internal::DoBothAction<Action7, Action8> > > > > > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
-    Action7 a7, Action8 a8) {
-  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4, typename Action5, typename Action6, typename Action7,
-    typename Action8, typename Action9>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
-    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
-    internal::DoBothAction<Action7, internal::DoBothAction<Action8,
-    Action9> > > > > > > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
-    Action7 a7, Action8 a8, Action9 a9) {
-  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-template <typename Action1, typename Action2, typename Action3,
-    typename Action4, typename Action5, typename Action6, typename Action7,
-    typename Action8, typename Action9, typename Action10>
-inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
-    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
-    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
-    internal::DoBothAction<Action7, internal::DoBothAction<Action8,
-    internal::DoBothAction<Action9, Action10> > > > > > > > >
-DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
-    Action7 a7, Action8 a8, Action9 a9, Action10 a10) {
-  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10));
-}
-
-}  // namespace testing
-
-// 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.  The reason is
-// that C++ doesn't yet allow function-local types to be used to
-// instantiate templates.  The up-coming C++0x standard will fix this.
-// Once that's done, we'll consider supporting using ACTION*() inside
-// a function.
-//
-// MORE INFORMATION:
-//
-// To learn more about using these macros, please search for 'ACTION'
-// on http://code.google.com/p/googlemock/wiki/CookBook.
-
-// An internal macro needed for implementing ACTION*().
-#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
-    const args_type& args GTEST_ATTRIBUTE_UNUSED_, \
-    arg0_type arg0 GTEST_ATTRIBUTE_UNUSED_, \
-    arg1_type arg1 GTEST_ATTRIBUTE_UNUSED_, \
-    arg2_type arg2 GTEST_ATTRIBUTE_UNUSED_, \
-    arg3_type arg3 GTEST_ATTRIBUTE_UNUSED_, \
-    arg4_type arg4 GTEST_ATTRIBUTE_UNUSED_, \
-    arg5_type arg5 GTEST_ATTRIBUTE_UNUSED_, \
-    arg6_type arg6 GTEST_ATTRIBUTE_UNUSED_, \
-    arg7_type arg7 GTEST_ATTRIBUTE_UNUSED_, \
-    arg8_type arg8 GTEST_ATTRIBUTE_UNUSED_, \
-    arg9_type arg9 GTEST_ATTRIBUTE_UNUSED_
-
-// 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(::testing::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(gmock_p0)
-#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
-    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), p1(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(gmock_p0), p1(gmock_p1), p2(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(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(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3), p4(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(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(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-        p7(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
-        p8(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
-        p8(gmock_p8), p9(gmock_p9)
-
-// 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_INIT_##value_params {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      GMOCK_INTERNAL_DEFN_##value_params\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(\
-          new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
-    }\
-    GMOCK_INTERNAL_DEFN_##value_params\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
-  };\
-  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 F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      GMOCK_ACTION_CLASS_(name, value_params)<\
-          GMOCK_INTERNAL_LIST_##template_params\
-          GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\
-              gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION(name)\
-  class name##Action {\
-   public:\
-    name##Action() {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl() {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>());\
-    }\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##Action);\
-  };\
-  inline name##Action name() {\
-    return name##Action();\
-  }\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##Action::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P(name, p0)\
-  template <typename p0##_type>\
-  class name##ActionP {\
-   public:\
-    explicit name##ActionP(p0##_type gmock_p0) : p0(gmock_p0) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      explicit gmock_Impl(p0##_type gmock_p0) : p0(gmock_p0) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0));\
-    }\
-    p0##_type p0;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP);\
-  };\
-  template <typename p0##_type>\
-  inline name##ActionP<p0##_type> name(p0##_type p0) {\
-    return name##ActionP<p0##_type>(p0);\
-  }\
-  template <typename p0##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP<p0##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P2(name, p0, p1)\
-  template <typename p0##_type, typename p1##_type>\
-  class name##ActionP2 {\
-   public:\
-    name##ActionP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
-        p1(gmock_p1) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
-          p1(gmock_p1) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP2);\
-  };\
-  template <typename p0##_type, typename p1##_type>\
-  inline name##ActionP2<p0##_type, p1##_type> name(p0##_type p0, \
-      p1##_type p1) {\
-    return name##ActionP2<p0##_type, p1##_type>(p0, p1);\
-  }\
-  template <typename p0##_type, typename p1##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP2<p0##_type, p1##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P3(name, p0, p1, p2)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type>\
-  class name##ActionP3 {\
-   public:\
-    name##ActionP3(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, \
-          p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP3);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type>\
-  inline name##ActionP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
-      p1##_type p1, p2##_type p2) {\
-    return name##ActionP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP3<p0##_type, p1##_type, \
-          p2##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P4(name, p0, p1, p2, p3)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type>\
-  class name##ActionP4 {\
-   public:\
-    name##ActionP4(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-          p3(gmock_p3) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP4);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type>\
-  inline name##ActionP4<p0##_type, p1##_type, p2##_type, \
-      p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
-      p3##_type p3) {\
-    return name##ActionP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, p1, \
-        p2, p3);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP4<p0##_type, p1##_type, p2##_type, \
-          p3##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P5(name, p0, p1, p2, p3, p4)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type>\
-  class name##ActionP5 {\
-   public:\
-    name##ActionP5(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, \
-        p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), \
-          p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP5);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type>\
-  inline name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-      p4##_type p4) {\
-    return name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type>(p0, p1, p2, p3, p4);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
-          p4##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P6(name, p0, p1, p2, p3, p4, p5)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type>\
-  class name##ActionP6 {\
-   public:\
-    name##ActionP6(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5));\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP6);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type>\
-  inline name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
-      p3##_type p3, p4##_type p4, p5##_type p5) {\
-    return name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-          p5##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P7(name, p0, p1, p2, p3, p4, p5, p6)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type>\
-  class name##ActionP7 {\
-   public:\
-    name##ActionP7(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(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
-        p6(gmock_p6) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-      p6##_type p6;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(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;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP7);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type>\
-  inline name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
-      p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
-      p6##_type p6) {\
-    return name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-          p5##_type, p6##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P8(name, p0, p1, p2, p3, p4, p5, p6, p7)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type>\
-  class name##ActionP8 {\
-   public:\
-    name##ActionP8(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-        p7(gmock_p7) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(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(gmock_p0), \
-          p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), \
-          p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-      p6##_type p6;\
-      p7##_type p7;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(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;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP8);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type>\
-  inline name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
-      p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
-      p6##_type p6, p7##_type p7) {\
-    return name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
-        p6, p7);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-          p5##_type, p6##_type, \
-          p7##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8)\
-  template <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>\
-  class name##ActionP9 {\
-   public:\
-    name##ActionP9(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
-        p8(gmock_p8) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-          p7(gmock_p7), p8(gmock_p8) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      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;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(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;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP9);\
-  };\
-  template <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>\
-  inline name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type, \
-      p8##_type> name(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) {\
-    return name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
-        p3, p4, p5, p6, p7, p8);\
-  }\
-  template <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>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-          p5##_type, p6##_type, p7##_type, \
-          p8##_type>::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)\
-  template <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>\
-  class name##ActionP10 {\
-   public:\
-    name##ActionP10(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(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-        p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-          p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <typename arg0_type, typename arg1_type, typename arg2_type, \
-          typename arg3_type, typename arg4_type, typename arg5_type, \
-          typename arg6_type, typename arg7_type, typename arg8_type, \
-          typename arg9_type>\
-      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
-          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
-          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
-          arg9_type arg9) const;\
-      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;\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>(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;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##ActionP10);\
-  };\
-  template <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>\
-  inline name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
-      p9##_type> name(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) {\
-    return name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
-        p1, p2, p3, p4, p5, p6, p7, p8, p9);\
-  }\
-  template <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>\
-  template <typename F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-          p5##_type, p6##_type, p7##_type, p8##_type, \
-          p9##_type>::gmock_Impl<F>::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
-// is expanded and macro expansion cannot contain #pragma.  Therefore
-// we suppress them here.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
-#endif
-
-// Various overloads for InvokeArgument<N>().
-//
-// 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 ByRef().  For
-//   example,
-//
-//     InvokeArgument<1>(5, string("Hello"), ByRef(foo))
-//
-//   passes 5 and string("Hello") by value, and passes foo by
-//   reference.
-//
-//   2. If the callable takes an argument by reference but ByRef() 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.
-
-namespace internal {
-namespace invoke_argument {
-
-// Appears in InvokeArgumentAdl's argument list to help avoid
-// accidental calls to user functions of the same name.
-struct AdlTag {};
-
-// InvokeArgumentAdl - a helper for InvokeArgument.
-// The basic overloads are provided here for generic functors.
-// Overloads for other custom-callables are provided in the
-// internal/custom/callback-actions.h header.
-
-template <typename R, typename F>
-R InvokeArgumentAdl(AdlTag, F f) {
-  return f();
-}
-template <typename R, typename F, typename A1>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1) {
-  return f(a1);
-}
-template <typename R, typename F, typename A1, typename A2>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2) {
-  return f(a1, a2);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3) {
-  return f(a1, a2, a3);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4) {
-  return f(a1, a2, a3, a4);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4, typename A5>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-  return f(a1, a2, a3, a4, a5);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
-  return f(a1, a2, a3, a4, a5, a6);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
-    A7 a7) {
-  return f(a1, a2, a3, a4, a5, a6, a7);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7, typename A8>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
-    A7 a7, A8 a8) {
-  return f(a1, a2, a3, a4, a5, a6, a7, a8);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7, typename A8,
-    typename A9>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
-    A7 a7, A8 a8, A9 a9) {
-  return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-}
-template <typename R, typename F, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7, typename A8,
-    typename A9, typename A10>
-R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
-    A7 a7, A8 a8, A9 a9, A10 a10) {
-  return f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
-}
-}  // namespace invoke_argument
-}  // namespace internal
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_0_VALUE_PARAMS()) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args));
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_1_VALUE_PARAMS(p0)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_2_VALUE_PARAMS(p0, p1)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_3_VALUE_PARAMS(p0, p1, p2)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3, p4);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
-}
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
-}
-
-// Various overloads for ReturnNew<T>().
-//
-// 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.
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_0_VALUE_PARAMS()) {
-  return new T();
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_1_VALUE_PARAMS(p0)) {
-  return new T(p0);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_2_VALUE_PARAMS(p0, p1)) {
-  return new T(p0, p1);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_3_VALUE_PARAMS(p0, p1, p2)) {
-  return new T(p0, p1, p2);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
-  return new T(p0, p1, p2, p3);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
-  return new T(p0, p1, p2, p3, p4);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
-  return new T(p0, p1, p2, p3, p4, p5);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
-  return new T(p0, p1, p2, p3, p4, p5, p6);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
-  return new T(p0, p1, p2, p3, p4, p5, p6, p7);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
-  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8);
-}
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
-  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
-}
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-}  // namespace testing
-
-// Include any custom actions 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-generated-actions.h"
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h.pump b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h.pump
deleted file mode 100644
index 66d9f9d5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-actions.h.pump
+++ /dev/null
@@ -1,794 +0,0 @@
-$$ -*- mode: c++; -*-
-$$ This is a Pump source file.  Please use Pump to convert it to
-$$ gmock-generated-actions.h.
-$$
-$var n = 10  $$ The maximum arity we support.
-$$}} This meta comment fixes auto-indentation in editors.
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some commonly used variadic actions.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
-
-#include "gmock/gmock-actions.h"
-#include "gmock/internal/gmock-port.h"
-
-namespace testing {
-namespace internal {
-
-// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary
-// function or method with the unpacked values, where F is a function
-// type that takes N arguments.
-template <typename Result, typename ArgumentTuple>
-class InvokeHelper;
-
-
-$range i 0..n
-$for i [[
-$range j 1..i
-$var types = [[$for j [[, typename A$j]]]]
-$var as = [[$for j, [[A$j]]]]
-$var args = [[$if i==0 [[]] $else [[ args]]]]
-$var gets = [[$for j, [[get<$(j - 1)>(args)]]]]
-template <typename R$types>
-class InvokeHelper<R, ::testing::tuple<$as> > {
- public:
-  template <typename Function>
-  static R Invoke(Function function, const ::testing::tuple<$as>&$args) {
-           return function($gets);
-  }
-
-  template <class Class, typename MethodPtr>
-  static R InvokeMethod(Class* obj_ptr,
-                        MethodPtr method_ptr,
-                        const ::testing::tuple<$as>&$args) {
-           return (obj_ptr->*method_ptr)($gets);
-  }
-};
-
-
-]]
-// An INTERNAL macro for extracting the type of a tuple field.  It's
-// subject to change without notice - DO NOT USE IN USER CODE!
-#define GMOCK_FIELD_(Tuple, N) \
-    typename ::testing::tuple_element<N, Tuple>::type
-
-$range i 1..n
-
-// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the
-// type of an n-ary function whose i-th (1-based) argument type is the
-// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple
-// type, and whose return type is Result.  For example,
-//   SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type
-// is int(bool, long).
-//
-// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args)
-// returns the selected fields (k1, k2, ..., k_n) of args as a tuple.
-// For example,
-//   SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select(
-//       ::testing::make_tuple(true, 'a', 2.5))
-// returns tuple (2.5, true).
-//
-// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be
-// in the range [0, $n].  Duplicates are allowed and they don't have
-// to be in an ascending or descending order.
-
-template <typename Result, typename ArgumentTuple, $for i, [[int k$i]]>
-class SelectArgs {
- public:
-  typedef Result type($for i, [[GMOCK_FIELD_(ArgumentTuple, k$i)]]);
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& args) {
-    return SelectedArgs($for i, [[get<k$i>(args)]]);
-  }
-};
-
-
-$for i [[
-$range j 1..n
-$range j1 1..i-1
-template <typename Result, typename ArgumentTuple$for j1[[, int k$j1]]>
-class SelectArgs<Result, ArgumentTuple,
-                 $for j, [[$if j <= i-1 [[k$j]] $else [[-1]]]]> {
- public:
-  typedef Result type($for j1, [[GMOCK_FIELD_(ArgumentTuple, k$j1)]]);
-  typedef typename Function<type>::ArgumentTuple SelectedArgs;
-  static SelectedArgs Select(const ArgumentTuple& [[]]
-$if i == 1 [[/* args */]] $else [[args]]) {
-    return SelectedArgs($for j1, [[get<k$j1>(args)]]);
-  }
-};
-
-
-]]
-#undef GMOCK_FIELD_
-
-$var ks = [[$for i, [[k$i]]]]
-
-// Implements the WithArgs action.
-template <typename InnerAction, $for i, [[int k$i = -1]]>
-class WithArgsAction {
- public:
-  explicit WithArgsAction(const InnerAction& action) : action_(action) {}
-
-  template <typename F>
-  operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
-
- private:
-  template <typename F>
-  class Impl : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-
-    explicit Impl(const InnerAction& action) : action_(action) {}
-
-    virtual Result Perform(const ArgumentTuple& args) {
-      return action_.Perform(SelectArgs<Result, ArgumentTuple, $ks>::Select(args));
-    }
-
-   private:
-    typedef typename SelectArgs<Result, ArgumentTuple,
-        $ks>::type InnerFunctionType;
-
-    Action<InnerFunctionType> action_;
-  };
-
-  const InnerAction action_;
-
-  GTEST_DISALLOW_ASSIGN_(WithArgsAction);
-};
-
-// A macro from the ACTION* family (defined later in this file)
-// 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 {};
-
-// A helper class needed for implementing the ACTION* macros.
-template <typename Result, class Impl>
-class ActionHelper {
- public:
-$range i 0..n
-$for i
-
-[[
-$var template = [[$if i==0 [[]] $else [[
-$range j 0..i-1
-  template <$for j, [[typename A$j]]>
-]]]]
-$range j 0..i-1
-$var As = [[$for j, [[A$j]]]]
-$var as = [[$for j, [[get<$j>(args)]]]]
-$range k 1..n-i
-$var eas = [[$for k, [[ExcessiveArg()]]]]
-$var arg_list = [[$if (i==0) | (i==n) [[$as$eas]] $else [[$as, $eas]]]]
-$template
-  static Result Perform(Impl* impl, const ::testing::tuple<$As>& args) {
-    return impl->template gmock_PerformImpl<$As>(args, $arg_list);
-  }
-
-]]
-};
-
-}  // namespace internal
-
-// Various overloads for Invoke().
-
-// 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.  C++ doesn't support default arguments for
-// function templates, so we have to overload it.
-
-$range i 1..n
-$for i [[
-$range j 1..i
-template <$for j [[int k$j, ]]typename InnerAction>
-inline internal::WithArgsAction<InnerAction$for j [[, k$j]]>
-WithArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction$for j [[, k$j]]>(action);
-}
-
-
-]]
-// Creates an action that does actions a1, a2, ..., sequentially in
-// each invocation.
-$range i 2..n
-$for i [[
-$range j 2..i
-$var types = [[$for j, [[typename Action$j]]]]
-$var Aas = [[$for j [[, Action$j a$j]]]]
-
-template <typename Action1, $types>
-$range k 1..i-1
-
-inline $for k [[internal::DoBothAction<Action$k, ]]Action$i$for k  [[>]]
-
-DoAll(Action1 a1$Aas) {
-$if i==2 [[
-
-  return internal::DoBothAction<Action1, Action2>(a1, a2);
-]] $else [[
-$range j2 2..i
-
-  return DoAll(a1, DoAll($for j2, [[a$j2]]));
-]]
-
-}
-
-]]
-
-}  // namespace testing
-
-// 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_P$n 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.  The reason is
-// that C++ doesn't yet allow function-local types to be used to
-// instantiate templates.  The up-coming C++0x standard will fix this.
-// Once that's done, we'll consider supporting using ACTION*() inside
-// a function.
-//
-// MORE INFORMATION:
-//
-// To learn more about using these macros, please search for 'ACTION'
-// on http://code.google.com/p/googlemock/wiki/CookBook.
-
-$range i 0..n
-$range k 0..n-1
-
-// An internal macro needed for implementing ACTION*().
-#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
-    const args_type& args GTEST_ATTRIBUTE_UNUSED_
-$for k [[, \
-    arg$k[[]]_type arg$k GTEST_ATTRIBUTE_UNUSED_]]
-
-
-// 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(::testing::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.
-
-$range j 1..n
-$for j [[
-$range m 0..j-1
-#define GMOCK_INTERNAL_DECL_HAS_$j[[]]
-_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[kind$m name$m]]
-
-
-]]
-
-// Lists the template parameters.
-
-$for j [[
-$range m 0..j-1
-#define GMOCK_INTERNAL_LIST_HAS_$j[[]]
-_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[name$m]]
-
-
-]]
-
-// Declares the types of value parameters.
-
-$for i [[
-$range j 0..i-1
-#define GMOCK_INTERNAL_DECL_TYPE_AND_$i[[]]
-_VALUE_PARAMS($for j, [[p$j]]) $for j [[, typename p$j##_type]]
-
-
-]]
-
-// Initializes the value parameters.
-
-$for i [[
-$range j 0..i-1
-#define GMOCK_INTERNAL_INIT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])\
-    ($for j, [[p$j##_type gmock_p$j]])$if i>0 [[ : ]]$for j, [[p$j(gmock_p$j)]]
-
-
-]]
-
-// Declares the fields for storing the value parameters.
-
-$for i [[
-$range j 0..i-1
-#define GMOCK_INTERNAL_DEFN_AND_$i[[]]
-_VALUE_PARAMS($for j, [[p$j]]) $for j [[p$j##_type p$j; ]]
-
-
-]]
-
-// Lists the value parameters.
-
-$for i [[
-$range j 0..i-1
-#define GMOCK_INTERNAL_LIST_AND_$i[[]]
-_VALUE_PARAMS($for j, [[p$j]]) $for j, [[p$j]]
-
-
-]]
-
-// Lists the value parameter types.
-
-$for i [[
-$range j 0..i-1
-#define GMOCK_INTERNAL_LIST_TYPE_AND_$i[[]]
-_VALUE_PARAMS($for j, [[p$j]]) $for j [[, p$j##_type]]
-
-
-]]
-
-// Declares the value parameters.
-
-$for i [[
-$range j 0..i-1
-#define GMOCK_INTERNAL_DECL_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]]
-$for j, [[p$j##_type p$j]]
-
-
-]]
-
-// The suffix of the class template implementing the action template.
-$for i [[
-
-
-$range j 0..i-1
-#define GMOCK_INTERNAL_COUNT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]]
-$if i==1 [[P]] $elif i>=2 [[P$i]]
-]]
-
-
-// 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)
-
-$range k 0..n-1
-
-#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_INIT_##value_params {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <$for k, [[typename arg$k[[]]_type]]>\
-      return_type gmock_PerformImpl(const args_type& args[[]]
-$for k [[, arg$k[[]]_type arg$k]]) const;\
-      GMOCK_INTERNAL_DEFN_##value_params\
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(\
-          new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
-    }\
-    GMOCK_INTERNAL_DEFN_##value_params\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
-  };\
-  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 F>\
-  template <typename arg0_type, typename arg1_type, typename arg2_type, \
-      typename arg3_type, typename arg4_type, typename arg5_type, \
-      typename arg6_type, typename arg7_type, typename arg8_type, \
-      typename arg9_type>\
-  typename ::testing::internal::Function<F>::Result\
-      GMOCK_ACTION_CLASS_(name, value_params)<\
-          GMOCK_INTERNAL_LIST_##template_params\
-          GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\
-              gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-$for i
-
-[[
-$var template = [[$if i==0 [[]] $else [[
-$range j 0..i-1
-
-  template <$for j, [[typename p$j##_type]]>\
-]]]]
-$var class_name = [[name##Action[[$if i==0 [[]] $elif i==1 [[P]]
-                                                $else [[P$i]]]]]]
-$range j 0..i-1
-$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
-$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]]
-$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]
-$var param_field_decls = [[$for j
-[[
-
-      p$j##_type p$j;\
-]]]]
-$var param_field_decls2 = [[$for j
-[[
-
-    p$j##_type p$j;\
-]]]]
-$var params = [[$for j, [[p$j]]]]
-$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]]
-$var typename_arg_types = [[$for k, [[typename arg$k[[]]_type]]]]
-$var arg_types_and_names = [[$for k, [[arg$k[[]]_type arg$k]]]]
-$var macro_name = [[$if i==0 [[ACTION]] $elif i==1 [[ACTION_P]]
-                                        $else [[ACTION_P$i]]]]
-
-#define $macro_name(name$for j [[, p$j]])\$template
-  class $class_name {\
-   public:\
-    [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {}\
-    template <typename F>\
-    class gmock_Impl : public ::testing::ActionInterface<F> {\
-     public:\
-      typedef F function_type;\
-      typedef typename ::testing::internal::Function<F>::Result return_type;\
-      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
-          args_type;\
-      [[$if i==1 [[explicit ]]]]gmock_Impl($ctor_param_list)$inits {}\
-      virtual return_type Perform(const args_type& args) {\
-        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
-            Perform(this, args);\
-      }\
-      template <$typename_arg_types>\
-      return_type gmock_PerformImpl(const args_type& args, [[]]
-$arg_types_and_names) const;\$param_field_decls
-     private:\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename F> operator ::testing::Action<F>() const {\
-      return ::testing::Action<F>(new gmock_Impl<F>($params));\
-    }\$param_field_decls2
-   private:\
-    GTEST_DISALLOW_ASSIGN_($class_name);\
-  };\$template
-  inline $class_name$param_types name($param_types_and_names) {\
-    return $class_name$param_types($params);\
-  }\$template
-  template <typename F>\
-  template <$typename_arg_types>\
-  typename ::testing::internal::Function<F>::Result\
-      $class_name$param_types::gmock_Impl<F>::gmock_PerformImpl(\
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-]]
-$$ }  // This meta comment fixes auto-indentation in Emacs.  It won't
-$$    // show up in the generated code.
-
-
-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
-// is expanded and macro expansion cannot contain #pragma.  Therefore
-// we suppress them here.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
-#endif
-
-// Various overloads for InvokeArgument<N>().
-//
-// 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 ByRef().  For
-//   example,
-//
-//     InvokeArgument<1>(5, string("Hello"), ByRef(foo))
-//
-//   passes 5 and string("Hello") by value, and passes foo by
-//   reference.
-//
-//   2. If the callable takes an argument by reference but ByRef() 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.
-
-namespace internal {
-namespace invoke_argument {
-
-// Appears in InvokeArgumentAdl's argument list to help avoid
-// accidental calls to user functions of the same name.
-struct AdlTag {};
-
-// InvokeArgumentAdl - a helper for InvokeArgument.
-// The basic overloads are provided here for generic functors.
-// Overloads for other custom-callables are provided in the
-// internal/custom/callback-actions.h header.
-
-$range i 0..n
-$for i
-[[
-$range j 1..i
-
-template <typename R, typename F[[$for j [[, typename A$j]]]]>
-R InvokeArgumentAdl(AdlTag, F f[[$for j [[, A$j a$j]]]]) {
-  return f([[$for j, [[a$j]]]]);
-}
-]]
-
-}  // namespace invoke_argument
-}  // namespace internal
-
-$range i 0..n
-$for i [[
-$range j 0..i-1
-
-ACTION_TEMPLATE(InvokeArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])) {
-  using internal::invoke_argument::InvokeArgumentAdl;
-  return InvokeArgumentAdl<return_type>(
-      internal::invoke_argument::AdlTag(),
-      ::testing::get<k>(args)$for j [[, p$j]]);
-}
-
-]]
-
-// Various overloads for ReturnNew<T>().
-//
-// 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.
-$range i 0..n
-$for i [[
-$range j 0..i-1
-$var ps = [[$for j, [[p$j]]]]
-
-ACTION_TEMPLATE(ReturnNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_$i[[]]_VALUE_PARAMS($ps)) {
-  return new T($ps);
-}
-
-]]
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-}  // namespace testing
-
-// Include any custom callback actions 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-generated-actions.h"
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h
deleted file mode 100644
index 4fa5ca94..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h
+++ /dev/null
@@ -1,1095 +0,0 @@
-// This file was GENERATED by command:
-//     pump.py gmock-generated-function-mockers.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements function mockers of various arities.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
-
-#include "gmock/gmock-spec-builders.h"
-#include "gmock/internal/gmock-internal-utils.h"
-
-#if GTEST_HAS_STD_FUNCTION_
-# include <functional>
-#endif
-
-namespace testing {
-namespace internal {
-
-template <typename F>
-class FunctionMockerBase;
-
-// Note: class FunctionMocker really belongs to the ::testing
-// namespace.  However if we define it in ::testing, MSVC will
-// complain when classes in ::testing::internal declare it as a
-// friend class template.  To workaround this compiler bug, we define
-// FunctionMocker in ::testing::internal and import it into ::testing.
-template <typename F>
-class FunctionMocker;
-
-template <typename R>
-class FunctionMocker<R()> : public
-    internal::FunctionMockerBase<R()> {
- public:
-  typedef R F();
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With() {
-    return this->current_spec();
-  }
-
-  R Invoke() {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple());
-  }
-};
-
-template <typename R, typename A1>
-class FunctionMocker<R(A1)> : public
-    internal::FunctionMockerBase<R(A1)> {
- public:
-  typedef R F(A1);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1));
-  }
-};
-
-template <typename R, typename A1, typename A2>
-class FunctionMocker<R(A1, A2)> : public
-    internal::FunctionMockerBase<R(A1, A2)> {
- public:
-  typedef R F(A1, A2);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3>
-class FunctionMocker<R(A1, A2, A3)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3)> {
- public:
-  typedef R F(A1, A2, A3);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4>
-class FunctionMocker<R(A1, A2, A3, A4)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4)> {
- public:
-  typedef R F(A1, A2, A3, A4);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5>
-class FunctionMocker<R(A1, A2, A3, A4, A5)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5)> {
- public:
-  typedef R F(A1, A2, A3, A4, A5);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
-class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6)> {
- public:
-  typedef R F(A1, A2, A3, A4, A5, A6);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
-      const Matcher<A6>& m6) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
-        m6));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7>
-class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7)> {
- public:
-  typedef R F(A1, A2, A3, A4, A5, A6, A7);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
-      const Matcher<A6>& m6, const Matcher<A7>& m7) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
-        m6, m7));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8>
-class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
- public:
-  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
-      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
-        m6, m7, m8));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9>
-class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
- public:
-  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
-      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
-      const Matcher<A9>& m9) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
-        m6, m7, m8, m9));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-  }
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9,
-    typename A10>
-class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public
-    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> {
- public:
-  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
-      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
-      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
-      const Matcher<A9>& m9, const Matcher<A10>& m10) {
-    this->current_spec().SetMatchers(::testing::make_tuple(m1, m2, m3, m4, m5,
-        m6, m7, m8, m9, m10));
-    return this->current_spec();
-  }
-
-  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
-      A10 a10) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9,
-        a10));
-  }
-};
-
-}  // 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;
-
-// GMOCK_RESULT_(tn, F) expands to the result type of function type F.
-// We define this as a variadic macro in case F contains unprotected
-// commas (the same reason that we use variadic macros in other places
-// in this file).
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_RESULT_(tn, ...) \
-    tn ::testing::internal::Function<__VA_ARGS__>::Result
-
-// The type of argument N of the given function type.
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_ARG_(tn, N, ...) \
-    tn ::testing::internal::Function<__VA_ARGS__>::Argument##N
-
-// The matcher type for argument N of the given function type.
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_MATCHER_(tn, N, ...) \
-    const ::testing::Matcher<GMOCK_ARG_(tn, N, __VA_ARGS__)>&
-
-// The variable for mocking the given method.
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_MOCKER_(arity, constness, Method) \
-    GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD0_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      ) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 0), \
-        this_method_does_not_take_0_arguments); \
-    GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(0, constness, Method).Invoke(); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method() constness { \
-    GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(0, constness, Method).With(); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(0, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD1_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 1), \
-        this_method_does_not_take_1_argument); \
-    GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(1, constness, Method).Invoke(gmock_a1); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1) constness { \
-    GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(1, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD2_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 2), \
-        this_method_does_not_take_2_arguments); \
-    GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(2, constness, Method).Invoke(gmock_a1, gmock_a2); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2) constness { \
-    GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(2, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD3_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 3), \
-        this_method_does_not_take_3_arguments); \
-    GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(3, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3) constness { \
-    GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(3, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(3, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD4_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 4), \
-        this_method_does_not_take_4_arguments); \
-    GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(4, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4) constness { \
-    GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(4, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(4, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD5_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
-      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 5), \
-        this_method_does_not_take_5_arguments); \
-    GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(5, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
-                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5) constness { \
-    GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(5, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(5, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD6_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
-      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
-      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 6), \
-        this_method_does_not_take_6_arguments); \
-    GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(6, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
-                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
-                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6) constness { \
-    GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(6, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(6, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD7_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
-      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
-      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
-      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 7), \
-        this_method_does_not_take_7_arguments); \
-    GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(7, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
-                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
-                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
-                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7) constness { \
-    GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(7, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(7, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD8_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
-      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
-      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
-      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
-      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 8), \
-        this_method_does_not_take_8_arguments); \
-    GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(8, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
-                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
-                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
-                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
-                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8) constness { \
-    GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(8, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(8, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD9_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
-      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
-      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
-      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
-      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \
-      GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 9), \
-        this_method_does_not_take_9_arguments); \
-    GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(9, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
-        gmock_a9); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
-                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
-                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
-                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
-                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \
-                     GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9) constness { \
-    GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(9, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
-        gmock_a9); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(9, constness, \
-      Method)
-
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD10_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
-      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
-      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
-      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
-      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
-      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
-      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
-      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \
-      GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9, \
-      GMOCK_ARG_(tn, 10, __VA_ARGS__) gmock_a10) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
-            == 10), \
-        this_method_does_not_take_10_arguments); \
-    GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_(10, constness, Method).Invoke(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
-        gmock_a10); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
-                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
-                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
-                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
-                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
-                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
-                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
-                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \
-                     GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9, \
-                     GMOCK_MATCHER_(tn, 10, \
-                         __VA_ARGS__) gmock_a10) constness { \
-    GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_(10, constness, Method).With(gmock_a1, gmock_a2, \
-        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
-        gmock_a10); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(10, constness, \
-      Method)
-
-#define MOCK_METHOD0(m, ...) GMOCK_METHOD0_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD1(m, ...) GMOCK_METHOD1_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD2(m, ...) GMOCK_METHOD2_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD3(m, ...) GMOCK_METHOD3_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD4(m, ...) GMOCK_METHOD4_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD5(m, ...) GMOCK_METHOD5_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD6(m, ...) GMOCK_METHOD6_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD7(m, ...) GMOCK_METHOD7_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD8(m, ...) GMOCK_METHOD8_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD9(m, ...) GMOCK_METHOD9_(, , , m, __VA_ARGS__)
-#define MOCK_METHOD10(m, ...) GMOCK_METHOD10_(, , , m, __VA_ARGS__)
-
-#define MOCK_CONST_METHOD0(m, ...) GMOCK_METHOD0_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD1(m, ...) GMOCK_METHOD1_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD2(m, ...) GMOCK_METHOD2_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD3(m, ...) GMOCK_METHOD3_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD4(m, ...) GMOCK_METHOD4_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD5(m, ...) GMOCK_METHOD5_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD6(m, ...) GMOCK_METHOD6_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD7(m, ...) GMOCK_METHOD7_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD8(m, ...) GMOCK_METHOD8_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD9(m, ...) GMOCK_METHOD9_(, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD10(m, ...) GMOCK_METHOD10_(, const, , m, __VA_ARGS__)
-
-#define MOCK_METHOD0_T(m, ...) GMOCK_METHOD0_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD1_T(m, ...) GMOCK_METHOD1_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD2_T(m, ...) GMOCK_METHOD2_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD3_T(m, ...) GMOCK_METHOD3_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD4_T(m, ...) GMOCK_METHOD4_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD5_T(m, ...) GMOCK_METHOD5_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD6_T(m, ...) GMOCK_METHOD6_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD7_T(m, ...) GMOCK_METHOD7_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD8_T(m, ...) GMOCK_METHOD8_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD9_T(m, ...) GMOCK_METHOD9_(typename, , , m, __VA_ARGS__)
-#define MOCK_METHOD10_T(m, ...) GMOCK_METHOD10_(typename, , , m, __VA_ARGS__)
-
-#define MOCK_CONST_METHOD0_T(m, ...) \
-    GMOCK_METHOD0_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD1_T(m, ...) \
-    GMOCK_METHOD1_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD2_T(m, ...) \
-    GMOCK_METHOD2_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD3_T(m, ...) \
-    GMOCK_METHOD3_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD4_T(m, ...) \
-    GMOCK_METHOD4_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD5_T(m, ...) \
-    GMOCK_METHOD5_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD6_T(m, ...) \
-    GMOCK_METHOD6_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD7_T(m, ...) \
-    GMOCK_METHOD7_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD8_T(m, ...) \
-    GMOCK_METHOD8_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD9_T(m, ...) \
-    GMOCK_METHOD9_(typename, const, , m, __VA_ARGS__)
-#define MOCK_CONST_METHOD10_T(m, ...) \
-    GMOCK_METHOD10_(typename, const, , m, __VA_ARGS__)
-
-#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD0_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD1_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD2_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD3_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD4_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD5_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD6_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD7_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD8_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD9_(, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD10_(, , ct, m, __VA_ARGS__)
-
-#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD0_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD1_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD2_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD3_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD4_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD5_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD6_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD7_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD8_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD9_(, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD10_(, const, ct, m, __VA_ARGS__)
-
-#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD0_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD1_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD2_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD3_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD4_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD5_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD6_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD7_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD8_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD9_(typename, , ct, m, __VA_ARGS__)
-#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD10_(typename, , ct, m, __VA_ARGS__)
-
-#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD0_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD1_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD2_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD3_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD4_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD5_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD6_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD7_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD8_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD9_(typename, const, ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD10_(typename, const, ct, m, __VA_ARGS__)
-
-// A MockFunction<F> class has one mock method whose type is 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<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());
-// }
-template <typename F>
-class MockFunction;
-
-template <typename R>
-class MockFunction<R()> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD0_T(Call, R());
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R()> AsStdFunction() {
-    return [this]() -> R {
-      return this->Call();
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0>
-class MockFunction<R(A0)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD1_T(Call, R(A0));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0)> AsStdFunction() {
-    return [this](A0 a0) -> R {
-      return this->Call(a0);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1>
-class MockFunction<R(A0, A1)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD2_T(Call, R(A0, A1));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1)> AsStdFunction() {
-    return [this](A0 a0, A1 a1) -> R {
-      return this->Call(a0, a1);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2>
-class MockFunction<R(A0, A1, A2)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD3_T(Call, R(A0, A1, A2));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2) -> R {
-      return this->Call(a0, a1, a2);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3>
-class MockFunction<R(A0, A1, A2, A3)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD4_T(Call, R(A0, A1, A2, A3));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3) -> R {
-      return this->Call(a0, a1, a2, a3);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3,
-    typename A4>
-class MockFunction<R(A0, A1, A2, A3, A4)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3, A4)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) -> R {
-      return this->Call(a0, a1, a2, a3, a4);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3,
-    typename A4, typename A5>
-class MockFunction<R(A0, A1, A2, A3, A4, A5)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3, A4, A5)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) -> R {
-      return this->Call(a0, a1, a2, a3, a4, a5);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6>
-class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3, A4, A5, A6)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) -> R {
-      return this->Call(a0, a1, a2, a3, a4, a5, a6);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7>
-class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3, A4, A5, A6, A7)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) -> R {
-      return this->Call(a0, a1, a2, a3, a4, a5, a6, a7);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7, typename A8>
-class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
-        A8 a8) -> R {
-      return this->Call(a0, a1, a2, a3, a4, a5, a6, a7, a8);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-template <typename R, typename A0, typename A1, typename A2, typename A3,
-    typename A4, typename A5, typename A6, typename A7, typename A8,
-    typename A9>
-class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> AsStdFunction() {
-    return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
-        A8 a8, A9 a9) -> R {
-      return this->Call(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.pump b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.pump
deleted file mode 100644
index 811502d0..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.pump
+++ /dev/null
@@ -1,291 +0,0 @@
-$$ -*- mode: c++; -*-
-$$ This is a Pump source file.  Please use Pump to convert it to
-$$ gmock-generated-function-mockers.h.
-$$
-$var n = 10  $$ The maximum arity we support.
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements function mockers of various arities.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
-
-#include "gmock/gmock-spec-builders.h"
-#include "gmock/internal/gmock-internal-utils.h"
-
-#if GTEST_HAS_STD_FUNCTION_
-# include <functional>
-#endif
-
-namespace testing {
-namespace internal {
-
-template <typename F>
-class FunctionMockerBase;
-
-// Note: class FunctionMocker really belongs to the ::testing
-// namespace.  However if we define it in ::testing, MSVC will
-// complain when classes in ::testing::internal declare it as a
-// friend class template.  To workaround this compiler bug, we define
-// FunctionMocker in ::testing::internal and import it into ::testing.
-template <typename F>
-class FunctionMocker;
-
-
-$range i 0..n
-$for i [[
-$range j 1..i
-$var typename_As = [[$for j [[, typename A$j]]]]
-$var As = [[$for j, [[A$j]]]]
-$var as = [[$for j, [[a$j]]]]
-$var Aas = [[$for j, [[A$j a$j]]]]
-$var ms = [[$for j, [[m$j]]]]
-$var matchers = [[$for j, [[const Matcher<A$j>& m$j]]]]
-template <typename R$typename_As>
-class FunctionMocker<R($As)> : public
-    internal::FunctionMockerBase<R($As)> {
- public:
-  typedef R F($As);
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-
-  MockSpec<F>& With($matchers) {
-
-$if i >= 1 [[
-    this->current_spec().SetMatchers(::testing::make_tuple($ms));
-
-]]
-    return this->current_spec();
-  }
-
-  R Invoke($Aas) {
-    // Even though gcc and MSVC don't enforce it, 'this->' is required
-    // by the C++ standard [14.6.4] here, as the base class type is
-    // dependent on the template argument (and thus shouldn't be
-    // looked into when resolving InvokeWith).
-    return this->InvokeWith(ArgumentTuple($as));
-  }
-};
-
-
-]]
-}  // 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;
-
-// GMOCK_RESULT_(tn, F) expands to the result type of function type F.
-// We define this as a variadic macro in case F contains unprotected
-// commas (the same reason that we use variadic macros in other places
-// in this file).
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_RESULT_(tn, ...) \
-    tn ::testing::internal::Function<__VA_ARGS__>::Result
-
-// The type of argument N of the given function type.
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_ARG_(tn, N, ...) \
-    tn ::testing::internal::Function<__VA_ARGS__>::Argument##N
-
-// The matcher type for argument N of the given function type.
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_MATCHER_(tn, N, ...) \
-    const ::testing::Matcher<GMOCK_ARG_(tn, N, __VA_ARGS__)>&
-
-// The variable for mocking the given method.
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_MOCKER_(arity, constness, Method) \
-    GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
-
-
-$for i [[
-$range j 1..i
-$var arg_as = [[$for j, \
-      [[GMOCK_ARG_(tn, $j, __VA_ARGS__) gmock_a$j]]]]
-$var as = [[$for j, [[gmock_a$j]]]]
-$var matcher_as = [[$for j, \
-                     [[GMOCK_MATCHER_(tn, $j, __VA_ARGS__) gmock_a$j]]]]
-// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
-#define GMOCK_METHOD$i[[]]_(tn, constness, ct, Method, ...) \
-  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
-      $arg_as) constness { \
-    GTEST_COMPILE_ASSERT_((::testing::tuple_size<                          \
-        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value == $i), \
-        this_method_does_not_take_$i[[]]_argument[[$if i != 1 [[s]]]]); \
-    GMOCK_MOCKER_($i, constness, Method).SetOwnerAndName(this, #Method); \
-    return GMOCK_MOCKER_($i, constness, Method).Invoke($as); \
-  } \
-  ::testing::MockSpec<__VA_ARGS__>& \
-      gmock_##Method($matcher_as) constness { \
-    GMOCK_MOCKER_($i, constness, Method).RegisterOwner(this); \
-    return GMOCK_MOCKER_($i, constness, Method).With($as); \
-  } \
-  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_($i, constness, Method)
-
-
-]]
-$for i [[
-#define MOCK_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, , , m, __VA_ARGS__)
-
-]]
-
-
-$for i [[
-#define MOCK_CONST_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, const, , m, __VA_ARGS__)
-
-]]
-
-
-$for i [[
-#define MOCK_METHOD$i[[]]_T(m, ...) GMOCK_METHOD$i[[]]_(typename, , , m, __VA_ARGS__)
-
-]]
-
-
-$for i [[
-#define MOCK_CONST_METHOD$i[[]]_T(m, ...) \
-    GMOCK_METHOD$i[[]]_(typename, const, , m, __VA_ARGS__)
-
-]]
-
-
-$for i [[
-#define MOCK_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD$i[[]]_(, , ct, m, __VA_ARGS__)
-
-]]
-
-
-$for i [[
-#define MOCK_CONST_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD$i[[]]_(, const, ct, m, __VA_ARGS__)
-
-]]
-
-
-$for i [[
-#define MOCK_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD$i[[]]_(typename, , ct, m, __VA_ARGS__)
-
-]]
-
-
-$for i [[
-#define MOCK_CONST_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \
-    GMOCK_METHOD$i[[]]_(typename, const, ct, m, __VA_ARGS__)
-
-]]
-
-// A MockFunction<F> class has one mock method whose type is 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<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());
-// }
-template <typename F>
-class MockFunction;
-
-
-$for i [[
-$range j 0..i-1
-$var ArgTypes = [[$for j, [[A$j]]]]
-$var ArgNames = [[$for j, [[a$j]]]]
-$var ArgDecls = [[$for j, [[A$j a$j]]]]
-template <typename R$for j [[, typename A$j]]>
-class MockFunction<R($ArgTypes)> {
- public:
-  MockFunction() {}
-
-  MOCK_METHOD$i[[]]_T(Call, R($ArgTypes));
-
-#if GTEST_HAS_STD_FUNCTION_
-  std::function<R($ArgTypes)> AsStdFunction() {
-    return [this]($ArgDecls) -> R {
-      return this->Call($ArgNames);
-    };
-  }
-#endif  // GTEST_HAS_STD_FUNCTION_
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
-};
-
-
-]]
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h
deleted file mode 100644
index 57056fd9..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h
+++ /dev/null
@@ -1,2179 +0,0 @@
-// This file was GENERATED by command:
-//     pump.py gmock-generated-matchers.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// 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.
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some commonly used variadic matchers.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
-
-#include <iterator>
-#include <sstream>
-#include <string>
-#include <vector>
-#include "gmock/gmock-matchers.h"
-
-namespace testing {
-namespace internal {
-
-// The type of the i-th (0-based) field of Tuple.
-#define GMOCK_FIELD_TYPE_(Tuple, i) \
-    typename ::testing::tuple_element<i, Tuple>::type
-
-// TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
-// tuple of type Tuple.  It has two members:
-//
-//   type: a tuple type whose i-th field is the ki-th field of Tuple.
-//   GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
-//
-// For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
-//
-//   type is tuple<int, bool>, and
-//   GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
-
-template <class Tuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
-    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
-    int k9 = -1>
-class TupleFields;
-
-// This generic version is used when there are 10 selectors.
-template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
-    int k7, int k8, int k9>
-class TupleFields {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
-      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
-      GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8),
-      GMOCK_FIELD_TYPE_(Tuple, k9)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
-        get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t), get<k9>(t));
-  }
-};
-
-// The following specialization is used for 0 ~ 9 selectors.
-
-template <class Tuple>
-class TupleFields<Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<> type;
-  static type GetSelectedFields(const Tuple& /* t */) {
-    return type();
-  }
-};
-
-template <class Tuple, int k0>
-class TupleFields<Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1>
-class TupleFields<Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2>
-class TupleFields<Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2, int k3>
-class TupleFields<Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2, int k3, int k4>
-class TupleFields<Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5>
-class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
-      GMOCK_FIELD_TYPE_(Tuple, k5)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
-        get<k5>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6>
-class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
-      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
-        get<k5>(t), get<k6>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
-    int k7>
-class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
-      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
-      GMOCK_FIELD_TYPE_(Tuple, k7)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
-        get<k5>(t), get<k6>(t), get<k7>(t));
-  }
-};
-
-template <class Tuple, int k0, int k1, int k2, int k3, int k4, int k5, int k6,
-    int k7, int k8>
-class TupleFields<Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1> {
- public:
-  typedef ::testing::tuple<GMOCK_FIELD_TYPE_(Tuple, k0),
-      GMOCK_FIELD_TYPE_(Tuple, k1), GMOCK_FIELD_TYPE_(Tuple, k2),
-      GMOCK_FIELD_TYPE_(Tuple, k3), GMOCK_FIELD_TYPE_(Tuple, k4),
-      GMOCK_FIELD_TYPE_(Tuple, k5), GMOCK_FIELD_TYPE_(Tuple, k6),
-      GMOCK_FIELD_TYPE_(Tuple, k7), GMOCK_FIELD_TYPE_(Tuple, k8)> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type(get<k0>(t), get<k1>(t), get<k2>(t), get<k3>(t), get<k4>(t),
-        get<k5>(t), get<k6>(t), get<k7>(t), get<k8>(t));
-  }
-};
-
-#undef GMOCK_FIELD_TYPE_
-
-// Implements the Args() matcher.
-template <class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
-    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
-    int k9 = -1>
-class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
- public:
-  // ArgsTuple may have top-level const or reference modifiers.
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
-  typedef typename internal::TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5,
-      k6, k7, k8, k9>::type SelectedArgs;
-  typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
-
-  template <typename InnerMatcher>
-  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
-      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
-
-  virtual bool MatchAndExplain(ArgsTuple args,
-                               MatchResultListener* listener) const {
-    const SelectedArgs& selected_args = GetSelectedArgs(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;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "are a tuple ";
-    PrintIndices(os);
-    inner_matcher_.DescribeTo(os);
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "are a tuple ";
-    PrintIndices(os);
-    inner_matcher_.DescribeNegationTo(os);
-  }
-
- private:
-  static SelectedArgs GetSelectedArgs(ArgsTuple args) {
-    return TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,
-        k9>::GetSelectedFields(args);
-  }
-
-  // Prints the indices of the selected fields.
-  static void PrintIndices(::std::ostream* os) {
-    *os << "whose fields (";
-    const int indices[10] = { k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 };
-    for (int i = 0; i < 10; i++) {
-      if (indices[i] < 0)
-        break;
-
-      if (i >= 1)
-        *os << ", ";
-
-      *os << "#" << indices[i];
-    }
-    *os << ") ";
-  }
-
-  const MonomorphicInnerMatcher inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
-};
-
-template <class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1,
-    int k3 = -1, int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1,
-    int k8 = -1, int k9 = -1>
-class ArgsMatcher {
- public:
-  explicit ArgsMatcher(const InnerMatcher& inner_matcher)
-      : inner_matcher_(inner_matcher) {}
-
-  template <typename ArgsTuple>
-  operator Matcher<ArgsTuple>() const {
-    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k0, k1, k2, k3, k4, k5,
-        k6, k7, k8, k9>(inner_matcher_));
-  }
-
- private:
-  const InnerMatcher inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
-};
-
-// A set of metafunctions for computing the result type of AllOf.
-// AllOf(m1, ..., mN) returns
-// AllOfResultN<decltype(m1), ..., decltype(mN)>::type.
-
-// Although AllOf isn't defined for one argument, AllOfResult1 is defined
-// to simplify the implementation.
-template <typename M1>
-struct AllOfResult1 {
-  typedef M1 type;
-};
-
-template <typename M1, typename M2>
-struct AllOfResult2 {
-  typedef BothOfMatcher<
-      typename AllOfResult1<M1>::type,
-      typename AllOfResult1<M2>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3>
-struct AllOfResult3 {
-  typedef BothOfMatcher<
-      typename AllOfResult1<M1>::type,
-      typename AllOfResult2<M2, M3>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4>
-struct AllOfResult4 {
-  typedef BothOfMatcher<
-      typename AllOfResult2<M1, M2>::type,
-      typename AllOfResult2<M3, M4>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5>
-struct AllOfResult5 {
-  typedef BothOfMatcher<
-      typename AllOfResult2<M1, M2>::type,
-      typename AllOfResult3<M3, M4, M5>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6>
-struct AllOfResult6 {
-  typedef BothOfMatcher<
-      typename AllOfResult3<M1, M2, M3>::type,
-      typename AllOfResult3<M4, M5, M6>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7>
-struct AllOfResult7 {
-  typedef BothOfMatcher<
-      typename AllOfResult3<M1, M2, M3>::type,
-      typename AllOfResult4<M4, M5, M6, M7>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8>
-struct AllOfResult8 {
-  typedef BothOfMatcher<
-      typename AllOfResult4<M1, M2, M3, M4>::type,
-      typename AllOfResult4<M5, M6, M7, M8>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9>
-struct AllOfResult9 {
-  typedef BothOfMatcher<
-      typename AllOfResult4<M1, M2, M3, M4>::type,
-      typename AllOfResult5<M5, M6, M7, M8, M9>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9, typename M10>
-struct AllOfResult10 {
-  typedef BothOfMatcher<
-      typename AllOfResult5<M1, M2, M3, M4, M5>::type,
-      typename AllOfResult5<M6, M7, M8, M9, M10>::type
-  > type;
-};
-
-// A set of metafunctions for computing the result type of AnyOf.
-// AnyOf(m1, ..., mN) returns
-// AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.
-
-// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
-// to simplify the implementation.
-template <typename M1>
-struct AnyOfResult1 {
-  typedef M1 type;
-};
-
-template <typename M1, typename M2>
-struct AnyOfResult2 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult1<M1>::type,
-      typename AnyOfResult1<M2>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3>
-struct AnyOfResult3 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult1<M1>::type,
-      typename AnyOfResult2<M2, M3>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4>
-struct AnyOfResult4 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult2<M1, M2>::type,
-      typename AnyOfResult2<M3, M4>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5>
-struct AnyOfResult5 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult2<M1, M2>::type,
-      typename AnyOfResult3<M3, M4, M5>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6>
-struct AnyOfResult6 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult3<M1, M2, M3>::type,
-      typename AnyOfResult3<M4, M5, M6>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7>
-struct AnyOfResult7 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult3<M1, M2, M3>::type,
-      typename AnyOfResult4<M4, M5, M6, M7>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8>
-struct AnyOfResult8 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult4<M1, M2, M3, M4>::type,
-      typename AnyOfResult4<M5, M6, M7, M8>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9>
-struct AnyOfResult9 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult4<M1, M2, M3, M4>::type,
-      typename AnyOfResult5<M5, M6, M7, M8, M9>::type
-  > type;
-};
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9, typename M10>
-struct AnyOfResult10 {
-  typedef EitherOfMatcher<
-      typename AnyOfResult5<M1, M2, M3, M4, M5>::type,
-      typename AnyOfResult5<M6, M7, M8, M9, M10>::type
-  > type;
-};
-
-}  // namespace internal
-
-// 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 <typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher>(matcher);
-}
-
-template <int k1, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1>(matcher);
-}
-
-template <int k1, int k2, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2>(matcher);
-}
-
-template <int k1, int k2, int k3, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
-    typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6,
-      k7>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
-    typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7,
-      k8>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
-    int k9, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
-      k9>(matcher);
-}
-
-template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
-    int k9, int k10, typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8, k9,
-    k10>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher, k1, k2, k3, k4, k5, k6, k7, k8,
-      k9, k10>(matcher);
-}
-
-// ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
-// n elements, where the i-th element in the container must
-// match the i-th argument in the list.  Each argument of
-// ElementsAre() can be either a value or a matcher.  We support up to
-// 10 arguments.
-//
-// The use of DecayArray in the implementation allows ElementsAre()
-// to accept string literals, whose type is const char[N], but we
-// want to treat them as const char*.
-//
-// NOTE: Since ElementsAre() cares about the order of the elements, it
-// must not be used with containers whose elements's order is
-// undefined (e.g. hash_map).
-
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<> >
-ElementsAre() {
-  typedef ::testing::tuple<> Args;
-  return internal::ElementsAreMatcher<Args>(Args());
-}
-
-template <typename T1>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type> >
-ElementsAre(const T1& e1) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1));
-}
-
-template <typename T1, typename T2>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type> >
-ElementsAre(const T1& e1, const T2& e2) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2));
-}
-
-template <typename T1, typename T2, typename T3>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3));
-}
-
-template <typename T1, typename T2, typename T3, typename T4>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type,
-        typename internal::DecayArray<T8>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type,
-      typename internal::DecayArray<T8>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
-      e8));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type,
-        typename internal::DecayArray<T8>::type,
-        typename internal::DecayArray<T9>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type,
-      typename internal::DecayArray<T8>::type,
-      typename internal::DecayArray<T9>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
-      e8, e9));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type,
-        typename internal::DecayArray<T8>::type,
-        typename internal::DecayArray<T9>::type,
-        typename internal::DecayArray<T10>::type> >
-ElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
-    const T10& e10) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type,
-      typename internal::DecayArray<T8>::type,
-      typename internal::DecayArray<T9>::type,
-      typename internal::DecayArray<T10>::type> Args;
-  return internal::ElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5, e6, e7,
-      e8, e9, e10));
-}
-
-// UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
-// that matches n elements in any order.  We support up to n=10 arguments.
-
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<> >
-UnorderedElementsAre() {
-  typedef ::testing::tuple<> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args());
-}
-
-template <typename T1>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type> >
-UnorderedElementsAre(const T1& e1) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1));
-}
-
-template <typename T1, typename T2>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2));
-}
-
-template <typename T1, typename T2, typename T3>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3));
-}
-
-template <typename T1, typename T2, typename T3, typename T4>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
-      e6));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
-      e6, e7));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type,
-        typename internal::DecayArray<T8>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7, const T8& e8) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type,
-      typename internal::DecayArray<T8>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
-      e6, e7, e8));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type,
-        typename internal::DecayArray<T8>::type,
-        typename internal::DecayArray<T9>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type,
-      typename internal::DecayArray<T8>::type,
-      typename internal::DecayArray<T9>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
-      e6, e7, e8, e9));
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-        typename internal::DecayArray<T1>::type,
-        typename internal::DecayArray<T2>::type,
-        typename internal::DecayArray<T3>::type,
-        typename internal::DecayArray<T4>::type,
-        typename internal::DecayArray<T5>::type,
-        typename internal::DecayArray<T6>::type,
-        typename internal::DecayArray<T7>::type,
-        typename internal::DecayArray<T8>::type,
-        typename internal::DecayArray<T9>::type,
-        typename internal::DecayArray<T10>::type> >
-UnorderedElementsAre(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
-    const T5& e5, const T6& e6, const T7& e7, const T8& e8, const T9& e9,
-    const T10& e10) {
-  typedef ::testing::tuple<
-      typename internal::DecayArray<T1>::type,
-      typename internal::DecayArray<T2>::type,
-      typename internal::DecayArray<T3>::type,
-      typename internal::DecayArray<T4>::type,
-      typename internal::DecayArray<T5>::type,
-      typename internal::DecayArray<T6>::type,
-      typename internal::DecayArray<T7>::type,
-      typename internal::DecayArray<T8>::type,
-      typename internal::DecayArray<T9>::type,
-      typename internal::DecayArray<T10>::type> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args(e1, e2, e3, e4, e5,
-      e6, e7, e8, e9, e10));
-}
-
-// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
-// sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.
-
-template <typename M1, typename M2>
-inline typename internal::AllOfResult2<M1, M2>::type
-AllOf(M1 m1, M2 m2) {
-  return typename internal::AllOfResult2<M1, M2>::type(
-      m1,
-      m2);
-}
-
-template <typename M1, typename M2, typename M3>
-inline typename internal::AllOfResult3<M1, M2, M3>::type
-AllOf(M1 m1, M2 m2, M3 m3) {
-  return typename internal::AllOfResult3<M1, M2, M3>::type(
-      m1,
-      ::testing::AllOf(m2, m3));
-}
-
-template <typename M1, typename M2, typename M3, typename M4>
-inline typename internal::AllOfResult4<M1, M2, M3, M4>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4) {
-  return typename internal::AllOfResult4<M1, M2, M3, M4>::type(
-      ::testing::AllOf(m1, m2),
-      ::testing::AllOf(m3, m4));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5>
-inline typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
-  return typename internal::AllOfResult5<M1, M2, M3, M4, M5>::type(
-      ::testing::AllOf(m1, m2),
-      ::testing::AllOf(m3, m4, m5));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6>
-inline typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
-  return typename internal::AllOfResult6<M1, M2, M3, M4, M5, M6>::type(
-      ::testing::AllOf(m1, m2, m3),
-      ::testing::AllOf(m4, m5, m6));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7>
-inline typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
-  return typename internal::AllOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
-      ::testing::AllOf(m1, m2, m3),
-      ::testing::AllOf(m4, m5, m6, m7));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8>
-inline typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
-  return typename internal::AllOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
-      ::testing::AllOf(m1, m2, m3, m4),
-      ::testing::AllOf(m5, m6, m7, m8));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9>
-inline typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
-  return typename internal::AllOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
-      M9>::type(
-      ::testing::AllOf(m1, m2, m3, m4),
-      ::testing::AllOf(m5, m6, m7, m8, m9));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9, typename M10>
-inline typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
-    M10>::type
-AllOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
-  return typename internal::AllOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
-      M10>::type(
-      ::testing::AllOf(m1, m2, m3, m4, m5),
-      ::testing::AllOf(m6, m7, m8, m9, m10));
-}
-
-// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
-// sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
-
-template <typename M1, typename M2>
-inline typename internal::AnyOfResult2<M1, M2>::type
-AnyOf(M1 m1, M2 m2) {
-  return typename internal::AnyOfResult2<M1, M2>::type(
-      m1,
-      m2);
-}
-
-template <typename M1, typename M2, typename M3>
-inline typename internal::AnyOfResult3<M1, M2, M3>::type
-AnyOf(M1 m1, M2 m2, M3 m3) {
-  return typename internal::AnyOfResult3<M1, M2, M3>::type(
-      m1,
-      ::testing::AnyOf(m2, m3));
-}
-
-template <typename M1, typename M2, typename M3, typename M4>
-inline typename internal::AnyOfResult4<M1, M2, M3, M4>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4) {
-  return typename internal::AnyOfResult4<M1, M2, M3, M4>::type(
-      ::testing::AnyOf(m1, m2),
-      ::testing::AnyOf(m3, m4));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5>
-inline typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5) {
-  return typename internal::AnyOfResult5<M1, M2, M3, M4, M5>::type(
-      ::testing::AnyOf(m1, m2),
-      ::testing::AnyOf(m3, m4, m5));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6>
-inline typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6) {
-  return typename internal::AnyOfResult6<M1, M2, M3, M4, M5, M6>::type(
-      ::testing::AnyOf(m1, m2, m3),
-      ::testing::AnyOf(m4, m5, m6));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7>
-inline typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7) {
-  return typename internal::AnyOfResult7<M1, M2, M3, M4, M5, M6, M7>::type(
-      ::testing::AnyOf(m1, m2, m3),
-      ::testing::AnyOf(m4, m5, m6, m7));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8>
-inline typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8) {
-  return typename internal::AnyOfResult8<M1, M2, M3, M4, M5, M6, M7, M8>::type(
-      ::testing::AnyOf(m1, m2, m3, m4),
-      ::testing::AnyOf(m5, m6, m7, m8));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9>
-inline typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8, M9>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9) {
-  return typename internal::AnyOfResult9<M1, M2, M3, M4, M5, M6, M7, M8,
-      M9>::type(
-      ::testing::AnyOf(m1, m2, m3, m4),
-      ::testing::AnyOf(m5, m6, m7, m8, m9));
-}
-
-template <typename M1, typename M2, typename M3, typename M4, typename M5,
-    typename M6, typename M7, typename M8, typename M9, typename M10>
-inline typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
-    M10>::type
-AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
-  return typename internal::AnyOfResult10<M1, M2, M3, M4, M5, M6, M7, M8, M9,
-      M10>::type(
-      ::testing::AnyOf(m1, m2, m3, m4, m5),
-      ::testing::AnyOf(m6, m7, m8, m9, m10));
-}
-
-}  // namespace testing
-
-
-// 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_P10 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,
-//       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.  The reason is
-// that C++ doesn't yet allow function-local types to be used to
-// instantiate templates.  The up-coming C++0x standard will fix this.
-// Once that's done, we'll consider supporting using MATCHER*() inside
-// a function.
-//
-// More Information
-// ================
-//
-// To learn more about using these macros, please search for 'MATCHER'
-// on http://code.google.com/p/googlemock/wiki/CookBook.
-
-#define MATCHER(name, description)\
-  class name##Matcher {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl()\
-           {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<>()));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>());\
-    }\
-    name##Matcher() {\
-    }\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##Matcher);\
-  };\
-  inline name##Matcher name() {\
-    return name##Matcher();\
-  }\
-  template <typename arg_type>\
-  bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P(name, p0, description)\
-  template <typename p0##_type>\
-  class name##MatcherP {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      explicit gmock_Impl(p0##_type gmock_p0)\
-           : p0(gmock_p0) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type>(p0)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0));\
-    }\
-    explicit name##MatcherP(p0##_type gmock_p0) : p0(gmock_p0) {\
-    }\
-    p0##_type p0;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP);\
-  };\
-  template <typename p0##_type>\
-  inline name##MatcherP<p0##_type> name(p0##_type p0) {\
-    return name##MatcherP<p0##_type>(p0);\
-  }\
-  template <typename p0##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP<p0##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P2(name, p0, p1, description)\
-  template <typename p0##_type, typename p1##_type>\
-  class name##MatcherP2 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\
-           : p0(gmock_p0), p1(gmock_p1) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type>(p0, p1)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1));\
-    }\
-    name##MatcherP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
-        p1(gmock_p1) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP2);\
-  };\
-  template <typename p0##_type, typename p1##_type>\
-  inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \
-      p1##_type p1) {\
-    return name##MatcherP2<p0##_type, p1##_type>(p0, p1);\
-  }\
-  template <typename p0##_type, typename p1##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP2<p0##_type, \
-      p1##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P3(name, p0, p1, p2, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type>\
-  class name##MatcherP3 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\
-           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type>(p0, p1, \
-                    p2)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2));\
-    }\
-    name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP3);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type>\
-  inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
-      p1##_type p1, p2##_type p2) {\
-    return name##MatcherP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP3<p0##_type, p1##_type, \
-      p2##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P4(name, p0, p1, p2, p3, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type>\
-  class name##MatcherP4 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3)\
-           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, \
-                    p3##_type>(p0, p1, p2, p3)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3));\
-    }\
-    name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP4);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type>\
-  inline name##MatcherP4<p0##_type, p1##_type, p2##_type, \
-      p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
-      p3##_type p3) {\
-    return name##MatcherP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, \
-        p1, p2, p3);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP4<p0##_type, p1##_type, p2##_type, \
-      p3##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type>\
-  class name##MatcherP5 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-          p3##_type gmock_p3, p4##_type gmock_p4)\
-           : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
-               p4(gmock_p4) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
-                    p4##_type>(p0, p1, p2, p3, p4)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4));\
-    }\
-    name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2, p3##_type gmock_p3, \
-        p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP5);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type>\
-  inline name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-      p4##_type p4) {\
-    return name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type>(p0, p1, p2, p3, p4);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP5<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type>\
-  class name##MatcherP6 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
-               p4(gmock_p4), p5(gmock_p5) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
-                    p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5));\
-    }\
-    name##MatcherP6(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP6);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type>\
-  inline name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
-      p3##_type p3, p4##_type p4, p5##_type p5) {\
-    return name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-      p5##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type>\
-  class name##MatcherP7 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
-               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-      p6##_type p6;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
-                    p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, \
-                    p6)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6));\
-    }\
-    name##MatcherP7(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(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
-        p6(gmock_p6) {\
-    }\
-    p0##_type p0;\
-    p1##_type p1;\
-    p2##_type p2;\
-    p3##_type p3;\
-    p4##_type p4;\
-    p5##_type p5;\
-    p6##_type p6;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP7);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type>\
-  inline name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
-      p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
-      p6##_type p6) {\
-    return name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-      p5##_type, p6##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type>\
-  class name##MatcherP8 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
-               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      p0##_type p0;\
-      p1##_type p1;\
-      p2##_type p2;\
-      p3##_type p3;\
-      p4##_type p4;\
-      p5##_type p5;\
-      p6##_type p6;\
-      p7##_type p7;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
-                    p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, \
-                    p3, p4, p5, p6, p7)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7));\
-    }\
-    name##MatcherP8(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-        p7(gmock_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;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP8);\
-  };\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type>\
-  inline name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
-      p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
-      p6##_type p6, p7##_type p7) {\
-    return name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
-        p6, p7);\
-  }\
-  template <typename p0##_type, typename p1##_type, typename p2##_type, \
-      typename p3##_type, typename p4##_type, typename p5##_type, \
-      typename p6##_type, typename p7##_type>\
-  template <typename arg_type>\
-  bool name##MatcherP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-      p5##_type, p6##_type, \
-      p7##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\
-  template <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>\
-  class name##MatcherP9 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
-               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
-               p8(gmock_p8) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      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;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
-                    p4##_type, p5##_type, p6##_type, p7##_type, \
-                    p8##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8));\
-    }\
-    name##MatcherP9(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
-        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
-        p8(gmock_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;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP9);\
-  };\
-  template <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>\
-  inline name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type, \
-      p8##_type> name(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) {\
-    return name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
-        p3, p4, p5, p6, p7, p8);\
-  }\
-  template <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>\
-  template <typename arg_type>\
-  bool name##MatcherP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-      p5##_type, p6##_type, p7##_type, \
-      p8##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\
-  template <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>\
-  class name##MatcherP10 {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      gmock_Impl(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(gmock_p0), p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), \
-               p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
-               p8(gmock_p8), p9(gmock_p9) {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\
-      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;\
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<p0##_type, p1##_type, p2##_type, p3##_type, \
-                    p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
-                    p9##_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\
-    }\
-    name##MatcherP10(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(gmock_p0), p1(gmock_p1), \
-        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
-        p7(gmock_p7), p8(gmock_p8), p9(gmock_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;\
-   private:\
-    GTEST_DISALLOW_ASSIGN_(name##MatcherP10);\
-  };\
-  template <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>\
-  inline name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
-      p9##_type> name(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) {\
-    return name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
-        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
-        p1, p2, p3, p4, p5, p6, p7, p8, p9);\
-  }\
-  template <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>\
-  template <typename arg_type>\
-  bool name##MatcherP10<p0##_type, p1##_type, p2##_type, p3##_type, \
-      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
-      p9##_type>::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h.pump b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h.pump
deleted file mode 100644
index de30c2c9..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-matchers.h.pump
+++ /dev/null
@@ -1,672 +0,0 @@
-$$ -*- mode: c++; -*-
-$$ This is a Pump source file.  Please use Pump to convert it to
-$$ gmock-generated-actions.h.
-$$
-$var n = 10  $$ The maximum arity we support.
-$$ }} This line fixes auto-indentation of the following code in Emacs.
-// 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.
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some commonly used variadic matchers.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
-
-#include <iterator>
-#include <sstream>
-#include <string>
-#include <vector>
-#include "gmock/gmock-matchers.h"
-
-namespace testing {
-namespace internal {
-
-$range i 0..n-1
-
-// The type of the i-th (0-based) field of Tuple.
-#define GMOCK_FIELD_TYPE_(Tuple, i) \
-    typename ::testing::tuple_element<i, Tuple>::type
-
-// TupleFields<Tuple, k0, ..., kn> is for selecting fields from a
-// tuple of type Tuple.  It has two members:
-//
-//   type: a tuple type whose i-th field is the ki-th field of Tuple.
-//   GetSelectedFields(t): returns fields k0, ..., and kn of t as a tuple.
-//
-// For example, in class TupleFields<tuple<bool, char, int>, 2, 0>, we have:
-//
-//   type is tuple<int, bool>, and
-//   GetSelectedFields(make_tuple(true, 'a', 42)) is (42, true).
-
-template <class Tuple$for i [[, int k$i = -1]]>
-class TupleFields;
-
-// This generic version is used when there are $n selectors.
-template <class Tuple$for i [[, int k$i]]>
-class TupleFields {
- public:
-  typedef ::testing::tuple<$for i, [[GMOCK_FIELD_TYPE_(Tuple, k$i)]]> type;
-  static type GetSelectedFields(const Tuple& t) {
-    return type($for i, [[get<k$i>(t)]]);
-  }
-};
-
-// The following specialization is used for 0 ~ $(n-1) selectors.
-
-$for i [[
-$$ }}}
-$range j 0..i-1
-$range k 0..n-1
-
-template <class Tuple$for j [[, int k$j]]>
-class TupleFields<Tuple, $for k, [[$if k < i [[k$k]] $else [[-1]]]]> {
- public:
-  typedef ::testing::tuple<$for j, [[GMOCK_FIELD_TYPE_(Tuple, k$j)]]> type;
-  static type GetSelectedFields(const Tuple& $if i==0 [[/* t */]] $else [[t]]) {
-    return type($for j, [[get<k$j>(t)]]);
-  }
-};
-
-]]
-
-#undef GMOCK_FIELD_TYPE_
-
-// Implements the Args() matcher.
-
-$var ks = [[$for i, [[k$i]]]]
-template <class ArgsTuple$for i [[, int k$i = -1]]>
-class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
- public:
-  // ArgsTuple may have top-level const or reference modifiers.
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(ArgsTuple) RawArgsTuple;
-  typedef typename internal::TupleFields<RawArgsTuple, $ks>::type SelectedArgs;
-  typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
-
-  template <typename InnerMatcher>
-  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
-      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
-
-  virtual bool MatchAndExplain(ArgsTuple args,
-                               MatchResultListener* listener) const {
-    const SelectedArgs& selected_args = GetSelectedArgs(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;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "are a tuple ";
-    PrintIndices(os);
-    inner_matcher_.DescribeTo(os);
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "are a tuple ";
-    PrintIndices(os);
-    inner_matcher_.DescribeNegationTo(os);
-  }
-
- private:
-  static SelectedArgs GetSelectedArgs(ArgsTuple args) {
-    return TupleFields<RawArgsTuple, $ks>::GetSelectedFields(args);
-  }
-
-  // Prints the indices of the selected fields.
-  static void PrintIndices(::std::ostream* os) {
-    *os << "whose fields (";
-    const int indices[$n] = { $ks };
-    for (int i = 0; i < $n; i++) {
-      if (indices[i] < 0)
-        break;
-
-      if (i >= 1)
-        *os << ", ";
-
-      *os << "#" << indices[i];
-    }
-    *os << ") ";
-  }
-
-  const MonomorphicInnerMatcher inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
-};
-
-template <class InnerMatcher$for i [[, int k$i = -1]]>
-class ArgsMatcher {
- public:
-  explicit ArgsMatcher(const InnerMatcher& inner_matcher)
-      : inner_matcher_(inner_matcher) {}
-
-  template <typename ArgsTuple>
-  operator Matcher<ArgsTuple>() const {
-    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, $ks>(inner_matcher_));
-  }
-
- private:
-  const InnerMatcher inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
-};
-
-// A set of metafunctions for computing the result type of AllOf.
-// AllOf(m1, ..., mN) returns
-// AllOfResultN<decltype(m1), ..., decltype(mN)>::type.
-
-// Although AllOf isn't defined for one argument, AllOfResult1 is defined
-// to simplify the implementation.
-template <typename M1>
-struct AllOfResult1 {
-  typedef M1 type;
-};
-
-$range i 1..n
-
-$range i 2..n
-$for i [[
-$range j 2..i
-$var m = i/2
-$range k 1..m
-$range t m+1..i
-
-template <typename M1$for j [[, typename M$j]]>
-struct AllOfResult$i {
-  typedef BothOfMatcher<
-      typename AllOfResult$m<$for k, [[M$k]]>::type,
-      typename AllOfResult$(i-m)<$for t, [[M$t]]>::type
-  > type;
-};
-
-]]
-
-// A set of metafunctions for computing the result type of AnyOf.
-// AnyOf(m1, ..., mN) returns
-// AnyOfResultN<decltype(m1), ..., decltype(mN)>::type.
-
-// Although AnyOf isn't defined for one argument, AnyOfResult1 is defined
-// to simplify the implementation.
-template <typename M1>
-struct AnyOfResult1 {
-  typedef M1 type;
-};
-
-$range i 1..n
-
-$range i 2..n
-$for i [[
-$range j 2..i
-$var m = i/2
-$range k 1..m
-$range t m+1..i
-
-template <typename M1$for j [[, typename M$j]]>
-struct AnyOfResult$i {
-  typedef EitherOfMatcher<
-      typename AnyOfResult$m<$for k, [[M$k]]>::type,
-      typename AnyOfResult$(i-m)<$for t, [[M$t]]>::type
-  > type;
-};
-
-]]
-
-}  // namespace internal
-
-// 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.
-
-$range i 0..n
-$for i [[
-$range j 1..i
-template <$for j [[int k$j, ]]typename InnerMatcher>
-inline internal::ArgsMatcher<InnerMatcher$for j [[, k$j]]>
-Args(const InnerMatcher& matcher) {
-  return internal::ArgsMatcher<InnerMatcher$for j [[, k$j]]>(matcher);
-}
-
-
-]]
-// ElementsAre(e_1, e_2, ... e_n) matches an STL-style container with
-// n elements, where the i-th element in the container must
-// match the i-th argument in the list.  Each argument of
-// ElementsAre() can be either a value or a matcher.  We support up to
-// $n arguments.
-//
-// The use of DecayArray in the implementation allows ElementsAre()
-// to accept string literals, whose type is const char[N], but we
-// want to treat them as const char*.
-//
-// NOTE: Since ElementsAre() cares about the order of the elements, it
-// must not be used with containers whose elements's order is
-// undefined (e.g. hash_map).
-
-$range i 0..n
-$for i [[
-
-$range j 1..i
-
-$if i>0 [[
-
-template <$for j, [[typename T$j]]>
-]]
-
-inline internal::ElementsAreMatcher<
-    ::testing::tuple<
-$for j, [[
-
-        typename internal::DecayArray<T$j[[]]>::type]]> >
-ElementsAre($for j, [[const T$j& e$j]]) {
-  typedef ::testing::tuple<
-$for j, [[
-
-      typename internal::DecayArray<T$j[[]]>::type]]> Args;
-  return internal::ElementsAreMatcher<Args>(Args($for j, [[e$j]]));
-}
-
-]]
-
-// UnorderedElementsAre(e_1, e_2, ..., e_n) is an ElementsAre extension
-// that matches n elements in any order.  We support up to n=$n arguments.
-
-$range i 0..n
-$for i [[
-
-$range j 1..i
-
-$if i>0 [[
-
-template <$for j, [[typename T$j]]>
-]]
-
-inline internal::UnorderedElementsAreMatcher<
-    ::testing::tuple<
-$for j, [[
-
-        typename internal::DecayArray<T$j[[]]>::type]]> >
-UnorderedElementsAre($for j, [[const T$j& e$j]]) {
-  typedef ::testing::tuple<
-$for j, [[
-
-      typename internal::DecayArray<T$j[[]]>::type]]> Args;
-  return internal::UnorderedElementsAreMatcher<Args>(Args($for j, [[e$j]]));
-}
-
-]]
-
-// AllOf(m1, m2, ..., mk) matches any value that matches all of the given
-// sub-matchers.  AllOf is called fully qualified to prevent ADL from firing.
-
-$range i 2..n
-$for i [[
-$range j 1..i
-$var m = i/2
-$range k 1..m
-$range t m+1..i
-
-template <$for j, [[typename M$j]]>
-inline typename internal::AllOfResult$i<$for j, [[M$j]]>::type
-AllOf($for j, [[M$j m$j]]) {
-  return typename internal::AllOfResult$i<$for j, [[M$j]]>::type(
-      $if m == 1 [[m1]] $else [[::testing::AllOf($for k, [[m$k]])]],
-      $if m+1 == i [[m$i]] $else [[::testing::AllOf($for t, [[m$t]])]]);
-}
-
-]]
-
-// AnyOf(m1, m2, ..., mk) matches any value that matches any of the given
-// sub-matchers.  AnyOf is called fully qualified to prevent ADL from firing.
-
-$range i 2..n
-$for i [[
-$range j 1..i
-$var m = i/2
-$range k 1..m
-$range t m+1..i
-
-template <$for j, [[typename M$j]]>
-inline typename internal::AnyOfResult$i<$for j, [[M$j]]>::type
-AnyOf($for j, [[M$j m$j]]) {
-  return typename internal::AnyOfResult$i<$for j, [[M$j]]>::type(
-      $if m == 1 [[m1]] $else [[::testing::AnyOf($for k, [[m$k]])]],
-      $if m+1 == i [[m$i]] $else [[::testing::AnyOf($for t, [[m$t]])]]);
-}
-
-]]
-
-}  // namespace testing
-$$ } // This Pump meta comment fixes auto-indentation in Emacs. It will not
-$$   // show up in the generated code.
-
-
-// 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,
-//       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.  The reason is
-// that C++ doesn't yet allow function-local types to be used to
-// instantiate templates.  The up-coming C++0x standard will fix this.
-// Once that's done, we'll consider supporting using MATCHER*() inside
-// a function.
-//
-// More Information
-// ================
-//
-// To learn more about using these macros, please search for 'MATCHER'
-// on http://code.google.com/p/googlemock/wiki/CookBook.
-
-$range i 0..n
-$for i
-
-[[
-$var macro_name = [[$if i==0 [[MATCHER]] $elif i==1 [[MATCHER_P]]
-                                         $else [[MATCHER_P$i]]]]
-$var class_name = [[name##Matcher[[$if i==0 [[]] $elif i==1 [[P]]
-                                                 $else [[P$i]]]]]]
-$range j 0..i-1
-$var template = [[$if i==0 [[]] $else [[
-
-  template <$for j, [[typename p$j##_type]]>\
-]]]]
-$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
-$var impl_ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]]
-$var impl_inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]
-$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]]
-$var params = [[$for j, [[p$j]]]]
-$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]]
-$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]]
-$var param_field_decls = [[$for j
-[[
-
-      p$j##_type p$j;\
-]]]]
-$var param_field_decls2 = [[$for j
-[[
-
-    p$j##_type p$j;\
-]]]]
-
-#define $macro_name(name$for j [[, p$j]], description)\$template
-  class $class_name {\
-   public:\
-    template <typename arg_type>\
-    class gmock_Impl : public ::testing::MatcherInterface<arg_type> {\
-     public:\
-      [[$if i==1 [[explicit ]]]]gmock_Impl($impl_ctor_param_list)\
-          $impl_inits {}\
-      virtual bool MatchAndExplain(\
-          arg_type arg, ::testing::MatchResultListener* result_listener) const;\
-      virtual void DescribeTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(false);\
-      }\
-      virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\
-        *gmock_os << FormatDescription(true);\
-      }\$param_field_decls
-     private:\
-      ::testing::internal::string FormatDescription(bool negation) const {\
-        const ::testing::internal::string gmock_description = (description);\
-        if (!gmock_description.empty())\
-          return gmock_description;\
-        return ::testing::internal::FormatMatcherDescription(\
-            negation, #name, \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
-                ::testing::tuple<$for j, [[p$j##_type]]>($for j, [[p$j]])));\
-      }\
-      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
-    };\
-    template <typename arg_type>\
-    operator ::testing::Matcher<arg_type>() const {\
-      return ::testing::Matcher<arg_type>(\
-          new gmock_Impl<arg_type>($params));\
-    }\
-    [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {\
-    }\$param_field_decls2
-   private:\
-    GTEST_DISALLOW_ASSIGN_($class_name);\
-  };\$template
-  inline $class_name$param_types name($param_types_and_names) {\
-    return $class_name$param_types($params);\
-  }\$template
-  template <typename arg_type>\
-  bool $class_name$param_types::gmock_Impl<arg_type>::MatchAndExplain(\
-      arg_type arg, \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\
-          const
-]]
-
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h
deleted file mode 100644
index 4095f4d5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h
+++ /dev/null
@@ -1,397 +0,0 @@
-// This file was GENERATED by command:
-//     pump.py gmock-generated-nice-strict.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// 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, with up-to 10 arguments.  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.
-//
-// Another known limitation is that the constructors of the base mock
-// cannot have arguments passed by non-const reference, which are
-// banned by the Google C++ style guide anyway.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
-
-#include "gmock/gmock-spec-builders.h"
-#include "gmock/internal/gmock-port.h"
-
-namespace testing {
-
-template <class MockClass>
-class NiceMock : public MockClass {
- public:
-  // We don't factor out the constructor body to a common method, as
-  // we have to avoid a possible clash with members of MockClass.
-  NiceMock() {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  // C++ doesn't (yet) allow inheritance of constructors, so we have
-  // to define it for each arity.
-  template <typename A1>
-  explicit NiceMock(const A1& a1) : MockClass(a1) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-  template <typename A1, typename A2>
-  NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3,
-      const A4& a4) : MockClass(a1, a2, a3, a4) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
-      a6, a7) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
-      a2, a3, a4, a5, a6, a7, a8) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8, typename A9>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
-      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8, typename A9, typename A10>
-  NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
-      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
-    ::testing::Mock::AllowUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  virtual ~NiceMock() {
-    ::testing::Mock::UnregisterCallReaction(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
-};
-
-template <class MockClass>
-class NaggyMock : public MockClass {
- public:
-  // We don't factor out the constructor body to a common method, as
-  // we have to avoid a possible clash with members of MockClass.
-  NaggyMock() {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  // C++ doesn't (yet) allow inheritance of constructors, so we have
-  // to define it for each arity.
-  template <typename A1>
-  explicit NaggyMock(const A1& a1) : MockClass(a1) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-  template <typename A1, typename A2>
-  NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3,
-      const A4& a4) : MockClass(a1, a2, a3, a4) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
-      a6, a7) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
-      a2, a3, a4, a5, a6, a7, a8) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8, typename A9>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
-      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8, typename A9, typename A10>
-  NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
-      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
-    ::testing::Mock::WarnUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  virtual ~NaggyMock() {
-    ::testing::Mock::UnregisterCallReaction(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
-};
-
-template <class MockClass>
-class StrictMock : public MockClass {
- public:
-  // We don't factor out the constructor body to a common method, as
-  // we have to avoid a possible clash with members of MockClass.
-  StrictMock() {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  // C++ doesn't (yet) allow inheritance of constructors, so we have
-  // to define it for each arity.
-  template <typename A1>
-  explicit StrictMock(const A1& a1) : MockClass(a1) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-  template <typename A1, typename A2>
-  StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3,
-      const A4& a4) : MockClass(a1, a2, a3, a4) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
-      a6, a7) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
-      a2, a3, a4, a5, a6, a7, a8) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8, typename A9>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8,
-      const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  template <typename A1, typename A2, typename A3, typename A4, typename A5,
-      typename A6, typename A7, typename A8, typename A9, typename A10>
-  StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
-      const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
-      const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
-    ::testing::Mock::FailUninterestingCalls(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  virtual ~StrictMock() {
-    ::testing::Mock::UnregisterCallReaction(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
-};
-
-// The following specializations catch some (relatively more common)
-// user errors of nesting nice and strict mocks.  They do NOT catch
-// all possible errors.
-
-// These specializations are declared but not defined, as NiceMock,
-// NaggyMock, and StrictMock cannot be nested.
-
-template <typename MockClass>
-class NiceMock<NiceMock<MockClass> >;
-template <typename MockClass>
-class NiceMock<NaggyMock<MockClass> >;
-template <typename MockClass>
-class NiceMock<StrictMock<MockClass> >;
-
-template <typename MockClass>
-class NaggyMock<NiceMock<MockClass> >;
-template <typename MockClass>
-class NaggyMock<NaggyMock<MockClass> >;
-template <typename MockClass>
-class NaggyMock<StrictMock<MockClass> >;
-
-template <typename MockClass>
-class StrictMock<NiceMock<MockClass> >;
-template <typename MockClass>
-class StrictMock<NaggyMock<MockClass> >;
-template <typename MockClass>
-class StrictMock<StrictMock<MockClass> >;
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h.pump b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h.pump
deleted file mode 100644
index 3ee1ce7f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-generated-nice-strict.h.pump
+++ /dev/null
@@ -1,161 +0,0 @@
-$$ -*- mode: c++; -*-
-$$ This is a Pump source file.  Please use Pump to convert it to
-$$ gmock-generated-nice-strict.h.
-$$
-$var n = 10  $$ The maximum arity we support.
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// 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, with up-to $n arguments.  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.
-//
-// Another known limitation is that the constructors of the base mock
-// cannot have arguments passed by non-const reference, which are
-// banned by the Google C++ style guide anyway.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
-
-#include "gmock/gmock-spec-builders.h"
-#include "gmock/internal/gmock-port.h"
-
-namespace testing {
-
-$range kind 0..2
-$for kind [[
-
-$var clazz=[[$if kind==0 [[NiceMock]]
-             $elif kind==1 [[NaggyMock]]
-             $else [[StrictMock]]]]
-
-$var method=[[$if kind==0 [[AllowUninterestingCalls]]
-             $elif kind==1 [[WarnUninterestingCalls]]
-             $else [[FailUninterestingCalls]]]]
-
-template <class MockClass>
-class $clazz : public MockClass {
- public:
-  // We don't factor out the constructor body to a common method, as
-  // we have to avoid a possible clash with members of MockClass.
-  $clazz() {
-    ::testing::Mock::$method(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-  // C++ doesn't (yet) allow inheritance of constructors, so we have
-  // to define it for each arity.
-  template <typename A1>
-  explicit $clazz(const A1& a1) : MockClass(a1) {
-    ::testing::Mock::$method(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-$range i 2..n
-$for i [[
-$range j 1..i
-  template <$for j, [[typename A$j]]>
-  $clazz($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) {
-    ::testing::Mock::$method(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
-
-]]
-  virtual ~$clazz() {
-    ::testing::Mock::UnregisterCallReaction(
-        internal::ImplicitCast_<MockClass*>(this));
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_($clazz);
-};
-
-]]
-
-// The following specializations catch some (relatively more common)
-// user errors of nesting nice and strict mocks.  They do NOT catch
-// all possible errors.
-
-// These specializations are declared but not defined, as NiceMock,
-// NaggyMock, and StrictMock cannot be nested.
-
-template <typename MockClass>
-class NiceMock<NiceMock<MockClass> >;
-template <typename MockClass>
-class NiceMock<NaggyMock<MockClass> >;
-template <typename MockClass>
-class NiceMock<StrictMock<MockClass> >;
-
-template <typename MockClass>
-class NaggyMock<NiceMock<MockClass> >;
-template <typename MockClass>
-class NaggyMock<NaggyMock<MockClass> >;
-template <typename MockClass>
-class NaggyMock<StrictMock<MockClass> >;
-
-template <typename MockClass>
-class StrictMock<NiceMock<MockClass> >;
-template <typename MockClass>
-class StrictMock<NaggyMock<MockClass> >;
-template <typename MockClass>
-class StrictMock<StrictMock<MockClass> >;
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_NICE_STRICT_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-matchers.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-matchers.h
deleted file mode 100644
index 33b37a7a..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-matchers.h
+++ /dev/null
@@ -1,4399 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some commonly used argument matchers.  More
-// matchers can be defined by the user implementing the
-// MatcherInterface<T> interface if necessary.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
-
-#include <math.h>
-#include <algorithm>
-#include <iterator>
-#include <limits>
-#include <ostream>  // NOLINT
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "gmock/internal/gmock-internal-utils.h"
-#include "gmock/internal/gmock-port.h"
-#include "gtest/gtest.h"
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-# include <initializer_list>  // NOLINT -- must be after gtest.h
-#endif
-
-namespace testing {
-
-// To implement a matcher Foo for type T, define:
-//   1. a class FooMatcherImpl that implements the
-//      MatcherInterface<T> interface, and
-//   2. a factory function that creates a Matcher<T> object from a
-//      FooMatcherImpl*.
-//
-// The two-level delegation design makes it possible to allow a user
-// to write "v" instead of "Eq(v)" where a Matcher is expected, which
-// is impossible if we pass matchers by pointers.  It also eases
-// ownership management as Matcher objects can now be copied like
-// plain values.
-
-// MatchResultListener is an abstract class.  Its << operator can be
-// used by a matcher to explain why a value matches or doesn't match.
-//
-// TODO(wan@google.com): add method
-//   bool InterestedInWhy(bool result) const;
-// to indicate whether the listener is interested in why the match
-// result is 'result'.
-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_ != NULL)
-      *stream_ << x;
-    return *this;
-  }
-
-  // Returns the underlying ostream.
-  ::std::ostream* stream() { return stream_; }
-
-  // Returns true iff 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_ != NULL; }
-
- 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 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 iff 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 Mock) 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;
-};
-
-// A match result listener that stores the explanation in a string.
-class StringMatchResultListener : public MatchResultListener {
- public:
-  StringMatchResultListener() : MatchResultListener(&ss_) {}
-
-  // Returns the explanation accumulated so far.
-  internal::string str() const { return ss_.str(); }
-
-  // Clears the explanation accumulated so far.
-  void Clear() { ss_.str(""); }
-
- private:
-  ::std::stringstream ss_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
-};
-
-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(NULL) {}
-
- 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);
-};
-
-// 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 {
- public:
-  // Returns true iff the matcher matches x; also explains the match
-  // result to 'listener'.
-  bool MatchAndExplain(T x, MatchResultListener* listener) const {
-    return impl_->MatchAndExplain(x, listener);
-  }
-
-  // Returns true iff this matcher matches x.
-  bool Matches(T x) const {
-    DummyMatchResultListener dummy;
-    return MatchAndExplain(x, &dummy);
-  }
-
-  // Describes this matcher to an ostream.
-  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
-
-  // Describes the negation of this matcher to an ostream.
-  void DescribeNegationTo(::std::ostream* os) const {
-    impl_->DescribeNegationTo(os);
-  }
-
-  // Explains why x matches, or doesn't match, the matcher.
-  void ExplainMatchResultTo(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 {
-    return impl_.get();
-  }
-
- protected:
-  MatcherBase() {}
-
-  // Constructs a matcher from its implementation.
-  explicit MatcherBase(const MatcherInterface<T>* impl)
-      : impl_(impl) {}
-
-  virtual ~MatcherBase() {}
-
- private:
-  // shared_ptr (util/gtl/shared_ptr.h) and linked_ptr have similar
-  // interfaces.  The former dynamically allocates a chunk of memory
-  // to hold the reference count, while the latter tracks all
-  // references using a circular linked list without allocating
-  // memory.  It has been observed that linked_ptr performs better in
-  // typical scenarios.  However, shared_ptr can out-perform
-  // linked_ptr when there are many more uses of the copy constructor
-  // than the default constructor.
-  //
-  // If performance becomes a problem, we should see if using
-  // shared_ptr helps.
-  ::testing::internal::linked_ptr<const MatcherInterface<T> > impl_;
-};
-
-}  // 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 linked_ptr to const
-// MatcherInterface<T>, so copying is fairly cheap.  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<T>* impl)
-      : internal::MatcherBase<T>(impl) {}
-
-  // 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 string
-// matcher is expected.
-template <>
-class GTEST_API_ Matcher<const internal::string&>
-    : public internal::MatcherBase<const internal::string&> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<const internal::string&>* impl)
-      : internal::MatcherBase<const internal::string&>(impl) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a string object.
-  Matcher(const internal::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-};
-
-template <>
-class GTEST_API_ Matcher<internal::string>
-    : public internal::MatcherBase<internal::string> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<internal::string>* impl)
-      : internal::MatcherBase<internal::string>(impl) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a string object.
-  Matcher(const internal::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-};
-
-#if GTEST_HAS_STRING_PIECE_
-// The following two specializations allow the user to write str
-// instead of Eq(str) and "foo" instead of Eq("foo") when a StringPiece
-// matcher is expected.
-template <>
-class GTEST_API_ Matcher<const StringPiece&>
-    : public internal::MatcherBase<const StringPiece&> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<const StringPiece&>* impl)
-      : internal::MatcherBase<const StringPiece&>(impl) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a string object.
-  Matcher(const internal::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-
-  // Allows the user to pass StringPieces directly.
-  Matcher(StringPiece s);  // NOLINT
-};
-
-template <>
-class GTEST_API_ Matcher<StringPiece>
-    : public internal::MatcherBase<StringPiece> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<StringPiece>* impl)
-      : internal::MatcherBase<StringPiece>(impl) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a string object.
-  Matcher(const internal::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-
-  // Allows the user to pass StringPieces directly.
-  Matcher(StringPiece s);  // NOLINT
-};
-#endif  // GTEST_HAS_STRING_PIECE_
-
-// 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<T>(impl_));
-  }
-
- private:
-  template <typename T>
-  class MonomorphicImpl : public MatcherInterface<T> {
-   public:
-    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      impl_.DescribeTo(os);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      impl_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-      return impl_.MatchAndExplain(x, listener);
-    }
-
-   private:
-    const Impl impl_;
-
-    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
-  };
-
-  Impl impl_;
-
-  GTEST_DISALLOW_ASSIGN_(PolymorphicMatcher);
-};
-
-// Creates a matcher from its implementation.  This is easier to use
-// than the Matcher<T> constructor as it doesn't require you to
-// explicitly write the template argument, e.g.
-//
-//   MakeMatcher(foo);
-// vs
-//   Matcher<const string&>(foo);
-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);
-}
-
-// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
-// and MUST NOT BE USED IN USER CODE!!!
-namespace internal {
-
-// The MatcherCastImpl class template is a helper for implementing
-// MatcherCast().  We need this helper in order to partially
-// specialize the implementation of MatcherCast() (C++ allows
-// class/struct templates to be partially specialized, but not
-// function templates.).
-
-// This general version is used when MatcherCast()'s argument is a
-// polymorphic matcher (i.e. something that can be converted to a
-// Matcher but is not one yet; for example, Eq(value)) or a value (for
-// example, "hello").
-template <typename T, typename M>
-class MatcherCastImpl {
- public:
-  static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
-    // M can be a polymorhic 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.
-    //
-    // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a
-    // polymorphic matcher because it'll be ambiguous if T has an implicit
-    // constructor from M (this usually happens when T has an implicit
-    // constructor from any type).
-    //
-    // It won't work to unconditionally implict_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,
-        BooleanConstant<
-            internal::ImplicitlyConvertible<M, Matcher<T> >::value>());
-  }
-
- private:
-  static Matcher<T> CastImpl(const M& value, BooleanConstant<false>) {
-    // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
-    // matcher.  It must be a value then.  Use direct initialization to create
-    // a matcher.
-    return Matcher<T>(ImplicitCast_<T>(value));
-  }
-
-  static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,
-                             BooleanConstant<true>) {
-    // M is implicitly convertible to Matcher<T>, which means that either
-    // M is a polymorhpic matcher or Matcher<T> has an implicit constructor
-    // from M.  In both cases using the implicit conversion will produce a
-    // matcher.
-    //
-    // Even if T has an implicit constructor from M, it won't be called because
-    // creating Matcher<T> would require a chain of two user-defined conversions
-    // (first to create T from M and then to create Matcher<T> from T).
-    return polymorphic_matcher_or_value;
-  }
-};
-
-// This more specialized version is used when MatcherCast()'s argument
-// is already a Matcher.  This only compiles when type T can be
-// statically converted to type U.
-template <typename T, typename U>
-class MatcherCastImpl<T, Matcher<U> > {
- public:
-  static Matcher<T> Cast(const Matcher<U>& source_matcher) {
-    return Matcher<T>(new Impl(source_matcher));
-  }
-
- private:
-  class Impl : public MatcherInterface<T> {
-   public:
-    explicit Impl(const Matcher<U>& source_matcher)
-        : source_matcher_(source_matcher) {}
-
-    // We delegate the matching logic to the source matcher.
-    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-      return source_matcher_.MatchAndExplain(static_cast<U>(x), listener);
-    }
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      source_matcher_.DescribeTo(os);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      source_matcher_.DescribeNegationTo(os);
-    }
-
-   private:
-    const Matcher<U> source_matcher_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-};
-
-// This even more specialized version is used for efficiently casting
-// a matcher to its own type.
-template <typename T>
-class MatcherCastImpl<T, Matcher<T> > {
- public:
-  static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }
-};
-
-}  // namespace internal
-
-// In order to be safe and clear, casting between different matcher
-// types is done explicitly via MatcherCast<T>(m), which takes a
-// matcher m and returns a Matcher<T>.  It compiles only when T can be
-// statically converted to the argument type of m.
-template <typename T, typename M>
-inline Matcher<T> MatcherCast(const M& matcher) {
-  return internal::MatcherCastImpl<T, M>::Cast(matcher);
-}
-
-// Implements SafeMatcherCast().
-//
-// We use an intermediate class to do the actual safe casting as Nokia's
-// Symbian compiler cannot decide between
-// template <T, M> ... (M) and
-// template <T, U> ... (const Matcher<U>&)
-// for function templates but can for member function templates.
-template <typename T>
-class SafeMatcherCastImpl {
- public:
-  // This overload handles polymorphic matchers and values only since
-  // monomorphic matchers are handled by the next one.
-  template <typename M>
-  static inline Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
-    return internal::MatcherCastImpl<T, M>::Cast(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 U>
-  static inline Matcher<T> Cast(const Matcher<U>& matcher) {
-    // Enforce that T can be implicitly converted to U.
-    GTEST_COMPILE_ASSERT_((internal::ImplicitlyConvertible<T, 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_(
-        internal::is_reference<T>::value || !internal::is_reference<U>::value,
-        cannot_convert_non_referentce_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;
-    const bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
-    const 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);
-  }
-};
-
-template <typename T, typename M>
-inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher) {
-  return SafeMatcherCastImpl<T>::Cast(polymorphic_matcher);
-}
-
-// A<T>() returns a matcher that matches any value of type T.
-template <typename T>
-Matcher<T> A();
-
-// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
-// and MUST NOT BE USED IN USER CODE!!!
-namespace internal {
-
-// If the explanation is not empty, prints it to the ostream.
-inline void PrintIfNotEmpty(const internal::string& explanation,
-                            ::std::ostream* os) {
-  if (explanation != "" && os != NULL) {
-    *os << ", " << 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 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("<(") == string::npos);
-}
-
-// Matches the value against the given matcher, prints the value and explains
-// the match result to the listener. Returns the match result.
-// 'listener' must not be NULL.
-// Value cannot be passed by const reference, because some matchers take a
-// non-const argument.
-template <typename Value, typename T>
-bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
-                          MatchResultListener* listener) {
-  if (!listener->IsInterested()) {
-    // If the listener is not interested, we do not need to construct the
-    // inner explanation.
-    return matcher.Matches(value);
-  }
-
-  StringMatchResultListener inner_listener;
-  const bool match = matcher.MatchAndExplain(value, &inner_listener);
-
-  UniversalPrint(value, listener->stream());
-#if GTEST_HAS_RTTI
-  const string& type_name = GetTypeName<Value>();
-  if (IsReadableTypeName(type_name))
-    *listener->stream() << " (of type " << type_name << ")";
-#endif
-  PrintIfNotEmpty(inner_listener.str(), listener->stream());
-
-  return match;
-}
-
-// An internal helper class for doing compile-time loop on a tuple's
-// fields.
-template <size_t N>
-class TuplePrefix {
- public:
-  // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true
-  // iff 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)
-        && get<N - 1>(matcher_tuple).Matches(get<N - 1>(value_tuple));
-  }
-
-  // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
-  // describes failures in matching the first N fields of matchers
-  // against the first N fields of values.  If there is no failure,
-  // nothing will be streamed to os.
-  template <typename MatcherTuple, typename ValueTuple>
-  static void ExplainMatchFailuresTo(const MatcherTuple& matchers,
-                                     const ValueTuple& values,
-                                     ::std::ostream* os) {
-    // First, describes failures in the first N - 1 fields.
-    TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os);
-
-    // Then describes the failure (if any) in the (N - 1)-th (0-based)
-    // field.
-    typename tuple_element<N - 1, MatcherTuple>::type matcher =
-        get<N - 1>(matchers);
-    typedef typename tuple_element<N - 1, ValueTuple>::type Value;
-    Value value = get<N - 1>(values);
-    StringMatchResultListener listener;
-    if (!matcher.MatchAndExplain(value, &listener)) {
-      // TODO(wan): include in the message the name of the parameter
-      // as used in MOCK_METHOD*() when possible.
-      *os << "  Expected arg #" << N - 1 << ": ";
-      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
-      // isn't interesting to the user most of the time.  The
-      // matcher's MatchAndExplain() method handles the case when
-      // the address is interesting.
-      internal::UniversalPrint(value, os);
-      PrintIfNotEmpty(listener.str(), os);
-      *os << "\n";
-    }
-  }
-};
-
-// The base case.
-template <>
-class TuplePrefix<0> {
- public:
-  template <typename MatcherTuple, typename ValueTuple>
-  static bool Matches(const MatcherTuple& /* matcher_tuple */,
-                      const ValueTuple& /* value_tuple */) {
-    return true;
-  }
-
-  template <typename MatcherTuple, typename ValueTuple>
-  static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */,
-                                     const ValueTuple& /* values */,
-                                     ::std::ostream* /* os */) {}
-};
-
-// TupleMatches(matcher_tuple, value_tuple) returns true iff 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.
-template <typename MatcherTuple, typename ValueTuple>
-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_(tuple_size<MatcherTuple>::value ==
-                        tuple_size<ValueTuple>::value,
-                        matcher_and_value_have_different_numbers_of_fields);
-  return TuplePrefix<tuple_size<ValueTuple>::value>::
-      Matches(matcher_tuple, value_tuple);
-}
-
-// Describes failures in matching matchers against values.  If there
-// is no failure, nothing will be streamed to os.
-template <typename MatcherTuple, typename ValueTuple>
-void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
-                                const ValueTuple& values,
-                                ::std::ostream* os) {
-  TuplePrefix<tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
-      matchers, values, os);
-}
-
-// TransformTupleValues and its helper.
-//
-// TransformTupleValuesHelper hides the internal machinery that
-// TransformTupleValues uses to implement a tuple traversal.
-template <typename Tuple, typename Func, typename OutIter>
-class TransformTupleValuesHelper {
- private:
-  typedef ::testing::tuple_size<Tuple> TupleSize;
-
- public:
-  // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'.
-  // Returns the final value of 'out' in case the caller needs it.
-  static OutIter Run(Func f, const Tuple& t, OutIter out) {
-    return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out);
-  }
-
- private:
-  template <typename Tup, size_t kRemainingSize>
-  struct IterateOverTuple {
-    OutIter operator() (Func f, const Tup& t, OutIter out) const {
-      *out++ = f(::testing::get<TupleSize::value - kRemainingSize>(t));
-      return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
-    }
-  };
-  template <typename Tup>
-  struct IterateOverTuple<Tup, 0> {
-    OutIter operator() (Func /* f */, const Tup& /* t */, OutIter out) const {
-      return out;
-    }
-  };
-};
-
-// Successively invokes 'f(element)' on each element of the tuple 't',
-// appending each result to the 'out' iterator. Returns the final value
-// of 'out'.
-template <typename Tuple, typename Func, typename OutIter>
-OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) {
-  return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);
-}
-
-// Implements A<T>().
-template <typename T>
-class AnyMatcherImpl : public MatcherInterface<T> {
- public:
-  virtual bool MatchAndExplain(
-      T /* x */, MatchResultListener* /* listener */) const { return true; }
-  virtual void DescribeTo(::std::ostream* os) const { *os << "is anything"; }
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    // This is mostly for completeness' safe, 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";
-  }
-};
-
-// 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:
-  template <typename T>
-  operator Matcher<T>() const { return A<T>(); }
-};
-
-// 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) {}
-  template <typename Lhs>
-  operator Matcher<Lhs>() const {
-    return MakeMatcher(new Impl<Lhs>(rhs_));
-  }
-
- private:
-  template <typename Lhs>
-  class Impl : public MatcherInterface<Lhs> {
-   public:
-    explicit Impl(const Rhs& rhs) : rhs_(rhs) {}
-    virtual bool MatchAndExplain(
-        Lhs lhs, MatchResultListener* /* listener */) const {
-      return Op()(lhs, rhs_);
-    }
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << D::Desc() << " ";
-      UniversalPrint(rhs_, os);
-    }
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << D::NegatedDesc() <<  " ";
-      UniversalPrint(rhs_, os);
-    }
-   private:
-    Rhs rhs_;
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-  Rhs rhs_;
-  GTEST_DISALLOW_ASSIGN_(ComparisonBase);
-};
-
-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 >="; }
-};
-
-// Implements the polymorphic IsNull() matcher, which matches any raw or smart
-// pointer that is NULL.
-class IsNullMatcher {
- public:
-  template <typename Pointer>
-  bool MatchAndExplain(const Pointer& p,
-                       MatchResultListener* /* listener */) const {
-#if GTEST_LANG_CXX11
-    return p == nullptr;
-#else  // GTEST_LANG_CXX11
-    return GetRawPointer(p) == NULL;
-#endif  // GTEST_LANG_CXX11
-  }
-
-  void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "isn't NULL";
-  }
-};
-
-// Implements the polymorphic NotNull() matcher, which matches any raw or smart
-// pointer that is not NULL.
-class NotNullMatcher {
- public:
-  template <typename Pointer>
-  bool MatchAndExplain(const Pointer& p,
-                       MatchResultListener* /* listener */) const {
-#if GTEST_LANG_CXX11
-    return p != nullptr;
-#else  // GTEST_LANG_CXX11
-    return GetRawPointer(p) != NULL;
-#endif  // GTEST_LANG_CXX11
-  }
-
-  void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is NULL";
-  }
-};
-
-// Ref(variable) matches any argument that is a reference to
-// 'variable'.  This matcher is polymorphic as it can match any
-// super type of the type of 'variable'.
-//
-// The RefMatcher template class implements Ref(variable).  It can
-// only be instantiated with a reference type.  This prevents a user
-// from mistakenly using Ref(x) to match a non-reference function
-// argument.  For example, the following will righteously cause a
-// compiler error:
-//
-//   int n;
-//   Matcher<int> m1 = Ref(n);   // This won't compile.
-//   Matcher<int&> m2 = Ref(n);  // This will compile.
-template <typename T>
-class RefMatcher;
-
-template <typename T>
-class RefMatcher<T&> {
-  // Google Mock is a generic framework and thus needs to support
-  // mocking any function types, including those that take non-const
-  // reference arguments.  Therefore the template parameter T (and
-  // Super below) can be instantiated to either a const type or a
-  // non-const type.
- public:
-  // RefMatcher() takes a T& instead of const T&, as we want the
-  // compiler to catch using Ref(const_value) as a matcher for a
-  // non-const reference.
-  explicit RefMatcher(T& x) : object_(x) {}  // NOLINT
-
-  template <typename Super>
-  operator Matcher<Super&>() const {
-    // By passing object_ (type T&) to Impl(), which expects a Super&,
-    // we make sure that Super is a super type of T.  In particular,
-    // this catches using Ref(const_value) as a matcher for a
-    // non-const reference, as you cannot implicitly convert a const
-    // reference to a non-const reference.
-    return MakeMatcher(new Impl<Super>(object_));
-  }
-
- private:
-  template <typename Super>
-  class Impl : public MatcherInterface<Super&> {
-   public:
-    explicit Impl(Super& x) : object_(x) {}  // NOLINT
-
-    // MatchAndExplain() takes a Super& (as opposed to const Super&)
-    // in order to match the interface MatcherInterface<Super&>.
-    virtual bool MatchAndExplain(
-        Super& x, MatchResultListener* listener) const {
-      *listener << "which is located @" << static_cast<const void*>(&x);
-      return &x == &object_;
-    }
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "references the variable ";
-      UniversalPrinter<Super&>::Print(object_, os);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "does not reference the variable ";
-      UniversalPrinter<Super&>::Print(object_, os);
-    }
-
-   private:
-    const Super& object_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  T& object_;
-
-  GTEST_DISALLOW_ASSIGN_(RefMatcher);
-};
-
-// Polymorphic helper functions for narrow and wide string matchers.
-inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
-  return String::CaseInsensitiveCStringEquals(lhs, rhs);
-}
-
-inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
-                                         const wchar_t* rhs) {
-  return String::CaseInsensitiveWideCStringEquals(lhs, rhs);
-}
-
-// String comparison for narrow or wide strings that can have embedded NUL
-// characters.
-template <typename StringType>
-bool CaseInsensitiveStringEquals(const StringType& s1,
-                                 const StringType& s2) {
-  // Are the heads equal?
-  if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {
-    return false;
-  }
-
-  // Skip the equal heads.
-  const typename StringType::value_type nul = 0;
-  const size_t i1 = s1.find(nul), i2 = s2.find(nul);
-
-  // Are we at the end of either s1 or s2?
-  if (i1 == StringType::npos || i2 == StringType::npos) {
-    return i1 == i2;
-  }
-
-  // Are the tails equal?
-  return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1));
-}
-
-// String matchers.
-
-// Implements equality-based string matchers like StrEq, StrCaseNe, and etc.
-template <typename StringType>
-class StrEqualityMatcher {
- public:
-  StrEqualityMatcher(const StringType& str, bool expect_eq,
-                     bool case_sensitive)
-      : string_(str), expect_eq_(expect_eq), case_sensitive_(case_sensitive) {}
-
-  // Accepts pointer types, particularly:
-  //   const char*
-  //   char*
-  //   const wchar_t*
-  //   wchar_t*
-  template <typename CharType>
-  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    if (s == NULL) {
-      return !expect_eq_;
-    }
-    return MatchAndExplain(StringType(s), listener);
-  }
-
-  // Matches anything that can convert to StringType.
-  //
-  // This is a template, not just a plain function with const StringType&,
-  // because StringPiece has some interfering non-explicit constructors.
-  template <typename MatcheeStringType>
-  bool MatchAndExplain(const MatcheeStringType& s,
-                       MatchResultListener* /* listener */) const {
-    const StringType& s2(s);
-    const bool eq = case_sensitive_ ? s2 == string_ :
-        CaseInsensitiveStringEquals(s2, string_);
-    return expect_eq_ == eq;
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    DescribeToHelper(expect_eq_, os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    DescribeToHelper(!expect_eq_, os);
-  }
-
- private:
-  void DescribeToHelper(bool expect_eq, ::std::ostream* os) const {
-    *os << (expect_eq ? "is " : "isn't ");
-    *os << "equal to ";
-    if (!case_sensitive_) {
-      *os << "(ignoring case) ";
-    }
-    UniversalPrint(string_, os);
-  }
-
-  const StringType string_;
-  const bool expect_eq_;
-  const bool case_sensitive_;
-
-  GTEST_DISALLOW_ASSIGN_(StrEqualityMatcher);
-};
-
-// Implements the polymorphic HasSubstr(substring) matcher, which
-// can be used as a Matcher<T> as long as T can be converted to a
-// string.
-template <typename StringType>
-class HasSubstrMatcher {
- public:
-  explicit HasSubstrMatcher(const StringType& substring)
-      : substring_(substring) {}
-
-  // Accepts pointer types, particularly:
-  //   const char*
-  //   char*
-  //   const wchar_t*
-  //   wchar_t*
-  template <typename CharType>
-  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != NULL && MatchAndExplain(StringType(s), listener);
-  }
-
-  // Matches anything that can convert to StringType.
-  //
-  // This is a template, not just a plain function with const StringType&,
-  // because StringPiece has some interfering non-explicit constructors.
-  template <typename MatcheeStringType>
-  bool MatchAndExplain(const MatcheeStringType& s,
-                       MatchResultListener* /* listener */) const {
-    const StringType& s2(s);
-    return s2.find(substring_) != StringType::npos;
-  }
-
-  // Describes what this matcher matches.
-  void DescribeTo(::std::ostream* os) const {
-    *os << "has substring ";
-    UniversalPrint(substring_, os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "has no substring ";
-    UniversalPrint(substring_, os);
-  }
-
- private:
-  const StringType substring_;
-
-  GTEST_DISALLOW_ASSIGN_(HasSubstrMatcher);
-};
-
-// Implements the polymorphic StartsWith(substring) matcher, which
-// can be used as a Matcher<T> as long as T can be converted to a
-// string.
-template <typename StringType>
-class StartsWithMatcher {
- public:
-  explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {
-  }
-
-  // Accepts pointer types, particularly:
-  //   const char*
-  //   char*
-  //   const wchar_t*
-  //   wchar_t*
-  template <typename CharType>
-  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != NULL && MatchAndExplain(StringType(s), listener);
-  }
-
-  // Matches anything that can convert to StringType.
-  //
-  // This is a template, not just a plain function with const StringType&,
-  // because StringPiece has some interfering non-explicit constructors.
-  template <typename MatcheeStringType>
-  bool MatchAndExplain(const MatcheeStringType& s,
-                       MatchResultListener* /* listener */) const {
-    const StringType& s2(s);
-    return s2.length() >= prefix_.length() &&
-        s2.substr(0, prefix_.length()) == prefix_;
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << "starts with ";
-    UniversalPrint(prefix_, os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't start with ";
-    UniversalPrint(prefix_, os);
-  }
-
- private:
-  const StringType prefix_;
-
-  GTEST_DISALLOW_ASSIGN_(StartsWithMatcher);
-};
-
-// Implements the polymorphic EndsWith(substring) matcher, which
-// can be used as a Matcher<T> as long as T can be converted to a
-// string.
-template <typename StringType>
-class EndsWithMatcher {
- public:
-  explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}
-
-  // Accepts pointer types, particularly:
-  //   const char*
-  //   char*
-  //   const wchar_t*
-  //   wchar_t*
-  template <typename CharType>
-  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != NULL && MatchAndExplain(StringType(s), listener);
-  }
-
-  // Matches anything that can convert to StringType.
-  //
-  // This is a template, not just a plain function with const StringType&,
-  // because StringPiece has some interfering non-explicit constructors.
-  template <typename MatcheeStringType>
-  bool MatchAndExplain(const MatcheeStringType& s,
-                       MatchResultListener* /* listener */) const {
-    const StringType& s2(s);
-    return s2.length() >= suffix_.length() &&
-        s2.substr(s2.length() - suffix_.length()) == suffix_;
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << "ends with ";
-    UniversalPrint(suffix_, os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't end with ";
-    UniversalPrint(suffix_, os);
-  }
-
- private:
-  const StringType suffix_;
-
-  GTEST_DISALLOW_ASSIGN_(EndsWithMatcher);
-};
-
-// 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) {}
-
-  // Accepts pointer types, particularly:
-  //   const char*
-  //   char*
-  //   const wchar_t*
-  //   wchar_t*
-  template <typename CharType>
-  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != NULL && MatchAndExplain(internal::string(s), listener);
-  }
-
-  // Matches anything that can convert to internal::string.
-  //
-  // This is a template, not just a plain function with const internal::string&,
-  // because StringPiece has some interfering non-explicit constructors.
-  template <class MatcheeStringType>
-  bool MatchAndExplain(const MatcheeStringType& s,
-                       MatchResultListener* /* listener */) const {
-    const internal::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<internal::string>::Print(regex_->pattern(), os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't " << (full_match_ ? "match" : "contain")
-        << " regular expression ";
-    UniversalPrinter<internal::string>::Print(regex_->pattern(), os);
-  }
-
- private:
-  const internal::linked_ptr<const RE> regex_;
-  const bool full_match_;
-
-  GTEST_DISALLOW_ASSIGN_(MatchesRegexMatcher);
-};
-
-// Implements a matcher that compares the two fields of a 2-tuple
-// using one of the ==, <=, <, etc, operators.  The two fields being
-// compared don't have to have the same type.
-//
-// The matcher defined here is polymorphic (for example, Eq() can be
-// used to match a tuple<int, short>, a 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< ::testing::tuple<T1, T2> >() const {
-    return MakeMatcher(new Impl< ::testing::tuple<T1, T2> >);
-  }
-  template <typename T1, typename T2>
-  operator Matcher<const ::testing::tuple<T1, T2>&>() const {
-    return MakeMatcher(new Impl<const ::testing::tuple<T1, T2>&>);
-  }
-
- private:
-  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
-    return os << D::Desc();
-  }
-
-  template <typename Tuple>
-  class Impl : public MatcherInterface<Tuple> {
-   public:
-    virtual bool MatchAndExplain(
-        Tuple args,
-        MatchResultListener* /* listener */) const {
-      return Op()(::testing::get<0>(args), ::testing::get<1>(args));
-    }
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "are " << GetDesc;
-    }
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "aren't " << GetDesc;
-    }
-  };
-};
-
-class Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> {
- public:
-  static const char* Desc() { return "an equal pair"; }
-};
-class Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> {
- public:
-  static const char* Desc() { return "an unequal pair"; }
-};
-class Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> {
- public:
-  static const char* Desc() { return "a pair where the first < the second"; }
-};
-class Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> {
- public:
-  static const char* Desc() { return "a pair where the first > the second"; }
-};
-class Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> {
- public:
-  static const char* Desc() { return "a pair where the first <= the second"; }
-};
-class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> {
- public:
-  static const char* Desc() { return "a pair where the first >= the second"; }
-};
-
-// Implements the Not(...) matcher for a particular argument type T.
-// We do not nest it inside the NotMatcher class template, as that
-// will prevent different instantiations of NotMatcher from sharing
-// the same NotMatcherImpl<T> class.
-template <typename T>
-class NotMatcherImpl : public MatcherInterface<T> {
- public:
-  explicit NotMatcherImpl(const Matcher<T>& matcher)
-      : matcher_(matcher) {}
-
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-    return !matcher_.MatchAndExplain(x, listener);
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    matcher_.DescribeNegationTo(os);
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    matcher_.DescribeTo(os);
-  }
-
- private:
-  const Matcher<T> matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(NotMatcherImpl);
-};
-
-// Implements the Not(m) matcher, which matches a value that doesn't
-// match matcher m.
-template <typename InnerMatcher>
-class NotMatcher {
- public:
-  explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {}
-
-  // This template type conversion operator allows Not(m) to be used
-  // to match any type m can match.
-  template <typename T>
-  operator Matcher<T>() const {
-    return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
-  }
-
- private:
-  InnerMatcher matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(NotMatcher);
-};
-
-// Implements the AllOf(m1, m2) matcher for a particular argument type
-// T. We do not nest it inside the BothOfMatcher class template, as
-// that will prevent different instantiations of BothOfMatcher from
-// sharing the same BothOfMatcherImpl<T> class.
-template <typename T>
-class BothOfMatcherImpl : public MatcherInterface<T> {
- public:
-  BothOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2)
-      : matcher1_(matcher1), matcher2_(matcher2) {}
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "(";
-    matcher1_.DescribeTo(os);
-    *os << ") and (";
-    matcher2_.DescribeTo(os);
-    *os << ")";
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "(";
-    matcher1_.DescribeNegationTo(os);
-    *os << ") or (";
-    matcher2_.DescribeNegationTo(os);
-    *os << ")";
-  }
-
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-    // If either matcher1_ or matcher2_ doesn't match x, we only need
-    // to explain why one of them fails.
-    StringMatchResultListener listener1;
-    if (!matcher1_.MatchAndExplain(x, &listener1)) {
-      *listener << listener1.str();
-      return false;
-    }
-
-    StringMatchResultListener listener2;
-    if (!matcher2_.MatchAndExplain(x, &listener2)) {
-      *listener << listener2.str();
-      return false;
-    }
-
-    // Otherwise we need to explain why *both* of them match.
-    const internal::string s1 = listener1.str();
-    const internal::string s2 = listener2.str();
-
-    if (s1 == "") {
-      *listener << s2;
-    } else {
-      *listener << s1;
-      if (s2 != "") {
-        *listener << ", and " << s2;
-      }
-    }
-    return true;
-  }
-
- private:
-  const Matcher<T> matcher1_;
-  const Matcher<T> matcher2_;
-
-  GTEST_DISALLOW_ASSIGN_(BothOfMatcherImpl);
-};
-
-#if GTEST_LANG_CXX11
-// MatcherList provides mechanisms for storing a variable number of matchers in
-// a list structure (ListType) and creating a combining matcher from such a
-// list.
-// The template is defined recursively using the following template paramters:
-//   * kSize is the length of the MatcherList.
-//   * Head is the type of the first matcher of the list.
-//   * Tail denotes the types of the remaining matchers of the list.
-template <int kSize, typename Head, typename... Tail>
-struct MatcherList {
-  typedef MatcherList<kSize - 1, Tail...> MatcherListTail;
-  typedef ::std::pair<Head, typename MatcherListTail::ListType> ListType;
-
-  // BuildList stores variadic type values in a nested pair structure.
-  // Example:
-  // MatcherList<3, int, string, float>::BuildList(5, "foo", 2.0) will return
-  // the corresponding result of type pair<int, pair<string, float>>.
-  static ListType BuildList(const Head& matcher, const Tail&... tail) {
-    return ListType(matcher, MatcherListTail::BuildList(tail...));
-  }
-
-  // CreateMatcher<T> creates a Matcher<T> from a given list of matchers (built
-  // by BuildList()). CombiningMatcher<T> is used to combine the matchers of the
-  // list. CombiningMatcher<T> must implement MatcherInterface<T> and have a
-  // constructor taking two Matcher<T>s as input.
-  template <typename T, template <typename /* T */> class CombiningMatcher>
-  static Matcher<T> CreateMatcher(const ListType& matchers) {
-    return Matcher<T>(new CombiningMatcher<T>(
-        SafeMatcherCast<T>(matchers.first),
-        MatcherListTail::template CreateMatcher<T, CombiningMatcher>(
-            matchers.second)));
-  }
-};
-
-// The following defines the base case for the recursive definition of
-// MatcherList.
-template <typename Matcher1, typename Matcher2>
-struct MatcherList<2, Matcher1, Matcher2> {
-  typedef ::std::pair<Matcher1, Matcher2> ListType;
-
-  static ListType BuildList(const Matcher1& matcher1,
-                            const Matcher2& matcher2) {
-    return ::std::pair<Matcher1, Matcher2>(matcher1, matcher2);
-  }
-
-  template <typename T, template <typename /* T */> class CombiningMatcher>
-  static Matcher<T> CreateMatcher(const ListType& matchers) {
-    return Matcher<T>(new CombiningMatcher<T>(
-        SafeMatcherCast<T>(matchers.first),
-        SafeMatcherCast<T>(matchers.second)));
-  }
-};
-
-// VariadicMatcher is used for the variadic implementation of
-// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...).
-// CombiningMatcher<T> is used to recursively combine the provided matchers
-// (of type Args...).
-template <template <typename T> class CombiningMatcher, typename... Args>
-class VariadicMatcher {
- public:
-  VariadicMatcher(const Args&... matchers)  // NOLINT
-      : matchers_(MatcherListType::BuildList(matchers...)) {}
-
-  // 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 {
-    return MatcherListType::template CreateMatcher<T, CombiningMatcher>(
-        matchers_);
-  }
-
- private:
-  typedef MatcherList<sizeof...(Args), Args...> MatcherListType;
-
-  const typename MatcherListType::ListType matchers_;
-
-  GTEST_DISALLOW_ASSIGN_(VariadicMatcher);
-};
-
-template <typename... Args>
-using AllOfMatcher = VariadicMatcher<BothOfMatcherImpl, Args...>;
-
-#endif  // GTEST_LANG_CXX11
-
-// Used for implementing the AllOf(m_1, ..., m_n) matcher, which
-// matches a value that matches all of the matchers m_1, ..., and m_n.
-template <typename Matcher1, typename Matcher2>
-class BothOfMatcher {
- public:
-  BothOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
-      : matcher1_(matcher1), matcher2_(matcher2) {}
-
-  // This template type conversion operator allows a
-  // BothOfMatcher<Matcher1, Matcher2> object to match any type that
-  // both Matcher1 and Matcher2 can match.
-  template <typename T>
-  operator Matcher<T>() const {
-    return Matcher<T>(new BothOfMatcherImpl<T>(SafeMatcherCast<T>(matcher1_),
-                                               SafeMatcherCast<T>(matcher2_)));
-  }
-
- private:
-  Matcher1 matcher1_;
-  Matcher2 matcher2_;
-
-  GTEST_DISALLOW_ASSIGN_(BothOfMatcher);
-};
-
-// 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 EitherOfMatcherImpl : public MatcherInterface<T> {
- public:
-  EitherOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2)
-      : matcher1_(matcher1), matcher2_(matcher2) {}
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "(";
-    matcher1_.DescribeTo(os);
-    *os << ") or (";
-    matcher2_.DescribeTo(os);
-    *os << ")";
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "(";
-    matcher1_.DescribeNegationTo(os);
-    *os << ") and (";
-    matcher2_.DescribeNegationTo(os);
-    *os << ")";
-  }
-
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-    // If either matcher1_ or matcher2_ matches x, we just need to
-    // explain why *one* of them matches.
-    StringMatchResultListener listener1;
-    if (matcher1_.MatchAndExplain(x, &listener1)) {
-      *listener << listener1.str();
-      return true;
-    }
-
-    StringMatchResultListener listener2;
-    if (matcher2_.MatchAndExplain(x, &listener2)) {
-      *listener << listener2.str();
-      return true;
-    }
-
-    // Otherwise we need to explain why *both* of them fail.
-    const internal::string s1 = listener1.str();
-    const internal::string s2 = listener2.str();
-
-    if (s1 == "") {
-      *listener << s2;
-    } else {
-      *listener << s1;
-      if (s2 != "") {
-        *listener << ", and " << s2;
-      }
-    }
-    return false;
-  }
-
- private:
-  const Matcher<T> matcher1_;
-  const Matcher<T> matcher2_;
-
-  GTEST_DISALLOW_ASSIGN_(EitherOfMatcherImpl);
-};
-
-#if GTEST_LANG_CXX11
-// AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...).
-template <typename... Args>
-using AnyOfMatcher = VariadicMatcher<EitherOfMatcherImpl, Args...>;
-
-#endif  // GTEST_LANG_CXX11
-
-// Used for implementing the AnyOf(m_1, ..., m_n) matcher, which
-// matches a value that matches at least one of the matchers m_1, ...,
-// and m_n.
-template <typename Matcher1, typename Matcher2>
-class EitherOfMatcher {
- public:
-  EitherOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
-      : matcher1_(matcher1), matcher2_(matcher2) {}
-
-  // This template type conversion operator allows a
-  // EitherOfMatcher<Matcher1, Matcher2> object to match any type that
-  // both Matcher1 and Matcher2 can match.
-  template <typename T>
-  operator Matcher<T>() const {
-    return Matcher<T>(new EitherOfMatcherImpl<T>(
-        SafeMatcherCast<T>(matcher1_), SafeMatcherCast<T>(matcher2_)));
-  }
-
- private:
-  Matcher1 matcher1_;
-  Matcher2 matcher2_;
-
-  GTEST_DISALLOW_ASSIGN_(EitherOfMatcher);
-};
-
-// Used for implementing Truly(pred), which turns a predicate into a
-// matcher.
-template <typename Predicate>
-class TrulyMatcher {
- public:
-  explicit TrulyMatcher(Predicate pred) : predicate_(pred) {}
-
-  // This method template allows Truly(pred) to be used as a matcher
-  // for type T where T is the argument type of predicate 'pred'.  The
-  // argument is passed by reference as the predicate may be
-  // interested in the address of the argument.
-  template <typename T>
-  bool MatchAndExplain(T& x,  // NOLINT
-                       MatchResultListener* /* listener */) const {
-    // Without the if-statement, MSVC sometimes warns about converting
-    // a value to bool (warning 4800).
-    //
-    // We cannot write 'return !!predicate_(x);' as that doesn't work
-    // when predicate_(x) returns a class convertible to bool but
-    // having no operator!().
-    if (predicate_(x))
-      return true;
-    return false;
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << "satisfies the given predicate";
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't satisfy the given predicate";
-  }
-
- private:
-  Predicate predicate_;
-
-  GTEST_DISALLOW_ASSIGN_(TrulyMatcher);
-};
-
-// Used for implementing Matches(matcher), which turns a matcher into
-// a predicate.
-template <typename M>
-class MatcherAsPredicate {
- public:
-  explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {}
-
-  // This template operator() allows Matches(m) to be used as a
-  // predicate on type T where m is a matcher on type T.
-  //
-  // The argument x is passed by reference instead of by value, as
-  // some matcher may be interested in its address (e.g. as in
-  // Matches(Ref(n))(x)).
-  template <typename T>
-  bool operator()(const T& x) const {
-    // We let matcher_ commit to a particular type here instead of
-    // when the MatcherAsPredicate object was constructed.  This
-    // allows us to write Matches(m) where m is a polymorphic matcher
-    // (e.g. Eq(5)).
-    //
-    // If we write Matcher<T>(matcher_).Matches(x) here, it won't
-    // compile when matcher_ has type Matcher<const T&>; if we write
-    // Matcher<const T&>(matcher_).Matches(x) here, it won't compile
-    // when matcher_ has type Matcher<T>; if we just write
-    // matcher_.Matches(x), it won't compile when matcher_ is
-    // polymorphic, e.g. Eq(5).
-    //
-    // MatcherCast<const T&>() is necessary for making the code work
-    // in all of the above situations.
-    return MatcherCast<const T&>(matcher_).Matches(x);
-  }
-
- private:
-  M matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(MatcherAsPredicate);
-};
-
-// For implementing ASSERT_THAT() and EXPECT_THAT().  The template
-// argument M must be a type that can be converted to a matcher.
-template <typename M>
-class PredicateFormatterFromMatcher {
- public:
-  explicit PredicateFormatterFromMatcher(M m) : matcher_(internal::move(m)) {}
-
-  // This template () operator allows a PredicateFormatterFromMatcher
-  // object to act as a predicate-formatter suitable for using with
-  // Google Test's EXPECT_PRED_FORMAT1() macro.
-  template <typename T>
-  AssertionResult operator()(const char* value_text, const T& x) const {
-    // We convert matcher_ to a Matcher<const T&> *now* instead of
-    // when the PredicateFormatterFromMatcher object was constructed,
-    // as matcher_ may be polymorphic (e.g. NotNull()) and we won't
-    // know which type to instantiate it to until we actually see the
-    // type of x here.
-    //
-    // We write SafeMatcherCast<const T&>(matcher_) instead of
-    // Matcher<const T&>(matcher_), as the latter won't compile when
-    // matcher_ has type Matcher<T> (e.g. An<int>()).
-    // 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_);
-    StringMatchResultListener listener;
-    if (MatchPrintAndExplain(x, matcher, &listener))
-      return AssertionSuccess();
-
-    ::std::stringstream ss;
-    ss << "Value of: " << value_text << "\n"
-       << "Expected: ";
-    matcher.DescribeTo(&ss);
-    ss << "\n  Actual: " << listener.str();
-    return AssertionFailure() << ss.str();
-  }
-
- private:
-  const M matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(PredicateFormatterFromMatcher);
-};
-
-// A helper function for converting a matcher to a predicate-formatter
-// without the user needing to explicitly write the type.  This is
-// used for implementing ASSERT_THAT() and EXPECT_THAT().
-// Implementation detail: 'matcher' is received by-value to force decaying.
-template <typename M>
-inline PredicateFormatterFromMatcher<M>
-MakePredicateFormatterFromMatcher(M matcher) {
-  return PredicateFormatterFromMatcher<M>(internal::move(matcher));
-}
-
-// 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
-// FloatType being either float or double.
-template <typename FloatType>
-class FloatingEqMatcher {
- public:
-  // Constructor for FloatingEqMatcher.
-  // The matcher's input will be compared with expected.  The matcher treats two
-  // NANs as equal if nan_eq_nan is true.  Otherwise, under IEEE standards,
-  // equality comparisons between NANs will always return false.  We specify a
-  // negative max_abs_error_ term to indicate that ULP-based approximation will
-  // be used for comparison.
-  FloatingEqMatcher(FloatType expected, bool nan_eq_nan) :
-    expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {
-  }
-
-  // Constructor that supports a user-specified max_abs_error that will be used
-  // for comparison instead of ULP-based approximation.  The max absolute
-  // should be non-negative.
-  FloatingEqMatcher(FloatType expected, bool nan_eq_nan,
-                    FloatType max_abs_error)
-      : expected_(expected),
-        nan_eq_nan_(nan_eq_nan),
-        max_abs_error_(max_abs_error) {
-    GTEST_CHECK_(max_abs_error >= 0)
-        << ", where max_abs_error is" << max_abs_error;
-  }
-
-  // Implements floating point equality matcher as a Matcher<T>.
-  template <typename T>
-  class Impl : public MatcherInterface<T> {
-   public:
-    Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error)
-        : expected_(expected),
-          nan_eq_nan_(nan_eq_nan),
-          max_abs_error_(max_abs_error) {}
-
-    virtual bool MatchAndExplain(T value,
-                                 MatchResultListener* listener) const {
-      const FloatingPoint<FloatType> actual(value), expected(expected_);
-
-      // Compares NaNs first, if nan_eq_nan_ is true.
-      if (actual.is_nan() || expected.is_nan()) {
-        if (actual.is_nan() && expected.is_nan()) {
-          return nan_eq_nan_;
-        }
-        // One is nan; the other is not nan.
-        return false;
-      }
-      if (HasMaxAbsError()) {
-        // We perform an equality check so that inf will match inf, regardless
-        // of error bounds.  If the result of value - expected_ would result in
-        // overflow or if either value is inf, the default result is infinity,
-        // which should only match if max_abs_error_ is also infinity.
-        if (value == expected_) {
-          return true;
-        }
-
-        const FloatType diff = value - expected_;
-        if (fabs(diff) <= max_abs_error_) {
-          return true;
-        }
-
-        if (listener->IsInterested()) {
-          *listener << "which is " << diff << " from " << expected_;
-        }
-        return false;
-      } else {
-        return actual.AlmostEquals(expected);
-      }
-    }
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      // os->precision() returns the previously set precision, which we
-      // store to restore the ostream to its original configuration
-      // after outputting.
-      const ::std::streamsize old_precision = os->precision(
-          ::std::numeric_limits<FloatType>::digits10 + 2);
-      if (FloatingPoint<FloatType>(expected_).is_nan()) {
-        if (nan_eq_nan_) {
-          *os << "is NaN";
-        } else {
-          *os << "never matches";
-        }
-      } else {
-        *os << "is approximately " << expected_;
-        if (HasMaxAbsError()) {
-          *os << " (absolute error <= " << max_abs_error_ << ")";
-        }
-      }
-      os->precision(old_precision);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      // As before, get original precision.
-      const ::std::streamsize old_precision = os->precision(
-          ::std::numeric_limits<FloatType>::digits10 + 2);
-      if (FloatingPoint<FloatType>(expected_).is_nan()) {
-        if (nan_eq_nan_) {
-          *os << "isn't NaN";
-        } else {
-          *os << "is anything";
-        }
-      } else {
-        *os << "isn't approximately " << expected_;
-        if (HasMaxAbsError()) {
-          *os << " (absolute error > " << max_abs_error_ << ")";
-        }
-      }
-      // Restore original precision.
-      os->precision(old_precision);
-    }
-
-   private:
-    bool HasMaxAbsError() const {
-      return max_abs_error_ >= 0;
-    }
-
-    const FloatType expected_;
-    const bool nan_eq_nan_;
-    // max_abs_error will be used for value comparison when >= 0.
-    const FloatType max_abs_error_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  // The following 3 type conversion operators allow FloatEq(expected) and
-  // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a
-  // Matcher<const float&>, or a Matcher<float&>, but nothing else.
-  // (While Google's C++ coding style doesn't allow arguments passed
-  // by non-const reference, we may see them in code not conforming to
-  // the style.  Therefore Google Mock needs to support them.)
-  operator Matcher<FloatType>() const {
-    return MakeMatcher(
-        new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_));
-  }
-
-  operator Matcher<const FloatType&>() const {
-    return MakeMatcher(
-        new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
-  }
-
-  operator Matcher<FloatType&>() const {
-    return MakeMatcher(
-        new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
-  }
-
- private:
-  const FloatType expected_;
-  const bool nan_eq_nan_;
-  // max_abs_error will be used for value comparison when >= 0.
-  const FloatType max_abs_error_;
-
-  GTEST_DISALLOW_ASSIGN_(FloatingEqMatcher);
-};
-
-// 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>
-class PointeeMatcher {
- public:
-  explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
-
-  // This type conversion operator template allows Pointee(m) to be
-  // used as a matcher for any pointer type whose pointee type is
-  // compatible with the inner matcher, where type Pointer 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 Pointee().
-  template <typename Pointer>
-  operator Matcher<Pointer>() const {
-    return MakeMatcher(new Impl<Pointer>(matcher_));
-  }
-
- private:
-  // The monomorphic implementation that works for a particular pointer type.
-  template <typename Pointer>
-  class Impl : public MatcherInterface<Pointer> {
-   public:
-    typedef typename PointeeOf<GTEST_REMOVE_CONST_(  // NOLINT
-        GTEST_REMOVE_REFERENCE_(Pointer))>::type Pointee;
-
-    explicit Impl(const InnerMatcher& matcher)
-        : matcher_(MatcherCast<const Pointee&>(matcher)) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "points to a value that ";
-      matcher_.DescribeTo(os);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "does not point to a value that ";
-      matcher_.DescribeTo(os);
-    }
-
-    virtual bool MatchAndExplain(Pointer pointer,
-                                 MatchResultListener* listener) const {
-      if (GetRawPointer(pointer) == NULL)
-        return false;
-
-      *listener << "which points to ";
-      return MatchPrintAndExplain(*pointer, matcher_, listener);
-    }
-
-   private:
-    const Matcher<const Pointee&> matcher_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  const InnerMatcher matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(PointeeMatcher);
-};
-
-// 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.
-// If To is a pointer and the cast fails, the inner matcher will receive NULL.
-// If To is a reference and the cast fails, this matcher returns false
-// immediately.
-template <typename To>
-class WhenDynamicCastToMatcherBase {
- public:
-  explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher)
-      : matcher_(matcher) {}
-
-  void DescribeTo(::std::ostream* os) const {
-    GetCastTypeDescription(os);
-    matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    GetCastTypeDescription(os);
-    matcher_.DescribeNegationTo(os);
-  }
-
- protected:
-  const Matcher<To> matcher_;
-
-  static string GetToName() {
-#if GTEST_HAS_RTTI
-    return GetTypeName<To>();
-#else  // GTEST_HAS_RTTI
-    return "the target type";
-#endif  // GTEST_HAS_RTTI
-  }
-
- private:
-  static void GetCastTypeDescription(::std::ostream* os) {
-    *os << "when dynamic_cast to " << GetToName() << ", ";
-  }
-
-  GTEST_DISALLOW_ASSIGN_(WhenDynamicCastToMatcherBase);
-};
-
-// Primary template.
-// To is a pointer. Cast and forward the result.
-template <typename To>
-class WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> {
- public:
-  explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher)
-      : WhenDynamicCastToMatcherBase<To>(matcher) {}
-
-  template <typename From>
-  bool MatchAndExplain(From from, MatchResultListener* listener) const {
-    // TODO(sbenza): Add more detail on failures. ie did the dyn_cast fail?
-    To to = dynamic_cast<To>(from);
-    return MatchPrintAndExplain(to, this->matcher_, listener);
-  }
-};
-
-// Specialize for references.
-// In this case we return false if the dynamic_cast fails.
-template <typename To>
-class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> {
- public:
-  explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher)
-      : WhenDynamicCastToMatcherBase<To&>(matcher) {}
-
-  template <typename From>
-  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 == NULL) {
-      *listener << "which cannot be dynamic_cast to " << this->GetToName();
-      return false;
-    }
-    return MatchPrintAndExplain(*to, this->matcher_, listener);
-  }
-};
-
-// Implements the Field() matcher for matching a field (i.e. member
-// variable) of an object.
-template <typename Class, typename FieldType>
-class FieldMatcher {
- public:
-  FieldMatcher(FieldType Class::*field,
-               const Matcher<const FieldType&>& matcher)
-      : field_(field), matcher_(matcher) {}
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << "is an object whose given field ";
-    matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is an object whose given field ";
-    matcher_.DescribeNegationTo(os);
-  }
-
-  template <typename T>
-  bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
-    return MatchAndExplainImpl(
-        typename ::testing::internal::
-            is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
-        value, listener);
-  }
-
- private:
-  // The first argument of MatchAndExplainImpl() is needed to help
-  // Symbian's C++ compiler choose which overload to use.  Its type is
-  // true_type iff the Field() matcher is used to match a pointer.
-  bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj,
-                           MatchResultListener* listener) const {
-    *listener << "whose given field is ";
-    return MatchPrintAndExplain(obj.*field_, matcher_, listener);
-  }
-
-  bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
-                           MatchResultListener* listener) const {
-    if (p == NULL)
-      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(false_type(), *p, listener);
-  }
-
-  const FieldType Class::*field_;
-  const Matcher<const FieldType&> matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(FieldMatcher);
-};
-
-// Implements the Property() matcher for matching a property
-// (i.e. return value of a getter method) of an object.
-template <typename Class, typename PropertyType>
-class PropertyMatcher {
- public:
-  // The property may have a reference type, so 'const PropertyType&'
-  // may cause double references and fail to compile.  That's why we
-  // need GTEST_REFERENCE_TO_CONST, which works regardless of
-  // PropertyType being a reference or not.
-  typedef GTEST_REFERENCE_TO_CONST_(PropertyType) RefToConstProperty;
-
-  PropertyMatcher(PropertyType (Class::*property)() const,
-                  const Matcher<RefToConstProperty>& matcher)
-      : property_(property), matcher_(matcher) {}
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << "is an object whose given property ";
-    matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is an object whose given property ";
-    matcher_.DescribeNegationTo(os);
-  }
-
-  template <typename T>
-  bool MatchAndExplain(const T&value, MatchResultListener* listener) const {
-    return MatchAndExplainImpl(
-        typename ::testing::internal::
-            is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
-        value, listener);
-  }
-
- private:
-  // The first argument of MatchAndExplainImpl() is needed to help
-  // Symbian's C++ compiler choose which overload to use.  Its type is
-  // true_type iff the Property() matcher is used to match a pointer.
-  bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj,
-                           MatchResultListener* listener) const {
-    *listener << "whose given property is ";
-    // Cannot pass the return value (for example, int) to MatchPrintAndExplain,
-    // which takes a non-const reference as argument.
-#if defined(_PREFAST_ ) && _MSC_VER == 1800
-    // Workaround bug in VC++ 2013's /analyze parser.
-    // https://connect.microsoft.com/VisualStudio/feedback/details/1106363/internal-compiler-error-with-analyze-due-to-failure-to-infer-move
-    posix::Abort();  // To make sure it is never run.
-    return false;
-#else
-    RefToConstProperty result = (obj.*property_)();
-    return MatchPrintAndExplain(result, matcher_, listener);
-#endif
-  }
-
-  bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
-                           MatchResultListener* listener) const {
-    if (p == NULL)
-      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(false_type(), *p, listener);
-  }
-
-  PropertyType (Class::*property_)() const;
-  const Matcher<RefToConstProperty> matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(PropertyMatcher);
-};
-
-// Type traits specifying various features of different functors for ResultOf.
-// The default template specifies features for functor objects.
-// Functor classes have to typedef argument_type and result_type
-// to be compatible with ResultOf.
-template <typename Functor>
-struct CallableTraits {
-  typedef typename Functor::result_type ResultType;
-  typedef Functor StorageType;
-
-  static void CheckIsValid(Functor /* functor */) {}
-  template <typename T>
-  static ResultType Invoke(Functor f, T arg) { return f(arg); }
-};
-
-// Specialization for function pointers.
-template <typename ArgType, typename ResType>
-struct CallableTraits<ResType(*)(ArgType)> {
-  typedef ResType ResultType;
-  typedef ResType(*StorageType)(ArgType);
-
-  static void CheckIsValid(ResType(*f)(ArgType)) {
-    GTEST_CHECK_(f != NULL)
-        << "NULL function pointer is passed into ResultOf().";
-  }
-  template <typename T>
-  static ResType Invoke(ResType(*f)(ArgType), T arg) {
-    return (*f)(arg);
-  }
-};
-
-// Implements the ResultOf() matcher for matching a return value of a
-// unary function of an object.
-template <typename Callable>
-class ResultOfMatcher {
- public:
-  typedef typename CallableTraits<Callable>::ResultType ResultType;
-
-  ResultOfMatcher(Callable callable, const Matcher<ResultType>& matcher)
-      : callable_(callable), matcher_(matcher) {
-    CallableTraits<Callable>::CheckIsValid(callable_);
-  }
-
-  template <typename T>
-  operator Matcher<T>() const {
-    return Matcher<T>(new Impl<T>(callable_, matcher_));
-  }
-
- private:
-  typedef typename CallableTraits<Callable>::StorageType CallableStorageType;
-
-  template <typename T>
-  class Impl : public MatcherInterface<T> {
-   public:
-    Impl(CallableStorageType callable, const Matcher<ResultType>& matcher)
-        : callable_(callable), matcher_(matcher) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "is mapped by the given callable to a value that ";
-      matcher_.DescribeTo(os);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "is mapped by the given callable to a value that ";
-      matcher_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(T obj, MatchResultListener* listener) const {
-      *listener << "which is mapped by the given callable to ";
-      // Cannot pass the return value (for example, int) to
-      // MatchPrintAndExplain, which takes a non-const reference as argument.
-      ResultType result =
-          CallableTraits<Callable>::template Invoke<T>(callable_, obj);
-      return MatchPrintAndExplain(result, matcher_, listener);
-    }
-
-   private:
-    // Functors often define operator() as non-const method even though
-    // they are actualy 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 does't guarantee
-    // how many times the callable will be invoked.
-    mutable CallableStorageType callable_;
-    const Matcher<ResultType> matcher_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };  // class Impl
-
-  const CallableStorageType callable_;
-  const Matcher<ResultType> matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(ResultOfMatcher);
-};
-
-// Implements a matcher that checks the size of an STL-style container.
-template <typename SizeMatcher>
-class SizeIsMatcher {
- public:
-  explicit SizeIsMatcher(const SizeMatcher& size_matcher)
-       : size_matcher_(size_matcher) {
-  }
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    return MakeMatcher(new Impl<Container>(size_matcher_));
-  }
-
-  template <typename Container>
-  class Impl : public MatcherInterface<Container> {
-   public:
-    typedef internal::StlContainerView<
-         GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
-    typedef typename ContainerView::type::size_type SizeType;
-    explicit Impl(const SizeMatcher& size_matcher)
-        : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "size ";
-      size_matcher_.DescribeTo(os);
-    }
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "size ";
-      size_matcher_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(Container container,
-                                 MatchResultListener* listener) const {
-      SizeType size = container.size();
-      StringMatchResultListener size_listener;
-      const bool result = size_matcher_.MatchAndExplain(size, &size_listener);
-      *listener
-          << "whose size " << size << (result ? " matches" : " doesn't match");
-      PrintIfNotEmpty(size_listener.str(), listener->stream());
-      return result;
-    }
-
-   private:
-    const Matcher<SizeType> size_matcher_;
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
- private:
-  const SizeMatcher size_matcher_;
-  GTEST_DISALLOW_ASSIGN_(SizeIsMatcher);
-};
-
-// Implements a matcher that checks the begin()..end() distance of an STL-style
-// container.
-template <typename DistanceMatcher>
-class BeginEndDistanceIsMatcher {
- public:
-  explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher)
-      : distance_matcher_(distance_matcher) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    return MakeMatcher(new Impl<Container>(distance_matcher_));
-  }
-
-  template <typename Container>
-  class Impl : public MatcherInterface<Container> {
-   public:
-    typedef internal::StlContainerView<
-        GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
-    typedef typename std::iterator_traits<
-        typename ContainerView::type::const_iterator>::difference_type
-        DistanceType;
-    explicit Impl(const DistanceMatcher& distance_matcher)
-        : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "distance between begin() and end() ";
-      distance_matcher_.DescribeTo(os);
-    }
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "distance between begin() and end() ";
-      distance_matcher_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(Container container,
-                                 MatchResultListener* listener) const {
-#if GTEST_HAS_STD_BEGIN_AND_END_
-      using std::begin;
-      using std::end;
-      DistanceType distance = std::distance(begin(container), end(container));
-#else
-      DistanceType distance = std::distance(container.begin(), container.end());
-#endif
-      StringMatchResultListener distance_listener;
-      const bool result =
-          distance_matcher_.MatchAndExplain(distance, &distance_listener);
-      *listener << "whose distance between begin() and end() " << distance
-                << (result ? " matches" : " doesn't match");
-      PrintIfNotEmpty(distance_listener.str(), listener->stream());
-      return result;
-    }
-
-   private:
-    const Matcher<DistanceType> distance_matcher_;
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
- private:
-  const DistanceMatcher distance_matcher_;
-  GTEST_DISALLOW_ASSIGN_(BeginEndDistanceIsMatcher);
-};
-
-// Implements an equality matcher for any STL-style container whose elements
-// support ==. This matcher is like Eq(), but its failure explanations provide
-// more detailed information that is useful when the container is used as a set.
-// The failure message reports elements that are in one of the operands but not
-// the other. The failure messages do not report duplicate or out-of-order
-// elements in the containers (which don't properly matter to sets, but can
-// occur if the containers are vectors or lists, for example).
-//
-// Uses the container's const_iterator, value_type, operator ==,
-// begin(), and end().
-template <typename Container>
-class ContainerEqMatcher {
- public:
-  typedef internal::StlContainerView<Container> View;
-  typedef typename View::type StlContainer;
-  typedef typename View::const_reference StlContainerReference;
-
-  // 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)) {
-    // Makes sure the user doesn't instantiate this class template
-    // with a const or reference type.
-    (void)testing::StaticAssertTypeEq<Container,
-        GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>();
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << "equals ";
-    UniversalPrint(expected_, os);
-  }
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "does not equal ";
-    UniversalPrint(expected_, os);
-  }
-
-  template <typename LhsContainer>
-  bool MatchAndExplain(const LhsContainer& lhs,
-                       MatchResultListener* listener) const {
-    // GTEST_REMOVE_CONST_() is needed to work around an MSVC 8.0 bug
-    // that causes LhsContainer to be a const type sometimes.
-    typedef internal::StlContainerView<GTEST_REMOVE_CONST_(LhsContainer)>
-        LhsView;
-    typedef typename LhsView::type LhsStlContainer;
-    StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
-    if (lhs_stl_container == expected_)
-      return true;
-
-    ::std::ostream* const os = listener->stream();
-    if (os != NULL) {
-      // Something is different. Check for extra values first.
-      bool printed_header = false;
-      for (typename LhsStlContainer::const_iterator it =
-               lhs_stl_container.begin();
-           it != lhs_stl_container.end(); ++it) {
-        if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) ==
-            expected_.end()) {
-          if (printed_header) {
-            *os << ", ";
-          } else {
-            *os << "which has these unexpected elements: ";
-            printed_header = true;
-          }
-          UniversalPrint(*it, os);
-        }
-      }
-
-      // Now check for missing values.
-      bool printed_header2 = false;
-      for (typename StlContainer::const_iterator it = expected_.begin();
-           it != expected_.end(); ++it) {
-        if (internal::ArrayAwareFind(
-                lhs_stl_container.begin(), lhs_stl_container.end(), *it) ==
-            lhs_stl_container.end()) {
-          if (printed_header2) {
-            *os << ", ";
-          } else {
-            *os << (printed_header ? ",\nand" : "which")
-                << " doesn't have these expected elements: ";
-            printed_header2 = true;
-          }
-          UniversalPrint(*it, os);
-        }
-      }
-    }
-
-    return false;
-  }
-
- private:
-  const StlContainer expected_;
-
-  GTEST_DISALLOW_ASSIGN_(ContainerEqMatcher);
-};
-
-// A comparator functor that uses the < operator to compare two values.
-struct LessComparator {
-  template <typename T, typename U>
-  bool operator()(const T& lhs, const U& rhs) const { return lhs < rhs; }
-};
-
-// Implements WhenSortedBy(comparator, container_matcher).
-template <typename Comparator, typename ContainerMatcher>
-class WhenSortedByMatcher {
- public:
-  WhenSortedByMatcher(const Comparator& comparator,
-                      const ContainerMatcher& matcher)
-      : comparator_(comparator), matcher_(matcher) {}
-
-  template <typename LhsContainer>
-  operator Matcher<LhsContainer>() const {
-    return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_));
-  }
-
-  template <typename LhsContainer>
-  class Impl : public MatcherInterface<LhsContainer> {
-   public:
-    typedef internal::StlContainerView<
-         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
-    typedef typename LhsView::type LhsStlContainer;
-    typedef typename LhsView::const_reference LhsStlContainerReference;
-    // Transforms std::pair<const Key, Value> into std::pair<Key, Value>
-    // so that we can match associative containers.
-    typedef typename RemoveConstFromKey<
-        typename LhsStlContainer::value_type>::type LhsValue;
-
-    Impl(const Comparator& comparator, const ContainerMatcher& matcher)
-        : comparator_(comparator), matcher_(matcher) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "(when sorted) ";
-      matcher_.DescribeTo(os);
-    }
-
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *os << "(when sorted) ";
-      matcher_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(LhsContainer lhs,
-                                 MatchResultListener* listener) const {
-      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
-      ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
-                                               lhs_stl_container.end());
-      ::std::sort(
-           sorted_container.begin(), sorted_container.end(), comparator_);
-
-      if (!listener->IsInterested()) {
-        // If the listener is not interested, we do not need to
-        // construct the inner explanation.
-        return matcher_.Matches(sorted_container);
-      }
-
-      *listener << "which is ";
-      UniversalPrint(sorted_container, listener->stream());
-      *listener << " when sorted";
-
-      StringMatchResultListener inner_listener;
-      const bool match = matcher_.MatchAndExplain(sorted_container,
-                                                  &inner_listener);
-      PrintIfNotEmpty(inner_listener.str(), listener->stream());
-      return match;
-    }
-
-   private:
-    const Comparator comparator_;
-    const Matcher<const ::std::vector<LhsValue>&> matcher_;
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
-  };
-
- private:
-  const Comparator comparator_;
-  const ContainerMatcher matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(WhenSortedByMatcher);
-};
-
-// Implements Pointwise(tuple_matcher, rhs_container).  tuple_matcher
-// must be able to be safely cast to Matcher<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 {
- public:
-  typedef internal::StlContainerView<RhsContainer> RhsView;
-  typedef typename RhsView::type RhsStlContainer;
-  typedef typename RhsStlContainer::value_type RhsValue;
-
-  // 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)) {
-    // Makes sure the user doesn't instantiate this class template
-    // with a const or reference type.
-    (void)testing::StaticAssertTypeEq<RhsContainer,
-        GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>();
-  }
-
-  template <typename LhsContainer>
-  operator Matcher<LhsContainer>() const {
-    return MakeMatcher(new Impl<LhsContainer>(tuple_matcher_, rhs_));
-  }
-
-  template <typename LhsContainer>
-  class Impl : public MatcherInterface<LhsContainer> {
-   public:
-    typedef internal::StlContainerView<
-         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
-    typedef typename LhsView::type LhsStlContainer;
-    typedef typename LhsView::const_reference LhsStlContainerReference;
-    typedef typename LhsStlContainer::value_type LhsValue;
-    // We pass the LHS value and the RHS value to the inner matcher by
-    // 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 ::testing::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) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "contains " << rhs_.size()
-          << " values, where each value and its corresponding value in ";
-      UniversalPrinter<RhsStlContainer>::Print(rhs_, os);
-      *os << " ";
-      mono_tuple_matcher_.DescribeTo(os);
-    }
-    virtual void DescribeNegationTo(::std::ostream* os) const {
-      *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 ";
-      UniversalPrint(rhs_, os);
-      *os << " ";
-      mono_tuple_matcher_.DescribeNegationTo(os);
-    }
-
-    virtual bool MatchAndExplain(LhsContainer lhs,
-                                 MatchResultListener* listener) const {
-      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
-      const size_t actual_size = lhs_stl_container.size();
-      if (actual_size != rhs_.size()) {
-        *listener << "which contains " << actual_size << " values";
-        return false;
-      }
-
-      typename LhsStlContainer::const_iterator left = lhs_stl_container.begin();
-      typename RhsStlContainer::const_iterator right = rhs_.begin();
-      for (size_t i = 0; i != actual_size; ++i, ++left, ++right) {
-        const InnerMatcherArg value_pair(*left, *right);
-
-        if (listener->IsInterested()) {
-          StringMatchResultListener inner_listener;
-          if (!mono_tuple_matcher_.MatchAndExplain(
-                  value_pair, &inner_listener)) {
-            *listener << "where the value pair (";
-            UniversalPrint(*left, listener->stream());
-            *listener << ", ";
-            UniversalPrint(*right, listener->stream());
-            *listener << ") at index #" << i << " don't match";
-            PrintIfNotEmpty(inner_listener.str(), listener->stream());
-            return false;
-          }
-        } else {
-          if (!mono_tuple_matcher_.Matches(value_pair))
-            return false;
-        }
-      }
-
-      return true;
-    }
-
-   private:
-    const Matcher<InnerMatcherArg> mono_tuple_matcher_;
-    const RhsStlContainer rhs_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
- private:
-  const TupleMatcher tuple_matcher_;
-  const RhsStlContainer rhs_;
-
-  GTEST_DISALLOW_ASSIGN_(PointwiseMatcher);
-};
-
-// Holds the logic common to ContainsMatcherImpl and EachMatcherImpl.
-template <typename Container>
-class QuantifierMatcherImpl : public MatcherInterface<Container> {
- public:
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
-  typedef StlContainerView<RawContainer> View;
-  typedef typename View::type StlContainer;
-  typedef typename View::const_reference StlContainerReference;
-  typedef typename StlContainer::value_type Element;
-
-  template <typename InnerMatcher>
-  explicit QuantifierMatcherImpl(InnerMatcher inner_matcher)
-      : inner_matcher_(
-           testing::SafeMatcherCast<const Element&>(inner_matcher)) {}
-
-  // Checks whether:
-  // * All elements in the container match, if all_elements_should_match.
-  // * Any element in the container matches, if !all_elements_should_match.
-  bool MatchAndExplainImpl(bool all_elements_should_match,
-                           Container container,
-                           MatchResultListener* listener) const {
-    StlContainerReference stl_container = View::ConstReference(container);
-    size_t i = 0;
-    for (typename StlContainer::const_iterator it = stl_container.begin();
-         it != stl_container.end(); ++it, ++i) {
-      StringMatchResultListener inner_listener;
-      const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);
-
-      if (matches != all_elements_should_match) {
-        *listener << "whose element #" << i
-                  << (matches ? " matches" : " doesn't match");
-        PrintIfNotEmpty(inner_listener.str(), listener->stream());
-        return !all_elements_should_match;
-      }
-    }
-    return all_elements_should_match;
-  }
-
- protected:
-  const Matcher<const Element&> inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(QuantifierMatcherImpl);
-};
-
-// Implements Contains(element_matcher) for the given argument type Container.
-// Symmetric to EachMatcherImpl.
-template <typename Container>
-class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> {
- public:
-  template <typename InnerMatcher>
-  explicit ContainsMatcherImpl(InnerMatcher inner_matcher)
-      : QuantifierMatcherImpl<Container>(inner_matcher) {}
-
-  // Describes what this matcher does.
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "contains at least one element that ";
-    this->inner_matcher_.DescribeTo(os);
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't contain any element that ";
-    this->inner_matcher_.DescribeTo(os);
-  }
-
-  virtual bool MatchAndExplain(Container container,
-                               MatchResultListener* listener) const {
-    return this->MatchAndExplainImpl(false, container, listener);
-  }
-
- private:
-  GTEST_DISALLOW_ASSIGN_(ContainsMatcherImpl);
-};
-
-// Implements Each(element_matcher) for the given argument type Container.
-// Symmetric to ContainsMatcherImpl.
-template <typename Container>
-class EachMatcherImpl : public QuantifierMatcherImpl<Container> {
- public:
-  template <typename InnerMatcher>
-  explicit EachMatcherImpl(InnerMatcher inner_matcher)
-      : QuantifierMatcherImpl<Container>(inner_matcher) {}
-
-  // Describes what this matcher does.
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "only contains elements that ";
-    this->inner_matcher_.DescribeTo(os);
-  }
-
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "contains some element that ";
-    this->inner_matcher_.DescribeNegationTo(os);
-  }
-
-  virtual bool MatchAndExplain(Container container,
-                               MatchResultListener* listener) const {
-    return this->MatchAndExplainImpl(true, container, listener);
-  }
-
- private:
-  GTEST_DISALLOW_ASSIGN_(EachMatcherImpl);
-};
-
-// Implements polymorphic Contains(element_matcher).
-template <typename M>
-class ContainsMatcher {
- public:
-  explicit ContainsMatcher(M m) : inner_matcher_(m) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    return MakeMatcher(new ContainsMatcherImpl<Container>(inner_matcher_));
-  }
-
- private:
-  const M inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(ContainsMatcher);
-};
-
-// Implements polymorphic Each(element_matcher).
-template <typename M>
-class EachMatcher {
- public:
-  explicit EachMatcher(M m) : inner_matcher_(m) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    return MakeMatcher(new EachMatcherImpl<Container>(inner_matcher_));
-  }
-
- private:
-  const M inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(EachMatcher);
-};
-
-// 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
-// std::map that contains at least one element whose key is >= 5.
-template <typename PairType>
-class KeyMatcherImpl : public MatcherInterface<PairType> {
- public:
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
-  typedef typename RawPairType::first_type KeyType;
-
-  template <typename InnerMatcher>
-  explicit KeyMatcherImpl(InnerMatcher inner_matcher)
-      : inner_matcher_(
-          testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {
-  }
-
-  // Returns true iff 'key_value.first' (the key) matches the inner matcher.
-  virtual bool MatchAndExplain(PairType key_value,
-                               MatchResultListener* listener) const {
-    StringMatchResultListener inner_listener;
-    const bool match = inner_matcher_.MatchAndExplain(key_value.first,
-                                                      &inner_listener);
-    const internal::string explanation = inner_listener.str();
-    if (explanation != "") {
-      *listener << "whose first field is a value " << explanation;
-    }
-    return match;
-  }
-
-  // Describes what this matcher does.
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "has a key that ";
-    inner_matcher_.DescribeTo(os);
-  }
-
-  // Describes what the negation of this matcher does.
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't have a key that ";
-    inner_matcher_.DescribeTo(os);
-  }
-
- private:
-  const Matcher<const KeyType&> inner_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(KeyMatcherImpl);
-};
-
-// Implements polymorphic Key(matcher_for_key).
-template <typename M>
-class KeyMatcher {
- public:
-  explicit KeyMatcher(M m) : matcher_for_key_(m) {}
-
-  template <typename PairType>
-  operator Matcher<PairType>() const {
-    return MakeMatcher(new KeyMatcherImpl<PairType>(matcher_for_key_));
-  }
-
- private:
-  const M matcher_for_key_;
-
-  GTEST_DISALLOW_ASSIGN_(KeyMatcher);
-};
-
-// Implements Pair(first_matcher, second_matcher) for the given argument pair
-// type with its two matchers. See Pair() function below.
-template <typename PairType>
-class PairMatcherImpl : public MatcherInterface<PairType> {
- public:
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
-  typedef typename RawPairType::first_type FirstType;
-  typedef typename RawPairType::second_type SecondType;
-
-  template <typename FirstMatcher, typename SecondMatcher>
-  PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher)
-      : first_matcher_(
-            testing::SafeMatcherCast<const FirstType&>(first_matcher)),
-        second_matcher_(
-            testing::SafeMatcherCast<const SecondType&>(second_matcher)) {
-  }
-
-  // Describes what this matcher does.
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "has a first field that ";
-    first_matcher_.DescribeTo(os);
-    *os << ", and has a second field that ";
-    second_matcher_.DescribeTo(os);
-  }
-
-  // Describes what the negation of this matcher does.
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "has a first field that ";
-    first_matcher_.DescribeNegationTo(os);
-    *os << ", or has a second field that ";
-    second_matcher_.DescribeNegationTo(os);
-  }
-
-  // Returns true iff 'a_pair.first' matches first_matcher and 'a_pair.second'
-  // matches second_matcher.
-  virtual bool MatchAndExplain(PairType a_pair,
-                               MatchResultListener* listener) const {
-    if (!listener->IsInterested()) {
-      // If the listener is not interested, we don't need to construct the
-      // explanation.
-      return first_matcher_.Matches(a_pair.first) &&
-             second_matcher_.Matches(a_pair.second);
-    }
-    StringMatchResultListener first_inner_listener;
-    if (!first_matcher_.MatchAndExplain(a_pair.first,
-                                        &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(a_pair.second,
-                                         &second_inner_listener)) {
-      *listener << "whose second field does not match";
-      PrintIfNotEmpty(second_inner_listener.str(), listener->stream());
-      return false;
-    }
-    ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(),
-                   listener);
-    return true;
-  }
-
- private:
-  void ExplainSuccess(const internal::string& first_explanation,
-                      const internal::string& second_explanation,
-                      MatchResultListener* listener) const {
-    *listener << "whose both fields match";
-    if (first_explanation != "") {
-      *listener << ", where the first field is a value " << first_explanation;
-    }
-    if (second_explanation != "") {
-      *listener << ", ";
-      if (first_explanation != "") {
-        *listener << "and ";
-      } else {
-        *listener << "where ";
-      }
-      *listener << "the second field is a value " << second_explanation;
-    }
-  }
-
-  const Matcher<const FirstType&> first_matcher_;
-  const Matcher<const SecondType&> second_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(PairMatcherImpl);
-};
-
-// Implements polymorphic Pair(first_matcher, second_matcher).
-template <typename FirstMatcher, typename SecondMatcher>
-class PairMatcher {
- public:
-  PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher)
-      : first_matcher_(first_matcher), second_matcher_(second_matcher) {}
-
-  template <typename PairType>
-  operator Matcher<PairType> () const {
-    return MakeMatcher(
-        new PairMatcherImpl<PairType>(
-            first_matcher_, second_matcher_));
-  }
-
- private:
-  const FirstMatcher first_matcher_;
-  const SecondMatcher second_matcher_;
-
-  GTEST_DISALLOW_ASSIGN_(PairMatcher);
-};
-
-// Implements ElementsAre() and ElementsAreArray().
-template <typename Container>
-class ElementsAreMatcherImpl : public MatcherInterface<Container> {
- public:
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
-  typedef internal::StlContainerView<RawContainer> View;
-  typedef typename View::type StlContainer;
-  typedef typename View::const_reference StlContainerReference;
-  typedef typename StlContainer::value_type Element;
-
-  // Constructs the matcher from a sequence of element values or
-  // element matchers.
-  template <typename InputIter>
-  ElementsAreMatcherImpl(InputIter first, InputIter last) {
-    while (first != last) {
-      matchers_.push_back(MatcherCast<const Element&>(*first++));
-    }
-  }
-
-  // Describes what this matcher does.
-  virtual void DescribeTo(::std::ostream* os) const {
-    if (count() == 0) {
-      *os << "is empty";
-    } else if (count() == 1) {
-      *os << "has 1 element that ";
-      matchers_[0].DescribeTo(os);
-    } else {
-      *os << "has " << Elements(count()) << " where\n";
-      for (size_t i = 0; i != count(); ++i) {
-        *os << "element #" << i << " ";
-        matchers_[i].DescribeTo(os);
-        if (i + 1 < count()) {
-          *os << ",\n";
-        }
-      }
-    }
-  }
-
-  // Describes what the negation of this matcher does.
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    if (count() == 0) {
-      *os << "isn't empty";
-      return;
-    }
-
-    *os << "doesn't have " << Elements(count()) << ", or\n";
-    for (size_t i = 0; i != count(); ++i) {
-      *os << "element #" << i << " ";
-      matchers_[i].DescribeNegationTo(os);
-      if (i + 1 < count()) {
-        *os << ", or\n";
-      }
-    }
-  }
-
-  virtual bool MatchAndExplain(Container container,
-                               MatchResultListener* listener) const {
-    // 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<internal::string> explanations(count());
-    StlContainerReference stl_container = View::ConstReference(container);
-    typename StlContainer::const_iterator it = stl_container.begin();
-    size_t exam_pos = 0;
-    bool mismatch_found = false;  // Have we found a mismatched element yet?
-
-    // Go through the elements and matchers in pairs, until we reach
-    // the end of either the elements or the matchers, or until we find a
-    // mismatch.
-    for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) {
-      bool match;  // Does the current element match the current matcher?
-      if (listener_interested) {
-        StringMatchResultListener s;
-        match = matchers_[exam_pos].MatchAndExplain(*it, &s);
-        explanations[exam_pos] = s.str();
-      } else {
-        match = matchers_[exam_pos].Matches(*it);
-      }
-
-      if (!match) {
-        mismatch_found = true;
-        break;
-      }
-    }
-    // If mismatch_found is true, 'exam_pos' is the index of the mismatch.
-
-    // Find how many elements the actual container has.  We avoid
-    // calling size() s.t. this code works for stream-like "containers"
-    // that don't define size().
-    size_t actual_count = exam_pos;
-    for (; it != stl_container.end(); ++it) {
-      ++actual_count;
-    }
-
-    if (actual_count != count()) {
-      // 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 (listener_interested && (actual_count != 0)) {
-        *listener << "which has " << Elements(actual_count);
-      }
-      return false;
-    }
-
-    if (mismatch_found) {
-      // The element count matches, but the exam_pos-th element doesn't match.
-      if (listener_interested) {
-        *listener << "whose element #" << exam_pos << " doesn't match";
-        PrintIfNotEmpty(explanations[exam_pos], listener->stream());
-      }
-      return false;
-    }
-
-    // Every element matches its expectation.  We need to explain why
-    // (the obvious ones can be skipped).
-    if (listener_interested) {
-      bool reason_printed = false;
-      for (size_t i = 0; i != count(); ++i) {
-        const internal::string& s = explanations[i];
-        if (!s.empty()) {
-          if (reason_printed) {
-            *listener << ",\nand ";
-          }
-          *listener << "whose element #" << i << " matches, " << s;
-          reason_printed = true;
-        }
-      }
-    }
-    return true;
-  }
-
- private:
-  static Message Elements(size_t count) {
-    return Message() << count << (count == 1 ? " element" : " elements");
-  }
-
-  size_t count() const { return matchers_.size(); }
-
-  ::std::vector<Matcher<const Element&> > matchers_;
-
-  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcherImpl);
-};
-
-// Connectivity matrix of (elements X matchers), in element-major order.
-// Initially, there are no edges.
-// Use NextGraph() to iterate over all possible edge configurations.
-// Use Randomize() to generate a random edge configuration.
-class GTEST_API_ MatchMatrix {
- public:
-  MatchMatrix(size_t num_elements, size_t num_matchers)
-      : num_elements_(num_elements),
-        num_matchers_(num_matchers),
-        matched_(num_elements_* num_matchers_, 0) {
-  }
-
-  size_t LhsSize() const { return num_elements_; }
-  size_t RhsSize() const { return num_matchers_; }
-  bool HasEdge(size_t ilhs, size_t irhs) const {
-    return matched_[SpaceIndex(ilhs, irhs)] == 1;
-  }
-  void SetEdge(size_t ilhs, size_t irhs, bool b) {
-    matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0;
-  }
-
-  // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number,
-  // adds 1 to that number; returns false if incrementing the graph left it
-  // empty.
-  bool NextGraph();
-
-  void Randomize();
-
-  string DebugString() const;
-
- private:
-  size_t SpaceIndex(size_t ilhs, size_t irhs) const {
-    return ilhs * num_matchers_ + irhs;
-  }
-
-  size_t num_elements_;
-  size_t num_matchers_;
-
-  // Each element is a char interpreted as bool. They are stored as a
-  // flattened array in lhs-major order, use 'SpaceIndex()' to translate
-  // a (ilhs, irhs) matrix coordinate into an offset.
-  ::std::vector<char> matched_;
-};
-
-typedef ::std::pair<size_t, size_t> ElementMatcherPair;
-typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;
-
-// Returns a maximum bipartite matching for the specified graph 'g'.
-// The matching is represented as a vector of {element, matcher} pairs.
-GTEST_API_ ElementMatcherPairs
-FindMaxBipartiteMatching(const MatchMatrix& g);
-
-GTEST_API_ bool FindPairing(const MatchMatrix& matrix,
-                            MatchResultListener* listener);
-
-// 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:
-  // 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).
-  typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec;
-
-  // Describes this UnorderedElementsAre matcher.
-  void DescribeToImpl(::std::ostream* os) const;
-
-  // Describes the negation of this UnorderedElementsAre matcher.
-  void DescribeNegationToImpl(::std::ostream* os) const;
-
-  bool VerifyAllElementsAndMatchersAreMatched(
-      const ::std::vector<string>& element_printouts,
-      const MatchMatrix& matrix,
-      MatchResultListener* listener) const;
-
-  MatcherDescriberVec& matcher_describers() {
-    return matcher_describers_;
-  }
-
-  static Message Elements(size_t n) {
-    return Message() << n << " element" << (n == 1 ? "" : "s");
-  }
-
- private:
-  MatcherDescriberVec matcher_describers_;
-
-  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcherImplBase);
-};
-
-// Implements unordered ElementsAre and unordered ElementsAreArray.
-template <typename Container>
-class UnorderedElementsAreMatcherImpl
-    : public MatcherInterface<Container>,
-      public UnorderedElementsAreMatcherImplBase {
- public:
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
-  typedef internal::StlContainerView<RawContainer> View;
-  typedef typename View::type StlContainer;
-  typedef typename View::const_reference StlContainerReference;
-  typedef typename StlContainer::const_iterator StlContainerConstIterator;
-  typedef typename StlContainer::value_type Element;
-
-  // Constructs the matcher from a sequence of element values or
-  // element matchers.
-  template <typename InputIter>
-  UnorderedElementsAreMatcherImpl(InputIter first, InputIter last) {
-    for (; first != last; ++first) {
-      matchers_.push_back(MatcherCast<const Element&>(*first));
-      matcher_describers().push_back(matchers_.back().GetDescriber());
-    }
-  }
-
-  // Describes what this matcher does.
-  virtual void DescribeTo(::std::ostream* os) const {
-    return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os);
-  }
-
-  // Describes what the negation of this matcher does.
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os);
-  }
-
-  virtual bool MatchAndExplain(Container container,
-                               MatchResultListener* listener) const {
-    StlContainerReference stl_container = View::ConstReference(container);
-    ::std::vector<string> element_printouts;
-    MatchMatrix matrix = AnalyzeElements(stl_container.begin(),
-                                         stl_container.end(),
-                                         &element_printouts,
-                                         listener);
-
-    const size_t actual_count = matrix.LhsSize();
-    if (actual_count == 0 && matchers_.empty()) {
-      return true;
-    }
-    if (actual_count != matchers_.size()) {
-      // 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 (actual_count != 0 && listener->IsInterested()) {
-        *listener << "which has " << Elements(actual_count);
-      }
-      return false;
-    }
-
-    return VerifyAllElementsAndMatchersAreMatched(element_printouts,
-                                                  matrix, listener) &&
-           FindPairing(matrix, listener);
-  }
-
- private:
-  typedef ::std::vector<Matcher<const Element&> > MatcherVec;
-
-  template <typename ElementIter>
-  MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last,
-                              ::std::vector<string>* element_printouts,
-                              MatchResultListener* listener) const {
-    element_printouts->clear();
-    ::std::vector<char> did_match;
-    size_t num_elements = 0;
-    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(Matches(matchers_[irhs])(*elem_first));
-      }
-    }
-
-    MatchMatrix matrix(num_elements, matchers_.size());
-    ::std::vector<char>::const_iterator did_match_iter = did_match.begin();
-    for (size_t ilhs = 0; ilhs != num_elements; ++ilhs) {
-      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
-        matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0);
-      }
-    }
-    return matrix;
-  }
-
-  MatcherVec matchers_;
-
-  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcherImpl);
-};
-
-// Functor for use in TransformTuple.
-// Performs MatcherCast<Target> on an input argument of any type.
-template <typename Target>
-struct CastAndAppendTransform {
-  template <typename Arg>
-  Matcher<Target> operator()(const Arg& a) const {
-    return MatcherCast<Target>(a);
-  }
-};
-
-// Implements UnorderedElementsAre.
-template <typename MatcherTuple>
-class UnorderedElementsAreMatcher {
- public:
-  explicit UnorderedElementsAreMatcher(const MatcherTuple& args)
-      : matchers_(args) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    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(::testing::tuple_size<MatcherTuple>::value);
-    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
-                         ::std::back_inserter(matchers));
-    return MakeMatcher(new UnorderedElementsAreMatcherImpl<Container>(
-                           matchers.begin(), matchers.end()));
-  }
-
- private:
-  const MatcherTuple matchers_;
-  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcher);
-};
-
-// Implements ElementsAre.
-template <typename MatcherTuple>
-class ElementsAreMatcher {
- public:
-  explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    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(::testing::tuple_size<MatcherTuple>::value);
-    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
-                         ::std::back_inserter(matchers));
-    return MakeMatcher(new ElementsAreMatcherImpl<Container>(
-                           matchers.begin(), matchers.end()));
-  }
-
- private:
-  const MatcherTuple matchers_;
-  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher);
-};
-
-// Implements UnorderedElementsAreArray().
-template <typename T>
-class UnorderedElementsAreArrayMatcher {
- public:
-  UnorderedElementsAreArrayMatcher() {}
-
-  template <typename Iter>
-  UnorderedElementsAreArrayMatcher(Iter first, Iter last)
-      : matchers_(first, last) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    return MakeMatcher(
-        new UnorderedElementsAreMatcherImpl<Container>(matchers_.begin(),
-                                                       matchers_.end()));
-  }
-
- private:
-  ::std::vector<T> matchers_;
-
-  GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreArrayMatcher);
-};
-
-// Implements ElementsAreArray().
-template <typename T>
-class ElementsAreArrayMatcher {
- public:
-  template <typename Iter>
-  ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
-
-  template <typename Container>
-  operator Matcher<Container>() const {
-    return MakeMatcher(new ElementsAreMatcherImpl<Container>(
-        matchers_.begin(), matchers_.end()));
-  }
-
- private:
-  const ::std::vector<T> matchers_;
-
-  GTEST_DISALLOW_ASSIGN_(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 iff tm
-// matches tuple (x, second).  Useful for implementing
-// UnorderedPointwise() in terms of UnorderedElementsAreArray().
-//
-// BoundSecondMatcher is copyable and assignable, as we need to put
-// instances of this class in a vector when implementing
-// UnorderedPointwise().
-template <typename Tuple2Matcher, typename Second>
-class BoundSecondMatcher {
- public:
-  BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second)
-      : tuple2_matcher_(tm), second_value_(second) {}
-
-  template <typename T>
-  operator Matcher<T>() const {
-    return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_));
-  }
-
-  // We have to define this for UnorderedPointwise() to compile in
-  // C++98 mode, as it puts BoundSecondMatcher instances in a vector,
-  // which requires the elements to be assignable in C++98.  The
-  // compiler cannot generate the operator= for us, as Tuple2Matcher
-  // and Second may not be assignable.
-  //
-  // However, this should never be called, so the implementation just
-  // need to assert.
-  void operator=(const BoundSecondMatcher& /*rhs*/) {
-    GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned.";
-  }
-
- private:
-  template <typename T>
-  class Impl : public MatcherInterface<T> {
-   public:
-    typedef ::testing::tuple<T, Second> ArgTuple;
-
-    Impl(const Tuple2Matcher& tm, const Second& second)
-        : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)),
-          second_value_(second) {}
-
-    virtual void DescribeTo(::std::ostream* os) const {
-      *os << "and ";
-      UniversalPrint(second_value_, os);
-      *os << " ";
-      mono_tuple2_matcher_.DescribeTo(os);
-    }
-
-    virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
-      return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_),
-                                                  listener);
-    }
-
-   private:
-    const Matcher<const ArgTuple&> mono_tuple2_matcher_;
-    const Second second_value_;
-
-    GTEST_DISALLOW_ASSIGN_(Impl);
-  };
-
-  const Tuple2Matcher tuple2_matcher_;
-  const Second second_value_;
-};
-
-// Given a 2-tuple matcher tm and a value second,
-// MatcherBindSecond(tm, second) returns a matcher that matches a
-// value x iff 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) {
-  return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second);
-}
-
-// Returns the description for a matcher defined using the MATCHER*()
-// macro where the user-supplied description string is "", if
-// '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_ string FormatMatcherDescription(bool negation,
-                                           const char* matcher_name,
-                                           const Strings& param_values);
-
-}  // namespace internal
-
-// ElementsAreArray(first, last)
-// ElementsAreArray(pointer, count)
-// ElementsAreArray(array)
-// ElementsAreArray(container)
-// ElementsAreArray({ e1, e2, ..., en })
-//
-// The ElementsAreArray() functions are like ElementsAre(...), except
-// that they are given a homogeneous sequence rather than taking each
-// element as a function argument. The sequence can be specified as an
-// array, a pointer and count, a vector, an initializer list, or an
-// STL iterator range. In each of these cases, the underlying sequence
-// can be either a sequence of values or a sequence of matchers.
-//
-// All forms of ElementsAreArray() make a copy of the input matcher sequence.
-
-template <typename Iter>
-inline internal::ElementsAreArrayMatcher<
-    typename ::std::iterator_traits<Iter>::value_type>
-ElementsAreArray(Iter first, Iter last) {
-  typedef typename ::std::iterator_traits<Iter>::value_type T;
-  return internal::ElementsAreArrayMatcher<T>(first, last);
-}
-
-template <typename T>
-inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
-    const T* pointer, size_t count) {
-  return ElementsAreArray(pointer, pointer + count);
-}
-
-template <typename T, size_t N>
-inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
-    const T (&array)[N]) {
-  return ElementsAreArray(array, N);
-}
-
-template <typename Container>
-inline internal::ElementsAreArrayMatcher<typename Container::value_type>
-ElementsAreArray(const Container& container) {
-  return ElementsAreArray(container.begin(), container.end());
-}
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-template <typename T>
-inline internal::ElementsAreArrayMatcher<T>
-ElementsAreArray(::std::initializer_list<T> xs) {
-  return ElementsAreArray(xs.begin(), xs.end());
-}
-#endif
-
-// UnorderedElementsAreArray(first, last)
-// UnorderedElementsAreArray(pointer, count)
-// UnorderedElementsAreArray(array)
-// UnorderedElementsAreArray(container)
-// UnorderedElementsAreArray({ e1, e2, ..., en })
-//
-// The UnorderedElementsAreArray() functions are like
-// ElementsAreArray(...), but allow matching the elements in any order.
-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>(first, last);
-}
-
-template <typename T>
-inline internal::UnorderedElementsAreArrayMatcher<T>
-UnorderedElementsAreArray(const T* pointer, size_t count) {
-  return UnorderedElementsAreArray(pointer, pointer + count);
-}
-
-template <typename T, size_t N>
-inline internal::UnorderedElementsAreArrayMatcher<T>
-UnorderedElementsAreArray(const T (&array)[N]) {
-  return UnorderedElementsAreArray(array, N);
-}
-
-template <typename Container>
-inline internal::UnorderedElementsAreArrayMatcher<
-    typename Container::value_type>
-UnorderedElementsAreArray(const Container& container) {
-  return UnorderedElementsAreArray(container.begin(), container.end());
-}
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-template <typename T>
-inline internal::UnorderedElementsAreArrayMatcher<T>
-UnorderedElementsAreArray(::std::initializer_list<T> xs) {
-  return UnorderedElementsAreArray(xs.begin(), xs.end());
-}
-#endif
-
-// _ is a matcher that matches anything of any type.
-//
-// This definition is fine as:
-//
-//   1. The C++ standard permits using the name _ in a namespace that
-//      is not the global namespace or ::std.
-//   2. The AnythingMatcher class has no data member or constructor,
-//      so it's OK to create global variables of this type.
-//   3. c-style has approved of using _ in this case.
-const internal::AnythingMatcher _ = {};
-// Creates a matcher that matches any value of the given type T.
-template <typename T>
-inline Matcher<T> A() { return MakeMatcher(new internal::AnyMatcherImpl<T>()); }
-
-// Creates a matcher that matches any value of the given type T.
-template <typename T>
-inline Matcher<T> An() { return A<T>(); }
-
-// 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);
-}
-
-// Creates a polymorphic matcher that matches any NULL pointer.
-inline PolymorphicMatcher<internal::IsNullMatcher > IsNull() {
-  return MakePolymorphicMatcher(internal::IsNullMatcher());
-}
-
-// Creates a polymorphic matcher that matches any non-NULL pointer.
-// This is convenient as Not(NULL) doesn't compile (the compiler
-// thinks that that expression is comparing a pointer with an integer).
-inline PolymorphicMatcher<internal::NotNullMatcher > NotNull() {
-  return MakePolymorphicMatcher(internal::NotNullMatcher());
-}
-
-// Creates a polymorphic matcher that matches any argument that
-// references variable x.
-template <typename T>
-inline internal::RefMatcher<T&> Ref(T& x) {  // NOLINT
-  return internal::RefMatcher<T&>(x);
-}
-
-// 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) {
-  return internal::FloatingEqMatcher<double>(rhs, false);
-}
-
-// Creates a matcher that matches any double argument approximately
-// equal to rhs, including NaN values when rhs is NaN.
-inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) {
-  return internal::FloatingEqMatcher<double>(rhs, true);
-}
-
-// Creates a matcher that matches any double argument approximately equal to
-// rhs, up to the specified max absolute error bound, where two NANs are
-// considered unequal.  The max absolute error bound must be non-negative.
-inline internal::FloatingEqMatcher<double> DoubleNear(
-    double rhs, double max_abs_error) {
-  return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);
-}
-
-// Creates a matcher that matches any double argument approximately equal to
-// rhs, up to the specified max absolute error bound, including NaN values when
-// rhs is NaN.  The max absolute error bound must be non-negative.
-inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear(
-    double rhs, double max_abs_error) {
-  return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error);
-}
-
-// Creates a matcher that matches any float argument approximately
-// equal to rhs, where two NANs are considered unequal.
-inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {
-  return internal::FloatingEqMatcher<float>(rhs, false);
-}
-
-// Creates a matcher that matches any float argument approximately
-// equal to rhs, including NaN values when rhs is NaN.
-inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
-  return internal::FloatingEqMatcher<float>(rhs, true);
-}
-
-// Creates a matcher that matches any float argument approximately equal to
-// rhs, up to the specified max absolute error bound, where two NANs are
-// considered unequal.  The max absolute error bound must be non-negative.
-inline internal::FloatingEqMatcher<float> FloatNear(
-    float rhs, float max_abs_error) {
-  return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);
-}
-
-// Creates a matcher that matches any float argument approximately equal to
-// rhs, up to the specified max absolute error bound, including NaN values when
-// rhs is NaN.  The max absolute error bound must be non-negative.
-inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear(
-    float rhs, float max_abs_error) {
-  return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error);
-}
-
-// Creates a matcher that matches a pointer (raw or smart) that points
-// to a value that matches inner_matcher.
-template <typename InnerMatcher>
-inline internal::PointeeMatcher<InnerMatcher> Pointee(
-    const InnerMatcher& inner_matcher) {
-  return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
-}
-
-// 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.
-// If To is a pointer and the cast fails, the inner matcher will receive NULL.
-// If To is a reference and the cast fails, this matcher returns false
-// immediately.
-template <typename To>
-inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To> >
-WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
-  return MakePolymorphicMatcher(
-      internal::WhenDynamicCastToMatcher<To>(inner_matcher));
-}
-
-// Creates a matcher that matches an object whose given field matches
-// 'matcher'.  For example,
-//   Field(&Foo::number, Ge(5))
-// matches a Foo object x iff x.number >= 5.
-template <typename Class, typename FieldType, typename FieldMatcher>
-inline PolymorphicMatcher<
-  internal::FieldMatcher<Class, FieldType> > Field(
-    FieldType Class::*field, const FieldMatcher& matcher) {
-  return MakePolymorphicMatcher(
-      internal::FieldMatcher<Class, FieldType>(
-          field, MatcherCast<const FieldType&>(matcher)));
-  // The call to MatcherCast() is required for supporting inner
-  // matchers of compatible types.  For example, it allows
-  //   Field(&Foo::bar, m)
-  // to compile where bar is an int32 and m is a matcher for int64.
-}
-
-// Creates a matcher that matches an object whose given property
-// matches 'matcher'.  For example,
-//   Property(&Foo::str, StartsWith("hi"))
-// matches a Foo object x iff x.str() starts with "hi".
-template <typename Class, typename PropertyType, typename PropertyMatcher>
-inline PolymorphicMatcher<
-  internal::PropertyMatcher<Class, PropertyType> > Property(
-    PropertyType (Class::*property)() const, const PropertyMatcher& matcher) {
-  return MakePolymorphicMatcher(
-      internal::PropertyMatcher<Class, PropertyType>(
-          property,
-          MatcherCast<GTEST_REFERENCE_TO_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.
-}
-
-// Creates a matcher that matches an object iff the result of applying
-// a callable to x matches 'matcher'.
-// For example,
-//   ResultOf(f, StartsWith("hi"))
-// matches a Foo object x iff f(x) starts with "hi".
-// callable parameter can be a function, function pointer, or a functor.
-// Callable has to satisfy the following conditions:
-//   * 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.
-//   * If it is a function object, it has to define type result_type.
-//     We recommend deriving your functor classes from std::unary_function.
-template <typename Callable, typename ResultOfMatcher>
-internal::ResultOfMatcher<Callable> ResultOf(
-    Callable callable, const ResultOfMatcher& matcher) {
-  return internal::ResultOfMatcher<Callable>(
-          callable,
-          MatcherCast<typename internal::CallableTraits<Callable>::ResultType>(
-              matcher));
-  // The call to MatcherCast() is required for supporting inner
-  // matchers of compatible types.  For example, it allows
-  //   ResultOf(Function, m)
-  // to compile where Function() returns an int32 and m is a matcher for int64.
-}
-
-// String matchers.
-
-// Matches a string equal to str.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
-    StrEq(const internal::string& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
-      str, true, true));
-}
-
-// Matches a string not equal to str.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
-    StrNe(const internal::string& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
-      str, false, true));
-}
-
-// Matches a string equal to str, ignoring case.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
-    StrCaseEq(const internal::string& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
-      str, true, false));
-}
-
-// Matches a string not equal to str, ignoring case.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
-    StrCaseNe(const internal::string& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
-      str, false, false));
-}
-
-// Creates a matcher that matches any string, std::string, or C string
-// that contains the given substring.
-inline PolymorphicMatcher<internal::HasSubstrMatcher<internal::string> >
-    HasSubstr(const internal::string& substring) {
-  return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::string>(
-      substring));
-}
-
-// Matches a string that starts with 'prefix' (case-sensitive).
-inline PolymorphicMatcher<internal::StartsWithMatcher<internal::string> >
-    StartsWith(const internal::string& prefix) {
-  return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::string>(
-      prefix));
-}
-
-// Matches a string that ends with 'suffix' (case-sensitive).
-inline PolymorphicMatcher<internal::EndsWithMatcher<internal::string> >
-    EndsWith(const internal::string& suffix) {
-  return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::string>(
-      suffix));
-}
-
-// 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));
-}
-inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
-    const internal::string& regex) {
-  return MatchesRegex(new internal::RE(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));
-}
-inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
-    const internal::string& regex) {
-  return ContainsRegex(new internal::RE(regex));
-}
-
-#if GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING
-// Wide string matchers.
-
-// Matches a string equal to str.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
-    StrEq(const internal::wstring& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
-      str, true, true));
-}
-
-// Matches a string not equal to str.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
-    StrNe(const internal::wstring& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
-      str, false, true));
-}
-
-// Matches a string equal to str, ignoring case.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
-    StrCaseEq(const internal::wstring& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
-      str, true, false));
-}
-
-// Matches a string not equal to str, ignoring case.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
-    StrCaseNe(const internal::wstring& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
-      str, false, false));
-}
-
-// Creates a matcher that matches any wstring, std::wstring, or C wide string
-// that contains the given substring.
-inline PolymorphicMatcher<internal::HasSubstrMatcher<internal::wstring> >
-    HasSubstr(const internal::wstring& substring) {
-  return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::wstring>(
-      substring));
-}
-
-// Matches a string that starts with 'prefix' (case-sensitive).
-inline PolymorphicMatcher<internal::StartsWithMatcher<internal::wstring> >
-    StartsWith(const internal::wstring& prefix) {
-  return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::wstring>(
-      prefix));
-}
-
-// Matches a string that ends with 'suffix' (case-sensitive).
-inline PolymorphicMatcher<internal::EndsWithMatcher<internal::wstring> >
-    EndsWith(const internal::wstring& suffix) {
-  return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::wstring>(
-      suffix));
-}
-
-#endif  // GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING
-
-// Creates a polymorphic matcher that matches a 2-tuple where the
-// first field == the second field.
-inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }
-
-// Creates a polymorphic matcher that matches a 2-tuple where the
-// first field >= the second field.
-inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); }
-
-// Creates a polymorphic matcher that matches a 2-tuple where the
-// first field > the second field.
-inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); }
-
-// Creates a polymorphic matcher that matches a 2-tuple where the
-// first field <= the second field.
-inline internal::Le2Matcher Le() { return internal::Le2Matcher(); }
-
-// Creates a polymorphic matcher that matches a 2-tuple where the
-// first field < the second field.
-inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }
-
-// Creates a polymorphic matcher that matches a 2-tuple where the
-// first field != the second field.
-inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }
-
-// Creates a matcher that matches any value of type T that m doesn't
-// match.
-template <typename InnerMatcher>
-inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) {
-  return internal::NotMatcher<InnerMatcher>(m);
-}
-
-// Returns a matcher that matches anything that satisfies the given
-// predicate.  The predicate can be any unary function or functor
-// whose return type can be implicitly converted to bool.
-template <typename Predicate>
-inline PolymorphicMatcher<internal::TrulyMatcher<Predicate> >
-Truly(Predicate pred) {
-  return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
-}
-
-// Returns a matcher that matches the container size. The container must
-// support both size() and size_type which all STL-like containers provide.
-// Note that the parameter 'size' can be a value of type size_type as well as
-// matcher. For instance:
-//   EXPECT_THAT(container, SizeIs(2));     // Checks container has 2 elements.
-//   EXPECT_THAT(container, SizeIs(Le(2));  // Checks container has at most 2.
-template <typename SizeMatcher>
-inline internal::SizeIsMatcher<SizeMatcher>
-SizeIs(const SizeMatcher& size_matcher) {
-  return internal::SizeIsMatcher<SizeMatcher>(size_matcher);
-}
-
-// Returns a matcher that matches the distance between the container's begin()
-// iterator and its end() iterator, i.e. the size of the container. This matcher
-// can be used instead of SizeIs with containers such as std::forward_list which
-// do not implement size(). The container must provide const_iterator (with
-// valid iterator_traits), begin() and end().
-template <typename DistanceMatcher>
-inline internal::BeginEndDistanceIsMatcher<DistanceMatcher>
-BeginEndDistanceIs(const DistanceMatcher& distance_matcher) {
-  return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher);
-}
-
-// Returns a matcher that matches an equal container.
-// This matcher behaves like Eq(), but in the event of mismatch lists the
-// 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<  // NOLINT
-                            GTEST_REMOVE_CONST_(Container)> >
-    ContainerEq(const Container& rhs) {
-  // This following line is for working around a bug in MSVC 8.0,
-  // which causes Container to be a const type sometimes.
-  typedef GTEST_REMOVE_CONST_(Container) RawContainer;
-  return MakePolymorphicMatcher(
-      internal::ContainerEqMatcher<RawContainer>(rhs));
-}
-
-// Returns a matcher that matches a container that, when sorted using
-// the given comparator, matches container_matcher.
-template <typename Comparator, typename ContainerMatcher>
-inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher>
-WhenSortedBy(const Comparator& comparator,
-             const ContainerMatcher& container_matcher) {
-  return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(
-      comparator, container_matcher);
-}
-
-// Returns a matcher that matches a container that, when sorted using
-// the < operator, matches container_matcher.
-template <typename ContainerMatcher>
-inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>
-WhenSorted(const ContainerMatcher& container_matcher) {
-  return
-      internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>(
-          internal::LessComparator(), 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<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,
-                                  GTEST_REMOVE_CONST_(Container)>
-Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
-  // This following line is for working around a bug in MSVC 8.0,
-  // which causes Container to be a const type sometimes (e.g. when
-  // rhs is a const int[])..
-  typedef GTEST_REMOVE_CONST_(Container) RawContainer;
-  return internal::PointwiseMatcher<TupleMatcher, RawContainer>(
-      tuple_matcher, rhs);
-}
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-
-// Supports the Pointwise(m, {a, b, c}) syntax.
-template <typename TupleMatcher, typename T>
-inline internal::PointwiseMatcher<TupleMatcher, std::vector<T> > Pointwise(
-    const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {
-  return Pointwise(tuple_matcher, std::vector<T>(rhs));
-}
-
-#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
-
-// UnorderedPointwise(pair_matcher, rhs) matches an STL-style
-// container or a native array that contains the same number of
-// 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<tuple<const T1&, const T2&> >, where T1 and T2 are
-// the types of elements in the LHS container and the RHS container
-// respectively.
-//
-// This is like Pointwise(pair_matcher, rhs), except that the element
-// order doesn't matter.
-template <typename Tuple2Matcher, typename RhsContainer>
-inline internal::UnorderedElementsAreArrayMatcher<
-    typename internal::BoundSecondMatcher<
-        Tuple2Matcher, typename internal::StlContainerView<GTEST_REMOVE_CONST_(
-                           RhsContainer)>::type::value_type> >
-UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
-                   const RhsContainer& rhs_container) {
-  // This following line is for working around a bug in MSVC 8.0,
-  // which causes RhsContainer to be a const type sometimes (e.g. when
-  // rhs_container is a const int[]).
-  typedef GTEST_REMOVE_CONST_(RhsContainer) RawRhsContainer;
-
-  // 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<RawRhsContainer> RhsView;
-  typedef typename RhsView::type RhsStlContainer;
-  typedef typename RhsStlContainer::value_type Second;
-  const RhsStlContainer& rhs_stl_container =
-      RhsView::ConstReference(rhs_container);
-
-  // Create a matcher for each element in rhs_container.
-  ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers;
-  for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin();
-       it != rhs_stl_container.end(); ++it) {
-    matchers.push_back(
-        internal::MatcherBindSecond(tuple2_matcher, *it));
-  }
-
-  // Delegate the work to UnorderedElementsAreArray().
-  return UnorderedElementsAreArray(matchers);
-}
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-
-// Supports the UnorderedPointwise(m, {a, b, c}) syntax.
-template <typename Tuple2Matcher, typename T>
-inline internal::UnorderedElementsAreArrayMatcher<
-    typename internal::BoundSecondMatcher<Tuple2Matcher, T> >
-UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
-                   std::initializer_list<T> rhs) {
-  return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));
-}
-
-#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
-
-// Matches an STL-style container or a native array that contains at
-// least one element matching the given value or matcher.
-//
-// Examples:
-//   ::std::set<int> page_ids;
-//   page_ids.insert(3);
-//   page_ids.insert(1);
-//   EXPECT_THAT(page_ids, Contains(1));
-//   EXPECT_THAT(page_ids, Contains(Gt(2)));
-//   EXPECT_THAT(page_ids, Not(Contains(4)));
-//
-//   ::std::map<int, size_t> page_lengths;
-//   page_lengths[1] = 100;
-//   EXPECT_THAT(page_lengths,
-//               Contains(::std::pair<const int, size_t>(1, 100)));
-//
-//   const char* user_ids[] = { "joe", "mike", "tom" };
-//   EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom"))));
-template <typename M>
-inline internal::ContainsMatcher<M> Contains(M matcher) {
-  return internal::ContainsMatcher<M>(matcher);
-}
-
-// Matches an STL-style container or a native array that contains only
-// elements matching the given value or matcher.
-//
-// Each(m) is semantically equivalent to Not(Contains(Not(m))). Only
-// the messages are different.
-//
-// Examples:
-//   ::std::set<int> page_ids;
-//   // Each(m) matches an empty container, regardless of what m is.
-//   EXPECT_THAT(page_ids, Each(Eq(1)));
-//   EXPECT_THAT(page_ids, Each(Eq(77)));
-//
-//   page_ids.insert(3);
-//   EXPECT_THAT(page_ids, Each(Gt(0)));
-//   EXPECT_THAT(page_ids, Not(Each(Gt(4))));
-//   page_ids.insert(1);
-//   EXPECT_THAT(page_ids, Not(Each(Lt(2))));
-//
-//   ::std::map<int, size_t> page_lengths;
-//   page_lengths[1] = 100;
-//   page_lengths[2] = 200;
-//   page_lengths[3] = 300;
-//   EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100))));
-//   EXPECT_THAT(page_lengths, Each(Key(Le(3))));
-//
-//   const char* user_ids[] = { "joe", "mike", "tom" };
-//   EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom")))));
-template <typename M>
-inline internal::EachMatcher<M> Each(M matcher) {
-  return internal::EachMatcher<M>(matcher);
-}
-
-// 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
-// std::map that contains at least one element whose key is >= 5.
-template <typename M>
-inline internal::KeyMatcher<M> Key(M inner_matcher) {
-  return internal::KeyMatcher<M>(inner_matcher);
-}
-
-// Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field
-// matches first_matcher and whose 'second' field matches second_matcher.  For
-// example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used
-// to match a std::map<int, string> that contains exactly one element whose key
-// is >= 5 and whose value equals "foo".
-template <typename FirstMatcher, typename SecondMatcher>
-inline internal::PairMatcher<FirstMatcher, SecondMatcher>
-Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) {
-  return internal::PairMatcher<FirstMatcher, SecondMatcher>(
-      first_matcher, second_matcher);
-}
-
-// Returns a predicate that is satisfied by anything that matches the
-// given matcher.
-template <typename M>
-inline internal::MatcherAsPredicate<M> Matches(M matcher) {
-  return internal::MatcherAsPredicate<M>(matcher);
-}
-
-// Returns true iff the value matches the matcher.
-template <typename T, typename M>
-inline bool Value(const T& value, M matcher) {
-  return testing::Matches(matcher)(value);
-}
-
-// Matches the value against the given matcher and explains the match
-// result to listener.
-template <typename T, typename M>
-inline bool ExplainMatchResult(
-    M matcher, const T& value, MatchResultListener* listener) {
-  return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
-}
-
-#if GTEST_LANG_CXX11
-// Define variadic matcher versions. They are overloaded in
-// gmock-generated-matchers.h for the cases supported by pre C++11 compilers.
-template <typename... Args>
-inline internal::AllOfMatcher<Args...> AllOf(const Args&... matchers) {
-  return internal::AllOfMatcher<Args...>(matchers...);
-}
-
-template <typename... Args>
-inline internal::AnyOfMatcher<Args...> AnyOf(const Args&... matchers) {
-  return internal::AnyOfMatcher<Args...>(matchers...);
-}
-
-#endif  // GTEST_LANG_CXX11
-
-// AllArgs(m) is a synonym of m.  This is useful in
-//
-//   EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq()));
-//
-// which is easier to read than
-//
-//   EXPECT_CALL(foo, Bar(_, _)).With(Eq());
-template <typename InnerMatcher>
-inline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; }
-
-// These macros allow using matchers to check values in Google Test
-// tests.  ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)
-// succeed iff 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)
-
-}  // namespace testing
-
-// 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  // GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-actions.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-actions.h
deleted file mode 100644
index 3d387b6b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-actions.h
+++ /dev/null
@@ -1,246 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some actions that depend on gmock-generated-actions.h.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
-
-#include <algorithm>
-
-#include "gmock/gmock-generated-actions.h"
-
-namespace testing {
-namespace internal {
-
-// Implements the Invoke(f) action.  The template argument
-// FunctionImpl is the implementation type of f, which can be either a
-// function pointer or a functor.  Invoke(f) can be used as an
-// Action<F> as long as f's type is compatible with F (i.e. f can be
-// assigned to a tr1::function<F>).
-template <typename FunctionImpl>
-class InvokeAction {
- public:
-  // The c'tor makes a copy of function_impl (either a function
-  // pointer or a functor).
-  explicit InvokeAction(FunctionImpl function_impl)
-      : function_impl_(function_impl) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) {
-    return InvokeHelper<Result, ArgumentTuple>::Invoke(function_impl_, args);
-  }
-
- private:
-  FunctionImpl function_impl_;
-
-  GTEST_DISALLOW_ASSIGN_(InvokeAction);
-};
-
-// Implements the Invoke(object_ptr, &Class::Method) action.
-template <class Class, typename MethodPtr>
-class InvokeMethodAction {
- public:
-  InvokeMethodAction(Class* obj_ptr, MethodPtr method_ptr)
-      : method_ptr_(method_ptr), obj_ptr_(obj_ptr) {}
-
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) const {
-    return InvokeHelper<Result, ArgumentTuple>::InvokeMethod(
-        obj_ptr_, method_ptr_, args);
-  }
-
- private:
-  // The order of these members matters.  Reversing the order can trigger
-  // warning C4121 in MSVC (see
-  // http://computer-programming-forum.com/7-vc.net/6fbc30265f860ad1.htm ).
-  const MethodPtr method_ptr_;
-  Class* const obj_ptr_;
-
-  GTEST_DISALLOW_ASSIGN_(InvokeMethodAction);
-};
-
-// An internal replacement for std::copy which mimics its behavior. This is
-// necessary because Visual Studio deprecates ::std::copy, issuing warning 4996.
-// However Visual Studio 2010 and later do not honor #pragmas which disable that
-// warning.
-template<typename InputIterator, typename OutputIterator>
-inline OutputIterator CopyElements(InputIterator first,
-                                   InputIterator last,
-                                   OutputIterator output) {
-  for (; first != last; ++first, ++output) {
-    *output = *first;
-  }
-  return output;
-}
-
-}  // namespace internal
-
-// Various overloads for Invoke().
-
-// Creates an action that invokes 'function_impl' with the mock
-// function's arguments.
-template <typename FunctionImpl>
-PolymorphicAction<internal::InvokeAction<FunctionImpl> > Invoke(
-    FunctionImpl function_impl) {
-  return MakePolymorphicAction(
-      internal::InvokeAction<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>
-PolymorphicAction<internal::InvokeMethodAction<Class, MethodPtr> > Invoke(
-    Class* obj_ptr, MethodPtr method_ptr) {
-  return MakePolymorphicAction(
-      internal::InvokeMethodAction<Class, MethodPtr>(obj_ptr, method_ptr));
-}
-
-// 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>
-inline internal::WithArgsAction<InnerAction>
-WithoutArgs(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction>(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 <int k, typename InnerAction>
-inline internal::WithArgsAction<InnerAction, k>
-WithArg(const InnerAction& action) {
-  return internal::WithArgsAction<InnerAction, k>(action);
-}
-
-// 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
-// is expanded and macro expansion cannot contain #pragma.  Therefore
-// we suppress them here.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
-#endif
-
-// Action ReturnArg<k>() returns the k-th argument of the mock function.
-ACTION_TEMPLATE(ReturnArg,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_0_VALUE_PARAMS()) {
-  return ::testing::get<k>(args);
-}
-
-// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
-// mock function to *pointer.
-ACTION_TEMPLATE(SaveArg,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_1_VALUE_PARAMS(pointer)) {
-  *pointer = ::testing::get<k>(args);
-}
-
-// Action SaveArgPointee<k>(pointer) saves the value pointed to
-// by the k-th (0-based) argument of the mock function to *pointer.
-ACTION_TEMPLATE(SaveArgPointee,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_1_VALUE_PARAMS(pointer)) {
-  *pointer = *::testing::get<k>(args);
-}
-
-// Action SetArgReferee<k>(value) assigns 'value' to the variable
-// referenced by the k-th (0-based) argument of the mock function.
-ACTION_TEMPLATE(SetArgReferee,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_1_VALUE_PARAMS(value)) {
-  typedef typename ::testing::tuple_element<k, args_type>::type argk_type;
-  // Ensures that argument #k is a reference.  If you get a compiler
-  // error on the next line, you are using SetArgReferee<k>(value) in
-  // a mock function whose k-th (0-based) argument is not a reference.
-  GTEST_COMPILE_ASSERT_(internal::is_reference<argk_type>::value,
-                        SetArgReferee_must_be_used_with_a_reference_argument);
-  ::testing::get<k>(args) = 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.
-ACTION_TEMPLATE(SetArrayArgument,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_2_VALUE_PARAMS(first, last)) {
-  // Visual Studio deprecates ::std::copy, so we use our own copy in that case.
-#ifdef _MSC_VER
-  internal::CopyElements(first, last, ::testing::get<k>(args));
-#else
-  ::std::copy(first, last, ::testing::get<k>(args));
-#endif
-}
-
-// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
-// function.
-ACTION_TEMPLATE(DeleteArg,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_0_VALUE_PARAMS()) {
-  delete ::testing::get<k>(args);
-}
-
-// This action returns the value pointed to by 'pointer'.
-ACTION_P(ReturnPointee, 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
-
-// Suppresses the 'unreachable code' warning that VC generates in opt modes.
-# ifdef _MSC_VER
-#  pragma warning(push)          // Saves the current warning state.
-#  pragma warning(disable:4702)  // Temporarily disables warning 4702.
-# endif
-ACTION_P(Throw, exception) { throw exception; }
-# ifdef _MSC_VER
-#  pragma warning(pop)           // Restores the warning state.
-# endif
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-matchers.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-matchers.h
deleted file mode 100644
index 3db899f4..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-more-matchers.h
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2013, 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.
-//
-// Author: marcus.boerger@google.com (Marcus Boerger)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements some matchers that depend on gmock-generated-matchers.h.
-//
-// Note that tests are implemented in gmock-matchers_test.cc rather than
-// gmock-more-matchers-test.cc.
-
-#ifndef GMOCK_GMOCK_MORE_MATCHERS_H_
-#define GMOCK_GMOCK_MORE_MATCHERS_H_
-
-#include "gmock/gmock-generated-matchers.h"
-
-namespace testing {
-
-// 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") {
-  if (arg.empty()) {
-    return true;
-  }
-  *result_listener << "whose size is " << arg.size();
-  return false;
-}
-
-}  // namespace testing
-
-#endif  // GMOCK_GMOCK_MORE_MATCHERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-spec-builders.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-spec-builders.h
deleted file mode 100644
index fed7de66..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock-spec-builders.h
+++ /dev/null
@@ -1,1847 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements the ON_CALL() and EXPECT_CALL() macros.
-//
-// A user can use the ON_CALL() macro to specify the default action of
-// a mock method.  The syntax is:
-//
-//   ON_CALL(mock_object, Method(argument-matchers))
-//       .With(multi-argument-matcher)
-//       .WillByDefault(action);
-//
-//  where the .With() clause is optional.
-//
-// A user can use the EXPECT_CALL() macro to specify an expectation on
-// a mock method.  The syntax is:
-//
-//   EXPECT_CALL(mock_object, Method(argument-matchers))
-//       .With(multi-argument-matchers)
-//       .Times(cardinality)
-//       .InSequence(sequences)
-//       .After(expectations)
-//       .WillOnce(action)
-//       .WillRepeatedly(action)
-//       .RetiresOnSaturation();
-//
-// where all clauses are optional, and .InSequence()/.After()/
-// .WillOnce() can appear any number of times.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
-
-#include <map>
-#include <set>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#if GTEST_HAS_EXCEPTIONS
-# include <stdexcept>  // NOLINT
-#endif
-
-#include "gmock/gmock-actions.h"
-#include "gmock/gmock-cardinalities.h"
-#include "gmock/gmock-matchers.h"
-#include "gmock/internal/gmock-internal-utils.h"
-#include "gmock/internal/gmock-port.h"
-#include "gtest/gtest.h"
-
-namespace testing {
-
-// An abstract handle of an expectation.
-class Expectation;
-
-// A set of expectation handles.
-class ExpectationSet;
-
-// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
-// and MUST NOT BE USED IN USER CODE!!!
-namespace internal {
-
-// Implements a mock function.
-template <typename F> class FunctionMocker;
-
-// Base class for expectations.
-class ExpectationBase;
-
-// Implements an expectation.
-template <typename F> class TypedExpectation;
-
-// Helper class for testing the Expectation class template.
-class ExpectationTester;
-
-// Base class for function mockers.
-template <typename F> class FunctionMockerBase;
-
-// Protects the mock object registry (in class Mock), all function
-// mockers, and all expectations.
-//
-// The reason we don't use more fine-grained protection is: when a
-// mock function Foo() is called, it needs to consult its expectations
-// to see which one should be picked.  If another thread is allowed to
-// call a mock function (either Foo() or a different one) at the same
-// time, it could affect the "retired" attributes of Foo()'s
-// expectations when InSequence() is used, and thus affect which
-// expectation gets picked.  Therefore, we sequence all mock function
-// calls to ensure the integrity of the mock objects' states.
-GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
-
-// Untyped base class for ActionResultHolder<R>.
-class UntypedActionResultHolderBase;
-
-// Abstract base class of FunctionMockerBase.  This is the
-// type-agnostic part of the function mocker interface.  Its pure
-// virtual methods are implemented by FunctionMockerBase.
-class GTEST_API_ UntypedFunctionMockerBase {
- public:
-  UntypedFunctionMockerBase();
-  virtual ~UntypedFunctionMockerBase();
-
-  // Verifies that all expectations on this mock function have been
-  // satisfied.  Reports one or more Google Test non-fatal failures
-  // and returns false if not.
-  bool VerifyAndClearExpectationsLocked()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
-
-  // Clears the ON_CALL()s set on this mock function.
-  virtual void ClearDefaultActionsLocked()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0;
-
-  // In all of the following Untyped* functions, it's the caller's
-  // responsibility to guarantee the correctness of the arguments'
-  // types.
-
-  // Performs the default action with the given arguments and returns
-  // the action's result.  The call description string will be used in
-  // the error message to describe the call in the case the default
-  // action fails.
-  // L = *
-  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
-      const void* untyped_args,
-      const 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,
-      const void* untyped_args) const = 0;
-
-  // Writes a message that the call is uninteresting (i.e. neither
-  // explicitly expected nor explicitly unexpected) to the given
-  // ostream.
-  virtual void UntypedDescribeUninterestingCall(
-      const void* untyped_args,
-      ::std::ostream* os) const
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
-
-  // Returns the expectation that matches the given function arguments
-  // (or NULL is there's no match); when a match is found,
-  // untyped_action is set to point to the action that should be
-  // performed (or NULL if the action is "do default"), and
-  // is_excessive is modified to indicate whether the call exceeds the
-  // expected number.
-  virtual const ExpectationBase* UntypedFindMatchingExpectation(
-      const void* untyped_args,
-      const void** untyped_action, bool* is_excessive,
-      ::std::ostream* what, ::std::ostream* why)
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
-
-  // Prints the given function arguments to the ostream.
-  virtual void UntypedPrintArgs(const void* untyped_args,
-                                ::std::ostream* os) const = 0;
-
-  // Sets the mock object this mock method belongs to, and registers
-  // this information in the global mock registry.  Will be called
-  // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
-  // method.
-  // TODO(wan@google.com): rename to SetAndRegisterOwner().
-  void RegisterOwner(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
-
-  // Sets the mock object this mock method belongs to, and sets the
-  // name of the mock function.  Will be called upon each invocation
-  // of this mock function.
-  void SetOwnerAndName(const void* mock_obj, const char* name)
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
-
-  // Returns the mock object this mock method belongs to.  Must be
-  // called after RegisterOwner() or SetOwnerAndName() has been
-  // called.
-  const void* MockObject() const
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
-
-  // Returns the name of this mock method.  Must be called after
-  // SetOwnerAndName() has been called.
-  const char* Name() const
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
-
-  // Returns the result of invoking this mock function with the given
-  // arguments.  This function can be safely called from multiple
-  // threads concurrently.  The caller is responsible for deleting the
-  // result.
-  UntypedActionResultHolderBase* UntypedInvokeWith(
-      const void* untyped_args)
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
-
- protected:
-  typedef std::vector<const void*> UntypedOnCallSpecs;
-
-  typedef std::vector<internal::linked_ptr<ExpectationBase> >
-  UntypedExpectations;
-
-  // Returns an Expectation object that references and co-owns exp,
-  // which must be an expectation on this mock function.
-  Expectation GetHandleOf(ExpectationBase* exp);
-
-  // Address of the mock object this mock method belongs to.  Only
-  // valid after this mock method has been called or
-  // ON_CALL/EXPECT_CALL has been invoked on it.
-  const void* mock_obj_;  // Protected by g_gmock_mutex.
-
-  // Name of the function being mocked.  Only valid after this mock
-  // method has been called.
-  const char* name_;  // Protected by g_gmock_mutex.
-
-  // All default action specs for this function mocker.
-  UntypedOnCallSpecs untyped_on_call_specs_;
-
-  // All expectations for this function mocker.
-  UntypedExpectations untyped_expectations_;
-};  // class UntypedFunctionMockerBase
-
-// Untyped base class for OnCallSpec<F>.
-class UntypedOnCallSpecBase {
- public:
-  // The arguments are the location of the ON_CALL() statement.
-  UntypedOnCallSpecBase(const char* a_file, int a_line)
-      : file_(a_file), line_(a_line), last_clause_(kNone) {}
-
-  // Where in the source file was the default action spec defined?
-  const char* file() const { return file_; }
-  int line() const { return line_; }
-
- protected:
-  // Gives each clause in the ON_CALL() statement a name.
-  enum Clause {
-    // Do not change the order of the enum members!  The run-time
-    // syntax checking relies on it.
-    kNone,
-    kWith,
-    kWillByDefault
-  };
-
-  // Asserts that the ON_CALL() statement has a certain property.
-  void AssertSpecProperty(bool property, const 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 string& failure_message) const {
-    Expect(property, file_, line_, failure_message);
-  }
-
-  const char* file_;
-  int line_;
-
-  // The last clause in the ON_CALL() statement as seen so far.
-  // Initially kNone and changes as the statement is parsed.
-  Clause last_clause_;
-};  // class UntypedOnCallSpecBase
-
-// This template class implements an ON_CALL spec.
-template <typename F>
-class OnCallSpec : public UntypedOnCallSpecBase {
- public:
-  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
-
-  // Constructs an OnCallSpec object from the information inside
-  // the parenthesis of an ON_CALL() statement.
-  OnCallSpec(const char* a_file, int a_line,
-             const ArgumentMatcherTuple& matchers)
-      : UntypedOnCallSpecBase(a_file, a_line),
-        matchers_(matchers),
-        // By default, extra_matcher_ should match anything.  However,
-        // we cannot initialize it with _ as that triggers a compiler
-        // bug in Symbian's C++ compiler (cannot decide between two
-        // overloaded constructors of Matcher<const ArgumentTuple&>).
-        extra_matcher_(A<const ArgumentTuple&>()) {
-  }
-
-  // Implements the .With() clause.
-  OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
-    // Makes sure this is called at most once.
-    ExpectSpecProperty(last_clause_ < kWith,
-                       ".With() cannot appear "
-                       "more than once in an ON_CALL().");
-    last_clause_ = kWith;
-
-    extra_matcher_ = m;
-    return *this;
-  }
-
-  // Implements the .WillByDefault() clause.
-  OnCallSpec& WillByDefault(const Action<F>& action) {
-    ExpectSpecProperty(last_clause_ < kWillByDefault,
-                       ".WillByDefault() must appear "
-                       "exactly once in an ON_CALL().");
-    last_clause_ = kWillByDefault;
-
-    ExpectSpecProperty(!action.IsDoDefault(),
-                       "DoDefault() cannot be used in ON_CALL().");
-    action_ = action;
-    return *this;
-  }
-
-  // Returns true iff the given arguments match the matchers.
-  bool Matches(const ArgumentTuple& args) const {
-    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
-  }
-
-  // Returns the action specified by the user.
-  const Action<F>& GetAction() const {
-    AssertSpecProperty(last_clause_ == kWillByDefault,
-                       ".WillByDefault() must appear exactly "
-                       "once in an ON_CALL().");
-    return action_;
-  }
-
- private:
-  // The information in statement
-  //
-  //   ON_CALL(mock_object, Method(matchers))
-  //       .With(multi-argument-matcher)
-  //       .WillByDefault(action);
-  //
-  // is recorded in the data members like this:
-  //
-  //   source file that contains the statement => file_
-  //   line number of the statement            => line_
-  //   matchers                                => matchers_
-  //   multi-argument-matcher                  => extra_matcher_
-  //   action                                  => action_
-  ArgumentMatcherTuple matchers_;
-  Matcher<const ArgumentTuple&> extra_matcher_;
-  Action<F> action_;
-};  // class OnCallSpec
-
-// Possible reactions on uninteresting calls.
-enum CallReaction {
-  kAllow,
-  kWarn,
-  kFail,
-  kDefault = kWarn  // By default, warn about uninteresting calls.
-};
-
-}  // namespace internal
-
-// Utilities for manipulating mock objects.
-class GTEST_API_ Mock {
- public:
-  // The following public methods can be called concurrently.
-
-  // Tells Google Mock to ignore mock_obj when checking for leaked
-  // mock objects.
-  static void AllowLeak(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Verifies and clears all expectations on the given mock object.
-  // If the expectations aren't satisfied, generates one or more
-  // Google Test non-fatal failures and returns false.
-  static bool VerifyAndClearExpectations(void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Verifies all expectations on the given mock object and clears its
-  // default actions and expectations.  Returns true iff the
-  // verification was successful.
-  static bool VerifyAndClear(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::FunctionMockerBase;
-
-  template <typename M>
-  friend class NiceMock;
-
-  template <typename M>
-  friend class NaggyMock;
-
-  template <typename M>
-  friend class StrictMock;
-
-  // Tells Google Mock to allow uninteresting calls on the given mock
-  // object.
-  static void AllowUninterestingCalls(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Tells Google Mock to warn the user about uninteresting calls on
-  // the given mock object.
-  static void WarnUninterestingCalls(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Tells Google Mock to fail uninteresting calls on the given mock
-  // object.
-  static void FailUninterestingCalls(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Tells Google Mock the given mock object is being destroyed and
-  // its entry in the call-reaction table should be removed.
-  static void UnregisterCallReaction(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Returns the reaction Google Mock will have on uninteresting calls
-  // made on the given mock object.
-  static internal::CallReaction GetReactionOnUninterestingCalls(
-      const void* mock_obj)
-          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Verifies that all expectations on the given mock object have been
-  // satisfied.  Reports one or more Google Test non-fatal failures
-  // and returns false if not.
-  static bool VerifyAndClearExpectationsLocked(void* mock_obj)
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
-
-  // Clears all ON_CALL()s set on the given mock object.
-  static void ClearDefaultActionsLocked(void* mock_obj)
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
-
-  // Registers a mock object and a mock method it owns.
-  static void Register(
-      const void* mock_obj,
-      internal::UntypedFunctionMockerBase* mocker)
-          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // Tells Google Mock where in the source code mock_obj is used in an
-  // ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
-  // information helps the user identify which object it is.
-  static void RegisterUseByOnCallOrExpectCall(
-      const void* mock_obj, const char* file, int line)
-          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
-  // 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
-  // FunctionMockerBase.
-  static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
-};  // class Mock
-
-// An abstract handle of an expectation.  Useful in the .After()
-// clause of EXPECT_CALL() for setting the (partial) order of
-// expectations.  The syntax:
-//
-//   Expectation e1 = EXPECT_CALL(...)...;
-//   EXPECT_CALL(...).After(e1)...;
-//
-// sets two expectations where the latter can only be matched after
-// the former has been satisfied.
-//
-// Notes:
-//   - This class is copyable and has value semantics.
-//   - 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().
-//   - The constructors and destructor are defined out-of-line because
-//     the Symbian WINSCW compiler wants to otherwise instantiate them
-//     when it sees this class definition, at which point it doesn't have
-//     ExpectationBase available yet, leading to incorrect destruction
-//     in the linked_ptr (or compilation errors if using a checking
-//     linked_ptr).
-class GTEST_API_ Expectation {
- public:
-  // Constructs a null object that doesn't reference any expectation.
-  Expectation();
-
-  ~Expectation();
-
-  // This single-argument ctor must not be explicit, in order to support the
-  //   Expectation e = EXPECT_CALL(...);
-  // syntax.
-  //
-  // A TypedExpectation object stores its pre-requisites as
-  // Expectation objects, and needs to call the non-const Retire()
-  // method on the ExpectationBase objects they reference.  Therefore
-  // Expectation must receive a *non-const* reference to the
-  // ExpectationBase object.
-  Expectation(internal::ExpectationBase& exp);  // NOLINT
-
-  // The compiler-generated copy ctor and operator= work exactly as
-  // intended, so we don't need to define our own.
-
-  // Returns true iff rhs references the same expectation as this object does.
-  bool operator==(const Expectation& rhs) const {
-    return expectation_base_ == rhs.expectation_base_;
-  }
-
-  bool operator!=(const Expectation& rhs) const { return !(*this == rhs); }
-
- private:
-  friend class ExpectationSet;
-  friend class Sequence;
-  friend class ::testing::internal::ExpectationBase;
-  friend class ::testing::internal::UntypedFunctionMockerBase;
-
-  template <typename F>
-  friend class ::testing::internal::FunctionMockerBase;
-
-  template <typename F>
-  friend class ::testing::internal::TypedExpectation;
-
-  // This comparator is needed for putting Expectation objects into a set.
-  class Less {
-   public:
-    bool operator()(const Expectation& lhs, const Expectation& rhs) const {
-      return lhs.expectation_base_.get() < rhs.expectation_base_.get();
-    }
-  };
-
-  typedef ::std::set<Expectation, Less> Set;
-
-  Expectation(
-      const internal::linked_ptr<internal::ExpectationBase>& expectation_base);
-
-  // Returns the expectation this object references.
-  const internal::linked_ptr<internal::ExpectationBase>&
-  expectation_base() const {
-    return expectation_base_;
-  }
-
-  // A linked_ptr that co-owns the expectation this handle references.
-  internal::linked_ptr<internal::ExpectationBase> expectation_base_;
-};
-
-// A set of expectation handles.  Useful in the .After() clause of
-// EXPECT_CALL() for setting the (partial) order of expectations.  The
-// syntax:
-//
-//   ExpectationSet es;
-//   es += EXPECT_CALL(...)...;
-//   es += EXPECT_CALL(...)...;
-//   EXPECT_CALL(...).After(es)...;
-//
-// sets three expectations where the last one can only be matched
-// after the first two have both been satisfied.
-//
-// This class is copyable and has value semantics.
-class ExpectationSet {
- public:
-  // A bidirectional iterator that can read a const element in the set.
-  typedef Expectation::Set::const_iterator const_iterator;
-
-  // An object stored in the set.  This is an alias of Expectation.
-  typedef Expectation::Set::value_type value_type;
-
-  // Constructs an empty set.
-  ExpectationSet() {}
-
-  // This single-argument ctor must not be explicit, in order to support the
-  //   ExpectationSet es = EXPECT_CALL(...);
-  // syntax.
-  ExpectationSet(internal::ExpectationBase& exp) {  // NOLINT
-    *this += Expectation(exp);
-  }
-
-  // This single-argument ctor implements implicit conversion from
-  // Expectation and thus must not be explicit.  This allows either an
-  // Expectation or an ExpectationSet to be used in .After().
-  ExpectationSet(const Expectation& e) {  // NOLINT
-    *this += e;
-  }
-
-  // The compiler-generator ctor and operator= works exactly as
-  // intended, so we don't need to define our own.
-
-  // Returns true iff rhs contains the same set of Expectation objects
-  // as this does.
-  bool operator==(const ExpectationSet& rhs) const {
-    return expectations_ == rhs.expectations_;
-  }
-
-  bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); }
-
-  // Implements the syntax
-  //   expectation_set += EXPECT_CALL(...);
-  ExpectationSet& operator+=(const Expectation& e) {
-    expectations_.insert(e);
-    return *this;
-  }
-
-  int size() const { return static_cast<int>(expectations_.size()); }
-
-  const_iterator begin() const { return expectations_.begin(); }
-  const_iterator end() const { return expectations_.end(); }
-
- private:
-  Expectation::Set expectations_;
-};
-
-
-// Sequence objects are used by a user to specify the relative order
-// in which the expectations should match.  They are copyable (we rely
-// on the compiler-defined copy constructor and assignment operator).
-class GTEST_API_ Sequence {
- public:
-  // Constructs an empty sequence.
-  Sequence() : last_expectation_(new Expectation) {}
-
-  // Adds an expectation to this sequence.  The caller must ensure
-  // that no other thread is accessing this Sequence object.
-  void AddExpectation(const Expectation& expectation) const;
-
- private:
-  // The last expectation in this sequence.  We use a linked_ptr here
-  // because Sequence objects are copyable and we want the copies to
-  // be aliases.  The linked_ptr allows the copies to co-own and share
-  // the same Expectation object.
-  internal::linked_ptr<Expectation> last_expectation_;
-};  // class Sequence
-
-// An object of this type causes all EXPECT_CALL() statements
-// encountered in its scope to be put in an anonymous sequence.  The
-// work is done in the constructor and destructor.  You should only
-// create an InSequence object on the stack.
-//
-// The sole purpose for this class is to support easy definition of
-// sequential expectations, e.g.
-//
-//   {
-//     InSequence dummy;  // The name of the object doesn't matter.
-//
-//     // The following expectations must match in the order they appear.
-//     EXPECT_CALL(a, Bar())...;
-//     EXPECT_CALL(a, Baz())...;
-//     ...
-//     EXPECT_CALL(b, Xyz())...;
-//   }
-//
-// You can create InSequence objects in multiple threads, as long as
-// they are used to affect different mock objects.  The idea is that
-// each thread can create and set up its own mocks as if it's the only
-// thread.  However, for clarity of your tests we recommend you to set
-// up mocks in the main thread unless you have a good reason not to do
-// so.
-class GTEST_API_ InSequence {
- public:
-  InSequence();
-  ~InSequence();
- private:
-  bool sequence_created_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence);  // NOLINT
-} GTEST_ATTRIBUTE_UNUSED_;
-
-namespace internal {
-
-// Points to the implicit sequence introduced by a living InSequence
-// object (if any) in the current thread or NULL.
-GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence;
-
-// Base class for implementing expectations.
-//
-// There are two reasons for having a type-agnostic base class for
-// Expectation:
-//
-//   1. We need to store collections of expectations of different
-//   types (e.g. all pre-requisites of a particular expectation, all
-//   expectations in a sequence).  Therefore these expectation objects
-//   must share a common base class.
-//
-//   2. We can avoid binary code bloat by moving methods not depending
-//   on the template argument of Expectation to the base class.
-//
-// This class is internal and mustn't be used by user code directly.
-class GTEST_API_ ExpectationBase {
- public:
-  // source_text is the EXPECT_CALL(...) source that created this Expectation.
-  ExpectationBase(const char* file, int line, const string& source_text);
-
-  virtual ~ExpectationBase();
-
-  // Where in the source file was the expectation spec defined?
-  const char* file() const { return file_; }
-  int line() const { return line_; }
-  const char* source_text() const { return source_text_.c_str(); }
-  // Returns the cardinality specified in the expectation spec.
-  const Cardinality& cardinality() const { return cardinality_; }
-
-  // Describes the source file location of this expectation.
-  void DescribeLocationTo(::std::ostream* os) const {
-    *os << FormatFileLocation(file(), line()) << " ";
-  }
-
-  // Describes how many times a function call matching this
-  // expectation has occurred.
-  void DescribeCallCountTo(::std::ostream* os) const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
-
-  // If this mock method has an extra matcher (i.e. .With(matcher)),
-  // describes it to the ostream.
-  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0;
-
- protected:
-  friend class ::testing::Expectation;
-  friend class UntypedFunctionMockerBase;
-
-  enum Clause {
-    // Don't change the order of the enum members!
-    kNone,
-    kWith,
-    kTimes,
-    kInSequence,
-    kAfter,
-    kWillOnce,
-    kWillRepeatedly,
-    kRetiresOnSaturation
-  };
-
-  typedef std::vector<const void*> UntypedActions;
-
-  // Returns an Expectation object that references and co-owns this
-  // expectation.
-  virtual Expectation GetHandle() = 0;
-
-  // Asserts that the EXPECT_CALL() statement has the given property.
-  void AssertSpecProperty(bool property, const 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 string& failure_message) const {
-    Expect(property, file_, line_, failure_message);
-  }
-
-  // Explicitly specifies the cardinality of this expectation.  Used
-  // by the subclasses to implement the .Times() clause.
-  void SpecifyCardinality(const Cardinality& cardinality);
-
-  // Returns true iff the user specified the cardinality explicitly
-  // using a .Times().
-  bool cardinality_specified() const { return cardinality_specified_; }
-
-  // Sets the cardinality of this expectation spec.
-  void set_cardinality(const Cardinality& a_cardinality) {
-    cardinality_ = a_cardinality;
-  }
-
-  // The following group of methods should only be called after the
-  // EXPECT_CALL() statement, and only when g_gmock_mutex is held by
-  // the current thread.
-
-  // Retires all pre-requisites of this expectation.
-  void RetireAllPreRequisites()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
-
-  // Returns true iff this expectation is retired.
-  bool is_retired() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    return retired_;
-  }
-
-  // Retires this expectation.
-  void Retire()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    retired_ = true;
-  }
-
-  // Returns true iff 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 iff 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 iff 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 iff all pre-requisites of this expectation are satisfied.
-  bool AllPrerequisitesAreSatisfied() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
-
-  // Adds unsatisfied pre-requisites of this expectation to 'result'.
-  void FindUnsatisfiedPrerequisites(ExpectationSet* result) const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
-
-  // Returns the number this expectation has been invoked.
-  int call_count() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    return call_count_;
-  }
-
-  // Increments the number this expectation has been invoked.
-  void IncrementCallCount()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    call_count_++;
-  }
-
-  // Checks the action count (i.e. the number of WillOnce() and
-  // WillRepeatedly() clauses) against the cardinality if this hasn't
-  // been done before.  Prints a warning if there are too many or too
-  // few actions.
-  void CheckActionCountIfNotDone() const
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  friend class ::testing::Sequence;
-  friend class ::testing::internal::ExpectationTester;
-
-  template <typename Function>
-  friend class TypedExpectation;
-
-  // Implements the .Times() clause.
-  void UntypedTimes(const Cardinality& a_cardinality);
-
-  // This group of fields are part of the spec and won't change after
-  // an EXPECT_CALL() statement finishes.
-  const char* file_;          // The file that contains the expectation.
-  int line_;                  // The line number of the expectation.
-  const string source_text_;  // The EXPECT_CALL(...) source text.
-  // True iff 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 linked_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.
-  ExpectationSet immediate_prerequisites_;
-
-  // 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 iff this expectation has retired.
-  UntypedActions untyped_actions_;
-  bool extra_matcher_specified_;
-  bool repeated_action_specified_;  // True if a WillRepeatedly() was specified.
-  bool retires_on_saturation_;
-  Clause last_clause_;
-  mutable bool action_count_checked_;  // Under mutex_.
-  mutable Mutex mutex_;  // Protects action_count_checked_.
-
-  GTEST_DISALLOW_ASSIGN_(ExpectationBase);
-};  // class ExpectationBase
-
-// Impements an expectation for the given function type.
-template <typename F>
-class TypedExpectation : public ExpectationBase {
- public:
-  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
-  typedef typename Function<F>::Result Result;
-
-  TypedExpectation(FunctionMockerBase<F>* owner,
-                   const char* a_file, int a_line, const 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 triggers a compiler
-        // bug in Symbian's C++ compiler (cannot decide between two
-        // overloaded constructors of Matcher<const ArgumentTuple&>).
-        extra_matcher_(A<const ArgumentTuple&>()),
-        repeated_action_(DoDefault()) {}
-
-  virtual ~TypedExpectation() {
-    // Check the validity of the action count if it hasn't been done
-    // yet (for example, if the expectation was never used).
-    CheckActionCountIfNotDone();
-    for (UntypedActions::const_iterator it = untyped_actions_.begin();
-         it != untyped_actions_.end(); ++it) {
-      delete static_cast<const Action<F>*>(*it);
-    }
-  }
-
-  // Implements the .With() clause.
-  TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) {
-    if (last_clause_ == kWith) {
-      ExpectSpecProperty(false,
-                         ".With() cannot appear "
-                         "more than once in an EXPECT_CALL().");
-    } else {
-      ExpectSpecProperty(last_clause_ < kWith,
-                         ".With() must be the first "
-                         "clause in an EXPECT_CALL().");
-    }
-    last_clause_ = kWith;
-
-    extra_matcher_ = m;
-    extra_matcher_specified_ = true;
-    return *this;
-  }
-
-  // Implements the .Times() clause.
-  TypedExpectation& Times(const Cardinality& a_cardinality) {
-    ExpectationBase::UntypedTimes(a_cardinality);
-    return *this;
-  }
-
-  // Implements the .Times() clause.
-  TypedExpectation& Times(int n) {
-    return Times(Exactly(n));
-  }
-
-  // Implements the .InSequence() clause.
-  TypedExpectation& InSequence(const Sequence& s) {
-    ExpectSpecProperty(last_clause_ <= kInSequence,
-                       ".InSequence() cannot appear after .After(),"
-                       " .WillOnce(), .WillRepeatedly(), or "
-                       ".RetiresOnSaturation().");
-    last_clause_ = kInSequence;
-
-    s.AddExpectation(GetHandle());
-    return *this;
-  }
-  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) {
-    return InSequence(s1).InSequence(s2);
-  }
-  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
-                               const Sequence& s3) {
-    return InSequence(s1, s2).InSequence(s3);
-  }
-  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
-                               const Sequence& s3, const Sequence& s4) {
-    return InSequence(s1, s2, s3).InSequence(s4);
-  }
-  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
-                               const Sequence& s3, const Sequence& s4,
-                               const Sequence& s5) {
-    return InSequence(s1, s2, s3, s4).InSequence(s5);
-  }
-
-  // Implements that .After() clause.
-  TypedExpectation& After(const ExpectationSet& s) {
-    ExpectSpecProperty(last_clause_ <= kAfter,
-                       ".After() cannot appear after .WillOnce(),"
-                       " .WillRepeatedly(), or "
-                       ".RetiresOnSaturation().");
-    last_clause_ = kAfter;
-
-    for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) {
-      immediate_prerequisites_ += *it;
-    }
-    return *this;
-  }
-  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) {
-    return After(s1).After(s2);
-  }
-  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
-                          const ExpectationSet& s3) {
-    return After(s1, s2).After(s3);
-  }
-  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
-                          const ExpectationSet& s3, const ExpectationSet& s4) {
-    return After(s1, s2, s3).After(s4);
-  }
-  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
-                          const ExpectationSet& s3, const ExpectationSet& s4,
-                          const ExpectationSet& s5) {
-    return After(s1, s2, s3, s4).After(s5);
-  }
-
-  // Implements the .WillOnce() clause.
-  TypedExpectation& WillOnce(const Action<F>& action) {
-    ExpectSpecProperty(last_clause_ <= kWillOnce,
-                       ".WillOnce() cannot appear after "
-                       ".WillRepeatedly() or .RetiresOnSaturation().");
-    last_clause_ = kWillOnce;
-
-    untyped_actions_.push_back(new Action<F>(action));
-    if (!cardinality_specified()) {
-      set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
-    }
-    return *this;
-  }
-
-  // Implements the .WillRepeatedly() clause.
-  TypedExpectation& WillRepeatedly(const Action<F>& action) {
-    if (last_clause_ == kWillRepeatedly) {
-      ExpectSpecProperty(false,
-                         ".WillRepeatedly() cannot appear "
-                         "more than once in an EXPECT_CALL().");
-    } else {
-      ExpectSpecProperty(last_clause_ < kWillRepeatedly,
-                         ".WillRepeatedly() cannot appear "
-                         "after .RetiresOnSaturation().");
-    }
-    last_clause_ = kWillRepeatedly;
-    repeated_action_specified_ = true;
-
-    repeated_action_ = action;
-    if (!cardinality_specified()) {
-      set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size())));
-    }
-
-    // Now that no more action clauses can be specified, we check
-    // whether their count makes sense.
-    CheckActionCountIfNotDone();
-    return *this;
-  }
-
-  // Implements the .RetiresOnSaturation() clause.
-  TypedExpectation& RetiresOnSaturation() {
-    ExpectSpecProperty(last_clause_ < kRetiresOnSaturation,
-                       ".RetiresOnSaturation() cannot appear "
-                       "more than once.");
-    last_clause_ = kRetiresOnSaturation;
-    retires_on_saturation_ = true;
-
-    // Now that no more action clauses can be specified, we check
-    // whether their count makes sense.
-    CheckActionCountIfNotDone();
-    return *this;
-  }
-
-  // Returns the matchers for the arguments as specified inside the
-  // EXPECT_CALL() macro.
-  const ArgumentMatcherTuple& matchers() const {
-    return matchers_;
-  }
-
-  // Returns the matcher specified by the .With() clause.
-  const Matcher<const ArgumentTuple&>& extra_matcher() const {
-    return extra_matcher_;
-  }
-
-  // Returns the action specified by the .WillRepeatedly() clause.
-  const Action<F>& repeated_action() const { return repeated_action_; }
-
-  // If this mock method has an extra matcher (i.e. .With(matcher)),
-  // describes it to the ostream.
-  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) {
-    if (extra_matcher_specified_) {
-      *os << "    Expected args: ";
-      extra_matcher_.DescribeTo(os);
-      *os << "\n";
-    }
-  }
-
- private:
-  template <typename Function>
-  friend class FunctionMockerBase;
-
-  // Returns an Expectation object that references and co-owns this
-  // expectation.
-  virtual Expectation GetHandle() {
-    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 iff 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 iff this expectation should handle the given arguments.
-  bool ShouldHandleArguments(const ArgumentTuple& args) const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-
-    // In case the action count wasn't checked when the expectation
-    // was defined (e.g. if this expectation has no WillRepeatedly()
-    // or RetiresOnSaturation() clause), we check it when the
-    // expectation is used for the first time.
-    CheckActionCountIfNotDone();
-    return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args);
-  }
-
-  // Describes the result of matching the arguments against this
-  // expectation to the given ostream.
-  void ExplainMatchResultTo(
-      const ArgumentTuple& args,
-      ::std::ostream* os) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-
-    if (is_retired()) {
-      *os << "         Expected: the expectation is active\n"
-          << "           Actual: it is retired\n";
-    } else if (!Matches(args)) {
-      if (!TupleMatches(matchers_, args)) {
-        ExplainMatchFailureTupleTo(matchers_, args, os);
-      }
-      StringMatchResultListener listener;
-      if (!extra_matcher_.MatchAndExplain(args, &listener)) {
-        *os << "    Expected args: ";
-        extra_matcher_.DescribeTo(os);
-        *os << "\n           Actual: don't match";
-
-        internal::PrintIfNotEmpty(listener.str(), os);
-        *os << "\n";
-      }
-    } else if (!AllPrerequisitesAreSatisfied()) {
-      *os << "         Expected: all pre-requisites are satisfied\n"
-          << "           Actual: the following immediate pre-requisites "
-          << "are not satisfied:\n";
-      ExpectationSet unsatisfied_prereqs;
-      FindUnsatisfiedPrerequisites(&unsatisfied_prereqs);
-      int i = 0;
-      for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin();
-           it != unsatisfied_prereqs.end(); ++it) {
-        it->expectation_base()->DescribeLocationTo(os);
-        *os << "pre-requisite #" << i++ << "\n";
-      }
-      *os << "                   (end of pre-requisites)\n";
-    } else {
-      // This line is here just for completeness' sake.  It will never
-      // be executed as currently the ExplainMatchResultTo() function
-      // is called only when the mock function call does NOT match the
-      // expectation.
-      *os << "The call matches the expectation.\n";
-    }
-  }
-
-  // Returns the action that should be taken for the current invocation.
-  const Action<F>& GetCurrentAction(
-      const FunctionMockerBase<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__,
-           "call_count() is <= 0 when GetCurrentAction() is "
-           "called - this should never happen.");
-
-    const int action_count = static_cast<int>(untyped_actions_.size());
-    if (action_count > 0 && !repeated_action_specified_ &&
-        count > action_count) {
-      // If there is at least one WillOnce() and no WillRepeatedly(),
-      // we warn the user when the WillOnce() clauses ran out.
-      ::std::stringstream ss;
-      DescribeLocationTo(&ss);
-      ss << "Actions ran out in " << source_text() << "...\n"
-         << "Called " << count << " times, but only "
-         << action_count << " WillOnce()"
-         << (action_count == 1 ? " is" : "s are") << " specified - ";
-      mocker->DescribeDefaultActionTo(args, &ss);
-      Log(kWarning, ss.str(), 1);
-    }
-
-    return count <= action_count ?
-        *static_cast<const Action<F>*>(untyped_actions_[count - 1]) :
-        repeated_action();
-  }
-
-  // Given the arguments of a mock function call, if the call will
-  // over-saturate this expectation, returns the default action;
-  // otherwise, returns the next action in this expectation.  Also
-  // describes *what* happened to 'what', and explains *why* Google
-  // 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 FunctionMockerBase<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.
-      IncrementCallCount();
-      *what << "Mock function called more times than expected - ";
-      mocker->DescribeDefaultActionTo(args, what);
-      DescribeCallCountTo(why);
-
-      // TODO(wan@google.com): allow the user to control whether
-      // unexpected calls should fail immediately or continue using a
-      // flag --gmock_unexpected_calls_are_fatal.
-      return NULL;
-    }
-
-    IncrementCallCount();
-    RetireAllPreRequisites();
-
-    if (retires_on_saturation_ && IsSaturated()) {
-      Retire();
-    }
-
-    // Must be done after IncrementCount()!
-    *what << "Mock function call matches " << source_text() <<"...\n";
-    return &(GetCurrentAction(mocker, args));
-  }
-
-  // All the fields below won't change once the EXPECT_CALL()
-  // statement finishes.
-  FunctionMockerBase<F>* const owner_;
-  ArgumentMatcherTuple matchers_;
-  Matcher<const ArgumentTuple&> extra_matcher_;
-  Action<F> repeated_action_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
-};  // class TypedExpectation
-
-// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
-// specifying the default behavior of, or expectation on, a mock
-// function.
-
-// Note: class MockSpec really belongs to the ::testing namespace.
-// However if we define it in ::testing, MSVC will complain when
-// classes in ::testing::internal declare it as a friend class
-// template.  To workaround this compiler bug, we define MockSpec in
-// ::testing::internal and import it into ::testing.
-
-// Logs a message including file and line number information.
-GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
-                                const char* file, int line,
-                                const string& message);
-
-template <typename F>
-class MockSpec {
- public:
-  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-  typedef typename internal::Function<F>::ArgumentMatcherTuple
-      ArgumentMatcherTuple;
-
-  // Constructs a MockSpec object, given the function mocker object
-  // that the spec is associated with.
-  explicit MockSpec(internal::FunctionMockerBase<F>* function_mocker)
-      : function_mocker_(function_mocker) {}
-
-  // 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,
-        string("ON_CALL(") + obj + ", " + call + ") invoked");
-    return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
-  }
-
-  // Adds a new expectation spec to the function mocker and returns
-  // the newly created spec.
-  internal::TypedExpectation<F>& InternalExpectedAt(
-      const char* file, int line, const char* obj, const char* call) {
-    const string source_text(string("EXPECT_CALL(") + obj + ", " + call + ")");
-    LogWithLocation(internal::kInfo, file, line, source_text + " invoked");
-    return function_mocker_->AddNewExpectation(
-        file, line, source_text, matchers_);
-  }
-
- private:
-  template <typename Function>
-  friend class internal::FunctionMocker;
-
-  void SetMatchers(const ArgumentMatcherTuple& matchers) {
-    matchers_ = matchers;
-  }
-
-  // The function mocker that owns this spec.
-  internal::FunctionMockerBase<F>* const function_mocker_;
-  // The argument matchers specified in the spec.
-  ArgumentMatcherTuple matchers_;
-
-  GTEST_DISALLOW_ASSIGN_(MockSpec);
-};  // class MockSpec
-
-// Wrapper type for generically holding an ordinary value or lvalue reference.
-// If T is not a reference type, it must be copyable or movable.
-// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless
-// T is a move-only value type (which means that it will always be copyable
-// if the current platform does not support move semantics).
-//
-// The primary template defines handling for values, but function header
-// comments describe the contract for the whole template (including
-// specializations).
-template <typename T>
-class ReferenceOrValueWrapper {
- public:
-  // Constructs a wrapper from the given value/reference.
-  explicit ReferenceOrValueWrapper(T value)
-      : value_(::testing::internal::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 ::testing::internal::move(value_); }
-
-  // Provides nondestructive access to the underlying value/reference.
-  // Always returns a const reference (more precisely,
-  // const RemoveReference<T>&). The behavior of calling this after
-  // calling Unwrap on the same object is unspecified.
-  const T& Peek() const {
-    return value_;
-  }
-
- private:
-  T value_;
-};
-
-// Specialization for lvalue reference types. See primary template
-// for documentation.
-template <typename T>
-class ReferenceOrValueWrapper<T&> {
- public:
-  // Workaround for debatable pass-by-reference lint warning (c-library-team
-  // policy precludes NOLINT in this context)
-  typedef T& reference;
-  explicit ReferenceOrValueWrapper(reference ref)
-      : value_ptr_(&ref) {}
-  T& Unwrap() { return *value_ptr_; }
-  const T& Peek() const { return *value_ptr_; }
-
- private:
-  T* value_ptr_;
-};
-
-// MSVC warns about using 'this' in base member initializer list, so
-// we need to temporarily disable the warning.  We have to do it for
-// the entire class to suppress the warning, even though it's about
-// the constructor only.
-
-#ifdef _MSC_VER
-# pragma warning(push)          // Saves the current warning state.
-# pragma warning(disable:4355)  // Temporarily disables warning 4355.
-#endif  // _MSV_VER
-
-// C++ treats the void type specially.  For example, you cannot define
-// a void-typed variable or pass a void value to a function.
-// ActionResultHolder<T> holds a value of type T, where T must be a
-// copyable type or void (T doesn't need to be default-constructable).
-// It hides the syntactic difference between void and other types, and
-// is used to unify the code for invoking both void-returning and
-// non-void-returning mock functions.
-
-// Untyped base class for ActionResultHolder<T>.
-class UntypedActionResultHolderBase {
- public:
-  virtual ~UntypedActionResultHolderBase() {}
-
-  // Prints the held value as an action's result to os.
-  virtual void PrintAsActionResult(::std::ostream* os) const = 0;
-};
-
-// This generic definition is used when T is not void.
-template <typename T>
-class ActionResultHolder : public UntypedActionResultHolderBase {
- public:
-  // Returns the held value. Must not be called more than once.
-  T Unwrap() {
-    return result_.Unwrap();
-  }
-
-  // Prints the held value as an action's result to os.
-  virtual void PrintAsActionResult(::std::ostream* os) const {
-    *os << "\n          Returns: ";
-    // T may be a reference type, so we don't use UniversalPrint().
-    UniversalPrinter<T>::Print(result_.Peek(), os);
-  }
-
-  // Performs the given mock function's default action and returns the
-  // result in a new-ed ActionResultHolder.
-  template <typename F>
-  static ActionResultHolder* PerformDefaultAction(
-      const FunctionMockerBase<F>* func_mocker,
-      const typename Function<F>::ArgumentTuple& args,
-      const string& call_description) {
-    return new ActionResultHolder(Wrapper(
-        func_mocker->PerformDefaultAction(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,
-                const typename Function<F>::ArgumentTuple& args) {
-    return new ActionResultHolder(Wrapper(action.Perform(args)));
-  }
-
- private:
-  typedef ReferenceOrValueWrapper<T> Wrapper;
-
-  explicit ActionResultHolder(Wrapper result)
-      : result_(::testing::internal::move(result)) {
-  }
-
-  Wrapper result_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
-};
-
-// Specialization for T = void.
-template <>
-class ActionResultHolder<void> : public UntypedActionResultHolderBase {
- public:
-  void Unwrap() { }
-
-  virtual void PrintAsActionResult(::std::ostream* /* os */) const {}
-
-  // Performs the given mock function's default action and returns ownership
-  // of an empty ActionResultHolder*.
-  template <typename F>
-  static ActionResultHolder* PerformDefaultAction(
-      const FunctionMockerBase<F>* func_mocker,
-      const typename Function<F>::ArgumentTuple& args,
-      const string& call_description) {
-    func_mocker->PerformDefaultAction(args, call_description);
-    return new ActionResultHolder;
-  }
-
-  // Performs the given action and returns ownership of an empty
-  // ActionResultHolder*.
-  template <typename F>
-  static ActionResultHolder* PerformAction(
-      const Action<F>& action,
-      const typename Function<F>::ArgumentTuple& args) {
-    action.Perform(args);
-    return new ActionResultHolder;
-  }
-
- private:
-  ActionResultHolder() {}
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
-};
-
-// The base of the function mocker class for the given function type.
-// We put the methods in this class instead of its child to avoid code
-// bloat.
-template <typename F>
-class FunctionMockerBase : public UntypedFunctionMockerBase {
- public:
-  typedef typename Function<F>::Result Result;
-  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
-  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
-
-  FunctionMockerBase() : current_spec_(this) {}
-
-  // 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.
-  virtual ~FunctionMockerBase()
-        GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    MutexLock l(&g_gmock_mutex);
-    VerifyAndClearExpectationsLocked();
-    Mock::UnregisterLocked(this);
-    ClearDefaultActionsLocked();
-  }
-
-  // Returns the ON_CALL spec that matches this mock function with the
-  // given arguments; returns NULL if no matching ON_CALL is found.
-  // L = *
-  const OnCallSpec<F>* FindOnCallSpec(
-      const ArgumentTuple& args) const {
-    for (UntypedOnCallSpecs::const_reverse_iterator it
-             = untyped_on_call_specs_.rbegin();
-         it != untyped_on_call_specs_.rend(); ++it) {
-      const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it);
-      if (spec->Matches(args))
-        return spec;
-    }
-
-    return NULL;
-  }
-
-  // Performs the default action of this mock function on the given
-  // arguments and returns the result. Asserts (or throws if
-  // exceptions are enabled) with a helpful call descrption if there
-  // is no valid return value. This method doesn't depend on the
-  // mutable state of this object, and thus can be called concurrently
-  // without locking.
-  // L = *
-  Result PerformDefaultAction(const ArgumentTuple& args,
-                              const string& call_description) const {
-    const OnCallSpec<F>* const spec =
-        this->FindOnCallSpec(args);
-    if (spec != NULL) {
-      return spec->GetAction().Perform(args);
-    }
-    const 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
-    if (!DefaultValue<Result>::Exists()) {
-      throw std::runtime_error(message);
-    }
-#else
-    Assert(DefaultValue<Result>::Exists(), "", -1, message);
-#endif
-    return DefaultValue<Result>::Get();
-  }
-
-  // Performs the default action with the given arguments and returns
-  // the action's result.  The call description string will be used in
-  // the error message to describe the call in the case the default
-  // action fails.  The caller is responsible for deleting the result.
-  // L = *
-  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
-      const void* untyped_args,  // must point to an ArgumentTuple
-      const string& call_description) const {
-    const ArgumentTuple& args =
-        *static_cast<const ArgumentTuple*>(untyped_args);
-    return ResultHolder::PerformDefaultAction(this, 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 = *
-  virtual UntypedActionResultHolderBase* UntypedPerformAction(
-      const void* untyped_action, const void* untyped_args) const {
-    // 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);
-    const ArgumentTuple& args =
-        *static_cast<const ArgumentTuple*>(untyped_args);
-    return ResultHolder::PerformAction(action, args);
-  }
-
-  // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
-  // clears the ON_CALL()s set on this mock function.
-  virtual void ClearDefaultActionsLocked()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-
-    // Deleting our default actions may trigger other mock objects to be
-    // deleted, for example if an action contains a reference counted smart
-    // pointer to that mock object, and that is the last reference. So if we
-    // delete our actions within the context of the global mutex we may deadlock
-    // when this method is called again. Instead, make a copy of the set of
-    // actions to delete, clear our set within the mutex, and then delete the
-    // actions outside of the mutex.
-    UntypedOnCallSpecs specs_to_delete;
-    untyped_on_call_specs_.swap(specs_to_delete);
-
-    g_gmock_mutex.Unlock();
-    for (UntypedOnCallSpecs::const_iterator it =
-             specs_to_delete.begin();
-         it != specs_to_delete.end(); ++it) {
-      delete static_cast<const OnCallSpec<F>*>(*it);
-    }
-
-    // Lock the mutex again, since the caller expects it to be locked when we
-    // return.
-    g_gmock_mutex.Lock();
-  }
-
- protected:
-  template <typename Function>
-  friend class MockSpec;
-
-  typedef ActionResultHolder<Result> ResultHolder;
-
-  // Returns the result of invoking this mock function with the given
-  // arguments.  This function can be safely called from multiple
-  // threads concurrently.
-  Result InvokeWith(const ArgumentTuple& args)
-        GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    scoped_ptr<ResultHolder> holder(
-        DownCast_<ResultHolder*>(this->UntypedInvokeWith(&args)));
-    return holder->Unwrap();
-  }
-
-  // Adds and returns a default action spec for this mock function.
-  OnCallSpec<F>& AddNewOnCallSpec(
-      const char* file, int line,
-      const ArgumentMatcherTuple& m)
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
-    OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m);
-    untyped_on_call_specs_.push_back(on_call_spec);
-    return *on_call_spec;
-  }
-
-  // Adds and returns an expectation spec for this mock function.
-  TypedExpectation<F>& AddNewExpectation(
-      const char* file,
-      int line,
-      const 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 linked_ptr<ExpectationBase> untyped_expectation(expectation);
-    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 != NULL) {
-      implicit_sequence->AddExpectation(Expectation(untyped_expectation));
-    }
-
-    return *expectation;
-  }
-
-  // The current spec (either default action spec or expectation spec)
-  // being described on this function mocker.
-  MockSpec<F>& current_spec() { return current_spec_; }
-
- private:
-  template <typename Func> friend class TypedExpectation;
-
-  // Some utilities needed for implementing UntypedInvokeWith().
-
-  // Describes what default action will be performed for the given
-  // arguments.
-  // L = *
-  void DescribeDefaultActionTo(const ArgumentTuple& args,
-                               ::std::ostream* os) const {
-    const OnCallSpec<F>* const spec = FindOnCallSpec(args);
-
-    if (spec == NULL) {
-      *os << (internal::type_equals<Result, void>::value ?
-              "returning directly.\n" :
-              "returning default value.\n");
-    } else {
-      *os << "taking default action specified at:\n"
-          << FormatFileLocation(spec->file(), spec->line()) << "\n";
-    }
-  }
-
-  // Writes a message that the call is uninteresting (i.e. neither
-  // explicitly expected nor explicitly unexpected) to the given
-  // ostream.
-  virtual void UntypedDescribeUninterestingCall(
-      const void* untyped_args,
-      ::std::ostream* os) const
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    const ArgumentTuple& args =
-        *static_cast<const ArgumentTuple*>(untyped_args);
-    *os << "Uninteresting mock function call - ";
-    DescribeDefaultActionTo(args, os);
-    *os << "    Function call: " << Name();
-    UniversalPrint(args, os);
-  }
-
-  // Returns the expectation that matches the given function arguments
-  // (or NULL is there's no match); when a match is found,
-  // untyped_action is set to point to the action that should be
-  // performed (or NULL if the action is "do default"), and
-  // is_excessive is modified to indicate whether the call exceeds the
-  // expected number.
-  //
-  // Critical section: We must find the matching expectation and the
-  // corresponding action that needs to be taken in an ATOMIC
-  // transaction.  Otherwise another thread may call this mock
-  // method in the middle and mess up the state.
-  //
-  // However, performing the action has to be left out of the critical
-  // 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.
-  virtual const ExpectationBase* UntypedFindMatchingExpectation(
-      const void* untyped_args,
-      const void** untyped_action, bool* is_excessive,
-      ::std::ostream* what, ::std::ostream* why)
-          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 == NULL) {  // A match wasn't found.
-      this->FormatUnexpectedCallMessageLocked(args, what, why);
-      return NULL;
-    }
-
-    // This line must be done before calling GetActionForArguments(),
-    // which will increment the call count for *exp and thus affect
-    // its saturation status.
-    *is_excessive = exp->IsSaturated();
-    const Action<F>* action = exp->GetActionForArguments(this, args, what, why);
-    if (action != NULL && action->IsDoDefault())
-      action = NULL;  // Normalize "do default" to NULL.
-    *untyped_action = action;
-    return exp;
-  }
-
-  // Prints the given function arguments to the ostream.
-  virtual void UntypedPrintArgs(const void* untyped_args,
-                                ::std::ostream* os) const {
-    const ArgumentTuple& args =
-        *static_cast<const ArgumentTuple*>(untyped_args);
-    UniversalPrint(args, os);
-  }
-
-  // Returns the expectation that matches the arguments, or NULL if no
-  // expectation matches them.
-  TypedExpectation<F>* FindMatchingExpectationLocked(
-      const ArgumentTuple& args) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    for (typename UntypedExpectations::const_reverse_iterator it =
-             untyped_expectations_.rbegin();
-         it != untyped_expectations_.rend(); ++it) {
-      TypedExpectation<F>* const exp =
-          static_cast<TypedExpectation<F>*>(it->get());
-      if (exp->ShouldHandleArguments(args)) {
-        return exp;
-      }
-    }
-    return NULL;
-  }
-
-  // Returns a message that the arguments don't match any expectation.
-  void FormatUnexpectedCallMessageLocked(
-      const ArgumentTuple& args,
-      ::std::ostream* os,
-      ::std::ostream* why) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    *os << "\nUnexpected mock function call - ";
-    DescribeDefaultActionTo(args, os);
-    PrintTriedExpectationsLocked(args, why);
-  }
-
-  // Prints a list of expectations that have been tried against the
-  // current mock function call.
-  void PrintTriedExpectationsLocked(
-      const ArgumentTuple& args,
-      ::std::ostream* why) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-    g_gmock_mutex.AssertHeld();
-    const int count = static_cast<int>(untyped_expectations_.size());
-    *why << "Google Mock tried the following " << count << " "
-         << (count == 1 ? "expectation, but it didn't match" :
-             "expectations, but none matched")
-         << ":\n";
-    for (int i = 0; i < count; i++) {
-      TypedExpectation<F>* const expectation =
-          static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get());
-      *why << "\n";
-      expectation->DescribeLocationTo(why);
-      if (count > 1) {
-        *why << "tried expectation #" << i << ": ";
-      }
-      *why << expectation->source_text() << "...\n";
-      expectation->ExplainMatchResultTo(args, why);
-      expectation->DescribeCallCountTo(why);
-    }
-  }
-
-  // The current spec (either default action spec or expectation spec)
-  // being described on this function mocker.
-  MockSpec<F> current_spec_;
-
-  // 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, he should implement his own copy
-  // operation, for example:
-  //
-  //   class MockFoo : public Foo {
-  //    public:
-  //     // Defines a copy constructor explicitly.
-  //     MockFoo(const MockFoo& src) {}
-  //     ...
-  //   };
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(FunctionMockerBase);
-};  // class FunctionMockerBase
-
-#ifdef _MSC_VER
-# pragma warning(pop)  // Restores the warning state.
-#endif  // _MSV_VER
-
-// Implements methods of FunctionMockerBase.
-
-// Verifies that all expectations on this mock function have been
-// satisfied.  Reports one or more Google Test non-fatal failures and
-// returns false if not.
-
-// Reports an uninteresting call (whose description is in msg) in the
-// manner specified by 'reaction'.
-void ReportUninterestingCall(CallReaction reaction, const string& msg);
-
-}  // namespace internal
-
-// 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
-// is just a trick for working around a bug in MSVC 8.0, which cannot
-// handle it if we define MockSpec in ::testing.
-using internal::MockSpec;
-
-// Const(x) is a convenient function for obtaining a const reference
-// to x.  This is useful for setting expectations on an overloaded
-// const mock method, e.g.
-//
-//   class MockFoo : public FooInterface {
-//    public:
-//     MOCK_METHOD0(Bar, int());
-//     MOCK_CONST_METHOD0(Bar, int&());
-//   };
-//
-//   MockFoo foo;
-//   // Expects a call to non-const MockFoo::Bar().
-//   EXPECT_CALL(foo, Bar());
-//   // Expects a call to const MockFoo::Bar().
-//   EXPECT_CALL(Const(foo), Bar());
-template <typename T>
-inline const T& Const(const T& x) { return x; }
-
-// Constructs an Expectation object that references and co-owns exp.
-inline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT
-    : expectation_base_(exp.GetHandle().expectation_base()) {}
-
-}  // namespace testing
-
-// 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.
-#define GMOCK_ON_CALL_IMPL_(obj, call) \
-    ((obj).gmock_##call).InternalDefaultActionSetAt(__FILE__, __LINE__, \
-                                                    #obj, #call)
-#define ON_CALL(obj, call) GMOCK_ON_CALL_IMPL_(obj, call)
-
-#define GMOCK_EXPECT_CALL_IMPL_(obj, call) \
-    ((obj).gmock_##call).InternalExpectedAt(__FILE__, __LINE__, #obj, #call)
-#define EXPECT_CALL(obj, call) GMOCK_EXPECT_CALL_IMPL_(obj, call)
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock.h
deleted file mode 100644
index 6735c71b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/gmock.h
+++ /dev/null
@@ -1,94 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This is the main header file a user should include.
-
-#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_H_
-#define GMOCK_INCLUDE_GMOCK_GMOCK_H_
-
-// This file implements the following syntax:
-//
-//   ON_CALL(mock_object.Method(...))
-//     .With(...) ?
-//     .WillByDefault(...);
-//
-// where With() is optional and WillByDefault() must appear exactly
-// once.
-//
-//   EXPECT_CALL(mock_object.Method(...))
-//     .With(...) ?
-//     .Times(...) ?
-//     .InSequence(...) *
-//     .WillOnce(...) *
-//     .WillRepeatedly(...) ?
-//     .RetiresOnSaturation() ? ;
-//
-// where all clauses are optional and WillOnce() can be repeated.
-
-#include "gmock/gmock-actions.h"
-#include "gmock/gmock-cardinalities.h"
-#include "gmock/gmock-generated-actions.h"
-#include "gmock/gmock-generated-function-mockers.h"
-#include "gmock/gmock-generated-nice-strict.h"
-#include "gmock/gmock-generated-matchers.h"
-#include "gmock/gmock-matchers.h"
-#include "gmock/gmock-more-actions.h"
-#include "gmock/gmock-more-matchers.h"
-#include "gmock/internal/gmock-internal-utils.h"
-
-namespace testing {
-
-// Declares Google Mock flags that we want a user to use programmatically.
-GMOCK_DECLARE_bool_(catch_leaked_mocks);
-GMOCK_DECLARE_string_(verbose);
-
-// Initializes Google Mock.  This must be called before running the
-// tests.  In particular, it parses the command line for the flags
-// that Google Mock recognizes.  Whenever a Google Mock flag is seen,
-// it is removed from argv, and *argc is decremented.
-//
-// No value is returned.  Instead, the Google Mock flag variables are
-// updated.
-//
-// Since Google Test is needed for Google Mock to work, this function
-// also initializes Google Test and parses its flags, if that hasn't
-// been done.
-GTEST_API_ void InitGoogleMock(int* argc, char** argv);
-
-// This overloaded version can be used in Windows programs compiled in
-// UNICODE mode.
-GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv);
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
deleted file mode 100644
index 7dc3b1ad..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// This file was GENERATED by command:
-//     pump.py gmock-generated-actions.h.pump
-// DO NOT EDIT BY HAND!!!
-
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
-
-#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump
deleted file mode 100644
index d26c8a08..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump
+++ /dev/null
@@ -1,10 +0,0 @@
-$$ -*- mode: c++; -*-
-$$ This is a Pump source file (http://go/pump).  Please use Pump to convert
-$$ it to callback-actions.h.
-$$
-$var max_callback_arity = 5
-$$}} This meta comment fixes auto-indentation in editors.
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
-
-#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h
deleted file mode 100644
index f2efef91..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2015, 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.
-//
-// ============================================================
-// An installation-specific extension point for gmock-matchers.h.
-// ============================================================
-//
-// Adds google3 callback support to CallableTraits.
-//
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
-
-#endif  //  GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-port.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-port.h
deleted file mode 100644
index 9ce8bfe0..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/custom/gmock-port.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2015, 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.
-//
-// Injection point for custom user configurations.
-// The following macros can be defined:
-//
-//   Flag related macros:
-//     GMOCK_DECLARE_bool_(name)
-//     GMOCK_DECLARE_int32_(name)
-//     GMOCK_DECLARE_string_(name)
-//     GMOCK_DEFINE_bool_(name, default_val, doc)
-//     GMOCK_DEFINE_int32_(name, default_val, doc)
-//     GMOCK_DEFINE_string_(name, default_val, doc)
-//
-// ** Custom implementation starts here **
-
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
-
-#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h
deleted file mode 100644
index 7811e43f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h
+++ /dev/null
@@ -1,279 +0,0 @@
-// This file was GENERATED by command:
-//     pump.py gmock-generated-internal-utils.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file contains template meta-programming utility classes needed
-// for implementing Google Mock.
-
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
-
-#include "gmock/internal/gmock-port.h"
-
-namespace testing {
-
-template <typename T>
-class Matcher;
-
-namespace internal {
-
-// An IgnoredValue object can be implicitly constructed from ANY value.
-// This is used in implementing the IgnoreResult(a) action.
-class IgnoredValue {
- 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.
-  template <typename T>
-  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
-};
-
-// MatcherTuple<T>::type is a tuple type where each field is a Matcher
-// for the corresponding field in tuple type T.
-template <typename Tuple>
-struct MatcherTuple;
-
-template <>
-struct MatcherTuple< ::testing::tuple<> > {
-  typedef ::testing::tuple< > type;
-};
-
-template <typename A1>
-struct MatcherTuple< ::testing::tuple<A1> > {
-  typedef ::testing::tuple<Matcher<A1> > type;
-};
-
-template <typename A1, typename A2>
-struct MatcherTuple< ::testing::tuple<A1, A2> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2> > type;
-};
-
-template <typename A1, typename A2, typename A3>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
-      Matcher<A4> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
-      Matcher<A5> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
-      Matcher<A5>, Matcher<A6> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6, typename A7>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
-      Matcher<A5>, Matcher<A6>, Matcher<A7> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6, typename A7, typename A8>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
-      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6, typename A7, typename A8, typename A9>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
-      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9> > type;
-};
-
-template <typename A1, typename A2, typename A3, typename A4, typename A5,
-    typename A6, typename A7, typename A8, typename A9, typename A10>
-struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
-    A10> > {
-  typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
-      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9>,
-      Matcher<A10> > type;
-};
-
-// Template struct Function<F>, where F must be a function type, contains
-// the following typedefs:
-//
-//   Result:               the function's return type.
-//   ArgumentN:            the type of the N-th argument, where N starts with 1.
-//   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 F>
-struct Function;
-
-template <typename R>
-struct Function<R()> {
-  typedef R Result;
-  typedef ::testing::tuple<> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid();
-  typedef IgnoredValue MakeResultIgnoredValue();
-};
-
-template <typename R, typename A1>
-struct Function<R(A1)>
-    : Function<R()> {
-  typedef A1 Argument1;
-  typedef ::testing::tuple<A1> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1);
-  typedef IgnoredValue MakeResultIgnoredValue(A1);
-};
-
-template <typename R, typename A1, typename A2>
-struct Function<R(A1, A2)>
-    : Function<R(A1)> {
-  typedef A2 Argument2;
-  typedef ::testing::tuple<A1, A2> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2);
-};
-
-template <typename R, typename A1, typename A2, typename A3>
-struct Function<R(A1, A2, A3)>
-    : Function<R(A1, A2)> {
-  typedef A3 Argument3;
-  typedef ::testing::tuple<A1, A2, A3> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4>
-struct Function<R(A1, A2, A3, A4)>
-    : Function<R(A1, A2, A3)> {
-  typedef A4 Argument4;
-  typedef ::testing::tuple<A1, A2, A3, A4> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5>
-struct Function<R(A1, A2, A3, A4, A5)>
-    : Function<R(A1, A2, A3, A4)> {
-  typedef A5 Argument5;
-  typedef ::testing::tuple<A1, A2, A3, A4, A5> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4, A5);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6>
-struct Function<R(A1, A2, A3, A4, A5, A6)>
-    : Function<R(A1, A2, A3, A4, A5)> {
-  typedef A6 Argument6;
-  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7>
-struct Function<R(A1, A2, A3, A4, A5, A6, A7)>
-    : Function<R(A1, A2, A3, A4, A5, A6)> {
-  typedef A7 Argument7;
-  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8>
-struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8)>
-    : Function<R(A1, A2, A3, A4, A5, A6, A7)> {
-  typedef A8 Argument8;
-  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9>
-struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
-    : Function<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
-  typedef A9 Argument9;
-  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
-      A9);
-};
-
-template <typename R, typename A1, typename A2, typename A3, typename A4,
-    typename A5, typename A6, typename A7, typename A8, typename A9,
-    typename A10>
-struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
-    : Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
-  typedef A10 Argument10;
-  typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
-      A10> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
-  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
-      A9, A10);
-};
-
-}  // namespace internal
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h.pump b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h.pump
deleted file mode 100644
index 800af17c..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-generated-internal-utils.h.pump
+++ /dev/null
@@ -1,136 +0,0 @@
-$$ -*- mode: c++; -*-
-$$ This is a Pump source file.  Please use Pump to convert it to
-$$ gmock-generated-function-mockers.h.
-$$
-$var n = 10  $$ The maximum arity we support.
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file contains template meta-programming utility classes needed
-// for implementing Google Mock.
-
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
-
-#include "gmock/internal/gmock-port.h"
-
-namespace testing {
-
-template <typename T>
-class Matcher;
-
-namespace internal {
-
-// An IgnoredValue object can be implicitly constructed from ANY value.
-// This is used in implementing the IgnoreResult(a) action.
-class IgnoredValue {
- 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.
-  template <typename T>
-  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
-};
-
-// MatcherTuple<T>::type is a tuple type where each field is a Matcher
-// for the corresponding field in tuple type T.
-template <typename Tuple>
-struct MatcherTuple;
-
-
-$range i 0..n
-$for i [[
-$range j 1..i
-$var typename_As = [[$for j, [[typename A$j]]]]
-$var As = [[$for j, [[A$j]]]]
-$var matcher_As = [[$for j, [[Matcher<A$j>]]]]
-template <$typename_As>
-struct MatcherTuple< ::testing::tuple<$As> > {
-  typedef ::testing::tuple<$matcher_As > type;
-};
-
-
-]]
-// Template struct Function<F>, where F must be a function type, contains
-// the following typedefs:
-//
-//   Result:               the function's return type.
-//   ArgumentN:            the type of the N-th argument, where N starts with 1.
-//   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 F>
-struct Function;
-
-template <typename R>
-struct Function<R()> {
-  typedef R Result;
-  typedef ::testing::tuple<> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid();
-  typedef IgnoredValue MakeResultIgnoredValue();
-};
-
-
-$range i 1..n
-$for i [[
-$range j 1..i
-$var typename_As = [[$for j [[, typename A$j]]]]
-$var As = [[$for j, [[A$j]]]]
-$var matcher_As = [[$for j, [[Matcher<A$j>]]]]
-$range k 1..i-1
-$var prev_As = [[$for k, [[A$k]]]]
-template <typename R$typename_As>
-struct Function<R($As)>
-    : Function<R($prev_As)> {
-  typedef A$i Argument$i;
-  typedef ::testing::tuple<$As> ArgumentTuple;
-  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
-  typedef void MakeResultVoid($As);
-  typedef IgnoredValue MakeResultIgnoredValue($As);
-};
-
-
-]]
-}  // namespace internal
-
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
deleted file mode 100644
index e2ddb05c..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
+++ /dev/null
@@ -1,511 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// 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.
-
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
-
-#include <stdio.h>
-#include <ostream>  // NOLINT
-#include <string>
-
-#include "gmock/internal/gmock-generated-internal-utils.h"
-#include "gmock/internal/gmock-port.h"
-#include "gtest/gtest.h"
-
-namespace testing {
-namespace internal {
-
-// 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_ string ConvertIdentifierNameToWords(const char* id_name);
-
-// PointeeOf<Pointer>::type is the type of a value pointed to by a
-// Pointer, which can be either a smart pointer or a raw pointer.  The
-// following default implementation is for the case where Pointer is a
-// smart pointer.
-template <typename Pointer>
-struct PointeeOf {
-  // Smart pointer classes define type element_type as the type of
-  // their pointees.
-  typedef typename Pointer::element_type type;
-};
-// This specialization is for the raw pointer case.
-template <typename T>
-struct PointeeOf<T*> { typedef T type; };  // NOLINT
-
-// 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.
-// The following default implementation is for the smart pointer case.
-template <typename Pointer>
-inline const typename Pointer::element_type* GetRawPointer(const Pointer& p) {
-  return p.get();
-}
-// This overloaded version is for the raw pointer case.
-template <typename Element>
-inline Element* GetRawPointer(Element* p) { return p; }
-
-// This comparator allows linked_ptr to be stored in sets.
-template <typename T>
-struct LinkedPtrLessThan {
-  bool operator()(const ::testing::internal::linked_ptr<T>& lhs,
-                  const ::testing::internal::linked_ptr<T>& rhs) const {
-    return lhs.get() < rhs.get();
-  }
-};
-
-// Symbian compilation can be done with wchar_t being either a native
-// type or a typedef.  Using Google Mock with OpenC without wchar_t
-// should require the definition of _STLP_NO_WCHAR_T.
-//
-// MSVC treats wchar_t as a native type usually, but treats it as the
-// 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 (GTEST_OS_SYMBIAN && defined(_STLP_NO_WCHAR_T)) || \
-    (defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED))
-// wchar_t is a typedef.
-#else
-# define GMOCK_WCHAR_T_IS_NATIVE_ 1
-#endif
-
-// signed wchar_t and unsigned wchar_t are NOT in the C++ standard.
-// Using them is a bad practice and not portable.  So DON'T use them.
-//
-// Still, Google Mock is designed to work even if the user uses signed
-// wchar_t or unsigned wchar_t (obviously, assuming the compiler
-// supports them).
-//
-// To gcc,
-//   wchar_t == signed wchar_t != unsigned wchar_t == unsigned int
-#ifdef __GNUC__
-// signed/unsigned wchar_t are valid types.
-# define GMOCK_HAS_SIGNED_WCHAR_T_ 1
-#endif
-
-// In what follows, we use the term "kind" to indicate whether a type
-// is bool, an integer type (excluding bool), a floating-point type,
-// or none of them.  This categorization is useful for determining
-// when a matcher argument type can be safely converted to another
-// type in the implementation of SafeMatcherCast.
-enum TypeKind {
-  kBool, kInteger, kFloatingPoint, kOther
-};
-
-// KindOf<T>::value is the kind of type T.
-template <typename T> struct KindOf {
-  enum { value = kOther };  // The default kind.
-};
-
-// This macro declares that the kind of 'type' is 'kind'.
-#define GMOCK_DECLARE_KIND_(type, kind) \
-  template <> struct KindOf<type> { enum { value = kind }; }
-
-GMOCK_DECLARE_KIND_(bool, kBool);
-
-// All standard integer types.
-GMOCK_DECLARE_KIND_(char, kInteger);
-GMOCK_DECLARE_KIND_(signed char, kInteger);
-GMOCK_DECLARE_KIND_(unsigned char, kInteger);
-GMOCK_DECLARE_KIND_(short, kInteger);  // NOLINT
-GMOCK_DECLARE_KIND_(unsigned short, kInteger);  // NOLINT
-GMOCK_DECLARE_KIND_(int, kInteger);
-GMOCK_DECLARE_KIND_(unsigned int, kInteger);
-GMOCK_DECLARE_KIND_(long, kInteger);  // NOLINT
-GMOCK_DECLARE_KIND_(unsigned long, kInteger);  // NOLINT
-
-#if GMOCK_WCHAR_T_IS_NATIVE_
-GMOCK_DECLARE_KIND_(wchar_t, kInteger);
-#endif
-
-// Non-standard integer types.
-GMOCK_DECLARE_KIND_(Int64, kInteger);
-GMOCK_DECLARE_KIND_(UInt64, kInteger);
-
-// All standard floating-point types.
-GMOCK_DECLARE_KIND_(float, kFloatingPoint);
-GMOCK_DECLARE_KIND_(double, kFloatingPoint);
-GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
-
-#undef GMOCK_DECLARE_KIND_
-
-// Evaluates to the kind of 'type'.
-#define GMOCK_KIND_OF_(type) \
-  static_cast< ::testing::internal::TypeKind>( \
-      ::testing::internal::KindOf<type>::value)
-
-// Evaluates to true iff integer type T is signed.
-#define GMOCK_IS_SIGNED_(T) (static_cast<T>(-1) < 0)
-
-// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value
-// is true iff 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, kFromKind is the kind of
-// 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>
-struct LosslessArithmeticConvertibleImpl : public false_type {};
-
-// Converting bool to bool is lossless.
-template <>
-struct LosslessArithmeticConvertibleImpl<kBool, bool, kBool, bool>
-    : public true_type {};  // NOLINT
-
-// Converting bool to any integer type is lossless.
-template <typename To>
-struct LosslessArithmeticConvertibleImpl<kBool, bool, kInteger, To>
-    : public true_type {};  // NOLINT
-
-// Converting bool to any floating-point type is lossless.
-template <typename To>
-struct LosslessArithmeticConvertibleImpl<kBool, bool, kFloatingPoint, To>
-    : public true_type {};  // NOLINT
-
-// Converting an integer to bool is lossy.
-template <typename From>
-struct LosslessArithmeticConvertibleImpl<kInteger, From, kBool, bool>
-    : public false_type {};  // NOLINT
-
-// Converting an integer to another non-bool integer is lossless iff
-// the target type's range encloses the source type's range.
-template <typename From, typename To>
-struct LosslessArithmeticConvertibleImpl<kInteger, From, kInteger, To>
-    : public bool_constant<
-      // When converting from a smaller size to a larger size, we are
-      // fine as long as we are not converting from signed to unsigned.
-      ((sizeof(From) < sizeof(To)) &&
-       (!GMOCK_IS_SIGNED_(From) || GMOCK_IS_SIGNED_(To))) ||
-      // When converting between the same size, the signedness must match.
-      ((sizeof(From) == sizeof(To)) &&
-       (GMOCK_IS_SIGNED_(From) == GMOCK_IS_SIGNED_(To)))> {};  // NOLINT
-
-#undef GMOCK_IS_SIGNED_
-
-// Converting an integer to a floating-point type may be lossy, since
-// the format of a floating-point number is implementation-defined.
-template <typename From, typename To>
-struct LosslessArithmeticConvertibleImpl<kInteger, From, kFloatingPoint, To>
-    : public false_type {};  // NOLINT
-
-// Converting a floating-point to bool is lossy.
-template <typename From>
-struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kBool, bool>
-    : public false_type {};  // NOLINT
-
-// Converting a floating-point to an integer is lossy.
-template <typename From, typename To>
-struct LosslessArithmeticConvertibleImpl<kFloatingPoint, From, kInteger, To>
-    : public false_type {};  // NOLINT
-
-// Converting a floating-point to another floating-point is lossless
-// iff the target type is at least as big as the source type.
-template <typename From, typename To>
-struct LosslessArithmeticConvertibleImpl<
-  kFloatingPoint, From, kFloatingPoint, To>
-    : public bool_constant<sizeof(From) <= sizeof(To)> {};  // NOLINT
-
-// LosslessArithmeticConvertible<From, To>::value is true iff 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>
-struct LosslessArithmeticConvertible
-    : public LosslessArithmeticConvertibleImpl<
-  GMOCK_KIND_OF_(From), From, GMOCK_KIND_OF_(To), To> {};  // NOLINT
-
-// This interface knows how to report a Google Mock failure (either
-// non-fatal or fatal).
-class FailureReporterInterface {
- public:
-  // The type of a failure (either non-fatal or fatal).
-  enum FailureType {
-    kNonfatal, kFatal
-  };
-
-  virtual ~FailureReporterInterface() {}
-
-  // Reports a failure that occurred at the given source file location.
-  virtual void ReportFailure(FailureType type, const char* file, int line,
-                             const string& message) = 0;
-};
-
-// Returns the failure reporter used by Google Mock.
-GTEST_API_ FailureReporterInterface* GetFailureReporter();
-
-// Asserts that condition is true; aborts the process with the given
-// message if condition is false.  We cannot use LOG(FATAL) or CHECK()
-// as Google Mock might be used to mock the log sink itself.  We
-// inline this function to prevent it from showing up in the stack
-// trace.
-inline void Assert(bool condition, const char* file, int line,
-                   const string& msg) {
-  if (!condition) {
-    GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal,
-                                        file, line, msg);
-  }
-}
-inline void Assert(bool condition, const char* file, int line) {
-  Assert(condition, file, line, "Assertion failed.");
-}
-
-// 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 string& msg) {
-  if (!condition) {
-    GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal,
-                                        file, line, msg);
-  }
-}
-inline void Expect(bool condition, const char* file, int line) {
-  Expect(condition, file, line, "Expectation failed.");
-}
-
-// Severity level of a log.
-enum LogSeverity {
-  kInfo = 0,
-  kWarning = 1
-};
-
-// Valid values for the --gmock_verbose flag.
-
-// All logs (informational and warnings) are printed.
-const char kInfoVerbosity[] = "info";
-// Only warnings are printed.
-const char kWarningVerbosity[] = "warning";
-// No logs are printed.
-const char kErrorVerbosity[] = "error";
-
-// Returns true iff 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 iff '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 string& message,
-                    int stack_frames_to_skip);
-
-// TODO(wan@google.com): group all type utilities together.
-
-// Type traits.
-
-// is_reference<T>::value is non-zero iff T is a reference type.
-template <typename T> struct is_reference : public false_type {};
-template <typename T> struct is_reference<T&> : public true_type {};
-
-// type_equals<T1, T2>::value is non-zero iff T1 and T2 are the same type.
-template <typename T1, typename T2> struct type_equals : public false_type {};
-template <typename T> struct type_equals<T, T> : public true_type {};
-
-// remove_reference<T>::type removes the reference from type T, if any.
-template <typename T> struct remove_reference { typedef T type; };  // NOLINT
-template <typename T> struct remove_reference<T&> { typedef T type; }; // NOLINT
-
-// DecayArray<T>::type turns an array type U[N] to const U* and preserves
-// other types.  Useful for saving a copy of a function argument.
-template <typename T> struct DecayArray { typedef T type; };  // NOLINT
-template <typename T, size_t N> struct DecayArray<T[N]> {
-  typedef const T* type;
-};
-// Sometimes people use arrays whose size is not available at the use site
-// (e.g. extern const char kNamePrefix[]).  This specialization covers that
-// case.
-template <typename T> struct DecayArray<T[]> {
-  typedef const T* type;
-};
-
-// Disable MSVC warnings for infinite recursion, since in this case the
-// the recursion is unreachable.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4717)
-#endif
-
-// Invalid<T>() is usable as an expression of type T, but will terminate
-// the program with an assertion failure if actually run.  This is useful
-// when a value of type T is needed for compilation, but the statement
-// will not really be executed (or we don't care if the statement
-// crashes).
-template <typename T>
-inline T Invalid() {
-  Assert(false, "", -1, "Internal error: attempt to return invalid value");
-  // This statement is unreachable, and would never terminate even if it
-  // could be reached. It is provided only to placate compiler warnings
-  // about missing return statements.
-  return Invalid<T>();
-}
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-// Given a raw type (i.e. having no top-level reference or const
-// modifier) RawContainer that's either an STL-style container or a
-// native array, class StlContainerView<RawContainer> has the
-// following members:
-//
-//   - type is a type that provides an STL-style container view to
-//     (i.e. implements the STL container concept for) RawContainer;
-//   - const_reference is a type that provides a reference to a const
-//     RawContainer;
-//   - ConstReference(raw_container) returns a const reference to an STL-style
-//     container view to raw_container, which is a RawContainer.
-//   - Copy(raw_container) returns an STL-style container view of a
-//     copy of raw_container, which is a RawContainer.
-//
-// This generic version is used when RawContainer itself is already an
-// STL-style container.
-template <class RawContainer>
-class StlContainerView {
- public:
-  typedef RawContainer type;
-  typedef const type& const_reference;
-
-  static const_reference ConstReference(const RawContainer& container) {
-    // Ensures that RawContainer is not a const type.
-    testing::StaticAssertTypeEq<RawContainer,
-        GTEST_REMOVE_CONST_(RawContainer)>();
-    return container;
-  }
-  static type Copy(const RawContainer& container) { return container; }
-};
-
-// This specialization is used when RawContainer is a native array type.
-template <typename Element, size_t N>
-class StlContainerView<Element[N]> {
- public:
-  typedef GTEST_REMOVE_CONST_(Element) 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'
-  // can be used to reference a const native array.  We cannot
-  // 'typedef const type& const_reference' here, as that would mean
-  // ConstReference() has to return a reference to a local variable.
-  typedef const type const_reference;
-
-  static const_reference ConstReference(const Element (&array)[N]) {
-    // Ensures that Element is not a const type.
-    testing::StaticAssertTypeEq<Element, RawElement>();
-#if GTEST_OS_SYMBIAN
-    // The Nokia Symbian compiler confuses itself in template instantiation
-    // for this call without the cast to Element*:
-    // function call '[testing::internal::NativeArray<char *>].NativeArray(
-    //     {lval} const char *[4], long, testing::internal::RelationToSource)'
-    //     does not match
-    // 'testing::internal::NativeArray<char *>::NativeArray(
-    //     char *const *, unsigned int, testing::internal::RelationToSource)'
-    // (instantiating: 'testing::internal::ContainsMatcherImpl
-    //     <const char * (&)[4]>::Matches(const char * (&)[4]) const')
-    // (instantiating: 'testing::internal::StlContainerView<char *[4]>::
-    //     ConstReference(const char * (&)[4])')
-    // (and though the N parameter type is mismatched in the above explicit
-    // conversion of it doesn't help - only the conversion of the array).
-    return type(const_cast<Element*>(&array[0]), N,
-                RelationToSourceReference());
-#else
-    return type(array, N, RelationToSourceReference());
-#endif  // GTEST_OS_SYMBIAN
-  }
-  static type Copy(const Element (&array)[N]) {
-#if GTEST_OS_SYMBIAN
-    return type(const_cast<Element*>(&array[0]), N, RelationToSourceCopy());
-#else
-    return type(array, N, RelationToSourceCopy());
-#endif  // GTEST_OS_SYMBIAN
-  }
-};
-
-// This specialization is used when RawContainer is a native array
-// represented as a (pointer, size) tuple.
-template <typename ElementPointer, typename Size>
-class StlContainerView< ::testing::tuple<ElementPointer, Size> > {
- public:
-  typedef GTEST_REMOVE_CONST_(
-      typename internal::PointeeOf<ElementPointer>::type) RawElement;
-  typedef internal::NativeArray<RawElement> type;
-  typedef const type const_reference;
-
-  static const_reference ConstReference(
-      const ::testing::tuple<ElementPointer, Size>& array) {
-    return type(get<0>(array), get<1>(array), RelationToSourceReference());
-  }
-  static type Copy(const ::testing::tuple<ElementPointer, Size>& array) {
-    return type(get<0>(array), get<1>(array), RelationToSourceCopy());
-  }
-};
-
-// The following specialization prevents the user from instantiating
-// StlContainer with a reference type.
-template <typename T> class StlContainerView<T&>;
-
-// A type transform to remove constness from the first part of a pair.
-// Pairs like that are used as the value_type of associative containers,
-// and this transform produces a similar but assignable pair.
-template <typename T>
-struct RemoveConstFromKey {
-  typedef T type;
-};
-
-// Partially specialized to remove constness from std::pair<const K, V>.
-template <typename K, typename V>
-struct RemoveConstFromKey<std::pair<const K, V> > {
-  typedef std::pair<K, V> type;
-};
-
-// Mapping from booleans to types. Similar to boost::bool_<kValue> and
-// std::integral_constant<bool, kValue>.
-template <bool kValue>
-struct BooleanConstant {};
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
-
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-port.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-port.h
deleted file mode 100644
index 63f4a680..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/include/gmock/internal/gmock-port.h
+++ /dev/null
@@ -1,91 +0,0 @@
-// 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.
-//
-// Author: vadimb@google.com (Vadim Berman)
-//
-// Low-level types and utilities for porting Google Mock to various
-// platforms.  All macros ending with _ and symbols defined in an
-// internal namespace are subject to change without notice.  Code
-// outside Google Mock MUST NOT USE THEM DIRECTLY.  Macros that don't
-// end with _ are part of Google Mock's public API and can be used by
-// code outside Google Mock.
-
-#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
-#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
-
-#include <assert.h>
-#include <stdlib.h>
-#include <iostream>
-
-// Most of the utilities needed for porting Google Mock are also
-// required for Google Test and are defined in gtest-port.h.
-//
-// Note to maintainers: to reduce code duplication, prefer adding
-// 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-linked_ptr.h"
-#include "gtest/internal/gtest-port.h"
-#include "gmock/internal/custom/gmock-port.h"
-
-// To avoid conditional compilation everywhere, we make it
-// gmock-port.h's responsibility to #include the header implementing
-// tr1/tuple.  gmock-port.h does this via gtest-port.h, which is
-// guaranteed to pull in the tuple header.
-
-// For MS Visual C++, check the compiler version. At least VS 2003 is
-// required to compile Google Mock.
-#if defined(_MSC_VER) && _MSC_VER < 1310
-# error "At least Visual C++ 2003 (7.1) is required to compile Google Mock."
-#endif
-
-// Macro for referencing flags.  This is public as we want the user to
-// use this syntax to reference Google Mock flags.
-#define GMOCK_FLAG(name) FLAGS_gmock_##name
-
-#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_ ::testing::internal::Int32 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) \
-    GTEST_API_ bool GMOCK_FLAG(name) = (default_val)
-#define GMOCK_DEFINE_int32_(name, default_val, doc) \
-    GTEST_API_ ::testing::internal::Int32 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  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/make/Makefile b/week4/softwareEng_9_4/vendor/googletest/googlemock/make/Makefile
deleted file mode 100644
index 7c13e05f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/make/Makefile
+++ /dev/null
@@ -1,101 +0,0 @@
-# A sample Makefile for building both Google Mock and Google Test and
-# using them in user tests.  This file is self-contained, so you don't
-# need to use the Makefile in Google Test's source tree.  Please tweak
-# it to suit your environment and project.  You may want to move it to
-# your project's root directory.
-#
-# SYNOPSIS:
-#
-#   make [all]  - makes everything.
-#   make TARGET - makes the given target.
-#   make clean  - removes all files generated by make.
-
-# Please tweak the following variable definitions as needed by your
-# project, except GMOCK_HEADERS and GTEST_HEADERS, which you can use
-# in your own targets but shouldn't modify.
-
-# Points to the root of Google Test, relative to where this file is.
-# Remember to tweak this if you move this file, or if you want to use
-# a copy of Google Test at a different location.
-GTEST_DIR = ../../googletest
-
-# Points to the root of Google Mock, relative to where this file is.
-# Remember to tweak this if you move this file.
-GMOCK_DIR = ..
-
-# Where to find user code.
-USER_DIR = ../test
-
-# Flags passed to the preprocessor.
-# Set Google Test and Google Mock's header directories as system
-# directories, such that the compiler doesn't generate warnings in
-# these headers.
-CPPFLAGS += -isystem $(GTEST_DIR)/include -isystem $(GMOCK_DIR)/include
-
-# Flags passed to the C++ compiler.
-CXXFLAGS += -g -Wall -Wextra -pthread
-
-# All tests produced by this Makefile.  Remember to add new tests you
-# created to the list.
-TESTS = gmock_test
-
-# All Google Test headers.  Usually you shouldn't change this
-# definition.
-GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
-                $(GTEST_DIR)/include/gtest/internal/*.h
-
-# All Google Mock headers. Note that all Google Test headers are
-# included here too, as they are #included by Google Mock headers.
-# Usually you shouldn't change this definition.	
-GMOCK_HEADERS = $(GMOCK_DIR)/include/gmock/*.h \
-                $(GMOCK_DIR)/include/gmock/internal/*.h \
-                $(GTEST_HEADERS)
-
-# House-keeping build targets.
-
-all : $(TESTS)
-
-clean :
-	rm -f $(TESTS) gmock.a gmock_main.a *.o
-
-# Builds gmock.a and gmock_main.a.  These libraries contain both
-# Google Mock and Google Test.  A test should link with either gmock.a
-# or gmock_main.a, depending on whether it defines its own main()
-# function.  It's fine if your test only uses features from Google
-# Test (and not Google Mock).
-
-# Usually you shouldn't tweak such internal variables, indicated by a
-# trailing _.
-GTEST_SRCS_ = $(GTEST_DIR)/src/*.cc $(GTEST_DIR)/src/*.h $(GTEST_HEADERS)
-GMOCK_SRCS_ = $(GMOCK_DIR)/src/*.cc $(GMOCK_HEADERS)
-
-# For simplicity and to avoid depending on implementation details of
-# Google Mock and Google Test, the dependencies specified below are
-# conservative and not optimized.  This is fine as Google Mock and
-# Google Test compile fast and for ordinary users their source rarely
-# changes.
-gtest-all.o : $(GTEST_SRCS_)
-	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
-            -c $(GTEST_DIR)/src/gtest-all.cc
-
-gmock-all.o : $(GMOCK_SRCS_)
-	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
-            -c $(GMOCK_DIR)/src/gmock-all.cc
-
-gmock_main.o : $(GMOCK_SRCS_)
-	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
-            -c $(GMOCK_DIR)/src/gmock_main.cc
-
-gmock.a : gmock-all.o gtest-all.o
-	$(AR) $(ARFLAGS) $@ $^
-
-gmock_main.a : gmock-all.o gtest-all.o gmock_main.o
-	$(AR) $(ARFLAGS) $@ $^
-
-# Builds a sample test.
-
-gmock_test.o : $(USER_DIR)/gmock_test.cc $(GMOCK_HEADERS)
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/gmock_test.cc
-
-gmock_test : gmock_test.o gmock_main.a
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.sln b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.sln
deleted file mode 100644
index b752f876..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.sln
+++ /dev/null
@@ -1,32 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 9.00
-# Visual Studio 2005
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock", "gmock.vcproj", "{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_test", "gmock_test.vcproj", "{F10D22F8-AC7B-4213-8720-608E7D878CD2}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_main", "gmock_main.vcproj", "{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.ActiveCfg = Debug|Win32
-		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.Build.0 = Debug|Win32
-		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.ActiveCfg = Release|Win32
-		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.Build.0 = Release|Win32
-		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.ActiveCfg = Debug|Win32
-		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.Build.0 = Debug|Win32
-		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.ActiveCfg = Release|Win32
-		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.Build.0 = Release|Win32
-		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.ActiveCfg = Debug|Win32
-		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.Build.0 = Debug|Win32
-		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.ActiveCfg = Release|Win32
-		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.vcproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.vcproj
deleted file mode 100644
index 4bbfe989..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock.vcproj
+++ /dev/null
@@ -1,191 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="8.00"
-	Name="gmock"
-	ProjectGUID="{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
-	RootNamespace="gmock"
-	Keyword="Win32Proj"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)\$(ProjectName)"
-			ConfigurationType="4"
-			InheritedPropertySheets=".\gmock_config.vsprops"
-			CharacterSet="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories="..\..\include;..\.."
-				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)\$(ProjectName)"
-			ConfigurationType="4"
-			InheritedPropertySheets=".\gmock_config.vsprops"
-			CharacterSet="1"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				AdditionalIncludeDirectories="..\..\include;..\.."
-				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
-				RuntimeLibrary="0"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath="..\..\src\gmock-all.cc"
-				>
-			</File>
-			<File
-				RelativePath="$(GTestDir)\src\gtest-all.cc"
-				>
-				<FileConfiguration
-					Name="Debug|Win32"
-					>
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="$(GTestDir)"
-					/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32"
-					>
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="$(GTestDir)"
-					/>
-				</FileConfiguration>
-			</File>
-		</Filter>
-		<Filter
-			Name="Public Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-		</Filter>
-		<Filter
-			Name="Private Header Files"
-			>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_config.vsprops b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_config.vsprops
deleted file mode 100644
index 875939c1..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_config.vsprops
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioPropertySheet
-	ProjectType="Visual C++"
-	Version="8.00"
-	Name="gmock_config"
-	>
-	<Tool
-		Name="VCCLCompilerTool"
-		AdditionalIncludeDirectories="&quot;$(GTestDir)/include&quot;"
-	/>
-	<UserMacro
-		Name="GTestDir"
-		Value="../../../googletest"
-	/>
-</VisualStudioPropertySheet>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_main.vcproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_main.vcproj
deleted file mode 100644
index 01505a93..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_main.vcproj
+++ /dev/null
@@ -1,187 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="8.00"
-	Name="gmock_main"
-	ProjectGUID="{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
-	RootNamespace="gmock_main"
-	Keyword="Win32Proj"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)\$(ProjectName)"
-			ConfigurationType="4"
-			InheritedPropertySheets=".\gmock_config.vsprops"
-			CharacterSet="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories="../../include"
-				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)\$(ProjectName)"
-			ConfigurationType="4"
-			InheritedPropertySheets=".\gmock_config.vsprops"
-			CharacterSet="1"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				AdditionalIncludeDirectories="../../include"
-				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
-				RuntimeLibrary="0"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-		<ProjectReference
-			ReferencedProjectIdentifier="{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
-			RelativePathToProject=".\gmock.vcproj"
-		/>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath="..\..\src\gmock_main.cc"
-				>
-				<FileConfiguration
-					Name="Debug|Win32"
-					>
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="../../include"
-					/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32"
-					>
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="../../include"
-					/>
-				</FileConfiguration>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_test.vcproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_test.vcproj
deleted file mode 100644
index d1e01e71..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2005/gmock_test.vcproj
+++ /dev/null
@@ -1,201 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="8.00"
-	Name="gmock_test"
-	ProjectGUID="{F10D22F8-AC7B-4213-8720-608E7D878CD2}"
-	RootNamespace="gmock_test"
-	Keyword="Win32Proj"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)\$(ProjectName)"
-			ConfigurationType="1"
-			InheritedPropertySheets=".\gmock_config.vsprops"
-			CharacterSet="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				AdditionalOptions="/bigobj"
-				Optimization="0"
-				AdditionalIncludeDirectories="..\..\include;..\.."
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="1"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="2"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCWebDeploymentTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)\$(ProjectName)"
-			ConfigurationType="1"
-			InheritedPropertySheets=".\gmock_config.vsprops"
-			CharacterSet="1"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				AdditionalOptions="/bigobj"
-				AdditionalIncludeDirectories="..\..\include;..\.."
-				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
-				RuntimeLibrary="0"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="1"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCWebDeploymentTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-		<ProjectReference
-			ReferencedProjectIdentifier="{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
-			RelativePathToProject=".\gmock_main.vcproj"
-		/>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath="..\..\test\gmock_all_test.cc"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.sln b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.sln
deleted file mode 100644
index d9496569..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.sln
+++ /dev/null
@@ -1,32 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 11.00
-# Visual C++ Express 2010
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock", "gmock.vcxproj", "{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_test", "gmock_test.vcxproj", "{F10D22F8-AC7B-4213-8720-608E7D878CD2}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_main", "gmock_main.vcxproj", "{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.ActiveCfg = Debug|Win32
-		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.Build.0 = Debug|Win32
-		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.ActiveCfg = Release|Win32
-		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.Build.0 = Release|Win32
-		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.ActiveCfg = Debug|Win32
-		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.Build.0 = Debug|Win32
-		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.ActiveCfg = Release|Win32
-		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.Build.0 = Release|Win32
-		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.ActiveCfg = Debug|Win32
-		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.Build.0 = Debug|Win32
-		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.ActiveCfg = Release|Win32
-		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.vcxproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.vcxproj
deleted file mode 100644
index 21a85ef6..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock.vcxproj
+++ /dev/null
@@ -1,82 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}</ProjectGuid>
-    <RootNamespace>gmock</RootNamespace>
-    <Keyword>Win32Proj</Keyword>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="gmock_config.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="gmock_config.props" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MinimalRebuild>true</MinimalRebuild>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="..\..\src\gmock-all.cc" />
-    <ClCompile Include="$(GTestDir)\src\gtest-all.cc">
-      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(GTestDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(GTestDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_config.props b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_config.props
deleted file mode 100644
index 441f31cf..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_config.props
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="UserMacros">
-    <GTestDir>../../../googletest</GTestDir>
-  </PropertyGroup>
-  <PropertyGroup>
-    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
-  </PropertyGroup>
-  <ItemDefinitionGroup>
-    <ClCompile>
-      <AdditionalIncludeDirectories>$(GTestDir)/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <BuildMacro Include="GTestDir">
-      <Value>$(GTestDir)</Value>
-    </BuildMacro>
-  </ItemGroup>
-</Project>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_main.vcxproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_main.vcxproj
deleted file mode 100644
index 27fecd5f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_main.vcxproj
+++ /dev/null
@@ -1,88 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{E4EF614B-30DF-4954-8C53-580A0BF6B589}</ProjectGuid>
-    <RootNamespace>gmock_main</RootNamespace>
-    <Keyword>Win32Proj</Keyword>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="gmock_config.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="gmock_config.props" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MinimalRebuild>true</MinimalRebuild>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ProjectReference Include="gmock.vcxproj">
-      <Project>{34681f0d-ce45-415d-b5f2-5c662dfe3bd5}</Project>
-      <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
-      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\..\src\gmock_main.cc">
-      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_test.vcxproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_test.vcxproj
deleted file mode 100644
index 265439ec..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2010/gmock_test.vcxproj
+++ /dev/null
@@ -1,101 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{F10D22F8-AC7B-4213-8720-608E7D878CD2}</ProjectGuid>
-    <RootNamespace>gmock_test</RootNamespace>
-    <Keyword>Win32Proj</Keyword>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="gmock_config.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="gmock_config.props" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MinimalRebuild>true</MinimalRebuild>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <TargetMachine>MachineX86</TargetMachine>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
-      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <TargetMachine>MachineX86</TargetMachine>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ProjectReference Include="gmock_main.vcxproj">
-      <Project>{e4ef614b-30df-4954-8c53-580a0bf6b589}</Project>
-      <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
-      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\..\test\gmock_all_test.cc" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.sln b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.sln
deleted file mode 100644
index c59e07fc..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.sln
+++ /dev/null
@@ -1,32 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock", "gmock.vcxproj", "{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_test", "gmock_test.vcxproj", "{F10D22F8-AC7B-4213-8720-608E7D878CD2}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gmock_main", "gmock_main.vcxproj", "{E4EF614B-30DF-4954-8C53-580A0BF6B589}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.ActiveCfg = Debug|Win32
-		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Debug|Win32.Build.0 = Debug|Win32
-		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.ActiveCfg = Release|Win32
-		{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}.Release|Win32.Build.0 = Release|Win32
-		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.ActiveCfg = Debug|Win32
-		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Debug|Win32.Build.0 = Debug|Win32
-		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.ActiveCfg = Release|Win32
-		{F10D22F8-AC7B-4213-8720-608E7D878CD2}.Release|Win32.Build.0 = Release|Win32
-		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.ActiveCfg = Debug|Win32
-		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Debug|Win32.Build.0 = Debug|Win32
-		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.ActiveCfg = Release|Win32
-		{E4EF614B-30DF-4954-8C53-580A0BF6B589}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.vcxproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.vcxproj
deleted file mode 100644
index d5ddd091..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock.vcxproj
+++ /dev/null
@@ -1,84 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{34681F0D-CE45-415D-B5F2-5C662DFE3BD5}</ProjectGuid>
-    <RootNamespace>gmock</RootNamespace>
-    <Keyword>Win32Proj</Keyword>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <PlatformToolset>v140</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v140</PlatformToolset>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="gmock_config.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="gmock_config.props" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MinimalRebuild>true</MinimalRebuild>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="..\..\src\gmock-all.cc" />
-    <ClCompile Include="$(GTestDir)\src\gtest-all.cc">
-      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(GTestDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(GTestDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_config.props b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_config.props
deleted file mode 100644
index 77bc95b1..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_config.props
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="UserMacros">
-    <GTestDir>../../../googletest</GTestDir>
-  </PropertyGroup>
-  <PropertyGroup>
-    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
-  </PropertyGroup>
-  <ItemDefinitionGroup>
-    <ClCompile>
-      <AdditionalIncludeDirectories>$(GTestDir)/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <BuildMacro Include="GTestDir">
-      <Value>$(GTestDir)</Value>
-    </BuildMacro>
-  </ItemGroup>
-</Project>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_main.vcxproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_main.vcxproj
deleted file mode 100644
index 76cc68b9..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_main.vcxproj
+++ /dev/null
@@ -1,90 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{E4EF614B-30DF-4954-8C53-580A0BF6B589}</ProjectGuid>
-    <RootNamespace>gmock_main</RootNamespace>
-    <Keyword>Win32Proj</Keyword>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <PlatformToolset>v140</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v140</PlatformToolset>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="gmock_config.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="gmock_config.props" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MinimalRebuild>true</MinimalRebuild>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ProjectReference Include="gmock.vcxproj">
-      <Project>{34681f0d-ce45-415d-b5f2-5c662dfe3bd5}</Project>
-      <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
-      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\..\src\gmock_main.cc">
-      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_test.vcxproj b/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_test.vcxproj
deleted file mode 100644
index 76ea5534..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/msvc/2015/gmock_test.vcxproj
+++ /dev/null
@@ -1,103 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{F10D22F8-AC7B-4213-8720-608E7D878CD2}</ProjectGuid>
-    <RootNamespace>gmock_test</RootNamespace>
-    <Keyword>Win32Proj</Keyword>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <PlatformToolset>v140</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v140</PlatformToolset>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="gmock_config.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="gmock_config.props" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(OutDir)$(ProjectName)\</IntDir>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(OutDir)$(ProjectName)\</IntDir>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>..\..\include;..\..;$(GTestDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MinimalRebuild>true</MinimalRebuild>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <TargetMachine>MachineX86</TargetMachine>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
-      <AdditionalIncludeDirectories>..\..\include;..\..;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <PrecompiledHeader>
-      </PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <TargetMachine>MachineX86</TargetMachine>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ProjectReference Include="gmock_main.vcxproj">
-      <Project>{e4ef614b-30df-4954-8c53-580a0bf6b589}</Project>
-      <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
-      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\..\test\gmock_all_test.cc" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/fuse_gmock_files.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/fuse_gmock_files.py
deleted file mode 100755
index cb7fdf2f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/fuse_gmock_files.py
+++ /dev/null
@@ -1,240 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2009, 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.
-
-"""fuse_gmock_files.py v0.1.0
-Fuses Google Mock and Google Test source code into two .h files and a .cc file.
-
-SYNOPSIS
-       fuse_gmock_files.py [GMOCK_ROOT_DIR] OUTPUT_DIR
-
-       Scans GMOCK_ROOT_DIR for Google Mock and Google Test source
-       code, assuming Google Test is in the GMOCK_ROOT_DIR/../googletest
-       directory, and generates three files:
-       OUTPUT_DIR/gtest/gtest.h, OUTPUT_DIR/gmock/gmock.h, and
-       OUTPUT_DIR/gmock-gtest-all.cc.  Then you can build your tests
-       by adding OUTPUT_DIR to the include search path and linking
-       with OUTPUT_DIR/gmock-gtest-all.cc.  These three files contain
-       everything you need to use Google Mock.  Hence you can
-       "install" Google Mock by copying them to wherever you want.
-
-       GMOCK_ROOT_DIR can be omitted and defaults to the parent
-       directory of the directory holding this script.
-
-EXAMPLES
-       ./fuse_gmock_files.py fused_gmock
-       ./fuse_gmock_files.py path/to/unpacked/gmock fused_gmock
-
-This tool is experimental.  In particular, it assumes that there is no
-conditional inclusion of Google Mock or Google Test headers.  Please
-report any problems to googlemock@googlegroups.com.  You can read
-http://code.google.com/p/googlemock/wiki/CookBook for more
-information.
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import re
-import sets
-import sys
-
-# We assume that this file is in the scripts/ directory in the Google
-# Mock root directory.
-DEFAULT_GMOCK_ROOT_DIR = os.path.join(os.path.dirname(__file__), '..')
-
-# We need to call into googletest/scripts/fuse_gtest_files.py.
-sys.path.append(os.path.join(DEFAULT_GMOCK_ROOT_DIR, '../googletest/scripts'))
-import fuse_gtest_files
-gtest = fuse_gtest_files
-
-# Regex for matching '#include "gmock/..."'.
-INCLUDE_GMOCK_FILE_REGEX = re.compile(r'^\s*#\s*include\s*"(gmock/.+)"')
-
-# Where to find the source seed files.
-GMOCK_H_SEED = 'include/gmock/gmock.h'
-GMOCK_ALL_CC_SEED = 'src/gmock-all.cc'
-
-# Where to put the generated files.
-GTEST_H_OUTPUT = 'gtest/gtest.h'
-GMOCK_H_OUTPUT = 'gmock/gmock.h'
-GMOCK_GTEST_ALL_CC_OUTPUT = 'gmock-gtest-all.cc'
-
-
-def GetGTestRootDir(gmock_root):
-  """Returns the root directory of Google Test."""
-
-  return os.path.join(gmock_root, '../googletest')
-
-
-def ValidateGMockRootDir(gmock_root):
-  """Makes sure gmock_root points to a valid gmock root directory.
-
-  The function aborts the program on failure.
-  """
-
-  gtest.ValidateGTestRootDir(GetGTestRootDir(gmock_root))
-  gtest.VerifyFileExists(gmock_root, GMOCK_H_SEED)
-  gtest.VerifyFileExists(gmock_root, GMOCK_ALL_CC_SEED)
-
-
-def ValidateOutputDir(output_dir):
-  """Makes sure output_dir points to a valid output directory.
-
-  The function aborts the program on failure.
-  """
-
-  gtest.VerifyOutputFile(output_dir, gtest.GTEST_H_OUTPUT)
-  gtest.VerifyOutputFile(output_dir, GMOCK_H_OUTPUT)
-  gtest.VerifyOutputFile(output_dir, GMOCK_GTEST_ALL_CC_OUTPUT)
-
-
-def FuseGMockH(gmock_root, output_dir):
-  """Scans folder gmock_root to generate gmock/gmock.h in output_dir."""
-
-  output_file = file(os.path.join(output_dir, GMOCK_H_OUTPUT), 'w')
-  processed_files = sets.Set()  # Holds all gmock headers we've processed.
-
-  def ProcessFile(gmock_header_path):
-    """Processes the given gmock header file."""
-
-    # We don't process the same header twice.
-    if gmock_header_path in processed_files:
-      return
-
-    processed_files.add(gmock_header_path)
-
-    # Reads each line in the given gmock header.
-    for line in file(os.path.join(gmock_root, gmock_header_path), 'r'):
-      m = INCLUDE_GMOCK_FILE_REGEX.match(line)
-      if m:
-        # It's '#include "gmock/..."' - let's process it recursively.
-        ProcessFile('include/' + m.group(1))
-      else:
-        m = gtest.INCLUDE_GTEST_FILE_REGEX.match(line)
-        if m:
-          # It's '#include "gtest/foo.h"'.  We translate it to
-          # "gtest/gtest.h", regardless of what foo is, since all
-          # gtest headers are fused into gtest/gtest.h.
-
-          # There is no need to #include gtest.h twice.
-          if not gtest.GTEST_H_SEED in processed_files:
-            processed_files.add(gtest.GTEST_H_SEED)
-            output_file.write('#include "%s"\n' % (gtest.GTEST_H_OUTPUT,))
-        else:
-          # Otherwise we copy the line unchanged to the output file.
-          output_file.write(line)
-
-  ProcessFile(GMOCK_H_SEED)
-  output_file.close()
-
-
-def FuseGMockAllCcToFile(gmock_root, output_file):
-  """Scans folder gmock_root to fuse gmock-all.cc into output_file."""
-
-  processed_files = sets.Set()
-
-  def ProcessFile(gmock_source_file):
-    """Processes the given gmock source file."""
-
-    # We don't process the same #included file twice.
-    if gmock_source_file in processed_files:
-      return
-
-    processed_files.add(gmock_source_file)
-
-    # Reads each line in the given gmock source file.
-    for line in file(os.path.join(gmock_root, gmock_source_file), 'r'):
-      m = INCLUDE_GMOCK_FILE_REGEX.match(line)
-      if m:
-        # It's '#include "gmock/foo.h"'.  We treat it as '#include
-        # "gmock/gmock.h"', as all other gmock headers are being fused
-        # into gmock.h and cannot be #included directly.
-
-        # There is no need to #include "gmock/gmock.h" more than once.
-        if not GMOCK_H_SEED in processed_files:
-          processed_files.add(GMOCK_H_SEED)
-          output_file.write('#include "%s"\n' % (GMOCK_H_OUTPUT,))
-      else:
-        m = gtest.INCLUDE_GTEST_FILE_REGEX.match(line)
-        if m:
-          # It's '#include "gtest/..."'.
-          # There is no need to #include gtest.h as it has been
-          # #included by gtest-all.cc.
-          pass
-        else:
-          m = gtest.INCLUDE_SRC_FILE_REGEX.match(line)
-          if m:
-            # It's '#include "src/foo"' - let's process it recursively.
-            ProcessFile(m.group(1))
-          else:
-            # Otherwise we copy the line unchanged to the output file.
-            output_file.write(line)
-
-  ProcessFile(GMOCK_ALL_CC_SEED)
-
-
-def FuseGMockGTestAllCc(gmock_root, output_dir):
-  """Scans folder gmock_root to generate gmock-gtest-all.cc in output_dir."""
-
-  output_file = file(os.path.join(output_dir, GMOCK_GTEST_ALL_CC_OUTPUT), 'w')
-  # First, fuse gtest-all.cc into gmock-gtest-all.cc.
-  gtest.FuseGTestAllCcToFile(GetGTestRootDir(gmock_root), output_file)
-  # Next, append fused gmock-all.cc to gmock-gtest-all.cc.
-  FuseGMockAllCcToFile(gmock_root, output_file)
-  output_file.close()
-
-
-def FuseGMock(gmock_root, output_dir):
-  """Fuses gtest.h, gmock.h, and gmock-gtest-all.h."""
-
-  ValidateGMockRootDir(gmock_root)
-  ValidateOutputDir(output_dir)
-
-  gtest.FuseGTestH(GetGTestRootDir(gmock_root), output_dir)
-  FuseGMockH(gmock_root, output_dir)
-  FuseGMockGTestAllCc(gmock_root, output_dir)
-
-
-def main():
-  argc = len(sys.argv)
-  if argc == 2:
-    # fuse_gmock_files.py OUTPUT_DIR
-    FuseGMock(DEFAULT_GMOCK_ROOT_DIR, sys.argv[1])
-  elif argc == 3:
-    # fuse_gmock_files.py GMOCK_ROOT_DIR OUTPUT_DIR
-    FuseGMock(sys.argv[1], sys.argv[2])
-  else:
-    print __doc__
-    sys.exit(1)
-
-
-if __name__ == '__main__':
-  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/LICENSE b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/LICENSE
deleted file mode 100644
index 87ea0636..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/LICENSE
+++ /dev/null
@@ -1,203 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [2007] Neal Norwitz
-   Portions Copyright [2007] Google Inc.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README
deleted file mode 100644
index d6f95974..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README
+++ /dev/null
@@ -1,35 +0,0 @@
-
-The Google Mock class generator is an application that is part of cppclean.
-For more information about cppclean, see the README.cppclean file or
-visit http://code.google.com/p/cppclean/
-
-cppclean requires Python 2.3.5 or later.  If you don't have Python installed
-on your system, you will also need to install it.  You can download Python
-from:  http://www.python.org/download/releases/
-
-To use the Google Mock class generator, you need to call it
-on the command line passing the header file and class for which you want
-to generate a Google Mock class.
-
-Make sure to install the scripts somewhere in your path.  Then you can
-run the program.
-
-  gmock_gen.py header-file.h [ClassName]...
-
-If no ClassNames are specified, all classes in the file are emitted.
-
-To change the indentation from the default of 2, set INDENT in
-the environment.  For example to use an indent of 4 spaces:
-
-INDENT=4 gmock_gen.py header-file.h ClassName
-
-This version was made from SVN revision 281 in the cppclean repository.
-
-Known Limitations
------------------
-Not all code will be generated properly.  For example, when mocking templated
-classes, the template information is lost.  You will need to add the template
-information manually.
-
-Not all permutations of using multiple pointers/references will be rendered
-properly.  These will also have to be fixed manually.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README.cppclean b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README.cppclean
deleted file mode 100644
index 65431b61..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/README.cppclean
+++ /dev/null
@@ -1,115 +0,0 @@
-Goal:
------
-  CppClean attempts to find problems in C++ source that slow development
-  in large code bases, for example various forms of unused code.
-  Unused code can be unused functions, methods, data members, types, etc
-  to unnecessary #include directives.  Unnecessary #includes can cause
-  considerable extra compiles increasing the edit-compile-run cycle.
-
-  The project home page is:   http://code.google.com/p/cppclean/
-
-
-Features:
----------
- * Find and print C++ language constructs: classes, methods, functions, etc.
- * Find classes with virtual methods, no virtual destructor, and no bases
- * Find global/static data that are potential problems when using threads
- * Unnecessary forward class declarations
- * Unnecessary function declarations
- * Undeclared function definitions
- * (planned) Find unnecessary header files #included
-   - No direct reference to anything in the header
-   - Header is unnecessary if classes were forward declared instead
- * (planned) Source files that reference headers not directly #included,
-   ie, files that rely on a transitive #include from another header
- * (planned) Unused members (private, protected, & public) methods and data
- * (planned) Store AST in a SQL database so relationships can be queried
-
-AST is Abstract Syntax Tree, a representation of parsed source code.
-http://en.wikipedia.org/wiki/Abstract_syntax_tree
-
-
-System Requirements:
---------------------
- * Python 2.4 or later (2.3 probably works too)
- * Works on Windows (untested), Mac OS X, and Unix
-
-
-How to Run:
------------
-  For all examples, it is assumed that cppclean resides in a directory called
-  /cppclean.
-
-  To print warnings for classes with virtual methods, no virtual destructor and
-  no base classes:
-
-      /cppclean/run.sh nonvirtual_dtors.py file1.h file2.h file3.cc ...
-
-  To print all the functions defined in header file(s):
-
-      /cppclean/run.sh functions.py file1.h file2.h ...
-
-  All the commands take multiple files on the command line.  Other programs
-  include: find_warnings, headers, methods, and types.  Some other programs
-  are available, but used primarily for debugging.
-
-  run.sh is a simple wrapper that sets PYTHONPATH to /cppclean and then
-  runs the program in /cppclean/cpp/PROGRAM.py.  There is currently
-  no equivalent for Windows.  Contributions for a run.bat file
-  would be greatly appreciated.
-
-
-How to Configure:
------------------
-  You can add a siteheaders.py file in /cppclean/cpp to configure where
-  to look for other headers (typically -I options passed to a compiler).
-  Currently two values are supported:  _TRANSITIVE and GetIncludeDirs.
-  _TRANSITIVE should be set to a boolean value (True or False) indicating
-  whether to transitively process all header files.  The default is False.
-
-  GetIncludeDirs is a function that takes a single argument and returns
-  a sequence of directories to include.  This can be a generator or
-  return a static list.
-
-      def GetIncludeDirs(filename):
-          return ['/some/path/with/other/headers']
-
-      # Here is a more complicated example.
-      def GetIncludeDirs(filename):
-          yield '/path1'
-          yield os.path.join('/path2', os.path.dirname(filename))
-          yield '/path3'
-
-
-How to Test:
-------------
-  For all examples, it is assumed that cppclean resides in a directory called
-  /cppclean.  The tests require
-
-  cd /cppclean
-  make test
-  # To generate expected results after a change:
-  make expected
-
-
-Current Status:
----------------
-  The parser works pretty well for header files, parsing about 99% of Google's
-  header files.  Anything which inspects structure of C++ source files should
-  work reasonably well.  Function bodies are not transformed to an AST,
-  but left as tokens.  Much work is still needed on finding unused header files
-  and storing an AST in a database.
-
-
-Non-goals:
-----------
- * Parsing all valid C++ source
- * Handling invalid C++ source gracefully
- * Compiling to machine code (or anything beyond an AST)
-
-
-Contact:
---------
-  If you used cppclean, I would love to hear about your experiences
-  cppclean@googlegroups.com.  Even if you don't use cppclean, I'd like to
-  hear from you.  :-)  (You can contact me directly at:  nnorwitz@gmail.com)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/__init__.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/__init__.py
deleted file mode 100755
index e69de29b..00000000
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/ast.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/ast.py
deleted file mode 100755
index 11cbe912..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/ast.py
+++ /dev/null
@@ -1,1733 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2007 Neal Norwitz
-# Portions Copyright 2007 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Generate an Abstract Syntax Tree (AST) for C++."""
-
-__author__ = 'nnorwitz@google.com (Neal Norwitz)'
-
-
-# TODO:
-#  * Tokens should never be exported, need to convert to Nodes
-#    (return types, parameters, etc.)
-#  * Handle static class data for templatized classes
-#  * Handle casts (both C++ and C-style)
-#  * Handle conditions and loops (if/else, switch, for, while/do)
-#
-# TODO much, much later:
-#  * Handle #define
-#  * exceptions
-
-
-try:
-    # Python 3.x
-    import builtins
-except ImportError:
-    # Python 2.x
-    import __builtin__ as builtins
-
-import sys
-import traceback
-
-from cpp import keywords
-from cpp import tokenize
-from cpp import utils
-
-
-if not hasattr(builtins, 'reversed'):
-    # Support Python 2.3 and earlier.
-    def reversed(seq):
-        for i in range(len(seq)-1, -1, -1):
-            yield seq[i]
-
-if not hasattr(builtins, 'next'):
-    # Support Python 2.5 and earlier.
-    def next(obj):
-        return obj.next()
-
-
-VISIBILITY_PUBLIC, VISIBILITY_PROTECTED, VISIBILITY_PRIVATE = range(3)
-
-FUNCTION_NONE = 0x00
-FUNCTION_CONST = 0x01
-FUNCTION_VIRTUAL = 0x02
-FUNCTION_PURE_VIRTUAL = 0x04
-FUNCTION_CTOR = 0x08
-FUNCTION_DTOR = 0x10
-FUNCTION_ATTRIBUTE = 0x20
-FUNCTION_UNKNOWN_ANNOTATION = 0x40
-FUNCTION_THROW = 0x80
-FUNCTION_OVERRIDE = 0x100
-
-"""
-These are currently unused.  Should really handle these properly at some point.
-
-TYPE_MODIFIER_INLINE   = 0x010000
-TYPE_MODIFIER_EXTERN   = 0x020000
-TYPE_MODIFIER_STATIC   = 0x040000
-TYPE_MODIFIER_CONST    = 0x080000
-TYPE_MODIFIER_REGISTER = 0x100000
-TYPE_MODIFIER_VOLATILE = 0x200000
-TYPE_MODIFIER_MUTABLE  = 0x400000
-
-TYPE_MODIFIER_MAP = {
-    'inline': TYPE_MODIFIER_INLINE,
-    'extern': TYPE_MODIFIER_EXTERN,
-    'static': TYPE_MODIFIER_STATIC,
-    'const': TYPE_MODIFIER_CONST,
-    'register': TYPE_MODIFIER_REGISTER,
-    'volatile': TYPE_MODIFIER_VOLATILE,
-    'mutable': TYPE_MODIFIER_MUTABLE,
-    }
-"""
-
-_INTERNAL_TOKEN = 'internal'
-_NAMESPACE_POP = 'ns-pop'
-
-
-# TODO(nnorwitz): use this as a singleton for templated_types, etc
-# where we don't want to create a new empty dict each time.  It is also const.
-class _NullDict(object):
-    __contains__ = lambda self: False
-    keys = values = items = iterkeys = itervalues = iteritems = lambda self: ()
-
-
-# TODO(nnorwitz): move AST nodes into a separate module.
-class Node(object):
-    """Base AST node."""
-
-    def __init__(self, start, end):
-        self.start = start
-        self.end = end
-
-    def IsDeclaration(self):
-        """Returns bool if this node is a declaration."""
-        return False
-
-    def IsDefinition(self):
-        """Returns bool if this node is a definition."""
-        return False
-
-    def IsExportable(self):
-        """Returns bool if this node exportable from a header file."""
-        return False
-
-    def Requires(self, node):
-        """Does this AST node require the definition of the node passed in?"""
-        return False
-
-    def XXX__str__(self):
-        return self._StringHelper(self.__class__.__name__, '')
-
-    def _StringHelper(self, name, suffix):
-        if not utils.DEBUG:
-            return '%s(%s)' % (name, suffix)
-        return '%s(%d, %d, %s)' % (name, self.start, self.end, suffix)
-
-    def __repr__(self):
-        return str(self)
-
-
-class Define(Node):
-    def __init__(self, start, end, name, definition):
-        Node.__init__(self, start, end)
-        self.name = name
-        self.definition = definition
-
-    def __str__(self):
-        value = '%s %s' % (self.name, self.definition)
-        return self._StringHelper(self.__class__.__name__, value)
-
-
-class Include(Node):
-    def __init__(self, start, end, filename, system):
-        Node.__init__(self, start, end)
-        self.filename = filename
-        self.system = system
-
-    def __str__(self):
-        fmt = '"%s"'
-        if self.system:
-            fmt = '<%s>'
-        return self._StringHelper(self.__class__.__name__, fmt % self.filename)
-
-
-class Goto(Node):
-    def __init__(self, start, end, label):
-        Node.__init__(self, start, end)
-        self.label = label
-
-    def __str__(self):
-        return self._StringHelper(self.__class__.__name__, str(self.label))
-
-
-class Expr(Node):
-    def __init__(self, start, end, expr):
-        Node.__init__(self, start, end)
-        self.expr = expr
-
-    def Requires(self, node):
-        # TODO(nnorwitz): impl.
-        return False
-
-    def __str__(self):
-        return self._StringHelper(self.__class__.__name__, str(self.expr))
-
-
-class Return(Expr):
-    pass
-
-
-class Delete(Expr):
-    pass
-
-
-class Friend(Expr):
-    def __init__(self, start, end, expr, namespace):
-        Expr.__init__(self, start, end, expr)
-        self.namespace = namespace[:]
-
-
-class Using(Node):
-    def __init__(self, start, end, names):
-        Node.__init__(self, start, end)
-        self.names = names
-
-    def __str__(self):
-        return self._StringHelper(self.__class__.__name__, str(self.names))
-
-
-class Parameter(Node):
-    def __init__(self, start, end, name, parameter_type, default):
-        Node.__init__(self, start, end)
-        self.name = name
-        self.type = parameter_type
-        self.default = default
-
-    def Requires(self, node):
-        # TODO(nnorwitz): handle namespaces, etc.
-        return self.type.name == node.name
-
-    def __str__(self):
-        name = str(self.type)
-        suffix = '%s %s' % (name, self.name)
-        if self.default:
-            suffix += ' = ' + ''.join([d.name for d in self.default])
-        return self._StringHelper(self.__class__.__name__, suffix)
-
-
-class _GenericDeclaration(Node):
-    def __init__(self, start, end, name, namespace):
-        Node.__init__(self, start, end)
-        self.name = name
-        self.namespace = namespace[:]
-
-    def FullName(self):
-        prefix = ''
-        if self.namespace and self.namespace[-1]:
-            prefix = '::'.join(self.namespace) + '::'
-        return prefix + self.name
-
-    def _TypeStringHelper(self, suffix):
-        if self.namespace:
-            names = [n or '<anonymous>' for n in self.namespace]
-            suffix += ' in ' + '::'.join(names)
-        return self._StringHelper(self.__class__.__name__, suffix)
-
-
-# TODO(nnorwitz): merge with Parameter in some way?
-class VariableDeclaration(_GenericDeclaration):
-    def __init__(self, start, end, name, var_type, initial_value, namespace):
-        _GenericDeclaration.__init__(self, start, end, name, namespace)
-        self.type = var_type
-        self.initial_value = initial_value
-
-    def Requires(self, node):
-        # TODO(nnorwitz): handle namespaces, etc.
-        return self.type.name == node.name
-
-    def ToString(self):
-        """Return a string that tries to reconstitute the variable decl."""
-        suffix = '%s %s' % (self.type, self.name)
-        if self.initial_value:
-            suffix += ' = ' + self.initial_value
-        return suffix
-
-    def __str__(self):
-        return self._StringHelper(self.__class__.__name__, self.ToString())
-
-
-class Typedef(_GenericDeclaration):
-    def __init__(self, start, end, name, alias, namespace):
-        _GenericDeclaration.__init__(self, start, end, name, namespace)
-        self.alias = alias
-
-    def IsDefinition(self):
-        return True
-
-    def IsExportable(self):
-        return True
-
-    def Requires(self, node):
-        # TODO(nnorwitz): handle namespaces, etc.
-        name = node.name
-        for token in self.alias:
-            if token is not None and name == token.name:
-                return True
-        return False
-
-    def __str__(self):
-        suffix = '%s, %s' % (self.name, self.alias)
-        return self._TypeStringHelper(suffix)
-
-
-class _NestedType(_GenericDeclaration):
-    def __init__(self, start, end, name, fields, namespace):
-        _GenericDeclaration.__init__(self, start, end, name, namespace)
-        self.fields = fields
-
-    def IsDefinition(self):
-        return True
-
-    def IsExportable(self):
-        return True
-
-    def __str__(self):
-        suffix = '%s, {%s}' % (self.name, self.fields)
-        return self._TypeStringHelper(suffix)
-
-
-class Union(_NestedType):
-    pass
-
-
-class Enum(_NestedType):
-    pass
-
-
-class Class(_GenericDeclaration):
-    def __init__(self, start, end, name, bases, templated_types, body, namespace):
-        _GenericDeclaration.__init__(self, start, end, name, namespace)
-        self.bases = bases
-        self.body = body
-        self.templated_types = templated_types
-
-    def IsDeclaration(self):
-        return self.bases is None and self.body is None
-
-    def IsDefinition(self):
-        return not self.IsDeclaration()
-
-    def IsExportable(self):
-        return not self.IsDeclaration()
-
-    def Requires(self, node):
-        # TODO(nnorwitz): handle namespaces, etc.
-        if self.bases:
-            for token_list in self.bases:
-                # TODO(nnorwitz): bases are tokens, do name comparision.
-                for token in token_list:
-                    if token.name == node.name:
-                        return True
-        # TODO(nnorwitz): search in body too.
-        return False
-
-    def __str__(self):
-        name = self.name
-        if self.templated_types:
-            name += '<%s>' % self.templated_types
-        suffix = '%s, %s, %s' % (name, self.bases, self.body)
-        return self._TypeStringHelper(suffix)
-
-
-class Struct(Class):
-    pass
-
-
-class Function(_GenericDeclaration):
-    def __init__(self, start, end, name, return_type, parameters,
-                 modifiers, templated_types, body, namespace):
-        _GenericDeclaration.__init__(self, start, end, name, namespace)
-        converter = TypeConverter(namespace)
-        self.return_type = converter.CreateReturnType(return_type)
-        self.parameters = converter.ToParameters(parameters)
-        self.modifiers = modifiers
-        self.body = body
-        self.templated_types = templated_types
-
-    def IsDeclaration(self):
-        return self.body is None
-
-    def IsDefinition(self):
-        return self.body is not None
-
-    def IsExportable(self):
-        if self.return_type and 'static' in self.return_type.modifiers:
-            return False
-        return None not in self.namespace
-
-    def Requires(self, node):
-        if self.parameters:
-            # TODO(nnorwitz): parameters are tokens, do name comparision.
-            for p in self.parameters:
-                if p.name == node.name:
-                    return True
-        # TODO(nnorwitz): search in body too.
-        return False
-
-    def __str__(self):
-        # TODO(nnorwitz): add templated_types.
-        suffix = ('%s %s(%s), 0x%02x, %s' %
-                  (self.return_type, self.name, self.parameters,
-                   self.modifiers, self.body))
-        return self._TypeStringHelper(suffix)
-
-
-class Method(Function):
-    def __init__(self, start, end, name, in_class, return_type, parameters,
-                 modifiers, templated_types, body, namespace):
-        Function.__init__(self, start, end, name, return_type, parameters,
-                          modifiers, templated_types, body, namespace)
-        # TODO(nnorwitz): in_class could also be a namespace which can
-        # mess up finding functions properly.
-        self.in_class = in_class
-
-
-class Type(_GenericDeclaration):
-    """Type used for any variable (eg class, primitive, struct, etc)."""
-
-    def __init__(self, start, end, name, templated_types, modifiers,
-                 reference, pointer, array):
-        """
-        Args:
-          name: str name of main type
-          templated_types: [Class (Type?)] template type info between <>
-          modifiers: [str] type modifiers (keywords) eg, const, mutable, etc.
-          reference, pointer, array: bools
-        """
-        _GenericDeclaration.__init__(self, start, end, name, [])
-        self.templated_types = templated_types
-        if not name and modifiers:
-            self.name = modifiers.pop()
-        self.modifiers = modifiers
-        self.reference = reference
-        self.pointer = pointer
-        self.array = array
-
-    def __str__(self):
-        prefix = ''
-        if self.modifiers:
-            prefix = ' '.join(self.modifiers) + ' '
-        name = str(self.name)
-        if self.templated_types:
-            name += '<%s>' % self.templated_types
-        suffix = prefix + name
-        if self.reference:
-            suffix += '&'
-        if self.pointer:
-            suffix += '*'
-        if self.array:
-            suffix += '[]'
-        return self._TypeStringHelper(suffix)
-
-    # By definition, Is* are always False.  A Type can only exist in
-    # some sort of variable declaration, parameter, or return value.
-    def IsDeclaration(self):
-        return False
-
-    def IsDefinition(self):
-        return False
-
-    def IsExportable(self):
-        return False
-
-
-class TypeConverter(object):
-
-    def __init__(self, namespace_stack):
-        self.namespace_stack = namespace_stack
-
-    def _GetTemplateEnd(self, tokens, start):
-        count = 1
-        end = start
-        while 1:
-            token = tokens[end]
-            end += 1
-            if token.name == '<':
-                count += 1
-            elif token.name == '>':
-                count -= 1
-                if count == 0:
-                    break
-        return tokens[start:end-1], end
-
-    def ToType(self, tokens):
-        """Convert [Token,...] to [Class(...), ] useful for base classes.
-        For example, code like class Foo : public Bar<x, y> { ... };
-        the "Bar<x, y>" portion gets converted to an AST.
-
-        Returns:
-          [Class(...), ...]
-        """
-        result = []
-        name_tokens = []
-        reference = pointer = array = False
-
-        def AddType(templated_types):
-            # Partition tokens into name and modifier tokens.
-            names = []
-            modifiers = []
-            for t in name_tokens:
-                if keywords.IsKeyword(t.name):
-                    modifiers.append(t.name)
-                else:
-                    names.append(t.name)
-            name = ''.join(names)
-            if name_tokens:
-                result.append(Type(name_tokens[0].start, name_tokens[-1].end,
-                                   name, templated_types, modifiers,
-                                   reference, pointer, array))
-            del name_tokens[:]
-
-        i = 0
-        end = len(tokens)
-        while i < end:
-            token = tokens[i]
-            if token.name == '<':
-                new_tokens, new_end = self._GetTemplateEnd(tokens, i+1)
-                AddType(self.ToType(new_tokens))
-                # If there is a comma after the template, we need to consume
-                # that here otherwise it becomes part of the name.
-                i = new_end
-                reference = pointer = array = False
-            elif token.name == ',':
-                AddType([])
-                reference = pointer = array = False
-            elif token.name == '*':
-                pointer = True
-            elif token.name == '&':
-                reference = True
-            elif token.name == '[':
-               pointer = True
-            elif token.name == ']':
-                pass
-            else:
-                name_tokens.append(token)
-            i += 1
-
-        if name_tokens:
-            # No '<' in the tokens, just a simple name and no template.
-            AddType([])
-        return result
-
-    def DeclarationToParts(self, parts, needs_name_removed):
-        name = None
-        default = []
-        if needs_name_removed:
-            # Handle default (initial) values properly.
-            for i, t in enumerate(parts):
-                if t.name == '=':
-                    default = parts[i+1:]
-                    name = parts[i-1].name
-                    if name == ']' and parts[i-2].name == '[':
-                        name = parts[i-3].name
-                        i -= 1
-                    parts = parts[:i-1]
-                    break
-            else:
-                if parts[-1].token_type == tokenize.NAME:
-                    name = parts.pop().name
-                else:
-                    # TODO(nnorwitz): this is a hack that happens for code like
-                    # Register(Foo<T>); where it thinks this is a function call
-                    # but it's actually a declaration.
-                    name = '???'
-        modifiers = []
-        type_name = []
-        other_tokens = []
-        templated_types = []
-        i = 0
-        end = len(parts)
-        while i < end:
-            p = parts[i]
-            if keywords.IsKeyword(p.name):
-                modifiers.append(p.name)
-            elif p.name == '<':
-                templated_tokens, new_end = self._GetTemplateEnd(parts, i+1)
-                templated_types = self.ToType(templated_tokens)
-                i = new_end - 1
-                # Don't add a spurious :: to data members being initialized.
-                next_index = i + 1
-                if next_index < end and parts[next_index].name == '::':
-                    i += 1
-            elif p.name in ('[', ']', '='):
-                # These are handled elsewhere.
-                other_tokens.append(p)
-            elif p.name not in ('*', '&', '>'):
-                # Ensure that names have a space between them.
-                if (type_name and type_name[-1].token_type == tokenize.NAME and
-                    p.token_type == tokenize.NAME):
-                    type_name.append(tokenize.Token(tokenize.SYNTAX, ' ', 0, 0))
-                type_name.append(p)
-            else:
-                other_tokens.append(p)
-            i += 1
-        type_name = ''.join([t.name for t in type_name])
-        return name, type_name, templated_types, modifiers, default, other_tokens
-
-    def ToParameters(self, tokens):
-        if not tokens:
-            return []
-
-        result = []
-        name = type_name = ''
-        type_modifiers = []
-        pointer = reference = array = False
-        first_token = None
-        default = []
-
-        def AddParameter(end):
-            if default:
-                del default[0]  # Remove flag.
-            parts = self.DeclarationToParts(type_modifiers, True)
-            (name, type_name, templated_types, modifiers,
-             unused_default, unused_other_tokens) = parts
-            parameter_type = Type(first_token.start, first_token.end,
-                                  type_name, templated_types, modifiers,
-                                  reference, pointer, array)
-            p = Parameter(first_token.start, end, name,
-                          parameter_type, default)
-            result.append(p)
-
-        template_count = 0
-        for s in tokens:
-            if not first_token:
-                first_token = s
-            if s.name == '<':
-                template_count += 1
-            elif s.name == '>':
-                template_count -= 1
-            if template_count > 0:
-                type_modifiers.append(s)
-                continue
-
-            if s.name == ',':
-                AddParameter(s.start)
-                name = type_name = ''
-                type_modifiers = []
-                pointer = reference = array = False
-                first_token = None
-                default = []
-            elif s.name == '*':
-                pointer = True
-            elif s.name == '&':
-                reference = True
-            elif s.name == '[':
-                array = True
-            elif s.name == ']':
-                pass  # Just don't add to type_modifiers.
-            elif s.name == '=':
-                # Got a default value.  Add any value (None) as a flag.
-                default.append(None)
-            elif default:
-                default.append(s)
-            else:
-                type_modifiers.append(s)
-        AddParameter(tokens[-1].end)
-        return result
-
-    def CreateReturnType(self, return_type_seq):
-        if not return_type_seq:
-            return None
-        start = return_type_seq[0].start
-        end = return_type_seq[-1].end
-        _, name, templated_types, modifiers, default, other_tokens = \
-           self.DeclarationToParts(return_type_seq, False)
-        names = [n.name for n in other_tokens]
-        reference = '&' in names
-        pointer = '*' in names
-        array = '[' in names
-        return Type(start, end, name, templated_types, modifiers,
-                    reference, pointer, array)
-
-    def GetTemplateIndices(self, names):
-        # names is a list of strings.
-        start = names.index('<')
-        end = len(names) - 1
-        while end > 0:
-            if names[end] == '>':
-                break
-            end -= 1
-        return start, end+1
-
-class AstBuilder(object):
-    def __init__(self, token_stream, filename, in_class='', visibility=None,
-                 namespace_stack=[]):
-        self.tokens = token_stream
-        self.filename = filename
-        # TODO(nnorwitz): use a better data structure (deque) for the queue.
-        # Switching directions of the "queue" improved perf by about 25%.
-        # Using a deque should be even better since we access from both sides.
-        self.token_queue = []
-        self.namespace_stack = namespace_stack[:]
-        self.in_class = in_class
-        if in_class is None:
-            self.in_class_name_only = None
-        else:
-            self.in_class_name_only = in_class.split('::')[-1]
-        self.visibility = visibility
-        self.in_function = False
-        self.current_token = None
-        # Keep the state whether we are currently handling a typedef or not.
-        self._handling_typedef = False
-
-        self.converter = TypeConverter(self.namespace_stack)
-
-    def HandleError(self, msg, token):
-        printable_queue = list(reversed(self.token_queue[-20:]))
-        sys.stderr.write('Got %s in %s @ %s %s\n' %
-                         (msg, self.filename, token, printable_queue))
-
-    def Generate(self):
-        while 1:
-            token = self._GetNextToken()
-            if not token:
-                break
-
-            # Get the next token.
-            self.current_token = token
-
-            # Dispatch on the next token type.
-            if token.token_type == _INTERNAL_TOKEN:
-                if token.name == _NAMESPACE_POP:
-                    self.namespace_stack.pop()
-                continue
-
-            try:
-                result = self._GenerateOne(token)
-                if result is not None:
-                    yield result
-            except:
-                self.HandleError('exception', token)
-                raise
-
-    def _CreateVariable(self, pos_token, name, type_name, type_modifiers,
-                        ref_pointer_name_seq, templated_types, value=None):
-        reference = '&' in ref_pointer_name_seq
-        pointer = '*' in ref_pointer_name_seq
-        array = '[' in ref_pointer_name_seq
-        var_type = Type(pos_token.start, pos_token.end, type_name,
-                        templated_types, type_modifiers,
-                        reference, pointer, array)
-        return VariableDeclaration(pos_token.start, pos_token.end,
-                                   name, var_type, value, self.namespace_stack)
-
-    def _GenerateOne(self, token):
-        if token.token_type == tokenize.NAME:
-            if (keywords.IsKeyword(token.name) and
-                not keywords.IsBuiltinType(token.name)):
-                method = getattr(self, 'handle_' + token.name)
-                return method()
-            elif token.name == self.in_class_name_only:
-                # The token name is the same as the class, must be a ctor if
-                # there is a paren.  Otherwise, it's the return type.
-                # Peek ahead to get the next token to figure out which.
-                next = self._GetNextToken()
-                self._AddBackToken(next)
-                if next.token_type == tokenize.SYNTAX and next.name == '(':
-                    return self._GetMethod([token], FUNCTION_CTOR, None, True)
-                # Fall through--handle like any other method.
-
-            # Handle data or function declaration/definition.
-            syntax = tokenize.SYNTAX
-            temp_tokens, last_token = \
-                self._GetVarTokensUpTo(syntax, '(', ';', '{', '[')
-            temp_tokens.insert(0, token)
-            if last_token.name == '(':
-                # If there is an assignment before the paren,
-                # this is an expression, not a method.
-                expr = bool([e for e in temp_tokens if e.name == '='])
-                if expr:
-                    new_temp = self._GetTokensUpTo(tokenize.SYNTAX, ';')
-                    temp_tokens.append(last_token)
-                    temp_tokens.extend(new_temp)
-                    last_token = tokenize.Token(tokenize.SYNTAX, ';', 0, 0)
-
-            if last_token.name == '[':
-                # Handle array, this isn't a method, unless it's an operator.
-                # TODO(nnorwitz): keep the size somewhere.
-                # unused_size = self._GetTokensUpTo(tokenize.SYNTAX, ']')
-                temp_tokens.append(last_token)
-                if temp_tokens[-2].name == 'operator':
-                    temp_tokens.append(self._GetNextToken())
-                else:
-                    temp_tokens2, last_token = \
-                        self._GetVarTokensUpTo(tokenize.SYNTAX, ';')
-                    temp_tokens.extend(temp_tokens2)
-
-            if last_token.name == ';':
-                # Handle data, this isn't a method.
-                parts = self.converter.DeclarationToParts(temp_tokens, True)
-                (name, type_name, templated_types, modifiers, default,
-                 unused_other_tokens) = parts
-
-                t0 = temp_tokens[0]
-                names = [t.name for t in temp_tokens]
-                if templated_types:
-                    start, end = self.converter.GetTemplateIndices(names)
-                    names = names[:start] + names[end:]
-                default = ''.join([t.name for t in default])
-                return self._CreateVariable(t0, name, type_name, modifiers,
-                                            names, templated_types, default)
-            if last_token.name == '{':
-                self._AddBackTokens(temp_tokens[1:])
-                self._AddBackToken(last_token)
-                method_name = temp_tokens[0].name
-                method = getattr(self, 'handle_' + method_name, None)
-                if not method:
-                    # Must be declaring a variable.
-                    # TODO(nnorwitz): handle the declaration.
-                    return None
-                return method()
-            return self._GetMethod(temp_tokens, 0, None, False)
-        elif token.token_type == tokenize.SYNTAX:
-            if token.name == '~' and self.in_class:
-                # Must be a dtor (probably not in method body).
-                token = self._GetNextToken()
-                # self.in_class can contain A::Name, but the dtor will only
-                # be Name.  Make sure to compare against the right value.
-                if (token.token_type == tokenize.NAME and
-                    token.name == self.in_class_name_only):
-                    return self._GetMethod([token], FUNCTION_DTOR, None, True)
-            # TODO(nnorwitz): handle a lot more syntax.
-        elif token.token_type == tokenize.PREPROCESSOR:
-            # TODO(nnorwitz): handle more preprocessor directives.
-            # token starts with a #, so remove it and strip whitespace.
-            name = token.name[1:].lstrip()
-            if name.startswith('include'):
-                # Remove "include".
-                name = name[7:].strip()
-                assert name
-                # Handle #include \<newline> "header-on-second-line.h".
-                if name.startswith('\\'):
-                    name = name[1:].strip()
-                assert name[0] in '<"', token
-                assert name[-1] in '>"', token
-                system = name[0] == '<'
-                filename = name[1:-1]
-                return Include(token.start, token.end, filename, system)
-            if name.startswith('define'):
-                # Remove "define".
-                name = name[6:].strip()
-                assert name
-                value = ''
-                for i, c in enumerate(name):
-                    if c.isspace():
-                        value = name[i:].lstrip()
-                        name = name[:i]
-                        break
-                return Define(token.start, token.end, name, value)
-            if name.startswith('if') and name[2:3].isspace():
-                condition = name[3:].strip()
-                if condition.startswith('0') or condition.startswith('(0)'):
-                    self._SkipIf0Blocks()
-        return None
-
-    def _GetTokensUpTo(self, expected_token_type, expected_token):
-        return self._GetVarTokensUpTo(expected_token_type, expected_token)[0]
-
-    def _GetVarTokensUpTo(self, expected_token_type, *expected_tokens):
-        last_token = self._GetNextToken()
-        tokens = []
-        while (last_token.token_type != expected_token_type or
-               last_token.name not in expected_tokens):
-            tokens.append(last_token)
-            last_token = self._GetNextToken()
-        return tokens, last_token
-
-    # TODO(nnorwitz): remove _IgnoreUpTo() it shouldn't be necesary.
-    def _IgnoreUpTo(self, token_type, token):
-        unused_tokens = self._GetTokensUpTo(token_type, token)
-
-    def _SkipIf0Blocks(self):
-        count = 1
-        while 1:
-            token = self._GetNextToken()
-            if token.token_type != tokenize.PREPROCESSOR:
-                continue
-
-            name = token.name[1:].lstrip()
-            if name.startswith('endif'):
-                count -= 1
-                if count == 0:
-                    break
-            elif name.startswith('if'):
-                count += 1
-
-    def _GetMatchingChar(self, open_paren, close_paren, GetNextToken=None):
-        if GetNextToken is None:
-            GetNextToken = self._GetNextToken
-        # Assumes the current token is open_paren and we will consume
-        # and return up to the close_paren.
-        count = 1
-        token = GetNextToken()
-        while 1:
-            if token.token_type == tokenize.SYNTAX:
-                if token.name == open_paren:
-                    count += 1
-                elif token.name == close_paren:
-                    count -= 1
-                    if count == 0:
-                        break
-            yield token
-            token = GetNextToken()
-        yield token
-
-    def _GetParameters(self):
-        return self._GetMatchingChar('(', ')')
-
-    def GetScope(self):
-        return self._GetMatchingChar('{', '}')
-
-    def _GetNextToken(self):
-        if self.token_queue:
-            return self.token_queue.pop()
-        return next(self.tokens)
-
-    def _AddBackToken(self, token):
-        if token.whence == tokenize.WHENCE_STREAM:
-            token.whence = tokenize.WHENCE_QUEUE
-            self.token_queue.insert(0, token)
-        else:
-            assert token.whence == tokenize.WHENCE_QUEUE, token
-            self.token_queue.append(token)
-
-    def _AddBackTokens(self, tokens):
-        if tokens:
-            if tokens[-1].whence == tokenize.WHENCE_STREAM:
-                for token in tokens:
-                    token.whence = tokenize.WHENCE_QUEUE
-                self.token_queue[:0] = reversed(tokens)
-            else:
-                assert tokens[-1].whence == tokenize.WHENCE_QUEUE, tokens
-                self.token_queue.extend(reversed(tokens))
-
-    def GetName(self, seq=None):
-        """Returns ([tokens], next_token_info)."""
-        GetNextToken = self._GetNextToken
-        if seq is not None:
-            it = iter(seq)
-            GetNextToken = lambda: next(it)
-        next_token = GetNextToken()
-        tokens = []
-        last_token_was_name = False
-        while (next_token.token_type == tokenize.NAME or
-               (next_token.token_type == tokenize.SYNTAX and
-                next_token.name in ('::', '<'))):
-            # Two NAMEs in a row means the identifier should terminate.
-            # It's probably some sort of variable declaration.
-            if last_token_was_name and next_token.token_type == tokenize.NAME:
-                break
-            last_token_was_name = next_token.token_type == tokenize.NAME
-            tokens.append(next_token)
-            # Handle templated names.
-            if next_token.name == '<':
-                tokens.extend(self._GetMatchingChar('<', '>', GetNextToken))
-                last_token_was_name = True
-            next_token = GetNextToken()
-        return tokens, next_token
-
-    def GetMethod(self, modifiers, templated_types):
-        return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(')
-        assert len(return_type_and_name) >= 1
-        return self._GetMethod(return_type_and_name, modifiers, templated_types,
-                               False)
-
-    def _GetMethod(self, return_type_and_name, modifiers, templated_types,
-                   get_paren):
-        template_portion = None
-        if get_paren:
-            token = self._GetNextToken()
-            assert token.token_type == tokenize.SYNTAX, token
-            if token.name == '<':
-                # Handle templatized dtors.
-                template_portion = [token]
-                template_portion.extend(self._GetMatchingChar('<', '>'))
-                token = self._GetNextToken()
-            assert token.token_type == tokenize.SYNTAX, token
-            assert token.name == '(', token
-
-        name = return_type_and_name.pop()
-        # Handle templatized ctors.
-        if name.name == '>':
-            index = 1
-            while return_type_and_name[index].name != '<':
-                index += 1
-            template_portion = return_type_and_name[index:] + [name]
-            del return_type_and_name[index:]
-            name = return_type_and_name.pop()
-        elif name.name == ']':
-            rt = return_type_and_name
-            assert rt[-1].name == '[', return_type_and_name
-            assert rt[-2].name == 'operator', return_type_and_name
-            name_seq = return_type_and_name[-2:]
-            del return_type_and_name[-2:]
-            name = tokenize.Token(tokenize.NAME, 'operator[]',
-                                  name_seq[0].start, name.end)
-            # Get the open paren so _GetParameters() below works.
-            unused_open_paren = self._GetNextToken()
-
-        # TODO(nnorwitz): store template_portion.
-        return_type = return_type_and_name
-        indices = name
-        if return_type:
-            indices = return_type[0]
-
-        # Force ctor for templatized ctors.
-        if name.name == self.in_class and not modifiers:
-            modifiers |= FUNCTION_CTOR
-        parameters = list(self._GetParameters())
-        del parameters[-1]              # Remove trailing ')'.
-
-        # Handling operator() is especially weird.
-        if name.name == 'operator' and not parameters:
-            token = self._GetNextToken()
-            assert token.name == '(', token
-            parameters = list(self._GetParameters())
-            del parameters[-1]          # Remove trailing ')'.
-
-        token = self._GetNextToken()
-        while token.token_type == tokenize.NAME:
-            modifier_token = token
-            token = self._GetNextToken()
-            if modifier_token.name == 'const':
-                modifiers |= FUNCTION_CONST
-            elif modifier_token.name == '__attribute__':
-                # TODO(nnorwitz): handle more __attribute__ details.
-                modifiers |= FUNCTION_ATTRIBUTE
-                assert token.name == '(', token
-                # Consume everything between the (parens).
-                unused_tokens = list(self._GetMatchingChar('(', ')'))
-                token = self._GetNextToken()
-            elif modifier_token.name == 'throw':
-                modifiers |= FUNCTION_THROW
-                assert token.name == '(', token
-                # Consume everything between the (parens).
-                unused_tokens = list(self._GetMatchingChar('(', ')'))
-                token = self._GetNextToken()
-            elif modifier_token.name == 'override':
-                modifiers |= FUNCTION_OVERRIDE
-            elif modifier_token.name == modifier_token.name.upper():
-                # HACK(nnorwitz):  assume that all upper-case names
-                # are some macro we aren't expanding.
-                modifiers |= FUNCTION_UNKNOWN_ANNOTATION
-            else:
-                self.HandleError('unexpected token', modifier_token)
-
-        assert token.token_type == tokenize.SYNTAX, token
-        # Handle ctor initializers.
-        if token.name == ':':
-            # TODO(nnorwitz): anything else to handle for initializer list?
-            while token.name != ';' and token.name != '{':
-                token = self._GetNextToken()
-
-        # Handle pointer to functions that are really data but look
-        # like method declarations.
-        if token.name == '(':
-            if parameters[0].name == '*':
-                # name contains the return type.
-                name = parameters.pop()
-                # parameters contains the name of the data.
-                modifiers = [p.name for p in parameters]
-                # Already at the ( to open the parameter list.
-                function_parameters = list(self._GetMatchingChar('(', ')'))
-                del function_parameters[-1]  # Remove trailing ')'.
-                # TODO(nnorwitz): store the function_parameters.
-                token = self._GetNextToken()
-                assert token.token_type == tokenize.SYNTAX, token
-                assert token.name == ';', token
-                return self._CreateVariable(indices, name.name, indices.name,
-                                            modifiers, '', None)
-            # At this point, we got something like:
-            #  return_type (type::*name_)(params);
-            # This is a data member called name_ that is a function pointer.
-            # With this code: void (sq_type::*field_)(string&);
-            # We get: name=void return_type=[] parameters=sq_type ... field_
-            # TODO(nnorwitz): is return_type always empty?
-            # TODO(nnorwitz): this isn't even close to being correct.
-            # Just put in something so we don't crash and can move on.
-            real_name = parameters[-1]
-            modifiers = [p.name for p in self._GetParameters()]
-            del modifiers[-1]           # Remove trailing ')'.
-            return self._CreateVariable(indices, real_name.name, indices.name,
-                                        modifiers, '', None)
-
-        if token.name == '{':
-            body = list(self.GetScope())
-            del body[-1]                # Remove trailing '}'.
-        else:
-            body = None
-            if token.name == '=':
-                token = self._GetNextToken()
-
-                if token.name == 'default' or token.name == 'delete':
-                    # Ignore explicitly defaulted and deleted special members
-                    # in C++11.
-                    token = self._GetNextToken()
-                else:
-                    # Handle pure-virtual declarations.
-                    assert token.token_type == tokenize.CONSTANT, token
-                    assert token.name == '0', token
-                    modifiers |= FUNCTION_PURE_VIRTUAL
-                    token = self._GetNextToken()
-
-            if token.name == '[':
-                # TODO(nnorwitz): store tokens and improve parsing.
-                # template <typename T, size_t N> char (&ASH(T (&seq)[N]))[N];
-                tokens = list(self._GetMatchingChar('[', ']'))
-                token = self._GetNextToken()
-
-            assert token.name == ';', (token, return_type_and_name, parameters)
-
-        # Looks like we got a method, not a function.
-        if len(return_type) > 2 and return_type[-1].name == '::':
-            return_type, in_class = \
-                         self._GetReturnTypeAndClassName(return_type)
-            return Method(indices.start, indices.end, name.name, in_class,
-                          return_type, parameters, modifiers, templated_types,
-                          body, self.namespace_stack)
-        return Function(indices.start, indices.end, name.name, return_type,
-                        parameters, modifiers, templated_types, body,
-                        self.namespace_stack)
-
-    def _GetReturnTypeAndClassName(self, token_seq):
-        # Splitting the return type from the class name in a method
-        # can be tricky.  For example, Return::Type::Is::Hard::To::Find().
-        # Where is the return type and where is the class name?
-        # The heuristic used is to pull the last name as the class name.
-        # This includes all the templated type info.
-        # TODO(nnorwitz): if there is only One name like in the
-        # example above, punt and assume the last bit is the class name.
-
-        # Ignore a :: prefix, if exists so we can find the first real name.
-        i = 0
-        if token_seq[0].name == '::':
-            i = 1
-        # Ignore a :: suffix, if exists.
-        end = len(token_seq) - 1
-        if token_seq[end-1].name == '::':
-            end -= 1
-
-        # Make a copy of the sequence so we can append a sentinel
-        # value. This is required for GetName will has to have some
-        # terminating condition beyond the last name.
-        seq_copy = token_seq[i:end]
-        seq_copy.append(tokenize.Token(tokenize.SYNTAX, '', 0, 0))
-        names = []
-        while i < end:
-            # Iterate through the sequence parsing out each name.
-            new_name, next = self.GetName(seq_copy[i:])
-            assert new_name, 'Got empty new_name, next=%s' % next
-            # We got a pointer or ref.  Add it to the name.
-            if next and next.token_type == tokenize.SYNTAX:
-                new_name.append(next)
-            names.append(new_name)
-            i += len(new_name)
-
-        # Now that we have the names, it's time to undo what we did.
-
-        # Remove the sentinel value.
-        names[-1].pop()
-        # Flatten the token sequence for the return type.
-        return_type = [e for seq in names[:-1] for e in seq]
-        # The class name is the last name.
-        class_name = names[-1]
-        return return_type, class_name
-
-    def handle_bool(self):
-        pass
-
-    def handle_char(self):
-        pass
-
-    def handle_int(self):
-        pass
-
-    def handle_long(self):
-        pass
-
-    def handle_short(self):
-        pass
-
-    def handle_double(self):
-        pass
-
-    def handle_float(self):
-        pass
-
-    def handle_void(self):
-        pass
-
-    def handle_wchar_t(self):
-        pass
-
-    def handle_unsigned(self):
-        pass
-
-    def handle_signed(self):
-        pass
-
-    def _GetNestedType(self, ctor):
-        name = None
-        name_tokens, token = self.GetName()
-        if name_tokens:
-            name = ''.join([t.name for t in name_tokens])
-
-        # Handle forward declarations.
-        if token.token_type == tokenize.SYNTAX and token.name == ';':
-            return ctor(token.start, token.end, name, None,
-                        self.namespace_stack)
-
-        if token.token_type == tokenize.NAME and self._handling_typedef:
-            self._AddBackToken(token)
-            return ctor(token.start, token.end, name, None,
-                        self.namespace_stack)
-
-        # Must be the type declaration.
-        fields = list(self._GetMatchingChar('{', '}'))
-        del fields[-1]                  # Remove trailing '}'.
-        if token.token_type == tokenize.SYNTAX and token.name == '{':
-            next = self._GetNextToken()
-            new_type = ctor(token.start, token.end, name, fields,
-                            self.namespace_stack)
-            # A name means this is an anonymous type and the name
-            # is the variable declaration.
-            if next.token_type != tokenize.NAME:
-                return new_type
-            name = new_type
-            token = next
-
-        # Must be variable declaration using the type prefixed with keyword.
-        assert token.token_type == tokenize.NAME, token
-        return self._CreateVariable(token, token.name, name, [], '', None)
-
-    def handle_struct(self):
-        # Special case the handling typedef/aliasing of structs here.
-        # It would be a pain to handle in the class code.
-        name_tokens, var_token = self.GetName()
-        if name_tokens:
-            next_token = self._GetNextToken()
-            is_syntax = (var_token.token_type == tokenize.SYNTAX and
-                         var_token.name[0] in '*&')
-            is_variable = (var_token.token_type == tokenize.NAME and
-                           next_token.name == ';')
-            variable = var_token
-            if is_syntax and not is_variable:
-                variable = next_token
-                temp = self._GetNextToken()
-                if temp.token_type == tokenize.SYNTAX and temp.name == '(':
-                    # Handle methods declared to return a struct.
-                    t0 = name_tokens[0]
-                    struct = tokenize.Token(tokenize.NAME, 'struct',
-                                            t0.start-7, t0.start-2)
-                    type_and_name = [struct]
-                    type_and_name.extend(name_tokens)
-                    type_and_name.extend((var_token, next_token))
-                    return self._GetMethod(type_and_name, 0, None, False)
-                assert temp.name == ';', (temp, name_tokens, var_token)
-            if is_syntax or (is_variable and not self._handling_typedef):
-                modifiers = ['struct']
-                type_name = ''.join([t.name for t in name_tokens])
-                position = name_tokens[0]
-                return self._CreateVariable(position, variable.name, type_name,
-                                            modifiers, var_token.name, None)
-            name_tokens.extend((var_token, next_token))
-            self._AddBackTokens(name_tokens)
-        else:
-            self._AddBackToken(var_token)
-        return self._GetClass(Struct, VISIBILITY_PUBLIC, None)
-
-    def handle_union(self):
-        return self._GetNestedType(Union)
-
-    def handle_enum(self):
-        return self._GetNestedType(Enum)
-
-    def handle_auto(self):
-        # TODO(nnorwitz): warn about using auto?  Probably not since it
-        # will be reclaimed and useful for C++0x.
-        pass
-
-    def handle_register(self):
-        pass
-
-    def handle_const(self):
-        pass
-
-    def handle_inline(self):
-        pass
-
-    def handle_extern(self):
-        pass
-
-    def handle_static(self):
-        pass
-
-    def handle_virtual(self):
-        # What follows must be a method.
-        token = token2 = self._GetNextToken()
-        if token.name == 'inline':
-            # HACK(nnorwitz): handle inline dtors by ignoring 'inline'.
-            token2 = self._GetNextToken()
-        if token2.token_type == tokenize.SYNTAX and token2.name == '~':
-            return self.GetMethod(FUNCTION_VIRTUAL + FUNCTION_DTOR, None)
-        assert token.token_type == tokenize.NAME or token.name == '::', token
-        return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(')  # )
-        return_type_and_name.insert(0, token)
-        if token2 is not token:
-            return_type_and_name.insert(1, token2)
-        return self._GetMethod(return_type_and_name, FUNCTION_VIRTUAL,
-                               None, False)
-
-    def handle_volatile(self):
-        pass
-
-    def handle_mutable(self):
-        pass
-
-    def handle_public(self):
-        assert self.in_class
-        self.visibility = VISIBILITY_PUBLIC
-
-    def handle_protected(self):
-        assert self.in_class
-        self.visibility = VISIBILITY_PROTECTED
-
-    def handle_private(self):
-        assert self.in_class
-        self.visibility = VISIBILITY_PRIVATE
-
-    def handle_friend(self):
-        tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
-        assert tokens
-        t0 = tokens[0]
-        return Friend(t0.start, t0.end, tokens, self.namespace_stack)
-
-    def handle_static_cast(self):
-        pass
-
-    def handle_const_cast(self):
-        pass
-
-    def handle_dynamic_cast(self):
-        pass
-
-    def handle_reinterpret_cast(self):
-        pass
-
-    def handle_new(self):
-        pass
-
-    def handle_delete(self):
-        tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
-        assert tokens
-        return Delete(tokens[0].start, tokens[0].end, tokens)
-
-    def handle_typedef(self):
-        token = self._GetNextToken()
-        if (token.token_type == tokenize.NAME and
-            keywords.IsKeyword(token.name)):
-            # Token must be struct/enum/union/class.
-            method = getattr(self, 'handle_' + token.name)
-            self._handling_typedef = True
-            tokens = [method()]
-            self._handling_typedef = False
-        else:
-            tokens = [token]
-
-        # Get the remainder of the typedef up to the semi-colon.
-        tokens.extend(self._GetTokensUpTo(tokenize.SYNTAX, ';'))
-
-        # TODO(nnorwitz): clean all this up.
-        assert tokens
-        name = tokens.pop()
-        indices = name
-        if tokens:
-            indices = tokens[0]
-        if not indices:
-            indices = token
-        if name.name == ')':
-            # HACK(nnorwitz): Handle pointers to functions "properly".
-            if (len(tokens) >= 4 and
-                tokens[1].name == '(' and tokens[2].name == '*'):
-                tokens.append(name)
-                name = tokens[3]
-        elif name.name == ']':
-            # HACK(nnorwitz): Handle arrays properly.
-            if len(tokens) >= 2:
-                tokens.append(name)
-                name = tokens[1]
-        new_type = tokens
-        if tokens and isinstance(tokens[0], tokenize.Token):
-            new_type = self.converter.ToType(tokens)[0]
-        return Typedef(indices.start, indices.end, name.name,
-                       new_type, self.namespace_stack)
-
-    def handle_typeid(self):
-        pass  # Not needed yet.
-
-    def handle_typename(self):
-        pass  # Not needed yet.
-
-    def _GetTemplatedTypes(self):
-        result = {}
-        tokens = list(self._GetMatchingChar('<', '>'))
-        len_tokens = len(tokens) - 1    # Ignore trailing '>'.
-        i = 0
-        while i < len_tokens:
-            key = tokens[i].name
-            i += 1
-            if keywords.IsKeyword(key) or key == ',':
-                continue
-            type_name = default = None
-            if i < len_tokens:
-                i += 1
-                if tokens[i-1].name == '=':
-                    assert i < len_tokens, '%s %s' % (i, tokens)
-                    default, unused_next_token = self.GetName(tokens[i:])
-                    i += len(default)
-                else:
-                    if tokens[i-1].name != ',':
-                        # We got something like: Type variable.
-                        # Re-adjust the key (variable) and type_name (Type).
-                        key = tokens[i-1].name
-                        type_name = tokens[i-2]
-
-            result[key] = (type_name, default)
-        return result
-
-    def handle_template(self):
-        token = self._GetNextToken()
-        assert token.token_type == tokenize.SYNTAX, token
-        assert token.name == '<', token
-        templated_types = self._GetTemplatedTypes()
-        # TODO(nnorwitz): for now, just ignore the template params.
-        token = self._GetNextToken()
-        if token.token_type == tokenize.NAME:
-            if token.name == 'class':
-                return self._GetClass(Class, VISIBILITY_PRIVATE, templated_types)
-            elif token.name == 'struct':
-                return self._GetClass(Struct, VISIBILITY_PUBLIC, templated_types)
-            elif token.name == 'friend':
-                return self.handle_friend()
-        self._AddBackToken(token)
-        tokens, last = self._GetVarTokensUpTo(tokenize.SYNTAX, '(', ';')
-        tokens.append(last)
-        self._AddBackTokens(tokens)
-        if last.name == '(':
-            return self.GetMethod(FUNCTION_NONE, templated_types)
-        # Must be a variable definition.
-        return None
-
-    def handle_true(self):
-        pass  # Nothing to do.
-
-    def handle_false(self):
-        pass  # Nothing to do.
-
-    def handle_asm(self):
-        pass  # Not needed yet.
-
-    def handle_class(self):
-        return self._GetClass(Class, VISIBILITY_PRIVATE, None)
-
-    def _GetBases(self):
-        # Get base classes.
-        bases = []
-        while 1:
-            token = self._GetNextToken()
-            assert token.token_type == tokenize.NAME, token
-            # TODO(nnorwitz): store kind of inheritance...maybe.
-            if token.name not in ('public', 'protected', 'private'):
-                # If inheritance type is not specified, it is private.
-                # Just put the token back so we can form a name.
-                # TODO(nnorwitz): it would be good to warn about this.
-                self._AddBackToken(token)
-            else:
-                # Check for virtual inheritance.
-                token = self._GetNextToken()
-                if token.name != 'virtual':
-                    self._AddBackToken(token)
-                else:
-                    # TODO(nnorwitz): store that we got virtual for this base.
-                    pass
-            base, next_token = self.GetName()
-            bases_ast = self.converter.ToType(base)
-            assert len(bases_ast) == 1, bases_ast
-            bases.append(bases_ast[0])
-            assert next_token.token_type == tokenize.SYNTAX, next_token
-            if next_token.name == '{':
-                token = next_token
-                break
-            # Support multiple inheritance.
-            assert next_token.name == ',', next_token
-        return bases, token
-
-    def _GetClass(self, class_type, visibility, templated_types):
-        class_name = None
-        class_token = self._GetNextToken()
-        if class_token.token_type != tokenize.NAME:
-            assert class_token.token_type == tokenize.SYNTAX, class_token
-            token = class_token
-        else:
-            # Skip any macro (e.g. storage class specifiers) after the
-            # 'class' keyword.
-            next_token = self._GetNextToken()
-            if next_token.token_type == tokenize.NAME:
-                self._AddBackToken(next_token)
-            else:
-                self._AddBackTokens([class_token, next_token])
-            name_tokens, token = self.GetName()
-            class_name = ''.join([t.name for t in name_tokens])
-        bases = None
-        if token.token_type == tokenize.SYNTAX:
-            if token.name == ';':
-                # Forward declaration.
-                return class_type(class_token.start, class_token.end,
-                                  class_name, None, templated_types, None,
-                                  self.namespace_stack)
-            if token.name in '*&':
-                # Inline forward declaration.  Could be method or data.
-                name_token = self._GetNextToken()
-                next_token = self._GetNextToken()
-                if next_token.name == ';':
-                    # Handle data
-                    modifiers = ['class']
-                    return self._CreateVariable(class_token, name_token.name,
-                                                class_name,
-                                                modifiers, token.name, None)
-                else:
-                    # Assume this is a method.
-                    tokens = (class_token, token, name_token, next_token)
-                    self._AddBackTokens(tokens)
-                    return self.GetMethod(FUNCTION_NONE, None)
-            if token.name == ':':
-                bases, token = self._GetBases()
-
-        body = None
-        if token.token_type == tokenize.SYNTAX and token.name == '{':
-            assert token.token_type == tokenize.SYNTAX, token
-            assert token.name == '{', token
-
-            ast = AstBuilder(self.GetScope(), self.filename, class_name,
-                             visibility, self.namespace_stack)
-            body = list(ast.Generate())
-
-            if not self._handling_typedef:
-                token = self._GetNextToken()
-                if token.token_type != tokenize.NAME:
-                    assert token.token_type == tokenize.SYNTAX, token
-                    assert token.name == ';', token
-                else:
-                    new_class = class_type(class_token.start, class_token.end,
-                                           class_name, bases, None,
-                                           body, self.namespace_stack)
-
-                    modifiers = []
-                    return self._CreateVariable(class_token,
-                                                token.name, new_class,
-                                                modifiers, token.name, None)
-        else:
-            if not self._handling_typedef:
-                self.HandleError('non-typedef token', token)
-            self._AddBackToken(token)
-
-        return class_type(class_token.start, class_token.end, class_name,
-                          bases, templated_types, body, self.namespace_stack)
-
-    def handle_namespace(self):
-        token = self._GetNextToken()
-        # Support anonymous namespaces.
-        name = None
-        if token.token_type == tokenize.NAME:
-            name = token.name
-            token = self._GetNextToken()
-        self.namespace_stack.append(name)
-        assert token.token_type == tokenize.SYNTAX, token
-        # Create an internal token that denotes when the namespace is complete.
-        internal_token = tokenize.Token(_INTERNAL_TOKEN, _NAMESPACE_POP,
-                                        None, None)
-        internal_token.whence = token.whence
-        if token.name == '=':
-            # TODO(nnorwitz): handle aliasing namespaces.
-            name, next_token = self.GetName()
-            assert next_token.name == ';', next_token
-            self._AddBackToken(internal_token)
-        else:
-            assert token.name == '{', token
-            tokens = list(self.GetScope())
-            # Replace the trailing } with the internal namespace pop token.
-            tokens[-1] = internal_token
-            # Handle namespace with nothing in it.
-            self._AddBackTokens(tokens)
-        return None
-
-    def handle_using(self):
-        tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
-        assert tokens
-        return Using(tokens[0].start, tokens[0].end, tokens)
-
-    def handle_explicit(self):
-        assert self.in_class
-        # Nothing much to do.
-        # TODO(nnorwitz): maybe verify the method name == class name.
-        # This must be a ctor.
-        return self.GetMethod(FUNCTION_CTOR, None)
-
-    def handle_this(self):
-        pass  # Nothing to do.
-
-    def handle_operator(self):
-        # Pull off the next token(s?) and make that part of the method name.
-        pass
-
-    def handle_sizeof(self):
-        pass
-
-    def handle_case(self):
-        pass
-
-    def handle_switch(self):
-        pass
-
-    def handle_default(self):
-        token = self._GetNextToken()
-        assert token.token_type == tokenize.SYNTAX
-        assert token.name == ':'
-
-    def handle_if(self):
-        pass
-
-    def handle_else(self):
-        pass
-
-    def handle_return(self):
-        tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
-        if not tokens:
-            return Return(self.current_token.start, self.current_token.end, None)
-        return Return(tokens[0].start, tokens[0].end, tokens)
-
-    def handle_goto(self):
-        tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
-        assert len(tokens) == 1, str(tokens)
-        return Goto(tokens[0].start, tokens[0].end, tokens[0].name)
-
-    def handle_try(self):
-        pass  # Not needed yet.
-
-    def handle_catch(self):
-        pass  # Not needed yet.
-
-    def handle_throw(self):
-        pass  # Not needed yet.
-
-    def handle_while(self):
-        pass
-
-    def handle_do(self):
-        pass
-
-    def handle_for(self):
-        pass
-
-    def handle_break(self):
-        self._IgnoreUpTo(tokenize.SYNTAX, ';')
-
-    def handle_continue(self):
-        self._IgnoreUpTo(tokenize.SYNTAX, ';')
-
-
-def BuilderFromSource(source, filename):
-    """Utility method that returns an AstBuilder from source code.
-
-    Args:
-      source: 'C++ source code'
-      filename: 'file1'
-
-    Returns:
-      AstBuilder
-    """
-    return AstBuilder(tokenize.GetTokens(source), filename)
-
-
-def PrintIndentifiers(filename, should_print):
-    """Prints all identifiers for a C++ source file.
-
-    Args:
-      filename: 'file1'
-      should_print: predicate with signature: bool Function(token)
-    """
-    source = utils.ReadFile(filename, False)
-    if source is None:
-        sys.stderr.write('Unable to find: %s\n' % filename)
-        return
-
-    #print('Processing %s' % actual_filename)
-    builder = BuilderFromSource(source, filename)
-    try:
-        for node in builder.Generate():
-            if should_print(node):
-                print(node.name)
-    except KeyboardInterrupt:
-        return
-    except:
-        pass
-
-
-def PrintAllIndentifiers(filenames, should_print):
-    """Prints all identifiers for each C++ source file in filenames.
-
-    Args:
-      filenames: ['file1', 'file2', ...]
-      should_print: predicate with signature: bool Function(token)
-    """
-    for path in filenames:
-        PrintIndentifiers(path, should_print)
-
-
-def main(argv):
-    for filename in argv[1:]:
-        source = utils.ReadFile(filename)
-        if source is None:
-            continue
-
-        print('Processing %s' % filename)
-        builder = BuilderFromSource(source, filename)
-        try:
-            entire_ast = filter(None, builder.Generate())
-        except KeyboardInterrupt:
-            return
-        except:
-            # Already printed a warning, print the traceback and continue.
-            traceback.print_exc()
-        else:
-            if utils.DEBUG:
-                for ast in entire_ast:
-                    print(ast)
-
-
-if __name__ == '__main__':
-    main(sys.argv)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class.py
deleted file mode 100755
index f9966cbb..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class.py
+++ /dev/null
@@ -1,227 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2008 Google Inc.  All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Generate Google Mock classes from base classes.
-
-This program will read in a C++ source file and output the Google Mock
-classes for the specified classes.  If no class is specified, all
-classes in the source file are emitted.
-
-Usage:
-  gmock_class.py header-file.h [ClassName]...
-
-Output is sent to stdout.
-"""
-
-__author__ = 'nnorwitz@google.com (Neal Norwitz)'
-
-
-import os
-import re
-import sys
-
-from cpp import ast
-from cpp import utils
-
-# Preserve compatibility with Python 2.3.
-try:
-  _dummy = set
-except NameError:
-  import sets
-  set = sets.Set
-
-_VERSION = (1, 0, 1)  # The version of this script.
-# How many spaces to indent.  Can set me with the INDENT environment variable.
-_INDENT = 2
-
-
-def _GenerateMethods(output_lines, source, class_node):
-  function_type = (ast.FUNCTION_VIRTUAL | ast.FUNCTION_PURE_VIRTUAL |
-                   ast.FUNCTION_OVERRIDE)
-  ctor_or_dtor = ast.FUNCTION_CTOR | ast.FUNCTION_DTOR
-  indent = ' ' * _INDENT
-
-  for node in class_node.body:
-    # We only care about virtual functions.
-    if (isinstance(node, ast.Function) and
-        node.modifiers & function_type and
-        not node.modifiers & ctor_or_dtor):
-      # Pick out all the elements we need from the original function.
-      const = ''
-      if node.modifiers & ast.FUNCTION_CONST:
-        const = 'CONST_'
-      return_type = 'void'
-      if node.return_type:
-        # Add modifiers like 'const'.
-        modifiers = ''
-        if node.return_type.modifiers:
-          modifiers = ' '.join(node.return_type.modifiers) + ' '
-        return_type = modifiers + node.return_type.name
-        template_args = [arg.name for arg in node.return_type.templated_types]
-        if template_args:
-          return_type += '<' + ', '.join(template_args) + '>'
-          if len(template_args) > 1:
-            for line in [
-                '// The following line won\'t really compile, as the return',
-                '// type has multiple template arguments.  To fix it, use a',
-                '// typedef for the return type.']:
-              output_lines.append(indent + line)
-        if node.return_type.pointer:
-          return_type += '*'
-        if node.return_type.reference:
-          return_type += '&'
-        num_parameters = len(node.parameters)
-        if len(node.parameters) == 1:
-          first_param = node.parameters[0]
-          if source[first_param.start:first_param.end].strip() == 'void':
-            # We must treat T(void) as a function with no parameters.
-            num_parameters = 0
-      tmpl = ''
-      if class_node.templated_types:
-        tmpl = '_T'
-      mock_method_macro = 'MOCK_%sMETHOD%d%s' % (const, num_parameters, tmpl)
-
-      args = ''
-      if node.parameters:
-        # Due to the parser limitations, it is impossible to keep comments
-        # while stripping the default parameters.  When defaults are
-        # present, we choose to strip them and comments (and produce
-        # compilable code).
-        # TODO(nnorwitz@google.com): Investigate whether it is possible to
-        # preserve parameter name when reconstructing parameter text from
-        # the AST.
-        if len([param for param in node.parameters if param.default]) > 0:
-          args = ', '.join(param.type.name for param in node.parameters)
-        else:
-          # Get the full text of the parameters from the start
-          # of the first parameter to the end of the last parameter.
-          start = node.parameters[0].start
-          end = node.parameters[-1].end
-          # Remove // comments.
-          args_strings = re.sub(r'//.*', '', source[start:end])
-          # Condense multiple spaces and eliminate newlines putting the
-          # parameters together on a single line.  Ensure there is a
-          # space in an argument which is split by a newline without
-          # intervening whitespace, e.g.: int\nBar
-          args = re.sub('  +', ' ', args_strings.replace('\n', ' '))
-
-      # Create the mock method definition.
-      output_lines.extend(['%s%s(%s,' % (indent, mock_method_macro, node.name),
-                           '%s%s(%s));' % (indent*3, return_type, args)])
-
-
-def _GenerateMocks(filename, source, ast_list, desired_class_names):
-  processed_class_names = set()
-  lines = []
-  for node in ast_list:
-    if (isinstance(node, ast.Class) and node.body and
-        # desired_class_names being None means that all classes are selected.
-        (not desired_class_names or node.name in desired_class_names)):
-      class_name = node.name
-      parent_name = class_name
-      processed_class_names.add(class_name)
-      class_node = node
-      # Add namespace before the class.
-      if class_node.namespace:
-        lines.extend(['namespace %s {' % n for n in class_node.namespace])  # }
-        lines.append('')
-
-      # Add template args for templated classes.
-      if class_node.templated_types:
-        # TODO(paulchang): The AST doesn't preserve template argument order,
-        # so we have to make up names here.
-        # TODO(paulchang): Handle non-type template arguments (e.g.
-        # template<typename T, int N>).
-        template_arg_count = len(class_node.templated_types.keys())
-        template_args = ['T%d' % n for n in range(template_arg_count)]
-        template_decls = ['typename ' + arg for arg in template_args]
-        lines.append('template <' + ', '.join(template_decls) + '>')
-        parent_name += '<' + ', '.join(template_args) + '>'
-
-      # Add the class prolog.
-      lines.append('class Mock%s : public %s {'  # }
-                   % (class_name, parent_name))
-      lines.append('%spublic:' % (' ' * (_INDENT // 2)))
-
-      # Add all the methods.
-      _GenerateMethods(lines, source, class_node)
-
-      # Close the class.
-      if lines:
-        # If there are no virtual methods, no need for a public label.
-        if len(lines) == 2:
-          del lines[-1]
-
-        # Only close the class if there really is a class.
-        lines.append('};')
-        lines.append('')  # Add an extra newline.
-
-      # Close the namespace.
-      if class_node.namespace:
-        for i in range(len(class_node.namespace)-1, -1, -1):
-          lines.append('}  // namespace %s' % class_node.namespace[i])
-        lines.append('')  # Add an extra newline.
-
-  if desired_class_names:
-    missing_class_name_list = list(desired_class_names - processed_class_names)
-    if missing_class_name_list:
-      missing_class_name_list.sort()
-      sys.stderr.write('Class(es) not found in %s: %s\n' %
-                       (filename, ', '.join(missing_class_name_list)))
-  elif not processed_class_names:
-    sys.stderr.write('No class found in %s\n' % filename)
-
-  return lines
-
-
-def main(argv=sys.argv):
-  if len(argv) < 2:
-    sys.stderr.write('Google Mock Class Generator v%s\n\n' %
-                     '.'.join(map(str, _VERSION)))
-    sys.stderr.write(__doc__)
-    return 1
-
-  global _INDENT
-  try:
-    _INDENT = int(os.environ['INDENT'])
-  except KeyError:
-    pass
-  except:
-    sys.stderr.write('Unable to use indent of %s\n' % os.environ.get('INDENT'))
-
-  filename = argv[1]
-  desired_class_names = None  # None means all classes in the source file.
-  if len(argv) >= 3:
-    desired_class_names = set(argv[2:])
-  source = utils.ReadFile(filename)
-  if source is None:
-    return 1
-
-  builder = ast.BuilderFromSource(source, filename)
-  try:
-    entire_ast = filter(None, builder.Generate())
-  except KeyboardInterrupt:
-    return
-  except:
-    # An error message was already printed since we couldn't parse.
-    sys.exit(1)
-  else:
-    lines = _GenerateMocks(filename, source, entire_ast, desired_class_names)
-    sys.stdout.write('\n'.join(lines))
-
-
-if __name__ == '__main__':
-  main(sys.argv)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class_test.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class_test.py
deleted file mode 100755
index 018f90a6..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/gmock_class_test.py
+++ /dev/null
@@ -1,448 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2009 Neal Norwitz All Rights Reserved.
-# Portions Copyright 2009 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Tests for gmock.scripts.generator.cpp.gmock_class."""
-
-__author__ = 'nnorwitz@google.com (Neal Norwitz)'
-
-
-import os
-import sys
-import unittest
-
-# Allow the cpp imports below to work when run as a standalone script.
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-
-from cpp import ast
-from cpp import gmock_class
-
-
-class TestCase(unittest.TestCase):
-  """Helper class that adds assert methods."""
-
-  def StripLeadingWhitespace(self, lines):
-    """Strip leading whitespace in each line in 'lines'."""
-    return '\n'.join([s.lstrip() for s in lines.split('\n')])
-
-  def assertEqualIgnoreLeadingWhitespace(self, expected_lines, lines):
-    """Specialized assert that ignores the indent level."""
-    self.assertEqual(expected_lines, self.StripLeadingWhitespace(lines))
-
-
-class GenerateMethodsTest(TestCase):
-
-  def GenerateMethodSource(self, cpp_source):
-    """Convert C++ source to Google Mock output source lines."""
-    method_source_lines = []
-    # <test> is a pseudo-filename, it is not read or written.
-    builder = ast.BuilderFromSource(cpp_source, '<test>')
-    ast_list = list(builder.Generate())
-    gmock_class._GenerateMethods(method_source_lines, cpp_source, ast_list[0])
-    return '\n'.join(method_source_lines)
-
-  def testSimpleMethod(self):
-    source = """
-class Foo {
- public:
-  virtual int Bar();
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD0(Bar,\nint());',
-        self.GenerateMethodSource(source))
-
-  def testSimpleConstructorsAndDestructor(self):
-    source = """
-class Foo {
- public:
-  Foo();
-  Foo(int x);
-  Foo(const Foo& f);
-  Foo(Foo&& f);
-  ~Foo();
-  virtual int Bar() = 0;
-};
-"""
-    # The constructors and destructor should be ignored.
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD0(Bar,\nint());',
-        self.GenerateMethodSource(source))
-
-  def testVirtualDestructor(self):
-    source = """
-class Foo {
- public:
-  virtual ~Foo();
-  virtual int Bar() = 0;
-};
-"""
-    # The destructor should be ignored.
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD0(Bar,\nint());',
-        self.GenerateMethodSource(source))
-
-  def testExplicitlyDefaultedConstructorsAndDestructor(self):
-    source = """
-class Foo {
- public:
-  Foo() = default;
-  Foo(const Foo& f) = default;
-  Foo(Foo&& f) = default;
-  ~Foo() = default;
-  virtual int Bar() = 0;
-};
-"""
-    # The constructors and destructor should be ignored.
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD0(Bar,\nint());',
-        self.GenerateMethodSource(source))
-
-  def testExplicitlyDeletedConstructorsAndDestructor(self):
-    source = """
-class Foo {
- public:
-  Foo() = delete;
-  Foo(const Foo& f) = delete;
-  Foo(Foo&& f) = delete;
-  ~Foo() = delete;
-  virtual int Bar() = 0;
-};
-"""
-    # The constructors and destructor should be ignored.
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD0(Bar,\nint());',
-        self.GenerateMethodSource(source))
-
-  def testSimpleOverrideMethod(self):
-    source = """
-class Foo {
- public:
-  int Bar() override;
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD0(Bar,\nint());',
-        self.GenerateMethodSource(source))
-
-  def testSimpleConstMethod(self):
-    source = """
-class Foo {
- public:
-  virtual void Bar(bool flag) const;
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_CONST_METHOD1(Bar,\nvoid(bool flag));',
-        self.GenerateMethodSource(source))
-
-  def testExplicitVoid(self):
-    source = """
-class Foo {
- public:
-  virtual int Bar(void);
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD0(Bar,\nint(void));',
-        self.GenerateMethodSource(source))
-
-  def testStrangeNewlineInParameter(self):
-    source = """
-class Foo {
- public:
-  virtual void Bar(int
-a) = 0;
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD1(Bar,\nvoid(int a));',
-        self.GenerateMethodSource(source))
-
-  def testDefaultParameters(self):
-    source = """
-class Foo {
- public:
-  virtual void Bar(int a, char c = 'x') = 0;
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD2(Bar,\nvoid(int, char));',
-        self.GenerateMethodSource(source))
-
-  def testMultipleDefaultParameters(self):
-    source = """
-class Foo {
- public:
-  virtual void Bar(int a = 42, char c = 'x') = 0;
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD2(Bar,\nvoid(int, char));',
-        self.GenerateMethodSource(source))
-
-  def testRemovesCommentsWhenDefaultsArePresent(self):
-    source = """
-class Foo {
- public:
-  virtual void Bar(int a = 42 /* a comment */,
-                   char /* other comment */ c= 'x') = 0;
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD2(Bar,\nvoid(int, char));',
-        self.GenerateMethodSource(source))
-
-  def testDoubleSlashCommentsInParameterListAreRemoved(self):
-    source = """
-class Foo {
- public:
-  virtual void Bar(int a,  // inline comments should be elided.
-                   int b   // inline comments should be elided.
-                   ) const = 0;
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_CONST_METHOD2(Bar,\nvoid(int a, int b));',
-        self.GenerateMethodSource(source))
-
-  def testCStyleCommentsInParameterListAreNotRemoved(self):
-    # NOTE(nnorwitz): I'm not sure if it's the best behavior to keep these
-    # comments.  Also note that C style comments after the last parameter
-    # are still elided.
-    source = """
-class Foo {
- public:
-  virtual const string& Bar(int /* keeper */, int b);
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD2(Bar,\nconst string&(int /* keeper */, int b));',
-        self.GenerateMethodSource(source))
-
-  def testArgsOfTemplateTypes(self):
-    source = """
-class Foo {
- public:
-  virtual int Bar(const vector<int>& v, map<int, string>* output);
-};"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD2(Bar,\n'
-        'int(const vector<int>& v, map<int, string>* output));',
-        self.GenerateMethodSource(source))
-
-  def testReturnTypeWithOneTemplateArg(self):
-    source = """
-class Foo {
- public:
-  virtual vector<int>* Bar(int n);
-};"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD1(Bar,\nvector<int>*(int n));',
-        self.GenerateMethodSource(source))
-
-  def testReturnTypeWithManyTemplateArgs(self):
-    source = """
-class Foo {
- public:
-  virtual map<int, string> Bar();
-};"""
-    # Comparing the comment text is brittle - we'll think of something
-    # better in case this gets annoying, but for now let's keep it simple.
-    self.assertEqualIgnoreLeadingWhitespace(
-        '// The following line won\'t really compile, as the return\n'
-        '// type has multiple template arguments.  To fix it, use a\n'
-        '// typedef for the return type.\n'
-        'MOCK_METHOD0(Bar,\nmap<int, string>());',
-        self.GenerateMethodSource(source))
-
-  def testSimpleMethodInTemplatedClass(self):
-    source = """
-template<class T>
-class Foo {
- public:
-  virtual int Bar();
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD0_T(Bar,\nint());',
-        self.GenerateMethodSource(source))
-
-  def testPointerArgWithoutNames(self):
-    source = """
-class Foo {
-  virtual int Bar(C*);
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD1(Bar,\nint(C*));',
-        self.GenerateMethodSource(source))
-
-  def testReferenceArgWithoutNames(self):
-    source = """
-class Foo {
-  virtual int Bar(C&);
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD1(Bar,\nint(C&));',
-        self.GenerateMethodSource(source))
-
-  def testArrayArgWithoutNames(self):
-    source = """
-class Foo {
-  virtual int Bar(C[]);
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD1(Bar,\nint(C[]));',
-        self.GenerateMethodSource(source))
-
-
-class GenerateMocksTest(TestCase):
-
-  def GenerateMocks(self, cpp_source):
-    """Convert C++ source to complete Google Mock output source."""
-    # <test> is a pseudo-filename, it is not read or written.
-    filename = '<test>'
-    builder = ast.BuilderFromSource(cpp_source, filename)
-    ast_list = list(builder.Generate())
-    lines = gmock_class._GenerateMocks(filename, cpp_source, ast_list, None)
-    return '\n'.join(lines)
-
-  def testNamespaces(self):
-    source = """
-namespace Foo {
-namespace Bar { class Forward; }
-namespace Baz {
-
-class Test {
- public:
-  virtual void Foo();
-};
-
-}  // namespace Baz
-}  // namespace Foo
-"""
-    expected = """\
-namespace Foo {
-namespace Baz {
-
-class MockTest : public Test {
-public:
-MOCK_METHOD0(Foo,
-void());
-};
-
-}  // namespace Baz
-}  // namespace Foo
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        expected, self.GenerateMocks(source))
-
-  def testClassWithStorageSpecifierMacro(self):
-    source = """
-class STORAGE_SPECIFIER Test {
- public:
-  virtual void Foo();
-};
-"""
-    expected = """\
-class MockTest : public Test {
-public:
-MOCK_METHOD0(Foo,
-void());
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        expected, self.GenerateMocks(source))
-
-  def testTemplatedForwardDeclaration(self):
-    source = """
-template <class T> class Forward;  // Forward declaration should be ignored.
-class Test {
- public:
-  virtual void Foo();
-};
-"""
-    expected = """\
-class MockTest : public Test {
-public:
-MOCK_METHOD0(Foo,
-void());
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        expected, self.GenerateMocks(source))
-
-  def testTemplatedClass(self):
-    source = """
-template <typename S, typename T>
-class Test {
- public:
-  virtual void Foo();
-};
-"""
-    expected = """\
-template <typename T0, typename T1>
-class MockTest : public Test<T0, T1> {
-public:
-MOCK_METHOD0_T(Foo,
-void());
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        expected, self.GenerateMocks(source))
-
-  def testTemplateInATemplateTypedef(self):
-    source = """
-class Test {
- public:
-  typedef std::vector<std::list<int>> FooType;
-  virtual void Bar(const FooType& test_arg);
-};
-"""
-    expected = """\
-class MockTest : public Test {
-public:
-MOCK_METHOD1(Bar,
-void(const FooType& test_arg));
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        expected, self.GenerateMocks(source))
-
-  def testTemplateInATemplateTypedefWithComma(self):
-    source = """
-class Test {
- public:
-  typedef std::function<void(
-      const vector<std::list<int>>&, int> FooType;
-  virtual void Bar(const FooType& test_arg);
-};
-"""
-    expected = """\
-class MockTest : public Test {
-public:
-MOCK_METHOD1(Bar,
-void(const FooType& test_arg));
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        expected, self.GenerateMocks(source))
-
-if __name__ == '__main__':
-  unittest.main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/keywords.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/keywords.py
deleted file mode 100755
index f694450e..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/keywords.py
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2007 Neal Norwitz
-# Portions Copyright 2007 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""C++ keywords and helper utilities for determining keywords."""
-
-__author__ = 'nnorwitz@google.com (Neal Norwitz)'
-
-
-try:
-    # Python 3.x
-    import builtins
-except ImportError:
-    # Python 2.x
-    import __builtin__ as builtins
-
-
-if not hasattr(builtins, 'set'):
-    # Nominal support for Python 2.3.
-    from sets import Set as set
-
-
-TYPES = set('bool char int long short double float void wchar_t unsigned signed'.split())
-TYPE_MODIFIERS = set('auto register const inline extern static virtual volatile mutable'.split())
-ACCESS = set('public protected private friend'.split())
-
-CASTS = set('static_cast const_cast dynamic_cast reinterpret_cast'.split())
-
-OTHERS = set('true false asm class namespace using explicit this operator sizeof'.split())
-OTHER_TYPES = set('new delete typedef struct union enum typeid typename template'.split())
-
-CONTROL = set('case switch default if else return goto'.split())
-EXCEPTION = set('try catch throw'.split())
-LOOP = set('while do for break continue'.split())
-
-ALL = TYPES | TYPE_MODIFIERS | ACCESS | CASTS | OTHERS | OTHER_TYPES | CONTROL | EXCEPTION | LOOP
-
-
-def IsKeyword(token):
-    return token in ALL
-
-def IsBuiltinType(token):
-    if token in ('virtual', 'inline'):
-        # These only apply to methods, they can't be types by themselves.
-        return False
-    return token in TYPES or token in TYPE_MODIFIERS
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/tokenize.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/tokenize.py
deleted file mode 100755
index 359d5562..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/tokenize.py
+++ /dev/null
@@ -1,287 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2007 Neal Norwitz
-# Portions Copyright 2007 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Tokenize C++ source code."""
-
-__author__ = 'nnorwitz@google.com (Neal Norwitz)'
-
-
-try:
-    # Python 3.x
-    import builtins
-except ImportError:
-    # Python 2.x
-    import __builtin__ as builtins
-
-
-import sys
-
-from cpp import utils
-
-
-if not hasattr(builtins, 'set'):
-    # Nominal support for Python 2.3.
-    from sets import Set as set
-
-
-# Add $ as a valid identifier char since so much code uses it.
-_letters = 'abcdefghijklmnopqrstuvwxyz'
-VALID_IDENTIFIER_CHARS = set(_letters + _letters.upper() + '_0123456789$')
-HEX_DIGITS = set('0123456789abcdefABCDEF')
-INT_OR_FLOAT_DIGITS = set('01234567890eE-+')
-
-
-# C++0x string preffixes.
-_STR_PREFIXES = set(('R', 'u8', 'u8R', 'u', 'uR', 'U', 'UR', 'L', 'LR'))
-
-
-# Token types.
-UNKNOWN = 'UNKNOWN'
-SYNTAX = 'SYNTAX'
-CONSTANT = 'CONSTANT'
-NAME = 'NAME'
-PREPROCESSOR = 'PREPROCESSOR'
-
-# Where the token originated from.  This can be used for backtracking.
-# It is always set to WHENCE_STREAM in this code.
-WHENCE_STREAM, WHENCE_QUEUE = range(2)
-
-
-class Token(object):
-    """Data container to represent a C++ token.
-
-    Tokens can be identifiers, syntax char(s), constants, or
-    pre-processor directives.
-
-    start contains the index of the first char of the token in the source
-    end contains the index of the last char of the token in the source
-    """
-
-    def __init__(self, token_type, name, start, end):
-        self.token_type = token_type
-        self.name = name
-        self.start = start
-        self.end = end
-        self.whence = WHENCE_STREAM
-
-    def __str__(self):
-        if not utils.DEBUG:
-            return 'Token(%r)' % self.name
-        return 'Token(%r, %s, %s)' % (self.name, self.start, self.end)
-
-    __repr__ = __str__
-
-
-def _GetString(source, start, i):
-    i = source.find('"', i+1)
-    while source[i-1] == '\\':
-        # Count the trailing backslashes.
-        backslash_count = 1
-        j = i - 2
-        while source[j] == '\\':
-            backslash_count += 1
-            j -= 1
-        # When trailing backslashes are even, they escape each other.
-        if (backslash_count % 2) == 0:
-            break
-        i = source.find('"', i+1)
-    return i + 1
-
-
-def _GetChar(source, start, i):
-    # NOTE(nnorwitz): may not be quite correct, should be good enough.
-    i = source.find("'", i+1)
-    while source[i-1] == '\\':
-        # Need to special case '\\'.
-        if (i - 2) > start and source[i-2] == '\\':
-            break
-        i = source.find("'", i+1)
-    # Try to handle unterminated single quotes (in a #if 0 block).
-    if i < 0:
-        i = start
-    return i + 1
-
-
-def GetTokens(source):
-    """Returns a sequence of Tokens.
-
-    Args:
-      source: string of C++ source code.
-
-    Yields:
-      Token that represents the next token in the source.
-    """
-    # Cache various valid character sets for speed.
-    valid_identifier_chars = VALID_IDENTIFIER_CHARS
-    hex_digits = HEX_DIGITS
-    int_or_float_digits = INT_OR_FLOAT_DIGITS
-    int_or_float_digits2 = int_or_float_digits | set('.')
-
-    # Only ignore errors while in a #if 0 block.
-    ignore_errors = False
-    count_ifs = 0
-
-    i = 0
-    end = len(source)
-    while i < end:
-        # Skip whitespace.
-        while i < end and source[i].isspace():
-            i += 1
-        if i >= end:
-            return
-
-        token_type = UNKNOWN
-        start = i
-        c = source[i]
-        if c.isalpha() or c == '_':              # Find a string token.
-            token_type = NAME
-            while source[i] in valid_identifier_chars:
-                i += 1
-            # String and character constants can look like a name if
-            # they are something like L"".
-            if (source[i] == "'" and (i - start) == 1 and
-                source[start:i] in 'uUL'):
-                # u, U, and L are valid C++0x character preffixes.
-                token_type = CONSTANT
-                i = _GetChar(source, start, i)
-            elif source[i] == "'" and source[start:i] in _STR_PREFIXES:
-                token_type = CONSTANT
-                i = _GetString(source, start, i)
-        elif c == '/' and source[i+1] == '/':    # Find // comments.
-            i = source.find('\n', i)
-            if i == -1:  # Handle EOF.
-                i = end
-            continue
-        elif c == '/' and source[i+1] == '*':    # Find /* comments. */
-            i = source.find('*/', i) + 2
-            continue
-        elif c in ':+-<>&|*=':                   # : or :: (plus other chars).
-            token_type = SYNTAX
-            i += 1
-            new_ch = source[i]
-            if new_ch == c and c != '>':         # Treat ">>" as two tokens.
-                i += 1
-            elif c == '-' and new_ch == '>':
-                i += 1
-            elif new_ch == '=':
-                i += 1
-        elif c in '()[]{}~!?^%;/.,':             # Handle single char tokens.
-            token_type = SYNTAX
-            i += 1
-            if c == '.' and source[i].isdigit():
-                token_type = CONSTANT
-                i += 1
-                while source[i] in int_or_float_digits:
-                    i += 1
-                # Handle float suffixes.
-                for suffix in ('l', 'f'):
-                    if suffix == source[i:i+1].lower():
-                        i += 1
-                        break
-        elif c.isdigit():                        # Find integer.
-            token_type = CONSTANT
-            if c == '0' and source[i+1] in 'xX':
-                # Handle hex digits.
-                i += 2
-                while source[i] in hex_digits:
-                    i += 1
-            else:
-                while source[i] in int_or_float_digits2:
-                    i += 1
-            # Handle integer (and float) suffixes.
-            for suffix in ('ull', 'll', 'ul', 'l', 'f', 'u'):
-                size = len(suffix)
-                if suffix == source[i:i+size].lower():
-                    i += size
-                    break
-        elif c == '"':                           # Find string.
-            token_type = CONSTANT
-            i = _GetString(source, start, i)
-        elif c == "'":                           # Find char.
-            token_type = CONSTANT
-            i = _GetChar(source, start, i)
-        elif c == '#':                           # Find pre-processor command.
-            token_type = PREPROCESSOR
-            got_if = source[i:i+3] == '#if' and source[i+3:i+4].isspace()
-            if got_if:
-                count_ifs += 1
-            elif source[i:i+6] == '#endif':
-                count_ifs -= 1
-                if count_ifs == 0:
-                    ignore_errors = False
-
-            # TODO(nnorwitz): handle preprocessor statements (\ continuations).
-            while 1:
-                i1 = source.find('\n', i)
-                i2 = source.find('//', i)
-                i3 = source.find('/*', i)
-                i4 = source.find('"', i)
-                # NOTE(nnorwitz): doesn't handle comments in #define macros.
-                # Get the first important symbol (newline, comment, EOF/end).
-                i = min([x for x in (i1, i2, i3, i4, end) if x != -1])
-
-                # Handle #include "dir//foo.h" properly.
-                if source[i] == '"':
-                    i = source.find('"', i+1) + 1
-                    assert i > 0
-                    continue
-                # Keep going if end of the line and the line ends with \.
-                if not (i == i1 and source[i-1] == '\\'):
-                    if got_if:
-                        condition = source[start+4:i].lstrip()
-                        if (condition.startswith('0') or
-                            condition.startswith('(0)')):
-                            ignore_errors = True
-                    break
-                i += 1
-        elif c == '\\':                          # Handle \ in code.
-            # This is different from the pre-processor \ handling.
-            i += 1
-            continue
-        elif ignore_errors:
-            # The tokenizer seems to be in pretty good shape.  This
-            # raise is conditionally disabled so that bogus code
-            # in an #if 0 block can be handled.  Since we will ignore
-            # it anyways, this is probably fine.  So disable the
-            # exception and  return the bogus char.
-            i += 1
-        else:
-            sys.stderr.write('Got invalid token in %s @ %d token:%s: %r\n' %
-                             ('?', i, c, source[i-10:i+10]))
-            raise RuntimeError('unexpected token')
-
-        if i <= 0:
-            print('Invalid index, exiting now.')
-            return
-        yield Token(token_type, source[start:i], start, i)
-
-
-if __name__ == '__main__':
-    def main(argv):
-        """Driver mostly for testing purposes."""
-        for filename in argv[1:]:
-            source = utils.ReadFile(filename)
-            if source is None:
-                continue
-
-            for token in GetTokens(source):
-                print('%-12s: %s' % (token.token_type, token.name))
-                # print('\r%6.2f%%' % (100.0 * index / token.end),)
-            sys.stdout.write('\n')
-
-
-    main(sys.argv)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/utils.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/utils.py
deleted file mode 100755
index eab36eec..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/cpp/utils.py
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2007 Neal Norwitz
-# Portions Copyright 2007 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Generic utilities for C++ parsing."""
-
-__author__ = 'nnorwitz@google.com (Neal Norwitz)'
-
-
-import sys
-
-
-# Set to True to see the start/end token indices.
-DEBUG = True
-
-
-def ReadFile(filename, print_error=True):
-    """Returns the contents of a file."""
-    try:
-        fp = open(filename)
-        try:
-            return fp.read()
-        finally:
-            fp.close()
-    except IOError:
-        if print_error:
-            print('Error reading %s: %s' % (filename, sys.exc_info()[1]))
-        return None
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/gmock_gen.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/gmock_gen.py
deleted file mode 100755
index 8cc0d135..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/generator/gmock_gen.py
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2008 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Driver for starting up Google Mock class generator."""
-
-__author__ = 'nnorwitz@google.com (Neal Norwitz)'
-
-import os
-import sys
-
-if __name__ == '__main__':
-  # Add the directory of this script to the path so we can import gmock_class.
-  sys.path.append(os.path.dirname(__file__))
-
-  from cpp import gmock_class
-  # Fix the docstring in case they require the usage.
-  gmock_class.__doc__ = gmock_class.__doc__.replace('gmock_class.py', __file__)
-  gmock_class.main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock-config.in b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock-config.in
deleted file mode 100755
index 2baefe94..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock-config.in
+++ /dev/null
@@ -1,303 +0,0 @@
-#!/bin/sh
-
-# These variables are automatically filled in by the configure script.
-name="@PACKAGE_TARNAME@"
-version="@PACKAGE_VERSION@"
-
-show_usage()
-{
-  echo "Usage: gmock-config [OPTIONS...]"
-}
-
-show_help()
-{
-  show_usage
-  cat <<\EOF
-
-The `gmock-config' script provides access to the necessary compile and linking
-flags to connect with Google C++ Mocking Framework, both in a build prior to
-installation, and on the system proper after installation. The installation
-overrides may be issued in combination with any other queries, but will only
-affect installation queries if called on a built but not installed gmock. The
-installation queries may not be issued with any other types of queries, and
-only one installation query may be made at a time. The version queries and
-compiler flag queries may be combined as desired but not mixed. Different
-version queries are always combined with logical "and" semantics, and only the
-last of any particular query is used while all previous ones ignored. All
-versions must be specified as a sequence of numbers separated by periods.
-Compiler flag queries output the union of the sets of flags when combined.
-
- Examples:
-  gmock-config --min-version=1.0 || echo "Insufficient Google Mock version."
-
-  g++ $(gmock-config --cppflags --cxxflags) -o foo.o -c foo.cpp
-  g++ $(gmock-config --ldflags --libs) -o foo foo.o
-
-  # When using a built but not installed Google Mock:
-  g++ $(../../my_gmock_build/scripts/gmock-config ...) ...
-
-  # When using an installed Google Mock, but with installation overrides:
-  export GMOCK_PREFIX="/opt"
-  g++ $(gmock-config --libdir="/opt/lib64" ...) ...
-
- Help:
-  --usage                    brief usage information
-  --help                     display this help message
-
- Installation Overrides:
-  --prefix=<dir>             overrides the installation prefix
-  --exec-prefix=<dir>        overrides the executable installation prefix
-  --libdir=<dir>             overrides the library installation prefix
-  --includedir=<dir>         overrides the header file installation prefix
-
- Installation Queries:
-  --prefix                   installation prefix
-  --exec-prefix              executable installation prefix
-  --libdir                   library installation directory
-  --includedir               header file installation directory
-  --version                  the version of the Google Mock installation
-
- Version Queries:
-  --min-version=VERSION      return 0 if the version is at least VERSION
-  --exact-version=VERSION    return 0 if the version is exactly VERSION
-  --max-version=VERSION      return 0 if the version is at most VERSION
-
- Compilation Flag Queries:
-  --cppflags                 compile flags specific to the C-like preprocessors
-  --cxxflags                 compile flags appropriate for C++ programs
-  --ldflags                  linker flags
-  --libs                     libraries for linking
-
-EOF
-}
-
-# This function bounds our version with a min and a max. It uses some clever
-# POSIX-compliant variable expansion to portably do all the work in the shell
-# and avoid any dependency on a particular "sed" or "awk" implementation.
-# Notable is that it will only ever compare the first 3 components of versions.
-# Further components will be cleanly stripped off. All versions must be
-# unadorned, so "v1.0" will *not* work. The minimum version must be in $1, and
-# the max in $2. TODO(chandlerc@google.com): If this ever breaks, we should
-# investigate expanding this via autom4te from AS_VERSION_COMPARE rather than
-# continuing to maintain our own shell version.
-check_versions()
-{
-  major_version=${version%%.*}
-  minor_version="0"
-  point_version="0"
-  if test "${version#*.}" != "${version}"; then
-    minor_version=${version#*.}
-    minor_version=${minor_version%%.*}
-  fi
-  if test "${version#*.*.}" != "${version}"; then
-    point_version=${version#*.*.}
-    point_version=${point_version%%.*}
-  fi
-
-  min_version="$1"
-  min_major_version=${min_version%%.*}
-  min_minor_version="0"
-  min_point_version="0"
-  if test "${min_version#*.}" != "${min_version}"; then
-    min_minor_version=${min_version#*.}
-    min_minor_version=${min_minor_version%%.*}
-  fi
-  if test "${min_version#*.*.}" != "${min_version}"; then
-    min_point_version=${min_version#*.*.}
-    min_point_version=${min_point_version%%.*}
-  fi
-
-  max_version="$2"
-  max_major_version=${max_version%%.*}
-  max_minor_version="0"
-  max_point_version="0"
-  if test "${max_version#*.}" != "${max_version}"; then
-    max_minor_version=${max_version#*.}
-    max_minor_version=${max_minor_version%%.*}
-  fi
-  if test "${max_version#*.*.}" != "${max_version}"; then
-    max_point_version=${max_version#*.*.}
-    max_point_version=${max_point_version%%.*}
-  fi
-
-  test $(($major_version)) -lt $(($min_major_version)) && exit 1
-  if test $(($major_version)) -eq $(($min_major_version)); then
-    test $(($minor_version)) -lt $(($min_minor_version)) && exit 1
-    if test $(($minor_version)) -eq $(($min_minor_version)); then
-      test $(($point_version)) -lt $(($min_point_version)) && exit 1
-    fi
-  fi
-
-  test $(($major_version)) -gt $(($max_major_version)) && exit 1
-  if test $(($major_version)) -eq $(($max_major_version)); then
-    test $(($minor_version)) -gt $(($max_minor_version)) && exit 1
-    if test $(($minor_version)) -eq $(($max_minor_version)); then
-      test $(($point_version)) -gt $(($max_point_version)) && exit 1
-    fi
-  fi
-
-  exit 0
-}
-
-# Show the usage line when no arguments are specified.
-if test $# -eq 0; then
-  show_usage
-  exit 1
-fi
-
-while test $# -gt 0; do
-  case $1 in
-    --usage)          show_usage;         exit 0;;
-    --help)           show_help;          exit 0;;
-
-    # Installation overrides
-    --prefix=*)       GMOCK_PREFIX=${1#--prefix=};;
-    --exec-prefix=*)  GMOCK_EXEC_PREFIX=${1#--exec-prefix=};;
-    --libdir=*)       GMOCK_LIBDIR=${1#--libdir=};;
-    --includedir=*)   GMOCK_INCLUDEDIR=${1#--includedir=};;
-
-    # Installation queries
-    --prefix|--exec-prefix|--libdir|--includedir|--version)
-      if test -n "${do_query}"; then
-        show_usage
-        exit 1
-      fi
-      do_query=${1#--}
-      ;;
-
-    # Version checking
-    --min-version=*)
-      do_check_versions=yes
-      min_version=${1#--min-version=}
-      ;;
-    --max-version=*)
-      do_check_versions=yes
-      max_version=${1#--max-version=}
-      ;;
-    --exact-version=*)
-      do_check_versions=yes
-      exact_version=${1#--exact-version=}
-      ;;
-
-    # Compiler flag output
-    --cppflags)       echo_cppflags=yes;;
-    --cxxflags)       echo_cxxflags=yes;;
-    --ldflags)        echo_ldflags=yes;;
-    --libs)           echo_libs=yes;;
-
-    # Everything else is an error
-    *)                show_usage;         exit 1;;
-  esac
-  shift
-done
-
-# These have defaults filled in by the configure script but can also be
-# overridden by environment variables or command line parameters.
-prefix="${GMOCK_PREFIX:-@prefix@}"
-exec_prefix="${GMOCK_EXEC_PREFIX:-@exec_prefix@}"
-libdir="${GMOCK_LIBDIR:-@libdir@}"
-includedir="${GMOCK_INCLUDEDIR:-@includedir@}"
-
-# We try and detect if our binary is not located at its installed location. If
-# it's not, we provide variables pointing to the source and build tree rather
-# than to the install tree. We also locate Google Test using the configured
-# gtest-config script rather than searching the PATH and our bindir for one.
-# This allows building against a just-built gmock rather than an installed
-# gmock.
-bindir="@bindir@"
-this_relative_bindir=`dirname $0`
-this_bindir=`cd ${this_relative_bindir}; pwd -P`
-if test "${this_bindir}" = "${this_bindir%${bindir}}"; then
-  # The path to the script doesn't end in the bindir sequence from Autoconf,
-  # assume that we are in a build tree.
-  build_dir=`dirname ${this_bindir}`
-  src_dir=`cd ${this_bindir}/@top_srcdir@; pwd -P`
-
-  # TODO(chandlerc@google.com): This is a dangerous dependency on libtool, we
-  # should work to remove it, and/or remove libtool altogether, replacing it
-  # with direct references to the library and a link path.
-  gmock_libs="${build_dir}/lib/libgmock.la"
-  gmock_ldflags=""
-
-  # We provide hooks to include from either the source or build dir, where the
-  # build dir is always preferred. This will potentially allow us to write
-  # build rules for generated headers and have them automatically be preferred
-  # over provided versions.
-  gmock_cppflags="-I${build_dir}/include -I${src_dir}/include"
-  gmock_cxxflags=""
-
-  # Directly invoke the gtest-config script used during the build process.
-  gtest_config="@GTEST_CONFIG@"
-else
-  # We're using an installed gmock, although it may be staged under some
-  # prefix. Assume (as our own libraries do) that we can resolve the prefix,
-  # and are present in the dynamic link paths.
-  gmock_ldflags="-L${libdir}"
-  gmock_libs="-l${name}"
-  gmock_cppflags="-I${includedir}"
-  gmock_cxxflags=""
-
-  # We also prefer any gtest-config script installed in our prefix. Lacking
-  # one, we look in the PATH for one.
-  gtest_config="${bindir}/gtest-config"
-  if test ! -x "${gtest_config}"; then
-    gtest_config=`which gtest-config`
-  fi
-fi
-
-# Ensure that we have located a Google Test to link against.
-if ! test -x "${gtest_config}"; then
-  echo "Unable to locate Google Test, check your Google Mock configuration" \
-       "and installation" >&2
-  exit 1
-elif ! "${gtest_config}" "--exact-version=@GTEST_VERSION@"; then
-  echo "The Google Test found is not the same version as Google Mock was " \
-       "built against" >&2
-  exit 1
-fi
-
-# Add the necessary Google Test bits into the various flag variables
-gmock_cppflags="${gmock_cppflags} `${gtest_config} --cppflags`"
-gmock_cxxflags="${gmock_cxxflags} `${gtest_config} --cxxflags`"
-gmock_ldflags="${gmock_ldflags} `${gtest_config} --ldflags`"
-gmock_libs="${gmock_libs} `${gtest_config} --libs`"
-
-# Do an installation query if requested.
-if test -n "$do_query"; then
-  case $do_query in
-    prefix)           echo $prefix;       exit 0;;
-    exec-prefix)      echo $exec_prefix;  exit 0;;
-    libdir)           echo $libdir;       exit 0;;
-    includedir)       echo $includedir;   exit 0;;
-    version)          echo $version;      exit 0;;
-    *)                show_usage;         exit 1;;
-  esac
-fi
-
-# Do a version check if requested.
-if test "$do_check_versions" = "yes"; then
-  # Make sure we didn't receive a bad combination of parameters.
-  test "$echo_cppflags" = "yes" && show_usage && exit 1
-  test "$echo_cxxflags" = "yes" && show_usage && exit 1
-  test "$echo_ldflags" = "yes"  && show_usage && exit 1
-  test "$echo_libs" = "yes"     && show_usage && exit 1
-
-  if test "$exact_version" != ""; then
-    check_versions $exact_version $exact_version
-    # unreachable
-  else
-    check_versions ${min_version:-0.0.0} ${max_version:-9999.9999.9999}
-    # unreachable
-  fi
-fi
-
-# Do the output in the correct order so that these can be used in-line of
-# a compiler invocation.
-output=""
-test "$echo_cppflags" = "yes" && output="$output $gmock_cppflags"
-test "$echo_cxxflags" = "yes" && output="$output $gmock_cxxflags"
-test "$echo_ldflags" = "yes"  && output="$output $gmock_ldflags"
-test "$echo_libs" = "yes"     && output="$output $gmock_libs"
-echo $output
-
-exit 0
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock_doctor.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock_doctor.py
deleted file mode 100755
index 74992bc7..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/gmock_doctor.py
+++ /dev/null
@@ -1,640 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-
-"""Converts compiler's errors in code using Google Mock to plain English."""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import re
-import sys
-
-_VERSION = '1.0.3'
-
-_EMAIL = 'googlemock@googlegroups.com'
-
-_COMMON_GMOCK_SYMBOLS = [
-    # Matchers
-    '_',
-    'A',
-    'AddressSatisfies',
-    'AllOf',
-    'An',
-    'AnyOf',
-    'ContainerEq',
-    'Contains',
-    'ContainsRegex',
-    'DoubleEq',
-    'ElementsAre',
-    'ElementsAreArray',
-    'EndsWith',
-    'Eq',
-    'Field',
-    'FloatEq',
-    'Ge',
-    'Gt',
-    'HasSubstr',
-    'IsInitializedProto',
-    'Le',
-    'Lt',
-    'MatcherCast',
-    'Matches',
-    'MatchesRegex',
-    'NanSensitiveDoubleEq',
-    'NanSensitiveFloatEq',
-    'Ne',
-    'Not',
-    'NotNull',
-    'Pointee',
-    'Property',
-    'Ref',
-    'ResultOf',
-    'SafeMatcherCast',
-    'StartsWith',
-    'StrCaseEq',
-    'StrCaseNe',
-    'StrEq',
-    'StrNe',
-    'Truly',
-    'TypedEq',
-    'Value',
-
-    # Actions
-    'Assign',
-    'ByRef',
-    'DeleteArg',
-    'DoAll',
-    'DoDefault',
-    'IgnoreResult',
-    'Invoke',
-    'InvokeArgument',
-    'InvokeWithoutArgs',
-    'Return',
-    'ReturnNew',
-    'ReturnNull',
-    'ReturnRef',
-    'SaveArg',
-    'SetArgReferee',
-    'SetArgPointee',
-    'SetArgumentPointee',
-    'SetArrayArgument',
-    'SetErrnoAndReturn',
-    'Throw',
-    'WithArg',
-    'WithArgs',
-    'WithoutArgs',
-
-    # Cardinalities
-    'AnyNumber',
-    'AtLeast',
-    'AtMost',
-    'Between',
-    'Exactly',
-
-    # Sequences
-    'InSequence',
-    'Sequence',
-
-    # Misc
-    'DefaultValue',
-    'Mock',
-    ]
-
-# Regex for matching source file path and line number in the compiler's errors.
-_GCC_FILE_LINE_RE = r'(?P<file>.*):(?P<line>\d+):(\d+:)?\s+'
-_CLANG_FILE_LINE_RE = r'(?P<file>.*):(?P<line>\d+):(?P<column>\d+):\s+'
-_CLANG_NON_GMOCK_FILE_LINE_RE = (
-    r'(?P<file>.*[/\\^](?!gmock-)[^/\\]+):(?P<line>\d+):(?P<column>\d+):\s+')
-
-
-def _FindAllMatches(regex, s):
-  """Generates all matches of regex in string s."""
-
-  r = re.compile(regex)
-  return r.finditer(s)
-
-
-def _GenericDiagnoser(short_name, long_name, diagnoses, msg):
-  """Diagnoses the given disease by pattern matching.
-
-  Can provide different diagnoses for different patterns.
-
-  Args:
-    short_name: Short name of the disease.
-    long_name:  Long name of the disease.
-    diagnoses:  A list of pairs (regex, pattern for formatting the diagnosis
-                for matching regex).
-    msg:        Compiler's error messages.
-  Yields:
-    Tuples of the form
-      (short name of disease, long name of disease, diagnosis).
-  """
-  for regex, diagnosis in diagnoses:
-    if re.search(regex, msg):
-      diagnosis = '%(file)s:%(line)s:' + diagnosis
-      for m in _FindAllMatches(regex, msg):
-        yield (short_name, long_name, diagnosis % m.groupdict())
-
-
-def _NeedToReturnReferenceDiagnoser(msg):
-  """Diagnoses the NRR disease, given the error messages by the compiler."""
-
-  gcc_regex = (r'In member function \'testing::internal::ReturnAction<R>.*\n'
-               + _GCC_FILE_LINE_RE + r'instantiated from here\n'
-               r'.*gmock-actions\.h.*error: creating array with negative size')
-  clang_regex = (r'error:.*array.*negative.*\r?\n'
-                 r'(.*\n)*?' +
-                 _CLANG_NON_GMOCK_FILE_LINE_RE +
-                 r'note: in instantiation of function template specialization '
-                 r'\'testing::internal::ReturnAction<(?P<type>.*)>'
-                 r'::operator Action<.*>\' requested here')
-  clang11_re = (r'use_ReturnRef_instead_of_Return_to_return_a_reference.*'
-                r'(.*\n)*?' + _CLANG_NON_GMOCK_FILE_LINE_RE)
-
-  diagnosis = """
-You are using a Return() action in a function that returns a reference to
-%(type)s.  Please use ReturnRef() instead."""
-  return _GenericDiagnoser('NRR', 'Need to Return Reference',
-                           [(clang_regex, diagnosis),
-                            (clang11_re, diagnosis % {'type': 'a type'}),
-                            (gcc_regex, diagnosis % {'type': 'a type'})],
-                           msg)
-
-
-def _NeedToReturnSomethingDiagnoser(msg):
-  """Diagnoses the NRS disease, given the error messages by the compiler."""
-
-  gcc_regex = (_GCC_FILE_LINE_RE + r'(instantiated from here\n.'
-               r'*gmock.*actions\.h.*error: void value not ignored)'
-               r'|(error: control reaches end of non-void function)')
-  clang_regex1 = (_CLANG_FILE_LINE_RE +
-                  r'error: cannot initialize return object '
-                  r'of type \'Result\' \(aka \'(?P<return_type>.*)\'\) '
-                  r'with an rvalue of type \'void\'')
-  clang_regex2 = (_CLANG_FILE_LINE_RE +
-                  r'error: cannot initialize return object '
-                  r'of type \'(?P<return_type>.*)\' '
-                  r'with an rvalue of type \'void\'')
-  diagnosis = """
-You are using an action that returns void, but it needs to return
-%(return_type)s.  Please tell it *what* to return.  Perhaps you can use
-the pattern DoAll(some_action, Return(some_value))?"""
-  return _GenericDiagnoser(
-      'NRS',
-      'Need to Return Something',
-      [(gcc_regex, diagnosis % {'return_type': '*something*'}),
-       (clang_regex1, diagnosis),
-       (clang_regex2, diagnosis)],
-      msg)
-
-
-def _NeedToReturnNothingDiagnoser(msg):
-  """Diagnoses the NRN disease, given the error messages by the compiler."""
-
-  gcc_regex = (_GCC_FILE_LINE_RE + r'instantiated from here\n'
-               r'.*gmock-actions\.h.*error: instantiation of '
-               r'\'testing::internal::ReturnAction<R>::Impl<F>::value_\' '
-               r'as type \'void\'')
-  clang_regex1 = (r'error: field has incomplete type '
-                  r'\'Result\' \(aka \'void\'\)(\r)?\n'
-                  r'(.*\n)*?' +
-                  _CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
-                  r'of function template specialization '
-                  r'\'testing::internal::ReturnAction<(?P<return_type>.*)>'
-                  r'::operator Action<void \(.*\)>\' requested here')
-  clang_regex2 = (r'error: field has incomplete type '
-                  r'\'Result\' \(aka \'void\'\)(\r)?\n'
-                  r'(.*\n)*?' +
-                  _CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
-                  r'of function template specialization '
-                  r'\'testing::internal::DoBothAction<.*>'
-                  r'::operator Action<(?P<return_type>.*) \(.*\)>\' '
-                  r'requested here')
-  diagnosis = """
-You are using an action that returns %(return_type)s, but it needs to return
-void.  Please use a void-returning action instead.
-
-All actions but the last in DoAll(...) must return void.  Perhaps you need
-to re-arrange the order of actions in a DoAll(), if you are using one?"""
-  return _GenericDiagnoser(
-      'NRN',
-      'Need to Return Nothing',
-      [(gcc_regex, diagnosis % {'return_type': '*something*'}),
-       (clang_regex1, diagnosis),
-       (clang_regex2, diagnosis)],
-      msg)
-
-
-def _IncompleteByReferenceArgumentDiagnoser(msg):
-  """Diagnoses the IBRA disease, given the error messages by the compiler."""
-
-  gcc_regex = (_GCC_FILE_LINE_RE + r'instantiated from here\n'
-               r'.*gtest-printers\.h.*error: invalid application of '
-               r'\'sizeof\' to incomplete type \'(?P<type>.*)\'')
-
-  clang_regex = (r'.*gtest-printers\.h.*error: invalid application of '
-                 r'\'sizeof\' to an incomplete type '
-                 r'\'(?P<type>.*)( const)?\'\r?\n'
-                 r'(.*\n)*?' +
-                 _CLANG_NON_GMOCK_FILE_LINE_RE +
-                 r'note: in instantiation of member function '
-                 r'\'testing::internal2::TypeWithoutFormatter<.*>::'
-                 r'PrintValue\' requested here')
-  diagnosis = """
-In order to mock this function, Google Mock needs to see the definition
-of type "%(type)s" - declaration alone is not enough.  Either #include
-the header that defines it, or change the argument to be passed
-by pointer."""
-
-  return _GenericDiagnoser('IBRA', 'Incomplete By-Reference Argument Type',
-                           [(gcc_regex, diagnosis),
-                            (clang_regex, diagnosis)],
-                           msg)
-
-
-def _OverloadedFunctionMatcherDiagnoser(msg):
-  """Diagnoses the OFM disease, given the error messages by the compiler."""
-
-  gcc_regex = (_GCC_FILE_LINE_RE + r'error: no matching function for '
-               r'call to \'Truly\(<unresolved overloaded function type>\)')
-  clang_regex = (_CLANG_FILE_LINE_RE + r'error: no matching function for '
-                 r'call to \'Truly')
-  diagnosis = """
-The argument you gave to Truly() is an overloaded function.  Please tell
-your compiler which overloaded version you want to use.
-
-For example, if you want to use the version whose signature is
-  bool Foo(int n);
-you should write
-  Truly(static_cast<bool (*)(int n)>(Foo))"""
-  return _GenericDiagnoser('OFM', 'Overloaded Function Matcher',
-                           [(gcc_regex, diagnosis),
-                            (clang_regex, diagnosis)],
-                           msg)
-
-
-def _OverloadedFunctionActionDiagnoser(msg):
-  """Diagnoses the OFA disease, given the error messages by the compiler."""
-
-  gcc_regex = (_GCC_FILE_LINE_RE + r'error: no matching function for call to '
-               r'\'Invoke\(<unresolved overloaded function type>')
-  clang_regex = (_CLANG_FILE_LINE_RE + r'error: no matching '
-                 r'function for call to \'Invoke\'\r?\n'
-                 r'(.*\n)*?'
-                 r'.*\bgmock-generated-actions\.h:\d+:\d+:\s+'
-                 r'note: candidate template ignored:\s+'
-                 r'couldn\'t infer template argument \'FunctionImpl\'')
-  diagnosis = """
-Function you are passing to Invoke is overloaded.  Please tell your compiler
-which overloaded version you want to use.
-
-For example, if you want to use the version whose signature is
-  bool MyFunction(int n, double x);
-you should write something like
-  Invoke(static_cast<bool (*)(int n, double x)>(MyFunction))"""
-  return _GenericDiagnoser('OFA', 'Overloaded Function Action',
-                           [(gcc_regex, diagnosis),
-                            (clang_regex, diagnosis)],
-                           msg)
-
-
-def _OverloadedMethodActionDiagnoser(msg):
-  """Diagnoses the OMA disease, given the error messages by the compiler."""
-
-  gcc_regex = (_GCC_FILE_LINE_RE + r'error: no matching function for '
-               r'call to \'Invoke\(.+, <unresolved overloaded function '
-               r'type>\)')
-  clang_regex = (_CLANG_FILE_LINE_RE + r'error: no matching function '
-                 r'for call to \'Invoke\'\r?\n'
-                 r'(.*\n)*?'
-                 r'.*\bgmock-generated-actions\.h:\d+:\d+: '
-                 r'note: candidate function template not viable: '
-                 r'requires .*, but 2 (arguments )?were provided')
-  diagnosis = """
-The second argument you gave to Invoke() is an overloaded method.  Please
-tell your compiler which overloaded version you want to use.
-
-For example, if you want to use the version whose signature is
-  class Foo {
-    ...
-    bool Bar(int n, double x);
-  };
-you should write something like
-  Invoke(foo, static_cast<bool (Foo::*)(int n, double x)>(&Foo::Bar))"""
-  return _GenericDiagnoser('OMA', 'Overloaded Method Action',
-                           [(gcc_regex, diagnosis),
-                            (clang_regex, diagnosis)],
-                           msg)
-
-
-def _MockObjectPointerDiagnoser(msg):
-  """Diagnoses the MOP disease, given the error messages by the compiler."""
-
-  gcc_regex = (_GCC_FILE_LINE_RE + r'error: request for member '
-               r'\'gmock_(?P<method>.+)\' in \'(?P<mock_object>.+)\', '
-               r'which is of non-class type \'(.*::)*(?P<class_name>.+)\*\'')
-  clang_regex = (_CLANG_FILE_LINE_RE + r'error: member reference type '
-                 r'\'(?P<class_name>.*?) *\' is a pointer; '
-                 r'(did you mean|maybe you meant) to use \'->\'\?')
-  diagnosis = """
-The first argument to ON_CALL() and EXPECT_CALL() must be a mock *object*,
-not a *pointer* to it.  Please write '*(%(mock_object)s)' instead of
-'%(mock_object)s' as your first argument.
-
-For example, given the mock class:
-
-  class %(class_name)s : public ... {
-    ...
-    MOCK_METHOD0(%(method)s, ...);
-  };
-
-and the following mock instance:
-
-  %(class_name)s* mock_ptr = ...
-
-you should use the EXPECT_CALL like this:
-
-  EXPECT_CALL(*mock_ptr, %(method)s(...));"""
-
-  return _GenericDiagnoser(
-      'MOP',
-      'Mock Object Pointer',
-      [(gcc_regex, diagnosis),
-       (clang_regex, diagnosis % {'mock_object': 'mock_object',
-                                  'method': 'method',
-                                  'class_name': '%(class_name)s'})],
-       msg)
-
-
-def _NeedToUseSymbolDiagnoser(msg):
-  """Diagnoses the NUS disease, given the error messages by the compiler."""
-
-  gcc_regex = (_GCC_FILE_LINE_RE + r'error: \'(?P<symbol>.+)\' '
-               r'(was not declared in this scope|has not been declared)')
-  clang_regex = (_CLANG_FILE_LINE_RE +
-                 r'error: (use of undeclared identifier|unknown type name|'
-                 r'no template named) \'(?P<symbol>[^\']+)\'')
-  diagnosis = """
-'%(symbol)s' is defined by Google Mock in the testing namespace.
-Did you forget to write
-  using testing::%(symbol)s;
-?"""
-  for m in (list(_FindAllMatches(gcc_regex, msg)) +
-            list(_FindAllMatches(clang_regex, msg))):
-    symbol = m.groupdict()['symbol']
-    if symbol in _COMMON_GMOCK_SYMBOLS:
-      yield ('NUS', 'Need to Use Symbol', diagnosis % m.groupdict())
-
-
-def _NeedToUseReturnNullDiagnoser(msg):
-  """Diagnoses the NRNULL disease, given the error messages by the compiler."""
-
-  gcc_regex = ('instantiated from \'testing::internal::ReturnAction<R>'
-               '::operator testing::Action<Func>\(\) const.*\n' +
-               _GCC_FILE_LINE_RE + r'instantiated from here\n'
-               r'.*error: no matching function for call to \'ImplicitCast_\('
-               r'(:?long )?int&\)')
-  clang_regex = (r'\bgmock-actions.h:.* error: no matching function for '
-                 r'call to \'ImplicitCast_\'\r?\n'
-                 r'(.*\n)*?' +
-                 _CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
-                 r'of function template specialization '
-                 r'\'testing::internal::ReturnAction<(int|long)>::operator '
-                 r'Action<(?P<type>.*)\(\)>\' requested here')
-  diagnosis = """
-You are probably calling Return(NULL) and the compiler isn't sure how to turn
-NULL into %(type)s. Use ReturnNull() instead.
-Note: the line number may be off; please fix all instances of Return(NULL)."""
-  return _GenericDiagnoser(
-      'NRNULL', 'Need to use ReturnNull',
-      [(clang_regex, diagnosis),
-       (gcc_regex, diagnosis % {'type': 'the right type'})],
-      msg)
-
-
-def _TypeInTemplatedBaseDiagnoser(msg):
-  """Diagnoses the TTB disease, given the error messages by the compiler."""
-
-  # This version works when the type is used as the mock function's return
-  # type.
-  gcc_4_3_1_regex_type_in_retval = (
-      r'In member function \'int .*\n' + _GCC_FILE_LINE_RE +
-      r'error: a function call cannot appear in a constant-expression')
-  gcc_4_4_0_regex_type_in_retval = (
-      r'error: a function call cannot appear in a constant-expression'
-      + _GCC_FILE_LINE_RE + r'error: template argument 1 is invalid\n')
-  # This version works when the type is used as the mock function's sole
-  # parameter type.
-  gcc_regex_type_of_sole_param = (
-      _GCC_FILE_LINE_RE +
-      r'error: \'(?P<type>.+)\' was not declared in this scope\n'
-      r'.*error: template argument 1 is invalid\n')
-  # This version works when the type is used as a parameter of a mock
-  # function that has multiple parameters.
-  gcc_regex_type_of_a_param = (
-      r'error: expected `;\' before \'::\' token\n'
-      + _GCC_FILE_LINE_RE +
-      r'error: \'(?P<type>.+)\' was not declared in this scope\n'
-      r'.*error: template argument 1 is invalid\n'
-      r'.*error: \'.+\' was not declared in this scope')
-  clang_regex_type_of_retval_or_sole_param = (
-      _CLANG_FILE_LINE_RE +
-      r'error: use of undeclared identifier \'(?P<type>.*)\'\n'
-      r'(.*\n)*?'
-      r'(?P=file):(?P=line):\d+: error: '
-      r'non-friend class member \'Result\' cannot have a qualified name'
-      )
-  clang_regex_type_of_a_param = (
-      _CLANG_FILE_LINE_RE +
-      r'error: C\+\+ requires a type specifier for all declarations\n'
-      r'(.*\n)*?'
-      r'(?P=file):(?P=line):(?P=column): error: '
-      r'C\+\+ requires a type specifier for all declarations'
-      )
-  clang_regex_unknown_type = (
-      _CLANG_FILE_LINE_RE +
-      r'error: unknown type name \'(?P<type>[^\']+)\''
-      )
-
-  diagnosis = """
-In a mock class template, types or typedefs defined in the base class
-template are *not* automatically visible.  This is how C++ works.  Before
-you can use a type or typedef named %(type)s defined in base class Base<T>, you
-need to make it visible.  One way to do it is:
-
-  typedef typename Base<T>::%(type)s %(type)s;"""
-
-  for diag in _GenericDiagnoser(
-      'TTB', 'Type in Template Base',
-      [(gcc_4_3_1_regex_type_in_retval, diagnosis % {'type': 'Foo'}),
-       (gcc_4_4_0_regex_type_in_retval, diagnosis % {'type': 'Foo'}),
-       (gcc_regex_type_of_sole_param, diagnosis),
-       (gcc_regex_type_of_a_param, diagnosis),
-       (clang_regex_type_of_retval_or_sole_param, diagnosis),
-       (clang_regex_type_of_a_param, diagnosis % {'type': 'Foo'})],
-      msg):
-    yield diag
-  # Avoid overlap with the NUS pattern.
-  for m in _FindAllMatches(clang_regex_unknown_type, msg):
-    type_ = m.groupdict()['type']
-    if type_ not in _COMMON_GMOCK_SYMBOLS:
-      yield ('TTB', 'Type in Template Base', diagnosis % m.groupdict())
-
-
-def _WrongMockMethodMacroDiagnoser(msg):
-  """Diagnoses the WMM disease, given the error messages by the compiler."""
-
-  gcc_regex = (_GCC_FILE_LINE_RE +
-               r'.*this_method_does_not_take_(?P<wrong_args>\d+)_argument.*\n'
-               r'.*\n'
-               r'.*candidates are.*FunctionMocker<[^>]+A(?P<args>\d+)\)>')
-  clang_regex = (_CLANG_NON_GMOCK_FILE_LINE_RE +
-                 r'error:.*array.*negative.*r?\n'
-                 r'(.*\n)*?'
-                 r'(?P=file):(?P=line):(?P=column): error: too few arguments '
-                 r'to function call, expected (?P<args>\d+), '
-                 r'have (?P<wrong_args>\d+)')
-  clang11_re = (_CLANG_NON_GMOCK_FILE_LINE_RE +
-                r'.*this_method_does_not_take_'
-                r'(?P<wrong_args>\d+)_argument.*')
-  diagnosis = """
-You are using MOCK_METHOD%(wrong_args)s to define a mock method that has
-%(args)s arguments. Use MOCK_METHOD%(args)s (or MOCK_CONST_METHOD%(args)s,
-MOCK_METHOD%(args)s_T, MOCK_CONST_METHOD%(args)s_T as appropriate) instead."""
-  return _GenericDiagnoser('WMM', 'Wrong MOCK_METHODn Macro',
-                           [(gcc_regex, diagnosis),
-                            (clang11_re, diagnosis % {'wrong_args': 'm',
-                                                      'args': 'n'}),
-                            (clang_regex, diagnosis)],
-                           msg)
-
-
-def _WrongParenPositionDiagnoser(msg):
-  """Diagnoses the WPP disease, given the error messages by the compiler."""
-
-  gcc_regex = (_GCC_FILE_LINE_RE +
-               r'error:.*testing::internal::MockSpec<.* has no member named \''
-               r'(?P<method>\w+)\'')
-  clang_regex = (_CLANG_NON_GMOCK_FILE_LINE_RE +
-                 r'error: no member named \'(?P<method>\w+)\' in '
-                 r'\'testing::internal::MockSpec<.*>\'')
-  diagnosis = """
-The closing parenthesis of ON_CALL or EXPECT_CALL should be *before*
-".%(method)s".  For example, you should write:
-  EXPECT_CALL(my_mock, Foo(_)).%(method)s(...);
-instead of:
-  EXPECT_CALL(my_mock, Foo(_).%(method)s(...));"""
-  return _GenericDiagnoser('WPP', 'Wrong Parenthesis Position',
-                           [(gcc_regex, diagnosis),
-                            (clang_regex, diagnosis)],
-                           msg)
-
-
-_DIAGNOSERS = [
-    _IncompleteByReferenceArgumentDiagnoser,
-    _MockObjectPointerDiagnoser,
-    _NeedToReturnNothingDiagnoser,
-    _NeedToReturnReferenceDiagnoser,
-    _NeedToReturnSomethingDiagnoser,
-    _NeedToUseReturnNullDiagnoser,
-    _NeedToUseSymbolDiagnoser,
-    _OverloadedFunctionActionDiagnoser,
-    _OverloadedFunctionMatcherDiagnoser,
-    _OverloadedMethodActionDiagnoser,
-    _TypeInTemplatedBaseDiagnoser,
-    _WrongMockMethodMacroDiagnoser,
-    _WrongParenPositionDiagnoser,
-    ]
-
-
-def Diagnose(msg):
-  """Generates all possible diagnoses given the compiler error message."""
-
-  msg = re.sub(r'\x1b\[[^m]*m', '', msg)  # Strips all color formatting.
-  # Assuming the string is using the UTF-8 encoding, replaces the left and
-  # the right single quote characters with apostrophes.
-  msg = re.sub(r'(\xe2\x80\x98|\xe2\x80\x99)', "'", msg)
-
-  diagnoses = []
-  for diagnoser in _DIAGNOSERS:
-    for diag in diagnoser(msg):
-      diagnosis = '[%s - %s]\n%s' % diag
-      if not diagnosis in diagnoses:
-        diagnoses.append(diagnosis)
-  return diagnoses
-
-
-def main():
-  print ('Google Mock Doctor v%s - '
-         'diagnoses problems in code using Google Mock.' % _VERSION)
-
-  if sys.stdin.isatty():
-    print ('Please copy and paste the compiler errors here.  Press c-D when '
-           'you are done:')
-  else:
-    print ('Waiting for compiler errors on stdin . . .')
-
-  msg = sys.stdin.read().strip()
-  diagnoses = Diagnose(msg)
-  count = len(diagnoses)
-  if not count:
-    print ("""
-Your compiler complained:
-8<------------------------------------------------------------
-%s
------------------------------------------------------------->8
-
-Uh-oh, I'm not smart enough to figure out what the problem is. :-(
-However...
-If you send your source code and the compiler's error messages to
-%s, you can be helped and I can get smarter --
-win-win for us!""" % (msg, _EMAIL))
-  else:
-    print ('------------------------------------------------------------')
-    print ('Your code appears to have the following',)
-    if count > 1:
-      print ('%s diseases:' % (count,))
-    else:
-      print ('disease:')
-    i = 0
-    for d in diagnoses:
-      i += 1
-      if count > 1:
-        print ('\n#%s:' % (i,))
-      print (d)
-    print ("""
-How did I do?  If you think I'm wrong or unhelpful, please send your
-source code and the compiler's error messages to %s.
-Then you can be helped and I can get smarter -- I promise I won't be upset!""" %
-           _EMAIL)
-
-
-if __name__ == '__main__':
-  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload.py
deleted file mode 100755
index 6e6f9a14..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload.py
+++ /dev/null
@@ -1,1387 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2007 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Tool for uploading diffs from a version control system to the codereview app.
-
-Usage summary: upload.py [options] [-- diff_options]
-
-Diff options are passed to the diff command of the underlying system.
-
-Supported version control systems:
-  Git
-  Mercurial
-  Subversion
-
-It is important for Git/Mercurial users to specify a tree/node/branch to diff
-against by using the '--rev' option.
-"""
-# This code is derived from appcfg.py in the App Engine SDK (open source),
-# and from ASPN recipe #146306.
-
-import cookielib
-import getpass
-import logging
-import md5
-import mimetypes
-import optparse
-import os
-import re
-import socket
-import subprocess
-import sys
-import urllib
-import urllib2
-import urlparse
-
-try:
-  import readline
-except ImportError:
-  pass
-
-# The logging verbosity:
-#  0: Errors only.
-#  1: Status messages.
-#  2: Info logs.
-#  3: Debug logs.
-verbosity = 1
-
-# Max size of patch or base file.
-MAX_UPLOAD_SIZE = 900 * 1024
-
-
-def GetEmail(prompt):
-  """Prompts the user for their email address and returns it.
-
-  The last used email address is saved to a file and offered up as a suggestion
-  to the user. If the user presses enter without typing in anything the last
-  used email address is used. If the user enters a new address, it is saved
-  for next time we prompt.
-
-  """
-  last_email_file_name = os.path.expanduser("~/.last_codereview_email_address")
-  last_email = ""
-  if os.path.exists(last_email_file_name):
-    try:
-      last_email_file = open(last_email_file_name, "r")
-      last_email = last_email_file.readline().strip("\n")
-      last_email_file.close()
-      prompt += " [%s]" % last_email
-    except IOError, e:
-      pass
-  email = raw_input(prompt + ": ").strip()
-  if email:
-    try:
-      last_email_file = open(last_email_file_name, "w")
-      last_email_file.write(email)
-      last_email_file.close()
-    except IOError, e:
-      pass
-  else:
-    email = last_email
-  return email
-
-
-def StatusUpdate(msg):
-  """Print a status message to stdout.
-
-  If 'verbosity' is greater than 0, print the message.
-
-  Args:
-    msg: The string to print.
-  """
-  if verbosity > 0:
-    print msg
-
-
-def ErrorExit(msg):
-  """Print an error message to stderr and exit."""
-  print >>sys.stderr, msg
-  sys.exit(1)
-
-
-class ClientLoginError(urllib2.HTTPError):
-  """Raised to indicate there was an error authenticating with ClientLogin."""
-
-  def __init__(self, url, code, msg, headers, args):
-    urllib2.HTTPError.__init__(self, url, code, msg, headers, None)
-    self.args = args
-    self.reason = args["Error"]
-
-
-class AbstractRpcServer(object):
-  """Provides a common interface for a simple RPC server."""
-
-  def __init__(self, host, auth_function, host_override=None, extra_headers={},
-               save_cookies=False):
-    """Creates a new HttpRpcServer.
-
-    Args:
-      host: The host to send requests to.
-      auth_function: A function that takes no arguments and returns an
-        (email, password) tuple when called. Will be called if authentication
-        is required.
-      host_override: The host header to send to the server (defaults to host).
-      extra_headers: A dict of extra headers to append to every request.
-      save_cookies: If True, save the authentication cookies to local disk.
-        If False, use an in-memory cookiejar instead.  Subclasses must
-        implement this functionality.  Defaults to False.
-    """
-    self.host = host
-    self.host_override = host_override
-    self.auth_function = auth_function
-    self.authenticated = False
-    self.extra_headers = extra_headers
-    self.save_cookies = save_cookies
-    self.opener = self._GetOpener()
-    if self.host_override:
-      logging.info("Server: %s; Host: %s", self.host, self.host_override)
-    else:
-      logging.info("Server: %s", self.host)
-
-  def _GetOpener(self):
-    """Returns an OpenerDirector for making HTTP requests.
-
-    Returns:
-      A urllib2.OpenerDirector object.
-    """
-    raise NotImplementedError()
-
-  def _CreateRequest(self, url, data=None):
-    """Creates a new urllib request."""
-    logging.debug("Creating request for: '%s' with payload:\n%s", url, data)
-    req = urllib2.Request(url, data=data)
-    if self.host_override:
-      req.add_header("Host", self.host_override)
-    for key, value in self.extra_headers.iteritems():
-      req.add_header(key, value)
-    return req
-
-  def _GetAuthToken(self, email, password):
-    """Uses ClientLogin to authenticate the user, returning an auth token.
-
-    Args:
-      email:    The user's email address
-      password: The user's password
-
-    Raises:
-      ClientLoginError: If there was an error authenticating with ClientLogin.
-      HTTPError: If there was some other form of HTTP error.
-
-    Returns:
-      The authentication token returned by ClientLogin.
-    """
-    account_type = "GOOGLE"
-    if self.host.endswith(".google.com"):
-      # Needed for use inside Google.
-      account_type = "HOSTED"
-    req = self._CreateRequest(
-        url="https://www.google.com/accounts/ClientLogin",
-        data=urllib.urlencode({
-            "Email": email,
-            "Passwd": password,
-            "service": "ah",
-            "source": "rietveld-codereview-upload",
-            "accountType": account_type,
-        }),
-    )
-    try:
-      response = self.opener.open(req)
-      response_body = response.read()
-      response_dict = dict(x.split("=")
-                           for x in response_body.split("\n") if x)
-      return response_dict["Auth"]
-    except urllib2.HTTPError, e:
-      if e.code == 403:
-        body = e.read()
-        response_dict = dict(x.split("=", 1) for x in body.split("\n") if x)
-        raise ClientLoginError(req.get_full_url(), e.code, e.msg,
-                               e.headers, response_dict)
-      else:
-        raise
-
-  def _GetAuthCookie(self, auth_token):
-    """Fetches authentication cookies for an authentication token.
-
-    Args:
-      auth_token: The authentication token returned by ClientLogin.
-
-    Raises:
-      HTTPError: If there was an error fetching the authentication cookies.
-    """
-    # This is a dummy value to allow us to identify when we're successful.
-    continue_location = "http://localhost/"
-    args = {"continue": continue_location, "auth": auth_token}
-    req = self._CreateRequest("http://%s/_ah/login?%s" %
-                              (self.host, urllib.urlencode(args)))
-    try:
-      response = self.opener.open(req)
-    except urllib2.HTTPError, e:
-      response = e
-    if (response.code != 302 or
-        response.info()["location"] != continue_location):
-      raise urllib2.HTTPError(req.get_full_url(), response.code, response.msg,
-                              response.headers, response.fp)
-    self.authenticated = True
-
-  def _Authenticate(self):
-    """Authenticates the user.
-
-    The authentication process works as follows:
-     1) We get a username and password from the user
-     2) We use ClientLogin to obtain an AUTH token for the user
-        (see http://code.google.com/apis/accounts/AuthForInstalledApps.html).
-     3) We pass the auth token to /_ah/login on the server to obtain an
-        authentication cookie. If login was successful, it tries to redirect
-        us to the URL we provided.
-
-    If we attempt to access the upload API without first obtaining an
-    authentication cookie, it returns a 401 response and directs us to
-    authenticate ourselves with ClientLogin.
-    """
-    for i in range(3):
-      credentials = self.auth_function()
-      try:
-        auth_token = self._GetAuthToken(credentials[0], credentials[1])
-      except ClientLoginError, e:
-        if e.reason == "BadAuthentication":
-          print >>sys.stderr, "Invalid username or password."
-          continue
-        if e.reason == "CaptchaRequired":
-          print >>sys.stderr, (
-              "Please go to\n"
-              "https://www.google.com/accounts/DisplayUnlockCaptcha\n"
-              "and verify you are a human.  Then try again.")
-          break
-        if e.reason == "NotVerified":
-          print >>sys.stderr, "Account not verified."
-          break
-        if e.reason == "TermsNotAgreed":
-          print >>sys.stderr, "User has not agreed to TOS."
-          break
-        if e.reason == "AccountDeleted":
-          print >>sys.stderr, "The user account has been deleted."
-          break
-        if e.reason == "AccountDisabled":
-          print >>sys.stderr, "The user account has been disabled."
-          break
-        if e.reason == "ServiceDisabled":
-          print >>sys.stderr, ("The user's access to the service has been "
-                               "disabled.")
-          break
-        if e.reason == "ServiceUnavailable":
-          print >>sys.stderr, "The service is not available; try again later."
-          break
-        raise
-      self._GetAuthCookie(auth_token)
-      return
-
-  def Send(self, request_path, payload=None,
-           content_type="application/octet-stream",
-           timeout=None,
-           **kwargs):
-    """Sends an RPC and returns the response.
-
-    Args:
-      request_path: The path to send the request to, eg /api/appversion/create.
-      payload: The body of the request, or None to send an empty request.
-      content_type: The Content-Type header to use.
-      timeout: timeout in seconds; default None i.e. no timeout.
-        (Note: for large requests on OS X, the timeout doesn't work right.)
-      kwargs: Any keyword arguments are converted into query string parameters.
-
-    Returns:
-      The response body, as a string.
-    """
-    # TODO: Don't require authentication.  Let the server say
-    # whether it is necessary.
-    if not self.authenticated:
-      self._Authenticate()
-
-    old_timeout = socket.getdefaulttimeout()
-    socket.setdefaulttimeout(timeout)
-    try:
-      tries = 0
-      while True:
-        tries += 1
-        args = dict(kwargs)
-        url = "http://%s%s" % (self.host, request_path)
-        if args:
-          url += "?" + urllib.urlencode(args)
-        req = self._CreateRequest(url=url, data=payload)
-        req.add_header("Content-Type", content_type)
-        try:
-          f = self.opener.open(req)
-          response = f.read()
-          f.close()
-          return response
-        except urllib2.HTTPError, e:
-          if tries > 3:
-            raise
-          elif e.code == 401:
-            self._Authenticate()
-##           elif e.code >= 500 and e.code < 600:
-##             # Server Error - try again.
-##             continue
-          else:
-            raise
-    finally:
-      socket.setdefaulttimeout(old_timeout)
-
-
-class HttpRpcServer(AbstractRpcServer):
-  """Provides a simplified RPC-style interface for HTTP requests."""
-
-  def _Authenticate(self):
-    """Save the cookie jar after authentication."""
-    super(HttpRpcServer, self)._Authenticate()
-    if self.save_cookies:
-      StatusUpdate("Saving authentication cookies to %s" % self.cookie_file)
-      self.cookie_jar.save()
-
-  def _GetOpener(self):
-    """Returns an OpenerDirector that supports cookies and ignores redirects.
-
-    Returns:
-      A urllib2.OpenerDirector object.
-    """
-    opener = urllib2.OpenerDirector()
-    opener.add_handler(urllib2.ProxyHandler())
-    opener.add_handler(urllib2.UnknownHandler())
-    opener.add_handler(urllib2.HTTPHandler())
-    opener.add_handler(urllib2.HTTPDefaultErrorHandler())
-    opener.add_handler(urllib2.HTTPSHandler())
-    opener.add_handler(urllib2.HTTPErrorProcessor())
-    if self.save_cookies:
-      self.cookie_file = os.path.expanduser("~/.codereview_upload_cookies")
-      self.cookie_jar = cookielib.MozillaCookieJar(self.cookie_file)
-      if os.path.exists(self.cookie_file):
-        try:
-          self.cookie_jar.load()
-          self.authenticated = True
-          StatusUpdate("Loaded authentication cookies from %s" %
-                       self.cookie_file)
-        except (cookielib.LoadError, IOError):
-          # Failed to load cookies - just ignore them.
-          pass
-      else:
-        # Create an empty cookie file with mode 600
-        fd = os.open(self.cookie_file, os.O_CREAT, 0600)
-        os.close(fd)
-      # Always chmod the cookie file
-      os.chmod(self.cookie_file, 0600)
-    else:
-      # Don't save cookies across runs of update.py.
-      self.cookie_jar = cookielib.CookieJar()
-    opener.add_handler(urllib2.HTTPCookieProcessor(self.cookie_jar))
-    return opener
-
-
-parser = optparse.OptionParser(usage="%prog [options] [-- diff_options]")
-parser.add_option("-y", "--assume_yes", action="store_true",
-                  dest="assume_yes", default=False,
-                  help="Assume that the answer to yes/no questions is 'yes'.")
-# Logging
-group = parser.add_option_group("Logging options")
-group.add_option("-q", "--quiet", action="store_const", const=0,
-                 dest="verbose", help="Print errors only.")
-group.add_option("-v", "--verbose", action="store_const", const=2,
-                 dest="verbose", default=1,
-                 help="Print info level logs (default).")
-group.add_option("--noisy", action="store_const", const=3,
-                 dest="verbose", help="Print all logs.")
-# Review server
-group = parser.add_option_group("Review server options")
-group.add_option("-s", "--server", action="store", dest="server",
-                 default="codereview.appspot.com",
-                 metavar="SERVER",
-                 help=("The server to upload to. The format is host[:port]. "
-                       "Defaults to 'codereview.appspot.com'."))
-group.add_option("-e", "--email", action="store", dest="email",
-                 metavar="EMAIL", default=None,
-                 help="The username to use. Will prompt if omitted.")
-group.add_option("-H", "--host", action="store", dest="host",
-                 metavar="HOST", default=None,
-                 help="Overrides the Host header sent with all RPCs.")
-group.add_option("--no_cookies", action="store_false",
-                 dest="save_cookies", default=True,
-                 help="Do not save authentication cookies to local disk.")
-# Issue
-group = parser.add_option_group("Issue options")
-group.add_option("-d", "--description", action="store", dest="description",
-                 metavar="DESCRIPTION", default=None,
-                 help="Optional description when creating an issue.")
-group.add_option("-f", "--description_file", action="store",
-                 dest="description_file", metavar="DESCRIPTION_FILE",
-                 default=None,
-                 help="Optional path of a file that contains "
-                      "the description when creating an issue.")
-group.add_option("-r", "--reviewers", action="store", dest="reviewers",
-                 metavar="REVIEWERS", default=None,
-                 help="Add reviewers (comma separated email addresses).")
-group.add_option("--cc", action="store", dest="cc",
-                 metavar="CC", default=None,
-                 help="Add CC (comma separated email addresses).")
-# Upload options
-group = parser.add_option_group("Patch options")
-group.add_option("-m", "--message", action="store", dest="message",
-                 metavar="MESSAGE", default=None,
-                 help="A message to identify the patch. "
-                      "Will prompt if omitted.")
-group.add_option("-i", "--issue", type="int", action="store",
-                 metavar="ISSUE", default=None,
-                 help="Issue number to which to add. Defaults to new issue.")
-group.add_option("--download_base", action="store_true",
-                 dest="download_base", default=False,
-                 help="Base files will be downloaded by the server "
-                 "(side-by-side diffs may not work on files with CRs).")
-group.add_option("--rev", action="store", dest="revision",
-                 metavar="REV", default=None,
-                 help="Branch/tree/revision to diff against (used by DVCS).")
-group.add_option("--send_mail", action="store_true",
-                 dest="send_mail", default=False,
-                 help="Send notification email to reviewers.")
-
-
-def GetRpcServer(options):
-  """Returns an instance of an AbstractRpcServer.
-
-  Returns:
-    A new AbstractRpcServer, on which RPC calls can be made.
-  """
-
-  rpc_server_class = HttpRpcServer
-
-  def GetUserCredentials():
-    """Prompts the user for a username and password."""
-    email = options.email
-    if email is None:
-      email = GetEmail("Email (login for uploading to %s)" % options.server)
-    password = getpass.getpass("Password for %s: " % email)
-    return (email, password)
-
-  # If this is the dev_appserver, use fake authentication.
-  host = (options.host or options.server).lower()
-  if host == "localhost" or host.startswith("localhost:"):
-    email = options.email
-    if email is None:
-      email = "test@example.com"
-      logging.info("Using debug user %s.  Override with --email" % email)
-    server = rpc_server_class(
-        options.server,
-        lambda: (email, "password"),
-        host_override=options.host,
-        extra_headers={"Cookie":
-                       'dev_appserver_login="%s:False"' % email},
-        save_cookies=options.save_cookies)
-    # Don't try to talk to ClientLogin.
-    server.authenticated = True
-    return server
-
-  return rpc_server_class(options.server, GetUserCredentials,
-                          host_override=options.host,
-                          save_cookies=options.save_cookies)
-
-
-def EncodeMultipartFormData(fields, files):
-  """Encode form fields for multipart/form-data.
-
-  Args:
-    fields: A sequence of (name, value) elements for regular form fields.
-    files: A sequence of (name, filename, value) elements for data to be
-           uploaded as files.
-  Returns:
-    (content_type, body) ready for httplib.HTTP instance.
-
-  Source:
-    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/146306
-  """
-  BOUNDARY = '-M-A-G-I-C---B-O-U-N-D-A-R-Y-'
-  CRLF = '\r\n'
-  lines = []
-  for (key, value) in fields:
-    lines.append('--' + BOUNDARY)
-    lines.append('Content-Disposition: form-data; name="%s"' % key)
-    lines.append('')
-    lines.append(value)
-  for (key, filename, value) in files:
-    lines.append('--' + BOUNDARY)
-    lines.append('Content-Disposition: form-data; name="%s"; filename="%s"' %
-             (key, filename))
-    lines.append('Content-Type: %s' % GetContentType(filename))
-    lines.append('')
-    lines.append(value)
-  lines.append('--' + BOUNDARY + '--')
-  lines.append('')
-  body = CRLF.join(lines)
-  content_type = 'multipart/form-data; boundary=%s' % BOUNDARY
-  return content_type, body
-
-
-def GetContentType(filename):
-  """Helper to guess the content-type from the filename."""
-  return mimetypes.guess_type(filename)[0] or 'application/octet-stream'
-
-
-# Use a shell for subcommands on Windows to get a PATH search.
-use_shell = sys.platform.startswith("win")
-
-def RunShellWithReturnCode(command, print_output=False,
-                           universal_newlines=True):
-  """Executes a command and returns the output from stdout and the return code.
-
-  Args:
-    command: Command to execute.
-    print_output: If True, the output is printed to stdout.
-                  If False, both stdout and stderr are ignored.
-    universal_newlines: Use universal_newlines flag (default: True).
-
-  Returns:
-    Tuple (output, return code)
-  """
-  logging.info("Running %s", command)
-  p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                       shell=use_shell, universal_newlines=universal_newlines)
-  if print_output:
-    output_array = []
-    while True:
-      line = p.stdout.readline()
-      if not line:
-        break
-      print line.strip("\n")
-      output_array.append(line)
-    output = "".join(output_array)
-  else:
-    output = p.stdout.read()
-  p.wait()
-  errout = p.stderr.read()
-  if print_output and errout:
-    print >>sys.stderr, errout
-  p.stdout.close()
-  p.stderr.close()
-  return output, p.returncode
-
-
-def RunShell(command, silent_ok=False, universal_newlines=True,
-             print_output=False):
-  data, retcode = RunShellWithReturnCode(command, print_output,
-                                         universal_newlines)
-  if retcode:
-    ErrorExit("Got error status from %s:\n%s" % (command, data))
-  if not silent_ok and not data:
-    ErrorExit("No output from %s" % command)
-  return data
-
-
-class VersionControlSystem(object):
-  """Abstract base class providing an interface to the VCS."""
-
-  def __init__(self, options):
-    """Constructor.
-
-    Args:
-      options: Command line options.
-    """
-    self.options = options
-
-  def GenerateDiff(self, args):
-    """Return the current diff as a string.
-
-    Args:
-      args: Extra arguments to pass to the diff command.
-    """
-    raise NotImplementedError(
-        "abstract method -- subclass %s must override" % self.__class__)
-
-  def GetUnknownFiles(self):
-    """Return a list of files unknown to the VCS."""
-    raise NotImplementedError(
-        "abstract method -- subclass %s must override" % self.__class__)
-
-  def CheckForUnknownFiles(self):
-    """Show an "are you sure?" prompt if there are unknown files."""
-    unknown_files = self.GetUnknownFiles()
-    if unknown_files:
-      print "The following files are not added to version control:"
-      for line in unknown_files:
-        print line
-      prompt = "Are you sure to continue?(y/N) "
-      answer = raw_input(prompt).strip()
-      if answer != "y":
-        ErrorExit("User aborted")
-
-  def GetBaseFile(self, filename):
-    """Get the content of the upstream version of a file.
-
-    Returns:
-      A tuple (base_content, new_content, is_binary, status)
-        base_content: The contents of the base file.
-        new_content: For text files, this is empty.  For binary files, this is
-          the contents of the new file, since the diff output won't contain
-          information to reconstruct the current file.
-        is_binary: True iff the file is binary.
-        status: The status of the file.
-    """
-
-    raise NotImplementedError(
-        "abstract method -- subclass %s must override" % self.__class__)
-
-
-  def GetBaseFiles(self, diff):
-    """Helper that calls GetBase file for each file in the patch.
-
-    Returns:
-      A dictionary that maps from filename to GetBaseFile's tuple.  Filenames
-      are retrieved based on lines that start with "Index:" or
-      "Property changes on:".
-    """
-    files = {}
-    for line in diff.splitlines(True):
-      if line.startswith('Index:') or line.startswith('Property changes on:'):
-        unused, filename = line.split(':', 1)
-        # On Windows if a file has property changes its filename uses '\'
-        # instead of '/'.
-        filename = filename.strip().replace('\\', '/')
-        files[filename] = self.GetBaseFile(filename)
-    return files
-
-
-  def UploadBaseFiles(self, issue, rpc_server, patch_list, patchset, options,
-                      files):
-    """Uploads the base files (and if necessary, the current ones as well)."""
-
-    def UploadFile(filename, file_id, content, is_binary, status, is_base):
-      """Uploads a file to the server."""
-      file_too_large = False
-      if is_base:
-        type = "base"
-      else:
-        type = "current"
-      if len(content) > MAX_UPLOAD_SIZE:
-        print ("Not uploading the %s file for %s because it's too large." %
-               (type, filename))
-        file_too_large = True
-        content = ""
-      checksum = md5.new(content).hexdigest()
-      if options.verbose > 0 and not file_too_large:
-        print "Uploading %s file for %s" % (type, filename)
-      url = "/%d/upload_content/%d/%d" % (int(issue), int(patchset), file_id)
-      form_fields = [("filename", filename),
-                     ("status", status),
-                     ("checksum", checksum),
-                     ("is_binary", str(is_binary)),
-                     ("is_current", str(not is_base)),
-                    ]
-      if file_too_large:
-        form_fields.append(("file_too_large", "1"))
-      if options.email:
-        form_fields.append(("user", options.email))
-      ctype, body = EncodeMultipartFormData(form_fields,
-                                            [("data", filename, content)])
-      response_body = rpc_server.Send(url, body,
-                                      content_type=ctype)
-      if not response_body.startswith("OK"):
-        StatusUpdate("  --> %s" % response_body)
-        sys.exit(1)
-
-    patches = dict()
-    [patches.setdefault(v, k) for k, v in patch_list]
-    for filename in patches.keys():
-      base_content, new_content, is_binary, status = files[filename]
-      file_id_str = patches.get(filename)
-      if file_id_str.find("nobase") != -1:
-        base_content = None
-        file_id_str = file_id_str[file_id_str.rfind("_") + 1:]
-      file_id = int(file_id_str)
-      if base_content != None:
-        UploadFile(filename, file_id, base_content, is_binary, status, True)
-      if new_content != None:
-        UploadFile(filename, file_id, new_content, is_binary, status, False)
-
-  def IsImage(self, filename):
-    """Returns true if the filename has an image extension."""
-    mimetype =  mimetypes.guess_type(filename)[0]
-    if not mimetype:
-      return False
-    return mimetype.startswith("image/")
-
-
-class SubversionVCS(VersionControlSystem):
-  """Implementation of the VersionControlSystem interface for Subversion."""
-
-  def __init__(self, options):
-    super(SubversionVCS, self).__init__(options)
-    if self.options.revision:
-      match = re.match(r"(\d+)(:(\d+))?", self.options.revision)
-      if not match:
-        ErrorExit("Invalid Subversion revision %s." % self.options.revision)
-      self.rev_start = match.group(1)
-      self.rev_end = match.group(3)
-    else:
-      self.rev_start = self.rev_end = None
-    # Cache output from "svn list -r REVNO dirname".
-    # Keys: dirname, Values: 2-tuple (ouput for start rev and end rev).
-    self.svnls_cache = {}
-    # SVN base URL is required to fetch files deleted in an older revision.
-    # Result is cached to not guess it over and over again in GetBaseFile().
-    required = self.options.download_base or self.options.revision is not None
-    self.svn_base = self._GuessBase(required)
-
-  def GuessBase(self, required):
-    """Wrapper for _GuessBase."""
-    return self.svn_base
-
-  def _GuessBase(self, required):
-    """Returns the SVN base URL.
-
-    Args:
-      required: If true, exits if the url can't be guessed, otherwise None is
-        returned.
-    """
-    info = RunShell(["svn", "info"])
-    for line in info.splitlines():
-      words = line.split()
-      if len(words) == 2 and words[0] == "URL:":
-        url = words[1]
-        scheme, netloc, path, params, query, fragment = urlparse.urlparse(url)
-        username, netloc = urllib.splituser(netloc)
-        if username:
-          logging.info("Removed username from base URL")
-        if netloc.endswith("svn.python.org"):
-          if netloc == "svn.python.org":
-            if path.startswith("/projects/"):
-              path = path[9:]
-          elif netloc != "pythondev@svn.python.org":
-            ErrorExit("Unrecognized Python URL: %s" % url)
-          base = "http://svn.python.org/view/*checkout*%s/" % path
-          logging.info("Guessed Python base = %s", base)
-        elif netloc.endswith("svn.collab.net"):
-          if path.startswith("/repos/"):
-            path = path[6:]
-          base = "http://svn.collab.net/viewvc/*checkout*%s/" % path
-          logging.info("Guessed CollabNet base = %s", base)
-        elif netloc.endswith(".googlecode.com"):
-          path = path + "/"
-          base = urlparse.urlunparse(("http", netloc, path, params,
-                                      query, fragment))
-          logging.info("Guessed Google Code base = %s", base)
-        else:
-          path = path + "/"
-          base = urlparse.urlunparse((scheme, netloc, path, params,
-                                      query, fragment))
-          logging.info("Guessed base = %s", base)
-        return base
-    if required:
-      ErrorExit("Can't find URL in output from svn info")
-    return None
-
-  def GenerateDiff(self, args):
-    cmd = ["svn", "diff"]
-    if self.options.revision:
-      cmd += ["-r", self.options.revision]
-    cmd.extend(args)
-    data = RunShell(cmd)
-    count = 0
-    for line in data.splitlines():
-      if line.startswith("Index:") or line.startswith("Property changes on:"):
-        count += 1
-        logging.info(line)
-    if not count:
-      ErrorExit("No valid patches found in output from svn diff")
-    return data
-
-  def _CollapseKeywords(self, content, keyword_str):
-    """Collapses SVN keywords."""
-    # svn cat translates keywords but svn diff doesn't. As a result of this
-    # behavior patching.PatchChunks() fails with a chunk mismatch error.
-    # This part was originally written by the Review Board development team
-    # who had the same problem (http://reviews.review-board.org/r/276/).
-    # Mapping of keywords to known aliases
-    svn_keywords = {
-      # Standard keywords
-      'Date':                ['Date', 'LastChangedDate'],
-      'Revision':            ['Revision', 'LastChangedRevision', 'Rev'],
-      'Author':              ['Author', 'LastChangedBy'],
-      'HeadURL':             ['HeadURL', 'URL'],
-      'Id':                  ['Id'],
-
-      # Aliases
-      'LastChangedDate':     ['LastChangedDate', 'Date'],
-      'LastChangedRevision': ['LastChangedRevision', 'Rev', 'Revision'],
-      'LastChangedBy':       ['LastChangedBy', 'Author'],
-      'URL':                 ['URL', 'HeadURL'],
-    }
-
-    def repl(m):
-       if m.group(2):
-         return "$%s::%s$" % (m.group(1), " " * len(m.group(3)))
-       return "$%s$" % m.group(1)
-    keywords = [keyword
-                for name in keyword_str.split(" ")
-                for keyword in svn_keywords.get(name, [])]
-    return re.sub(r"\$(%s):(:?)([^\$]+)\$" % '|'.join(keywords), repl, content)
-
-  def GetUnknownFiles(self):
-    status = RunShell(["svn", "status", "--ignore-externals"], silent_ok=True)
-    unknown_files = []
-    for line in status.split("\n"):
-      if line and line[0] == "?":
-        unknown_files.append(line)
-    return unknown_files
-
-  def ReadFile(self, filename):
-    """Returns the contents of a file."""
-    file = open(filename, 'rb')
-    result = ""
-    try:
-      result = file.read()
-    finally:
-      file.close()
-    return result
-
-  def GetStatus(self, filename):
-    """Returns the status of a file."""
-    if not self.options.revision:
-      status = RunShell(["svn", "status", "--ignore-externals", filename])
-      if not status:
-        ErrorExit("svn status returned no output for %s" % filename)
-      status_lines = status.splitlines()
-      # If file is in a cl, the output will begin with
-      # "\n--- Changelist 'cl_name':\n".  See
-      # http://svn.collab.net/repos/svn/trunk/notes/changelist-design.txt
-      if (len(status_lines) == 3 and
-          not status_lines[0] and
-          status_lines[1].startswith("--- Changelist")):
-        status = status_lines[2]
-      else:
-        status = status_lines[0]
-    # If we have a revision to diff against we need to run "svn list"
-    # for the old and the new revision and compare the results to get
-    # the correct status for a file.
-    else:
-      dirname, relfilename = os.path.split(filename)
-      if dirname not in self.svnls_cache:
-        cmd = ["svn", "list", "-r", self.rev_start, dirname or "."]
-        out, returncode = RunShellWithReturnCode(cmd)
-        if returncode:
-          ErrorExit("Failed to get status for %s." % filename)
-        old_files = out.splitlines()
-        args = ["svn", "list"]
-        if self.rev_end:
-          args += ["-r", self.rev_end]
-        cmd = args + [dirname or "."]
-        out, returncode = RunShellWithReturnCode(cmd)
-        if returncode:
-          ErrorExit("Failed to run command %s" % cmd)
-        self.svnls_cache[dirname] = (old_files, out.splitlines())
-      old_files, new_files = self.svnls_cache[dirname]
-      if relfilename in old_files and relfilename not in new_files:
-        status = "D   "
-      elif relfilename in old_files and relfilename in new_files:
-        status = "M   "
-      else:
-        status = "A   "
-    return status
-
-  def GetBaseFile(self, filename):
-    status = self.GetStatus(filename)
-    base_content = None
-    new_content = None
-
-    # If a file is copied its status will be "A  +", which signifies
-    # "addition-with-history".  See "svn st" for more information.  We need to
-    # upload the original file or else diff parsing will fail if the file was
-    # edited.
-    if status[0] == "A" and status[3] != "+":
-      # We'll need to upload the new content if we're adding a binary file
-      # since diff's output won't contain it.
-      mimetype = RunShell(["svn", "propget", "svn:mime-type", filename],
-                          silent_ok=True)
-      base_content = ""
-      is_binary = mimetype and not mimetype.startswith("text/")
-      if is_binary and self.IsImage(filename):
-        new_content = self.ReadFile(filename)
-    elif (status[0] in ("M", "D", "R") or
-          (status[0] == "A" and status[3] == "+") or  # Copied file.
-          (status[0] == " " and status[1] == "M")):  # Property change.
-      args = []
-      if self.options.revision:
-        url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
-      else:
-        # Don't change filename, it's needed later.
-        url = filename
-        args += ["-r", "BASE"]
-      cmd = ["svn"] + args + ["propget", "svn:mime-type", url]
-      mimetype, returncode = RunShellWithReturnCode(cmd)
-      if returncode:
-        # File does not exist in the requested revision.
-        # Reset mimetype, it contains an error message.
-        mimetype = ""
-      get_base = False
-      is_binary = mimetype and not mimetype.startswith("text/")
-      if status[0] == " ":
-        # Empty base content just to force an upload.
-        base_content = ""
-      elif is_binary:
-        if self.IsImage(filename):
-          get_base = True
-          if status[0] == "M":
-            if not self.rev_end:
-              new_content = self.ReadFile(filename)
-            else:
-              url = "%s/%s@%s" % (self.svn_base, filename, self.rev_end)
-              new_content = RunShell(["svn", "cat", url],
-                                     universal_newlines=True, silent_ok=True)
-        else:
-          base_content = ""
-      else:
-        get_base = True
-
-      if get_base:
-        if is_binary:
-          universal_newlines = False
-        else:
-          universal_newlines = True
-        if self.rev_start:
-          # "svn cat -r REV delete_file.txt" doesn't work. cat requires
-          # the full URL with "@REV" appended instead of using "-r" option.
-          url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
-          base_content = RunShell(["svn", "cat", url],
-                                  universal_newlines=universal_newlines,
-                                  silent_ok=True)
-        else:
-          base_content = RunShell(["svn", "cat", filename],
-                                  universal_newlines=universal_newlines,
-                                  silent_ok=True)
-        if not is_binary:
-          args = []
-          if self.rev_start:
-            url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
-          else:
-            url = filename
-            args += ["-r", "BASE"]
-          cmd = ["svn"] + args + ["propget", "svn:keywords", url]
-          keywords, returncode = RunShellWithReturnCode(cmd)
-          if keywords and not returncode:
-            base_content = self._CollapseKeywords(base_content, keywords)
-    else:
-      StatusUpdate("svn status returned unexpected output: %s" % status)
-      sys.exit(1)
-    return base_content, new_content, is_binary, status[0:5]
-
-
-class GitVCS(VersionControlSystem):
-  """Implementation of the VersionControlSystem interface for Git."""
-
-  def __init__(self, options):
-    super(GitVCS, self).__init__(options)
-    # Map of filename -> hash of base file.
-    self.base_hashes = {}
-
-  def GenerateDiff(self, extra_args):
-    # This is more complicated than svn's GenerateDiff because we must convert
-    # the diff output to include an svn-style "Index:" line as well as record
-    # the hashes of the base files, so we can upload them along with our diff.
-    if self.options.revision:
-      extra_args = [self.options.revision] + extra_args
-    gitdiff = RunShell(["git", "diff", "--full-index"] + extra_args)
-    svndiff = []
-    filecount = 0
-    filename = None
-    for line in gitdiff.splitlines():
-      match = re.match(r"diff --git a/(.*) b/.*$", line)
-      if match:
-        filecount += 1
-        filename = match.group(1)
-        svndiff.append("Index: %s\n" % filename)
-      else:
-        # The "index" line in a git diff looks like this (long hashes elided):
-        #   index 82c0d44..b2cee3f 100755
-        # We want to save the left hash, as that identifies the base file.
-        match = re.match(r"index (\w+)\.\.", line)
-        if match:
-          self.base_hashes[filename] = match.group(1)
-      svndiff.append(line + "\n")
-    if not filecount:
-      ErrorExit("No valid patches found in output from git diff")
-    return "".join(svndiff)
-
-  def GetUnknownFiles(self):
-    status = RunShell(["git", "ls-files", "--exclude-standard", "--others"],
-                      silent_ok=True)
-    return status.splitlines()
-
-  def GetBaseFile(self, filename):
-    hash = self.base_hashes[filename]
-    base_content = None
-    new_content = None
-    is_binary = False
-    if hash == "0" * 40:  # All-zero hash indicates no base file.
-      status = "A"
-      base_content = ""
-    else:
-      status = "M"
-      base_content, returncode = RunShellWithReturnCode(["git", "show", hash])
-      if returncode:
-        ErrorExit("Got error status from 'git show %s'" % hash)
-    return (base_content, new_content, is_binary, status)
-
-
-class MercurialVCS(VersionControlSystem):
-  """Implementation of the VersionControlSystem interface for Mercurial."""
-
-  def __init__(self, options, repo_dir):
-    super(MercurialVCS, self).__init__(options)
-    # Absolute path to repository (we can be in a subdir)
-    self.repo_dir = os.path.normpath(repo_dir)
-    # Compute the subdir
-    cwd = os.path.normpath(os.getcwd())
-    assert cwd.startswith(self.repo_dir)
-    self.subdir = cwd[len(self.repo_dir):].lstrip(r"\/")
-    if self.options.revision:
-      self.base_rev = self.options.revision
-    else:
-      self.base_rev = RunShell(["hg", "parent", "-q"]).split(':')[1].strip()
-
-  def _GetRelPath(self, filename):
-    """Get relative path of a file according to the current directory,
-    given its logical path in the repo."""
-    assert filename.startswith(self.subdir), filename
-    return filename[len(self.subdir):].lstrip(r"\/")
-
-  def GenerateDiff(self, extra_args):
-    # If no file specified, restrict to the current subdir
-    extra_args = extra_args or ["."]
-    cmd = ["hg", "diff", "--git", "-r", self.base_rev] + extra_args
-    data = RunShell(cmd, silent_ok=True)
-    svndiff = []
-    filecount = 0
-    for line in data.splitlines():
-      m = re.match("diff --git a/(\S+) b/(\S+)", line)
-      if m:
-        # Modify line to make it look like as it comes from svn diff.
-        # With this modification no changes on the server side are required
-        # to make upload.py work with Mercurial repos.
-        # NOTE: for proper handling of moved/copied files, we have to use
-        # the second filename.
-        filename = m.group(2)
-        svndiff.append("Index: %s" % filename)
-        svndiff.append("=" * 67)
-        filecount += 1
-        logging.info(line)
-      else:
-        svndiff.append(line)
-    if not filecount:
-      ErrorExit("No valid patches found in output from hg diff")
-    return "\n".join(svndiff) + "\n"
-
-  def GetUnknownFiles(self):
-    """Return a list of files unknown to the VCS."""
-    args = []
-    status = RunShell(["hg", "status", "--rev", self.base_rev, "-u", "."],
-        silent_ok=True)
-    unknown_files = []
-    for line in status.splitlines():
-      st, fn = line.split(" ", 1)
-      if st == "?":
-        unknown_files.append(fn)
-    return unknown_files
-
-  def GetBaseFile(self, filename):
-    # "hg status" and "hg cat" both take a path relative to the current subdir
-    # rather than to the repo root, but "hg diff" has given us the full path
-    # to the repo root.
-    base_content = ""
-    new_content = None
-    is_binary = False
-    oldrelpath = relpath = self._GetRelPath(filename)
-    # "hg status -C" returns two lines for moved/copied files, one otherwise
-    out = RunShell(["hg", "status", "-C", "--rev", self.base_rev, relpath])
-    out = out.splitlines()
-    # HACK: strip error message about missing file/directory if it isn't in
-    # the working copy
-    if out[0].startswith('%s: ' % relpath):
-      out = out[1:]
-    if len(out) > 1:
-      # Moved/copied => considered as modified, use old filename to
-      # retrieve base contents
-      oldrelpath = out[1].strip()
-      status = "M"
-    else:
-      status, _ = out[0].split(' ', 1)
-    if status != "A":
-      base_content = RunShell(["hg", "cat", "-r", self.base_rev, oldrelpath],
-        silent_ok=True)
-      is_binary = "\0" in base_content  # Mercurial's heuristic
-    if status != "R":
-      new_content = open(relpath, "rb").read()
-      is_binary = is_binary or "\0" in new_content
-    if is_binary and base_content:
-      # Fetch again without converting newlines
-      base_content = RunShell(["hg", "cat", "-r", self.base_rev, oldrelpath],
-        silent_ok=True, universal_newlines=False)
-    if not is_binary or not self.IsImage(relpath):
-      new_content = None
-    return base_content, new_content, is_binary, status
-
-
-# NOTE: The SplitPatch function is duplicated in engine.py, keep them in sync.
-def SplitPatch(data):
-  """Splits a patch into separate pieces for each file.
-
-  Args:
-    data: A string containing the output of svn diff.
-
-  Returns:
-    A list of 2-tuple (filename, text) where text is the svn diff output
-      pertaining to filename.
-  """
-  patches = []
-  filename = None
-  diff = []
-  for line in data.splitlines(True):
-    new_filename = None
-    if line.startswith('Index:'):
-      unused, new_filename = line.split(':', 1)
-      new_filename = new_filename.strip()
-    elif line.startswith('Property changes on:'):
-      unused, temp_filename = line.split(':', 1)
-      # When a file is modified, paths use '/' between directories, however
-      # when a property is modified '\' is used on Windows.  Make them the same
-      # otherwise the file shows up twice.
-      temp_filename = temp_filename.strip().replace('\\', '/')
-      if temp_filename != filename:
-        # File has property changes but no modifications, create a new diff.
-        new_filename = temp_filename
-    if new_filename:
-      if filename and diff:
-        patches.append((filename, ''.join(diff)))
-      filename = new_filename
-      diff = [line]
-      continue
-    if diff is not None:
-      diff.append(line)
-  if filename and diff:
-    patches.append((filename, ''.join(diff)))
-  return patches
-
-
-def UploadSeparatePatches(issue, rpc_server, patchset, data, options):
-  """Uploads a separate patch for each file in the diff output.
-
-  Returns a list of [patch_key, filename] for each file.
-  """
-  patches = SplitPatch(data)
-  rv = []
-  for patch in patches:
-    if len(patch[1]) > MAX_UPLOAD_SIZE:
-      print ("Not uploading the patch for " + patch[0] +
-             " because the file is too large.")
-      continue
-    form_fields = [("filename", patch[0])]
-    if not options.download_base:
-      form_fields.append(("content_upload", "1"))
-    files = [("data", "data.diff", patch[1])]
-    ctype, body = EncodeMultipartFormData(form_fields, files)
-    url = "/%d/upload_patch/%d" % (int(issue), int(patchset))
-    print "Uploading patch for " + patch[0]
-    response_body = rpc_server.Send(url, body, content_type=ctype)
-    lines = response_body.splitlines()
-    if not lines or lines[0] != "OK":
-      StatusUpdate("  --> %s" % response_body)
-      sys.exit(1)
-    rv.append([lines[1], patch[0]])
-  return rv
-
-
-def GuessVCS(options):
-  """Helper to guess the version control system.
-
-  This examines the current directory, guesses which VersionControlSystem
-  we're using, and returns an instance of the appropriate class.  Exit with an
-  error if we can't figure it out.
-
-  Returns:
-    A VersionControlSystem instance. Exits if the VCS can't be guessed.
-  """
-  # Mercurial has a command to get the base directory of a repository
-  # Try running it, but don't die if we don't have hg installed.
-  # NOTE: we try Mercurial first as it can sit on top of an SVN working copy.
-  try:
-    out, returncode = RunShellWithReturnCode(["hg", "root"])
-    if returncode == 0:
-      return MercurialVCS(options, out.strip())
-  except OSError, (errno, message):
-    if errno != 2:  # ENOENT -- they don't have hg installed.
-      raise
-
-  # Subversion has a .svn in all working directories.
-  if os.path.isdir('.svn'):
-    logging.info("Guessed VCS = Subversion")
-    return SubversionVCS(options)
-
-  # Git has a command to test if you're in a git tree.
-  # Try running it, but don't die if we don't have git installed.
-  try:
-    out, returncode = RunShellWithReturnCode(["git", "rev-parse",
-                                              "--is-inside-work-tree"])
-    if returncode == 0:
-      return GitVCS(options)
-  except OSError, (errno, message):
-    if errno != 2:  # ENOENT -- they don't have git installed.
-      raise
-
-  ErrorExit(("Could not guess version control system. "
-             "Are you in a working copy directory?"))
-
-
-def RealMain(argv, data=None):
-  """The real main function.
-
-  Args:
-    argv: Command line arguments.
-    data: Diff contents. If None (default) the diff is generated by
-      the VersionControlSystem implementation returned by GuessVCS().
-
-  Returns:
-    A 2-tuple (issue id, patchset id).
-    The patchset id is None if the base files are not uploaded by this
-    script (applies only to SVN checkouts).
-  """
-  logging.basicConfig(format=("%(asctime).19s %(levelname)s %(filename)s:"
-                              "%(lineno)s %(message)s "))
-  os.environ['LC_ALL'] = 'C'
-  options, args = parser.parse_args(argv[1:])
-  global verbosity
-  verbosity = options.verbose
-  if verbosity >= 3:
-    logging.getLogger().setLevel(logging.DEBUG)
-  elif verbosity >= 2:
-    logging.getLogger().setLevel(logging.INFO)
-  vcs = GuessVCS(options)
-  if isinstance(vcs, SubversionVCS):
-    # base field is only allowed for Subversion.
-    # Note: Fetching base files may become deprecated in future releases.
-    base = vcs.GuessBase(options.download_base)
-  else:
-    base = None
-  if not base and options.download_base:
-    options.download_base = True
-    logging.info("Enabled upload of base file")
-  if not options.assume_yes:
-    vcs.CheckForUnknownFiles()
-  if data is None:
-    data = vcs.GenerateDiff(args)
-  files = vcs.GetBaseFiles(data)
-  if verbosity >= 1:
-    print "Upload server:", options.server, "(change with -s/--server)"
-  if options.issue:
-    prompt = "Message describing this patch set: "
-  else:
-    prompt = "New issue subject: "
-  message = options.message or raw_input(prompt).strip()
-  if not message:
-    ErrorExit("A non-empty message is required")
-  rpc_server = GetRpcServer(options)
-  form_fields = [("subject", message)]
-  if base:
-    form_fields.append(("base", base))
-  if options.issue:
-    form_fields.append(("issue", str(options.issue)))
-  if options.email:
-    form_fields.append(("user", options.email))
-  if options.reviewers:
-    for reviewer in options.reviewers.split(','):
-      if "@" in reviewer and not reviewer.split("@")[1].count(".") == 1:
-        ErrorExit("Invalid email address: %s" % reviewer)
-    form_fields.append(("reviewers", options.reviewers))
-  if options.cc:
-    for cc in options.cc.split(','):
-      if "@" in cc and not cc.split("@")[1].count(".") == 1:
-        ErrorExit("Invalid email address: %s" % cc)
-    form_fields.append(("cc", options.cc))
-  description = options.description
-  if options.description_file:
-    if options.description:
-      ErrorExit("Can't specify description and description_file")
-    file = open(options.description_file, 'r')
-    description = file.read()
-    file.close()
-  if description:
-    form_fields.append(("description", description))
-  # Send a hash of all the base file so the server can determine if a copy
-  # already exists in an earlier patchset.
-  base_hashes = ""
-  for file, info in files.iteritems():
-    if not info[0] is None:
-      checksum = md5.new(info[0]).hexdigest()
-      if base_hashes:
-        base_hashes += "|"
-      base_hashes += checksum + ":" + file
-  form_fields.append(("base_hashes", base_hashes))
-  # If we're uploading base files, don't send the email before the uploads, so
-  # that it contains the file status.
-  if options.send_mail and options.download_base:
-    form_fields.append(("send_mail", "1"))
-  if not options.download_base:
-    form_fields.append(("content_upload", "1"))
-  if len(data) > MAX_UPLOAD_SIZE:
-    print "Patch is large, so uploading file patches separately."
-    uploaded_diff_file = []
-    form_fields.append(("separate_patches", "1"))
-  else:
-    uploaded_diff_file = [("data", "data.diff", data)]
-  ctype, body = EncodeMultipartFormData(form_fields, uploaded_diff_file)
-  response_body = rpc_server.Send("/upload", body, content_type=ctype)
-  patchset = None
-  if not options.download_base or not uploaded_diff_file:
-    lines = response_body.splitlines()
-    if len(lines) >= 2:
-      msg = lines[0]
-      patchset = lines[1].strip()
-      patches = [x.split(" ", 1) for x in lines[2:]]
-    else:
-      msg = response_body
-  else:
-    msg = response_body
-  StatusUpdate(msg)
-  if not response_body.startswith("Issue created.") and \
-  not response_body.startswith("Issue updated."):
-    sys.exit(0)
-  issue = msg[msg.rfind("/")+1:]
-
-  if not uploaded_diff_file:
-    result = UploadSeparatePatches(issue, rpc_server, patchset, data, options)
-    if not options.download_base:
-      patches = result
-
-  if not options.download_base:
-    vcs.UploadBaseFiles(issue, rpc_server, patches, patchset, options, files)
-    if options.send_mail:
-      rpc_server.Send("/" + issue + "/mail", payload="")
-  return issue, patchset
-
-
-def main():
-  try:
-    RealMain(sys.argv)
-  except KeyboardInterrupt:
-    print
-    StatusUpdate("Interrupted.")
-    sys.exit(1)
-
-
-if __name__ == "__main__":
-  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload_gmock.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload_gmock.py
deleted file mode 100755
index 5dc484b3..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/scripts/upload_gmock.py
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2009, 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.
-
-"""upload_gmock.py v0.1.0 -- uploads a Google Mock patch for review.
-
-This simple wrapper passes all command line flags and
---cc=googlemock@googlegroups.com to upload.py.
-
-USAGE: upload_gmock.py [options for upload.py]
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import sys
-
-CC_FLAG = '--cc='
-GMOCK_GROUP = 'googlemock@googlegroups.com'
-
-
-def main():
-  # Finds the path to upload.py, assuming it is in the same directory
-  # as this file.
-  my_dir = os.path.dirname(os.path.abspath(__file__))
-  upload_py_path = os.path.join(my_dir, 'upload.py')
-
-  # Adds Google Mock discussion group to the cc line if it's not there
-  # already.
-  upload_py_argv = [upload_py_path]
-  found_cc_flag = False
-  for arg in sys.argv[1:]:
-    if arg.startswith(CC_FLAG):
-      found_cc_flag = True
-      cc_line = arg[len(CC_FLAG):]
-      cc_list = [addr for addr in cc_line.split(',') if addr]
-      if GMOCK_GROUP not in cc_list:
-        cc_list.append(GMOCK_GROUP)
-      upload_py_argv.append(CC_FLAG + ','.join(cc_list))
-    else:
-      upload_py_argv.append(arg)
-
-  if not found_cc_flag:
-    upload_py_argv.append(CC_FLAG + GMOCK_GROUP)
-
-  # Invokes upload.py with the modified command line flags.
-  os.execv(upload_py_path, upload_py_argv)
-
-
-if __name__ == '__main__':
-  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-all.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-all.cc
deleted file mode 100644
index 7aebce7a..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-all.cc
+++ /dev/null
@@ -1,47 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Google C++ Mocking Framework (Google Mock)
-//
-// This file #includes all Google Mock implementation .cc files.  The
-// purpose is to allow a user to build Google Mock by compiling this
-// file alone.
-
-// This line ensures that gmock.h can be compiled on its own, even
-// when it's fused.
-#include "gmock/gmock.h"
-
-// The following lines pull in the real gmock *.cc files.
-#include "src/gmock-cardinalities.cc"
-#include "src/gmock-internal-utils.cc"
-#include "src/gmock-matchers.cc"
-#include "src/gmock-spec-builders.cc"
-#include "src/gmock.cc"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-cardinalities.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-cardinalities.cc
deleted file mode 100644
index 50ec7286..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-cardinalities.cc
+++ /dev/null
@@ -1,156 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements cardinalities.
-
-#include "gmock/gmock-cardinalities.h"
-
-#include <limits.h>
-#include <ostream>  // NOLINT
-#include <sstream>
-#include <string>
-#include "gmock/internal/gmock-internal-utils.h"
-#include "gtest/gtest.h"
-
-namespace testing {
-
-namespace {
-
-// Implements the Between(m, n) cardinality.
-class BetweenCardinalityImpl : public CardinalityInterface {
- public:
-  BetweenCardinalityImpl(int min, int max)
-      : min_(min >= 0 ? min : 0),
-        max_(max >= min_ ? max : min_) {
-    std::stringstream ss;
-    if (min < 0) {
-      ss << "The invocation lower bound must be >= 0, "
-         << "but is actually " << min << ".";
-      internal::Expect(false, __FILE__, __LINE__, ss.str());
-    } else if (max < 0) {
-      ss << "The invocation upper bound must be >= 0, "
-         << "but is actually " << max << ".";
-      internal::Expect(false, __FILE__, __LINE__, ss.str());
-    } else if (min > max) {
-      ss << "The invocation upper bound (" << max
-         << ") must be >= the invocation lower bound (" << min
-         << ").";
-      internal::Expect(false, __FILE__, __LINE__, ss.str());
-    }
-  }
-
-  // Conservative estimate on the lower/upper bound of the number of
-  // calls allowed.
-  virtual int ConservativeLowerBound() const { return min_; }
-  virtual int ConservativeUpperBound() const { return max_; }
-
-  virtual bool IsSatisfiedByCallCount(int call_count) const {
-    return min_ <= call_count && call_count <= max_;
-  }
-
-  virtual bool IsSaturatedByCallCount(int call_count) const {
-    return call_count >= max_;
-  }
-
-  virtual void DescribeTo(::std::ostream* os) const;
-
- private:
-  const int min_;
-  const int max_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(BetweenCardinalityImpl);
-};
-
-// Formats "n times" in a human-friendly way.
-inline internal::string FormatTimes(int n) {
-  if (n == 1) {
-    return "once";
-  } else if (n == 2) {
-    return "twice";
-  } else {
-    std::stringstream ss;
-    ss << n << " times";
-    return ss.str();
-  }
-}
-
-// Describes the Between(m, n) cardinality in human-friendly text.
-void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const {
-  if (min_ == 0) {
-    if (max_ == 0) {
-      *os << "never called";
-    } else if (max_ == INT_MAX) {
-      *os << "called any number of times";
-    } else {
-      *os << "called at most " << FormatTimes(max_);
-    }
-  } else if (min_ == max_) {
-    *os << "called " << FormatTimes(min_);
-  } else if (max_ == INT_MAX) {
-    *os << "called at least " << FormatTimes(min_);
-  } else {
-    // 0 < min_ < max_ < INT_MAX
-    *os << "called between " << min_ << " and " << max_ << " times";
-  }
-}
-
-}  // Unnamed namespace
-
-// Describes the given call count to an ostream.
-void Cardinality::DescribeActualCallCountTo(int actual_call_count,
-                                            ::std::ostream* os) {
-  if (actual_call_count > 0) {
-    *os << "called " << FormatTimes(actual_call_count);
-  } else {
-    *os << "never called";
-  }
-}
-
-// Creates a cardinality that allows at least n calls.
-GTEST_API_ Cardinality AtLeast(int n) { return Between(n, INT_MAX); }
-
-// Creates a cardinality that allows at most n calls.
-GTEST_API_ Cardinality AtMost(int n) { return Between(0, n); }
-
-// Creates a cardinality that allows any number of calls.
-GTEST_API_ Cardinality AnyNumber() { return AtLeast(0); }
-
-// Creates a cardinality that allows between min and max calls.
-GTEST_API_ Cardinality Between(int min, int max) {
-  return Cardinality(new BetweenCardinalityImpl(min, max));
-}
-
-// Creates a cardinality that allows exactly n calls.
-GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); }
-
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-internal-utils.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-internal-utils.cc
deleted file mode 100644
index fb530801..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-internal-utils.cc
+++ /dev/null
@@ -1,174 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// 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.
-
-#include "gmock/internal/gmock-internal-utils.h"
-
-#include <ctype.h>
-#include <ostream>  // NOLINT
-#include <string>
-#include "gmock/gmock.h"
-#include "gmock/internal/gmock-port.h"
-#include "gtest/gtest.h"
-
-namespace testing {
-namespace internal {
-
-// 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_ string ConvertIdentifierNameToWords(const char* id_name) {
-  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
-    // guaranteed to be a valid C++ identifier name.
-    const bool starts_new_word = IsUpper(*p) ||
-        (!IsAlpha(prev_char) && IsLower(*p)) ||
-        (!IsDigit(prev_char) && IsDigit(*p));
-
-    if (IsAlNum(*p)) {
-      if (starts_new_word && result != "")
-        result += ' ';
-      result += ToLower(*p);
-    }
-  }
-  return result;
-}
-
-// This class reports Google Mock failures as Google Test failures.  A
-// user can define another class in a similar fashion if he intends to
-// use Google Mock with a testing framework other than Google Test.
-class GoogleTestFailureReporter : public FailureReporterInterface {
- public:
-  virtual void ReportFailure(FailureType type, const char* file, int line,
-                             const string& message) {
-    AssertHelper(type == kFatal ?
-                 TestPartResult::kFatalFailure :
-                 TestPartResult::kNonFatalFailure,
-                 file,
-                 line,
-                 message.c_str()) = Message();
-    if (type == kFatal) {
-      posix::Abort();
-    }
-  }
-};
-
-// Returns the global failure reporter.  Will create a
-// GoogleTestFailureReporter and return it the first time called.
-GTEST_API_ FailureReporterInterface* GetFailureReporter() {
-  // Points to the global failure reporter used by Google Mock.  gcc
-  // guarantees that the following use of failure_reporter is
-  // thread-safe.  We may need to add additional synchronization to
-  // protect failure_reporter if we port Google Mock to other
-  // compilers.
-  static FailureReporterInterface* const failure_reporter =
-      new GoogleTestFailureReporter();
-  return failure_reporter;
-}
-
-// Protects global resources (stdout in particular) used by Log().
-static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex);
-
-// Returns true iff 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.
-    return true;
-  } else if (GMOCK_FLAG(verbose) == kErrorVerbosity) {
-    // Always hide it if --gmock_verbose=error.
-    return false;
-  } else {
-    // If --gmock_verbose is neither "info" nor "error", we treat it
-    // as "warning" (its default value).
-    return severity == kWarning;
-  }
-}
-
-// Prints the given message to stdout iff '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 string& message,
-                    int stack_frames_to_skip) {
-  if (!LogIsVisible(severity))
-    return;
-
-  // Ensures that logs from different threads don't interleave.
-  MutexLock l(&g_log_mutex);
-
-  // "using ::std::cout;" doesn't work with Symbian's STLport, where cout is a
-  // macro.
-
-  if (severity == kWarning) {
-    // Prints a GMOCK WARNING marker to make the warnings easily searchable.
-    std::cout << "\nGMOCK WARNING:";
-  }
-  // Pre-pends a new-line to message if it doesn't start with one.
-  if (message.empty() || message[0] != '\n') {
-    std::cout << "\n";
-  }
-  std::cout << message;
-  if (stack_frames_to_skip >= 0) {
-#ifdef NDEBUG
-    // In opt mode, we have to be conservative and skip no stack frame.
-    const int actual_to_skip = 0;
-#else
-    // In dbg mode, we can do what the caller tell us to do (plus one
-    // for skipping this function's stack frame).
-    const int actual_to_skip = stack_frames_to_skip + 1;
-#endif  // NDEBUG
-
-    // Appends a new-line to message if it doesn't end with one.
-    if (!message.empty() && *message.rbegin() != '\n') {
-      std::cout << "\n";
-    }
-    std::cout << "Stack trace:\n"
-         << ::testing::internal::GetCurrentOsStackTraceExceptTop(
-             ::testing::UnitTest::GetInstance(), actual_to_skip);
-  }
-  std::cout << ::std::flush;
-}
-
-}  // namespace internal
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-matchers.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-matchers.cc
deleted file mode 100644
index e7424510..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-matchers.cc
+++ /dev/null
@@ -1,498 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements Matcher<const string&>, Matcher<string>, and
-// utilities for defining matchers.
-
-#include "gmock/gmock-matchers.h"
-#include "gmock/gmock-generated-matchers.h"
-
-#include <string.h>
-#include <sstream>
-#include <string>
-
-namespace testing {
-
-// Constructs a matcher that matches a const string& whose value is
-// equal to s.
-Matcher<const internal::string&>::Matcher(const internal::string& s) {
-  *this = Eq(s);
-}
-
-// Constructs a matcher that matches a const string& whose value is
-// equal to s.
-Matcher<const internal::string&>::Matcher(const char* s) {
-  *this = Eq(internal::string(s));
-}
-
-// Constructs a matcher that matches a string whose value is equal to s.
-Matcher<internal::string>::Matcher(const internal::string& s) { *this = Eq(s); }
-
-// Constructs a matcher that matches a string whose value is equal to s.
-Matcher<internal::string>::Matcher(const char* s) {
-  *this = Eq(internal::string(s));
-}
-
-#if GTEST_HAS_STRING_PIECE_
-// Constructs a matcher that matches a const StringPiece& whose value is
-// equal to s.
-Matcher<const StringPiece&>::Matcher(const internal::string& s) {
-  *this = Eq(s);
-}
-
-// Constructs a matcher that matches a const StringPiece& whose value is
-// equal to s.
-Matcher<const StringPiece&>::Matcher(const char* s) {
-  *this = Eq(internal::string(s));
-}
-
-// Constructs a matcher that matches a const StringPiece& whose value is
-// equal to s.
-Matcher<const StringPiece&>::Matcher(StringPiece s) {
-  *this = Eq(s.ToString());
-}
-
-// Constructs a matcher that matches a StringPiece whose value is equal to s.
-Matcher<StringPiece>::Matcher(const internal::string& s) {
-  *this = Eq(s);
-}
-
-// Constructs a matcher that matches a StringPiece whose value is equal to s.
-Matcher<StringPiece>::Matcher(const char* s) {
-  *this = Eq(internal::string(s));
-}
-
-// Constructs a matcher that matches a StringPiece whose value is equal to s.
-Matcher<StringPiece>::Matcher(StringPiece s) {
-  *this = Eq(s.ToString());
-}
-#endif  // GTEST_HAS_STRING_PIECE_
-
-namespace internal {
-
-// Joins a vector of strings as if they are fields of a tuple; returns
-// the joined string.
-GTEST_API_ string JoinAsTuple(const Strings& fields) {
-  switch (fields.size()) {
-    case 0:
-      return "";
-    case 1:
-      return fields[0];
-    default:
-      string result = "(" + fields[0];
-      for (size_t i = 1; i < fields.size(); i++) {
-        result += ", ";
-        result += fields[i];
-      }
-      result += ")";
-      return result;
-  }
-}
-
-// Returns the description for a matcher defined using the MATCHER*()
-// macro where the user-supplied description string is "", if
-// '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_ string FormatMatcherDescription(bool negation,
-                                           const char* matcher_name,
-                                           const Strings& param_values) {
-  string result = ConvertIdentifierNameToWords(matcher_name);
-  if (param_values.size() >= 1)
-    result += " " + JoinAsTuple(param_values);
-  return negation ? "not (" + result + ")" : result;
-}
-
-// FindMaxBipartiteMatching and its helper class.
-//
-// Uses the well-known Ford-Fulkerson max flow method to find a maximum
-// bipartite matching. Flow is considered to be from left to right.
-// There is an implicit source node that is connected to all of the left
-// nodes, and an implicit sink node that is connected to all of the
-// right nodes. All edges have unit capacity.
-//
-// Neither the flow graph nor the residual flow graph are represented
-// explicitly. Instead, they are implied by the information in 'graph' and
-// a vector<int> called 'left_' whose elements are initialized to the
-// value kUnused. This represents the initial state of the algorithm,
-// where the flow graph is empty, and the residual flow graph has the
-// following edges:
-//   - An edge from source to each left_ node
-//   - An edge from each right_ node to sink
-//   - An edge from each left_ node to each right_ node, if the
-//     corresponding edge exists in 'graph'.
-//
-// When the TryAugment() method adds a flow, it sets left_[l] = r for some
-// nodes l and r. This induces the following changes:
-//   - The edges (source, l), (l, r), and (r, sink) are added to the
-//     flow graph.
-//   - The same three edges are removed from the residual flow graph.
-//   - The reverse edges (l, source), (r, l), and (sink, r) are added
-//     to the residual flow graph, which is a directional graph
-//     representing unused flow capacity.
-//
-// When the method augments a flow (moving left_[l] from some r1 to some
-// other r2), this can be thought of as "undoing" the above steps with
-// respect to r1 and "redoing" them with respect to r2.
-//
-// It bears repeating that the flow graph and residual flow graph are
-// never represented explicitly, but can be derived by looking at the
-// information in 'graph' and in left_.
-//
-// As an optimization, there is a second vector<int> called right_ which
-// does not provide any new information. Instead, it enables more
-// efficient queries about edges entering or leaving the right-side nodes
-// of the flow or residual flow graphs. The following invariants are
-// maintained:
-//
-// left[l] == kUnused or right[left[l]] == l
-// right[r] == kUnused or left[right[r]] == r
-//
-// . [ source ]                                        .
-// .   |||                                             .
-// .   |||                                             .
-// .   ||\--> left[0]=1  ---\    right[0]=-1 ----\     .
-// .   ||                   |                    |     .
-// .   |\---> left[1]=-1    \--> right[1]=0  ---\|     .
-// .   |                                        ||     .
-// .   \----> left[2]=2  ------> right[2]=2  --\||     .
-// .                                           |||     .
-// .         elements           matchers       vvv     .
-// .                                         [ sink ]  .
-//
-// See Also:
-//   [1] Cormen, et al (2001). "Section 26.2: The Ford-Fulkerson method".
-//       "Introduction to Algorithms (Second ed.)", pp. 651-664.
-//   [2] "Ford-Fulkerson algorithm", Wikipedia,
-//       'http://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
-class MaxBipartiteMatchState {
- public:
-  explicit MaxBipartiteMatchState(const MatchMatrix& graph)
-      : graph_(&graph),
-        left_(graph_->LhsSize(), kUnused),
-        right_(graph_->RhsSize(), kUnused) {
-  }
-
-  // Returns the edges of a maximal match, each in the form {left, right}.
-  ElementMatcherPairs Compute() {
-    // 'seen' is used for path finding { 0: unseen, 1: seen }.
-    ::std::vector<char> seen;
-    // Searches the residual flow graph for a path from each left node to
-    // the sink in the residual flow graph, and if one is found, add flow
-    // to the graph. It's okay to search through the left nodes once. The
-    // edge from the implicit source node to each previously-visited left
-    // node will have flow if that left node has any path to the sink
-    // whatsoever. Subsequent augmentations can only add flow to the
-    // network, and cannot take away that previous flow unit from the source.
-    // Since the source-to-left edge can only carry one flow unit (or,
-    // each element can be matched to only one matcher), there is no need
-    // to visit the left nodes more than once looking for augmented paths.
-    // The flow is known to be possible or impossible by looking at the
-    // node once.
-    for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
-      // Reset the path-marking vector and try to find a path from
-      // source to sink starting at the left_[ilhs] node.
-      GTEST_CHECK_(left_[ilhs] == kUnused)
-          << "ilhs: " << ilhs << ", left_[ilhs]: " << left_[ilhs];
-      // 'seen' initialized to 'graph_->RhsSize()' copies of 0.
-      seen.assign(graph_->RhsSize(), 0);
-      TryAugment(ilhs, &seen);
-    }
-    ElementMatcherPairs result;
-    for (size_t ilhs = 0; ilhs < left_.size(); ++ilhs) {
-      size_t irhs = left_[ilhs];
-      if (irhs == kUnused) continue;
-      result.push_back(ElementMatcherPair(ilhs, irhs));
-    }
-    return result;
-  }
-
- private:
-  static const size_t kUnused = static_cast<size_t>(-1);
-
-  // Perform a depth-first search from left node ilhs to the sink.  If a
-  // path is found, flow is added to the network by linking the left and
-  // right vector elements corresponding each segment of the path.
-  // Returns true if a path to sink was found, which means that a unit of
-  // flow was added to the network. The 'seen' vector elements correspond
-  // to right nodes and are marked to eliminate cycles from the search.
-  //
-  // Left nodes will only be explored at most once because they
-  // are accessible from at most one right node in the residual flow
-  // graph.
-  //
-  // Note that left_[ilhs] is the only element of left_ that TryAugment will
-  // potentially transition from kUnused to another value. Any other
-  // left_ element holding kUnused before TryAugment will be holding it
-  // when TryAugment returns.
-  //
-  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;
-      // There's an available edge from ilhs to irhs.
-      (*seen)[irhs] = 1;
-      // Next a search is performed to determine whether
-      // this edge is a dead end or leads to the sink.
-      //
-      // right_[irhs] == kUnused means that there is residual flow from
-      // right node irhs to the sink, so we can use that to finish this
-      // flow path and return success.
-      //
-      // Otherwise there is residual flow to some ilhs. We push flow
-      // along that path and call ourselves recursively to see if this
-      // ultimately leads to sink.
-      if (right_[irhs] == kUnused || TryAugment(right_[irhs], seen)) {
-        // Add flow from left_[ilhs] to right_[irhs].
-        left_[ilhs] = irhs;
-        right_[irhs] = ilhs;
-        return true;
-      }
-    }
-    return false;
-  }
-
-  const MatchMatrix* graph_;  // not owned
-  // 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 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
-  // be redundantly represented in the right_ vector as right_[1] == 3.
-  // Elements of left_ and right_ are either kUnused or mutually
-  // referent. Mutually referent means that left_[right_[i]] = i and
-  // right_[left_[i]] = i.
-  ::std::vector<size_t> left_;
-  ::std::vector<size_t> right_;
-
-  GTEST_DISALLOW_ASSIGN_(MaxBipartiteMatchState);
-};
-
-const size_t MaxBipartiteMatchState::kUnused;
-
-GTEST_API_ ElementMatcherPairs
-FindMaxBipartiteMatching(const MatchMatrix& g) {
-  return MaxBipartiteMatchState(g).Compute();
-}
-
-static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
-                                     ::std::ostream* stream) {
-  typedef ElementMatcherPairs::const_iterator Iter;
-  ::std::ostream& os = *stream;
-  os << "{";
-  const char *sep = "";
-  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
-    os << sep << "\n  ("
-       << "element #" << it->first << ", "
-       << "matcher #" << it->second << ")";
-    sep = ",";
-  }
-  os << "\n}";
-}
-
-// Tries to find a pairing, and explains the result.
-GTEST_API_ bool FindPairing(const MatchMatrix& matrix,
-                            MatchResultListener* listener) {
-  ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix);
-
-  size_t max_flow = matches.size();
-  bool result = (max_flow == matrix.RhsSize());
-
-  if (!result) {
-    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 (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 MatchMatrix::NextGraph() {
-  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
-    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
-      char& b = matched_[SpaceIndex(ilhs, irhs)];
-      if (!b) {
-        b = 1;
-        return true;
-      }
-      b = 0;
-    }
-  }
-  return false;
-}
-
-void MatchMatrix::Randomize() {
-  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
-    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
-      char& b = matched_[SpaceIndex(ilhs, irhs)];
-      b = static_cast<char>(rand() & 1);  // NOLINT
-    }
-  }
-}
-
-string MatchMatrix::DebugString() const {
-  ::std::stringstream ss;
-  const char *sep = "";
-  for (size_t i = 0; i < LhsSize(); ++i) {
-    ss << sep;
-    for (size_t j = 0; j < RhsSize(); ++j) {
-      ss << HasEdge(i, j);
-    }
-    sep = ";";
-  }
-  return ss.str();
-}
-
-void UnorderedElementsAreMatcherImplBase::DescribeToImpl(
-    ::std::ostream* os) const {
-  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";
-  const char* sep = "";
-  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
-    *os << sep << " - element #" << i << " ";
-    matcher_describers_[i]->DescribeTo(os);
-    sep = ", and\n";
-  }
-}
-
-void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(
-    ::std::ostream* os) const {
-  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";
-  const char* sep = "";
-  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
-    *os << sep << " - element #" << i << " ";
-    matcher_describers_[i]->DescribeTo(os);
-    sep = ", and\n";
-  }
-}
-
-// Checks that all matchers match at least one element, and that all
-// elements match at least one matcher. This enables faster matching
-// and better error reporting.
-// Returns false, writing an explanation to 'listener', if and only
-// if the success criteria are not met.
-bool UnorderedElementsAreMatcherImplBase::
-VerifyAllElementsAndMatchersAreMatched(
-    const ::std::vector<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);
-
-  for (size_t ilhs = 0; ilhs < matrix.LhsSize(); ilhs++) {
-    for (size_t irhs = 0; irhs < matrix.RhsSize(); irhs++) {
-      char matched = matrix.HasEdge(ilhs, irhs);
-      element_matched[ilhs] |= matched;
-      matcher_matched[irhs] |= matched;
-    }
-  }
-
-  {
-    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;
-      result = false;
-      if (listener->IsInterested()) {
-        *listener << sep << "matcher #" << mi << ": ";
-        matcher_describers_[mi]->DescribeTo(listener->stream());
-        sep = ",\n";
-      }
-    }
-  }
-
-  {
-    const char* sep =
-        "where the following elements don't match any matchers:\n";
-    const char* outer_sep = "";
-    if (!result) {
-      outer_sep = "\nand ";
-    }
-    for (size_t ei = 0; ei < element_matched.size(); ++ei) {
-      if (element_matched[ei])
-        continue;
-      result = false;
-      if (listener->IsInterested()) {
-        *listener << outer_sep << sep << "element #" << ei << ": "
-                  << element_printouts[ei];
-        sep = ",\n";
-        outer_sep = "";
-      }
-    }
-  }
-  return result;
-}
-
-}  // namespace internal
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-spec-builders.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-spec-builders.cc
deleted file mode 100644
index 95513420..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock-spec-builders.cc
+++ /dev/null
@@ -1,823 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements the spec builder syntax (ON_CALL and
-// EXPECT_CALL).
-
-#include "gmock/gmock-spec-builders.h"
-
-#include <stdlib.h>
-#include <iostream>  // NOLINT
-#include <map>
-#include <set>
-#include <string>
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
-# include <unistd.h>  // NOLINT
-#endif
-
-namespace testing {
-namespace internal {
-
-// Protects the mock object registry (in class Mock), all function
-// mockers, and all expectations.
-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 string& message) {
-  ::std::ostringstream s;
-  s << file << ":" << line << ": " << message << ::std::endl;
-  Log(severity, s.str(), 0);
-}
-
-// Constructs an ExpectationBase object.
-ExpectationBase::ExpectationBase(const char* a_file,
-                                 int a_line,
-                                 const string& a_source_text)
-    : file_(a_file),
-      line_(a_line),
-      source_text_(a_source_text),
-      cardinality_specified_(false),
-      cardinality_(Exactly(1)),
-      call_count_(0),
-      retired_(false),
-      extra_matcher_specified_(false),
-      repeated_action_specified_(false),
-      retires_on_saturation_(false),
-      last_clause_(kNone),
-      action_count_checked_(false) {}
-
-// Destructs an ExpectationBase object.
-ExpectationBase::~ExpectationBase() {}
-
-// Explicitly specifies the cardinality of this expectation.  Used by
-// the subclasses to implement the .Times() clause.
-void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) {
-  cardinality_specified_ = true;
-  cardinality_ = a_cardinality;
-}
-
-// Retires all pre-requisites of this expectation.
-void ExpectationBase::RetireAllPreRequisites()
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-  if (is_retired()) {
-    // We can take this short-cut as we never retire an expectation
-    // until we have retired all its pre-requisites.
-    return;
-  }
-
-  for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
-       it != immediate_prerequisites_.end(); ++it) {
-    ExpectationBase* const prerequisite = it->expectation_base().get();
-    if (!prerequisite->is_retired()) {
-      prerequisite->RetireAllPreRequisites();
-      prerequisite->Retire();
-    }
-  }
-}
-
-// Returns true iff all pre-requisites of this expectation have been
-// satisfied.
-bool ExpectationBase::AllPrerequisitesAreSatisfied() const
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-  g_gmock_mutex.AssertHeld();
-  for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
-       it != immediate_prerequisites_.end(); ++it) {
-    if (!(it->expectation_base()->IsSatisfied()) ||
-        !(it->expectation_base()->AllPrerequisitesAreSatisfied()))
-      return false;
-  }
-  return true;
-}
-
-// Adds unsatisfied pre-requisites of this expectation to 'result'.
-void ExpectationBase::FindUnsatisfiedPrerequisites(ExpectationSet* result) const
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-  g_gmock_mutex.AssertHeld();
-  for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
-       it != immediate_prerequisites_.end(); ++it) {
-    if (it->expectation_base()->IsSatisfied()) {
-      // If *it is satisfied and has a call count of 0, some of its
-      // pre-requisites may not be satisfied yet.
-      if (it->expectation_base()->call_count_ == 0) {
-        it->expectation_base()->FindUnsatisfiedPrerequisites(result);
-      }
-    } else {
-      // Now that we know *it is unsatisfied, we are not so interested
-      // in whether its pre-requisites are satisfied.  Therefore we
-      // don't recursively call FindUnsatisfiedPrerequisites() here.
-      *result += *it;
-    }
-  }
-}
-
-// Describes how many times a function call matching this
-// expectation has occurred.
-void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-  g_gmock_mutex.AssertHeld();
-
-  // Describes how many times the function is expected to be called.
-  *os << "         Expected: to be ";
-  cardinality().DescribeTo(os);
-  *os << "\n           Actual: ";
-  Cardinality::DescribeActualCallCountTo(call_count(), os);
-
-  // Describes the state of the expectation (e.g. is it satisfied?
-  // is it active?).
-  *os << " - " << (IsOverSaturated() ? "over-saturated" :
-                   IsSaturated() ? "saturated" :
-                   IsSatisfied() ? "satisfied" : "unsatisfied")
-      << " and "
-      << (is_retired() ? "retired" : "active");
-}
-
-// Checks the action count (i.e. the number of WillOnce() and
-// WillRepeatedly() clauses) against the cardinality if this hasn't
-// been done before.  Prints a warning if there are too many or too
-// few actions.
-void ExpectationBase::CheckActionCountIfNotDone() const
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  bool should_check = false;
-  {
-    MutexLock l(&mutex_);
-    if (!action_count_checked_) {
-      action_count_checked_ = true;
-      should_check = true;
-    }
-  }
-
-  if (should_check) {
-    if (!cardinality_specified_) {
-      // The cardinality was inferred - no need to check the action
-      // count against it.
-      return;
-    }
-
-    // The cardinality was explicitly specified.
-    const int action_count = static_cast<int>(untyped_actions_.size());
-    const int upper_bound = cardinality().ConservativeUpperBound();
-    const int lower_bound = cardinality().ConservativeLowerBound();
-    bool too_many;  // True if there are too many actions, or false
-    // if there are too few.
-    if (action_count > upper_bound ||
-        (action_count == upper_bound && repeated_action_specified_)) {
-      too_many = true;
-    } else if (0 < action_count && action_count < lower_bound &&
-               !repeated_action_specified_) {
-      too_many = false;
-    } else {
-      return;
-    }
-
-    ::std::stringstream ss;
-    DescribeLocationTo(&ss);
-    ss << "Too " << (too_many ? "many" : "few")
-       << " actions specified in " << source_text() << "...\n"
-       << "Expected to be ";
-    cardinality().DescribeTo(&ss);
-    ss << ", but has " << (too_many ? "" : "only ")
-       << action_count << " WillOnce()"
-       << (action_count == 1 ? "" : "s");
-    if (repeated_action_specified_) {
-      ss << " and a WillRepeatedly()";
-    }
-    ss << ".";
-    Log(kWarning, ss.str(), -1);  // -1 means "don't print stack trace".
-  }
-}
-
-// Implements the .Times() clause.
-void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) {
-  if (last_clause_ == kTimes) {
-    ExpectSpecProperty(false,
-                       ".Times() cannot appear "
-                       "more than once in an EXPECT_CALL().");
-  } else {
-    ExpectSpecProperty(last_clause_ < kTimes,
-                       ".Times() cannot appear after "
-                       ".InSequence(), .WillOnce(), .WillRepeatedly(), "
-                       "or .RetiresOnSaturation().");
-  }
-  last_clause_ = kTimes;
-
-  SpecifyCardinality(a_cardinality);
-}
-
-// Points to the implicit sequence introduced by a living InSequence
-// object (if any) in the current thread or NULL.
-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 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;
-  switch (reaction) {
-    case kAllow:
-      Log(kInfo, msg, stack_frames_to_skip);
-      break;
-    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/googlemock/docs/CookBook.md#"
-          "knowing-when-to-expect for details.\n",
-          stack_frames_to_skip);
-      break;
-    default:  // FAIL
-      Expect(false, NULL, -1, msg);
-  }
-}
-
-UntypedFunctionMockerBase::UntypedFunctionMockerBase()
-    : mock_obj_(NULL), name_("") {}
-
-UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}
-
-// Sets the mock object this mock method belongs to, and registers
-// this information in the global mock registry.  Will be called
-// whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
-// method.
-void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-  {
-    MutexLock l(&g_gmock_mutex);
-    mock_obj_ = mock_obj;
-  }
-  Mock::Register(mock_obj, this);
-}
-
-// Sets the mock object this mock method belongs to, and sets the name
-// of the mock function.  Will be called upon each invocation of this
-// mock function.
-void UntypedFunctionMockerBase::SetOwnerAndName(const void* mock_obj,
-                                                const char* name)
-    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-  // We protect name_ under g_gmock_mutex in case this mock function
-  // is called from two threads concurrently.
-  MutexLock l(&g_gmock_mutex);
-  mock_obj_ = mock_obj;
-  name_ = name;
-}
-
-// Returns the name of the function being mocked.  Must be called
-// after RegisterOwner() or SetOwnerAndName() has been called.
-const void* UntypedFunctionMockerBase::MockObject() const
-    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-  const void* mock_obj;
-  {
-    // 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_ != NULL, __FILE__, __LINE__,
-           "MockObject() must not be called before RegisterOwner() or "
-           "SetOwnerAndName() has been called.");
-    mock_obj = mock_obj_;
-  }
-  return mock_obj;
-}
-
-// Returns the name of this mock method.  Must be called after
-// SetOwnerAndName() has been called.
-const char* UntypedFunctionMockerBase::Name() const
-    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-  const char* name;
-  {
-    // 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_ != NULL, __FILE__, __LINE__,
-           "Name() must not be called before SetOwnerAndName() has "
-           "been called.");
-    name = name_;
-  }
-  return name;
-}
-
-// 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(const void* const untyped_args)
-    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-  if (untyped_expectations_.size() == 0) {
-    // No expectation is set on this mock method - we have an
-    // uninteresting call.
-
-    // We must get Google Mock's reaction on uninteresting calls
-    // made on this mock object BEFORE performing the action,
-    // because the action may DELETE the mock object and make the
-    // following expression meaningless.
-    const CallReaction reaction =
-        Mock::GetReactionOnUninterestingCalls(MockObject());
-
-    // True iff 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 he wants informational messages.
-        reaction == kAllow ? LogIsVisible(kInfo) :
-        // If the user wants this to be a warning, we print it only
-        // when he wants 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, "");
-    }
-
-    // Warns about the uninteresting call.
-    ::std::stringstream ss;
-    this->UntypedDescribeUninterestingCall(untyped_args, &ss);
-
-    // Calculates the function result.
-    UntypedActionResultHolderBase* const result =
-        this->UntypedPerformDefaultAction(untyped_args, ss.str());
-
-    // Prints the function result.
-    if (result != NULL)
-      result->PrintAsActionResult(&ss);
-
-    ReportUninterestingCall(reaction, ss.str());
-    return result;
-  }
-
-  bool is_excessive = false;
-  ::std::stringstream ss;
-  ::std::stringstream why;
-  ::std::stringstream loc;
-  const void* untyped_action = NULL;
-
-  // 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 != NULL;
-
-  // True iff 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 == NULL ?
-        this->UntypedPerformDefaultAction(untyped_args, "") :
-        this->UntypedPerformAction(untyped_action, untyped_args);
-  }
-
-  ss << "    Function call: " << Name();
-  this->UntypedPrintArgs(untyped_args, &ss);
-
-  // In case the action deletes a piece of the expectation, we
-  // generate the message beforehand.
-  if (found && !is_excessive) {
-    untyped_expectation->DescribeLocationTo(&loc);
-  }
-
-  UntypedActionResultHolderBase* const result =
-      untyped_action == NULL ?
-      this->UntypedPerformDefaultAction(untyped_args, ss.str()) :
-      this->UntypedPerformAction(untyped_action, untyped_args);
-  if (result != NULL)
-    result->PrintAsActionResult(&ss);
-  ss << "\n" << why.str();
-
-  if (!found) {
-    // No expectation matches this call - reports a failure.
-    Expect(false, NULL, -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);
-  }
-
-  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) {
-  for (UntypedExpectations::const_iterator it =
-           untyped_expectations_.begin();
-       it != untyped_expectations_.end(); ++it) {
-    if (it->get() == exp) {
-      return Expectation(*it);
-    }
-  }
-
-  Assert(false, __FILE__, __LINE__, "Cannot find expectation.");
-  return Expectation();
-  // The above statement is just to make the code compile, and will
-  // never be executed.
-}
-
-// Verifies that all expectations on this mock function have been
-// satisfied.  Reports one or more Google Test non-fatal failures
-// and returns false if not.
-bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
-  g_gmock_mutex.AssertHeld();
-  bool expectations_met = true;
-  for (UntypedExpectations::const_iterator it =
-           untyped_expectations_.begin();
-       it != untyped_expectations_.end(); ++it) {
-    ExpectationBase* const untyped_expectation = it->get();
-    if (untyped_expectation->IsOverSaturated()) {
-      // There was an upper-bound violation.  Since the error was
-      // already reported when it occurred, there is no need to do
-      // anything here.
-      expectations_met = false;
-    } else if (!untyped_expectation->IsSatisfied()) {
-      expectations_met = false;
-      ::std::stringstream ss;
-      ss  << "Actual function call count doesn't match "
-          << untyped_expectation->source_text() << "...\n";
-      // No need to show the source file location of the expectation
-      // in the description, as the Expect() call that follows already
-      // takes care of it.
-      untyped_expectation->MaybeDescribeExtraMatcherTo(&ss);
-      untyped_expectation->DescribeCallCountTo(&ss);
-      Expect(false, untyped_expectation->file(),
-             untyped_expectation->line(), ss.str());
-    }
-  }
-
-  // Deleting our expectations may trigger other mock objects to be deleted, for
-  // example if an action contains a reference counted smart pointer to that
-  // mock object, and that is the last reference. So if we delete our
-  // expectations within the context of the global mutex we may deadlock when
-  // this method is called again. Instead, make a copy of the set of
-  // expectations to delete, clear our set within the mutex, and then clear the
-  // copied set outside of it.
-  UntypedExpectations expectations_to_delete;
-  untyped_expectations_.swap(expectations_to_delete);
-
-  g_gmock_mutex.Unlock();
-  expectations_to_delete.clear();
-  g_gmock_mutex.Lock();
-
-  return expectations_met;
-}
-
-}  // namespace internal
-
-// Class Mock.
-
-namespace {
-
-typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers;
-
-// The current state of a mock object.  Such information is needed for
-// detecting leaked mock objects and explicitly verifying a mock's
-// expectations.
-struct MockObjectState {
-  MockObjectState()
-      : first_used_file(NULL), 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_case;
-  ::std::string first_used_test;
-  bool leakable;  // true iff it's OK to leak the object.
-  FunctionMockers function_mockers;  // All registered methods of the object.
-};
-
-// A global registry holding the state of all mock objects that are
-// alive.  A mock object is added to this registry the first time
-// Mock::AllowLeak(), ON_CALL(), or EXPECT_CALL() is called on it.  It
-// is removed from the registry in the mock object's destructor.
-class MockObjectRegistry {
- public:
-  // Maps a mock object (identified by its address) to its state.
-  typedef std::map<const void*, MockObjectState> StateMap;
-
-  // This destructor will be called when a program exits, after all
-  // tests in it have been run.  By then, there should be no mock
-  // object alive.  Therefore we report any living object as test
-  // failure, unless the user explicitly asked us to ignore it.
-  ~MockObjectRegistry() {
-    // "using ::std::cout;" doesn't work with Symbian's STLport, where cout is
-    // a macro.
-
-    if (!GMOCK_FLAG(catch_leaked_mocks))
-      return;
-
-    int leaked_count = 0;
-    for (StateMap::const_iterator it = states_.begin(); it != states_.end();
-         ++it) {
-      if (it->second.leakable)  // The user said it's fine to leak this object.
-        continue;
-
-      // TODO(wan@google.com): Print the type of the leaked object.
-      // This can help the user identify the leaked object.
-      std::cout << "\n";
-      const MockObjectState& state = it->second;
-      std::cout << internal::FormatFileLocation(state.first_used_file,
-                                                state.first_used_line);
-      std::cout << " ERROR: this mock object";
-      if (state.first_used_test != "") {
-        std::cout << " (used in test " << state.first_used_test_case << "."
-             << 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.\n";
-      std::cout.flush();
-      ::std::cerr.flush();
-      // RUN_ALL_TESTS() has already returned when this destructor is
-      // called.  Therefore we cannot use the normal Google Test
-      // failure reporting mechanism.
-      _exit(1);  // We cannot call exit() as it is not reentrant and
-                 // may already have been called.
-    }
-  }
-
-  StateMap& states() { return states_; }
-
- private:
-  StateMap states_;
-};
-
-// Protected by g_gmock_mutex.
-MockObjectRegistry g_mock_object_registry;
-
-// Maps a mock object to the reaction Google Mock should have when an
-// uninteresting method is called.  Protected by g_gmock_mutex.
-std::map<const void*, internal::CallReaction> g_uninteresting_call_reaction;
-
-// Sets the reaction Google Mock should have when an uninteresting
-// method of the given mock object is called.
-void SetReactionOnUninterestingCalls(const void* mock_obj,
-                                     internal::CallReaction reaction)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  g_uninteresting_call_reaction[mock_obj] = reaction;
-}
-
-}  // namespace
-
-// Tells Google Mock to allow uninteresting calls on the given mock
-// object.
-void Mock::AllowUninterestingCalls(const void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  SetReactionOnUninterestingCalls(mock_obj, internal::kAllow);
-}
-
-// Tells Google Mock to warn the user about uninteresting calls on the
-// given mock object.
-void Mock::WarnUninterestingCalls(const void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  SetReactionOnUninterestingCalls(mock_obj, internal::kWarn);
-}
-
-// Tells Google Mock to fail uninteresting calls on the given mock
-// object.
-void Mock::FailUninterestingCalls(const void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  SetReactionOnUninterestingCalls(mock_obj, internal::kFail);
-}
-
-// Tells Google Mock the given mock object is being destroyed and its
-// entry in the call-reaction table should be removed.
-void Mock::UnregisterCallReaction(const void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  g_uninteresting_call_reaction.erase(mock_obj);
-}
-
-// Returns the reaction Google Mock will have on uninteresting calls
-// made on the given mock object.
-internal::CallReaction Mock::GetReactionOnUninterestingCalls(
-    const void* mock_obj)
-        GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  return (g_uninteresting_call_reaction.count(mock_obj) == 0) ?
-      internal::kDefault : g_uninteresting_call_reaction[mock_obj];
-}
-
-// Tells Google Mock to ignore mock_obj when checking for leaked mock
-// objects.
-void Mock::AllowLeak(const void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  g_mock_object_registry.states()[mock_obj].leakable = true;
-}
-
-// Verifies and clears all expectations on the given mock object.  If
-// the expectations aren't satisfied, generates one or more Google
-// Test non-fatal failures and returns false.
-bool Mock::VerifyAndClearExpectations(void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  return VerifyAndClearExpectationsLocked(mock_obj);
-}
-
-// Verifies all expectations on the given mock object and clears its
-// default actions and expectations.  Returns true iff the
-// verification was successful.
-bool Mock::VerifyAndClear(void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  ClearDefaultActionsLocked(mock_obj);
-  return VerifyAndClearExpectationsLocked(mock_obj);
-}
-
-// Verifies and clears all expectations on the given mock object.  If
-// the expectations aren't satisfied, generates one or more Google
-// Test non-fatal failures and returns false.
-bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj)
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
-  internal::g_gmock_mutex.AssertHeld();
-  if (g_mock_object_registry.states().count(mock_obj) == 0) {
-    // No EXPECT_CALL() was set on the given mock object.
-    return true;
-  }
-
-  // Verifies and clears the expectations on each mock method in the
-  // given mock object.
-  bool expectations_met = true;
-  FunctionMockers& mockers =
-      g_mock_object_registry.states()[mock_obj].function_mockers;
-  for (FunctionMockers::const_iterator it = mockers.begin();
-       it != mockers.end(); ++it) {
-    if (!(*it)->VerifyAndClearExpectationsLocked()) {
-      expectations_met = false;
-    }
-  }
-
-  // We don't clear the content of mockers, as they may still be
-  // needed by ClearDefaultActionsLocked().
-  return expectations_met;
-}
-
-// Registers a mock object and a mock method it owns.
-void Mock::Register(const void* mock_obj,
-                    internal::UntypedFunctionMockerBase* mocker)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
-  g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker);
-}
-
-// Tells Google Mock where in the source code mock_obj is used in an
-// ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
-// information helps the user identify which object it is.
-void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj,
-                                           const char* file, int line)
-    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 == NULL) {
-    state.first_used_file = file;
-    state.first_used_line = line;
-    const TestInfo* const test_info =
-        UnitTest::GetInstance()->current_test_info();
-    if (test_info != NULL) {
-      // TODO(wan@google.com): record the test case name when the
-      // ON_CALL or EXPECT_CALL is invoked from SetUpTestCase() or
-      // TearDownTestCase().
-      state.first_used_test_case = test_info->test_case_name();
-      state.first_used_test = test_info->name();
-    }
-  }
-}
-
-// 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
-// FunctionMockerBase.
-void Mock::UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
-  internal::g_gmock_mutex.AssertHeld();
-  for (MockObjectRegistry::StateMap::iterator it =
-           g_mock_object_registry.states().begin();
-       it != g_mock_object_registry.states().end(); ++it) {
-    FunctionMockers& mockers = it->second.function_mockers;
-    if (mockers.erase(mocker) > 0) {
-      // mocker was in mockers and has been just removed.
-      if (mockers.empty()) {
-        g_mock_object_registry.states().erase(it);
-      }
-      return;
-    }
-  }
-}
-
-// Clears all ON_CALL()s set on the given mock object.
-void Mock::ClearDefaultActionsLocked(void* mock_obj)
-    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
-  internal::g_gmock_mutex.AssertHeld();
-
-  if (g_mock_object_registry.states().count(mock_obj) == 0) {
-    // No ON_CALL() was set on the given mock object.
-    return;
-  }
-
-  // Clears the default actions for each mock method in the given mock
-  // object.
-  FunctionMockers& mockers =
-      g_mock_object_registry.states()[mock_obj].function_mockers;
-  for (FunctionMockers::const_iterator it = mockers.begin();
-       it != mockers.end(); ++it) {
-    (*it)->ClearDefaultActionsLocked();
-  }
-
-  // We don't clear the content of mockers, as they may still be
-  // needed by VerifyAndClearExpectationsLocked().
-}
-
-Expectation::Expectation() {}
-
-Expectation::Expectation(
-    const internal::linked_ptr<internal::ExpectationBase>& an_expectation_base)
-    : expectation_base_(an_expectation_base) {}
-
-Expectation::~Expectation() {}
-
-// Adds an expectation to a sequence.
-void Sequence::AddExpectation(const Expectation& expectation) const {
-  if (*last_expectation_ != expectation) {
-    if (last_expectation_->expectation_base() != NULL) {
-      expectation.expectation_base()->immediate_prerequisites_
-          += *last_expectation_;
-    }
-    *last_expectation_ = expectation;
-  }
-}
-
-// Creates the implicit sequence if there isn't one.
-InSequence::InSequence() {
-  if (internal::g_gmock_implicit_sequence.get() == NULL) {
-    internal::g_gmock_implicit_sequence.set(new Sequence);
-    sequence_created_ = true;
-  } else {
-    sequence_created_ = false;
-  }
-}
-
-// Deletes the implicit sequence if it was created by the constructor
-// of this object.
-InSequence::~InSequence() {
-  if (sequence_created_) {
-    delete internal::g_gmock_implicit_sequence.get();
-    internal::g_gmock_implicit_sequence.set(NULL);
-  }
-}
-
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock.cc
deleted file mode 100644
index eac3d842..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock.cc
+++ /dev/null
@@ -1,183 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "gmock/gmock.h"
-#include "gmock/internal/gmock-port.h"
-
-namespace testing {
-
-// TODO(wan@google.com): support using environment variables to
-// control the flag values, like what Google Test does.
-
-GMOCK_DEFINE_bool_(catch_leaked_mocks, true,
-                   "true iff Google Mock should report leaked mock objects "
-                   "as failures.");
-
-GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
-                     "Controls how verbose Google Mock's output is."
-                     "  Valid values:\n"
-                     "  info    - prints all messages.\n"
-                     "  warning - prints warnings and errors.\n"
-                     "  error   - prints errors only.");
-
-namespace internal {
-
-// Parses a string as a command line flag.  The string should have the
-// format "--gmock_flag=value".  When def_optional is true, the
-// "=value" part can be omitted.
-//
-// Returns the value of the flag, or NULL if the parsing failed.
-static const char* ParseGoogleMockFlagValue(const char* str,
-                                            const char* flag,
-                                            bool def_optional) {
-  // str and flag must not be NULL.
-  if (str == NULL || flag == NULL) return NULL;
-
-  // 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 NULL;
-
-  // Skips the flag name.
-  const char* flag_end = str + flag_len;
-
-  // When def_optional is true, it's OK to not have a "=value" part.
-  if (def_optional && (flag_end[0] == '\0')) {
-    return flag_end;
-  }
-
-  // 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 NULL;
-
-  // Returns the string after "=".
-  return flag_end + 1;
-}
-
-// Parses a string for a Google Mock bool flag, in the form of
-// "--gmock_flag=value".
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
-                                    bool* 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 == NULL) 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 a Google Mock string flag, in the form of
-// "--gmock_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 ParseGoogleMockStringFlag(const char* str, const char* flag,
-                                      String* value) {
-  // Gets the value of the flag as a string.
-  const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);
-
-  // Aborts if the parsing failed.
-  if (value_str == NULL) return false;
-
-  // Sets *value to the value of the flag.
-  *value = value_str;
-  return true;
-}
-
-// The internal implementation of InitGoogleMock().
-//
-// The type parameter CharType can be instantiated to either char or
-// wchar_t.
-template <typename CharType>
-void InitGoogleMockImpl(int* argc, CharType** argv) {
-  // Makes sure Google Test is initialized.  InitGoogleTest() is
-  // idempotent, so it's fine if the user has already called it.
-  InitGoogleTest(argc, argv);
-  if (*argc <= 0) return;
-
-  for (int i = 1; i != *argc; i++) {
-    const std::string arg_string = StreamableToString(argv[i]);
-    const char* const arg = arg_string.c_str();
-
-    // Do we see a Google Mock flag?
-    if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
-                                &GMOCK_FLAG(catch_leaked_mocks)) ||
-        ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose))) {
-      // 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
-      // well.
-      for (int j = i; j != *argc; j++) {
-        argv[j] = argv[j + 1];
-      }
-
-      // Decrements the argument count.
-      (*argc)--;
-
-      // We also need to decrement the iterator as we just removed
-      // an element.
-      i--;
-    }
-  }
-}
-
-}  // namespace internal
-
-// Initializes Google Mock.  This must be called before running the
-// tests.  In particular, it parses a command line for the flags that
-// Google Mock recognizes.  Whenever a Google Mock flag is seen, it is
-// removed from argv, and *argc is decremented.
-//
-// No value is returned.  Instead, the Google Mock flag variables are
-// updated.
-//
-// Since Google Test is needed for Google Mock to work, this function
-// also initializes Google Test and parses its flags, if that hasn't
-// been done.
-GTEST_API_ void InitGoogleMock(int* argc, char** argv) {
-  internal::InitGoogleMockImpl(argc, argv);
-}
-
-// This overloaded version can be used in Windows programs compiled in
-// UNICODE mode.
-GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv) {
-  internal::InitGoogleMockImpl(argc, argv);
-}
-
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock_main.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock_main.cc
deleted file mode 100644
index bd5be03b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/src/gmock_main.cc
+++ /dev/null
@@ -1,54 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include <iostream>
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-// 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:
-// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=394464  // NOLINT
-#if GTEST_OS_WINDOWS_MOBILE
-# include <tchar.h>  // NOLINT
-
-GTEST_API_ int _tmain(int argc, TCHAR** argv) {
-#else
-GTEST_API_ int main(int argc, char** argv) {
-#endif  // GTEST_OS_WINDOWS_MOBILE
-  std::cout << "Running main() from gmock_main.cc\n";
-  // 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(&argc, argv);
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-actions_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-actions_test.cc
deleted file mode 100644
index f470de4c..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-actions_test.cc
+++ /dev/null
@@ -1,1411 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests the built-in actions.
-
-#include "gmock/gmock-actions.h"
-#include <algorithm>
-#include <iterator>
-#include <memory>
-#include <string>
-#include "gmock/gmock.h"
-#include "gmock/internal/gmock-port.h"
-#include "gtest/gtest.h"
-#include "gtest/gtest-spi.h"
-
-namespace {
-
-// This list should be kept sorted.
-using testing::Action;
-using testing::ActionInterface;
-using testing::Assign;
-using testing::ByMove;
-using testing::ByRef;
-using testing::DefaultValue;
-using testing::DoDefault;
-using testing::IgnoreResult;
-using testing::Invoke;
-using testing::InvokeWithoutArgs;
-using testing::MakePolymorphicAction;
-using testing::Ne;
-using testing::PolymorphicAction;
-using testing::Return;
-using testing::ReturnNull;
-using testing::ReturnRef;
-using testing::ReturnRefOfCopy;
-using testing::SetArgPointee;
-using testing::SetArgumentPointee;
-using testing::_;
-using testing::get;
-using testing::internal::BuiltInDefaultValue;
-using testing::internal::Int64;
-using testing::internal::UInt64;
-using testing::make_tuple;
-using testing::tuple;
-using testing::tuple_element;
-
-#if !GTEST_OS_WINDOWS_MOBILE
-using testing::SetErrnoAndReturn;
-#endif
-
-#if GTEST_HAS_PROTOBUF_
-using testing::internal::TestMessage;
-#endif  // GTEST_HAS_PROTOBUF_
-
-// Tests that BuiltInDefaultValue<T*>::Get() returns NULL.
-TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {
-  EXPECT_TRUE(BuiltInDefaultValue<int*>::Get() == NULL);
-  EXPECT_TRUE(BuiltInDefaultValue<const char*>::Get() == NULL);
-  EXPECT_TRUE(BuiltInDefaultValue<void*>::Get() == NULL);
-}
-
-// Tests that BuiltInDefaultValue<T*>::Exists() return true.
-TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) {
-  EXPECT_TRUE(BuiltInDefaultValue<int*>::Exists());
-  EXPECT_TRUE(BuiltInDefaultValue<const char*>::Exists());
-  EXPECT_TRUE(BuiltInDefaultValue<void*>::Exists());
-}
-
-// Tests that BuiltInDefaultValue<T>::Get() returns 0 when T is a
-// built-in numeric type.
-TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) {
-  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned char>::Get());
-  EXPECT_EQ(0, BuiltInDefaultValue<signed char>::Get());
-  EXPECT_EQ(0, BuiltInDefaultValue<char>::Get());
-#if GMOCK_HAS_SIGNED_WCHAR_T_
-  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned wchar_t>::Get());
-  EXPECT_EQ(0, BuiltInDefaultValue<signed wchar_t>::Get());
-#endif
-#if GMOCK_WCHAR_T_IS_NATIVE_
-  EXPECT_EQ(0, BuiltInDefaultValue<wchar_t>::Get());
-#endif
-  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned short>::Get());  // NOLINT
-  EXPECT_EQ(0, BuiltInDefaultValue<signed short>::Get());  // NOLINT
-  EXPECT_EQ(0, BuiltInDefaultValue<short>::Get());  // NOLINT
-  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned int>::Get());
-  EXPECT_EQ(0, BuiltInDefaultValue<signed int>::Get());
-  EXPECT_EQ(0, BuiltInDefaultValue<int>::Get());
-  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long>::Get());  // NOLINT
-  EXPECT_EQ(0, BuiltInDefaultValue<signed long>::Get());  // NOLINT
-  EXPECT_EQ(0, BuiltInDefaultValue<long>::Get());  // NOLINT
-  EXPECT_EQ(0U, BuiltInDefaultValue<UInt64>::Get());
-  EXPECT_EQ(0, BuiltInDefaultValue<Int64>::Get());
-  EXPECT_EQ(0, BuiltInDefaultValue<float>::Get());
-  EXPECT_EQ(0, BuiltInDefaultValue<double>::Get());
-}
-
-// Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
-// built-in numeric type.
-TEST(BuiltInDefaultValueTest, ExistsForNumericTypes) {
-  EXPECT_TRUE(BuiltInDefaultValue<unsigned char>::Exists());
-  EXPECT_TRUE(BuiltInDefaultValue<signed char>::Exists());
-  EXPECT_TRUE(BuiltInDefaultValue<char>::Exists());
-#if GMOCK_HAS_SIGNED_WCHAR_T_
-  EXPECT_TRUE(BuiltInDefaultValue<unsigned wchar_t>::Exists());
-  EXPECT_TRUE(BuiltInDefaultValue<signed wchar_t>::Exists());
-#endif
-#if GMOCK_WCHAR_T_IS_NATIVE_
-  EXPECT_TRUE(BuiltInDefaultValue<wchar_t>::Exists());
-#endif
-  EXPECT_TRUE(BuiltInDefaultValue<unsigned short>::Exists());  // NOLINT
-  EXPECT_TRUE(BuiltInDefaultValue<signed short>::Exists());  // NOLINT
-  EXPECT_TRUE(BuiltInDefaultValue<short>::Exists());  // NOLINT
-  EXPECT_TRUE(BuiltInDefaultValue<unsigned int>::Exists());
-  EXPECT_TRUE(BuiltInDefaultValue<signed int>::Exists());
-  EXPECT_TRUE(BuiltInDefaultValue<int>::Exists());
-  EXPECT_TRUE(BuiltInDefaultValue<unsigned long>::Exists());  // NOLINT
-  EXPECT_TRUE(BuiltInDefaultValue<signed long>::Exists());  // NOLINT
-  EXPECT_TRUE(BuiltInDefaultValue<long>::Exists());  // NOLINT
-  EXPECT_TRUE(BuiltInDefaultValue<UInt64>::Exists());
-  EXPECT_TRUE(BuiltInDefaultValue<Int64>::Exists());
-  EXPECT_TRUE(BuiltInDefaultValue<float>::Exists());
-  EXPECT_TRUE(BuiltInDefaultValue<double>::Exists());
-}
-
-// Tests that BuiltInDefaultValue<bool>::Get() returns false.
-TEST(BuiltInDefaultValueTest, IsFalseForBool) {
-  EXPECT_FALSE(BuiltInDefaultValue<bool>::Get());
-}
-
-// Tests that BuiltInDefaultValue<bool>::Exists() returns true.
-TEST(BuiltInDefaultValueTest, BoolExists) {
-  EXPECT_TRUE(BuiltInDefaultValue<bool>::Exists());
-}
-
-// Tests that BuiltInDefaultValue<T>::Get() returns "" when T is a
-// string type.
-TEST(BuiltInDefaultValueTest, IsEmptyStringForString) {
-#if GTEST_HAS_GLOBAL_STRING
-  EXPECT_EQ("", BuiltInDefaultValue< ::string>::Get());
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-  EXPECT_EQ("", BuiltInDefaultValue< ::std::string>::Get());
-}
-
-// Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
-// string type.
-TEST(BuiltInDefaultValueTest, ExistsForString) {
-#if GTEST_HAS_GLOBAL_STRING
-  EXPECT_TRUE(BuiltInDefaultValue< ::string>::Exists());
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-  EXPECT_TRUE(BuiltInDefaultValue< ::std::string>::Exists());
-}
-
-// Tests that BuiltInDefaultValue<const T>::Get() returns the same
-// value as BuiltInDefaultValue<T>::Get() does.
-TEST(BuiltInDefaultValueTest, WorksForConstTypes) {
-  EXPECT_EQ("", BuiltInDefaultValue<const std::string>::Get());
-  EXPECT_EQ(0, BuiltInDefaultValue<const int>::Get());
-  EXPECT_TRUE(BuiltInDefaultValue<char* const>::Get() == NULL);
-  EXPECT_FALSE(BuiltInDefaultValue<const bool>::Get());
-}
-
-// A type that's default constructible.
-class MyDefaultConstructible {
- public:
-  MyDefaultConstructible() : value_(42) {}
-
-  int value() const { return value_; }
-
- private:
-  int value_;
-};
-
-// A type that's not default constructible.
-class MyNonDefaultConstructible {
- public:
-  // Does not have a default ctor.
-  explicit MyNonDefaultConstructible(int a_value) : value_(a_value) {}
-
-  int value() const { return value_; }
-
- private:
-  int value_;
-};
-
-#if GTEST_HAS_STD_TYPE_TRAITS_
-
-TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {
-  EXPECT_TRUE(BuiltInDefaultValue<MyDefaultConstructible>::Exists());
-}
-
-TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructibleType) {
-  EXPECT_EQ(42, BuiltInDefaultValue<MyDefaultConstructible>::Get().value());
-}
-
-#endif  // GTEST_HAS_STD_TYPE_TRAITS_
-
-TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleType) {
-  EXPECT_FALSE(BuiltInDefaultValue<MyNonDefaultConstructible>::Exists());
-}
-
-// Tests that BuiltInDefaultValue<T&>::Get() aborts the program.
-TEST(BuiltInDefaultValueDeathTest, IsUndefinedForReferences) {
-  EXPECT_DEATH_IF_SUPPORTED({
-    BuiltInDefaultValue<int&>::Get();
-  }, "");
-  EXPECT_DEATH_IF_SUPPORTED({
-    BuiltInDefaultValue<const char&>::Get();
-  }, "");
-}
-
-TEST(BuiltInDefaultValueDeathTest, IsUndefinedForNonDefaultConstructibleType) {
-  EXPECT_DEATH_IF_SUPPORTED({
-    BuiltInDefaultValue<MyNonDefaultConstructible>::Get();
-  }, "");
-}
-
-// Tests that DefaultValue<T>::IsSet() is false initially.
-TEST(DefaultValueTest, IsInitiallyUnset) {
-  EXPECT_FALSE(DefaultValue<int>::IsSet());
-  EXPECT_FALSE(DefaultValue<MyDefaultConstructible>::IsSet());
-  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
-}
-
-// Tests that DefaultValue<T> can be set and then unset.
-TEST(DefaultValueTest, CanBeSetAndUnset) {
-  EXPECT_TRUE(DefaultValue<int>::Exists());
-  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
-
-  DefaultValue<int>::Set(1);
-  DefaultValue<const MyNonDefaultConstructible>::Set(
-      MyNonDefaultConstructible(42));
-
-  EXPECT_EQ(1, DefaultValue<int>::Get());
-  EXPECT_EQ(42, DefaultValue<const MyNonDefaultConstructible>::Get().value());
-
-  EXPECT_TRUE(DefaultValue<int>::Exists());
-  EXPECT_TRUE(DefaultValue<const MyNonDefaultConstructible>::Exists());
-
-  DefaultValue<int>::Clear();
-  DefaultValue<const MyNonDefaultConstructible>::Clear();
-
-  EXPECT_FALSE(DefaultValue<int>::IsSet());
-  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
-
-  EXPECT_TRUE(DefaultValue<int>::Exists());
-  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
-}
-
-// Tests that DefaultValue<T>::Get() returns the
-// BuiltInDefaultValue<T>::Get() when DefaultValue<T>::IsSet() is
-// false.
-TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
-  EXPECT_FALSE(DefaultValue<int>::IsSet());
-  EXPECT_TRUE(DefaultValue<int>::Exists());
-  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::IsSet());
-  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::Exists());
-
-  EXPECT_EQ(0, DefaultValue<int>::Get());
-
-  EXPECT_DEATH_IF_SUPPORTED({
-    DefaultValue<MyNonDefaultConstructible>::Get();
-  }, "");
-}
-
-#if GTEST_HAS_STD_UNIQUE_PTR_
-TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
-  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
-  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == NULL);
-  DefaultValue<std::unique_ptr<int>>::SetFactory([] {
-    return std::unique_ptr<int>(new int(42));
-  });
-  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
-  std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();
-  EXPECT_EQ(42, *i);
-}
-#endif  // GTEST_HAS_STD_UNIQUE_PTR_
-
-// Tests that DefaultValue<void>::Get() returns void.
-TEST(DefaultValueTest, GetWorksForVoid) {
-  return DefaultValue<void>::Get();
-}
-
-// Tests using DefaultValue with a reference type.
-
-// Tests that DefaultValue<T&>::IsSet() is false initially.
-TEST(DefaultValueOfReferenceTest, IsInitiallyUnset) {
-  EXPECT_FALSE(DefaultValue<int&>::IsSet());
-  EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::IsSet());
-  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
-}
-
-// Tests that DefaultValue<T&>::Exists is false initiallly.
-TEST(DefaultValueOfReferenceTest, IsInitiallyNotExisting) {
-  EXPECT_FALSE(DefaultValue<int&>::Exists());
-  EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::Exists());
-  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
-}
-
-// Tests that DefaultValue<T&> can be set and then unset.
-TEST(DefaultValueOfReferenceTest, CanBeSetAndUnset) {
-  int n = 1;
-  DefaultValue<const int&>::Set(n);
-  MyNonDefaultConstructible x(42);
-  DefaultValue<MyNonDefaultConstructible&>::Set(x);
-
-  EXPECT_TRUE(DefaultValue<const int&>::Exists());
-  EXPECT_TRUE(DefaultValue<MyNonDefaultConstructible&>::Exists());
-
-  EXPECT_EQ(&n, &(DefaultValue<const int&>::Get()));
-  EXPECT_EQ(&x, &(DefaultValue<MyNonDefaultConstructible&>::Get()));
-
-  DefaultValue<const int&>::Clear();
-  DefaultValue<MyNonDefaultConstructible&>::Clear();
-
-  EXPECT_FALSE(DefaultValue<const int&>::Exists());
-  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
-
-  EXPECT_FALSE(DefaultValue<const int&>::IsSet());
-  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
-}
-
-// Tests that DefaultValue<T&>::Get() returns the
-// BuiltInDefaultValue<T&>::Get() when DefaultValue<T&>::IsSet() is
-// false.
-TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
-  EXPECT_FALSE(DefaultValue<int&>::IsSet());
-  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
-
-  EXPECT_DEATH_IF_SUPPORTED({
-    DefaultValue<int&>::Get();
-  }, "");
-  EXPECT_DEATH_IF_SUPPORTED({
-    DefaultValue<MyNonDefaultConstructible>::Get();
-  }, "");
-}
-
-// Tests that ActionInterface can be implemented by defining the
-// Perform method.
-
-typedef int MyGlobalFunction(bool, int);
-
-class MyActionImpl : public ActionInterface<MyGlobalFunction> {
- public:
-  virtual int Perform(const tuple<bool, int>& args) {
-    return get<0>(args) ? get<1>(args) : 0;
-  }
-};
-
-TEST(ActionInterfaceTest, CanBeImplementedByDefiningPerform) {
-  MyActionImpl my_action_impl;
-  (void)my_action_impl;
-}
-
-TEST(ActionInterfaceTest, MakeAction) {
-  Action<MyGlobalFunction> action = MakeAction(new MyActionImpl);
-
-  // When exercising the Perform() method of Action<F>, we must pass
-  // it a tuple whose size and type are compatible with F's argument
-  // types.  For example, if F is int(), then Perform() takes a
-  // 0-tuple; if F is void(bool, int), then Perform() takes a
-  // tuple<bool, int>, and so on.
-  EXPECT_EQ(5, action.Perform(make_tuple(true, 5)));
-}
-
-// Tests that Action<F> can be contructed from a pointer to
-// ActionInterface<F>.
-TEST(ActionTest, CanBeConstructedFromActionInterface) {
-  Action<MyGlobalFunction> action(new MyActionImpl);
-}
-
-// Tests that Action<F> delegates actual work to ActionInterface<F>.
-TEST(ActionTest, DelegatesWorkToActionInterface) {
-  const Action<MyGlobalFunction> action(new MyActionImpl);
-
-  EXPECT_EQ(5, action.Perform(make_tuple(true, 5)));
-  EXPECT_EQ(0, action.Perform(make_tuple(false, 1)));
-}
-
-// Tests that Action<F> can be copied.
-TEST(ActionTest, IsCopyable) {
-  Action<MyGlobalFunction> a1(new MyActionImpl);
-  Action<MyGlobalFunction> a2(a1);  // Tests the copy constructor.
-
-  // a1 should continue to work after being copied from.
-  EXPECT_EQ(5, a1.Perform(make_tuple(true, 5)));
-  EXPECT_EQ(0, a1.Perform(make_tuple(false, 1)));
-
-  // a2 should work like the action it was copied from.
-  EXPECT_EQ(5, a2.Perform(make_tuple(true, 5)));
-  EXPECT_EQ(0, a2.Perform(make_tuple(false, 1)));
-
-  a2 = a1;  // Tests the assignment operator.
-
-  // a1 should continue to work after being copied from.
-  EXPECT_EQ(5, a1.Perform(make_tuple(true, 5)));
-  EXPECT_EQ(0, a1.Perform(make_tuple(false, 1)));
-
-  // a2 should work like the action it was copied from.
-  EXPECT_EQ(5, a2.Perform(make_tuple(true, 5)));
-  EXPECT_EQ(0, a2.Perform(make_tuple(false, 1)));
-}
-
-// Tests that an Action<From> object can be converted to a
-// compatible Action<To> object.
-
-class IsNotZero : public ActionInterface<bool(int)> {  // NOLINT
- public:
-  virtual bool Perform(const tuple<int>& arg) {
-    return get<0>(arg) != 0;
-  }
-};
-
-#if !GTEST_OS_SYMBIAN
-// Compiling this test on Nokia's Symbian compiler fails with:
-//  'Result' is not a member of class 'testing::internal::Function<int>'
-//  (point of instantiation: '@unnamed@gmock_actions_test_cc@::
-//      ActionTest_CanBeConvertedToOtherActionType_Test::TestBody()')
-// with no obvious fix.
-TEST(ActionTest, CanBeConvertedToOtherActionType) {
-  const Action<bool(int)> a1(new IsNotZero);  // NOLINT
-  const Action<int(char)> a2 = Action<int(char)>(a1);  // NOLINT
-  EXPECT_EQ(1, a2.Perform(make_tuple('a')));
-  EXPECT_EQ(0, a2.Perform(make_tuple('\0')));
-}
-#endif  // !GTEST_OS_SYMBIAN
-
-// The following two classes are for testing MakePolymorphicAction().
-
-// Implements a polymorphic action that returns the second of the
-// arguments it receives.
-class ReturnSecondArgumentAction {
- public:
-  // We want to verify that MakePolymorphicAction() can work with a
-  // polymorphic action whose Perform() method template is either
-  // const or not.  This lets us verify the non-const case.
-  template <typename Result, typename ArgumentTuple>
-  Result Perform(const ArgumentTuple& args) { return get<1>(args); }
-};
-
-// Implements a polymorphic action that can be used in a nullary
-// function to return 0.
-class ReturnZeroFromNullaryFunctionAction {
- public:
-  // For testing that MakePolymorphicAction() works when the
-  // implementation class' Perform() method template takes only one
-  // template parameter.
-  //
-  // We want to verify that MakePolymorphicAction() can work with a
-  // polymorphic action whose Perform() method template is either
-  // const or not.  This lets us verify the const case.
-  template <typename Result>
-  Result Perform(const tuple<>&) const { return 0; }
-};
-
-// These functions verify that MakePolymorphicAction() returns a
-// PolymorphicAction<T> where T is the argument's type.
-
-PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
-  return MakePolymorphicAction(ReturnSecondArgumentAction());
-}
-
-PolymorphicAction<ReturnZeroFromNullaryFunctionAction>
-ReturnZeroFromNullaryFunction() {
-  return MakePolymorphicAction(ReturnZeroFromNullaryFunctionAction());
-}
-
-// Tests that MakePolymorphicAction() turns a polymorphic action
-// implementation class into a polymorphic action.
-TEST(MakePolymorphicActionTest, ConstructsActionFromImpl) {
-  Action<int(bool, int, double)> a1 = ReturnSecondArgument();  // NOLINT
-  EXPECT_EQ(5, a1.Perform(make_tuple(false, 5, 2.0)));
-}
-
-// Tests that MakePolymorphicAction() works when the implementation
-// class' Perform() method template has only one template parameter.
-TEST(MakePolymorphicActionTest, WorksWhenPerformHasOneTemplateParameter) {
-  Action<int()> a1 = ReturnZeroFromNullaryFunction();
-  EXPECT_EQ(0, a1.Perform(make_tuple()));
-
-  Action<void*()> a2 = ReturnZeroFromNullaryFunction();
-  EXPECT_TRUE(a2.Perform(make_tuple()) == NULL);
-}
-
-// Tests that Return() works as an action for void-returning
-// functions.
-TEST(ReturnTest, WorksForVoid) {
-  const Action<void(int)> ret = Return();  // NOLINT
-  return ret.Perform(make_tuple(1));
-}
-
-// Tests that Return(v) returns v.
-TEST(ReturnTest, ReturnsGivenValue) {
-  Action<int()> ret = Return(1);  // NOLINT
-  EXPECT_EQ(1, ret.Perform(make_tuple()));
-
-  ret = Return(-5);
-  EXPECT_EQ(-5, ret.Perform(make_tuple()));
-}
-
-// Tests that Return("string literal") works.
-TEST(ReturnTest, AcceptsStringLiteral) {
-  Action<const char*()> a1 = Return("Hello");
-  EXPECT_STREQ("Hello", a1.Perform(make_tuple()));
-
-  Action<std::string()> a2 = Return("world");
-  EXPECT_EQ("world", a2.Perform(make_tuple()));
-}
-
-// Test struct which wraps a vector of integers. Used in
-// 'SupportsWrapperReturnType' test.
-struct IntegerVectorWrapper {
-  std::vector<int> * v;
-  IntegerVectorWrapper(std::vector<int>& _v) : v(&_v) {}  // NOLINT
-};
-
-// Tests that Return() works when return type is a wrapper type.
-TEST(ReturnTest, SupportsWrapperReturnType) {
-  // Initialize vector of integers.
-  std::vector<int> v;
-  for (int i = 0; i < 5; ++i) v.push_back(i);
-
-  // Return() called with 'v' as argument. The Action will return the same data
-  // as 'v' (copy) but it will be wrapped in an IntegerVectorWrapper.
-  Action<IntegerVectorWrapper()> a = Return(v);
-  const std::vector<int>& result = *(a.Perform(make_tuple()).v);
-  EXPECT_THAT(result, ::testing::ElementsAre(0, 1, 2, 3, 4));
-}
-
-// Tests that Return(v) is covaraint.
-
-struct Base {
-  bool operator==(const Base&) { return true; }
-};
-
-struct Derived : public Base {
-  bool operator==(const Derived&) { return true; }
-};
-
-TEST(ReturnTest, IsCovariant) {
-  Base base;
-  Derived derived;
-  Action<Base*()> ret = Return(&base);
-  EXPECT_EQ(&base, ret.Perform(make_tuple()));
-
-  ret = Return(&derived);
-  EXPECT_EQ(&derived, ret.Perform(make_tuple()));
-}
-
-// Tests that the type of the value passed into Return is converted into T
-// when the action is cast to Action<T(...)> rather than when the action is
-// performed. See comments on testing::internal::ReturnAction in
-// gmock-actions.h for more information.
-class FromType {
- public:
-  explicit FromType(bool* is_converted) : converted_(is_converted) {}
-  bool* converted() const { return converted_; }
-
- private:
-  bool* const converted_;
-
-  GTEST_DISALLOW_ASSIGN_(FromType);
-};
-
-class ToType {
- public:
-  // Must allow implicit conversion due to use in ImplicitCast_<T>.
-  ToType(const FromType& x) { *x.converted() = true; }  // NOLINT
-};
-
-TEST(ReturnTest, ConvertsArgumentWhenConverted) {
-  bool converted = false;
-  FromType x(&converted);
-  Action<ToType()> action(Return(x));
-  EXPECT_TRUE(converted) << "Return must convert its argument in its own "
-                         << "conversion operator.";
-  converted = false;
-  action.Perform(tuple<>());
-  EXPECT_FALSE(converted) << "Action must NOT convert its argument "
-                          << "when performed.";
-}
-
-class DestinationType {};
-
-class SourceType {
- public:
-  // Note: a non-const typecast operator.
-  operator DestinationType() { return DestinationType(); }
-};
-
-TEST(ReturnTest, CanConvertArgumentUsingNonConstTypeCastOperator) {
-  SourceType s;
-  Action<DestinationType()> action(Return(s));
-}
-
-// Tests that ReturnNull() returns NULL in a pointer-returning function.
-TEST(ReturnNullTest, WorksInPointerReturningFunction) {
-  const Action<int*()> a1 = ReturnNull();
-  EXPECT_TRUE(a1.Perform(make_tuple()) == NULL);
-
-  const Action<const char*(bool)> a2 = ReturnNull();  // NOLINT
-  EXPECT_TRUE(a2.Perform(make_tuple(true)) == NULL);
-}
-
-#if GTEST_HAS_STD_UNIQUE_PTR_
-// Tests that ReturnNull() returns NULL for shared_ptr and unique_ptr returning
-// functions.
-TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) {
-  const Action<std::unique_ptr<const int>()> a1 = ReturnNull();
-  EXPECT_TRUE(a1.Perform(make_tuple()) == nullptr);
-
-  const Action<std::shared_ptr<int>(std::string)> a2 = ReturnNull();
-  EXPECT_TRUE(a2.Perform(make_tuple("foo")) == nullptr);
-}
-#endif  // GTEST_HAS_STD_UNIQUE_PTR_
-
-// Tests that ReturnRef(v) works for reference types.
-TEST(ReturnRefTest, WorksForReference) {
-  const int n = 0;
-  const Action<const int&(bool)> ret = ReturnRef(n);  // NOLINT
-
-  EXPECT_EQ(&n, &ret.Perform(make_tuple(true)));
-}
-
-// Tests that ReturnRef(v) is covariant.
-TEST(ReturnRefTest, IsCovariant) {
-  Base base;
-  Derived derived;
-  Action<Base&()> a = ReturnRef(base);
-  EXPECT_EQ(&base, &a.Perform(make_tuple()));
-
-  a = ReturnRef(derived);
-  EXPECT_EQ(&derived, &a.Perform(make_tuple()));
-}
-
-// Tests that ReturnRefOfCopy(v) works for reference types.
-TEST(ReturnRefOfCopyTest, WorksForReference) {
-  int n = 42;
-  const Action<const int&()> ret = ReturnRefOfCopy(n);
-
-  EXPECT_NE(&n, &ret.Perform(make_tuple()));
-  EXPECT_EQ(42, ret.Perform(make_tuple()));
-
-  n = 43;
-  EXPECT_NE(&n, &ret.Perform(make_tuple()));
-  EXPECT_EQ(42, ret.Perform(make_tuple()));
-}
-
-// Tests that ReturnRefOfCopy(v) is covariant.
-TEST(ReturnRefOfCopyTest, IsCovariant) {
-  Base base;
-  Derived derived;
-  Action<Base&()> a = ReturnRefOfCopy(base);
-  EXPECT_NE(&base, &a.Perform(make_tuple()));
-
-  a = ReturnRefOfCopy(derived);
-  EXPECT_NE(&derived, &a.Perform(make_tuple()));
-}
-
-// Tests that DoDefault() does the default action for the mock method.
-
-class MockClass {
- public:
-  MockClass() {}
-
-  MOCK_METHOD1(IntFunc, int(bool flag));  // NOLINT
-  MOCK_METHOD0(Foo, MyNonDefaultConstructible());
-#if GTEST_HAS_STD_UNIQUE_PTR_
-  MOCK_METHOD0(MakeUnique, std::unique_ptr<int>());
-  MOCK_METHOD0(MakeUniqueBase, std::unique_ptr<Base>());
-  MOCK_METHOD0(MakeVectorUnique, std::vector<std::unique_ptr<int>>());
-#endif
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass);
-};
-
-// Tests that DoDefault() returns the built-in default value for the
-// return type by default.
-TEST(DoDefaultTest, ReturnsBuiltInDefaultValueByDefault) {
-  MockClass mock;
-  EXPECT_CALL(mock, IntFunc(_))
-      .WillOnce(DoDefault());
-  EXPECT_EQ(0, mock.IntFunc(true));
-}
-
-// Tests that DoDefault() throws (when exceptions are enabled) or aborts
-// the process when there is no built-in default value for the return type.
-TEST(DoDefaultDeathTest, DiesForUnknowType) {
-  MockClass mock;
-  EXPECT_CALL(mock, Foo())
-      .WillRepeatedly(DoDefault());
-#if GTEST_HAS_EXCEPTIONS
-  EXPECT_ANY_THROW(mock.Foo());
-#else
-  EXPECT_DEATH_IF_SUPPORTED({
-    mock.Foo();
-  }, "");
-#endif
-}
-
-// Tests that using DoDefault() inside a composite action leads to a
-// run-time error.
-
-void VoidFunc(bool /* flag */) {}
-
-TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
-  MockClass mock;
-  EXPECT_CALL(mock, IntFunc(_))
-      .WillRepeatedly(DoAll(Invoke(VoidFunc),
-                            DoDefault()));
-
-  // Ideally we should verify the error message as well.  Sadly,
-  // EXPECT_DEATH() can only capture stderr, while Google Mock's
-  // errors are printed on stdout.  Therefore we have to settle for
-  // not verifying the message.
-  EXPECT_DEATH_IF_SUPPORTED({
-    mock.IntFunc(true);
-  }, "");
-}
-
-// Tests that DoDefault() returns the default value set by
-// DefaultValue<T>::Set() when it's not overriden by an ON_CALL().
-TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIsOne) {
-  DefaultValue<int>::Set(1);
-  MockClass mock;
-  EXPECT_CALL(mock, IntFunc(_))
-      .WillOnce(DoDefault());
-  EXPECT_EQ(1, mock.IntFunc(false));
-  DefaultValue<int>::Clear();
-}
-
-// Tests that DoDefault() does the action specified by ON_CALL().
-TEST(DoDefaultTest, DoesWhatOnCallSpecifies) {
-  MockClass mock;
-  ON_CALL(mock, IntFunc(_))
-      .WillByDefault(Return(2));
-  EXPECT_CALL(mock, IntFunc(_))
-      .WillOnce(DoDefault());
-  EXPECT_EQ(2, mock.IntFunc(false));
-}
-
-// Tests that using DoDefault() in ON_CALL() leads to a run-time failure.
-TEST(DoDefaultTest, CannotBeUsedInOnCall) {
-  MockClass mock;
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    ON_CALL(mock, IntFunc(_))
-      .WillByDefault(DoDefault());
-  }, "DoDefault() cannot be used in ON_CALL()");
-}
-
-// Tests that SetArgPointee<N>(v) sets the variable pointed to by
-// the N-th (0-based) argument to v.
-TEST(SetArgPointeeTest, SetsTheNthPointee) {
-  typedef void MyFunction(bool, int*, char*);
-  Action<MyFunction> a = SetArgPointee<1>(2);
-
-  int n = 0;
-  char ch = '\0';
-  a.Perform(make_tuple(true, &n, &ch));
-  EXPECT_EQ(2, n);
-  EXPECT_EQ('\0', ch);
-
-  a = SetArgPointee<2>('a');
-  n = 0;
-  ch = '\0';
-  a.Perform(make_tuple(true, &n, &ch));
-  EXPECT_EQ(0, n);
-  EXPECT_EQ('a', ch);
-}
-
-#if !((GTEST_GCC_VER_ && GTEST_GCC_VER_ < 40000) || GTEST_OS_SYMBIAN)
-// Tests that SetArgPointee<N>() accepts a string literal.
-// GCC prior to v4.0 and the Symbian compiler do not support this.
-TEST(SetArgPointeeTest, AcceptsStringLiteral) {
-  typedef void MyFunction(std::string*, const char**);
-  Action<MyFunction> a = SetArgPointee<0>("hi");
-  std::string str;
-  const char* ptr = NULL;
-  a.Perform(make_tuple(&str, &ptr));
-  EXPECT_EQ("hi", str);
-  EXPECT_TRUE(ptr == NULL);
-
-  a = SetArgPointee<1>("world");
-  str = "";
-  a.Perform(make_tuple(&str, &ptr));
-  EXPECT_EQ("", str);
-  EXPECT_STREQ("world", ptr);
-}
-
-TEST(SetArgPointeeTest, AcceptsWideStringLiteral) {
-  typedef void MyFunction(const wchar_t**);
-  Action<MyFunction> a = SetArgPointee<0>(L"world");
-  const wchar_t* ptr = NULL;
-  a.Perform(make_tuple(&ptr));
-  EXPECT_STREQ(L"world", ptr);
-
-# if GTEST_HAS_STD_WSTRING
-
-  typedef void MyStringFunction(std::wstring*);
-  Action<MyStringFunction> a2 = SetArgPointee<0>(L"world");
-  std::wstring str = L"";
-  a2.Perform(make_tuple(&str));
-  EXPECT_EQ(L"world", str);
-
-# endif
-}
-#endif
-
-// Tests that SetArgPointee<N>() accepts a char pointer.
-TEST(SetArgPointeeTest, AcceptsCharPointer) {
-  typedef void MyFunction(bool, std::string*, const char**);
-  const char* const hi = "hi";
-  Action<MyFunction> a = SetArgPointee<1>(hi);
-  std::string str;
-  const char* ptr = NULL;
-  a.Perform(make_tuple(true, &str, &ptr));
-  EXPECT_EQ("hi", str);
-  EXPECT_TRUE(ptr == NULL);
-
-  char world_array[] = "world";
-  char* const world = world_array;
-  a = SetArgPointee<2>(world);
-  str = "";
-  a.Perform(make_tuple(true, &str, &ptr));
-  EXPECT_EQ("", str);
-  EXPECT_EQ(world, ptr);
-}
-
-TEST(SetArgPointeeTest, AcceptsWideCharPointer) {
-  typedef void MyFunction(bool, const wchar_t**);
-  const wchar_t* const hi = L"hi";
-  Action<MyFunction> a = SetArgPointee<1>(hi);
-  const wchar_t* ptr = NULL;
-  a.Perform(make_tuple(true, &ptr));
-  EXPECT_EQ(hi, ptr);
-
-# if GTEST_HAS_STD_WSTRING
-
-  typedef void MyStringFunction(bool, std::wstring*);
-  wchar_t world_array[] = L"world";
-  wchar_t* const world = world_array;
-  Action<MyStringFunction> a2 = SetArgPointee<1>(world);
-  std::wstring str;
-  a2.Perform(make_tuple(true, &str));
-  EXPECT_EQ(world_array, str);
-# endif
-}
-
-#if GTEST_HAS_PROTOBUF_
-
-// Tests that SetArgPointee<N>(proto_buffer) sets the v1 protobuf
-// variable pointed to by the N-th (0-based) argument to proto_buffer.
-TEST(SetArgPointeeTest, SetsTheNthPointeeOfProtoBufferType) {
-  TestMessage* const msg = new TestMessage;
-  msg->set_member("yes");
-  TestMessage orig_msg;
-  orig_msg.CopyFrom(*msg);
-
-  Action<void(bool, TestMessage*)> a = SetArgPointee<1>(*msg);
-  // SetArgPointee<N>(proto_buffer) makes a copy of proto_buffer
-  // s.t. the action works even when the original proto_buffer has
-  // died.  We ensure this behavior by deleting msg before using the
-  // action.
-  delete msg;
-
-  TestMessage dest;
-  EXPECT_FALSE(orig_msg.Equals(dest));
-  a.Perform(make_tuple(true, &dest));
-  EXPECT_TRUE(orig_msg.Equals(dest));
-}
-
-// Tests that SetArgPointee<N>(proto_buffer) sets the
-// ::ProtocolMessage variable pointed to by the N-th (0-based)
-// argument to proto_buffer.
-TEST(SetArgPointeeTest, SetsTheNthPointeeOfProtoBufferBaseType) {
-  TestMessage* const msg = new TestMessage;
-  msg->set_member("yes");
-  TestMessage orig_msg;
-  orig_msg.CopyFrom(*msg);
-
-  Action<void(bool, ::ProtocolMessage*)> a = SetArgPointee<1>(*msg);
-  // SetArgPointee<N>(proto_buffer) makes a copy of proto_buffer
-  // s.t. the action works even when the original proto_buffer has
-  // died.  We ensure this behavior by deleting msg before using the
-  // action.
-  delete msg;
-
-  TestMessage dest;
-  ::ProtocolMessage* const dest_base = &dest;
-  EXPECT_FALSE(orig_msg.Equals(dest));
-  a.Perform(make_tuple(true, dest_base));
-  EXPECT_TRUE(orig_msg.Equals(dest));
-}
-
-// Tests that SetArgPointee<N>(proto2_buffer) sets the v2
-// protobuf variable pointed to by the N-th (0-based) argument to
-// proto2_buffer.
-TEST(SetArgPointeeTest, SetsTheNthPointeeOfProto2BufferType) {
-  using testing::internal::FooMessage;
-  FooMessage* const msg = new FooMessage;
-  msg->set_int_field(2);
-  msg->set_string_field("hi");
-  FooMessage orig_msg;
-  orig_msg.CopyFrom(*msg);
-
-  Action<void(bool, FooMessage*)> a = SetArgPointee<1>(*msg);
-  // SetArgPointee<N>(proto2_buffer) makes a copy of
-  // proto2_buffer s.t. the action works even when the original
-  // proto2_buffer has died.  We ensure this behavior by deleting msg
-  // before using the action.
-  delete msg;
-
-  FooMessage dest;
-  dest.set_int_field(0);
-  a.Perform(make_tuple(true, &dest));
-  EXPECT_EQ(2, dest.int_field());
-  EXPECT_EQ("hi", dest.string_field());
-}
-
-// Tests that SetArgPointee<N>(proto2_buffer) sets the
-// proto2::Message variable pointed to by the N-th (0-based) argument
-// to proto2_buffer.
-TEST(SetArgPointeeTest, SetsTheNthPointeeOfProto2BufferBaseType) {
-  using testing::internal::FooMessage;
-  FooMessage* const msg = new FooMessage;
-  msg->set_int_field(2);
-  msg->set_string_field("hi");
-  FooMessage orig_msg;
-  orig_msg.CopyFrom(*msg);
-
-  Action<void(bool, ::proto2::Message*)> a = SetArgPointee<1>(*msg);
-  // SetArgPointee<N>(proto2_buffer) makes a copy of
-  // proto2_buffer s.t. the action works even when the original
-  // proto2_buffer has died.  We ensure this behavior by deleting msg
-  // before using the action.
-  delete msg;
-
-  FooMessage dest;
-  dest.set_int_field(0);
-  ::proto2::Message* const dest_base = &dest;
-  a.Perform(make_tuple(true, dest_base));
-  EXPECT_EQ(2, dest.int_field());
-  EXPECT_EQ("hi", dest.string_field());
-}
-
-#endif  // GTEST_HAS_PROTOBUF_
-
-// Tests that SetArgumentPointee<N>(v) sets the variable pointed to by
-// the N-th (0-based) argument to v.
-TEST(SetArgumentPointeeTest, SetsTheNthPointee) {
-  typedef void MyFunction(bool, int*, char*);
-  Action<MyFunction> a = SetArgumentPointee<1>(2);
-
-  int n = 0;
-  char ch = '\0';
-  a.Perform(make_tuple(true, &n, &ch));
-  EXPECT_EQ(2, n);
-  EXPECT_EQ('\0', ch);
-
-  a = SetArgumentPointee<2>('a');
-  n = 0;
-  ch = '\0';
-  a.Perform(make_tuple(true, &n, &ch));
-  EXPECT_EQ(0, n);
-  EXPECT_EQ('a', ch);
-}
-
-#if GTEST_HAS_PROTOBUF_
-
-// Tests that SetArgumentPointee<N>(proto_buffer) sets the v1 protobuf
-// variable pointed to by the N-th (0-based) argument to proto_buffer.
-TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProtoBufferType) {
-  TestMessage* const msg = new TestMessage;
-  msg->set_member("yes");
-  TestMessage orig_msg;
-  orig_msg.CopyFrom(*msg);
-
-  Action<void(bool, TestMessage*)> a = SetArgumentPointee<1>(*msg);
-  // SetArgumentPointee<N>(proto_buffer) makes a copy of proto_buffer
-  // s.t. the action works even when the original proto_buffer has
-  // died.  We ensure this behavior by deleting msg before using the
-  // action.
-  delete msg;
-
-  TestMessage dest;
-  EXPECT_FALSE(orig_msg.Equals(dest));
-  a.Perform(make_tuple(true, &dest));
-  EXPECT_TRUE(orig_msg.Equals(dest));
-}
-
-// Tests that SetArgumentPointee<N>(proto_buffer) sets the
-// ::ProtocolMessage variable pointed to by the N-th (0-based)
-// argument to proto_buffer.
-TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProtoBufferBaseType) {
-  TestMessage* const msg = new TestMessage;
-  msg->set_member("yes");
-  TestMessage orig_msg;
-  orig_msg.CopyFrom(*msg);
-
-  Action<void(bool, ::ProtocolMessage*)> a = SetArgumentPointee<1>(*msg);
-  // SetArgumentPointee<N>(proto_buffer) makes a copy of proto_buffer
-  // s.t. the action works even when the original proto_buffer has
-  // died.  We ensure this behavior by deleting msg before using the
-  // action.
-  delete msg;
-
-  TestMessage dest;
-  ::ProtocolMessage* const dest_base = &dest;
-  EXPECT_FALSE(orig_msg.Equals(dest));
-  a.Perform(make_tuple(true, dest_base));
-  EXPECT_TRUE(orig_msg.Equals(dest));
-}
-
-// Tests that SetArgumentPointee<N>(proto2_buffer) sets the v2
-// protobuf variable pointed to by the N-th (0-based) argument to
-// proto2_buffer.
-TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProto2BufferType) {
-  using testing::internal::FooMessage;
-  FooMessage* const msg = new FooMessage;
-  msg->set_int_field(2);
-  msg->set_string_field("hi");
-  FooMessage orig_msg;
-  orig_msg.CopyFrom(*msg);
-
-  Action<void(bool, FooMessage*)> a = SetArgumentPointee<1>(*msg);
-  // SetArgumentPointee<N>(proto2_buffer) makes a copy of
-  // proto2_buffer s.t. the action works even when the original
-  // proto2_buffer has died.  We ensure this behavior by deleting msg
-  // before using the action.
-  delete msg;
-
-  FooMessage dest;
-  dest.set_int_field(0);
-  a.Perform(make_tuple(true, &dest));
-  EXPECT_EQ(2, dest.int_field());
-  EXPECT_EQ("hi", dest.string_field());
-}
-
-// Tests that SetArgumentPointee<N>(proto2_buffer) sets the
-// proto2::Message variable pointed to by the N-th (0-based) argument
-// to proto2_buffer.
-TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProto2BufferBaseType) {
-  using testing::internal::FooMessage;
-  FooMessage* const msg = new FooMessage;
-  msg->set_int_field(2);
-  msg->set_string_field("hi");
-  FooMessage orig_msg;
-  orig_msg.CopyFrom(*msg);
-
-  Action<void(bool, ::proto2::Message*)> a = SetArgumentPointee<1>(*msg);
-  // SetArgumentPointee<N>(proto2_buffer) makes a copy of
-  // proto2_buffer s.t. the action works even when the original
-  // proto2_buffer has died.  We ensure this behavior by deleting msg
-  // before using the action.
-  delete msg;
-
-  FooMessage dest;
-  dest.set_int_field(0);
-  ::proto2::Message* const dest_base = &dest;
-  a.Perform(make_tuple(true, dest_base));
-  EXPECT_EQ(2, dest.int_field());
-  EXPECT_EQ("hi", dest.string_field());
-}
-
-#endif  // GTEST_HAS_PROTOBUF_
-
-// Sample functions and functors for testing Invoke() and etc.
-int Nullary() { return 1; }
-
-class NullaryFunctor {
- public:
-  int operator()() { return 2; }
-};
-
-bool g_done = false;
-void VoidNullary() { g_done = true; }
-
-class VoidNullaryFunctor {
- public:
-  void operator()() { g_done = true; }
-};
-
-class Foo {
- public:
-  Foo() : value_(123) {}
-
-  int Nullary() const { return value_; }
-
- private:
-  int value_;
-};
-
-// Tests InvokeWithoutArgs(function).
-TEST(InvokeWithoutArgsTest, Function) {
-  // As an action that takes one argument.
-  Action<int(int)> a = InvokeWithoutArgs(Nullary);  // NOLINT
-  EXPECT_EQ(1, a.Perform(make_tuple(2)));
-
-  // As an action that takes two arguments.
-  Action<int(int, double)> a2 = InvokeWithoutArgs(Nullary);  // NOLINT
-  EXPECT_EQ(1, a2.Perform(make_tuple(2, 3.5)));
-
-  // As an action that returns void.
-  Action<void(int)> a3 = InvokeWithoutArgs(VoidNullary);  // NOLINT
-  g_done = false;
-  a3.Perform(make_tuple(1));
-  EXPECT_TRUE(g_done);
-}
-
-// Tests InvokeWithoutArgs(functor).
-TEST(InvokeWithoutArgsTest, Functor) {
-  // As an action that takes no argument.
-  Action<int()> a = InvokeWithoutArgs(NullaryFunctor());  // NOLINT
-  EXPECT_EQ(2, a.Perform(make_tuple()));
-
-  // As an action that takes three arguments.
-  Action<int(int, double, char)> a2 =  // NOLINT
-      InvokeWithoutArgs(NullaryFunctor());
-  EXPECT_EQ(2, a2.Perform(make_tuple(3, 3.5, 'a')));
-
-  // As an action that returns void.
-  Action<void()> a3 = InvokeWithoutArgs(VoidNullaryFunctor());
-  g_done = false;
-  a3.Perform(make_tuple());
-  EXPECT_TRUE(g_done);
-}
-
-// Tests InvokeWithoutArgs(obj_ptr, method).
-TEST(InvokeWithoutArgsTest, Method) {
-  Foo foo;
-  Action<int(bool, char)> a =  // NOLINT
-      InvokeWithoutArgs(&foo, &Foo::Nullary);
-  EXPECT_EQ(123, a.Perform(make_tuple(true, 'a')));
-}
-
-// Tests using IgnoreResult() on a polymorphic action.
-TEST(IgnoreResultTest, PolymorphicAction) {
-  Action<void(int)> a = IgnoreResult(Return(5));  // NOLINT
-  a.Perform(make_tuple(1));
-}
-
-// Tests using IgnoreResult() on a monomorphic action.
-
-int ReturnOne() {
-  g_done = true;
-  return 1;
-}
-
-TEST(IgnoreResultTest, MonomorphicAction) {
-  g_done = false;
-  Action<void()> a = IgnoreResult(Invoke(ReturnOne));
-  a.Perform(make_tuple());
-  EXPECT_TRUE(g_done);
-}
-
-// Tests using IgnoreResult() on an action that returns a class type.
-
-MyNonDefaultConstructible ReturnMyNonDefaultConstructible(double /* x */) {
-  g_done = true;
-  return MyNonDefaultConstructible(42);
-}
-
-TEST(IgnoreResultTest, ActionReturningClass) {
-  g_done = false;
-  Action<void(int)> a =
-      IgnoreResult(Invoke(ReturnMyNonDefaultConstructible));  // NOLINT
-  a.Perform(make_tuple(2));
-  EXPECT_TRUE(g_done);
-}
-
-TEST(AssignTest, Int) {
-  int x = 0;
-  Action<void(int)> a = Assign(&x, 5);
-  a.Perform(make_tuple(0));
-  EXPECT_EQ(5, x);
-}
-
-TEST(AssignTest, String) {
-  ::std::string x;
-  Action<void(void)> a = Assign(&x, "Hello, world");
-  a.Perform(make_tuple());
-  EXPECT_EQ("Hello, world", x);
-}
-
-TEST(AssignTest, CompatibleTypes) {
-  double x = 0;
-  Action<void(int)> a = Assign(&x, 5);
-  a.Perform(make_tuple(0));
-  EXPECT_DOUBLE_EQ(5, x);
-}
-
-#if !GTEST_OS_WINDOWS_MOBILE
-
-class SetErrnoAndReturnTest : public testing::Test {
- protected:
-  virtual void SetUp() { errno = 0; }
-  virtual void TearDown() { errno = 0; }
-};
-
-TEST_F(SetErrnoAndReturnTest, Int) {
-  Action<int(void)> a = SetErrnoAndReturn(ENOTTY, -5);
-  EXPECT_EQ(-5, a.Perform(make_tuple()));
-  EXPECT_EQ(ENOTTY, errno);
-}
-
-TEST_F(SetErrnoAndReturnTest, Ptr) {
-  int x;
-  Action<int*(void)> a = SetErrnoAndReturn(ENOTTY, &x);
-  EXPECT_EQ(&x, a.Perform(make_tuple()));
-  EXPECT_EQ(ENOTTY, errno);
-}
-
-TEST_F(SetErrnoAndReturnTest, CompatibleTypes) {
-  Action<double()> a = SetErrnoAndReturn(EINVAL, 5);
-  EXPECT_DOUBLE_EQ(5.0, a.Perform(make_tuple()));
-  EXPECT_EQ(EINVAL, errno);
-}
-
-#endif  // !GTEST_OS_WINDOWS_MOBILE
-
-// Tests ByRef().
-
-// Tests that ReferenceWrapper<T> is copyable.
-TEST(ByRefTest, IsCopyable) {
-  const std::string s1 = "Hi";
-  const std::string s2 = "Hello";
-
-  ::testing::internal::ReferenceWrapper<const std::string> ref_wrapper =
-      ByRef(s1);
-  const std::string& r1 = ref_wrapper;
-  EXPECT_EQ(&s1, &r1);
-
-  // Assigns a new value to ref_wrapper.
-  ref_wrapper = ByRef(s2);
-  const std::string& r2 = ref_wrapper;
-  EXPECT_EQ(&s2, &r2);
-
-  ::testing::internal::ReferenceWrapper<const std::string> ref_wrapper1 =
-      ByRef(s1);
-  // Copies ref_wrapper1 to ref_wrapper.
-  ref_wrapper = ref_wrapper1;
-  const std::string& r3 = ref_wrapper;
-  EXPECT_EQ(&s1, &r3);
-}
-
-// Tests using ByRef() on a const value.
-TEST(ByRefTest, ConstValue) {
-  const int n = 0;
-  // int& ref = ByRef(n);  // This shouldn't compile - we have a
-                           // negative compilation test to catch it.
-  const int& const_ref = ByRef(n);
-  EXPECT_EQ(&n, &const_ref);
-}
-
-// Tests using ByRef() on a non-const value.
-TEST(ByRefTest, NonConstValue) {
-  int n = 0;
-
-  // ByRef(n) can be used as either an int&,
-  int& ref = ByRef(n);
-  EXPECT_EQ(&n, &ref);
-
-  // or a const int&.
-  const int& const_ref = ByRef(n);
-  EXPECT_EQ(&n, &const_ref);
-}
-
-// Tests explicitly specifying the type when using ByRef().
-TEST(ByRefTest, ExplicitType) {
-  int n = 0;
-  const int& r1 = ByRef<const int>(n);
-  EXPECT_EQ(&n, &r1);
-
-  // ByRef<char>(n);  // This shouldn't compile - we have a negative
-                      // compilation test to catch it.
-
-  Derived d;
-  Derived& r2 = ByRef<Derived>(d);
-  EXPECT_EQ(&d, &r2);
-
-  const Derived& r3 = ByRef<const Derived>(d);
-  EXPECT_EQ(&d, &r3);
-
-  Base& r4 = ByRef<Base>(d);
-  EXPECT_EQ(&d, &r4);
-
-  const Base& r5 = ByRef<const Base>(d);
-  EXPECT_EQ(&d, &r5);
-
-  // The following shouldn't compile - we have a negative compilation
-  // test for it.
-  //
-  // Base b;
-  // ByRef<Derived>(b);
-}
-
-// Tests that Google Mock prints expression ByRef(x) as a reference to x.
-TEST(ByRefTest, PrintsCorrectly) {
-  int n = 42;
-  ::std::stringstream expected, actual;
-  testing::internal::UniversalPrinter<const int&>::Print(n, &expected);
-  testing::internal::UniversalPrint(ByRef(n), &actual);
-  EXPECT_EQ(expected.str(), actual.str());
-}
-
-#if GTEST_HAS_STD_UNIQUE_PTR_
-
-std::unique_ptr<int> UniquePtrSource() {
-  return std::unique_ptr<int>(new int(19));
-}
-
-std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
-  std::vector<std::unique_ptr<int>> out;
-  out.emplace_back(new int(7));
-  return out;
-}
-
-TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
-  MockClass mock;
-  std::unique_ptr<int> i(new int(19));
-  EXPECT_CALL(mock, MakeUnique()).WillOnce(Return(ByMove(std::move(i))));
-  EXPECT_CALL(mock, MakeVectorUnique())
-      .WillOnce(Return(ByMove(VectorUniquePtrSource())));
-  Derived* d = new Derived;
-  EXPECT_CALL(mock, MakeUniqueBase())
-      .WillOnce(Return(ByMove(std::unique_ptr<Derived>(d))));
-
-  std::unique_ptr<int> result1 = mock.MakeUnique();
-  EXPECT_EQ(19, *result1);
-
-  std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
-  EXPECT_EQ(1u, vresult.size());
-  EXPECT_NE(nullptr, vresult[0]);
-  EXPECT_EQ(7, *vresult[0]);
-
-  std::unique_ptr<Base> result2 = mock.MakeUniqueBase();
-  EXPECT_EQ(d, result2.get());
-}
-
-TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
-  testing::MockFunction<void()> mock_function;
-  MockClass mock;
-  std::unique_ptr<int> i(new int(19));
-  EXPECT_CALL(mock_function, Call());
-  EXPECT_CALL(mock, MakeUnique()).WillOnce(DoAll(
-      InvokeWithoutArgs(&mock_function, &testing::MockFunction<void()>::Call),
-      Return(ByMove(std::move(i)))));
-
-  std::unique_ptr<int> result1 = mock.MakeUnique();
-  EXPECT_EQ(19, *result1);
-}
-
-TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
-  MockClass mock;
-
-  // Check default value
-  DefaultValue<std::unique_ptr<int>>::SetFactory([] {
-    return std::unique_ptr<int>(new int(42));
-  });
-  EXPECT_EQ(42, *mock.MakeUnique());
-
-  EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(Invoke(UniquePtrSource));
-  EXPECT_CALL(mock, MakeVectorUnique())
-      .WillRepeatedly(Invoke(VectorUniquePtrSource));
-  std::unique_ptr<int> result1 = mock.MakeUnique();
-  EXPECT_EQ(19, *result1);
-  std::unique_ptr<int> result2 = mock.MakeUnique();
-  EXPECT_EQ(19, *result2);
-  EXPECT_NE(result1, result2);
-
-  std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
-  EXPECT_EQ(1u, vresult.size());
-  EXPECT_NE(nullptr, vresult[0]);
-  EXPECT_EQ(7, *vresult[0]);
-}
-
-#endif  // GTEST_HAS_STD_UNIQUE_PTR_
-
-}  // Unnamed namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-cardinalities_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-cardinalities_test.cc
deleted file mode 100644
index 64815e57..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-cardinalities_test.cc
+++ /dev/null
@@ -1,428 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests the built-in cardinalities.
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "gtest/gtest-spi.h"
-
-namespace {
-
-using std::stringstream;
-using testing::AnyNumber;
-using testing::AtLeast;
-using testing::AtMost;
-using testing::Between;
-using testing::Cardinality;
-using testing::CardinalityInterface;
-using testing::Exactly;
-using testing::IsSubstring;
-using testing::MakeCardinality;
-
-class MockFoo {
- public:
-  MockFoo() {}
-  MOCK_METHOD0(Bar, int());  // NOLINT
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
-};
-
-// Tests that Cardinality objects can be default constructed.
-TEST(CardinalityTest, IsDefaultConstructable) {
-  Cardinality c;
-}
-
-// Tests that Cardinality objects are copyable.
-TEST(CardinalityTest, IsCopyable) {
-  // Tests the copy constructor.
-  Cardinality c = Exactly(1);
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(1));
-
-  // Tests the assignment operator.
-  c = Exactly(2);
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(2));
-}
-
-TEST(CardinalityTest, IsOverSaturatedByCallCountWorks) {
-  const Cardinality c = AtMost(5);
-  EXPECT_FALSE(c.IsOverSaturatedByCallCount(4));
-  EXPECT_FALSE(c.IsOverSaturatedByCallCount(5));
-  EXPECT_TRUE(c.IsOverSaturatedByCallCount(6));
-}
-
-// Tests that Cardinality::DescribeActualCallCountTo() creates the
-// correct description.
-TEST(CardinalityTest, CanDescribeActualCallCount) {
-  stringstream ss0;
-  Cardinality::DescribeActualCallCountTo(0, &ss0);
-  EXPECT_EQ("never called", ss0.str());
-
-  stringstream ss1;
-  Cardinality::DescribeActualCallCountTo(1, &ss1);
-  EXPECT_EQ("called once", ss1.str());
-
-  stringstream ss2;
-  Cardinality::DescribeActualCallCountTo(2, &ss2);
-  EXPECT_EQ("called twice", ss2.str());
-
-  stringstream ss3;
-  Cardinality::DescribeActualCallCountTo(3, &ss3);
-  EXPECT_EQ("called 3 times", ss3.str());
-}
-
-// Tests AnyNumber()
-TEST(AnyNumber, Works) {
-  const Cardinality c = AnyNumber();
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(1));
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(9));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(9));
-
-  stringstream ss;
-  c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called any number of times",
-                      ss.str());
-}
-
-TEST(AnyNumberTest, HasCorrectBounds) {
-  const Cardinality c = AnyNumber();
-  EXPECT_EQ(0, c.ConservativeLowerBound());
-  EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
-}
-
-// Tests AtLeast(n).
-
-TEST(AtLeastTest, OnNegativeNumber) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    AtLeast(-1);
-  }, "The invocation lower bound must be >= 0");
-}
-
-TEST(AtLeastTest, OnZero) {
-  const Cardinality c = AtLeast(0);
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(1));
-
-  stringstream ss;
-  c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "any number of times",
-                      ss.str());
-}
-
-TEST(AtLeastTest, OnPositiveNumber) {
-  const Cardinality c = AtLeast(2);
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
-
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(1));
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(2));
-
-  stringstream ss1;
-  AtLeast(1).DescribeTo(&ss1);
-  EXPECT_PRED_FORMAT2(IsSubstring, "at least once",
-                      ss1.str());
-
-  stringstream ss2;
-  c.DescribeTo(&ss2);
-  EXPECT_PRED_FORMAT2(IsSubstring, "at least twice",
-                      ss2.str());
-
-  stringstream ss3;
-  AtLeast(3).DescribeTo(&ss3);
-  EXPECT_PRED_FORMAT2(IsSubstring, "at least 3 times",
-                      ss3.str());
-}
-
-TEST(AtLeastTest, HasCorrectBounds) {
-  const Cardinality c = AtLeast(2);
-  EXPECT_EQ(2, c.ConservativeLowerBound());
-  EXPECT_EQ(INT_MAX, c.ConservativeUpperBound());
-}
-
-// Tests AtMost(n).
-
-TEST(AtMostTest, OnNegativeNumber) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    AtMost(-1);
-  }, "The invocation upper bound must be >= 0");
-}
-
-TEST(AtMostTest, OnZero) {
-  const Cardinality c = AtMost(0);
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(0));
-
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(1));
-
-  stringstream ss;
-  c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
-                      ss.str());
-}
-
-TEST(AtMostTest, OnPositiveNumber) {
-  const Cardinality c = AtMost(2);
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(1));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(1));
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(2));
-
-  stringstream ss1;
-  AtMost(1).DescribeTo(&ss1);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called at most once",
-                      ss1.str());
-
-  stringstream ss2;
-  c.DescribeTo(&ss2);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
-                      ss2.str());
-
-  stringstream ss3;
-  AtMost(3).DescribeTo(&ss3);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called at most 3 times",
-                      ss3.str());
-}
-
-TEST(AtMostTest, HasCorrectBounds) {
-  const Cardinality c = AtMost(2);
-  EXPECT_EQ(0, c.ConservativeLowerBound());
-  EXPECT_EQ(2, c.ConservativeUpperBound());
-}
-
-// Tests Between(m, n).
-
-TEST(BetweenTest, OnNegativeStart) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Between(-1, 2);
-  }, "The invocation lower bound must be >= 0, but is actually -1");
-}
-
-TEST(BetweenTest, OnNegativeEnd) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Between(1, -2);
-  }, "The invocation upper bound must be >= 0, but is actually -2");
-}
-
-TEST(BetweenTest, OnStartBiggerThanEnd) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Between(2, 1);
-  }, "The invocation upper bound (1) must be >= "
-     "the invocation lower bound (2)");
-}
-
-TEST(BetweenTest, OnZeroStartAndZeroEnd) {
-  const Cardinality c = Between(0, 0);
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(0));
-
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(1));
-
-  stringstream ss;
-  c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
-                      ss.str());
-}
-
-TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
-  const Cardinality c = Between(0, 2);
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(2));
-
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(4));
-
-  stringstream ss;
-  c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
-                      ss.str());
-}
-
-TEST(BetweenTest, OnSameStartAndEnd) {
-  const Cardinality c = Between(3, 3);
-
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(2));
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(3));
-
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(4));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(4));
-
-  stringstream ss;
-  c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
-                      ss.str());
-}
-
-TEST(BetweenTest, OnDifferentStartAndEnd) {
-  const Cardinality c = Between(3, 5);
-
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(2));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(2));
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(3));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(3));
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(5));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(5));
-
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(6));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(6));
-
-  stringstream ss;
-  c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called between 3 and 5 times",
-                      ss.str());
-}
-
-TEST(BetweenTest, HasCorrectBounds) {
-  const Cardinality c = Between(3, 5);
-  EXPECT_EQ(3, c.ConservativeLowerBound());
-  EXPECT_EQ(5, c.ConservativeUpperBound());
-}
-
-// Tests Exactly(n).
-
-TEST(ExactlyTest, OnNegativeNumber) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Exactly(-1);
-  }, "The invocation lower bound must be >= 0");
-}
-
-TEST(ExactlyTest, OnZero) {
-  const Cardinality c = Exactly(0);
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(0));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(0));
-
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(1));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(1));
-
-  stringstream ss;
-  c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
-                      ss.str());
-}
-
-TEST(ExactlyTest, OnPositiveNumber) {
-  const Cardinality c = Exactly(2);
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(0));
-  EXPECT_FALSE(c.IsSaturatedByCallCount(0));
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
-  EXPECT_TRUE(c.IsSaturatedByCallCount(2));
-
-  stringstream ss1;
-  Exactly(1).DescribeTo(&ss1);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called once",
-                      ss1.str());
-
-  stringstream ss2;
-  c.DescribeTo(&ss2);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called twice",
-                      ss2.str());
-
-  stringstream ss3;
-  Exactly(3).DescribeTo(&ss3);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
-                      ss3.str());
-}
-
-TEST(ExactlyTest, HasCorrectBounds) {
-  const Cardinality c = Exactly(3);
-  EXPECT_EQ(3, c.ConservativeLowerBound());
-  EXPECT_EQ(3, c.ConservativeUpperBound());
-}
-
-// Tests that a user can make his own cardinality by implementing
-// CardinalityInterface and calling MakeCardinality().
-
-class EvenCardinality : public CardinalityInterface {
- public:
-  // Returns true iff call_count calls will satisfy this cardinality.
-  virtual bool IsSatisfiedByCallCount(int call_count) const {
-    return (call_count % 2 == 0);
-  }
-
-  // Returns true iff call_count calls will saturate this cardinality.
-  virtual bool IsSaturatedByCallCount(int /* call_count */) const {
-    return false;
-  }
-
-  // Describes self to an ostream.
-  virtual void DescribeTo(::std::ostream* ss) const {
-    *ss << "called even number of times";
-  }
-};
-
-TEST(MakeCardinalityTest, ConstructsCardinalityFromInterface) {
-  const Cardinality c = MakeCardinality(new EvenCardinality);
-
-  EXPECT_TRUE(c.IsSatisfiedByCallCount(2));
-  EXPECT_FALSE(c.IsSatisfiedByCallCount(3));
-
-  EXPECT_FALSE(c.IsSaturatedByCallCount(10000));
-
-  stringstream ss;
-  c.DescribeTo(&ss);
-  EXPECT_EQ("called even number of times", ss.str());
-}
-
-}  // Unnamed namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-actions_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-actions_test.cc
deleted file mode 100644
index 5ca5bc78..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-actions_test.cc
+++ /dev/null
@@ -1,1228 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests the built-in actions generated by a script.
-
-#include "gmock/gmock-generated-actions.h"
-
-#include <functional>
-#include <sstream>
-#include <string>
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-namespace testing {
-namespace gmock_generated_actions_test {
-
-using ::std::plus;
-using ::std::string;
-using testing::get;
-using testing::make_tuple;
-using testing::tuple;
-using testing::tuple_element;
-using testing::_;
-using testing::Action;
-using testing::ActionInterface;
-using testing::ByRef;
-using testing::DoAll;
-using testing::Invoke;
-using testing::Return;
-using testing::ReturnNew;
-using testing::SetArgPointee;
-using testing::StaticAssertTypeEq;
-using testing::Unused;
-using testing::WithArgs;
-
-// For suppressing compiler warnings on conversion possibly losing precision.
-inline short Short(short n) { return n; }  // NOLINT
-inline char Char(char ch) { return ch; }
-
-// Sample functions and functors for testing various actions.
-int Nullary() { return 1; }
-
-class NullaryFunctor {
- public:
-  int operator()() { return 2; }
-};
-
-bool g_done = false;
-
-bool Unary(int x) { return x < 0; }
-
-const char* Plus1(const char* s) { return s + 1; }
-
-bool ByConstRef(const string& s) { return s == "Hi"; }
-
-const double g_double = 0;
-bool ReferencesGlobalDouble(const double& x) { return &x == &g_double; }
-
-string ByNonConstRef(string& s) { return s += "+"; }  // NOLINT
-
-struct UnaryFunctor {
-  int operator()(bool x) { return x ? 1 : -1; }
-};
-
-const char* Binary(const char* input, short n) { return input + n; }  // NOLINT
-
-void VoidBinary(int, char) { g_done = true; }
-
-int Ternary(int x, char y, short z) { return x + y + z; }  // NOLINT
-
-void VoidTernary(int, char, bool) { g_done = true; }
-
-int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }
-
-string Concat4(const char* s1, const char* s2, const char* s3,
-               const char* s4) {
-  return string(s1) + s2 + s3 + s4;
-}
-
-int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d + e; }
-
-struct SumOf5Functor {
-  int operator()(int a, int b, int c, int d, int e) {
-    return a + b + c + d + e;
-  }
-};
-
-string Concat5(const char* s1, const char* s2, const char* s3,
-               const char* s4, const char* s5) {
-  return string(s1) + s2 + s3 + s4 + s5;
-}
-
-int SumOf6(int a, int b, int c, int d, int e, int f) {
-  return a + b + c + d + e + f;
-}
-
-struct SumOf6Functor {
-  int operator()(int a, int b, int c, int d, int e, int f) {
-    return a + b + c + d + e + f;
-  }
-};
-
-string Concat6(const char* s1, const char* s2, const char* s3,
-               const char* s4, const char* s5, const char* s6) {
-  return string(s1) + s2 + s3 + s4 + s5 + s6;
-}
-
-string Concat7(const char* s1, const char* s2, const char* s3,
-               const char* s4, const char* s5, const char* s6,
-               const char* s7) {
-  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7;
-}
-
-string Concat8(const char* s1, const char* s2, const char* s3,
-               const char* s4, const char* s5, const char* s6,
-               const char* s7, const char* s8) {
-  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8;
-}
-
-string Concat9(const char* s1, const char* s2, const char* s3,
-               const char* s4, const char* s5, const char* s6,
-               const char* s7, const char* s8, const char* s9) {
-  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9;
-}
-
-string Concat10(const char* s1, const char* s2, const char* s3,
-                const char* s4, const char* s5, const char* s6,
-                const char* s7, const char* s8, const char* s9,
-                const char* s10) {
-  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10;
-}
-
-// A helper that turns the type of a C-string literal from const
-// char[N] to const char*.
-inline const char* CharPtr(const char* s) { return s; }
-
-// Tests InvokeArgument<N>(...).
-
-// Tests using InvokeArgument with a nullary function.
-TEST(InvokeArgumentTest, Function0) {
-  Action<int(int, int(*)())> a = InvokeArgument<1>();  // NOLINT
-  EXPECT_EQ(1, a.Perform(make_tuple(2, &Nullary)));
-}
-
-// Tests using InvokeArgument with a unary function.
-TEST(InvokeArgumentTest, Functor1) {
-  Action<int(UnaryFunctor)> a = InvokeArgument<0>(true);  // NOLINT
-  EXPECT_EQ(1, a.Perform(make_tuple(UnaryFunctor())));
-}
-
-// Tests using InvokeArgument with a 5-ary function.
-TEST(InvokeArgumentTest, Function5) {
-  Action<int(int(*)(int, int, int, int, int))> a =  // NOLINT
-      InvokeArgument<0>(10000, 2000, 300, 40, 5);
-  EXPECT_EQ(12345, a.Perform(make_tuple(&SumOf5)));
-}
-
-// Tests using InvokeArgument with a 5-ary functor.
-TEST(InvokeArgumentTest, Functor5) {
-  Action<int(SumOf5Functor)> a =  // NOLINT
-      InvokeArgument<0>(10000, 2000, 300, 40, 5);
-  EXPECT_EQ(12345, a.Perform(make_tuple(SumOf5Functor())));
-}
-
-// Tests using InvokeArgument with a 6-ary function.
-TEST(InvokeArgumentTest, Function6) {
-  Action<int(int(*)(int, int, int, int, int, int))> a =  // NOLINT
-      InvokeArgument<0>(100000, 20000, 3000, 400, 50, 6);
-  EXPECT_EQ(123456, a.Perform(make_tuple(&SumOf6)));
-}
-
-// Tests using InvokeArgument with a 6-ary functor.
-TEST(InvokeArgumentTest, Functor6) {
-  Action<int(SumOf6Functor)> a =  // NOLINT
-      InvokeArgument<0>(100000, 20000, 3000, 400, 50, 6);
-  EXPECT_EQ(123456, a.Perform(make_tuple(SumOf6Functor())));
-}
-
-// Tests using InvokeArgument with a 7-ary function.
-TEST(InvokeArgumentTest, Function7) {
-  Action<string(string(*)(const char*, const char*, const char*,
-                          const char*, const char*, const char*,
-                          const char*))> a =
-      InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7");
-  EXPECT_EQ("1234567", a.Perform(make_tuple(&Concat7)));
-}
-
-// Tests using InvokeArgument with a 8-ary function.
-TEST(InvokeArgumentTest, Function8) {
-  Action<string(string(*)(const char*, const char*, const char*,
-                          const char*, const char*, const char*,
-                          const char*, const char*))> a =
-      InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7", "8");
-  EXPECT_EQ("12345678", a.Perform(make_tuple(&Concat8)));
-}
-
-// Tests using InvokeArgument with a 9-ary function.
-TEST(InvokeArgumentTest, Function9) {
-  Action<string(string(*)(const char*, const char*, const char*,
-                          const char*, const char*, const char*,
-                          const char*, const char*, const char*))> a =
-      InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7", "8", "9");
-  EXPECT_EQ("123456789", a.Perform(make_tuple(&Concat9)));
-}
-
-// Tests using InvokeArgument with a 10-ary function.
-TEST(InvokeArgumentTest, Function10) {
-  Action<string(string(*)(const char*, const char*, const char*,
-                          const char*, const char*, const char*,
-                          const char*, const char*, const char*,
-                          const char*))> a =
-      InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7", "8", "9", "0");
-  EXPECT_EQ("1234567890", a.Perform(make_tuple(&Concat10)));
-}
-
-// Tests using InvokeArgument with a function that takes a pointer argument.
-TEST(InvokeArgumentTest, ByPointerFunction) {
-  Action<const char*(const char*(*)(const char* input, short n))> a =  // NOLINT
-      InvokeArgument<0>(static_cast<const char*>("Hi"), Short(1));
-  EXPECT_STREQ("i", a.Perform(make_tuple(&Binary)));
-}
-
-// Tests using InvokeArgument with a function that takes a const char*
-// by passing it a C-string literal.
-TEST(InvokeArgumentTest, FunctionWithCStringLiteral) {
-  Action<const char*(const char*(*)(const char* input, short n))> a =  // NOLINT
-      InvokeArgument<0>("Hi", Short(1));
-  EXPECT_STREQ("i", a.Perform(make_tuple(&Binary)));
-}
-
-// Tests using InvokeArgument with a function that takes a const reference.
-TEST(InvokeArgumentTest, ByConstReferenceFunction) {
-  Action<bool(bool(*function)(const string& s))> a =  // NOLINT
-      InvokeArgument<0>(string("Hi"));
-  // When action 'a' is constructed, it makes a copy of the temporary
-  // string object passed to it, so it's OK to use 'a' later, when the
-  // temporary object has already died.
-  EXPECT_TRUE(a.Perform(make_tuple(&ByConstRef)));
-}
-
-// Tests using InvokeArgument with ByRef() and a function that takes a
-// const reference.
-TEST(InvokeArgumentTest, ByExplicitConstReferenceFunction) {
-  Action<bool(bool(*)(const double& x))> a =  // NOLINT
-      InvokeArgument<0>(ByRef(g_double));
-  // The above line calls ByRef() on a const value.
-  EXPECT_TRUE(a.Perform(make_tuple(&ReferencesGlobalDouble)));
-
-  double x = 0;
-  a = InvokeArgument<0>(ByRef(x));  // This calls ByRef() on a non-const.
-  EXPECT_FALSE(a.Perform(make_tuple(&ReferencesGlobalDouble)));
-}
-
-// Tests using WithArgs and with an action that takes 1 argument.
-TEST(WithArgsTest, OneArg) {
-  Action<bool(double x, int n)> a = WithArgs<1>(Invoke(Unary));  // NOLINT
-  EXPECT_TRUE(a.Perform(make_tuple(1.5, -1)));
-  EXPECT_FALSE(a.Perform(make_tuple(1.5, 1)));
-}
-
-// Tests using WithArgs with an action that takes 2 arguments.
-TEST(WithArgsTest, TwoArgs) {
-  Action<const char*(const char* s, double x, short n)> a =
-      WithArgs<0, 2>(Invoke(Binary));
-  const char s[] = "Hello";
-  EXPECT_EQ(s + 2, a.Perform(make_tuple(CharPtr(s), 0.5, Short(2))));
-}
-
-// Tests using WithArgs with an action that takes 3 arguments.
-TEST(WithArgsTest, ThreeArgs) {
-  Action<int(int, double, char, short)> a =  // NOLINT
-      WithArgs<0, 2, 3>(Invoke(Ternary));
-  EXPECT_EQ(123, a.Perform(make_tuple(100, 6.5, Char(20), Short(3))));
-}
-
-// Tests using WithArgs with an action that takes 4 arguments.
-TEST(WithArgsTest, FourArgs) {
-  Action<string(const char*, const char*, double, const char*, const char*)> a =
-      WithArgs<4, 3, 1, 0>(Invoke(Concat4));
-  EXPECT_EQ("4310", a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), 2.5,
-                                         CharPtr("3"), CharPtr("4"))));
-}
-
-// Tests using WithArgs with an action that takes 5 arguments.
-TEST(WithArgsTest, FiveArgs) {
-  Action<string(const char*, const char*, const char*,
-                const char*, const char*)> a =
-      WithArgs<4, 3, 2, 1, 0>(Invoke(Concat5));
-  EXPECT_EQ("43210",
-            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
-                                 CharPtr("3"), CharPtr("4"))));
-}
-
-// Tests using WithArgs with an action that takes 6 arguments.
-TEST(WithArgsTest, SixArgs) {
-  Action<string(const char*, const char*, const char*)> a =
-      WithArgs<0, 1, 2, 2, 1, 0>(Invoke(Concat6));
-  EXPECT_EQ("012210",
-            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"))));
-}
-
-// Tests using WithArgs with an action that takes 7 arguments.
-TEST(WithArgsTest, SevenArgs) {
-  Action<string(const char*, const char*, const char*, const char*)> a =
-      WithArgs<0, 1, 2, 3, 2, 1, 0>(Invoke(Concat7));
-  EXPECT_EQ("0123210",
-            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
-                                 CharPtr("3"))));
-}
-
-// Tests using WithArgs with an action that takes 8 arguments.
-TEST(WithArgsTest, EightArgs) {
-  Action<string(const char*, const char*, const char*, const char*)> a =
-      WithArgs<0, 1, 2, 3, 0, 1, 2, 3>(Invoke(Concat8));
-  EXPECT_EQ("01230123",
-            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
-                                 CharPtr("3"))));
-}
-
-// Tests using WithArgs with an action that takes 9 arguments.
-TEST(WithArgsTest, NineArgs) {
-  Action<string(const char*, const char*, const char*, const char*)> a =
-      WithArgs<0, 1, 2, 3, 1, 2, 3, 2, 3>(Invoke(Concat9));
-  EXPECT_EQ("012312323",
-            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
-                                 CharPtr("3"))));
-}
-
-// Tests using WithArgs with an action that takes 10 arguments.
-TEST(WithArgsTest, TenArgs) {
-  Action<string(const char*, const char*, const char*, const char*)> a =
-      WithArgs<0, 1, 2, 3, 2, 1, 0, 1, 2, 3>(Invoke(Concat10));
-  EXPECT_EQ("0123210123",
-            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
-                                 CharPtr("3"))));
-}
-
-// Tests using WithArgs with an action that is not Invoke().
-class SubstractAction : public ActionInterface<int(int, int)> {  // NOLINT
- public:
-  virtual int Perform(const tuple<int, int>& args) {
-    return get<0>(args) - get<1>(args);
-  }
-};
-
-TEST(WithArgsTest, NonInvokeAction) {
-  Action<int(const string&, int, int)> a =  // NOLINT
-      WithArgs<2, 1>(MakeAction(new SubstractAction));
-  string s("hello");
-  EXPECT_EQ(8, a.Perform(tuple<const string&, int, int>(s, 2, 10)));
-}
-
-// Tests using WithArgs to pass all original arguments in the original order.
-TEST(WithArgsTest, Identity) {
-  Action<int(int x, char y, short z)> a =  // NOLINT
-      WithArgs<0, 1, 2>(Invoke(Ternary));
-  EXPECT_EQ(123, a.Perform(make_tuple(100, Char(20), Short(3))));
-}
-
-// Tests using WithArgs with repeated arguments.
-TEST(WithArgsTest, RepeatedArguments) {
-  Action<int(bool, int m, int n)> a =  // NOLINT
-      WithArgs<1, 1, 1, 1>(Invoke(SumOf4));
-  EXPECT_EQ(4, a.Perform(make_tuple(false, 1, 10)));
-}
-
-// Tests using WithArgs with reversed argument order.
-TEST(WithArgsTest, ReversedArgumentOrder) {
-  Action<const char*(short n, const char* input)> a =  // NOLINT
-      WithArgs<1, 0>(Invoke(Binary));
-  const char s[] = "Hello";
-  EXPECT_EQ(s + 2, a.Perform(make_tuple(Short(2), CharPtr(s))));
-}
-
-// Tests using WithArgs with compatible, but not identical, argument types.
-TEST(WithArgsTest, ArgsOfCompatibleTypes) {
-  Action<long(short x, char y, double z, char c)> a =  // NOLINT
-      WithArgs<0, 1, 3>(Invoke(Ternary));
-  EXPECT_EQ(123, a.Perform(make_tuple(Short(100), Char(20), 5.6, Char(3))));
-}
-
-// Tests using WithArgs with an action that returns void.
-TEST(WithArgsTest, VoidAction) {
-  Action<void(double x, char c, int n)> a = WithArgs<2, 1>(Invoke(VoidBinary));
-  g_done = false;
-  a.Perform(make_tuple(1.5, 'a', 3));
-  EXPECT_TRUE(g_done);
-}
-
-// Tests DoAll(a1, a2).
-TEST(DoAllTest, TwoActions) {
-  int n = 0;
-  Action<int(int*)> a = DoAll(SetArgPointee<0>(1),  // NOLINT
-                              Return(2));
-  EXPECT_EQ(2, a.Perform(make_tuple(&n)));
-  EXPECT_EQ(1, n);
-}
-
-// Tests DoAll(a1, a2, a3).
-TEST(DoAllTest, ThreeActions) {
-  int m = 0, n = 0;
-  Action<int(int*, int*)> a = DoAll(SetArgPointee<0>(1),  // NOLINT
-                                    SetArgPointee<1>(2),
-                                    Return(3));
-  EXPECT_EQ(3, a.Perform(make_tuple(&m, &n)));
-  EXPECT_EQ(1, m);
-  EXPECT_EQ(2, n);
-}
-
-// Tests DoAll(a1, a2, a3, a4).
-TEST(DoAllTest, FourActions) {
-  int m = 0, n = 0;
-  char ch = '\0';
-  Action<int(int*, int*, char*)> a =  // NOLINT
-      DoAll(SetArgPointee<0>(1),
-            SetArgPointee<1>(2),
-            SetArgPointee<2>('a'),
-            Return(3));
-  EXPECT_EQ(3, a.Perform(make_tuple(&m, &n, &ch)));
-  EXPECT_EQ(1, m);
-  EXPECT_EQ(2, n);
-  EXPECT_EQ('a', ch);
-}
-
-// Tests DoAll(a1, a2, a3, a4, a5).
-TEST(DoAllTest, FiveActions) {
-  int m = 0, n = 0;
-  char a = '\0', b = '\0';
-  Action<int(int*, int*, char*, char*)> action =  // NOLINT
-      DoAll(SetArgPointee<0>(1),
-            SetArgPointee<1>(2),
-            SetArgPointee<2>('a'),
-            SetArgPointee<3>('b'),
-            Return(3));
-  EXPECT_EQ(3, action.Perform(make_tuple(&m, &n, &a, &b)));
-  EXPECT_EQ(1, m);
-  EXPECT_EQ(2, n);
-  EXPECT_EQ('a', a);
-  EXPECT_EQ('b', b);
-}
-
-// Tests DoAll(a1, a2, ..., a6).
-TEST(DoAllTest, SixActions) {
-  int m = 0, n = 0;
-  char a = '\0', b = '\0', c = '\0';
-  Action<int(int*, int*, char*, char*, char*)> action =  // NOLINT
-      DoAll(SetArgPointee<0>(1),
-            SetArgPointee<1>(2),
-            SetArgPointee<2>('a'),
-            SetArgPointee<3>('b'),
-            SetArgPointee<4>('c'),
-            Return(3));
-  EXPECT_EQ(3, action.Perform(make_tuple(&m, &n, &a, &b, &c)));
-  EXPECT_EQ(1, m);
-  EXPECT_EQ(2, n);
-  EXPECT_EQ('a', a);
-  EXPECT_EQ('b', b);
-  EXPECT_EQ('c', c);
-}
-
-// Tests DoAll(a1, a2, ..., a7).
-TEST(DoAllTest, SevenActions) {
-  int m = 0, n = 0;
-  char a = '\0', b = '\0', c = '\0', d = '\0';
-  Action<int(int*, int*, char*, char*, char*, char*)> action =  // NOLINT
-      DoAll(SetArgPointee<0>(1),
-            SetArgPointee<1>(2),
-            SetArgPointee<2>('a'),
-            SetArgPointee<3>('b'),
-            SetArgPointee<4>('c'),
-            SetArgPointee<5>('d'),
-            Return(3));
-  EXPECT_EQ(3, action.Perform(make_tuple(&m, &n, &a, &b, &c, &d)));
-  EXPECT_EQ(1, m);
-  EXPECT_EQ(2, n);
-  EXPECT_EQ('a', a);
-  EXPECT_EQ('b', b);
-  EXPECT_EQ('c', c);
-  EXPECT_EQ('d', d);
-}
-
-// Tests DoAll(a1, a2, ..., a8).
-TEST(DoAllTest, EightActions) {
-  int m = 0, n = 0;
-  char a = '\0', b = '\0', c = '\0', d = '\0', e = '\0';
-  Action<int(int*, int*, char*, char*, char*, char*,  // NOLINT
-             char*)> action =
-      DoAll(SetArgPointee<0>(1),
-            SetArgPointee<1>(2),
-            SetArgPointee<2>('a'),
-            SetArgPointee<3>('b'),
-            SetArgPointee<4>('c'),
-            SetArgPointee<5>('d'),
-            SetArgPointee<6>('e'),
-            Return(3));
-  EXPECT_EQ(3, action.Perform(make_tuple(&m, &n, &a, &b, &c, &d, &e)));
-  EXPECT_EQ(1, m);
-  EXPECT_EQ(2, n);
-  EXPECT_EQ('a', a);
-  EXPECT_EQ('b', b);
-  EXPECT_EQ('c', c);
-  EXPECT_EQ('d', d);
-  EXPECT_EQ('e', e);
-}
-
-// Tests DoAll(a1, a2, ..., a9).
-TEST(DoAllTest, NineActions) {
-  int m = 0, n = 0;
-  char a = '\0', b = '\0', c = '\0', d = '\0', e = '\0', f = '\0';
-  Action<int(int*, int*, char*, char*, char*, char*,  // NOLINT
-             char*, char*)> action =
-      DoAll(SetArgPointee<0>(1),
-            SetArgPointee<1>(2),
-            SetArgPointee<2>('a'),
-            SetArgPointee<3>('b'),
-            SetArgPointee<4>('c'),
-            SetArgPointee<5>('d'),
-            SetArgPointee<6>('e'),
-            SetArgPointee<7>('f'),
-            Return(3));
-  EXPECT_EQ(3, action.Perform(make_tuple(&m, &n, &a, &b, &c, &d, &e, &f)));
-  EXPECT_EQ(1, m);
-  EXPECT_EQ(2, n);
-  EXPECT_EQ('a', a);
-  EXPECT_EQ('b', b);
-  EXPECT_EQ('c', c);
-  EXPECT_EQ('d', d);
-  EXPECT_EQ('e', e);
-  EXPECT_EQ('f', f);
-}
-
-// Tests DoAll(a1, a2, ..., a10).
-TEST(DoAllTest, TenActions) {
-  int m = 0, n = 0;
-  char a = '\0', b = '\0', c = '\0', d = '\0';
-  char e = '\0', f = '\0', g = '\0';
-  Action<int(int*, int*, char*, char*, char*, char*,  // NOLINT
-             char*, char*, char*)> action =
-      DoAll(SetArgPointee<0>(1),
-            SetArgPointee<1>(2),
-            SetArgPointee<2>('a'),
-            SetArgPointee<3>('b'),
-            SetArgPointee<4>('c'),
-            SetArgPointee<5>('d'),
-            SetArgPointee<6>('e'),
-            SetArgPointee<7>('f'),
-            SetArgPointee<8>('g'),
-            Return(3));
-  EXPECT_EQ(3, action.Perform(make_tuple(&m, &n, &a, &b, &c, &d, &e, &f, &g)));
-  EXPECT_EQ(1, m);
-  EXPECT_EQ(2, n);
-  EXPECT_EQ('a', a);
-  EXPECT_EQ('b', b);
-  EXPECT_EQ('c', c);
-  EXPECT_EQ('d', d);
-  EXPECT_EQ('e', e);
-  EXPECT_EQ('f', f);
-  EXPECT_EQ('g', g);
-}
-
-// 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
-// is expanded and macro expansion cannot contain #pragma.  Therefore
-// we suppress them here.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
-#endif
-
-// Tests the ACTION*() macro family.
-
-// Tests that ACTION() can define an action that doesn't reference the
-// mock function arguments.
-ACTION(Return5) { return 5; }
-
-TEST(ActionMacroTest, WorksWhenNotReferencingArguments) {
-  Action<double()> a1 = Return5();
-  EXPECT_DOUBLE_EQ(5, a1.Perform(make_tuple()));
-
-  Action<int(double, bool)> a2 = Return5();
-  EXPECT_EQ(5, a2.Perform(make_tuple(1, true)));
-}
-
-// Tests that ACTION() can define an action that returns void.
-ACTION(IncrementArg1) { (*arg1)++; }
-
-TEST(ActionMacroTest, WorksWhenReturningVoid) {
-  Action<void(int, int*)> a1 = IncrementArg1();
-  int n = 0;
-  a1.Perform(make_tuple(5, &n));
-  EXPECT_EQ(1, n);
-}
-
-// Tests that the body of ACTION() can reference the type of the
-// argument.
-ACTION(IncrementArg2) {
-  StaticAssertTypeEq<int*, arg2_type>();
-  arg2_type temp = arg2;
-  (*temp)++;
-}
-
-TEST(ActionMacroTest, CanReferenceArgumentType) {
-  Action<void(int, bool, int*)> a1 = IncrementArg2();
-  int n = 0;
-  a1.Perform(make_tuple(5, false, &n));
-  EXPECT_EQ(1, n);
-}
-
-// Tests that the body of ACTION() can reference the argument tuple
-// via args_type and args.
-ACTION(Sum2) {
-  StaticAssertTypeEq<tuple<int, char, int*>, args_type>();
-  args_type args_copy = args;
-  return get<0>(args_copy) + get<1>(args_copy);
-}
-
-TEST(ActionMacroTest, CanReferenceArgumentTuple) {
-  Action<int(int, char, int*)> a1 = Sum2();
-  int dummy = 0;
-  EXPECT_EQ(11, a1.Perform(make_tuple(5, Char(6), &dummy)));
-}
-
-// Tests that the body of ACTION() can reference the mock function
-// type.
-int Dummy(bool flag) { return flag? 1 : 0; }
-
-ACTION(InvokeDummy) {
-  StaticAssertTypeEq<int(bool), function_type>();
-  function_type* fp = &Dummy;
-  return (*fp)(true);
-}
-
-TEST(ActionMacroTest, CanReferenceMockFunctionType) {
-  Action<int(bool)> a1 = InvokeDummy();
-  EXPECT_EQ(1, a1.Perform(make_tuple(true)));
-  EXPECT_EQ(1, a1.Perform(make_tuple(false)));
-}
-
-// Tests that the body of ACTION() can reference the mock function's
-// return type.
-ACTION(InvokeDummy2) {
-  StaticAssertTypeEq<int, return_type>();
-  return_type result = Dummy(true);
-  return result;
-}
-
-TEST(ActionMacroTest, CanReferenceMockFunctionReturnType) {
-  Action<int(bool)> a1 = InvokeDummy2();
-  EXPECT_EQ(1, a1.Perform(make_tuple(true)));
-  EXPECT_EQ(1, a1.Perform(make_tuple(false)));
-}
-
-// Tests that ACTION() works for arguments passed by const reference.
-ACTION(ReturnAddrOfConstBoolReferenceArg) {
-  StaticAssertTypeEq<const bool&, arg1_type>();
-  return &arg1;
-}
-
-TEST(ActionMacroTest, WorksForConstReferenceArg) {
-  Action<const bool*(int, const bool&)> a = ReturnAddrOfConstBoolReferenceArg();
-  const bool b = false;
-  EXPECT_EQ(&b, a.Perform(tuple<int, const bool&>(0, b)));
-}
-
-// Tests that ACTION() works for arguments passed by non-const reference.
-ACTION(ReturnAddrOfIntReferenceArg) {
-  StaticAssertTypeEq<int&, arg0_type>();
-  return &arg0;
-}
-
-TEST(ActionMacroTest, WorksForNonConstReferenceArg) {
-  Action<int*(int&, bool, int)> a = ReturnAddrOfIntReferenceArg();
-  int n = 0;
-  EXPECT_EQ(&n, a.Perform(tuple<int&, bool, int>(n, true, 1)));
-}
-
-// Tests that ACTION() can be used in a namespace.
-namespace action_test {
-ACTION(Sum) { return arg0 + arg1; }
-}  // namespace action_test
-
-TEST(ActionMacroTest, WorksInNamespace) {
-  Action<int(int, int)> a1 = action_test::Sum();
-  EXPECT_EQ(3, a1.Perform(make_tuple(1, 2)));
-}
-
-// Tests that the same ACTION definition works for mock functions with
-// different argument numbers.
-ACTION(PlusTwo) { return arg0 + 2; }
-
-TEST(ActionMacroTest, WorksForDifferentArgumentNumbers) {
-  Action<int(int)> a1 = PlusTwo();
-  EXPECT_EQ(4, a1.Perform(make_tuple(2)));
-
-  Action<double(float, void*)> a2 = PlusTwo();
-  int dummy;
-  EXPECT_DOUBLE_EQ(6, a2.Perform(make_tuple(4.0f, &dummy)));
-}
-
-// Tests that ACTION_P can define a parameterized action.
-ACTION_P(Plus, n) { return arg0 + n; }
-
-TEST(ActionPMacroTest, DefinesParameterizedAction) {
-  Action<int(int m, bool t)> a1 = Plus(9);
-  EXPECT_EQ(10, a1.Perform(make_tuple(1, true)));
-}
-
-// Tests that the body of ACTION_P can reference the argument types
-// and the parameter type.
-ACTION_P(TypedPlus, n) {
-  arg0_type t1 = arg0;
-  n_type t2 = n;
-  return t1 + t2;
-}
-
-TEST(ActionPMacroTest, CanReferenceArgumentAndParameterTypes) {
-  Action<int(char m, bool t)> a1 = TypedPlus(9);
-  EXPECT_EQ(10, a1.Perform(make_tuple(Char(1), true)));
-}
-
-// Tests that a parameterized action can be used in any mock function
-// whose type is compatible.
-TEST(ActionPMacroTest, WorksInCompatibleMockFunction) {
-  Action<std::string(const std::string& s)> a1 = Plus("tail");
-  const std::string re = "re";
-  EXPECT_EQ("retail", a1.Perform(tuple<const std::string&>(re)));
-}
-
-// Tests that we can use ACTION*() to define actions overloaded on the
-// number of parameters.
-
-ACTION(OverloadedAction) { return arg0 ? arg1 : "hello"; }
-
-ACTION_P(OverloadedAction, default_value) {
-  return arg0 ? arg1 : default_value;
-}
-
-ACTION_P2(OverloadedAction, true_value, false_value) {
-  return arg0 ? true_value : false_value;
-}
-
-TEST(ActionMacroTest, CanDefineOverloadedActions) {
-  typedef Action<const char*(bool, const char*)> MyAction;
-
-  const MyAction a1 = OverloadedAction();
-  EXPECT_STREQ("hello", a1.Perform(make_tuple(false, CharPtr("world"))));
-  EXPECT_STREQ("world", a1.Perform(make_tuple(true, CharPtr("world"))));
-
-  const MyAction a2 = OverloadedAction("hi");
-  EXPECT_STREQ("hi", a2.Perform(make_tuple(false, CharPtr("world"))));
-  EXPECT_STREQ("world", a2.Perform(make_tuple(true, CharPtr("world"))));
-
-  const MyAction a3 = OverloadedAction("hi", "you");
-  EXPECT_STREQ("hi", a3.Perform(make_tuple(true, CharPtr("world"))));
-  EXPECT_STREQ("you", a3.Perform(make_tuple(false, CharPtr("world"))));
-}
-
-// Tests ACTION_Pn where n >= 3.
-
-ACTION_P3(Plus, m, n, k) { return arg0 + m + n + k; }
-
-TEST(ActionPnMacroTest, WorksFor3Parameters) {
-  Action<double(int m, bool t)> a1 = Plus(100, 20, 3.4);
-  EXPECT_DOUBLE_EQ(3123.4, a1.Perform(make_tuple(3000, true)));
-
-  Action<std::string(const std::string& s)> a2 = Plus("tail", "-", ">");
-  const std::string re = "re";
-  EXPECT_EQ("retail->", a2.Perform(tuple<const std::string&>(re)));
-}
-
-ACTION_P4(Plus, p0, p1, p2, p3) { return arg0 + p0 + p1 + p2 + p3; }
-
-TEST(ActionPnMacroTest, WorksFor4Parameters) {
-  Action<int(int)> a1 = Plus(1, 2, 3, 4);
-  EXPECT_EQ(10 + 1 + 2 + 3 + 4, a1.Perform(make_tuple(10)));
-}
-
-ACTION_P5(Plus, p0, p1, p2, p3, p4) { return arg0 + p0 + p1 + p2 + p3 + p4; }
-
-TEST(ActionPnMacroTest, WorksFor5Parameters) {
-  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5);
-  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5, a1.Perform(make_tuple(10)));
-}
-
-ACTION_P6(Plus, p0, p1, p2, p3, p4, p5) {
-  return arg0 + p0 + p1 + p2 + p3 + p4 + p5;
-}
-
-TEST(ActionPnMacroTest, WorksFor6Parameters) {
-  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6);
-  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6, a1.Perform(make_tuple(10)));
-}
-
-ACTION_P7(Plus, p0, p1, p2, p3, p4, p5, p6) {
-  return arg0 + p0 + p1 + p2 + p3 + p4 + p5 + p6;
-}
-
-TEST(ActionPnMacroTest, WorksFor7Parameters) {
-  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7);
-  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7, a1.Perform(make_tuple(10)));
-}
-
-ACTION_P8(Plus, p0, p1, p2, p3, p4, p5, p6, p7) {
-  return arg0 + p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7;
-}
-
-TEST(ActionPnMacroTest, WorksFor8Parameters) {
-  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7, 8);
-  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8, a1.Perform(make_tuple(10)));
-}
-
-ACTION_P9(Plus, p0, p1, p2, p3, p4, p5, p6, p7, p8) {
-  return arg0 + p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8;
-}
-
-TEST(ActionPnMacroTest, WorksFor9Parameters) {
-  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7, 8, 9);
-  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9, a1.Perform(make_tuple(10)));
-}
-
-ACTION_P10(Plus, p0, p1, p2, p3, p4, p5, p6, p7, p8, last_param) {
-  arg0_type t0 = arg0;
-  last_param_type t9 = last_param;
-  return t0 + p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + t9;
-}
-
-TEST(ActionPnMacroTest, WorksFor10Parameters) {
-  Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
-  EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10,
-            a1.Perform(make_tuple(10)));
-}
-
-// Tests that the action body can promote the parameter types.
-
-ACTION_P2(PadArgument, prefix, suffix) {
-  // The following lines promote the two parameters to desired types.
-  std::string prefix_str(prefix);
-  char suffix_char = static_cast<char>(suffix);
-  return prefix_str + arg0 + suffix_char;
-}
-
-TEST(ActionPnMacroTest, SimpleTypePromotion) {
-  Action<std::string(const char*)> no_promo =
-      PadArgument(std::string("foo"), 'r');
-  Action<std::string(const char*)> promo =
-      PadArgument("foo", static_cast<int>('r'));
-  EXPECT_EQ("foobar", no_promo.Perform(make_tuple(CharPtr("ba"))));
-  EXPECT_EQ("foobar", promo.Perform(make_tuple(CharPtr("ba"))));
-}
-
-// Tests that we can partially restrict parameter types using a
-// straight-forward pattern.
-
-// Defines a generic action that doesn't restrict the types of its
-// parameters.
-ACTION_P3(ConcatImpl, a, b, c) {
-  std::stringstream ss;
-  ss << a << b << c;
-  return ss.str();
-}
-
-// Next, we try to restrict that either the first parameter is a
-// string, or the second parameter is an int.
-
-// Defines a partially specialized wrapper that restricts the first
-// parameter to std::string.
-template <typename T1, typename T2>
-// ConcatImplActionP3 is the class template ACTION_P3 uses to
-// implement ConcatImpl.  We shouldn't change the name as this
-// pattern requires the user to use it directly.
-ConcatImplActionP3<std::string, T1, T2>
-Concat(const std::string& a, T1 b, T2 c) {
-  GTEST_INTENTIONAL_CONST_COND_PUSH_()
-  if (true) {
-  GTEST_INTENTIONAL_CONST_COND_POP_()
-    // This branch verifies that ConcatImpl() can be invoked without
-    // explicit template arguments.
-    return ConcatImpl(a, b, c);
-  } else {
-    // This branch verifies that ConcatImpl() can also be invoked with
-    // explicit template arguments.  It doesn't really need to be
-    // executed as this is a compile-time verification.
-    return ConcatImpl<std::string, T1, T2>(a, b, c);
-  }
-}
-
-// Defines another partially specialized wrapper that restricts the
-// second parameter to int.
-template <typename T1, typename T2>
-ConcatImplActionP3<T1, int, T2>
-Concat(T1 a, int b, T2 c) {
-  return ConcatImpl(a, b, c);
-}
-
-TEST(ActionPnMacroTest, CanPartiallyRestrictParameterTypes) {
-  Action<const std::string()> a1 = Concat("Hello", "1", 2);
-  EXPECT_EQ("Hello12", a1.Perform(make_tuple()));
-
-  a1 = Concat(1, 2, 3);
-  EXPECT_EQ("123", a1.Perform(make_tuple()));
-}
-
-// Verifies the type of an ACTION*.
-
-ACTION(DoFoo) {}
-ACTION_P(DoFoo, p) {}
-ACTION_P2(DoFoo, p0, p1) {}
-
-TEST(ActionPnMacroTest, TypesAreCorrect) {
-  // DoFoo() must be assignable to a DoFooAction variable.
-  DoFooAction a0 = DoFoo();
-
-  // DoFoo(1) must be assignable to a DoFooActionP variable.
-  DoFooActionP<int> a1 = DoFoo(1);
-
-  // DoFoo(p1, ..., pk) must be assignable to a DoFooActionPk
-  // variable, and so on.
-  DoFooActionP2<int, char> a2 = DoFoo(1, '2');
-  PlusActionP3<int, int, char> a3 = Plus(1, 2, '3');
-  PlusActionP4<int, int, int, char> a4 = Plus(1, 2, 3, '4');
-  PlusActionP5<int, int, int, int, char> a5 = Plus(1, 2, 3, 4, '5');
-  PlusActionP6<int, int, int, int, int, char> a6 = Plus(1, 2, 3, 4, 5, '6');
-  PlusActionP7<int, int, int, int, int, int, char> a7 =
-      Plus(1, 2, 3, 4, 5, 6, '7');
-  PlusActionP8<int, int, int, int, int, int, int, char> a8 =
-      Plus(1, 2, 3, 4, 5, 6, 7, '8');
-  PlusActionP9<int, int, int, int, int, int, int, int, char> a9 =
-      Plus(1, 2, 3, 4, 5, 6, 7, 8, '9');
-  PlusActionP10<int, int, int, int, int, int, int, int, int, char> a10 =
-      Plus(1, 2, 3, 4, 5, 6, 7, 8, 9, '0');
-
-  // Avoid "unused variable" warnings.
-  (void)a0;
-  (void)a1;
-  (void)a2;
-  (void)a3;
-  (void)a4;
-  (void)a5;
-  (void)a6;
-  (void)a7;
-  (void)a8;
-  (void)a9;
-  (void)a10;
-}
-
-// Tests that an ACTION_P*() action can be explicitly instantiated
-// with reference-typed parameters.
-
-ACTION_P(Plus1, x) { return x; }
-ACTION_P2(Plus2, x, y) { return x + y; }
-ACTION_P3(Plus3, x, y, z) { return x + y + z; }
-ACTION_P10(Plus10, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
-  return a0 + a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9;
-}
-
-TEST(ActionPnMacroTest, CanExplicitlyInstantiateWithReferenceTypes) {
-  int x = 1, y = 2, z = 3;
-  const tuple<> empty = make_tuple();
-
-  Action<int()> a = Plus1<int&>(x);
-  EXPECT_EQ(1, a.Perform(empty));
-
-  a = Plus2<const int&, int&>(x, y);
-  EXPECT_EQ(3, a.Perform(empty));
-
-  a = Plus3<int&, const int&, int&>(x, y, z);
-  EXPECT_EQ(6, a.Perform(empty));
-
-  int n[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
-  a = Plus10<const int&, int&, const int&, int&, const int&, int&, const int&,
-      int&, const int&, int&>(n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7],
-                              n[8], n[9]);
-  EXPECT_EQ(55, a.Perform(empty));
-}
-
-class NullaryConstructorClass {
- public:
-  NullaryConstructorClass() : value_(123) {}
-  int value_;
-};
-
-// Tests using ReturnNew() with a nullary constructor.
-TEST(ReturnNewTest, NoArgs) {
-  Action<NullaryConstructorClass*()> a = ReturnNew<NullaryConstructorClass>();
-  NullaryConstructorClass* c = a.Perform(make_tuple());
-  EXPECT_EQ(123, c->value_);
-  delete c;
-}
-
-class UnaryConstructorClass {
- public:
-  explicit UnaryConstructorClass(int value) : value_(value) {}
-  int value_;
-};
-
-// Tests using ReturnNew() with a unary constructor.
-TEST(ReturnNewTest, Unary) {
-  Action<UnaryConstructorClass*()> a = ReturnNew<UnaryConstructorClass>(4000);
-  UnaryConstructorClass* c = a.Perform(make_tuple());
-  EXPECT_EQ(4000, c->value_);
-  delete c;
-}
-
-TEST(ReturnNewTest, UnaryWorksWhenMockMethodHasArgs) {
-  Action<UnaryConstructorClass*(bool, int)> a =
-      ReturnNew<UnaryConstructorClass>(4000);
-  UnaryConstructorClass* c = a.Perform(make_tuple(false, 5));
-  EXPECT_EQ(4000, c->value_);
-  delete c;
-}
-
-TEST(ReturnNewTest, UnaryWorksWhenMockMethodReturnsPointerToConst) {
-  Action<const UnaryConstructorClass*()> a =
-      ReturnNew<UnaryConstructorClass>(4000);
-  const UnaryConstructorClass* c = a.Perform(make_tuple());
-  EXPECT_EQ(4000, c->value_);
-  delete c;
-}
-
-class TenArgConstructorClass {
- public:
-  TenArgConstructorClass(int a1, int a2, int a3, int a4, int a5,
-                         int a6, int a7, int a8, int a9, int a10)
-    : value_(a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10) {
-  }
-  int value_;
-};
-
-// Tests using ReturnNew() with a 10-argument constructor.
-TEST(ReturnNewTest, ConstructorThatTakes10Arguments) {
-  Action<TenArgConstructorClass*()> a =
-      ReturnNew<TenArgConstructorClass>(1000000000, 200000000, 30000000,
-                                        4000000, 500000, 60000,
-                                        7000, 800, 90, 0);
-  TenArgConstructorClass* c = a.Perform(make_tuple());
-  EXPECT_EQ(1234567890, c->value_);
-  delete c;
-}
-
-// Tests that ACTION_TEMPLATE works when there is no value parameter.
-ACTION_TEMPLATE(CreateNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_0_VALUE_PARAMS()) {
-  return new T;
-}
-
-TEST(ActionTemplateTest, WorksWithoutValueParam) {
-  const Action<int*()> a = CreateNew<int>();
-  int* p = a.Perform(make_tuple());
-  delete p;
-}
-
-// Tests that ACTION_TEMPLATE works when there are value parameters.
-ACTION_TEMPLATE(CreateNew,
-                HAS_1_TEMPLATE_PARAMS(typename, T),
-                AND_1_VALUE_PARAMS(a0)) {
-  return new T(a0);
-}
-
-TEST(ActionTemplateTest, WorksWithValueParams) {
-  const Action<int*()> a = CreateNew<int>(42);
-  int* p = a.Perform(make_tuple());
-  EXPECT_EQ(42, *p);
-  delete p;
-}
-
-// Tests that ACTION_TEMPLATE works for integral template parameters.
-ACTION_TEMPLATE(MyDeleteArg,
-                HAS_1_TEMPLATE_PARAMS(int, k),
-                AND_0_VALUE_PARAMS()) {
-  delete get<k>(args);
-}
-
-// Resets a bool variable in the destructor.
-class BoolResetter {
- public:
-  explicit BoolResetter(bool* value) : value_(value) {}
-  ~BoolResetter() { *value_ = false; }
- private:
-  bool* value_;
-};
-
-TEST(ActionTemplateTest, WorksForIntegralTemplateParams) {
-  const Action<void(int*, BoolResetter*)> a = MyDeleteArg<1>();
-  int n = 0;
-  bool b = true;
-  BoolResetter* resetter = new BoolResetter(&b);
-  a.Perform(make_tuple(&n, resetter));
-  EXPECT_FALSE(b);  // Verifies that resetter is deleted.
-}
-
-// Tests that ACTION_TEMPLATES works for template template parameters.
-ACTION_TEMPLATE(ReturnSmartPointer,
-                HAS_1_TEMPLATE_PARAMS(template <typename Pointee> class,
-                                      Pointer),
-                AND_1_VALUE_PARAMS(pointee)) {
-  return Pointer<pointee_type>(new pointee_type(pointee));
-}
-
-TEST(ActionTemplateTest, WorksForTemplateTemplateParameters) {
-  using ::testing::internal::linked_ptr;
-  const Action<linked_ptr<int>()> a = ReturnSmartPointer<linked_ptr>(42);
-  linked_ptr<int> p = a.Perform(make_tuple());
-  EXPECT_EQ(42, *p);
-}
-
-// Tests that ACTION_TEMPLATE works for 10 template parameters.
-template <typename T1, typename T2, typename T3, int k4, bool k5,
-          unsigned int k6, typename T7, typename T8, typename T9>
-struct GiantTemplate {
- public:
-  explicit GiantTemplate(int a_value) : value(a_value) {}
-  int value;
-};
-
-ACTION_TEMPLATE(ReturnGiant,
-                HAS_10_TEMPLATE_PARAMS(
-                    typename, T1,
-                    typename, T2,
-                    typename, T3,
-                    int, k4,
-                    bool, k5,
-                    unsigned int, k6,
-                    class, T7,
-                    class, T8,
-                    class, T9,
-                    template <typename T> class, T10),
-                AND_1_VALUE_PARAMS(value)) {
-  return GiantTemplate<T10<T1>, T2, T3, k4, k5, k6, T7, T8, T9>(value);
-}
-
-TEST(ActionTemplateTest, WorksFor10TemplateParameters) {
-  using ::testing::internal::linked_ptr;
-  typedef GiantTemplate<linked_ptr<int>, bool, double, 5,
-      true, 6, char, unsigned, int> Giant;
-  const Action<Giant()> a = ReturnGiant<
-      int, bool, double, 5, true, 6, char, unsigned, int, linked_ptr>(42);
-  Giant giant = a.Perform(make_tuple());
-  EXPECT_EQ(42, giant.value);
-}
-
-// Tests that ACTION_TEMPLATE works for 10 value parameters.
-ACTION_TEMPLATE(ReturnSum,
-                HAS_1_TEMPLATE_PARAMS(typename, Number),
-                AND_10_VALUE_PARAMS(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)) {
-  return static_cast<Number>(v1) + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10;
-}
-
-TEST(ActionTemplateTest, WorksFor10ValueParameters) {
-  const Action<int()> a = ReturnSum<int>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
-  EXPECT_EQ(55, a.Perform(make_tuple()));
-}
-
-// Tests that ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded
-// on the number of value parameters.
-
-ACTION(ReturnSum) { return 0; }
-
-ACTION_P(ReturnSum, x) { return x; }
-
-ACTION_TEMPLATE(ReturnSum,
-                HAS_1_TEMPLATE_PARAMS(typename, Number),
-                AND_2_VALUE_PARAMS(v1, v2)) {
-  return static_cast<Number>(v1) + v2;
-}
-
-ACTION_TEMPLATE(ReturnSum,
-                HAS_1_TEMPLATE_PARAMS(typename, Number),
-                AND_3_VALUE_PARAMS(v1, v2, v3)) {
-  return static_cast<Number>(v1) + v2 + v3;
-}
-
-ACTION_TEMPLATE(ReturnSum,
-                HAS_2_TEMPLATE_PARAMS(typename, Number, int, k),
-                AND_4_VALUE_PARAMS(v1, v2, v3, v4)) {
-  return static_cast<Number>(v1) + v2 + v3 + v4 + k;
-}
-
-TEST(ActionTemplateTest, CanBeOverloadedOnNumberOfValueParameters) {
-  const Action<int()> a0 = ReturnSum();
-  const Action<int()> a1 = ReturnSum(1);
-  const Action<int()> a2 = ReturnSum<int>(1, 2);
-  const Action<int()> a3 = ReturnSum<int>(1, 2, 3);
-  const Action<int()> a4 = ReturnSum<int, 10000>(2000, 300, 40, 5);
-  EXPECT_EQ(0, a0.Perform(make_tuple()));
-  EXPECT_EQ(1, a1.Perform(make_tuple()));
-  EXPECT_EQ(3, a2.Perform(make_tuple()));
-  EXPECT_EQ(6, a3.Perform(make_tuple()));
-  EXPECT_EQ(12345, a4.Perform(make_tuple()));
-}
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-}  // namespace gmock_generated_actions_test
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-function-mockers_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-function-mockers_test.cc
deleted file mode 100644
index a86a6135..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-function-mockers_test.cc
+++ /dev/null
@@ -1,622 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests the function mocker classes.
-
-#include "gmock/gmock-generated-function-mockers.h"
-
-#if GTEST_OS_WINDOWS
-// MSDN says the header file to be included for STDMETHOD is BaseTyps.h but
-// we are getting compiler errors if we use basetyps.h, hence including
-// objbase.h for definition of STDMETHOD.
-# include <objbase.h>
-#endif  // GTEST_OS_WINDOWS
-
-#include <map>
-#include <string>
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-// There is a bug in MSVC (fixed in VS 2008) that prevents creating a
-// mock for a function with const arguments, so we don't test such
-// cases for MSVC versions older than 2008.
-#if !GTEST_OS_WINDOWS || (_MSC_VER >= 1500)
-# define GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
-#endif  // !GTEST_OS_WINDOWS || (_MSC_VER >= 1500)
-
-namespace testing {
-namespace gmock_generated_function_mockers_test {
-
-using testing::internal::string;
-using testing::_;
-using testing::A;
-using testing::An;
-using testing::AnyNumber;
-using testing::Const;
-using testing::DoDefault;
-using testing::Eq;
-using testing::Lt;
-using testing::MockFunction;
-using testing::Ref;
-using testing::Return;
-using testing::ReturnRef;
-using testing::TypedEq;
-
-class FooInterface {
- public:
-  virtual ~FooInterface() {}
-
-  virtual void VoidReturning(int x) = 0;
-
-  virtual int Nullary() = 0;
-  virtual bool Unary(int x) = 0;
-  virtual long Binary(short x, int y) = 0;  // NOLINT
-  virtual int Decimal(bool b, char c, short d, int e, long f,  // NOLINT
-                      float g, double h, unsigned i, char* j, const string& k)
-      = 0;
-
-  virtual bool TakesNonConstReference(int& n) = 0;  // NOLINT
-  virtual string TakesConstReference(const int& n) = 0;
-#ifdef GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
-  virtual bool TakesConst(const int x) = 0;
-#endif  // GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
-
-  virtual int OverloadedOnArgumentNumber() = 0;
-  virtual int OverloadedOnArgumentNumber(int n) = 0;
-
-  virtual int OverloadedOnArgumentType(int n) = 0;
-  virtual char OverloadedOnArgumentType(char c) = 0;
-
-  virtual int OverloadedOnConstness() = 0;
-  virtual char OverloadedOnConstness() const = 0;
-
-  virtual int TypeWithHole(int (*func)()) = 0;
-  virtual int TypeWithComma(const std::map<int, string>& a_map) = 0;
-
-#if GTEST_OS_WINDOWS
-  STDMETHOD_(int, CTNullary)() = 0;
-  STDMETHOD_(bool, CTUnary)(int x) = 0;
-  STDMETHOD_(int, CTDecimal)(bool b, char c, short d, int e, long f,  // NOLINT
-      float g, double h, unsigned i, char* j, const string& k) = 0;
-  STDMETHOD_(char, CTConst)(int x) const = 0;
-#endif  // GTEST_OS_WINDOWS
-};
-
-// Const qualifiers on arguments were once (incorrectly) considered
-// significant in determining whether two virtual functions had the same
-// signature. This was fixed in Visual Studio 2008. However, the compiler
-// still emits a warning that alerts about this change in behavior.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable : 4373)
-#endif
-class MockFoo : public FooInterface {
- public:
-  MockFoo() {}
-
-  // Makes sure that a mock function parameter can be named.
-  MOCK_METHOD1(VoidReturning, void(int n));  // NOLINT
-
-  MOCK_METHOD0(Nullary, int());  // NOLINT
-
-  // Makes sure that a mock function parameter can be unnamed.
-  MOCK_METHOD1(Unary, bool(int));  // NOLINT
-  MOCK_METHOD2(Binary, long(short, int));  // NOLINT
-  MOCK_METHOD10(Decimal, int(bool, char, short, int, long, float,  // NOLINT
-                             double, unsigned, char*, const string& str));
-
-  MOCK_METHOD1(TakesNonConstReference, bool(int&));  // NOLINT
-  MOCK_METHOD1(TakesConstReference, string(const int&));
-
-#ifdef GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
-  MOCK_METHOD1(TakesConst, bool(const int));  // NOLINT
-#endif
-
-  // Tests that the function return type can contain unprotected comma.
-  MOCK_METHOD0(ReturnTypeWithComma, std::map<int, string>());
-  MOCK_CONST_METHOD1(ReturnTypeWithComma,
-                     std::map<int, string>(int));  // NOLINT
-
-  MOCK_METHOD0(OverloadedOnArgumentNumber, int());  // NOLINT
-  MOCK_METHOD1(OverloadedOnArgumentNumber, int(int));  // NOLINT
-
-  MOCK_METHOD1(OverloadedOnArgumentType, int(int));  // NOLINT
-  MOCK_METHOD1(OverloadedOnArgumentType, char(char));  // NOLINT
-
-  MOCK_METHOD0(OverloadedOnConstness, int());  // NOLINT
-  MOCK_CONST_METHOD0(OverloadedOnConstness, char());  // NOLINT
-
-  MOCK_METHOD1(TypeWithHole, int(int (*)()));  // NOLINT
-  MOCK_METHOD1(TypeWithComma, int(const std::map<int, string>&));  // NOLINT
-
-#if GTEST_OS_WINDOWS
-  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTNullary, int());
-  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTUnary, bool(int));
-  MOCK_METHOD10_WITH_CALLTYPE(STDMETHODCALLTYPE, CTDecimal, int(bool b, char c,
-      short d, int e, long f, float g, double h, unsigned i, char* j,
-      const string& k));
-  MOCK_CONST_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTConst, char(int));
-
-  // Tests that the function return type can contain unprotected comma.
-  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTReturnTypeWithComma,
-                             std::map<int, string>());
-#endif  // GTEST_OS_WINDOWS
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
-};
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-class FunctionMockerTest : public testing::Test {
- protected:
-  FunctionMockerTest() : foo_(&mock_foo_) {}
-
-  FooInterface* const foo_;
-  MockFoo mock_foo_;
-};
-
-// Tests mocking a void-returning function.
-TEST_F(FunctionMockerTest, MocksVoidFunction) {
-  EXPECT_CALL(mock_foo_, VoidReturning(Lt(100)));
-  foo_->VoidReturning(0);
-}
-
-// Tests mocking a nullary function.
-TEST_F(FunctionMockerTest, MocksNullaryFunction) {
-  EXPECT_CALL(mock_foo_, Nullary())
-      .WillOnce(DoDefault())
-      .WillOnce(Return(1));
-
-  EXPECT_EQ(0, foo_->Nullary());
-  EXPECT_EQ(1, foo_->Nullary());
-}
-
-// Tests mocking a unary function.
-TEST_F(FunctionMockerTest, MocksUnaryFunction) {
-  EXPECT_CALL(mock_foo_, Unary(Eq(2)))
-      .Times(2)
-      .WillOnce(Return(true));
-
-  EXPECT_TRUE(foo_->Unary(2));
-  EXPECT_FALSE(foo_->Unary(2));
-}
-
-// Tests mocking a binary function.
-TEST_F(FunctionMockerTest, MocksBinaryFunction) {
-  EXPECT_CALL(mock_foo_, Binary(2, _))
-      .WillOnce(Return(3));
-
-  EXPECT_EQ(3, foo_->Binary(2, 1));
-}
-
-// Tests mocking a decimal function.
-TEST_F(FunctionMockerTest, MocksDecimalFunction) {
-  EXPECT_CALL(mock_foo_, Decimal(true, 'a', 0, 0, 1L, A<float>(),
-                                 Lt(100), 5U, NULL, "hi"))
-      .WillOnce(Return(5));
-
-  EXPECT_EQ(5, foo_->Decimal(true, 'a', 0, 0, 1, 0, 0, 5, NULL, "hi"));
-}
-
-// Tests mocking a function that takes a non-const reference.
-TEST_F(FunctionMockerTest, MocksFunctionWithNonConstReferenceArgument) {
-  int a = 0;
-  EXPECT_CALL(mock_foo_, TakesNonConstReference(Ref(a)))
-      .WillOnce(Return(true));
-
-  EXPECT_TRUE(foo_->TakesNonConstReference(a));
-}
-
-// Tests mocking a function that takes a const reference.
-TEST_F(FunctionMockerTest, MocksFunctionWithConstReferenceArgument) {
-  int a = 0;
-  EXPECT_CALL(mock_foo_, TakesConstReference(Ref(a)))
-      .WillOnce(Return("Hello"));
-
-  EXPECT_EQ("Hello", foo_->TakesConstReference(a));
-}
-
-#ifdef GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
-// Tests mocking a function that takes a const variable.
-TEST_F(FunctionMockerTest, MocksFunctionWithConstArgument) {
-  EXPECT_CALL(mock_foo_, TakesConst(Lt(10)))
-      .WillOnce(DoDefault());
-
-  EXPECT_FALSE(foo_->TakesConst(5));
-}
-#endif  // GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS
-
-// Tests mocking functions overloaded on the number of arguments.
-TEST_F(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentNumber) {
-  EXPECT_CALL(mock_foo_, OverloadedOnArgumentNumber())
-      .WillOnce(Return(1));
-  EXPECT_CALL(mock_foo_, OverloadedOnArgumentNumber(_))
-      .WillOnce(Return(2));
-
-  EXPECT_EQ(2, foo_->OverloadedOnArgumentNumber(1));
-  EXPECT_EQ(1, foo_->OverloadedOnArgumentNumber());
-}
-
-// Tests mocking functions overloaded on the types of argument.
-TEST_F(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentType) {
-  EXPECT_CALL(mock_foo_, OverloadedOnArgumentType(An<int>()))
-      .WillOnce(Return(1));
-  EXPECT_CALL(mock_foo_, OverloadedOnArgumentType(TypedEq<char>('a')))
-      .WillOnce(Return('b'));
-
-  EXPECT_EQ(1, foo_->OverloadedOnArgumentType(0));
-  EXPECT_EQ('b', foo_->OverloadedOnArgumentType('a'));
-}
-
-// Tests mocking functions overloaded on the const-ness of this object.
-TEST_F(FunctionMockerTest, MocksFunctionsOverloadedOnConstnessOfThis) {
-  EXPECT_CALL(mock_foo_, OverloadedOnConstness());
-  EXPECT_CALL(Const(mock_foo_), OverloadedOnConstness())
-      .WillOnce(Return('a'));
-
-  EXPECT_EQ(0, foo_->OverloadedOnConstness());
-  EXPECT_EQ('a', Const(*foo_).OverloadedOnConstness());
-}
-
-TEST_F(FunctionMockerTest, MocksReturnTypeWithComma) {
-  const std::map<int, string> a_map;
-  EXPECT_CALL(mock_foo_, ReturnTypeWithComma())
-      .WillOnce(Return(a_map));
-  EXPECT_CALL(mock_foo_, ReturnTypeWithComma(42))
-      .WillOnce(Return(a_map));
-
-  EXPECT_EQ(a_map, mock_foo_.ReturnTypeWithComma());
-  EXPECT_EQ(a_map, mock_foo_.ReturnTypeWithComma(42));
-}
-
-#if GTEST_OS_WINDOWS
-// Tests mocking a nullary function with calltype.
-TEST_F(FunctionMockerTest, MocksNullaryFunctionWithCallType) {
-  EXPECT_CALL(mock_foo_, CTNullary())
-      .WillOnce(Return(-1))
-      .WillOnce(Return(0));
-
-  EXPECT_EQ(-1, foo_->CTNullary());
-  EXPECT_EQ(0, foo_->CTNullary());
-}
-
-// Tests mocking a unary function with calltype.
-TEST_F(FunctionMockerTest, MocksUnaryFunctionWithCallType) {
-  EXPECT_CALL(mock_foo_, CTUnary(Eq(2)))
-      .Times(2)
-      .WillOnce(Return(true))
-      .WillOnce(Return(false));
-
-  EXPECT_TRUE(foo_->CTUnary(2));
-  EXPECT_FALSE(foo_->CTUnary(2));
-}
-
-// Tests mocking a decimal function with calltype.
-TEST_F(FunctionMockerTest, MocksDecimalFunctionWithCallType) {
-  EXPECT_CALL(mock_foo_, CTDecimal(true, 'a', 0, 0, 1L, A<float>(),
-                                   Lt(100), 5U, NULL, "hi"))
-      .WillOnce(Return(10));
-
-  EXPECT_EQ(10, foo_->CTDecimal(true, 'a', 0, 0, 1, 0, 0, 5, NULL, "hi"));
-}
-
-// Tests mocking functions overloaded on the const-ness of this object.
-TEST_F(FunctionMockerTest, MocksFunctionsConstFunctionWithCallType) {
-  EXPECT_CALL(Const(mock_foo_), CTConst(_))
-      .WillOnce(Return('a'));
-
-  EXPECT_EQ('a', Const(*foo_).CTConst(0));
-}
-
-TEST_F(FunctionMockerTest, MocksReturnTypeWithCommaAndCallType) {
-  const std::map<int, string> a_map;
-  EXPECT_CALL(mock_foo_, CTReturnTypeWithComma())
-      .WillOnce(Return(a_map));
-
-  EXPECT_EQ(a_map, mock_foo_.CTReturnTypeWithComma());
-}
-
-#endif  // GTEST_OS_WINDOWS
-
-class MockB {
- public:
-  MockB() {}
-
-  MOCK_METHOD0(DoB, void());
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
-};
-
-// Tests that functions with no EXPECT_CALL() ruls can be called any
-// number of times.
-TEST(ExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOfTimes) {
-  {
-    MockB b;
-  }
-
-  {
-    MockB b;
-    b.DoB();
-  }
-
-  {
-    MockB b;
-    b.DoB();
-    b.DoB();
-  }
-}
-
-// Tests mocking template interfaces.
-
-template <typename T>
-class StackInterface {
- public:
-  virtual ~StackInterface() {}
-
-  // Template parameter appears in function parameter.
-  virtual void Push(const T& value) = 0;
-  virtual void Pop() = 0;
-  virtual int GetSize() const = 0;
-  // Template parameter appears in function return type.
-  virtual const T& GetTop() const = 0;
-};
-
-template <typename T>
-class MockStack : public StackInterface<T> {
- public:
-  MockStack() {}
-
-  MOCK_METHOD1_T(Push, void(const T& elem));
-  MOCK_METHOD0_T(Pop, void());
-  MOCK_CONST_METHOD0_T(GetSize, int());  // NOLINT
-  MOCK_CONST_METHOD0_T(GetTop, const T&());
-
-  // Tests that the function return type can contain unprotected comma.
-  MOCK_METHOD0_T(ReturnTypeWithComma, std::map<int, int>());
-  MOCK_CONST_METHOD1_T(ReturnTypeWithComma, std::map<int, int>(int));  // NOLINT
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStack);
-};
-
-// Tests that template mock works.
-TEST(TemplateMockTest, Works) {
-  MockStack<int> mock;
-
-  EXPECT_CALL(mock, GetSize())
-      .WillOnce(Return(0))
-      .WillOnce(Return(1))
-      .WillOnce(Return(0));
-  EXPECT_CALL(mock, Push(_));
-  int n = 5;
-  EXPECT_CALL(mock, GetTop())
-      .WillOnce(ReturnRef(n));
-  EXPECT_CALL(mock, Pop())
-      .Times(AnyNumber());
-
-  EXPECT_EQ(0, mock.GetSize());
-  mock.Push(5);
-  EXPECT_EQ(1, mock.GetSize());
-  EXPECT_EQ(5, mock.GetTop());
-  mock.Pop();
-  EXPECT_EQ(0, mock.GetSize());
-}
-
-TEST(TemplateMockTest, MethodWithCommaInReturnTypeWorks) {
-  MockStack<int> mock;
-
-  const std::map<int, int> a_map;
-  EXPECT_CALL(mock, ReturnTypeWithComma())
-      .WillOnce(Return(a_map));
-  EXPECT_CALL(mock, ReturnTypeWithComma(1))
-      .WillOnce(Return(a_map));
-
-  EXPECT_EQ(a_map, mock.ReturnTypeWithComma());
-  EXPECT_EQ(a_map, mock.ReturnTypeWithComma(1));
-}
-
-#if GTEST_OS_WINDOWS
-// Tests mocking template interfaces with calltype.
-
-template <typename T>
-class StackInterfaceWithCallType {
- public:
-  virtual ~StackInterfaceWithCallType() {}
-
-  // Template parameter appears in function parameter.
-  STDMETHOD_(void, Push)(const T& value) = 0;
-  STDMETHOD_(void, Pop)() = 0;
-  STDMETHOD_(int, GetSize)() const = 0;
-  // Template parameter appears in function return type.
-  STDMETHOD_(const T&, GetTop)() const = 0;
-};
-
-template <typename T>
-class MockStackWithCallType : public StackInterfaceWithCallType<T> {
- public:
-  MockStackWithCallType() {}
-
-  MOCK_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Push, void(const T& elem));
-  MOCK_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Pop, void());
-  MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetSize, int());
-  MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetTop, const T&());
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStackWithCallType);
-};
-
-// Tests that template mock with calltype works.
-TEST(TemplateMockTestWithCallType, Works) {
-  MockStackWithCallType<int> mock;
-
-  EXPECT_CALL(mock, GetSize())
-      .WillOnce(Return(0))
-      .WillOnce(Return(1))
-      .WillOnce(Return(0));
-  EXPECT_CALL(mock, Push(_));
-  int n = 5;
-  EXPECT_CALL(mock, GetTop())
-      .WillOnce(ReturnRef(n));
-  EXPECT_CALL(mock, Pop())
-      .Times(AnyNumber());
-
-  EXPECT_EQ(0, mock.GetSize());
-  mock.Push(5);
-  EXPECT_EQ(1, mock.GetSize());
-  EXPECT_EQ(5, mock.GetTop());
-  mock.Pop();
-  EXPECT_EQ(0, mock.GetSize());
-}
-#endif  // GTEST_OS_WINDOWS
-
-#define MY_MOCK_METHODS1_ \
-    MOCK_METHOD0(Overloaded, void()); \
-    MOCK_CONST_METHOD1(Overloaded, int(int n)); \
-    MOCK_METHOD2(Overloaded, bool(bool f, int n))
-
-class MockOverloadedOnArgNumber {
- public:
-  MockOverloadedOnArgNumber() {}
-
-  MY_MOCK_METHODS1_;
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnArgNumber);
-};
-
-TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) {
-  MockOverloadedOnArgNumber mock;
-  EXPECT_CALL(mock, Overloaded());
-  EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2));
-  EXPECT_CALL(mock, Overloaded(true, 1)).WillOnce(Return(true));
-
-  mock.Overloaded();
-  EXPECT_EQ(2, mock.Overloaded(1));
-  EXPECT_TRUE(mock.Overloaded(true, 1));
-}
-
-#define MY_MOCK_METHODS2_ \
-    MOCK_CONST_METHOD1(Overloaded, int(int n)); \
-    MOCK_METHOD1(Overloaded, int(int n));
-
-class MockOverloadedOnConstness {
- public:
-  MockOverloadedOnConstness() {}
-
-  MY_MOCK_METHODS2_;
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnConstness);
-};
-
-TEST(OverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody) {
-  MockOverloadedOnConstness mock;
-  const MockOverloadedOnConstness* const_mock = &mock;
-  EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2));
-  EXPECT_CALL(*const_mock, Overloaded(1)).WillOnce(Return(3));
-
-  EXPECT_EQ(2, mock.Overloaded(1));
-  EXPECT_EQ(3, const_mock->Overloaded(1));
-}
-
-TEST(MockFunctionTest, WorksForVoidNullary) {
-  MockFunction<void()> foo;
-  EXPECT_CALL(foo, Call());
-  foo.Call();
-}
-
-TEST(MockFunctionTest, WorksForNonVoidNullary) {
-  MockFunction<int()> foo;
-  EXPECT_CALL(foo, Call())
-      .WillOnce(Return(1))
-      .WillOnce(Return(2));
-  EXPECT_EQ(1, foo.Call());
-  EXPECT_EQ(2, foo.Call());
-}
-
-TEST(MockFunctionTest, WorksForVoidUnary) {
-  MockFunction<void(int)> foo;
-  EXPECT_CALL(foo, Call(1));
-  foo.Call(1);
-}
-
-TEST(MockFunctionTest, WorksForNonVoidBinary) {
-  MockFunction<int(bool, int)> foo;
-  EXPECT_CALL(foo, Call(false, 42))
-      .WillOnce(Return(1))
-      .WillOnce(Return(2));
-  EXPECT_CALL(foo, Call(true, Ge(100)))
-      .WillOnce(Return(3));
-  EXPECT_EQ(1, foo.Call(false, 42));
-  EXPECT_EQ(2, foo.Call(false, 42));
-  EXPECT_EQ(3, foo.Call(true, 120));
-}
-
-TEST(MockFunctionTest, WorksFor10Arguments) {
-  MockFunction<int(bool a0, char a1, int a2, int a3, int a4,
-                   int a5, int a6, char a7, int a8, bool a9)> foo;
-  EXPECT_CALL(foo, Call(_, 'a', _, _, _, _, _, _, _, _))
-      .WillOnce(Return(1))
-      .WillOnce(Return(2));
-  EXPECT_EQ(1, foo.Call(false, 'a', 0, 0, 0, 0, 0, 'b', 0, true));
-  EXPECT_EQ(2, foo.Call(true, 'a', 0, 0, 0, 0, 0, 'b', 1, false));
-}
-
-#if GTEST_HAS_STD_FUNCTION_
-TEST(MockFunctionTest, AsStdFunction) {
-  MockFunction<int(int)> foo;
-  auto call = [](const std::function<int(int)> &f, int i) {
-    return f(i);
-  };
-  EXPECT_CALL(foo, Call(1)).WillOnce(Return(-1));
-  EXPECT_CALL(foo, Call(2)).WillOnce(Return(-2));
-  EXPECT_EQ(-1, call(foo.AsStdFunction(), 1));
-  EXPECT_EQ(-2, call(foo.AsStdFunction(), 2));
-}
-
-TEST(MockFunctionTest, AsStdFunctionReturnsReference) {
-  MockFunction<int&()> foo;
-  int value = 1;
-  EXPECT_CALL(foo, Call()).WillOnce(ReturnRef(value));
-  int& ref = foo.AsStdFunction()();
-  EXPECT_EQ(1, ref);
-  value = 2;
-  EXPECT_EQ(2, ref);
-}
-#endif  // GTEST_HAS_STD_FUNCTION_
-
-}  // namespace gmock_generated_function_mockers_test
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-internal-utils_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-internal-utils_test.cc
deleted file mode 100644
index e0a535a3..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-internal-utils_test.cc
+++ /dev/null
@@ -1,127 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests the internal utilities.
-
-#include "gmock/internal/gmock-generated-internal-utils.h"
-#include "gmock/internal/gmock-internal-utils.h"
-#include "gtest/gtest.h"
-
-namespace {
-
-using ::testing::tuple;
-using ::testing::Matcher;
-using ::testing::internal::CompileAssertTypesEqual;
-using ::testing::internal::MatcherTuple;
-using ::testing::internal::Function;
-using ::testing::internal::IgnoredValue;
-
-// Tests the MatcherTuple template struct.
-
-TEST(MatcherTupleTest, ForSize0) {
-  CompileAssertTypesEqual<tuple<>, MatcherTuple<tuple<> >::type>();
-}
-
-TEST(MatcherTupleTest, ForSize1) {
-  CompileAssertTypesEqual<tuple<Matcher<int> >,
-                          MatcherTuple<tuple<int> >::type>();
-}
-
-TEST(MatcherTupleTest, ForSize2) {
-  CompileAssertTypesEqual<tuple<Matcher<int>, Matcher<char> >,
-                          MatcherTuple<tuple<int, char> >::type>();
-}
-
-TEST(MatcherTupleTest, ForSize5) {
-  CompileAssertTypesEqual<tuple<Matcher<int>, Matcher<char>, Matcher<bool>,
-                                Matcher<double>, Matcher<char*> >,
-                          MatcherTuple<tuple<int, char, bool, double, char*>
-                                      >::type>();
-}
-
-// Tests the Function template struct.
-
-TEST(FunctionTest, Nullary) {
-  typedef Function<int()> F;  // NOLINT
-  CompileAssertTypesEqual<int, F::Result>();
-  CompileAssertTypesEqual<tuple<>, F::ArgumentTuple>();
-  CompileAssertTypesEqual<tuple<>, F::ArgumentMatcherTuple>();
-  CompileAssertTypesEqual<void(), F::MakeResultVoid>();
-  CompileAssertTypesEqual<IgnoredValue(), F::MakeResultIgnoredValue>();
-}
-
-TEST(FunctionTest, Unary) {
-  typedef Function<int(bool)> F;  // NOLINT
-  CompileAssertTypesEqual<int, F::Result>();
-  CompileAssertTypesEqual<bool, F::Argument1>();
-  CompileAssertTypesEqual<tuple<bool>, F::ArgumentTuple>();
-  CompileAssertTypesEqual<tuple<Matcher<bool> >, F::ArgumentMatcherTuple>();
-  CompileAssertTypesEqual<void(bool), F::MakeResultVoid>();  // NOLINT
-  CompileAssertTypesEqual<IgnoredValue(bool),  // NOLINT
-      F::MakeResultIgnoredValue>();
-}
-
-TEST(FunctionTest, Binary) {
-  typedef Function<int(bool, const long&)> F;  // NOLINT
-  CompileAssertTypesEqual<int, F::Result>();
-  CompileAssertTypesEqual<bool, F::Argument1>();
-  CompileAssertTypesEqual<const long&, F::Argument2>();  // NOLINT
-  CompileAssertTypesEqual<tuple<bool, const long&>, F::ArgumentTuple>();  // NOLINT
-  CompileAssertTypesEqual<tuple<Matcher<bool>, Matcher<const long&> >,  // NOLINT
-                          F::ArgumentMatcherTuple>();
-  CompileAssertTypesEqual<void(bool, const long&), F::MakeResultVoid>();  // NOLINT
-  CompileAssertTypesEqual<IgnoredValue(bool, const long&),  // NOLINT
-      F::MakeResultIgnoredValue>();
-}
-
-TEST(FunctionTest, LongArgumentList) {
-  typedef Function<char(bool, int, char*, int&, const long&)> F;  // NOLINT
-  CompileAssertTypesEqual<char, F::Result>();
-  CompileAssertTypesEqual<bool, F::Argument1>();
-  CompileAssertTypesEqual<int, F::Argument2>();
-  CompileAssertTypesEqual<char*, F::Argument3>();
-  CompileAssertTypesEqual<int&, F::Argument4>();
-  CompileAssertTypesEqual<const long&, F::Argument5>();  // NOLINT
-  CompileAssertTypesEqual<tuple<bool, int, char*, int&, const long&>,  // NOLINT
-                          F::ArgumentTuple>();
-  CompileAssertTypesEqual<tuple<Matcher<bool>, Matcher<int>, Matcher<char*>,
-                                Matcher<int&>, Matcher<const long&> >,  // NOLINT
-                          F::ArgumentMatcherTuple>();
-  CompileAssertTypesEqual<void(bool, int, char*, int&, const long&),  // NOLINT
-                          F::MakeResultVoid>();
-  CompileAssertTypesEqual<
-      IgnoredValue(bool, int, char*, int&, const long&),  // NOLINT
-      F::MakeResultIgnoredValue>();
-}
-
-}  // Unnamed namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-matchers_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-matchers_test.cc
deleted file mode 100644
index 0e9f77f5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-generated-matchers_test.cc
+++ /dev/null
@@ -1,1286 +0,0 @@
-// 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.
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests the built-in matchers generated by a script.
-
-#include "gmock/gmock-generated-matchers.h"
-
-#include <list>
-#include <map>
-#include <set>
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "gtest/gtest-spi.h"
-
-namespace {
-
-using std::list;
-using std::map;
-using std::pair;
-using std::set;
-using std::stringstream;
-using std::vector;
-using testing::get;
-using testing::make_tuple;
-using testing::tuple;
-using testing::_;
-using testing::Args;
-using testing::Contains;
-using testing::ElementsAre;
-using testing::ElementsAreArray;
-using testing::Eq;
-using testing::Ge;
-using testing::Gt;
-using testing::Le;
-using testing::Lt;
-using testing::MakeMatcher;
-using testing::Matcher;
-using testing::MatcherInterface;
-using testing::MatchResultListener;
-using testing::Ne;
-using testing::Not;
-using testing::Pointee;
-using testing::PrintToString;
-using testing::Ref;
-using testing::StaticAssertTypeEq;
-using testing::StrEq;
-using testing::Value;
-using testing::internal::ElementsAreArrayMatcher;
-using testing::internal::string;
-
-// Returns the description of the given matcher.
-template <typename T>
-string Describe(const Matcher<T>& m) {
-  stringstream ss;
-  m.DescribeTo(&ss);
-  return ss.str();
-}
-
-// Returns the description of the negation of the given matcher.
-template <typename T>
-string DescribeNegation(const Matcher<T>& m) {
-  stringstream ss;
-  m.DescribeNegationTo(&ss);
-  return ss.str();
-}
-
-// Returns the reason why x matches, or doesn't match, m.
-template <typename MatcherType, typename Value>
-string Explain(const MatcherType& m, const Value& x) {
-  stringstream ss;
-  m.ExplainMatchResultTo(x, &ss);
-  return ss.str();
-}
-
-// Tests Args<k0, ..., kn>(m).
-
-TEST(ArgsTest, AcceptsZeroTemplateArg) {
-  const tuple<int, bool> t(5, true);
-  EXPECT_THAT(t, Args<>(Eq(tuple<>())));
-  EXPECT_THAT(t, Not(Args<>(Ne(tuple<>()))));
-}
-
-TEST(ArgsTest, AcceptsOneTemplateArg) {
-  const tuple<int, bool> t(5, true);
-  EXPECT_THAT(t, Args<0>(Eq(make_tuple(5))));
-  EXPECT_THAT(t, Args<1>(Eq(make_tuple(true))));
-  EXPECT_THAT(t, Not(Args<1>(Eq(make_tuple(false)))));
-}
-
-TEST(ArgsTest, AcceptsTwoTemplateArgs) {
-  const tuple<short, int, long> t(4, 5, 6L);  // NOLINT
-
-  EXPECT_THAT(t, (Args<0, 1>(Lt())));
-  EXPECT_THAT(t, (Args<1, 2>(Lt())));
-  EXPECT_THAT(t, Not(Args<0, 2>(Gt())));
-}
-
-TEST(ArgsTest, AcceptsRepeatedTemplateArgs) {
-  const tuple<short, int, long> t(4, 5, 6L);  // NOLINT
-  EXPECT_THAT(t, (Args<0, 0>(Eq())));
-  EXPECT_THAT(t, Not(Args<1, 1>(Ne())));
-}
-
-TEST(ArgsTest, AcceptsDecreasingTemplateArgs) {
-  const tuple<short, int, long> t(4, 5, 6L);  // NOLINT
-  EXPECT_THAT(t, (Args<2, 0>(Gt())));
-  EXPECT_THAT(t, Not(Args<2, 1>(Lt())));
-}
-
-// The MATCHER*() 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
-// is expanded and macro expansion cannot contain #pragma.  Therefore
-// we suppress them here.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
-#endif
-
-MATCHER(SumIsZero, "") {
-  return get<0>(arg) + get<1>(arg) + get<2>(arg) == 0;
-}
-
-TEST(ArgsTest, AcceptsMoreTemplateArgsThanArityOfOriginalTuple) {
-  EXPECT_THAT(make_tuple(-1, 2), (Args<0, 0, 1>(SumIsZero())));
-  EXPECT_THAT(make_tuple(1, 2), Not(Args<0, 0, 1>(SumIsZero())));
-}
-
-TEST(ArgsTest, CanBeNested) {
-  const tuple<short, int, long, int> t(4, 5, 6L, 6);  // NOLINT
-  EXPECT_THAT(t, (Args<1, 2, 3>(Args<1, 2>(Eq()))));
-  EXPECT_THAT(t, (Args<0, 1, 3>(Args<0, 2>(Lt()))));
-}
-
-TEST(ArgsTest, CanMatchTupleByValue) {
-  typedef tuple<char, int, int> Tuple3;
-  const Matcher<Tuple3> m = Args<1, 2>(Lt());
-  EXPECT_TRUE(m.Matches(Tuple3('a', 1, 2)));
-  EXPECT_FALSE(m.Matches(Tuple3('b', 2, 2)));
-}
-
-TEST(ArgsTest, CanMatchTupleByReference) {
-  typedef tuple<char, char, int> Tuple3;
-  const Matcher<const Tuple3&> m = Args<0, 1>(Lt());
-  EXPECT_TRUE(m.Matches(Tuple3('a', 'b', 2)));
-  EXPECT_FALSE(m.Matches(Tuple3('b', 'b', 2)));
-}
-
-// Validates that arg is printed as str.
-MATCHER_P(PrintsAs, str, "") {
-  return testing::PrintToString(arg) == str;
-}
-
-TEST(ArgsTest, AcceptsTenTemplateArgs) {
-  EXPECT_THAT(make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9),
-              (Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>(
-                  PrintsAs("(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)"))));
-  EXPECT_THAT(make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9),
-              Not(Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>(
-                      PrintsAs("(0, 8, 7, 6, 5, 4, 3, 2, 1, 0)"))));
-}
-
-TEST(ArgsTest, DescirbesSelfCorrectly) {
-  const Matcher<tuple<int, bool, char> > m = Args<2, 0>(Lt());
-  EXPECT_EQ("are a tuple whose fields (#2, #0) are a pair where "
-            "the first < the second",
-            Describe(m));
-}
-
-TEST(ArgsTest, DescirbesNestedArgsCorrectly) {
-  const Matcher<const tuple<int, bool, char, int>&> m =
-      Args<0, 2, 3>(Args<2, 0>(Lt()));
-  EXPECT_EQ("are a tuple whose fields (#0, #2, #3) are a tuple "
-            "whose fields (#2, #0) are a pair where the first < the second",
-            Describe(m));
-}
-
-TEST(ArgsTest, DescribesNegationCorrectly) {
-  const Matcher<tuple<int, char> > m = Args<1, 0>(Gt());
-  EXPECT_EQ("are a tuple whose fields (#1, #0) aren't a pair "
-            "where the first > the second",
-            DescribeNegation(m));
-}
-
-TEST(ArgsTest, ExplainsMatchResultWithoutInnerExplanation) {
-  const Matcher<tuple<bool, int, int> > m = Args<1, 2>(Eq());
-  EXPECT_EQ("whose fields (#1, #2) are (42, 42)",
-            Explain(m, make_tuple(false, 42, 42)));
-  EXPECT_EQ("whose fields (#1, #2) are (42, 43)",
-            Explain(m, make_tuple(false, 42, 43)));
-}
-
-// For testing Args<>'s explanation.
-class LessThanMatcher : public MatcherInterface<tuple<char, int> > {
- public:
-  virtual void DescribeTo(::std::ostream* os) const {}
-
-  virtual bool MatchAndExplain(tuple<char, int> value,
-                               MatchResultListener* listener) const {
-    const int diff = get<0>(value) - get<1>(value);
-    if (diff > 0) {
-      *listener << "where the first value is " << diff
-                << " more than the second";
-    }
-    return diff < 0;
-  }
-};
-
-Matcher<tuple<char, int> > LessThan() {
-  return MakeMatcher(new LessThanMatcher);
-}
-
-TEST(ArgsTest, ExplainsMatchResultWithInnerExplanation) {
-  const Matcher<tuple<char, int, int> > m = Args<0, 2>(LessThan());
-  EXPECT_EQ("whose fields (#0, #2) are ('a' (97, 0x61), 42), "
-            "where the first value is 55 more than the second",
-            Explain(m, make_tuple('a', 42, 42)));
-  EXPECT_EQ("whose fields (#0, #2) are ('\\0', 43)",
-            Explain(m, make_tuple('\0', 42, 43)));
-}
-
-// For testing ExplainMatchResultTo().
-class GreaterThanMatcher : public MatcherInterface<int> {
- public:
-  explicit GreaterThanMatcher(int rhs) : rhs_(rhs) {}
-
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "is greater than " << rhs_;
-  }
-
-  virtual bool MatchAndExplain(int lhs,
-                               MatchResultListener* listener) const {
-    const int diff = lhs - rhs_;
-    if (diff > 0) {
-      *listener << "which is " << diff << " more than " << rhs_;
-    } else if (diff == 0) {
-      *listener << "which is the same as " << rhs_;
-    } else {
-      *listener << "which is " << -diff << " less than " << rhs_;
-    }
-
-    return lhs > rhs_;
-  }
-
- private:
-  int rhs_;
-};
-
-Matcher<int> GreaterThan(int n) {
-  return MakeMatcher(new GreaterThanMatcher(n));
-}
-
-// Tests for ElementsAre().
-
-TEST(ElementsAreTest, CanDescribeExpectingNoElement) {
-  Matcher<const vector<int>&> m = ElementsAre();
-  EXPECT_EQ("is empty", Describe(m));
-}
-
-TEST(ElementsAreTest, CanDescribeExpectingOneElement) {
-  Matcher<vector<int> > m = ElementsAre(Gt(5));
-  EXPECT_EQ("has 1 element that is > 5", Describe(m));
-}
-
-TEST(ElementsAreTest, CanDescribeExpectingManyElements) {
-  Matcher<list<string> > m = ElementsAre(StrEq("one"), "two");
-  EXPECT_EQ("has 2 elements where\n"
-            "element #0 is equal to \"one\",\n"
-            "element #1 is equal to \"two\"", Describe(m));
-}
-
-TEST(ElementsAreTest, CanDescribeNegationOfExpectingNoElement) {
-  Matcher<vector<int> > m = ElementsAre();
-  EXPECT_EQ("isn't empty", DescribeNegation(m));
-}
-
-TEST(ElementsAreTest, CanDescribeNegationOfExpectingOneElment) {
-  Matcher<const list<int>& > m = ElementsAre(Gt(5));
-  EXPECT_EQ("doesn't have 1 element, or\n"
-            "element #0 isn't > 5", DescribeNegation(m));
-}
-
-TEST(ElementsAreTest, CanDescribeNegationOfExpectingManyElements) {
-  Matcher<const list<string>& > m = ElementsAre("one", "two");
-  EXPECT_EQ("doesn't have 2 elements, or\n"
-            "element #0 isn't equal to \"one\", or\n"
-            "element #1 isn't equal to \"two\"", DescribeNegation(m));
-}
-
-TEST(ElementsAreTest, DoesNotExplainTrivialMatch) {
-  Matcher<const list<int>& > m = ElementsAre(1, Ne(2));
-
-  list<int> test_list;
-  test_list.push_back(1);
-  test_list.push_back(3);
-  EXPECT_EQ("", Explain(m, test_list));  // No need to explain anything.
-}
-
-TEST(ElementsAreTest, ExplainsNonTrivialMatch) {
-  Matcher<const vector<int>& > m =
-      ElementsAre(GreaterThan(1), 0, GreaterThan(2));
-
-  const int a[] = { 10, 0, 100 };
-  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
-  EXPECT_EQ("whose element #0 matches, which is 9 more than 1,\n"
-            "and whose element #2 matches, which is 98 more than 2",
-            Explain(m, test_vector));
-}
-
-TEST(ElementsAreTest, CanExplainMismatchWrongSize) {
-  Matcher<const list<int>& > m = ElementsAre(1, 3);
-
-  list<int> test_list;
-  // No need to explain when the container is empty.
-  EXPECT_EQ("", Explain(m, test_list));
-
-  test_list.push_back(1);
-  EXPECT_EQ("which has 1 element", Explain(m, test_list));
-}
-
-TEST(ElementsAreTest, CanExplainMismatchRightSize) {
-  Matcher<const vector<int>& > m = ElementsAre(1, GreaterThan(5));
-
-  vector<int> v;
-  v.push_back(2);
-  v.push_back(1);
-  EXPECT_EQ("whose element #0 doesn't match", Explain(m, v));
-
-  v[0] = 1;
-  EXPECT_EQ("whose element #1 doesn't match, which is 4 less than 5",
-            Explain(m, v));
-}
-
-TEST(ElementsAreTest, MatchesOneElementVector) {
-  vector<string> test_vector;
-  test_vector.push_back("test string");
-
-  EXPECT_THAT(test_vector, ElementsAre(StrEq("test string")));
-}
-
-TEST(ElementsAreTest, MatchesOneElementList) {
-  list<string> test_list;
-  test_list.push_back("test string");
-
-  EXPECT_THAT(test_list, ElementsAre("test string"));
-}
-
-TEST(ElementsAreTest, MatchesThreeElementVector) {
-  vector<string> test_vector;
-  test_vector.push_back("one");
-  test_vector.push_back("two");
-  test_vector.push_back("three");
-
-  EXPECT_THAT(test_vector, ElementsAre("one", StrEq("two"), _));
-}
-
-TEST(ElementsAreTest, MatchesOneElementEqMatcher) {
-  vector<int> test_vector;
-  test_vector.push_back(4);
-
-  EXPECT_THAT(test_vector, ElementsAre(Eq(4)));
-}
-
-TEST(ElementsAreTest, MatchesOneElementAnyMatcher) {
-  vector<int> test_vector;
-  test_vector.push_back(4);
-
-  EXPECT_THAT(test_vector, ElementsAre(_));
-}
-
-TEST(ElementsAreTest, MatchesOneElementValue) {
-  vector<int> test_vector;
-  test_vector.push_back(4);
-
-  EXPECT_THAT(test_vector, ElementsAre(4));
-}
-
-TEST(ElementsAreTest, MatchesThreeElementsMixedMatchers) {
-  vector<int> test_vector;
-  test_vector.push_back(1);
-  test_vector.push_back(2);
-  test_vector.push_back(3);
-
-  EXPECT_THAT(test_vector, ElementsAre(1, Eq(2), _));
-}
-
-TEST(ElementsAreTest, MatchesTenElementVector) {
-  const int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
-
-  EXPECT_THAT(test_vector,
-              // The element list can contain values and/or matchers
-              // of different types.
-              ElementsAre(0, Ge(0), _, 3, 4, Ne(2), Eq(6), 7, 8, _));
-}
-
-TEST(ElementsAreTest, DoesNotMatchWrongSize) {
-  vector<string> test_vector;
-  test_vector.push_back("test string");
-  test_vector.push_back("test string");
-
-  Matcher<vector<string> > m = ElementsAre(StrEq("test string"));
-  EXPECT_FALSE(m.Matches(test_vector));
-}
-
-TEST(ElementsAreTest, DoesNotMatchWrongValue) {
-  vector<string> test_vector;
-  test_vector.push_back("other string");
-
-  Matcher<vector<string> > m = ElementsAre(StrEq("test string"));
-  EXPECT_FALSE(m.Matches(test_vector));
-}
-
-TEST(ElementsAreTest, DoesNotMatchWrongOrder) {
-  vector<string> test_vector;
-  test_vector.push_back("one");
-  test_vector.push_back("three");
-  test_vector.push_back("two");
-
-  Matcher<vector<string> > m = ElementsAre(
-    StrEq("one"), StrEq("two"), StrEq("three"));
-  EXPECT_FALSE(m.Matches(test_vector));
-}
-
-TEST(ElementsAreTest, WorksForNestedContainer) {
-  const char* strings[] = {
-    "Hi",
-    "world"
-  };
-
-  vector<list<char> > nested;
-  for (size_t i = 0; i < GTEST_ARRAY_SIZE_(strings); i++) {
-    nested.push_back(list<char>(strings[i], strings[i] + strlen(strings[i])));
-  }
-
-  EXPECT_THAT(nested, ElementsAre(ElementsAre('H', Ne('e')),
-                                  ElementsAre('w', 'o', _, _, 'd')));
-  EXPECT_THAT(nested, Not(ElementsAre(ElementsAre('H', 'e'),
-                                      ElementsAre('w', 'o', _, _, 'd'))));
-}
-
-TEST(ElementsAreTest, WorksWithByRefElementMatchers) {
-  int a[] = { 0, 1, 2 };
-  vector<int> v(a, a + GTEST_ARRAY_SIZE_(a));
-
-  EXPECT_THAT(v, ElementsAre(Ref(v[0]), Ref(v[1]), Ref(v[2])));
-  EXPECT_THAT(v, Not(ElementsAre(Ref(v[0]), Ref(v[1]), Ref(a[2]))));
-}
-
-TEST(ElementsAreTest, WorksWithContainerPointerUsingPointee) {
-  int a[] = { 0, 1, 2 };
-  vector<int> v(a, a + GTEST_ARRAY_SIZE_(a));
-
-  EXPECT_THAT(&v, Pointee(ElementsAre(0, 1, _)));
-  EXPECT_THAT(&v, Not(Pointee(ElementsAre(0, _, 3))));
-}
-
-TEST(ElementsAreTest, WorksWithNativeArrayPassedByReference) {
-  int array[] = { 0, 1, 2 };
-  EXPECT_THAT(array, ElementsAre(0, 1, _));
-  EXPECT_THAT(array, Not(ElementsAre(1, _, _)));
-  EXPECT_THAT(array, Not(ElementsAre(0, _)));
-}
-
-class NativeArrayPassedAsPointerAndSize {
- public:
-  NativeArrayPassedAsPointerAndSize() {}
-
-  MOCK_METHOD2(Helper, void(int* array, int size));
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(NativeArrayPassedAsPointerAndSize);
-};
-
-TEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) {
-  int array[] = { 0, 1 };
-  ::testing::tuple<int*, size_t> array_as_tuple(array, 2);
-  EXPECT_THAT(array_as_tuple, ElementsAre(0, 1));
-  EXPECT_THAT(array_as_tuple, Not(ElementsAre(0)));
-
-  NativeArrayPassedAsPointerAndSize helper;
-  EXPECT_CALL(helper, Helper(_, _))
-      .With(ElementsAre(0, 1));
-  helper.Helper(array, 2);
-}
-
-TEST(ElementsAreTest, WorksWithTwoDimensionalNativeArray) {
-  const char a2[][3] = { "hi", "lo" };
-  EXPECT_THAT(a2, ElementsAre(ElementsAre('h', 'i', '\0'),
-                              ElementsAre('l', 'o', '\0')));
-  EXPECT_THAT(a2, ElementsAre(StrEq("hi"), StrEq("lo")));
-  EXPECT_THAT(a2, ElementsAre(Not(ElementsAre('h', 'o', '\0')),
-                              ElementsAre('l', 'o', '\0')));
-}
-
-TEST(ElementsAreTest, AcceptsStringLiteral) {
-  string array[] = { "hi", "one", "two" };
-  EXPECT_THAT(array, ElementsAre("hi", "one", "two"));
-  EXPECT_THAT(array, Not(ElementsAre("hi", "one", "too")));
-}
-
-#ifndef _MSC_VER
-
-// The following test passes a value of type const char[] to a
-// function template that expects const T&.  Some versions of MSVC
-// generates a compiler error C2665 for that.  We believe it's a bug
-// in MSVC.  Therefore this test is #if-ed out for MSVC.
-
-// Declared here with the size unknown.  Defined AFTER the following test.
-extern const char kHi[];
-
-TEST(ElementsAreTest, AcceptsArrayWithUnknownSize) {
-  // The size of kHi is not known in this test, but ElementsAre() should
-  // still accept it.
-
-  string array1[] = { "hi" };
-  EXPECT_THAT(array1, ElementsAre(kHi));
-
-  string array2[] = { "ho" };
-  EXPECT_THAT(array2, Not(ElementsAre(kHi)));
-}
-
-const char kHi[] = "hi";
-
-#endif  // _MSC_VER
-
-TEST(ElementsAreTest, MakesCopyOfArguments) {
-  int x = 1;
-  int y = 2;
-  // This should make a copy of x and y.
-  ::testing::internal::ElementsAreMatcher<testing::tuple<int, int> >
-          polymorphic_matcher = ElementsAre(x, y);
-  // Changing x and y now shouldn't affect the meaning of the above matcher.
-  x = y = 0;
-  const int array1[] = { 1, 2 };
-  EXPECT_THAT(array1, polymorphic_matcher);
-  const int array2[] = { 0, 0 };
-  EXPECT_THAT(array2, Not(polymorphic_matcher));
-}
-
-
-// Tests for ElementsAreArray().  Since ElementsAreArray() shares most
-// of the implementation with ElementsAre(), we don't test it as
-// thoroughly here.
-
-TEST(ElementsAreArrayTest, CanBeCreatedWithValueArray) {
-  const int a[] = { 1, 2, 3 };
-
-  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
-  EXPECT_THAT(test_vector, ElementsAreArray(a));
-
-  test_vector[2] = 0;
-  EXPECT_THAT(test_vector, Not(ElementsAreArray(a)));
-}
-
-TEST(ElementsAreArrayTest, CanBeCreatedWithArraySize) {
-  const char* a[] = { "one", "two", "three" };
-
-  vector<string> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
-  EXPECT_THAT(test_vector, ElementsAreArray(a, GTEST_ARRAY_SIZE_(a)));
-
-  const char** p = a;
-  test_vector[0] = "1";
-  EXPECT_THAT(test_vector, Not(ElementsAreArray(p, GTEST_ARRAY_SIZE_(a))));
-}
-
-TEST(ElementsAreArrayTest, CanBeCreatedWithoutArraySize) {
-  const char* a[] = { "one", "two", "three" };
-
-  vector<string> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
-  EXPECT_THAT(test_vector, ElementsAreArray(a));
-
-  test_vector[0] = "1";
-  EXPECT_THAT(test_vector, Not(ElementsAreArray(a)));
-}
-
-TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherArray) {
-  const Matcher<string> kMatcherArray[] =
-    { StrEq("one"), StrEq("two"), StrEq("three") };
-
-  vector<string> test_vector;
-  test_vector.push_back("one");
-  test_vector.push_back("two");
-  test_vector.push_back("three");
-  EXPECT_THAT(test_vector, ElementsAreArray(kMatcherArray));
-
-  test_vector.push_back("three");
-  EXPECT_THAT(test_vector, Not(ElementsAreArray(kMatcherArray)));
-}
-
-TEST(ElementsAreArrayTest, CanBeCreatedWithVector) {
-  const int a[] = { 1, 2, 3 };
-  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
-  const vector<int> expected(a, a + GTEST_ARRAY_SIZE_(a));
-  EXPECT_THAT(test_vector, ElementsAreArray(expected));
-  test_vector.push_back(4);
-  EXPECT_THAT(test_vector, Not(ElementsAreArray(expected)));
-}
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-
-TEST(ElementsAreArrayTest, TakesInitializerList) {
-  const int a[5] = { 1, 2, 3, 4, 5 };
-  EXPECT_THAT(a, ElementsAreArray({ 1, 2, 3, 4, 5 }));
-  EXPECT_THAT(a, Not(ElementsAreArray({ 1, 2, 3, 5, 4 })));
-  EXPECT_THAT(a, Not(ElementsAreArray({ 1, 2, 3, 4, 6 })));
-}
-
-TEST(ElementsAreArrayTest, TakesInitializerListOfCStrings) {
-  const string a[5] = { "a", "b", "c", "d", "e" };
-  EXPECT_THAT(a, ElementsAreArray({ "a", "b", "c", "d", "e" }));
-  EXPECT_THAT(a, Not(ElementsAreArray({ "a", "b", "c", "e", "d" })));
-  EXPECT_THAT(a, Not(ElementsAreArray({ "a", "b", "c", "d", "ef" })));
-}
-
-TEST(ElementsAreArrayTest, TakesInitializerListOfSameTypedMatchers) {
-  const int a[5] = { 1, 2, 3, 4, 5 };
-  EXPECT_THAT(a, ElementsAreArray(
-      { Eq(1), Eq(2), Eq(3), Eq(4), Eq(5) }));
-  EXPECT_THAT(a, Not(ElementsAreArray(
-      { Eq(1), Eq(2), Eq(3), Eq(4), Eq(6) })));
-}
-
-TEST(ElementsAreArrayTest,
-     TakesInitializerListOfDifferentTypedMatchers) {
-  const int a[5] = { 1, 2, 3, 4, 5 };
-  // The compiler cannot infer the type of the initializer list if its
-  // elements have different types.  We must explicitly specify the
-  // unified element type in this case.
-  EXPECT_THAT(a, ElementsAreArray<Matcher<int> >(
-      { Eq(1), Ne(-2), Ge(3), Le(4), Eq(5) }));
-  EXPECT_THAT(a, Not(ElementsAreArray<Matcher<int> >(
-      { Eq(1), Ne(-2), Ge(3), Le(4), Eq(6) })));
-}
-
-#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
-
-TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherVector) {
-  const int a[] = { 1, 2, 3 };
-  const Matcher<int> kMatchers[] = { Eq(1), Eq(2), Eq(3) };
-  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
-  const vector<Matcher<int> > expected(
-      kMatchers, kMatchers + GTEST_ARRAY_SIZE_(kMatchers));
-  EXPECT_THAT(test_vector, ElementsAreArray(expected));
-  test_vector.push_back(4);
-  EXPECT_THAT(test_vector, Not(ElementsAreArray(expected)));
-}
-
-TEST(ElementsAreArrayTest, CanBeCreatedWithIteratorRange) {
-  const int a[] = { 1, 2, 3 };
-  const vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
-  const vector<int> expected(a, a + GTEST_ARRAY_SIZE_(a));
-  EXPECT_THAT(test_vector, ElementsAreArray(expected.begin(), expected.end()));
-  // Pointers are iterators, too.
-  EXPECT_THAT(test_vector, ElementsAreArray(a, a + GTEST_ARRAY_SIZE_(a)));
-  // The empty range of NULL pointers should also be okay.
-  int* const null_int = NULL;
-  EXPECT_THAT(test_vector, Not(ElementsAreArray(null_int, null_int)));
-  EXPECT_THAT((vector<int>()), ElementsAreArray(null_int, null_int));
-}
-
-// Since ElementsAre() and ElementsAreArray() share much of the
-// implementation, we only do a sanity test for native arrays here.
-TEST(ElementsAreArrayTest, WorksWithNativeArray) {
-  ::std::string a[] = { "hi", "ho" };
-  ::std::string b[] = { "hi", "ho" };
-
-  EXPECT_THAT(a, ElementsAreArray(b));
-  EXPECT_THAT(a, ElementsAreArray(b, 2));
-  EXPECT_THAT(a, Not(ElementsAreArray(b, 1)));
-}
-
-TEST(ElementsAreArrayTest, SourceLifeSpan) {
-  const int a[] = { 1, 2, 3 };
-  vector<int> test_vector(a, a + GTEST_ARRAY_SIZE_(a));
-  vector<int> expect(a, a + GTEST_ARRAY_SIZE_(a));
-  ElementsAreArrayMatcher<int> matcher_maker =
-      ElementsAreArray(expect.begin(), expect.end());
-  EXPECT_THAT(test_vector, matcher_maker);
-  // Changing in place the values that initialized matcher_maker should not
-  // affect matcher_maker anymore. It should have made its own copy of them.
-  typedef vector<int>::iterator Iter;
-  for (Iter it = expect.begin(); it != expect.end(); ++it) { *it += 10; }
-  EXPECT_THAT(test_vector, matcher_maker);
-  test_vector.push_back(3);
-  EXPECT_THAT(test_vector, Not(matcher_maker));
-}
-
-// Tests for the MATCHER*() macro family.
-
-// Tests that a simple MATCHER() definition works.
-
-MATCHER(IsEven, "") { return (arg % 2) == 0; }
-
-TEST(MatcherMacroTest, Works) {
-  const Matcher<int> m = IsEven();
-  EXPECT_TRUE(m.Matches(6));
-  EXPECT_FALSE(m.Matches(7));
-
-  EXPECT_EQ("is even", Describe(m));
-  EXPECT_EQ("not (is even)", DescribeNegation(m));
-  EXPECT_EQ("", Explain(m, 6));
-  EXPECT_EQ("", Explain(m, 7));
-}
-
-// This also tests that the description string can reference 'negation'.
-MATCHER(IsEven2, negation ? "is odd" : "is even") {
-  if ((arg % 2) == 0) {
-    // Verifies that we can stream to result_listener, a listener
-    // supplied by the MATCHER macro implicitly.
-    *result_listener << "OK";
-    return true;
-  } else {
-    *result_listener << "% 2 == " << (arg % 2);
-    return false;
-  }
-}
-
-// This also tests that the description string can reference matcher
-// parameters.
-MATCHER_P2(EqSumOf, x, y,
-           string(negation ? "doesn't equal" : "equals") + " the sum of " +
-           PrintToString(x) + " and " + PrintToString(y)) {
-  if (arg == (x + y)) {
-    *result_listener << "OK";
-    return true;
-  } else {
-    // Verifies that we can stream to the underlying stream of
-    // result_listener.
-    if (result_listener->stream() != NULL) {
-      *result_listener->stream() << "diff == " << (x + y - arg);
-    }
-    return false;
-  }
-}
-
-// Tests that the matcher description can reference 'negation' and the
-// matcher parameters.
-TEST(MatcherMacroTest, DescriptionCanReferenceNegationAndParameters) {
-  const Matcher<int> m1 = IsEven2();
-  EXPECT_EQ("is even", Describe(m1));
-  EXPECT_EQ("is odd", DescribeNegation(m1));
-
-  const Matcher<int> m2 = EqSumOf(5, 9);
-  EXPECT_EQ("equals the sum of 5 and 9", Describe(m2));
-  EXPECT_EQ("doesn't equal the sum of 5 and 9", DescribeNegation(m2));
-}
-
-// Tests explaining match result in a MATCHER* macro.
-TEST(MatcherMacroTest, CanExplainMatchResult) {
-  const Matcher<int> m1 = IsEven2();
-  EXPECT_EQ("OK", Explain(m1, 4));
-  EXPECT_EQ("% 2 == 1", Explain(m1, 5));
-
-  const Matcher<int> m2 = EqSumOf(1, 2);
-  EXPECT_EQ("OK", Explain(m2, 3));
-  EXPECT_EQ("diff == -1", Explain(m2, 4));
-}
-
-// Tests that the body of MATCHER() can reference the type of the
-// value being matched.
-
-MATCHER(IsEmptyString, "") {
-  StaticAssertTypeEq< ::std::string, arg_type>();
-  return arg == "";
-}
-
-MATCHER(IsEmptyStringByRef, "") {
-  StaticAssertTypeEq<const ::std::string&, arg_type>();
-  return arg == "";
-}
-
-TEST(MatcherMacroTest, CanReferenceArgType) {
-  const Matcher< ::std::string> m1 = IsEmptyString();
-  EXPECT_TRUE(m1.Matches(""));
-
-  const Matcher<const ::std::string&> m2 = IsEmptyStringByRef();
-  EXPECT_TRUE(m2.Matches(""));
-}
-
-// Tests that MATCHER() can be used in a namespace.
-
-namespace matcher_test {
-MATCHER(IsOdd, "") { return (arg % 2) != 0; }
-}  // namespace matcher_test
-
-TEST(MatcherMacroTest, WorksInNamespace) {
-  Matcher<int> m = matcher_test::IsOdd();
-  EXPECT_FALSE(m.Matches(4));
-  EXPECT_TRUE(m.Matches(5));
-}
-
-// Tests that Value() can be used to compose matchers.
-MATCHER(IsPositiveOdd, "") {
-  return Value(arg, matcher_test::IsOdd()) && arg > 0;
-}
-
-TEST(MatcherMacroTest, CanBeComposedUsingValue) {
-  EXPECT_THAT(3, IsPositiveOdd());
-  EXPECT_THAT(4, Not(IsPositiveOdd()));
-  EXPECT_THAT(-1, Not(IsPositiveOdd()));
-}
-
-// Tests that a simple MATCHER_P() definition works.
-
-MATCHER_P(IsGreaterThan32And, n, "") { return arg > 32 && arg > n; }
-
-TEST(MatcherPMacroTest, Works) {
-  const Matcher<int> m = IsGreaterThan32And(5);
-  EXPECT_TRUE(m.Matches(36));
-  EXPECT_FALSE(m.Matches(5));
-
-  EXPECT_EQ("is greater than 32 and 5", Describe(m));
-  EXPECT_EQ("not (is greater than 32 and 5)", DescribeNegation(m));
-  EXPECT_EQ("", Explain(m, 36));
-  EXPECT_EQ("", Explain(m, 5));
-}
-
-// Tests that the description is calculated correctly from the matcher name.
-MATCHER_P(_is_Greater_Than32and_, n, "") { return arg > 32 && arg > n; }
-
-TEST(MatcherPMacroTest, GeneratesCorrectDescription) {
-  const Matcher<int> m = _is_Greater_Than32and_(5);
-
-  EXPECT_EQ("is greater than 32 and 5", Describe(m));
-  EXPECT_EQ("not (is greater than 32 and 5)", DescribeNegation(m));
-  EXPECT_EQ("", Explain(m, 36));
-  EXPECT_EQ("", Explain(m, 5));
-}
-
-// Tests that a MATCHER_P matcher can be explicitly instantiated with
-// a reference parameter type.
-
-class UncopyableFoo {
- public:
-  explicit UncopyableFoo(char value) : value_(value) {}
- private:
-  UncopyableFoo(const UncopyableFoo&);
-  void operator=(const UncopyableFoo&);
-
-  char value_;
-};
-
-MATCHER_P(ReferencesUncopyable, variable, "") { return &arg == &variable; }
-
-TEST(MatcherPMacroTest, WorksWhenExplicitlyInstantiatedWithReference) {
-  UncopyableFoo foo1('1'), foo2('2');
-  const Matcher<const UncopyableFoo&> m =
-      ReferencesUncopyable<const UncopyableFoo&>(foo1);
-
-  EXPECT_TRUE(m.Matches(foo1));
-  EXPECT_FALSE(m.Matches(foo2));
-
-  // We don't want the address of the parameter printed, as most
-  // likely it will just annoy the user.  If the address is
-  // interesting, the user should consider passing the parameter by
-  // pointer instead.
-  EXPECT_EQ("references uncopyable 1-byte object <31>", Describe(m));
-}
-
-
-// Tests that the body of MATCHER_Pn() can reference the parameter
-// types.
-
-MATCHER_P3(ParamTypesAreIntLongAndChar, foo, bar, baz, "") {
-  StaticAssertTypeEq<int, foo_type>();
-  StaticAssertTypeEq<long, bar_type>();  // NOLINT
-  StaticAssertTypeEq<char, baz_type>();
-  return arg == 0;
-}
-
-TEST(MatcherPnMacroTest, CanReferenceParamTypes) {
-  EXPECT_THAT(0, ParamTypesAreIntLongAndChar(10, 20L, 'a'));
-}
-
-// Tests that a MATCHER_Pn matcher can be explicitly instantiated with
-// reference parameter types.
-
-MATCHER_P2(ReferencesAnyOf, variable1, variable2, "") {
-  return &arg == &variable1 || &arg == &variable2;
-}
-
-TEST(MatcherPnMacroTest, WorksWhenExplicitlyInstantiatedWithReferences) {
-  UncopyableFoo foo1('1'), foo2('2'), foo3('3');
-  const Matcher<const UncopyableFoo&> m =
-      ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2);
-
-  EXPECT_TRUE(m.Matches(foo1));
-  EXPECT_TRUE(m.Matches(foo2));
-  EXPECT_FALSE(m.Matches(foo3));
-}
-
-TEST(MatcherPnMacroTest,
-     GeneratesCorretDescriptionWhenExplicitlyInstantiatedWithReferences) {
-  UncopyableFoo foo1('1'), foo2('2');
-  const Matcher<const UncopyableFoo&> m =
-      ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2);
-
-  // We don't want the addresses of the parameters printed, as most
-  // likely they will just annoy the user.  If the addresses are
-  // interesting, the user should consider passing the parameters by
-  // pointers instead.
-  EXPECT_EQ("references any of (1-byte object <31>, 1-byte object <32>)",
-            Describe(m));
-}
-
-// Tests that a simple MATCHER_P2() definition works.
-
-MATCHER_P2(IsNotInClosedRange, low, hi, "") { return arg < low || arg > hi; }
-
-TEST(MatcherPnMacroTest, Works) {
-  const Matcher<const long&> m = IsNotInClosedRange(10, 20);  // NOLINT
-  EXPECT_TRUE(m.Matches(36L));
-  EXPECT_FALSE(m.Matches(15L));
-
-  EXPECT_EQ("is not in closed range (10, 20)", Describe(m));
-  EXPECT_EQ("not (is not in closed range (10, 20))", DescribeNegation(m));
-  EXPECT_EQ("", Explain(m, 36L));
-  EXPECT_EQ("", Explain(m, 15L));
-}
-
-// Tests that MATCHER*() definitions can be overloaded on the number
-// of parameters; also tests MATCHER_Pn() where n >= 3.
-
-MATCHER(EqualsSumOf, "") { return arg == 0; }
-MATCHER_P(EqualsSumOf, a, "") { return arg == a; }
-MATCHER_P2(EqualsSumOf, a, b, "") { return arg == a + b; }
-MATCHER_P3(EqualsSumOf, a, b, c, "") { return arg == a + b + c; }
-MATCHER_P4(EqualsSumOf, a, b, c, d, "") { return arg == a + b + c + d; }
-MATCHER_P5(EqualsSumOf, a, b, c, d, e, "") { return arg == a + b + c + d + e; }
-MATCHER_P6(EqualsSumOf, a, b, c, d, e, f, "") {
-  return arg == a + b + c + d + e + f;
-}
-MATCHER_P7(EqualsSumOf, a, b, c, d, e, f, g, "") {
-  return arg == a + b + c + d + e + f + g;
-}
-MATCHER_P8(EqualsSumOf, a, b, c, d, e, f, g, h, "") {
-  return arg == a + b + c + d + e + f + g + h;
-}
-MATCHER_P9(EqualsSumOf, a, b, c, d, e, f, g, h, i, "") {
-  return arg == a + b + c + d + e + f + g + h + i;
-}
-MATCHER_P10(EqualsSumOf, a, b, c, d, e, f, g, h, i, j, "") {
-  return arg == a + b + c + d + e + f + g + h + i + j;
-}
-
-TEST(MatcherPnMacroTest, CanBeOverloadedOnNumberOfParameters) {
-  EXPECT_THAT(0, EqualsSumOf());
-  EXPECT_THAT(1, EqualsSumOf(1));
-  EXPECT_THAT(12, EqualsSumOf(10, 2));
-  EXPECT_THAT(123, EqualsSumOf(100, 20, 3));
-  EXPECT_THAT(1234, EqualsSumOf(1000, 200, 30, 4));
-  EXPECT_THAT(12345, EqualsSumOf(10000, 2000, 300, 40, 5));
-  EXPECT_THAT("abcdef",
-              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f'));
-  EXPECT_THAT("abcdefg",
-              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g'));
-  EXPECT_THAT("abcdefgh",
-              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
-                          "h"));
-  EXPECT_THAT("abcdefghi",
-              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
-                          "h", 'i'));
-  EXPECT_THAT("abcdefghij",
-              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
-                          "h", 'i', ::std::string("j")));
-
-  EXPECT_THAT(1, Not(EqualsSumOf()));
-  EXPECT_THAT(-1, Not(EqualsSumOf(1)));
-  EXPECT_THAT(-12, Not(EqualsSumOf(10, 2)));
-  EXPECT_THAT(-123, Not(EqualsSumOf(100, 20, 3)));
-  EXPECT_THAT(-1234, Not(EqualsSumOf(1000, 200, 30, 4)));
-  EXPECT_THAT(-12345, Not(EqualsSumOf(10000, 2000, 300, 40, 5)));
-  EXPECT_THAT("abcdef ",
-              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f')));
-  EXPECT_THAT("abcdefg ",
-              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f',
-                              'g')));
-  EXPECT_THAT("abcdefgh ",
-              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
-                              "h")));
-  EXPECT_THAT("abcdefghi ",
-              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
-                              "h", 'i')));
-  EXPECT_THAT("abcdefghij ",
-              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
-                              "h", 'i', ::std::string("j"))));
-}
-
-// Tests that a MATCHER_Pn() definition can be instantiated with any
-// compatible parameter types.
-TEST(MatcherPnMacroTest, WorksForDifferentParameterTypes) {
-  EXPECT_THAT(123, EqualsSumOf(100L, 20, static_cast<char>(3)));
-  EXPECT_THAT("abcd", EqualsSumOf(::std::string("a"), "b", 'c', "d"));
-
-  EXPECT_THAT(124, Not(EqualsSumOf(100L, 20, static_cast<char>(3))));
-  EXPECT_THAT("abcde", Not(EqualsSumOf(::std::string("a"), "b", 'c', "d")));
-}
-
-// Tests that the matcher body can promote the parameter types.
-
-MATCHER_P2(EqConcat, prefix, suffix, "") {
-  // The following lines promote the two parameters to desired types.
-  std::string prefix_str(prefix);
-  char suffix_char = static_cast<char>(suffix);
-  return arg == prefix_str + suffix_char;
-}
-
-TEST(MatcherPnMacroTest, SimpleTypePromotion) {
-  Matcher<std::string> no_promo =
-      EqConcat(std::string("foo"), 't');
-  Matcher<const std::string&> promo =
-      EqConcat("foo", static_cast<int>('t'));
-  EXPECT_FALSE(no_promo.Matches("fool"));
-  EXPECT_FALSE(promo.Matches("fool"));
-  EXPECT_TRUE(no_promo.Matches("foot"));
-  EXPECT_TRUE(promo.Matches("foot"));
-}
-
-// Verifies the type of a MATCHER*.
-
-TEST(MatcherPnMacroTest, TypesAreCorrect) {
-  // EqualsSumOf() must be assignable to a EqualsSumOfMatcher variable.
-  EqualsSumOfMatcher a0 = EqualsSumOf();
-
-  // EqualsSumOf(1) must be assignable to a EqualsSumOfMatcherP variable.
-  EqualsSumOfMatcherP<int> a1 = EqualsSumOf(1);
-
-  // EqualsSumOf(p1, ..., pk) must be assignable to a EqualsSumOfMatcherPk
-  // variable, and so on.
-  EqualsSumOfMatcherP2<int, char> a2 = EqualsSumOf(1, '2');
-  EqualsSumOfMatcherP3<int, int, char> a3 = EqualsSumOf(1, 2, '3');
-  EqualsSumOfMatcherP4<int, int, int, char> a4 = EqualsSumOf(1, 2, 3, '4');
-  EqualsSumOfMatcherP5<int, int, int, int, char> a5 =
-      EqualsSumOf(1, 2, 3, 4, '5');
-  EqualsSumOfMatcherP6<int, int, int, int, int, char> a6 =
-      EqualsSumOf(1, 2, 3, 4, 5, '6');
-  EqualsSumOfMatcherP7<int, int, int, int, int, int, char> a7 =
-      EqualsSumOf(1, 2, 3, 4, 5, 6, '7');
-  EqualsSumOfMatcherP8<int, int, int, int, int, int, int, char> a8 =
-      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, '8');
-  EqualsSumOfMatcherP9<int, int, int, int, int, int, int, int, char> a9 =
-      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, '9');
-  EqualsSumOfMatcherP10<int, int, int, int, int, int, int, int, int, char> a10 =
-      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, 9, '0');
-
-  // Avoid "unused variable" warnings.
-  (void)a0;
-  (void)a1;
-  (void)a2;
-  (void)a3;
-  (void)a4;
-  (void)a5;
-  (void)a6;
-  (void)a7;
-  (void)a8;
-  (void)a9;
-  (void)a10;
-}
-
-// Tests that matcher-typed parameters can be used in Value() inside a
-// MATCHER_Pn definition.
-
-// Succeeds if arg matches exactly 2 of the 3 matchers.
-MATCHER_P3(TwoOf, m1, m2, m3, "") {
-  const int count = static_cast<int>(Value(arg, m1))
-      + static_cast<int>(Value(arg, m2)) + static_cast<int>(Value(arg, m3));
-  return count == 2;
-}
-
-TEST(MatcherPnMacroTest, CanUseMatcherTypedParameterInValue) {
-  EXPECT_THAT(42, TwoOf(Gt(0), Lt(50), Eq(10)));
-  EXPECT_THAT(0, Not(TwoOf(Gt(-1), Lt(1), Eq(0))));
-}
-
-// Tests Contains().
-
-TEST(ContainsTest, ListMatchesWhenElementIsInContainer) {
-  list<int> some_list;
-  some_list.push_back(3);
-  some_list.push_back(1);
-  some_list.push_back(2);
-  EXPECT_THAT(some_list, Contains(1));
-  EXPECT_THAT(some_list, Contains(Gt(2.5)));
-  EXPECT_THAT(some_list, Contains(Eq(2.0f)));
-
-  list<string> another_list;
-  another_list.push_back("fee");
-  another_list.push_back("fie");
-  another_list.push_back("foe");
-  another_list.push_back("fum");
-  EXPECT_THAT(another_list, Contains(string("fee")));
-}
-
-TEST(ContainsTest, ListDoesNotMatchWhenElementIsNotInContainer) {
-  list<int> some_list;
-  some_list.push_back(3);
-  some_list.push_back(1);
-  EXPECT_THAT(some_list, Not(Contains(4)));
-}
-
-TEST(ContainsTest, SetMatchesWhenElementIsInContainer) {
-  set<int> some_set;
-  some_set.insert(3);
-  some_set.insert(1);
-  some_set.insert(2);
-  EXPECT_THAT(some_set, Contains(Eq(1.0)));
-  EXPECT_THAT(some_set, Contains(Eq(3.0f)));
-  EXPECT_THAT(some_set, Contains(2));
-
-  set<const char*> another_set;
-  another_set.insert("fee");
-  another_set.insert("fie");
-  another_set.insert("foe");
-  another_set.insert("fum");
-  EXPECT_THAT(another_set, Contains(Eq(string("fum"))));
-}
-
-TEST(ContainsTest, SetDoesNotMatchWhenElementIsNotInContainer) {
-  set<int> some_set;
-  some_set.insert(3);
-  some_set.insert(1);
-  EXPECT_THAT(some_set, Not(Contains(4)));
-
-  set<const char*> c_string_set;
-  c_string_set.insert("hello");
-  EXPECT_THAT(c_string_set, Not(Contains(string("hello").c_str())));
-}
-
-TEST(ContainsTest, ExplainsMatchResultCorrectly) {
-  const int a[2] = { 1, 2 };
-  Matcher<const int (&)[2]> m = Contains(2);
-  EXPECT_EQ("whose element #1 matches", Explain(m, a));
-
-  m = Contains(3);
-  EXPECT_EQ("", Explain(m, a));
-
-  m = Contains(GreaterThan(0));
-  EXPECT_EQ("whose element #0 matches, which is 1 more than 0", Explain(m, a));
-
-  m = Contains(GreaterThan(10));
-  EXPECT_EQ("", Explain(m, a));
-}
-
-TEST(ContainsTest, DescribesItselfCorrectly) {
-  Matcher<vector<int> > m = Contains(1);
-  EXPECT_EQ("contains at least one element that is equal to 1", Describe(m));
-
-  Matcher<vector<int> > m2 = Not(m);
-  EXPECT_EQ("doesn't contain any element that is equal to 1", Describe(m2));
-}
-
-TEST(ContainsTest, MapMatchesWhenElementIsInContainer) {
-  map<const char*, int> my_map;
-  const char* bar = "a string";
-  my_map[bar] = 2;
-  EXPECT_THAT(my_map, Contains(pair<const char* const, int>(bar, 2)));
-
-  map<string, int> another_map;
-  another_map["fee"] = 1;
-  another_map["fie"] = 2;
-  another_map["foe"] = 3;
-  another_map["fum"] = 4;
-  EXPECT_THAT(another_map, Contains(pair<const string, int>(string("fee"), 1)));
-  EXPECT_THAT(another_map, Contains(pair<const string, int>("fie", 2)));
-}
-
-TEST(ContainsTest, MapDoesNotMatchWhenElementIsNotInContainer) {
-  map<int, int> some_map;
-  some_map[1] = 11;
-  some_map[2] = 22;
-  EXPECT_THAT(some_map, Not(Contains(pair<const int, int>(2, 23))));
-}
-
-TEST(ContainsTest, ArrayMatchesWhenElementIsInContainer) {
-  const char* string_array[] = { "fee", "fie", "foe", "fum" };
-  EXPECT_THAT(string_array, Contains(Eq(string("fum"))));
-}
-
-TEST(ContainsTest, ArrayDoesNotMatchWhenElementIsNotInContainer) {
-  int int_array[] = { 1, 2, 3, 4 };
-  EXPECT_THAT(int_array, Not(Contains(5)));
-}
-
-TEST(ContainsTest, AcceptsMatcher) {
-  const int a[] = { 1, 2, 3 };
-  EXPECT_THAT(a, Contains(Gt(2)));
-  EXPECT_THAT(a, Not(Contains(Gt(4))));
-}
-
-TEST(ContainsTest, WorksForNativeArrayAsTuple) {
-  const int a[] = { 1, 2 };
-  const int* const pointer = a;
-  EXPECT_THAT(make_tuple(pointer, 2), Contains(1));
-  EXPECT_THAT(make_tuple(pointer, 2), Not(Contains(Gt(3))));
-}
-
-TEST(ContainsTest, WorksForTwoDimensionalNativeArray) {
-  int a[][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
-  EXPECT_THAT(a, Contains(ElementsAre(4, 5, 6)));
-  EXPECT_THAT(a, Contains(Contains(5)));
-  EXPECT_THAT(a, Not(Contains(ElementsAre(3, 4, 5))));
-  EXPECT_THAT(a, Contains(Not(Contains(5))));
-}
-
-TEST(AllOfTest, HugeMatcher) {
-  // Verify that using AllOf with many arguments doesn't cause
-  // the compiler to exceed template instantiation depth limit.
-  EXPECT_THAT(0, testing::AllOf(_, _, _, _, _, _, _, _, _,
-                                testing::AllOf(_, _, _, _, _, _, _, _, _, _)));
-}
-
-TEST(AnyOfTest, HugeMatcher) {
-  // Verify that using AnyOf with many arguments doesn't cause
-  // the compiler to exceed template instantiation depth limit.
-  EXPECT_THAT(0, testing::AnyOf(_, _, _, _, _, _, _, _, _,
-                                testing::AnyOf(_, _, _, _, _, _, _, _, _, _)));
-}
-
-namespace adl_test {
-
-// Verifies that the implementation of ::testing::AllOf and ::testing::AnyOf
-// don't issue unqualified recursive calls.  If they do, the argument dependent
-// name lookup will cause AllOf/AnyOf in the 'adl_test' namespace to be found
-// as a candidate and the compilation will break due to an ambiguous overload.
-
-// The matcher must be in the same namespace as AllOf/AnyOf to make argument
-// dependent lookup find those.
-MATCHER(M, "") { return true; }
-
-template <typename T1, typename T2>
-bool AllOf(const T1& t1, const T2& t2) { return true; }
-
-TEST(AllOfTest, DoesNotCallAllOfUnqualified) {
-  EXPECT_THAT(42, testing::AllOf(
-      M(), M(), M(), M(), M(), M(), M(), M(), M(), M()));
-}
-
-template <typename T1, typename T2> bool
-AnyOf(const T1& t1, const T2& t2) { return true; }
-
-TEST(AnyOfTest, DoesNotCallAnyOfUnqualified) {
-  EXPECT_THAT(42, testing::AnyOf(
-      M(), M(), M(), M(), M(), M(), M(), M(), M(), M()));
-}
-
-}  // namespace adl_test
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-}  // namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-internal-utils_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-internal-utils_test.cc
deleted file mode 100644
index 9d5ec609..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-internal-utils_test.cc
+++ /dev/null
@@ -1,699 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests the internal utilities.
-
-#include "gmock/internal/gmock-internal-utils.h"
-#include <stdlib.h>
-#include <map>
-#include <memory>
-#include <string>
-#include <sstream>
-#include <vector>
-#include "gmock/gmock.h"
-#include "gmock/internal/gmock-port.h"
-#include "gtest/gtest.h"
-#include "gtest/gtest-spi.h"
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick is to
-// prevent a user from accidentally including gtest-internal-inl.h in
-// his code.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-#if GTEST_OS_CYGWIN
-# include <sys/types.h>  // For ssize_t. NOLINT
-#endif
-
-class ProtocolMessage;
-
-namespace proto2 {
-class Message;
-}  // namespace proto2
-
-namespace testing {
-namespace internal {
-
-namespace {
-
-TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) {
-  EXPECT_EQ("", ConvertIdentifierNameToWords(""));
-  EXPECT_EQ("", ConvertIdentifierNameToWords("_"));
-  EXPECT_EQ("", ConvertIdentifierNameToWords("__"));
-}
-
-TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsDigits) {
-  EXPECT_EQ("1", ConvertIdentifierNameToWords("_1"));
-  EXPECT_EQ("2", ConvertIdentifierNameToWords("2_"));
-  EXPECT_EQ("34", ConvertIdentifierNameToWords("_34_"));
-  EXPECT_EQ("34 56", ConvertIdentifierNameToWords("_34_56"));
-}
-
-TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsCamelCaseWords) {
-  EXPECT_EQ("a big word", ConvertIdentifierNameToWords("ABigWord"));
-  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("FooBar"));
-  EXPECT_EQ("foo", ConvertIdentifierNameToWords("Foo_"));
-  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_Foo_Bar_"));
-  EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_Foo__And_Bar"));
-}
-
-TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContains_SeparatedWords) {
-  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("foo_bar"));
-  EXPECT_EQ("foo", ConvertIdentifierNameToWords("_foo_"));
-  EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_foo_bar_"));
-  EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_foo__and_bar"));
-}
-
-TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) {
-  EXPECT_EQ("foo bar 123", ConvertIdentifierNameToWords("Foo_bar123"));
-  EXPECT_EQ("chapter 11 section 1",
-            ConvertIdentifierNameToWords("_Chapter11Section_1_"));
-}
-
-TEST(PointeeOfTest, WorksForSmartPointers) {
-  CompileAssertTypesEqual<const char,
-      PointeeOf<internal::linked_ptr<const char> >::type>();
-#if GTEST_HAS_STD_UNIQUE_PTR_
-  CompileAssertTypesEqual<int, PointeeOf<std::unique_ptr<int> >::type>();
-#endif  // GTEST_HAS_STD_UNIQUE_PTR_
-#if GTEST_HAS_STD_SHARED_PTR_
-  CompileAssertTypesEqual<std::string,
-                          PointeeOf<std::shared_ptr<std::string> >::type>();
-#endif  // GTEST_HAS_STD_SHARED_PTR_
-}
-
-TEST(PointeeOfTest, WorksForRawPointers) {
-  CompileAssertTypesEqual<int, PointeeOf<int*>::type>();
-  CompileAssertTypesEqual<const char, PointeeOf<const char*>::type>();
-  CompileAssertTypesEqual<void, PointeeOf<void*>::type>();
-}
-
-TEST(GetRawPointerTest, WorksForSmartPointers) {
-#if GTEST_HAS_STD_UNIQUE_PTR_
-  const char* const raw_p1 = new const char('a');  // NOLINT
-  const std::unique_ptr<const char> p1(raw_p1);
-  EXPECT_EQ(raw_p1, GetRawPointer(p1));
-#endif  // GTEST_HAS_STD_UNIQUE_PTR_
-#if GTEST_HAS_STD_SHARED_PTR_
-  double* const raw_p2 = new double(2.5);  // NOLINT
-  const std::shared_ptr<double> p2(raw_p2);
-  EXPECT_EQ(raw_p2, GetRawPointer(p2));
-#endif  // GTEST_HAS_STD_SHARED_PTR_
-
-  const char* const raw_p4 = new const char('a');  // NOLINT
-  const internal::linked_ptr<const char> p4(raw_p4);
-  EXPECT_EQ(raw_p4, GetRawPointer(p4));
-}
-
-TEST(GetRawPointerTest, WorksForRawPointers) {
-  int* p = NULL;
-  // Don't use EXPECT_EQ as no NULL-testing magic on Symbian.
-  EXPECT_TRUE(NULL == GetRawPointer(p));
-  int n = 1;
-  EXPECT_EQ(&n, GetRawPointer(&n));
-}
-
-// Tests KindOf<T>.
-
-class Base {};
-class Derived : public Base {};
-
-TEST(KindOfTest, Bool) {
-  EXPECT_EQ(kBool, GMOCK_KIND_OF_(bool));  // NOLINT
-}
-
-TEST(KindOfTest, Integer) {
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(char));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(signed char));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned char));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(short));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned short));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(int));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned int));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(Int64));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(UInt64));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t));  // NOLINT
-#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN
-  // ssize_t is not defined on Windows and possibly some other OSes.
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t));  // NOLINT
-#endif
-}
-
-TEST(KindOfTest, FloatingPoint) {
-  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(float));  // NOLINT
-  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(double));  // NOLINT
-  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(long double));  // NOLINT
-}
-
-TEST(KindOfTest, Other) {
-  EXPECT_EQ(kOther, GMOCK_KIND_OF_(void*));  // NOLINT
-  EXPECT_EQ(kOther, GMOCK_KIND_OF_(char**));  // NOLINT
-  EXPECT_EQ(kOther, GMOCK_KIND_OF_(Base));  // NOLINT
-}
-
-// Tests LosslessArithmeticConvertible<T, U>.
-
-TEST(LosslessArithmeticConvertibleTest, BoolToBool) {
-  EXPECT_TRUE((LosslessArithmeticConvertible<bool, bool>::value));
-}
-
-TEST(LosslessArithmeticConvertibleTest, BoolToInteger) {
-  EXPECT_TRUE((LosslessArithmeticConvertible<bool, char>::value));
-  EXPECT_TRUE((LosslessArithmeticConvertible<bool, int>::value));
-  EXPECT_TRUE(
-      (LosslessArithmeticConvertible<bool, unsigned long>::value));  // NOLINT
-}
-
-TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) {
-  EXPECT_TRUE((LosslessArithmeticConvertible<bool, float>::value));
-  EXPECT_TRUE((LosslessArithmeticConvertible<bool, double>::value));
-}
-
-TEST(LosslessArithmeticConvertibleTest, IntegerToBool) {
-  EXPECT_FALSE((LosslessArithmeticConvertible<unsigned char, bool>::value));
-  EXPECT_FALSE((LosslessArithmeticConvertible<int, bool>::value));
-}
-
-TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) {
-  // Unsigned => larger signed is fine.
-  EXPECT_TRUE((LosslessArithmeticConvertible<unsigned char, int>::value));
-
-  // Unsigned => larger unsigned is fine.
-  EXPECT_TRUE(
-      (LosslessArithmeticConvertible<unsigned short, UInt64>::value)); // NOLINT
-
-  // Signed => unsigned is not fine.
-  EXPECT_FALSE((LosslessArithmeticConvertible<short, UInt64>::value)); // NOLINT
-  EXPECT_FALSE((LosslessArithmeticConvertible<
-      signed char, unsigned int>::value));  // NOLINT
-
-  // Same size and same signedness: fine too.
-  EXPECT_TRUE((LosslessArithmeticConvertible<
-               unsigned char, unsigned char>::value));
-  EXPECT_TRUE((LosslessArithmeticConvertible<int, int>::value));
-  EXPECT_TRUE((LosslessArithmeticConvertible<wchar_t, wchar_t>::value));
-  EXPECT_TRUE((LosslessArithmeticConvertible<
-               unsigned long, unsigned long>::value));  // NOLINT
-
-  // Same size, different signedness: not fine.
-  EXPECT_FALSE((LosslessArithmeticConvertible<
-                unsigned char, signed char>::value));
-  EXPECT_FALSE((LosslessArithmeticConvertible<int, unsigned int>::value));
-  EXPECT_FALSE((LosslessArithmeticConvertible<UInt64, Int64>::value));
-
-  // Larger size => smaller size is not fine.
-  EXPECT_FALSE((LosslessArithmeticConvertible<long, char>::value));  // NOLINT
-  EXPECT_FALSE((LosslessArithmeticConvertible<int, signed char>::value));
-  EXPECT_FALSE((LosslessArithmeticConvertible<Int64, unsigned int>::value));
-}
-
-TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) {
-  // Integers cannot be losslessly converted to floating-points, as
-  // the format of the latter is implementation-defined.
-  EXPECT_FALSE((LosslessArithmeticConvertible<char, float>::value));
-  EXPECT_FALSE((LosslessArithmeticConvertible<int, double>::value));
-  EXPECT_FALSE((LosslessArithmeticConvertible<
-                short, long double>::value));  // NOLINT
-}
-
-TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) {
-  EXPECT_FALSE((LosslessArithmeticConvertible<float, bool>::value));
-  EXPECT_FALSE((LosslessArithmeticConvertible<double, bool>::value));
-}
-
-TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) {
-  EXPECT_FALSE((LosslessArithmeticConvertible<float, long>::value));  // NOLINT
-  EXPECT_FALSE((LosslessArithmeticConvertible<double, Int64>::value));
-  EXPECT_FALSE((LosslessArithmeticConvertible<long double, int>::value));
-}
-
-TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) {
-  // Smaller size => larger size is fine.
-  EXPECT_TRUE((LosslessArithmeticConvertible<float, double>::value));
-  EXPECT_TRUE((LosslessArithmeticConvertible<float, long double>::value));
-  EXPECT_TRUE((LosslessArithmeticConvertible<double, long double>::value));
-
-  // Same size: fine.
-  EXPECT_TRUE((LosslessArithmeticConvertible<float, float>::value));
-  EXPECT_TRUE((LosslessArithmeticConvertible<double, double>::value));
-
-  // Larger size => smaller size is not fine.
-  EXPECT_FALSE((LosslessArithmeticConvertible<double, float>::value));
-  GTEST_INTENTIONAL_CONST_COND_PUSH_()
-  if (sizeof(double) == sizeof(long double)) {  // NOLINT
-  GTEST_INTENTIONAL_CONST_COND_POP_()
-    // In some implementations (e.g. MSVC), double and long double
-    // have the same size.
-    EXPECT_TRUE((LosslessArithmeticConvertible<long double, double>::value));
-  } else {
-    EXPECT_FALSE((LosslessArithmeticConvertible<long double, double>::value));
-  }
-}
-
-// Tests the TupleMatches() template function.
-
-TEST(TupleMatchesTest, WorksForSize0) {
-  tuple<> matchers;
-  tuple<> values;
-
-  EXPECT_TRUE(TupleMatches(matchers, values));
-}
-
-TEST(TupleMatchesTest, WorksForSize1) {
-  tuple<Matcher<int> > matchers(Eq(1));
-  tuple<int> values1(1),
-      values2(2);
-
-  EXPECT_TRUE(TupleMatches(matchers, values1));
-  EXPECT_FALSE(TupleMatches(matchers, values2));
-}
-
-TEST(TupleMatchesTest, WorksForSize2) {
-  tuple<Matcher<int>, Matcher<char> > matchers(Eq(1), Eq('a'));
-  tuple<int, char> values1(1, 'a'),
-      values2(1, 'b'),
-      values3(2, 'a'),
-      values4(2, 'b');
-
-  EXPECT_TRUE(TupleMatches(matchers, values1));
-  EXPECT_FALSE(TupleMatches(matchers, values2));
-  EXPECT_FALSE(TupleMatches(matchers, values3));
-  EXPECT_FALSE(TupleMatches(matchers, values4));
-}
-
-TEST(TupleMatchesTest, WorksForSize5) {
-  tuple<Matcher<int>, Matcher<char>, Matcher<bool>, Matcher<long>,  // NOLINT
-      Matcher<string> >
-      matchers(Eq(1), Eq('a'), Eq(true), Eq(2L), Eq("hi"));
-  tuple<int, char, bool, long, string>  // NOLINT
-      values1(1, 'a', true, 2L, "hi"),
-      values2(1, 'a', true, 2L, "hello"),
-      values3(2, 'a', true, 2L, "hi");
-
-  EXPECT_TRUE(TupleMatches(matchers, values1));
-  EXPECT_FALSE(TupleMatches(matchers, values2));
-  EXPECT_FALSE(TupleMatches(matchers, values3));
-}
-
-// Tests that Assert(true, ...) succeeds.
-TEST(AssertTest, SucceedsOnTrue) {
-  Assert(true, __FILE__, __LINE__, "This should succeed.");
-  Assert(true, __FILE__, __LINE__);  // This should succeed too.
-}
-
-// Tests that Assert(false, ...) generates a fatal failure.
-TEST(AssertTest, FailsFatallyOnFalse) {
-  EXPECT_DEATH_IF_SUPPORTED({
-    Assert(false, __FILE__, __LINE__, "This should fail.");
-  }, "");
-
-  EXPECT_DEATH_IF_SUPPORTED({
-    Assert(false, __FILE__, __LINE__);
-  }, "");
-}
-
-// Tests that Expect(true, ...) succeeds.
-TEST(ExpectTest, SucceedsOnTrue) {
-  Expect(true, __FILE__, __LINE__, "This should succeed.");
-  Expect(true, __FILE__, __LINE__);  // This should succeed too.
-}
-
-// Tests that Expect(false, ...) generates a non-fatal failure.
-TEST(ExpectTest, FailsNonfatallyOnFalse) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Expect(false, __FILE__, __LINE__, "This should fail.");
-  }, "This should fail");
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Expect(false, __FILE__, __LINE__);
-  }, "Expectation failed");
-}
-
-// Tests LogIsVisible().
-
-class LogIsVisibleTest : public ::testing::Test {
- protected:
-  virtual void SetUp() {
-    original_verbose_ = GMOCK_FLAG(verbose);
-  }
-
-  virtual void TearDown() { GMOCK_FLAG(verbose) = original_verbose_; }
-
-  string original_verbose_;
-};
-
-TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) {
-  GMOCK_FLAG(verbose) = kInfoVerbosity;
-  EXPECT_TRUE(LogIsVisible(kInfo));
-  EXPECT_TRUE(LogIsVisible(kWarning));
-}
-
-TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) {
-  GMOCK_FLAG(verbose) = kErrorVerbosity;
-  EXPECT_FALSE(LogIsVisible(kInfo));
-  EXPECT_FALSE(LogIsVisible(kWarning));
-}
-
-TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
-  GMOCK_FLAG(verbose) = kWarningVerbosity;
-  EXPECT_FALSE(LogIsVisible(kInfo));
-  EXPECT_TRUE(LogIsVisible(kWarning));
-}
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Tests the Log() function.
-
-// Verifies that Log() behaves correctly for the given verbosity level
-// and log severity.
-void TestLogWithSeverity(const string& verbosity, LogSeverity severity,
-                         bool should_print) {
-  const string old_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = verbosity;
-  CaptureStdout();
-  Log(severity, "Test log.\n", 0);
-  if (should_print) {
-    EXPECT_THAT(GetCapturedStdout().c_str(),
-                ContainsRegex(
-                    severity == kWarning ?
-                    "^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n" :
-                    "^\nTest log\\.\nStack trace:\n"));
-  } else {
-    EXPECT_STREQ("", GetCapturedStdout().c_str());
-  }
-  GMOCK_FLAG(verbose) = old_flag;
-}
-
-// Tests that when the stack_frames_to_skip parameter is negative,
-// Log() doesn't include the stack trace in the output.
-TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) {
-  const string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = kInfoVerbosity;
-  CaptureStdout();
-  Log(kInfo, "Test log.\n", -1);
-  EXPECT_STREQ("\nTest log.\n", GetCapturedStdout().c_str());
-  GMOCK_FLAG(verbose) = saved_flag;
-}
-
-struct MockStackTraceGetter : testing::internal::OsStackTraceGetterInterface {
-  virtual string CurrentStackTrace(int max_depth, int skip_count) {
-    return (testing::Message() << max_depth << "::" << skip_count << "\n")
-        .GetString();
-  }
-  virtual void UponLeavingGTest() {}
-};
-
-// Tests that in opt mode, a positive stack_frames_to_skip argument is
-// treated as 0.
-TEST(LogTest, NoSkippingStackFrameInOptMode) {
-  MockStackTraceGetter* mock_os_stack_trace_getter = new MockStackTraceGetter;
-  GetUnitTestImpl()->set_os_stack_trace_getter(mock_os_stack_trace_getter);
-
-  CaptureStdout();
-  Log(kWarning, "Test log.\n", 100);
-  const string log = GetCapturedStdout();
-
-  string expected_trace =
-      (testing::Message() << GTEST_FLAG(stack_trace_depth) << "::").GetString();
-  string expected_message =
-      "\nGMOCK WARNING:\n"
-      "Test log.\n"
-      "Stack trace:\n" +
-      expected_trace;
-  EXPECT_THAT(log, HasSubstr(expected_message));
-  int skip_count = atoi(log.substr(expected_message.size()).c_str());
-
-# if defined(NDEBUG)
-  // In opt mode, no stack frame should be skipped.
-  const int expected_skip_count = 0;
-# else
-  // In dbg mode, the stack frames should be skipped.
-  const int expected_skip_count = 100;
-# endif
-
-  // Note that each inner implementation layer will +1 the number to remove
-  // itself from the trace. This means that the value is a little higher than
-  // expected, but close enough.
-  EXPECT_THAT(skip_count,
-              AllOf(Ge(expected_skip_count), Le(expected_skip_count + 10)));
-
-  // Restores the default OS stack trace getter.
-  GetUnitTestImpl()->set_os_stack_trace_getter(NULL);
-}
-
-// Tests that all logs are printed when the value of the
-// --gmock_verbose flag is "info".
-TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) {
-  TestLogWithSeverity(kInfoVerbosity, kInfo, true);
-  TestLogWithSeverity(kInfoVerbosity, kWarning, true);
-}
-
-// Tests that only warnings are printed when the value of the
-// --gmock_verbose flag is "warning".
-TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsWarning) {
-  TestLogWithSeverity(kWarningVerbosity, kInfo, false);
-  TestLogWithSeverity(kWarningVerbosity, kWarning, true);
-}
-
-// Tests that no logs are printed when the value of the
-// --gmock_verbose flag is "error".
-TEST(LogTest, NoLogsArePrintedWhenVerbosityIsError) {
-  TestLogWithSeverity(kErrorVerbosity, kInfo, false);
-  TestLogWithSeverity(kErrorVerbosity, kWarning, false);
-}
-
-// Tests that only warnings are printed when the value of the
-// --gmock_verbose flag is invalid.
-TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) {
-  TestLogWithSeverity("invalid", kInfo, false);
-  TestLogWithSeverity("invalid", kWarning, true);
-}
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-TEST(TypeTraitsTest, true_type) {
-  EXPECT_TRUE(true_type::value);
-}
-
-TEST(TypeTraitsTest, false_type) {
-  EXPECT_FALSE(false_type::value);
-}
-
-TEST(TypeTraitsTest, is_reference) {
-  EXPECT_FALSE(is_reference<int>::value);
-  EXPECT_FALSE(is_reference<char*>::value);
-  EXPECT_TRUE(is_reference<const int&>::value);
-}
-
-TEST(TypeTraitsTest, is_pointer) {
-  EXPECT_FALSE(is_pointer<int>::value);
-  EXPECT_FALSE(is_pointer<char&>::value);
-  EXPECT_TRUE(is_pointer<const int*>::value);
-}
-
-TEST(TypeTraitsTest, type_equals) {
-  EXPECT_FALSE((type_equals<int, const int>::value));
-  EXPECT_FALSE((type_equals<int, int&>::value));
-  EXPECT_FALSE((type_equals<int, double>::value));
-  EXPECT_TRUE((type_equals<char, char>::value));
-}
-
-TEST(TypeTraitsTest, remove_reference) {
-  EXPECT_TRUE((type_equals<char, remove_reference<char&>::type>::value));
-  EXPECT_TRUE((type_equals<const int,
-               remove_reference<const int&>::type>::value));
-  EXPECT_TRUE((type_equals<int, remove_reference<int>::type>::value));
-  EXPECT_TRUE((type_equals<double*, remove_reference<double*>::type>::value));
-}
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Verifies that Log() behaves correctly for the given verbosity level
-// and log severity.
-std::string GrabOutput(void(*logger)(), const char* verbosity) {
-  const string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = verbosity;
-  CaptureStdout();
-  logger();
-  GMOCK_FLAG(verbose) = saved_flag;
-  return GetCapturedStdout();
-}
-
-class DummyMock {
- public:
-  MOCK_METHOD0(TestMethod, void());
-  MOCK_METHOD1(TestMethodArg, void(int dummy));
-};
-
-void ExpectCallLogger() {
-  DummyMock mock;
-  EXPECT_CALL(mock, TestMethod());
-  mock.TestMethod();
-};
-
-// Verifies that EXPECT_CALL logs if the --gmock_verbose flag is set to "info".
-TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) {
-  EXPECT_THAT(std::string(GrabOutput(ExpectCallLogger, kInfoVerbosity)),
-              HasSubstr("EXPECT_CALL(mock, TestMethod())"));
-}
-
-// Verifies that EXPECT_CALL doesn't log
-// if the --gmock_verbose flag is set to "warning".
-TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) {
-  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kWarningVerbosity).c_str());
-}
-
-// Verifies that EXPECT_CALL doesn't log
-// if the --gmock_verbose flag is set to "error".
-TEST(ExpectCallTest,  DoesNotLogWhenVerbosityIsError) {
-  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str());
-}
-
-void OnCallLogger() {
-  DummyMock mock;
-  ON_CALL(mock, TestMethod());
-};
-
-// Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info".
-TEST(OnCallTest, LogsWhenVerbosityIsInfo) {
-  EXPECT_THAT(std::string(GrabOutput(OnCallLogger, kInfoVerbosity)),
-              HasSubstr("ON_CALL(mock, TestMethod())"));
-}
-
-// Verifies that ON_CALL doesn't log
-// if the --gmock_verbose flag is set to "warning".
-TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) {
-  EXPECT_STREQ("", GrabOutput(OnCallLogger, kWarningVerbosity).c_str());
-}
-
-// Verifies that ON_CALL doesn't log if
-// the --gmock_verbose flag is set to "error".
-TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {
-  EXPECT_STREQ("", GrabOutput(OnCallLogger, kErrorVerbosity).c_str());
-}
-
-void OnCallAnyArgumentLogger() {
-  DummyMock mock;
-  ON_CALL(mock, TestMethodArg(_));
-}
-
-// Verifies that ON_CALL prints provided _ argument.
-TEST(OnCallTest, LogsAnythingArgument) {
-  EXPECT_THAT(std::string(GrabOutput(OnCallAnyArgumentLogger, kInfoVerbosity)),
-              HasSubstr("ON_CALL(mock, TestMethodArg(_)"));
-}
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-// Tests StlContainerView.
-
-TEST(StlContainerViewTest, WorksForStlContainer) {
-  StaticAssertTypeEq<std::vector<int>,
-      StlContainerView<std::vector<int> >::type>();
-  StaticAssertTypeEq<const std::vector<double>&,
-      StlContainerView<std::vector<double> >::const_reference>();
-
-  typedef std::vector<char> Chars;
-  Chars v1;
-  const Chars& v2(StlContainerView<Chars>::ConstReference(v1));
-  EXPECT_EQ(&v1, &v2);
-
-  v1.push_back('a');
-  Chars v3 = StlContainerView<Chars>::Copy(v1);
-  EXPECT_THAT(v3, Eq(v3));
-}
-
-TEST(StlContainerViewTest, WorksForStaticNativeArray) {
-  StaticAssertTypeEq<NativeArray<int>,
-      StlContainerView<int[3]>::type>();
-  StaticAssertTypeEq<NativeArray<double>,
-      StlContainerView<const double[4]>::type>();
-  StaticAssertTypeEq<NativeArray<char[3]>,
-      StlContainerView<const char[2][3]>::type>();
-
-  StaticAssertTypeEq<const NativeArray<int>,
-      StlContainerView<int[2]>::const_reference>();
-
-  int a1[3] = { 0, 1, 2 };
-  NativeArray<int> a2 = StlContainerView<int[3]>::ConstReference(a1);
-  EXPECT_EQ(3U, a2.size());
-  EXPECT_EQ(a1, a2.begin());
-
-  const NativeArray<int> a3 = StlContainerView<int[3]>::Copy(a1);
-  ASSERT_EQ(3U, a3.size());
-  EXPECT_EQ(0, a3.begin()[0]);
-  EXPECT_EQ(1, a3.begin()[1]);
-  EXPECT_EQ(2, a3.begin()[2]);
-
-  // Makes sure a1 and a3 aren't aliases.
-  a1[0] = 3;
-  EXPECT_EQ(0, a3.begin()[0]);
-}
-
-TEST(StlContainerViewTest, WorksForDynamicNativeArray) {
-  StaticAssertTypeEq<NativeArray<int>,
-      StlContainerView<tuple<const int*, size_t> >::type>();
-  StaticAssertTypeEq<NativeArray<double>,
-      StlContainerView<tuple<linked_ptr<double>, int> >::type>();
-
-  StaticAssertTypeEq<const NativeArray<int>,
-      StlContainerView<tuple<const int*, int> >::const_reference>();
-
-  int a1[3] = { 0, 1, 2 };
-  const int* const p1 = a1;
-  NativeArray<int> a2 = StlContainerView<tuple<const int*, int> >::
-      ConstReference(make_tuple(p1, 3));
-  EXPECT_EQ(3U, a2.size());
-  EXPECT_EQ(a1, a2.begin());
-
-  const NativeArray<int> a3 = StlContainerView<tuple<int*, size_t> >::
-      Copy(make_tuple(static_cast<int*>(a1), 3));
-  ASSERT_EQ(3U, a3.size());
-  EXPECT_EQ(0, a3.begin()[0]);
-  EXPECT_EQ(1, a3.begin()[1]);
-  EXPECT_EQ(2, a3.begin()[2]);
-
-  // Makes sure a1 and a3 aren't aliases.
-  a1[0] = 3;
-  EXPECT_EQ(0, a3.begin()[0]);
-}
-
-}  // namespace
-}  // namespace internal
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-matchers_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-matchers_test.cc
deleted file mode 100644
index 9f62c3d8..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-matchers_test.cc
+++ /dev/null
@@ -1,5652 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests some commonly used argument matchers.
-
-#include "gmock/gmock-matchers.h"
-#include "gmock/gmock-more-matchers.h"
-
-#include <string.h>
-#include <time.h>
-#include <deque>
-#include <functional>
-#include <iostream>
-#include <iterator>
-#include <limits>
-#include <list>
-#include <map>
-#include <set>
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "gtest/gtest-spi.h"
-
-#if GTEST_HAS_STD_FORWARD_LIST_
-# include <forward_list>  // NOLINT
-#endif
-
-namespace testing {
-
-namespace internal {
-GTEST_API_ string JoinAsTuple(const Strings& fields);
-}  // namespace internal
-
-namespace gmock_matchers_test {
-
-using std::greater;
-using std::less;
-using std::list;
-using std::make_pair;
-using std::map;
-using std::multimap;
-using std::multiset;
-using std::ostream;
-using std::pair;
-using std::set;
-using std::stringstream;
-using std::vector;
-using testing::A;
-using testing::AllArgs;
-using testing::AllOf;
-using testing::An;
-using testing::AnyOf;
-using testing::ByRef;
-using testing::ContainsRegex;
-using testing::DoubleEq;
-using testing::DoubleNear;
-using testing::EndsWith;
-using testing::Eq;
-using testing::ExplainMatchResult;
-using testing::Field;
-using testing::FloatEq;
-using testing::FloatNear;
-using testing::Ge;
-using testing::Gt;
-using testing::HasSubstr;
-using testing::IsEmpty;
-using testing::IsNull;
-using testing::Key;
-using testing::Le;
-using testing::Lt;
-using testing::MakeMatcher;
-using testing::MakePolymorphicMatcher;
-using testing::MatchResultListener;
-using testing::Matcher;
-using testing::MatcherCast;
-using testing::MatcherInterface;
-using testing::Matches;
-using testing::MatchesRegex;
-using testing::NanSensitiveDoubleEq;
-using testing::NanSensitiveDoubleNear;
-using testing::NanSensitiveFloatEq;
-using testing::NanSensitiveFloatNear;
-using testing::Ne;
-using testing::Not;
-using testing::NotNull;
-using testing::Pair;
-using testing::Pointee;
-using testing::Pointwise;
-using testing::PolymorphicMatcher;
-using testing::Property;
-using testing::Ref;
-using testing::ResultOf;
-using testing::SizeIs;
-using testing::StartsWith;
-using testing::StrCaseEq;
-using testing::StrCaseNe;
-using testing::StrEq;
-using testing::StrNe;
-using testing::StringMatchResultListener;
-using testing::Truly;
-using testing::TypedEq;
-using testing::UnorderedPointwise;
-using testing::Value;
-using testing::WhenSorted;
-using testing::WhenSortedBy;
-using testing::_;
-using testing::get;
-using testing::internal::DummyMatchResultListener;
-using testing::internal::ElementMatcherPair;
-using testing::internal::ElementMatcherPairs;
-using testing::internal::ExplainMatchFailureTupleTo;
-using testing::internal::FloatingEqMatcher;
-using testing::internal::FormatMatcherDescription;
-using testing::internal::IsReadableTypeName;
-using testing::internal::JoinAsTuple;
-using testing::internal::linked_ptr;
-using testing::internal::MatchMatrix;
-using testing::internal::RE;
-using testing::internal::scoped_ptr;
-using testing::internal::StreamMatchResultListener;
-using testing::internal::Strings;
-using testing::internal::linked_ptr;
-using testing::internal::scoped_ptr;
-using testing::internal::string;
-using testing::make_tuple;
-using testing::tuple;
-
-// For testing ExplainMatchResultTo().
-class GreaterThanMatcher : public MatcherInterface<int> {
- public:
-  explicit GreaterThanMatcher(int rhs) : rhs_(rhs) {}
-
-  virtual void DescribeTo(ostream* os) const {
-    *os << "is > " << rhs_;
-  }
-
-  virtual bool MatchAndExplain(int lhs,
-                               MatchResultListener* listener) const {
-    const int diff = lhs - rhs_;
-    if (diff > 0) {
-      *listener << "which is " << diff << " more than " << rhs_;
-    } else if (diff == 0) {
-      *listener << "which is the same as " << rhs_;
-    } else {
-      *listener << "which is " << -diff << " less than " << rhs_;
-    }
-
-    return lhs > rhs_;
-  }
-
- private:
-  int rhs_;
-};
-
-Matcher<int> GreaterThan(int n) {
-  return MakeMatcher(new GreaterThanMatcher(n));
-}
-
-string OfType(const string& type_name) {
-#if GTEST_HAS_RTTI
-  return " (of type " + type_name + ")";
-#else
-  return "";
-#endif
-}
-
-// Returns the description of the given matcher.
-template <typename T>
-string Describe(const Matcher<T>& m) {
-  stringstream ss;
-  m.DescribeTo(&ss);
-  return ss.str();
-}
-
-// Returns the description of the negation of the given matcher.
-template <typename T>
-string DescribeNegation(const Matcher<T>& m) {
-  stringstream ss;
-  m.DescribeNegationTo(&ss);
-  return ss.str();
-}
-
-// Returns the reason why x matches, or doesn't match, m.
-template <typename MatcherType, typename Value>
-string Explain(const MatcherType& m, const Value& x) {
-  StringMatchResultListener listener;
-  ExplainMatchResult(m, x, &listener);
-  return listener.str();
-}
-
-TEST(MatchResultListenerTest, StreamingWorks) {
-  StringMatchResultListener listener;
-  listener << "hi" << 5;
-  EXPECT_EQ("hi5", listener.str());
-
-  listener.Clear();
-  EXPECT_EQ("", listener.str());
-
-  listener << 42;
-  EXPECT_EQ("42", listener.str());
-
-  // Streaming shouldn't crash when the underlying ostream is NULL.
-  DummyMatchResultListener dummy;
-  dummy << "hi" << 5;
-}
-
-TEST(MatchResultListenerTest, CanAccessUnderlyingStream) {
-  EXPECT_TRUE(DummyMatchResultListener().stream() == NULL);
-  EXPECT_TRUE(StreamMatchResultListener(NULL).stream() == NULL);
-
-  EXPECT_EQ(&std::cout, StreamMatchResultListener(&std::cout).stream());
-}
-
-TEST(MatchResultListenerTest, IsInterestedWorks) {
-  EXPECT_TRUE(StringMatchResultListener().IsInterested());
-  EXPECT_TRUE(StreamMatchResultListener(&std::cout).IsInterested());
-
-  EXPECT_FALSE(DummyMatchResultListener().IsInterested());
-  EXPECT_FALSE(StreamMatchResultListener(NULL).IsInterested());
-}
-
-// Makes sure that the MatcherInterface<T> interface doesn't
-// change.
-class EvenMatcherImpl : public MatcherInterface<int> {
- public:
-  virtual bool MatchAndExplain(int x,
-                               MatchResultListener* /* listener */) const {
-    return x % 2 == 0;
-  }
-
-  virtual void DescribeTo(ostream* os) const {
-    *os << "is an even number";
-  }
-
-  // We deliberately don't define DescribeNegationTo() and
-  // ExplainMatchResultTo() here, to make sure the definition of these
-  // two methods is optional.
-};
-
-// Makes sure that the MatcherInterface API doesn't change.
-TEST(MatcherInterfaceTest, CanBeImplementedUsingPublishedAPI) {
-  EvenMatcherImpl m;
-}
-
-// Tests implementing a monomorphic matcher using MatchAndExplain().
-
-class NewEvenMatcherImpl : public MatcherInterface<int> {
- public:
-  virtual bool MatchAndExplain(int x, MatchResultListener* listener) const {
-    const bool match = x % 2 == 0;
-    // Verifies that we can stream to a listener directly.
-    *listener << "value % " << 2;
-    if (listener->stream() != NULL) {
-      // Verifies that we can stream to a listener's underlying stream
-      // too.
-      *listener->stream() << " == " << (x % 2);
-    }
-    return match;
-  }
-
-  virtual void DescribeTo(ostream* os) const {
-    *os << "is an even number";
-  }
-};
-
-TEST(MatcherInterfaceTest, CanBeImplementedUsingNewAPI) {
-  Matcher<int> m = MakeMatcher(new NewEvenMatcherImpl);
-  EXPECT_TRUE(m.Matches(2));
-  EXPECT_FALSE(m.Matches(3));
-  EXPECT_EQ("value % 2 == 0", Explain(m, 2));
-  EXPECT_EQ("value % 2 == 1", Explain(m, 3));
-}
-
-// Tests default-constructing a matcher.
-TEST(MatcherTest, CanBeDefaultConstructed) {
-  Matcher<double> m;
-}
-
-// Tests that Matcher<T> can be constructed from a MatcherInterface<T>*.
-TEST(MatcherTest, CanBeConstructedFromMatcherInterface) {
-  const MatcherInterface<int>* impl = new EvenMatcherImpl;
-  Matcher<int> m(impl);
-  EXPECT_TRUE(m.Matches(4));
-  EXPECT_FALSE(m.Matches(5));
-}
-
-// Tests that value can be used in place of Eq(value).
-TEST(MatcherTest, CanBeImplicitlyConstructedFromValue) {
-  Matcher<int> m1 = 5;
-  EXPECT_TRUE(m1.Matches(5));
-  EXPECT_FALSE(m1.Matches(6));
-}
-
-// Tests that NULL can be used in place of Eq(NULL).
-TEST(MatcherTest, CanBeImplicitlyConstructedFromNULL) {
-  Matcher<int*> m1 = NULL;
-  EXPECT_TRUE(m1.Matches(NULL));
-  int n = 0;
-  EXPECT_FALSE(m1.Matches(&n));
-}
-
-// Tests that matchers are copyable.
-TEST(MatcherTest, IsCopyable) {
-  // Tests the copy constructor.
-  Matcher<bool> m1 = Eq(false);
-  EXPECT_TRUE(m1.Matches(false));
-  EXPECT_FALSE(m1.Matches(true));
-
-  // Tests the assignment operator.
-  m1 = Eq(true);
-  EXPECT_TRUE(m1.Matches(true));
-  EXPECT_FALSE(m1.Matches(false));
-}
-
-// Tests that Matcher<T>::DescribeTo() calls
-// MatcherInterface<T>::DescribeTo().
-TEST(MatcherTest, CanDescribeItself) {
-  EXPECT_EQ("is an even number",
-            Describe(Matcher<int>(new EvenMatcherImpl)));
-}
-
-// Tests Matcher<T>::MatchAndExplain().
-TEST(MatcherTest, MatchAndExplain) {
-  Matcher<int> m = GreaterThan(0);
-  StringMatchResultListener listener1;
-  EXPECT_TRUE(m.MatchAndExplain(42, &listener1));
-  EXPECT_EQ("which is 42 more than 0", listener1.str());
-
-  StringMatchResultListener listener2;
-  EXPECT_FALSE(m.MatchAndExplain(-9, &listener2));
-  EXPECT_EQ("which is 9 less than 0", listener2.str());
-}
-
-// Tests that a C-string literal can be implicitly converted to a
-// Matcher<string> or Matcher<const string&>.
-TEST(StringMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
-  Matcher<string> m1 = "hi";
-  EXPECT_TRUE(m1.Matches("hi"));
-  EXPECT_FALSE(m1.Matches("hello"));
-
-  Matcher<const string&> m2 = "hi";
-  EXPECT_TRUE(m2.Matches("hi"));
-  EXPECT_FALSE(m2.Matches("hello"));
-}
-
-// Tests that a string object can be implicitly converted to a
-// Matcher<string> or Matcher<const string&>.
-TEST(StringMatcherTest, CanBeImplicitlyConstructedFromString) {
-  Matcher<string> m1 = string("hi");
-  EXPECT_TRUE(m1.Matches("hi"));
-  EXPECT_FALSE(m1.Matches("hello"));
-
-  Matcher<const string&> m2 = string("hi");
-  EXPECT_TRUE(m2.Matches("hi"));
-  EXPECT_FALSE(m2.Matches("hello"));
-}
-
-#if GTEST_HAS_STRING_PIECE_
-// Tests that a C-string literal can be implicitly converted to a
-// Matcher<StringPiece> or Matcher<const StringPiece&>.
-TEST(StringPieceMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
-  Matcher<StringPiece> m1 = "cats";
-  EXPECT_TRUE(m1.Matches("cats"));
-  EXPECT_FALSE(m1.Matches("dogs"));
-
-  Matcher<const StringPiece&> m2 = "cats";
-  EXPECT_TRUE(m2.Matches("cats"));
-  EXPECT_FALSE(m2.Matches("dogs"));
-}
-
-// Tests that a string object can be implicitly converted to a
-// Matcher<StringPiece> or Matcher<const StringPiece&>.
-TEST(StringPieceMatcherTest, CanBeImplicitlyConstructedFromString) {
-  Matcher<StringPiece> m1 = string("cats");
-  EXPECT_TRUE(m1.Matches("cats"));
-  EXPECT_FALSE(m1.Matches("dogs"));
-
-  Matcher<const StringPiece&> m2 = string("cats");
-  EXPECT_TRUE(m2.Matches("cats"));
-  EXPECT_FALSE(m2.Matches("dogs"));
-}
-
-// Tests that a StringPiece object can be implicitly converted to a
-// Matcher<StringPiece> or Matcher<const StringPiece&>.
-TEST(StringPieceMatcherTest, CanBeImplicitlyConstructedFromStringPiece) {
-  Matcher<StringPiece> m1 = StringPiece("cats");
-  EXPECT_TRUE(m1.Matches("cats"));
-  EXPECT_FALSE(m1.Matches("dogs"));
-
-  Matcher<const StringPiece&> m2 = StringPiece("cats");
-  EXPECT_TRUE(m2.Matches("cats"));
-  EXPECT_FALSE(m2.Matches("dogs"));
-}
-#endif  // GTEST_HAS_STRING_PIECE_
-
-// Tests that MakeMatcher() constructs a Matcher<T> from a
-// MatcherInterface* without requiring the user to explicitly
-// write the type.
-TEST(MakeMatcherTest, ConstructsMatcherFromMatcherInterface) {
-  const MatcherInterface<int>* dummy_impl = NULL;
-  Matcher<int> m = MakeMatcher(dummy_impl);
-}
-
-// Tests that MakePolymorphicMatcher() can construct a polymorphic
-// matcher from its implementation using the old API.
-const int g_bar = 1;
-class ReferencesBarOrIsZeroImpl {
- public:
-  template <typename T>
-  bool MatchAndExplain(const T& x,
-                       MatchResultListener* /* listener */) const {
-    const void* p = &x;
-    return p == &g_bar || x == 0;
-  }
-
-  void DescribeTo(ostream* os) const { *os << "g_bar or zero"; }
-
-  void DescribeNegationTo(ostream* os) const {
-    *os << "doesn't reference g_bar and is not zero";
-  }
-};
-
-// This function verifies that MakePolymorphicMatcher() returns a
-// PolymorphicMatcher<T> where T is the argument's type.
-PolymorphicMatcher<ReferencesBarOrIsZeroImpl> ReferencesBarOrIsZero() {
-  return MakePolymorphicMatcher(ReferencesBarOrIsZeroImpl());
-}
-
-TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingOldAPI) {
-  // Using a polymorphic matcher to match a reference type.
-  Matcher<const int&> m1 = ReferencesBarOrIsZero();
-  EXPECT_TRUE(m1.Matches(0));
-  // Verifies that the identity of a by-reference argument is preserved.
-  EXPECT_TRUE(m1.Matches(g_bar));
-  EXPECT_FALSE(m1.Matches(1));
-  EXPECT_EQ("g_bar or zero", Describe(m1));
-
-  // Using a polymorphic matcher to match a value type.
-  Matcher<double> m2 = ReferencesBarOrIsZero();
-  EXPECT_TRUE(m2.Matches(0.0));
-  EXPECT_FALSE(m2.Matches(0.1));
-  EXPECT_EQ("g_bar or zero", Describe(m2));
-}
-
-// Tests implementing a polymorphic matcher using MatchAndExplain().
-
-class PolymorphicIsEvenImpl {
- public:
-  void DescribeTo(ostream* os) const { *os << "is even"; }
-
-  void DescribeNegationTo(ostream* os) const {
-    *os << "is odd";
-  }
-
-  template <typename T>
-  bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
-    // Verifies that we can stream to the listener directly.
-    *listener << "% " << 2;
-    if (listener->stream() != NULL) {
-      // Verifies that we can stream to the listener's underlying stream
-      // too.
-      *listener->stream() << " == " << (x % 2);
-    }
-    return (x % 2) == 0;
-  }
-};
-
-PolymorphicMatcher<PolymorphicIsEvenImpl> PolymorphicIsEven() {
-  return MakePolymorphicMatcher(PolymorphicIsEvenImpl());
-}
-
-TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingNewAPI) {
-  // Using PolymorphicIsEven() as a Matcher<int>.
-  const Matcher<int> m1 = PolymorphicIsEven();
-  EXPECT_TRUE(m1.Matches(42));
-  EXPECT_FALSE(m1.Matches(43));
-  EXPECT_EQ("is even", Describe(m1));
-
-  const Matcher<int> not_m1 = Not(m1);
-  EXPECT_EQ("is odd", Describe(not_m1));
-
-  EXPECT_EQ("% 2 == 0", Explain(m1, 42));
-
-  // Using PolymorphicIsEven() as a Matcher<char>.
-  const Matcher<char> m2 = PolymorphicIsEven();
-  EXPECT_TRUE(m2.Matches('\x42'));
-  EXPECT_FALSE(m2.Matches('\x43'));
-  EXPECT_EQ("is even", Describe(m2));
-
-  const Matcher<char> not_m2 = Not(m2);
-  EXPECT_EQ("is odd", Describe(not_m2));
-
-  EXPECT_EQ("% 2 == 0", Explain(m2, '\x42'));
-}
-
-// Tests that MatcherCast<T>(m) works when m is a polymorphic matcher.
-TEST(MatcherCastTest, FromPolymorphicMatcher) {
-  Matcher<int> m = MatcherCast<int>(Eq(5));
-  EXPECT_TRUE(m.Matches(5));
-  EXPECT_FALSE(m.Matches(6));
-}
-
-// For testing casting matchers between compatible types.
-class IntValue {
- public:
-  // An int can be statically (although not implicitly) cast to a
-  // IntValue.
-  explicit IntValue(int a_value) : value_(a_value) {}
-
-  int value() const { return value_; }
- private:
-  int value_;
-};
-
-// For testing casting matchers between compatible types.
-bool IsPositiveIntValue(const IntValue& foo) {
-  return foo.value() > 0;
-}
-
-// Tests that MatcherCast<T>(m) works when m is a Matcher<U> where T
-// can be statically converted to U.
-TEST(MatcherCastTest, FromCompatibleType) {
-  Matcher<double> m1 = Eq(2.0);
-  Matcher<int> m2 = MatcherCast<int>(m1);
-  EXPECT_TRUE(m2.Matches(2));
-  EXPECT_FALSE(m2.Matches(3));
-
-  Matcher<IntValue> m3 = Truly(IsPositiveIntValue);
-  Matcher<int> m4 = MatcherCast<int>(m3);
-  // In the following, the arguments 1 and 0 are statically converted
-  // to IntValue objects, and then tested by the IsPositiveIntValue()
-  // predicate.
-  EXPECT_TRUE(m4.Matches(1));
-  EXPECT_FALSE(m4.Matches(0));
-}
-
-// Tests that MatcherCast<T>(m) works when m is a Matcher<const T&>.
-TEST(MatcherCastTest, FromConstReferenceToNonReference) {
-  Matcher<const int&> m1 = Eq(0);
-  Matcher<int> m2 = MatcherCast<int>(m1);
-  EXPECT_TRUE(m2.Matches(0));
-  EXPECT_FALSE(m2.Matches(1));
-}
-
-// Tests that MatcherCast<T>(m) works when m is a Matcher<T&>.
-TEST(MatcherCastTest, FromReferenceToNonReference) {
-  Matcher<int&> m1 = Eq(0);
-  Matcher<int> m2 = MatcherCast<int>(m1);
-  EXPECT_TRUE(m2.Matches(0));
-  EXPECT_FALSE(m2.Matches(1));
-}
-
-// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
-TEST(MatcherCastTest, FromNonReferenceToConstReference) {
-  Matcher<int> m1 = Eq(0);
-  Matcher<const int&> m2 = MatcherCast<const int&>(m1);
-  EXPECT_TRUE(m2.Matches(0));
-  EXPECT_FALSE(m2.Matches(1));
-}
-
-// Tests that MatcherCast<T&>(m) works when m is a Matcher<T>.
-TEST(MatcherCastTest, FromNonReferenceToReference) {
-  Matcher<int> m1 = Eq(0);
-  Matcher<int&> m2 = MatcherCast<int&>(m1);
-  int n = 0;
-  EXPECT_TRUE(m2.Matches(n));
-  n = 1;
-  EXPECT_FALSE(m2.Matches(n));
-}
-
-// Tests that MatcherCast<T>(m) works when m is a Matcher<T>.
-TEST(MatcherCastTest, FromSameType) {
-  Matcher<int> m1 = Eq(0);
-  Matcher<int> m2 = MatcherCast<int>(m1);
-  EXPECT_TRUE(m2.Matches(0));
-  EXPECT_FALSE(m2.Matches(1));
-}
-
-// Implicitly convertible from any type.
-struct ConvertibleFromAny {
-  ConvertibleFromAny(int a_value) : value(a_value) {}
-  template <typename T>
-  explicit ConvertibleFromAny(const T& /*a_value*/) : value(-1) {
-    ADD_FAILURE() << "Conversion constructor called";
-  }
-  int value;
-};
-
-bool operator==(const ConvertibleFromAny& a, const ConvertibleFromAny& b) {
-  return a.value == b.value;
-}
-
-ostream& operator<<(ostream& os, const ConvertibleFromAny& a) {
-  return os << a.value;
-}
-
-TEST(MatcherCastTest, ConversionConstructorIsUsed) {
-  Matcher<ConvertibleFromAny> m = MatcherCast<ConvertibleFromAny>(1);
-  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
-  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
-}
-
-TEST(MatcherCastTest, FromConvertibleFromAny) {
-  Matcher<ConvertibleFromAny> m =
-      MatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
-  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
-  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
-}
-
-struct IntReferenceWrapper {
-  IntReferenceWrapper(const int& a_value) : value(&a_value) {}
-  const int* value;
-};
-
-bool operator==(const IntReferenceWrapper& a, const IntReferenceWrapper& b) {
-  return a.value == b.value;
-}
-
-TEST(MatcherCastTest, ValueIsNotCopied) {
-  int n = 42;
-  Matcher<IntReferenceWrapper> m = MatcherCast<IntReferenceWrapper>(n);
-  // Verify that the matcher holds a reference to n, not to its temporary copy.
-  EXPECT_TRUE(m.Matches(n));
-}
-
-class Base {
- public:
-  virtual ~Base() {}
-  Base() {}
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Base);
-};
-
-class Derived : public Base {
- public:
-  Derived() : Base() {}
-  int i;
-};
-
-class OtherDerived : public Base {};
-
-// Tests that SafeMatcherCast<T>(m) works when m is a polymorphic matcher.
-TEST(SafeMatcherCastTest, FromPolymorphicMatcher) {
-  Matcher<char> m2 = SafeMatcherCast<char>(Eq(32));
-  EXPECT_TRUE(m2.Matches(' '));
-  EXPECT_FALSE(m2.Matches('\n'));
-}
-
-// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where
-// T and U are arithmetic types and T can be losslessly converted to
-// U.
-TEST(SafeMatcherCastTest, FromLosslesslyConvertibleArithmeticType) {
-  Matcher<double> m1 = DoubleEq(1.0);
-  Matcher<float> m2 = SafeMatcherCast<float>(m1);
-  EXPECT_TRUE(m2.Matches(1.0f));
-  EXPECT_FALSE(m2.Matches(2.0f));
-
-  Matcher<char> m3 = SafeMatcherCast<char>(TypedEq<int>('a'));
-  EXPECT_TRUE(m3.Matches('a'));
-  EXPECT_FALSE(m3.Matches('b'));
-}
-
-// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T and U
-// are pointers or references to a derived and a base class, correspondingly.
-TEST(SafeMatcherCastTest, FromBaseClass) {
-  Derived d, d2;
-  Matcher<Base*> m1 = Eq(&d);
-  Matcher<Derived*> m2 = SafeMatcherCast<Derived*>(m1);
-  EXPECT_TRUE(m2.Matches(&d));
-  EXPECT_FALSE(m2.Matches(&d2));
-
-  Matcher<Base&> m3 = Ref(d);
-  Matcher<Derived&> m4 = SafeMatcherCast<Derived&>(m3);
-  EXPECT_TRUE(m4.Matches(d));
-  EXPECT_FALSE(m4.Matches(d2));
-}
-
-// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<const T&>.
-TEST(SafeMatcherCastTest, FromConstReferenceToReference) {
-  int n = 0;
-  Matcher<const int&> m1 = Ref(n);
-  Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
-  int n1 = 0;
-  EXPECT_TRUE(m2.Matches(n));
-  EXPECT_FALSE(m2.Matches(n1));
-}
-
-// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
-TEST(SafeMatcherCastTest, FromNonReferenceToConstReference) {
-  Matcher<int> m1 = Eq(0);
-  Matcher<const int&> m2 = SafeMatcherCast<const int&>(m1);
-  EXPECT_TRUE(m2.Matches(0));
-  EXPECT_FALSE(m2.Matches(1));
-}
-
-// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<T>.
-TEST(SafeMatcherCastTest, FromNonReferenceToReference) {
-  Matcher<int> m1 = Eq(0);
-  Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
-  int n = 0;
-  EXPECT_TRUE(m2.Matches(n));
-  n = 1;
-  EXPECT_FALSE(m2.Matches(n));
-}
-
-// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<T>.
-TEST(SafeMatcherCastTest, FromSameType) {
-  Matcher<int> m1 = Eq(0);
-  Matcher<int> m2 = SafeMatcherCast<int>(m1);
-  EXPECT_TRUE(m2.Matches(0));
-  EXPECT_FALSE(m2.Matches(1));
-}
-
-TEST(SafeMatcherCastTest, ConversionConstructorIsUsed) {
-  Matcher<ConvertibleFromAny> m = SafeMatcherCast<ConvertibleFromAny>(1);
-  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
-  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
-}
-
-TEST(SafeMatcherCastTest, FromConvertibleFromAny) {
-  Matcher<ConvertibleFromAny> m =
-      SafeMatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
-  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
-  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
-}
-
-TEST(SafeMatcherCastTest, ValueIsNotCopied) {
-  int n = 42;
-  Matcher<IntReferenceWrapper> m = SafeMatcherCast<IntReferenceWrapper>(n);
-  // Verify that the matcher holds a reference to n, not to its temporary copy.
-  EXPECT_TRUE(m.Matches(n));
-}
-
-TEST(ExpectThat, TakesLiterals) {
-  EXPECT_THAT(1, 1);
-  EXPECT_THAT(1.0, 1.0);
-  EXPECT_THAT(string(), "");
-}
-
-TEST(ExpectThat, TakesFunctions) {
-  struct Helper {
-    static void Func() {}
-  };
-  void (*func)() = Helper::Func;
-  EXPECT_THAT(func, Helper::Func);
-  EXPECT_THAT(func, &Helper::Func);
-}
-
-// Tests that A<T>() matches any value of type T.
-TEST(ATest, MatchesAnyValue) {
-  // Tests a matcher for a value type.
-  Matcher<double> m1 = A<double>();
-  EXPECT_TRUE(m1.Matches(91.43));
-  EXPECT_TRUE(m1.Matches(-15.32));
-
-  // Tests a matcher for a reference type.
-  int a = 2;
-  int b = -6;
-  Matcher<int&> m2 = A<int&>();
-  EXPECT_TRUE(m2.Matches(a));
-  EXPECT_TRUE(m2.Matches(b));
-}
-
-TEST(ATest, WorksForDerivedClass) {
-  Base base;
-  Derived derived;
-  EXPECT_THAT(&base, A<Base*>());
-  // This shouldn't compile: EXPECT_THAT(&base, A<Derived*>());
-  EXPECT_THAT(&derived, A<Base*>());
-  EXPECT_THAT(&derived, A<Derived*>());
-}
-
-// Tests that A<T>() describes itself properly.
-TEST(ATest, CanDescribeSelf) {
-  EXPECT_EQ("is anything", Describe(A<bool>()));
-}
-
-// Tests that An<T>() matches any value of type T.
-TEST(AnTest, MatchesAnyValue) {
-  // Tests a matcher for a value type.
-  Matcher<int> m1 = An<int>();
-  EXPECT_TRUE(m1.Matches(9143));
-  EXPECT_TRUE(m1.Matches(-1532));
-
-  // Tests a matcher for a reference type.
-  int a = 2;
-  int b = -6;
-  Matcher<int&> m2 = An<int&>();
-  EXPECT_TRUE(m2.Matches(a));
-  EXPECT_TRUE(m2.Matches(b));
-}
-
-// Tests that An<T>() describes itself properly.
-TEST(AnTest, CanDescribeSelf) {
-  EXPECT_EQ("is anything", Describe(An<int>()));
-}
-
-// Tests that _ can be used as a matcher for any type and matches any
-// value of that type.
-TEST(UnderscoreTest, MatchesAnyValue) {
-  // Uses _ as a matcher for a value type.
-  Matcher<int> m1 = _;
-  EXPECT_TRUE(m1.Matches(123));
-  EXPECT_TRUE(m1.Matches(-242));
-
-  // Uses _ as a matcher for a reference type.
-  bool a = false;
-  const bool b = true;
-  Matcher<const bool&> m2 = _;
-  EXPECT_TRUE(m2.Matches(a));
-  EXPECT_TRUE(m2.Matches(b));
-}
-
-// Tests that _ describes itself properly.
-TEST(UnderscoreTest, CanDescribeSelf) {
-  Matcher<int> m = _;
-  EXPECT_EQ("is anything", Describe(m));
-}
-
-// Tests that Eq(x) matches any value equal to x.
-TEST(EqTest, MatchesEqualValue) {
-  // 2 C-strings with same content but different addresses.
-  const char a1[] = "hi";
-  const char a2[] = "hi";
-
-  Matcher<const char*> m1 = Eq(a1);
-  EXPECT_TRUE(m1.Matches(a1));
-  EXPECT_FALSE(m1.Matches(a2));
-}
-
-// Tests that Eq(v) describes itself properly.
-
-class Unprintable {
- public:
-  Unprintable() : c_('a') {}
-
- private:
-  char c_;
-};
-
-inline bool operator==(const Unprintable& /* lhs */, 
-                       const Unprintable& /* rhs */) { 
-    return true; 
-}
-
-TEST(EqTest, CanDescribeSelf) {
-  Matcher<Unprintable> m = Eq(Unprintable());
-  EXPECT_EQ("is equal to 1-byte object <61>", Describe(m));
-}
-
-// Tests that Eq(v) can be used to match any type that supports
-// comparing with type T, where T is v's type.
-TEST(EqTest, IsPolymorphic) {
-  Matcher<int> m1 = Eq(1);
-  EXPECT_TRUE(m1.Matches(1));
-  EXPECT_FALSE(m1.Matches(2));
-
-  Matcher<char> m2 = Eq(1);
-  EXPECT_TRUE(m2.Matches('\1'));
-  EXPECT_FALSE(m2.Matches('a'));
-}
-
-// Tests that TypedEq<T>(v) matches values of type T that's equal to v.
-TEST(TypedEqTest, ChecksEqualityForGivenType) {
-  Matcher<char> m1 = TypedEq<char>('a');
-  EXPECT_TRUE(m1.Matches('a'));
-  EXPECT_FALSE(m1.Matches('b'));
-
-  Matcher<int> m2 = TypedEq<int>(6);
-  EXPECT_TRUE(m2.Matches(6));
-  EXPECT_FALSE(m2.Matches(7));
-}
-
-// Tests that TypedEq(v) describes itself properly.
-TEST(TypedEqTest, CanDescribeSelf) {
-  EXPECT_EQ("is equal to 2", Describe(TypedEq<int>(2)));
-}
-
-// Tests that TypedEq<T>(v) has type Matcher<T>.
-
-// Type<T>::IsTypeOf(v) compiles iff the type of value v is T, where T
-// is a "bare" type (i.e. not in the form of const U or U&).  If v's
-// type is not T, the compiler will generate a message about
-// "undefined referece".
-template <typename T>
-struct Type {
-  static bool IsTypeOf(const T& /* v */) { return true; }
-
-  template <typename T2>
-  static void IsTypeOf(T2 v);
-};
-
-TEST(TypedEqTest, HasSpecifiedType) {
-  // Verfies that the type of TypedEq<T>(v) is Matcher<T>.
-  Type<Matcher<int> >::IsTypeOf(TypedEq<int>(5));
-  Type<Matcher<double> >::IsTypeOf(TypedEq<double>(5));
-}
-
-// Tests that Ge(v) matches anything >= v.
-TEST(GeTest, ImplementsGreaterThanOrEqual) {
-  Matcher<int> m1 = Ge(0);
-  EXPECT_TRUE(m1.Matches(1));
-  EXPECT_TRUE(m1.Matches(0));
-  EXPECT_FALSE(m1.Matches(-1));
-}
-
-// Tests that Ge(v) describes itself properly.
-TEST(GeTest, CanDescribeSelf) {
-  Matcher<int> m = Ge(5);
-  EXPECT_EQ("is >= 5", Describe(m));
-}
-
-// Tests that Gt(v) matches anything > v.
-TEST(GtTest, ImplementsGreaterThan) {
-  Matcher<double> m1 = Gt(0);
-  EXPECT_TRUE(m1.Matches(1.0));
-  EXPECT_FALSE(m1.Matches(0.0));
-  EXPECT_FALSE(m1.Matches(-1.0));
-}
-
-// Tests that Gt(v) describes itself properly.
-TEST(GtTest, CanDescribeSelf) {
-  Matcher<int> m = Gt(5);
-  EXPECT_EQ("is > 5", Describe(m));
-}
-
-// Tests that Le(v) matches anything <= v.
-TEST(LeTest, ImplementsLessThanOrEqual) {
-  Matcher<char> m1 = Le('b');
-  EXPECT_TRUE(m1.Matches('a'));
-  EXPECT_TRUE(m1.Matches('b'));
-  EXPECT_FALSE(m1.Matches('c'));
-}
-
-// Tests that Le(v) describes itself properly.
-TEST(LeTest, CanDescribeSelf) {
-  Matcher<int> m = Le(5);
-  EXPECT_EQ("is <= 5", Describe(m));
-}
-
-// Tests that Lt(v) matches anything < v.
-TEST(LtTest, ImplementsLessThan) {
-  Matcher<const string&> m1 = Lt("Hello");
-  EXPECT_TRUE(m1.Matches("Abc"));
-  EXPECT_FALSE(m1.Matches("Hello"));
-  EXPECT_FALSE(m1.Matches("Hello, world!"));
-}
-
-// Tests that Lt(v) describes itself properly.
-TEST(LtTest, CanDescribeSelf) {
-  Matcher<int> m = Lt(5);
-  EXPECT_EQ("is < 5", Describe(m));
-}
-
-// Tests that Ne(v) matches anything != v.
-TEST(NeTest, ImplementsNotEqual) {
-  Matcher<int> m1 = Ne(0);
-  EXPECT_TRUE(m1.Matches(1));
-  EXPECT_TRUE(m1.Matches(-1));
-  EXPECT_FALSE(m1.Matches(0));
-}
-
-// Tests that Ne(v) describes itself properly.
-TEST(NeTest, CanDescribeSelf) {
-  Matcher<int> m = Ne(5);
-  EXPECT_EQ("isn't equal to 5", Describe(m));
-}
-
-// Tests that IsNull() matches any NULL pointer of any type.
-TEST(IsNullTest, MatchesNullPointer) {
-  Matcher<int*> m1 = IsNull();
-  int* p1 = NULL;
-  int n = 0;
-  EXPECT_TRUE(m1.Matches(p1));
-  EXPECT_FALSE(m1.Matches(&n));
-
-  Matcher<const char*> m2 = IsNull();
-  const char* p2 = NULL;
-  EXPECT_TRUE(m2.Matches(p2));
-  EXPECT_FALSE(m2.Matches("hi"));
-
-#if !GTEST_OS_SYMBIAN
-  // Nokia's Symbian compiler generates:
-  // gmock-matchers.h: ambiguous access to overloaded function
-  // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(void *)'
-  // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(const testing::
-  //     MatcherInterface<void *> *)'
-  // gmock-matchers.h:  (point of instantiation: 'testing::
-  //     gmock_matchers_test::IsNullTest_MatchesNullPointer_Test::TestBody()')
-  // gmock-matchers.h:   (instantiating: 'testing::PolymorphicMatc
-  Matcher<void*> m3 = IsNull();
-  void* p3 = NULL;
-  EXPECT_TRUE(m3.Matches(p3));
-  EXPECT_FALSE(m3.Matches(reinterpret_cast<void*>(0xbeef)));
-#endif
-}
-
-TEST(IsNullTest, LinkedPtr) {
-  const Matcher<linked_ptr<int> > m = IsNull();
-  const linked_ptr<int> null_p;
-  const linked_ptr<int> non_null_p(new int);
-
-  EXPECT_TRUE(m.Matches(null_p));
-  EXPECT_FALSE(m.Matches(non_null_p));
-}
-
-TEST(IsNullTest, ReferenceToConstLinkedPtr) {
-  const Matcher<const linked_ptr<double>&> m = IsNull();
-  const linked_ptr<double> null_p;
-  const linked_ptr<double> non_null_p(new double);
-
-  EXPECT_TRUE(m.Matches(null_p));
-  EXPECT_FALSE(m.Matches(non_null_p));
-}
-
-#if GTEST_HAS_STD_FUNCTION_
-TEST(IsNullTest, StdFunction) {
-  const Matcher<std::function<void()>> m = IsNull();
-
-  EXPECT_TRUE(m.Matches(std::function<void()>()));
-  EXPECT_FALSE(m.Matches([]{}));
-}
-#endif  // GTEST_HAS_STD_FUNCTION_
-
-// Tests that IsNull() describes itself properly.
-TEST(IsNullTest, CanDescribeSelf) {
-  Matcher<int*> m = IsNull();
-  EXPECT_EQ("is NULL", Describe(m));
-  EXPECT_EQ("isn't NULL", DescribeNegation(m));
-}
-
-// Tests that NotNull() matches any non-NULL pointer of any type.
-TEST(NotNullTest, MatchesNonNullPointer) {
-  Matcher<int*> m1 = NotNull();
-  int* p1 = NULL;
-  int n = 0;
-  EXPECT_FALSE(m1.Matches(p1));
-  EXPECT_TRUE(m1.Matches(&n));
-
-  Matcher<const char*> m2 = NotNull();
-  const char* p2 = NULL;
-  EXPECT_FALSE(m2.Matches(p2));
-  EXPECT_TRUE(m2.Matches("hi"));
-}
-
-TEST(NotNullTest, LinkedPtr) {
-  const Matcher<linked_ptr<int> > m = NotNull();
-  const linked_ptr<int> null_p;
-  const linked_ptr<int> non_null_p(new int);
-
-  EXPECT_FALSE(m.Matches(null_p));
-  EXPECT_TRUE(m.Matches(non_null_p));
-}
-
-TEST(NotNullTest, ReferenceToConstLinkedPtr) {
-  const Matcher<const linked_ptr<double>&> m = NotNull();
-  const linked_ptr<double> null_p;
-  const linked_ptr<double> non_null_p(new double);
-
-  EXPECT_FALSE(m.Matches(null_p));
-  EXPECT_TRUE(m.Matches(non_null_p));
-}
-
-#if GTEST_HAS_STD_FUNCTION_
-TEST(NotNullTest, StdFunction) {
-  const Matcher<std::function<void()>> m = NotNull();
-
-  EXPECT_TRUE(m.Matches([]{}));
-  EXPECT_FALSE(m.Matches(std::function<void()>()));
-}
-#endif  // GTEST_HAS_STD_FUNCTION_
-
-// Tests that NotNull() describes itself properly.
-TEST(NotNullTest, CanDescribeSelf) {
-  Matcher<int*> m = NotNull();
-  EXPECT_EQ("isn't NULL", Describe(m));
-}
-
-// Tests that Ref(variable) matches an argument that references
-// 'variable'.
-TEST(RefTest, MatchesSameVariable) {
-  int a = 0;
-  int b = 0;
-  Matcher<int&> m = Ref(a);
-  EXPECT_TRUE(m.Matches(a));
-  EXPECT_FALSE(m.Matches(b));
-}
-
-// Tests that Ref(variable) describes itself properly.
-TEST(RefTest, CanDescribeSelf) {
-  int n = 5;
-  Matcher<int&> m = Ref(n);
-  stringstream ss;
-  ss << "references the variable @" << &n << " 5";
-  EXPECT_EQ(string(ss.str()), Describe(m));
-}
-
-// Test that Ref(non_const_varialbe) can be used as a matcher for a
-// const reference.
-TEST(RefTest, CanBeUsedAsMatcherForConstReference) {
-  int a = 0;
-  int b = 0;
-  Matcher<const int&> m = Ref(a);
-  EXPECT_TRUE(m.Matches(a));
-  EXPECT_FALSE(m.Matches(b));
-}
-
-// Tests that Ref(variable) is covariant, i.e. Ref(derived) can be
-// used wherever Ref(base) can be used (Ref(derived) is a sub-type
-// of Ref(base), but not vice versa.
-
-TEST(RefTest, IsCovariant) {
-  Base base, base2;
-  Derived derived;
-  Matcher<const Base&> m1 = Ref(base);
-  EXPECT_TRUE(m1.Matches(base));
-  EXPECT_FALSE(m1.Matches(base2));
-  EXPECT_FALSE(m1.Matches(derived));
-
-  m1 = Ref(derived);
-  EXPECT_TRUE(m1.Matches(derived));
-  EXPECT_FALSE(m1.Matches(base));
-  EXPECT_FALSE(m1.Matches(base2));
-}
-
-TEST(RefTest, ExplainsResult) {
-  int n = 0;
-  EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), n),
-              StartsWith("which is located @"));
-
-  int m = 0;
-  EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), m),
-              StartsWith("which is located @"));
-}
-
-// Tests string comparison matchers.
-
-TEST(StrEqTest, MatchesEqualString) {
-  Matcher<const char*> m = StrEq(string("Hello"));
-  EXPECT_TRUE(m.Matches("Hello"));
-  EXPECT_FALSE(m.Matches("hello"));
-  EXPECT_FALSE(m.Matches(NULL));
-
-  Matcher<const string&> m2 = StrEq("Hello");
-  EXPECT_TRUE(m2.Matches("Hello"));
-  EXPECT_FALSE(m2.Matches("Hi"));
-}
-
-TEST(StrEqTest, CanDescribeSelf) {
-  Matcher<string> m = StrEq("Hi-\'\"?\\\a\b\f\n\r\t\v\xD3");
-  EXPECT_EQ("is equal to \"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\\xD3\"",
-      Describe(m));
-
-  string str("01204500800");
-  str[3] = '\0';
-  Matcher<string> m2 = StrEq(str);
-  EXPECT_EQ("is equal to \"012\\04500800\"", Describe(m2));
-  str[0] = str[6] = str[7] = str[9] = str[10] = '\0';
-  Matcher<string> m3 = StrEq(str);
-  EXPECT_EQ("is equal to \"\\012\\045\\0\\08\\0\\0\"", Describe(m3));
-}
-
-TEST(StrNeTest, MatchesUnequalString) {
-  Matcher<const char*> m = StrNe("Hello");
-  EXPECT_TRUE(m.Matches(""));
-  EXPECT_TRUE(m.Matches(NULL));
-  EXPECT_FALSE(m.Matches("Hello"));
-
-  Matcher<string> m2 = StrNe(string("Hello"));
-  EXPECT_TRUE(m2.Matches("hello"));
-  EXPECT_FALSE(m2.Matches("Hello"));
-}
-
-TEST(StrNeTest, CanDescribeSelf) {
-  Matcher<const char*> m = StrNe("Hi");
-  EXPECT_EQ("isn't equal to \"Hi\"", Describe(m));
-}
-
-TEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) {
-  Matcher<const char*> m = StrCaseEq(string("Hello"));
-  EXPECT_TRUE(m.Matches("Hello"));
-  EXPECT_TRUE(m.Matches("hello"));
-  EXPECT_FALSE(m.Matches("Hi"));
-  EXPECT_FALSE(m.Matches(NULL));
-
-  Matcher<const string&> m2 = StrCaseEq("Hello");
-  EXPECT_TRUE(m2.Matches("hello"));
-  EXPECT_FALSE(m2.Matches("Hi"));
-}
-
-TEST(StrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
-  string str1("oabocdooeoo");
-  string str2("OABOCDOOEOO");
-  Matcher<const string&> m0 = StrCaseEq(str1);
-  EXPECT_FALSE(m0.Matches(str2 + string(1, '\0')));
-
-  str1[3] = str2[3] = '\0';
-  Matcher<const string&> m1 = StrCaseEq(str1);
-  EXPECT_TRUE(m1.Matches(str2));
-
-  str1[0] = str1[6] = str1[7] = str1[10] = '\0';
-  str2[0] = str2[6] = str2[7] = str2[10] = '\0';
-  Matcher<const string&> m2 = StrCaseEq(str1);
-  str1[9] = str2[9] = '\0';
-  EXPECT_FALSE(m2.Matches(str2));
-
-  Matcher<const string&> m3 = StrCaseEq(str1);
-  EXPECT_TRUE(m3.Matches(str2));
-
-  EXPECT_FALSE(m3.Matches(str2 + "x"));
-  str2.append(1, '\0');
-  EXPECT_FALSE(m3.Matches(str2));
-  EXPECT_FALSE(m3.Matches(string(str2, 0, 9)));
-}
-
-TEST(StrCaseEqTest, CanDescribeSelf) {
-  Matcher<string> m = StrCaseEq("Hi");
-  EXPECT_EQ("is equal to (ignoring case) \"Hi\"", Describe(m));
-}
-
-TEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) {
-  Matcher<const char*> m = StrCaseNe("Hello");
-  EXPECT_TRUE(m.Matches("Hi"));
-  EXPECT_TRUE(m.Matches(NULL));
-  EXPECT_FALSE(m.Matches("Hello"));
-  EXPECT_FALSE(m.Matches("hello"));
-
-  Matcher<string> m2 = StrCaseNe(string("Hello"));
-  EXPECT_TRUE(m2.Matches(""));
-  EXPECT_FALSE(m2.Matches("Hello"));
-}
-
-TEST(StrCaseNeTest, CanDescribeSelf) {
-  Matcher<const char*> m = StrCaseNe("Hi");
-  EXPECT_EQ("isn't equal to (ignoring case) \"Hi\"", Describe(m));
-}
-
-// Tests that HasSubstr() works for matching string-typed values.
-TEST(HasSubstrTest, WorksForStringClasses) {
-  const Matcher<string> m1 = HasSubstr("foo");
-  EXPECT_TRUE(m1.Matches(string("I love food.")));
-  EXPECT_FALSE(m1.Matches(string("tofo")));
-
-  const Matcher<const std::string&> m2 = HasSubstr("foo");
-  EXPECT_TRUE(m2.Matches(std::string("I love food.")));
-  EXPECT_FALSE(m2.Matches(std::string("tofo")));
-}
-
-// Tests that HasSubstr() works for matching C-string-typed values.
-TEST(HasSubstrTest, WorksForCStrings) {
-  const Matcher<char*> m1 = HasSubstr("foo");
-  EXPECT_TRUE(m1.Matches(const_cast<char*>("I love food.")));
-  EXPECT_FALSE(m1.Matches(const_cast<char*>("tofo")));
-  EXPECT_FALSE(m1.Matches(NULL));
-
-  const Matcher<const char*> m2 = HasSubstr("foo");
-  EXPECT_TRUE(m2.Matches("I love food."));
-  EXPECT_FALSE(m2.Matches("tofo"));
-  EXPECT_FALSE(m2.Matches(NULL));
-}
-
-// Tests that HasSubstr(s) describes itself properly.
-TEST(HasSubstrTest, CanDescribeSelf) {
-  Matcher<string> m = HasSubstr("foo\n\"");
-  EXPECT_EQ("has substring \"foo\\n\\\"\"", Describe(m));
-}
-
-TEST(KeyTest, CanDescribeSelf) {
-  Matcher<const pair<std::string, int>&> m = Key("foo");
-  EXPECT_EQ("has a key that is equal to \"foo\"", Describe(m));
-  EXPECT_EQ("doesn't have a key that is equal to \"foo\"", DescribeNegation(m));
-}
-
-TEST(KeyTest, ExplainsResult) {
-  Matcher<pair<int, bool> > m = Key(GreaterThan(10));
-  EXPECT_EQ("whose first field is a value which is 5 less than 10",
-            Explain(m, make_pair(5, true)));
-  EXPECT_EQ("whose first field is a value which is 5 more than 10",
-            Explain(m, make_pair(15, true)));
-}
-
-TEST(KeyTest, MatchesCorrectly) {
-  pair<int, std::string> p(25, "foo");
-  EXPECT_THAT(p, Key(25));
-  EXPECT_THAT(p, Not(Key(42)));
-  EXPECT_THAT(p, Key(Ge(20)));
-  EXPECT_THAT(p, Not(Key(Lt(25))));
-}
-
-TEST(KeyTest, SafelyCastsInnerMatcher) {
-  Matcher<int> is_positive = Gt(0);
-  Matcher<int> is_negative = Lt(0);
-  pair<char, bool> p('a', true);
-  EXPECT_THAT(p, Key(is_positive));
-  EXPECT_THAT(p, Not(Key(is_negative)));
-}
-
-TEST(KeyTest, InsideContainsUsingMap) {
-  map<int, char> container;
-  container.insert(make_pair(1, 'a'));
-  container.insert(make_pair(2, 'b'));
-  container.insert(make_pair(4, 'c'));
-  EXPECT_THAT(container, Contains(Key(1)));
-  EXPECT_THAT(container, Not(Contains(Key(3))));
-}
-
-TEST(KeyTest, InsideContainsUsingMultimap) {
-  multimap<int, char> container;
-  container.insert(make_pair(1, 'a'));
-  container.insert(make_pair(2, 'b'));
-  container.insert(make_pair(4, 'c'));
-
-  EXPECT_THAT(container, Not(Contains(Key(25))));
-  container.insert(make_pair(25, 'd'));
-  EXPECT_THAT(container, Contains(Key(25)));
-  container.insert(make_pair(25, 'e'));
-  EXPECT_THAT(container, Contains(Key(25)));
-
-  EXPECT_THAT(container, Contains(Key(1)));
-  EXPECT_THAT(container, Not(Contains(Key(3))));
-}
-
-TEST(PairTest, Typing) {
-  // Test verifies the following type conversions can be compiled.
-  Matcher<const pair<const char*, int>&> m1 = Pair("foo", 42);
-  Matcher<const pair<const char*, int> > m2 = Pair("foo", 42);
-  Matcher<pair<const char*, int> > m3 = Pair("foo", 42);
-
-  Matcher<pair<int, const std::string> > m4 = Pair(25, "42");
-  Matcher<pair<const std::string, int> > m5 = Pair("25", 42);
-}
-
-TEST(PairTest, CanDescribeSelf) {
-  Matcher<const pair<std::string, int>&> m1 = Pair("foo", 42);
-  EXPECT_EQ("has a first field that is equal to \"foo\""
-            ", and has a second field that is equal to 42",
-            Describe(m1));
-  EXPECT_EQ("has a first field that isn't equal to \"foo\""
-            ", or has a second field that isn't equal to 42",
-            DescribeNegation(m1));
-  // Double and triple negation (1 or 2 times not and description of negation).
-  Matcher<const pair<int, int>&> m2 = Not(Pair(Not(13), 42));
-  EXPECT_EQ("has a first field that isn't equal to 13"
-            ", and has a second field that is equal to 42",
-            DescribeNegation(m2));
-}
-
-TEST(PairTest, CanExplainMatchResultTo) {
-  // If neither field matches, Pair() should explain about the first
-  // field.
-  const Matcher<pair<int, int> > m = Pair(GreaterThan(0), GreaterThan(0));
-  EXPECT_EQ("whose first field does not match, which is 1 less than 0",
-            Explain(m, make_pair(-1, -2)));
-
-  // If the first field matches but the second doesn't, Pair() should
-  // explain about the second field.
-  EXPECT_EQ("whose second field does not match, which is 2 less than 0",
-            Explain(m, make_pair(1, -2)));
-
-  // If the first field doesn't match but the second does, Pair()
-  // should explain about the first field.
-  EXPECT_EQ("whose first field does not match, which is 1 less than 0",
-            Explain(m, make_pair(-1, 2)));
-
-  // If both fields match, Pair() should explain about them both.
-  EXPECT_EQ("whose both fields match, where the first field is a value "
-            "which is 1 more than 0, and the second field is a value "
-            "which is 2 more than 0",
-            Explain(m, make_pair(1, 2)));
-
-  // If only the first match has an explanation, only this explanation should
-  // be printed.
-  const Matcher<pair<int, int> > explain_first = Pair(GreaterThan(0), 0);
-  EXPECT_EQ("whose both fields match, where the first field is a value "
-            "which is 1 more than 0",
-            Explain(explain_first, make_pair(1, 0)));
-
-  // If only the second match has an explanation, only this explanation should
-  // be printed.
-  const Matcher<pair<int, int> > explain_second = Pair(0, GreaterThan(0));
-  EXPECT_EQ("whose both fields match, where the second field is a value "
-            "which is 1 more than 0",
-            Explain(explain_second, make_pair(0, 1)));
-}
-
-TEST(PairTest, MatchesCorrectly) {
-  pair<int, std::string> p(25, "foo");
-
-  // Both fields match.
-  EXPECT_THAT(p, Pair(25, "foo"));
-  EXPECT_THAT(p, Pair(Ge(20), HasSubstr("o")));
-
-  // 'first' doesnt' match, but 'second' matches.
-  EXPECT_THAT(p, Not(Pair(42, "foo")));
-  EXPECT_THAT(p, Not(Pair(Lt(25), "foo")));
-
-  // 'first' matches, but 'second' doesn't match.
-  EXPECT_THAT(p, Not(Pair(25, "bar")));
-  EXPECT_THAT(p, Not(Pair(25, Not("foo"))));
-
-  // Neither field matches.
-  EXPECT_THAT(p, Not(Pair(13, "bar")));
-  EXPECT_THAT(p, Not(Pair(Lt(13), HasSubstr("a"))));
-}
-
-TEST(PairTest, SafelyCastsInnerMatchers) {
-  Matcher<int> is_positive = Gt(0);
-  Matcher<int> is_negative = Lt(0);
-  pair<char, bool> p('a', true);
-  EXPECT_THAT(p, Pair(is_positive, _));
-  EXPECT_THAT(p, Not(Pair(is_negative, _)));
-  EXPECT_THAT(p, Pair(_, is_positive));
-  EXPECT_THAT(p, Not(Pair(_, is_negative)));
-}
-
-TEST(PairTest, InsideContainsUsingMap) {
-  map<int, char> container;
-  container.insert(make_pair(1, 'a'));
-  container.insert(make_pair(2, 'b'));
-  container.insert(make_pair(4, 'c'));
-  EXPECT_THAT(container, Contains(Pair(1, 'a')));
-  EXPECT_THAT(container, Contains(Pair(1, _)));
-  EXPECT_THAT(container, Contains(Pair(_, 'a')));
-  EXPECT_THAT(container, Not(Contains(Pair(3, _))));
-}
-
-// Tests StartsWith(s).
-
-TEST(StartsWithTest, MatchesStringWithGivenPrefix) {
-  const Matcher<const char*> m1 = StartsWith(string(""));
-  EXPECT_TRUE(m1.Matches("Hi"));
-  EXPECT_TRUE(m1.Matches(""));
-  EXPECT_FALSE(m1.Matches(NULL));
-
-  const Matcher<const string&> m2 = StartsWith("Hi");
-  EXPECT_TRUE(m2.Matches("Hi"));
-  EXPECT_TRUE(m2.Matches("Hi Hi!"));
-  EXPECT_TRUE(m2.Matches("High"));
-  EXPECT_FALSE(m2.Matches("H"));
-  EXPECT_FALSE(m2.Matches(" Hi"));
-}
-
-TEST(StartsWithTest, CanDescribeSelf) {
-  Matcher<const std::string> m = StartsWith("Hi");
-  EXPECT_EQ("starts with \"Hi\"", Describe(m));
-}
-
-// Tests EndsWith(s).
-
-TEST(EndsWithTest, MatchesStringWithGivenSuffix) {
-  const Matcher<const char*> m1 = EndsWith("");
-  EXPECT_TRUE(m1.Matches("Hi"));
-  EXPECT_TRUE(m1.Matches(""));
-  EXPECT_FALSE(m1.Matches(NULL));
-
-  const Matcher<const string&> m2 = EndsWith(string("Hi"));
-  EXPECT_TRUE(m2.Matches("Hi"));
-  EXPECT_TRUE(m2.Matches("Wow Hi Hi"));
-  EXPECT_TRUE(m2.Matches("Super Hi"));
-  EXPECT_FALSE(m2.Matches("i"));
-  EXPECT_FALSE(m2.Matches("Hi "));
-}
-
-TEST(EndsWithTest, CanDescribeSelf) {
-  Matcher<const std::string> m = EndsWith("Hi");
-  EXPECT_EQ("ends with \"Hi\"", Describe(m));
-}
-
-// Tests MatchesRegex().
-
-TEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) {
-  const Matcher<const char*> m1 = MatchesRegex("a.*z");
-  EXPECT_TRUE(m1.Matches("az"));
-  EXPECT_TRUE(m1.Matches("abcz"));
-  EXPECT_FALSE(m1.Matches(NULL));
-
-  const Matcher<const string&> m2 = MatchesRegex(new RE("a.*z"));
-  EXPECT_TRUE(m2.Matches("azbz"));
-  EXPECT_FALSE(m2.Matches("az1"));
-  EXPECT_FALSE(m2.Matches("1az"));
-}
-
-TEST(MatchesRegexTest, CanDescribeSelf) {
-  Matcher<const std::string> m1 = MatchesRegex(string("Hi.*"));
-  EXPECT_EQ("matches regular expression \"Hi.*\"", Describe(m1));
-
-  Matcher<const char*> m2 = MatchesRegex(new RE("a.*"));
-  EXPECT_EQ("matches regular expression \"a.*\"", Describe(m2));
-}
-
-// Tests ContainsRegex().
-
-TEST(ContainsRegexTest, MatchesStringContainingGivenRegex) {
-  const Matcher<const char*> m1 = ContainsRegex(string("a.*z"));
-  EXPECT_TRUE(m1.Matches("az"));
-  EXPECT_TRUE(m1.Matches("0abcz1"));
-  EXPECT_FALSE(m1.Matches(NULL));
-
-  const Matcher<const string&> m2 = ContainsRegex(new RE("a.*z"));
-  EXPECT_TRUE(m2.Matches("azbz"));
-  EXPECT_TRUE(m2.Matches("az1"));
-  EXPECT_FALSE(m2.Matches("1a"));
-}
-
-TEST(ContainsRegexTest, CanDescribeSelf) {
-  Matcher<const std::string> m1 = ContainsRegex("Hi.*");
-  EXPECT_EQ("contains regular expression \"Hi.*\"", Describe(m1));
-
-  Matcher<const char*> m2 = ContainsRegex(new RE("a.*"));
-  EXPECT_EQ("contains regular expression \"a.*\"", Describe(m2));
-}
-
-// Tests for wide strings.
-#if GTEST_HAS_STD_WSTRING
-TEST(StdWideStrEqTest, MatchesEqual) {
-  Matcher<const wchar_t*> m = StrEq(::std::wstring(L"Hello"));
-  EXPECT_TRUE(m.Matches(L"Hello"));
-  EXPECT_FALSE(m.Matches(L"hello"));
-  EXPECT_FALSE(m.Matches(NULL));
-
-  Matcher<const ::std::wstring&> m2 = StrEq(L"Hello");
-  EXPECT_TRUE(m2.Matches(L"Hello"));
-  EXPECT_FALSE(m2.Matches(L"Hi"));
-
-  Matcher<const ::std::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D");
-  EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D"));
-  EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E"));
-
-  ::std::wstring str(L"01204500800");
-  str[3] = L'\0';
-  Matcher<const ::std::wstring&> m4 = StrEq(str);
-  EXPECT_TRUE(m4.Matches(str));
-  str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
-  Matcher<const ::std::wstring&> m5 = StrEq(str);
-  EXPECT_TRUE(m5.Matches(str));
-}
-
-TEST(StdWideStrEqTest, CanDescribeSelf) {
-  Matcher< ::std::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v");
-  EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"",
-    Describe(m));
-
-  Matcher< ::std::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D");
-  EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"",
-    Describe(m2));
-
-  ::std::wstring str(L"01204500800");
-  str[3] = L'\0';
-  Matcher<const ::std::wstring&> m4 = StrEq(str);
-  EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4));
-  str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
-  Matcher<const ::std::wstring&> m5 = StrEq(str);
-  EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5));
-}
-
-TEST(StdWideStrNeTest, MatchesUnequalString) {
-  Matcher<const wchar_t*> m = StrNe(L"Hello");
-  EXPECT_TRUE(m.Matches(L""));
-  EXPECT_TRUE(m.Matches(NULL));
-  EXPECT_FALSE(m.Matches(L"Hello"));
-
-  Matcher< ::std::wstring> m2 = StrNe(::std::wstring(L"Hello"));
-  EXPECT_TRUE(m2.Matches(L"hello"));
-  EXPECT_FALSE(m2.Matches(L"Hello"));
-}
-
-TEST(StdWideStrNeTest, CanDescribeSelf) {
-  Matcher<const wchar_t*> m = StrNe(L"Hi");
-  EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m));
-}
-
-TEST(StdWideStrCaseEqTest, MatchesEqualStringIgnoringCase) {
-  Matcher<const wchar_t*> m = StrCaseEq(::std::wstring(L"Hello"));
-  EXPECT_TRUE(m.Matches(L"Hello"));
-  EXPECT_TRUE(m.Matches(L"hello"));
-  EXPECT_FALSE(m.Matches(L"Hi"));
-  EXPECT_FALSE(m.Matches(NULL));
-
-  Matcher<const ::std::wstring&> m2 = StrCaseEq(L"Hello");
-  EXPECT_TRUE(m2.Matches(L"hello"));
-  EXPECT_FALSE(m2.Matches(L"Hi"));
-}
-
-TEST(StdWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
-  ::std::wstring str1(L"oabocdooeoo");
-  ::std::wstring str2(L"OABOCDOOEOO");
-  Matcher<const ::std::wstring&> m0 = StrCaseEq(str1);
-  EXPECT_FALSE(m0.Matches(str2 + ::std::wstring(1, L'\0')));
-
-  str1[3] = str2[3] = L'\0';
-  Matcher<const ::std::wstring&> m1 = StrCaseEq(str1);
-  EXPECT_TRUE(m1.Matches(str2));
-
-  str1[0] = str1[6] = str1[7] = str1[10] = L'\0';
-  str2[0] = str2[6] = str2[7] = str2[10] = L'\0';
-  Matcher<const ::std::wstring&> m2 = StrCaseEq(str1);
-  str1[9] = str2[9] = L'\0';
-  EXPECT_FALSE(m2.Matches(str2));
-
-  Matcher<const ::std::wstring&> m3 = StrCaseEq(str1);
-  EXPECT_TRUE(m3.Matches(str2));
-
-  EXPECT_FALSE(m3.Matches(str2 + L"x"));
-  str2.append(1, L'\0');
-  EXPECT_FALSE(m3.Matches(str2));
-  EXPECT_FALSE(m3.Matches(::std::wstring(str2, 0, 9)));
-}
-
-TEST(StdWideStrCaseEqTest, CanDescribeSelf) {
-  Matcher< ::std::wstring> m = StrCaseEq(L"Hi");
-  EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m));
-}
-
-TEST(StdWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) {
-  Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
-  EXPECT_TRUE(m.Matches(L"Hi"));
-  EXPECT_TRUE(m.Matches(NULL));
-  EXPECT_FALSE(m.Matches(L"Hello"));
-  EXPECT_FALSE(m.Matches(L"hello"));
-
-  Matcher< ::std::wstring> m2 = StrCaseNe(::std::wstring(L"Hello"));
-  EXPECT_TRUE(m2.Matches(L""));
-  EXPECT_FALSE(m2.Matches(L"Hello"));
-}
-
-TEST(StdWideStrCaseNeTest, CanDescribeSelf) {
-  Matcher<const wchar_t*> m = StrCaseNe(L"Hi");
-  EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m));
-}
-
-// Tests that HasSubstr() works for matching wstring-typed values.
-TEST(StdWideHasSubstrTest, WorksForStringClasses) {
-  const Matcher< ::std::wstring> m1 = HasSubstr(L"foo");
-  EXPECT_TRUE(m1.Matches(::std::wstring(L"I love food.")));
-  EXPECT_FALSE(m1.Matches(::std::wstring(L"tofo")));
-
-  const Matcher<const ::std::wstring&> m2 = HasSubstr(L"foo");
-  EXPECT_TRUE(m2.Matches(::std::wstring(L"I love food.")));
-  EXPECT_FALSE(m2.Matches(::std::wstring(L"tofo")));
-}
-
-// Tests that HasSubstr() works for matching C-wide-string-typed values.
-TEST(StdWideHasSubstrTest, WorksForCStrings) {
-  const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
-  EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food.")));
-  EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo")));
-  EXPECT_FALSE(m1.Matches(NULL));
-
-  const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
-  EXPECT_TRUE(m2.Matches(L"I love food."));
-  EXPECT_FALSE(m2.Matches(L"tofo"));
-  EXPECT_FALSE(m2.Matches(NULL));
-}
-
-// Tests that HasSubstr(s) describes itself properly.
-TEST(StdWideHasSubstrTest, CanDescribeSelf) {
-  Matcher< ::std::wstring> m = HasSubstr(L"foo\n\"");
-  EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m));
-}
-
-// Tests StartsWith(s).
-
-TEST(StdWideStartsWithTest, MatchesStringWithGivenPrefix) {
-  const Matcher<const wchar_t*> m1 = StartsWith(::std::wstring(L""));
-  EXPECT_TRUE(m1.Matches(L"Hi"));
-  EXPECT_TRUE(m1.Matches(L""));
-  EXPECT_FALSE(m1.Matches(NULL));
-
-  const Matcher<const ::std::wstring&> m2 = StartsWith(L"Hi");
-  EXPECT_TRUE(m2.Matches(L"Hi"));
-  EXPECT_TRUE(m2.Matches(L"Hi Hi!"));
-  EXPECT_TRUE(m2.Matches(L"High"));
-  EXPECT_FALSE(m2.Matches(L"H"));
-  EXPECT_FALSE(m2.Matches(L" Hi"));
-}
-
-TEST(StdWideStartsWithTest, CanDescribeSelf) {
-  Matcher<const ::std::wstring> m = StartsWith(L"Hi");
-  EXPECT_EQ("starts with L\"Hi\"", Describe(m));
-}
-
-// Tests EndsWith(s).
-
-TEST(StdWideEndsWithTest, MatchesStringWithGivenSuffix) {
-  const Matcher<const wchar_t*> m1 = EndsWith(L"");
-  EXPECT_TRUE(m1.Matches(L"Hi"));
-  EXPECT_TRUE(m1.Matches(L""));
-  EXPECT_FALSE(m1.Matches(NULL));
-
-  const Matcher<const ::std::wstring&> m2 = EndsWith(::std::wstring(L"Hi"));
-  EXPECT_TRUE(m2.Matches(L"Hi"));
-  EXPECT_TRUE(m2.Matches(L"Wow Hi Hi"));
-  EXPECT_TRUE(m2.Matches(L"Super Hi"));
-  EXPECT_FALSE(m2.Matches(L"i"));
-  EXPECT_FALSE(m2.Matches(L"Hi "));
-}
-
-TEST(StdWideEndsWithTest, CanDescribeSelf) {
-  Matcher<const ::std::wstring> m = EndsWith(L"Hi");
-  EXPECT_EQ("ends with L\"Hi\"", Describe(m));
-}
-
-#endif  // GTEST_HAS_STD_WSTRING
-
-#if GTEST_HAS_GLOBAL_WSTRING
-TEST(GlobalWideStrEqTest, MatchesEqual) {
-  Matcher<const wchar_t*> m = StrEq(::wstring(L"Hello"));
-  EXPECT_TRUE(m.Matches(L"Hello"));
-  EXPECT_FALSE(m.Matches(L"hello"));
-  EXPECT_FALSE(m.Matches(NULL));
-
-  Matcher<const ::wstring&> m2 = StrEq(L"Hello");
-  EXPECT_TRUE(m2.Matches(L"Hello"));
-  EXPECT_FALSE(m2.Matches(L"Hi"));
-
-  Matcher<const ::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D");
-  EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D"));
-  EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E"));
-
-  ::wstring str(L"01204500800");
-  str[3] = L'\0';
-  Matcher<const ::wstring&> m4 = StrEq(str);
-  EXPECT_TRUE(m4.Matches(str));
-  str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
-  Matcher<const ::wstring&> m5 = StrEq(str);
-  EXPECT_TRUE(m5.Matches(str));
-}
-
-TEST(GlobalWideStrEqTest, CanDescribeSelf) {
-  Matcher< ::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v");
-  EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"",
-    Describe(m));
-
-  Matcher< ::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D");
-  EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"",
-    Describe(m2));
-
-  ::wstring str(L"01204500800");
-  str[3] = L'\0';
-  Matcher<const ::wstring&> m4 = StrEq(str);
-  EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4));
-  str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
-  Matcher<const ::wstring&> m5 = StrEq(str);
-  EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5));
-}
-
-TEST(GlobalWideStrNeTest, MatchesUnequalString) {
-  Matcher<const wchar_t*> m = StrNe(L"Hello");
-  EXPECT_TRUE(m.Matches(L""));
-  EXPECT_TRUE(m.Matches(NULL));
-  EXPECT_FALSE(m.Matches(L"Hello"));
-
-  Matcher< ::wstring> m2 = StrNe(::wstring(L"Hello"));
-  EXPECT_TRUE(m2.Matches(L"hello"));
-  EXPECT_FALSE(m2.Matches(L"Hello"));
-}
-
-TEST(GlobalWideStrNeTest, CanDescribeSelf) {
-  Matcher<const wchar_t*> m = StrNe(L"Hi");
-  EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m));
-}
-
-TEST(GlobalWideStrCaseEqTest, MatchesEqualStringIgnoringCase) {
-  Matcher<const wchar_t*> m = StrCaseEq(::wstring(L"Hello"));
-  EXPECT_TRUE(m.Matches(L"Hello"));
-  EXPECT_TRUE(m.Matches(L"hello"));
-  EXPECT_FALSE(m.Matches(L"Hi"));
-  EXPECT_FALSE(m.Matches(NULL));
-
-  Matcher<const ::wstring&> m2 = StrCaseEq(L"Hello");
-  EXPECT_TRUE(m2.Matches(L"hello"));
-  EXPECT_FALSE(m2.Matches(L"Hi"));
-}
-
-TEST(GlobalWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
-  ::wstring str1(L"oabocdooeoo");
-  ::wstring str2(L"OABOCDOOEOO");
-  Matcher<const ::wstring&> m0 = StrCaseEq(str1);
-  EXPECT_FALSE(m0.Matches(str2 + ::wstring(1, L'\0')));
-
-  str1[3] = str2[3] = L'\0';
-  Matcher<const ::wstring&> m1 = StrCaseEq(str1);
-  EXPECT_TRUE(m1.Matches(str2));
-
-  str1[0] = str1[6] = str1[7] = str1[10] = L'\0';
-  str2[0] = str2[6] = str2[7] = str2[10] = L'\0';
-  Matcher<const ::wstring&> m2 = StrCaseEq(str1);
-  str1[9] = str2[9] = L'\0';
-  EXPECT_FALSE(m2.Matches(str2));
-
-  Matcher<const ::wstring&> m3 = StrCaseEq(str1);
-  EXPECT_TRUE(m3.Matches(str2));
-
-  EXPECT_FALSE(m3.Matches(str2 + L"x"));
-  str2.append(1, L'\0');
-  EXPECT_FALSE(m3.Matches(str2));
-  EXPECT_FALSE(m3.Matches(::wstring(str2, 0, 9)));
-}
-
-TEST(GlobalWideStrCaseEqTest, CanDescribeSelf) {
-  Matcher< ::wstring> m = StrCaseEq(L"Hi");
-  EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m));
-}
-
-TEST(GlobalWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) {
-  Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
-  EXPECT_TRUE(m.Matches(L"Hi"));
-  EXPECT_TRUE(m.Matches(NULL));
-  EXPECT_FALSE(m.Matches(L"Hello"));
-  EXPECT_FALSE(m.Matches(L"hello"));
-
-  Matcher< ::wstring> m2 = StrCaseNe(::wstring(L"Hello"));
-  EXPECT_TRUE(m2.Matches(L""));
-  EXPECT_FALSE(m2.Matches(L"Hello"));
-}
-
-TEST(GlobalWideStrCaseNeTest, CanDescribeSelf) {
-  Matcher<const wchar_t*> m = StrCaseNe(L"Hi");
-  EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m));
-}
-
-// Tests that HasSubstr() works for matching wstring-typed values.
-TEST(GlobalWideHasSubstrTest, WorksForStringClasses) {
-  const Matcher< ::wstring> m1 = HasSubstr(L"foo");
-  EXPECT_TRUE(m1.Matches(::wstring(L"I love food.")));
-  EXPECT_FALSE(m1.Matches(::wstring(L"tofo")));
-
-  const Matcher<const ::wstring&> m2 = HasSubstr(L"foo");
-  EXPECT_TRUE(m2.Matches(::wstring(L"I love food.")));
-  EXPECT_FALSE(m2.Matches(::wstring(L"tofo")));
-}
-
-// Tests that HasSubstr() works for matching C-wide-string-typed values.
-TEST(GlobalWideHasSubstrTest, WorksForCStrings) {
-  const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
-  EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food.")));
-  EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo")));
-  EXPECT_FALSE(m1.Matches(NULL));
-
-  const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
-  EXPECT_TRUE(m2.Matches(L"I love food."));
-  EXPECT_FALSE(m2.Matches(L"tofo"));
-  EXPECT_FALSE(m2.Matches(NULL));
-}
-
-// Tests that HasSubstr(s) describes itself properly.
-TEST(GlobalWideHasSubstrTest, CanDescribeSelf) {
-  Matcher< ::wstring> m = HasSubstr(L"foo\n\"");
-  EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m));
-}
-
-// Tests StartsWith(s).
-
-TEST(GlobalWideStartsWithTest, MatchesStringWithGivenPrefix) {
-  const Matcher<const wchar_t*> m1 = StartsWith(::wstring(L""));
-  EXPECT_TRUE(m1.Matches(L"Hi"));
-  EXPECT_TRUE(m1.Matches(L""));
-  EXPECT_FALSE(m1.Matches(NULL));
-
-  const Matcher<const ::wstring&> m2 = StartsWith(L"Hi");
-  EXPECT_TRUE(m2.Matches(L"Hi"));
-  EXPECT_TRUE(m2.Matches(L"Hi Hi!"));
-  EXPECT_TRUE(m2.Matches(L"High"));
-  EXPECT_FALSE(m2.Matches(L"H"));
-  EXPECT_FALSE(m2.Matches(L" Hi"));
-}
-
-TEST(GlobalWideStartsWithTest, CanDescribeSelf) {
-  Matcher<const ::wstring> m = StartsWith(L"Hi");
-  EXPECT_EQ("starts with L\"Hi\"", Describe(m));
-}
-
-// Tests EndsWith(s).
-
-TEST(GlobalWideEndsWithTest, MatchesStringWithGivenSuffix) {
-  const Matcher<const wchar_t*> m1 = EndsWith(L"");
-  EXPECT_TRUE(m1.Matches(L"Hi"));
-  EXPECT_TRUE(m1.Matches(L""));
-  EXPECT_FALSE(m1.Matches(NULL));
-
-  const Matcher<const ::wstring&> m2 = EndsWith(::wstring(L"Hi"));
-  EXPECT_TRUE(m2.Matches(L"Hi"));
-  EXPECT_TRUE(m2.Matches(L"Wow Hi Hi"));
-  EXPECT_TRUE(m2.Matches(L"Super Hi"));
-  EXPECT_FALSE(m2.Matches(L"i"));
-  EXPECT_FALSE(m2.Matches(L"Hi "));
-}
-
-TEST(GlobalWideEndsWithTest, CanDescribeSelf) {
-  Matcher<const ::wstring> m = EndsWith(L"Hi");
-  EXPECT_EQ("ends with L\"Hi\"", Describe(m));
-}
-
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-
-typedef ::testing::tuple<long, int> Tuple2;  // NOLINT
-
-// Tests that Eq() matches a 2-tuple where the first field == the
-// second field.
-TEST(Eq2Test, MatchesEqualArguments) {
-  Matcher<const Tuple2&> m = Eq();
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
-}
-
-// Tests that Eq() describes itself properly.
-TEST(Eq2Test, CanDescribeSelf) {
-  Matcher<const Tuple2&> m = Eq();
-  EXPECT_EQ("are an equal pair", Describe(m));
-}
-
-// Tests that Ge() matches a 2-tuple where the first field >= the
-// second field.
-TEST(Ge2Test, MatchesGreaterThanOrEqualArguments) {
-  Matcher<const Tuple2&> m = Ge();
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
-}
-
-// Tests that Ge() describes itself properly.
-TEST(Ge2Test, CanDescribeSelf) {
-  Matcher<const Tuple2&> m = Ge();
-  EXPECT_EQ("are a pair where the first >= the second", Describe(m));
-}
-
-// Tests that Gt() matches a 2-tuple where the first field > the
-// second field.
-TEST(Gt2Test, MatchesGreaterThanArguments) {
-  Matcher<const Tuple2&> m = Gt();
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
-}
-
-// Tests that Gt() describes itself properly.
-TEST(Gt2Test, CanDescribeSelf) {
-  Matcher<const Tuple2&> m = Gt();
-  EXPECT_EQ("are a pair where the first > the second", Describe(m));
-}
-
-// Tests that Le() matches a 2-tuple where the first field <= the
-// second field.
-TEST(Le2Test, MatchesLessThanOrEqualArguments) {
-  Matcher<const Tuple2&> m = Le();
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
-}
-
-// Tests that Le() describes itself properly.
-TEST(Le2Test, CanDescribeSelf) {
-  Matcher<const Tuple2&> m = Le();
-  EXPECT_EQ("are a pair where the first <= the second", Describe(m));
-}
-
-// Tests that Lt() matches a 2-tuple where the first field < the
-// second field.
-TEST(Lt2Test, MatchesLessThanArguments) {
-  Matcher<const Tuple2&> m = Lt();
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
-}
-
-// Tests that Lt() describes itself properly.
-TEST(Lt2Test, CanDescribeSelf) {
-  Matcher<const Tuple2&> m = Lt();
-  EXPECT_EQ("are a pair where the first < the second", Describe(m));
-}
-
-// Tests that Ne() matches a 2-tuple where the first field != the
-// second field.
-TEST(Ne2Test, MatchesUnequalArguments) {
-  Matcher<const Tuple2&> m = Ne();
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
-}
-
-// Tests that Ne() describes itself properly.
-TEST(Ne2Test, CanDescribeSelf) {
-  Matcher<const Tuple2&> m = Ne();
-  EXPECT_EQ("are an unequal pair", Describe(m));
-}
-
-// Tests that Not(m) matches any value that doesn't match m.
-TEST(NotTest, NegatesMatcher) {
-  Matcher<int> m;
-  m = Not(Eq(2));
-  EXPECT_TRUE(m.Matches(3));
-  EXPECT_FALSE(m.Matches(2));
-}
-
-// Tests that Not(m) describes itself properly.
-TEST(NotTest, CanDescribeSelf) {
-  Matcher<int> m = Not(Eq(5));
-  EXPECT_EQ("isn't equal to 5", Describe(m));
-}
-
-// Tests that monomorphic matchers are safely cast by the Not matcher.
-TEST(NotTest, NotMatcherSafelyCastsMonomorphicMatchers) {
-  // greater_than_5 is a monomorphic matcher.
-  Matcher<int> greater_than_5 = Gt(5);
-
-  Matcher<const int&> m = Not(greater_than_5);
-  Matcher<int&> m2 = Not(greater_than_5);
-  Matcher<int&> m3 = Not(m);
-}
-
-// Helper to allow easy testing of AllOf matchers with num parameters.
-void AllOfMatches(int num, const Matcher<int>& m) {
-  SCOPED_TRACE(Describe(m));
-  EXPECT_TRUE(m.Matches(0));
-  for (int i = 1; i <= num; ++i) {
-    EXPECT_FALSE(m.Matches(i));
-  }
-  EXPECT_TRUE(m.Matches(num + 1));
-}
-
-// Tests that AllOf(m1, ..., mn) matches any value that matches all of
-// the given matchers.
-TEST(AllOfTest, MatchesWhenAllMatch) {
-  Matcher<int> m;
-  m = AllOf(Le(2), Ge(1));
-  EXPECT_TRUE(m.Matches(1));
-  EXPECT_TRUE(m.Matches(2));
-  EXPECT_FALSE(m.Matches(0));
-  EXPECT_FALSE(m.Matches(3));
-
-  m = AllOf(Gt(0), Ne(1), Ne(2));
-  EXPECT_TRUE(m.Matches(3));
-  EXPECT_FALSE(m.Matches(2));
-  EXPECT_FALSE(m.Matches(1));
-  EXPECT_FALSE(m.Matches(0));
-
-  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
-  EXPECT_TRUE(m.Matches(4));
-  EXPECT_FALSE(m.Matches(3));
-  EXPECT_FALSE(m.Matches(2));
-  EXPECT_FALSE(m.Matches(1));
-  EXPECT_FALSE(m.Matches(0));
-
-  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
-  EXPECT_TRUE(m.Matches(0));
-  EXPECT_TRUE(m.Matches(1));
-  EXPECT_FALSE(m.Matches(3));
-
-  // The following tests for varying number of sub-matchers. Due to the way
-  // the sub-matchers are handled it is enough to test every sub-matcher once
-  // with sub-matchers using the same matcher type. Varying matcher types are
-  // checked for above.
-  AllOfMatches(2, AllOf(Ne(1), Ne(2)));
-  AllOfMatches(3, AllOf(Ne(1), Ne(2), Ne(3)));
-  AllOfMatches(4, AllOf(Ne(1), Ne(2), Ne(3), Ne(4)));
-  AllOfMatches(5, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5)));
-  AllOfMatches(6, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6)));
-  AllOfMatches(7, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7)));
-  AllOfMatches(8, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7),
-                        Ne(8)));
-  AllOfMatches(9, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7),
-                        Ne(8), Ne(9)));
-  AllOfMatches(10, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
-                         Ne(9), Ne(10)));
-}
-
-#if GTEST_LANG_CXX11
-// Tests the variadic version of the AllOfMatcher.
-TEST(AllOfTest, VariadicMatchesWhenAllMatch) {
-  // Make sure AllOf is defined in the right namespace and does not depend on
-  // ADL.
-  ::testing::AllOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
-  Matcher<int> m = AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
-                         Ne(9), Ne(10), Ne(11));
-  EXPECT_THAT(Describe(m), EndsWith("and (isn't equal to 11))))))))))"));
-  AllOfMatches(11, m);
-  AllOfMatches(50, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
-                         Ne(9), Ne(10), Ne(11), Ne(12), Ne(13), Ne(14), Ne(15),
-                         Ne(16), Ne(17), Ne(18), Ne(19), Ne(20), Ne(21), Ne(22),
-                         Ne(23), Ne(24), Ne(25), Ne(26), Ne(27), Ne(28), Ne(29),
-                         Ne(30), Ne(31), Ne(32), Ne(33), Ne(34), Ne(35), Ne(36),
-                         Ne(37), Ne(38), Ne(39), Ne(40), Ne(41), Ne(42), Ne(43),
-                         Ne(44), Ne(45), Ne(46), Ne(47), Ne(48), Ne(49),
-                         Ne(50)));
-}
-
-#endif  // GTEST_LANG_CXX11
-
-// Tests that AllOf(m1, ..., mn) describes itself properly.
-TEST(AllOfTest, CanDescribeSelf) {
-  Matcher<int> m;
-  m = AllOf(Le(2), Ge(1));
-  EXPECT_EQ("(is <= 2) and (is >= 1)", Describe(m));
-
-  m = AllOf(Gt(0), Ne(1), Ne(2));
-  EXPECT_EQ("(is > 0) and "
-            "((isn't equal to 1) and "
-            "(isn't equal to 2))",
-            Describe(m));
-
-
-  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
-  EXPECT_EQ("((is > 0) and "
-            "(isn't equal to 1)) and "
-            "((isn't equal to 2) and "
-            "(isn't equal to 3))",
-            Describe(m));
-
-
-  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
-  EXPECT_EQ("((is >= 0) and "
-            "(is < 10)) and "
-            "((isn't equal to 3) and "
-            "((isn't equal to 5) and "
-            "(isn't equal to 7)))",
-            Describe(m));
-}
-
-// Tests that AllOf(m1, ..., mn) describes its negation properly.
-TEST(AllOfTest, CanDescribeNegation) {
-  Matcher<int> m;
-  m = AllOf(Le(2), Ge(1));
-  EXPECT_EQ("(isn't <= 2) or "
-            "(isn't >= 1)",
-            DescribeNegation(m));
-
-  m = AllOf(Gt(0), Ne(1), Ne(2));
-  EXPECT_EQ("(isn't > 0) or "
-            "((is equal to 1) or "
-            "(is equal to 2))",
-            DescribeNegation(m));
-
-
-  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
-  EXPECT_EQ("((isn't > 0) or "
-            "(is equal to 1)) or "
-            "((is equal to 2) or "
-            "(is equal to 3))",
-            DescribeNegation(m));
-
-
-  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
-  EXPECT_EQ("((isn't >= 0) or "
-            "(isn't < 10)) or "
-            "((is equal to 3) or "
-            "((is equal to 5) or "
-            "(is equal to 7)))",
-            DescribeNegation(m));
-}
-
-// Tests that monomorphic matchers are safely cast by the AllOf matcher.
-TEST(AllOfTest, AllOfMatcherSafelyCastsMonomorphicMatchers) {
-  // greater_than_5 and less_than_10 are monomorphic matchers.
-  Matcher<int> greater_than_5 = Gt(5);
-  Matcher<int> less_than_10 = Lt(10);
-
-  Matcher<const int&> m = AllOf(greater_than_5, less_than_10);
-  Matcher<int&> m2 = AllOf(greater_than_5, less_than_10);
-  Matcher<int&> m3 = AllOf(greater_than_5, m2);
-
-  // Tests that BothOf works when composing itself.
-  Matcher<const int&> m4 = AllOf(greater_than_5, less_than_10, less_than_10);
-  Matcher<int&> m5 = AllOf(greater_than_5, less_than_10, less_than_10);
-}
-
-TEST(AllOfTest, ExplainsResult) {
-  Matcher<int> m;
-
-  // Successful match.  Both matchers need to explain.  The second
-  // matcher doesn't give an explanation, so only the first matcher's
-  // explanation is printed.
-  m = AllOf(GreaterThan(10), Lt(30));
-  EXPECT_EQ("which is 15 more than 10", Explain(m, 25));
-
-  // Successful match.  Both matchers need to explain.
-  m = AllOf(GreaterThan(10), GreaterThan(20));
-  EXPECT_EQ("which is 20 more than 10, and which is 10 more than 20",
-            Explain(m, 30));
-
-  // Successful match.  All matchers need to explain.  The second
-  // matcher doesn't given an explanation.
-  m = AllOf(GreaterThan(10), Lt(30), GreaterThan(20));
-  EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20",
-            Explain(m, 25));
-
-  // Successful match.  All matchers need to explain.
-  m = AllOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
-  EXPECT_EQ("which is 30 more than 10, and which is 20 more than 20, "
-            "and which is 10 more than 30",
-            Explain(m, 40));
-
-  // Failed match.  The first matcher, which failed, needs to
-  // explain.
-  m = AllOf(GreaterThan(10), GreaterThan(20));
-  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
-
-  // Failed match.  The second matcher, which failed, needs to
-  // explain.  Since it doesn't given an explanation, nothing is
-  // printed.
-  m = AllOf(GreaterThan(10), Lt(30));
-  EXPECT_EQ("", Explain(m, 40));
-
-  // Failed match.  The second matcher, which failed, needs to
-  // explain.
-  m = AllOf(GreaterThan(10), GreaterThan(20));
-  EXPECT_EQ("which is 5 less than 20", Explain(m, 15));
-}
-
-// Helper to allow easy testing of AnyOf matchers with num parameters.
-void AnyOfMatches(int num, const Matcher<int>& m) {
-  SCOPED_TRACE(Describe(m));
-  EXPECT_FALSE(m.Matches(0));
-  for (int i = 1; i <= num; ++i) {
-    EXPECT_TRUE(m.Matches(i));
-  }
-  EXPECT_FALSE(m.Matches(num + 1));
-}
-
-// Tests that AnyOf(m1, ..., mn) matches any value that matches at
-// least one of the given matchers.
-TEST(AnyOfTest, MatchesWhenAnyMatches) {
-  Matcher<int> m;
-  m = AnyOf(Le(1), Ge(3));
-  EXPECT_TRUE(m.Matches(1));
-  EXPECT_TRUE(m.Matches(4));
-  EXPECT_FALSE(m.Matches(2));
-
-  m = AnyOf(Lt(0), Eq(1), Eq(2));
-  EXPECT_TRUE(m.Matches(-1));
-  EXPECT_TRUE(m.Matches(1));
-  EXPECT_TRUE(m.Matches(2));
-  EXPECT_FALSE(m.Matches(0));
-
-  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
-  EXPECT_TRUE(m.Matches(-1));
-  EXPECT_TRUE(m.Matches(1));
-  EXPECT_TRUE(m.Matches(2));
-  EXPECT_TRUE(m.Matches(3));
-  EXPECT_FALSE(m.Matches(0));
-
-  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
-  EXPECT_TRUE(m.Matches(0));
-  EXPECT_TRUE(m.Matches(11));
-  EXPECT_TRUE(m.Matches(3));
-  EXPECT_FALSE(m.Matches(2));
-
-  // The following tests for varying number of sub-matchers. Due to the way
-  // the sub-matchers are handled it is enough to test every sub-matcher once
-  // with sub-matchers using the same matcher type. Varying matcher types are
-  // checked for above.
-  AnyOfMatches(2, AnyOf(1, 2));
-  AnyOfMatches(3, AnyOf(1, 2, 3));
-  AnyOfMatches(4, AnyOf(1, 2, 3, 4));
-  AnyOfMatches(5, AnyOf(1, 2, 3, 4, 5));
-  AnyOfMatches(6, AnyOf(1, 2, 3, 4, 5, 6));
-  AnyOfMatches(7, AnyOf(1, 2, 3, 4, 5, 6, 7));
-  AnyOfMatches(8, AnyOf(1, 2, 3, 4, 5, 6, 7, 8));
-  AnyOfMatches(9, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9));
-  AnyOfMatches(10, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
-}
-
-#if GTEST_LANG_CXX11
-// Tests the variadic version of the AnyOfMatcher.
-TEST(AnyOfTest, VariadicMatchesWhenAnyMatches) {
-  // Also make sure AnyOf is defined in the right namespace and does not depend
-  // on ADL.
-  Matcher<int> m = ::testing::AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
-
-  EXPECT_THAT(Describe(m), EndsWith("or (is equal to 11))))))))))"));
-  AnyOfMatches(11, m);
-  AnyOfMatches(50, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
-                         11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-                         21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
-                         31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-                         41, 42, 43, 44, 45, 46, 47, 48, 49, 50));
-}
-
-#endif  // GTEST_LANG_CXX11
-
-// Tests that AnyOf(m1, ..., mn) describes itself properly.
-TEST(AnyOfTest, CanDescribeSelf) {
-  Matcher<int> m;
-  m = AnyOf(Le(1), Ge(3));
-  EXPECT_EQ("(is <= 1) or (is >= 3)",
-            Describe(m));
-
-  m = AnyOf(Lt(0), Eq(1), Eq(2));
-  EXPECT_EQ("(is < 0) or "
-            "((is equal to 1) or (is equal to 2))",
-            Describe(m));
-
-  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
-  EXPECT_EQ("((is < 0) or "
-            "(is equal to 1)) or "
-            "((is equal to 2) or "
-            "(is equal to 3))",
-            Describe(m));
-
-  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
-  EXPECT_EQ("((is <= 0) or "
-            "(is > 10)) or "
-            "((is equal to 3) or "
-            "((is equal to 5) or "
-            "(is equal to 7)))",
-            Describe(m));
-}
-
-// Tests that AnyOf(m1, ..., mn) describes its negation properly.
-TEST(AnyOfTest, CanDescribeNegation) {
-  Matcher<int> m;
-  m = AnyOf(Le(1), Ge(3));
-  EXPECT_EQ("(isn't <= 1) and (isn't >= 3)",
-            DescribeNegation(m));
-
-  m = AnyOf(Lt(0), Eq(1), Eq(2));
-  EXPECT_EQ("(isn't < 0) and "
-            "((isn't equal to 1) and (isn't equal to 2))",
-            DescribeNegation(m));
-
-  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
-  EXPECT_EQ("((isn't < 0) and "
-            "(isn't equal to 1)) and "
-            "((isn't equal to 2) and "
-            "(isn't equal to 3))",
-            DescribeNegation(m));
-
-  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
-  EXPECT_EQ("((isn't <= 0) and "
-            "(isn't > 10)) and "
-            "((isn't equal to 3) and "
-            "((isn't equal to 5) and "
-            "(isn't equal to 7)))",
-            DescribeNegation(m));
-}
-
-// Tests that monomorphic matchers are safely cast by the AnyOf matcher.
-TEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) {
-  // greater_than_5 and less_than_10 are monomorphic matchers.
-  Matcher<int> greater_than_5 = Gt(5);
-  Matcher<int> less_than_10 = Lt(10);
-
-  Matcher<const int&> m = AnyOf(greater_than_5, less_than_10);
-  Matcher<int&> m2 = AnyOf(greater_than_5, less_than_10);
-  Matcher<int&> m3 = AnyOf(greater_than_5, m2);
-
-  // Tests that EitherOf works when composing itself.
-  Matcher<const int&> m4 = AnyOf(greater_than_5, less_than_10, less_than_10);
-  Matcher<int&> m5 = AnyOf(greater_than_5, less_than_10, less_than_10);
-}
-
-TEST(AnyOfTest, ExplainsResult) {
-  Matcher<int> m;
-
-  // Failed match.  Both matchers need to explain.  The second
-  // matcher doesn't give an explanation, so only the first matcher's
-  // explanation is printed.
-  m = AnyOf(GreaterThan(10), Lt(0));
-  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
-
-  // Failed match.  Both matchers need to explain.
-  m = AnyOf(GreaterThan(10), GreaterThan(20));
-  EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20",
-            Explain(m, 5));
-
-  // Failed match.  All matchers need to explain.  The second
-  // matcher doesn't given an explanation.
-  m = AnyOf(GreaterThan(10), Gt(20), GreaterThan(30));
-  EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30",
-            Explain(m, 5));
-
-  // Failed match.  All matchers need to explain.
-  m = AnyOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
-  EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20, "
-            "and which is 25 less than 30",
-            Explain(m, 5));
-
-  // Successful match.  The first matcher, which succeeded, needs to
-  // explain.
-  m = AnyOf(GreaterThan(10), GreaterThan(20));
-  EXPECT_EQ("which is 5 more than 10", Explain(m, 15));
-
-  // Successful match.  The second matcher, which succeeded, needs to
-  // explain.  Since it doesn't given an explanation, nothing is
-  // printed.
-  m = AnyOf(GreaterThan(10), Lt(30));
-  EXPECT_EQ("", Explain(m, 0));
-
-  // Successful match.  The second matcher, which succeeded, needs to
-  // explain.
-  m = AnyOf(GreaterThan(30), GreaterThan(20));
-  EXPECT_EQ("which is 5 more than 20", Explain(m, 25));
-}
-
-// The following predicate function and predicate functor are for
-// testing the Truly(predicate) matcher.
-
-// Returns non-zero if the input is positive.  Note that the return
-// type of this function is not bool.  It's OK as Truly() accepts any
-// unary function or functor whose return type can be implicitly
-// converted to bool.
-int IsPositive(double x) {
-  return x > 0 ? 1 : 0;
-}
-
-// This functor returns true if the input is greater than the given
-// number.
-class IsGreaterThan {
- public:
-  explicit IsGreaterThan(int threshold) : threshold_(threshold) {}
-
-  bool operator()(int n) const { return n > threshold_; }
-
- private:
-  int threshold_;
-};
-
-// For testing Truly().
-const int foo = 0;
-
-// This predicate returns true iff the argument references foo and has
-// a zero value.
-bool ReferencesFooAndIsZero(const int& n) {
-  return (&n == &foo) && (n == 0);
-}
-
-// Tests that Truly(predicate) matches what satisfies the given
-// predicate.
-TEST(TrulyTest, MatchesWhatSatisfiesThePredicate) {
-  Matcher<double> m = Truly(IsPositive);
-  EXPECT_TRUE(m.Matches(2.0));
-  EXPECT_FALSE(m.Matches(-1.5));
-}
-
-// Tests that Truly(predicate_functor) works too.
-TEST(TrulyTest, CanBeUsedWithFunctor) {
-  Matcher<int> m = Truly(IsGreaterThan(5));
-  EXPECT_TRUE(m.Matches(6));
-  EXPECT_FALSE(m.Matches(4));
-}
-
-// A class that can be implicitly converted to bool.
-class ConvertibleToBool {
- public:
-  explicit ConvertibleToBool(int number) : number_(number) {}
-  operator bool() const { return number_ != 0; }
-
- private:
-  int number_;
-};
-
-ConvertibleToBool IsNotZero(int number) {
-  return ConvertibleToBool(number);
-}
-
-// Tests that the predicate used in Truly() may return a class that's
-// implicitly convertible to bool, even when the class has no
-// operator!().
-TEST(TrulyTest, PredicateCanReturnAClassConvertibleToBool) {
-  Matcher<int> m = Truly(IsNotZero);
-  EXPECT_TRUE(m.Matches(1));
-  EXPECT_FALSE(m.Matches(0));
-}
-
-// Tests that Truly(predicate) can describe itself properly.
-TEST(TrulyTest, CanDescribeSelf) {
-  Matcher<double> m = Truly(IsPositive);
-  EXPECT_EQ("satisfies the given predicate",
-            Describe(m));
-}
-
-// Tests that Truly(predicate) works when the matcher takes its
-// argument by reference.
-TEST(TrulyTest, WorksForByRefArguments) {
-  Matcher<const int&> m = Truly(ReferencesFooAndIsZero);
-  EXPECT_TRUE(m.Matches(foo));
-  int n = 0;
-  EXPECT_FALSE(m.Matches(n));
-}
-
-// Tests that Matches(m) is a predicate satisfied by whatever that
-// matches matcher m.
-TEST(MatchesTest, IsSatisfiedByWhatMatchesTheMatcher) {
-  EXPECT_TRUE(Matches(Ge(0))(1));
-  EXPECT_FALSE(Matches(Eq('a'))('b'));
-}
-
-// Tests that Matches(m) works when the matcher takes its argument by
-// reference.
-TEST(MatchesTest, WorksOnByRefArguments) {
-  int m = 0, n = 0;
-  EXPECT_TRUE(Matches(AllOf(Ref(n), Eq(0)))(n));
-  EXPECT_FALSE(Matches(Ref(m))(n));
-}
-
-// Tests that a Matcher on non-reference type can be used in
-// Matches().
-TEST(MatchesTest, WorksWithMatcherOnNonRefType) {
-  Matcher<int> eq5 = Eq(5);
-  EXPECT_TRUE(Matches(eq5)(5));
-  EXPECT_FALSE(Matches(eq5)(2));
-}
-
-// Tests Value(value, matcher).  Since Value() is a simple wrapper for
-// Matches(), which has been tested already, we don't spend a lot of
-// effort on testing Value().
-TEST(ValueTest, WorksWithPolymorphicMatcher) {
-  EXPECT_TRUE(Value("hi", StartsWith("h")));
-  EXPECT_FALSE(Value(5, Gt(10)));
-}
-
-TEST(ValueTest, WorksWithMonomorphicMatcher) {
-  const Matcher<int> is_zero = Eq(0);
-  EXPECT_TRUE(Value(0, is_zero));
-  EXPECT_FALSE(Value('a', is_zero));
-
-  int n = 0;
-  const Matcher<const int&> ref_n = Ref(n);
-  EXPECT_TRUE(Value(n, ref_n));
-  EXPECT_FALSE(Value(1, ref_n));
-}
-
-TEST(ExplainMatchResultTest, WorksWithPolymorphicMatcher) {
-  StringMatchResultListener listener1;
-  EXPECT_TRUE(ExplainMatchResult(PolymorphicIsEven(), 42, &listener1));
-  EXPECT_EQ("% 2 == 0", listener1.str());
-
-  StringMatchResultListener listener2;
-  EXPECT_FALSE(ExplainMatchResult(Ge(42), 1.5, &listener2));
-  EXPECT_EQ("", listener2.str());
-}
-
-TEST(ExplainMatchResultTest, WorksWithMonomorphicMatcher) {
-  const Matcher<int> is_even = PolymorphicIsEven();
-  StringMatchResultListener listener1;
-  EXPECT_TRUE(ExplainMatchResult(is_even, 42, &listener1));
-  EXPECT_EQ("% 2 == 0", listener1.str());
-
-  const Matcher<const double&> is_zero = Eq(0);
-  StringMatchResultListener listener2;
-  EXPECT_FALSE(ExplainMatchResult(is_zero, 1.5, &listener2));
-  EXPECT_EQ("", listener2.str());
-}
-
-MATCHER_P(Really, inner_matcher, "") {
-  return ExplainMatchResult(inner_matcher, arg, result_listener);
-}
-
-TEST(ExplainMatchResultTest, WorksInsideMATCHER) {
-  EXPECT_THAT(0, Really(Eq(0)));
-}
-
-TEST(AllArgsTest, WorksForTuple) {
-  EXPECT_THAT(make_tuple(1, 2L), AllArgs(Lt()));
-  EXPECT_THAT(make_tuple(2L, 1), Not(AllArgs(Lt())));
-}
-
-TEST(AllArgsTest, WorksForNonTuple) {
-  EXPECT_THAT(42, AllArgs(Gt(0)));
-  EXPECT_THAT('a', Not(AllArgs(Eq('b'))));
-}
-
-class AllArgsHelper {
- public:
-  AllArgsHelper() {}
-
-  MOCK_METHOD2(Helper, int(char x, int y));
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(AllArgsHelper);
-};
-
-TEST(AllArgsTest, WorksInWithClause) {
-  AllArgsHelper helper;
-  ON_CALL(helper, Helper(_, _))
-      .With(AllArgs(Lt()))
-      .WillByDefault(Return(1));
-  EXPECT_CALL(helper, Helper(_, _));
-  EXPECT_CALL(helper, Helper(_, _))
-      .With(AllArgs(Gt()))
-      .WillOnce(Return(2));
-
-  EXPECT_EQ(1, helper.Helper('\1', 2));
-  EXPECT_EQ(2, helper.Helper('a', 1));
-}
-
-// Tests that ASSERT_THAT() and EXPECT_THAT() work when the value
-// matches the matcher.
-TEST(MatcherAssertionTest, WorksWhenMatcherIsSatisfied) {
-  ASSERT_THAT(5, Ge(2)) << "This should succeed.";
-  ASSERT_THAT("Foo", EndsWith("oo"));
-  EXPECT_THAT(2, AllOf(Le(7), Ge(0))) << "This should succeed too.";
-  EXPECT_THAT("Hello", StartsWith("Hell"));
-}
-
-// Tests that ASSERT_THAT() and EXPECT_THAT() work when the value
-// doesn't match the matcher.
-TEST(MatcherAssertionTest, WorksWhenMatcherIsNotSatisfied) {
-  // 'n' must be static as it is used in an EXPECT_FATAL_FAILURE(),
-  // which cannot reference auto variables.
-  static unsigned short n;  // NOLINT
-  n = 5;
-
-  // VC++ prior to version 8.0 SP1 has a bug where it will not see any
-  // functions declared in the namespace scope from within nested classes.
-  // EXPECT/ASSERT_(NON)FATAL_FAILURE macros use nested classes so that all
-  // namespace-level functions invoked inside them need to be explicitly
-  // resolved.
-  EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Gt(10)),
-                       "Value of: n\n"
-                       "Expected: is > 10\n"
-                       "  Actual: 5" + OfType("unsigned short"));
-  n = 0;
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_THAT(n, ::testing::AllOf(::testing::Le(7), ::testing::Ge(5))),
-      "Value of: n\n"
-      "Expected: (is <= 7) and (is >= 5)\n"
-      "  Actual: 0" + OfType("unsigned short"));
-}
-
-// Tests that ASSERT_THAT() and EXPECT_THAT() work when the argument
-// has a reference type.
-TEST(MatcherAssertionTest, WorksForByRefArguments) {
-  // We use a static variable here as EXPECT_FATAL_FAILURE() cannot
-  // reference auto variables.
-  static int n;
-  n = 0;
-  EXPECT_THAT(n, AllOf(Le(7), Ref(n)));
-  EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))),
-                       "Value of: n\n"
-                       "Expected: does not reference the variable @");
-  // Tests the "Actual" part.
-  EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))),
-                       "Actual: 0" + OfType("int") + ", which is located @");
-}
-
-#if !GTEST_OS_SYMBIAN
-// Tests that ASSERT_THAT() and EXPECT_THAT() work when the matcher is
-// monomorphic.
-
-// ASSERT_THAT("hello", starts_with_he) fails to compile with Nokia's
-// Symbian compiler: it tries to compile
-// template<T, U> class MatcherCastImpl { ...
-//   virtual bool MatchAndExplain(T x, ...) const {
-//     return source_matcher_.MatchAndExplain(static_cast<U>(x), ...);
-// with U == string and T == const char*
-// With ASSERT_THAT("hello"...) changed to ASSERT_THAT(string("hello") ... )
-// the compiler silently crashes with no output.
-// If MatcherCastImpl is changed to use U(x) instead of static_cast<U>(x)
-// the code compiles but the converted string is bogus.
-TEST(MatcherAssertionTest, WorksForMonomorphicMatcher) {
-  Matcher<const char*> starts_with_he = StartsWith("he");
-  ASSERT_THAT("hello", starts_with_he);
-
-  Matcher<const string&> ends_with_ok = EndsWith("ok");
-  ASSERT_THAT("book", ends_with_ok);
-  const string bad = "bad";
-  EXPECT_NONFATAL_FAILURE(EXPECT_THAT(bad, ends_with_ok),
-                          "Value of: bad\n"
-                          "Expected: ends with \"ok\"\n"
-                          "  Actual: \"bad\"");
-  Matcher<int> is_greater_than_5 = Gt(5);
-  EXPECT_NONFATAL_FAILURE(EXPECT_THAT(5, is_greater_than_5),
-                          "Value of: 5\n"
-                          "Expected: is > 5\n"
-                          "  Actual: 5" + OfType("int"));
-}
-#endif  // !GTEST_OS_SYMBIAN
-
-// Tests floating-point matchers.
-template <typename RawType>
-class FloatingPointTest : public testing::Test {
- protected:
-  typedef testing::internal::FloatingPoint<RawType> Floating;
-  typedef typename Floating::Bits Bits;
-
-  FloatingPointTest()
-      : max_ulps_(Floating::kMaxUlps),
-        zero_bits_(Floating(0).bits()),
-        one_bits_(Floating(1).bits()),
-        infinity_bits_(Floating(Floating::Infinity()).bits()),
-        close_to_positive_zero_(AsBits(zero_bits_ + max_ulps_/2)),
-        close_to_negative_zero_(AsBits(zero_bits_ + max_ulps_ - max_ulps_/2)),
-        further_from_negative_zero_(-AsBits(
-            zero_bits_ + max_ulps_ + 1 - max_ulps_/2)),
-        close_to_one_(AsBits(one_bits_ + max_ulps_)),
-        further_from_one_(AsBits(one_bits_ + max_ulps_ + 1)),
-        infinity_(Floating::Infinity()),
-        close_to_infinity_(AsBits(infinity_bits_ - max_ulps_)),
-        further_from_infinity_(AsBits(infinity_bits_ - max_ulps_ - 1)),
-        max_(Floating::Max()),
-        nan1_(AsBits(Floating::kExponentBitMask | 1)),
-        nan2_(AsBits(Floating::kExponentBitMask | 200)) {
-  }
-
-  void TestSize() {
-    EXPECT_EQ(sizeof(RawType), sizeof(Bits));
-  }
-
-  // A battery of tests for FloatingEqMatcher::Matches.
-  // matcher_maker is a pointer to a function which creates a FloatingEqMatcher.
-  void TestMatches(
-      testing::internal::FloatingEqMatcher<RawType> (*matcher_maker)(RawType)) {
-    Matcher<RawType> m1 = matcher_maker(0.0);
-    EXPECT_TRUE(m1.Matches(-0.0));
-    EXPECT_TRUE(m1.Matches(close_to_positive_zero_));
-    EXPECT_TRUE(m1.Matches(close_to_negative_zero_));
-    EXPECT_FALSE(m1.Matches(1.0));
-
-    Matcher<RawType> m2 = matcher_maker(close_to_positive_zero_);
-    EXPECT_FALSE(m2.Matches(further_from_negative_zero_));
-
-    Matcher<RawType> m3 = matcher_maker(1.0);
-    EXPECT_TRUE(m3.Matches(close_to_one_));
-    EXPECT_FALSE(m3.Matches(further_from_one_));
-
-    // Test commutativity: matcher_maker(0.0).Matches(1.0) was tested above.
-    EXPECT_FALSE(m3.Matches(0.0));
-
-    Matcher<RawType> m4 = matcher_maker(-infinity_);
-    EXPECT_TRUE(m4.Matches(-close_to_infinity_));
-
-    Matcher<RawType> m5 = matcher_maker(infinity_);
-    EXPECT_TRUE(m5.Matches(close_to_infinity_));
-
-    // This is interesting as the representations of infinity_ and nan1_
-    // are only 1 DLP apart.
-    EXPECT_FALSE(m5.Matches(nan1_));
-
-    // matcher_maker can produce a Matcher<const RawType&>, which is needed in
-    // some cases.
-    Matcher<const RawType&> m6 = matcher_maker(0.0);
-    EXPECT_TRUE(m6.Matches(-0.0));
-    EXPECT_TRUE(m6.Matches(close_to_positive_zero_));
-    EXPECT_FALSE(m6.Matches(1.0));
-
-    // matcher_maker can produce a Matcher<RawType&>, which is needed in some
-    // cases.
-    Matcher<RawType&> m7 = matcher_maker(0.0);
-    RawType x = 0.0;
-    EXPECT_TRUE(m7.Matches(x));
-    x = 0.01f;
-    EXPECT_FALSE(m7.Matches(x));
-  }
-
-  // Pre-calculated numbers to be used by the tests.
-
-  const size_t max_ulps_;
-
-  const Bits zero_bits_;  // The bits that represent 0.0.
-  const Bits one_bits_;  // The bits that represent 1.0.
-  const Bits infinity_bits_;  // The bits that represent +infinity.
-
-  // Some numbers close to 0.0.
-  const RawType close_to_positive_zero_;
-  const RawType close_to_negative_zero_;
-  const RawType further_from_negative_zero_;
-
-  // Some numbers close to 1.0.
-  const RawType close_to_one_;
-  const RawType further_from_one_;
-
-  // Some numbers close to +infinity.
-  const RawType infinity_;
-  const RawType close_to_infinity_;
-  const RawType further_from_infinity_;
-
-  // Maximum representable value that's not infinity.
-  const RawType max_;
-
-  // Some NaNs.
-  const RawType nan1_;
-  const RawType nan2_;
-
- private:
-  template <typename T>
-  static RawType AsBits(T value) {
-    return Floating::ReinterpretBits(static_cast<Bits>(value));
-  }
-};
-
-// Tests floating-point matchers with fixed epsilons.
-template <typename RawType>
-class FloatingPointNearTest : public FloatingPointTest<RawType> {
- protected:
-  typedef FloatingPointTest<RawType> ParentType;
-
-  // A battery of tests for FloatingEqMatcher::Matches with a fixed epsilon.
-  // matcher_maker is a pointer to a function which creates a FloatingEqMatcher.
-  void TestNearMatches(
-      testing::internal::FloatingEqMatcher<RawType>
-          (*matcher_maker)(RawType, RawType)) {
-    Matcher<RawType> m1 = matcher_maker(0.0, 0.0);
-    EXPECT_TRUE(m1.Matches(0.0));
-    EXPECT_TRUE(m1.Matches(-0.0));
-    EXPECT_FALSE(m1.Matches(ParentType::close_to_positive_zero_));
-    EXPECT_FALSE(m1.Matches(ParentType::close_to_negative_zero_));
-    EXPECT_FALSE(m1.Matches(1.0));
-
-    Matcher<RawType> m2 = matcher_maker(0.0, 1.0);
-    EXPECT_TRUE(m2.Matches(0.0));
-    EXPECT_TRUE(m2.Matches(-0.0));
-    EXPECT_TRUE(m2.Matches(1.0));
-    EXPECT_TRUE(m2.Matches(-1.0));
-    EXPECT_FALSE(m2.Matches(ParentType::close_to_one_));
-    EXPECT_FALSE(m2.Matches(-ParentType::close_to_one_));
-
-    // Check that inf matches inf, regardless of the of the specified max
-    // absolute error.
-    Matcher<RawType> m3 = matcher_maker(ParentType::infinity_, 0.0);
-    EXPECT_TRUE(m3.Matches(ParentType::infinity_));
-    EXPECT_FALSE(m3.Matches(ParentType::close_to_infinity_));
-    EXPECT_FALSE(m3.Matches(-ParentType::infinity_));
-
-    Matcher<RawType> m4 = matcher_maker(-ParentType::infinity_, 0.0);
-    EXPECT_TRUE(m4.Matches(-ParentType::infinity_));
-    EXPECT_FALSE(m4.Matches(-ParentType::close_to_infinity_));
-    EXPECT_FALSE(m4.Matches(ParentType::infinity_));
-
-    // Test various overflow scenarios.
-    Matcher<RawType> m5 = matcher_maker(ParentType::max_, ParentType::max_);
-    EXPECT_TRUE(m5.Matches(ParentType::max_));
-    EXPECT_FALSE(m5.Matches(-ParentType::max_));
-
-    Matcher<RawType> m6 = matcher_maker(-ParentType::max_, ParentType::max_);
-    EXPECT_FALSE(m6.Matches(ParentType::max_));
-    EXPECT_TRUE(m6.Matches(-ParentType::max_));
-
-    Matcher<RawType> m7 = matcher_maker(ParentType::max_, 0);
-    EXPECT_TRUE(m7.Matches(ParentType::max_));
-    EXPECT_FALSE(m7.Matches(-ParentType::max_));
-
-    Matcher<RawType> m8 = matcher_maker(-ParentType::max_, 0);
-    EXPECT_FALSE(m8.Matches(ParentType::max_));
-    EXPECT_TRUE(m8.Matches(-ParentType::max_));
-
-    // The difference between max() and -max() normally overflows to infinity,
-    // but it should still match if the max_abs_error is also infinity.
-    Matcher<RawType> m9 = matcher_maker(
-        ParentType::max_, ParentType::infinity_);
-    EXPECT_TRUE(m8.Matches(-ParentType::max_));
-
-    // matcher_maker can produce a Matcher<const RawType&>, which is needed in
-    // some cases.
-    Matcher<const RawType&> m10 = matcher_maker(0.0, 1.0);
-    EXPECT_TRUE(m10.Matches(-0.0));
-    EXPECT_TRUE(m10.Matches(ParentType::close_to_positive_zero_));
-    EXPECT_FALSE(m10.Matches(ParentType::close_to_one_));
-
-    // matcher_maker can produce a Matcher<RawType&>, which is needed in some
-    // cases.
-    Matcher<RawType&> m11 = matcher_maker(0.0, 1.0);
-    RawType x = 0.0;
-    EXPECT_TRUE(m11.Matches(x));
-    x = 1.0f;
-    EXPECT_TRUE(m11.Matches(x));
-    x = -1.0f;
-    EXPECT_TRUE(m11.Matches(x));
-    x = 1.1f;
-    EXPECT_FALSE(m11.Matches(x));
-    x = -1.1f;
-    EXPECT_FALSE(m11.Matches(x));
-  }
-};
-
-// Instantiate FloatingPointTest for testing floats.
-typedef FloatingPointTest<float> FloatTest;
-
-TEST_F(FloatTest, FloatEqApproximatelyMatchesFloats) {
-  TestMatches(&FloatEq);
-}
-
-TEST_F(FloatTest, NanSensitiveFloatEqApproximatelyMatchesFloats) {
-  TestMatches(&NanSensitiveFloatEq);
-}
-
-TEST_F(FloatTest, FloatEqCannotMatchNaN) {
-  // FloatEq never matches NaN.
-  Matcher<float> m = FloatEq(nan1_);
-  EXPECT_FALSE(m.Matches(nan1_));
-  EXPECT_FALSE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST_F(FloatTest, NanSensitiveFloatEqCanMatchNaN) {
-  // NanSensitiveFloatEq will match NaN.
-  Matcher<float> m = NanSensitiveFloatEq(nan1_);
-  EXPECT_TRUE(m.Matches(nan1_));
-  EXPECT_TRUE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST_F(FloatTest, FloatEqCanDescribeSelf) {
-  Matcher<float> m1 = FloatEq(2.0f);
-  EXPECT_EQ("is approximately 2", Describe(m1));
-  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
-
-  Matcher<float> m2 = FloatEq(0.5f);
-  EXPECT_EQ("is approximately 0.5", Describe(m2));
-  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
-
-  Matcher<float> m3 = FloatEq(nan1_);
-  EXPECT_EQ("never matches", Describe(m3));
-  EXPECT_EQ("is anything", DescribeNegation(m3));
-}
-
-TEST_F(FloatTest, NanSensitiveFloatEqCanDescribeSelf) {
-  Matcher<float> m1 = NanSensitiveFloatEq(2.0f);
-  EXPECT_EQ("is approximately 2", Describe(m1));
-  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
-
-  Matcher<float> m2 = NanSensitiveFloatEq(0.5f);
-  EXPECT_EQ("is approximately 0.5", Describe(m2));
-  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
-
-  Matcher<float> m3 = NanSensitiveFloatEq(nan1_);
-  EXPECT_EQ("is NaN", Describe(m3));
-  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
-}
-
-// Instantiate FloatingPointTest for testing floats with a user-specified
-// max absolute error.
-typedef FloatingPointNearTest<float> FloatNearTest;
-
-TEST_F(FloatNearTest, FloatNearMatches) {
-  TestNearMatches(&FloatNear);
-}
-
-TEST_F(FloatNearTest, NanSensitiveFloatNearApproximatelyMatchesFloats) {
-  TestNearMatches(&NanSensitiveFloatNear);
-}
-
-TEST_F(FloatNearTest, FloatNearCanDescribeSelf) {
-  Matcher<float> m1 = FloatNear(2.0f, 0.5f);
-  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
-  EXPECT_EQ(
-      "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
-
-  Matcher<float> m2 = FloatNear(0.5f, 0.5f);
-  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
-  EXPECT_EQ(
-      "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
-
-  Matcher<float> m3 = FloatNear(nan1_, 0.0);
-  EXPECT_EQ("never matches", Describe(m3));
-  EXPECT_EQ("is anything", DescribeNegation(m3));
-}
-
-TEST_F(FloatNearTest, NanSensitiveFloatNearCanDescribeSelf) {
-  Matcher<float> m1 = NanSensitiveFloatNear(2.0f, 0.5f);
-  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
-  EXPECT_EQ(
-      "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
-
-  Matcher<float> m2 = NanSensitiveFloatNear(0.5f, 0.5f);
-  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
-  EXPECT_EQ(
-      "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
-
-  Matcher<float> m3 = NanSensitiveFloatNear(nan1_, 0.1f);
-  EXPECT_EQ("is NaN", Describe(m3));
-  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
-}
-
-TEST_F(FloatNearTest, FloatNearCannotMatchNaN) {
-  // FloatNear never matches NaN.
-  Matcher<float> m = FloatNear(ParentType::nan1_, 0.1f);
-  EXPECT_FALSE(m.Matches(nan1_));
-  EXPECT_FALSE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST_F(FloatNearTest, NanSensitiveFloatNearCanMatchNaN) {
-  // NanSensitiveFloatNear will match NaN.
-  Matcher<float> m = NanSensitiveFloatNear(nan1_, 0.1f);
-  EXPECT_TRUE(m.Matches(nan1_));
-  EXPECT_TRUE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-// Instantiate FloatingPointTest for testing doubles.
-typedef FloatingPointTest<double> DoubleTest;
-
-TEST_F(DoubleTest, DoubleEqApproximatelyMatchesDoubles) {
-  TestMatches(&DoubleEq);
-}
-
-TEST_F(DoubleTest, NanSensitiveDoubleEqApproximatelyMatchesDoubles) {
-  TestMatches(&NanSensitiveDoubleEq);
-}
-
-TEST_F(DoubleTest, DoubleEqCannotMatchNaN) {
-  // DoubleEq never matches NaN.
-  Matcher<double> m = DoubleEq(nan1_);
-  EXPECT_FALSE(m.Matches(nan1_));
-  EXPECT_FALSE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST_F(DoubleTest, NanSensitiveDoubleEqCanMatchNaN) {
-  // NanSensitiveDoubleEq will match NaN.
-  Matcher<double> m = NanSensitiveDoubleEq(nan1_);
-  EXPECT_TRUE(m.Matches(nan1_));
-  EXPECT_TRUE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST_F(DoubleTest, DoubleEqCanDescribeSelf) {
-  Matcher<double> m1 = DoubleEq(2.0);
-  EXPECT_EQ("is approximately 2", Describe(m1));
-  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
-
-  Matcher<double> m2 = DoubleEq(0.5);
-  EXPECT_EQ("is approximately 0.5", Describe(m2));
-  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
-
-  Matcher<double> m3 = DoubleEq(nan1_);
-  EXPECT_EQ("never matches", Describe(m3));
-  EXPECT_EQ("is anything", DescribeNegation(m3));
-}
-
-TEST_F(DoubleTest, NanSensitiveDoubleEqCanDescribeSelf) {
-  Matcher<double> m1 = NanSensitiveDoubleEq(2.0);
-  EXPECT_EQ("is approximately 2", Describe(m1));
-  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
-
-  Matcher<double> m2 = NanSensitiveDoubleEq(0.5);
-  EXPECT_EQ("is approximately 0.5", Describe(m2));
-  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
-
-  Matcher<double> m3 = NanSensitiveDoubleEq(nan1_);
-  EXPECT_EQ("is NaN", Describe(m3));
-  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
-}
-
-// Instantiate FloatingPointTest for testing floats with a user-specified
-// max absolute error.
-typedef FloatingPointNearTest<double> DoubleNearTest;
-
-TEST_F(DoubleNearTest, DoubleNearMatches) {
-  TestNearMatches(&DoubleNear);
-}
-
-TEST_F(DoubleNearTest, NanSensitiveDoubleNearApproximatelyMatchesDoubles) {
-  TestNearMatches(&NanSensitiveDoubleNear);
-}
-
-TEST_F(DoubleNearTest, DoubleNearCanDescribeSelf) {
-  Matcher<double> m1 = DoubleNear(2.0, 0.5);
-  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
-  EXPECT_EQ(
-      "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
-
-  Matcher<double> m2 = DoubleNear(0.5, 0.5);
-  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
-  EXPECT_EQ(
-      "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
-
-  Matcher<double> m3 = DoubleNear(nan1_, 0.0);
-  EXPECT_EQ("never matches", Describe(m3));
-  EXPECT_EQ("is anything", DescribeNegation(m3));
-}
-
-TEST_F(DoubleNearTest, ExplainsResultWhenMatchFails) {
-  EXPECT_EQ("", Explain(DoubleNear(2.0, 0.1), 2.05));
-  EXPECT_EQ("which is 0.2 from 2", Explain(DoubleNear(2.0, 0.1), 2.2));
-  EXPECT_EQ("which is -0.3 from 2", Explain(DoubleNear(2.0, 0.1), 1.7));
-
-  const string explanation = Explain(DoubleNear(2.1, 1e-10), 2.1 + 1.2e-10);
-  // Different C++ implementations may print floating-point numbers
-  // slightly differently.
-  EXPECT_TRUE(explanation == "which is 1.2e-10 from 2.1" ||  // GCC
-              explanation == "which is 1.2e-010 from 2.1")   // MSVC
-      << " where explanation is \"" << explanation << "\".";
-}
-
-TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanDescribeSelf) {
-  Matcher<double> m1 = NanSensitiveDoubleNear(2.0, 0.5);
-  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
-  EXPECT_EQ(
-      "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
-
-  Matcher<double> m2 = NanSensitiveDoubleNear(0.5, 0.5);
-  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
-  EXPECT_EQ(
-      "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
-
-  Matcher<double> m3 = NanSensitiveDoubleNear(nan1_, 0.1);
-  EXPECT_EQ("is NaN", Describe(m3));
-  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
-}
-
-TEST_F(DoubleNearTest, DoubleNearCannotMatchNaN) {
-  // DoubleNear never matches NaN.
-  Matcher<double> m = DoubleNear(ParentType::nan1_, 0.1);
-  EXPECT_FALSE(m.Matches(nan1_));
-  EXPECT_FALSE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanMatchNaN) {
-  // NanSensitiveDoubleNear will match NaN.
-  Matcher<double> m = NanSensitiveDoubleNear(nan1_, 0.1);
-  EXPECT_TRUE(m.Matches(nan1_));
-  EXPECT_TRUE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST(PointeeTest, RawPointer) {
-  const Matcher<int*> m = Pointee(Ge(0));
-
-  int n = 1;
-  EXPECT_TRUE(m.Matches(&n));
-  n = -1;
-  EXPECT_FALSE(m.Matches(&n));
-  EXPECT_FALSE(m.Matches(NULL));
-}
-
-TEST(PointeeTest, RawPointerToConst) {
-  const Matcher<const double*> m = Pointee(Ge(0));
-
-  double x = 1;
-  EXPECT_TRUE(m.Matches(&x));
-  x = -1;
-  EXPECT_FALSE(m.Matches(&x));
-  EXPECT_FALSE(m.Matches(NULL));
-}
-
-TEST(PointeeTest, ReferenceToConstRawPointer) {
-  const Matcher<int* const &> m = Pointee(Ge(0));
-
-  int n = 1;
-  EXPECT_TRUE(m.Matches(&n));
-  n = -1;
-  EXPECT_FALSE(m.Matches(&n));
-  EXPECT_FALSE(m.Matches(NULL));
-}
-
-TEST(PointeeTest, ReferenceToNonConstRawPointer) {
-  const Matcher<double* &> m = Pointee(Ge(0));
-
-  double x = 1.0;
-  double* p = &x;
-  EXPECT_TRUE(m.Matches(p));
-  x = -1;
-  EXPECT_FALSE(m.Matches(p));
-  p = NULL;
-  EXPECT_FALSE(m.Matches(p));
-}
-
-MATCHER_P(FieldIIs, inner_matcher, "") {
-  return ExplainMatchResult(inner_matcher, arg.i, result_listener);
-}
-
-#if GTEST_HAS_RTTI
-
-TEST(WhenDynamicCastToTest, SameType) {
-  Derived derived;
-  derived.i = 4;
-
-  // Right type. A pointer is passed down.
-  Base* as_base_ptr = &derived;
-  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Not(IsNull())));
-  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(4))));
-  EXPECT_THAT(as_base_ptr,
-              Not(WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(5)))));
-}
-
-TEST(WhenDynamicCastToTest, WrongTypes) {
-  Base base;
-  Derived derived;
-  OtherDerived other_derived;
-
-  // Wrong types. NULL is passed.
-  EXPECT_THAT(&base, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
-  EXPECT_THAT(&base, WhenDynamicCastTo<Derived*>(IsNull()));
-  Base* as_base_ptr = &derived;
-  EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<OtherDerived*>(Pointee(_))));
-  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<OtherDerived*>(IsNull()));
-  as_base_ptr = &other_derived;
-  EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
-  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
-}
-
-TEST(WhenDynamicCastToTest, AlreadyNull) {
-  // Already NULL.
-  Base* as_base_ptr = NULL;
-  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
-}
-
-struct AmbiguousCastTypes {
-  class VirtualDerived : public virtual Base {};
-  class DerivedSub1 : public VirtualDerived {};
-  class DerivedSub2 : public VirtualDerived {};
-  class ManyDerivedInHierarchy : public DerivedSub1, public DerivedSub2 {};
-};
-
-TEST(WhenDynamicCastToTest, AmbiguousCast) {
-  AmbiguousCastTypes::DerivedSub1 sub1;
-  AmbiguousCastTypes::ManyDerivedInHierarchy many_derived;
-  // Multiply derived from Base. dynamic_cast<> returns NULL.
-  Base* as_base_ptr =
-      static_cast<AmbiguousCastTypes::DerivedSub1*>(&many_derived);
-  EXPECT_THAT(as_base_ptr,
-              WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(IsNull()));
-  as_base_ptr = &sub1;
-  EXPECT_THAT(
-      as_base_ptr,
-      WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(Not(IsNull())));
-}
-
-TEST(WhenDynamicCastToTest, Describe) {
-  Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
-  const string prefix =
-      "when dynamic_cast to " + internal::GetTypeName<Derived*>() + ", ";
-  EXPECT_EQ(prefix + "points to a value that is anything", Describe(matcher));
-  EXPECT_EQ(prefix + "does not point to a value that is anything",
-            DescribeNegation(matcher));
-}
-
-TEST(WhenDynamicCastToTest, Explain) {
-  Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
-  Base* null = NULL;
-  EXPECT_THAT(Explain(matcher, null), HasSubstr("NULL"));
-  Derived derived;
-  EXPECT_TRUE(matcher.Matches(&derived));
-  EXPECT_THAT(Explain(matcher, &derived), HasSubstr("which points to "));
-
-  // With references, the matcher itself can fail. Test for that one.
-  Matcher<const Base&> ref_matcher = WhenDynamicCastTo<const OtherDerived&>(_);
-  EXPECT_THAT(Explain(ref_matcher, derived),
-              HasSubstr("which cannot be dynamic_cast"));
-}
-
-TEST(WhenDynamicCastToTest, GoodReference) {
-  Derived derived;
-  derived.i = 4;
-  Base& as_base_ref = derived;
-  EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(FieldIIs(4)));
-  EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(Not(FieldIIs(5))));
-}
-
-TEST(WhenDynamicCastToTest, BadReference) {
-  Derived derived;
-  Base& as_base_ref = derived;
-  EXPECT_THAT(as_base_ref, Not(WhenDynamicCastTo<const OtherDerived&>(_)));
-}
-
-#endif  // GTEST_HAS_RTTI
-
-// Minimal const-propagating pointer.
-template <typename T>
-class ConstPropagatingPtr {
- public:
-  typedef T element_type;
-
-  ConstPropagatingPtr() : val_() {}
-  explicit ConstPropagatingPtr(T* t) : val_(t) {}
-  ConstPropagatingPtr(const ConstPropagatingPtr& other) : val_(other.val_) {}
-
-  T* get() { return val_; }
-  T& operator*() { return *val_; }
-  // Most smart pointers return non-const T* and T& from the next methods.
-  const T* get() const { return val_; }
-  const T& operator*() const { return *val_; }
-
- private:
-  T* val_;
-};
-
-TEST(PointeeTest, WorksWithConstPropagatingPointers) {
-  const Matcher< ConstPropagatingPtr<int> > m = Pointee(Lt(5));
-  int three = 3;
-  const ConstPropagatingPtr<int> co(&three);
-  ConstPropagatingPtr<int> o(&three);
-  EXPECT_TRUE(m.Matches(o));
-  EXPECT_TRUE(m.Matches(co));
-  *o = 6;
-  EXPECT_FALSE(m.Matches(o));
-  EXPECT_FALSE(m.Matches(ConstPropagatingPtr<int>()));
-}
-
-TEST(PointeeTest, NeverMatchesNull) {
-  const Matcher<const char*> m = Pointee(_);
-  EXPECT_FALSE(m.Matches(NULL));
-}
-
-// Tests that we can write Pointee(value) instead of Pointee(Eq(value)).
-TEST(PointeeTest, MatchesAgainstAValue) {
-  const Matcher<int*> m = Pointee(5);
-
-  int n = 5;
-  EXPECT_TRUE(m.Matches(&n));
-  n = -1;
-  EXPECT_FALSE(m.Matches(&n));
-  EXPECT_FALSE(m.Matches(NULL));
-}
-
-TEST(PointeeTest, CanDescribeSelf) {
-  const Matcher<int*> m = Pointee(Gt(3));
-  EXPECT_EQ("points to a value that is > 3", Describe(m));
-  EXPECT_EQ("does not point to a value that is > 3",
-            DescribeNegation(m));
-}
-
-TEST(PointeeTest, CanExplainMatchResult) {
-  const Matcher<const string*> m = Pointee(StartsWith("Hi"));
-
-  EXPECT_EQ("", Explain(m, static_cast<const string*>(NULL)));
-
-  const Matcher<long*> m2 = Pointee(GreaterThan(1));  // NOLINT
-  long n = 3;  // NOLINT
-  EXPECT_EQ("which points to 3" + OfType("long") + ", which is 2 more than 1",
-            Explain(m2, &n));
-}
-
-TEST(PointeeTest, AlwaysExplainsPointee) {
-  const Matcher<int*> m = Pointee(0);
-  int n = 42;
-  EXPECT_EQ("which points to 42" + OfType("int"), Explain(m, &n));
-}
-
-// An uncopyable class.
-class Uncopyable {
- public:
-  Uncopyable() : value_(-1) {}
-  explicit Uncopyable(int a_value) : value_(a_value) {}
-
-  int value() const { return value_; }
-  void set_value(int i) { value_ = i; }
-
- private:
-  int value_;
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Uncopyable);
-};
-
-// Returns true iff x.value() is positive.
-bool ValueIsPositive(const Uncopyable& x) { return x.value() > 0; }
-
-MATCHER_P(UncopyableIs, inner_matcher, "") {
-  return ExplainMatchResult(inner_matcher, arg.value(), result_listener);
-}
-
-// A user-defined struct for testing Field().
-struct AStruct {
-  AStruct() : x(0), y(1.0), z(5), p(NULL) {}
-  AStruct(const AStruct& rhs)
-      : x(rhs.x), y(rhs.y), z(rhs.z.value()), p(rhs.p) {}
-
-  int x;           // A non-const field.
-  const double y;  // A const field.
-  Uncopyable z;    // An uncopyable field.
-  const char* p;   // A pointer field.
-
- private:
-  GTEST_DISALLOW_ASSIGN_(AStruct);
-};
-
-// A derived struct for testing Field().
-struct DerivedStruct : public AStruct {
-  char ch;
-
- private:
-  GTEST_DISALLOW_ASSIGN_(DerivedStruct);
-};
-
-// Tests that Field(&Foo::field, ...) works when field is non-const.
-TEST(FieldTest, WorksForNonConstField) {
-  Matcher<AStruct> m = Field(&AStruct::x, Ge(0));
-
-  AStruct a;
-  EXPECT_TRUE(m.Matches(a));
-  a.x = -1;
-  EXPECT_FALSE(m.Matches(a));
-}
-
-// Tests that Field(&Foo::field, ...) works when field is const.
-TEST(FieldTest, WorksForConstField) {
-  AStruct a;
-
-  Matcher<AStruct> m = Field(&AStruct::y, Ge(0.0));
-  EXPECT_TRUE(m.Matches(a));
-  m = Field(&AStruct::y, Le(0.0));
-  EXPECT_FALSE(m.Matches(a));
-}
-
-// Tests that Field(&Foo::field, ...) works when field is not copyable.
-TEST(FieldTest, WorksForUncopyableField) {
-  AStruct a;
-
-  Matcher<AStruct> m = Field(&AStruct::z, Truly(ValueIsPositive));
-  EXPECT_TRUE(m.Matches(a));
-  m = Field(&AStruct::z, Not(Truly(ValueIsPositive)));
-  EXPECT_FALSE(m.Matches(a));
-}
-
-// Tests that Field(&Foo::field, ...) works when field is a pointer.
-TEST(FieldTest, WorksForPointerField) {
-  // Matching against NULL.
-  Matcher<AStruct> m = Field(&AStruct::p, static_cast<const char*>(NULL));
-  AStruct a;
-  EXPECT_TRUE(m.Matches(a));
-  a.p = "hi";
-  EXPECT_FALSE(m.Matches(a));
-
-  // Matching a pointer that is not NULL.
-  m = Field(&AStruct::p, StartsWith("hi"));
-  a.p = "hill";
-  EXPECT_TRUE(m.Matches(a));
-  a.p = "hole";
-  EXPECT_FALSE(m.Matches(a));
-}
-
-// Tests that Field() works when the object is passed by reference.
-TEST(FieldTest, WorksForByRefArgument) {
-  Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
-
-  AStruct a;
-  EXPECT_TRUE(m.Matches(a));
-  a.x = -1;
-  EXPECT_FALSE(m.Matches(a));
-}
-
-// Tests that Field(&Foo::field, ...) works when the argument's type
-// is a sub-type of Foo.
-TEST(FieldTest, WorksForArgumentOfSubType) {
-  // Note that the matcher expects DerivedStruct but we say AStruct
-  // inside Field().
-  Matcher<const DerivedStruct&> m = Field(&AStruct::x, Ge(0));
-
-  DerivedStruct d;
-  EXPECT_TRUE(m.Matches(d));
-  d.x = -1;
-  EXPECT_FALSE(m.Matches(d));
-}
-
-// Tests that Field(&Foo::field, m) works when field's type and m's
-// argument type are compatible but not the same.
-TEST(FieldTest, WorksForCompatibleMatcherType) {
-  // The field is an int, but the inner matcher expects a signed char.
-  Matcher<const AStruct&> m = Field(&AStruct::x,
-                                    Matcher<signed char>(Ge(0)));
-
-  AStruct a;
-  EXPECT_TRUE(m.Matches(a));
-  a.x = -1;
-  EXPECT_FALSE(m.Matches(a));
-}
-
-// Tests that Field() can describe itself.
-TEST(FieldTest, CanDescribeSelf) {
-  Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
-
-  EXPECT_EQ("is an object whose given field is >= 0", Describe(m));
-  EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m));
-}
-
-// Tests that Field() can explain the match result.
-TEST(FieldTest, CanExplainMatchResult) {
-  Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
-
-  AStruct a;
-  a.x = 1;
-  EXPECT_EQ("whose given field is 1" + OfType("int"), Explain(m, a));
-
-  m = Field(&AStruct::x, GreaterThan(0));
-  EXPECT_EQ(
-      "whose given field is 1" + OfType("int") + ", which is 1 more than 0",
-      Explain(m, a));
-}
-
-// Tests that Field() works when the argument is a pointer to const.
-TEST(FieldForPointerTest, WorksForPointerToConst) {
-  Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
-
-  AStruct a;
-  EXPECT_TRUE(m.Matches(&a));
-  a.x = -1;
-  EXPECT_FALSE(m.Matches(&a));
-}
-
-// Tests that Field() works when the argument is a pointer to non-const.
-TEST(FieldForPointerTest, WorksForPointerToNonConst) {
-  Matcher<AStruct*> m = Field(&AStruct::x, Ge(0));
-
-  AStruct a;
-  EXPECT_TRUE(m.Matches(&a));
-  a.x = -1;
-  EXPECT_FALSE(m.Matches(&a));
-}
-
-// Tests that Field() works when the argument is a reference to a const pointer.
-TEST(FieldForPointerTest, WorksForReferenceToConstPointer) {
-  Matcher<AStruct* const&> m = Field(&AStruct::x, Ge(0));
-
-  AStruct a;
-  EXPECT_TRUE(m.Matches(&a));
-  a.x = -1;
-  EXPECT_FALSE(m.Matches(&a));
-}
-
-// Tests that Field() does not match the NULL pointer.
-TEST(FieldForPointerTest, DoesNotMatchNull) {
-  Matcher<const AStruct*> m = Field(&AStruct::x, _);
-  EXPECT_FALSE(m.Matches(NULL));
-}
-
-// Tests that Field(&Foo::field, ...) works when the argument's type
-// is a sub-type of const Foo*.
-TEST(FieldForPointerTest, WorksForArgumentOfSubType) {
-  // Note that the matcher expects DerivedStruct but we say AStruct
-  // inside Field().
-  Matcher<DerivedStruct*> m = Field(&AStruct::x, Ge(0));
-
-  DerivedStruct d;
-  EXPECT_TRUE(m.Matches(&d));
-  d.x = -1;
-  EXPECT_FALSE(m.Matches(&d));
-}
-
-// Tests that Field() can describe itself when used to match a pointer.
-TEST(FieldForPointerTest, CanDescribeSelf) {
-  Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
-
-  EXPECT_EQ("is an object whose given field is >= 0", Describe(m));
-  EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m));
-}
-
-// Tests that Field() can explain the result of matching a pointer.
-TEST(FieldForPointerTest, CanExplainMatchResult) {
-  Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
-
-  AStruct a;
-  a.x = 1;
-  EXPECT_EQ("", Explain(m, static_cast<const AStruct*>(NULL)));
-  EXPECT_EQ("which points to an object whose given field is 1" + OfType("int"),
-            Explain(m, &a));
-
-  m = Field(&AStruct::x, GreaterThan(0));
-  EXPECT_EQ("which points to an object whose given field is 1" + OfType("int") +
-            ", which is 1 more than 0", Explain(m, &a));
-}
-
-// A user-defined class for testing Property().
-class AClass {
- public:
-  AClass() : n_(0) {}
-
-  // A getter that returns a non-reference.
-  int n() const { return n_; }
-
-  void set_n(int new_n) { n_ = new_n; }
-
-  // A getter that returns a reference to const.
-  const string& s() const { return s_; }
-
-  void set_s(const string& new_s) { s_ = new_s; }
-
-  // A getter that returns a reference to non-const.
-  double& x() const { return x_; }
- private:
-  int n_;
-  string s_;
-
-  static double x_;
-};
-
-double AClass::x_ = 0.0;
-
-// A derived class for testing Property().
-class DerivedClass : public AClass {
- public:
-  int k() const { return k_; }
- private:
-  int k_;
-};
-
-// Tests that Property(&Foo::property, ...) works when property()
-// returns a non-reference.
-TEST(PropertyTest, WorksForNonReferenceProperty) {
-  Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
-
-  AClass a;
-  a.set_n(1);
-  EXPECT_TRUE(m.Matches(a));
-
-  a.set_n(-1);
-  EXPECT_FALSE(m.Matches(a));
-}
-
-// Tests that Property(&Foo::property, ...) works when property()
-// returns a reference to const.
-TEST(PropertyTest, WorksForReferenceToConstProperty) {
-  Matcher<const AClass&> m = Property(&AClass::s, StartsWith("hi"));
-
-  AClass a;
-  a.set_s("hill");
-  EXPECT_TRUE(m.Matches(a));
-
-  a.set_s("hole");
-  EXPECT_FALSE(m.Matches(a));
-}
-
-// Tests that Property(&Foo::property, ...) works when property()
-// returns a reference to non-const.
-TEST(PropertyTest, WorksForReferenceToNonConstProperty) {
-  double x = 0.0;
-  AClass a;
-
-  Matcher<const AClass&> m = Property(&AClass::x, Ref(x));
-  EXPECT_FALSE(m.Matches(a));
-
-  m = Property(&AClass::x, Not(Ref(x)));
-  EXPECT_TRUE(m.Matches(a));
-}
-
-// Tests that Property(&Foo::property, ...) works when the argument is
-// passed by value.
-TEST(PropertyTest, WorksForByValueArgument) {
-  Matcher<AClass> m = Property(&AClass::s, StartsWith("hi"));
-
-  AClass a;
-  a.set_s("hill");
-  EXPECT_TRUE(m.Matches(a));
-
-  a.set_s("hole");
-  EXPECT_FALSE(m.Matches(a));
-}
-
-// Tests that Property(&Foo::property, ...) works when the argument's
-// type is a sub-type of Foo.
-TEST(PropertyTest, WorksForArgumentOfSubType) {
-  // The matcher expects a DerivedClass, but inside the Property() we
-  // say AClass.
-  Matcher<const DerivedClass&> m = Property(&AClass::n, Ge(0));
-
-  DerivedClass d;
-  d.set_n(1);
-  EXPECT_TRUE(m.Matches(d));
-
-  d.set_n(-1);
-  EXPECT_FALSE(m.Matches(d));
-}
-
-// Tests that Property(&Foo::property, m) works when property()'s type
-// and m's argument type are compatible but different.
-TEST(PropertyTest, WorksForCompatibleMatcherType) {
-  // n() returns an int but the inner matcher expects a signed char.
-  Matcher<const AClass&> m = Property(&AClass::n,
-                                      Matcher<signed char>(Ge(0)));
-
-  AClass a;
-  EXPECT_TRUE(m.Matches(a));
-  a.set_n(-1);
-  EXPECT_FALSE(m.Matches(a));
-}
-
-// Tests that Property() can describe itself.
-TEST(PropertyTest, CanDescribeSelf) {
-  Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
-
-  EXPECT_EQ("is an object whose given property is >= 0", Describe(m));
-  EXPECT_EQ("is an object whose given property isn't >= 0",
-            DescribeNegation(m));
-}
-
-// Tests that Property() can explain the match result.
-TEST(PropertyTest, CanExplainMatchResult) {
-  Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
-
-  AClass a;
-  a.set_n(1);
-  EXPECT_EQ("whose given property is 1" + OfType("int"), Explain(m, a));
-
-  m = Property(&AClass::n, GreaterThan(0));
-  EXPECT_EQ(
-      "whose given property is 1" + OfType("int") + ", which is 1 more than 0",
-      Explain(m, a));
-}
-
-// Tests that Property() works when the argument is a pointer to const.
-TEST(PropertyForPointerTest, WorksForPointerToConst) {
-  Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
-
-  AClass a;
-  a.set_n(1);
-  EXPECT_TRUE(m.Matches(&a));
-
-  a.set_n(-1);
-  EXPECT_FALSE(m.Matches(&a));
-}
-
-// Tests that Property() works when the argument is a pointer to non-const.
-TEST(PropertyForPointerTest, WorksForPointerToNonConst) {
-  Matcher<AClass*> m = Property(&AClass::s, StartsWith("hi"));
-
-  AClass a;
-  a.set_s("hill");
-  EXPECT_TRUE(m.Matches(&a));
-
-  a.set_s("hole");
-  EXPECT_FALSE(m.Matches(&a));
-}
-
-// Tests that Property() works when the argument is a reference to a
-// const pointer.
-TEST(PropertyForPointerTest, WorksForReferenceToConstPointer) {
-  Matcher<AClass* const&> m = Property(&AClass::s, StartsWith("hi"));
-
-  AClass a;
-  a.set_s("hill");
-  EXPECT_TRUE(m.Matches(&a));
-
-  a.set_s("hole");
-  EXPECT_FALSE(m.Matches(&a));
-}
-
-// Tests that Property() does not match the NULL pointer.
-TEST(PropertyForPointerTest, WorksForReferenceToNonConstProperty) {
-  Matcher<const AClass*> m = Property(&AClass::x, _);
-  EXPECT_FALSE(m.Matches(NULL));
-}
-
-// Tests that Property(&Foo::property, ...) works when the argument's
-// type is a sub-type of const Foo*.
-TEST(PropertyForPointerTest, WorksForArgumentOfSubType) {
-  // The matcher expects a DerivedClass, but inside the Property() we
-  // say AClass.
-  Matcher<const DerivedClass*> m = Property(&AClass::n, Ge(0));
-
-  DerivedClass d;
-  d.set_n(1);
-  EXPECT_TRUE(m.Matches(&d));
-
-  d.set_n(-1);
-  EXPECT_FALSE(m.Matches(&d));
-}
-
-// Tests that Property() can describe itself when used to match a pointer.
-TEST(PropertyForPointerTest, CanDescribeSelf) {
-  Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
-
-  EXPECT_EQ("is an object whose given property is >= 0", Describe(m));
-  EXPECT_EQ("is an object whose given property isn't >= 0",
-            DescribeNegation(m));
-}
-
-// Tests that Property() can explain the result of matching a pointer.
-TEST(PropertyForPointerTest, CanExplainMatchResult) {
-  Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
-
-  AClass a;
-  a.set_n(1);
-  EXPECT_EQ("", Explain(m, static_cast<const AClass*>(NULL)));
-  EXPECT_EQ(
-      "which points to an object whose given property is 1" + OfType("int"),
-      Explain(m, &a));
-
-  m = Property(&AClass::n, GreaterThan(0));
-  EXPECT_EQ("which points to an object whose given property is 1" +
-            OfType("int") + ", which is 1 more than 0",
-            Explain(m, &a));
-}
-
-// Tests ResultOf.
-
-// Tests that ResultOf(f, ...) compiles and works as expected when f is a
-// function pointer.
-string IntToStringFunction(int input) { return input == 1 ? "foo" : "bar"; }
-
-TEST(ResultOfTest, WorksForFunctionPointers) {
-  Matcher<int> matcher = ResultOf(&IntToStringFunction, Eq(string("foo")));
-
-  EXPECT_TRUE(matcher.Matches(1));
-  EXPECT_FALSE(matcher.Matches(2));
-}
-
-// Tests that ResultOf() can describe itself.
-TEST(ResultOfTest, CanDescribeItself) {
-  Matcher<int> matcher = ResultOf(&IntToStringFunction, StrEq("foo"));
-
-  EXPECT_EQ("is mapped by the given callable to a value that "
-            "is equal to \"foo\"", Describe(matcher));
-  EXPECT_EQ("is mapped by the given callable to a value that "
-            "isn't equal to \"foo\"", DescribeNegation(matcher));
-}
-
-// Tests that ResultOf() can explain the match result.
-int IntFunction(int input) { return input == 42 ? 80 : 90; }
-
-TEST(ResultOfTest, CanExplainMatchResult) {
-  Matcher<int> matcher = ResultOf(&IntFunction, Ge(85));
-  EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int"),
-            Explain(matcher, 36));
-
-  matcher = ResultOf(&IntFunction, GreaterThan(85));
-  EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int") +
-            ", which is 5 more than 85", Explain(matcher, 36));
-}
-
-// Tests that ResultOf(f, ...) compiles and works as expected when f(x)
-// returns a non-reference.
-TEST(ResultOfTest, WorksForNonReferenceResults) {
-  Matcher<int> matcher = ResultOf(&IntFunction, Eq(80));
-
-  EXPECT_TRUE(matcher.Matches(42));
-  EXPECT_FALSE(matcher.Matches(36));
-}
-
-// Tests that ResultOf(f, ...) compiles and works as expected when f(x)
-// returns a reference to non-const.
-double& DoubleFunction(double& input) { return input; }  // NOLINT
-
-Uncopyable& RefUncopyableFunction(Uncopyable& obj) {  // NOLINT
-  return obj;
-}
-
-TEST(ResultOfTest, WorksForReferenceToNonConstResults) {
-  double x = 3.14;
-  double x2 = x;
-  Matcher<double&> matcher = ResultOf(&DoubleFunction, Ref(x));
-
-  EXPECT_TRUE(matcher.Matches(x));
-  EXPECT_FALSE(matcher.Matches(x2));
-
-  // Test that ResultOf works with uncopyable objects
-  Uncopyable obj(0);
-  Uncopyable obj2(0);
-  Matcher<Uncopyable&> matcher2 =
-      ResultOf(&RefUncopyableFunction, Ref(obj));
-
-  EXPECT_TRUE(matcher2.Matches(obj));
-  EXPECT_FALSE(matcher2.Matches(obj2));
-}
-
-// Tests that ResultOf(f, ...) compiles and works as expected when f(x)
-// returns a reference to const.
-const string& StringFunction(const string& input) { return input; }
-
-TEST(ResultOfTest, WorksForReferenceToConstResults) {
-  string s = "foo";
-  string s2 = s;
-  Matcher<const string&> matcher = ResultOf(&StringFunction, Ref(s));
-
-  EXPECT_TRUE(matcher.Matches(s));
-  EXPECT_FALSE(matcher.Matches(s2));
-}
-
-// Tests that ResultOf(f, m) works when f(x) and m's
-// argument types are compatible but different.
-TEST(ResultOfTest, WorksForCompatibleMatcherTypes) {
-  // IntFunction() returns int but the inner matcher expects a signed char.
-  Matcher<int> matcher = ResultOf(IntFunction, Matcher<signed char>(Ge(85)));
-
-  EXPECT_TRUE(matcher.Matches(36));
-  EXPECT_FALSE(matcher.Matches(42));
-}
-
-// Tests that the program aborts when ResultOf is passed
-// a NULL function pointer.
-TEST(ResultOfDeathTest, DiesOnNullFunctionPointers) {
-  EXPECT_DEATH_IF_SUPPORTED(
-      ResultOf(static_cast<string(*)(int dummy)>(NULL), Eq(string("foo"))),
-               "NULL function pointer is passed into ResultOf\\(\\)\\.");
-}
-
-// Tests that ResultOf(f, ...) compiles and works as expected when f is a
-// function reference.
-TEST(ResultOfTest, WorksForFunctionReferences) {
-  Matcher<int> matcher = ResultOf(IntToStringFunction, StrEq("foo"));
-  EXPECT_TRUE(matcher.Matches(1));
-  EXPECT_FALSE(matcher.Matches(2));
-}
-
-// Tests that ResultOf(f, ...) compiles and works as expected when f is a
-// function object.
-struct Functor : public ::std::unary_function<int, string> {
-  result_type operator()(argument_type input) const {
-    return IntToStringFunction(input);
-  }
-};
-
-TEST(ResultOfTest, WorksForFunctors) {
-  Matcher<int> matcher = ResultOf(Functor(), Eq(string("foo")));
-
-  EXPECT_TRUE(matcher.Matches(1));
-  EXPECT_FALSE(matcher.Matches(2));
-}
-
-// Tests that ResultOf(f, ...) compiles and works as expected when f is a
-// functor with more then one operator() defined. ResultOf() must work
-// for each defined operator().
-struct PolymorphicFunctor {
-  typedef int result_type;
-  int operator()(int n) { return n; }
-  int operator()(const char* s) { return static_cast<int>(strlen(s)); }
-};
-
-TEST(ResultOfTest, WorksForPolymorphicFunctors) {
-  Matcher<int> matcher_int = ResultOf(PolymorphicFunctor(), Ge(5));
-
-  EXPECT_TRUE(matcher_int.Matches(10));
-  EXPECT_FALSE(matcher_int.Matches(2));
-
-  Matcher<const char*> matcher_string = ResultOf(PolymorphicFunctor(), Ge(5));
-
-  EXPECT_TRUE(matcher_string.Matches("long string"));
-  EXPECT_FALSE(matcher_string.Matches("shrt"));
-}
-
-const int* ReferencingFunction(const int& n) { return &n; }
-
-struct ReferencingFunctor {
-  typedef const int* result_type;
-  result_type operator()(const int& n) { return &n; }
-};
-
-TEST(ResultOfTest, WorksForReferencingCallables) {
-  const int n = 1;
-  const int n2 = 1;
-  Matcher<const int&> matcher2 = ResultOf(ReferencingFunction, Eq(&n));
-  EXPECT_TRUE(matcher2.Matches(n));
-  EXPECT_FALSE(matcher2.Matches(n2));
-
-  Matcher<const int&> matcher3 = ResultOf(ReferencingFunctor(), Eq(&n));
-  EXPECT_TRUE(matcher3.Matches(n));
-  EXPECT_FALSE(matcher3.Matches(n2));
-}
-
-class DivisibleByImpl {
- public:
-  explicit DivisibleByImpl(int a_divider) : divider_(a_divider) {}
-
-  // For testing using ExplainMatchResultTo() with polymorphic matchers.
-  template <typename T>
-  bool MatchAndExplain(const T& n, MatchResultListener* listener) const {
-    *listener << "which is " << (n % divider_) << " modulo "
-              << divider_;
-    return (n % divider_) == 0;
-  }
-
-  void DescribeTo(ostream* os) const {
-    *os << "is divisible by " << divider_;
-  }
-
-  void DescribeNegationTo(ostream* os) const {
-    *os << "is not divisible by " << divider_;
-  }
-
-  void set_divider(int a_divider) { divider_ = a_divider; }
-  int divider() const { return divider_; }
-
- private:
-  int divider_;
-};
-
-PolymorphicMatcher<DivisibleByImpl> DivisibleBy(int n) {
-  return MakePolymorphicMatcher(DivisibleByImpl(n));
-}
-
-// Tests that when AllOf() fails, only the first failing matcher is
-// asked to explain why.
-TEST(ExplainMatchResultTest, AllOf_False_False) {
-  const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
-  EXPECT_EQ("which is 1 modulo 4", Explain(m, 5));
-}
-
-// Tests that when AllOf() fails, only the first failing matcher is
-// asked to explain why.
-TEST(ExplainMatchResultTest, AllOf_False_True) {
-  const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
-  EXPECT_EQ("which is 2 modulo 4", Explain(m, 6));
-}
-
-// Tests that when AllOf() fails, only the first failing matcher is
-// asked to explain why.
-TEST(ExplainMatchResultTest, AllOf_True_False) {
-  const Matcher<int> m = AllOf(Ge(1), DivisibleBy(3));
-  EXPECT_EQ("which is 2 modulo 3", Explain(m, 5));
-}
-
-// Tests that when AllOf() succeeds, all matchers are asked to explain
-// why.
-TEST(ExplainMatchResultTest, AllOf_True_True) {
-  const Matcher<int> m = AllOf(DivisibleBy(2), DivisibleBy(3));
-  EXPECT_EQ("which is 0 modulo 2, and which is 0 modulo 3", Explain(m, 6));
-}
-
-TEST(ExplainMatchResultTest, AllOf_True_True_2) {
-  const Matcher<int> m = AllOf(Ge(2), Le(3));
-  EXPECT_EQ("", Explain(m, 2));
-}
-
-TEST(ExplainmatcherResultTest, MonomorphicMatcher) {
-  const Matcher<int> m = GreaterThan(5);
-  EXPECT_EQ("which is 1 more than 5", Explain(m, 6));
-}
-
-// The following two tests verify that values without a public copy
-// ctor can be used as arguments to matchers like Eq(), Ge(), and etc
-// with the help of ByRef().
-
-class NotCopyable {
- public:
-  explicit NotCopyable(int a_value) : value_(a_value) {}
-
-  int value() const { return value_; }
-
-  bool operator==(const NotCopyable& rhs) const {
-    return value() == rhs.value();
-  }
-
-  bool operator>=(const NotCopyable& rhs) const {
-    return value() >= rhs.value();
-  }
- private:
-  int value_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(NotCopyable);
-};
-
-TEST(ByRefTest, AllowsNotCopyableConstValueInMatchers) {
-  const NotCopyable const_value1(1);
-  const Matcher<const NotCopyable&> m = Eq(ByRef(const_value1));
-
-  const NotCopyable n1(1), n2(2);
-  EXPECT_TRUE(m.Matches(n1));
-  EXPECT_FALSE(m.Matches(n2));
-}
-
-TEST(ByRefTest, AllowsNotCopyableValueInMatchers) {
-  NotCopyable value2(2);
-  const Matcher<NotCopyable&> m = Ge(ByRef(value2));
-
-  NotCopyable n1(1), n2(2);
-  EXPECT_FALSE(m.Matches(n1));
-  EXPECT_TRUE(m.Matches(n2));
-}
-
-TEST(IsEmptyTest, ImplementsIsEmpty) {
-  vector<int> container;
-  EXPECT_THAT(container, IsEmpty());
-  container.push_back(0);
-  EXPECT_THAT(container, Not(IsEmpty()));
-  container.push_back(1);
-  EXPECT_THAT(container, Not(IsEmpty()));
-}
-
-TEST(IsEmptyTest, WorksWithString) {
-  string text;
-  EXPECT_THAT(text, IsEmpty());
-  text = "foo";
-  EXPECT_THAT(text, Not(IsEmpty()));
-  text = string("\0", 1);
-  EXPECT_THAT(text, Not(IsEmpty()));
-}
-
-TEST(IsEmptyTest, CanDescribeSelf) {
-  Matcher<vector<int> > m = IsEmpty();
-  EXPECT_EQ("is empty", Describe(m));
-  EXPECT_EQ("isn't empty", DescribeNegation(m));
-}
-
-TEST(IsEmptyTest, ExplainsResult) {
-  Matcher<vector<int> > m = IsEmpty();
-  vector<int> container;
-  EXPECT_EQ("", Explain(m, container));
-  container.push_back(0);
-  EXPECT_EQ("whose size is 1", Explain(m, container));
-}
-
-TEST(SizeIsTest, ImplementsSizeIs) {
-  vector<int> container;
-  EXPECT_THAT(container, SizeIs(0));
-  EXPECT_THAT(container, Not(SizeIs(1)));
-  container.push_back(0);
-  EXPECT_THAT(container, Not(SizeIs(0)));
-  EXPECT_THAT(container, SizeIs(1));
-  container.push_back(0);
-  EXPECT_THAT(container, Not(SizeIs(0)));
-  EXPECT_THAT(container, SizeIs(2));
-}
-
-TEST(SizeIsTest, WorksWithMap) {
-  map<string, int> container;
-  EXPECT_THAT(container, SizeIs(0));
-  EXPECT_THAT(container, Not(SizeIs(1)));
-  container.insert(make_pair("foo", 1));
-  EXPECT_THAT(container, Not(SizeIs(0)));
-  EXPECT_THAT(container, SizeIs(1));
-  container.insert(make_pair("bar", 2));
-  EXPECT_THAT(container, Not(SizeIs(0)));
-  EXPECT_THAT(container, SizeIs(2));
-}
-
-TEST(SizeIsTest, WorksWithReferences) {
-  vector<int> container;
-  Matcher<const vector<int>&> m = SizeIs(1);
-  EXPECT_THAT(container, Not(m));
-  container.push_back(0);
-  EXPECT_THAT(container, m);
-}
-
-TEST(SizeIsTest, CanDescribeSelf) {
-  Matcher<vector<int> > m = SizeIs(2);
-  EXPECT_EQ("size is equal to 2", Describe(m));
-  EXPECT_EQ("size isn't equal to 2", DescribeNegation(m));
-}
-
-TEST(SizeIsTest, ExplainsResult) {
-  Matcher<vector<int> > m1 = SizeIs(2);
-  Matcher<vector<int> > m2 = SizeIs(Lt(2u));
-  Matcher<vector<int> > m3 = SizeIs(AnyOf(0, 3));
-  Matcher<vector<int> > m4 = SizeIs(GreaterThan(1));
-  vector<int> container;
-  EXPECT_EQ("whose size 0 doesn't match", Explain(m1, container));
-  EXPECT_EQ("whose size 0 matches", Explain(m2, container));
-  EXPECT_EQ("whose size 0 matches", Explain(m3, container));
-  EXPECT_EQ("whose size 0 doesn't match, which is 1 less than 1",
-            Explain(m4, container));
-  container.push_back(0);
-  container.push_back(0);
-  EXPECT_EQ("whose size 2 matches", Explain(m1, container));
-  EXPECT_EQ("whose size 2 doesn't match", Explain(m2, container));
-  EXPECT_EQ("whose size 2 doesn't match", Explain(m3, container));
-  EXPECT_EQ("whose size 2 matches, which is 1 more than 1",
-            Explain(m4, container));
-}
-
-#if GTEST_HAS_TYPED_TEST
-// Tests ContainerEq with different container types, and
-// different element types.
-
-template <typename T>
-class ContainerEqTest : public testing::Test {};
-
-typedef testing::Types<
-    set<int>,
-    vector<size_t>,
-    multiset<size_t>,
-    list<int> >
-    ContainerEqTestTypes;
-
-TYPED_TEST_CASE(ContainerEqTest, ContainerEqTestTypes);
-
-// Tests that the filled container is equal to itself.
-TYPED_TEST(ContainerEqTest, EqualsSelf) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  TypeParam my_set(vals, vals + 6);
-  const Matcher<TypeParam> m = ContainerEq(my_set);
-  EXPECT_TRUE(m.Matches(my_set));
-  EXPECT_EQ("", Explain(m, my_set));
-}
-
-// Tests that missing values are reported.
-TYPED_TEST(ContainerEqTest, ValueMissing) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {2, 1, 8, 5};
-  TypeParam my_set(vals, vals + 6);
-  TypeParam test_set(test_vals, test_vals + 4);
-  const Matcher<TypeParam> m = ContainerEq(my_set);
-  EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("which doesn't have these expected elements: 3",
-            Explain(m, test_set));
-}
-
-// Tests that added values are reported.
-TYPED_TEST(ContainerEqTest, ValueAdded) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {1, 2, 3, 5, 8, 46};
-  TypeParam my_set(vals, vals + 6);
-  TypeParam test_set(test_vals, test_vals + 6);
-  const Matcher<const TypeParam&> m = ContainerEq(my_set);
-  EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("which has these unexpected elements: 46", Explain(m, test_set));
-}
-
-// Tests that added and missing values are reported together.
-TYPED_TEST(ContainerEqTest, ValueAddedAndRemoved) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {1, 2, 3, 8, 46};
-  TypeParam my_set(vals, vals + 6);
-  TypeParam test_set(test_vals, test_vals + 5);
-  const Matcher<TypeParam> m = ContainerEq(my_set);
-  EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("which has these unexpected elements: 46,\n"
-            "and doesn't have these expected elements: 5",
-            Explain(m, test_set));
-}
-
-// Tests duplicated value -- expect no explanation.
-TYPED_TEST(ContainerEqTest, DuplicateDifference) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {1, 2, 3, 5, 8};
-  TypeParam my_set(vals, vals + 6);
-  TypeParam test_set(test_vals, test_vals + 5);
-  const Matcher<const TypeParam&> m = ContainerEq(my_set);
-  // Depending on the container, match may be true or false
-  // But in any case there should be no explanation.
-  EXPECT_EQ("", Explain(m, test_set));
-}
-#endif  // GTEST_HAS_TYPED_TEST
-
-// Tests that mutliple missing values are reported.
-// Using just vector here, so order is predicatble.
-TEST(ContainerEqExtraTest, MultipleValuesMissing) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {2, 1, 5};
-  vector<int> my_set(vals, vals + 6);
-  vector<int> test_set(test_vals, test_vals + 3);
-  const Matcher<vector<int> > m = ContainerEq(my_set);
-  EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("which doesn't have these expected elements: 3, 8",
-            Explain(m, test_set));
-}
-
-// Tests that added values are reported.
-// Using just vector here, so order is predicatble.
-TEST(ContainerEqExtraTest, MultipleValuesAdded) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {1, 2, 92, 3, 5, 8, 46};
-  list<size_t> my_set(vals, vals + 6);
-  list<size_t> test_set(test_vals, test_vals + 7);
-  const Matcher<const list<size_t>&> m = ContainerEq(my_set);
-  EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("which has these unexpected elements: 92, 46",
-            Explain(m, test_set));
-}
-
-// Tests that added and missing values are reported together.
-TEST(ContainerEqExtraTest, MultipleValuesAddedAndRemoved) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {1, 2, 3, 92, 46};
-  list<size_t> my_set(vals, vals + 6);
-  list<size_t> test_set(test_vals, test_vals + 5);
-  const Matcher<const list<size_t> > m = ContainerEq(my_set);
-  EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("which has these unexpected elements: 92, 46,\n"
-            "and doesn't have these expected elements: 5, 8",
-            Explain(m, test_set));
-}
-
-// Tests to see that duplicate elements are detected,
-// but (as above) not reported in the explanation.
-TEST(ContainerEqExtraTest, MultiSetOfIntDuplicateDifference) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {1, 2, 3, 5, 8};
-  vector<int> my_set(vals, vals + 6);
-  vector<int> test_set(test_vals, test_vals + 5);
-  const Matcher<vector<int> > m = ContainerEq(my_set);
-  EXPECT_TRUE(m.Matches(my_set));
-  EXPECT_FALSE(m.Matches(test_set));
-  // There is nothing to report when both sets contain all the same values.
-  EXPECT_EQ("", Explain(m, test_set));
-}
-
-// Tests that ContainerEq works for non-trivial associative containers,
-// like maps.
-TEST(ContainerEqExtraTest, WorksForMaps) {
-  map<int, std::string> my_map;
-  my_map[0] = "a";
-  my_map[1] = "b";
-
-  map<int, std::string> test_map;
-  test_map[0] = "aa";
-  test_map[1] = "b";
-
-  const Matcher<const map<int, std::string>&> m = ContainerEq(my_map);
-  EXPECT_TRUE(m.Matches(my_map));
-  EXPECT_FALSE(m.Matches(test_map));
-
-  EXPECT_EQ("which has these unexpected elements: (0, \"aa\"),\n"
-            "and doesn't have these expected elements: (0, \"a\")",
-            Explain(m, test_map));
-}
-
-TEST(ContainerEqExtraTest, WorksForNativeArray) {
-  int a1[] = {1, 2, 3};
-  int a2[] = {1, 2, 3};
-  int b[] = {1, 2, 4};
-
-  EXPECT_THAT(a1, ContainerEq(a2));
-  EXPECT_THAT(a1, Not(ContainerEq(b)));
-}
-
-TEST(ContainerEqExtraTest, WorksForTwoDimensionalNativeArray) {
-  const char a1[][3] = {"hi", "lo"};
-  const char a2[][3] = {"hi", "lo"};
-  const char b[][3] = {"lo", "hi"};
-
-  // Tests using ContainerEq() in the first dimension.
-  EXPECT_THAT(a1, ContainerEq(a2));
-  EXPECT_THAT(a1, Not(ContainerEq(b)));
-
-  // Tests using ContainerEq() in the second dimension.
-  EXPECT_THAT(a1, ElementsAre(ContainerEq(a2[0]), ContainerEq(a2[1])));
-  EXPECT_THAT(a1, ElementsAre(Not(ContainerEq(b[0])), ContainerEq(a2[1])));
-}
-
-TEST(ContainerEqExtraTest, WorksForNativeArrayAsTuple) {
-  const int a1[] = {1, 2, 3};
-  const int a2[] = {1, 2, 3};
-  const int b[] = {1, 2, 3, 4};
-
-  const int* const p1 = a1;
-  EXPECT_THAT(make_tuple(p1, 3), ContainerEq(a2));
-  EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(b)));
-
-  const int c[] = {1, 3, 2};
-  EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(c)));
-}
-
-TEST(ContainerEqExtraTest, CopiesNativeArrayParameter) {
-  std::string a1[][3] = {
-    {"hi", "hello", "ciao"},
-    {"bye", "see you", "ciao"}
-  };
-
-  std::string a2[][3] = {
-    {"hi", "hello", "ciao"},
-    {"bye", "see you", "ciao"}
-  };
-
-  const Matcher<const std::string(&)[2][3]> m = ContainerEq(a2);
-  EXPECT_THAT(a1, m);
-
-  a2[0][0] = "ha";
-  EXPECT_THAT(a1, m);
-}
-
-TEST(WhenSortedByTest, WorksForEmptyContainer) {
-  const vector<int> numbers;
-  EXPECT_THAT(numbers, WhenSortedBy(less<int>(), ElementsAre()));
-  EXPECT_THAT(numbers, Not(WhenSortedBy(less<int>(), ElementsAre(1))));
-}
-
-TEST(WhenSortedByTest, WorksForNonEmptyContainer) {
-  vector<unsigned> numbers;
-  numbers.push_back(3);
-  numbers.push_back(1);
-  numbers.push_back(2);
-  numbers.push_back(2);
-  EXPECT_THAT(numbers, WhenSortedBy(greater<unsigned>(),
-                                    ElementsAre(3, 2, 2, 1)));
-  EXPECT_THAT(numbers, Not(WhenSortedBy(greater<unsigned>(),
-                                        ElementsAre(1, 2, 2, 3))));
-}
-
-TEST(WhenSortedByTest, WorksForNonVectorContainer) {
-  list<string> words;
-  words.push_back("say");
-  words.push_back("hello");
-  words.push_back("world");
-  EXPECT_THAT(words, WhenSortedBy(less<string>(),
-                                  ElementsAre("hello", "say", "world")));
-  EXPECT_THAT(words, Not(WhenSortedBy(less<string>(),
-                                      ElementsAre("say", "hello", "world"))));
-}
-
-TEST(WhenSortedByTest, WorksForNativeArray) {
-  const int numbers[] = {1, 3, 2, 4};
-  const int sorted_numbers[] = {1, 2, 3, 4};
-  EXPECT_THAT(numbers, WhenSortedBy(less<int>(), ElementsAre(1, 2, 3, 4)));
-  EXPECT_THAT(numbers, WhenSortedBy(less<int>(),
-                                    ElementsAreArray(sorted_numbers)));
-  EXPECT_THAT(numbers, Not(WhenSortedBy(less<int>(), ElementsAre(1, 3, 2, 4))));
-}
-
-TEST(WhenSortedByTest, CanDescribeSelf) {
-  const Matcher<vector<int> > m = WhenSortedBy(less<int>(), ElementsAre(1, 2));
-  EXPECT_EQ("(when sorted) has 2 elements where\n"
-            "element #0 is equal to 1,\n"
-            "element #1 is equal to 2",
-            Describe(m));
-  EXPECT_EQ("(when sorted) doesn't have 2 elements, or\n"
-            "element #0 isn't equal to 1, or\n"
-            "element #1 isn't equal to 2",
-            DescribeNegation(m));
-}
-
-TEST(WhenSortedByTest, ExplainsMatchResult) {
-  const int a[] = {2, 1};
-  EXPECT_EQ("which is { 1, 2 } when sorted, whose element #0 doesn't match",
-            Explain(WhenSortedBy(less<int>(), ElementsAre(2, 3)), a));
-  EXPECT_EQ("which is { 1, 2 } when sorted",
-            Explain(WhenSortedBy(less<int>(), ElementsAre(1, 2)), a));
-}
-
-// WhenSorted() is a simple wrapper on WhenSortedBy().  Hence we don't
-// need to test it as exhaustively as we test the latter.
-
-TEST(WhenSortedTest, WorksForEmptyContainer) {
-  const vector<int> numbers;
-  EXPECT_THAT(numbers, WhenSorted(ElementsAre()));
-  EXPECT_THAT(numbers, Not(WhenSorted(ElementsAre(1))));
-}
-
-TEST(WhenSortedTest, WorksForNonEmptyContainer) {
-  list<string> words;
-  words.push_back("3");
-  words.push_back("1");
-  words.push_back("2");
-  words.push_back("2");
-  EXPECT_THAT(words, WhenSorted(ElementsAre("1", "2", "2", "3")));
-  EXPECT_THAT(words, Not(WhenSorted(ElementsAre("3", "1", "2", "2"))));
-}
-
-TEST(WhenSortedTest, WorksForMapTypes) {
-    map<string, int> word_counts;
-    word_counts["and"] = 1;
-    word_counts["the"] = 1;
-    word_counts["buffalo"] = 2;
-    EXPECT_THAT(word_counts, WhenSorted(ElementsAre(
-            Pair("and", 1), Pair("buffalo", 2), Pair("the", 1))));
-    EXPECT_THAT(word_counts, Not(WhenSorted(ElementsAre(
-            Pair("and", 1), Pair("the", 1), Pair("buffalo", 2)))));
-}
-
-TEST(WhenSortedTest, WorksForMultiMapTypes) {
-    multimap<int, int> ifib;
-    ifib.insert(make_pair(8, 6));
-    ifib.insert(make_pair(2, 3));
-    ifib.insert(make_pair(1, 1));
-    ifib.insert(make_pair(3, 4));
-    ifib.insert(make_pair(1, 2));
-    ifib.insert(make_pair(5, 5));
-    EXPECT_THAT(ifib, WhenSorted(ElementsAre(Pair(1, 1),
-                                             Pair(1, 2),
-                                             Pair(2, 3),
-                                             Pair(3, 4),
-                                             Pair(5, 5),
-                                             Pair(8, 6))));
-    EXPECT_THAT(ifib, Not(WhenSorted(ElementsAre(Pair(8, 6),
-                                                 Pair(2, 3),
-                                                 Pair(1, 1),
-                                                 Pair(3, 4),
-                                                 Pair(1, 2),
-                                                 Pair(5, 5)))));
-}
-
-TEST(WhenSortedTest, WorksForPolymorphicMatcher) {
-    std::deque<int> d;
-    d.push_back(2);
-    d.push_back(1);
-    EXPECT_THAT(d, WhenSorted(ElementsAre(1, 2)));
-    EXPECT_THAT(d, Not(WhenSorted(ElementsAre(2, 1))));
-}
-
-TEST(WhenSortedTest, WorksForVectorConstRefMatcher) {
-    std::deque<int> d;
-    d.push_back(2);
-    d.push_back(1);
-    Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2);
-    EXPECT_THAT(d, WhenSorted(vector_match));
-    Matcher<const std::vector<int>&> not_vector_match = ElementsAre(2, 1);
-    EXPECT_THAT(d, Not(WhenSorted(not_vector_match)));
-}
-
-// Deliberately bare pseudo-container.
-// Offers only begin() and end() accessors, yielding InputIterator.
-template <typename T>
-class Streamlike {
- private:
-  class ConstIter;
- public:
-  typedef ConstIter const_iterator;
-  typedef T value_type;
-
-  template <typename InIter>
-  Streamlike(InIter first, InIter last) : remainder_(first, last) {}
-
-  const_iterator begin() const {
-    return const_iterator(this, remainder_.begin());
-  }
-  const_iterator end() const {
-    return const_iterator(this, remainder_.end());
-  }
-
- private:
-  class ConstIter : public std::iterator<std::input_iterator_tag,
-                                         value_type,
-                                         ptrdiff_t,
-                                         const value_type*,
-                                         const value_type&> {
-   public:
-    ConstIter(const Streamlike* s,
-              typename std::list<value_type>::iterator pos)
-        : s_(s), pos_(pos) {}
-
-    const value_type& operator*() const { return *pos_; }
-    const value_type* operator->() const { return &*pos_; }
-    ConstIter& operator++() {
-      s_->remainder_.erase(pos_++);
-      return *this;
-    }
-
-    // *iter++ is required to work (see std::istreambuf_iterator).
-    // (void)iter++ is also required to work.
-    class PostIncrProxy {
-     public:
-      explicit PostIncrProxy(const value_type& value) : value_(value) {}
-      value_type operator*() const { return value_; }
-     private:
-      value_type value_;
-    };
-    PostIncrProxy operator++(int) {
-      PostIncrProxy proxy(**this);
-      ++(*this);
-      return proxy;
-    }
-
-    friend bool operator==(const ConstIter& a, const ConstIter& b) {
-      return a.s_ == b.s_ && a.pos_ == b.pos_;
-    }
-    friend bool operator!=(const ConstIter& a, const ConstIter& b) {
-      return !(a == b);
-    }
-
-   private:
-    const Streamlike* s_;
-    typename std::list<value_type>::iterator pos_;
-  };
-
-  friend std::ostream& operator<<(std::ostream& os, const Streamlike& s) {
-    os << "[";
-    typedef typename std::list<value_type>::const_iterator Iter;
-    const char* sep = "";
-    for (Iter it = s.remainder_.begin(); it != s.remainder_.end(); ++it) {
-      os << sep << *it;
-      sep = ",";
-    }
-    os << "]";
-    return os;
-  }
-
-  mutable std::list<value_type> remainder_;  // modified by iteration
-};
-
-TEST(StreamlikeTest, Iteration) {
-  const int a[5] = {2, 1, 4, 5, 3};
-  Streamlike<int> s(a, a + 5);
-  Streamlike<int>::const_iterator it = s.begin();
-  const int* ip = a;
-  while (it != s.end()) {
-    SCOPED_TRACE(ip - a);
-    EXPECT_EQ(*ip++, *it++);
-  }
-}
-
-#if GTEST_HAS_STD_FORWARD_LIST_
-TEST(BeginEndDistanceIsTest, WorksWithForwardList) {
-  std::forward_list<int> container;
-  EXPECT_THAT(container, BeginEndDistanceIs(0));
-  EXPECT_THAT(container, Not(BeginEndDistanceIs(1)));
-  container.push_front(0);
-  EXPECT_THAT(container, Not(BeginEndDistanceIs(0)));
-  EXPECT_THAT(container, BeginEndDistanceIs(1));
-  container.push_front(0);
-  EXPECT_THAT(container, Not(BeginEndDistanceIs(0)));
-  EXPECT_THAT(container, BeginEndDistanceIs(2));
-}
-#endif  // GTEST_HAS_STD_FORWARD_LIST_
-
-TEST(BeginEndDistanceIsTest, WorksWithNonStdList) {
-  const int a[5] = {1, 2, 3, 4, 5};
-  Streamlike<int> s(a, a + 5);
-  EXPECT_THAT(s, BeginEndDistanceIs(5));
-}
-
-TEST(BeginEndDistanceIsTest, CanDescribeSelf) {
-  Matcher<vector<int> > m = BeginEndDistanceIs(2);
-  EXPECT_EQ("distance between begin() and end() is equal to 2", Describe(m));
-  EXPECT_EQ("distance between begin() and end() isn't equal to 2",
-            DescribeNegation(m));
-}
-
-TEST(BeginEndDistanceIsTest, ExplainsResult) {
-  Matcher<vector<int> > m1 = BeginEndDistanceIs(2);
-  Matcher<vector<int> > m2 = BeginEndDistanceIs(Lt(2));
-  Matcher<vector<int> > m3 = BeginEndDistanceIs(AnyOf(0, 3));
-  Matcher<vector<int> > m4 = BeginEndDistanceIs(GreaterThan(1));
-  vector<int> container;
-  EXPECT_EQ("whose distance between begin() and end() 0 doesn't match",
-            Explain(m1, container));
-  EXPECT_EQ("whose distance between begin() and end() 0 matches",
-            Explain(m2, container));
-  EXPECT_EQ("whose distance between begin() and end() 0 matches",
-            Explain(m3, container));
-  EXPECT_EQ(
-      "whose distance between begin() and end() 0 doesn't match, which is 1 "
-      "less than 1",
-      Explain(m4, container));
-  container.push_back(0);
-  container.push_back(0);
-  EXPECT_EQ("whose distance between begin() and end() 2 matches",
-            Explain(m1, container));
-  EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
-            Explain(m2, container));
-  EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
-            Explain(m3, container));
-  EXPECT_EQ(
-      "whose distance between begin() and end() 2 matches, which is 1 more "
-      "than 1",
-      Explain(m4, container));
-}
-
-TEST(WhenSortedTest, WorksForStreamlike) {
-  // Streamlike 'container' provides only minimal iterator support.
-  // Its iterators are tagged with input_iterator_tag.
-  const int a[5] = {2, 1, 4, 5, 3};
-  Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
-  EXPECT_THAT(s, WhenSorted(ElementsAre(1, 2, 3, 4, 5)));
-  EXPECT_THAT(s, Not(WhenSorted(ElementsAre(2, 1, 4, 5, 3))));
-}
-
-TEST(WhenSortedTest, WorksForVectorConstRefMatcherOnStreamlike) {
-  const int a[] = {2, 1, 4, 5, 3};
-  Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
-  Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2, 3, 4, 5);
-  EXPECT_THAT(s, WhenSorted(vector_match));
-  EXPECT_THAT(s, Not(WhenSorted(ElementsAre(2, 1, 4, 5, 3))));
-}
-
-// Tests using ElementsAre() and ElementsAreArray() with stream-like
-// "containers".
-
-TEST(ElemensAreStreamTest, WorksForStreamlike) {
-  const int a[5] = {1, 2, 3, 4, 5};
-  Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
-  EXPECT_THAT(s, ElementsAre(1, 2, 3, 4, 5));
-  EXPECT_THAT(s, Not(ElementsAre(2, 1, 4, 5, 3)));
-}
-
-TEST(ElemensAreArrayStreamTest, WorksForStreamlike) {
-  const int a[5] = {1, 2, 3, 4, 5};
-  Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
-
-  vector<int> expected;
-  expected.push_back(1);
-  expected.push_back(2);
-  expected.push_back(3);
-  expected.push_back(4);
-  expected.push_back(5);
-  EXPECT_THAT(s, ElementsAreArray(expected));
-
-  expected[3] = 0;
-  EXPECT_THAT(s, Not(ElementsAreArray(expected)));
-}
-
-TEST(ElementsAreTest, WorksWithUncopyable) {
-  Uncopyable objs[2];
-  objs[0].set_value(-3);
-  objs[1].set_value(1);
-  EXPECT_THAT(objs, ElementsAre(UncopyableIs(-3), Truly(ValueIsPositive)));
-}
-
-TEST(ElementsAreTest, TakesStlContainer) {
-  const int actual[] = {3, 1, 2};
-
-  ::std::list<int> expected;
-  expected.push_back(3);
-  expected.push_back(1);
-  expected.push_back(2);
-  EXPECT_THAT(actual, ElementsAreArray(expected));
-
-  expected.push_back(4);
-  EXPECT_THAT(actual, Not(ElementsAreArray(expected)));
-}
-
-// Tests for UnorderedElementsAreArray()
-
-TEST(UnorderedElementsAreArrayTest, SucceedsWhenExpected) {
-  const int a[] = {0, 1, 2, 3, 4};
-  std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
-  do {
-    StringMatchResultListener listener;
-    EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(a),
-                                   s, &listener)) << listener.str();
-  } while (std::next_permutation(s.begin(), s.end()));
-}
-
-TEST(UnorderedElementsAreArrayTest, VectorBool) {
-  const bool a[] = {0, 1, 0, 1, 1};
-  const bool b[] = {1, 0, 1, 1, 0};
-  std::vector<bool> expected(a, a + GTEST_ARRAY_SIZE_(a));
-  std::vector<bool> actual(b, b + GTEST_ARRAY_SIZE_(b));
-  StringMatchResultListener listener;
-  EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(expected),
-                                 actual, &listener)) << listener.str();
-}
-
-TEST(UnorderedElementsAreArrayTest, WorksForStreamlike) {
-  // Streamlike 'container' provides only minimal iterator support.
-  // Its iterators are tagged with input_iterator_tag, and it has no
-  // size() or empty() methods.
-  const int a[5] = {2, 1, 4, 5, 3};
-  Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
-
-  ::std::vector<int> expected;
-  expected.push_back(1);
-  expected.push_back(2);
-  expected.push_back(3);
-  expected.push_back(4);
-  expected.push_back(5);
-  EXPECT_THAT(s, UnorderedElementsAreArray(expected));
-
-  expected.push_back(6);
-  EXPECT_THAT(s, Not(UnorderedElementsAreArray(expected)));
-}
-
-TEST(UnorderedElementsAreArrayTest, TakesStlContainer) {
-  const int actual[] = {3, 1, 2};
-
-  ::std::list<int> expected;
-  expected.push_back(1);
-  expected.push_back(2);
-  expected.push_back(3);
-  EXPECT_THAT(actual, UnorderedElementsAreArray(expected));
-
-  expected.push_back(4);
-  EXPECT_THAT(actual, Not(UnorderedElementsAreArray(expected)));
-}
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-
-TEST(UnorderedElementsAreArrayTest, TakesInitializerList) {
-  const int a[5] = {2, 1, 4, 5, 3};
-  EXPECT_THAT(a, UnorderedElementsAreArray({1, 2, 3, 4, 5}));
-  EXPECT_THAT(a, Not(UnorderedElementsAreArray({1, 2, 3, 4, 6})));
-}
-
-TEST(UnorderedElementsAreArrayTest, TakesInitializerListOfCStrings) {
-  const string a[5] = {"a", "b", "c", "d", "e"};
-  EXPECT_THAT(a, UnorderedElementsAreArray({"a", "b", "c", "d", "e"}));
-  EXPECT_THAT(a, Not(UnorderedElementsAreArray({"a", "b", "c", "d", "ef"})));
-}
-
-TEST(UnorderedElementsAreArrayTest, TakesInitializerListOfSameTypedMatchers) {
-  const int a[5] = {2, 1, 4, 5, 3};
-  EXPECT_THAT(a, UnorderedElementsAreArray(
-      {Eq(1), Eq(2), Eq(3), Eq(4), Eq(5)}));
-  EXPECT_THAT(a, Not(UnorderedElementsAreArray(
-      {Eq(1), Eq(2), Eq(3), Eq(4), Eq(6)})));
-}
-
-TEST(UnorderedElementsAreArrayTest,
-     TakesInitializerListOfDifferentTypedMatchers) {
-  const int a[5] = {2, 1, 4, 5, 3};
-  // The compiler cannot infer the type of the initializer list if its
-  // elements have different types.  We must explicitly specify the
-  // unified element type in this case.
-  EXPECT_THAT(a, UnorderedElementsAreArray<Matcher<int> >(
-      {Eq(1), Ne(-2), Ge(3), Le(4), Eq(5)}));
-  EXPECT_THAT(a, Not(UnorderedElementsAreArray<Matcher<int> >(
-      {Eq(1), Ne(-2), Ge(3), Le(4), Eq(6)})));
-}
-
-#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
-
-class UnorderedElementsAreTest : public testing::Test {
- protected:
-  typedef std::vector<int> IntVec;
-};
-
-TEST_F(UnorderedElementsAreTest, WorksWithUncopyable) {
-  Uncopyable objs[2];
-  objs[0].set_value(-3);
-  objs[1].set_value(1);
-  EXPECT_THAT(objs,
-              UnorderedElementsAre(Truly(ValueIsPositive), UncopyableIs(-3)));
-}
-
-TEST_F(UnorderedElementsAreTest, SucceedsWhenExpected) {
-  const int a[] = {1, 2, 3};
-  std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
-  do {
-    StringMatchResultListener listener;
-    EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
-                                   s, &listener)) << listener.str();
-  } while (std::next_permutation(s.begin(), s.end()));
-}
-
-TEST_F(UnorderedElementsAreTest, FailsWhenAnElementMatchesNoMatcher) {
-  const int a[] = {1, 2, 3};
-  std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
-  std::vector<Matcher<int> > mv;
-  mv.push_back(1);
-  mv.push_back(2);
-  mv.push_back(2);
-  // The element with value '3' matches nothing: fail fast.
-  StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAreArray(mv),
-                                  s, &listener)) << listener.str();
-}
-
-TEST_F(UnorderedElementsAreTest, WorksForStreamlike) {
-  // Streamlike 'container' provides only minimal iterator support.
-  // Its iterators are tagged with input_iterator_tag, and it has no
-  // size() or empty() methods.
-  const int a[5] = {2, 1, 4, 5, 3};
-  Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
-
-  EXPECT_THAT(s, UnorderedElementsAre(1, 2, 3, 4, 5));
-  EXPECT_THAT(s, Not(UnorderedElementsAre(2, 2, 3, 4, 5)));
-}
-
-// One naive implementation of the matcher runs in O(N!) time, which is too
-// slow for many real-world inputs. This test shows that our matcher can match
-// 100 inputs very quickly (a few milliseconds).  An O(100!) is 10^158
-// iterations and obviously effectively incomputable.
-// [ RUN      ] UnorderedElementsAreTest.Performance
-// [       OK ] UnorderedElementsAreTest.Performance (4 ms)
-TEST_F(UnorderedElementsAreTest, Performance) {
-  std::vector<int> s;
-  std::vector<Matcher<int> > mv;
-  for (int i = 0; i < 100; ++i) {
-    s.push_back(i);
-    mv.push_back(_);
-  }
-  mv[50] = Eq(0);
-  StringMatchResultListener listener;
-  EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv),
-                                 s, &listener)) << listener.str();
-}
-
-// Another variant of 'Performance' with similar expectations.
-// [ RUN      ] UnorderedElementsAreTest.PerformanceHalfStrict
-// [       OK ] UnorderedElementsAreTest.PerformanceHalfStrict (4 ms)
-TEST_F(UnorderedElementsAreTest, PerformanceHalfStrict) {
-  std::vector<int> s;
-  std::vector<Matcher<int> > mv;
-  for (int i = 0; i < 100; ++i) {
-    s.push_back(i);
-    if (i & 1) {
-      mv.push_back(_);
-    } else {
-      mv.push_back(i);
-    }
-  }
-  StringMatchResultListener listener;
-  EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv),
-                                 s, &listener)) << listener.str();
-}
-
-TEST_F(UnorderedElementsAreTest, FailMessageCountWrong) {
-  std::vector<int> v;
-  v.push_back(4);
-  StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
-                                  v, &listener)) << listener.str();
-  EXPECT_THAT(listener.str(), Eq("which has 1 element"));
-}
-
-TEST_F(UnorderedElementsAreTest, FailMessageCountWrongZero) {
-  std::vector<int> v;
-  StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
-                                  v, &listener)) << listener.str();
-  EXPECT_THAT(listener.str(), Eq(""));
-}
-
-TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatchers) {
-  std::vector<int> v;
-  v.push_back(1);
-  v.push_back(1);
-  StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2),
-                                  v, &listener)) << listener.str();
-  EXPECT_THAT(
-      listener.str(),
-      Eq("where the following matchers don't match any elements:\n"
-         "matcher #1: is equal to 2"));
-}
-
-TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedElements) {
-  std::vector<int> v;
-  v.push_back(1);
-  v.push_back(2);
-  StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 1),
-                                  v, &listener)) << listener.str();
-  EXPECT_THAT(
-      listener.str(),
-      Eq("where the following elements don't match any matchers:\n"
-         "element #1: 2"));
-}
-
-TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatcherAndElement) {
-  std::vector<int> v;
-  v.push_back(2);
-  v.push_back(3);
-  StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2),
-                                  v, &listener)) << listener.str();
-  EXPECT_THAT(
-      listener.str(),
-      Eq("where"
-         " the following matchers don't match any elements:\n"
-         "matcher #0: is equal to 1\n"
-         "and"
-         " where"
-         " the following elements don't match any matchers:\n"
-         "element #1: 3"));
-}
-
-// Test helper for formatting element, matcher index pairs in expectations.
-static string EMString(int element, int matcher) {
-  stringstream ss;
-  ss << "(element #" << element << ", matcher #" << matcher << ")";
-  return ss.str();
-}
-
-TEST_F(UnorderedElementsAreTest, FailMessageImperfectMatchOnly) {
-  // A situation where all elements and matchers have a match
-  // associated with them, but the max matching is not perfect.
-  std::vector<string> v;
-  v.push_back("a");
-  v.push_back("b");
-  v.push_back("c");
-  StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(
-      UnorderedElementsAre("a", "a", AnyOf("b", "c")), v, &listener))
-      << listener.str();
-
-  string prefix =
-      "where no permutation of the elements can satisfy all matchers, "
-      "and the closest match is 2 of 3 matchers with the "
-      "pairings:\n";
-
-  // We have to be a bit loose here, because there are 4 valid max matches.
-  EXPECT_THAT(
-      listener.str(),
-      AnyOf(prefix + "{\n  " + EMString(0, 0) +
-                     ",\n  " + EMString(1, 2) + "\n}",
-            prefix + "{\n  " + EMString(0, 1) +
-                     ",\n  " + EMString(1, 2) + "\n}",
-            prefix + "{\n  " + EMString(0, 0) +
-                     ",\n  " + EMString(2, 2) + "\n}",
-            prefix + "{\n  " + EMString(0, 1) +
-                     ",\n  " + EMString(2, 2) + "\n}"));
-}
-
-TEST_F(UnorderedElementsAreTest, Describe) {
-  EXPECT_THAT(Describe<IntVec>(UnorderedElementsAre()),
-              Eq("is empty"));
-  EXPECT_THAT(
-      Describe<IntVec>(UnorderedElementsAre(345)),
-      Eq("has 1 element and that element is equal to 345"));
-  EXPECT_THAT(
-      Describe<IntVec>(UnorderedElementsAre(111, 222, 333)),
-      Eq("has 3 elements and there exists some permutation "
-         "of elements such that:\n"
-         " - element #0 is equal to 111, and\n"
-         " - element #1 is equal to 222, and\n"
-         " - element #2 is equal to 333"));
-}
-
-TEST_F(UnorderedElementsAreTest, DescribeNegation) {
-  EXPECT_THAT(DescribeNegation<IntVec>(UnorderedElementsAre()),
-              Eq("isn't empty"));
-  EXPECT_THAT(
-      DescribeNegation<IntVec>(UnorderedElementsAre(345)),
-      Eq("doesn't have 1 element, or has 1 element that isn't equal to 345"));
-  EXPECT_THAT(
-      DescribeNegation<IntVec>(UnorderedElementsAre(123, 234, 345)),
-      Eq("doesn't have 3 elements, or there exists no permutation "
-         "of elements such that:\n"
-         " - element #0 is equal to 123, and\n"
-         " - element #1 is equal to 234, and\n"
-         " - element #2 is equal to 345"));
-}
-
-namespace {
-
-// Used as a check on the more complex max flow method used in the
-// real testing::internal::FindMaxBipartiteMatching. This method is
-// compatible but runs in worst-case factorial time, so we only
-// use it in testing for small problem sizes.
-template <typename Graph>
-class BacktrackingMaxBPMState {
- public:
-  // Does not take ownership of 'g'.
-  explicit BacktrackingMaxBPMState(const Graph* g) : graph_(g) { }
-
-  ElementMatcherPairs Compute() {
-    if (graph_->LhsSize() == 0 || graph_->RhsSize() == 0) {
-      return best_so_far_;
-    }
-    lhs_used_.assign(graph_->LhsSize(), kUnused);
-    rhs_used_.assign(graph_->RhsSize(), kUnused);
-    for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
-      matches_.clear();
-      RecurseInto(irhs);
-      if (best_so_far_.size() == graph_->RhsSize())
-        break;
-    }
-    return best_so_far_;
-  }
-
- private:
-  static const size_t kUnused = static_cast<size_t>(-1);
-
-  void PushMatch(size_t lhs, size_t rhs) {
-    matches_.push_back(ElementMatcherPair(lhs, rhs));
-    lhs_used_[lhs] = rhs;
-    rhs_used_[rhs] = lhs;
-    if (matches_.size() > best_so_far_.size()) {
-      best_so_far_ = matches_;
-    }
-  }
-
-  void PopMatch() {
-    const ElementMatcherPair& back = matches_.back();
-    lhs_used_[back.first] = kUnused;
-    rhs_used_[back.second] = kUnused;
-    matches_.pop_back();
-  }
-
-  bool RecurseInto(size_t irhs) {
-    if (rhs_used_[irhs] != kUnused) {
-      return true;
-    }
-    for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
-      if (lhs_used_[ilhs] != kUnused) {
-        continue;
-      }
-      if (!graph_->HasEdge(ilhs, irhs)) {
-        continue;
-      }
-      PushMatch(ilhs, irhs);
-      if (best_so_far_.size() == graph_->RhsSize()) {
-        return false;
-      }
-      for (size_t mi = irhs + 1; mi < graph_->RhsSize(); ++mi) {
-        if (!RecurseInto(mi)) return false;
-      }
-      PopMatch();
-    }
-    return true;
-  }
-
-  const Graph* graph_;  // not owned
-  std::vector<size_t> lhs_used_;
-  std::vector<size_t> rhs_used_;
-  ElementMatcherPairs matches_;
-  ElementMatcherPairs best_so_far_;
-};
-
-template <typename Graph>
-const size_t BacktrackingMaxBPMState<Graph>::kUnused;
-
-}  // namespace
-
-// Implement a simple backtracking algorithm to determine if it is possible
-// to find one element per matcher, without reusing elements.
-template <typename Graph>
-ElementMatcherPairs
-FindBacktrackingMaxBPM(const Graph& g) {
-  return BacktrackingMaxBPMState<Graph>(&g).Compute();
-}
-
-class BacktrackingBPMTest : public ::testing::Test { };
-
-// Tests the MaxBipartiteMatching algorithm with square matrices.
-// The single int param is the # of nodes on each of the left and right sides.
-class BipartiteTest : public ::testing::TestWithParam<int> { };
-
-// Verify all match graphs up to some moderate number of edges.
-TEST_P(BipartiteTest, Exhaustive) {
-  int nodes = GetParam();
-  MatchMatrix graph(nodes, nodes);
-  do {
-    ElementMatcherPairs matches =
-        internal::FindMaxBipartiteMatching(graph);
-    EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(), matches.size())
-        << "graph: " << graph.DebugString();
-    // Check that all elements of matches are in the graph.
-    // Check that elements of first and second are unique.
-    std::vector<bool> seen_element(graph.LhsSize());
-    std::vector<bool> seen_matcher(graph.RhsSize());
-    SCOPED_TRACE(PrintToString(matches));
-    for (size_t i = 0; i < matches.size(); ++i) {
-      size_t ilhs = matches[i].first;
-      size_t irhs = matches[i].second;
-      EXPECT_TRUE(graph.HasEdge(ilhs, irhs));
-      EXPECT_FALSE(seen_element[ilhs]);
-      EXPECT_FALSE(seen_matcher[irhs]);
-      seen_element[ilhs] = true;
-      seen_matcher[irhs] = true;
-    }
-  } while (graph.NextGraph());
-}
-
-INSTANTIATE_TEST_CASE_P(AllGraphs, BipartiteTest,
-                        ::testing::Range(0, 5));
-
-// Parameterized by a pair interpreted as (LhsSize, RhsSize).
-class BipartiteNonSquareTest
-    : public ::testing::TestWithParam<std::pair<size_t, size_t> > {
-};
-
-TEST_F(BipartiteNonSquareTest, SimpleBacktracking) {
-  //   .......
-  // 0:-----\ :
-  // 1:---\ | :
-  // 2:---\ | :
-  // 3:-\ | | :
-  //  :.......:
-  //    0 1 2
-  MatchMatrix g(4, 3);
-  static const int kEdges[][2] = {{0, 2}, {1, 1}, {2, 1}, {3, 0}};
-  for (size_t i = 0; i < GTEST_ARRAY_SIZE_(kEdges); ++i) {
-    g.SetEdge(kEdges[i][0], kEdges[i][1], true);
-  }
-  EXPECT_THAT(FindBacktrackingMaxBPM(g),
-              ElementsAre(Pair(3, 0),
-                          Pair(AnyOf(1, 2), 1),
-                          Pair(0, 2))) << g.DebugString();
-}
-
-// Verify a few nonsquare matrices.
-TEST_P(BipartiteNonSquareTest, Exhaustive) {
-  size_t nlhs = GetParam().first;
-  size_t nrhs = GetParam().second;
-  MatchMatrix graph(nlhs, nrhs);
-  do {
-    EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
-              internal::FindMaxBipartiteMatching(graph).size())
-        << "graph: " << graph.DebugString()
-        << "\nbacktracking: "
-        << PrintToString(FindBacktrackingMaxBPM(graph))
-        << "\nmax flow: "
-        << PrintToString(internal::FindMaxBipartiteMatching(graph));
-  } while (graph.NextGraph());
-}
-
-INSTANTIATE_TEST_CASE_P(AllGraphs, BipartiteNonSquareTest,
-    testing::Values(
-        std::make_pair(1, 2),
-        std::make_pair(2, 1),
-        std::make_pair(3, 2),
-        std::make_pair(2, 3),
-        std::make_pair(4, 1),
-        std::make_pair(1, 4),
-        std::make_pair(4, 3),
-        std::make_pair(3, 4)));
-
-class BipartiteRandomTest
-    : public ::testing::TestWithParam<std::pair<int, int> > {
-};
-
-// Verifies a large sample of larger graphs.
-TEST_P(BipartiteRandomTest, LargerNets) {
-  int nodes = GetParam().first;
-  int iters = GetParam().second;
-  MatchMatrix graph(nodes, nodes);
-
-  testing::internal::Int32 seed = GTEST_FLAG(random_seed);
-  if (seed == 0) {
-    seed = static_cast<testing::internal::Int32>(time(NULL));
-  }
-
-  for (; iters > 0; --iters, ++seed) {
-    srand(static_cast<int>(seed));
-    graph.Randomize();
-    EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
-              internal::FindMaxBipartiteMatching(graph).size())
-        << " graph: " << graph.DebugString()
-        << "\nTo reproduce the failure, rerun the test with the flag"
-           " --" << GTEST_FLAG_PREFIX_ << "random_seed=" << seed;
-  }
-}
-
-// Test argument is a std::pair<int, int> representing (nodes, iters).
-INSTANTIATE_TEST_CASE_P(Samples, BipartiteRandomTest,
-    testing::Values(
-        std::make_pair(5, 10000),
-        std::make_pair(6, 5000),
-        std::make_pair(7, 2000),
-        std::make_pair(8, 500),
-        std::make_pair(9, 100)));
-
-// Tests IsReadableTypeName().
-
-TEST(IsReadableTypeNameTest, ReturnsTrueForShortNames) {
-  EXPECT_TRUE(IsReadableTypeName("int"));
-  EXPECT_TRUE(IsReadableTypeName("const unsigned char*"));
-  EXPECT_TRUE(IsReadableTypeName("MyMap<int, void*>"));
-  EXPECT_TRUE(IsReadableTypeName("void (*)(int, bool)"));
-}
-
-TEST(IsReadableTypeNameTest, ReturnsTrueForLongNonTemplateNonFunctionNames) {
-  EXPECT_TRUE(IsReadableTypeName("my_long_namespace::MyClassName"));
-  EXPECT_TRUE(IsReadableTypeName("int [5][6][7][8][9][10][11]"));
-  EXPECT_TRUE(IsReadableTypeName("my_namespace::MyOuterClass::MyInnerClass"));
-}
-
-TEST(IsReadableTypeNameTest, ReturnsFalseForLongTemplateNames) {
-  EXPECT_FALSE(
-      IsReadableTypeName("basic_string<char, std::char_traits<char> >"));
-  EXPECT_FALSE(IsReadableTypeName("std::vector<int, std::alloc_traits<int> >"));
-}
-
-TEST(IsReadableTypeNameTest, ReturnsFalseForLongFunctionTypeNames) {
-  EXPECT_FALSE(IsReadableTypeName("void (&)(int, bool, char, float)"));
-}
-
-// Tests JoinAsTuple().
-
-TEST(JoinAsTupleTest, JoinsEmptyTuple) {
-  EXPECT_EQ("", JoinAsTuple(Strings()));
-}
-
-TEST(JoinAsTupleTest, JoinsOneTuple) {
-  const char* fields[] = {"1"};
-  EXPECT_EQ("1", JoinAsTuple(Strings(fields, fields + 1)));
-}
-
-TEST(JoinAsTupleTest, JoinsTwoTuple) {
-  const char* fields[] = {"1", "a"};
-  EXPECT_EQ("(1, a)", JoinAsTuple(Strings(fields, fields + 2)));
-}
-
-TEST(JoinAsTupleTest, JoinsTenTuple) {
-  const char* fields[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
-  EXPECT_EQ("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)",
-            JoinAsTuple(Strings(fields, fields + 10)));
-}
-
-// Tests FormatMatcherDescription().
-
-TEST(FormatMatcherDescriptionTest, WorksForEmptyDescription) {
-  EXPECT_EQ("is even",
-            FormatMatcherDescription(false, "IsEven", Strings()));
-  EXPECT_EQ("not (is even)",
-            FormatMatcherDescription(true, "IsEven", Strings()));
-
-  const char* params[] = {"5"};
-  EXPECT_EQ("equals 5",
-            FormatMatcherDescription(false, "Equals",
-                                     Strings(params, params + 1)));
-
-  const char* params2[] = {"5", "8"};
-  EXPECT_EQ("is in range (5, 8)",
-            FormatMatcherDescription(false, "IsInRange",
-                                     Strings(params2, params2 + 2)));
-}
-
-// Tests PolymorphicMatcher::mutable_impl().
-TEST(PolymorphicMatcherTest, CanAccessMutableImpl) {
-  PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
-  DivisibleByImpl& impl = m.mutable_impl();
-  EXPECT_EQ(42, impl.divider());
-
-  impl.set_divider(0);
-  EXPECT_EQ(0, m.mutable_impl().divider());
-}
-
-// Tests PolymorphicMatcher::impl().
-TEST(PolymorphicMatcherTest, CanAccessImpl) {
-  const PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
-  const DivisibleByImpl& impl = m.impl();
-  EXPECT_EQ(42, impl.divider());
-}
-
-TEST(MatcherTupleTest, ExplainsMatchFailure) {
-  stringstream ss1;
-  ExplainMatchFailureTupleTo(make_tuple(Matcher<char>(Eq('a')), GreaterThan(5)),
-                             make_tuple('a', 10), &ss1);
-  EXPECT_EQ("", ss1.str());  // Successful match.
-
-  stringstream ss2;
-  ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
-                             make_tuple(2, 'b'), &ss2);
-  EXPECT_EQ("  Expected arg #0: is > 5\n"
-            "           Actual: 2, which is 3 less than 5\n"
-            "  Expected arg #1: is equal to 'a' (97, 0x61)\n"
-            "           Actual: 'b' (98, 0x62)\n",
-            ss2.str());  // Failed match where both arguments need explanation.
-
-  stringstream ss3;
-  ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
-                             make_tuple(2, 'a'), &ss3);
-  EXPECT_EQ("  Expected arg #0: is > 5\n"
-            "           Actual: 2, which is 3 less than 5\n",
-            ss3.str());  // Failed match where only one argument needs
-                         // explanation.
-}
-
-// Tests Each().
-
-TEST(EachTest, ExplainsMatchResultCorrectly) {
-  set<int> a;  // empty
-
-  Matcher<set<int> > m = Each(2);
-  EXPECT_EQ("", Explain(m, a));
-
-  Matcher<const int(&)[1]> n = Each(1);  // NOLINT
-
-  const int b[1] = {1};
-  EXPECT_EQ("", Explain(n, b));
-
-  n = Each(3);
-  EXPECT_EQ("whose element #0 doesn't match", Explain(n, b));
-
-  a.insert(1);
-  a.insert(2);
-  a.insert(3);
-  m = Each(GreaterThan(0));
-  EXPECT_EQ("", Explain(m, a));
-
-  m = Each(GreaterThan(10));
-  EXPECT_EQ("whose element #0 doesn't match, which is 9 less than 10",
-            Explain(m, a));
-}
-
-TEST(EachTest, DescribesItselfCorrectly) {
-  Matcher<vector<int> > m = Each(1);
-  EXPECT_EQ("only contains elements that is equal to 1", Describe(m));
-
-  Matcher<vector<int> > m2 = Not(m);
-  EXPECT_EQ("contains some element that isn't equal to 1", Describe(m2));
-}
-
-TEST(EachTest, MatchesVectorWhenAllElementsMatch) {
-  vector<int> some_vector;
-  EXPECT_THAT(some_vector, Each(1));
-  some_vector.push_back(3);
-  EXPECT_THAT(some_vector, Not(Each(1)));
-  EXPECT_THAT(some_vector, Each(3));
-  some_vector.push_back(1);
-  some_vector.push_back(2);
-  EXPECT_THAT(some_vector, Not(Each(3)));
-  EXPECT_THAT(some_vector, Each(Lt(3.5)));
-
-  vector<string> another_vector;
-  another_vector.push_back("fee");
-  EXPECT_THAT(another_vector, Each(string("fee")));
-  another_vector.push_back("fie");
-  another_vector.push_back("foe");
-  another_vector.push_back("fum");
-  EXPECT_THAT(another_vector, Not(Each(string("fee"))));
-}
-
-TEST(EachTest, MatchesMapWhenAllElementsMatch) {
-  map<const char*, int> my_map;
-  const char* bar = "a string";
-  my_map[bar] = 2;
-  EXPECT_THAT(my_map, Each(make_pair(bar, 2)));
-
-  map<string, int> another_map;
-  EXPECT_THAT(another_map, Each(make_pair(string("fee"), 1)));
-  another_map["fee"] = 1;
-  EXPECT_THAT(another_map, Each(make_pair(string("fee"), 1)));
-  another_map["fie"] = 2;
-  another_map["foe"] = 3;
-  another_map["fum"] = 4;
-  EXPECT_THAT(another_map, Not(Each(make_pair(string("fee"), 1))));
-  EXPECT_THAT(another_map, Not(Each(make_pair(string("fum"), 1))));
-  EXPECT_THAT(another_map, Each(Pair(_, Gt(0))));
-}
-
-TEST(EachTest, AcceptsMatcher) {
-  const int a[] = {1, 2, 3};
-  EXPECT_THAT(a, Each(Gt(0)));
-  EXPECT_THAT(a, Not(Each(Gt(1))));
-}
-
-TEST(EachTest, WorksForNativeArrayAsTuple) {
-  const int a[] = {1, 2};
-  const int* const pointer = a;
-  EXPECT_THAT(make_tuple(pointer, 2), Each(Gt(0)));
-  EXPECT_THAT(make_tuple(pointer, 2), Not(Each(Gt(1))));
-}
-
-// For testing Pointwise().
-class IsHalfOfMatcher {
- public:
-  template <typename T1, typename T2>
-  bool MatchAndExplain(const tuple<T1, T2>& a_pair,
-                       MatchResultListener* listener) const {
-    if (get<0>(a_pair) == get<1>(a_pair)/2) {
-      *listener << "where the second is " << get<1>(a_pair);
-      return true;
-    } else {
-      *listener << "where the second/2 is " << get<1>(a_pair)/2;
-      return false;
-    }
-  }
-
-  void DescribeTo(ostream* os) const {
-    *os << "are a pair where the first is half of the second";
-  }
-
-  void DescribeNegationTo(ostream* os) const {
-    *os << "are a pair where the first isn't half of the second";
-  }
-};
-
-PolymorphicMatcher<IsHalfOfMatcher> IsHalfOf() {
-  return MakePolymorphicMatcher(IsHalfOfMatcher());
-}
-
-TEST(PointwiseTest, DescribesSelf) {
-  vector<int> rhs;
-  rhs.push_back(1);
-  rhs.push_back(2);
-  rhs.push_back(3);
-  const Matcher<const vector<int>&> m = Pointwise(IsHalfOf(), rhs);
-  EXPECT_EQ("contains 3 values, where each value and its corresponding value "
-            "in { 1, 2, 3 } are a pair where the first is half of the second",
-            Describe(m));
-  EXPECT_EQ("doesn't contain exactly 3 values, or contains a value x at some "
-            "index i where x and the i-th value of { 1, 2, 3 } are a pair "
-            "where the first isn't half of the second",
-            DescribeNegation(m));
-}
-
-TEST(PointwiseTest, MakesCopyOfRhs) {
-  list<signed char> rhs;
-  rhs.push_back(2);
-  rhs.push_back(4);
-
-  int lhs[] = {1, 2};
-  const Matcher<const int (&)[2]> m = Pointwise(IsHalfOf(), rhs);
-  EXPECT_THAT(lhs, m);
-
-  // Changing rhs now shouldn't affect m, which made a copy of rhs.
-  rhs.push_back(6);
-  EXPECT_THAT(lhs, m);
-}
-
-TEST(PointwiseTest, WorksForLhsNativeArray) {
-  const int lhs[] = {1, 2, 3};
-  vector<int> rhs;
-  rhs.push_back(2);
-  rhs.push_back(4);
-  rhs.push_back(6);
-  EXPECT_THAT(lhs, Pointwise(Lt(), rhs));
-  EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs)));
-}
-
-TEST(PointwiseTest, WorksForRhsNativeArray) {
-  const int rhs[] = {1, 2, 3};
-  vector<int> lhs;
-  lhs.push_back(2);
-  lhs.push_back(4);
-  lhs.push_back(6);
-  EXPECT_THAT(lhs, Pointwise(Gt(), rhs));
-  EXPECT_THAT(lhs, Not(Pointwise(Lt(), rhs)));
-}
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-
-TEST(PointwiseTest, WorksForRhsInitializerList) {
-  const vector<int> lhs{2, 4, 6};
-  EXPECT_THAT(lhs, Pointwise(Gt(), {1, 2, 3}));
-  EXPECT_THAT(lhs, Not(Pointwise(Lt(), {3, 3, 7})));
-}
-
-#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
-
-TEST(PointwiseTest, RejectsWrongSize) {
-  const double lhs[2] = {1, 2};
-  const int rhs[1] = {0};
-  EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs)));
-  EXPECT_EQ("which contains 2 values",
-            Explain(Pointwise(Gt(), rhs), lhs));
-
-  const int rhs2[3] = {0, 1, 2};
-  EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs2)));
-}
-
-TEST(PointwiseTest, RejectsWrongContent) {
-  const double lhs[3] = {1, 2, 3};
-  const int rhs[3] = {2, 6, 4};
-  EXPECT_THAT(lhs, Not(Pointwise(IsHalfOf(), rhs)));
-  EXPECT_EQ("where the value pair (2, 6) at index #1 don't match, "
-            "where the second/2 is 3",
-            Explain(Pointwise(IsHalfOf(), rhs), lhs));
-}
-
-TEST(PointwiseTest, AcceptsCorrectContent) {
-  const double lhs[3] = {1, 2, 3};
-  const int rhs[3] = {2, 4, 6};
-  EXPECT_THAT(lhs, Pointwise(IsHalfOf(), rhs));
-  EXPECT_EQ("", Explain(Pointwise(IsHalfOf(), rhs), lhs));
-}
-
-TEST(PointwiseTest, AllowsMonomorphicInnerMatcher) {
-  const double lhs[3] = {1, 2, 3};
-  const int rhs[3] = {2, 4, 6};
-  const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf();
-  EXPECT_THAT(lhs, Pointwise(m1, rhs));
-  EXPECT_EQ("", Explain(Pointwise(m1, rhs), lhs));
-
-  // This type works as a tuple<const double&, const int&> can be
-  // implicitly cast to tuple<double, int>.
-  const Matcher<tuple<double, int> > m2 = IsHalfOf();
-  EXPECT_THAT(lhs, Pointwise(m2, rhs));
-  EXPECT_EQ("", Explain(Pointwise(m2, rhs), lhs));
-}
-
-TEST(UnorderedPointwiseTest, DescribesSelf) {
-  vector<int> rhs;
-  rhs.push_back(1);
-  rhs.push_back(2);
-  rhs.push_back(3);
-  const Matcher<const vector<int>&> m = UnorderedPointwise(IsHalfOf(), rhs);
-  EXPECT_EQ(
-      "has 3 elements and there exists some permutation of elements such "
-      "that:\n"
-      " - element #0 and 1 are a pair where the first is half of the second, "
-      "and\n"
-      " - element #1 and 2 are a pair where the first is half of the second, "
-      "and\n"
-      " - element #2 and 3 are a pair where the first is half of the second",
-      Describe(m));
-  EXPECT_EQ(
-      "doesn't have 3 elements, or there exists no permutation of elements "
-      "such that:\n"
-      " - element #0 and 1 are a pair where the first is half of the second, "
-      "and\n"
-      " - element #1 and 2 are a pair where the first is half of the second, "
-      "and\n"
-      " - element #2 and 3 are a pair where the first is half of the second",
-      DescribeNegation(m));
-}
-
-TEST(UnorderedPointwiseTest, MakesCopyOfRhs) {
-  list<signed char> rhs;
-  rhs.push_back(2);
-  rhs.push_back(4);
-
-  int lhs[] = {2, 1};
-  const Matcher<const int (&)[2]> m = UnorderedPointwise(IsHalfOf(), rhs);
-  EXPECT_THAT(lhs, m);
-
-  // Changing rhs now shouldn't affect m, which made a copy of rhs.
-  rhs.push_back(6);
-  EXPECT_THAT(lhs, m);
-}
-
-TEST(UnorderedPointwiseTest, WorksForLhsNativeArray) {
-  const int lhs[] = {1, 2, 3};
-  vector<int> rhs;
-  rhs.push_back(4);
-  rhs.push_back(6);
-  rhs.push_back(2);
-  EXPECT_THAT(lhs, UnorderedPointwise(Lt(), rhs));
-  EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs)));
-}
-
-TEST(UnorderedPointwiseTest, WorksForRhsNativeArray) {
-  const int rhs[] = {1, 2, 3};
-  vector<int> lhs;
-  lhs.push_back(4);
-  lhs.push_back(2);
-  lhs.push_back(6);
-  EXPECT_THAT(lhs, UnorderedPointwise(Gt(), rhs));
-  EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), rhs)));
-}
-
-#if GTEST_HAS_STD_INITIALIZER_LIST_
-
-TEST(UnorderedPointwiseTest, WorksForRhsInitializerList) {
-  const vector<int> lhs{2, 4, 6};
-  EXPECT_THAT(lhs, UnorderedPointwise(Gt(), {5, 1, 3}));
-  EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), {1, 1, 7})));
-}
-
-#endif  // GTEST_HAS_STD_INITIALIZER_LIST_
-
-TEST(UnorderedPointwiseTest, RejectsWrongSize) {
-  const double lhs[2] = {1, 2};
-  const int rhs[1] = {0};
-  EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs)));
-  EXPECT_EQ("which has 2 elements",
-            Explain(UnorderedPointwise(Gt(), rhs), lhs));
-
-  const int rhs2[3] = {0, 1, 2};
-  EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs2)));
-}
-
-TEST(UnorderedPointwiseTest, RejectsWrongContent) {
-  const double lhs[3] = {1, 2, 3};
-  const int rhs[3] = {2, 6, 6};
-  EXPECT_THAT(lhs, Not(UnorderedPointwise(IsHalfOf(), rhs)));
-  EXPECT_EQ("where the following elements don't match any matchers:\n"
-            "element #1: 2",
-            Explain(UnorderedPointwise(IsHalfOf(), rhs), lhs));
-}
-
-TEST(UnorderedPointwiseTest, AcceptsCorrectContentInSameOrder) {
-  const double lhs[3] = {1, 2, 3};
-  const int rhs[3] = {2, 4, 6};
-  EXPECT_THAT(lhs, UnorderedPointwise(IsHalfOf(), rhs));
-}
-
-TEST(UnorderedPointwiseTest, AcceptsCorrectContentInDifferentOrder) {
-  const double lhs[3] = {1, 2, 3};
-  const int rhs[3] = {6, 4, 2};
-  EXPECT_THAT(lhs, UnorderedPointwise(IsHalfOf(), rhs));
-}
-
-TEST(UnorderedPointwiseTest, AllowsMonomorphicInnerMatcher) {
-  const double lhs[3] = {1, 2, 3};
-  const int rhs[3] = {4, 6, 2};
-  const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf();
-  EXPECT_THAT(lhs, UnorderedPointwise(m1, rhs));
-
-  // This type works as a tuple<const double&, const int&> can be
-  // implicitly cast to tuple<double, int>.
-  const Matcher<tuple<double, int> > m2 = IsHalfOf();
-  EXPECT_THAT(lhs, UnorderedPointwise(m2, rhs));
-}
-
-}  // namespace gmock_matchers_test
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-more-actions_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-more-actions_test.cc
deleted file mode 100644
index 77e15bd5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-more-actions_test.cc
+++ /dev/null
@@ -1,708 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests the built-in actions in gmock-more-actions.h.
-
-#include "gmock/gmock-more-actions.h"
-
-#include <functional>
-#include <sstream>
-#include <string>
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "gtest/internal/gtest-linked_ptr.h"
-
-namespace testing {
-namespace gmock_more_actions_test {
-
-using ::std::plus;
-using ::std::string;
-using testing::get;
-using testing::make_tuple;
-using testing::tuple;
-using testing::tuple_element;
-using testing::_;
-using testing::Action;
-using testing::ActionInterface;
-using testing::DeleteArg;
-using testing::Invoke;
-using testing::Return;
-using testing::ReturnArg;
-using testing::ReturnPointee;
-using testing::SaveArg;
-using testing::SaveArgPointee;
-using testing::SetArgReferee;
-using testing::StaticAssertTypeEq;
-using testing::Unused;
-using testing::WithArg;
-using testing::WithoutArgs;
-using testing::internal::linked_ptr;
-
-// For suppressing compiler warnings on conversion possibly losing precision.
-inline short Short(short n) { return n; }  // NOLINT
-inline char Char(char ch) { return ch; }
-
-// Sample functions and functors for testing Invoke() and etc.
-int Nullary() { return 1; }
-
-class NullaryFunctor {
- public:
-  int operator()() { return 2; }
-};
-
-bool g_done = false;
-void VoidNullary() { g_done = true; }
-
-class VoidNullaryFunctor {
- public:
-  void operator()() { g_done = true; }
-};
-
-bool Unary(int x) { return x < 0; }
-
-const char* Plus1(const char* s) { return s + 1; }
-
-void VoidUnary(int /* n */) { g_done = true; }
-
-bool ByConstRef(const string& s) { return s == "Hi"; }
-
-const double g_double = 0;
-bool ReferencesGlobalDouble(const double& x) { return &x == &g_double; }
-
-string ByNonConstRef(string& s) { return s += "+"; }  // NOLINT
-
-struct UnaryFunctor {
-  int operator()(bool x) { return x ? 1 : -1; }
-};
-
-const char* Binary(const char* input, short n) { return input + n; }  // NOLINT
-
-void VoidBinary(int, char) { g_done = true; }
-
-int Ternary(int x, char y, short z) { return x + y + z; }  // NOLINT
-
-void VoidTernary(int, char, bool) { g_done = true; }
-
-int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }
-
-int SumOfFirst2(int a, int b, Unused, Unused) { return a + b; }
-
-void VoidFunctionWithFourArguments(char, int, float, double) { g_done = true; }
-
-string Concat4(const char* s1, const char* s2, const char* s3,
-               const char* s4) {
-  return string(s1) + s2 + s3 + s4;
-}
-
-int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d + e; }
-
-struct SumOf5Functor {
-  int operator()(int a, int b, int c, int d, int e) {
-    return a + b + c + d + e;
-  }
-};
-
-string Concat5(const char* s1, const char* s2, const char* s3,
-               const char* s4, const char* s5) {
-  return string(s1) + s2 + s3 + s4 + s5;
-}
-
-int SumOf6(int a, int b, int c, int d, int e, int f) {
-  return a + b + c + d + e + f;
-}
-
-struct SumOf6Functor {
-  int operator()(int a, int b, int c, int d, int e, int f) {
-    return a + b + c + d + e + f;
-  }
-};
-
-string Concat6(const char* s1, const char* s2, const char* s3,
-               const char* s4, const char* s5, const char* s6) {
-  return string(s1) + s2 + s3 + s4 + s5 + s6;
-}
-
-string Concat7(const char* s1, const char* s2, const char* s3,
-               const char* s4, const char* s5, const char* s6,
-               const char* s7) {
-  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7;
-}
-
-string Concat8(const char* s1, const char* s2, const char* s3,
-               const char* s4, const char* s5, const char* s6,
-               const char* s7, const char* s8) {
-  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8;
-}
-
-string Concat9(const char* s1, const char* s2, const char* s3,
-               const char* s4, const char* s5, const char* s6,
-               const char* s7, const char* s8, const char* s9) {
-  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9;
-}
-
-string Concat10(const char* s1, const char* s2, const char* s3,
-                const char* s4, const char* s5, const char* s6,
-                const char* s7, const char* s8, const char* s9,
-                const char* s10) {
-  return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10;
-}
-
-class Foo {
- public:
-  Foo() : value_(123) {}
-
-  int Nullary() const { return value_; }
-
-  short Unary(long x) { return static_cast<short>(value_ + x); }  // NOLINT
-
-  string Binary(const string& str, char c) const { return str + c; }
-
-  int Ternary(int x, bool y, char z) { return value_ + x + y*z; }
-
-  int SumOf4(int a, int b, int c, int d) const {
-    return a + b + c + d + value_;
-  }
-
-  int SumOfLast2(Unused, Unused, int a, int b) const { return a + b; }
-
-  int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d + e; }
-
-  int SumOf6(int a, int b, int c, int d, int e, int f) {
-    return a + b + c + d + e + f;
-  }
-
-  string Concat7(const char* s1, const char* s2, const char* s3,
-                 const char* s4, const char* s5, const char* s6,
-                 const char* s7) {
-    return string(s1) + s2 + s3 + s4 + s5 + s6 + s7;
-  }
-
-  string Concat8(const char* s1, const char* s2, const char* s3,
-                 const char* s4, const char* s5, const char* s6,
-                 const char* s7, const char* s8) {
-    return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8;
-  }
-
-  string Concat9(const char* s1, const char* s2, const char* s3,
-                 const char* s4, const char* s5, const char* s6,
-                 const char* s7, const char* s8, const char* s9) {
-    return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9;
-  }
-
-  string Concat10(const char* s1, const char* s2, const char* s3,
-                  const char* s4, const char* s5, const char* s6,
-                  const char* s7, const char* s8, const char* s9,
-                  const char* s10) {
-    return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10;
-  }
-
- private:
-  int value_;
-};
-
-// Tests using Invoke() with a nullary function.
-TEST(InvokeTest, Nullary) {
-  Action<int()> a = Invoke(Nullary);  // NOLINT
-  EXPECT_EQ(1, a.Perform(make_tuple()));
-}
-
-// Tests using Invoke() with a unary function.
-TEST(InvokeTest, Unary) {
-  Action<bool(int)> a = Invoke(Unary);  // NOLINT
-  EXPECT_FALSE(a.Perform(make_tuple(1)));
-  EXPECT_TRUE(a.Perform(make_tuple(-1)));
-}
-
-// Tests using Invoke() with a binary function.
-TEST(InvokeTest, Binary) {
-  Action<const char*(const char*, short)> a = Invoke(Binary);  // NOLINT
-  const char* p = "Hello";
-  EXPECT_EQ(p + 2, a.Perform(make_tuple(p, Short(2))));
-}
-
-// Tests using Invoke() with a ternary function.
-TEST(InvokeTest, Ternary) {
-  Action<int(int, char, short)> a = Invoke(Ternary);  // NOLINT
-  EXPECT_EQ(6, a.Perform(make_tuple(1, '\2', Short(3))));
-}
-
-// Tests using Invoke() with a 4-argument function.
-TEST(InvokeTest, FunctionThatTakes4Arguments) {
-  Action<int(int, int, int, int)> a = Invoke(SumOf4);  // NOLINT
-  EXPECT_EQ(1234, a.Perform(make_tuple(1000, 200, 30, 4)));
-}
-
-// Tests using Invoke() with a 5-argument function.
-TEST(InvokeTest, FunctionThatTakes5Arguments) {
-  Action<int(int, int, int, int, int)> a = Invoke(SumOf5);  // NOLINT
-  EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5)));
-}
-
-// Tests using Invoke() with a 6-argument function.
-TEST(InvokeTest, FunctionThatTakes6Arguments) {
-  Action<int(int, int, int, int, int, int)> a = Invoke(SumOf6);  // NOLINT
-  EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6)));
-}
-
-// A helper that turns the type of a C-string literal from const
-// char[N] to const char*.
-inline const char* CharPtr(const char* s) { return s; }
-
-// Tests using Invoke() with a 7-argument function.
-TEST(InvokeTest, FunctionThatTakes7Arguments) {
-  Action<string(const char*, const char*, const char*, const char*,
-                const char*, const char*, const char*)> a =
-      Invoke(Concat7);
-  EXPECT_EQ("1234567",
-            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
-                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
-                                 CharPtr("7"))));
-}
-
-// Tests using Invoke() with a 8-argument function.
-TEST(InvokeTest, FunctionThatTakes8Arguments) {
-  Action<string(const char*, const char*, const char*, const char*,
-                const char*, const char*, const char*, const char*)> a =
-      Invoke(Concat8);
-  EXPECT_EQ("12345678",
-            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
-                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
-                                 CharPtr("7"), CharPtr("8"))));
-}
-
-// Tests using Invoke() with a 9-argument function.
-TEST(InvokeTest, FunctionThatTakes9Arguments) {
-  Action<string(const char*, const char*, const char*, const char*,
-                const char*, const char*, const char*, const char*,
-                const char*)> a = Invoke(Concat9);
-  EXPECT_EQ("123456789",
-            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
-                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
-                                 CharPtr("7"), CharPtr("8"), CharPtr("9"))));
-}
-
-// Tests using Invoke() with a 10-argument function.
-TEST(InvokeTest, FunctionThatTakes10Arguments) {
-  Action<string(const char*, const char*, const char*, const char*,
-                const char*, const char*, const char*, const char*,
-                const char*, const char*)> a = Invoke(Concat10);
-  EXPECT_EQ("1234567890",
-            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
-                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
-                                 CharPtr("7"), CharPtr("8"), CharPtr("9"),
-                                 CharPtr("0"))));
-}
-
-// Tests using Invoke() with functions with parameters declared as Unused.
-TEST(InvokeTest, FunctionWithUnusedParameters) {
-  Action<int(int, int, double, const string&)> a1 =
-      Invoke(SumOfFirst2);
-  string s("hi");
-  EXPECT_EQ(12, a1.Perform(
-    tuple<int, int, double, const string&>(10, 2, 5.6, s)));
-
-  Action<int(int, int, bool, int*)> a2 =
-      Invoke(SumOfFirst2);
-  EXPECT_EQ(23, a2.Perform(make_tuple(20, 3, true, static_cast<int*>(NULL))));
-}
-
-// Tests using Invoke() with methods with parameters declared as Unused.
-TEST(InvokeTest, MethodWithUnusedParameters) {
-  Foo foo;
-  Action<int(string, bool, int, int)> a1 =
-      Invoke(&foo, &Foo::SumOfLast2);
-  EXPECT_EQ(12, a1.Perform(make_tuple(CharPtr("hi"), true, 10, 2)));
-
-  Action<int(char, double, int, int)> a2 =
-      Invoke(&foo, &Foo::SumOfLast2);
-  EXPECT_EQ(23, a2.Perform(make_tuple('a', 2.5, 20, 3)));
-}
-
-// Tests using Invoke() with a functor.
-TEST(InvokeTest, Functor) {
-  Action<long(long, int)> a = Invoke(plus<long>());  // NOLINT
-  EXPECT_EQ(3L, a.Perform(make_tuple(1, 2)));
-}
-
-// Tests using Invoke(f) as an action of a compatible type.
-TEST(InvokeTest, FunctionWithCompatibleType) {
-  Action<long(int, short, char, bool)> a = Invoke(SumOf4);  // NOLINT
-  EXPECT_EQ(4321, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
-}
-
-// Tests using Invoke() with an object pointer and a method pointer.
-
-// Tests using Invoke() with a nullary method.
-TEST(InvokeMethodTest, Nullary) {
-  Foo foo;
-  Action<int()> a = Invoke(&foo, &Foo::Nullary);  // NOLINT
-  EXPECT_EQ(123, a.Perform(make_tuple()));
-}
-
-// Tests using Invoke() with a unary method.
-TEST(InvokeMethodTest, Unary) {
-  Foo foo;
-  Action<short(long)> a = Invoke(&foo, &Foo::Unary);  // NOLINT
-  EXPECT_EQ(4123, a.Perform(make_tuple(4000)));
-}
-
-// Tests using Invoke() with a binary method.
-TEST(InvokeMethodTest, Binary) {
-  Foo foo;
-  Action<string(const string&, char)> a = Invoke(&foo, &Foo::Binary);
-  string s("Hell");
-  EXPECT_EQ("Hello", a.Perform(
-      tuple<const string&, char>(s, 'o')));
-}
-
-// Tests using Invoke() with a ternary method.
-TEST(InvokeMethodTest, Ternary) {
-  Foo foo;
-  Action<int(int, bool, char)> a = Invoke(&foo, &Foo::Ternary);  // NOLINT
-  EXPECT_EQ(1124, a.Perform(make_tuple(1000, true, Char(1))));
-}
-
-// Tests using Invoke() with a 4-argument method.
-TEST(InvokeMethodTest, MethodThatTakes4Arguments) {
-  Foo foo;
-  Action<int(int, int, int, int)> a = Invoke(&foo, &Foo::SumOf4);  // NOLINT
-  EXPECT_EQ(1357, a.Perform(make_tuple(1000, 200, 30, 4)));
-}
-
-// Tests using Invoke() with a 5-argument method.
-TEST(InvokeMethodTest, MethodThatTakes5Arguments) {
-  Foo foo;
-  Action<int(int, int, int, int, int)> a = Invoke(&foo, &Foo::SumOf5);  // NOLINT
-  EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5)));
-}
-
-// Tests using Invoke() with a 6-argument method.
-TEST(InvokeMethodTest, MethodThatTakes6Arguments) {
-  Foo foo;
-  Action<int(int, int, int, int, int, int)> a =  // NOLINT
-      Invoke(&foo, &Foo::SumOf6);
-  EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6)));
-}
-
-// Tests using Invoke() with a 7-argument method.
-TEST(InvokeMethodTest, MethodThatTakes7Arguments) {
-  Foo foo;
-  Action<string(const char*, const char*, const char*, const char*,
-                const char*, const char*, const char*)> a =
-      Invoke(&foo, &Foo::Concat7);
-  EXPECT_EQ("1234567",
-            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
-                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
-                                 CharPtr("7"))));
-}
-
-// Tests using Invoke() with a 8-argument method.
-TEST(InvokeMethodTest, MethodThatTakes8Arguments) {
-  Foo foo;
-  Action<string(const char*, const char*, const char*, const char*,
-                const char*, const char*, const char*, const char*)> a =
-      Invoke(&foo, &Foo::Concat8);
-  EXPECT_EQ("12345678",
-            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
-                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
-                                 CharPtr("7"), CharPtr("8"))));
-}
-
-// Tests using Invoke() with a 9-argument method.
-TEST(InvokeMethodTest, MethodThatTakes9Arguments) {
-  Foo foo;
-  Action<string(const char*, const char*, const char*, const char*,
-                const char*, const char*, const char*, const char*,
-                const char*)> a = Invoke(&foo, &Foo::Concat9);
-  EXPECT_EQ("123456789",
-            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
-                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
-                                 CharPtr("7"), CharPtr("8"), CharPtr("9"))));
-}
-
-// Tests using Invoke() with a 10-argument method.
-TEST(InvokeMethodTest, MethodThatTakes10Arguments) {
-  Foo foo;
-  Action<string(const char*, const char*, const char*, const char*,
-                const char*, const char*, const char*, const char*,
-                const char*, const char*)> a = Invoke(&foo, &Foo::Concat10);
-  EXPECT_EQ("1234567890",
-            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
-                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
-                                 CharPtr("7"), CharPtr("8"), CharPtr("9"),
-                                 CharPtr("0"))));
-}
-
-// Tests using Invoke(f) as an action of a compatible type.
-TEST(InvokeMethodTest, MethodWithCompatibleType) {
-  Foo foo;
-  Action<long(int, short, char, bool)> a =  // NOLINT
-      Invoke(&foo, &Foo::SumOf4);
-  EXPECT_EQ(4444, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
-}
-
-// Tests using WithoutArgs with an action that takes no argument.
-TEST(WithoutArgsTest, NoArg) {
-  Action<int(int n)> a = WithoutArgs(Invoke(Nullary));  // NOLINT
-  EXPECT_EQ(1, a.Perform(make_tuple(2)));
-}
-
-// Tests using WithArg with an action that takes 1 argument.
-TEST(WithArgTest, OneArg) {
-  Action<bool(double x, int n)> b = WithArg<1>(Invoke(Unary));  // NOLINT
-  EXPECT_TRUE(b.Perform(make_tuple(1.5, -1)));
-  EXPECT_FALSE(b.Perform(make_tuple(1.5, 1)));
-}
-
-TEST(ReturnArgActionTest, WorksForOneArgIntArg0) {
-  const Action<int(int)> a = ReturnArg<0>();
-  EXPECT_EQ(5, a.Perform(make_tuple(5)));
-}
-
-TEST(ReturnArgActionTest, WorksForMultiArgBoolArg0) {
-  const Action<bool(bool, bool, bool)> a = ReturnArg<0>();
-  EXPECT_TRUE(a.Perform(make_tuple(true, false, false)));
-}
-
-TEST(ReturnArgActionTest, WorksForMultiArgStringArg2) {
-  const Action<string(int, int, string, int)> a = ReturnArg<2>();
-  EXPECT_EQ("seven", a.Perform(make_tuple(5, 6, string("seven"), 8)));
-}
-
-TEST(SaveArgActionTest, WorksForSameType) {
-  int result = 0;
-  const Action<void(int n)> a1 = SaveArg<0>(&result);
-  a1.Perform(make_tuple(5));
-  EXPECT_EQ(5, result);
-}
-
-TEST(SaveArgActionTest, WorksForCompatibleType) {
-  int result = 0;
-  const Action<void(bool, char)> a1 = SaveArg<1>(&result);
-  a1.Perform(make_tuple(true, 'a'));
-  EXPECT_EQ('a', result);
-}
-
-TEST(SaveArgPointeeActionTest, WorksForSameType) {
-  int result = 0;
-  const int value = 5;
-  const Action<void(const int*)> a1 = SaveArgPointee<0>(&result);
-  a1.Perform(make_tuple(&value));
-  EXPECT_EQ(5, result);
-}
-
-TEST(SaveArgPointeeActionTest, WorksForCompatibleType) {
-  int result = 0;
-  char value = 'a';
-  const Action<void(bool, char*)> a1 = SaveArgPointee<1>(&result);
-  a1.Perform(make_tuple(true, &value));
-  EXPECT_EQ('a', result);
-}
-
-TEST(SaveArgPointeeActionTest, WorksForLinkedPtr) {
-  int result = 0;
-  linked_ptr<int> value(new int(5));
-  const Action<void(linked_ptr<int>)> a1 = SaveArgPointee<0>(&result);
-  a1.Perform(make_tuple(value));
-  EXPECT_EQ(5, result);
-}
-
-TEST(SetArgRefereeActionTest, WorksForSameType) {
-  int value = 0;
-  const Action<void(int&)> a1 = SetArgReferee<0>(1);
-  a1.Perform(tuple<int&>(value));
-  EXPECT_EQ(1, value);
-}
-
-TEST(SetArgRefereeActionTest, WorksForCompatibleType) {
-  int value = 0;
-  const Action<void(int, int&)> a1 = SetArgReferee<1>('a');
-  a1.Perform(tuple<int, int&>(0, value));
-  EXPECT_EQ('a', value);
-}
-
-TEST(SetArgRefereeActionTest, WorksWithExtraArguments) {
-  int value = 0;
-  const Action<void(bool, int, int&, const char*)> a1 = SetArgReferee<2>('a');
-  a1.Perform(tuple<bool, int, int&, const char*>(true, 0, value, "hi"));
-  EXPECT_EQ('a', value);
-}
-
-// A class that can be used to verify that its destructor is called: it will set
-// the bool provided to the constructor to true when destroyed.
-class DeletionTester {
- public:
-  explicit DeletionTester(bool* is_deleted)
-    : is_deleted_(is_deleted) {
-    // Make sure the bit is set to false.
-    *is_deleted_ = false;
-  }
-
-  ~DeletionTester() {
-    *is_deleted_ = true;
-  }
-
- private:
-  bool* is_deleted_;
-};
-
-TEST(DeleteArgActionTest, OneArg) {
-  bool is_deleted = false;
-  DeletionTester* t = new DeletionTester(&is_deleted);
-  const Action<void(DeletionTester*)> a1 = DeleteArg<0>();      // NOLINT
-  EXPECT_FALSE(is_deleted);
-  a1.Perform(make_tuple(t));
-  EXPECT_TRUE(is_deleted);
-}
-
-TEST(DeleteArgActionTest, TenArgs) {
-  bool is_deleted = false;
-  DeletionTester* t = new DeletionTester(&is_deleted);
-  const Action<void(bool, int, int, const char*, bool,
-                    int, int, int, int, DeletionTester*)> a1 = DeleteArg<9>();
-  EXPECT_FALSE(is_deleted);
-  a1.Perform(make_tuple(true, 5, 6, CharPtr("hi"), false, 7, 8, 9, 10, t));
-  EXPECT_TRUE(is_deleted);
-}
-
-#if GTEST_HAS_EXCEPTIONS
-
-TEST(ThrowActionTest, ThrowsGivenExceptionInVoidFunction) {
-  const Action<void(int n)> a = Throw('a');
-  EXPECT_THROW(a.Perform(make_tuple(0)), char);
-}
-
-class MyException {};
-
-TEST(ThrowActionTest, ThrowsGivenExceptionInNonVoidFunction) {
-  const Action<double(char ch)> a = Throw(MyException());
-  EXPECT_THROW(a.Perform(make_tuple('0')), MyException);
-}
-
-TEST(ThrowActionTest, ThrowsGivenExceptionInNullaryFunction) {
-  const Action<double()> a = Throw(MyException());
-  EXPECT_THROW(a.Perform(make_tuple()), MyException);
-}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// Tests that SetArrayArgument<N>(first, last) sets the elements of the array
-// pointed to by the N-th (0-based) argument to values in range [first, last).
-TEST(SetArrayArgumentTest, SetsTheNthArray) {
-  typedef void MyFunction(bool, int*, char*);
-  int numbers[] = { 1, 2, 3 };
-  Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers + 3);
-
-  int n[4] = {};
-  int* pn = n;
-  char ch[4] = {};
-  char* pch = ch;
-  a.Perform(make_tuple(true, pn, pch));
-  EXPECT_EQ(1, n[0]);
-  EXPECT_EQ(2, n[1]);
-  EXPECT_EQ(3, n[2]);
-  EXPECT_EQ(0, n[3]);
-  EXPECT_EQ('\0', ch[0]);
-  EXPECT_EQ('\0', ch[1]);
-  EXPECT_EQ('\0', ch[2]);
-  EXPECT_EQ('\0', ch[3]);
-
-  // Tests first and last are iterators.
-  std::string letters = "abc";
-  a = SetArrayArgument<2>(letters.begin(), letters.end());
-  std::fill_n(n, 4, 0);
-  std::fill_n(ch, 4, '\0');
-  a.Perform(make_tuple(true, pn, pch));
-  EXPECT_EQ(0, n[0]);
-  EXPECT_EQ(0, n[1]);
-  EXPECT_EQ(0, n[2]);
-  EXPECT_EQ(0, n[3]);
-  EXPECT_EQ('a', ch[0]);
-  EXPECT_EQ('b', ch[1]);
-  EXPECT_EQ('c', ch[2]);
-  EXPECT_EQ('\0', ch[3]);
-}
-
-// Tests SetArrayArgument<N>(first, last) where first == last.
-TEST(SetArrayArgumentTest, SetsTheNthArrayWithEmptyRange) {
-  typedef void MyFunction(bool, int*);
-  int numbers[] = { 1, 2, 3 };
-  Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers);
-
-  int n[4] = {};
-  int* pn = n;
-  a.Perform(make_tuple(true, pn));
-  EXPECT_EQ(0, n[0]);
-  EXPECT_EQ(0, n[1]);
-  EXPECT_EQ(0, n[2]);
-  EXPECT_EQ(0, n[3]);
-}
-
-// Tests SetArrayArgument<N>(first, last) where *first is convertible
-// (but not equal) to the argument type.
-TEST(SetArrayArgumentTest, SetsTheNthArrayWithConvertibleType) {
-  typedef void MyFunction(bool, int*);
-  char chars[] = { 97, 98, 99 };
-  Action<MyFunction> a = SetArrayArgument<1>(chars, chars + 3);
-
-  int codes[4] = { 111, 222, 333, 444 };
-  int* pcodes = codes;
-  a.Perform(make_tuple(true, pcodes));
-  EXPECT_EQ(97, codes[0]);
-  EXPECT_EQ(98, codes[1]);
-  EXPECT_EQ(99, codes[2]);
-  EXPECT_EQ(444, codes[3]);
-}
-
-// Test SetArrayArgument<N>(first, last) with iterator as argument.
-TEST(SetArrayArgumentTest, SetsTheNthArrayWithIteratorArgument) {
-  typedef void MyFunction(bool, std::back_insert_iterator<std::string>);
-  std::string letters = "abc";
-  Action<MyFunction> a = SetArrayArgument<1>(letters.begin(), letters.end());
-
-  std::string s;
-  a.Perform(make_tuple(true, back_inserter(s)));
-  EXPECT_EQ(letters, s);
-}
-
-TEST(ReturnPointeeTest, Works) {
-  int n = 42;
-  const Action<int()> a = ReturnPointee(&n);
-  EXPECT_EQ(42, a.Perform(make_tuple()));
-
-  n = 43;
-  EXPECT_EQ(43, a.Perform(make_tuple()));
-}
-
-}  // namespace gmock_generated_actions_test
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-nice-strict_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-nice-strict_test.cc
deleted file mode 100644
index d0adcbbe..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-nice-strict_test.cc
+++ /dev/null
@@ -1,424 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "gmock/gmock-generated-nice-strict.h"
-
-#include <string>
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "gtest/gtest-spi.h"
-
-// This must not be defined inside the ::testing namespace, or it will
-// clash with ::testing::Mock.
-class Mock {
- public:
-  Mock() {}
-
-  MOCK_METHOD0(DoThis, void());
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
-};
-
-namespace testing {
-namespace gmock_nice_strict_test {
-
-using testing::internal::string;
-using testing::GMOCK_FLAG(verbose);
-using testing::HasSubstr;
-using testing::NaggyMock;
-using testing::NiceMock;
-using testing::StrictMock;
-
-#if GTEST_HAS_STREAM_REDIRECTION
-using testing::internal::CaptureStdout;
-using testing::internal::GetCapturedStdout;
-#endif
-
-// Defines some mock classes needed by the tests.
-
-class Foo {
- public:
-  virtual ~Foo() {}
-
-  virtual void DoThis() = 0;
-  virtual int DoThat(bool flag) = 0;
-};
-
-class MockFoo : public Foo {
- public:
-  MockFoo() {}
-  void Delete() { delete this; }
-
-  MOCK_METHOD0(DoThis, void());
-  MOCK_METHOD1(DoThat, int(bool flag));
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
-};
-
-class MockBar {
- public:
-  explicit MockBar(const string& s) : str_(s) {}
-
-  MockBar(char a1, char a2, string a3, string a4, int a5, int a6,
-          const string& a7, const string& a8, bool a9, bool a10) {
-    str_ = string() + a1 + a2 + a3 + a4 + static_cast<char>(a5) +
-        static_cast<char>(a6) + a7 + a8 + (a9 ? 'T' : 'F') + (a10 ? 'T' : 'F');
-  }
-
-  virtual ~MockBar() {}
-
-  const string& str() const { return str_; }
-
-  MOCK_METHOD0(This, int());
-  MOCK_METHOD2(That, string(int, bool));
-
- private:
-  string str_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockBar);
-};
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Tests that a raw mock generates warnings for uninteresting calls.
-TEST(RawMockTest, WarningForUninterestingCall) {
-  const string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "warning";
-
-  MockFoo raw_foo;
-
-  CaptureStdout();
-  raw_foo.DoThis();
-  raw_foo.DoThat(true);
-  EXPECT_THAT(GetCapturedStdout(),
-              HasSubstr("Uninteresting mock function call"));
-
-  GMOCK_FLAG(verbose) = saved_flag;
-}
-
-// Tests that a raw mock generates warnings for uninteresting calls
-// that delete the mock object.
-TEST(RawMockTest, WarningForUninterestingCallAfterDeath) {
-  const string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "warning";
-
-  MockFoo* const raw_foo = new MockFoo;
-
-  ON_CALL(*raw_foo, DoThis())
-      .WillByDefault(Invoke(raw_foo, &MockFoo::Delete));
-
-  CaptureStdout();
-  raw_foo->DoThis();
-  EXPECT_THAT(GetCapturedStdout(),
-              HasSubstr("Uninteresting mock function call"));
-
-  GMOCK_FLAG(verbose) = saved_flag;
-}
-
-// Tests that a raw mock generates informational logs for
-// uninteresting calls.
-TEST(RawMockTest, InfoForUninterestingCall) {
-  MockFoo raw_foo;
-
-  const string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "info";
-  CaptureStdout();
-  raw_foo.DoThis();
-  EXPECT_THAT(GetCapturedStdout(),
-              HasSubstr("Uninteresting mock function call"));
-
-  GMOCK_FLAG(verbose) = saved_flag;
-}
-
-// Tests that a nice mock generates no warning for uninteresting calls.
-TEST(NiceMockTest, NoWarningForUninterestingCall) {
-  NiceMock<MockFoo> nice_foo;
-
-  CaptureStdout();
-  nice_foo.DoThis();
-  nice_foo.DoThat(true);
-  EXPECT_EQ("", GetCapturedStdout());
-}
-
-// Tests that a nice mock generates no warning for uninteresting calls
-// that delete the mock object.
-TEST(NiceMockTest, NoWarningForUninterestingCallAfterDeath) {
-  NiceMock<MockFoo>* const nice_foo = new NiceMock<MockFoo>;
-
-  ON_CALL(*nice_foo, DoThis())
-      .WillByDefault(Invoke(nice_foo, &MockFoo::Delete));
-
-  CaptureStdout();
-  nice_foo->DoThis();
-  EXPECT_EQ("", GetCapturedStdout());
-}
-
-// Tests that a nice mock generates informational logs for
-// uninteresting calls.
-TEST(NiceMockTest, InfoForUninterestingCall) {
-  NiceMock<MockFoo> nice_foo;
-
-  const string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "info";
-  CaptureStdout();
-  nice_foo.DoThis();
-  EXPECT_THAT(GetCapturedStdout(),
-              HasSubstr("Uninteresting mock function call"));
-
-  GMOCK_FLAG(verbose) = saved_flag;
-}
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-// Tests that a nice mock allows expected calls.
-TEST(NiceMockTest, AllowsExpectedCall) {
-  NiceMock<MockFoo> nice_foo;
-
-  EXPECT_CALL(nice_foo, DoThis());
-  nice_foo.DoThis();
-}
-
-// Tests that an unexpected call on a nice mock fails.
-TEST(NiceMockTest, UnexpectedCallFails) {
-  NiceMock<MockFoo> nice_foo;
-
-  EXPECT_CALL(nice_foo, DoThis()).Times(0);
-  EXPECT_NONFATAL_FAILURE(nice_foo.DoThis(), "called more times than expected");
-}
-
-// Tests that NiceMock works with a mock class that has a non-default
-// constructor.
-TEST(NiceMockTest, NonDefaultConstructor) {
-  NiceMock<MockBar> nice_bar("hi");
-  EXPECT_EQ("hi", nice_bar.str());
-
-  nice_bar.This();
-  nice_bar.That(5, true);
-}
-
-// Tests that NiceMock works with a mock class that has a 10-ary
-// non-default constructor.
-TEST(NiceMockTest, NonDefaultConstructor10) {
-  NiceMock<MockBar> nice_bar('a', 'b', "c", "d", 'e', 'f',
-                             "g", "h", true, false);
-  EXPECT_EQ("abcdefghTF", nice_bar.str());
-
-  nice_bar.This();
-  nice_bar.That(5, true);
-}
-
-#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
-// Tests that NiceMock<Mock> compiles where Mock is a user-defined
-// class (as opposed to ::testing::Mock).  We had to work around an
-// MSVC 8.0 bug that caused the symbol Mock used in the definition of
-// NiceMock to be looked up in the wrong context, and this test
-// ensures that our fix works.
-//
-// We have to skip this test on Symbian and Windows Mobile, as it
-// causes the program to crash there, for reasons unclear to us yet.
-TEST(NiceMockTest, AcceptsClassNamedMock) {
-  NiceMock< ::Mock> nice;
-  EXPECT_CALL(nice, DoThis());
-  nice.DoThis();
-}
-#endif  // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Tests that a naggy mock generates warnings for uninteresting calls.
-TEST(NaggyMockTest, WarningForUninterestingCall) {
-  const string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "warning";
-
-  NaggyMock<MockFoo> naggy_foo;
-
-  CaptureStdout();
-  naggy_foo.DoThis();
-  naggy_foo.DoThat(true);
-  EXPECT_THAT(GetCapturedStdout(),
-              HasSubstr("Uninteresting mock function call"));
-
-  GMOCK_FLAG(verbose) = saved_flag;
-}
-
-// Tests that a naggy mock generates a warning for an uninteresting call
-// that deletes the mock object.
-TEST(NaggyMockTest, WarningForUninterestingCallAfterDeath) {
-  const string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "warning";
-
-  NaggyMock<MockFoo>* const naggy_foo = new NaggyMock<MockFoo>;
-
-  ON_CALL(*naggy_foo, DoThis())
-      .WillByDefault(Invoke(naggy_foo, &MockFoo::Delete));
-
-  CaptureStdout();
-  naggy_foo->DoThis();
-  EXPECT_THAT(GetCapturedStdout(),
-              HasSubstr("Uninteresting mock function call"));
-
-  GMOCK_FLAG(verbose) = saved_flag;
-}
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-// Tests that a naggy mock allows expected calls.
-TEST(NaggyMockTest, AllowsExpectedCall) {
-  NaggyMock<MockFoo> naggy_foo;
-
-  EXPECT_CALL(naggy_foo, DoThis());
-  naggy_foo.DoThis();
-}
-
-// Tests that an unexpected call on a naggy mock fails.
-TEST(NaggyMockTest, UnexpectedCallFails) {
-  NaggyMock<MockFoo> naggy_foo;
-
-  EXPECT_CALL(naggy_foo, DoThis()).Times(0);
-  EXPECT_NONFATAL_FAILURE(naggy_foo.DoThis(),
-                          "called more times than expected");
-}
-
-// Tests that NaggyMock works with a mock class that has a non-default
-// constructor.
-TEST(NaggyMockTest, NonDefaultConstructor) {
-  NaggyMock<MockBar> naggy_bar("hi");
-  EXPECT_EQ("hi", naggy_bar.str());
-
-  naggy_bar.This();
-  naggy_bar.That(5, true);
-}
-
-// Tests that NaggyMock works with a mock class that has a 10-ary
-// non-default constructor.
-TEST(NaggyMockTest, NonDefaultConstructor10) {
-  NaggyMock<MockBar> naggy_bar('0', '1', "2", "3", '4', '5',
-                               "6", "7", true, false);
-  EXPECT_EQ("01234567TF", naggy_bar.str());
-
-  naggy_bar.This();
-  naggy_bar.That(5, true);
-}
-
-#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
-// Tests that NaggyMock<Mock> compiles where Mock is a user-defined
-// class (as opposed to ::testing::Mock).  We had to work around an
-// MSVC 8.0 bug that caused the symbol Mock used in the definition of
-// NaggyMock to be looked up in the wrong context, and this test
-// ensures that our fix works.
-//
-// We have to skip this test on Symbian and Windows Mobile, as it
-// causes the program to crash there, for reasons unclear to us yet.
-TEST(NaggyMockTest, AcceptsClassNamedMock) {
-  NaggyMock< ::Mock> naggy;
-  EXPECT_CALL(naggy, DoThis());
-  naggy.DoThis();
-}
-#endif  // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
-
-// Tests that a strict mock allows expected calls.
-TEST(StrictMockTest, AllowsExpectedCall) {
-  StrictMock<MockFoo> strict_foo;
-
-  EXPECT_CALL(strict_foo, DoThis());
-  strict_foo.DoThis();
-}
-
-// Tests that an unexpected call on a strict mock fails.
-TEST(StrictMockTest, UnexpectedCallFails) {
-  StrictMock<MockFoo> strict_foo;
-
-  EXPECT_CALL(strict_foo, DoThis()).Times(0);
-  EXPECT_NONFATAL_FAILURE(strict_foo.DoThis(),
-                          "called more times than expected");
-}
-
-// Tests that an uninteresting call on a strict mock fails.
-TEST(StrictMockTest, UninterestingCallFails) {
-  StrictMock<MockFoo> strict_foo;
-
-  EXPECT_NONFATAL_FAILURE(strict_foo.DoThis(),
-                          "Uninteresting mock function call");
-}
-
-// Tests that an uninteresting call on a strict mock fails, even if
-// the call deletes the mock object.
-TEST(StrictMockTest, UninterestingCallFailsAfterDeath) {
-  StrictMock<MockFoo>* const strict_foo = new StrictMock<MockFoo>;
-
-  ON_CALL(*strict_foo, DoThis())
-      .WillByDefault(Invoke(strict_foo, &MockFoo::Delete));
-
-  EXPECT_NONFATAL_FAILURE(strict_foo->DoThis(),
-                          "Uninteresting mock function call");
-}
-
-// Tests that StrictMock works with a mock class that has a
-// non-default constructor.
-TEST(StrictMockTest, NonDefaultConstructor) {
-  StrictMock<MockBar> strict_bar("hi");
-  EXPECT_EQ("hi", strict_bar.str());
-
-  EXPECT_NONFATAL_FAILURE(strict_bar.That(5, true),
-                          "Uninteresting mock function call");
-}
-
-// Tests that StrictMock works with a mock class that has a 10-ary
-// non-default constructor.
-TEST(StrictMockTest, NonDefaultConstructor10) {
-  StrictMock<MockBar> strict_bar('a', 'b', "c", "d", 'e', 'f',
-                                 "g", "h", true, false);
-  EXPECT_EQ("abcdefghTF", strict_bar.str());
-
-  EXPECT_NONFATAL_FAILURE(strict_bar.That(5, true),
-                          "Uninteresting mock function call");
-}
-
-#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
-// Tests that StrictMock<Mock> compiles where Mock is a user-defined
-// class (as opposed to ::testing::Mock).  We had to work around an
-// MSVC 8.0 bug that caused the symbol Mock used in the definition of
-// StrictMock to be looked up in the wrong context, and this test
-// ensures that our fix works.
-//
-// We have to skip this test on Symbian and Windows Mobile, as it
-// causes the program to crash there, for reasons unclear to us yet.
-TEST(StrictMockTest, AcceptsClassNamedMock) {
-  StrictMock< ::Mock> strict;
-  EXPECT_CALL(strict, DoThis());
-  strict.DoThis();
-}
-#endif  // !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
-
-}  // namespace gmock_nice_strict_test
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-port_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-port_test.cc
deleted file mode 100644
index d6a8d444..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-port_test.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-// 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests the internal cross-platform support utilities.
-
-#include "gmock/internal/gmock-port.h"
-#include "gtest/gtest.h"
-
-// NOTE: if this file is left without tests for some reason, put a dummy
-// test here to make references to symbols in the gtest library and avoid
-// 'undefined symbol' linker errors in gmock_main:
-
-TEST(DummyTest, Dummy) {}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-spec-builders_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-spec-builders_test.cc
deleted file mode 100644
index 59ea87c8..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock-spec-builders_test.cc
+++ /dev/null
@@ -1,2644 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests the spec builder syntax.
-
-#include "gmock/gmock-spec-builders.h"
-
-#include <ostream>  // NOLINT
-#include <sstream>
-#include <string>
-
-#include "gmock/gmock.h"
-#include "gmock/internal/gmock-port.h"
-#include "gtest/gtest.h"
-#include "gtest/gtest-spi.h"
-#include "gtest/internal/gtest-port.h"
-
-namespace testing {
-namespace internal {
-
-// Helper class for testing the Expectation class template.
-class ExpectationTester {
- public:
-  // Sets the call count of the given expectation to the given number.
-  void SetCallCount(int n, ExpectationBase* exp) {
-    exp->call_count_ = n;
-  }
-};
-
-}  // namespace internal
-}  // namespace testing
-
-namespace {
-
-using testing::_;
-using testing::AnyNumber;
-using testing::AtLeast;
-using testing::AtMost;
-using testing::Between;
-using testing::Cardinality;
-using testing::CardinalityInterface;
-using testing::ContainsRegex;
-using testing::Const;
-using testing::DoAll;
-using testing::DoDefault;
-using testing::Eq;
-using testing::Expectation;
-using testing::ExpectationSet;
-using testing::GMOCK_FLAG(verbose);
-using testing::Gt;
-using testing::InSequence;
-using testing::Invoke;
-using testing::InvokeWithoutArgs;
-using testing::IsNotSubstring;
-using testing::IsSubstring;
-using testing::Lt;
-using testing::Message;
-using testing::Mock;
-using testing::NaggyMock;
-using testing::Ne;
-using testing::Return;
-using testing::Sequence;
-using testing::SetArgPointee;
-using testing::internal::ExpectationTester;
-using testing::internal::FormatFileLocation;
-using testing::internal::kErrorVerbosity;
-using testing::internal::kInfoVerbosity;
-using testing::internal::kWarningVerbosity;
-using testing::internal::linked_ptr;
-using testing::internal::string;
-
-#if GTEST_HAS_STREAM_REDIRECTION
-using testing::HasSubstr;
-using testing::internal::CaptureStdout;
-using testing::internal::GetCapturedStdout;
-#endif
-
-class Incomplete;
-
-class MockIncomplete {
- public:
-  // This line verifies that a mock method can take a by-reference
-  // argument of an incomplete type.
-  MOCK_METHOD1(ByRefFunc, void(const Incomplete& x));
-};
-
-// Tells Google Mock how to print a value of type Incomplete.
-void PrintTo(const Incomplete& x, ::std::ostream* os);
-
-TEST(MockMethodTest, CanInstantiateWithIncompleteArgType) {
-  // Even though this mock class contains a mock method that takes
-  // by-reference an argument whose type is incomplete, we can still
-  // use the mock, as long as Google Mock knows how to print the
-  // argument.
-  MockIncomplete incomplete;
-  EXPECT_CALL(incomplete, ByRefFunc(_))
-      .Times(AnyNumber());
-}
-
-// The definition of the printer for the argument type doesn't have to
-// be visible where the mock is used.
-void PrintTo(const Incomplete& /* x */, ::std::ostream* os) {
-  *os << "incomplete";
-}
-
-class Result {};
-
-// A type that's not default constructible.
-class NonDefaultConstructible {
- public:
-  explicit NonDefaultConstructible(int /* dummy */) {}
-};
-
-class MockA {
- public:
-  MockA() {}
-
-  MOCK_METHOD1(DoA, void(int n));
-  MOCK_METHOD1(ReturnResult, Result(int n));
-  MOCK_METHOD0(ReturnNonDefaultConstructible, NonDefaultConstructible());
-  MOCK_METHOD2(Binary, bool(int x, int y));
-  MOCK_METHOD2(ReturnInt, int(int x, int y));
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockA);
-};
-
-class MockB {
- public:
-  MockB() {}
-
-  MOCK_CONST_METHOD0(DoB, int());  // NOLINT
-  MOCK_METHOD1(DoB, int(int n));  // NOLINT
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
-};
-
-class ReferenceHoldingMock {
- public:
-  ReferenceHoldingMock() {}
-
-  MOCK_METHOD1(AcceptReference, void(linked_ptr<MockA>*));
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ReferenceHoldingMock);
-};
-
-// Tests that EXPECT_CALL and ON_CALL compile in a presence of macro
-// redefining a mock method name. This could happen, for example, when
-// the tested code #includes Win32 API headers which define many APIs
-// as macros, e.g. #define TextOut TextOutW.
-
-#define Method MethodW
-
-class CC {
- public:
-  virtual ~CC() {}
-  virtual int Method() = 0;
-};
-class MockCC : public CC {
- public:
-  MockCC() {}
-
-  MOCK_METHOD0(Method, int());
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockCC);
-};
-
-// Tests that a method with expanded name compiles.
-TEST(OnCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
-  MockCC cc;
-  ON_CALL(cc, Method());
-}
-
-// Tests that the method with expanded name not only compiles but runs
-// and returns a correct value, too.
-TEST(OnCallSyntaxTest, WorksWithMethodNameExpandedFromMacro) {
-  MockCC cc;
-  ON_CALL(cc, Method()).WillByDefault(Return(42));
-  EXPECT_EQ(42, cc.Method());
-}
-
-// Tests that a method with expanded name compiles.
-TEST(ExpectCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
-  MockCC cc;
-  EXPECT_CALL(cc, Method());
-  cc.Method();
-}
-
-// Tests that it works, too.
-TEST(ExpectCallSyntaxTest, WorksWithMethodNameExpandedFromMacro) {
-  MockCC cc;
-  EXPECT_CALL(cc, Method()).WillOnce(Return(42));
-  EXPECT_EQ(42, cc.Method());
-}
-
-#undef Method  // Done with macro redefinition tests.
-
-// Tests that ON_CALL evaluates its arguments exactly once as promised
-// by Google Mock.
-TEST(OnCallSyntaxTest, EvaluatesFirstArgumentOnce) {
-  MockA a;
-  MockA* pa = &a;
-
-  ON_CALL(*pa++, DoA(_));
-  EXPECT_EQ(&a + 1, pa);
-}
-
-TEST(OnCallSyntaxTest, EvaluatesSecondArgumentOnce) {
-  MockA a;
-  int n = 0;
-
-  ON_CALL(a, DoA(n++));
-  EXPECT_EQ(1, n);
-}
-
-// Tests that the syntax of ON_CALL() is enforced at run time.
-
-TEST(OnCallSyntaxTest, WithIsOptional) {
-  MockA a;
-
-  ON_CALL(a, DoA(5))
-      .WillByDefault(Return());
-  ON_CALL(a, DoA(_))
-      .With(_)
-      .WillByDefault(Return());
-}
-
-TEST(OnCallSyntaxTest, WithCanAppearAtMostOnce) {
-  MockA a;
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    ON_CALL(a, ReturnResult(_))
-        .With(_)
-        .With(_)
-        .WillByDefault(Return(Result()));
-  }, ".With() cannot appear more than once in an ON_CALL()");
-}
-
-TEST(OnCallSyntaxTest, WillByDefaultIsMandatory) {
-  MockA a;
-
-  EXPECT_DEATH_IF_SUPPORTED({
-    ON_CALL(a, DoA(5));
-    a.DoA(5);
-  }, "");
-}
-
-TEST(OnCallSyntaxTest, WillByDefaultCanAppearAtMostOnce) {
-  MockA a;
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    ON_CALL(a, DoA(5))
-        .WillByDefault(Return())
-        .WillByDefault(Return());
-  }, ".WillByDefault() must appear exactly once in an ON_CALL()");
-}
-
-// Tests that EXPECT_CALL evaluates its arguments exactly once as
-// promised by Google Mock.
-TEST(ExpectCallSyntaxTest, EvaluatesFirstArgumentOnce) {
-  MockA a;
-  MockA* pa = &a;
-
-  EXPECT_CALL(*pa++, DoA(_));
-  a.DoA(0);
-  EXPECT_EQ(&a + 1, pa);
-}
-
-TEST(ExpectCallSyntaxTest, EvaluatesSecondArgumentOnce) {
-  MockA a;
-  int n = 0;
-
-  EXPECT_CALL(a, DoA(n++));
-  a.DoA(0);
-  EXPECT_EQ(1, n);
-}
-
-// Tests that the syntax of EXPECT_CALL() is enforced at run time.
-
-TEST(ExpectCallSyntaxTest, WithIsOptional) {
-  MockA a;
-
-  EXPECT_CALL(a, DoA(5))
-      .Times(0);
-  EXPECT_CALL(a, DoA(6))
-      .With(_)
-      .Times(0);
-}
-
-TEST(ExpectCallSyntaxTest, WithCanAppearAtMostOnce) {
-  MockA a;
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(6))
-        .With(_)
-        .With(_);
-  }, ".With() cannot appear more than once in an EXPECT_CALL()");
-
-  a.DoA(6);
-}
-
-TEST(ExpectCallSyntaxTest, WithMustBeFirstClause) {
-  MockA a;
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .Times(1)
-        .With(_);
-  }, ".With() must be the first clause in an EXPECT_CALL()");
-
-  a.DoA(1);
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(2))
-        .WillOnce(Return())
-        .With(_);
-  }, ".With() must be the first clause in an EXPECT_CALL()");
-
-  a.DoA(2);
-}
-
-TEST(ExpectCallSyntaxTest, TimesCanBeInferred) {
-  MockA a;
-
-  EXPECT_CALL(a, DoA(1))
-      .WillOnce(Return());
-
-  EXPECT_CALL(a, DoA(2))
-      .WillOnce(Return())
-      .WillRepeatedly(Return());
-
-  a.DoA(1);
-  a.DoA(2);
-  a.DoA(2);
-}
-
-TEST(ExpectCallSyntaxTest, TimesCanAppearAtMostOnce) {
-  MockA a;
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .Times(1)
-        .Times(2);
-  }, ".Times() cannot appear more than once in an EXPECT_CALL()");
-
-  a.DoA(1);
-  a.DoA(1);
-}
-
-TEST(ExpectCallSyntaxTest, TimesMustBeBeforeInSequence) {
-  MockA a;
-  Sequence s;
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .InSequence(s)
-        .Times(1);
-  }, ".Times() cannot appear after ");
-
-  a.DoA(1);
-}
-
-TEST(ExpectCallSyntaxTest, InSequenceIsOptional) {
-  MockA a;
-  Sequence s;
-
-  EXPECT_CALL(a, DoA(1));
-  EXPECT_CALL(a, DoA(2))
-      .InSequence(s);
-
-  a.DoA(1);
-  a.DoA(2);
-}
-
-TEST(ExpectCallSyntaxTest, InSequenceCanAppearMultipleTimes) {
-  MockA a;
-  Sequence s1, s2;
-
-  EXPECT_CALL(a, DoA(1))
-      .InSequence(s1, s2)
-      .InSequence(s1);
-
-  a.DoA(1);
-}
-
-TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeAfter) {
-  MockA a;
-  Sequence s;
-
-  Expectation e = EXPECT_CALL(a, DoA(1))
-      .Times(AnyNumber());
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(2))
-        .After(e)
-        .InSequence(s);
-  }, ".InSequence() cannot appear after ");
-
-  a.DoA(2);
-}
-
-TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeWillOnce) {
-  MockA a;
-  Sequence s;
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .WillOnce(Return())
-        .InSequence(s);
-  }, ".InSequence() cannot appear after ");
-
-  a.DoA(1);
-}
-
-TEST(ExpectCallSyntaxTest, AfterMustBeBeforeWillOnce) {
-  MockA a;
-
-  Expectation e = EXPECT_CALL(a, DoA(1));
-  EXPECT_NONFATAL_FAILURE({
-    EXPECT_CALL(a, DoA(2))
-        .WillOnce(Return())
-        .After(e);
-  }, ".After() cannot appear after ");
-
-  a.DoA(1);
-  a.DoA(2);
-}
-
-TEST(ExpectCallSyntaxTest, WillIsOptional) {
-  MockA a;
-
-  EXPECT_CALL(a, DoA(1));
-  EXPECT_CALL(a, DoA(2))
-      .WillOnce(Return());
-
-  a.DoA(1);
-  a.DoA(2);
-}
-
-TEST(ExpectCallSyntaxTest, WillCanAppearMultipleTimes) {
-  MockA a;
-
-  EXPECT_CALL(a, DoA(1))
-      .Times(AnyNumber())
-      .WillOnce(Return())
-      .WillOnce(Return())
-      .WillOnce(Return());
-}
-
-TEST(ExpectCallSyntaxTest, WillMustBeBeforeWillRepeatedly) {
-  MockA a;
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .WillRepeatedly(Return())
-        .WillOnce(Return());
-  }, ".WillOnce() cannot appear after ");
-
-  a.DoA(1);
-}
-
-TEST(ExpectCallSyntaxTest, WillRepeatedlyIsOptional) {
-  MockA a;
-
-  EXPECT_CALL(a, DoA(1))
-      .WillOnce(Return());
-  EXPECT_CALL(a, DoA(2))
-      .WillOnce(Return())
-      .WillRepeatedly(Return());
-
-  a.DoA(1);
-  a.DoA(2);
-  a.DoA(2);
-}
-
-TEST(ExpectCallSyntaxTest, WillRepeatedlyCannotAppearMultipleTimes) {
-  MockA a;
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .WillRepeatedly(Return())
-        .WillRepeatedly(Return());
-  }, ".WillRepeatedly() cannot appear more than once in an "
-     "EXPECT_CALL()");
-}
-
-TEST(ExpectCallSyntaxTest, WillRepeatedlyMustBeBeforeRetiresOnSaturation) {
-  MockA a;
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .RetiresOnSaturation()
-        .WillRepeatedly(Return());
-  }, ".WillRepeatedly() cannot appear after ");
-}
-
-TEST(ExpectCallSyntaxTest, RetiresOnSaturationIsOptional) {
-  MockA a;
-
-  EXPECT_CALL(a, DoA(1));
-  EXPECT_CALL(a, DoA(1))
-      .RetiresOnSaturation();
-
-  a.DoA(1);
-  a.DoA(1);
-}
-
-TEST(ExpectCallSyntaxTest, RetiresOnSaturationCannotAppearMultipleTimes) {
-  MockA a;
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .RetiresOnSaturation()
-        .RetiresOnSaturation();
-  }, ".RetiresOnSaturation() cannot appear more than once");
-
-  a.DoA(1);
-}
-
-TEST(ExpectCallSyntaxTest, DefaultCardinalityIsOnce) {
-  {
-    MockA a;
-    EXPECT_CALL(a, DoA(1));
-    a.DoA(1);
-  }
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    MockA a;
-    EXPECT_CALL(a, DoA(1));
-  }, "to be called once");
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    MockA a;
-    EXPECT_CALL(a, DoA(1));
-    a.DoA(1);
-    a.DoA(1);
-  }, "to be called once");
-}
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Tests that Google Mock doesn't print a warning when the number of
-// WillOnce() is adequate.
-TEST(ExpectCallSyntaxTest, DoesNotWarnOnAdequateActionCount) {
-  CaptureStdout();
-  {
-    MockB b;
-
-    // It's always fine to omit WillOnce() entirely.
-    EXPECT_CALL(b, DoB())
-        .Times(0);
-    EXPECT_CALL(b, DoB(1))
-        .Times(AtMost(1));
-    EXPECT_CALL(b, DoB(2))
-        .Times(1)
-        .WillRepeatedly(Return(1));
-
-    // It's fine for the number of WillOnce()s to equal the upper bound.
-    EXPECT_CALL(b, DoB(3))
-        .Times(Between(1, 2))
-        .WillOnce(Return(1))
-        .WillOnce(Return(2));
-
-    // It's fine for the number of WillOnce()s to be smaller than the
-    // upper bound when there is a WillRepeatedly().
-    EXPECT_CALL(b, DoB(4))
-        .Times(AtMost(3))
-        .WillOnce(Return(1))
-        .WillRepeatedly(Return(2));
-
-    // Satisfies the above expectations.
-    b.DoB(2);
-    b.DoB(3);
-  }
-  EXPECT_STREQ("", GetCapturedStdout().c_str());
-}
-
-// Tests that Google Mock warns on having too many actions in an
-// expectation compared to its cardinality.
-TEST(ExpectCallSyntaxTest, WarnsOnTooManyActions) {
-  CaptureStdout();
-  {
-    MockB b;
-
-    // Warns when the number of WillOnce()s is larger than the upper bound.
-    EXPECT_CALL(b, DoB())
-        .Times(0)
-        .WillOnce(Return(1));  // #1
-    EXPECT_CALL(b, DoB())
-        .Times(AtMost(1))
-        .WillOnce(Return(1))
-        .WillOnce(Return(2));  // #2
-    EXPECT_CALL(b, DoB(1))
-        .Times(1)
-        .WillOnce(Return(1))
-        .WillOnce(Return(2))
-        .RetiresOnSaturation();  // #3
-
-    // Warns when the number of WillOnce()s equals the upper bound and
-    // there is a WillRepeatedly().
-    EXPECT_CALL(b, DoB())
-        .Times(0)
-        .WillRepeatedly(Return(1));  // #4
-    EXPECT_CALL(b, DoB(2))
-        .Times(1)
-        .WillOnce(Return(1))
-        .WillRepeatedly(Return(2));  // #5
-
-    // Satisfies the above expectations.
-    b.DoB(1);
-    b.DoB(2);
-  }
-  const std::string output = GetCapturedStdout();
-  EXPECT_PRED_FORMAT2(
-      IsSubstring,
-      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
-      "Expected to be never called, but has 1 WillOnce().",
-      output);  // #1
-  EXPECT_PRED_FORMAT2(
-      IsSubstring,
-      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
-      "Expected to be called at most once, "
-      "but has 2 WillOnce()s.",
-      output);  // #2
-  EXPECT_PRED_FORMAT2(
-      IsSubstring,
-      "Too many actions specified in EXPECT_CALL(b, DoB(1))...\n"
-      "Expected to be called once, but has 2 WillOnce()s.",
-      output);  // #3
-  EXPECT_PRED_FORMAT2(
-      IsSubstring,
-      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
-      "Expected to be never called, but has 0 WillOnce()s "
-      "and a WillRepeatedly().",
-      output);  // #4
-  EXPECT_PRED_FORMAT2(
-      IsSubstring,
-      "Too many actions specified in EXPECT_CALL(b, DoB(2))...\n"
-      "Expected to be called once, but has 1 WillOnce() "
-      "and a WillRepeatedly().",
-      output);  // #5
-}
-
-// Tests that Google Mock warns on having too few actions in an
-// expectation compared to its cardinality.
-TEST(ExpectCallSyntaxTest, WarnsOnTooFewActions) {
-  MockB b;
-
-  EXPECT_CALL(b, DoB())
-      .Times(Between(2, 3))
-      .WillOnce(Return(1));
-
-  CaptureStdout();
-  b.DoB();
-  const std::string output = GetCapturedStdout();
-  EXPECT_PRED_FORMAT2(
-      IsSubstring,
-      "Too few actions specified in EXPECT_CALL(b, DoB())...\n"
-      "Expected to be called between 2 and 3 times, "
-      "but has only 1 WillOnce().",
-      output);
-  b.DoB();
-}
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-// Tests the semantics of ON_CALL().
-
-// Tests that the built-in default action is taken when no ON_CALL()
-// is specified.
-TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCall) {
-  MockB b;
-  EXPECT_CALL(b, DoB());
-
-  EXPECT_EQ(0, b.DoB());
-}
-
-// Tests that the built-in default action is taken when no ON_CALL()
-// matches the invocation.
-TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCallMatches) {
-  MockB b;
-  ON_CALL(b, DoB(1))
-      .WillByDefault(Return(1));
-  EXPECT_CALL(b, DoB(_));
-
-  EXPECT_EQ(0, b.DoB(2));
-}
-
-// Tests that the last matching ON_CALL() action is taken.
-TEST(OnCallTest, PicksLastMatchingOnCall) {
-  MockB b;
-  ON_CALL(b, DoB(_))
-      .WillByDefault(Return(3));
-  ON_CALL(b, DoB(2))
-      .WillByDefault(Return(2));
-  ON_CALL(b, DoB(1))
-      .WillByDefault(Return(1));
-  EXPECT_CALL(b, DoB(_));
-
-  EXPECT_EQ(2, b.DoB(2));
-}
-
-// Tests the semantics of EXPECT_CALL().
-
-// Tests that any call is allowed when no EXPECT_CALL() is specified.
-TEST(ExpectCallTest, AllowsAnyCallWhenNoSpec) {
-  MockB b;
-  EXPECT_CALL(b, DoB());
-  // There is no expectation on DoB(int).
-
-  b.DoB();
-
-  // DoB(int) can be called any number of times.
-  b.DoB(1);
-  b.DoB(2);
-}
-
-// Tests that the last matching EXPECT_CALL() fires.
-TEST(ExpectCallTest, PicksLastMatchingExpectCall) {
-  MockB b;
-  EXPECT_CALL(b, DoB(_))
-      .WillRepeatedly(Return(2));
-  EXPECT_CALL(b, DoB(1))
-      .WillRepeatedly(Return(1));
-
-  EXPECT_EQ(1, b.DoB(1));
-}
-
-// Tests lower-bound violation.
-TEST(ExpectCallTest, CatchesTooFewCalls) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    MockB b;
-    EXPECT_CALL(b, DoB(5))
-        .Times(AtLeast(2));
-
-    b.DoB(5);
-  }, "Actual function call count doesn't match EXPECT_CALL(b, DoB(5))...\n"
-     "         Expected: to be called at least twice\n"
-     "           Actual: called once - unsatisfied and active");
-}
-
-// Tests that the cardinality can be inferred when no Times(...) is
-// specified.
-TEST(ExpectCallTest, InfersCardinalityWhenThereIsNoWillRepeatedly) {
-  {
-    MockB b;
-    EXPECT_CALL(b, DoB())
-        .WillOnce(Return(1))
-        .WillOnce(Return(2));
-
-    EXPECT_EQ(1, b.DoB());
-    EXPECT_EQ(2, b.DoB());
-  }
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    MockB b;
-    EXPECT_CALL(b, DoB())
-        .WillOnce(Return(1))
-        .WillOnce(Return(2));
-
-    EXPECT_EQ(1, b.DoB());
-  }, "to be called twice");
-
-  {  // NOLINT
-    MockB b;
-    EXPECT_CALL(b, DoB())
-        .WillOnce(Return(1))
-        .WillOnce(Return(2));
-
-    EXPECT_EQ(1, b.DoB());
-    EXPECT_EQ(2, b.DoB());
-    EXPECT_NONFATAL_FAILURE(b.DoB(), "to be called twice");
-  }
-}
-
-TEST(ExpectCallTest, InfersCardinality1WhenThereIsWillRepeatedly) {
-  {
-    MockB b;
-    EXPECT_CALL(b, DoB())
-        .WillOnce(Return(1))
-        .WillRepeatedly(Return(2));
-
-    EXPECT_EQ(1, b.DoB());
-  }
-
-  {  // NOLINT
-    MockB b;
-    EXPECT_CALL(b, DoB())
-        .WillOnce(Return(1))
-        .WillRepeatedly(Return(2));
-
-    EXPECT_EQ(1, b.DoB());
-    EXPECT_EQ(2, b.DoB());
-    EXPECT_EQ(2, b.DoB());
-  }
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    MockB b;
-    EXPECT_CALL(b, DoB())
-        .WillOnce(Return(1))
-        .WillRepeatedly(Return(2));
-  }, "to be called at least once");
-}
-
-// Tests that the n-th action is taken for the n-th matching
-// invocation.
-TEST(ExpectCallTest, NthMatchTakesNthAction) {
-  MockB b;
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(1))
-      .WillOnce(Return(2))
-      .WillOnce(Return(3));
-
-  EXPECT_EQ(1, b.DoB());
-  EXPECT_EQ(2, b.DoB());
-  EXPECT_EQ(3, b.DoB());
-}
-
-// Tests that the WillRepeatedly() action is taken when the WillOnce(...)
-// list is exhausted.
-TEST(ExpectCallTest, TakesRepeatedActionWhenWillListIsExhausted) {
-  MockB b;
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(1))
-      .WillRepeatedly(Return(2));
-
-  EXPECT_EQ(1, b.DoB());
-  EXPECT_EQ(2, b.DoB());
-  EXPECT_EQ(2, b.DoB());
-}
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Tests that the default action is taken when the WillOnce(...) list is
-// exhausted and there is no WillRepeatedly().
-TEST(ExpectCallTest, TakesDefaultActionWhenWillListIsExhausted) {
-  MockB b;
-  EXPECT_CALL(b, DoB(_))
-      .Times(1);
-  EXPECT_CALL(b, DoB())
-      .Times(AnyNumber())
-      .WillOnce(Return(1))
-      .WillOnce(Return(2));
-
-  CaptureStdout();
-  EXPECT_EQ(0, b.DoB(1));  // Shouldn't generate a warning as the
-                           // expectation has no action clause at all.
-  EXPECT_EQ(1, b.DoB());
-  EXPECT_EQ(2, b.DoB());
-  const std::string output1 = GetCapturedStdout();
-  EXPECT_STREQ("", output1.c_str());
-
-  CaptureStdout();
-  EXPECT_EQ(0, b.DoB());
-  EXPECT_EQ(0, b.DoB());
-  const std::string output2 = GetCapturedStdout();
-  EXPECT_THAT(output2.c_str(),
-              HasSubstr("Actions ran out in EXPECT_CALL(b, DoB())...\n"
-                        "Called 3 times, but only 2 WillOnce()s are specified"
-                        " - returning default value."));
-  EXPECT_THAT(output2.c_str(),
-              HasSubstr("Actions ran out in EXPECT_CALL(b, DoB())...\n"
-                        "Called 4 times, but only 2 WillOnce()s are specified"
-                        " - returning default value."));
-}
-
-TEST(FunctionMockerMessageTest, ReportsExpectCallLocationForExhausedActions) {
-  MockB b;
-  std::string expect_call_location = FormatFileLocation(__FILE__, __LINE__ + 1);
-  EXPECT_CALL(b, DoB()).Times(AnyNumber()).WillOnce(Return(1));
-
-  EXPECT_EQ(1, b.DoB());
-
-  CaptureStdout();
-  EXPECT_EQ(0, b.DoB());
-  const std::string output = GetCapturedStdout();
-  // The warning message should contain the call location.
-  EXPECT_PRED_FORMAT2(IsSubstring, expect_call_location, output);
-}
-
-TEST(FunctionMockerMessageTest,
-     ReportsDefaultActionLocationOfUninterestingCallsForNaggyMock) {
-  std::string on_call_location;
-  CaptureStdout();
-  {
-    NaggyMock<MockB> b;
-    on_call_location = FormatFileLocation(__FILE__, __LINE__ + 1);
-    ON_CALL(b, DoB(_)).WillByDefault(Return(0));
-    b.DoB(0);
-  }
-  EXPECT_PRED_FORMAT2(IsSubstring, on_call_location, GetCapturedStdout());
-}
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-// Tests that an uninteresting call performs the default action.
-TEST(UninterestingCallTest, DoesDefaultAction) {
-  // When there is an ON_CALL() statement, the action specified by it
-  // should be taken.
-  MockA a;
-  ON_CALL(a, Binary(_, _))
-      .WillByDefault(Return(true));
-  EXPECT_TRUE(a.Binary(1, 2));
-
-  // When there is no ON_CALL(), the default value for the return type
-  // should be returned.
-  MockB b;
-  EXPECT_EQ(0, b.DoB());
-}
-
-// Tests that an unexpected call performs the default action.
-TEST(UnexpectedCallTest, DoesDefaultAction) {
-  // When there is an ON_CALL() statement, the action specified by it
-  // should be taken.
-  MockA a;
-  ON_CALL(a, Binary(_, _))
-      .WillByDefault(Return(true));
-  EXPECT_CALL(a, Binary(0, 0));
-  a.Binary(0, 0);
-  bool result = false;
-  EXPECT_NONFATAL_FAILURE(result = a.Binary(1, 2),
-                          "Unexpected mock function call");
-  EXPECT_TRUE(result);
-
-  // When there is no ON_CALL(), the default value for the return type
-  // should be returned.
-  MockB b;
-  EXPECT_CALL(b, DoB(0))
-      .Times(0);
-  int n = -1;
-  EXPECT_NONFATAL_FAILURE(n = b.DoB(1),
-                          "Unexpected mock function call");
-  EXPECT_EQ(0, n);
-}
-
-// Tests that when an unexpected void function generates the right
-// failure message.
-TEST(UnexpectedCallTest, GeneratesFailureForVoidFunction) {
-  // First, tests the message when there is only one EXPECT_CALL().
-  MockA a1;
-  EXPECT_CALL(a1, DoA(1));
-  a1.DoA(1);
-  // Ideally we should match the failure message against a regex, but
-  // EXPECT_NONFATAL_FAILURE doesn't support that, so we test for
-  // multiple sub-strings instead.
-  EXPECT_NONFATAL_FAILURE(
-      a1.DoA(9),
-      "Unexpected mock function call - returning directly.\n"
-      "    Function call: DoA(9)\n"
-      "Google Mock tried the following 1 expectation, but it didn't match:");
-  EXPECT_NONFATAL_FAILURE(
-      a1.DoA(9),
-      "  Expected arg #0: is equal to 1\n"
-      "           Actual: 9\n"
-      "         Expected: to be called once\n"
-      "           Actual: called once - saturated and active");
-
-  // Next, tests the message when there are more than one EXPECT_CALL().
-  MockA a2;
-  EXPECT_CALL(a2, DoA(1));
-  EXPECT_CALL(a2, DoA(3));
-  a2.DoA(1);
-  EXPECT_NONFATAL_FAILURE(
-      a2.DoA(2),
-      "Unexpected mock function call - returning directly.\n"
-      "    Function call: DoA(2)\n"
-      "Google Mock tried the following 2 expectations, but none matched:");
-  EXPECT_NONFATAL_FAILURE(
-      a2.DoA(2),
-      "tried expectation #0: EXPECT_CALL(a2, DoA(1))...\n"
-      "  Expected arg #0: is equal to 1\n"
-      "           Actual: 2\n"
-      "         Expected: to be called once\n"
-      "           Actual: called once - saturated and active");
-  EXPECT_NONFATAL_FAILURE(
-      a2.DoA(2),
-      "tried expectation #1: EXPECT_CALL(a2, DoA(3))...\n"
-      "  Expected arg #0: is equal to 3\n"
-      "           Actual: 2\n"
-      "         Expected: to be called once\n"
-      "           Actual: never called - unsatisfied and active");
-  a2.DoA(3);
-}
-
-// Tests that an unexpected non-void function generates the right
-// failure message.
-TEST(UnexpectedCallTest, GeneartesFailureForNonVoidFunction) {
-  MockB b1;
-  EXPECT_CALL(b1, DoB(1));
-  b1.DoB(1);
-  EXPECT_NONFATAL_FAILURE(
-      b1.DoB(2),
-      "Unexpected mock function call - returning default value.\n"
-      "    Function call: DoB(2)\n"
-      "          Returns: 0\n"
-      "Google Mock tried the following 1 expectation, but it didn't match:");
-  EXPECT_NONFATAL_FAILURE(
-      b1.DoB(2),
-      "  Expected arg #0: is equal to 1\n"
-      "           Actual: 2\n"
-      "         Expected: to be called once\n"
-      "           Actual: called once - saturated and active");
-}
-
-// Tests that Google Mock explains that an retired expectation doesn't
-// match the call.
-TEST(UnexpectedCallTest, RetiredExpectation) {
-  MockB b;
-  EXPECT_CALL(b, DoB(1))
-      .RetiresOnSaturation();
-
-  b.DoB(1);
-  EXPECT_NONFATAL_FAILURE(
-      b.DoB(1),
-      "         Expected: the expectation is active\n"
-      "           Actual: it is retired");
-}
-
-// Tests that Google Mock explains that an expectation that doesn't
-// match the arguments doesn't match the call.
-TEST(UnexpectedCallTest, UnmatchedArguments) {
-  MockB b;
-  EXPECT_CALL(b, DoB(1));
-
-  EXPECT_NONFATAL_FAILURE(
-      b.DoB(2),
-      "  Expected arg #0: is equal to 1\n"
-      "           Actual: 2\n");
-  b.DoB(1);
-}
-
-// Tests that Google Mock explains that an expectation with
-// unsatisfied pre-requisites doesn't match the call.
-TEST(UnexpectedCallTest, UnsatisifiedPrerequisites) {
-  Sequence s1, s2;
-  MockB b;
-  EXPECT_CALL(b, DoB(1))
-      .InSequence(s1);
-  EXPECT_CALL(b, DoB(2))
-      .Times(AnyNumber())
-      .InSequence(s1);
-  EXPECT_CALL(b, DoB(3))
-      .InSequence(s2);
-  EXPECT_CALL(b, DoB(4))
-      .InSequence(s1, s2);
-
-  ::testing::TestPartResultArray failures;
-  {
-    ::testing::ScopedFakeTestPartResultReporter reporter(&failures);
-    b.DoB(4);
-    // Now 'failures' contains the Google Test failures generated by
-    // the above statement.
-  }
-
-  // There should be one non-fatal failure.
-  ASSERT_EQ(1, failures.size());
-  const ::testing::TestPartResult& r = failures.GetTestPartResult(0);
-  EXPECT_EQ(::testing::TestPartResult::kNonFatalFailure, r.type());
-
-  // Verifies that the failure message contains the two unsatisfied
-  // pre-requisites but not the satisfied one.
-#if GTEST_USES_PCRE
-  EXPECT_THAT(r.message(), ContainsRegex(
-      // PCRE has trouble using (.|\n) to match any character, but
-      // supports the (?s) prefix for using . to match any character.
-      "(?s)the following immediate pre-requisites are not satisfied:\n"
-      ".*: pre-requisite #0\n"
-      ".*: pre-requisite #1"));
-#elif GTEST_USES_POSIX_RE
-  EXPECT_THAT(r.message(), ContainsRegex(
-      // POSIX RE doesn't understand the (?s) prefix, but has no trouble
-      // with (.|\n).
-      "the following immediate pre-requisites are not satisfied:\n"
-      "(.|\n)*: pre-requisite #0\n"
-      "(.|\n)*: pre-requisite #1"));
-#else
-  // We can only use Google Test's own simple regex.
-  EXPECT_THAT(r.message(), ContainsRegex(
-      "the following immediate pre-requisites are not satisfied:"));
-  EXPECT_THAT(r.message(), ContainsRegex(": pre-requisite #0"));
-  EXPECT_THAT(r.message(), ContainsRegex(": pre-requisite #1"));
-#endif  // GTEST_USES_PCRE
-
-  b.DoB(1);
-  b.DoB(3);
-  b.DoB(4);
-}
-
-TEST(UndefinedReturnValueTest,
-     ReturnValueIsMandatoryWhenNotDefaultConstructible) {
-  MockA a;
-  // TODO(wan@google.com): We should really verify the output message,
-  // but we cannot yet due to that EXPECT_DEATH only captures stderr
-  // while Google Mock logs to stdout.
-#if GTEST_HAS_EXCEPTIONS
-  EXPECT_ANY_THROW(a.ReturnNonDefaultConstructible());
-#else
-  EXPECT_DEATH_IF_SUPPORTED(a.ReturnNonDefaultConstructible(), "");
-#endif
-}
-
-// Tests that an excessive call (one whose arguments match the
-// matchers but is called too many times) performs the default action.
-TEST(ExcessiveCallTest, DoesDefaultAction) {
-  // When there is an ON_CALL() statement, the action specified by it
-  // should be taken.
-  MockA a;
-  ON_CALL(a, Binary(_, _))
-      .WillByDefault(Return(true));
-  EXPECT_CALL(a, Binary(0, 0));
-  a.Binary(0, 0);
-  bool result = false;
-  EXPECT_NONFATAL_FAILURE(result = a.Binary(0, 0),
-                          "Mock function called more times than expected");
-  EXPECT_TRUE(result);
-
-  // When there is no ON_CALL(), the default value for the return type
-  // should be returned.
-  MockB b;
-  EXPECT_CALL(b, DoB(0))
-      .Times(0);
-  int n = -1;
-  EXPECT_NONFATAL_FAILURE(n = b.DoB(0),
-                          "Mock function called more times than expected");
-  EXPECT_EQ(0, n);
-}
-
-// Tests that when a void function is called too many times,
-// the failure message contains the argument values.
-TEST(ExcessiveCallTest, GeneratesFailureForVoidFunction) {
-  MockA a;
-  EXPECT_CALL(a, DoA(_))
-      .Times(0);
-  EXPECT_NONFATAL_FAILURE(
-      a.DoA(9),
-      "Mock function called more times than expected - returning directly.\n"
-      "    Function call: DoA(9)\n"
-      "         Expected: to be never called\n"
-      "           Actual: called once - over-saturated and active");
-}
-
-// Tests that when a non-void function is called too many times, the
-// failure message contains the argument values and the return value.
-TEST(ExcessiveCallTest, GeneratesFailureForNonVoidFunction) {
-  MockB b;
-  EXPECT_CALL(b, DoB(_));
-  b.DoB(1);
-  EXPECT_NONFATAL_FAILURE(
-      b.DoB(2),
-      "Mock function called more times than expected - "
-      "returning default value.\n"
-      "    Function call: DoB(2)\n"
-      "          Returns: 0\n"
-      "         Expected: to be called once\n"
-      "           Actual: called twice - over-saturated and active");
-}
-
-// Tests using sequences.
-
-TEST(InSequenceTest, AllExpectationInScopeAreInSequence) {
-  MockA a;
-  {
-    InSequence dummy;
-
-    EXPECT_CALL(a, DoA(1));
-    EXPECT_CALL(a, DoA(2));
-  }
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    a.DoA(2);
-  }, "Unexpected mock function call");
-
-  a.DoA(1);
-  a.DoA(2);
-}
-
-TEST(InSequenceTest, NestedInSequence) {
-  MockA a;
-  {
-    InSequence dummy;
-
-    EXPECT_CALL(a, DoA(1));
-    {
-      InSequence dummy2;
-
-      EXPECT_CALL(a, DoA(2));
-      EXPECT_CALL(a, DoA(3));
-    }
-  }
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    a.DoA(1);
-    a.DoA(3);
-  }, "Unexpected mock function call");
-
-  a.DoA(2);
-  a.DoA(3);
-}
-
-TEST(InSequenceTest, ExpectationsOutOfScopeAreNotAffected) {
-  MockA a;
-  {
-    InSequence dummy;
-
-    EXPECT_CALL(a, DoA(1));
-    EXPECT_CALL(a, DoA(2));
-  }
-  EXPECT_CALL(a, DoA(3));
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    a.DoA(2);
-  }, "Unexpected mock function call");
-
-  a.DoA(3);
-  a.DoA(1);
-  a.DoA(2);
-}
-
-// Tests that any order is allowed when no sequence is used.
-TEST(SequenceTest, AnyOrderIsOkByDefault) {
-  {
-    MockA a;
-    MockB b;
-
-    EXPECT_CALL(a, DoA(1));
-    EXPECT_CALL(b, DoB())
-        .Times(AnyNumber());
-
-    a.DoA(1);
-    b.DoB();
-  }
-
-  {  // NOLINT
-    MockA a;
-    MockB b;
-
-    EXPECT_CALL(a, DoA(1));
-    EXPECT_CALL(b, DoB())
-        .Times(AnyNumber());
-
-    b.DoB();
-    a.DoA(1);
-  }
-}
-
-// Tests that the calls must be in strict order when a complete order
-// is specified.
-TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo1) {
-  MockA a;
-  ON_CALL(a, ReturnResult(_))
-      .WillByDefault(Return(Result()));
-
-  Sequence s;
-  EXPECT_CALL(a, ReturnResult(1))
-      .InSequence(s);
-  EXPECT_CALL(a, ReturnResult(2))
-      .InSequence(s);
-  EXPECT_CALL(a, ReturnResult(3))
-      .InSequence(s);
-
-  a.ReturnResult(1);
-
-  // May only be called after a.ReturnResult(2).
-  EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
-
-  a.ReturnResult(2);
-  a.ReturnResult(3);
-}
-
-// Tests that the calls must be in strict order when a complete order
-// is specified.
-TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo2) {
-  MockA a;
-  ON_CALL(a, ReturnResult(_))
-      .WillByDefault(Return(Result()));
-
-  Sequence s;
-  EXPECT_CALL(a, ReturnResult(1))
-      .InSequence(s);
-  EXPECT_CALL(a, ReturnResult(2))
-      .InSequence(s);
-
-  // May only be called after a.ReturnResult(1).
-  EXPECT_NONFATAL_FAILURE(a.ReturnResult(2), "Unexpected mock function call");
-
-  a.ReturnResult(1);
-  a.ReturnResult(2);
-}
-
-// Tests specifying a DAG using multiple sequences.
-class PartialOrderTest : public testing::Test {
- protected:
-  PartialOrderTest() {
-    ON_CALL(a_, ReturnResult(_))
-        .WillByDefault(Return(Result()));
-
-    // Specifies this partial ordering:
-    //
-    // a.ReturnResult(1) ==>
-    //                       a.ReturnResult(2) * n  ==>  a.ReturnResult(3)
-    // b.DoB() * 2       ==>
-    Sequence x, y;
-    EXPECT_CALL(a_, ReturnResult(1))
-        .InSequence(x);
-    EXPECT_CALL(b_, DoB())
-        .Times(2)
-        .InSequence(y);
-    EXPECT_CALL(a_, ReturnResult(2))
-        .Times(AnyNumber())
-        .InSequence(x, y);
-    EXPECT_CALL(a_, ReturnResult(3))
-        .InSequence(x);
-  }
-
-  MockA a_;
-  MockB b_;
-};
-
-TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag1) {
-  a_.ReturnResult(1);
-  b_.DoB();
-
-  // May only be called after the second DoB().
-  EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2), "Unexpected mock function call");
-
-  b_.DoB();
-  a_.ReturnResult(3);
-}
-
-TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag2) {
-  // May only be called after ReturnResult(1).
-  EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2), "Unexpected mock function call");
-
-  a_.ReturnResult(1);
-  b_.DoB();
-  b_.DoB();
-  a_.ReturnResult(3);
-}
-
-TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag3) {
-  // May only be called last.
-  EXPECT_NONFATAL_FAILURE(a_.ReturnResult(3), "Unexpected mock function call");
-
-  a_.ReturnResult(1);
-  b_.DoB();
-  b_.DoB();
-  a_.ReturnResult(3);
-}
-
-TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag4) {
-  a_.ReturnResult(1);
-  b_.DoB();
-  b_.DoB();
-  a_.ReturnResult(3);
-
-  // May only be called before ReturnResult(3).
-  EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2), "Unexpected mock function call");
-}
-
-TEST(SequenceTest, Retirement) {
-  MockA a;
-  Sequence s;
-
-  EXPECT_CALL(a, DoA(1))
-      .InSequence(s);
-  EXPECT_CALL(a, DoA(_))
-      .InSequence(s)
-      .RetiresOnSaturation();
-  EXPECT_CALL(a, DoA(1))
-      .InSequence(s);
-
-  a.DoA(1);
-  a.DoA(2);
-  a.DoA(1);
-}
-
-// Tests Expectation.
-
-TEST(ExpectationTest, ConstrutorsWork) {
-  MockA a;
-  Expectation e1;  // Default ctor.
-
-  // Ctor from various forms of EXPECT_CALL.
-  Expectation e2 = EXPECT_CALL(a, DoA(2));
-  Expectation e3 = EXPECT_CALL(a, DoA(3)).With(_);
-  {
-    Sequence s;
-    Expectation e4 = EXPECT_CALL(a, DoA(4)).Times(1);
-    Expectation e5 = EXPECT_CALL(a, DoA(5)).InSequence(s);
-  }
-  Expectation e6 = EXPECT_CALL(a, DoA(6)).After(e2);
-  Expectation e7 = EXPECT_CALL(a, DoA(7)).WillOnce(Return());
-  Expectation e8 = EXPECT_CALL(a, DoA(8)).WillRepeatedly(Return());
-  Expectation e9 = EXPECT_CALL(a, DoA(9)).RetiresOnSaturation();
-
-  Expectation e10 = e2;  // Copy ctor.
-
-  EXPECT_THAT(e1, Ne(e2));
-  EXPECT_THAT(e2, Eq(e10));
-
-  a.DoA(2);
-  a.DoA(3);
-  a.DoA(4);
-  a.DoA(5);
-  a.DoA(6);
-  a.DoA(7);
-  a.DoA(8);
-  a.DoA(9);
-}
-
-TEST(ExpectationTest, AssignmentWorks) {
-  MockA a;
-  Expectation e1;
-  Expectation e2 = EXPECT_CALL(a, DoA(1));
-
-  EXPECT_THAT(e1, Ne(e2));
-
-  e1 = e2;
-  EXPECT_THAT(e1, Eq(e2));
-
-  a.DoA(1);
-}
-
-// Tests ExpectationSet.
-
-TEST(ExpectationSetTest, MemberTypesAreCorrect) {
-  ::testing::StaticAssertTypeEq<Expectation, ExpectationSet::value_type>();
-}
-
-TEST(ExpectationSetTest, ConstructorsWork) {
-  MockA a;
-
-  Expectation e1;
-  const Expectation e2;
-  ExpectationSet es1;  // Default ctor.
-  ExpectationSet es2 = EXPECT_CALL(a, DoA(1));  // Ctor from EXPECT_CALL.
-  ExpectationSet es3 = e1;  // Ctor from Expectation.
-  ExpectationSet es4(e1);   // Ctor from Expectation; alternative syntax.
-  ExpectationSet es5 = e2;  // Ctor from const Expectation.
-  ExpectationSet es6(e2);   // Ctor from const Expectation; alternative syntax.
-  ExpectationSet es7 = es2;  // Copy ctor.
-
-  EXPECT_EQ(0, es1.size());
-  EXPECT_EQ(1, es2.size());
-  EXPECT_EQ(1, es3.size());
-  EXPECT_EQ(1, es4.size());
-  EXPECT_EQ(1, es5.size());
-  EXPECT_EQ(1, es6.size());
-  EXPECT_EQ(1, es7.size());
-
-  EXPECT_THAT(es3, Ne(es2));
-  EXPECT_THAT(es4, Eq(es3));
-  EXPECT_THAT(es5, Eq(es4));
-  EXPECT_THAT(es6, Eq(es5));
-  EXPECT_THAT(es7, Eq(es2));
-  a.DoA(1);
-}
-
-TEST(ExpectationSetTest, AssignmentWorks) {
-  ExpectationSet es1;
-  ExpectationSet es2 = Expectation();
-
-  es1 = es2;
-  EXPECT_EQ(1, es1.size());
-  EXPECT_THAT(*(es1.begin()), Eq(Expectation()));
-  EXPECT_THAT(es1, Eq(es2));
-}
-
-TEST(ExpectationSetTest, InsertionWorks) {
-  ExpectationSet es1;
-  Expectation e1;
-  es1 += e1;
-  EXPECT_EQ(1, es1.size());
-  EXPECT_THAT(*(es1.begin()), Eq(e1));
-
-  MockA a;
-  Expectation e2 = EXPECT_CALL(a, DoA(1));
-  es1 += e2;
-  EXPECT_EQ(2, es1.size());
-
-  ExpectationSet::const_iterator it1 = es1.begin();
-  ExpectationSet::const_iterator it2 = it1;
-  ++it2;
-  EXPECT_TRUE(*it1 == e1 || *it2 == e1);  // e1 must be in the set.
-  EXPECT_TRUE(*it1 == e2 || *it2 == e2);  // e2 must be in the set too.
-  a.DoA(1);
-}
-
-TEST(ExpectationSetTest, SizeWorks) {
-  ExpectationSet es;
-  EXPECT_EQ(0, es.size());
-
-  es += Expectation();
-  EXPECT_EQ(1, es.size());
-
-  MockA a;
-  es += EXPECT_CALL(a, DoA(1));
-  EXPECT_EQ(2, es.size());
-
-  a.DoA(1);
-}
-
-TEST(ExpectationSetTest, IsEnumerable) {
-  ExpectationSet es;
-  EXPECT_TRUE(es.begin() == es.end());
-
-  es += Expectation();
-  ExpectationSet::const_iterator it = es.begin();
-  EXPECT_TRUE(it != es.end());
-  EXPECT_THAT(*it, Eq(Expectation()));
-  ++it;
-  EXPECT_TRUE(it== es.end());
-}
-
-// Tests the .After() clause.
-
-TEST(AfterTest, SucceedsWhenPartialOrderIsSatisfied) {
-  MockA a;
-  ExpectationSet es;
-  es += EXPECT_CALL(a, DoA(1));
-  es += EXPECT_CALL(a, DoA(2));
-  EXPECT_CALL(a, DoA(3))
-      .After(es);
-
-  a.DoA(1);
-  a.DoA(2);
-  a.DoA(3);
-}
-
-TEST(AfterTest, SucceedsWhenTotalOrderIsSatisfied) {
-  MockA a;
-  MockB b;
-  // The following also verifies that const Expectation objects work
-  // too.  Do not remove the const modifiers.
-  const Expectation e1 = EXPECT_CALL(a, DoA(1));
-  const Expectation e2 = EXPECT_CALL(b, DoB())
-      .Times(2)
-      .After(e1);
-  EXPECT_CALL(a, DoA(2)).After(e2);
-
-  a.DoA(1);
-  b.DoB();
-  b.DoB();
-  a.DoA(2);
-}
-
-// Calls must be in strict order when specified so using .After().
-TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo1) {
-  MockA a;
-  MockB b;
-
-  // Define ordering:
-  //   a.DoA(1) ==> b.DoB() ==> a.DoA(2)
-  Expectation e1 = EXPECT_CALL(a, DoA(1));
-  Expectation e2 = EXPECT_CALL(b, DoB())
-      .After(e1);
-  EXPECT_CALL(a, DoA(2))
-      .After(e2);
-
-  a.DoA(1);
-
-  // May only be called after DoB().
-  EXPECT_NONFATAL_FAILURE(a.DoA(2), "Unexpected mock function call");
-
-  b.DoB();
-  a.DoA(2);
-}
-
-// Calls must be in strict order when specified so using .After().
-TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo2) {
-  MockA a;
-  MockB b;
-
-  // Define ordering:
-  //   a.DoA(1) ==> b.DoB() * 2 ==> a.DoA(2)
-  Expectation e1 = EXPECT_CALL(a, DoA(1));
-  Expectation e2 = EXPECT_CALL(b, DoB())
-      .Times(2)
-      .After(e1);
-  EXPECT_CALL(a, DoA(2))
-      .After(e2);
-
-  a.DoA(1);
-  b.DoB();
-
-  // May only be called after the second DoB().
-  EXPECT_NONFATAL_FAILURE(a.DoA(2), "Unexpected mock function call");
-
-  b.DoB();
-  a.DoA(2);
-}
-
-// Calls must satisfy the partial order when specified so.
-TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo) {
-  MockA a;
-  ON_CALL(a, ReturnResult(_))
-      .WillByDefault(Return(Result()));
-
-  // Define ordering:
-  //   a.DoA(1) ==>
-  //   a.DoA(2) ==> a.ReturnResult(3)
-  Expectation e = EXPECT_CALL(a, DoA(1));
-  const ExpectationSet es = EXPECT_CALL(a, DoA(2));
-  EXPECT_CALL(a, ReturnResult(3))
-      .After(e, es);
-
-  // May only be called last.
-  EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
-
-  a.DoA(2);
-  a.DoA(1);
-  a.ReturnResult(3);
-}
-
-// Calls must satisfy the partial order when specified so.
-TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo2) {
-  MockA a;
-
-  // Define ordering:
-  //   a.DoA(1) ==>
-  //   a.DoA(2) ==> a.DoA(3)
-  Expectation e = EXPECT_CALL(a, DoA(1));
-  const ExpectationSet es = EXPECT_CALL(a, DoA(2));
-  EXPECT_CALL(a, DoA(3))
-      .After(e, es);
-
-  a.DoA(2);
-
-  // May only be called last.
-  EXPECT_NONFATAL_FAILURE(a.DoA(3), "Unexpected mock function call");
-
-  a.DoA(1);
-  a.DoA(3);
-}
-
-// .After() can be combined with .InSequence().
-TEST(AfterTest, CanBeUsedWithInSequence) {
-  MockA a;
-  Sequence s;
-  Expectation e = EXPECT_CALL(a, DoA(1));
-  EXPECT_CALL(a, DoA(2)).InSequence(s);
-  EXPECT_CALL(a, DoA(3))
-      .InSequence(s)
-      .After(e);
-
-  a.DoA(1);
-
-  // May only be after DoA(2).
-  EXPECT_NONFATAL_FAILURE(a.DoA(3), "Unexpected mock function call");
-
-  a.DoA(2);
-  a.DoA(3);
-}
-
-// .After() can be called multiple times.
-TEST(AfterTest, CanBeCalledManyTimes) {
-  MockA a;
-  Expectation e1 = EXPECT_CALL(a, DoA(1));
-  Expectation e2 = EXPECT_CALL(a, DoA(2));
-  Expectation e3 = EXPECT_CALL(a, DoA(3));
-  EXPECT_CALL(a, DoA(4))
-      .After(e1)
-      .After(e2)
-      .After(e3);
-
-  a.DoA(3);
-  a.DoA(1);
-  a.DoA(2);
-  a.DoA(4);
-}
-
-// .After() accepts up to 5 arguments.
-TEST(AfterTest, AcceptsUpToFiveArguments) {
-  MockA a;
-  Expectation e1 = EXPECT_CALL(a, DoA(1));
-  Expectation e2 = EXPECT_CALL(a, DoA(2));
-  Expectation e3 = EXPECT_CALL(a, DoA(3));
-  ExpectationSet es1 = EXPECT_CALL(a, DoA(4));
-  ExpectationSet es2 = EXPECT_CALL(a, DoA(5));
-  EXPECT_CALL(a, DoA(6))
-      .After(e1, e2, e3, es1, es2);
-
-  a.DoA(5);
-  a.DoA(2);
-  a.DoA(4);
-  a.DoA(1);
-  a.DoA(3);
-  a.DoA(6);
-}
-
-// .After() allows input to contain duplicated Expectations.
-TEST(AfterTest, AcceptsDuplicatedInput) {
-  MockA a;
-  ON_CALL(a, ReturnResult(_))
-      .WillByDefault(Return(Result()));
-
-  // Define ordering:
-  //   DoA(1) ==>
-  //   DoA(2) ==> ReturnResult(3)
-  Expectation e1 = EXPECT_CALL(a, DoA(1));
-  Expectation e2 = EXPECT_CALL(a, DoA(2));
-  ExpectationSet es;
-  es += e1;
-  es += e2;
-  EXPECT_CALL(a, ReturnResult(3))
-      .After(e1, e2, es, e1);
-
-  a.DoA(1);
-
-  // May only be after DoA(2).
-  EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
-
-  a.DoA(2);
-  a.ReturnResult(3);
-}
-
-// An Expectation added to an ExpectationSet after it has been used in
-// an .After() has no effect.
-TEST(AfterTest, ChangesToExpectationSetHaveNoEffectAfterwards) {
-  MockA a;
-  ExpectationSet es1 = EXPECT_CALL(a, DoA(1));
-  Expectation e2 = EXPECT_CALL(a, DoA(2));
-  EXPECT_CALL(a, DoA(3))
-      .After(es1);
-  es1 += e2;
-
-  a.DoA(1);
-  a.DoA(3);
-  a.DoA(2);
-}
-
-// Tests that Google Mock correctly handles calls to mock functions
-// after a mock object owning one of their pre-requisites has died.
-
-// Tests that calls that satisfy the original spec are successful.
-TEST(DeletingMockEarlyTest, Success1) {
-  MockB* const b1 = new MockB;
-  MockA* const a = new MockA;
-  MockB* const b2 = new MockB;
-
-  {
-    InSequence dummy;
-    EXPECT_CALL(*b1, DoB(_))
-        .WillOnce(Return(1));
-    EXPECT_CALL(*a, Binary(_, _))
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(true));
-    EXPECT_CALL(*b2, DoB(_))
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(2));
-  }
-
-  EXPECT_EQ(1, b1->DoB(1));
-  delete b1;
-  // a's pre-requisite has died.
-  EXPECT_TRUE(a->Binary(0, 1));
-  delete b2;
-  // a's successor has died.
-  EXPECT_TRUE(a->Binary(1, 2));
-  delete a;
-}
-
-// Tests that calls that satisfy the original spec are successful.
-TEST(DeletingMockEarlyTest, Success2) {
-  MockB* const b1 = new MockB;
-  MockA* const a = new MockA;
-  MockB* const b2 = new MockB;
-
-  {
-    InSequence dummy;
-    EXPECT_CALL(*b1, DoB(_))
-        .WillOnce(Return(1));
-    EXPECT_CALL(*a, Binary(_, _))
-        .Times(AnyNumber());
-    EXPECT_CALL(*b2, DoB(_))
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(2));
-  }
-
-  delete a;  // a is trivially satisfied.
-  EXPECT_EQ(1, b1->DoB(1));
-  EXPECT_EQ(2, b2->DoB(2));
-  delete b1;
-  delete b2;
-}
-
-// Tests that it's OK to delete a mock object itself in its action.
-
-// Suppresses warning on unreferenced formal parameter in MSVC with
-// -W4.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
-#endif
-
-ACTION_P(Delete, ptr) { delete ptr; }
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningVoid) {
-  MockA* const a = new MockA;
-  EXPECT_CALL(*a, DoA(_)).WillOnce(Delete(a));
-  a->DoA(42);  // This will cause a to be deleted.
-}
-
-TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningValue) {
-  MockA* const a = new MockA;
-  EXPECT_CALL(*a, ReturnResult(_))
-      .WillOnce(DoAll(Delete(a), Return(Result())));
-  a->ReturnResult(42);  // This will cause a to be deleted.
-}
-
-// Tests that calls that violate the original spec yield failures.
-TEST(DeletingMockEarlyTest, Failure1) {
-  MockB* const b1 = new MockB;
-  MockA* const a = new MockA;
-  MockB* const b2 = new MockB;
-
-  {
-    InSequence dummy;
-    EXPECT_CALL(*b1, DoB(_))
-        .WillOnce(Return(1));
-    EXPECT_CALL(*a, Binary(_, _))
-        .Times(AnyNumber());
-    EXPECT_CALL(*b2, DoB(_))
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(2));
-  }
-
-  delete a;  // a is trivially satisfied.
-  EXPECT_NONFATAL_FAILURE({
-    b2->DoB(2);
-  }, "Unexpected mock function call");
-  EXPECT_EQ(1, b1->DoB(1));
-  delete b1;
-  delete b2;
-}
-
-// Tests that calls that violate the original spec yield failures.
-TEST(DeletingMockEarlyTest, Failure2) {
-  MockB* const b1 = new MockB;
-  MockA* const a = new MockA;
-  MockB* const b2 = new MockB;
-
-  {
-    InSequence dummy;
-    EXPECT_CALL(*b1, DoB(_));
-    EXPECT_CALL(*a, Binary(_, _))
-        .Times(AnyNumber());
-    EXPECT_CALL(*b2, DoB(_))
-        .Times(AnyNumber());
-  }
-
-  EXPECT_NONFATAL_FAILURE(delete b1,
-                          "Actual: never called");
-  EXPECT_NONFATAL_FAILURE(a->Binary(0, 1),
-                          "Unexpected mock function call");
-  EXPECT_NONFATAL_FAILURE(b2->DoB(1),
-                          "Unexpected mock function call");
-  delete a;
-  delete b2;
-}
-
-class EvenNumberCardinality : public CardinalityInterface {
- public:
-  // Returns true iff call_count calls will satisfy this cardinality.
-  virtual bool IsSatisfiedByCallCount(int call_count) const {
-    return call_count % 2 == 0;
-  }
-
-  // Returns true iff call_count calls will saturate this cardinality.
-  virtual bool IsSaturatedByCallCount(int /* call_count */) const {
-    return false;
-  }
-
-  // Describes self to an ostream.
-  virtual void DescribeTo(::std::ostream* os) const {
-    *os << "called even number of times";
-  }
-};
-
-Cardinality EvenNumber() {
-  return Cardinality(new EvenNumberCardinality);
-}
-
-TEST(ExpectationBaseTest,
-     AllPrerequisitesAreSatisfiedWorksForNonMonotonicCardinality) {
-  MockA* a = new MockA;
-  Sequence s;
-
-  EXPECT_CALL(*a, DoA(1))
-      .Times(EvenNumber())
-      .InSequence(s);
-  EXPECT_CALL(*a, DoA(2))
-      .Times(AnyNumber())
-      .InSequence(s);
-  EXPECT_CALL(*a, DoA(3))
-      .Times(AnyNumber());
-
-  a->DoA(3);
-  a->DoA(1);
-  EXPECT_NONFATAL_FAILURE(a->DoA(2), "Unexpected mock function call");
-  EXPECT_NONFATAL_FAILURE(delete a, "to be called even number of times");
-}
-
-// The following tests verify the message generated when a mock
-// function is called.
-
-struct Printable {
-};
-
-inline void operator<<(::std::ostream& os, const Printable&) {
-  os << "Printable";
-}
-
-struct Unprintable {
-  Unprintable() : value(0) {}
-  int value;
-};
-
-class MockC {
- public:
-  MockC() {}
-
-  MOCK_METHOD6(VoidMethod, void(bool cond, int n, string s, void* p,
-                                const Printable& x, Unprintable y));
-  MOCK_METHOD0(NonVoidMethod, int());  // NOLINT
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockC);
-};
-
-class VerboseFlagPreservingFixture : public testing::Test {
- protected:
-  VerboseFlagPreservingFixture()
-      : saved_verbose_flag_(GMOCK_FLAG(verbose)) {}
-
-  ~VerboseFlagPreservingFixture() { GMOCK_FLAG(verbose) = saved_verbose_flag_; }
-
- private:
-  const string saved_verbose_flag_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(VerboseFlagPreservingFixture);
-};
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Tests that an uninteresting mock function call on a naggy mock
-// generates a warning without the stack trace when
-// --gmock_verbose=warning is specified.
-TEST(FunctionCallMessageTest,
-     UninterestingCallOnNaggyMockGeneratesNoStackTraceWhenVerboseWarning) {
-  GMOCK_FLAG(verbose) = kWarningVerbosity;
-  NaggyMock<MockC> c;
-  CaptureStdout();
-  c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
-  const std::string output = GetCapturedStdout();
-  EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output);
-  EXPECT_PRED_FORMAT2(IsNotSubstring, "Stack trace:", output);
-}
-
-// Tests that an uninteresting mock function call on a naggy mock
-// generates a warning containing the stack trace when
-// --gmock_verbose=info is specified.
-TEST(FunctionCallMessageTest,
-     UninterestingCallOnNaggyMockGeneratesFyiWithStackTraceWhenVerboseInfo) {
-  GMOCK_FLAG(verbose) = kInfoVerbosity;
-  NaggyMock<MockC> c;
-  CaptureStdout();
-  c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
-  const std::string output = GetCapturedStdout();
-  EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output);
-  EXPECT_PRED_FORMAT2(IsSubstring, "Stack trace:", output);
-
-# ifndef NDEBUG
-
-  // We check the stack trace content in dbg-mode only, as opt-mode
-  // may inline the call we are interested in seeing.
-
-  // Verifies that a void mock function's name appears in the stack
-  // trace.
-  EXPECT_PRED_FORMAT2(IsSubstring, "VoidMethod(", output);
-
-  // Verifies that a non-void mock function's name appears in the
-  // stack trace.
-  CaptureStdout();
-  c.NonVoidMethod();
-  const std::string output2 = GetCapturedStdout();
-  EXPECT_PRED_FORMAT2(IsSubstring, "NonVoidMethod(", output2);
-
-# endif  // NDEBUG
-}
-
-// Tests that an uninteresting mock function call on a naggy mock
-// causes the function arguments and return value to be printed.
-TEST(FunctionCallMessageTest,
-     UninterestingCallOnNaggyMockPrintsArgumentsAndReturnValue) {
-  // A non-void mock function.
-  NaggyMock<MockB> b;
-  CaptureStdout();
-  b.DoB();
-  const std::string output1 = GetCapturedStdout();
-  EXPECT_PRED_FORMAT2(
-      IsSubstring,
-      "Uninteresting mock function call - returning default value.\n"
-      "    Function call: DoB()\n"
-      "          Returns: 0\n", output1.c_str());
-  // Makes sure the return value is printed.
-
-  // A void mock function.
-  NaggyMock<MockC> c;
-  CaptureStdout();
-  c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
-  const std::string output2 = GetCapturedStdout();
-  EXPECT_THAT(output2.c_str(),
-              ContainsRegex(
-                  "Uninteresting mock function call - returning directly\\.\n"
-                  "    Function call: VoidMethod"
-                  "\\(false, 5, \"Hi\", NULL, @.+ "
-                  "Printable, 4-byte object <00-00 00-00>\\)"));
-  // A void function has no return value to print.
-}
-
-// Tests how the --gmock_verbose flag affects Google Mock's output.
-
-class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
- public:
-  // Verifies that the given Google Mock output is correct.  (When
-  // should_print is true, the output should match the given regex and
-  // contain the given function name in the stack trace.  When it's
-  // false, the output should be empty.)
-  void VerifyOutput(const std::string& output, bool should_print,
-                    const string& expected_substring,
-                    const string& function_name) {
-    if (should_print) {
-      EXPECT_THAT(output.c_str(), HasSubstr(expected_substring));
-# ifndef NDEBUG
-      // We check the stack trace content in dbg-mode only, as opt-mode
-      // may inline the call we are interested in seeing.
-      EXPECT_THAT(output.c_str(), HasSubstr(function_name));
-# else
-      // Suppresses 'unused function parameter' warnings.
-      static_cast<void>(function_name);
-# endif  // NDEBUG
-    } else {
-      EXPECT_STREQ("", output.c_str());
-    }
-  }
-
-  // Tests how the flag affects expected calls.
-  void TestExpectedCall(bool should_print) {
-    MockA a;
-    EXPECT_CALL(a, DoA(5));
-    EXPECT_CALL(a, Binary(_, 1))
-        .WillOnce(Return(true));
-
-    // A void-returning function.
-    CaptureStdout();
-    a.DoA(5);
-    VerifyOutput(
-        GetCapturedStdout(),
-        should_print,
-        "Mock function call matches EXPECT_CALL(a, DoA(5))...\n"
-        "    Function call: DoA(5)\n"
-        "Stack trace:\n",
-        "DoA");
-
-    // A non-void-returning function.
-    CaptureStdout();
-    a.Binary(2, 1);
-    VerifyOutput(
-        GetCapturedStdout(),
-        should_print,
-        "Mock function call matches EXPECT_CALL(a, Binary(_, 1))...\n"
-        "    Function call: Binary(2, 1)\n"
-        "          Returns: true\n"
-        "Stack trace:\n",
-        "Binary");
-  }
-
-  // Tests how the flag affects uninteresting calls on a naggy mock.
-  void TestUninterestingCallOnNaggyMock(bool should_print) {
-    NaggyMock<MockA> a;
-    const string note =
-        "NOTE: 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/googlemock/docs/CookBook.md#"
-        "knowing-when-to-expect for details.";
-
-    // A void-returning function.
-    CaptureStdout();
-    a.DoA(5);
-    VerifyOutput(
-        GetCapturedStdout(),
-        should_print,
-        "\nGMOCK WARNING:\n"
-        "Uninteresting mock function call - returning directly.\n"
-        "    Function call: DoA(5)\n" +
-        note,
-        "DoA");
-
-    // A non-void-returning function.
-    CaptureStdout();
-    a.Binary(2, 1);
-    VerifyOutput(
-        GetCapturedStdout(),
-        should_print,
-        "\nGMOCK WARNING:\n"
-        "Uninteresting mock function call - returning default value.\n"
-        "    Function call: Binary(2, 1)\n"
-        "          Returns: false\n" +
-        note,
-        "Binary");
-  }
-};
-
-// Tests that --gmock_verbose=info causes both expected and
-// uninteresting calls to be reported.
-TEST_F(GMockVerboseFlagTest, Info) {
-  GMOCK_FLAG(verbose) = kInfoVerbosity;
-  TestExpectedCall(true);
-  TestUninterestingCallOnNaggyMock(true);
-}
-
-// Tests that --gmock_verbose=warning causes uninteresting calls to be
-// reported.
-TEST_F(GMockVerboseFlagTest, Warning) {
-  GMOCK_FLAG(verbose) = kWarningVerbosity;
-  TestExpectedCall(false);
-  TestUninterestingCallOnNaggyMock(true);
-}
-
-// Tests that --gmock_verbose=warning causes neither expected nor
-// uninteresting calls to be reported.
-TEST_F(GMockVerboseFlagTest, Error) {
-  GMOCK_FLAG(verbose) = kErrorVerbosity;
-  TestExpectedCall(false);
-  TestUninterestingCallOnNaggyMock(false);
-}
-
-// Tests that --gmock_verbose=SOME_INVALID_VALUE has the same effect
-// as --gmock_verbose=warning.
-TEST_F(GMockVerboseFlagTest, InvalidFlagIsTreatedAsWarning) {
-  GMOCK_FLAG(verbose) = "invalid";  // Treated as "warning".
-  TestExpectedCall(false);
-  TestUninterestingCallOnNaggyMock(true);
-}
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-// A helper class that generates a failure when printed.  We use it to
-// ensure that Google Mock doesn't print a value (even to an internal
-// buffer) when it is not supposed to do so.
-class PrintMeNot {};
-
-void PrintTo(PrintMeNot /* dummy */, ::std::ostream* /* os */) {
-  ADD_FAILURE() << "Google Mock is printing a value that shouldn't be "
-                << "printed even to an internal buffer.";
-}
-
-class LogTestHelper {
- public:
-  LogTestHelper() {}
-
-  MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot));
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(LogTestHelper);
-};
-
-class GMockLogTest : public VerboseFlagPreservingFixture {
- protected:
-  LogTestHelper helper_;
-};
-
-TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsWarning) {
-  GMOCK_FLAG(verbose) = kWarningVerbosity;
-  EXPECT_CALL(helper_, Foo(_))
-      .WillOnce(Return(PrintMeNot()));
-  helper_.Foo(PrintMeNot());  // This is an expected call.
-}
-
-TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsError) {
-  GMOCK_FLAG(verbose) = kErrorVerbosity;
-  EXPECT_CALL(helper_, Foo(_))
-      .WillOnce(Return(PrintMeNot()));
-  helper_.Foo(PrintMeNot());  // This is an expected call.
-}
-
-TEST_F(GMockLogTest, DoesNotPrintWarningInternallyIfVerbosityIsError) {
-  GMOCK_FLAG(verbose) = kErrorVerbosity;
-  ON_CALL(helper_, Foo(_))
-      .WillByDefault(Return(PrintMeNot()));
-  helper_.Foo(PrintMeNot());  // This should generate a warning.
-}
-
-// Tests Mock::AllowLeak().
-
-TEST(AllowLeakTest, AllowsLeakingUnusedMockObject) {
-  MockA* a = new MockA;
-  Mock::AllowLeak(a);
-}
-
-TEST(AllowLeakTest, CanBeCalledBeforeOnCall) {
-  MockA* a = new MockA;
-  Mock::AllowLeak(a);
-  ON_CALL(*a, DoA(_)).WillByDefault(Return());
-  a->DoA(0);
-}
-
-TEST(AllowLeakTest, CanBeCalledAfterOnCall) {
-  MockA* a = new MockA;
-  ON_CALL(*a, DoA(_)).WillByDefault(Return());
-  Mock::AllowLeak(a);
-}
-
-TEST(AllowLeakTest, CanBeCalledBeforeExpectCall) {
-  MockA* a = new MockA;
-  Mock::AllowLeak(a);
-  EXPECT_CALL(*a, DoA(_));
-  a->DoA(0);
-}
-
-TEST(AllowLeakTest, CanBeCalledAfterExpectCall) {
-  MockA* a = new MockA;
-  EXPECT_CALL(*a, DoA(_)).Times(AnyNumber());
-  Mock::AllowLeak(a);
-}
-
-TEST(AllowLeakTest, WorksWhenBothOnCallAndExpectCallArePresent) {
-  MockA* a = new MockA;
-  ON_CALL(*a, DoA(_)).WillByDefault(Return());
-  EXPECT_CALL(*a, DoA(_)).Times(AnyNumber());
-  Mock::AllowLeak(a);
-}
-
-// Tests that we can verify and clear a mock object's expectations
-// when none of its methods has expectations.
-TEST(VerifyAndClearExpectationsTest, NoMethodHasExpectations) {
-  MockB b;
-  ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
-
-  // There should be no expectations on the methods now, so we can
-  // freely call them.
-  EXPECT_EQ(0, b.DoB());
-  EXPECT_EQ(0, b.DoB(1));
-}
-
-// Tests that we can verify and clear a mock object's expectations
-// when some, but not all, of its methods have expectations *and* the
-// verification succeeds.
-TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndSucceed) {
-  MockB b;
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(1));
-  b.DoB();
-  ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
-
-  // There should be no expectations on the methods now, so we can
-  // freely call them.
-  EXPECT_EQ(0, b.DoB());
-  EXPECT_EQ(0, b.DoB(1));
-}
-
-// Tests that we can verify and clear a mock object's expectations
-// when some, but not all, of its methods have expectations *and* the
-// verification fails.
-TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndFail) {
-  MockB b;
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(1));
-  bool result = true;
-  EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
-                          "Actual: never called");
-  ASSERT_FALSE(result);
-
-  // There should be no expectations on the methods now, so we can
-  // freely call them.
-  EXPECT_EQ(0, b.DoB());
-  EXPECT_EQ(0, b.DoB(1));
-}
-
-// Tests that we can verify and clear a mock object's expectations
-// when all of its methods have expectations.
-TEST(VerifyAndClearExpectationsTest, AllMethodsHaveExpectations) {
-  MockB b;
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(1));
-  EXPECT_CALL(b, DoB(_))
-      .WillOnce(Return(2));
-  b.DoB();
-  b.DoB(1);
-  ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
-
-  // There should be no expectations on the methods now, so we can
-  // freely call them.
-  EXPECT_EQ(0, b.DoB());
-  EXPECT_EQ(0, b.DoB(1));
-}
-
-// Tests that we can verify and clear a mock object's expectations
-// when a method has more than one expectation.
-TEST(VerifyAndClearExpectationsTest, AMethodHasManyExpectations) {
-  MockB b;
-  EXPECT_CALL(b, DoB(0))
-      .WillOnce(Return(1));
-  EXPECT_CALL(b, DoB(_))
-      .WillOnce(Return(2));
-  b.DoB(1);
-  bool result = true;
-  EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
-                          "Actual: never called");
-  ASSERT_FALSE(result);
-
-  // There should be no expectations on the methods now, so we can
-  // freely call them.
-  EXPECT_EQ(0, b.DoB());
-  EXPECT_EQ(0, b.DoB(1));
-}
-
-// Tests that we can call VerifyAndClearExpectations() on the same
-// mock object multiple times.
-TEST(VerifyAndClearExpectationsTest, CanCallManyTimes) {
-  MockB b;
-  EXPECT_CALL(b, DoB());
-  b.DoB();
-  Mock::VerifyAndClearExpectations(&b);
-
-  EXPECT_CALL(b, DoB(_))
-      .WillOnce(Return(1));
-  b.DoB(1);
-  Mock::VerifyAndClearExpectations(&b);
-  Mock::VerifyAndClearExpectations(&b);
-
-  // There should be no expectations on the methods now, so we can
-  // freely call them.
-  EXPECT_EQ(0, b.DoB());
-  EXPECT_EQ(0, b.DoB(1));
-}
-
-// Tests that we can clear a mock object's default actions when none
-// of its methods has default actions.
-TEST(VerifyAndClearTest, NoMethodHasDefaultActions) {
-  MockB b;
-  // If this crashes or generates a failure, the test will catch it.
-  Mock::VerifyAndClear(&b);
-  EXPECT_EQ(0, b.DoB());
-}
-
-// Tests that we can clear a mock object's default actions when some,
-// but not all of its methods have default actions.
-TEST(VerifyAndClearTest, SomeMethodsHaveDefaultActions) {
-  MockB b;
-  ON_CALL(b, DoB())
-      .WillByDefault(Return(1));
-
-  Mock::VerifyAndClear(&b);
-
-  // Verifies that the default action of int DoB() was removed.
-  EXPECT_EQ(0, b.DoB());
-}
-
-// Tests that we can clear a mock object's default actions when all of
-// its methods have default actions.
-TEST(VerifyAndClearTest, AllMethodsHaveDefaultActions) {
-  MockB b;
-  ON_CALL(b, DoB())
-      .WillByDefault(Return(1));
-  ON_CALL(b, DoB(_))
-      .WillByDefault(Return(2));
-
-  Mock::VerifyAndClear(&b);
-
-  // Verifies that the default action of int DoB() was removed.
-  EXPECT_EQ(0, b.DoB());
-
-  // Verifies that the default action of int DoB(int) was removed.
-  EXPECT_EQ(0, b.DoB(0));
-}
-
-// Tests that we can clear a mock object's default actions when a
-// method has more than one ON_CALL() set on it.
-TEST(VerifyAndClearTest, AMethodHasManyDefaultActions) {
-  MockB b;
-  ON_CALL(b, DoB(0))
-      .WillByDefault(Return(1));
-  ON_CALL(b, DoB(_))
-      .WillByDefault(Return(2));
-
-  Mock::VerifyAndClear(&b);
-
-  // Verifies that the default actions (there are two) of int DoB(int)
-  // were removed.
-  EXPECT_EQ(0, b.DoB(0));
-  EXPECT_EQ(0, b.DoB(1));
-}
-
-// Tests that we can call VerifyAndClear() on a mock object multiple
-// times.
-TEST(VerifyAndClearTest, CanCallManyTimes) {
-  MockB b;
-  ON_CALL(b, DoB())
-      .WillByDefault(Return(1));
-  Mock::VerifyAndClear(&b);
-  Mock::VerifyAndClear(&b);
-
-  ON_CALL(b, DoB(_))
-      .WillByDefault(Return(1));
-  Mock::VerifyAndClear(&b);
-
-  EXPECT_EQ(0, b.DoB());
-  EXPECT_EQ(0, b.DoB(1));
-}
-
-// Tests that VerifyAndClear() works when the verification succeeds.
-TEST(VerifyAndClearTest, Success) {
-  MockB b;
-  ON_CALL(b, DoB())
-      .WillByDefault(Return(1));
-  EXPECT_CALL(b, DoB(1))
-      .WillOnce(Return(2));
-
-  b.DoB();
-  b.DoB(1);
-  ASSERT_TRUE(Mock::VerifyAndClear(&b));
-
-  // There should be no expectations on the methods now, so we can
-  // freely call them.
-  EXPECT_EQ(0, b.DoB());
-  EXPECT_EQ(0, b.DoB(1));
-}
-
-// Tests that VerifyAndClear() works when the verification fails.
-TEST(VerifyAndClearTest, Failure) {
-  MockB b;
-  ON_CALL(b, DoB(_))
-      .WillByDefault(Return(1));
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(2));
-
-  b.DoB(1);
-  bool result = true;
-  EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClear(&b),
-                          "Actual: never called");
-  ASSERT_FALSE(result);
-
-  // There should be no expectations on the methods now, so we can
-  // freely call them.
-  EXPECT_EQ(0, b.DoB());
-  EXPECT_EQ(0, b.DoB(1));
-}
-
-// Tests that VerifyAndClear() works when the default actions and
-// expectations are set on a const mock object.
-TEST(VerifyAndClearTest, Const) {
-  MockB b;
-  ON_CALL(Const(b), DoB())
-      .WillByDefault(Return(1));
-
-  EXPECT_CALL(Const(b), DoB())
-      .WillOnce(DoDefault())
-      .WillOnce(Return(2));
-
-  b.DoB();
-  b.DoB();
-  ASSERT_TRUE(Mock::VerifyAndClear(&b));
-
-  // There should be no expectations on the methods now, so we can
-  // freely call them.
-  EXPECT_EQ(0, b.DoB());
-  EXPECT_EQ(0, b.DoB(1));
-}
-
-// Tests that we can set default actions and expectations on a mock
-// object after VerifyAndClear() has been called on it.
-TEST(VerifyAndClearTest, CanSetDefaultActionsAndExpectationsAfterwards) {
-  MockB b;
-  ON_CALL(b, DoB())
-      .WillByDefault(Return(1));
-  EXPECT_CALL(b, DoB(_))
-      .WillOnce(Return(2));
-  b.DoB(1);
-
-  Mock::VerifyAndClear(&b);
-
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(3));
-  ON_CALL(b, DoB(_))
-      .WillByDefault(Return(4));
-
-  EXPECT_EQ(3, b.DoB());
-  EXPECT_EQ(4, b.DoB(1));
-}
-
-// Tests that calling VerifyAndClear() on one mock object does not
-// affect other mock objects (either of the same type or not).
-TEST(VerifyAndClearTest, DoesNotAffectOtherMockObjects) {
-  MockA a;
-  MockB b1;
-  MockB b2;
-
-  ON_CALL(a, Binary(_, _))
-      .WillByDefault(Return(true));
-  EXPECT_CALL(a, Binary(_, _))
-      .WillOnce(DoDefault())
-      .WillOnce(Return(false));
-
-  ON_CALL(b1, DoB())
-      .WillByDefault(Return(1));
-  EXPECT_CALL(b1, DoB(_))
-      .WillOnce(Return(2));
-
-  ON_CALL(b2, DoB())
-      .WillByDefault(Return(3));
-  EXPECT_CALL(b2, DoB(_));
-
-  b2.DoB(0);
-  Mock::VerifyAndClear(&b2);
-
-  // Verifies that the default actions and expectations of a and b1
-  // are still in effect.
-  EXPECT_TRUE(a.Binary(0, 0));
-  EXPECT_FALSE(a.Binary(0, 0));
-
-  EXPECT_EQ(1, b1.DoB());
-  EXPECT_EQ(2, b1.DoB(0));
-}
-
-TEST(VerifyAndClearTest,
-     DestroyingChainedMocksDoesNotDeadlockThroughExpectations) {
-  linked_ptr<MockA> a(new MockA);
-  ReferenceHoldingMock test_mock;
-
-  // EXPECT_CALL stores a reference to a inside test_mock.
-  EXPECT_CALL(test_mock, AcceptReference(_))
-      .WillRepeatedly(SetArgPointee<0>(a));
-
-  // Throw away the reference to the mock that we have in a. After this, the
-  // only reference to it is stored by test_mock.
-  a.reset();
-
-  // When test_mock goes out of scope, it destroys the last remaining reference
-  // to the mock object originally pointed to by a. This will cause the MockA
-  // destructor to be called from inside the ReferenceHoldingMock destructor.
-  // The state of all mocks is protected by a single global lock, but there
-  // should be no deadlock.
-}
-
-TEST(VerifyAndClearTest,
-     DestroyingChainedMocksDoesNotDeadlockThroughDefaultAction) {
-  linked_ptr<MockA> a(new MockA);
-  ReferenceHoldingMock test_mock;
-
-  // ON_CALL stores a reference to a inside test_mock.
-  ON_CALL(test_mock, AcceptReference(_))
-      .WillByDefault(SetArgPointee<0>(a));
-
-  // Throw away the reference to the mock that we have in a. After this, the
-  // only reference to it is stored by test_mock.
-  a.reset();
-
-  // When test_mock goes out of scope, it destroys the last remaining reference
-  // to the mock object originally pointed to by a. This will cause the MockA
-  // destructor to be called from inside the ReferenceHoldingMock destructor.
-  // The state of all mocks is protected by a single global lock, but there
-  // should be no deadlock.
-}
-
-// Tests that a mock function's action can call a mock function
-// (either the same function or a different one) either as an explicit
-// action or as a default action without causing a dead lock.  It
-// verifies that the action is not performed inside the critical
-// section.
-TEST(SynchronizationTest, CanCallMockMethodInAction) {
-  MockA a;
-  MockC c;
-  ON_CALL(a, DoA(_))
-      .WillByDefault(IgnoreResult(InvokeWithoutArgs(&c,
-                                                    &MockC::NonVoidMethod)));
-  EXPECT_CALL(a, DoA(1));
-  EXPECT_CALL(a, DoA(1))
-      .WillOnce(Invoke(&a, &MockA::DoA))
-      .RetiresOnSaturation();
-  EXPECT_CALL(c, NonVoidMethod());
-
-  a.DoA(1);
-  // This will match the second EXPECT_CALL() and trigger another a.DoA(1),
-  // which will in turn match the first EXPECT_CALL() and trigger a call to
-  // c.NonVoidMethod() that was specified by the ON_CALL() since the first
-  // EXPECT_CALL() did not specify an action.
-}
-
-}  // namespace
-
-// Allows the user to define his own main and then invoke gmock_main
-// from it. This might be necessary on some platforms which require
-// specific setup and teardown.
-#if GMOCK_RENAME_MAIN
-int gmock_main(int argc, char **argv) {
-#else
-int main(int argc, char **argv) {
-#endif  // GMOCK_RENAME_MAIN
-  testing::InitGoogleMock(&argc, argv);
-
-  // Ensures that the tests pass no matter what value of
-  // --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
-  testing::GMOCK_FLAG(catch_leaked_mocks) = true;
-  testing::GMOCK_FLAG(verbose) = testing::internal::kWarningVerbosity;
-
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_all_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_all_test.cc
deleted file mode 100644
index 56d6c49c..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_all_test.cc
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2009, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Tests for Google C++ Mocking Framework (Google Mock)
-//
-// Some users use a build system that Google Mock doesn't support directly,
-// yet they still want to build and run Google Mock's own tests.  This file
-// includes most such tests, making it easier for these users to maintain
-// their build scripts (they just need to build this file, even though the
-// below list of actual *_test.cc files might change).
-#include "test/gmock-actions_test.cc"
-#include "test/gmock-cardinalities_test.cc"
-#include "test/gmock-generated-actions_test.cc"
-#include "test/gmock-generated-function-mockers_test.cc"
-#include "test/gmock-generated-internal-utils_test.cc"
-#include "test/gmock-generated-matchers_test.cc"
-#include "test/gmock-internal-utils_test.cc"
-#include "test/gmock-matchers_test.cc"
-#include "test/gmock-more-actions_test.cc"
-#include "test/gmock-nice-strict_test.cc"
-#include "test/gmock-port_test.cc"
-#include "test/gmock-spec-builders_test.cc"
-#include "test/gmock_test.cc"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_ex_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_ex_test.cc
deleted file mode 100644
index 3afed86a..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_ex_test.cc
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2013, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Tests Google Mock's functionality that depends on exceptions.
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-namespace {
-
-using testing::HasSubstr;
-using testing::internal::GoogleTestFailureException;
-
-// A type that cannot be default constructed.
-class NonDefaultConstructible {
- public:
-  explicit NonDefaultConstructible(int /* dummy */) {}
-};
-
-class MockFoo {
- public:
-  // A mock method that returns a user-defined type.  Google Mock
-  // doesn't know what the default value for this type is.
-  MOCK_METHOD0(GetNonDefaultConstructible, NonDefaultConstructible());
-};
-
-#if GTEST_HAS_EXCEPTIONS
-
-TEST(DefaultValueTest, ThrowsRuntimeErrorWhenNoDefaultValue) {
-  MockFoo mock;
-  try {
-    // No expectation is set on this method, so Google Mock must
-    // return the default value.  However, since Google Mock knows
-    // nothing about the return type, it doesn't know what to return,
-    // and has to throw (when exceptions are enabled) or abort
-    // (otherwise).
-    mock.GetNonDefaultConstructible();
-    FAIL() << "GetNonDefaultConstructible()'s return type has no default "
-           << "value, so Google Mock should have thrown.";
-  } catch (const GoogleTestFailureException& /* unused */) {
-    FAIL() << "Google Test does not try to catch an exception of type "
-           << "GoogleTestFailureException, which is used for reporting "
-           << "a failure to other testing frameworks.  Google Mock should "
-           << "not throw a GoogleTestFailureException as it will kill the "
-           << "entire test program instead of just the current TEST.";
-  } catch (const std::exception& ex) {
-    EXPECT_THAT(ex.what(), HasSubstr("has no default value"));
-  }
-}
-
-#endif
-
-}  // unnamed namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test.py
deleted file mode 100755
index 997680ce..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test.py
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2009, 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.
-
-"""Tests that leaked mock objects can be caught be Google Mock."""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-
-import gmock_test_utils
-
-
-PROGRAM_PATH = gmock_test_utils.GetTestExecutablePath('gmock_leak_test_')
-TEST_WITH_EXPECT_CALL = [PROGRAM_PATH, '--gtest_filter=*ExpectCall*']
-TEST_WITH_ON_CALL = [PROGRAM_PATH, '--gtest_filter=*OnCall*']
-TEST_MULTIPLE_LEAKS = [PROGRAM_PATH, '--gtest_filter=*MultipleLeaked*']
-
-environ = gmock_test_utils.environ
-SetEnvVar = gmock_test_utils.SetEnvVar
-
-# Tests in this file run a Google-Test-based test program and expect it
-# to terminate prematurely.  Therefore they are incompatible with
-# the premature-exit-file protocol by design.  Unset the
-# premature-exit filepath to prevent Google Test from creating
-# the file.
-SetEnvVar(gmock_test_utils.PREMATURE_EXIT_FILE_ENV_VAR, None)
-
-
-class GMockLeakTest(gmock_test_utils.TestCase):
-
-  def testCatchesLeakedMockByDefault(self):
-    self.assertNotEqual(
-        0,
-        gmock_test_utils.Subprocess(TEST_WITH_EXPECT_CALL,
-                                    env=environ).exit_code)
-    self.assertNotEqual(
-        0,
-        gmock_test_utils.Subprocess(TEST_WITH_ON_CALL,
-                                    env=environ).exit_code)
-
-  def testDoesNotCatchLeakedMockWhenDisabled(self):
-    self.assertEquals(
-        0,
-        gmock_test_utils.Subprocess(TEST_WITH_EXPECT_CALL +
-                                    ['--gmock_catch_leaked_mocks=0'],
-                                    env=environ).exit_code)
-    self.assertEquals(
-        0,
-        gmock_test_utils.Subprocess(TEST_WITH_ON_CALL +
-                                    ['--gmock_catch_leaked_mocks=0'],
-                                    env=environ).exit_code)
-
-  def testCatchesLeakedMockWhenEnabled(self):
-    self.assertNotEqual(
-        0,
-        gmock_test_utils.Subprocess(TEST_WITH_EXPECT_CALL +
-                                    ['--gmock_catch_leaked_mocks'],
-                                    env=environ).exit_code)
-    self.assertNotEqual(
-        0,
-        gmock_test_utils.Subprocess(TEST_WITH_ON_CALL +
-                                    ['--gmock_catch_leaked_mocks'],
-                                    env=environ).exit_code)
-
-  def testCatchesLeakedMockWhenEnabledWithExplictFlagValue(self):
-    self.assertNotEqual(
-        0,
-        gmock_test_utils.Subprocess(TEST_WITH_EXPECT_CALL +
-                                    ['--gmock_catch_leaked_mocks=1'],
-                                    env=environ).exit_code)
-
-  def testCatchesMultipleLeakedMocks(self):
-    self.assertNotEqual(
-        0,
-        gmock_test_utils.Subprocess(TEST_MULTIPLE_LEAKS +
-                                    ['--gmock_catch_leaked_mocks'],
-                                    env=environ).exit_code)
-
-
-if __name__ == '__main__':
-  gmock_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test_.cc
deleted file mode 100644
index 1d27d22f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_leak_test_.cc
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright 2009, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This program is for verifying that a leaked mock object can be
-// caught by Google Mock's leak detector.
-
-#include "gmock/gmock.h"
-
-namespace {
-
-using ::testing::Return;
-
-class FooInterface {
- public:
-  virtual ~FooInterface() {}
-  virtual void DoThis() = 0;
-};
-
-class MockFoo : public FooInterface {
- public:
-  MockFoo() {}
-
-  MOCK_METHOD0(DoThis, void());
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
-};
-
-TEST(LeakTest, LeakedMockWithExpectCallCausesFailureWhenLeakCheckingIsEnabled) {
-  MockFoo* foo = new MockFoo;
-
-  EXPECT_CALL(*foo, DoThis());
-  foo->DoThis();
-
-  // In order to test the leak detector, we deliberately leak foo.
-
-  // Makes sure Google Mock's leak detector can change the exit code
-  // to 1 even when the code is already exiting with 0.
-  exit(0);
-}
-
-TEST(LeakTest, LeakedMockWithOnCallCausesFailureWhenLeakCheckingIsEnabled) {
-  MockFoo* foo = new MockFoo;
-
-  ON_CALL(*foo, DoThis()).WillByDefault(Return());
-
-  // In order to test the leak detector, we deliberately leak foo.
-
-  // Makes sure Google Mock's leak detector can change the exit code
-  // to 1 even when the code is already exiting with 0.
-  exit(0);
-}
-
-TEST(LeakTest, CatchesMultipleLeakedMockObjects) {
-  MockFoo* foo1 = new MockFoo;
-  MockFoo* foo2 = new MockFoo;
-
-  ON_CALL(*foo1, DoThis()).WillByDefault(Return());
-  EXPECT_CALL(*foo2, DoThis());
-  foo2->DoThis();
-
-  // In order to test the leak detector, we deliberately leak foo1 and
-  // foo2.
-
-  // Makes sure Google Mock's leak detector can change the exit code
-  // to 1 even when the code is already exiting with 0.
-  exit(0);
-}
-
-}  // namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link2_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link2_test.cc
deleted file mode 100644
index 4c310c3d..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link2_test.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file is for verifying that various Google Mock constructs do not
-// produce linker errors when instantiated in different translation units.
-// Please see gmock_link_test.h for details.
-
-#define LinkTest LinkTest2
-
-#include  "test/gmock_link_test.h"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.cc
deleted file mode 100644
index 61e97d10..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file is for verifying that various Google Mock constructs do not
-// produce linker errors when instantiated in different translation units.
-// Please see gmock_link_test.h for details.
-
-#define LinkTest LinkTest1
-
-#include  "test/gmock_link_test.h"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.h b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.h
deleted file mode 100644
index 1f55f5bd..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_link_test.h
+++ /dev/null
@@ -1,669 +0,0 @@
-// Copyright 2009, 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests that:
-// a. A header file defining a mock class can be included in multiple
-//    translation units without causing a link error.
-// b. Actions and matchers can be instantiated with identical template
-//    arguments in different translation units without causing link
-//    errors.
-//    The following constructs are currently tested:
-//    Actions:
-//      Return()
-//      Return(value)
-//      ReturnNull
-//      ReturnRef
-//      Assign
-//      SetArgPointee
-//      SetArrayArgument
-//      SetErrnoAndReturn
-//      Invoke(function)
-//      Invoke(object, method)
-//      InvokeWithoutArgs(function)
-//      InvokeWithoutArgs(object, method)
-//      InvokeArgument
-//      WithArg
-//      WithArgs
-//      WithoutArgs
-//      DoAll
-//      DoDefault
-//      IgnoreResult
-//      Throw
-//      ACTION()-generated
-//      ACTION_P()-generated
-//      ACTION_P2()-generated
-//    Matchers:
-//      _
-//      A
-//      An
-//      Eq
-//      Gt, Lt, Ge, Le, Ne
-//      NotNull
-//      Ref
-//      TypedEq
-//      DoubleEq
-//      FloatEq
-//      NanSensitiveDoubleEq
-//      NanSensitiveFloatEq
-//      ContainsRegex
-//      MatchesRegex
-//      EndsWith
-//      HasSubstr
-//      StartsWith
-//      StrCaseEq
-//      StrCaseNe
-//      StrEq
-//      StrNe
-//      ElementsAre
-//      ElementsAreArray
-//      ContainerEq
-//      Field
-//      Property
-//      ResultOf(function)
-//      Pointee
-//      Truly(predicate)
-//      AllOf
-//      AnyOf
-//      Not
-//      MatcherCast<T>
-//
-//  Please note: this test does not verify the functioning of these
-//  constructs, only that the programs using them will link successfully.
-//
-// Implementation note:
-// This test requires identical definitions of Interface and Mock to be
-// included in different translation units.  We achieve this by writing
-// them in this header and #including it in gmock_link_test.cc and
-// gmock_link2_test.cc.  Because the symbols generated by the compiler for
-// those constructs must be identical in both translation units,
-// definitions of Interface and Mock tests MUST be kept in the SAME
-// NON-ANONYMOUS namespace in this file.  The test fixture class LinkTest
-// is defined as LinkTest1 in gmock_link_test.cc and as LinkTest2 in
-// gmock_link2_test.cc to avoid producing linker errors.
-
-#ifndef GMOCK_TEST_GMOCK_LINK_TEST_H_
-#define GMOCK_TEST_GMOCK_LINK_TEST_H_
-
-#include "gmock/gmock.h"
-
-#if !GTEST_OS_WINDOWS_MOBILE
-# include <errno.h>
-#endif
-
-#include "gmock/internal/gmock-port.h"
-#include "gtest/gtest.h"
-#include <iostream>
-#include <vector>
-
-using testing::_;
-using testing::A;
-using testing::AllOf;
-using testing::AnyOf;
-using testing::Assign;
-using testing::ContainerEq;
-using testing::DoAll;
-using testing::DoDefault;
-using testing::DoubleEq;
-using testing::ElementsAre;
-using testing::ElementsAreArray;
-using testing::EndsWith;
-using testing::Eq;
-using testing::Field;
-using testing::FloatEq;
-using testing::Ge;
-using testing::Gt;
-using testing::HasSubstr;
-using testing::IgnoreResult;
-using testing::Invoke;
-using testing::InvokeArgument;
-using testing::InvokeWithoutArgs;
-using testing::IsNull;
-using testing::Le;
-using testing::Lt;
-using testing::Matcher;
-using testing::MatcherCast;
-using testing::NanSensitiveDoubleEq;
-using testing::NanSensitiveFloatEq;
-using testing::Ne;
-using testing::Not;
-using testing::NotNull;
-using testing::Pointee;
-using testing::Property;
-using testing::Ref;
-using testing::ResultOf;
-using testing::Return;
-using testing::ReturnNull;
-using testing::ReturnRef;
-using testing::SetArgPointee;
-using testing::SetArrayArgument;
-using testing::StartsWith;
-using testing::StrCaseEq;
-using testing::StrCaseNe;
-using testing::StrEq;
-using testing::StrNe;
-using testing::Truly;
-using testing::TypedEq;
-using testing::WithArg;
-using testing::WithArgs;
-using testing::WithoutArgs;
-
-#if !GTEST_OS_WINDOWS_MOBILE
-using testing::SetErrnoAndReturn;
-#endif
-
-#if GTEST_HAS_EXCEPTIONS
-using testing::Throw;
-#endif
-
-using testing::ContainsRegex;
-using testing::MatchesRegex;
-
-class Interface {
- public:
-  virtual ~Interface() {}
-  virtual void VoidFromString(char* str) = 0;
-  virtual char* StringFromString(char* str) = 0;
-  virtual int IntFromString(char* str) = 0;
-  virtual int& IntRefFromString(char* str) = 0;
-  virtual void VoidFromFunc(void(*func)(char* str)) = 0;
-  virtual void VoidFromIntRef(int& n) = 0;  // NOLINT
-  virtual void VoidFromFloat(float n) = 0;
-  virtual void VoidFromDouble(double n) = 0;
-  virtual void VoidFromVector(const std::vector<int>& v) = 0;
-};
-
-class Mock: public Interface {
- public:
-  Mock() {}
-
-  MOCK_METHOD1(VoidFromString, void(char* str));
-  MOCK_METHOD1(StringFromString, char*(char* str));
-  MOCK_METHOD1(IntFromString, int(char* str));
-  MOCK_METHOD1(IntRefFromString, int&(char* str));
-  MOCK_METHOD1(VoidFromFunc, void(void(*func)(char* str)));
-  MOCK_METHOD1(VoidFromIntRef, void(int& n));  // NOLINT
-  MOCK_METHOD1(VoidFromFloat, void(float n));
-  MOCK_METHOD1(VoidFromDouble, void(double n));
-  MOCK_METHOD1(VoidFromVector, void(const std::vector<int>& v));
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
-};
-
-class InvokeHelper {
- public:
-  static void StaticVoidFromVoid() {}
-  void VoidFromVoid() {}
-  static void StaticVoidFromString(char* /* str */) {}
-  void VoidFromString(char* /* str */) {}
-  static int StaticIntFromString(char* /* str */) { return 1; }
-  static bool StaticBoolFromString(const char* /* str */) { return true; }
-};
-
-class FieldHelper {
- public:
-  explicit FieldHelper(int a_field) : field_(a_field) {}
-  int field() const { return field_; }
-  int field_;  // NOLINT -- need external access to field_ to test
-               //           the Field matcher.
-};
-
-// Tests the linkage of the ReturnVoid action.
-TEST(LinkTest, TestReturnVoid) {
-  Mock mock;
-
-  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
-  mock.VoidFromString(NULL);
-}
-
-// Tests the linkage of the Return action.
-TEST(LinkTest, TestReturn) {
-  Mock mock;
-  char ch = 'x';
-
-  EXPECT_CALL(mock, StringFromString(_)).WillOnce(Return(&ch));
-  mock.StringFromString(NULL);
-}
-
-// Tests the linkage of the ReturnNull action.
-TEST(LinkTest, TestReturnNull) {
-  Mock mock;
-
-  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
-  mock.VoidFromString(NULL);
-}
-
-// Tests the linkage of the ReturnRef action.
-TEST(LinkTest, TestReturnRef) {
-  Mock mock;
-  int n = 42;
-
-  EXPECT_CALL(mock, IntRefFromString(_)).WillOnce(ReturnRef(n));
-  mock.IntRefFromString(NULL);
-}
-
-// Tests the linkage of the Assign action.
-TEST(LinkTest, TestAssign) {
-  Mock mock;
-  char ch = 'x';
-
-  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Assign(&ch, 'y'));
-  mock.VoidFromString(NULL);
-}
-
-// Tests the linkage of the SetArgPointee action.
-TEST(LinkTest, TestSetArgPointee) {
-  Mock mock;
-  char ch = 'x';
-
-  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(SetArgPointee<0>('y'));
-  mock.VoidFromString(&ch);
-}
-
-// Tests the linkage of the SetArrayArgument action.
-TEST(LinkTest, TestSetArrayArgument) {
-  Mock mock;
-  char ch = 'x';
-  char ch2 = 'y';
-
-  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(SetArrayArgument<0>(&ch2,
-                                                                    &ch2 + 1));
-  mock.VoidFromString(&ch);
-}
-
-#if !GTEST_OS_WINDOWS_MOBILE
-
-// Tests the linkage of the SetErrnoAndReturn action.
-TEST(LinkTest, TestSetErrnoAndReturn) {
-  Mock mock;
-
-  int saved_errno = errno;
-  EXPECT_CALL(mock, IntFromString(_)).WillOnce(SetErrnoAndReturn(1, -1));
-  mock.IntFromString(NULL);
-  errno = saved_errno;
-}
-
-#endif  // !GTEST_OS_WINDOWS_MOBILE
-
-// Tests the linkage of the Invoke(function) and Invoke(object, method) actions.
-TEST(LinkTest, TestInvoke) {
-  Mock mock;
-  InvokeHelper test_invoke_helper;
-
-  EXPECT_CALL(mock, VoidFromString(_))
-      .WillOnce(Invoke(&InvokeHelper::StaticVoidFromString))
-      .WillOnce(Invoke(&test_invoke_helper, &InvokeHelper::VoidFromString));
-  mock.VoidFromString(NULL);
-  mock.VoidFromString(NULL);
-}
-
-// Tests the linkage of the InvokeWithoutArgs action.
-TEST(LinkTest, TestInvokeWithoutArgs) {
-  Mock mock;
-  InvokeHelper test_invoke_helper;
-
-  EXPECT_CALL(mock, VoidFromString(_))
-      .WillOnce(InvokeWithoutArgs(&InvokeHelper::StaticVoidFromVoid))
-      .WillOnce(InvokeWithoutArgs(&test_invoke_helper,
-                                  &InvokeHelper::VoidFromVoid));
-  mock.VoidFromString(NULL);
-  mock.VoidFromString(NULL);
-}
-
-// Tests the linkage of the InvokeArgument action.
-TEST(LinkTest, TestInvokeArgument) {
-  Mock mock;
-  char ch = 'x';
-
-  EXPECT_CALL(mock, VoidFromFunc(_)).WillOnce(InvokeArgument<0>(&ch));
-  mock.VoidFromFunc(InvokeHelper::StaticVoidFromString);
-}
-
-// Tests the linkage of the WithArg action.
-TEST(LinkTest, TestWithArg) {
-  Mock mock;
-
-  EXPECT_CALL(mock, VoidFromString(_))
-      .WillOnce(WithArg<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
-  mock.VoidFromString(NULL);
-}
-
-// Tests the linkage of the WithArgs action.
-TEST(LinkTest, TestWithArgs) {
-  Mock mock;
-
-  EXPECT_CALL(mock, VoidFromString(_))
-      .WillOnce(WithArgs<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
-  mock.VoidFromString(NULL);
-}
-
-// Tests the linkage of the WithoutArgs action.
-TEST(LinkTest, TestWithoutArgs) {
-  Mock mock;
-
-  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(WithoutArgs(Return()));
-  mock.VoidFromString(NULL);
-}
-
-// Tests the linkage of the DoAll action.
-TEST(LinkTest, TestDoAll) {
-  Mock mock;
-  char ch = 'x';
-
-  EXPECT_CALL(mock, VoidFromString(_))
-      .WillOnce(DoAll(SetArgPointee<0>('y'), Return()));
-  mock.VoidFromString(&ch);
-}
-
-// Tests the linkage of the DoDefault action.
-TEST(LinkTest, TestDoDefault) {
-  Mock mock;
-  char ch = 'x';
-
-  ON_CALL(mock, VoidFromString(_)).WillByDefault(Return());
-  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(DoDefault());
-  mock.VoidFromString(&ch);
-}
-
-// Tests the linkage of the IgnoreResult action.
-TEST(LinkTest, TestIgnoreResult) {
-  Mock mock;
-
-  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(IgnoreResult(Return(42)));
-  mock.VoidFromString(NULL);
-}
-
-#if GTEST_HAS_EXCEPTIONS
-// Tests the linkage of the Throw action.
-TEST(LinkTest, TestThrow) {
-  Mock mock;
-
-  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Throw(42));
-  EXPECT_THROW(mock.VoidFromString(NULL), int);
-}
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// 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
-// is expanded and macro expansion cannot contain #pragma.  Therefore
-// we suppress them here.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
-#endif
-
-// Tests the linkage of actions created using ACTION macro.
-namespace {
-ACTION(Return1) { return 1; }
-}
-
-TEST(LinkTest, TestActionMacro) {
-  Mock mock;
-
-  EXPECT_CALL(mock, IntFromString(_)).WillOnce(Return1());
-  mock.IntFromString(NULL);
-}
-
-// Tests the linkage of actions created using ACTION_P macro.
-namespace {
-ACTION_P(ReturnArgument, ret_value) { return ret_value; }
-}
-
-TEST(LinkTest, TestActionPMacro) {
-  Mock mock;
-
-  EXPECT_CALL(mock, IntFromString(_)).WillOnce(ReturnArgument(42));
-  mock.IntFromString(NULL);
-}
-
-// Tests the linkage of actions created using ACTION_P2 macro.
-namespace {
-ACTION_P2(ReturnEqualsEitherOf, first, second) {
-  return arg0 == first || arg0 == second;
-}
-}
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-TEST(LinkTest, TestActionP2Macro) {
-  Mock mock;
-  char ch = 'x';
-
-  EXPECT_CALL(mock, IntFromString(_))
-      .WillOnce(ReturnEqualsEitherOf("one", "two"));
-  mock.IntFromString(&ch);
-}
-
-// Tests the linkage of the "_" matcher.
-TEST(LinkTest, TestMatcherAnything) {
-  Mock mock;
-
-  ON_CALL(mock, VoidFromString(_)).WillByDefault(Return());
-}
-
-// Tests the linkage of the A matcher.
-TEST(LinkTest, TestMatcherA) {
-  Mock mock;
-
-  ON_CALL(mock, VoidFromString(A<char*>())).WillByDefault(Return());
-}
-
-// Tests the linkage of the Eq and the "bare value" matcher.
-TEST(LinkTest, TestMatchersEq) {
-  Mock mock;
-  const char* p = "x";
-
-  ON_CALL(mock, VoidFromString(Eq(p))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromString(const_cast<char*>("y")))
-      .WillByDefault(Return());
-}
-
-// Tests the linkage of the Lt, Gt, Le, Ge, and Ne matchers.
-TEST(LinkTest, TestMatchersRelations) {
-  Mock mock;
-
-  ON_CALL(mock, VoidFromFloat(Lt(1.0f))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromFloat(Gt(1.0f))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromFloat(Le(1.0f))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromFloat(Ge(1.0f))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromFloat(Ne(1.0f))).WillByDefault(Return());
-}
-
-// Tests the linkage of the NotNull matcher.
-TEST(LinkTest, TestMatcherNotNull) {
-  Mock mock;
-
-  ON_CALL(mock, VoidFromString(NotNull())).WillByDefault(Return());
-}
-
-// Tests the linkage of the IsNull matcher.
-TEST(LinkTest, TestMatcherIsNull) {
-  Mock mock;
-
-  ON_CALL(mock, VoidFromString(IsNull())).WillByDefault(Return());
-}
-
-// Tests the linkage of the Ref matcher.
-TEST(LinkTest, TestMatcherRef) {
-  Mock mock;
-  int a = 0;
-
-  ON_CALL(mock, VoidFromIntRef(Ref(a))).WillByDefault(Return());
-}
-
-// Tests the linkage of the TypedEq matcher.
-TEST(LinkTest, TestMatcherTypedEq) {
-  Mock mock;
-  long a = 0;
-
-  ON_CALL(mock, VoidFromIntRef(TypedEq<int&>(a))).WillByDefault(Return());
-}
-
-// Tests the linkage of the FloatEq, DoubleEq, NanSensitiveFloatEq and
-// NanSensitiveDoubleEq matchers.
-TEST(LinkTest, TestMatchersFloatingPoint) {
-  Mock mock;
-  float a = 0;
-
-  ON_CALL(mock, VoidFromFloat(FloatEq(a))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromDouble(DoubleEq(a))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromFloat(NanSensitiveFloatEq(a))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromDouble(NanSensitiveDoubleEq(a)))
-      .WillByDefault(Return());
-}
-
-// Tests the linkage of the ContainsRegex matcher.
-TEST(LinkTest, TestMatcherContainsRegex) {
-  Mock mock;
-
-  ON_CALL(mock, VoidFromString(ContainsRegex(".*"))).WillByDefault(Return());
-}
-
-// Tests the linkage of the MatchesRegex matcher.
-TEST(LinkTest, TestMatcherMatchesRegex) {
-  Mock mock;
-
-  ON_CALL(mock, VoidFromString(MatchesRegex(".*"))).WillByDefault(Return());
-}
-
-// Tests the linkage of the StartsWith, EndsWith, and HasSubstr matchers.
-TEST(LinkTest, TestMatchersSubstrings) {
-  Mock mock;
-
-  ON_CALL(mock, VoidFromString(StartsWith("a"))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromString(EndsWith("c"))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromString(HasSubstr("b"))).WillByDefault(Return());
-}
-
-// Tests the linkage of the StrEq, StrNe, StrCaseEq, and StrCaseNe matchers.
-TEST(LinkTest, TestMatchersStringEquality) {
-  Mock mock;
-  ON_CALL(mock, VoidFromString(StrEq("a"))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromString(StrNe("a"))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromString(StrCaseEq("a"))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromString(StrCaseNe("a"))).WillByDefault(Return());
-}
-
-// Tests the linkage of the ElementsAre matcher.
-TEST(LinkTest, TestMatcherElementsAre) {
-  Mock mock;
-
-  ON_CALL(mock, VoidFromVector(ElementsAre('a', _))).WillByDefault(Return());
-}
-
-// Tests the linkage of the ElementsAreArray matcher.
-TEST(LinkTest, TestMatcherElementsAreArray) {
-  Mock mock;
-  char arr[] = { 'a', 'b' };
-
-  ON_CALL(mock, VoidFromVector(ElementsAreArray(arr))).WillByDefault(Return());
-}
-
-// Tests the linkage of the ContainerEq matcher.
-TEST(LinkTest, TestMatcherContainerEq) {
-  Mock mock;
-  std::vector<int> v;
-
-  ON_CALL(mock, VoidFromVector(ContainerEq(v))).WillByDefault(Return());
-}
-
-// Tests the linkage of the Field matcher.
-TEST(LinkTest, TestMatcherField) {
-  FieldHelper helper(0);
-
-  Matcher<const FieldHelper&> m = Field(&FieldHelper::field_, Eq(0));
-  EXPECT_TRUE(m.Matches(helper));
-
-  Matcher<const FieldHelper*> m2 = Field(&FieldHelper::field_, Eq(0));
-  EXPECT_TRUE(m2.Matches(&helper));
-}
-
-// Tests the linkage of the Property matcher.
-TEST(LinkTest, TestMatcherProperty) {
-  FieldHelper helper(0);
-
-  Matcher<const FieldHelper&> m = Property(&FieldHelper::field, Eq(0));
-  EXPECT_TRUE(m.Matches(helper));
-
-  Matcher<const FieldHelper*> m2 = Property(&FieldHelper::field, Eq(0));
-  EXPECT_TRUE(m2.Matches(&helper));
-}
-
-// Tests the linkage of the ResultOf matcher.
-TEST(LinkTest, TestMatcherResultOf) {
-  Matcher<char*> m = ResultOf(&InvokeHelper::StaticIntFromString, Eq(1));
-  EXPECT_TRUE(m.Matches(NULL));
-}
-
-// Tests the linkage of the ResultOf matcher.
-TEST(LinkTest, TestMatcherPointee) {
-  int n = 1;
-
-  Matcher<int*> m = Pointee(Eq(1));
-  EXPECT_TRUE(m.Matches(&n));
-}
-
-// Tests the linkage of the Truly matcher.
-TEST(LinkTest, TestMatcherTruly) {
-  Matcher<const char*> m = Truly(&InvokeHelper::StaticBoolFromString);
-  EXPECT_TRUE(m.Matches(NULL));
-}
-
-// Tests the linkage of the AllOf matcher.
-TEST(LinkTest, TestMatcherAllOf) {
-  Matcher<int> m = AllOf(_, Eq(1));
-  EXPECT_TRUE(m.Matches(1));
-}
-
-// Tests the linkage of the AnyOf matcher.
-TEST(LinkTest, TestMatcherAnyOf) {
-  Matcher<int> m = AnyOf(_, Eq(1));
-  EXPECT_TRUE(m.Matches(1));
-}
-
-// Tests the linkage of the Not matcher.
-TEST(LinkTest, TestMatcherNot) {
-  Matcher<int> m = Not(_);
-  EXPECT_FALSE(m.Matches(1));
-}
-
-// Tests the linkage of the MatcherCast<T>() function.
-TEST(LinkTest, TestMatcherCast) {
-  Matcher<const char*> m = MatcherCast<const char*>(_);
-  EXPECT_TRUE(m.Matches(NULL));
-}
-
-#endif  // GMOCK_TEST_GMOCK_LINK_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test.py
deleted file mode 100755
index eced8a81..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test.py
+++ /dev/null
@@ -1,180 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-
-"""Tests the text output of Google C++ Mocking Framework.
-
-SYNOPSIS
-       gmock_output_test.py --build_dir=BUILD/DIR --gengolden
-         # where BUILD/DIR contains the built gmock_output_test_ file.
-       gmock_output_test.py --gengolden
-       gmock_output_test.py
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import re
-import sys
-
-import gmock_test_utils
-
-
-# The flag for generating the golden file
-GENGOLDEN_FLAG = '--gengolden'
-
-PROGRAM_PATH = gmock_test_utils.GetTestExecutablePath('gmock_output_test_')
-COMMAND = [PROGRAM_PATH, '--gtest_stack_trace_depth=0', '--gtest_print_time=0']
-GOLDEN_NAME = 'gmock_output_test_golden.txt'
-GOLDEN_PATH = os.path.join(gmock_test_utils.GetSourceDir(), GOLDEN_NAME)
-
-
-def ToUnixLineEnding(s):
-  """Changes all Windows/Mac line endings in s to UNIX line endings."""
-
-  return s.replace('\r\n', '\n').replace('\r', '\n')
-
-
-def RemoveReportHeaderAndFooter(output):
-  """Removes Google Test result report's header and footer from the output."""
-
-  output = re.sub(r'.*gtest_main.*\n', '', output)
-  output = re.sub(r'\[.*\d+ tests.*\n', '', output)
-  output = re.sub(r'\[.* test environment .*\n', '', output)
-  output = re.sub(r'\[=+\] \d+ tests .* ran.*', '', output)
-  output = re.sub(r'.* FAILED TESTS\n', '', output)
-  return output
-
-
-def RemoveLocations(output):
-  """Removes all file location info from a Google Test program's output.
-
-  Args:
-       output:  the output of a Google Test program.
-
-  Returns:
-       output with all file location info (in the form of
-       'DIRECTORY/FILE_NAME:LINE_NUMBER: 'or
-       'DIRECTORY\\FILE_NAME(LINE_NUMBER): ') replaced by
-       'FILE:#: '.
-  """
-
-  return re.sub(r'.*[/\\](.+)(\:\d+|\(\d+\))\:', 'FILE:#:', output)
-
-
-def NormalizeErrorMarker(output):
-  """Normalizes the error marker, which is different on Windows vs on Linux."""
-
-  return re.sub(r' error: ', ' Failure\n', output)
-
-
-def RemoveMemoryAddresses(output):
-  """Removes memory addresses from the test output."""
-
-  return re.sub(r'@\w+', '@0x#', output)
-
-
-def RemoveTestNamesOfLeakedMocks(output):
-  """Removes the test names of leaked mock objects from the test output."""
-
-  return re.sub(r'\(used in test .+\) ', '', output)
-
-
-def GetLeakyTests(output):
-  """Returns a list of test names that leak mock objects."""
-
-  # findall() returns a list of all matches of the regex in output.
-  # For example, if '(used in test FooTest.Bar)' is in output, the
-  # list will contain 'FooTest.Bar'.
-  return re.findall(r'\(used in test (.+)\)', output)
-
-
-def GetNormalizedOutputAndLeakyTests(output):
-  """Normalizes the output of gmock_output_test_.
-
-  Args:
-    output: The test output.
-
-  Returns:
-    A tuple (the normalized test output, the list of test names that have
-    leaked mocks).
-  """
-
-  output = ToUnixLineEnding(output)
-  output = RemoveReportHeaderAndFooter(output)
-  output = NormalizeErrorMarker(output)
-  output = RemoveLocations(output)
-  output = RemoveMemoryAddresses(output)
-  return (RemoveTestNamesOfLeakedMocks(output), GetLeakyTests(output))
-
-
-def GetShellCommandOutput(cmd):
-  """Runs a command in a sub-process, and returns its STDOUT in a string."""
-
-  return gmock_test_utils.Subprocess(cmd, capture_stderr=False).output
-
-
-def GetNormalizedCommandOutputAndLeakyTests(cmd):
-  """Runs a command and returns its normalized output and a list of leaky tests.
-
-  Args:
-    cmd:  the shell command.
-  """
-
-  # Disables exception pop-ups on Windows.
-  os.environ['GTEST_CATCH_EXCEPTIONS'] = '1'
-  return GetNormalizedOutputAndLeakyTests(GetShellCommandOutput(cmd))
-
-
-class GMockOutputTest(gmock_test_utils.TestCase):
-  def testOutput(self):
-    (output, leaky_tests) = GetNormalizedCommandOutputAndLeakyTests(COMMAND)
-    golden_file = open(GOLDEN_PATH, 'rb')
-    golden = golden_file.read()
-    golden_file.close()
-
-    # The normalized output should match the golden file.
-    self.assertEquals(golden, output)
-
-    # The raw output should contain 2 leaked mock object errors for
-    # test GMockOutputTest.CatchesLeakedMocks.
-    self.assertEquals(['GMockOutputTest.CatchesLeakedMocks',
-                       'GMockOutputTest.CatchesLeakedMocks'],
-                      leaky_tests)
-
-
-if __name__ == '__main__':
-  if sys.argv[1:] == [GENGOLDEN_FLAG]:
-    (output, _) = GetNormalizedCommandOutputAndLeakyTests(COMMAND)
-    golden_file = open(GOLDEN_PATH, 'wb')
-    golden_file.write(output)
-    golden_file.close()
-  else:
-    gmock_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_.cc
deleted file mode 100644
index 44cba342..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_.cc
+++ /dev/null
@@ -1,291 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Tests Google Mock's output in various scenarios.  This ensures that
-// Google Mock's messages are readable and useful.
-
-#include "gmock/gmock.h"
-
-#include <stdio.h>
-#include <string>
-
-#include "gtest/gtest.h"
-
-using testing::_;
-using testing::AnyNumber;
-using testing::Ge;
-using testing::InSequence;
-using testing::NaggyMock;
-using testing::Ref;
-using testing::Return;
-using testing::Sequence;
-
-class MockFoo {
- public:
-  MockFoo() {}
-
-  MOCK_METHOD3(Bar, char(const std::string& s, int i, double x));
-  MOCK_METHOD2(Bar2, bool(int x, int y));
-  MOCK_METHOD2(Bar3, void(int x, int y));
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
-};
-
-class GMockOutputTest : public testing::Test {
- protected:
-  NaggyMock<MockFoo> foo_;
-};
-
-TEST_F(GMockOutputTest, ExpectedCall) {
-  testing::GMOCK_FLAG(verbose) = "info";
-
-  EXPECT_CALL(foo_, Bar2(0, _));
-  foo_.Bar2(0, 0);  // Expected call
-
-  testing::GMOCK_FLAG(verbose) = "warning";
-}
-
-TEST_F(GMockOutputTest, ExpectedCallToVoidFunction) {
-  testing::GMOCK_FLAG(verbose) = "info";
-
-  EXPECT_CALL(foo_, Bar3(0, _));
-  foo_.Bar3(0, 0);  // Expected call
-
-  testing::GMOCK_FLAG(verbose) = "warning";
-}
-
-TEST_F(GMockOutputTest, ExplicitActionsRunOut) {
-  EXPECT_CALL(foo_, Bar2(_, _))
-      .Times(2)
-      .WillOnce(Return(false));
-  foo_.Bar2(2, 2);
-  foo_.Bar2(1, 1);  // Explicit actions in EXPECT_CALL run out.
-}
-
-TEST_F(GMockOutputTest, UnexpectedCall) {
-  EXPECT_CALL(foo_, Bar2(0, _));
-
-  foo_.Bar2(1, 0);  // Unexpected call
-  foo_.Bar2(0, 0);  // Expected call
-}
-
-TEST_F(GMockOutputTest, UnexpectedCallToVoidFunction) {
-  EXPECT_CALL(foo_, Bar3(0, _));
-
-  foo_.Bar3(1, 0);  // Unexpected call
-  foo_.Bar3(0, 0);  // Expected call
-}
-
-TEST_F(GMockOutputTest, ExcessiveCall) {
-  EXPECT_CALL(foo_, Bar2(0, _));
-
-  foo_.Bar2(0, 0);  // Expected call
-  foo_.Bar2(0, 1);  // Excessive call
-}
-
-TEST_F(GMockOutputTest, ExcessiveCallToVoidFunction) {
-  EXPECT_CALL(foo_, Bar3(0, _));
-
-  foo_.Bar3(0, 0);  // Expected call
-  foo_.Bar3(0, 1);  // Excessive call
-}
-
-TEST_F(GMockOutputTest, UninterestingCall) {
-  foo_.Bar2(0, 1);  // Uninteresting call
-}
-
-TEST_F(GMockOutputTest, UninterestingCallToVoidFunction) {
-  foo_.Bar3(0, 1);  // Uninteresting call
-}
-
-TEST_F(GMockOutputTest, RetiredExpectation) {
-  EXPECT_CALL(foo_, Bar2(_, _))
-      .RetiresOnSaturation();
-  EXPECT_CALL(foo_, Bar2(0, 0));
-
-  foo_.Bar2(1, 1);
-  foo_.Bar2(1, 1);  // Matches a retired expectation
-  foo_.Bar2(0, 0);
-}
-
-TEST_F(GMockOutputTest, UnsatisfiedPrerequisite) {
-  {
-    InSequence s;
-    EXPECT_CALL(foo_, Bar(_, 0, _));
-    EXPECT_CALL(foo_, Bar2(0, 0));
-    EXPECT_CALL(foo_, Bar2(1, _));
-  }
-
-  foo_.Bar2(1, 0);  // Has one immediate unsatisfied pre-requisite
-  foo_.Bar("Hi", 0, 0);
-  foo_.Bar2(0, 0);
-  foo_.Bar2(1, 0);
-}
-
-TEST_F(GMockOutputTest, UnsatisfiedPrerequisites) {
-  Sequence s1, s2;
-
-  EXPECT_CALL(foo_, Bar(_, 0, _))
-      .InSequence(s1);
-  EXPECT_CALL(foo_, Bar2(0, 0))
-      .InSequence(s2);
-  EXPECT_CALL(foo_, Bar2(1, _))
-      .InSequence(s1, s2);
-
-  foo_.Bar2(1, 0);  // Has two immediate unsatisfied pre-requisites
-  foo_.Bar("Hi", 0, 0);
-  foo_.Bar2(0, 0);
-  foo_.Bar2(1, 0);
-}
-
-TEST_F(GMockOutputTest, UnsatisfiedWith) {
-  EXPECT_CALL(foo_, Bar2(_, _)).With(Ge());
-}
-
-TEST_F(GMockOutputTest, UnsatisfiedExpectation) {
-  EXPECT_CALL(foo_, Bar(_, _, _));
-  EXPECT_CALL(foo_, Bar2(0, _))
-      .Times(2);
-
-  foo_.Bar2(0, 1);
-}
-
-TEST_F(GMockOutputTest, MismatchArguments) {
-  const std::string s = "Hi";
-  EXPECT_CALL(foo_, Bar(Ref(s), _, Ge(0)));
-
-  foo_.Bar("Ho", 0, -0.1);  // Mismatch arguments
-  foo_.Bar(s, 0, 0);
-}
-
-TEST_F(GMockOutputTest, MismatchWith) {
-  EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))
-      .With(Ge());
-
-  foo_.Bar2(2, 3);  // Mismatch With()
-  foo_.Bar2(2, 1);
-}
-
-TEST_F(GMockOutputTest, MismatchArgumentsAndWith) {
-  EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))
-      .With(Ge());
-
-  foo_.Bar2(1, 3);  // Mismatch arguments and mismatch With()
-  foo_.Bar2(2, 1);
-}
-
-TEST_F(GMockOutputTest, UnexpectedCallWithDefaultAction) {
-  ON_CALL(foo_, Bar2(_, _))
-      .WillByDefault(Return(true));   // Default action #1
-  ON_CALL(foo_, Bar2(1, _))
-      .WillByDefault(Return(false));  // Default action #2
-
-  EXPECT_CALL(foo_, Bar2(2, 2));
-  foo_.Bar2(1, 0);  // Unexpected call, takes default action #2.
-  foo_.Bar2(0, 0);  // Unexpected call, takes default action #1.
-  foo_.Bar2(2, 2);  // Expected call.
-}
-
-TEST_F(GMockOutputTest, ExcessiveCallWithDefaultAction) {
-  ON_CALL(foo_, Bar2(_, _))
-      .WillByDefault(Return(true));   // Default action #1
-  ON_CALL(foo_, Bar2(1, _))
-      .WillByDefault(Return(false));  // Default action #2
-
-  EXPECT_CALL(foo_, Bar2(2, 2));
-  EXPECT_CALL(foo_, Bar2(1, 1));
-
-  foo_.Bar2(2, 2);  // Expected call.
-  foo_.Bar2(2, 2);  // Excessive call, takes default action #1.
-  foo_.Bar2(1, 1);  // Expected call.
-  foo_.Bar2(1, 1);  // Excessive call, takes default action #2.
-}
-
-TEST_F(GMockOutputTest, UninterestingCallWithDefaultAction) {
-  ON_CALL(foo_, Bar2(_, _))
-      .WillByDefault(Return(true));   // Default action #1
-  ON_CALL(foo_, Bar2(1, _))
-      .WillByDefault(Return(false));  // Default action #2
-
-  foo_.Bar2(2, 2);  // Uninteresting call, takes default action #1.
-  foo_.Bar2(1, 1);  // Uninteresting call, takes default action #2.
-}
-
-TEST_F(GMockOutputTest, ExplicitActionsRunOutWithDefaultAction) {
-  ON_CALL(foo_, Bar2(_, _))
-      .WillByDefault(Return(true));   // Default action #1
-
-  EXPECT_CALL(foo_, Bar2(_, _))
-      .Times(2)
-      .WillOnce(Return(false));
-  foo_.Bar2(2, 2);
-  foo_.Bar2(1, 1);  // Explicit actions in EXPECT_CALL run out.
-}
-
-TEST_F(GMockOutputTest, CatchesLeakedMocks) {
-  MockFoo* foo1 = new MockFoo;
-  MockFoo* foo2 = new MockFoo;
-
-  // Invokes ON_CALL on foo1.
-  ON_CALL(*foo1, Bar(_, _, _)).WillByDefault(Return('a'));
-
-  // Invokes EXPECT_CALL on foo2.
-  EXPECT_CALL(*foo2, Bar2(_, _));
-  EXPECT_CALL(*foo2, Bar2(1, _));
-  EXPECT_CALL(*foo2, Bar3(_, _)).Times(AnyNumber());
-  foo2->Bar2(2, 1);
-  foo2->Bar2(1, 1);
-
-  // Both foo1 and foo2 are deliberately leaked.
-}
-
-void TestCatchesLeakedMocksInAdHocTests() {
-  MockFoo* foo = new MockFoo;
-
-  // Invokes EXPECT_CALL on foo.
-  EXPECT_CALL(*foo, Bar2(_, _));
-  foo->Bar2(2, 1);
-
-  // foo is deliberately leaked.
-}
-
-int main(int argc, char **argv) {
-  testing::InitGoogleMock(&argc, argv);
-
-  // Ensures that the tests pass no matter what value of
-  // --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
-  testing::GMOCK_FLAG(catch_leaked_mocks) = true;
-  testing::GMOCK_FLAG(verbose) = "warning";
-
-  TestCatchesLeakedMocksInAdHocTests();
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_golden.txt b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_golden.txt
deleted file mode 100644
index 689d5eeb..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_output_test_golden.txt
+++ /dev/null
@@ -1,310 +0,0 @@
-[ RUN      ] GMockOutputTest.ExpectedCall
-
-FILE:#: EXPECT_CALL(foo_, Bar2(0, _)) invoked
-Stack trace:
-
-FILE:#: Mock function call matches EXPECT_CALL(foo_, Bar2(0, _))...
-    Function call: Bar2(0, 0)
-          Returns: false
-Stack trace:
-[       OK ] GMockOutputTest.ExpectedCall
-[ RUN      ] GMockOutputTest.ExpectedCallToVoidFunction
-
-FILE:#: EXPECT_CALL(foo_, Bar3(0, _)) invoked
-Stack trace:
-
-FILE:#: Mock function call matches EXPECT_CALL(foo_, Bar3(0, _))...
-    Function call: Bar3(0, 0)
-Stack trace:
-[       OK ] GMockOutputTest.ExpectedCallToVoidFunction
-[ RUN      ] GMockOutputTest.ExplicitActionsRunOut
-
-GMOCK WARNING:
-FILE:#: Too few actions specified in EXPECT_CALL(foo_, Bar2(_, _))...
-Expected to be called twice, but has only 1 WillOnce().
-GMOCK WARNING:
-FILE:#: Actions ran out in EXPECT_CALL(foo_, Bar2(_, _))...
-Called 2 times, but only 1 WillOnce() is specified - returning default value.
-Stack trace:
-[       OK ] GMockOutputTest.ExplicitActionsRunOut
-[ RUN      ] GMockOutputTest.UnexpectedCall
-unknown file: Failure
-
-Unexpected mock function call - returning default value.
-    Function call: Bar2(1, 0)
-          Returns: false
-Google Mock tried the following 1 expectation, but it didn't match:
-
-FILE:#: EXPECT_CALL(foo_, Bar2(0, _))...
-  Expected arg #0: is equal to 0
-           Actual: 1
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] GMockOutputTest.UnexpectedCall
-[ RUN      ] GMockOutputTest.UnexpectedCallToVoidFunction
-unknown file: Failure
-
-Unexpected mock function call - returning directly.
-    Function call: Bar3(1, 0)
-Google Mock tried the following 1 expectation, but it didn't match:
-
-FILE:#: EXPECT_CALL(foo_, Bar3(0, _))...
-  Expected arg #0: is equal to 0
-           Actual: 1
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] GMockOutputTest.UnexpectedCallToVoidFunction
-[ RUN      ] GMockOutputTest.ExcessiveCall
-FILE:#: Failure
-Mock function called more times than expected - returning default value.
-    Function call: Bar2(0, 1)
-          Returns: false
-         Expected: to be called once
-           Actual: called twice - over-saturated and active
-[  FAILED  ] GMockOutputTest.ExcessiveCall
-[ RUN      ] GMockOutputTest.ExcessiveCallToVoidFunction
-FILE:#: Failure
-Mock function called more times than expected - returning directly.
-    Function call: Bar3(0, 1)
-         Expected: to be called once
-           Actual: called twice - over-saturated and active
-[  FAILED  ] GMockOutputTest.ExcessiveCallToVoidFunction
-[ RUN      ] GMockOutputTest.UninterestingCall
-
-GMOCK WARNING:
-Uninteresting mock function call - returning default value.
-    Function call: Bar2(0, 1)
-          Returns: false
-NOTE: 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/googlemock/docs/CookBook.md#knowing-when-to-expect for details.
-[       OK ] GMockOutputTest.UninterestingCall
-[ RUN      ] GMockOutputTest.UninterestingCallToVoidFunction
-
-GMOCK WARNING:
-Uninteresting mock function call - returning directly.
-    Function call: Bar3(0, 1)
-NOTE: 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/googlemock/docs/CookBook.md#knowing-when-to-expect for details.
-[       OK ] GMockOutputTest.UninterestingCallToVoidFunction
-[ RUN      ] GMockOutputTest.RetiredExpectation
-unknown file: Failure
-
-Unexpected mock function call - returning default value.
-    Function call: Bar2(1, 1)
-          Returns: false
-Google Mock tried the following 2 expectations, but none matched:
-
-FILE:#: tried expectation #0: EXPECT_CALL(foo_, Bar2(_, _))...
-         Expected: the expectation is active
-           Actual: it is retired
-         Expected: to be called once
-           Actual: called once - saturated and retired
-FILE:#: tried expectation #1: EXPECT_CALL(foo_, Bar2(0, 0))...
-  Expected arg #0: is equal to 0
-           Actual: 1
-  Expected arg #1: is equal to 0
-           Actual: 1
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] GMockOutputTest.RetiredExpectation
-[ RUN      ] GMockOutputTest.UnsatisfiedPrerequisite
-unknown file: Failure
-
-Unexpected mock function call - returning default value.
-    Function call: Bar2(1, 0)
-          Returns: false
-Google Mock tried the following 2 expectations, but none matched:
-
-FILE:#: tried expectation #0: EXPECT_CALL(foo_, Bar2(0, 0))...
-  Expected arg #0: is equal to 0
-           Actual: 1
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-FILE:#: tried expectation #1: EXPECT_CALL(foo_, Bar2(1, _))...
-         Expected: all pre-requisites are satisfied
-           Actual: the following immediate pre-requisites are not satisfied:
-FILE:#: pre-requisite #0
-                   (end of pre-requisites)
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] GMockOutputTest.UnsatisfiedPrerequisite
-[ RUN      ] GMockOutputTest.UnsatisfiedPrerequisites
-unknown file: Failure
-
-Unexpected mock function call - returning default value.
-    Function call: Bar2(1, 0)
-          Returns: false
-Google Mock tried the following 2 expectations, but none matched:
-
-FILE:#: tried expectation #0: EXPECT_CALL(foo_, Bar2(0, 0))...
-  Expected arg #0: is equal to 0
-           Actual: 1
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-FILE:#: tried expectation #1: EXPECT_CALL(foo_, Bar2(1, _))...
-         Expected: all pre-requisites are satisfied
-           Actual: the following immediate pre-requisites are not satisfied:
-FILE:#: pre-requisite #0
-FILE:#: pre-requisite #1
-                   (end of pre-requisites)
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] GMockOutputTest.UnsatisfiedPrerequisites
-[ RUN      ] GMockOutputTest.UnsatisfiedWith
-FILE:#: Failure
-Actual function call count doesn't match EXPECT_CALL(foo_, Bar2(_, _))...
-    Expected args: are a pair where the first >= the second
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] GMockOutputTest.UnsatisfiedWith
-[ RUN      ] GMockOutputTest.UnsatisfiedExpectation
-FILE:#: Failure
-Actual function call count doesn't match EXPECT_CALL(foo_, Bar2(0, _))...
-         Expected: to be called twice
-           Actual: called once - unsatisfied and active
-FILE:#: Failure
-Actual function call count doesn't match EXPECT_CALL(foo_, Bar(_, _, _))...
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] GMockOutputTest.UnsatisfiedExpectation
-[ RUN      ] GMockOutputTest.MismatchArguments
-unknown file: Failure
-
-Unexpected mock function call - returning default value.
-    Function call: Bar(@0x# "Ho", 0, -0.1)
-          Returns: '\0'
-Google Mock tried the following 1 expectation, but it didn't match:
-
-FILE:#: EXPECT_CALL(foo_, Bar(Ref(s), _, Ge(0)))...
-  Expected arg #0: references the variable @0x# "Hi"
-           Actual: "Ho", which is located @0x#
-  Expected arg #2: is >= 0
-           Actual: -0.1
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] GMockOutputTest.MismatchArguments
-[ RUN      ] GMockOutputTest.MismatchWith
-unknown file: Failure
-
-Unexpected mock function call - returning default value.
-    Function call: Bar2(2, 3)
-          Returns: false
-Google Mock tried the following 1 expectation, but it didn't match:
-
-FILE:#: EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))...
-    Expected args: are a pair where the first >= the second
-           Actual: don't match
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] GMockOutputTest.MismatchWith
-[ RUN      ] GMockOutputTest.MismatchArgumentsAndWith
-unknown file: Failure
-
-Unexpected mock function call - returning default value.
-    Function call: Bar2(1, 3)
-          Returns: false
-Google Mock tried the following 1 expectation, but it didn't match:
-
-FILE:#: EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))...
-  Expected arg #0: is >= 2
-           Actual: 1
-    Expected args: are a pair where the first >= the second
-           Actual: don't match
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] GMockOutputTest.MismatchArgumentsAndWith
-[ RUN      ] GMockOutputTest.UnexpectedCallWithDefaultAction
-unknown file: Failure
-
-Unexpected mock function call - taking default action specified at:
-FILE:#:
-    Function call: Bar2(1, 0)
-          Returns: false
-Google Mock tried the following 1 expectation, but it didn't match:
-
-FILE:#: EXPECT_CALL(foo_, Bar2(2, 2))...
-  Expected arg #0: is equal to 2
-           Actual: 1
-  Expected arg #1: is equal to 2
-           Actual: 0
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-unknown file: Failure
-
-Unexpected mock function call - taking default action specified at:
-FILE:#:
-    Function call: Bar2(0, 0)
-          Returns: true
-Google Mock tried the following 1 expectation, but it didn't match:
-
-FILE:#: EXPECT_CALL(foo_, Bar2(2, 2))...
-  Expected arg #0: is equal to 2
-           Actual: 0
-  Expected arg #1: is equal to 2
-           Actual: 0
-         Expected: to be called once
-           Actual: never called - unsatisfied and active
-[  FAILED  ] GMockOutputTest.UnexpectedCallWithDefaultAction
-[ RUN      ] GMockOutputTest.ExcessiveCallWithDefaultAction
-FILE:#: Failure
-Mock function called more times than expected - taking default action specified at:
-FILE:#:
-    Function call: Bar2(2, 2)
-          Returns: true
-         Expected: to be called once
-           Actual: called twice - over-saturated and active
-FILE:#: Failure
-Mock function called more times than expected - taking default action specified at:
-FILE:#:
-    Function call: Bar2(1, 1)
-          Returns: false
-         Expected: to be called once
-           Actual: called twice - over-saturated and active
-[  FAILED  ] GMockOutputTest.ExcessiveCallWithDefaultAction
-[ RUN      ] GMockOutputTest.UninterestingCallWithDefaultAction
-
-GMOCK WARNING:
-Uninteresting mock function call - taking default action specified at:
-FILE:#:
-    Function call: Bar2(2, 2)
-          Returns: true
-NOTE: 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/googlemock/docs/CookBook.md#knowing-when-to-expect for details.
-
-GMOCK WARNING:
-Uninteresting mock function call - taking default action specified at:
-FILE:#:
-    Function call: Bar2(1, 1)
-          Returns: false
-NOTE: 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/googlemock/docs/CookBook.md#knowing-when-to-expect for details.
-[       OK ] GMockOutputTest.UninterestingCallWithDefaultAction
-[ RUN      ] GMockOutputTest.ExplicitActionsRunOutWithDefaultAction
-
-GMOCK WARNING:
-FILE:#: Too few actions specified in EXPECT_CALL(foo_, Bar2(_, _))...
-Expected to be called twice, but has only 1 WillOnce().
-GMOCK WARNING:
-FILE:#: Actions ran out in EXPECT_CALL(foo_, Bar2(_, _))...
-Called 2 times, but only 1 WillOnce() is specified - taking default action specified at:
-FILE:#:
-Stack trace:
-[       OK ] GMockOutputTest.ExplicitActionsRunOutWithDefaultAction
-[ RUN      ] GMockOutputTest.CatchesLeakedMocks
-[       OK ] GMockOutputTest.CatchesLeakedMocks
-[  FAILED  ] GMockOutputTest.UnexpectedCall
-[  FAILED  ] GMockOutputTest.UnexpectedCallToVoidFunction
-[  FAILED  ] GMockOutputTest.ExcessiveCall
-[  FAILED  ] GMockOutputTest.ExcessiveCallToVoidFunction
-[  FAILED  ] GMockOutputTest.RetiredExpectation
-[  FAILED  ] GMockOutputTest.UnsatisfiedPrerequisite
-[  FAILED  ] GMockOutputTest.UnsatisfiedPrerequisites
-[  FAILED  ] GMockOutputTest.UnsatisfiedWith
-[  FAILED  ] GMockOutputTest.UnsatisfiedExpectation
-[  FAILED  ] GMockOutputTest.MismatchArguments
-[  FAILED  ] GMockOutputTest.MismatchWith
-[  FAILED  ] GMockOutputTest.MismatchArgumentsAndWith
-[  FAILED  ] GMockOutputTest.UnexpectedCallWithDefaultAction
-[  FAILED  ] GMockOutputTest.ExcessiveCallWithDefaultAction
-
-
-FILE:#: ERROR: this mock object should be deleted but never is. Its address is @0x#.
-FILE:#: ERROR: this mock object should be deleted but never is. Its address is @0x#.
-FILE:#: ERROR: this mock object should be deleted but never is. Its address is @0x#.
-ERROR: 3 leaked mock objects found at program exit.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_stress_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_stress_test.cc
deleted file mode 100644
index 0e97aeed..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_stress_test.cc
+++ /dev/null
@@ -1,322 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Tests that Google Mock constructs can be used in a large number of
-// threads concurrently.
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-namespace testing {
-namespace {
-
-// From <gtest/internal/gtest-port.h>.
-using ::testing::internal::ThreadWithParam;
-
-// The maximum number of test threads (not including helper threads)
-// to create.
-const int kMaxTestThreads = 50;
-
-// How many times to repeat a task in a test thread.
-const int kRepeat = 50;
-
-class MockFoo {
- public:
-  MOCK_METHOD1(Bar, int(int n));  // NOLINT
-  MOCK_METHOD2(Baz, char(const char* s1, const internal::string& s2));  // NOLINT
-};
-
-// Helper for waiting for the given thread to finish and then deleting it.
-template <typename T>
-void JoinAndDelete(ThreadWithParam<T>* t) {
-  t->Join();
-  delete t;
-}
-
-using internal::linked_ptr;
-
-// Helper classes for testing using linked_ptr concurrently.
-
-class Base {
- public:
-  explicit Base(int a_x) : x_(a_x) {}
-  virtual ~Base() {}
-  int x() const { return x_; }
- private:
-  int x_;
-};
-
-class Derived1 : public Base {
- public:
-  Derived1(int a_x, int a_y) : Base(a_x), y_(a_y) {}
-  int y() const { return y_; }
- private:
-  int y_;
-};
-
-class Derived2 : public Base {
- public:
-  Derived2(int a_x, int a_z) : Base(a_x), z_(a_z) {}
-  int z() const { return z_; }
- private:
-  int z_;
-};
-
-linked_ptr<Derived1> pointer1(new Derived1(1, 2));
-linked_ptr<Derived2> pointer2(new Derived2(3, 4));
-
-struct Dummy {};
-
-// Tests that we can copy from a linked_ptr and read it concurrently.
-void TestConcurrentCopyAndReadLinkedPtr(Dummy /* dummy */) {
-  // Reads pointer1 and pointer2 while they are being copied from in
-  // another thread.
-  EXPECT_EQ(1, pointer1->x());
-  EXPECT_EQ(2, pointer1->y());
-  EXPECT_EQ(3, pointer2->x());
-  EXPECT_EQ(4, pointer2->z());
-
-  // Copies from pointer1.
-  linked_ptr<Derived1> p1(pointer1);
-  EXPECT_EQ(1, p1->x());
-  EXPECT_EQ(2, p1->y());
-
-  // Assigns from pointer2 where the LHS was empty.
-  linked_ptr<Base> p2;
-  p2 = pointer1;
-  EXPECT_EQ(1, p2->x());
-
-  // Assigns from pointer2 where the LHS was not empty.
-  p2 = pointer2;
-  EXPECT_EQ(3, p2->x());
-}
-
-const linked_ptr<Derived1> p0(new Derived1(1, 2));
-
-// Tests that we can concurrently modify two linked_ptrs that point to
-// the same object.
-void TestConcurrentWriteToEqualLinkedPtr(Dummy /* dummy */) {
-  // p1 and p2 point to the same, shared thing.  One thread resets p1.
-  // Another thread assigns to p2.  This will cause the same
-  // underlying "ring" to be updated concurrently.
-  linked_ptr<Derived1> p1(p0);
-  linked_ptr<Derived1> p2(p0);
-
-  EXPECT_EQ(1, p1->x());
-  EXPECT_EQ(2, p1->y());
-
-  EXPECT_EQ(1, p2->x());
-  EXPECT_EQ(2, p2->y());
-
-  p1.reset();
-  p2 = p0;
-
-  EXPECT_EQ(1, p2->x());
-  EXPECT_EQ(2, p2->y());
-}
-
-// Tests that different mock objects can be used in their respective
-// threads.  This should generate no Google Test failure.
-void TestConcurrentMockObjects(Dummy /* dummy */) {
-  // Creates a mock and does some typical operations on it.
-  MockFoo foo;
-  ON_CALL(foo, Bar(_))
-      .WillByDefault(Return(1));
-  ON_CALL(foo, Baz(_, _))
-      .WillByDefault(Return('b'));
-  ON_CALL(foo, Baz(_, "you"))
-      .WillByDefault(Return('a'));
-
-  EXPECT_CALL(foo, Bar(0))
-      .Times(AtMost(3));
-  EXPECT_CALL(foo, Baz(_, _));
-  EXPECT_CALL(foo, Baz("hi", "you"))
-      .WillOnce(Return('z'))
-      .WillRepeatedly(DoDefault());
-
-  EXPECT_EQ(1, foo.Bar(0));
-  EXPECT_EQ(1, foo.Bar(0));
-  EXPECT_EQ('z', foo.Baz("hi", "you"));
-  EXPECT_EQ('a', foo.Baz("hi", "you"));
-  EXPECT_EQ('b', foo.Baz("hi", "me"));
-}
-
-// Tests invoking methods of the same mock object in multiple threads.
-
-struct Helper1Param {
-  MockFoo* mock_foo;
-  int* count;
-};
-
-void Helper1(Helper1Param param) {
-  for (int i = 0; i < kRepeat; i++) {
-    const char ch = param.mock_foo->Baz("a", "b");
-    if (ch == 'a') {
-      // It was an expected call.
-      (*param.count)++;
-    } else {
-      // It was an excessive call.
-      EXPECT_EQ('\0', ch);
-    }
-
-    // An unexpected call.
-    EXPECT_EQ('\0', param.mock_foo->Baz("x", "y")) << "Expected failure.";
-
-    // An uninteresting call.
-    EXPECT_EQ(1, param.mock_foo->Bar(5));
-  }
-}
-
-// This should generate 3*kRepeat + 1 failures in total.
-void TestConcurrentCallsOnSameObject(Dummy /* dummy */) {
-  MockFoo foo;
-
-  ON_CALL(foo, Bar(_))
-      .WillByDefault(Return(1));
-  EXPECT_CALL(foo, Baz(_, "b"))
-      .Times(kRepeat)
-      .WillRepeatedly(Return('a'));
-  EXPECT_CALL(foo, Baz(_, "c"));  // Expected to be unsatisfied.
-
-  // This chunk of code should generate kRepeat failures about
-  // excessive calls, and 2*kRepeat failures about unexpected calls.
-  int count1 = 0;
-  const Helper1Param param = { &foo, &count1 };
-  ThreadWithParam<Helper1Param>* const t =
-      new ThreadWithParam<Helper1Param>(Helper1, param, NULL);
-
-  int count2 = 0;
-  const Helper1Param param2 = { &foo, &count2 };
-  Helper1(param2);
-  JoinAndDelete(t);
-
-  EXPECT_EQ(kRepeat, count1 + count2);
-
-  // foo's destructor should generate one failure about unsatisfied
-  // expectation.
-}
-
-// Tests using the same mock object in multiple threads when the
-// expectations are partially ordered.
-
-void Helper2(MockFoo* foo) {
-  for (int i = 0; i < kRepeat; i++) {
-    foo->Bar(2);
-    foo->Bar(3);
-  }
-}
-
-// This should generate no Google Test failures.
-void TestPartiallyOrderedExpectationsWithThreads(Dummy /* dummy */) {
-  MockFoo foo;
-  Sequence s1, s2;
-
-  {
-    InSequence dummy;
-    EXPECT_CALL(foo, Bar(0));
-    EXPECT_CALL(foo, Bar(1))
-        .InSequence(s1, s2);
-  }
-
-  EXPECT_CALL(foo, Bar(2))
-      .Times(2*kRepeat)
-      .InSequence(s1)
-      .RetiresOnSaturation();
-  EXPECT_CALL(foo, Bar(3))
-      .Times(2*kRepeat)
-      .InSequence(s2);
-
-  {
-    InSequence dummy;
-    EXPECT_CALL(foo, Bar(2))
-        .InSequence(s1, s2);
-    EXPECT_CALL(foo, Bar(4));
-  }
-
-  foo.Bar(0);
-  foo.Bar(1);
-
-  ThreadWithParam<MockFoo*>* const t =
-      new ThreadWithParam<MockFoo*>(Helper2, &foo, NULL);
-  Helper2(&foo);
-  JoinAndDelete(t);
-
-  foo.Bar(2);
-  foo.Bar(4);
-}
-
-// Tests using Google Mock constructs in many threads concurrently.
-TEST(StressTest, CanUseGMockWithThreads) {
-  void (*test_routines[])(Dummy dummy) = {
-    &TestConcurrentCopyAndReadLinkedPtr,
-    &TestConcurrentWriteToEqualLinkedPtr,
-    &TestConcurrentMockObjects,
-    &TestConcurrentCallsOnSameObject,
-    &TestPartiallyOrderedExpectationsWithThreads,
-  };
-
-  const int kRoutines = sizeof(test_routines)/sizeof(test_routines[0]);
-  const int kCopiesOfEachRoutine = kMaxTestThreads / kRoutines;
-  const int kTestThreads = kCopiesOfEachRoutine * kRoutines;
-  ThreadWithParam<Dummy>* threads[kTestThreads] = {};
-  for (int i = 0; i < kTestThreads; i++) {
-    // Creates a thread to run the test function.
-    threads[i] =
-        new ThreadWithParam<Dummy>(test_routines[i % kRoutines], Dummy(), NULL);
-    GTEST_LOG_(INFO) << "Thread #" << i << " running . . .";
-  }
-
-  // At this point, we have many threads running.
-  for (int i = 0; i < kTestThreads; i++) {
-    JoinAndDelete(threads[i]);
-  }
-
-  // Ensures that the correct number of failures have been reported.
-  const TestInfo* const info = UnitTest::GetInstance()->current_test_info();
-  const TestResult& result = *info->result();
-  const int kExpectedFailures = (3*kRepeat + 1)*kCopiesOfEachRoutine;
-  GTEST_CHECK_(kExpectedFailures == result.total_part_count())
-      << "Expected " << kExpectedFailures << " failures, but got "
-      << result.total_part_count();
-}
-
-}  // namespace
-}  // namespace testing
-
-int main(int argc, char **argv) {
-  testing::InitGoogleMock(&argc, argv);
-
-  const int exit_code = RUN_ALL_TESTS();  // Expected to fail.
-  GTEST_CHECK_(exit_code != 0) << "RUN_ALL_TESTS() did not fail as expected";
-
-  printf("\nPASS\n");
-  return 0;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test.cc b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test.cc
deleted file mode 100644
index d8d0c57b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test.cc
+++ /dev/null
@@ -1,220 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests code in gmock.cc.
-
-#include "gmock/gmock.h"
-
-#include <string>
-#include "gtest/gtest.h"
-
-#if !defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-
-using testing::GMOCK_FLAG(verbose);
-using testing::InitGoogleMock;
-
-// Verifies that calling InitGoogleMock() on argv results in new_argv,
-// and the gmock_verbose flag's value is set to expected_gmock_verbose.
-template <typename Char, int M, int N>
-void TestInitGoogleMock(const Char* (&argv)[M], const Char* (&new_argv)[N],
-                        const ::std::string& expected_gmock_verbose) {
-  const ::std::string old_verbose = GMOCK_FLAG(verbose);
-
-  int argc = M;
-  InitGoogleMock(&argc, const_cast<Char**>(argv));
-  ASSERT_EQ(N, argc) << "The new argv has wrong number of elements.";
-
-  for (int i = 0; i < N; i++) {
-    EXPECT_STREQ(new_argv[i], argv[i]);
-  }
-
-  EXPECT_EQ(expected_gmock_verbose, GMOCK_FLAG(verbose).c_str());
-  GMOCK_FLAG(verbose) = old_verbose;  // Restores the gmock_verbose flag.
-}
-
-TEST(InitGoogleMockTest, ParsesInvalidCommandLine) {
-  const char* argv[] = {
-    NULL
-  };
-
-  const char* new_argv[] = {
-    NULL
-  };
-
-  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
-}
-
-TEST(InitGoogleMockTest, ParsesEmptyCommandLine) {
-  const char* argv[] = {
-    "foo.exe",
-    NULL
-  };
-
-  const char* new_argv[] = {
-    "foo.exe",
-    NULL
-  };
-
-  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
-}
-
-TEST(InitGoogleMockTest, ParsesSingleFlag) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gmock_verbose=info",
-    NULL
-  };
-
-  const char* new_argv[] = {
-    "foo.exe",
-    NULL
-  };
-
-  TestInitGoogleMock(argv, new_argv, "info");
-}
-
-TEST(InitGoogleMockTest, ParsesUnrecognizedFlag) {
-  const char* argv[] = {
-    "foo.exe",
-    "--non_gmock_flag=blah",
-    NULL
-  };
-
-  const char* new_argv[] = {
-    "foo.exe",
-    "--non_gmock_flag=blah",
-    NULL
-  };
-
-  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
-}
-
-TEST(InitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
-  const char* argv[] = {
-    "foo.exe",
-    "--non_gmock_flag=blah",
-    "--gmock_verbose=error",
-    NULL
-  };
-
-  const char* new_argv[] = {
-    "foo.exe",
-    "--non_gmock_flag=blah",
-    NULL
-  };
-
-  TestInitGoogleMock(argv, new_argv, "error");
-}
-
-TEST(WideInitGoogleMockTest, ParsesInvalidCommandLine) {
-  const wchar_t* argv[] = {
-    NULL
-  };
-
-  const wchar_t* new_argv[] = {
-    NULL
-  };
-
-  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
-}
-
-TEST(WideInitGoogleMockTest, ParsesEmptyCommandLine) {
-  const wchar_t* argv[] = {
-    L"foo.exe",
-    NULL
-  };
-
-  const wchar_t* new_argv[] = {
-    L"foo.exe",
-    NULL
-  };
-
-  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
-}
-
-TEST(WideInitGoogleMockTest, ParsesSingleFlag) {
-  const wchar_t* argv[] = {
-    L"foo.exe",
-    L"--gmock_verbose=info",
-    NULL
-  };
-
-  const wchar_t* new_argv[] = {
-    L"foo.exe",
-    NULL
-  };
-
-  TestInitGoogleMock(argv, new_argv, "info");
-}
-
-TEST(WideInitGoogleMockTest, ParsesUnrecognizedFlag) {
-  const wchar_t* argv[] = {
-    L"foo.exe",
-    L"--non_gmock_flag=blah",
-    NULL
-  };
-
-  const wchar_t* new_argv[] = {
-    L"foo.exe",
-    L"--non_gmock_flag=blah",
-    NULL
-  };
-
-  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
-}
-
-TEST(WideInitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
-  const wchar_t* argv[] = {
-    L"foo.exe",
-    L"--non_gmock_flag=blah",
-    L"--gmock_verbose=error",
-    NULL
-  };
-
-  const wchar_t* new_argv[] = {
-    L"foo.exe",
-    L"--non_gmock_flag=blah",
-    NULL
-  };
-
-  TestInitGoogleMock(argv, new_argv, "error");
-}
-
-#endif  // !defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-
-// Makes sure Google Mock flags can be accessed in code.
-TEST(FlagTest, IsAccessibleInCode) {
-  bool dummy = testing::GMOCK_FLAG(catch_leaked_mocks) &&
-      testing::GMOCK_FLAG(verbose) == "";
-  (void)dummy;  // Avoids the "unused local variable" warning.
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test_utils.py b/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test_utils.py
deleted file mode 100755
index 20e3d3d4..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googlemock/test/gmock_test_utils.py
+++ /dev/null
@@ -1,112 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2006, 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.
-
-"""Unit test utilities for Google C++ Mocking Framework."""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import sys
-
-
-# Determines path to gtest_test_utils and imports it.
-SCRIPT_DIR = os.path.dirname(__file__) or '.'
-
-# isdir resolves symbolic links.
-gtest_tests_util_dir = os.path.join(SCRIPT_DIR, '../gtest/test')
-if os.path.isdir(gtest_tests_util_dir):
-  GTEST_TESTS_UTIL_DIR = gtest_tests_util_dir
-else:
-  GTEST_TESTS_UTIL_DIR = os.path.join(SCRIPT_DIR, '../../gtest/test')
-
-sys.path.append(GTEST_TESTS_UTIL_DIR)
-import gtest_test_utils  # pylint: disable-msg=C6204
-
-
-def GetSourceDir():
-  """Returns the absolute path of the directory where the .py files are."""
-
-  return gtest_test_utils.GetSourceDir()
-
-
-def GetTestExecutablePath(executable_name):
-  """Returns the absolute path of the test binary given its name.
-
-  The function will print a message and abort the program if the resulting file
-  doesn't exist.
-
-  Args:
-    executable_name: name of the test binary that the test script runs.
-
-  Returns:
-    The absolute path of the test binary.
-  """
-
-  return gtest_test_utils.GetTestExecutablePath(executable_name)
-
-
-def GetExitStatus(exit_code):
-  """Returns the argument to exit(), or -1 if exit() wasn't called.
-
-  Args:
-    exit_code: the result value of os.system(command).
-  """
-
-  if os.name == 'nt':
-    # On Windows, os.WEXITSTATUS() doesn't work and os.system() returns
-    # the argument to exit() directly.
-    return exit_code
-  else:
-    # On Unix, os.WEXITSTATUS() must be used to extract the exit status
-    # from the result of os.system().
-    if os.WIFEXITED(exit_code):
-      return os.WEXITSTATUS(exit_code)
-    else:
-      return -1
-
-
-# Suppresses the "Invalid const name" lint complaint
-# pylint: disable-msg=C6409
-
-# Exposes utilities from gtest_test_utils.
-Subprocess = gtest_test_utils.Subprocess
-TestCase = gtest_test_utils.TestCase
-environ = gtest_test_utils.environ
-SetEnvVar = gtest_test_utils.SetEnvVar
-PREMATURE_EXIT_FILE_ENV_VAR = gtest_test_utils.PREMATURE_EXIT_FILE_ENV_VAR
-
-# pylint: enable-msg=C6409
-
-
-def Main():
-  """Runs the unit test."""
-
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/.gitignore b/week4/softwareEng_9_4/vendor/googletest/googletest/.gitignore
deleted file mode 100644
index 4b7be4b9..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-# python
-*.pyc
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/CHANGES b/week4/softwareEng_9_4/vendor/googletest/googletest/CHANGES
deleted file mode 100644
index 05521324..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/CHANGES
+++ /dev/null
@@ -1,157 +0,0 @@
-Changes for 1.7.0:
-
-* New feature: death tests are supported on OpenBSD and in iOS
-  simulator now.
-* New feature: Google Test now implements a protocol to allow
-  a test runner to detect that a test program has exited
-  prematurely and report it as a failure (before it would be
-  falsely reported as a success if the exit code is 0).
-* New feature: Test::RecordProperty() can now be used outside of the
-  lifespan of a test method, in which case it will be attributed to
-  the current test case or the test program in the XML report.
-* New feature (potentially breaking): --gtest_list_tests now prints
-  the type parameters and value parameters for each test.
-* Improvement: char pointers and char arrays are now escaped properly
-  in failure messages.
-* Improvement: failure summary in XML reports now includes file and
-  line information.
-* Improvement: the <testsuites> XML element now has a timestamp attribute.
-* Improvement: When --gtest_filter is specified, XML report now doesn't
-  contain information about tests that are filtered out.
-* Fixed the bug where long --gtest_filter flag values are truncated in
-  death tests.
-* Potentially breaking change: RUN_ALL_TESTS() is now implemented as a
-  function instead of a macro in order to work better with Clang.
-* Compatibility fixes with C++ 11 and various platforms.
-* Bug/warning fixes.
-
-Changes for 1.6.0:
-
-* New feature: ADD_FAILURE_AT() for reporting a test failure at the
-  given source location -- useful for writing testing utilities.
-* New feature: the universal value printer is moved from Google Mock
-  to Google Test.
-* New feature: type parameters and value parameters are reported in
-  the XML report now.
-* A gtest_disable_pthreads CMake option.
-* Colored output works in GNU Screen sessions now.
-* Parameters of value-parameterized tests are now printed in the
-  textual output.
-* Failures from ad hoc test assertions run before RUN_ALL_TESTS() are
-  now correctly reported.
-* Arguments of ASSERT_XY and EXPECT_XY no longer need to support << to
-  ostream.
-* More complete handling of exceptions.
-* GTEST_ASSERT_XY can be used instead of ASSERT_XY in case the latter
-  name is already used by another library.
-* --gtest_catch_exceptions is now true by default, allowing a test
-  program to continue after an exception is thrown.
-* Value-parameterized test fixtures can now derive from Test and
-  WithParamInterface<T> separately, easing conversion of legacy tests.
-* Death test messages are clearly marked to make them more
-  distinguishable from other messages.
-* Compatibility fixes for Android, Google Native Client, MinGW, HP UX,
-  PowerPC, Lucid autotools, libCStd, Sun C++, Borland C++ Builder (Code Gear),
-  IBM XL C++ (Visual Age C++), and C++0x.
-* Bug fixes and implementation clean-ups.
-* Potentially incompatible changes: disables the harmful 'make install'
-  command in autotools.
-
-Changes for 1.5.0:
-
- * New feature: assertions can be safely called in multiple threads
-   where the pthreads library is available.
- * New feature: predicates used inside EXPECT_TRUE() and friends
-   can now generate custom failure messages.
- * New feature: Google Test can now be compiled as a DLL.
- * New feature: fused source files are included.
- * New feature: prints help when encountering unrecognized Google Test flags.
- * Experimental feature: CMake build script (requires CMake 2.6.4+).
- * Experimental feature: the Pump script for meta programming.
- * double values streamed to an assertion are printed with enough precision
-   to differentiate any two different values.
- * Google Test now works on Solaris and AIX.
- * Build and test script improvements.
- * Bug fixes and implementation clean-ups.
-
- Potentially breaking changes:
-
- * Stopped supporting VC++ 7.1 with exceptions disabled.
- * Dropped support for 'make install'.
-
-Changes for 1.4.0:
-
- * New feature: the event listener API
- * New feature: test shuffling
- * New feature: the XML report format is closer to junitreport and can
-   be parsed by Hudson now.
- * New feature: when a test runs under Visual Studio, its failures are
-   integrated in the IDE.
- * New feature: /MD(d) versions of VC++ projects.
- * New feature: elapsed time for the tests is printed by default.
- * New feature: comes with a TR1 tuple implementation such that Boost
-   is no longer needed for Combine().
- * New feature: EXPECT_DEATH_IF_SUPPORTED macro and friends.
- * New feature: the Xcode project can now produce static gtest
-   libraries in addition to a framework.
- * Compatibility fixes for Solaris, Cygwin, minGW, Windows Mobile,
-   Symbian, gcc, and C++Builder.
- * Bug fixes and implementation clean-ups.
-
-Changes for 1.3.0:
-
- * New feature: death tests on Windows, Cygwin, and Mac.
- * New feature: ability to use Google Test assertions in other testing
-   frameworks.
- * New feature: ability to run disabled test via
-   --gtest_also_run_disabled_tests.
- * New feature: the --help flag for printing the usage.
- * New feature: access to Google Test flag values in user code.
- * New feature: a script that packs Google Test into one .h and one
-   .cc file for easy deployment.
- * New feature: support for distributing test functions to multiple
-   machines (requires support from the test runner).
- * Bug fixes and implementation clean-ups.
-
-Changes for 1.2.1:
-
- * Compatibility fixes for Linux IA-64 and IBM z/OS.
- * Added support for using Boost and other TR1 implementations.
- * Changes to the build scripts to support upcoming release of Google C++
-   Mocking Framework.
- * Added Makefile to the distribution package.
- * Improved build instructions in README.
-
-Changes for 1.2.0:
-
- * New feature: value-parameterized tests.
- * New feature: the ASSERT/EXPECT_(NON)FATAL_FAILURE(_ON_ALL_THREADS)
-   macros.
- * Changed the XML report format to match JUnit/Ant's.
- * Added tests to the Xcode project.
- * Added scons/SConscript for building with SCons.
- * Added src/gtest-all.cc for building Google Test from a single file.
- * Fixed compatibility with Solaris and z/OS.
- * Enabled running Python tests on systems with python 2.3 installed,
-   e.g. Mac OS X 10.4.
- * Bug fixes.
-
-Changes for 1.1.0:
-
- * New feature: type-parameterized tests.
- * New feature: exception assertions.
- * New feature: printing elapsed time of tests.
- * Improved the robustness of death tests.
- * Added an Xcode project and samples.
- * Adjusted the output format on Windows to be understandable by Visual Studio.
- * Minor bug fixes.
-
-Changes for 1.0.1:
-
- * Added project files for Visual Studio 7.1.
- * Fixed issues with compiling on Mac OS X.
- * Fixed issues with compiling on Cygwin.
-
-Changes for 1.0.0:
-
- * Initial Open Source release of Google Test
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/CMakeLists.txt b/week4/softwareEng_9_4/vendor/googletest/googletest/CMakeLists.txt
deleted file mode 100644
index 621d0f04..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/CMakeLists.txt
+++ /dev/null
@@ -1,286 +0,0 @@
-########################################################################
-# CMake build script for Google Test.
-#
-# To run the tests for Google Test itself on Linux, use 'make test' or
-# ctest.  You can select which tests to run using 'ctest -R regex'.
-# For more options, run 'ctest --help'.
-
-# BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to
-# make it prominent in the GUI.
-option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF)
-
-# When other libraries are using a shared version of runtime libraries,
-# Google Test also has to use one.
-option(
-  gtest_force_shared_crt
-  "Use shared (DLL) run-time lib even when Google Test is built as static lib."
-  OFF)
-
-option(gtest_build_tests "Build all of gtest's own tests." OFF)
-
-option(gtest_build_samples "Build gtest's sample programs." OFF)
-
-option(gtest_disable_pthreads "Disable uses of pthreads in gtest." OFF)
-
-option(
-  gtest_hide_internal_symbols
-  "Build gtest with internal symbols hidden in shared libraries."
-  OFF)
-
-# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build().
-include(cmake/hermetic_build.cmake OPTIONAL)
-
-if (COMMAND pre_project_set_up_hermetic_build)
-  pre_project_set_up_hermetic_build()
-endif()
-
-########################################################################
-#
-# Project-wide settings
-
-# Name of the project.
-#
-# CMake files in this project can refer to the root source directory
-# as ${gtest_SOURCE_DIR} and to the root binary directory as
-# ${gtest_BINARY_DIR}.
-# Language "C" is required for find_package(Threads).
-project(gtest CXX C)
-cmake_minimum_required(VERSION 2.6.2)
-
-if (COMMAND set_up_hermetic_build)
-  set_up_hermetic_build()
-endif()
-
-if (gtest_hide_internal_symbols)
-  set(CMAKE_CXX_VISIBILITY_PRESET hidden)
-  set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
-endif()
-
-# Define helper functions and macros used by Google Test.
-include(cmake/internal_utils.cmake)
-
-config_compiler_and_linker()  # Defined in internal_utils.cmake.
-
-# Where Google Test's .h files can be found.
-include_directories(
-  ${gtest_SOURCE_DIR}/include
-  ${gtest_SOURCE_DIR})
-
-# Where Google Test's libraries can be found.
-link_directories(${gtest_BINARY_DIR}/src)
-
-# Summary of tuple support for Microsoft Visual Studio:
-# Compiler    version(MS)  version(cmake)  Support
-# ----------  -----------  --------------  -----------------------------
-# <= VS 2010  <= 10        <= 1600         Use Google Tests's own tuple.
-# VS 2012     11           1700            std::tr1::tuple + _VARIADIC_MAX=10
-# VS 2013     12           1800            std::tr1::tuple
-if (MSVC AND MSVC_VERSION EQUAL 1700)
-  add_definitions(/D _VARIADIC_MAX=10)
-endif()
-
-########################################################################
-#
-# Defines the gtest & gtest_main libraries.  User tests should link
-# with one of them.
-
-# Google Test libraries.  We build them using more strict warnings than what
-# are used for other targets, to ensure that gtest can be compiled by a user
-# aggressive about warnings.
-cxx_library(gtest "${cxx_strict}" src/gtest-all.cc)
-cxx_library(gtest_main "${cxx_strict}" src/gtest_main.cc)
-target_link_libraries(gtest_main gtest)
-
-# If the CMake version supports it, attach header directory information
-# to the targets for when we are part of a parent build (ie being pulled
-# in via add_subdirectory() rather than being a standalone build).
-if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
-  target_include_directories(gtest      INTERFACE "${gtest_SOURCE_DIR}/include")
-  target_include_directories(gtest_main INTERFACE "${gtest_SOURCE_DIR}/include")
-endif()
-
-########################################################################
-#
-# Install rules
-install(TARGETS gtest gtest_main
-  DESTINATION lib)
-install(DIRECTORY ${gtest_SOURCE_DIR}/include/gtest
-  DESTINATION include)
-
-########################################################################
-#
-# Samples on how to link user tests with gtest or gtest_main.
-#
-# They are not built by default.  To build them, set the
-# gtest_build_samples option to ON.  You can do it by running ccmake
-# or specifying the -Dgtest_build_samples=ON flag when running cmake.
-
-if (gtest_build_samples)
-  cxx_executable(sample1_unittest samples gtest_main samples/sample1.cc)
-  cxx_executable(sample2_unittest samples gtest_main samples/sample2.cc)
-  cxx_executable(sample3_unittest samples gtest_main)
-  cxx_executable(sample4_unittest samples gtest_main samples/sample4.cc)
-  cxx_executable(sample5_unittest samples gtest_main samples/sample1.cc)
-  cxx_executable(sample6_unittest samples gtest_main)
-  cxx_executable(sample7_unittest samples gtest_main)
-  cxx_executable(sample8_unittest samples gtest_main)
-  cxx_executable(sample9_unittest samples gtest)
-  cxx_executable(sample10_unittest samples gtest)
-endif()
-
-########################################################################
-#
-# Google Test's own tests.
-#
-# You can skip this section if you aren't interested in testing
-# Google Test itself.
-#
-# The tests are not built by default.  To build them, set the
-# gtest_build_tests option to ON.  You can do it by running ccmake
-# or specifying the -Dgtest_build_tests=ON flag when running cmake.
-
-if (gtest_build_tests)
-  # This must be set in the root directory for the tests to be run by
-  # 'make test' or ctest.
-  enable_testing()
-
-  ############################################################
-  # C++ tests built with standard compiler flags.
-
-  cxx_test(gtest-death-test_test gtest_main)
-  cxx_test(gtest_environment_test gtest)
-  cxx_test(gtest-filepath_test gtest_main)
-  cxx_test(gtest-linked_ptr_test gtest_main)
-  cxx_test(gtest-listener_test gtest_main)
-  cxx_test(gtest_main_unittest gtest_main)
-  cxx_test(gtest-message_test gtest_main)
-  cxx_test(gtest_no_test_unittest gtest)
-  cxx_test(gtest-options_test gtest_main)
-  cxx_test(gtest-param-test_test gtest
-    test/gtest-param-test2_test.cc)
-  cxx_test(gtest-port_test gtest_main)
-  cxx_test(gtest_pred_impl_unittest gtest_main)
-  cxx_test(gtest_premature_exit_test gtest
-    test/gtest_premature_exit_test.cc)
-  cxx_test(gtest-printers_test gtest_main)
-  cxx_test(gtest_prod_test gtest_main
-    test/production.cc)
-  cxx_test(gtest_repeat_test gtest)
-  cxx_test(gtest_sole_header_test gtest_main)
-  cxx_test(gtest_stress_test gtest)
-  cxx_test(gtest-test-part_test gtest_main)
-  cxx_test(gtest_throw_on_failure_ex_test gtest)
-  cxx_test(gtest-typed-test_test gtest_main
-    test/gtest-typed-test2_test.cc)
-  cxx_test(gtest_unittest gtest_main)
-  cxx_test(gtest-unittest-api_test gtest)
-
-  ############################################################
-  # C++ tests built with non-standard compiler flags.
-
-  # MSVC 7.1 does not support STL with exceptions disabled.
-  if (NOT MSVC OR MSVC_VERSION GREATER 1310)
-    cxx_library(gtest_no_exception "${cxx_no_exception}"
-      src/gtest-all.cc)
-    cxx_library(gtest_main_no_exception "${cxx_no_exception}"
-      src/gtest-all.cc src/gtest_main.cc)
-  endif()
-  cxx_library(gtest_main_no_rtti "${cxx_no_rtti}"
-    src/gtest-all.cc src/gtest_main.cc)
-
-  cxx_test_with_flags(gtest-death-test_ex_nocatch_test
-    "${cxx_exception} -DGTEST_ENABLE_CATCH_EXCEPTIONS_=0"
-    gtest test/gtest-death-test_ex_test.cc)
-  cxx_test_with_flags(gtest-death-test_ex_catch_test
-    "${cxx_exception} -DGTEST_ENABLE_CATCH_EXCEPTIONS_=1"
-    gtest test/gtest-death-test_ex_test.cc)
-
-  cxx_test_with_flags(gtest_no_rtti_unittest "${cxx_no_rtti}"
-    gtest_main_no_rtti test/gtest_unittest.cc)
-
-  cxx_shared_library(gtest_dll "${cxx_default}"
-    src/gtest-all.cc src/gtest_main.cc)
-
-  cxx_executable_with_flags(gtest_dll_test_ "${cxx_default}"
-    gtest_dll test/gtest_all_test.cc)
-  set_target_properties(gtest_dll_test_
-                        PROPERTIES
-                        COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
-
-  if (NOT MSVC OR MSVC_VERSION LESS 1600)  # 1600 is Visual Studio 2010.
-    # Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that
-    # conflict with our own definitions. Therefore using our own tuple does not
-    # work on those compilers.
-    cxx_library(gtest_main_use_own_tuple "${cxx_use_own_tuple}"
-      src/gtest-all.cc src/gtest_main.cc)
-
-    cxx_test_with_flags(gtest-tuple_test "${cxx_use_own_tuple}"
-      gtest_main_use_own_tuple test/gtest-tuple_test.cc)
-
-    cxx_test_with_flags(gtest_use_own_tuple_test "${cxx_use_own_tuple}"
-      gtest_main_use_own_tuple
-      test/gtest-param-test_test.cc test/gtest-param-test2_test.cc)
-  endif()
-
-  ############################################################
-  # Python tests.
-
-  cxx_executable(gtest_break_on_failure_unittest_ test gtest)
-  py_test(gtest_break_on_failure_unittest)
-
-  # Visual Studio .NET 2003 does not support STL with exceptions disabled.
-  if (NOT MSVC OR MSVC_VERSION GREATER 1310)  # 1310 is Visual Studio .NET 2003
-    cxx_executable_with_flags(
-      gtest_catch_exceptions_no_ex_test_
-      "${cxx_no_exception}"
-      gtest_main_no_exception
-      test/gtest_catch_exceptions_test_.cc)
-  endif()
-
-  cxx_executable_with_flags(
-    gtest_catch_exceptions_ex_test_
-    "${cxx_exception}"
-    gtest_main
-    test/gtest_catch_exceptions_test_.cc)
-  py_test(gtest_catch_exceptions_test)
-
-  cxx_executable(gtest_color_test_ test gtest)
-  py_test(gtest_color_test)
-
-  cxx_executable(gtest_env_var_test_ test gtest)
-  py_test(gtest_env_var_test)
-
-  cxx_executable(gtest_filter_unittest_ test gtest)
-  py_test(gtest_filter_unittest)
-
-  cxx_executable(gtest_help_test_ test gtest_main)
-  py_test(gtest_help_test)
-
-  cxx_executable(gtest_list_tests_unittest_ test gtest)
-  py_test(gtest_list_tests_unittest)
-
-  cxx_executable(gtest_output_test_ test gtest)
-  py_test(gtest_output_test)
-
-  cxx_executable(gtest_shuffle_test_ test gtest)
-  py_test(gtest_shuffle_test)
-
-  # MSVC 7.1 does not support STL with exceptions disabled.
-  if (NOT MSVC OR MSVC_VERSION GREATER 1310)
-    cxx_executable(gtest_throw_on_failure_test_ test gtest_no_exception)
-    set_target_properties(gtest_throw_on_failure_test_
-      PROPERTIES
-      COMPILE_FLAGS "${cxx_no_exception}")
-    py_test(gtest_throw_on_failure_test)
-  endif()
-
-  cxx_executable(gtest_uninitialized_test_ test gtest)
-  py_test(gtest_uninitialized_test)
-
-  cxx_executable(gtest_xml_outfile1_test_ test gtest_main)
-  cxx_executable(gtest_xml_outfile2_test_ test gtest_main)
-  py_test(gtest_xml_outfiles_test)
-
-  cxx_executable(gtest_xml_output_unittest_ test gtest)
-  py_test(gtest_xml_output_unittest)
-endif()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/CONTRIBUTORS b/week4/softwareEng_9_4/vendor/googletest/googletest/CONTRIBUTORS
deleted file mode 100644
index feae2fc0..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/CONTRIBUTORS
+++ /dev/null
@@ -1,37 +0,0 @@
-# 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>
-Bharat Mediratta <bharat@menalto.com>
-Chandler Carruth <chandlerc@google.com>
-Chris Prince <cprince@google.com>
-Chris Taylor <taylorc@google.com>
-Dan Egnor <egnor@google.com>
-Eric Roman <eroman@chromium.org>
-Hady Zalek <hady.zalek@gmail.com>
-Jeffrey Yasskin <jyasskin@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>
-Manuel Klimek <klimek@google.com>
-Markus Heule <markus.heule@gmail.com>
-Mika Raento <mikie@iki.fi>
-Miklós Fazekas <mfazekas@szemafor.com>
-Pasi Valminen <pasi.valminen@gmail.com>
-Patrick Hanna <phanna@google.com>
-Patrick Riley <pfr@google.com>
-Peter 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>
-Tracy Bialik <tracy@pentad.com>
-Vadim Berman <vadimb@google.com>
-Vlad Losev <vladl@google.com>
-Zhanyong Wan <wan@google.com>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/LICENSE b/week4/softwareEng_9_4/vendor/googletest/googletest/LICENSE
deleted file mode 100644
index 1941a11f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/LICENSE
+++ /dev/null
@@ -1,28 +0,0 @@
-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/week4/softwareEng_9_4/vendor/googletest/googletest/Makefile.am b/week4/softwareEng_9_4/vendor/googletest/googletest/Makefile.am
deleted file mode 100644
index 29797e4e..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/Makefile.am
+++ /dev/null
@@ -1,310 +0,0 @@
-# Automake file
-
-ACLOCAL_AMFLAGS = -I m4
-
-# Nonstandard package files for distribution
-EXTRA_DIST = \
-  CHANGES \
-  CONTRIBUTORS \
-  LICENSE \
-  include/gtest/gtest-param-test.h.pump \
-  include/gtest/internal/gtest-param-util-generated.h.pump \
-  include/gtest/internal/gtest-tuple.h.pump \
-  include/gtest/internal/gtest-type-util.h.pump \
-  make/Makefile \
-  scripts/fuse_gtest_files.py \
-  scripts/gen_gtest_pred_impl.py \
-  scripts/pump.py \
-  scripts/test/Makefile
-
-# gtest source files that we don't compile directly.  They are
-# #included by gtest-all.cc.
-GTEST_SRC = \
-  src/gtest-death-test.cc \
-  src/gtest-filepath.cc \
-  src/gtest-internal-inl.h \
-  src/gtest-port.cc \
-  src/gtest-printers.cc \
-  src/gtest-test-part.cc \
-  src/gtest-typed-test.cc \
-  src/gtest.cc
-
-EXTRA_DIST += $(GTEST_SRC)
-
-# Sample files that we don't compile.
-EXTRA_DIST += \
-  samples/prime_tables.h \
-  samples/sample2_unittest.cc \
-  samples/sample3_unittest.cc \
-  samples/sample4_unittest.cc \
-  samples/sample5_unittest.cc \
-  samples/sample6_unittest.cc \
-  samples/sample7_unittest.cc \
-  samples/sample8_unittest.cc \
-  samples/sample9_unittest.cc
-
-# C++ test files that we don't compile directly.
-EXTRA_DIST += \
-  test/gtest-death-test_ex_test.cc \
-  test/gtest-death-test_test.cc \
-  test/gtest-filepath_test.cc \
-  test/gtest-linked_ptr_test.cc \
-  test/gtest-listener_test.cc \
-  test/gtest-message_test.cc \
-  test/gtest-options_test.cc \
-  test/gtest-param-test2_test.cc \
-  test/gtest-param-test2_test.cc \
-  test/gtest-param-test_test.cc \
-  test/gtest-param-test_test.cc \
-  test/gtest-param-test_test.h \
-  test/gtest-port_test.cc \
-  test/gtest_premature_exit_test.cc \
-  test/gtest-printers_test.cc \
-  test/gtest-test-part_test.cc \
-  test/gtest-tuple_test.cc \
-  test/gtest-typed-test2_test.cc \
-  test/gtest-typed-test_test.cc \
-  test/gtest-typed-test_test.h \
-  test/gtest-unittest-api_test.cc \
-  test/gtest_break_on_failure_unittest_.cc \
-  test/gtest_catch_exceptions_test_.cc \
-  test/gtest_color_test_.cc \
-  test/gtest_env_var_test_.cc \
-  test/gtest_environment_test.cc \
-  test/gtest_filter_unittest_.cc \
-  test/gtest_help_test_.cc \
-  test/gtest_list_tests_unittest_.cc \
-  test/gtest_main_unittest.cc \
-  test/gtest_no_test_unittest.cc \
-  test/gtest_output_test_.cc \
-  test/gtest_pred_impl_unittest.cc \
-  test/gtest_prod_test.cc \
-  test/gtest_repeat_test.cc \
-  test/gtest_shuffle_test_.cc \
-  test/gtest_sole_header_test.cc \
-  test/gtest_stress_test.cc \
-  test/gtest_throw_on_failure_ex_test.cc \
-  test/gtest_throw_on_failure_test_.cc \
-  test/gtest_uninitialized_test_.cc \
-  test/gtest_unittest.cc \
-  test/gtest_unittest.cc \
-  test/gtest_xml_outfile1_test_.cc \
-  test/gtest_xml_outfile2_test_.cc \
-  test/gtest_xml_output_unittest_.cc \
-  test/production.cc \
-  test/production.h
-
-# Python tests that we don't run.
-EXTRA_DIST += \
-  test/gtest_break_on_failure_unittest.py \
-  test/gtest_catch_exceptions_test.py \
-  test/gtest_color_test.py \
-  test/gtest_env_var_test.py \
-  test/gtest_filter_unittest.py \
-  test/gtest_help_test.py \
-  test/gtest_list_tests_unittest.py \
-  test/gtest_output_test.py \
-  test/gtest_output_test_golden_lin.txt \
-  test/gtest_shuffle_test.py \
-  test/gtest_test_utils.py \
-  test/gtest_throw_on_failure_test.py \
-  test/gtest_uninitialized_test.py \
-  test/gtest_xml_outfiles_test.py \
-  test/gtest_xml_output_unittest.py \
-  test/gtest_xml_test_utils.py
-
-# CMake script
-EXTRA_DIST += \
-  CMakeLists.txt \
-  cmake/internal_utils.cmake
-
-# MSVC project files
-EXTRA_DIST += \
-  msvc/gtest-md.sln \
-  msvc/gtest-md.vcproj \
-  msvc/gtest.sln \
-  msvc/gtest.vcproj \
-  msvc/gtest_main-md.vcproj \
-  msvc/gtest_main.vcproj \
-  msvc/gtest_prod_test-md.vcproj \
-  msvc/gtest_prod_test.vcproj \
-  msvc/gtest_unittest-md.vcproj \
-  msvc/gtest_unittest.vcproj
-
-# xcode project files
-EXTRA_DIST += \
-  xcode/Config/DebugProject.xcconfig \
-  xcode/Config/FrameworkTarget.xcconfig \
-  xcode/Config/General.xcconfig \
-  xcode/Config/ReleaseProject.xcconfig \
-  xcode/Config/StaticLibraryTarget.xcconfig \
-  xcode/Config/TestTarget.xcconfig \
-  xcode/Resources/Info.plist \
-  xcode/Scripts/runtests.sh \
-  xcode/Scripts/versiongenerate.py \
-  xcode/gtest.xcodeproj/project.pbxproj
-
-# xcode sample files
-EXTRA_DIST += \
-  xcode/Samples/FrameworkSample/Info.plist \
-  xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj \
-  xcode/Samples/FrameworkSample/runtests.sh \
-  xcode/Samples/FrameworkSample/widget.cc \
-  xcode/Samples/FrameworkSample/widget.h \
-  xcode/Samples/FrameworkSample/widget_test.cc
-
-# C++Builder project files
-EXTRA_DIST += \
-  codegear/gtest.cbproj \
-  codegear/gtest.groupproj \
-  codegear/gtest_all.cc \
-  codegear/gtest_link.cc \
-  codegear/gtest_main.cbproj \
-  codegear/gtest_unittest.cbproj
-
-# Distribute and install M4 macro
-m4datadir = $(datadir)/aclocal
-m4data_DATA = m4/gtest.m4
-EXTRA_DIST += $(m4data_DATA)
-
-# We define the global AM_CPPFLAGS as everything we compile includes from these
-# directories.
-AM_CPPFLAGS = -I$(srcdir) -I$(srcdir)/include
-
-# Modifies compiler and linker flags for pthreads compatibility.
-if HAVE_PTHREADS
-  AM_CXXFLAGS = @PTHREAD_CFLAGS@ -DGTEST_HAS_PTHREAD=1
-  AM_LIBS = @PTHREAD_LIBS@
-else
-  AM_CXXFLAGS = -DGTEST_HAS_PTHREAD=0
-endif
-
-# Build rules for libraries.
-lib_LTLIBRARIES = lib/libgtest.la lib/libgtest_main.la
-
-lib_libgtest_la_SOURCES = src/gtest-all.cc
-
-pkginclude_HEADERS = \
-  include/gtest/gtest-death-test.h \
-  include/gtest/gtest-message.h \
-  include/gtest/gtest-param-test.h \
-  include/gtest/gtest-printers.h \
-  include/gtest/gtest-spi.h \
-  include/gtest/gtest-test-part.h \
-  include/gtest/gtest-typed-test.h \
-  include/gtest/gtest.h \
-  include/gtest/gtest_pred_impl.h \
-  include/gtest/gtest_prod.h
-
-pkginclude_internaldir = $(pkgincludedir)/internal
-pkginclude_internal_HEADERS = \
-  include/gtest/internal/gtest-death-test-internal.h \
-  include/gtest/internal/gtest-filepath.h \
-  include/gtest/internal/gtest-internal.h \
-  include/gtest/internal/gtest-linked_ptr.h \
-  include/gtest/internal/gtest-param-util-generated.h \
-  include/gtest/internal/gtest-param-util.h \
-  include/gtest/internal/gtest-port.h \
-  include/gtest/internal/gtest-port-arch.h \
-  include/gtest/internal/gtest-string.h \
-  include/gtest/internal/gtest-tuple.h \
-  include/gtest/internal/gtest-type-util.h \
-  include/gtest/internal/custom/gtest.h \
-  include/gtest/internal/custom/gtest-port.h \
-  include/gtest/internal/custom/gtest-printers.h
-
-lib_libgtest_main_la_SOURCES = src/gtest_main.cc
-lib_libgtest_main_la_LIBADD = lib/libgtest.la
-
-# Bulid rules for samples and tests. Automake's naming for some of
-# these variables isn't terribly obvious, so this is a brief
-# reference:
-#
-# TESTS -- Programs run automatically by "make check"
-# check_PROGRAMS -- Programs built by "make check" but not necessarily run
-
-noinst_LTLIBRARIES = samples/libsamples.la
-
-samples_libsamples_la_SOURCES = \
-  samples/sample1.cc \
-  samples/sample1.h \
-  samples/sample2.cc \
-  samples/sample2.h \
-  samples/sample3-inl.h \
-  samples/sample4.cc \
-  samples/sample4.h
-
-TESTS=
-TESTS_ENVIRONMENT = GTEST_SOURCE_DIR="$(srcdir)/test" \
-                    GTEST_BUILD_DIR="$(top_builddir)/test"
-check_PROGRAMS=
-
-# A simple sample on using gtest.
-TESTS += samples/sample1_unittest
-check_PROGRAMS += samples/sample1_unittest
-samples_sample1_unittest_SOURCES = samples/sample1_unittest.cc
-samples_sample1_unittest_LDADD = lib/libgtest_main.la \
-                                 lib/libgtest.la \
-                                 samples/libsamples.la
-
-# Another sample.  It also verifies that libgtest works.
-TESTS += samples/sample10_unittest
-check_PROGRAMS += samples/sample10_unittest
-samples_sample10_unittest_SOURCES = samples/sample10_unittest.cc
-samples_sample10_unittest_LDADD = lib/libgtest.la
-
-# This tests most constructs of gtest and verifies that libgtest_main
-# and libgtest work.
-TESTS += test/gtest_all_test
-check_PROGRAMS += test/gtest_all_test
-test_gtest_all_test_SOURCES = test/gtest_all_test.cc
-test_gtest_all_test_LDADD = lib/libgtest_main.la \
-                            lib/libgtest.la
-
-# Tests that fused gtest files compile and work.
-FUSED_GTEST_SRC = \
-  fused-src/gtest/gtest-all.cc \
-  fused-src/gtest/gtest.h \
-  fused-src/gtest/gtest_main.cc
-
-if HAVE_PYTHON
-TESTS += test/fused_gtest_test
-check_PROGRAMS += test/fused_gtest_test
-test_fused_gtest_test_SOURCES = $(FUSED_GTEST_SRC) \
-                                samples/sample1.cc samples/sample1_unittest.cc
-test_fused_gtest_test_CPPFLAGS = -I"$(srcdir)/fused-src"
-
-# Build rules for putting fused Google Test files into the distribution
-# package. The user can also create those files by manually running
-# scripts/fuse_gtest_files.py.
-$(test_fused_gtest_test_SOURCES): fused-gtest
-
-fused-gtest: $(pkginclude_HEADERS) $(pkginclude_internal_HEADERS) \
-             $(GTEST_SRC) src/gtest-all.cc src/gtest_main.cc \
-             scripts/fuse_gtest_files.py
-	mkdir -p "$(srcdir)/fused-src"
-	chmod -R u+w "$(srcdir)/fused-src"
-	rm -f "$(srcdir)/fused-src/gtest/gtest-all.cc"
-	rm -f "$(srcdir)/fused-src/gtest/gtest.h"
-	"$(srcdir)/scripts/fuse_gtest_files.py" "$(srcdir)/fused-src"
-	cp -f "$(srcdir)/src/gtest_main.cc" "$(srcdir)/fused-src/gtest/"
-
-maintainer-clean-local:
-	rm -rf "$(srcdir)/fused-src"
-endif
-
-# Death tests may produce core dumps in the build directory. In case
-# this happens, clean them to keep distcleancheck happy.
-CLEANFILES = core
-
-# Disables 'make install' as installing a compiled version of Google
-# Test can lead to undefined behavior due to violation of the
-# One-Definition Rule.
-
-install-exec-local:
-	echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Test into your build system."
-	false
-
-install-data-local:
-	echo "'make install' is dangerous and not supported. Instead, see README for how to integrate Google Test into your build system."
-	false
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/README.md b/week4/softwareEng_9_4/vendor/googletest/googletest/README.md
deleted file mode 100644
index edd44080..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/README.md
+++ /dev/null
@@ -1,280 +0,0 @@
-
-### Generic Build Instructions ###
-
-#### Setup ####
-
-To build Google Test 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 ####
-
-Suppose you put Google Test in directory `${GTEST_DIR}`.  To build it,
-create a library build target (or a project as called by Visual Studio
-and Xcode) to compile
-
-    ${GTEST_DIR}/src/gtest-all.cc
-
-with `${GTEST_DIR}/include` in the system header search path and `${GTEST_DIR}`
-in the normal header search path.  Assuming a Linux-like system and gcc,
-something like the following will do:
-
-    g++ -isystem ${GTEST_DIR}/include -I${GTEST_DIR} \
-        -pthread -c ${GTEST_DIR}/src/gtest-all.cc
-    ar -rv libgtest.a gtest-all.o
-
-(We need `-pthread` as Google Test uses threads.)
-
-Next, you should compile your test source file with
-`${GTEST_DIR}/include` in the system header search path, and link it
-with gtest and any other necessary libraries:
-
-    g++ -isystem ${GTEST_DIR}/include -pthread path/to/your_test.cc libgtest.a \
-        -o your_test
-
-As an example, the make/ directory contains a Makefile that you can
-use to build Google Test on systems where GNU make is available
-(e.g. Linux, Mac OS X, and Cygwin).  It doesn't try to build Google
-Test's own tests.  Instead, it just builds the Google Test library and
-a sample test.  You can use it as a starting point for your own build
-script.
-
-If the default settings are correct for your environment, the
-following commands should succeed:
-
-    cd ${GTEST_DIR}/make
-    make
-    ./sample1_unittest
-
-If you see errors, try to tweak the contents of `make/Makefile` to make
-them go away.  There are instructions in `make/Makefile` on how to do
-it.
-
-### Using CMake ###
-
-Google Test comes with a CMake build script (
-[CMakeLists.txt](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.  The typical
-workflow starts with:
-
-    mkdir mybuild       # Create a directory to hold the build output.
-    cd mybuild
-    cmake ${GTEST_DIR}  # Generate native build scripts.
-
-If you want to build Google Test's samples, you should replace the
-last command with
-
-    cmake -Dgtest_build_samples=ON ${GTEST_DIR}
-
-If you are on a \*nix system, you should now see a Makefile in the
-current directory.  Just type 'make' to build gtest.
-
-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.
-
-### Legacy Build Scripts ###
-
-Before settling on CMake, we have been providing hand-maintained build
-projects/scripts for Visual Studio, Xcode, and Autotools.  While we
-continue to provide them for convenience, they are not actively
-maintained any more.  We highly recommend that you follow the
-instructions in the previous two sections to integrate Google Test
-with your existing build system.
-
-If you still need to use the legacy build scripts, here's how:
-
-The msvc\ folder contains two solutions with Visual C++ projects.
-Open the `gtest.sln` or `gtest-md.sln` file using Visual Studio, and you
-are ready to build Google Test the same way you build any Visual
-Studio project.  Files that have names ending with -md use DLL
-versions of Microsoft runtime libraries (the /MD or the /MDd compiler
-option).  Files without that suffix use static versions of the runtime
-libraries (the /MT or the /MTd option).  Please note that one must use
-the same option to compile both gtest and the test code.  If you use
-Visual Studio 2005 or above, we recommend the -md version as /MD is
-the default for new projects in these versions of Visual Studio.
-
-On Mac OS X, open the `gtest.xcodeproj` in the `xcode/` folder using
-Xcode.  Build the "gtest" target.  The universal binary framework will
-end up in your selected build directory (selected in the Xcode
-"Preferences..." -> "Building" pane and defaults to xcode/build).
-Alternatively, at the command line, enter:
-
-    xcodebuild
-
-This will build the "Release" configuration of gtest.framework in your
-default build location.  See the "xcodebuild" man page for more
-information about building different configurations and building in
-different locations.
-
-If you wish to use the Google Test Xcode project with Xcode 4.x and
-above, you need to either:
-
- * update the SDK configuration options in xcode/Config/General.xconfig.
-   Comment options `SDKROOT`, `MACOS_DEPLOYMENT_TARGET`, and `GCC_VERSION`. If
-   you choose this route you lose the ability to target earlier versions
-   of MacOS X.
- * Install an SDK for an earlier version. This doesn't appear to be
-   supported by Apple, but has been reported to work
-   (http://stackoverflow.com/questions/5378518).
-
-### Tweaking Google Test ###
-
-Google Test 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 Google Test 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](include/gtest/internal/gtest-port.h).
-
-### Choosing a TR1 Tuple Library ###
-
-Some Google Test features require the C++ Technical Report 1 (TR1)
-tuple library, which is not yet available with all compilers.  The
-good news is that Google Test implements a subset of TR1 tuple that's
-enough for its own need, and will automatically use this when the
-compiler doesn't provide TR1 tuple.
-
-Usually you don't need to care about which tuple library Google Test
-uses.  However, if your project already uses TR1 tuple, you need to
-tell Google Test to use the same TR1 tuple library the rest of your
-project uses, or the two tuple implementations will clash.  To do
-that, add
-
-    -DGTEST_USE_OWN_TR1_TUPLE=0
-
-to the compiler flags while compiling Google Test and your tests.  If
-you want to force Google Test to use its own tuple library, just add
-
-    -DGTEST_USE_OWN_TR1_TUPLE=1
-
-to the compiler flags instead.
-
-If you don't want Google Test to use tuple at all, add
-
-    -DGTEST_HAS_TR1_TUPLE=0
-
-and all features using tuple will be disabled.
-
-### Multi-threaded Tests ###
-
-Google Test 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 Google Test 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 Google Test 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 or the deprecated Autotools
-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) ###
-
-Google Test is compact, so most users can build and link it as a
-static library for the simplicity.  You can choose to use Google Test
-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 Google Test as a
-shared library.  Otherwise a future release of Google Test 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 Google Test macro clashes with another
-library, you can force Google Test to rename its macro to avoid the
-conflict.
-
-Specifically, if both Google Test and some other code define macro
-FOO, you can add
-
-    -DGTEST_DONT_DEFINE_FOO=1
-
-to the compiler flags to tell Google Test 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.
-
-## Developing Google Test ##
-
-This section discusses how to make your own changes to Google Test.
-
-### Testing Google Test Itself ###
-
-To make sure your changes work as intended and don't break existing
-functionality, you'll want to compile and run Google Test's own tests.
-For that you can use CMake:
-
-    mkdir mybuild
-    cd mybuild
-    cmake -Dgtest_build_tests=ON ${GTEST_DIR}
-
-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 -Dgtest_build_tests=ON ${GTEST_DIR}
-
-Next, you can build Google Test and all of its own tests.  On \*nix,
-this is usually done by 'make'.  To run the tests, do
-
-    make test
-
-All tests should pass.
-
-Normally you don't need to worry about regenerating the source files,
-unless you need to modify them.  In that case, you should modify the
-corresponding .pump files instead and run the pump.py Python script to
-regenerate them.  You can find pump.py in the [scripts/](scripts/) directory.
-Read the [Pump manual](docs/PumpManual.md) for how to use it.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/build-aux/.keep b/week4/softwareEng_9_4/vendor/googletest/googletest/build-aux/.keep
deleted file mode 100644
index e69de29b..00000000
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/cmake/internal_utils.cmake b/week4/softwareEng_9_4/vendor/googletest/googletest/cmake/internal_utils.cmake
deleted file mode 100644
index 8878dc1a..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/cmake/internal_utils.cmake
+++ /dev/null
@@ -1,256 +0,0 @@
-# Defines functions and macros useful for building Google Test and
-# Google Mock.
-#
-# Note:
-#
-# - This file will be run twice when building Google Mock (once via
-#   Google Test's CMakeLists.txt, and once via Google Mock's).
-#   Therefore it shouldn't have any side effects other than defining
-#   the functions and macros.
-#
-# - The functions/macros defined in this file may depend on Google
-#   Test and Google Mock's option() definitions, and thus must be
-#   called *after* the options have been defined.
-
-# Tweaks CMake's default compiler/linker settings to suit Google Test's needs.
-#
-# This must be a macro(), as inside a function string() can only
-# update variables in the function scope.
-macro(fix_default_compiler_settings_)
-  if (MSVC)
-    # For MSVC, CMake sets certain flags to defaults we want to override.
-    # This replacement code is taken from sample in the CMake Wiki at
-    # http://www.cmake.org/Wiki/CMake_FAQ#Dynamic_Replace.
-    foreach (flag_var
-             CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
-             CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
-      if (NOT BUILD_SHARED_LIBS AND NOT gtest_force_shared_crt)
-        # When Google Test is built as a shared library, it should also use
-        # shared runtime libraries.  Otherwise, it may end up with multiple
-        # copies of runtime library data in different modules, resulting in
-        # hard-to-find crashes. When it is built as a static library, it is
-        # preferable to use CRT as static libraries, as we don't have to rely
-        # on CRT DLLs being available. CMake always defaults to using shared
-        # CRT libraries, so we override that default here.
-        string(REPLACE "/MD" "-MT" ${flag_var} "${${flag_var}}")
-      endif()
-
-      # We prefer more strict warning checking for building Google Test.
-      # Replaces /W3 with /W4 in defaults.
-      string(REPLACE "/W3" "/W4" ${flag_var} "${${flag_var}}")
-    endforeach()
-  endif()
-endmacro()
-
-# Defines the compiler/linker flags used to build Google Test and
-# Google Mock.  You can tweak these definitions to suit your need.  A
-# variable's value is empty before it's explicitly assigned to.
-macro(config_compiler_and_linker)
-  # Note: pthreads on MinGW is not supported, even if available
-  # instead, we use windows threading primitives
-  if (NOT gtest_disable_pthreads AND NOT MINGW)
-    # Defines CMAKE_USE_PTHREADS_INIT and CMAKE_THREAD_LIBS_INIT.
-    find_package(Threads)
-  endif()
-
-  fix_default_compiler_settings_()
-  if (MSVC)
-    # Newlines inside flags variables break CMake's NMake generator.
-    # TODO(vladl@google.com): Add -RTCs and -RTCu to debug builds.
-    set(cxx_base_flags "-GS -W4 -WX -wd4251 -wd4275 -nologo -J -Zi")
-    if (MSVC_VERSION LESS 1400)  # 1400 is Visual Studio 2005
-      # Suppress spurious warnings MSVC 7.1 sometimes issues.
-      # Forcing value to bool.
-      set(cxx_base_flags "${cxx_base_flags} -wd4800")
-      # Copy constructor and assignment operator could not be generated.
-      set(cxx_base_flags "${cxx_base_flags} -wd4511 -wd4512")
-      # Compatibility warnings not applicable to Google Test.
-      # Resolved overload was found by argument-dependent lookup.
-      set(cxx_base_flags "${cxx_base_flags} -wd4675")
-    endif()
-    if (MSVC_VERSION LESS 1500)  # 1500 is Visual Studio 2008
-      # Conditional expression is constant.
-      # When compiling with /W4, we get several instances of C4127
-      # (Conditional expression is constant). In our code, we disable that
-      # warning on a case-by-case basis. However, on Visual Studio 2005,
-      # the warning fires on std::list. Therefore on that compiler and earlier,
-      # we disable the warning project-wide.
-      set(cxx_base_flags "${cxx_base_flags} -wd4127")
-    endif()
-    if (NOT (MSVC_VERSION LESS 1700))  # 1700 is Visual Studio 2012.
-      # Suppress "unreachable code" warning on VS 2012 and later.
-      # http://stackoverflow.com/questions/3232669 explains the issue.
-      set(cxx_base_flags "${cxx_base_flags} -wd4702")
-    endif()
-    if (NOT (MSVC_VERSION GREATER 1900))  # 1900 is Visual Studio 2015
-      # BigObj required for tests.
-      set(cxx_base_flags "${cxx_base_flags} -bigobj")
-    endif()
-
-    set(cxx_base_flags "${cxx_base_flags} -D_UNICODE -DUNICODE -DWIN32 -D_WIN32")
-    set(cxx_base_flags "${cxx_base_flags} -DSTRICT -DWIN32_LEAN_AND_MEAN")
-    set(cxx_exception_flags "-EHsc -D_HAS_EXCEPTIONS=1")
-    set(cxx_no_exception_flags "-D_HAS_EXCEPTIONS=0")
-    set(cxx_no_rtti_flags "-GR-")
-  elseif (CMAKE_COMPILER_IS_GNUCXX)
-    set(cxx_base_flags "-Wall -Wshadow")
-    set(cxx_exception_flags "-fexceptions")
-    set(cxx_no_exception_flags "-fno-exceptions")
-    # Until version 4.3.2, GCC doesn't define a macro to indicate
-    # whether RTTI is enabled.  Therefore we define GTEST_HAS_RTTI
-    # explicitly.
-    set(cxx_no_rtti_flags "-fno-rtti -DGTEST_HAS_RTTI=0")
-    set(cxx_strict_flags
-      "-Wextra -Wno-unused-parameter -Wno-missing-field-initializers")
-  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "SunPro")
-    set(cxx_exception_flags "-features=except")
-    # Sun Pro doesn't provide macros to indicate whether exceptions and
-    # RTTI are enabled, so we define GTEST_HAS_* explicitly.
-    set(cxx_no_exception_flags "-features=no%except -DGTEST_HAS_EXCEPTIONS=0")
-    set(cxx_no_rtti_flags "-features=no%rtti -DGTEST_HAS_RTTI=0")
-  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "VisualAge" OR
-      CMAKE_CXX_COMPILER_ID STREQUAL "XL")
-    # CMake 2.8 changes Visual Age's compiler ID to "XL".
-    set(cxx_exception_flags "-qeh")
-    set(cxx_no_exception_flags "-qnoeh")
-    # Until version 9.0, Visual Age doesn't define a macro to indicate
-    # whether RTTI is enabled.  Therefore we define GTEST_HAS_RTTI
-    # explicitly.
-    set(cxx_no_rtti_flags "-qnortti -DGTEST_HAS_RTTI=0")
-  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "HP")
-    set(cxx_base_flags "-AA -mt")
-    set(cxx_exception_flags "-DGTEST_HAS_EXCEPTIONS=1")
-    set(cxx_no_exception_flags "+noeh -DGTEST_HAS_EXCEPTIONS=0")
-    # RTTI can not be disabled in HP aCC compiler.
-    set(cxx_no_rtti_flags "")
-  endif()
-
-  if (CMAKE_USE_PTHREADS_INIT)  # The pthreads library is available and allowed.
-    set(cxx_base_flags "${cxx_base_flags} -DGTEST_HAS_PTHREAD=1")
-  else()
-    set(cxx_base_flags "${cxx_base_flags} -DGTEST_HAS_PTHREAD=0")
-  endif()
-
-  # For building gtest's own tests and samples.
-  set(cxx_exception "${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_exception_flags}")
-  set(cxx_no_exception
-    "${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_no_exception_flags}")
-  set(cxx_default "${cxx_exception}")
-  set(cxx_no_rtti "${cxx_default} ${cxx_no_rtti_flags}")
-  set(cxx_use_own_tuple "${cxx_default} -DGTEST_USE_OWN_TR1_TUPLE=1")
-
-  # For building the gtest libraries.
-  set(cxx_strict "${cxx_default} ${cxx_strict_flags}")
-endmacro()
-
-# Defines the gtest & gtest_main libraries.  User tests should link
-# with one of them.
-function(cxx_library_with_type name type cxx_flags)
-  # type can be either STATIC or SHARED to denote a static or shared library.
-  # ARGN refers to additional arguments after 'cxx_flags'.
-  add_library(${name} ${type} ${ARGN})
-  set_target_properties(${name}
-    PROPERTIES
-    COMPILE_FLAGS "${cxx_flags}")
-  if (BUILD_SHARED_LIBS OR type STREQUAL "SHARED")
-    set_target_properties(${name}
-      PROPERTIES
-      COMPILE_DEFINITIONS "GTEST_CREATE_SHARED_LIBRARY=1")
-  endif()
-  if (CMAKE_USE_PTHREADS_INIT)
-    target_link_libraries(${name} ${CMAKE_THREAD_LIBS_INIT})
-  endif()
-endfunction()
-
-########################################################################
-#
-# Helper functions for creating build targets.
-
-function(cxx_shared_library name cxx_flags)
-  cxx_library_with_type(${name} SHARED "${cxx_flags}" ${ARGN})
-endfunction()
-
-function(cxx_library name cxx_flags)
-  cxx_library_with_type(${name} "" "${cxx_flags}" ${ARGN})
-endfunction()
-
-# cxx_executable_with_flags(name cxx_flags libs srcs...)
-#
-# creates a named C++ executable that depends on the given libraries and
-# is built from the given source files with the given compiler flags.
-function(cxx_executable_with_flags name cxx_flags libs)
-  add_executable(${name} ${ARGN})
-  if (cxx_flags)
-    set_target_properties(${name}
-      PROPERTIES
-      COMPILE_FLAGS "${cxx_flags}")
-  endif()
-  if (BUILD_SHARED_LIBS)
-    set_target_properties(${name}
-      PROPERTIES
-      COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
-  endif()
-  # To support mixing linking in static and dynamic libraries, link each
-  # library in with an extra call to target_link_libraries.
-  foreach (lib "${libs}")
-    target_link_libraries(${name} ${lib})
-  endforeach()
-endfunction()
-
-# cxx_executable(name dir lib srcs...)
-#
-# creates a named target that depends on the given libs and is built
-# from the given source files.  dir/name.cc is implicitly included in
-# the source file list.
-function(cxx_executable name dir libs)
-  cxx_executable_with_flags(
-    ${name} "${cxx_default}" "${libs}" "${dir}/${name}.cc" ${ARGN})
-endfunction()
-
-# Sets PYTHONINTERP_FOUND and PYTHON_EXECUTABLE.
-find_package(PythonInterp)
-
-# cxx_test_with_flags(name cxx_flags libs srcs...)
-#
-# creates a named C++ test that depends on the given libs and is built
-# from the given source files with the given compiler flags.
-function(cxx_test_with_flags name cxx_flags libs)
-  cxx_executable_with_flags(${name} "${cxx_flags}" "${libs}" ${ARGN})
-  add_test(${name} ${name})
-endfunction()
-
-# cxx_test(name libs srcs...)
-#
-# creates a named test target that depends on the given libs and is
-# built from the given source files.  Unlike cxx_test_with_flags,
-# test/name.cc is already implicitly included in the source file list.
-function(cxx_test name libs)
-  cxx_test_with_flags("${name}" "${cxx_default}" "${libs}"
-    "test/${name}.cc" ${ARGN})
-endfunction()
-
-# py_test(name)
-#
-# creates a Python test with the given name whose main module is in
-# test/name.py.  It does nothing if Python is not installed.
-function(py_test name)
-  # We are not supporting Python tests on Linux yet as they consider
-  # all Linux environments to be google3 and try to use google3 features.
-  if (PYTHONINTERP_FOUND)
-    # ${CMAKE_BINARY_DIR} is known at configuration time, so we can
-    # directly bind it from cmake. ${CTEST_CONFIGURATION_TYPE} is known
-    # only at ctest runtime (by calling ctest -c <Configuration>), so
-    # we have to escape $ to delay variable substitution here.
-    if (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 3.1)
-      add_test(
-        NAME ${name}
-        COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
-            --build_dir=${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>)
-    else (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 3.1)
-      add_test(
-        ${name}
-        ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
-          --build_dir=${CMAKE_CURRENT_BINARY_DIR}/\${CTEST_CONFIGURATION_TYPE})
-    endif (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 3.1)
-  endif()
-endfunction()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.cbproj b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.cbproj
deleted file mode 100644
index 95c3054b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.cbproj
+++ /dev/null
@@ -1,138 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <ProjectGuid>{bca37a72-5b07-46cf-b44e-89f8e06451a2}</ProjectGuid>
-    <Config Condition="'$(Config)'==''">Release</Config>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''">
-    <Base>true</Base>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_1)'!=''">
-    <Base>true</Base>
-    <Cfg_1>true</Cfg_1>
-    <CfgParent>Base</CfgParent>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_2)'!=''">
-    <Base>true</Base>
-    <Cfg_2>true</Cfg_2>
-    <CfgParent>Base</CfgParent>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Base)'!=''">
-    <BCC_OptimizeForSpeed>true</BCC_OptimizeForSpeed>
-    <OutputExt>lib</OutputExt>
-    <DCC_CBuilderOutput>JPHNE</DCC_CBuilderOutput>
-    <Defines>NO_STRICT</Defines>
-    <DynamicRTL>true</DynamicRTL>
-    <UsePackages>true</UsePackages>
-    <ProjectType>CppStaticLibrary</ProjectType>
-    <BCC_CPPCompileAlways>true</BCC_CPPCompileAlways>
-    <PackageImports>rtl.bpi;vcl.bpi;bcbie.bpi;vclx.bpi;vclactnband.bpi;xmlrtl.bpi;bcbsmp.bpi;dbrtl.bpi;vcldb.bpi;bdertl.bpi;vcldbx.bpi;dsnap.bpi;dsnapcon.bpi;vclib.bpi;ibxpress.bpi;adortl.bpi;dbxcds.bpi;dbexpress.bpi;DbxCommonDriver.bpi;websnap.bpi;vclie.bpi;webdsnap.bpi;inet.bpi;inetdbbde.bpi;inetdbxpress.bpi;soaprtl.bpi;Rave75VCL.bpi;teeUI.bpi;tee.bpi;teedb.bpi;IndyCore.bpi;IndySystem.bpi;IndyProtocols.bpi;IntrawebDB_90_100.bpi;Intraweb_90_100.bpi;dclZipForged11.bpi;vclZipForged11.bpi;GR32_BDS2006.bpi;GR32_DSGN_BDS2006.bpi;Jcl.bpi;JclVcl.bpi;JvCoreD11R.bpi;JvSystemD11R.bpi;JvStdCtrlsD11R.bpi;JvAppFrmD11R.bpi;JvBandsD11R.bpi;JvDBD11R.bpi;JvDlgsD11R.bpi;JvBDED11R.bpi;JvCmpD11R.bpi;JvCryptD11R.bpi;JvCtrlsD11R.bpi;JvCustomD11R.bpi;JvDockingD11R.bpi;JvDotNetCtrlsD11R.bpi;JvEDID11R.bpi;JvGlobusD11R.bpi;JvHMID11R.bpi;JvInterpreterD11R.bpi;JvJansD11R.bpi;JvManagedThreadsD11R.bpi;JvMMD11R.bpi;JvNetD11R.bpi;JvPageCompsD11R.bpi;JvPluginD11R.bpi;JvPrintPreviewD11R.bpi;JvRuntimeDesignD11R.bpi;JvTimeFrameworkD11R.bpi;JvValidatorsD11R.bpi;JvWizardD11R.bpi;JvXPCtrlsD11R.bpi;VclSmp.bpi;CExceptionExpert11.bpi</PackageImports>
-    <BCC_wpar>false</BCC_wpar>
-    <IncludePath>$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</IncludePath>
-    <AllPackageLibs>rtl.lib;vcl.lib</AllPackageLibs>
-    <TLIB_PageSize>32</TLIB_PageSize>
-    <ILINK_LibraryPath>$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk</ILINK_LibraryPath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Cfg_1)'!=''">
-    <BCC_OptimizeForSpeed>false</BCC_OptimizeForSpeed>
-    <DCC_Optimize>false</DCC_Optimize>
-    <DCC_DebugInfoInExe>true</DCC_DebugInfoInExe>
-    <Defines>_DEBUG;$(Defines)</Defines>
-    <ILINK_FullDebugInfo>true</ILINK_FullDebugInfo>
-    <BCC_InlineFunctionExpansion>false</BCC_InlineFunctionExpansion>
-    <ILINK_DisableIncrementalLinking>true</ILINK_DisableIncrementalLinking>
-    <BCC_UseRegisterVariables>None</BCC_UseRegisterVariables>
-    <DCC_Define>DEBUG</DCC_Define>
-    <BCC_DebugLineNumbers>true</BCC_DebugLineNumbers>
-    <IntermediateOutputDir>Debug</IntermediateOutputDir>
-    <TASM_DisplaySourceLines>true</TASM_DisplaySourceLines>
-    <BCC_StackFrames>true</BCC_StackFrames>
-    <BCC_DisableOptimizations>true</BCC_DisableOptimizations>
-    <ILINK_LibraryPath>$(BDS)\lib\debug;$(ILINK_LibraryPath)</ILINK_LibraryPath>
-    <TASM_Debugging>Full</TASM_Debugging>
-    <BCC_SourceDebuggingOn>true</BCC_SourceDebuggingOn>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Cfg_2)'!=''">
-    <Defines>NDEBUG;$(Defines)</Defines>
-    <IntermediateOutputDir>Release</IntermediateOutputDir>
-    <ILINK_LibraryPath>$(BDS)\lib\release;$(ILINK_LibraryPath)</ILINK_LibraryPath>
-    <TASM_Debugging>None</TASM_Debugging>
-  </PropertyGroup>
-  <ProjectExtensions>
-    <Borland.Personality>CPlusPlusBuilder.Personality</Borland.Personality>
-    <Borland.ProjectType>CppStaticLibrary</Borland.ProjectType>
-    <BorlandProject>
-<BorlandProject><CPlusPlusBuilder.Personality><VersionInfo><VersionInfo Name="IncludeVerInfo">False</VersionInfo><VersionInfo Name="AutoIncBuild">False</VersionInfo><VersionInfo Name="MajorVer">1</VersionInfo><VersionInfo Name="MinorVer">0</VersionInfo><VersionInfo Name="Release">0</VersionInfo><VersionInfo Name="Build">0</VersionInfo><VersionInfo Name="Debug">False</VersionInfo><VersionInfo Name="PreRelease">False</VersionInfo><VersionInfo Name="Special">False</VersionInfo><VersionInfo Name="Private">False</VersionInfo><VersionInfo Name="DLL">False</VersionInfo><VersionInfo Name="Locale">1033</VersionInfo><VersionInfo Name="CodePage">1252</VersionInfo></VersionInfo><VersionInfoKeys><VersionInfoKeys Name="CompanyName"></VersionInfoKeys><VersionInfoKeys Name="FileDescription"></VersionInfoKeys><VersionInfoKeys Name="FileVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="InternalName"></VersionInfoKeys><VersionInfoKeys Name="LegalCopyright"></VersionInfoKeys><VersionInfoKeys Name="LegalTrademarks"></VersionInfoKeys><VersionInfoKeys Name="OriginalFilename"></VersionInfoKeys><VersionInfoKeys Name="ProductName"></VersionInfoKeys><VersionInfoKeys Name="ProductVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="Comments"></VersionInfoKeys></VersionInfoKeys><Debugging><Debugging Name="DebugSourceDirs"></Debugging></Debugging><Parameters><Parameters Name="RunParams"></Parameters><Parameters Name="Launcher"></Parameters><Parameters Name="UseLauncher">False</Parameters><Parameters Name="DebugCWD"></Parameters><Parameters Name="HostApplication"></Parameters><Parameters Name="RemoteHost"></Parameters><Parameters Name="RemotePath"></Parameters><Parameters Name="RemoteParams"></Parameters><Parameters Name="RemoteLauncher"></Parameters><Parameters Name="UseRemoteLauncher">False</Parameters><Parameters Name="RemoteCWD"></Parameters><Parameters Name="RemoteDebug">False</Parameters><Parameters Name="Debug Symbols Search Path"></Parameters><Parameters Name="LoadAllSymbols">True</Parameters><Parameters Name="LoadUnspecifiedSymbols">False</Parameters></Parameters><Excluded_Packages>
-      
-      
-      <Excluded_Packages Name="$(BDS)\bin\bcboffice2k100.bpl">CodeGear C++Builder Office 2000 Servers Package</Excluded_Packages>
-      <Excluded_Packages Name="$(BDS)\bin\bcbofficexp100.bpl">CodeGear C++Builder Office XP Servers Package</Excluded_Packages>
-    </Excluded_Packages><Linker><Linker Name="LibPrefix"></Linker><Linker Name="LibSuffix"></Linker><Linker Name="LibVersion"></Linker></Linker><ProjectProperties><ProjectProperties Name="AutoShowDeps">False</ProjectProperties><ProjectProperties Name="ManagePaths">True</ProjectProperties><ProjectProperties Name="VerifyPackages">True</ProjectProperties></ProjectProperties><HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Count">3</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item0">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item1">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item2">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\src;..\include</HistoryLists_hlIncludePath></HistoryLists_hlIncludePath><HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Count">1</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item0">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk</HistoryLists_hlILINK_LibraryPath></HistoryLists_hlILINK_LibraryPath><HistoryLists_hlDefines><HistoryLists_hlDefines Name="Count">1</HistoryLists_hlDefines><HistoryLists_hlDefines Name="Item0">NO_STRICT</HistoryLists_hlDefines></HistoryLists_hlDefines><HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Count">1</HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Item0">32</HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Item1">16</HistoryLists_hlTLIB_PageSize></HistoryLists_hlTLIB_PageSize></CPlusPlusBuilder.Personality></BorlandProject></BorlandProject>
-  </ProjectExtensions>
-  <Import Project="$(MSBuildBinPath)\Borland.Cpp.Targets" />
-  <ItemGroup>
-    <None Include="..\include\gtest\gtest-death-test.h">
-      <BuildOrder>3</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\gtest-message.h">
-      <BuildOrder>4</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\gtest-param-test.h">
-      <BuildOrder>5</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\gtest-spi.h">
-      <BuildOrder>6</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\gtest-test-part.h">
-      <BuildOrder>7</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\gtest-typed-test.h">
-      <BuildOrder>8</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\gtest.h">
-      <BuildOrder>0</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\gtest_pred_impl.h">
-      <BuildOrder>1</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\gtest_prod.h">
-      <BuildOrder>2</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\internal\gtest-death-test-internal.h">
-      <BuildOrder>9</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\internal\gtest-filepath.h">
-      <BuildOrder>10</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\internal\gtest-internal.h">
-      <BuildOrder>11</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\internal\gtest-linked_ptr.h">
-      <BuildOrder>12</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\internal\gtest-param-util-generated.h">
-      <BuildOrder>14</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\internal\gtest-param-util.h">
-      <BuildOrder>13</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\internal\gtest-port.h">
-      <BuildOrder>15</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\internal\gtest-string.h">
-      <BuildOrder>16</BuildOrder>
-    </None>
-    <None Include="..\include\gtest\internal\gtest-type-util.h">
-      <BuildOrder>17</BuildOrder>
-    </None>
-    <CppCompile Include="gtest_all.cc">
-      <BuildOrder>18</BuildOrder>
-    </CppCompile>
-    <BuildConfiguration Include="Debug">
-      <Key>Cfg_1</Key>
-    </BuildConfiguration>
-    <BuildConfiguration Include="Release">
-      <Key>Cfg_2</Key>
-    </BuildConfiguration>
-  </ItemGroup>
-</Project>
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.groupproj b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.groupproj
deleted file mode 100644
index faf31cab..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest.groupproj
+++ /dev/null
@@ -1,54 +0,0 @@
-<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <ProjectGuid>{c1d923e0-6cba-4332-9b6f-3420acbf5091}</ProjectGuid>
-  </PropertyGroup>
-  <ItemGroup />
-  <ItemGroup>
-    <Projects Include="gtest.cbproj" />
-    <Projects Include="gtest_main.cbproj" />
-    <Projects Include="gtest_unittest.cbproj" />
-  </ItemGroup>
-  <ProjectExtensions>
-    <Borland.Personality>Default.Personality</Borland.Personality>
-    <Borland.ProjectType />
-    <BorlandProject>
-<BorlandProject xmlns=""><Default.Personality></Default.Personality></BorlandProject></BorlandProject>
-  </ProjectExtensions>
-  <Target Name="gtest">
-    <MSBuild Projects="gtest.cbproj" Targets="" />
-  </Target>
-  <Target Name="gtest:Clean">
-    <MSBuild Projects="gtest.cbproj" Targets="Clean" />
-  </Target>
-  <Target Name="gtest:Make">
-    <MSBuild Projects="gtest.cbproj" Targets="Make" />
-  </Target>
-  <Target Name="gtest_main">
-    <MSBuild Projects="gtest_main.cbproj" Targets="" />
-  </Target>
-  <Target Name="gtest_main:Clean">
-    <MSBuild Projects="gtest_main.cbproj" Targets="Clean" />
-  </Target>
-  <Target Name="gtest_main:Make">
-    <MSBuild Projects="gtest_main.cbproj" Targets="Make" />
-  </Target>
-  <Target Name="gtest_unittest">
-    <MSBuild Projects="gtest_unittest.cbproj" Targets="" />
-  </Target>
-  <Target Name="gtest_unittest:Clean">
-    <MSBuild Projects="gtest_unittest.cbproj" Targets="Clean" />
-  </Target>
-  <Target Name="gtest_unittest:Make">
-    <MSBuild Projects="gtest_unittest.cbproj" Targets="Make" />
-  </Target>
-  <Target Name="Build">
-    <CallTarget Targets="gtest;gtest_main;gtest_unittest" />
-  </Target>
-  <Target Name="Clean">
-    <CallTarget Targets="gtest:Clean;gtest_main:Clean;gtest_unittest:Clean" />
-  </Target>
-  <Target Name="Make">
-    <CallTarget Targets="gtest:Make;gtest_main:Make;gtest_unittest:Make" />
-  </Target>
-  <Import Condition="Exists('$(MSBuildBinPath)\Borland.Group.Targets')" Project="$(MSBuildBinPath)\Borland.Group.Targets" />
-</Project>
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_all.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_all.cc
deleted file mode 100644
index 121b2d80..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_all.cc
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2009, 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.
-//
-// Author: Josh Kelley (joshkel@gmail.com)
-//
-// Google C++ Testing Framework (Google Test)
-//
-// C++Builder's IDE cannot build a static library from files with hyphens
-// in their name.  See http://qc.codegear.com/wc/qcmain.aspx?d=70977 .
-// This file serves as a workaround.
-
-#include "src/gtest-all.cc"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_link.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_link.cc
deleted file mode 100644
index 918eccd1..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_link.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2009, 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.
-//
-// Author: Josh Kelley (joshkel@gmail.com)
-//
-// Google C++ Testing Framework (Google Test)
-//
-// Links gtest.lib and gtest_main.lib into the current project in C++Builder.
-// This means that these libraries can't be renamed, but it's the only way to
-// ensure that Debug versus Release test builds are linked against the
-// appropriate Debug or Release build of the libraries.
-
-#pragma link "gtest.lib"
-#pragma link "gtest_main.lib"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_main.cbproj b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_main.cbproj
deleted file mode 100644
index d76ce139..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_main.cbproj
+++ /dev/null
@@ -1,82 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <ProjectGuid>{bca37a72-5b07-46cf-b44e-89f8e06451a2}</ProjectGuid>
-    <Config Condition="'$(Config)'==''">Release</Config>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''">
-    <Base>true</Base>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_1)'!=''">
-    <Base>true</Base>
-    <Cfg_1>true</Cfg_1>
-    <CfgParent>Base</CfgParent>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_2)'!=''">
-    <Base>true</Base>
-    <Cfg_2>true</Cfg_2>
-    <CfgParent>Base</CfgParent>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Base)'!=''">
-    <BCC_OptimizeForSpeed>true</BCC_OptimizeForSpeed>
-    <OutputExt>lib</OutputExt>
-    <DCC_CBuilderOutput>JPHNE</DCC_CBuilderOutput>
-    <Defines>NO_STRICT</Defines>
-    <DynamicRTL>true</DynamicRTL>
-    <UsePackages>true</UsePackages>
-    <ProjectType>CppStaticLibrary</ProjectType>
-    <BCC_CPPCompileAlways>true</BCC_CPPCompileAlways>
-    <PackageImports>rtl.bpi;vcl.bpi;bcbie.bpi;vclx.bpi;vclactnband.bpi;xmlrtl.bpi;bcbsmp.bpi;dbrtl.bpi;vcldb.bpi;bdertl.bpi;vcldbx.bpi;dsnap.bpi;dsnapcon.bpi;vclib.bpi;ibxpress.bpi;adortl.bpi;dbxcds.bpi;dbexpress.bpi;DbxCommonDriver.bpi;websnap.bpi;vclie.bpi;webdsnap.bpi;inet.bpi;inetdbbde.bpi;inetdbxpress.bpi;soaprtl.bpi;Rave75VCL.bpi;teeUI.bpi;tee.bpi;teedb.bpi;IndyCore.bpi;IndySystem.bpi;IndyProtocols.bpi;IntrawebDB_90_100.bpi;Intraweb_90_100.bpi;dclZipForged11.bpi;vclZipForged11.bpi;GR32_BDS2006.bpi;GR32_DSGN_BDS2006.bpi;Jcl.bpi;JclVcl.bpi;JvCoreD11R.bpi;JvSystemD11R.bpi;JvStdCtrlsD11R.bpi;JvAppFrmD11R.bpi;JvBandsD11R.bpi;JvDBD11R.bpi;JvDlgsD11R.bpi;JvBDED11R.bpi;JvCmpD11R.bpi;JvCryptD11R.bpi;JvCtrlsD11R.bpi;JvCustomD11R.bpi;JvDockingD11R.bpi;JvDotNetCtrlsD11R.bpi;JvEDID11R.bpi;JvGlobusD11R.bpi;JvHMID11R.bpi;JvInterpreterD11R.bpi;JvJansD11R.bpi;JvManagedThreadsD11R.bpi;JvMMD11R.bpi;JvNetD11R.bpi;JvPageCompsD11R.bpi;JvPluginD11R.bpi;JvPrintPreviewD11R.bpi;JvRuntimeDesignD11R.bpi;JvTimeFrameworkD11R.bpi;JvValidatorsD11R.bpi;JvWizardD11R.bpi;JvXPCtrlsD11R.bpi;VclSmp.bpi;CExceptionExpert11.bpi</PackageImports>
-    <BCC_wpar>false</BCC_wpar>
-    <IncludePath>$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</IncludePath>
-    <AllPackageLibs>rtl.lib;vcl.lib</AllPackageLibs>
-    <TLIB_PageSize>32</TLIB_PageSize>
-    <ILINK_LibraryPath>$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk</ILINK_LibraryPath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Cfg_1)'!=''">
-    <BCC_OptimizeForSpeed>false</BCC_OptimizeForSpeed>
-    <DCC_Optimize>false</DCC_Optimize>
-    <DCC_DebugInfoInExe>true</DCC_DebugInfoInExe>
-    <Defines>_DEBUG;$(Defines)</Defines>
-    <ILINK_FullDebugInfo>true</ILINK_FullDebugInfo>
-    <BCC_InlineFunctionExpansion>false</BCC_InlineFunctionExpansion>
-    <ILINK_DisableIncrementalLinking>true</ILINK_DisableIncrementalLinking>
-    <BCC_UseRegisterVariables>None</BCC_UseRegisterVariables>
-    <DCC_Define>DEBUG</DCC_Define>
-    <BCC_DebugLineNumbers>true</BCC_DebugLineNumbers>
-    <IntermediateOutputDir>Debug</IntermediateOutputDir>
-    <TASM_DisplaySourceLines>true</TASM_DisplaySourceLines>
-    <BCC_StackFrames>true</BCC_StackFrames>
-    <BCC_DisableOptimizations>true</BCC_DisableOptimizations>
-    <ILINK_LibraryPath>$(BDS)\lib\debug;$(ILINK_LibraryPath)</ILINK_LibraryPath>
-    <TASM_Debugging>Full</TASM_Debugging>
-    <BCC_SourceDebuggingOn>true</BCC_SourceDebuggingOn>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Cfg_2)'!=''">
-    <Defines>NDEBUG;$(Defines)</Defines>
-    <IntermediateOutputDir>Release</IntermediateOutputDir>
-    <ILINK_LibraryPath>$(BDS)\lib\release;$(ILINK_LibraryPath)</ILINK_LibraryPath>
-    <TASM_Debugging>None</TASM_Debugging>
-  </PropertyGroup>
-  <ProjectExtensions>
-    <Borland.Personality>CPlusPlusBuilder.Personality</Borland.Personality>
-    <Borland.ProjectType>CppStaticLibrary</Borland.ProjectType>
-    <BorlandProject>
-<BorlandProject><CPlusPlusBuilder.Personality><VersionInfo><VersionInfo Name="IncludeVerInfo">False</VersionInfo><VersionInfo Name="AutoIncBuild">False</VersionInfo><VersionInfo Name="MajorVer">1</VersionInfo><VersionInfo Name="MinorVer">0</VersionInfo><VersionInfo Name="Release">0</VersionInfo><VersionInfo Name="Build">0</VersionInfo><VersionInfo Name="Debug">False</VersionInfo><VersionInfo Name="PreRelease">False</VersionInfo><VersionInfo Name="Special">False</VersionInfo><VersionInfo Name="Private">False</VersionInfo><VersionInfo Name="DLL">False</VersionInfo><VersionInfo Name="Locale">1033</VersionInfo><VersionInfo Name="CodePage">1252</VersionInfo></VersionInfo><VersionInfoKeys><VersionInfoKeys Name="CompanyName"></VersionInfoKeys><VersionInfoKeys Name="FileDescription"></VersionInfoKeys><VersionInfoKeys Name="FileVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="InternalName"></VersionInfoKeys><VersionInfoKeys Name="LegalCopyright"></VersionInfoKeys><VersionInfoKeys Name="LegalTrademarks"></VersionInfoKeys><VersionInfoKeys Name="OriginalFilename"></VersionInfoKeys><VersionInfoKeys Name="ProductName"></VersionInfoKeys><VersionInfoKeys Name="ProductVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="Comments"></VersionInfoKeys></VersionInfoKeys><Debugging><Debugging Name="DebugSourceDirs"></Debugging></Debugging><Parameters><Parameters Name="RunParams"></Parameters><Parameters Name="Launcher"></Parameters><Parameters Name="UseLauncher">False</Parameters><Parameters Name="DebugCWD"></Parameters><Parameters Name="HostApplication"></Parameters><Parameters Name="RemoteHost"></Parameters><Parameters Name="RemotePath"></Parameters><Parameters Name="RemoteParams"></Parameters><Parameters Name="RemoteLauncher"></Parameters><Parameters Name="UseRemoteLauncher">False</Parameters><Parameters Name="RemoteCWD"></Parameters><Parameters Name="RemoteDebug">False</Parameters><Parameters Name="Debug Symbols Search Path"></Parameters><Parameters Name="LoadAllSymbols">True</Parameters><Parameters Name="LoadUnspecifiedSymbols">False</Parameters></Parameters><Excluded_Packages>
-      <Excluded_Packages Name="$(BDS)\bin\bcboffice2k100.bpl">CodeGear C++Builder Office 2000 Servers Package</Excluded_Packages>
-      <Excluded_Packages Name="$(BDS)\bin\bcbofficexp100.bpl">CodeGear C++Builder Office XP Servers Package</Excluded_Packages>
-    </Excluded_Packages><Linker><Linker Name="LibPrefix"></Linker><Linker Name="LibSuffix"></Linker><Linker Name="LibVersion"></Linker></Linker><ProjectProperties><ProjectProperties Name="AutoShowDeps">False</ProjectProperties><ProjectProperties Name="ManagePaths">True</ProjectProperties><ProjectProperties Name="VerifyPackages">True</ProjectProperties></ProjectProperties><HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Count">3</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item0">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item1">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\include;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item2">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\src;..\src;..\include</HistoryLists_hlIncludePath></HistoryLists_hlIncludePath><HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Count">1</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item0">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk</HistoryLists_hlILINK_LibraryPath></HistoryLists_hlILINK_LibraryPath><HistoryLists_hlDefines><HistoryLists_hlDefines Name="Count">1</HistoryLists_hlDefines><HistoryLists_hlDefines Name="Item0">NO_STRICT</HistoryLists_hlDefines></HistoryLists_hlDefines><HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Count">1</HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Item0">32</HistoryLists_hlTLIB_PageSize><HistoryLists_hlTLIB_PageSize Name="Item1">16</HistoryLists_hlTLIB_PageSize></HistoryLists_hlTLIB_PageSize></CPlusPlusBuilder.Personality></BorlandProject></BorlandProject>
-  </ProjectExtensions>
-  <Import Project="$(MSBuildBinPath)\Borland.Cpp.Targets" />
-  <ItemGroup>
-    <CppCompile Include="..\src\gtest_main.cc">
-      <BuildOrder>0</BuildOrder>
-    </CppCompile>
-    <BuildConfiguration Include="Debug">
-      <Key>Cfg_1</Key>
-    </BuildConfiguration>
-    <BuildConfiguration Include="Release">
-      <Key>Cfg_2</Key>
-    </BuildConfiguration>
-  </ItemGroup>
-</Project>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_unittest.cbproj b/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_unittest.cbproj
deleted file mode 100644
index dc5db8e4..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/codegear/gtest_unittest.cbproj
+++ /dev/null
@@ -1,88 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <ProjectGuid>{eea63393-5ac5-4b9c-8909-d75fef2daa41}</ProjectGuid>
-    <Config Condition="'$(Config)'==''">Release</Config>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''">
-    <Base>true</Base>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_1)'!=''">
-    <Base>true</Base>
-    <Cfg_1>true</Cfg_1>
-    <CfgParent>Base</CfgParent>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_2)'!=''">
-    <Base>true</Base>
-    <Cfg_2>true</Cfg_2>
-    <CfgParent>Base</CfgParent>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Base)'!=''">
-    <OutputExt>exe</OutputExt>
-    <BCC_OptimizeForSpeed>true</BCC_OptimizeForSpeed>
-    <Defines>NO_STRICT</Defines>
-    <DCC_CBuilderOutput>JPHNE</DCC_CBuilderOutput>
-    <DynamicRTL>true</DynamicRTL>
-    <ILINK_ObjectSearchPath>..\test</ILINK_ObjectSearchPath>
-    <UsePackages>true</UsePackages>
-    <ProjectType>CppConsoleApplication</ProjectType>
-    <NoVCL>true</NoVCL>
-    <BCC_CPPCompileAlways>true</BCC_CPPCompileAlways>
-    <PackageImports>rtl.bpi;vcl.bpi;bcbie.bpi;vclx.bpi;vclactnband.bpi;xmlrtl.bpi;bcbsmp.bpi;dbrtl.bpi;vcldb.bpi;bdertl.bpi;vcldbx.bpi;dsnap.bpi;dsnapcon.bpi;vclib.bpi;ibxpress.bpi;adortl.bpi;dbxcds.bpi;dbexpress.bpi;DbxCommonDriver.bpi;websnap.bpi;vclie.bpi;webdsnap.bpi;inet.bpi;inetdbbde.bpi;inetdbxpress.bpi;soaprtl.bpi;Rave75VCL.bpi;teeUI.bpi;tee.bpi;teedb.bpi;IndyCore.bpi;IndySystem.bpi;IndyProtocols.bpi;IntrawebDB_90_100.bpi;Intraweb_90_100.bpi;Jcl.bpi;JclVcl.bpi;JvCoreD11R.bpi;JvSystemD11R.bpi;JvStdCtrlsD11R.bpi;JvAppFrmD11R.bpi;JvBandsD11R.bpi;JvDBD11R.bpi;JvDlgsD11R.bpi;JvBDED11R.bpi;JvCmpD11R.bpi;JvCryptD11R.bpi;JvCtrlsD11R.bpi;JvCustomD11R.bpi;JvDockingD11R.bpi;JvDotNetCtrlsD11R.bpi;JvEDID11R.bpi;JvGlobusD11R.bpi;JvHMID11R.bpi;JvInterpreterD11R.bpi;JvJansD11R.bpi;JvManagedThreadsD11R.bpi;JvMMD11R.bpi;JvNetD11R.bpi;JvPageCompsD11R.bpi;JvPluginD11R.bpi;JvPrintPreviewD11R.bpi;JvRuntimeDesignD11R.bpi;JvTimeFrameworkD11R.bpi;JvValidatorsD11R.bpi;JvWizardD11R.bpi;JvXPCtrlsD11R.bpi;VclSmp.bpi</PackageImports>
-    <BCC_wpar>false</BCC_wpar>
-    <IncludePath>$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\include;..\test;..</IncludePath>
-    <ILINK_LibraryPath>$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk;..\test</ILINK_LibraryPath>
-    <Multithreaded>true</Multithreaded>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Cfg_1)'!=''">
-    <BCC_OptimizeForSpeed>false</BCC_OptimizeForSpeed>
-    <DCC_Optimize>false</DCC_Optimize>
-    <DCC_DebugInfoInExe>true</DCC_DebugInfoInExe>
-    <Defines>_DEBUG;$(Defines)</Defines>
-    <ILINK_FullDebugInfo>true</ILINK_FullDebugInfo>
-    <BCC_InlineFunctionExpansion>false</BCC_InlineFunctionExpansion>
-    <ILINK_DisableIncrementalLinking>true</ILINK_DisableIncrementalLinking>
-    <BCC_UseRegisterVariables>None</BCC_UseRegisterVariables>
-    <DCC_Define>DEBUG</DCC_Define>
-    <BCC_DebugLineNumbers>true</BCC_DebugLineNumbers>
-    <IntermediateOutputDir>Debug</IntermediateOutputDir>
-    <TASM_DisplaySourceLines>true</TASM_DisplaySourceLines>
-    <BCC_StackFrames>true</BCC_StackFrames>
-    <BCC_DisableOptimizations>true</BCC_DisableOptimizations>
-    <ILINK_LibraryPath>$(BDS)\lib\debug;$(ILINK_LibraryPath)</ILINK_LibraryPath>
-    <TASM_Debugging>Full</TASM_Debugging>
-    <BCC_SourceDebuggingOn>true</BCC_SourceDebuggingOn>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Cfg_2)'!=''">
-    <Defines>NDEBUG;$(Defines)</Defines>
-    <IntermediateOutputDir>Release</IntermediateOutputDir>
-    <ILINK_LibraryPath>$(BDS)\lib\release;$(ILINK_LibraryPath)</ILINK_LibraryPath>
-    <TASM_Debugging>None</TASM_Debugging>
-  </PropertyGroup>
-  <ProjectExtensions>
-    <Borland.Personality>CPlusPlusBuilder.Personality</Borland.Personality>
-    <Borland.ProjectType>CppConsoleApplication</Borland.ProjectType>
-    <BorlandProject>
-<BorlandProject><CPlusPlusBuilder.Personality><VersionInfo><VersionInfo Name="IncludeVerInfo">False</VersionInfo><VersionInfo Name="AutoIncBuild">False</VersionInfo><VersionInfo Name="MajorVer">1</VersionInfo><VersionInfo Name="MinorVer">0</VersionInfo><VersionInfo Name="Release">0</VersionInfo><VersionInfo Name="Build">0</VersionInfo><VersionInfo Name="Debug">False</VersionInfo><VersionInfo Name="PreRelease">False</VersionInfo><VersionInfo Name="Special">False</VersionInfo><VersionInfo Name="Private">False</VersionInfo><VersionInfo Name="DLL">False</VersionInfo><VersionInfo Name="Locale">1033</VersionInfo><VersionInfo Name="CodePage">1252</VersionInfo></VersionInfo><VersionInfoKeys><VersionInfoKeys Name="CompanyName"></VersionInfoKeys><VersionInfoKeys Name="FileDescription"></VersionInfoKeys><VersionInfoKeys Name="FileVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="InternalName"></VersionInfoKeys><VersionInfoKeys Name="LegalCopyright"></VersionInfoKeys><VersionInfoKeys Name="LegalTrademarks"></VersionInfoKeys><VersionInfoKeys Name="OriginalFilename"></VersionInfoKeys><VersionInfoKeys Name="ProductName"></VersionInfoKeys><VersionInfoKeys Name="ProductVersion">1.0.0.0</VersionInfoKeys><VersionInfoKeys Name="Comments"></VersionInfoKeys></VersionInfoKeys><Debugging><Debugging Name="DebugSourceDirs"></Debugging></Debugging><Parameters><Parameters Name="RunParams"></Parameters><Parameters Name="Launcher"></Parameters><Parameters Name="UseLauncher">False</Parameters><Parameters Name="DebugCWD"></Parameters><Parameters Name="HostApplication"></Parameters><Parameters Name="RemoteHost"></Parameters><Parameters Name="RemotePath"></Parameters><Parameters Name="RemoteParams"></Parameters><Parameters Name="RemoteLauncher"></Parameters><Parameters Name="UseRemoteLauncher">False</Parameters><Parameters Name="RemoteCWD"></Parameters><Parameters Name="RemoteDebug">False</Parameters><Parameters Name="Debug Symbols Search Path"></Parameters><Parameters Name="LoadAllSymbols">True</Parameters><Parameters Name="LoadUnspecifiedSymbols">False</Parameters></Parameters><Excluded_Packages>
-      
-      
-      <Excluded_Packages Name="$(BDS)\bin\bcboffice2k100.bpl">CodeGear C++Builder Office 2000 Servers Package</Excluded_Packages>
-      <Excluded_Packages Name="$(BDS)\bin\bcbofficexp100.bpl">CodeGear C++Builder Office XP Servers Package</Excluded_Packages>
-    </Excluded_Packages><Linker><Linker Name="LibPrefix"></Linker><Linker Name="LibSuffix"></Linker><Linker Name="LibVersion"></Linker></Linker><ProjectProperties><ProjectProperties Name="AutoShowDeps">False</ProjectProperties><ProjectProperties Name="ManagePaths">True</ProjectProperties><ProjectProperties Name="VerifyPackages">True</ProjectProperties></ProjectProperties><HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Count">3</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item0">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\include;..\test;..</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item1">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\include;..\test</HistoryLists_hlIncludePath><HistoryLists_hlIncludePath Name="Item2">$(BDS)\include;$(BDS)\include\dinkumware;$(BDS)\include\vcl;..\include</HistoryLists_hlIncludePath></HistoryLists_hlIncludePath><HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Count">1</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item0">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk;..\test</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item1">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk;..\test</HistoryLists_hlILINK_LibraryPath><HistoryLists_hlILINK_LibraryPath Name="Item2">$(BDS)\lib;$(BDS)\lib\obj;$(BDS)\lib\psdk;$(OUTPUTDIR);..\test</HistoryLists_hlILINK_LibraryPath></HistoryLists_hlILINK_LibraryPath><HistoryLists_hlDefines><HistoryLists_hlDefines Name="Count">2</HistoryLists_hlDefines><HistoryLists_hlDefines Name="Item0">NO_STRICT</HistoryLists_hlDefines><HistoryLists_hlDefines Name="Item1">STRICT</HistoryLists_hlDefines></HistoryLists_hlDefines></CPlusPlusBuilder.Personality></BorlandProject></BorlandProject>
-  </ProjectExtensions>
-  <Import Project="$(MSBuildBinPath)\Borland.Cpp.Targets" />
-  <ItemGroup>
-    <CppCompile Include="..\test\gtest_unittest.cc">
-      <BuildOrder>0</BuildOrder>
-    </CppCompile>
-    <CppCompile Include="gtest_link.cc">
-      <BuildOrder>1</BuildOrder>
-    </CppCompile>
-    <BuildConfiguration Include="Debug">
-      <Key>Cfg_1</Key>
-    </BuildConfiguration>
-    <BuildConfiguration Include="Release">
-      <Key>Cfg_2</Key>
-    </BuildConfiguration>
-  </ItemGroup>
-</Project>
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/configure.ac b/week4/softwareEng_9_4/vendor/googletest/googletest/configure.ac
deleted file mode 100644
index cc592e15..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/configure.ac
+++ /dev/null
@@ -1,68 +0,0 @@
-m4_include(m4/acx_pthread.m4)
-
-# At this point, the Xcode project assumes the version string will be three
-# integers separated by periods and surrounded by square brackets (e.g.
-# "[1.0.1]"). It also asumes that there won't be any closing parenthesis
-# between "AC_INIT(" and the closing ")" including comments and strings.
-AC_INIT([Google C++ Testing Framework],
-        [1.7.0],
-        [googletestframework@googlegroups.com],
-        [gtest])
-
-# Provide various options to initialize the Autoconf and configure processes.
-AC_PREREQ([2.59])
-AC_CONFIG_SRCDIR([./LICENSE])
-AC_CONFIG_MACRO_DIR([m4])
-AC_CONFIG_AUX_DIR([build-aux])
-AC_CONFIG_HEADERS([build-aux/config.h])
-AC_CONFIG_FILES([Makefile])
-AC_CONFIG_FILES([scripts/gtest-config], [chmod +x scripts/gtest-config])
-
-# Initialize Automake with various options. We require at least v1.9, prevent
-# pedantic complaints about package files, and enable various distribution
-# targets.
-AM_INIT_AUTOMAKE([1.9 dist-bzip2 dist-zip foreign subdir-objects])
-
-# Check for programs used in building Google Test.
-AC_PROG_CC
-AC_PROG_CXX
-AC_LANG([C++])
-AC_PROG_LIBTOOL
-
-# TODO(chandlerc@google.com): Currently we aren't running the Python tests
-# against the interpreter detected by AM_PATH_PYTHON, and so we condition
-# HAVE_PYTHON by requiring "python" to be in the PATH, and that interpreter's
-# version to be >= 2.3. This will allow the scripts to use a "/usr/bin/env"
-# hashbang.
-PYTHON=  # We *do not* allow the user to specify a python interpreter
-AC_PATH_PROG([PYTHON],[python],[:])
-AS_IF([test "$PYTHON" != ":"],
-      [AM_PYTHON_CHECK_VERSION([$PYTHON],[2.3],[:],[PYTHON=":"])])
-AM_CONDITIONAL([HAVE_PYTHON],[test "$PYTHON" != ":"])
-
-# Configure pthreads.
-AC_ARG_WITH([pthreads],
-            [AS_HELP_STRING([--with-pthreads],
-               [use pthreads (default is yes)])],
-            [with_pthreads=$withval],
-            [with_pthreads=check])
-
-have_pthreads=no
-AS_IF([test "x$with_pthreads" != "xno"],
-      [ACX_PTHREAD(
-        [],
-        [AS_IF([test "x$with_pthreads" != "xcheck"],
-               [AC_MSG_FAILURE(
-                 [--with-pthreads was specified, but unable to be used])])])
-       have_pthreads="$acx_pthread_ok"])
-AM_CONDITIONAL([HAVE_PTHREADS],[test "x$have_pthreads" = "xyes"])
-AC_SUBST(PTHREAD_CFLAGS)
-AC_SUBST(PTHREAD_LIBS)
-
-# TODO(chandlerc@google.com) Check for the necessary system headers.
-
-# TODO(chandlerc@google.com) Check the types, structures, and other compiler
-# and architecture characteristics.
-
-# Output the generated files. No further autoconf macros may be used.
-AC_OUTPUT
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/AdvancedGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/AdvancedGuide.md
deleted file mode 100644
index 93a65200..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/AdvancedGuide.md
+++ /dev/null
@@ -1,2182 +0,0 @@
-
-
-Now that you have read [Primer](Primer.md) and learned how to write tests
-using Google Test, it's time to learn some new tricks. This document
-will show you more assertions as well as how to construct complex
-failure messages, propagate fatal failures, reuse and speed up your
-test fixtures, and use various flags with your tests.
-
-# More Assertions #
-
-This section covers some less frequently used, but still significant,
-assertions.
-
-## Explicit Success and Failure ##
-
-These three assertions do not actually test a value or expression. Instead,
-they generate a success or failure directly. Like the macros that actually
-perform a test, you may stream a custom failure message into the them.
-
-| `SUCCEED();` |
-|:-------------|
-
-Generates a success. This does NOT make the overall test succeed. A test is
-considered successful only if none of its assertions fail during its execution.
-
-Note: `SUCCEED()` is purely documentary and currently doesn't generate any
-user-visible output. However, we may add `SUCCEED()` messages to Google Test's
-output in the future.
-
-| `FAIL();`  | `ADD_FAILURE();` | `ADD_FAILURE_AT("`_file\_path_`", `_line\_number_`);` |
-|:-----------|:-----------------|:------------------------------------------------------|
-
-`FAIL()` generates a fatal failure, while `ADD_FAILURE()` and `ADD_FAILURE_AT()` generate a nonfatal
-failure. These are useful when control flow, rather than a Boolean expression,
-deteremines the test's success or failure. For example, you might want to write
-something like:
-
-```
-switch(expression) {
-  case 1: ... some checks ...
-  case 2: ... some other checks
-  ...
-  default: FAIL() << "We shouldn't get here.";
-}
-```
-
-Note: you can only use `FAIL()` in functions that return `void`. See the [Assertion Placement section](#assertion-placement) for more information.
-
-_Availability_: Linux, Windows, Mac.
-
-## Exception Assertions ##
-
-These are for verifying that a piece of code throws (or does not
-throw) an exception of the given type:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_THROW(`_statement_, _exception\_type_`);`  | `EXPECT_THROW(`_statement_, _exception\_type_`);`  | _statement_ throws an exception of the given type  |
-| `ASSERT_ANY_THROW(`_statement_`);`                | `EXPECT_ANY_THROW(`_statement_`);`                | _statement_ throws an exception of any type        |
-| `ASSERT_NO_THROW(`_statement_`);`                 | `EXPECT_NO_THROW(`_statement_`);`                 | _statement_ doesn't throw any exception            |
-
-Examples:
-
-```
-ASSERT_THROW(Foo(5), bar_exception);
-
-EXPECT_NO_THROW({
-  int n = 5;
-  Bar(&n);
-});
-```
-
-_Availability_: Linux, Windows, Mac; since version 1.1.0.
-
-## Predicate Assertions for Better Error Messages ##
-
-Even though Google Test has a rich set of assertions, they can never be
-complete, as it's impossible (nor a good idea) to anticipate all the scenarios
-a user might run into. Therefore, sometimes a user has to use `EXPECT_TRUE()`
-to check a complex expression, for lack of a better macro. This has the problem
-of not showing you the values of the parts of the expression, making it hard to
-understand what went wrong. As a workaround, some users choose to construct the
-failure message by themselves, streaming it into `EXPECT_TRUE()`. However, this
-is awkward especially when the expression has side-effects or is expensive to
-evaluate.
-
-Google Test gives you three different options to solve this problem:
-
-### Using an Existing Boolean Function ###
-
-If you already have a function or a functor that returns `bool` (or a type
-that can be implicitly converted to `bool`), you can use it in a _predicate
-assertion_ to get the function arguments printed for free:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_PRED1(`_pred1, val1_`);`       | `EXPECT_PRED1(`_pred1, val1_`);` | _pred1(val1)_ returns true |
-| `ASSERT_PRED2(`_pred2, val1, val2_`);` | `EXPECT_PRED2(`_pred2, val1, val2_`);` |  _pred2(val1, val2)_ returns true |
-|  ...                | ...                    | ...          |
-
-In the above, _predn_ is an _n_-ary predicate function or functor, where
-_val1_, _val2_, ..., and _valn_ are its arguments. The assertion succeeds
-if the predicate returns `true` when applied to the given arguments, and fails
-otherwise. When the assertion fails, it prints the value of each argument. In
-either case, the arguments are evaluated exactly once.
-
-Here's an example. Given
-
-```
-// Returns true iff m and n have no common divisors except 1.
-bool MutuallyPrime(int m, int n) { ... }
-const int a = 3;
-const int b = 4;
-const int c = 10;
-```
-
-the assertion `EXPECT_PRED2(MutuallyPrime, a, b);` will succeed, while the
-assertion `EXPECT_PRED2(MutuallyPrime, b, c);` will fail with the message
-
-<pre>
-!MutuallyPrime(b, c) is false, where<br>
-b is 4<br>
-c is 10<br>
-</pre>
-
-**Notes:**
-
-  1. If you see a compiler error "no matching function to call" when using `ASSERT_PRED*` or `EXPECT_PRED*`, please see [this FAQ](FAQ.md#the-compiler-complains-no-matching-function-to-call-when-i-use-assert_predn-how-do-i-fix-it) for how to resolve it.
-  1. Currently we only provide predicate assertions of arity <= 5. If you need a higher-arity assertion, let us know.
-
-_Availability_: Linux, Windows, Mac
-
-### Using a Function That Returns an AssertionResult ###
-
-While `EXPECT_PRED*()` and friends are handy for a quick job, the
-syntax is not satisfactory: you have to use different macros for
-different arities, and it feels more like Lisp than C++.  The
-`::testing::AssertionResult` class solves this problem.
-
-An `AssertionResult` object represents the result of an assertion
-(whether it's a success or a failure, and an associated message).  You
-can create an `AssertionResult` using one of these factory
-functions:
-
-```
-namespace testing {
-
-// Returns an AssertionResult object to indicate that an assertion has
-// succeeded.
-AssertionResult AssertionSuccess();
-
-// Returns an AssertionResult object to indicate that an assertion has
-// failed.
-AssertionResult AssertionFailure();
-
-}
-```
-
-You can then use the `<<` operator to stream messages to the
-`AssertionResult` object.
-
-To provide more readable messages in Boolean assertions
-(e.g. `EXPECT_TRUE()`), write a predicate function that returns
-`AssertionResult` instead of `bool`. For example, if you define
-`IsEven()` as:
-
-```
-::testing::AssertionResult IsEven(int n) {
-  if ((n % 2) == 0)
-    return ::testing::AssertionSuccess();
-  else
-    return ::testing::AssertionFailure() << n << " is odd";
-}
-```
-
-instead of:
-
-```
-bool IsEven(int n) {
-  return (n % 2) == 0;
-}
-```
-
-the failed assertion `EXPECT_TRUE(IsEven(Fib(4)))` will print:
-
-<pre>
-Value of: IsEven(Fib(4))<br>
-Actual: false (*3 is odd*)<br>
-Expected: true<br>
-</pre>
-
-instead of a more opaque
-
-<pre>
-Value of: IsEven(Fib(4))<br>
-Actual: false<br>
-Expected: true<br>
-</pre>
-
-If you want informative messages in `EXPECT_FALSE` and `ASSERT_FALSE`
-as well, and are fine with making the predicate slower in the success
-case, you can supply a success message:
-
-```
-::testing::AssertionResult IsEven(int n) {
-  if ((n % 2) == 0)
-    return ::testing::AssertionSuccess() << n << " is even";
-  else
-    return ::testing::AssertionFailure() << n << " is odd";
-}
-```
-
-Then the statement `EXPECT_FALSE(IsEven(Fib(6)))` will print
-
-<pre>
-Value of: IsEven(Fib(6))<br>
-Actual: true (8 is even)<br>
-Expected: false<br>
-</pre>
-
-_Availability_: Linux, Windows, Mac; since version 1.4.1.
-
-### Using a Predicate-Formatter ###
-
-If you find the default message generated by `(ASSERT|EXPECT)_PRED*` and
-`(ASSERT|EXPECT)_(TRUE|FALSE)` unsatisfactory, or some arguments to your
-predicate do not support streaming to `ostream`, you can instead use the
-following _predicate-formatter assertions_ to _fully_ customize how the
-message is formatted:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_PRED_FORMAT1(`_pred\_format1, val1_`);`        | `EXPECT_PRED_FORMAT1(`_pred\_format1, val1_`);` | _pred\_format1(val1)_ is successful |
-| `ASSERT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | `EXPECT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | _pred\_format2(val1, val2)_ is successful |
-| `...`               | `...`                  | `...`        |
-
-The difference between this and the previous two groups of macros is that instead of
-a predicate, `(ASSERT|EXPECT)_PRED_FORMAT*` take a _predicate-formatter_
-(_pred\_formatn_), which is a function or functor with the signature:
-
-`::testing::AssertionResult PredicateFormattern(const char* `_expr1_`, const char* `_expr2_`, ... const char* `_exprn_`, T1 `_val1_`, T2 `_val2_`, ... Tn `_valn_`);`
-
-where _val1_, _val2_, ..., and _valn_ are the values of the predicate
-arguments, and _expr1_, _expr2_, ..., and _exprn_ are the corresponding
-expressions as they appear in the source code. The types `T1`, `T2`, ..., and
-`Tn` can be either value types or reference types. For example, if an
-argument has type `Foo`, you can declare it as either `Foo` or `const Foo&`,
-whichever is appropriate.
-
-A predicate-formatter returns a `::testing::AssertionResult` object to indicate
-whether the assertion has succeeded or not. The only way to create such an
-object is to call one of these factory functions:
-
-As an example, let's improve the failure message in the previous example, which uses `EXPECT_PRED2()`:
-
-```
-// Returns the smallest prime common divisor of m and n,
-// or 1 when m and n are mutually prime.
-int SmallestPrimeCommonDivisor(int m, int n) { ... }
-
-// A predicate-formatter for asserting that two integers are mutually prime.
-::testing::AssertionResult AssertMutuallyPrime(const char* m_expr,
-                                               const char* n_expr,
-                                               int m,
-                                               int n) {
-  if (MutuallyPrime(m, n))
-    return ::testing::AssertionSuccess();
-
-  return ::testing::AssertionFailure()
-      << m_expr << " and " << n_expr << " (" << m << " and " << n
-      << ") are not mutually prime, " << "as they have a common divisor "
-      << SmallestPrimeCommonDivisor(m, n);
-}
-```
-
-With this predicate-formatter, we can use
-
-```
-EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c);
-```
-
-to generate the message
-
-<pre>
-b and c (4 and 10) are not mutually prime, as they have a common divisor 2.<br>
-</pre>
-
-As you may have realized, many of the assertions we introduced earlier are
-special cases of `(EXPECT|ASSERT)_PRED_FORMAT*`. In fact, most of them are
-indeed defined using `(EXPECT|ASSERT)_PRED_FORMAT*`.
-
-_Availability_: Linux, Windows, Mac.
-
-
-## Floating-Point Comparison ##
-
-Comparing floating-point numbers is tricky. Due to round-off errors, it is
-very unlikely that two floating-points will match exactly. Therefore,
-`ASSERT_EQ` 's naive comparison usually doesn't work. And since floating-points
-can have a wide value range, no single fixed error bound works. It's better to
-compare by a fixed relative error bound, except for values close to 0 due to
-the loss of precision there.
-
-In general, for floating-point comparison to make sense, the user needs to
-carefully choose the error bound. If they don't want or care to, comparing in
-terms of Units in the Last Place (ULPs) is a good default, and Google Test
-provides assertions to do this. Full details about ULPs are quite long; if you
-want to learn more, see
-[this article on float comparison](http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm).
-
-### Floating-Point Macros ###
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_FLOAT_EQ(`_val1, val2_`);`  | `EXPECT_FLOAT_EQ(`_val1, val2_`);` | the two `float` values are almost equal |
-| `ASSERT_DOUBLE_EQ(`_val1, val2_`);` | `EXPECT_DOUBLE_EQ(`_val1, val2_`);` | the two `double` values are almost equal |
-
-By "almost equal", we mean the two values are within 4 ULP's from each
-other.
-
-The following assertions allow you to choose the acceptable error bound:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_NEAR(`_val1, val2, abs\_error_`);` | `EXPECT_NEAR`_(val1, val2, abs\_error_`);` | the difference between _val1_ and _val2_ doesn't exceed the given absolute error |
-
-_Availability_: Linux, Windows, Mac.
-
-### Floating-Point Predicate-Format Functions ###
-
-Some floating-point operations are useful, but not that often used. In order
-to avoid an explosion of new macros, we provide them as predicate-format
-functions that can be used in predicate assertion macros (e.g.
-`EXPECT_PRED_FORMAT2`, etc).
-
-```
-EXPECT_PRED_FORMAT2(::testing::FloatLE, val1, val2);
-EXPECT_PRED_FORMAT2(::testing::DoubleLE, val1, val2);
-```
-
-Verifies that _val1_ is less than, or almost equal to, _val2_. You can
-replace `EXPECT_PRED_FORMAT2` in the above table with `ASSERT_PRED_FORMAT2`.
-
-_Availability_: Linux, Windows, Mac.
-
-## Windows HRESULT assertions ##
-
-These assertions test for `HRESULT` success or failure.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_HRESULT_SUCCEEDED(`_expression_`);` | `EXPECT_HRESULT_SUCCEEDED(`_expression_`);` | _expression_ is a success `HRESULT` |
-| `ASSERT_HRESULT_FAILED(`_expression_`);`    | `EXPECT_HRESULT_FAILED(`_expression_`);`    | _expression_ is a failure `HRESULT` |
-
-The generated output contains the human-readable error message
-associated with the `HRESULT` code returned by _expression_.
-
-You might use them like this:
-
-```
-CComPtr shell;
-ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application"));
-CComVariant empty;
-ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty));
-```
-
-_Availability_: Windows.
-
-## Type Assertions ##
-
-You can call the function
-```
-::testing::StaticAssertTypeEq<T1, T2>();
-```
-to assert that types `T1` and `T2` are the same.  The function does
-nothing if the assertion is satisfied.  If the types are different,
-the function call will fail to compile, and the compiler error message
-will likely (depending on the compiler) show you the actual values of
-`T1` and `T2`.  This is mainly useful inside template code.
-
-_Caveat:_ When used inside a member function of a class template or a
-function template, `StaticAssertTypeEq<T1, T2>()` is effective _only if_
-the function is instantiated.  For example, given:
-```
-template <typename T> class Foo {
- public:
-  void Bar() { ::testing::StaticAssertTypeEq<int, T>(); }
-};
-```
-the code:
-```
-void Test1() { Foo<bool> foo; }
-```
-will _not_ generate a compiler error, as `Foo<bool>::Bar()` is never
-actually instantiated.  Instead, you need:
-```
-void Test2() { Foo<bool> foo; foo.Bar(); }
-```
-to cause a compiler error.
-
-_Availability:_ Linux, Windows, Mac; since version 1.3.0.
-
-## Assertion Placement ##
-
-You can use assertions in any C++ function. In particular, it doesn't
-have to be a method of the test fixture class. The one constraint is
-that assertions that generate a fatal failure (`FAIL*` and `ASSERT_*`)
-can only be used in void-returning functions. This is a consequence of
-Google Test not using exceptions. By placing it in a non-void function
-you'll get a confusing compile error like
-`"error: void value not ignored as it ought to be"`.
-
-If you need to use assertions in a function that returns non-void, one option
-is to make the function return the value in an out parameter instead. For
-example, you can rewrite `T2 Foo(T1 x)` to `void Foo(T1 x, T2* result)`. You
-need to make sure that `*result` contains some sensible value even when the
-function returns prematurely. As the function now returns `void`, you can use
-any assertion inside of it.
-
-If changing the function's type is not an option, you should just use
-assertions that generate non-fatal failures, such as `ADD_FAILURE*` and
-`EXPECT_*`.
-
-_Note_: Constructors and destructors are not considered void-returning
-functions, according to the C++ language specification, and so you may not use
-fatal assertions in them. You'll get a compilation error if you try. A simple
-workaround is to transfer the entire body of the constructor or destructor to a
-private void-returning method. However, you should be aware that a fatal
-assertion failure in a constructor does not terminate the current test, as your
-intuition might suggest; it merely returns from the constructor early, possibly
-leaving your object in a partially-constructed state. Likewise, a fatal
-assertion failure in a destructor may leave your object in a
-partially-destructed state. Use assertions carefully in these situations!
-
-# Teaching Google Test How to Print Your Values #
-
-When a test assertion such as `EXPECT_EQ` fails, Google Test prints the
-argument values to help you debug.  It does this using a
-user-extensible value printer.
-
-This printer knows how to print built-in C++ types, native arrays, STL
-containers, and any type that supports the `<<` operator.  For other
-types, it prints the raw bytes in the value and hopes that you the
-user can figure it out.
-
-As mentioned earlier, the printer is _extensible_.  That means
-you can teach it to do a better job at printing your particular type
-than to dump the bytes.  To do that, define `<<` for your type:
-
-```
-#include <iostream>
-
-namespace foo {
-
-class Bar { ... };  // We want Google Test to be able to print instances of this.
-
-// It's important that the << operator is defined in the SAME
-// namespace that defines Bar.  C++'s look-up rules rely on that.
-::std::ostream& operator<<(::std::ostream& os, const Bar& bar) {
-  return os << bar.DebugString();  // whatever needed to print bar to os
-}
-
-}  // namespace foo
-```
-
-Sometimes, this might not be an option: your team may consider it bad
-style to have a `<<` operator for `Bar`, or `Bar` may already have a
-`<<` operator that doesn't do what you want (and you cannot change
-it).  If so, you can instead define a `PrintTo()` function like this:
-
-```
-#include <iostream>
-
-namespace foo {
-
-class Bar { ... };
-
-// It's important that PrintTo() is defined in the SAME
-// namespace that defines Bar.  C++'s look-up rules rely on that.
-void PrintTo(const Bar& bar, ::std::ostream* os) {
-  *os << bar.DebugString();  // whatever needed to print bar to os
-}
-
-}  // namespace foo
-```
-
-If you have defined both `<<` and `PrintTo()`, the latter will be used
-when Google Test is concerned.  This allows you to customize how the value
-appears in Google Test's output without affecting code that relies on the
-behavior of its `<<` operator.
-
-If you want to print a value `x` using Google Test's value printer
-yourself, just call `::testing::PrintToString(`_x_`)`, which
-returns an `std::string`:
-
-```
-vector<pair<Bar, int> > bar_ints = GetBarIntVector();
-
-EXPECT_TRUE(IsCorrectBarIntVector(bar_ints))
-    << "bar_ints = " << ::testing::PrintToString(bar_ints);
-```
-
-# Death Tests #
-
-In many applications, there are assertions that can cause application failure
-if a condition is not met. These sanity checks, which ensure that the program
-is in a known good state, are there to fail at the earliest possible time after
-some program state is corrupted. If the assertion checks the wrong condition,
-then the program may proceed in an erroneous state, which could lead to memory
-corruption, security holes, or worse. Hence it is vitally important to test
-that such assertion statements work as expected.
-
-Since these precondition checks cause the processes to die, we call such tests
-_death tests_. More generally, any test that checks that a program terminates
-(except by throwing an exception) in an expected fashion is also a death test.
-
-Note that if a piece of code throws an exception, we don't consider it "death"
-for the purpose of death tests, as the caller of the code could catch the exception
-and avoid the crash. If you want to verify exceptions thrown by your code,
-see [Exception Assertions](#exception-assertions).
-
-If you want to test `EXPECT_*()/ASSERT_*()` failures in your test code, see [Catching Failures](#catching-failures).
-
-## How to Write a Death Test ##
-
-Google Test has the following macros to support death tests:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_DEATH(`_statement, regex_`);` | `EXPECT_DEATH(`_statement, regex_`);` | _statement_ crashes with the given error |
-| `ASSERT_DEATH_IF_SUPPORTED(`_statement, regex_`);` | `EXPECT_DEATH_IF_SUPPORTED(`_statement, regex_`);` | if death tests are supported, verifies that _statement_ crashes with the given error; otherwise verifies nothing |
-| `ASSERT_EXIT(`_statement, predicate, regex_`);` | `EXPECT_EXIT(`_statement, predicate, regex_`);` |_statement_ exits with the given error and its exit code matches _predicate_ |
-
-where _statement_ is a statement that is expected to cause the process to
-die, _predicate_ is a function or function object that evaluates an integer
-exit status, and _regex_ is a regular expression that the stderr output of
-_statement_ is expected to match. Note that _statement_ can be _any valid
-statement_ (including _compound statement_) and doesn't have to be an
-expression.
-
-As usual, the `ASSERT` variants abort the current test function, while the
-`EXPECT` variants do not.
-
-**Note:** We use the word "crash" here to mean that the process
-terminates with a _non-zero_ exit status code.  There are two
-possibilities: either the process has called `exit()` or `_exit()`
-with a non-zero value, or it may be killed by a signal.
-
-This means that if _statement_ terminates the process with a 0 exit
-code, it is _not_ considered a crash by `EXPECT_DEATH`.  Use
-`EXPECT_EXIT` instead if this is the case, or if you want to restrict
-the exit code more precisely.
-
-A predicate here must accept an `int` and return a `bool`. The death test
-succeeds only if the predicate returns `true`. Google Test defines a few
-predicates that handle the most common cases:
-
-```
-::testing::ExitedWithCode(exit_code)
-```
-
-This expression is `true` if the program exited normally with the given exit
-code.
-
-```
-::testing::KilledBySignal(signal_number)  // Not available on Windows.
-```
-
-This expression is `true` if the program was killed by the given signal.
-
-The `*_DEATH` macros are convenient wrappers for `*_EXIT` that use a predicate
-that verifies the process' exit code is non-zero.
-
-Note that a death test only cares about three things:
-
-  1. does _statement_ abort or exit the process?
-  1. (in the case of `ASSERT_EXIT` and `EXPECT_EXIT`) does the exit status satisfy _predicate_?  Or (in the case of `ASSERT_DEATH` and `EXPECT_DEATH`) is the exit status non-zero?  And
-  1. does the stderr output match _regex_?
-
-In particular, if _statement_ generates an `ASSERT_*` or `EXPECT_*` failure, it will **not** cause the death test to fail, as Google Test assertions don't abort the process.
-
-To write a death test, simply use one of the above macros inside your test
-function. For example,
-
-```
-TEST(MyDeathTest, Foo) {
-  // This death test uses a compound statement.
-  ASSERT_DEATH({ int n = 5; Foo(&n); }, "Error on line .* of Foo()");
-}
-TEST(MyDeathTest, NormalExit) {
-  EXPECT_EXIT(NormalExit(), ::testing::ExitedWithCode(0), "Success");
-}
-TEST(MyDeathTest, KillMyself) {
-  EXPECT_EXIT(KillMyself(), ::testing::KilledBySignal(SIGKILL), "Sending myself unblockable signal");
-}
-```
-
-verifies that:
-
-  * calling `Foo(5)` causes the process to die with the given error message,
-  * calling `NormalExit()` causes the process to print `"Success"` to stderr and exit with exit code 0, and
-  * calling `KillMyself()` kills the process with signal `SIGKILL`.
-
-The test function body may contain other assertions and statements as well, if
-necessary.
-
-_Important:_ We strongly recommend you to follow the convention of naming your
-test case (not test) `*DeathTest` when it contains a death test, as
-demonstrated in the above example. The `Death Tests And Threads` section below
-explains why.
-
-If a test fixture class is shared by normal tests and death tests, you
-can use typedef to introduce an alias for the fixture class and avoid
-duplicating its code:
-```
-class FooTest : public ::testing::Test { ... };
-
-typedef FooTest FooDeathTest;
-
-TEST_F(FooTest, DoesThis) {
-  // normal test
-}
-
-TEST_F(FooDeathTest, DoesThat) {
-  // death test
-}
-```
-
-_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Cygwin, and Mac (the latter three are supported since v1.3.0).  `(ASSERT|EXPECT)_DEATH_IF_SUPPORTED` are new in v1.4.0.
-
-## Regular Expression Syntax ##
-
-On POSIX systems (e.g. Linux, Cygwin, and Mac), Google Test uses the
-[POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
-syntax in death tests. To learn about this syntax, you may want to read this [Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
-
-On Windows, Google Test uses its own simple regular expression
-implementation. It lacks many features you can find in POSIX extended
-regular expressions.  For example, we don't support union (`"x|y"`),
-grouping (`"(xy)"`), brackets (`"[xy]"`), and repetition count
-(`"x{5,7}"`), among others. Below is what we do support (Letter `A` denotes a
-literal character, period (`.`), or a single `\\` escape sequence; `x`
-and `y` denote regular expressions.):
-
-| `c` | matches any literal character `c` |
-|:----|:----------------------------------|
-| `\\d` | matches any decimal digit         |
-| `\\D` | matches any character that's not a decimal digit |
-| `\\f` | matches `\f`                      |
-| `\\n` | matches `\n`                      |
-| `\\r` | matches `\r`                      |
-| `\\s` | matches any ASCII whitespace, including `\n` |
-| `\\S` | matches any character that's not a whitespace |
-| `\\t` | matches `\t`                      |
-| `\\v` | matches `\v`                      |
-| `\\w` | matches any letter, `_`, or decimal digit |
-| `\\W` | matches any character that `\\w` doesn't match |
-| `\\c` | matches any literal character `c`, which must be a punctuation |
-| `\\.` | matches the `.` character         |
-| `.` | matches any single character except `\n` |
-| `A?` | matches 0 or 1 occurrences of `A` |
-| `A*` | matches 0 or many occurrences of `A` |
-| `A+` | matches 1 or many occurrences of `A` |
-| `^` | matches the beginning of a string (not that of each line) |
-| `$` | matches the end of a string (not that of each line) |
-| `xy` | matches `x` followed by `y`       |
-
-To help you determine which capability is available on your system,
-Google Test defines macro `GTEST_USES_POSIX_RE=1` when it uses POSIX
-extended regular expressions, or `GTEST_USES_SIMPLE_RE=1` when it uses
-the simple version.  If you want your death tests to work in both
-cases, you can either `#if` on these macros or use the more limited
-syntax only.
-
-## How It Works ##
-
-Under the hood, `ASSERT_EXIT()` spawns a new process and executes the
-death test statement in that process. The details of of how precisely
-that happens depend on the platform and the variable
-`::testing::GTEST_FLAG(death_test_style)` (which is initialized from the
-command-line flag `--gtest_death_test_style`).
-
-  * On POSIX systems, `fork()` (or `clone()` on Linux) is used to spawn the child, after which:
-    * If the variable's value is `"fast"`, the death test statement is immediately executed.
-    * If the variable's value is `"threadsafe"`, the child process re-executes the unit test binary just as it was originally invoked, but with some extra flags to cause just the single death test under consideration to be run.
-  * On Windows, the child is spawned using the `CreateProcess()` API, and re-executes the binary to cause just the single death test under consideration to be run - much like the `threadsafe` mode on POSIX.
-
-Other values for the variable are illegal and will cause the death test to
-fail. Currently, the flag's default value is `"fast"`. However, we reserve the
-right to change it in the future. Therefore, your tests should not depend on
-this.
-
-In either case, the parent process waits for the child process to complete, and checks that
-
-  1. the child's exit status satisfies the predicate, and
-  1. the child's stderr matches the regular expression.
-
-If the death test statement runs to completion without dying, the child
-process will nonetheless terminate, and the assertion fails.
-
-## Death Tests And Threads ##
-
-The reason for the two death test styles has to do with thread safety. Due to
-well-known problems with forking in the presence of threads, death tests should
-be run in a single-threaded context. Sometimes, however, it isn't feasible to
-arrange that kind of environment. For example, statically-initialized modules
-may start threads before main is ever reached. Once threads have been created,
-it may be difficult or impossible to clean them up.
-
-Google Test has three features intended to raise awareness of threading issues.
-
-  1. A warning is emitted if multiple threads are running when a death test is encountered.
-  1. Test cases with a name ending in "DeathTest" are run before all other tests.
-  1. It uses `clone()` instead of `fork()` to spawn the child process on Linux (`clone()` is not available on Cygwin and Mac), as `fork()` is more likely to cause the child to hang when the parent process has multiple threads.
-
-It's perfectly fine to create threads inside a death test statement; they are
-executed in a separate process and cannot affect the parent.
-
-## Death Test Styles ##
-
-The "threadsafe" death test style was introduced in order to help mitigate the
-risks of testing in a possibly multithreaded environment. It trades increased
-test execution time (potentially dramatically so) for improved thread safety.
-We suggest using the faster, default "fast" style unless your test has specific
-problems with it.
-
-You can choose a particular style of death tests by setting the flag
-programmatically:
-
-```
-::testing::FLAGS_gtest_death_test_style = "threadsafe";
-```
-
-You can do this in `main()` to set the style for all death tests in the
-binary, or in individual tests. Recall that flags are saved before running each
-test and restored afterwards, so you need not do that yourself. For example:
-
-```
-TEST(MyDeathTest, TestOne) {
-  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-  // This test is run in the "threadsafe" style:
-  ASSERT_DEATH(ThisShouldDie(), "");
-}
-
-TEST(MyDeathTest, TestTwo) {
-  // This test is run in the "fast" style:
-  ASSERT_DEATH(ThisShouldDie(), "");
-}
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  ::testing::FLAGS_gtest_death_test_style = "fast";
-  return RUN_ALL_TESTS();
-}
-```
-
-## Caveats ##
-
-The _statement_ argument of `ASSERT_EXIT()` can be any valid C++ statement.
-If it leaves the current function via a `return` statement or by throwing an exception,
-the death test is considered to have failed.  Some Google Test macros may return
-from the current function (e.g. `ASSERT_TRUE()`), so be sure to avoid them in _statement_.
-
-Since _statement_ runs in the child process, any in-memory side effect (e.g.
-modifying a variable, releasing memory, etc) it causes will _not_ be observable
-in the parent process. In particular, if you release memory in a death test,
-your program will fail the heap check as the parent process will never see the
-memory reclaimed. To solve this problem, you can
-
-  1. try not to free memory in a death test;
-  1. free the memory again in the parent process; or
-  1. do not use the heap checker in your program.
-
-Due to an implementation detail, you cannot place multiple death test
-assertions on the same line; otherwise, compilation will fail with an unobvious
-error message.
-
-Despite the improved thread safety afforded by the "threadsafe" style of death
-test, thread problems such as deadlock are still possible in the presence of
-handlers registered with `pthread_atfork(3)`.
-
-# Using Assertions in Sub-routines #
-
-## Adding Traces to Assertions ##
-
-If a test sub-routine is called from several places, when an assertion
-inside it fails, it can be hard to tell which invocation of the
-sub-routine the failure is from.  You can alleviate this problem using
-extra logging or custom failure messages, but that usually clutters up
-your tests. A better solution is to use the `SCOPED_TRACE` macro:
-
-| `SCOPED_TRACE(`_message_`);` |
-|:-----------------------------|
-
-where _message_ can be anything streamable to `std::ostream`. This
-macro will cause the current file name, line number, and the given
-message to be added in every failure message. The effect will be
-undone when the control leaves the current lexical scope.
-
-For example,
-
-```
-10: void Sub1(int n) {
-11:   EXPECT_EQ(1, Bar(n));
-12:   EXPECT_EQ(2, Bar(n + 1));
-13: }
-14:
-15: TEST(FooTest, Bar) {
-16:   {
-17:     SCOPED_TRACE("A");  // This trace point will be included in
-18:                         // every failure in this scope.
-19:     Sub1(1);
-20:   }
-21:   // Now it won't.
-22:   Sub1(9);
-23: }
-```
-
-could result in messages like these:
-
-```
-path/to/foo_test.cc:11: Failure
-Value of: Bar(n)
-Expected: 1
-  Actual: 2
-   Trace:
-path/to/foo_test.cc:17: A
-
-path/to/foo_test.cc:12: Failure
-Value of: Bar(n + 1)
-Expected: 2
-  Actual: 3
-```
-
-Without the trace, it would've been difficult to know which invocation
-of `Sub1()` the two failures come from respectively. (You could add an
-extra message to each assertion in `Sub1()` to indicate the value of
-`n`, but that's tedious.)
-
-Some tips on using `SCOPED_TRACE`:
-
-  1. With a suitable message, it's often enough to use `SCOPED_TRACE` at the beginning of a sub-routine, instead of at each call site.
-  1. When calling sub-routines inside a loop, make the loop iterator part of the message in `SCOPED_TRACE` such that you can know which iteration the failure is from.
-  1. Sometimes the line number of the trace point is enough for identifying the particular invocation of a sub-routine. In this case, you don't have to choose a unique message for `SCOPED_TRACE`. You can simply use `""`.
-  1. You can use `SCOPED_TRACE` in an inner scope when there is one in the outer scope. In this case, all active trace points will be included in the failure messages, in reverse order they are encountered.
-  1. The trace dump is clickable in Emacs' compilation buffer - hit return on a line number and you'll be taken to that line in the source file!
-
-_Availability:_ Linux, Windows, Mac.
-
-## Propagating Fatal Failures ##
-
-A common pitfall when using `ASSERT_*` and `FAIL*` is not understanding that
-when they fail they only abort the _current function_, not the entire test. For
-example, the following test will segfault:
-```
-void Subroutine() {
-  // Generates a fatal failure and aborts the current function.
-  ASSERT_EQ(1, 2);
-  // The following won't be executed.
-  ...
-}
-
-TEST(FooTest, Bar) {
-  Subroutine();
-  // The intended behavior is for the fatal failure
-  // in Subroutine() to abort the entire test.
-  // The actual behavior: the function goes on after Subroutine() returns.
-  int* p = NULL;
-  *p = 3; // Segfault!
-}
-```
-
-Since we don't use exceptions, it is technically impossible to
-implement the intended behavior here.  To alleviate this, Google Test
-provides two solutions.  You could use either the
-`(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the
-`HasFatalFailure()` function.  They are described in the following two
-subsections.
-
-### Asserting on Subroutines ###
-
-As shown above, if your test calls a subroutine that has an `ASSERT_*`
-failure in it, the test will continue after the subroutine
-returns. This may not be what you want.
-
-Often people want fatal failures to propagate like exceptions.  For
-that Google Test offers the following macros:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_NO_FATAL_FAILURE(`_statement_`);` | `EXPECT_NO_FATAL_FAILURE(`_statement_`);` | _statement_ doesn't generate any new fatal failures in the current thread. |
-
-Only failures in the thread that executes the assertion are checked to
-determine the result of this type of assertions.  If _statement_
-creates new threads, failures in these threads are ignored.
-
-Examples:
-
-```
-ASSERT_NO_FATAL_FAILURE(Foo());
-
-int i;
-EXPECT_NO_FATAL_FAILURE({
-  i = Bar();
-});
-```
-
-_Availability:_ Linux, Windows, Mac. Assertions from multiple threads
-are currently not supported.
-
-### Checking for Failures in the Current Test ###
-
-`HasFatalFailure()` in the `::testing::Test` class returns `true` if an
-assertion in the current test has suffered a fatal failure. This
-allows functions to catch fatal failures in a sub-routine and return
-early.
-
-```
-class Test {
- public:
-  ...
-  static bool HasFatalFailure();
-};
-```
-
-The typical usage, which basically simulates the behavior of a thrown
-exception, is:
-
-```
-TEST(FooTest, Bar) {
-  Subroutine();
-  // Aborts if Subroutine() had a fatal failure.
-  if (HasFatalFailure())
-    return;
-  // The following won't be executed.
-  ...
-}
-```
-
-If `HasFatalFailure()` is used outside of `TEST()` , `TEST_F()` , or a test
-fixture, you must add the `::testing::Test::` prefix, as in:
-
-```
-if (::testing::Test::HasFatalFailure())
-  return;
-```
-
-Similarly, `HasNonfatalFailure()` returns `true` if the current test
-has at least one non-fatal failure, and `HasFailure()` returns `true`
-if the current test has at least one failure of either kind.
-
-_Availability:_ Linux, Windows, Mac.  `HasNonfatalFailure()` and
-`HasFailure()` are available since version 1.4.0.
-
-# Logging Additional Information #
-
-In your test code, you can call `RecordProperty("key", value)` to log
-additional information, where `value` can be either a string or an `int`. The _last_ value recorded for a key will be emitted to the XML output
-if you specify one. For example, the test
-
-```
-TEST_F(WidgetUsageTest, MinAndMaxWidgets) {
-  RecordProperty("MaximumWidgets", ComputeMaxUsage());
-  RecordProperty("MinimumWidgets", ComputeMinUsage());
-}
-```
-
-will output XML like this:
-
-```
-...
-  <testcase name="MinAndMaxWidgets" status="run" time="6" classname="WidgetUsageTest"
-            MaximumWidgets="12"
-            MinimumWidgets="9" />
-...
-```
-
-_Note_:
-  * `RecordProperty()` is a static member of the `Test` class. Therefore it needs to be prefixed with `::testing::Test::` if used outside of the `TEST` body and the test fixture class.
-  * `key` must be a valid XML attribute name, and cannot conflict with the ones already used by Google Test (`name`, `status`, `time`, `classname`, `type_param`, and `value_param`).
-  * Calling `RecordProperty()` outside of the lifespan of a test is allowed. If it's called outside of a test but between a test case's `SetUpTestCase()` and `TearDownTestCase()` methods, it will be attributed to the XML element for the test case. If it's called outside of all test cases (e.g. in a test environment), it will be attributed to the top-level XML element.
-
-_Availability_: Linux, Windows, Mac.
-
-# Sharing Resources Between Tests in the Same Test Case #
-
-
-
-Google Test creates a new test fixture object for each test in order to make
-tests independent and easier to debug. However, sometimes tests use resources
-that are expensive to set up, making the one-copy-per-test model prohibitively
-expensive.
-
-If the tests don't change the resource, there's no harm in them sharing a
-single resource copy. So, in addition to per-test set-up/tear-down, Google Test
-also supports per-test-case set-up/tear-down. To use it:
-
-  1. In your test fixture class (say `FooTest` ), define as `static` some member variables to hold the shared resources.
-  1. In the same test fixture class, define a `static void SetUpTestCase()` function (remember not to spell it as **`SetupTestCase`** with a small `u`!) to set up the shared resources and a `static void TearDownTestCase()` function to tear them down.
-
-That's it! Google Test automatically calls `SetUpTestCase()` before running the
-_first test_ in the `FooTest` test case (i.e. before creating the first
-`FooTest` object), and calls `TearDownTestCase()` after running the _last test_
-in it (i.e. after deleting the last `FooTest` object). In between, the tests
-can use the shared resources.
-
-Remember that the test order is undefined, so your code can't depend on a test
-preceding or following another. Also, the tests must either not modify the
-state of any shared resource, or, if they do modify the state, they must
-restore the state to its original value before passing control to the next
-test.
-
-Here's an example of per-test-case set-up and tear-down:
-```
-class FooTest : public ::testing::Test {
- protected:
-  // Per-test-case set-up.
-  // Called before the first test in this test case.
-  // Can be omitted if not needed.
-  static void SetUpTestCase() {
-    shared_resource_ = new ...;
-  }
-
-  // Per-test-case tear-down.
-  // Called after the last test in this test case.
-  // Can be omitted if not needed.
-  static void TearDownTestCase() {
-    delete shared_resource_;
-    shared_resource_ = NULL;
-  }
-
-  // You can define per-test set-up and tear-down logic as usual.
-  virtual void SetUp() { ... }
-  virtual void TearDown() { ... }
-
-  // Some expensive resource shared by all tests.
-  static T* shared_resource_;
-};
-
-T* FooTest::shared_resource_ = NULL;
-
-TEST_F(FooTest, Test1) {
-  ... you can refer to shared_resource here ...
-}
-TEST_F(FooTest, Test2) {
-  ... you can refer to shared_resource here ...
-}
-```
-
-_Availability:_ Linux, Windows, Mac.
-
-# Global Set-Up and Tear-Down #
-
-Just as you can do set-up and tear-down at the test level and the test case
-level, you can also do it at the test program level. Here's how.
-
-First, you subclass the `::testing::Environment` class to define a test
-environment, which knows how to set-up and tear-down:
-
-```
-class Environment {
- public:
-  virtual ~Environment() {}
-  // Override this to define how to set up the environment.
-  virtual void SetUp() {}
-  // Override this to define how to tear down the environment.
-  virtual void TearDown() {}
-};
-```
-
-Then, you register an instance of your environment class with Google Test by
-calling the `::testing::AddGlobalTestEnvironment()` function:
-
-```
-Environment* AddGlobalTestEnvironment(Environment* env);
-```
-
-Now, when `RUN_ALL_TESTS()` is called, it first calls the `SetUp()` method of
-the environment object, then runs the tests if there was no fatal failures, and
-finally calls `TearDown()` of the environment object.
-
-It's OK to register multiple environment objects. In this case, their `SetUp()`
-will be called in the order they are registered, and their `TearDown()` will be
-called in the reverse order.
-
-Note that Google Test takes ownership of the registered environment objects.
-Therefore **do not delete them** by yourself.
-
-You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is
-called, probably in `main()`. If you use `gtest_main`, you need to      call
-this before `main()` starts for it to take effect. One way to do this is to
-define a global variable like this:
-
-```
-::testing::Environment* const foo_env = ::testing::AddGlobalTestEnvironment(new FooEnvironment);
-```
-
-However, we strongly recommend you to write your own `main()` and call
-`AddGlobalTestEnvironment()` there, as relying on initialization of global
-variables makes the code harder to read and may cause problems when you
-register multiple environments from different translation units and the
-environments have dependencies among them (remember that the compiler doesn't
-guarantee the order in which global variables from different translation units
-are initialized).
-
-_Availability:_ Linux, Windows, Mac.
-
-
-# Value Parameterized Tests #
-
-_Value-parameterized tests_ allow you to test your code with different
-parameters without writing multiple copies of the same test.
-
-Suppose you write a test for your code and then realize that your code is affected by a presence of a Boolean command line flag.
-
-```
-TEST(MyCodeTest, TestFoo) {
-  // A code to test foo().
-}
-```
-
-Usually people factor their test code into a function with a Boolean parameter in such situations. The function sets the flag, then executes the testing code.
-
-```
-void TestFooHelper(bool flag_value) {
-  flag = flag_value;
-  // A code to test foo().
-}
-
-TEST(MyCodeTest, TestFoo) {
-  TestFooHelper(false);
-  TestFooHelper(true);
-}
-```
-
-But this setup has serious drawbacks. First, when a test assertion fails in your tests, it becomes unclear what value of the parameter caused it to fail. You can stream a clarifying message into your `EXPECT`/`ASSERT` statements, but it you'll have to do it with all of them. Second, you have to add one such helper function per test. What if you have ten tests? Twenty? A hundred?
-
-Value-parameterized tests will let you write your test only once and then easily instantiate and run it with an arbitrary number of parameter values.
-
-Here are some other situations when value-parameterized tests come handy:
-
-  * You want to test different implementations of an OO interface.
-  * You want to test your code over various inputs (a.k.a. data-driven testing). This feature is easy to abuse, so please exercise your good sense when doing it!
-
-## How to Write Value-Parameterized Tests ##
-
-To write value-parameterized tests, first you should define a fixture
-class.  It must be derived from both `::testing::Test` and
-`::testing::WithParamInterface<T>` (the latter is a pure interface),
-where `T` is the type of your parameter values.  For convenience, you
-can just derive the fixture class from `::testing::TestWithParam<T>`,
-which itself is derived from both `::testing::Test` and
-`::testing::WithParamInterface<T>`. `T` can be any copyable type. If
-it's a raw pointer, you are responsible for managing the lifespan of
-the pointed values.
-
-```
-class FooTest : public ::testing::TestWithParam<const char*> {
-  // You can implement all the usual fixture class members here.
-  // To access the test parameter, call GetParam() from class
-  // TestWithParam<T>.
-};
-
-// Or, when you want to add parameters to a pre-existing fixture class:
-class BaseTest : public ::testing::Test {
-  ...
-};
-class BarTest : public BaseTest,
-                public ::testing::WithParamInterface<const char*> {
-  ...
-};
-```
-
-Then, use the `TEST_P` macro to define as many test patterns using
-this fixture as you want.  The `_P` suffix is for "parameterized" or
-"pattern", whichever you prefer to think.
-
-```
-TEST_P(FooTest, DoesBlah) {
-  // Inside a test, access the test parameter with the GetParam() method
-  // of the TestWithParam<T> class:
-  EXPECT_TRUE(foo.Blah(GetParam()));
-  ...
-}
-
-TEST_P(FooTest, HasBlahBlah) {
-  ...
-}
-```
-
-Finally, you can use `INSTANTIATE_TEST_CASE_P` to instantiate the test
-case with 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 are all in the `testing` namespace:
-
-| `Range(begin, end[, step])` | Yields values `{begin, begin+step, begin+step+step, ...}`. The values do not include `end`. `step` defaults to 1. |
-|:----------------------------|:------------------------------------------------------------------------------------------------------------------|
-| `Values(v1, v2, ..., vN)`   | Yields values `{v1, v2, ..., vN}`.                                                                                |
-| `ValuesIn(container)` and `ValuesIn(begin, end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)`. `container`, `begin`, and `end` can be expressions whose values are determined at run time.  |
-| `Bool()`                    | Yields sequence `{false, true}`.                                                                                  |
-| `Combine(g1, g2, ..., gN)`  | Yields all combinations (the Cartesian product for the math savvy) of the values generated by the `N` generators. This is only available if your system provides the `<tr1/tuple>` header. If you are sure your system does, and Google Test disagrees, you can override it by defining `GTEST_HAS_TR1_TUPLE=1`. See comments in [include/gtest/internal/gtest-port.h](../include/gtest/internal/gtest-port.h) for more information. |
-
-For more details, see the comments at the definitions of these functions in the [source code](../include/gtest/gtest-param-test.h).
-
-The following statement will instantiate tests from the `FooTest` test case
-each with parameter values `"meeny"`, `"miny"`, and `"moe"`.
-
-```
-INSTANTIATE_TEST_CASE_P(InstantiationName,
-                        FooTest,
-                        ::testing::Values("meeny", "miny", "moe"));
-```
-
-To distinguish different instances of the pattern (yes, you can
-instantiate it more than once), the first argument to
-`INSTANTIATE_TEST_CASE_P` is a prefix that will be added to the actual
-test case name. Remember to pick unique prefixes for different
-instantiations. The tests from the instantiation above will have these
-names:
-
-  * `InstantiationName/FooTest.DoesBlah/0` for `"meeny"`
-  * `InstantiationName/FooTest.DoesBlah/1` for `"miny"`
-  * `InstantiationName/FooTest.DoesBlah/2` for `"moe"`
-  * `InstantiationName/FooTest.HasBlahBlah/0` for `"meeny"`
-  * `InstantiationName/FooTest.HasBlahBlah/1` for `"miny"`
-  * `InstantiationName/FooTest.HasBlahBlah/2` for `"moe"`
-
-You can use these names in [--gtest\_filter](#running-a-subset-of-the-tests).
-
-This statement will instantiate all tests from `FooTest` again, each
-with parameter values `"cat"` and `"dog"`:
-
-```
-const char* pets[] = {"cat", "dog"};
-INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest,
-                        ::testing::ValuesIn(pets));
-```
-
-The tests from the instantiation above will have these names:
-
-  * `AnotherInstantiationName/FooTest.DoesBlah/0` for `"cat"`
-  * `AnotherInstantiationName/FooTest.DoesBlah/1` for `"dog"`
-  * `AnotherInstantiationName/FooTest.HasBlahBlah/0` for `"cat"`
-  * `AnotherInstantiationName/FooTest.HasBlahBlah/1` for `"dog"`
-
-Please note that `INSTANTIATE_TEST_CASE_P` will instantiate _all_
-tests in the given test case, whether their definitions come before or
-_after_ the `INSTANTIATE_TEST_CASE_P` statement.
-
-You can see
-[these](../samples/sample7_unittest.cc)
-[files](../samples/sample8_unittest.cc) for more examples.
-
-_Availability_: Linux, Windows (requires MSVC 8.0 or above), Mac; since version 1.2.0.
-
-## Creating Value-Parameterized Abstract Tests ##
-
-In the above, we define and instantiate `FooTest` in the same source
-file. Sometimes you may want to define value-parameterized tests in a
-library and let other people instantiate them later. This pattern is
-known as <i>abstract tests</i>. As an example of its application, when you
-are designing an interface you can write a standard suite of abstract
-tests (perhaps using a factory function as the test parameter) that
-all implementations of the interface are expected to pass. When
-someone implements the interface, he can instantiate your suite to get
-all the interface-conformance tests for free.
-
-To define abstract tests, you should organize your code like this:
-
-  1. Put the definition of the parameterized test fixture class (e.g. `FooTest`) in a header file, say `foo_param_test.h`. Think of this as _declaring_ your abstract tests.
-  1. Put the `TEST_P` definitions in `foo_param_test.cc`, which includes `foo_param_test.h`. Think of this as _implementing_ your abstract tests.
-
-Once they are defined, you can instantiate them by including
-`foo_param_test.h`, invoking `INSTANTIATE_TEST_CASE_P()`, and linking
-with `foo_param_test.cc`. You can instantiate the same abstract test
-case multiple times, possibly in different source files.
-
-# Typed Tests #
-
-Suppose you have multiple implementations of the same interface and
-want to make sure that all of them satisfy some common requirements.
-Or, you may have defined several types that are supposed to conform to
-the same "concept" and you want to verify it.  In both cases, you want
-the same test logic repeated for different types.
-
-While you can write one `TEST` or `TEST_F` for each type you want to
-test (and you may even factor the test logic into a function template
-that you invoke from the `TEST`), it's tedious and doesn't scale:
-if you want _m_ tests over _n_ types, you'll end up writing _m\*n_
-`TEST`s.
-
-_Typed tests_ allow you to repeat the same test logic over a list of
-types.  You only need to write the test logic once, although you must
-know the type list when writing typed tests.  Here's how you do it:
-
-First, define a fixture class template.  It should be parameterized
-by a type.  Remember to derive it from `::testing::Test`:
-
-```
-template <typename T>
-class FooTest : public ::testing::Test {
- public:
-  ...
-  typedef std::list<T> List;
-  static T shared_;
-  T value_;
-};
-```
-
-Next, associate a list of types with the test case, which will be
-repeated for each type in the list:
-
-```
-typedef ::testing::Types<char, int, unsigned int> MyTypes;
-TYPED_TEST_CASE(FooTest, MyTypes);
-```
-
-The `typedef` is necessary for the `TYPED_TEST_CASE` macro to parse
-correctly.  Otherwise the compiler will think that each comma in the
-type list introduces a new macro argument.
-
-Then, use `TYPED_TEST()` instead of `TEST_F()` to define a typed test
-for this test case.  You can repeat this as many times as you want:
-
-```
-TYPED_TEST(FooTest, DoesBlah) {
-  // Inside a test, refer to the special name TypeParam to get the type
-  // parameter.  Since we are inside a derived class template, C++ requires
-  // us to visit the members of FooTest via 'this'.
-  TypeParam n = this->value_;
-
-  // To visit static members of the fixture, add the 'TestFixture::'
-  // prefix.
-  n += TestFixture::shared_;
-
-  // To refer to typedefs in the fixture, add the 'typename TestFixture::'
-  // prefix.  The 'typename' is required to satisfy the compiler.
-  typename TestFixture::List values;
-  values.push_back(n);
-  ...
-}
-
-TYPED_TEST(FooTest, HasPropertyA) { ... }
-```
-
-You can see `samples/sample6_unittest.cc` for a complete example.
-
-_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
-since version 1.1.0.
-
-# Type-Parameterized Tests #
-
-_Type-parameterized tests_ are like typed tests, except that they
-don't require you to know the list of types ahead of time.  Instead,
-you can define the test logic first and instantiate it with different
-type lists later.  You can even instantiate it more than once in the
-same program.
-
-If you are designing an interface or concept, you can define a suite
-of type-parameterized tests to verify properties that any valid
-implementation of the interface/concept should have.  Then, the author
-of each implementation can just instantiate the test suite with his
-type to verify that it conforms to the requirements, without having to
-write similar tests repeatedly.  Here's an example:
-
-First, define a fixture class template, as we did with typed tests:
-
-```
-template <typename T>
-class FooTest : public ::testing::Test {
-  ...
-};
-```
-
-Next, declare that you will define a type-parameterized test case:
-
-```
-TYPED_TEST_CASE_P(FooTest);
-```
-
-The `_P` suffix is for "parameterized" or "pattern", whichever you
-prefer to think.
-
-Then, use `TYPED_TEST_P()` to define a type-parameterized test.  You
-can repeat this as many times as you want:
-
-```
-TYPED_TEST_P(FooTest, DoesBlah) {
-  // Inside a test, refer to TypeParam to get the type parameter.
-  TypeParam n = 0;
-  ...
-}
-
-TYPED_TEST_P(FooTest, HasPropertyA) { ... }
-```
-
-Now the tricky part: you need to register all test patterns using the
-`REGISTER_TYPED_TEST_CASE_P` macro before you can instantiate them.
-The first argument of the macro is the test case name; the rest are
-the names of the tests in this test case:
-
-```
-REGISTER_TYPED_TEST_CASE_P(FooTest,
-                           DoesBlah, HasPropertyA);
-```
-
-Finally, you are free to instantiate the pattern with the types you
-want.  If you put the above code in a header file, you can `#include`
-it in multiple C++ source files and instantiate it multiple times.
-
-```
-typedef ::testing::Types<char, int, unsigned int> MyTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
-```
-
-To distinguish different instances of the pattern, the first argument
-to the `INSTANTIATE_TYPED_TEST_CASE_P` macro is a prefix that will be
-added to the actual test case name.  Remember to pick unique prefixes
-for different instances.
-
-In the special case where the type list contains only one type, you
-can write that type directly without `::testing::Types<...>`, like this:
-
-```
-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
-```
-
-You can see `samples/sample6_unittest.cc` for a complete example.
-
-_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
-since version 1.1.0.
-
-# Testing Private Code #
-
-If you change your software's internal implementation, your tests should not
-break as long as the change is not observable by users. Therefore, per the
-_black-box testing principle_, most of the time you should test your code
-through its public interfaces.
-
-If you still find yourself needing to test internal implementation code,
-consider if there's a better design that wouldn't require you to do so. If you
-absolutely have to test non-public interface code though, you can. There are
-two cases to consider:
-
-  * Static functions (_not_ the same as static member functions!) or unnamed namespaces, and
-  * Private or protected class members
-
-## Static Functions ##
-
-Both static functions and definitions/declarations in an unnamed namespace are
-only visible within the same translation unit. To test them, you can `#include`
-the entire `.cc` file being tested in your `*_test.cc` file. (`#include`ing `.cc`
-files is not a good way to reuse code - you should not do this in production
-code!)
-
-However, a better approach is to move the private code into the
-`foo::internal` namespace, where `foo` is the namespace your project normally
-uses, and put the private declarations in a `*-internal.h` file. Your
-production `.cc` files and your tests are allowed to include this internal
-header, but your clients are not. This way, you can fully test your internal
-implementation without leaking it to your clients.
-
-## Private Class Members ##
-
-Private class members are only accessible from within the class or by friends.
-To access a class' private members, you can declare your test fixture as a
-friend to the class and define accessors in your fixture. Tests using the
-fixture can then access the private members of your production class via the
-accessors in the fixture. Note that even though your fixture is a friend to
-your production class, your tests are not automatically friends to it, as they
-are technically defined in sub-classes of the fixture.
-
-Another way to test private members is to refactor them into an implementation
-class, which is then declared in a `*-internal.h` file. Your clients aren't
-allowed to include this header but your tests can. Such is called the Pimpl
-(Private Implementation) idiom.
-
-Or, you can declare an individual test as a friend of your class by adding this
-line in the class body:
-
-```
-FRIEND_TEST(TestCaseName, TestName);
-```
-
-For example,
-```
-// foo.h
-#include "gtest/gtest_prod.h"
-
-// Defines FRIEND_TEST.
-class Foo {
-  ...
- private:
-  FRIEND_TEST(FooTest, BarReturnsZeroOnNull);
-  int Bar(void* x);
-};
-
-// foo_test.cc
-...
-TEST(FooTest, BarReturnsZeroOnNull) {
-  Foo foo;
-  EXPECT_EQ(0, foo.Bar(NULL));
-  // Uses Foo's private member Bar().
-}
-```
-
-Pay special attention when your class is defined in a namespace, as you should
-define your test fixtures and tests in the same namespace if you want them to
-be friends of your class. For example, if the code to be tested looks like:
-
-```
-namespace my_namespace {
-
-class Foo {
-  friend class FooTest;
-  FRIEND_TEST(FooTest, Bar);
-  FRIEND_TEST(FooTest, Baz);
-  ...
-  definition of the class Foo
-  ...
-};
-
-}  // namespace my_namespace
-```
-
-Your test code should be something like:
-
-```
-namespace my_namespace {
-class FooTest : public ::testing::Test {
- protected:
-  ...
-};
-
-TEST_F(FooTest, Bar) { ... }
-TEST_F(FooTest, Baz) { ... }
-
-}  // namespace my_namespace
-```
-
-# Catching Failures #
-
-If you are building a testing utility on top of Google Test, you'll
-want to test your utility.  What framework would you use to test it?
-Google Test, of course.
-
-The challenge is to verify that your testing utility reports failures
-correctly.  In frameworks that report a failure by throwing an
-exception, you could catch the exception and assert on it.  But Google
-Test doesn't use exceptions, so how do we test that a piece of code
-generates an expected failure?
-
-`"gtest/gtest-spi.h"` contains some constructs to do this.  After 
-`#include`ing this header, you can use
-
-| `EXPECT_FATAL_FAILURE(`_statement, substring_`);` |
-|:--------------------------------------------------|
-
-to assert that _statement_ generates a fatal (e.g. `ASSERT_*`) failure
-whose message contains the given _substring_, or use
-
-| `EXPECT_NONFATAL_FAILURE(`_statement, substring_`);` |
-|:-----------------------------------------------------|
-
-if you are expecting a non-fatal (e.g. `EXPECT_*`) failure.
-
-For technical reasons, there are some caveats:
-
-  1. You cannot stream a failure message to either macro.
-  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot reference local non-static variables or non-static members of `this` object.
-  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot return a value.
-
-_Note:_ Google Test is designed with threads in mind. Once the
-synchronization primitives in `"gtest/internal/gtest-port.h"` have
-been implemented, Google Test will become thread-safe, meaning that
-you can then use assertions in multiple threads concurrently. Before
-that, however, Google Test only supports single-threaded usage. Once
-thread-safe, `EXPECT_FATAL_FAILURE()` and `EXPECT_NONFATAL_FAILURE()`
-will capture failures in the current thread only. If _statement_
-creates new threads, failures in these threads will be ignored. If
-you want to capture failures from all threads instead, you should use
-the following macros:
-
-| `EXPECT_FATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
-|:-----------------------------------------------------------------|
-| `EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
-
-# Getting the Current Test's Name #
-
-Sometimes a function may need to know the name of the currently running test.
-For example, you may be using the `SetUp()` method of your test fixture to set
-the golden file name based on which test is running. The `::testing::TestInfo`
-class has this information:
-
-```
-namespace testing {
-
-class TestInfo {
- public:
-  // Returns the test case name and the test name, respectively.
-  //
-  // Do NOT delete or free the return value - it's managed by the
-  // TestInfo class.
-  const char* test_case_name() const;
-  const char* name() const;
-};
-
-}  // namespace testing
-```
-
-
-> To obtain a `TestInfo` object for the currently running test, call
-`current_test_info()` on the `UnitTest` singleton object:
-
-```
-// Gets information about the currently running test.
-// Do NOT delete the returned object - it's managed by the UnitTest class.
-const ::testing::TestInfo* const test_info =
-  ::testing::UnitTest::GetInstance()->current_test_info();
-printf("We are in test %s of test case %s.\n",
-       test_info->name(), test_info->test_case_name());
-```
-
-`current_test_info()` returns a null pointer if no test is running. In
-particular, you cannot find the test case name in `TestCaseSetUp()`,
-`TestCaseTearDown()` (where you know the test case name implicitly), or
-functions called from them.
-
-_Availability:_ Linux, Windows, Mac.
-
-# Extending Google Test by Handling Test Events #
-
-Google Test provides an <b>event listener API</b> to let you receive
-notifications about the progress of a test program and test
-failures. The events you can listen to include the start and end of
-the test program, a test case, or a test method, among others. You may
-use this API to augment or replace the standard console output,
-replace the XML output, or provide a completely different form of
-output, such as a GUI or a database. You can also use test events as
-checkpoints to implement a resource leak checker, for example.
-
-_Availability:_ Linux, Windows, Mac; since v1.4.0.
-
-## Defining Event Listeners ##
-
-To define a event listener, you subclass either
-[testing::TestEventListener](../include/gtest/gtest.h#L991)
-or [testing::EmptyTestEventListener](../include/gtest/gtest.h#L1044).
-The former is an (abstract) interface, where <i>each pure virtual method<br>
-can be overridden to handle a test event</i> (For example, when a test
-starts, the `OnTestStart()` method will be called.). The latter provides
-an empty implementation of all methods in the interface, such that a
-subclass only needs to override the methods it cares about.
-
-When an event is fired, its context is passed to the handler function
-as an argument. The following argument types are used:
-  * [UnitTest](../include/gtest/gtest.h#L1151) reflects the state of the entire test program,
-  * [TestCase](../include/gtest/gtest.h#L778) has information about a test case, which can contain one or more tests,
-  * [TestInfo](../include/gtest/gtest.h#L644) contains the state of a test, and
-  * [TestPartResult](../include/gtest/gtest-test-part.h#L47) represents the result of a test assertion.
-
-An event handler function can examine the argument it receives to find
-out interesting information about the event and the test program's
-state.  Here's an example:
-
-```
-  class MinimalistPrinter : public ::testing::EmptyTestEventListener {
-    // Called before a test starts.
-    virtual void OnTestStart(const ::testing::TestInfo& test_info) {
-      printf("*** Test %s.%s starting.\n",
-             test_info.test_case_name(), test_info.name());
-    }
-
-    // Called after a failed assertion or a SUCCEED() invocation.
-    virtual void OnTestPartResult(
-        const ::testing::TestPartResult& test_part_result) {
-      printf("%s in %s:%d\n%s\n",
-             test_part_result.failed() ? "*** Failure" : "Success",
-             test_part_result.file_name(),
-             test_part_result.line_number(),
-             test_part_result.summary());
-    }
-
-    // Called after a test ends.
-    virtual void OnTestEnd(const ::testing::TestInfo& test_info) {
-      printf("*** Test %s.%s ending.\n",
-             test_info.test_case_name(), test_info.name());
-    }
-  };
-```
-
-## Using Event Listeners ##
-
-To use the event listener you have defined, add an instance of it to
-the Google Test event listener list (represented by class
-[TestEventListeners](../include/gtest/gtest.h#L1064)
-- note the "s" at the end of the name) in your
-`main()` function, before calling `RUN_ALL_TESTS()`:
-```
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  // Gets hold of the event listener list.
-  ::testing::TestEventListeners& listeners =
-      ::testing::UnitTest::GetInstance()->listeners();
-  // Adds a listener to the end.  Google Test takes the ownership.
-  listeners.Append(new MinimalistPrinter);
-  return RUN_ALL_TESTS();
-}
-```
-
-There's only one problem: the default test result printer is still in
-effect, so its output will mingle with the output from your minimalist
-printer. To suppress the default printer, just release it from the
-event listener list and delete it. You can do so by adding one line:
-```
-  ...
-  delete listeners.Release(listeners.default_result_printer());
-  listeners.Append(new MinimalistPrinter);
-  return RUN_ALL_TESTS();
-```
-
-Now, sit back and enjoy a completely different output from your
-tests. For more details, you can read this
-[sample](../samples/sample9_unittest.cc).
-
-You may append more than one listener to the list. When an `On*Start()`
-or `OnTestPartResult()` event is fired, the listeners will receive it in
-the order they appear in the list (since new listeners are added to
-the end of the list, the default text printer and the default XML
-generator will receive the event first). An `On*End()` event will be
-received by the listeners in the _reverse_ order. This allows output by
-listeners added later to be framed by output from listeners added
-earlier.
-
-## Generating Failures in Listeners ##
-
-You may use failure-raising macros (`EXPECT_*()`, `ASSERT_*()`,
-`FAIL()`, etc) when processing an event. There are some restrictions:
-
-  1. You cannot generate any failure in `OnTestPartResult()` (otherwise it will cause `OnTestPartResult()` to be called recursively).
-  1. A listener that handles `OnTestPartResult()` is not allowed to generate any failure.
-
-When you add listeners to the listener list, you should put listeners
-that handle `OnTestPartResult()` _before_ listeners that can generate
-failures. This ensures that failures generated by the latter are
-attributed to the right test by the former.
-
-We have a sample of failure-raising listener
-[here](../samples/sample10_unittest.cc).
-
-# Running Test Programs: Advanced Options #
-
-Google Test test programs are ordinary executables. Once built, you can run
-them directly and affect their behavior via the following environment variables
-and/or command line flags. For the flags to work, your programs must call
-`::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`.
-
-To see a list of supported flags and their usage, please run your test
-program with the `--help` flag.  You can also use `-h`, `-?`, or `/?`
-for short.  This feature is added in version 1.3.0.
-
-If an option is specified both by an environment variable and by a
-flag, the latter takes precedence.  Most of the options can also be
-set/read in code: to access the value of command line flag
-`--gtest_foo`, write `::testing::GTEST_FLAG(foo)`.  A common pattern is
-to set the value of a flag before calling `::testing::InitGoogleTest()`
-to change the default value of the flag:
-```
-int main(int argc, char** argv) {
-  // Disables elapsed time by default.
-  ::testing::GTEST_FLAG(print_time) = false;
-
-  // This allows the user to override the flag on the command line.
-  ::testing::InitGoogleTest(&argc, argv);
-
-  return RUN_ALL_TESTS();
-}
-```
-
-## Selecting Tests ##
-
-This section shows various options for choosing which tests to run.
-
-### Listing Test Names ###
-
-Sometimes it is necessary to list the available tests in a program before
-running them so that a filter may be applied if needed. Including the flag
-`--gtest_list_tests` overrides all other flags and lists tests in the following
-format:
-```
-TestCase1.
-  TestName1
-  TestName2
-TestCase2.
-  TestName
-```
-
-None of the tests listed are actually run if the flag is provided. There is no
-corresponding environment variable for this flag.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Running a Subset of the Tests ###
-
-By default, a Google Test program runs all tests the user has defined.
-Sometimes, you want to run only a subset of the tests (e.g. for debugging or
-quickly verifying a change). If you set the `GTEST_FILTER` environment variable
-or the `--gtest_filter` flag to a filter string, Google Test will only run the
-tests whose full names (in the form of `TestCaseName.TestName`) match the
-filter.
-
-The format of a filter is a '`:`'-separated list of wildcard patterns (called
-the positive patterns) optionally followed by a '`-`' and another
-'`:`'-separated pattern list (called the negative patterns). A test matches the
-filter if and only if it matches any of the positive patterns but does not
-match any of the negative patterns.
-
-A pattern may contain `'*'` (matches any string) or `'?'` (matches any single
-character). For convenience, the filter `'*-NegativePatterns'` can be also
-written as `'-NegativePatterns'`.
-
-For example:
-
-  * `./foo_test` Has no flag, and thus runs all its tests.
-  * `./foo_test --gtest_filter=*` Also runs everything, due to the single match-everything `*` value.
-  * `./foo_test --gtest_filter=FooTest.*` Runs everything in test case `FooTest`.
-  * `./foo_test --gtest_filter=*Null*:*Constructor*` Runs any test whose full name contains either `"Null"` or `"Constructor"`.
-  * `./foo_test --gtest_filter=-*DeathTest.*` Runs all non-death tests.
-  * `./foo_test --gtest_filter=FooTest.*-FooTest.Bar` Runs everything in test case `FooTest` except `FooTest.Bar`.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Temporarily Disabling Tests ###
-
-If you have a broken test that you cannot fix right away, you can add the
-`DISABLED_` prefix to its name. This will exclude it from execution. This is
-better than commenting out the code or using `#if 0`, as disabled tests are
-still compiled (and thus won't rot).
-
-If you need to disable all tests in a test case, you can either add `DISABLED_`
-to the front of the name of each test, or alternatively add it to the front of
-the test case name.
-
-For example, the following tests won't be run by Google Test, even though they
-will still be compiled:
-
-```
-// Tests that Foo does Abc.
-TEST(FooTest, DISABLED_DoesAbc) { ... }
-
-class DISABLED_BarTest : public ::testing::Test { ... };
-
-// Tests that Bar does Xyz.
-TEST_F(DISABLED_BarTest, DoesXyz) { ... }
-```
-
-_Note:_ This feature should only be used for temporary pain-relief. You still
-have to fix the disabled tests at a later date. As a reminder, Google Test will
-print a banner warning you if a test program contains any disabled tests.
-
-_Tip:_ You can easily count the number of disabled tests you have
-using `grep`. This number can be used as a metric for improving your
-test quality.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Temporarily Enabling Disabled Tests ###
-
-To include [disabled tests](#temporarily-disabling-tests) in test
-execution, just invoke the test program with the
-`--gtest_also_run_disabled_tests` flag or set the
-`GTEST_ALSO_RUN_DISABLED_TESTS` environment variable to a value other
-than `0`.  You can combine this with the
-[--gtest\_filter](#running-a-subset-of-the-tests) flag to further select
-which disabled tests to run.
-
-_Availability:_ Linux, Windows, Mac; since version 1.3.0.
-
-## Repeating the Tests ##
-
-Once in a while you'll run into a test whose result is hit-or-miss. Perhaps it
-will fail only 1% of the time, making it rather hard to reproduce the bug under
-a debugger. This can be a major source of frustration.
-
-The `--gtest_repeat` flag allows you to repeat all (or selected) test methods
-in a program many times. Hopefully, a flaky test will eventually fail and give
-you a chance to debug. Here's how to use it:
-
-| `$ foo_test --gtest_repeat=1000` | Repeat foo\_test 1000 times and don't stop at failures. |
-|:---------------------------------|:--------------------------------------------------------|
-| `$ foo_test --gtest_repeat=-1`   | A negative count means repeating forever.               |
-| `$ foo_test --gtest_repeat=1000 --gtest_break_on_failure` | Repeat foo\_test 1000 times, stopping at the first failure. This is especially useful when running under a debugger: when the testfails, it will drop into the debugger and you can then inspect variables and stacks. |
-| `$ foo_test --gtest_repeat=1000 --gtest_filter=FooBar` | Repeat the tests whose name matches the filter 1000 times. |
-
-If your test program contains global set-up/tear-down code registered
-using `AddGlobalTestEnvironment()`, it will be repeated in each
-iteration as well, as the flakiness may be in it. You can also specify
-the repeat count by setting the `GTEST_REPEAT` environment variable.
-
-_Availability:_ Linux, Windows, Mac.
-
-## Shuffling the Tests ##
-
-You can specify the `--gtest_shuffle` flag (or set the `GTEST_SHUFFLE`
-environment variable to `1`) to run the tests in a program in a random
-order. This helps to reveal bad dependencies between tests.
-
-By default, Google Test uses a random seed calculated from the current
-time. Therefore you'll get a different order every time. The console
-output includes the random seed value, such that you can reproduce an
-order-related test failure later. To specify the random seed
-explicitly, use the `--gtest_random_seed=SEED` flag (or set the
-`GTEST_RANDOM_SEED` environment variable), where `SEED` is an integer
-between 0 and 99999. The seed value 0 is special: it tells Google Test
-to do the default behavior of calculating the seed from the current
-time.
-
-If you combine this with `--gtest_repeat=N`, Google Test will pick a
-different random seed and re-shuffle the tests in each iteration.
-
-_Availability:_ Linux, Windows, Mac; since v1.4.0.
-
-## Controlling Test Output ##
-
-This section teaches how to tweak the way test results are reported.
-
-### Colored Terminal Output ###
-
-Google Test can use colors in its terminal output to make it easier to spot
-the separation between tests, and whether tests passed.
-
-You can set the GTEST\_COLOR environment variable or set the `--gtest_color`
-command line flag to `yes`, `no`, or `auto` (the default) to enable colors,
-disable colors, or let Google Test decide. When the value is `auto`, Google
-Test will use colors if and only if the output goes to a terminal and (on
-non-Windows platforms) the `TERM` environment variable is set to `xterm` or
-`xterm-color`.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Suppressing the Elapsed Time ###
-
-By default, Google Test prints the time it takes to run each test.  To
-suppress that, run the test program with the `--gtest_print_time=0`
-command line flag.  Setting the `GTEST_PRINT_TIME` environment
-variable to `0` has the same effect.
-
-_Availability:_ Linux, Windows, Mac.  (In Google Test 1.3.0 and lower,
-the default behavior is that the elapsed time is **not** printed.)
-
-### Generating an XML Report ###
-
-Google Test can emit a detailed XML report to a file in addition to its normal
-textual output. The report contains the duration of each test, and thus can
-help you identify slow tests.
-
-To generate the XML report, set the `GTEST_OUTPUT` environment variable or the
-`--gtest_output` flag to the string `"xml:_path_to_output_file_"`, which will
-create the file at the given location. You can also just use the string
-`"xml"`, in which case the output can be found in the `test_detail.xml` file in
-the current directory.
-
-If you specify a directory (for example, `"xml:output/directory/"` on Linux or
-`"xml:output\directory\"` on Windows), Google Test will create the XML file in
-that directory, named after the test executable (e.g. `foo_test.xml` for test
-program `foo_test` or `foo_test.exe`). If the file already exists (perhaps left
-over from a previous run), Google Test will pick a different name (e.g.
-`foo_test_1.xml`) to avoid overwriting it.
-
-The report uses the format described here.  It is based on the
-`junitreport` Ant task and can be parsed by popular continuous build
-systems like [Hudson](https://hudson.dev.java.net/). Since that format
-was originally intended for Java, a little interpretation is required
-to make it apply to Google Test tests, as shown here:
-
-```
-<testsuites name="AllTests" ...>
-  <testsuite name="test_case_name" ...>
-    <testcase name="test_name" ...>
-      <failure message="..."/>
-      <failure message="..."/>
-      <failure message="..."/>
-    </testcase>
-  </testsuite>
-</testsuites>
-```
-
-  * The root `<testsuites>` element corresponds to the entire test program.
-  * `<testsuite>` elements correspond to Google Test test cases.
-  * `<testcase>` elements correspond to Google Test test functions.
-
-For instance, the following program
-
-```
-TEST(MathTest, Addition) { ... }
-TEST(MathTest, Subtraction) { ... }
-TEST(LogicTest, NonContradiction) { ... }
-```
-
-could generate this report:
-
-```
-<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="3" failures="1" errors="0" time="35" name="AllTests">
-  <testsuite name="MathTest" tests="2" failures="1" errors="0" time="15">
-    <testcase name="Addition" status="run" time="7" classname="">
-      <failure message="Value of: add(1, 1)&#x0A; Actual: 3&#x0A;Expected: 2" type=""/>
-      <failure message="Value of: add(1, -1)&#x0A; Actual: 1&#x0A;Expected: 0" type=""/>
-    </testcase>
-    <testcase name="Subtraction" status="run" time="5" classname="">
-    </testcase>
-  </testsuite>
-  <testsuite name="LogicTest" tests="1" failures="0" errors="0" time="5">
-    <testcase name="NonContradiction" status="run" time="5" classname="">
-    </testcase>
-  </testsuite>
-</testsuites>
-```
-
-Things to note:
-
-  * The `tests` attribute of a `<testsuites>` or `<testsuite>` element tells how many test functions the Google Test program or test case contains, while the `failures` attribute tells how many of them failed.
-  * The `time` attribute expresses the duration of the test, test case, or entire test program in milliseconds.
-  * Each `<failure>` element corresponds to a single failed Google Test assertion.
-  * Some JUnit concepts don't apply to Google Test, yet we have to conform to the DTD. Therefore you'll see some dummy elements and attributes in the report. You can safely ignore these parts.
-
-_Availability:_ Linux, Windows, Mac.
-
-## Controlling How Failures Are Reported ##
-
-### Turning Assertion Failures into Break-Points ###
-
-When running test programs under a debugger, it's very convenient if the
-debugger can catch an assertion failure and automatically drop into interactive
-mode. Google Test's _break-on-failure_ mode supports this behavior.
-
-To enable it, set the `GTEST_BREAK_ON_FAILURE` environment variable to a value
-other than `0` . Alternatively, you can use the `--gtest_break_on_failure`
-command line flag.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Disabling Catching Test-Thrown Exceptions ###
-
-Google Test can be used either with or without exceptions enabled.  If
-a test throws a C++ exception or (on Windows) a structured exception
-(SEH), by default Google Test catches it, reports it as a test
-failure, and continues with the next test method.  This maximizes the
-coverage of a test run.  Also, on Windows an uncaught exception will
-cause a pop-up window, so catching the exceptions allows you to run
-the tests automatically.
-
-When debugging the test failures, however, you may instead want the
-exceptions to be handled by the debugger, such that you can examine
-the call stack when an exception is thrown.  To achieve that, set the
-`GTEST_CATCH_EXCEPTIONS` environment variable to `0`, or use the
-`--gtest_catch_exceptions=0` flag when running the tests.
-
-**Availability**: Linux, Windows, Mac.
-
-### Letting Another Testing Framework Drive ###
-
-If you work on a project that has already been using another testing
-framework and is not ready to completely switch to Google Test yet,
-you can get much of Google Test's benefit by using its assertions in
-your existing tests.  Just change your `main()` function to look
-like:
-
-```
-#include "gtest/gtest.h"
-
-int main(int argc, char** argv) {
-  ::testing::GTEST_FLAG(throw_on_failure) = true;
-  // Important: Google Test must be initialized.
-  ::testing::InitGoogleTest(&argc, argv);
-
-  ... whatever your existing testing framework requires ...
-}
-```
-
-With that, you can use Google Test assertions in addition to the
-native assertions your testing framework provides, for example:
-
-```
-void TestFooDoesBar() {
-  Foo foo;
-  EXPECT_LE(foo.Bar(1), 100);     // A Google Test assertion.
-  CPPUNIT_ASSERT(foo.IsEmpty());  // A native assertion.
-}
-```
-
-If a Google Test assertion fails, it will print an error message and
-throw an exception, which will be treated as a failure by your host
-testing framework.  If you compile your code with exceptions disabled,
-a failed Google Test assertion will instead exit your program with a
-non-zero code, which will also signal a test failure to your test
-runner.
-
-If you don't write `::testing::GTEST_FLAG(throw_on_failure) = true;` in
-your `main()`, you can alternatively enable this feature by specifying
-the `--gtest_throw_on_failure` flag on the command-line or setting the
-`GTEST_THROW_ON_FAILURE` environment variable to a non-zero value.
-
-Death tests are _not_ supported when other test framework is used to organize tests.
-
-_Availability:_ Linux, Windows, Mac; since v1.3.0.
-
-## Distributing Test Functions to Multiple Machines ##
-
-If you have more than one machine you can use to run a test program,
-you might want to run the test functions in parallel and get the
-result faster.  We call this technique _sharding_, where each machine
-is called a _shard_.
-
-Google Test is compatible with test sharding.  To take advantage of
-this feature, your test runner (not part of Google Test) needs to do
-the following:
-
-  1. Allocate a number of machines (shards) to run the tests.
-  1. On each shard, set the `GTEST_TOTAL_SHARDS` environment variable to the total number of shards.  It must be the same for all shards.
-  1. On each shard, set the `GTEST_SHARD_INDEX` environment variable to the index of the shard.  Different shards must be assigned different indices, which must be in the range `[0, GTEST_TOTAL_SHARDS - 1]`.
-  1. Run the same test program on all shards.  When Google Test sees the above two environment variables, it will select a subset of the test functions to run.  Across all shards, each test function in the program will be run exactly once.
-  1. Wait for all shards to finish, then collect and report the results.
-
-Your project may have tests that were written without Google Test and
-thus don't understand this protocol.  In order for your test runner to
-figure out which test supports sharding, it can set the environment
-variable `GTEST_SHARD_STATUS_FILE` to a non-existent file path.  If a
-test program supports sharding, it will create this file to
-acknowledge the fact (the actual contents of the file are not
-important at this time; although we may stick some useful information
-in it in the future.); otherwise it will not create it.
-
-Here's an example to make it clear.  Suppose you have a test program
-`foo_test` that contains the following 5 test functions:
-```
-TEST(A, V)
-TEST(A, W)
-TEST(B, X)
-TEST(B, Y)
-TEST(B, Z)
-```
-and you have 3 machines at your disposal.  To run the test functions in
-parallel, you would set `GTEST_TOTAL_SHARDS` to 3 on all machines, and
-set `GTEST_SHARD_INDEX` to 0, 1, and 2 on the machines respectively.
-Then you would run the same `foo_test` on each machine.
-
-Google Test reserves the right to change how the work is distributed
-across the shards, but here's one possible scenario:
-
-  * Machine #0 runs `A.V` and `B.X`.
-  * Machine #1 runs `A.W` and `B.Y`.
-  * Machine #2 runs `B.Z`.
-
-_Availability:_ Linux, Windows, Mac; since version 1.3.0.
-
-# Fusing Google Test Source Files #
-
-Google Test's implementation consists of ~30 files (excluding its own
-tests).  Sometimes you may want them to be packaged up in two files (a
-`.h` and a `.cc`) instead, such that you can easily copy them to a new
-machine and start hacking there.  For this we provide an experimental
-Python script `fuse_gtest_files.py` in the `scripts/` directory (since release 1.3.0).
-Assuming you have Python 2.4 or above installed on your machine, just
-go to that directory and run
-```
-python fuse_gtest_files.py OUTPUT_DIR
-```
-
-and you should see an `OUTPUT_DIR` directory being created with files
-`gtest/gtest.h` and `gtest/gtest-all.cc` in it.  These files contain
-everything you need to use Google Test.  Just copy them to anywhere
-you want and you are ready to write tests.  You can use the
-[scripts/test/Makefile](../scripts/test/Makefile)
-file as an example on how to compile your tests against them.
-
-# Where to Go from Here #
-
-Congratulations! You've now learned more advanced Google Test tools and are
-ready to tackle more complex testing tasks. If you want to dive even deeper, you
-can read the [Frequently-Asked Questions](FAQ.md).
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/DevGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/DevGuide.md
deleted file mode 100644
index 06467a32..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/DevGuide.md
+++ /dev/null
@@ -1,126 +0,0 @@
-
-
-If you are interested in understanding the internals of Google Test,
-building from source, or contributing ideas or modifications to the
-project, then this document is for you.
-
-# Introduction #
-
-First, let's give you some background of the project.
-
-## Licensing ##
-
-All Google Test source and pre-built packages are provided under the [New BSD License](http://www.opensource.org/licenses/bsd-license.php).
-
-## The Google Test Community ##
-
-The Google Test community exists primarily through the [discussion group](http://groups.google.com/group/googletestframework) and the GitHub repository.
-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.
-
-# Working with the Code #
-
-If you want to get your hands dirty with the code inside Google Test,
-this is the section for you.
-
-## Compiling from Source ##
-
-Once you check out the code, you can find instructions on how to
-compile it in the [README](../README.md) file.
-
-## Testing ##
-
-A testing framework is of no good if itself is not thoroughly tested.
-Tests should be written for any new code, and changes should be
-verified to not break existing tests before they are submitted for
-review. To perform the tests, follow the instructions in
-[README](../README.md) and verify that there are no failures.
-
-# Contributing Code #
-
-We are excited that Google Test is now open source, and hope to get
-great patches from the community. Before you fire up your favorite IDE
-and begin hammering away at that new feature, though, please take the
-time to read this section and understand the process. While it seems
-rigorous, we want to keep a high standard of quality in the code
-base.
-
-## Contributor License Agreements ##
-
-You must sign a Contributor License Agreement (CLA) before we can
-accept any code.  The CLA protects you and us.
-
-  * 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](http://code.google.com/legal/individual-cla-v1.0.html).
-  * If you work for a company that wants to allow you to contribute your work to Google Test, then you'll need to sign a [corporate CLA](http://code.google.com/legal/corporate-cla-v1.0.html).
-
-Follow either of the two links above to access the appropriate CLA and
-instructions for how to sign and return it.
-
-## Coding 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](http://code.google.com/p/google-styleguide/) project.  All patches will be expected
-to conform to the style outlined [here](http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml).
-
-## Updating Generated Code ##
-
-Some of Google Test's source files are generated by the Pump tool (a
-Python script).  If you need to update such files, please modify the
-source (`foo.h.pump`) and re-generate the C++ file using Pump.  You
-can read the PumpManual for details.
-
-## Submitting Patches ##
-
-Please do submit code. Here's what you need to do:
-
-  1. A submission should be a set of changes that addresses one issue in the [issue tracker](https://github.com/google/googletest/issues). 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.
-  1. 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.
-  1. Ensure that your code adheres to the [Google Test source code style](#Coding_Style.md).
-  1. Ensure that there are unit tests for your code.
-  1. Sign a Contributor License Agreement.
-  1. Create a Pull Request in the usual way.
-
-## Google Test Committers ##
-
-The current members of the Google Test engineering team are the only
-committers at present. In the great tradition of eating one's own
-dogfood, we will be requiring each new Google Test engineering team
-member to earn the right to become a committer by following the
-procedures in this document, writing consistently great code, and
-demonstrating repeatedly that he or she truly gets the zen of Google
-Test.
-
-# Release Process #
-
-We follow a typical release process:
-
-  1. A release branch named `release-X.Y` is created.
-  1. Bugs are fixed and features are added in trunk; those individual patches are merged into the release branch until it's stable.
-  1. An individual point release (the `Z` in `X.Y.Z`) is made by creating a tag from the branch.
-  1. Repeat steps 2 and 3 throughout one release cycle (as determined by features or time).
-  1. Go back to step 1 to create another release branch and so on.
-
----
-
-This page is based on the [Making GWT Better](http://code.google.com/webtoolkit/makinggwtbetter.html) guide from the [Google Web Toolkit](http://code.google.com/webtoolkit/) project.  Except as otherwise [noted](http://code.google.com/policies.html#restrictions), the content of this page is licensed under the [Creative Commons Attribution 2.5 License](http://creativecommons.org/licenses/by/2.5/).
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Documentation.md
deleted file mode 100644
index 8ca1aac7..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Documentation.md
+++ /dev/null
@@ -1,14 +0,0 @@
-This page lists all documentation wiki pages for Google Test **(the SVN trunk version)**
--- **if you use a released version of Google Test, please read the
-documentation for that specific version instead.**
-
-  * [Primer](Primer.md) -- start here if you are new to Google Test.
-  * [Samples](Samples.md) -- learn from examples.
-  * [AdvancedGuide](AdvancedGuide.md) -- learn more about Google Test.
-  * [XcodeGuide](XcodeGuide.md) -- how to use Google Test in Xcode on Mac.
-  * [Frequently-Asked Questions](FAQ.md) -- check here before asking a question on the mailing list.
-
-To contribute code to Google Test, read:
-
-  * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
-  * [PumpManual](PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/FAQ.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/FAQ.md
deleted file mode 100644
index 5fd6cb72..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/FAQ.md
+++ /dev/null
@@ -1,1087 +0,0 @@
-
-
-If you cannot find the answer to your question here, and you have read
-[Primer](Primer.md) and [AdvancedGuide](AdvancedGuide.md), send it to
-googletestframework@googlegroups.com.
-
-## Why should I use Google Test instead of my favorite C++ testing framework? ##
-
-First, let us say clearly that we don't want to get into the debate of
-which C++ testing framework is **the best**.  There exist many fine
-frameworks for writing C++ tests, and we have tremendous respect for
-the developers and users of them.  We don't think there is (or will
-be) a single best framework - you have to pick the right tool for the
-particular task you are tackling.
-
-We created Google Test because we couldn't find the right combination
-of features and conveniences in an existing framework to satisfy _our_
-needs.  The following is a list of things that _we_ like about Google
-Test.  We don't claim them to be unique to Google Test - rather, the
-combination of them makes Google Test the choice for us.  We hope this
-list can help you decide whether it is for you too.
-
-  * Google Test is designed to be portable: it doesn't require exceptions or RTTI; it works around various bugs in various compilers and environments; etc.  As a result, it works on Linux, Mac OS X, Windows and several embedded operating systems.
-  * Nonfatal assertions (`EXPECT_*`) have proven to be great time savers, as they allow a test to report multiple failures in a single edit-compile-test cycle.
-  * It's easy to write assertions that generate informative messages: you just use the stream syntax to append any additional information, e.g. `ASSERT_EQ(5, Foo(i)) << " where i = " << i;`.  It doesn't require a new set of macros or special functions.
-  * Google Test automatically detects your tests and doesn't require you to enumerate them in order to run them.
-  * Death tests are pretty handy for ensuring that your asserts in production code are triggered by the right conditions.
-  * `SCOPED_TRACE` helps you understand the context of an assertion failure when it comes from inside a sub-routine or loop.
-  * You can decide which tests to run using name patterns.  This saves time when you want to quickly reproduce a test failure.
-  * Google Test can generate XML test result reports that can be parsed by popular continuous build system like Hudson.
-  * Simple things are easy in Google Test, while hard things are possible: in addition to advanced features like [global test environments](AdvancedGuide.md#global-set-up-and-tear-down) and tests parameterized by [values](AdvancedGuide.md#value-parameterized-tests) or [types](docs/AdvancedGuide.md#typed-tests), Google Test supports various ways for the user to extend the framework -- if Google Test doesn't do something out of the box, chances are that a user can implement the feature using Google Test's public API, without changing Google Test itself.  In particular, you can:
-    * expand your testing vocabulary by defining [custom predicates](AdvancedGuide.md#predicate-assertions-for-better-error-messages),
-    * teach Google Test how to [print your types](AdvancedGuide.md#teaching-google-test-how-to-print-your-values),
-    * define your own testing macros or utilities and verify them using Google Test's [Service Provider Interface](AdvancedGuide.md#catching-failures), and
-    * reflect on the test cases or change the test output format by intercepting the [test events](AdvancedGuide.md#extending-google-test-by-handling-test-events).
-
-## I'm getting warnings when compiling Google Test.  Would you fix them? ##
-
-We strive to minimize compiler warnings Google Test generates.  Before releasing a new version, we test to make sure that it doesn't generate warnings when compiled using its CMake script on Windows, Linux, and Mac OS.
-
-Unfortunately, this doesn't mean you are guaranteed to see no warnings when compiling Google Test in your environment:
-
-  * You may be using a different compiler as we use, or a different version of the same compiler.  We cannot possibly test for all compilers.
-  * You may be compiling on a different platform as we do.
-  * Your project may be using different compiler flags as we do.
-
-It is not always possible to make Google Test warning-free for everyone.  Or, it may not be desirable if the warning is rarely enabled and fixing the violations makes the code more complex.
-
-If you see warnings when compiling Google Test, we suggest that you use the `-isystem` flag (assuming your are using GCC) to mark Google Test headers as system headers.  That'll suppress warnings from Google Test headers.
-
-## Why should not test case names and test names contain underscore? ##
-
-Underscore (`_`) is special, as C++ reserves the following to be used by
-the compiler and the standard library:
-
-  1. any identifier that starts with an `_` followed by an upper-case letter, and
-  1. any identifier that containers two consecutive underscores (i.e. `__`) _anywhere_ in its name.
-
-User code is _prohibited_ from using such identifiers.
-
-Now let's look at what this means for `TEST` and `TEST_F`.
-
-Currently `TEST(TestCaseName, TestName)` generates a class named
-`TestCaseName_TestName_Test`.  What happens if `TestCaseName` or `TestName`
-contains `_`?
-
-  1. If `TestCaseName` starts with an `_` followed by an upper-case letter (say, `_Foo`), we end up with `_Foo_TestName_Test`, which is reserved and thus invalid.
-  1. If `TestCaseName` ends with an `_` (say, `Foo_`), we get `Foo__TestName_Test`, which is invalid.
-  1. If `TestName` starts with an `_` (say, `_Bar`), we get `TestCaseName__Bar_Test`, which is invalid.
-  1. If `TestName` ends with an `_` (say, `Bar_`), we get `TestCaseName_Bar__Test`, which is invalid.
-
-So clearly `TestCaseName` and `TestName` cannot start or end with `_`
-(Actually, `TestCaseName` can start with `_` -- as long as the `_` isn't
-followed by an upper-case letter.  But that's getting complicated.  So
-for simplicity we just say that it cannot start with `_`.).
-
-It may seem fine for `TestCaseName` and `TestName` to contain `_` in the
-middle.  However, consider this:
-``` cpp
-TEST(Time, Flies_Like_An_Arrow) { ... }
-TEST(Time_Flies, Like_An_Arrow) { ... }
-```
-
-Now, the two `TEST`s will both generate the same class
-(`Time_Files_Like_An_Arrow_Test`).  That's not good.
-
-So for simplicity, we just ask the users to avoid `_` in `TestCaseName`
-and `TestName`.  The rule is more constraining than necessary, but it's
-simple and easy to remember.  It also gives Google Test some wiggle
-room in case its implementation needs to change in the future.
-
-If you violate the rule, there may not be immediately consequences,
-but your test may (just may) break with a new compiler (or a new
-version of the compiler you are using) or with a new version of Google
-Test.  Therefore it's best to follow the rule.
-
-## Why is it not recommended to install a pre-compiled copy of Google Test (for example, into /usr/local)? ##
-
-In the early days, we said that you could install
-compiled Google Test libraries on `*`nix systems using `make install`.
-Then every user of your machine can write tests without
-recompiling Google Test.
-
-This seemed like a good idea, but it has a
-got-cha: every user needs to compile his tests using the _same_ compiler
-flags used to compile the installed Google Test libraries; otherwise
-he may run into undefined behaviors (i.e. the tests can behave
-strangely and may even crash for no obvious reasons).
-
-Why?  Because C++ has this thing called the One-Definition Rule: if
-two C++ source files contain different definitions of the same
-class/function/variable, and you link them together, you violate the
-rule.  The linker may or may not catch the error (in many cases it's
-not required by the C++ standard to catch the violation).  If it
-doesn't, you get strange run-time behaviors that are unexpected and
-hard to debug.
-
-If you compile Google Test and your test code using different compiler
-flags, they may see different definitions of the same
-class/function/variable (e.g. due to the use of `#if` in Google Test).
-Therefore, for your sanity, we recommend to avoid installing pre-compiled
-Google Test libraries.  Instead, each project should compile
-Google Test itself such that it can be sure that the same flags are
-used for both Google Test and the tests.
-
-## How do I generate 64-bit binaries on Windows (using Visual Studio 2008)? ##
-
-(Answered by Trevor Robinson)
-
-Load the supplied Visual Studio solution file, either `msvc\gtest-md.sln` or
-`msvc\gtest.sln`. Go through the migration wizard to migrate the
-solution and project files to Visual Studio 2008. Select
-`Configuration Manager...` from the `Build` menu. Select `<New...>` from
-the `Active solution platform` dropdown.  Select `x64` from the new
-platform dropdown, leave `Copy settings from` set to `Win32` and
-`Create new project platforms` checked, then click `OK`. You now have
-`Win32` and `x64` platform configurations, selectable from the
-`Standard` toolbar, which allow you to toggle between building 32-bit or
-64-bit binaries (or both at once using Batch Build).
-
-In order to prevent build output files from overwriting one another,
-you'll need to change the `Intermediate Directory` settings for the
-newly created platform configuration across all the projects. To do
-this, multi-select (e.g. using shift-click) all projects (but not the
-solution) in the `Solution Explorer`. Right-click one of them and
-select `Properties`. In the left pane, select `Configuration Properties`,
-and from the `Configuration` dropdown, select `All Configurations`.
-Make sure the selected platform is `x64`. For the
-`Intermediate Directory` setting, change the value from
-`$(PlatformName)\$(ConfigurationName)` to
-`$(OutDir)\$(ProjectName)`. Click `OK` and then build the
-solution. When the build is complete, the 64-bit binaries will be in
-the `msvc\x64\Debug` directory.
-
-## Can I use Google Test on MinGW? ##
-
-We haven't tested this ourselves, but Per Abrahamsen reported that he
-was able to compile and install Google Test successfully when using
-MinGW from Cygwin.  You'll need to configure it with:
-
-`PATH/TO/configure CC="gcc -mno-cygwin" CXX="g++ -mno-cygwin"`
-
-You should be able to replace the `-mno-cygwin` option with direct links
-to the real MinGW binaries, but we haven't tried that.
-
-Caveats:
-
-  * There are many warnings when compiling.
-  * `make check` will produce some errors as not all tests for Google Test itself are compatible with MinGW.
-
-We also have reports on successful cross compilation of Google Test
-MinGW binaries on Linux using
-[these instructions](http://wiki.wxwidgets.org/Cross-Compiling_Under_Linux#Cross-compiling_under_Linux_for_MS_Windows)
-on the WxWidgets site.
-
-Please contact `googletestframework@googlegroups.com` if you are
-interested in improving the support for MinGW.
-
-## Why does Google Test support EXPECT\_EQ(NULL, ptr) and ASSERT\_EQ(NULL, ptr) but not EXPECT\_NE(NULL, ptr) and ASSERT\_NE(NULL, ptr)? ##
-
-Due to some peculiarity of C++, it requires some non-trivial template
-meta programming tricks to support using `NULL` as an argument of the
-`EXPECT_XX()` and `ASSERT_XX()` macros. Therefore we only do it where
-it's most needed (otherwise we make the implementation of Google Test
-harder to maintain and more error-prone than necessary).
-
-The `EXPECT_EQ()` macro takes the _expected_ value as its first
-argument and the _actual_ value as the second. It's reasonable that
-someone wants to write `EXPECT_EQ(NULL, some_expression)`, and this
-indeed was requested several times. Therefore we implemented it.
-
-The need for `EXPECT_NE(NULL, ptr)` isn't nearly as strong. When the
-assertion fails, you already know that `ptr` must be `NULL`, so it
-doesn't add any information to print ptr in this case. That means
-`EXPECT_TRUE(ptr != NULL)` works just as well.
-
-If we were to support `EXPECT_NE(NULL, ptr)`, for consistency we'll
-have to support `EXPECT_NE(ptr, NULL)` as well, as unlike `EXPECT_EQ`,
-we don't have a convention on the order of the two arguments for
-`EXPECT_NE`. This means using the template meta programming tricks
-twice in the implementation, making it even harder to understand and
-maintain. We believe the benefit doesn't justify the cost.
-
-Finally, with the growth of Google Mock's [matcher](../../googlemock/docs/CookBook.md#using-matchers-in-google-test-assertions) library, we are
-encouraging people to use the unified `EXPECT_THAT(value, matcher)`
-syntax more often in tests. One significant advantage of the matcher
-approach is that matchers can be easily combined to form new matchers,
-while the `EXPECT_NE`, etc, macros cannot be easily
-combined. Therefore we want to invest more in the matchers than in the
-`EXPECT_XX()` macros.
-
-## Does Google Test support running tests in parallel? ##
-
-Test runners tend to be tightly coupled with the build/test
-environment, and Google Test doesn't try to solve the problem of
-running tests in parallel.  Instead, we tried to make Google Test work
-nicely with test runners.  For example, Google Test's XML report
-contains the time spent on each test, and its `gtest_list_tests` and
-`gtest_filter` flags can be used for splitting the execution of test
-methods into multiple processes.  These functionalities can help the
-test runner run the tests in parallel.
-
-## Why don't Google Test run the tests in different threads to speed things up? ##
-
-It's difficult to write thread-safe code.  Most tests are not written
-with thread-safety in mind, and thus may not work correctly in a
-multi-threaded setting.
-
-If you think about it, it's already hard to make your code work when
-you know what other threads are doing.  It's much harder, and
-sometimes even impossible, to make your code work when you don't know
-what other threads are doing (remember that test methods can be added,
-deleted, or modified after your test was written).  If you want to run
-the tests in parallel, you'd better run them in different processes.
-
-## Why aren't Google Test assertions implemented using exceptions? ##
-
-Our original motivation was to be able to use Google Test in projects
-that disable exceptions.  Later we realized some additional benefits
-of this approach:
-
-  1. Throwing in a destructor is undefined behavior in C++.  Not using exceptions means Google Test's assertions are safe to use in destructors.
-  1. The `EXPECT_*` family of macros will continue even after a failure, allowing multiple failures in a `TEST` to be reported in a single run. This is a popular feature, as in C++ the edit-compile-test cycle is usually quite long and being able to fixing more than one thing at a time is a blessing.
-  1. If assertions are implemented using exceptions, a test may falsely ignore a failure if it's caught by user code:
-``` cpp
-try { ... ASSERT_TRUE(...) ... }
-catch (...) { ... }
-```
-The above code will pass even if the `ASSERT_TRUE` throws.  While it's unlikely for someone to write this in a test, it's possible to run into this pattern when you write assertions in callbacks that are called by the code under test.
-
-The downside of not using exceptions is that `ASSERT_*` (implemented
-using `return`) will only abort the current function, not the current
-`TEST`.
-
-## Why do we use two different macros for tests with and without fixtures? ##
-
-Unfortunately, C++'s macro system doesn't allow us to use the same
-macro for both cases.  One possibility is to provide only one macro
-for tests with fixtures, and require the user to define an empty
-fixture sometimes:
-
-``` cpp
-class FooTest : public ::testing::Test {};
-
-TEST_F(FooTest, DoesThis) { ... }
-```
-or
-``` cpp
-typedef ::testing::Test FooTest;
-
-TEST_F(FooTest, DoesThat) { ... }
-```
-
-Yet, many people think this is one line too many. :-) Our goal was to
-make it really easy to write tests, so we tried to make simple tests
-trivial to create.  That means using a separate macro for such tests.
-
-We think neither approach is ideal, yet either of them is reasonable.
-In the end, it probably doesn't matter much either way.
-
-## Why don't we use structs as test fixtures? ##
-
-We like to use structs only when representing passive data.  This
-distinction between structs and classes is good for documenting the
-intent of the code's author.  Since test fixtures have logic like
-`SetUp()` and `TearDown()`, they are better defined as classes.
-
-## Why are death tests implemented as assertions instead of using a test runner? ##
-
-Our goal was to make death tests as convenient for a user as C++
-possibly allows.  In particular:
-
-  * The runner-style requires to split the information into two pieces: the definition of the death test itself, and the specification for the runner on how to run the death test and what to expect.  The death test would be written in C++, while the runner spec may or may not be.  A user needs to carefully keep the two in sync. `ASSERT_DEATH(statement, expected_message)` specifies all necessary information in one place, in one language, without boilerplate code. It is very declarative.
-  * `ASSERT_DEATH` has a similar syntax and error-reporting semantics as other Google Test assertions, and thus is easy to learn.
-  * `ASSERT_DEATH` can be mixed with other assertions and other logic at your will.  You are not limited to one death test per test method. For example, you can write something like:
-``` cpp
-    if (FooCondition()) {
-      ASSERT_DEATH(Bar(), "blah");
-    } else {
-      ASSERT_EQ(5, Bar());
-    }
-```
-If you prefer one death test per test method, you can write your tests in that style too, but we don't want to impose that on the users.  The fewer artificial limitations the better.
-  * `ASSERT_DEATH` can reference local variables in the current function, and you can decide how many death tests you want based on run-time information.  For example,
-``` cpp
-    const int count = GetCount();  // Only known at run time.
-    for (int i = 1; i <= count; i++) {
-      ASSERT_DEATH({
-        double* buffer = new double[i];
-        ... initializes buffer ...
-        Foo(buffer, i)
-      }, "blah blah");
-    }
-```
-The runner-based approach tends to be more static and less flexible, or requires more user effort to get this kind of flexibility.
-
-Another interesting thing about `ASSERT_DEATH` is that it calls `fork()`
-to create a child process to run the death test.  This is lightening
-fast, as `fork()` uses copy-on-write pages and incurs almost zero
-overhead, and the child process starts from the user-supplied
-statement directly, skipping all global and local initialization and
-any code leading to the given statement.  If you launch the child
-process from scratch, it can take seconds just to load everything and
-start running if the test links to many libraries dynamically.
-
-## My death test modifies some state, but the change seems lost after the death test finishes. Why? ##
-
-Death tests (`EXPECT_DEATH`, etc) are executed in a sub-process s.t. the
-expected crash won't kill the test program (i.e. the parent process). As a
-result, any in-memory side effects they incur are observable in their
-respective sub-processes, but not in the parent process. You can think of them
-as running in a parallel universe, more or less.
-
-## The compiler complains about "undefined references" to some static const member variables, but I did define them in the class body. What's wrong? ##
-
-If your class has a static data member:
-
-``` cpp
-// foo.h
-class Foo {
-  ...
-  static const int kBar = 100;
-};
-```
-
-You also need to define it _outside_ of the class body in `foo.cc`:
-
-``` cpp
-const int Foo::kBar;  // No initializer here.
-```
-
-Otherwise your code is **invalid C++**, and may break in unexpected ways. In
-particular, using it in Google Test comparison assertions (`EXPECT_EQ`, etc)
-will generate an "undefined reference" linker error.
-
-## I have an interface that has several implementations. Can I write a set of tests once and repeat them over all the implementations? ##
-
-Google Test doesn't yet have good support for this kind of tests, or
-data-driven tests in general. We hope to be able to make improvements in this
-area soon.
-
-## Can I derive a test fixture from another? ##
-
-Yes.
-
-Each test fixture has a corresponding and same named test case. This means only
-one test case can use a particular fixture. Sometimes, however, multiple test
-cases may want to use the same or slightly different fixtures. For example, you
-may want to make sure that all of a GUI library's test cases don't leak
-important system resources like fonts and brushes.
-
-In Google Test, you share a fixture among test cases by putting the shared
-logic in a base test fixture, then deriving from that base a separate fixture
-for each test case that wants to use this common logic. You then use `TEST_F()`
-to write tests using each derived fixture.
-
-Typically, your code looks like this:
-
-``` cpp
-// Defines a base test fixture.
-class BaseTest : public ::testing::Test {
-  protected:
-   ...
-};
-
-// Derives a fixture FooTest from BaseTest.
-class FooTest : public BaseTest {
-  protected:
-    virtual void SetUp() {
-      BaseTest::SetUp();  // Sets up the base fixture first.
-      ... additional set-up work ...
-    }
-    virtual void TearDown() {
-      ... clean-up work for FooTest ...
-      BaseTest::TearDown();  // Remember to tear down the base fixture
-                             // after cleaning up FooTest!
-    }
-    ... functions and variables for FooTest ...
-};
-
-// Tests that use the fixture FooTest.
-TEST_F(FooTest, Bar) { ... }
-TEST_F(FooTest, Baz) { ... }
-
-... additional fixtures derived from BaseTest ...
-```
-
-If necessary, you can continue to derive test fixtures from a derived fixture.
-Google Test has no limit on how deep the hierarchy can be.
-
-For a complete example using derived test fixtures, see
-[sample5](../samples/sample5_unittest.cc).
-
-## My compiler complains "void value not ignored as it ought to be." What does this mean? ##
-
-You're probably using an `ASSERT_*()` in a function that doesn't return `void`.
-`ASSERT_*()` can only be used in `void` functions.
-
-## My death test hangs (or seg-faults). How do I fix it? ##
-
-In Google Test, death tests are run in a child process and the way they work is
-delicate. To write death tests you really need to understand how they work.
-Please make sure you have read this.
-
-In particular, death tests don't like having multiple threads in the parent
-process. So the first thing you can try is to eliminate creating threads
-outside of `EXPECT_DEATH()`.
-
-Sometimes this is impossible as some library you must use may be creating
-threads before `main()` is even reached. In this case, you can try to minimize
-the chance of conflicts by either moving as many activities as possible inside
-`EXPECT_DEATH()` (in the extreme case, you want to move everything inside), or
-leaving as few things as possible in it. Also, you can try to set the death
-test style to `"threadsafe"`, which is safer but slower, and see if it helps.
-
-If you go with thread-safe death tests, remember that they rerun the test
-program from the beginning in the child process. Therefore make sure your
-program can run side-by-side with itself and is deterministic.
-
-In the end, this boils down to good concurrent programming. You have to make
-sure that there is no race conditions or dead locks in your program. No silver
-bullet - sorry!
-
-## Should I use the constructor/destructor of the test fixture or the set-up/tear-down function? ##
-
-The first thing to remember is that Google Test does not reuse the
-same test fixture object across multiple tests. For each `TEST_F`,
-Google Test will create a fresh test fixture object, _immediately_
-call `SetUp()`, run the test body, call `TearDown()`, and then
-_immediately_ delete the test fixture object.
-
-When you need to write per-test set-up and tear-down logic, you have
-the choice between using the test fixture constructor/destructor or
-`SetUp()/TearDown()`. The former is usually preferred, as it has the
-following benefits:
-
-  * By initializing a member variable in the constructor, we have the option to make it `const`, which helps prevent accidental changes to its value and makes the tests more obviously correct.
-  * In case we need to subclass the test fixture class, the subclass' constructor is guaranteed to call the base class' constructor first, and the subclass' destructor is guaranteed to call the base class' destructor afterward. With `SetUp()/TearDown()`, a subclass may make the mistake of forgetting to call the base class' `SetUp()/TearDown()` or call them at the wrong moment.
-
-You may still want to use `SetUp()/TearDown()` in the following rare cases:
-  * If the tear-down operation could throw an exception, you must use `TearDown()` as opposed to the destructor, as throwing in a destructor leads to undefined behavior and usually will kill your program right away. Note that many standard libraries (like STL) may throw when exceptions are enabled in the compiler. Therefore you should prefer `TearDown()` if you want to write portable tests that work with or without exceptions.
-  * The assertion macros throw an exception when flag `--gtest_throw_on_failure` is specified. Therefore, you shouldn't use Google Test assertions in a destructor if you plan to run your tests with this flag.
-  * In a constructor or destructor, you cannot make a virtual function call on this object. (You can call a method declared as virtual, but it will be statically bound.) Therefore, if you need to call a method that will be overriden in a derived class, you have to use `SetUp()/TearDown()`.
-
-## The compiler complains "no matching function to call" when I use ASSERT\_PREDn. How do I fix it? ##
-
-If the predicate function you use in `ASSERT_PRED*` or `EXPECT_PRED*` is
-overloaded or a template, the compiler will have trouble figuring out which
-overloaded version it should use. `ASSERT_PRED_FORMAT*` and
-`EXPECT_PRED_FORMAT*` don't have this problem.
-
-If you see this error, you might want to switch to
-`(ASSERT|EXPECT)_PRED_FORMAT*`, which will also give you a better failure
-message. If, however, that is not an option, you can resolve the problem by
-explicitly telling the compiler which version to pick.
-
-For example, suppose you have
-
-``` cpp
-bool IsPositive(int n) {
-  return n > 0;
-}
-bool IsPositive(double x) {
-  return x > 0;
-}
-```
-
-you will get a compiler error if you write
-
-``` cpp
-EXPECT_PRED1(IsPositive, 5);
-```
-
-However, this will work:
-
-``` cpp
-EXPECT_PRED1(*static_cast<bool (*)(int)>*(IsPositive), 5);
-```
-
-(The stuff inside the angled brackets for the `static_cast` operator is the
-type of the function pointer for the `int`-version of `IsPositive()`.)
-
-As another example, when you have a template function
-
-``` cpp
-template <typename T>
-bool IsNegative(T x) {
-  return x < 0;
-}
-```
-
-you can use it in a predicate assertion like this:
-
-``` cpp
-ASSERT_PRED1(IsNegative*<int>*, -5);
-```
-
-Things are more interesting if your template has more than one parameters. The
-following won't compile:
-
-``` cpp
-ASSERT_PRED2(*GreaterThan<int, int>*, 5, 0);
-```
-
-
-as the C++ pre-processor thinks you are giving `ASSERT_PRED2` 4 arguments,
-which is one more than expected. The workaround is to wrap the predicate
-function in parentheses:
-
-``` cpp
-ASSERT_PRED2(*(GreaterThan<int, int>)*, 5, 0);
-```
-
-
-## My compiler complains about "ignoring return value" when I call RUN\_ALL\_TESTS(). Why? ##
-
-Some people had been ignoring the return value of `RUN_ALL_TESTS()`. That is,
-instead of
-
-``` cpp
-return RUN_ALL_TESTS();
-```
-
-they write
-
-``` cpp
-RUN_ALL_TESTS();
-```
-
-This is wrong and dangerous. A test runner needs to see the return value of
-`RUN_ALL_TESTS()` in order to determine if a test has passed. If your `main()`
-function ignores it, your test will be considered successful even if it has a
-Google Test assertion failure. Very bad.
-
-To help the users avoid this dangerous bug, the implementation of
-`RUN_ALL_TESTS()` causes gcc to raise this warning, when the return value is
-ignored. If you see this warning, the fix is simple: just make sure its value
-is used as the return value of `main()`.
-
-## My compiler complains that a constructor (or destructor) cannot return a value. What's going on? ##
-
-Due to a peculiarity of C++, in order to support the syntax for streaming
-messages to an `ASSERT_*`, e.g.
-
-``` cpp
-ASSERT_EQ(1, Foo()) << "blah blah" << foo;
-```
-
-we had to give up using `ASSERT*` and `FAIL*` (but not `EXPECT*` and
-`ADD_FAILURE*`) in constructors and destructors. The workaround is to move the
-content of your constructor/destructor to a private void member function, or
-switch to `EXPECT_*()` if that works. This section in the user's guide explains
-it.
-
-## My set-up function is not called. Why? ##
-
-C++ is case-sensitive. It should be spelled as `SetUp()`.  Did you
-spell it as `Setup()`?
-
-Similarly, sometimes people spell `SetUpTestCase()` as `SetupTestCase()` and
-wonder why it's never called.
-
-## How do I jump to the line of a failure in Emacs directly? ##
-
-Google Test's failure message format is understood by Emacs and many other
-IDEs, like acme and XCode. If a Google Test message is in a compilation buffer
-in Emacs, then it's clickable. You can now hit `enter` on a message to jump to
-the corresponding source code, or use `C-x `` to jump to the next failure.
-
-## I have several test cases which share the same test fixture logic, do I have to define a new test fixture class for each of them? This seems pretty tedious. ##
-
-You don't have to. Instead of
-
-``` cpp
-class FooTest : public BaseTest {};
-
-TEST_F(FooTest, Abc) { ... }
-TEST_F(FooTest, Def) { ... }
-
-class BarTest : public BaseTest {};
-
-TEST_F(BarTest, Abc) { ... }
-TEST_F(BarTest, Def) { ... }
-```
-
-you can simply `typedef` the test fixtures:
-``` cpp
-typedef BaseTest FooTest;
-
-TEST_F(FooTest, Abc) { ... }
-TEST_F(FooTest, Def) { ... }
-
-typedef BaseTest BarTest;
-
-TEST_F(BarTest, Abc) { ... }
-TEST_F(BarTest, Def) { ... }
-```
-
-## The Google Test output is buried in a whole bunch of log messages. What do I do? ##
-
-The Google Test output is meant to be a concise and human-friendly report. If
-your test generates textual output itself, it will mix with the Google Test
-output, making it hard to read. However, there is an easy solution to this
-problem.
-
-Since most log messages go to stderr, we decided to let Google Test output go
-to stdout. This way, you can easily separate the two using redirection. For
-example:
-```
-./my_test > googletest_output.txt
-```
-
-## Why should I prefer test fixtures over global variables? ##
-
-There are several good reasons:
-  1. It's likely your test needs to change the states of its global variables. This makes it difficult to keep side effects from escaping one test and contaminating others, making debugging difficult. By using fixtures, each test has a fresh set of variables that's different (but with the same names). Thus, tests are kept independent of each other.
-  1. Global variables pollute the global namespace.
-  1. Test fixtures can be reused via subclassing, which cannot be done easily with global variables. This is useful if many test cases have something in common.
-
-## How do I test private class members without writing FRIEND\_TEST()s? ##
-
-You should try to write testable code, which means classes should be easily
-tested from their public interface. One way to achieve this is the Pimpl idiom:
-you move all private members of a class into a helper class, and make all
-members of the helper class public.
-
-You have several other options that don't require using `FRIEND_TEST`:
-  * Write the tests as members of the fixture class:
-``` cpp
-class Foo {
-  friend class FooTest;
-  ...
-};
-
-class FooTest : public ::testing::Test {
- protected:
-  ...
-  void Test1() {...} // This accesses private members of class Foo.
-  void Test2() {...} // So does this one.
-};
-
-TEST_F(FooTest, Test1) {
-  Test1();
-}
-
-TEST_F(FooTest, Test2) {
-  Test2();
-}
-```
-  * In the fixture class, write accessors for the tested class' private members, then use the accessors in your tests:
-``` cpp
-class Foo {
-  friend class FooTest;
-  ...
-};
-
-class FooTest : public ::testing::Test {
- protected:
-  ...
-  T1 get_private_member1(Foo* obj) {
-    return obj->private_member1_;
-  }
-};
-
-TEST_F(FooTest, Test1) {
-  ...
-  get_private_member1(x)
-  ...
-}
-```
-  * If the methods are declared **protected**, you can change their access level in a test-only subclass:
-``` cpp
-class YourClass {
-  ...
- protected: // protected access for testability.
-  int DoSomethingReturningInt();
-  ...
-};
-
-// in the your_class_test.cc file:
-class TestableYourClass : public YourClass {
-  ...
- public: using YourClass::DoSomethingReturningInt; // changes access rights
-  ...
-};
-
-TEST_F(YourClassTest, DoSomethingTest) {
-  TestableYourClass obj;
-  assertEquals(expected_value, obj.DoSomethingReturningInt());
-}
-```
-
-## How do I test private class static members without writing FRIEND\_TEST()s? ##
-
-We find private static methods clutter the header file.  They are
-implementation details and ideally should be kept out of a .h. So often I make
-them free functions instead.
-
-Instead of:
-``` cpp
-// foo.h
-class Foo {
-  ...
- private:
-  static bool Func(int n);
-};
-
-// foo.cc
-bool Foo::Func(int n) { ... }
-
-// foo_test.cc
-EXPECT_TRUE(Foo::Func(12345));
-```
-
-You probably should better write:
-``` cpp
-// foo.h
-class Foo {
-  ...
-};
-
-// foo.cc
-namespace internal {
-  bool Func(int n) { ... }
-}
-
-// foo_test.cc
-namespace internal {
-  bool Func(int n);
-}
-
-EXPECT_TRUE(internal::Func(12345));
-```
-
-## I would like to run a test several times with different parameters. Do I need to write several similar copies of it? ##
-
-No. You can use a feature called [value-parameterized tests](AdvancedGuide.md#Value_Parameterized_Tests) which
-lets you repeat your tests with different parameters, without defining it more than once.
-
-## How do I test a file that defines main()? ##
-
-To test a `foo.cc` file, you need to compile and link it into your unit test
-program. However, when the file contains a definition for the `main()`
-function, it will clash with the `main()` of your unit test, and will result in
-a build error.
-
-The right solution is to split it into three files:
-  1. `foo.h` which contains the declarations,
-  1. `foo.cc` which contains the definitions except `main()`, and
-  1. `foo_main.cc` which contains nothing but the definition of `main()`.
-
-Then `foo.cc` can be easily tested.
-
-If you are adding tests to an existing file and don't want an intrusive change
-like this, there is a hack: just include the entire `foo.cc` file in your unit
-test. For example:
-``` cpp
-// File foo_unittest.cc
-
-// The headers section
-...
-
-// Renames main() in foo.cc to make room for the unit test main()
-#define main FooMain
-
-#include "a/b/foo.cc"
-
-// The tests start here.
-...
-```
-
-
-However, please remember this is a hack and should only be used as the last
-resort.
-
-## What can the statement argument in ASSERT\_DEATH() be? ##
-
-`ASSERT_DEATH(_statement_, _regex_)` (or any death assertion macro) can be used
-wherever `_statement_` is valid. So basically `_statement_` can be any C++
-statement that makes sense in the current context. In particular, it can
-reference global and/or local variables, and can be:
-  * a simple function call (often the case),
-  * a complex expression, or
-  * a compound statement.
-
-Some examples are shown here:
-
-``` cpp
-// A death test can be a simple function call.
-TEST(MyDeathTest, FunctionCall) {
-  ASSERT_DEATH(Xyz(5), "Xyz failed");
-}
-
-// Or a complex expression that references variables and functions.
-TEST(MyDeathTest, ComplexExpression) {
-  const bool c = Condition();
-  ASSERT_DEATH((c ? Func1(0) : object2.Method("test")),
-               "(Func1|Method) failed");
-}
-
-// Death assertions can be used any where in a function. In
-// particular, they can be inside a loop.
-TEST(MyDeathTest, InsideLoop) {
-  // Verifies that Foo(0), Foo(1), ..., and Foo(4) all die.
-  for (int i = 0; i < 5; i++) {
-    EXPECT_DEATH_M(Foo(i), "Foo has \\d+ errors",
-                   ::testing::Message() << "where i is " << i);
-  }
-}
-
-// A death assertion can contain a compound statement.
-TEST(MyDeathTest, CompoundStatement) {
-  // Verifies that at lease one of Bar(0), Bar(1), ..., and
-  // Bar(4) dies.
-  ASSERT_DEATH({
-    for (int i = 0; i < 5; i++) {
-      Bar(i);
-    }
-  },
-  "Bar has \\d+ errors");}
-```
-
-`googletest_unittest.cc` contains more examples if you are interested.
-
-## What syntax does the regular expression in ASSERT\_DEATH use? ##
-
-On POSIX systems, Google Test uses the POSIX Extended regular
-expression syntax
-(http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
-On Windows, it uses a limited variant of regular expression
-syntax. For more details, see the
-[regular expression syntax](AdvancedGuide.md#Regular_Expression_Syntax).
-
-## I have a fixture class Foo, but TEST\_F(Foo, Bar) gives me error "no matching function for call to Foo::Foo()". Why? ##
-
-Google Test needs to be able to create objects of your test fixture class, so
-it must have a default constructor. Normally the compiler will define one for
-you. However, there are cases where you have to define your own:
-  * If you explicitly declare a non-default constructor for class `Foo`, then you need to define a default constructor, even if it would be empty.
-  * If `Foo` has a const non-static data member, then you have to define the default constructor _and_ initialize the const member in the initializer list of the constructor. (Early versions of `gcc` doesn't force you to initialize the const member. It's a bug that has been fixed in `gcc 4`.)
-
-## Why does ASSERT\_DEATH complain about previous threads that were already joined? ##
-
-With the Linux pthread library, there is no turning back once you cross the
-line from single thread to multiple threads. The first time you create a
-thread, a manager thread is created in addition, so you get 3, not 2, threads.
-Later when the thread you create joins the main thread, the thread count
-decrements by 1, but the manager thread will never be killed, so you still have
-2 threads, which means you cannot safely run a death test.
-
-The new NPTL thread library doesn't suffer from this problem, as it doesn't
-create a manager thread. However, if you don't control which machine your test
-runs on, you shouldn't depend on this.
-
-## Why does Google Test require the entire test case, instead of individual tests, to be named FOODeathTest when it uses ASSERT\_DEATH? ##
-
-Google Test does not interleave tests from different test cases. That is, it
-runs all tests in one test case first, and then runs all tests in the next test
-case, and so on. Google Test does this because it needs to set up a test case
-before the first test in it is run, and tear it down afterwords. Splitting up
-the test case would require multiple set-up and tear-down processes, which is
-inefficient and makes the semantics unclean.
-
-If we were to determine the order of tests based on test name instead of test
-case name, then we would have a problem with the following situation:
-
-``` cpp
-TEST_F(FooTest, AbcDeathTest) { ... }
-TEST_F(FooTest, Uvw) { ... }
-
-TEST_F(BarTest, DefDeathTest) { ... }
-TEST_F(BarTest, Xyz) { ... }
-```
-
-Since `FooTest.AbcDeathTest` needs to run before `BarTest.Xyz`, and we don't
-interleave tests from different test cases, we need to run all tests in the
-`FooTest` case before running any test in the `BarTest` case. This contradicts
-with the requirement to run `BarTest.DefDeathTest` before `FooTest.Uvw`.
-
-## But I don't like calling my entire test case FOODeathTest when it contains both death tests and non-death tests. What do I do? ##
-
-You don't have to, but if you like, you may split up the test case into
-`FooTest` and `FooDeathTest`, where the names make it clear that they are
-related:
-
-``` cpp
-class FooTest : public ::testing::Test { ... };
-
-TEST_F(FooTest, Abc) { ... }
-TEST_F(FooTest, Def) { ... }
-
-typedef FooTest FooDeathTest;
-
-TEST_F(FooDeathTest, Uvw) { ... EXPECT_DEATH(...) ... }
-TEST_F(FooDeathTest, Xyz) { ... ASSERT_DEATH(...) ... }
-```
-
-## The compiler complains about "no match for 'operator<<'" when I use an assertion. What gives? ##
-
-If you use a user-defined type `FooType` in an assertion, you must make sure
-there is an `std::ostream& operator<<(std::ostream&, const FooType&)` function
-defined such that we can print a value of `FooType`.
-
-In addition, if `FooType` is declared in a name space, the `<<` operator also
-needs to be defined in the _same_ name space.
-
-## How do I suppress the memory leak messages on Windows? ##
-
-Since the statically initialized Google Test singleton requires allocations on
-the heap, the Visual C++ memory leak detector will report memory leaks at the
-end of the program run. The easiest way to avoid this is to use the
-`_CrtMemCheckpoint` and `_CrtMemDumpAllObjectsSince` calls to not report any
-statically initialized heap objects. See MSDN for more details and additional
-heap check/debug routines.
-
-## I am building my project with Google Test in Visual Studio and all I'm getting is a bunch of linker errors (or warnings). Help! ##
-
-You may get a number of the following linker error or warnings if you
-attempt to link your test project with the Google Test library when
-your project and the are not built using the same compiler settings.
-
-  * LNK2005: symbol already defined in object
-  * LNK4217: locally defined symbol 'symbol' imported in function 'function'
-  * LNK4049: locally defined symbol 'symbol' imported
-
-The Google Test project (gtest.vcproj) has the Runtime Library option
-set to /MT (use multi-threaded static libraries, /MTd for debug). If
-your project uses something else, for example /MD (use multi-threaded
-DLLs, /MDd for debug), you need to change the setting in the Google
-Test project to match your project's.
-
-To update this setting open the project properties in the Visual
-Studio IDE then select the branch Configuration Properties | C/C++ |
-Code Generation and change the option "Runtime Library".  You may also try
-using gtest-md.vcproj instead of gtest.vcproj.
-
-## I put my tests in a library and Google Test doesn't run them. What's happening? ##
-Have you read a
-[warning](Primer.md#important-note-for-visual-c-users) on
-the Google Test Primer page?
-
-## I want to use Google Test with Visual Studio but don't know where to start. ##
-Many people are in your position and one of the posted his solution to
-our mailing list.
-
-## I am seeing compile errors mentioning std::type\_traits when I try to use Google Test on Solaris. ##
-Google Test uses parts of the standard C++ library that SunStudio does not support.
-Our users reported success using alternative implementations. Try running the build after runing this commad:
-
-`export CC=cc CXX=CC CXXFLAGS='-library=stlport4'`
-
-## How can my code detect if it is running in a test? ##
-
-If you write code that sniffs whether it's running in a test and does
-different things accordingly, you are leaking test-only logic into
-production code and there is no easy way to ensure that the test-only
-code paths aren't run by mistake in production.  Such cleverness also
-leads to
-[Heisenbugs](http://en.wikipedia.org/wiki/Unusual_software_bug#Heisenbug).
-Therefore we strongly advise against the practice, and Google Test doesn't
-provide a way to do it.
-
-In general, the recommended way to cause the code to behave
-differently under test is [dependency injection](http://jamesshore.com/Blog/Dependency-Injection-Demystified.html).
-You can inject different functionality from the test and from the
-production code.  Since your production code doesn't link in the
-for-test logic at all, there is no danger in accidentally running it.
-
-However, if you _really_, _really_, _really_ have no choice, and if
-you follow the rule of ending your test program names with `_test`,
-you can use the _horrible_ hack of sniffing your executable name
-(`argv[0]` in `main()`) to know whether the code is under test.
-
-## Google Test defines a macro that clashes with one defined by another library. How do I deal with that? ##
-
-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 Google Test macro clashes with another
-library, you can force Google Test to rename its macro to avoid the
-conflict.
-
-Specifically, if both Google Test and some other code define macro
-`FOO`, you can add
-```
-  -DGTEST_DONT_DEFINE_FOO=1
-```
-to the compiler flags to tell Google Test to change the macro's name
-from `FOO` to `GTEST_FOO`. For example, with `-DGTEST_DONT_DEFINE_TEST=1`, you'll need to write
-``` cpp
-  GTEST_TEST(SomeTest, DoesThis) { ... }
-```
-instead of
-``` cpp
-  TEST(SomeTest, DoesThis) { ... }
-```
-in order to define a test.
-
-Currently, the following `TEST`, `FAIL`, `SUCCEED`, and the basic comparison assertion macros can have alternative names. You can see the full list of covered macros [here](http://www.google.com/codesearch?q=if+!GTEST_DONT_DEFINE_\w%2B+package:http://googletest\.googlecode\.com+file:/include/gtest/gtest.h). More information can be found in the "Avoiding Macro Name Clashes" section of the README file.
-
-
-## Is it OK if I have two separate `TEST(Foo, Bar)` test methods defined in different namespaces? ##
-
-Yes.
-
-The rule is **all test methods in the same test case must use the same fixture class**. This means that the following is **allowed** because both tests use the same fixture class (`::testing::Test`).
-
-``` cpp
-namespace foo {
-TEST(CoolTest, DoSomething) {
-  SUCCEED();
-}
-}  // namespace foo
-
-namespace bar {
-TEST(CoolTest, DoSomething) {
-  SUCCEED();
-}
-}  // namespace foo
-```
-
-However, the following code is **not allowed** and will produce a runtime error from Google Test because the test methods are using different test fixture classes with the same test case name.
-
-``` cpp
-namespace foo {
-class CoolTest : public ::testing::Test {};  // Fixture foo::CoolTest
-TEST_F(CoolTest, DoSomething) {
-  SUCCEED();
-}
-}  // namespace foo
-
-namespace bar {
-class CoolTest : public ::testing::Test {};  // Fixture: bar::CoolTest
-TEST_F(CoolTest, DoSomething) {
-  SUCCEED();
-}
-}  // namespace foo
-```
-
-## How do I build Google Testing Framework with Xcode 4? ##
-
-If you try to build Google Test's Xcode project with Xcode 4.0 or later, you may encounter an error message that looks like
-"Missing SDK in target gtest\_framework: /Developer/SDKs/MacOSX10.4u.sdk". That means that Xcode does not support the SDK the project is targeting. See the Xcode section in the [README](../README.md) file on how to resolve this.
-
-## My question is not covered in your FAQ! ##
-
-If you cannot find the answer to your question in this FAQ, there are
-some other resources you can use:
-
-  1. read other [wiki pages](../docs),
-  1. search the mailing list [archive](https://groups.google.com/forum/#!forum/googletestframework),
-  1. ask it on [googletestframework@googlegroups.com](mailto:googletestframework@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googletestframework) before you can post.).
-
-Please note that creating an issue in the
-[issue tracker](https://github.com/google/googletest/issues) is _not_
-a good way to get your answer, as it is monitored infrequently by a
-very small number of people.
-
-When asking a question, it's helpful to provide as much of the
-following information as possible (people cannot help you if there's
-not enough information in your question):
-
-  * the version (or the commit hash if you check out from Git directly) of Google Test you use (Google Test is under active development, so it's possible that your problem has been solved in a later version),
-  * your operating system,
-  * the name and version of your compiler,
-  * the complete command line flags you give to your compiler,
-  * the complete compiler error messages (if the question is about compilation),
-  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Primer.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Primer.md
deleted file mode 100644
index 474c1d2a..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Primer.md
+++ /dev/null
@@ -1,502 +0,0 @@
-
-
-# Introduction: Why Google C++ Testing Framework? #
-
-_Google C++ Testing Framework_ helps you write better C++ tests.
-
-No matter whether you work on Linux, Windows, or a Mac, if you write C++ code,
-Google Test can help you.
-
-So what makes a good test, and how does Google C++ Testing Framework fit in? We believe:
-  1. Tests should be _independent_ and _repeatable_. It's a pain to debug a test that succeeds or fails as a result of other tests.  Google C++ Testing Framework isolates the tests by running each of them on a different object. When a test fails, Google C++ Testing Framework allows you to run it in isolation for quick debugging.
-  1. Tests should be well _organized_ and reflect the structure of the tested code.  Google C++ Testing Framework groups related tests into test cases that can share data and subroutines. This common pattern is easy to recognize and makes tests easy to maintain. Such consistency is especially helpful when people switch projects and start to work on a new code base.
-  1. Tests should be _portable_ and _reusable_. The open-source community has a lot of code that is platform-neutral, its tests should also be platform-neutral.  Google C++ Testing Framework works on different OSes, with different compilers (gcc, MSVC, and others), with or without exceptions, so Google C++ Testing Framework tests can easily work with a variety of configurations.  (Note that the current release only contains build scripts for Linux - we are actively working on scripts for other platforms.)
-  1. When tests fail, they should provide as much _information_ about the problem as possible. Google C++ Testing Framework doesn't stop at the first test failure. Instead, it only stops the current test and continues with the next. You can also set up tests that report non-fatal failures after which the current test continues. Thus, you can detect and fix multiple bugs in a single run-edit-compile cycle.
-  1. The testing framework should liberate test writers from housekeeping chores and let them focus on the test _content_.  Google C++ Testing Framework automatically keeps track of all tests defined, and doesn't require the user to enumerate them in order to run them.
-  1. Tests should be _fast_. With Google C++ Testing Framework, you can reuse shared resources across tests and pay for the set-up/tear-down only once, without making tests depend on each other.
-
-Since Google C++ Testing Framework is based on the popular xUnit
-architecture, you'll feel right at home if you've used JUnit or PyUnit before.
-If not, it will take you about 10 minutes to learn the basics and get started.
-So let's go!
-
-_Note:_ We sometimes refer to Google C++ Testing Framework informally
-as _Google Test_.
-
-# Setting up a New Test Project #
-
-To write a test program using Google Test, you need to compile Google
-Test into a library and link your test with it.  We provide build
-files for some popular build systems: `msvc/` for Visual Studio,
-`xcode/` for Mac Xcode, `make/` for GNU make, `codegear/` for Borland
-C++ Builder, and the autotools script (deprecated) and
-`CMakeLists.txt` for CMake (recommended) in the Google Test root
-directory.  If your build system is not on this list, you can take a
-look at `make/Makefile` to learn how Google Test should be compiled
-(basically you want to compile `src/gtest-all.cc` with `GTEST_ROOT`
-and `GTEST_ROOT/include` in the header search path, where `GTEST_ROOT`
-is the Google Test root directory).
-
-Once you are able to compile the Google Test library, you should
-create a project or build target for your test program.  Make sure you
-have `GTEST_ROOT/include` in the header search path so that the
-compiler can find `"gtest/gtest.h"` when compiling your test.  Set up
-your test project to link with the Google Test library (for example,
-in Visual Studio, this is done by adding a dependency on
-`gtest.vcproj`).
-
-If you still have questions, take a look at how Google Test's own
-tests are built and use them as examples.
-
-# Basic Concepts #
-
-When using Google Test, you start by writing _assertions_, which are statements
-that check whether a condition is true. An assertion's result can be _success_,
-_nonfatal failure_, or _fatal failure_. If a fatal failure occurs, it aborts
-the current function; otherwise the program continues normally.
-
-_Tests_ use assertions to verify the tested code's behavior. If a test crashes
-or has a failed assertion, then it _fails_; otherwise it _succeeds_.
-
-A _test case_ contains one or many tests. You should group your tests into test
-cases that reflect the structure of the tested code. When multiple tests in a
-test case need to share common objects and subroutines, you can put them into a
-_test fixture_ class.
-
-A _test program_ can contain multiple test cases.
-
-We'll now explain how to write a test program, starting at the individual
-assertion level and building up to tests and test cases.
-
-# Assertions #
-
-Google Test assertions are macros that resemble function calls. You test a
-class or function by making assertions about its behavior. When an assertion
-fails, Google Test prints the assertion's source file and line number location,
-along with a failure message. You may also supply a custom failure message
-which will be appended to Google Test's message.
-
-The assertions come in pairs that test the same thing but have different
-effects on the current function. `ASSERT_*` versions generate fatal failures
-when they fail, and **abort the current function**. `EXPECT_*` versions generate
-nonfatal failures, which don't abort the current function. Usually `EXPECT_*`
-are preferred, as they allow more than one failures to be reported in a test.
-However, you should use `ASSERT_*` if it doesn't make sense to continue when
-the assertion in question fails.
-
-Since a failed `ASSERT_*` returns from the current function immediately,
-possibly skipping clean-up code that comes after it, it may cause a space leak.
-Depending on the nature of the leak, it may or may not be worth fixing - so
-keep this in mind if you get a heap checker error in addition to assertion
-errors.
-
-To provide a custom failure message, simply stream it into the macro using the
-`<<` operator, or a sequence of such operators. An example:
-```
-ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length";
-
-for (int i = 0; i < x.size(); ++i) {
-  EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i;
-}
-```
-
-Anything that can be streamed to an `ostream` can be streamed to an assertion
-macro--in particular, C strings and `string` objects. If a wide string
-(`wchar_t*`, `TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is
-streamed to an assertion, it will be translated to UTF-8 when printed.
-
-## Basic Assertions ##
-
-These assertions do basic true/false condition testing.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_TRUE(`_condition_`)`;  | `EXPECT_TRUE(`_condition_`)`;   | _condition_ is true |
-| `ASSERT_FALSE(`_condition_`)`; | `EXPECT_FALSE(`_condition_`)`;  | _condition_ is false |
-
-Remember, when they fail, `ASSERT_*` yields a fatal failure and
-returns from the current function, while `EXPECT_*` yields a nonfatal
-failure, allowing the function to continue running. In either case, an
-assertion failure means its containing test fails.
-
-_Availability_: Linux, Windows, Mac.
-
-## Binary Comparison ##
-
-This section describes assertions that compare two values.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-|`ASSERT_EQ(`_val1_`, `_val2_`);`|`EXPECT_EQ(`_val1_`, `_val2_`);`| _val1_ `==` _val2_ |
-|`ASSERT_NE(`_val1_`, `_val2_`);`|`EXPECT_NE(`_val1_`, `_val2_`);`| _val1_ `!=` _val2_ |
-|`ASSERT_LT(`_val1_`, `_val2_`);`|`EXPECT_LT(`_val1_`, `_val2_`);`| _val1_ `<` _val2_ |
-|`ASSERT_LE(`_val1_`, `_val2_`);`|`EXPECT_LE(`_val1_`, `_val2_`);`| _val1_ `<=` _val2_ |
-|`ASSERT_GT(`_val1_`, `_val2_`);`|`EXPECT_GT(`_val1_`, `_val2_`);`| _val1_ `>` _val2_ |
-|`ASSERT_GE(`_val1_`, `_val2_`);`|`EXPECT_GE(`_val1_`, `_val2_`);`| _val1_ `>=` _val2_ |
-
-In the event of a failure, Google Test prints both _val1_ and _val2_.
-
-Value arguments must be comparable by the assertion's comparison
-operator or you'll get a compiler error.  We used to require the
-arguments to support the `<<` operator for streaming to an `ostream`,
-but it's no longer necessary since v1.6.0 (if `<<` is supported, it
-will be called to print the arguments when the assertion fails;
-otherwise Google Test will attempt to print them in the best way it
-can. For more details and how to customize the printing of the
-arguments, see this Google Mock [recipe](../../googlemock/docs/CookBook.md#teaching-google-mock-how-to-print-your-values).).
-
-These assertions can work with a user-defined type, but only if you define the
-corresponding comparison operator (e.g. `==`, `<`, etc).  If the corresponding
-operator is defined, prefer using the `ASSERT_*()` macros because they will
-print out not only the result of the comparison, but the two operands as well.
-
-Arguments are always evaluated exactly once. Therefore, it's OK for the
-arguments to have side effects. However, as with any ordinary C/C++ function,
-the arguments' evaluation order is undefined (i.e. the compiler is free to
-choose any order) and your code should not depend on any particular argument
-evaluation order.
-
-`ASSERT_EQ()` does pointer equality on pointers. If used on two C strings, it
-tests if they are in the same memory location, not if they have the same value.
-Therefore, if you want to compare C strings (e.g. `const char*`) by value, use
-`ASSERT_STREQ()` , which will be described later on. In particular, to assert
-that a C string is `NULL`, use `ASSERT_STREQ(NULL, c_string)` . However, to
-compare two `string` objects, you should use `ASSERT_EQ`.
-
-Macros in this section work with both narrow and wide string objects (`string`
-and `wstring`).
-
-_Availability_: Linux, Windows, Mac.
-
-_Historical note_: Before February 2016 `*_EQ` had a convention of calling it as
-`ASSERT_EQ(expected, actual)`, so lots of existing code uses this order.
-Now `*_EQ` treats both parameters in the same way.
-
-## String Comparison ##
-
-The assertions in this group compare two **C strings**. If you want to compare
-two `string` objects, use `EXPECT_EQ`, `EXPECT_NE`, and etc instead.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_STREQ(`_str1_`, `_str2_`);`    | `EXPECT_STREQ(`_str1_`, `_str_2`);`     | the two C strings have the same content |
-| `ASSERT_STRNE(`_str1_`, `_str2_`);`    | `EXPECT_STRNE(`_str1_`, `_str2_`);`     | the two C strings have different content |
-| `ASSERT_STRCASEEQ(`_str1_`, `_str2_`);`| `EXPECT_STRCASEEQ(`_str1_`, `_str2_`);` | the two C strings have the same content, ignoring case |
-| `ASSERT_STRCASENE(`_str1_`, `_str2_`);`| `EXPECT_STRCASENE(`_str1_`, `_str2_`);` | the two C strings have different content, ignoring case |
-
-Note that "CASE" in an assertion name means that case is ignored.
-
-`*STREQ*` and `*STRNE*` also accept wide C strings (`wchar_t*`). If a
-comparison of two wide strings fails, their values will be printed as UTF-8
-narrow strings.
-
-A `NULL` pointer and an empty string are considered _different_.
-
-_Availability_: Linux, Windows, Mac.
-
-See also: For more string comparison tricks (substring, prefix, suffix, and
-regular expression matching, for example), see the [Advanced Google Test Guide](AdvancedGuide.md).
-
-# Simple Tests #
-
-To create a test:
-  1. Use the `TEST()` macro to define and name a test function, These are ordinary C++ functions that don't return a value.
-  1. In this function, along with any valid C++ statements you want to include, use the various Google Test assertions to check values.
-  1. The test's result is determined by the assertions; if any assertion in the test fails (either fatally or non-fatally), or if the test crashes, the entire test fails. Otherwise, it succeeds.
-
-```
-TEST(test_case_name, test_name) {
- ... test body ...
-}
-```
-
-
-`TEST()` arguments go from general to specific. The _first_ argument is the
-name of the test case, and the _second_ argument is the test's name within the
-test case. Both names must be valid C++ identifiers, and they should not contain underscore (`_`). A test's _full name_ consists of its containing test case and its
-individual name. Tests from different test cases can have the same individual
-name.
-
-For example, let's take a simple integer function:
-```
-int Factorial(int n); // Returns the factorial of n
-```
-
-A test case for this function might look like:
-```
-// Tests factorial of 0.
-TEST(FactorialTest, HandlesZeroInput) {
-  EXPECT_EQ(1, Factorial(0));
-}
-
-// Tests factorial of positive numbers.
-TEST(FactorialTest, HandlesPositiveInput) {
-  EXPECT_EQ(1, Factorial(1));
-  EXPECT_EQ(2, Factorial(2));
-  EXPECT_EQ(6, Factorial(3));
-  EXPECT_EQ(40320, Factorial(8));
-}
-```
-
-Google Test groups the test results by test cases, so logically-related tests
-should be in the same test case; in other words, the first argument to their
-`TEST()` should be the same. In the above example, we have two tests,
-`HandlesZeroInput` and `HandlesPositiveInput`, that belong to the same test
-case `FactorialTest`.
-
-_Availability_: Linux, Windows, Mac.
-
-# Test Fixtures: Using the Same Data Configuration for Multiple Tests #
-
-If you find yourself writing two or more tests that operate on similar data,
-you can use a _test fixture_. It allows you to reuse the same configuration of
-objects for several different tests.
-
-To create a fixture, just:
-  1. Derive a class from `::testing::Test` . Start its body with `protected:` or `public:` as we'll want to access fixture members from sub-classes.
-  1. Inside the class, declare any objects you plan to use.
-  1. If necessary, write a default constructor or `SetUp()` function to prepare the objects for each test. A common mistake is to spell `SetUp()` as `Setup()` with a small `u` - don't let that happen to you.
-  1. If necessary, write a destructor or `TearDown()` function to release any resources you allocated in `SetUp()` . To learn when you should use the constructor/destructor and when you should use `SetUp()/TearDown()`, read this [FAQ entry](FAQ.md#should-i-use-the-constructordestructor-of-the-test-fixture-or-the-set-uptear-down-function).
-  1. If needed, define subroutines for your tests to share.
-
-When using a fixture, use `TEST_F()` instead of `TEST()` as it allows you to
-access objects and subroutines in the test fixture:
-```
-TEST_F(test_case_name, test_name) {
- ... test body ...
-}
-```
-
-Like `TEST()`, the first argument is the test case name, but for `TEST_F()`
-this must be the name of the test fixture class. You've probably guessed: `_F`
-is for fixture.
-
-Unfortunately, the C++ macro system does not allow us to create a single macro
-that can handle both types of tests. Using the wrong macro causes a compiler
-error.
-
-Also, you must first define a test fixture class before using it in a
-`TEST_F()`, or you'll get the compiler error "`virtual outside class
-declaration`".
-
-For each test defined with `TEST_F()`, Google Test will:
-  1. Create a _fresh_ test fixture at runtime
-  1. Immediately initialize it via `SetUp()` ,
-  1. Run the test
-  1. Clean up by calling `TearDown()`
-  1. Delete the test fixture.  Note that different tests in the same test case have different test fixture objects, and Google Test always deletes a test fixture before it creates the next one. Google Test does not reuse the same test fixture for multiple tests. Any changes one test makes to the fixture do not affect other tests.
-
-As an example, let's write tests for a FIFO queue class named `Queue`, which
-has the following interface:
-```
-template <typename E> // E is the element type.
-class Queue {
- public:
-  Queue();
-  void Enqueue(const E& element);
-  E* Dequeue(); // Returns NULL if the queue is empty.
-  size_t size() const;
-  ...
-};
-```
-
-First, define a fixture class. By convention, you should give it the name
-`FooTest` where `Foo` is the class being tested.
-```
-class QueueTest : public ::testing::Test {
- protected:
-  virtual void SetUp() {
-    q1_.Enqueue(1);
-    q2_.Enqueue(2);
-    q2_.Enqueue(3);
-  }
-
-  // virtual void TearDown() {}
-
-  Queue<int> q0_;
-  Queue<int> q1_;
-  Queue<int> q2_;
-};
-```
-
-In this case, `TearDown()` is not needed since we don't have to clean up after
-each test, other than what's already done by the destructor.
-
-Now we'll write tests using `TEST_F()` and this fixture.
-```
-TEST_F(QueueTest, IsEmptyInitially) {
-  EXPECT_EQ(0, q0_.size());
-}
-
-TEST_F(QueueTest, DequeueWorks) {
-  int* n = q0_.Dequeue();
-  EXPECT_EQ(NULL, n);
-
-  n = q1_.Dequeue();
-  ASSERT_TRUE(n != NULL);
-  EXPECT_EQ(1, *n);
-  EXPECT_EQ(0, q1_.size());
-  delete n;
-
-  n = q2_.Dequeue();
-  ASSERT_TRUE(n != NULL);
-  EXPECT_EQ(2, *n);
-  EXPECT_EQ(1, q2_.size());
-  delete n;
-}
-```
-
-The above uses both `ASSERT_*` and `EXPECT_*` assertions. The rule of thumb is
-to use `EXPECT_*` when you want the test to continue to reveal more errors
-after the assertion failure, and use `ASSERT_*` when continuing after failure
-doesn't make sense. For example, the second assertion in the `Dequeue` test is
-`ASSERT_TRUE(n != NULL)`, as we need to dereference the pointer `n` later,
-which would lead to a segfault when `n` is `NULL`.
-
-When these tests run, the following happens:
-  1. Google Test constructs a `QueueTest` object (let's call it `t1` ).
-  1. `t1.SetUp()` initializes `t1` .
-  1. The first test ( `IsEmptyInitially` ) runs on `t1` .
-  1. `t1.TearDown()` cleans up after the test finishes.
-  1. `t1` is destructed.
-  1. The above steps are repeated on another `QueueTest` object, this time running the `DequeueWorks` test.
-
-_Availability_: Linux, Windows, Mac.
-
-_Note_: Google Test automatically saves all _Google Test_ flags when a test
-object is constructed, and restores them when it is destructed.
-
-# Invoking the Tests #
-
-`TEST()` and `TEST_F()` implicitly register their tests with Google Test. So, unlike with many other C++ testing frameworks, you don't have to re-list all your defined tests in order to run them.
-
-After defining your tests, you can run them with `RUN_ALL_TESTS()` , which returns `0` if all the tests are successful, or `1` otherwise. Note that `RUN_ALL_TESTS()` runs _all tests_ in your link unit -- they can be from different test cases, or even different source files.
-
-When invoked, the `RUN_ALL_TESTS()` macro:
-  1. Saves the state of all  Google Test flags.
-  1. Creates a test fixture object for the first test.
-  1. Initializes it via `SetUp()`.
-  1. Runs the test on the fixture object.
-  1. Cleans up the fixture via `TearDown()`.
-  1. Deletes the fixture.
-  1. Restores the state of all Google Test flags.
-  1. Repeats the above steps for the next test, until all tests have run.
-
-In addition, if the text fixture's constructor generates a fatal failure in
-step 2, there is no point for step 3 - 5 and they are thus skipped. Similarly,
-if step 3 generates a fatal failure, step 4 will be skipped.
-
-_Important_: You must not ignore the return value of `RUN_ALL_TESTS()`, or `gcc`
-will give you a compiler error. The rationale for this design is that the
-automated testing service determines whether a test has passed based on its
-exit code, not on its stdout/stderr output; thus your `main()` function must
-return the value of `RUN_ALL_TESTS()`.
-
-Also, you should call `RUN_ALL_TESTS()` only **once**. Calling it more than once
-conflicts with some advanced Google Test features (e.g. thread-safe death
-tests) and thus is not supported.
-
-_Availability_: Linux, Windows, Mac.
-
-# Writing the main() Function #
-
-You can start from this boilerplate:
-```
-#include "this/package/foo.h"
-#include "gtest/gtest.h"
-
-namespace {
-
-// The fixture for testing class Foo.
-class FooTest : public ::testing::Test {
- protected:
-  // You can remove any or all of the following functions if its body
-  // is empty.
-
-  FooTest() {
-    // You can do set-up work for each test here.
-  }
-
-  virtual ~FooTest() {
-    // You can do clean-up work that doesn't throw exceptions here.
-  }
-
-  // If the constructor and destructor are not enough for setting up
-  // and cleaning up each test, you can define the following methods:
-
-  virtual void SetUp() {
-    // Code here will be called immediately after the constructor (right
-    // before each test).
-  }
-
-  virtual void TearDown() {
-    // Code here will be called immediately after each test (right
-    // before the destructor).
-  }
-
-  // Objects declared here can be used by all tests in the test case for Foo.
-};
-
-// Tests that the Foo::Bar() method does Abc.
-TEST_F(FooTest, MethodBarDoesAbc) {
-  const string input_filepath = "this/package/testdata/myinputfile.dat";
-  const string output_filepath = "this/package/testdata/myoutputfile.dat";
-  Foo f;
-  EXPECT_EQ(0, f.Bar(input_filepath, output_filepath));
-}
-
-// Tests that Foo does Xyz.
-TEST_F(FooTest, DoesXyz) {
-  // Exercises the Xyz feature of Foo.
-}
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
-```
-
-The `::testing::InitGoogleTest()` function parses the command line for Google
-Test flags, and removes all recognized flags. This allows the user to control a
-test program's behavior via various flags, which we'll cover in [AdvancedGuide](AdvancedGuide.md).
-You must call this function before calling `RUN_ALL_TESTS()`, or the flags
-won't be properly initialized.
-
-On Windows, `InitGoogleTest()` also works with wide strings, so it can be used
-in programs compiled in `UNICODE` mode as well.
-
-But maybe you think that writing all those main() functions is too much work? We agree with you completely and that's why Google Test provides a basic implementation of main(). If it fits your needs, then just link your test with gtest\_main library and you are good to go.
-
-## Important note for Visual C++ users ##
-If you put your tests into a library and your `main()` function is in a different library or in your .exe file, those tests will not run. The reason is a [bug](https://connect.microsoft.com/feedback/viewfeedback.aspx?FeedbackID=244410&siteid=210) in Visual C++. When you define your tests, Google Test creates certain static objects to register them. These objects are not referenced from elsewhere but their constructors are still supposed to run. When Visual C++ linker sees that nothing in the library is referenced from other places it throws the library out. You have to reference your library with tests from your main program to keep the linker from discarding it. Here is how to do it. Somewhere in your library code declare a function:
-```
-__declspec(dllexport) int PullInMyLibrary() { return 0; }
-```
-If you put your tests in a static library (not DLL) then `__declspec(dllexport)` is not required. Now, in your main program, write a code that invokes that function:
-```
-int PullInMyLibrary();
-static int dummy = PullInMyLibrary();
-```
-This will keep your tests referenced and will make them register themselves at startup.
-
-In addition, if you define your tests in a static library, add `/OPT:NOREF` to your main program linker options. If you use MSVC++ IDE, go to your .exe project properties/Configuration Properties/Linker/Optimization and set References setting to `Keep Unreferenced Data (/OPT:NOREF)`. This will keep Visual C++ linker from discarding individual symbols generated by your tests from the final executable.
-
-There is one more pitfall, though. If you use Google Test as a static library (that's how it is defined in gtest.vcproj) your tests must also reside in a static library. If you have to have them in a DLL, you _must_ change Google Test to build into a DLL as well. Otherwise your tests will not run correctly or will not run at all. The general conclusion here is: make your life easier - do not write your tests in libraries!
-
-# Where to Go from Here #
-
-Congratulations! You've learned the Google Test basics. You can start writing
-and running Google Test tests, read some [samples](Samples.md), or continue with
-[AdvancedGuide](AdvancedGuide.md), which describes many more useful Google Test features.
-
-# Known Limitations #
-
-Google Test is designed to be thread-safe.  The implementation is
-thread-safe on systems where the `pthreads` library is available.  It
-is currently _unsafe_ to use Google Test assertions from two threads
-concurrently on other systems (e.g. Windows).  In most tests this is
-not an issue as usually the assertions are done in the main thread. If
-you want to help, you can volunteer to implement the necessary
-synchronization primitives in `gtest-port.h` for your platform.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/PumpManual.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/PumpManual.md
deleted file mode 100644
index 8184f153..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/PumpManual.md
+++ /dev/null
@@ -1,177 +0,0 @@
-
-
-<b>P</b>ump is <b>U</b>seful for <b>M</b>eta <b>P</b>rogramming.
-
-# The Problem #
-
-Template and macro libraries often need to define many classes,
-functions, or macros that vary only (or almost only) in the number of
-arguments they take. It's a lot of repetitive, mechanical, and
-error-prone work.
-
-Variadic templates and variadic macros can alleviate the problem.
-However, while both are being considered by the C++ committee, neither
-is in the standard yet or widely supported by compilers.  Thus they
-are often not a good choice, especially when your code needs to be
-portable. And their capabilities are still limited.
-
-As a result, authors of such libraries often have to write scripts to
-generate their implementation. However, our experience is that it's
-tedious to write such scripts, which tend to reflect the structure of
-the generated code poorly and are often hard to read and edit. For
-example, a small change needed in the generated code may require some
-non-intuitive, non-trivial changes in the script. This is especially
-painful when experimenting with the code.
-
-# Our Solution #
-
-Pump (for Pump is Useful for Meta Programming, Pretty Useful for Meta
-Programming, or Practical Utility for Meta Programming, whichever you
-prefer) is a simple meta-programming tool for C++. The idea is that a
-programmer writes a `foo.pump` file which contains C++ code plus meta
-code that manipulates the C++ code. The meta code can handle
-iterations over a range, nested iterations, local meta variable
-definitions, simple arithmetic, and conditional expressions. You can
-view it as a small Domain-Specific Language. The meta language is
-designed to be non-intrusive (s.t. it won't confuse Emacs' C++ mode,
-for example) and concise, making Pump code intuitive and easy to
-maintain.
-
-## Highlights ##
-
-  * The implementation is in a single Python script and thus ultra portable: no build or installation is needed and it works cross platforms.
-  * Pump tries to be smart with respect to [Google's style guide](http://code.google.com/p/google-styleguide/): it breaks long lines (easy to have when they are generated) at acceptable places to fit within 80 columns and indent the continuation lines correctly.
-  * The format is human-readable and more concise than XML.
-  * The format works relatively well with Emacs' C++ mode.
-
-## Examples ##
-
-The following Pump code (where meta keywords start with `$`, `[[` and `]]` are meta brackets, and `$$` starts a meta comment that ends with the line):
-
-```
-$var n = 3     $$ Defines a meta variable n.
-$range i 0..n  $$ Declares the range of meta iterator i (inclusive).
-$for i [[
-               $$ Meta loop.
-// Foo$i does blah for $i-ary predicates.
-$range j 1..i
-template <size_t N $for j [[, typename A$j]]>
-class Foo$i {
-$if i == 0 [[
-  blah a;
-]] $elif i <= 2 [[
-  blah b;
-]] $else [[
-  blah c;
-]]
-};
-
-]]
-```
-
-will be translated by the Pump compiler to:
-
-```
-// Foo0 does blah for 0-ary predicates.
-template <size_t N>
-class Foo0 {
-  blah a;
-};
-
-// Foo1 does blah for 1-ary predicates.
-template <size_t N, typename A1>
-class Foo1 {
-  blah b;
-};
-
-// Foo2 does blah for 2-ary predicates.
-template <size_t N, typename A1, typename A2>
-class Foo2 {
-  blah b;
-};
-
-// Foo3 does blah for 3-ary predicates.
-template <size_t N, typename A1, typename A2, typename A3>
-class Foo3 {
-  blah c;
-};
-```
-
-In another example,
-
-```
-$range i 1..n
-Func($for i + [[a$i]]);
-$$ The text between i and [[ is the separator between iterations.
-```
-
-will generate one of the following lines (without the comments), depending on the value of `n`:
-
-```
-Func();              // If n is 0.
-Func(a1);            // If n is 1.
-Func(a1 + a2);       // If n is 2.
-Func(a1 + a2 + a3);  // If n is 3.
-// And so on...
-```
-
-## Constructs ##
-
-We support the following meta programming constructs:
-
-| `$var id = exp` | Defines a named constant value. `$id` is valid util the end of the current meta lexical block. |
-|:----------------|:-----------------------------------------------------------------------------------------------|
-| `$range id exp..exp` | Sets the range of an iteration variable, which can be reused in multiple loops later.          |
-| `$for id sep [[ code ]]` | Iteration. The range of `id` must have been defined earlier. `$id` is valid in `code`.         |
-| `$($)`          | Generates a single `$` character.                                                              |
-| `$id`           | Value of the named constant or iteration variable.                                             |
-| `$(exp)`        | Value of the expression.                                                                       |
-| `$if exp [[ code ]] else_branch` | Conditional.                                                                                   |
-| `[[ code ]]`    | Meta lexical block.                                                                            |
-| `cpp_code`      | Raw C++ code.                                                                                  |
-| `$$ comment`    | Meta comment.                                                                                  |
-
-**Note:** To give the user some freedom in formatting the Pump source
-code, Pump ignores a new-line character if it's right after `$for foo`
-or next to `[[` or `]]`. Without this rule you'll often be forced to write
-very long lines to get the desired output. Therefore sometimes you may
-need to insert an extra new-line in such places for a new-line to show
-up in your output.
-
-## Grammar ##
-
-```
-code ::= atomic_code*
-atomic_code ::= $var id = exp
-    | $var id = [[ code ]]
-    | $range id exp..exp
-    | $for id sep [[ code ]]
-    | $($)
-    | $id
-    | $(exp)
-    | $if exp [[ code ]] else_branch
-    | [[ code ]]
-    | cpp_code
-sep ::= cpp_code | empty_string
-else_branch ::= $else [[ code ]]
-    | $elif exp [[ code ]] else_branch
-    | empty_string
-exp ::= simple_expression_in_Python_syntax
-```
-
-## Code ##
-
-You can find the source code of Pump in [scripts/pump.py](../scripts/pump.py). It is still
-very unpolished and lacks automated tests, although it has been
-successfully used many times. If you find a chance to use it in your
-project, please let us know what you think!  We also welcome help on
-improving Pump.
-
-## Real Examples ##
-
-You can find real-world applications of Pump in [Google Test](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgoogletest\.googlecode\.com) and [Google Mock](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgooglemock\.googlecode\.com).  The source file `foo.h.pump` generates `foo.h`.
-
-## Tips ##
-
-  * If a meta variable is followed by a letter or digit, you can separate them using `[[]]`, which inserts an empty string. For example `Foo$j[[]]Helper` generate `Foo1Helper` when `j` is 1.
-  * To avoid extra-long Pump source lines, you can break a line anywhere you want by inserting `[[]]` followed by a new line. Since any new-line character next to `[[` or `]]` is ignored, the generated code won't contain this new line.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Samples.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Samples.md
deleted file mode 100644
index f21d2005..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/Samples.md
+++ /dev/null
@@ -1,14 +0,0 @@
-If you're like us, you'd like to look at some Google Test sample code.  The
-[samples folder](../samples) has a number of well-commented samples showing how to use a
-variety of Google Test features.
-
-  * [Sample #1](../samples/sample1_unittest.cc) shows the basic steps of using Google Test to test C++ functions.
-  * [Sample #2](../samples/sample2_unittest.cc) shows a more complex unit test for a class with multiple member functions.
-  * [Sample #3](../samples/sample3_unittest.cc) uses a test fixture.
-  * [Sample #4](../samples/sample4_unittest.cc) is another basic example of using Google Test.
-  * [Sample #5](../samples/sample5_unittest.cc) teaches how to reuse a test fixture in multiple test cases by deriving sub-fixtures from it.
-  * [Sample #6](../samples/sample6_unittest.cc) demonstrates type-parameterized tests.
-  * [Sample #7](../samples/sample7_unittest.cc) teaches the basics of value-parameterized tests.
-  * [Sample #8](../samples/sample8_unittest.cc) shows using `Combine()` in value-parameterized tests.
-  * [Sample #9](../samples/sample9_unittest.cc) shows use of the listener API to modify Google Test's console output and the use of its reflection API to inspect test results.
-  * [Sample #10](../samples/sample10_unittest.cc) shows use of the listener API to implement a primitive memory leak checker.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_AdvancedGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_AdvancedGuide.md
deleted file mode 100644
index 34e19c26..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_AdvancedGuide.md
+++ /dev/null
@@ -1,2096 +0,0 @@
-
-
-Now that you have read [Primer](V1_5_Primer.md) and learned how to write tests
-using Google Test, it's time to learn some new tricks. This document
-will show you more assertions as well as how to construct complex
-failure messages, propagate fatal failures, reuse and speed up your
-test fixtures, and use various flags with your tests.
-
-# More Assertions #
-
-This section covers some less frequently used, but still significant,
-assertions.
-
-## Explicit Success and Failure ##
-
-These three assertions do not actually test a value or expression. Instead,
-they generate a success or failure directly. Like the macros that actually
-perform a test, you may stream a custom failure message into the them.
-
-| `SUCCEED();` |
-|:-------------|
-
-Generates a success. This does NOT make the overall test succeed. A test is
-considered successful only if none of its assertions fail during its execution.
-
-Note: `SUCCEED()` is purely documentary and currently doesn't generate any
-user-visible output. However, we may add `SUCCEED()` messages to Google Test's
-output in the future.
-
-| `FAIL();`  | `ADD_FAILURE();` |
-|:-----------|:-----------------|
-
-`FAIL*` generates a fatal failure while `ADD_FAILURE*` generates a nonfatal
-failure. These are useful when control flow, rather than a Boolean expression,
-deteremines the test's success or failure. For example, you might want to write
-something like:
-
-```
-switch(expression) {
-  case 1: ... some checks ...
-  case 2: ... some other checks
-  ...
-  default: FAIL() << "We shouldn't get here.";
-}
-```
-
-_Availability_: Linux, Windows, Mac.
-
-## Exception Assertions ##
-
-These are for verifying that a piece of code throws (or does not
-throw) an exception of the given type:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_THROW(`_statement_, _exception\_type_`);`  | `EXPECT_THROW(`_statement_, _exception\_type_`);`  | _statement_ throws an exception of the given type  |
-| `ASSERT_ANY_THROW(`_statement_`);`                | `EXPECT_ANY_THROW(`_statement_`);`                | _statement_ throws an exception of any type        |
-| `ASSERT_NO_THROW(`_statement_`);`                 | `EXPECT_NO_THROW(`_statement_`);`                 | _statement_ doesn't throw any exception            |
-
-Examples:
-
-```
-ASSERT_THROW(Foo(5), bar_exception);
-
-EXPECT_NO_THROW({
-  int n = 5;
-  Bar(&n);
-});
-```
-
-_Availability_: Linux, Windows, Mac; since version 1.1.0.
-
-## Predicate Assertions for Better Error Messages ##
-
-Even though Google Test has a rich set of assertions, they can never be
-complete, as it's impossible (nor a good idea) to anticipate all the scenarios
-a user might run into. Therefore, sometimes a user has to use `EXPECT_TRUE()`
-to check a complex expression, for lack of a better macro. This has the problem
-of not showing you the values of the parts of the expression, making it hard to
-understand what went wrong. As a workaround, some users choose to construct the
-failure message by themselves, streaming it into `EXPECT_TRUE()`. However, this
-is awkward especially when the expression has side-effects or is expensive to
-evaluate.
-
-Google Test gives you three different options to solve this problem:
-
-### Using an Existing Boolean Function ###
-
-If you already have a function or a functor that returns `bool` (or a type
-that can be implicitly converted to `bool`), you can use it in a _predicate
-assertion_ to get the function arguments printed for free:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_PRED1(`_pred1, val1_`);`       | `EXPECT_PRED1(`_pred1, val1_`);` | _pred1(val1)_ returns true |
-| `ASSERT_PRED2(`_pred2, val1, val2_`);` | `EXPECT_PRED2(`_pred2, val1, val2_`);` |  _pred2(val1, val2)_ returns true |
-|  ...                | ...                    | ...          |
-
-In the above, _predn_ is an _n_-ary predicate function or functor, where
-_val1_, _val2_, ..., and _valn_ are its arguments. The assertion succeeds
-if the predicate returns `true` when applied to the given arguments, and fails
-otherwise. When the assertion fails, it prints the value of each argument. In
-either case, the arguments are evaluated exactly once.
-
-Here's an example. Given
-
-```
-// Returns true iff m and n have no common divisors except 1.
-bool MutuallyPrime(int m, int n) { ... }
-const int a = 3;
-const int b = 4;
-const int c = 10;
-```
-
-the assertion `EXPECT_PRED2(MutuallyPrime, a, b);` will succeed, while the
-assertion `EXPECT_PRED2(MutuallyPrime, b, c);` will fail with the message
-
-<pre>
-!MutuallyPrime(b, c) is false, where<br>
-b is 4<br>
-c is 10<br>
-</pre>
-
-**Notes:**
-
-  1. If you see a compiler error "no matching function to call" when using `ASSERT_PRED*` or `EXPECT_PRED*`, please see [this](V1_5_FAQ.md#the-compiler-complains-about-undefined-references-to-some-static-const-member-variables-but-i-did-define-them-in-the-class-body-whats-wrong) for how to resolve it.
-  1. Currently we only provide predicate assertions of arity <= 5. If you need a higher-arity assertion, let us know.
-
-_Availability_: Linux, Windows, Mac
-
-### Using a Function That Returns an AssertionResult ###
-
-While `EXPECT_PRED*()` and friends are handy for a quick job, the
-syntax is not satisfactory: you have to use different macros for
-different arities, and it feels more like Lisp than C++.  The
-`::testing::AssertionResult` class solves this problem.
-
-An `AssertionResult` object represents the result of an assertion
-(whether it's a success or a failure, and an associated message).  You
-can create an `AssertionResult` using one of these factory
-functions:
-
-```
-namespace testing {
-
-// Returns an AssertionResult object to indicate that an assertion has
-// succeeded.
-AssertionResult AssertionSuccess();
-
-// Returns an AssertionResult object to indicate that an assertion has
-// failed.
-AssertionResult AssertionFailure();
-
-}
-```
-
-You can then use the `<<` operator to stream messages to the
-`AssertionResult` object.
-
-To provide more readable messages in Boolean assertions
-(e.g. `EXPECT_TRUE()`), write a predicate function that returns
-`AssertionResult` instead of `bool`. For example, if you define
-`IsEven()` as:
-
-```
-::testing::AssertionResult IsEven(int n) {
-  if ((n % 2) == 0)
-    return ::testing::AssertionSuccess();
-  else
-    return ::testing::AssertionFailure() << n << " is odd";
-}
-```
-
-instead of:
-
-```
-bool IsEven(int n) {
-  return (n % 2) == 0;
-}
-```
-
-the failed assertion `EXPECT_TRUE(IsEven(Fib(4)))` will print:
-
-<pre>
-Value of: !IsEven(Fib(4))<br>
-Actual: false (*3 is odd*)<br>
-Expected: true<br>
-</pre>
-
-instead of a more opaque
-
-<pre>
-Value of: !IsEven(Fib(4))<br>
-Actual: false<br>
-Expected: true<br>
-</pre>
-
-If you want informative messages in `EXPECT_FALSE` and `ASSERT_FALSE`
-as well, and are fine with making the predicate slower in the success
-case, you can supply a success message:
-
-```
-::testing::AssertionResult IsEven(int n) {
-  if ((n % 2) == 0)
-    return ::testing::AssertionSuccess() << n << " is even";
-  else
-    return ::testing::AssertionFailure() << n << " is odd";
-}
-```
-
-Then the statement `EXPECT_FALSE(IsEven(Fib(6)))` will print
-
-<pre>
-Value of: !IsEven(Fib(6))<br>
-Actual: true (8 is even)<br>
-Expected: false<br>
-</pre>
-
-_Availability_: Linux, Windows, Mac; since version 1.4.1.
-
-### Using a Predicate-Formatter ###
-
-If you find the default message generated by `(ASSERT|EXPECT)_PRED*` and
-`(ASSERT|EXPECT)_(TRUE|FALSE)` unsatisfactory, or some arguments to your
-predicate do not support streaming to `ostream`, you can instead use the
-following _predicate-formatter assertions_ to _fully_ customize how the
-message is formatted:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_PRED_FORMAT1(`_pred\_format1, val1_`);`        | `EXPECT_PRED_FORMAT1(`_pred\_format1, val1_`); | _pred\_format1(val1)_ is successful |
-| `ASSERT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | `EXPECT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | _pred\_format2(val1, val2)_ is successful |
-| `...`               | `...`                  | `...`        |
-
-The difference between this and the previous two groups of macros is that instead of
-a predicate, `(ASSERT|EXPECT)_PRED_FORMAT*` take a _predicate-formatter_
-(_pred\_formatn_), which is a function or functor with the signature:
-
-`::testing::AssertionResult PredicateFormattern(const char* `_expr1_`, const char* `_expr2_`, ... const char* `_exprn_`, T1 `_val1_`, T2 `_val2_`, ... Tn `_valn_`);`
-
-where _val1_, _val2_, ..., and _valn_ are the values of the predicate
-arguments, and _expr1_, _expr2_, ..., and _exprn_ are the corresponding
-expressions as they appear in the source code. The types `T1`, `T2`, ..., and
-`Tn` can be either value types or reference types. For example, if an
-argument has type `Foo`, you can declare it as either `Foo` or `const Foo&`,
-whichever is appropriate.
-
-A predicate-formatter returns a `::testing::AssertionResult` object to indicate
-whether the assertion has succeeded or not. The only way to create such an
-object is to call one of these factory functions:
-
-As an example, let's improve the failure message in the previous example, which uses `EXPECT_PRED2()`:
-
-```
-// Returns the smallest prime common divisor of m and n,
-// or 1 when m and n are mutually prime.
-int SmallestPrimeCommonDivisor(int m, int n) { ... }
-
-// A predicate-formatter for asserting that two integers are mutually prime.
-::testing::AssertionResult AssertMutuallyPrime(const char* m_expr,
-                                               const char* n_expr,
-                                               int m,
-                                               int n) {
-  if (MutuallyPrime(m, n))
-    return ::testing::AssertionSuccess();
-
-  return ::testing::AssertionFailure()
-      << m_expr << " and " << n_expr << " (" << m << " and " << n
-      << ") are not mutually prime, " << "as they have a common divisor "
-      << SmallestPrimeCommonDivisor(m, n);
-}
-```
-
-With this predicate-formatter, we can use
-
-```
-EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c);
-```
-
-to generate the message
-
-<pre>
-b and c (4 and 10) are not mutually prime, as they have a common divisor 2.<br>
-</pre>
-
-As you may have realized, many of the assertions we introduced earlier are
-special cases of `(EXPECT|ASSERT)_PRED_FORMAT*`. In fact, most of them are
-indeed defined using `(EXPECT|ASSERT)_PRED_FORMAT*`.
-
-_Availability_: Linux, Windows, Mac.
-
-
-## Floating-Point Comparison ##
-
-Comparing floating-point numbers is tricky. Due to round-off errors, it is
-very unlikely that two floating-points will match exactly. Therefore,
-`ASSERT_EQ` 's naive comparison usually doesn't work. And since floating-points
-can have a wide value range, no single fixed error bound works. It's better to
-compare by a fixed relative error bound, except for values close to 0 due to
-the loss of precision there.
-
-In general, for floating-point comparison to make sense, the user needs to
-carefully choose the error bound. If they don't want or care to, comparing in
-terms of Units in the Last Place (ULPs) is a good default, and Google Test
-provides assertions to do this. Full details about ULPs are quite long; if you
-want to learn more, see
-[this article on float comparison](http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm).
-
-### Floating-Point Macros ###
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_FLOAT_EQ(`_expected, actual_`);`  | `EXPECT_FLOAT_EQ(`_expected, actual_`);` | the two `float` values are almost equal |
-| `ASSERT_DOUBLE_EQ(`_expected, actual_`);` | `EXPECT_DOUBLE_EQ(`_expected, actual_`);` | the two `double` values are almost equal |
-
-By "almost equal", we mean the two values are within 4 ULP's from each
-other.
-
-The following assertions allow you to choose the acceptable error bound:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_NEAR(`_val1, val2, abs\_error_`);` | `EXPECT_NEAR`_(val1, val2, abs\_error_`);` | the difference between _val1_ and _val2_ doesn't exceed the given absolute error |
-
-_Availability_: Linux, Windows, Mac.
-
-### Floating-Point Predicate-Format Functions ###
-
-Some floating-point operations are useful, but not that often used. In order
-to avoid an explosion of new macros, we provide them as predicate-format
-functions that can be used in predicate assertion macros (e.g.
-`EXPECT_PRED_FORMAT2`, etc).
-
-```
-EXPECT_PRED_FORMAT2(::testing::FloatLE, val1, val2);
-EXPECT_PRED_FORMAT2(::testing::DoubleLE, val1, val2);
-```
-
-Verifies that _val1_ is less than, or almost equal to, _val2_. You can
-replace `EXPECT_PRED_FORMAT2` in the above table with `ASSERT_PRED_FORMAT2`.
-
-_Availability_: Linux, Windows, Mac.
-
-## Windows HRESULT assertions ##
-
-These assertions test for `HRESULT` success or failure.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_HRESULT_SUCCEEDED(`_expression_`);` | `EXPECT_HRESULT_SUCCEEDED(`_expression_`);` | _expression_ is a success `HRESULT` |
-| `ASSERT_HRESULT_FAILED(`_expression_`);`    | `EXPECT_HRESULT_FAILED(`_expression_`);`    | _expression_ is a failure `HRESULT` |
-
-The generated output contains the human-readable error message
-associated with the `HRESULT` code returned by _expression_.
-
-You might use them like this:
-
-```
-CComPtr shell;
-ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application"));
-CComVariant empty;
-ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty));
-```
-
-_Availability_: Windows.
-
-## Type Assertions ##
-
-You can call the function
-```
-::testing::StaticAssertTypeEq<T1, T2>();
-```
-to assert that types `T1` and `T2` are the same.  The function does
-nothing if the assertion is satisfied.  If the types are different,
-the function call will fail to compile, and the compiler error message
-will likely (depending on the compiler) show you the actual values of
-`T1` and `T2`.  This is mainly useful inside template code.
-
-_Caveat:_ When used inside a member function of a class template or a
-function template, `StaticAssertTypeEq<T1, T2>()` is effective _only if_
-the function is instantiated.  For example, given:
-```
-template <typename T> class Foo {
- public:
-  void Bar() { ::testing::StaticAssertTypeEq<int, T>(); }
-};
-```
-the code:
-```
-void Test1() { Foo<bool> foo; }
-```
-will _not_ generate a compiler error, as `Foo<bool>::Bar()` is never
-actually instantiated.  Instead, you need:
-```
-void Test2() { Foo<bool> foo; foo.Bar(); }
-```
-to cause a compiler error.
-
-_Availability:_ Linux, Windows, Mac; since version 1.3.0.
-
-## Assertion Placement ##
-
-You can use assertions in any C++ function. In particular, it doesn't
-have to be a method of the test fixture class. The one constraint is
-that assertions that generate a fatal failure (`FAIL*` and `ASSERT_*`)
-can only be used in void-returning functions. This is a consequence of
-Google Test not using exceptions. By placing it in a non-void function
-you'll get a confusing compile error like
-`"error: void value not ignored as it ought to be"`.
-
-If you need to use assertions in a function that returns non-void, one option
-is to make the function return the value in an out parameter instead. For
-example, you can rewrite `T2 Foo(T1 x)` to `void Foo(T1 x, T2* result)`. You
-need to make sure that `*result` contains some sensible value even when the
-function returns prematurely. As the function now returns `void`, you can use
-any assertion inside of it.
-
-If changing the function's type is not an option, you should just use
-assertions that generate non-fatal failures, such as `ADD_FAILURE*` and
-`EXPECT_*`.
-
-_Note_: Constructors and destructors are not considered void-returning
-functions, according to the C++ language specification, and so you may not use
-fatal assertions in them. You'll get a compilation error if you try. A simple
-workaround is to transfer the entire body of the constructor or destructor to a
-private void-returning method. However, you should be aware that a fatal
-assertion failure in a constructor does not terminate the current test, as your
-intuition might suggest; it merely returns from the constructor early, possibly
-leaving your object in a partially-constructed state. Likewise, a fatal
-assertion failure in a destructor may leave your object in a
-partially-destructed state. Use assertions carefully in these situations!
-
-# Death Tests #
-
-In many applications, there are assertions that can cause application failure
-if a condition is not met. These sanity checks, which ensure that the program
-is in a known good state, are there to fail at the earliest possible time after
-some program state is corrupted. If the assertion checks the wrong condition,
-then the program may proceed in an erroneous state, which could lead to memory
-corruption, security holes, or worse. Hence it is vitally important to test
-that such assertion statements work as expected.
-
-Since these precondition checks cause the processes to die, we call such tests
-_death tests_. More generally, any test that checks that a program terminates
-in an expected fashion is also a death test.
-
-If you want to test `EXPECT_*()/ASSERT_*()` failures in your test code, see [Catching Failures](#catching-failures).
-
-## How to Write a Death Test ##
-
-Google Test has the following macros to support death tests:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_DEATH(`_statement, regex_`); | `EXPECT_DEATH(`_statement, regex_`); | _statement_ crashes with the given error |
-| `ASSERT_DEATH_IF_SUPPORTED(`_statement, regex_`); | `EXPECT_DEATH_IF_SUPPORTED(`_statement, regex_`); | if death tests are supported, verifies that _statement_ crashes with the given error; otherwise verifies nothing |
-| `ASSERT_EXIT(`_statement, predicate, regex_`); | `EXPECT_EXIT(`_statement, predicate, regex_`); |_statement_ exits with the given error and its exit code matches _predicate_ |
-
-where _statement_ is a statement that is expected to cause the process to
-die, _predicate_ is a function or function object that evaluates an integer
-exit status, and _regex_ is a regular expression that the stderr output of
-_statement_ is expected to match. Note that _statement_ can be _any valid
-statement_ (including _compound statement_) and doesn't have to be an
-expression.
-
-As usual, the `ASSERT` variants abort the current test function, while the
-`EXPECT` variants do not.
-
-**Note:** We use the word "crash" here to mean that the process
-terminates with a _non-zero_ exit status code.  There are two
-possibilities: either the process has called `exit()` or `_exit()`
-with a non-zero value, or it may be killed by a signal.
-
-This means that if _statement_ terminates the process with a 0 exit
-code, it is _not_ considered a crash by `EXPECT_DEATH`.  Use
-`EXPECT_EXIT` instead if this is the case, or if you want to restrict
-the exit code more precisely.
-
-A predicate here must accept an `int` and return a `bool`. The death test
-succeeds only if the predicate returns `true`. Google Test defines a few
-predicates that handle the most common cases:
-
-```
-::testing::ExitedWithCode(exit_code)
-```
-
-This expression is `true` if the program exited normally with the given exit
-code.
-
-```
-::testing::KilledBySignal(signal_number)  // Not available on Windows.
-```
-
-This expression is `true` if the program was killed by the given signal.
-
-The `*_DEATH` macros are convenient wrappers for `*_EXIT` that use a predicate
-that verifies the process' exit code is non-zero.
-
-Note that a death test only cares about three things:
-
-  1. does _statement_ abort or exit the process?
-  1. (in the case of `ASSERT_EXIT` and `EXPECT_EXIT`) does the exit status satisfy _predicate_?  Or (in the case of `ASSERT_DEATH` and `EXPECT_DEATH`) is the exit status non-zero?  And
-  1. does the stderr output match _regex_?
-
-In particular, if _statement_ generates an `ASSERT_*` or `EXPECT_*` failure, it will **not** cause the death test to fail, as Google Test assertions don't abort the process.
-
-To write a death test, simply use one of the above macros inside your test
-function. For example,
-
-```
-TEST(My*DeathTest*, Foo) {
-  // This death test uses a compound statement.
-  ASSERT_DEATH({ int n = 5; Foo(&n); }, "Error on line .* of Foo()");
-}
-TEST(MyDeathTest, NormalExit) {
-  EXPECT_EXIT(NormalExit(), ::testing::ExitedWithCode(0), "Success");
-}
-TEST(MyDeathTest, KillMyself) {
-  EXPECT_EXIT(KillMyself(), ::testing::KilledBySignal(SIGKILL), "Sending myself unblockable signal");
-}
-```
-
-verifies that:
-
-  * calling `Foo(5)` causes the process to die with the given error message,
-  * calling `NormalExit()` causes the process to print `"Success"` to stderr and exit with exit code 0, and
-  * calling `KillMyself()` kills the process with signal `SIGKILL`.
-
-The test function body may contain other assertions and statements as well, if
-necessary.
-
-_Important:_ We strongly recommend you to follow the convention of naming your
-test case (not test) `*DeathTest` when it contains a death test, as
-demonstrated in the above example. The `Death Tests And Threads` section below
-explains why.
-
-If a test fixture class is shared by normal tests and death tests, you
-can use typedef to introduce an alias for the fixture class and avoid
-duplicating its code:
-```
-class FooTest : public ::testing::Test { ... };
-
-typedef FooTest FooDeathTest;
-
-TEST_F(FooTest, DoesThis) {
-  // normal test
-}
-
-TEST_F(FooDeathTest, DoesThat) {
-  // death test
-}
-```
-
-_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Cygwin, and Mac (the latter three are supported since v1.3.0).  `(ASSERT|EXPECT)_DEATH_IF_SUPPORTED` are new in v1.4.0.
-
-## Regular Expression Syntax ##
-
-On POSIX systems (e.g. Linux, Cygwin, and Mac), Google Test uses the
-[POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
-syntax in death tests. To learn about this syntax, you may want to read this [Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
-
-On Windows, Google Test uses its own simple regular expression
-implementation. It lacks many features you can find in POSIX extended
-regular expressions.  For example, we don't support union (`"x|y"`),
-grouping (`"(xy)"`), brackets (`"[xy]"`), and repetition count
-(`"x{5,7}"`), among others. Below is what we do support (`A` denotes a
-literal character, period (`.`), or a single `\\` escape sequence; `x`
-and `y` denote regular expressions.):
-
-| `c` | matches any literal character `c` |
-|:----|:----------------------------------|
-| `\\d` | matches any decimal digit         |
-| `\\D` | matches any character that's not a decimal digit |
-| `\\f` | matches `\f`                      |
-| `\\n` | matches `\n`                      |
-| `\\r` | matches `\r`                      |
-| `\\s` | matches any ASCII whitespace, including `\n` |
-| `\\S` | matches any character that's not a whitespace |
-| `\\t` | matches `\t`                      |
-| `\\v` | matches `\v`                      |
-| `\\w` | matches any letter, `_`, or decimal digit |
-| `\\W` | matches any character that `\\w` doesn't match |
-| `\\c` | matches any literal character `c`, which must be a punctuation |
-| `.` | matches any single character except `\n` |
-| `A?` | matches 0 or 1 occurrences of `A` |
-| `A*` | matches 0 or many occurrences of `A` |
-| `A+` | matches 1 or many occurrences of `A` |
-| `^` | matches the beginning of a string (not that of each line) |
-| `$` | matches the end of a string (not that of each line) |
-| `xy` | matches `x` followed by `y`       |
-
-To help you determine which capability is available on your system,
-Google Test defines macro `GTEST_USES_POSIX_RE=1` when it uses POSIX
-extended regular expressions, or `GTEST_USES_SIMPLE_RE=1` when it uses
-the simple version.  If you want your death tests to work in both
-cases, you can either `#if` on these macros or use the more limited
-syntax only.
-
-## How It Works ##
-
-Under the hood, `ASSERT_EXIT()` spawns a new process and executes the
-death test statement in that process. The details of of how precisely
-that happens depend on the platform and the variable
-`::testing::GTEST_FLAG(death_test_style)` (which is initialized from the
-command-line flag `--gtest_death_test_style`).
-
-  * On POSIX systems, `fork()` (or `clone()` on Linux) is used to spawn the child, after which:
-    * If the variable's value is `"fast"`, the death test statement is immediately executed.
-    * If the variable's value is `"threadsafe"`, the child process re-executes the unit test binary just as it was originally invoked, but with some extra flags to cause just the single death test under consideration to be run.
-  * On Windows, the child is spawned using the `CreateProcess()` API, and re-executes the binary to cause just the single death test under consideration to be run - much like the `threadsafe` mode on POSIX.
-
-Other values for the variable are illegal and will cause the death test to
-fail. Currently, the flag's default value is `"fast"`. However, we reserve the
-right to change it in the future. Therefore, your tests should not depend on
-this.
-
-In either case, the parent process waits for the child process to complete, and checks that
-
-  1. the child's exit status satisfies the predicate, and
-  1. the child's stderr matches the regular expression.
-
-If the death test statement runs to completion without dying, the child
-process will nonetheless terminate, and the assertion fails.
-
-## Death Tests And Threads ##
-
-The reason for the two death test styles has to do with thread safety. Due to
-well-known problems with forking in the presence of threads, death tests should
-be run in a single-threaded context. Sometimes, however, it isn't feasible to
-arrange that kind of environment. For example, statically-initialized modules
-may start threads before main is ever reached. Once threads have been created,
-it may be difficult or impossible to clean them up.
-
-Google Test has three features intended to raise awareness of threading issues.
-
-  1. A warning is emitted if multiple threads are running when a death test is encountered.
-  1. Test cases with a name ending in "DeathTest" are run before all other tests.
-  1. It uses `clone()` instead of `fork()` to spawn the child process on Linux (`clone()` is not available on Cygwin and Mac), as `fork()` is more likely to cause the child to hang when the parent process has multiple threads.
-
-It's perfectly fine to create threads inside a death test statement; they are
-executed in a separate process and cannot affect the parent.
-
-## Death Test Styles ##
-
-The "threadsafe" death test style was introduced in order to help mitigate the
-risks of testing in a possibly multithreaded environment. It trades increased
-test execution time (potentially dramatically so) for improved thread safety.
-We suggest using the faster, default "fast" style unless your test has specific
-problems with it.
-
-You can choose a particular style of death tests by setting the flag
-programmatically:
-
-```
-::testing::FLAGS_gtest_death_test_style = "threadsafe";
-```
-
-You can do this in `main()` to set the style for all death tests in the
-binary, or in individual tests. Recall that flags are saved before running each
-test and restored afterwards, so you need not do that yourself. For example:
-
-```
-TEST(MyDeathTest, TestOne) {
-  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-  // This test is run in the "threadsafe" style:
-  ASSERT_DEATH(ThisShouldDie(), "");
-}
-
-TEST(MyDeathTest, TestTwo) {
-  // This test is run in the "fast" style:
-  ASSERT_DEATH(ThisShouldDie(), "");
-}
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  ::testing::FLAGS_gtest_death_test_style = "fast";
-  return RUN_ALL_TESTS();
-}
-```
-
-## Caveats ##
-
-The _statement_ argument of `ASSERT_EXIT()` can be any valid C++ statement
-except that it can not return from the current function. This means
-_statement_ should not contain `return` or a macro that might return (e.g.
-`ASSERT_TRUE()` ). If _statement_ returns before it crashes, Google Test will
-print an error message, and the test will fail.
-
-Since _statement_ runs in the child process, any in-memory side effect (e.g.
-modifying a variable, releasing memory, etc) it causes will _not_ be observable
-in the parent process. In particular, if you release memory in a death test,
-your program will fail the heap check as the parent process will never see the
-memory reclaimed. To solve this problem, you can
-
-  1. try not to free memory in a death test;
-  1. free the memory again in the parent process; or
-  1. do not use the heap checker in your program.
-
-Due to an implementation detail, you cannot place multiple death test
-assertions on the same line; otherwise, compilation will fail with an unobvious
-error message.
-
-Despite the improved thread safety afforded by the "threadsafe" style of death
-test, thread problems such as deadlock are still possible in the presence of
-handlers registered with `pthread_atfork(3)`.
-
-# Using Assertions in Sub-routines #
-
-## Adding Traces to Assertions ##
-
-If a test sub-routine is called from several places, when an assertion
-inside it fails, it can be hard to tell which invocation of the
-sub-routine the failure is from.  You can alleviate this problem using
-extra logging or custom failure messages, but that usually clutters up
-your tests. A better solution is to use the `SCOPED_TRACE` macro:
-
-| `SCOPED_TRACE(`_message_`);` |
-|:-----------------------------|
-
-where _message_ can be anything streamable to `std::ostream`. This
-macro will cause the current file name, line number, and the given
-message to be added in every failure message. The effect will be
-undone when the control leaves the current lexical scope.
-
-For example,
-
-```
-10: void Sub1(int n) {
-11:   EXPECT_EQ(1, Bar(n));
-12:   EXPECT_EQ(2, Bar(n + 1));
-13: }
-14:
-15: TEST(FooTest, Bar) {
-16:   {
-17:     SCOPED_TRACE("A");  // This trace point will be included in
-18:                         // every failure in this scope.
-19:     Sub1(1);
-20:   }
-21:   // Now it won't.
-22:   Sub1(9);
-23: }
-```
-
-could result in messages like these:
-
-```
-path/to/foo_test.cc:11: Failure
-Value of: Bar(n)
-Expected: 1
-  Actual: 2
-   Trace:
-path/to/foo_test.cc:17: A
-
-path/to/foo_test.cc:12: Failure
-Value of: Bar(n + 1)
-Expected: 2
-  Actual: 3
-```
-
-Without the trace, it would've been difficult to know which invocation
-of `Sub1()` the two failures come from respectively. (You could add an
-extra message to each assertion in `Sub1()` to indicate the value of
-`n`, but that's tedious.)
-
-Some tips on using `SCOPED_TRACE`:
-
-  1. With a suitable message, it's often enough to use `SCOPED_TRACE` at the beginning of a sub-routine, instead of at each call site.
-  1. When calling sub-routines inside a loop, make the loop iterator part of the message in `SCOPED_TRACE` such that you can know which iteration the failure is from.
-  1. Sometimes the line number of the trace point is enough for identifying the particular invocation of a sub-routine. In this case, you don't have to choose a unique message for `SCOPED_TRACE`. You can simply use `""`.
-  1. You can use `SCOPED_TRACE` in an inner scope when there is one in the outer scope. In this case, all active trace points will be included in the failure messages, in reverse order they are encountered.
-  1. The trace dump is clickable in Emacs' compilation buffer - hit return on a line number and you'll be taken to that line in the source file!
-
-_Availability:_ Linux, Windows, Mac.
-
-## Propagating Fatal Failures ##
-
-A common pitfall when using `ASSERT_*` and `FAIL*` is not understanding that
-when they fail they only abort the _current function_, not the entire test. For
-example, the following test will segfault:
-```
-void Subroutine() {
-  // Generates a fatal failure and aborts the current function.
-  ASSERT_EQ(1, 2);
-  // The following won't be executed.
-  ...
-}
-
-TEST(FooTest, Bar) {
-  Subroutine();
-  // The intended behavior is for the fatal failure
-  // in Subroutine() to abort the entire test.
-  // The actual behavior: the function goes on after Subroutine() returns.
-  int* p = NULL;
-  *p = 3; // Segfault!
-}
-```
-
-Since we don't use exceptions, it is technically impossible to
-implement the intended behavior here.  To alleviate this, Google Test
-provides two solutions.  You could use either the
-`(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the
-`HasFatalFailure()` function.  They are described in the following two
-subsections.
-
-
-
-### Asserting on Subroutines ###
-
-As shown above, if your test calls a subroutine that has an `ASSERT_*`
-failure in it, the test will continue after the subroutine
-returns. This may not be what you want.
-
-Often people want fatal failures to propagate like exceptions.  For
-that Google Test offers the following macros:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_NO_FATAL_FAILURE(`_statement_`);` | `EXPECT_NO_FATAL_FAILURE(`_statement_`);` | _statement_ doesn't generate any new fatal failures in the current thread. |
-
-Only failures in the thread that executes the assertion are checked to
-determine the result of this type of assertions.  If _statement_
-creates new threads, failures in these threads are ignored.
-
-Examples:
-
-```
-ASSERT_NO_FATAL_FAILURE(Foo());
-
-int i;
-EXPECT_NO_FATAL_FAILURE({
-  i = Bar();
-});
-```
-
-_Availability:_ Linux, Windows, Mac. Assertions from multiple threads
-are currently not supported.
-
-### Checking for Failures in the Current Test ###
-
-`HasFatalFailure()` in the `::testing::Test` class returns `true` if an
-assertion in the current test has suffered a fatal failure. This
-allows functions to catch fatal failures in a sub-routine and return
-early.
-
-```
-class Test {
- public:
-  ...
-  static bool HasFatalFailure();
-};
-```
-
-The typical usage, which basically simulates the behavior of a thrown
-exception, is:
-
-```
-TEST(FooTest, Bar) {
-  Subroutine();
-  // Aborts if Subroutine() had a fatal failure.
-  if (HasFatalFailure())
-    return;
-  // The following won't be executed.
-  ...
-}
-```
-
-If `HasFatalFailure()` is used outside of `TEST()` , `TEST_F()` , or a test
-fixture, you must add the `::testing::Test::` prefix, as in:
-
-```
-if (::testing::Test::HasFatalFailure())
-  return;
-```
-
-Similarly, `HasNonfatalFailure()` returns `true` if the current test
-has at least one non-fatal failure, and `HasFailure()` returns `true`
-if the current test has at least one failure of either kind.
-
-_Availability:_ Linux, Windows, Mac.  `HasNonfatalFailure()` and
-`HasFailure()` are available since version 1.4.0.
-
-# Logging Additional Information #
-
-In your test code, you can call `RecordProperty("key", value)` to log
-additional information, where `value` can be either a C string or a 32-bit
-integer. The _last_ value recorded for a key will be emitted to the XML output
-if you specify one. For example, the test
-
-```
-TEST_F(WidgetUsageTest, MinAndMaxWidgets) {
-  RecordProperty("MaximumWidgets", ComputeMaxUsage());
-  RecordProperty("MinimumWidgets", ComputeMinUsage());
-}
-```
-
-will output XML like this:
-
-```
-...
-  <testcase name="MinAndMaxWidgets" status="run" time="6" classname="WidgetUsageTest"
-            MaximumWidgets="12"
-            MinimumWidgets="9" />
-...
-```
-
-_Note_:
-  * `RecordProperty()` is a static member of the `Test` class. Therefore it needs to be prefixed with `::testing::Test::` if used outside of the `TEST` body and the test fixture class.
-  * `key` must be a valid XML attribute name, and cannot conflict with the ones already used by Google Test (`name`, `status`,     `time`, and `classname`).
-
-_Availability_: Linux, Windows, Mac.
-
-# Sharing Resources Between Tests in the Same Test Case #
-
-
-
-Google Test creates a new test fixture object for each test in order to make
-tests independent and easier to debug. However, sometimes tests use resources
-that are expensive to set up, making the one-copy-per-test model prohibitively
-expensive.
-
-If the tests don't change the resource, there's no harm in them sharing a
-single resource copy. So, in addition to per-test set-up/tear-down, Google Test
-also supports per-test-case set-up/tear-down. To use it:
-
-  1. In your test fixture class (say `FooTest` ), define as `static` some member variables to hold the shared resources.
-  1. In the same test fixture class, define a `static void SetUpTestCase()` function (remember not to spell it as **`SetupTestCase`** with a small `u`!) to set up the shared resources and a `static void TearDownTestCase()` function to tear them down.
-
-That's it! Google Test automatically calls `SetUpTestCase()` before running the
-_first test_ in the `FooTest` test case (i.e. before creating the first
-`FooTest` object), and calls `TearDownTestCase()` after running the _last test_
-in it (i.e. after deleting the last `FooTest` object). In between, the tests
-can use the shared resources.
-
-Remember that the test order is undefined, so your code can't depend on a test
-preceding or following another. Also, the tests must either not modify the
-state of any shared resource, or, if they do modify the state, they must
-restore the state to its original value before passing control to the next
-test.
-
-Here's an example of per-test-case set-up and tear-down:
-```
-class FooTest : public ::testing::Test {
- protected:
-  // Per-test-case set-up.
-  // Called before the first test in this test case.
-  // Can be omitted if not needed.
-  static void SetUpTestCase() {
-    shared_resource_ = new ...;
-  }
-
-  // Per-test-case tear-down.
-  // Called after the last test in this test case.
-  // Can be omitted if not needed.
-  static void TearDownTestCase() {
-    delete shared_resource_;
-    shared_resource_ = NULL;
-  }
-
-  // You can define per-test set-up and tear-down logic as usual.
-  virtual void SetUp() { ... }
-  virtual void TearDown() { ... }
-
-  // Some expensive resource shared by all tests.
-  static T* shared_resource_;
-};
-
-T* FooTest::shared_resource_ = NULL;
-
-TEST_F(FooTest, Test1) {
-  ... you can refer to shared_resource here ...
-}
-TEST_F(FooTest, Test2) {
-  ... you can refer to shared_resource here ...
-}
-```
-
-_Availability:_ Linux, Windows, Mac.
-
-# Global Set-Up and Tear-Down #
-
-Just as you can do set-up and tear-down at the test level and the test case
-level, you can also do it at the test program level. Here's how.
-
-First, you subclass the `::testing::Environment` class to define a test
-environment, which knows how to set-up and tear-down:
-
-```
-class Environment {
- public:
-  virtual ~Environment() {}
-  // Override this to define how to set up the environment.
-  virtual void SetUp() {}
-  // Override this to define how to tear down the environment.
-  virtual void TearDown() {}
-};
-```
-
-Then, you register an instance of your environment class with Google Test by
-calling the `::testing::AddGlobalTestEnvironment()` function:
-
-```
-Environment* AddGlobalTestEnvironment(Environment* env);
-```
-
-Now, when `RUN_ALL_TESTS()` is called, it first calls the `SetUp()` method of
-the environment object, then runs the tests if there was no fatal failures, and
-finally calls `TearDown()` of the environment object.
-
-It's OK to register multiple environment objects. In this case, their `SetUp()`
-will be called in the order they are registered, and their `TearDown()` will be
-called in the reverse order.
-
-Note that Google Test takes ownership of the registered environment objects.
-Therefore **do not delete them** by yourself.
-
-You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is
-called, probably in `main()`. If you use `gtest_main`, you need to      call
-this before `main()` starts for it to take effect. One way to do this is to
-define a global variable like this:
-
-```
-::testing::Environment* const foo_env = ::testing::AddGlobalTestEnvironment(new FooEnvironment);
-```
-
-However, we strongly recommend you to write your own `main()` and call
-`AddGlobalTestEnvironment()` there, as relying on initialization of global
-variables makes the code harder to read and may cause problems when you
-register multiple environments from different translation units and the
-environments have dependencies among them (remember that the compiler doesn't
-guarantee the order in which global variables from different translation units
-are initialized).
-
-_Availability:_ Linux, Windows, Mac.
-
-
-# Value Parameterized Tests #
-
-_Value-parameterized tests_ allow you to test your code with different
-parameters without writing multiple copies of the same test.
-
-Suppose you write a test for your code and then realize that your code is affected by a presence of a Boolean command line flag.
-
-```
-TEST(MyCodeTest, TestFoo) {
-  // A code to test foo().
-}
-```
-
-Usually people factor their test code into a function with a Boolean parameter in such situations. The function sets the flag, then executes the testing code.
-
-```
-void TestFooHelper(bool flag_value) {
-  flag = flag_value;
-  // A code to test foo().
-}
-
-TEST(MyCodeTest, TestFooo) {
-  TestFooHelper(false);
-  TestFooHelper(true);
-}
-```
-
-But this setup has serious drawbacks. First, when a test assertion fails in your tests, it becomes unclear what value of the parameter caused it to fail. You can stream a clarifying message into your `EXPECT`/`ASSERT` statements, but it you'll have to do it with all of them. Second, you have to add one such helper function per test. What if you have ten tests? Twenty? A hundred?
-
-Value-parameterized tests will let you write your test only once and then easily instantiate and run it with an arbitrary number of parameter values.
-
-Here are some other situations when value-parameterized tests come handy:
-
-  * You wan to test different implementations of an OO interface.
-  * You want to test your code over various inputs (a.k.a. data-driven testing). This feature is easy to abuse, so please exercise your good sense when doing it!
-
-## How to Write Value-Parameterized Tests ##
-
-To write value-parameterized tests, first you should define a fixture
-class. It must be derived from `::testing::TestWithParam<T>`, where `T`
-is the type of your parameter values. `TestWithParam<T>` is itself
-derived from `::testing::Test`. `T` can be any copyable type. If it's
-a raw pointer, you are responsible for managing the lifespan of the
-pointed values.
-
-```
-class FooTest : public ::testing::TestWithParam<const char*> {
-  // You can implement all the usual fixture class members here.
-  // To access the test parameter, call GetParam() from class
-  // TestWithParam<T>.
-};
-```
-
-Then, use the `TEST_P` macro to define as many test patterns using
-this fixture as you want.  The `_P` suffix is for "parameterized" or
-"pattern", whichever you prefer to think.
-
-```
-TEST_P(FooTest, DoesBlah) {
-  // Inside a test, access the test parameter with the GetParam() method
-  // of the TestWithParam<T> class:
-  EXPECT_TRUE(foo.Blah(GetParam()));
-  ...
-}
-
-TEST_P(FooTest, HasBlahBlah) {
-  ...
-}
-```
-
-Finally, you can use `INSTANTIATE_TEST_CASE_P` to instantiate the test
-case with 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 are all in the `testing` namespace:
-
-| `Range(begin, end[, step])` | Yields values `{begin, begin+step, begin+step+step, ...}`. The values do not include `end`. `step` defaults to 1. |
-|:----------------------------|:------------------------------------------------------------------------------------------------------------------|
-| `Values(v1, v2, ..., vN)`   | Yields values `{v1, v2, ..., vN}`.                                                                                |
-| `ValuesIn(container)` and `ValuesIn(begin, end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)`.                  |
-| `Bool()`                    | Yields sequence `{false, true}`.                                                                                  |
-| `Combine(g1, g2, ..., gN)`  | Yields all combinations (the Cartesian product for the math savvy) of the values generated by the `N` generators. This is only available if your system provides the `<tr1/tuple>` header. If you are sure your system does, and Google Test disagrees, you can override it by defining `GTEST_HAS_TR1_TUPLE=1`. See comments in [include/gtest/internal/gtest-port.h](../include/gtest/internal/gtest-port.h) for more information. |
-
-For more details, see the comments at the definitions of these functions in the [source code](../include/gtest/gtest-param-test.h).
-
-The following statement will instantiate tests from the `FooTest` test case
-each with parameter values `"meeny"`, `"miny"`, and `"moe"`.
-
-```
-INSTANTIATE_TEST_CASE_P(InstantiationName,
-                        FooTest,
-                        ::testing::Values("meeny", "miny", "moe"));
-```
-
-To distinguish different instances of the pattern (yes, you can
-instantiate it more than once), the first argument to
-`INSTANTIATE_TEST_CASE_P` is a prefix that will be added to the actual
-test case name. Remember to pick unique prefixes for different
-instantiations. The tests from the instantiation above will have these
-names:
-
-  * `InstantiationName/FooTest.DoesBlah/0` for `"meeny"`
-  * `InstantiationName/FooTest.DoesBlah/1` for `"miny"`
-  * `InstantiationName/FooTest.DoesBlah/2` for `"moe"`
-  * `InstantiationName/FooTest.HasBlahBlah/0` for `"meeny"`
-  * `InstantiationName/FooTest.HasBlahBlah/1` for `"miny"`
-  * `InstantiationName/FooTest.HasBlahBlah/2` for `"moe"`
-
-You can use these names in [--gtest\-filter](#running-a-subset-of-the-tests).
-
-This statement will instantiate all tests from `FooTest` again, each
-with parameter values `"cat"` and `"dog"`:
-
-```
-const char* pets[] = {"cat", "dog"};
-INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest,
-                        ::testing::ValuesIn(pets));
-```
-
-The tests from the instantiation above will have these names:
-
-  * `AnotherInstantiationName/FooTest.DoesBlah/0` for `"cat"`
-  * `AnotherInstantiationName/FooTest.DoesBlah/1` for `"dog"`
-  * `AnotherInstantiationName/FooTest.HasBlahBlah/0` for `"cat"`
-  * `AnotherInstantiationName/FooTest.HasBlahBlah/1` for `"dog"`
-
-Please note that `INSTANTIATE_TEST_CASE_P` will instantiate _all_
-tests in the given test case, whether their definitions come before or
-_after_ the `INSTANTIATE_TEST_CASE_P` statement.
-
-You can see
-[these](../samples/sample7_unittest.cc)
-[files](../samples/sample8_unittest.cc) for more examples.
-
-_Availability_: Linux, Windows (requires MSVC 8.0 or above), Mac; since version 1.2.0.
-
-## Creating Value-Parameterized Abstract Tests ##
-
-In the above, we define and instantiate `FooTest` in the same source
-file. Sometimes you may want to define value-parameterized tests in a
-library and let other people instantiate them later. This pattern is
-known as <i>abstract tests</i>. As an example of its application, when you
-are designing an interface you can write a standard suite of abstract
-tests (perhaps using a factory function as the test parameter) that
-all implementations of the interface are expected to pass. When
-someone implements the interface, he can instantiate your suite to get
-all the interface-conformance tests for free.
-
-To define abstract tests, you should organize your code like this:
-
-  1. Put the definition of the parameterized test fixture class (e.g. `FooTest`) in a header file, say `foo_param_test.h`. Think of this as _declaring_ your abstract tests.
-  1. Put the `TEST_P` definitions in `foo_param_test.cc`, which includes `foo_param_test.h`. Think of this as _implementing_ your abstract tests.
-
-Once they are defined, you can instantiate them by including
-`foo_param_test.h`, invoking `INSTANTIATE_TEST_CASE_P()`, and linking
-with `foo_param_test.cc`. You can instantiate the same abstract test
-case multiple times, possibly in different source files.
-
-# Typed Tests #
-
-Suppose you have multiple implementations of the same interface and
-want to make sure that all of them satisfy some common requirements.
-Or, you may have defined several types that are supposed to conform to
-the same "concept" and you want to verify it.  In both cases, you want
-the same test logic repeated for different types.
-
-While you can write one `TEST` or `TEST_F` for each type you want to
-test (and you may even factor the test logic into a function template
-that you invoke from the `TEST`), it's tedious and doesn't scale:
-if you want _m_ tests over _n_ types, you'll end up writing _m\*n_
-`TEST`s.
-
-_Typed tests_ allow you to repeat the same test logic over a list of
-types.  You only need to write the test logic once, although you must
-know the type list when writing typed tests.  Here's how you do it:
-
-First, define a fixture class template.  It should be parameterized
-by a type.  Remember to derive it from `::testing::Test`:
-
-```
-template <typename T>
-class FooTest : public ::testing::Test {
- public:
-  ...
-  typedef std::list<T> List;
-  static T shared_;
-  T value_;
-};
-```
-
-Next, associate a list of types with the test case, which will be
-repeated for each type in the list:
-
-```
-typedef ::testing::Types<char, int, unsigned int> MyTypes;
-TYPED_TEST_CASE(FooTest, MyTypes);
-```
-
-The `typedef` is necessary for the `TYPED_TEST_CASE` macro to parse
-correctly.  Otherwise the compiler will think that each comma in the
-type list introduces a new macro argument.
-
-Then, use `TYPED_TEST()` instead of `TEST_F()` to define a typed test
-for this test case.  You can repeat this as many times as you want:
-
-```
-TYPED_TEST(FooTest, DoesBlah) {
-  // Inside a test, refer to the special name TypeParam to get the type
-  // parameter.  Since we are inside a derived class template, C++ requires
-  // us to visit the members of FooTest via 'this'.
-  TypeParam n = this->value_;
-
-  // To visit static members of the fixture, add the 'TestFixture::'
-  // prefix.
-  n += TestFixture::shared_;
-
-  // To refer to typedefs in the fixture, add the 'typename TestFixture::'
-  // prefix.  The 'typename' is required to satisfy the compiler.
-  typename TestFixture::List values;
-  values.push_back(n);
-  ...
-}
-
-TYPED_TEST(FooTest, HasPropertyA) { ... }
-```
-
-You can see `samples/sample6_unittest.cc` for a complete example.
-
-_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
-since version 1.1.0.
-
-# Type-Parameterized Tests #
-
-_Type-parameterized tests_ are like typed tests, except that they
-don't require you to know the list of types ahead of time.  Instead,
-you can define the test logic first and instantiate it with different
-type lists later.  You can even instantiate it more than once in the
-same program.
-
-If you are designing an interface or concept, you can define a suite
-of type-parameterized tests to verify properties that any valid
-implementation of the interface/concept should have.  Then, the author
-of each implementation can just instantiate the test suite with his
-type to verify that it conforms to the requirements, without having to
-write similar tests repeatedly.  Here's an example:
-
-First, define a fixture class template, as we did with typed tests:
-
-```
-template <typename T>
-class FooTest : public ::testing::Test {
-  ...
-};
-```
-
-Next, declare that you will define a type-parameterized test case:
-
-```
-TYPED_TEST_CASE_P(FooTest);
-```
-
-The `_P` suffix is for "parameterized" or "pattern", whichever you
-prefer to think.
-
-Then, use `TYPED_TEST_P()` to define a type-parameterized test.  You
-can repeat this as many times as you want:
-
-```
-TYPED_TEST_P(FooTest, DoesBlah) {
-  // Inside a test, refer to TypeParam to get the type parameter.
-  TypeParam n = 0;
-  ...
-}
-
-TYPED_TEST_P(FooTest, HasPropertyA) { ... }
-```
-
-Now the tricky part: you need to register all test patterns using the
-`REGISTER_TYPED_TEST_CASE_P` macro before you can instantiate them.
-The first argument of the macro is the test case name; the rest are
-the names of the tests in this test case:
-
-```
-REGISTER_TYPED_TEST_CASE_P(FooTest,
-                           DoesBlah, HasPropertyA);
-```
-
-Finally, you are free to instantiate the pattern with the types you
-want.  If you put the above code in a header file, you can `#include`
-it in multiple C++ source files and instantiate it multiple times.
-
-```
-typedef ::testing::Types<char, int, unsigned int> MyTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
-```
-
-To distinguish different instances of the pattern, the first argument
-to the `INSTANTIATE_TYPED_TEST_CASE_P` macro is a prefix that will be
-added to the actual test case name.  Remember to pick unique prefixes
-for different instances.
-
-In the special case where the type list contains only one type, you
-can write that type directly without `::testing::Types<...>`, like this:
-
-```
-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
-```
-
-You can see `samples/sample6_unittest.cc` for a complete example.
-
-_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
-since version 1.1.0.
-
-# Testing Private Code #
-
-If you change your software's internal implementation, your tests should not
-break as long as the change is not observable by users. Therefore, per the
-_black-box testing principle_, most of the time you should test your code
-through its public interfaces.
-
-If you still find yourself needing to test internal implementation code,
-consider if there's a better design that wouldn't require you to do so. If you
-absolutely have to test non-public interface code though, you can. There are
-two cases to consider:
-
-  * Static functions (_not_ the same as static member functions!) or unnamed namespaces, and
-  * Private or protected class members
-
-## Static Functions ##
-
-Both static functions and definitions/declarations in an unnamed namespace are
-only visible within the same translation unit. To test them, you can `#include`
-the entire `.cc` file being tested in your `*_test.cc` file. (`#include`ing `.cc`
-files is not a good way to reuse code - you should not do this in production
-code!)
-
-However, a better approach is to move the private code into the
-`foo::internal` namespace, where `foo` is the namespace your project normally
-uses, and put the private declarations in a `*-internal.h` file. Your
-production `.cc` files and your tests are allowed to include this internal
-header, but your clients are not. This way, you can fully test your internal
-implementation without leaking it to your clients.
-
-## Private Class Members ##
-
-Private class members are only accessible from within the class or by friends.
-To access a class' private members, you can declare your test fixture as a
-friend to the class and define accessors in your fixture. Tests using the
-fixture can then access the private members of your production class via the
-accessors in the fixture. Note that even though your fixture is a friend to
-your production class, your tests are not automatically friends to it, as they
-are technically defined in sub-classes of the fixture.
-
-Another way to test private members is to refactor them into an implementation
-class, which is then declared in a `*-internal.h` file. Your clients aren't
-allowed to include this header but your tests can. Such is called the Pimpl
-(Private Implementation) idiom.
-
-Or, you can declare an individual test as a friend of your class by adding this
-line in the class body:
-
-```
-FRIEND_TEST(TestCaseName, TestName);
-```
-
-For example,
-```
-// foo.h
-#include <gtest/gtest_prod.h>
-
-// Defines FRIEND_TEST.
-class Foo {
-  ...
- private:
-  FRIEND_TEST(FooTest, BarReturnsZeroOnNull);
-  int Bar(void* x);
-};
-
-// foo_test.cc
-...
-TEST(FooTest, BarReturnsZeroOnNull) {
-  Foo foo;
-  EXPECT_EQ(0, foo.Bar(NULL));
-  // Uses Foo's private member Bar().
-}
-```
-
-Pay special attention when your class is defined in a namespace, as you should
-define your test fixtures and tests in the same namespace if you want them to
-be friends of your class. For example, if the code to be tested looks like:
-
-```
-namespace my_namespace {
-
-class Foo {
-  friend class FooTest;
-  FRIEND_TEST(FooTest, Bar);
-  FRIEND_TEST(FooTest, Baz);
-  ...
-  definition of the class Foo
-  ...
-};
-
-}  // namespace my_namespace
-```
-
-Your test code should be something like:
-
-```
-namespace my_namespace {
-class FooTest : public ::testing::Test {
- protected:
-  ...
-};
-
-TEST_F(FooTest, Bar) { ... }
-TEST_F(FooTest, Baz) { ... }
-
-}  // namespace my_namespace
-```
-
-# Catching Failures #
-
-If you are building a testing utility on top of Google Test, you'll
-want to test your utility.  What framework would you use to test it?
-Google Test, of course.
-
-The challenge is to verify that your testing utility reports failures
-correctly.  In frameworks that report a failure by throwing an
-exception, you could catch the exception and assert on it.  But Google
-Test doesn't use exceptions, so how do we test that a piece of code
-generates an expected failure?
-
-`<gtest/gtest-spi.h>` contains some constructs to do this.  After
-`#include`ing this header, you can use
-
-| `EXPECT_FATAL_FAILURE(`_statement, substring_`);` |
-|:--------------------------------------------------|
-
-to assert that _statement_ generates a fatal (e.g. `ASSERT_*`) failure
-whose message contains the given _substring_, or use
-
-| `EXPECT_NONFATAL_FAILURE(`_statement, substring_`);` |
-|:-----------------------------------------------------|
-
-if you are expecting a non-fatal (e.g. `EXPECT_*`) failure.
-
-For technical reasons, there are some caveats:
-
-  1. You cannot stream a failure message to either macro.
-  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot reference local non-static variables or non-static members of `this` object.
-  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot return a value.
-
-_Note:_ Google Test is designed with threads in mind.  Once the
-synchronization primitives in `<gtest/internal/gtest-port.h>` have
-been implemented, Google Test will become thread-safe, meaning that
-you can then use assertions in multiple threads concurrently.  Before
-
-that, however, Google Test only supports single-threaded usage.  Once
-thread-safe, `EXPECT_FATAL_FAILURE()` and `EXPECT_NONFATAL_FAILURE()`
-will capture failures in the current thread only. If _statement_
-creates new threads, failures in these threads will be ignored.  If
-you want to capture failures from all threads instead, you should use
-the following macros:
-
-| `EXPECT_FATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
-|:-----------------------------------------------------------------|
-| `EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
-
-# Getting the Current Test's Name #
-
-Sometimes a function may need to know the name of the currently running test.
-For example, you may be using the `SetUp()` method of your test fixture to set
-the golden file name based on which test is running. The `::testing::TestInfo`
-class has this information:
-
-```
-namespace testing {
-
-class TestInfo {
- public:
-  // Returns the test case name and the test name, respectively.
-  //
-  // Do NOT delete or free the return value - it's managed by the
-  // TestInfo class.
-  const char* test_case_name() const;
-  const char* name() const;
-};
-
-}  // namespace testing
-```
-
-
-> To obtain a `TestInfo` object for the currently running test, call
-`current_test_info()` on the `UnitTest` singleton object:
-
-```
-// Gets information about the currently running test.
-// Do NOT delete the returned object - it's managed by the UnitTest class.
-const ::testing::TestInfo* const test_info =
-  ::testing::UnitTest::GetInstance()->current_test_info();
-printf("We are in test %s of test case %s.\n",
-       test_info->name(), test_info->test_case_name());
-```
-
-`current_test_info()` returns a null pointer if no test is running. In
-particular, you cannot find the test case name in `TestCaseSetUp()`,
-`TestCaseTearDown()` (where you know the test case name implicitly), or
-functions called from them.
-
-_Availability:_ Linux, Windows, Mac.
-
-# Extending Google Test by Handling Test Events #
-
-Google Test provides an <b>event listener API</b> to let you receive
-notifications about the progress of a test program and test
-failures. The events you can listen to include the start and end of
-the test program, a test case, or a test method, among others. You may
-use this API to augment or replace the standard console output,
-replace the XML output, or provide a completely different form of
-output, such as a GUI or a database. You can also use test events as
-checkpoints to implement a resource leak checker, for example.
-
-_Availability:_ Linux, Windows, Mac; since v1.4.0.
-
-## Defining Event Listeners ##
-
-To define a event listener, you subclass either
-[testing::TestEventListener](../include/gtest/gtest.h#L855)
-or [testing::EmptyTestEventListener](../include/gtest/gtest.h#L905).
-The former is an (abstract) interface, where <i>each pure virtual method<br>
-can be overridden to handle a test event</i> (For example, when a test
-starts, the `OnTestStart()` method will be called.). The latter provides
-an empty implementation of all methods in the interface, such that a
-subclass only needs to override the methods it cares about.
-
-When an event is fired, its context is passed to the handler function
-as an argument. The following argument types are used:
-  * [UnitTest](../include/gtest/gtest.h#L1007) reflects the state of the entire test program,
-  * [TestCase](../include/gtest/gtest.h#L689) has information about a test case, which can contain one or more tests,
-  * [TestInfo](../include/gtest/gtest.h#L599) contains the state of a test, and
-  * [TestPartResult](../include/gtest/gtest-test-part.h#L42) represents the result of a test assertion.
-
-An event handler function can examine the argument it receives to find
-out interesting information about the event and the test program's
-state.  Here's an example:
-
-```
-  class MinimalistPrinter : public ::testing::EmptyTestEventListener {
-    // Called before a test starts.
-    virtual void OnTestStart(const ::testing::TestInfo& test_info) {
-      printf("*** Test %s.%s starting.\n",
-             test_info.test_case_name(), test_info.name());
-    }
-
-    // Called after a failed assertion or a SUCCESS().
-    virtual void OnTestPartResult(
-        const ::testing::TestPartResult& test_part_result) {
-      printf("%s in %s:%d\n%s\n",
-             test_part_result.failed() ? "*** Failure" : "Success",
-             test_part_result.file_name(),
-             test_part_result.line_number(),
-             test_part_result.summary());
-    }
-
-    // Called after a test ends.
-    virtual void OnTestEnd(const ::testing::TestInfo& test_info) {
-      printf("*** Test %s.%s ending.\n",
-             test_info.test_case_name(), test_info.name());
-    }
-  };
-```
-
-## Using Event Listeners ##
-
-To use the event listener you have defined, add an instance of it to
-the Google Test event listener list (represented by class
-[TestEventListeners](../include/gtest/gtest.h#L929)
-- note the "s" at the end of the name) in your
-`main()` function, before calling `RUN_ALL_TESTS()`:
-```
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  // Gets hold of the event listener list.
-  ::testing::TestEventListeners& listeners =
-      ::testing::UnitTest::GetInstance()->listeners();
-  // Adds a listener to the end.  Google Test takes the ownership.
-  listeners.Append(new MinimalistPrinter);
-  return RUN_ALL_TESTS();
-}
-```
-
-There's only one problem: the default test result printer is still in
-effect, so its output will mingle with the output from your minimalist
-printer. To suppress the default printer, just release it from the
-event listener list and delete it. You can do so by adding one line:
-```
-  ...
-  delete listeners.Release(listeners.default_result_printer());
-  listeners.Append(new MinimalistPrinter);
-  return RUN_ALL_TESTS();
-```
-
-Now, sit back and enjoy a completely different output from your
-tests. For more details, you can read this
-[sample](../samples/sample9_unittest.cc).
-
-You may append more than one listener to the list. When an `On*Start()`
-or `OnTestPartResult()` event is fired, the listeners will receive it in
-the order they appear in the list (since new listeners are added to
-the end of the list, the default text printer and the default XML
-generator will receive the event first). An `On*End()` event will be
-received by the listeners in the _reverse_ order. This allows output by
-listeners added later to be framed by output from listeners added
-earlier.
-
-## Generating Failures in Listeners ##
-
-You may use failure-raising macros (`EXPECT_*()`, `ASSERT_*()`,
-`FAIL()`, etc) when processing an event. There are some restrictions:
-
-  1. You cannot generate any failure in `OnTestPartResult()` (otherwise it will cause `OnTestPartResult()` to be called recursively).
-  1. A listener that handles `OnTestPartResult()` is not allowed to generate any failure.
-
-When you add listeners to the listener list, you should put listeners
-that handle `OnTestPartResult()` _before_ listeners that can generate
-failures. This ensures that failures generated by the latter are
-attributed to the right test by the former.
-
-We have a sample of failure-raising listener
-[here](../samples/sample10_unittest.cc).
-
-# Running Test Programs: Advanced Options #
-
-Google Test test programs are ordinary executables. Once built, you can run
-them directly and affect their behavior via the following environment variables
-and/or command line flags. For the flags to work, your programs must call
-`::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`.
-
-To see a list of supported flags and their usage, please run your test
-program with the `--help` flag.  You can also use `-h`, `-?`, or `/?`
-for short.  This feature is added in version 1.3.0.
-
-If an option is specified both by an environment variable and by a
-flag, the latter takes precedence.  Most of the options can also be
-set/read in code: to access the value of command line flag
-`--gtest_foo`, write `::testing::GTEST_FLAG(foo)`.  A common pattern is
-to set the value of a flag before calling `::testing::InitGoogleTest()`
-to change the default value of the flag:
-```
-int main(int argc, char** argv) {
-  // Disables elapsed time by default.
-  ::testing::GTEST_FLAG(print_time) = false;
-
-  // This allows the user to override the flag on the command line.
-  ::testing::InitGoogleTest(&argc, argv);
-
-  return RUN_ALL_TESTS();
-}
-```
-
-## Selecting Tests ##
-
-This section shows various options for choosing which tests to run.
-
-### Listing Test Names ###
-
-Sometimes it is necessary to list the available tests in a program before
-running them so that a filter may be applied if needed. Including the flag
-`--gtest_list_tests` overrides all other flags and lists tests in the following
-format:
-```
-TestCase1.
-  TestName1
-  TestName2
-TestCase2.
-  TestName
-```
-
-None of the tests listed are actually run if the flag is provided. There is no
-corresponding environment variable for this flag.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Running a Subset of the Tests ###
-
-By default, a Google Test program runs all tests the user has defined.
-Sometimes, you want to run only a subset of the tests (e.g. for debugging or
-quickly verifying a change). If you set the `GTEST_FILTER` environment variable
-or the `--gtest_filter` flag to a filter string, Google Test will only run the
-tests whose full names (in the form of `TestCaseName.TestName`) match the
-filter.
-
-The format of a filter is a '`:`'-separated list of wildcard patterns (called
-the positive patterns) optionally followed by a '`-`' and another
-'`:`'-separated pattern list (called the negative patterns). A test matches the
-filter if and only if it matches any of the positive patterns but does not
-match any of the negative patterns.
-
-A pattern may contain `'*'` (matches any string) or `'?'` (matches any single
-character). For convenience, the filter `'*-NegativePatterns'` can be also
-written as `'-NegativePatterns'`.
-
-For example:
-
-  * `./foo_test` Has no flag, and thus runs all its tests.
-  * `./foo_test --gtest_filter=*` Also runs everything, due to the single match-everything `*` value.
-  * `./foo_test --gtest_filter=FooTest.*` Runs everything in test case `FooTest`.
-  * `./foo_test --gtest_filter=*Null*:*Constructor*` Runs any test whose full name contains either `"Null"` or `"Constructor"`.
-  * `./foo_test --gtest_filter=-*DeathTest.*` Runs all non-death tests.
-  * `./foo_test --gtest_filter=FooTest.*-FooTest.Bar` Runs everything in test case `FooTest` except `FooTest.Bar`.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Temporarily Disabling Tests ###
-
-If you have a broken test that you cannot fix right away, you can add the
-`DISABLED_` prefix to its name. This will exclude it from execution. This is
-better than commenting out the code or using `#if 0`, as disabled tests are
-still compiled (and thus won't rot).
-
-If you need to disable all tests in a test case, you can either add `DISABLED_`
-to the front of the name of each test, or alternatively add it to the front of
-the test case name.
-
-For example, the following tests won't be run by Google Test, even though they
-will still be compiled:
-
-```
-// Tests that Foo does Abc.
-TEST(FooTest, DISABLED_DoesAbc) { ... }
-
-class DISABLED_BarTest : public ::testing::Test { ... };
-
-// Tests that Bar does Xyz.
-TEST_F(DISABLED_BarTest, DoesXyz) { ... }
-```
-
-_Note:_ This feature should only be used for temporary pain-relief. You still
-have to fix the disabled tests at a later date. As a reminder, Google Test will
-print a banner warning you if a test program contains any disabled tests.
-
-_Tip:_ You can easily count the number of disabled tests you have
-using `grep`. This number can be used as a metric for improving your
-test quality.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Temporarily Enabling Disabled Tests ###
-
-To include [disabled tests](#temporarily-disabling-tests) in test
-execution, just invoke the test program with the
-`--gtest_also_run_disabled_tests` flag or set the
-`GTEST_ALSO_RUN_DISABLED_TESTS` environment variable to a value other
-than `0`.  You can combine this with the
-[--gtest\_filter](#running-a-subset-of-the-tests) flag to further select
-which disabled tests to run.
-
-_Availability:_ Linux, Windows, Mac; since version 1.3.0.
-
-## Repeating the Tests ##
-
-Once in a while you'll run into a test whose result is hit-or-miss. Perhaps it
-will fail only 1% of the time, making it rather hard to reproduce the bug under
-a debugger. This can be a major source of frustration.
-
-The `--gtest_repeat` flag allows you to repeat all (or selected) test methods
-in a program many times. Hopefully, a flaky test will eventually fail and give
-you a chance to debug. Here's how to use it:
-
-| `$ foo_test --gtest_repeat=1000` | Repeat foo\_test 1000 times and don't stop at failures. |
-|:---------------------------------|:--------------------------------------------------------|
-| `$ foo_test --gtest_repeat=-1`   | A negative count means repeating forever.               |
-| `$ foo_test --gtest_repeat=1000 --gtest_break_on_failure` | Repeat foo\_test 1000 times, stopping at the first failure. This is especially useful when running under a debugger: when the testfails, it will drop into the debugger and you can then inspect variables and stacks. |
-| `$ foo_test --gtest_repeat=1000 --gtest_filter=FooBar` | Repeat the tests whose name matches the filter 1000 times. |
-
-If your test program contains global set-up/tear-down code registered
-using `AddGlobalTestEnvironment()`, it will be repeated in each
-iteration as well, as the flakiness may be in it. You can also specify
-the repeat count by setting the `GTEST_REPEAT` environment variable.
-
-_Availability:_ Linux, Windows, Mac.
-
-## Shuffling the Tests ##
-
-You can specify the `--gtest_shuffle` flag (or set the `GTEST_SHUFFLE`
-environment variable to `1`) to run the tests in a program in a random
-order. This helps to reveal bad dependencies between tests.
-
-By default, Google Test uses a random seed calculated from the current
-time. Therefore you'll get a different order every time. The console
-output includes the random seed value, such that you can reproduce an
-order-related test failure later. To specify the random seed
-explicitly, use the `--gtest_random_seed=SEED` flag (or set the
-`GTEST_RANDOM_SEED` environment variable), where `SEED` is an integer
-between 0 and 99999. The seed value 0 is special: it tells Google Test
-to do the default behavior of calculating the seed from the current
-time.
-
-If you combine this with `--gtest_repeat=N`, Google Test will pick a
-different random seed and re-shuffle the tests in each iteration.
-
-_Availability:_ Linux, Windows, Mac; since v1.4.0.
-
-## Controlling Test Output ##
-
-This section teaches how to tweak the way test results are reported.
-
-### Colored Terminal Output ###
-
-Google Test can use colors in its terminal output to make it easier to spot
-the separation between tests, and whether tests passed.
-
-You can set the GTEST\_COLOR environment variable or set the `--gtest_color`
-command line flag to `yes`, `no`, or `auto` (the default) to enable colors,
-disable colors, or let Google Test decide. When the value is `auto`, Google
-Test will use colors if and only if the output goes to a terminal and (on
-non-Windows platforms) the `TERM` environment variable is set to `xterm` or
-`xterm-color`.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Suppressing the Elapsed Time ###
-
-By default, Google Test prints the time it takes to run each test.  To
-suppress that, run the test program with the `--gtest_print_time=0`
-command line flag.  Setting the `GTEST_PRINT_TIME` environment
-variable to `0` has the same effect.
-
-_Availability:_ Linux, Windows, Mac.  (In Google Test 1.3.0 and lower,
-the default behavior is that the elapsed time is **not** printed.)
-
-### Generating an XML Report ###
-
-Google Test can emit a detailed XML report to a file in addition to its normal
-textual output. The report contains the duration of each test, and thus can
-help you identify slow tests.
-
-To generate the XML report, set the `GTEST_OUTPUT` environment variable or the
-`--gtest_output` flag to the string `"xml:_path_to_output_file_"`, which will
-create the file at the given location. You can also just use the string
-`"xml"`, in which case the output can be found in the `test_detail.xml` file in
-the current directory.
-
-If you specify a directory (for example, `"xml:output/directory/"` on Linux or
-`"xml:output\directory\"` on Windows), Google Test will create the XML file in
-that directory, named after the test executable (e.g. `foo_test.xml` for test
-program `foo_test` or `foo_test.exe`). If the file already exists (perhaps left
-over from a previous run), Google Test will pick a different name (e.g.
-`foo_test_1.xml`) to avoid overwriting it.
-
-The report uses the format described here.  It is based on the
-`junitreport` Ant task and can be parsed by popular continuous build
-systems like [Hudson](https://hudson.dev.java.net/). Since that format
-was originally intended for Java, a little interpretation is required
-to make it apply to Google Test tests, as shown here:
-
-```
-<testsuites name="AllTests" ...>
-  <testsuite name="test_case_name" ...>
-    <testcase name="test_name" ...>
-      <failure message="..."/>
-      <failure message="..."/>
-      <failure message="..."/>
-    </testcase>
-  </testsuite>
-</testsuites>
-```
-
-  * The root `<testsuites>` element corresponds to the entire test program.
-  * `<testsuite>` elements correspond to Google Test test cases.
-  * `<testcase>` elements correspond to Google Test test functions.
-
-For instance, the following program
-
-```
-TEST(MathTest, Addition) { ... }
-TEST(MathTest, Subtraction) { ... }
-TEST(LogicTest, NonContradiction) { ... }
-```
-
-could generate this report:
-
-```
-<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="3" failures="1" errors="0" time="35" name="AllTests">
-  <testsuite name="MathTest" tests="2" failures="1"* errors="0" time="15">
-    <testcase name="Addition" status="run" time="7" classname="">
-      <failure message="Value of: add(1, 1)&#x0A; Actual: 3&#x0A;Expected: 2" type=""/>
-      <failure message="Value of: add(1, -1)&#x0A; Actual: 1&#x0A;Expected: 0" type=""/>
-    </testcase>
-    <testcase name="Subtraction" status="run" time="5" classname="">
-    </testcase>
-  </testsuite>
-  <testsuite name="LogicTest" tests="1" failures="0" errors="0" time="5">
-    <testcase name="NonContradiction" status="run" time="5" classname="">
-    </testcase>
-  </testsuite>
-</testsuites>
-```
-
-Things to note:
-
-  * The `tests` attribute of a `<testsuites>` or `<testsuite>` element tells how many test functions the Google Test program or test case contains, while the `failures` attribute tells how many of them failed.
-  * The `time` attribute expresses the duration of the test, test case, or entire test program in milliseconds.
-  * Each `<failure>` element corresponds to a single failed Google Test assertion.
-  * Some JUnit concepts don't apply to Google Test, yet we have to conform to the DTD. Therefore you'll see some dummy elements and attributes in the report. You can safely ignore these parts.
-
-_Availability:_ Linux, Windows, Mac.
-
-## Controlling How Failures Are Reported ##
-
-### Turning Assertion Failures into Break-Points ###
-
-When running test programs under a debugger, it's very convenient if the
-debugger can catch an assertion failure and automatically drop into interactive
-mode. Google Test's _break-on-failure_ mode supports this behavior.
-
-To enable it, set the `GTEST_BREAK_ON_FAILURE` environment variable to a value
-other than `0` . Alternatively, you can use the `--gtest_break_on_failure`
-command line flag.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Suppressing Pop-ups Caused by Exceptions ###
-
-On Windows, Google Test may be used with exceptions enabled. Even when
-exceptions are disabled, an application can still throw structured exceptions
-(SEH's). If a test throws an exception, by default Google Test doesn't try to
-catch it. Instead, you'll see a pop-up dialog, at which point you can attach
-the process to a debugger and easily find out what went wrong.
-
-However, if you don't want to see the pop-ups (for example, if you run the
-tests in a batch job), set the `GTEST_CATCH_EXCEPTIONS` environment variable to
-a non- `0` value, or use the `--gtest_catch_exceptions` flag. Google Test now
-catches all test-thrown exceptions and logs them as failures.
-
-_Availability:_ Windows. `GTEST_CATCH_EXCEPTIONS` and
-`--gtest_catch_exceptions` have no effect on Google Test's behavior on Linux or
-Mac, even if exceptions are enabled. It is possible to add support for catching
-exceptions on these platforms, but it is not implemented yet.
-
-### Letting Another Testing Framework Drive ###
-
-If you work on a project that has already been using another testing
-framework and is not ready to completely switch to Google Test yet,
-you can get much of Google Test's benefit by using its assertions in
-your existing tests.  Just change your `main()` function to look
-like:
-
-```
-#include <gtest/gtest.h>
-
-int main(int argc, char** argv) {
-  ::testing::GTEST_FLAG(throw_on_failure) = true;
-  // Important: Google Test must be initialized.
-  ::testing::InitGoogleTest(&argc, argv);
-
-  ... whatever your existing testing framework requires ...
-}
-```
-
-With that, you can use Google Test assertions in addition to the
-native assertions your testing framework provides, for example:
-
-```
-void TestFooDoesBar() {
-  Foo foo;
-  EXPECT_LE(foo.Bar(1), 100);     // A Google Test assertion.
-  CPPUNIT_ASSERT(foo.IsEmpty());  // A native assertion.
-}
-```
-
-If a Google Test assertion fails, it will print an error message and
-throw an exception, which will be treated as a failure by your host
-testing framework.  If you compile your code with exceptions disabled,
-a failed Google Test assertion will instead exit your program with a
-non-zero code, which will also signal a test failure to your test
-runner.
-
-If you don't write `::testing::GTEST_FLAG(throw_on_failure) = true;` in
-your `main()`, you can alternatively enable this feature by specifying
-the `--gtest_throw_on_failure` flag on the command-line or setting the
-`GTEST_THROW_ON_FAILURE` environment variable to a non-zero value.
-
-_Availability:_ Linux, Windows, Mac; since v1.3.0.
-
-## Distributing Test Functions to Multiple Machines ##
-
-If you have more than one machine you can use to run a test program,
-you might want to run the test functions in parallel and get the
-result faster.  We call this technique _sharding_, where each machine
-is called a _shard_.
-
-Google Test is compatible with test sharding.  To take advantage of
-this feature, your test runner (not part of Google Test) needs to do
-the following:
-
-  1. Allocate a number of machines (shards) to run the tests.
-  1. On each shard, set the `GTEST_TOTAL_SHARDS` environment variable to the total number of shards.  It must be the same for all shards.
-  1. On each shard, set the `GTEST_SHARD_INDEX` environment variable to the index of the shard.  Different shards must be assigned different indices, which must be in the range `[0, GTEST_TOTAL_SHARDS - 1]`.
-  1. Run the same test program on all shards.  When Google Test sees the above two environment variables, it will select a subset of the test functions to run.  Across all shards, each test function in the program will be run exactly once.
-  1. Wait for all shards to finish, then collect and report the results.
-
-Your project may have tests that were written without Google Test and
-thus don't understand this protocol.  In order for your test runner to
-figure out which test supports sharding, it can set the environment
-variable `GTEST_SHARD_STATUS_FILE` to a non-existent file path.  If a
-test program supports sharding, it will create this file to
-acknowledge the fact (the actual contents of the file are not
-important at this time; although we may stick some useful information
-in it in the future.); otherwise it will not create it.
-
-Here's an example to make it clear.  Suppose you have a test program
-`foo_test` that contains the following 5 test functions:
-```
-TEST(A, V)
-TEST(A, W)
-TEST(B, X)
-TEST(B, Y)
-TEST(B, Z)
-```
-and you have 3 machines at your disposal.  To run the test functions in
-parallel, you would set `GTEST_TOTAL_SHARDS` to 3 on all machines, and
-set `GTEST_SHARD_INDEX` to 0, 1, and 2 on the machines respectively.
-Then you would run the same `foo_test` on each machine.
-
-Google Test reserves the right to change how the work is distributed
-across the shards, but here's one possible scenario:
-
-  * Machine #0 runs `A.V` and `B.X`.
-  * Machine #1 runs `A.W` and `B.Y`.
-  * Machine #2 runs `B.Z`.
-
-_Availability:_ Linux, Windows, Mac; since version 1.3.0.
-
-# Fusing Google Test Source Files #
-
-Google Test's implementation consists of ~30 files (excluding its own
-tests).  Sometimes you may want them to be packaged up in two files (a
-`.h` and a `.cc`) instead, such that you can easily copy them to a new
-machine and start hacking there.  For this we provide an experimental
-Python script `fuse_gtest_files.py` in the `scripts/` directory (since release 1.3.0).
-Assuming you have Python 2.4 or above installed on your machine, just
-go to that directory and run
-```
-python fuse_gtest_files.py OUTPUT_DIR
-```
-
-and you should see an `OUTPUT_DIR` directory being created with files
-`gtest/gtest.h` and `gtest/gtest-all.cc` in it.  These files contain
-everything you need to use Google Test.  Just copy them to anywhere
-you want and you are ready to write tests.  You can use the
-[scrpts/test/Makefile](../scripts/test/Makefile)
-file as an example on how to compile your tests against them.
-
-# Where to Go from Here #
-
-Congratulations! You've now learned more advanced Google Test tools and are
-ready to tackle more complex testing tasks. If you want to dive even deeper, you
-can read the [FAQ](V1_5_FAQ.md).
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Documentation.md
deleted file mode 100644
index 46bba2ec..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Documentation.md
+++ /dev/null
@@ -1,12 +0,0 @@
-This page lists all official documentation wiki pages for Google Test **1.5.0** -- **if you use a different version of Google Test, make sure to read the documentation for that version instead.**
-
-  * [Primer](V1_5_Primer.md) -- start here if you are new to Google Test.
-  * [Samples](Samples.md) -- learn from examples.
-  * [AdvancedGuide](V1_5_AdvancedGuide.md) -- learn more about Google Test.
-  * [XcodeGuide](V1_5_XcodeGuide.md) -- how to use Google Test in Xcode on Mac.
-  * [Frequently-Asked Questions](V1_5_FAQ.md) -- check here before asking a question on the mailing list.
-
-To contribute code to Google Test, read:
-
-  * DevGuide -- read this _before_ writing your first patch.
-  * [PumpManual](V1_5_PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_FAQ.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_FAQ.md
deleted file mode 100644
index e870aff0..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_FAQ.md
+++ /dev/null
@@ -1,886 +0,0 @@
-
-
-If you cannot find the answer to your question here, and you have read
-[Primer](V1_5_Primer.md) and [AdvancedGuide](V1_5_AdvancedGuide.md), send it to
-googletestframework@googlegroups.com.
-
-## Why should I use Google Test instead of my favorite C++ testing framework? ##
-
-First, let's say clearly that we don't want to get into the debate of
-which C++ testing framework is **the best**.  There exist many fine
-frameworks for writing C++ tests, and we have tremendous respect for
-the developers and users of them.  We don't think there is (or will
-be) a single best framework - you have to pick the right tool for the
-particular task you are tackling.
-
-We created Google Test because we couldn't find the right combination
-of features and conveniences in an existing framework to satisfy _our_
-needs.  The following is a list of things that _we_ like about Google
-Test.  We don't claim them to be unique to Google Test - rather, the
-combination of them makes Google Test the choice for us.  We hope this
-list can help you decide whether it is for you too.
-
-  * Google Test is designed to be portable.  It works where many STL types (e.g. `std::string` and `std::vector`) don't compile.  It doesn't require exceptions or RTTI.  As a result, it runs on Linux, Mac OS X, Windows and several embedded operating systems.
-  * Nonfatal assertions (`EXPECT_*`) have proven to be great time savers, as they allow a test to report multiple failures in a single edit-compile-test cycle.
-  * It's easy to write assertions that generate informative messages: you just use the stream syntax to append any additional information, e.g. `ASSERT_EQ(5, Foo(i)) << " where i = " << i;`.  It doesn't require a new set of macros or special functions.
-  * Google Test automatically detects your tests and doesn't require you to enumerate them in order to run them.
-  * No framework can anticipate all your needs, so Google Test provides `EXPECT_PRED*` to make it easy to extend your assertion vocabulary.  For a nicer syntax, you can define your own assertion macros trivially in terms of `EXPECT_PRED*`.
-  * Death tests are pretty handy for ensuring that your asserts in production code are triggered by the right conditions.
-  * `SCOPED_TRACE` helps you understand the context of an assertion failure when it comes from inside a sub-routine or loop.
-  * You can decide which tests to run using name patterns.  This saves time when you want to quickly reproduce a test failure.
-
-## How do I generate 64-bit binaries on Windows (using Visual Studio 2008)? ##
-
-(Answered by Trevor Robinson)
-
-Load the supplied Visual Studio solution file, either `msvc\gtest-md.sln` or
-`msvc\gtest.sln`. Go through the migration wizard to migrate the
-solution and project files to Visual Studio 2008. Select
-`Configuration Manager...` from the `Build` menu. Select `<New...>` from
-the `Active solution platform` dropdown.  Select `x64` from the new
-platform dropdown, leave `Copy settings from` set to `Win32` and
-`Create new project platforms` checked, then click `OK`. You now have
-`Win32` and `x64` platform configurations, selectable from the
-`Standard` toolbar, which allow you to toggle between building 32-bit or
-64-bit binaries (or both at once using Batch Build).
-
-In order to prevent build output files from overwriting one another,
-you'll need to change the `Intermediate Directory` settings for the
-newly created platform configuration across all the projects. To do
-this, multi-select (e.g. using shift-click) all projects (but not the
-solution) in the `Solution Explorer`. Right-click one of them and
-select `Properties`. In the left pane, select `Configuration Properties`,
-and from the `Configuration` dropdown, select `All Configurations`.
-Make sure the selected platform is `x64`. For the
-`Intermediate Directory` setting, change the value from
-`$(PlatformName)\$(ConfigurationName)` to
-`$(OutDir)\$(ProjectName)`. Click `OK` and then build the
-solution. When the build is complete, the 64-bit binaries will be in
-the `msvc\x64\Debug` directory.
-
-## Can I use Google Test on MinGW? ##
-
-We haven't tested this ourselves, but Per Abrahamsen reported that he
-was able to compile and install Google Test successfully when using
-MinGW from Cygwin.  You'll need to configure it with:
-
-`PATH/TO/configure CC="gcc -mno-cygwin" CXX="g++ -mno-cygwin"`
-
-You should be able to replace the `-mno-cygwin` option with direct links
-to the real MinGW binaries, but we haven't tried that.
-
-Caveats:
-
-  * There are many warnings when compiling.
-  * `make check` will produce some errors as not all tests for Google Test itself are compatible with MinGW.
-
-We also have reports on successful cross compilation of Google Test MinGW binaries on Linux using [these instructions](http://wiki.wxwidgets.org/Cross-Compiling_Under_Linux#Cross-compiling_under_Linux_for_MS_Windows) on the WxWidgets site.
-
-Please contact `googletestframework@googlegroups.com` if you are
-interested in improving the support for MinGW.
-
-## Why does Google Test support EXPECT\_EQ(NULL, ptr) and ASSERT\_EQ(NULL, ptr) but not EXPECT\_NE(NULL, ptr) and ASSERT\_NE(NULL, ptr)? ##
-
-Due to some peculiarity of C++, it requires some non-trivial template
-meta programming tricks to support using `NULL` as an argument of the
-`EXPECT_XX()` and `ASSERT_XX()` macros. Therefore we only do it where
-it's most needed (otherwise we make the implementation of Google Test
-harder to maintain and more error-prone than necessary).
-
-The `EXPECT_EQ()` macro takes the _expected_ value as its first
-argument and the _actual_ value as the second. It's reasonable that
-someone wants to write `EXPECT_EQ(NULL, some_expression)`, and this
-indeed was requested several times. Therefore we implemented it.
-
-The need for `EXPECT_NE(NULL, ptr)` isn't nearly as strong. When the
-assertion fails, you already know that `ptr` must be `NULL`, so it
-doesn't add any information to print ptr in this case. That means
-`EXPECT_TRUE(ptr ! NULL)` works just as well.
-
-If we were to support `EXPECT_NE(NULL, ptr)`, for consistency we'll
-have to support `EXPECT_NE(ptr, NULL)` as well, as unlike `EXPECT_EQ`,
-we don't have a convention on the order of the two arguments for
-`EXPECT_NE`. This means using the template meta programming tricks
-twice in the implementation, making it even harder to understand and
-maintain. We believe the benefit doesn't justify the cost.
-
-Finally, with the growth of Google Mock's [matcher](../../CookBook.md#using-matchers-in-google-test-assertions) library, we are
-encouraging people to use the unified `EXPECT_THAT(value, matcher)`
-syntax more often in tests. One significant advantage of the matcher
-approach is that matchers can be easily combined to form new matchers,
-while the `EXPECT_NE`, etc, macros cannot be easily
-combined. Therefore we want to invest more in the matchers than in the
-`EXPECT_XX()` macros.
-
-## Does Google Test support running tests in parallel? ##
-
-Test runners tend to be tightly coupled with the build/test
-environment, and Google Test doesn't try to solve the problem of
-running tests in parallel.  Instead, we tried to make Google Test work
-nicely with test runners.  For example, Google Test's XML report
-contains the time spent on each test, and its `gtest_list_tests` and
-`gtest_filter` flags can be used for splitting the execution of test
-methods into multiple processes.  These functionalities can help the
-test runner run the tests in parallel.
-
-## Why don't Google Test run the tests in different threads to speed things up? ##
-
-It's difficult to write thread-safe code.  Most tests are not written
-with thread-safety in mind, and thus may not work correctly in a
-multi-threaded setting.
-
-If you think about it, it's already hard to make your code work when
-you know what other threads are doing.  It's much harder, and
-sometimes even impossible, to make your code work when you don't know
-what other threads are doing (remember that test methods can be added,
-deleted, or modified after your test was written).  If you want to run
-the tests in parallel, you'd better run them in different processes.
-
-## Why aren't Google Test assertions implemented using exceptions? ##
-
-Our original motivation was to be able to use Google Test in projects
-that disable exceptions.  Later we realized some additional benefits
-of this approach:
-
-  1. Throwing in a destructor is undefined behavior in C++.  Not using exceptions means Google Test's assertions are safe to use in destructors.
-  1. The `EXPECT_*` family of macros will continue even after a failure, allowing multiple failures in a `TEST` to be reported in a single run. This is a popular feature, as in C++ the edit-compile-test cycle is usually quite long and being able to fixing more than one thing at a time is a blessing.
-  1. If assertions are implemented using exceptions, a test may falsely ignore a failure if it's caught by user code:
-```
-try { ... ASSERT_TRUE(...) ... }
-catch (...) { ... }
-```
-The above code will pass even if the `ASSERT_TRUE` throws.  While it's unlikely for someone to write this in a test, it's possible to run into this pattern when you write assertions in callbacks that are called by the code under test.
-
-The downside of not using exceptions is that `ASSERT_*` (implemented
-using `return`) will only abort the current function, not the current
-`TEST`.
-
-## Why do we use two different macros for tests with and without fixtures? ##
-
-Unfortunately, C++'s macro system doesn't allow us to use the same
-macro for both cases.  One possibility is to provide only one macro
-for tests with fixtures, and require the user to define an empty
-fixture sometimes:
-
-```
-class FooTest : public ::testing::Test {};
-
-TEST_F(FooTest, DoesThis) { ... }
-```
-or
-```
-typedef ::testing::Test FooTest;
-
-TEST_F(FooTest, DoesThat) { ... }
-```
-
-Yet, many people think this is one line too many. :-) Our goal was to
-make it really easy to write tests, so we tried to make simple tests
-trivial to create.  That means using a separate macro for such tests.
-
-We think neither approach is ideal, yet either of them is reasonable.
-In the end, it probably doesn't matter much either way.
-
-## Why don't we use structs as test fixtures? ##
-
-We like to use structs only when representing passive data.  This
-distinction between structs and classes is good for documenting the
-intent of the code's author.  Since test fixtures have logic like
-`SetUp()` and `TearDown()`, they are better defined as classes.
-
-## Why are death tests implemented as assertions instead of using a test runner? ##
-
-Our goal was to make death tests as convenient for a user as C++
-possibly allows.  In particular:
-
-  * The runner-style requires to split the information into two pieces: the definition of the death test itself, and the specification for the runner on how to run the death test and what to expect.  The death test would be written in C++, while the runner spec may or may not be.  A user needs to carefully keep the two in sync. `ASSERT_DEATH(statement, expected_message)` specifies all necessary information in one place, in one language, without boilerplate code. It is very declarative.
-  * `ASSERT_DEATH` has a similar syntax and error-reporting semantics as other Google Test assertions, and thus is easy to learn.
-  * `ASSERT_DEATH` can be mixed with other assertions and other logic at your will.  You are not limited to one death test per test method. For example, you can write something like:
-```
-    if (FooCondition()) {
-      ASSERT_DEATH(Bar(), "blah");
-    } else {
-      ASSERT_EQ(5, Bar());
-    }
-```
-If you prefer one death test per test method, you can write your tests in that style too, but we don't want to impose that on the users.  The fewer artificial limitations the better.
-  * `ASSERT_DEATH` can reference local variables in the current function, and you can decide how many death tests you want based on run-time information.  For example,
-```
-    const int count = GetCount();  // Only known at run time.
-    for (int i = 1; i <= count; i++) {
-      ASSERT_DEATH({
-        double* buffer = new double[i];
-        ... initializes buffer ...
-        Foo(buffer, i)
-      }, "blah blah");
-    }
-```
-The runner-based approach tends to be more static and less flexible, or requires more user effort to get this kind of flexibility.
-
-Another interesting thing about `ASSERT_DEATH` is that it calls `fork()`
-to create a child process to run the death test.  This is lightening
-fast, as `fork()` uses copy-on-write pages and incurs almost zero
-overhead, and the child process starts from the user-supplied
-statement directly, skipping all global and local initialization and
-any code leading to the given statement.  If you launch the child
-process from scratch, it can take seconds just to load everything and
-start running if the test links to many libraries dynamically.
-
-## My death test modifies some state, but the change seems lost after the death test finishes. Why? ##
-
-Death tests (`EXPECT_DEATH`, etc) are executed in a sub-process s.t. the
-expected crash won't kill the test program (i.e. the parent process). As a
-result, any in-memory side effects they incur are observable in their
-respective sub-processes, but not in the parent process. You can think of them
-as running in a parallel universe, more or less.
-
-## The compiler complains about "undefined references" to some static const member variables, but I did define them in the class body. What's wrong? ##
-
-If your class has a static data member:
-
-```
-// foo.h
-class Foo {
-  ...
-  static const int kBar = 100;
-};
-```
-
-You also need to define it _outside_ of the class body in `foo.cc`:
-
-```
-const int Foo::kBar;  // No initializer here.
-```
-
-Otherwise your code is **invalid C++**, and may break in unexpected ways. In
-particular, using it in Google Test comparison assertions (`EXPECT_EQ`, etc)
-will generate an "undefined reference" linker error.
-
-## I have an interface that has several implementations. Can I write a set of tests once and repeat them over all the implementations? ##
-
-Google Test doesn't yet have good support for this kind of tests, or
-data-driven tests in general. We hope to be able to make improvements in this
-area soon.
-
-## Can I derive a test fixture from another? ##
-
-Yes.
-
-Each test fixture has a corresponding and same named test case. This means only
-one test case can use a particular fixture. Sometimes, however, multiple test
-cases may want to use the same or slightly different fixtures. For example, you
-may want to make sure that all of a GUI library's test cases don't leak
-important system resources like fonts and brushes.
-
-In Google Test, you share a fixture among test cases by putting the shared
-logic in a base test fixture, then deriving from that base a separate fixture
-for each test case that wants to use this common logic. You then use `TEST_F()`
-to write tests using each derived fixture.
-
-Typically, your code looks like this:
-
-```
-// Defines a base test fixture.
-class BaseTest : public ::testing::Test {
-  protected:
-   ...
-};
-
-// Derives a fixture FooTest from BaseTest.
-class FooTest : public BaseTest {
-  protected:
-    virtual void SetUp() {
-      BaseTest::SetUp();  // Sets up the base fixture first.
-      ... additional set-up work ...
-    }
-    virtual void TearDown() {
-      ... clean-up work for FooTest ...
-      BaseTest::TearDown();  // Remember to tear down the base fixture
-                             // after cleaning up FooTest!
-    }
-    ... functions and variables for FooTest ...
-};
-
-// Tests that use the fixture FooTest.
-TEST_F(FooTest, Bar) { ... }
-TEST_F(FooTest, Baz) { ... }
-
-... additional fixtures derived from BaseTest ...
-```
-
-If necessary, you can continue to derive test fixtures from a derived fixture.
-Google Test has no limit on how deep the hierarchy can be.
-
-For a complete example using derived test fixtures, see
-`samples/sample5_unittest.cc`.
-
-## My compiler complains "void value not ignored as it ought to be." What does this mean? ##
-
-You're probably using an `ASSERT_*()` in a function that doesn't return `void`.
-`ASSERT_*()` can only be used in `void` functions.
-
-## My death test hangs (or seg-faults). How do I fix it? ##
-
-In Google Test, death tests are run in a child process and the way they work is
-delicate. To write death tests you really need to understand how they work.
-Please make sure you have read this.
-
-In particular, death tests don't like having multiple threads in the parent
-process. So the first thing you can try is to eliminate creating threads
-outside of `EXPECT_DEATH()`.
-
-Sometimes this is impossible as some library you must use may be creating
-threads before `main()` is even reached. In this case, you can try to minimize
-the chance of conflicts by either moving as many activities as possible inside
-`EXPECT_DEATH()` (in the extreme case, you want to move everything inside), or
-leaving as few things as possible in it. Also, you can try to set the death
-test style to `"threadsafe"`, which is safer but slower, and see if it helps.
-
-If you go with thread-safe death tests, remember that they rerun the test
-program from the beginning in the child process. Therefore make sure your
-program can run side-by-side with itself and is deterministic.
-
-In the end, this boils down to good concurrent programming. You have to make
-sure that there is no race conditions or dead locks in your program. No silver
-bullet - sorry!
-
-## Should I use the constructor/destructor of the test fixture or the set-up/tear-down function? ##
-
-The first thing to remember is that Google Test does not reuse the
-same test fixture object across multiple tests. For each `TEST_F`,
-Google Test will create a fresh test fixture object, _immediately_
-call `SetUp()`, run the test, call `TearDown()`, and then
-_immediately_ delete the test fixture object. Therefore, there is no
-need to write a `SetUp()` or `TearDown()` function if the constructor
-or destructor already does the job.
-
-You may still want to use `SetUp()/TearDown()` in the following cases:
-  * If the tear-down operation could throw an exception, you must use `TearDown()` as opposed to the destructor, as throwing in a destructor leads to undefined behavior and usually will kill your program right away. Note that many standard libraries (like STL) may throw when exceptions are enabled in the compiler. Therefore you should prefer `TearDown()` if you want to write portable tests that work with or without exceptions.
-  * The Google Test team is considering making the assertion macros throw on platforms where exceptions are enabled (e.g. Windows, Mac OS, and Linux client-side), which will eliminate the need for the user to propagate failures from a subroutine to its caller. Therefore, you shouldn't use Google Test assertions in a destructor if your code could run on such a platform.
-  * In a constructor or destructor, you cannot make a virtual function call on this object. (You can call a method declared as virtual, but it will be statically bound.) Therefore, if you need to call a method that will be overriden in a derived class, you have to use `SetUp()/TearDown()`.
-
-## The compiler complains "no matching function to call" when I use ASSERT\_PREDn. How do I fix it? ##
-
-If the predicate function you use in `ASSERT_PRED*` or `EXPECT_PRED*` is
-overloaded or a template, the compiler will have trouble figuring out which
-overloaded version it should use. `ASSERT_PRED_FORMAT*` and
-`EXPECT_PRED_FORMAT*` don't have this problem.
-
-If you see this error, you might want to switch to
-`(ASSERT|EXPECT)_PRED_FORMAT*`, which will also give you a better failure
-message. If, however, that is not an option, you can resolve the problem by
-explicitly telling the compiler which version to pick.
-
-For example, suppose you have
-
-```
-bool IsPositive(int n) {
-  return n > 0;
-}
-bool IsPositive(double x) {
-  return x > 0;
-}
-```
-
-you will get a compiler error if you write
-
-```
-EXPECT_PRED1(IsPositive, 5);
-```
-
-However, this will work:
-
-```
-EXPECT_PRED1(*static_cast<bool (*)(int)>*(IsPositive), 5);
-```
-
-(The stuff inside the angled brackets for the `static_cast` operator is the
-type of the function pointer for the `int`-version of `IsPositive()`.)
-
-As another example, when you have a template function
-
-```
-template <typename T>
-bool IsNegative(T x) {
-  return x < 0;
-}
-```
-
-you can use it in a predicate assertion like this:
-
-```
-ASSERT_PRED1(IsNegative*<int>*, -5);
-```
-
-Things are more interesting if your template has more than one parameters. The
-following won't compile:
-
-```
-ASSERT_PRED2(*GreaterThan<int, int>*, 5, 0);
-```
-
-
-as the C++ pre-processor thinks you are giving `ASSERT_PRED2` 4 arguments,
-which is one more than expected. The workaround is to wrap the predicate
-function in parentheses:
-
-```
-ASSERT_PRED2(*(GreaterThan<int, int>)*, 5, 0);
-```
-
-
-## My compiler complains about "ignoring return value" when I call RUN\_ALL\_TESTS(). Why? ##
-
-Some people had been ignoring the return value of `RUN_ALL_TESTS()`. That is,
-instead of
-
-```
-return RUN_ALL_TESTS();
-```
-
-they write
-
-```
-RUN_ALL_TESTS();
-```
-
-This is wrong and dangerous. A test runner needs to see the return value of
-`RUN_ALL_TESTS()` in order to determine if a test has passed. If your `main()`
-function ignores it, your test will be considered successful even if it has a
-Google Test assertion failure. Very bad.
-
-To help the users avoid this dangerous bug, the implementation of
-`RUN_ALL_TESTS()` causes gcc to raise this warning, when the return value is
-ignored. If you see this warning, the fix is simple: just make sure its value
-is used as the return value of `main()`.
-
-## My compiler complains that a constructor (or destructor) cannot return a value. What's going on? ##
-
-Due to a peculiarity of C++, in order to support the syntax for streaming
-messages to an `ASSERT_*`, e.g.
-
-```
-ASSERT_EQ(1, Foo()) << "blah blah" << foo;
-```
-
-we had to give up using `ASSERT*` and `FAIL*` (but not `EXPECT*` and
-`ADD_FAILURE*`) in constructors and destructors. The workaround is to move the
-content of your constructor/destructor to a private void member function, or
-switch to `EXPECT_*()` if that works. This section in the user's guide explains
-it.
-
-## My set-up function is not called. Why? ##
-
-C++ is case-sensitive. It should be spelled as `SetUp()`.  Did you
-spell it as `Setup()`?
-
-Similarly, sometimes people spell `SetUpTestCase()` as `SetupTestCase()` and
-wonder why it's never called.
-
-## How do I jump to the line of a failure in Emacs directly? ##
-
-Google Test's failure message format is understood by Emacs and many other
-IDEs, like acme and XCode. If a Google Test message is in a compilation buffer
-in Emacs, then it's clickable. You can now hit `enter` on a message to jump to
-the corresponding source code, or use `C-x `` to jump to the next failure.
-
-## I have several test cases which share the same test fixture logic, do I have to define a new test fixture class for each of them? This seems pretty tedious. ##
-
-You don't have to. Instead of
-
-```
-class FooTest : public BaseTest {};
-
-TEST_F(FooTest, Abc) { ... }
-TEST_F(FooTest, Def) { ... }
-
-class BarTest : public BaseTest {};
-
-TEST_F(BarTest, Abc) { ... }
-TEST_F(BarTest, Def) { ... }
-```
-
-you can simply `typedef` the test fixtures:
-```
-typedef BaseTest FooTest;
-
-TEST_F(FooTest, Abc) { ... }
-TEST_F(FooTest, Def) { ... }
-
-typedef BaseTest BarTest;
-
-TEST_F(BarTest, Abc) { ... }
-TEST_F(BarTest, Def) { ... }
-```
-
-## The Google Test output is buried in a whole bunch of log messages. What do I do? ##
-
-The Google Test output is meant to be a concise and human-friendly report. If
-your test generates textual output itself, it will mix with the Google Test
-output, making it hard to read. However, there is an easy solution to this
-problem.
-
-Since most log messages go to stderr, we decided to let Google Test output go
-to stdout. This way, you can easily separate the two using redirection. For
-example:
-```
-./my_test > googletest_output.txt
-```
-
-## Why should I prefer test fixtures over global variables? ##
-
-There are several good reasons:
-  1. It's likely your test needs to change the states of its global variables. This makes it difficult to keep side effects from escaping one test and contaminating others, making debugging difficult. By using fixtures, each test has a fresh set of variables that's different (but with the same names). Thus, tests are kept independent of each other.
-  1. Global variables pollute the global namespace.
-  1. Test fixtures can be reused via subclassing, which cannot be done easily with global variables. This is useful if many test cases have something in common.
-
-## How do I test private class members without writing FRIEND\_TEST()s? ##
-
-You should try to write testable code, which means classes should be easily
-tested from their public interface. One way to achieve this is the Pimpl idiom:
-you move all private members of a class into a helper class, and make all
-members of the helper class public.
-
-You have several other options that don't require using `FRIEND_TEST`:
-  * Write the tests as members of the fixture class:
-```
-class Foo {
-  friend class FooTest;
-  ...
-};
-
-class FooTest : public ::testing::Test {
- protected:
-  ...
-  void Test1() {...} // This accesses private members of class Foo.
-  void Test2() {...} // So does this one.
-};
-
-TEST_F(FooTest, Test1) {
-  Test1();
-}
-
-TEST_F(FooTest, Test2) {
-  Test2();
-}
-```
-  * In the fixture class, write accessors for the tested class' private members, then use the accessors in your tests:
-```
-class Foo {
-  friend class FooTest;
-  ...
-};
-
-class FooTest : public ::testing::Test {
- protected:
-  ...
-  T1 get_private_member1(Foo* obj) {
-    return obj->private_member1_;
-  }
-};
-
-TEST_F(FooTest, Test1) {
-  ...
-  get_private_member1(x)
-  ...
-}
-```
-  * If the methods are declared **protected**, you can change their access level in a test-only subclass:
-```
-class YourClass {
-  ...
- protected: // protected access for testability.
-  int DoSomethingReturningInt();
-  ...
-};
-
-// in the your_class_test.cc file:
-class TestableYourClass : public YourClass {
-  ...
- public: using YourClass::DoSomethingReturningInt; // changes access rights
-  ...
-};
-
-TEST_F(YourClassTest, DoSomethingTest) {
-  TestableYourClass obj;
-  assertEquals(expected_value, obj.DoSomethingReturningInt());
-}
-```
-
-## How do I test private class static members without writing FRIEND\_TEST()s? ##
-
-We find private static methods clutter the header file.  They are
-implementation details and ideally should be kept out of a .h. So often I make
-them free functions instead.
-
-Instead of:
-```
-// foo.h
-class Foo {
-  ...
- private:
-  static bool Func(int n);
-};
-
-// foo.cc
-bool Foo::Func(int n) { ... }
-
-// foo_test.cc
-EXPECT_TRUE(Foo::Func(12345));
-```
-
-You probably should better write:
-```
-// foo.h
-class Foo {
-  ...
-};
-
-// foo.cc
-namespace internal {
-  bool Func(int n) { ... }
-}
-
-// foo_test.cc
-namespace internal {
-  bool Func(int n);
-}
-
-EXPECT_TRUE(internal::Func(12345));
-```
-
-## I would like to run a test several times with different parameters. Do I need to write several similar copies of it? ##
-
-No. You can use a feature called [value-parameterized tests](V1_5_AdvancedGuide.md#Value_Parameterized_Tests) which
-lets you repeat your tests with different parameters, without defining it more than once.
-
-## How do I test a file that defines main()? ##
-
-To test a `foo.cc` file, you need to compile and link it into your unit test
-program. However, when the file contains a definition for the `main()`
-function, it will clash with the `main()` of your unit test, and will result in
-a build error.
-
-The right solution is to split it into three files:
-  1. `foo.h` which contains the declarations,
-  1. `foo.cc` which contains the definitions except `main()`, and
-  1. `foo_main.cc` which contains nothing but the definition of `main()`.
-
-Then `foo.cc` can be easily tested.
-
-If you are adding tests to an existing file and don't want an intrusive change
-like this, there is a hack: just include the entire `foo.cc` file in your unit
-test. For example:
-```
-// File foo_unittest.cc
-
-// The headers section
-...
-
-// Renames main() in foo.cc to make room for the unit test main()
-#define main FooMain
-
-#include "a/b/foo.cc"
-
-// The tests start here.
-...
-```
-
-
-However, please remember this is a hack and should only be used as the last
-resort.
-
-## What can the statement argument in ASSERT\_DEATH() be? ##
-
-`ASSERT_DEATH(_statement_, _regex_)` (or any death assertion macro) can be used
-wherever `_statement_` is valid. So basically `_statement_` can be any C++
-statement that makes sense in the current context. In particular, it can
-reference global and/or local variables, and can be:
-  * a simple function call (often the case),
-  * a complex expression, or
-  * a compound statement.
-
-> Some examples are shown here:
-
-```
-// A death test can be a simple function call.
-TEST(MyDeathTest, FunctionCall) {
-  ASSERT_DEATH(Xyz(5), "Xyz failed");
-}
-
-// Or a complex expression that references variables and functions.
-TEST(MyDeathTest, ComplexExpression) {
-  const bool c = Condition();
-  ASSERT_DEATH((c ? Func1(0) : object2.Method("test")),
-               "(Func1|Method) failed");
-}
-
-// Death assertions can be used any where in a function. In
-// particular, they can be inside a loop.
-TEST(MyDeathTest, InsideLoop) {
-  // Verifies that Foo(0), Foo(1), ..., and Foo(4) all die.
-  for (int i = 0; i < 5; i++) {
-    EXPECT_DEATH_M(Foo(i), "Foo has \\d+ errors",
-                   ::testing::Message() << "where i is " << i);
-  }
-}
-
-// A death assertion can contain a compound statement.
-TEST(MyDeathTest, CompoundStatement) {
-  // Verifies that at lease one of Bar(0), Bar(1), ..., and
-  // Bar(4) dies.
-  ASSERT_DEATH({
-    for (int i = 0; i < 5; i++) {
-      Bar(i);
-    }
-  },
-  "Bar has \\d+ errors");}
-```
-
-`googletest_unittest.cc` contains more examples if you are interested.
-
-## What syntax does the regular expression in ASSERT\_DEATH use? ##
-
-On POSIX systems, Google Test uses the POSIX Extended regular
-expression syntax
-(http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions). On
-Windows, it uses a limited variant of regular expression syntax. For
-more details, see the [regular expression syntax](V1_5_AdvancedGuide.md#Regular_Expression_Syntax).
-
-## I have a fixture class Foo, but TEST\_F(Foo, Bar) gives me error "no matching function for call to Foo::Foo()". Why? ##
-
-Google Test needs to be able to create objects of your test fixture class, so
-it must have a default constructor. Normally the compiler will define one for
-you. However, there are cases where you have to define your own:
-  * If you explicitly declare a non-default constructor for class `Foo`, then you need to define a default constructor, even if it would be empty.
-  * If `Foo` has a const non-static data member, then you have to define the default constructor _and_ initialize the const member in the initializer list of the constructor. (Early versions of `gcc` doesn't force you to initialize the const member. It's a bug that has been fixed in `gcc 4`.)
-
-## Why does ASSERT\_DEATH complain about previous threads that were already joined? ##
-
-With the Linux pthread library, there is no turning back once you cross the
-line from single thread to multiple threads. The first time you create a
-thread, a manager thread is created in addition, so you get 3, not 2, threads.
-Later when the thread you create joins the main thread, the thread count
-decrements by 1, but the manager thread will never be killed, so you still have
-2 threads, which means you cannot safely run a death test.
-
-The new NPTL thread library doesn't suffer from this problem, as it doesn't
-create a manager thread. However, if you don't control which machine your test
-runs on, you shouldn't depend on this.
-
-## Why does Google Test require the entire test case, instead of individual tests, to be named FOODeathTest when it uses ASSERT\_DEATH? ##
-
-Google Test does not interleave tests from different test cases. That is, it
-runs all tests in one test case first, and then runs all tests in the next test
-case, and so on. Google Test does this because it needs to set up a test case
-before the first test in it is run, and tear it down afterwords. Splitting up
-the test case would require multiple set-up and tear-down processes, which is
-inefficient and makes the semantics unclean.
-
-If we were to determine the order of tests based on test name instead of test
-case name, then we would have a problem with the following situation:
-
-```
-TEST_F(FooTest, AbcDeathTest) { ... }
-TEST_F(FooTest, Uvw) { ... }
-
-TEST_F(BarTest, DefDeathTest) { ... }
-TEST_F(BarTest, Xyz) { ... }
-```
-
-Since `FooTest.AbcDeathTest` needs to run before `BarTest.Xyz`, and we don't
-interleave tests from different test cases, we need to run all tests in the
-`FooTest` case before running any test in the `BarTest` case. This contradicts
-with the requirement to run `BarTest.DefDeathTest` before `FooTest.Uvw`.
-
-## But I don't like calling my entire test case FOODeathTest when it contains both death tests and non-death tests. What do I do? ##
-
-You don't have to, but if you like, you may split up the test case into
-`FooTest` and `FooDeathTest`, where the names make it clear that they are
-related:
-
-```
-class FooTest : public ::testing::Test { ... };
-
-TEST_F(FooTest, Abc) { ... }
-TEST_F(FooTest, Def) { ... }
-
-typedef FooTest FooDeathTest;
-
-TEST_F(FooDeathTest, Uvw) { ... EXPECT_DEATH(...) ... }
-TEST_F(FooDeathTest, Xyz) { ... ASSERT_DEATH(...) ... }
-```
-
-## The compiler complains about "no match for 'operator<<'" when I use an assertion. What gives? ##
-
-If you use a user-defined type `FooType` in an assertion, you must make sure
-there is an `std::ostream& operator<<(std::ostream&, const FooType&)` function
-defined such that we can print a value of `FooType`.
-
-In addition, if `FooType` is declared in a name space, the `<<` operator also
-needs to be defined in the _same_ name space.
-
-## How do I suppress the memory leak messages on Windows? ##
-
-Since the statically initialized Google Test singleton requires allocations on
-the heap, the Visual C++ memory leak detector will report memory leaks at the
-end of the program run. The easiest way to avoid this is to use the
-`_CrtMemCheckpoint` and `_CrtMemDumpAllObjectsSince` calls to not report any
-statically initialized heap objects. See MSDN for more details and additional
-heap check/debug routines.
-
-## I am building my project with Google Test in Visual Studio and all I'm getting is a bunch of linker errors (or warnings). Help! ##
-
-You may get a number of the following linker error or warnings if you
-attempt to link your test project with the Google Test library when
-your project and the are not built using the same compiler settings.
-
-  * LNK2005: symbol already defined in object
-  * LNK4217: locally defined symbol 'symbol' imported in function 'function'
-  * LNK4049: locally defined symbol 'symbol' imported
-
-The Google Test project (gtest.vcproj) has the Runtime Library option
-set to /MT (use multi-threaded static libraries, /MTd for debug). If
-your project uses something else, for example /MD (use multi-threaded
-DLLs, /MDd for debug), you need to change the setting in the Google
-Test project to match your project's.
-
-To update this setting open the project properties in the Visual
-Studio IDE then select the branch Configuration Properties | C/C++ |
-Code Generation and change the option "Runtime Library".  You may also try
-using gtest-md.vcproj instead of gtest.vcproj.
-
-## I put my tests in a library and Google Test doesn't run them. What's happening? ##
-Have you read a
-[warning](V1_5_Primer.md#important-note-for-visual-c-users) on
-the Google Test Primer page?
-
-## I want to use Google Test with Visual Studio but don't know where to start. ##
-Many people are in your position and one of the posted his solution to
-our mailing list. Here is his link:
-http://hassanjamilahmad.blogspot.com/2009/07/gtest-starters-help.html.
-
-## My question is not covered in your FAQ! ##
-
-If you cannot find the answer to your question in this FAQ, there are
-some other resources you can use:
-
-  1. read other [wiki pages](http://code.google.com/p/googletest/w/list),
-  1. search the mailing list [archive](http://groups.google.com/group/googletestframework/topics),
-  1. ask it on [googletestframework@googlegroups.com](mailto:googletestframework@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googletestframework) before you can post.).
-
-Please note that creating an issue in the
-[issue tracker](http://code.google.com/p/googletest/issues/list) is _not_
-a good way to get your answer, as it is monitored infrequently by a
-very small number of people.
-
-When asking a question, it's helpful to provide as much of the
-following information as possible (people cannot help you if there's
-not enough information in your question):
-
-  * the version (or the revision number if you check out from SVN directly) of Google Test you use (Google Test is under active development, so it's possible that your problem has been solved in a later version),
-  * your operating system,
-  * the name and version of your compiler,
-  * the complete command line flags you give to your compiler,
-  * the complete compiler error messages (if the question is about compilation),
-  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Primer.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Primer.md
deleted file mode 100644
index 6960d2ce..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_Primer.md
+++ /dev/null
@@ -1,497 +0,0 @@
-
-
-# Introduction: Why Google C++ Testing Framework? #
-
-_Google C++ Testing Framework_ helps you write better C++ tests.
-
-No matter whether you work on Linux, Windows, or a Mac, if you write C++ code,
-Google Test can help you.
-
-So what makes a good test, and how does Google C++ Testing Framework fit in? We believe:
-  1. Tests should be _independent_ and _repeatable_. It's a pain to debug a test that succeeds or fails as a result of other tests.  Google C++ Testing Framework isolates the tests by running each of them on a different object. When a test fails, Google C++ Testing Framework allows you to run it in isolation for quick debugging.
-  1. Tests should be well _organized_ and reflect the structure of the tested code.  Google C++ Testing Framework groups related tests into test cases that can share data and subroutines. This common pattern is easy to recognize and makes tests easy to maintain. Such consistency is especially helpful when people switch projects and start to work on a new code base.
-  1. Tests should be _portable_ and _reusable_. The open-source community has a lot of code that is platform-neutral, its tests should also be platform-neutral.  Google C++ Testing Framework works on different OSes, with different compilers (gcc, MSVC, and others), with or without exceptions, so Google C++ Testing Framework tests can easily work with a variety of configurations.  (Note that the current release only contains build scripts for Linux - we are actively working on scripts for other platforms.)
-  1. When tests fail, they should provide as much _information_ about the problem as possible. Google C++ Testing Framework doesn't stop at the first test failure. Instead, it only stops the current test and continues with the next. You can also set up tests that report non-fatal failures after which the current test continues. Thus, you can detect and fix multiple bugs in a single run-edit-compile cycle.
-  1. The testing framework should liberate test writers from housekeeping chores and let them focus on the test _content_.  Google C++ Testing Framework automatically keeps track of all tests defined, and doesn't require the user to enumerate them in order to run them.
-  1. Tests should be _fast_. With Google C++ Testing Framework, you can reuse shared resources across tests and pay for the set-up/tear-down only once, without making tests depend on each other.
-
-Since Google C++ Testing Framework is based on the popular xUnit
-architecture, you'll feel right at home if you've used JUnit or PyUnit before.
-If not, it will take you about 10 minutes to learn the basics and get started.
-So let's go!
-
-_Note:_ We sometimes refer to Google C++ Testing Framework informally
-as _Google Test_.
-
-# Setting up a New Test Project #
-
-To write a test program using Google Test, you need to compile Google
-Test into a library and link your test with it.  We provide build
-files for some popular build systems (`msvc/` for Visual Studio,
-`xcode/` for Mac Xcode, `make/` for GNU make, `codegear/` for Borland
-C++ Builder, and the autotools script in the
-Google Test root directory).  If your build system is not on this
-list, you can take a look at `make/Makefile` to learn how Google Test
-should be compiled (basically you want to compile `src/gtest-all.cc`
-with `GTEST_ROOT` and `GTEST_ROOT/include` in the header search path,
-where `GTEST_ROOT` is the Google Test root directory).
-
-Once you are able to compile the Google Test library, you should
-create a project or build target for your test program.  Make sure you
-have `GTEST_ROOT/include` in the header search path so that the
-compiler can find `<gtest/gtest.h>` when compiling your test.  Set up
-your test project to link with the Google Test library (for example,
-in Visual Studio, this is done by adding a dependency on
-`gtest.vcproj`).
-
-If you still have questions, take a look at how Google Test's own
-tests are built and use them as examples.
-
-# Basic Concepts #
-
-When using Google Test, you start by writing _assertions_, which are statements
-that check whether a condition is true. An assertion's result can be _success_,
-_nonfatal failure_, or _fatal failure_. If a fatal failure occurs, it aborts
-the current function; otherwise the program continues normally.
-
-_Tests_ use assertions to verify the tested code's behavior. If a test crashes
-or has a failed assertion, then it _fails_; otherwise it _succeeds_.
-
-A _test case_ contains one or many tests. You should group your tests into test
-cases that reflect the structure of the tested code. When multiple tests in a
-test case need to share common objects and subroutines, you can put them into a
-_test fixture_ class.
-
-A _test program_ can contain multiple test cases.
-
-We'll now explain how to write a test program, starting at the individual
-assertion level and building up to tests and test cases.
-
-# Assertions #
-
-Google Test assertions are macros that resemble function calls. You test a
-class or function by making assertions about its behavior. When an assertion
-fails, Google Test prints the assertion's source file and line number location,
-along with a failure message. You may also supply a custom failure message
-which will be appended to Google Test's message.
-
-The assertions come in pairs that test the same thing but have different
-effects on the current function. `ASSERT_*` versions generate fatal failures
-when they fail, and **abort the current function**. `EXPECT_*` versions generate
-nonfatal failures, which don't abort the current function. Usually `EXPECT_*`
-are preferred, as they allow more than one failures to be reported in a test.
-However, you should use `ASSERT_*` if it doesn't make sense to continue when
-the assertion in question fails.
-
-Since a failed `ASSERT_*` returns from the current function immediately,
-possibly skipping clean-up code that comes after it, it may cause a space leak.
-Depending on the nature of the leak, it may or may not be worth fixing - so
-keep this in mind if you get a heap checker error in addition to assertion
-errors.
-
-To provide a custom failure message, simply stream it into the macro using the
-`<<` operator, or a sequence of such operators. An example:
-```
-ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length";
-
-for (int i = 0; i < x.size(); ++i) {
-  EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i;
-}
-```
-
-Anything that can be streamed to an `ostream` can be streamed to an assertion
-macro--in particular, C strings and `string` objects. If a wide string
-(`wchar_t*`, `TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is
-streamed to an assertion, it will be translated to UTF-8 when printed.
-
-## Basic Assertions ##
-
-These assertions do basic true/false condition testing.
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_TRUE(`_condition_`)`;  | `EXPECT_TRUE(`_condition_`)`;   | _condition_ is true |
-| `ASSERT_FALSE(`_condition_`)`; | `EXPECT_FALSE(`_condition_`)`;  | _condition_ is false |
-
-Remember, when they fail, `ASSERT_*` yields a fatal failure and
-returns from the current function, while `EXPECT_*` yields a nonfatal
-failure, allowing the function to continue running. In either case, an
-assertion failure means its containing test fails.
-
-_Availability_: Linux, Windows, Mac.
-
-## Binary Comparison ##
-
-This section describes assertions that compare two values.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-|`ASSERT_EQ(`_expected_`, `_actual_`);`|`EXPECT_EQ(`_expected_`, `_actual_`);`| _expected_ `==` _actual_ |
-|`ASSERT_NE(`_val1_`, `_val2_`);`      |`EXPECT_NE(`_val1_`, `_val2_`);`      | _val1_ `!=` _val2_ |
-|`ASSERT_LT(`_val1_`, `_val2_`);`      |`EXPECT_LT(`_val1_`, `_val2_`);`      | _val1_ `<` _val2_ |
-|`ASSERT_LE(`_val1_`, `_val2_`);`      |`EXPECT_LE(`_val1_`, `_val2_`);`      | _val1_ `<=` _val2_ |
-|`ASSERT_GT(`_val1_`, `_val2_`);`      |`EXPECT_GT(`_val1_`, `_val2_`);`      | _val1_ `>` _val2_ |
-|`ASSERT_GE(`_val1_`, `_val2_`);`      |`EXPECT_GE(`_val1_`, `_val2_`);`      | _val1_ `>=` _val2_ |
-
-In the event of a failure, Google Test prints both _val1_ and _val2_
-. In `ASSERT_EQ*` and `EXPECT_EQ*` (and all other equality assertions
-we'll introduce later), you should put the expression you want to test
-in the position of _actual_, and put its expected value in _expected_,
-as Google Test's failure messages are optimized for this convention.
-
-Value arguments must be comparable by the assertion's comparison operator or
-you'll get a compiler error. Values must also support the `<<` operator for
-streaming to an `ostream`. All built-in types support this.
-
-These assertions can work with a user-defined type, but only if you define the
-corresponding comparison operator (e.g. `==`, `<`, etc).  If the corresponding
-operator is defined, prefer using the `ASSERT_*()` macros because they will
-print out not only the result of the comparison, but the two operands as well.
-
-Arguments are always evaluated exactly once. Therefore, it's OK for the
-arguments to have side effects. However, as with any ordinary C/C++ function,
-the arguments' evaluation order is undefined (i.e. the compiler is free to
-choose any order) and your code should not depend on any particular argument
-evaluation order.
-
-`ASSERT_EQ()` does pointer equality on pointers. If used on two C strings, it
-tests if they are in the same memory location, not if they have the same value.
-Therefore, if you want to compare C strings (e.g. `const char*`) by value, use
-`ASSERT_STREQ()` , which will be described later on. In particular, to assert
-that a C string is `NULL`, use `ASSERT_STREQ(NULL, c_string)` . However, to
-compare two `string` objects, you should use `ASSERT_EQ`.
-
-Macros in this section work with both narrow and wide string objects (`string`
-and `wstring`).
-
-_Availability_: Linux, Windows, Mac.
-
-## String Comparison ##
-
-The assertions in this group compare two **C strings**. If you want to compare
-two `string` objects, use `EXPECT_EQ`, `EXPECT_NE`, and etc instead.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_STREQ(`_expected\_str_`, `_actual\_str_`);`    | `EXPECT_STREQ(`_expected\_str_`, `_actual\_str_`);`     | the two C strings have the same content |
-| `ASSERT_STRNE(`_str1_`, `_str2_`);`    | `EXPECT_STRNE(`_str1_`, `_str2_`);`     | the two C strings have different content |
-| `ASSERT_STRCASEEQ(`_expected\_str_`, `_actual\_str_`);`| `EXPECT_STRCASEEQ(`_expected\_str_`, `_actual\_str_`);` | the two C strings have the same content, ignoring case |
-| `ASSERT_STRCASENE(`_str1_`, `_str2_`);`| `EXPECT_STRCASENE(`_str1_`, `_str2_`);` | the two C strings have different content, ignoring case |
-
-Note that "CASE" in an assertion name means that case is ignored.
-
-`*STREQ*` and `*STRNE*` also accept wide C strings (`wchar_t*`). If a
-comparison of two wide strings fails, their values will be printed as UTF-8
-narrow strings.
-
-A `NULL` pointer and an empty string are considered _different_.
-
-_Availability_: Linux, Windows, Mac.
-
-See also: For more string comparison tricks (substring, prefix, suffix, and
-regular expression matching, for example), see the [AdvancedGuide Advanced
-Google Test Guide].
-
-# Simple Tests #
-
-To create a test:
-  1. Use the `TEST()` macro to define and name a test function, These are ordinary C++ functions that don't return a value.
-  1. In this function, along with any valid C++ statements you want to include, use the various Google Test assertions to check values.
-  1. The test's result is determined by the assertions; if any assertion in the test fails (either fatally or non-fatally), or if the test crashes, the entire test fails. Otherwise, it succeeds.
-
-```
-TEST(test_case_name, test_name) {
- ... test body ...
-}
-```
-
-
-`TEST()` arguments go from general to specific. The _first_ argument is the
-name of the test case, and the _second_ argument is the test's name within the
-test case. Remember that a test case can contain any number of individual
-tests. A test's _full name_ consists of its containing test case and its
-individual name. Tests from different test cases can have the same individual
-name.
-
-For example, let's take a simple integer function:
-```
-int Factorial(int n); // Returns the factorial of n
-```
-
-A test case for this function might look like:
-```
-// Tests factorial of 0.
-TEST(FactorialTest, HandlesZeroInput) {
-  EXPECT_EQ(1, Factorial(0));
-}
-
-// Tests factorial of positive numbers.
-TEST(FactorialTest, HandlesPositiveInput) {
-  EXPECT_EQ(1, Factorial(1));
-  EXPECT_EQ(2, Factorial(2));
-  EXPECT_EQ(6, Factorial(3));
-  EXPECT_EQ(40320, Factorial(8));
-}
-```
-
-Google Test groups the test results by test cases, so logically-related tests
-should be in the same test case; in other words, the first argument to their
-`TEST()` should be the same. In the above example, we have two tests,
-`HandlesZeroInput` and `HandlesPositiveInput`, that belong to the same test
-case `FactorialTest`.
-
-_Availability_: Linux, Windows, Mac.
-
-# Test Fixtures: Using the Same Data Configuration for Multiple Tests #
-
-If you find yourself writing two or more tests that operate on similar data,
-you can use a _test fixture_. It allows you to reuse the same configuration of
-objects for several different tests.
-
-To create a fixture, just:
-  1. Derive a class from `::testing::Test` . Start its body with `protected:` or `public:` as we'll want to access fixture members from sub-classes.
-  1. Inside the class, declare any objects you plan to use.
-  1. If necessary, write a default constructor or `SetUp()` function to prepare the objects for each test. A common mistake is to spell `SetUp()` as `Setup()` with a small `u` - don't let that happen to you.
-  1. If necessary, write a destructor or `TearDown()` function to release any resources you allocated in `SetUp()` . To learn when you should use the constructor/destructor and when you should use `SetUp()/TearDown()`, read this [FAQ entry](V1_5_FAQ.md#should-i-use-the-constructordestructor-of-the-test-fixture-or-the-set-uptear-down-function).
-  1. If needed, define subroutines for your tests to share.
-
-When using a fixture, use `TEST_F()` instead of `TEST()` as it allows you to
-access objects and subroutines in the test fixture:
-```
-TEST_F(test_case_name, test_name) {
- ... test body ...
-}
-```
-
-Like `TEST()`, the first argument is the test case name, but for `TEST_F()`
-this must be the name of the test fixture class. You've probably guessed: `_F`
-is for fixture.
-
-Unfortunately, the C++ macro system does not allow us to create a single macro
-that can handle both types of tests. Using the wrong macro causes a compiler
-error.
-
-Also, you must first define a test fixture class before using it in a
-`TEST_F()`, or you'll get the compiler error "`virtual outside class
-declaration`".
-
-For each test defined with `TEST_F()`, Google Test will:
-  1. Create a _fresh_ test fixture at runtime
-  1. Immediately initialize it via `SetUp()` ,
-  1. Run the test
-  1. Clean up by calling `TearDown()`
-  1. Delete the test fixture.  Note that different tests in the same test case have different test fixture objects, and Google Test always deletes a test fixture before it creates the next one. Google Test does not reuse the same test fixture for multiple tests. Any changes one test makes to the fixture do not affect other tests.
-
-As an example, let's write tests for a FIFO queue class named `Queue`, which
-has the following interface:
-```
-template <typename E> // E is the element type.
-class Queue {
- public:
-  Queue();
-  void Enqueue(const E& element);
-  E* Dequeue(); // Returns NULL if the queue is empty.
-  size_t size() const;
-  ...
-};
-```
-
-First, define a fixture class. By convention, you should give it the name
-`FooTest` where `Foo` is the class being tested.
-```
-class QueueTest : public ::testing::Test {
- protected:
-  virtual void SetUp() {
-    q1_.Enqueue(1);
-    q2_.Enqueue(2);
-    q2_.Enqueue(3);
-  }
-
-  // virtual void TearDown() {}
-
-  Queue<int> q0_;
-  Queue<int> q1_;
-  Queue<int> q2_;
-};
-```
-
-In this case, `TearDown()` is not needed since we don't have to clean up after
-each test, other than what's already done by the destructor.
-
-Now we'll write tests using `TEST_F()` and this fixture.
-```
-TEST_F(QueueTest, IsEmptyInitially) {
-  EXPECT_EQ(0, q0_.size());
-}
-
-TEST_F(QueueTest, DequeueWorks) {
-  int* n = q0_.Dequeue();
-  EXPECT_EQ(NULL, n);
-
-  n = q1_.Dequeue();
-  ASSERT_TRUE(n != NULL);
-  EXPECT_EQ(1, *n);
-  EXPECT_EQ(0, q1_.size());
-  delete n;
-
-  n = q2_.Dequeue();
-  ASSERT_TRUE(n != NULL);
-  EXPECT_EQ(2, *n);
-  EXPECT_EQ(1, q2_.size());
-  delete n;
-}
-```
-
-The above uses both `ASSERT_*` and `EXPECT_*` assertions. The rule of thumb is
-to use `EXPECT_*` when you want the test to continue to reveal more errors
-after the assertion failure, and use `ASSERT_*` when continuing after failure
-doesn't make sense. For example, the second assertion in the `Dequeue` test is
-`ASSERT_TRUE(n != NULL)`, as we need to dereference the pointer `n` later,
-which would lead to a segfault when `n` is `NULL`.
-
-When these tests run, the following happens:
-  1. Google Test constructs a `QueueTest` object (let's call it `t1` ).
-  1. `t1.SetUp()` initializes `t1` .
-  1. The first test ( `IsEmptyInitially` ) runs on `t1` .
-  1. `t1.TearDown()` cleans up after the test finishes.
-  1. `t1` is destructed.
-  1. The above steps are repeated on another `QueueTest` object, this time running the `DequeueWorks` test.
-
-_Availability_: Linux, Windows, Mac.
-
-_Note_: Google Test automatically saves all _Google Test_ flags when a test
-object is constructed, and restores them when it is destructed.
-
-# Invoking the Tests #
-
-`TEST()` and `TEST_F()` implicitly register their tests with Google Test. So, unlike with many other C++ testing frameworks, you don't have to re-list all your defined tests in order to run them.
-
-After defining your tests, you can run them with `RUN_ALL_TESTS()` , which returns `0` if all the tests are successful, or `1` otherwise. Note that `RUN_ALL_TESTS()` runs _all tests_ in your link unit -- they can be from different test cases, or even different source files.
-
-When invoked, the `RUN_ALL_TESTS()` macro:
-  1. Saves the state of all  Google Test flags.
-  1. Creates a test fixture object for the first test.
-  1. Initializes it via `SetUp()`.
-  1. Runs the test on the fixture object.
-  1. Cleans up the fixture via `TearDown()`.
-  1. Deletes the fixture.
-  1. Restores the state of all Google Test flags.
-  1. Repeats the above steps for the next test, until all tests have run.
-
-In addition, if the text fixture's constructor generates a fatal failure in
-step 2, there is no point for step 3 - 5 and they are thus skipped. Similarly,
-if step 3 generates a fatal failure, step 4 will be skipped.
-
-_Important_: You must not ignore the return value of `RUN_ALL_TESTS()`, or `gcc`
-will give you a compiler error. The rationale for this design is that the
-automated testing service determines whether a test has passed based on its
-exit code, not on its stdout/stderr output; thus your `main()` function must
-return the value of `RUN_ALL_TESTS()`.
-
-Also, you should call `RUN_ALL_TESTS()` only **once**. Calling it more than once
-conflicts with some advanced Google Test features (e.g. thread-safe death
-tests) and thus is not supported.
-
-_Availability_: Linux, Windows, Mac.
-
-# Writing the main() Function #
-
-You can start from this boilerplate:
-```
-#include "this/package/foo.h"
-#include <gtest/gtest.h>
-
-namespace {
-
-// The fixture for testing class Foo.
-class FooTest : public ::testing::Test {
- protected:
-  // You can remove any or all of the following functions if its body
-  // is empty.
-
-  FooTest() {
-    // You can do set-up work for each test here.
-  }
-
-  virtual ~FooTest() {
-    // You can do clean-up work that doesn't throw exceptions here.
-  }
-
-  // If the constructor and destructor are not enough for setting up
-  // and cleaning up each test, you can define the following methods:
-
-  virtual void SetUp() {
-    // Code here will be called immediately after the constructor (right
-    // before each test).
-  }
-
-  virtual void TearDown() {
-    // Code here will be called immediately after each test (right
-    // before the destructor).
-  }
-
-  // Objects declared here can be used by all tests in the test case for Foo.
-};
-
-// Tests that the Foo::Bar() method does Abc.
-TEST_F(FooTest, MethodBarDoesAbc) {
-  const string input_filepath = "this/package/testdata/myinputfile.dat";
-  const string output_filepath = "this/package/testdata/myoutputfile.dat";
-  Foo f;
-  EXPECT_EQ(0, f.Bar(input_filepath, output_filepath));
-}
-
-// Tests that Foo does Xyz.
-TEST_F(FooTest, DoesXyz) {
-  // Exercises the Xyz feature of Foo.
-}
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
-```
-
-The `::testing::InitGoogleTest()` function parses the command line for Google
-Test flags, and removes all recognized flags. This allows the user to control a
-test program's behavior via various flags, which we'll cover in [AdvancedGuide](V1_5_AdvancedGuide.md).
-You must call this function before calling `RUN_ALL_TESTS()`, or the flags
-won't be properly initialized.
-
-On Windows, `InitGoogleTest()` also works with wide strings, so it can be used
-in programs compiled in `UNICODE` mode as well.
-
-But maybe you think that writing all those main() functions is too much work? We agree with you completely and that's why Google Test provides a basic implementation of main(). If it fits your needs, then just link your test with gtest\_main library and you are good to go.
-
-## Important note for Visual C++ users ##
-If you put your tests into a library and your `main()` function is in a different library or in your .exe file, those tests will not run. The reason is a [bug](https://connect.microsoft.com/feedback/viewfeedback.aspx?FeedbackID=244410&siteid=210) in Visual C++. When you define your tests, Google Test creates certain static objects to register them. These objects are not referenced from elsewhere but their constructors are still supposed to run. When Visual C++ linker sees that nothing in the library is referenced from other places it throws the library out. You have to reference your library with tests from your main program to keep the linker from discarding it. Here is how to do it. Somewhere in your library code declare a function:
-```
-__declspec(dllexport) int PullInMyLibrary() { return 0; }
-```
-If you put your tests in a static library (not DLL) then `__declspec(dllexport)` is not required. Now, in your main program, write a code that invokes that function:
-```
-int PullInMyLibrary();
-static int dummy = PullInMyLibrary();
-```
-This will keep your tests referenced and will make them register themselves at startup.
-
-In addition, if you define your tests in a static library, add `/OPT:NOREF` to your main program linker options. If you use MSVC++ IDE, go to your .exe project properties/Configuration Properties/Linker/Optimization and set References setting to `Keep Unreferenced Data (/OPT:NOREF)`. This will keep Visual C++ linker from discarding individual symbols generated by your tests from the final executable.
-
-There is one more pitfall, though. If you use Google Test as a static library (that's how it is defined in gtest.vcproj) your tests must also reside in a static library. If you have to have them in a DLL, you _must_ change Google Test to build into a DLL as well. Otherwise your tests will not run correctly or will not run at all. The general conclusion here is: make your life easier - do not write your tests in libraries!
-
-# Where to Go from Here #
-
-Congratulations! You've learned the Google Test basics. You can start writing
-and running Google Test tests, read some [samples](Samples.md), or continue with
-[AdvancedGuide](V1_5_AdvancedGuide.md), which describes many more useful Google Test features.
-
-# Known Limitations #
-
-Google Test is designed to be thread-safe.  The implementation is
-thread-safe on systems where the `pthreads` library is available.  It
-is currently _unsafe_ to use Google Test assertions from two threads
-concurrently on other systems (e.g. Windows).  In most tests this is
-not an issue as usually the assertions are done in the main thread. If
-you want to help, you can volunteer to implement the necessary
-synchronization primitives in `gtest-port.h` for your platform.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_PumpManual.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_PumpManual.md
deleted file mode 100644
index 15710789..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_PumpManual.md
+++ /dev/null
@@ -1,177 +0,0 @@
-
-
-<b>P</b>ump is <b>U</b>seful for <b>M</b>eta <b>P</b>rogramming.
-
-# The Problem #
-
-Template and macro libraries often need to define many classes,
-functions, or macros that vary only (or almost only) in the number of
-arguments they take. It's a lot of repetitive, mechanical, and
-error-prone work.
-
-Variadic templates and variadic macros can alleviate the problem.
-However, while both are being considered by the C++ committee, neither
-is in the standard yet or widely supported by compilers.  Thus they
-are often not a good choice, especially when your code needs to be
-portable. And their capabilities are still limited.
-
-As a result, authors of such libraries often have to write scripts to
-generate their implementation. However, our experience is that it's
-tedious to write such scripts, which tend to reflect the structure of
-the generated code poorly and are often hard to read and edit. For
-example, a small change needed in the generated code may require some
-non-intuitive, non-trivial changes in the script. This is especially
-painful when experimenting with the code.
-
-# Our Solution #
-
-Pump (for Pump is Useful for Meta Programming, Pretty Useful for Meta
-Programming, or Practical Utility for Meta Programming, whichever you
-prefer) is a simple meta-programming tool for C++. The idea is that a
-programmer writes a `foo.pump` file which contains C++ code plus meta
-code that manipulates the C++ code. The meta code can handle
-iterations over a range, nested iterations, local meta variable
-definitions, simple arithmetic, and conditional expressions. You can
-view it as a small Domain-Specific Language. The meta language is
-designed to be non-intrusive (s.t. it won't confuse Emacs' C++ mode,
-for example) and concise, making Pump code intuitive and easy to
-maintain.
-
-## Highlights ##
-
-  * The implementation is in a single Python script and thus ultra portable: no build or installation is needed and it works cross platforms.
-  * Pump tries to be smart with respect to [Google's style guide](http://code.google.com/p/google-styleguide/): it breaks long lines (easy to have when they are generated) at acceptable places to fit within 80 columns and indent the continuation lines correctly.
-  * The format is human-readable and more concise than XML.
-  * The format works relatively well with Emacs' C++ mode.
-
-## Examples ##
-
-The following Pump code (where meta keywords start with `$`, `[[` and `]]` are meta brackets, and `$$` starts a meta comment that ends with the line):
-
-```
-$var n = 3     $$ Defines a meta variable n.
-$range i 0..n  $$ Declares the range of meta iterator i (inclusive).
-$for i [[
-               $$ Meta loop.
-// Foo$i does blah for $i-ary predicates.
-$range j 1..i
-template <size_t N $for j [[, typename A$j]]>
-class Foo$i {
-$if i == 0 [[
-  blah a;
-]] $elif i <= 2 [[
-  blah b;
-]] $else [[
-  blah c;
-]]
-};
-
-]]
-```
-
-will be translated by the Pump compiler to:
-
-```
-// Foo0 does blah for 0-ary predicates.
-template <size_t N>
-class Foo0 {
-  blah a;
-};
-
-// Foo1 does blah for 1-ary predicates.
-template <size_t N, typename A1>
-class Foo1 {
-  blah b;
-};
-
-// Foo2 does blah for 2-ary predicates.
-template <size_t N, typename A1, typename A2>
-class Foo2 {
-  blah b;
-};
-
-// Foo3 does blah for 3-ary predicates.
-template <size_t N, typename A1, typename A2, typename A3>
-class Foo3 {
-  blah c;
-};
-```
-
-In another example,
-
-```
-$range i 1..n
-Func($for i + [[a$i]]);
-$$ The text between i and [[ is the separator between iterations.
-```
-
-will generate one of the following lines (without the comments), depending on the value of `n`:
-
-```
-Func();              // If n is 0.
-Func(a1);            // If n is 1.
-Func(a1 + a2);       // If n is 2.
-Func(a1 + a2 + a3);  // If n is 3.
-// And so on...
-```
-
-## Constructs ##
-
-We support the following meta programming constructs:
-
-| `$var id = exp` | Defines a named constant value. `$id` is valid util the end of the current meta lexical block. |
-|:----------------|:-----------------------------------------------------------------------------------------------|
-| $range id exp..exp | Sets the range of an iteration variable, which can be reused in multiple loops later.          |
-| $for id sep [[code ](.md)] | Iteration. The range of `id` must have been defined earlier. `$id` is valid in `code`.         |
-| `$($)`          | Generates a single `$` character.                                                              |
-| `$id`           | Value of the named constant or iteration variable.                                             |
-| `$(exp)`        | Value of the expression.                                                                       |
-| `$if exp [[ code ]] else_branch` | Conditional.                                                                                   |
-| `[[ code ]]`    | Meta lexical block.                                                                            |
-| `cpp_code`      | Raw C++ code.                                                                                  |
-| `$$ comment`    | Meta comment.                                                                                  |
-
-**Note:** To give the user some freedom in formatting the Pump source
-code, Pump ignores a new-line character if it's right after `$for foo`
-or next to `[[` or `]]`. Without this rule you'll often be forced to write
-very long lines to get the desired output. Therefore sometimes you may
-need to insert an extra new-line in such places for a new-line to show
-up in your output.
-
-## Grammar ##
-
-```
-code ::= atomic_code*
-atomic_code ::= $var id = exp
-    | $var id = [[ code ]]
-    | $range id exp..exp
-    | $for id sep [[ code ]]
-    | $($)
-    | $id
-    | $(exp)
-    | $if exp [[ code ]] else_branch
-    | [[ code ]]
-    | cpp_code
-sep ::= cpp_code | empty_string
-else_branch ::= $else [[ code ]]
-    | $elif exp [[ code ]] else_branch
-    | empty_string
-exp ::= simple_expression_in_Python_syntax
-```
-
-## Code ##
-
-You can find the source code of Pump in [scripts/pump.py](http://code.google.com/p/googletest/source/browse/trunk/scripts/pump.py). It is still
-very unpolished and lacks automated tests, although it has been
-successfully used many times. If you find a chance to use it in your
-project, please let us know what you think!  We also welcome help on
-improving Pump.
-
-## Real Examples ##
-
-You can find real-world applications of Pump in [Google Test](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgoogletest\.googlecode\.com) and [Google Mock](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgooglemock\.googlecode\.com).  The source file `foo.h.pump` generates `foo.h`.
-
-## Tips ##
-
-  * If a meta variable is followed by a letter or digit, you can separate them using `[[]]`, which inserts an empty string. For example `Foo$j[[]]Helper` generate `Foo1Helper` when `j` is 1.
-  * To avoid extra-long Pump source lines, you can break a line anywhere you want by inserting `[[]]` followed by a new line. Since any new-line character next to `[[` or `]]` is ignored, the generated code won't contain this new line.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_XcodeGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_XcodeGuide.md
deleted file mode 100644
index bf24bf51..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_5_XcodeGuide.md
+++ /dev/null
@@ -1,93 +0,0 @@
-
-
-This guide will explain how to use the Google Testing Framework in your Xcode projects on Mac OS X. This tutorial begins by quickly explaining what to do for experienced users. After the quick start, the guide goes provides additional explanation about each step.
-
-# Quick Start #
-
-Here is the quick guide for using Google Test in your Xcode project.
-
-  1. Download the source from the [website](http://code.google.com/p/googletest) using this command: `svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only`
-  1. Open up the `gtest.xcodeproj` in the `googletest-read-only/xcode/` directory and build the gtest.framework.
-  1. Create a new "Shell Tool" target in your Xcode project called something like "UnitTests"
-  1. Add the gtest.framework to your project and add it to the "Link Binary with Libraries" build phase of "UnitTests"
-  1. Add your unit test source code to the "Compile Sources" build phase of "UnitTests"
-  1. Edit the "UnitTests" executable and add an environment variable named "DYLD\_FRAMEWORK\_PATH" with a value equal to the path to the framework containing the gtest.framework relative to the compiled executable.
-  1. Build and Go
-
-The following sections further explain each of the steps listed above in depth, describing in more detail how to complete it including some variations.
-
-# Get the Source #
-
-Currently, the gtest.framework discussed here isn't available in a tagged release of Google Test, it is only available in the trunk. As explained at the Google Test [site](http://code.google.com/p/googletest/source/checkout">svn), you can get the code from anonymous SVN with this command:
-
-```
-svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only
-```
-
-Alternatively, if you are working with Subversion in your own code base, you can add Google Test as an external dependency to your own Subversion repository. By following this approach, everyone that checks out your svn repository will also receive a copy of Google Test (a specific version, if you wish) without having to check it out explicitly. This makes the set up of your project simpler and reduces the copied code in the repository.
-
-To use `svn:externals`, decide where you would like to have the external source reside. You might choose to put the external source inside the trunk, because you want it to be part of the branch when you make a release. However, keeping it outside the trunk in a version-tagged directory called something like `third-party/googletest/1.0.1`, is another option. Once the location is established, use `svn propedit svn:externals _directory_` to set the svn:externals property on a directory in your repository. This directory won't contain the code, but be its versioned parent directory.
-
-The command `svn propedit` will bring up your Subversion editor, making editing the long, (potentially multi-line) property simpler. This same method can be used to check out a tagged branch, by using the appropriate URL (e.g. `http://googletest.googlecode.com/svn/tags/release-1.0.1`). Additionally, the svn:externals property allows the specification of a particular revision of the trunk with the `-r_##_` option (e.g. `externals/src/googletest -r60 http://googletest.googlecode.com/svn/trunk`).
-
-Here is an example of using the svn:externals properties on a trunk (read via `svn propget`) of a project. This value checks out a copy of Google Test into the `trunk/externals/src/googletest/` directory.
-
-```
-[Computer:svn] user$ svn propget svn:externals trunk
-externals/src/googletest http://googletest.googlecode.com/svn/trunk
-```
-
-# Add the Framework to Your Project #
-
-The next step is to build and add the gtest.framework to your own project. This guide describes two common ways below.
-
-  * **Option 1** --- The simplest way to add Google Test to your own project, is to open gtest.xcodeproj (found in the xcode/ directory of the Google Test trunk) and build the framework manually. Then, add the built framework into your project using the "Add->Existing Framework..." from the context menu or "Project->Add..." from the main menu. The gtest.framework is relocatable and contains the headers and object code that you'll need to make tests. This method requires rebuilding every time you upgrade Google Test in your project.
-  * **Option 2** --- If you are going to be living off the trunk of Google Test, incorporating its latest features into your unit tests (or are a Google Test developer yourself). You'll want to rebuild the framework every time the source updates. to do this, you'll need to add the gtest.xcodeproj file, not the framework itself, to your own Xcode project. Then, from the build products that are revealed by the project's disclosure triangle, you can find the gtest.framework, which can be added to your targets (discussed below).
-
-# Make a Test Target #
-
-To start writing tests, make a new "Shell Tool" target. This target template is available under BSD, Cocoa, or Carbon. Add your unit test source code to the "Compile Sources" build phase of the target.
-
-Next, you'll want to add gtest.framework in two different ways, depending upon which option you chose above.
-
-  * **Option 1** --- During compilation, Xcode will need to know that you are linking against the gtest.framework. Add the gtest.framework to the "Link Binary with Libraries" build phase of your test target. This will include the Google Test headers in your header search path, and will tell the linker where to find the library.
-  * **Option 2** --- If your working out of the trunk, you'll also want to add gtest.framework to your "Link Binary with Libraries" build phase of your test target. In addition, you'll  want to add the gtest.framework as a dependency to your unit test target. This way, Xcode will make sure that gtest.framework is up to date, every time your build your target. Finally, if you don't share build directories with Google Test, you'll have to copy the gtest.framework into your own build products directory using a "Run Script" build phase.
-
-# Set Up the Executable Run Environment #
-
-Since the unit test executable is a shell tool, it doesn't have a bundle with a `Contents/Frameworks` directory, in which to place gtest.framework. Instead, the dynamic linker must be told at runtime to search for the framework in another location. This can be accomplished by setting the "DYLD\_FRAMEWORK\_PATH" environment variable in the "Edit Active Executable ..." Arguments tab, under "Variables to be set in the environment:". The path for this value is the path (relative or absolute) of the directory containing the gtest.framework.
-
-If you haven't set up the DYLD\_FRAMEWORK\_PATH, correctly, you might get a message like this:
-
-```
-[Session started at 2008-08-15 06:23:57 -0600.]
-  dyld: Library not loaded: @loader_path/../Frameworks/gtest.framework/Versions/A/gtest
-    Referenced from: /Users/username/Documents/Sandbox/gtestSample/build/Debug/WidgetFrameworkTest
-    Reason: image not found
-```
-
-To correct this problem, got to the directory containing the executable named in "Referenced from:" value in the error message above. Then, with the terminal in this location, find the relative path to the directory containing the gtest.framework. That is the value you'll need to set as the DYLD\_FRAMEWORK\_PATH.
-
-# Build and Go #
-
-Now, when you click "Build and Go", the test will be executed. Dumping out something like this:
-
-```
-[Session started at 2008-08-06 06:36:13 -0600.]
-[==========] Running 2 tests from 1 test case.
-[----------] Global test environment set-up.
-[----------] 2 tests from WidgetInitializerTest
-[ RUN      ] WidgetInitializerTest.TestConstructor
-[       OK ] WidgetInitializerTest.TestConstructor
-[ RUN      ] WidgetInitializerTest.TestConversion
-[       OK ] WidgetInitializerTest.TestConversion
-[----------] Global test environment tear-down
-[==========] 2 tests from 1 test case ran.
-[  PASSED  ] 2 tests.
-
-The Debugger has exited with status 0.  
-```
-
-# Summary #
-
-Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_AdvancedGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_AdvancedGuide.md
deleted file mode 100644
index 78864b16..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_AdvancedGuide.md
+++ /dev/null
@@ -1,2178 +0,0 @@
-
-
-Now that you have read [Primer](V1_6_Primer.md) and learned how to write tests
-using Google Test, it's time to learn some new tricks. This document
-will show you more assertions as well as how to construct complex
-failure messages, propagate fatal failures, reuse and speed up your
-test fixtures, and use various flags with your tests.
-
-# More Assertions #
-
-This section covers some less frequently used, but still significant,
-assertions.
-
-## Explicit Success and Failure ##
-
-These three assertions do not actually test a value or expression. Instead,
-they generate a success or failure directly. Like the macros that actually
-perform a test, you may stream a custom failure message into the them.
-
-| `SUCCEED();` |
-|:-------------|
-
-Generates a success. This does NOT make the overall test succeed. A test is
-considered successful only if none of its assertions fail during its execution.
-
-Note: `SUCCEED()` is purely documentary and currently doesn't generate any
-user-visible output. However, we may add `SUCCEED()` messages to Google Test's
-output in the future.
-
-| `FAIL();`  | `ADD_FAILURE();` | `ADD_FAILURE_AT("`_file\_path_`", `_line\_number_`);` |
-|:-----------|:-----------------|:------------------------------------------------------|
-
-`FAIL()` generates a fatal failure, while `ADD_FAILURE()` and `ADD_FAILURE_AT()` generate a nonfatal
-failure. These are useful when control flow, rather than a Boolean expression,
-deteremines the test's success or failure. For example, you might want to write
-something like:
-
-```
-switch(expression) {
-  case 1: ... some checks ...
-  case 2: ... some other checks
-  ...
-  default: FAIL() << "We shouldn't get here.";
-}
-```
-
-_Availability_: Linux, Windows, Mac.
-
-## Exception Assertions ##
-
-These are for verifying that a piece of code throws (or does not
-throw) an exception of the given type:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_THROW(`_statement_, _exception\_type_`);`  | `EXPECT_THROW(`_statement_, _exception\_type_`);`  | _statement_ throws an exception of the given type  |
-| `ASSERT_ANY_THROW(`_statement_`);`                | `EXPECT_ANY_THROW(`_statement_`);`                | _statement_ throws an exception of any type        |
-| `ASSERT_NO_THROW(`_statement_`);`                 | `EXPECT_NO_THROW(`_statement_`);`                 | _statement_ doesn't throw any exception            |
-
-Examples:
-
-```
-ASSERT_THROW(Foo(5), bar_exception);
-
-EXPECT_NO_THROW({
-  int n = 5;
-  Bar(&n);
-});
-```
-
-_Availability_: Linux, Windows, Mac; since version 1.1.0.
-
-## Predicate Assertions for Better Error Messages ##
-
-Even though Google Test has a rich set of assertions, they can never be
-complete, as it's impossible (nor a good idea) to anticipate all the scenarios
-a user might run into. Therefore, sometimes a user has to use `EXPECT_TRUE()`
-to check a complex expression, for lack of a better macro. This has the problem
-of not showing you the values of the parts of the expression, making it hard to
-understand what went wrong. As a workaround, some users choose to construct the
-failure message by themselves, streaming it into `EXPECT_TRUE()`. However, this
-is awkward especially when the expression has side-effects or is expensive to
-evaluate.
-
-Google Test gives you three different options to solve this problem:
-
-### Using an Existing Boolean Function ###
-
-If you already have a function or a functor that returns `bool` (or a type
-that can be implicitly converted to `bool`), you can use it in a _predicate
-assertion_ to get the function arguments printed for free:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_PRED1(`_pred1, val1_`);`       | `EXPECT_PRED1(`_pred1, val1_`);` | _pred1(val1)_ returns true |
-| `ASSERT_PRED2(`_pred2, val1, val2_`);` | `EXPECT_PRED2(`_pred2, val1, val2_`);` |  _pred2(val1, val2)_ returns true |
-|  ...                | ...                    | ...          |
-
-In the above, _predn_ is an _n_-ary predicate function or functor, where
-_val1_, _val2_, ..., and _valn_ are its arguments. The assertion succeeds
-if the predicate returns `true` when applied to the given arguments, and fails
-otherwise. When the assertion fails, it prints the value of each argument. In
-either case, the arguments are evaluated exactly once.
-
-Here's an example. Given
-
-```
-// Returns true iff m and n have no common divisors except 1.
-bool MutuallyPrime(int m, int n) { ... }
-const int a = 3;
-const int b = 4;
-const int c = 10;
-```
-
-the assertion `EXPECT_PRED2(MutuallyPrime, a, b);` will succeed, while the
-assertion `EXPECT_PRED2(MutuallyPrime, b, c);` will fail with the message
-
-<pre>
-!MutuallyPrime(b, c) is false, where<br>
-b is 4<br>
-c is 10<br>
-</pre>
-
-**Notes:**
-
-  1. If you see a compiler error "no matching function to call" when using `ASSERT_PRED*` or `EXPECT_PRED*`, please see [this](v1_6_FAQ.md#ithe-compiler-complains-about-undefined-references-to-some-static-const-member-variables-but-i-did-define-them-in-the-class-body-whats-wrong) for how to resolve it.
-  1. Currently we only provide predicate assertions of arity <= 5. If you need a higher-arity assertion, let us know.
-
-_Availability_: Linux, Windows, Mac
-
-### Using a Function That Returns an AssertionResult ###
-
-While `EXPECT_PRED*()` and friends are handy for a quick job, the
-syntax is not satisfactory: you have to use different macros for
-different arities, and it feels more like Lisp than C++.  The
-`::testing::AssertionResult` class solves this problem.
-
-An `AssertionResult` object represents the result of an assertion
-(whether it's a success or a failure, and an associated message).  You
-can create an `AssertionResult` using one of these factory
-functions:
-
-```
-namespace testing {
-
-// Returns an AssertionResult object to indicate that an assertion has
-// succeeded.
-AssertionResult AssertionSuccess();
-
-// Returns an AssertionResult object to indicate that an assertion has
-// failed.
-AssertionResult AssertionFailure();
-
-}
-```
-
-You can then use the `<<` operator to stream messages to the
-`AssertionResult` object.
-
-To provide more readable messages in Boolean assertions
-(e.g. `EXPECT_TRUE()`), write a predicate function that returns
-`AssertionResult` instead of `bool`. For example, if you define
-`IsEven()` as:
-
-```
-::testing::AssertionResult IsEven(int n) {
-  if ((n % 2) == 0)
-    return ::testing::AssertionSuccess();
-  else
-    return ::testing::AssertionFailure() << n << " is odd";
-}
-```
-
-instead of:
-
-```
-bool IsEven(int n) {
-  return (n % 2) == 0;
-}
-```
-
-the failed assertion `EXPECT_TRUE(IsEven(Fib(4)))` will print:
-
-<pre>
-Value of: !IsEven(Fib(4))<br>
-Actual: false (*3 is odd*)<br>
-Expected: true<br>
-</pre>
-
-instead of a more opaque
-
-<pre>
-Value of: !IsEven(Fib(4))<br>
-Actual: false<br>
-Expected: true<br>
-</pre>
-
-If you want informative messages in `EXPECT_FALSE` and `ASSERT_FALSE`
-as well, and are fine with making the predicate slower in the success
-case, you can supply a success message:
-
-```
-::testing::AssertionResult IsEven(int n) {
-  if ((n % 2) == 0)
-    return ::testing::AssertionSuccess() << n << " is even";
-  else
-    return ::testing::AssertionFailure() << n << " is odd";
-}
-```
-
-Then the statement `EXPECT_FALSE(IsEven(Fib(6)))` will print
-
-<pre>
-Value of: !IsEven(Fib(6))<br>
-Actual: true (8 is even)<br>
-Expected: false<br>
-</pre>
-
-_Availability_: Linux, Windows, Mac; since version 1.4.1.
-
-### Using a Predicate-Formatter ###
-
-If you find the default message generated by `(ASSERT|EXPECT)_PRED*` and
-`(ASSERT|EXPECT)_(TRUE|FALSE)` unsatisfactory, or some arguments to your
-predicate do not support streaming to `ostream`, you can instead use the
-following _predicate-formatter assertions_ to _fully_ customize how the
-message is formatted:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_PRED_FORMAT1(`_pred\_format1, val1_`);`        | `EXPECT_PRED_FORMAT1(`_pred\_format1, val1_`); | _pred\_format1(val1)_ is successful |
-| `ASSERT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | `EXPECT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | _pred\_format2(val1, val2)_ is successful |
-| `...`               | `...`                  | `...`        |
-
-The difference between this and the previous two groups of macros is that instead of
-a predicate, `(ASSERT|EXPECT)_PRED_FORMAT*` take a _predicate-formatter_
-(_pred\_formatn_), which is a function or functor with the signature:
-
-`::testing::AssertionResult PredicateFormattern(const char* `_expr1_`, const char* `_expr2_`, ... const char* `_exprn_`, T1 `_val1_`, T2 `_val2_`, ... Tn `_valn_`);`
-
-where _val1_, _val2_, ..., and _valn_ are the values of the predicate
-arguments, and _expr1_, _expr2_, ..., and _exprn_ are the corresponding
-expressions as they appear in the source code. The types `T1`, `T2`, ..., and
-`Tn` can be either value types or reference types. For example, if an
-argument has type `Foo`, you can declare it as either `Foo` or `const Foo&`,
-whichever is appropriate.
-
-A predicate-formatter returns a `::testing::AssertionResult` object to indicate
-whether the assertion has succeeded or not. The only way to create such an
-object is to call one of these factory functions:
-
-As an example, let's improve the failure message in the previous example, which uses `EXPECT_PRED2()`:
-
-```
-// Returns the smallest prime common divisor of m and n,
-// or 1 when m and n are mutually prime.
-int SmallestPrimeCommonDivisor(int m, int n) { ... }
-
-// A predicate-formatter for asserting that two integers are mutually prime.
-::testing::AssertionResult AssertMutuallyPrime(const char* m_expr,
-                                               const char* n_expr,
-                                               int m,
-                                               int n) {
-  if (MutuallyPrime(m, n))
-    return ::testing::AssertionSuccess();
-
-  return ::testing::AssertionFailure()
-      << m_expr << " and " << n_expr << " (" << m << " and " << n
-      << ") are not mutually prime, " << "as they have a common divisor "
-      << SmallestPrimeCommonDivisor(m, n);
-}
-```
-
-With this predicate-formatter, we can use
-
-```
-EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c);
-```
-
-to generate the message
-
-<pre>
-b and c (4 and 10) are not mutually prime, as they have a common divisor 2.<br>
-</pre>
-
-As you may have realized, many of the assertions we introduced earlier are
-special cases of `(EXPECT|ASSERT)_PRED_FORMAT*`. In fact, most of them are
-indeed defined using `(EXPECT|ASSERT)_PRED_FORMAT*`.
-
-_Availability_: Linux, Windows, Mac.
-
-
-## Floating-Point Comparison ##
-
-Comparing floating-point numbers is tricky. Due to round-off errors, it is
-very unlikely that two floating-points will match exactly. Therefore,
-`ASSERT_EQ` 's naive comparison usually doesn't work. And since floating-points
-can have a wide value range, no single fixed error bound works. It's better to
-compare by a fixed relative error bound, except for values close to 0 due to
-the loss of precision there.
-
-In general, for floating-point comparison to make sense, the user needs to
-carefully choose the error bound. If they don't want or care to, comparing in
-terms of Units in the Last Place (ULPs) is a good default, and Google Test
-provides assertions to do this. Full details about ULPs are quite long; if you
-want to learn more, see
-[this article on float comparison](http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm).
-
-### Floating-Point Macros ###
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_FLOAT_EQ(`_expected, actual_`);`  | `EXPECT_FLOAT_EQ(`_expected, actual_`);` | the two `float` values are almost equal |
-| `ASSERT_DOUBLE_EQ(`_expected, actual_`);` | `EXPECT_DOUBLE_EQ(`_expected, actual_`);` | the two `double` values are almost equal |
-
-By "almost equal", we mean the two values are within 4 ULP's from each
-other.
-
-The following assertions allow you to choose the acceptable error bound:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_NEAR(`_val1, val2, abs\_error_`);` | `EXPECT_NEAR`_(val1, val2, abs\_error_`);` | the difference between _val1_ and _val2_ doesn't exceed the given absolute error |
-
-_Availability_: Linux, Windows, Mac.
-
-### Floating-Point Predicate-Format Functions ###
-
-Some floating-point operations are useful, but not that often used. In order
-to avoid an explosion of new macros, we provide them as predicate-format
-functions that can be used in predicate assertion macros (e.g.
-`EXPECT_PRED_FORMAT2`, etc).
-
-```
-EXPECT_PRED_FORMAT2(::testing::FloatLE, val1, val2);
-EXPECT_PRED_FORMAT2(::testing::DoubleLE, val1, val2);
-```
-
-Verifies that _val1_ is less than, or almost equal to, _val2_. You can
-replace `EXPECT_PRED_FORMAT2` in the above table with `ASSERT_PRED_FORMAT2`.
-
-_Availability_: Linux, Windows, Mac.
-
-## Windows HRESULT assertions ##
-
-These assertions test for `HRESULT` success or failure.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_HRESULT_SUCCEEDED(`_expression_`);` | `EXPECT_HRESULT_SUCCEEDED(`_expression_`);` | _expression_ is a success `HRESULT` |
-| `ASSERT_HRESULT_FAILED(`_expression_`);`    | `EXPECT_HRESULT_FAILED(`_expression_`);`    | _expression_ is a failure `HRESULT` |
-
-The generated output contains the human-readable error message
-associated with the `HRESULT` code returned by _expression_.
-
-You might use them like this:
-
-```
-CComPtr shell;
-ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application"));
-CComVariant empty;
-ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty));
-```
-
-_Availability_: Windows.
-
-## Type Assertions ##
-
-You can call the function
-```
-::testing::StaticAssertTypeEq<T1, T2>();
-```
-to assert that types `T1` and `T2` are the same.  The function does
-nothing if the assertion is satisfied.  If the types are different,
-the function call will fail to compile, and the compiler error message
-will likely (depending on the compiler) show you the actual values of
-`T1` and `T2`.  This is mainly useful inside template code.
-
-_Caveat:_ When used inside a member function of a class template or a
-function template, `StaticAssertTypeEq<T1, T2>()` is effective _only if_
-the function is instantiated.  For example, given:
-```
-template <typename T> class Foo {
- public:
-  void Bar() { ::testing::StaticAssertTypeEq<int, T>(); }
-};
-```
-the code:
-```
-void Test1() { Foo<bool> foo; }
-```
-will _not_ generate a compiler error, as `Foo<bool>::Bar()` is never
-actually instantiated.  Instead, you need:
-```
-void Test2() { Foo<bool> foo; foo.Bar(); }
-```
-to cause a compiler error.
-
-_Availability:_ Linux, Windows, Mac; since version 1.3.0.
-
-## Assertion Placement ##
-
-You can use assertions in any C++ function. In particular, it doesn't
-have to be a method of the test fixture class. The one constraint is
-that assertions that generate a fatal failure (`FAIL*` and `ASSERT_*`)
-can only be used in void-returning functions. This is a consequence of
-Google Test not using exceptions. By placing it in a non-void function
-you'll get a confusing compile error like
-`"error: void value not ignored as it ought to be"`.
-
-If you need to use assertions in a function that returns non-void, one option
-is to make the function return the value in an out parameter instead. For
-example, you can rewrite `T2 Foo(T1 x)` to `void Foo(T1 x, T2* result)`. You
-need to make sure that `*result` contains some sensible value even when the
-function returns prematurely. As the function now returns `void`, you can use
-any assertion inside of it.
-
-If changing the function's type is not an option, you should just use
-assertions that generate non-fatal failures, such as `ADD_FAILURE*` and
-`EXPECT_*`.
-
-_Note_: Constructors and destructors are not considered void-returning
-functions, according to the C++ language specification, and so you may not use
-fatal assertions in them. You'll get a compilation error if you try. A simple
-workaround is to transfer the entire body of the constructor or destructor to a
-private void-returning method. However, you should be aware that a fatal
-assertion failure in a constructor does not terminate the current test, as your
-intuition might suggest; it merely returns from the constructor early, possibly
-leaving your object in a partially-constructed state. Likewise, a fatal
-assertion failure in a destructor may leave your object in a
-partially-destructed state. Use assertions carefully in these situations!
-
-# Teaching Google Test How to Print Your Values #
-
-When a test assertion such as `EXPECT_EQ` fails, Google Test prints the
-argument values to help you debug.  It does this using a
-user-extensible value printer.
-
-This printer knows how to print built-in C++ types, native arrays, STL
-containers, and any type that supports the `<<` operator.  For other
-types, it prints the raw bytes in the value and hopes that you the
-user can figure it out.
-
-As mentioned earlier, the printer is _extensible_.  That means
-you can teach it to do a better job at printing your particular type
-than to dump the bytes.  To do that, define `<<` for your type:
-
-```
-#include <iostream>
-
-namespace foo {
-
-class Bar { ... };  // We want Google Test to be able to print instances of this.
-
-// It's important that the << operator is defined in the SAME
-// namespace that defines Bar.  C++'s look-up rules rely on that.
-::std::ostream& operator<<(::std::ostream& os, const Bar& bar) {
-  return os << bar.DebugString();  // whatever needed to print bar to os
-}
-
-}  // namespace foo
-```
-
-Sometimes, this might not be an option: your team may consider it bad
-style to have a `<<` operator for `Bar`, or `Bar` may already have a
-`<<` operator that doesn't do what you want (and you cannot change
-it).  If so, you can instead define a `PrintTo()` function like this:
-
-```
-#include <iostream>
-
-namespace foo {
-
-class Bar { ... };
-
-// It's important that PrintTo() is defined in the SAME
-// namespace that defines Bar.  C++'s look-up rules rely on that.
-void PrintTo(const Bar& bar, ::std::ostream* os) {
-  *os << bar.DebugString();  // whatever needed to print bar to os
-}
-
-}  // namespace foo
-```
-
-If you have defined both `<<` and `PrintTo()`, the latter will be used
-when Google Test is concerned.  This allows you to customize how the value
-appears in Google Test's output without affecting code that relies on the
-behavior of its `<<` operator.
-
-If you want to print a value `x` using Google Test's value printer
-yourself, just call `::testing::PrintToString(`_x_`)`, which
-returns an `std::string`:
-
-```
-vector<pair<Bar, int> > bar_ints = GetBarIntVector();
-
-EXPECT_TRUE(IsCorrectBarIntVector(bar_ints))
-    << "bar_ints = " << ::testing::PrintToString(bar_ints);
-```
-
-# Death Tests #
-
-In many applications, there are assertions that can cause application failure
-if a condition is not met. These sanity checks, which ensure that the program
-is in a known good state, are there to fail at the earliest possible time after
-some program state is corrupted. If the assertion checks the wrong condition,
-then the program may proceed in an erroneous state, which could lead to memory
-corruption, security holes, or worse. Hence it is vitally important to test
-that such assertion statements work as expected.
-
-Since these precondition checks cause the processes to die, we call such tests
-_death tests_. More generally, any test that checks that a program terminates
-(except by throwing an exception) in an expected fashion is also a death test.
-
-Note that if a piece of code throws an exception, we don't consider it "death"
-for the purpose of death tests, as the caller of the code could catch the exception
-and avoid the crash. If you want to verify exceptions thrown by your code,
-see [Exception Assertions](#exception-assertions).
-
-If you want to test `EXPECT_*()/ASSERT_*()` failures in your test code, see [Catching Failures](#catching-failures).
-
-## How to Write a Death Test ##
-
-Google Test has the following macros to support death tests:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_DEATH(`_statement, regex_`); | `EXPECT_DEATH(`_statement, regex_`); | _statement_ crashes with the given error |
-| `ASSERT_DEATH_IF_SUPPORTED(`_statement, regex_`); | `EXPECT_DEATH_IF_SUPPORTED(`_statement, regex_`); | if death tests are supported, verifies that _statement_ crashes with the given error; otherwise verifies nothing |
-| `ASSERT_EXIT(`_statement, predicate, regex_`); | `EXPECT_EXIT(`_statement, predicate, regex_`); |_statement_ exits with the given error and its exit code matches _predicate_ |
-
-where _statement_ is a statement that is expected to cause the process to
-die, _predicate_ is a function or function object that evaluates an integer
-exit status, and _regex_ is a regular expression that the stderr output of
-_statement_ is expected to match. Note that _statement_ can be _any valid
-statement_ (including _compound statement_) and doesn't have to be an
-expression.
-
-As usual, the `ASSERT` variants abort the current test function, while the
-`EXPECT` variants do not.
-
-**Note:** We use the word "crash" here to mean that the process
-terminates with a _non-zero_ exit status code.  There are two
-possibilities: either the process has called `exit()` or `_exit()`
-with a non-zero value, or it may be killed by a signal.
-
-This means that if _statement_ terminates the process with a 0 exit
-code, it is _not_ considered a crash by `EXPECT_DEATH`.  Use
-`EXPECT_EXIT` instead if this is the case, or if you want to restrict
-the exit code more precisely.
-
-A predicate here must accept an `int` and return a `bool`. The death test
-succeeds only if the predicate returns `true`. Google Test defines a few
-predicates that handle the most common cases:
-
-```
-::testing::ExitedWithCode(exit_code)
-```
-
-This expression is `true` if the program exited normally with the given exit
-code.
-
-```
-::testing::KilledBySignal(signal_number)  // Not available on Windows.
-```
-
-This expression is `true` if the program was killed by the given signal.
-
-The `*_DEATH` macros are convenient wrappers for `*_EXIT` that use a predicate
-that verifies the process' exit code is non-zero.
-
-Note that a death test only cares about three things:
-
-  1. does _statement_ abort or exit the process?
-  1. (in the case of `ASSERT_EXIT` and `EXPECT_EXIT`) does the exit status satisfy _predicate_?  Or (in the case of `ASSERT_DEATH` and `EXPECT_DEATH`) is the exit status non-zero?  And
-  1. does the stderr output match _regex_?
-
-In particular, if _statement_ generates an `ASSERT_*` or `EXPECT_*` failure, it will **not** cause the death test to fail, as Google Test assertions don't abort the process.
-
-To write a death test, simply use one of the above macros inside your test
-function. For example,
-
-```
-TEST(My*DeathTest*, Foo) {
-  // This death test uses a compound statement.
-  ASSERT_DEATH({ int n = 5; Foo(&n); }, "Error on line .* of Foo()");
-}
-TEST(MyDeathTest, NormalExit) {
-  EXPECT_EXIT(NormalExit(), ::testing::ExitedWithCode(0), "Success");
-}
-TEST(MyDeathTest, KillMyself) {
-  EXPECT_EXIT(KillMyself(), ::testing::KilledBySignal(SIGKILL), "Sending myself unblockable signal");
-}
-```
-
-verifies that:
-
-  * calling `Foo(5)` causes the process to die with the given error message,
-  * calling `NormalExit()` causes the process to print `"Success"` to stderr and exit with exit code 0, and
-  * calling `KillMyself()` kills the process with signal `SIGKILL`.
-
-The test function body may contain other assertions and statements as well, if
-necessary.
-
-_Important:_ We strongly recommend you to follow the convention of naming your
-test case (not test) `*DeathTest` when it contains a death test, as
-demonstrated in the above example. The `Death Tests And Threads` section below
-explains why.
-
-If a test fixture class is shared by normal tests and death tests, you
-can use typedef to introduce an alias for the fixture class and avoid
-duplicating its code:
-```
-class FooTest : public ::testing::Test { ... };
-
-typedef FooTest FooDeathTest;
-
-TEST_F(FooTest, DoesThis) {
-  // normal test
-}
-
-TEST_F(FooDeathTest, DoesThat) {
-  // death test
-}
-```
-
-_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Cygwin, and Mac (the latter three are supported since v1.3.0).  `(ASSERT|EXPECT)_DEATH_IF_SUPPORTED` are new in v1.4.0.
-
-## Regular Expression Syntax ##
-
-On POSIX systems (e.g. Linux, Cygwin, and Mac), Google Test uses the
-[POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
-syntax in death tests. To learn about this syntax, you may want to read this [Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
-
-On Windows, Google Test uses its own simple regular expression
-implementation. It lacks many features you can find in POSIX extended
-regular expressions.  For example, we don't support union (`"x|y"`),
-grouping (`"(xy)"`), brackets (`"[xy]"`), and repetition count
-(`"x{5,7}"`), among others. Below is what we do support (`A` denotes a
-literal character, period (`.`), or a single `\\` escape sequence; `x`
-and `y` denote regular expressions.):
-
-| `c` | matches any literal character `c` |
-|:----|:----------------------------------|
-| `\\d` | matches any decimal digit         |
-| `\\D` | matches any character that's not a decimal digit |
-| `\\f` | matches `\f`                      |
-| `\\n` | matches `\n`                      |
-| `\\r` | matches `\r`                      |
-| `\\s` | matches any ASCII whitespace, including `\n` |
-| `\\S` | matches any character that's not a whitespace |
-| `\\t` | matches `\t`                      |
-| `\\v` | matches `\v`                      |
-| `\\w` | matches any letter, `_`, or decimal digit |
-| `\\W` | matches any character that `\\w` doesn't match |
-| `\\c` | matches any literal character `c`, which must be a punctuation |
-| `.` | matches any single character except `\n` |
-| `A?` | matches 0 or 1 occurrences of `A` |
-| `A*` | matches 0 or many occurrences of `A` |
-| `A+` | matches 1 or many occurrences of `A` |
-| `^` | matches the beginning of a string (not that of each line) |
-| `$` | matches the end of a string (not that of each line) |
-| `xy` | matches `x` followed by `y`       |
-
-To help you determine which capability is available on your system,
-Google Test defines macro `GTEST_USES_POSIX_RE=1` when it uses POSIX
-extended regular expressions, or `GTEST_USES_SIMPLE_RE=1` when it uses
-the simple version.  If you want your death tests to work in both
-cases, you can either `#if` on these macros or use the more limited
-syntax only.
-
-## How It Works ##
-
-Under the hood, `ASSERT_EXIT()` spawns a new process and executes the
-death test statement in that process. The details of of how precisely
-that happens depend on the platform and the variable
-`::testing::GTEST_FLAG(death_test_style)` (which is initialized from the
-command-line flag `--gtest_death_test_style`).
-
-  * On POSIX systems, `fork()` (or `clone()` on Linux) is used to spawn the child, after which:
-    * If the variable's value is `"fast"`, the death test statement is immediately executed.
-    * If the variable's value is `"threadsafe"`, the child process re-executes the unit test binary just as it was originally invoked, but with some extra flags to cause just the single death test under consideration to be run.
-  * On Windows, the child is spawned using the `CreateProcess()` API, and re-executes the binary to cause just the single death test under consideration to be run - much like the `threadsafe` mode on POSIX.
-
-Other values for the variable are illegal and will cause the death test to
-fail. Currently, the flag's default value is `"fast"`. However, we reserve the
-right to change it in the future. Therefore, your tests should not depend on
-this.
-
-In either case, the parent process waits for the child process to complete, and checks that
-
-  1. the child's exit status satisfies the predicate, and
-  1. the child's stderr matches the regular expression.
-
-If the death test statement runs to completion without dying, the child
-process will nonetheless terminate, and the assertion fails.
-
-## Death Tests And Threads ##
-
-The reason for the two death test styles has to do with thread safety. Due to
-well-known problems with forking in the presence of threads, death tests should
-be run in a single-threaded context. Sometimes, however, it isn't feasible to
-arrange that kind of environment. For example, statically-initialized modules
-may start threads before main is ever reached. Once threads have been created,
-it may be difficult or impossible to clean them up.
-
-Google Test has three features intended to raise awareness of threading issues.
-
-  1. A warning is emitted if multiple threads are running when a death test is encountered.
-  1. Test cases with a name ending in "DeathTest" are run before all other tests.
-  1. It uses `clone()` instead of `fork()` to spawn the child process on Linux (`clone()` is not available on Cygwin and Mac), as `fork()` is more likely to cause the child to hang when the parent process has multiple threads.
-
-It's perfectly fine to create threads inside a death test statement; they are
-executed in a separate process and cannot affect the parent.
-
-## Death Test Styles ##
-
-The "threadsafe" death test style was introduced in order to help mitigate the
-risks of testing in a possibly multithreaded environment. It trades increased
-test execution time (potentially dramatically so) for improved thread safety.
-We suggest using the faster, default "fast" style unless your test has specific
-problems with it.
-
-You can choose a particular style of death tests by setting the flag
-programmatically:
-
-```
-::testing::FLAGS_gtest_death_test_style = "threadsafe";
-```
-
-You can do this in `main()` to set the style for all death tests in the
-binary, or in individual tests. Recall that flags are saved before running each
-test and restored afterwards, so you need not do that yourself. For example:
-
-```
-TEST(MyDeathTest, TestOne) {
-  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-  // This test is run in the "threadsafe" style:
-  ASSERT_DEATH(ThisShouldDie(), "");
-}
-
-TEST(MyDeathTest, TestTwo) {
-  // This test is run in the "fast" style:
-  ASSERT_DEATH(ThisShouldDie(), "");
-}
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  ::testing::FLAGS_gtest_death_test_style = "fast";
-  return RUN_ALL_TESTS();
-}
-```
-
-## Caveats ##
-
-The _statement_ argument of `ASSERT_EXIT()` can be any valid C++ statement.
-If it leaves the current function via a `return` statement or by throwing an exception,
-the death test is considered to have failed.  Some Google Test macros may return
-from the current function (e.g. `ASSERT_TRUE()`), so be sure to avoid them in _statement_.
-
-Since _statement_ runs in the child process, any in-memory side effect (e.g.
-modifying a variable, releasing memory, etc) it causes will _not_ be observable
-in the parent process. In particular, if you release memory in a death test,
-your program will fail the heap check as the parent process will never see the
-memory reclaimed. To solve this problem, you can
-
-  1. try not to free memory in a death test;
-  1. free the memory again in the parent process; or
-  1. do not use the heap checker in your program.
-
-Due to an implementation detail, you cannot place multiple death test
-assertions on the same line; otherwise, compilation will fail with an unobvious
-error message.
-
-Despite the improved thread safety afforded by the "threadsafe" style of death
-test, thread problems such as deadlock are still possible in the presence of
-handlers registered with `pthread_atfork(3)`.
-
-# Using Assertions in Sub-routines #
-
-## Adding Traces to Assertions ##
-
-If a test sub-routine is called from several places, when an assertion
-inside it fails, it can be hard to tell which invocation of the
-sub-routine the failure is from.  You can alleviate this problem using
-extra logging or custom failure messages, but that usually clutters up
-your tests. A better solution is to use the `SCOPED_TRACE` macro:
-
-| `SCOPED_TRACE(`_message_`);` |
-|:-----------------------------|
-
-where _message_ can be anything streamable to `std::ostream`. This
-macro will cause the current file name, line number, and the given
-message to be added in every failure message. The effect will be
-undone when the control leaves the current lexical scope.
-
-For example,
-
-```
-10: void Sub1(int n) {
-11:   EXPECT_EQ(1, Bar(n));
-12:   EXPECT_EQ(2, Bar(n + 1));
-13: }
-14:
-15: TEST(FooTest, Bar) {
-16:   {
-17:     SCOPED_TRACE("A");  // This trace point will be included in
-18:                         // every failure in this scope.
-19:     Sub1(1);
-20:   }
-21:   // Now it won't.
-22:   Sub1(9);
-23: }
-```
-
-could result in messages like these:
-
-```
-path/to/foo_test.cc:11: Failure
-Value of: Bar(n)
-Expected: 1
-  Actual: 2
-   Trace:
-path/to/foo_test.cc:17: A
-
-path/to/foo_test.cc:12: Failure
-Value of: Bar(n + 1)
-Expected: 2
-  Actual: 3
-```
-
-Without the trace, it would've been difficult to know which invocation
-of `Sub1()` the two failures come from respectively. (You could add an
-extra message to each assertion in `Sub1()` to indicate the value of
-`n`, but that's tedious.)
-
-Some tips on using `SCOPED_TRACE`:
-
-  1. With a suitable message, it's often enough to use `SCOPED_TRACE` at the beginning of a sub-routine, instead of at each call site.
-  1. When calling sub-routines inside a loop, make the loop iterator part of the message in `SCOPED_TRACE` such that you can know which iteration the failure is from.
-  1. Sometimes the line number of the trace point is enough for identifying the particular invocation of a sub-routine. In this case, you don't have to choose a unique message for `SCOPED_TRACE`. You can simply use `""`.
-  1. You can use `SCOPED_TRACE` in an inner scope when there is one in the outer scope. In this case, all active trace points will be included in the failure messages, in reverse order they are encountered.
-  1. The trace dump is clickable in Emacs' compilation buffer - hit return on a line number and you'll be taken to that line in the source file!
-
-_Availability:_ Linux, Windows, Mac.
-
-## Propagating Fatal Failures ##
-
-A common pitfall when using `ASSERT_*` and `FAIL*` is not understanding that
-when they fail they only abort the _current function_, not the entire test. For
-example, the following test will segfault:
-```
-void Subroutine() {
-  // Generates a fatal failure and aborts the current function.
-  ASSERT_EQ(1, 2);
-  // The following won't be executed.
-  ...
-}
-
-TEST(FooTest, Bar) {
-  Subroutine();
-  // The intended behavior is for the fatal failure
-  // in Subroutine() to abort the entire test.
-  // The actual behavior: the function goes on after Subroutine() returns.
-  int* p = NULL;
-  *p = 3; // Segfault!
-}
-```
-
-Since we don't use exceptions, it is technically impossible to
-implement the intended behavior here.  To alleviate this, Google Test
-provides two solutions.  You could use either the
-`(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the
-`HasFatalFailure()` function.  They are described in the following two
-subsections.
-
-### Asserting on Subroutines ###
-
-As shown above, if your test calls a subroutine that has an `ASSERT_*`
-failure in it, the test will continue after the subroutine
-returns. This may not be what you want.
-
-Often people want fatal failures to propagate like exceptions.  For
-that Google Test offers the following macros:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_NO_FATAL_FAILURE(`_statement_`);` | `EXPECT_NO_FATAL_FAILURE(`_statement_`);` | _statement_ doesn't generate any new fatal failures in the current thread. |
-
-Only failures in the thread that executes the assertion are checked to
-determine the result of this type of assertions.  If _statement_
-creates new threads, failures in these threads are ignored.
-
-Examples:
-
-```
-ASSERT_NO_FATAL_FAILURE(Foo());
-
-int i;
-EXPECT_NO_FATAL_FAILURE({
-  i = Bar();
-});
-```
-
-_Availability:_ Linux, Windows, Mac. Assertions from multiple threads
-are currently not supported.
-
-### Checking for Failures in the Current Test ###
-
-`HasFatalFailure()` in the `::testing::Test` class returns `true` if an
-assertion in the current test has suffered a fatal failure. This
-allows functions to catch fatal failures in a sub-routine and return
-early.
-
-```
-class Test {
- public:
-  ...
-  static bool HasFatalFailure();
-};
-```
-
-The typical usage, which basically simulates the behavior of a thrown
-exception, is:
-
-```
-TEST(FooTest, Bar) {
-  Subroutine();
-  // Aborts if Subroutine() had a fatal failure.
-  if (HasFatalFailure())
-    return;
-  // The following won't be executed.
-  ...
-}
-```
-
-If `HasFatalFailure()` is used outside of `TEST()` , `TEST_F()` , or a test
-fixture, you must add the `::testing::Test::` prefix, as in:
-
-```
-if (::testing::Test::HasFatalFailure())
-  return;
-```
-
-Similarly, `HasNonfatalFailure()` returns `true` if the current test
-has at least one non-fatal failure, and `HasFailure()` returns `true`
-if the current test has at least one failure of either kind.
-
-_Availability:_ Linux, Windows, Mac.  `HasNonfatalFailure()` and
-`HasFailure()` are available since version 1.4.0.
-
-# Logging Additional Information #
-
-In your test code, you can call `RecordProperty("key", value)` to log
-additional information, where `value` can be either a C string or a 32-bit
-integer. The _last_ value recorded for a key will be emitted to the XML output
-if you specify one. For example, the test
-
-```
-TEST_F(WidgetUsageTest, MinAndMaxWidgets) {
-  RecordProperty("MaximumWidgets", ComputeMaxUsage());
-  RecordProperty("MinimumWidgets", ComputeMinUsage());
-}
-```
-
-will output XML like this:
-
-```
-...
-  <testcase name="MinAndMaxWidgets" status="run" time="6" classname="WidgetUsageTest"
-            MaximumWidgets="12"
-            MinimumWidgets="9" />
-...
-```
-
-_Note_:
-  * `RecordProperty()` is a static member of the `Test` class. Therefore it needs to be prefixed with `::testing::Test::` if used outside of the `TEST` body and the test fixture class.
-  * `key` must be a valid XML attribute name, and cannot conflict with the ones already used by Google Test (`name`, `status`,     `time`, and `classname`).
-
-_Availability_: Linux, Windows, Mac.
-
-# Sharing Resources Between Tests in the Same Test Case #
-
-
-
-Google Test creates a new test fixture object for each test in order to make
-tests independent and easier to debug. However, sometimes tests use resources
-that are expensive to set up, making the one-copy-per-test model prohibitively
-expensive.
-
-If the tests don't change the resource, there's no harm in them sharing a
-single resource copy. So, in addition to per-test set-up/tear-down, Google Test
-also supports per-test-case set-up/tear-down. To use it:
-
-  1. In your test fixture class (say `FooTest` ), define as `static` some member variables to hold the shared resources.
-  1. In the same test fixture class, define a `static void SetUpTestCase()` function (remember not to spell it as **`SetupTestCase`** with a small `u`!) to set up the shared resources and a `static void TearDownTestCase()` function to tear them down.
-
-That's it! Google Test automatically calls `SetUpTestCase()` before running the
-_first test_ in the `FooTest` test case (i.e. before creating the first
-`FooTest` object), and calls `TearDownTestCase()` after running the _last test_
-in it (i.e. after deleting the last `FooTest` object). In between, the tests
-can use the shared resources.
-
-Remember that the test order is undefined, so your code can't depend on a test
-preceding or following another. Also, the tests must either not modify the
-state of any shared resource, or, if they do modify the state, they must
-restore the state to its original value before passing control to the next
-test.
-
-Here's an example of per-test-case set-up and tear-down:
-```
-class FooTest : public ::testing::Test {
- protected:
-  // Per-test-case set-up.
-  // Called before the first test in this test case.
-  // Can be omitted if not needed.
-  static void SetUpTestCase() {
-    shared_resource_ = new ...;
-  }
-
-  // Per-test-case tear-down.
-  // Called after the last test in this test case.
-  // Can be omitted if not needed.
-  static void TearDownTestCase() {
-    delete shared_resource_;
-    shared_resource_ = NULL;
-  }
-
-  // You can define per-test set-up and tear-down logic as usual.
-  virtual void SetUp() { ... }
-  virtual void TearDown() { ... }
-
-  // Some expensive resource shared by all tests.
-  static T* shared_resource_;
-};
-
-T* FooTest::shared_resource_ = NULL;
-
-TEST_F(FooTest, Test1) {
-  ... you can refer to shared_resource here ...
-}
-TEST_F(FooTest, Test2) {
-  ... you can refer to shared_resource here ...
-}
-```
-
-_Availability:_ Linux, Windows, Mac.
-
-# Global Set-Up and Tear-Down #
-
-Just as you can do set-up and tear-down at the test level and the test case
-level, you can also do it at the test program level. Here's how.
-
-First, you subclass the `::testing::Environment` class to define a test
-environment, which knows how to set-up and tear-down:
-
-```
-class Environment {
- public:
-  virtual ~Environment() {}
-  // Override this to define how to set up the environment.
-  virtual void SetUp() {}
-  // Override this to define how to tear down the environment.
-  virtual void TearDown() {}
-};
-```
-
-Then, you register an instance of your environment class with Google Test by
-calling the `::testing::AddGlobalTestEnvironment()` function:
-
-```
-Environment* AddGlobalTestEnvironment(Environment* env);
-```
-
-Now, when `RUN_ALL_TESTS()` is called, it first calls the `SetUp()` method of
-the environment object, then runs the tests if there was no fatal failures, and
-finally calls `TearDown()` of the environment object.
-
-It's OK to register multiple environment objects. In this case, their `SetUp()`
-will be called in the order they are registered, and their `TearDown()` will be
-called in the reverse order.
-
-Note that Google Test takes ownership of the registered environment objects.
-Therefore **do not delete them** by yourself.
-
-You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is
-called, probably in `main()`. If you use `gtest_main`, you need to      call
-this before `main()` starts for it to take effect. One way to do this is to
-define a global variable like this:
-
-```
-::testing::Environment* const foo_env = ::testing::AddGlobalTestEnvironment(new FooEnvironment);
-```
-
-However, we strongly recommend you to write your own `main()` and call
-`AddGlobalTestEnvironment()` there, as relying on initialization of global
-variables makes the code harder to read and may cause problems when you
-register multiple environments from different translation units and the
-environments have dependencies among them (remember that the compiler doesn't
-guarantee the order in which global variables from different translation units
-are initialized).
-
-_Availability:_ Linux, Windows, Mac.
-
-
-# Value Parameterized Tests #
-
-_Value-parameterized tests_ allow you to test your code with different
-parameters without writing multiple copies of the same test.
-
-Suppose you write a test for your code and then realize that your code is affected by a presence of a Boolean command line flag.
-
-```
-TEST(MyCodeTest, TestFoo) {
-  // A code to test foo().
-}
-```
-
-Usually people factor their test code into a function with a Boolean parameter in such situations. The function sets the flag, then executes the testing code.
-
-```
-void TestFooHelper(bool flag_value) {
-  flag = flag_value;
-  // A code to test foo().
-}
-
-TEST(MyCodeTest, TestFooo) {
-  TestFooHelper(false);
-  TestFooHelper(true);
-}
-```
-
-But this setup has serious drawbacks. First, when a test assertion fails in your tests, it becomes unclear what value of the parameter caused it to fail. You can stream a clarifying message into your `EXPECT`/`ASSERT` statements, but it you'll have to do it with all of them. Second, you have to add one such helper function per test. What if you have ten tests? Twenty? A hundred?
-
-Value-parameterized tests will let you write your test only once and then easily instantiate and run it with an arbitrary number of parameter values.
-
-Here are some other situations when value-parameterized tests come handy:
-
-  * You want to test different implementations of an OO interface.
-  * You want to test your code over various inputs (a.k.a. data-driven testing). This feature is easy to abuse, so please exercise your good sense when doing it!
-
-## How to Write Value-Parameterized Tests ##
-
-To write value-parameterized tests, first you should define a fixture
-class.  It must be derived from both `::testing::Test` and
-`::testing::WithParamInterface<T>` (the latter is a pure interface),
-where `T` is the type of your parameter values.  For convenience, you
-can just derive the fixture class from `::testing::TestWithParam<T>`,
-which itself is derived from both `::testing::Test` and
-`::testing::WithParamInterface<T>`. `T` can be any copyable type. If
-it's a raw pointer, you are responsible for managing the lifespan of
-the pointed values.
-
-```
-class FooTest : public ::testing::TestWithParam<const char*> {
-  // You can implement all the usual fixture class members here.
-  // To access the test parameter, call GetParam() from class
-  // TestWithParam<T>.
-};
-
-// Or, when you want to add parameters to a pre-existing fixture class:
-class BaseTest : public ::testing::Test {
-  ...
-};
-class BarTest : public BaseTest,
-                public ::testing::WithParamInterface<const char*> {
-  ...
-};
-```
-
-Then, use the `TEST_P` macro to define as many test patterns using
-this fixture as you want.  The `_P` suffix is for "parameterized" or
-"pattern", whichever you prefer to think.
-
-```
-TEST_P(FooTest, DoesBlah) {
-  // Inside a test, access the test parameter with the GetParam() method
-  // of the TestWithParam<T> class:
-  EXPECT_TRUE(foo.Blah(GetParam()));
-  ...
-}
-
-TEST_P(FooTest, HasBlahBlah) {
-  ...
-}
-```
-
-Finally, you can use `INSTANTIATE_TEST_CASE_P` to instantiate the test
-case with 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 are all in the `testing` namespace:
-
-| `Range(begin, end[, step])` | Yields values `{begin, begin+step, begin+step+step, ...}`. The values do not include `end`. `step` defaults to 1. |
-|:----------------------------|:------------------------------------------------------------------------------------------------------------------|
-| `Values(v1, v2, ..., vN)`   | Yields values `{v1, v2, ..., vN}`.                                                                                |
-| `ValuesIn(container)` and `ValuesIn(begin, end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)`. `container`, `begin`, and `end` can be expressions whose values are determined at run time.  |
-| `Bool()`                    | Yields sequence `{false, true}`.                                                                                  |
-| `Combine(g1, g2, ..., gN)`  | Yields all combinations (the Cartesian product for the math savvy) of the values generated by the `N` generators. This is only available if your system provides the `<tr1/tuple>` header. If you are sure your system does, and Google Test disagrees, you can override it by defining `GTEST_HAS_TR1_TUPLE=1`. See comments in [include/gtest/internal/gtest-port.h](../include/gtest/internal/gtest-port.h) for more information. |
-
-For more details, see the comments at the definitions of these functions in the [source code](../include/gtest/gtest-param-test.h).
-
-The following statement will instantiate tests from the `FooTest` test case
-each with parameter values `"meeny"`, `"miny"`, and `"moe"`.
-
-```
-INSTANTIATE_TEST_CASE_P(InstantiationName,
-                        FooTest,
-                        ::testing::Values("meeny", "miny", "moe"));
-```
-
-To distinguish different instances of the pattern (yes, you can
-instantiate it more than once), the first argument to
-`INSTANTIATE_TEST_CASE_P` is a prefix that will be added to the actual
-test case name. Remember to pick unique prefixes for different
-instantiations. The tests from the instantiation above will have these
-names:
-
-  * `InstantiationName/FooTest.DoesBlah/0` for `"meeny"`
-  * `InstantiationName/FooTest.DoesBlah/1` for `"miny"`
-  * `InstantiationName/FooTest.DoesBlah/2` for `"moe"`
-  * `InstantiationName/FooTest.HasBlahBlah/0` for `"meeny"`
-  * `InstantiationName/FooTest.HasBlahBlah/1` for `"miny"`
-  * `InstantiationName/FooTest.HasBlahBlah/2` for `"moe"`
-
-You can use these names in [--gtest\-filter](#running-a-subset-of-the-tests).
-
-This statement will instantiate all tests from `FooTest` again, each
-with parameter values `"cat"` and `"dog"`:
-
-```
-const char* pets[] = {"cat", "dog"};
-INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest,
-                        ::testing::ValuesIn(pets));
-```
-
-The tests from the instantiation above will have these names:
-
-  * `AnotherInstantiationName/FooTest.DoesBlah/0` for `"cat"`
-  * `AnotherInstantiationName/FooTest.DoesBlah/1` for `"dog"`
-  * `AnotherInstantiationName/FooTest.HasBlahBlah/0` for `"cat"`
-  * `AnotherInstantiationName/FooTest.HasBlahBlah/1` for `"dog"`
-
-Please note that `INSTANTIATE_TEST_CASE_P` will instantiate _all_
-tests in the given test case, whether their definitions come before or
-_after_ the `INSTANTIATE_TEST_CASE_P` statement.
-
-You can see
-[these](../samples/sample7_unittest.cc)
-[files](../samples/sample8_unittest.cc) for more examples.
-
-_Availability_: Linux, Windows (requires MSVC 8.0 or above), Mac; since version 1.2.0.
-
-## Creating Value-Parameterized Abstract Tests ##
-
-In the above, we define and instantiate `FooTest` in the same source
-file. Sometimes you may want to define value-parameterized tests in a
-library and let other people instantiate them later. This pattern is
-known as <i>abstract tests</i>. As an example of its application, when you
-are designing an interface you can write a standard suite of abstract
-tests (perhaps using a factory function as the test parameter) that
-all implementations of the interface are expected to pass. When
-someone implements the interface, he can instantiate your suite to get
-all the interface-conformance tests for free.
-
-To define abstract tests, you should organize your code like this:
-
-  1. Put the definition of the parameterized test fixture class (e.g. `FooTest`) in a header file, say `foo_param_test.h`. Think of this as _declaring_ your abstract tests.
-  1. Put the `TEST_P` definitions in `foo_param_test.cc`, which includes `foo_param_test.h`. Think of this as _implementing_ your abstract tests.
-
-Once they are defined, you can instantiate them by including
-`foo_param_test.h`, invoking `INSTANTIATE_TEST_CASE_P()`, and linking
-with `foo_param_test.cc`. You can instantiate the same abstract test
-case multiple times, possibly in different source files.
-
-# Typed Tests #
-
-Suppose you have multiple implementations of the same interface and
-want to make sure that all of them satisfy some common requirements.
-Or, you may have defined several types that are supposed to conform to
-the same "concept" and you want to verify it.  In both cases, you want
-the same test logic repeated for different types.
-
-While you can write one `TEST` or `TEST_F` for each type you want to
-test (and you may even factor the test logic into a function template
-that you invoke from the `TEST`), it's tedious and doesn't scale:
-if you want _m_ tests over _n_ types, you'll end up writing _m\*n_
-`TEST`s.
-
-_Typed tests_ allow you to repeat the same test logic over a list of
-types.  You only need to write the test logic once, although you must
-know the type list when writing typed tests.  Here's how you do it:
-
-First, define a fixture class template.  It should be parameterized
-by a type.  Remember to derive it from `::testing::Test`:
-
-```
-template <typename T>
-class FooTest : public ::testing::Test {
- public:
-  ...
-  typedef std::list<T> List;
-  static T shared_;
-  T value_;
-};
-```
-
-Next, associate a list of types with the test case, which will be
-repeated for each type in the list:
-
-```
-typedef ::testing::Types<char, int, unsigned int> MyTypes;
-TYPED_TEST_CASE(FooTest, MyTypes);
-```
-
-The `typedef` is necessary for the `TYPED_TEST_CASE` macro to parse
-correctly.  Otherwise the compiler will think that each comma in the
-type list introduces a new macro argument.
-
-Then, use `TYPED_TEST()` instead of `TEST_F()` to define a typed test
-for this test case.  You can repeat this as many times as you want:
-
-```
-TYPED_TEST(FooTest, DoesBlah) {
-  // Inside a test, refer to the special name TypeParam to get the type
-  // parameter.  Since we are inside a derived class template, C++ requires
-  // us to visit the members of FooTest via 'this'.
-  TypeParam n = this->value_;
-
-  // To visit static members of the fixture, add the 'TestFixture::'
-  // prefix.
-  n += TestFixture::shared_;
-
-  // To refer to typedefs in the fixture, add the 'typename TestFixture::'
-  // prefix.  The 'typename' is required to satisfy the compiler.
-  typename TestFixture::List values;
-  values.push_back(n);
-  ...
-}
-
-TYPED_TEST(FooTest, HasPropertyA) { ... }
-```
-
-You can see `samples/sample6_unittest.cc` for a complete example.
-
-_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
-since version 1.1.0.
-
-# Type-Parameterized Tests #
-
-_Type-parameterized tests_ are like typed tests, except that they
-don't require you to know the list of types ahead of time.  Instead,
-you can define the test logic first and instantiate it with different
-type lists later.  You can even instantiate it more than once in the
-same program.
-
-If you are designing an interface or concept, you can define a suite
-of type-parameterized tests to verify properties that any valid
-implementation of the interface/concept should have.  Then, the author
-of each implementation can just instantiate the test suite with his
-type to verify that it conforms to the requirements, without having to
-write similar tests repeatedly.  Here's an example:
-
-First, define a fixture class template, as we did with typed tests:
-
-```
-template <typename T>
-class FooTest : public ::testing::Test {
-  ...
-};
-```
-
-Next, declare that you will define a type-parameterized test case:
-
-```
-TYPED_TEST_CASE_P(FooTest);
-```
-
-The `_P` suffix is for "parameterized" or "pattern", whichever you
-prefer to think.
-
-Then, use `TYPED_TEST_P()` to define a type-parameterized test.  You
-can repeat this as many times as you want:
-
-```
-TYPED_TEST_P(FooTest, DoesBlah) {
-  // Inside a test, refer to TypeParam to get the type parameter.
-  TypeParam n = 0;
-  ...
-}
-
-TYPED_TEST_P(FooTest, HasPropertyA) { ... }
-```
-
-Now the tricky part: you need to register all test patterns using the
-`REGISTER_TYPED_TEST_CASE_P` macro before you can instantiate them.
-The first argument of the macro is the test case name; the rest are
-the names of the tests in this test case:
-
-```
-REGISTER_TYPED_TEST_CASE_P(FooTest,
-                           DoesBlah, HasPropertyA);
-```
-
-Finally, you are free to instantiate the pattern with the types you
-want.  If you put the above code in a header file, you can `#include`
-it in multiple C++ source files and instantiate it multiple times.
-
-```
-typedef ::testing::Types<char, int, unsigned int> MyTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
-```
-
-To distinguish different instances of the pattern, the first argument
-to the `INSTANTIATE_TYPED_TEST_CASE_P` macro is a prefix that will be
-added to the actual test case name.  Remember to pick unique prefixes
-for different instances.
-
-In the special case where the type list contains only one type, you
-can write that type directly without `::testing::Types<...>`, like this:
-
-```
-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
-```
-
-You can see `samples/sample6_unittest.cc` for a complete example.
-
-_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
-since version 1.1.0.
-
-# Testing Private Code #
-
-If you change your software's internal implementation, your tests should not
-break as long as the change is not observable by users. Therefore, per the
-_black-box testing principle_, most of the time you should test your code
-through its public interfaces.
-
-If you still find yourself needing to test internal implementation code,
-consider if there's a better design that wouldn't require you to do so. If you
-absolutely have to test non-public interface code though, you can. There are
-two cases to consider:
-
-  * Static functions (_not_ the same as static member functions!) or unnamed namespaces, and
-  * Private or protected class members
-
-## Static Functions ##
-
-Both static functions and definitions/declarations in an unnamed namespace are
-only visible within the same translation unit. To test them, you can `#include`
-the entire `.cc` file being tested in your `*_test.cc` file. (`#include`ing `.cc`
-files is not a good way to reuse code - you should not do this in production
-code!)
-
-However, a better approach is to move the private code into the
-`foo::internal` namespace, where `foo` is the namespace your project normally
-uses, and put the private declarations in a `*-internal.h` file. Your
-production `.cc` files and your tests are allowed to include this internal
-header, but your clients are not. This way, you can fully test your internal
-implementation without leaking it to your clients.
-
-## Private Class Members ##
-
-Private class members are only accessible from within the class or by friends.
-To access a class' private members, you can declare your test fixture as a
-friend to the class and define accessors in your fixture. Tests using the
-fixture can then access the private members of your production class via the
-accessors in the fixture. Note that even though your fixture is a friend to
-your production class, your tests are not automatically friends to it, as they
-are technically defined in sub-classes of the fixture.
-
-Another way to test private members is to refactor them into an implementation
-class, which is then declared in a `*-internal.h` file. Your clients aren't
-allowed to include this header but your tests can. Such is called the Pimpl
-(Private Implementation) idiom.
-
-Or, you can declare an individual test as a friend of your class by adding this
-line in the class body:
-
-```
-FRIEND_TEST(TestCaseName, TestName);
-```
-
-For example,
-```
-// foo.h
-#include "gtest/gtest_prod.h"
-
-// Defines FRIEND_TEST.
-class Foo {
-  ...
- private:
-  FRIEND_TEST(FooTest, BarReturnsZeroOnNull);
-  int Bar(void* x);
-};
-
-// foo_test.cc
-...
-TEST(FooTest, BarReturnsZeroOnNull) {
-  Foo foo;
-  EXPECT_EQ(0, foo.Bar(NULL));
-  // Uses Foo's private member Bar().
-}
-```
-
-Pay special attention when your class is defined in a namespace, as you should
-define your test fixtures and tests in the same namespace if you want them to
-be friends of your class. For example, if the code to be tested looks like:
-
-```
-namespace my_namespace {
-
-class Foo {
-  friend class FooTest;
-  FRIEND_TEST(FooTest, Bar);
-  FRIEND_TEST(FooTest, Baz);
-  ...
-  definition of the class Foo
-  ...
-};
-
-}  // namespace my_namespace
-```
-
-Your test code should be something like:
-
-```
-namespace my_namespace {
-class FooTest : public ::testing::Test {
- protected:
-  ...
-};
-
-TEST_F(FooTest, Bar) { ... }
-TEST_F(FooTest, Baz) { ... }
-
-}  // namespace my_namespace
-```
-
-# Catching Failures #
-
-If you are building a testing utility on top of Google Test, you'll
-want to test your utility.  What framework would you use to test it?
-Google Test, of course.
-
-The challenge is to verify that your testing utility reports failures
-correctly.  In frameworks that report a failure by throwing an
-exception, you could catch the exception and assert on it.  But Google
-Test doesn't use exceptions, so how do we test that a piece of code
-generates an expected failure?
-
-`"gtest/gtest-spi.h"` contains some constructs to do this.  After
-`#include`ing this header, you can use
-
-| `EXPECT_FATAL_FAILURE(`_statement, substring_`);` |
-|:--------------------------------------------------|
-
-to assert that _statement_ generates a fatal (e.g. `ASSERT_*`) failure
-whose message contains the given _substring_, or use
-
-| `EXPECT_NONFATAL_FAILURE(`_statement, substring_`);` |
-|:-----------------------------------------------------|
-
-if you are expecting a non-fatal (e.g. `EXPECT_*`) failure.
-
-For technical reasons, there are some caveats:
-
-  1. You cannot stream a failure message to either macro.
-  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot reference local non-static variables or non-static members of `this` object.
-  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot return a value.
-
-_Note:_ Google Test is designed with threads in mind.  Once the
-synchronization primitives in `"gtest/internal/gtest-port.h"` have
-been implemented, Google Test will become thread-safe, meaning that
-you can then use assertions in multiple threads concurrently.  Before
-
-that, however, Google Test only supports single-threaded usage.  Once
-thread-safe, `EXPECT_FATAL_FAILURE()` and `EXPECT_NONFATAL_FAILURE()`
-will capture failures in the current thread only. If _statement_
-creates new threads, failures in these threads will be ignored.  If
-you want to capture failures from all threads instead, you should use
-the following macros:
-
-| `EXPECT_FATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
-|:-----------------------------------------------------------------|
-| `EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
-
-# Getting the Current Test's Name #
-
-Sometimes a function may need to know the name of the currently running test.
-For example, you may be using the `SetUp()` method of your test fixture to set
-the golden file name based on which test is running. The `::testing::TestInfo`
-class has this information:
-
-```
-namespace testing {
-
-class TestInfo {
- public:
-  // Returns the test case name and the test name, respectively.
-  //
-  // Do NOT delete or free the return value - it's managed by the
-  // TestInfo class.
-  const char* test_case_name() const;
-  const char* name() const;
-};
-
-}  // namespace testing
-```
-
-
-> To obtain a `TestInfo` object for the currently running test, call
-`current_test_info()` on the `UnitTest` singleton object:
-
-```
-// Gets information about the currently running test.
-// Do NOT delete the returned object - it's managed by the UnitTest class.
-const ::testing::TestInfo* const test_info =
-  ::testing::UnitTest::GetInstance()->current_test_info();
-printf("We are in test %s of test case %s.\n",
-       test_info->name(), test_info->test_case_name());
-```
-
-`current_test_info()` returns a null pointer if no test is running. In
-particular, you cannot find the test case name in `TestCaseSetUp()`,
-`TestCaseTearDown()` (where you know the test case name implicitly), or
-functions called from them.
-
-_Availability:_ Linux, Windows, Mac.
-
-# Extending Google Test by Handling Test Events #
-
-Google Test provides an <b>event listener API</b> to let you receive
-notifications about the progress of a test program and test
-failures. The events you can listen to include the start and end of
-the test program, a test case, or a test method, among others. You may
-use this API to augment or replace the standard console output,
-replace the XML output, or provide a completely different form of
-output, such as a GUI or a database. You can also use test events as
-checkpoints to implement a resource leak checker, for example.
-
-_Availability:_ Linux, Windows, Mac; since v1.4.0.
-
-## Defining Event Listeners ##
-
-To define a event listener, you subclass either
-[testing::TestEventListener](../include/gtest/gtest.h#L855)
-or [testing::EmptyTestEventListener](../include/gtest/gtest.h#L905).
-The former is an (abstract) interface, where <i>each pure virtual method<br>
-can be overridden to handle a test event</i> (For example, when a test
-starts, the `OnTestStart()` method will be called.). The latter provides
-an empty implementation of all methods in the interface, such that a
-subclass only needs to override the methods it cares about.
-
-When an event is fired, its context is passed to the handler function
-as an argument. The following argument types are used:
-  * [UnitTest](../include/gtest/gtest.h#L1007) reflects the state of the entire test program,
-  * [TestCase](../include/gtest/gtest.h#L689) has information about a test case, which can contain one or more tests,
-  * [TestInfo](../include/gtest/gtest.h#L599) contains the state of a test, and
-  * [TestPartResult](../include/gtest/gtest-test-part.h#L42) represents the result of a test assertion.
-
-An event handler function can examine the argument it receives to find
-out interesting information about the event and the test program's
-state.  Here's an example:
-
-```
-  class MinimalistPrinter : public ::testing::EmptyTestEventListener {
-    // Called before a test starts.
-    virtual void OnTestStart(const ::testing::TestInfo& test_info) {
-      printf("*** Test %s.%s starting.\n",
-             test_info.test_case_name(), test_info.name());
-    }
-
-    // Called after a failed assertion or a SUCCEED() invocation.
-    virtual void OnTestPartResult(
-        const ::testing::TestPartResult& test_part_result) {
-      printf("%s in %s:%d\n%s\n",
-             test_part_result.failed() ? "*** Failure" : "Success",
-             test_part_result.file_name(),
-             test_part_result.line_number(),
-             test_part_result.summary());
-    }
-
-    // Called after a test ends.
-    virtual void OnTestEnd(const ::testing::TestInfo& test_info) {
-      printf("*** Test %s.%s ending.\n",
-             test_info.test_case_name(), test_info.name());
-    }
-  };
-```
-
-## Using Event Listeners ##
-
-To use the event listener you have defined, add an instance of it to
-the Google Test event listener list (represented by class
-[TestEventListeners](../include/gtest/gtest.h#L929)
-- note the "s" at the end of the name) in your
-`main()` function, before calling `RUN_ALL_TESTS()`:
-```
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  // Gets hold of the event listener list.
-  ::testing::TestEventListeners& listeners =
-      ::testing::UnitTest::GetInstance()->listeners();
-  // Adds a listener to the end.  Google Test takes the ownership.
-  listeners.Append(new MinimalistPrinter);
-  return RUN_ALL_TESTS();
-}
-```
-
-There's only one problem: the default test result printer is still in
-effect, so its output will mingle with the output from your minimalist
-printer. To suppress the default printer, just release it from the
-event listener list and delete it. You can do so by adding one line:
-```
-  ...
-  delete listeners.Release(listeners.default_result_printer());
-  listeners.Append(new MinimalistPrinter);
-  return RUN_ALL_TESTS();
-```
-
-Now, sit back and enjoy a completely different output from your
-tests. For more details, you can read this
-[sample](../samples/sample9_unittest.cc).
-
-You may append more than one listener to the list. When an `On*Start()`
-or `OnTestPartResult()` event is fired, the listeners will receive it in
-the order they appear in the list (since new listeners are added to
-the end of the list, the default text printer and the default XML
-generator will receive the event first). An `On*End()` event will be
-received by the listeners in the _reverse_ order. This allows output by
-listeners added later to be framed by output from listeners added
-earlier.
-
-## Generating Failures in Listeners ##
-
-You may use failure-raising macros (`EXPECT_*()`, `ASSERT_*()`,
-`FAIL()`, etc) when processing an event. There are some restrictions:
-
-  1. You cannot generate any failure in `OnTestPartResult()` (otherwise it will cause `OnTestPartResult()` to be called recursively).
-  1. A listener that handles `OnTestPartResult()` is not allowed to generate any failure.
-
-When you add listeners to the listener list, you should put listeners
-that handle `OnTestPartResult()` _before_ listeners that can generate
-failures. This ensures that failures generated by the latter are
-attributed to the right test by the former.
-
-We have a sample of failure-raising listener
-[here](../samples/sample10_unittest.cc).
-
-# Running Test Programs: Advanced Options #
-
-Google Test test programs are ordinary executables. Once built, you can run
-them directly and affect their behavior via the following environment variables
-and/or command line flags. For the flags to work, your programs must call
-`::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`.
-
-To see a list of supported flags and their usage, please run your test
-program with the `--help` flag.  You can also use `-h`, `-?`, or `/?`
-for short.  This feature is added in version 1.3.0.
-
-If an option is specified both by an environment variable and by a
-flag, the latter takes precedence.  Most of the options can also be
-set/read in code: to access the value of command line flag
-`--gtest_foo`, write `::testing::GTEST_FLAG(foo)`.  A common pattern is
-to set the value of a flag before calling `::testing::InitGoogleTest()`
-to change the default value of the flag:
-```
-int main(int argc, char** argv) {
-  // Disables elapsed time by default.
-  ::testing::GTEST_FLAG(print_time) = false;
-
-  // This allows the user to override the flag on the command line.
-  ::testing::InitGoogleTest(&argc, argv);
-
-  return RUN_ALL_TESTS();
-}
-```
-
-## Selecting Tests ##
-
-This section shows various options for choosing which tests to run.
-
-### Listing Test Names ###
-
-Sometimes it is necessary to list the available tests in a program before
-running them so that a filter may be applied if needed. Including the flag
-`--gtest_list_tests` overrides all other flags and lists tests in the following
-format:
-```
-TestCase1.
-  TestName1
-  TestName2
-TestCase2.
-  TestName
-```
-
-None of the tests listed are actually run if the flag is provided. There is no
-corresponding environment variable for this flag.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Running a Subset of the Tests ###
-
-By default, a Google Test program runs all tests the user has defined.
-Sometimes, you want to run only a subset of the tests (e.g. for debugging or
-quickly verifying a change). If you set the `GTEST_FILTER` environment variable
-or the `--gtest_filter` flag to a filter string, Google Test will only run the
-tests whose full names (in the form of `TestCaseName.TestName`) match the
-filter.
-
-The format of a filter is a '`:`'-separated list of wildcard patterns (called
-the positive patterns) optionally followed by a '`-`' and another
-'`:`'-separated pattern list (called the negative patterns). A test matches the
-filter if and only if it matches any of the positive patterns but does not
-match any of the negative patterns.
-
-A pattern may contain `'*'` (matches any string) or `'?'` (matches any single
-character). For convenience, the filter `'*-NegativePatterns'` can be also
-written as `'-NegativePatterns'`.
-
-For example:
-
-  * `./foo_test` Has no flag, and thus runs all its tests.
-  * `./foo_test --gtest_filter=*` Also runs everything, due to the single match-everything `*` value.
-  * `./foo_test --gtest_filter=FooTest.*` Runs everything in test case `FooTest`.
-  * `./foo_test --gtest_filter=*Null*:*Constructor*` Runs any test whose full name contains either `"Null"` or `"Constructor"`.
-  * `./foo_test --gtest_filter=-*DeathTest.*` Runs all non-death tests.
-  * `./foo_test --gtest_filter=FooTest.*-FooTest.Bar` Runs everything in test case `FooTest` except `FooTest.Bar`.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Temporarily Disabling Tests ###
-
-If you have a broken test that you cannot fix right away, you can add the
-`DISABLED_` prefix to its name. This will exclude it from execution. This is
-better than commenting out the code or using `#if 0`, as disabled tests are
-still compiled (and thus won't rot).
-
-If you need to disable all tests in a test case, you can either add `DISABLED_`
-to the front of the name of each test, or alternatively add it to the front of
-the test case name.
-
-For example, the following tests won't be run by Google Test, even though they
-will still be compiled:
-
-```
-// Tests that Foo does Abc.
-TEST(FooTest, DISABLED_DoesAbc) { ... }
-
-class DISABLED_BarTest : public ::testing::Test { ... };
-
-// Tests that Bar does Xyz.
-TEST_F(DISABLED_BarTest, DoesXyz) { ... }
-```
-
-_Note:_ This feature should only be used for temporary pain-relief. You still
-have to fix the disabled tests at a later date. As a reminder, Google Test will
-print a banner warning you if a test program contains any disabled tests.
-
-_Tip:_ You can easily count the number of disabled tests you have
-using `grep`. This number can be used as a metric for improving your
-test quality.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Temporarily Enabling Disabled Tests ###
-
-To include [disabled tests](#temporarily-disabling-tests) in test
-execution, just invoke the test program with the
-`--gtest_also_run_disabled_tests` flag or set the
-`GTEST_ALSO_RUN_DISABLED_TESTS` environment variable to a value other
-than `0`.  You can combine this with the
-[--gtest\-filter](#running-a-subset-of-the_tests) flag to further select
-which disabled tests to run.
-
-_Availability:_ Linux, Windows, Mac; since version 1.3.0.
-
-## Repeating the Tests ##
-
-Once in a while you'll run into a test whose result is hit-or-miss. Perhaps it
-will fail only 1% of the time, making it rather hard to reproduce the bug under
-a debugger. This can be a major source of frustration.
-
-The `--gtest_repeat` flag allows you to repeat all (or selected) test methods
-in a program many times. Hopefully, a flaky test will eventually fail and give
-you a chance to debug. Here's how to use it:
-
-| `$ foo_test --gtest_repeat=1000` | Repeat foo\_test 1000 times and don't stop at failures. |
-|:---------------------------------|:--------------------------------------------------------|
-| `$ foo_test --gtest_repeat=-1`   | A negative count means repeating forever.               |
-| `$ foo_test --gtest_repeat=1000 --gtest_break_on_failure` | Repeat foo\_test 1000 times, stopping at the first failure. This is especially useful when running under a debugger: when the testfails, it will drop into the debugger and you can then inspect variables and stacks. |
-| `$ foo_test --gtest_repeat=1000 --gtest_filter=FooBar` | Repeat the tests whose name matches the filter 1000 times. |
-
-If your test program contains global set-up/tear-down code registered
-using `AddGlobalTestEnvironment()`, it will be repeated in each
-iteration as well, as the flakiness may be in it. You can also specify
-the repeat count by setting the `GTEST_REPEAT` environment variable.
-
-_Availability:_ Linux, Windows, Mac.
-
-## Shuffling the Tests ##
-
-You can specify the `--gtest_shuffle` flag (or set the `GTEST_SHUFFLE`
-environment variable to `1`) to run the tests in a program in a random
-order. This helps to reveal bad dependencies between tests.
-
-By default, Google Test uses a random seed calculated from the current
-time. Therefore you'll get a different order every time. The console
-output includes the random seed value, such that you can reproduce an
-order-related test failure later. To specify the random seed
-explicitly, use the `--gtest_random_seed=SEED` flag (or set the
-`GTEST_RANDOM_SEED` environment variable), where `SEED` is an integer
-between 0 and 99999. The seed value 0 is special: it tells Google Test
-to do the default behavior of calculating the seed from the current
-time.
-
-If you combine this with `--gtest_repeat=N`, Google Test will pick a
-different random seed and re-shuffle the tests in each iteration.
-
-_Availability:_ Linux, Windows, Mac; since v1.4.0.
-
-## Controlling Test Output ##
-
-This section teaches how to tweak the way test results are reported.
-
-### Colored Terminal Output ###
-
-Google Test can use colors in its terminal output to make it easier to spot
-the separation between tests, and whether tests passed.
-
-You can set the GTEST\_COLOR environment variable or set the `--gtest_color`
-command line flag to `yes`, `no`, or `auto` (the default) to enable colors,
-disable colors, or let Google Test decide. When the value is `auto`, Google
-Test will use colors if and only if the output goes to a terminal and (on
-non-Windows platforms) the `TERM` environment variable is set to `xterm` or
-`xterm-color`.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Suppressing the Elapsed Time ###
-
-By default, Google Test prints the time it takes to run each test.  To
-suppress that, run the test program with the `--gtest_print_time=0`
-command line flag.  Setting the `GTEST_PRINT_TIME` environment
-variable to `0` has the same effect.
-
-_Availability:_ Linux, Windows, Mac.  (In Google Test 1.3.0 and lower,
-the default behavior is that the elapsed time is **not** printed.)
-
-### Generating an XML Report ###
-
-Google Test can emit a detailed XML report to a file in addition to its normal
-textual output. The report contains the duration of each test, and thus can
-help you identify slow tests.
-
-To generate the XML report, set the `GTEST_OUTPUT` environment variable or the
-`--gtest_output` flag to the string `"xml:_path_to_output_file_"`, which will
-create the file at the given location. You can also just use the string
-`"xml"`, in which case the output can be found in the `test_detail.xml` file in
-the current directory.
-
-If you specify a directory (for example, `"xml:output/directory/"` on Linux or
-`"xml:output\directory\"` on Windows), Google Test will create the XML file in
-that directory, named after the test executable (e.g. `foo_test.xml` for test
-program `foo_test` or `foo_test.exe`). If the file already exists (perhaps left
-over from a previous run), Google Test will pick a different name (e.g.
-`foo_test_1.xml`) to avoid overwriting it.
-
-The report uses the format described here.  It is based on the
-`junitreport` Ant task and can be parsed by popular continuous build
-systems like [Hudson](https://hudson.dev.java.net/). Since that format
-was originally intended for Java, a little interpretation is required
-to make it apply to Google Test tests, as shown here:
-
-```
-<testsuites name="AllTests" ...>
-  <testsuite name="test_case_name" ...>
-    <testcase name="test_name" ...>
-      <failure message="..."/>
-      <failure message="..."/>
-      <failure message="..."/>
-    </testcase>
-  </testsuite>
-</testsuites>
-```
-
-  * The root `<testsuites>` element corresponds to the entire test program.
-  * `<testsuite>` elements correspond to Google Test test cases.
-  * `<testcase>` elements correspond to Google Test test functions.
-
-For instance, the following program
-
-```
-TEST(MathTest, Addition) { ... }
-TEST(MathTest, Subtraction) { ... }
-TEST(LogicTest, NonContradiction) { ... }
-```
-
-could generate this report:
-
-```
-<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="3" failures="1" errors="0" time="35" name="AllTests">
-  <testsuite name="MathTest" tests="2" failures="1" errors="0" time="15">
-    <testcase name="Addition" status="run" time="7" classname="">
-      <failure message="Value of: add(1, 1)&#x0A; Actual: 3&#x0A;Expected: 2" type=""/>
-      <failure message="Value of: add(1, -1)&#x0A; Actual: 1&#x0A;Expected: 0" type=""/>
-    </testcase>
-    <testcase name="Subtraction" status="run" time="5" classname="">
-    </testcase>
-  </testsuite>
-  <testsuite name="LogicTest" tests="1" failures="0" errors="0" time="5">
-    <testcase name="NonContradiction" status="run" time="5" classname="">
-    </testcase>
-  </testsuite>
-</testsuites>
-```
-
-Things to note:
-
-  * The `tests` attribute of a `<testsuites>` or `<testsuite>` element tells how many test functions the Google Test program or test case contains, while the `failures` attribute tells how many of them failed.
-  * The `time` attribute expresses the duration of the test, test case, or entire test program in milliseconds.
-  * Each `<failure>` element corresponds to a single failed Google Test assertion.
-  * Some JUnit concepts don't apply to Google Test, yet we have to conform to the DTD. Therefore you'll see some dummy elements and attributes in the report. You can safely ignore these parts.
-
-_Availability:_ Linux, Windows, Mac.
-
-## Controlling How Failures Are Reported ##
-
-### Turning Assertion Failures into Break-Points ###
-
-When running test programs under a debugger, it's very convenient if the
-debugger can catch an assertion failure and automatically drop into interactive
-mode. Google Test's _break-on-failure_ mode supports this behavior.
-
-To enable it, set the `GTEST_BREAK_ON_FAILURE` environment variable to a value
-other than `0` . Alternatively, you can use the `--gtest_break_on_failure`
-command line flag.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Disabling Catching Test-Thrown Exceptions ###
-
-Google Test can be used either with or without exceptions enabled.  If
-a test throws a C++ exception or (on Windows) a structured exception
-(SEH), by default Google Test catches it, reports it as a test
-failure, and continues with the next test method.  This maximizes the
-coverage of a test run.  Also, on Windows an uncaught exception will
-cause a pop-up window, so catching the exceptions allows you to run
-the tests automatically.
-
-When debugging the test failures, however, you may instead want the
-exceptions to be handled by the debugger, such that you can examine
-the call stack when an exception is thrown.  To achieve that, set the
-`GTEST_CATCH_EXCEPTIONS` environment variable to `0`, or use the
-`--gtest_catch_exceptions=0` flag when running the tests.
-
-**Availability**: Linux, Windows, Mac.
-
-### Letting Another Testing Framework Drive ###
-
-If you work on a project that has already been using another testing
-framework and is not ready to completely switch to Google Test yet,
-you can get much of Google Test's benefit by using its assertions in
-your existing tests.  Just change your `main()` function to look
-like:
-
-```
-#include "gtest/gtest.h"
-
-int main(int argc, char** argv) {
-  ::testing::GTEST_FLAG(throw_on_failure) = true;
-  // Important: Google Test must be initialized.
-  ::testing::InitGoogleTest(&argc, argv);
-
-  ... whatever your existing testing framework requires ...
-}
-```
-
-With that, you can use Google Test assertions in addition to the
-native assertions your testing framework provides, for example:
-
-```
-void TestFooDoesBar() {
-  Foo foo;
-  EXPECT_LE(foo.Bar(1), 100);     // A Google Test assertion.
-  CPPUNIT_ASSERT(foo.IsEmpty());  // A native assertion.
-}
-```
-
-If a Google Test assertion fails, it will print an error message and
-throw an exception, which will be treated as a failure by your host
-testing framework.  If you compile your code with exceptions disabled,
-a failed Google Test assertion will instead exit your program with a
-non-zero code, which will also signal a test failure to your test
-runner.
-
-If you don't write `::testing::GTEST_FLAG(throw_on_failure) = true;` in
-your `main()`, you can alternatively enable this feature by specifying
-the `--gtest_throw_on_failure` flag on the command-line or setting the
-`GTEST_THROW_ON_FAILURE` environment variable to a non-zero value.
-
-_Availability:_ Linux, Windows, Mac; since v1.3.0.
-
-## Distributing Test Functions to Multiple Machines ##
-
-If you have more than one machine you can use to run a test program,
-you might want to run the test functions in parallel and get the
-result faster.  We call this technique _sharding_, where each machine
-is called a _shard_.
-
-Google Test is compatible with test sharding.  To take advantage of
-this feature, your test runner (not part of Google Test) needs to do
-the following:
-
-  1. Allocate a number of machines (shards) to run the tests.
-  1. On each shard, set the `GTEST_TOTAL_SHARDS` environment variable to the total number of shards.  It must be the same for all shards.
-  1. On each shard, set the `GTEST_SHARD_INDEX` environment variable to the index of the shard.  Different shards must be assigned different indices, which must be in the range `[0, GTEST_TOTAL_SHARDS - 1]`.
-  1. Run the same test program on all shards.  When Google Test sees the above two environment variables, it will select a subset of the test functions to run.  Across all shards, each test function in the program will be run exactly once.
-  1. Wait for all shards to finish, then collect and report the results.
-
-Your project may have tests that were written without Google Test and
-thus don't understand this protocol.  In order for your test runner to
-figure out which test supports sharding, it can set the environment
-variable `GTEST_SHARD_STATUS_FILE` to a non-existent file path.  If a
-test program supports sharding, it will create this file to
-acknowledge the fact (the actual contents of the file are not
-important at this time; although we may stick some useful information
-in it in the future.); otherwise it will not create it.
-
-Here's an example to make it clear.  Suppose you have a test program
-`foo_test` that contains the following 5 test functions:
-```
-TEST(A, V)
-TEST(A, W)
-TEST(B, X)
-TEST(B, Y)
-TEST(B, Z)
-```
-and you have 3 machines at your disposal.  To run the test functions in
-parallel, you would set `GTEST_TOTAL_SHARDS` to 3 on all machines, and
-set `GTEST_SHARD_INDEX` to 0, 1, and 2 on the machines respectively.
-Then you would run the same `foo_test` on each machine.
-
-Google Test reserves the right to change how the work is distributed
-across the shards, but here's one possible scenario:
-
-  * Machine #0 runs `A.V` and `B.X`.
-  * Machine #1 runs `A.W` and `B.Y`.
-  * Machine #2 runs `B.Z`.
-
-_Availability:_ Linux, Windows, Mac; since version 1.3.0.
-
-# Fusing Google Test Source Files #
-
-Google Test's implementation consists of ~30 files (excluding its own
-tests).  Sometimes you may want them to be packaged up in two files (a
-`.h` and a `.cc`) instead, such that you can easily copy them to a new
-machine and start hacking there.  For this we provide an experimental
-Python script `fuse_gtest_files.py` in the `scripts/` directory (since release 1.3.0).
-Assuming you have Python 2.4 or above installed on your machine, just
-go to that directory and run
-```
-python fuse_gtest_files.py OUTPUT_DIR
-```
-
-and you should see an `OUTPUT_DIR` directory being created with files
-`gtest/gtest.h` and `gtest/gtest-all.cc` in it.  These files contain
-everything you need to use Google Test.  Just copy them to anywhere
-you want and you are ready to write tests.  You can use the
-[scripts/test/Makefile](../scripts/test/Makefile)
-file as an example on how to compile your tests against them.
-
-# Where to Go from Here #
-
-Congratulations! You've now learned more advanced Google Test tools and are
-ready to tackle more complex testing tasks. If you want to dive even deeper, you
-can read the [Frequently-Asked Questions](V1_6_FAQ.md).
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Documentation.md
deleted file mode 100644
index ca924660..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Documentation.md
+++ /dev/null
@@ -1,14 +0,0 @@
-This page lists all documentation wiki pages for Google Test **1.6**
--- **if you use a released version of Google Test, please read the
-documentation for that specific version instead.**
-
-  * [Primer](V1_6_Primer.md) -- start here if you are new to Google Test.
-  * [Samples](V1_6_Samples.md) -- learn from examples.
-  * [AdvancedGuide](V1_6_AdvancedGuide.md) -- learn more about Google Test.
-  * [XcodeGuide](V1_6_XcodeGuide.md) -- how to use Google Test in Xcode on Mac.
-  * [Frequently-Asked Questions](V1_6_FAQ.md) -- check here before asking a question on the mailing list.
-
-To contribute code to Google Test, read:
-
-  * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
-  * [PumpManual](V1_6_PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_FAQ.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_FAQ.md
deleted file mode 100644
index 2b7f7840..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_FAQ.md
+++ /dev/null
@@ -1,1038 +0,0 @@
-
-
-If you cannot find the answer to your question here, and you have read
-[Primer](V1_6_Primer.md) and [AdvancedGuide](V1_6_AdvancedGuide.md), send it to
-googletestframework@googlegroups.com.
-
-## Why should I use Google Test instead of my favorite C++ testing framework? ##
-
-First, let us say clearly that we don't want to get into the debate of
-which C++ testing framework is **the best**.  There exist many fine
-frameworks for writing C++ tests, and we have tremendous respect for
-the developers and users of them.  We don't think there is (or will
-be) a single best framework - you have to pick the right tool for the
-particular task you are tackling.
-
-We created Google Test because we couldn't find the right combination
-of features and conveniences in an existing framework to satisfy _our_
-needs.  The following is a list of things that _we_ like about Google
-Test.  We don't claim them to be unique to Google Test - rather, the
-combination of them makes Google Test the choice for us.  We hope this
-list can help you decide whether it is for you too.
-
-  * Google Test is designed to be portable: it doesn't require exceptions or RTTI; it works around various bugs in various compilers and environments; etc.  As a result, it works on Linux, Mac OS X, Windows and several embedded operating systems.
-  * Nonfatal assertions (`EXPECT_*`) have proven to be great time savers, as they allow a test to report multiple failures in a single edit-compile-test cycle.
-  * It's easy to write assertions that generate informative messages: you just use the stream syntax to append any additional information, e.g. `ASSERT_EQ(5, Foo(i)) << " where i = " << i;`.  It doesn't require a new set of macros or special functions.
-  * Google Test automatically detects your tests and doesn't require you to enumerate them in order to run them.
-  * Death tests are pretty handy for ensuring that your asserts in production code are triggered by the right conditions.
-  * `SCOPED_TRACE` helps you understand the context of an assertion failure when it comes from inside a sub-routine or loop.
-  * You can decide which tests to run using name patterns.  This saves time when you want to quickly reproduce a test failure.
-  * Google Test can generate XML test result reports that can be parsed by popular continuous build system like Hudson.
-  * Simple things are easy in Google Test, while hard things are possible: in addition to advanced features like [global test environments](V1_6_AdvancedGuide.md#Global_Set-Up_and_Tear-Down) and tests parameterized by [values](V1_6_AdvancedGuide.md#value-parameterized-tests) or [types](V1_6_AdvancedGuide.md#typed-tests), Google Test supports various ways for the user to extend the framework -- if Google Test doesn't do something out of the box, chances are that a user can implement the feature using Google Test's public API, without changing Google Test itself.  In particular, you can:
-    * expand your testing vocabulary by defining [custom predicates](V1_6_AdvancedGuide.md#predicate-assertions-for-better-error-messages),
-    * teach Google Test how to [print your types](V1_6_AdvancedGuide.md#teaching-google-test-how-to-print-your-values),
-    * define your own testing macros or utilities and verify them using Google Test's [Service Provider Interface](V1_6_AdvancedGuide.md#catching-failures), and
-    * reflect on the test cases or change the test output format by intercepting the [test events](V1_6_AdvancedGuide.md#extending-google-test-by-handling-test-events).
-
-## I'm getting warnings when compiling Google Test.  Would you fix them? ##
-
-We strive to minimize compiler warnings Google Test generates.  Before releasing a new version, we test to make sure that it doesn't generate warnings when compiled using its CMake script on Windows, Linux, and Mac OS.
-
-Unfortunately, this doesn't mean you are guaranteed to see no warnings when compiling Google Test in your environment:
-
-  * You may be using a different compiler as we use, or a different version of the same compiler.  We cannot possibly test for all compilers.
-  * You may be compiling on a different platform as we do.
-  * Your project may be using different compiler flags as we do.
-
-It is not always possible to make Google Test warning-free for everyone.  Or, it may not be desirable if the warning is rarely enabled and fixing the violations makes the code more complex.
-
-If you see warnings when compiling Google Test, we suggest that you use the `-isystem` flag (assuming your are using GCC) to mark Google Test headers as system headers.  That'll suppress warnings from Google Test headers.
-
-## Why should not test case names and test names contain underscore? ##
-
-Underscore (`_`) is special, as C++ reserves the following to be used by
-the compiler and the standard library:
-
-  1. any identifier that starts with an `_` followed by an upper-case letter, and
-  1. any identifier that containers two consecutive underscores (i.e. `__`) _anywhere_ in its name.
-
-User code is _prohibited_ from using such identifiers.
-
-Now let's look at what this means for `TEST` and `TEST_F`.
-
-Currently `TEST(TestCaseName, TestName)` generates a class named
-`TestCaseName_TestName_Test`.  What happens if `TestCaseName` or `TestName`
-contains `_`?
-
-  1. If `TestCaseName` starts with an `_` followed by an upper-case letter (say, `_Foo`), we end up with `_Foo_TestName_Test`, which is reserved and thus invalid.
-  1. If `TestCaseName` ends with an `_` (say, `Foo_`), we get `Foo__TestName_Test`, which is invalid.
-  1. If `TestName` starts with an `_` (say, `_Bar`), we get `TestCaseName__Bar_Test`, which is invalid.
-  1. If `TestName` ends with an `_` (say, `Bar_`), we get `TestCaseName_Bar__Test`, which is invalid.
-
-So clearly `TestCaseName` and `TestName` cannot start or end with `_`
-(Actually, `TestCaseName` can start with `_` -- as long as the `_` isn't
-followed by an upper-case letter.  But that's getting complicated.  So
-for simplicity we just say that it cannot start with `_`.).
-
-It may seem fine for `TestCaseName` and `TestName` to contain `_` in the
-middle.  However, consider this:
-```
-TEST(Time, Flies_Like_An_Arrow) { ... }
-TEST(Time_Flies, Like_An_Arrow) { ... }
-```
-
-Now, the two `TEST`s will both generate the same class
-(`Time_Files_Like_An_Arrow_Test`).  That's not good.
-
-So for simplicity, we just ask the users to avoid `_` in `TestCaseName`
-and `TestName`.  The rule is more constraining than necessary, but it's
-simple and easy to remember.  It also gives Google Test some wiggle
-room in case its implementation needs to change in the future.
-
-If you violate the rule, there may not be immediately consequences,
-but your test may (just may) break with a new compiler (or a new
-version of the compiler you are using) or with a new version of Google
-Test.  Therefore it's best to follow the rule.
-
-## Why is it not recommended to install a pre-compiled copy of Google Test (for example, into /usr/local)? ##
-
-In the early days, we said that you could install
-compiled Google Test libraries on `*`nix systems using `make install`.
-Then every user of your machine can write tests without
-recompiling Google Test.
-
-This seemed like a good idea, but it has a
-got-cha: every user needs to compile his tests using the _same_ compiler
-flags used to compile the installed Google Test libraries; otherwise
-he may run into undefined behaviors (i.e. the tests can behave
-strangely and may even crash for no obvious reasons).
-
-Why?  Because C++ has this thing called the One-Definition Rule: if
-two C++ source files contain different definitions of the same
-class/function/variable, and you link them together, you violate the
-rule.  The linker may or may not catch the error (in many cases it's
-not required by the C++ standard to catch the violation).  If it
-doesn't, you get strange run-time behaviors that are unexpected and
-hard to debug.
-
-If you compile Google Test and your test code using different compiler
-flags, they may see different definitions of the same
-class/function/variable (e.g. due to the use of `#if` in Google Test).
-Therefore, for your sanity, we recommend to avoid installing pre-compiled
-Google Test libraries.  Instead, each project should compile
-Google Test itself such that it can be sure that the same flags are
-used for both Google Test and the tests.
-
-## How do I generate 64-bit binaries on Windows (using Visual Studio 2008)? ##
-
-(Answered by Trevor Robinson)
-
-Load the supplied Visual Studio solution file, either `msvc\gtest-md.sln` or
-`msvc\gtest.sln`. Go through the migration wizard to migrate the
-solution and project files to Visual Studio 2008. Select
-`Configuration Manager...` from the `Build` menu. Select `<New...>` from
-the `Active solution platform` dropdown.  Select `x64` from the new
-platform dropdown, leave `Copy settings from` set to `Win32` and
-`Create new project platforms` checked, then click `OK`. You now have
-`Win32` and `x64` platform configurations, selectable from the
-`Standard` toolbar, which allow you to toggle between building 32-bit or
-64-bit binaries (or both at once using Batch Build).
-
-In order to prevent build output files from overwriting one another,
-you'll need to change the `Intermediate Directory` settings for the
-newly created platform configuration across all the projects. To do
-this, multi-select (e.g. using shift-click) all projects (but not the
-solution) in the `Solution Explorer`. Right-click one of them and
-select `Properties`. In the left pane, select `Configuration Properties`,
-and from the `Configuration` dropdown, select `All Configurations`.
-Make sure the selected platform is `x64`. For the
-`Intermediate Directory` setting, change the value from
-`$(PlatformName)\$(ConfigurationName)` to
-`$(OutDir)\$(ProjectName)`. Click `OK` and then build the
-solution. When the build is complete, the 64-bit binaries will be in
-the `msvc\x64\Debug` directory.
-
-## Can I use Google Test on MinGW? ##
-
-We haven't tested this ourselves, but Per Abrahamsen reported that he
-was able to compile and install Google Test successfully when using
-MinGW from Cygwin.  You'll need to configure it with:
-
-`PATH/TO/configure CC="gcc -mno-cygwin" CXX="g++ -mno-cygwin"`
-
-You should be able to replace the `-mno-cygwin` option with direct links
-to the real MinGW binaries, but we haven't tried that.
-
-Caveats:
-
-  * There are many warnings when compiling.
-  * `make check` will produce some errors as not all tests for Google Test itself are compatible with MinGW.
-
-We also have reports on successful cross compilation of Google Test
-MinGW binaries on Linux using
-[these instructions](http://wiki.wxwidgets.org/Cross-Compiling_Under_Linux#Cross-compiling_under_Linux_for_MS_Windows)
-on the WxWidgets site.
-
-Please contact `googletestframework@googlegroups.com` if you are
-interested in improving the support for MinGW.
-
-## Why does Google Test support EXPECT\_EQ(NULL, ptr) and ASSERT\_EQ(NULL, ptr) but not EXPECT\_NE(NULL, ptr) and ASSERT\_NE(NULL, ptr)? ##
-
-Due to some peculiarity of C++, it requires some non-trivial template
-meta programming tricks to support using `NULL` as an argument of the
-`EXPECT_XX()` and `ASSERT_XX()` macros. Therefore we only do it where
-it's most needed (otherwise we make the implementation of Google Test
-harder to maintain and more error-prone than necessary).
-
-The `EXPECT_EQ()` macro takes the _expected_ value as its first
-argument and the _actual_ value as the second. It's reasonable that
-someone wants to write `EXPECT_EQ(NULL, some_expression)`, and this
-indeed was requested several times. Therefore we implemented it.
-
-The need for `EXPECT_NE(NULL, ptr)` isn't nearly as strong. When the
-assertion fails, you already know that `ptr` must be `NULL`, so it
-doesn't add any information to print ptr in this case. That means
-`EXPECT_TRUE(ptr ! NULL)` works just as well.
-
-If we were to support `EXPECT_NE(NULL, ptr)`, for consistency we'll
-have to support `EXPECT_NE(ptr, NULL)` as well, as unlike `EXPECT_EQ`,
-we don't have a convention on the order of the two arguments for
-`EXPECT_NE`. This means using the template meta programming tricks
-twice in the implementation, making it even harder to understand and
-maintain. We believe the benefit doesn't justify the cost.
-
-Finally, with the growth of Google Mock's [matcher](../../CookBook.md#using-matchers-in-google-test-assertions) library, we are
-encouraging people to use the unified `EXPECT_THAT(value, matcher)`
-syntax more often in tests. One significant advantage of the matcher
-approach is that matchers can be easily combined to form new matchers,
-while the `EXPECT_NE`, etc, macros cannot be easily
-combined. Therefore we want to invest more in the matchers than in the
-`EXPECT_XX()` macros.
-
-## Does Google Test support running tests in parallel? ##
-
-Test runners tend to be tightly coupled with the build/test
-environment, and Google Test doesn't try to solve the problem of
-running tests in parallel.  Instead, we tried to make Google Test work
-nicely with test runners.  For example, Google Test's XML report
-contains the time spent on each test, and its `gtest_list_tests` and
-`gtest_filter` flags can be used for splitting the execution of test
-methods into multiple processes.  These functionalities can help the
-test runner run the tests in parallel.
-
-## Why don't Google Test run the tests in different threads to speed things up? ##
-
-It's difficult to write thread-safe code.  Most tests are not written
-with thread-safety in mind, and thus may not work correctly in a
-multi-threaded setting.
-
-If you think about it, it's already hard to make your code work when
-you know what other threads are doing.  It's much harder, and
-sometimes even impossible, to make your code work when you don't know
-what other threads are doing (remember that test methods can be added,
-deleted, or modified after your test was written).  If you want to run
-the tests in parallel, you'd better run them in different processes.
-
-## Why aren't Google Test assertions implemented using exceptions? ##
-
-Our original motivation was to be able to use Google Test in projects
-that disable exceptions.  Later we realized some additional benefits
-of this approach:
-
-  1. Throwing in a destructor is undefined behavior in C++.  Not using exceptions means Google Test's assertions are safe to use in destructors.
-  1. The `EXPECT_*` family of macros will continue even after a failure, allowing multiple failures in a `TEST` to be reported in a single run. This is a popular feature, as in C++ the edit-compile-test cycle is usually quite long and being able to fixing more than one thing at a time is a blessing.
-  1. If assertions are implemented using exceptions, a test may falsely ignore a failure if it's caught by user code:
-```
-try { ... ASSERT_TRUE(...) ... }
-catch (...) { ... }
-```
-The above code will pass even if the `ASSERT_TRUE` throws.  While it's unlikely for someone to write this in a test, it's possible to run into this pattern when you write assertions in callbacks that are called by the code under test.
-
-The downside of not using exceptions is that `ASSERT_*` (implemented
-using `return`) will only abort the current function, not the current
-`TEST`.
-
-## Why do we use two different macros for tests with and without fixtures? ##
-
-Unfortunately, C++'s macro system doesn't allow us to use the same
-macro for both cases.  One possibility is to provide only one macro
-for tests with fixtures, and require the user to define an empty
-fixture sometimes:
-
-```
-class FooTest : public ::testing::Test {};
-
-TEST_F(FooTest, DoesThis) { ... }
-```
-or
-```
-typedef ::testing::Test FooTest;
-
-TEST_F(FooTest, DoesThat) { ... }
-```
-
-Yet, many people think this is one line too many. :-) Our goal was to
-make it really easy to write tests, so we tried to make simple tests
-trivial to create.  That means using a separate macro for such tests.
-
-We think neither approach is ideal, yet either of them is reasonable.
-In the end, it probably doesn't matter much either way.
-
-## Why don't we use structs as test fixtures? ##
-
-We like to use structs only when representing passive data.  This
-distinction between structs and classes is good for documenting the
-intent of the code's author.  Since test fixtures have logic like
-`SetUp()` and `TearDown()`, they are better defined as classes.
-
-## Why are death tests implemented as assertions instead of using a test runner? ##
-
-Our goal was to make death tests as convenient for a user as C++
-possibly allows.  In particular:
-
-  * The runner-style requires to split the information into two pieces: the definition of the death test itself, and the specification for the runner on how to run the death test and what to expect.  The death test would be written in C++, while the runner spec may or may not be.  A user needs to carefully keep the two in sync. `ASSERT_DEATH(statement, expected_message)` specifies all necessary information in one place, in one language, without boilerplate code. It is very declarative.
-  * `ASSERT_DEATH` has a similar syntax and error-reporting semantics as other Google Test assertions, and thus is easy to learn.
-  * `ASSERT_DEATH` can be mixed with other assertions and other logic at your will.  You are not limited to one death test per test method. For example, you can write something like:
-```
-    if (FooCondition()) {
-      ASSERT_DEATH(Bar(), "blah");
-    } else {
-      ASSERT_EQ(5, Bar());
-    }
-```
-If you prefer one death test per test method, you can write your tests in that style too, but we don't want to impose that on the users.  The fewer artificial limitations the better.
-  * `ASSERT_DEATH` can reference local variables in the current function, and you can decide how many death tests you want based on run-time information.  For example,
-```
-    const int count = GetCount();  // Only known at run time.
-    for (int i = 1; i <= count; i++) {
-      ASSERT_DEATH({
-        double* buffer = new double[i];
-        ... initializes buffer ...
-        Foo(buffer, i)
-      }, "blah blah");
-    }
-```
-The runner-based approach tends to be more static and less flexible, or requires more user effort to get this kind of flexibility.
-
-Another interesting thing about `ASSERT_DEATH` is that it calls `fork()`
-to create a child process to run the death test.  This is lightening
-fast, as `fork()` uses copy-on-write pages and incurs almost zero
-overhead, and the child process starts from the user-supplied
-statement directly, skipping all global and local initialization and
-any code leading to the given statement.  If you launch the child
-process from scratch, it can take seconds just to load everything and
-start running if the test links to many libraries dynamically.
-
-## My death test modifies some state, but the change seems lost after the death test finishes. Why? ##
-
-Death tests (`EXPECT_DEATH`, etc) are executed in a sub-process s.t. the
-expected crash won't kill the test program (i.e. the parent process). As a
-result, any in-memory side effects they incur are observable in their
-respective sub-processes, but not in the parent process. You can think of them
-as running in a parallel universe, more or less.
-
-## The compiler complains about "undefined references" to some static const member variables, but I did define them in the class body. What's wrong? ##
-
-If your class has a static data member:
-
-```
-// foo.h
-class Foo {
-  ...
-  static const int kBar = 100;
-};
-```
-
-You also need to define it _outside_ of the class body in `foo.cc`:
-
-```
-const int Foo::kBar;  // No initializer here.
-```
-
-Otherwise your code is **invalid C++**, and may break in unexpected ways. In
-particular, using it in Google Test comparison assertions (`EXPECT_EQ`, etc)
-will generate an "undefined reference" linker error.
-
-## I have an interface that has several implementations. Can I write a set of tests once and repeat them over all the implementations? ##
-
-Google Test doesn't yet have good support for this kind of tests, or
-data-driven tests in general. We hope to be able to make improvements in this
-area soon.
-
-## Can I derive a test fixture from another? ##
-
-Yes.
-
-Each test fixture has a corresponding and same named test case. This means only
-one test case can use a particular fixture. Sometimes, however, multiple test
-cases may want to use the same or slightly different fixtures. For example, you
-may want to make sure that all of a GUI library's test cases don't leak
-important system resources like fonts and brushes.
-
-In Google Test, you share a fixture among test cases by putting the shared
-logic in a base test fixture, then deriving from that base a separate fixture
-for each test case that wants to use this common logic. You then use `TEST_F()`
-to write tests using each derived fixture.
-
-Typically, your code looks like this:
-
-```
-// Defines a base test fixture.
-class BaseTest : public ::testing::Test {
-  protected:
-   ...
-};
-
-// Derives a fixture FooTest from BaseTest.
-class FooTest : public BaseTest {
-  protected:
-    virtual void SetUp() {
-      BaseTest::SetUp();  // Sets up the base fixture first.
-      ... additional set-up work ...
-    }
-    virtual void TearDown() {
-      ... clean-up work for FooTest ...
-      BaseTest::TearDown();  // Remember to tear down the base fixture
-                             // after cleaning up FooTest!
-    }
-    ... functions and variables for FooTest ...
-};
-
-// Tests that use the fixture FooTest.
-TEST_F(FooTest, Bar) { ... }
-TEST_F(FooTest, Baz) { ... }
-
-... additional fixtures derived from BaseTest ...
-```
-
-If necessary, you can continue to derive test fixtures from a derived fixture.
-Google Test has no limit on how deep the hierarchy can be.
-
-For a complete example using derived test fixtures, see
-[sample5](../samples/sample5_unittest.cc).
-
-## My compiler complains "void value not ignored as it ought to be." What does this mean? ##
-
-You're probably using an `ASSERT_*()` in a function that doesn't return `void`.
-`ASSERT_*()` can only be used in `void` functions.
-
-## My death test hangs (or seg-faults). How do I fix it? ##
-
-In Google Test, death tests are run in a child process and the way they work is
-delicate. To write death tests you really need to understand how they work.
-Please make sure you have read this.
-
-In particular, death tests don't like having multiple threads in the parent
-process. So the first thing you can try is to eliminate creating threads
-outside of `EXPECT_DEATH()`.
-
-Sometimes this is impossible as some library you must use may be creating
-threads before `main()` is even reached. In this case, you can try to minimize
-the chance of conflicts by either moving as many activities as possible inside
-`EXPECT_DEATH()` (in the extreme case, you want to move everything inside), or
-leaving as few things as possible in it. Also, you can try to set the death
-test style to `"threadsafe"`, which is safer but slower, and see if it helps.
-
-If you go with thread-safe death tests, remember that they rerun the test
-program from the beginning in the child process. Therefore make sure your
-program can run side-by-side with itself and is deterministic.
-
-In the end, this boils down to good concurrent programming. You have to make
-sure that there is no race conditions or dead locks in your program. No silver
-bullet - sorry!
-
-## Should I use the constructor/destructor of the test fixture or the set-up/tear-down function? ##
-
-The first thing to remember is that Google Test does not reuse the
-same test fixture object across multiple tests. For each `TEST_F`,
-Google Test will create a fresh test fixture object, _immediately_
-call `SetUp()`, run the test, call `TearDown()`, and then
-_immediately_ delete the test fixture object. Therefore, there is no
-need to write a `SetUp()` or `TearDown()` function if the constructor
-or destructor already does the job.
-
-You may still want to use `SetUp()/TearDown()` in the following cases:
-  * If the tear-down operation could throw an exception, you must use `TearDown()` as opposed to the destructor, as throwing in a destructor leads to undefined behavior and usually will kill your program right away. Note that many standard libraries (like STL) may throw when exceptions are enabled in the compiler. Therefore you should prefer `TearDown()` if you want to write portable tests that work with or without exceptions.
-  * The Google Test team is considering making the assertion macros throw on platforms where exceptions are enabled (e.g. Windows, Mac OS, and Linux client-side), which will eliminate the need for the user to propagate failures from a subroutine to its caller. Therefore, you shouldn't use Google Test assertions in a destructor if your code could run on such a platform.
-  * In a constructor or destructor, you cannot make a virtual function call on this object. (You can call a method declared as virtual, but it will be statically bound.) Therefore, if you need to call a method that will be overriden in a derived class, you have to use `SetUp()/TearDown()`.
-
-## The compiler complains "no matching function to call" when I use ASSERT\_PREDn. How do I fix it? ##
-
-If the predicate function you use in `ASSERT_PRED*` or `EXPECT_PRED*` is
-overloaded or a template, the compiler will have trouble figuring out which
-overloaded version it should use. `ASSERT_PRED_FORMAT*` and
-`EXPECT_PRED_FORMAT*` don't have this problem.
-
-If you see this error, you might want to switch to
-`(ASSERT|EXPECT)_PRED_FORMAT*`, which will also give you a better failure
-message. If, however, that is not an option, you can resolve the problem by
-explicitly telling the compiler which version to pick.
-
-For example, suppose you have
-
-```
-bool IsPositive(int n) {
-  return n > 0;
-}
-bool IsPositive(double x) {
-  return x > 0;
-}
-```
-
-you will get a compiler error if you write
-
-```
-EXPECT_PRED1(IsPositive, 5);
-```
-
-However, this will work:
-
-```
-EXPECT_PRED1(*static_cast<bool (*)(int)>*(IsPositive), 5);
-```
-
-(The stuff inside the angled brackets for the `static_cast` operator is the
-type of the function pointer for the `int`-version of `IsPositive()`.)
-
-As another example, when you have a template function
-
-```
-template <typename T>
-bool IsNegative(T x) {
-  return x < 0;
-}
-```
-
-you can use it in a predicate assertion like this:
-
-```
-ASSERT_PRED1(IsNegative*<int>*, -5);
-```
-
-Things are more interesting if your template has more than one parameters. The
-following won't compile:
-
-```
-ASSERT_PRED2(*GreaterThan<int, int>*, 5, 0);
-```
-
-
-as the C++ pre-processor thinks you are giving `ASSERT_PRED2` 4 arguments,
-which is one more than expected. The workaround is to wrap the predicate
-function in parentheses:
-
-```
-ASSERT_PRED2(*(GreaterThan<int, int>)*, 5, 0);
-```
-
-
-## My compiler complains about "ignoring return value" when I call RUN\_ALL\_TESTS(). Why? ##
-
-Some people had been ignoring the return value of `RUN_ALL_TESTS()`. That is,
-instead of
-
-```
-return RUN_ALL_TESTS();
-```
-
-they write
-
-```
-RUN_ALL_TESTS();
-```
-
-This is wrong and dangerous. A test runner needs to see the return value of
-`RUN_ALL_TESTS()` in order to determine if a test has passed. If your `main()`
-function ignores it, your test will be considered successful even if it has a
-Google Test assertion failure. Very bad.
-
-To help the users avoid this dangerous bug, the implementation of
-`RUN_ALL_TESTS()` causes gcc to raise this warning, when the return value is
-ignored. If you see this warning, the fix is simple: just make sure its value
-is used as the return value of `main()`.
-
-## My compiler complains that a constructor (or destructor) cannot return a value. What's going on? ##
-
-Due to a peculiarity of C++, in order to support the syntax for streaming
-messages to an `ASSERT_*`, e.g.
-
-```
-ASSERT_EQ(1, Foo()) << "blah blah" << foo;
-```
-
-we had to give up using `ASSERT*` and `FAIL*` (but not `EXPECT*` and
-`ADD_FAILURE*`) in constructors and destructors. The workaround is to move the
-content of your constructor/destructor to a private void member function, or
-switch to `EXPECT_*()` if that works. This section in the user's guide explains
-it.
-
-## My set-up function is not called. Why? ##
-
-C++ is case-sensitive. It should be spelled as `SetUp()`.  Did you
-spell it as `Setup()`?
-
-Similarly, sometimes people spell `SetUpTestCase()` as `SetupTestCase()` and
-wonder why it's never called.
-
-## How do I jump to the line of a failure in Emacs directly? ##
-
-Google Test's failure message format is understood by Emacs and many other
-IDEs, like acme and XCode. If a Google Test message is in a compilation buffer
-in Emacs, then it's clickable. You can now hit `enter` on a message to jump to
-the corresponding source code, or use `C-x `` to jump to the next failure.
-
-## I have several test cases which share the same test fixture logic, do I have to define a new test fixture class for each of them? This seems pretty tedious. ##
-
-You don't have to. Instead of
-
-```
-class FooTest : public BaseTest {};
-
-TEST_F(FooTest, Abc) { ... }
-TEST_F(FooTest, Def) { ... }
-
-class BarTest : public BaseTest {};
-
-TEST_F(BarTest, Abc) { ... }
-TEST_F(BarTest, Def) { ... }
-```
-
-you can simply `typedef` the test fixtures:
-```
-typedef BaseTest FooTest;
-
-TEST_F(FooTest, Abc) { ... }
-TEST_F(FooTest, Def) { ... }
-
-typedef BaseTest BarTest;
-
-TEST_F(BarTest, Abc) { ... }
-TEST_F(BarTest, Def) { ... }
-```
-
-## The Google Test output is buried in a whole bunch of log messages. What do I do? ##
-
-The Google Test output is meant to be a concise and human-friendly report. If
-your test generates textual output itself, it will mix with the Google Test
-output, making it hard to read. However, there is an easy solution to this
-problem.
-
-Since most log messages go to stderr, we decided to let Google Test output go
-to stdout. This way, you can easily separate the two using redirection. For
-example:
-```
-./my_test > googletest_output.txt
-```
-
-## Why should I prefer test fixtures over global variables? ##
-
-There are several good reasons:
-  1. It's likely your test needs to change the states of its global variables. This makes it difficult to keep side effects from escaping one test and contaminating others, making debugging difficult. By using fixtures, each test has a fresh set of variables that's different (but with the same names). Thus, tests are kept independent of each other.
-  1. Global variables pollute the global namespace.
-  1. Test fixtures can be reused via subclassing, which cannot be done easily with global variables. This is useful if many test cases have something in common.
-
-## How do I test private class members without writing FRIEND\_TEST()s? ##
-
-You should try to write testable code, which means classes should be easily
-tested from their public interface. One way to achieve this is the Pimpl idiom:
-you move all private members of a class into a helper class, and make all
-members of the helper class public.
-
-You have several other options that don't require using `FRIEND_TEST`:
-  * Write the tests as members of the fixture class:
-```
-class Foo {
-  friend class FooTest;
-  ...
-};
-
-class FooTest : public ::testing::Test {
- protected:
-  ...
-  void Test1() {...} // This accesses private members of class Foo.
-  void Test2() {...} // So does this one.
-};
-
-TEST_F(FooTest, Test1) {
-  Test1();
-}
-
-TEST_F(FooTest, Test2) {
-  Test2();
-}
-```
-  * In the fixture class, write accessors for the tested class' private members, then use the accessors in your tests:
-```
-class Foo {
-  friend class FooTest;
-  ...
-};
-
-class FooTest : public ::testing::Test {
- protected:
-  ...
-  T1 get_private_member1(Foo* obj) {
-    return obj->private_member1_;
-  }
-};
-
-TEST_F(FooTest, Test1) {
-  ...
-  get_private_member1(x)
-  ...
-}
-```
-  * If the methods are declared **protected**, you can change their access level in a test-only subclass:
-```
-class YourClass {
-  ...
- protected: // protected access for testability.
-  int DoSomethingReturningInt();
-  ...
-};
-
-// in the your_class_test.cc file:
-class TestableYourClass : public YourClass {
-  ...
- public: using YourClass::DoSomethingReturningInt; // changes access rights
-  ...
-};
-
-TEST_F(YourClassTest, DoSomethingTest) {
-  TestableYourClass obj;
-  assertEquals(expected_value, obj.DoSomethingReturningInt());
-}
-```
-
-## How do I test private class static members without writing FRIEND\_TEST()s? ##
-
-We find private static methods clutter the header file.  They are
-implementation details and ideally should be kept out of a .h. So often I make
-them free functions instead.
-
-Instead of:
-```
-// foo.h
-class Foo {
-  ...
- private:
-  static bool Func(int n);
-};
-
-// foo.cc
-bool Foo::Func(int n) { ... }
-
-// foo_test.cc
-EXPECT_TRUE(Foo::Func(12345));
-```
-
-You probably should better write:
-```
-// foo.h
-class Foo {
-  ...
-};
-
-// foo.cc
-namespace internal {
-  bool Func(int n) { ... }
-}
-
-// foo_test.cc
-namespace internal {
-  bool Func(int n);
-}
-
-EXPECT_TRUE(internal::Func(12345));
-```
-
-## I would like to run a test several times with different parameters. Do I need to write several similar copies of it? ##
-
-No. You can use a feature called [value-parameterized tests](V1_6_AdvancedGuide.md#Value_Parameterized_Tests) which
-lets you repeat your tests with different parameters, without defining it more than once.
-
-## How do I test a file that defines main()? ##
-
-To test a `foo.cc` file, you need to compile and link it into your unit test
-program. However, when the file contains a definition for the `main()`
-function, it will clash with the `main()` of your unit test, and will result in
-a build error.
-
-The right solution is to split it into three files:
-  1. `foo.h` which contains the declarations,
-  1. `foo.cc` which contains the definitions except `main()`, and
-  1. `foo_main.cc` which contains nothing but the definition of `main()`.
-
-Then `foo.cc` can be easily tested.
-
-If you are adding tests to an existing file and don't want an intrusive change
-like this, there is a hack: just include the entire `foo.cc` file in your unit
-test. For example:
-```
-// File foo_unittest.cc
-
-// The headers section
-...
-
-// Renames main() in foo.cc to make room for the unit test main()
-#define main FooMain
-
-#include "a/b/foo.cc"
-
-// The tests start here.
-...
-```
-
-
-However, please remember this is a hack and should only be used as the last
-resort.
-
-## What can the statement argument in ASSERT\_DEATH() be? ##
-
-`ASSERT_DEATH(_statement_, _regex_)` (or any death assertion macro) can be used
-wherever `_statement_` is valid. So basically `_statement_` can be any C++
-statement that makes sense in the current context. In particular, it can
-reference global and/or local variables, and can be:
-  * a simple function call (often the case),
-  * a complex expression, or
-  * a compound statement.
-
-> Some examples are shown here:
-
-```
-// A death test can be a simple function call.
-TEST(MyDeathTest, FunctionCall) {
-  ASSERT_DEATH(Xyz(5), "Xyz failed");
-}
-
-// Or a complex expression that references variables and functions.
-TEST(MyDeathTest, ComplexExpression) {
-  const bool c = Condition();
-  ASSERT_DEATH((c ? Func1(0) : object2.Method("test")),
-               "(Func1|Method) failed");
-}
-
-// Death assertions can be used any where in a function. In
-// particular, they can be inside a loop.
-TEST(MyDeathTest, InsideLoop) {
-  // Verifies that Foo(0), Foo(1), ..., and Foo(4) all die.
-  for (int i = 0; i < 5; i++) {
-    EXPECT_DEATH_M(Foo(i), "Foo has \\d+ errors",
-                   ::testing::Message() << "where i is " << i);
-  }
-}
-
-// A death assertion can contain a compound statement.
-TEST(MyDeathTest, CompoundStatement) {
-  // Verifies that at lease one of Bar(0), Bar(1), ..., and
-  // Bar(4) dies.
-  ASSERT_DEATH({
-    for (int i = 0; i < 5; i++) {
-      Bar(i);
-    }
-  },
-  "Bar has \\d+ errors");}
-```
-
-`googletest_unittest.cc` contains more examples if you are interested.
-
-## What syntax does the regular expression in ASSERT\_DEATH use? ##
-
-On POSIX systems, Google Test uses the POSIX Extended regular
-expression syntax
-(http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
-On Windows, it uses a limited variant of regular expression
-syntax. For more details, see the
-[regular expression syntax](V1_6_AdvancedGuide.md#Regular_Expression_Syntax).
-
-## I have a fixture class Foo, but TEST\_F(Foo, Bar) gives me error "no matching function for call to Foo::Foo()". Why? ##
-
-Google Test needs to be able to create objects of your test fixture class, so
-it must have a default constructor. Normally the compiler will define one for
-you. However, there are cases where you have to define your own:
-  * If you explicitly declare a non-default constructor for class `Foo`, then you need to define a default constructor, even if it would be empty.
-  * If `Foo` has a const non-static data member, then you have to define the default constructor _and_ initialize the const member in the initializer list of the constructor. (Early versions of `gcc` doesn't force you to initialize the const member. It's a bug that has been fixed in `gcc 4`.)
-
-## Why does ASSERT\_DEATH complain about previous threads that were already joined? ##
-
-With the Linux pthread library, there is no turning back once you cross the
-line from single thread to multiple threads. The first time you create a
-thread, a manager thread is created in addition, so you get 3, not 2, threads.
-Later when the thread you create joins the main thread, the thread count
-decrements by 1, but the manager thread will never be killed, so you still have
-2 threads, which means you cannot safely run a death test.
-
-The new NPTL thread library doesn't suffer from this problem, as it doesn't
-create a manager thread. However, if you don't control which machine your test
-runs on, you shouldn't depend on this.
-
-## Why does Google Test require the entire test case, instead of individual tests, to be named FOODeathTest when it uses ASSERT\_DEATH? ##
-
-Google Test does not interleave tests from different test cases. That is, it
-runs all tests in one test case first, and then runs all tests in the next test
-case, and so on. Google Test does this because it needs to set up a test case
-before the first test in it is run, and tear it down afterwords. Splitting up
-the test case would require multiple set-up and tear-down processes, which is
-inefficient and makes the semantics unclean.
-
-If we were to determine the order of tests based on test name instead of test
-case name, then we would have a problem with the following situation:
-
-```
-TEST_F(FooTest, AbcDeathTest) { ... }
-TEST_F(FooTest, Uvw) { ... }
-
-TEST_F(BarTest, DefDeathTest) { ... }
-TEST_F(BarTest, Xyz) { ... }
-```
-
-Since `FooTest.AbcDeathTest` needs to run before `BarTest.Xyz`, and we don't
-interleave tests from different test cases, we need to run all tests in the
-`FooTest` case before running any test in the `BarTest` case. This contradicts
-with the requirement to run `BarTest.DefDeathTest` before `FooTest.Uvw`.
-
-## But I don't like calling my entire test case FOODeathTest when it contains both death tests and non-death tests. What do I do? ##
-
-You don't have to, but if you like, you may split up the test case into
-`FooTest` and `FooDeathTest`, where the names make it clear that they are
-related:
-
-```
-class FooTest : public ::testing::Test { ... };
-
-TEST_F(FooTest, Abc) { ... }
-TEST_F(FooTest, Def) { ... }
-
-typedef FooTest FooDeathTest;
-
-TEST_F(FooDeathTest, Uvw) { ... EXPECT_DEATH(...) ... }
-TEST_F(FooDeathTest, Xyz) { ... ASSERT_DEATH(...) ... }
-```
-
-## The compiler complains about "no match for 'operator<<'" when I use an assertion. What gives? ##
-
-If you use a user-defined type `FooType` in an assertion, you must make sure
-there is an `std::ostream& operator<<(std::ostream&, const FooType&)` function
-defined such that we can print a value of `FooType`.
-
-In addition, if `FooType` is declared in a name space, the `<<` operator also
-needs to be defined in the _same_ name space.
-
-## How do I suppress the memory leak messages on Windows? ##
-
-Since the statically initialized Google Test singleton requires allocations on
-the heap, the Visual C++ memory leak detector will report memory leaks at the
-end of the program run. The easiest way to avoid this is to use the
-`_CrtMemCheckpoint` and `_CrtMemDumpAllObjectsSince` calls to not report any
-statically initialized heap objects. See MSDN for more details and additional
-heap check/debug routines.
-
-## I am building my project with Google Test in Visual Studio and all I'm getting is a bunch of linker errors (or warnings). Help! ##
-
-You may get a number of the following linker error or warnings if you
-attempt to link your test project with the Google Test library when
-your project and the are not built using the same compiler settings.
-
-  * LNK2005: symbol already defined in object
-  * LNK4217: locally defined symbol 'symbol' imported in function 'function'
-  * LNK4049: locally defined symbol 'symbol' imported
-
-The Google Test project (gtest.vcproj) has the Runtime Library option
-set to /MT (use multi-threaded static libraries, /MTd for debug). If
-your project uses something else, for example /MD (use multi-threaded
-DLLs, /MDd for debug), you need to change the setting in the Google
-Test project to match your project's.
-
-To update this setting open the project properties in the Visual
-Studio IDE then select the branch Configuration Properties | C/C++ |
-Code Generation and change the option "Runtime Library".  You may also try
-using gtest-md.vcproj instead of gtest.vcproj.
-
-## I put my tests in a library and Google Test doesn't run them. What's happening? ##
-Have you read a
-[warning](V1_6_Primer.md#important-note-for-visual-c-users) on
-the Google Test Primer page?
-
-## I want to use Google Test with Visual Studio but don't know where to start. ##
-Many people are in your position and one of the posted his solution to
-our mailing list. Here is his link:
-http://hassanjamilahmad.blogspot.com/2009/07/gtest-starters-help.html.
-
-## I am seeing compile errors mentioning std::type\_traits when I try to use Google Test on Solaris. ##
-Google Test uses parts of the standard C++ library that SunStudio does not support.
-Our users reported success using alternative implementations. Try running the build after runing this commad:
-
-`export CC=cc CXX=CC CXXFLAGS='-library=stlport4'`
-
-## How can my code detect if it is running in a test? ##
-
-If you write code that sniffs whether it's running in a test and does
-different things accordingly, you are leaking test-only logic into
-production code and there is no easy way to ensure that the test-only
-code paths aren't run by mistake in production.  Such cleverness also
-leads to
-[Heisenbugs](http://en.wikipedia.org/wiki/Unusual_software_bug#Heisenbug).
-Therefore we strongly advise against the practice, and Google Test doesn't
-provide a way to do it.
-
-In general, the recommended way to cause the code to behave
-differently under test is [dependency injection](http://jamesshore.com/Blog/Dependency-Injection-Demystified.html).
-You can inject different functionality from the test and from the
-production code.  Since your production code doesn't link in the
-for-test logic at all, there is no danger in accidentally running it.
-
-However, if you _really_, _really_, _really_ have no choice, and if
-you follow the rule of ending your test program names with `_test`,
-you can use the _horrible_ hack of sniffing your executable name
-(`argv[0]` in `main()`) to know whether the code is under test.
-
-## Google Test defines a macro that clashes with one defined by another library. How do I deal with that? ##
-
-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 Google Test macro clashes with another
-library, you can force Google Test to rename its macro to avoid the
-conflict.
-
-Specifically, if both Google Test and some other code define macro
-`FOO`, you can add
-```
-  -DGTEST_DONT_DEFINE_FOO=1
-```
-to the compiler flags to tell Google Test to change the macro's name
-from `FOO` to `GTEST_FOO`. 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.
-
-Currently, the following `TEST`, `FAIL`, `SUCCEED`, and the basic comparison assertion macros can have alternative names. You can see the full list of covered macros [here](http://www.google.com/codesearch?q=if+!GTEST_DONT_DEFINE_\w%2B+package:http://googletest\.googlecode\.com+file:/include/gtest/gtest.h). More information can be found in the "Avoiding Macro Name Clashes" section of the README file.
-
-## My question is not covered in your FAQ! ##
-
-If you cannot find the answer to your question in this FAQ, there are
-some other resources you can use:
-
-  1. read other [wiki pages](http://code.google.com/p/googletest/w/list),
-  1. search the mailing list [archive](http://groups.google.com/group/googletestframework/topics),
-  1. ask it on [googletestframework@googlegroups.com](mailto:googletestframework@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googletestframework) before you can post.).
-
-Please note that creating an issue in the
-[issue tracker](http://code.google.com/p/googletest/issues/list) is _not_
-a good way to get your answer, as it is monitored infrequently by a
-very small number of people.
-
-When asking a question, it's helpful to provide as much of the
-following information as possible (people cannot help you if there's
-not enough information in your question):
-
-  * the version (or the revision number if you check out from SVN directly) of Google Test you use (Google Test is under active development, so it's possible that your problem has been solved in a later version),
-  * your operating system,
-  * the name and version of your compiler,
-  * the complete command line flags you give to your compiler,
-  * the complete compiler error messages (if the question is about compilation),
-  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Primer.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Primer.md
deleted file mode 100644
index 8d840ef4..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Primer.md
+++ /dev/null
@@ -1,501 +0,0 @@
-
-
-# Introduction: Why Google C++ Testing Framework? #
-
-_Google C++ Testing Framework_ helps you write better C++ tests.
-
-No matter whether you work on Linux, Windows, or a Mac, if you write C++ code,
-Google Test can help you.
-
-So what makes a good test, and how does Google C++ Testing Framework fit in? We believe:
-  1. Tests should be _independent_ and _repeatable_. It's a pain to debug a test that succeeds or fails as a result of other tests.  Google C++ Testing Framework isolates the tests by running each of them on a different object. When a test fails, Google C++ Testing Framework allows you to run it in isolation for quick debugging.
-  1. Tests should be well _organized_ and reflect the structure of the tested code.  Google C++ Testing Framework groups related tests into test cases that can share data and subroutines. This common pattern is easy to recognize and makes tests easy to maintain. Such consistency is especially helpful when people switch projects and start to work on a new code base.
-  1. Tests should be _portable_ and _reusable_. The open-source community has a lot of code that is platform-neutral, its tests should also be platform-neutral.  Google C++ Testing Framework works on different OSes, with different compilers (gcc, MSVC, and others), with or without exceptions, so Google C++ Testing Framework tests can easily work with a variety of configurations.  (Note that the current release only contains build scripts for Linux - we are actively working on scripts for other platforms.)
-  1. When tests fail, they should provide as much _information_ about the problem as possible. Google C++ Testing Framework doesn't stop at the first test failure. Instead, it only stops the current test and continues with the next. You can also set up tests that report non-fatal failures after which the current test continues. Thus, you can detect and fix multiple bugs in a single run-edit-compile cycle.
-  1. The testing framework should liberate test writers from housekeeping chores and let them focus on the test _content_.  Google C++ Testing Framework automatically keeps track of all tests defined, and doesn't require the user to enumerate them in order to run them.
-  1. Tests should be _fast_. With Google C++ Testing Framework, you can reuse shared resources across tests and pay for the set-up/tear-down only once, without making tests depend on each other.
-
-Since Google C++ Testing Framework is based on the popular xUnit
-architecture, you'll feel right at home if you've used JUnit or PyUnit before.
-If not, it will take you about 10 minutes to learn the basics and get started.
-So let's go!
-
-_Note:_ We sometimes refer to Google C++ Testing Framework informally
-as _Google Test_.
-
-# Setting up a New Test Project #
-
-To write a test program using Google Test, you need to compile Google
-Test into a library and link your test with it.  We provide build
-files for some popular build systems: `msvc/` for Visual Studio,
-`xcode/` for Mac Xcode, `make/` for GNU make, `codegear/` for Borland
-C++ Builder, and the autotools script (deprecated) and
-`CMakeLists.txt` for CMake (recommended) in the Google Test root
-directory.  If your build system is not on this list, you can take a
-look at `make/Makefile` to learn how Google Test should be compiled
-(basically you want to compile `src/gtest-all.cc` with `GTEST_ROOT`
-and `GTEST_ROOT/include` in the header search path, where `GTEST_ROOT`
-is the Google Test root directory).
-
-Once you are able to compile the Google Test library, you should
-create a project or build target for your test program.  Make sure you
-have `GTEST_ROOT/include` in the header search path so that the
-compiler can find `"gtest/gtest.h"` when compiling your test.  Set up
-your test project to link with the Google Test library (for example,
-in Visual Studio, this is done by adding a dependency on
-`gtest.vcproj`).
-
-If you still have questions, take a look at how Google Test's own
-tests are built and use them as examples.
-
-# Basic Concepts #
-
-When using Google Test, you start by writing _assertions_, which are statements
-that check whether a condition is true. An assertion's result can be _success_,
-_nonfatal failure_, or _fatal failure_. If a fatal failure occurs, it aborts
-the current function; otherwise the program continues normally.
-
-_Tests_ use assertions to verify the tested code's behavior. If a test crashes
-or has a failed assertion, then it _fails_; otherwise it _succeeds_.
-
-A _test case_ contains one or many tests. You should group your tests into test
-cases that reflect the structure of the tested code. When multiple tests in a
-test case need to share common objects and subroutines, you can put them into a
-_test fixture_ class.
-
-A _test program_ can contain multiple test cases.
-
-We'll now explain how to write a test program, starting at the individual
-assertion level and building up to tests and test cases.
-
-# Assertions #
-
-Google Test assertions are macros that resemble function calls. You test a
-class or function by making assertions about its behavior. When an assertion
-fails, Google Test prints the assertion's source file and line number location,
-along with a failure message. You may also supply a custom failure message
-which will be appended to Google Test's message.
-
-The assertions come in pairs that test the same thing but have different
-effects on the current function. `ASSERT_*` versions generate fatal failures
-when they fail, and **abort the current function**. `EXPECT_*` versions generate
-nonfatal failures, which don't abort the current function. Usually `EXPECT_*`
-are preferred, as they allow more than one failures to be reported in a test.
-However, you should use `ASSERT_*` if it doesn't make sense to continue when
-the assertion in question fails.
-
-Since a failed `ASSERT_*` returns from the current function immediately,
-possibly skipping clean-up code that comes after it, it may cause a space leak.
-Depending on the nature of the leak, it may or may not be worth fixing - so
-keep this in mind if you get a heap checker error in addition to assertion
-errors.
-
-To provide a custom failure message, simply stream it into the macro using the
-`<<` operator, or a sequence of such operators. An example:
-```
-ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length";
-
-for (int i = 0; i < x.size(); ++i) {
-  EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i;
-}
-```
-
-Anything that can be streamed to an `ostream` can be streamed to an assertion
-macro--in particular, C strings and `string` objects. If a wide string
-(`wchar_t*`, `TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is
-streamed to an assertion, it will be translated to UTF-8 when printed.
-
-## Basic Assertions ##
-
-These assertions do basic true/false condition testing.
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_TRUE(`_condition_`)`;  | `EXPECT_TRUE(`_condition_`)`;   | _condition_ is true |
-| `ASSERT_FALSE(`_condition_`)`; | `EXPECT_FALSE(`_condition_`)`;  | _condition_ is false |
-
-Remember, when they fail, `ASSERT_*` yields a fatal failure and
-returns from the current function, while `EXPECT_*` yields a nonfatal
-failure, allowing the function to continue running. In either case, an
-assertion failure means its containing test fails.
-
-_Availability_: Linux, Windows, Mac.
-
-## Binary Comparison ##
-
-This section describes assertions that compare two values.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-|`ASSERT_EQ(`_expected_`, `_actual_`);`|`EXPECT_EQ(`_expected_`, `_actual_`);`| _expected_ `==` _actual_ |
-|`ASSERT_NE(`_val1_`, `_val2_`);`      |`EXPECT_NE(`_val1_`, `_val2_`);`      | _val1_ `!=` _val2_ |
-|`ASSERT_LT(`_val1_`, `_val2_`);`      |`EXPECT_LT(`_val1_`, `_val2_`);`      | _val1_ `<` _val2_ |
-|`ASSERT_LE(`_val1_`, `_val2_`);`      |`EXPECT_LE(`_val1_`, `_val2_`);`      | _val1_ `<=` _val2_ |
-|`ASSERT_GT(`_val1_`, `_val2_`);`      |`EXPECT_GT(`_val1_`, `_val2_`);`      | _val1_ `>` _val2_ |
-|`ASSERT_GE(`_val1_`, `_val2_`);`      |`EXPECT_GE(`_val1_`, `_val2_`);`      | _val1_ `>=` _val2_ |
-
-In the event of a failure, Google Test prints both _val1_ and _val2_
-. In `ASSERT_EQ*` and `EXPECT_EQ*` (and all other equality assertions
-we'll introduce later), you should put the expression you want to test
-in the position of _actual_, and put its expected value in _expected_,
-as Google Test's failure messages are optimized for this convention.
-
-Value arguments must be comparable by the assertion's comparison
-operator or you'll get a compiler error.  We used to require the
-arguments to support the `<<` operator for streaming to an `ostream`,
-but it's no longer necessary since v1.6.0 (if `<<` is supported, it
-will be called to print the arguments when the assertion fails;
-otherwise Google Test will attempt to print them in the best way it
-can. For more details and how to customize the printing of the
-arguments, see this Google Mock [recipe](../../googlemock/docs/CookBook.md#teaching-google-mock-how-to-print-your-values).).
-
-These assertions can work with a user-defined type, but only if you define the
-corresponding comparison operator (e.g. `==`, `<`, etc).  If the corresponding
-operator is defined, prefer using the `ASSERT_*()` macros because they will
-print out not only the result of the comparison, but the two operands as well.
-
-Arguments are always evaluated exactly once. Therefore, it's OK for the
-arguments to have side effects. However, as with any ordinary C/C++ function,
-the arguments' evaluation order is undefined (i.e. the compiler is free to
-choose any order) and your code should not depend on any particular argument
-evaluation order.
-
-`ASSERT_EQ()` does pointer equality on pointers. If used on two C strings, it
-tests if they are in the same memory location, not if they have the same value.
-Therefore, if you want to compare C strings (e.g. `const char*`) by value, use
-`ASSERT_STREQ()` , which will be described later on. In particular, to assert
-that a C string is `NULL`, use `ASSERT_STREQ(NULL, c_string)` . However, to
-compare two `string` objects, you should use `ASSERT_EQ`.
-
-Macros in this section work with both narrow and wide string objects (`string`
-and `wstring`).
-
-_Availability_: Linux, Windows, Mac.
-
-## String Comparison ##
-
-The assertions in this group compare two **C strings**. If you want to compare
-two `string` objects, use `EXPECT_EQ`, `EXPECT_NE`, and etc instead.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_STREQ(`_expected\_str_`, `_actual\_str_`);`    | `EXPECT_STREQ(`_expected\_str_`, `_actual\_str_`);`     | the two C strings have the same content |
-| `ASSERT_STRNE(`_str1_`, `_str2_`);`    | `EXPECT_STRNE(`_str1_`, `_str2_`);`     | the two C strings have different content |
-| `ASSERT_STRCASEEQ(`_expected\_str_`, `_actual\_str_`);`| `EXPECT_STRCASEEQ(`_expected\_str_`, `_actual\_str_`);` | the two C strings have the same content, ignoring case |
-| `ASSERT_STRCASENE(`_str1_`, `_str2_`);`| `EXPECT_STRCASENE(`_str1_`, `_str2_`);` | the two C strings have different content, ignoring case |
-
-Note that "CASE" in an assertion name means that case is ignored.
-
-`*STREQ*` and `*STRNE*` also accept wide C strings (`wchar_t*`). If a
-comparison of two wide strings fails, their values will be printed as UTF-8
-narrow strings.
-
-A `NULL` pointer and an empty string are considered _different_.
-
-_Availability_: Linux, Windows, Mac.
-
-See also: For more string comparison tricks (substring, prefix, suffix, and
-regular expression matching, for example), see the [Advanced Google Test Guide](V1_6_AdvancedGuide.md).
-
-# Simple Tests #
-
-To create a test:
-  1. Use the `TEST()` macro to define and name a test function, These are ordinary C++ functions that don't return a value.
-  1. In this function, along with any valid C++ statements you want to include, use the various Google Test assertions to check values.
-  1. The test's result is determined by the assertions; if any assertion in the test fails (either fatally or non-fatally), or if the test crashes, the entire test fails. Otherwise, it succeeds.
-
-```
-TEST(test_case_name, test_name) {
- ... test body ...
-}
-```
-
-
-`TEST()` arguments go from general to specific. The _first_ argument is the
-name of the test case, and the _second_ argument is the test's name within the
-test case. Both names must be valid C++ identifiers, and they should not contain underscore (`_`). A test's _full name_ consists of its containing test case and its
-individual name. Tests from different test cases can have the same individual
-name.
-
-For example, let's take a simple integer function:
-```
-int Factorial(int n); // Returns the factorial of n
-```
-
-A test case for this function might look like:
-```
-// Tests factorial of 0.
-TEST(FactorialTest, HandlesZeroInput) {
-  EXPECT_EQ(1, Factorial(0));
-}
-
-// Tests factorial of positive numbers.
-TEST(FactorialTest, HandlesPositiveInput) {
-  EXPECT_EQ(1, Factorial(1));
-  EXPECT_EQ(2, Factorial(2));
-  EXPECT_EQ(6, Factorial(3));
-  EXPECT_EQ(40320, Factorial(8));
-}
-```
-
-Google Test groups the test results by test cases, so logically-related tests
-should be in the same test case; in other words, the first argument to their
-`TEST()` should be the same. In the above example, we have two tests,
-`HandlesZeroInput` and `HandlesPositiveInput`, that belong to the same test
-case `FactorialTest`.
-
-_Availability_: Linux, Windows, Mac.
-
-# Test Fixtures: Using the Same Data Configuration for Multiple Tests #
-
-If you find yourself writing two or more tests that operate on similar data,
-you can use a _test fixture_. It allows you to reuse the same configuration of
-objects for several different tests.
-
-To create a fixture, just:
-  1. Derive a class from `::testing::Test` . Start its body with `protected:` or `public:` as we'll want to access fixture members from sub-classes.
-  1. Inside the class, declare any objects you plan to use.
-  1. If necessary, write a default constructor or `SetUp()` function to prepare the objects for each test. A common mistake is to spell `SetUp()` as `Setup()` with a small `u` - don't let that happen to you.
-  1. If necessary, write a destructor or `TearDown()` function to release any resources you allocated in `SetUp()` . To learn when you should use the constructor/destructor and when you should use `SetUp()/TearDown()`, read this [FAQ entry](V1_6_FAQ.md#should-i-use-the-constructordestructor-of-the-test-fixture-or-the-set-uptear-down-function).
-  1. If needed, define subroutines for your tests to share.
-
-When using a fixture, use `TEST_F()` instead of `TEST()` as it allows you to
-access objects and subroutines in the test fixture:
-```
-TEST_F(test_case_name, test_name) {
- ... test body ...
-}
-```
-
-Like `TEST()`, the first argument is the test case name, but for `TEST_F()`
-this must be the name of the test fixture class. You've probably guessed: `_F`
-is for fixture.
-
-Unfortunately, the C++ macro system does not allow us to create a single macro
-that can handle both types of tests. Using the wrong macro causes a compiler
-error.
-
-Also, you must first define a test fixture class before using it in a
-`TEST_F()`, or you'll get the compiler error "`virtual outside class
-declaration`".
-
-For each test defined with `TEST_F()`, Google Test will:
-  1. Create a _fresh_ test fixture at runtime
-  1. Immediately initialize it via `SetUp()` ,
-  1. Run the test
-  1. Clean up by calling `TearDown()`
-  1. Delete the test fixture.  Note that different tests in the same test case have different test fixture objects, and Google Test always deletes a test fixture before it creates the next one. Google Test does not reuse the same test fixture for multiple tests. Any changes one test makes to the fixture do not affect other tests.
-
-As an example, let's write tests for a FIFO queue class named `Queue`, which
-has the following interface:
-```
-template <typename E> // E is the element type.
-class Queue {
- public:
-  Queue();
-  void Enqueue(const E& element);
-  E* Dequeue(); // Returns NULL if the queue is empty.
-  size_t size() const;
-  ...
-};
-```
-
-First, define a fixture class. By convention, you should give it the name
-`FooTest` where `Foo` is the class being tested.
-```
-class QueueTest : public ::testing::Test {
- protected:
-  virtual void SetUp() {
-    q1_.Enqueue(1);
-    q2_.Enqueue(2);
-    q2_.Enqueue(3);
-  }
-
-  // virtual void TearDown() {}
-
-  Queue<int> q0_;
-  Queue<int> q1_;
-  Queue<int> q2_;
-};
-```
-
-In this case, `TearDown()` is not needed since we don't have to clean up after
-each test, other than what's already done by the destructor.
-
-Now we'll write tests using `TEST_F()` and this fixture.
-```
-TEST_F(QueueTest, IsEmptyInitially) {
-  EXPECT_EQ(0, q0_.size());
-}
-
-TEST_F(QueueTest, DequeueWorks) {
-  int* n = q0_.Dequeue();
-  EXPECT_EQ(NULL, n);
-
-  n = q1_.Dequeue();
-  ASSERT_TRUE(n != NULL);
-  EXPECT_EQ(1, *n);
-  EXPECT_EQ(0, q1_.size());
-  delete n;
-
-  n = q2_.Dequeue();
-  ASSERT_TRUE(n != NULL);
-  EXPECT_EQ(2, *n);
-  EXPECT_EQ(1, q2_.size());
-  delete n;
-}
-```
-
-The above uses both `ASSERT_*` and `EXPECT_*` assertions. The rule of thumb is
-to use `EXPECT_*` when you want the test to continue to reveal more errors
-after the assertion failure, and use `ASSERT_*` when continuing after failure
-doesn't make sense. For example, the second assertion in the `Dequeue` test is
-`ASSERT_TRUE(n != NULL)`, as we need to dereference the pointer `n` later,
-which would lead to a segfault when `n` is `NULL`.
-
-When these tests run, the following happens:
-  1. Google Test constructs a `QueueTest` object (let's call it `t1` ).
-  1. `t1.SetUp()` initializes `t1` .
-  1. The first test ( `IsEmptyInitially` ) runs on `t1` .
-  1. `t1.TearDown()` cleans up after the test finishes.
-  1. `t1` is destructed.
-  1. The above steps are repeated on another `QueueTest` object, this time running the `DequeueWorks` test.
-
-_Availability_: Linux, Windows, Mac.
-
-_Note_: Google Test automatically saves all _Google Test_ flags when a test
-object is constructed, and restores them when it is destructed.
-
-# Invoking the Tests #
-
-`TEST()` and `TEST_F()` implicitly register their tests with Google Test. So, unlike with many other C++ testing frameworks, you don't have to re-list all your defined tests in order to run them.
-
-After defining your tests, you can run them with `RUN_ALL_TESTS()` , which returns `0` if all the tests are successful, or `1` otherwise. Note that `RUN_ALL_TESTS()` runs _all tests_ in your link unit -- they can be from different test cases, or even different source files.
-
-When invoked, the `RUN_ALL_TESTS()` macro:
-  1. Saves the state of all  Google Test flags.
-  1. Creates a test fixture object for the first test.
-  1. Initializes it via `SetUp()`.
-  1. Runs the test on the fixture object.
-  1. Cleans up the fixture via `TearDown()`.
-  1. Deletes the fixture.
-  1. Restores the state of all Google Test flags.
-  1. Repeats the above steps for the next test, until all tests have run.
-
-In addition, if the text fixture's constructor generates a fatal failure in
-step 2, there is no point for step 3 - 5 and they are thus skipped. Similarly,
-if step 3 generates a fatal failure, step 4 will be skipped.
-
-_Important_: You must not ignore the return value of `RUN_ALL_TESTS()`, or `gcc`
-will give you a compiler error. The rationale for this design is that the
-automated testing service determines whether a test has passed based on its
-exit code, not on its stdout/stderr output; thus your `main()` function must
-return the value of `RUN_ALL_TESTS()`.
-
-Also, you should call `RUN_ALL_TESTS()` only **once**. Calling it more than once
-conflicts with some advanced Google Test features (e.g. thread-safe death
-tests) and thus is not supported.
-
-_Availability_: Linux, Windows, Mac.
-
-# Writing the main() Function #
-
-You can start from this boilerplate:
-```
-#include "this/package/foo.h"
-#include "gtest/gtest.h"
-
-namespace {
-
-// The fixture for testing class Foo.
-class FooTest : public ::testing::Test {
- protected:
-  // You can remove any or all of the following functions if its body
-  // is empty.
-
-  FooTest() {
-    // You can do set-up work for each test here.
-  }
-
-  virtual ~FooTest() {
-    // You can do clean-up work that doesn't throw exceptions here.
-  }
-
-  // If the constructor and destructor are not enough for setting up
-  // and cleaning up each test, you can define the following methods:
-
-  virtual void SetUp() {
-    // Code here will be called immediately after the constructor (right
-    // before each test).
-  }
-
-  virtual void TearDown() {
-    // Code here will be called immediately after each test (right
-    // before the destructor).
-  }
-
-  // Objects declared here can be used by all tests in the test case for Foo.
-};
-
-// Tests that the Foo::Bar() method does Abc.
-TEST_F(FooTest, MethodBarDoesAbc) {
-  const string input_filepath = "this/package/testdata/myinputfile.dat";
-  const string output_filepath = "this/package/testdata/myoutputfile.dat";
-  Foo f;
-  EXPECT_EQ(0, f.Bar(input_filepath, output_filepath));
-}
-
-// Tests that Foo does Xyz.
-TEST_F(FooTest, DoesXyz) {
-  // Exercises the Xyz feature of Foo.
-}
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
-```
-
-The `::testing::InitGoogleTest()` function parses the command line for Google
-Test flags, and removes all recognized flags. This allows the user to control a
-test program's behavior via various flags, which we'll cover in [AdvancedGuide](V1_6_AdvancedGuide.md).
-You must call this function before calling `RUN_ALL_TESTS()`, or the flags
-won't be properly initialized.
-
-On Windows, `InitGoogleTest()` also works with wide strings, so it can be used
-in programs compiled in `UNICODE` mode as well.
-
-But maybe you think that writing all those main() functions is too much work? We agree with you completely and that's why Google Test provides a basic implementation of main(). If it fits your needs, then just link your test with gtest\_main library and you are good to go.
-
-## Important note for Visual C++ users ##
-If you put your tests into a library and your `main()` function is in a different library or in your .exe file, those tests will not run. The reason is a [bug](https://connect.microsoft.com/feedback/viewfeedback.aspx?FeedbackID=244410&siteid=210) in Visual C++. When you define your tests, Google Test creates certain static objects to register them. These objects are not referenced from elsewhere but their constructors are still supposed to run. When Visual C++ linker sees that nothing in the library is referenced from other places it throws the library out. You have to reference your library with tests from your main program to keep the linker from discarding it. Here is how to do it. Somewhere in your library code declare a function:
-```
-__declspec(dllexport) int PullInMyLibrary() { return 0; }
-```
-If you put your tests in a static library (not DLL) then `__declspec(dllexport)` is not required. Now, in your main program, write a code that invokes that function:
-```
-int PullInMyLibrary();
-static int dummy = PullInMyLibrary();
-```
-This will keep your tests referenced and will make them register themselves at startup.
-
-In addition, if you define your tests in a static library, add `/OPT:NOREF` to your main program linker options. If you use MSVC++ IDE, go to your .exe project properties/Configuration Properties/Linker/Optimization and set References setting to `Keep Unreferenced Data (/OPT:NOREF)`. This will keep Visual C++ linker from discarding individual symbols generated by your tests from the final executable.
-
-There is one more pitfall, though. If you use Google Test as a static library (that's how it is defined in gtest.vcproj) your tests must also reside in a static library. If you have to have them in a DLL, you _must_ change Google Test to build into a DLL as well. Otherwise your tests will not run correctly or will not run at all. The general conclusion here is: make your life easier - do not write your tests in libraries!
-
-# Where to Go from Here #
-
-Congratulations! You've learned the Google Test basics. You can start writing
-and running Google Test tests, read some [samples](V1_6_Samples.md), or continue with
-[AdvancedGuide](V1_6_AdvancedGuide.md), which describes many more useful Google Test features.
-
-# Known Limitations #
-
-Google Test is designed to be thread-safe.  The implementation is
-thread-safe on systems where the `pthreads` library is available.  It
-is currently _unsafe_ to use Google Test assertions from two threads
-concurrently on other systems (e.g. Windows).  In most tests this is
-not an issue as usually the assertions are done in the main thread. If
-you want to help, you can volunteer to implement the necessary
-synchronization primitives in `gtest-port.h` for your platform.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_PumpManual.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_PumpManual.md
deleted file mode 100644
index 8184f153..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_PumpManual.md
+++ /dev/null
@@ -1,177 +0,0 @@
-
-
-<b>P</b>ump is <b>U</b>seful for <b>M</b>eta <b>P</b>rogramming.
-
-# The Problem #
-
-Template and macro libraries often need to define many classes,
-functions, or macros that vary only (or almost only) in the number of
-arguments they take. It's a lot of repetitive, mechanical, and
-error-prone work.
-
-Variadic templates and variadic macros can alleviate the problem.
-However, while both are being considered by the C++ committee, neither
-is in the standard yet or widely supported by compilers.  Thus they
-are often not a good choice, especially when your code needs to be
-portable. And their capabilities are still limited.
-
-As a result, authors of such libraries often have to write scripts to
-generate their implementation. However, our experience is that it's
-tedious to write such scripts, which tend to reflect the structure of
-the generated code poorly and are often hard to read and edit. For
-example, a small change needed in the generated code may require some
-non-intuitive, non-trivial changes in the script. This is especially
-painful when experimenting with the code.
-
-# Our Solution #
-
-Pump (for Pump is Useful for Meta Programming, Pretty Useful for Meta
-Programming, or Practical Utility for Meta Programming, whichever you
-prefer) is a simple meta-programming tool for C++. The idea is that a
-programmer writes a `foo.pump` file which contains C++ code plus meta
-code that manipulates the C++ code. The meta code can handle
-iterations over a range, nested iterations, local meta variable
-definitions, simple arithmetic, and conditional expressions. You can
-view it as a small Domain-Specific Language. The meta language is
-designed to be non-intrusive (s.t. it won't confuse Emacs' C++ mode,
-for example) and concise, making Pump code intuitive and easy to
-maintain.
-
-## Highlights ##
-
-  * The implementation is in a single Python script and thus ultra portable: no build or installation is needed and it works cross platforms.
-  * Pump tries to be smart with respect to [Google's style guide](http://code.google.com/p/google-styleguide/): it breaks long lines (easy to have when they are generated) at acceptable places to fit within 80 columns and indent the continuation lines correctly.
-  * The format is human-readable and more concise than XML.
-  * The format works relatively well with Emacs' C++ mode.
-
-## Examples ##
-
-The following Pump code (where meta keywords start with `$`, `[[` and `]]` are meta brackets, and `$$` starts a meta comment that ends with the line):
-
-```
-$var n = 3     $$ Defines a meta variable n.
-$range i 0..n  $$ Declares the range of meta iterator i (inclusive).
-$for i [[
-               $$ Meta loop.
-// Foo$i does blah for $i-ary predicates.
-$range j 1..i
-template <size_t N $for j [[, typename A$j]]>
-class Foo$i {
-$if i == 0 [[
-  blah a;
-]] $elif i <= 2 [[
-  blah b;
-]] $else [[
-  blah c;
-]]
-};
-
-]]
-```
-
-will be translated by the Pump compiler to:
-
-```
-// Foo0 does blah for 0-ary predicates.
-template <size_t N>
-class Foo0 {
-  blah a;
-};
-
-// Foo1 does blah for 1-ary predicates.
-template <size_t N, typename A1>
-class Foo1 {
-  blah b;
-};
-
-// Foo2 does blah for 2-ary predicates.
-template <size_t N, typename A1, typename A2>
-class Foo2 {
-  blah b;
-};
-
-// Foo3 does blah for 3-ary predicates.
-template <size_t N, typename A1, typename A2, typename A3>
-class Foo3 {
-  blah c;
-};
-```
-
-In another example,
-
-```
-$range i 1..n
-Func($for i + [[a$i]]);
-$$ The text between i and [[ is the separator between iterations.
-```
-
-will generate one of the following lines (without the comments), depending on the value of `n`:
-
-```
-Func();              // If n is 0.
-Func(a1);            // If n is 1.
-Func(a1 + a2);       // If n is 2.
-Func(a1 + a2 + a3);  // If n is 3.
-// And so on...
-```
-
-## Constructs ##
-
-We support the following meta programming constructs:
-
-| `$var id = exp` | Defines a named constant value. `$id` is valid util the end of the current meta lexical block. |
-|:----------------|:-----------------------------------------------------------------------------------------------|
-| `$range id exp..exp` | Sets the range of an iteration variable, which can be reused in multiple loops later.          |
-| `$for id sep [[ code ]]` | Iteration. The range of `id` must have been defined earlier. `$id` is valid in `code`.         |
-| `$($)`          | Generates a single `$` character.                                                              |
-| `$id`           | Value of the named constant or iteration variable.                                             |
-| `$(exp)`        | Value of the expression.                                                                       |
-| `$if exp [[ code ]] else_branch` | Conditional.                                                                                   |
-| `[[ code ]]`    | Meta lexical block.                                                                            |
-| `cpp_code`      | Raw C++ code.                                                                                  |
-| `$$ comment`    | Meta comment.                                                                                  |
-
-**Note:** To give the user some freedom in formatting the Pump source
-code, Pump ignores a new-line character if it's right after `$for foo`
-or next to `[[` or `]]`. Without this rule you'll often be forced to write
-very long lines to get the desired output. Therefore sometimes you may
-need to insert an extra new-line in such places for a new-line to show
-up in your output.
-
-## Grammar ##
-
-```
-code ::= atomic_code*
-atomic_code ::= $var id = exp
-    | $var id = [[ code ]]
-    | $range id exp..exp
-    | $for id sep [[ code ]]
-    | $($)
-    | $id
-    | $(exp)
-    | $if exp [[ code ]] else_branch
-    | [[ code ]]
-    | cpp_code
-sep ::= cpp_code | empty_string
-else_branch ::= $else [[ code ]]
-    | $elif exp [[ code ]] else_branch
-    | empty_string
-exp ::= simple_expression_in_Python_syntax
-```
-
-## Code ##
-
-You can find the source code of Pump in [scripts/pump.py](../scripts/pump.py). It is still
-very unpolished and lacks automated tests, although it has been
-successfully used many times. If you find a chance to use it in your
-project, please let us know what you think!  We also welcome help on
-improving Pump.
-
-## Real Examples ##
-
-You can find real-world applications of Pump in [Google Test](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgoogletest\.googlecode\.com) and [Google Mock](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgooglemock\.googlecode\.com).  The source file `foo.h.pump` generates `foo.h`.
-
-## Tips ##
-
-  * If a meta variable is followed by a letter or digit, you can separate them using `[[]]`, which inserts an empty string. For example `Foo$j[[]]Helper` generate `Foo1Helper` when `j` is 1.
-  * To avoid extra-long Pump source lines, you can break a line anywhere you want by inserting `[[]]` followed by a new line. Since any new-line character next to `[[` or `]]` is ignored, the generated code won't contain this new line.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Samples.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Samples.md
deleted file mode 100644
index f21d2005..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_Samples.md
+++ /dev/null
@@ -1,14 +0,0 @@
-If you're like us, you'd like to look at some Google Test sample code.  The
-[samples folder](../samples) has a number of well-commented samples showing how to use a
-variety of Google Test features.
-
-  * [Sample #1](../samples/sample1_unittest.cc) shows the basic steps of using Google Test to test C++ functions.
-  * [Sample #2](../samples/sample2_unittest.cc) shows a more complex unit test for a class with multiple member functions.
-  * [Sample #3](../samples/sample3_unittest.cc) uses a test fixture.
-  * [Sample #4](../samples/sample4_unittest.cc) is another basic example of using Google Test.
-  * [Sample #5](../samples/sample5_unittest.cc) teaches how to reuse a test fixture in multiple test cases by deriving sub-fixtures from it.
-  * [Sample #6](../samples/sample6_unittest.cc) demonstrates type-parameterized tests.
-  * [Sample #7](../samples/sample7_unittest.cc) teaches the basics of value-parameterized tests.
-  * [Sample #8](../samples/sample8_unittest.cc) shows using `Combine()` in value-parameterized tests.
-  * [Sample #9](../samples/sample9_unittest.cc) shows use of the listener API to modify Google Test's console output and the use of its reflection API to inspect test results.
-  * [Sample #10](../samples/sample10_unittest.cc) shows use of the listener API to implement a primitive memory leak checker.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_XcodeGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_XcodeGuide.md
deleted file mode 100644
index bf24bf51..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_6_XcodeGuide.md
+++ /dev/null
@@ -1,93 +0,0 @@
-
-
-This guide will explain how to use the Google Testing Framework in your Xcode projects on Mac OS X. This tutorial begins by quickly explaining what to do for experienced users. After the quick start, the guide goes provides additional explanation about each step.
-
-# Quick Start #
-
-Here is the quick guide for using Google Test in your Xcode project.
-
-  1. Download the source from the [website](http://code.google.com/p/googletest) using this command: `svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only`
-  1. Open up the `gtest.xcodeproj` in the `googletest-read-only/xcode/` directory and build the gtest.framework.
-  1. Create a new "Shell Tool" target in your Xcode project called something like "UnitTests"
-  1. Add the gtest.framework to your project and add it to the "Link Binary with Libraries" build phase of "UnitTests"
-  1. Add your unit test source code to the "Compile Sources" build phase of "UnitTests"
-  1. Edit the "UnitTests" executable and add an environment variable named "DYLD\_FRAMEWORK\_PATH" with a value equal to the path to the framework containing the gtest.framework relative to the compiled executable.
-  1. Build and Go
-
-The following sections further explain each of the steps listed above in depth, describing in more detail how to complete it including some variations.
-
-# Get the Source #
-
-Currently, the gtest.framework discussed here isn't available in a tagged release of Google Test, it is only available in the trunk. As explained at the Google Test [site](http://code.google.com/p/googletest/source/checkout">svn), you can get the code from anonymous SVN with this command:
-
-```
-svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only
-```
-
-Alternatively, if you are working with Subversion in your own code base, you can add Google Test as an external dependency to your own Subversion repository. By following this approach, everyone that checks out your svn repository will also receive a copy of Google Test (a specific version, if you wish) without having to check it out explicitly. This makes the set up of your project simpler and reduces the copied code in the repository.
-
-To use `svn:externals`, decide where you would like to have the external source reside. You might choose to put the external source inside the trunk, because you want it to be part of the branch when you make a release. However, keeping it outside the trunk in a version-tagged directory called something like `third-party/googletest/1.0.1`, is another option. Once the location is established, use `svn propedit svn:externals _directory_` to set the svn:externals property on a directory in your repository. This directory won't contain the code, but be its versioned parent directory.
-
-The command `svn propedit` will bring up your Subversion editor, making editing the long, (potentially multi-line) property simpler. This same method can be used to check out a tagged branch, by using the appropriate URL (e.g. `http://googletest.googlecode.com/svn/tags/release-1.0.1`). Additionally, the svn:externals property allows the specification of a particular revision of the trunk with the `-r_##_` option (e.g. `externals/src/googletest -r60 http://googletest.googlecode.com/svn/trunk`).
-
-Here is an example of using the svn:externals properties on a trunk (read via `svn propget`) of a project. This value checks out a copy of Google Test into the `trunk/externals/src/googletest/` directory.
-
-```
-[Computer:svn] user$ svn propget svn:externals trunk
-externals/src/googletest http://googletest.googlecode.com/svn/trunk
-```
-
-# Add the Framework to Your Project #
-
-The next step is to build and add the gtest.framework to your own project. This guide describes two common ways below.
-
-  * **Option 1** --- The simplest way to add Google Test to your own project, is to open gtest.xcodeproj (found in the xcode/ directory of the Google Test trunk) and build the framework manually. Then, add the built framework into your project using the "Add->Existing Framework..." from the context menu or "Project->Add..." from the main menu. The gtest.framework is relocatable and contains the headers and object code that you'll need to make tests. This method requires rebuilding every time you upgrade Google Test in your project.
-  * **Option 2** --- If you are going to be living off the trunk of Google Test, incorporating its latest features into your unit tests (or are a Google Test developer yourself). You'll want to rebuild the framework every time the source updates. to do this, you'll need to add the gtest.xcodeproj file, not the framework itself, to your own Xcode project. Then, from the build products that are revealed by the project's disclosure triangle, you can find the gtest.framework, which can be added to your targets (discussed below).
-
-# Make a Test Target #
-
-To start writing tests, make a new "Shell Tool" target. This target template is available under BSD, Cocoa, or Carbon. Add your unit test source code to the "Compile Sources" build phase of the target.
-
-Next, you'll want to add gtest.framework in two different ways, depending upon which option you chose above.
-
-  * **Option 1** --- During compilation, Xcode will need to know that you are linking against the gtest.framework. Add the gtest.framework to the "Link Binary with Libraries" build phase of your test target. This will include the Google Test headers in your header search path, and will tell the linker where to find the library.
-  * **Option 2** --- If your working out of the trunk, you'll also want to add gtest.framework to your "Link Binary with Libraries" build phase of your test target. In addition, you'll  want to add the gtest.framework as a dependency to your unit test target. This way, Xcode will make sure that gtest.framework is up to date, every time your build your target. Finally, if you don't share build directories with Google Test, you'll have to copy the gtest.framework into your own build products directory using a "Run Script" build phase.
-
-# Set Up the Executable Run Environment #
-
-Since the unit test executable is a shell tool, it doesn't have a bundle with a `Contents/Frameworks` directory, in which to place gtest.framework. Instead, the dynamic linker must be told at runtime to search for the framework in another location. This can be accomplished by setting the "DYLD\_FRAMEWORK\_PATH" environment variable in the "Edit Active Executable ..." Arguments tab, under "Variables to be set in the environment:". The path for this value is the path (relative or absolute) of the directory containing the gtest.framework.
-
-If you haven't set up the DYLD\_FRAMEWORK\_PATH, correctly, you might get a message like this:
-
-```
-[Session started at 2008-08-15 06:23:57 -0600.]
-  dyld: Library not loaded: @loader_path/../Frameworks/gtest.framework/Versions/A/gtest
-    Referenced from: /Users/username/Documents/Sandbox/gtestSample/build/Debug/WidgetFrameworkTest
-    Reason: image not found
-```
-
-To correct this problem, got to the directory containing the executable named in "Referenced from:" value in the error message above. Then, with the terminal in this location, find the relative path to the directory containing the gtest.framework. That is the value you'll need to set as the DYLD\_FRAMEWORK\_PATH.
-
-# Build and Go #
-
-Now, when you click "Build and Go", the test will be executed. Dumping out something like this:
-
-```
-[Session started at 2008-08-06 06:36:13 -0600.]
-[==========] Running 2 tests from 1 test case.
-[----------] Global test environment set-up.
-[----------] 2 tests from WidgetInitializerTest
-[ RUN      ] WidgetInitializerTest.TestConstructor
-[       OK ] WidgetInitializerTest.TestConstructor
-[ RUN      ] WidgetInitializerTest.TestConversion
-[       OK ] WidgetInitializerTest.TestConversion
-[----------] Global test environment tear-down
-[==========] 2 tests from 1 test case ran.
-[  PASSED  ] 2 tests.
-
-The Debugger has exited with status 0.  
-```
-
-# Summary #
-
-Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_AdvancedGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_AdvancedGuide.md
deleted file mode 100644
index dd4af8f3..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_AdvancedGuide.md
+++ /dev/null
@@ -1,2181 +0,0 @@
-
-
-Now that you have read [Primer](V1_7_Primer.md) and learned how to write tests
-using Google Test, it's time to learn some new tricks. This document
-will show you more assertions as well as how to construct complex
-failure messages, propagate fatal failures, reuse and speed up your
-test fixtures, and use various flags with your tests.
-
-# More Assertions #
-
-This section covers some less frequently used, but still significant,
-assertions.
-
-## Explicit Success and Failure ##
-
-These three assertions do not actually test a value or expression. Instead,
-they generate a success or failure directly. Like the macros that actually
-perform a test, you may stream a custom failure message into the them.
-
-| `SUCCEED();` |
-|:-------------|
-
-Generates a success. This does NOT make the overall test succeed. A test is
-considered successful only if none of its assertions fail during its execution.
-
-Note: `SUCCEED()` is purely documentary and currently doesn't generate any
-user-visible output. However, we may add `SUCCEED()` messages to Google Test's
-output in the future.
-
-| `FAIL();`  | `ADD_FAILURE();` | `ADD_FAILURE_AT("`_file\_path_`", `_line\_number_`);` |
-|:-----------|:-----------------|:------------------------------------------------------|
-
-`FAIL()` generates a fatal failure, while `ADD_FAILURE()` and `ADD_FAILURE_AT()` generate a nonfatal
-failure. These are useful when control flow, rather than a Boolean expression,
-deteremines the test's success or failure. For example, you might want to write
-something like:
-
-```
-switch(expression) {
-  case 1: ... some checks ...
-  case 2: ... some other checks
-  ...
-  default: FAIL() << "We shouldn't get here.";
-}
-```
-
-_Availability_: Linux, Windows, Mac.
-
-## Exception Assertions ##
-
-These are for verifying that a piece of code throws (or does not
-throw) an exception of the given type:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_THROW(`_statement_, _exception\_type_`);`  | `EXPECT_THROW(`_statement_, _exception\_type_`);`  | _statement_ throws an exception of the given type  |
-| `ASSERT_ANY_THROW(`_statement_`);`                | `EXPECT_ANY_THROW(`_statement_`);`                | _statement_ throws an exception of any type        |
-| `ASSERT_NO_THROW(`_statement_`);`                 | `EXPECT_NO_THROW(`_statement_`);`                 | _statement_ doesn't throw any exception            |
-
-Examples:
-
-```
-ASSERT_THROW(Foo(5), bar_exception);
-
-EXPECT_NO_THROW({
-  int n = 5;
-  Bar(&n);
-});
-```
-
-_Availability_: Linux, Windows, Mac; since version 1.1.0.
-
-## Predicate Assertions for Better Error Messages ##
-
-Even though Google Test has a rich set of assertions, they can never be
-complete, as it's impossible (nor a good idea) to anticipate all the scenarios
-a user might run into. Therefore, sometimes a user has to use `EXPECT_TRUE()`
-to check a complex expression, for lack of a better macro. This has the problem
-of not showing you the values of the parts of the expression, making it hard to
-understand what went wrong. As a workaround, some users choose to construct the
-failure message by themselves, streaming it into `EXPECT_TRUE()`. However, this
-is awkward especially when the expression has side-effects or is expensive to
-evaluate.
-
-Google Test gives you three different options to solve this problem:
-
-### Using an Existing Boolean Function ###
-
-If you already have a function or a functor that returns `bool` (or a type
-that can be implicitly converted to `bool`), you can use it in a _predicate
-assertion_ to get the function arguments printed for free:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_PRED1(`_pred1, val1_`);`       | `EXPECT_PRED1(`_pred1, val1_`);` | _pred1(val1)_ returns true |
-| `ASSERT_PRED2(`_pred2, val1, val2_`);` | `EXPECT_PRED2(`_pred2, val1, val2_`);` |  _pred2(val1, val2)_ returns true |
-|  ...                | ...                    | ...          |
-
-In the above, _predn_ is an _n_-ary predicate function or functor, where
-_val1_, _val2_, ..., and _valn_ are its arguments. The assertion succeeds
-if the predicate returns `true` when applied to the given arguments, and fails
-otherwise. When the assertion fails, it prints the value of each argument. In
-either case, the arguments are evaluated exactly once.
-
-Here's an example. Given
-
-```
-// Returns true iff m and n have no common divisors except 1.
-bool MutuallyPrime(int m, int n) { ... }
-const int a = 3;
-const int b = 4;
-const int c = 10;
-```
-
-the assertion `EXPECT_PRED2(MutuallyPrime, a, b);` will succeed, while the
-assertion `EXPECT_PRED2(MutuallyPrime, b, c);` will fail with the message
-
-<pre>
-!MutuallyPrime(b, c) is false, where<br>
-b is 4<br>
-c is 10<br>
-</pre>
-
-**Notes:**
-
-  1. If you see a compiler error "no matching function to call" when using `ASSERT_PRED*` or `EXPECT_PRED*`, please see [this](V1_7_FAQ.md#the-compiler-complains-about-undefined-references-to-some-static-const-member-variables-but-i-did-define-them-in-the-class-body-whats-wrong) for how to resolve it.
-  1. Currently we only provide predicate assertions of arity <= 5. If you need a higher-arity assertion, let us know.
-
-_Availability_: Linux, Windows, Mac
-
-### Using a Function That Returns an AssertionResult ###
-
-While `EXPECT_PRED*()` and friends are handy for a quick job, the
-syntax is not satisfactory: you have to use different macros for
-different arities, and it feels more like Lisp than C++.  The
-`::testing::AssertionResult` class solves this problem.
-
-An `AssertionResult` object represents the result of an assertion
-(whether it's a success or a failure, and an associated message).  You
-can create an `AssertionResult` using one of these factory
-functions:
-
-```
-namespace testing {
-
-// Returns an AssertionResult object to indicate that an assertion has
-// succeeded.
-AssertionResult AssertionSuccess();
-
-// Returns an AssertionResult object to indicate that an assertion has
-// failed.
-AssertionResult AssertionFailure();
-
-}
-```
-
-You can then use the `<<` operator to stream messages to the
-`AssertionResult` object.
-
-To provide more readable messages in Boolean assertions
-(e.g. `EXPECT_TRUE()`), write a predicate function that returns
-`AssertionResult` instead of `bool`. For example, if you define
-`IsEven()` as:
-
-```
-::testing::AssertionResult IsEven(int n) {
-  if ((n % 2) == 0)
-    return ::testing::AssertionSuccess();
-  else
-    return ::testing::AssertionFailure() << n << " is odd";
-}
-```
-
-instead of:
-
-```
-bool IsEven(int n) {
-  return (n % 2) == 0;
-}
-```
-
-the failed assertion `EXPECT_TRUE(IsEven(Fib(4)))` will print:
-
-<pre>
-Value of: IsEven(Fib(4))<br>
-Actual: false (*3 is odd*)<br>
-Expected: true<br>
-</pre>
-
-instead of a more opaque
-
-<pre>
-Value of: IsEven(Fib(4))<br>
-Actual: false<br>
-Expected: true<br>
-</pre>
-
-If you want informative messages in `EXPECT_FALSE` and `ASSERT_FALSE`
-as well, and are fine with making the predicate slower in the success
-case, you can supply a success message:
-
-```
-::testing::AssertionResult IsEven(int n) {
-  if ((n % 2) == 0)
-    return ::testing::AssertionSuccess() << n << " is even";
-  else
-    return ::testing::AssertionFailure() << n << " is odd";
-}
-```
-
-Then the statement `EXPECT_FALSE(IsEven(Fib(6)))` will print
-
-<pre>
-Value of: IsEven(Fib(6))<br>
-Actual: true (8 is even)<br>
-Expected: false<br>
-</pre>
-
-_Availability_: Linux, Windows, Mac; since version 1.4.1.
-
-### Using a Predicate-Formatter ###
-
-If you find the default message generated by `(ASSERT|EXPECT)_PRED*` and
-`(ASSERT|EXPECT)_(TRUE|FALSE)` unsatisfactory, or some arguments to your
-predicate do not support streaming to `ostream`, you can instead use the
-following _predicate-formatter assertions_ to _fully_ customize how the
-message is formatted:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_PRED_FORMAT1(`_pred\_format1, val1_`);`        | `EXPECT_PRED_FORMAT1(`_pred\_format1, val1_`); | _pred\_format1(val1)_ is successful |
-| `ASSERT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | `EXPECT_PRED_FORMAT2(`_pred\_format2, val1, val2_`);` | _pred\_format2(val1, val2)_ is successful |
-| `...`               | `...`                  | `...`        |
-
-The difference between this and the previous two groups of macros is that instead of
-a predicate, `(ASSERT|EXPECT)_PRED_FORMAT*` take a _predicate-formatter_
-(_pred\_formatn_), which is a function or functor with the signature:
-
-`::testing::AssertionResult PredicateFormattern(const char* `_expr1_`, const char* `_expr2_`, ... const char* `_exprn_`, T1 `_val1_`, T2 `_val2_`, ... Tn `_valn_`);`
-
-where _val1_, _val2_, ..., and _valn_ are the values of the predicate
-arguments, and _expr1_, _expr2_, ..., and _exprn_ are the corresponding
-expressions as they appear in the source code. The types `T1`, `T2`, ..., and
-`Tn` can be either value types or reference types. For example, if an
-argument has type `Foo`, you can declare it as either `Foo` or `const Foo&`,
-whichever is appropriate.
-
-A predicate-formatter returns a `::testing::AssertionResult` object to indicate
-whether the assertion has succeeded or not. The only way to create such an
-object is to call one of these factory functions:
-
-As an example, let's improve the failure message in the previous example, which uses `EXPECT_PRED2()`:
-
-```
-// Returns the smallest prime common divisor of m and n,
-// or 1 when m and n are mutually prime.
-int SmallestPrimeCommonDivisor(int m, int n) { ... }
-
-// A predicate-formatter for asserting that two integers are mutually prime.
-::testing::AssertionResult AssertMutuallyPrime(const char* m_expr,
-                                               const char* n_expr,
-                                               int m,
-                                               int n) {
-  if (MutuallyPrime(m, n))
-    return ::testing::AssertionSuccess();
-
-  return ::testing::AssertionFailure()
-      << m_expr << " and " << n_expr << " (" << m << " and " << n
-      << ") are not mutually prime, " << "as they have a common divisor "
-      << SmallestPrimeCommonDivisor(m, n);
-}
-```
-
-With this predicate-formatter, we can use
-
-```
-EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c);
-```
-
-to generate the message
-
-<pre>
-b and c (4 and 10) are not mutually prime, as they have a common divisor 2.<br>
-</pre>
-
-As you may have realized, many of the assertions we introduced earlier are
-special cases of `(EXPECT|ASSERT)_PRED_FORMAT*`. In fact, most of them are
-indeed defined using `(EXPECT|ASSERT)_PRED_FORMAT*`.
-
-_Availability_: Linux, Windows, Mac.
-
-
-## Floating-Point Comparison ##
-
-Comparing floating-point numbers is tricky. Due to round-off errors, it is
-very unlikely that two floating-points will match exactly. Therefore,
-`ASSERT_EQ` 's naive comparison usually doesn't work. And since floating-points
-can have a wide value range, no single fixed error bound works. It's better to
-compare by a fixed relative error bound, except for values close to 0 due to
-the loss of precision there.
-
-In general, for floating-point comparison to make sense, the user needs to
-carefully choose the error bound. If they don't want or care to, comparing in
-terms of Units in the Last Place (ULPs) is a good default, and Google Test
-provides assertions to do this. Full details about ULPs are quite long; if you
-want to learn more, see
-[this article on float comparison](http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm).
-
-### Floating-Point Macros ###
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_FLOAT_EQ(`_expected, actual_`);`  | `EXPECT_FLOAT_EQ(`_expected, actual_`);` | the two `float` values are almost equal |
-| `ASSERT_DOUBLE_EQ(`_expected, actual_`);` | `EXPECT_DOUBLE_EQ(`_expected, actual_`);` | the two `double` values are almost equal |
-
-By "almost equal", we mean the two values are within 4 ULP's from each
-other.
-
-The following assertions allow you to choose the acceptable error bound:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_NEAR(`_val1, val2, abs\_error_`);` | `EXPECT_NEAR`_(val1, val2, abs\_error_`);` | the difference between _val1_ and _val2_ doesn't exceed the given absolute error |
-
-_Availability_: Linux, Windows, Mac.
-
-### Floating-Point Predicate-Format Functions ###
-
-Some floating-point operations are useful, but not that often used. In order
-to avoid an explosion of new macros, we provide them as predicate-format
-functions that can be used in predicate assertion macros (e.g.
-`EXPECT_PRED_FORMAT2`, etc).
-
-```
-EXPECT_PRED_FORMAT2(::testing::FloatLE, val1, val2);
-EXPECT_PRED_FORMAT2(::testing::DoubleLE, val1, val2);
-```
-
-Verifies that _val1_ is less than, or almost equal to, _val2_. You can
-replace `EXPECT_PRED_FORMAT2` in the above table with `ASSERT_PRED_FORMAT2`.
-
-_Availability_: Linux, Windows, Mac.
-
-## Windows HRESULT assertions ##
-
-These assertions test for `HRESULT` success or failure.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_HRESULT_SUCCEEDED(`_expression_`);` | `EXPECT_HRESULT_SUCCEEDED(`_expression_`);` | _expression_ is a success `HRESULT` |
-| `ASSERT_HRESULT_FAILED(`_expression_`);`    | `EXPECT_HRESULT_FAILED(`_expression_`);`    | _expression_ is a failure `HRESULT` |
-
-The generated output contains the human-readable error message
-associated with the `HRESULT` code returned by _expression_.
-
-You might use them like this:
-
-```
-CComPtr shell;
-ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application"));
-CComVariant empty;
-ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty));
-```
-
-_Availability_: Windows.
-
-## Type Assertions ##
-
-You can call the function
-```
-::testing::StaticAssertTypeEq<T1, T2>();
-```
-to assert that types `T1` and `T2` are the same.  The function does
-nothing if the assertion is satisfied.  If the types are different,
-the function call will fail to compile, and the compiler error message
-will likely (depending on the compiler) show you the actual values of
-`T1` and `T2`.  This is mainly useful inside template code.
-
-_Caveat:_ When used inside a member function of a class template or a
-function template, `StaticAssertTypeEq<T1, T2>()` is effective _only if_
-the function is instantiated.  For example, given:
-```
-template <typename T> class Foo {
- public:
-  void Bar() { ::testing::StaticAssertTypeEq<int, T>(); }
-};
-```
-the code:
-```
-void Test1() { Foo<bool> foo; }
-```
-will _not_ generate a compiler error, as `Foo<bool>::Bar()` is never
-actually instantiated.  Instead, you need:
-```
-void Test2() { Foo<bool> foo; foo.Bar(); }
-```
-to cause a compiler error.
-
-_Availability:_ Linux, Windows, Mac; since version 1.3.0.
-
-## Assertion Placement ##
-
-You can use assertions in any C++ function. In particular, it doesn't
-have to be a method of the test fixture class. The one constraint is
-that assertions that generate a fatal failure (`FAIL*` and `ASSERT_*`)
-can only be used in void-returning functions. This is a consequence of
-Google Test not using exceptions. By placing it in a non-void function
-you'll get a confusing compile error like
-`"error: void value not ignored as it ought to be"`.
-
-If you need to use assertions in a function that returns non-void, one option
-is to make the function return the value in an out parameter instead. For
-example, you can rewrite `T2 Foo(T1 x)` to `void Foo(T1 x, T2* result)`. You
-need to make sure that `*result` contains some sensible value even when the
-function returns prematurely. As the function now returns `void`, you can use
-any assertion inside of it.
-
-If changing the function's type is not an option, you should just use
-assertions that generate non-fatal failures, such as `ADD_FAILURE*` and
-`EXPECT_*`.
-
-_Note_: Constructors and destructors are not considered void-returning
-functions, according to the C++ language specification, and so you may not use
-fatal assertions in them. You'll get a compilation error if you try. A simple
-workaround is to transfer the entire body of the constructor or destructor to a
-private void-returning method. However, you should be aware that a fatal
-assertion failure in a constructor does not terminate the current test, as your
-intuition might suggest; it merely returns from the constructor early, possibly
-leaving your object in a partially-constructed state. Likewise, a fatal
-assertion failure in a destructor may leave your object in a
-partially-destructed state. Use assertions carefully in these situations!
-
-# Teaching Google Test How to Print Your Values #
-
-When a test assertion such as `EXPECT_EQ` fails, Google Test prints the
-argument values to help you debug.  It does this using a
-user-extensible value printer.
-
-This printer knows how to print built-in C++ types, native arrays, STL
-containers, and any type that supports the `<<` operator.  For other
-types, it prints the raw bytes in the value and hopes that you the
-user can figure it out.
-
-As mentioned earlier, the printer is _extensible_.  That means
-you can teach it to do a better job at printing your particular type
-than to dump the bytes.  To do that, define `<<` for your type:
-
-```
-#include <iostream>
-
-namespace foo {
-
-class Bar { ... };  // We want Google Test to be able to print instances of this.
-
-// It's important that the << operator is defined in the SAME
-// namespace that defines Bar.  C++'s look-up rules rely on that.
-::std::ostream& operator<<(::std::ostream& os, const Bar& bar) {
-  return os << bar.DebugString();  // whatever needed to print bar to os
-}
-
-}  // namespace foo
-```
-
-Sometimes, this might not be an option: your team may consider it bad
-style to have a `<<` operator for `Bar`, or `Bar` may already have a
-`<<` operator that doesn't do what you want (and you cannot change
-it).  If so, you can instead define a `PrintTo()` function like this:
-
-```
-#include <iostream>
-
-namespace foo {
-
-class Bar { ... };
-
-// It's important that PrintTo() is defined in the SAME
-// namespace that defines Bar.  C++'s look-up rules rely on that.
-void PrintTo(const Bar& bar, ::std::ostream* os) {
-  *os << bar.DebugString();  // whatever needed to print bar to os
-}
-
-}  // namespace foo
-```
-
-If you have defined both `<<` and `PrintTo()`, the latter will be used
-when Google Test is concerned.  This allows you to customize how the value
-appears in Google Test's output without affecting code that relies on the
-behavior of its `<<` operator.
-
-If you want to print a value `x` using Google Test's value printer
-yourself, just call `::testing::PrintToString(`_x_`)`, which
-returns an `std::string`:
-
-```
-vector<pair<Bar, int> > bar_ints = GetBarIntVector();
-
-EXPECT_TRUE(IsCorrectBarIntVector(bar_ints))
-    << "bar_ints = " << ::testing::PrintToString(bar_ints);
-```
-
-# Death Tests #
-
-In many applications, there are assertions that can cause application failure
-if a condition is not met. These sanity checks, which ensure that the program
-is in a known good state, are there to fail at the earliest possible time after
-some program state is corrupted. If the assertion checks the wrong condition,
-then the program may proceed in an erroneous state, which could lead to memory
-corruption, security holes, or worse. Hence it is vitally important to test
-that such assertion statements work as expected.
-
-Since these precondition checks cause the processes to die, we call such tests
-_death tests_. More generally, any test that checks that a program terminates
-(except by throwing an exception) in an expected fashion is also a death test.
-
-Note that if a piece of code throws an exception, we don't consider it "death"
-for the purpose of death tests, as the caller of the code could catch the exception
-and avoid the crash. If you want to verify exceptions thrown by your code,
-see [Exception Assertions](#exception-assertions).
-
-If you want to test `EXPECT_*()/ASSERT_*()` failures in your test code, see [Catching Failures](#catching-failures).
-
-## How to Write a Death Test ##
-
-Google Test has the following macros to support death tests:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_DEATH(`_statement, regex_`); | `EXPECT_DEATH(`_statement, regex_`); | _statement_ crashes with the given error |
-| `ASSERT_DEATH_IF_SUPPORTED(`_statement, regex_`); | `EXPECT_DEATH_IF_SUPPORTED(`_statement, regex_`); | if death tests are supported, verifies that _statement_ crashes with the given error; otherwise verifies nothing |
-| `ASSERT_EXIT(`_statement, predicate, regex_`); | `EXPECT_EXIT(`_statement, predicate, regex_`); |_statement_ exits with the given error and its exit code matches _predicate_ |
-
-where _statement_ is a statement that is expected to cause the process to
-die, _predicate_ is a function or function object that evaluates an integer
-exit status, and _regex_ is a regular expression that the stderr output of
-_statement_ is expected to match. Note that _statement_ can be _any valid
-statement_ (including _compound statement_) and doesn't have to be an
-expression.
-
-As usual, the `ASSERT` variants abort the current test function, while the
-`EXPECT` variants do not.
-
-**Note:** We use the word "crash" here to mean that the process
-terminates with a _non-zero_ exit status code.  There are two
-possibilities: either the process has called `exit()` or `_exit()`
-with a non-zero value, or it may be killed by a signal.
-
-This means that if _statement_ terminates the process with a 0 exit
-code, it is _not_ considered a crash by `EXPECT_DEATH`.  Use
-`EXPECT_EXIT` instead if this is the case, or if you want to restrict
-the exit code more precisely.
-
-A predicate here must accept an `int` and return a `bool`. The death test
-succeeds only if the predicate returns `true`. Google Test defines a few
-predicates that handle the most common cases:
-
-```
-::testing::ExitedWithCode(exit_code)
-```
-
-This expression is `true` if the program exited normally with the given exit
-code.
-
-```
-::testing::KilledBySignal(signal_number)  // Not available on Windows.
-```
-
-This expression is `true` if the program was killed by the given signal.
-
-The `*_DEATH` macros are convenient wrappers for `*_EXIT` that use a predicate
-that verifies the process' exit code is non-zero.
-
-Note that a death test only cares about three things:
-
-  1. does _statement_ abort or exit the process?
-  1. (in the case of `ASSERT_EXIT` and `EXPECT_EXIT`) does the exit status satisfy _predicate_?  Or (in the case of `ASSERT_DEATH` and `EXPECT_DEATH`) is the exit status non-zero?  And
-  1. does the stderr output match _regex_?
-
-In particular, if _statement_ generates an `ASSERT_*` or `EXPECT_*` failure, it will **not** cause the death test to fail, as Google Test assertions don't abort the process.
-
-To write a death test, simply use one of the above macros inside your test
-function. For example,
-
-```
-TEST(MyDeathTest, Foo) {
-  // This death test uses a compound statement.
-  ASSERT_DEATH({ int n = 5; Foo(&n); }, "Error on line .* of Foo()");
-}
-TEST(MyDeathTest, NormalExit) {
-  EXPECT_EXIT(NormalExit(), ::testing::ExitedWithCode(0), "Success");
-}
-TEST(MyDeathTest, KillMyself) {
-  EXPECT_EXIT(KillMyself(), ::testing::KilledBySignal(SIGKILL), "Sending myself unblockable signal");
-}
-```
-
-verifies that:
-
-  * calling `Foo(5)` causes the process to die with the given error message,
-  * calling `NormalExit()` causes the process to print `"Success"` to stderr and exit with exit code 0, and
-  * calling `KillMyself()` kills the process with signal `SIGKILL`.
-
-The test function body may contain other assertions and statements as well, if
-necessary.
-
-_Important:_ We strongly recommend you to follow the convention of naming your
-test case (not test) `*DeathTest` when it contains a death test, as
-demonstrated in the above example. The `Death Tests And Threads` section below
-explains why.
-
-If a test fixture class is shared by normal tests and death tests, you
-can use typedef to introduce an alias for the fixture class and avoid
-duplicating its code:
-```
-class FooTest : public ::testing::Test { ... };
-
-typedef FooTest FooDeathTest;
-
-TEST_F(FooTest, DoesThis) {
-  // normal test
-}
-
-TEST_F(FooDeathTest, DoesThat) {
-  // death test
-}
-```
-
-_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Cygwin, and Mac (the latter three are supported since v1.3.0).  `(ASSERT|EXPECT)_DEATH_IF_SUPPORTED` are new in v1.4.0.
-
-## Regular Expression Syntax ##
-
-On POSIX systems (e.g. Linux, Cygwin, and Mac), Google Test uses the
-[POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
-syntax in death tests. To learn about this syntax, you may want to read this [Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
-
-On Windows, Google Test uses its own simple regular expression
-implementation. It lacks many features you can find in POSIX extended
-regular expressions.  For example, we don't support union (`"x|y"`),
-grouping (`"(xy)"`), brackets (`"[xy]"`), and repetition count
-(`"x{5,7}"`), among others. Below is what we do support (Letter `A` denotes a
-literal character, period (`.`), or a single `\\` escape sequence; `x`
-and `y` denote regular expressions.):
-
-| `c` | matches any literal character `c` |
-|:----|:----------------------------------|
-| `\\d` | matches any decimal digit         |
-| `\\D` | matches any character that's not a decimal digit |
-| `\\f` | matches `\f`                      |
-| `\\n` | matches `\n`                      |
-| `\\r` | matches `\r`                      |
-| `\\s` | matches any ASCII whitespace, including `\n` |
-| `\\S` | matches any character that's not a whitespace |
-| `\\t` | matches `\t`                      |
-| `\\v` | matches `\v`                      |
-| `\\w` | matches any letter, `_`, or decimal digit |
-| `\\W` | matches any character that `\\w` doesn't match |
-| `\\c` | matches any literal character `c`, which must be a punctuation |
-| `\\.` | matches the `.` character         |
-| `.` | matches any single character except `\n` |
-| `A?` | matches 0 or 1 occurrences of `A` |
-| `A*` | matches 0 or many occurrences of `A` |
-| `A+` | matches 1 or many occurrences of `A` |
-| `^` | matches the beginning of a string (not that of each line) |
-| `$` | matches the end of a string (not that of each line) |
-| `xy` | matches `x` followed by `y`       |
-
-To help you determine which capability is available on your system,
-Google Test defines macro `GTEST_USES_POSIX_RE=1` when it uses POSIX
-extended regular expressions, or `GTEST_USES_SIMPLE_RE=1` when it uses
-the simple version.  If you want your death tests to work in both
-cases, you can either `#if` on these macros or use the more limited
-syntax only.
-
-## How It Works ##
-
-Under the hood, `ASSERT_EXIT()` spawns a new process and executes the
-death test statement in that process. The details of of how precisely
-that happens depend on the platform and the variable
-`::testing::GTEST_FLAG(death_test_style)` (which is initialized from the
-command-line flag `--gtest_death_test_style`).
-
-  * On POSIX systems, `fork()` (or `clone()` on Linux) is used to spawn the child, after which:
-    * If the variable's value is `"fast"`, the death test statement is immediately executed.
-    * If the variable's value is `"threadsafe"`, the child process re-executes the unit test binary just as it was originally invoked, but with some extra flags to cause just the single death test under consideration to be run.
-  * On Windows, the child is spawned using the `CreateProcess()` API, and re-executes the binary to cause just the single death test under consideration to be run - much like the `threadsafe` mode on POSIX.
-
-Other values for the variable are illegal and will cause the death test to
-fail. Currently, the flag's default value is `"fast"`. However, we reserve the
-right to change it in the future. Therefore, your tests should not depend on
-this.
-
-In either case, the parent process waits for the child process to complete, and checks that
-
-  1. the child's exit status satisfies the predicate, and
-  1. the child's stderr matches the regular expression.
-
-If the death test statement runs to completion without dying, the child
-process will nonetheless terminate, and the assertion fails.
-
-## Death Tests And Threads ##
-
-The reason for the two death test styles has to do with thread safety. Due to
-well-known problems with forking in the presence of threads, death tests should
-be run in a single-threaded context. Sometimes, however, it isn't feasible to
-arrange that kind of environment. For example, statically-initialized modules
-may start threads before main is ever reached. Once threads have been created,
-it may be difficult or impossible to clean them up.
-
-Google Test has three features intended to raise awareness of threading issues.
-
-  1. A warning is emitted if multiple threads are running when a death test is encountered.
-  1. Test cases with a name ending in "DeathTest" are run before all other tests.
-  1. It uses `clone()` instead of `fork()` to spawn the child process on Linux (`clone()` is not available on Cygwin and Mac), as `fork()` is more likely to cause the child to hang when the parent process has multiple threads.
-
-It's perfectly fine to create threads inside a death test statement; they are
-executed in a separate process and cannot affect the parent.
-
-## Death Test Styles ##
-
-The "threadsafe" death test style was introduced in order to help mitigate the
-risks of testing in a possibly multithreaded environment. It trades increased
-test execution time (potentially dramatically so) for improved thread safety.
-We suggest using the faster, default "fast" style unless your test has specific
-problems with it.
-
-You can choose a particular style of death tests by setting the flag
-programmatically:
-
-```
-::testing::FLAGS_gtest_death_test_style = "threadsafe";
-```
-
-You can do this in `main()` to set the style for all death tests in the
-binary, or in individual tests. Recall that flags are saved before running each
-test and restored afterwards, so you need not do that yourself. For example:
-
-```
-TEST(MyDeathTest, TestOne) {
-  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-  // This test is run in the "threadsafe" style:
-  ASSERT_DEATH(ThisShouldDie(), "");
-}
-
-TEST(MyDeathTest, TestTwo) {
-  // This test is run in the "fast" style:
-  ASSERT_DEATH(ThisShouldDie(), "");
-}
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  ::testing::FLAGS_gtest_death_test_style = "fast";
-  return RUN_ALL_TESTS();
-}
-```
-
-## Caveats ##
-
-The _statement_ argument of `ASSERT_EXIT()` can be any valid C++ statement.
-If it leaves the current function via a `return` statement or by throwing an exception,
-the death test is considered to have failed.  Some Google Test macros may return
-from the current function (e.g. `ASSERT_TRUE()`), so be sure to avoid them in _statement_.
-
-Since _statement_ runs in the child process, any in-memory side effect (e.g.
-modifying a variable, releasing memory, etc) it causes will _not_ be observable
-in the parent process. In particular, if you release memory in a death test,
-your program will fail the heap check as the parent process will never see the
-memory reclaimed. To solve this problem, you can
-
-  1. try not to free memory in a death test;
-  1. free the memory again in the parent process; or
-  1. do not use the heap checker in your program.
-
-Due to an implementation detail, you cannot place multiple death test
-assertions on the same line; otherwise, compilation will fail with an unobvious
-error message.
-
-Despite the improved thread safety afforded by the "threadsafe" style of death
-test, thread problems such as deadlock are still possible in the presence of
-handlers registered with `pthread_atfork(3)`.
-
-# Using Assertions in Sub-routines #
-
-## Adding Traces to Assertions ##
-
-If a test sub-routine is called from several places, when an assertion
-inside it fails, it can be hard to tell which invocation of the
-sub-routine the failure is from.  You can alleviate this problem using
-extra logging or custom failure messages, but that usually clutters up
-your tests. A better solution is to use the `SCOPED_TRACE` macro:
-
-| `SCOPED_TRACE(`_message_`);` |
-|:-----------------------------|
-
-where _message_ can be anything streamable to `std::ostream`. This
-macro will cause the current file name, line number, and the given
-message to be added in every failure message. The effect will be
-undone when the control leaves the current lexical scope.
-
-For example,
-
-```
-10: void Sub1(int n) {
-11:   EXPECT_EQ(1, Bar(n));
-12:   EXPECT_EQ(2, Bar(n + 1));
-13: }
-14:
-15: TEST(FooTest, Bar) {
-16:   {
-17:     SCOPED_TRACE("A");  // This trace point will be included in
-18:                         // every failure in this scope.
-19:     Sub1(1);
-20:   }
-21:   // Now it won't.
-22:   Sub1(9);
-23: }
-```
-
-could result in messages like these:
-
-```
-path/to/foo_test.cc:11: Failure
-Value of: Bar(n)
-Expected: 1
-  Actual: 2
-   Trace:
-path/to/foo_test.cc:17: A
-
-path/to/foo_test.cc:12: Failure
-Value of: Bar(n + 1)
-Expected: 2
-  Actual: 3
-```
-
-Without the trace, it would've been difficult to know which invocation
-of `Sub1()` the two failures come from respectively. (You could add an
-extra message to each assertion in `Sub1()` to indicate the value of
-`n`, but that's tedious.)
-
-Some tips on using `SCOPED_TRACE`:
-
-  1. With a suitable message, it's often enough to use `SCOPED_TRACE` at the beginning of a sub-routine, instead of at each call site.
-  1. When calling sub-routines inside a loop, make the loop iterator part of the message in `SCOPED_TRACE` such that you can know which iteration the failure is from.
-  1. Sometimes the line number of the trace point is enough for identifying the particular invocation of a sub-routine. In this case, you don't have to choose a unique message for `SCOPED_TRACE`. You can simply use `""`.
-  1. You can use `SCOPED_TRACE` in an inner scope when there is one in the outer scope. In this case, all active trace points will be included in the failure messages, in reverse order they are encountered.
-  1. The trace dump is clickable in Emacs' compilation buffer - hit return on a line number and you'll be taken to that line in the source file!
-
-_Availability:_ Linux, Windows, Mac.
-
-## Propagating Fatal Failures ##
-
-A common pitfall when using `ASSERT_*` and `FAIL*` is not understanding that
-when they fail they only abort the _current function_, not the entire test. For
-example, the following test will segfault:
-```
-void Subroutine() {
-  // Generates a fatal failure and aborts the current function.
-  ASSERT_EQ(1, 2);
-  // The following won't be executed.
-  ...
-}
-
-TEST(FooTest, Bar) {
-  Subroutine();
-  // The intended behavior is for the fatal failure
-  // in Subroutine() to abort the entire test.
-  // The actual behavior: the function goes on after Subroutine() returns.
-  int* p = NULL;
-  *p = 3; // Segfault!
-}
-```
-
-Since we don't use exceptions, it is technically impossible to
-implement the intended behavior here.  To alleviate this, Google Test
-provides two solutions.  You could use either the
-`(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the
-`HasFatalFailure()` function.  They are described in the following two
-subsections.
-
-### Asserting on Subroutines ###
-
-As shown above, if your test calls a subroutine that has an `ASSERT_*`
-failure in it, the test will continue after the subroutine
-returns. This may not be what you want.
-
-Often people want fatal failures to propagate like exceptions.  For
-that Google Test offers the following macros:
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_NO_FATAL_FAILURE(`_statement_`);` | `EXPECT_NO_FATAL_FAILURE(`_statement_`);` | _statement_ doesn't generate any new fatal failures in the current thread. |
-
-Only failures in the thread that executes the assertion are checked to
-determine the result of this type of assertions.  If _statement_
-creates new threads, failures in these threads are ignored.
-
-Examples:
-
-```
-ASSERT_NO_FATAL_FAILURE(Foo());
-
-int i;
-EXPECT_NO_FATAL_FAILURE({
-  i = Bar();
-});
-```
-
-_Availability:_ Linux, Windows, Mac. Assertions from multiple threads
-are currently not supported.
-
-### Checking for Failures in the Current Test ###
-
-`HasFatalFailure()` in the `::testing::Test` class returns `true` if an
-assertion in the current test has suffered a fatal failure. This
-allows functions to catch fatal failures in a sub-routine and return
-early.
-
-```
-class Test {
- public:
-  ...
-  static bool HasFatalFailure();
-};
-```
-
-The typical usage, which basically simulates the behavior of a thrown
-exception, is:
-
-```
-TEST(FooTest, Bar) {
-  Subroutine();
-  // Aborts if Subroutine() had a fatal failure.
-  if (HasFatalFailure())
-    return;
-  // The following won't be executed.
-  ...
-}
-```
-
-If `HasFatalFailure()` is used outside of `TEST()` , `TEST_F()` , or a test
-fixture, you must add the `::testing::Test::` prefix, as in:
-
-```
-if (::testing::Test::HasFatalFailure())
-  return;
-```
-
-Similarly, `HasNonfatalFailure()` returns `true` if the current test
-has at least one non-fatal failure, and `HasFailure()` returns `true`
-if the current test has at least one failure of either kind.
-
-_Availability:_ Linux, Windows, Mac.  `HasNonfatalFailure()` and
-`HasFailure()` are available since version 1.4.0.
-
-# Logging Additional Information #
-
-In your test code, you can call `RecordProperty("key", value)` to log
-additional information, where `value` can be either a string or an `int`. The _last_ value recorded for a key will be emitted to the XML output
-if you specify one. For example, the test
-
-```
-TEST_F(WidgetUsageTest, MinAndMaxWidgets) {
-  RecordProperty("MaximumWidgets", ComputeMaxUsage());
-  RecordProperty("MinimumWidgets", ComputeMinUsage());
-}
-```
-
-will output XML like this:
-
-```
-...
-  <testcase name="MinAndMaxWidgets" status="run" time="6" classname="WidgetUsageTest"
-            MaximumWidgets="12"
-            MinimumWidgets="9" />
-...
-```
-
-_Note_:
-  * `RecordProperty()` is a static member of the `Test` class. Therefore it needs to be prefixed with `::testing::Test::` if used outside of the `TEST` body and the test fixture class.
-  * `key` must be a valid XML attribute name, and cannot conflict with the ones already used by Google Test (`name`, `status`, `time`, `classname`, `type_param`, and `value_param`).
-  * Calling `RecordProperty()` outside of the lifespan of a test is allowed. If it's called outside of a test but between a test case's `SetUpTestCase()` and `TearDownTestCase()` methods, it will be attributed to the XML element for the test case. If it's called outside of all test cases (e.g. in a test environment), it will be attributed to the top-level XML element.
-
-_Availability_: Linux, Windows, Mac.
-
-# Sharing Resources Between Tests in the Same Test Case #
-
-
-
-Google Test creates a new test fixture object for each test in order to make
-tests independent and easier to debug. However, sometimes tests use resources
-that are expensive to set up, making the one-copy-per-test model prohibitively
-expensive.
-
-If the tests don't change the resource, there's no harm in them sharing a
-single resource copy. So, in addition to per-test set-up/tear-down, Google Test
-also supports per-test-case set-up/tear-down. To use it:
-
-  1. In your test fixture class (say `FooTest` ), define as `static` some member variables to hold the shared resources.
-  1. In the same test fixture class, define a `static void SetUpTestCase()` function (remember not to spell it as **`SetupTestCase`** with a small `u`!) to set up the shared resources and a `static void TearDownTestCase()` function to tear them down.
-
-That's it! Google Test automatically calls `SetUpTestCase()` before running the
-_first test_ in the `FooTest` test case (i.e. before creating the first
-`FooTest` object), and calls `TearDownTestCase()` after running the _last test_
-in it (i.e. after deleting the last `FooTest` object). In between, the tests
-can use the shared resources.
-
-Remember that the test order is undefined, so your code can't depend on a test
-preceding or following another. Also, the tests must either not modify the
-state of any shared resource, or, if they do modify the state, they must
-restore the state to its original value before passing control to the next
-test.
-
-Here's an example of per-test-case set-up and tear-down:
-```
-class FooTest : public ::testing::Test {
- protected:
-  // Per-test-case set-up.
-  // Called before the first test in this test case.
-  // Can be omitted if not needed.
-  static void SetUpTestCase() {
-    shared_resource_ = new ...;
-  }
-
-  // Per-test-case tear-down.
-  // Called after the last test in this test case.
-  // Can be omitted if not needed.
-  static void TearDownTestCase() {
-    delete shared_resource_;
-    shared_resource_ = NULL;
-  }
-
-  // You can define per-test set-up and tear-down logic as usual.
-  virtual void SetUp() { ... }
-  virtual void TearDown() { ... }
-
-  // Some expensive resource shared by all tests.
-  static T* shared_resource_;
-};
-
-T* FooTest::shared_resource_ = NULL;
-
-TEST_F(FooTest, Test1) {
-  ... you can refer to shared_resource here ...
-}
-TEST_F(FooTest, Test2) {
-  ... you can refer to shared_resource here ...
-}
-```
-
-_Availability:_ Linux, Windows, Mac.
-
-# Global Set-Up and Tear-Down #
-
-Just as you can do set-up and tear-down at the test level and the test case
-level, you can also do it at the test program level. Here's how.
-
-First, you subclass the `::testing::Environment` class to define a test
-environment, which knows how to set-up and tear-down:
-
-```
-class Environment {
- public:
-  virtual ~Environment() {}
-  // Override this to define how to set up the environment.
-  virtual void SetUp() {}
-  // Override this to define how to tear down the environment.
-  virtual void TearDown() {}
-};
-```
-
-Then, you register an instance of your environment class with Google Test by
-calling the `::testing::AddGlobalTestEnvironment()` function:
-
-```
-Environment* AddGlobalTestEnvironment(Environment* env);
-```
-
-Now, when `RUN_ALL_TESTS()` is called, it first calls the `SetUp()` method of
-the environment object, then runs the tests if there was no fatal failures, and
-finally calls `TearDown()` of the environment object.
-
-It's OK to register multiple environment objects. In this case, their `SetUp()`
-will be called in the order they are registered, and their `TearDown()` will be
-called in the reverse order.
-
-Note that Google Test takes ownership of the registered environment objects.
-Therefore **do not delete them** by yourself.
-
-You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is
-called, probably in `main()`. If you use `gtest_main`, you need to      call
-this before `main()` starts for it to take effect. One way to do this is to
-define a global variable like this:
-
-```
-::testing::Environment* const foo_env = ::testing::AddGlobalTestEnvironment(new FooEnvironment);
-```
-
-However, we strongly recommend you to write your own `main()` and call
-`AddGlobalTestEnvironment()` there, as relying on initialization of global
-variables makes the code harder to read and may cause problems when you
-register multiple environments from different translation units and the
-environments have dependencies among them (remember that the compiler doesn't
-guarantee the order in which global variables from different translation units
-are initialized).
-
-_Availability:_ Linux, Windows, Mac.
-
-
-# Value Parameterized Tests #
-
-_Value-parameterized tests_ allow you to test your code with different
-parameters without writing multiple copies of the same test.
-
-Suppose you write a test for your code and then realize that your code is affected by a presence of a Boolean command line flag.
-
-```
-TEST(MyCodeTest, TestFoo) {
-  // A code to test foo().
-}
-```
-
-Usually people factor their test code into a function with a Boolean parameter in such situations. The function sets the flag, then executes the testing code.
-
-```
-void TestFooHelper(bool flag_value) {
-  flag = flag_value;
-  // A code to test foo().
-}
-
-TEST(MyCodeTest, TestFoo) {
-  TestFooHelper(false);
-  TestFooHelper(true);
-}
-```
-
-But this setup has serious drawbacks. First, when a test assertion fails in your tests, it becomes unclear what value of the parameter caused it to fail. You can stream a clarifying message into your `EXPECT`/`ASSERT` statements, but it you'll have to do it with all of them. Second, you have to add one such helper function per test. What if you have ten tests? Twenty? A hundred?
-
-Value-parameterized tests will let you write your test only once and then easily instantiate and run it with an arbitrary number of parameter values.
-
-Here are some other situations when value-parameterized tests come handy:
-
-  * You want to test different implementations of an OO interface.
-  * You want to test your code over various inputs (a.k.a. data-driven testing). This feature is easy to abuse, so please exercise your good sense when doing it!
-
-## How to Write Value-Parameterized Tests ##
-
-To write value-parameterized tests, first you should define a fixture
-class.  It must be derived from both `::testing::Test` and
-`::testing::WithParamInterface<T>` (the latter is a pure interface),
-where `T` is the type of your parameter values.  For convenience, you
-can just derive the fixture class from `::testing::TestWithParam<T>`,
-which itself is derived from both `::testing::Test` and
-`::testing::WithParamInterface<T>`. `T` can be any copyable type. If
-it's a raw pointer, you are responsible for managing the lifespan of
-the pointed values.
-
-```
-class FooTest : public ::testing::TestWithParam<const char*> {
-  // You can implement all the usual fixture class members here.
-  // To access the test parameter, call GetParam() from class
-  // TestWithParam<T>.
-};
-
-// Or, when you want to add parameters to a pre-existing fixture class:
-class BaseTest : public ::testing::Test {
-  ...
-};
-class BarTest : public BaseTest,
-                public ::testing::WithParamInterface<const char*> {
-  ...
-};
-```
-
-Then, use the `TEST_P` macro to define as many test patterns using
-this fixture as you want.  The `_P` suffix is for "parameterized" or
-"pattern", whichever you prefer to think.
-
-```
-TEST_P(FooTest, DoesBlah) {
-  // Inside a test, access the test parameter with the GetParam() method
-  // of the TestWithParam<T> class:
-  EXPECT_TRUE(foo.Blah(GetParam()));
-  ...
-}
-
-TEST_P(FooTest, HasBlahBlah) {
-  ...
-}
-```
-
-Finally, you can use `INSTANTIATE_TEST_CASE_P` to instantiate the test
-case with 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 are all in the `testing` namespace:
-
-| `Range(begin, end[, step])` | Yields values `{begin, begin+step, begin+step+step, ...}`. The values do not include `end`. `step` defaults to 1. |
-|:----------------------------|:------------------------------------------------------------------------------------------------------------------|
-| `Values(v1, v2, ..., vN)`   | Yields values `{v1, v2, ..., vN}`.                                                                                |
-| `ValuesIn(container)` and `ValuesIn(begin, end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)`. `container`, `begin`, and `end` can be expressions whose values are determined at run time.  |
-| `Bool()`                    | Yields sequence `{false, true}`.                                                                                  |
-| `Combine(g1, g2, ..., gN)`  | Yields all combinations (the Cartesian product for the math savvy) of the values generated by the `N` generators. This is only available if your system provides the `<tr1/tuple>` header. If you are sure your system does, and Google Test disagrees, you can override it by defining `GTEST_HAS_TR1_TUPLE=1`. See comments in [include/gtest/internal/gtest-port.h](../include/gtest/internal/gtest-port.h) for more information. |
-
-For more details, see the comments at the definitions of these functions in the [source code](../include/gtest/gtest-param-test.h).
-
-The following statement will instantiate tests from the `FooTest` test case
-each with parameter values `"meeny"`, `"miny"`, and `"moe"`.
-
-```
-INSTANTIATE_TEST_CASE_P(InstantiationName,
-                        FooTest,
-                        ::testing::Values("meeny", "miny", "moe"));
-```
-
-To distinguish different instances of the pattern (yes, you can
-instantiate it more than once), the first argument to
-`INSTANTIATE_TEST_CASE_P` is a prefix that will be added to the actual
-test case name. Remember to pick unique prefixes for different
-instantiations. The tests from the instantiation above will have these
-names:
-
-  * `InstantiationName/FooTest.DoesBlah/0` for `"meeny"`
-  * `InstantiationName/FooTest.DoesBlah/1` for `"miny"`
-  * `InstantiationName/FooTest.DoesBlah/2` for `"moe"`
-  * `InstantiationName/FooTest.HasBlahBlah/0` for `"meeny"`
-  * `InstantiationName/FooTest.HasBlahBlah/1` for `"miny"`
-  * `InstantiationName/FooTest.HasBlahBlah/2` for `"moe"`
-
-You can use these names in [--gtest\_filter](#running-a-subset-of-the-tests).
-
-This statement will instantiate all tests from `FooTest` again, each
-with parameter values `"cat"` and `"dog"`:
-
-```
-const char* pets[] = {"cat", "dog"};
-INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest,
-                        ::testing::ValuesIn(pets));
-```
-
-The tests from the instantiation above will have these names:
-
-  * `AnotherInstantiationName/FooTest.DoesBlah/0` for `"cat"`
-  * `AnotherInstantiationName/FooTest.DoesBlah/1` for `"dog"`
-  * `AnotherInstantiationName/FooTest.HasBlahBlah/0` for `"cat"`
-  * `AnotherInstantiationName/FooTest.HasBlahBlah/1` for `"dog"`
-
-Please note that `INSTANTIATE_TEST_CASE_P` will instantiate _all_
-tests in the given test case, whether their definitions come before or
-_after_ the `INSTANTIATE_TEST_CASE_P` statement.
-
-You can see
-[these](../samples/sample7_unittest.cc)
-[files](../samples/sample8_unittest.cc) for more examples.
-
-_Availability_: Linux, Windows (requires MSVC 8.0 or above), Mac; since version 1.2.0.
-
-## Creating Value-Parameterized Abstract Tests ##
-
-In the above, we define and instantiate `FooTest` in the same source
-file. Sometimes you may want to define value-parameterized tests in a
-library and let other people instantiate them later. This pattern is
-known as <i>abstract tests</i>. As an example of its application, when you
-are designing an interface you can write a standard suite of abstract
-tests (perhaps using a factory function as the test parameter) that
-all implementations of the interface are expected to pass. When
-someone implements the interface, he can instantiate your suite to get
-all the interface-conformance tests for free.
-
-To define abstract tests, you should organize your code like this:
-
-  1. Put the definition of the parameterized test fixture class (e.g. `FooTest`) in a header file, say `foo_param_test.h`. Think of this as _declaring_ your abstract tests.
-  1. Put the `TEST_P` definitions in `foo_param_test.cc`, which includes `foo_param_test.h`. Think of this as _implementing_ your abstract tests.
-
-Once they are defined, you can instantiate them by including
-`foo_param_test.h`, invoking `INSTANTIATE_TEST_CASE_P()`, and linking
-with `foo_param_test.cc`. You can instantiate the same abstract test
-case multiple times, possibly in different source files.
-
-# Typed Tests #
-
-Suppose you have multiple implementations of the same interface and
-want to make sure that all of them satisfy some common requirements.
-Or, you may have defined several types that are supposed to conform to
-the same "concept" and you want to verify it.  In both cases, you want
-the same test logic repeated for different types.
-
-While you can write one `TEST` or `TEST_F` for each type you want to
-test (and you may even factor the test logic into a function template
-that you invoke from the `TEST`), it's tedious and doesn't scale:
-if you want _m_ tests over _n_ types, you'll end up writing _m\*n_
-`TEST`s.
-
-_Typed tests_ allow you to repeat the same test logic over a list of
-types.  You only need to write the test logic once, although you must
-know the type list when writing typed tests.  Here's how you do it:
-
-First, define a fixture class template.  It should be parameterized
-by a type.  Remember to derive it from `::testing::Test`:
-
-```
-template <typename T>
-class FooTest : public ::testing::Test {
- public:
-  ...
-  typedef std::list<T> List;
-  static T shared_;
-  T value_;
-};
-```
-
-Next, associate a list of types with the test case, which will be
-repeated for each type in the list:
-
-```
-typedef ::testing::Types<char, int, unsigned int> MyTypes;
-TYPED_TEST_CASE(FooTest, MyTypes);
-```
-
-The `typedef` is necessary for the `TYPED_TEST_CASE` macro to parse
-correctly.  Otherwise the compiler will think that each comma in the
-type list introduces a new macro argument.
-
-Then, use `TYPED_TEST()` instead of `TEST_F()` to define a typed test
-for this test case.  You can repeat this as many times as you want:
-
-```
-TYPED_TEST(FooTest, DoesBlah) {
-  // Inside a test, refer to the special name TypeParam to get the type
-  // parameter.  Since we are inside a derived class template, C++ requires
-  // us to visit the members of FooTest via 'this'.
-  TypeParam n = this->value_;
-
-  // To visit static members of the fixture, add the 'TestFixture::'
-  // prefix.
-  n += TestFixture::shared_;
-
-  // To refer to typedefs in the fixture, add the 'typename TestFixture::'
-  // prefix.  The 'typename' is required to satisfy the compiler.
-  typename TestFixture::List values;
-  values.push_back(n);
-  ...
-}
-
-TYPED_TEST(FooTest, HasPropertyA) { ... }
-```
-
-You can see `samples/sample6_unittest.cc` for a complete example.
-
-_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
-since version 1.1.0.
-
-# Type-Parameterized Tests #
-
-_Type-parameterized tests_ are like typed tests, except that they
-don't require you to know the list of types ahead of time.  Instead,
-you can define the test logic first and instantiate it with different
-type lists later.  You can even instantiate it more than once in the
-same program.
-
-If you are designing an interface or concept, you can define a suite
-of type-parameterized tests to verify properties that any valid
-implementation of the interface/concept should have.  Then, the author
-of each implementation can just instantiate the test suite with his
-type to verify that it conforms to the requirements, without having to
-write similar tests repeatedly.  Here's an example:
-
-First, define a fixture class template, as we did with typed tests:
-
-```
-template <typename T>
-class FooTest : public ::testing::Test {
-  ...
-};
-```
-
-Next, declare that you will define a type-parameterized test case:
-
-```
-TYPED_TEST_CASE_P(FooTest);
-```
-
-The `_P` suffix is for "parameterized" or "pattern", whichever you
-prefer to think.
-
-Then, use `TYPED_TEST_P()` to define a type-parameterized test.  You
-can repeat this as many times as you want:
-
-```
-TYPED_TEST_P(FooTest, DoesBlah) {
-  // Inside a test, refer to TypeParam to get the type parameter.
-  TypeParam n = 0;
-  ...
-}
-
-TYPED_TEST_P(FooTest, HasPropertyA) { ... }
-```
-
-Now the tricky part: you need to register all test patterns using the
-`REGISTER_TYPED_TEST_CASE_P` macro before you can instantiate them.
-The first argument of the macro is the test case name; the rest are
-the names of the tests in this test case:
-
-```
-REGISTER_TYPED_TEST_CASE_P(FooTest,
-                           DoesBlah, HasPropertyA);
-```
-
-Finally, you are free to instantiate the pattern with the types you
-want.  If you put the above code in a header file, you can `#include`
-it in multiple C++ source files and instantiate it multiple times.
-
-```
-typedef ::testing::Types<char, int, unsigned int> MyTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
-```
-
-To distinguish different instances of the pattern, the first argument
-to the `INSTANTIATE_TYPED_TEST_CASE_P` macro is a prefix that will be
-added to the actual test case name.  Remember to pick unique prefixes
-for different instances.
-
-In the special case where the type list contains only one type, you
-can write that type directly without `::testing::Types<...>`, like this:
-
-```
-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
-```
-
-You can see `samples/sample6_unittest.cc` for a complete example.
-
-_Availability:_ Linux, Windows (requires MSVC 8.0 or above), Mac;
-since version 1.1.0.
-
-# Testing Private Code #
-
-If you change your software's internal implementation, your tests should not
-break as long as the change is not observable by users. Therefore, per the
-_black-box testing principle_, most of the time you should test your code
-through its public interfaces.
-
-If you still find yourself needing to test internal implementation code,
-consider if there's a better design that wouldn't require you to do so. If you
-absolutely have to test non-public interface code though, you can. There are
-two cases to consider:
-
-  * Static functions (_not_ the same as static member functions!) or unnamed namespaces, and
-  * Private or protected class members
-
-## Static Functions ##
-
-Both static functions and definitions/declarations in an unnamed namespace are
-only visible within the same translation unit. To test them, you can `#include`
-the entire `.cc` file being tested in your `*_test.cc` file. (`#include`ing `.cc`
-files is not a good way to reuse code - you should not do this in production
-code!)
-
-However, a better approach is to move the private code into the
-`foo::internal` namespace, where `foo` is the namespace your project normally
-uses, and put the private declarations in a `*-internal.h` file. Your
-production `.cc` files and your tests are allowed to include this internal
-header, but your clients are not. This way, you can fully test your internal
-implementation without leaking it to your clients.
-
-## Private Class Members ##
-
-Private class members are only accessible from within the class or by friends.
-To access a class' private members, you can declare your test fixture as a
-friend to the class and define accessors in your fixture. Tests using the
-fixture can then access the private members of your production class via the
-accessors in the fixture. Note that even though your fixture is a friend to
-your production class, your tests are not automatically friends to it, as they
-are technically defined in sub-classes of the fixture.
-
-Another way to test private members is to refactor them into an implementation
-class, which is then declared in a `*-internal.h` file. Your clients aren't
-allowed to include this header but your tests can. Such is called the Pimpl
-(Private Implementation) idiom.
-
-Or, you can declare an individual test as a friend of your class by adding this
-line in the class body:
-
-```
-FRIEND_TEST(TestCaseName, TestName);
-```
-
-For example,
-```
-// foo.h
-#include "gtest/gtest_prod.h"
-
-// Defines FRIEND_TEST.
-class Foo {
-  ...
- private:
-  FRIEND_TEST(FooTest, BarReturnsZeroOnNull);
-  int Bar(void* x);
-};
-
-// foo_test.cc
-...
-TEST(FooTest, BarReturnsZeroOnNull) {
-  Foo foo;
-  EXPECT_EQ(0, foo.Bar(NULL));
-  // Uses Foo's private member Bar().
-}
-```
-
-Pay special attention when your class is defined in a namespace, as you should
-define your test fixtures and tests in the same namespace if you want them to
-be friends of your class. For example, if the code to be tested looks like:
-
-```
-namespace my_namespace {
-
-class Foo {
-  friend class FooTest;
-  FRIEND_TEST(FooTest, Bar);
-  FRIEND_TEST(FooTest, Baz);
-  ...
-  definition of the class Foo
-  ...
-};
-
-}  // namespace my_namespace
-```
-
-Your test code should be something like:
-
-```
-namespace my_namespace {
-class FooTest : public ::testing::Test {
- protected:
-  ...
-};
-
-TEST_F(FooTest, Bar) { ... }
-TEST_F(FooTest, Baz) { ... }
-
-}  // namespace my_namespace
-```
-
-# Catching Failures #
-
-If you are building a testing utility on top of Google Test, you'll
-want to test your utility.  What framework would you use to test it?
-Google Test, of course.
-
-The challenge is to verify that your testing utility reports failures
-correctly.  In frameworks that report a failure by throwing an
-exception, you could catch the exception and assert on it.  But Google
-Test doesn't use exceptions, so how do we test that a piece of code
-generates an expected failure?
-
-`"gtest/gtest-spi.h"` contains some constructs to do this.  After
-`#include`ing this header, you can use
-
-| `EXPECT_FATAL_FAILURE(`_statement, substring_`);` |
-|:--------------------------------------------------|
-
-to assert that _statement_ generates a fatal (e.g. `ASSERT_*`) failure
-whose message contains the given _substring_, or use
-
-| `EXPECT_NONFATAL_FAILURE(`_statement, substring_`);` |
-|:-----------------------------------------------------|
-
-if you are expecting a non-fatal (e.g. `EXPECT_*`) failure.
-
-For technical reasons, there are some caveats:
-
-  1. You cannot stream a failure message to either macro.
-  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot reference local non-static variables or non-static members of `this` object.
-  1. _statement_ in `EXPECT_FATAL_FAILURE()` cannot return a value.
-
-_Note:_ Google Test is designed with threads in mind.  Once the
-synchronization primitives in `"gtest/internal/gtest-port.h"` have
-been implemented, Google Test will become thread-safe, meaning that
-you can then use assertions in multiple threads concurrently.  Before
-
-that, however, Google Test only supports single-threaded usage.  Once
-thread-safe, `EXPECT_FATAL_FAILURE()` and `EXPECT_NONFATAL_FAILURE()`
-will capture failures in the current thread only. If _statement_
-creates new threads, failures in these threads will be ignored.  If
-you want to capture failures from all threads instead, you should use
-the following macros:
-
-| `EXPECT_FATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
-|:-----------------------------------------------------------------|
-| `EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(`_statement, substring_`);` |
-
-# Getting the Current Test's Name #
-
-Sometimes a function may need to know the name of the currently running test.
-For example, you may be using the `SetUp()` method of your test fixture to set
-the golden file name based on which test is running. The `::testing::TestInfo`
-class has this information:
-
-```
-namespace testing {
-
-class TestInfo {
- public:
-  // Returns the test case name and the test name, respectively.
-  //
-  // Do NOT delete or free the return value - it's managed by the
-  // TestInfo class.
-  const char* test_case_name() const;
-  const char* name() const;
-};
-
-}  // namespace testing
-```
-
-
-> To obtain a `TestInfo` object for the currently running test, call
-`current_test_info()` on the `UnitTest` singleton object:
-
-```
-// Gets information about the currently running test.
-// Do NOT delete the returned object - it's managed by the UnitTest class.
-const ::testing::TestInfo* const test_info =
-  ::testing::UnitTest::GetInstance()->current_test_info();
-printf("We are in test %s of test case %s.\n",
-       test_info->name(), test_info->test_case_name());
-```
-
-`current_test_info()` returns a null pointer if no test is running. In
-particular, you cannot find the test case name in `TestCaseSetUp()`,
-`TestCaseTearDown()` (where you know the test case name implicitly), or
-functions called from them.
-
-_Availability:_ Linux, Windows, Mac.
-
-# Extending Google Test by Handling Test Events #
-
-Google Test provides an <b>event listener API</b> to let you receive
-notifications about the progress of a test program and test
-failures. The events you can listen to include the start and end of
-the test program, a test case, or a test method, among others. You may
-use this API to augment or replace the standard console output,
-replace the XML output, or provide a completely different form of
-output, such as a GUI or a database. You can also use test events as
-checkpoints to implement a resource leak checker, for example.
-
-_Availability:_ Linux, Windows, Mac; since v1.4.0.
-
-## Defining Event Listeners ##
-
-To define a event listener, you subclass either
-[testing::TestEventListener](../include/gtest/gtest.h#L855)
-or [testing::EmptyTestEventListener](../include/gtest/gtest.h#L905).
-The former is an (abstract) interface, where <i>each pure virtual method<br>
-can be overridden to handle a test event</i> (For example, when a test
-starts, the `OnTestStart()` method will be called.). The latter provides
-an empty implementation of all methods in the interface, such that a
-subclass only needs to override the methods it cares about.
-
-When an event is fired, its context is passed to the handler function
-as an argument. The following argument types are used:
-  * [UnitTest](../include/gtest/gtest.h#L1007) reflects the state of the entire test program,
-  * [TestCase](../include/gtest/gtest.h#L689) has information about a test case, which can contain one or more tests,
-  * [TestInfo](../include/gtest/gtest.h#L599) contains the state of a test, and
-  * [TestPartResult](../include/gtest/gtest-test-part.h#L42) represents the result of a test assertion.
-
-An event handler function can examine the argument it receives to find
-out interesting information about the event and the test program's
-state.  Here's an example:
-
-```
-  class MinimalistPrinter : public ::testing::EmptyTestEventListener {
-    // Called before a test starts.
-    virtual void OnTestStart(const ::testing::TestInfo& test_info) {
-      printf("*** Test %s.%s starting.\n",
-             test_info.test_case_name(), test_info.name());
-    }
-
-    // Called after a failed assertion or a SUCCEED() invocation.
-    virtual void OnTestPartResult(
-        const ::testing::TestPartResult& test_part_result) {
-      printf("%s in %s:%d\n%s\n",
-             test_part_result.failed() ? "*** Failure" : "Success",
-             test_part_result.file_name(),
-             test_part_result.line_number(),
-             test_part_result.summary());
-    }
-
-    // Called after a test ends.
-    virtual void OnTestEnd(const ::testing::TestInfo& test_info) {
-      printf("*** Test %s.%s ending.\n",
-             test_info.test_case_name(), test_info.name());
-    }
-  };
-```
-
-## Using Event Listeners ##
-
-To use the event listener you have defined, add an instance of it to
-the Google Test event listener list (represented by class
-[TestEventListeners](../include/gtest/gtest.h#L929)
-- note the "s" at the end of the name) in your
-`main()` function, before calling `RUN_ALL_TESTS()`:
-```
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  // Gets hold of the event listener list.
-  ::testing::TestEventListeners& listeners =
-      ::testing::UnitTest::GetInstance()->listeners();
-  // Adds a listener to the end.  Google Test takes the ownership.
-  listeners.Append(new MinimalistPrinter);
-  return RUN_ALL_TESTS();
-}
-```
-
-There's only one problem: the default test result printer is still in
-effect, so its output will mingle with the output from your minimalist
-printer. To suppress the default printer, just release it from the
-event listener list and delete it. You can do so by adding one line:
-```
-  ...
-  delete listeners.Release(listeners.default_result_printer());
-  listeners.Append(new MinimalistPrinter);
-  return RUN_ALL_TESTS();
-```
-
-Now, sit back and enjoy a completely different output from your
-tests. For more details, you can read this
-[sample](../samples/sample9_unittest.cc).
-
-You may append more than one listener to the list. When an `On*Start()`
-or `OnTestPartResult()` event is fired, the listeners will receive it in
-the order they appear in the list (since new listeners are added to
-the end of the list, the default text printer and the default XML
-generator will receive the event first). An `On*End()` event will be
-received by the listeners in the _reverse_ order. This allows output by
-listeners added later to be framed by output from listeners added
-earlier.
-
-## Generating Failures in Listeners ##
-
-You may use failure-raising macros (`EXPECT_*()`, `ASSERT_*()`,
-`FAIL()`, etc) when processing an event. There are some restrictions:
-
-  1. You cannot generate any failure in `OnTestPartResult()` (otherwise it will cause `OnTestPartResult()` to be called recursively).
-  1. A listener that handles `OnTestPartResult()` is not allowed to generate any failure.
-
-When you add listeners to the listener list, you should put listeners
-that handle `OnTestPartResult()` _before_ listeners that can generate
-failures. This ensures that failures generated by the latter are
-attributed to the right test by the former.
-
-We have a sample of failure-raising listener
-[here](../samples/sample10_unittest.cc).
-
-# Running Test Programs: Advanced Options #
-
-Google Test test programs are ordinary executables. Once built, you can run
-them directly and affect their behavior via the following environment variables
-and/or command line flags. For the flags to work, your programs must call
-`::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`.
-
-To see a list of supported flags and their usage, please run your test
-program with the `--help` flag.  You can also use `-h`, `-?`, or `/?`
-for short.  This feature is added in version 1.3.0.
-
-If an option is specified both by an environment variable and by a
-flag, the latter takes precedence.  Most of the options can also be
-set/read in code: to access the value of command line flag
-`--gtest_foo`, write `::testing::GTEST_FLAG(foo)`.  A common pattern is
-to set the value of a flag before calling `::testing::InitGoogleTest()`
-to change the default value of the flag:
-```
-int main(int argc, char** argv) {
-  // Disables elapsed time by default.
-  ::testing::GTEST_FLAG(print_time) = false;
-
-  // This allows the user to override the flag on the command line.
-  ::testing::InitGoogleTest(&argc, argv);
-
-  return RUN_ALL_TESTS();
-}
-```
-
-## Selecting Tests ##
-
-This section shows various options for choosing which tests to run.
-
-### Listing Test Names ###
-
-Sometimes it is necessary to list the available tests in a program before
-running them so that a filter may be applied if needed. Including the flag
-`--gtest_list_tests` overrides all other flags and lists tests in the following
-format:
-```
-TestCase1.
-  TestName1
-  TestName2
-TestCase2.
-  TestName
-```
-
-None of the tests listed are actually run if the flag is provided. There is no
-corresponding environment variable for this flag.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Running a Subset of the Tests ###
-
-By default, a Google Test program runs all tests the user has defined.
-Sometimes, you want to run only a subset of the tests (e.g. for debugging or
-quickly verifying a change). If you set the `GTEST_FILTER` environment variable
-or the `--gtest_filter` flag to a filter string, Google Test will only run the
-tests whose full names (in the form of `TestCaseName.TestName`) match the
-filter.
-
-The format of a filter is a '`:`'-separated list of wildcard patterns (called
-the positive patterns) optionally followed by a '`-`' and another
-'`:`'-separated pattern list (called the negative patterns). A test matches the
-filter if and only if it matches any of the positive patterns but does not
-match any of the negative patterns.
-
-A pattern may contain `'*'` (matches any string) or `'?'` (matches any single
-character). For convenience, the filter `'*-NegativePatterns'` can be also
-written as `'-NegativePatterns'`.
-
-For example:
-
-  * `./foo_test` Has no flag, and thus runs all its tests.
-  * `./foo_test --gtest_filter=*` Also runs everything, due to the single match-everything `*` value.
-  * `./foo_test --gtest_filter=FooTest.*` Runs everything in test case `FooTest`.
-  * `./foo_test --gtest_filter=*Null*:*Constructor*` Runs any test whose full name contains either `"Null"` or `"Constructor"`.
-  * `./foo_test --gtest_filter=-*DeathTest.*` Runs all non-death tests.
-  * `./foo_test --gtest_filter=FooTest.*-FooTest.Bar` Runs everything in test case `FooTest` except `FooTest.Bar`.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Temporarily Disabling Tests ###
-
-If you have a broken test that you cannot fix right away, you can add the
-`DISABLED_` prefix to its name. This will exclude it from execution. This is
-better than commenting out the code or using `#if 0`, as disabled tests are
-still compiled (and thus won't rot).
-
-If you need to disable all tests in a test case, you can either add `DISABLED_`
-to the front of the name of each test, or alternatively add it to the front of
-the test case name.
-
-For example, the following tests won't be run by Google Test, even though they
-will still be compiled:
-
-```
-// Tests that Foo does Abc.
-TEST(FooTest, DISABLED_DoesAbc) { ... }
-
-class DISABLED_BarTest : public ::testing::Test { ... };
-
-// Tests that Bar does Xyz.
-TEST_F(DISABLED_BarTest, DoesXyz) { ... }
-```
-
-_Note:_ This feature should only be used for temporary pain-relief. You still
-have to fix the disabled tests at a later date. As a reminder, Google Test will
-print a banner warning you if a test program contains any disabled tests.
-
-_Tip:_ You can easily count the number of disabled tests you have
-using `grep`. This number can be used as a metric for improving your
-test quality.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Temporarily Enabling Disabled Tests ###
-
-To include [disabled tests](#temporarily-disabling-tests) in test
-execution, just invoke the test program with the
-`--gtest_also_run_disabled_tests` flag or set the
-`GTEST_ALSO_RUN_DISABLED_TESTS` environment variable to a value other
-than `0`.  You can combine this with the
-[--gtest\_filter](#running-a-subset-of-the-tests) flag to further select
-which disabled tests to run.
-
-_Availability:_ Linux, Windows, Mac; since version 1.3.0.
-
-## Repeating the Tests ##
-
-Once in a while you'll run into a test whose result is hit-or-miss. Perhaps it
-will fail only 1% of the time, making it rather hard to reproduce the bug under
-a debugger. This can be a major source of frustration.
-
-The `--gtest_repeat` flag allows you to repeat all (or selected) test methods
-in a program many times. Hopefully, a flaky test will eventually fail and give
-you a chance to debug. Here's how to use it:
-
-| `$ foo_test --gtest_repeat=1000` | Repeat foo\_test 1000 times and don't stop at failures. |
-|:---------------------------------|:--------------------------------------------------------|
-| `$ foo_test --gtest_repeat=-1`   | A negative count means repeating forever.               |
-| `$ foo_test --gtest_repeat=1000 --gtest_break_on_failure` | Repeat foo\_test 1000 times, stopping at the first failure. This is especially useful when running under a debugger: when the testfails, it will drop into the debugger and you can then inspect variables and stacks. |
-| `$ foo_test --gtest_repeat=1000 --gtest_filter=FooBar` | Repeat the tests whose name matches the filter 1000 times. |
-
-If your test program contains global set-up/tear-down code registered
-using `AddGlobalTestEnvironment()`, it will be repeated in each
-iteration as well, as the flakiness may be in it. You can also specify
-the repeat count by setting the `GTEST_REPEAT` environment variable.
-
-_Availability:_ Linux, Windows, Mac.
-
-## Shuffling the Tests ##
-
-You can specify the `--gtest_shuffle` flag (or set the `GTEST_SHUFFLE`
-environment variable to `1`) to run the tests in a program in a random
-order. This helps to reveal bad dependencies between tests.
-
-By default, Google Test uses a random seed calculated from the current
-time. Therefore you'll get a different order every time. The console
-output includes the random seed value, such that you can reproduce an
-order-related test failure later. To specify the random seed
-explicitly, use the `--gtest_random_seed=SEED` flag (or set the
-`GTEST_RANDOM_SEED` environment variable), where `SEED` is an integer
-between 0 and 99999. The seed value 0 is special: it tells Google Test
-to do the default behavior of calculating the seed from the current
-time.
-
-If you combine this with `--gtest_repeat=N`, Google Test will pick a
-different random seed and re-shuffle the tests in each iteration.
-
-_Availability:_ Linux, Windows, Mac; since v1.4.0.
-
-## Controlling Test Output ##
-
-This section teaches how to tweak the way test results are reported.
-
-### Colored Terminal Output ###
-
-Google Test can use colors in its terminal output to make it easier to spot
-the separation between tests, and whether tests passed.
-
-You can set the GTEST\_COLOR environment variable or set the `--gtest_color`
-command line flag to `yes`, `no`, or `auto` (the default) to enable colors,
-disable colors, or let Google Test decide. When the value is `auto`, Google
-Test will use colors if and only if the output goes to a terminal and (on
-non-Windows platforms) the `TERM` environment variable is set to `xterm` or
-`xterm-color`.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Suppressing the Elapsed Time ###
-
-By default, Google Test prints the time it takes to run each test.  To
-suppress that, run the test program with the `--gtest_print_time=0`
-command line flag.  Setting the `GTEST_PRINT_TIME` environment
-variable to `0` has the same effect.
-
-_Availability:_ Linux, Windows, Mac.  (In Google Test 1.3.0 and lower,
-the default behavior is that the elapsed time is **not** printed.)
-
-### Generating an XML Report ###
-
-Google Test can emit a detailed XML report to a file in addition to its normal
-textual output. The report contains the duration of each test, and thus can
-help you identify slow tests.
-
-To generate the XML report, set the `GTEST_OUTPUT` environment variable or the
-`--gtest_output` flag to the string `"xml:_path_to_output_file_"`, which will
-create the file at the given location. You can also just use the string
-`"xml"`, in which case the output can be found in the `test_detail.xml` file in
-the current directory.
-
-If you specify a directory (for example, `"xml:output/directory/"` on Linux or
-`"xml:output\directory\"` on Windows), Google Test will create the XML file in
-that directory, named after the test executable (e.g. `foo_test.xml` for test
-program `foo_test` or `foo_test.exe`). If the file already exists (perhaps left
-over from a previous run), Google Test will pick a different name (e.g.
-`foo_test_1.xml`) to avoid overwriting it.
-
-The report uses the format described here.  It is based on the
-`junitreport` Ant task and can be parsed by popular continuous build
-systems like [Jenkins](http://jenkins-ci.org/). Since that format
-was originally intended for Java, a little interpretation is required
-to make it apply to Google Test tests, as shown here:
-
-```
-<testsuites name="AllTests" ...>
-  <testsuite name="test_case_name" ...>
-    <testcase name="test_name" ...>
-      <failure message="..."/>
-      <failure message="..."/>
-      <failure message="..."/>
-    </testcase>
-  </testsuite>
-</testsuites>
-```
-
-  * The root `<testsuites>` element corresponds to the entire test program.
-  * `<testsuite>` elements correspond to Google Test test cases.
-  * `<testcase>` elements correspond to Google Test test functions.
-
-For instance, the following program
-
-```
-TEST(MathTest, Addition) { ... }
-TEST(MathTest, Subtraction) { ... }
-TEST(LogicTest, NonContradiction) { ... }
-```
-
-could generate this report:
-
-```
-<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="3" failures="1" errors="0" time="35" name="AllTests">
-  <testsuite name="MathTest" tests="2" failures="1" errors="0" time="15">
-    <testcase name="Addition" status="run" time="7" classname="">
-      <failure message="Value of: add(1, 1)&#x0A; Actual: 3&#x0A;Expected: 2" type=""/>
-      <failure message="Value of: add(1, -1)&#x0A; Actual: 1&#x0A;Expected: 0" type=""/>
-    </testcase>
-    <testcase name="Subtraction" status="run" time="5" classname="">
-    </testcase>
-  </testsuite>
-  <testsuite name="LogicTest" tests="1" failures="0" errors="0" time="5">
-    <testcase name="NonContradiction" status="run" time="5" classname="">
-    </testcase>
-  </testsuite>
-</testsuites>
-```
-
-Things to note:
-
-  * The `tests` attribute of a `<testsuites>` or `<testsuite>` element tells how many test functions the Google Test program or test case contains, while the `failures` attribute tells how many of them failed.
-  * The `time` attribute expresses the duration of the test, test case, or entire test program in milliseconds.
-  * Each `<failure>` element corresponds to a single failed Google Test assertion.
-  * Some JUnit concepts don't apply to Google Test, yet we have to conform to the DTD. Therefore you'll see some dummy elements and attributes in the report. You can safely ignore these parts.
-
-_Availability:_ Linux, Windows, Mac.
-
-## Controlling How Failures Are Reported ##
-
-### Turning Assertion Failures into Break-Points ###
-
-When running test programs under a debugger, it's very convenient if the
-debugger can catch an assertion failure and automatically drop into interactive
-mode. Google Test's _break-on-failure_ mode supports this behavior.
-
-To enable it, set the `GTEST_BREAK_ON_FAILURE` environment variable to a value
-other than `0` . Alternatively, you can use the `--gtest_break_on_failure`
-command line flag.
-
-_Availability:_ Linux, Windows, Mac.
-
-### Disabling Catching Test-Thrown Exceptions ###
-
-Google Test can be used either with or without exceptions enabled.  If
-a test throws a C++ exception or (on Windows) a structured exception
-(SEH), by default Google Test catches it, reports it as a test
-failure, and continues with the next test method.  This maximizes the
-coverage of a test run.  Also, on Windows an uncaught exception will
-cause a pop-up window, so catching the exceptions allows you to run
-the tests automatically.
-
-When debugging the test failures, however, you may instead want the
-exceptions to be handled by the debugger, such that you can examine
-the call stack when an exception is thrown.  To achieve that, set the
-`GTEST_CATCH_EXCEPTIONS` environment variable to `0`, or use the
-`--gtest_catch_exceptions=0` flag when running the tests.
-
-**Availability**: Linux, Windows, Mac.
-
-### Letting Another Testing Framework Drive ###
-
-If you work on a project that has already been using another testing
-framework and is not ready to completely switch to Google Test yet,
-you can get much of Google Test's benefit by using its assertions in
-your existing tests.  Just change your `main()` function to look
-like:
-
-```
-#include "gtest/gtest.h"
-
-int main(int argc, char** argv) {
-  ::testing::GTEST_FLAG(throw_on_failure) = true;
-  // Important: Google Test must be initialized.
-  ::testing::InitGoogleTest(&argc, argv);
-
-  ... whatever your existing testing framework requires ...
-}
-```
-
-With that, you can use Google Test assertions in addition to the
-native assertions your testing framework provides, for example:
-
-```
-void TestFooDoesBar() {
-  Foo foo;
-  EXPECT_LE(foo.Bar(1), 100);     // A Google Test assertion.
-  CPPUNIT_ASSERT(foo.IsEmpty());  // A native assertion.
-}
-```
-
-If a Google Test assertion fails, it will print an error message and
-throw an exception, which will be treated as a failure by your host
-testing framework.  If you compile your code with exceptions disabled,
-a failed Google Test assertion will instead exit your program with a
-non-zero code, which will also signal a test failure to your test
-runner.
-
-If you don't write `::testing::GTEST_FLAG(throw_on_failure) = true;` in
-your `main()`, you can alternatively enable this feature by specifying
-the `--gtest_throw_on_failure` flag on the command-line or setting the
-`GTEST_THROW_ON_FAILURE` environment variable to a non-zero value.
-
-Death tests are _not_ supported when other test framework is used to organize tests.
-
-_Availability:_ Linux, Windows, Mac; since v1.3.0.
-
-## Distributing Test Functions to Multiple Machines ##
-
-If you have more than one machine you can use to run a test program,
-you might want to run the test functions in parallel and get the
-result faster.  We call this technique _sharding_, where each machine
-is called a _shard_.
-
-Google Test is compatible with test sharding.  To take advantage of
-this feature, your test runner (not part of Google Test) needs to do
-the following:
-
-  1. Allocate a number of machines (shards) to run the tests.
-  1. On each shard, set the `GTEST_TOTAL_SHARDS` environment variable to the total number of shards.  It must be the same for all shards.
-  1. On each shard, set the `GTEST_SHARD_INDEX` environment variable to the index of the shard.  Different shards must be assigned different indices, which must be in the range `[0, GTEST_TOTAL_SHARDS - 1]`.
-  1. Run the same test program on all shards.  When Google Test sees the above two environment variables, it will select a subset of the test functions to run.  Across all shards, each test function in the program will be run exactly once.
-  1. Wait for all shards to finish, then collect and report the results.
-
-Your project may have tests that were written without Google Test and
-thus don't understand this protocol.  In order for your test runner to
-figure out which test supports sharding, it can set the environment
-variable `GTEST_SHARD_STATUS_FILE` to a non-existent file path.  If a
-test program supports sharding, it will create this file to
-acknowledge the fact (the actual contents of the file are not
-important at this time; although we may stick some useful information
-in it in the future.); otherwise it will not create it.
-
-Here's an example to make it clear.  Suppose you have a test program
-`foo_test` that contains the following 5 test functions:
-```
-TEST(A, V)
-TEST(A, W)
-TEST(B, X)
-TEST(B, Y)
-TEST(B, Z)
-```
-and you have 3 machines at your disposal.  To run the test functions in
-parallel, you would set `GTEST_TOTAL_SHARDS` to 3 on all machines, and
-set `GTEST_SHARD_INDEX` to 0, 1, and 2 on the machines respectively.
-Then you would run the same `foo_test` on each machine.
-
-Google Test reserves the right to change how the work is distributed
-across the shards, but here's one possible scenario:
-
-  * Machine #0 runs `A.V` and `B.X`.
-  * Machine #1 runs `A.W` and `B.Y`.
-  * Machine #2 runs `B.Z`.
-
-_Availability:_ Linux, Windows, Mac; since version 1.3.0.
-
-# Fusing Google Test Source Files #
-
-Google Test's implementation consists of ~30 files (excluding its own
-tests).  Sometimes you may want them to be packaged up in two files (a
-`.h` and a `.cc`) instead, such that you can easily copy them to a new
-machine and start hacking there.  For this we provide an experimental
-Python script `fuse_gtest_files.py` in the `scripts/` directory (since release 1.3.0).
-Assuming you have Python 2.4 or above installed on your machine, just
-go to that directory and run
-```
-python fuse_gtest_files.py OUTPUT_DIR
-```
-
-and you should see an `OUTPUT_DIR` directory being created with files
-`gtest/gtest.h` and `gtest/gtest-all.cc` in it.  These files contain
-everything you need to use Google Test.  Just copy them to anywhere
-you want and you are ready to write tests.  You can use the
-[scripts/test/Makefile](../scripts/test/Makefile)
-file as an example on how to compile your tests against them.
-
-# Where to Go from Here #
-
-Congratulations! You've now learned more advanced Google Test tools and are
-ready to tackle more complex testing tasks. If you want to dive even deeper, you
-can read the [Frequently-Asked Questions](V1_7_FAQ.md).
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Documentation.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Documentation.md
deleted file mode 100644
index 282697a5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Documentation.md
+++ /dev/null
@@ -1,14 +0,0 @@
-This page lists all documentation wiki pages for Google Test **(the SVN trunk version)**
--- **if you use a released version of Google Test, please read the
-documentation for that specific version instead.**
-
-  * [Primer](V1_7_Primer.md) -- start here if you are new to Google Test.
-  * [Samples](V1_7_Samples.md) -- learn from examples.
-  * [AdvancedGuide](V1_7_AdvancedGuide.md) -- learn more about Google Test.
-  * [XcodeGuide](V1_7_XcodeGuide.md) -- how to use Google Test in Xcode on Mac.
-  * [Frequently-Asked Questions](V1_7_FAQ.md) -- check here before asking a question on the mailing list.
-
-To contribute code to Google Test, read:
-
-  * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
-  * [PumpManual](V1_7_PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_FAQ.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_FAQ.md
deleted file mode 100644
index 3dd914dc..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_FAQ.md
+++ /dev/null
@@ -1,1082 +0,0 @@
-
-
-If you cannot find the answer to your question here, and you have read
-[Primer](V1_7_Primer.md) and [AdvancedGuide](V1_7_AdvancedGuide.md), send it to
-googletestframework@googlegroups.com.
-
-## Why should I use Google Test instead of my favorite C++ testing framework? ##
-
-First, let us say clearly that we don't want to get into the debate of
-which C++ testing framework is **the best**.  There exist many fine
-frameworks for writing C++ tests, and we have tremendous respect for
-the developers and users of them.  We don't think there is (or will
-be) a single best framework - you have to pick the right tool for the
-particular task you are tackling.
-
-We created Google Test because we couldn't find the right combination
-of features and conveniences in an existing framework to satisfy _our_
-needs.  The following is a list of things that _we_ like about Google
-Test.  We don't claim them to be unique to Google Test - rather, the
-combination of them makes Google Test the choice for us.  We hope this
-list can help you decide whether it is for you too.
-
-  * Google Test is designed to be portable: it doesn't require exceptions or RTTI; it works around various bugs in various compilers and environments; etc.  As a result, it works on Linux, Mac OS X, Windows and several embedded operating systems.
-  * Nonfatal assertions (`EXPECT_*`) have proven to be great time savers, as they allow a test to report multiple failures in a single edit-compile-test cycle.
-  * It's easy to write assertions that generate informative messages: you just use the stream syntax to append any additional information, e.g. `ASSERT_EQ(5, Foo(i)) << " where i = " << i;`.  It doesn't require a new set of macros or special functions.
-  * Google Test automatically detects your tests and doesn't require you to enumerate them in order to run them.
-  * Death tests are pretty handy for ensuring that your asserts in production code are triggered by the right conditions.
-  * `SCOPED_TRACE` helps you understand the context of an assertion failure when it comes from inside a sub-routine or loop.
-  * You can decide which tests to run using name patterns.  This saves time when you want to quickly reproduce a test failure.
-  * Google Test can generate XML test result reports that can be parsed by popular continuous build system like Hudson.
-  * Simple things are easy in Google Test, while hard things are possible: in addition to advanced features like [global test environments](V1_7_AdvancedGuide.md#global-set-up-and-tear-down) and tests parameterized by [values](V1_7_AdvancedGuide.md#value-parameterized-tests) or [types](V1_7_AdvancedGuide.md#typed-tests), Google Test supports various ways for the user to extend the framework -- if Google Test doesn't do something out of the box, chances are that a user can implement the feature using Google Test's public API, without changing Google Test itself.  In particular, you can:
-    * expand your testing vocabulary by defining [custom predicates](V1_7_AdvancedGuide.md#predicate-assertions-for-better-error-messages),
-    * teach Google Test how to [print your types](V1_7_AdvancedGuide.md#teaching-google-test-how-to-print-your-values),
-    * define your own testing macros or utilities and verify them using Google Test's [Service Provider Interface](V1_7_AdvancedGuide.md#catching-failures), and
-    * reflect on the test cases or change the test output format by intercepting the [test events](V1_7_AdvancedGuide.md#extending-google-test-by-handling-test-events).
-
-## I'm getting warnings when compiling Google Test.  Would you fix them? ##
-
-We strive to minimize compiler warnings Google Test generates.  Before releasing a new version, we test to make sure that it doesn't generate warnings when compiled using its CMake script on Windows, Linux, and Mac OS.
-
-Unfortunately, this doesn't mean you are guaranteed to see no warnings when compiling Google Test in your environment:
-
-  * You may be using a different compiler as we use, or a different version of the same compiler.  We cannot possibly test for all compilers.
-  * You may be compiling on a different platform as we do.
-  * Your project may be using different compiler flags as we do.
-
-It is not always possible to make Google Test warning-free for everyone.  Or, it may not be desirable if the warning is rarely enabled and fixing the violations makes the code more complex.
-
-If you see warnings when compiling Google Test, we suggest that you use the `-isystem` flag (assuming your are using GCC) to mark Google Test headers as system headers.  That'll suppress warnings from Google Test headers.
-
-## Why should not test case names and test names contain underscore? ##
-
-Underscore (`_`) is special, as C++ reserves the following to be used by
-the compiler and the standard library:
-
-  1. any identifier that starts with an `_` followed by an upper-case letter, and
-  1. any identifier that containers two consecutive underscores (i.e. `__`) _anywhere_ in its name.
-
-User code is _prohibited_ from using such identifiers.
-
-Now let's look at what this means for `TEST` and `TEST_F`.
-
-Currently `TEST(TestCaseName, TestName)` generates a class named
-`TestCaseName_TestName_Test`.  What happens if `TestCaseName` or `TestName`
-contains `_`?
-
-  1. If `TestCaseName` starts with an `_` followed by an upper-case letter (say, `_Foo`), we end up with `_Foo_TestName_Test`, which is reserved and thus invalid.
-  1. If `TestCaseName` ends with an `_` (say, `Foo_`), we get `Foo__TestName_Test`, which is invalid.
-  1. If `TestName` starts with an `_` (say, `_Bar`), we get `TestCaseName__Bar_Test`, which is invalid.
-  1. If `TestName` ends with an `_` (say, `Bar_`), we get `TestCaseName_Bar__Test`, which is invalid.
-
-So clearly `TestCaseName` and `TestName` cannot start or end with `_`
-(Actually, `TestCaseName` can start with `_` -- as long as the `_` isn't
-followed by an upper-case letter.  But that's getting complicated.  So
-for simplicity we just say that it cannot start with `_`.).
-
-It may seem fine for `TestCaseName` and `TestName` to contain `_` in the
-middle.  However, consider this:
-```
-TEST(Time, Flies_Like_An_Arrow) { ... }
-TEST(Time_Flies, Like_An_Arrow) { ... }
-```
-
-Now, the two `TEST`s will both generate the same class
-(`Time_Files_Like_An_Arrow_Test`).  That's not good.
-
-So for simplicity, we just ask the users to avoid `_` in `TestCaseName`
-and `TestName`.  The rule is more constraining than necessary, but it's
-simple and easy to remember.  It also gives Google Test some wiggle
-room in case its implementation needs to change in the future.
-
-If you violate the rule, there may not be immediately consequences,
-but your test may (just may) break with a new compiler (or a new
-version of the compiler you are using) or with a new version of Google
-Test.  Therefore it's best to follow the rule.
-
-## Why is it not recommended to install a pre-compiled copy of Google Test (for example, into /usr/local)? ##
-
-In the early days, we said that you could install
-compiled Google Test libraries on `*`nix systems using `make install`.
-Then every user of your machine can write tests without
-recompiling Google Test.
-
-This seemed like a good idea, but it has a
-got-cha: every user needs to compile his tests using the _same_ compiler
-flags used to compile the installed Google Test libraries; otherwise
-he may run into undefined behaviors (i.e. the tests can behave
-strangely and may even crash for no obvious reasons).
-
-Why?  Because C++ has this thing called the One-Definition Rule: if
-two C++ source files contain different definitions of the same
-class/function/variable, and you link them together, you violate the
-rule.  The linker may or may not catch the error (in many cases it's
-not required by the C++ standard to catch the violation).  If it
-doesn't, you get strange run-time behaviors that are unexpected and
-hard to debug.
-
-If you compile Google Test and your test code using different compiler
-flags, they may see different definitions of the same
-class/function/variable (e.g. due to the use of `#if` in Google Test).
-Therefore, for your sanity, we recommend to avoid installing pre-compiled
-Google Test libraries.  Instead, each project should compile
-Google Test itself such that it can be sure that the same flags are
-used for both Google Test and the tests.
-
-## How do I generate 64-bit binaries on Windows (using Visual Studio 2008)? ##
-
-(Answered by Trevor Robinson)
-
-Load the supplied Visual Studio solution file, either `msvc\gtest-md.sln` or
-`msvc\gtest.sln`. Go through the migration wizard to migrate the
-solution and project files to Visual Studio 2008. Select
-`Configuration Manager...` from the `Build` menu. Select `<New...>` from
-the `Active solution platform` dropdown.  Select `x64` from the new
-platform dropdown, leave `Copy settings from` set to `Win32` and
-`Create new project platforms` checked, then click `OK`. You now have
-`Win32` and `x64` platform configurations, selectable from the
-`Standard` toolbar, which allow you to toggle between building 32-bit or
-64-bit binaries (or both at once using Batch Build).
-
-In order to prevent build output files from overwriting one another,
-you'll need to change the `Intermediate Directory` settings for the
-newly created platform configuration across all the projects. To do
-this, multi-select (e.g. using shift-click) all projects (but not the
-solution) in the `Solution Explorer`. Right-click one of them and
-select `Properties`. In the left pane, select `Configuration Properties`,
-and from the `Configuration` dropdown, select `All Configurations`.
-Make sure the selected platform is `x64`. For the
-`Intermediate Directory` setting, change the value from
-`$(PlatformName)\$(ConfigurationName)` to
-`$(OutDir)\$(ProjectName)`. Click `OK` and then build the
-solution. When the build is complete, the 64-bit binaries will be in
-the `msvc\x64\Debug` directory.
-
-## Can I use Google Test on MinGW? ##
-
-We haven't tested this ourselves, but Per Abrahamsen reported that he
-was able to compile and install Google Test successfully when using
-MinGW from Cygwin.  You'll need to configure it with:
-
-`PATH/TO/configure CC="gcc -mno-cygwin" CXX="g++ -mno-cygwin"`
-
-You should be able to replace the `-mno-cygwin` option with direct links
-to the real MinGW binaries, but we haven't tried that.
-
-Caveats:
-
-  * There are many warnings when compiling.
-  * `make check` will produce some errors as not all tests for Google Test itself are compatible with MinGW.
-
-We also have reports on successful cross compilation of Google Test
-MinGW binaries on Linux using
-[these instructions](http://wiki.wxwidgets.org/Cross-Compiling_Under_Linux#Cross-compiling_under_Linux_for_MS_Windows)
-on the WxWidgets site.
-
-Please contact `googletestframework@googlegroups.com` if you are
-interested in improving the support for MinGW.
-
-## Why does Google Test support EXPECT\_EQ(NULL, ptr) and ASSERT\_EQ(NULL, ptr) but not EXPECT\_NE(NULL, ptr) and ASSERT\_NE(NULL, ptr)? ##
-
-Due to some peculiarity of C++, it requires some non-trivial template
-meta programming tricks to support using `NULL` as an argument of the
-`EXPECT_XX()` and `ASSERT_XX()` macros. Therefore we only do it where
-it's most needed (otherwise we make the implementation of Google Test
-harder to maintain and more error-prone than necessary).
-
-The `EXPECT_EQ()` macro takes the _expected_ value as its first
-argument and the _actual_ value as the second. It's reasonable that
-someone wants to write `EXPECT_EQ(NULL, some_expression)`, and this
-indeed was requested several times. Therefore we implemented it.
-
-The need for `EXPECT_NE(NULL, ptr)` isn't nearly as strong. When the
-assertion fails, you already know that `ptr` must be `NULL`, so it
-doesn't add any information to print ptr in this case. That means
-`EXPECT_TRUE(ptr != NULL)` works just as well.
-
-If we were to support `EXPECT_NE(NULL, ptr)`, for consistency we'll
-have to support `EXPECT_NE(ptr, NULL)` as well, as unlike `EXPECT_EQ`,
-we don't have a convention on the order of the two arguments for
-`EXPECT_NE`. This means using the template meta programming tricks
-twice in the implementation, making it even harder to understand and
-maintain. We believe the benefit doesn't justify the cost.
-
-Finally, with the growth of Google Mock's [matcher](../../CookBook.md#using-matchers-in-google-test-assertions) library, we are
-encouraging people to use the unified `EXPECT_THAT(value, matcher)`
-syntax more often in tests. One significant advantage of the matcher
-approach is that matchers can be easily combined to form new matchers,
-while the `EXPECT_NE`, etc, macros cannot be easily
-combined. Therefore we want to invest more in the matchers than in the
-`EXPECT_XX()` macros.
-
-## Does Google Test support running tests in parallel? ##
-
-Test runners tend to be tightly coupled with the build/test
-environment, and Google Test doesn't try to solve the problem of
-running tests in parallel.  Instead, we tried to make Google Test work
-nicely with test runners.  For example, Google Test's XML report
-contains the time spent on each test, and its `gtest_list_tests` and
-`gtest_filter` flags can be used for splitting the execution of test
-methods into multiple processes.  These functionalities can help the
-test runner run the tests in parallel.
-
-## Why don't Google Test run the tests in different threads to speed things up? ##
-
-It's difficult to write thread-safe code.  Most tests are not written
-with thread-safety in mind, and thus may not work correctly in a
-multi-threaded setting.
-
-If you think about it, it's already hard to make your code work when
-you know what other threads are doing.  It's much harder, and
-sometimes even impossible, to make your code work when you don't know
-what other threads are doing (remember that test methods can be added,
-deleted, or modified after your test was written).  If you want to run
-the tests in parallel, you'd better run them in different processes.
-
-## Why aren't Google Test assertions implemented using exceptions? ##
-
-Our original motivation was to be able to use Google Test in projects
-that disable exceptions.  Later we realized some additional benefits
-of this approach:
-
-  1. Throwing in a destructor is undefined behavior in C++.  Not using exceptions means Google Test's assertions are safe to use in destructors.
-  1. The `EXPECT_*` family of macros will continue even after a failure, allowing multiple failures in a `TEST` to be reported in a single run. This is a popular feature, as in C++ the edit-compile-test cycle is usually quite long and being able to fixing more than one thing at a time is a blessing.
-  1. If assertions are implemented using exceptions, a test may falsely ignore a failure if it's caught by user code:
-```
-try { ... ASSERT_TRUE(...) ... }
-catch (...) { ... }
-```
-The above code will pass even if the `ASSERT_TRUE` throws.  While it's unlikely for someone to write this in a test, it's possible to run into this pattern when you write assertions in callbacks that are called by the code under test.
-
-The downside of not using exceptions is that `ASSERT_*` (implemented
-using `return`) will only abort the current function, not the current
-`TEST`.
-
-## Why do we use two different macros for tests with and without fixtures? ##
-
-Unfortunately, C++'s macro system doesn't allow us to use the same
-macro for both cases.  One possibility is to provide only one macro
-for tests with fixtures, and require the user to define an empty
-fixture sometimes:
-
-```
-class FooTest : public ::testing::Test {};
-
-TEST_F(FooTest, DoesThis) { ... }
-```
-or
-```
-typedef ::testing::Test FooTest;
-
-TEST_F(FooTest, DoesThat) { ... }
-```
-
-Yet, many people think this is one line too many. :-) Our goal was to
-make it really easy to write tests, so we tried to make simple tests
-trivial to create.  That means using a separate macro for such tests.
-
-We think neither approach is ideal, yet either of them is reasonable.
-In the end, it probably doesn't matter much either way.
-
-## Why don't we use structs as test fixtures? ##
-
-We like to use structs only when representing passive data.  This
-distinction between structs and classes is good for documenting the
-intent of the code's author.  Since test fixtures have logic like
-`SetUp()` and `TearDown()`, they are better defined as classes.
-
-## Why are death tests implemented as assertions instead of using a test runner? ##
-
-Our goal was to make death tests as convenient for a user as C++
-possibly allows.  In particular:
-
-  * The runner-style requires to split the information into two pieces: the definition of the death test itself, and the specification for the runner on how to run the death test and what to expect.  The death test would be written in C++, while the runner spec may or may not be.  A user needs to carefully keep the two in sync. `ASSERT_DEATH(statement, expected_message)` specifies all necessary information in one place, in one language, without boilerplate code. It is very declarative.
-  * `ASSERT_DEATH` has a similar syntax and error-reporting semantics as other Google Test assertions, and thus is easy to learn.
-  * `ASSERT_DEATH` can be mixed with other assertions and other logic at your will.  You are not limited to one death test per test method. For example, you can write something like:
-```
-    if (FooCondition()) {
-      ASSERT_DEATH(Bar(), "blah");
-    } else {
-      ASSERT_EQ(5, Bar());
-    }
-```
-If you prefer one death test per test method, you can write your tests in that style too, but we don't want to impose that on the users.  The fewer artificial limitations the better.
-  * `ASSERT_DEATH` can reference local variables in the current function, and you can decide how many death tests you want based on run-time information.  For example,
-```
-    const int count = GetCount();  // Only known at run time.
-    for (int i = 1; i <= count; i++) {
-      ASSERT_DEATH({
-        double* buffer = new double[i];
-        ... initializes buffer ...
-        Foo(buffer, i)
-      }, "blah blah");
-    }
-```
-The runner-based approach tends to be more static and less flexible, or requires more user effort to get this kind of flexibility.
-
-Another interesting thing about `ASSERT_DEATH` is that it calls `fork()`
-to create a child process to run the death test.  This is lightening
-fast, as `fork()` uses copy-on-write pages and incurs almost zero
-overhead, and the child process starts from the user-supplied
-statement directly, skipping all global and local initialization and
-any code leading to the given statement.  If you launch the child
-process from scratch, it can take seconds just to load everything and
-start running if the test links to many libraries dynamically.
-
-## My death test modifies some state, but the change seems lost after the death test finishes. Why? ##
-
-Death tests (`EXPECT_DEATH`, etc) are executed in a sub-process s.t. the
-expected crash won't kill the test program (i.e. the parent process). As a
-result, any in-memory side effects they incur are observable in their
-respective sub-processes, but not in the parent process. You can think of them
-as running in a parallel universe, more or less.
-
-## The compiler complains about "undefined references" to some static const member variables, but I did define them in the class body. What's wrong? ##
-
-If your class has a static data member:
-
-```
-// foo.h
-class Foo {
-  ...
-  static const int kBar = 100;
-};
-```
-
-You also need to define it _outside_ of the class body in `foo.cc`:
-
-```
-const int Foo::kBar;  // No initializer here.
-```
-
-Otherwise your code is **invalid C++**, and may break in unexpected ways. In
-particular, using it in Google Test comparison assertions (`EXPECT_EQ`, etc)
-will generate an "undefined reference" linker error.
-
-## I have an interface that has several implementations. Can I write a set of tests once and repeat them over all the implementations? ##
-
-Google Test doesn't yet have good support for this kind of tests, or
-data-driven tests in general. We hope to be able to make improvements in this
-area soon.
-
-## Can I derive a test fixture from another? ##
-
-Yes.
-
-Each test fixture has a corresponding and same named test case. This means only
-one test case can use a particular fixture. Sometimes, however, multiple test
-cases may want to use the same or slightly different fixtures. For example, you
-may want to make sure that all of a GUI library's test cases don't leak
-important system resources like fonts and brushes.
-
-In Google Test, you share a fixture among test cases by putting the shared
-logic in a base test fixture, then deriving from that base a separate fixture
-for each test case that wants to use this common logic. You then use `TEST_F()`
-to write tests using each derived fixture.
-
-Typically, your code looks like this:
-
-```
-// Defines a base test fixture.
-class BaseTest : public ::testing::Test {
-  protected:
-   ...
-};
-
-// Derives a fixture FooTest from BaseTest.
-class FooTest : public BaseTest {
-  protected:
-    virtual void SetUp() {
-      BaseTest::SetUp();  // Sets up the base fixture first.
-      ... additional set-up work ...
-    }
-    virtual void TearDown() {
-      ... clean-up work for FooTest ...
-      BaseTest::TearDown();  // Remember to tear down the base fixture
-                             // after cleaning up FooTest!
-    }
-    ... functions and variables for FooTest ...
-};
-
-// Tests that use the fixture FooTest.
-TEST_F(FooTest, Bar) { ... }
-TEST_F(FooTest, Baz) { ... }
-
-... additional fixtures derived from BaseTest ...
-```
-
-If necessary, you can continue to derive test fixtures from a derived fixture.
-Google Test has no limit on how deep the hierarchy can be.
-
-For a complete example using derived test fixtures, see
-[sample5](../samples/sample5_unittest.cc).
-
-## My compiler complains "void value not ignored as it ought to be." What does this mean? ##
-
-You're probably using an `ASSERT_*()` in a function that doesn't return `void`.
-`ASSERT_*()` can only be used in `void` functions.
-
-## My death test hangs (or seg-faults). How do I fix it? ##
-
-In Google Test, death tests are run in a child process and the way they work is
-delicate. To write death tests you really need to understand how they work.
-Please make sure you have read this.
-
-In particular, death tests don't like having multiple threads in the parent
-process. So the first thing you can try is to eliminate creating threads
-outside of `EXPECT_DEATH()`.
-
-Sometimes this is impossible as some library you must use may be creating
-threads before `main()` is even reached. In this case, you can try to minimize
-the chance of conflicts by either moving as many activities as possible inside
-`EXPECT_DEATH()` (in the extreme case, you want to move everything inside), or
-leaving as few things as possible in it. Also, you can try to set the death
-test style to `"threadsafe"`, which is safer but slower, and see if it helps.
-
-If you go with thread-safe death tests, remember that they rerun the test
-program from the beginning in the child process. Therefore make sure your
-program can run side-by-side with itself and is deterministic.
-
-In the end, this boils down to good concurrent programming. You have to make
-sure that there is no race conditions or dead locks in your program. No silver
-bullet - sorry!
-
-## Should I use the constructor/destructor of the test fixture or the set-up/tear-down function? ##
-
-The first thing to remember is that Google Test does not reuse the
-same test fixture object across multiple tests. For each `TEST_F`,
-Google Test will create a fresh test fixture object, _immediately_
-call `SetUp()`, run the test, call `TearDown()`, and then
-_immediately_ delete the test fixture object. Therefore, there is no
-need to write a `SetUp()` or `TearDown()` function if the constructor
-or destructor already does the job.
-
-You may still want to use `SetUp()/TearDown()` in the following cases:
-  * If the tear-down operation could throw an exception, you must use `TearDown()` as opposed to the destructor, as throwing in a destructor leads to undefined behavior and usually will kill your program right away. Note that many standard libraries (like STL) may throw when exceptions are enabled in the compiler. Therefore you should prefer `TearDown()` if you want to write portable tests that work with or without exceptions.
-  * The assertion macros throw an exception when flag `--gtest_throw_on_failure` is specified. Therefore, you shouldn't use Google Test assertions in a destructor if you plan to run your tests with this flag.
-  * In a constructor or destructor, you cannot make a virtual function call on this object. (You can call a method declared as virtual, but it will be statically bound.) Therefore, if you need to call a method that will be overriden in a derived class, you have to use `SetUp()/TearDown()`.
-
-## The compiler complains "no matching function to call" when I use ASSERT\_PREDn. How do I fix it? ##
-
-If the predicate function you use in `ASSERT_PRED*` or `EXPECT_PRED*` is
-overloaded or a template, the compiler will have trouble figuring out which
-overloaded version it should use. `ASSERT_PRED_FORMAT*` and
-`EXPECT_PRED_FORMAT*` don't have this problem.
-
-If you see this error, you might want to switch to
-`(ASSERT|EXPECT)_PRED_FORMAT*`, which will also give you a better failure
-message. If, however, that is not an option, you can resolve the problem by
-explicitly telling the compiler which version to pick.
-
-For example, suppose you have
-
-```
-bool IsPositive(int n) {
-  return n > 0;
-}
-bool IsPositive(double x) {
-  return x > 0;
-}
-```
-
-you will get a compiler error if you write
-
-```
-EXPECT_PRED1(IsPositive, 5);
-```
-
-However, this will work:
-
-```
-EXPECT_PRED1(*static_cast<bool (*)(int)>*(IsPositive), 5);
-```
-
-(The stuff inside the angled brackets for the `static_cast` operator is the
-type of the function pointer for the `int`-version of `IsPositive()`.)
-
-As another example, when you have a template function
-
-```
-template <typename T>
-bool IsNegative(T x) {
-  return x < 0;
-}
-```
-
-you can use it in a predicate assertion like this:
-
-```
-ASSERT_PRED1(IsNegative*<int>*, -5);
-```
-
-Things are more interesting if your template has more than one parameters. The
-following won't compile:
-
-```
-ASSERT_PRED2(*GreaterThan<int, int>*, 5, 0);
-```
-
-
-as the C++ pre-processor thinks you are giving `ASSERT_PRED2` 4 arguments,
-which is one more than expected. The workaround is to wrap the predicate
-function in parentheses:
-
-```
-ASSERT_PRED2(*(GreaterThan<int, int>)*, 5, 0);
-```
-
-
-## My compiler complains about "ignoring return value" when I call RUN\_ALL\_TESTS(). Why? ##
-
-Some people had been ignoring the return value of `RUN_ALL_TESTS()`. That is,
-instead of
-
-```
-return RUN_ALL_TESTS();
-```
-
-they write
-
-```
-RUN_ALL_TESTS();
-```
-
-This is wrong and dangerous. A test runner needs to see the return value of
-`RUN_ALL_TESTS()` in order to determine if a test has passed. If your `main()`
-function ignores it, your test will be considered successful even if it has a
-Google Test assertion failure. Very bad.
-
-To help the users avoid this dangerous bug, the implementation of
-`RUN_ALL_TESTS()` causes gcc to raise this warning, when the return value is
-ignored. If you see this warning, the fix is simple: just make sure its value
-is used as the return value of `main()`.
-
-## My compiler complains that a constructor (or destructor) cannot return a value. What's going on? ##
-
-Due to a peculiarity of C++, in order to support the syntax for streaming
-messages to an `ASSERT_*`, e.g.
-
-```
-ASSERT_EQ(1, Foo()) << "blah blah" << foo;
-```
-
-we had to give up using `ASSERT*` and `FAIL*` (but not `EXPECT*` and
-`ADD_FAILURE*`) in constructors and destructors. The workaround is to move the
-content of your constructor/destructor to a private void member function, or
-switch to `EXPECT_*()` if that works. This section in the user's guide explains
-it.
-
-## My set-up function is not called. Why? ##
-
-C++ is case-sensitive. It should be spelled as `SetUp()`.  Did you
-spell it as `Setup()`?
-
-Similarly, sometimes people spell `SetUpTestCase()` as `SetupTestCase()` and
-wonder why it's never called.
-
-## How do I jump to the line of a failure in Emacs directly? ##
-
-Google Test's failure message format is understood by Emacs and many other
-IDEs, like acme and XCode. If a Google Test message is in a compilation buffer
-in Emacs, then it's clickable. You can now hit `enter` on a message to jump to
-the corresponding source code, or use `C-x `` to jump to the next failure.
-
-## I have several test cases which share the same test fixture logic, do I have to define a new test fixture class for each of them? This seems pretty tedious. ##
-
-You don't have to. Instead of
-
-```
-class FooTest : public BaseTest {};
-
-TEST_F(FooTest, Abc) { ... }
-TEST_F(FooTest, Def) { ... }
-
-class BarTest : public BaseTest {};
-
-TEST_F(BarTest, Abc) { ... }
-TEST_F(BarTest, Def) { ... }
-```
-
-you can simply `typedef` the test fixtures:
-```
-typedef BaseTest FooTest;
-
-TEST_F(FooTest, Abc) { ... }
-TEST_F(FooTest, Def) { ... }
-
-typedef BaseTest BarTest;
-
-TEST_F(BarTest, Abc) { ... }
-TEST_F(BarTest, Def) { ... }
-```
-
-## The Google Test output is buried in a whole bunch of log messages. What do I do? ##
-
-The Google Test output is meant to be a concise and human-friendly report. If
-your test generates textual output itself, it will mix with the Google Test
-output, making it hard to read. However, there is an easy solution to this
-problem.
-
-Since most log messages go to stderr, we decided to let Google Test output go
-to stdout. This way, you can easily separate the two using redirection. For
-example:
-```
-./my_test > googletest_output.txt
-```
-
-## Why should I prefer test fixtures over global variables? ##
-
-There are several good reasons:
-  1. It's likely your test needs to change the states of its global variables. This makes it difficult to keep side effects from escaping one test and contaminating others, making debugging difficult. By using fixtures, each test has a fresh set of variables that's different (but with the same names). Thus, tests are kept independent of each other.
-  1. Global variables pollute the global namespace.
-  1. Test fixtures can be reused via subclassing, which cannot be done easily with global variables. This is useful if many test cases have something in common.
-
-## How do I test private class members without writing FRIEND\_TEST()s? ##
-
-You should try to write testable code, which means classes should be easily
-tested from their public interface. One way to achieve this is the Pimpl idiom:
-you move all private members of a class into a helper class, and make all
-members of the helper class public.
-
-You have several other options that don't require using `FRIEND_TEST`:
-  * Write the tests as members of the fixture class:
-```
-class Foo {
-  friend class FooTest;
-  ...
-};
-
-class FooTest : public ::testing::Test {
- protected:
-  ...
-  void Test1() {...} // This accesses private members of class Foo.
-  void Test2() {...} // So does this one.
-};
-
-TEST_F(FooTest, Test1) {
-  Test1();
-}
-
-TEST_F(FooTest, Test2) {
-  Test2();
-}
-```
-  * In the fixture class, write accessors for the tested class' private members, then use the accessors in your tests:
-```
-class Foo {
-  friend class FooTest;
-  ...
-};
-
-class FooTest : public ::testing::Test {
- protected:
-  ...
-  T1 get_private_member1(Foo* obj) {
-    return obj->private_member1_;
-  }
-};
-
-TEST_F(FooTest, Test1) {
-  ...
-  get_private_member1(x)
-  ...
-}
-```
-  * If the methods are declared **protected**, you can change their access level in a test-only subclass:
-```
-class YourClass {
-  ...
- protected: // protected access for testability.
-  int DoSomethingReturningInt();
-  ...
-};
-
-// in the your_class_test.cc file:
-class TestableYourClass : public YourClass {
-  ...
- public: using YourClass::DoSomethingReturningInt; // changes access rights
-  ...
-};
-
-TEST_F(YourClassTest, DoSomethingTest) {
-  TestableYourClass obj;
-  assertEquals(expected_value, obj.DoSomethingReturningInt());
-}
-```
-
-## How do I test private class static members without writing FRIEND\_TEST()s? ##
-
-We find private static methods clutter the header file.  They are
-implementation details and ideally should be kept out of a .h. So often I make
-them free functions instead.
-
-Instead of:
-```
-// foo.h
-class Foo {
-  ...
- private:
-  static bool Func(int n);
-};
-
-// foo.cc
-bool Foo::Func(int n) { ... }
-
-// foo_test.cc
-EXPECT_TRUE(Foo::Func(12345));
-```
-
-You probably should better write:
-```
-// foo.h
-class Foo {
-  ...
-};
-
-// foo.cc
-namespace internal {
-  bool Func(int n) { ... }
-}
-
-// foo_test.cc
-namespace internal {
-  bool Func(int n);
-}
-
-EXPECT_TRUE(internal::Func(12345));
-```
-
-## I would like to run a test several times with different parameters. Do I need to write several similar copies of it? ##
-
-No. You can use a feature called [value-parameterized tests](V1_7_AdvancedGuide.md#Value_Parameterized_Tests) which
-lets you repeat your tests with different parameters, without defining it more than once.
-
-## How do I test a file that defines main()? ##
-
-To test a `foo.cc` file, you need to compile and link it into your unit test
-program. However, when the file contains a definition for the `main()`
-function, it will clash with the `main()` of your unit test, and will result in
-a build error.
-
-The right solution is to split it into three files:
-  1. `foo.h` which contains the declarations,
-  1. `foo.cc` which contains the definitions except `main()`, and
-  1. `foo_main.cc` which contains nothing but the definition of `main()`.
-
-Then `foo.cc` can be easily tested.
-
-If you are adding tests to an existing file and don't want an intrusive change
-like this, there is a hack: just include the entire `foo.cc` file in your unit
-test. For example:
-```
-// File foo_unittest.cc
-
-// The headers section
-...
-
-// Renames main() in foo.cc to make room for the unit test main()
-#define main FooMain
-
-#include "a/b/foo.cc"
-
-// The tests start here.
-...
-```
-
-
-However, please remember this is a hack and should only be used as the last
-resort.
-
-## What can the statement argument in ASSERT\_DEATH() be? ##
-
-`ASSERT_DEATH(_statement_, _regex_)` (or any death assertion macro) can be used
-wherever `_statement_` is valid. So basically `_statement_` can be any C++
-statement that makes sense in the current context. In particular, it can
-reference global and/or local variables, and can be:
-  * a simple function call (often the case),
-  * a complex expression, or
-  * a compound statement.
-
-> Some examples are shown here:
-
-```
-// A death test can be a simple function call.
-TEST(MyDeathTest, FunctionCall) {
-  ASSERT_DEATH(Xyz(5), "Xyz failed");
-}
-
-// Or a complex expression that references variables and functions.
-TEST(MyDeathTest, ComplexExpression) {
-  const bool c = Condition();
-  ASSERT_DEATH((c ? Func1(0) : object2.Method("test")),
-               "(Func1|Method) failed");
-}
-
-// Death assertions can be used any where in a function. In
-// particular, they can be inside a loop.
-TEST(MyDeathTest, InsideLoop) {
-  // Verifies that Foo(0), Foo(1), ..., and Foo(4) all die.
-  for (int i = 0; i < 5; i++) {
-    EXPECT_DEATH_M(Foo(i), "Foo has \\d+ errors",
-                   ::testing::Message() << "where i is " << i);
-  }
-}
-
-// A death assertion can contain a compound statement.
-TEST(MyDeathTest, CompoundStatement) {
-  // Verifies that at lease one of Bar(0), Bar(1), ..., and
-  // Bar(4) dies.
-  ASSERT_DEATH({
-    for (int i = 0; i < 5; i++) {
-      Bar(i);
-    }
-  },
-  "Bar has \\d+ errors");}
-```
-
-`googletest_unittest.cc` contains more examples if you are interested.
-
-## What syntax does the regular expression in ASSERT\_DEATH use? ##
-
-On POSIX systems, Google Test uses the POSIX Extended regular
-expression syntax
-(http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
-On Windows, it uses a limited variant of regular expression
-syntax. For more details, see the
-[regular expression syntax](V1_7_AdvancedGuide.md#Regular_Expression_Syntax).
-
-## I have a fixture class Foo, but TEST\_F(Foo, Bar) gives me error "no matching function for call to Foo::Foo()". Why? ##
-
-Google Test needs to be able to create objects of your test fixture class, so
-it must have a default constructor. Normally the compiler will define one for
-you. However, there are cases where you have to define your own:
-  * If you explicitly declare a non-default constructor for class `Foo`, then you need to define a default constructor, even if it would be empty.
-  * If `Foo` has a const non-static data member, then you have to define the default constructor _and_ initialize the const member in the initializer list of the constructor. (Early versions of `gcc` doesn't force you to initialize the const member. It's a bug that has been fixed in `gcc 4`.)
-
-## Why does ASSERT\_DEATH complain about previous threads that were already joined? ##
-
-With the Linux pthread library, there is no turning back once you cross the
-line from single thread to multiple threads. The first time you create a
-thread, a manager thread is created in addition, so you get 3, not 2, threads.
-Later when the thread you create joins the main thread, the thread count
-decrements by 1, but the manager thread will never be killed, so you still have
-2 threads, which means you cannot safely run a death test.
-
-The new NPTL thread library doesn't suffer from this problem, as it doesn't
-create a manager thread. However, if you don't control which machine your test
-runs on, you shouldn't depend on this.
-
-## Why does Google Test require the entire test case, instead of individual tests, to be named FOODeathTest when it uses ASSERT\_DEATH? ##
-
-Google Test does not interleave tests from different test cases. That is, it
-runs all tests in one test case first, and then runs all tests in the next test
-case, and so on. Google Test does this because it needs to set up a test case
-before the first test in it is run, and tear it down afterwords. Splitting up
-the test case would require multiple set-up and tear-down processes, which is
-inefficient and makes the semantics unclean.
-
-If we were to determine the order of tests based on test name instead of test
-case name, then we would have a problem with the following situation:
-
-```
-TEST_F(FooTest, AbcDeathTest) { ... }
-TEST_F(FooTest, Uvw) { ... }
-
-TEST_F(BarTest, DefDeathTest) { ... }
-TEST_F(BarTest, Xyz) { ... }
-```
-
-Since `FooTest.AbcDeathTest` needs to run before `BarTest.Xyz`, and we don't
-interleave tests from different test cases, we need to run all tests in the
-`FooTest` case before running any test in the `BarTest` case. This contradicts
-with the requirement to run `BarTest.DefDeathTest` before `FooTest.Uvw`.
-
-## But I don't like calling my entire test case FOODeathTest when it contains both death tests and non-death tests. What do I do? ##
-
-You don't have to, but if you like, you may split up the test case into
-`FooTest` and `FooDeathTest`, where the names make it clear that they are
-related:
-
-```
-class FooTest : public ::testing::Test { ... };
-
-TEST_F(FooTest, Abc) { ... }
-TEST_F(FooTest, Def) { ... }
-
-typedef FooTest FooDeathTest;
-
-TEST_F(FooDeathTest, Uvw) { ... EXPECT_DEATH(...) ... }
-TEST_F(FooDeathTest, Xyz) { ... ASSERT_DEATH(...) ... }
-```
-
-## The compiler complains about "no match for 'operator<<'" when I use an assertion. What gives? ##
-
-If you use a user-defined type `FooType` in an assertion, you must make sure
-there is an `std::ostream& operator<<(std::ostream&, const FooType&)` function
-defined such that we can print a value of `FooType`.
-
-In addition, if `FooType` is declared in a name space, the `<<` operator also
-needs to be defined in the _same_ name space.
-
-## How do I suppress the memory leak messages on Windows? ##
-
-Since the statically initialized Google Test singleton requires allocations on
-the heap, the Visual C++ memory leak detector will report memory leaks at the
-end of the program run. The easiest way to avoid this is to use the
-`_CrtMemCheckpoint` and `_CrtMemDumpAllObjectsSince` calls to not report any
-statically initialized heap objects. See MSDN for more details and additional
-heap check/debug routines.
-
-## I am building my project with Google Test in Visual Studio and all I'm getting is a bunch of linker errors (or warnings). Help! ##
-
-You may get a number of the following linker error or warnings if you
-attempt to link your test project with the Google Test library when
-your project and the are not built using the same compiler settings.
-
-  * LNK2005: symbol already defined in object
-  * LNK4217: locally defined symbol 'symbol' imported in function 'function'
-  * LNK4049: locally defined symbol 'symbol' imported
-
-The Google Test project (gtest.vcproj) has the Runtime Library option
-set to /MT (use multi-threaded static libraries, /MTd for debug). If
-your project uses something else, for example /MD (use multi-threaded
-DLLs, /MDd for debug), you need to change the setting in the Google
-Test project to match your project's.
-
-To update this setting open the project properties in the Visual
-Studio IDE then select the branch Configuration Properties | C/C++ |
-Code Generation and change the option "Runtime Library".  You may also try
-using gtest-md.vcproj instead of gtest.vcproj.
-
-## I put my tests in a library and Google Test doesn't run them. What's happening? ##
-Have you read a
-[warning](V1_7_Primer.md#important-note-for-visual-c-users) on
-the Google Test Primer page?
-
-## I want to use Google Test with Visual Studio but don't know where to start. ##
-Many people are in your position and one of the posted his solution to
-our mailing list. Here is his link:
-http://hassanjamilahmad.blogspot.com/2009/07/gtest-starters-help.html.
-
-## I am seeing compile errors mentioning std::type\_traits when I try to use Google Test on Solaris. ##
-Google Test uses parts of the standard C++ library that SunStudio does not support.
-Our users reported success using alternative implementations. Try running the build after runing this commad:
-
-`export CC=cc CXX=CC CXXFLAGS='-library=stlport4'`
-
-## How can my code detect if it is running in a test? ##
-
-If you write code that sniffs whether it's running in a test and does
-different things accordingly, you are leaking test-only logic into
-production code and there is no easy way to ensure that the test-only
-code paths aren't run by mistake in production.  Such cleverness also
-leads to
-[Heisenbugs](http://en.wikipedia.org/wiki/Unusual_software_bug#Heisenbug).
-Therefore we strongly advise against the practice, and Google Test doesn't
-provide a way to do it.
-
-In general, the recommended way to cause the code to behave
-differently under test is [dependency injection](http://jamesshore.com/Blog/Dependency-Injection-Demystified.html).
-You can inject different functionality from the test and from the
-production code.  Since your production code doesn't link in the
-for-test logic at all, there is no danger in accidentally running it.
-
-However, if you _really_, _really_, _really_ have no choice, and if
-you follow the rule of ending your test program names with `_test`,
-you can use the _horrible_ hack of sniffing your executable name
-(`argv[0]` in `main()`) to know whether the code is under test.
-
-## Google Test defines a macro that clashes with one defined by another library. How do I deal with that? ##
-
-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 Google Test macro clashes with another
-library, you can force Google Test to rename its macro to avoid the
-conflict.
-
-Specifically, if both Google Test and some other code define macro
-`FOO`, you can add
-```
-  -DGTEST_DONT_DEFINE_FOO=1
-```
-to the compiler flags to tell Google Test to change the macro's name
-from `FOO` to `GTEST_FOO`. 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.
-
-Currently, the following `TEST`, `FAIL`, `SUCCEED`, and the basic comparison assertion macros can have alternative names. You can see the full list of covered macros [here](http://www.google.com/codesearch?q=if+!GTEST_DONT_DEFINE_\w%2B+package:http://googletest\.googlecode\.com+file:/include/gtest/gtest.h). More information can be found in the "Avoiding Macro Name Clashes" section of the README file.
-
-
-## Is it OK if I have two separate `TEST(Foo, Bar)` test methods defined in different namespaces? ##
-
-Yes.
-
-The rule is **all test methods in the same test case must use the same fixture class**. This means that the following is **allowed** because both tests use the same fixture class (`::testing::Test`).
-
-```
-namespace foo {
-TEST(CoolTest, DoSomething) {
-  SUCCEED();
-}
-}  // namespace foo
-
-namespace bar {
-TEST(CoolTest, DoSomething) {
-  SUCCEED();
-}
-}  // namespace foo
-```
-
-However, the following code is **not allowed** and will produce a runtime error from Google Test because the test methods are using different test fixture classes with the same test case name.
-
-```
-namespace foo {
-class CoolTest : public ::testing::Test {};  // Fixture foo::CoolTest
-TEST_F(CoolTest, DoSomething) {
-  SUCCEED();
-}
-}  // namespace foo
-
-namespace bar {
-class CoolTest : public ::testing::Test {};  // Fixture: bar::CoolTest
-TEST_F(CoolTest, DoSomething) {
-  SUCCEED();
-}
-}  // namespace foo
-```
-
-## How do I build Google Testing Framework with Xcode 4? ##
-
-If you try to build Google Test's Xcode project with Xcode 4.0 or later, you may encounter an error message that looks like
-"Missing SDK in target gtest\_framework: /Developer/SDKs/MacOSX10.4u.sdk". That means that Xcode does not support the SDK the project is targeting. See the Xcode section in the [README](../../README.MD) file on how to resolve this.
-
-## My question is not covered in your FAQ! ##
-
-If you cannot find the answer to your question in this FAQ, there are
-some other resources you can use:
-
-  1. read other [wiki pages](http://code.google.com/p/googletest/w/list),
-  1. search the mailing list [archive](http://groups.google.com/group/googletestframework/topics),
-  1. ask it on [googletestframework@googlegroups.com](mailto:googletestframework@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googletestframework) before you can post.).
-
-Please note that creating an issue in the
-[issue tracker](http://code.google.com/p/googletest/issues/list) is _not_
-a good way to get your answer, as it is monitored infrequently by a
-very small number of people.
-
-When asking a question, it's helpful to provide as much of the
-following information as possible (people cannot help you if there's
-not enough information in your question):
-
-  * the version (or the revision number if you check out from SVN directly) of Google Test you use (Google Test is under active development, so it's possible that your problem has been solved in a later version),
-  * your operating system,
-  * the name and version of your compiler,
-  * the complete command line flags you give to your compiler,
-  * the complete compiler error messages (if the question is about compilation),
-  * the _actual_ code (ideally, a minimal but complete program) that has the problem you encounter.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Primer.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Primer.md
deleted file mode 100644
index b1827c73..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Primer.md
+++ /dev/null
@@ -1,501 +0,0 @@
-
-
-# Introduction: Why Google C++ Testing Framework? #
-
-_Google C++ Testing Framework_ helps you write better C++ tests.
-
-No matter whether you work on Linux, Windows, or a Mac, if you write C++ code,
-Google Test can help you.
-
-So what makes a good test, and how does Google C++ Testing Framework fit in? We believe:
-  1. Tests should be _independent_ and _repeatable_. It's a pain to debug a test that succeeds or fails as a result of other tests.  Google C++ Testing Framework isolates the tests by running each of them on a different object. When a test fails, Google C++ Testing Framework allows you to run it in isolation for quick debugging.
-  1. Tests should be well _organized_ and reflect the structure of the tested code.  Google C++ Testing Framework groups related tests into test cases that can share data and subroutines. This common pattern is easy to recognize and makes tests easy to maintain. Such consistency is especially helpful when people switch projects and start to work on a new code base.
-  1. Tests should be _portable_ and _reusable_. The open-source community has a lot of code that is platform-neutral, its tests should also be platform-neutral.  Google C++ Testing Framework works on different OSes, with different compilers (gcc, MSVC, and others), with or without exceptions, so Google C++ Testing Framework tests can easily work with a variety of configurations.  (Note that the current release only contains build scripts for Linux - we are actively working on scripts for other platforms.)
-  1. When tests fail, they should provide as much _information_ about the problem as possible. Google C++ Testing Framework doesn't stop at the first test failure. Instead, it only stops the current test and continues with the next. You can also set up tests that report non-fatal failures after which the current test continues. Thus, you can detect and fix multiple bugs in a single run-edit-compile cycle.
-  1. The testing framework should liberate test writers from housekeeping chores and let them focus on the test _content_.  Google C++ Testing Framework automatically keeps track of all tests defined, and doesn't require the user to enumerate them in order to run them.
-  1. Tests should be _fast_. With Google C++ Testing Framework, you can reuse shared resources across tests and pay for the set-up/tear-down only once, without making tests depend on each other.
-
-Since Google C++ Testing Framework is based on the popular xUnit
-architecture, you'll feel right at home if you've used JUnit or PyUnit before.
-If not, it will take you about 10 minutes to learn the basics and get started.
-So let's go!
-
-_Note:_ We sometimes refer to Google C++ Testing Framework informally
-as _Google Test_.
-
-# Setting up a New Test Project #
-
-To write a test program using Google Test, you need to compile Google
-Test into a library and link your test with it.  We provide build
-files for some popular build systems: `msvc/` for Visual Studio,
-`xcode/` for Mac Xcode, `make/` for GNU make, `codegear/` for Borland
-C++ Builder, and the autotools script (deprecated) and
-`CMakeLists.txt` for CMake (recommended) in the Google Test root
-directory.  If your build system is not on this list, you can take a
-look at `make/Makefile` to learn how Google Test should be compiled
-(basically you want to compile `src/gtest-all.cc` with `GTEST_ROOT`
-and `GTEST_ROOT/include` in the header search path, where `GTEST_ROOT`
-is the Google Test root directory).
-
-Once you are able to compile the Google Test library, you should
-create a project or build target for your test program.  Make sure you
-have `GTEST_ROOT/include` in the header search path so that the
-compiler can find `"gtest/gtest.h"` when compiling your test.  Set up
-your test project to link with the Google Test library (for example,
-in Visual Studio, this is done by adding a dependency on
-`gtest.vcproj`).
-
-If you still have questions, take a look at how Google Test's own
-tests are built and use them as examples.
-
-# Basic Concepts #
-
-When using Google Test, you start by writing _assertions_, which are statements
-that check whether a condition is true. An assertion's result can be _success_,
-_nonfatal failure_, or _fatal failure_. If a fatal failure occurs, it aborts
-the current function; otherwise the program continues normally.
-
-_Tests_ use assertions to verify the tested code's behavior. If a test crashes
-or has a failed assertion, then it _fails_; otherwise it _succeeds_.
-
-A _test case_ contains one or many tests. You should group your tests into test
-cases that reflect the structure of the tested code. When multiple tests in a
-test case need to share common objects and subroutines, you can put them into a
-_test fixture_ class.
-
-A _test program_ can contain multiple test cases.
-
-We'll now explain how to write a test program, starting at the individual
-assertion level and building up to tests and test cases.
-
-# Assertions #
-
-Google Test assertions are macros that resemble function calls. You test a
-class or function by making assertions about its behavior. When an assertion
-fails, Google Test prints the assertion's source file and line number location,
-along with a failure message. You may also supply a custom failure message
-which will be appended to Google Test's message.
-
-The assertions come in pairs that test the same thing but have different
-effects on the current function. `ASSERT_*` versions generate fatal failures
-when they fail, and **abort the current function**. `EXPECT_*` versions generate
-nonfatal failures, which don't abort the current function. Usually `EXPECT_*`
-are preferred, as they allow more than one failures to be reported in a test.
-However, you should use `ASSERT_*` if it doesn't make sense to continue when
-the assertion in question fails.
-
-Since a failed `ASSERT_*` returns from the current function immediately,
-possibly skipping clean-up code that comes after it, it may cause a space leak.
-Depending on the nature of the leak, it may or may not be worth fixing - so
-keep this in mind if you get a heap checker error in addition to assertion
-errors.
-
-To provide a custom failure message, simply stream it into the macro using the
-`<<` operator, or a sequence of such operators. An example:
-```
-ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length";
-
-for (int i = 0; i < x.size(); ++i) {
-  EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i;
-}
-```
-
-Anything that can be streamed to an `ostream` can be streamed to an assertion
-macro--in particular, C strings and `string` objects. If a wide string
-(`wchar_t*`, `TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is
-streamed to an assertion, it will be translated to UTF-8 when printed.
-
-## Basic Assertions ##
-
-These assertions do basic true/false condition testing.
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_TRUE(`_condition_`)`;  | `EXPECT_TRUE(`_condition_`)`;   | _condition_ is true |
-| `ASSERT_FALSE(`_condition_`)`; | `EXPECT_FALSE(`_condition_`)`;  | _condition_ is false |
-
-Remember, when they fail, `ASSERT_*` yields a fatal failure and
-returns from the current function, while `EXPECT_*` yields a nonfatal
-failure, allowing the function to continue running. In either case, an
-assertion failure means its containing test fails.
-
-_Availability_: Linux, Windows, Mac.
-
-## Binary Comparison ##
-
-This section describes assertions that compare two values.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-|`ASSERT_EQ(`_expected_`, `_actual_`);`|`EXPECT_EQ(`_expected_`, `_actual_`);`| _expected_ `==` _actual_ |
-|`ASSERT_NE(`_val1_`, `_val2_`);`      |`EXPECT_NE(`_val1_`, `_val2_`);`      | _val1_ `!=` _val2_ |
-|`ASSERT_LT(`_val1_`, `_val2_`);`      |`EXPECT_LT(`_val1_`, `_val2_`);`      | _val1_ `<` _val2_ |
-|`ASSERT_LE(`_val1_`, `_val2_`);`      |`EXPECT_LE(`_val1_`, `_val2_`);`      | _val1_ `<=` _val2_ |
-|`ASSERT_GT(`_val1_`, `_val2_`);`      |`EXPECT_GT(`_val1_`, `_val2_`);`      | _val1_ `>` _val2_ |
-|`ASSERT_GE(`_val1_`, `_val2_`);`      |`EXPECT_GE(`_val1_`, `_val2_`);`      | _val1_ `>=` _val2_ |
-
-In the event of a failure, Google Test prints both _val1_ and _val2_
-. In `ASSERT_EQ*` and `EXPECT_EQ*` (and all other equality assertions
-we'll introduce later), you should put the expression you want to test
-in the position of _actual_, and put its expected value in _expected_,
-as Google Test's failure messages are optimized for this convention.
-
-Value arguments must be comparable by the assertion's comparison
-operator or you'll get a compiler error.  We used to require the
-arguments to support the `<<` operator for streaming to an `ostream`,
-but it's no longer necessary since v1.6.0 (if `<<` is supported, it
-will be called to print the arguments when the assertion fails;
-otherwise Google Test will attempt to print them in the best way it
-can. For more details and how to customize the printing of the
-arguments, see this Google Mock [recipe](../../googlemock/docs/CookBook.md#teaching-google-mock-how-to-print-your-values).).
-
-These assertions can work with a user-defined type, but only if you define the
-corresponding comparison operator (e.g. `==`, `<`, etc).  If the corresponding
-operator is defined, prefer using the `ASSERT_*()` macros because they will
-print out not only the result of the comparison, but the two operands as well.
-
-Arguments are always evaluated exactly once. Therefore, it's OK for the
-arguments to have side effects. However, as with any ordinary C/C++ function,
-the arguments' evaluation order is undefined (i.e. the compiler is free to
-choose any order) and your code should not depend on any particular argument
-evaluation order.
-
-`ASSERT_EQ()` does pointer equality on pointers. If used on two C strings, it
-tests if they are in the same memory location, not if they have the same value.
-Therefore, if you want to compare C strings (e.g. `const char*`) by value, use
-`ASSERT_STREQ()` , which will be described later on. In particular, to assert
-that a C string is `NULL`, use `ASSERT_STREQ(NULL, c_string)` . However, to
-compare two `string` objects, you should use `ASSERT_EQ`.
-
-Macros in this section work with both narrow and wide string objects (`string`
-and `wstring`).
-
-_Availability_: Linux, Windows, Mac.
-
-## String Comparison ##
-
-The assertions in this group compare two **C strings**. If you want to compare
-two `string` objects, use `EXPECT_EQ`, `EXPECT_NE`, and etc instead.
-
-| **Fatal assertion** | **Nonfatal assertion** | **Verifies** |
-|:--------------------|:-----------------------|:-------------|
-| `ASSERT_STREQ(`_expected\_str_`, `_actual\_str_`);`    | `EXPECT_STREQ(`_expected\_str_`, `_actual\_str_`);`     | the two C strings have the same content |
-| `ASSERT_STRNE(`_str1_`, `_str2_`);`    | `EXPECT_STRNE(`_str1_`, `_str2_`);`     | the two C strings have different content |
-| `ASSERT_STRCASEEQ(`_expected\_str_`, `_actual\_str_`);`| `EXPECT_STRCASEEQ(`_expected\_str_`, `_actual\_str_`);` | the two C strings have the same content, ignoring case |
-| `ASSERT_STRCASENE(`_str1_`, `_str2_`);`| `EXPECT_STRCASENE(`_str1_`, `_str2_`);` | the two C strings have different content, ignoring case |
-
-Note that "CASE" in an assertion name means that case is ignored.
-
-`*STREQ*` and `*STRNE*` also accept wide C strings (`wchar_t*`). If a
-comparison of two wide strings fails, their values will be printed as UTF-8
-narrow strings.
-
-A `NULL` pointer and an empty string are considered _different_.
-
-_Availability_: Linux, Windows, Mac.
-
-See also: For more string comparison tricks (substring, prefix, suffix, and
-regular expression matching, for example), see the [Advanced Google Test Guide](V1_7_AdvancedGuide.md).
-
-# Simple Tests #
-
-To create a test:
-  1. Use the `TEST()` macro to define and name a test function, These are ordinary C++ functions that don't return a value.
-  1. In this function, along with any valid C++ statements you want to include, use the various Google Test assertions to check values.
-  1. The test's result is determined by the assertions; if any assertion in the test fails (either fatally or non-fatally), or if the test crashes, the entire test fails. Otherwise, it succeeds.
-
-```
-TEST(test_case_name, test_name) {
- ... test body ...
-}
-```
-
-
-`TEST()` arguments go from general to specific. The _first_ argument is the
-name of the test case, and the _second_ argument is the test's name within the
-test case. Both names must be valid C++ identifiers, and they should not contain underscore (`_`). A test's _full name_ consists of its containing test case and its
-individual name. Tests from different test cases can have the same individual
-name.
-
-For example, let's take a simple integer function:
-```
-int Factorial(int n); // Returns the factorial of n
-```
-
-A test case for this function might look like:
-```
-// Tests factorial of 0.
-TEST(FactorialTest, HandlesZeroInput) {
-  EXPECT_EQ(1, Factorial(0));
-}
-
-// Tests factorial of positive numbers.
-TEST(FactorialTest, HandlesPositiveInput) {
-  EXPECT_EQ(1, Factorial(1));
-  EXPECT_EQ(2, Factorial(2));
-  EXPECT_EQ(6, Factorial(3));
-  EXPECT_EQ(40320, Factorial(8));
-}
-```
-
-Google Test groups the test results by test cases, so logically-related tests
-should be in the same test case; in other words, the first argument to their
-`TEST()` should be the same. In the above example, we have two tests,
-`HandlesZeroInput` and `HandlesPositiveInput`, that belong to the same test
-case `FactorialTest`.
-
-_Availability_: Linux, Windows, Mac.
-
-# Test Fixtures: Using the Same Data Configuration for Multiple Tests #
-
-If you find yourself writing two or more tests that operate on similar data,
-you can use a _test fixture_. It allows you to reuse the same configuration of
-objects for several different tests.
-
-To create a fixture, just:
-  1. Derive a class from `::testing::Test` . Start its body with `protected:` or `public:` as we'll want to access fixture members from sub-classes.
-  1. Inside the class, declare any objects you plan to use.
-  1. If necessary, write a default constructor or `SetUp()` function to prepare the objects for each test. A common mistake is to spell `SetUp()` as `Setup()` with a small `u` - don't let that happen to you.
-  1. If necessary, write a destructor or `TearDown()` function to release any resources you allocated in `SetUp()` . To learn when you should use the constructor/destructor and when you should use `SetUp()/TearDown()`, read this [FAQ entry](V1_7_FAQ.md#should-i-use-the-constructordestructor-of-the-test-fixture-or-the-set-uptear-down-function).
-  1. If needed, define subroutines for your tests to share.
-
-When using a fixture, use `TEST_F()` instead of `TEST()` as it allows you to
-access objects and subroutines in the test fixture:
-```
-TEST_F(test_case_name, test_name) {
- ... test body ...
-}
-```
-
-Like `TEST()`, the first argument is the test case name, but for `TEST_F()`
-this must be the name of the test fixture class. You've probably guessed: `_F`
-is for fixture.
-
-Unfortunately, the C++ macro system does not allow us to create a single macro
-that can handle both types of tests. Using the wrong macro causes a compiler
-error.
-
-Also, you must first define a test fixture class before using it in a
-`TEST_F()`, or you'll get the compiler error "`virtual outside class
-declaration`".
-
-For each test defined with `TEST_F()`, Google Test will:
-  1. Create a _fresh_ test fixture at runtime
-  1. Immediately initialize it via `SetUp()` ,
-  1. Run the test
-  1. Clean up by calling `TearDown()`
-  1. Delete the test fixture.  Note that different tests in the same test case have different test fixture objects, and Google Test always deletes a test fixture before it creates the next one. Google Test does not reuse the same test fixture for multiple tests. Any changes one test makes to the fixture do not affect other tests.
-
-As an example, let's write tests for a FIFO queue class named `Queue`, which
-has the following interface:
-```
-template <typename E> // E is the element type.
-class Queue {
- public:
-  Queue();
-  void Enqueue(const E& element);
-  E* Dequeue(); // Returns NULL if the queue is empty.
-  size_t size() const;
-  ...
-};
-```
-
-First, define a fixture class. By convention, you should give it the name
-`FooTest` where `Foo` is the class being tested.
-```
-class QueueTest : public ::testing::Test {
- protected:
-  virtual void SetUp() {
-    q1_.Enqueue(1);
-    q2_.Enqueue(2);
-    q2_.Enqueue(3);
-  }
-
-  // virtual void TearDown() {}
-
-  Queue<int> q0_;
-  Queue<int> q1_;
-  Queue<int> q2_;
-};
-```
-
-In this case, `TearDown()` is not needed since we don't have to clean up after
-each test, other than what's already done by the destructor.
-
-Now we'll write tests using `TEST_F()` and this fixture.
-```
-TEST_F(QueueTest, IsEmptyInitially) {
-  EXPECT_EQ(0, q0_.size());
-}
-
-TEST_F(QueueTest, DequeueWorks) {
-  int* n = q0_.Dequeue();
-  EXPECT_EQ(NULL, n);
-
-  n = q1_.Dequeue();
-  ASSERT_TRUE(n != NULL);
-  EXPECT_EQ(1, *n);
-  EXPECT_EQ(0, q1_.size());
-  delete n;
-
-  n = q2_.Dequeue();
-  ASSERT_TRUE(n != NULL);
-  EXPECT_EQ(2, *n);
-  EXPECT_EQ(1, q2_.size());
-  delete n;
-}
-```
-
-The above uses both `ASSERT_*` and `EXPECT_*` assertions. The rule of thumb is
-to use `EXPECT_*` when you want the test to continue to reveal more errors
-after the assertion failure, and use `ASSERT_*` when continuing after failure
-doesn't make sense. For example, the second assertion in the `Dequeue` test is
-`ASSERT_TRUE(n != NULL)`, as we need to dereference the pointer `n` later,
-which would lead to a segfault when `n` is `NULL`.
-
-When these tests run, the following happens:
-  1. Google Test constructs a `QueueTest` object (let's call it `t1` ).
-  1. `t1.SetUp()` initializes `t1` .
-  1. The first test ( `IsEmptyInitially` ) runs on `t1` .
-  1. `t1.TearDown()` cleans up after the test finishes.
-  1. `t1` is destructed.
-  1. The above steps are repeated on another `QueueTest` object, this time running the `DequeueWorks` test.
-
-_Availability_: Linux, Windows, Mac.
-
-_Note_: Google Test automatically saves all _Google Test_ flags when a test
-object is constructed, and restores them when it is destructed.
-
-# Invoking the Tests #
-
-`TEST()` and `TEST_F()` implicitly register their tests with Google Test. So, unlike with many other C++ testing frameworks, you don't have to re-list all your defined tests in order to run them.
-
-After defining your tests, you can run them with `RUN_ALL_TESTS()` , which returns `0` if all the tests are successful, or `1` otherwise. Note that `RUN_ALL_TESTS()` runs _all tests_ in your link unit -- they can be from different test cases, or even different source files.
-
-When invoked, the `RUN_ALL_TESTS()` macro:
-  1. Saves the state of all  Google Test flags.
-  1. Creates a test fixture object for the first test.
-  1. Initializes it via `SetUp()`.
-  1. Runs the test on the fixture object.
-  1. Cleans up the fixture via `TearDown()`.
-  1. Deletes the fixture.
-  1. Restores the state of all Google Test flags.
-  1. Repeats the above steps for the next test, until all tests have run.
-
-In addition, if the text fixture's constructor generates a fatal failure in
-step 2, there is no point for step 3 - 5 and they are thus skipped. Similarly,
-if step 3 generates a fatal failure, step 4 will be skipped.
-
-_Important_: You must not ignore the return value of `RUN_ALL_TESTS()`, or `gcc`
-will give you a compiler error. The rationale for this design is that the
-automated testing service determines whether a test has passed based on its
-exit code, not on its stdout/stderr output; thus your `main()` function must
-return the value of `RUN_ALL_TESTS()`.
-
-Also, you should call `RUN_ALL_TESTS()` only **once**. Calling it more than once
-conflicts with some advanced Google Test features (e.g. thread-safe death
-tests) and thus is not supported.
-
-_Availability_: Linux, Windows, Mac.
-
-# Writing the main() Function #
-
-You can start from this boilerplate:
-```
-#include "this/package/foo.h"
-#include "gtest/gtest.h"
-
-namespace {
-
-// The fixture for testing class Foo.
-class FooTest : public ::testing::Test {
- protected:
-  // You can remove any or all of the following functions if its body
-  // is empty.
-
-  FooTest() {
-    // You can do set-up work for each test here.
-  }
-
-  virtual ~FooTest() {
-    // You can do clean-up work that doesn't throw exceptions here.
-  }
-
-  // If the constructor and destructor are not enough for setting up
-  // and cleaning up each test, you can define the following methods:
-
-  virtual void SetUp() {
-    // Code here will be called immediately after the constructor (right
-    // before each test).
-  }
-
-  virtual void TearDown() {
-    // Code here will be called immediately after each test (right
-    // before the destructor).
-  }
-
-  // Objects declared here can be used by all tests in the test case for Foo.
-};
-
-// Tests that the Foo::Bar() method does Abc.
-TEST_F(FooTest, MethodBarDoesAbc) {
-  const string input_filepath = "this/package/testdata/myinputfile.dat";
-  const string output_filepath = "this/package/testdata/myoutputfile.dat";
-  Foo f;
-  EXPECT_EQ(0, f.Bar(input_filepath, output_filepath));
-}
-
-// Tests that Foo does Xyz.
-TEST_F(FooTest, DoesXyz) {
-  // Exercises the Xyz feature of Foo.
-}
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
-```
-
-The `::testing::InitGoogleTest()` function parses the command line for Google
-Test flags, and removes all recognized flags. This allows the user to control a
-test program's behavior via various flags, which we'll cover in [AdvancedGuide](V1_7_AdvancedGuide.md).
-You must call this function before calling `RUN_ALL_TESTS()`, or the flags
-won't be properly initialized.
-
-On Windows, `InitGoogleTest()` also works with wide strings, so it can be used
-in programs compiled in `UNICODE` mode as well.
-
-But maybe you think that writing all those main() functions is too much work? We agree with you completely and that's why Google Test provides a basic implementation of main(). If it fits your needs, then just link your test with gtest\_main library and you are good to go.
-
-## Important note for Visual C++ users ##
-If you put your tests into a library and your `main()` function is in a different library or in your .exe file, those tests will not run. The reason is a [bug](https://connect.microsoft.com/feedback/viewfeedback.aspx?FeedbackID=244410&siteid=210) in Visual C++. When you define your tests, Google Test creates certain static objects to register them. These objects are not referenced from elsewhere but their constructors are still supposed to run. When Visual C++ linker sees that nothing in the library is referenced from other places it throws the library out. You have to reference your library with tests from your main program to keep the linker from discarding it. Here is how to do it. Somewhere in your library code declare a function:
-```
-__declspec(dllexport) int PullInMyLibrary() { return 0; }
-```
-If you put your tests in a static library (not DLL) then `__declspec(dllexport)` is not required. Now, in your main program, write a code that invokes that function:
-```
-int PullInMyLibrary();
-static int dummy = PullInMyLibrary();
-```
-This will keep your tests referenced and will make them register themselves at startup.
-
-In addition, if you define your tests in a static library, add `/OPT:NOREF` to your main program linker options. If you use MSVC++ IDE, go to your .exe project properties/Configuration Properties/Linker/Optimization and set References setting to `Keep Unreferenced Data (/OPT:NOREF)`. This will keep Visual C++ linker from discarding individual symbols generated by your tests from the final executable.
-
-There is one more pitfall, though. If you use Google Test as a static library (that's how it is defined in gtest.vcproj) your tests must also reside in a static library. If you have to have them in a DLL, you _must_ change Google Test to build into a DLL as well. Otherwise your tests will not run correctly or will not run at all. The general conclusion here is: make your life easier - do not write your tests in libraries!
-
-# Where to Go from Here #
-
-Congratulations! You've learned the Google Test basics. You can start writing
-and running Google Test tests, read some [samples](V1_7_Samples.md), or continue with
-[AdvancedGuide](V1_7_AdvancedGuide.md), which describes many more useful Google Test features.
-
-# Known Limitations #
-
-Google Test is designed to be thread-safe.  The implementation is
-thread-safe on systems where the `pthreads` library is available.  It
-is currently _unsafe_ to use Google Test assertions from two threads
-concurrently on other systems (e.g. Windows).  In most tests this is
-not an issue as usually the assertions are done in the main thread. If
-you want to help, you can volunteer to implement the necessary
-synchronization primitives in `gtest-port.h` for your platform.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_PumpManual.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_PumpManual.md
deleted file mode 100644
index 8184f153..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_PumpManual.md
+++ /dev/null
@@ -1,177 +0,0 @@
-
-
-<b>P</b>ump is <b>U</b>seful for <b>M</b>eta <b>P</b>rogramming.
-
-# The Problem #
-
-Template and macro libraries often need to define many classes,
-functions, or macros that vary only (or almost only) in the number of
-arguments they take. It's a lot of repetitive, mechanical, and
-error-prone work.
-
-Variadic templates and variadic macros can alleviate the problem.
-However, while both are being considered by the C++ committee, neither
-is in the standard yet or widely supported by compilers.  Thus they
-are often not a good choice, especially when your code needs to be
-portable. And their capabilities are still limited.
-
-As a result, authors of such libraries often have to write scripts to
-generate their implementation. However, our experience is that it's
-tedious to write such scripts, which tend to reflect the structure of
-the generated code poorly and are often hard to read and edit. For
-example, a small change needed in the generated code may require some
-non-intuitive, non-trivial changes in the script. This is especially
-painful when experimenting with the code.
-
-# Our Solution #
-
-Pump (for Pump is Useful for Meta Programming, Pretty Useful for Meta
-Programming, or Practical Utility for Meta Programming, whichever you
-prefer) is a simple meta-programming tool for C++. The idea is that a
-programmer writes a `foo.pump` file which contains C++ code plus meta
-code that manipulates the C++ code. The meta code can handle
-iterations over a range, nested iterations, local meta variable
-definitions, simple arithmetic, and conditional expressions. You can
-view it as a small Domain-Specific Language. The meta language is
-designed to be non-intrusive (s.t. it won't confuse Emacs' C++ mode,
-for example) and concise, making Pump code intuitive and easy to
-maintain.
-
-## Highlights ##
-
-  * The implementation is in a single Python script and thus ultra portable: no build or installation is needed and it works cross platforms.
-  * Pump tries to be smart with respect to [Google's style guide](http://code.google.com/p/google-styleguide/): it breaks long lines (easy to have when they are generated) at acceptable places to fit within 80 columns and indent the continuation lines correctly.
-  * The format is human-readable and more concise than XML.
-  * The format works relatively well with Emacs' C++ mode.
-
-## Examples ##
-
-The following Pump code (where meta keywords start with `$`, `[[` and `]]` are meta brackets, and `$$` starts a meta comment that ends with the line):
-
-```
-$var n = 3     $$ Defines a meta variable n.
-$range i 0..n  $$ Declares the range of meta iterator i (inclusive).
-$for i [[
-               $$ Meta loop.
-// Foo$i does blah for $i-ary predicates.
-$range j 1..i
-template <size_t N $for j [[, typename A$j]]>
-class Foo$i {
-$if i == 0 [[
-  blah a;
-]] $elif i <= 2 [[
-  blah b;
-]] $else [[
-  blah c;
-]]
-};
-
-]]
-```
-
-will be translated by the Pump compiler to:
-
-```
-// Foo0 does blah for 0-ary predicates.
-template <size_t N>
-class Foo0 {
-  blah a;
-};
-
-// Foo1 does blah for 1-ary predicates.
-template <size_t N, typename A1>
-class Foo1 {
-  blah b;
-};
-
-// Foo2 does blah for 2-ary predicates.
-template <size_t N, typename A1, typename A2>
-class Foo2 {
-  blah b;
-};
-
-// Foo3 does blah for 3-ary predicates.
-template <size_t N, typename A1, typename A2, typename A3>
-class Foo3 {
-  blah c;
-};
-```
-
-In another example,
-
-```
-$range i 1..n
-Func($for i + [[a$i]]);
-$$ The text between i and [[ is the separator between iterations.
-```
-
-will generate one of the following lines (without the comments), depending on the value of `n`:
-
-```
-Func();              // If n is 0.
-Func(a1);            // If n is 1.
-Func(a1 + a2);       // If n is 2.
-Func(a1 + a2 + a3);  // If n is 3.
-// And so on...
-```
-
-## Constructs ##
-
-We support the following meta programming constructs:
-
-| `$var id = exp` | Defines a named constant value. `$id` is valid util the end of the current meta lexical block. |
-|:----------------|:-----------------------------------------------------------------------------------------------|
-| `$range id exp..exp` | Sets the range of an iteration variable, which can be reused in multiple loops later.          |
-| `$for id sep [[ code ]]` | Iteration. The range of `id` must have been defined earlier. `$id` is valid in `code`.         |
-| `$($)`          | Generates a single `$` character.                                                              |
-| `$id`           | Value of the named constant or iteration variable.                                             |
-| `$(exp)`        | Value of the expression.                                                                       |
-| `$if exp [[ code ]] else_branch` | Conditional.                                                                                   |
-| `[[ code ]]`    | Meta lexical block.                                                                            |
-| `cpp_code`      | Raw C++ code.                                                                                  |
-| `$$ comment`    | Meta comment.                                                                                  |
-
-**Note:** To give the user some freedom in formatting the Pump source
-code, Pump ignores a new-line character if it's right after `$for foo`
-or next to `[[` or `]]`. Without this rule you'll often be forced to write
-very long lines to get the desired output. Therefore sometimes you may
-need to insert an extra new-line in such places for a new-line to show
-up in your output.
-
-## Grammar ##
-
-```
-code ::= atomic_code*
-atomic_code ::= $var id = exp
-    | $var id = [[ code ]]
-    | $range id exp..exp
-    | $for id sep [[ code ]]
-    | $($)
-    | $id
-    | $(exp)
-    | $if exp [[ code ]] else_branch
-    | [[ code ]]
-    | cpp_code
-sep ::= cpp_code | empty_string
-else_branch ::= $else [[ code ]]
-    | $elif exp [[ code ]] else_branch
-    | empty_string
-exp ::= simple_expression_in_Python_syntax
-```
-
-## Code ##
-
-You can find the source code of Pump in [scripts/pump.py](../scripts/pump.py). It is still
-very unpolished and lacks automated tests, although it has been
-successfully used many times. If you find a chance to use it in your
-project, please let us know what you think!  We also welcome help on
-improving Pump.
-
-## Real Examples ##
-
-You can find real-world applications of Pump in [Google Test](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgoogletest\.googlecode\.com) and [Google Mock](http://www.google.com/codesearch?q=file%3A\.pump%24+package%3Ahttp%3A%2F%2Fgooglemock\.googlecode\.com).  The source file `foo.h.pump` generates `foo.h`.
-
-## Tips ##
-
-  * If a meta variable is followed by a letter or digit, you can separate them using `[[]]`, which inserts an empty string. For example `Foo$j[[]]Helper` generate `Foo1Helper` when `j` is 1.
-  * To avoid extra-long Pump source lines, you can break a line anywhere you want by inserting `[[]]` followed by a new line. Since any new-line character next to `[[` or `]]` is ignored, the generated code won't contain this new line.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Samples.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Samples.md
deleted file mode 100644
index f21d2005..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_Samples.md
+++ /dev/null
@@ -1,14 +0,0 @@
-If you're like us, you'd like to look at some Google Test sample code.  The
-[samples folder](../samples) has a number of well-commented samples showing how to use a
-variety of Google Test features.
-
-  * [Sample #1](../samples/sample1_unittest.cc) shows the basic steps of using Google Test to test C++ functions.
-  * [Sample #2](../samples/sample2_unittest.cc) shows a more complex unit test for a class with multiple member functions.
-  * [Sample #3](../samples/sample3_unittest.cc) uses a test fixture.
-  * [Sample #4](../samples/sample4_unittest.cc) is another basic example of using Google Test.
-  * [Sample #5](../samples/sample5_unittest.cc) teaches how to reuse a test fixture in multiple test cases by deriving sub-fixtures from it.
-  * [Sample #6](../samples/sample6_unittest.cc) demonstrates type-parameterized tests.
-  * [Sample #7](../samples/sample7_unittest.cc) teaches the basics of value-parameterized tests.
-  * [Sample #8](../samples/sample8_unittest.cc) shows using `Combine()` in value-parameterized tests.
-  * [Sample #9](../samples/sample9_unittest.cc) shows use of the listener API to modify Google Test's console output and the use of its reflection API to inspect test results.
-  * [Sample #10](../samples/sample10_unittest.cc) shows use of the listener API to implement a primitive memory leak checker.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_XcodeGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_XcodeGuide.md
deleted file mode 100644
index bf24bf51..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/V1_7_XcodeGuide.md
+++ /dev/null
@@ -1,93 +0,0 @@
-
-
-This guide will explain how to use the Google Testing Framework in your Xcode projects on Mac OS X. This tutorial begins by quickly explaining what to do for experienced users. After the quick start, the guide goes provides additional explanation about each step.
-
-# Quick Start #
-
-Here is the quick guide for using Google Test in your Xcode project.
-
-  1. Download the source from the [website](http://code.google.com/p/googletest) using this command: `svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only`
-  1. Open up the `gtest.xcodeproj` in the `googletest-read-only/xcode/` directory and build the gtest.framework.
-  1. Create a new "Shell Tool" target in your Xcode project called something like "UnitTests"
-  1. Add the gtest.framework to your project and add it to the "Link Binary with Libraries" build phase of "UnitTests"
-  1. Add your unit test source code to the "Compile Sources" build phase of "UnitTests"
-  1. Edit the "UnitTests" executable and add an environment variable named "DYLD\_FRAMEWORK\_PATH" with a value equal to the path to the framework containing the gtest.framework relative to the compiled executable.
-  1. Build and Go
-
-The following sections further explain each of the steps listed above in depth, describing in more detail how to complete it including some variations.
-
-# Get the Source #
-
-Currently, the gtest.framework discussed here isn't available in a tagged release of Google Test, it is only available in the trunk. As explained at the Google Test [site](http://code.google.com/p/googletest/source/checkout">svn), you can get the code from anonymous SVN with this command:
-
-```
-svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only
-```
-
-Alternatively, if you are working with Subversion in your own code base, you can add Google Test as an external dependency to your own Subversion repository. By following this approach, everyone that checks out your svn repository will also receive a copy of Google Test (a specific version, if you wish) without having to check it out explicitly. This makes the set up of your project simpler and reduces the copied code in the repository.
-
-To use `svn:externals`, decide where you would like to have the external source reside. You might choose to put the external source inside the trunk, because you want it to be part of the branch when you make a release. However, keeping it outside the trunk in a version-tagged directory called something like `third-party/googletest/1.0.1`, is another option. Once the location is established, use `svn propedit svn:externals _directory_` to set the svn:externals property on a directory in your repository. This directory won't contain the code, but be its versioned parent directory.
-
-The command `svn propedit` will bring up your Subversion editor, making editing the long, (potentially multi-line) property simpler. This same method can be used to check out a tagged branch, by using the appropriate URL (e.g. `http://googletest.googlecode.com/svn/tags/release-1.0.1`). Additionally, the svn:externals property allows the specification of a particular revision of the trunk with the `-r_##_` option (e.g. `externals/src/googletest -r60 http://googletest.googlecode.com/svn/trunk`).
-
-Here is an example of using the svn:externals properties on a trunk (read via `svn propget`) of a project. This value checks out a copy of Google Test into the `trunk/externals/src/googletest/` directory.
-
-```
-[Computer:svn] user$ svn propget svn:externals trunk
-externals/src/googletest http://googletest.googlecode.com/svn/trunk
-```
-
-# Add the Framework to Your Project #
-
-The next step is to build and add the gtest.framework to your own project. This guide describes two common ways below.
-
-  * **Option 1** --- The simplest way to add Google Test to your own project, is to open gtest.xcodeproj (found in the xcode/ directory of the Google Test trunk) and build the framework manually. Then, add the built framework into your project using the "Add->Existing Framework..." from the context menu or "Project->Add..." from the main menu. The gtest.framework is relocatable and contains the headers and object code that you'll need to make tests. This method requires rebuilding every time you upgrade Google Test in your project.
-  * **Option 2** --- If you are going to be living off the trunk of Google Test, incorporating its latest features into your unit tests (or are a Google Test developer yourself). You'll want to rebuild the framework every time the source updates. to do this, you'll need to add the gtest.xcodeproj file, not the framework itself, to your own Xcode project. Then, from the build products that are revealed by the project's disclosure triangle, you can find the gtest.framework, which can be added to your targets (discussed below).
-
-# Make a Test Target #
-
-To start writing tests, make a new "Shell Tool" target. This target template is available under BSD, Cocoa, or Carbon. Add your unit test source code to the "Compile Sources" build phase of the target.
-
-Next, you'll want to add gtest.framework in two different ways, depending upon which option you chose above.
-
-  * **Option 1** --- During compilation, Xcode will need to know that you are linking against the gtest.framework. Add the gtest.framework to the "Link Binary with Libraries" build phase of your test target. This will include the Google Test headers in your header search path, and will tell the linker where to find the library.
-  * **Option 2** --- If your working out of the trunk, you'll also want to add gtest.framework to your "Link Binary with Libraries" build phase of your test target. In addition, you'll  want to add the gtest.framework as a dependency to your unit test target. This way, Xcode will make sure that gtest.framework is up to date, every time your build your target. Finally, if you don't share build directories with Google Test, you'll have to copy the gtest.framework into your own build products directory using a "Run Script" build phase.
-
-# Set Up the Executable Run Environment #
-
-Since the unit test executable is a shell tool, it doesn't have a bundle with a `Contents/Frameworks` directory, in which to place gtest.framework. Instead, the dynamic linker must be told at runtime to search for the framework in another location. This can be accomplished by setting the "DYLD\_FRAMEWORK\_PATH" environment variable in the "Edit Active Executable ..." Arguments tab, under "Variables to be set in the environment:". The path for this value is the path (relative or absolute) of the directory containing the gtest.framework.
-
-If you haven't set up the DYLD\_FRAMEWORK\_PATH, correctly, you might get a message like this:
-
-```
-[Session started at 2008-08-15 06:23:57 -0600.]
-  dyld: Library not loaded: @loader_path/../Frameworks/gtest.framework/Versions/A/gtest
-    Referenced from: /Users/username/Documents/Sandbox/gtestSample/build/Debug/WidgetFrameworkTest
-    Reason: image not found
-```
-
-To correct this problem, got to the directory containing the executable named in "Referenced from:" value in the error message above. Then, with the terminal in this location, find the relative path to the directory containing the gtest.framework. That is the value you'll need to set as the DYLD\_FRAMEWORK\_PATH.
-
-# Build and Go #
-
-Now, when you click "Build and Go", the test will be executed. Dumping out something like this:
-
-```
-[Session started at 2008-08-06 06:36:13 -0600.]
-[==========] Running 2 tests from 1 test case.
-[----------] Global test environment set-up.
-[----------] 2 tests from WidgetInitializerTest
-[ RUN      ] WidgetInitializerTest.TestConstructor
-[       OK ] WidgetInitializerTest.TestConstructor
-[ RUN      ] WidgetInitializerTest.TestConversion
-[       OK ] WidgetInitializerTest.TestConversion
-[----------] Global test environment tear-down
-[==========] 2 tests from 1 test case ran.
-[  PASSED  ] 2 tests.
-
-The Debugger has exited with status 0.  
-```
-
-# Summary #
-
-Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/XcodeGuide.md b/week4/softwareEng_9_4/vendor/googletest/googletest/docs/XcodeGuide.md
deleted file mode 100644
index bf24bf51..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/docs/XcodeGuide.md
+++ /dev/null
@@ -1,93 +0,0 @@
-
-
-This guide will explain how to use the Google Testing Framework in your Xcode projects on Mac OS X. This tutorial begins by quickly explaining what to do for experienced users. After the quick start, the guide goes provides additional explanation about each step.
-
-# Quick Start #
-
-Here is the quick guide for using Google Test in your Xcode project.
-
-  1. Download the source from the [website](http://code.google.com/p/googletest) using this command: `svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only`
-  1. Open up the `gtest.xcodeproj` in the `googletest-read-only/xcode/` directory and build the gtest.framework.
-  1. Create a new "Shell Tool" target in your Xcode project called something like "UnitTests"
-  1. Add the gtest.framework to your project and add it to the "Link Binary with Libraries" build phase of "UnitTests"
-  1. Add your unit test source code to the "Compile Sources" build phase of "UnitTests"
-  1. Edit the "UnitTests" executable and add an environment variable named "DYLD\_FRAMEWORK\_PATH" with a value equal to the path to the framework containing the gtest.framework relative to the compiled executable.
-  1. Build and Go
-
-The following sections further explain each of the steps listed above in depth, describing in more detail how to complete it including some variations.
-
-# Get the Source #
-
-Currently, the gtest.framework discussed here isn't available in a tagged release of Google Test, it is only available in the trunk. As explained at the Google Test [site](http://code.google.com/p/googletest/source/checkout">svn), you can get the code from anonymous SVN with this command:
-
-```
-svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-read-only
-```
-
-Alternatively, if you are working with Subversion in your own code base, you can add Google Test as an external dependency to your own Subversion repository. By following this approach, everyone that checks out your svn repository will also receive a copy of Google Test (a specific version, if you wish) without having to check it out explicitly. This makes the set up of your project simpler and reduces the copied code in the repository.
-
-To use `svn:externals`, decide where you would like to have the external source reside. You might choose to put the external source inside the trunk, because you want it to be part of the branch when you make a release. However, keeping it outside the trunk in a version-tagged directory called something like `third-party/googletest/1.0.1`, is another option. Once the location is established, use `svn propedit svn:externals _directory_` to set the svn:externals property on a directory in your repository. This directory won't contain the code, but be its versioned parent directory.
-
-The command `svn propedit` will bring up your Subversion editor, making editing the long, (potentially multi-line) property simpler. This same method can be used to check out a tagged branch, by using the appropriate URL (e.g. `http://googletest.googlecode.com/svn/tags/release-1.0.1`). Additionally, the svn:externals property allows the specification of a particular revision of the trunk with the `-r_##_` option (e.g. `externals/src/googletest -r60 http://googletest.googlecode.com/svn/trunk`).
-
-Here is an example of using the svn:externals properties on a trunk (read via `svn propget`) of a project. This value checks out a copy of Google Test into the `trunk/externals/src/googletest/` directory.
-
-```
-[Computer:svn] user$ svn propget svn:externals trunk
-externals/src/googletest http://googletest.googlecode.com/svn/trunk
-```
-
-# Add the Framework to Your Project #
-
-The next step is to build and add the gtest.framework to your own project. This guide describes two common ways below.
-
-  * **Option 1** --- The simplest way to add Google Test to your own project, is to open gtest.xcodeproj (found in the xcode/ directory of the Google Test trunk) and build the framework manually. Then, add the built framework into your project using the "Add->Existing Framework..." from the context menu or "Project->Add..." from the main menu. The gtest.framework is relocatable and contains the headers and object code that you'll need to make tests. This method requires rebuilding every time you upgrade Google Test in your project.
-  * **Option 2** --- If you are going to be living off the trunk of Google Test, incorporating its latest features into your unit tests (or are a Google Test developer yourself). You'll want to rebuild the framework every time the source updates. to do this, you'll need to add the gtest.xcodeproj file, not the framework itself, to your own Xcode project. Then, from the build products that are revealed by the project's disclosure triangle, you can find the gtest.framework, which can be added to your targets (discussed below).
-
-# Make a Test Target #
-
-To start writing tests, make a new "Shell Tool" target. This target template is available under BSD, Cocoa, or Carbon. Add your unit test source code to the "Compile Sources" build phase of the target.
-
-Next, you'll want to add gtest.framework in two different ways, depending upon which option you chose above.
-
-  * **Option 1** --- During compilation, Xcode will need to know that you are linking against the gtest.framework. Add the gtest.framework to the "Link Binary with Libraries" build phase of your test target. This will include the Google Test headers in your header search path, and will tell the linker where to find the library.
-  * **Option 2** --- If your working out of the trunk, you'll also want to add gtest.framework to your "Link Binary with Libraries" build phase of your test target. In addition, you'll  want to add the gtest.framework as a dependency to your unit test target. This way, Xcode will make sure that gtest.framework is up to date, every time your build your target. Finally, if you don't share build directories with Google Test, you'll have to copy the gtest.framework into your own build products directory using a "Run Script" build phase.
-
-# Set Up the Executable Run Environment #
-
-Since the unit test executable is a shell tool, it doesn't have a bundle with a `Contents/Frameworks` directory, in which to place gtest.framework. Instead, the dynamic linker must be told at runtime to search for the framework in another location. This can be accomplished by setting the "DYLD\_FRAMEWORK\_PATH" environment variable in the "Edit Active Executable ..." Arguments tab, under "Variables to be set in the environment:". The path for this value is the path (relative or absolute) of the directory containing the gtest.framework.
-
-If you haven't set up the DYLD\_FRAMEWORK\_PATH, correctly, you might get a message like this:
-
-```
-[Session started at 2008-08-15 06:23:57 -0600.]
-  dyld: Library not loaded: @loader_path/../Frameworks/gtest.framework/Versions/A/gtest
-    Referenced from: /Users/username/Documents/Sandbox/gtestSample/build/Debug/WidgetFrameworkTest
-    Reason: image not found
-```
-
-To correct this problem, got to the directory containing the executable named in "Referenced from:" value in the error message above. Then, with the terminal in this location, find the relative path to the directory containing the gtest.framework. That is the value you'll need to set as the DYLD\_FRAMEWORK\_PATH.
-
-# Build and Go #
-
-Now, when you click "Build and Go", the test will be executed. Dumping out something like this:
-
-```
-[Session started at 2008-08-06 06:36:13 -0600.]
-[==========] Running 2 tests from 1 test case.
-[----------] Global test environment set-up.
-[----------] 2 tests from WidgetInitializerTest
-[ RUN      ] WidgetInitializerTest.TestConstructor
-[       OK ] WidgetInitializerTest.TestConstructor
-[ RUN      ] WidgetInitializerTest.TestConversion
-[       OK ] WidgetInitializerTest.TestConversion
-[----------] Global test environment tear-down
-[==========] 2 tests from 1 test case ran.
-[  PASSED  ] 2 tests.
-
-The Debugger has exited with status 0.  
-```
-
-# Summary #
-
-Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-death-test.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-death-test.h
deleted file mode 100644
index 957a69c6..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-death-test.h
+++ /dev/null
@@ -1,294 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// The Google C++ Testing 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.
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
-#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
-
-#include "gtest/internal/gtest-death-test-internal.h"
-
-namespace testing {
-
-// This flag controls the style of death tests.  Valid values are "threadsafe",
-// meaning that the death test child process will re-execute the test binary
-// from the start, running only a single death test, or "fast",
-// meaning that the child process will execute the test logic immediately
-// after forking.
-GTEST_DECLARE_string_(death_test_style);
-
-#if GTEST_HAS_DEATH_TEST
-
-namespace internal {
-
-// Returns a Boolean value indicating whether the caller is currently
-// executing in the context of the death test child process.  Tools such as
-// Valgrind heap checkers may need this to modify their behavior in death
-// tests.  IMPORTANT: This is an internal utility.  Using it may break the
-// implementation of death tests.  User code MUST NOT use it.
-GTEST_API_ bool InDeathTestChild();
-
-}  // namespace internal
-
-// The following macros are useful for writing death tests.
-
-// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
-// executed:
-//
-//   1. It generates a warning if there is more than one active
-//   thread.  This is because it's safe to fork() or clone() only
-//   when there is a single thread.
-//
-//   2. The parent process clone()s a sub-process and runs the death
-//   test in it; the sub-process exits with code 0 at the end of the
-//   death test, if it hasn't exited already.
-//
-//   3. The parent process waits for the sub-process to terminate.
-//
-//   4. The parent process checks the exit code and error message of
-//   the sub-process.
-//
-// Examples:
-//
-//   ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
-//   for (int i = 0; i < 5; i++) {
-//     EXPECT_DEATH(server.ProcessRequest(i),
-//                  "Invalid request .* in ProcessRequest()")
-//                  << "Failed to die on request " << i;
-//   }
-//
-//   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
-//
-//   bool KilledBySIGHUP(int exit_code) {
-//     return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
-//   }
-//
-//   ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
-//
-// On the regular expressions used in death tests:
-//
-//   On POSIX-compliant systems (*nix), we use the <regex.h> library,
-//   which uses the POSIX extended regex syntax.
-//
-//   On other platforms (e.g. Windows), 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
-//   or POSIX extended regex syntax.  For example, we don't support
-//   union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
-//   repetition count ("x{5,7}"), among others.
-//
-//   Below is the syntax that we do support.  We chose it to be a
-//   subset of both PCRE and POSIX extended regex, so it's easy to
-//   learn wherever you come from.  In the following: 'A' denotes a
-//   literal character, period (.), or a single \\ escape sequence;
-//   'x' and 'y' denote regular expressions; 'm' and 'n' are for
-//   natural numbers.
-//
-//     c     matches any literal character c
-//     \\d   matches any decimal digit
-//     \\D   matches any character that's not a decimal digit
-//     \\f   matches \f
-//     \\n   matches \n
-//     \\r   matches \r
-//     \\s   matches any ASCII whitespace, including \n
-//     \\S   matches any character that's not a whitespace
-//     \\t   matches \t
-//     \\v   matches \v
-//     \\w   matches any letter, _, or decimal digit
-//     \\W   matches any character that \\w doesn't match
-//     \\c   matches any literal character c, which must be a punctuation
-//     .     matches any single character except \n
-//     A?    matches 0 or 1 occurrences of A
-//     A*    matches 0 or many occurrences of A
-//     A+    matches 1 or many occurrences of A
-//     ^     matches the beginning of a string (not that of each line)
-//     $     matches the end of a string (not that of each line)
-//     xy    matches x followed by y
-//
-//   If you accidentally use PCRE or POSIX extended regex features
-//   not implemented by us, you will get a run-time failure.  In that
-//   case, please try to rewrite your regular expression within the
-//   above syntax.
-//
-//   This implementation is *not* meant to be as highly tuned or robust
-//   as a compiled regex library, but should perform well enough for a
-//   death test, which already incurs significant overhead by launching
-//   a child process.
-//
-// Known caveats:
-//
-//   A "threadsafe" style death test obtains the path to the test
-//   program from argv[0] and re-executes it in the sub-process.  For
-//   simplicity, the current implementation doesn't search the PATH
-//   when launching the sub-process.  This means that the user must
-//   invoke the test program via a path that contains at least one
-//   path separator (e.g. path/to/foo_test and
-//   /absolute/path/to/bar_test are fine, but foo_test is not).  This
-//   is rarely a problem as people usually don't put the test binary
-//   directory in PATH.
-//
-// TODO(wan@google.com): make thread-safe death tests search the 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 regex.
-# define ASSERT_EXIT(statement, predicate, regex) \
-    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)
-
-// Like ASSERT_EXIT, but continues on to successive tests in the
-// test case, if any:
-# define EXPECT_EXIT(statement, predicate, regex) \
-    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_)
-
-// 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 regex.
-# define ASSERT_DEATH(statement, regex) \
-    ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
-
-// Like ASSERT_DEATH, but continues on to successive tests in the
-// test case, if any:
-# define EXPECT_DEATH(statement, regex) \
-    EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
-
-// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
-
-// Tests that an exit code describes a normal exit with a given exit code.
-class GTEST_API_ ExitedWithCode {
- public:
-  explicit ExitedWithCode(int exit_code);
-  bool operator()(int exit_status) const;
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ExitedWithCode& other);
-
-  const int exit_code_;
-};
-
-# if !GTEST_OS_WINDOWS
-// Tests that an exit code describes an exit due to termination by a
-// given signal.
-class GTEST_API_ KilledBySignal {
- public:
-  explicit KilledBySignal(int signum);
-  bool operator()(int exit_status) const;
- private:
-  const int signum_;
-};
-# endif  // !GTEST_OS_WINDOWS
-
-// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
-// The death testing framework causes this to have interesting semantics,
-// since the sideeffects of the call are only visible in opt mode, and not
-// in debug mode.
-//
-// In practice, this can be used to test functions that utilize the
-// LOG(DFATAL) macro using the following style:
-//
-// int DieInDebugOr12(int* sideeffect) {
-//   if (sideeffect) {
-//     *sideeffect = 12;
-//   }
-//   LOG(DFATAL) << "death";
-//   return 12;
-// }
-//
-// TEST(TestCase, TestDieOr12WorksInDgbAndOpt) {
-//   int sideeffect = 0;
-//   // Only asserts in dbg.
-//   EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
-//
-// #ifdef NDEBUG
-//   // opt-mode has sideeffect visible.
-//   EXPECT_EQ(12, sideeffect);
-// #else
-//   // dbg-mode no visible sideeffect.
-//   EXPECT_EQ(0, sideeffect);
-// #endif
-// }
-//
-// This will assert that DieInDebugReturn12InOpt() crashes in debug
-// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
-// appropriate fallback value (12 in this case) in opt mode. If you
-// need to test that a function has appropriate side-effects in opt
-// mode, include assertions against the side-effects.  A general
-// pattern for this is:
-//
-// EXPECT_DEBUG_DEATH({
-//   // Side-effects here will have an effect after this statement in
-//   // opt mode, but none in debug mode.
-//   EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
-// }, "death");
-//
-# ifdef NDEBUG
-
-#  define EXPECT_DEBUG_DEATH(statement, regex) \
-  GTEST_EXECUTE_STATEMENT_(statement, regex)
-
-#  define ASSERT_DEBUG_DEATH(statement, regex) \
-  GTEST_EXECUTE_STATEMENT_(statement, regex)
-
-# else
-
-#  define EXPECT_DEBUG_DEATH(statement, regex) \
-  EXPECT_DEATH(statement, regex)
-
-#  define ASSERT_DEBUG_DEATH(statement, regex) \
-  ASSERT_DEATH(statement, regex)
-
-# endif  // NDEBUG for EXPECT_DEBUG_DEATH
-#endif  // GTEST_HAS_DEATH_TEST
-
-// 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
-// useful when you are combining death test assertions with normal test
-// assertions in one test.
-#if GTEST_HAS_DEATH_TEST
-# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
-    EXPECT_DEATH(statement, regex)
-# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
-    ASSERT_DEATH(statement, regex)
-#else
-# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
-    GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, )
-# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
-    GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, return)
-#endif
-
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-message.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-message.h
deleted file mode 100644
index fe879bca..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-message.h
+++ /dev/null
@@ -1,250 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This header file defines the Message class.
-//
-// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
-// leave some internal implementation details in this header file.
-// They are clearly marked by comments like this:
-//
-//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-//
-// Such code is NOT meant to be used by a user directly, and is subject
-// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
-// program!
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
-#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
-
-#include <limits>
-
-#include "gtest/internal/gtest-port.h"
-
-// 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);
-
-namespace testing {
-
-// The Message class works like an ostream repeater.
-//
-// Typical usage:
-//
-//   1. You stream a bunch of values to a Message object.
-//      It will remember the text in a stringstream.
-//   2. Then you stream the Message object to an ostream.
-//      This causes the text in the Message to be streamed
-//      to the ostream.
-//
-// For example;
-//
-//   testing::Message foo;
-//   foo << 1 << " != " << 2;
-//   std::cout << foo;
-//
-// will print "1 != 2".
-//
-// Message is not intended to be inherited from.  In particular, its
-// destructor is not virtual.
-//
-// Note that stringstream behaves differently in gcc and in MSVC.  You
-// can stream a NULL char pointer to it in the former, but not in the
-// latter (it causes an access violation if you do).  The Message
-// class hides this difference by treating a NULL char pointer as
-// "(null)".
-class GTEST_API_ Message {
- private:
-  // The type of basic IO manipulators (endl, ends, and flush) for
-  // narrow streams.
-  typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
-
- public:
-  // Constructs an empty Message.
-  Message();
-
-  // Copy constructor.
-  Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
-    *ss_ << msg.GetString();
-  }
-
-  // Constructs a Message from a C-string.
-  explicit Message(const char* str) : ss_(new ::std::stringstream) {
-    *ss_ << str;
-  }
-
-#if GTEST_OS_SYMBIAN
-  // Streams a value (either a pointer or not) to this object.
-  template <typename T>
-  inline Message& operator <<(const T& value) {
-    StreamHelper(typename internal::is_pointer<T>::type(), value);
-    return *this;
-  }
-#else
-  // Streams a non-pointer value to this object.
-  template <typename T>
-  inline Message& operator <<(const T& val) {
-    // Some libraries overload << for STL containers.  These
-    // overloads are defined in the global namespace instead of ::std.
-    //
-    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
-    // overloads are visible in either the std namespace or the global
-    // namespace, but not other namespaces, including the testing
-    // namespace which Google Test's Message class is in.
-    //
-    // To allow STL containers (and other types that has a << operator
-    // defined in the global namespace) to be used in Google Test
-    // assertions, testing::Message must access the custom << operator
-    // from the global namespace.  With this using declaration,
-    // overloads of << defined in the global namespace and those
-    // visible via Koenig lookup are both exposed in this function.
-    using ::operator <<;
-    *ss_ << val;
-    return *this;
-  }
-
-  // Streams a pointer value to this object.
-  //
-  // This function is an overload of the previous one.  When you
-  // stream a pointer to a Message, this definition will be used as it
-  // is more specialized.  (The C++ Standard, section
-  // [temp.func.order].)  If you stream a non-pointer, then the
-  // previous definition will be used.
-  //
-  // The reason for this overload is that streaming a NULL pointer to
-  // ostream is undefined behavior.  Depending on the compiler, you
-  // may get "0", "(nil)", "(null)", or an access violation.  To
-  // ensure consistent result across compilers, we always treat NULL
-  // as "(null)".
-  template <typename T>
-  inline Message& operator <<(T* const& pointer) {  // NOLINT
-    if (pointer == NULL) {
-      *ss_ << "(null)";
-    } else {
-      *ss_ << pointer;
-    }
-    return *this;
-  }
-#endif  // GTEST_OS_SYMBIAN
-
-  // Since the basic IO manipulators are overloaded for both narrow
-  // and wide streams, we have to provide this specialized definition
-  // of operator <<, even though its body is the same as the
-  // templatized version above.  Without this definition, streaming
-  // endl or other basic IO manipulators to Message will confuse the
-  // compiler.
-  Message& operator <<(BasicNarrowIoManip val) {
-    *ss_ << val;
-    return *this;
-  }
-
-  // Instead of 1/0, we want to see true/false for bool values.
-  Message& operator <<(bool b) {
-    return *this << (b ? "true" : "false");
-  }
-
-  // These two overloads allow streaming a wide C string to a Message
-  // using the UTF-8 encoding.
-  Message& operator <<(const wchar_t* wide_c_str);
-  Message& operator <<(wchar_t* wide_c_str);
-
-#if GTEST_HAS_STD_WSTRING
-  // Converts the given wide string to a narrow string using the UTF-8
-  // encoding, and streams the result to this Message object.
-  Message& operator <<(const ::std::wstring& wstr);
-#endif  // GTEST_HAS_STD_WSTRING
-
-#if GTEST_HAS_GLOBAL_WSTRING
-  // Converts the given wide string to a narrow string using the UTF-8
-  // encoding, and streams the result to this Message object.
-  Message& operator <<(const ::wstring& wstr);
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-  // Gets the text streamed to this object so far as an std::string.
-  // Each '\0' character in the buffer is replaced with "\\0".
-  //
-  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  std::string GetString() const;
-
- private:
-
-#if GTEST_OS_SYMBIAN
-  // These are needed as the Nokia Symbian Compiler cannot decide between
-  // const T& and const T* in a function template. The Nokia compiler _can_
-  // decide between class template specializations for T and T*, so a
-  // tr1::type_traits-like is_pointer works, and we can overload on that.
-  template <typename T>
-  inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
-    if (pointer == NULL) {
-      *ss_ << "(null)";
-    } else {
-      *ss_ << pointer;
-    }
-  }
-  template <typename T>
-  inline void StreamHelper(internal::false_type /*is_pointer*/,
-                           const T& value) {
-    // See the comments in Message& operator <<(const T&) above for why
-    // we need this using statement.
-    using ::operator <<;
-    *ss_ << value;
-  }
-#endif  // GTEST_OS_SYMBIAN
-
-  // We'll hold the text streamed to this object here.
-  const internal::scoped_ptr< ::std::stringstream> ss_;
-
-  // We declare (but don't implement) this to prevent the compiler
-  // from implementing the assignment operator.
-  void operator=(const Message&);
-};
-
-// Streams a Message to an ostream.
-inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
-  return os << sb.GetString();
-}
-
-namespace internal {
-
-// Converts a streamable value to an std::string.  A NULL pointer is
-// converted to "(null)".  When the input value is a ::string,
-// ::std::string, ::wstring, or ::std::wstring object, each NUL
-// character in it is replaced with "\\0".
-template <typename T>
-std::string StreamableToString(const T& streamable) {
-  return (Message() << streamable).GetString();
-}
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h
deleted file mode 100644
index 038f9ba7..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h
+++ /dev/null
@@ -1,1444 +0,0 @@
-// This file was GENERATED by command:
-//     pump.py gtest-param-test.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// 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.
-//
-// Authors: vladl@google.com (Vlad Losev)
-//
-// Macros and functions for implementing parameterized tests
-// in Google C++ Testing Framework (Google Test)
-//
-// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
-//
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
-#define GTEST_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.
-//
-// Here is how you use value-parameterized tests:
-
-#if 0
-
-// To write value-parameterized tests, first you should define a fixture
-// class. It is usually derived from testing::TestWithParam<T> (see below for
-// another inheritance scheme that's sometimes useful in more complicated
-// class hierarchies), where the type of your parameter values.
-// TestWithParam<T> is itself derived from testing::Test. T can be any
-// copyable type. If it's a raw pointer, you are responsible for managing the
-// lifespan of the pointed values.
-
-class FooTest : public ::testing::TestWithParam<const char*> {
-  // You can implement all the usual class fixture members here.
-};
-
-// Then, use the TEST_P macro to define as many parameterized tests
-// for this fixture as you want. The _P suffix is for "parameterized"
-// or "pattern", whichever you prefer to think.
-
-TEST_P(FooTest, DoesBlah) {
-  // Inside a test, access the test parameter with the GetParam() method
-  // of the TestWithParam<T> class:
-  EXPECT_TRUE(foo.Blah(GetParam()));
-  ...
-}
-
-TEST_P(FooTest, HasBlahBlah) {
-  ...
-}
-
-// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
-// case with 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
-// are all in the testing namespace:
-//
-//
-//  Range(begin, end [, step]) - Yields values {begin, begin+step,
-//                               begin+step+step, ...}. The values do not
-//                               include end. step defaults to 1.
-//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
-//  ValuesIn(container)        - Yields values from a C-style array, an STL
-//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
-//  Bool()                     - Yields sequence {false, true}.
-//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
-//                               for the math savvy) of the values generated
-//                               by the N generators.
-//
-// 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 case
-// each with parameter values "meeny", "miny", and "moe".
-
-INSTANTIATE_TEST_CASE_P(InstantiationName,
-                        FooTest,
-                        Values("meeny", "miny", "moe"));
-
-// To distinguish different instances of the pattern, (yes, you
-// can instantiate it more then once) the first argument to the
-// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
-// actual test case name. Remember to pick unique prefixes for different
-// instantiations. The tests from the instantiation above will have
-// these names:
-//
-//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
-//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
-//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
-//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
-//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
-//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
-//
-// You can use these names in --gtest_filter.
-//
-// This statement will instantiate all tests from FooTest again, each
-// with parameter values "cat" and "dog":
-
-const char* pets[] = {"cat", "dog"};
-INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
-
-// The tests from the instantiation above will have these names:
-//
-//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
-//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
-//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
-//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
-//
-// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
-// in the given test case, whether their definitions come before or
-// AFTER the INSTANTIATE_TEST_CASE_P statement.
-//
-// Please also note that generator expressions (including parameters to the
-// generators) are evaluated in InitGoogleTest(), after main() has started.
-// This allows the user on one hand, to adjust generator parameters in order
-// to dynamically determine a set of tests to run and on the other hand,
-// give the user a chance to inspect the generated tests with Google Test
-// reflection API before RUN_ALL_TESTS() is executed.
-//
-// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
-// for more examples.
-//
-// In the future, we plan to publish the API for defining new parameter
-// generators. But for now this interface remains part of the internal
-// implementation and is subject to change.
-//
-//
-// A parameterized test fixture must be derived from testing::Test and from
-// testing::WithParamInterface<T>, where T is the type of the parameter
-// values. Inheriting from TestWithParam<T> satisfies that requirement because
-// TestWithParam<T> inherits from both Test and WithParamInterface. In more
-// complicated hierarchies, however, it is occasionally useful to inherit
-// separately from Test and WithParamInterface. For example:
-
-class BaseTest : public ::testing::Test {
-  // You can inherit all the usual members for a non-parameterized test
-  // fixture here.
-};
-
-class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
-  // The usual test fixture members go here too.
-};
-
-TEST_F(BaseTest, HasFoo) {
-  // This is an ordinary non-parameterized test.
-}
-
-TEST_P(DerivedTest, DoesBlah) {
-  // GetParam works just the same here as if you inherit from TestWithParam.
-  EXPECT_TRUE(foo.Blah(GetParam()));
-}
-
-#endif  // 0
-
-#include "gtest/internal/gtest-port.h"
-
-#if !GTEST_OS_SYMBIAN
-# include <utility>
-#endif
-
-// scripts/fuse_gtest.py depends on gtest's own header being #included
-// *unconditionally*.  Therefore these #includes cannot be moved
-// inside #if GTEST_HAS_PARAM_TEST.
-#include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-param-util.h"
-#include "gtest/internal/gtest-param-util-generated.h"
-
-#if GTEST_HAS_PARAM_TEST
-
-namespace testing {
-
-// Functions producing parameter generators.
-//
-// Google Test uses these generators to produce parameters for value-
-// parameterized tests. When a parameterized test case 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 case FooTest are instantiated
-// each three times with parameter values 3, 5, and 8:
-//
-// class FooTest : public TestWithParam<int> { ... };
-//
-// TEST_P(FooTest, TestThis) {
-// }
-// TEST_P(FooTest, TestThat) {
-// }
-// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
-//
-
-// Range() returns generators providing sequences of values in a range.
-//
-// Synopsis:
-// Range(start, end)
-//   - returns a generator producing a sequence of values {start, start+1,
-//     start+2, ..., }.
-// Range(start, end, step)
-//   - returns a generator producing a sequence of values {start, start+step,
-//     start+step+step, ..., }.
-// Notes:
-//   * The generated sequences never include end. For example, Range(1, 5)
-//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
-//     returns a generator producing {1, 3, 5, 7}.
-//   * start and end must have the same type. That type may be any integral or
-//     floating-point type or a user defined type satisfying these conditions:
-//     * It must be assignable (have operator=() defined).
-//     * It must have operator+() (operator+(int-compatible type) for
-//       two-operand version).
-//     * It must have operator<() defined.
-//     Elements in the resulting sequences will also have that type.
-//   * Condition start < end must be satisfied in order for resulting sequences
-//     to contain any elements.
-//
-template <typename T, typename IncrementT>
-internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
-  return internal::ParamGenerator<T>(
-      new internal::RangeGenerator<T, IncrementT>(start, end, step));
-}
-
-template <typename T>
-internal::ParamGenerator<T> Range(T start, T end) {
-  return Range(start, end, 1);
-}
-
-// ValuesIn() function allows generation of tests with parameters coming from
-// a container.
-//
-// Synopsis:
-// ValuesIn(const T (&array)[N])
-//   - returns a generator producing sequences with elements from
-//     a C-style array.
-// ValuesIn(const Container& container)
-//   - returns a generator producing sequences with elements from
-//     an STL-style container.
-// ValuesIn(Iterator begin, Iterator end)
-//   - returns a generator producing sequences with elements from
-//     a range [begin, end) defined by a pair of STL-style iterators. These
-//     iterators can also be plain C pointers.
-//
-// Please note that ValuesIn copies the values from the containers
-// passed in and keeps them to generate tests in RUN_ALL_TESTS().
-//
-// Examples:
-//
-// This instantiates tests from test case StringTest
-// each with C-string values of "foo", "bar", and "baz":
-//
-// const char* strings[] = {"foo", "bar", "baz"};
-// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));
-//
-// This instantiates tests from test case StlStringTest
-// each with STL strings with values "a" and "b":
-//
-// ::std::vector< ::std::string> GetParameterStrings() {
-//   ::std::vector< ::std::string> v;
-//   v.push_back("a");
-//   v.push_back("b");
-//   return v;
-// }
-//
-// INSTANTIATE_TEST_CASE_P(CharSequence,
-//                         StlStringTest,
-//                         ValuesIn(GetParameterStrings()));
-//
-//
-// This will also instantiate tests from CharTest
-// each with parameter values 'a' and 'b':
-//
-// ::std::list<char> GetParameterChars() {
-//   ::std::list<char> list;
-//   list.push_back('a');
-//   list.push_back('b');
-//   return list;
-// }
-// ::std::list<char> l = GetParameterChars();
-// INSTANTIATE_TEST_CASE_P(CharSequence2,
-//                         CharTest,
-//                         ValuesIn(l.begin(), l.end()));
-//
-template <typename ForwardIterator>
-internal::ParamGenerator<
-  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
-ValuesIn(ForwardIterator begin, ForwardIterator end) {
-  typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
-      ::value_type ParamType;
-  return internal::ParamGenerator<ParamType>(
-      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
-}
-
-template <typename T, size_t N>
-internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
-  return ValuesIn(array, array + N);
-}
-
-template <class Container>
-internal::ParamGenerator<typename Container::value_type> ValuesIn(
-    const Container& container) {
-  return ValuesIn(container.begin(), container.end());
-}
-
-// Values() allows generating tests from explicitly specified list of
-// parameters.
-//
-// Synopsis:
-// Values(T v1, T v2, ..., T vN)
-//   - returns a generator producing sequences with elements v1, v2, ..., vN.
-//
-// For example, this instantiates tests from test case BarTest each
-// with values "one", "two", and "three":
-//
-// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));
-//
-// This instantiates tests from test case BazTest each with values 1, 2, 3.5.
-// The exact type of values will depend on the type of parameter in BazTest.
-//
-// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
-//
-// Currently, Values() supports from 1 to 50 parameters.
-//
-template <typename T1>
-internal::ValueArray1<T1> Values(T1 v1) {
-  return internal::ValueArray1<T1>(v1);
-}
-
-template <typename T1, typename T2>
-internal::ValueArray2<T1, T2> Values(T1 v1, T2 v2) {
-  return internal::ValueArray2<T1, T2>(v1, v2);
-}
-
-template <typename T1, typename T2, typename T3>
-internal::ValueArray3<T1, T2, T3> Values(T1 v1, T2 v2, T3 v3) {
-  return internal::ValueArray3<T1, T2, T3>(v1, v2, v3);
-}
-
-template <typename T1, typename T2, typename T3, typename T4>
-internal::ValueArray4<T1, T2, T3, T4> Values(T1 v1, T2 v2, T3 v3, T4 v4) {
-  return internal::ValueArray4<T1, T2, T3, T4>(v1, v2, v3, v4);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-internal::ValueArray5<T1, T2, T3, T4, T5> Values(T1 v1, T2 v2, T3 v3, T4 v4,
-    T5 v5) {
-  return internal::ValueArray5<T1, T2, T3, T4, T5>(v1, v2, v3, v4, v5);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-internal::ValueArray6<T1, T2, T3, T4, T5, T6> Values(T1 v1, T2 v2, T3 v3,
-    T4 v4, T5 v5, T6 v6) {
-  return internal::ValueArray6<T1, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7> Values(T1 v1, T2 v2, T3 v3,
-    T4 v4, T5 v5, T6 v6, T7 v7) {
-  return internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7>(v1, v2, v3, v4, v5,
-      v6, v7);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8> Values(T1 v1, T2 v2,
-    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
-  return internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8>(v1, v2, v3, v4,
-      v5, v6, v7, v8);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9> Values(T1 v1, T2 v2,
-    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
-  return internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1, v2, v3,
-      v4, v5, v6, v7, v8, v9);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Values(T1 v1,
-    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {
-  return internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(v1,
-      v2, v3, v4, v5, v6, v7, v8, v9, v10);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11>
-internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
-    T11> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11) {
-  return internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
-      T11>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12>
-internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-    T12> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12) {
-  return internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13>
-internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-    T13> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13) {
-  return internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14>
-internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) {
-  return internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
-      v14);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15>
-internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
-    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) {
-  return internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
-      v13, v14, v15);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16>
-internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16) {
-  return internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
-      v12, v13, v14, v15, v16);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17>
-internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17) {
-  return internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
-      v11, v12, v13, v14, v15, v16, v17);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18>
-internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
-    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18) {
-  return internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
-      v10, v11, v12, v13, v14, v15, v16, v17, v18);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19>
-internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
-    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
-    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) {
-  return internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19>(v1, v2, v3, v4, v5, v6, v7, v8,
-      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20>
-internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20> Values(T1 v1, T2 v2, T3 v3, T4 v4,
-    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
-    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) {
-  return internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20>(v1, v2, v3, v4, v5, v6, v7,
-      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21>
-internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21> Values(T1 v1, T2 v2, T3 v3, T4 v4,
-    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
-    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21) {
-  return internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(v1, v2, v3, v4, v5, v6,
-      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22>
-internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22> Values(T1 v1, T2 v2, T3 v3,
-    T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
-    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
-    T21 v21, T22 v22) {
-  return internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(v1, v2, v3, v4,
-      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
-      v20, v21, v22);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23>
-internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Values(T1 v1, T2 v2,
-    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
-    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
-    T21 v21, T22 v22, T23 v23) {
-  return internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>(v1, v2, v3,
-      v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
-      v20, v21, v22, v23);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24>
-internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Values(T1 v1, T2 v2,
-    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
-    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
-    T21 v21, T22 v22, T23 v23, T24 v24) {
-  return internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>(v1, v2,
-      v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
-      v19, v20, v21, v22, v23, v24);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25>
-internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Values(T1 v1,
-    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
-    T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,
-    T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25) {
-  return internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>(v1,
-      v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
-      v18, v19, v20, v21, v22, v23, v24, v25);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26>
-internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-    T26> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26) {
-  return internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
-      v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27>
-internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-    T27> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27) {
-  return internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
-      v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28>
-internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-    T28> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27, T28 v28) {
-  return internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
-      v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
-      v28);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29>
-internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27, T28 v28, T29 v29) {
-  return internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
-      v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
-      v27, v28, v29);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30>
-internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
-    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
-    T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
-    T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) {
-  return internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
-      v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
-      v26, v27, v28, v29, v30);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31>
-internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
-    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) {
-  return internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
-      v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
-      v25, v26, v27, v28, v29, v30, v31);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32>
-internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
-    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
-    T32 v32) {
-  return internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
-      v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
-      v24, v25, v26, v27, v28, v29, v30, v31, v32);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33>
-internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
-    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
-    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
-    T32 v32, T33 v33) {
-  return internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33>(v1, v2, v3, v4, v5, v6, v7, v8,
-      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
-      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34>
-internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
-    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
-    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,
-    T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,
-    T31 v31, T32 v32, T33 v33, T34 v34) {
-  return internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34>(v1, v2, v3, v4, v5, v6, v7,
-      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
-      v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35>
-internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35> Values(T1 v1, T2 v2, T3 v3, T4 v4,
-    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
-    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
-    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
-    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35) {
-  return internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35>(v1, v2, v3, v4, v5, v6,
-      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
-      v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36>
-internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36> Values(T1 v1, T2 v2, T3 v3, T4 v4,
-    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
-    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
-    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
-    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36) {
-  return internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36>(v1, v2, v3, v4,
-      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
-      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
-      v34, v35, v36);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37>
-internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37> Values(T1 v1, T2 v2, T3 v3,
-    T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
-    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
-    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
-    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
-    T37 v37) {
-  return internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37>(v1, v2, v3,
-      v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
-      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
-      v34, v35, v36, v37);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38>
-internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Values(T1 v1, T2 v2,
-    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
-    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
-    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
-    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
-    T37 v37, T38 v38) {
-  return internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38>(v1, v2,
-      v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
-      v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32,
-      v33, v34, v35, v36, v37, v38);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39>
-internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Values(T1 v1, T2 v2,
-    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
-    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
-    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
-    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
-    T37 v37, T38 v38, T39 v39) {
-  return internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39>(v1,
-      v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
-      v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
-      v32, v33, v34, v35, v36, v37, v38, v39);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40>
-internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Values(T1 v1,
-    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
-    T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,
-    T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27,
-    T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35,
-    T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) {
-  return internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
-      v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29,
-      v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41>
-internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-    T41> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41) {
-  return internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
-      v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28,
-      v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42>
-internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-    T42> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-    T42 v42) {
-  return internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
-      v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
-      v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41,
-      v42);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43>
-internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-    T43> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-    T42 v42, T43 v43) {
-  return internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
-      v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
-      v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40,
-      v41, v42, v43);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44>
-internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-    T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-    T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-    T42 v42, T43 v43, T44 v44) {
-  return internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
-      v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
-      v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39,
-      v40, v41, v42, v43, v44);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45>
-internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
-    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
-    T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
-    T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
-    T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
-    T41 v41, T42 v42, T43 v43, T44 v44, T45 v45) {
-  return internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44, T45>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
-      v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
-      v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38,
-      v39, v40, v41, v42, v43, v44, v45);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46>
-internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
-    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
-    T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
-    T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) {
-  return internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44, T45, T46>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
-      v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
-      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
-      v38, v39, v40, v41, v42, v43, v44, v45, v46);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47>
-internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46, T47> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
-    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
-    T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
-    T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) {
-  return internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44, T45, T46, T47>(v1, v2, v3, v4, v5, v6, v7, v8,
-      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
-      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
-      v38, v39, v40, v41, v42, v43, v44, v45, v46, v47);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48>
-internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46, T47, T48> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
-    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
-    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
-    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
-    T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
-    T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47,
-    T48 v48) {
-  return internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44, T45, T46, T47, T48>(v1, v2, v3, v4, v5, v6, v7,
-      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
-      v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36,
-      v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49>
-internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46, T47, T48, T49> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
-    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
-    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,
-    T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,
-    T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38,
-    T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46,
-    T47 v47, T48 v48, T49 v49) {
-  return internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44, T45, T46, T47, T48, T49>(v1, v2, v3, v4, v5, v6,
-      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
-      v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35,
-      v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49, typename T50>
-internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46, T47, T48, T49, T50> Values(T1 v1, T2 v2, T3 v3, T4 v4,
-    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
-    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
-    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
-    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37,
-    T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45,
-    T46 v46, T47 v47, T48 v48, T49 v49, T50 v50) {
-  return internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>(v1, v2, v3, v4,
-      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
-      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
-      v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
-      v48, v49, v50);
-}
-
-// Bool() allows generating tests with parameters in a set of (false, true).
-//
-// Synopsis:
-// Bool()
-//   - returns a generator producing sequences with elements {false, true}.
-//
-// It is useful when testing code that depends on Boolean flags. Combinations
-// of multiple flags can be tested when several Bool()'s are combined using
-// Combine() function.
-//
-// In the following example all tests in the test case FlagDependentTest
-// will be instantiated twice with parameters false and true.
-//
-// class FlagDependentTest : public testing::TestWithParam<bool> {
-//   virtual void SetUp() {
-//     external_flag = GetParam();
-//   }
-// }
-// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
-//
-inline internal::ParamGenerator<bool> Bool() {
-  return Values(false, true);
-}
-
-# if GTEST_HAS_COMBINE
-// Combine() allows the user to combine two or more sequences to produce
-// values of a Cartesian product of those sequences' elements.
-//
-// Synopsis:
-// Combine(gen1, gen2, ..., genN)
-//   - 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
-//     tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
-//     of elements from sequences produces by gen1, gen2, ..., genN.
-//
-// Combine can have up to 10 arguments. This number is currently limited
-// by the maximum number of elements in the tuple implementation used by Google
-// Test.
-//
-// Example:
-//
-// This will instantiate tests in test case 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<tuple<const char*, Color> > {...};
-//
-// TEST_P(AnimalTest, AnimalLooksNice) {...}
-//
-// INSTANTIATE_TEST_CASE_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<tuple<bool, bool> > {
-//   virtual void SetUp() {
-//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
-//     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_CASE_P(TwoBoolSequence, FlagDependentTest,
-//                         Combine(Bool(), Bool()));
-//
-template <typename Generator1, typename Generator2>
-internal::CartesianProductHolder2<Generator1, Generator2> Combine(
-    const Generator1& g1, const Generator2& g2) {
-  return internal::CartesianProductHolder2<Generator1, Generator2>(
-      g1, g2);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3>
-internal::CartesianProductHolder3<Generator1, Generator2, Generator3> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3) {
-  return internal::CartesianProductHolder3<Generator1, Generator2, Generator3>(
-      g1, g2, g3);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4>
-internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
-    Generator4> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4) {
-  return internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
-      Generator4>(
-      g1, g2, g3, g4);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4, typename Generator5>
-internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
-    Generator4, Generator5> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4, const Generator5& g5) {
-  return internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
-      Generator4, Generator5>(
-      g1, g2, g3, g4, g5);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4, typename Generator5, typename Generator6>
-internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
-    Generator4, Generator5, Generator6> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4, const Generator5& g5, const Generator6& g6) {
-  return internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
-      Generator4, Generator5, Generator6>(
-      g1, g2, g3, g4, g5, g6);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4, typename Generator5, typename Generator6,
-    typename Generator7>
-internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
-    Generator4, Generator5, Generator6, Generator7> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4, const Generator5& g5, const Generator6& g6,
-        const Generator7& g7) {
-  return internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
-      Generator4, Generator5, Generator6, Generator7>(
-      g1, g2, g3, g4, g5, g6, g7);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4, typename Generator5, typename Generator6,
-    typename Generator7, typename Generator8>
-internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
-    Generator4, Generator5, Generator6, Generator7, Generator8> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4, const Generator5& g5, const Generator6& g6,
-        const Generator7& g7, const Generator8& g8) {
-  return internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
-      Generator4, Generator5, Generator6, Generator7, Generator8>(
-      g1, g2, g3, g4, g5, g6, g7, g8);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4, typename Generator5, typename Generator6,
-    typename Generator7, typename Generator8, typename Generator9>
-internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
-    Generator4, Generator5, Generator6, Generator7, Generator8,
-    Generator9> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4, const Generator5& g5, const Generator6& g6,
-        const Generator7& g7, const Generator8& g8, const Generator9& g9) {
-  return internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
-      Generator4, Generator5, Generator6, Generator7, Generator8, Generator9>(
-      g1, g2, g3, g4, g5, g6, g7, g8, g9);
-}
-
-template <typename Generator1, typename Generator2, typename Generator3,
-    typename Generator4, typename Generator5, typename Generator6,
-    typename Generator7, typename Generator8, typename Generator9,
-    typename Generator10>
-internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
-    Generator4, Generator5, Generator6, Generator7, Generator8, Generator9,
-    Generator10> Combine(
-    const Generator1& g1, const Generator2& g2, const Generator3& g3,
-        const Generator4& g4, const Generator5& g5, const Generator6& g6,
-        const Generator7& g7, const Generator8& g8, const Generator9& g9,
-        const Generator10& g10) {
-  return internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
-      Generator4, Generator5, Generator6, Generator7, Generator8, Generator9,
-      Generator10>(
-      g1, g2, g3, g4, g5, g6, g7, g8, g9, g10);
-}
-# endif  // GTEST_HAS_COMBINE
-
-
-
-# define TEST_P(test_case_name, test_name) \
-  class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
-      : public test_case_name { \
-   public: \
-    GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
-    virtual void TestBody(); \
-   private: \
-    static int AddToRegistry() { \
-      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
-          GetTestCasePatternHolder<test_case_name>(\
-              #test_case_name, \
-              ::testing::internal::CodeLocation(\
-                  __FILE__, __LINE__))->AddTestPattern(\
-                      #test_case_name, \
-                      #test_name, \
-                      new ::testing::internal::TestMetaFactory< \
-                          GTEST_TEST_CLASS_NAME_(\
-                              test_case_name, test_name)>()); \
-      return 0; \
-    } \
-    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(\
-        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
-  }; \
-  int GTEST_TEST_CLASS_NAME_(test_case_name, \
-                             test_name)::gtest_registering_dummy_ = \
-      GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
-  void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
-
-// The optional last argument to INSTANTIATE_TEST_CASE_P allows the user
-// to specify a function or functor that generates custom test name suffixes
-// based on the test parameters. The function should accept one argument of
-// type testing::TestParamInfo<class ParamType>, and return std::string.
-//
-// testing::PrintToStringParamName is a builtin test suffix generator that
-// returns the value of testing::PrintToString(GetParam()). It does not work
-// for std::string or C strings.
-//
-// Note: test names must be non-empty, unique, and may only contain ASCII
-// alphanumeric characters or underscore.
-
-# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, ...) \
-  ::testing::internal::ParamGenerator<test_case_name::ParamType> \
-      gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
-  ::std::string gtest_##prefix##test_case_name##_EvalGenerateName_( \
-      const ::testing::TestParamInfo<test_case_name::ParamType>& info) { \
-    return ::testing::internal::GetParamNameGen<test_case_name::ParamType> \
-        (__VA_ARGS__)(info); \
-  } \
-  int gtest_##prefix##test_case_name##_dummy_ GTEST_ATTRIBUTE_UNUSED_ = \
-      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
-          GetTestCasePatternHolder<test_case_name>(\
-              #test_case_name, \
-              ::testing::internal::CodeLocation(\
-                  __FILE__, __LINE__))->AddTestCaseInstantiation(\
-                      #prefix, \
-                      &gtest_##prefix##test_case_name##_EvalGenerator_, \
-                      &gtest_##prefix##test_case_name##_EvalGenerateName_, \
-                      __FILE__, __LINE__)
-
-}  // namespace testing
-
-#endif  // GTEST_HAS_PARAM_TEST
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h.pump b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h.pump
deleted file mode 100644
index 3078d6d2..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-param-test.h.pump
+++ /dev/null
@@ -1,510 +0,0 @@
-$$ -*- mode: c++; -*-
-$var n = 50  $$ Maximum length of Values arguments we want to support.
-$var maxtuple = 10  $$ Maximum number of Combine arguments we want to support.
-// 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.
-//
-// Authors: vladl@google.com (Vlad Losev)
-//
-// Macros and functions for implementing parameterized tests
-// in Google C++ Testing Framework (Google Test)
-//
-// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
-//
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
-#define GTEST_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.
-//
-// Here is how you use value-parameterized tests:
-
-#if 0
-
-// To write value-parameterized tests, first you should define a fixture
-// class. It is usually derived from testing::TestWithParam<T> (see below for
-// another inheritance scheme that's sometimes useful in more complicated
-// class hierarchies), where the type of your parameter values.
-// TestWithParam<T> is itself derived from testing::Test. T can be any
-// copyable type. If it's a raw pointer, you are responsible for managing the
-// lifespan of the pointed values.
-
-class FooTest : public ::testing::TestWithParam<const char*> {
-  // You can implement all the usual class fixture members here.
-};
-
-// Then, use the TEST_P macro to define as many parameterized tests
-// for this fixture as you want. The _P suffix is for "parameterized"
-// or "pattern", whichever you prefer to think.
-
-TEST_P(FooTest, DoesBlah) {
-  // Inside a test, access the test parameter with the GetParam() method
-  // of the TestWithParam<T> class:
-  EXPECT_TRUE(foo.Blah(GetParam()));
-  ...
-}
-
-TEST_P(FooTest, HasBlahBlah) {
-  ...
-}
-
-// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
-// case with 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
-// are all in the testing namespace:
-//
-//
-//  Range(begin, end [, step]) - Yields values {begin, begin+step,
-//                               begin+step+step, ...}. The values do not
-//                               include end. step defaults to 1.
-//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
-//  ValuesIn(container)        - Yields values from a C-style array, an STL
-//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
-//  Bool()                     - Yields sequence {false, true}.
-//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
-//                               for the math savvy) of the values generated
-//                               by the N generators.
-//
-// 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 case
-// each with parameter values "meeny", "miny", and "moe".
-
-INSTANTIATE_TEST_CASE_P(InstantiationName,
-                        FooTest,
-                        Values("meeny", "miny", "moe"));
-
-// To distinguish different instances of the pattern, (yes, you
-// can instantiate it more then once) the first argument to the
-// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
-// actual test case name. Remember to pick unique prefixes for different
-// instantiations. The tests from the instantiation above will have
-// these names:
-//
-//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
-//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
-//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
-//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
-//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
-//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
-//
-// You can use these names in --gtest_filter.
-//
-// This statement will instantiate all tests from FooTest again, each
-// with parameter values "cat" and "dog":
-
-const char* pets[] = {"cat", "dog"};
-INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
-
-// The tests from the instantiation above will have these names:
-//
-//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
-//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
-//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
-//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
-//
-// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
-// in the given test case, whether their definitions come before or
-// AFTER the INSTANTIATE_TEST_CASE_P statement.
-//
-// Please also note that generator expressions (including parameters to the
-// generators) are evaluated in InitGoogleTest(), after main() has started.
-// This allows the user on one hand, to adjust generator parameters in order
-// to dynamically determine a set of tests to run and on the other hand,
-// give the user a chance to inspect the generated tests with Google Test
-// reflection API before RUN_ALL_TESTS() is executed.
-//
-// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
-// for more examples.
-//
-// In the future, we plan to publish the API for defining new parameter
-// generators. But for now this interface remains part of the internal
-// implementation and is subject to change.
-//
-//
-// A parameterized test fixture must be derived from testing::Test and from
-// testing::WithParamInterface<T>, where T is the type of the parameter
-// values. Inheriting from TestWithParam<T> satisfies that requirement because
-// TestWithParam<T> inherits from both Test and WithParamInterface. In more
-// complicated hierarchies, however, it is occasionally useful to inherit
-// separately from Test and WithParamInterface. For example:
-
-class BaseTest : public ::testing::Test {
-  // You can inherit all the usual members for a non-parameterized test
-  // fixture here.
-};
-
-class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
-  // The usual test fixture members go here too.
-};
-
-TEST_F(BaseTest, HasFoo) {
-  // This is an ordinary non-parameterized test.
-}
-
-TEST_P(DerivedTest, DoesBlah) {
-  // GetParam works just the same here as if you inherit from TestWithParam.
-  EXPECT_TRUE(foo.Blah(GetParam()));
-}
-
-#endif  // 0
-
-#include "gtest/internal/gtest-port.h"
-
-#if !GTEST_OS_SYMBIAN
-# include <utility>
-#endif
-
-// scripts/fuse_gtest.py depends on gtest's own header being #included
-// *unconditionally*.  Therefore these #includes cannot be moved
-// inside #if GTEST_HAS_PARAM_TEST.
-#include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-param-util.h"
-#include "gtest/internal/gtest-param-util-generated.h"
-
-#if GTEST_HAS_PARAM_TEST
-
-namespace testing {
-
-// Functions producing parameter generators.
-//
-// Google Test uses these generators to produce parameters for value-
-// parameterized tests. When a parameterized test case 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 case FooTest are instantiated
-// each three times with parameter values 3, 5, and 8:
-//
-// class FooTest : public TestWithParam<int> { ... };
-//
-// TEST_P(FooTest, TestThis) {
-// }
-// TEST_P(FooTest, TestThat) {
-// }
-// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
-//
-
-// Range() returns generators providing sequences of values in a range.
-//
-// Synopsis:
-// Range(start, end)
-//   - returns a generator producing a sequence of values {start, start+1,
-//     start+2, ..., }.
-// Range(start, end, step)
-//   - returns a generator producing a sequence of values {start, start+step,
-//     start+step+step, ..., }.
-// Notes:
-//   * The generated sequences never include end. For example, Range(1, 5)
-//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
-//     returns a generator producing {1, 3, 5, 7}.
-//   * start and end must have the same type. That type may be any integral or
-//     floating-point type or a user defined type satisfying these conditions:
-//     * It must be assignable (have operator=() defined).
-//     * It must have operator+() (operator+(int-compatible type) for
-//       two-operand version).
-//     * It must have operator<() defined.
-//     Elements in the resulting sequences will also have that type.
-//   * Condition start < end must be satisfied in order for resulting sequences
-//     to contain any elements.
-//
-template <typename T, typename IncrementT>
-internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
-  return internal::ParamGenerator<T>(
-      new internal::RangeGenerator<T, IncrementT>(start, end, step));
-}
-
-template <typename T>
-internal::ParamGenerator<T> Range(T start, T end) {
-  return Range(start, end, 1);
-}
-
-// ValuesIn() function allows generation of tests with parameters coming from
-// a container.
-//
-// Synopsis:
-// ValuesIn(const T (&array)[N])
-//   - returns a generator producing sequences with elements from
-//     a C-style array.
-// ValuesIn(const Container& container)
-//   - returns a generator producing sequences with elements from
-//     an STL-style container.
-// ValuesIn(Iterator begin, Iterator end)
-//   - returns a generator producing sequences with elements from
-//     a range [begin, end) defined by a pair of STL-style iterators. These
-//     iterators can also be plain C pointers.
-//
-// Please note that ValuesIn copies the values from the containers
-// passed in and keeps them to generate tests in RUN_ALL_TESTS().
-//
-// Examples:
-//
-// This instantiates tests from test case StringTest
-// each with C-string values of "foo", "bar", and "baz":
-//
-// const char* strings[] = {"foo", "bar", "baz"};
-// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));
-//
-// This instantiates tests from test case StlStringTest
-// each with STL strings with values "a" and "b":
-//
-// ::std::vector< ::std::string> GetParameterStrings() {
-//   ::std::vector< ::std::string> v;
-//   v.push_back("a");
-//   v.push_back("b");
-//   return v;
-// }
-//
-// INSTANTIATE_TEST_CASE_P(CharSequence,
-//                         StlStringTest,
-//                         ValuesIn(GetParameterStrings()));
-//
-//
-// This will also instantiate tests from CharTest
-// each with parameter values 'a' and 'b':
-//
-// ::std::list<char> GetParameterChars() {
-//   ::std::list<char> list;
-//   list.push_back('a');
-//   list.push_back('b');
-//   return list;
-// }
-// ::std::list<char> l = GetParameterChars();
-// INSTANTIATE_TEST_CASE_P(CharSequence2,
-//                         CharTest,
-//                         ValuesIn(l.begin(), l.end()));
-//
-template <typename ForwardIterator>
-internal::ParamGenerator<
-  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
-ValuesIn(ForwardIterator begin, ForwardIterator end) {
-  typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
-      ::value_type ParamType;
-  return internal::ParamGenerator<ParamType>(
-      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
-}
-
-template <typename T, size_t N>
-internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
-  return ValuesIn(array, array + N);
-}
-
-template <class Container>
-internal::ParamGenerator<typename Container::value_type> ValuesIn(
-    const Container& container) {
-  return ValuesIn(container.begin(), container.end());
-}
-
-// Values() allows generating tests from explicitly specified list of
-// parameters.
-//
-// Synopsis:
-// Values(T v1, T v2, ..., T vN)
-//   - returns a generator producing sequences with elements v1, v2, ..., vN.
-//
-// For example, this instantiates tests from test case BarTest each
-// with values "one", "two", and "three":
-//
-// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));
-//
-// This instantiates tests from test case BazTest each with values 1, 2, 3.5.
-// The exact type of values will depend on the type of parameter in BazTest.
-//
-// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
-//
-// Currently, Values() supports from 1 to $n parameters.
-//
-$range i 1..n
-$for i [[
-$range j 1..i
-
-template <$for j, [[typename T$j]]>
-internal::ValueArray$i<$for j, [[T$j]]> Values($for j, [[T$j v$j]]) {
-  return internal::ValueArray$i<$for j, [[T$j]]>($for j, [[v$j]]);
-}
-
-]]
-
-// Bool() allows generating tests with parameters in a set of (false, true).
-//
-// Synopsis:
-// Bool()
-//   - returns a generator producing sequences with elements {false, true}.
-//
-// It is useful when testing code that depends on Boolean flags. Combinations
-// of multiple flags can be tested when several Bool()'s are combined using
-// Combine() function.
-//
-// In the following example all tests in the test case FlagDependentTest
-// will be instantiated twice with parameters false and true.
-//
-// class FlagDependentTest : public testing::TestWithParam<bool> {
-//   virtual void SetUp() {
-//     external_flag = GetParam();
-//   }
-// }
-// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
-//
-inline internal::ParamGenerator<bool> Bool() {
-  return Values(false, true);
-}
-
-# if GTEST_HAS_COMBINE
-// Combine() allows the user to combine two or more sequences to produce
-// values of a Cartesian product of those sequences' elements.
-//
-// Synopsis:
-// Combine(gen1, gen2, ..., genN)
-//   - 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
-//     tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
-//     of elements from sequences produces by gen1, gen2, ..., genN.
-//
-// Combine can have up to $maxtuple arguments. This number is currently limited
-// by the maximum number of elements in the tuple implementation used by Google
-// Test.
-//
-// Example:
-//
-// This will instantiate tests in test case 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<tuple<const char*, Color> > {...};
-//
-// TEST_P(AnimalTest, AnimalLooksNice) {...}
-//
-// INSTANTIATE_TEST_CASE_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<tuple<bool, bool> > {
-//   virtual void SetUp() {
-//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
-//     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_CASE_P(TwoBoolSequence, FlagDependentTest,
-//                         Combine(Bool(), Bool()));
-//
-$range i 2..maxtuple
-$for i [[
-$range j 1..i
-
-template <$for j, [[typename Generator$j]]>
-internal::CartesianProductHolder$i<$for j, [[Generator$j]]> Combine(
-    $for j, [[const Generator$j& g$j]]) {
-  return internal::CartesianProductHolder$i<$for j, [[Generator$j]]>(
-      $for j, [[g$j]]);
-}
-
-]]
-# endif  // GTEST_HAS_COMBINE
-
-
-
-# define TEST_P(test_case_name, test_name) \
-  class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
-      : public test_case_name { \
-   public: \
-    GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
-    virtual void TestBody(); \
-   private: \
-    static int AddToRegistry() { \
-      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
-          GetTestCasePatternHolder<test_case_name>(\
-              #test_case_name, \
-              ::testing::internal::CodeLocation(\
-                  __FILE__, __LINE__))->AddTestPattern(\
-                      #test_case_name, \
-                      #test_name, \
-                      new ::testing::internal::TestMetaFactory< \
-                          GTEST_TEST_CLASS_NAME_(\
-                              test_case_name, test_name)>()); \
-      return 0; \
-    } \
-    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(\
-        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
-  }; \
-  int GTEST_TEST_CLASS_NAME_(test_case_name, \
-                             test_name)::gtest_registering_dummy_ = \
-      GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
-  void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
-
-// The optional last argument to INSTANTIATE_TEST_CASE_P allows the user
-// to specify a function or functor that generates custom test name suffixes
-// based on the test parameters. The function should accept one argument of
-// type testing::TestParamInfo<class ParamType>, and return std::string.
-//
-// testing::PrintToStringParamName is a builtin test suffix generator that
-// returns the value of testing::PrintToString(GetParam()).
-//
-// 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 INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, ...) \
-  ::testing::internal::ParamGenerator<test_case_name::ParamType> \
-      gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
-  ::std::string gtest_##prefix##test_case_name##_EvalGenerateName_( \
-      const ::testing::TestParamInfo<test_case_name::ParamType>& info) { \
-    return ::testing::internal::GetParamNameGen<test_case_name::ParamType> \
-        (__VA_ARGS__)(info); \
-  } \
-  int gtest_##prefix##test_case_name##_dummy_ GTEST_ATTRIBUTE_UNUSED_ = \
-      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
-          GetTestCasePatternHolder<test_case_name>(\
-              #test_case_name, \
-              ::testing::internal::CodeLocation(\
-                  __FILE__, __LINE__))->AddTestCaseInstantiation(\
-                      #prefix, \
-                      &gtest_##prefix##test_case_name##_EvalGenerator_, \
-                      &gtest_##prefix##test_case_name##_EvalGenerateName_, \
-                      __FILE__, __LINE__)
-
-}  // namespace testing
-
-#endif  // GTEST_HAS_PARAM_TEST
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-printers.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-printers.h
deleted file mode 100644
index 8a33164c..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-printers.h
+++ /dev/null
@@ -1,993 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Test - The Google C++ Testing Framework
-//
-// This file implements a universal value printer that can print a
-// value of any type T:
-//
-//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
-//
-// A user can teach this function how to print a class type T by
-// defining either operator<<() or PrintTo() in the namespace that
-// defines T.  More specifically, the FIRST defined function in the
-// following list will be used (assuming T is defined in namespace
-// foo):
-//
-//   1. foo::PrintTo(const T&, ostream*)
-//   2. operator<<(ostream&, const T&) defined in either foo or the
-//      global namespace.
-//
-// 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.
-//
-// To aid debugging: when T is a reference type, the address of the
-// value is also printed; when T is a (const) char pointer, both the
-// pointer value and the NUL-terminated string it points to are
-// printed.
-//
-// We also provide some convenient wrappers:
-//
-//   // Prints a value to a string.  For a (const or not) char
-//   // pointer, the NUL-terminated string (but not the pointer) is
-//   // printed.
-//   std::string ::testing::PrintToString(const T& value);
-//
-//   // Prints a value tersely: for a reference type, the referenced
-//   // value (but not the address) is printed; for a (const or not) char
-//   // pointer, the NUL-terminated string (but not the pointer) is
-//   // printed.
-//   void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
-//
-//   // Prints value using the type inferred by the compiler.  The difference
-//   // from UniversalTersePrint() is that this function prints both the
-//   // pointer and the NUL-terminated string for a (const or not) char pointer.
-//   void ::testing::internal::UniversalPrint(const T& value, ostream*);
-//
-//   // Prints the fields of a tuple tersely to a string vector, one
-//   // element for each field. Tuple support must be enabled in
-//   // gtest-port.h.
-//   std::vector<string> UniversalTersePrintTupleFieldsToStrings(
-//       const Tuple& value);
-//
-// Known limitation:
-//
-// The print primitives print the elements of an STL-style container
-// using the compiler-inferred type of *iter where iter is a
-// const_iterator of the container.  When const_iterator is an input
-// iterator but not a forward iterator, this inferred type may not
-// match value_type, and the print output may be incorrect.  In
-// practice, this is rarely a problem as for most containers
-// const_iterator is a forward iterator.  We'll fix this if there's an
-// actual need for it.  Note that this fix cannot rely on value_type
-// being defined as many user-defined container types don't have
-// value_type.
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
-#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
-
-#include <ostream>  // NOLINT
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-#include "gtest/internal/gtest-port.h"
-#include "gtest/internal/gtest-internal.h"
-
-#if GTEST_HAS_STD_TUPLE_
-# include <tuple>
-#endif
-
-namespace testing {
-
-// Definitions in the 'internal' and 'internal2' name spaces are
-// subject to change without notice.  DO NOT USE THEM IN USER CODE!
-namespace internal2 {
-
-// 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);
-
-// For selecting which printer to use when a given type has neither <<
-// nor PrintTo().
-enum TypeKind {
-  kProtobuf,              // a protobuf type
-  kConvertibleToInteger,  // a type implicitly convertible to BiggestInt
-                          // (e.g. a named or unnamed enum type)
-  kOtherType              // anything else
-};
-
-// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
-// by the universal printer to print a value of type T when neither
-// operator<< nor PrintTo() is defined for T, where kTypeKind is the
-// "kind" of T as defined by enum TypeKind.
-template <typename T, TypeKind kTypeKind>
-class TypeWithoutFormatter {
- public:
-  // This default version is called when kTypeKind is kOtherType.
-  static void PrintValue(const T& value, ::std::ostream* os) {
-    PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value),
-                         sizeof(value), os);
-  }
-};
-
-// 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.
-const size_t kProtobufOneLinerMaxLength = 50;
-
-template <typename T>
-class TypeWithoutFormatter<T, kProtobuf> {
- public:
-  static void PrintValue(const T& value, ::std::ostream* os) {
-    const ::testing::internal::string short_str = value.ShortDebugString();
-    const ::testing::internal::string pretty_str =
-        short_str.length() <= kProtobufOneLinerMaxLength ?
-        short_str : ("\n" + value.DebugString());
-    *os << ("<" + pretty_str + ">");
-  }
-};
-
-template <typename T>
-class TypeWithoutFormatter<T, kConvertibleToInteger> {
- public:
-  // Since T has no << operator or PrintTo() but can be implicitly
-  // converted to BiggestInt, we print it as a BiggestInt.
-  //
-  // Most likely T is an enum type (either named or unnamed), in which
-  // 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(const T& value, ::std::ostream* os) {
-    const internal::BiggestInt kBigInt = value;
-    *os << kBigInt;
-  }
-};
-
-// Prints the given value to the given ostream.  If the value is a
-// protocol message, its debug string is printed; if it's an enum or
-// of a type implicitly convertible to BiggestInt, it's printed as an
-// integer; otherwise the bytes in the value are printed.  This is
-// what UniversalPrinter<T>::Print() does when it knows nothing about
-// type T and T has neither << operator nor PrintTo().
-//
-// A user can override this behavior for a class type Foo by defining
-// a << operator in the namespace where Foo is defined.
-//
-// We put this operator in namespace 'internal2' instead of 'internal'
-// to simplify the implementation, as much code in 'internal' needs to
-// use << in STL, which would conflict with our own << were it defined
-// in 'internal'.
-//
-// Note that this operator<< takes a generic std::basic_ostream<Char,
-// CharTraits> type instead of the more restricted std::ostream.  If
-// we define it to take an std::ostream instead, we'll get an
-// "ambiguous overloads" compiler error when trying to print a type
-// Foo that supports streaming to std::basic_ostream<Char,
-// CharTraits>, as the compiler cannot tell whether
-// operator<<(std::ostream&, const T&) or
-// operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more
-// specific.
-template <typename Char, typename CharTraits, typename T>
-::std::basic_ostream<Char, CharTraits>& operator<<(
-    ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
-  TypeWithoutFormatter<T,
-      (internal::IsAProtocolMessage<T>::value ? kProtobuf :
-       internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
-       kConvertibleToInteger : kOtherType)>::PrintValue(x, &os);
-  return os;
-}
-
-}  // namespace internal2
-}  // namespace testing
-
-// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
-// magic needed for implementing UniversalPrinter won't work.
-namespace testing_internal {
-
-// Used to print a value that is not an STL-style container when the
-// user doesn't define PrintTo() for it.
-template <typename T>
-void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
-  // With the following statement, during unqualified name lookup,
-  // testing::internal2::operator<< appears as if it was declared in
-  // the nearest enclosing namespace that contains both
-  // ::testing_internal and ::testing::internal2, i.e. the global
-  // namespace.  For more details, refer to the C++ Standard section
-  // 7.3.4-1 [namespace.udir].  This allows us to fall back onto
-  // testing::internal2::operator<< in case T doesn't come with a <<
-  // operator.
-  //
-  // We cannot write 'using ::testing::internal2::operator<<;', which
-  // gcc 3.3 fails to compile due to a compiler bug.
-  using namespace ::testing::internal2;  // NOLINT
-
-  // Assuming T is defined in namespace foo, in the next statement,
-  // the compiler will consider all of:
-  //
-  //   1. foo::operator<< (thanks to Koenig look-up),
-  //   2. ::operator<< (as the current namespace is enclosed in ::),
-  //   3. testing::internal2::operator<< (thanks to the using statement above).
-  //
-  // The operator<< whose type matches T best will be picked.
-  //
-  // We deliberately allow #2 to be a candidate, as sometimes it's
-  // impossible to define #1 (e.g. when foo is ::std, defining
-  // anything in it is undefined behavior unless you are a compiler
-  // vendor.).
-  *os << value;
-}
-
-}  // namespace testing_internal
-
-namespace testing {
-namespace internal {
-
-// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
-// value of type ToPrint that is an operand of a comparison assertion
-// (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
-// the comparison, and is used to help determine the best way to
-// format the value.  In particular, when the value is a C string
-// (char pointer) and the other operand is an STL string object, we
-// want to format the C string as a string, since we know it is
-// compared by value with the string object.  If the value is a char
-// pointer but the other operand is not an STL string object, we don't
-// know whether the pointer is supposed to point to a NUL-terminated
-// string, and thus want to print it as a pointer to be safe.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-
-// The default case.
-template <typename ToPrint, typename OtherOperand>
-class FormatForComparison {
- public:
-  static ::std::string Format(const ToPrint& value) {
-    return ::testing::PrintToString(value);
-  }
-};
-
-// Array.
-template <typename ToPrint, size_t N, typename OtherOperand>
-class FormatForComparison<ToPrint[N], OtherOperand> {
- public:
-  static ::std::string Format(const ToPrint* value) {
-    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
-  }
-};
-
-// By default, print C string as pointers to be safe, as we don't know
-// whether they actually point to a NUL-terminated string.
-
-#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
-  template <typename OtherOperand>                                      \
-  class FormatForComparison<CharType*, OtherOperand> {                  \
-   public:                                                              \
-    static ::std::string Format(CharType* value) {                      \
-      return ::testing::PrintToString(static_cast<const void*>(value)); \
-    }                                                                   \
-  }
-
-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);
-
-#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
-
-// If a C string is compared with an STL string object, we know it's meant
-// to point to a NUL-terminated string, and thus can print it as a string.
-
-#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
-  template <>                                                           \
-  class FormatForComparison<CharType*, OtherStringType> {               \
-   public:                                                              \
-    static ::std::string Format(CharType* value) {                      \
-      return ::testing::PrintToString(value);                           \
-    }                                                                   \
-  }
-
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
-
-#if GTEST_HAS_GLOBAL_STRING
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
-#endif
-
-#if GTEST_HAS_GLOBAL_WSTRING
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring);
-#endif
-
-#if GTEST_HAS_STD_WSTRING
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
-#endif
-
-#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
-
-// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
-// operand to be used in a failure message.  The type (but not value)
-// of the other operand may affect the format.  This allows us to
-// print a char* as a raw pointer when it is compared against another
-// char* or void*, and print it as a C string when it is compared
-// against an std::string object, for example.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-template <typename T1, typename T2>
-std::string FormatForComparisonFailureMessage(
-    const T1& value, const T2& /* other_operand */) {
-  return FormatForComparison<T1, T2>::Format(value);
-}
-
-// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
-// value to the given ostream.  The caller must ensure that
-// 'ostream_ptr' is not NULL, or the behavior is undefined.
-//
-// We define UniversalPrinter as a class template (as opposed to a
-// function template), as we need to partially specialize it for
-// reference types, which cannot be done with function templates.
-template <typename T>
-class UniversalPrinter;
-
-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.
-template <typename C>
-void DefaultPrintTo(IsContainer /* dummy */,
-                    false_type /* is not a pointer */,
-                    const C& container, ::std::ostream* os) {
-  const size_t kMaxCount = 32;  // The maximum number of elements to print.
-  *os << '{';
-  size_t count = 0;
-  for (typename C::const_iterator it = container.begin();
-       it != container.end(); ++it, ++count) {
-    if (count > 0) {
-      *os << ',';
-      if (count == kMaxCount) {  // Enough has been printed.
-        *os << " ...";
-        break;
-      }
-    }
-    *os << ' ';
-    // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
-    // handle *it being a native array.
-    internal::UniversalPrint(*it, os);
-  }
-
-  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.)
-template <typename T>
-void DefaultPrintTo(IsNotContainer /* dummy */,
-                    true_type /* is a pointer */,
-                    T* p, ::std::ostream* os) {
-  if (p == NULL) {
-    *os << "NULL";
-  } else {
-    // C++ doesn't allow casting from a function pointer to any object
-    // pointer.
-    //
-    // IsTrue() silences warnings: "Condition is always true",
-    // "unreachable code".
-    if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
-      // 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;
-    } 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*.  However, we cannot cast it to const void* directly,
-      // even using reinterpret_cast, as earlier versions of gcc
-      // (e.g. 3.4.5) cannot compile the cast when p is a function
-      // pointer.  Casting to UInt64 first solves the problem.
-      *os << reinterpret_cast<const void*>(
-          reinterpret_cast<internal::UInt64>(p));
-    }
-  }
-}
-
-// Used to print a non-container, non-pointer value when the user
-// doesn't define PrintTo() for it.
-template <typename T>
-void DefaultPrintTo(IsNotContainer /* dummy */,
-                    false_type /* is not a pointer */,
-                    const T& value, ::std::ostream* os) {
-  ::testing_internal::DefaultPrintNonContainerTo(value, os);
-}
-
-// Prints the given value using the << operator if it has one;
-// otherwise prints the bytes in it.  This is what
-// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
-// or overloaded for type T.
-//
-// A user can override this behavior for a class type Foo by defining
-// an overload of PrintTo() in the namespace where Foo is defined.  We
-// give the user this option as sometimes defining a << operator for
-// Foo is not desirable (e.g. the coding style may prevent doing it,
-// or there is already a << operator but it doesn't do what the user
-// wants).
-template <typename T>
-void PrintTo(const T& value, ::std::ostream* os) {
-  // DefaultPrintTo() is overloaded.  The type of its first two
-  // arguments determine which version will be picked.  If T is an
-  // STL-style container, the version for container will be called; if
-  // T is a pointer, the pointer version will be called; otherwise the
-  // generic version will be called.
-  //
-  // Note that we check for container types here, prior to we check
-  // for protocol message types in our operator<<.  The rationale is:
-  //
-  // For protocol messages, we want to give people a chance to
-  // override Google Mock's format by defining a PrintTo() or
-  // operator<<.  For STL containers, other formats can be
-  // incompatible with Google Mock's format for the container
-  // elements; therefore we check for container types here to ensure
-  // that our format is used.
-  //
-  // The second argument of DefaultPrintTo() is needed to bypass a bug
-  // in Symbian's C++ compiler that prevents it from picking the right
-  // overload between:
-  //
-  //   PrintTo(const T& x, ...);
-  //   PrintTo(T* x, ...);
-  DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
-}
-
-// The following list of PrintTo() overloads tells
-// UniversalPrinter<T>::Print() how to print standard types (built-in
-// types, strings, plain arrays, and pointers).
-
-// Overloads for various char types.
-GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
-GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
-inline void PrintTo(char c, ::std::ostream* os) {
-  // When printing a plain char, we always treat it as unsigned.  This
-  // way, the output won't be affected by whether the compiler thinks
-  // char is signed or not.
-  PrintTo(static_cast<unsigned char>(c), os);
-}
-
-// Overloads for other simple built-in types.
-inline void PrintTo(bool x, ::std::ostream* os) {
-  *os << (x ? "true" : "false");
-}
-
-// Overload for wchar_t type.
-// Prints a wchar_t as a symbol if it is printable or as its internal
-// code otherwise and also as its decimal code (except for L'\0').
-// The L'\0' char is printed as "L'\\0'". The decimal code is printed
-// as signed integer when wchar_t is implemented by the compiler
-// as a signed type and is printed as an unsigned integer when wchar_t
-// is implemented as an unsigned type.
-GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
-
-// Overloads for C strings.
-GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
-inline void PrintTo(char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const char*>(s), os);
-}
-
-// signed/unsigned char is often used for representing binary data, so
-// we print pointers to it as void* to be safe.
-inline void PrintTo(const signed char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const void*>(s), os);
-}
-inline void PrintTo(signed char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const void*>(s), os);
-}
-inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const void*>(s), os);
-}
-inline void PrintTo(unsigned char* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const void*>(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
-// type.  When wchar_t is a typedef, defining an overload for const
-// wchar_t* would cause unsigned short* be printed as a wide string,
-// possibly causing invalid memory accesses.
-#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
-// Overloads for wide C strings
-GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
-inline void PrintTo(wchar_t* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const wchar_t*>(s), os);
-}
-#endif
-
-// Overload for C arrays.  Multi-dimensional arrays are printed
-// properly.
-
-// Prints the given number of elements in an array, without printing
-// the curly braces.
-template <typename T>
-void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
-  UniversalPrint(a[0], os);
-  for (size_t i = 1; i != count; i++) {
-    *os << ", ";
-    UniversalPrint(a[i], os);
-  }
-}
-
-// Overloads for ::string and ::std::string.
-#if GTEST_HAS_GLOBAL_STRING
-GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os);
-inline void PrintTo(const ::string& s, ::std::ostream* os) {
-  PrintStringTo(s, os);
-}
-#endif  // GTEST_HAS_GLOBAL_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 ::wstring and ::std::wstring.
-#if GTEST_HAS_GLOBAL_WSTRING
-GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os);
-inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
-  PrintWideStringTo(s, os);
-}
-#endif  // GTEST_HAS_GLOBAL_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) {
-  PrintWideStringTo(s, os);
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
-// Helper function for printing a tuple.  T must be instantiated with
-// a tuple type.
-template <typename T>
-void PrintTupleTo(const T& t, ::std::ostream* os);
-#endif  // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
-
-#if GTEST_HAS_TR1_TUPLE
-// Overload for ::std::tr1::tuple.  Needed for printing function arguments,
-// which are packed as tuples.
-
-// Overloaded PrintTo() for tuples of various arities.  We support
-// tuples of up-to 10 fields.  The following implementation works
-// regardless of whether tr1::tuple is implemented using the
-// non-standard variadic template feature or not.
-
-inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1>
-void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2>
-void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
-             ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-          typename T6>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t,
-             ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-          typename T6, typename T7>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
-             ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-          typename T6, typename T7, typename T8>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
-             ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-          typename T6, typename T7, typename T8, typename T9>
-void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t,
-             ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-          typename T6, typename T7, typename T8, typename T9, typename T10>
-void PrintTo(
-    const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t,
-    ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-#endif  // GTEST_HAS_TR1_TUPLE
-
-#if GTEST_HAS_STD_TUPLE_
-template <typename... Types>
-void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
-  PrintTupleTo(t, os);
-}
-#endif  // GTEST_HAS_STD_TUPLE_
-
-// Overload for std::pair.
-template <typename T1, typename T2>
-void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
-  *os << '(';
-  // We cannot use UniversalPrint(value.first, os) here, as T1 may be
-  // a reference type.  The same for printing value.second.
-  UniversalPrinter<T1>::Print(value.first, os);
-  *os << ", ";
-  UniversalPrinter<T2>::Print(value.second, os);
-  *os << ')';
-}
-
-// Implements printing a non-reference type T by letting the compiler
-// pick the right overload of PrintTo() for T.
-template <typename T>
-class UniversalPrinter {
- public:
-  // MSVC warns about adding const to a function type, so we want to
-  // disable the warning.
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
-
-  // Note: we deliberately don't call this PrintTo(), as that name
-  // conflicts with ::testing::internal::PrintTo in the body of the
-  // function.
-  static void Print(const T& value, ::std::ostream* os) {
-    // By default, ::testing::internal::PrintTo() is used for printing
-    // the value.
-    //
-    // Thanks to Koenig look-up, if T is a class and has its own
-    // PrintTo() function defined in its namespace, that function will
-    // be visible here.  Since it is more specific than the generic ones
-    // in ::testing::internal, it will be picked by the compiler in the
-    // following statement - exactly what we want.
-    PrintTo(value, os);
-  }
-
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-};
-
-// UniversalPrintArray(begin, len, os) prints an array of 'len'
-// elements, starting at address 'begin'.
-template <typename T>
-void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
-  if (len == 0) {
-    *os << "{}";
-  } else {
-    *os << "{ ";
-    const size_t kThreshold = 18;
-    const size_t kChunkSize = 8;
-    // If the array has more than kThreshold elements, we'll have to
-    // omit some details by printing only the first and the last
-    // kChunkSize elements.
-    // TODO(wan@google.com): let the user control the threshold using a flag.
-    if (len <= kThreshold) {
-      PrintRawArrayTo(begin, len, os);
-    } else {
-      PrintRawArrayTo(begin, kChunkSize, os);
-      *os << ", ..., ";
-      PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
-    }
-    *os << " }";
-  }
-}
-// This overload prints a (const) char array compactly.
-GTEST_API_ void UniversalPrintArray(
-    const char* 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);
-
-// Implements printing an array type T[N].
-template <typename T, size_t N>
-class UniversalPrinter<T[N]> {
- public:
-  // Prints the given array, omitting some elements when there are too
-  // many.
-  static void Print(const T (&a)[N], ::std::ostream* os) {
-    UniversalPrintArray(a, N, os);
-  }
-};
-
-// Implements printing a reference type T&.
-template <typename T>
-class UniversalPrinter<T&> {
- public:
-  // MSVC warns about adding const to a function type, so we want to
-  // disable the warning.
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
-
-  static void Print(const T& value, ::std::ostream* os) {
-    // Prints the address of the value.  We use reinterpret_cast here
-    // as static_cast doesn't compile when T is a function type.
-    *os << "@" << reinterpret_cast<const void*>(&value) << " ";
-
-    // Then prints the value itself.
-    UniversalPrint(value, os);
-  }
-
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-};
-
-// Prints a value tersely: for a reference type, the referenced value
-// (but not the address) is printed; for a (const) char pointer, the
-// NUL-terminated string (but not the pointer) is printed.
-
-template <typename T>
-class UniversalTersePrinter {
- public:
-  static void Print(const T& value, ::std::ostream* os) {
-    UniversalPrint(value, os);
-  }
-};
-template <typename T>
-class UniversalTersePrinter<T&> {
- public:
-  static void Print(const T& value, ::std::ostream* os) {
-    UniversalPrint(value, os);
-  }
-};
-template <typename T, size_t N>
-class UniversalTersePrinter<T[N]> {
- public:
-  static void Print(const T (&value)[N], ::std::ostream* os) {
-    UniversalPrinter<T[N]>::Print(value, os);
-  }
-};
-template <>
-class UniversalTersePrinter<const char*> {
- public:
-  static void Print(const char* str, ::std::ostream* os) {
-    if (str == NULL) {
-      *os << "NULL";
-    } else {
-      UniversalPrint(string(str), os);
-    }
-  }
-};
-template <>
-class UniversalTersePrinter<char*> {
- public:
-  static void Print(char* str, ::std::ostream* os) {
-    UniversalTersePrinter<const char*>::Print(str, os);
-  }
-};
-
-#if GTEST_HAS_STD_WSTRING
-template <>
-class UniversalTersePrinter<const wchar_t*> {
- public:
-  static void Print(const wchar_t* str, ::std::ostream* os) {
-    if (str == NULL) {
-      *os << "NULL";
-    } else {
-      UniversalPrint(::std::wstring(str), os);
-    }
-  }
-};
-#endif
-
-template <>
-class UniversalTersePrinter<wchar_t*> {
- public:
-  static void Print(wchar_t* str, ::std::ostream* os) {
-    UniversalTersePrinter<const wchar_t*>::Print(str, os);
-  }
-};
-
-template <typename T>
-void UniversalTersePrint(const T& value, ::std::ostream* os) {
-  UniversalTersePrinter<T>::Print(value, os);
-}
-
-// Prints a value using the type inferred by the compiler.  The
-// difference between this and UniversalTersePrint() is that for a
-// (const) char pointer, this prints both the pointer and the
-// NUL-terminated string.
-template <typename T>
-void UniversalPrint(const T& value, ::std::ostream* os) {
-  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
-  // UniversalPrinter with T directly.
-  typedef T T1;
-  UniversalPrinter<T1>::Print(value, os);
-}
-
-typedef ::std::vector<string> Strings;
-
-// TuplePolicy<TupleT> must provide:
-// - tuple_size
-//     size of tuple TupleT.
-// - get<size_t I>(const TupleT& t)
-//     static function extracting element I of tuple TupleT.
-// - tuple_element<size_t I>::type
-//     type of element I of tuple TupleT.
-template <typename TupleT>
-struct TuplePolicy;
-
-#if GTEST_HAS_TR1_TUPLE
-template <typename TupleT>
-struct TuplePolicy {
-  typedef TupleT Tuple;
-  static const size_t tuple_size = ::std::tr1::tuple_size<Tuple>::value;
-
-  template <size_t I>
-  struct tuple_element : ::std::tr1::tuple_element<I, Tuple> {};
-
-  template <size_t I>
-  static typename AddReference<
-      const typename ::std::tr1::tuple_element<I, Tuple>::type>::type get(
-      const Tuple& tuple) {
-    return ::std::tr1::get<I>(tuple);
-  }
-};
-template <typename TupleT>
-const size_t TuplePolicy<TupleT>::tuple_size;
-#endif  // GTEST_HAS_TR1_TUPLE
-
-#if GTEST_HAS_STD_TUPLE_
-template <typename... Types>
-struct TuplePolicy< ::std::tuple<Types...> > {
-  typedef ::std::tuple<Types...> Tuple;
-  static const size_t tuple_size = ::std::tuple_size<Tuple>::value;
-
-  template <size_t I>
-  struct tuple_element : ::std::tuple_element<I, Tuple> {};
-
-  template <size_t I>
-  static const typename ::std::tuple_element<I, Tuple>::type& get(
-      const Tuple& tuple) {
-    return ::std::get<I>(tuple);
-  }
-};
-template <typename... Types>
-const size_t TuplePolicy< ::std::tuple<Types...> >::tuple_size;
-#endif  // GTEST_HAS_STD_TUPLE_
-
-#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
-// This helper template allows PrintTo() for tuples and
-// UniversalTersePrintTupleFieldsToStrings() to be defined by
-// induction on the number of tuple fields.  The idea is that
-// TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N
-// fields in tuple t, and can be defined in terms of
-// TuplePrefixPrinter<N - 1>.
-//
-// The inductive case.
-template <size_t N>
-struct TuplePrefixPrinter {
-  // Prints the first N fields of a tuple.
-  template <typename Tuple>
-  static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
-    TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
-    GTEST_INTENTIONAL_CONST_COND_PUSH_()
-    if (N > 1) {
-    GTEST_INTENTIONAL_CONST_COND_POP_()
-      *os << ", ";
-    }
-    UniversalPrinter<
-        typename TuplePolicy<Tuple>::template tuple_element<N - 1>::type>
-        ::Print(TuplePolicy<Tuple>::template get<N - 1>(t), os);
-  }
-
-  // Tersely prints the first N fields of a tuple to a string vector,
-  // one element for each field.
-  template <typename Tuple>
-  static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
-    TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings);
-    ::std::stringstream ss;
-    UniversalTersePrint(TuplePolicy<Tuple>::template get<N - 1>(t), &ss);
-    strings->push_back(ss.str());
-  }
-};
-
-// Base case.
-template <>
-struct TuplePrefixPrinter<0> {
-  template <typename Tuple>
-  static void PrintPrefixTo(const Tuple&, ::std::ostream*) {}
-
-  template <typename Tuple>
-  static void TersePrintPrefixToStrings(const Tuple&, Strings*) {}
-};
-
-// Helper function for printing a tuple.
-// Tuple must be either std::tr1::tuple or std::tuple type.
-template <typename Tuple>
-void PrintTupleTo(const Tuple& t, ::std::ostream* os) {
-  *os << "(";
-  TuplePrefixPrinter<TuplePolicy<Tuple>::tuple_size>::PrintPrefixTo(t, os);
-  *os << ")";
-}
-
-// Prints the fields of a tuple tersely to a string vector, one
-// element for each field.  See the comment before
-// UniversalTersePrint() for how we define "tersely".
-template <typename Tuple>
-Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
-  Strings result;
-  TuplePrefixPrinter<TuplePolicy<Tuple>::tuple_size>::
-      TersePrintPrefixToStrings(value, &result);
-  return result;
-}
-#endif  // GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
-
-}  // namespace internal
-
-template <typename T>
-::std::string PrintToString(const T& value) {
-  ::std::stringstream ss;
-  internal::UniversalTersePrinter<T>::Print(value, &ss);
-  return ss.str();
-}
-
-}  // namespace testing
-
-// Include any custom printer 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 "gtest/internal/custom/gtest-printers.h"
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-spi.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-spi.h
deleted file mode 100644
index f63fa9a1..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-spi.h
+++ /dev/null
@@ -1,232 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Utilities for testing Google Test itself and code that uses Google Test
-// (e.g. frameworks built on top of Google Test).
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_
-#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_
-
-#include "gtest/gtest.h"
-
-namespace testing {
-
-// This helper class can be used to mock out Google Test failure reporting
-// so that we can test Google Test or code that builds on Google Test.
-//
-// An object of this class appends a TestPartResult object to the
-// TestPartResultArray object given in the constructor whenever a Google Test
-// failure is reported. It can either intercept only failures that are
-// generated in the same thread that created this object or it can intercept
-// all generated failures. The scope of this mock object can be controlled with
-// the second argument to the two arguments constructor.
-class GTEST_API_ ScopedFakeTestPartResultReporter
-    : public TestPartResultReporterInterface {
- public:
-  // The two possible mocking modes of this object.
-  enum InterceptMode {
-    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
-    INTERCEPT_ALL_THREADS           // Intercepts all failures.
-  };
-
-  // The c'tor sets this object as the test part result reporter used
-  // by Google Test.  The 'result' parameter specifies where to report the
-  // results. This reporter will only catch failures generated in the current
-  // thread. DEPRECATED
-  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
-
-  // Same as above, but you can choose the interception scope of this object.
-  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
-                                   TestPartResultArray* result);
-
-  // The d'tor restores the previous test part result reporter.
-  virtual ~ScopedFakeTestPartResultReporter();
-
-  // Appends the TestPartResult object to the TestPartResultArray
-  // received in the constructor.
-  //
-  // This method is from the TestPartResultReporterInterface
-  // interface.
-  virtual void ReportTestPartResult(const TestPartResult& result);
- private:
-  void Init();
-
-  const InterceptMode intercept_mode_;
-  TestPartResultReporterInterface* old_reporter_;
-  TestPartResultArray* const result_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
-};
-
-namespace internal {
-
-// A helper class for implementing EXPECT_FATAL_FAILURE() and
-// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
-// TestPartResultArray contains exactly one failure that has the given
-// type and contains the given substring.  If that's not the case, a
-// non-fatal failure will be generated.
-class GTEST_API_ SingleFailureChecker {
- public:
-  // The constructor remembers the arguments.
-  SingleFailureChecker(const TestPartResultArray* results,
-                       TestPartResult::Type type,
-                       const string& substr);
-  ~SingleFailureChecker();
- private:
-  const TestPartResultArray* const results_;
-  const TestPartResult::Type type_;
-  const string substr_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
-};
-
-}  // namespace internal
-
-}  // namespace testing
-
-// 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'
-// being part of the failure message.
-//
-// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
-// affects and considers failures generated in the current thread and
-// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
-//
-// The verification of the assertion is done correctly even when the statement
-// throws an exception or aborts the current function.
-//
-// Known restrictions:
-//   - 'statement' cannot reference local non-static variables or
-//     non-static members of the current object.
-//   - 'statement' cannot return a value.
-//   - You cannot stream a failure message to this macro.
-//
-// Note that even though the implementations of the following two
-// macros are much alike, we cannot refactor them to use a common
-// helper macro, due to some peculiarity in how the preprocessor
-// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
-// gtest_unittest.cc will fail to compile if we do that.
-#define EXPECT_FATAL_FAILURE(statement, substr) \
-  do { \
-    class GTestExpectFatalFailureHelper {\
-     public:\
-      static void Execute() { statement; }\
-    };\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter:: \
-          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
-      GTestExpectFatalFailureHelper::Execute();\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
-  do { \
-    class GTestExpectFatalFailureHelper {\
-     public:\
-      static void Execute() { statement; }\
-    };\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter:: \
-          INTERCEPT_ALL_THREADS, &gtest_failures);\
-      GTestExpectFatalFailureHelper::Execute();\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-// A macro for testing Google Test assertions or code that's expected to
-// generate Google Test non-fatal failures.  It asserts that the given
-// statement will cause exactly one non-fatal Google Test failure with 'substr'
-// being part of the failure message.
-//
-// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
-// affects and considers failures generated in the current thread and
-// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
-//
-// 'statement' is allowed to reference local variables and members of
-// the current object.
-//
-// The verification of the assertion is done correctly even when the statement
-// throws an exception or aborts the current function.
-//
-// Known restrictions:
-//   - You cannot stream a failure message to this macro.
-//
-// Note that even though the implementations of the following two
-// macros are much alike, we cannot refactor them to use a common
-// helper macro, due to some peculiarity in how the preprocessor
-// works.  If we do that, the code won't compile when the user gives
-// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
-// expands to code containing an unprotected comma.  The
-// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
-// catches that.
-//
-// For the same reason, we have to write
-//   if (::testing::internal::AlwaysTrue()) { statement; }
-// instead of
-//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
-// to avoid an MSVC warning on unreachable code.
-#define EXPECT_NONFATAL_FAILURE(statement, substr) \
-  do {\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
-        (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter:: \
-          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
-      if (::testing::internal::AlwaysTrue()) { statement; }\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
-  do {\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
-        (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
-          &gtest_failures);\
-      if (::testing::internal::AlwaysTrue()) { statement; }\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_SPI_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-test-part.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-test-part.h
deleted file mode 100644
index 77eb8448..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-test-part.h
+++ /dev/null
@@ -1,179 +0,0 @@
-// 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.
-//
-// Author: mheule@google.com (Markus Heule)
-//
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
-#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
-
-#include <iosfwd>
-#include <vector>
-#include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-string.h"
-
-namespace testing {
-
-// A copyable object representing the result of a test part (i.e. an
-// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
-//
-// Don't inherit from TestPartResult as its destructor is not virtual.
-class GTEST_API_ TestPartResult {
- public:
-  // The possible outcomes of a test part (i.e. an assertion or an
-  // explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
-  enum Type {
-    kSuccess,          // Succeeded.
-    kNonFatalFailure,  // Failed but the test can continue.
-    kFatalFailure      // Failed and the test should be terminated.
-  };
-
-  // 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,
-                 const char* a_message)
-      : type_(a_type),
-        file_name_(a_file_name == NULL ? "" : a_file_name),
-        line_number_(a_line_number),
-        summary_(ExtractSummary(a_message)),
-        message_(a_message) {
-  }
-
-  // Gets the outcome of the test part.
-  Type type() const { return type_; }
-
-  // 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() ? NULL : file_name_.c_str();
-  }
-
-  // Gets the line in the source file where the test part took place,
-  // or -1 if it's unknown.
-  int line_number() const { return line_number_; }
-
-  // Gets the summary of the failure message.
-  const char* summary() const { return summary_.c_str(); }
-
-  // Gets the message associated with the test part.
-  const char* message() const { return message_.c_str(); }
-
-  // Returns true iff the test part passed.
-  bool passed() const { return type_ == kSuccess; }
-
-  // Returns true iff the test part failed.
-  bool failed() const { return type_ != kSuccess; }
-
-  // Returns true iff the test part non-fatally failed.
-  bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
-
-  // Returns true iff the test part fatally failed.
-  bool fatally_failed() const { return type_ == kFatalFailure; }
-
- private:
-  Type type_;
-
-  // Gets the summary of the failure message by omitting the stack
-  // trace in it.
-  static std::string ExtractSummary(const char* message);
-
-  // The name of the source file where the test part took place, or
-  // "" if the source file is unknown.
-  std::string file_name_;
-  // The line in the source file where the test part took place, or -1
-  // if the line number is unknown.
-  int line_number_;
-  std::string summary_;  // The test failure summary.
-  std::string message_;  // The test failure message.
-};
-
-// Prints a TestPartResult object.
-std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
-
-// An array of TestPartResult objects.
-//
-// Don't inherit from TestPartResultArray as its destructor is not
-// virtual.
-class GTEST_API_ TestPartResultArray {
- public:
-  TestPartResultArray() {}
-
-  // Appends the given TestPartResult to the array.
-  void Append(const TestPartResult& result);
-
-  // Returns the TestPartResult at the given index (0-based).
-  const TestPartResult& GetTestPartResult(int index) const;
-
-  // Returns the number of TestPartResult objects in the array.
-  int size() const;
-
- private:
-  std::vector<TestPartResult> array_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
-};
-
-// This interface knows how to report a test part result.
-class TestPartResultReporterInterface {
- public:
-  virtual ~TestPartResultReporterInterface() {}
-
-  virtual void ReportTestPartResult(const TestPartResult& result) = 0;
-};
-
-namespace internal {
-
-// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
-// statement generates new fatal failures. To do so it registers itself as the
-// current test part result reporter. Besides checking if fatal failures were
-// reported, it only delegates the reporting to the former result reporter.
-// The original result reporter is restored in the destructor.
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-class GTEST_API_ HasNewFatalFailureHelper
-    : public TestPartResultReporterInterface {
- public:
-  HasNewFatalFailureHelper();
-  virtual ~HasNewFatalFailureHelper();
-  virtual void ReportTestPartResult(const TestPartResult& result);
-  bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
- private:
-  bool has_new_fatal_failure_;
-  TestPartResultReporterInterface* original_reporter_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
-};
-
-}  // namespace internal
-
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-typed-test.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-typed-test.h
deleted file mode 100644
index 5f69d567..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest-typed-test.h
+++ /dev/null
@@ -1,263 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
-#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
-
-// This header implements typed tests and type-parameterized tests.
-
-// Typed (aka type-driven) tests repeat the same test for types in a
-// list.  You must know which types you want to test with when writing
-// typed tests. Here's how you do it:
-
-#if 0
-
-// First, define a fixture class template.  It should be parameterized
-// by a type.  Remember to derive it from testing::Test.
-template <typename T>
-class FooTest : public testing::Test {
- public:
-  ...
-  typedef std::list<T> List;
-  static T shared_;
-  T value_;
-};
-
-// Next, associate a list of types with the test case, which will be
-// repeated for 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_CASE(FooTest, MyTypes);
-
-// If the type list contains only one type, you can write that type
-// directly without Types<...>:
-//   TYPED_TEST_CASE(FooTest, int);
-
-// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
-// tests for this test case as you want.
-TYPED_TEST(FooTest, DoesBlah) {
-  // Inside a test, refer to TypeParam to get the type parameter.
-  // Since we are inside a derived class template, C++ requires use to
-  // visit the members of FooTest via 'this'.
-  TypeParam n = this->value_;
-
-  // To visit static members of the fixture, add the TestFixture::
-  // prefix.
-  n += TestFixture::shared_;
-
-  // To refer to typedefs in the fixture, add the "typename
-  // TestFixture::" prefix.
-  typename TestFixture::List values;
-  values.push_back(n);
-  ...
-}
-
-TYPED_TEST(FooTest, HasPropertyA) { ... }
-
-#endif  // 0
-
-// Type-parameterized tests are abstract test patterns parameterized
-// by a type.  Compared with typed tests, type-parameterized tests
-// allow you to define the test pattern without knowing what the type
-// parameters are.  The defined pattern can be instantiated with
-// different types any number of times, in any number of translation
-// units.
-//
-// If you are designing an interface or concept, you can define a
-// suite of type-parameterized tests to verify properties that any
-// valid implementation of the interface/concept should have.  Then,
-// each implementation can easily instantiate the test suite to verify
-// that it conforms to the requirements, without having to write
-// similar tests repeatedly.  Here's an example:
-
-#if 0
-
-// First, define a fixture class template.  It should be parameterized
-// by a type.  Remember to derive it from testing::Test.
-template <typename T>
-class FooTest : public testing::Test {
-  ...
-};
-
-// Next, declare that you will define a type-parameterized test case
-// (the _P suffix is for "parameterized" or "pattern", whichever you
-// prefer):
-TYPED_TEST_CASE_P(FooTest);
-
-// Then, use TYPED_TEST_P() to define as many type-parameterized tests
-// for this type-parameterized test case as you want.
-TYPED_TEST_P(FooTest, DoesBlah) {
-  // Inside a test, refer to TypeParam to get the type parameter.
-  TypeParam n = 0;
-  ...
-}
-
-TYPED_TEST_P(FooTest, HasPropertyA) { ... }
-
-// Now the tricky part: you need to register all test patterns before
-// you can instantiate them.  The first argument of the macro is the
-// test case name; the rest are the names of the tests in this test
-// case.
-REGISTER_TYPED_TEST_CASE_P(FooTest,
-                           DoesBlah, HasPropertyA);
-
-// Finally, you are free to instantiate the pattern with the types you
-// want.  If you put the above code in a header file, you can #include
-// it in multiple C++ source files and instantiate it multiple times.
-//
-// 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 case name.  Remember to pick unique prefixes for
-// different instances.
-typedef testing::Types<char, int, unsigned int> MyTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
-
-// If the type list contains only one type, you can write that type
-// directly without Types<...>:
-//   INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
-
-#endif  // 0
-
-#include "gtest/internal/gtest-port.h"
-#include "gtest/internal/gtest-type-util.h"
-
-// Implements typed tests.
-
-#if GTEST_HAS_TYPED_TEST
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Expands to the name of the typedef for the type parameters of the
-// given test case.
-# define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_
-
-// The 'Types' template argument below must have spaces around it
-// since some compilers may choke on '>>' when passing a template
-// instance (e.g. Types<int>)
-# define TYPED_TEST_CASE(CaseName, Types) \
-  typedef ::testing::internal::TypeList< Types >::type \
-      GTEST_TYPE_PARAMS_(CaseName)
-
-# define TYPED_TEST(CaseName, TestName) \
-  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; \
-    virtual void TestBody(); \
-  }; \
-  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__), \
-              #CaseName, #TestName, 0); \
-  template <typename gtest_TypeParam_> \
-  void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody()
-
-#endif  // GTEST_HAS_TYPED_TEST
-
-// Implements type-parameterized tests.
-
-#if GTEST_HAS_TYPED_TEST_P
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Expands to the namespace name that the type-parameterized tests for
-// the given type-parameterized test case are defined in.  The exact
-// name of the namespace is subject to change without notice.
-# define GTEST_CASE_NAMESPACE_(TestCaseName) \
-  gtest_case_##TestCaseName##_
-
-// 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 case.
-# define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \
-  gtest_typed_test_case_p_state_##TestCaseName##_
-
-// 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 case.
-# define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \
-  gtest_registered_test_names_##TestCaseName##_
-
-// 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_CASE_P(CaseName) \
-  static ::testing::internal::TypedTestCasePState \
-      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName)
-
-# define TYPED_TEST_P(CaseName, TestName) \
-  namespace GTEST_CASE_NAMESPACE_(CaseName) { \
-  template <typename gtest_TypeParam_> \
-  class TestName : public CaseName<gtest_TypeParam_> { \
-   private: \
-    typedef CaseName<gtest_TypeParam_> TestFixture; \
-    typedef gtest_TypeParam_ TypeParam; \
-    virtual void TestBody(); \
-  }; \
-  static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
-      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\
-          __FILE__, __LINE__, #CaseName, #TestName); \
-  } \
-  template <typename gtest_TypeParam_> \
-  void GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody()
-
-# define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \
-  namespace GTEST_CASE_NAMESPACE_(CaseName) { \
-  typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \
-  } \
-  static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \
-      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\
-          __FILE__, __LINE__, #__VA_ARGS__)
-
-// The 'Types' template argument below must have spaces around it
-// since some compilers may choke on '>>' when passing a template
-// instance (e.g. Types<int>)
-# define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \
-  bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \
-      ::testing::internal::TypeParameterizedTestCase<CaseName, \
-          GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \
-          ::testing::internal::TypeList< Types >::type>::Register(\
-              #Prefix, \
-              ::testing::internal::CodeLocation(__FILE__, __LINE__), \
-              &GTEST_TYPED_TEST_CASE_P_STATE_(CaseName), \
-              #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName))
-
-#endif  // GTEST_HAS_TYPED_TEST_P
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest.h
deleted file mode 100644
index f846c5bd..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest.h
+++ /dev/null
@@ -1,2236 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This header file defines the public API for Google Test.  It should be
-// included by any test program that uses Google Test.
-//
-// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
-// leave some internal implementation details in this header file.
-// They are clearly marked by comments like this:
-//
-//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-//
-// Such code is NOT meant to be used by a user directly, and is subject
-// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
-// program!
-//
-// Acknowledgment: Google Test borrowed the idea of automatic test
-// registration from Barthelemy Dagenais' (barthelemy@prologique.com)
-// easyUnit framework.
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
-#define GTEST_INCLUDE_GTEST_GTEST_H_
-
-#include <limits>
-#include <ostream>
-#include <vector>
-
-#include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-string.h"
-#include "gtest/gtest-death-test.h"
-#include "gtest/gtest-message.h"
-#include "gtest/gtest-param-test.h"
-#include "gtest/gtest-printers.h"
-#include "gtest/gtest_prod.h"
-#include "gtest/gtest-test-part.h"
-#include "gtest/gtest-typed-test.h"
-
-// Depending on the platform, different string classes are available.
-// On Linux, in addition to ::std::string, Google also makes use of
-// class ::string, which has the same interface as ::std::string, but
-// has a different implementation.
-//
-// You can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that
-// ::string is available AND is a distinct type to ::std::string, or
-// define it to 0 to indicate otherwise.
-//
-// If ::std::string and ::string are the same class on your platform
-// due to aliasing, you should define GTEST_HAS_GLOBAL_STRING to 0.
-//
-// If you do not define GTEST_HAS_GLOBAL_STRING, it is defined
-// heuristically.
-
-namespace testing {
-
-// Declares the flags.
-
-// This flag temporary enables the disabled tests.
-GTEST_DECLARE_bool_(also_run_disabled_tests);
-
-// This flag brings the debugger on an assertion failure.
-GTEST_DECLARE_bool_(break_on_failure);
-
-// This flag controls whether Google Test catches all test-thrown exceptions
-// and logs them as failures.
-GTEST_DECLARE_bool_(catch_exceptions);
-
-// This flag enables using colors in terminal output. Available values are
-// "yes" to enable colors, "no" (disable colors), or "auto" (the default)
-// to let Google Test decide.
-GTEST_DECLARE_string_(color);
-
-// This flag sets up the filter to select by name using a glob pattern
-// the tests to run. If the filter is not given all tests are executed.
-GTEST_DECLARE_string_(filter);
-
-// This flag causes the Google Test to list tests. None of the tests listed
-// are actually run if the flag is provided.
-GTEST_DECLARE_bool_(list_tests);
-
-// This flag controls whether Google Test emits a detailed XML report to a file
-// in addition to its normal textual output.
-GTEST_DECLARE_string_(output);
-
-// This flags control whether Google Test prints the elapsed time for each
-// test.
-GTEST_DECLARE_bool_(print_time);
-
-// This flag specifies the random number seed.
-GTEST_DECLARE_int32_(random_seed);
-
-// This flag sets how many times the tests are repeated. The default value
-// is 1. If the value is -1 the tests are repeating forever.
-GTEST_DECLARE_int32_(repeat);
-
-// This flag controls whether Google Test includes Google Test internal
-// stack frames in failure stack traces.
-GTEST_DECLARE_bool_(show_internal_stack_frames);
-
-// When this flag is specified, tests' order is randomized on every iteration.
-GTEST_DECLARE_bool_(shuffle);
-
-// This flag specifies the maximum number of stack frames to be
-// printed in a failure message.
-GTEST_DECLARE_int32_(stack_trace_depth);
-
-// When this flag is specified, a failed assertion will throw an
-// exception if exceptions are enabled, or exit the program with a
-// non-zero code otherwise.
-GTEST_DECLARE_bool_(throw_on_failure);
-
-// When this flag is set with a "host:port" string, on supported
-// platforms test results are streamed to the specified port on
-// the specified host machine.
-GTEST_DECLARE_string_(stream_result_to);
-
-// The upper limit for valid stack trace depths.
-const int kMaxStackTraceDepth = 100;
-
-namespace internal {
-
-class AssertHelper;
-class DefaultGlobalTestPartResultReporter;
-class ExecDeathTest;
-class NoExecDeathTest;
-class FinalSuccessChecker;
-class GTestFlagSaver;
-class StreamingListenerTest;
-class TestResultAccessor;
-class TestEventListenersAccessor;
-class TestEventRepeater;
-class UnitTestRecordPropertyTestHelper;
-class WindowsDeathTest;
-class UnitTestImpl* GetUnitTestImpl();
-void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
-                                    const std::string& message);
-
-}  // namespace internal
-
-// The friend relationship of some of these classes is cyclic.
-// If we don't forward declare them the compiler might confuse the classes
-// in friendship clauses with same named classes on the scope.
-class Test;
-class TestCase;
-class TestInfo;
-class UnitTest;
-
-// A class for indicating whether an assertion was successful.  When
-// the assertion wasn't successful, the AssertionResult object
-// remembers a non-empty message that describes how it failed.
-//
-// To create an instance of this class, use one of the factory functions
-// (AssertionSuccess() and AssertionFailure()).
-//
-// This class is useful for two purposes:
-//   1. Defining predicate functions to be used with Boolean test assertions
-//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
-//   2. Defining predicate-format functions to be
-//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
-//
-// For example, if you define IsEven predicate:
-//
-//   testing::AssertionResult IsEven(int n) {
-//     if ((n % 2) == 0)
-//       return testing::AssertionSuccess();
-//     else
-//       return testing::AssertionFailure() << n << " is odd";
-//   }
-//
-// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
-// will print the message
-//
-//   Value of: IsEven(Fib(5))
-//     Actual: false (5 is odd)
-//   Expected: true
-//
-// instead of a more opaque
-//
-//   Value of: IsEven(Fib(5))
-//     Actual: false
-//   Expected: true
-//
-// in case IsEven is a simple Boolean predicate.
-//
-// If you expect your predicate to be reused and want to support informative
-// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
-// about half as often as positive ones in our tests), supply messages for
-// both success and failure cases:
-//
-//   testing::AssertionResult IsEven(int n) {
-//     if ((n % 2) == 0)
-//       return testing::AssertionSuccess() << n << " is even";
-//     else
-//       return testing::AssertionFailure() << n << " is odd";
-//   }
-//
-// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
-//
-//   Value of: IsEven(Fib(6))
-//     Actual: true (8 is even)
-//   Expected: false
-//
-// NB: Predicates that support negative Boolean assertions have reduced
-// performance in positive ones so be careful not to use them in tests
-// that have lots (tens of thousands) of positive Boolean assertions.
-//
-// To use this class with EXPECT_PRED_FORMAT assertions such as:
-//
-//   // Verifies that Foo() returns an even number.
-//   EXPECT_PRED_FORMAT1(IsEven, Foo());
-//
-// you need to define:
-//
-//   testing::AssertionResult IsEven(const char* expr, int n) {
-//     if ((n % 2) == 0)
-//       return testing::AssertionSuccess();
-//     else
-//       return testing::AssertionFailure()
-//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
-//   }
-//
-// If Foo() returns 5, you will see the following message:
-//
-//   Expected: Foo() is even
-//     Actual: it's 5
-//
-class GTEST_API_ AssertionResult {
- public:
-  // Copy constructor.
-  // Used in EXPECT_TRUE/FALSE(assertion_result).
-  AssertionResult(const AssertionResult& other);
-
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
-
-  // Used in the EXPECT_TRUE/FALSE(bool_expression).
-  //
-  // T must be contextually convertible to bool.
-  //
-  // The second parameter prevents this overload from being considered if
-  // the argument is implicitly convertible to AssertionResult. In that case
-  // we want AssertionResult's copy constructor to be used.
-  template <typename T>
-  explicit AssertionResult(
-      const T& success,
-      typename internal::EnableIf<
-          !internal::ImplicitlyConvertible<T, AssertionResult>::value>::type*
-          /*enabler*/ = NULL)
-      : success_(success) {}
-
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-  // Assignment operator.
-  AssertionResult& operator=(AssertionResult other) {
-    swap(other);
-    return *this;
-  }
-
-  // Returns true iff the assertion succeeded.
-  operator bool() const { return success_; }  // NOLINT
-
-  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
-  AssertionResult operator!() const;
-
-  // Returns the text streamed into this AssertionResult. Test assertions
-  // use it when they fail (i.e., the predicate's outcome doesn't match the
-  // assertion's expectation). When nothing has been streamed into the
-  // object, returns an empty string.
-  const char* message() const {
-    return message_.get() != NULL ?  message_->c_str() : "";
-  }
-  // TODO(vladl@google.com): Remove this after making sure no clients use it.
-  // Deprecated; please use message() instead.
-  const char* failure_message() const { return message(); }
-
-  // Streams a custom failure message into this object.
-  template <typename T> AssertionResult& operator<<(const T& value) {
-    AppendMessage(Message() << value);
-    return *this;
-  }
-
-  // Allows streaming basic output manipulators such as endl or flush into
-  // this object.
-  AssertionResult& operator<<(
-      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
-    AppendMessage(Message() << basic_manipulator);
-    return *this;
-  }
-
- private:
-  // Appends the contents of message to message_.
-  void AppendMessage(const Message& a_message) {
-    if (message_.get() == NULL)
-      message_.reset(new ::std::string);
-    message_->append(a_message.GetString().c_str());
-  }
-
-  // Swap the contents of this AssertionResult with other.
-  void swap(AssertionResult& other);
-
-  // Stores result of the assertion predicate.
-  bool success_;
-  // Stores the message describing the condition in case the expectation
-  // construct is not satisfied with the predicate's outcome.
-  // Referenced via a pointer to avoid taking too much stack frame space
-  // with test assertions.
-  internal::scoped_ptr< ::std::string> message_;
-};
-
-// Makes a successful assertion result.
-GTEST_API_ AssertionResult AssertionSuccess();
-
-// Makes a failed assertion result.
-GTEST_API_ AssertionResult AssertionFailure();
-
-// Makes a failed assertion result with the given failure message.
-// Deprecated; use AssertionFailure() << msg.
-GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
-
-// The abstract class that all tests inherit from.
-//
-// In Google Test, a unit test program contains one or many TestCases, and
-// each TestCase 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 a TEST_F.  For example:
-//
-//   class FooTest : public testing::Test {
-//    protected:
-//     void SetUp() override { ... }
-//     void TearDown() override { ... }
-//     ...
-//   };
-//
-//   TEST_F(FooTest, Bar) { ... }
-//   TEST_F(FooTest, Baz) { ... }
-//
-// Test is not copyable.
-class GTEST_API_ Test {
- public:
-  friend class TestInfo;
-
-  // Defines types for pointers to functions that set up and tear down
-  // a test case.
-  typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc;
-  typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc;
-
-  // The d'tor is virtual as we intend to inherit from Test.
-  virtual ~Test();
-
-  // Sets up the stuff shared by all tests in this test case.
-  //
-  // Google Test will call Foo::SetUpTestCase() before running the first
-  // test in test case Foo.  Hence a sub-class can define its own
-  // SetUpTestCase() method to shadow the one defined in the super
-  // class.
-  static void SetUpTestCase() {}
-
-  // Tears down the stuff shared by all tests in this test case.
-  //
-  // Google Test will call Foo::TearDownTestCase() after running the last
-  // test in test case Foo.  Hence a sub-class can define its own
-  // TearDownTestCase() method to shadow the one defined in the super
-  // class.
-  static void TearDownTestCase() {}
-
-  // Returns true iff the current test has a fatal failure.
-  static bool HasFatalFailure();
-
-  // Returns true iff the current test has a non-fatal failure.
-  static bool HasNonfatalFailure();
-
-  // Returns true iff the current test has a (either fatal or
-  // non-fatal) failure.
-  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
-
-  // Logs a property for the current test, test case, or for the entire
-  // invocation of the test program when used outside of the context of a
-  // test case.  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
-  // SetUpTestCase or TearDownTestCase are logged as attributes of the
-  // corresponding <testsuite> element.  Calls to RecordProperty made in the
-  // global context (before or after invocation of RUN_ALL_TESTS and from
-  // SetUp/TearDown method of Environment objects registered with Google
-  // Test) will be output as attributes of the <testsuites> element.
-  static void RecordProperty(const std::string& key, const std::string& value);
-  static void RecordProperty(const std::string& key, int value);
-
- protected:
-  // Creates a Test object.
-  Test();
-
-  // Sets up the test fixture.
-  virtual void SetUp();
-
-  // Tears down the test fixture.
-  virtual void TearDown();
-
- private:
-  // Returns true iff the current test has the same fixture class as
-  // the first test in the current test case.
-  static bool HasSameFixtureClass();
-
-  // Runs the test after the test fixture has been set up.
-  //
-  // A sub-class must implement this to define the test logic.
-  //
-  // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
-  // Instead, use the TEST or TEST_F macro.
-  virtual void TestBody() = 0;
-
-  // Sets up, executes, and tears down the test.
-  void Run();
-
-  // Deletes self.  We deliberately pick an unusual name for this
-  // internal method to avoid clashing with names used in user TESTs.
-  void DeleteSelf_() { delete this; }
-
-  const internal::scoped_ptr< GTEST_FLAG_SAVER_ > gtest_flag_saver_;
-
-  // Often a user misspells SetUp() as Setup() and spends a long time
-  // wondering why it is never called by Google Test.  The declaration of
-  // the following method is solely for catching such an error at
-  // compile time:
-  //
-  //   - The return type is deliberately chosen to be not void, so it
-  //   will be a conflict if void Setup() is declared in the user's
-  //   test fixture.
-  //
-  //   - This method is private, so it will be another compiler error
-  //   if the method is called from the user's test fixture.
-  //
-  // DO NOT OVERRIDE THIS FUNCTION.
-  //
-  // If you see an error about overriding the following function or
-  // about it being private, you have mis-spelled SetUp() as Setup().
-  struct Setup_should_be_spelled_SetUp {};
-  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
-
-  // We disallow copying Tests.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
-};
-
-typedef internal::TimeInMillis TimeInMillis;
-
-// A copyable object representing a user specified test property which can be
-// output as a key/value string pair.
-//
-// Don't inherit from TestProperty as its destructor is not virtual.
-class TestProperty {
- public:
-  // C'tor.  TestProperty does NOT have a default constructor.
-  // Always use this constructor (with parameters) to create a
-  // TestProperty object.
-  TestProperty(const std::string& a_key, const std::string& a_value) :
-    key_(a_key), value_(a_value) {
-  }
-
-  // Gets the user supplied key.
-  const char* key() const {
-    return key_.c_str();
-  }
-
-  // Gets the user supplied value.
-  const char* value() const {
-    return value_.c_str();
-  }
-
-  // Sets a new value, overriding the one supplied in the constructor.
-  void SetValue(const std::string& new_value) {
-    value_ = new_value;
-  }
-
- private:
-  // The key supplied by the user.
-  std::string key_;
-  // The value supplied by the user.
-  std::string value_;
-};
-
-// The result of a single Test.  This includes a list of
-// TestPartResults, a list of TestProperties, a count of how many
-// death tests there are in the Test, and how much time it took to run
-// the Test.
-//
-// TestResult is not copyable.
-class GTEST_API_ TestResult {
- public:
-  // Creates an empty TestResult.
-  TestResult();
-
-  // D'tor.  Do not inherit from TestResult.
-  ~TestResult();
-
-  // Gets the number of all test parts.  This is the sum of the number
-  // of successful test parts and the number of failed test parts.
-  int total_part_count() const;
-
-  // Returns the number of the test properties.
-  int test_property_count() const;
-
-  // Returns true iff the test passed (i.e. no test part failed).
-  bool Passed() const { return !Failed(); }
-
-  // Returns true iff the test failed.
-  bool Failed() const;
-
-  // Returns true iff the test fatally failed.
-  bool HasFatalFailure() const;
-
-  // Returns true iff the test has a non-fatal failure.
-  bool HasNonfatalFailure() const;
-
-  // Returns the elapsed time, in milliseconds.
-  TimeInMillis elapsed_time() const { return elapsed_time_; }
-
-  // Returns the i-th test part result among all the results. i can range
-  // from 0 to test_property_count() - 1. If i is not in that range, aborts
-  // the program.
-  const TestPartResult& GetTestPartResult(int i) const;
-
-  // Returns the i-th test property. i can range from 0 to
-  // test_property_count() - 1. If i is not in that range, aborts the
-  // program.
-  const TestProperty& GetTestProperty(int i) const;
-
- private:
-  friend class TestInfo;
-  friend class TestCase;
-  friend class UnitTest;
-  friend class internal::DefaultGlobalTestPartResultReporter;
-  friend class internal::ExecDeathTest;
-  friend class internal::TestResultAccessor;
-  friend class internal::UnitTestImpl;
-  friend class internal::WindowsDeathTest;
-
-  // Gets the vector of TestPartResults.
-  const std::vector<TestPartResult>& test_part_results() const {
-    return test_part_results_;
-  }
-
-  // Gets the vector of TestProperties.
-  const std::vector<TestProperty>& test_properties() const {
-    return test_properties_;
-  }
-
-  // Sets the elapsed time.
-  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
-
-  // Adds a test property to the list. The property is validated and may add
-  // a non-fatal failure if invalid (e.g., if it conflicts with reserved
-  // key names). If a property is already recorded for the same key, the
-  // value will be updated, rather than storing multiple values for the same
-  // key.  xml_element specifies the element for which the property is being
-  // recorded and is used for validation.
-  void RecordProperty(const std::string& xml_element,
-                      const TestProperty& test_property);
-
-  // Adds a failure if the key is a reserved attribute of Google Test
-  // testcase tags.  Returns true if the property is valid.
-  // TODO(russr): Validate attribute names are legal and human readable.
-  static bool ValidateTestProperty(const std::string& xml_element,
-                                   const TestProperty& test_property);
-
-  // Adds a test part result to the list.
-  void AddTestPartResult(const TestPartResult& test_part_result);
-
-  // Returns the death test count.
-  int death_test_count() const { return death_test_count_; }
-
-  // Increments the death test count, returning the new count.
-  int increment_death_test_count() { return ++death_test_count_; }
-
-  // Clears the test part results.
-  void ClearTestPartResults();
-
-  // Clears the object.
-  void Clear();
-
-  // Protects mutable state of the property vector and of owned
-  // properties, whose values may be updated.
-  internal::Mutex test_properites_mutex_;
-
-  // The vector of TestPartResults
-  std::vector<TestPartResult> test_part_results_;
-  // The vector of TestProperties
-  std::vector<TestProperty> test_properties_;
-  // Running count of death tests.
-  int death_test_count_;
-  // The elapsed time, in milliseconds.
-  TimeInMillis elapsed_time_;
-
-  // We disallow copying TestResult.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
-};  // class TestResult
-
-// A TestInfo object stores the following information about a test:
-//
-//   Test case name
-//   Test name
-//   Whether the test should be run
-//   A function pointer that creates the test object when invoked
-//   Test result
-//
-// The constructor of TestInfo registers itself with the UnitTest
-// singleton such that the RUN_ALL_TESTS() macro knows which tests to
-// run.
-class GTEST_API_ TestInfo {
- public:
-  // Destructs a TestInfo object.  This function is not virtual, so
-  // don't inherit from TestInfo.
-  ~TestInfo();
-
-  // Returns the test case name.
-  const char* test_case_name() const { return test_case_name_.c_str(); }
-
-  // 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() != NULL)
-      return type_param_->c_str();
-    return NULL;
-  }
-
-  // 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() != NULL)
-      return value_param_->c_str();
-    return NULL;
-  }
-
-  // Returns the file name where this test is defined.
-  const char* file() const { return location_.file.c_str(); }
-
-  // Returns the line where this test is defined.
-  int line() const { return location_.line; }
-
-  // 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 case Foo is defined as
-  // "Foo.Bar".  Only the tests that match the filter will run.
-  //
-  // A filter is a colon-separated list of glob (not regex) patterns,
-  // optionally followed by a '-' and a colon-separated list of
-  // negative patterns (tests to exclude).  A test is run if it
-  // matches one of the positive patterns and does not match any of
-  // the negative patterns.
-  //
-  // For example, *A*:Foo.* is a filter that matches any string that
-  // contains the character 'A' or starts with "Foo.".
-  bool should_run() const { return should_run_; }
-
-  // Returns true iff this test will appear in the XML report.
-  bool is_reportable() const {
-    // For now, the XML report includes all tests matching the filter.
-    // In the future, we may trim tests that are excluded because of
-    // sharding.
-    return matches_filter_;
-  }
-
-  // Returns the result of the test.
-  const TestResult* result() const { return &result_; }
-
- private:
-#if GTEST_HAS_DEATH_TEST
-  friend class internal::DefaultDeathTestFactory;
-#endif  // GTEST_HAS_DEATH_TEST
-  friend class Test;
-  friend class TestCase;
-  friend class internal::UnitTestImpl;
-  friend class internal::StreamingListenerTest;
-  friend TestInfo* internal::MakeAndRegisterTestInfo(
-      const char* test_case_name,
-      const char* name,
-      const char* type_param,
-      const char* value_param,
-      internal::CodeLocation code_location,
-      internal::TypeId fixture_class_id,
-      Test::SetUpTestCaseFunc set_up_tc,
-      Test::TearDownTestCaseFunc 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_case_name,
-           const std::string& name,
-           const char* a_type_param,   // NULL if not a type-parameterized test
-           const char* a_value_param,  // NULL if not a value-parameterized test
-           internal::CodeLocation a_code_location,
-           internal::TypeId fixture_class_id,
-           internal::TestFactoryBase* factory);
-
-  // Increments the number of death tests encountered in this test so
-  // far.
-  int increment_death_test_count() {
-    return result_.increment_death_test_count();
-  }
-
-  // Creates the test object, runs it, records its result, and then
-  // deletes it.
-  void Run();
-
-  static void ClearTestResult(TestInfo* test_info) {
-    test_info->result_.Clear();
-  }
-
-  // These fields are immutable properties of the test.
-  const std::string test_case_name_;     // Test case 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 internal::scoped_ptr<const ::std::string> type_param_;
-  // Text representation of the value parameter, or NULL if this is not a
-  // value-parameterized test.
-  const internal::scoped_ptr<const ::std::string> value_param_;
-  internal::CodeLocation location_;
-  const internal::TypeId fixture_class_id_;   // ID of the test fixture class
-  bool should_run_;                 // True iff this test should run
-  bool is_disabled_;                // True iff this test is disabled
-  bool matches_filter_;             // True if this test matches the
-                                    // user-specified filter.
-  internal::TestFactoryBase* const factory_;  // The factory that creates
-                                              // the test object
-
-  // This field is mutable and needs to be reset before running the
-  // test for the second time.
-  TestResult result_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
-};
-
-// A test case, which consists of a vector of TestInfos.
-//
-// TestCase is not copyable.
-class GTEST_API_ TestCase {
- public:
-  // Creates a TestCase with the given name.
-  //
-  // TestCase does NOT have a default constructor.  Always use this
-  // constructor to create a TestCase object.
-  //
-  // Arguments:
-  //
-  //   name:         name of the test case
-  //   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 case
-  //   tear_down_tc: pointer to the function that tears down the test case
-  TestCase(const char* name, const char* a_type_param,
-           Test::SetUpTestCaseFunc set_up_tc,
-           Test::TearDownTestCaseFunc tear_down_tc);
-
-  // Destructor of TestCase.
-  virtual ~TestCase();
-
-  // Gets the name of the TestCase.
-  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 case.
-  const char* type_param() const {
-    if (type_param_.get() != NULL)
-      return type_param_->c_str();
-    return NULL;
-  }
-
-  // Returns true if any test in this test case should run.
-  bool should_run() const { return should_run_; }
-
-  // Gets the number of successful tests in this test case.
-  int successful_test_count() const;
-
-  // Gets the number of failed tests in this test case.
-  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 case.
-  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 case that should run.
-  int test_to_run_count() const;
-
-  // Gets the number of all tests in this test case.
-  int total_test_count() const;
-
-  // Returns true iff the test case passed.
-  bool Passed() const { return !Failed(); }
-
-  // Returns true iff the test case failed.
-  bool Failed() const { return failed_test_count() > 0; }
-
-  // Returns the elapsed time, in milliseconds.
-  TimeInMillis elapsed_time() const { return elapsed_time_; }
-
-  // Returns the i-th test among all the tests. i can range from 0 to
-  // total_test_count() - 1. If i is not in that range, returns NULL.
-  const TestInfo* GetTestInfo(int i) const;
-
-  // Returns the TestResult that holds test properties recorded during
-  // execution of SetUpTestCase and TearDownTestCase.
-  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 TestCase.
-  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
-
-  // Gets the (immutable) vector of TestInfos in this TestCase.
-  const std::vector<TestInfo*>& test_info_list() const {
-    return test_info_list_;
-  }
-
-  // Returns the i-th test among all the tests. i can range from 0 to
-  // total_test_count() - 1. If i is not in that range, returns NULL.
-  TestInfo* GetMutableTestInfo(int i);
-
-  // Sets the should_run member.
-  void set_should_run(bool should) { should_run_ = should; }
-
-  // Adds a TestInfo to this test case.  Will delete the TestInfo upon
-  // destruction of the TestCase object.
-  void AddTestInfo(TestInfo * test_info);
-
-  // Clears the results of all tests in this test case.
-  void ClearResult();
-
-  // Clears the results of all tests in the given test case.
-  static void ClearTestCaseResult(TestCase* test_case) {
-    test_case->ClearResult();
-  }
-
-  // Runs every test in this TestCase.
-  void Run();
-
-  // Runs SetUpTestCase() for this TestCase.  This wrapper is needed
-  // for catching exceptions thrown from SetUpTestCase().
-  void RunSetUpTestCase() { (*set_up_tc_)(); }
-
-  // Runs TearDownTestCase() for this TestCase.  This wrapper is
-  // needed for catching exceptions thrown from TearDownTestCase().
-  void RunTearDownTestCase() { (*tear_down_tc_)(); }
-
-  // Returns true iff test passed.
-  static bool TestPassed(const TestInfo* test_info) {
-    return test_info->should_run() && test_info->result()->Passed();
-  }
-
-  // Returns true iff test failed.
-  static bool TestFailed(const TestInfo* test_info) {
-    return test_info->should_run() && test_info->result()->Failed();
-  }
-
-  // Returns true iff the test is disabled and will be reported in the XML
-  // report.
-  static bool TestReportableDisabled(const TestInfo* test_info) {
-    return test_info->is_reportable() && test_info->is_disabled_;
-  }
-
-  // Returns true iff test is disabled.
-  static bool TestDisabled(const TestInfo* test_info) {
-    return test_info->is_disabled_;
-  }
-
-  // Returns true iff this test will appear in the XML report.
-  static bool TestReportable(const TestInfo* test_info) {
-    return test_info->is_reportable();
-  }
-
-  // Returns true if the given test should run.
-  static bool ShouldRunTest(const TestInfo* test_info) {
-    return test_info->should_run();
-  }
-
-  // Shuffles the tests in this test case.
-  void ShuffleTests(internal::Random* random);
-
-  // Restores the test order to before the first shuffle.
-  void UnshuffleTests();
-
-  // Name of the test case.
-  std::string name_;
-  // Name of the parameter type, or NULL if this is not a typed or a
-  // type-parameterized test.
-  const internal::scoped_ptr<const ::std::string> type_param_;
-  // The vector of TestInfos in their original order.  It owns the
-  // elements in the vector.
-  std::vector<TestInfo*> test_info_list_;
-  // Provides a level of indirection for the test list to allow easy
-  // shuffling and restoring the test order.  The i-th element in this
-  // vector is the index of the i-th test in the shuffled test list.
-  std::vector<int> test_indices_;
-  // Pointer to the function that sets up the test case.
-  Test::SetUpTestCaseFunc set_up_tc_;
-  // Pointer to the function that tears down the test case.
-  Test::TearDownTestCaseFunc tear_down_tc_;
-  // True iff any test in this test case should run.
-  bool should_run_;
-  // Elapsed time, in milliseconds.
-  TimeInMillis elapsed_time_;
-  // Holds test properties recorded during execution of SetUpTestCase and
-  // TearDownTestCase.
-  TestResult ad_hoc_test_result_;
-
-  // We disallow copying TestCases.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase);
-};
-
-// An Environment object is capable of setting up and tearing down an
-// environment.  You should subclass this to define your own
-// environment(s).
-//
-// An Environment object does the set-up and tear-down in virtual
-// methods SetUp() and TearDown() instead of the constructor and the
-// destructor, as:
-//
-//   1. You cannot safely throw from a destructor.  This is a problem
-//      as in some cases Google Test is used where exceptions are enabled, and
-//      we may want to implement ASSERT_* using exceptions where they are
-//      available.
-//   2. You cannot use ASSERT_* directly in a constructor or
-//      destructor.
-class Environment {
- public:
-  // The d'tor is virtual as we need to subclass Environment.
-  virtual ~Environment() {}
-
-  // Override this to define how to set up the environment.
-  virtual void SetUp() {}
-
-  // Override this to define how to tear down the environment.
-  virtual void TearDown() {}
- private:
-  // If you see an error about overriding the following function or
-  // about it being private, you have mis-spelled SetUp() as Setup().
-  struct Setup_should_be_spelled_SetUp {};
-  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
-};
-
-// The interface for tracing execution of tests. The methods are organized in
-// the order the corresponding events are fired.
-class TestEventListener {
- public:
-  virtual ~TestEventListener() {}
-
-  // Fired before any test activity starts.
-  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
-
-  // Fired before each iteration of tests starts.  There may be more than
-  // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
-  // index, starting from 0.
-  virtual void OnTestIterationStart(const UnitTest& unit_test,
-                                    int iteration) = 0;
-
-  // Fired before environment set-up for each iteration of tests starts.
-  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
-
-  // Fired after environment set-up for each iteration of tests ends.
-  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
-
-  // Fired before the test case starts.
-  virtual void OnTestCaseStart(const TestCase& test_case) = 0;
-
-  // Fired before the test starts.
-  virtual void OnTestStart(const TestInfo& test_info) = 0;
-
-  // Fired after a failed assertion or a SUCCEED() invocation.
-  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 case ends.
-  virtual void OnTestCaseEnd(const TestCase& test_case) = 0;
-
-  // Fired before environment tear-down for each iteration of tests starts.
-  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
-
-  // Fired after environment tear-down for each iteration of tests ends.
-  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
-
-  // Fired after each iteration of tests finishes.
-  virtual void OnTestIterationEnd(const UnitTest& unit_test,
-                                  int iteration) = 0;
-
-  // Fired after all test activities have ended.
-  virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
-};
-
-// The convenience class for users who need to override just one or two
-// methods and are not concerned that a possible change to a signature of
-// the methods they override will not be caught during the build.  For
-// comments about each method please see the definition of TestEventListener
-// above.
-class EmptyTestEventListener : public TestEventListener {
- public:
-  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
-                                    int /*iteration*/) {}
-  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {}
-  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
-  virtual void OnTestStart(const TestInfo& /*test_info*/) {}
-  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {}
-  virtual void OnTestEnd(const TestInfo& /*test_info*/) {}
-  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
-  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {}
-  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
-                                  int /*iteration*/) {}
-  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
-};
-
-// TestEventListeners lets users add listeners to track events in Google Test.
-class GTEST_API_ TestEventListeners {
- public:
-  TestEventListeners();
-  ~TestEventListeners();
-
-  // Appends an event listener to the end of the list. Google Test assumes
-  // the ownership of the listener (i.e. it will delete the listener when
-  // the test program finishes).
-  void Append(TestEventListener* listener);
-
-  // Removes the given event listener from the list and returns it.  It then
-  // becomes the caller's responsibility to delete the listener. Returns
-  // NULL if the listener is not found in the list.
-  TestEventListener* Release(TestEventListener* listener);
-
-  // Returns the standard listener responsible for the default console
-  // output.  Can be removed from the listeners list to shut down default
-  // console output.  Note that removing this object from the listener list
-  // with Release transfers its ownership to the caller and makes this
-  // function return NULL the next time.
-  TestEventListener* default_result_printer() const {
-    return default_result_printer_;
-  }
-
-  // Returns the standard listener responsible for the default XML output
-  // controlled by the --gtest_output=xml flag.  Can be removed from the
-  // listeners list by users who want to shut down the default XML output
-  // controlled by this flag and substitute it with custom one.  Note that
-  // removing this object from the listener list with Release transfers its
-  // ownership to the caller and makes this function return NULL the next
-  // time.
-  TestEventListener* default_xml_generator() const {
-    return default_xml_generator_;
-  }
-
- private:
-  friend class TestCase;
-  friend class TestInfo;
-  friend class internal::DefaultGlobalTestPartResultReporter;
-  friend class internal::NoExecDeathTest;
-  friend class internal::TestEventListenersAccessor;
-  friend class internal::UnitTestImpl;
-
-  // Returns repeater that broadcasts the TestEventListener events to all
-  // subscribers.
-  TestEventListener* repeater();
-
-  // Sets the default_result_printer attribute to the provided listener.
-  // The listener is also added to the listener list and previous
-  // default_result_printer is removed from it and deleted. The listener can
-  // also be NULL in which case it will not be added to the list. Does
-  // nothing if the previous and the current listener objects are the same.
-  void SetDefaultResultPrinter(TestEventListener* listener);
-
-  // Sets the default_xml_generator attribute to the provided listener.  The
-  // listener is also added to the listener list and previous
-  // default_xml_generator is removed from it and deleted. The listener can
-  // also be NULL in which case it will not be added to the list. Does
-  // nothing if the previous and the current listener objects are the same.
-  void SetDefaultXmlGenerator(TestEventListener* listener);
-
-  // Controls whether events will be forwarded by the repeater to the
-  // listeners in the list.
-  bool EventForwardingEnabled() const;
-  void SuppressEventForwarding();
-
-  // The actual list of listeners.
-  internal::TestEventRepeater* repeater_;
-  // Listener responsible for the standard result output.
-  TestEventListener* default_result_printer_;
-  // Listener responsible for the creation of the XML output file.
-  TestEventListener* default_xml_generator_;
-
-  // We disallow copying TestEventListeners.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
-};
-
-// A UnitTest consists of a vector of TestCases.
-//
-// This is a singleton class.  The only instance of UnitTest is
-// created when UnitTest::GetInstance() is first called.  This
-// instance is never deleted.
-//
-// UnitTest is not copyable.
-//
-// This class is thread-safe as long as the methods are called
-// according to their specification.
-class GTEST_API_ UnitTest {
- public:
-  // Gets the singleton UnitTest object.  The first time this method
-  // is called, a UnitTest object is constructed and returned.
-  // Consecutive calls will return the same object.
-  static UnitTest* GetInstance();
-
-  // Runs all tests in this UnitTest object and prints the result.
-  // Returns 0 if successful, or 1 otherwise.
-  //
-  // This method can only be called from the main thread.
-  //
-  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  int Run() GTEST_MUST_USE_RESULT_;
-
-  // Returns the working directory when the first TEST() or TEST_F()
-  // was executed.  The UnitTest object owns the string.
-  const char* original_working_dir() const;
-
-  // Returns the TestCase object for the test that's currently running,
-  // or NULL if no test is running.
-  const TestCase* current_test_case() const
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Returns the TestInfo object for the test that's currently running,
-  // or NULL if no test is running.
-  const TestInfo* current_test_info() const
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Returns the random seed used at the start of the current test run.
-  int random_seed() const;
-
-#if GTEST_HAS_PARAM_TEST
-  // Returns the ParameterizedTestCaseRegistry object used to keep track of
-  // value-parameterized tests and instantiate and register them.
-  //
-  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  internal::ParameterizedTestCaseRegistry& parameterized_test_registry()
-      GTEST_LOCK_EXCLUDED_(mutex_);
-#endif  // GTEST_HAS_PARAM_TEST
-
-  // Gets the number of successful test cases.
-  int successful_test_case_count() const;
-
-  // Gets the number of failed test cases.
-  int failed_test_case_count() const;
-
-  // Gets the number of all test cases.
-  int total_test_case_count() const;
-
-  // Gets the number of all test cases that contain at least one test
-  // that should run.
-  int test_case_to_run_count() const;
-
-  // Gets the number of successful tests.
-  int successful_test_count() const;
-
-  // Gets the number of failed tests.
-  int failed_test_count() const;
-
-  // Gets the number of disabled tests that will be reported in the XML report.
-  int reportable_disabled_test_count() const;
-
-  // Gets the number of disabled tests.
-  int disabled_test_count() const;
-
-  // Gets the number of tests to be printed in the XML report.
-  int reportable_test_count() const;
-
-  // Gets the number of all tests.
-  int total_test_count() const;
-
-  // Gets the number of tests that should run.
-  int test_to_run_count() const;
-
-  // Gets the time of the test program start, in ms from the start of the
-  // UNIX epoch.
-  TimeInMillis start_timestamp() const;
-
-  // Gets the elapsed time, in milliseconds.
-  TimeInMillis elapsed_time() const;
-
-  // Returns true iff the unit test passed (i.e. all test cases passed).
-  bool Passed() const;
-
-  // Returns true iff the unit test failed (i.e. some test case failed
-  // or something outside of all tests failed).
-  bool Failed() const;
-
-  // Gets the i-th test case among all the test cases. i can range from 0 to
-  // total_test_case_count() - 1. If i is not in that range, returns NULL.
-  const TestCase* GetTestCase(int i) const;
-
-  // Returns the TestResult containing information on test failures and
-  // properties logged outside of individual test cases.
-  const TestResult& ad_hoc_test_result() const;
-
-  // Returns the list of event listeners that can be used to track events
-  // inside Google Test.
-  TestEventListeners& listeners();
-
- private:
-  // Registers and returns a global test environment.  When a test
-  // program is run, all global test environments will be set-up in
-  // the order they were registered.  After all tests in the program
-  // have finished, all global test environments will be torn-down in
-  // the *reverse* order they were registered.
-  //
-  // The UnitTest object takes ownership of the given environment.
-  //
-  // This method can only be called from the main thread.
-  Environment* AddEnvironment(Environment* env);
-
-  // Adds a TestPartResult to the current TestResult object.  All
-  // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
-  // eventually call this to report their results.  The user code
-  // should use the assertion macros instead of calling this directly.
-  void AddTestPartResult(TestPartResult::Type result_type,
-                         const char* file_name,
-                         int line_number,
-                         const std::string& message,
-                         const std::string& os_stack_trace)
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Adds a TestProperty to the current TestResult object when invoked from
-  // inside a test, to current TestCase's ad_hoc_test_result_ when invoked
-  // from SetUpTestCase or TearDownTestCase, 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 case among all the test cases. i can range from 0 to
-  // total_test_case_count() - 1. If i is not in that range, returns NULL.
-  TestCase* GetMutableTestCase(int i);
-
-  // Accessors for the implementation object.
-  internal::UnitTestImpl* impl() { return impl_; }
-  const internal::UnitTestImpl* impl() const { return impl_; }
-
-  // These classes and funcions are friends as they need to access private
-  // members of UnitTest.
-  friend class Test;
-  friend class internal::AssertHelper;
-  friend class internal::ScopedTrace;
-  friend class internal::StreamingListenerTest;
-  friend class internal::UnitTestRecordPropertyTestHelper;
-  friend Environment* AddGlobalTestEnvironment(Environment* env);
-  friend internal::UnitTestImpl* internal::GetUnitTestImpl();
-  friend void internal::ReportFailureInUnknownLocation(
-      TestPartResult::Type result_type,
-      const std::string& message);
-
-  // Creates an empty UnitTest.
-  UnitTest();
-
-  // D'tor
-  virtual ~UnitTest();
-
-  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
-  // Google Test trace stack.
-  void PushGTestTrace(const internal::TraceInfo& trace)
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Pops a trace from the per-thread Google Test trace stack.
-  void PopGTestTrace()
-      GTEST_LOCK_EXCLUDED_(mutex_);
-
-  // Protects mutable state in *impl_.  This is mutable as some const
-  // methods need to lock it too.
-  mutable internal::Mutex mutex_;
-
-  // Opaque implementation object.  This field is never changed once
-  // the object is constructed.  We don't mark it as const here, as
-  // doing so will cause a warning in the constructor of UnitTest.
-  // Mutable state in *impl_ is protected by mutex_.
-  internal::UnitTestImpl* impl_;
-
-  // We disallow copying UnitTest.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
-};
-
-// A convenient wrapper for adding an environment for the test
-// program.
-//
-// You should call this before RUN_ALL_TESTS() is called, probably in
-// main().  If you use gtest_main, you need to call this before main()
-// starts for it to take effect.  For example, you can define a global
-// variable like this:
-//
-//   testing::Environment* const foo_env =
-//       testing::AddGlobalTestEnvironment(new FooEnvironment);
-//
-// However, we strongly recommend you to write your own main() and
-// call AddGlobalTestEnvironment() there, as relying on initialization
-// of global variables makes the code harder to read and may cause
-// problems when you register multiple environments from different
-// translation units and the environments have dependencies among them
-// (remember that the compiler doesn't guarantee the order in which
-// global variables from different translation units are initialized).
-inline Environment* AddGlobalTestEnvironment(Environment* env) {
-  return UnitTest::GetInstance()->AddEnvironment(env);
-}
-
-// Initializes Google Test.  This must be called before calling
-// RUN_ALL_TESTS().  In particular, it parses a command line for the
-// flags that Google Test recognizes.  Whenever a Google Test flag is
-// seen, it is removed from argv, and *argc is decremented.
-//
-// No value is returned.  Instead, the Google Test flag variables are
-// updated.
-//
-// Calling the function for the second time has no user-visible effect.
-GTEST_API_ void InitGoogleTest(int* argc, char** argv);
-
-// This overloaded version can be used in Windows programs compiled in
-// UNICODE mode.
-GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
-
-namespace internal {
-
-// Separate the error generating code from the code path to reduce the stack
-// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers
-// when calling EXPECT_* in a tight loop.
-template <typename T1, typename T2>
-AssertionResult CmpHelperEQFailure(const char* lhs_expression,
-                                   const char* rhs_expression,
-                                   const T1& lhs, const T2& rhs) {
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   FormatForComparisonFailureMessage(lhs, rhs),
-                   FormatForComparisonFailureMessage(rhs, lhs),
-                   false);
-}
-
-// The helper function for {ASSERT|EXPECT}_EQ.
-template <typename T1, typename T2>
-AssertionResult CmpHelperEQ(const char* lhs_expression,
-                            const char* rhs_expression,
-                            const T1& lhs,
-                            const T2& rhs) {
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
-  if (lhs == rhs) {
-    return AssertionSuccess();
-  }
-GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-  return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
-}
-
-// With this overloaded version, we allow anonymous enums to be used
-// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
-// can be implicitly cast to BiggestInt.
-GTEST_API_ AssertionResult CmpHelperEQ(const char* lhs_expression,
-                                       const char* rhs_expression,
-                                       BiggestInt lhs,
-                                       BiggestInt rhs);
-
-// The helper class for {ASSERT|EXPECT}_EQ.  The template argument
-// lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
-// is a null pointer literal.  The following default implementation is
-// for lhs_is_null_literal being false.
-template <bool lhs_is_null_literal>
-class EqHelper {
- public:
-  // This templatized version is for the general case.
-  template <typename T1, typename T2>
-  static AssertionResult Compare(const char* lhs_expression,
-                                 const char* rhs_expression,
-                                 const T1& lhs,
-                                 const T2& rhs) {
-    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
-  }
-
-  // With this overloaded version, we allow anonymous enums to be used
-  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
-  // enums can be implicitly cast to BiggestInt.
-  //
-  // Even though its body looks the same as the above version, we
-  // cannot merge the two, as it will make anonymous enums unhappy.
-  static AssertionResult Compare(const char* lhs_expression,
-                                 const char* rhs_expression,
-                                 BiggestInt lhs,
-                                 BiggestInt rhs) {
-    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
-  }
-};
-
-// This specialization is used when the first argument to ASSERT_EQ()
-// is a null pointer literal, like NULL, false, or 0.
-template <>
-class EqHelper<true> {
- public:
-  // We define two overloaded versions of Compare().  The first
-  // version will be picked when the second argument to ASSERT_EQ() is
-  // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or
-  // EXPECT_EQ(false, a_bool).
-  template <typename T1, typename T2>
-  static AssertionResult Compare(
-      const char* lhs_expression,
-      const char* rhs_expression,
-      const T1& lhs,
-      const T2& rhs,
-      // The following line prevents this overload from being considered if T2
-      // is not a pointer type.  We need this because ASSERT_EQ(NULL, my_ptr)
-      // expands to Compare("", "", NULL, my_ptr), which requires a conversion
-      // to match the Secret* in the other overload, which would otherwise make
-      // this template match better.
-      typename EnableIf<!is_pointer<T2>::value>::type* = 0) {
-    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
-  }
-
-  // This version will be picked when the second argument to ASSERT_EQ() is a
-  // pointer, e.g. ASSERT_EQ(NULL, a_pointer).
-  template <typename T>
-  static AssertionResult Compare(
-      const char* lhs_expression,
-      const char* rhs_expression,
-      // We used to have a second template parameter instead of Secret*.  That
-      // template parameter would deduce to 'long', making this a better match
-      // than the first overload even without the first overload's EnableIf.
-      // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to
-      // non-pointer argument" (even a deduced integral argument), so the old
-      // implementation caused warnings in user code.
-      Secret* /* lhs (NULL) */,
-      T* rhs) {
-    // We already know that 'lhs' is a null pointer.
-    return CmpHelperEQ(lhs_expression, rhs_expression,
-                       static_cast<T*>(NULL), rhs);
-  }
-};
-
-// Separate the error generating code from the code path to reduce the stack
-// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers
-// when calling EXPECT_OP in a tight loop.
-template <typename T1, typename T2>
-AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
-                                   const T1& val1, const T2& val2,
-                                   const char* op) {
-  return AssertionFailure()
-         << "Expected: (" << expr1 << ") " << op << " (" << expr2
-         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
-         << " vs " << FormatForComparisonFailureMessage(val2, val1);
-}
-
-// A macro for implementing the helper functions needed to implement
-// ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
-// of similar code.
-//
-// For each templatized helper function, we also define an overloaded
-// version for BiggestInt in order to reduce code bloat and allow
-// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
-// with gcc 4.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-
-#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
-template <typename T1, typename T2>\
-AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
-                                   const T1& val1, const T2& val2) {\
-  if (val1 op val2) {\
-    return AssertionSuccess();\
-  } else {\
-    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
-  }\
-}\
-GTEST_API_ AssertionResult CmpHelper##op_name(\
-    const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-
-// Implements the helper function for {ASSERT|EXPECT}_NE
-GTEST_IMPL_CMP_HELPER_(NE, !=);
-// Implements the helper function for {ASSERT|EXPECT}_LE
-GTEST_IMPL_CMP_HELPER_(LE, <=);
-// Implements the helper function for {ASSERT|EXPECT}_LT
-GTEST_IMPL_CMP_HELPER_(LT, <);
-// Implements the helper function for {ASSERT|EXPECT}_GE
-GTEST_IMPL_CMP_HELPER_(GE, >=);
-// Implements the helper function for {ASSERT|EXPECT}_GT
-GTEST_IMPL_CMP_HELPER_(GT, >);
-
-#undef GTEST_IMPL_CMP_HELPER_
-
-// The helper function for {ASSERT|EXPECT}_STREQ.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
-                                          const char* s2_expression,
-                                          const char* s1,
-                                          const char* s2);
-
-// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression,
-                                              const char* s2_expression,
-                                              const char* s1,
-                                              const char* s2);
-
-// The helper function for {ASSERT|EXPECT}_STRNE.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                                          const char* s2_expression,
-                                          const char* s1,
-                                          const char* s2);
-
-// The helper function for {ASSERT|EXPECT}_STRCASENE.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
-                                              const char* s2_expression,
-                                              const char* s1,
-                                              const char* s2);
-
-
-// Helper function for *_STREQ on wide strings.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
-                                          const char* s2_expression,
-                                          const wchar_t* s1,
-                                          const wchar_t* s2);
-
-// Helper function for *_STRNE on wide strings.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                                          const char* s2_expression,
-                                          const wchar_t* s1,
-                                          const wchar_t* s2);
-
-}  // namespace internal
-
-// IsSubstring() and IsNotSubstring() are intended to be used as the
-// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
-// themselves.  They check whether needle is a substring of haystack
-// (NULL is considered a substring of itself only), and return an
-// appropriate error message when they fail.
-//
-// The {needle,haystack}_expr arguments are the stringified
-// expressions that generated the two real arguments.
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack);
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack);
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack);
-
-#if GTEST_HAS_STD_WSTRING
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack);
-#endif  // GTEST_HAS_STD_WSTRING
-
-namespace internal {
-
-// Helper template function for comparing floating-points.
-//
-// Template parameter:
-//
-//   RawType: the raw floating-point type (either float or double)
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-template <typename RawType>
-AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
-                                         const char* rhs_expression,
-                                         RawType lhs_value,
-                                         RawType rhs_value) {
-  const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);
-
-  if (lhs.AlmostEquals(rhs)) {
-    return AssertionSuccess();
-  }
-
-  ::std::stringstream lhs_ss;
-  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
-         << lhs_value;
-
-  ::std::stringstream rhs_ss;
-  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
-         << rhs_value;
-
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   StringStreamToString(&lhs_ss),
-                   StringStreamToString(&rhs_ss),
-                   false);
-}
-
-// Helper function for implementing ASSERT_NEAR.
-//
-// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
-                                                const char* expr2,
-                                                const char* abs_error_expr,
-                                                double val1,
-                                                double val2,
-                                                double abs_error);
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-// A class that enables one to stream messages to assertion macros
-class GTEST_API_ AssertHelper {
- public:
-  // Constructor.
-  AssertHelper(TestPartResult::Type type,
-               const char* file,
-               int line,
-               const char* message);
-  ~AssertHelper();
-
-  // Message assignment is a semantic trick to enable assertion
-  // streaming; see the GTEST_MESSAGE_ macro below.
-  void operator=(const Message& message) const;
-
- private:
-  // We put our data in a struct so that the size of the AssertHelper class can
-  // be as small as possible.  This is important because gcc is incapable of
-  // re-using stack space even for temporary variables, so every EXPECT_EQ
-  // reserves stack space for another AssertHelper.
-  struct AssertHelperData {
-    AssertHelperData(TestPartResult::Type t,
-                     const char* srcfile,
-                     int line_num,
-                     const char* msg)
-        : type(t), file(srcfile), line(line_num), message(msg) { }
-
-    TestPartResult::Type const type;
-    const char* const file;
-    int const line;
-    std::string const message;
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
-  };
-
-  AssertHelperData* const data_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
-};
-
-}  // namespace internal
-
-#if GTEST_HAS_PARAM_TEST
-// The pure interface class that all value-parameterized tests inherit from.
-// A value-parameterized class must inherit from both ::testing::Test and
-// ::testing::WithParamInterface. In most cases that just means inheriting
-// from ::testing::TestWithParam, but more complicated test hierarchies
-// may need to inherit from Test and WithParamInterface at different levels.
-//
-// This interface has support for accessing the test parameter value via
-// the GetParam() method.
-//
-// Use it with one of the parameter generator defining functions, like Range(),
-// Values(), ValuesIn(), Bool(), and Combine().
-//
-// class FooTest : public ::testing::TestWithParam<int> {
-//  protected:
-//   FooTest() {
-//     // Can use GetParam() here.
-//   }
-//   virtual ~FooTest() {
-//     // Can use GetParam() here.
-//   }
-//   virtual void SetUp() {
-//     // Can use GetParam() here.
-//   }
-//   virtual void TearDown {
-//     // Can use GetParam() here.
-//   }
-// };
-// TEST_P(FooTest, DoesBar) {
-//   // Can use GetParam() method here.
-//   Foo foo;
-//   ASSERT_TRUE(foo.DoesBar(GetParam()));
-// }
-// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
-
-template <typename T>
-class WithParamInterface {
- public:
-  typedef T ParamType;
-  virtual ~WithParamInterface() {}
-
-  // The current parameter value. Is also available in the test fixture's
-  // constructor. This member function is non-static, even though it only
-  // references static data, to reduce the opportunity for incorrect uses
-  // like writing 'WithParamInterface<bool>::GetParam()' for a test that
-  // uses a fixture whose parameter type is int.
-  const ParamType& GetParam() const {
-    GTEST_CHECK_(parameter_ != NULL)
-        << "GetParam() can only be called inside a value-parameterized test "
-        << "-- did you intend to write TEST_P instead of TEST_F?";
-    return *parameter_;
-  }
-
- private:
-  // Sets parameter value. The caller is responsible for making sure the value
-  // remains alive and unchanged throughout the current test.
-  static void SetParam(const ParamType* parameter) {
-    parameter_ = parameter;
-  }
-
-  // Static value used for accessing parameter during a test lifetime.
-  static const ParamType* parameter_;
-
-  // TestClass must be a subclass of WithParamInterface<T> and Test.
-  template <class TestClass> friend class internal::ParameterizedTestFactory;
-};
-
-template <typename T>
-const T* WithParamInterface<T>::parameter_ = NULL;
-
-// Most value-parameterized classes can ignore the existence of
-// WithParamInterface, and can just inherit from ::testing::TestWithParam.
-
-template <typename T>
-class TestWithParam : public Test, public WithParamInterface<T> {
-};
-
-#endif  // GTEST_HAS_PARAM_TEST
-
-// Macros for indicating success/failure in test code.
-
-// ADD_FAILURE unconditionally adds a failure to the current test.
-// SUCCEED generates a success - it doesn't automatically make the
-// current test successful, as a test is only successful when it has
-// no failure.
-//
-// EXPECT_* verifies that a certain condition is satisfied.  If not,
-// it behaves like ADD_FAILURE.  In particular:
-//
-//   EXPECT_TRUE  verifies that a Boolean condition is true.
-//   EXPECT_FALSE verifies that a Boolean condition is false.
-//
-// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
-// that they will also abort the current function on failure.  People
-// usually want the fail-fast behavior of FAIL and ASSERT_*, but those
-// writing data-driven tests often find themselves using ADD_FAILURE
-// and EXPECT_* more.
-
-// Generates a nonfatal failure with a generic message.
-#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
-
-// Generates a nonfatal failure at the given source file location with
-// a generic message.
-#define ADD_FAILURE_AT(file, line) \
-  GTEST_MESSAGE_AT_(file, line, "Failed", \
-                    ::testing::TestPartResult::kNonFatalFailure)
-
-// Generates a fatal failure with a generic message.
-#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
-
-// Define this macro to 1 to omit the definition of FAIL(), which is a
-// generic name and clashes with some other libraries.
-#if !GTEST_DONT_DEFINE_FAIL
-# define FAIL() GTEST_FAIL()
-#endif
-
-// Generates a success with a generic message.
-#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
-
-// Define this macro to 1 to omit the definition of SUCCEED(), which
-// is a generic name and clashes with some other libraries.
-#if !GTEST_DONT_DEFINE_SUCCEED
-# define SUCCEED() GTEST_SUCCEED()
-#endif
-
-// Macros for testing exceptions.
-//
-//    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
-//         Tests that the statement throws the expected exception.
-//    * {ASSERT|EXPECT}_NO_THROW(statement):
-//         Tests that the statement doesn't throw any exception.
-//    * {ASSERT|EXPECT}_ANY_THROW(statement):
-//         Tests that the statement throws an exception.
-
-#define EXPECT_THROW(statement, expected_exception) \
-  GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_NO_THROW(statement) \
-  GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_ANY_THROW(statement) \
-  GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_THROW(statement, expected_exception) \
-  GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
-#define ASSERT_NO_THROW(statement) \
-  GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
-#define ASSERT_ANY_THROW(statement) \
-  GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
-
-// Boolean assertions. Condition can be either a Boolean expression or an
-// AssertionResult. For more information on how to use AssertionResult with
-// these macros see comments on that class.
-#define EXPECT_TRUE(condition) \
-  GTEST_TEST_BOOLEAN_((condition), #condition, false, true, \
-                      GTEST_NONFATAL_FAILURE_)
-#define EXPECT_FALSE(condition) \
-  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
-                      GTEST_NONFATAL_FAILURE_)
-#define ASSERT_TRUE(condition) \
-  GTEST_TEST_BOOLEAN_((condition), #condition, false, true, \
-                      GTEST_FATAL_FAILURE_)
-#define ASSERT_FALSE(condition) \
-  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
-                      GTEST_FATAL_FAILURE_)
-
-// Includes the auto-generated header that implements a family of
-// generic predicate assertion macros.
-#include "gtest/gtest_pred_impl.h"
-
-// Macros for testing equalities and inequalities.
-//
-//    * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2
-//    * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2
-//    * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2
-//    * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2
-//    * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2
-//    * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2
-//
-// When they are not, Google Test prints both the tested expressions and
-// their actual values.  The values must be compatible built-in types,
-// or you will get a compiler error.  By "compatible" we mean that the
-// values can be compared by the respective operator.
-//
-// Note:
-//
-//   1. It is possible to make a user-defined type work with
-//   {ASSERT|EXPECT}_??(), but that requires overloading the
-//   comparison operators and is thus discouraged by the Google C++
-//   Usage Guide.  Therefore, you are advised to use the
-//   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
-//   equal.
-//
-//   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
-//   pointers (in particular, C strings).  Therefore, if you use it
-//   with two C strings, you are testing how their locations in memory
-//   are related, not how their content is related.  To compare two C
-//   strings by content, use {ASSERT|EXPECT}_STR*().
-//
-//   3. {ASSERT|EXPECT}_EQ(v1, v2) is preferred to
-//   {ASSERT|EXPECT}_TRUE(v1 == v2), as the former tells you
-//   what the actual value is when it fails, and similarly for the
-//   other comparisons.
-//
-//   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
-//   evaluate their arguments, which is undefined.
-//
-//   5. These macros evaluate their arguments exactly once.
-//
-// Examples:
-//
-//   EXPECT_NE(5, Foo());
-//   EXPECT_EQ(NULL, a_pointer);
-//   ASSERT_LT(i, array_size);
-//   ASSERT_GT(records.size(), 0) << "There is no record left.";
-
-#define EXPECT_EQ(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal:: \
-                      EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
-                      val1, val2)
-#define EXPECT_NE(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
-#define EXPECT_LE(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
-#define EXPECT_LT(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
-#define EXPECT_GE(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
-#define EXPECT_GT(val1, val2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
-
-#define GTEST_ASSERT_EQ(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal:: \
-                      EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
-                      val1, val2)
-#define GTEST_ASSERT_NE(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
-#define GTEST_ASSERT_LE(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
-#define GTEST_ASSERT_LT(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
-#define GTEST_ASSERT_GE(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
-#define GTEST_ASSERT_GT(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
-
-// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
-// ASSERT_XY(), which clashes with some users' own code.
-
-#if !GTEST_DONT_DEFINE_ASSERT_EQ
-# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_NE
-# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_LE
-# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_LT
-# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_GE
-# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_GT
-# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
-#endif
-
-// C-string Comparisons.  All tests treat NULL and any non-NULL string
-// as different.  Two NULLs are equal.
-//
-//    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
-//    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
-//    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
-//    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
-//
-// For wide or narrow string objects, you can use the
-// {ASSERT|EXPECT}_??() macros.
-//
-// Don't depend on the order in which the arguments are evaluated,
-// which is undefined.
-//
-// These macros evaluate their arguments exactly once.
-
-#define EXPECT_STREQ(s1, s2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
-#define EXPECT_STRNE(s1, s2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
-#define EXPECT_STRCASEEQ(s1, s2) \
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
-#define EXPECT_STRCASENE(s1, s2)\
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
-
-#define ASSERT_STREQ(s1, s2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
-#define ASSERT_STRNE(s1, s2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
-#define ASSERT_STRCASEEQ(s1, s2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
-#define ASSERT_STRCASENE(s1, s2)\
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
-
-// Macros for comparing floating-point numbers.
-//
-//    * {ASSERT|EXPECT}_FLOAT_EQ(val1, val2):
-//         Tests that two float values are almost equal.
-//    * {ASSERT|EXPECT}_DOUBLE_EQ(val1, val2):
-//         Tests that two double values are almost equal.
-//    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
-//         Tests that v1 and v2 are within the given distance to each other.
-//
-// Google Test uses ULP-based comparison to automatically pick a default
-// error bound that is appropriate for the operands.  See the
-// FloatingPoint template class in gtest-internal.h if you are
-// interested in the implementation details.
-
-#define EXPECT_FLOAT_EQ(val1, val2)\
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
-                      val1, val2)
-
-#define EXPECT_DOUBLE_EQ(val1, val2)\
-  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
-                      val1, val2)
-
-#define ASSERT_FLOAT_EQ(val1, val2)\
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
-                      val1, val2)
-
-#define ASSERT_DOUBLE_EQ(val1, val2)\
-  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
-                      val1, val2)
-
-#define EXPECT_NEAR(val1, val2, abs_error)\
-  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
-                      val1, val2, abs_error)
-
-#define ASSERT_NEAR(val1, val2, abs_error)\
-  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
-                      val1, val2, abs_error)
-
-// These predicate format functions work on floating-point values, and
-// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
-//
-//   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
-
-// Asserts that val1 is less than, or almost equal to, val2.  Fails
-// otherwise.  In particular, it fails if either val1 or val2 is NaN.
-GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
-                                   float val1, float val2);
-GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
-                                    double val1, double val2);
-
-
-#if GTEST_OS_WINDOWS
-
-// Macros that test for HRESULT failure and success, these are only useful
-// on Windows, and rely on Windows SDK macros and APIs to compile.
-//
-//    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
-//
-// When expr unexpectedly fails or succeeds, Google Test prints the
-// expected result and the actual result with both a human-readable
-// string representation of the error, if available, as well as the
-// hex result code.
-# define EXPECT_HRESULT_SUCCEEDED(expr) \
-    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
-
-# define ASSERT_HRESULT_SUCCEEDED(expr) \
-    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
-
-# define EXPECT_HRESULT_FAILED(expr) \
-    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
-
-# define ASSERT_HRESULT_FAILED(expr) \
-    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
-
-#endif  // GTEST_OS_WINDOWS
-
-// Macros that execute statement and check that it doesn't generate new fatal
-// failures in the current thread.
-//
-//   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
-//
-// Examples:
-//
-//   EXPECT_NO_FATAL_FAILURE(Process());
-//   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
-//
-#define ASSERT_NO_FATAL_FAILURE(statement) \
-    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
-#define EXPECT_NO_FATAL_FAILURE(statement) \
-    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
-
-// Causes a trace (including the source file path, the current line
-// number, and the given message) to be included in every test failure
-// message generated by code in the current scope.  The effect is
-// undone when the control leaves the current scope.
-//
-// The message argument can be anything streamable to std::ostream.
-//
-// In the implementation, we include the current line number as part
-// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
-// to appear in the same block - as long as they are on different
-// lines.
-#define SCOPED_TRACE(message) \
-  ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
-    __FILE__, __LINE__, ::testing::Message() << (message))
-
-// Compile-time assertion for type equality.
-// StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
-// the same type.  The value it returns is not interesting.
-//
-// Instead of making StaticAssertTypeEq a class template, we make it a
-// function template that invokes a helper class template.  This
-// prevents a user from misusing StaticAssertTypeEq<T1, T2> by
-// defining objects of that type.
-//
-// CAVEAT:
-//
-// When used inside a method of a class template,
-// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
-// instantiated.  For example, given:
-//
-//   template <typename T> class Foo {
-//    public:
-//     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
-//   };
-//
-// the code:
-//
-//   void Test1() { Foo<bool> foo; }
-//
-// will NOT generate a compiler error, as Foo<bool>::Bar() is never
-// actually instantiated.  Instead, you need:
-//
-//   void Test2() { Foo<bool> foo; foo.Bar(); }
-//
-// to cause a compiler error.
-template <typename T1, typename T2>
-bool StaticAssertTypeEq() {
-  (void)internal::StaticAssertTypeEqHelper<T1, T2>();
-  return true;
-}
-
-// Defines a test.
-//
-// The first parameter is the name of the test case, and the second
-// parameter is the name of the test within the test case.
-//
-// The convention is to end the test case name with "Test".  For
-// example, a test case for the Foo class can be named FooTest.
-//
-// Test code should appear between braces after an invocation of
-// this macro.  Example:
-//
-//   TEST(FooTest, InitializesCorrectly) {
-//     Foo foo;
-//     EXPECT_TRUE(foo.StatusIsOK());
-//   }
-
-// Note that we call GetTestTypeId() instead of GetTypeId<
-// ::testing::Test>() here to get the type ID of testing::Test.  This
-// is to work around a suspected linker bug when using Google Test as
-// a framework on Mac OS X.  The bug causes GetTypeId<
-// ::testing::Test>() to return different values depending on whether
-// the call is from the Google Test framework itself or from user test
-// code.  GetTestTypeId() is guaranteed to always return the same
-// value, as it always calls GetTypeId<>() from the Google Test
-// framework.
-#define GTEST_TEST(test_case_name, test_name)\
-  GTEST_TEST_(test_case_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_case_name, test_name) GTEST_TEST(test_case_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 case name.  The second parameter is the
-// name of the test within the test case.
-//
-// A test fixture class must be declared earlier.  The user should put
-// his test code between braces after using this macro.  Example:
-//
-//   class FooTest : public testing::Test {
-//    protected:
-//     virtual void SetUp() { b_.AddElement(3); }
-//
-//     Foo a_;
-//     Foo b_;
-//   };
-//
-//   TEST_F(FooTest, InitializesCorrectly) {
-//     EXPECT_TRUE(a_.StatusIsOK());
-//   }
-//
-//   TEST_F(FooTest, ReturnsElementCountCorrectly) {
-//     EXPECT_EQ(0, a_.size());
-//     EXPECT_EQ(1, b_.size());
-//   }
-
-#define TEST_F(test_fixture, test_name)\
-  GTEST_TEST_(test_fixture, test_name, test_fixture, \
-              ::testing::internal::GetTypeId<test_fixture>())
-
-}  // namespace testing
-
-// Use this function in main() to run all tests.  It returns 0 if all
-// tests are successful, or 1 otherwise.
-//
-// RUN_ALL_TESTS() should be invoked after the command line has been
-// parsed by InitGoogleTest().
-//
-// This function was formerly a macro; thus, it is in the global
-// namespace and has an all-caps name.
-int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
-
-inline int RUN_ALL_TESTS() {
-  return ::testing::UnitTest::GetInstance()->Run();
-}
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_pred_impl.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_pred_impl.h
deleted file mode 100644
index 30ae712f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_pred_impl.h
+++ /dev/null
@@ -1,358 +0,0 @@
-// Copyright 2006, 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.
-
-// This file is AUTOMATICALLY GENERATED on 10/31/2011 by command
-// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
-//
-// Implements a family of generic predicate assertion macros.
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
-#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
-
-// Makes sure this header is not included before gtest.h.
-#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
-# error Do not include gtest_pred_impl.h directly.  Include gtest.h instead.
-#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
-
-// This header implements a family of generic predicate assertion
-// macros:
-//
-//   ASSERT_PRED_FORMAT1(pred_format, v1)
-//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
-//   ...
-//
-// where pred_format is a function or functor that takes n (in the
-// case of ASSERT_PRED_FORMATn) values and their source expression
-// text, and returns a testing::AssertionResult.  See the definition
-// of ASSERT_EQ in gtest.h for an example.
-//
-// If you don't care about formatting, you can use the more
-// restrictive version:
-//
-//   ASSERT_PRED1(pred, v1)
-//   ASSERT_PRED2(pred, v1, v2)
-//   ...
-//
-// where pred is an n-ary function or functor that returns bool,
-// and the values v1, v2, ..., must support the << operator for
-// streaming to std::ostream.
-//
-// We also define the EXPECT_* variations.
-//
-// For now we only support predicates whose arity is at most 5.
-// Please email googletestframework@googlegroups.com if you need
-// support for higher arities.
-
-// GTEST_ASSERT_ is the basic statement to which all of the assertions
-// in this file reduce.  Don't use this in your code.
-
-#define GTEST_ASSERT_(expression, on_failure) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (const ::testing::AssertionResult gtest_ar = (expression)) \
-    ; \
-  else \
-    on_failure(gtest_ar.failure_message())
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1>
-AssertionResult AssertPred1Helper(const char* pred_text,
-                                  const char* e1,
-                                  Pred pred,
-                                  const T1& v1) {
-  if (pred(v1)) return AssertionSuccess();
-
-  return AssertionFailure() << pred_text << "("
-                            << e1 << ") evaluates to false, where"
-                            << "\n" << e1 << " evaluates to " << v1;
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, v1), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
-// this in your code.
-#define GTEST_PRED1_(pred, v1, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
-                                             #v1, \
-                                             pred, \
-                                             v1), on_failure)
-
-// Unary predicate assertion macros.
-#define EXPECT_PRED_FORMAT1(pred_format, v1) \
-  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED1(pred, v1) \
-  GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT1(pred_format, v1) \
-  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED1(pred, v1) \
-  GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
-
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2>
-AssertionResult AssertPred2Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2) {
-  if (pred(v1, v2)) return AssertionSuccess();
-
-  return AssertionFailure() << pred_text << "("
-                            << e1 << ", "
-                            << e2 << ") evaluates to false, where"
-                            << "\n" << e1 << " evaluates to " << v1
-                            << "\n" << e2 << " evaluates to " << v2;
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
-// this in your code.
-#define GTEST_PRED2_(pred, v1, v2, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             pred, \
-                                             v1, \
-                                             v2), on_failure)
-
-// Binary predicate assertion macros.
-#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
-  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED2(pred, v1, v2) \
-  GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
-  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED2(pred, v1, v2) \
-  GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
-
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2,
-          typename T3>
-AssertionResult AssertPred3Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  const char* e3,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2,
-                                  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 " << v1
-                            << "\n" << e2 << " evaluates to " << v2
-                            << "\n" << e3 << " evaluates to " << v3;
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
-// this in your code.
-#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             #v3, \
-                                             pred, \
-                                             v1, \
-                                             v2, \
-                                             v3), on_failure)
-
-// Ternary predicate assertion macros.
-#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
-  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED3(pred, v1, v2, v3) \
-  GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
-  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED3(pred, v1, v2, v3) \
-  GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
-
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4>
-AssertionResult AssertPred4Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  const char* e3,
-                                  const char* e4,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2,
-                                  const T3& v3,
-                                  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 " << v1
-                            << "\n" << e2 << " evaluates to " << v2
-                            << "\n" << e3 << " evaluates to " << v3
-                            << "\n" << e4 << " evaluates to " << v4;
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
-// this in your code.
-#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             #v3, \
-                                             #v4, \
-                                             pred, \
-                                             v1, \
-                                             v2, \
-                                             v3, \
-                                             v4), on_failure)
-
-// 4-ary predicate assertion macros.
-#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
-  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED4(pred, v1, v2, v3, v4) \
-  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
-  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED4(pred, v1, v2, v3, v4) \
-  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
-
-
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
-// this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5>
-AssertionResult AssertPred5Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  const char* e3,
-                                  const char* e4,
-                                  const char* e5,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2,
-                                  const T3& v3,
-                                  const T4& v4,
-                                  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 " << v1
-                            << "\n" << e2 << " evaluates to " << v2
-                            << "\n" << e3 << " evaluates to " << v3
-                            << "\n" << e4 << " evaluates to " << v4
-                            << "\n" << e5 << " evaluates to " << v5;
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
-// this in your code.
-#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             #v3, \
-                                             #v4, \
-                                             #v5, \
-                                             pred, \
-                                             v1, \
-                                             v2, \
-                                             v3, \
-                                             v4, \
-                                             v5), on_failure)
-
-// 5-ary predicate assertion macros.
-#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
-  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
-  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
-  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
-  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
-
-
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_prod.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_prod.h
deleted file mode 100644
index da80ddc6..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/gtest_prod.h
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2006, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Google C++ Testing Framework definitions useful in production code.
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_
-#define GTEST_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
-// class.  For example:
-//
-// class MyClass {
-//  private:
-//   void MyMethod();
-//   FRIEND_TEST(MyClassTest, MyMethod);
-// };
-//
-// class MyClassTest : public testing::Test {
-//   // ...
-// };
-//
-// TEST_F(MyClassTest, MyMethod) {
-//   // Can call MyClass::MyMethod() here.
-// }
-
-#define FRIEND_TEST(test_case_name, test_name)\
-friend class test_case_name##_##test_name##_Test
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PROD_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-port.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-port.h
deleted file mode 100644
index 7e744bd3..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-port.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright 2015, 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.
-//
-// Injection point for custom user configurations.
-// The following macros can be defined:
-//
-//   Flag related macros:
-//     GTEST_FLAG(flag_name)
-//     GTEST_USE_OWN_FLAGFILE_FLAG_  - Define to 0 when the system provides its
-//                                     own flagfile flag parsing.
-//     GTEST_DECLARE_bool_(name)
-//     GTEST_DECLARE_int32_(name)
-//     GTEST_DECLARE_string_(name)
-//     GTEST_DEFINE_bool_(name, default_val, doc)
-//     GTEST_DEFINE_int32_(name, default_val, doc)
-//     GTEST_DEFINE_string_(name, default_val, doc)
-//
-//   Test filtering:
-//     GTEST_TEST_FILTER_ENV_VAR_ - The name of an environment variable that
-//                                  will be used if --GTEST_FLAG(test_filter)
-//                                  is not provided.
-//
-//   Logging:
-//     GTEST_LOG_(severity)
-//     GTEST_CHECK_(condition)
-//     Functions LogToStderr() and FlushInfoLog() have to be provided too.
-//
-//   Threading:
-//     GTEST_HAS_NOTIFICATION_ - Enabled if Notification is already provided.
-//     GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ - Enabled if Mutex and ThreadLocal are
-//                                         already provided.
-//     Must also provide GTEST_DECLARE_STATIC_MUTEX_(mutex) and
-//     GTEST_DEFINE_STATIC_MUTEX_(mutex)
-//
-//     GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
-//     GTEST_LOCK_EXCLUDED_(locks)
-//
-// ** Custom implementation starts here **
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-printers.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-printers.h
deleted file mode 100644
index 60c1ea05..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest-printers.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2015, 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.
-//
-// This file provides an injection point for custom printers in a local
-// installation of gTest.
-// It will be included from gtest-printers.h and the overrides in this file
-// will be visible to everyone.
-// See documentation at gtest/gtest-printers.h for details on how to define a
-// custom printer.
-//
-// ** Custom implementation starts here **
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest.h
deleted file mode 100644
index c27412a8..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/custom/gtest.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2015, 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.
-//
-// Injection point for custom user configurations.
-// The following macros can be defined:
-//
-// GTEST_OS_STACK_TRACE_GETTER_  - The name of an implementation of
-//                                 OsStackTraceGetterInterface.
-//
-// ** Custom implementation starts here **
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
deleted file mode 100644
index 2b3a78f5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
+++ /dev/null
@@ -1,319 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This header file defines internal utilities needed for implementing
-// death tests.  They are subject to change without notice.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
-
-#include "gtest/internal/gtest-internal.h"
-
-#include <stdio.h>
-
-namespace testing {
-namespace internal {
-
-GTEST_DECLARE_string_(internal_run_death_test);
-
-// Names of the flags (needed for parsing Google Test flags).
-const char kDeathTestStyleFlag[] = "death_test_style";
-const char kDeathTestUseFork[] = "death_test_use_fork";
-const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
-
-#if GTEST_HAS_DEATH_TEST
-
-// 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
-// style, as defined by the --gtest_death_test_style and/or
-// --gtest_internal_run_death_test flags.
-
-// In describing the results of death tests, these terms are used with
-// the corresponding definitions:
-//
-// exit status:  The integer exit information in the format specified
-//               by wait(2)
-// exit code:    The integer code passed to exit(3), _exit(2), or
-//               returned from main()
-class GTEST_API_ DeathTest {
- public:
-  // Create returns false if there was an error determining the
-  // appropriate action to take for the current death test; for example,
-  // if the gtest_death_test_style flag is set to an invalid value.
-  // The LastMessage method will return a more detailed message in that
-  // case.  Otherwise, the DeathTest pointer pointed to by the "test"
-  // 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, const RE* regex,
-                     const char* file, int line, DeathTest** test);
-  DeathTest();
-  virtual ~DeathTest() { }
-
-  // A helper class that aborts a death test when it's deleted.
-  class ReturnSentinel {
-   public:
-    explicit ReturnSentinel(DeathTest* test) : test_(test) { }
-    ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
-   private:
-    DeathTest* const test_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
-  } GTEST_ATTRIBUTE_UNUSED_;
-
-  // An enumeration of possible roles that may be taken when a death
-  // test is encountered.  EXECUTE means that the death test logic should
-  // be executed immediately.  OVERSEE means that the program should prepare
-  // the appropriate environment for a child process to execute the death
-  // test, then wait for it to complete.
-  enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
-
-  // An enumeration of the three reasons that a test might be aborted.
-  enum AbortReason {
-    TEST_ENCOUNTERED_RETURN_STATEMENT,
-    TEST_THREW_EXCEPTION,
-    TEST_DID_NOT_DIE
-  };
-
-  // Assumes one of the above roles.
-  virtual TestRole AssumeRole() = 0;
-
-  // Waits for the death test to finish and returns its status.
-  virtual int Wait() = 0;
-
-  // Returns true if the death test passed; that is, the test process
-  // exited during the test, its exit status matches a user-supplied
-  // predicate, and its stderr output matches a user-supplied regular
-  // expression.
-  // The user-supplied predicate may be a macro expression rather
-  // than a function pointer or functor, or else Wait and Passed could
-  // be combined.
-  virtual bool Passed(bool exit_status_ok) = 0;
-
-  // Signals that the death test did not die as expected.
-  virtual void Abort(AbortReason reason) = 0;
-
-  // Returns a human-readable outcome message regarding the outcome of
-  // the last death test.
-  static const char* LastMessage();
-
-  static void set_last_death_test_message(const std::string& message);
-
- private:
-  // A string containing a description of the outcome of the last death test.
-  static std::string last_death_test_message_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
-};
-
-// Factory interface for death tests.  May be mocked out for testing.
-class DeathTestFactory {
- public:
-  virtual ~DeathTestFactory() { }
-  virtual bool Create(const char* statement, const RE* regex,
-                      const char* file, int line, DeathTest** test) = 0;
-};
-
-// A concrete DeathTestFactory implementation for normal use.
-class DefaultDeathTestFactory : public DeathTestFactory {
- public:
-  virtual bool Create(const char* statement, const RE* regex,
-                      const char* file, int line, DeathTest** test);
-};
-
-// 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);
-
-// Traps C++ exceptions escaping statement and reports them as test
-// failures. Note that trapping SEH exceptions is not implemented here.
-# if GTEST_HAS_EXCEPTIONS
-#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
-  try { \
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-  } catch (const ::std::exception& gtest_exception) { \
-    fprintf(\
-        stderr, \
-        "\n%s: Caught std::exception-derived exception escaping the " \
-        "death test statement. Exception message: %s\n", \
-        ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
-        gtest_exception.what()); \
-    fflush(stderr); \
-    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
-  } catch (...) { \
-    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
-  }
-
-# else
-#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
-  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
-
-# endif
-
-// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
-// ASSERT_EXIT*, and EXPECT_EXIT*.
-# define GTEST_DEATH_TEST_(statement, predicate, regex, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-    const ::testing::internal::RE& gtest_regex = (regex); \
-    ::testing::internal::DeathTest* gtest_dt; \
-    if (!::testing::internal::DeathTest::Create(#statement, &gtest_regex, \
-        __FILE__, __LINE__, &gtest_dt)) { \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
-    } \
-    if (gtest_dt != NULL) { \
-      ::testing::internal::scoped_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, the regex is
-// ignored, and the macro must accept a streamed message even though the message
-// is never printed.
-# define GTEST_EXECUTE_STATEMENT_(statement, regex) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-     GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-  } else \
-    ::testing::Message()
-
-// A class representing the parsed contents of the
-// --gtest_internal_run_death_test flag, as it existed when
-// RUN_ALL_TESTS was called.
-class InternalRunDeathTestFlag {
- public:
-  InternalRunDeathTestFlag(const std::string& a_file,
-                           int a_line,
-                           int an_index,
-                           int a_write_fd)
-      : file_(a_file), line_(a_line), index_(an_index),
-        write_fd_(a_write_fd) {}
-
-  ~InternalRunDeathTestFlag() {
-    if (write_fd_ >= 0)
-      posix::Close(write_fd_);
-  }
-
-  const std::string& file() const { return file_; }
-  int line() const { return line_; }
-  int index() const { return index_; }
-  int write_fd() const { return write_fd_; }
-
- private:
-  std::string file_;
-  int line_;
-  int index_;
-  int write_fd_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
-};
-
-// Returns a newly created InternalRunDeathTestFlag object with fields
-// initialized from the GTEST_FLAG(internal_run_death_test) flag if
-// the flag is specified; otherwise returns NULL.
-InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
-
-#else  // 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
-// iff 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.
-//
-// 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 iff 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()
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-filepath.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-filepath.h
deleted file mode 100644
index 7a13b4b0..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-filepath.h
+++ /dev/null
@@ -1,206 +0,0 @@
-// 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.
-//
-// Author: keith.ray@gmail.com (Keith Ray)
-//
-// Google Test filepath utilities
-//
-// 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>.
-// Do not include this header file separately!
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
-
-#include "gtest/internal/gtest-string.h"
-
-namespace testing {
-namespace internal {
-
-// FilePath - a class for file and directory pathname manipulation which
-// handles platform-specific conventions (like the pathname separator).
-// Used for helper functions for naming files in a directory for xml output.
-// Except for Set methods, all methods are const or static, which provides an
-// "immutable value object" -- useful for peace of mind.
-// A FilePath with a value ending in a path separator ("like/this/") represents
-// a directory, otherwise it is assumed to represent a file. In either case,
-// it may or may not represent an actual file or directory in the file system.
-// Names are NOT checked for syntax correctness -- no checking for illegal
-// characters, malformed paths, etc.
-
-class GTEST_API_ FilePath {
- public:
-  FilePath() : pathname_("") { }
-  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
-
-  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
-    Normalize();
-  }
-
-  FilePath& operator=(const FilePath& rhs) {
-    Set(rhs);
-    return *this;
-  }
-
-  void Set(const FilePath& rhs) {
-    pathname_ = rhs.pathname_;
-  }
-
-  const std::string& string() const { return pathname_; }
-  const char* c_str() const { return pathname_.c_str(); }
-
-  // Returns the current working directory, or "" if unsuccessful.
-  static FilePath GetCurrentDir();
-
-  // Given directory = "dir", base_name = "test", number = 0,
-  // extension = "xml", returns "dir/test.xml". If number is greater
-  // than zero (e.g., 12), returns "dir/test_12.xml".
-  // On Windows platform, uses \ as the separator rather than /.
-  static FilePath MakeFileName(const FilePath& directory,
-                               const FilePath& base_name,
-                               int number,
-                               const char* extension);
-
-  // Given directory = "dir", relative_path = "test.xml",
-  // returns "dir/test.xml".
-  // On Windows, uses \ as the separator rather than /.
-  static FilePath ConcatPaths(const FilePath& directory,
-                              const FilePath& relative_path);
-
-  // Returns a pathname for a file that does not currently exist. The pathname
-  // will be directory/base_name.extension or
-  // directory/base_name_<number>.extension if directory/base_name.extension
-  // already exists. The number will be incremented until a pathname is found
-  // that does not already exist.
-  // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
-  // There could be a race condition if two or more processes are calling this
-  // function at the same time -- they could both pick the same filename.
-  static FilePath GenerateUniqueFileName(const FilePath& directory,
-                                         const FilePath& base_name,
-                                         const char* extension);
-
-  // Returns true iff the path is "".
-  bool IsEmpty() const { return pathname_.empty(); }
-
-  // If input name has a trailing separator character, removes it and returns
-  // the name, otherwise return the name string unmodified.
-  // On Windows platform, uses \ as the separator, other platforms use /.
-  FilePath RemoveTrailingPathSeparator() const;
-
-  // Returns a copy of the FilePath with the directory part removed.
-  // Example: FilePath("path/to/file").RemoveDirectoryName() returns
-  // FilePath("file"). If there is no directory part ("just_a_file"), it returns
-  // the FilePath unmodified. If there is no file part ("just_a_dir/") it
-  // returns an empty FilePath ("").
-  // On Windows platform, '\' is the path separator, otherwise it is '/'.
-  FilePath RemoveDirectoryName() const;
-
-  // RemoveFileName returns the directory path with the filename removed.
-  // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
-  // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
-  // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
-  // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
-  // On Windows platform, '\' is the path separator, otherwise it is '/'.
-  FilePath RemoveFileName() const;
-
-  // Returns a copy of the FilePath with the case-insensitive extension removed.
-  // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
-  // FilePath("dir/file"). If a case-insensitive extension is not
-  // found, returns a copy of the original FilePath.
-  FilePath RemoveExtension(const char* extension) const;
-
-  // Creates directories so that path exists. Returns true if successful or if
-  // the directories already exist; returns false if unable to create
-  // directories for any reason. Will also return false if the FilePath does
-  // not represent a directory (that is, it doesn't end with a path separator).
-  bool CreateDirectoriesRecursively() const;
-
-  // Create the directory so that path exists. Returns true if successful or
-  // if the directory already exists; returns false if unable to create the
-  // directory for any reason, including if the parent directory does not
-  // exist. Not named "CreateDirectory" because that's a macro on Windows.
-  bool CreateFolder() const;
-
-  // Returns true if FilePath describes something in the file-system,
-  // either a file, directory, or whatever, and that something exists.
-  bool FileOrDirectoryExists() const;
-
-  // Returns true if pathname describes a directory in the file-system
-  // that exists.
-  bool DirectoryExists() const;
-
-  // Returns true if FilePath ends with a path separator, which indicates that
-  // it is intended to represent a directory. Returns false otherwise.
-  // This does NOT check that a directory (or file) actually exists.
-  bool IsDirectory() const;
-
-  // Returns true if pathname describes a root directory. (Windows has one
-  // root directory per disk drive.)
-  bool IsRootDirectory() const;
-
-  // Returns true if pathname describes an absolute path.
-  bool IsAbsolutePath() const;
-
- private:
-  // Replaces multiple consecutive separators with a single separator.
-  // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
-  // redundancies that might be in a pathname involving "." or "..".
-  //
-  // A pathname with multiple consecutive separators may occur either through
-  // user error or as a result of some scripts or APIs that generate a pathname
-  // with a trailing separator. On other platforms the same API or script
-  // may NOT generate a pathname with a trailing "/". Then elsewhere that
-  // pathname may have another "/" and pathname components added to it,
-  // without checking for the separator already being there.
-  // The script language and operating system may allow paths like "foo//bar"
-  // but some of the functions in FilePath will not handle that correctly. In
-  // particular, RemoveTrailingPathSeparator() only removes one separator, and
-  // it is called in CreateDirectoriesRecursively() assuming that it will change
-  // a pathname from directory syntax (trailing separator) to filename syntax.
-  //
-  // On Windows this method also replaces the alternate path separator '/' with
-  // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
-  // "bar\\foo".
-
-  void Normalize();
-
-  // Returns a pointer to the last occurence 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;
-
-  std::string pathname_;
-};  // class FilePath
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-internal.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-internal.h
deleted file mode 100644
index ebd1cf61..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-internal.h
+++ /dev/null
@@ -1,1238 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This header file declares functions and macros used internally by
-// Google Test.  They are subject to change without notice.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
-
-#include "gtest/internal/gtest-port.h"
-
-#if GTEST_OS_LINUX
-# include <stdlib.h>
-# include <sys/types.h>
-# include <sys/wait.h>
-# include <unistd.h>
-#endif  // GTEST_OS_LINUX
-
-#if GTEST_HAS_EXCEPTIONS
-# include <stdexcept>
-#endif
-
-#include <ctype.h>
-#include <float.h>
-#include <string.h>
-#include <iomanip>
-#include <limits>
-#include <map>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "gtest/gtest-message.h"
-#include "gtest/internal/gtest-string.h"
-#include "gtest/internal/gtest-filepath.h"
-#include "gtest/internal/gtest-type-util.h"
-
-// Due to C++ preprocessor weirdness, we need double indirection to
-// concatenate two tokens when one of them is __LINE__.  Writing
-//
-//   foo ## __LINE__
-//
-// will result in the token foo__LINE__, instead of foo followed by
-// the current line number.  For more details, see
-// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
-#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
-#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
-
-class ProtocolMessage;
-namespace proto2 { class Message; }
-
-namespace testing {
-
-// Forward declarations.
-
-class AssertionResult;                 // Result of an assertion.
-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 cases.
-
-template <typename T>
-::std::string PrintToString(const T& value);
-
-namespace internal {
-
-struct TraceInfo;                      // Information about a trace point.
-class ScopedTrace;                     // Implements scoped trace.
-class TestInfoImpl;                    // Opaque implementation of TestInfo
-class UnitTestImpl;                    // Opaque implementation of UnitTest
-
-// The text used in failure messages to indicate the start of the
-// stack trace.
-GTEST_API_ extern const char kStackTraceMarker[];
-
-// Two overloaded helpers for checking at compile time whether an
-// expression is a null pointer literal (i.e. NULL or any 0-valued
-// compile-time integral constant).  Their return values have
-// different sizes, so we can use sizeof() to test which version is
-// picked by the compiler.  These helpers have no implementations, as
-// we only need their signatures.
-//
-// Given IsNullLiteralHelper(x), the compiler will pick the first
-// version if x can be implicitly converted to Secret*, and pick the
-// second version otherwise.  Since Secret is a secret and incomplete
-// type, the only expression a user can write that has type Secret* is
-// a null pointer literal.  Therefore, we know that x is a null
-// pointer literal if and only if the first version is picked by the
-// compiler.
-char IsNullLiteralHelper(Secret* p);
-char (&IsNullLiteralHelper(...))[2];  // NOLINT
-
-// A compile-time bool constant that is true if and only if x is a
-// null pointer literal (i.e. NULL or any 0-valued compile-time
-// integral constant).
-#ifdef GTEST_ELLIPSIS_NEEDS_POD_
-// We lose support for NULL detection where the compiler doesn't like
-// passing non-POD classes through ellipsis (...).
-# define GTEST_IS_NULL_LITERAL_(x) false
-#else
-# define GTEST_IS_NULL_LITERAL_(x) \
-    (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1)
-#endif  // GTEST_ELLIPSIS_NEEDS_POD_
-
-// Appends the user-supplied message to the Google-Test-generated message.
-GTEST_API_ std::string AppendUserMessage(
-    const std::string& gtest_msg, const Message& user_msg);
-
-#if GTEST_HAS_EXCEPTIONS
-
-// 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
-// errors presumably detectable only at run time.  Since
-// std::runtime_error inherits from std::exception, many testing
-// frameworks know how to extract and print the message inside it.
-class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
- public:
-  explicit GoogleTestFailureException(const TestPartResult& failure);
-};
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// A helper class for creating scoped traces in user programs.
-class GTEST_API_ ScopedTrace {
- public:
-  // The c'tor pushes the given source file location and message onto
-  // a trace stack maintained by Google Test.
-  ScopedTrace(const char* file, int line, const Message& 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:
-  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.
-
-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.
-// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
-enum EditType { kMatch, kAdd, kRemove, kReplace };
-GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
-    const std::vector<size_t>& left, const std::vector<size_t>& right);
-
-// Same as above, but the input is represented as strings.
-GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
-    const std::vector<std::string>& left,
-    const std::vector<std::string>& right);
-
-// Create a diff of the input strings in Unified diff format.
-GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
-                                         const std::vector<std::string>& right,
-                                         size_t context = 2);
-
-}  // namespace edit_distance
-
-// Calculate the diff between 'left' and 'right' and return it in unified diff
-// format.
-// If not null, stores in 'total_line_count' the total number of lines found
-// in left + right.
-GTEST_API_ std::string DiffStrings(const std::string& left,
-                                   const std::string& right,
-                                   size_t* total_line_count);
-
-// Constructs and returns the message for an equality assertion
-// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
-//
-// The first four parameters are the expressions used in the assertion
-// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
-// where foo is 5 and bar is 6, we have:
-//
-//   expected_expression: "foo"
-//   actual_expression:   "bar"
-//   expected_value:      "5"
-//   actual_value:        "6"
-//
-// The ignoring_case parameter is true iff 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,
-                                     const char* actual_expression,
-                                     const std::string& expected_value,
-                                     const std::string& actual_value,
-                                     bool ignoring_case);
-
-// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
-GTEST_API_ std::string GetBoolAssertionFailureMessage(
-    const AssertionResult& assertion_result,
-    const char* expression_text,
-    const char* actual_predicate_value,
-    const char* expected_predicate_value);
-
-// This template class represents an IEEE floating-point number
-// (either single-precision or double-precision, depending on the
-// template parameters).
-//
-// The purpose of this class is to do more sophisticated number
-// comparison.  (Due to round-off error, etc, it's very unlikely that
-// two floating-points will be equal exactly.  Hence a naive
-// comparison by the == operation often doesn't work.)
-//
-// Format of IEEE floating-point:
-//
-//   The most-significant bit being the leftmost, an IEEE
-//   floating-point looks like
-//
-//     sign_bit exponent_bits fraction_bits
-//
-//   Here, sign_bit is a single bit that designates the sign of the
-//   number.
-//
-//   For float, there are 8 exponent bits and 23 fraction bits.
-//
-//   For double, there are 11 exponent bits and 52 fraction bits.
-//
-//   More details can be found at
-//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
-//
-// Template parameter:
-//
-//   RawType: the raw floating-point type (either float or double)
-template <typename RawType>
-class FloatingPoint {
- public:
-  // Defines the unsigned integer type that has the same size as the
-  // floating point number.
-  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
-
-  // Constants.
-
-  // # of bits in a number.
-  static const size_t kBitCount = 8*sizeof(RawType);
-
-  // # of fraction bits in a number.
-  static const size_t kFractionBitCount =
-    std::numeric_limits<RawType>::digits - 1;
-
-  // # of exponent bits in a number.
-  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
-
-  // The mask for the sign bit.
-  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
-
-  // The mask for the fraction bits.
-  static const Bits kFractionBitMask =
-    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
-
-  // The mask for the exponent bits.
-  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
-
-  // How many ULP's (Units in the Last Place) we want to tolerate when
-  // comparing two numbers.  The larger the value, the more error we
-  // allow.  A 0 value means that two numbers must be exactly the same
-  // to be considered equal.
-  //
-  // The maximum error of a single floating-point operation is 0.5
-  // units in the last place.  On Intel CPU's, all floating-point
-  // calculations are done with 80-bit precision, while double has 64
-  // bits.  Therefore, 4 should be enough for ordinary use.
-  //
-  // See the following article for more details on ULP:
-  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
-  static const size_t kMaxUlps = 4;
-
-  // Constructs a FloatingPoint from a raw floating-point number.
-  //
-  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
-  // around may change its bits, although the new value is guaranteed
-  // to be also a NAN.  Therefore, don't expect this constructor to
-  // preserve the bits in x when x is a NAN.
-  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
-
-  // Static methods
-
-  // Reinterprets a bit pattern as a floating-point number.
-  //
-  // This function is needed to test the AlmostEquals() method.
-  static RawType ReinterpretBits(const Bits bits) {
-    FloatingPoint fp(0);
-    fp.u_.bits_ = bits;
-    return fp.u_.value_;
-  }
-
-  // Returns the floating-point number that represent positive infinity.
-  static RawType Infinity() {
-    return ReinterpretBits(kExponentBitMask);
-  }
-
-  // Returns the maximum representable finite floating-point number.
-  static RawType Max();
-
-  // Non-static methods
-
-  // Returns the bits that represents this number.
-  const Bits &bits() const { return u_.bits_; }
-
-  // Returns the exponent bits of this number.
-  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
-
-  // Returns the fraction bits of this number.
-  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }
-
-  // Returns the sign bit of this number.
-  Bits sign_bit() const { return kSignBitMask & u_.bits_; }
-
-  // Returns true iff 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 iff 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.
-  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
-  bool AlmostEquals(const FloatingPoint& rhs) const {
-    // The IEEE standard says that any comparison operation involving
-    // a NAN must return false.
-    if (is_nan() || rhs.is_nan()) return false;
-
-    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
-        <= kMaxUlps;
-  }
-
- private:
-  // The data type used to store the actual floating-point number.
-  union FloatingPointUnion {
-    RawType value_;  // The raw floating-point number.
-    Bits bits_;      // The bits that represent the number.
-  };
-
-  // Converts an integer from the sign-and-magnitude representation to
-  // the biased representation.  More precisely, let N be 2 to the
-  // power of (kBitCount - 1), an integer x is represented by the
-  // unsigned number x + N.
-  //
-  // For instance,
-  //
-  //   -N + 1 (the most negative number representable using
-  //          sign-and-magnitude) is represented by 1;
-  //   0      is represented by N; and
-  //   N - 1  (the biggest number representable using
-  //          sign-and-magnitude) is represented by 2N - 1.
-  //
-  // Read http://en.wikipedia.org/wiki/Signed_number_representations
-  // for more details on signed number representations.
-  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
-    if (kSignBitMask & sam) {
-      // sam represents a negative number.
-      return ~sam + 1;
-    } else {
-      // sam represents a positive number.
-      return kSignBitMask | sam;
-    }
-  }
-
-  // Given two numbers in the sign-and-magnitude representation,
-  // returns the distance between them as an unsigned number.
-  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
-                                                     const Bits &sam2) {
-    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
-    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
-    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
-  }
-
-  FloatingPointUnion u_;
-};
-
-// We cannot use std::numeric_limits<T>::max() as it clashes with the max()
-// macro defined by <windows.h>.
-template <>
-inline float FloatingPoint<float>::Max() { return FLT_MAX; }
-template <>
-inline double FloatingPoint<double>::Max() { return DBL_MAX; }
-
-// Typedefs the instances of the FloatingPoint template class that we
-// care to use.
-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 case, 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
-// them for equality using the == operator.
-typedef const void* TypeId;
-
-template <typename T>
-class TypeIdHelper {
- public:
-  // dummy_ must not have a const type.  Otherwise an overly eager
-  // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
-  // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
-  static bool dummy_;
-};
-
-template <typename T>
-bool TypeIdHelper<T>::dummy_ = false;
-
-// GetTypeId<T>() returns the ID of type T.  Different values will be
-// returned for different types.  Calling the function twice with the
-// same type argument is guaranteed to return the same ID.
-template <typename T>
-TypeId GetTypeId() {
-  // The compiler is required to allocate a different
-  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
-  // the template.  Therefore, the address of dummy_ is guaranteed to
-  // be unique.
-  return &(TypeIdHelper<T>::dummy_);
-}
-
-// Returns the type ID of ::testing::Test.  Always call this instead
-// of GetTypeId< ::testing::Test>() to get the type ID of
-// ::testing::Test, as the latter may give the wrong result due to a
-// suspected linker bug when compiling Google Test as a Mac OS X
-// framework.
-GTEST_API_ TypeId GetTestTypeId();
-
-// Defines the abstract factory interface that creates instances
-// of a Test object.
-class TestFactoryBase {
- public:
-  virtual ~TestFactoryBase() {}
-
-  // Creates a test instance to run. The instance is both created and destroyed
-  // within TestInfoImpl::Run()
-  virtual Test* CreateTest() = 0;
-
- protected:
-  TestFactoryBase() {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
-};
-
-// This class provides implementation of TeastFactoryBase interface.
-// It is used in TEST and TEST_F macros.
-template <class TestClass>
-class TestFactoryImpl : public TestFactoryBase {
- public:
-  virtual Test* CreateTest() { return new TestClass; }
-};
-
-#if GTEST_OS_WINDOWS
-
-// Predicate-formatters for implementing the HRESULT checking macros
-// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
-// We pass a long instead of HRESULT to avoid causing an
-// include dependency for the HRESULT type.
-GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
-                                            long hr);  // NOLINT
-GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
-                                            long hr);  // NOLINT
-
-#endif  // GTEST_OS_WINDOWS
-
-// Types of SetUpTestCase() and TearDownTestCase() functions.
-typedef void (*SetUpTestCaseFunc)();
-typedef void (*TearDownTestCaseFunc)();
-
-struct CodeLocation {
-  CodeLocation(const string& a_file, int a_line) : file(a_file), line(a_line) {}
-
-  string file;
-  int line;
-};
-
-// Creates a new TestInfo object and registers it with Google Test;
-// returns the created object.
-//
-// Arguments:
-//
-//   test_case_name:   name of the test case
-//   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.
-//   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 case
-//   tear_down_tc:     pointer to the function that tears down the test case
-//   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_case_name,
-    const char* name,
-    const char* type_param,
-    const char* value_param,
-    CodeLocation code_location,
-    TypeId fixture_class_id,
-    SetUpTestCaseFunc set_up_tc,
-    TearDownTestCaseFunc 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);
-
-#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-// State of the definition of a type-parameterized test case.
-class GTEST_API_ TypedTestCasePState {
- public:
-  TypedTestCasePState() : registered_(false) {}
-
-  // Adds the given test name to defined_test_names_ and return true
-  // if the test case 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_CASE_P(%s, ...).\n",
-              FormatFileLocation(file, line).c_str(), test_name, case_name);
-      fflush(stderr);
-      posix::Abort();
-    }
-    registered_tests_.insert(
-        ::std::make_pair(test_name, CodeLocation(file, line)));
-    return true;
-  }
-
-  bool TestExists(const std::string& test_name) const {
-    return registered_tests_.count(test_name) > 0;
-  }
-
-  const CodeLocation& GetCodeLocation(const std::string& test_name) const {
-    RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name);
-    GTEST_CHECK_(it != registered_tests_.end());
-    return it->second;
-  }
-
-  // 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* file, int line, const char* registered_tests);
-
- private:
-  typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;
-
-  bool registered_;
-  RegisteredTestsMap registered_tests_;
-};
-
-// 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 == NULL) {
-    return NULL;
-  }
-  while (IsSpace(*(++comma))) {}
-  return comma;
-}
-
-// Returns the prefix of 'str' before the first comma in it; returns
-// the entire string if it contains no comma.
-inline std::string GetPrefixUntilComma(const char* str) {
-  const char* comma = strchr(str, ',');
-  return comma == NULL ? str : std::string(str, comma);
-}
-
-// Splits a given string on a given delimiter, populating a given
-// vector with the fields.
-void SplitString(const ::std::string& str, char delimiter,
-                 ::std::vector< ::std::string>* dest);
-
-// 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
-// such that we can call this function in a namespace scope.
-//
-// Implementation note: The GTEST_TEMPLATE_ macro declares a template
-// template parameter.  It's defined in gtest-type-util.h.
-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_CASE_P(Prefix, TestCase,
-  // Types).  Valid values for 'index' are [0, N - 1] where N is the
-  // length of Types.
-  static bool Register(const char* prefix,
-                       CodeLocation code_location,
-                       const char* case_name, const char* test_names,
-                       int index) {
-    typedef typename Types::Head Type;
-    typedef Fixture<Type> FixtureClass;
-    typedef typename GTEST_BIND_(TestSel, Type) TestClass;
-
-    // First, registers the first type-parameterized test in the type
-    // list.
-    MakeAndRegisterTestInfo(
-        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
-         + StreamableToString(index)).c_str(),
-        StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
-        GetTypeName<Type>().c_str(),
-        NULL,  // No value parameter.
-        code_location,
-        GetTypeId<FixtureClass>(),
-        TestClass::SetUpTestCase,
-        TestClass::TearDownTestCase,
-        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);
-  }
-};
-
-// The base case for the compile time recursion.
-template <GTEST_TEMPLATE_ Fixture, class TestSel>
-class TypeParameterizedTest<Fixture, TestSel, Types0> {
- public:
-  static bool Register(const char* /*prefix*/, CodeLocation,
-                       const char* /*case_name*/, const char* /*test_names*/,
-                       int /*index*/) {
-    return true;
-  }
-};
-
-// TypeParameterizedTestCase<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 TypeParameterizedTestCase {
- public:
-  static bool Register(const char* prefix, CodeLocation code_location,
-                       const TypedTestCasePState* state,
-                       const char* case_name, const char* test_names) {
-    std::string test_name = StripTrailingSpaces(
-        GetPrefixUntilComma(test_names));
-    if (!state->TestExists(test_name)) {
-      fprintf(stderr, "Failed to get code location for test %s.%s at %s.",
-              case_name, test_name.c_str(),
-              FormatFileLocation(code_location.file.c_str(),
-                                 code_location.line).c_str());
-      fflush(stderr);
-      posix::Abort();
-    }
-    const CodeLocation& test_location = state->GetCodeLocation(test_name);
-
-    typedef typename Tests::Head Head;
-
-    // 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);
-
-    // Next, recurses (at compile time) with the tail of the test list.
-    return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types>
-        ::Register(prefix, code_location, state,
-                   case_name, SkipComma(test_names));
-  }
-};
-
-// The base case for the compile time recursion.
-template <GTEST_TEMPLATE_ Fixture, typename Types>
-class TypeParameterizedTestCase<Fixture, Templates0, Types> {
- public:
-  static bool Register(const char* /*prefix*/, CodeLocation,
-                       const TypedTestCasePState* /*state*/,
-                       const char* /*case_name*/, const char* /*test_names*/) {
-    return true;
-  }
-};
-
-#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-// Returns the current OS stack trace as an std::string.
-//
-// The maximum number of stack frames to be included is specified by
-// the gtest_stack_trace_depth flag.  The skip_count parameter
-// specifies the number of top frames to be skipped, which doesn't
-// count against the number of frames to be included.
-//
-// For example, if Foo() calls Bar(), which in turn calls
-// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
-// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
-GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
-    UnitTest* unit_test, int skip_count);
-
-// Helpers for suppressing warnings on unreachable code or constant
-// condition.
-
-// Always returns true.
-GTEST_API_ bool AlwaysTrue();
-
-// Always returns false.
-inline bool AlwaysFalse() { return !AlwaysTrue(); }
-
-// Helper for suppressing false warning from Clang on a const char*
-// variable declared in a conditional expression always being NULL in
-// the else branch.
-struct GTEST_API_ ConstCharPtr {
-  ConstCharPtr(const char* str) : value(str) {}
-  operator bool() const { return true; }
-  const char* 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
-// code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
-// but it's good enough for our purposes.
-class GTEST_API_ Random {
- public:
-  static const UInt32 kMaxRange = 1u << 31;
-
-  explicit Random(UInt32 seed) : state_(seed) {}
-
-  void Reseed(UInt32 seed) { state_ = seed; }
-
-  // Generates a random number from [0, range).  Crashes if 'range' is
-  // 0 or greater than kMaxRange.
-  UInt32 Generate(UInt32 range);
-
- private:
-  UInt32 state_;
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
-};
-
-// Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a
-// compiler error iff T1 and T2 are different types.
-template <typename T1, typename T2>
-struct CompileAssertTypesEqual;
-
-template <typename T>
-struct CompileAssertTypesEqual<T, T> {
-};
-
-// Removes the reference from a type if it is a reference type,
-// otherwise leaves it unchanged.  This is the same as
-// tr1::remove_reference, which is not widely available yet.
-template <typename T>
-struct RemoveReference { typedef T type; };  // NOLINT
-template <typename T>
-struct RemoveReference<T&> { typedef T type; };  // NOLINT
-
-// A handy wrapper around RemoveReference that works when the argument
-// T depends on template parameters.
-#define GTEST_REMOVE_REFERENCE_(T) \
-    typename ::testing::internal::RemoveReference<T>::type
-
-// Removes const from a type if it is a const type, otherwise leaves
-// it unchanged.  This is the same as tr1::remove_const, which is not
-// widely available yet.
-template <typename T>
-struct RemoveConst { typedef T type; };  // NOLINT
-template <typename T>
-struct RemoveConst<const T> { typedef T type; };  // NOLINT
-
-// MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
-// definition to fail to remove the const in 'const int[3]' and 'const
-// char[3][4]'.  The following specialization works around the bug.
-template <typename T, size_t N>
-struct RemoveConst<const T[N]> {
-  typedef typename RemoveConst<T>::type type[N];
-};
-
-#if defined(_MSC_VER) && _MSC_VER < 1400
-// This is the only specialization that allows VC++ 7.1 to remove const in
-// 'const int[3] and 'const int[3][4]'.  However, it causes trouble with GCC
-// and thus needs to be conditionally compiled.
-template <typename T, size_t N>
-struct RemoveConst<T[N]> {
-  typedef typename RemoveConst<T>::type type[N];
-};
-#endif
-
-// A handy wrapper around RemoveConst that works when the argument
-// T depends on template parameters.
-#define GTEST_REMOVE_CONST_(T) \
-    typename ::testing::internal::RemoveConst<T>::type
-
-// Turns const U&, U&, const U, and U all into U.
-#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
-    GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))
-
-// Adds reference to a type if it is not a reference type,
-// otherwise leaves it unchanged.  This is the same as
-// tr1::add_reference, which is not widely available yet.
-template <typename T>
-struct AddReference { typedef T& type; };  // NOLINT
-template <typename T>
-struct AddReference<T&> { typedef T& type; };  // NOLINT
-
-// A handy wrapper around AddReference that works when the argument T
-// depends on template parameters.
-#define GTEST_ADD_REFERENCE_(T) \
-    typename ::testing::internal::AddReference<T>::type
-
-// Adds a reference to const on top of T as necessary.  For example,
-// it transforms
-//
-//   char         ==> const char&
-//   const char   ==> const char&
-//   char&        ==> const char&
-//   const char&  ==> const char&
-//
-// The argument T must depend on some template parameters.
-#define GTEST_REFERENCE_TO_CONST_(T) \
-    GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T))
-
-// ImplicitlyConvertible<From, To>::value is a compile-time bool
-// constant that's true iff type From can be implicitly converted to
-// type To.
-template <typename From, typename To>
-class ImplicitlyConvertible {
- private:
-  // We need the following helper functions only for their types.
-  // They have no implementations.
-
-  // MakeFrom() is an expression whose type is From.  We cannot simply
-  // use From(), as the type From may not have a public default
-  // constructor.
-  static typename AddReference<From>::type MakeFrom();
-
-  // These two functions are overloaded.  Given an expression
-  // Helper(x), the compiler will pick the first version if x can be
-  // implicitly converted to type To; otherwise it will pick the
-  // second version.
-  //
-  // The first version returns a value of size 1, and the second
-  // version returns a value of size 2.  Therefore, by checking the
-  // size of Helper(x), which can be done at compile time, we can tell
-  // which version of Helper() is used, and hence whether x can be
-  // implicitly converted to type To.
-  static char Helper(To);
-  static char (&Helper(...))[2];  // NOLINT
-
-  // We have to put the 'public' section after the 'private' section,
-  // or MSVC refuses to compile the code.
- public:
-#if defined(__BORLANDC__)
-  // C++Builder cannot use member overload resolution during template
-  // instantiation.  The simplest workaround is to use its C++0x type traits
-  // functions (C++Builder 2009 and above only).
-  static const bool value = __is_convertible(From, To);
-#else
-  // MSVC warns about implicitly converting from double to int for
-  // possible loss of data, so we need to temporarily disable the
-  // warning.
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4244)
-  static const bool value =
-      sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-#endif  // __BORLANDC__
-};
-template <typename From, typename To>
-const bool ImplicitlyConvertible<From, To>::value;
-
-// IsAProtocolMessage<T>::value is a compile-time bool constant that's
-// true iff T is type ProtocolMessage, proto2::Message, or a subclass
-// of those.
-template <typename T>
-struct IsAProtocolMessage
-    : public bool_constant<
-  ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value ||
-  ImplicitlyConvertible<const T*, const ::proto2::Message*>::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
-// valid types and NULL can be implicitly converted to them).  It will
-// be picked over the second overload as 'int' is a perfect match for
-// the type of argument 0.  If C::iterator or C::const_iterator is not
-// a valid type, the first overload is not viable, and the second
-// overload will be picked.  Therefore, we can determine whether C is
-// a container class by checking the type of IsContainerTest<C>(0).
-// The value of the expression is insignificant.
-//
-// Note 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
-// iterator is an STL container.
-//
-// Also note that the simpler approach of overloading
-// IsContainerTest(typename C::const_iterator*) and
-// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
-typedef int IsContainer;
-template <class C>
-IsContainer IsContainerTest(int /* dummy */,
-                            typename C::iterator* /* it */ = NULL,
-                            typename C::const_iterator* /* const_it */ = NULL) {
-  return 0;
-}
-
-typedef char IsNotContainer;
-template <class C>
-IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
-
-// EnableIf<condition>::type is void when 'Cond' is true, and
-// undefined when 'Cond' is false.  To use SFINAE to make a function
-// overload only apply when a particular expression is true, add
-// "typename EnableIf<expression>::type* = 0" as the last parameter.
-template<bool> struct EnableIf;
-template<> struct EnableIf<true> { typedef void type; };  // NOLINT
-
-// Utilities for native arrays.
-
-// ArrayEq() compares two k-dimensional native arrays using the
-// elements' operator==, where k can be any integer >= 0.  When k is
-// 0, ArrayEq() degenerates into comparing a single pair of values.
-
-template <typename T, typename U>
-bool ArrayEq(const T* lhs, size_t size, const U* rhs);
-
-// This generic version is used when k is 0.
-template <typename T, typename U>
-inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
-
-// This overload is used when k >= 1.
-template <typename T, typename U, size_t N>
-inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
-  return internal::ArrayEq(lhs, N, rhs);
-}
-
-// This helper reduces code bloat.  If we instead put its logic inside
-// the previous ArrayEq() function, arrays with different sizes would
-// lead to different copies of the template code.
-template <typename T, typename U>
-bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
-  for (size_t i = 0; i != size; i++) {
-    if (!internal::ArrayEq(lhs[i], rhs[i]))
-      return false;
-  }
-  return true;
-}
-
-// Finds the first element in the iterator range [begin, end) that
-// equals elem.  Element may be a native array type itself.
-template <typename Iter, typename Element>
-Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
-  for (Iter it = begin; it != end; ++it) {
-    if (internal::ArrayEq(*it, elem))
-      return it;
-  }
-  return end;
-}
-
-// CopyArray() copies a k-dimensional native array using the elements'
-// operator=, where k can be any integer >= 0.  When k is 0,
-// CopyArray() degenerates into copying a single value.
-
-template <typename T, typename U>
-void CopyArray(const T* from, size_t size, U* to);
-
-// This generic version is used when k is 0.
-template <typename T, typename U>
-inline void CopyArray(const T& from, U* to) { *to = from; }
-
-// This overload is used when k >= 1.
-template <typename T, typename U, size_t N>
-inline void CopyArray(const T(&from)[N], U(*to)[N]) {
-  internal::CopyArray(from, N, *to);
-}
-
-// This helper reduces code bloat.  If we instead put its logic inside
-// the previous CopyArray() function, arrays with different sizes
-// would lead to different copies of the template code.
-template <typename T, typename U>
-void CopyArray(const T* from, size_t size, U* to) {
-  for (size_t i = 0; i != size; i++) {
-    internal::CopyArray(from[i], to + i);
-  }
-}
-
-// The relation between an NativeArray object (see below) and the
-// native array it represents.
-// We use 2 different structs to allow non-copyable types to be used, as long
-// as RelationToSourceReference() is passed.
-struct RelationToSourceReference {};
-struct RelationToSourceCopy {};
-
-// Adapts a native array to a read-only STL-style container.  Instead
-// of the complete STL container concept, this adaptor only implements
-// members useful for Google Mock's container matchers.  New members
-// should be added as needed.  To simplify the implementation, we only
-// support Element being a raw type (i.e. having no top-level const or
-// reference modifier).  It's the client's responsibility to satisfy
-// this requirement.  Element can be an array type itself (hence
-// multi-dimensional arrays are supported).
-template <typename Element>
-class NativeArray {
- public:
-  // STL-style container typedefs.
-  typedef Element value_type;
-  typedef Element* iterator;
-  typedef const Element* const_iterator;
-
-  // Constructs from a native array. References the source.
-  NativeArray(const Element* array, size_t count, RelationToSourceReference) {
-    InitRef(array, count);
-  }
-
-  // Constructs from a native array. Copies the source.
-  NativeArray(const Element* array, size_t count, RelationToSourceCopy) {
-    InitCopy(array, count);
-  }
-
-  // Copy constructor.
-  NativeArray(const NativeArray& rhs) {
-    (this->*rhs.clone_)(rhs.array_, rhs.size_);
-  }
-
-  ~NativeArray() {
-    if (clone_ != &NativeArray::InitRef)
-      delete[] array_;
-  }
-
-  // STL-style container methods.
-  size_t size() const { return size_; }
-  const_iterator begin() const { return array_; }
-  const_iterator end() const { return array_ + size_; }
-  bool operator==(const NativeArray& rhs) const {
-    return size() == rhs.size() &&
-        ArrayEq(begin(), size(), rhs.begin());
-  }
-
- private:
-  enum {
-    kCheckTypeIsNotConstOrAReference = StaticAssertTypeEqHelper<
-        Element, GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>::value,
-  };
-
-  // Initializes this object with a copy of the input.
-  void InitCopy(const Element* array, size_t a_size) {
-    Element* const copy = new Element[a_size];
-    CopyArray(array, a_size, copy);
-    array_ = copy;
-    size_ = a_size;
-    clone_ = &NativeArray::InitCopy;
-  }
-
-  // Initializes this object with a reference of the input.
-  void InitRef(const Element* array, size_t a_size) {
-    array_ = array;
-    size_ = a_size;
-    clone_ = &NativeArray::InitRef;
-  }
-
-  const Element* array_;
-  size_t size_;
-  void (NativeArray::*clone_)(const Element*, size_t);
-
-  GTEST_DISALLOW_ASSIGN_(NativeArray);
-};
-
-}  // namespace internal
-}  // namespace testing
-
-#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
-  ::testing::internal::AssertHelper(result_type, file, line, message) \
-    = ::testing::Message()
-
-#define GTEST_MESSAGE_(message, result_type) \
-  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
-
-#define GTEST_FATAL_FAILURE_(message) \
-  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
-
-#define GTEST_NONFATAL_FAILURE_(message) \
-  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
-
-#define GTEST_SUCCESS_(message) \
-  GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
-
-// Suppresses MSVC warnings 4072 (unreachable code) for the code following
-// statement if it returns or throws (or doesn't return or throw in some
-// situations).
-#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
-  if (::testing::internal::AlwaysTrue()) { statement; }
-
-#define GTEST_TEST_THROW_(statement, expected_exception, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::ConstCharPtr gtest_msg = "") { \
-    bool gtest_caught_expected = false; \
-    try { \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    } \
-    catch (expected_exception const&) { \
-      gtest_caught_expected = true; \
-    } \
-    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 \
-    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
-      fail(gtest_msg.value)
-
-#define GTEST_TEST_NO_THROW_(statement, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-    try { \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    } \
-    catch (...) { \
-      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: it throws.")
-
-#define GTEST_TEST_ANY_THROW_(statement, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-    bool gtest_caught_any = false; \
-    try { \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    } \
-    catch (...) { \
-      gtest_caught_any = true; \
-    } \
-    if (!gtest_caught_any) { \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
-      fail("Expected: " #statement " throws an exception.\n" \
-           "  Actual: it doesn't.")
-
-
-// Implements Boolean test assertions such as EXPECT_TRUE. expression can be
-// either a boolean expression or an AssertionResult. text is a textual
-// represenation 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_ = \
-      ::testing::AssertionResult(expression)) \
-    ; \
-  else \
-    fail(::testing::internal::GetBoolAssertionFailureMessage(\
-        gtest_ar_, text, #actual, #expected).c_str())
-
-#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-    ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
-      fail("Expected: " #statement " doesn't generate new fatal " \
-           "failures in the current thread.\n" \
-           "  Actual: it does.")
-
-// Expands to the name of the class that implements the given test.
-#define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
-  test_case_name##_##test_name##_Test
-
-// Helper macro for defining tests.
-#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
-class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
- public:\
-  GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\
- private:\
-  virtual void TestBody();\
-  static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(\
-      GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
-};\
-\
-::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
-  ::test_info_ =\
-    ::testing::internal::MakeAndRegisterTestInfo(\
-        #test_case_name, #test_name, NULL, NULL, \
-        ::testing::internal::CodeLocation(__FILE__, __LINE__), \
-        (parent_id), \
-        parent_class::SetUpTestCase, \
-        parent_class::TearDownTestCase, \
-        new ::testing::internal::TestFactoryImpl<\
-            GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
-void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
-
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-linked_ptr.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-linked_ptr.h
deleted file mode 100644
index 36029422..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-linked_ptr.h
+++ /dev/null
@@ -1,243 +0,0 @@
-// Copyright 2003 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.
-//
-// Authors: Dan Egnor (egnor@google.com)
-//
-// A "smart" pointer type with reference tracking.  Every pointer to a
-// particular object is kept on a circular linked list.  When the last pointer
-// to an object is destroyed or reassigned, the object is deleted.
-//
-// Used properly, this deletes the object when the last reference goes away.
-// There are several caveats:
-// - Like all reference counting schemes, cycles lead to leaks.
-// - Each smart pointer is actually two pointers (8 bytes instead of 4).
-// - Every time a pointer is assigned, the entire list of pointers to that
-//   object is traversed.  This class is therefore NOT SUITABLE when there
-//   will often be more than two or three pointers to a particular object.
-// - References are only tracked as long as linked_ptr<> objects are copied.
-//   If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
-//   will happen (double deletion).
-//
-// A good use of this class is storing object references in STL containers.
-// You can safely put linked_ptr<> in a vector<>.
-// Other uses may not be as good.
-//
-// Note: If you use an incomplete type with linked_ptr<>, the class
-// *containing* linked_ptr<> must have a constructor and destructor (even
-// if they do nothing!).
-//
-// Bill Gibbons suggested we use something like this.
-//
-// Thread Safety:
-//   Unlike other linked_ptr implementations, in this implementation
-//   a linked_ptr object is thread-safe in the sense that:
-//     - it's safe to copy linked_ptr objects concurrently,
-//     - it's safe to copy *from* a linked_ptr and read its underlying
-//       raw pointer (e.g. via get()) concurrently, and
-//     - it's safe to write to two linked_ptrs that point to the same
-//       shared object concurrently.
-// TODO(wan@google.com): rename this to safe_linked_ptr to avoid
-// confusion with normal linked_ptr.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
-
-#include <stdlib.h>
-#include <assert.h>
-
-#include "gtest/internal/gtest-port.h"
-
-namespace testing {
-namespace internal {
-
-// Protects copying of all linked_ptr objects.
-GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_linked_ptr_mutex);
-
-// This is used internally by all instances of linked_ptr<>.  It needs to be
-// a non-template class because different types of linked_ptr<> can refer to
-// the same object (linked_ptr<Superclass>(obj) vs linked_ptr<Subclass>(obj)).
-// So, it needs to be possible for different types of linked_ptr to participate
-// in the same circular linked list, so we need a single class type here.
-//
-// DO NOT USE THIS CLASS DIRECTLY YOURSELF.  Use linked_ptr<T>.
-class linked_ptr_internal {
- public:
-  // Create a new circle that includes only this instance.
-  void join_new() {
-    next_ = this;
-  }
-
-  // Many linked_ptr operations may change p.link_ for some linked_ptr
-  // variable p in the same circle as this object.  Therefore we need
-  // to prevent two such operations from occurring concurrently.
-  //
-  // Note that different types of linked_ptr objects can coexist in a
-  // circle (e.g. linked_ptr<Base>, linked_ptr<Derived1>, and
-  // linked_ptr<Derived2>).  Therefore we must use a single mutex to
-  // protect all linked_ptr objects.  This can create serious
-  // contention in production code, but is acceptable in a testing
-  // framework.
-
-  // Join an existing circle.
-  void join(linked_ptr_internal const* ptr)
-      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
-    MutexLock lock(&g_linked_ptr_mutex);
-
-    linked_ptr_internal const* p = ptr;
-    while (p->next_ != ptr) {
-      assert(p->next_ != this &&
-             "Trying to join() a linked ring we are already in. "
-             "Is GMock thread safety enabled?");
-      p = p->next_;
-    }
-    p->next_ = this;
-    next_ = ptr;
-  }
-
-  // Leave whatever circle we're part of.  Returns true if we were the
-  // last member of the circle.  Once this is done, you can join() another.
-  bool depart()
-      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
-    MutexLock lock(&g_linked_ptr_mutex);
-
-    if (next_ == this) return true;
-    linked_ptr_internal const* p = next_;
-    while (p->next_ != this) {
-      assert(p->next_ != next_ &&
-             "Trying to depart() a linked ring we are not in. "
-             "Is GMock thread safety enabled?");
-      p = p->next_;
-    }
-    p->next_ = next_;
-    return false;
-  }
-
- private:
-  mutable linked_ptr_internal const* next_;
-};
-
-template <typename T>
-class linked_ptr {
- public:
-  typedef T element_type;
-
-  // Take over ownership of a raw pointer.  This should happen as soon as
-  // possible after the object is created.
-  explicit linked_ptr(T* ptr = NULL) { capture(ptr); }
-  ~linked_ptr() { depart(); }
-
-  // Copy an existing linked_ptr<>, adding ourselves to the list of references.
-  template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); }
-  linked_ptr(linked_ptr const& ptr) {  // NOLINT
-    assert(&ptr != this);
-    copy(&ptr);
-  }
-
-  // Assignment releases the old value and acquires the new.
-  template <typename U> linked_ptr& operator=(linked_ptr<U> const& ptr) {
-    depart();
-    copy(&ptr);
-    return *this;
-  }
-
-  linked_ptr& operator=(linked_ptr const& ptr) {
-    if (&ptr != this) {
-      depart();
-      copy(&ptr);
-    }
-    return *this;
-  }
-
-  // Smart pointer members.
-  void reset(T* ptr = NULL) {
-    depart();
-    capture(ptr);
-  }
-  T* get() const { return value_; }
-  T* operator->() const { return value_; }
-  T& operator*() const { return *value_; }
-
-  bool operator==(T* p) const { return value_ == p; }
-  bool operator!=(T* p) const { return value_ != p; }
-  template <typename U>
-  bool operator==(linked_ptr<U> const& ptr) const {
-    return value_ == ptr.get();
-  }
-  template <typename U>
-  bool operator!=(linked_ptr<U> const& ptr) const {
-    return value_ != ptr.get();
-  }
-
- private:
-  template <typename U>
-  friend class linked_ptr;
-
-  T* value_;
-  linked_ptr_internal link_;
-
-  void depart() {
-    if (link_.depart()) delete value_;
-  }
-
-  void capture(T* ptr) {
-    value_ = ptr;
-    link_.join_new();
-  }
-
-  template <typename U> void copy(linked_ptr<U> const* ptr) {
-    value_ = ptr->get();
-    if (value_)
-      link_.join(&ptr->link_);
-    else
-      link_.join_new();
-  }
-};
-
-template<typename T> inline
-bool operator==(T* ptr, const linked_ptr<T>& x) {
-  return ptr == x.get();
-}
-
-template<typename T> inline
-bool operator!=(T* ptr, const linked_ptr<T>& x) {
-  return ptr != x.get();
-}
-
-// A function to convert T* into linked_ptr<T>
-// Doing e.g. make_linked_ptr(new FooBarBaz<type>(arg)) is a shorter notation
-// for linked_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
-template <typename T>
-linked_ptr<T> make_linked_ptr(T* ptr) {
-  return linked_ptr<T>(ptr);
-}
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h
deleted file mode 100644
index 4d1d81d2..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h
+++ /dev/null
@@ -1,5146 +0,0 @@
-// This file was GENERATED by command:
-//     pump.py gtest-param-util-generated.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-
-// Type and function utilities for implementing parameterized tests.
-// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
-//
-// Currently Google Test supports at most 50 arguments in Values,
-// and at most 10 arguments in Combine. Please contact
-// googletestframework@googlegroups.com if you need more.
-// Please note that the number of arguments to Combine is limited
-// by the maximum arity of the implementation of tuple which is
-// currently set at 10.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
-
-// scripts/fuse_gtest.py depends on gtest's own header being #included
-// *unconditionally*.  Therefore these #includes cannot be moved
-// inside #if GTEST_HAS_PARAM_TEST.
-#include "gtest/internal/gtest-param-util.h"
-#include "gtest/internal/gtest-port.h"
-
-#if GTEST_HAS_PARAM_TEST
-
-namespace testing {
-
-// Forward declarations of ValuesIn(), which is implemented in
-// include/gtest/gtest-param-test.h.
-template <typename ForwardIterator>
-internal::ParamGenerator<
-  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
-ValuesIn(ForwardIterator begin, ForwardIterator end);
-
-template <typename T, size_t N>
-internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);
-
-template <class Container>
-internal::ParamGenerator<typename Container::value_type> ValuesIn(
-    const Container& container);
-
-namespace internal {
-
-// Used in the Values() function to provide polymorphic capabilities.
-template <typename T1>
-class ValueArray1 {
- public:
-  explicit ValueArray1(T1 v1) : v1_(v1) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray1& other);
-
-  const T1 v1_;
-};
-
-template <typename T1, typename T2>
-class ValueArray2 {
- public:
-  ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray2& other);
-
-  const T1 v1_;
-  const T2 v2_;
-};
-
-template <typename T1, typename T2, typename T3>
-class ValueArray3 {
- public:
-  ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray3& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4>
-class ValueArray4 {
- public:
-  ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray4& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-class ValueArray5 {
- public:
-  ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4), v5_(v5) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray5& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-class ValueArray6 {
- public:
-  ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1), v2_(v2),
-      v3_(v3), v4_(v4), v5_(v5), v6_(v6) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray6& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-class ValueArray7 {
- public:
-  ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1),
-      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray7& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-class ValueArray8 {
- public:
-  ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
-      T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray8& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-class ValueArray9 {
- public:
-  ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
-      T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray9& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-class ValueArray10 {
- public:
-  ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray10& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11>
-class ValueArray11 {
- public:
-  ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
-      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray11& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12>
-class ValueArray12 {
- public:
-  ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
-      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray12& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13>
-class ValueArray13 {
- public:
-  ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
-      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
-      v12_(v12), v13_(v13) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray13& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14>
-class ValueArray14 {
- public:
-  ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray14& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15>
-class ValueArray15 {
- public:
-  ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1), v2_(v2),
-      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray15& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16>
-class ValueArray16 {
- public:
-  ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) : v1_(v1),
-      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
-      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
-      v16_(v16) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray16& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17>
-class ValueArray17 {
- public:
-  ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
-      T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray17& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18>
-class ValueArray18 {
- public:
-  ValueArray18(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray18& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19>
-class ValueArray19 {
- public:
-  ValueArray19(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
-      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
-      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray19& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20>
-class ValueArray20 {
- public:
-  ValueArray20(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
-      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
-      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
-      v19_(v19), v20_(v20) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray20& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21>
-class ValueArray21 {
- public:
-  ValueArray21(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
-      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
-      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
-      v18_(v18), v19_(v19), v20_(v20), v21_(v21) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray21& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22>
-class ValueArray22 {
- public:
-  ValueArray22(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray22& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23>
-class ValueArray23 {
- public:
-  ValueArray23(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) : v1_(v1), v2_(v2),
-      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray23& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24>
-class ValueArray24 {
- public:
-  ValueArray24(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) : v1_(v1),
-      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
-      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
-      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
-      v22_(v22), v23_(v23), v24_(v24) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray24& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25>
-class ValueArray25 {
- public:
-  ValueArray25(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
-      T25 v25) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray25& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26>
-class ValueArray26 {
- public:
-  ValueArray26(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray26& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27>
-class ValueArray27 {
- public:
-  ValueArray27(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
-      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
-      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
-      v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
-      v26_(v26), v27_(v27) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray27& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28>
-class ValueArray28 {
- public:
-  ValueArray28(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
-      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
-      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
-      v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
-      v25_(v25), v26_(v26), v27_(v27), v28_(v28) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray28& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29>
-class ValueArray29 {
- public:
-  ValueArray29(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
-      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
-      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
-      v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
-      v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray29& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30>
-class ValueArray30 {
- public:
-  ValueArray30(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
-      v29_(v29), v30_(v30) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray30& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31>
-class ValueArray31 {
- public:
-  ValueArray31(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) : v1_(v1), v2_(v2),
-      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
-      v29_(v29), v30_(v30), v31_(v31) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray31& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32>
-class ValueArray32 {
- public:
-  ValueArray32(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32) : v1_(v1),
-      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
-      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
-      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
-      v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
-      v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray32& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33>
-class ValueArray33 {
- public:
-  ValueArray33(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
-      T33 v33) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
-      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
-      v33_(v33) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray33& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34>
-class ValueArray34 {
- public:
-  ValueArray34(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
-      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
-      v33_(v33), v34_(v34) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray34& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35>
-class ValueArray35 {
- public:
-  ValueArray35(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
-      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
-      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
-      v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
-      v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
-      v32_(v32), v33_(v33), v34_(v34), v35_(v35) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray35& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36>
-class ValueArray36 {
- public:
-  ValueArray36(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
-      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
-      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
-      v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
-      v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
-      v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray36& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37>
-class ValueArray37 {
- public:
-  ValueArray37(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
-      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
-      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
-      v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
-      v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
-      v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
-      v36_(v36), v37_(v37) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray37& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38>
-class ValueArray38 {
- public:
-  ValueArray38(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
-      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
-      v35_(v35), v36_(v36), v37_(v37), v38_(v38) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray38& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39>
-class ValueArray39 {
- public:
-  ValueArray39(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39) : v1_(v1), v2_(v2),
-      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
-      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
-      v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray39& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40>
-class ValueArray40 {
- public:
-  ValueArray40(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) : v1_(v1),
-      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
-      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
-      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
-      v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
-      v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
-      v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
-      v40_(v40) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray40& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41>
-class ValueArray41 {
- public:
-  ValueArray41(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
-      T41 v41) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
-      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
-      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
-      v39_(v39), v40_(v40), v41_(v41) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray41& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42>
-class ValueArray42 {
- public:
-  ValueArray42(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
-      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
-      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
-      v39_(v39), v40_(v40), v41_(v41), v42_(v42) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray42& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43>
-class ValueArray43 {
- public:
-  ValueArray43(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
-      v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
-      v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
-      v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
-      v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
-      v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37),
-      v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray43& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44>
-class ValueArray44 {
- public:
-  ValueArray44(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
-      v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
-      v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
-      v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
-      v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
-      v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36),
-      v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42),
-      v43_(v43), v44_(v44) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray44& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45>
-class ValueArray45 {
- public:
-  ValueArray45(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44, T45 v45) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
-      v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
-      v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
-      v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
-      v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
-      v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
-      v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41),
-      v42_(v42), v43_(v43), v44_(v44), v45_(v45) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
-        static_cast<T>(v45_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray45& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-  const T45 v45_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46>
-class ValueArray46 {
- public:
-  ValueArray46(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) : v1_(v1), v2_(v2), v3_(v3),
-      v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
-      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
-      v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
-      v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
-        static_cast<T>(v45_), static_cast<T>(v46_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray46& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-  const T45 v45_;
-  const T46 v46_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47>
-class ValueArray47 {
- public:
-  ValueArray47(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) : v1_(v1), v2_(v2),
-      v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
-      v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
-      v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
-      v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
-      v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
-      v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
-      v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46),
-      v47_(v47) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
-        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray47& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-  const T45 v45_;
-  const T46 v46_;
-  const T47 v47_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48>
-class ValueArray48 {
- public:
-  ValueArray48(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48) : v1_(v1),
-      v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
-      v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
-      v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
-      v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
-      v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
-      v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
-      v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45),
-      v46_(v46), v47_(v47), v48_(v48) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
-        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
-        static_cast<T>(v48_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray48& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-  const T45 v45_;
-  const T46 v46_;
-  const T47 v47_;
-  const T48 v48_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49>
-class ValueArray49 {
- public:
-  ValueArray49(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48,
-      T49 v49) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
-      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
-      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
-      v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
-      v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
-        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
-        static_cast<T>(v48_), static_cast<T>(v49_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray49& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-  const T45 v45_;
-  const T46 v46_;
-  const T47 v47_;
-  const T48 v48_;
-  const T49 v49_;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49, typename T50>
-class ValueArray50 {
- public:
-  ValueArray50(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
-      T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
-      T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
-      T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
-      T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
-      T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49,
-      T50 v50) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
-      v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
-      v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
-      v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
-      v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
-      v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
-      v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
-      v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49), v50_(v50) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
-        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
-        static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
-        static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
-        static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
-        static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
-        static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
-        static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
-        static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
-        static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
-        static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
-        static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
-        static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
-        static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
-        static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
-        static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
-        static_cast<T>(v48_), static_cast<T>(v49_), static_cast<T>(v50_)};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray50& other);
-
-  const T1 v1_;
-  const T2 v2_;
-  const T3 v3_;
-  const T4 v4_;
-  const T5 v5_;
-  const T6 v6_;
-  const T7 v7_;
-  const T8 v8_;
-  const T9 v9_;
-  const T10 v10_;
-  const T11 v11_;
-  const T12 v12_;
-  const T13 v13_;
-  const T14 v14_;
-  const T15 v15_;
-  const T16 v16_;
-  const T17 v17_;
-  const T18 v18_;
-  const T19 v19_;
-  const T20 v20_;
-  const T21 v21_;
-  const T22 v22_;
-  const T23 v23_;
-  const T24 v24_;
-  const T25 v25_;
-  const T26 v26_;
-  const T27 v27_;
-  const T28 v28_;
-  const T29 v29_;
-  const T30 v30_;
-  const T31 v31_;
-  const T32 v32_;
-  const T33 v33_;
-  const T34 v34_;
-  const T35 v35_;
-  const T36 v36_;
-  const T37 v37_;
-  const T38 v38_;
-  const T39 v39_;
-  const T40 v40_;
-  const T41 v41_;
-  const T42 v42_;
-  const T43 v43_;
-  const T44 v44_;
-  const T45 v45_;
-  const T46 v46_;
-  const T47 v47_;
-  const T48 v48_;
-  const T49 v49_;
-  const T50 v50_;
-};
-
-# if GTEST_HAS_COMBINE
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Generates values from the Cartesian product of values produced
-// by the argument generators.
-//
-template <typename T1, typename T2>
-class CartesianProductGenerator2
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2> > {
- public:
-  typedef ::testing::tuple<T1, T2> ParamType;
-
-  CartesianProductGenerator2(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2)
-      : g1_(g1), g2_(g2) {}
-  virtual ~CartesianProductGenerator2() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current2_;
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // 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 Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&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().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator2::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator2& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-};  // class CartesianProductGenerator2
-
-
-template <typename T1, typename T2, typename T3>
-class CartesianProductGenerator3
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3> ParamType;
-
-  CartesianProductGenerator3(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3)
-      : g1_(g1), g2_(g2), g3_(g3) {}
-  virtual ~CartesianProductGenerator3() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current3_;
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // 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 Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&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().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator3::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator3& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-};  // class CartesianProductGenerator3
-
-
-template <typename T1, typename T2, typename T3, typename T4>
-class CartesianProductGenerator4
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4> ParamType;
-
-  CartesianProductGenerator4(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
-  virtual ~CartesianProductGenerator4() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current4_;
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // 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 Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&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().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator4::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator4& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-};  // class CartesianProductGenerator4
-
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-class CartesianProductGenerator5
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4, T5> ParamType;
-
-  CartesianProductGenerator5(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
-  virtual ~CartesianProductGenerator5() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end(), g5_, g5_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4,
-      const ParamGenerator<T5>& g5,
-      const typename ParamGenerator<T5>::iterator& current5)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
-          begin5_(g5.begin()), end5_(g5.end()), current5_(current5)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current5_;
-      if (current5_ == end5_) {
-        current5_ = begin5_;
-        ++current4_;
-      }
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // 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 Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&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().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_ &&
-          current5_ == typed_other->current5_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_),
-        begin5_(other.begin5_),
-        end5_(other.end5_),
-        current5_(other.current5_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_, *current5_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_ ||
-          current5_ == end5_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    const typename ParamGenerator<T5>::iterator begin5_;
-    const typename ParamGenerator<T5>::iterator end5_;
-    typename ParamGenerator<T5>::iterator current5_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator5::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator5& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-  const ParamGenerator<T5> g5_;
-};  // class CartesianProductGenerator5
-
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-class CartesianProductGenerator6
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5,
-        T6> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6> ParamType;
-
-  CartesianProductGenerator6(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
-      const ParamGenerator<T6>& g6)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
-  virtual ~CartesianProductGenerator6() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4,
-      const ParamGenerator<T5>& g5,
-      const typename ParamGenerator<T5>::iterator& current5,
-      const ParamGenerator<T6>& g6,
-      const typename ParamGenerator<T6>::iterator& current6)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
-          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
-          begin6_(g6.begin()), end6_(g6.end()), current6_(current6)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current6_;
-      if (current6_ == end6_) {
-        current6_ = begin6_;
-        ++current5_;
-      }
-      if (current5_ == end5_) {
-        current5_ = begin5_;
-        ++current4_;
-      }
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // 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 Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&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().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_ &&
-          current5_ == typed_other->current5_ &&
-          current6_ == typed_other->current6_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_),
-        begin5_(other.begin5_),
-        end5_(other.end5_),
-        current5_(other.current5_),
-        begin6_(other.begin6_),
-        end6_(other.end6_),
-        current6_(other.current6_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_, *current5_, *current6_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_ ||
-          current5_ == end5_ ||
-          current6_ == end6_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    const typename ParamGenerator<T5>::iterator begin5_;
-    const typename ParamGenerator<T5>::iterator end5_;
-    typename ParamGenerator<T5>::iterator current5_;
-    const typename ParamGenerator<T6>::iterator begin6_;
-    const typename ParamGenerator<T6>::iterator end6_;
-    typename ParamGenerator<T6>::iterator current6_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator6::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator6& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-  const ParamGenerator<T5> g5_;
-  const ParamGenerator<T6> g6_;
-};  // class CartesianProductGenerator6
-
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-class CartesianProductGenerator7
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
-        T7> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
-
-  CartesianProductGenerator7(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
-      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
-  virtual ~CartesianProductGenerator7() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
-        g7_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4,
-      const ParamGenerator<T5>& g5,
-      const typename ParamGenerator<T5>::iterator& current5,
-      const ParamGenerator<T6>& g6,
-      const typename ParamGenerator<T6>::iterator& current6,
-      const ParamGenerator<T7>& g7,
-      const typename ParamGenerator<T7>::iterator& current7)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
-          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
-          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
-          begin7_(g7.begin()), end7_(g7.end()), current7_(current7)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current7_;
-      if (current7_ == end7_) {
-        current7_ = begin7_;
-        ++current6_;
-      }
-      if (current6_ == end6_) {
-        current6_ = begin6_;
-        ++current5_;
-      }
-      if (current5_ == end5_) {
-        current5_ = begin5_;
-        ++current4_;
-      }
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // 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 Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&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().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_ &&
-          current5_ == typed_other->current5_ &&
-          current6_ == typed_other->current6_ &&
-          current7_ == typed_other->current7_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_),
-        begin5_(other.begin5_),
-        end5_(other.end5_),
-        current5_(other.current5_),
-        begin6_(other.begin6_),
-        end6_(other.end6_),
-        current6_(other.current6_),
-        begin7_(other.begin7_),
-        end7_(other.end7_),
-        current7_(other.current7_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_, *current5_, *current6_, *current7_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_ ||
-          current5_ == end5_ ||
-          current6_ == end6_ ||
-          current7_ == end7_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    const typename ParamGenerator<T5>::iterator begin5_;
-    const typename ParamGenerator<T5>::iterator end5_;
-    typename ParamGenerator<T5>::iterator current5_;
-    const typename ParamGenerator<T6>::iterator begin6_;
-    const typename ParamGenerator<T6>::iterator end6_;
-    typename ParamGenerator<T6>::iterator current6_;
-    const typename ParamGenerator<T7>::iterator begin7_;
-    const typename ParamGenerator<T7>::iterator end7_;
-    typename ParamGenerator<T7>::iterator current7_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator7::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator7& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-  const ParamGenerator<T5> g5_;
-  const ParamGenerator<T6> g6_;
-  const ParamGenerator<T7> g7_;
-};  // class CartesianProductGenerator7
-
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-class CartesianProductGenerator8
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
-        T7, T8> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType;
-
-  CartesianProductGenerator8(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
-      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
-      const ParamGenerator<T8>& g8)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
-          g8_(g8) {}
-  virtual ~CartesianProductGenerator8() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
-        g7_.begin(), g8_, g8_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
-        g8_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4,
-      const ParamGenerator<T5>& g5,
-      const typename ParamGenerator<T5>::iterator& current5,
-      const ParamGenerator<T6>& g6,
-      const typename ParamGenerator<T6>::iterator& current6,
-      const ParamGenerator<T7>& g7,
-      const typename ParamGenerator<T7>::iterator& current7,
-      const ParamGenerator<T8>& g8,
-      const typename ParamGenerator<T8>::iterator& current8)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
-          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
-          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
-          begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
-          begin8_(g8.begin()), end8_(g8.end()), current8_(current8)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current8_;
-      if (current8_ == end8_) {
-        current8_ = begin8_;
-        ++current7_;
-      }
-      if (current7_ == end7_) {
-        current7_ = begin7_;
-        ++current6_;
-      }
-      if (current6_ == end6_) {
-        current6_ = begin6_;
-        ++current5_;
-      }
-      if (current5_ == end5_) {
-        current5_ = begin5_;
-        ++current4_;
-      }
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // 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 Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&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().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_ &&
-          current5_ == typed_other->current5_ &&
-          current6_ == typed_other->current6_ &&
-          current7_ == typed_other->current7_ &&
-          current8_ == typed_other->current8_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_),
-        begin5_(other.begin5_),
-        end5_(other.end5_),
-        current5_(other.current5_),
-        begin6_(other.begin6_),
-        end6_(other.end6_),
-        current6_(other.current6_),
-        begin7_(other.begin7_),
-        end7_(other.end7_),
-        current7_(other.current7_),
-        begin8_(other.begin8_),
-        end8_(other.end8_),
-        current8_(other.current8_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_, *current5_, *current6_, *current7_, *current8_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_ ||
-          current5_ == end5_ ||
-          current6_ == end6_ ||
-          current7_ == end7_ ||
-          current8_ == end8_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    const typename ParamGenerator<T5>::iterator begin5_;
-    const typename ParamGenerator<T5>::iterator end5_;
-    typename ParamGenerator<T5>::iterator current5_;
-    const typename ParamGenerator<T6>::iterator begin6_;
-    const typename ParamGenerator<T6>::iterator end6_;
-    typename ParamGenerator<T6>::iterator current6_;
-    const typename ParamGenerator<T7>::iterator begin7_;
-    const typename ParamGenerator<T7>::iterator end7_;
-    typename ParamGenerator<T7>::iterator current7_;
-    const typename ParamGenerator<T8>::iterator begin8_;
-    const typename ParamGenerator<T8>::iterator end8_;
-    typename ParamGenerator<T8>::iterator current8_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator8::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator8& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-  const ParamGenerator<T5> g5_;
-  const ParamGenerator<T6> g6_;
-  const ParamGenerator<T7> g7_;
-  const ParamGenerator<T8> g8_;
-};  // class CartesianProductGenerator8
-
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-class CartesianProductGenerator9
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
-        T7, T8, T9> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType;
-
-  CartesianProductGenerator9(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
-      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
-      const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
-          g9_(g9) {}
-  virtual ~CartesianProductGenerator9() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
-        g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
-        g8_.end(), g9_, g9_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4,
-      const ParamGenerator<T5>& g5,
-      const typename ParamGenerator<T5>::iterator& current5,
-      const ParamGenerator<T6>& g6,
-      const typename ParamGenerator<T6>::iterator& current6,
-      const ParamGenerator<T7>& g7,
-      const typename ParamGenerator<T7>::iterator& current7,
-      const ParamGenerator<T8>& g8,
-      const typename ParamGenerator<T8>::iterator& current8,
-      const ParamGenerator<T9>& g9,
-      const typename ParamGenerator<T9>::iterator& current9)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
-          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
-          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
-          begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
-          begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
-          begin9_(g9.begin()), end9_(g9.end()), current9_(current9)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current9_;
-      if (current9_ == end9_) {
-        current9_ = begin9_;
-        ++current8_;
-      }
-      if (current8_ == end8_) {
-        current8_ = begin8_;
-        ++current7_;
-      }
-      if (current7_ == end7_) {
-        current7_ = begin7_;
-        ++current6_;
-      }
-      if (current6_ == end6_) {
-        current6_ = begin6_;
-        ++current5_;
-      }
-      if (current5_ == end5_) {
-        current5_ = begin5_;
-        ++current4_;
-      }
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // 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 Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&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().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_ &&
-          current5_ == typed_other->current5_ &&
-          current6_ == typed_other->current6_ &&
-          current7_ == typed_other->current7_ &&
-          current8_ == typed_other->current8_ &&
-          current9_ == typed_other->current9_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_),
-        begin5_(other.begin5_),
-        end5_(other.end5_),
-        current5_(other.current5_),
-        begin6_(other.begin6_),
-        end6_(other.end6_),
-        current6_(other.current6_),
-        begin7_(other.begin7_),
-        end7_(other.end7_),
-        current7_(other.current7_),
-        begin8_(other.begin8_),
-        end8_(other.end8_),
-        current8_(other.current8_),
-        begin9_(other.begin9_),
-        end9_(other.end9_),
-        current9_(other.current9_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_, *current5_, *current6_, *current7_, *current8_,
-            *current9_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_ ||
-          current5_ == end5_ ||
-          current6_ == end6_ ||
-          current7_ == end7_ ||
-          current8_ == end8_ ||
-          current9_ == end9_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    const typename ParamGenerator<T5>::iterator begin5_;
-    const typename ParamGenerator<T5>::iterator end5_;
-    typename ParamGenerator<T5>::iterator current5_;
-    const typename ParamGenerator<T6>::iterator begin6_;
-    const typename ParamGenerator<T6>::iterator end6_;
-    typename ParamGenerator<T6>::iterator current6_;
-    const typename ParamGenerator<T7>::iterator begin7_;
-    const typename ParamGenerator<T7>::iterator end7_;
-    typename ParamGenerator<T7>::iterator current7_;
-    const typename ParamGenerator<T8>::iterator begin8_;
-    const typename ParamGenerator<T8>::iterator end8_;
-    typename ParamGenerator<T8>::iterator current8_;
-    const typename ParamGenerator<T9>::iterator begin9_;
-    const typename ParamGenerator<T9>::iterator end9_;
-    typename ParamGenerator<T9>::iterator current9_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator9::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator9& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-  const ParamGenerator<T5> g5_;
-  const ParamGenerator<T6> g6_;
-  const ParamGenerator<T7> g7_;
-  const ParamGenerator<T8> g8_;
-  const ParamGenerator<T9> g9_;
-};  // class CartesianProductGenerator9
-
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-class CartesianProductGenerator10
-    : public ParamGeneratorInterface< ::testing::tuple<T1, T2, T3, T4, T5, T6,
-        T7, T8, T9, T10> > {
- public:
-  typedef ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ParamType;
-
-  CartesianProductGenerator10(const ParamGenerator<T1>& g1,
-      const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
-      const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
-      const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
-      const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9,
-      const ParamGenerator<T10>& g10)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
-          g9_(g9), g10_(g10) {}
-  virtual ~CartesianProductGenerator10() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
-        g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
-        g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin(), g10_, g10_.begin());
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
-        g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
-        g8_.end(), g9_, g9_.end(), g10_, g10_.end());
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base,
-      const ParamGenerator<T1>& g1,
-      const typename ParamGenerator<T1>::iterator& current1,
-      const ParamGenerator<T2>& g2,
-      const typename ParamGenerator<T2>::iterator& current2,
-      const ParamGenerator<T3>& g3,
-      const typename ParamGenerator<T3>::iterator& current3,
-      const ParamGenerator<T4>& g4,
-      const typename ParamGenerator<T4>::iterator& current4,
-      const ParamGenerator<T5>& g5,
-      const typename ParamGenerator<T5>::iterator& current5,
-      const ParamGenerator<T6>& g6,
-      const typename ParamGenerator<T6>::iterator& current6,
-      const ParamGenerator<T7>& g7,
-      const typename ParamGenerator<T7>::iterator& current7,
-      const ParamGenerator<T8>& g8,
-      const typename ParamGenerator<T8>::iterator& current8,
-      const ParamGenerator<T9>& g9,
-      const typename ParamGenerator<T9>::iterator& current9,
-      const ParamGenerator<T10>& g10,
-      const typename ParamGenerator<T10>::iterator& current10)
-        : base_(base),
-          begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
-          begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
-          begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
-          begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
-          begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
-          begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
-          begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
-          begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
-          begin9_(g9.begin()), end9_(g9.end()), current9_(current9),
-          begin10_(g10.begin()), end10_(g10.end()), current10_(current10)    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current10_;
-      if (current10_ == end10_) {
-        current10_ = begin10_;
-        ++current9_;
-      }
-      if (current9_ == end9_) {
-        current9_ = begin9_;
-        ++current8_;
-      }
-      if (current8_ == end8_) {
-        current8_ = begin8_;
-        ++current7_;
-      }
-      if (current7_ == end7_) {
-        current7_ = begin7_;
-        ++current6_;
-      }
-      if (current6_ == end6_) {
-        current6_ = begin6_;
-        ++current5_;
-      }
-      if (current5_ == end5_) {
-        current5_ = begin5_;
-        ++current4_;
-      }
-      if (current4_ == end4_) {
-        current4_ = begin4_;
-        ++current3_;
-      }
-      if (current3_ == end3_) {
-        current3_ = begin3_;
-        ++current2_;
-      }
-      if (current2_ == end2_) {
-        current2_ = begin2_;
-        ++current1_;
-      }
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // 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 Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&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().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         (
-          current1_ == typed_other->current1_ &&
-          current2_ == typed_other->current2_ &&
-          current3_ == typed_other->current3_ &&
-          current4_ == typed_other->current4_ &&
-          current5_ == typed_other->current5_ &&
-          current6_ == typed_other->current6_ &&
-          current7_ == typed_other->current7_ &&
-          current8_ == typed_other->current8_ &&
-          current9_ == typed_other->current9_ &&
-          current10_ == typed_other->current10_);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_),
-        begin1_(other.begin1_),
-        end1_(other.end1_),
-        current1_(other.current1_),
-        begin2_(other.begin2_),
-        end2_(other.end2_),
-        current2_(other.current2_),
-        begin3_(other.begin3_),
-        end3_(other.end3_),
-        current3_(other.current3_),
-        begin4_(other.begin4_),
-        end4_(other.end4_),
-        current4_(other.current4_),
-        begin5_(other.begin5_),
-        end5_(other.end5_),
-        current5_(other.current5_),
-        begin6_(other.begin6_),
-        end6_(other.end6_),
-        current6_(other.current6_),
-        begin7_(other.begin7_),
-        end7_(other.end7_),
-        current7_(other.current7_),
-        begin8_(other.begin8_),
-        end8_(other.end8_),
-        current8_(other.current8_),
-        begin9_(other.begin9_),
-        end9_(other.end9_),
-        current9_(other.current9_),
-        begin10_(other.begin10_),
-        end10_(other.end10_),
-        current10_(other.current10_) {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType(*current1_, *current2_, *current3_,
-            *current4_, *current5_, *current6_, *current7_, *current8_,
-            *current9_, *current10_);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-          current1_ == end1_ ||
-          current2_ == end2_ ||
-          current3_ == end3_ ||
-          current4_ == end4_ ||
-          current5_ == end5_ ||
-          current6_ == end6_ ||
-          current7_ == end7_ ||
-          current8_ == end8_ ||
-          current9_ == end9_ ||
-          current10_ == end10_;
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-    const typename ParamGenerator<T1>::iterator begin1_;
-    const typename ParamGenerator<T1>::iterator end1_;
-    typename ParamGenerator<T1>::iterator current1_;
-    const typename ParamGenerator<T2>::iterator begin2_;
-    const typename ParamGenerator<T2>::iterator end2_;
-    typename ParamGenerator<T2>::iterator current2_;
-    const typename ParamGenerator<T3>::iterator begin3_;
-    const typename ParamGenerator<T3>::iterator end3_;
-    typename ParamGenerator<T3>::iterator current3_;
-    const typename ParamGenerator<T4>::iterator begin4_;
-    const typename ParamGenerator<T4>::iterator end4_;
-    typename ParamGenerator<T4>::iterator current4_;
-    const typename ParamGenerator<T5>::iterator begin5_;
-    const typename ParamGenerator<T5>::iterator end5_;
-    typename ParamGenerator<T5>::iterator current5_;
-    const typename ParamGenerator<T6>::iterator begin6_;
-    const typename ParamGenerator<T6>::iterator end6_;
-    typename ParamGenerator<T6>::iterator current6_;
-    const typename ParamGenerator<T7>::iterator begin7_;
-    const typename ParamGenerator<T7>::iterator end7_;
-    typename ParamGenerator<T7>::iterator current7_;
-    const typename ParamGenerator<T8>::iterator begin8_;
-    const typename ParamGenerator<T8>::iterator end8_;
-    typename ParamGenerator<T8>::iterator current8_;
-    const typename ParamGenerator<T9>::iterator begin9_;
-    const typename ParamGenerator<T9>::iterator end9_;
-    typename ParamGenerator<T9>::iterator current9_;
-    const typename ParamGenerator<T10>::iterator begin10_;
-    const typename ParamGenerator<T10>::iterator end10_;
-    typename ParamGenerator<T10>::iterator current10_;
-    ParamType current_value_;
-  };  // class CartesianProductGenerator10::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator10& other);
-
-  const ParamGenerator<T1> g1_;
-  const ParamGenerator<T2> g2_;
-  const ParamGenerator<T3> g3_;
-  const ParamGenerator<T4> g4_;
-  const ParamGenerator<T5> g5_;
-  const ParamGenerator<T6> g6_;
-  const ParamGenerator<T7> g7_;
-  const ParamGenerator<T8> g8_;
-  const ParamGenerator<T9> g9_;
-  const ParamGenerator<T10> g10_;
-};  // class CartesianProductGenerator10
-
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Helper classes providing Combine() with polymorphic features. They allow
-// casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is
-// convertible to U.
-//
-template <class Generator1, class Generator2>
-class CartesianProductHolder2 {
- public:
-CartesianProductHolder2(const Generator1& g1, const Generator2& g2)
-      : g1_(g1), g2_(g2) {}
-  template <typename T1, typename T2>
-  operator ParamGenerator< ::testing::tuple<T1, T2> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2> >(
-        new CartesianProductGenerator2<T1, T2>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder2& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-};  // class CartesianProductHolder2
-
-template <class Generator1, class Generator2, class Generator3>
-class CartesianProductHolder3 {
- public:
-CartesianProductHolder3(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3)
-      : g1_(g1), g2_(g2), g3_(g3) {}
-  template <typename T1, typename T2, typename T3>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3> >(
-        new CartesianProductGenerator3<T1, T2, T3>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder3& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-};  // class CartesianProductHolder3
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4>
-class CartesianProductHolder4 {
- public:
-CartesianProductHolder4(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
-  template <typename T1, typename T2, typename T3, typename T4>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4> >(
-        new CartesianProductGenerator4<T1, T2, T3, T4>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder4& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-};  // class CartesianProductHolder4
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4, class Generator5>
-class CartesianProductHolder5 {
- public:
-CartesianProductHolder5(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4, const Generator5& g5)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
-  template <typename T1, typename T2, typename T3, typename T4, typename T5>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5> >(
-        new CartesianProductGenerator5<T1, T2, T3, T4, T5>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_),
-        static_cast<ParamGenerator<T5> >(g5_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder5& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-  const Generator5 g5_;
-};  // class CartesianProductHolder5
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4, class Generator5, class Generator6>
-class CartesianProductHolder6 {
- public:
-CartesianProductHolder6(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4, const Generator5& g5,
-    const Generator6& g6)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-      typename T6>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >(
-        new CartesianProductGenerator6<T1, T2, T3, T4, T5, T6>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_),
-        static_cast<ParamGenerator<T5> >(g5_),
-        static_cast<ParamGenerator<T6> >(g6_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder6& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-  const Generator5 g5_;
-  const Generator6 g6_;
-};  // class CartesianProductHolder6
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4, class Generator5, class Generator6, class Generator7>
-class CartesianProductHolder7 {
- public:
-CartesianProductHolder7(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4, const Generator5& g5,
-    const Generator6& g6, const Generator7& g7)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-      typename T6, typename T7>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6,
-      T7> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7> >(
-        new CartesianProductGenerator7<T1, T2, T3, T4, T5, T6, T7>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_),
-        static_cast<ParamGenerator<T5> >(g5_),
-        static_cast<ParamGenerator<T6> >(g6_),
-        static_cast<ParamGenerator<T7> >(g7_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder7& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-  const Generator5 g5_;
-  const Generator6 g6_;
-  const Generator7 g7_;
-};  // class CartesianProductHolder7
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4, class Generator5, class Generator6, class Generator7,
-    class Generator8>
-class CartesianProductHolder8 {
- public:
-CartesianProductHolder8(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4, const Generator5& g5,
-    const Generator6& g6, const Generator7& g7, const Generator8& g8)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
-          g8_(g8) {}
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-      typename T6, typename T7, typename T8>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7,
-      T8> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8> >(
-        new CartesianProductGenerator8<T1, T2, T3, T4, T5, T6, T7, T8>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_),
-        static_cast<ParamGenerator<T5> >(g5_),
-        static_cast<ParamGenerator<T6> >(g6_),
-        static_cast<ParamGenerator<T7> >(g7_),
-        static_cast<ParamGenerator<T8> >(g8_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder8& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-  const Generator5 g5_;
-  const Generator6 g6_;
-  const Generator7 g7_;
-  const Generator8 g8_;
-};  // class CartesianProductHolder8
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4, class Generator5, class Generator6, class Generator7,
-    class Generator8, class Generator9>
-class CartesianProductHolder9 {
- public:
-CartesianProductHolder9(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4, const Generator5& g5,
-    const Generator6& g6, const Generator7& g7, const Generator8& g8,
-    const Generator9& g9)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
-          g9_(g9) {}
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-      typename T6, typename T7, typename T8, typename T9>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
-      T9> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
-        T9> >(
-        new CartesianProductGenerator9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_),
-        static_cast<ParamGenerator<T5> >(g5_),
-        static_cast<ParamGenerator<T6> >(g6_),
-        static_cast<ParamGenerator<T7> >(g7_),
-        static_cast<ParamGenerator<T8> >(g8_),
-        static_cast<ParamGenerator<T9> >(g9_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder9& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-  const Generator5 g5_;
-  const Generator6 g6_;
-  const Generator7 g7_;
-  const Generator8 g8_;
-  const Generator9 g9_;
-};  // class CartesianProductHolder9
-
-template <class Generator1, class Generator2, class Generator3,
-    class Generator4, class Generator5, class Generator6, class Generator7,
-    class Generator8, class Generator9, class Generator10>
-class CartesianProductHolder10 {
- public:
-CartesianProductHolder10(const Generator1& g1, const Generator2& g2,
-    const Generator3& g3, const Generator4& g4, const Generator5& g5,
-    const Generator6& g6, const Generator7& g7, const Generator8& g8,
-    const Generator9& g9, const Generator10& g10)
-      : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
-          g9_(g9), g10_(g10) {}
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-      typename T6, typename T7, typename T8, typename T9, typename T10>
-  operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9,
-      T10> >() const {
-    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9,
-        T10> >(
-        new CartesianProductGenerator10<T1, T2, T3, T4, T5, T6, T7, T8, T9,
-            T10>(
-        static_cast<ParamGenerator<T1> >(g1_),
-        static_cast<ParamGenerator<T2> >(g2_),
-        static_cast<ParamGenerator<T3> >(g3_),
-        static_cast<ParamGenerator<T4> >(g4_),
-        static_cast<ParamGenerator<T5> >(g5_),
-        static_cast<ParamGenerator<T6> >(g6_),
-        static_cast<ParamGenerator<T7> >(g7_),
-        static_cast<ParamGenerator<T8> >(g8_),
-        static_cast<ParamGenerator<T9> >(g9_),
-        static_cast<ParamGenerator<T10> >(g10_)));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder10& other);
-
-  const Generator1 g1_;
-  const Generator2 g2_;
-  const Generator3 g3_;
-  const Generator4 g4_;
-  const Generator5 g5_;
-  const Generator6 g6_;
-  const Generator7 g7_;
-  const Generator8 g8_;
-  const Generator9 g9_;
-  const Generator10 g10_;
-};  // class CartesianProductHolder10
-
-# endif  // GTEST_HAS_COMBINE
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  //  GTEST_HAS_PARAM_TEST
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h.pump b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h.pump
deleted file mode 100644
index 5c7c47af..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util-generated.h.pump
+++ /dev/null
@@ -1,286 +0,0 @@
-$$ -*- mode: c++; -*-
-$var n = 50  $$ Maximum length of Values arguments we want to support.
-$var maxtuple = 10  $$ Maximum number of Combine arguments we want to support.
-// 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-
-// Type and function utilities for implementing parameterized tests.
-// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
-//
-// Currently Google Test supports at most $n arguments in Values,
-// and at most $maxtuple arguments in Combine. Please contact
-// googletestframework@googlegroups.com if you need more.
-// Please note that the number of arguments to Combine is limited
-// by the maximum arity of the implementation of tuple which is
-// currently set at $maxtuple.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
-
-// scripts/fuse_gtest.py depends on gtest's own header being #included
-// *unconditionally*.  Therefore these #includes cannot be moved
-// inside #if GTEST_HAS_PARAM_TEST.
-#include "gtest/internal/gtest-param-util.h"
-#include "gtest/internal/gtest-port.h"
-
-#if GTEST_HAS_PARAM_TEST
-
-namespace testing {
-
-// Forward declarations of ValuesIn(), which is implemented in
-// include/gtest/gtest-param-test.h.
-template <typename ForwardIterator>
-internal::ParamGenerator<
-  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
-ValuesIn(ForwardIterator begin, ForwardIterator end);
-
-template <typename T, size_t N>
-internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);
-
-template <class Container>
-internal::ParamGenerator<typename Container::value_type> ValuesIn(
-    const Container& container);
-
-namespace internal {
-
-// Used in the Values() function to provide polymorphic capabilities.
-$range i 1..n
-$for i [[
-$range j 1..i
-
-template <$for j, [[typename T$j]]>
-class ValueArray$i {
- public:
-  $if i==1 [[explicit ]]ValueArray$i($for j, [[T$j v$j]]) : $for j, [[v$(j)_(v$j)]] {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {
-    const T array[] = {$for j, [[static_cast<T>(v$(j)_)]]};
-    return ValuesIn(array);
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const ValueArray$i& other);
-
-$for j [[
-
-  const T$j v$(j)_;
-]]
-
-};
-
-]]
-
-# if GTEST_HAS_COMBINE
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Generates values from the Cartesian product of values produced
-// by the argument generators.
-//
-$range i 2..maxtuple
-$for i [[
-$range j 1..i
-$range k 2..i
-
-template <$for j, [[typename T$j]]>
-class CartesianProductGenerator$i
-    : public ParamGeneratorInterface< ::testing::tuple<$for j, [[T$j]]> > {
- public:
-  typedef ::testing::tuple<$for j, [[T$j]]> ParamType;
-
-  CartesianProductGenerator$i($for j, [[const ParamGenerator<T$j>& g$j]])
-      : $for j, [[g$(j)_(g$j)]] {}
-  virtual ~CartesianProductGenerator$i() {}
-
-  virtual ParamIteratorInterface<ParamType>* Begin() const {
-    return new Iterator(this, $for j, [[g$(j)_, g$(j)_.begin()]]);
-  }
-  virtual ParamIteratorInterface<ParamType>* End() const {
-    return new Iterator(this, $for j, [[g$(j)_, g$(j)_.end()]]);
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<ParamType> {
-   public:
-    Iterator(const ParamGeneratorInterface<ParamType>* base, $for j, [[
-
-      const ParamGenerator<T$j>& g$j,
-      const typename ParamGenerator<T$j>::iterator& current$(j)]])
-        : base_(base),
-$for j, [[
-
-          begin$(j)_(g$j.begin()), end$(j)_(g$j.end()), current$(j)_(current$j)
-]]    {
-      ComputeCurrentValue();
-    }
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    virtual void Advance() {
-      assert(!AtEnd());
-      ++current$(i)_;
-
-$for k [[
-      if (current$(i+2-k)_ == end$(i+2-k)_) {
-        current$(i+2-k)_ = begin$(i+2-k)_;
-        ++current$(i+2-k-1)_;
-      }
-
-]]
-      ComputeCurrentValue();
-    }
-    virtual ParamIteratorInterface<ParamType>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const ParamType* Current() const { return &current_value_; }
-    virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
-      // 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 Iterator* typed_other =
-          CheckedDowncastToActualType<const Iterator>(&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().
-      return (AtEnd() && typed_other->AtEnd()) ||
-         ($for j  && [[
-
-          current$(j)_ == typed_other->current$(j)_
-]]);
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : base_(other.base_), $for j, [[
-
-        begin$(j)_(other.begin$(j)_),
-        end$(j)_(other.end$(j)_),
-        current$(j)_(other.current$(j)_)
-]] {
-      ComputeCurrentValue();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = ParamType($for j, [[*current$(j)_]]);
-    }
-    bool AtEnd() const {
-      // We must report iterator past the end of the range when either of the
-      // component iterators has reached the end of its range.
-      return
-$for j  || [[
-
-          current$(j)_ == end$(j)_
-]];
-    }
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
-    // current[i]_ is the actual traversing iterator.
-$for j [[
-
-    const typename ParamGenerator<T$j>::iterator begin$(j)_;
-    const typename ParamGenerator<T$j>::iterator end$(j)_;
-    typename ParamGenerator<T$j>::iterator current$(j)_;
-]]
-
-    ParamType current_value_;
-  };  // class CartesianProductGenerator$i::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductGenerator$i& other);
-
-
-$for j [[
-  const ParamGenerator<T$j> g$(j)_;
-
-]]
-};  // class CartesianProductGenerator$i
-
-
-]]
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Helper classes providing Combine() with polymorphic features. They allow
-// casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is
-// convertible to U.
-//
-$range i 2..maxtuple
-$for i [[
-$range j 1..i
-
-template <$for j, [[class Generator$j]]>
-class CartesianProductHolder$i {
- public:
-CartesianProductHolder$i($for j, [[const Generator$j& g$j]])
-      : $for j, [[g$(j)_(g$j)]] {}
-  template <$for j, [[typename T$j]]>
-  operator ParamGenerator< ::testing::tuple<$for j, [[T$j]]> >() const {
-    return ParamGenerator< ::testing::tuple<$for j, [[T$j]]> >(
-        new CartesianProductGenerator$i<$for j, [[T$j]]>(
-$for j,[[
-
-        static_cast<ParamGenerator<T$j> >(g$(j)_)
-]]));
-  }
-
- private:
-  // No implementation - assignment is unsupported.
-  void operator=(const CartesianProductHolder$i& other);
-
-
-$for j [[
-  const Generator$j g$(j)_;
-
-]]
-};  // class CartesianProductHolder$i
-
-]]
-
-# endif  // GTEST_HAS_COMBINE
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  //  GTEST_HAS_PARAM_TEST
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util.h
deleted file mode 100644
index 82cab9b0..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-param-util.h
+++ /dev/null
@@ -1,731 +0,0 @@
-// 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-
-// Type and function utilities for implementing parameterized tests.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
-
-#include <ctype.h>
-
-#include <iterator>
-#include <set>
-#include <utility>
-#include <vector>
-
-// scripts/fuse_gtest.py depends on gtest's own header being #included
-// *unconditionally*.  Therefore these #includes cannot be moved
-// inside #if GTEST_HAS_PARAM_TEST.
-#include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-linked_ptr.h"
-#include "gtest/internal/gtest-port.h"
-#include "gtest/gtest-printers.h"
-
-#if GTEST_HAS_PARAM_TEST
-
-namespace testing {
-
-// Input to a parameterized test name generator, describing a test parameter.
-// Consists of the parameter value and the integer parameter index.
-template <class ParamType>
-struct TestParamInfo {
-  TestParamInfo(const ParamType& a_param, size_t an_index) :
-    param(a_param),
-    index(an_index) {}
-  ParamType param;
-  size_t index;
-};
-
-// A builtin parameterized test name generator which returns the result of
-// testing::PrintToString.
-struct PrintToStringParamName {
-  template <class ParamType>
-  std::string operator()(const TestParamInfo<ParamType>& info) const {
-    return PrintToString(info.param);
-  }
-};
-
-namespace internal {
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Outputs a message explaining invalid registration of different
-// fixture class for the same test case. This may happen when
-// TEST_P macro is used to define two tests with the same name
-// but in different namespaces.
-GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name,
-                                          CodeLocation code_location);
-
-template <typename> class ParamGeneratorInterface;
-template <typename> class ParamGenerator;
-
-// Interface for iterating over elements provided by an implementation
-// of ParamGeneratorInterface<T>.
-template <typename T>
-class ParamIteratorInterface {
- public:
-  virtual ~ParamIteratorInterface() {}
-  // A pointer to the base generator instance.
-  // Used only for the purposes of iterator comparison
-  // to make sure that two iterators belong to the same generator.
-  virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
-  // Advances iterator to point to the next element
-  // provided by the generator. The caller is responsible
-  // for not calling Advance() on an iterator equal to
-  // BaseGenerator()->End().
-  virtual void Advance() = 0;
-  // Clones the iterator object. Used for implementing copy semantics
-  // of ParamIterator<T>.
-  virtual ParamIteratorInterface* Clone() const = 0;
-  // Dereferences the current iterator and provides (read-only) access
-  // to the pointed value. It is the caller's responsibility not to call
-  // Current() on an iterator equal to BaseGenerator()->End().
-  // Used for implementing ParamGenerator<T>::operator*().
-  virtual const T* Current() const = 0;
-  // Determines whether the given iterator and other point to the same
-  // element in the sequence generated by the generator.
-  // Used for implementing ParamGenerator<T>::operator==().
-  virtual bool Equals(const ParamIteratorInterface& other) const = 0;
-};
-
-// Class iterating over elements provided by an implementation of
-// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
-// and implements the const forward iterator concept.
-template <typename T>
-class ParamIterator {
- public:
-  typedef T value_type;
-  typedef const T& reference;
-  typedef ptrdiff_t difference_type;
-
-  // ParamIterator assumes ownership of the impl_ pointer.
-  ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
-  ParamIterator& operator=(const ParamIterator& other) {
-    if (this != &other)
-      impl_.reset(other.impl_->Clone());
-    return *this;
-  }
-
-  const T& operator*() const { return *impl_->Current(); }
-  const T* operator->() const { return impl_->Current(); }
-  // Prefix version of operator++.
-  ParamIterator& operator++() {
-    impl_->Advance();
-    return *this;
-  }
-  // Postfix version of operator++.
-  ParamIterator operator++(int /*unused*/) {
-    ParamIteratorInterface<T>* clone = impl_->Clone();
-    impl_->Advance();
-    return ParamIterator(clone);
-  }
-  bool operator==(const ParamIterator& other) const {
-    return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
-  }
-  bool operator!=(const ParamIterator& other) const {
-    return !(*this == other);
-  }
-
- private:
-  friend class ParamGenerator<T>;
-  explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
-  scoped_ptr<ParamIteratorInterface<T> > impl_;
-};
-
-// ParamGeneratorInterface<T> is the binary interface to access generators
-// defined in other translation units.
-template <typename T>
-class ParamGeneratorInterface {
- public:
-  typedef T ParamType;
-
-  virtual ~ParamGeneratorInterface() {}
-
-  // Generator interface definition
-  virtual ParamIteratorInterface<T>* Begin() const = 0;
-  virtual ParamIteratorInterface<T>* End() const = 0;
-};
-
-// Wraps ParamGeneratorInterface<T> and provides general generator syntax
-// compatible with the STL Container concept.
-// This class implements copy initialization semantics and the contained
-// ParamGeneratorInterface<T> instance is shared among all copies
-// of the original object. This is possible because that instance is immutable.
-template<typename T>
-class ParamGenerator {
- public:
-  typedef ParamIterator<T> iterator;
-
-  explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
-  ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}
-
-  ParamGenerator& operator=(const ParamGenerator& other) {
-    impl_ = other.impl_;
-    return *this;
-  }
-
-  iterator begin() const { return iterator(impl_->Begin()); }
-  iterator end() const { return iterator(impl_->End()); }
-
- private:
-  linked_ptr<const ParamGeneratorInterface<T> > impl_;
-};
-
-// Generates values from a range of two comparable values. Can be used to
-// generate sequences of user-defined types that implement operator+() and
-// operator<().
-// This class is used in the Range() function.
-template <typename T, typename IncrementT>
-class RangeGenerator : public ParamGeneratorInterface<T> {
- public:
-  RangeGenerator(T begin, T end, IncrementT step)
-      : begin_(begin), end_(end),
-        step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
-  virtual ~RangeGenerator() {}
-
-  virtual ParamIteratorInterface<T>* Begin() const {
-    return new Iterator(this, begin_, 0, step_);
-  }
-  virtual ParamIteratorInterface<T>* End() const {
-    return new Iterator(this, end_, end_index_, step_);
-  }
-
- private:
-  class Iterator : public ParamIteratorInterface<T> {
-   public:
-    Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
-             IncrementT step)
-        : base_(base), value_(value), index_(index), step_(step) {}
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
-      return base_;
-    }
-    virtual void Advance() {
-      value_ = static_cast<T>(value_ + step_);
-      index_++;
-    }
-    virtual ParamIteratorInterface<T>* Clone() const {
-      return new Iterator(*this);
-    }
-    virtual const T* Current() const { return &value_; }
-    virtual bool Equals(const ParamIteratorInterface<T>& other) const {
-      // 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 int other_index =
-          CheckedDowncastToActualType<const Iterator>(&other)->index_;
-      return index_ == other_index;
-    }
-
-   private:
-    Iterator(const Iterator& other)
-        : ParamIteratorInterface<T>(),
-          base_(other.base_), value_(other.value_), index_(other.index_),
-          step_(other.step_) {}
-
-    // No implementation - assignment is unsupported.
-    void operator=(const Iterator& other);
-
-    const ParamGeneratorInterface<T>* const base_;
-    T value_;
-    int index_;
-    const IncrementT step_;
-  };  // class RangeGenerator::Iterator
-
-  static int CalculateEndIndex(const T& begin,
-                               const T& end,
-                               const IncrementT& step) {
-    int end_index = 0;
-    for (T i = begin; i < end; i = static_cast<T>(i + step))
-      end_index++;
-    return end_index;
-  }
-
-  // No implementation - assignment is unsupported.
-  void operator=(const RangeGenerator& other);
-
-  const T begin_;
-  const T end_;
-  const IncrementT step_;
-  // The index for the end() iterator. All the elements in the generated
-  // sequence are indexed (0-based) to aid iterator comparison.
-  const int end_index_;
-};  // class RangeGenerator
-
-
-// Generates values from a pair of STL-style iterators. Used in the
-// ValuesIn() function. The elements are copied from the source range
-// since the source can be located on the stack, and the generator
-// is likely to persist beyond that stack frame.
-template <typename T>
-class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
- public:
-  template <typename ForwardIterator>
-  ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
-      : container_(begin, end) {}
-  virtual ~ValuesInIteratorRangeGenerator() {}
-
-  virtual ParamIteratorInterface<T>* Begin() const {
-    return new Iterator(this, container_.begin());
-  }
-  virtual ParamIteratorInterface<T>* End() const {
-    return new Iterator(this, container_.end());
-  }
-
- private:
-  typedef typename ::std::vector<T> ContainerType;
-
-  class Iterator : public ParamIteratorInterface<T> {
-   public:
-    Iterator(const ParamGeneratorInterface<T>* base,
-             typename ContainerType::const_iterator iterator)
-        : base_(base), iterator_(iterator) {}
-    virtual ~Iterator() {}
-
-    virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
-      return base_;
-    }
-    virtual void Advance() {
-      ++iterator_;
-      value_.reset();
-    }
-    virtual ParamIteratorInterface<T>* Clone() const {
-      return new Iterator(*this);
-    }
-    // We need to use cached value referenced by iterator_ because *iterator_
-    // can return a temporary object (and of type other then T), so just
-    // having "return &*iterator_;" doesn't work.
-    // value_ is updated here and not in Advance() because Advance()
-    // 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.
-    virtual const T* Current() const {
-      if (value_.get() == NULL)
-        value_.reset(new T(*iterator_));
-      return value_.get();
-    }
-    virtual bool Equals(const ParamIteratorInterface<T>& other) const {
-      // 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;
-      return iterator_ ==
-          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
-    }
-
-   private:
-    Iterator(const Iterator& other)
-          // The explicit constructor call suppresses a false warning
-          // emitted by gcc when supplied with the -Wextra option.
-        : ParamIteratorInterface<T>(),
-          base_(other.base_),
-          iterator_(other.iterator_) {}
-
-    const ParamGeneratorInterface<T>* const base_;
-    typename ContainerType::const_iterator iterator_;
-    // 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 scoped_ptr helps manage cached value's lifetime,
-    // which is bound by the lifespan of the iterator itself.
-    mutable scoped_ptr<const T> value_;
-  };  // class ValuesInIteratorRangeGenerator::Iterator
-
-  // No implementation - assignment is unsupported.
-  void operator=(const ValuesInIteratorRangeGenerator& other);
-
-  const ContainerType container_;
-};  // class ValuesInIteratorRangeGenerator
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Default parameterized test name generator, returns a string containing the
-// integer test parameter index.
-template <class ParamType>
-std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
-  Message name_stream;
-  name_stream << info.index;
-  return name_stream.GetString();
-}
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Parameterized test name overload helpers, which help the
-// INSTANTIATE_TEST_CASE_P macro choose between the default parameterized
-// test name generator and user param name generator.
-template <class ParamType, class ParamNameGenFunctor>
-ParamNameGenFunctor GetParamNameGen(ParamNameGenFunctor func) {
-  return func;
-}
-
-template <class ParamType>
-struct ParamNameGenFunc {
-  typedef std::string Type(const TestParamInfo<ParamType>&);
-};
-
-template <class ParamType>
-typename ParamNameGenFunc<ParamType>::Type *GetParamNameGen() {
-  return DefaultParamName;
-}
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Stores a parameter value and later creates tests parameterized with that
-// value.
-template <class TestClass>
-class ParameterizedTestFactory : public TestFactoryBase {
- public:
-  typedef typename TestClass::ParamType ParamType;
-  explicit ParameterizedTestFactory(ParamType parameter) :
-      parameter_(parameter) {}
-  virtual Test* CreateTest() {
-    TestClass::SetParam(&parameter_);
-    return new TestClass();
-  }
-
- private:
-  const ParamType parameter_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
-};
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// TestMetaFactoryBase is a base class for meta-factories that create
-// test factories for passing into MakeAndRegisterTestInfo function.
-template <class ParamType>
-class TestMetaFactoryBase {
- public:
-  virtual ~TestMetaFactoryBase() {}
-
-  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
-};
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// 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 ParameterizedTestCaseInfo is going to call
-// it for each Test/Parameter value combination. Thus it needs meta factory
-// creator class.
-template <class TestCase>
-class TestMetaFactory
-    : public TestMetaFactoryBase<typename TestCase::ParamType> {
- public:
-  typedef typename TestCase::ParamType ParamType;
-
-  TestMetaFactory() {}
-
-  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) {
-    return new ParameterizedTestFactory<TestCase>(parameter);
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
-};
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// ParameterizedTestCaseInfoBase is a generic interface
-// to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase
-// accumulates test information provided by TEST_P macro invocations
-// and generators provided by INSTANTIATE_TEST_CASE_P macro invocations
-// and uses that information to register all resulting test instances
-// in RegisterTests method. The ParameterizeTestCaseRegistry class holds
-// a collection of pointers to the ParameterizedTestCaseInfo objects
-// and calls RegisterTests() on each of them when asked.
-class ParameterizedTestCaseInfoBase {
- public:
-  virtual ~ParameterizedTestCaseInfoBase() {}
-
-  // Base part of test case name for display purposes.
-  virtual const string& GetTestCaseName() const = 0;
-  // Test case id to verify identity.
-  virtual TypeId GetTestCaseTypeId() const = 0;
-  // UnitTest class invokes this method to register tests in this
-  // test case right before running them in RUN_ALL_TESTS macro.
-  // This method should not be called more then once on any single
-  // instance of a ParameterizedTestCaseInfoBase derived class.
-  virtual void RegisterTests() = 0;
-
- protected:
-  ParameterizedTestCaseInfoBase() {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase);
-};
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// ParameterizedTestCaseInfo accumulates tests obtained from TEST_P
-// macro invocations for a particular test case and generators
-// obtained from INSTANTIATE_TEST_CASE_P macro invocations for that
-// test case. It registers tests with all values generated by all
-// generators when asked.
-template <class TestCase>
-class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
- public:
-  // ParamType and GeneratorCreationFunc are private types but are required
-  // for declarations of public methods AddTestPattern() and
-  // AddTestCaseInstantiation().
-  typedef typename TestCase::ParamType ParamType;
-  // A function that returns an instance of appropriate generator type.
-  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
-  typedef typename ParamNameGenFunc<ParamType>::Type ParamNameGeneratorFunc;
-
-  explicit ParameterizedTestCaseInfo(
-      const char* name, CodeLocation code_location)
-      : test_case_name_(name), code_location_(code_location) {}
-
-  // Test case base name for display purposes.
-  virtual const string& GetTestCaseName() const { return test_case_name_; }
-  // Test case id to verify identity.
-  virtual TypeId GetTestCaseTypeId() const { return GetTypeId<TestCase>(); }
-  // TEST_P macro uses AddTestPattern() to record information
-  // about a single test in a LocalTestInfo structure.
-  // test_case_name is the base name of the test case (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 case base name and DoBar is test base name.
-  void AddTestPattern(const char* test_case_name,
-                      const char* test_base_name,
-                      TestMetaFactoryBase<ParamType>* meta_factory) {
-    tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name,
-                                                       test_base_name,
-                                                       meta_factory)));
-  }
-  // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information
-  // about a generator.
-  int AddTestCaseInstantiation(const 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 case
-  // test cases right before running tests in RUN_ALL_TESTS macro.
-  // This method should not be called more then once on any single
-  // instance of a ParameterizedTestCaseInfoBase derived class.
-  // UnitTest has a guard to prevent from calling this method more then once.
-  virtual void RegisterTests() {
-    for (typename TestInfoContainer::iterator test_it = tests_.begin();
-         test_it != tests_.end(); ++test_it) {
-      linked_ptr<TestInfo> test_info = *test_it;
-      for (typename InstantiationContainer::iterator gen_it =
-               instantiations_.begin(); gen_it != instantiations_.end();
-               ++gen_it) {
-        const 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;
-
-        string test_case_name;
-        if ( !instantiation_name.empty() )
-          test_case_name = instantiation_name + "/";
-        test_case_name += test_info->test_case_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) {
-          Message test_name_stream;
-
-          std::string param_name = name_func(
-              TestParamInfo<ParamType>(*param_it, i));
-
-          GTEST_CHECK_(IsValidParamName(param_name))
-              << "Parameterized test name '" << param_name
-              << "' is invalid, in " << file
-              << " line " << line << std::endl;
-
-          GTEST_CHECK_(test_param_names.count(param_name) == 0)
-              << "Duplicate parameterized test name '" << param_name
-              << "', in " << file << " line " << line << std::endl;
-
-          test_param_names.insert(param_name);
-
-          test_name_stream << test_info->test_base_name << "/" << param_name;
-          MakeAndRegisterTestInfo(
-              test_case_name.c_str(),
-              test_name_stream.GetString().c_str(),
-              NULL,  // No type parameter.
-              PrintToString(*param_it).c_str(),
-              code_location_,
-              GetTestCaseTypeId(),
-              TestCase::SetUpTestCase,
-              TestCase::TearDownTestCase,
-              test_info->test_meta_factory->CreateTestFactory(*param_it));
-        }  // for param_it
-      }  // for gen_it
-    }  // for test_it
-  }  // RegisterTests
-
- private:
-  // LocalTestInfo structure keeps information about a single test registered
-  // with TEST_P macro.
-  struct TestInfo {
-    TestInfo(const char* a_test_case_base_name,
-             const char* a_test_base_name,
-             TestMetaFactoryBase<ParamType>* a_test_meta_factory) :
-        test_case_base_name(a_test_case_base_name),
-        test_base_name(a_test_base_name),
-        test_meta_factory(a_test_meta_factory) {}
-
-    const string test_case_base_name;
-    const string test_base_name;
-    const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
-  };
-  typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
-  // Records data received from INSTANTIATE_TEST_CASE_P macros:
-  //  <Instantiation name, Sequence generator creation function,
-  //     Name generator function, Source file, Source line>
-  struct InstantiationInfo {
-      InstantiationInfo(const std::string &name_in,
-                        GeneratorCreationFunc* generator_in,
-                        ParamNameGeneratorFunc* name_func_in,
-                        const char* file_in,
-                        int line_in)
-          : name(name_in),
-            generator(generator_in),
-            name_func(name_func_in),
-            file(file_in),
-            line(line_in) {}
-
-      std::string name;
-      GeneratorCreationFunc* generator;
-      ParamNameGeneratorFunc* name_func;
-      const char* file;
-      int line;
-  };
-  typedef ::std::vector<InstantiationInfo> InstantiationContainer;
-
-  static bool IsValidParamName(const std::string& name) {
-    // Check for empty string
-    if (name.empty())
-      return false;
-
-    // Check for invalid characters
-    for (std::string::size_type index = 0; index < name.size(); ++index) {
-      if (!isalnum(name[index]) && name[index] != '_')
-        return false;
-    }
-
-    return true;
-  }
-
-  const string test_case_name_;
-  CodeLocation code_location_;
-  TestInfoContainer tests_;
-  InstantiationContainer instantiations_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo);
-};  // class ParameterizedTestCaseInfo
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase
-// classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
-// macros use it to locate their corresponding ParameterizedTestCaseInfo
-// descriptors.
-class ParameterizedTestCaseRegistry {
- public:
-  ParameterizedTestCaseRegistry() {}
-  ~ParameterizedTestCaseRegistry() {
-    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
-         it != test_case_infos_.end(); ++it) {
-      delete *it;
-    }
-  }
-
-  // Looks up or creates and returns a structure containing information about
-  // tests and instantiations of a particular test case.
-  template <class TestCase>
-  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
-      const char* test_case_name,
-      CodeLocation code_location) {
-    ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL;
-    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
-         it != test_case_infos_.end(); ++it) {
-      if ((*it)->GetTestCaseName() == test_case_name) {
-        if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) {
-          // Complain about incorrect usage of Google Test facilities
-          // and terminate the program since we cannot guaranty correct
-          // test case setup and tear-down in this case.
-          ReportInvalidTestCaseType(test_case_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<
-              ParameterizedTestCaseInfo<TestCase> >(*it);
-        }
-        break;
-      }
-    }
-    if (typed_test_info == NULL) {
-      typed_test_info = new ParameterizedTestCaseInfo<TestCase>(
-          test_case_name, code_location);
-      test_case_infos_.push_back(typed_test_info);
-    }
-    return typed_test_info;
-  }
-  void RegisterTests() {
-    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
-         it != test_case_infos_.end(); ++it) {
-      (*it)->RegisterTests();
-    }
-  }
-
- private:
-  typedef ::std::vector<ParameterizedTestCaseInfoBase*> TestCaseInfoContainer;
-
-  TestCaseInfoContainer test_case_infos_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry);
-};
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  //  GTEST_HAS_PARAM_TEST
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port-arch.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port-arch.h
deleted file mode 100644
index 74ab9490..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port-arch.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2015, 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 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 GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
-#define GTEST_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 __SYMBIAN32__
-# define GTEST_OS_SYMBIAN 1
-#elif defined _WIN32
-# define GTEST_OS_WINDOWS 1
-# ifdef _WIN32_WCE
-#  define GTEST_OS_WINDOWS_MOBILE 1
-# elif defined(__MINGW__) || defined(__MINGW32__)
-#  define GTEST_OS_WINDOWS_MINGW 1
-# elif defined(WINAPI_FAMILY)
-#  include <winapifamily.h>
-#  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-#   define GTEST_OS_WINDOWS_DESKTOP 1
-#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
-#   define GTEST_OS_WINDOWS_PHONE 1
-#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
-#   define GTEST_OS_WINDOWS_RT 1
-#  else
-    // WINAPI_FAMILY defined but no known partition matched.
-    // Default to desktop.
-#   define GTEST_OS_WINDOWS_DESKTOP 1
-#  endif
-# else
-#  define GTEST_OS_WINDOWS_DESKTOP 1
-# endif  // _WIN32_WCE
-#elif defined __APPLE__
-# define GTEST_OS_MAC 1
-# if TARGET_OS_IPHONE
-#  define GTEST_OS_IOS 1
-# endif
-#elif defined __FreeBSD__
-# define GTEST_OS_FREEBSD 1
-#elif defined __linux__
-# define GTEST_OS_LINUX 1
-# if defined __ANDROID__
-#  define GTEST_OS_LINUX_ANDROID 1
-# endif
-#elif defined __MVS__
-# define GTEST_OS_ZOS 1
-#elif defined(__sun) && defined(__SVR4)
-# define GTEST_OS_SOLARIS 1
-#elif defined(_AIX)
-# define GTEST_OS_AIX 1
-#elif defined(__hpux)
-# define GTEST_OS_HPUX 1
-#elif defined __native_client__
-# define GTEST_OS_NACL 1
-#elif defined __OpenBSD__
-# define GTEST_OS_OPENBSD 1
-#elif defined __QNX__
-# define GTEST_OS_QNX 1
-#endif  // __CYGWIN__
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port.h
deleted file mode 100644
index 860aaaf5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-port.h
+++ /dev/null
@@ -1,2560 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Authors: wan@google.com (Zhanyong Wan)
-//
-// Low-level types and utilities for porting Google Test to various
-// platforms.  All macros ending with _ and symbols defined in an
-// internal namespace are subject to change without notice.  Code
-// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't
-// end with _ are part of Google Test's public API and can be used by
-// code outside Google Test.
-//
-// This file is fundamental to Google Test.  All other Google Test source
-// files are expected to #include this.  Therefore, it cannot #include
-// any other Google Test header.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
-
-// Environment-describing macros
-// -----------------------------
-//
-// Google Test can be used in many different environments.  Macros in
-// this section tell Google Test what kind of environment it is being
-// used in, such that Google Test can provide environment-specific
-// features and implementations.
-//
-// Google Test tries to automatically detect the properties of its
-// environment, so users usually don't need to worry about these
-// macros.  However, the automatic detection is not perfect.
-// Sometimes it's necessary for a user to define some of the following
-// macros in the build script to override Google Test's decisions.
-//
-// If the user doesn't define a macro in the list, Google Test will
-// provide a default definition.  After this header is #included, all
-// macros in this list will be defined to either 1 or 0.
-//
-// Notes to maintainers:
-//   - Each macro here is a user-tweakable knob; do not grow the list
-//     lightly.
-//   - Use #if to key off these macros.  Don't use #ifdef or "#if
-//     defined(...)", which will not work as these macros are ALWAYS
-//     defined.
-//
-//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
-//                              is/isn't available.
-//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
-//                              are enabled.
-//   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
-//                              is/isn't available (some systems define
-//                              ::string, which is different to std::string).
-//   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
-//                              is/isn't available (some systems define
-//                              ::wstring, which is different to std::wstring).
-//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
-//                              expressions are/aren't available.
-//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
-//                              is/isn't available.
-//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
-//                              enabled.
-//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
-//                              std::wstring does/doesn't work (Google Test can
-//                              be used where std::wstring is unavailable).
-//   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple
-//                              is/isn't available.
-//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
-//                              compiler supports Microsoft's "Structured
-//                              Exception Handling".
-//   GTEST_HAS_STREAM_REDIRECTION
-//                            - Define it to 1/0 to indicate whether the
-//                              platform supports I/O stream redirection using
-//                              dup() and dup2().
-//   GTEST_USE_OWN_TR1_TUPLE  - Define it to 1/0 to indicate whether Google
-//                              Test's own tr1 tuple implementation should be
-//                              used.  Unused when the user sets
-//                              GTEST_HAS_TR1_TUPLE to 0.
-//   GTEST_LANG_CXX11         - Define it to 1/0 to indicate that Google Test
-//                              is building in C++11/C++98 mode.
-//   GTEST_LINKED_AS_SHARED_LIBRARY
-//                            - Define to 1 when compiling tests that use
-//                              Google Test as a shared library (known as
-//                              DLL on Windows).
-//   GTEST_CREATE_SHARED_LIBRARY
-//                            - Define to 1 when compiling Google Test itself
-//                              as a shared library.
-
-// Platform-indicating macros
-// --------------------------
-//
-// Macros indicating the platform on which Google Test is being used
-// (a macro is defined to 1 if compiled on the given platform;
-// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
-// defines these macros automatically.  Code outside Google Test MUST
-// NOT define them.
-//
-//   GTEST_OS_AIX      - IBM AIX
-//   GTEST_OS_CYGWIN   - Cygwin
-//   GTEST_OS_FREEBSD  - FreeBSD
-//   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_OPENBSD  - OpenBSD
-//   GTEST_OS_QNX      - QNX
-//   GTEST_OS_SOLARIS  - Sun Solaris
-//   GTEST_OS_SYMBIAN  - Symbian
-//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
-//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
-//     GTEST_OS_WINDOWS_MINGW    - MinGW
-//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
-//     GTEST_OS_WINDOWS_PHONE    - Windows Phone
-//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
-//   GTEST_OS_ZOS      - z/OS
-//
-// Among the platforms, Cygwin, Linux, Max 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
-// googletestframework@googlegroups.com (patches for fixing them are
-// even more welcome!).
-//
-// It is possible that none of the GTEST_OS_* macros are defined.
-
-// Feature-indicating macros
-// -------------------------
-//
-// Macros indicating which Google Test features are available (a macro
-// is defined to 1 if the corresponding feature is supported;
-// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
-// defines these macros automatically.  Code outside Google Test MUST
-// NOT define them.
-//
-// These macros are public so that portable tests can be written.
-// Such tests typically surround code using a feature with an #if
-// which controls that code.  For example:
-//
-// #if GTEST_HAS_DEATH_TEST
-//   EXPECT_DEATH(DoSomethingDeadly());
-// #endif
-//
-//   GTEST_HAS_COMBINE      - the Combine() function (for value-parameterized
-//                            tests)
-//   GTEST_HAS_DEATH_TEST   - death tests
-//   GTEST_HAS_PARAM_TEST   - value-parameterized tests
-//   GTEST_HAS_TYPED_TEST   - typed tests
-//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
-//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
-//   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 two are mutually exclusive.
-//   GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().
-
-// Misc public macros
-// ------------------
-//
-//   GTEST_FLAG(flag_name)  - references the variable corresponding to
-//                            the given Google Test flag.
-
-// Internal utilities
-// ------------------
-//
-// The following macros and utilities are for Google Test's INTERNAL
-// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.
-//
-// Macros for basic C++ coding:
-//   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 operator=.
-//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy 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.
-//
-// C++11 feature wrappers:
-//
-//   testing::internal::move  - portability wrapper for std::move.
-//
-// Synchronization:
-//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
-//                            - synchronization primitives.
-//
-// Template meta programming:
-//   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
-//   IteratorTraits - partial implementation of std::iterator_traits, which
-//                    is not available in libCstd when compiled with Sun C++.
-//
-// Smart pointers:
-//   scoped_ptr     - as in TR2.
-//
-// Regular expressions:
-//   RE             - a simple regular expression class using the POSIX
-//                    Extended Regular Expression syntax on UNIX-like
-//                    platforms, 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.
-//   FlushInfoLog() - flushes informational log messages.
-//
-// Stdout and stderr capturing:
-//   CaptureStdout()     - starts capturing stdout.
-//   GetCapturedStdout() - stops capturing stdout and returns the captured
-//                         string.
-//   CaptureStderr()     - starts capturing stderr.
-//   GetCapturedStderr() - stops capturing stderr and returns the captured
-//                         string.
-//
-// Integer types:
-//   TypeWithSize   - maps an integer to a int type.
-//   Int32, UInt32, Int64, UInt64, TimeInMillis
-//                  - integers of known sizes.
-//   BiggestInt     - the biggest signed integer type.
-//
-// Command-line utilities:
-//   GTEST_DECLARE_*()  - declares a flag.
-//   GTEST_DEFINE_*()   - defines a flag.
-//   GetInjectableArgvs() - returns the command line as a vector of strings.
-//
-// Environment variable utilities:
-//   GetEnv()             - gets the value of an environment variable.
-//   BoolFromGTestEnv()   - parses a bool environment variable.
-//   Int32FromGTestEnv()  - parses an Int32 environment variable.
-//   StringFromGTestEnv() - parses a string environment variable.
-
-#include <ctype.h>   // for isspace, etc
-#include <stddef.h>  // for ptrdiff_t
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#ifndef _WIN32_WCE
-# include <sys/types.h>
-# include <sys/stat.h>
-#endif  // !_WIN32_WCE
-
-#if defined __APPLE__
-# include <AvailabilityMacros.h>
-# include <TargetConditionals.h>
-#endif
-
-#include <algorithm>  // NOLINT
-#include <iostream>  // NOLINT
-#include <sstream>  // NOLINT
-#include <string>  // NOLINT
-#include <utility>
-#include <vector>  // NOLINT
-
-#include "gtest/internal/gtest-port-arch.h"
-#include "gtest/internal/custom/gtest-port.h"
-
-#if !defined(GTEST_DEV_EMAIL_)
-# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
-# define GTEST_FLAG_PREFIX_ "gtest_"
-# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
-# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
-# define GTEST_NAME_ "Google Test"
-# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
-#endif  // !defined(GTEST_DEV_EMAIL_)
-
-#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
-# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
-#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
-
-// Determines the version of gcc that is used to compile this.
-#ifdef __GNUC__
-// 40302 means version 4.3.2.
-# define GTEST_GCC_VER_ \
-    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
-#endif  // __GNUC__
-
-// Macros for disabling Microsoft Visual C++ warnings.
-//
-//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
-//   /* code that triggers warnings C4800 and C4385 */
-//   GTEST_DISABLE_MSC_WARNINGS_POP_()
-#if _MSC_VER >= 1500
-# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
-    __pragma(warning(push))                        \
-    __pragma(warning(disable: warnings))
-# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
-    __pragma(warning(pop))
-#else
-// Older versions of MSVC don't have __pragma.
-# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
-# define GTEST_DISABLE_MSC_WARNINGS_POP_()
-#endif
-
-#ifndef GTEST_LANG_CXX11
-// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
-// -std={c,gnu}++{0x,11} is passed.  The C++11 standard specifies a
-// value for __cplusplus, and recent versions of clang, gcc, and
-// probably other compilers set that too in C++11 mode.
-# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L
-// Compiling in at least C++11 mode.
-#  define GTEST_LANG_CXX11 1
-# else
-#  define GTEST_LANG_CXX11 0
-# endif
-#endif
-
-// Distinct from C++11 language support, some environments don't provide
-// proper C++11 library support. Notably, it's possible to build in
-// C++11 mode when targeting Mac OS X 10.6, which has an old libstdc++
-// with no C++11 support.
-//
-// libstdc++ has sufficient C++11 support as of GCC 4.6.0, __GLIBCXX__
-// 20110325, but maintenance releases in the 4.4 and 4.5 series followed
-// this date, so check for those versions by their date stamps.
-// https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html#abi.versioning
-#if GTEST_LANG_CXX11 && \
-    (!defined(__GLIBCXX__) || ( \
-        __GLIBCXX__ >= 20110325ul &&  /* GCC >= 4.6.0 */ \
-        /* Blacklist of patch releases of older branches: */ \
-        __GLIBCXX__ != 20110416ul &&  /* GCC 4.4.6 */ \
-        __GLIBCXX__ != 20120313ul &&  /* GCC 4.4.7 */ \
-        __GLIBCXX__ != 20110428ul &&  /* GCC 4.5.3 */ \
-        __GLIBCXX__ != 20120702ul))   /* GCC 4.5.4 */
-# define GTEST_STDLIB_CXX11 1
-#endif
-
-// Only use C++11 library features if the library provides them.
-#if GTEST_STDLIB_CXX11
-# define GTEST_HAS_STD_BEGIN_AND_END_ 1
-# define GTEST_HAS_STD_FORWARD_LIST_ 1
-# define GTEST_HAS_STD_FUNCTION_ 1
-# define GTEST_HAS_STD_INITIALIZER_LIST_ 1
-# define GTEST_HAS_STD_MOVE_ 1
-# define GTEST_HAS_STD_SHARED_PTR_ 1
-# define GTEST_HAS_STD_TYPE_TRAITS_ 1
-# define GTEST_HAS_STD_UNIQUE_PTR_ 1
-#endif
-
-// C++11 specifies that <tuple> provides std::tuple.
-// Some platforms still might not have it, however.
-#if GTEST_LANG_CXX11
-# define GTEST_HAS_STD_TUPLE_ 1
-# if defined(__clang__)
-// Inspired by http://clang.llvm.org/docs/LanguageExtensions.html#__has_include
-#  if defined(__has_include) && !__has_include(<tuple>)
-#   undef GTEST_HAS_STD_TUPLE_
-#  endif
-# elif defined(_MSC_VER)
-// Inspired by boost/config/stdlib/dinkumware.hpp
-#  if defined(_CPPLIB_VER) && _CPPLIB_VER < 520
-#   undef GTEST_HAS_STD_TUPLE_
-#  endif
-# elif defined(__GLIBCXX__)
-// Inspired by boost/config/stdlib/libstdcpp3.hpp,
-// http://gcc.gnu.org/gcc-4.2/changes.html and
-// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt01ch01.html#manual.intro.status.standard.200x
-#  if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2)
-#   undef GTEST_HAS_STD_TUPLE_
-#  endif
-# endif
-#endif
-
-// Brings in definitions for functions used in the testing::internal::posix
-// namespace (read, write, close, chdir, isatty, stat). We do not currently
-// use them on Windows Mobile.
-#if GTEST_OS_WINDOWS
-# if !GTEST_OS_WINDOWS_MOBILE
-#  include <direct.h>
-#  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.
-// This assumption is verified by
-// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
-typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
-#endif
-#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
-// mentioned above.
-# include <unistd.h>
-# include <strings.h>
-#endif  // GTEST_OS_WINDOWS
-
-#if GTEST_OS_LINUX_ANDROID
-// Used to define __ANDROID_API__ matching the target NDK API level.
-#  include <android/api-level.h>  // NOLINT
-#endif
-
-// Defines this to true iff 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)
-# endif
-#endif
-
-#if GTEST_USES_PCRE
-// The appropriate headers have already been included.
-
-#elif GTEST_HAS_POSIX_RE
-
-// On some platforms, <regex.h> needs someone to define size_t, and
-// 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>.
-# include <regex.h>  // NOLINT
-
-# define GTEST_USES_POSIX_RE 1
-
-#elif GTEST_OS_WINDOWS
-
-// <regex.h> is not available on Windows.  Use our own simple regex
-// implementation instead.
-# define GTEST_USES_SIMPLE_RE 1
-
-#else
-
-// <regex.h> may not be available on this platform.  Use our own
-// simple regex implementation instead.
-# define GTEST_USES_SIMPLE_RE 1
-
-#endif  // GTEST_USES_PCRE
-
-#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(__BORLANDC__)
-// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
-// macro to enable exceptions, so we'll do the same.
-// Assumes that exceptions are enabled by default.
-#  ifndef _HAS_EXCEPTIONS
-#   define _HAS_EXCEPTIONS 1
-#  endif  // _HAS_EXCEPTIONS
-#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
-# elif defined(__clang__)
-// clang defines __EXCEPTIONS iff exceptions are enabled before clang 220714,
-// but iff 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 iff 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
-// detecting whether they are enabled or not.  Therefore, we assume that
-// they are enabled unless the user tells us otherwise.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__IBMCPP__) && __EXCEPTIONS
-// xlC defines __EXCEPTIONS to 1 iff 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
-// be turned of by +noeh compiler option if desired.
-#  define GTEST_HAS_EXCEPTIONS 1
-# else
-// For other compilers, we assume exceptions are disabled to be
-// conservative.
-#  define GTEST_HAS_EXCEPTIONS 0
-# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
-#endif  // GTEST_HAS_EXCEPTIONS
-
-#if !defined(GTEST_HAS_STD_STRING)
-// Even though we don't use this macro any longer, we keep it in case
-// some clients still depend on it.
-# define GTEST_HAS_STD_STRING 1
-#elif !GTEST_HAS_STD_STRING
-// The user told us that ::std::string isn't available.
-# error "Google Test cannot be used where ::std::string isn't available."
-#endif  // !defined(GTEST_HAS_STD_STRING)
-
-#ifndef GTEST_HAS_GLOBAL_STRING
-// The user didn't tell us whether ::string is available, so we need
-// to figure it out.
-
-# define GTEST_HAS_GLOBAL_STRING 0
-
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-#ifndef GTEST_HAS_STD_WSTRING
-// The user didn't tell us whether ::std::wstring is available, so we need
-// to figure it out.
-// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
-//   is available.
-
-// 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))
-
-#endif  // GTEST_HAS_STD_WSTRING
-
-#ifndef GTEST_HAS_GLOBAL_WSTRING
-// The user didn't tell us whether ::wstring is available, so we need
-// to figure it out.
-# define GTEST_HAS_GLOBAL_WSTRING \
-    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-// Determines whether RTTI is available.
-#ifndef GTEST_HAS_RTTI
-// The user didn't tell us whether RTTI is enabled, so we need to
-// figure it out.
-
-# ifdef _MSC_VER
-
-#  ifdef _CPPRTTI  // MSVC defines this macro iff 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 iff RTTI is enabled.
-# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
-
-#  ifdef __GXX_RTTI
-// When building against STLport with the Android NDK and with
-// -frtti -fno-exceptions, the build fails at link time with undefined
-// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
-// so disable RTTI when detected.
-#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
-       !defined(__EXCEPTIONS)
-#    define GTEST_HAS_RTTI 0
-#   else
-#    define GTEST_HAS_RTTI 1
-#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
-#  else
-#   define GTEST_HAS_RTTI 0
-#  endif  // __GXX_RTTI
-
-// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
-// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
-// first version with C++ support.
-# elif defined(__clang__)
-
-#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
-
-// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
-// both the typeid and dynamic_cast features are present.
-# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
-
-#  ifdef __RTTI_ALL__
-#   define GTEST_HAS_RTTI 1
-#  else
-#   define GTEST_HAS_RTTI 0
-#  endif
-
-# else
-
-// For all other compilers, we assume RTTI is enabled.
-#  define GTEST_HAS_RTTI 1
-
-# endif  // _MSC_VER
-
-#endif  // GTEST_HAS_RTTI
-
-// It's this header's responsibility to #include <typeinfo> when RTTI
-// is enabled.
-#if GTEST_HAS_RTTI
-# include <typeinfo>
-#endif
-
-// Determines whether Google Test can use the pthreads library.
-#ifndef GTEST_HAS_PTHREAD
-// The user didn't tell us explicitly, so we make reasonable assumptions about
-// which platforms have pthreads support.
-//
-// 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)
-#endif  // GTEST_HAS_PTHREAD
-
-#if GTEST_HAS_PTHREAD
-// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
-// true.
-# include <pthread.h>  // NOLINT
-
-// For timespec and nanosleep, used below.
-# include <time.h>  // NOLINT
-#endif
-
-// Determines if hash_map/hash_set are available.
-// Only used for testing against those containers.
-#if !defined(GTEST_HAS_HASH_MAP_)
-# if _MSC_VER
-#  define GTEST_HAS_HASH_MAP_ 1  // Indicates that hash_map is available.
-#  define GTEST_HAS_HASH_SET_ 1  // Indicates that hash_set is available.
-# endif  // _MSC_VER
-#endif  // !defined(GTEST_HAS_HASH_MAP_)
-
-// Determines whether Google Test can use tr1/tuple.  You can define
-// this macro to 0 to prevent Google Test from using tuple (any
-// feature depending on tuple with be disabled in this mode).
-#ifndef GTEST_HAS_TR1_TUPLE
-# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
-// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
-#  define GTEST_HAS_TR1_TUPLE 0
-# else
-// The user didn't tell us not to do it, so we assume it's OK.
-#  define GTEST_HAS_TR1_TUPLE 1
-# endif
-#endif  // GTEST_HAS_TR1_TUPLE
-
-// Determines whether Google Test's own tr1 tuple implementation
-// should be used.
-#ifndef GTEST_USE_OWN_TR1_TUPLE
-// The user didn't tell us, so we need to figure it out.
-
-// We use our own TR1 tuple if we aren't sure the user has an
-// implementation of it already.  At this time, libstdc++ 4.0.0+ and
-// MSVC 2010 are the only mainstream standard libraries that come
-// with a TR1 tuple implementation.  NVIDIA's CUDA NVCC compiler
-// pretends to be GCC by defining __GNUC__ and friends, but cannot
-// compile GCC's tuple implementation.  MSVC 2008 (9.0) provides TR1
-// tuple in a 323 MB Feature Pack download, which we cannot assume the
-// user has.  QNX's QCC compiler is a modified GCC but it doesn't
-// support TR1 tuple.  libc++ only provides std::tuple, in C++11 mode,
-// and it can be used with some compilers that define __GNUC__.
-# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
-      && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600
-#  define GTEST_ENV_HAS_TR1_TUPLE_ 1
-# endif
-
-// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
-// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6
-// can build with clang but need to use gcc4.2's libstdc++).
-# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
-#  define GTEST_ENV_HAS_STD_TUPLE_ 1
-# endif
-
-# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
-#  define GTEST_USE_OWN_TR1_TUPLE 0
-# else
-#  define GTEST_USE_OWN_TR1_TUPLE 1
-# endif
-
-#endif  // GTEST_USE_OWN_TR1_TUPLE
-
-// To avoid conditional compilation everywhere, we make it
-// gtest-port.h's responsibility to #include the header implementing
-// tuple.
-#if GTEST_HAS_STD_TUPLE_
-# include <tuple>  // IWYU pragma: export
-# define GTEST_TUPLE_NAMESPACE_ ::std
-#endif  // GTEST_HAS_STD_TUPLE_
-
-// We include tr1::tuple even if std::tuple is available to define printers for
-// them.
-#if GTEST_HAS_TR1_TUPLE
-# ifndef GTEST_TUPLE_NAMESPACE_
-#  define GTEST_TUPLE_NAMESPACE_ ::std::tr1
-# endif  // GTEST_TUPLE_NAMESPACE_
-
-# if GTEST_USE_OWN_TR1_TUPLE
-#  include "gtest/internal/gtest-tuple.h"  // IWYU pragma: export  // NOLINT
-# elif GTEST_ENV_HAS_STD_TUPLE_
-#  include <tuple>
-// C++11 puts its tuple into the ::std namespace rather than
-// ::std::tr1.  gtest expects tuple to live in ::std::tr1, so put it there.
-// This causes undefined behavior, but supported compilers react in
-// the way we intend.
-namespace std {
-namespace tr1 {
-using ::std::get;
-using ::std::make_tuple;
-using ::std::tuple;
-using ::std::tuple_element;
-using ::std::tuple_size;
-}
-}
-
-# elif GTEST_OS_SYMBIAN
-
-// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
-// use STLport's tuple implementation, which unfortunately doesn't
-// work as the copy of STLport distributed with Symbian is incomplete.
-// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
-// use its own tuple implementation.
-#  ifdef BOOST_HAS_TR1_TUPLE
-#   undef BOOST_HAS_TR1_TUPLE
-#  endif  // BOOST_HAS_TR1_TUPLE
-
-// This prevents <boost/tr1/detail/config.hpp>, which defines
-// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
-#  define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
-#  include <tuple>  // IWYU pragma: export  // NOLINT
-
-# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
-// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header.  This does
-// not conform to the TR1 spec, which requires the header to be <tuple>.
-
-#  if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
-// Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
-// which is #included by <tr1/tuple>, to not compile when RTTI is
-// disabled.  _TR1_FUNCTIONAL is the header guard for
-// <tr1/functional>.  Hence the following #define is a hack to prevent
-// <tr1/functional> from being included.
-#   define _TR1_FUNCTIONAL 1
-#   include <tr1/tuple>
-#   undef _TR1_FUNCTIONAL  // Allows the user to #include
-                        // <tr1/functional> if he chooses to.
-#  else
-#   include <tr1/tuple>  // NOLINT
-#  endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
-
-# else
-// If the compiler is not GCC 4.0+, we assume the user is using a
-// spec-conforming TR1 implementation.
-#  include <tuple>  // IWYU pragma: export  // NOLINT
-# endif  // GTEST_USE_OWN_TR1_TUPLE
-
-#endif  // GTEST_HAS_TR1_TUPLE
-
-// Determines whether clone(2) is supported.
-// Usually it will only be available on Linux, excluding
-// Linux on the Itanium architecture.
-// Also see http://linux.die.net/man/2/clone.
-#ifndef GTEST_HAS_CLONE
-// The user didn't tell us, so we need to figure it out.
-
-# if GTEST_OS_LINUX && !defined(__ia64__)
-#  if GTEST_OS_LINUX_ANDROID
-// On Android, clone() is only available on ARM starting with Gingerbread.
-#    if defined(__arm__) && __ANDROID_API__ >= 9
-#     define GTEST_HAS_CLONE 1
-#    else
-#     define GTEST_HAS_CLONE 0
-#    endif
-#  else
-#   define GTEST_HAS_CLONE 1
-#  endif
-# else
-#  define GTEST_HAS_CLONE 0
-# endif  // GTEST_OS_LINUX && !defined(__ia64__)
-
-#endif  // GTEST_HAS_CLONE
-
-// Determines whether to support stream redirection. This is used to test
-// output correctness and to implement death tests.
-#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_SYMBIAN || \
-    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
-#  define GTEST_HAS_STREAM_REDIRECTION 0
-# else
-#  define GTEST_HAS_STREAM_REDIRECTION 1
-# endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-// Determines whether to support death tests.
-// Google Test does not support death tests for VC 7.1 and earlier as
-// abort() in a VC 7.1 application compiled as GUI in debug config
-// 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 >= 1400) || \
-     GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
-     GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD)
-# define GTEST_HAS_DEATH_TEST 1
-#endif
-
-// We don't support MSVC 7.1 with exceptions disabled now.  Therefore
-// all the compilers we care about are adequate for supporting
-// value-parameterized tests.
-#define GTEST_HAS_PARAM_TEST 1
-
-// Determines whether to support type-driven tests.
-
-// 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__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \
-    defined(__IBMCPP__) || defined(__HP_aCC)
-# define GTEST_HAS_TYPED_TEST 1
-# define GTEST_HAS_TYPED_TEST_P 1
-#endif
-
-// Determines whether to support Combine(). This only makes sense when
-// value-parameterized tests are enabled.  The implementation doesn't
-// work on Sun Studio since it doesn't understand templated conversion
-// operators.
-#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC)
-# define GTEST_HAS_COMBINE 1
-#endif
-
-// 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_SYMBIAN || GTEST_OS_AIX)
-
-// Determines whether test results can be streamed to a socket.
-#if GTEST_OS_LINUX
-# define GTEST_CAN_STREAM_RESULTS_ 1
-#endif
-
-// Defines some utility macros.
-
-// The GNU compiler emits a warning if nested "if" statements are followed by
-// an "else" statement and braces are not used to explicitly disambiguate the
-// "else" binding.  This leads to problems with code like:
-//
-//   if (gate)
-//     ASSERT_*(condition) << "Some message";
-//
-// The "switch (0) case 0:" idiom is used to suppress this.
-#ifdef __INTEL_COMPILER
-# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
-#else
-# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
-#endif
-
-// Use this annotation at the end of a struct/class definition to
-// prevent the compiler from optimizing away instances that are never
-// used.  This is useful when all interesting logic happens inside the
-// c'tor and / or d'tor.  Example:
-//
-//   struct Foo {
-//     Foo() { ... }
-//   } GTEST_ATTRIBUTE_UNUSED_;
-//
-// Also use it after a variable or parameter declaration to tell the
-// compiler the variable/parameter does not have to be used.
-#if defined(__GNUC__) && !defined(COMPILER_ICC)
-# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
-#elif defined(__clang__)
-# if __has_attribute(unused)
-#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
-# endif
-#endif
-#ifndef GTEST_ATTRIBUTE_UNUSED_
-# define GTEST_ATTRIBUTE_UNUSED_
-#endif
-
-// A macro to disallow operator=
-// This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_ASSIGN_(type)\
-  void operator=(type const &)
-
-// 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 &);\
-  GTEST_DISALLOW_ASSIGN_(type)
-
-// 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__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
-# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
-#else
-# define GTEST_MUST_USE_RESULT_
-#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !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
-// suppressed. Use the following two macros in such cases:
-//
-// GTEST_INTENTIONAL_CONST_COND_PUSH_()
-// while (true) {
-// GTEST_INTENTIONAL_CONST_COND_POP_()
-// }
-# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
-    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
-# define GTEST_INTENTIONAL_CONST_COND_POP_() \
-    GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-// Determine whether the compiler supports Microsoft's Structured Exception
-// Handling.  This is supported by several Windows compilers but generally
-// does not exist on any other system.
-#ifndef GTEST_HAS_SEH
-// The user didn't tell us, so we need to figure it out.
-
-# if defined(_MSC_VER) || defined(__BORLANDC__)
-// These two compilers are known to support SEH.
-#  define GTEST_HAS_SEH 1
-# else
-// Assume no SEH.
-#  define GTEST_HAS_SEH 0
-# endif
-
-#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_HAS_SEH
-
-#ifdef _MSC_VER
-# if GTEST_LINKED_AS_SHARED_LIBRARY
-#  define GTEST_API_ __declspec(dllimport)
-# elif GTEST_CREATE_SHARED_LIBRARY
-#  define GTEST_API_ __declspec(dllexport)
-# endif
-#elif __GNUC__ >= 4 || defined(__clang__)
-# define GTEST_API_ __attribute__((visibility ("default")))
-#endif // _MSC_VER
-
-#ifndef GTEST_API_
-# define GTEST_API_
-#endif
-
-#ifdef __GNUC__
-// Ask the compiler to never inline a given function.
-# define GTEST_NO_INLINE_ __attribute__((noinline))
-#else
-# define GTEST_NO_INLINE_
-#endif
-
-// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
-#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
-# define GTEST_HAS_CXXABI_H_ 1
-#else
-# define GTEST_HAS_CXXABI_H_ 0
-#endif
-
-// A function level attribute to disable checking for use of uninitialized
-// memory when built with MemorySanitizer.
-#if defined(__clang__)
-# if __has_feature(memory_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
-       __attribute__((no_sanitize_memory))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-# endif  // __has_feature(memory_sanitizer)
-#else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-#endif  // __clang__
-
-// A function level attribute to disable AddressSanitizer instrumentation.
-#if defined(__clang__)
-# if __has_feature(address_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
-       __attribute__((no_sanitize_address))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-# endif  // __has_feature(address_sanitizer)
-#else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-#endif  // __clang__
-
-// A function level attribute to disable ThreadSanitizer instrumentation.
-#if defined(__clang__)
-# if __has_feature(thread_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
-       __attribute__((no_sanitize_thread))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-# endif  // __has_feature(thread_sanitizer)
-#else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-#endif  // __clang__
-
-namespace testing {
-
-class Message;
-
-#if defined(GTEST_TUPLE_NAMESPACE_)
-// Import tuple and friends into the ::testing namespace.
-// It is part of our interface, having them in ::testing allows us to change
-// their types as needed.
-using GTEST_TUPLE_NAMESPACE_::get;
-using GTEST_TUPLE_NAMESPACE_::make_tuple;
-using GTEST_TUPLE_NAMESPACE_::tuple;
-using GTEST_TUPLE_NAMESPACE_::tuple_size;
-using GTEST_TUPLE_NAMESPACE_::tuple_element;
-#endif  // defined(GTEST_TUPLE_NAMESPACE_)
-
-namespace internal {
-
-// A secret type that Google Test users don't know about.  It has no
-// definition on purpose.  Therefore it's impossible to create a
-// Secret object, which is what we want.
-class Secret;
-
-// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
-// expression is true. 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);
-//
-// or to make sure a struct is smaller than a certain size:
-//
-//   GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
-//
-// The second argument to the macro is the name of the variable. If
-// the expression is false, most compilers will issue a warning/error
-// containing the name of the variable.
-
-#if GTEST_LANG_CXX11
-# define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
-#else  // !GTEST_LANG_CXX11
-template <bool>
-  struct CompileAssert {
-};
-
-# define GTEST_COMPILE_ASSERT_(expr, msg) \
-  typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
-      msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
-#endif  // !GTEST_LANG_CXX11
-
-// Implementation details of GTEST_COMPILE_ASSERT_:
-//
-// (In C++11, we simply use static_assert instead of the following)
-//
-// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
-//   elements (and thus is invalid) when the expression is false.
-//
-// - The simpler definition
-//
-//    #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
-//
-//   does not work, as gcc supports variable-length arrays whose sizes
-//   are determined at run-time (this is gcc's extension and not part
-//   of the C++ standard).  As a result, gcc fails to reject the
-//   following code with the simple definition:
-//
-//     int foo;
-//     GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
-//                                      // not a compile-time constant.
-//
-// - By using the type CompileAssert<(bool(expr))>, we ensures that
-//   expr is a compile-time constant.  (Template arguments must be
-//   determined at compile-time.)
-//
-// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
-//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
-//
-//     CompileAssert<bool(expr)>
-//
-//   instead, these compilers will refuse to compile
-//
-//     GTEST_COMPILE_ASSERT_(5 > 0, some_message);
-//
-//   (They seem to think the ">" in "5 > 0" marks the end of the
-//   template argument list.)
-//
-// - The array size is (bool(expr) ? 1 : -1), instead of simply
-//
-//     ((expr) ? 1 : -1).
-//
-//   This is to avoid running into a bug in MS VC 7.1, which
-//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
-
-// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
-//
-// This template is declared, but intentionally undefined.
-template <typename T1, typename T2>
-struct StaticAssertTypeEqHelper;
-
-template <typename T>
-struct StaticAssertTypeEqHelper<T, T> {
-  enum { value = true };
-};
-
-// Evaluates to the number of elements in 'array'.
-#define GTEST_ARRAY_SIZE_(array) (sizeof(array) / sizeof(array[0]))
-
-#if GTEST_HAS_GLOBAL_STRING
-typedef ::string string;
-#else
-typedef ::std::string string;
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-#if GTEST_HAS_GLOBAL_WSTRING
-typedef ::wstring wstring;
-#elif GTEST_HAS_STD_WSTRING
-typedef ::std::wstring wstring;
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-// A helper for suppressing warnings on constant condition.  It just
-// returns 'condition'.
-GTEST_API_ bool IsTrue(bool condition);
-
-// Defines scoped_ptr.
-
-// This implementation of scoped_ptr is PARTIAL - it only contains
-// enough stuff to satisfy Google Test's need.
-template <typename T>
-class scoped_ptr {
- public:
-  typedef T element_type;
-
-  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
-  ~scoped_ptr() { reset(); }
-
-  T& operator*() const { return *ptr_; }
-  T* operator->() const { return ptr_; }
-  T* get() const { return ptr_; }
-
-  T* release() {
-    T* const ptr = ptr_;
-    ptr_ = NULL;
-    return ptr;
-  }
-
-  void reset(T* p = NULL) {
-    if (p != ptr_) {
-      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
-        delete ptr_;
-      }
-      ptr_ = p;
-    }
-  }
-
-  friend void swap(scoped_ptr& a, scoped_ptr& b) {
-    using std::swap;
-    swap(a.ptr_, b.ptr_);
-  }
-
- private:
-  T* ptr_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
-};
-
-// Defines RE.
-
-// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
-// Regular Expression syntax.
-class GTEST_API_ RE {
- public:
-  // A copy constructor is required by the Standard to initialize object
-  // references from r-values.
-  RE(const RE& other) { Init(other.pattern()); }
-
-  // Constructs an RE from a string.
-  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
-
-#if GTEST_HAS_GLOBAL_STRING
-
-  RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
-
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-  RE(const char* regex) { Init(regex); }  // NOLINT
-  ~RE();
-
-  // Returns the string representation of the regex.
-  const char* pattern() const { return pattern_; }
-
-  // FullMatch(str, re) returns true iff regular expression re matches
-  // the entire str.
-  // PartialMatch(str, re) returns true iff regular expression re
-  // matches a substring of str (including str itself).
-  //
-  // TODO(wan@google.com): make FullMatch() and PartialMatch() work
-  // when str contains NUL characters.
-  static bool FullMatch(const ::std::string& str, const RE& re) {
-    return FullMatch(str.c_str(), re);
-  }
-  static bool PartialMatch(const ::std::string& str, const RE& re) {
-    return PartialMatch(str.c_str(), re);
-  }
-
-#if GTEST_HAS_GLOBAL_STRING
-
-  static bool FullMatch(const ::string& str, const RE& re) {
-    return FullMatch(str.c_str(), re);
-  }
-  static bool PartialMatch(const ::string& str, const RE& re) {
-    return PartialMatch(str.c_str(), re);
-  }
-
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-  static bool FullMatch(const char* str, const RE& re);
-  static bool PartialMatch(const char* str, const RE& re);
-
- private:
-  void Init(const char* regex);
-
-  // We use a const char* instead of an std::string, as Google Test used to be
-  // used where std::string is not available.  TODO(wan@google.com): change to
-  // std::string.
-  const char* pattern_;
-  bool is_valid_;
-
-#if GTEST_USES_POSIX_RE
-
-  regex_t full_regex_;     // For FullMatch().
-  regex_t partial_regex_;  // For PartialMatch().
-
-#else  // GTEST_USES_SIMPLE_RE
-
-  const char* full_pattern_;  // For FullMatch();
-
-#endif
-
-  GTEST_DISALLOW_ASSIGN_(RE);
-};
-
-// 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);
-
-// Formats a file location for compiler-independent XML output.
-// Although this function is not platform dependent, we put it next to
-// FormatFileLocation in order to contrast the two functions.
-GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
-                                                               int line);
-
-// Defines logging utilities:
-//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
-//                          message itself is streamed into the macro.
-//   LogToStderr()  - directs all log messages to stderr.
-//   FlushInfoLog() - flushes informational log messages.
-
-enum GTestLogSeverity {
-  GTEST_INFO,
-  GTEST_WARNING,
-  GTEST_ERROR,
-  GTEST_FATAL
-};
-
-// Formats log entry severity, provides a stream object for streaming the
-// log message, and terminates the message with a newline when going out of
-// scope.
-class GTEST_API_ GTestLog {
- public:
-  GTestLog(GTestLogSeverity severity, const char* file, int line);
-
-  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
-  ~GTestLog();
-
-  ::std::ostream& GetStream() { return ::std::cerr; }
-
- private:
-  const GTestLogSeverity severity_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
-};
-
-#if !defined(GTEST_LOG_)
-
-# define GTEST_LOG_(severity) \
-    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
-                                  __FILE__, __LINE__).GetStream()
-
-inline void LogToStderr() {}
-inline void FlushInfoLog() { fflush(NULL); }
-
-#endif  // !defined(GTEST_LOG_)
-
-#if !defined(GTEST_CHECK_)
-// INTERNAL IMPLEMENTATION - DO NOT USE.
-//
-// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
-// is not satisfied.
-//  Synopsys:
-//    GTEST_CHECK_(boolean_condition);
-//     or
-//    GTEST_CHECK_(boolean_condition) << "Additional message";
-//
-//    This checks the condition and if the condition is not satisfied
-//    it prints message about the condition violation, including the
-//    condition itself, plus additional message streamed into it, if any,
-//    and then it aborts the program. It aborts the program irrespective of
-//    whether it is built in the debug mode or not.
-# define GTEST_CHECK_(condition) \
-    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-    if (::testing::internal::IsTrue(condition)) \
-      ; \
-    else \
-      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
-#endif  // !defined(GTEST_CHECK_)
-
-// An all-mode assert to verify that the given POSIX-style function
-// call returns 0 (indicating success).  Known limitation: this
-// doesn't expand to a balanced 'if' statement, so enclose the macro
-// in {} if you need to use it as the only statement in an 'if'
-// branch.
-#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
-  if (const int gtest_error = (posix_call)) \
-    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
-                      << gtest_error
-
-#if GTEST_HAS_STD_MOVE_
-using std::move;
-#else  // GTEST_HAS_STD_MOVE_
-template <typename T>
-const T& move(const T& t) {
-  return t;
-}
-#endif  // GTEST_HAS_STD_MOVE_
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// Use ImplicitCast_ as a safe version of static_cast for upcasting in
-// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
-// const Foo*).  When you use ImplicitCast_, the compiler checks that
-// the cast is safe.  Such explicit ImplicitCast_s are necessary in
-// surprisingly many situations where C++ demands an exact type match
-// instead of an argument type convertable to a target type.
-//
-// The syntax for using ImplicitCast_ is the same as for static_cast:
-//
-//   ImplicitCast_<ToType>(expr)
-//
-// ImplicitCast_ would have been part of the C++ standard library,
-// but the proposal was submitted too late.  It will probably make
-// its way into the language in the future.
-//
-// This relatively ugly name is intentional. It prevents clashes with
-// similar functions users may have (e.g., implicit_cast). The internal
-// namespace alone is not enough because the function can be found by ADL.
-template<typename To>
-inline To ImplicitCast_(To x) { return x; }
-
-// When you upcast (that is, cast a pointer from type Foo to type
-// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
-// always succeed.  When you downcast (that is, cast a pointer from
-// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
-// how do you know the pointer is really of type SubclassOfFoo?  It
-// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
-// when you downcast, you should use this macro.  In debug mode, we
-// use dynamic_cast<> to double-check the downcast is legal (we die
-// if it's not).  In normal mode, we do the efficient static_cast<>
-// instead.  Thus, it's important to test in debug mode to make sure
-// the cast is legal!
-//    This is the only place in the code we should use dynamic_cast<>.
-// In particular, you SHOULDN'T be using dynamic_cast<> in order to
-// do RTTI (eg code like this:
-//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
-//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
-// You should design the code some other way not to need this.
-//
-// This relatively ugly name is intentional. It prevents clashes with
-// similar functions users may have (e.g., down_cast). The internal
-// namespace alone is not enough because the function can be found by ADL.
-template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
-inline To DownCast_(From* f) {  // so we only accept pointers
-  // Ensures that To is a sub-type of From *.  This test is here only
-  // for compile-time type checking, and has no overhead in an
-  // optimized build at run-time, as it will be optimized away
-  // completely.
-  GTEST_INTENTIONAL_CONST_COND_PUSH_()
-  if (false) {
-  GTEST_INTENTIONAL_CONST_COND_POP_()
-    const To to = NULL;
-    ::testing::internal::ImplicitCast_<From*>(to);
-  }
-
-#if GTEST_HAS_RTTI
-  // RTTI: debug mode only!
-  GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
-#endif
-  return static_cast<To>(f);
-}
-
-// Downcasts the pointer of type Base to Derived.
-// Derived must be a subclass of Base. The parameter MUST
-// point to a class of type Derived, not any subclass of it.
-// When RTTI is available, the function performs a runtime
-// check to enforce this.
-template <class Derived, class Base>
-Derived* CheckedDowncastToActualType(Base* base) {
-#if GTEST_HAS_RTTI
-  GTEST_CHECK_(typeid(*base) == typeid(Derived));
-#endif
-
-#if GTEST_HAS_DOWNCAST_
-  return ::down_cast<Derived*>(base);
-#elif GTEST_HAS_RTTI
-  return dynamic_cast<Derived*>(base);  // NOLINT
-#else
-  return static_cast<Derived*>(base);  // Poor man's downcast.
-#endif
-}
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Defines the stderr capturer:
-//   CaptureStdout     - starts capturing stdout.
-//   GetCapturedStdout - stops capturing stdout and returns the captured string.
-//   CaptureStderr     - starts capturing stderr.
-//   GetCapturedStderr - stops capturing stderr and returns the captured string.
-//
-GTEST_API_ void CaptureStdout();
-GTEST_API_ std::string GetCapturedStdout();
-GTEST_API_ void CaptureStderr();
-GTEST_API_ std::string GetCapturedStderr();
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-// Returns a path to temporary directory.
-GTEST_API_ std::string TempDir();
-
-// Returns the size (in bytes) of a file.
-GTEST_API_ size_t GetFileSize(FILE* file);
-
-// Reads the entire content of a file as a string.
-GTEST_API_ std::string ReadEntireFile(FILE* file);
-
-// All command line arguments.
-GTEST_API_ const ::std::vector<testing::internal::string>& GetArgvs();
-
-#if GTEST_HAS_DEATH_TEST
-
-const ::std::vector<testing::internal::string>& GetInjectableArgvs();
-void SetInjectableArgvs(const ::std::vector<testing::internal::string>*
-                             new_argvs);
-
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-// Defines synchronization primitives.
-#if GTEST_IS_THREADSAFE
-# if GTEST_HAS_PTHREAD
-// Sleeps for (roughly) n milliseconds.  This function is only for testing
-// Google Test's own constructs.  Don't use it in user tests, either
-// directly or indirectly.
-inline void SleepMilliseconds(int n) {
-  const timespec time = {
-    0,                  // 0 seconds.
-    n * 1000L * 1000L,  // And n ms.
-  };
-  nanosleep(&time, NULL);
-}
-# endif  // GTEST_HAS_PTHREAD
-
-# if GTEST_HAS_NOTIFICATION_
-// Notification has already been imported into the namespace.
-// Nothing to do here.
-
-# elif GTEST_HAS_PTHREAD
-// Allows a controller thread to pause execution of newly created
-// threads until notified.  Instances of this class must be created
-// and destroyed in the controller thread.
-//
-// This class is only for testing Google Test's own constructs. Do not
-// use it in user tests, either directly or indirectly.
-class Notification {
- public:
-  Notification() : notified_(false) {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
-  }
-  ~Notification() {
-    pthread_mutex_destroy(&mutex_);
-  }
-
-  // Notifies all threads created with this notification to start. Must
-  // be called from the controller thread.
-  void Notify() {
-    pthread_mutex_lock(&mutex_);
-    notified_ = true;
-    pthread_mutex_unlock(&mutex_);
-  }
-
-  // Blocks until the controller thread notifies. Must be called from a test
-  // thread.
-  void WaitForNotification() {
-    for (;;) {
-      pthread_mutex_lock(&mutex_);
-      const bool notified = notified_;
-      pthread_mutex_unlock(&mutex_);
-      if (notified)
-        break;
-      SleepMilliseconds(10);
-    }
-  }
-
- private:
-  pthread_mutex_t mutex_;
-  bool notified_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
-};
-
-# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-
-GTEST_API_ void SleepMilliseconds(int n);
-
-// Provides leak-safe Windows kernel handle ownership.
-// Used in death tests and in threading support.
-class GTEST_API_ AutoHandle {
- public:
-  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to
-  // avoid including <windows.h> in this header file. Including <windows.h> is
-  // undesirable because it defines a lot of symbols and macros that tend to
-  // conflict with client code. This assumption is verified by
-  // WindowsTypesTest.HANDLEIsVoidStar.
-  typedef void* Handle;
-  AutoHandle();
-  explicit AutoHandle(Handle handle);
-
-  ~AutoHandle();
-
-  Handle Get() const;
-  void Reset();
-  void Reset(Handle handle);
-
- private:
-  // Returns true iff the handle is a valid handle object that can be closed.
-  bool IsCloseable() const;
-
-  Handle handle_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
-};
-
-// Allows a controller thread to pause execution of newly created
-// threads until notified.  Instances of this class must be created
-// and destroyed in the controller thread.
-//
-// This class is only for testing Google Test's own constructs. Do not
-// use it in user tests, either directly or indirectly.
-class GTEST_API_ Notification {
- public:
-  Notification();
-  void Notify();
-  void WaitForNotification();
-
- private:
-  AutoHandle event_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
-};
-# endif  // GTEST_HAS_NOTIFICATION_
-
-// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
-// defined, but we don't want to use MinGW's pthreads implementation, which
-// has conformance problems with some versions of the POSIX standard.
-# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
-
-// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
-// Consequently, it cannot select a correct instantiation of ThreadWithParam
-// in order to call its Run(). Introducing ThreadWithParamBase as a
-// non-templated base class for ThreadWithParam allows us to bypass this
-// problem.
-class ThreadWithParamBase {
- public:
-  virtual ~ThreadWithParamBase() {}
-  virtual void Run() = 0;
-};
-
-// pthread_create() accepts a pointer to a function type with the C linkage.
-// According to the Standard (7.5/1), function types with different linkages
-// are different even if they are otherwise identical.  Some compilers (for
-// example, SunStudio) treat them as different types.  Since class methods
-// cannot be defined with C-linkage we need to define a free C-function to
-// pass into pthread_create().
-extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
-  static_cast<ThreadWithParamBase*>(thread)->Run();
-  return NULL;
-}
-
-// Helper class for testing Google Test's multi-threading constructs.
-// To use it, write:
-//
-//   void ThreadFunc(int param) { /* Do things with param */ }
-//   Notification thread_can_start;
-//   ...
-//   // The thread_can_start parameter is optional; you can supply NULL.
-//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
-//   thread_can_start.Notify();
-//
-// These classes are only for testing Google Test's own constructs. Do
-// not use them in user tests, either directly or indirectly.
-template <typename T>
-class ThreadWithParam : public ThreadWithParamBase {
- public:
-  typedef void UserThreadFunc(T);
-
-  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
-      : func_(func),
-        param_(param),
-        thread_can_start_(thread_can_start),
-        finished_(false) {
-    ThreadWithParamBase* const base = this;
-    // The thread can be created only after all fields except thread_
-    // have been initialized.
-    GTEST_CHECK_POSIX_SUCCESS_(
-        pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
-  }
-  ~ThreadWithParam() { Join(); }
-
-  void Join() {
-    if (!finished_) {
-      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
-      finished_ = true;
-    }
-  }
-
-  virtual void Run() {
-    if (thread_can_start_ != NULL)
-      thread_can_start_->WaitForNotification();
-    func_(param_);
-  }
-
- private:
-  UserThreadFunc* const func_;  // User-supplied thread function.
-  const T param_;  // User-supplied parameter to the thread function.
-  // When non-NULL, used to block execution until the controller thread
-  // notifies.
-  Notification* const thread_can_start_;
-  bool finished_;  // true iff we know that the thread function has finished.
-  pthread_t thread_;  // The native thread object.
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
-};
-# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
-         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
-
-# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
-// Mutex and ThreadLocal have already been imported into the namespace.
-// Nothing to do here.
-
-# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-
-// Mutex implements mutex on Windows platforms.  It is used in conjunction
-// with class MutexLock:
-//
-//   Mutex mutex;
-//   ...
-//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the
-//                            // end of the current scope.
-//
-// A static Mutex *must* be defined or declared using one of the following
-// macros:
-//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
-//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
-//
-// (A non-static Mutex is defined/declared in the usual way).
-class GTEST_API_ Mutex {
- public:
-  enum MutexType { kStatic = 0, kDynamic = 1 };
-  // We rely on kStaticMutex being 0 as it is to what the linker initializes
-  // type_ in static mutexes.  critical_section_ will be initialized lazily
-  // in ThreadSafeLazyInit().
-  enum StaticConstructorSelector { kStaticMutex = 0 };
-
-  // This constructor intentionally does nothing.  It relies on type_ being
-  // statically initialized to 0 (effectively setting it to kStatic) and on
-  // ThreadSafeLazyInit() to lazily initialize the rest of the members.
-  explicit Mutex(StaticConstructorSelector /*dummy*/) {}
-
-  Mutex();
-  ~Mutex();
-
-  void Lock();
-
-  void Unlock();
-
-  // Does nothing if the current thread holds the mutex. Otherwise, crashes
-  // with high probability.
-  void AssertHeld();
-
- private:
-  // Initializes owner_thread_id_ and critical_section_ in static mutexes.
-  void ThreadSafeLazyInit();
-
-  // Per http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx,
-  // we assume that 0 is an invalid value for thread IDs.
-  unsigned int owner_thread_id_;
-
-  // For static mutexes, we rely on these members being initialized to zeros
-  // by the linker.
-  MutexType type_;
-  long critical_section_init_phase_;  // NOLINT
-  GTEST_CRITICAL_SECTION* critical_section_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
-};
-
-# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
-    extern ::testing::internal::Mutex mutex
-
-# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
-    ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
-
-// We cannot name this class MutexLock because the ctor declaration would
-// conflict with a macro named MutexLock, which is defined on some
-// platforms. That macro is used as a defensive measure to prevent against
-// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
-// "MutexLock l(&mu)".  Hence the typedef trick below.
-class GTestMutexLock {
- public:
-  explicit GTestMutexLock(Mutex* mutex)
-      : mutex_(mutex) { mutex_->Lock(); }
-
-  ~GTestMutexLock() { mutex_->Unlock(); }
-
- private:
-  Mutex* const mutex_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
-};
-
-typedef GTestMutexLock MutexLock;
-
-// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value
-// without knowing its type.
-class ThreadLocalValueHolderBase {
- public:
-  virtual ~ThreadLocalValueHolderBase() {}
-};
-
-// Provides a way for a thread to send notifications to a ThreadLocal
-// regardless of its parameter type.
-class ThreadLocalBase {
- public:
-  // Creates a new ValueHolder<T> object holding a default value passed to
-  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's
-  // responsibility not to call this when the ThreadLocal<T> instance already
-  // has a value on the current thread.
-  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;
-
- protected:
-  ThreadLocalBase() {}
-  virtual ~ThreadLocalBase() {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
-};
-
-// Maps a thread to a set of ThreadLocals that have values instantiated on that
-// thread and notifies them when the thread exits.  A ThreadLocal instance is
-// expected to persist until all threads it has values on have terminated.
-class GTEST_API_ ThreadLocalRegistry {
- public:
-  // Registers thread_local_instance as having value on the current thread.
-  // Returns a value that can be used to identify the thread from other threads.
-  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
-      const ThreadLocalBase* thread_local_instance);
-
-  // Invoked when a ThreadLocal instance is destroyed.
-  static void OnThreadLocalDestroyed(
-      const ThreadLocalBase* thread_local_instance);
-};
-
-class GTEST_API_ ThreadWithParamBase {
- public:
-  void Join();
-
- protected:
-  class Runnable {
-   public:
-    virtual ~Runnable() {}
-    virtual void Run() = 0;
-  };
-
-  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
-  virtual ~ThreadWithParamBase();
-
- private:
-  AutoHandle thread_;
-};
-
-// Helper class for testing Google Test's multi-threading constructs.
-template <typename T>
-class ThreadWithParam : public ThreadWithParamBase {
- public:
-  typedef void UserThreadFunc(T);
-
-  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
-      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
-  }
-  virtual ~ThreadWithParam() {}
-
- private:
-  class RunnableImpl : public Runnable {
-   public:
-    RunnableImpl(UserThreadFunc* func, T param)
-        : func_(func),
-          param_(param) {
-    }
-    virtual ~RunnableImpl() {}
-    virtual void Run() {
-      func_(param_);
-    }
-
-   private:
-    UserThreadFunc* const func_;
-    const T param_;
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
-  };
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
-};
-
-// Implements thread-local storage on Windows systems.
-//
-//   // Thread 1
-//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
-//
-//   // Thread 2
-//   tl.set(150);  // Changes the value for thread 2 only.
-//   EXPECT_EQ(150, tl.get());
-//
-//   // Thread 1
-//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
-//   tl.set(200);
-//   EXPECT_EQ(200, tl.get());
-//
-// The template type argument T must have a public copy constructor.
-// In addition, the default ThreadLocal constructor requires T to have
-// a public default constructor.
-//
-// The users of a TheadLocal instance have to make sure that all but one
-// threads (including the main one) using that instance have exited before
-// destroying it. Otherwise, the per-thread objects managed for them by the
-// ThreadLocal instance are not guaranteed to be destroyed on all platforms.
-//
-// Google Test only uses global ThreadLocal objects.  That means they
-// will die after main() has returned.  Therefore, no per-thread
-// object managed by Google Test will be leaked as long as all threads
-// using Google Test have exited when main() returns.
-template <typename T>
-class ThreadLocal : public ThreadLocalBase {
- public:
-  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
-  explicit ThreadLocal(const T& value)
-      : default_factory_(new InstanceValueHolderFactory(value)) {}
-
-  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
-
-  T* pointer() { return GetOrCreateValue(); }
-  const T* pointer() const { return GetOrCreateValue(); }
-  const T& get() const { return *pointer(); }
-  void set(const T& value) { *pointer() = value; }
-
- private:
-  // Holds a value of T.  Can be deleted via its base class without the caller
-  // knowing the type of T.
-  class ValueHolder : public ThreadLocalValueHolderBase {
-   public:
-    ValueHolder() : value_() {}
-    explicit ValueHolder(const T& value) : value_(value) {}
-
-    T* pointer() { return &value_; }
-
-   private:
-    T value_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
-  };
-
-
-  T* GetOrCreateValue() const {
-    return static_cast<ValueHolder*>(
-        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
-  }
-
-  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
-    return default_factory_->MakeNewHolder();
-  }
-
-  class ValueHolderFactory {
-   public:
-    ValueHolderFactory() {}
-    virtual ~ValueHolderFactory() {}
-    virtual ValueHolder* MakeNewHolder() const = 0;
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
-  };
-
-  class DefaultValueHolderFactory : public ValueHolderFactory {
-   public:
-    DefaultValueHolderFactory() {}
-    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
-  };
-
-  class InstanceValueHolderFactory : public ValueHolderFactory {
-   public:
-    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
-    virtual ValueHolder* MakeNewHolder() const {
-      return new ValueHolder(value_);
-    }
-
-   private:
-    const T value_;  // The value for each thread.
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
-  };
-
-  scoped_ptr<ValueHolderFactory> default_factory_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
-};
-
-# elif GTEST_HAS_PTHREAD
-
-// MutexBase and Mutex implement mutex on pthreads-based platforms.
-class MutexBase {
- public:
-  // Acquires this mutex.
-  void Lock() {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
-    owner_ = pthread_self();
-    has_owner_ = true;
-  }
-
-  // Releases this mutex.
-  void Unlock() {
-    // Since the lock is being released the owner_ field should no longer be
-    // considered valid. We don't protect writing to has_owner_ here, as it's
-    // the caller's responsibility to ensure that the current thread holds the
-    // mutex when this is called.
-    has_owner_ = false;
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
-  }
-
-  // Does nothing if the current thread holds the mutex. Otherwise, crashes
-  // with high probability.
-  void AssertHeld() const {
-    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
-        << "The current thread is not holding the mutex @" << this;
-  }
-
-  // A static mutex may be used before main() is entered.  It may even
-  // be used before the dynamic initialization stage.  Therefore we
-  // must be able to initialize a static mutex object at link time.
-  // This means MutexBase has to be a POD and its member variables
-  // have to be public.
- public:
-  pthread_mutex_t mutex_;  // The underlying pthread mutex.
-  // has_owner_ indicates whether the owner_ field below contains a valid thread
-  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
-  // accesses to the owner_ field should be protected by a check of this field.
-  // An alternative might be to memset() owner_ to all zeros, but there's no
-  // guarantee that a zero'd pthread_t is necessarily invalid or even different
-  // from pthread_self().
-  bool has_owner_;
-  pthread_t owner_;  // The thread holding the mutex.
-};
-
-// Forward-declares a static mutex.
-#  define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
-     extern ::testing::internal::MutexBase mutex
-
-// Defines and statically (i.e. at link time) initializes a static mutex.
-#  define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
-     ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false, pthread_t() }
-
-// 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_, NULL));
-    has_owner_ = false;
-  }
-  ~Mutex() {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
-};
-
-// We cannot name this class MutexLock because the ctor declaration would
-// conflict with a macro named MutexLock, which is defined on some
-// platforms. That macro is used as a defensive measure to prevent against
-// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
-// "MutexLock l(&mu)".  Hence the typedef trick below.
-class GTestMutexLock {
- public:
-  explicit GTestMutexLock(MutexBase* mutex)
-      : mutex_(mutex) { mutex_->Lock(); }
-
-  ~GTestMutexLock() { mutex_->Unlock(); }
-
- private:
-  MutexBase* const mutex_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
-};
-
-typedef GTestMutexLock MutexLock;
-
-// Helpers for ThreadLocal.
-
-// pthread_key_create() requires DeleteThreadLocalValue() to have
-// C-linkage.  Therefore it cannot be templatized to access
-// ThreadLocal<T>.  Hence the need for class
-// ThreadLocalValueHolderBase.
-class ThreadLocalValueHolderBase {
- public:
-  virtual ~ThreadLocalValueHolderBase() {}
-};
-
-// Called by pthread to delete thread-local data stored by
-// pthread_setspecific().
-extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
-  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
-}
-
-// Implements thread-local storage on pthreads-based systems.
-template <typename T>
-class ThreadLocal {
- public:
-  ThreadLocal()
-      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
-  explicit ThreadLocal(const T& value)
-      : key_(CreateKey()),
-        default_factory_(new InstanceValueHolderFactory(value)) {}
-
-  ~ThreadLocal() {
-    // Destroys the managed object for the current thread, if any.
-    DeleteThreadLocalValue(pthread_getspecific(key_));
-
-    // Releases resources associated with the key.  This will *not*
-    // delete managed objects for other threads.
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
-  }
-
-  T* pointer() { return GetOrCreateValue(); }
-  const T* pointer() const { return GetOrCreateValue(); }
-  const T& get() const { return *pointer(); }
-  void set(const T& value) { *pointer() = value; }
-
- private:
-  // Holds a value of type T.
-  class ValueHolder : public ThreadLocalValueHolderBase {
-   public:
-    ValueHolder() : value_() {}
-    explicit ValueHolder(const T& value) : value_(value) {}
-
-    T* pointer() { return &value_; }
-
-   private:
-    T value_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
-  };
-
-  static pthread_key_t CreateKey() {
-    pthread_key_t key;
-    // When a thread exits, DeleteThreadLocalValue() will be called on
-    // the object managed for that thread.
-    GTEST_CHECK_POSIX_SUCCESS_(
-        pthread_key_create(&key, &DeleteThreadLocalValue));
-    return key;
-  }
-
-  T* GetOrCreateValue() const {
-    ThreadLocalValueHolderBase* const holder =
-        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
-    if (holder != NULL) {
-      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
-    }
-
-    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
-    ThreadLocalValueHolderBase* const holder_base = new_holder;
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
-    return new_holder->pointer();
-  }
-
-  class ValueHolderFactory {
-   public:
-    ValueHolderFactory() {}
-    virtual ~ValueHolderFactory() {}
-    virtual ValueHolder* MakeNewHolder() const = 0;
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
-  };
-
-  class DefaultValueHolderFactory : public ValueHolderFactory {
-   public:
-    DefaultValueHolderFactory() {}
-    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
-
-   private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
-  };
-
-  class InstanceValueHolderFactory : public ValueHolderFactory {
-   public:
-    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
-    virtual ValueHolder* MakeNewHolder() const {
-      return new ValueHolder(value_);
-    }
-
-   private:
-    const T value_;  // The value for each thread.
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
-  };
-
-  // A key pthreads uses for looking up per-thread values.
-  const pthread_key_t key_;
-  scoped_ptr<ValueHolderFactory> default_factory_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
-};
-
-# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
-
-#else  // GTEST_IS_THREADSAFE
-
-// A dummy implementation of synchronization primitives (mutex, lock,
-// and thread-local variable).  Necessary for compiling Google Test where
-// mutex is not supported - using Google Test in multiple threads is not
-// supported on such platforms.
-
-class Mutex {
- public:
-  Mutex() {}
-  void Lock() {}
-  void Unlock() {}
-  void AssertHeld() const {}
-};
-
-# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
-  extern ::testing::internal::Mutex mutex
-
-# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
-
-// We cannot name this class MutexLock because the ctor declaration would
-// conflict with a macro named MutexLock, which is defined on some
-// platforms. That macro is used as a defensive measure to prevent against
-// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
-// "MutexLock l(&mu)".  Hence the typedef trick below.
-class GTestMutexLock {
- public:
-  explicit GTestMutexLock(Mutex*) {}  // NOLINT
-};
-
-typedef GTestMutexLock MutexLock;
-
-template <typename T>
-class ThreadLocal {
- public:
-  ThreadLocal() : value_() {}
-  explicit ThreadLocal(const T& value) : value_(value) {}
-  T* pointer() { return &value_; }
-  const T* pointer() const { return &value_; }
-  const T& get() const { return value_; }
-  void set(const T& value) { value_ = value; }
- private:
-  T value_;
-};
-
-#endif  // GTEST_IS_THREADSAFE
-
-// Returns the number of threads running in the process, or 0 to indicate that
-// we cannot detect it.
-GTEST_API_ size_t GetThreadCount();
-
-// Passing non-POD classes through ellipsis (...) crashes the ARM
-// compiler and generates a warning in Sun Studio.  The Nokia Symbian
-// and the IBM XL C/C++ compiler try to instantiate a copy constructor
-// for objects passed through ellipsis (...), failing for uncopyable
-// objects.  We define this to ensure that only POD is passed through
-// ellipsis on these systems.
-#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
-// We lose support for NULL detection where the compiler doesn't like
-// passing non-POD classes through ellipsis (...).
-# define GTEST_ELLIPSIS_NEEDS_POD_ 1
-#else
-# define GTEST_CAN_COMPARE_NULL 1
-#endif
-
-// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
-// const T& and const T* in a function template.  These compilers
-// _can_ decide between class template specializations for T and T*,
-// so a tr1::type_traits-like is_pointer works.
-#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
-# define GTEST_NEEDS_IS_POINTER_ 1
-#endif
-
-template <bool bool_value>
-struct bool_constant {
-  typedef bool_constant<bool_value> type;
-  static const bool value = bool_value;
-};
-template <bool bool_value> const bool bool_constant<bool_value>::value;
-
-typedef bool_constant<false> false_type;
-typedef bool_constant<true> true_type;
-
-template <typename T>
-struct is_pointer : public false_type {};
-
-template <typename T>
-struct is_pointer<T*> : public true_type {};
-
-template <typename Iterator>
-struct IteratorTraits {
-  typedef typename Iterator::value_type value_type;
-};
-
-template <typename T>
-struct IteratorTraits<T*> {
-  typedef T value_type;
-};
-
-template <typename T>
-struct IteratorTraits<const T*> {
-  typedef T value_type;
-};
-
-#if GTEST_OS_WINDOWS
-# define GTEST_PATH_SEP_ "\\"
-# define GTEST_HAS_ALT_PATH_SEP_ 1
-// The biggest signed integer type the compiler supports.
-typedef __int64 BiggestInt;
-#else
-# define GTEST_PATH_SEP_ "/"
-# define GTEST_HAS_ALT_PATH_SEP_ 0
-typedef long long BiggestInt;  // NOLINT
-#endif  // GTEST_OS_WINDOWS
-
-// Utilities for char.
-
-// isspace(int ch) and friends accept an unsigned char or EOF.  char
-// may be signed, depending on the compiler (or compiler flags).
-// Therefore we need to cast a char to unsigned char before calling
-// isspace(), etc.
-
-inline bool IsAlpha(char ch) {
-  return isalpha(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsAlNum(char ch) {
-  return isalnum(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsDigit(char ch) {
-  return isdigit(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsLower(char ch) {
-  return islower(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsSpace(char ch) {
-  return isspace(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsUpper(char ch) {
-  return isupper(static_cast<unsigned char>(ch)) != 0;
-}
-inline bool IsXDigit(char ch) {
-  return isxdigit(static_cast<unsigned char>(ch)) != 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;
-}
-
-inline char ToLower(char ch) {
-  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
-}
-inline char ToUpper(char ch) {
-  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
-}
-
-inline std::string StripTrailingSpaces(std::string str) {
-  std::string::iterator it = str.end();
-  while (it != str.begin() && IsSpace(*--it))
-    it = str.erase(it);
-  return str;
-}
-
-// The testing::internal::posix namespace holds wrappers for common
-// POSIX functions.  These wrappers hide the differences between
-// Windows/MSVC and POSIX systems.  Since some compilers define these
-// standard functions as macros, the wrapper cannot have the same name
-// as the wrapped function.
-
-namespace posix {
-
-// Functions with a different name on Windows.
-
-#if GTEST_OS_WINDOWS
-
-typedef struct _stat StatStruct;
-
-# ifdef __BORLANDC__
-inline int IsATTY(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 IsATTY(int /* fd */) { return 0; }
-#  else
-inline int IsATTY(int fd) { return _isatty(fd); }
-#  endif  // GTEST_OS_WINDOWS_MOBILE
-inline int StrCaseCmp(const char* s1, const char* s2) {
-  return _stricmp(s1, s2);
-}
-inline char* StrDup(const char* src) { return _strdup(src); }
-# endif  // __BORLANDC__
-
-# if GTEST_OS_WINDOWS_MOBILE
-inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
-// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
-// time and thus not defined there.
-# else
-inline int FileNo(FILE* file) { return _fileno(file); }
-inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
-inline int RmDir(const char* dir) { return _rmdir(dir); }
-inline bool IsDir(const StatStruct& st) {
-  return (_S_IFDIR & st.st_mode) != 0;
-}
-# endif  // GTEST_OS_WINDOWS_MOBILE
-
-#else
-
-typedef struct stat StatStruct;
-
-inline int FileNo(FILE* file) { return fileno(file); }
-inline int IsATTY(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);
-}
-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); }
-
-#endif  // GTEST_OS_WINDOWS
-
-// Functions deprecated by MSVC 8.0.
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */)
-
-inline const char* StrNCpy(char* dest, const char* src, size_t n) {
-  return strncpy(dest, src, n);
-}
-
-// 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
-inline int ChDir(const char* dir) { return chdir(dir); }
-#endif
-inline FILE* FOpen(const char* path, const char* mode) {
-  return fopen(path, mode);
-}
-#if !GTEST_OS_WINDOWS_MOBILE
-inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
-  return freopen(path, mode, stream);
-}
-inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
-#endif
-inline int FClose(FILE* fp) { return fclose(fp); }
-#if !GTEST_OS_WINDOWS_MOBILE
-inline int Read(int fd, void* buf, unsigned int count) {
-  return static_cast<int>(read(fd, buf, count));
-}
-inline int Write(int fd, const void* buf, unsigned int count) {
-  return static_cast<int>(write(fd, buf, count));
-}
-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
-  // We are on Windows CE, which has no environment variables.
-  static_cast<void>(name);  // To prevent 'unused argument' warning.
-  return NULL;
-#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 != NULL && env[0] != '\0') ? env : NULL;
-#else
-  return getenv(name);
-#endif
-}
-
-GTEST_DISABLE_MSC_WARNINGS_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.
-void Abort();
-#else
-inline void Abort() { abort(); }
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-}  // namespace posix
-
-// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
-// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
-// 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 >= 1400 && !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 and MSVC prior to 2005 doesn't
-// complain about _snprintf.
-# define GTEST_SNPRINTF_ _snprintf
-#else
-# define GTEST_SNPRINTF_ snprintf
-#endif
-
-// The maximum number a BiggestInt can represent.  This definition
-// works no matter BiggestInt is represented in one's complement or
-// two's complement.
-//
-// We cannot rely on numeric_limits in STL, as __int64 and long long
-// are not part of standard C++ and numeric_limits doesn't need to be
-// defined for them.
-const BiggestInt kMaxBiggestInt =
-    ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
-
-// 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.
-//
-//   TypeWithSize<4>::UInt
-//
-// is typedef-ed to be unsigned int (unsigned integer made up of 4
-// bytes).
-//
-// Such functionality should belong to STL, but I cannot find it
-// there.
-//
-// Google Test uses this class in the implementation of floating-point
-// comparison.
-//
-// For now it only handles UInt (unsigned int) as that's all Google Test
-// needs.  Other types can be easily added in the future if need
-// arises.
-template <size_t size>
-class TypeWithSize {
- public:
-  // This prevents the user from using TypeWithSize<N> with incorrect
-  // values of N.
-  typedef void UInt;
-};
-
-// The specialization for size 4.
-template <>
-class TypeWithSize<4> {
- public:
-  // unsigned int has size 4 in both gcc and MSVC.
-  //
-  // As base/basictypes.h doesn't compile on Windows, we cannot use
-  // uint32, uint64, and etc here.
-  typedef int Int;
-  typedef unsigned int UInt;
-};
-
-// The specialization for size 8.
-template <>
-class TypeWithSize<8> {
- public:
-#if GTEST_OS_WINDOWS
-  typedef __int64 Int;
-  typedef unsigned __int64 UInt;
-#else
-  typedef long long Int;  // NOLINT
-  typedef unsigned long long UInt;  // NOLINT
-#endif  // GTEST_OS_WINDOWS
-};
-
-// Integer types of known sizes.
-typedef TypeWithSize<4>::Int Int32;
-typedef TypeWithSize<4>::UInt UInt32;
-typedef TypeWithSize<8>::Int Int64;
-typedef TypeWithSize<8>::UInt UInt64;
-typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
-
-// Utilities for command line flags and environment variables.
-
-// Macro for referencing flags.
-#if !defined(GTEST_FLAG)
-# define GTEST_FLAG(name) FLAGS_gtest_##name
-#endif  // !defined(GTEST_FLAG)
-
-#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
-# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
-#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
-
-#if !defined(GTEST_DECLARE_bool_)
-# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
-
-// Macros for declaring flags.
-# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
-# define GTEST_DECLARE_int32_(name) \
-    GTEST_API_ extern ::testing::internal::Int32 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) \
-    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
-#define GTEST_DEFINE_int32_(name, default_val, doc) \
-    GTEST_API_ ::testing::internal::Int32 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_)
-
-// Thread annotations
-#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
-# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
-# define GTEST_LOCK_EXCLUDED_(locks)
-#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
-
-// 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.
-// TODO(chandlerc): Find a better way to refactor flag and environment parsing
-// out of both gtest-port.cc and gtest.cc to avoid exporting this utility
-// function.
-bool ParseInt32(const Message& src_text, const char* str, Int32* value);
-
-// Parses a bool/Int32/string from the environment variable
-// corresponding to the given Google Test flag.
-bool BoolFromGTestEnv(const char* flag, bool default_val);
-GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
-std::string StringFromGTestEnv(const char* flag, const char* default_val);
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-string.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-string.h
deleted file mode 100644
index 97f1a7fd..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-string.h
+++ /dev/null
@@ -1,167 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
-//
-// The Google C++ Testing 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/gtest-internal.h>.
-// It should not be #included by other files.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
-
-#ifdef __BORLANDC__
-// string.h is not guaranteed to provide strcpy on C++ Builder.
-# include <mem.h>
-#endif
-
-#include <string.h>
-#include <string>
-
-#include "gtest/internal/gtest-port.h"
-
-namespace testing {
-namespace internal {
-
-// String - an abstract class holding static string utilities.
-class GTEST_API_ String {
- public:
-  // Static utility methods
-
-  // Clones a 0-terminated C string, allocating memory using new.  The
-  // caller is responsible for deleting the return value using
-  // delete[].  Returns the cloned string, or NULL if the input is
-  // NULL.
-  //
-  // This is different from strdup() in string.h, which allocates
-  // memory using malloc().
-  static const char* CloneCString(const char* c_str);
-
-#if GTEST_OS_WINDOWS_MOBILE
-  // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
-  // able to pass strings to Win32 APIs on CE we need to convert them
-  // to 'Unicode', UTF-16.
-
-  // Creates a UTF-16 wide string from the given ANSI string, allocating
-  // memory using new. The caller is responsible for deleting the return
-  // value using delete[]. Returns the wide string, or NULL if the
-  // input is NULL.
-  //
-  // The wide string is created using the ANSI codepage (CP_ACP) to
-  // match the behaviour of the ANSI versions of Win32 calls and the
-  // C runtime.
-  static LPCWSTR AnsiToUtf16(const char* c_str);
-
-  // Creates an ANSI string from the given wide string, allocating
-  // memory using new. The caller is responsible for deleting the return
-  // value using delete[]. Returns the ANSI string, or NULL if the
-  // input is NULL.
-  //
-  // The returned string is created using the ANSI codepage (CP_ACP) to
-  // match the behaviour of the ANSI versions of Win32 calls and the
-  // C runtime.
-  static const char* Utf16ToAnsi(LPCWSTR utf16_str);
-#endif
-
-  // Compares two C strings.  Returns true iff 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.
-  static bool CStringEquals(const char* lhs, const char* rhs);
-
-  // Converts a wide C string to a String using the UTF-8 encoding.
-  // NULL will be converted to "(null)".  If an error occurred during
-  // the conversion, "(failed to convert from wide string)" is
-  // returned.
-  static std::string ShowWideCString(const wchar_t* wide_c_str);
-
-  // Compares two wide C strings.  Returns true iff 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 iff 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.
-  static bool CaseInsensitiveCStringEquals(const char* lhs,
-                                           const char* rhs);
-
-  // Compares two wide C strings, ignoring case.  Returns true iff 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.
-  static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
-                                               const wchar_t* rhs);
-
-  // Returns true iff 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 as "%X".
-  static std::string FormatHexInt(int value);
-
-  // Formats a byte as "%02X".
-  static std::string FormatByte(unsigned char value);
-
- private:
-  String();  // Not meant to be instantiated.
-};  // class String
-
-// Gets the content of the stringstream's buffer as an std::string.  Each '\0'
-// character in the buffer is replaced with "\\0".
-GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h
deleted file mode 100644
index e9b40534..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h
+++ /dev/null
@@ -1,1020 +0,0 @@
-// This file was GENERATED by command:
-//     pump.py gtest-tuple.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// Copyright 2009 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Implements a subset of TR1 tuple needed by Google Test and Google Mock.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
-
-#include <utility>  // For ::std::pair.
-
-// The compiler used in Symbian has a bug that prevents us from declaring the
-// tuple template as a friend (it complains that tuple is redefined).  This
-// hack bypasses the bug by declaring the members that should otherwise be
-// private as public.
-// Sun Studio versions < 12 also have the above bug.
-#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
-# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
-#else
-# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
-    template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
-   private:
-#endif
-
-// Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that conflict
-// with our own definitions. Therefore using our own tuple does not work on
-// those compilers.
-#if defined(_MSC_VER) && _MSC_VER >= 1600  /* 1600 is Visual Studio 2010 */
-# error "gtest's tuple doesn't compile on Visual Studio 2010 or later. \
-GTEST_USE_OWN_TR1_TUPLE must be set to 0 on those compilers."
-#endif
-
-// GTEST_n_TUPLE_(T) is the type of an n-tuple.
-#define GTEST_0_TUPLE_(T) tuple<>
-#define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \
-    void, void, void>
-#define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \
-    void, void, void>
-#define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \
-    void, void, void>
-#define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \
-    void, void, void>
-#define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
-    void, void, void>
-#define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
-    void, void, void>
-#define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
-    void, void, void>
-#define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
-    T##7, void, void>
-#define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
-    T##7, T##8, void>
-#define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
-    T##7, T##8, T##9>
-
-// GTEST_n_TYPENAMES_(T) declares a list of n typenames.
-#define GTEST_0_TYPENAMES_(T)
-#define GTEST_1_TYPENAMES_(T) typename T##0
-#define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1
-#define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2
-#define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3
-#define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3, typename T##4
-#define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3, typename T##4, typename T##5
-#define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3, typename T##4, typename T##5, typename T##6
-#define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3, typename T##4, typename T##5, typename T##6, typename T##7
-#define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3, typename T##4, typename T##5, typename T##6, \
-    typename T##7, typename T##8
-#define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
-    typename T##3, typename T##4, typename T##5, typename T##6, \
-    typename T##7, typename T##8, typename T##9
-
-// In theory, defining stuff in the ::std namespace is undefined
-// behavior.  We can do this as we are playing the role of a standard
-// library vendor.
-namespace std {
-namespace tr1 {
-
-template <typename T0 = void, typename T1 = void, typename T2 = void,
-    typename T3 = void, typename T4 = void, typename T5 = void,
-    typename T6 = void, typename T7 = void, typename T8 = void,
-    typename T9 = void>
-class tuple;
-
-// Anything in namespace gtest_internal is Google Test's INTERNAL
-// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
-namespace gtest_internal {
-
-// ByRef<T>::type is T if T is a reference; otherwise it's const T&.
-template <typename T>
-struct ByRef { typedef const T& type; };  // NOLINT
-template <typename T>
-struct ByRef<T&> { typedef T& type; };  // NOLINT
-
-// A handy wrapper for ByRef.
-#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
-
-// AddRef<T>::type is T if T is a reference; otherwise it's T&.  This
-// is the same as tr1::add_reference<T>::type.
-template <typename T>
-struct AddRef { typedef T& type; };  // NOLINT
-template <typename T>
-struct AddRef<T&> { typedef T& type; };  // NOLINT
-
-// A handy wrapper for AddRef.
-#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
-
-// A helper for implementing get<k>().
-template <int k> class Get;
-
-// A helper for implementing tuple_element<k, T>.  kIndexValid is true
-// iff k < the number of fields in tuple type T.
-template <bool kIndexValid, int kIndex, class Tuple>
-struct TupleElement;
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > {
-  typedef T0 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > {
-  typedef T1 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > {
-  typedef T2 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > {
-  typedef T3 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > {
-  typedef T4 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > {
-  typedef T5 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > {
-  typedef T6 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > {
-  typedef T7 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > {
-  typedef T8 type;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > {
-  typedef T9 type;
-};
-
-}  // namespace gtest_internal
-
-template <>
-class tuple<> {
- public:
-  tuple() {}
-  tuple(const tuple& /* t */)  {}
-  tuple& operator=(const tuple& /* t */) { return *this; }
-};
-
-template <GTEST_1_TYPENAMES_(T)>
-class GTEST_1_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
-
-  tuple(const tuple& t) : f0_(t.f0_) {}
-
-  template <GTEST_1_TYPENAMES_(U)>
-  tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_1_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_1_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    return *this;
-  }
-
-  T0 f0_;
-};
-
-template <GTEST_2_TYPENAMES_(T)>
-class GTEST_2_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
-      f1_(f1) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
-
-  template <GTEST_2_TYPENAMES_(U)>
-  tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
-  template <typename U0, typename U1>
-  tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_2_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-  template <typename U0, typename U1>
-  tuple& operator=(const ::std::pair<U0, U1>& p) {
-    f0_ = p.first;
-    f1_ = p.second;
-    return *this;
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_2_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-};
-
-template <GTEST_3_TYPENAMES_(T)>
-class GTEST_3_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
-
-  template <GTEST_3_TYPENAMES_(U)>
-  tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_3_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_3_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-};
-
-template <GTEST_4_TYPENAMES_(T)>
-class GTEST_4_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2),
-      f3_(f3) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
-
-  template <GTEST_4_TYPENAMES_(U)>
-  tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_4_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_4_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-};
-
-template <GTEST_5_TYPENAMES_(T)>
-class GTEST_5_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3,
-      GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
-      f4_(t.f4_) {}
-
-  template <GTEST_5_TYPENAMES_(U)>
-  tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_), f4_(t.f4_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_5_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_5_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    f4_ = t.f4_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-  T4 f4_;
-};
-
-template <GTEST_6_TYPENAMES_(T)>
-class GTEST_6_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
-      GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
-      f5_(f5) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
-      f4_(t.f4_), f5_(t.f5_) {}
-
-  template <GTEST_6_TYPENAMES_(U)>
-  tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_6_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_6_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    f4_ = t.f4_;
-    f5_ = t.f5_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-  T4 f4_;
-  T5 f5_;
-};
-
-template <GTEST_7_TYPENAMES_(T)>
-class GTEST_7_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
-      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2),
-      f3_(f3), f4_(f4), f5_(f5), f6_(f6) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
-      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
-
-  template <GTEST_7_TYPENAMES_(U)>
-  tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_7_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_7_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    f4_ = t.f4_;
-    f5_ = t.f5_;
-    f6_ = t.f6_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-  T4 f4_;
-  T5 f5_;
-  T6 f6_;
-};
-
-template <GTEST_8_TYPENAMES_(T)>
-class GTEST_8_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
-      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6,
-      GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
-      f5_(f5), f6_(f6), f7_(f7) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
-      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
-
-  template <GTEST_8_TYPENAMES_(U)>
-  tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_8_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_8_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    f4_ = t.f4_;
-    f5_ = t.f5_;
-    f6_ = t.f6_;
-    f7_ = t.f7_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-  T4 f4_;
-  T5 f5_;
-  T6 f6_;
-  T7 f7_;
-};
-
-template <GTEST_9_TYPENAMES_(T)>
-class GTEST_9_TUPLE_(T) {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
-      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
-      GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
-      f5_(f5), f6_(f6), f7_(f7), f8_(f8) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
-      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
-
-  template <GTEST_9_TYPENAMES_(U)>
-  tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_9_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_9_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    f4_ = t.f4_;
-    f5_ = t.f5_;
-    f6_ = t.f6_;
-    f7_ = t.f7_;
-    f8_ = t.f8_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-  T4 f4_;
-  T5 f5_;
-  T6 f6_;
-  T7 f7_;
-  T8 f8_;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-class tuple {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(),
-      f9_() {}
-
-  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
-      GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
-      GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
-      GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2),
-      f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {}
-
-  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
-      f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {}
-
-  template <GTEST_10_TYPENAMES_(U)>
-  tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
-      f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
-      f9_(t.f9_) {}
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_10_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_10_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
-    f0_ = t.f0_;
-    f1_ = t.f1_;
-    f2_ = t.f2_;
-    f3_ = t.f3_;
-    f4_ = t.f4_;
-    f5_ = t.f5_;
-    f6_ = t.f6_;
-    f7_ = t.f7_;
-    f8_ = t.f8_;
-    f9_ = t.f9_;
-    return *this;
-  }
-
-  T0 f0_;
-  T1 f1_;
-  T2 f2_;
-  T3 f3_;
-  T4 f4_;
-  T5 f5_;
-  T6 f6_;
-  T7 f7_;
-  T8 f8_;
-  T9 f9_;
-};
-
-// 6.1.3.2 Tuple creation functions.
-
-// Known limitations: we don't support passing an
-// std::tr1::reference_wrapper<T> to make_tuple().  And we don't
-// implement tie().
-
-inline tuple<> make_tuple() { return tuple<>(); }
-
-template <GTEST_1_TYPENAMES_(T)>
-inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) {
-  return GTEST_1_TUPLE_(T)(f0);
-}
-
-template <GTEST_2_TYPENAMES_(T)>
-inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
-  return GTEST_2_TUPLE_(T)(f0, f1);
-}
-
-template <GTEST_3_TYPENAMES_(T)>
-inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
-  return GTEST_3_TUPLE_(T)(f0, f1, f2);
-}
-
-template <GTEST_4_TYPENAMES_(T)>
-inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3) {
-  return GTEST_4_TUPLE_(T)(f0, f1, f2, f3);
-}
-
-template <GTEST_5_TYPENAMES_(T)>
-inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3, const T4& f4) {
-  return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4);
-}
-
-template <GTEST_6_TYPENAMES_(T)>
-inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3, const T4& f4, const T5& f5) {
-  return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5);
-}
-
-template <GTEST_7_TYPENAMES_(T)>
-inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3, const T4& f4, const T5& f5, const T6& f6) {
-  return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6);
-}
-
-template <GTEST_8_TYPENAMES_(T)>
-inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) {
-  return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7);
-}
-
-template <GTEST_9_TYPENAMES_(T)>
-inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
-    const T8& f8) {
-  return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8);
-}
-
-template <GTEST_10_TYPENAMES_(T)>
-inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
-    const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
-    const T8& f8, const T9& f9) {
-  return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
-}
-
-// 6.1.3.3 Tuple helper classes.
-
-template <typename Tuple> struct tuple_size;
-
-template <GTEST_0_TYPENAMES_(T)>
-struct tuple_size<GTEST_0_TUPLE_(T) > {
-  static const int value = 0;
-};
-
-template <GTEST_1_TYPENAMES_(T)>
-struct tuple_size<GTEST_1_TUPLE_(T) > {
-  static const int value = 1;
-};
-
-template <GTEST_2_TYPENAMES_(T)>
-struct tuple_size<GTEST_2_TUPLE_(T) > {
-  static const int value = 2;
-};
-
-template <GTEST_3_TYPENAMES_(T)>
-struct tuple_size<GTEST_3_TUPLE_(T) > {
-  static const int value = 3;
-};
-
-template <GTEST_4_TYPENAMES_(T)>
-struct tuple_size<GTEST_4_TUPLE_(T) > {
-  static const int value = 4;
-};
-
-template <GTEST_5_TYPENAMES_(T)>
-struct tuple_size<GTEST_5_TUPLE_(T) > {
-  static const int value = 5;
-};
-
-template <GTEST_6_TYPENAMES_(T)>
-struct tuple_size<GTEST_6_TUPLE_(T) > {
-  static const int value = 6;
-};
-
-template <GTEST_7_TYPENAMES_(T)>
-struct tuple_size<GTEST_7_TUPLE_(T) > {
-  static const int value = 7;
-};
-
-template <GTEST_8_TYPENAMES_(T)>
-struct tuple_size<GTEST_8_TUPLE_(T) > {
-  static const int value = 8;
-};
-
-template <GTEST_9_TYPENAMES_(T)>
-struct tuple_size<GTEST_9_TUPLE_(T) > {
-  static const int value = 9;
-};
-
-template <GTEST_10_TYPENAMES_(T)>
-struct tuple_size<GTEST_10_TUPLE_(T) > {
-  static const int value = 10;
-};
-
-template <int k, class Tuple>
-struct tuple_element {
-  typedef typename gtest_internal::TupleElement<
-      k < (tuple_size<Tuple>::value), k, Tuple>::type type;
-};
-
-#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
-
-// 6.1.3.4 Element access.
-
-namespace gtest_internal {
-
-template <>
-class Get<0> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
-  Field(Tuple& t) { return t.f0_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
-  ConstField(const Tuple& t) { return t.f0_; }
-};
-
-template <>
-class Get<1> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
-  Field(Tuple& t) { return t.f1_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
-  ConstField(const Tuple& t) { return t.f1_; }
-};
-
-template <>
-class Get<2> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
-  Field(Tuple& t) { return t.f2_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
-  ConstField(const Tuple& t) { return t.f2_; }
-};
-
-template <>
-class Get<3> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
-  Field(Tuple& t) { return t.f3_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
-  ConstField(const Tuple& t) { return t.f3_; }
-};
-
-template <>
-class Get<4> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
-  Field(Tuple& t) { return t.f4_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
-  ConstField(const Tuple& t) { return t.f4_; }
-};
-
-template <>
-class Get<5> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
-  Field(Tuple& t) { return t.f5_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
-  ConstField(const Tuple& t) { return t.f5_; }
-};
-
-template <>
-class Get<6> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
-  Field(Tuple& t) { return t.f6_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
-  ConstField(const Tuple& t) { return t.f6_; }
-};
-
-template <>
-class Get<7> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
-  Field(Tuple& t) { return t.f7_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
-  ConstField(const Tuple& t) { return t.f7_; }
-};
-
-template <>
-class Get<8> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
-  Field(Tuple& t) { return t.f8_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
-  ConstField(const Tuple& t) { return t.f8_; }
-};
-
-template <>
-class Get<9> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
-  Field(Tuple& t) { return t.f9_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
-  ConstField(const Tuple& t) { return t.f9_; }
-};
-
-}  // namespace gtest_internal
-
-template <int k, GTEST_10_TYPENAMES_(T)>
-GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
-get(GTEST_10_TUPLE_(T)& t) {
-  return gtest_internal::Get<k>::Field(t);
-}
-
-template <int k, GTEST_10_TYPENAMES_(T)>
-GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k,  GTEST_10_TUPLE_(T)))
-get(const GTEST_10_TUPLE_(T)& t) {
-  return gtest_internal::Get<k>::ConstField(t);
-}
-
-// 6.1.3.5 Relational operators
-
-// We only implement == and !=, as we don't have a need for the rest yet.
-
-namespace gtest_internal {
-
-// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
-// first k fields of t1 equals the first k fields of t2.
-// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
-// k1 != k2.
-template <int kSize1, int kSize2>
-struct SameSizeTuplePrefixComparator;
-
-template <>
-struct SameSizeTuplePrefixComparator<0, 0> {
-  template <class Tuple1, class Tuple2>
-  static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
-    return true;
-  }
-};
-
-template <int k>
-struct SameSizeTuplePrefixComparator<k, k> {
-  template <class Tuple1, class Tuple2>
-  static bool Eq(const Tuple1& t1, const Tuple2& t2) {
-    return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
-        ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
-  }
-};
-
-}  // namespace gtest_internal
-
-template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
-inline bool operator==(const GTEST_10_TUPLE_(T)& t,
-                       const GTEST_10_TUPLE_(U)& u) {
-  return gtest_internal::SameSizeTuplePrefixComparator<
-      tuple_size<GTEST_10_TUPLE_(T) >::value,
-      tuple_size<GTEST_10_TUPLE_(U) >::value>::Eq(t, u);
-}
-
-template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
-inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
-                       const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
-
-// 6.1.4 Pairs.
-// Unimplemented.
-
-}  // namespace tr1
-}  // namespace std
-
-#undef GTEST_0_TUPLE_
-#undef GTEST_1_TUPLE_
-#undef GTEST_2_TUPLE_
-#undef GTEST_3_TUPLE_
-#undef GTEST_4_TUPLE_
-#undef GTEST_5_TUPLE_
-#undef GTEST_6_TUPLE_
-#undef GTEST_7_TUPLE_
-#undef GTEST_8_TUPLE_
-#undef GTEST_9_TUPLE_
-#undef GTEST_10_TUPLE_
-
-#undef GTEST_0_TYPENAMES_
-#undef GTEST_1_TYPENAMES_
-#undef GTEST_2_TYPENAMES_
-#undef GTEST_3_TYPENAMES_
-#undef GTEST_4_TYPENAMES_
-#undef GTEST_5_TYPENAMES_
-#undef GTEST_6_TYPENAMES_
-#undef GTEST_7_TYPENAMES_
-#undef GTEST_8_TYPENAMES_
-#undef GTEST_9_TYPENAMES_
-#undef GTEST_10_TYPENAMES_
-
-#undef GTEST_DECLARE_TUPLE_AS_FRIEND_
-#undef GTEST_BY_REF_
-#undef GTEST_ADD_REF_
-#undef GTEST_TUPLE_ELEMENT_
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h.pump b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h.pump
deleted file mode 100644
index 429ddfee..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-tuple.h.pump
+++ /dev/null
@@ -1,347 +0,0 @@
-$$ -*- mode: c++; -*-
-$var n = 10  $$ Maximum number of tuple fields we want to support.
-$$ This meta comment fixes auto-indentation in Emacs. }}
-// Copyright 2009 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Implements a subset of TR1 tuple needed by Google Test and Google Mock.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
-
-#include <utility>  // For ::std::pair.
-
-// The compiler used in Symbian has a bug that prevents us from declaring the
-// tuple template as a friend (it complains that tuple is redefined).  This
-// hack bypasses the bug by declaring the members that should otherwise be
-// private as public.
-// Sun Studio versions < 12 also have the above bug.
-#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
-# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
-#else
-# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
-    template <GTEST_$(n)_TYPENAMES_(U)> friend class tuple; \
-   private:
-#endif
-
-// Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that conflict
-// with our own definitions. Therefore using our own tuple does not work on
-// those compilers.
-#if defined(_MSC_VER) && _MSC_VER >= 1600  /* 1600 is Visual Studio 2010 */
-# error "gtest's tuple doesn't compile on Visual Studio 2010 or later. \
-GTEST_USE_OWN_TR1_TUPLE must be set to 0 on those compilers."
-#endif
-
-
-$range i 0..n-1
-$range j 0..n
-$range k 1..n
-// GTEST_n_TUPLE_(T) is the type of an n-tuple.
-#define GTEST_0_TUPLE_(T) tuple<>
-
-$for k [[
-$range m 0..k-1
-$range m2 k..n-1
-#define GTEST_$(k)_TUPLE_(T) tuple<$for m, [[T##$m]]$for m2 [[, void]]>
-
-]]
-
-// GTEST_n_TYPENAMES_(T) declares a list of n typenames.
-
-$for j [[
-$range m 0..j-1
-#define GTEST_$(j)_TYPENAMES_(T) $for m, [[typename T##$m]]
-
-
-]]
-
-// In theory, defining stuff in the ::std namespace is undefined
-// behavior.  We can do this as we are playing the role of a standard
-// library vendor.
-namespace std {
-namespace tr1 {
-
-template <$for i, [[typename T$i = void]]>
-class tuple;
-
-// Anything in namespace gtest_internal is Google Test's INTERNAL
-// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
-namespace gtest_internal {
-
-// ByRef<T>::type is T if T is a reference; otherwise it's const T&.
-template <typename T>
-struct ByRef { typedef const T& type; };  // NOLINT
-template <typename T>
-struct ByRef<T&> { typedef T& type; };  // NOLINT
-
-// A handy wrapper for ByRef.
-#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
-
-// AddRef<T>::type is T if T is a reference; otherwise it's T&.  This
-// is the same as tr1::add_reference<T>::type.
-template <typename T>
-struct AddRef { typedef T& type; };  // NOLINT
-template <typename T>
-struct AddRef<T&> { typedef T& type; };  // NOLINT
-
-// A handy wrapper for AddRef.
-#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
-
-// A helper for implementing get<k>().
-template <int k> class Get;
-
-// A helper for implementing tuple_element<k, T>.  kIndexValid is true
-// iff k < the number of fields in tuple type T.
-template <bool kIndexValid, int kIndex, class Tuple>
-struct TupleElement;
-
-
-$for i [[
-template <GTEST_$(n)_TYPENAMES_(T)>
-struct TupleElement<true, $i, GTEST_$(n)_TUPLE_(T) > {
-  typedef T$i type;
-};
-
-
-]]
-}  // namespace gtest_internal
-
-template <>
-class tuple<> {
- public:
-  tuple() {}
-  tuple(const tuple& /* t */)  {}
-  tuple& operator=(const tuple& /* t */) { return *this; }
-};
-
-
-$for k [[
-$range m 0..k-1
-template <GTEST_$(k)_TYPENAMES_(T)>
-class $if k < n [[GTEST_$(k)_TUPLE_(T)]] $else [[tuple]] {
- public:
-  template <int k> friend class gtest_internal::Get;
-
-  tuple() : $for m, [[f$(m)_()]] {}
-
-  explicit tuple($for m, [[GTEST_BY_REF_(T$m) f$m]]) : [[]]
-$for m, [[f$(m)_(f$m)]] {}
-
-  tuple(const tuple& t) : $for m, [[f$(m)_(t.f$(m)_)]] {}
-
-  template <GTEST_$(k)_TYPENAMES_(U)>
-  tuple(const GTEST_$(k)_TUPLE_(U)& t) : $for m, [[f$(m)_(t.f$(m)_)]] {}
-
-$if k == 2 [[
-  template <typename U0, typename U1>
-  tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
-
-]]
-
-  tuple& operator=(const tuple& t) { return CopyFrom(t); }
-
-  template <GTEST_$(k)_TYPENAMES_(U)>
-  tuple& operator=(const GTEST_$(k)_TUPLE_(U)& t) {
-    return CopyFrom(t);
-  }
-
-$if k == 2 [[
-  template <typename U0, typename U1>
-  tuple& operator=(const ::std::pair<U0, U1>& p) {
-    f0_ = p.first;
-    f1_ = p.second;
-    return *this;
-  }
-
-]]
-
-  GTEST_DECLARE_TUPLE_AS_FRIEND_
-
-  template <GTEST_$(k)_TYPENAMES_(U)>
-  tuple& CopyFrom(const GTEST_$(k)_TUPLE_(U)& t) {
-
-$for m [[
-    f$(m)_ = t.f$(m)_;
-
-]]
-    return *this;
-  }
-
-
-$for m [[
-  T$m f$(m)_;
-
-]]
-};
-
-
-]]
-// 6.1.3.2 Tuple creation functions.
-
-// Known limitations: we don't support passing an
-// std::tr1::reference_wrapper<T> to make_tuple().  And we don't
-// implement tie().
-
-inline tuple<> make_tuple() { return tuple<>(); }
-
-$for k [[
-$range m 0..k-1
-
-template <GTEST_$(k)_TYPENAMES_(T)>
-inline GTEST_$(k)_TUPLE_(T) make_tuple($for m, [[const T$m& f$m]]) {
-  return GTEST_$(k)_TUPLE_(T)($for m, [[f$m]]);
-}
-
-]]
-
-// 6.1.3.3 Tuple helper classes.
-
-template <typename Tuple> struct tuple_size;
-
-
-$for j [[
-template <GTEST_$(j)_TYPENAMES_(T)>
-struct tuple_size<GTEST_$(j)_TUPLE_(T) > {
-  static const int value = $j;
-};
-
-
-]]
-template <int k, class Tuple>
-struct tuple_element {
-  typedef typename gtest_internal::TupleElement<
-      k < (tuple_size<Tuple>::value), k, Tuple>::type type;
-};
-
-#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
-
-// 6.1.3.4 Element access.
-
-namespace gtest_internal {
-
-
-$for i [[
-template <>
-class Get<$i> {
- public:
-  template <class Tuple>
-  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple))
-  Field(Tuple& t) { return t.f$(i)_; }  // NOLINT
-
-  template <class Tuple>
-  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple))
-  ConstField(const Tuple& t) { return t.f$(i)_; }
-};
-
-
-]]
-}  // namespace gtest_internal
-
-template <int k, GTEST_$(n)_TYPENAMES_(T)>
-GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T)))
-get(GTEST_$(n)_TUPLE_(T)& t) {
-  return gtest_internal::Get<k>::Field(t);
-}
-
-template <int k, GTEST_$(n)_TYPENAMES_(T)>
-GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k,  GTEST_$(n)_TUPLE_(T)))
-get(const GTEST_$(n)_TUPLE_(T)& t) {
-  return gtest_internal::Get<k>::ConstField(t);
-}
-
-// 6.1.3.5 Relational operators
-
-// We only implement == and !=, as we don't have a need for the rest yet.
-
-namespace gtest_internal {
-
-// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
-// first k fields of t1 equals the first k fields of t2.
-// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
-// k1 != k2.
-template <int kSize1, int kSize2>
-struct SameSizeTuplePrefixComparator;
-
-template <>
-struct SameSizeTuplePrefixComparator<0, 0> {
-  template <class Tuple1, class Tuple2>
-  static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
-    return true;
-  }
-};
-
-template <int k>
-struct SameSizeTuplePrefixComparator<k, k> {
-  template <class Tuple1, class Tuple2>
-  static bool Eq(const Tuple1& t1, const Tuple2& t2) {
-    return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
-        ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
-  }
-};
-
-}  // namespace gtest_internal
-
-template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)>
-inline bool operator==(const GTEST_$(n)_TUPLE_(T)& t,
-                       const GTEST_$(n)_TUPLE_(U)& u) {
-  return gtest_internal::SameSizeTuplePrefixComparator<
-      tuple_size<GTEST_$(n)_TUPLE_(T) >::value,
-      tuple_size<GTEST_$(n)_TUPLE_(U) >::value>::Eq(t, u);
-}
-
-template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)>
-inline bool operator!=(const GTEST_$(n)_TUPLE_(T)& t,
-                       const GTEST_$(n)_TUPLE_(U)& u) { return !(t == u); }
-
-// 6.1.4 Pairs.
-// Unimplemented.
-
-}  // namespace tr1
-}  // namespace std
-
-
-$for j [[
-#undef GTEST_$(j)_TUPLE_
-
-]]
-
-
-$for j [[
-#undef GTEST_$(j)_TYPENAMES_
-
-]]
-
-#undef GTEST_DECLARE_TUPLE_AS_FRIEND_
-#undef GTEST_BY_REF_
-#undef GTEST_ADD_REF_
-#undef GTEST_TUPLE_ELEMENT_
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h
deleted file mode 100644
index e46f7cfc..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h
+++ /dev/null
@@ -1,3331 +0,0 @@
-// This file was GENERATED by command:
-//     pump.py gtest-type-util.h.pump
-// DO NOT EDIT BY HAND!!!
-
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Type utilities needed for implementing typed and type-parameterized
-// tests.  This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
-//
-// Currently we support at most 50 types in a list, and at most 50
-// type-parameterized tests in one type-parameterized test case.
-// Please contact googletestframework@googlegroups.com if you need
-// more.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
-
-#include "gtest/internal/gtest-port.h"
-
-// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
-// libstdc++ (which is where cxxabi.h comes from).
-# if GTEST_HAS_CXXABI_H_
-#  include <cxxabi.h>
-# elif defined(__HP_aCC)
-#  include <acxx_demangle.h>
-# endif  // GTEST_HASH_CXXABI_H_
-
-namespace testing {
-namespace internal {
-
-// GetTypeName<T>() returns a human-readable name of type T.
-// 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
-
-  const char* const name = typeid(T).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_
-  using abi::__cxa_demangle;
-#   endif  // GTEST_HAS_CXXABI_H_
-  char* const readable_name = __cxa_demangle(name, 0, 0, &status);
-  const std::string name_str(status == 0 ? readable_name : name);
-  free(readable_name);
-  return name_str;
-#  else
-  return name;
-#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
-
-# else
-
-  return "<type>";
-
-# endif  // GTEST_HAS_RTTI
-}
-
-#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
-// type.  This can be used as a compile-time assertion to ensure that
-// two types are equal.
-
-template <typename T1, typename T2>
-struct AssertTypeEq;
-
-template <typename T>
-struct AssertTypeEq<T, T> {
-  typedef bool type;
-};
-
-// A unique type used as the default value for the arguments of class
-// template Types.  This allows us to simulate variadic templates
-// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
-// support directly.
-struct None {};
-
-// The following family of struct and struct templates are used to
-// represent type lists.  In particular, TypesN<T1, T2, ..., TN>
-// represents a type list with N types (T1, T2, ..., and TN) in it.
-// Except for Types0, every struct in the family has two member types:
-// Head for the first type in the list, and Tail for the rest of the
-// list.
-
-// The empty type list.
-struct Types0 {};
-
-// Type lists of length 1, 2, 3, and so on.
-
-template <typename T1>
-struct Types1 {
-  typedef T1 Head;
-  typedef Types0 Tail;
-};
-template <typename T1, typename T2>
-struct Types2 {
-  typedef T1 Head;
-  typedef Types1<T2> Tail;
-};
-
-template <typename T1, typename T2, typename T3>
-struct Types3 {
-  typedef T1 Head;
-  typedef Types2<T2, T3> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4>
-struct Types4 {
-  typedef T1 Head;
-  typedef Types3<T2, T3, T4> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-struct Types5 {
-  typedef T1 Head;
-  typedef Types4<T2, T3, T4, T5> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-struct Types6 {
-  typedef T1 Head;
-  typedef Types5<T2, T3, T4, T5, T6> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-struct Types7 {
-  typedef T1 Head;
-  typedef Types6<T2, T3, T4, T5, T6, T7> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-struct Types8 {
-  typedef T1 Head;
-  typedef Types7<T2, T3, T4, T5, T6, T7, T8> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-struct Types9 {
-  typedef T1 Head;
-  typedef Types8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-struct Types10 {
-  typedef T1 Head;
-  typedef Types9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11>
-struct Types11 {
-  typedef T1 Head;
-  typedef Types10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12>
-struct Types12 {
-  typedef T1 Head;
-  typedef Types11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13>
-struct Types13 {
-  typedef T1 Head;
-  typedef Types12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14>
-struct Types14 {
-  typedef T1 Head;
-  typedef Types13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15>
-struct Types15 {
-  typedef T1 Head;
-  typedef Types14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16>
-struct Types16 {
-  typedef T1 Head;
-  typedef Types15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17>
-struct Types17 {
-  typedef T1 Head;
-  typedef Types16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18>
-struct Types18 {
-  typedef T1 Head;
-  typedef Types17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19>
-struct Types19 {
-  typedef T1 Head;
-  typedef Types18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20>
-struct Types20 {
-  typedef T1 Head;
-  typedef Types19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21>
-struct Types21 {
-  typedef T1 Head;
-  typedef Types20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22>
-struct Types22 {
-  typedef T1 Head;
-  typedef Types21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23>
-struct Types23 {
-  typedef T1 Head;
-  typedef Types22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24>
-struct Types24 {
-  typedef T1 Head;
-  typedef Types23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25>
-struct Types25 {
-  typedef T1 Head;
-  typedef Types24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26>
-struct Types26 {
-  typedef T1 Head;
-  typedef Types25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27>
-struct Types27 {
-  typedef T1 Head;
-  typedef Types26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28>
-struct Types28 {
-  typedef T1 Head;
-  typedef Types27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29>
-struct Types29 {
-  typedef T1 Head;
-  typedef Types28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30>
-struct Types30 {
-  typedef T1 Head;
-  typedef Types29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31>
-struct Types31 {
-  typedef T1 Head;
-  typedef Types30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32>
-struct Types32 {
-  typedef T1 Head;
-  typedef Types31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33>
-struct Types33 {
-  typedef T1 Head;
-  typedef Types32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34>
-struct Types34 {
-  typedef T1 Head;
-  typedef Types33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35>
-struct Types35 {
-  typedef T1 Head;
-  typedef Types34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36>
-struct Types36 {
-  typedef T1 Head;
-  typedef Types35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37>
-struct Types37 {
-  typedef T1 Head;
-  typedef Types36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38>
-struct Types38 {
-  typedef T1 Head;
-  typedef Types37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39>
-struct Types39 {
-  typedef T1 Head;
-  typedef Types38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40>
-struct Types40 {
-  typedef T1 Head;
-  typedef Types39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41>
-struct Types41 {
-  typedef T1 Head;
-  typedef Types40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42>
-struct Types42 {
-  typedef T1 Head;
-  typedef Types41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43>
-struct Types43 {
-  typedef T1 Head;
-  typedef Types42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44>
-struct Types44 {
-  typedef T1 Head;
-  typedef Types43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45>
-struct Types45 {
-  typedef T1 Head;
-  typedef Types44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46>
-struct Types46 {
-  typedef T1 Head;
-  typedef Types45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47>
-struct Types47 {
-  typedef T1 Head;
-  typedef Types46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46, T47> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48>
-struct Types48 {
-  typedef T1 Head;
-  typedef Types47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46, T47, T48> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49>
-struct Types49 {
-  typedef T1 Head;
-  typedef Types48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46, T47, T48, T49> Tail;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49, typename T50>
-struct Types50 {
-  typedef T1 Head;
-  typedef Types49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-      T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-      T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-      T44, T45, T46, T47, T48, T49, T50> Tail;
-};
-
-
-}  // namespace internal
-
-// We don't want to require the users to write TypesN<...> directly,
-// as that would require them to count the length.  Types<...> is much
-// easier to write, but generates horrible messages when there is a
-// compiler error, as gcc insists on printing out each template
-// argument, even if it has the default value (this means Types<int>
-// will appear as Types<int, None, None, ..., None> in the compiler
-// errors).
-//
-// Our solution is to combine the best part of the two approaches: a
-// user would write Types<T1, ..., TN>, and Google Test will translate
-// that to TypesN<T1, ..., TN> internally to make error messages
-// readable.  The translation is done by the 'type' member of the
-// Types template.
-template <typename T1 = internal::None, typename T2 = internal::None,
-    typename T3 = internal::None, typename T4 = internal::None,
-    typename T5 = internal::None, typename T6 = internal::None,
-    typename T7 = internal::None, typename T8 = internal::None,
-    typename T9 = internal::None, typename T10 = internal::None,
-    typename T11 = internal::None, typename T12 = internal::None,
-    typename T13 = internal::None, typename T14 = internal::None,
-    typename T15 = internal::None, typename T16 = internal::None,
-    typename T17 = internal::None, typename T18 = internal::None,
-    typename T19 = internal::None, typename T20 = internal::None,
-    typename T21 = internal::None, typename T22 = internal::None,
-    typename T23 = internal::None, typename T24 = internal::None,
-    typename T25 = internal::None, typename T26 = internal::None,
-    typename T27 = internal::None, typename T28 = internal::None,
-    typename T29 = internal::None, typename T30 = internal::None,
-    typename T31 = internal::None, typename T32 = internal::None,
-    typename T33 = internal::None, typename T34 = internal::None,
-    typename T35 = internal::None, typename T36 = internal::None,
-    typename T37 = internal::None, typename T38 = internal::None,
-    typename T39 = internal::None, typename T40 = internal::None,
-    typename T41 = internal::None, typename T42 = internal::None,
-    typename T43 = internal::None, typename T44 = internal::None,
-    typename T45 = internal::None, typename T46 = internal::None,
-    typename T47 = internal::None, typename T48 = internal::None,
-    typename T49 = internal::None, typename T50 = internal::None>
-struct Types {
-  typedef internal::Types50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
-};
-
-template <>
-struct Types<internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types0 type;
-};
-template <typename T1>
-struct Types<T1, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types1<T1> type;
-};
-template <typename T1, typename T2>
-struct Types<T1, T2, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types2<T1, T2> type;
-};
-template <typename T1, typename T2, typename T3>
-struct Types<T1, T2, T3, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types3<T1, T2, T3> type;
-};
-template <typename T1, typename T2, typename T3, typename T4>
-struct Types<T1, T2, T3, T4, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types4<T1, T2, T3, T4> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-struct Types<T1, T2, T3, T4, T5, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types5<T1, T2, T3, T4, T5> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6>
-struct Types<T1, T2, T3, T4, T5, T6, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types6<T1, T2, T3, T4, T5, T6> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7>
-struct Types<T1, T2, T3, T4, T5, T6, T7, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types7<T1, T2, T3, T4, T5, T6, T7> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types8<T1, T2, T3, T4, T5, T6, T7, T8> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
-      T12> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
-      T26> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
-      T40> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, internal::None,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None, internal::None> {
-  typedef internal::Types43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None, internal::None> {
-  typedef internal::Types44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    internal::None, internal::None, internal::None, internal::None,
-    internal::None> {
-  typedef internal::Types45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    T46, internal::None, internal::None, internal::None, internal::None> {
-  typedef internal::Types46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    T46, T47, internal::None, internal::None, internal::None> {
-  typedef internal::Types47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    T46, T47, T48, internal::None, internal::None> {
-  typedef internal::Types48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47, T48> type;
-};
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49>
-struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
-    T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
-    T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
-    T46, T47, T48, T49, internal::None> {
-  typedef internal::Types49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47, T48, T49> type;
-};
-
-namespace internal {
-
-# define GTEST_TEMPLATE_ template <typename T> class
-
-// The template "selector" struct TemplateSel<Tmpl> is used to
-// represent Tmpl, which must be a class template with one type
-// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
-// as the type Tmpl<T>.  This allows us to actually instantiate the
-// template "selected" by TemplateSel<Tmpl>.
-//
-// This trick is necessary for simulating typedef for class templates,
-// which C++ doesn't support directly.
-template <GTEST_TEMPLATE_ Tmpl>
-struct TemplateSel {
-  template <typename T>
-  struct Bind {
-    typedef Tmpl<T> type;
-  };
-};
-
-# define GTEST_BIND_(TmplSel, T) \
-  TmplSel::template Bind<T>::type
-
-// A unique struct template used as the default value for the
-// arguments of class template Templates.  This allows us to simulate
-// variadic templates (e.g. Templates<int>, Templates<int, double>,
-// and etc), which C++ doesn't support directly.
-template <typename T>
-struct NoneT {};
-
-// The following family of struct and struct templates are used to
-// represent template lists.  In particular, TemplatesN<T1, T2, ...,
-// TN> represents a list of N templates (T1, T2, ..., and TN).  Except
-// for Templates0, every struct in the family has two member types:
-// Head for the selector of the first template in the list, and Tail
-// for the rest of the list.
-
-// The empty template list.
-struct Templates0 {};
-
-// Template lists of length 1, 2, 3, and so on.
-
-template <GTEST_TEMPLATE_ T1>
-struct Templates1 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates0 Tail;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
-struct Templates2 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates1<T2> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
-struct Templates3 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates2<T2, T3> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4>
-struct Templates4 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates3<T2, T3, T4> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
-struct Templates5 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates4<T2, T3, T4, T5> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
-struct Templates6 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates5<T2, T3, T4, T5, T6> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7>
-struct Templates7 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates6<T2, T3, T4, T5, T6, T7> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
-struct Templates8 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates7<T2, T3, T4, T5, T6, T7, T8> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
-struct Templates9 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10>
-struct Templates10 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
-struct Templates11 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
-struct Templates12 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13>
-struct Templates13 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
-struct Templates14 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
-struct Templates15 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16>
-struct Templates16 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
-struct Templates17 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
-struct Templates18 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19>
-struct Templates19 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
-struct Templates20 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
-struct Templates21 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22>
-struct Templates22 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
-struct Templates23 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
-struct Templates24 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25>
-struct Templates25 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
-struct Templates26 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
-struct Templates27 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28>
-struct Templates28 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
-struct Templates29 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
-struct Templates30 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31>
-struct Templates31 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
-struct Templates32 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
-struct Templates33 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34>
-struct Templates34 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
-struct Templates35 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
-struct Templates36 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37>
-struct Templates37 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
-struct Templates38 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
-struct Templates39 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40>
-struct Templates40 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
-struct Templates41 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42>
-struct Templates42 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43>
-struct Templates43 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44>
-struct Templates44 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45>
-struct Templates45 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46>
-struct Templates46 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47>
-struct Templates47 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46, T47> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48>
-struct Templates48 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46, T47, T48> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
-    GTEST_TEMPLATE_ T49>
-struct Templates49 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46, T47, T48, T49> Tail;
-};
-
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
-    GTEST_TEMPLATE_ T49, GTEST_TEMPLATE_ T50>
-struct Templates50 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-      T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-      T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
-      T43, T44, T45, T46, T47, T48, T49, T50> Tail;
-};
-
-
-// We don't want to require the users to write TemplatesN<...> directly,
-// as that would require them to count the length.  Templates<...> is much
-// easier to write, but generates horrible messages when there is a
-// compiler error, as gcc insists on printing out each template
-// argument, even if it has the default value (this means Templates<list>
-// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler
-// errors).
-//
-// Our solution is to combine the best part of the two approaches: a
-// user would write Templates<T1, ..., TN>, and Google Test will translate
-// that to TemplatesN<T1, ..., TN> internally to make error messages
-// readable.  The translation is done by the 'type' member of the
-// Templates template.
-template <GTEST_TEMPLATE_ T1 = NoneT, GTEST_TEMPLATE_ T2 = NoneT,
-    GTEST_TEMPLATE_ T3 = NoneT, GTEST_TEMPLATE_ T4 = NoneT,
-    GTEST_TEMPLATE_ T5 = NoneT, GTEST_TEMPLATE_ T6 = NoneT,
-    GTEST_TEMPLATE_ T7 = NoneT, GTEST_TEMPLATE_ T8 = NoneT,
-    GTEST_TEMPLATE_ T9 = NoneT, GTEST_TEMPLATE_ T10 = NoneT,
-    GTEST_TEMPLATE_ T11 = NoneT, GTEST_TEMPLATE_ T12 = NoneT,
-    GTEST_TEMPLATE_ T13 = NoneT, GTEST_TEMPLATE_ T14 = NoneT,
-    GTEST_TEMPLATE_ T15 = NoneT, GTEST_TEMPLATE_ T16 = NoneT,
-    GTEST_TEMPLATE_ T17 = NoneT, GTEST_TEMPLATE_ T18 = NoneT,
-    GTEST_TEMPLATE_ T19 = NoneT, GTEST_TEMPLATE_ T20 = NoneT,
-    GTEST_TEMPLATE_ T21 = NoneT, GTEST_TEMPLATE_ T22 = NoneT,
-    GTEST_TEMPLATE_ T23 = NoneT, GTEST_TEMPLATE_ T24 = NoneT,
-    GTEST_TEMPLATE_ T25 = NoneT, GTEST_TEMPLATE_ T26 = NoneT,
-    GTEST_TEMPLATE_ T27 = NoneT, GTEST_TEMPLATE_ T28 = NoneT,
-    GTEST_TEMPLATE_ T29 = NoneT, GTEST_TEMPLATE_ T30 = NoneT,
-    GTEST_TEMPLATE_ T31 = NoneT, GTEST_TEMPLATE_ T32 = NoneT,
-    GTEST_TEMPLATE_ T33 = NoneT, GTEST_TEMPLATE_ T34 = NoneT,
-    GTEST_TEMPLATE_ T35 = NoneT, GTEST_TEMPLATE_ T36 = NoneT,
-    GTEST_TEMPLATE_ T37 = NoneT, GTEST_TEMPLATE_ T38 = NoneT,
-    GTEST_TEMPLATE_ T39 = NoneT, GTEST_TEMPLATE_ T40 = NoneT,
-    GTEST_TEMPLATE_ T41 = NoneT, GTEST_TEMPLATE_ T42 = NoneT,
-    GTEST_TEMPLATE_ T43 = NoneT, GTEST_TEMPLATE_ T44 = NoneT,
-    GTEST_TEMPLATE_ T45 = NoneT, GTEST_TEMPLATE_ T46 = NoneT,
-    GTEST_TEMPLATE_ T47 = NoneT, GTEST_TEMPLATE_ T48 = NoneT,
-    GTEST_TEMPLATE_ T49 = NoneT, GTEST_TEMPLATE_ T50 = NoneT>
-struct Templates {
-  typedef Templates50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
-};
-
-template <>
-struct Templates<NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT> {
-  typedef Templates0 type;
-};
-template <GTEST_TEMPLATE_ T1>
-struct Templates<T1, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT> {
-  typedef Templates1<T1> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
-struct Templates<T1, T2, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT> {
-  typedef Templates2<T1, T2> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
-struct Templates<T1, T2, T3, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates3<T1, T2, T3> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4>
-struct Templates<T1, T2, T3, T4, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates4<T1, T2, T3, T4> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
-struct Templates<T1, T2, T3, T4, T5, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates5<T1, T2, T3, T4, T5> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
-struct Templates<T1, T2, T3, T4, T5, T6, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates6<T1, T2, T3, T4, T5, T6> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates7<T1, T2, T3, T4, T5, T6, T7> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates8<T1, T2, T3, T4, T5, T6, T7, T8> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT> {
-  typedef Templates22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT> {
-  typedef Templates23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT> {
-  typedef Templates24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT> {
-  typedef Templates25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT> {
-  typedef Templates26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT> {
-  typedef Templates27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT> {
-  typedef Templates28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT> {
-  typedef Templates29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, NoneT, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, NoneT, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, NoneT, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, NoneT, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, NoneT,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, NoneT, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, T46, NoneT, NoneT, NoneT, NoneT> {
-  typedef Templates46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, T46, T47, NoneT, NoneT, NoneT> {
-  typedef Templates47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46, T47> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, T46, T47, T48, NoneT, NoneT> {
-  typedef Templates48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46, T47, T48> type;
-};
-template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
-    GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
-    GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
-    GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
-    GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
-    GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
-    GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
-    GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
-    GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
-    GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
-    GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
-    GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
-    GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
-    GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
-    GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
-    GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
-    GTEST_TEMPLATE_ T49>
-struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
-    T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
-    T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
-    T45, T46, T47, T48, T49, NoneT> {
-  typedef Templates49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-      T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
-      T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
-      T42, T43, T44, T45, T46, T47, T48, T49> type;
-};
-
-// The TypeList template makes it possible to use either a single type
-// or a Types<...> list in TYPED_TEST_CASE() and
-// INSTANTIATE_TYPED_TEST_CASE_P().
-
-template <typename T>
-struct TypeList {
-  typedef Types1<T> type;
-};
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-    typename T6, typename T7, typename T8, typename T9, typename T10,
-    typename T11, typename T12, typename T13, typename T14, typename T15,
-    typename T16, typename T17, typename T18, typename T19, typename T20,
-    typename T21, typename T22, typename T23, typename T24, typename T25,
-    typename T26, typename T27, typename T28, typename T29, typename T30,
-    typename T31, typename T32, typename T33, typename T34, typename T35,
-    typename T36, typename T37, typename T38, typename T39, typename T40,
-    typename T41, typename T42, typename T43, typename T44, typename T45,
-    typename T46, typename T47, typename T48, typename T49, typename T50>
-struct TypeList<Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
-    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
-    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
-    T44, T45, T46, T47, T48, T49, T50> > {
-  typedef typename Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
-      T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
-      T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
-      T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>::type type;
-};
-
-#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h.pump b/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h.pump
deleted file mode 100644
index 251fdf02..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/include/gtest/internal/gtest-type-util.h.pump
+++ /dev/null
@@ -1,297 +0,0 @@
-$$ -*- mode: c++; -*-
-$var n = 50  $$ Maximum length of type lists we want to support.
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Type utilities needed for implementing typed and type-parameterized
-// tests.  This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
-//
-// Currently we support at most $n types in a list, and at most $n
-// type-parameterized tests in one type-parameterized test case.
-// Please contact googletestframework@googlegroups.com if you need
-// more.
-
-#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
-#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
-
-#include "gtest/internal/gtest-port.h"
-
-// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
-// libstdc++ (which is where cxxabi.h comes from).
-# if GTEST_HAS_CXXABI_H_
-#  include <cxxabi.h>
-# elif defined(__HP_aCC)
-#  include <acxx_demangle.h>
-# endif  // GTEST_HASH_CXXABI_H_
-
-namespace testing {
-namespace internal {
-
-// GetTypeName<T>() returns a human-readable name of type T.
-// 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
-
-  const char* const name = typeid(T).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_
-  using abi::__cxa_demangle;
-#   endif  // GTEST_HAS_CXXABI_H_
-  char* const readable_name = __cxa_demangle(name, 0, 0, &status);
-  const std::string name_str(status == 0 ? readable_name : name);
-  free(readable_name);
-  return name_str;
-#  else
-  return name;
-#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
-
-# else
-
-  return "<type>";
-
-# endif  // GTEST_HAS_RTTI
-}
-
-#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
-// type.  This can be used as a compile-time assertion to ensure that
-// two types are equal.
-
-template <typename T1, typename T2>
-struct AssertTypeEq;
-
-template <typename T>
-struct AssertTypeEq<T, T> {
-  typedef bool type;
-};
-
-// A unique type used as the default value for the arguments of class
-// template Types.  This allows us to simulate variadic templates
-// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
-// support directly.
-struct None {};
-
-// The following family of struct and struct templates are used to
-// represent type lists.  In particular, TypesN<T1, T2, ..., TN>
-// represents a type list with N types (T1, T2, ..., and TN) in it.
-// Except for Types0, every struct in the family has two member types:
-// Head for the first type in the list, and Tail for the rest of the
-// list.
-
-// The empty type list.
-struct Types0 {};
-
-// Type lists of length 1, 2, 3, and so on.
-
-template <typename T1>
-struct Types1 {
-  typedef T1 Head;
-  typedef Types0 Tail;
-};
-
-$range i 2..n
-
-$for i [[
-$range j 1..i
-$range k 2..i
-template <$for j, [[typename T$j]]>
-struct Types$i {
-  typedef T1 Head;
-  typedef Types$(i-1)<$for k, [[T$k]]> Tail;
-};
-
-
-]]
-
-}  // namespace internal
-
-// We don't want to require the users to write TypesN<...> directly,
-// as that would require them to count the length.  Types<...> is much
-// easier to write, but generates horrible messages when there is a
-// compiler error, as gcc insists on printing out each template
-// argument, even if it has the default value (this means Types<int>
-// will appear as Types<int, None, None, ..., None> in the compiler
-// errors).
-//
-// Our solution is to combine the best part of the two approaches: a
-// user would write Types<T1, ..., TN>, and Google Test will translate
-// that to TypesN<T1, ..., TN> internally to make error messages
-// readable.  The translation is done by the 'type' member of the
-// Types template.
-
-$range i 1..n
-template <$for i, [[typename T$i = internal::None]]>
-struct Types {
-  typedef internal::Types$n<$for i, [[T$i]]> type;
-};
-
-template <>
-struct Types<$for i, [[internal::None]]> {
-  typedef internal::Types0 type;
-};
-
-$range i 1..n-1
-$for i [[
-$range j 1..i
-$range k i+1..n
-template <$for j, [[typename T$j]]>
-struct Types<$for j, [[T$j]]$for k[[, internal::None]]> {
-  typedef internal::Types$i<$for j, [[T$j]]> type;
-};
-
-]]
-
-namespace internal {
-
-# define GTEST_TEMPLATE_ template <typename T> class
-
-// The template "selector" struct TemplateSel<Tmpl> is used to
-// represent Tmpl, which must be a class template with one type
-// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
-// as the type Tmpl<T>.  This allows us to actually instantiate the
-// template "selected" by TemplateSel<Tmpl>.
-//
-// This trick is necessary for simulating typedef for class templates,
-// which C++ doesn't support directly.
-template <GTEST_TEMPLATE_ Tmpl>
-struct TemplateSel {
-  template <typename T>
-  struct Bind {
-    typedef Tmpl<T> type;
-  };
-};
-
-# define GTEST_BIND_(TmplSel, T) \
-  TmplSel::template Bind<T>::type
-
-// A unique struct template used as the default value for the
-// arguments of class template Templates.  This allows us to simulate
-// variadic templates (e.g. Templates<int>, Templates<int, double>,
-// and etc), which C++ doesn't support directly.
-template <typename T>
-struct NoneT {};
-
-// The following family of struct and struct templates are used to
-// represent template lists.  In particular, TemplatesN<T1, T2, ...,
-// TN> represents a list of N templates (T1, T2, ..., and TN).  Except
-// for Templates0, every struct in the family has two member types:
-// Head for the selector of the first template in the list, and Tail
-// for the rest of the list.
-
-// The empty template list.
-struct Templates0 {};
-
-// Template lists of length 1, 2, 3, and so on.
-
-template <GTEST_TEMPLATE_ T1>
-struct Templates1 {
-  typedef TemplateSel<T1> Head;
-  typedef Templates0 Tail;
-};
-
-$range i 2..n
-
-$for i [[
-$range j 1..i
-$range k 2..i
-template <$for j, [[GTEST_TEMPLATE_ T$j]]>
-struct Templates$i {
-  typedef TemplateSel<T1> Head;
-  typedef Templates$(i-1)<$for k, [[T$k]]> Tail;
-};
-
-
-]]
-
-// We don't want to require the users to write TemplatesN<...> directly,
-// as that would require them to count the length.  Templates<...> is much
-// easier to write, but generates horrible messages when there is a
-// compiler error, as gcc insists on printing out each template
-// argument, even if it has the default value (this means Templates<list>
-// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler
-// errors).
-//
-// Our solution is to combine the best part of the two approaches: a
-// user would write Templates<T1, ..., TN>, and Google Test will translate
-// that to TemplatesN<T1, ..., TN> internally to make error messages
-// readable.  The translation is done by the 'type' member of the
-// Templates template.
-
-$range i 1..n
-template <$for i, [[GTEST_TEMPLATE_ T$i = NoneT]]>
-struct Templates {
-  typedef Templates$n<$for i, [[T$i]]> type;
-};
-
-template <>
-struct Templates<$for i, [[NoneT]]> {
-  typedef Templates0 type;
-};
-
-$range i 1..n-1
-$for i [[
-$range j 1..i
-$range k i+1..n
-template <$for j, [[GTEST_TEMPLATE_ T$j]]>
-struct Templates<$for j, [[T$j]]$for k[[, NoneT]]> {
-  typedef Templates$i<$for j, [[T$j]]> type;
-};
-
-]]
-
-// The TypeList template makes it possible to use either a single type
-// or a Types<...> list in TYPED_TEST_CASE() and
-// INSTANTIATE_TYPED_TEST_CASE_P().
-
-template <typename T>
-struct TypeList {
-  typedef Types1<T> type;
-};
-
-
-$range i 1..n
-template <$for i, [[typename T$i]]>
-struct TypeList<Types<$for i, [[T$i]]> > {
-  typedef typename Types<$for i, [[T$i]]>::type type;
-};
-
-#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/m4/acx_pthread.m4 b/week4/softwareEng_9_4/vendor/googletest/googletest/m4/acx_pthread.m4
deleted file mode 100644
index 2cf20de1..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/m4/acx_pthread.m4
+++ /dev/null
@@ -1,363 +0,0 @@
-# This was retrieved from
-#    http://svn.0pointer.de/viewvc/trunk/common/acx_pthread.m4?revision=1277&root=avahi
-# See also (perhaps for new versions?)
-#    http://svn.0pointer.de/viewvc/trunk/common/acx_pthread.m4?root=avahi
-#
-# We've rewritten the inconsistency check code (from avahi), to work
-# more broadly.  In particular, it no longer assumes ld accepts -zdefs.
-# This caused a restructing of the code, but the functionality has only
-# changed a little.
-
-dnl @synopsis ACX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
-dnl
-dnl @summary figure out how to build C programs using POSIX threads
-dnl
-dnl This macro figures out how to build C programs using POSIX threads.
-dnl It sets the PTHREAD_LIBS output variable to the threads library and
-dnl linker flags, and the PTHREAD_CFLAGS output variable to any special
-dnl C compiler flags that are needed. (The user can also force certain
-dnl compiler flags/libs to be tested by setting these environment
-dnl variables.)
-dnl
-dnl Also sets PTHREAD_CC to any special C compiler that is needed for
-dnl multi-threaded programs (defaults to the value of CC otherwise).
-dnl (This is necessary on AIX to use the special cc_r compiler alias.)
-dnl
-dnl NOTE: You are assumed to not only compile your program with these
-dnl flags, but also link it with them as well. e.g. you should link
-dnl with $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS
-dnl $LIBS
-dnl
-dnl If you are only building threads programs, you may wish to use
-dnl these variables in your default LIBS, CFLAGS, and CC:
-dnl
-dnl        LIBS="$PTHREAD_LIBS $LIBS"
-dnl        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
-dnl        CC="$PTHREAD_CC"
-dnl
-dnl In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute
-dnl constant has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to
-dnl that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
-dnl
-dnl ACTION-IF-FOUND is a list of shell commands to run if a threads
-dnl library is found, and ACTION-IF-NOT-FOUND is a list of commands to
-dnl run it if it is not found. If ACTION-IF-FOUND is not specified, the
-dnl default action will define HAVE_PTHREAD.
-dnl
-dnl Please let the authors know if this macro fails on any platform, or
-dnl if you have any other suggestions or comments. This macro was based
-dnl on work by SGJ on autoconf scripts for FFTW (www.fftw.org) (with
-dnl help from M. Frigo), as well as ac_pthread and hb_pthread macros
-dnl posted by Alejandro Forero Cuervo to the autoconf macro repository.
-dnl We are also grateful for the helpful feedback of numerous users.
-dnl
-dnl @category InstalledPackages
-dnl @author Steven G. Johnson <stevenj@alum.mit.edu>
-dnl @version 2006-05-29
-dnl @license GPLWithACException
-dnl 
-dnl Checks for GCC shared/pthread inconsistency based on work by
-dnl Marcin Owsiany <marcin@owsiany.pl>
-
-
-AC_DEFUN([ACX_PTHREAD], [
-AC_REQUIRE([AC_CANONICAL_HOST])
-AC_LANG_SAVE
-AC_LANG_C
-acx_pthread_ok=no
-
-# We used to check for pthread.h first, but this fails if pthread.h
-# requires special compiler flags (e.g. on True64 or Sequent).
-# It gets checked for in the link test anyway.
-
-# First of all, check if the user has set any of the PTHREAD_LIBS,
-# etcetera environment variables, and if threads linking works using
-# them:
-if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
-        save_CFLAGS="$CFLAGS"
-        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
-        save_LIBS="$LIBS"
-        LIBS="$PTHREAD_LIBS $LIBS"
-        AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
-        AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes)
-        AC_MSG_RESULT($acx_pthread_ok)
-        if test x"$acx_pthread_ok" = xno; then
-                PTHREAD_LIBS=""
-                PTHREAD_CFLAGS=""
-        fi
-        LIBS="$save_LIBS"
-        CFLAGS="$save_CFLAGS"
-fi
-
-# We must check for the threads library under a number of different
-# names; the ordering is very important because some systems
-# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
-# libraries is broken (non-POSIX).
-
-# Create a list of thread flags to try.  Items starting with a "-" are
-# C compiler flags, and other items are library names, except for "none"
-# which indicates that we try without any flags at all, and "pthread-config"
-# which is a program returning the flags for the Pth emulation library.
-
-acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
-
-# The ordering *is* (sometimes) important.  Some notes on the
-# individual items follow:
-
-# pthreads: AIX (must check this before -lpthread)
-# none: in case threads are in libc; should be tried before -Kthread and
-#       other compiler flags to prevent continual compiler warnings
-# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
-# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
-# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
-# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
-# -pthreads: Solaris/gcc
-# -mthreads: Mingw32/gcc, Lynx/gcc
-# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
-#      doesn't hurt to check since this sometimes defines pthreads too;
-#      also defines -D_REENTRANT)
-#      ... -mt is also the pthreads flag for HP/aCC
-# pthread: Linux, etcetera
-# --thread-safe: KAI C++
-# pthread-config: use pthread-config program (for GNU Pth library)
-
-case "${host_cpu}-${host_os}" in
-        *solaris*)
-
-        # On Solaris (at least, for some versions), libc contains stubbed
-        # (non-functional) versions of the pthreads routines, so link-based
-        # tests will erroneously succeed.  (We need to link with -pthreads/-mt/
-        # -lpthread.)  (The stubs are missing pthread_cleanup_push, or rather
-        # a function called by this macro, so we could check for that, but
-        # who knows whether they'll stub that too in a future libc.)  So,
-        # we'll just look for -pthreads and -lpthread first:
-
-        acx_pthread_flags="-pthreads pthread -mt -pthread $acx_pthread_flags"
-        ;;
-esac
-
-if test x"$acx_pthread_ok" = xno; then
-for flag in $acx_pthread_flags; do
-
-        case $flag in
-                none)
-                AC_MSG_CHECKING([whether pthreads work without any flags])
-                ;;
-
-                -*)
-                AC_MSG_CHECKING([whether pthreads work with $flag])
-                PTHREAD_CFLAGS="$flag"
-                ;;
-
-		pthread-config)
-		AC_CHECK_PROG(acx_pthread_config, pthread-config, yes, no)
-		if test x"$acx_pthread_config" = xno; then continue; fi
-		PTHREAD_CFLAGS="`pthread-config --cflags`"
-		PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
-		;;
-
-                *)
-                AC_MSG_CHECKING([for the pthreads library -l$flag])
-                PTHREAD_LIBS="-l$flag"
-                ;;
-        esac
-
-        save_LIBS="$LIBS"
-        save_CFLAGS="$CFLAGS"
-        LIBS="$PTHREAD_LIBS $LIBS"
-        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
-
-        # Check for various functions.  We must include pthread.h,
-        # since some functions may be macros.  (On the Sequent, we
-        # need a special flag -Kthread to make this header compile.)
-        # We check for pthread_join because it is in -lpthread on IRIX
-        # while pthread_create is in libc.  We check for pthread_attr_init
-        # due to DEC craziness with -lpthreads.  We check for
-        # pthread_cleanup_push because it is one of the few pthread
-        # functions on Solaris that doesn't have a non-functional libc stub.
-        # We try pthread_create on general principles.
-        AC_TRY_LINK([#include <pthread.h>],
-                    [pthread_t th; pthread_join(th, 0);
-                     pthread_attr_init(0); pthread_cleanup_push(0, 0);
-                     pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
-                    [acx_pthread_ok=yes])
-
-        LIBS="$save_LIBS"
-        CFLAGS="$save_CFLAGS"
-
-        AC_MSG_RESULT($acx_pthread_ok)
-        if test "x$acx_pthread_ok" = xyes; then
-                break;
-        fi
-
-        PTHREAD_LIBS=""
-        PTHREAD_CFLAGS=""
-done
-fi
-
-# Various other checks:
-if test "x$acx_pthread_ok" = xyes; then
-        save_LIBS="$LIBS"
-        LIBS="$PTHREAD_LIBS $LIBS"
-        save_CFLAGS="$CFLAGS"
-        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
-
-        # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
-	AC_MSG_CHECKING([for joinable pthread attribute])
-	attr_name=unknown
-	for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
-	    AC_TRY_LINK([#include <pthread.h>], [int attr=$attr; return attr;],
-                        [attr_name=$attr; break])
-	done
-        AC_MSG_RESULT($attr_name)
-        if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then
-            AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name,
-                               [Define to necessary symbol if this constant
-                                uses a non-standard name on your system.])
-        fi
-
-        AC_MSG_CHECKING([if more special flags are required for pthreads])
-        flag=no
-        case "${host_cpu}-${host_os}" in
-            *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";;
-            *solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";;
-        esac
-        AC_MSG_RESULT(${flag})
-        if test "x$flag" != xno; then
-            PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
-        fi
-
-        LIBS="$save_LIBS"
-        CFLAGS="$save_CFLAGS"
-        # More AIX lossage: must compile with xlc_r or cc_r
-	if test x"$GCC" != xyes; then
-          AC_CHECK_PROGS(PTHREAD_CC, xlc_r cc_r, ${CC})
-        else
-          PTHREAD_CC=$CC
-	fi
-
-	# The next part tries to detect GCC inconsistency with -shared on some
-	# architectures and systems. The problem is that in certain
-	# configurations, when -shared is specified, GCC "forgets" to
-	# internally use various flags which are still necessary.
-	
-	#
-	# Prepare the flags
-	#
-	save_CFLAGS="$CFLAGS"
-	save_LIBS="$LIBS"
-	save_CC="$CC"
-	
-	# Try with the flags determined by the earlier checks.
-	#
-	# -Wl,-z,defs forces link-time symbol resolution, so that the
-	# linking checks with -shared actually have any value
-	#
-	# FIXME: -fPIC is required for -shared on many architectures,
-	# so we specify it here, but the right way would probably be to
-	# properly detect whether it is actually required.
-	CFLAGS="-shared -fPIC -Wl,-z,defs $CFLAGS $PTHREAD_CFLAGS"
-	LIBS="$PTHREAD_LIBS $LIBS"
-	CC="$PTHREAD_CC"
-	
-	# In order not to create several levels of indentation, we test
-	# the value of "$done" until we find the cure or run out of ideas.
-	done="no"
-	
-	# First, make sure the CFLAGS we added are actually accepted by our
-	# compiler.  If not (and OS X's ld, for instance, does not accept -z),
-	# then we can't do this test.
-	if test x"$done" = xno; then
-	   AC_MSG_CHECKING([whether to check for GCC pthread/shared inconsistencies])
-	   AC_TRY_LINK(,, , [done=yes])
-	
-	   if test "x$done" = xyes ; then
-	      AC_MSG_RESULT([no])
-	   else
-	      AC_MSG_RESULT([yes])
-	   fi
-	fi
-	
-	if test x"$done" = xno; then
-	   AC_MSG_CHECKING([whether -pthread is sufficient with -shared])
-	   AC_TRY_LINK([#include <pthread.h>],
-	      [pthread_t th; pthread_join(th, 0);
-	      pthread_attr_init(0); pthread_cleanup_push(0, 0);
-	      pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
-	      [done=yes])
-	   
-	   if test "x$done" = xyes; then
-	      AC_MSG_RESULT([yes])
-	   else
-	      AC_MSG_RESULT([no])
-	   fi
-	fi
-	
-	#
-	# Linux gcc on some architectures such as mips/mipsel forgets
-	# about -lpthread
-	#
-	if test x"$done" = xno; then
-	   AC_MSG_CHECKING([whether -lpthread fixes that])
-	   LIBS="-lpthread $PTHREAD_LIBS $save_LIBS"
-	   AC_TRY_LINK([#include <pthread.h>],
-	      [pthread_t th; pthread_join(th, 0);
-	      pthread_attr_init(0); pthread_cleanup_push(0, 0);
-	      pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
-	      [done=yes])
-	
-	   if test "x$done" = xyes; then
-	      AC_MSG_RESULT([yes])
-	      PTHREAD_LIBS="-lpthread $PTHREAD_LIBS"
-	   else
-	      AC_MSG_RESULT([no])
-	   fi
-	fi
-	#
-	# FreeBSD 4.10 gcc forgets to use -lc_r instead of -lc
-	#
-	if test x"$done" = xno; then
-	   AC_MSG_CHECKING([whether -lc_r fixes that])
-	   LIBS="-lc_r $PTHREAD_LIBS $save_LIBS"
-	   AC_TRY_LINK([#include <pthread.h>],
-	       [pthread_t th; pthread_join(th, 0);
-	        pthread_attr_init(0); pthread_cleanup_push(0, 0);
-	        pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
-	       [done=yes])
-	
-	   if test "x$done" = xyes; then
-	      AC_MSG_RESULT([yes])
-	      PTHREAD_LIBS="-lc_r $PTHREAD_LIBS"
-	   else
-	      AC_MSG_RESULT([no])
-	   fi
-	fi
-	if test x"$done" = xno; then
-	   # OK, we have run out of ideas
-	   AC_MSG_WARN([Impossible to determine how to use pthreads with shared libraries])
-	
-	   # so it's not safe to assume that we may use pthreads
-	   acx_pthread_ok=no
-	fi
-	
-	CFLAGS="$save_CFLAGS"
-	LIBS="$save_LIBS"
-	CC="$save_CC"
-else
-        PTHREAD_CC="$CC"
-fi
-
-AC_SUBST(PTHREAD_LIBS)
-AC_SUBST(PTHREAD_CFLAGS)
-AC_SUBST(PTHREAD_CC)
-
-# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
-if test x"$acx_pthread_ok" = xyes; then
-        ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
-        :
-else
-        acx_pthread_ok=no
-        $2
-fi
-AC_LANG_RESTORE
-])dnl ACX_PTHREAD
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/m4/gtest.m4 b/week4/softwareEng_9_4/vendor/googletest/googletest/m4/gtest.m4
deleted file mode 100644
index 6598ba75..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/m4/gtest.m4
+++ /dev/null
@@ -1,74 +0,0 @@
-dnl GTEST_LIB_CHECK([minimum version [,
-dnl                  action if found [,action if not found]]])
-dnl
-dnl Check for the presence of the Google Test library, optionally at a minimum
-dnl version, and indicate a viable version with the HAVE_GTEST flag. It defines
-dnl standard variables for substitution including GTEST_CPPFLAGS,
-dnl GTEST_CXXFLAGS, GTEST_LDFLAGS, and GTEST_LIBS. It also defines
-dnl GTEST_VERSION as the version of Google Test found. Finally, it provides
-dnl optional custom action slots in the event GTEST is found or not.
-AC_DEFUN([GTEST_LIB_CHECK],
-[
-dnl Provide a flag to enable or disable Google Test usage.
-AC_ARG_ENABLE([gtest],
-  [AS_HELP_STRING([--enable-gtest],
-                  [Enable tests using the Google C++ Testing Framework.
-                  (Default is enabled.)])],
-  [],
-  [enable_gtest=])
-AC_ARG_VAR([GTEST_CONFIG],
-           [The exact path of Google Test's 'gtest-config' script.])
-AC_ARG_VAR([GTEST_CPPFLAGS],
-           [C-like preprocessor flags for Google Test.])
-AC_ARG_VAR([GTEST_CXXFLAGS],
-           [C++ compile flags for Google Test.])
-AC_ARG_VAR([GTEST_LDFLAGS],
-           [Linker path and option flags for Google Test.])
-AC_ARG_VAR([GTEST_LIBS],
-           [Library linking flags for Google Test.])
-AC_ARG_VAR([GTEST_VERSION],
-           [The version of Google Test available.])
-HAVE_GTEST="no"
-AS_IF([test "x${enable_gtest}" != "xno"],
-  [AC_MSG_CHECKING([for 'gtest-config'])
-   AS_IF([test "x${enable_gtest}" != "xyes"],
-     [AS_IF([test -x "${enable_gtest}/scripts/gtest-config"],
-        [GTEST_CONFIG="${enable_gtest}/scripts/gtest-config"],
-        [GTEST_CONFIG="${enable_gtest}/bin/gtest-config"])
-      AS_IF([test -x "${GTEST_CONFIG}"], [],
-        [AC_MSG_RESULT([no])
-         AC_MSG_ERROR([dnl
-Unable to locate either a built or installed Google Test.
-The specific location '${enable_gtest}' was provided for a built or installed
-Google Test, but no 'gtest-config' script could be found at this location.])
-         ])],
-     [AC_PATH_PROG([GTEST_CONFIG], [gtest-config])])
-   AS_IF([test -x "${GTEST_CONFIG}"],
-     [AC_MSG_RESULT([${GTEST_CONFIG}])
-      m4_ifval([$1],
-        [_gtest_min_version="--min-version=$1"
-         AC_MSG_CHECKING([for Google Test at least version >= $1])],
-        [_gtest_min_version="--min-version=0"
-         AC_MSG_CHECKING([for Google Test])])
-      AS_IF([${GTEST_CONFIG} ${_gtest_min_version}],
-        [AC_MSG_RESULT([yes])
-         HAVE_GTEST='yes'],
-        [AC_MSG_RESULT([no])])],
-     [AC_MSG_RESULT([no])])
-   AS_IF([test "x${HAVE_GTEST}" = "xyes"],
-     [GTEST_CPPFLAGS=`${GTEST_CONFIG} --cppflags`
-      GTEST_CXXFLAGS=`${GTEST_CONFIG} --cxxflags`
-      GTEST_LDFLAGS=`${GTEST_CONFIG} --ldflags`
-      GTEST_LIBS=`${GTEST_CONFIG} --libs`
-      GTEST_VERSION=`${GTEST_CONFIG} --version`
-      AC_DEFINE([HAVE_GTEST],[1],[Defined when Google Test is available.])],
-     [AS_IF([test "x${enable_gtest}" = "xyes"],
-        [AC_MSG_ERROR([dnl
-Google Test was enabled, but no viable version could be found.])
-         ])])])
-AC_SUBST([HAVE_GTEST])
-AM_CONDITIONAL([HAVE_GTEST],[test "x$HAVE_GTEST" = "xyes"])
-AS_IF([test "x$HAVE_GTEST" = "xyes"],
-  [m4_ifval([$2], [$2])],
-  [m4_ifval([$3], [$3])])
-])
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/make/Makefile b/week4/softwareEng_9_4/vendor/googletest/googletest/make/Makefile
deleted file mode 100644
index 9ac74493..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/make/Makefile
+++ /dev/null
@@ -1,82 +0,0 @@
-# A sample Makefile for building Google Test and using it in user
-# tests.  Please tweak it to suit your environment and project.  You
-# may want to move it to your project's root directory.
-#
-# SYNOPSIS:
-#
-#   make [all]  - makes everything.
-#   make TARGET - makes the given target.
-#   make clean  - removes all files generated by make.
-
-# Please tweak the following variable definitions as needed by your
-# project, except GTEST_HEADERS, which you can use in your own targets
-# but shouldn't modify.
-
-# Points to the root of Google Test, relative to where this file is.
-# Remember to tweak this if you move this file.
-GTEST_DIR = ..
-
-# Where to find user code.
-USER_DIR = ../samples
-
-# Flags passed to the preprocessor.
-# Set Google Test's header directory as a system directory, such that
-# the compiler doesn't generate warnings in Google Test headers.
-CPPFLAGS += -isystem $(GTEST_DIR)/include
-
-# Flags passed to the C++ compiler.
-CXXFLAGS += -g -Wall -Wextra -pthread
-
-# All tests produced by this Makefile.  Remember to add new tests you
-# created to the list.
-TESTS = sample1_unittest
-
-# All Google Test headers.  Usually you shouldn't change this
-# definition.
-GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
-                $(GTEST_DIR)/include/gtest/internal/*.h
-
-# House-keeping build targets.
-
-all : $(TESTS)
-
-clean :
-	rm -f $(TESTS) gtest.a gtest_main.a *.o
-
-# Builds gtest.a and gtest_main.a.
-
-# Usually you shouldn't tweak such internal variables, indicated by a
-# trailing _.
-GTEST_SRCS_ = $(GTEST_DIR)/src/*.cc $(GTEST_DIR)/src/*.h $(GTEST_HEADERS)
-
-# For simplicity and to avoid depending on Google Test's
-# implementation details, the dependencies specified below are
-# conservative and not optimized.  This is fine as Google Test
-# compiles fast and for ordinary users its source rarely changes.
-gtest-all.o : $(GTEST_SRCS_)
-	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
-            $(GTEST_DIR)/src/gtest-all.cc
-
-gtest_main.o : $(GTEST_SRCS_)
-	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
-            $(GTEST_DIR)/src/gtest_main.cc
-
-gtest.a : gtest-all.o
-	$(AR) $(ARFLAGS) $@ $^
-
-gtest_main.a : gtest-all.o gtest_main.o
-	$(AR) $(ARFLAGS) $@ $^
-
-# Builds a sample test.  A test should link with either gtest.a or
-# gtest_main.a, depending on whether it defines its own main()
-# function.
-
-sample1.o : $(USER_DIR)/sample1.cc $(USER_DIR)/sample1.h $(GTEST_HEADERS)
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/sample1.cc
-
-sample1_unittest.o : $(USER_DIR)/sample1_unittest.cc \
-                     $(USER_DIR)/sample1.h $(GTEST_HEADERS)
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/sample1_unittest.cc
-
-sample1_unittest : sample1.o sample1_unittest.o gtest_main.a
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.sln b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.sln
deleted file mode 100644
index f7908da1..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.sln
+++ /dev/null
@@ -1,45 +0,0 @@
-Microsoft Visual Studio Solution File, Format Version 8.00
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest-md", "gtest-md.vcproj", "{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}"
-	ProjectSection(ProjectDependencies) = postProject
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_main-md", "gtest_main-md.vcproj", "{3AF54C8A-10BF-4332-9147-F68ED9862033}"
-	ProjectSection(ProjectDependencies) = postProject
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_prod_test-md", "gtest_prod_test-md.vcproj", "{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}"
-	ProjectSection(ProjectDependencies) = postProject
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_unittest-md", "gtest_unittest-md.vcproj", "{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}"
-	ProjectSection(ProjectDependencies) = postProject
-	EndProjectSection
-EndProject
-Global
-	GlobalSection(SolutionConfiguration) = preSolution
-		Debug = Debug
-		Release = Release
-	EndGlobalSection
-	GlobalSection(ProjectConfiguration) = postSolution
-		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Debug.ActiveCfg = Debug|Win32
-		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Debug.Build.0 = Debug|Win32
-		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Release.ActiveCfg = Release|Win32
-		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}.Release.Build.0 = Release|Win32
-		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Debug.ActiveCfg = Debug|Win32
-		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Debug.Build.0 = Debug|Win32
-		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Release.ActiveCfg = Release|Win32
-		{3AF54C8A-10BF-4332-9147-F68ED9862033}.Release.Build.0 = Release|Win32
-		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}.Debug.ActiveCfg = Debug|Win32
-		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}.Debug.Build.0 = Debug|Win32
-		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}.Release.ActiveCfg = Release|Win32
-		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}.Release.Build.0 = Release|Win32
-		{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}.Debug.ActiveCfg = Debug|Win32
-		{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}.Debug.Build.0 = Debug|Win32
-		{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}.Release.ActiveCfg = Release|Win32
-		{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}.Release.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-	EndGlobalSection
-	GlobalSection(ExtensibilityAddIns) = postSolution
-	EndGlobalSection
-EndGlobal
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.vcproj
deleted file mode 100644
index 1c35c3a5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest-md.vcproj
+++ /dev/null
@@ -1,126 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="7.10"
-	Name="gtest-md"
-	ProjectGUID="{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}"
-	Keyword="Win32Proj">
-	<Platforms>
-		<Platform
-			Name="Win32"/>
-	</Platforms>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="4"
-			CharacterSet="2"
-			ReferencesPath="">
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
-				MinimalRebuild="TRUE"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="4"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="$(OutDir)/gtestd.lib"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="4"
-			CharacterSet="2"
-			ReferencesPath="&quot;..\include&quot;;&quot;..&quot;">
-			<Tool
-				Name="VCCLCompilerTool"
-				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
-				RuntimeLibrary="2"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="3"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="$(OutDir)/gtest.lib"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
-			<File
-				RelativePath="..\src\gtest-all.cc">
-				<FileConfiguration
-					Name="Debug|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
-				</FileConfiguration>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.sln b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.sln
deleted file mode 100644
index ef4b057f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.sln
+++ /dev/null
@@ -1,45 +0,0 @@
-Microsoft Visual Studio Solution File, Format Version 8.00
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest", "gtest.vcproj", "{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}"
-	ProjectSection(ProjectDependencies) = postProject
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_main", "gtest_main.vcproj", "{3AF54C8A-10BF-4332-9147-F68ED9862032}"
-	ProjectSection(ProjectDependencies) = postProject
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_unittest", "gtest_unittest.vcproj", "{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}"
-	ProjectSection(ProjectDependencies) = postProject
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gtest_prod_test", "gtest_prod_test.vcproj", "{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}"
-	ProjectSection(ProjectDependencies) = postProject
-	EndProjectSection
-EndProject
-Global
-	GlobalSection(SolutionConfiguration) = preSolution
-		Debug = Debug
-		Release = Release
-	EndGlobalSection
-	GlobalSection(ProjectConfiguration) = postSolution
-		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}.Debug.ActiveCfg = Debug|Win32
-		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}.Debug.Build.0 = Debug|Win32
-		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}.Release.ActiveCfg = Release|Win32
-		{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}.Release.Build.0 = Release|Win32
-		{3AF54C8A-10BF-4332-9147-F68ED9862032}.Debug.ActiveCfg = Debug|Win32
-		{3AF54C8A-10BF-4332-9147-F68ED9862032}.Debug.Build.0 = Debug|Win32
-		{3AF54C8A-10BF-4332-9147-F68ED9862032}.Release.ActiveCfg = Release|Win32
-		{3AF54C8A-10BF-4332-9147-F68ED9862032}.Release.Build.0 = Release|Win32
-		{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}.Debug.ActiveCfg = Debug|Win32
-		{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}.Debug.Build.0 = Debug|Win32
-		{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}.Release.ActiveCfg = Release|Win32
-		{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}.Release.Build.0 = Release|Win32
-		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}.Debug.ActiveCfg = Debug|Win32
-		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}.Debug.Build.0 = Debug|Win32
-		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}.Release.ActiveCfg = Release|Win32
-		{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}.Release.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-	EndGlobalSection
-	GlobalSection(ExtensibilityAddIns) = postSolution
-	EndGlobalSection
-EndGlobal
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.vcproj
deleted file mode 100644
index a8373ce9..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest.vcproj
+++ /dev/null
@@ -1,126 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="7.10"
-	Name="gtest"
-	ProjectGUID="{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}"
-	Keyword="Win32Proj">
-	<Platforms>
-		<Platform
-			Name="Win32"/>
-	</Platforms>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="4"
-			CharacterSet="2"
-			ReferencesPath="">
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
-				MinimalRebuild="TRUE"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="5"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="4"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="$(OutDir)/gtestd.lib"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="4"
-			CharacterSet="2"
-			ReferencesPath="&quot;..\include&quot;;&quot;..&quot;">
-			<Tool
-				Name="VCCLCompilerTool"
-				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
-				RuntimeLibrary="4"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="3"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="$(OutDir)/gtest.lib"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
-			<File
-				RelativePath="..\src\gtest-all.cc">
-				<FileConfiguration
-					Name="Debug|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
-				</FileConfiguration>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main-md.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main-md.vcproj
deleted file mode 100644
index b5379fe6..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main-md.vcproj
+++ /dev/null
@@ -1,129 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="7.10"
-	Name="gtest_main-md"
-	ProjectGUID="{3AF54C8A-10BF-4332-9147-F68ED9862033}"
-	Keyword="Win32Proj">
-	<Platforms>
-		<Platform
-			Name="Win32"/>
-	</Platforms>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="4"
-			CharacterSet="2"
-			ReferencesPath="">
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
-				MinimalRebuild="TRUE"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="4"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="$(OutDir)/$(ProjectName)d.lib"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="4"
-			CharacterSet="2"
-			ReferencesPath="&quot;..\include&quot;;&quot;..&quot;">
-			<Tool
-				Name="VCCLCompilerTool"
-				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
-				RuntimeLibrary="2"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="3"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="$(OutDir)/$(ProjectName).lib"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-	</Configurations>
-	<References>
-		<ProjectReference
-			ReferencedProjectIdentifier="{C8F6C172-56F2-4E76-B5FA-C3B423B31BE8}"
-			Name="gtest-md"/>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
-			<File
-				RelativePath="..\src\gtest_main.cc">
-				<FileConfiguration
-					Name="Debug|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
-				</FileConfiguration>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main.vcproj
deleted file mode 100644
index e8b763c5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_main.vcproj
+++ /dev/null
@@ -1,129 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="7.10"
-	Name="gtest_main"
-	ProjectGUID="{3AF54C8A-10BF-4332-9147-F68ED9862032}"
-	Keyword="Win32Proj">
-	<Platforms>
-		<Platform
-			Name="Win32"/>
-	</Platforms>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="4"
-			CharacterSet="2"
-			ReferencesPath="">
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
-				MinimalRebuild="TRUE"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="5"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="4"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="$(OutDir)/$(ProjectName)d.lib"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="4"
-			CharacterSet="2"
-			ReferencesPath="&quot;..\include&quot;;&quot;..&quot;">
-			<Tool
-				Name="VCCLCompilerTool"
-				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
-				RuntimeLibrary="4"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="3"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="$(OutDir)/$(ProjectName).lib"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-	</Configurations>
-	<References>
-		<ProjectReference
-			ReferencedProjectIdentifier="{C8F6C172-56F2-4E76-B5FA-C3B423B31BE7}"
-			Name="gtest"/>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
-			<File
-				RelativePath="..\src\gtest_main.cc">
-				<FileConfiguration
-					Name="Debug|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"/>
-				</FileConfiguration>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test-md.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test-md.vcproj
deleted file mode 100644
index 05b05d9e..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test-md.vcproj
+++ /dev/null
@@ -1,164 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="7.10"
-	Name="gtest_prod_test-md"
-	ProjectGUID="{24848551-EF4F-47E8-9A9D-EA4D49BC3ECB}"
-	Keyword="Win32Proj">
-	<Platforms>
-		<Platform
-			Name="Win32"/>
-	</Platforms>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="1"
-			CharacterSet="2">
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
-				MinimalRebuild="TRUE"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				UsePrecompiledHeader="3"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="4"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLinkerTool"
-				OutputFile="$(OutDir)/gtest_prod_test.exe"
-				LinkIncremental="2"
-				GenerateDebugInformation="TRUE"
-				ProgramDatabaseFile="$(OutDir)/gtest_prod_test.pdb"
-				SubSystem="1"
-				TargetMachine="1"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCWebDeploymentTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="1"
-			CharacterSet="2">
-			<Tool
-				Name="VCCLCompilerTool"
-				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
-				RuntimeLibrary="2"
-				UsePrecompiledHeader="3"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="3"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLinkerTool"
-				OutputFile="$(OutDir)/gtest_prod_test.exe"
-				LinkIncremental="1"
-				GenerateDebugInformation="TRUE"
-				SubSystem="1"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCWebDeploymentTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-	</Configurations>
-	<References>
-		<ProjectReference
-			ReferencedProjectIdentifier="{3AF54C8A-10BF-4332-9147-F68ED9862033}"
-			Name="gtest_main-md"/>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
-			<File
-				RelativePath="..\test\gtest_prod_test.cc">
-				<FileConfiguration
-					Name="Debug|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
-						UsePrecompiledHeader="0"/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
-						UsePrecompiledHeader="0"/>
-				</FileConfiguration>
-			</File>
-			<File
-				RelativePath="..\test\production.cc">
-				<FileConfiguration
-					Name="Debug|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
-						UsePrecompiledHeader="0"/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
-						UsePrecompiledHeader="0"/>
-				</FileConfiguration>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
-			<File
-				RelativePath="..\test\production.h">
-			</File>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test.vcproj
deleted file mode 100644
index 6d7a2f02..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_prod_test.vcproj
+++ /dev/null
@@ -1,164 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="7.10"
-	Name="gtest_prod_test"
-	ProjectGUID="{24848551-EF4F-47E8-9A9D-EA4D49BC3ECA}"
-	Keyword="Win32Proj">
-	<Platforms>
-		<Platform
-			Name="Win32"/>
-	</Platforms>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="1"
-			CharacterSet="2">
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
-				MinimalRebuild="TRUE"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="5"
-				UsePrecompiledHeader="3"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="4"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLinkerTool"
-				OutputFile="$(OutDir)/gtest_prod_test.exe"
-				LinkIncremental="2"
-				GenerateDebugInformation="TRUE"
-				ProgramDatabaseFile="$(OutDir)/gtest_prod_test.pdb"
-				SubSystem="1"
-				TargetMachine="1"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCWebDeploymentTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="1"
-			CharacterSet="2">
-			<Tool
-				Name="VCCLCompilerTool"
-				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
-				RuntimeLibrary="4"
-				UsePrecompiledHeader="3"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="3"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLinkerTool"
-				OutputFile="$(OutDir)/gtest_prod_test.exe"
-				LinkIncremental="1"
-				GenerateDebugInformation="TRUE"
-				SubSystem="1"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCWebDeploymentTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-	</Configurations>
-	<References>
-		<ProjectReference
-			ReferencedProjectIdentifier="{3AF54C8A-10BF-4332-9147-F68ED9862032}"
-			Name="gtest_main"/>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
-			<File
-				RelativePath="..\test\gtest_prod_test.cc">
-				<FileConfiguration
-					Name="Debug|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
-						UsePrecompiledHeader="0"/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
-						UsePrecompiledHeader="0"/>
-				</FileConfiguration>
-			</File>
-			<File
-				RelativePath="..\test\production.cc">
-				<FileConfiguration
-					Name="Debug|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
-						UsePrecompiledHeader="0"/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
-						UsePrecompiledHeader="0"/>
-				</FileConfiguration>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
-			<File
-				RelativePath="..\test\production.h">
-			</File>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest-md.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest-md.vcproj
deleted file mode 100644
index 38a5e566..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest-md.vcproj
+++ /dev/null
@@ -1,147 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="7.10"
-	Name="gtest_unittest-md"
-	ProjectGUID="{4D9FDFB5-986A-4139-823C-F4EE0ED481A2}"
-	Keyword="Win32Proj">
-	<Platforms>
-		<Platform
-			Name="Win32"/>
-	</Platforms>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="1"
-			CharacterSet="2">
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
-				MinimalRebuild="TRUE"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				UsePrecompiledHeader="3"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="4"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLinkerTool"
-				OutputFile="$(OutDir)/gtest_unittest.exe"
-				LinkIncremental="2"
-				GenerateDebugInformation="TRUE"
-				ProgramDatabaseFile="$(OutDir)/gtest_unittest.pdb"
-				SubSystem="1"
-				TargetMachine="1"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCWebDeploymentTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="1"
-			CharacterSet="2">
-			<Tool
-				Name="VCCLCompilerTool"
-				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
-				RuntimeLibrary="2"
-				UsePrecompiledHeader="3"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="3"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLinkerTool"
-				OutputFile="$(OutDir)/gtest_unittest.exe"
-				LinkIncremental="1"
-				GenerateDebugInformation="TRUE"
-				SubSystem="1"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCWebDeploymentTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-	</Configurations>
-	<References>
-		<ProjectReference
-			ReferencedProjectIdentifier="{3AF54C8A-10BF-4332-9147-F68ED9862033}"
-			Name="gtest_main-md"/>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
-			<File
-				RelativePath="..\test\gtest_unittest.cc">
-				<FileConfiguration
-					Name="Debug|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						Optimization="1"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
-						BasicRuntimeChecks="0"
-						UsePrecompiledHeader="0"
-						DebugInformationFormat="3"/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
-						UsePrecompiledHeader="0"/>
-				</FileConfiguration>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest.vcproj b/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest.vcproj
deleted file mode 100644
index cb1f52b1..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/msvc/gtest_unittest.vcproj
+++ /dev/null
@@ -1,147 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="7.10"
-	Name="gtest_unittest"
-	ProjectGUID="{4D9FDFB5-986A-4139-823C-F4EE0ED481A1}"
-	Keyword="Win32Proj">
-	<Platforms>
-		<Platform
-			Name="Win32"/>
-	</Platforms>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="1"
-			CharacterSet="2">
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
-				MinimalRebuild="TRUE"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="5"
-				UsePrecompiledHeader="3"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="4"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLinkerTool"
-				OutputFile="$(OutDir)/gtest_unittest.exe"
-				LinkIncremental="2"
-				GenerateDebugInformation="TRUE"
-				ProgramDatabaseFile="$(OutDir)/gtest_unittest.pdb"
-				SubSystem="1"
-				TargetMachine="1"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCWebDeploymentTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionName)/$(ConfigurationName)"
-			IntermediateDirectory="$(OutDir)/$(ProjectName)"
-			ConfigurationType="1"
-			CharacterSet="2">
-			<Tool
-				Name="VCCLCompilerTool"
-				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
-				RuntimeLibrary="4"
-				UsePrecompiledHeader="3"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="FALSE"
-				DebugInformationFormat="3"/>
-			<Tool
-				Name="VCCustomBuildTool"/>
-			<Tool
-				Name="VCLinkerTool"
-				OutputFile="$(OutDir)/gtest_unittest.exe"
-				LinkIncremental="1"
-				GenerateDebugInformation="TRUE"
-				SubSystem="1"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"/>
-			<Tool
-				Name="VCMIDLTool"/>
-			<Tool
-				Name="VCPostBuildEventTool"/>
-			<Tool
-				Name="VCPreBuildEventTool"/>
-			<Tool
-				Name="VCPreLinkEventTool"/>
-			<Tool
-				Name="VCResourceCompilerTool"/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"/>
-			<Tool
-				Name="VCWebDeploymentTool"/>
-			<Tool
-				Name="VCManagedWrapperGeneratorTool"/>
-			<Tool
-				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
-		</Configuration>
-	</Configurations>
-	<References>
-		<ProjectReference
-			ReferencedProjectIdentifier="{3AF54C8A-10BF-4332-9147-F68ED9862032}"
-			Name="gtest_main"/>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
-			<File
-				RelativePath="..\test\gtest_unittest.cc">
-				<FileConfiguration
-					Name="Debug|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						Optimization="1"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
-						BasicRuntimeChecks="0"
-						UsePrecompiledHeader="0"
-						DebugInformationFormat="3"/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32">
-					<Tool
-						Name="VCCLCompilerTool"
-						AdditionalIncludeDirectories="&quot;..&quot;;&quot;..\include&quot;"
-						UsePrecompiledHeader="0"/>
-				</FileConfiguration>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/prime_tables.h b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/prime_tables.h
deleted file mode 100644
index 92ce16a0..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/prime_tables.h
+++ /dev/null
@@ -1,123 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-// Author: vladl@google.com (Vlad Losev)
-
-// This provides interface PrimeTable that determines whether a number is a
-// prime and determines a next prime number. This interface is used
-// in Google Test samples demonstrating use of parameterized tests.
-
-#ifndef GTEST_SAMPLES_PRIME_TABLES_H_
-#define GTEST_SAMPLES_PRIME_TABLES_H_
-
-#include <algorithm>
-
-// The prime table interface.
-class PrimeTable {
- public:
-  virtual ~PrimeTable() {}
-
-  // Returns true iff n is a prime number.
-  virtual bool IsPrime(int n) const = 0;
-
-  // Returns the smallest prime number greater than p; or returns -1
-  // if the next prime is beyond the capacity of the table.
-  virtual int GetNextPrime(int p) const = 0;
-};
-
-// Implementation #1 calculates the primes on-the-fly.
-class OnTheFlyPrimeTable : public PrimeTable {
- public:
-  virtual bool IsPrime(int n) const {
-    if (n <= 1) return false;
-
-    for (int i = 2; i*i <= n; i++) {
-      // n is divisible by an integer other than 1 and itself.
-      if ((n % i) == 0) return false;
-    }
-
-    return true;
-  }
-
-  virtual int GetNextPrime(int p) const {
-    for (int n = p + 1; n > 0; n++) {
-      if (IsPrime(n)) return n;
-    }
-
-    return -1;
-  }
-};
-
-// Implementation #2 pre-calculates the primes and stores the result
-// in an array.
-class PreCalculatedPrimeTable : public PrimeTable {
- public:
-  // 'max' specifies the maximum number the prime table holds.
-  explicit PreCalculatedPrimeTable(int max)
-      : is_prime_size_(max + 1), is_prime_(new bool[max + 1]) {
-    CalculatePrimesUpTo(max);
-  }
-  virtual ~PreCalculatedPrimeTable() { delete[] is_prime_; }
-
-  virtual bool IsPrime(int n) const {
-    return 0 <= n && n < is_prime_size_ && is_prime_[n];
-  }
-
-  virtual int GetNextPrime(int p) const {
-    for (int n = p + 1; n < is_prime_size_; n++) {
-      if (is_prime_[n]) return n;
-    }
-
-    return -1;
-  }
-
- private:
-  void CalculatePrimesUpTo(int max) {
-    ::std::fill(is_prime_, is_prime_ + is_prime_size_, true);
-    is_prime_[0] = is_prime_[1] = false;
-
-    for (int i = 2; i <= max; i++) {
-      if (!is_prime_[i]) continue;
-
-      // Marks all multiples of i (except i itself) as non-prime.
-      for (int j = 2*i; j <= max; j += i) {
-        is_prime_[j] = false;
-      }
-    }
-  }
-
-  const int is_prime_size_;
-  bool* const is_prime_;
-
-  // Disables compiler warning "assignment operator could not be generated."
-  void operator=(const PreCalculatedPrimeTable& rhs);
-};
-
-#endif  // GTEST_SAMPLES_PRIME_TABLES_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.cc
deleted file mode 100644
index f171e260..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.cc
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// A sample program demonstrating using Google C++ testing framework.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "sample1.h"
-
-// Returns n! (the factorial of n).  For negative n, n! is defined to be 1.
-int Factorial(int n) {
-  int result = 1;
-  for (int i = 1; i <= n; i++) {
-    result *= i;
-  }
-
-  return result;
-}
-
-// Returns true iff n is a prime number.
-bool IsPrime(int n) {
-  // Trivial case 1: small numbers
-  if (n <= 1) return false;
-
-  // Trivial case 2: even numbers
-  if (n % 2 == 0) return n == 2;
-
-  // Now, we have that n is odd and n >= 3.
-
-  // Try to divide n by every odd number i, starting from 3
-  for (int i = 3; ; i += 2) {
-    // We only have to try i up to the squre root of n
-    if (i > n/i) break;
-
-    // Now, we have i <= n/i < n.
-    // If n is divisible by i, n is not prime.
-    if (n % i == 0) return false;
-  }
-
-  // n has no integer factor in the range (1, n), and thus is prime.
-  return true;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.h b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.h
deleted file mode 100644
index 3dfeb98c..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// A sample program demonstrating using Google C++ testing framework.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#ifndef GTEST_SAMPLES_SAMPLE1_H_
-#define GTEST_SAMPLES_SAMPLE1_H_
-
-// Returns n! (the factorial of n).  For negative n, n! is defined to be 1.
-int Factorial(int n);
-
-// Returns true iff n is a prime number.
-bool IsPrime(int n);
-
-#endif  // GTEST_SAMPLES_SAMPLE1_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample10_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample10_unittest.cc
deleted file mode 100644
index 0051cd5d..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample10_unittest.cc
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright 2009 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-
-// This sample shows how to use Google Test listener API to implement
-// a primitive leak checker.
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "gtest/gtest.h"
-
-using ::testing::EmptyTestEventListener;
-using ::testing::InitGoogleTest;
-using ::testing::Test;
-using ::testing::TestCase;
-using ::testing::TestEventListeners;
-using ::testing::TestInfo;
-using ::testing::TestPartResult;
-using ::testing::UnitTest;
-
-namespace {
-
-// We will track memory used by this class.
-class Water {
- public:
-  // Normal Water declarations go here.
-
-  // operator new and operator delete help us control water allocation.
-  void* operator new(size_t allocation_size) {
-    allocated_++;
-    return malloc(allocation_size);
-  }
-
-  void operator delete(void* block, size_t /* allocation_size */) {
-    allocated_--;
-    free(block);
-  }
-
-  static int allocated() { return allocated_; }
-
- private:
-  static int allocated_;
-};
-
-int Water::allocated_ = 0;
-
-// This event listener monitors how many Water objects are created and
-// destroyed by each test, and reports a failure if a test leaks some Water
-// objects. It does this by comparing the number of live Water objects at
-// the beginning of a test and at the end of a test.
-class LeakChecker : public EmptyTestEventListener {
- private:
-  // Called before a test starts.
-  virtual void OnTestStart(const TestInfo& /* test_info */) {
-    initially_allocated_ = Water::allocated();
-  }
-
-  // Called after a test ends.
-  virtual void OnTestEnd(const TestInfo& /* test_info */) {
-    int difference = Water::allocated() - initially_allocated_;
-
-    // You can generate a failure in any event handler except
-    // OnTestPartResult. Just use an appropriate Google Test assertion to do
-    // it.
-    EXPECT_LE(difference, 0) << "Leaked " << difference << " unit(s) of Water!";
-  }
-
-  int initially_allocated_;
-};
-
-TEST(ListenersTest, DoesNotLeak) {
-  Water* water = new Water;
-  delete water;
-}
-
-// This should fail when the --check_for_leaks command line flag is
-// specified.
-TEST(ListenersTest, LeaksWater) {
-  Water* water = new Water;
-  EXPECT_TRUE(water != NULL);
-}
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  InitGoogleTest(&argc, argv);
-
-  bool check_for_leaks = false;
-  if (argc > 1 && strcmp(argv[1], "--check_for_leaks") == 0 )
-    check_for_leaks = true;
-  else
-    printf("%s\n", "Run this program with --check_for_leaks to enable "
-           "custom leak checking in the tests.");
-
-  // If we are given the --check_for_leaks command line flag, installs the
-  // leak checker.
-  if (check_for_leaks) {
-    TestEventListeners& listeners = UnitTest::GetInstance()->listeners();
-
-    // Adds the leak checker to the end of the test event listener list,
-    // after the default text output printer and the default XML report
-    // generator.
-    //
-    // The order is important - it ensures that failures generated in the
-    // leak checker's OnTestEnd() method are processed by the text and XML
-    // printers *before* their OnTestEnd() methods are called, such that
-    // they are attributed to the right test. Remember that a listener
-    // receives an OnXyzStart event *after* listeners preceding it in the
-    // list received that event, and receives an OnXyzEnd event *before*
-    // listeners preceding it.
-    //
-    // We don't need to worry about deleting the new listener later, as
-    // Google Test will do it.
-    listeners.Append(new LeakChecker);
-  }
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1_unittest.cc
deleted file mode 100644
index aefc4f1d..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample1_unittest.cc
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// A sample program demonstrating using Google C++ testing framework.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-
-// This sample shows how to write a simple unit test for a function,
-// using Google C++ testing framework.
-//
-// Writing a unit test using Google C++ testing framework is easy as 1-2-3:
-
-
-// Step 1. Include necessary header files such that the stuff your
-// test logic needs is declared.
-//
-// Don't forget gtest.h, which declares the testing framework.
-
-#include <limits.h>
-#include "sample1.h"
-#include "gtest/gtest.h"
-
-
-// Step 2. Use the TEST macro to define your tests.
-//
-// TEST has two parameters: the test case name and the test name.
-// After using the macro, you should define your test logic between a
-// pair of braces.  You can use a bunch of macros to indicate the
-// success or failure of a test.  EXPECT_TRUE and EXPECT_EQ are
-// examples of such macros.  For a complete list, see gtest.h.
-//
-// <TechnicalDetails>
-//
-// In Google Test, tests are grouped into test cases.  This is how we
-// keep test code organized.  You should put logically related tests
-// into the same test case.
-//
-// The test case name and the test name should both be valid C++
-// identifiers.  And you should not use underscore (_) in the names.
-//
-// Google Test guarantees that each test you define is run exactly
-// once, but it makes no guarantee on the order the tests are
-// executed.  Therefore, you should write your tests in such a way
-// that their results don't depend on their order.
-//
-// </TechnicalDetails>
-
-
-// Tests Factorial().
-
-// Tests factorial of negative numbers.
-TEST(FactorialTest, Negative) {
-  // This test is named "Negative", and belongs to the "FactorialTest"
-  // test case.
-  EXPECT_EQ(1, Factorial(-5));
-  EXPECT_EQ(1, Factorial(-1));
-  EXPECT_GT(Factorial(-10), 0);
-
-  // <TechnicalDetails>
-  //
-  // EXPECT_EQ(expected, actual) is the same as
-  //
-  //   EXPECT_TRUE((expected) == (actual))
-  //
-  // except that it will print both the expected value and the actual
-  // value when the assertion fails.  This is very helpful for
-  // debugging.  Therefore in this case EXPECT_EQ is preferred.
-  //
-  // On the other hand, EXPECT_TRUE accepts any Boolean expression,
-  // and is thus more general.
-  //
-  // </TechnicalDetails>
-}
-
-// Tests factorial of 0.
-TEST(FactorialTest, Zero) {
-  EXPECT_EQ(1, Factorial(0));
-}
-
-// Tests factorial of positive numbers.
-TEST(FactorialTest, Positive) {
-  EXPECT_EQ(1, Factorial(1));
-  EXPECT_EQ(2, Factorial(2));
-  EXPECT_EQ(6, Factorial(3));
-  EXPECT_EQ(40320, Factorial(8));
-}
-
-
-// Tests IsPrime()
-
-// Tests negative input.
-TEST(IsPrimeTest, Negative) {
-  // This test belongs to the IsPrimeTest test case.
-
-  EXPECT_FALSE(IsPrime(-1));
-  EXPECT_FALSE(IsPrime(-2));
-  EXPECT_FALSE(IsPrime(INT_MIN));
-}
-
-// Tests some trivial cases.
-TEST(IsPrimeTest, Trivial) {
-  EXPECT_FALSE(IsPrime(0));
-  EXPECT_FALSE(IsPrime(1));
-  EXPECT_TRUE(IsPrime(2));
-  EXPECT_TRUE(IsPrime(3));
-}
-
-// Tests positive input.
-TEST(IsPrimeTest, Positive) {
-  EXPECT_FALSE(IsPrime(4));
-  EXPECT_TRUE(IsPrime(5));
-  EXPECT_FALSE(IsPrime(6));
-  EXPECT_TRUE(IsPrime(23));
-}
-
-// Step 3. Call RUN_ALL_TESTS() in main().
-//
-// We do this by linking in src/gtest_main.cc file, which consists of
-// a main() function which calls RUN_ALL_TESTS() for us.
-//
-// This runs all the tests you've defined, prints the result, and
-// returns 0 if successful, or 1 otherwise.
-//
-// Did you notice that we didn't register the tests?  The
-// RUN_ALL_TESTS() macro magically knows about all the tests we
-// defined.  Isn't this convenient?
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.cc
deleted file mode 100644
index 5f763b9b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.cc
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// A sample program demonstrating using Google C++ testing framework.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "sample2.h"
-
-#include <string.h>
-
-// Clones a 0-terminated C string, allocating memory using new.
-const char* MyString::CloneCString(const char* a_c_string) {
-  if (a_c_string == NULL) return NULL;
-
-  const size_t len = strlen(a_c_string);
-  char* const clone = new char[ len + 1 ];
-  memcpy(clone, a_c_string, len + 1);
-
-  return clone;
-}
-
-// Sets the 0-terminated C string this MyString object
-// represents.
-void MyString::Set(const char* a_c_string) {
-  // Makes sure this works when c_string == c_string_
-  const char* const temp = MyString::CloneCString(a_c_string);
-  delete[] c_string_;
-  c_string_ = temp;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.h b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.h
deleted file mode 100644
index cb485c70..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2.h
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// A sample program demonstrating using Google C++ testing framework.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#ifndef GTEST_SAMPLES_SAMPLE2_H_
-#define GTEST_SAMPLES_SAMPLE2_H_
-
-#include <string.h>
-
-
-// A simple string class.
-class MyString {
- private:
-  const char* c_string_;
-  const MyString& operator=(const MyString& rhs);
-
- public:
-  // Clones a 0-terminated C string, allocating memory using new.
-  static const char* CloneCString(const char* a_c_string);
-
-  ////////////////////////////////////////////////////////////
-  //
-  // C'tors
-
-  // The default c'tor constructs a NULL string.
-  MyString() : c_string_(NULL) {}
-
-  // Constructs a MyString by cloning a 0-terminated C string.
-  explicit MyString(const char* a_c_string) : c_string_(NULL) {
-    Set(a_c_string);
-  }
-
-  // Copy c'tor
-  MyString(const MyString& string) : c_string_(NULL) {
-    Set(string.c_string_);
-  }
-
-  ////////////////////////////////////////////////////////////
-  //
-  // D'tor.  MyString is intended to be a final class, so the d'tor
-  // doesn't need to be virtual.
-  ~MyString() { delete[] c_string_; }
-
-  // Gets the 0-terminated C string this MyString object represents.
-  const char* c_string() const { return c_string_; }
-
-  size_t Length() const {
-    return c_string_ == NULL ? 0 : strlen(c_string_);
-  }
-
-  // Sets the 0-terminated C string this MyString object represents.
-  void Set(const char* c_string);
-};
-
-
-#endif  // GTEST_SAMPLES_SAMPLE2_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2_unittest.cc
deleted file mode 100644
index 4fa19b71..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample2_unittest.cc
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// A sample program demonstrating using Google C++ testing framework.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-
-// This sample shows how to write a more complex unit test for a class
-// that has multiple member functions.
-//
-// Usually, it's a good idea to have one test for each method in your
-// class.  You don't have to do that exactly, but it helps to keep
-// your tests organized.  You may also throw in additional tests as
-// needed.
-
-#include "sample2.h"
-#include "gtest/gtest.h"
-
-// In this example, we test the MyString class (a simple string).
-
-// Tests the default c'tor.
-TEST(MyString, DefaultConstructor) {
-  const MyString s;
-
-  // Asserts that s.c_string() returns NULL.
-  //
-  // <TechnicalDetails>
-  //
-  // If we write NULL instead of
-  //
-  //   static_cast<const char *>(NULL)
-  //
-  // in this assertion, it will generate a warning on gcc 3.4.  The
-  // reason is that EXPECT_EQ needs to know the types of its
-  // arguments in order to print them when it fails.  Since NULL is
-  // #defined as 0, the compiler will use the formatter function for
-  // int to print it.  However, gcc thinks that NULL should be used as
-  // a pointer, not an int, and therefore complains.
-  //
-  // The root of the problem is C++'s lack of distinction between the
-  // integer number 0 and the null pointer constant.  Unfortunately,
-  // we have to live with this fact.
-  //
-  // </TechnicalDetails>
-  EXPECT_STREQ(NULL, s.c_string());
-
-  EXPECT_EQ(0u, s.Length());
-}
-
-const char kHelloString[] = "Hello, world!";
-
-// Tests the c'tor that accepts a C string.
-TEST(MyString, ConstructorFromCString) {
-  const MyString s(kHelloString);
-  EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
-  EXPECT_EQ(sizeof(kHelloString)/sizeof(kHelloString[0]) - 1,
-            s.Length());
-}
-
-// Tests the copy c'tor.
-TEST(MyString, CopyConstructor) {
-  const MyString s1(kHelloString);
-  const MyString s2 = s1;
-  EXPECT_EQ(0, strcmp(s2.c_string(), kHelloString));
-}
-
-// Tests the Set method.
-TEST(MyString, Set) {
-  MyString s;
-
-  s.Set(kHelloString);
-  EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
-
-  // Set should work when the input pointer is the same as the one
-  // already in the MyString object.
-  s.Set(s.c_string());
-  EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
-
-  // Can we set the MyString to NULL?
-  s.Set(NULL);
-  EXPECT_STREQ(NULL, s.c_string());
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3-inl.h b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3-inl.h
deleted file mode 100644
index 7e3084d6..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3-inl.h
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// A sample program demonstrating using Google C++ testing framework.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#ifndef GTEST_SAMPLES_SAMPLE3_INL_H_
-#define GTEST_SAMPLES_SAMPLE3_INL_H_
-
-#include <stddef.h>
-
-
-// Queue is a simple queue implemented as a singled-linked list.
-//
-// The element type must support copy constructor.
-template <typename E>  // E is the element type
-class Queue;
-
-// QueueNode is a node in a Queue, which consists of an element of
-// type E and a pointer to the next node.
-template <typename E>  // E is the element type
-class QueueNode {
-  friend class Queue<E>;
-
- public:
-  // Gets the element in this node.
-  const E& element() const { return element_; }
-
-  // Gets the next node in the queue.
-  QueueNode* next() { return next_; }
-  const QueueNode* next() const { return next_; }
-
- private:
-  // Creates a node with a given element value.  The next pointer is
-  // set to NULL.
-  explicit QueueNode(const E& an_element) : element_(an_element), next_(NULL) {}
-
-  // We disable the default assignment operator and copy c'tor.
-  const QueueNode& operator = (const QueueNode&);
-  QueueNode(const QueueNode&);
-
-  E element_;
-  QueueNode* next_;
-};
-
-template <typename E>  // E is the element type.
-class Queue {
- public:
-  // Creates an empty queue.
-  Queue() : head_(NULL), last_(NULL), size_(0) {}
-
-  // D'tor.  Clears the queue.
-  ~Queue() { Clear(); }
-
-  // Clears the queue.
-  void Clear() {
-    if (size_ > 0) {
-      // 1. Deletes every node.
-      QueueNode<E>* node = head_;
-      QueueNode<E>* next = node->next();
-      for (; ;) {
-        delete node;
-        node = next;
-        if (node == NULL) break;
-        next = node->next();
-      }
-
-      // 2. Resets the member variables.
-      head_ = last_ = NULL;
-      size_ = 0;
-    }
-  }
-
-  // Gets the number of elements.
-  size_t Size() const { return size_; }
-
-  // Gets the first element of the queue, or NULL if the queue is empty.
-  QueueNode<E>* Head() { return head_; }
-  const QueueNode<E>* Head() const { return head_; }
-
-  // Gets the last element of the queue, or NULL if the queue is empty.
-  QueueNode<E>* Last() { return last_; }
-  const QueueNode<E>* Last() const { return last_; }
-
-  // Adds an element to the end of the queue.  A copy of the element is
-  // created using the copy constructor, and then stored in the queue.
-  // Changes made to the element in the queue doesn't affect the source
-  // object, and vice versa.
-  void Enqueue(const E& element) {
-    QueueNode<E>* new_node = new QueueNode<E>(element);
-
-    if (size_ == 0) {
-      head_ = last_ = new_node;
-      size_ = 1;
-    } else {
-      last_->next_ = new_node;
-      last_ = new_node;
-      size_++;
-    }
-  }
-
-  // Removes the head of the queue and returns it.  Returns NULL if
-  // the queue is empty.
-  E* Dequeue() {
-    if (size_ == 0) {
-      return NULL;
-    }
-
-    const QueueNode<E>* const old_head = head_;
-    head_ = head_->next_;
-    size_--;
-    if (size_ == 0) {
-      last_ = NULL;
-    }
-
-    E* element = new E(old_head->element());
-    delete old_head;
-
-    return element;
-  }
-
-  // Applies a function/functor on each element of the queue, and
-  // returns the result in a new queue.  The original queue is not
-  // affected.
-  template <typename F>
-  Queue* Map(F function) const {
-    Queue* new_queue = new Queue();
-    for (const QueueNode<E>* node = head_; node != NULL; node = node->next_) {
-      new_queue->Enqueue(function(node->element()));
-    }
-
-    return new_queue;
-  }
-
- private:
-  QueueNode<E>* head_;  // The first node of the queue.
-  QueueNode<E>* last_;  // The last node of the queue.
-  size_t size_;  // The number of elements in the queue.
-
-  // We disallow copying a queue.
-  Queue(const Queue&);
-  const Queue& operator = (const Queue&);
-};
-
-#endif  // GTEST_SAMPLES_SAMPLE3_INL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3_unittest.cc
deleted file mode 100644
index bf3877d0..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample3_unittest.cc
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// A sample program demonstrating using Google C++ testing framework.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-
-// In this example, we use a more advanced feature of Google Test called
-// test fixture.
-//
-// A test fixture is a place to hold objects and functions shared by
-// all tests in a test case.  Using a test fixture avoids duplicating
-// the test code necessary to initialize and cleanup those common
-// objects for each test.  It is also useful for defining sub-routines
-// that your tests need to invoke a lot.
-//
-// <TechnicalDetails>
-//
-// The tests share the test fixture in the sense of code sharing, not
-// data sharing.  Each test is given its own fresh copy of the
-// fixture.  You cannot expect the data modified by one test to be
-// passed on to another test, which is a bad idea.
-//
-// The reason for this design is that tests should be independent and
-// repeatable.  In particular, a test should not fail as the result of
-// another test's failure.  If one test depends on info produced by
-// another test, then the two tests should really be one big test.
-//
-// The macros for indicating the success/failure of a test
-// (EXPECT_TRUE, FAIL, etc) need to know what the current test is
-// (when Google Test prints the test result, it tells you which test
-// each failure belongs to).  Technically, these macros invoke a
-// member function of the Test class.  Therefore, you cannot use them
-// in a global function.  That's why you should put test sub-routines
-// in a test fixture.
-//
-// </TechnicalDetails>
-
-#include "sample3-inl.h"
-#include "gtest/gtest.h"
-
-// To use a test fixture, derive a class from testing::Test.
-class QueueTest : public testing::Test {
- protected:  // You should make the members protected s.t. they can be
-             // accessed from sub-classes.
-
-  // virtual void SetUp() will be called before each test is run.  You
-  // should define it if you need to initialize the varaibles.
-  // Otherwise, this can be skipped.
-  virtual void SetUp() {
-    q1_.Enqueue(1);
-    q2_.Enqueue(2);
-    q2_.Enqueue(3);
-  }
-
-  // virtual void TearDown() will be called after each test is run.
-  // You should define it if there is cleanup work to do.  Otherwise,
-  // you don't have to provide it.
-  //
-  // virtual void TearDown() {
-  // }
-
-  // A helper function that some test uses.
-  static int Double(int n) {
-    return 2*n;
-  }
-
-  // A helper function for testing Queue::Map().
-  void MapTester(const Queue<int> * q) {
-    // Creates a new queue, where each element is twice as big as the
-    // corresponding one in q.
-    const Queue<int> * const new_q = q->Map(Double);
-
-    // Verifies that the new queue has the same size as q.
-    ASSERT_EQ(q->Size(), new_q->Size());
-
-    // Verifies the relationship between the elements of the two queues.
-    for ( const QueueNode<int> * n1 = q->Head(), * n2 = new_q->Head();
-          n1 != NULL; n1 = n1->next(), n2 = n2->next() ) {
-      EXPECT_EQ(2 * n1->element(), n2->element());
-    }
-
-    delete new_q;
-  }
-
-  // Declares the variables your tests want to use.
-  Queue<int> q0_;
-  Queue<int> q1_;
-  Queue<int> q2_;
-};
-
-// When you have a test fixture, you define a test using TEST_F
-// instead of TEST.
-
-// Tests the default c'tor.
-TEST_F(QueueTest, DefaultConstructor) {
-  // You can access data in the test fixture here.
-  EXPECT_EQ(0u, q0_.Size());
-}
-
-// Tests Dequeue().
-TEST_F(QueueTest, Dequeue) {
-  int * n = q0_.Dequeue();
-  EXPECT_TRUE(n == NULL);
-
-  n = q1_.Dequeue();
-  ASSERT_TRUE(n != NULL);
-  EXPECT_EQ(1, *n);
-  EXPECT_EQ(0u, q1_.Size());
-  delete n;
-
-  n = q2_.Dequeue();
-  ASSERT_TRUE(n != NULL);
-  EXPECT_EQ(2, *n);
-  EXPECT_EQ(1u, q2_.Size());
-  delete n;
-}
-
-// Tests the Queue::Map() function.
-TEST_F(QueueTest, Map) {
-  MapTester(&q0_);
-  MapTester(&q1_);
-  MapTester(&q2_);
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.cc
deleted file mode 100644
index ae44bda6..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.cc
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// A sample program demonstrating using Google C++ testing framework.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include <stdio.h>
-
-#include "sample4.h"
-
-// Returns the current counter value, and increments it.
-int Counter::Increment() {
-  return counter_++;
-}
-
-// Prints the current counter value to STDOUT.
-void Counter::Print() const {
-  printf("%d", counter_);
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.h b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.h
deleted file mode 100644
index cd60f0dd..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// A sample program demonstrating using Google C++ testing framework.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#ifndef GTEST_SAMPLES_SAMPLE4_H_
-#define GTEST_SAMPLES_SAMPLE4_H_
-
-// A simple monotonic counter.
-class Counter {
- private:
-  int counter_;
-
- public:
-  // Creates a counter that starts at 0.
-  Counter() : counter_(0) {}
-
-  // Returns the current counter value, and increments it.
-  int Increment();
-
-  // Prints the current counter value to STDOUT.
-  void Print() const;
-};
-
-#endif  // GTEST_SAMPLES_SAMPLE4_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4_unittest.cc
deleted file mode 100644
index fa5afc7d..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample4_unittest.cc
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "gtest/gtest.h"
-#include "sample4.h"
-
-// Tests the Increment() method.
-TEST(Counter, Increment) {
-  Counter c;
-
-  // EXPECT_EQ() evaluates its arguments exactly once, so they
-  // can have side effects.
-
-  EXPECT_EQ(0, c.Increment());
-  EXPECT_EQ(1, c.Increment());
-  EXPECT_EQ(2, c.Increment());
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample5_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample5_unittest.cc
deleted file mode 100644
index 43d8e577..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample5_unittest.cc
+++ /dev/null
@@ -1,199 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// This sample teaches how to reuse a test fixture in multiple test
-// cases by deriving sub-fixtures from it.
-//
-// When you define a test fixture, you specify the name of the test
-// case that will use this fixture.  Therefore, a test fixture can
-// be used by only one test case.
-//
-// Sometimes, more than one test cases may want to use the same or
-// slightly different test fixtures.  For example, you may want to
-// make sure that all tests for a GUI library don't leak important
-// system resources like fonts and brushes.  In Google Test, you do
-// this by putting the shared logic in a super (as in "super class")
-// test fixture, and then have each test case use a fixture derived
-// from this super fixture.
-
-#include <limits.h>
-#include <time.h>
-#include "sample3-inl.h"
-#include "gtest/gtest.h"
-#include "sample1.h"
-
-// In this sample, we want to ensure that every test finishes within
-// ~5 seconds.  If a test takes longer to run, we consider it a
-// failure.
-//
-// We put the code for timing a test in a test fixture called
-// "QuickTest".  QuickTest is intended to be the super fixture that
-// other fixtures derive from, therefore there is no test case with
-// the name "QuickTest".  This is OK.
-//
-// Later, we will derive multiple test fixtures from QuickTest.
-class QuickTest : public testing::Test {
- protected:
-  // Remember that SetUp() is run immediately before a test starts.
-  // This is a good place to record the start time.
-  virtual void SetUp() {
-    start_time_ = time(NULL);
-  }
-
-  // TearDown() is invoked immediately after a test finishes.  Here we
-  // check if the test was too slow.
-  virtual void TearDown() {
-    // Gets the time when the test finishes
-    const time_t end_time = time(NULL);
-
-    // Asserts that the test took no more than ~5 seconds.  Did you
-    // know that you can use assertions in SetUp() and TearDown() as
-    // well?
-    EXPECT_TRUE(end_time - start_time_ <= 5) << "The test took too long.";
-  }
-
-  // The UTC time (in seconds) when the test starts
-  time_t start_time_;
-};
-
-
-// We derive a fixture named IntegerFunctionTest from the QuickTest
-// fixture.  All tests using this fixture will be automatically
-// required to be quick.
-class IntegerFunctionTest : public QuickTest {
-  // We don't need any more logic than already in the QuickTest fixture.
-  // Therefore the body is empty.
-};
-
-
-// Now we can write tests in the IntegerFunctionTest test case.
-
-// Tests Factorial()
-TEST_F(IntegerFunctionTest, Factorial) {
-  // Tests factorial of negative numbers.
-  EXPECT_EQ(1, Factorial(-5));
-  EXPECT_EQ(1, Factorial(-1));
-  EXPECT_GT(Factorial(-10), 0);
-
-  // Tests factorial of 0.
-  EXPECT_EQ(1, Factorial(0));
-
-  // Tests factorial of positive numbers.
-  EXPECT_EQ(1, Factorial(1));
-  EXPECT_EQ(2, Factorial(2));
-  EXPECT_EQ(6, Factorial(3));
-  EXPECT_EQ(40320, Factorial(8));
-}
-
-
-// Tests IsPrime()
-TEST_F(IntegerFunctionTest, IsPrime) {
-  // Tests negative input.
-  EXPECT_FALSE(IsPrime(-1));
-  EXPECT_FALSE(IsPrime(-2));
-  EXPECT_FALSE(IsPrime(INT_MIN));
-
-  // Tests some trivial cases.
-  EXPECT_FALSE(IsPrime(0));
-  EXPECT_FALSE(IsPrime(1));
-  EXPECT_TRUE(IsPrime(2));
-  EXPECT_TRUE(IsPrime(3));
-
-  // Tests positive input.
-  EXPECT_FALSE(IsPrime(4));
-  EXPECT_TRUE(IsPrime(5));
-  EXPECT_FALSE(IsPrime(6));
-  EXPECT_TRUE(IsPrime(23));
-}
-
-
-// The next test case (named "QueueTest") also needs to be quick, so
-// we derive another fixture from QuickTest.
-//
-// The QueueTest test fixture has some logic and shared objects in
-// addition to what's in QuickTest already.  We define the additional
-// stuff inside the body of the test fixture, as usual.
-class QueueTest : public QuickTest {
- protected:
-  virtual void SetUp() {
-    // First, we need to set up the super fixture (QuickTest).
-    QuickTest::SetUp();
-
-    // Second, some additional setup for this fixture.
-    q1_.Enqueue(1);
-    q2_.Enqueue(2);
-    q2_.Enqueue(3);
-  }
-
-  // By default, TearDown() inherits the behavior of
-  // QuickTest::TearDown().  As we have no additional cleaning work
-  // for QueueTest, we omit it here.
-  //
-  // virtual void TearDown() {
-  //   QuickTest::TearDown();
-  // }
-
-  Queue<int> q0_;
-  Queue<int> q1_;
-  Queue<int> q2_;
-};
-
-
-// Now, let's write tests using the QueueTest fixture.
-
-// Tests the default constructor.
-TEST_F(QueueTest, DefaultConstructor) {
-  EXPECT_EQ(0u, q0_.Size());
-}
-
-// Tests Dequeue().
-TEST_F(QueueTest, Dequeue) {
-  int* n = q0_.Dequeue();
-  EXPECT_TRUE(n == NULL);
-
-  n = q1_.Dequeue();
-  EXPECT_TRUE(n != NULL);
-  EXPECT_EQ(1, *n);
-  EXPECT_EQ(0u, q1_.Size());
-  delete n;
-
-  n = q2_.Dequeue();
-  EXPECT_TRUE(n != NULL);
-  EXPECT_EQ(2, *n);
-  EXPECT_EQ(1u, q2_.Size());
-  delete n;
-}
-
-// If necessary, you can derive further test fixtures from a derived
-// fixture itself.  For example, you can derive another fixture from
-// QueueTest.  Google Test imposes no limit on how deep the hierarchy
-// can be.  In practice, however, you probably don't want it to be too
-// deep as to be confusing.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample6_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample6_unittest.cc
deleted file mode 100644
index 8f2036a5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample6_unittest.cc
+++ /dev/null
@@ -1,224 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// This sample shows how to test common properties of multiple
-// implementations of the same interface (aka interface tests).
-
-// The interface and its implementations are in this header.
-#include "prime_tables.h"
-
-#include "gtest/gtest.h"
-
-// First, we define some factory functions for creating instances of
-// the implementations.  You may be able to skip this step if all your
-// implementations can be constructed the same way.
-
-template <class T>
-PrimeTable* CreatePrimeTable();
-
-template <>
-PrimeTable* CreatePrimeTable<OnTheFlyPrimeTable>() {
-  return new OnTheFlyPrimeTable;
-}
-
-template <>
-PrimeTable* CreatePrimeTable<PreCalculatedPrimeTable>() {
-  return new PreCalculatedPrimeTable(10000);
-}
-
-// Then we define a test fixture class template.
-template <class T>
-class PrimeTableTest : public testing::Test {
- protected:
-  // The ctor calls the factory function to create a prime table
-  // implemented by T.
-  PrimeTableTest() : table_(CreatePrimeTable<T>()) {}
-
-  virtual ~PrimeTableTest() { delete table_; }
-
-  // Note that we test an implementation via the base interface
-  // instead of the actual implementation class.  This is important
-  // for keeping the tests close to the real world scenario, where the
-  // implementation is invoked via the base interface.  It avoids
-  // got-yas where the implementation class has a method that shadows
-  // a method with the same name (but slightly different argument
-  // types) in the base interface, for example.
-  PrimeTable* const table_;
-};
-
-#if GTEST_HAS_TYPED_TEST
-
-using testing::Types;
-
-// Google Test offers two ways for reusing tests for different types.
-// The first is called "typed tests".  You should use it if you
-// already know *all* the types you are gonna exercise when you write
-// the tests.
-
-// To write a typed test case, first use
-//
-//   TYPED_TEST_CASE(TestCaseName, TypeList);
-//
-// to declare it and specify the type parameters.  As with TEST_F,
-// TestCaseName must match the test fixture name.
-
-// The list of types we want to test.
-typedef Types<OnTheFlyPrimeTable, PreCalculatedPrimeTable> Implementations;
-
-TYPED_TEST_CASE(PrimeTableTest, Implementations);
-
-// Then use TYPED_TEST(TestCaseName, TestName) to define a typed test,
-// similar to TEST_F.
-TYPED_TEST(PrimeTableTest, ReturnsFalseForNonPrimes) {
-  // Inside the test body, you can refer to the type parameter by
-  // TypeParam, and refer to the fixture class by TestFixture.  We
-  // don't need them in this example.
-
-  // Since we are in the template world, C++ requires explicitly
-  // writing 'this->' when referring to members of the fixture class.
-  // This is something you have to learn to live with.
-  EXPECT_FALSE(this->table_->IsPrime(-5));
-  EXPECT_FALSE(this->table_->IsPrime(0));
-  EXPECT_FALSE(this->table_->IsPrime(1));
-  EXPECT_FALSE(this->table_->IsPrime(4));
-  EXPECT_FALSE(this->table_->IsPrime(6));
-  EXPECT_FALSE(this->table_->IsPrime(100));
-}
-
-TYPED_TEST(PrimeTableTest, ReturnsTrueForPrimes) {
-  EXPECT_TRUE(this->table_->IsPrime(2));
-  EXPECT_TRUE(this->table_->IsPrime(3));
-  EXPECT_TRUE(this->table_->IsPrime(5));
-  EXPECT_TRUE(this->table_->IsPrime(7));
-  EXPECT_TRUE(this->table_->IsPrime(11));
-  EXPECT_TRUE(this->table_->IsPrime(131));
-}
-
-TYPED_TEST(PrimeTableTest, CanGetNextPrime) {
-  EXPECT_EQ(2, this->table_->GetNextPrime(0));
-  EXPECT_EQ(3, this->table_->GetNextPrime(2));
-  EXPECT_EQ(5, this->table_->GetNextPrime(3));
-  EXPECT_EQ(7, this->table_->GetNextPrime(5));
-  EXPECT_EQ(11, this->table_->GetNextPrime(7));
-  EXPECT_EQ(131, this->table_->GetNextPrime(128));
-}
-
-// That's it!  Google Test will repeat each TYPED_TEST for each type
-// in the type list specified in TYPED_TEST_CASE.  Sit back and be
-// happy that you don't have to define them multiple times.
-
-#endif  // GTEST_HAS_TYPED_TEST
-
-#if GTEST_HAS_TYPED_TEST_P
-
-using testing::Types;
-
-// Sometimes, however, you don't yet know all the types that you want
-// to test when you write the tests.  For example, if you are the
-// author of an interface and expect other people to implement it, you
-// might want to write a set of tests to make sure each implementation
-// conforms to some basic requirements, but you don't know what
-// implementations will be written in the future.
-//
-// How can you write the tests without committing to the type
-// parameters?  That's what "type-parameterized tests" can do for you.
-// It is a bit more involved than typed tests, but in return you get a
-// test pattern that can be reused in many contexts, which is a big
-// win.  Here's how you do it:
-
-// First, define a test fixture class template.  Here we just reuse
-// the PrimeTableTest fixture defined earlier:
-
-template <class T>
-class PrimeTableTest2 : public PrimeTableTest<T> {
-};
-
-// Then, declare the test case.  The argument is the name of the test
-// fixture, and also the name of the test case (as usual).  The _P
-// suffix is for "parameterized" or "pattern".
-TYPED_TEST_CASE_P(PrimeTableTest2);
-
-// Next, use TYPED_TEST_P(TestCaseName, TestName) to define a test,
-// similar to what you do with TEST_F.
-TYPED_TEST_P(PrimeTableTest2, ReturnsFalseForNonPrimes) {
-  EXPECT_FALSE(this->table_->IsPrime(-5));
-  EXPECT_FALSE(this->table_->IsPrime(0));
-  EXPECT_FALSE(this->table_->IsPrime(1));
-  EXPECT_FALSE(this->table_->IsPrime(4));
-  EXPECT_FALSE(this->table_->IsPrime(6));
-  EXPECT_FALSE(this->table_->IsPrime(100));
-}
-
-TYPED_TEST_P(PrimeTableTest2, ReturnsTrueForPrimes) {
-  EXPECT_TRUE(this->table_->IsPrime(2));
-  EXPECT_TRUE(this->table_->IsPrime(3));
-  EXPECT_TRUE(this->table_->IsPrime(5));
-  EXPECT_TRUE(this->table_->IsPrime(7));
-  EXPECT_TRUE(this->table_->IsPrime(11));
-  EXPECT_TRUE(this->table_->IsPrime(131));
-}
-
-TYPED_TEST_P(PrimeTableTest2, CanGetNextPrime) {
-  EXPECT_EQ(2, this->table_->GetNextPrime(0));
-  EXPECT_EQ(3, this->table_->GetNextPrime(2));
-  EXPECT_EQ(5, this->table_->GetNextPrime(3));
-  EXPECT_EQ(7, this->table_->GetNextPrime(5));
-  EXPECT_EQ(11, this->table_->GetNextPrime(7));
-  EXPECT_EQ(131, this->table_->GetNextPrime(128));
-}
-
-// Type-parameterized tests involve one extra step: you have to
-// enumerate the tests you defined:
-REGISTER_TYPED_TEST_CASE_P(
-    PrimeTableTest2,  // The first argument is the test case name.
-    // The rest of the arguments are the test names.
-    ReturnsFalseForNonPrimes, ReturnsTrueForPrimes, CanGetNextPrime);
-
-// At this point the test pattern is done.  However, you don't have
-// any real test yet as you haven't said which types you want to run
-// the tests with.
-
-// To turn the abstract test pattern into real tests, you instantiate
-// it with a list of types.  Usually the test pattern will be defined
-// in a .h file, and anyone can #include and instantiate it.  You can
-// even instantiate it more than once in the same program.  To tell
-// different instances apart, you give each of them a name, which will
-// become part of the test case name and can be used in test filters.
-
-// The list of types we want to test.  Note that it doesn't have to be
-// defined at the time we write the TYPED_TEST_P()s.
-typedef Types<OnTheFlyPrimeTable, PreCalculatedPrimeTable>
-    PrimeTableImplementations;
-INSTANTIATE_TYPED_TEST_CASE_P(OnTheFlyAndPreCalculated,    // Instance name
-                              PrimeTableTest2,             // Test case name
-                              PrimeTableImplementations);  // Type list
-
-#endif  // GTEST_HAS_TYPED_TEST_P
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample7_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample7_unittest.cc
deleted file mode 100644
index 1b651a21..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample7_unittest.cc
+++ /dev/null
@@ -1,130 +0,0 @@
-// 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-
-// This sample shows how to test common properties of multiple
-// implementations of an interface (aka interface tests) using
-// value-parameterized tests. Each test in the test case has
-// a parameter that is an interface pointer to an implementation
-// tested.
-
-// The interface and its implementations are in this header.
-#include "prime_tables.h"
-
-#include "gtest/gtest.h"
-
-#if GTEST_HAS_PARAM_TEST
-
-using ::testing::TestWithParam;
-using ::testing::Values;
-
-// As a general rule, to prevent a test from affecting the tests that come
-// after it, you should create and destroy the tested objects for each test
-// instead of reusing them.  In this sample we will define a simple factory
-// function for PrimeTable objects.  We will instantiate objects in test's
-// SetUp() method and delete them in TearDown() method.
-typedef PrimeTable* CreatePrimeTableFunc();
-
-PrimeTable* CreateOnTheFlyPrimeTable() {
-  return new OnTheFlyPrimeTable();
-}
-
-template <size_t max_precalculated>
-PrimeTable* CreatePreCalculatedPrimeTable() {
-  return new PreCalculatedPrimeTable(max_precalculated);
-}
-
-// Inside the test body, fixture constructor, SetUp(), and TearDown() you
-// can refer to the test parameter by GetParam().  In this case, the test
-// parameter is a factory function which we call in fixture's SetUp() to
-// create and store an instance of PrimeTable.
-class PrimeTableTest : public TestWithParam<CreatePrimeTableFunc*> {
- public:
-  virtual ~PrimeTableTest() { delete table_; }
-  virtual void SetUp() { table_ = (*GetParam())(); }
-  virtual void TearDown() {
-    delete table_;
-    table_ = NULL;
-  }
-
- protected:
-  PrimeTable* table_;
-};
-
-TEST_P(PrimeTableTest, ReturnsFalseForNonPrimes) {
-  EXPECT_FALSE(table_->IsPrime(-5));
-  EXPECT_FALSE(table_->IsPrime(0));
-  EXPECT_FALSE(table_->IsPrime(1));
-  EXPECT_FALSE(table_->IsPrime(4));
-  EXPECT_FALSE(table_->IsPrime(6));
-  EXPECT_FALSE(table_->IsPrime(100));
-}
-
-TEST_P(PrimeTableTest, ReturnsTrueForPrimes) {
-  EXPECT_TRUE(table_->IsPrime(2));
-  EXPECT_TRUE(table_->IsPrime(3));
-  EXPECT_TRUE(table_->IsPrime(5));
-  EXPECT_TRUE(table_->IsPrime(7));
-  EXPECT_TRUE(table_->IsPrime(11));
-  EXPECT_TRUE(table_->IsPrime(131));
-}
-
-TEST_P(PrimeTableTest, CanGetNextPrime) {
-  EXPECT_EQ(2, table_->GetNextPrime(0));
-  EXPECT_EQ(3, table_->GetNextPrime(2));
-  EXPECT_EQ(5, table_->GetNextPrime(3));
-  EXPECT_EQ(7, table_->GetNextPrime(5));
-  EXPECT_EQ(11, table_->GetNextPrime(7));
-  EXPECT_EQ(131, table_->GetNextPrime(128));
-}
-
-// In order to run value-parameterized tests, you need to instantiate them,
-// or bind them to a list of values which will be used as test parameters.
-// You can instantiate them in a different translation module, or even
-// instantiate them several times.
-//
-// Here, we instantiate our tests with a list of two PrimeTable object
-// factory functions:
-INSTANTIATE_TEST_CASE_P(
-    OnTheFlyAndPreCalculated,
-    PrimeTableTest,
-    Values(&CreateOnTheFlyPrimeTable, &CreatePreCalculatedPrimeTable<1000>));
-
-#else
-
-// Google Test may not support value-parameterized tests with some
-// compilers. If we use conditional compilation to compile out all
-// code referring to the gtest_main library, MSVC linker will not link
-// that library at all and consequently complain about missing entry
-// point defined in that library (fatal error LNK1561: entry point
-// must be defined). This dummy test keeps gtest_main linked in.
-TEST(DummyTest, ValueParameterizedTestsAreNotSupportedOnThisPlatform) {}
-
-#endif  // GTEST_HAS_PARAM_TEST
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample8_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample8_unittest.cc
deleted file mode 100644
index 72743340..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample8_unittest.cc
+++ /dev/null
@@ -1,173 +0,0 @@
-// 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-
-// This sample shows how to test code relying on some global flag variables.
-// Combine() helps with generating all possible combinations of such flags,
-// and each test is given one combination as a parameter.
-
-// Use class definitions to test from this header.
-#include "prime_tables.h"
-
-#include "gtest/gtest.h"
-
-#if GTEST_HAS_COMBINE
-
-// Suppose we want to introduce a new, improved implementation of PrimeTable
-// which combines speed of PrecalcPrimeTable and versatility of
-// OnTheFlyPrimeTable (see prime_tables.h). Inside it instantiates both
-// PrecalcPrimeTable and OnTheFlyPrimeTable and uses the one that is more
-// appropriate under the circumstances. But in low memory conditions, it can be
-// told to instantiate without PrecalcPrimeTable instance at all and use only
-// OnTheFlyPrimeTable.
-class HybridPrimeTable : public PrimeTable {
- public:
-  HybridPrimeTable(bool force_on_the_fly, int max_precalculated)
-      : on_the_fly_impl_(new OnTheFlyPrimeTable),
-        precalc_impl_(force_on_the_fly ? NULL :
-                          new PreCalculatedPrimeTable(max_precalculated)),
-        max_precalculated_(max_precalculated) {}
-  virtual ~HybridPrimeTable() {
-    delete on_the_fly_impl_;
-    delete precalc_impl_;
-  }
-
-  virtual bool IsPrime(int n) const {
-    if (precalc_impl_ != NULL && n < max_precalculated_)
-      return precalc_impl_->IsPrime(n);
-    else
-      return on_the_fly_impl_->IsPrime(n);
-  }
-
-  virtual int GetNextPrime(int p) const {
-    int next_prime = -1;
-    if (precalc_impl_ != NULL && p < max_precalculated_)
-      next_prime = precalc_impl_->GetNextPrime(p);
-
-    return next_prime != -1 ? next_prime : on_the_fly_impl_->GetNextPrime(p);
-  }
-
- private:
-  OnTheFlyPrimeTable* on_the_fly_impl_;
-  PreCalculatedPrimeTable* precalc_impl_;
-  int max_precalculated_;
-};
-
-using ::testing::TestWithParam;
-using ::testing::Bool;
-using ::testing::Values;
-using ::testing::Combine;
-
-// To test all code paths for HybridPrimeTable we must test it with numbers
-// both within and outside PreCalculatedPrimeTable's capacity and also with
-// PreCalculatedPrimeTable disabled. We do this by defining fixture which will
-// accept different combinations of parameters for instantiating a
-// HybridPrimeTable instance.
-class PrimeTableTest : public TestWithParam< ::testing::tuple<bool, int> > {
- protected:
-  virtual void SetUp() {
-    // This can be written as
-    //
-    // bool force_on_the_fly;
-    // int max_precalculated;
-    // tie(force_on_the_fly, max_precalculated) = GetParam();
-    //
-    // once the Google C++ Style Guide allows use of ::std::tr1::tie.
-    //
-    bool force_on_the_fly = ::testing::get<0>(GetParam());
-    int max_precalculated = ::testing::get<1>(GetParam());
-    table_ = new HybridPrimeTable(force_on_the_fly, max_precalculated);
-  }
-  virtual void TearDown() {
-    delete table_;
-    table_ = NULL;
-  }
-  HybridPrimeTable* table_;
-};
-
-TEST_P(PrimeTableTest, ReturnsFalseForNonPrimes) {
-  // Inside the test body, you can refer to the test parameter by GetParam().
-  // In this case, the test parameter is a PrimeTable interface pointer which
-  // we can use directly.
-  // Please note that you can also save it in the fixture's SetUp() method
-  // or constructor and use saved copy in the tests.
-
-  EXPECT_FALSE(table_->IsPrime(-5));
-  EXPECT_FALSE(table_->IsPrime(0));
-  EXPECT_FALSE(table_->IsPrime(1));
-  EXPECT_FALSE(table_->IsPrime(4));
-  EXPECT_FALSE(table_->IsPrime(6));
-  EXPECT_FALSE(table_->IsPrime(100));
-}
-
-TEST_P(PrimeTableTest, ReturnsTrueForPrimes) {
-  EXPECT_TRUE(table_->IsPrime(2));
-  EXPECT_TRUE(table_->IsPrime(3));
-  EXPECT_TRUE(table_->IsPrime(5));
-  EXPECT_TRUE(table_->IsPrime(7));
-  EXPECT_TRUE(table_->IsPrime(11));
-  EXPECT_TRUE(table_->IsPrime(131));
-}
-
-TEST_P(PrimeTableTest, CanGetNextPrime) {
-  EXPECT_EQ(2, table_->GetNextPrime(0));
-  EXPECT_EQ(3, table_->GetNextPrime(2));
-  EXPECT_EQ(5, table_->GetNextPrime(3));
-  EXPECT_EQ(7, table_->GetNextPrime(5));
-  EXPECT_EQ(11, table_->GetNextPrime(7));
-  EXPECT_EQ(131, table_->GetNextPrime(128));
-}
-
-// In order to run value-parameterized tests, you need to instantiate them,
-// or bind them to a list of values which will be used as test parameters.
-// You can instantiate them in a different translation module, or even
-// instantiate them several times.
-//
-// Here, we instantiate our tests with a list of parameters. We must combine
-// all variations of the boolean flag suppressing PrecalcPrimeTable and some
-// meaningful values for tests. We choose a small value (1), and a value that
-// will put some of the tested numbers beyond the capability of the
-// PrecalcPrimeTable instance and some inside it (10). Combine will produce all
-// possible combinations.
-INSTANTIATE_TEST_CASE_P(MeaningfulTestParameters,
-                        PrimeTableTest,
-                        Combine(Bool(), Values(1, 10)));
-
-#else
-
-// Google Test may not support Combine() with some compilers. If we
-// use conditional compilation to compile out all code referring to
-// the gtest_main library, MSVC linker will not link that library at
-// all and consequently complain about missing entry point defined in
-// that library (fatal error LNK1561: entry point must be
-// defined). This dummy test keeps gtest_main linked in.
-TEST(DummyTest, CombineIsNotSupportedOnThisPlatform) {}
-
-#endif  // GTEST_HAS_COMBINE
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample9_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample9_unittest.cc
deleted file mode 100644
index b2e2079b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/samples/sample9_unittest.cc
+++ /dev/null
@@ -1,160 +0,0 @@
-// Copyright 2009 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-
-// This sample shows how to use Google Test listener API to implement
-// an alternative console output and how to use the UnitTest reflection API
-// to enumerate test cases and tests and to inspect their results.
-
-#include <stdio.h>
-
-#include "gtest/gtest.h"
-
-using ::testing::EmptyTestEventListener;
-using ::testing::InitGoogleTest;
-using ::testing::Test;
-using ::testing::TestCase;
-using ::testing::TestEventListeners;
-using ::testing::TestInfo;
-using ::testing::TestPartResult;
-using ::testing::UnitTest;
-
-namespace {
-
-// Provides alternative output mode which produces minimal amount of
-// information about tests.
-class TersePrinter : public EmptyTestEventListener {
- private:
-  // Called before any test activity starts.
-  virtual void OnTestProgramStart(const UnitTest& /* unit_test */) {}
-
-  // Called after all test activities have ended.
-  virtual void OnTestProgramEnd(const UnitTest& unit_test) {
-    fprintf(stdout, "TEST %s\n", unit_test.Passed() ? "PASSED" : "FAILED");
-    fflush(stdout);
-  }
-
-  // Called before a test starts.
-  virtual void OnTestStart(const TestInfo& test_info) {
-    fprintf(stdout,
-            "*** Test %s.%s starting.\n",
-            test_info.test_case_name(),
-            test_info.name());
-    fflush(stdout);
-  }
-
-  // Called after a failed assertion or a SUCCEED() invocation.
-  virtual void OnTestPartResult(const TestPartResult& test_part_result) {
-    fprintf(stdout,
-            "%s in %s:%d\n%s\n",
-            test_part_result.failed() ? "*** Failure" : "Success",
-            test_part_result.file_name(),
-            test_part_result.line_number(),
-            test_part_result.summary());
-    fflush(stdout);
-  }
-
-  // Called after a test ends.
-  virtual void OnTestEnd(const TestInfo& test_info) {
-    fprintf(stdout,
-            "*** Test %s.%s ending.\n",
-            test_info.test_case_name(),
-            test_info.name());
-    fflush(stdout);
-  }
-};  // class TersePrinter
-
-TEST(CustomOutputTest, PrintsMessage) {
-  printf("Printing something from the test body...\n");
-}
-
-TEST(CustomOutputTest, Succeeds) {
-  SUCCEED() << "SUCCEED() has been invoked from here";
-}
-
-TEST(CustomOutputTest, Fails) {
-  EXPECT_EQ(1, 2)
-      << "This test fails in order to demonstrate alternative failure messages";
-}
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  InitGoogleTest(&argc, argv);
-
-  bool terse_output = false;
-  if (argc > 1 && strcmp(argv[1], "--terse_output") == 0 )
-    terse_output = true;
-  else
-    printf("%s\n", "Run this program with --terse_output to change the way "
-           "it prints its output.");
-
-  UnitTest& unit_test = *UnitTest::GetInstance();
-
-  // If we are given the --terse_output command line flag, suppresses the
-  // standard output and attaches own result printer.
-  if (terse_output) {
-    TestEventListeners& listeners = unit_test.listeners();
-
-    // Removes the default console output listener from the list so it will
-    // not receive events from Google Test and won't print any output. Since
-    // this operation transfers ownership of the listener to the caller we
-    // have to delete it as well.
-    delete listeners.Release(listeners.default_result_printer());
-
-    // Adds the custom output listener to the list. It will now receive
-    // events from Google Test and print the alternative output. We don't
-    // have to worry about deleting it since Google Test assumes ownership
-    // over it after adding it to the list.
-    listeners.Append(new TersePrinter);
-  }
-  int ret_val = RUN_ALL_TESTS();
-
-  // This is an example of using the UnitTest reflection API to inspect test
-  // results. Here we discount failures from the tests we expected to fail.
-  int unexpectedly_failed_tests = 0;
-  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
-    const TestCase& test_case = *unit_test.GetTestCase(i);
-    for (int j = 0; j < test_case.total_test_count(); ++j) {
-      const TestInfo& test_info = *test_case.GetTestInfo(j);
-      // Counts failed tests that were not meant to fail (those without
-      // 'Fails' in the name).
-      if (test_info.result()->Failed() &&
-          strcmp(test_info.name(), "Fails") != 0) {
-        unexpectedly_failed_tests++;
-      }
-    }
-  }
-
-  // Test that were meant to fail should not affect the test program outcome.
-  if (unexpectedly_failed_tests == 0)
-    ret_val = 0;
-
-  return ret_val;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/common.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/common.py
deleted file mode 100644
index 3c0347a7..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/common.py
+++ /dev/null
@@ -1,83 +0,0 @@
-# Copyright 2013 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.
-
-"""Shared utilities for writing scripts for Google Test/Mock."""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-
-import os
-import re
-
-
-# Matches the line from 'svn info .' output that describes what SVN
-# path the current local directory corresponds to.  For example, in
-# a googletest SVN workspace's trunk/test directory, the output will be:
-#
-# URL: https://googletest.googlecode.com/svn/trunk/test
-_SVN_INFO_URL_RE = re.compile(r'^URL: https://(\w+)\.googlecode\.com/svn(.*)')
-
-
-def GetCommandOutput(command):
-  """Runs the shell command and returns its stdout as a list of lines."""
-
-  f = os.popen(command, 'r')
-  lines = [line.strip() for line in f.readlines()]
-  f.close()
-  return lines
-
-
-def GetSvnInfo():
-  """Returns the project name and the current SVN workspace's root path."""
-
-  for line in GetCommandOutput('svn info .'):
-    m = _SVN_INFO_URL_RE.match(line)
-    if m:
-      project = m.group(1)  # googletest or googlemock
-      rel_path = m.group(2)
-      root = os.path.realpath(rel_path.count('/') * '../')
-      return project, root
-
-  return None, None
-
-
-def GetSvnTrunk():
-  """Returns the current SVN workspace's trunk root path."""
-
-  _, root = GetSvnInfo()
-  return root + '/trunk' if root else None
-
-
-def IsInGTestSvn():
-  project, _ = GetSvnInfo()
-  return project == 'googletest'
-
-
-def IsInGMockSvn():
-  project, _ = GetSvnInfo()
-  return project == 'googlemock'
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/fuse_gtest_files.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/fuse_gtest_files.py
deleted file mode 100755
index 3f3e9f36..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/fuse_gtest_files.py
+++ /dev/null
@@ -1,253 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2009, 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.
-
-"""fuse_gtest_files.py v0.2.0
-Fuses Google Test source code into a .h file and a .cc file.
-
-SYNOPSIS
-       fuse_gtest_files.py [GTEST_ROOT_DIR] OUTPUT_DIR
-
-       Scans GTEST_ROOT_DIR for Google Test source code, and generates
-       two files: OUTPUT_DIR/gtest/gtest.h and OUTPUT_DIR/gtest/gtest-all.cc.
-       Then you can build your tests by adding OUTPUT_DIR to the include
-       search path and linking with OUTPUT_DIR/gtest/gtest-all.cc.  These
-       two files contain everything you need to use Google Test.  Hence
-       you can "install" Google Test by copying them to wherever you want.
-
-       GTEST_ROOT_DIR can be omitted and defaults to the parent
-       directory of the directory holding this script.
-
-EXAMPLES
-       ./fuse_gtest_files.py fused_gtest
-       ./fuse_gtest_files.py path/to/unpacked/gtest fused_gtest
-
-This tool is experimental.  In particular, it assumes that there is no
-conditional inclusion of Google Test headers.  Please report any
-problems to googletestframework@googlegroups.com.  You can read
-http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide for
-more information.
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import re
-try:
-  from sets import Set as set  # For Python 2.3 compatibility
-except ImportError:
-  pass
-import sys
-
-# We assume that this file is in the scripts/ directory in the Google
-# Test root directory.
-DEFAULT_GTEST_ROOT_DIR = os.path.join(os.path.dirname(__file__), '..')
-
-# Regex for matching '#include "gtest/..."'.
-INCLUDE_GTEST_FILE_REGEX = re.compile(r'^\s*#\s*include\s*"(gtest/.+)"')
-
-# Regex for matching '#include "src/..."'.
-INCLUDE_SRC_FILE_REGEX = re.compile(r'^\s*#\s*include\s*"(src/.+)"')
-
-# Where to find the source seed files.
-GTEST_H_SEED = 'include/gtest/gtest.h'
-GTEST_SPI_H_SEED = 'include/gtest/gtest-spi.h'
-GTEST_ALL_CC_SEED = 'src/gtest-all.cc'
-
-# Where to put the generated files.
-GTEST_H_OUTPUT = 'gtest/gtest.h'
-GTEST_ALL_CC_OUTPUT = 'gtest/gtest-all.cc'
-
-
-def VerifyFileExists(directory, relative_path):
-  """Verifies that the given file exists; aborts on failure.
-
-  relative_path is the file path relative to the given directory.
-  """
-
-  if not os.path.isfile(os.path.join(directory, relative_path)):
-    print('ERROR: Cannot find %s in directory %s.' % (relative_path,
-                                                      directory))
-    print('Please either specify a valid project root directory '
-          'or omit it on the command line.')
-    sys.exit(1)
-
-
-def ValidateGTestRootDir(gtest_root):
-  """Makes sure gtest_root points to a valid gtest root directory.
-
-  The function aborts the program on failure.
-  """
-
-  VerifyFileExists(gtest_root, GTEST_H_SEED)
-  VerifyFileExists(gtest_root, GTEST_ALL_CC_SEED)
-
-
-def VerifyOutputFile(output_dir, relative_path):
-  """Verifies that the given output file path is valid.
-
-  relative_path is relative to the output_dir directory.
-  """
-
-  # Makes sure the output file either doesn't exist or can be overwritten.
-  output_file = os.path.join(output_dir, relative_path)
-  if os.path.exists(output_file):
-    # TODO(wan@google.com): The following user-interaction doesn't
-    # work with automated processes.  We should provide a way for the
-    # Makefile to force overwriting the files.
-    print('%s already exists in directory %s - overwrite it? (y/N) ' %
-          (relative_path, output_dir))
-    answer = sys.stdin.readline().strip()
-    if answer not in ['y', 'Y']:
-      print('ABORTED.')
-      sys.exit(1)
-
-  # Makes sure the directory holding the output file exists; creates
-  # it and all its ancestors if necessary.
-  parent_directory = os.path.dirname(output_file)
-  if not os.path.isdir(parent_directory):
-    os.makedirs(parent_directory)
-
-
-def ValidateOutputDir(output_dir):
-  """Makes sure output_dir points to a valid output directory.
-
-  The function aborts the program on failure.
-  """
-
-  VerifyOutputFile(output_dir, GTEST_H_OUTPUT)
-  VerifyOutputFile(output_dir, GTEST_ALL_CC_OUTPUT)
-
-
-def FuseGTestH(gtest_root, output_dir):
-  """Scans folder gtest_root to generate gtest/gtest.h in output_dir."""
-
-  output_file = open(os.path.join(output_dir, GTEST_H_OUTPUT), 'w')
-  processed_files = set()  # Holds all gtest headers we've processed.
-
-  def ProcessFile(gtest_header_path):
-    """Processes the given gtest header file."""
-
-    # We don't process the same header twice.
-    if gtest_header_path in processed_files:
-      return
-
-    processed_files.add(gtest_header_path)
-
-    # Reads each line in the given gtest header.
-    for line in open(os.path.join(gtest_root, gtest_header_path), 'r'):
-      m = INCLUDE_GTEST_FILE_REGEX.match(line)
-      if m:
-        # It's '#include "gtest/..."' - let's process it recursively.
-        ProcessFile('include/' + m.group(1))
-      else:
-        # Otherwise we copy the line unchanged to the output file.
-        output_file.write(line)
-
-  ProcessFile(GTEST_H_SEED)
-  output_file.close()
-
-
-def FuseGTestAllCcToFile(gtest_root, output_file):
-  """Scans folder gtest_root to generate gtest/gtest-all.cc in output_file."""
-
-  processed_files = set()
-
-  def ProcessFile(gtest_source_file):
-    """Processes the given gtest source file."""
-
-    # We don't process the same #included file twice.
-    if gtest_source_file in processed_files:
-      return
-
-    processed_files.add(gtest_source_file)
-
-    # Reads each line in the given gtest source file.
-    for line in open(os.path.join(gtest_root, gtest_source_file), 'r'):
-      m = INCLUDE_GTEST_FILE_REGEX.match(line)
-      if m:
-        if 'include/' + m.group(1) == GTEST_SPI_H_SEED:
-          # It's '#include "gtest/gtest-spi.h"'.  This file is not
-          # #included by "gtest/gtest.h", so we need to process it.
-          ProcessFile(GTEST_SPI_H_SEED)
-        else:
-          # It's '#include "gtest/foo.h"' where foo is not gtest-spi.
-          # We treat it as '#include "gtest/gtest.h"', as all other
-          # gtest headers are being fused into gtest.h and cannot be
-          # #included directly.
-
-          # There is no need to #include "gtest/gtest.h" more than once.
-          if not GTEST_H_SEED in processed_files:
-            processed_files.add(GTEST_H_SEED)
-            output_file.write('#include "%s"\n' % (GTEST_H_OUTPUT,))
-      else:
-        m = INCLUDE_SRC_FILE_REGEX.match(line)
-        if m:
-          # It's '#include "src/foo"' - let's process it recursively.
-          ProcessFile(m.group(1))
-        else:
-          output_file.write(line)
-
-  ProcessFile(GTEST_ALL_CC_SEED)
-
-
-def FuseGTestAllCc(gtest_root, output_dir):
-  """Scans folder gtest_root to generate gtest/gtest-all.cc in output_dir."""
-
-  output_file = open(os.path.join(output_dir, GTEST_ALL_CC_OUTPUT), 'w')
-  FuseGTestAllCcToFile(gtest_root, output_file)
-  output_file.close()
-
-
-def FuseGTest(gtest_root, output_dir):
-  """Fuses gtest.h and gtest-all.cc."""
-
-  ValidateGTestRootDir(gtest_root)
-  ValidateOutputDir(output_dir)
-
-  FuseGTestH(gtest_root, output_dir)
-  FuseGTestAllCc(gtest_root, output_dir)
-
-
-def main():
-  argc = len(sys.argv)
-  if argc == 2:
-    # fuse_gtest_files.py OUTPUT_DIR
-    FuseGTest(DEFAULT_GTEST_ROOT_DIR, sys.argv[1])
-  elif argc == 3:
-    # fuse_gtest_files.py GTEST_ROOT_DIR OUTPUT_DIR
-    FuseGTest(sys.argv[1], sys.argv[2])
-  else:
-    print(__doc__)
-    sys.exit(1)
-
-
-if __name__ == '__main__':
-  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gen_gtest_pred_impl.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gen_gtest_pred_impl.py
deleted file mode 100755
index 3e7ab042..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gen_gtest_pred_impl.py
+++ /dev/null
@@ -1,730 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2006, 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.
-
-"""gen_gtest_pred_impl.py v0.1
-
-Generates the implementation of Google Test predicate assertions and
-accompanying tests.
-
-Usage:
-
-  gen_gtest_pred_impl.py MAX_ARITY
-
-where MAX_ARITY is a positive integer.
-
-The command generates the implementation of up-to MAX_ARITY-ary
-predicate assertions, and writes it to file gtest_pred_impl.h in the
-directory where the script is.  It also generates the accompanying
-unit test in file gtest_pred_impl_unittest.cc.
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import sys
-import time
-
-# Where this script is.
-SCRIPT_DIR = os.path.dirname(sys.argv[0])
-
-# Where to store the generated header.
-HEADER = os.path.join(SCRIPT_DIR, '../include/gtest/gtest_pred_impl.h')
-
-# Where to store the generated unit test.
-UNIT_TEST = os.path.join(SCRIPT_DIR, '../test/gtest_pred_impl_unittest.cc')
-
-
-def HeaderPreamble(n):
-  """Returns the preamble for the header file.
-
-  Args:
-    n:  the maximum arity of the predicate macros to be generated.
-  """
-
-  # A map that defines the values used in the preamble template.
-  DEFS = {
-    'today' : time.strftime('%m/%d/%Y'),
-    'year' : time.strftime('%Y'),
-    'command' : '%s %s' % (os.path.basename(sys.argv[0]), n),
-    'n' : n
-    }
-
-  return (
-"""// Copyright 2006, 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.
-
-// This file is AUTOMATICALLY GENERATED on %(today)s by command
-// '%(command)s'.  DO NOT EDIT BY HAND!
-//
-// Implements a family of generic predicate assertion macros.
-
-#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
-#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
-
-// Makes sure this header is not included before gtest.h.
-#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
-# error Do not include gtest_pred_impl.h directly.  Include gtest.h instead.
-#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
-
-// This header implements a family of generic predicate assertion
-// macros:
-//
-//   ASSERT_PRED_FORMAT1(pred_format, v1)
-//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
-//   ...
-//
-// where pred_format is a function or functor that takes n (in the
-// case of ASSERT_PRED_FORMATn) values and their source expression
-// text, and returns a testing::AssertionResult.  See the definition
-// of ASSERT_EQ in gtest.h for an example.
-//
-// If you don't care about formatting, you can use the more
-// restrictive version:
-//
-//   ASSERT_PRED1(pred, v1)
-//   ASSERT_PRED2(pred, v1, v2)
-//   ...
-//
-// where pred is an n-ary function or functor that returns bool,
-// and the values v1, v2, ..., must support the << operator for
-// streaming to std::ostream.
-//
-// We also define the EXPECT_* variations.
-//
-// For now we only support predicates whose arity is at most %(n)s.
-// Please email googletestframework@googlegroups.com if you need
-// support for higher arities.
-
-// GTEST_ASSERT_ is the basic statement to which all of the assertions
-// in this file reduce.  Don't use this in your code.
-
-#define GTEST_ASSERT_(expression, on_failure) \\
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \\
-  if (const ::testing::AssertionResult gtest_ar = (expression)) \\
-    ; \\
-  else \\
-    on_failure(gtest_ar.failure_message())
-""" % DEFS)
-
-
-def Arity(n):
-  """Returns the English name of the given arity."""
-
-  if n < 0:
-    return None
-  elif n <= 3:
-    return ['nullary', 'unary', 'binary', 'ternary'][n]
-  else:
-    return '%s-ary' % n
-
-
-def Title(word):
-  """Returns the given word in title case.  The difference between
-  this and string's title() method is that Title('4-ary') is '4-ary'
-  while '4-ary'.title() is '4-Ary'."""
-
-  return word[0].upper() + word[1:]
-
-
-def OneTo(n):
-  """Returns the list [1, 2, 3, ..., n]."""
-
-  return range(1, n + 1)
-
-
-def Iter(n, format, sep=''):
-  """Given a positive integer n, a format string that contains 0 or
-  more '%s' format specs, and optionally a separator string, returns
-  the join of n strings, each formatted with the format string on an
-  iterator ranged from 1 to n.
-
-  Example:
-
-  Iter(3, 'v%s', sep=', ') returns 'v1, v2, v3'.
-  """
-
-  # How many '%s' specs are in format?
-  spec_count = len(format.split('%s')) - 1
-  return sep.join([format % (spec_count * (i,)) for i in OneTo(n)])
-
-
-def ImplementationForArity(n):
-  """Returns the implementation of n-ary predicate assertions."""
-
-  # A map the defines the values used in the implementation template.
-  DEFS = {
-    'n' : str(n),
-    'vs' : Iter(n, 'v%s', sep=', '),
-    'vts' : Iter(n, '#v%s', sep=', '),
-    'arity' : Arity(n),
-    'Arity' : Title(Arity(n))
-    }
-
-  impl = """
-
-// Helper function for implementing {EXPECT|ASSERT}_PRED%(n)s.  Don't use
-// this in your code.
-template <typename Pred""" % DEFS
-
-  impl += Iter(n, """,
-          typename T%s""")
-
-  impl += """>
-AssertionResult AssertPred%(n)sHelper(const char* pred_text""" % DEFS
-
-  impl += Iter(n, """,
-                                  const char* e%s""")
-
-  impl += """,
-                                  Pred pred"""
-
-  impl += Iter(n, """,
-                                  const T%s& v%s""")
-
-  impl += """) {
-  if (pred(%(vs)s)) return AssertionSuccess();
-
-""" % DEFS
-
-  impl += '  return AssertionFailure() << pred_text << "("'
-
-  impl += Iter(n, """
-                            << e%s""", sep=' << ", "')
-
-  impl += ' << ") evaluates to false, where"'
-
-  impl += Iter(n, """
-                            << "\\n" << e%s << " evaluates to " << v%s""")
-
-  impl += """;
-}
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT%(n)s.
-// Don't use this in your code.
-#define GTEST_PRED_FORMAT%(n)s_(pred_format, %(vs)s, on_failure)\\
-  GTEST_ASSERT_(pred_format(%(vts)s, %(vs)s), \\
-                on_failure)
-
-// Internal macro for implementing {EXPECT|ASSERT}_PRED%(n)s.  Don't use
-// this in your code.
-#define GTEST_PRED%(n)s_(pred, %(vs)s, on_failure)\\
-  GTEST_ASSERT_(::testing::AssertPred%(n)sHelper(#pred""" % DEFS
-
-  impl += Iter(n, """, \\
-                                             #v%s""")
-
-  impl += """, \\
-                                             pred"""
-
-  impl += Iter(n, """, \\
-                                             v%s""")
-
-  impl += """), on_failure)
-
-// %(Arity)s predicate assertion macros.
-#define EXPECT_PRED_FORMAT%(n)s(pred_format, %(vs)s) \\
-  GTEST_PRED_FORMAT%(n)s_(pred_format, %(vs)s, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED%(n)s(pred, %(vs)s) \\
-  GTEST_PRED%(n)s_(pred, %(vs)s, GTEST_NONFATAL_FAILURE_)
-#define ASSERT_PRED_FORMAT%(n)s(pred_format, %(vs)s) \\
-  GTEST_PRED_FORMAT%(n)s_(pred_format, %(vs)s, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED%(n)s(pred, %(vs)s) \\
-  GTEST_PRED%(n)s_(pred, %(vs)s, GTEST_FATAL_FAILURE_)
-
-""" % DEFS
-
-  return impl
-
-
-def HeaderPostamble():
-  """Returns the postamble for the header file."""
-
-  return """
-
-#endif  // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
-"""
-
-
-def GenerateFile(path, content):
-  """Given a file path and a content string, overwrites it with the
-  given content."""
-
-  print 'Updating file %s . . .' % path
-
-  f = file(path, 'w+')
-  print >>f, content,
-  f.close()
-
-  print 'File %s has been updated.' % path
-
-
-def GenerateHeader(n):
-  """Given the maximum arity n, updates the header file that implements
-  the predicate assertions."""
-
-  GenerateFile(HEADER,
-               HeaderPreamble(n)
-               + ''.join([ImplementationForArity(i) for i in OneTo(n)])
-               + HeaderPostamble())
-
-
-def UnitTestPreamble():
-  """Returns the preamble for the unit test file."""
-
-  # A map that defines the values used in the preamble template.
-  DEFS = {
-    'today' : time.strftime('%m/%d/%Y'),
-    'year' : time.strftime('%Y'),
-    'command' : '%s %s' % (os.path.basename(sys.argv[0]), sys.argv[1]),
-    }
-
-  return (
-"""// Copyright 2006, 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.
-
-// This file is AUTOMATICALLY GENERATED on %(today)s by command
-// '%(command)s'.  DO NOT EDIT BY HAND!
-
-// Regression test for gtest_pred_impl.h
-//
-// This file is generated by a script and quite long.  If you intend to
-// learn how Google Test works by reading its unit tests, read
-// gtest_unittest.cc instead.
-//
-// This is intended as a regression test for the Google Test predicate
-// assertions.  We compile it as part of the gtest_unittest target
-// only to keep the implementation tidy and compact, as it is quite
-// involved to set up the stage for testing Google Test using Google
-// Test itself.
-//
-// Currently, gtest_unittest takes ~11 seconds to run in the testing
-// daemon.  In the future, if it grows too large and needs much more
-// time to finish, we should consider separating this file into a
-// stand-alone regression test.
-
-#include <iostream>
-
-#include "gtest/gtest.h"
-#include "gtest/gtest-spi.h"
-
-// A user-defined data type.
-struct Bool {
-  explicit Bool(int val) : value(val != 0) {}
-
-  bool operator>(int n) const { return value > Bool(n).value; }
-
-  Bool operator+(const Bool& rhs) const { return Bool(value + rhs.value); }
-
-  bool operator==(const Bool& rhs) const { return value == rhs.value; }
-
-  bool value;
-};
-
-// Enables Bool to be used in assertions.
-std::ostream& operator<<(std::ostream& os, const Bool& x) {
-  return os << (x.value ? "true" : "false");
-}
-
-""" % DEFS)
-
-
-def TestsForArity(n):
-  """Returns the tests for n-ary predicate assertions."""
-
-  # A map that defines the values used in the template for the tests.
-  DEFS = {
-    'n' : n,
-    'es' : Iter(n, 'e%s', sep=', '),
-    'vs' : Iter(n, 'v%s', sep=', '),
-    'vts' : Iter(n, '#v%s', sep=', '),
-    'tvs' : Iter(n, 'T%s v%s', sep=', '),
-    'int_vs' : Iter(n, 'int v%s', sep=', '),
-    'Bool_vs' : Iter(n, 'Bool v%s', sep=', '),
-    'types' : Iter(n, 'typename T%s', sep=', '),
-    'v_sum' : Iter(n, 'v%s', sep=' + '),
-    'arity' : Arity(n),
-    'Arity' : Title(Arity(n)),
-    }
-
-  tests = (
-"""// Sample functions/functors for testing %(arity)s predicate assertions.
-
-// A %(arity)s predicate function.
-template <%(types)s>
-bool PredFunction%(n)s(%(tvs)s) {
-  return %(v_sum)s > 0;
-}
-
-// The following two functions are needed to circumvent a bug in
-// gcc 2.95.3, which sometimes has problem with the above template
-// function.
-bool PredFunction%(n)sInt(%(int_vs)s) {
-  return %(v_sum)s > 0;
-}
-bool PredFunction%(n)sBool(%(Bool_vs)s) {
-  return %(v_sum)s > 0;
-}
-""" % DEFS)
-
-  tests += """
-// A %(arity)s predicate functor.
-struct PredFunctor%(n)s {
-  template <%(types)s>
-  bool operator()(""" % DEFS
-
-  tests += Iter(n, 'const T%s& v%s', sep=""",
-                  """)
-
-  tests += """) {
-    return %(v_sum)s > 0;
-  }
-};
-""" % DEFS
-
-  tests += """
-// A %(arity)s predicate-formatter function.
-template <%(types)s>
-testing::AssertionResult PredFormatFunction%(n)s(""" % DEFS
-
-  tests += Iter(n, 'const char* e%s', sep=""",
-                                             """)
-
-  tests += Iter(n, """,
-                                             const T%s& v%s""")
-
-  tests += """) {
-  if (PredFunction%(n)s(%(vs)s))
-    return testing::AssertionSuccess();
-
-  return testing::AssertionFailure()
-      << """ % DEFS
-
-  tests += Iter(n, 'e%s', sep=' << " + " << ')
-
-  tests += """
-      << " is expected to be positive, but evaluates to "
-      << %(v_sum)s << ".";
-}
-""" % DEFS
-
-  tests += """
-// A %(arity)s predicate-formatter functor.
-struct PredFormatFunctor%(n)s {
-  template <%(types)s>
-  testing::AssertionResult operator()(""" % DEFS
-
-  tests += Iter(n, 'const char* e%s', sep=""",
-                                      """)
-
-  tests += Iter(n, """,
-                                      const T%s& v%s""")
-
-  tests += """) const {
-    return PredFormatFunction%(n)s(%(es)s, %(vs)s);
-  }
-};
-""" % DEFS
-
-  tests += """
-// Tests for {EXPECT|ASSERT}_PRED_FORMAT%(n)s.
-
-class Predicate%(n)sTest : public testing::Test {
- protected:
-  virtual void SetUp() {
-    expected_to_finish_ = true;
-    finished_ = false;""" % DEFS
-
-  tests += """
-    """ + Iter(n, 'n%s_ = ') + """0;
-  }
-"""
-
-  tests += """
-  virtual void TearDown() {
-    // Verifies that each of the predicate's arguments was evaluated
-    // exactly once."""
-
-  tests += ''.join(["""
-    EXPECT_EQ(1, n%s_) <<
-        "The predicate assertion didn't evaluate argument %s "
-        "exactly once.";""" % (i, i + 1) for i in OneTo(n)])
-
-  tests += """
-
-    // Verifies that the control flow in the test function is expected.
-    if (expected_to_finish_ && !finished_) {
-      FAIL() << "The predicate assertion unexpactedly aborted the test.";
-    } else if (!expected_to_finish_ && finished_) {
-      FAIL() << "The failed predicate assertion didn't abort the test "
-                "as expected.";
-    }
-  }
-
-  // true iff the test function is expected to run to finish.
-  static bool expected_to_finish_;
-
-  // true iff the test function did run to finish.
-  static bool finished_;
-""" % DEFS
-
-  tests += Iter(n, """
-  static int n%s_;""")
-
-  tests += """
-};
-
-bool Predicate%(n)sTest::expected_to_finish_;
-bool Predicate%(n)sTest::finished_;
-""" % DEFS
-
-  tests += Iter(n, """int Predicate%%(n)sTest::n%s_;
-""") % DEFS
-
-  tests += """
-typedef Predicate%(n)sTest EXPECT_PRED_FORMAT%(n)sTest;
-typedef Predicate%(n)sTest ASSERT_PRED_FORMAT%(n)sTest;
-typedef Predicate%(n)sTest EXPECT_PRED%(n)sTest;
-typedef Predicate%(n)sTest ASSERT_PRED%(n)sTest;
-""" % DEFS
-
-  def GenTest(use_format, use_assert, expect_failure,
-              use_functor, use_user_type):
-    """Returns the test for a predicate assertion macro.
-
-    Args:
-      use_format:     true iff the assertion is a *_PRED_FORMAT*.
-      use_assert:     true iff the assertion is a ASSERT_*.
-      expect_failure: true iff the assertion is expected to fail.
-      use_functor:    true iff the first argument of the assertion is
-                      a functor (as opposed to a function)
-      use_user_type:  true iff the predicate functor/function takes
-                      argument(s) of a user-defined type.
-
-    Example:
-
-      GenTest(1, 0, 0, 1, 0) returns a test that tests the behavior
-      of a successful EXPECT_PRED_FORMATn() that takes a functor
-      whose arguments have built-in types."""
-
-    if use_assert:
-      assrt = 'ASSERT'  # 'assert' is reserved, so we cannot use
-                        # that identifier here.
-    else:
-      assrt = 'EXPECT'
-
-    assertion = assrt + '_PRED'
-
-    if use_format:
-      pred_format = 'PredFormat'
-      assertion += '_FORMAT'
-    else:
-      pred_format = 'Pred'
-
-    assertion += '%(n)s' % DEFS
-
-    if use_functor:
-      pred_format_type = 'functor'
-      pred_format += 'Functor%(n)s()'
-    else:
-      pred_format_type = 'function'
-      pred_format += 'Function%(n)s'
-      if not use_format:
-        if use_user_type:
-          pred_format += 'Bool'
-        else:
-          pred_format += 'Int'
-
-    test_name = pred_format_type.title()
-
-    if use_user_type:
-      arg_type = 'user-defined type (Bool)'
-      test_name += 'OnUserType'
-      if expect_failure:
-        arg = 'Bool(n%s_++)'
-      else:
-        arg = 'Bool(++n%s_)'
-    else:
-      arg_type = 'built-in type (int)'
-      test_name += 'OnBuiltInType'
-      if expect_failure:
-        arg = 'n%s_++'
-      else:
-        arg = '++n%s_'
-
-    if expect_failure:
-      successful_or_failed = 'failed'
-      expected_or_not = 'expected.'
-      test_name +=  'Failure'
-    else:
-      successful_or_failed = 'successful'
-      expected_or_not = 'UNEXPECTED!'
-      test_name +=  'Success'
-
-    # A map that defines the values used in the test template.
-    defs = DEFS.copy()
-    defs.update({
-      'assert' : assrt,
-      'assertion' : assertion,
-      'test_name' : test_name,
-      'pf_type' : pred_format_type,
-      'pf' : pred_format,
-      'arg_type' : arg_type,
-      'arg' : arg,
-      'successful' : successful_or_failed,
-      'expected' : expected_or_not,
-      })
-
-    test = """
-// Tests a %(successful)s %(assertion)s where the
-// predicate-formatter is a %(pf_type)s on a %(arg_type)s.
-TEST_F(%(assertion)sTest, %(test_name)s) {""" % defs
-
-    indent = (len(assertion) + 3)*' '
-    extra_indent = ''
-
-    if expect_failure:
-      extra_indent = '  '
-      if use_assert:
-        test += """
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT"""
-      else:
-        test += """
-  EXPECT_NONFATAL_FAILURE({  // NOLINT"""
-
-    test += '\n' + extra_indent + """  %(assertion)s(%(pf)s""" % defs
-
-    test = test % defs
-    test += Iter(n, ',\n' + indent + extra_indent + '%(arg)s' % defs)
-    test += ');\n' + extra_indent + '  finished_ = true;\n'
-
-    if expect_failure:
-      test += '  }, "");\n'
-
-    test += '}\n'
-    return test
-
-  # Generates tests for all 2**6 = 64 combinations.
-  tests += ''.join([GenTest(use_format, use_assert, expect_failure,
-                            use_functor, use_user_type)
-                    for use_format in [0, 1]
-                    for use_assert in [0, 1]
-                    for expect_failure in [0, 1]
-                    for use_functor in [0, 1]
-                    for use_user_type in [0, 1]
-                    ])
-
-  return tests
-
-
-def UnitTestPostamble():
-  """Returns the postamble for the tests."""
-
-  return ''
-
-
-def GenerateUnitTest(n):
-  """Returns the tests for up-to n-ary predicate assertions."""
-
-  GenerateFile(UNIT_TEST,
-               UnitTestPreamble()
-               + ''.join([TestsForArity(i) for i in OneTo(n)])
-               + UnitTestPostamble())
-
-
-def _Main():
-  """The entry point of the script.  Generates the header file and its
-  unit test."""
-
-  if len(sys.argv) != 2:
-    print __doc__
-    print 'Author: ' + __author__
-    sys.exit(1)
-
-  n = int(sys.argv[1])
-  GenerateHeader(n)
-  GenerateUnitTest(n)
-
-
-if __name__ == '__main__':
-  _Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gtest-config.in b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gtest-config.in
deleted file mode 100755
index 780f8432..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/gtest-config.in
+++ /dev/null
@@ -1,274 +0,0 @@
-#!/bin/sh
-
-# These variables are automatically filled in by the configure script.
-name="@PACKAGE_TARNAME@"
-version="@PACKAGE_VERSION@"
-
-show_usage()
-{
-  echo "Usage: gtest-config [OPTIONS...]"
-}
-
-show_help()
-{
-  show_usage
-  cat <<\EOF
-
-The `gtest-config' script provides access to the necessary compile and linking
-flags to connect with Google C++ Testing Framework, both in a build prior to
-installation, and on the system proper after installation. The installation
-overrides may be issued in combination with any other queries, but will only
-affect installation queries if called on a built but not installed gtest. The
-installation queries may not be issued with any other types of queries, and
-only one installation query may be made at a time. The version queries and
-compiler flag queries may be combined as desired but not mixed. Different
-version queries are always combined with logical "and" semantics, and only the
-last of any particular query is used while all previous ones ignored. All
-versions must be specified as a sequence of numbers separated by periods.
-Compiler flag queries output the union of the sets of flags when combined.
-
- Examples:
-  gtest-config --min-version=1.0 || echo "Insufficient Google Test version."
-
-  g++ $(gtest-config --cppflags --cxxflags) -o foo.o -c foo.cpp
-  g++ $(gtest-config --ldflags --libs) -o foo foo.o
-
-  # When using a built but not installed Google Test:
-  g++ $(../../my_gtest_build/scripts/gtest-config ...) ...
-
-  # When using an installed Google Test, but with installation overrides:
-  export GTEST_PREFIX="/opt"
-  g++ $(gtest-config --libdir="/opt/lib64" ...) ...
-
- Help:
-  --usage                    brief usage information
-  --help                     display this help message
-
- Installation Overrides:
-  --prefix=<dir>             overrides the installation prefix
-  --exec-prefix=<dir>        overrides the executable installation prefix
-  --libdir=<dir>             overrides the library installation prefix
-  --includedir=<dir>         overrides the header file installation prefix
-
- Installation Queries:
-  --prefix                   installation prefix
-  --exec-prefix              executable installation prefix
-  --libdir                   library installation directory
-  --includedir               header file installation directory
-  --version                  the version of the Google Test installation
-
- Version Queries:
-  --min-version=VERSION      return 0 if the version is at least VERSION
-  --exact-version=VERSION    return 0 if the version is exactly VERSION
-  --max-version=VERSION      return 0 if the version is at most VERSION
-
- Compilation Flag Queries:
-  --cppflags                 compile flags specific to the C-like preprocessors
-  --cxxflags                 compile flags appropriate for C++ programs
-  --ldflags                  linker flags
-  --libs                     libraries for linking
-
-EOF
-}
-
-# This function bounds our version with a min and a max. It uses some clever
-# POSIX-compliant variable expansion to portably do all the work in the shell
-# and avoid any dependency on a particular "sed" or "awk" implementation.
-# Notable is that it will only ever compare the first 3 components of versions.
-# Further components will be cleanly stripped off. All versions must be
-# unadorned, so "v1.0" will *not* work. The minimum version must be in $1, and
-# the max in $2. TODO(chandlerc@google.com): If this ever breaks, we should
-# investigate expanding this via autom4te from AS_VERSION_COMPARE rather than
-# continuing to maintain our own shell version.
-check_versions()
-{
-  major_version=${version%%.*}
-  minor_version="0"
-  point_version="0"
-  if test "${version#*.}" != "${version}"; then
-    minor_version=${version#*.}
-    minor_version=${minor_version%%.*}
-  fi
-  if test "${version#*.*.}" != "${version}"; then
-    point_version=${version#*.*.}
-    point_version=${point_version%%.*}
-  fi
-
-  min_version="$1"
-  min_major_version=${min_version%%.*}
-  min_minor_version="0"
-  min_point_version="0"
-  if test "${min_version#*.}" != "${min_version}"; then
-    min_minor_version=${min_version#*.}
-    min_minor_version=${min_minor_version%%.*}
-  fi
-  if test "${min_version#*.*.}" != "${min_version}"; then
-    min_point_version=${min_version#*.*.}
-    min_point_version=${min_point_version%%.*}
-  fi
-
-  max_version="$2"
-  max_major_version=${max_version%%.*}
-  max_minor_version="0"
-  max_point_version="0"
-  if test "${max_version#*.}" != "${max_version}"; then
-    max_minor_version=${max_version#*.}
-    max_minor_version=${max_minor_version%%.*}
-  fi
-  if test "${max_version#*.*.}" != "${max_version}"; then
-    max_point_version=${max_version#*.*.}
-    max_point_version=${max_point_version%%.*}
-  fi
-
-  test $(($major_version)) -lt $(($min_major_version)) && exit 1
-  if test $(($major_version)) -eq $(($min_major_version)); then
-    test $(($minor_version)) -lt $(($min_minor_version)) && exit 1
-    if test $(($minor_version)) -eq $(($min_minor_version)); then
-      test $(($point_version)) -lt $(($min_point_version)) && exit 1
-    fi
-  fi
-
-  test $(($major_version)) -gt $(($max_major_version)) && exit 1
-  if test $(($major_version)) -eq $(($max_major_version)); then
-    test $(($minor_version)) -gt $(($max_minor_version)) && exit 1
-    if test $(($minor_version)) -eq $(($max_minor_version)); then
-      test $(($point_version)) -gt $(($max_point_version)) && exit 1
-    fi
-  fi
-
-  exit 0
-}
-
-# Show the usage line when no arguments are specified.
-if test $# -eq 0; then
-  show_usage
-  exit 1
-fi
-
-while test $# -gt 0; do
-  case $1 in
-    --usage)          show_usage;         exit 0;;
-    --help)           show_help;          exit 0;;
-
-    # Installation overrides
-    --prefix=*)       GTEST_PREFIX=${1#--prefix=};;
-    --exec-prefix=*)  GTEST_EXEC_PREFIX=${1#--exec-prefix=};;
-    --libdir=*)       GTEST_LIBDIR=${1#--libdir=};;
-    --includedir=*)   GTEST_INCLUDEDIR=${1#--includedir=};;
-
-    # Installation queries
-    --prefix|--exec-prefix|--libdir|--includedir|--version)
-      if test -n "${do_query}"; then
-        show_usage
-        exit 1
-      fi
-      do_query=${1#--}
-      ;;
-
-    # Version checking
-    --min-version=*)
-      do_check_versions=yes
-      min_version=${1#--min-version=}
-      ;;
-    --max-version=*)
-      do_check_versions=yes
-      max_version=${1#--max-version=}
-      ;;
-    --exact-version=*)
-      do_check_versions=yes
-      exact_version=${1#--exact-version=}
-      ;;
-
-    # Compiler flag output
-    --cppflags)       echo_cppflags=yes;;
-    --cxxflags)       echo_cxxflags=yes;;
-    --ldflags)        echo_ldflags=yes;;
-    --libs)           echo_libs=yes;;
-
-    # Everything else is an error
-    *)                show_usage;         exit 1;;
-  esac
-  shift
-done
-
-# These have defaults filled in by the configure script but can also be
-# overridden by environment variables or command line parameters.
-prefix="${GTEST_PREFIX:-@prefix@}"
-exec_prefix="${GTEST_EXEC_PREFIX:-@exec_prefix@}"
-libdir="${GTEST_LIBDIR:-@libdir@}"
-includedir="${GTEST_INCLUDEDIR:-@includedir@}"
-
-# We try and detect if our binary is not located at its installed location. If
-# it's not, we provide variables pointing to the source and build tree rather
-# than to the install tree. This allows building against a just-built gtest
-# rather than an installed gtest.
-bindir="@bindir@"
-this_relative_bindir=`dirname $0`
-this_bindir=`cd ${this_relative_bindir}; pwd -P`
-if test "${this_bindir}" = "${this_bindir%${bindir}}"; then
-  # The path to the script doesn't end in the bindir sequence from Autoconf,
-  # assume that we are in a build tree.
-  build_dir=`dirname ${this_bindir}`
-  src_dir=`cd ${this_bindir}; cd @top_srcdir@; pwd -P`
-
-  # TODO(chandlerc@google.com): This is a dangerous dependency on libtool, we
-  # should work to remove it, and/or remove libtool altogether, replacing it
-  # with direct references to the library and a link path.
-  gtest_libs="${build_dir}/lib/libgtest.la @PTHREAD_CFLAGS@ @PTHREAD_LIBS@"
-  gtest_ldflags=""
-
-  # We provide hooks to include from either the source or build dir, where the
-  # build dir is always preferred. This will potentially allow us to write
-  # build rules for generated headers and have them automatically be preferred
-  # over provided versions.
-  gtest_cppflags="-I${build_dir}/include -I${src_dir}/include"
-  gtest_cxxflags="@PTHREAD_CFLAGS@"
-else
-  # We're using an installed gtest, although it may be staged under some
-  # prefix. Assume (as our own libraries do) that we can resolve the prefix,
-  # and are present in the dynamic link paths.
-  gtest_ldflags="-L${libdir}"
-  gtest_libs="-l${name} @PTHREAD_CFLAGS@ @PTHREAD_LIBS@"
-  gtest_cppflags="-I${includedir}"
-  gtest_cxxflags="@PTHREAD_CFLAGS@"
-fi
-
-# Do an installation query if requested.
-if test -n "$do_query"; then
-  case $do_query in
-    prefix)           echo $prefix;       exit 0;;
-    exec-prefix)      echo $exec_prefix;  exit 0;;
-    libdir)           echo $libdir;       exit 0;;
-    includedir)       echo $includedir;   exit 0;;
-    version)          echo $version;      exit 0;;
-    *)                show_usage;         exit 1;;
-  esac
-fi
-
-# Do a version check if requested.
-if test "$do_check_versions" = "yes"; then
-  # Make sure we didn't receive a bad combination of parameters.
-  test "$echo_cppflags" = "yes" && show_usage && exit 1
-  test "$echo_cxxflags" = "yes" && show_usage && exit 1
-  test "$echo_ldflags" = "yes"  && show_usage && exit 1
-  test "$echo_libs" = "yes"     && show_usage && exit 1
-
-  if test "$exact_version" != ""; then
-    check_versions $exact_version $exact_version
-    # unreachable
-  else
-    check_versions ${min_version:-0.0.0} ${max_version:-9999.9999.9999}
-    # unreachable
-  fi
-fi
-
-# Do the output in the correct order so that these can be used in-line of
-# a compiler invocation.
-output=""
-test "$echo_cppflags" = "yes" && output="$output $gtest_cppflags"
-test "$echo_cxxflags" = "yes" && output="$output $gtest_cxxflags"
-test "$echo_ldflags" = "yes"  && output="$output $gtest_ldflags"
-test "$echo_libs" = "yes"     && output="$output $gtest_libs"
-echo $output
-
-exit 0
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/pump.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/pump.py
deleted file mode 100755
index 5efb653c..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/pump.py
+++ /dev/null
@@ -1,855 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-
-"""pump v0.2.0 - Pretty Useful for Meta Programming.
-
-A tool for preprocessor meta programming.  Useful for generating
-repetitive boilerplate code.  Especially useful for writing C++
-classes, functions, macros, and templates that need to work with
-various number of arguments.
-
-USAGE:
-       pump.py SOURCE_FILE
-
-EXAMPLES:
-       pump.py foo.cc.pump
-         Converts foo.cc.pump to foo.cc.
-
-GRAMMAR:
-       CODE ::= ATOMIC_CODE*
-       ATOMIC_CODE ::= $var ID = EXPRESSION
-           | $var ID = [[ CODE ]]
-           | $range ID EXPRESSION..EXPRESSION
-           | $for ID SEPARATOR [[ CODE ]]
-           | $($)
-           | $ID
-           | $(EXPRESSION)
-           | $if EXPRESSION [[ CODE ]] ELSE_BRANCH
-           | [[ CODE ]]
-           | RAW_CODE
-       SEPARATOR ::= RAW_CODE | EMPTY
-       ELSE_BRANCH ::= $else [[ CODE ]]
-           | $elif EXPRESSION [[ CODE ]] ELSE_BRANCH
-           | EMPTY
-       EXPRESSION has Python syntax.
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import re
-import sys
-
-
-TOKEN_TABLE = [
-    (re.compile(r'\$var\s+'), '$var'),
-    (re.compile(r'\$elif\s+'), '$elif'),
-    (re.compile(r'\$else\s+'), '$else'),
-    (re.compile(r'\$for\s+'), '$for'),
-    (re.compile(r'\$if\s+'), '$if'),
-    (re.compile(r'\$range\s+'), '$range'),
-    (re.compile(r'\$[_A-Za-z]\w*'), '$id'),
-    (re.compile(r'\$\(\$\)'), '$($)'),
-    (re.compile(r'\$'), '$'),
-    (re.compile(r'\[\[\n?'), '[['),
-    (re.compile(r'\]\]\n?'), ']]'),
-    ]
-
-
-class Cursor:
-  """Represents a position (line and column) in a text file."""
-
-  def __init__(self, line=-1, column=-1):
-    self.line = line
-    self.column = column
-
-  def __eq__(self, rhs):
-    return self.line == rhs.line and self.column == rhs.column
-
-  def __ne__(self, rhs):
-    return not self == rhs
-
-  def __lt__(self, rhs):
-    return self.line < rhs.line or (
-        self.line == rhs.line and self.column < rhs.column)
-
-  def __le__(self, rhs):
-    return self < rhs or self == rhs
-
-  def __gt__(self, rhs):
-    return rhs < self
-
-  def __ge__(self, rhs):
-    return rhs <= self
-
-  def __str__(self):
-    if self == Eof():
-      return 'EOF'
-    else:
-      return '%s(%s)' % (self.line + 1, self.column)
-
-  def __add__(self, offset):
-    return Cursor(self.line, self.column + offset)
-
-  def __sub__(self, offset):
-    return Cursor(self.line, self.column - offset)
-
-  def Clone(self):
-    """Returns a copy of self."""
-
-    return Cursor(self.line, self.column)
-
-
-# Special cursor to indicate the end-of-file.
-def Eof():
-  """Returns the special cursor to denote the end-of-file."""
-  return Cursor(-1, -1)
-
-
-class Token:
-  """Represents a token in a Pump source file."""
-
-  def __init__(self, start=None, end=None, value=None, token_type=None):
-    if start is None:
-      self.start = Eof()
-    else:
-      self.start = start
-    if end is None:
-      self.end = Eof()
-    else:
-      self.end = end
-    self.value = value
-    self.token_type = token_type
-
-  def __str__(self):
-    return 'Token @%s: \'%s\' type=%s' % (
-        self.start, self.value, self.token_type)
-
-  def Clone(self):
-    """Returns a copy of self."""
-
-    return Token(self.start.Clone(), self.end.Clone(), self.value,
-                 self.token_type)
-
-
-def StartsWith(lines, pos, string):
-  """Returns True iff the given position in lines starts with 'string'."""
-
-  return lines[pos.line][pos.column:].startswith(string)
-
-
-def FindFirstInLine(line, token_table):
-  best_match_start = -1
-  for (regex, token_type) in token_table:
-    m = regex.search(line)
-    if m:
-      # We found regex in lines
-      if best_match_start < 0 or m.start() < best_match_start:
-        best_match_start = m.start()
-        best_match_length = m.end() - m.start()
-        best_match_token_type = token_type
-
-  if best_match_start < 0:
-    return None
-
-  return (best_match_start, best_match_length, best_match_token_type)
-
-
-def FindFirst(lines, token_table, cursor):
-  """Finds the first occurrence of any string in strings in lines."""
-
-  start = cursor.Clone()
-  cur_line_number = cursor.line
-  for line in lines[start.line:]:
-    if cur_line_number == start.line:
-      line = line[start.column:]
-    m = FindFirstInLine(line, token_table)
-    if m:
-      # We found a regex in line.
-      (start_column, length, token_type) = m
-      if cur_line_number == start.line:
-        start_column += start.column
-      found_start = Cursor(cur_line_number, start_column)
-      found_end = found_start + length
-      return MakeToken(lines, found_start, found_end, token_type)
-    cur_line_number += 1
-  # We failed to find str in lines
-  return None
-
-
-def SubString(lines, start, end):
-  """Returns a substring in lines."""
-
-  if end == Eof():
-    end = Cursor(len(lines) - 1, len(lines[-1]))
-
-  if start >= end:
-    return ''
-
-  if start.line == end.line:
-    return lines[start.line][start.column:end.column]
-
-  result_lines = ([lines[start.line][start.column:]] +
-                  lines[start.line + 1:end.line] +
-                  [lines[end.line][:end.column]])
-  return ''.join(result_lines)
-
-
-def StripMetaComments(str):
-  """Strip meta comments from each line in the given string."""
-
-  # First, completely remove lines containing nothing but a meta
-  # comment, including the trailing \n.
-  str = re.sub(r'^\s*\$\$.*\n', '', str)
-
-  # Then, remove meta comments from contentful lines.
-  return re.sub(r'\s*\$\$.*', '', str)
-
-
-def MakeToken(lines, start, end, token_type):
-  """Creates a new instance of Token."""
-
-  return Token(start, end, SubString(lines, start, end), token_type)
-
-
-def ParseToken(lines, pos, regex, token_type):
-  line = lines[pos.line][pos.column:]
-  m = regex.search(line)
-  if m and not m.start():
-    return MakeToken(lines, pos, pos + m.end(), token_type)
-  else:
-    print 'ERROR: %s expected at %s.' % (token_type, pos)
-    sys.exit(1)
-
-
-ID_REGEX = re.compile(r'[_A-Za-z]\w*')
-EQ_REGEX = re.compile(r'=')
-REST_OF_LINE_REGEX = re.compile(r'.*?(?=$|\$\$)')
-OPTIONAL_WHITE_SPACES_REGEX = re.compile(r'\s*')
-WHITE_SPACE_REGEX = re.compile(r'\s')
-DOT_DOT_REGEX = re.compile(r'\.\.')
-
-
-def Skip(lines, pos, regex):
-  line = lines[pos.line][pos.column:]
-  m = re.search(regex, line)
-  if m and not m.start():
-    return pos + m.end()
-  else:
-    return pos
-
-
-def SkipUntil(lines, pos, regex, token_type):
-  line = lines[pos.line][pos.column:]
-  m = re.search(regex, line)
-  if m:
-    return pos + m.start()
-  else:
-    print ('ERROR: %s expected on line %s after column %s.' %
-           (token_type, pos.line + 1, pos.column))
-    sys.exit(1)
-
-
-def ParseExpTokenInParens(lines, pos):
-  def ParseInParens(pos):
-    pos = Skip(lines, pos, OPTIONAL_WHITE_SPACES_REGEX)
-    pos = Skip(lines, pos, r'\(')
-    pos = Parse(pos)
-    pos = Skip(lines, pos, r'\)')
-    return pos
-
-  def Parse(pos):
-    pos = SkipUntil(lines, pos, r'\(|\)', ')')
-    if SubString(lines, pos, pos + 1) == '(':
-      pos = Parse(pos + 1)
-      pos = Skip(lines, pos, r'\)')
-      return Parse(pos)
-    else:
-      return pos
-
-  start = pos.Clone()
-  pos = ParseInParens(pos)
-  return MakeToken(lines, start, pos, 'exp')
-
-
-def RStripNewLineFromToken(token):
-  if token.value.endswith('\n'):
-    return Token(token.start, token.end, token.value[:-1], token.token_type)
-  else:
-    return token
-
-
-def TokenizeLines(lines, pos):
-  while True:
-    found = FindFirst(lines, TOKEN_TABLE, pos)
-    if not found:
-      yield MakeToken(lines, pos, Eof(), 'code')
-      return
-
-    if found.start == pos:
-      prev_token = None
-      prev_token_rstripped = None
-    else:
-      prev_token = MakeToken(lines, pos, found.start, 'code')
-      prev_token_rstripped = RStripNewLineFromToken(prev_token)
-
-    if found.token_type == '$var':
-      if prev_token_rstripped:
-        yield prev_token_rstripped
-      yield found
-      id_token = ParseToken(lines, found.end, ID_REGEX, 'id')
-      yield id_token
-      pos = Skip(lines, id_token.end, OPTIONAL_WHITE_SPACES_REGEX)
-
-      eq_token = ParseToken(lines, pos, EQ_REGEX, '=')
-      yield eq_token
-      pos = Skip(lines, eq_token.end, r'\s*')
-
-      if SubString(lines, pos, pos + 2) != '[[':
-        exp_token = ParseToken(lines, pos, REST_OF_LINE_REGEX, 'exp')
-        yield exp_token
-        pos = Cursor(exp_token.end.line + 1, 0)
-    elif found.token_type == '$for':
-      if prev_token_rstripped:
-        yield prev_token_rstripped
-      yield found
-      id_token = ParseToken(lines, found.end, ID_REGEX, 'id')
-      yield id_token
-      pos = Skip(lines, id_token.end, WHITE_SPACE_REGEX)
-    elif found.token_type == '$range':
-      if prev_token_rstripped:
-        yield prev_token_rstripped
-      yield found
-      id_token = ParseToken(lines, found.end, ID_REGEX, 'id')
-      yield id_token
-      pos = Skip(lines, id_token.end, OPTIONAL_WHITE_SPACES_REGEX)
-
-      dots_pos = SkipUntil(lines, pos, DOT_DOT_REGEX, '..')
-      yield MakeToken(lines, pos, dots_pos, 'exp')
-      yield MakeToken(lines, dots_pos, dots_pos + 2, '..')
-      pos = dots_pos + 2
-      new_pos = Cursor(pos.line + 1, 0)
-      yield MakeToken(lines, pos, new_pos, 'exp')
-      pos = new_pos
-    elif found.token_type == '$':
-      if prev_token:
-        yield prev_token
-      yield found
-      exp_token = ParseExpTokenInParens(lines, found.end)
-      yield exp_token
-      pos = exp_token.end
-    elif (found.token_type == ']]' or found.token_type == '$if' or
-          found.token_type == '$elif' or found.token_type == '$else'):
-      if prev_token_rstripped:
-        yield prev_token_rstripped
-      yield found
-      pos = found.end
-    else:
-      if prev_token:
-        yield prev_token
-      yield found
-      pos = found.end
-
-
-def Tokenize(s):
-  """A generator that yields the tokens in the given string."""
-  if s != '':
-    lines = s.splitlines(True)
-    for token in TokenizeLines(lines, Cursor(0, 0)):
-      yield token
-
-
-class CodeNode:
-  def __init__(self, atomic_code_list=None):
-    self.atomic_code = atomic_code_list
-
-
-class VarNode:
-  def __init__(self, identifier=None, atomic_code=None):
-    self.identifier = identifier
-    self.atomic_code = atomic_code
-
-
-class RangeNode:
-  def __init__(self, identifier=None, exp1=None, exp2=None):
-    self.identifier = identifier
-    self.exp1 = exp1
-    self.exp2 = exp2
-
-
-class ForNode:
-  def __init__(self, identifier=None, sep=None, code=None):
-    self.identifier = identifier
-    self.sep = sep
-    self.code = code
-
-
-class ElseNode:
-  def __init__(self, else_branch=None):
-    self.else_branch = else_branch
-
-
-class IfNode:
-  def __init__(self, exp=None, then_branch=None, else_branch=None):
-    self.exp = exp
-    self.then_branch = then_branch
-    self.else_branch = else_branch
-
-
-class RawCodeNode:
-  def __init__(self, token=None):
-    self.raw_code = token
-
-
-class LiteralDollarNode:
-  def __init__(self, token):
-    self.token = token
-
-
-class ExpNode:
-  def __init__(self, token, python_exp):
-    self.token = token
-    self.python_exp = python_exp
-
-
-def PopFront(a_list):
-  head = a_list[0]
-  a_list[:1] = []
-  return head
-
-
-def PushFront(a_list, elem):
-  a_list[:0] = [elem]
-
-
-def PopToken(a_list, token_type=None):
-  token = PopFront(a_list)
-  if token_type is not None and token.token_type != token_type:
-    print 'ERROR: %s expected at %s' % (token_type, token.start)
-    print 'ERROR: %s found instead' % (token,)
-    sys.exit(1)
-
-  return token
-
-
-def PeekToken(a_list):
-  if not a_list:
-    return None
-
-  return a_list[0]
-
-
-def ParseExpNode(token):
-  python_exp = re.sub(r'([_A-Za-z]\w*)', r'self.GetValue("\1")', token.value)
-  return ExpNode(token, python_exp)
-
-
-def ParseElseNode(tokens):
-  def Pop(token_type=None):
-    return PopToken(tokens, token_type)
-
-  next = PeekToken(tokens)
-  if not next:
-    return None
-  if next.token_type == '$else':
-    Pop('$else')
-    Pop('[[')
-    code_node = ParseCodeNode(tokens)
-    Pop(']]')
-    return code_node
-  elif next.token_type == '$elif':
-    Pop('$elif')
-    exp = Pop('code')
-    Pop('[[')
-    code_node = ParseCodeNode(tokens)
-    Pop(']]')
-    inner_else_node = ParseElseNode(tokens)
-    return CodeNode([IfNode(ParseExpNode(exp), code_node, inner_else_node)])
-  elif not next.value.strip():
-    Pop('code')
-    return ParseElseNode(tokens)
-  else:
-    return None
-
-
-def ParseAtomicCodeNode(tokens):
-  def Pop(token_type=None):
-    return PopToken(tokens, token_type)
-
-  head = PopFront(tokens)
-  t = head.token_type
-  if t == 'code':
-    return RawCodeNode(head)
-  elif t == '$var':
-    id_token = Pop('id')
-    Pop('=')
-    next = PeekToken(tokens)
-    if next.token_type == 'exp':
-      exp_token = Pop()
-      return VarNode(id_token, ParseExpNode(exp_token))
-    Pop('[[')
-    code_node = ParseCodeNode(tokens)
-    Pop(']]')
-    return VarNode(id_token, code_node)
-  elif t == '$for':
-    id_token = Pop('id')
-    next_token = PeekToken(tokens)
-    if next_token.token_type == 'code':
-      sep_token = next_token
-      Pop('code')
-    else:
-      sep_token = None
-    Pop('[[')
-    code_node = ParseCodeNode(tokens)
-    Pop(']]')
-    return ForNode(id_token, sep_token, code_node)
-  elif t == '$if':
-    exp_token = Pop('code')
-    Pop('[[')
-    code_node = ParseCodeNode(tokens)
-    Pop(']]')
-    else_node = ParseElseNode(tokens)
-    return IfNode(ParseExpNode(exp_token), code_node, else_node)
-  elif t == '$range':
-    id_token = Pop('id')
-    exp1_token = Pop('exp')
-    Pop('..')
-    exp2_token = Pop('exp')
-    return RangeNode(id_token, ParseExpNode(exp1_token),
-                     ParseExpNode(exp2_token))
-  elif t == '$id':
-    return ParseExpNode(Token(head.start + 1, head.end, head.value[1:], 'id'))
-  elif t == '$($)':
-    return LiteralDollarNode(head)
-  elif t == '$':
-    exp_token = Pop('exp')
-    return ParseExpNode(exp_token)
-  elif t == '[[':
-    code_node = ParseCodeNode(tokens)
-    Pop(']]')
-    return code_node
-  else:
-    PushFront(tokens, head)
-    return None
-
-
-def ParseCodeNode(tokens):
-  atomic_code_list = []
-  while True:
-    if not tokens:
-      break
-    atomic_code_node = ParseAtomicCodeNode(tokens)
-    if atomic_code_node:
-      atomic_code_list.append(atomic_code_node)
-    else:
-      break
-  return CodeNode(atomic_code_list)
-
-
-def ParseToAST(pump_src_text):
-  """Convert the given Pump source text into an AST."""
-  tokens = list(Tokenize(pump_src_text))
-  code_node = ParseCodeNode(tokens)
-  return code_node
-
-
-class Env:
-  def __init__(self):
-    self.variables = []
-    self.ranges = []
-
-  def Clone(self):
-    clone = Env()
-    clone.variables = self.variables[:]
-    clone.ranges = self.ranges[:]
-    return clone
-
-  def PushVariable(self, var, value):
-    # If value looks like an int, store it as an int.
-    try:
-      int_value = int(value)
-      if ('%s' % int_value) == value:
-        value = int_value
-    except Exception:
-      pass
-    self.variables[:0] = [(var, value)]
-
-  def PopVariable(self):
-    self.variables[:1] = []
-
-  def PushRange(self, var, lower, upper):
-    self.ranges[:0] = [(var, lower, upper)]
-
-  def PopRange(self):
-    self.ranges[:1] = []
-
-  def GetValue(self, identifier):
-    for (var, value) in self.variables:
-      if identifier == var:
-        return value
-
-    print 'ERROR: meta variable %s is undefined.' % (identifier,)
-    sys.exit(1)
-
-  def EvalExp(self, exp):
-    try:
-      result = eval(exp.python_exp)
-    except Exception, e:
-      print 'ERROR: caught exception %s: %s' % (e.__class__.__name__, e)
-      print ('ERROR: failed to evaluate meta expression %s at %s' %
-             (exp.python_exp, exp.token.start))
-      sys.exit(1)
-    return result
-
-  def GetRange(self, identifier):
-    for (var, lower, upper) in self.ranges:
-      if identifier == var:
-        return (lower, upper)
-
-    print 'ERROR: range %s is undefined.' % (identifier,)
-    sys.exit(1)
-
-
-class Output:
-  def __init__(self):
-    self.string = ''
-
-  def GetLastLine(self):
-    index = self.string.rfind('\n')
-    if index < 0:
-      return ''
-
-    return self.string[index + 1:]
-
-  def Append(self, s):
-    self.string += s
-
-
-def RunAtomicCode(env, node, output):
-  if isinstance(node, VarNode):
-    identifier = node.identifier.value.strip()
-    result = Output()
-    RunAtomicCode(env.Clone(), node.atomic_code, result)
-    value = result.string
-    env.PushVariable(identifier, value)
-  elif isinstance(node, RangeNode):
-    identifier = node.identifier.value.strip()
-    lower = int(env.EvalExp(node.exp1))
-    upper = int(env.EvalExp(node.exp2))
-    env.PushRange(identifier, lower, upper)
-  elif isinstance(node, ForNode):
-    identifier = node.identifier.value.strip()
-    if node.sep is None:
-      sep = ''
-    else:
-      sep = node.sep.value
-    (lower, upper) = env.GetRange(identifier)
-    for i in range(lower, upper + 1):
-      new_env = env.Clone()
-      new_env.PushVariable(identifier, i)
-      RunCode(new_env, node.code, output)
-      if i != upper:
-        output.Append(sep)
-  elif isinstance(node, RawCodeNode):
-    output.Append(node.raw_code.value)
-  elif isinstance(node, IfNode):
-    cond = env.EvalExp(node.exp)
-    if cond:
-      RunCode(env.Clone(), node.then_branch, output)
-    elif node.else_branch is not None:
-      RunCode(env.Clone(), node.else_branch, output)
-  elif isinstance(node, ExpNode):
-    value = env.EvalExp(node)
-    output.Append('%s' % (value,))
-  elif isinstance(node, LiteralDollarNode):
-    output.Append('$')
-  elif isinstance(node, CodeNode):
-    RunCode(env.Clone(), node, output)
-  else:
-    print 'BAD'
-    print node
-    sys.exit(1)
-
-
-def RunCode(env, code_node, output):
-  for atomic_code in code_node.atomic_code:
-    RunAtomicCode(env, atomic_code, output)
-
-
-def IsSingleLineComment(cur_line):
-  return '//' in cur_line
-
-
-def IsInPreprocessorDirective(prev_lines, cur_line):
-  if cur_line.lstrip().startswith('#'):
-    return True
-  return prev_lines and prev_lines[-1].endswith('\\')
-
-
-def WrapComment(line, output):
-  loc = line.find('//')
-  before_comment = line[:loc].rstrip()
-  if before_comment == '':
-    indent = loc
-  else:
-    output.append(before_comment)
-    indent = len(before_comment) - len(before_comment.lstrip())
-  prefix = indent*' ' + '// '
-  max_len = 80 - len(prefix)
-  comment = line[loc + 2:].strip()
-  segs = [seg for seg in re.split(r'(\w+\W*)', comment) if seg != '']
-  cur_line = ''
-  for seg in segs:
-    if len((cur_line + seg).rstrip()) < max_len:
-      cur_line += seg
-    else:
-      if cur_line.strip() != '':
-        output.append(prefix + cur_line.rstrip())
-      cur_line = seg.lstrip()
-  if cur_line.strip() != '':
-    output.append(prefix + cur_line.strip())
-
-
-def WrapCode(line, line_concat, output):
-  indent = len(line) - len(line.lstrip())
-  prefix = indent*' '  # Prefix of the current line
-  max_len = 80 - indent - len(line_concat)  # Maximum length of the current line
-  new_prefix = prefix + 4*' '  # Prefix of a continuation line
-  new_max_len = max_len - 4  # Maximum length of a continuation line
-  # Prefers to wrap a line after a ',' or ';'.
-  segs = [seg for seg in re.split(r'([^,;]+[,;]?)', line.strip()) if seg != '']
-  cur_line = ''  # The current line without leading spaces.
-  for seg in segs:
-    # If the line is still too long, wrap at a space.
-    while cur_line == '' and len(seg.strip()) > max_len:
-      seg = seg.lstrip()
-      split_at = seg.rfind(' ', 0, max_len)
-      output.append(prefix + seg[:split_at].strip() + line_concat)
-      seg = seg[split_at + 1:]
-      prefix = new_prefix
-      max_len = new_max_len
-
-    if len((cur_line + seg).rstrip()) < max_len:
-      cur_line = (cur_line + seg).lstrip()
-    else:
-      output.append(prefix + cur_line.rstrip() + line_concat)
-      prefix = new_prefix
-      max_len = new_max_len
-      cur_line = seg.lstrip()
-  if cur_line.strip() != '':
-    output.append(prefix + cur_line.strip())
-
-
-def WrapPreprocessorDirective(line, output):
-  WrapCode(line, ' \\', output)
-
-
-def WrapPlainCode(line, output):
-  WrapCode(line, '', output)
-
-
-def IsMultiLineIWYUPragma(line):
-  return re.search(r'/\* IWYU pragma: ', line)
-
-
-def IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
-  return (re.match(r'^#(ifndef|define|endif\s*//)\s*[\w_]+\s*$', line) or
-          re.match(r'^#include\s', line) or
-          # Don't break IWYU pragmas, either; that causes iwyu.py problems.
-          re.search(r'// IWYU pragma: ', line))
-
-
-def WrapLongLine(line, output):
-  line = line.rstrip()
-  if len(line) <= 80:
-    output.append(line)
-  elif IsSingleLineComment(line):
-    if IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
-      # The style guide made an exception to allow long header guard lines,
-      # includes and IWYU pragmas.
-      output.append(line)
-    else:
-      WrapComment(line, output)
-  elif IsInPreprocessorDirective(output, line):
-    if IsHeaderGuardIncludeOrOneLineIWYUPragma(line):
-      # The style guide made an exception to allow long header guard lines,
-      # includes and IWYU pragmas.
-      output.append(line)
-    else:
-      WrapPreprocessorDirective(line, output)
-  elif IsMultiLineIWYUPragma(line):
-    output.append(line)
-  else:
-    WrapPlainCode(line, output)
-
-
-def BeautifyCode(string):
-  lines = string.splitlines()
-  output = []
-  for line in lines:
-    WrapLongLine(line, output)
-  output2 = [line.rstrip() for line in output]
-  return '\n'.join(output2) + '\n'
-
-
-def ConvertFromPumpSource(src_text):
-  """Return the text generated from the given Pump source text."""
-  ast = ParseToAST(StripMetaComments(src_text))
-  output = Output()
-  RunCode(Env(), ast, output)
-  return BeautifyCode(output.string)
-
-
-def main(argv):
-  if len(argv) == 1:
-    print __doc__
-    sys.exit(1)
-
-  file_path = argv[-1]
-  output_str = ConvertFromPumpSource(file(file_path, 'r').read())
-  if file_path.endswith('.pump'):
-    output_file_path = file_path[:-5]
-  else:
-    output_file_path = '-'
-  if output_file_path == '-':
-    print output_str,
-  else:
-    output_file = file(output_file_path, 'w')
-    output_file.write('// This file was GENERATED by command:\n')
-    output_file.write('//     %s %s\n' %
-                      (os.path.basename(__file__), os.path.basename(file_path)))
-    output_file.write('// DO NOT EDIT BY HAND!!!\n\n')
-    output_file.write(output_str)
-    output_file.close()
-
-
-if __name__ == '__main__':
-  main(sys.argv)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/release_docs.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/release_docs.py
deleted file mode 100755
index 1291347f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/release_docs.py
+++ /dev/null
@@ -1,158 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2013 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.
-
-"""Script for branching Google Test/Mock wiki pages for a new version.
-
-SYNOPSIS
-       release_docs.py NEW_RELEASE_VERSION
-
-       Google Test and Google Mock's external user documentation is in
-       interlinked wiki files.  When we release a new version of
-       Google Test or Google Mock, we need to branch the wiki files
-       such that users of a specific version of Google Test/Mock can
-       look up documenation relevant for that version.  This script
-       automates that process by:
-
-         - branching the current wiki pages (which document the
-           behavior of the SVN trunk head) to pages for the specified
-           version (e.g. branching FAQ.wiki to V2_6_FAQ.wiki when
-           NEW_RELEASE_VERSION is 2.6);
-         - updating the links in the branched files to point to the branched
-           version (e.g. a link in V2_6_FAQ.wiki that pointed to
-           Primer.wiki#Anchor will now point to V2_6_Primer.wiki#Anchor).
-
-       NOTE: NEW_RELEASE_VERSION must be a NEW version number for
-       which the wiki pages don't yet exist; otherwise you'll get SVN
-       errors like "svn: Path 'V1_7_PumpManual.wiki' is not a
-       directory" when running the script.
-
-EXAMPLE
-       $ cd PATH/TO/GTEST_SVN_WORKSPACE/trunk
-       $ scripts/release_docs.py 2.6  # create wiki pages for v2.6
-       $ svn status                   # verify the file list
-       $ svn diff                     # verify the file contents
-       $ svn commit -m "release wiki pages for v2.6"
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import re
-import sys
-
-import common
-
-
-# Wiki pages that shouldn't be branched for every gtest/gmock release.
-GTEST_UNVERSIONED_WIKIS = ['DevGuide.wiki']
-GMOCK_UNVERSIONED_WIKIS = [
-    'DesignDoc.wiki',
-    'DevGuide.wiki',
-    'KnownIssues.wiki'
-    ]
-
-
-def DropWikiSuffix(wiki_filename):
-  """Removes the .wiki suffix (if any) from the given filename."""
-
-  return (wiki_filename[:-len('.wiki')] if wiki_filename.endswith('.wiki')
-          else wiki_filename)
-
-
-class WikiBrancher(object):
-  """Branches ..."""
-
-  def __init__(self, dot_version):
-    self.project, svn_root_path = common.GetSvnInfo()
-    if self.project not in ('googletest', 'googlemock'):
-      sys.exit('This script must be run in a gtest or gmock SVN workspace.')
-    self.wiki_dir = svn_root_path + '/wiki'
-    # Turn '2.6' to 'V2_6_'.
-    self.version_prefix = 'V' + dot_version.replace('.', '_') + '_'
-    self.files_to_branch = self.GetFilesToBranch()
-    page_names = [DropWikiSuffix(f) for f in self.files_to_branch]
-    # A link to Foo.wiki is in one of the following forms:
-    #   [Foo words]
-    #   [Foo#Anchor words]
-    #   [http://code.google.com/.../wiki/Foo words]
-    #   [http://code.google.com/.../wiki/Foo#Anchor words]
-    # We want to replace 'Foo' with 'V2_6_Foo' in the above cases.
-    self.search_for_re = re.compile(
-        # This regex matches either
-        #   [Foo
-        # or
-        #   /wiki/Foo
-        # followed by a space or a #, where Foo is the name of an
-        # unversioned wiki page.
-        r'(\[|/wiki/)(%s)([ #])' % '|'.join(page_names))
-    self.replace_with = r'\1%s\2\3' % (self.version_prefix,)
-
-  def GetFilesToBranch(self):
-    """Returns a list of .wiki file names that need to be branched."""
-
-    unversioned_wikis = (GTEST_UNVERSIONED_WIKIS if self.project == 'googletest'
-                         else GMOCK_UNVERSIONED_WIKIS)
-    return [f for f in os.listdir(self.wiki_dir)
-            if (f.endswith('.wiki') and
-                not re.match(r'^V\d', f) and  # Excluded versioned .wiki files.
-                f not in unversioned_wikis)]
-
-  def BranchFiles(self):
-    """Branches the .wiki files needed to be branched."""
-
-    print 'Branching %d .wiki files:' % (len(self.files_to_branch),)
-    os.chdir(self.wiki_dir)
-    for f in self.files_to_branch:
-      command = 'svn cp %s %s%s' % (f, self.version_prefix, f)
-      print command
-      os.system(command)
-
-  def UpdateLinksInBranchedFiles(self):
-
-    for f in self.files_to_branch:
-      source_file = os.path.join(self.wiki_dir, f)
-      versioned_file = os.path.join(self.wiki_dir, self.version_prefix + f)
-      print 'Updating links in %s.' % (versioned_file,)
-      text = file(source_file, 'r').read()
-      new_text = self.search_for_re.sub(self.replace_with, text)
-      file(versioned_file, 'w').write(new_text)
-
-
-def main():
-  if len(sys.argv) != 2:
-    sys.exit(__doc__)
-
-  brancher = WikiBrancher(sys.argv[1])
-  brancher.BranchFiles()
-  brancher.UpdateLinksInBranchedFiles()
-
-
-if __name__ == '__main__':
-  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/test/Makefile b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/test/Makefile
deleted file mode 100644
index cdff5846..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/test/Makefile
+++ /dev/null
@@ -1,59 +0,0 @@
-# A Makefile for fusing Google Test and building a sample test against it.
-#
-# SYNOPSIS:
-#
-#   make [all]  - makes everything.
-#   make TARGET - makes the given target.
-#   make check  - makes everything and runs the built sample test.
-#   make clean  - removes all files generated by make.
-
-# Points to the root of fused Google Test, relative to where this file is.
-FUSED_GTEST_DIR = output
-
-# Paths to the fused gtest files.
-FUSED_GTEST_H = $(FUSED_GTEST_DIR)/gtest/gtest.h
-FUSED_GTEST_ALL_CC = $(FUSED_GTEST_DIR)/gtest/gtest-all.cc
-
-# Where to find the sample test.
-SAMPLE_DIR = ../../samples
-
-# Where to find gtest_main.cc.
-GTEST_MAIN_CC = ../../src/gtest_main.cc
-
-# Flags passed to the preprocessor.
-# We have no idea here whether pthreads is available in the system, so
-# disable its use.
-CPPFLAGS += -I$(FUSED_GTEST_DIR) -DGTEST_HAS_PTHREAD=0
-
-# Flags passed to the C++ compiler.
-CXXFLAGS += -g
-
-all : sample1_unittest
-
-check : all
-	./sample1_unittest
-
-clean :
-	rm -rf $(FUSED_GTEST_DIR) sample1_unittest *.o
-
-$(FUSED_GTEST_H) :
-	../fuse_gtest_files.py $(FUSED_GTEST_DIR)
-
-$(FUSED_GTEST_ALL_CC) :
-	../fuse_gtest_files.py $(FUSED_GTEST_DIR)
-
-gtest-all.o : $(FUSED_GTEST_H) $(FUSED_GTEST_ALL_CC)
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(FUSED_GTEST_DIR)/gtest/gtest-all.cc
-
-gtest_main.o : $(FUSED_GTEST_H) $(GTEST_MAIN_CC)
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(GTEST_MAIN_CC)
-
-sample1.o : $(SAMPLE_DIR)/sample1.cc $(SAMPLE_DIR)/sample1.h
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(SAMPLE_DIR)/sample1.cc
-
-sample1_unittest.o : $(SAMPLE_DIR)/sample1_unittest.cc \
-                     $(SAMPLE_DIR)/sample1.h $(FUSED_GTEST_H)
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(SAMPLE_DIR)/sample1_unittest.cc
-
-sample1_unittest : sample1.o sample1_unittest.o gtest-all.o gtest_main.o
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) $^ -o $@
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload.py
deleted file mode 100755
index 6e6f9a14..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload.py
+++ /dev/null
@@ -1,1387 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2007 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Tool for uploading diffs from a version control system to the codereview app.
-
-Usage summary: upload.py [options] [-- diff_options]
-
-Diff options are passed to the diff command of the underlying system.
-
-Supported version control systems:
-  Git
-  Mercurial
-  Subversion
-
-It is important for Git/Mercurial users to specify a tree/node/branch to diff
-against by using the '--rev' option.
-"""
-# This code is derived from appcfg.py in the App Engine SDK (open source),
-# and from ASPN recipe #146306.
-
-import cookielib
-import getpass
-import logging
-import md5
-import mimetypes
-import optparse
-import os
-import re
-import socket
-import subprocess
-import sys
-import urllib
-import urllib2
-import urlparse
-
-try:
-  import readline
-except ImportError:
-  pass
-
-# The logging verbosity:
-#  0: Errors only.
-#  1: Status messages.
-#  2: Info logs.
-#  3: Debug logs.
-verbosity = 1
-
-# Max size of patch or base file.
-MAX_UPLOAD_SIZE = 900 * 1024
-
-
-def GetEmail(prompt):
-  """Prompts the user for their email address and returns it.
-
-  The last used email address is saved to a file and offered up as a suggestion
-  to the user. If the user presses enter without typing in anything the last
-  used email address is used. If the user enters a new address, it is saved
-  for next time we prompt.
-
-  """
-  last_email_file_name = os.path.expanduser("~/.last_codereview_email_address")
-  last_email = ""
-  if os.path.exists(last_email_file_name):
-    try:
-      last_email_file = open(last_email_file_name, "r")
-      last_email = last_email_file.readline().strip("\n")
-      last_email_file.close()
-      prompt += " [%s]" % last_email
-    except IOError, e:
-      pass
-  email = raw_input(prompt + ": ").strip()
-  if email:
-    try:
-      last_email_file = open(last_email_file_name, "w")
-      last_email_file.write(email)
-      last_email_file.close()
-    except IOError, e:
-      pass
-  else:
-    email = last_email
-  return email
-
-
-def StatusUpdate(msg):
-  """Print a status message to stdout.
-
-  If 'verbosity' is greater than 0, print the message.
-
-  Args:
-    msg: The string to print.
-  """
-  if verbosity > 0:
-    print msg
-
-
-def ErrorExit(msg):
-  """Print an error message to stderr and exit."""
-  print >>sys.stderr, msg
-  sys.exit(1)
-
-
-class ClientLoginError(urllib2.HTTPError):
-  """Raised to indicate there was an error authenticating with ClientLogin."""
-
-  def __init__(self, url, code, msg, headers, args):
-    urllib2.HTTPError.__init__(self, url, code, msg, headers, None)
-    self.args = args
-    self.reason = args["Error"]
-
-
-class AbstractRpcServer(object):
-  """Provides a common interface for a simple RPC server."""
-
-  def __init__(self, host, auth_function, host_override=None, extra_headers={},
-               save_cookies=False):
-    """Creates a new HttpRpcServer.
-
-    Args:
-      host: The host to send requests to.
-      auth_function: A function that takes no arguments and returns an
-        (email, password) tuple when called. Will be called if authentication
-        is required.
-      host_override: The host header to send to the server (defaults to host).
-      extra_headers: A dict of extra headers to append to every request.
-      save_cookies: If True, save the authentication cookies to local disk.
-        If False, use an in-memory cookiejar instead.  Subclasses must
-        implement this functionality.  Defaults to False.
-    """
-    self.host = host
-    self.host_override = host_override
-    self.auth_function = auth_function
-    self.authenticated = False
-    self.extra_headers = extra_headers
-    self.save_cookies = save_cookies
-    self.opener = self._GetOpener()
-    if self.host_override:
-      logging.info("Server: %s; Host: %s", self.host, self.host_override)
-    else:
-      logging.info("Server: %s", self.host)
-
-  def _GetOpener(self):
-    """Returns an OpenerDirector for making HTTP requests.
-
-    Returns:
-      A urllib2.OpenerDirector object.
-    """
-    raise NotImplementedError()
-
-  def _CreateRequest(self, url, data=None):
-    """Creates a new urllib request."""
-    logging.debug("Creating request for: '%s' with payload:\n%s", url, data)
-    req = urllib2.Request(url, data=data)
-    if self.host_override:
-      req.add_header("Host", self.host_override)
-    for key, value in self.extra_headers.iteritems():
-      req.add_header(key, value)
-    return req
-
-  def _GetAuthToken(self, email, password):
-    """Uses ClientLogin to authenticate the user, returning an auth token.
-
-    Args:
-      email:    The user's email address
-      password: The user's password
-
-    Raises:
-      ClientLoginError: If there was an error authenticating with ClientLogin.
-      HTTPError: If there was some other form of HTTP error.
-
-    Returns:
-      The authentication token returned by ClientLogin.
-    """
-    account_type = "GOOGLE"
-    if self.host.endswith(".google.com"):
-      # Needed for use inside Google.
-      account_type = "HOSTED"
-    req = self._CreateRequest(
-        url="https://www.google.com/accounts/ClientLogin",
-        data=urllib.urlencode({
-            "Email": email,
-            "Passwd": password,
-            "service": "ah",
-            "source": "rietveld-codereview-upload",
-            "accountType": account_type,
-        }),
-    )
-    try:
-      response = self.opener.open(req)
-      response_body = response.read()
-      response_dict = dict(x.split("=")
-                           for x in response_body.split("\n") if x)
-      return response_dict["Auth"]
-    except urllib2.HTTPError, e:
-      if e.code == 403:
-        body = e.read()
-        response_dict = dict(x.split("=", 1) for x in body.split("\n") if x)
-        raise ClientLoginError(req.get_full_url(), e.code, e.msg,
-                               e.headers, response_dict)
-      else:
-        raise
-
-  def _GetAuthCookie(self, auth_token):
-    """Fetches authentication cookies for an authentication token.
-
-    Args:
-      auth_token: The authentication token returned by ClientLogin.
-
-    Raises:
-      HTTPError: If there was an error fetching the authentication cookies.
-    """
-    # This is a dummy value to allow us to identify when we're successful.
-    continue_location = "http://localhost/"
-    args = {"continue": continue_location, "auth": auth_token}
-    req = self._CreateRequest("http://%s/_ah/login?%s" %
-                              (self.host, urllib.urlencode(args)))
-    try:
-      response = self.opener.open(req)
-    except urllib2.HTTPError, e:
-      response = e
-    if (response.code != 302 or
-        response.info()["location"] != continue_location):
-      raise urllib2.HTTPError(req.get_full_url(), response.code, response.msg,
-                              response.headers, response.fp)
-    self.authenticated = True
-
-  def _Authenticate(self):
-    """Authenticates the user.
-
-    The authentication process works as follows:
-     1) We get a username and password from the user
-     2) We use ClientLogin to obtain an AUTH token for the user
-        (see http://code.google.com/apis/accounts/AuthForInstalledApps.html).
-     3) We pass the auth token to /_ah/login on the server to obtain an
-        authentication cookie. If login was successful, it tries to redirect
-        us to the URL we provided.
-
-    If we attempt to access the upload API without first obtaining an
-    authentication cookie, it returns a 401 response and directs us to
-    authenticate ourselves with ClientLogin.
-    """
-    for i in range(3):
-      credentials = self.auth_function()
-      try:
-        auth_token = self._GetAuthToken(credentials[0], credentials[1])
-      except ClientLoginError, e:
-        if e.reason == "BadAuthentication":
-          print >>sys.stderr, "Invalid username or password."
-          continue
-        if e.reason == "CaptchaRequired":
-          print >>sys.stderr, (
-              "Please go to\n"
-              "https://www.google.com/accounts/DisplayUnlockCaptcha\n"
-              "and verify you are a human.  Then try again.")
-          break
-        if e.reason == "NotVerified":
-          print >>sys.stderr, "Account not verified."
-          break
-        if e.reason == "TermsNotAgreed":
-          print >>sys.stderr, "User has not agreed to TOS."
-          break
-        if e.reason == "AccountDeleted":
-          print >>sys.stderr, "The user account has been deleted."
-          break
-        if e.reason == "AccountDisabled":
-          print >>sys.stderr, "The user account has been disabled."
-          break
-        if e.reason == "ServiceDisabled":
-          print >>sys.stderr, ("The user's access to the service has been "
-                               "disabled.")
-          break
-        if e.reason == "ServiceUnavailable":
-          print >>sys.stderr, "The service is not available; try again later."
-          break
-        raise
-      self._GetAuthCookie(auth_token)
-      return
-
-  def Send(self, request_path, payload=None,
-           content_type="application/octet-stream",
-           timeout=None,
-           **kwargs):
-    """Sends an RPC and returns the response.
-
-    Args:
-      request_path: The path to send the request to, eg /api/appversion/create.
-      payload: The body of the request, or None to send an empty request.
-      content_type: The Content-Type header to use.
-      timeout: timeout in seconds; default None i.e. no timeout.
-        (Note: for large requests on OS X, the timeout doesn't work right.)
-      kwargs: Any keyword arguments are converted into query string parameters.
-
-    Returns:
-      The response body, as a string.
-    """
-    # TODO: Don't require authentication.  Let the server say
-    # whether it is necessary.
-    if not self.authenticated:
-      self._Authenticate()
-
-    old_timeout = socket.getdefaulttimeout()
-    socket.setdefaulttimeout(timeout)
-    try:
-      tries = 0
-      while True:
-        tries += 1
-        args = dict(kwargs)
-        url = "http://%s%s" % (self.host, request_path)
-        if args:
-          url += "?" + urllib.urlencode(args)
-        req = self._CreateRequest(url=url, data=payload)
-        req.add_header("Content-Type", content_type)
-        try:
-          f = self.opener.open(req)
-          response = f.read()
-          f.close()
-          return response
-        except urllib2.HTTPError, e:
-          if tries > 3:
-            raise
-          elif e.code == 401:
-            self._Authenticate()
-##           elif e.code >= 500 and e.code < 600:
-##             # Server Error - try again.
-##             continue
-          else:
-            raise
-    finally:
-      socket.setdefaulttimeout(old_timeout)
-
-
-class HttpRpcServer(AbstractRpcServer):
-  """Provides a simplified RPC-style interface for HTTP requests."""
-
-  def _Authenticate(self):
-    """Save the cookie jar after authentication."""
-    super(HttpRpcServer, self)._Authenticate()
-    if self.save_cookies:
-      StatusUpdate("Saving authentication cookies to %s" % self.cookie_file)
-      self.cookie_jar.save()
-
-  def _GetOpener(self):
-    """Returns an OpenerDirector that supports cookies and ignores redirects.
-
-    Returns:
-      A urllib2.OpenerDirector object.
-    """
-    opener = urllib2.OpenerDirector()
-    opener.add_handler(urllib2.ProxyHandler())
-    opener.add_handler(urllib2.UnknownHandler())
-    opener.add_handler(urllib2.HTTPHandler())
-    opener.add_handler(urllib2.HTTPDefaultErrorHandler())
-    opener.add_handler(urllib2.HTTPSHandler())
-    opener.add_handler(urllib2.HTTPErrorProcessor())
-    if self.save_cookies:
-      self.cookie_file = os.path.expanduser("~/.codereview_upload_cookies")
-      self.cookie_jar = cookielib.MozillaCookieJar(self.cookie_file)
-      if os.path.exists(self.cookie_file):
-        try:
-          self.cookie_jar.load()
-          self.authenticated = True
-          StatusUpdate("Loaded authentication cookies from %s" %
-                       self.cookie_file)
-        except (cookielib.LoadError, IOError):
-          # Failed to load cookies - just ignore them.
-          pass
-      else:
-        # Create an empty cookie file with mode 600
-        fd = os.open(self.cookie_file, os.O_CREAT, 0600)
-        os.close(fd)
-      # Always chmod the cookie file
-      os.chmod(self.cookie_file, 0600)
-    else:
-      # Don't save cookies across runs of update.py.
-      self.cookie_jar = cookielib.CookieJar()
-    opener.add_handler(urllib2.HTTPCookieProcessor(self.cookie_jar))
-    return opener
-
-
-parser = optparse.OptionParser(usage="%prog [options] [-- diff_options]")
-parser.add_option("-y", "--assume_yes", action="store_true",
-                  dest="assume_yes", default=False,
-                  help="Assume that the answer to yes/no questions is 'yes'.")
-# Logging
-group = parser.add_option_group("Logging options")
-group.add_option("-q", "--quiet", action="store_const", const=0,
-                 dest="verbose", help="Print errors only.")
-group.add_option("-v", "--verbose", action="store_const", const=2,
-                 dest="verbose", default=1,
-                 help="Print info level logs (default).")
-group.add_option("--noisy", action="store_const", const=3,
-                 dest="verbose", help="Print all logs.")
-# Review server
-group = parser.add_option_group("Review server options")
-group.add_option("-s", "--server", action="store", dest="server",
-                 default="codereview.appspot.com",
-                 metavar="SERVER",
-                 help=("The server to upload to. The format is host[:port]. "
-                       "Defaults to 'codereview.appspot.com'."))
-group.add_option("-e", "--email", action="store", dest="email",
-                 metavar="EMAIL", default=None,
-                 help="The username to use. Will prompt if omitted.")
-group.add_option("-H", "--host", action="store", dest="host",
-                 metavar="HOST", default=None,
-                 help="Overrides the Host header sent with all RPCs.")
-group.add_option("--no_cookies", action="store_false",
-                 dest="save_cookies", default=True,
-                 help="Do not save authentication cookies to local disk.")
-# Issue
-group = parser.add_option_group("Issue options")
-group.add_option("-d", "--description", action="store", dest="description",
-                 metavar="DESCRIPTION", default=None,
-                 help="Optional description when creating an issue.")
-group.add_option("-f", "--description_file", action="store",
-                 dest="description_file", metavar="DESCRIPTION_FILE",
-                 default=None,
-                 help="Optional path of a file that contains "
-                      "the description when creating an issue.")
-group.add_option("-r", "--reviewers", action="store", dest="reviewers",
-                 metavar="REVIEWERS", default=None,
-                 help="Add reviewers (comma separated email addresses).")
-group.add_option("--cc", action="store", dest="cc",
-                 metavar="CC", default=None,
-                 help="Add CC (comma separated email addresses).")
-# Upload options
-group = parser.add_option_group("Patch options")
-group.add_option("-m", "--message", action="store", dest="message",
-                 metavar="MESSAGE", default=None,
-                 help="A message to identify the patch. "
-                      "Will prompt if omitted.")
-group.add_option("-i", "--issue", type="int", action="store",
-                 metavar="ISSUE", default=None,
-                 help="Issue number to which to add. Defaults to new issue.")
-group.add_option("--download_base", action="store_true",
-                 dest="download_base", default=False,
-                 help="Base files will be downloaded by the server "
-                 "(side-by-side diffs may not work on files with CRs).")
-group.add_option("--rev", action="store", dest="revision",
-                 metavar="REV", default=None,
-                 help="Branch/tree/revision to diff against (used by DVCS).")
-group.add_option("--send_mail", action="store_true",
-                 dest="send_mail", default=False,
-                 help="Send notification email to reviewers.")
-
-
-def GetRpcServer(options):
-  """Returns an instance of an AbstractRpcServer.
-
-  Returns:
-    A new AbstractRpcServer, on which RPC calls can be made.
-  """
-
-  rpc_server_class = HttpRpcServer
-
-  def GetUserCredentials():
-    """Prompts the user for a username and password."""
-    email = options.email
-    if email is None:
-      email = GetEmail("Email (login for uploading to %s)" % options.server)
-    password = getpass.getpass("Password for %s: " % email)
-    return (email, password)
-
-  # If this is the dev_appserver, use fake authentication.
-  host = (options.host or options.server).lower()
-  if host == "localhost" or host.startswith("localhost:"):
-    email = options.email
-    if email is None:
-      email = "test@example.com"
-      logging.info("Using debug user %s.  Override with --email" % email)
-    server = rpc_server_class(
-        options.server,
-        lambda: (email, "password"),
-        host_override=options.host,
-        extra_headers={"Cookie":
-                       'dev_appserver_login="%s:False"' % email},
-        save_cookies=options.save_cookies)
-    # Don't try to talk to ClientLogin.
-    server.authenticated = True
-    return server
-
-  return rpc_server_class(options.server, GetUserCredentials,
-                          host_override=options.host,
-                          save_cookies=options.save_cookies)
-
-
-def EncodeMultipartFormData(fields, files):
-  """Encode form fields for multipart/form-data.
-
-  Args:
-    fields: A sequence of (name, value) elements for regular form fields.
-    files: A sequence of (name, filename, value) elements for data to be
-           uploaded as files.
-  Returns:
-    (content_type, body) ready for httplib.HTTP instance.
-
-  Source:
-    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/146306
-  """
-  BOUNDARY = '-M-A-G-I-C---B-O-U-N-D-A-R-Y-'
-  CRLF = '\r\n'
-  lines = []
-  for (key, value) in fields:
-    lines.append('--' + BOUNDARY)
-    lines.append('Content-Disposition: form-data; name="%s"' % key)
-    lines.append('')
-    lines.append(value)
-  for (key, filename, value) in files:
-    lines.append('--' + BOUNDARY)
-    lines.append('Content-Disposition: form-data; name="%s"; filename="%s"' %
-             (key, filename))
-    lines.append('Content-Type: %s' % GetContentType(filename))
-    lines.append('')
-    lines.append(value)
-  lines.append('--' + BOUNDARY + '--')
-  lines.append('')
-  body = CRLF.join(lines)
-  content_type = 'multipart/form-data; boundary=%s' % BOUNDARY
-  return content_type, body
-
-
-def GetContentType(filename):
-  """Helper to guess the content-type from the filename."""
-  return mimetypes.guess_type(filename)[0] or 'application/octet-stream'
-
-
-# Use a shell for subcommands on Windows to get a PATH search.
-use_shell = sys.platform.startswith("win")
-
-def RunShellWithReturnCode(command, print_output=False,
-                           universal_newlines=True):
-  """Executes a command and returns the output from stdout and the return code.
-
-  Args:
-    command: Command to execute.
-    print_output: If True, the output is printed to stdout.
-                  If False, both stdout and stderr are ignored.
-    universal_newlines: Use universal_newlines flag (default: True).
-
-  Returns:
-    Tuple (output, return code)
-  """
-  logging.info("Running %s", command)
-  p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                       shell=use_shell, universal_newlines=universal_newlines)
-  if print_output:
-    output_array = []
-    while True:
-      line = p.stdout.readline()
-      if not line:
-        break
-      print line.strip("\n")
-      output_array.append(line)
-    output = "".join(output_array)
-  else:
-    output = p.stdout.read()
-  p.wait()
-  errout = p.stderr.read()
-  if print_output and errout:
-    print >>sys.stderr, errout
-  p.stdout.close()
-  p.stderr.close()
-  return output, p.returncode
-
-
-def RunShell(command, silent_ok=False, universal_newlines=True,
-             print_output=False):
-  data, retcode = RunShellWithReturnCode(command, print_output,
-                                         universal_newlines)
-  if retcode:
-    ErrorExit("Got error status from %s:\n%s" % (command, data))
-  if not silent_ok and not data:
-    ErrorExit("No output from %s" % command)
-  return data
-
-
-class VersionControlSystem(object):
-  """Abstract base class providing an interface to the VCS."""
-
-  def __init__(self, options):
-    """Constructor.
-
-    Args:
-      options: Command line options.
-    """
-    self.options = options
-
-  def GenerateDiff(self, args):
-    """Return the current diff as a string.
-
-    Args:
-      args: Extra arguments to pass to the diff command.
-    """
-    raise NotImplementedError(
-        "abstract method -- subclass %s must override" % self.__class__)
-
-  def GetUnknownFiles(self):
-    """Return a list of files unknown to the VCS."""
-    raise NotImplementedError(
-        "abstract method -- subclass %s must override" % self.__class__)
-
-  def CheckForUnknownFiles(self):
-    """Show an "are you sure?" prompt if there are unknown files."""
-    unknown_files = self.GetUnknownFiles()
-    if unknown_files:
-      print "The following files are not added to version control:"
-      for line in unknown_files:
-        print line
-      prompt = "Are you sure to continue?(y/N) "
-      answer = raw_input(prompt).strip()
-      if answer != "y":
-        ErrorExit("User aborted")
-
-  def GetBaseFile(self, filename):
-    """Get the content of the upstream version of a file.
-
-    Returns:
-      A tuple (base_content, new_content, is_binary, status)
-        base_content: The contents of the base file.
-        new_content: For text files, this is empty.  For binary files, this is
-          the contents of the new file, since the diff output won't contain
-          information to reconstruct the current file.
-        is_binary: True iff the file is binary.
-        status: The status of the file.
-    """
-
-    raise NotImplementedError(
-        "abstract method -- subclass %s must override" % self.__class__)
-
-
-  def GetBaseFiles(self, diff):
-    """Helper that calls GetBase file for each file in the patch.
-
-    Returns:
-      A dictionary that maps from filename to GetBaseFile's tuple.  Filenames
-      are retrieved based on lines that start with "Index:" or
-      "Property changes on:".
-    """
-    files = {}
-    for line in diff.splitlines(True):
-      if line.startswith('Index:') or line.startswith('Property changes on:'):
-        unused, filename = line.split(':', 1)
-        # On Windows if a file has property changes its filename uses '\'
-        # instead of '/'.
-        filename = filename.strip().replace('\\', '/')
-        files[filename] = self.GetBaseFile(filename)
-    return files
-
-
-  def UploadBaseFiles(self, issue, rpc_server, patch_list, patchset, options,
-                      files):
-    """Uploads the base files (and if necessary, the current ones as well)."""
-
-    def UploadFile(filename, file_id, content, is_binary, status, is_base):
-      """Uploads a file to the server."""
-      file_too_large = False
-      if is_base:
-        type = "base"
-      else:
-        type = "current"
-      if len(content) > MAX_UPLOAD_SIZE:
-        print ("Not uploading the %s file for %s because it's too large." %
-               (type, filename))
-        file_too_large = True
-        content = ""
-      checksum = md5.new(content).hexdigest()
-      if options.verbose > 0 and not file_too_large:
-        print "Uploading %s file for %s" % (type, filename)
-      url = "/%d/upload_content/%d/%d" % (int(issue), int(patchset), file_id)
-      form_fields = [("filename", filename),
-                     ("status", status),
-                     ("checksum", checksum),
-                     ("is_binary", str(is_binary)),
-                     ("is_current", str(not is_base)),
-                    ]
-      if file_too_large:
-        form_fields.append(("file_too_large", "1"))
-      if options.email:
-        form_fields.append(("user", options.email))
-      ctype, body = EncodeMultipartFormData(form_fields,
-                                            [("data", filename, content)])
-      response_body = rpc_server.Send(url, body,
-                                      content_type=ctype)
-      if not response_body.startswith("OK"):
-        StatusUpdate("  --> %s" % response_body)
-        sys.exit(1)
-
-    patches = dict()
-    [patches.setdefault(v, k) for k, v in patch_list]
-    for filename in patches.keys():
-      base_content, new_content, is_binary, status = files[filename]
-      file_id_str = patches.get(filename)
-      if file_id_str.find("nobase") != -1:
-        base_content = None
-        file_id_str = file_id_str[file_id_str.rfind("_") + 1:]
-      file_id = int(file_id_str)
-      if base_content != None:
-        UploadFile(filename, file_id, base_content, is_binary, status, True)
-      if new_content != None:
-        UploadFile(filename, file_id, new_content, is_binary, status, False)
-
-  def IsImage(self, filename):
-    """Returns true if the filename has an image extension."""
-    mimetype =  mimetypes.guess_type(filename)[0]
-    if not mimetype:
-      return False
-    return mimetype.startswith("image/")
-
-
-class SubversionVCS(VersionControlSystem):
-  """Implementation of the VersionControlSystem interface for Subversion."""
-
-  def __init__(self, options):
-    super(SubversionVCS, self).__init__(options)
-    if self.options.revision:
-      match = re.match(r"(\d+)(:(\d+))?", self.options.revision)
-      if not match:
-        ErrorExit("Invalid Subversion revision %s." % self.options.revision)
-      self.rev_start = match.group(1)
-      self.rev_end = match.group(3)
-    else:
-      self.rev_start = self.rev_end = None
-    # Cache output from "svn list -r REVNO dirname".
-    # Keys: dirname, Values: 2-tuple (ouput for start rev and end rev).
-    self.svnls_cache = {}
-    # SVN base URL is required to fetch files deleted in an older revision.
-    # Result is cached to not guess it over and over again in GetBaseFile().
-    required = self.options.download_base or self.options.revision is not None
-    self.svn_base = self._GuessBase(required)
-
-  def GuessBase(self, required):
-    """Wrapper for _GuessBase."""
-    return self.svn_base
-
-  def _GuessBase(self, required):
-    """Returns the SVN base URL.
-
-    Args:
-      required: If true, exits if the url can't be guessed, otherwise None is
-        returned.
-    """
-    info = RunShell(["svn", "info"])
-    for line in info.splitlines():
-      words = line.split()
-      if len(words) == 2 and words[0] == "URL:":
-        url = words[1]
-        scheme, netloc, path, params, query, fragment = urlparse.urlparse(url)
-        username, netloc = urllib.splituser(netloc)
-        if username:
-          logging.info("Removed username from base URL")
-        if netloc.endswith("svn.python.org"):
-          if netloc == "svn.python.org":
-            if path.startswith("/projects/"):
-              path = path[9:]
-          elif netloc != "pythondev@svn.python.org":
-            ErrorExit("Unrecognized Python URL: %s" % url)
-          base = "http://svn.python.org/view/*checkout*%s/" % path
-          logging.info("Guessed Python base = %s", base)
-        elif netloc.endswith("svn.collab.net"):
-          if path.startswith("/repos/"):
-            path = path[6:]
-          base = "http://svn.collab.net/viewvc/*checkout*%s/" % path
-          logging.info("Guessed CollabNet base = %s", base)
-        elif netloc.endswith(".googlecode.com"):
-          path = path + "/"
-          base = urlparse.urlunparse(("http", netloc, path, params,
-                                      query, fragment))
-          logging.info("Guessed Google Code base = %s", base)
-        else:
-          path = path + "/"
-          base = urlparse.urlunparse((scheme, netloc, path, params,
-                                      query, fragment))
-          logging.info("Guessed base = %s", base)
-        return base
-    if required:
-      ErrorExit("Can't find URL in output from svn info")
-    return None
-
-  def GenerateDiff(self, args):
-    cmd = ["svn", "diff"]
-    if self.options.revision:
-      cmd += ["-r", self.options.revision]
-    cmd.extend(args)
-    data = RunShell(cmd)
-    count = 0
-    for line in data.splitlines():
-      if line.startswith("Index:") or line.startswith("Property changes on:"):
-        count += 1
-        logging.info(line)
-    if not count:
-      ErrorExit("No valid patches found in output from svn diff")
-    return data
-
-  def _CollapseKeywords(self, content, keyword_str):
-    """Collapses SVN keywords."""
-    # svn cat translates keywords but svn diff doesn't. As a result of this
-    # behavior patching.PatchChunks() fails with a chunk mismatch error.
-    # This part was originally written by the Review Board development team
-    # who had the same problem (http://reviews.review-board.org/r/276/).
-    # Mapping of keywords to known aliases
-    svn_keywords = {
-      # Standard keywords
-      'Date':                ['Date', 'LastChangedDate'],
-      'Revision':            ['Revision', 'LastChangedRevision', 'Rev'],
-      'Author':              ['Author', 'LastChangedBy'],
-      'HeadURL':             ['HeadURL', 'URL'],
-      'Id':                  ['Id'],
-
-      # Aliases
-      'LastChangedDate':     ['LastChangedDate', 'Date'],
-      'LastChangedRevision': ['LastChangedRevision', 'Rev', 'Revision'],
-      'LastChangedBy':       ['LastChangedBy', 'Author'],
-      'URL':                 ['URL', 'HeadURL'],
-    }
-
-    def repl(m):
-       if m.group(2):
-         return "$%s::%s$" % (m.group(1), " " * len(m.group(3)))
-       return "$%s$" % m.group(1)
-    keywords = [keyword
-                for name in keyword_str.split(" ")
-                for keyword in svn_keywords.get(name, [])]
-    return re.sub(r"\$(%s):(:?)([^\$]+)\$" % '|'.join(keywords), repl, content)
-
-  def GetUnknownFiles(self):
-    status = RunShell(["svn", "status", "--ignore-externals"], silent_ok=True)
-    unknown_files = []
-    for line in status.split("\n"):
-      if line and line[0] == "?":
-        unknown_files.append(line)
-    return unknown_files
-
-  def ReadFile(self, filename):
-    """Returns the contents of a file."""
-    file = open(filename, 'rb')
-    result = ""
-    try:
-      result = file.read()
-    finally:
-      file.close()
-    return result
-
-  def GetStatus(self, filename):
-    """Returns the status of a file."""
-    if not self.options.revision:
-      status = RunShell(["svn", "status", "--ignore-externals", filename])
-      if not status:
-        ErrorExit("svn status returned no output for %s" % filename)
-      status_lines = status.splitlines()
-      # If file is in a cl, the output will begin with
-      # "\n--- Changelist 'cl_name':\n".  See
-      # http://svn.collab.net/repos/svn/trunk/notes/changelist-design.txt
-      if (len(status_lines) == 3 and
-          not status_lines[0] and
-          status_lines[1].startswith("--- Changelist")):
-        status = status_lines[2]
-      else:
-        status = status_lines[0]
-    # If we have a revision to diff against we need to run "svn list"
-    # for the old and the new revision and compare the results to get
-    # the correct status for a file.
-    else:
-      dirname, relfilename = os.path.split(filename)
-      if dirname not in self.svnls_cache:
-        cmd = ["svn", "list", "-r", self.rev_start, dirname or "."]
-        out, returncode = RunShellWithReturnCode(cmd)
-        if returncode:
-          ErrorExit("Failed to get status for %s." % filename)
-        old_files = out.splitlines()
-        args = ["svn", "list"]
-        if self.rev_end:
-          args += ["-r", self.rev_end]
-        cmd = args + [dirname or "."]
-        out, returncode = RunShellWithReturnCode(cmd)
-        if returncode:
-          ErrorExit("Failed to run command %s" % cmd)
-        self.svnls_cache[dirname] = (old_files, out.splitlines())
-      old_files, new_files = self.svnls_cache[dirname]
-      if relfilename in old_files and relfilename not in new_files:
-        status = "D   "
-      elif relfilename in old_files and relfilename in new_files:
-        status = "M   "
-      else:
-        status = "A   "
-    return status
-
-  def GetBaseFile(self, filename):
-    status = self.GetStatus(filename)
-    base_content = None
-    new_content = None
-
-    # If a file is copied its status will be "A  +", which signifies
-    # "addition-with-history".  See "svn st" for more information.  We need to
-    # upload the original file or else diff parsing will fail if the file was
-    # edited.
-    if status[0] == "A" and status[3] != "+":
-      # We'll need to upload the new content if we're adding a binary file
-      # since diff's output won't contain it.
-      mimetype = RunShell(["svn", "propget", "svn:mime-type", filename],
-                          silent_ok=True)
-      base_content = ""
-      is_binary = mimetype and not mimetype.startswith("text/")
-      if is_binary and self.IsImage(filename):
-        new_content = self.ReadFile(filename)
-    elif (status[0] in ("M", "D", "R") or
-          (status[0] == "A" and status[3] == "+") or  # Copied file.
-          (status[0] == " " and status[1] == "M")):  # Property change.
-      args = []
-      if self.options.revision:
-        url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
-      else:
-        # Don't change filename, it's needed later.
-        url = filename
-        args += ["-r", "BASE"]
-      cmd = ["svn"] + args + ["propget", "svn:mime-type", url]
-      mimetype, returncode = RunShellWithReturnCode(cmd)
-      if returncode:
-        # File does not exist in the requested revision.
-        # Reset mimetype, it contains an error message.
-        mimetype = ""
-      get_base = False
-      is_binary = mimetype and not mimetype.startswith("text/")
-      if status[0] == " ":
-        # Empty base content just to force an upload.
-        base_content = ""
-      elif is_binary:
-        if self.IsImage(filename):
-          get_base = True
-          if status[0] == "M":
-            if not self.rev_end:
-              new_content = self.ReadFile(filename)
-            else:
-              url = "%s/%s@%s" % (self.svn_base, filename, self.rev_end)
-              new_content = RunShell(["svn", "cat", url],
-                                     universal_newlines=True, silent_ok=True)
-        else:
-          base_content = ""
-      else:
-        get_base = True
-
-      if get_base:
-        if is_binary:
-          universal_newlines = False
-        else:
-          universal_newlines = True
-        if self.rev_start:
-          # "svn cat -r REV delete_file.txt" doesn't work. cat requires
-          # the full URL with "@REV" appended instead of using "-r" option.
-          url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
-          base_content = RunShell(["svn", "cat", url],
-                                  universal_newlines=universal_newlines,
-                                  silent_ok=True)
-        else:
-          base_content = RunShell(["svn", "cat", filename],
-                                  universal_newlines=universal_newlines,
-                                  silent_ok=True)
-        if not is_binary:
-          args = []
-          if self.rev_start:
-            url = "%s/%s@%s" % (self.svn_base, filename, self.rev_start)
-          else:
-            url = filename
-            args += ["-r", "BASE"]
-          cmd = ["svn"] + args + ["propget", "svn:keywords", url]
-          keywords, returncode = RunShellWithReturnCode(cmd)
-          if keywords and not returncode:
-            base_content = self._CollapseKeywords(base_content, keywords)
-    else:
-      StatusUpdate("svn status returned unexpected output: %s" % status)
-      sys.exit(1)
-    return base_content, new_content, is_binary, status[0:5]
-
-
-class GitVCS(VersionControlSystem):
-  """Implementation of the VersionControlSystem interface for Git."""
-
-  def __init__(self, options):
-    super(GitVCS, self).__init__(options)
-    # Map of filename -> hash of base file.
-    self.base_hashes = {}
-
-  def GenerateDiff(self, extra_args):
-    # This is more complicated than svn's GenerateDiff because we must convert
-    # the diff output to include an svn-style "Index:" line as well as record
-    # the hashes of the base files, so we can upload them along with our diff.
-    if self.options.revision:
-      extra_args = [self.options.revision] + extra_args
-    gitdiff = RunShell(["git", "diff", "--full-index"] + extra_args)
-    svndiff = []
-    filecount = 0
-    filename = None
-    for line in gitdiff.splitlines():
-      match = re.match(r"diff --git a/(.*) b/.*$", line)
-      if match:
-        filecount += 1
-        filename = match.group(1)
-        svndiff.append("Index: %s\n" % filename)
-      else:
-        # The "index" line in a git diff looks like this (long hashes elided):
-        #   index 82c0d44..b2cee3f 100755
-        # We want to save the left hash, as that identifies the base file.
-        match = re.match(r"index (\w+)\.\.", line)
-        if match:
-          self.base_hashes[filename] = match.group(1)
-      svndiff.append(line + "\n")
-    if not filecount:
-      ErrorExit("No valid patches found in output from git diff")
-    return "".join(svndiff)
-
-  def GetUnknownFiles(self):
-    status = RunShell(["git", "ls-files", "--exclude-standard", "--others"],
-                      silent_ok=True)
-    return status.splitlines()
-
-  def GetBaseFile(self, filename):
-    hash = self.base_hashes[filename]
-    base_content = None
-    new_content = None
-    is_binary = False
-    if hash == "0" * 40:  # All-zero hash indicates no base file.
-      status = "A"
-      base_content = ""
-    else:
-      status = "M"
-      base_content, returncode = RunShellWithReturnCode(["git", "show", hash])
-      if returncode:
-        ErrorExit("Got error status from 'git show %s'" % hash)
-    return (base_content, new_content, is_binary, status)
-
-
-class MercurialVCS(VersionControlSystem):
-  """Implementation of the VersionControlSystem interface for Mercurial."""
-
-  def __init__(self, options, repo_dir):
-    super(MercurialVCS, self).__init__(options)
-    # Absolute path to repository (we can be in a subdir)
-    self.repo_dir = os.path.normpath(repo_dir)
-    # Compute the subdir
-    cwd = os.path.normpath(os.getcwd())
-    assert cwd.startswith(self.repo_dir)
-    self.subdir = cwd[len(self.repo_dir):].lstrip(r"\/")
-    if self.options.revision:
-      self.base_rev = self.options.revision
-    else:
-      self.base_rev = RunShell(["hg", "parent", "-q"]).split(':')[1].strip()
-
-  def _GetRelPath(self, filename):
-    """Get relative path of a file according to the current directory,
-    given its logical path in the repo."""
-    assert filename.startswith(self.subdir), filename
-    return filename[len(self.subdir):].lstrip(r"\/")
-
-  def GenerateDiff(self, extra_args):
-    # If no file specified, restrict to the current subdir
-    extra_args = extra_args or ["."]
-    cmd = ["hg", "diff", "--git", "-r", self.base_rev] + extra_args
-    data = RunShell(cmd, silent_ok=True)
-    svndiff = []
-    filecount = 0
-    for line in data.splitlines():
-      m = re.match("diff --git a/(\S+) b/(\S+)", line)
-      if m:
-        # Modify line to make it look like as it comes from svn diff.
-        # With this modification no changes on the server side are required
-        # to make upload.py work with Mercurial repos.
-        # NOTE: for proper handling of moved/copied files, we have to use
-        # the second filename.
-        filename = m.group(2)
-        svndiff.append("Index: %s" % filename)
-        svndiff.append("=" * 67)
-        filecount += 1
-        logging.info(line)
-      else:
-        svndiff.append(line)
-    if not filecount:
-      ErrorExit("No valid patches found in output from hg diff")
-    return "\n".join(svndiff) + "\n"
-
-  def GetUnknownFiles(self):
-    """Return a list of files unknown to the VCS."""
-    args = []
-    status = RunShell(["hg", "status", "--rev", self.base_rev, "-u", "."],
-        silent_ok=True)
-    unknown_files = []
-    for line in status.splitlines():
-      st, fn = line.split(" ", 1)
-      if st == "?":
-        unknown_files.append(fn)
-    return unknown_files
-
-  def GetBaseFile(self, filename):
-    # "hg status" and "hg cat" both take a path relative to the current subdir
-    # rather than to the repo root, but "hg diff" has given us the full path
-    # to the repo root.
-    base_content = ""
-    new_content = None
-    is_binary = False
-    oldrelpath = relpath = self._GetRelPath(filename)
-    # "hg status -C" returns two lines for moved/copied files, one otherwise
-    out = RunShell(["hg", "status", "-C", "--rev", self.base_rev, relpath])
-    out = out.splitlines()
-    # HACK: strip error message about missing file/directory if it isn't in
-    # the working copy
-    if out[0].startswith('%s: ' % relpath):
-      out = out[1:]
-    if len(out) > 1:
-      # Moved/copied => considered as modified, use old filename to
-      # retrieve base contents
-      oldrelpath = out[1].strip()
-      status = "M"
-    else:
-      status, _ = out[0].split(' ', 1)
-    if status != "A":
-      base_content = RunShell(["hg", "cat", "-r", self.base_rev, oldrelpath],
-        silent_ok=True)
-      is_binary = "\0" in base_content  # Mercurial's heuristic
-    if status != "R":
-      new_content = open(relpath, "rb").read()
-      is_binary = is_binary or "\0" in new_content
-    if is_binary and base_content:
-      # Fetch again without converting newlines
-      base_content = RunShell(["hg", "cat", "-r", self.base_rev, oldrelpath],
-        silent_ok=True, universal_newlines=False)
-    if not is_binary or not self.IsImage(relpath):
-      new_content = None
-    return base_content, new_content, is_binary, status
-
-
-# NOTE: The SplitPatch function is duplicated in engine.py, keep them in sync.
-def SplitPatch(data):
-  """Splits a patch into separate pieces for each file.
-
-  Args:
-    data: A string containing the output of svn diff.
-
-  Returns:
-    A list of 2-tuple (filename, text) where text is the svn diff output
-      pertaining to filename.
-  """
-  patches = []
-  filename = None
-  diff = []
-  for line in data.splitlines(True):
-    new_filename = None
-    if line.startswith('Index:'):
-      unused, new_filename = line.split(':', 1)
-      new_filename = new_filename.strip()
-    elif line.startswith('Property changes on:'):
-      unused, temp_filename = line.split(':', 1)
-      # When a file is modified, paths use '/' between directories, however
-      # when a property is modified '\' is used on Windows.  Make them the same
-      # otherwise the file shows up twice.
-      temp_filename = temp_filename.strip().replace('\\', '/')
-      if temp_filename != filename:
-        # File has property changes but no modifications, create a new diff.
-        new_filename = temp_filename
-    if new_filename:
-      if filename and diff:
-        patches.append((filename, ''.join(diff)))
-      filename = new_filename
-      diff = [line]
-      continue
-    if diff is not None:
-      diff.append(line)
-  if filename and diff:
-    patches.append((filename, ''.join(diff)))
-  return patches
-
-
-def UploadSeparatePatches(issue, rpc_server, patchset, data, options):
-  """Uploads a separate patch for each file in the diff output.
-
-  Returns a list of [patch_key, filename] for each file.
-  """
-  patches = SplitPatch(data)
-  rv = []
-  for patch in patches:
-    if len(patch[1]) > MAX_UPLOAD_SIZE:
-      print ("Not uploading the patch for " + patch[0] +
-             " because the file is too large.")
-      continue
-    form_fields = [("filename", patch[0])]
-    if not options.download_base:
-      form_fields.append(("content_upload", "1"))
-    files = [("data", "data.diff", patch[1])]
-    ctype, body = EncodeMultipartFormData(form_fields, files)
-    url = "/%d/upload_patch/%d" % (int(issue), int(patchset))
-    print "Uploading patch for " + patch[0]
-    response_body = rpc_server.Send(url, body, content_type=ctype)
-    lines = response_body.splitlines()
-    if not lines or lines[0] != "OK":
-      StatusUpdate("  --> %s" % response_body)
-      sys.exit(1)
-    rv.append([lines[1], patch[0]])
-  return rv
-
-
-def GuessVCS(options):
-  """Helper to guess the version control system.
-
-  This examines the current directory, guesses which VersionControlSystem
-  we're using, and returns an instance of the appropriate class.  Exit with an
-  error if we can't figure it out.
-
-  Returns:
-    A VersionControlSystem instance. Exits if the VCS can't be guessed.
-  """
-  # Mercurial has a command to get the base directory of a repository
-  # Try running it, but don't die if we don't have hg installed.
-  # NOTE: we try Mercurial first as it can sit on top of an SVN working copy.
-  try:
-    out, returncode = RunShellWithReturnCode(["hg", "root"])
-    if returncode == 0:
-      return MercurialVCS(options, out.strip())
-  except OSError, (errno, message):
-    if errno != 2:  # ENOENT -- they don't have hg installed.
-      raise
-
-  # Subversion has a .svn in all working directories.
-  if os.path.isdir('.svn'):
-    logging.info("Guessed VCS = Subversion")
-    return SubversionVCS(options)
-
-  # Git has a command to test if you're in a git tree.
-  # Try running it, but don't die if we don't have git installed.
-  try:
-    out, returncode = RunShellWithReturnCode(["git", "rev-parse",
-                                              "--is-inside-work-tree"])
-    if returncode == 0:
-      return GitVCS(options)
-  except OSError, (errno, message):
-    if errno != 2:  # ENOENT -- they don't have git installed.
-      raise
-
-  ErrorExit(("Could not guess version control system. "
-             "Are you in a working copy directory?"))
-
-
-def RealMain(argv, data=None):
-  """The real main function.
-
-  Args:
-    argv: Command line arguments.
-    data: Diff contents. If None (default) the diff is generated by
-      the VersionControlSystem implementation returned by GuessVCS().
-
-  Returns:
-    A 2-tuple (issue id, patchset id).
-    The patchset id is None if the base files are not uploaded by this
-    script (applies only to SVN checkouts).
-  """
-  logging.basicConfig(format=("%(asctime).19s %(levelname)s %(filename)s:"
-                              "%(lineno)s %(message)s "))
-  os.environ['LC_ALL'] = 'C'
-  options, args = parser.parse_args(argv[1:])
-  global verbosity
-  verbosity = options.verbose
-  if verbosity >= 3:
-    logging.getLogger().setLevel(logging.DEBUG)
-  elif verbosity >= 2:
-    logging.getLogger().setLevel(logging.INFO)
-  vcs = GuessVCS(options)
-  if isinstance(vcs, SubversionVCS):
-    # base field is only allowed for Subversion.
-    # Note: Fetching base files may become deprecated in future releases.
-    base = vcs.GuessBase(options.download_base)
-  else:
-    base = None
-  if not base and options.download_base:
-    options.download_base = True
-    logging.info("Enabled upload of base file")
-  if not options.assume_yes:
-    vcs.CheckForUnknownFiles()
-  if data is None:
-    data = vcs.GenerateDiff(args)
-  files = vcs.GetBaseFiles(data)
-  if verbosity >= 1:
-    print "Upload server:", options.server, "(change with -s/--server)"
-  if options.issue:
-    prompt = "Message describing this patch set: "
-  else:
-    prompt = "New issue subject: "
-  message = options.message or raw_input(prompt).strip()
-  if not message:
-    ErrorExit("A non-empty message is required")
-  rpc_server = GetRpcServer(options)
-  form_fields = [("subject", message)]
-  if base:
-    form_fields.append(("base", base))
-  if options.issue:
-    form_fields.append(("issue", str(options.issue)))
-  if options.email:
-    form_fields.append(("user", options.email))
-  if options.reviewers:
-    for reviewer in options.reviewers.split(','):
-      if "@" in reviewer and not reviewer.split("@")[1].count(".") == 1:
-        ErrorExit("Invalid email address: %s" % reviewer)
-    form_fields.append(("reviewers", options.reviewers))
-  if options.cc:
-    for cc in options.cc.split(','):
-      if "@" in cc and not cc.split("@")[1].count(".") == 1:
-        ErrorExit("Invalid email address: %s" % cc)
-    form_fields.append(("cc", options.cc))
-  description = options.description
-  if options.description_file:
-    if options.description:
-      ErrorExit("Can't specify description and description_file")
-    file = open(options.description_file, 'r')
-    description = file.read()
-    file.close()
-  if description:
-    form_fields.append(("description", description))
-  # Send a hash of all the base file so the server can determine if a copy
-  # already exists in an earlier patchset.
-  base_hashes = ""
-  for file, info in files.iteritems():
-    if not info[0] is None:
-      checksum = md5.new(info[0]).hexdigest()
-      if base_hashes:
-        base_hashes += "|"
-      base_hashes += checksum + ":" + file
-  form_fields.append(("base_hashes", base_hashes))
-  # If we're uploading base files, don't send the email before the uploads, so
-  # that it contains the file status.
-  if options.send_mail and options.download_base:
-    form_fields.append(("send_mail", "1"))
-  if not options.download_base:
-    form_fields.append(("content_upload", "1"))
-  if len(data) > MAX_UPLOAD_SIZE:
-    print "Patch is large, so uploading file patches separately."
-    uploaded_diff_file = []
-    form_fields.append(("separate_patches", "1"))
-  else:
-    uploaded_diff_file = [("data", "data.diff", data)]
-  ctype, body = EncodeMultipartFormData(form_fields, uploaded_diff_file)
-  response_body = rpc_server.Send("/upload", body, content_type=ctype)
-  patchset = None
-  if not options.download_base or not uploaded_diff_file:
-    lines = response_body.splitlines()
-    if len(lines) >= 2:
-      msg = lines[0]
-      patchset = lines[1].strip()
-      patches = [x.split(" ", 1) for x in lines[2:]]
-    else:
-      msg = response_body
-  else:
-    msg = response_body
-  StatusUpdate(msg)
-  if not response_body.startswith("Issue created.") and \
-  not response_body.startswith("Issue updated."):
-    sys.exit(0)
-  issue = msg[msg.rfind("/")+1:]
-
-  if not uploaded_diff_file:
-    result = UploadSeparatePatches(issue, rpc_server, patchset, data, options)
-    if not options.download_base:
-      patches = result
-
-  if not options.download_base:
-    vcs.UploadBaseFiles(issue, rpc_server, patches, patchset, options, files)
-    if options.send_mail:
-      rpc_server.Send("/" + issue + "/mail", payload="")
-  return issue, patchset
-
-
-def main():
-  try:
-    RealMain(sys.argv)
-  except KeyboardInterrupt:
-    print
-    StatusUpdate("Interrupted.")
-    sys.exit(1)
-
-
-if __name__ == "__main__":
-  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload_gtest.py b/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload_gtest.py
deleted file mode 100755
index be19ae80..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/scripts/upload_gtest.py
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2009, 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.
-
-"""upload_gtest.py v0.1.0 -- uploads a Google Test patch for review.
-
-This simple wrapper passes all command line flags and
---cc=googletestframework@googlegroups.com to upload.py.
-
-USAGE: upload_gtest.py [options for upload.py]
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import sys
-
-CC_FLAG = '--cc='
-GTEST_GROUP = 'googletestframework@googlegroups.com'
-
-
-def main():
-  # Finds the path to upload.py, assuming it is in the same directory
-  # as this file.
-  my_dir = os.path.dirname(os.path.abspath(__file__))
-  upload_py_path = os.path.join(my_dir, 'upload.py')
-
-  # Adds Google Test discussion group to the cc line if it's not there
-  # already.
-  upload_py_argv = [upload_py_path]
-  found_cc_flag = False
-  for arg in sys.argv[1:]:
-    if arg.startswith(CC_FLAG):
-      found_cc_flag = True
-      cc_line = arg[len(CC_FLAG):]
-      cc_list = [addr for addr in cc_line.split(',') if addr]
-      if GTEST_GROUP not in cc_list:
-        cc_list.append(GTEST_GROUP)
-      upload_py_argv.append(CC_FLAG + ','.join(cc_list))
-    else:
-      upload_py_argv.append(arg)
-
-  if not found_cc_flag:
-    upload_py_argv.append(CC_FLAG + GTEST_GROUP)
-
-  # Invokes upload.py with the modified command line flags.
-  os.execv(upload_py_path, upload_py_argv)
-
-
-if __name__ == '__main__':
-  main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-all.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-all.cc
deleted file mode 100644
index 0a9cee52..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-all.cc
+++ /dev/null
@@ -1,48 +0,0 @@
-// 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.
-//
-// Author: mheule@google.com (Markus Heule)
-//
-// Google C++ Testing Framework (Google Test)
-//
-// Sometimes it's desirable to build Google Test by compiling a single file.
-// This file serves this purpose.
-
-// This line ensures that gtest.h can be compiled on its own, even
-// when it's fused.
-#include "gtest/gtest.h"
-
-// The following lines pull in the real gtest *.cc files.
-#include "src/gtest.cc"
-#include "src/gtest-death-test.cc"
-#include "src/gtest-filepath.cc"
-#include "src/gtest-port.cc"
-#include "src/gtest-printers.cc"
-#include "src/gtest-test-part.cc"
-#include "src/gtest-typed-test.cc"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-death-test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-death-test.cc
deleted file mode 100644
index a01a3698..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-death-test.cc
+++ /dev/null
@@ -1,1342 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev)
-//
-// This file implements death tests.
-
-#include "gtest/gtest-death-test.h"
-#include "gtest/internal/gtest-port.h"
-#include "gtest/internal/custom/gtest.h"
-
-#if GTEST_HAS_DEATH_TEST
-
-# if GTEST_OS_MAC
-#  include <crt_externs.h>
-# endif  // GTEST_OS_MAC
-
-# include <errno.h>
-# include <fcntl.h>
-# include <limits.h>
-
-# if GTEST_OS_LINUX
-#  include <signal.h>
-# endif  // GTEST_OS_LINUX
-
-# include <stdarg.h>
-
-# if GTEST_OS_WINDOWS
-#  include <windows.h>
-# else
-#  include <sys/mman.h>
-#  include <sys/wait.h>
-# endif  // GTEST_OS_WINDOWS
-
-# if GTEST_OS_QNX
-#  include <spawn.h>
-# endif  // GTEST_OS_QNX
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-#include "gtest/gtest-message.h"
-#include "gtest/internal/gtest-string.h"
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick exists to
-// prevent the accidental inclusion of gtest-internal-inl.h in the
-// user's code.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-namespace testing {
-
-// Constants.
-
-// The default death test style.
-static const char kDefaultDeathTestStyle[] = "fast";
-
-GTEST_DEFINE_string_(
-    death_test_style,
-    internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),
-    "Indicates how to run a death test in a forked child process: "
-    "\"threadsafe\" (child process re-executes the test binary "
-    "from the beginning, running only the specific death test) or "
-    "\"fast\" (child process runs the death test immediately "
-    "after forking).");
-
-GTEST_DEFINE_bool_(
-    death_test_use_fork,
-    internal::BoolFromGTestEnv("death_test_use_fork", false),
-    "Instructs to use fork()/_exit() instead of clone() in death tests. "
-    "Ignored and always uses fork() on POSIX systems where clone() is not "
-    "implemented. Useful when running under valgrind or similar tools if "
-    "those do not support clone(). Valgrind 3.3.1 will just fail if "
-    "it sees an unsupported combination of clone() flags. "
-    "It is not recommended to use this flag w/o valgrind though it will "
-    "work in 99% of the cases. Once valgrind is fixed, this flag will "
-    "most likely be removed.");
-
-namespace internal {
-GTEST_DEFINE_string_(
-    internal_run_death_test, "",
-    "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 "
-    "death test.  FOR INTERNAL USE ONLY.");
-}  // namespace internal
-
-#if GTEST_HAS_DEATH_TEST
-
-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
-static bool g_in_fast_death_test_child = false;
-# endif
-
-// Returns a Boolean value indicating whether the caller is currently
-// executing in the context of the death test child process.  Tools such as
-// Valgrind heap checkers may need this to modify their behavior in death
-// 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
-
-  // On Windows, death tests are thread-safe regardless of the value of the
-  // death_test_style flag.
-  return !GTEST_FLAG(internal_run_death_test).empty();
-
-# else
-
-  if (GTEST_FLAG(death_test_style) == "threadsafe")
-    return !GTEST_FLAG(internal_run_death_test).empty();
-  else
-    return g_in_fast_death_test_child;
-#endif
-}
-
-}  // namespace internal
-
-// ExitedWithCode constructor.
-ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
-}
-
-// ExitedWithCode function-call operator.
-bool ExitedWithCode::operator()(int exit_status) const {
-# if GTEST_OS_WINDOWS
-
-  return exit_status == exit_code_;
-
-# else
-
-  return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
-
-# endif  // GTEST_OS_WINDOWS
-}
-
-# if !GTEST_OS_WINDOWS
-// KilledBySignal constructor.
-KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
-}
-
-// KilledBySignal function-call operator.
-bool KilledBySignal::operator()(int exit_status) const {
-#  if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
-  {
-    bool result;
-    if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
-      return result;
-    }
-  }
-#  endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
-  return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
-}
-# endif  // !GTEST_OS_WINDOWS
-
-namespace internal {
-
-// Utilities needed for death tests.
-
-// Generates a textual description of a given exit code, in the format
-// specified by wait(2).
-static std::string ExitSummary(int exit_code) {
-  Message m;
-
-# if GTEST_OS_WINDOWS
-
-  m << "Exited with exit status " << exit_code;
-
-# else
-
-  if (WIFEXITED(exit_code)) {
-    m << "Exited with exit status " << WEXITSTATUS(exit_code);
-  } else if (WIFSIGNALED(exit_code)) {
-    m << "Terminated by signal " << WTERMSIG(exit_code);
-  }
-#  ifdef WCOREDUMP
-  if (WCOREDUMP(exit_code)) {
-    m << " (core dumped)";
-  }
-#  endif
-# endif  // GTEST_OS_WINDOWS
-
-  return m.GetString();
-}
-
-// Returns true if exit_status describes a process that was terminated
-// by a signal, or exited normally with a nonzero exit code.
-bool ExitedUnsuccessfully(int exit_status) {
-  return !ExitedWithCode(0)(exit_status);
-}
-
-# if !GTEST_OS_WINDOWS
-// 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
-// caller not to pass a thread_count of 1.
-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)
-    msg << "couldn't detect the number of threads.";
-  else
-    msg << "detected " << thread_count << " threads.";
-  return msg.GetString();
-}
-# endif  // !GTEST_OS_WINDOWS
-
-// Flag characters for reporting a death test that did not die.
-static const char kDeathTestLived = 'L';
-static const char kDeathTestReturned = 'R';
-static const char kDeathTestThrew = 'T';
-static const char kDeathTestInternalError = 'I';
-
-// 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;
-// RETURNED means that the test statement attempted to execute a return
-// statement, which is not allowed; THREW means that the test statement
-// returned control by throwing an exception.  IN_PROGRESS means the test
-// has not yet concluded.
-// TODO(vladl@google.com): Unify names and possibly values for
-// AbortReason, DeathTestOutcome, and flag characters above.
-enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
-
-// Routine for aborting the program which is safe to call from an
-// exec-style death test child process, in which case the error
-// 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.
-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 != NULL) {
-    FILE* parent = posix::FDOpen(flag->write_fd(), "w");
-    fputc(kDeathTestInternalError, parent);
-    fprintf(parent, "%s", message.c_str());
-    fflush(parent);
-    _exit(1);
-  } else {
-    fprintf(stderr, "%s", message.c_str());
-    fflush(stderr);
-    posix::Abort();
-  }
-}
-
-// A replacement for CHECK that calls DeathTestAbort if the assertion
-// fails.
-# define GTEST_DEATH_TEST_CHECK_(expression) \
-  do { \
-    if (!::testing::internal::IsTrue(expression)) { \
-      DeathTestAbort( \
-          ::std::string("CHECK failed: File ") + __FILE__ +  ", line " \
-          + ::testing::internal::StreamableToString(__LINE__) + ": " \
-          + #expression); \
-    } \
-  } while (::testing::internal::AlwaysFalse())
-
-// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for
-// evaluating any system call that fulfills two conditions: it must return
-// -1 on failure, and set errno to EINTR when it is interrupted and
-// should be tried again.  The macro expands to a loop that repeatedly
-// evaluates the expression as long as it evaluates to -1 and sets
-// errno to EINTR.  If the expression evaluates to -1 but errno is
-// something other than EINTR, DeathTestAbort is called.
-# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \
-  do { \
-    int gtest_retval; \
-    do { \
-      gtest_retval = (expression); \
-    } while (gtest_retval == -1 && errno == EINTR); \
-    if (gtest_retval == -1) { \
-      DeathTestAbort( \
-          ::std::string("CHECK failed: File ") + __FILE__ + ", line " \
-          + ::testing::internal::StreamableToString(__LINE__) + ": " \
-          + #expression + " != -1"); \
-    } \
-  } while (::testing::internal::AlwaysFalse())
-
-// Returns the message describing the last system error in errno.
-std::string GetLastErrnoDescription() {
-    return errno == 0 ? "" : posix::StrError(errno);
-}
-
-// This is called from a death test parent process to read a failure
-// message from the death test child process and log it with the FATAL
-// severity. On Windows, the message is read from a pipe handle. On other
-// platforms, it is read from a file descriptor.
-static void FailFromInternalError(int fd) {
-  Message error;
-  char buffer[256];
-  int num_read;
-
-  do {
-    while ((num_read = posix::Read(fd, buffer, 255)) > 0) {
-      buffer[num_read] = '\0';
-      error << buffer;
-    }
-  } while (num_read == -1 && errno == EINTR);
-
-  if (num_read == 0) {
-    GTEST_LOG_(FATAL) << error.GetString();
-  } else {
-    const int last_error = errno;
-    GTEST_LOG_(FATAL) << "Error while reading death test internal: "
-                      << GetLastErrnoDescription() << " [" << last_error << "]";
-  }
-}
-
-// Death test constructor.  Increments the running death test count
-// for the current test.
-DeathTest::DeathTest() {
-  TestInfo* const info = GetUnitTestImpl()->current_test_info();
-  if (info == NULL) {
-    DeathTestAbort("Cannot run a death test outside of a TEST or "
-                   "TEST_F construct");
-  }
-}
-
-// Creates and returns a death test by dispatching to the current
-// death test factory.
-bool DeathTest::Create(const char* statement, const RE* regex,
-                       const char* file, int line, DeathTest** test) {
-  return GetUnitTestImpl()->death_test_factory()->Create(
-      statement, regex, file, line, test);
-}
-
-const char* DeathTest::LastMessage() {
-  return last_death_test_message_.c_str();
-}
-
-void DeathTest::set_last_death_test_message(const std::string& message) {
-  last_death_test_message_ = message;
-}
-
-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, const RE* a_regex)
-      : statement_(a_statement),
-        regex_(a_regex),
-        spawned_(false),
-        status_(-1),
-        outcome_(IN_PROGRESS),
-        read_fd_(-1),
-        write_fd_(-1) {}
-
-  // read_fd_ is expected to be closed and cleared by a derived class.
-  ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
-
-  void Abort(AbortReason reason);
-  virtual bool Passed(bool status_ok);
-
-  const char* statement() const { return statement_; }
-  const RE* regex() const { return regex_; }
-  bool spawned() const { return spawned_; }
-  void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
-  int status() const { return status_; }
-  void set_status(int a_status) { status_ = a_status; }
-  DeathTestOutcome outcome() const { return outcome_; }
-  void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; }
-  int read_fd() const { return read_fd_; }
-  void set_read_fd(int fd) { read_fd_ = fd; }
-  int write_fd() const { return write_fd_; }
-  void set_write_fd(int fd) { write_fd_ = fd; }
-
-  // Called in the parent process only. Reads the result code of the death
-  // test child process via a pipe, interprets it to set the outcome_
-  // member, and closes read_fd_.  Outputs diagnostics and terminates in
-  // case of unexpected codes.
-  void ReadAndInterpretStatusByte();
-
- 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_;
-  // The regular expression which test output must match.  DeathTestImpl
-  // doesn't own this object and should not attempt to delete it.
-  const RE* const regex_;
-  // True if the death test child process has been successfully spawned.
-  bool spawned_;
-  // The exit status of the child process.
-  int status_;
-  // How the death test concluded.
-  DeathTestOutcome outcome_;
-  // Descriptor to the read end of the pipe to the child process.  It is
-  // always -1 in the child process.  The child keeps its write end of the
-  // pipe in write_fd_.
-  int read_fd_;
-  // Descriptor to the child's write end of the pipe to the parent process.
-  // It is always -1 in the parent process.  The parent keeps its end of the
-  // pipe in read_fd_.
-  int write_fd_;
-};
-
-// Called in the parent process only. Reads the result code of the death
-// test child process via a pipe, interprets it to set the outcome_
-// member, and closes read_fd_.  Outputs diagnostics and terminates in
-// case of unexpected codes.
-void DeathTestImpl::ReadAndInterpretStatusByte() {
-  char flag;
-  int bytes_read;
-
-  // The read() here blocks until data is available (signifying the
-  // failure of the death test) or until the pipe is closed (signifying
-  // its success), so it's okay to call this in the parent before
-  // the child process has exited.
-  do {
-    bytes_read = posix::Read(read_fd(), &flag, 1);
-  } while (bytes_read == -1 && errno == EINTR);
-
-  if (bytes_read == 0) {
-    set_outcome(DIED);
-  } else if (bytes_read == 1) {
-    switch (flag) {
-      case kDeathTestReturned:
-        set_outcome(RETURNED);
-        break;
-      case kDeathTestThrew:
-        set_outcome(THREW);
-        break;
-      case kDeathTestLived:
-        set_outcome(LIVED);
-        break;
-      case kDeathTestInternalError:
-        FailFromInternalError(read_fd());  // Does not return.
-        break;
-      default:
-        GTEST_LOG_(FATAL) << "Death test child process reported "
-                          << "unexpected status byte ("
-                          << static_cast<unsigned int>(flag) << ")";
-    }
-  } else {
-    GTEST_LOG_(FATAL) << "Read from death test child process failed: "
-                      << GetLastErrnoDescription();
-  }
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
-  set_read_fd(-1);
-}
-
-// 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
-// calls _exit(1).
-void DeathTestImpl::Abort(AbortReason reason) {
-  // The parent process considers the death test to be a failure if
-  // it finds any data in our pipe.  So, here we write a single flag byte
-  // to the pipe, then exit.
-  const char status_ch =
-      reason == TEST_DID_NOT_DIE ? kDeathTestLived :
-      reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;
-
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
-  // We are leaking the descriptor here because on some platforms (i.e.,
-  // when built as Windows DLL), destructors of global objects will still
-  // run after calling _exit(). On such systems, write_fd_ will be
-  // indirectly closed from the destructor of UnitTestImpl, causing double
-  // close if it is also closed here. On debug configurations, double close
-  // may assert. As there are no in-process buffers to flush here, we are
-  // relying on the OS to close the descriptor after the process terminates
-  // when the destructors are not run.
-  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
-}
-
-// Returns an indented copy of stderr output for a death test.
-// This makes distinguishing death test output lines from regular log lines
-// much easier.
-static ::std::string FormatDeathTestOutput(const ::std::string& output) {
-  ::std::string ret;
-  for (size_t at = 0; ; ) {
-    const size_t line_end = output.find('\n', at);
-    ret += "[  DEATH   ] ";
-    if (line_end == ::std::string::npos) {
-      ret += output.substr(at);
-      break;
-    }
-    ret += output.substr(at, line_end + 1 - at);
-    at = line_end + 1;
-  }
-  return ret;
-}
-
-// Assesses the success or failure of a death test, using both private
-// members which have previously been set, and one argument:
-//
-// Private data members:
-//   outcome:  An enumeration describing how the death test
-//             concluded: DIED, LIVED, THREW, or RETURNED.  The death test
-//             fails in the latter three cases.
-//   status:   The exit status of the child process. On *nix, it is in the
-//             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.
-//   regex:    A regular expression object to be applied to
-//             the test's captured standard error output; the death test
-//             fails if it does not match.
-//
-// 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 iff 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 = GetCapturedStderr();
-
-  bool success = false;
-  Message buffer;
-
-  buffer << "Death test: " << statement() << "\n";
-  switch (outcome()) {
-    case LIVED:
-      buffer << "    Result: failed to die.\n"
-             << " Error msg:\n" << FormatDeathTestOutput(error_message);
-      break;
-    case THREW:
-      buffer << "    Result: threw an exception.\n"
-             << " Error msg:\n" << FormatDeathTestOutput(error_message);
-      break;
-    case RETURNED:
-      buffer << "    Result: illegal return in test statement.\n"
-             << " Error msg:\n" << FormatDeathTestOutput(error_message);
-      break;
-    case DIED:
-      if (status_ok) {
-        const bool matched = RE::PartialMatch(error_message.c_str(), *regex());
-        if (matched) {
-          success = true;
-        } else {
-          buffer << "    Result: died but not with expected error.\n"
-                 << "  Expected: " << regex()->pattern() << "\n"
-                 << "Actual msg:\n" << FormatDeathTestOutput(error_message);
-        }
-      } else {
-        buffer << "    Result: died but not with expected exit code:\n"
-               << "            " << ExitSummary(status()) << "\n"
-               << "Actual msg:\n" << FormatDeathTestOutput(error_message);
-      }
-      break;
-    case IN_PROGRESS:
-    default:
-      GTEST_LOG_(FATAL)
-          << "DeathTest::Passed somehow called before conclusion of test";
-  }
-
-  DeathTest::set_last_death_test_message(buffer.GetString());
-  return success;
-}
-
-# if GTEST_OS_WINDOWS
-// WindowsDeathTest implements death tests on Windows. Due to the
-// specifics of starting new processes on Windows, death tests there are
-// always threadsafe, and Google Test considers the
-// --gtest_death_test_style=fast setting to be equivalent to
-// --gtest_death_test_style=threadsafe there.
-//
-// A few implementation notes:  Like the Linux version, the Windows
-// implementation uses pipes for child-to-parent communication. But due to
-// the specifics of pipes on Windows, some extra steps are required:
-//
-// 1. The parent creates a communication pipe and stores handles to both
-//    ends of it.
-// 2. The parent starts the child and provides it with the information
-//    necessary to acquire the handle to the write end of the pipe.
-// 3. The child acquires the write end of the pipe and signals the parent
-//    using a Windows event.
-// 4. Now the parent can release the write end of the pipe on its side. If
-//    this is done before step 3, the object's reference count goes down to
-//    0 and it is destroyed, preventing the child from acquiring it. The
-//    parent now has to release it, or read operations on the read end of
-//    the pipe will not return when the child terminates.
-// 5. The parent reads child's output through the pipe (outcome code and
-//    any possible error messages) from the pipe, and its stderr and then
-//    determines whether to fail the test.
-//
-// Note: to distinguish Win32 API calls from the local method and function
-// calls, the former are explicitly resolved in the global namespace.
-//
-class WindowsDeathTest : public DeathTestImpl {
- public:
-  WindowsDeathTest(const char* a_statement,
-                   const RE* a_regex,
-                   const char* file,
-                   int line)
-      : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {}
-
-  // All of these virtual functions are inherited from DeathTest.
-  virtual int Wait();
-  virtual TestRole AssumeRole();
-
- 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_;
-  // Handle to the write end of the pipe to the child process.
-  AutoHandle write_handle_;
-  // Child process handle.
-  AutoHandle child_handle_;
-  // Event the child process uses to signal the parent that it has
-  // acquired the handle to the write end of the pipe. After seeing this
-  // event the parent can release its own handles to make sure its
-  // ReadFile() calls return when the child terminates.
-  AutoHandle event_handle_;
-};
-
-// 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 WindowsDeathTest::Wait() {
-  if (!spawned())
-    return 0;
-
-  // Wait until the child either signals that it has acquired the write end
-  // of the pipe or it dies.
-  const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() };
-  switch (::WaitForMultipleObjects(2,
-                                   wait_handles,
-                                   FALSE,  // Waits for any of the handles.
-                                   INFINITE)) {
-    case WAIT_OBJECT_0:
-    case WAIT_OBJECT_0 + 1:
-      break;
-    default:
-      GTEST_DEATH_TEST_CHECK_(false);  // Should not get here.
-  }
-
-  // The child has acquired the write end of the pipe or exited.
-  // We release the handle on our side and continue.
-  write_handle_.Reset();
-  event_handle_.Reset();
-
-  ReadAndInterpretStatusByte();
-
-  // Waits for the child process to exit if it haven't already. This
-  // returns immediately if the child has already exited, regardless of
-  // whether previous calls to WaitForMultipleObjects synchronized on this
-  // handle or not.
-  GTEST_DEATH_TEST_CHECK_(
-      WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(),
-                                             INFINITE));
-  DWORD status_code;
-  GTEST_DEATH_TEST_CHECK_(
-      ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE);
-  child_handle_.Reset();
-  set_status(static_cast<int>(status_code));
-  return status();
-}
-
-// The AssumeRole process for a Windows 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 WindowsDeathTest::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 != NULL) {
-    // ParseInternalRunDeathTestFlag() has performed all the necessary
-    // processing.
-    set_write_fd(flag->write_fd());
-    return EXECUTE_TEST;
-  }
-
-  // WindowsDeathTest uses an anonymous pipe to communicate results of
-  // a death test.
-  SECURITY_ATTRIBUTES handles_are_inheritable = {
-    sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
-  HANDLE read_handle, write_handle;
-  GTEST_DEATH_TEST_CHECK_(
-      ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
-                   0)  // Default buffer size.
-      != FALSE);
-  set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle),
-                                O_RDONLY));
-  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.
-      NULL));  // The even is unnamed.
-  GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL);
-  const std::string filter_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" +
-      info->test_case_name() + "." + info->name();
-  const std::string internal_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
-      "=" + file_ + "|" + StreamableToString(line_) + "|" +
-      StreamableToString(death_test_index) + "|" +
-      StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
-      // size_t has the same width as pointers on both 32-bit and 64-bit
-      // Windows platforms.
-      // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
-      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) +
-      "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
-
-  char executable_path[_MAX_PATH + 1];  // NOLINT
-  GTEST_DEATH_TEST_CHECK_(
-      _MAX_PATH + 1 != ::GetModuleFileNameA(NULL,
-                                            executable_path,
-                                            _MAX_PATH));
-
-  std::string command_line =
-      std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
-      internal_flag + "\"";
-
-  DeathTest::set_last_death_test_message("");
-
-  CaptureStderr();
-  // Flush the log buffers since the log streams are shared with the child.
-  FlushInfoLog();
-
-  // The child process will share the standard handles with the parent.
-  STARTUPINFOA startup_info;
-  memset(&startup_info, 0, sizeof(STARTUPINFO));
-  startup_info.dwFlags = STARTF_USESTDHANDLES;
-  startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE);
-  startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
-  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()),
-      NULL,   // Retuned process handle is not inheritable.
-      NULL,   // Retuned thread handle is not inheritable.
-      TRUE,   // Child inherits all inheritable handles (for write_handle_).
-      0x0,    // Default creation flags.
-      NULL,   // 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;
-}
-# else  // We are not on Windows.
-
-// 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, const RE* regex);
-
-  // All of these virtual functions are inherited from DeathTest.
-  virtual int Wait();
-
- protected:
-  void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
-
- private:
-  // PID of child process during death test; 0 in the child process itself.
-  pid_t child_pid_;
-};
-
-// Constructs a ForkingDeathTest.
-ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex)
-    : DeathTestImpl(a_statement, a_regex),
-      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
-// outcome data member.
-int ForkingDeathTest::Wait() {
-  if (!spawned())
-    return 0;
-
-  ReadAndInterpretStatusByte();
-
-  int status_value;
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
-  set_status(status_value);
-  return status_value;
-}
-
-// A concrete death test class that forks, then immediately runs the test
-// in the child process.
-class NoExecDeathTest : public ForkingDeathTest {
- public:
-  NoExecDeathTest(const char* a_statement, const RE* a_regex) :
-      ForkingDeathTest(a_statement, a_regex) { }
-  virtual TestRole AssumeRole();
-};
-
-// The AssumeRole process for a fork-and-run death test.  It implements a
-// straightforward fork, with a simple pipe to transmit the status byte.
-DeathTest::TestRole NoExecDeathTest::AssumeRole() {
-  const size_t thread_count = GetThreadCount();
-  if (thread_count != 1) {
-    GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
-  }
-
-  int pipe_fd[2];
-  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
-
-  DeathTest::set_last_death_test_message("");
-  CaptureStderr();
-  // When we fork the process below, the log file buffers are copied, but the
-  // file descriptors are shared.  We flush all log files here so that closing
-  // the file descriptors in the child process doesn't throw off the
-  // synchronization between descriptors and buffers in the parent process.
-  // This is as close to the fork as possible to avoid a race condition in case
-  // there are multiple threads running before the death test, and another
-  // thread writes to the log file.
-  FlushInfoLog();
-
-  const pid_t child_pid = fork();
-  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
-  set_child_pid(child_pid);
-  if (child_pid == 0) {
-    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0]));
-    set_write_fd(pipe_fd[1]);
-    // Redirects all logging to stderr in the child process to prevent
-    // concurrent writes to the log files.  We capture stderr in the parent
-    // process and append the child process' output to a log.
-    LogToStderr();
-    // Event forwarding to the listeners of event listener API mush be shut
-    // down in death test subprocesses.
-    GetUnitTestImpl()->listeners()->SuppressEventForwarding();
-    g_in_fast_death_test_child = true;
-    return EXECUTE_TEST;
-  } else {
-    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
-    set_read_fd(pipe_fd[0]);
-    set_spawned(true);
-    return OVERSEE_TEST;
-  }
-}
-
-// A concrete death test class that forks and re-executes the main
-// program from the beginning, with command-line flags set that cause
-// only this specific death test to be run.
-class ExecDeathTest : public ForkingDeathTest {
- public:
-  ExecDeathTest(const char* a_statement, const RE* a_regex,
-                const char* file, int line) :
-      ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { }
-  virtual TestRole AssumeRole();
- private:
-  static ::std::vector<testing::internal::string>
-  GetArgvsForDeathTestChildProcess() {
-    ::std::vector<testing::internal::string> args = GetInjectableArgvs();
-#  if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
-    ::std::vector<testing::internal::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_)
-    return args;
-  }
-  // 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_;
-};
-
-// Utility class for accumulating command-line arguments.
-class Arguments {
- public:
-  Arguments() {
-    args_.push_back(NULL);
-  }
-
-  ~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];
-  }
-
- private:
-  std::vector<char*> args_;
-};
-
-// A struct that encompasses the arguments to the child process of a
-// threadsafe-style death test process.
-struct ExecDeathTestArgs {
-  char* const* argv;  // Command-line arguments for the child's call to exec
-  int close_fd;       // File descriptor to close; the read end of a pipe
-};
-
-#  if GTEST_OS_MAC
-inline char** GetEnviron() {
-  // When Google Test is built as a framework on MacOS X, the environ variable
-  // is unavailable. Apple's documentation (man environ) recommends using
-  // _NSGetEnviron() instead.
-  return *_NSGetEnviron();
-}
-#  else
-// Some POSIX platforms expect you to declare environ. extern "C" makes
-// it reside in the global namespace.
-extern "C" char** environ;
-inline char** GetEnviron() { return environ; }
-#  endif  // GTEST_OS_MAC
-
-#  if !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.
-static int ExecDeathTestChildMain(void* child_arg) {
-  ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
-
-  // We need to execute the test program in the same environment where
-  // it was originally invoked.  Therefore we change to the original
-  // working directory first.
-  const char* const original_dir =
-      UnitTest::GetInstance()->original_working_dir();
-  // We can safely call chdir() as it's a direct system call.
-  if (chdir(original_dir) != 0) {
-    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
-                   GetLastErrnoDescription());
-    return EXIT_FAILURE;
-  }
-
-  // We can safely call execve() as it's a direct system call.  We
-  // cannot use execvp() as it's a libc function and thus potentially
-  // unsafe.  Since execve() doesn't search the PATH, the user must
-  // invoke the test program via a valid path that contains at least
-  // one path separator.
-  execve(args->argv[0], args->argv, GetEnviron());
-  DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " +
-                 original_dir + " failed: " +
-                 GetLastErrnoDescription());
-  return EXIT_FAILURE;
-}
-#  endif  // !GTEST_OS_QNX
-
-// Two utility routines that together determine the direction the stack
-// grows.
-// This could be accomplished more elegantly by a single recursive
-// function, but we want to guard against the unlikely possibility of
-// a smart compiler optimizing the recursion away.
-//
-// GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining
-// StackLowerThanAddress into StackGrowsDown, which then doesn't give
-// correct answer.
-void StackLowerThanAddress(const void* ptr, bool* result) GTEST_NO_INLINE_;
-void StackLowerThanAddress(const void* ptr, bool* result) {
-  int dummy;
-  *result = (&dummy < ptr);
-}
-
-// Make sure AddressSanitizer does not tamper with the stack here.
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-bool StackGrowsDown() {
-  int dummy;
-  bool result;
-  StackLowerThanAddress(&dummy, &result);
-  return result;
-}
-
-// 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
-// implementation uses fork(2) + exec.  On systems where clone(2) is
-// available, it is used instead, being slightly more thread-safe.  On QNX,
-// fork supports only single-threaded environments, so this function uses
-// spawn(2) there instead.  The function dies with an error message if
-// anything goes wrong.
-static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
-  ExecDeathTestArgs args = { argv, close_fd };
-  pid_t child_pid = -1;
-
-#  if GTEST_OS_QNX
-  // Obtains the current directory and sets it to be closed in the child
-  // process.
-  const int cwd_fd = open(".", O_RDONLY);
-  GTEST_DEATH_TEST_CHECK_(cwd_fd != -1);
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC));
-  // We need to execute the test program in the same environment where
-  // it was originally invoked.  Therefore we change to the original
-  // working directory first.
-  const char* const original_dir =
-      UnitTest::GetInstance()->original_working_dir();
-  // We can safely call chdir() as it's a direct system call.
-  if (chdir(original_dir) != 0) {
-    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
-                   GetLastErrnoDescription());
-    return EXIT_FAILURE;
-  }
-
-  int fd_flags;
-  // Set close_fd to be closed after spawn.
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD));
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD,
-                                        fd_flags | FD_CLOEXEC));
-  struct inheritance inherit = {0};
-  // spawn is a system call.
-  child_pid = spawn(args.argv[0], 0, NULL, &inherit, args.argv, GetEnviron());
-  // Restores the current working directory.
-  GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
-
-#  else   // GTEST_OS_QNX
-#   if GTEST_OS_LINUX
-  // When a SIGPROF signal is received while fork() or clone() are executing,
-  // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
-  // it after the call to fork()/clone() is complete.
-  struct sigaction saved_sigprof_action;
-  struct sigaction ignore_sigprof_action;
-  memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action));
-  sigemptyset(&ignore_sigprof_action.sa_mask);
-  ignore_sigprof_action.sa_handler = SIG_IGN;
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction(
-      SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
-#   endif  // GTEST_OS_LINUX
-
-#   if GTEST_HAS_CLONE
-  const bool use_fork = GTEST_FLAG(death_test_use_fork);
-
-  if (!use_fork) {
-    static const bool stack_grows_down = StackGrowsDown();
-    const size_t stack_size = getpagesize();
-    // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
-    void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE,
-                             MAP_ANON | MAP_PRIVATE, -1, 0);
-    GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
-
-    // Maximum stack alignment in bytes:  For a downward-growing stack, this
-    // amount is subtracted from size of the stack space to get an address
-    // that is within the stack space and is aligned on all systems we care
-    // about.  As far as I know there is no ABI with stack alignment greater
-    // than 64.  We assume stack and stack_size already have alignment of
-    // kMaxStackAlignment.
-    const size_t kMaxStackAlignment = 64;
-    void* const stack_top =
-        static_cast<char*>(stack) +
-            (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
-    GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment &&
-        reinterpret_cast<intptr_t>(stack_top) % kMaxStackAlignment == 0);
-
-    child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
-
-    GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
-  }
-#   else
-  const bool use_fork = true;
-#   endif  // GTEST_HAS_CLONE
-
-  if (use_fork && (child_pid = fork()) == 0) {
-      ExecDeathTestChildMain(&args);
-      _exit(0);
-  }
-#  endif  // GTEST_OS_QNX
-#  if GTEST_OS_LINUX
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(
-      sigaction(SIGPROF, &saved_sigprof_action, NULL));
-#  endif  // GTEST_OS_LINUX
-
-  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
-  return child_pid;
-}
-
-// The AssumeRole process for a fork-and-exec death test.  It re-executes the
-// main program from the beginning, setting the --gtest_filter
-// and --gtest_internal_run_death_test flags to cause only the current
-// death test to be re-run.
-DeathTest::TestRole ExecDeathTest::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 != NULL) {
-    set_write_fd(flag->write_fd());
-    return EXECUTE_TEST;
-  }
-
-  int pipe_fd[2];
-  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
-  // Clear the close-on-exec flag on the write end of the pipe, lest
-  // 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_case_name() + "." + info->name();
-  const std::string internal_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
-      + file_ + "|" + StreamableToString(line_) + "|"
-      + StreamableToString(death_test_index) + "|"
-      + StreamableToString(pipe_fd[1]);
-  Arguments args;
-  args.AddArguments(GetArgvsForDeathTestChildProcess());
-  args.AddArgument(filter_flag.c_str());
-  args.AddArgument(internal_flag.c_str());
-
-  DeathTest::set_last_death_test_message("");
-
-  CaptureStderr();
-  // See the comment in NoExecDeathTest::AssumeRole for why the next line
-  // is necessary.
-  FlushInfoLog();
-
-  const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]);
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
-  set_child_pid(child_pid);
-  set_read_fd(pipe_fd[0]);
-  set_spawned(true);
-  return OVERSEE_TEST;
-}
-
-# endif  // !GTEST_OS_WINDOWS
-
-// Creates a concrete DeathTest-derived class that depends on the
-// --gtest_death_test_style flag, and sets the pointer pointed to
-// 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, const RE* regex,
-                                     const char* file, int line,
-                                     DeathTest** test) {
-  UnitTestImpl* const impl = GetUnitTestImpl();
-  const InternalRunDeathTestFlag* const flag =
-      impl->internal_run_death_test_flag();
-  const int death_test_index = impl->current_test_info()
-      ->increment_death_test_count();
-
-  if (flag != NULL) {
-    if (death_test_index > flag->index()) {
-      DeathTest::set_last_death_test_message(
-          "Death test count (" + StreamableToString(death_test_index)
-          + ") somehow exceeded expected maximum ("
-          + StreamableToString(flag->index()) + ")");
-      return false;
-    }
-
-    if (!(flag->file() == file && flag->line() == line &&
-          flag->index() == death_test_index)) {
-      *test = NULL;
-      return true;
-    }
-  }
-
-# if GTEST_OS_WINDOWS
-
-  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
-      GTEST_FLAG(death_test_style) == "fast") {
-    *test = new WindowsDeathTest(statement, regex, file, line);
-  }
-
-# else
-
-  if (GTEST_FLAG(death_test_style) == "threadsafe") {
-    *test = new ExecDeathTest(statement, regex, file, line);
-  } else if (GTEST_FLAG(death_test_style) == "fast") {
-    *test = new NoExecDeathTest(statement, regex);
-  }
-
-# endif  // GTEST_OS_WINDOWS
-
-  else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
-    DeathTest::set_last_death_test_message(
-        "Unknown death test style \"" + GTEST_FLAG(death_test_style)
-        + "\" encountered");
-    return false;
-  }
-
-  return true;
-}
-
-# if GTEST_OS_WINDOWS
-// 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.
-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,
-                                                   FALSE,  // Non-inheritable.
-                                                   parent_process_id));
-  if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
-    DeathTestAbort("Unable to open parent process " +
-                   StreamableToString(parent_process_id));
-  }
-
-  // TODO(vladl@google.com): Replace the following check with a
-  // compile-time assertion when available.
-  GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));
-
-  const HANDLE write_handle =
-      reinterpret_cast<HANDLE>(write_handle_as_size_t);
-  HANDLE dup_write_handle;
-
-  // The newly initialized handle is accessible only in in the parent
-  // process. To obtain one accessible within the child, we need to use
-  // DuplicateHandle.
-  if (!::DuplicateHandle(parent_process_handle.Get(), write_handle,
-                         ::GetCurrentProcess(), &dup_write_handle,
-                         0x0,    // Requested privileges ignored since
-                                 // DUPLICATE_SAME_ACCESS is used.
-                         FALSE,  // Request non-inheritable handler.
-                         DUPLICATE_SAME_ACCESS)) {
-    DeathTestAbort("Unable to duplicate the pipe handle " +
-                   StreamableToString(write_handle_as_size_t) +
-                   " from the parent process " +
-                   StreamableToString(parent_process_id));
-  }
-
-  const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t);
-  HANDLE dup_event_handle;
-
-  if (!::DuplicateHandle(parent_process_handle.Get(), event_handle,
-                         ::GetCurrentProcess(), &dup_event_handle,
-                         0x0,
-                         FALSE,
-                         DUPLICATE_SAME_ACCESS)) {
-    DeathTestAbort("Unable to duplicate the event handle " +
-                   StreamableToString(event_handle_as_size_t) +
-                   " from the parent process " +
-                   StreamableToString(parent_process_id));
-  }
-
-  const int write_fd =
-      ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND);
-  if (write_fd == -1) {
-    DeathTestAbort("Unable to convert pipe handle " +
-                   StreamableToString(write_handle_as_size_t) +
-                   " to a file descriptor");
-  }
-
-  // Signals the parent that the write end of the pipe has been acquired
-  // so the parent can release its own write end.
-  ::SetEvent(dup_event_handle);
-
-  return write_fd;
-}
-# endif  // GTEST_OS_WINDOWS
-
-// Returns a newly created InternalRunDeathTestFlag object with fields
-// 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 NULL;
-
-  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
-  // can use it here.
-  int line = -1;
-  int index = -1;
-  ::std::vector< ::std::string> fields;
-  SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields);
-  int write_fd = -1;
-
-# if GTEST_OS_WINDOWS
-
-  unsigned int parent_process_id = 0;
-  size_t write_handle_as_size_t = 0;
-  size_t event_handle_as_size_t = 0;
-
-  if (fields.size() != 6
-      || !ParseNaturalNumber(fields[1], &line)
-      || !ParseNaturalNumber(fields[2], &index)
-      || !ParseNaturalNumber(fields[3], &parent_process_id)
-      || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
-      || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
-    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
-                   GTEST_FLAG(internal_run_death_test));
-  }
-  write_fd = GetStatusFileDescriptor(parent_process_id,
-                                     write_handle_as_size_t,
-                                     event_handle_as_size_t);
-# else
-
-  if (fields.size() != 4
-      || !ParseNaturalNumber(fields[1], &line)
-      || !ParseNaturalNumber(fields[2], &index)
-      || !ParseNaturalNumber(fields[3], &write_fd)) {
-    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
-        + GTEST_FLAG(internal_run_death_test));
-  }
-
-# endif  // GTEST_OS_WINDOWS
-
-  return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
-}
-
-}  // namespace internal
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-filepath.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-filepath.cc
deleted file mode 100644
index 0292dc11..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-filepath.cc
+++ /dev/null
@@ -1,387 +0,0 @@
-// 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.
-//
-// Authors: keith.ray@gmail.com (Keith Ray)
-
-#include "gtest/gtest-message.h"
-#include "gtest/internal/gtest-filepath.h"
-#include "gtest/internal/gtest-port.h"
-
-#include <stdlib.h>
-
-#if GTEST_OS_WINDOWS_MOBILE
-# include <windows.h>
-#elif GTEST_OS_WINDOWS
-# include <direct.h>
-# include <io.h>
-#elif GTEST_OS_SYMBIAN
-// Symbian OpenC has PATH_MAX in sys/syslimits.h
-# include <sys/syslimits.h>
-#else
-# include <limits.h>
-# include <climits>  // Some Linux distributions define PATH_MAX here.
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-#if GTEST_OS_WINDOWS
-# define GTEST_PATH_MAX_ _MAX_PATH
-#elif defined(PATH_MAX)
-# define GTEST_PATH_MAX_ PATH_MAX
-#elif defined(_XOPEN_PATH_MAX)
-# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX
-#else
-# define GTEST_PATH_MAX_ _POSIX_PATH_MAX
-#endif  // GTEST_OS_WINDOWS
-
-#include "gtest/internal/gtest-string.h"
-
-namespace testing {
-namespace internal {
-
-#if GTEST_OS_WINDOWS
-// On Windows, '\\' is the standard path separator, but many tools and the
-// Windows API also accept '/' as an alternate path separator. Unless otherwise
-// noted, a file path can contain either kind of path separators, or a mixture
-// of them.
-const char kPathSeparator = '\\';
-const char kAlternatePathSeparator = '/';
-const char kAlternatePathSeparatorString[] = "/";
-# if GTEST_OS_WINDOWS_MOBILE
-// Windows CE doesn't have a current directory. You should not use
-// the current directory in tests on Windows CE, but this at least
-// provides a reasonable fallback.
-const char kCurrentDirectoryString[] = "\\";
-// Windows CE doesn't define INVALID_FILE_ATTRIBUTES
-const DWORD kInvalidFileAttributes = 0xffffffff;
-# else
-const char kCurrentDirectoryString[] = ".\\";
-# endif  // GTEST_OS_WINDOWS_MOBILE
-#else
-const char kPathSeparator = '/';
-const char kCurrentDirectoryString[] = "./";
-#endif  // GTEST_OS_WINDOWS
-
-// Returns whether the given character is a valid path separator.
-static bool IsPathSeparator(char c) {
-#if GTEST_HAS_ALT_PATH_SEP_
-  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
-#else
-  return c == kPathSeparator;
-#endif
-}
-
-// Returns the current working directory, or "" if unsuccessful.
-FilePath FilePath::GetCurrentDir() {
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
-  // Windows CE doesn't 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)) == NULL ? "" : cwd);
-#else
-  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
-  char* result = getcwd(cwd, sizeof(cwd));
-# if GTEST_OS_NACL
-  // 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 == NULL ? kCurrentDirectoryString : cwd);
-# endif  // GTEST_OS_NACL
-  return FilePath(result == NULL ? "" : cwd);
-#endif  // GTEST_OS_WINDOWS_MOBILE
-}
-
-// Returns a copy of the FilePath with the case-insensitive extension removed.
-// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
-// FilePath("dir/file"). If a case-insensitive extension is not
-// found, returns a copy of the original FilePath.
-FilePath FilePath::RemoveExtension(const char* extension) const {
-  const std::string dot_extension = std::string(".") + extension;
-  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
-    return FilePath(pathname_.substr(
-        0, pathname_.length() - dot_extension.length()));
-  }
-  return *this;
-}
-
-// Returns a pointer to the last occurence 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 {
-  const char* const last_sep = strrchr(c_str(), kPathSeparator);
-#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 != NULL &&
-      (last_sep == NULL || last_alt_sep > last_sep)) {
-    return last_alt_sep;
-  }
-#endif
-  return last_sep;
-}
-
-// Returns a copy of the FilePath with the directory part removed.
-// Example: FilePath("path/to/file").RemoveDirectoryName() returns
-// FilePath("file"). If there is no directory part ("just_a_file"), it returns
-// the FilePath unmodified. If there is no file part ("just_a_dir/") it
-// returns an empty FilePath ("").
-// On Windows platform, '\' is the path separator, otherwise it is '/'.
-FilePath FilePath::RemoveDirectoryName() const {
-  const char* const last_sep = FindLastPathSeparator();
-  return last_sep ? FilePath(last_sep + 1) : *this;
-}
-
-// RemoveFileName returns the directory path with the filename removed.
-// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
-// If the FilePath is "a_file" or "/a_file", RemoveFileName returns
-// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
-// not have a file, like "just/a/dir/", it returns the FilePath unmodified.
-// On Windows platform, '\' is the path separator, otherwise it is '/'.
-FilePath FilePath::RemoveFileName() const {
-  const char* const last_sep = FindLastPathSeparator();
-  std::string dir;
-  if (last_sep) {
-    dir = std::string(c_str(), last_sep + 1 - c_str());
-  } else {
-    dir = kCurrentDirectoryString;
-  }
-  return FilePath(dir);
-}
-
-// Helper functions for naming files in a directory for xml output.
-
-// Given directory = "dir", base_name = "test", number = 0,
-// extension = "xml", returns "dir/test.xml". If number is greater
-// than zero (e.g., 12), returns "dir/test_12.xml".
-// On Windows platform, uses \ as the separator rather than /.
-FilePath FilePath::MakeFileName(const FilePath& directory,
-                                const FilePath& base_name,
-                                int number,
-                                const char* extension) {
-  std::string file;
-  if (number == 0) {
-    file = base_name.string() + "." + extension;
-  } else {
-    file = base_name.string() + "_" + StreamableToString(number)
-        + "." + extension;
-  }
-  return ConcatPaths(directory, FilePath(file));
-}
-
-// Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml".
-// On Windows, uses \ as the separator rather than /.
-FilePath FilePath::ConcatPaths(const FilePath& directory,
-                               const FilePath& relative_path) {
-  if (directory.IsEmpty())
-    return relative_path;
-  const FilePath dir(directory.RemoveTrailingPathSeparator());
-  return FilePath(dir.string() + kPathSeparator + relative_path.string());
-}
-
-// Returns true if pathname describes something findable in the file-system,
-// either a file, directory, or whatever.
-bool FilePath::FileOrDirectoryExists() const {
-#if GTEST_OS_WINDOWS_MOBILE
-  LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
-  const DWORD attributes = GetFileAttributes(unicode);
-  delete [] unicode;
-  return attributes != kInvalidFileAttributes;
-#else
-  posix::StatStruct file_stat;
-  return posix::Stat(pathname_.c_str(), &file_stat) == 0;
-#endif  // GTEST_OS_WINDOWS_MOBILE
-}
-
-// Returns true if pathname describes a directory in the file-system
-// that exists.
-bool FilePath::DirectoryExists() const {
-  bool result = false;
-#if GTEST_OS_WINDOWS
-  // Don't strip off trailing separator if path is a root directory on
-  // Windows (like "C:\\").
-  const FilePath& path(IsRootDirectory() ? *this :
-                                           RemoveTrailingPathSeparator());
-#else
-  const FilePath& path(*this);
-#endif
-
-#if GTEST_OS_WINDOWS_MOBILE
-  LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
-  const DWORD attributes = GetFileAttributes(unicode);
-  delete [] unicode;
-  if ((attributes != kInvalidFileAttributes) &&
-      (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
-    result = true;
-  }
-#else
-  posix::StatStruct file_stat;
-  result = posix::Stat(path.c_str(), &file_stat) == 0 &&
-      posix::IsDir(file_stat);
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-  return result;
-}
-
-// Returns true if pathname describes a root directory. (Windows has one
-// root directory per disk drive.)
-bool FilePath::IsRootDirectory() const {
-#if GTEST_OS_WINDOWS
-  // TODO(wan@google.com): on Windows a network share like
-  // \\server\share can be a root directory, although it cannot be the
-  // current directory.  Handle this properly.
-  return pathname_.length() == 3 && IsAbsolutePath();
-#else
-  return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
-#endif
-}
-
-// Returns true if pathname describes an absolute path.
-bool FilePath::IsAbsolutePath() const {
-  const char* const name = pathname_.c_str();
-#if GTEST_OS_WINDOWS
-  return pathname_.length() >= 3 &&
-     ((name[0] >= 'a' && name[0] <= 'z') ||
-      (name[0] >= 'A' && name[0] <= 'Z')) &&
-     name[1] == ':' &&
-     IsPathSeparator(name[2]);
-#else
-  return IsPathSeparator(name[0]);
-#endif
-}
-
-// Returns a pathname for a file that does not currently exist. The pathname
-// will be directory/base_name.extension or
-// directory/base_name_<number>.extension if directory/base_name.extension
-// already exists. The number will be incremented until a pathname is found
-// that does not already exist.
-// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
-// There could be a race condition if two or more processes are calling this
-// function at the same time -- they could both pick the same filename.
-FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
-                                          const FilePath& base_name,
-                                          const char* extension) {
-  FilePath full_pathname;
-  int number = 0;
-  do {
-    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
-  } while (full_pathname.FileOrDirectoryExists());
-  return full_pathname;
-}
-
-// Returns true if FilePath ends with a path separator, which indicates that
-// it is intended to represent a directory. Returns false otherwise.
-// This does NOT check that a directory (or file) actually exists.
-bool FilePath::IsDirectory() const {
-  return !pathname_.empty() &&
-         IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]);
-}
-
-// Create directories so that path exists. Returns true if successful or if
-// the directories already exist; returns false if unable to create directories
-// for any reason.
-bool FilePath::CreateDirectoriesRecursively() const {
-  if (!this->IsDirectory()) {
-    return false;
-  }
-
-  if (pathname_.length() == 0 || this->DirectoryExists()) {
-    return true;
-  }
-
-  const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
-  return parent.CreateDirectoriesRecursively() && this->CreateFolder();
-}
-
-// Create the directory so that path exists. Returns true if successful or
-// if the directory already exists; returns false if unable to create the
-// directory for any reason, including if the parent directory does not
-// exist. Not named "CreateDirectory" because that's a macro on Windows.
-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, NULL) ? 0 : -1;
-  delete [] unicode;
-#elif GTEST_OS_WINDOWS
-  int result = _mkdir(pathname_.c_str());
-#else
-  int result = mkdir(pathname_.c_str(), 0777);
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-  if (result == -1) {
-    return this->DirectoryExists();  // An error is OK if the directory exists.
-  }
-  return true;  // No error.
-}
-
-// If input name has a trailing separator character, remove it and return the
-// name, otherwise return the name string unmodified.
-// On Windows platform, uses \ as the separator, other platforms use /.
-FilePath FilePath::RemoveTrailingPathSeparator() const {
-  return IsDirectory()
-      ? FilePath(pathname_.substr(0, pathname_.length() - 1))
-      : *this;
-}
-
-// Removes any redundant separators that might be in the pathname.
-// For example, "bar///foo" becomes "bar/foo". Does not eliminate other
-// redundancies that might be in a pathname involving "." or "..".
-// TODO(wan@google.com): handle Windows network shares (e.g. \\server\share).
-void FilePath::Normalize() {
-  if (pathname_.c_str() == NULL) {
-    pathname_ = "";
-    return;
-  }
-  const char* src = pathname_.c_str();
-  char* const dest = new char[pathname_.length() + 1];
-  char* dest_ptr = dest;
-  memset(dest_ptr, 0, pathname_.length() + 1);
-
-  while (*src != '\0') {
-    *dest_ptr = *src;
-    if (!IsPathSeparator(*src)) {
-      src++;
-    } else {
-#if GTEST_HAS_ALT_PATH_SEP_
-      if (*dest_ptr == kAlternatePathSeparator) {
-        *dest_ptr = kPathSeparator;
-      }
-#endif
-      while (IsPathSeparator(*src))
-        src++;
-    }
-    dest_ptr++;
-  }
-  *dest_ptr = '\0';
-  pathname_ = dest;
-  delete[] dest;
-}
-
-}  // namespace internal
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-internal-inl.h b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-internal-inl.h
deleted file mode 100644
index ed8a682a..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-internal-inl.h
+++ /dev/null
@@ -1,1183 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Utility functions and classes used by the Google C++ testing framework.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// This file contains purely Google Test's internal implementation.  Please
-// DO NOT #INCLUDE IT IN A USER PROGRAM.
-
-#ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_
-#define GTEST_SRC_GTEST_INTERNAL_INL_H_
-
-// GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is
-// part of Google Test's implementation; otherwise it's undefined.
-#if !GTEST_IMPLEMENTATION_
-// If this file is included from the user's code, just say no.
-# error "gtest-internal-inl.h is part of Google Test's internal implementation."
-# error "It must not be included except by Google Test itself."
-#endif  // GTEST_IMPLEMENTATION_
-
-#ifndef _WIN32_WCE
-# include <errno.h>
-#endif  // !_WIN32_WCE
-#include <stddef.h>
-#include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
-#include <string.h>  // For memmove.
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-#include "gtest/internal/gtest-port.h"
-
-#if GTEST_CAN_STREAM_RESULTS_
-# include <arpa/inet.h>  // NOLINT
-# include <netdb.h>  // NOLINT
-#endif
-
-#if GTEST_OS_WINDOWS
-# include <windows.h>  // NOLINT
-#endif  // GTEST_OS_WINDOWS
-
-#include "gtest/gtest.h"  // NOLINT
-#include "gtest/gtest-spi.h"
-
-namespace testing {
-
-// Declares the flags.
-//
-// We don't want the users to modify this flag in the code, but want
-// Google Test's own unit tests to be able to access it. Therefore we
-// declare it here as opposed to in gtest.h.
-GTEST_DECLARE_bool_(death_test_use_fork);
-
-namespace internal {
-
-// The value of GetTestTypeId() as seen from within the Google Test
-// library.  This is solely for testing GetTestTypeId().
-GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;
-
-// Names of the flags (needed for parsing Google Test flags).
-const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
-const char kBreakOnFailureFlag[] = "break_on_failure";
-const char kCatchExceptionsFlag[] = "catch_exceptions";
-const char kColorFlag[] = "color";
-const char kFilterFlag[] = "filter";
-const char kListTestsFlag[] = "list_tests";
-const char kOutputFlag[] = "output";
-const char kPrintTimeFlag[] = "print_time";
-const char kRandomSeedFlag[] = "random_seed";
-const char kRepeatFlag[] = "repeat";
-const char kShuffleFlag[] = "shuffle";
-const char kStackTraceDepthFlag[] = "stack_trace_depth";
-const char kStreamResultToFlag[] = "stream_result_to";
-const char kThrowOnFailureFlag[] = "throw_on_failure";
-const char kFlagfileFlag[] = "flagfile";
-
-// A valid random seed must be in [1, kMaxRandomSeed].
-const int kMaxRandomSeed = 99999;
-
-// g_help_flag is true iff 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 iff Google Test should use colors in the output.
-GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
-
-// Formats the given time in milliseconds as seconds.
-GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);
-
-// Converts the given time in milliseconds to a date string in the ISO 8601
-// format, without the timezone information.  N.B.: due to the use the
-// non-reentrant localtime() function, this function is not thread safe.  Do
-// not use it in any code that can be called from multiple threads.
-GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);
-
-// Parses a string for an Int32 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.
-GTEST_API_ bool ParseInt32Flag(
-    const char* str, const char* flag, Int32* value);
-
-// Returns a random seed in range [1, kMaxRandomSeed] based on the
-// given --gtest_random_seed flag value.
-inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
-  const unsigned int raw_seed = (random_seed_flag == 0) ?
-      static_cast<unsigned int>(GetTimeInMillis()) :
-      static_cast<unsigned int>(random_seed_flag);
-
-  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
-  // it's easy to type.
-  const int normalized_seed =
-      static_cast<int>((raw_seed - 1U) %
-                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
-  return normalized_seed;
-}
-
-// Returns the first valid random seed after 'seed'.  The behavior is
-// undefined if 'seed' is invalid.  The seed after kMaxRandomSeed is
-// considered to be 1.
-inline int GetNextRandomSeed(int seed) {
-  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
-      << "Invalid random seed " << seed << " - must be in [1, "
-      << kMaxRandomSeed << "].";
-  const int next_seed = seed + 1;
-  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
-}
-
-// This class saves the values of all Google Test flags in its c'tor, and
-// restores them in its d'tor.
-class GTestFlagSaver {
- public:
-  // The c'tor.
-  GTestFlagSaver() {
-    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
-    break_on_failure_ = GTEST_FLAG(break_on_failure);
-    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
-    color_ = GTEST_FLAG(color);
-    death_test_style_ = GTEST_FLAG(death_test_style);
-    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
-    filter_ = GTEST_FLAG(filter);
-    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
-    list_tests_ = GTEST_FLAG(list_tests);
-    output_ = GTEST_FLAG(output);
-    print_time_ = GTEST_FLAG(print_time);
-    random_seed_ = GTEST_FLAG(random_seed);
-    repeat_ = GTEST_FLAG(repeat);
-    shuffle_ = GTEST_FLAG(shuffle);
-    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
-    stream_result_to_ = GTEST_FLAG(stream_result_to);
-    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
-  }
-
-  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
-  ~GTestFlagSaver() {
-    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
-    GTEST_FLAG(break_on_failure) = break_on_failure_;
-    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
-    GTEST_FLAG(color) = color_;
-    GTEST_FLAG(death_test_style) = death_test_style_;
-    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
-    GTEST_FLAG(filter) = filter_;
-    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
-    GTEST_FLAG(list_tests) = list_tests_;
-    GTEST_FLAG(output) = output_;
-    GTEST_FLAG(print_time) = print_time_;
-    GTEST_FLAG(random_seed) = random_seed_;
-    GTEST_FLAG(repeat) = repeat_;
-    GTEST_FLAG(shuffle) = shuffle_;
-    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
-    GTEST_FLAG(stream_result_to) = stream_result_to_;
-    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
-  }
-
- private:
-  // Fields for saving the original values of flags.
-  bool also_run_disabled_tests_;
-  bool break_on_failure_;
-  bool catch_exceptions_;
-  std::string color_;
-  std::string death_test_style_;
-  bool death_test_use_fork_;
-  std::string filter_;
-  std::string internal_run_death_test_;
-  bool list_tests_;
-  std::string output_;
-  bool print_time_;
-  internal::Int32 random_seed_;
-  internal::Int32 repeat_;
-  bool shuffle_;
-  internal::Int32 stack_trace_depth_;
-  std::string stream_result_to_;
-  bool throw_on_failure_;
-} GTEST_ATTRIBUTE_UNUSED_;
-
-// Converts a Unicode code point to a narrow string in UTF-8 encoding.
-// code_point parameter is of type UInt32 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)".
-GTEST_API_ std::string CodePointToUtf8(UInt32 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, Symbian OS)
-//   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
-// of wchar_t characters processed. -1 is used when the entire string
-// should be processed.
-// If the string contains code points that are not valid Unicode code points
-// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
-// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
-// and contains invalid UTF-16 surrogate pairs, values in those pairs
-// will be encoded as individual Unicode characters from Basic Normal Plane.
-GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars);
-
-// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
-// if the variable is present. If a file already exists at this location, this
-// function will write over it. If the variable is present, but the file cannot
-// be created, prints an error and exits.
-void WriteToShardStatusFileIfNeeded();
-
-// Checks whether sharding is enabled by examining the relevant
-// environment variable values. If the variables are present,
-// but inconsistent (e.g., shard_index >= total_shards), prints
-// an error and exits. If in_subprocess_for_death_test, sharding is
-// disabled because it must only be applied to the original test
-// process. Otherwise, we could filter out death tests we intended to execute.
-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 an Int32. If it is unset,
-// returns default_val. If it is not an Int32, prints an error and
-// and aborts.
-GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val);
-
-// Given the total number of shards, the shard index, and the test id,
-// returns true iff 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);
-
-// STL container utilities.
-
-// Returns the number of elements in the given container that satisfy
-// the given predicate.
-template <class Container, typename Predicate>
-inline int CountIf(const Container& c, Predicate predicate) {
-  // Implemented as an explicit loop since std::count_if() in libCstd on
-  // Solaris has a non-standard signature.
-  int count = 0;
-  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
-    if (predicate(*it))
-      ++count;
-  }
-  return count;
-}
-
-// Applies a function/functor to each element in the container.
-template <class Container, typename Functor>
-void ForEach(const Container& c, Functor functor) {
-  std::for_each(c.begin(), c.end(), functor);
-}
-
-// Returns the i-th element of the vector, or default_value if i is not
-// 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[i];
-}
-
-// Performs an in-place shuffle of a range of the vector's elements.
-// 'begin' and 'end' are element indices as an STL-style range;
-// i.e. [begin, end) are shuffled, where 'end' == size() means to
-// shuffle to the end of the vector.
-template <typename E>
-void ShuffleRange(internal::Random* random, int begin, int end,
-                  std::vector<E>* v) {
-  const int size = static_cast<int>(v->size());
-  GTEST_CHECK_(0 <= begin && begin <= size)
-      << "Invalid shuffle range start " << begin << ": must be in range [0, "
-      << size << "].";
-  GTEST_CHECK_(begin <= end && end <= size)
-      << "Invalid shuffle range finish " << end << ": must be in range ["
-      << begin << ", " << size << "].";
-
-  // Fisher-Yates shuffle, from
-  // 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 + random->Generate(range_width);
-    std::swap((*v)[selected], (*v)[last_in_range]);
-  }
-}
-
-// Performs an in-place shuffle of the vector's elements.
-template <typename E>
-inline void Shuffle(internal::Random* random, std::vector<E>* v) {
-  ShuffleRange(random, 0, static_cast<int>(v->size()), v);
-}
-
-// A function for deleting an object.  Handy for being used as a
-// functor.
-template <typename T>
-static void Delete(T* x) {
-  delete x;
-}
-
-// A predicate that checks the key of a TestProperty against a known key.
-//
-// TestPropertyKeyIs is copyable.
-class TestPropertyKeyIs {
- public:
-  // Constructor.
-  //
-  // TestPropertyKeyIs has NO default constructor.
-  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
-
-  // Returns true iff the test name of test property matches on key_.
-  bool operator()(const TestProperty& test_property) const {
-    return test_property.key() == key_;
-  }
-
- private:
-  std::string key_;
-};
-
-// Class UnitTestOptions.
-//
-// This class contains functions for processing options the user
-// specifies when running the tests.  It has only static members.
-//
-// In most cases, the user can specify an option using either an
-// environment variable or a command line flag.  E.g. you can set the
-// test filter using either GTEST_FILTER or --gtest_filter.  If both
-// the variable and the flag are present, the latter overrides the
-// former.
-class GTEST_API_ UnitTestOptions {
- public:
-  // Functions for processing the gtest_output flag.
-
-  // Returns the output format, or "" for normal printed output.
-  static std::string GetOutputFormat();
-
-  // Returns the absolute path of the requested output file, or the
-  // default (test_detail.xml in the original working directory) if
-  // none was explicitly specified.
-  static std::string GetAbsolutePathToOutputFile();
-
-  // Functions for processing the gtest_filter flag.
-
-  // Returns true iff the wildcard pattern matches the string.  The
-  // first ':' or '\0' character in pattern marks the end of it.
-  //
-  // This recursive algorithm isn't very efficient, but is clear and
-  // works well enough for matching test names, which are short.
-  static bool PatternMatchesString(const char *pattern, const char *str);
-
-  // Returns true iff the user-specified filter matches the test case
-  // name and the test name.
-  static bool FilterMatchesTest(const std::string &test_case_name,
-                                const std::string &test_name);
-
-#if GTEST_OS_WINDOWS
-  // Function for supporting the gtest_catch_exception flag.
-
-  // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
-  // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
-  // This function is useful as an __except condition.
-  static int GTestShouldProcessSEH(DWORD exception_code);
-#endif  // GTEST_OS_WINDOWS
-
-  // Returns true if "name" matches the ':' separated list of glob-style
-  // filters in "filter".
-  static bool MatchesFilter(const std::string& name, const char* filter);
-};
-
-// Returns the current application's name, removing directory path if that
-// is present.  Used by UnitTestOptions::GetOutputFile.
-GTEST_API_ FilePath GetCurrentExecutableName();
-
-// The role interface for getting the OS stack trace as a string.
-class OsStackTraceGetterInterface {
- public:
-  OsStackTraceGetterInterface() {}
-  virtual ~OsStackTraceGetterInterface() {}
-
-  // Returns the current OS stack trace as an std::string.  Parameters:
-  //
-  //   max_depth  - the maximum number of stack frames to be included
-  //                in the trace.
-  //   skip_count - the number of top frames to be skipped; doesn't count
-  //                against max_depth.
-  virtual 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
-  // CurrentStackTrace() will use to find and hide Google Test stack frames.
-  virtual void UponLeavingGTest() = 0;
-
-  // This string is inserted in place of stack frames that are part of
-  // Google Test's implementation.
-  static const char* const kElidedFramesMarker;
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
-};
-
-// A working implementation of the OsStackTraceGetterInterface interface.
-class OsStackTraceGetter : public OsStackTraceGetterInterface {
- public:
-  OsStackTraceGetter() {}
-
-  virtual string CurrentStackTrace(int max_depth, int skip_count);
-  virtual void UponLeavingGTest();
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
-};
-
-// Information about a Google Test trace point.
-struct TraceInfo {
-  const char* file;
-  int line;
-  std::string message;
-};
-
-// This is the default global test part result reporter used in UnitTestImpl.
-// This class should only be used by UnitTestImpl.
-class DefaultGlobalTestPartResultReporter
-  : public TestPartResultReporterInterface {
- public:
-  explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
-  // Implements the TestPartResultReporterInterface. Reports the test part
-  // result in the current test.
-  virtual void ReportTestPartResult(const TestPartResult& result);
-
- private:
-  UnitTestImpl* const unit_test_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
-};
-
-// This is the default per thread test part result reporter used in
-// UnitTestImpl. This class should only be used by UnitTestImpl.
-class DefaultPerThreadTestPartResultReporter
-    : public TestPartResultReporterInterface {
- public:
-  explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test);
-  // Implements the TestPartResultReporterInterface. The implementation just
-  // delegates to the current global test part result reporter of *unit_test_.
-  virtual void ReportTestPartResult(const TestPartResult& result);
-
- private:
-  UnitTestImpl* const unit_test_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
-};
-
-// The private implementation of the UnitTest class.  We don't protect
-// the methods under a mutex, as this class is not accessible by a
-// user and the UnitTest class that delegates work to this class does
-// proper locking.
-class GTEST_API_ UnitTestImpl {
- public:
-  explicit UnitTestImpl(UnitTest* parent);
-  virtual ~UnitTestImpl();
-
-  // There are two different ways to register your own TestPartResultReporter.
-  // You can register your own repoter to listen either only for test results
-  // from the current thread or for results from all threads.
-  // By default, each per-thread test result repoter just passes a new
-  // TestPartResult to the global test result reporter, which registers the
-  // test part result for the currently running test.
-
-  // Returns the global test part result reporter.
-  TestPartResultReporterInterface* GetGlobalTestPartResultReporter();
-
-  // Sets the global test part result reporter.
-  void SetGlobalTestPartResultReporter(
-      TestPartResultReporterInterface* reporter);
-
-  // Returns the test part result reporter for the current thread.
-  TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread();
-
-  // Sets the test part result reporter for the current thread.
-  void SetTestPartResultReporterForCurrentThread(
-      TestPartResultReporterInterface* reporter);
-
-  // Gets the number of successful test cases.
-  int successful_test_case_count() const;
-
-  // Gets the number of failed test cases.
-  int failed_test_case_count() const;
-
-  // Gets the number of all test cases.
-  int total_test_case_count() const;
-
-  // Gets the number of all test cases that contain at least one test
-  // that should run.
-  int test_case_to_run_count() const;
-
-  // Gets the number of successful tests.
-  int successful_test_count() const;
-
-  // Gets the number of failed tests.
-  int failed_test_count() const;
-
-  // Gets the number of disabled tests that will be reported in the XML report.
-  int reportable_disabled_test_count() const;
-
-  // Gets the number of disabled tests.
-  int disabled_test_count() const;
-
-  // Gets the number of tests to be printed in the XML report.
-  int reportable_test_count() const;
-
-  // Gets the number of all tests.
-  int total_test_count() const;
-
-  // Gets the number of tests that should run.
-  int test_to_run_count() const;
-
-  // Gets the time of the test program start, in ms from the start of the
-  // UNIX epoch.
-  TimeInMillis start_timestamp() const { return start_timestamp_; }
-
-  // Gets the elapsed time, in milliseconds.
-  TimeInMillis elapsed_time() const { return elapsed_time_; }
-
-  // Returns true iff the unit test passed (i.e. all test cases passed).
-  bool Passed() const { return !Failed(); }
-
-  // Returns true iff the unit test failed (i.e. some test case failed
-  // or something outside of all tests failed).
-  bool Failed() const {
-    return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed();
-  }
-
-  // Gets the i-th test case among all the test cases. i can range from 0 to
-  // total_test_case_count() - 1. If i is not in that range, returns NULL.
-  const TestCase* GetTestCase(int i) const {
-    const int index = GetElementOr(test_case_indices_, i, -1);
-    return index < 0 ? NULL : test_cases_[i];
-  }
-
-  // Gets the i-th test case among all the test cases. i can range from 0 to
-  // total_test_case_count() - 1. If i is not in that range, returns NULL.
-  TestCase* GetMutableTestCase(int i) {
-    const int index = GetElementOr(test_case_indices_, i, -1);
-    return index < 0 ? NULL : test_cases_[index];
-  }
-
-  // Provides access to the event listener list.
-  TestEventListeners* listeners() { return &listeners_; }
-
-  // Returns the TestResult for the test that's currently running, or
-  // the TestResult for the ad hoc test if no test is running.
-  TestResult* current_test_result();
-
-  // Returns the TestResult for the ad hoc test.
-  const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }
-
-  // Sets the OS stack trace getter.
-  //
-  // Does nothing if the input and the current OS stack trace getter
-  // are the same; otherwise, deletes the old getter and makes the
-  // input the current getter.
-  void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);
-
-  // Returns the current OS stack trace getter if it is not NULL;
-  // otherwise, creates an OsStackTraceGetter, makes it the current
-  // getter, and returns it.
-  OsStackTraceGetterInterface* os_stack_trace_getter();
-
-  // Returns the current OS stack trace as an std::string.
-  //
-  // The maximum number of stack frames to be included is specified by
-  // the gtest_stack_trace_depth flag.  The skip_count parameter
-  // specifies the number of top frames to be skipped, which doesn't
-  // count against the number of frames to be included.
-  //
-  // For example, if Foo() calls Bar(), which in turn calls
-  // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
-  // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
-  std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_;
-
-  // Finds and returns a TestCase with the given name.  If one doesn't
-  // exist, creates one and returns it.
-  //
-  // Arguments:
-  //
-  //   test_case_name: name of the test case
-  //   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 case
-  //   tear_down_tc:   pointer to the function that tears down the test case
-  TestCase* GetTestCase(const char* test_case_name,
-                        const char* type_param,
-                        Test::SetUpTestCaseFunc set_up_tc,
-                        Test::TearDownTestCaseFunc tear_down_tc);
-
-  // Adds a TestInfo to the unit test.
-  //
-  // Arguments:
-  //
-  //   set_up_tc:    pointer to the function that sets up the test case
-  //   tear_down_tc: pointer to the function that tears down the test case
-  //   test_info:    the TestInfo object
-  void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
-                   Test::TearDownTestCaseFunc tear_down_tc,
-                   TestInfo* test_info) {
-    // 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
-    // the user may have changed the current directory before calling
-    // RUN_ALL_TESTS().  Therefore we capture the current directory in
-    // AddTestInfo(), which is called to register a TEST or TEST_F
-    // before main() is reached.
-    if (original_working_dir_.IsEmpty()) {
-      original_working_dir_.Set(FilePath::GetCurrentDir());
-      GTEST_CHECK_(!original_working_dir_.IsEmpty())
-          << "Failed to get the current working directory.";
-    }
-
-    GetTestCase(test_info->test_case_name(),
-                test_info->type_param(),
-                set_up_tc,
-                tear_down_tc)->AddTestInfo(test_info);
-  }
-
-#if GTEST_HAS_PARAM_TEST
-  // Returns ParameterizedTestCaseRegistry object used to keep track of
-  // value-parameterized tests and instantiate and register them.
-  internal::ParameterizedTestCaseRegistry& parameterized_test_registry() {
-    return parameterized_test_registry_;
-  }
-#endif  // GTEST_HAS_PARAM_TEST
-
-  // Sets the TestCase object for the test that's currently running.
-  void set_current_test_case(TestCase* a_current_test_case) {
-    current_test_case_ = a_current_test_case;
-  }
-
-  // Sets the TestInfo object for the test that's currently running.  If
-  // current_test_info is NULL, the assertion results will be stored in
-  // ad_hoc_test_result_.
-  void set_current_test_info(TestInfo* a_current_test_info) {
-    current_test_info_ = a_current_test_info;
-  }
-
-  // Registers all parameterized tests defined using TEST_P and
-  // INSTANTIATE_TEST_CASE_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
-  // present but does nothing.
-  void RegisterParameterizedTests();
-
-  // Runs all tests in this UnitTest object, prints the result, and
-  // returns true if all tests are successful.  If any exception is
-  // thrown during a test, this test is considered to be failed, but
-  // the rest of the tests will still be run.
-  bool RunAllTests();
-
-  // Clears the results of all tests, except the ad hoc tests.
-  void ClearNonAdHocTestResult() {
-    ForEach(test_cases_, TestCase::ClearTestCaseResult);
-  }
-
-  // Clears the results of ad-hoc test assertions.
-  void ClearAdHocTestResult() {
-    ad_hoc_test_result_.Clear();
-  }
-
-  // Adds a TestProperty to the current TestResult object when invoked in a
-  // context of a test or a test case, 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);
-
-  enum ReactionToSharding {
-    HONOR_SHARDING_PROTOCOL,
-    IGNORE_SHARDING_PROTOCOL
-  };
-
-  // 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 TestCase 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.
-  int FilterTests(ReactionToSharding shard_tests);
-
-  // Prints the names of the tests matching the user-specified filter flag.
-  void ListTestsMatchingFilter();
-
-  const TestCase* current_test_case() const { return current_test_case_; }
-  TestInfo* current_test_info() { return current_test_info_; }
-  const TestInfo* current_test_info() const { return current_test_info_; }
-
-  // Returns the vector of environments that need to be set-up/torn-down
-  // before/after the tests are run.
-  std::vector<Environment*>& environments() { return environments_; }
-
-  // Getters for the per-thread Google Test trace stack.
-  std::vector<TraceInfo>& gtest_trace_stack() {
-    return *(gtest_trace_stack_.pointer());
-  }
-  const std::vector<TraceInfo>& gtest_trace_stack() const {
-    return gtest_trace_stack_.get();
-  }
-
-#if GTEST_HAS_DEATH_TEST
-  void InitDeathTestSubprocessControlInfo() {
-    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
-  }
-  // Returns a pointer to the parsed --gtest_internal_run_death_test
-  // flag, or NULL if that flag was not specified.
-  // This information is useful only in a death test child process.
-  // Must not be called before a call to InitGoogleTest.
-  const InternalRunDeathTestFlag* internal_run_death_test_flag() const {
-    return internal_run_death_test_flag_.get();
-  }
-
-  // Returns a pointer to the current death test factory.
-  internal::DeathTestFactory* death_test_factory() {
-    return death_test_factory_.get();
-  }
-
-  void SuppressTestEventsIfInSubprocess();
-
-  friend class ReplaceDeathTestFactory;
-#endif  // GTEST_HAS_DEATH_TEST
-
-  // Initializes the event listener performing XML output as specified by
-  // UnitTestOptions. Must not be called before InitGoogleTest.
-  void ConfigureXmlOutput();
-
-#if GTEST_CAN_STREAM_RESULTS_
-  // Initializes the event listener for streaming test results to a socket.
-  // Must not be called before InitGoogleTest.
-  void ConfigureStreamingOutput();
-#endif
-
-  // Performs initialization dependent upon flag values obtained in
-  // ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
-  // ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
-  // this function is also called from RunAllTests.  Since this function can be
-  // called more than once, it has to be idempotent.
-  void PostFlagParsingInit();
-
-  // Gets the random seed used at the start of the current test iteration.
-  int random_seed() const { return random_seed_; }
-
-  // Gets the random number generator.
-  internal::Random* random() { return &random_; }
-
-  // Shuffles all test cases, and the tests within each test case,
-  // making sure that death tests are still run first.
-  void ShuffleTests();
-
-  // Restores the test cases and tests to their order before the first shuffle.
-  void UnshuffleTests();
-
-  // Returns the value of GTEST_FLAG(catch_exceptions) at the moment
-  // UnitTest::Run() starts.
-  bool catch_exceptions() const { return catch_exceptions_; }
-
- private:
-  friend class ::testing::UnitTest;
-
-  // Used by UnitTest::Run() to capture the state of
-  // GTEST_FLAG(catch_exceptions) at the moment it starts.
-  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }
-
-  // The UnitTest object that owns this implementation object.
-  UnitTest* const parent_;
-
-  // The working directory when the first TEST() or TEST_F() was
-  // executed.
-  internal::FilePath original_working_dir_;
-
-  // The default test part result reporters.
-  DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_;
-  DefaultPerThreadTestPartResultReporter
-      default_per_thread_test_part_result_reporter_;
-
-  // Points to (but doesn't own) the global test part result reporter.
-  TestPartResultReporterInterface* global_test_part_result_repoter_;
-
-  // Protects read and write access to global_test_part_result_reporter_.
-  internal::Mutex global_test_part_result_reporter_mutex_;
-
-  // Points to (but doesn't own) the per-thread test part result reporter.
-  internal::ThreadLocal<TestPartResultReporterInterface*>
-      per_thread_test_part_result_reporter_;
-
-  // The vector of environments that need to be set-up/torn-down
-  // before/after the tests are run.
-  std::vector<Environment*> environments_;
-
-  // The vector of TestCases in their original order.  It owns the
-  // elements in the vector.
-  std::vector<TestCase*> test_cases_;
-
-  // Provides a level of indirection for the test case list to allow
-  // easy shuffling and restoring the test case order.  The i-th
-  // element of this vector is the index of the i-th test case in the
-  // shuffled order.
-  std::vector<int> test_case_indices_;
-
-#if GTEST_HAS_PARAM_TEST
-  // ParameterizedTestRegistry object used to register value-parameterized
-  // tests.
-  internal::ParameterizedTestCaseRegistry parameterized_test_registry_;
-
-  // Indicates whether RegisterParameterizedTests() has been called already.
-  bool parameterized_tests_registered_;
-#endif  // GTEST_HAS_PARAM_TEST
-
-  // Index of the last death test case registered.  Initially -1.
-  int last_death_test_case_;
-
-  // This points to the TestCase for the currently running test.  It
-  // changes as Google Test goes through one test case 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.
-  TestCase* current_test_case_;
-
-  // This points to the TestInfo for the currently running test.  It
-  // changes as Google Test goes through one test 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.
-  TestInfo* current_test_info_;
-
-  // Normally, a user only writes assertions inside a TEST or TEST_F,
-  // or inside a function called by a TEST or TEST_F.  Since Google
-  // Test keeps track of which test is current running, it can
-  // associate such an assertion with the test it belongs to.
-  //
-  // If an assertion is encountered when no TEST or TEST_F is running,
-  // Google Test attributes the assertion result to an imaginary "ad hoc"
-  // test, and records the result in ad_hoc_test_result_.
-  TestResult ad_hoc_test_result_;
-
-  // The list of event listeners that can be used to track events inside
-  // Google Test.
-  TestEventListeners listeners_;
-
-  // The OS stack trace getter.  Will be deleted when the UnitTest
-  // object is destructed.  By default, an OsStackTraceGetter is used,
-  // but the user can set this field to use a custom getter if that is
-  // desired.
-  OsStackTraceGetterInterface* os_stack_trace_getter_;
-
-  // True iff PostFlagParsingInit() has been called.
-  bool post_flag_parse_init_performed_;
-
-  // The random number seed used at the beginning of the test run.
-  int random_seed_;
-
-  // Our random number generator.
-  internal::Random random_;
-
-  // The time of the test program start, in ms from the start of the
-  // UNIX epoch.
-  TimeInMillis start_timestamp_;
-
-  // How long the test took to run, in milliseconds.
-  TimeInMillis elapsed_time_;
-
-#if GTEST_HAS_DEATH_TEST
-  // The decomposed components of the gtest_internal_run_death_test flag,
-  // parsed when RUN_ALL_TESTS is called.
-  internal::scoped_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
-  internal::scoped_ptr<internal::DeathTestFactory> death_test_factory_;
-#endif  // GTEST_HAS_DEATH_TEST
-
-  // A per-thread stack of traces created by the SCOPED_TRACE() macro.
-  internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_;
-
-  // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests()
-  // starts.
-  bool catch_exceptions_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
-};  // class UnitTestImpl
-
-// Convenience function for accessing the global UnitTest
-// implementation object.
-inline UnitTestImpl* GetUnitTestImpl() {
-  return UnitTest::GetInstance()->impl();
-}
-
-#if GTEST_USES_SIMPLE_RE
-
-// Internal helper functions for implementing the simple regular
-// expression matcher.
-GTEST_API_ bool IsInSet(char ch, const char* str);
-GTEST_API_ bool IsAsciiDigit(char ch);
-GTEST_API_ bool IsAsciiPunct(char ch);
-GTEST_API_ bool IsRepeat(char ch);
-GTEST_API_ bool IsAsciiWhiteSpace(char ch);
-GTEST_API_ bool IsAsciiWordChar(char ch);
-GTEST_API_ bool IsValidEscape(char ch);
-GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch);
-GTEST_API_ bool ValidateRegex(const char* regex);
-GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str);
-GTEST_API_ bool MatchRepetitionAndRegexAtHead(
-    bool escaped, char ch, char repeat, const char* regex, const char* str);
-GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);
-
-#endif  // GTEST_USES_SIMPLE_RE
-
-// Parses the command line for Google Test flags, without initializing
-// other parts of Google Test.
-GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv);
-GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
-
-#if GTEST_HAS_DEATH_TEST
-
-// Returns the message describing the last system error, regardless of the
-// platform.
-GTEST_API_ std::string GetLastErrnoDescription();
-
-// Attempts to parse a string into a positive integer pointed to by the
-// number parameter.  Returns true if that is possible.
-// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use
-// it here.
-template <typename Integer>
-bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
-  // Fail fast if the given string does not begin with a digit;
-  // this bypasses strtoXXX's "optional leading whitespace and plus
-  // or minus sign" semantics, which are undesirable here.
-  if (str.empty() || !IsDigit(str[0])) {
-    return false;
-  }
-  errno = 0;
-
-  char* end;
-  // BiggestConvertible is the largest integer type that system-provided
-  // string-to-number conversion routines can return.
-
-# if GTEST_OS_WINDOWS && !defined(__GNUC__)
-
-  // MSVC and C++ Builder define __int64 instead of the standard long long.
-  typedef unsigned __int64 BiggestConvertible;
-  const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10);
-
-# else
-
-  typedef unsigned long long BiggestConvertible;  // NOLINT
-  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);
-
-# endif  // GTEST_OS_WINDOWS && !defined(__GNUC__)
-
-  const bool parse_success = *end == '\0' && errno == 0;
-
-  // TODO(vladl@google.com): Convert this to compile time assertion when it is
-  // available.
-  GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
-
-  const Integer result = static_cast<Integer>(parsed);
-  if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
-    *number = result;
-    return true;
-  }
-  return false;
-}
-#endif  // GTEST_HAS_DEATH_TEST
-
-// TestResult contains some private methods that should be hidden from
-// Google Test user but are required for testing. This class allow our tests
-// to access them.
-//
-// This class is supplied only for the purpose of testing Google Test's own
-// constructs. Do not use it in user tests, either directly or indirectly.
-class TestResultAccessor {
- public:
-  static void RecordProperty(TestResult* test_result,
-                             const std::string& xml_element,
-                             const TestProperty& property) {
-    test_result->RecordProperty(xml_element, property);
-  }
-
-  static void ClearTestPartResults(TestResult* test_result) {
-    test_result->ClearTestPartResults();
-  }
-
-  static const std::vector<testing::TestPartResult>& test_part_results(
-      const TestResult& test_result) {
-    return test_result.test_part_results();
-  }
-};
-
-#if GTEST_CAN_STREAM_RESULTS_
-
-// Streams test results to the given port on the given host machine.
-class GTEST_API_ StreamingListener : public EmptyTestEventListener {
- public:
-  // Abstract base class for writing strings to a socket.
-  class AbstractSocketWriter {
-   public:
-    virtual ~AbstractSocketWriter() {}
-
-    // Sends a string to the socket.
-    virtual void Send(const string& message) = 0;
-
-    // Closes the socket.
-    virtual void CloseConnection() {}
-
-    // Sends a string and a newline to the socket.
-    void SendLn(const string& message) {
-      Send(message + "\n");
-    }
-  };
-
-  // Concrete class for actually writing strings to a socket.
-  class SocketWriter : public AbstractSocketWriter {
-   public:
-    SocketWriter(const string& host, const string& port)
-        : sockfd_(-1), host_name_(host), port_num_(port) {
-      MakeConnection();
-    }
-
-    virtual ~SocketWriter() {
-      if (sockfd_ != -1)
-        CloseConnection();
-    }
-
-    // Sends a string to the socket.
-    virtual void Send(const string& message) {
-      GTEST_CHECK_(sockfd_ != -1)
-          << "Send() can be called only when there is a connection.";
-
-      const int len = static_cast<int>(message.length());
-      if (write(sockfd_, message.c_str(), len) != len) {
-        GTEST_LOG_(WARNING)
-            << "stream_result_to: failed to stream to "
-            << host_name_ << ":" << port_num_;
-      }
-    }
-
-   private:
-    // Creates a client socket and connects to the server.
-    void MakeConnection();
-
-    // Closes the socket.
-    void CloseConnection() {
-      GTEST_CHECK_(sockfd_ != -1)
-          << "CloseConnection() can be called only when there is a connection.";
-
-      close(sockfd_);
-      sockfd_ = -1;
-    }
-
-    int sockfd_;  // socket file descriptor
-    const string host_name_;
-    const string port_num_;
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
-  };  // class SocketWriter
-
-  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
-  static string UrlEncode(const char* str);
-
-  StreamingListener(const string& host, const 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 */) {
-    SendLn("event=TestProgramStart");
-  }
-
-  void OnTestProgramEnd(const UnitTest& unit_test) {
-    // 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()));
-
-    // Notify the streaming server to stop.
-    socket_writer_->CloseConnection();
-  }
-
-  void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) {
-    SendLn("event=TestIterationStart&iteration=" +
-           StreamableToString(iteration));
-  }
-
-  void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) {
-    SendLn("event=TestIterationEnd&passed=" +
-           FormatBool(unit_test.Passed()) + "&elapsed_time=" +
-           StreamableToString(unit_test.elapsed_time()) + "ms");
-  }
-
-  void OnTestCaseStart(const TestCase& test_case) {
-    SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
-  }
-
-  void OnTestCaseEnd(const TestCase& test_case) {
-    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed())
-           + "&elapsed_time=" + StreamableToString(test_case.elapsed_time())
-           + "ms");
-  }
-
-  void OnTestStart(const TestInfo& test_info) {
-    SendLn(std::string("event=TestStart&name=") + test_info.name());
-  }
-
-  void OnTestEnd(const TestInfo& test_info) {
-    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) {
-    const char* file_name = test_part_result.file_name();
-    if (file_name == NULL)
-      file_name = "";
-    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
-           "&line=" + StreamableToString(test_part_result.line_number()) +
-           "&message=" + UrlEncode(test_part_result.message()));
-  }
-
- private:
-  // Sends the given message and a newline to the socket.
-  void SendLn(const 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"); }
-
-  string FormatBool(bool value) { return value ? "1" : "0"; }
-
-  const scoped_ptr<AbstractSocketWriter> socket_writer_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
-};  // class StreamingListener
-
-#endif  // GTEST_CAN_STREAM_RESULTS_
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // GTEST_SRC_GTEST_INTERNAL_INL_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-port.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-port.cc
deleted file mode 100644
index e5bf3dd2..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-port.cc
+++ /dev/null
@@ -1,1259 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "gtest/internal/gtest-port.h"
-
-#include <limits.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <fstream>
-
-#if GTEST_OS_WINDOWS
-# include <windows.h>
-# include <io.h>
-# include <sys/stat.h>
-# include <map>  // Used in ThreadLocal.
-#else
-# include <unistd.h>
-#endif  // GTEST_OS_WINDOWS
-
-#if GTEST_OS_MAC
-# include <mach/mach_init.h>
-# include <mach/task.h>
-# include <mach/vm_map.h>
-#endif  // GTEST_OS_MAC
-
-#if GTEST_OS_QNX
-# include <devctl.h>
-# include <fcntl.h>
-# include <sys/procfs.h>
-#endif  // GTEST_OS_QNX
-
-#if GTEST_OS_AIX
-# include <procinfo.h>
-# include <sys/types.h>
-#endif  // GTEST_OS_AIX
-
-#include "gtest/gtest-spi.h"
-#include "gtest/gtest-message.h"
-#include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-string.h"
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick exists to
-// prevent the accidental inclusion of gtest-internal-inl.h in the
-// user's code.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-namespace testing {
-namespace internal {
-
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
-const int kStdOutFileno = 1;
-const int kStdErrFileno = 2;
-#else
-const int kStdOutFileno = STDOUT_FILENO;
-const int kStdErrFileno = STDERR_FILENO;
-#endif  // _MSC_VER
-
-#if GTEST_OS_LINUX
-
-namespace {
-template <typename T>
-T ReadProcFileField(const string& filename, int field) {
-  std::string dummy;
-  std::ifstream file(filename.c_str());
-  while (field-- > 0) {
-    file >> dummy;
-  }
-  T output = 0;
-  file >> output;
-  return output;
-}
-}  // namespace
-
-// Returns the number of active threads, or 0 when there is an error.
-size_t GetThreadCount() {
-  const string filename =
-      (Message() << "/proc/" << getpid() << "/stat").GetString();
-  return ReadProcFileField<int>(filename, 19);
-}
-
-#elif GTEST_OS_MAC
-
-size_t GetThreadCount() {
-  const task_t task = mach_task_self();
-  mach_msg_type_number_t thread_count;
-  thread_act_array_t thread_list;
-  const kern_return_t status = task_threads(task, &thread_list, &thread_count);
-  if (status == KERN_SUCCESS) {
-    // task_threads allocates resources in thread_list and we need to free them
-    // to avoid leaks.
-    vm_deallocate(task,
-                  reinterpret_cast<vm_address_t>(thread_list),
-                  sizeof(thread_t) * thread_count);
-    return static_cast<size_t>(thread_count);
-  } else {
-    return 0;
-  }
-}
-
-#elif GTEST_OS_QNX
-
-// Returns the number of threads running in the process, or 0 to indicate that
-// we cannot detect it.
-size_t GetThreadCount() {
-  const int fd = open("/proc/self/as", O_RDONLY);
-  if (fd < 0) {
-    return 0;
-  }
-  procfs_info process_info;
-  const int status =
-      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), NULL);
-  close(fd);
-  if (status == EOK) {
-    return static_cast<size_t>(process_info.num_threads);
-  } else {
-    return 0;
-  }
-}
-
-#elif GTEST_OS_AIX
-
-size_t GetThreadCount() {
-  struct procentry64 entry;
-  pid_t pid = getpid();
-  int status = getprocs64(&entry, sizeof(entry), NULL, 0, &pid, 1);
-  if (status == 1) {
-    return entry.pi_thcount;
-  } else {
-    return 0;
-  }
-}
-
-#else
-
-size_t GetThreadCount() {
-  // There's no portable way to detect the number of threads, so we just
-  // return 0 to indicate that we cannot detect it.
-  return 0;
-}
-
-#endif  // GTEST_OS_LINUX
-
-#if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
-
-void SleepMilliseconds(int n) {
-  ::Sleep(n);
-}
-
-AutoHandle::AutoHandle()
-    : handle_(INVALID_HANDLE_VALUE) {}
-
-AutoHandle::AutoHandle(Handle handle)
-    : handle_(handle) {}
-
-AutoHandle::~AutoHandle() {
-  Reset();
-}
-
-AutoHandle::Handle AutoHandle::Get() const {
-  return handle_;
-}
-
-void AutoHandle::Reset() {
-  Reset(INVALID_HANDLE_VALUE);
-}
-
-void AutoHandle::Reset(HANDLE handle) {
-  // Resetting with the same handle we already own is invalid.
-  if (handle_ != handle) {
-    if (IsCloseable()) {
-      ::CloseHandle(handle_);
-    }
-    handle_ = handle;
-  } else {
-    GTEST_CHECK_(!IsCloseable())
-        << "Resetting a valid handle to itself is likely a programmer error "
-            "and thus not allowed.";
-  }
-}
-
-bool AutoHandle::IsCloseable() const {
-  // Different Windows APIs may use either of these values to represent an
-  // invalid handle.
-  return handle_ != NULL && handle_ != INVALID_HANDLE_VALUE;
-}
-
-Notification::Notification()
-    : event_(::CreateEvent(NULL,   // Default security attributes.
-                           TRUE,   // Do not reset automatically.
-                           FALSE,  // Initially unset.
-                           NULL)) {  // Anonymous event.
-  GTEST_CHECK_(event_.Get() != NULL);
-}
-
-void Notification::Notify() {
-  GTEST_CHECK_(::SetEvent(event_.Get()) != FALSE);
-}
-
-void Notification::WaitForNotification() {
-  GTEST_CHECK_(
-      ::WaitForSingleObject(event_.Get(), INFINITE) == WAIT_OBJECT_0);
-}
-
-Mutex::Mutex()
-    : owner_thread_id_(0),
-      type_(kDynamic),
-      critical_section_init_phase_(0),
-      critical_section_(new CRITICAL_SECTION) {
-  ::InitializeCriticalSection(critical_section_);
-}
-
-Mutex::~Mutex() {
-  // Static mutexes are leaked intentionally. It is not thread-safe to try
-  // to clean them up.
-  // TODO(yukawa): Switch to Slim Reader/Writer (SRW) Locks, which requires
-  // nothing to clean it up but is available only on Vista and later.
-  // http://msdn.microsoft.com/en-us/library/windows/desktop/aa904937.aspx
-  if (type_ == kDynamic) {
-    ::DeleteCriticalSection(critical_section_);
-    delete critical_section_;
-    critical_section_ = NULL;
-  }
-}
-
-void Mutex::Lock() {
-  ThreadSafeLazyInit();
-  ::EnterCriticalSection(critical_section_);
-  owner_thread_id_ = ::GetCurrentThreadId();
-}
-
-void Mutex::Unlock() {
-  ThreadSafeLazyInit();
-  // We don't protect writing to owner_thread_id_ here, as it's the
-  // caller's responsibility to ensure that the current thread holds the
-  // mutex when this is called.
-  owner_thread_id_ = 0;
-  ::LeaveCriticalSection(critical_section_);
-}
-
-// Does nothing if the current thread holds the mutex. Otherwise, crashes
-// with high probability.
-void Mutex::AssertHeld() {
-  ThreadSafeLazyInit();
-  GTEST_CHECK_(owner_thread_id_ == ::GetCurrentThreadId())
-      << "The current thread is not holding the mutex @" << this;
-}
-
-// Initializes owner_thread_id_ and critical_section_ in static mutexes.
-void Mutex::ThreadSafeLazyInit() {
-  // Dynamic mutexes are initialized in the constructor.
-  if (type_ == kStatic) {
-    switch (
-        ::InterlockedCompareExchange(&critical_section_init_phase_, 1L, 0L)) {
-      case 0:
-        // 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;
-        critical_section_ = new CRITICAL_SECTION;
-        ::InitializeCriticalSection(critical_section_);
-        // Updates the critical_section_init_phase_ to 2 to signal
-        // initialization complete.
-        GTEST_CHECK_(::InterlockedCompareExchange(
-                          &critical_section_init_phase_, 2L, 1L) ==
-                      1L);
-        break;
-      case 1:
-        // Somebody else is already initializing the mutex; spin until they
-        // are done.
-        while (::InterlockedCompareExchange(&critical_section_init_phase_,
-                                            2L,
-                                            2L) != 2L) {
-          // Possibly yields the rest of the thread's time slice to other
-          // threads.
-          ::Sleep(0);
-        }
-        break;
-
-      case 2:
-        break;  // The mutex is already initialized and ready for use.
-
-      default:
-        GTEST_CHECK_(false)
-            << "Unexpected value of critical_section_init_phase_ "
-            << "while initializing a static mutex.";
-    }
-  }
-}
-
-namespace {
-
-class ThreadWithParamSupport : public ThreadWithParamBase {
- public:
-  static HANDLE CreateThread(Runnable* runnable,
-                             Notification* thread_can_start) {
-    ThreadMainParam* param = new ThreadMainParam(runnable, thread_can_start);
-    DWORD thread_id;
-    // TODO(yukawa): Consider to use _beginthreadex instead.
-    HANDLE thread_handle = ::CreateThread(
-        NULL,    // Default security.
-        0,       // Default stack size.
-        &ThreadWithParamSupport::ThreadMain,
-        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 != NULL) << "CreateThread failed with error "
-                                        << ::GetLastError() << ".";
-    if (thread_handle == NULL) {
-      delete param;
-    }
-    return thread_handle;
-  }
-
- private:
-  struct ThreadMainParam {
-    ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
-        : runnable_(runnable),
-          thread_can_start_(thread_can_start) {
-    }
-    scoped_ptr<Runnable> runnable_;
-    // Does not own.
-    Notification* thread_can_start_;
-  };
-
-  static DWORD WINAPI ThreadMain(void* ptr) {
-    // Transfers ownership.
-    scoped_ptr<ThreadMainParam> param(static_cast<ThreadMainParam*>(ptr));
-    if (param->thread_can_start_ != NULL)
-      param->thread_can_start_->WaitForNotification();
-    param->runnable_->Run();
-    return 0;
-  }
-
-  // Prohibit instantiation.
-  ThreadWithParamSupport();
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParamSupport);
-};
-
-}  // namespace
-
-ThreadWithParamBase::ThreadWithParamBase(Runnable *runnable,
-                                         Notification* thread_can_start)
-      : thread_(ThreadWithParamSupport::CreateThread(runnable,
-                                                     thread_can_start)) {
-}
-
-ThreadWithParamBase::~ThreadWithParamBase() {
-  Join();
-}
-
-void ThreadWithParamBase::Join() {
-  GTEST_CHECK_(::WaitForSingleObject(thread_.Get(), INFINITE) == WAIT_OBJECT_0)
-      << "Failed to join the thread with error " << ::GetLastError() << ".";
-}
-
-// Maps a thread to a set of ThreadIdToThreadLocals that have values
-// instantiated on that thread and notifies them when the thread exits.  A
-// ThreadLocal instance is expected to persist until all threads it has
-// values on have terminated.
-class ThreadLocalRegistryImpl {
- public:
-  // Registers thread_local_instance as having value on the current thread.
-  // Returns a value that can be used to identify the thread from other threads.
-  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
-      const ThreadLocalBase* thread_local_instance) {
-    DWORD current_thread = ::GetCurrentThreadId();
-    MutexLock lock(&mutex_);
-    ThreadIdToThreadLocals* const thread_to_thread_locals =
-        GetThreadLocalsMapLocked();
-    ThreadIdToThreadLocals::iterator thread_local_pos =
-        thread_to_thread_locals->find(current_thread);
-    if (thread_local_pos == thread_to_thread_locals->end()) {
-      thread_local_pos = thread_to_thread_locals->insert(
-          std::make_pair(current_thread, ThreadLocalValues())).first;
-      StartWatcherThreadFor(current_thread);
-    }
-    ThreadLocalValues& thread_local_values = thread_local_pos->second;
-    ThreadLocalValues::iterator value_pos =
-        thread_local_values.find(thread_local_instance);
-    if (value_pos == thread_local_values.end()) {
-      value_pos =
-          thread_local_values
-              .insert(std::make_pair(
-                  thread_local_instance,
-                  linked_ptr<ThreadLocalValueHolderBase>(
-                      thread_local_instance->NewValueForCurrentThread())))
-              .first;
-    }
-    return value_pos->second.get();
-  }
-
-  static void OnThreadLocalDestroyed(
-      const ThreadLocalBase* thread_local_instance) {
-    std::vector<linked_ptr<ThreadLocalValueHolderBase> > value_holders;
-    // Clean up the ThreadLocalValues data structure while holding the lock, but
-    // defer the destruction of the ThreadLocalValueHolderBases.
-    {
-      MutexLock lock(&mutex_);
-      ThreadIdToThreadLocals* const thread_to_thread_locals =
-          GetThreadLocalsMapLocked();
-      for (ThreadIdToThreadLocals::iterator it =
-          thread_to_thread_locals->begin();
-          it != thread_to_thread_locals->end();
-          ++it) {
-        ThreadLocalValues& thread_local_values = it->second;
-        ThreadLocalValues::iterator value_pos =
-            thread_local_values.find(thread_local_instance);
-        if (value_pos != thread_local_values.end()) {
-          value_holders.push_back(value_pos->second);
-          thread_local_values.erase(value_pos);
-          // This 'if' can only be successful at most once, so theoretically we
-          // could break out of the loop here, but we don't bother doing so.
-        }
-      }
-    }
-    // Outside the lock, let the destructor for 'value_holders' deallocate the
-    // ThreadLocalValueHolderBases.
-  }
-
-  static void OnThreadExit(DWORD thread_id) {
-    GTEST_CHECK_(thread_id != 0) << ::GetLastError();
-    std::vector<linked_ptr<ThreadLocalValueHolderBase> > value_holders;
-    // Clean up the ThreadIdToThreadLocals data structure while holding the
-    // lock, but defer the destruction of the ThreadLocalValueHolderBases.
-    {
-      MutexLock lock(&mutex_);
-      ThreadIdToThreadLocals* const thread_to_thread_locals =
-          GetThreadLocalsMapLocked();
-      ThreadIdToThreadLocals::iterator thread_local_pos =
-          thread_to_thread_locals->find(thread_id);
-      if (thread_local_pos != thread_to_thread_locals->end()) {
-        ThreadLocalValues& thread_local_values = thread_local_pos->second;
-        for (ThreadLocalValues::iterator value_pos =
-            thread_local_values.begin();
-            value_pos != thread_local_values.end();
-            ++value_pos) {
-          value_holders.push_back(value_pos->second);
-        }
-        thread_to_thread_locals->erase(thread_local_pos);
-      }
-    }
-    // Outside the lock, let the destructor for 'value_holders' deallocate the
-    // ThreadLocalValueHolderBases.
-  }
-
- private:
-  // In a particular thread, maps a ThreadLocal object to its value.
-  typedef std::map<const ThreadLocalBase*,
-                   linked_ptr<ThreadLocalValueHolderBase> > ThreadLocalValues;
-  // Stores all ThreadIdToThreadLocals having values in a thread, indexed by
-  // thread's ID.
-  typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;
-
-  // Holds the thread id and thread handle that we pass from
-  // StartWatcherThreadFor to WatcherThreadFunc.
-  typedef std::pair<DWORD, HANDLE> ThreadIdAndHandle;
-
-  static void StartWatcherThreadFor(DWORD thread_id) {
-    // The returned handle will be kept in thread_map and closed by
-    // watcher_thread in WatcherThreadFunc.
-    HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION,
-                                 FALSE,
-                                 thread_id);
-    GTEST_CHECK_(thread != NULL);
-    // We need to to pass a valid thread ID pointer into CreateThread for it
-    // to work correctly under Win98.
-    DWORD watcher_thread_id;
-    HANDLE watcher_thread = ::CreateThread(
-        NULL,   // 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 != NULL);
-    // Give the watcher thread the same priority as ours to avoid being
-    // blocked by it.
-    ::SetThreadPriority(watcher_thread,
-                        ::GetThreadPriority(::GetCurrentThread()));
-    ::ResumeThread(watcher_thread);
-    ::CloseHandle(watcher_thread);
-  }
-
-  // Monitors exit from a given thread and notifies those
-  // ThreadIdToThreadLocals about thread termination.
-  static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
-    const ThreadIdAndHandle* tah =
-        reinterpret_cast<const ThreadIdAndHandle*>(param);
-    GTEST_CHECK_(
-        ::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0);
-    OnThreadExit(tah->first);
-    ::CloseHandle(tah->second);
-    delete tah;
-    return 0;
-  }
-
-  // Returns map of thread local instances.
-  static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
-    mutex_.AssertHeld();
-    static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals;
-    return map;
-  }
-
-  // Protects access to GetThreadLocalsMapLocked() and its return value.
-  static Mutex mutex_;
-  // Protects access to GetThreadMapLocked() and its return value.
-  static Mutex thread_map_mutex_;
-};
-
-Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex);
-Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex);
-
-ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentThread(
-      const ThreadLocalBase* thread_local_instance) {
-  return ThreadLocalRegistryImpl::GetValueOnCurrentThread(
-      thread_local_instance);
-}
-
-void ThreadLocalRegistry::OnThreadLocalDestroyed(
-      const ThreadLocalBase* thread_local_instance) {
-  ThreadLocalRegistryImpl::OnThreadLocalDestroyed(thread_local_instance);
-}
-
-#endif  // GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
-
-#if GTEST_USES_POSIX_RE
-
-// Implements RE.  Currently only needed for death tests.
-
-RE::~RE() {
-  if (is_valid_) {
-    // regfree'ing an invalid regex might crash because the content
-    // of the regex is undefined. Since the regex's are essentially
-    // the same, one cannot be valid (or invalid) without the other
-    // being so too.
-    regfree(&partial_regex_);
-    regfree(&full_regex_);
-  }
-  free(const_cast<char*>(pattern_));
-}
-
-// Returns true iff regular expression re matches the entire str.
-bool RE::FullMatch(const char* str, const RE& re) {
-  if (!re.is_valid_) return false;
-
-  regmatch_t match;
-  return regexec(&re.full_regex_, str, 1, &match, 0) == 0;
-}
-
-// Returns true iff 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;
-
-  regmatch_t match;
-  return regexec(&re.partial_regex_, str, 1, &match, 0) == 0;
-}
-
-// Initializes an RE from its string representation.
-void RE::Init(const char* regex) {
-  pattern_ = posix::StrDup(regex);
-
-  // Reserves enough bytes to hold the regular expression used for a
-  // full match.
-  const size_t full_regex_len = strlen(regex) + 10;
-  char* const full_pattern = new char[full_regex_len];
-
-  snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
-  is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
-  // We want to call regcomp(&partial_regex_, ...) even if the
-  // previous expression returns false.  Otherwise partial_regex_ may
-  // not be properly initialized can may cause trouble when it's
-  // freed.
-  //
-  // Some implementation of POSIX regex (e.g. on at least some
-  // versions of Cygwin) doesn't accept the empty string as a valid
-  // regex.  We change it to an equivalent form "()" to be safe.
-  if (is_valid_) {
-    const char* const partial_regex = (*regex == '\0') ? "()" : regex;
-    is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
-  }
-  EXPECT_TRUE(is_valid_)
-      << "Regular expression \"" << regex
-      << "\" is not a valid POSIX Extended regular expression.";
-
-  delete[] full_pattern;
-}
-
-#elif GTEST_USES_SIMPLE_RE
-
-// Returns true iff ch appears anywhere in str (excluding the
-// terminating '\0' character).
-bool IsInSet(char ch, const char* str) {
-  return ch != '\0' && strchr(str, ch) != NULL;
-}
-
-// Returns true iff 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) {
-  return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~");
-}
-bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
-bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
-bool IsAsciiWordChar(char ch) {
-  return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') ||
-      ('0' <= ch && ch <= '9') || ch == '_';
-}
-
-// Returns true iff "\\c" is a supported escape sequence.
-bool IsValidEscape(char c) {
-  return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW"));
-}
-
-// Returns true iff 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) {
-      case 'd': return IsAsciiDigit(ch);
-      case 'D': return !IsAsciiDigit(ch);
-      case 'f': return ch == '\f';
-      case 'n': return ch == '\n';
-      case 'r': return ch == '\r';
-      case 's': return IsAsciiWhiteSpace(ch);
-      case 'S': return !IsAsciiWhiteSpace(ch);
-      case 't': return ch == '\t';
-      case 'v': return ch == '\v';
-      case 'w': return IsAsciiWordChar(ch);
-      case 'W': return !IsAsciiWordChar(ch);
-    }
-    return IsAsciiPunct(pattern_char) && pattern_char == ch;
-  }
-
-  return (pattern_char == '.' && ch != '\n') || pattern_char == ch;
-}
-
-// Helper function used by ValidateRegex() to format error messages.
-std::string FormatRegexSyntaxError(const char* regex, int index) {
-  return (Message() << "Syntax error at index " << index
-          << " in simple regular expression \"" << regex << "\": ").GetString();
-}
-
-// Generates non-fatal failures and returns false if regex is invalid;
-// otherwise returns true.
-bool ValidateRegex(const char* regex) {
-  if (regex == NULL) {
-    // TODO(wan@google.com): fix the source file location in the
-    // assertion failures to match where the regex is used in user
-    // code.
-    ADD_FAILURE() << "NULL is not a valid simple regular expression.";
-    return false;
-  }
-
-  bool is_valid = true;
-
-  // True iff ?, *, or + can follow the previous atom.
-  bool prev_repeatable = false;
-  for (int i = 0; regex[i]; i++) {
-    if (regex[i] == '\\') {  // An escape sequence
-      i++;
-      if (regex[i] == '\0') {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
-                      << "'\\' cannot appear at the end.";
-        return false;
-      }
-
-      if (!IsValidEscape(regex[i])) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
-                      << "invalid escape sequence \"\\" << regex[i] << "\".";
-        is_valid = false;
-      }
-      prev_repeatable = true;
-    } else {  // Not an escape sequence.
-      const char ch = regex[i];
-
-      if (ch == '^' && i > 0) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'^' can only appear at the beginning.";
-        is_valid = false;
-      } else if (ch == '$' && regex[i + 1] != '\0') {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'$' can only appear at the end.";
-        is_valid = false;
-      } else if (IsInSet(ch, "()[]{}|")) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'" << ch << "' is unsupported.";
-        is_valid = false;
-      } else if (IsRepeat(ch) && !prev_repeatable) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'" << ch << "' can only follow a repeatable token.";
-        is_valid = false;
-      }
-
-      prev_repeatable = !IsInSet(ch, "^$?*+");
-    }
-  }
-
-  return is_valid;
-}
-
-// Matches a repeated regex atom followed by a valid simple regular
-// expression.  The regex atom is defined as c if escaped is false,
-// or \c otherwise.  repeat is the repetition meta character (?, *,
-// or +).  The behavior is undefined if str contains too many
-// characters to be indexable by size_t, in which case the test will
-// probably time out anyway.  We are fine with this limitation as
-// std::string has it too.
-bool MatchRepetitionAndRegexAtHead(
-    bool escaped, char c, char repeat, const char* regex,
-    const char* str) {
-  const size_t min_count = (repeat == '+') ? 1 : 0;
-  const size_t max_count = (repeat == '?') ? 1 :
-      static_cast<size_t>(-1) - 1;
-  // We cannot call numeric_limits::max() as it conflicts with the
-  // max() macro on Windows.
-
-  for (size_t i = 0; i <= max_count; ++i) {
-    // We know that the atom matches each of the first i characters in str.
-    if (i >= min_count && MatchRegexAtHead(regex, str + i)) {
-      // We have enough matches at the head, and the tail matches too.
-      // Since we only care about *whether* the pattern matches str
-      // (as opposed to *how* it matches), there is no need to find a
-      // greedy match.
-      return true;
-    }
-    if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i]))
-      return false;
-  }
-  return false;
-}
-
-// Returns true iff 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.
-    return true;
-
-  // "$" only matches the end of a string.  Note that regex being
-  // valid guarantees that there's nothing after "$" in it.
-  if (*regex == '$')
-    return *str == '\0';
-
-  // Is the first thing in regex an escape sequence?
-  const bool escaped = *regex == '\\';
-  if (escaped)
-    ++regex;
-  if (IsRepeat(regex[1])) {
-    // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so
-    // here's an indirect recursion.  It terminates as the regex gets
-    // shorter in each recursion.
-    return MatchRepetitionAndRegexAtHead(
-        escaped, regex[0], regex[1], regex + 2, str);
-  } else {
-    // regex isn't empty, isn't "$", and doesn't start with a
-    // repetition.  We match the first atom of regex with the first
-    // character of str and recurse.
-    return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) &&
-        MatchRegexAtHead(regex + 1, str + 1);
-  }
-}
-
-// Returns true iff 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
-// stack space normally.  In rare cases the time complexity can be
-// 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 == NULL || str == NULL)
-    return false;
-
-  if (*regex == '^')
-    return MatchRegexAtHead(regex + 1, str);
-
-  // A successful match can be anywhere in str.
-  do {
-    if (MatchRegexAtHead(regex, str))
-      return true;
-  } while (*str++ != '\0');
-  return false;
-}
-
-// Implements the RE class.
-
-RE::~RE() {
-  free(const_cast<char*>(pattern_));
-  free(const_cast<char*>(full_pattern_));
-}
-
-// Returns true iff 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 iff 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_ = NULL;
-  if (regex != NULL) {
-    pattern_ = posix::StrDup(regex);
-  }
-
-  is_valid_ = ValidateRegex(regex);
-  if (!is_valid_) {
-    // No need to calculate the full pattern when the regex is invalid.
-    return;
-  }
-
-  const size_t len = strlen(regex);
-  // Reserves enough bytes to hold the regular expression used for a
-  // full match: we need space to prepend a '^', append a '$', and
-  // terminate the string with '\0'.
-  char* buffer = static_cast<char*>(malloc(len + 3));
-  full_pattern_ = buffer;
-
-  if (*regex != '^')
-    *buffer++ = '^';  // Makes sure full_pattern_ starts with '^'.
-
-  // We don't use snprintf or strncpy, as they trigger a warning when
-  // compiled with VC++ 8.0.
-  memcpy(buffer, regex, len);
-  buffer += len;
-
-  if (len == 0 || regex[len - 1] != '$')
-    *buffer++ = '$';  // Makes sure full_pattern_ ends with '$'.
-
-  *buffer = '\0';
-}
-
-#endif  // GTEST_USES_POSIX_RE
-
-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 == NULL ? kUnknownFile : file);
-
-  if (line < 0) {
-    return file_name + ":";
-  }
-#ifdef _MSC_VER
-  return file_name + "(" + StreamableToString(line) + "):";
-#else
-  return file_name + ":" + StreamableToString(line) + ":";
-#endif  // _MSC_VER
-}
-
-// Formats a file location for compiler-independent XML output.
-// Although this function is not platform dependent, we put it next to
-// FormatFileLocation in order to contrast the two functions.
-// Note that FormatCompilerIndependentFileLocation() does NOT append colon
-// to the file location it produces, unlike FormatFileLocation().
-GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
-    const char* file, int line) {
-  const std::string file_name(file == NULL ? kUnknownFile : file);
-
-  if (line < 0)
-    return file_name;
-  else
-    return file_name + ":" + StreamableToString(line);
-}
-
-GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
-    : severity_(severity) {
-  const char* const marker =
-      severity == GTEST_INFO ?    "[  INFO ]" :
-      severity == GTEST_WARNING ? "[WARNING]" :
-      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
-  GetStream() << ::std::endl << marker << " "
-              << FormatFileLocation(file, line).c_str() << ": ";
-}
-
-// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
-GTestLog::~GTestLog() {
-  GetStream() << ::std::endl;
-  if (severity_ == GTEST_FATAL) {
-    fflush(stderr);
-    posix::Abort();
-  }
-}
-// Disable Microsoft deprecation warnings for POSIX functions called from
-// this class (creat, dup, dup2, and close)
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
-
-#if GTEST_HAS_STREAM_REDIRECTION
-
-// Object that captures an output stream (stdout/stderr).
-class CapturedStream {
- public:
-  // The ctor redirects the stream to a temporary file.
-  explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
-# if GTEST_OS_WINDOWS
-    char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
-    char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT
-
-    ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
-    const UINT success = ::GetTempFileNameA(temp_dir_path,
-                                            "gtest_redir",
-                                            0,  // Generate unique file name.
-                                            temp_file_path);
-    GTEST_CHECK_(success != 0)
-        << "Unable to create a temporary file in " << temp_dir_path;
-    const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
-    GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file "
-                                    << temp_file_path;
-    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 the /tmp directory
-    // instead. We use /tmp on most systems, and /sdcard on Android.
-    // That's because Android doesn't have /tmp.
-#  if GTEST_OS_LINUX_ANDROID
-    // Note: Android applications are expected to call the framework's
-    // Context.getExternalStorageDirectory() method through JNI to get
-    // the location of the world-writable SD Card directory. However,
-    // this requires a Context handle, which cannot be retrieved
-    // globally from native code. Doing so also precludes running the
-    // 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 /sdcard is directly accessible from native code
-    // and is the only location (unofficially) supported by the Android
-    // team. It's generally a symlink to the real SD Card mount point
-    // which can be /mnt/sdcard, /mnt/sdcard0, /system/media/sdcard, or
-    // other OEM-customized locations. Never rely on these, and always
-    // use /sdcard.
-    char name_template[] = "/sdcard/gtest_captured_stream.XXXXXX";
-#  else
-    char name_template[] = "/tmp/captured_stream.XXXXXX";
-#  endif  // GTEST_OS_LINUX_ANDROID
-    const int captured_fd = mkstemp(name_template);
-    filename_ = name_template;
-# endif  // GTEST_OS_WINDOWS
-    fflush(NULL);
-    dup2(captured_fd, fd_);
-    close(captured_fd);
-  }
-
-  ~CapturedStream() {
-    remove(filename_.c_str());
-  }
-
-  std::string GetCapturedString() {
-    if (uncaptured_fd_ != -1) {
-      // Restores the original stream.
-      fflush(NULL);
-      dup2(uncaptured_fd_, fd_);
-      close(uncaptured_fd_);
-      uncaptured_fd_ = -1;
-    }
-
-    FILE* const file = posix::FOpen(filename_.c_str(), "r");
-    const std::string content = ReadEntireFile(file);
-    posix::FClose(file);
-    return content;
-  }
-
- private:
-  const int fd_;  // A stream to capture.
-  int uncaptured_fd_;
-  // Name of the temporary file holding the stderr output.
-  ::std::string filename_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
-};
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-static CapturedStream* g_captured_stderr = NULL;
-static CapturedStream* g_captured_stdout = NULL;
-
-// Starts capturing an output stream (stdout/stderr).
-void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {
-  if (*stream != NULL) {
-    GTEST_LOG_(FATAL) << "Only one " << stream_name
-                      << " capturer can exist at a time.";
-  }
-  *stream = new CapturedStream(fd);
-}
-
-// Stops capturing the output stream and returns the captured string.
-std::string GetCapturedStream(CapturedStream** captured_stream) {
-  const std::string content = (*captured_stream)->GetCapturedString();
-
-  delete *captured_stream;
-  *captured_stream = NULL;
-
-  return content;
-}
-
-// Starts capturing stdout.
-void CaptureStdout() {
-  CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout);
-}
-
-// Starts capturing stderr.
-void CaptureStderr() {
-  CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr);
-}
-
-// Stops capturing stdout and returns the captured string.
-std::string GetCapturedStdout() {
-  return GetCapturedStream(&g_captured_stdout);
-}
-
-// Stops capturing stderr and returns the captured string.
-std::string GetCapturedStderr() {
-  return GetCapturedStream(&g_captured_stderr);
-}
-
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-std::string TempDir() {
-#if GTEST_OS_WINDOWS_MOBILE
-  return "\\temp\\";
-#elif GTEST_OS_WINDOWS
-  const char* temp_dir = posix::GetEnv("TEMP");
-  if (temp_dir == NULL || 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
-  return "/sdcard/";
-#else
-  return "/tmp/";
-#endif  // GTEST_OS_WINDOWS_MOBILE
-}
-
-size_t GetFileSize(FILE* file) {
-  fseek(file, 0, SEEK_END);
-  return static_cast<size_t>(ftell(file));
-}
-
-std::string ReadEntireFile(FILE* file) {
-  const size_t file_size = GetFileSize(file);
-  char* const buffer = new char[file_size];
-
-  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
-  size_t bytes_read = 0;       // # of bytes read so far
-
-  fseek(file, 0, SEEK_SET);
-
-  // Keeps reading the file until we cannot read further or the
-  // pre-determined file size is reached.
-  do {
-    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
-    bytes_read += bytes_last_read;
-  } while (bytes_last_read > 0 && bytes_read < file_size);
-
-  const std::string content(buffer, bytes_read);
-  delete[] buffer;
-
-  return content;
-}
-
-#if GTEST_HAS_DEATH_TEST
-
-static const ::std::vector<testing::internal::string>* g_injected_test_argvs =
-                                        NULL;  // Owned.
-
-void SetInjectableArgvs(const ::std::vector<testing::internal::string>* argvs) {
-  if (g_injected_test_argvs != argvs)
-    delete g_injected_test_argvs;
-  g_injected_test_argvs = argvs;
-}
-
-const ::std::vector<testing::internal::string>& GetInjectableArgvs() {
-  if (g_injected_test_argvs != NULL) {
-    return *g_injected_test_argvs;
-  }
-  return GetArgvs();
-}
-#endif  // GTEST_HAS_DEATH_TEST
-
-#if GTEST_OS_WINDOWS_MOBILE
-namespace posix {
-void Abort() {
-  DebugBreak();
-  TerminateProcess(GetCurrentProcess(), 1);
-}
-}  // namespace posix
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-// Returns the name of the environment variable corresponding to the
-// given flag.  For example, FlagToEnvVar("foo") will return
-// "GTEST_FOO" in the open-source version.
-static std::string FlagToEnvVar(const char* flag) {
-  const std::string full_flag =
-      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
-
-  Message env_var;
-  for (size_t i = 0; i != full_flag.length(); i++) {
-    env_var << ToUpper(full_flag.c_str()[i]);
-  }
-
-  return env_var.GetString();
-}
-
-// 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* value) {
-  // Parses the environment variable as a decimal integer.
-  char* end = NULL;
-  const long long_value = strtol(str, &end, 10);  // NOLINT
-
-  // Has strtol() consumed all characters in the string?
-  if (*end != '\0') {
-    // No - an invalid character was encountered.
-    Message msg;
-    msg << "WARNING: " << src_text
-        << " is expected to be a 32-bit integer, but actually"
-        << " has value \"" << str << "\".\n";
-    printf("%s", msg.GetString().c_str());
-    fflush(stdout);
-    return false;
-  }
-
-  // Is the parsed value in the range of an Int32?
-  const Int32 result = static_cast<Int32>(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.
-      ) {
-    Message msg;
-    msg << "WARNING: " << src_text
-        << " is expected to be a 32-bit integer, but actually"
-        << " has value " << str << ", which overflows.\n";
-    printf("%s", msg.GetString().c_str());
-    fflush(stdout);
-    return false;
-  }
-
-  *value = result;
-  return true;
-}
-
-// 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 iff 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);
-#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
-  const std::string env_var = FlagToEnvVar(flag);
-  const char* const string_value = posix::GetEnv(env_var.c_str());
-  return string_value == NULL ?
-      default_value : strcmp(string_value, "0") != 0;
-}
-
-// 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 Int32FromGTestEnv(const char* flag, Int32 default_value) {
-#if defined(GTEST_GET_INT32_FROM_ENV_)
-  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
-#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
-  const std::string env_var = FlagToEnvVar(flag);
-  const char* const string_value = posix::GetEnv(env_var.c_str());
-  if (string_value == NULL) {
-    // The environment variable is not set.
-    return default_value;
-  }
-
-  Int32 result = default_value;
-  if (!ParseInt32(Message() << "Environment variable " << env_var,
-                  string_value, &result)) {
-    printf("The default value %s is used.\n",
-           (Message() << default_value).GetString().c_str());
-    fflush(stdout);
-    return default_value;
-  }
-
-  return result;
-}
-
-// Reads and returns the string environment variable corresponding to
-// the given flag; if it's not set, returns default_value.
-std::string StringFromGTestEnv(const char* flag, const char* default_value) {
-#if defined(GTEST_GET_STRING_FROM_ENV_)
-  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
-#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
-  const std::string env_var = FlagToEnvVar(flag);
-  const char* value = posix::GetEnv(env_var.c_str());
-  if (value != NULL) {
-    return value;
-  }
-
-  // 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.
-  //
-  // The net priority order after flag processing is thus:
-  //   --gtest_output command line flag
-  //   GTEST_OUTPUT environment variable
-  //   XML_OUTPUT_FILE environment variable
-  //   'default_value'
-  if (strcmp(flag, "output") == 0) {
-    value = posix::GetEnv("XML_OUTPUT_FILE");
-    if (value != NULL) {
-      return std::string("xml:") + value;
-    }
-  }
-  return default_value;
-}
-
-}  // namespace internal
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-printers.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-printers.cc
deleted file mode 100644
index a2df412f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-printers.cc
+++ /dev/null
@@ -1,373 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Test - The Google C++ Testing Framework
-//
-// This file implements a universal value printer that can print a
-// value of any type T:
-//
-//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
-//
-// It uses the << operator when possible, and prints the bytes in the
-// object otherwise.  A user can override its behavior for a class
-// type Foo by defining either operator<<(::std::ostream&, const Foo&)
-// or void PrintTo(const Foo&, ::std::ostream*) in the namespace that
-// defines Foo.
-
-#include "gtest/gtest-printers.h"
-#include <ctype.h>
-#include <stdio.h>
-#include <cwchar>
-#include <ostream>  // NOLINT
-#include <string>
-#include "gtest/internal/gtest-port.h"
-
-namespace testing {
-
-namespace {
-
-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_THREAD_
-void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
-                                size_t count, ostream* os) {
-  char text[5] = "";
-  for (size_t i = 0; i != count; i++) {
-    const size_t j = start + i;
-    if (i != 0) {
-      // Organizes the bytes into groups of 2 for easy parsing by
-      // human.
-      if ((j % 2) == 0)
-        *os << ' ';
-      else
-        *os << '-';
-    }
-    GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
-    *os << text;
-  }
-}
-
-// Prints the bytes in the given value to the given ostream.
-void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
-                              ostream* os) {
-  // Tells the user how big the object is.
-  *os << count << "-byte object <";
-
-  const size_t kThreshold = 132;
-  const size_t kChunkSize = 64;
-  // If the object size is bigger than kThreshold, we'll have to omit
-  // some details by printing only the first and the last kChunkSize
-  // bytes.
-  // TODO(wan): let the user control the threshold using a flag.
-  if (count < kThreshold) {
-    PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
-  } else {
-    PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os);
-    *os << " ... ";
-    // Rounds up to 2-byte boundary.
-    const size_t resume_pos = (count - kChunkSize + 1)/2*2;
-    PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os);
-  }
-  *os << ">";
-}
-
-}  // namespace
-
-namespace internal2 {
-
-// Delegates to PrintBytesInObjectToImpl() to print the bytes in the
-// given object.  The delegation simplifies the implementation, which
-// uses the << operator and thus is easier done outside of the
-// ::testing::internal namespace, which contains a << operator that
-// sometimes conflicts with the one in STL.
-void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
-                          ostream* os) {
-  PrintBytesInObjectToImpl(obj_bytes, count, os);
-}
-
-}  // namespace internal2
-
-namespace internal {
-
-// 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 hexidecimal escape sequence (e.g. '\x7F'), or
-//   - as a special escape sequence (e.g. '\r', '\n').
-enum CharFormat {
-  kAsIs,
-  kHexEscape,
-  kSpecialEscape
-};
-
-// 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(wchar_t c) {
-  return 0x20 <= c && c <= 0x7E;
-}
-
-// Prints a wide or narrow char c as a character literal without the
-// quotes, escaping it when necessary; returns how c was formatted.
-// The template argument UnsignedChar is the unsigned version of Char,
-// which is the type of c.
-template <typename UnsignedChar, typename Char>
-static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
-  switch (static_cast<wchar_t>(c)) {
-    case L'\0':
-      *os << "\\0";
-      break;
-    case L'\'':
-      *os << "\\'";
-      break;
-    case L'\\':
-      *os << "\\\\";
-      break;
-    case L'\a':
-      *os << "\\a";
-      break;
-    case L'\b':
-      *os << "\\b";
-      break;
-    case L'\f':
-      *os << "\\f";
-      break;
-    case L'\n':
-      *os << "\\n";
-      break;
-    case L'\r':
-      *os << "\\r";
-      break;
-    case L'\t':
-      *os << "\\t";
-      break;
-    case L'\v':
-      *os << "\\v";
-      break;
-    default:
-      if (IsPrintableAscii(c)) {
-        *os << static_cast<char>(c);
-        return kAsIs;
-      } else {
-        *os << "\\x" + String::FormatHexInt(static_cast<UnsignedChar>(c));
-        return kHexEscape;
-      }
-  }
-  return kSpecialEscape;
-}
-
-// Prints a wchar_t c as if it's part of a string literal, escaping it when
-// necessary; returns how c was formatted.
-static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
-  switch (c) {
-    case L'\'':
-      *os << "'";
-      return kAsIs;
-    case L'"':
-      *os << "\\\"";
-      return kSpecialEscape;
-    default:
-      return PrintAsCharLiteralTo<wchar_t>(c, os);
-  }
-}
-
-// 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(
-      static_cast<wchar_t>(static_cast<unsigned char>(c)), os);
-}
-
-// Prints a wide or narrow character c and its code.  '\0' is printed
-// as "'\\0'", other unprintable characters are also properly escaped
-// using the standard C++ escape sequence.  The template argument
-// UnsignedChar is the unsigned version of Char, which is the type of c.
-template <typename UnsignedChar, typename Char>
-void PrintCharAndCodeTo(Char c, ostream* os) {
-  // First, print c as a literal in the most readable form we can find.
-  *os << ((sizeof(c) > 1) ? "L'" : "'");
-  const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
-  *os << "'";
-
-  // To aid user debugging, we also print c's code in decimal, unless
-  // it's 0 (in which case c was printed as '\\0', making the code
-  // obvious).
-  if (c == 0)
-    return;
-  *os << " (" << static_cast<int>(c);
-
-  // For more convenience, we print c's code again in hexidecimal,
-  // 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<UnsignedChar>(c));
-  }
-  *os << ")";
-}
-
-void PrintTo(unsigned char c, ::std::ostream* os) {
-  PrintCharAndCodeTo<unsigned char>(c, os);
-}
-void PrintTo(signed char c, ::std::ostream* os) {
-  PrintCharAndCodeTo<unsigned char>(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<wchar_t>(wc, os);
-}
-
-// Prints the given array of characters to the ostream.  CharType must be either
-// char 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_THREAD_
-static void PrintCharsAsStringTo(
-    const CharType* begin, size_t len, ostream* os) {
-  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
-  *os << kQuoteBegin;
-  bool is_previous_hex = false;
-  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 << "\" " << kQuoteBegin;
-    }
-    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
-  }
-  *os << "\"";
-}
-
-// Prints a (const) char/wchar_t array of 'len' elements, starting at address
-// 'begin'.  CharType must be either char or wchar_t.
-template <typename CharType>
-GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-static void UniversalPrintCharArray(
-    const CharType* begin, size_t len, ostream* os) {
-  // The code
-  //   const char kFoo[] = "foo";
-  // generates an array of 4, not 3, elements, with the last one being '\0'.
-  //
-  // Therefore when printing a char array, we don't print the last element if
-  // it's '\0', such that the output matches the string literal as it's
-  // written in the source code.
-  if (len > 0 && begin[len - 1] == '\0') {
-    PrintCharsAsStringTo(begin, len - 1, os);
-    return;
-  }
-
-  // If, however, the last element in the array is not '\0', e.g.
-  //    const char kFoo[] = { 'f', 'o', 'o' };
-  // we must print the entire array.  We also print a message to indicate
-  // that the array is not NUL-terminated.
-  PrintCharsAsStringTo(begin, len, os);
-  *os << " (no terminating NUL)";
-}
-
-// Prints a (const) char array of 'len' elements, starting at address 'begin'.
-void UniversalPrintArray(const char* 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);
-}
-
-// Prints the given C string to the ostream.
-void PrintTo(const char* s, ostream* os) {
-  if (s == NULL) {
-    *os << "NULL";
-  } else {
-    *os << ImplicitCast_<const void*>(s) << " pointing to ";
-    PrintCharsAsStringTo(s, strlen(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,
-// possibly accessing more memory than intended and causing invalid
-// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
-// 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) {
-  if (s == NULL) {
-    *os << "NULL";
-  } else {
-    *os << ImplicitCast_<const void*>(s) << " pointing to ";
-    PrintCharsAsStringTo(s, std::wcslen(s), os);
-  }
-}
-#endif  // wchar_t is native
-
-// Prints a ::string object.
-#if GTEST_HAS_GLOBAL_STRING
-void PrintStringTo(const ::string& s, ostream* os) {
-  PrintCharsAsStringTo(s.data(), s.size(), os);
-}
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-void PrintStringTo(const ::std::string& s, ostream* os) {
-  PrintCharsAsStringTo(s.data(), s.size(), os);
-}
-
-// Prints a ::wstring object.
-#if GTEST_HAS_GLOBAL_WSTRING
-void PrintWideStringTo(const ::wstring& s, ostream* os) {
-  PrintCharsAsStringTo(s.data(), s.size(), os);
-}
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-#if GTEST_HAS_STD_WSTRING
-void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
-  PrintCharsAsStringTo(s.data(), s.size(), os);
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-}  // namespace internal
-
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-test-part.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-test-part.cc
deleted file mode 100644
index fb0e3542..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-test-part.cc
+++ /dev/null
@@ -1,110 +0,0 @@
-// 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.
-//
-// Author: mheule@google.com (Markus Heule)
-//
-// The Google C++ Testing Framework (Google Test)
-
-#include "gtest/gtest-test-part.h"
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick exists to
-// prevent the accidental inclusion of gtest-internal-inl.h in the
-// user's code.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-namespace testing {
-
-using internal::GetUnitTestImpl;
-
-// Gets the summary of the failure message by omitting the stack trace
-// in it.
-std::string TestPartResult::ExtractSummary(const char* message) {
-  const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
-  return stack_trace == NULL ? message :
-      std::string(message, stack_trace);
-}
-
-// Prints a TestPartResult object.
-std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
-  return os
-      << result.file_name() << ":" << result.line_number() << ": "
-      << (result.type() == TestPartResult::kSuccess ? "Success" :
-          result.type() == TestPartResult::kFatalFailure ? "Fatal failure" :
-          "Non-fatal failure") << ":\n"
-      << result.message() << std::endl;
-}
-
-// Appends a TestPartResult to the array.
-void TestPartResultArray::Append(const TestPartResult& result) {
-  array_.push_back(result);
-}
-
-// Returns the TestPartResult at the given index (0-based).
-const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
-  if (index < 0 || index >= size()) {
-    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
-    internal::posix::Abort();
-  }
-
-  return array_[index];
-}
-
-// Returns the number of TestPartResult objects in the array.
-int TestPartResultArray::size() const {
-  return static_cast<int>(array_.size());
-}
-
-namespace internal {
-
-HasNewFatalFailureHelper::HasNewFatalFailureHelper()
-    : has_new_fatal_failure_(false),
-      original_reporter_(GetUnitTestImpl()->
-                         GetTestPartResultReporterForCurrentThread()) {
-  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
-}
-
-HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
-  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
-      original_reporter_);
-}
-
-void HasNewFatalFailureHelper::ReportTestPartResult(
-    const TestPartResult& result) {
-  if (result.fatally_failed())
-    has_new_fatal_failure_ = true;
-  original_reporter_->ReportTestPartResult(result);
-}
-
-}  // namespace internal
-
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-typed-test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-typed-test.cc
deleted file mode 100644
index df1eef47..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest-typed-test.cc
+++ /dev/null
@@ -1,118 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "gtest/gtest-typed-test.h"
-#include "gtest/gtest.h"
-
-namespace testing {
-namespace internal {
-
-#if GTEST_HAS_TYPED_TEST_P
-
-// Skips to the first non-space char in str. Returns an empty string if str
-// contains only whitespace characters.
-static const char* SkipSpaces(const char* str) {
-  while (IsSpace(*str))
-    str++;
-  return str;
-}
-
-static std::vector<std::string> SplitIntoTestNames(const char* src) {
-  std::vector<std::string> name_vec;
-  src = SkipSpaces(src);
-  for (; src != NULL; src = SkipComma(src)) {
-    name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
-  }
-  return name_vec;
-}
-
-// Verifies that registered_tests match the test names in
-// registered_tests_; returns registered_tests if successful, or
-// aborts the program otherwise.
-const char* TypedTestCasePState::VerifyRegisteredTestNames(
-    const char* file, int line, const char* registered_tests) {
-  typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
-  registered_ = true;
-
-  std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests);
-
-  Message errors;
-
-  std::set<std::string> tests;
-  for (std::vector<std::string>::const_iterator name_it = name_vec.begin();
-       name_it != name_vec.end(); ++name_it) {
-    const std::string& name = *name_it;
-    if (tests.count(name) != 0) {
-      errors << "Test " << name << " is listed more than once.\n";
-      continue;
-    }
-
-    bool found = false;
-    for (RegisteredTestIter it = registered_tests_.begin();
-         it != registered_tests_.end();
-         ++it) {
-      if (name == it->first) {
-        found = true;
-        break;
-      }
-    }
-
-    if (found) {
-      tests.insert(name);
-    } else {
-      errors << "No test named " << name
-             << " can be found in this test case.\n";
-    }
-  }
-
-  for (RegisteredTestIter it = registered_tests_.begin();
-       it != registered_tests_.end();
-       ++it) {
-    if (tests.count(it->first) == 0) {
-      errors << "You forgot to list test " << it->first << ".\n";
-    }
-  }
-
-  const std::string& errors_str = errors.GetString();
-  if (errors_str != "") {
-    fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
-            errors_str.c_str());
-    fflush(stderr);
-    posix::Abort();
-  }
-
-  return registered_tests;
-}
-
-#endif  // GTEST_HAS_TYPED_TEST_P
-
-}  // namespace internal
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest.cc
deleted file mode 100644
index d882ab2e..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest.cc
+++ /dev/null
@@ -1,5388 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// The Google C++ Testing Framework (Google Test)
-
-#include "gtest/gtest.h"
-#include "gtest/internal/custom/gtest.h"
-#include "gtest/gtest-spi.h"
-
-#include <ctype.h>
-#include <math.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-#include <wchar.h>
-#include <wctype.h>
-
-#include <algorithm>
-#include <iomanip>
-#include <limits>
-#include <list>
-#include <map>
-#include <ostream>  // NOLINT
-#include <sstream>
-#include <vector>
-
-#if GTEST_OS_LINUX
-
-// TODO(kenton@google.com): Use autoconf to detect availability of
-// gettimeofday().
-# define GTEST_HAS_GETTIMEOFDAY_ 1
-
-# include <fcntl.h>  // NOLINT
-# include <limits.h>  // NOLINT
-# include <sched.h>  // NOLINT
-// Declares vsnprintf().  This header is not available on Windows.
-# include <strings.h>  // NOLINT
-# include <sys/mman.h>  // NOLINT
-# include <sys/time.h>  // NOLINT
-# include <unistd.h>  // NOLINT
-# include <string>
-
-#elif GTEST_OS_SYMBIAN
-# define GTEST_HAS_GETTIMEOFDAY_ 1
-# include <sys/time.h>  // NOLINT
-
-#elif GTEST_OS_ZOS
-# define GTEST_HAS_GETTIMEOFDAY_ 1
-# include <sys/time.h>  // NOLINT
-
-// On z/OS we additionally need strings.h for strcasecmp.
-# include <strings.h>  // NOLINT
-
-#elif GTEST_OS_WINDOWS_MOBILE  // We are on Windows CE.
-
-# include <windows.h>  // NOLINT
-# undef min
-
-#elif GTEST_OS_WINDOWS  // We are on Windows proper.
-
-# include <io.h>  // NOLINT
-# include <sys/timeb.h>  // NOLINT
-# include <sys/types.h>  // NOLINT
-# include <sys/stat.h>  // NOLINT
-
-# if GTEST_OS_WINDOWS_MINGW
-// MinGW has gettimeofday() but not _ftime64().
-// TODO(kenton@google.com): Use autoconf to detect availability of
-//   gettimeofday().
-// TODO(kenton@google.com): There are other ways to get the time on
-//   Windows, like GetTickCount() or GetSystemTimeAsFileTime().  MinGW
-//   supports these.  consider using them instead.
-#  define GTEST_HAS_GETTIMEOFDAY_ 1
-#  include <sys/time.h>  // NOLINT
-# endif  // GTEST_OS_WINDOWS_MINGW
-
-// cpplint thinks that the header is already included, so we want to
-// silence it.
-# include <windows.h>  // NOLINT
-# undef min
-
-#else
-
-// Assume other platforms have gettimeofday().
-// TODO(kenton@google.com): Use autoconf to detect availability of
-//   gettimeofday().
-# define GTEST_HAS_GETTIMEOFDAY_ 1
-
-// cpplint thinks that the header is already included, so we want to
-// silence it.
-# include <sys/time.h>  // NOLINT
-# include <unistd.h>  // NOLINT
-
-#endif  // GTEST_OS_LINUX
-
-#if GTEST_HAS_EXCEPTIONS
-# include <stdexcept>
-#endif
-
-#if GTEST_CAN_STREAM_RESULTS_
-# include <arpa/inet.h>  // NOLINT
-# include <netdb.h>  // NOLINT
-# include <sys/socket.h>  // NOLINT
-# include <sys/types.h>  // NOLINT
-#endif
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick is to
-// prevent a user from accidentally including gtest-internal-inl.h in
-// his code.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-#if GTEST_OS_WINDOWS
-# define vsnprintf _vsnprintf
-#endif  // GTEST_OS_WINDOWS
-
-namespace testing {
-
-using internal::CountIf;
-using internal::ForEach;
-using internal::GetElementOr;
-using internal::Shuffle;
-
-// Constants.
-
-// A test whose test case name or test name matches this filter is
-// disabled and not run.
-static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";
-
-// A test case whose name matches this filter is considered a death
-// test case and will be run before test cases whose name doesn't
-// match this filter.
-static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*";
-
-// A test filter that matches everything.
-static const char kUniversalFilter[] = "*";
-
-// The default output file for XML output.
-static const char kDefaultOutputFile[] = "test_detail.xml";
-
-// The environment variable name for the test shard index.
-static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
-// The environment variable name for the total number of test shards.
-static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
-// The environment variable name for the test shard status file.
-static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";
-
-namespace internal {
-
-// The text used in failure messages to indicate the start of the
-// stack trace.
-const char kStackTraceMarker[] = "\nStack trace:\n";
-
-// g_help_flag is true iff the --help flag or an equivalent form is
-// specified on the command line.
-bool g_help_flag = false;
-
-}  // namespace internal
-
-static const char* GetDefaultFilter() {
-#ifdef GTEST_TEST_FILTER_ENV_VAR_
-  const char* const testbridge_test_only = getenv(GTEST_TEST_FILTER_ENV_VAR_);
-  if (testbridge_test_only != NULL) {
-    return testbridge_test_only;
-  }
-#endif  // GTEST_TEST_FILTER_ENV_VAR_
-  return kUniversalFilter;
-}
-
-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 iff a failed assertion should be a debugger break-point.");
-
-GTEST_DEFINE_bool_(
-    catch_exceptions,
-    internal::BoolFromGTestEnv("catch_exceptions", true),
-    "True iff " GTEST_NAME_
-    " should catch exceptions and treat them as test failures.");
-
-GTEST_DEFINE_string_(
-    color,
-    internal::StringFromGTestEnv("color", "auto"),
-    "Whether to use colors in the output.  Valid values: yes, no, "
-    "and auto.  'auto' means to use colors if the output is "
-    "being sent to a terminal and the TERM environment variable "
-    "is set to a terminal type that supports colors.");
-
-GTEST_DEFINE_string_(
-    filter,
-    internal::StringFromGTestEnv("filter", GetDefaultFilter()),
-    "A colon-separated list of glob (not regex) patterns "
-    "for filtering the tests to run, optionally followed by a "
-    "'-' and a : separated list of negative patterns (tests to "
-    "exclude).  A test is run if it matches one of the positive "
-    "patterns and does not match any of the negative patterns.");
-
-GTEST_DEFINE_bool_(list_tests, false,
-                   "List all tests without running them.");
-
-GTEST_DEFINE_string_(
-    output,
-    internal::StringFromGTestEnv("output", ""),
-    "A format (currently must be \"xml\"), 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_(
-    print_time,
-    internal::BoolFromGTestEnv("print_time", true),
-    "True iff " GTEST_NAME_
-    " should display elapsed time in text output.");
-
-GTEST_DEFINE_int32_(
-    random_seed,
-    internal::Int32FromGTestEnv("random_seed", 0),
-    "Random number seed to use when shuffling test orders.  Must be in range "
-    "[1, 99999], or 0 to use a seed based on the current time.");
-
-GTEST_DEFINE_int32_(
-    repeat,
-    internal::Int32FromGTestEnv("repeat", 1),
-    "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 iff " GTEST_NAME_ " should include internal stack frames when "
-    "printing test failure stack traces.");
-
-GTEST_DEFINE_bool_(
-    shuffle,
-    internal::BoolFromGTestEnv("shuffle", false),
-    "True iff " GTEST_NAME_
-    " should randomize tests' order on every run.");
-
-GTEST_DEFINE_int32_(
-    stack_trace_depth,
-    internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),
-    "The maximum number of stack frames to print when an "
-    "assertion fails.  The valid range is 0 through 100, inclusive.");
-
-GTEST_DEFINE_string_(
-    stream_result_to,
-    internal::StringFromGTestEnv("stream_result_to", ""),
-    "This flag specifies the host name and the port number on which to stream "
-    "test results. Example: \"localhost:555\". The flag is effective only on "
-    "Linux.");
-
-GTEST_DEFINE_bool_(
-    throw_on_failure,
-    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.");
-
-#if GTEST_USE_OWN_FLAGFILE_FLAG_
-GTEST_DEFINE_string_(
-    flagfile,
-    internal::StringFromGTestEnv("flagfile", ""),
-    "This flag specifies the flagfile to read command-line flags from.");
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
-
-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 Random::Generate(UInt32 range) {
-  // These constants are the same as are used in glibc's rand(3).
-  state_ = (1103515245U*state_ + 12345U) % kMaxRange;
-
-  GTEST_CHECK_(range > 0)
-      << "Cannot generate a number in the range [0, 0).";
-  GTEST_CHECK_(range <= kMaxRange)
-      << "Generation of a number in [0, " << range << ") was requested, "
-      << "but this can only generate numbers in [0, " << kMaxRange << ").";
-
-  // Converting via modulus introduces a bit of downward bias, but
-  // it's simple, and a linear congruential generator isn't too good
-  // to begin with.
-  return state_ % range;
-}
-
-// GTestIsInitialized() returns true iff 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 TestCases, keeping a running sum of the
-// results of calling a given int-returning method on each.
-// Returns the sum.
-static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
-                               int (TestCase::*method)() const) {
-  int sum = 0;
-  for (size_t i = 0; i < case_list.size(); i++) {
-    sum += (case_list[i]->*method)();
-  }
-  return sum;
-}
-
-// Returns true iff the test case passed.
-static bool TestCasePassed(const TestCase* test_case) {
-  return test_case->should_run() && test_case->Passed();
-}
-
-// Returns true iff the test case failed.
-static bool TestCaseFailed(const TestCase* test_case) {
-  return test_case->should_run() && test_case->Failed();
-}
-
-// Returns true iff test_case contains at least one test that should
-// run.
-static bool ShouldRunTestCase(const TestCase* test_case) {
-  return test_case->should_run();
-}
-
-// AssertHelper constructor.
-AssertHelper::AssertHelper(TestPartResult::Type type,
-                           const char* file,
-                           int line,
-                           const char* message)
-    : data_(new AssertHelperData(type, file, line, message)) {
-}
-
-AssertHelper::~AssertHelper() {
-  delete data_;
-}
-
-// Message assignment, for assertion streaming support.
-void AssertHelper::operator=(const Message& message) const {
-  UnitTest::GetInstance()->
-    AddTestPartResult(data_->type, data_->file, data_->line,
-                      AppendUserMessage(data_->message, message),
-                      UnitTest::GetInstance()->impl()
-                      ->CurrentOsStackTraceExceptTop(1)
-                      // Skips the stack frame for this function itself.
-                      );  // NOLINT
-}
-
-// Mutex for linked pointers.
-GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
-
-// A copy of all command line arguments.  Set by InitGoogleTest().
-::std::vector<testing::internal::string> g_argvs;
-
-const ::std::vector<testing::internal::string>& GetArgvs() {
-#if defined(GTEST_CUSTOM_GET_ARGVS_)
-  return GTEST_CUSTOM_GET_ARGVS_();
-#else  // defined(GTEST_CUSTOM_GET_ARGVS_)
-  return g_argvs;
-#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
-}
-
-// Returns the current application's name, removing directory path if that
-// is present.
-FilePath GetCurrentExecutableName() {
-  FilePath result;
-
-#if GTEST_OS_WINDOWS
-  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
-#else
-  result.Set(FilePath(GetArgvs()[0]));
-#endif  // GTEST_OS_WINDOWS
-
-  return result.RemoveDirectoryName();
-}
-
-// Functions for processing the gtest_output flag.
-
-// Returns the output format, or "" for normal printed output.
-std::string UnitTestOptions::GetOutputFormat() {
-  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
-  if (gtest_output_flag == NULL) return std::string("");
-
-  const char* const colon = strchr(gtest_output_flag, ':');
-  return (colon == NULL) ?
-      std::string(gtest_output_flag) :
-      std::string(gtest_output_flag, colon - gtest_output_flag);
-}
-
-// Returns the name of the requested output file, or the default if none
-// was explicitly specified.
-std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
-  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
-  if (gtest_output_flag == NULL)
-    return "";
-
-  const char* const colon = strchr(gtest_output_flag, ':');
-  if (colon == NULL)
-    return internal::FilePath::ConcatPaths(
-        internal::FilePath(
-            UnitTest::GetInstance()->original_working_dir()),
-        internal::FilePath(kDefaultOutputFile)).string();
-
-  internal::FilePath output_name(colon + 1);
-  if (!output_name.IsAbsolutePath())
-    // TODO(wan@google.com): on Windows \some\path is not an absolute
-    // path (as its meaning depends on the current drive), yet the
-    // following logic for turning it into an absolute path is wrong.
-    // Fix it.
-    output_name = internal::FilePath::ConcatPaths(
-        internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
-        internal::FilePath(colon + 1));
-
-  if (!output_name.IsDirectory())
-    return output_name.string();
-
-  internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
-      output_name, internal::GetCurrentExecutableName(),
-      GetOutputFormat().c_str()));
-  return result.string();
-}
-
-// Returns true iff the wildcard pattern matches the string.  The
-// first ':' or '\0' character in pattern marks the end of it.
-//
-// This recursive algorithm isn't very efficient, but is clear and
-// works well enough for matching test names, which are short.
-bool UnitTestOptions::PatternMatchesString(const char *pattern,
-                                           const char *str) {
-  switch (*pattern) {
-    case '\0':
-    case ':':  // Either ':' or '\0' marks the end of the pattern.
-      return *str == '\0';
-    case '?':  // Matches any single character.
-      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
-    case '*':  // Matches any string (possibly empty) of characters.
-      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
-          PatternMatchesString(pattern + 1, str);
-    default:  // Non-special character.  Matches itself.
-      return *pattern == *str &&
-          PatternMatchesString(pattern + 1, str + 1);
-  }
-}
-
-bool UnitTestOptions::MatchesFilter(
-    const std::string& name, const char* filter) {
-  const char *cur_pattern = filter;
-  for (;;) {
-    if (PatternMatchesString(cur_pattern, name.c_str())) {
-      return true;
-    }
-
-    // Finds the next pattern in the filter.
-    cur_pattern = strchr(cur_pattern, ':');
-
-    // Returns if no more pattern can be found.
-    if (cur_pattern == NULL) {
-      return false;
-    }
-
-    // Skips the pattern separater (the ':' character).
-    cur_pattern++;
-  }
-}
-
-// Returns true iff the user-specified filter matches the test case
-// name and the test name.
-bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name,
-                                        const std::string &test_name) {
-  const std::string& full_name = test_case_name + "." + test_name.c_str();
-
-  // Split --gtest_filter at '-', if there is one, to separate into
-  // positive filter and negative filter portions
-  const char* const p = GTEST_FLAG(filter).c_str();
-  const char* const dash = strchr(p, '-');
-  std::string positive;
-  std::string negative;
-  if (dash == NULL) {
-    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
-    negative = "";
-  } else {
-    positive = std::string(p, dash);   // Everything up to the dash
-    negative = std::string(dash + 1);  // Everything after the dash
-    if (positive.empty()) {
-      // Treat '-test1' as the same as '*-test1'
-      positive = kUniversalFilter;
-    }
-  }
-
-  // A filter is a colon-separated list of patterns.  It matches a
-  // test if any pattern in it matches the test.
-  return (MatchesFilter(full_name, positive.c_str()) &&
-          !MatchesFilter(full_name, negative.c_str()));
-}
-
-#if GTEST_HAS_SEH
-// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
-// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
-// This function is useful as an __except condition.
-int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
-  // Google Test should handle a SEH exception if:
-  //   1. the user wants it to, AND
-  //   2. this is not a breakpoint exception, AND
-  //   3. this is not a C++ exception (VC++ implements them via SEH,
-  //      apparently).
-  //
-  // SEH exception code for C++ exceptions.
-  // (see http://support.microsoft.com/kb/185294 for more information).
-  const DWORD kCxxExceptionCode = 0xe06d7363;
-
-  bool should_handle = true;
-
-  if (!GTEST_FLAG(catch_exceptions))
-    should_handle = false;
-  else if (exception_code == EXCEPTION_BREAKPOINT)
-    should_handle = false;
-  else if (exception_code == kCxxExceptionCode)
-    should_handle = false;
-
-  return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
-}
-#endif  // GTEST_HAS_SEH
-
-}  // namespace internal
-
-// The c'tor sets this object as the test part result reporter used by
-// Google Test.  The 'result' parameter specifies where to report the
-// results. Intercepts only failures from the current thread.
-ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
-    TestPartResultArray* result)
-    : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
-      result_(result) {
-  Init();
-}
-
-// The c'tor sets this object as the test part result reporter used by
-// Google Test.  The 'result' parameter specifies where to report the
-// results.
-ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
-    InterceptMode intercept_mode, TestPartResultArray* result)
-    : intercept_mode_(intercept_mode),
-      result_(result) {
-  Init();
-}
-
-void ScopedFakeTestPartResultReporter::Init() {
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
-    old_reporter_ = impl->GetGlobalTestPartResultReporter();
-    impl->SetGlobalTestPartResultReporter(this);
-  } else {
-    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
-    impl->SetTestPartResultReporterForCurrentThread(this);
-  }
-}
-
-// The d'tor restores the test part result reporter used by Google Test
-// before.
-ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
-    impl->SetGlobalTestPartResultReporter(old_reporter_);
-  } else {
-    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
-  }
-}
-
-// Increments the test part result count and remembers the result.
-// This method is from the TestPartResultReporterInterface interface.
-void ScopedFakeTestPartResultReporter::ReportTestPartResult(
-    const TestPartResult& result) {
-  result_->Append(result);
-}
-
-namespace internal {
-
-// Returns the type ID of ::testing::Test.  We should always call this
-// instead of GetTypeId< ::testing::Test>() to get the type ID of
-// testing::Test.  This is to work around a suspected linker bug when
-// using Google Test as a framework on Mac OS X.  The bug causes
-// GetTypeId< ::testing::Test>() to return different values depending
-// on whether the call is from the Google Test framework itself or
-// from user test code.  GetTestTypeId() is guaranteed to always
-// return the same value, as it always calls GetTypeId<>() from the
-// gtest.cc, which is within the Google Test framework.
-TypeId GetTestTypeId() {
-  return GetTypeId<Test>();
-}
-
-// The value of GetTestTypeId() as seen from within the Google Test
-// library.  This is solely for testing GetTestTypeId().
-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.
-AssertionResult HasOneFailure(const char* /* results_expr */,
-                              const char* /* type_expr */,
-                              const char* /* substr_expr */,
-                              const TestPartResultArray& results,
-                              TestPartResult::Type type,
-                              const string& substr) {
-  const std::string expected(type == TestPartResult::kFatalFailure ?
-                        "1 fatal failure" :
-                        "1 non-fatal failure");
-  Message msg;
-  if (results.size() != 1) {
-    msg << "Expected: " << expected << "\n"
-        << "  Actual: " << results.size() << " failures";
-    for (int i = 0; i < results.size(); i++) {
-      msg << "\n" << results.GetTestPartResult(i);
-    }
-    return AssertionFailure() << msg;
-  }
-
-  const TestPartResult& r = results.GetTestPartResult(0);
-  if (r.type() != type) {
-    return AssertionFailure() << "Expected: " << expected << "\n"
-                              << "  Actual:\n"
-                              << r;
-  }
-
-  if (strstr(r.message(), substr.c_str()) == NULL) {
-    return AssertionFailure() << "Expected: " << expected << " containing \""
-                              << substr << "\"\n"
-                              << "  Actual:\n"
-                              << r;
-  }
-
-  return AssertionSuccess();
-}
-
-// 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 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
-// type and contains the given substring.  If that's not the case, a
-// non-fatal failure will be generated.
-SingleFailureChecker::~SingleFailureChecker() {
-  EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
-}
-
-DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
-    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
-
-void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
-    const TestPartResult& result) {
-  unit_test_->current_test_result()->AddTestPartResult(result);
-  unit_test_->listeners()->repeater()->OnTestPartResult(result);
-}
-
-DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
-    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
-
-void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
-    const TestPartResult& result) {
-  unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
-}
-
-// Returns the global test part result reporter.
-TestPartResultReporterInterface*
-UnitTestImpl::GetGlobalTestPartResultReporter() {
-  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
-  return global_test_part_result_repoter_;
-}
-
-// Sets the global test part result reporter.
-void UnitTestImpl::SetGlobalTestPartResultReporter(
-    TestPartResultReporterInterface* reporter) {
-  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
-  global_test_part_result_repoter_ = reporter;
-}
-
-// Returns the test part result reporter for the current thread.
-TestPartResultReporterInterface*
-UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
-  return per_thread_test_part_result_reporter_.get();
-}
-
-// Sets the test part result reporter for the current thread.
-void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
-    TestPartResultReporterInterface* reporter) {
-  per_thread_test_part_result_reporter_.set(reporter);
-}
-
-// Gets the number of successful test cases.
-int UnitTestImpl::successful_test_case_count() const {
-  return CountIf(test_cases_, TestCasePassed);
-}
-
-// Gets the number of failed test cases.
-int UnitTestImpl::failed_test_case_count() const {
-  return CountIf(test_cases_, TestCaseFailed);
-}
-
-// Gets the number of all test cases.
-int UnitTestImpl::total_test_case_count() const {
-  return static_cast<int>(test_cases_.size());
-}
-
-// Gets the number of all test cases that contain at least one test
-// that should run.
-int UnitTestImpl::test_case_to_run_count() const {
-  return CountIf(test_cases_, ShouldRunTestCase);
-}
-
-// Gets the number of successful tests.
-int UnitTestImpl::successful_test_count() const {
-  return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count);
-}
-
-// Gets the number of failed tests.
-int UnitTestImpl::failed_test_count() const {
-  return SumOverTestCaseList(test_cases_, &TestCase::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 SumOverTestCaseList(test_cases_,
-                             &TestCase::reportable_disabled_test_count);
-}
-
-// Gets the number of disabled tests.
-int UnitTestImpl::disabled_test_count() const {
-  return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count);
-}
-
-// Gets the number of tests to be printed in the XML report.
-int UnitTestImpl::reportable_test_count() const {
-  return SumOverTestCaseList(test_cases_, &TestCase::reportable_test_count);
-}
-
-// Gets the number of all tests.
-int UnitTestImpl::total_test_count() const {
-  return SumOverTestCaseList(test_cases_, &TestCase::total_test_count);
-}
-
-// Gets the number of tests that should run.
-int UnitTestImpl::test_to_run_count() const {
-  return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count);
-}
-
-// Returns the current OS stack trace as an std::string.
-//
-// The maximum number of stack frames to be included is specified by
-// the gtest_stack_trace_depth flag.  The skip_count parameter
-// specifies the number of top frames to be skipped, which doesn't
-// count against the number of frames to be included.
-//
-// For example, if Foo() calls Bar(), which in turn calls
-// CurrentOsStackTraceExceptTop(1), Foo() will be included in the
-// trace but Bar() and CurrentOsStackTraceExceptTop() won't.
-std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
-  return os_stack_trace_getter()->CurrentStackTrace(
-      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
-      skip_count + 1
-      // Skips the user-specified number of frames plus this function
-      // itself.
-      );  // NOLINT
-}
-
-// Returns the current time in milliseconds.
-TimeInMillis GetTimeInMillis() {
-#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__)
-  // Difference between 1970-01-01 and 1601-01-01 in milliseconds.
-  // http://analogous.blogspot.com/2005/04/epoch.html
-  const TimeInMillis kJavaEpochToWinFileTimeDelta =
-    static_cast<TimeInMillis>(116444736UL) * 100000UL;
-  const DWORD kTenthMicrosInMilliSecond = 10000;
-
-  SYSTEMTIME now_systime;
-  FILETIME now_filetime;
-  ULARGE_INTEGER now_int64;
-  // TODO(kenton@google.com): Shouldn't this just use
-  //   GetSystemTimeAsFileTime()?
-  GetSystemTime(&now_systime);
-  if (SystemTimeToFileTime(&now_systime, &now_filetime)) {
-    now_int64.LowPart = now_filetime.dwLowDateTime;
-    now_int64.HighPart = now_filetime.dwHighDateTime;
-    now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) -
-      kJavaEpochToWinFileTimeDelta;
-    return now_int64.QuadPart;
-  }
-  return 0;
-#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_
-  __timeb64 now;
-
-  // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996
-  // (deprecated function) there.
-  // TODO(kenton@google.com): Use GetTickCount()?  Or use
-  //   SystemTimeToFileTime()
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
-  _ftime64(&now);
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-  return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm;
-#elif GTEST_HAS_GETTIMEOFDAY_
-  struct timeval now;
-  gettimeofday(&now, NULL);
-  return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000;
-#else
-# error "Don't know how to get the current time on your system."
-#endif
-}
-
-// Utilities
-
-// class String.
-
-#if GTEST_OS_WINDOWS_MOBILE
-// Creates a UTF-16 wide string from the given ANSI string, allocating
-// memory using new. The caller is responsible for deleting the return
-// value using delete[]. Returns the wide string, or NULL if the
-// input is NULL.
-LPCWSTR String::AnsiToUtf16(const char* ansi) {
-  if (!ansi) return NULL;
-  const int length = strlen(ansi);
-  const int unicode_length =
-      MultiByteToWideChar(CP_ACP, 0, ansi, length,
-                          NULL, 0);
-  WCHAR* unicode = new WCHAR[unicode_length + 1];
-  MultiByteToWideChar(CP_ACP, 0, ansi, length,
-                      unicode, unicode_length);
-  unicode[unicode_length] = 0;
-  return unicode;
-}
-
-// Creates an ANSI string from the given wide string, allocating
-// memory using new. The caller is responsible for deleting the return
-// 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 NULL;
-  const int ansi_length =
-      WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
-                          NULL, 0, NULL, NULL);
-  char* ansi = new char[ansi_length + 1];
-  WideCharToMultiByte(CP_ACP, 0, utf16_str, -1,
-                      ansi, ansi_length, NULL, NULL);
-  ansi[ansi_length] = 0;
-  return ansi;
-}
-
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-// Compares two C strings.  Returns true iff 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 == NULL ) return rhs == NULL;
-
-  if ( rhs == NULL ) return false;
-
-  return strcmp(lhs, rhs) == 0;
-}
-
-#if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_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.
-static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
-                                     Message* msg) {
-  for (size_t i = 0; i != length; ) {  // NOLINT
-    if (wstr[i] != L'\0') {
-      *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
-      while (i != length && wstr[i] != L'\0')
-        i++;
-    } else {
-      *msg << '\0';
-      i++;
-    }
-  }
-}
-
-#endif  // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING
-
-void SplitString(const ::std::string& str, char delimiter,
-                 ::std::vector< ::std::string>* dest) {
-  ::std::vector< ::std::string> parsed;
-  ::std::string::size_type pos = 0;
-  while (::testing::internal::AlwaysTrue()) {
-    const ::std::string::size_type colon = str.find(delimiter, pos);
-    if (colon == ::std::string::npos) {
-      parsed.push_back(str.substr(pos));
-      break;
-    } else {
-      parsed.push_back(str.substr(pos, colon - pos));
-      pos = colon + 1;
-    }
-  }
-  dest->swap(parsed);
-}
-
-}  // namespace internal
-
-// Constructs an empty Message.
-// We allocate the stringstream separately because otherwise each use of
-// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
-// stack frame leading to huge stack frames in some cases; gcc does not reuse
-// the stack space.
-Message::Message() : ss_(new ::std::stringstream) {
-  // By default, we want there to be enough precision when printing
-  // a double to a Message.
-  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
-}
-
-// These two overloads allow streaming a wide C string to a Message
-// using the UTF-8 encoding.
-Message& Message::operator <<(const wchar_t* wide_c_str) {
-  return *this << internal::String::ShowWideCString(wide_c_str);
-}
-Message& Message::operator <<(wchar_t* wide_c_str) {
-  return *this << internal::String::ShowWideCString(wide_c_str);
-}
-
-#if GTEST_HAS_STD_WSTRING
-// Converts the given wide string to a narrow string using the UTF-8
-// encoding, and streams the result to this Message object.
-Message& Message::operator <<(const ::std::wstring& wstr) {
-  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
-  return *this;
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-#if GTEST_HAS_GLOBAL_WSTRING
-// Converts the given wide string to a narrow string using the UTF-8
-// encoding, and streams the result to this Message object.
-Message& Message::operator <<(const ::wstring& wstr) {
-  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
-  return *this;
-}
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-// Gets the text streamed to this object so far as an std::string.
-// Each '\0' character in the buffer is replaced with "\\0".
-std::string Message::GetString() const {
-  return internal::StringStreamToString(ss_.get());
-}
-
-// AssertionResult constructors.
-// Used in EXPECT_TRUE/FALSE(assertion_result).
-AssertionResult::AssertionResult(const AssertionResult& other)
-    : success_(other.success_),
-      message_(other.message_.get() != NULL ?
-               new ::std::string(*other.message_) :
-               static_cast< ::std::string*>(NULL)) {
-}
-
-// Swaps two AssertionResults.
-void AssertionResult::swap(AssertionResult& other) {
-  using std::swap;
-  swap(success_, other.success_);
-  swap(message_, other.message_);
-}
-
-// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
-AssertionResult AssertionResult::operator!() const {
-  AssertionResult negation(!success_);
-  if (message_.get() != NULL)
-    negation << *message_;
-  return negation;
-}
-
-// Makes a successful assertion result.
-AssertionResult AssertionSuccess() {
-  return AssertionResult(true);
-}
-
-// Makes a failed assertion result.
-AssertionResult AssertionFailure() {
-  return AssertionResult(false);
-}
-
-// Makes a failed assertion result with the given failure message.
-// Deprecated; use AssertionFailure() << message.
-AssertionResult AssertionFailure(const Message& message) {
-  return AssertionFailure() << message;
-}
-
-namespace internal {
-
-namespace edit_distance {
-std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
-                                            const std::vector<size_t>& right) {
-  std::vector<std::vector<double> > costs(
-      left.size() + 1, std::vector<double>(right.size() + 1));
-  std::vector<std::vector<EditType> > best_move(
-      left.size() + 1, std::vector<EditType>(right.size() + 1));
-
-  // Populate for empty right.
-  for (size_t l_i = 0; l_i < costs.size(); ++l_i) {
-    costs[l_i][0] = static_cast<double>(l_i);
-    best_move[l_i][0] = kRemove;
-  }
-  // Populate for empty left.
-  for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) {
-    costs[0][r_i] = static_cast<double>(r_i);
-    best_move[0][r_i] = kAdd;
-  }
-
-  for (size_t l_i = 0; l_i < left.size(); ++l_i) {
-    for (size_t r_i = 0; r_i < right.size(); ++r_i) {
-      if (left[l_i] == right[r_i]) {
-        // Found a match. Consume it.
-        costs[l_i + 1][r_i + 1] = costs[l_i][r_i];
-        best_move[l_i + 1][r_i + 1] = kMatch;
-        continue;
-      }
-
-      const double add = costs[l_i + 1][r_i];
-      const double remove = costs[l_i][r_i + 1];
-      const double replace = costs[l_i][r_i];
-      if (add < remove && add < replace) {
-        costs[l_i + 1][r_i + 1] = add + 1;
-        best_move[l_i + 1][r_i + 1] = kAdd;
-      } else if (remove < add && remove < replace) {
-        costs[l_i + 1][r_i + 1] = remove + 1;
-        best_move[l_i + 1][r_i + 1] = kRemove;
-      } else {
-        // We make replace a little more expensive than add/remove to lower
-        // their priority.
-        costs[l_i + 1][r_i + 1] = replace + 1.00001;
-        best_move[l_i + 1][r_i + 1] = kReplace;
-      }
-    }
-  }
-
-  // Reconstruct the best path. We do it in reverse order.
-  std::vector<EditType> best_path;
-  for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) {
-    EditType move = best_move[l_i][r_i];
-    best_path.push_back(move);
-    l_i -= move != kAdd;
-    r_i -= move != kRemove;
-  }
-  std::reverse(best_path.begin(), best_path.end());
-  return best_path;
-}
-
-namespace {
-
-// Helper class to convert string into ids with deduplication.
-class InternalStrings {
- public:
-  size_t GetId(const std::string& str) {
-    IdMap::iterator it = ids_.find(str);
-    if (it != ids_.end()) return it->second;
-    size_t id = ids_.size();
-    return ids_[str] = id;
-  }
-
- private:
-  typedef std::map<std::string, size_t> IdMap;
-  IdMap ids_;
-};
-
-}  // namespace
-
-std::vector<EditType> CalculateOptimalEdits(
-    const std::vector<std::string>& left,
-    const std::vector<std::string>& right) {
-  std::vector<size_t> left_ids, right_ids;
-  {
-    InternalStrings intern_table;
-    for (size_t i = 0; i < left.size(); ++i) {
-      left_ids.push_back(intern_table.GetId(left[i]));
-    }
-    for (size_t i = 0; i < right.size(); ++i) {
-      right_ids.push_back(intern_table.GetId(right[i]));
-    }
-  }
-  return CalculateOptimalEdits(left_ids, right_ids);
-}
-
-namespace {
-
-// Helper class that holds the state for one hunk and prints it out to the
-// stream.
-// It reorders adds/removes when possible to group all removes before all
-// adds. It also adds the hunk header before printint into the stream.
-class Hunk {
- public:
-  Hunk(size_t left_start, size_t right_start)
-      : left_start_(left_start),
-        right_start_(right_start),
-        adds_(),
-        removes_(),
-        common_() {}
-
-  void PushLine(char edit, const char* line) {
-    switch (edit) {
-      case ' ':
-        ++common_;
-        FlushEdits();
-        hunk_.push_back(std::make_pair(' ', line));
-        break;
-      case '-':
-        ++removes_;
-        hunk_removes_.push_back(std::make_pair('-', line));
-        break;
-      case '+':
-        ++adds_;
-        hunk_adds_.push_back(std::make_pair('+', line));
-        break;
-    }
-  }
-
-  void PrintTo(std::ostream* os) {
-    PrintHeader(os);
-    FlushEdits();
-    for (std::list<std::pair<char, const char*> >::const_iterator it =
-             hunk_.begin();
-         it != hunk_.end(); ++it) {
-      *os << it->first << it->second << "\n";
-    }
-  }
-
-  bool has_edits() const { return adds_ || removes_; }
-
- private:
-  void FlushEdits() {
-    hunk_.splice(hunk_.end(), hunk_removes_);
-    hunk_.splice(hunk_.end(), hunk_adds_);
-  }
-
-  // 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 ommitted if unnecessary.
-  void PrintHeader(std::ostream* ss) const {
-    *ss << "@@ ";
-    if (removes_) {
-      *ss << "-" << left_start_ << "," << (removes_ + common_);
-    }
-    if (removes_ && adds_) {
-      *ss << " ";
-    }
-    if (adds_) {
-      *ss << "+" << right_start_ << "," << (adds_ + common_);
-    }
-    *ss << " @@\n";
-  }
-
-  size_t left_start_, right_start_;
-  size_t adds_, removes_, common_;
-  std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_;
-};
-
-}  // namespace
-
-// Create a list of diff hunks in Unified diff format.
-// Each hunk has a header generated by PrintHeader above plus a body with
-// lines prefixed with ' ' for no change, '-' for deletion and '+' for
-// addition.
-// 'context' represents the desired unchanged prefix/suffix around the diff.
-// If two hunks are close enough that their contexts overlap, then they are
-// joined into one hunk.
-std::string CreateUnifiedDiff(const std::vector<std::string>& left,
-                              const std::vector<std::string>& right,
-                              size_t context) {
-  const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
-
-  size_t l_i = 0, r_i = 0, edit_i = 0;
-  std::stringstream ss;
-  while (edit_i < edits.size()) {
-    // Find first edit.
-    while (edit_i < edits.size() && edits[edit_i] == kMatch) {
-      ++l_i;
-      ++r_i;
-      ++edit_i;
-    }
-
-    // Find the first line to include in the hunk.
-    const size_t prefix_context = std::min(l_i, context);
-    Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
-    for (size_t i = prefix_context; i > 0; --i) {
-      hunk.PushLine(' ', left[l_i - i].c_str());
-    }
-
-    // Iterate the edits until we found enough suffix for the hunk or the input
-    // is over.
-    size_t n_suffix = 0;
-    for (; edit_i < edits.size(); ++edit_i) {
-      if (n_suffix >= context) {
-        // Continue only if the next hunk is very close.
-        std::vector<EditType>::const_iterator it = edits.begin() + edit_i;
-        while (it != edits.end() && *it == kMatch) ++it;
-        if (it == edits.end() || (it - edits.begin()) - edit_i >= context) {
-          // There is no next edit or it is too far away.
-          break;
-        }
-      }
-
-      EditType edit = edits[edit_i];
-      // Reset count when a non match is found.
-      n_suffix = edit == kMatch ? n_suffix + 1 : 0;
-
-      if (edit == kMatch || edit == kRemove || edit == kReplace) {
-        hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());
-      }
-      if (edit == kAdd || edit == kReplace) {
-        hunk.PushLine('+', right[r_i].c_str());
-      }
-
-      // Advance indices, depending on edit type.
-      l_i += edit != kAdd;
-      r_i += edit != kRemove;
-    }
-
-    if (!hunk.has_edits()) {
-      // We are done. We don't want this hunk.
-      break;
-    }
-
-    hunk.PrintTo(&ss);
-  }
-  return ss.str();
-}
-
-}  // namespace edit_distance
-
-namespace {
-
-// The string representation of the values received in EqFailure() are already
-// escaped. Split them on escaped '\n' boundaries. Leave all other escaped
-// characters the same.
-std::vector<std::string> SplitEscapedString(const std::string& str) {
-  std::vector<std::string> lines;
-  size_t start = 0, end = str.size();
-  if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
-    ++start;
-    --end;
-  }
-  bool escaped = false;
-  for (size_t i = start; i + 1 < end; ++i) {
-    if (escaped) {
-      escaped = false;
-      if (str[i] == 'n') {
-        lines.push_back(str.substr(start, i - start - 1));
-        start = i + 1;
-      }
-    } else {
-      escaped = str[i] == '\\';
-    }
-  }
-  lines.push_back(str.substr(start, end - start));
-  return lines;
-}
-
-}  // namespace
-
-// Constructs and returns the message for an equality assertion
-// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
-//
-// The first four parameters are the expressions used in the assertion
-// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
-// where foo is 5 and bar is 6, we have:
-//
-//   lhs_expression: "foo"
-//   rhs_expression: "bar"
-//   lhs_value:      "5"
-//   rhs_value:      "6"
-//
-// The ignoring_case parameter is true iff 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,
-                          const char* rhs_expression,
-                          const std::string& lhs_value,
-                          const std::string& rhs_value,
-                          bool ignoring_case) {
-  Message msg;
-  msg << "      Expected: " << lhs_expression;
-  if (lhs_value != lhs_expression) {
-    msg << "\n      Which is: " << lhs_value;
-  }
-  msg << "\nTo be equal to: " << rhs_expression;
-  if (rhs_value != rhs_expression) {
-    msg << "\n      Which is: " << rhs_value;
-  }
-
-  if (ignoring_case) {
-    msg << "\nIgnoring case";
-  }
-
-  if (!lhs_value.empty() && !rhs_value.empty()) {
-    const std::vector<std::string> lhs_lines =
-        SplitEscapedString(lhs_value);
-    const std::vector<std::string> rhs_lines =
-        SplitEscapedString(rhs_value);
-    if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
-      msg << "\nWith diff:\n"
-          << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
-    }
-  }
-
-  return AssertionFailure() << msg;
-}
-
-// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
-std::string GetBoolAssertionFailureMessage(
-    const AssertionResult& assertion_result,
-    const char* expression_text,
-    const char* actual_predicate_value,
-    const char* expected_predicate_value) {
-  const char* actual_message = assertion_result.message();
-  Message msg;
-  msg << "Value of: " << expression_text
-      << "\n  Actual: " << actual_predicate_value;
-  if (actual_message[0] != '\0')
-    msg << " (" << actual_message << ")";
-  msg << "\nExpected: " << expected_predicate_value;
-  return msg.GetString();
-}
-
-// Helper function for implementing ASSERT_NEAR.
-AssertionResult DoubleNearPredFormat(const char* expr1,
-                                     const char* expr2,
-                                     const char* abs_error_expr,
-                                     double val1,
-                                     double val2,
-                                     double abs_error) {
-  const double diff = fabs(val1 - val2);
-  if (diff <= abs_error) return AssertionSuccess();
-
-  // TODO(wan): do not print the value of an expression if it's
-  // already a literal.
-  return AssertionFailure()
-      << "The difference between " << expr1 << " and " << expr2
-      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
-      << expr1 << " evaluates to " << val1 << ",\n"
-      << expr2 << " evaluates to " << val2 << ", and\n"
-      << abs_error_expr << " evaluates to " << abs_error << ".";
-}
-
-
-// Helper template for implementing FloatLE() and DoubleLE().
-template <typename RawType>
-AssertionResult FloatingPointLE(const char* expr1,
-                                const char* expr2,
-                                RawType val1,
-                                RawType val2) {
-  // Returns success if val1 is less than val2,
-  if (val1 < val2) {
-    return AssertionSuccess();
-  }
-
-  // or if val1 is almost equal to val2.
-  const FloatingPoint<RawType> lhs(val1), rhs(val2);
-  if (lhs.AlmostEquals(rhs)) {
-    return AssertionSuccess();
-  }
-
-  // Note that the above two checks will both fail if either val1 or
-  // val2 is NaN, as the IEEE floating-point standard requires that
-  // any predicate involving a NaN must return false.
-
-  ::std::stringstream val1_ss;
-  val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
-          << val1;
-
-  ::std::stringstream val2_ss;
-  val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
-          << val2;
-
-  return AssertionFailure()
-      << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
-      << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
-      << StringStreamToString(&val2_ss);
-}
-
-}  // namespace internal
-
-// Asserts that val1 is less than, or almost equal to, val2.  Fails
-// otherwise.  In particular, it fails if either val1 or val2 is NaN.
-AssertionResult FloatLE(const char* expr1, const char* expr2,
-                        float val1, float val2) {
-  return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
-}
-
-// Asserts that val1 is less than, or almost equal to, val2.  Fails
-// otherwise.  In particular, it fails if either val1 or val2 is NaN.
-AssertionResult DoubleLE(const char* expr1, const char* expr2,
-                         double val1, double val2) {
-  return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
-}
-
-namespace internal {
-
-// The helper function for {ASSERT|EXPECT}_EQ with int or enum
-// arguments.
-AssertionResult CmpHelperEQ(const char* lhs_expression,
-                            const char* rhs_expression,
-                            BiggestInt lhs,
-                            BiggestInt rhs) {
-  if (lhs == rhs) {
-    return AssertionSuccess();
-  }
-
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   FormatForComparisonFailureMessage(lhs, rhs),
-                   FormatForComparisonFailureMessage(rhs, lhs),
-                   false);
-}
-
-// A macro for implementing the helper functions needed to implement
-// ASSERT_?? and EXPECT_?? with integer or enum arguments.  It is here
-// just to avoid copy-and-paste of similar code.
-#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
-AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
-                                   BiggestInt val1, BiggestInt val2) {\
-  if (val1 op val2) {\
-    return AssertionSuccess();\
-  } else {\
-    return AssertionFailure() \
-        << "Expected: (" << expr1 << ") " #op " (" << expr2\
-        << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
-        << " vs " << FormatForComparisonFailureMessage(val2, val1);\
-  }\
-}
-
-// Implements the helper function for {ASSERT|EXPECT}_NE with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(NE, !=)
-// Implements the helper function for {ASSERT|EXPECT}_LE with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(LE, <=)
-// Implements the helper function for {ASSERT|EXPECT}_LT with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(LT, < )
-// Implements the helper function for {ASSERT|EXPECT}_GE with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(GE, >=)
-// Implements the helper function for {ASSERT|EXPECT}_GT with int or
-// enum arguments.
-GTEST_IMPL_CMP_HELPER_(GT, > )
-
-#undef GTEST_IMPL_CMP_HELPER_
-
-// The helper function for {ASSERT|EXPECT}_STREQ.
-AssertionResult CmpHelperSTREQ(const char* lhs_expression,
-                               const char* rhs_expression,
-                               const char* lhs,
-                               const char* rhs) {
-  if (String::CStringEquals(lhs, rhs)) {
-    return AssertionSuccess();
-  }
-
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   PrintToString(lhs),
-                   PrintToString(rhs),
-                   false);
-}
-
-// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
-AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
-                                   const char* rhs_expression,
-                                   const char* lhs,
-                                   const char* rhs) {
-  if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
-    return AssertionSuccess();
-  }
-
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   PrintToString(lhs),
-                   PrintToString(rhs),
-                   true);
-}
-
-// The helper function for {ASSERT|EXPECT}_STRNE.
-AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                               const char* s2_expression,
-                               const char* s1,
-                               const char* s2) {
-  if (!String::CStringEquals(s1, s2)) {
-    return AssertionSuccess();
-  } else {
-    return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
-                              << s2_expression << "), actual: \""
-                              << s1 << "\" vs \"" << s2 << "\"";
-  }
-}
-
-// The helper function for {ASSERT|EXPECT}_STRCASENE.
-AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
-                                   const char* s2_expression,
-                                   const char* s1,
-                                   const char* s2) {
-  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
-    return AssertionSuccess();
-  } else {
-    return AssertionFailure()
-        << "Expected: (" << s1_expression << ") != ("
-        << s2_expression << ") (ignoring case), actual: \""
-        << s1 << "\" vs \"" << s2 << "\"";
-  }
-}
-
-}  // namespace internal
-
-namespace {
-
-// Helper functions for implementing IsSubString() and IsNotSubstring().
-
-// This group of overloaded functions return true iff needle is a
-// substring of haystack.  NULL is considered a substring of itself
-// only.
-
-bool IsSubstringPred(const char* needle, const char* haystack) {
-  if (needle == NULL || haystack == NULL)
-    return needle == haystack;
-
-  return strstr(haystack, needle) != NULL;
-}
-
-bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
-  if (needle == NULL || haystack == NULL)
-    return needle == haystack;
-
-  return wcsstr(haystack, needle) != NULL;
-}
-
-// StringType here can be either ::std::string or ::std::wstring.
-template <typename StringType>
-bool IsSubstringPred(const StringType& needle,
-                     const StringType& haystack) {
-  return haystack.find(needle) != StringType::npos;
-}
-
-// This function implements either IsSubstring() or IsNotSubstring(),
-// depending on the value of the expected_to_be_substring parameter.
-// StringType here can be const char*, const wchar_t*, ::std::string,
-// or ::std::wstring.
-template <typename StringType>
-AssertionResult IsSubstringImpl(
-    bool expected_to_be_substring,
-    const char* needle_expr, const char* haystack_expr,
-    const StringType& needle, const StringType& haystack) {
-  if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
-    return AssertionSuccess();
-
-  const bool is_wide_string = sizeof(needle[0]) > 1;
-  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
-  return AssertionFailure()
-      << "Value of: " << needle_expr << "\n"
-      << "  Actual: " << begin_string_quote << needle << "\"\n"
-      << "Expected: " << (expected_to_be_substring ? "" : "not ")
-      << "a substring of " << haystack_expr << "\n"
-      << "Which is: " << begin_string_quote << haystack << "\"";
-}
-
-}  // namespace
-
-// IsSubstring() and IsNotSubstring() check whether needle is a
-// substring of haystack (NULL is considered a substring of itself
-// only), and return an appropriate error message when they fail.
-
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack) {
-  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack) {
-  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack) {
-  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack) {
-  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack) {
-  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack) {
-  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
-}
-
-#if GTEST_HAS_STD_WSTRING
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack) {
-  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
-}
-
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack) {
-  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-namespace internal {
-
-#if GTEST_OS_WINDOWS
-
-namespace {
-
-// Helper function for IsHRESULT{SuccessFailure} predicates
-AssertionResult HRESULTFailureHelper(const char* expr,
-                                     const char* expected,
-                                     long hr) {  // NOLINT
-# if GTEST_OS_WINDOWS_MOBILE
-
-  // Windows CE doesn't support FormatMessage.
-  const char error_text[] = "";
-
-# else
-
-  // Looks up the human-readable system message for the HRESULT code
-  // and since we're not passing any params to FormatMessage, we don't
-  // want inserts expanded.
-  const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
-                       FORMAT_MESSAGE_IGNORE_INSERTS;
-  const DWORD kBufSize = 4096;
-  // 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
-                                          hr,  // the error
-                                          0,  // no line width restrictions
-                                          error_text,  // output buffer
-                                          kBufSize,  // buf size
-                                          NULL);  // 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) {
-    error_text[message_length - 1] = '\0';
-  }
-
-# endif  // GTEST_OS_WINDOWS_MOBILE
-
-  const std::string error_hex("0x" + String::FormatHexInt(hr));
-  return ::testing::AssertionFailure()
-      << "Expected: " << expr << " " << expected << ".\n"
-      << "  Actual: " << error_hex << " " << error_text << "\n";
-}
-
-}  // namespace
-
-AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
-  if (SUCCEEDED(hr)) {
-    return AssertionSuccess();
-  }
-  return HRESULTFailureHelper(expr, "succeeds", hr);
-}
-
-AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
-  if (FAILED(hr)) {
-    return AssertionSuccess();
-  }
-  return HRESULTFailureHelper(expr, "fails", hr);
-}
-
-#endif  // GTEST_OS_WINDOWS
-
-// Utility functions for encoding Unicode text (wide strings) in
-// UTF-8.
-
-// A Unicode code-point can have upto 21 bits, and is encoded in UTF-8
-// like this:
-//
-// Code-point length   Encoding
-//   0 -  7 bits       0xxxxxxx
-//   8 - 11 bits       110xxxxx 10xxxxxx
-//  12 - 16 bits       1110xxxx 10xxxxxx 10xxxxxx
-//  17 - 21 bits       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-
-// The maximum code-point a one-byte UTF-8 sequence can represent.
-const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) <<  7) - 1;
-
-// The maximum code-point a two-byte UTF-8 sequence can represent.
-const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1;
-
-// The maximum code-point a three-byte UTF-8 sequence can represent.
-const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1;
-
-// The maximum code-point a four-byte UTF-8 sequence can represent.
-const UInt32 kMaxCodePoint4 = (static_cast<UInt32>(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 ChopLowBits(UInt32* bits, int n) {
-  const UInt32 low_bits = *bits & ((static_cast<UInt32>(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 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 code_point) {
-  if (code_point > kMaxCodePoint4) {
-    return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
-  }
-
-  char str[5];  // Big enough for the largest valid code point.
-  if (code_point <= kMaxCodePoint1) {
-    str[1] = '\0';
-    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
-  } else if (code_point <= kMaxCodePoint2) {
-    str[2] = '\0';
-    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
-  } else if (code_point <= kMaxCodePoint3) {
-    str[3] = '\0';
-    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
-  } else {  // code_point <= kMaxCodePoint4
-    str[4] = '\0';
-    str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
-    str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
-  }
-  return str;
-}
-
-// The following two functions only make sense if the the system
-// uses UTF-16 for wide string encoding. All supported systems
-// with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16.
-
-// Determines if the arguments constitute UTF-16 surrogate pair
-// and thus should be combined into a single Unicode code point
-// using CreateCodePointFromUtf16SurrogatePair.
-inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
-  return sizeof(wchar_t) == 2 &&
-      (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
-}
-
-// Creates a Unicode code point from UTF16 surrogate pair.
-inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
-                                                    wchar_t second) {
-  const UInt32 mask = (1 << 10) - 1;
-  return (sizeof(wchar_t) == 2) ?
-      (((first & mask) << 10) | (second & mask)) + 0x10000 :
-      // This function should not be called when the condition is
-      // false, but we provide a sensible default in case it is.
-      static_cast<UInt32>(first);
-}
-
-// 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, Symbian OS)
-//   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
-// of wchar_t characters processed. -1 is used when the entire string
-// should be processed.
-// If the string contains code points that are not valid Unicode code points
-// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
-// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
-// and contains invalid UTF-16 surrogate pairs, values in those pairs
-// will be encoded as individual Unicode characters from Basic Normal Plane.
-std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
-  if (num_chars == -1)
-    num_chars = static_cast<int>(wcslen(str));
-
-  ::std::stringstream stream;
-  for (int i = 0; i < num_chars; ++i) {
-    UInt32 unicode_code_point;
-
-    if (str[i] == L'\0') {
-      break;
-    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
-      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
-                                                                 str[i + 1]);
-      i++;
-    } else {
-      unicode_code_point = static_cast<UInt32>(str[i]);
-    }
-
-    stream << CodePointToUtf8(unicode_code_point);
-  }
-  return StringStreamToString(&stream);
-}
-
-// 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 == NULL)  return "(null)";
-
-  return internal::WideStringToUtf8(wide_c_str, -1);
-}
-
-// Compares two wide C strings.  Returns true iff 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 == NULL) return rhs == NULL;
-
-  if (rhs == NULL) return false;
-
-  return wcscmp(lhs, rhs) == 0;
-}
-
-// Helper function for *_STREQ on wide strings.
-AssertionResult CmpHelperSTREQ(const char* lhs_expression,
-                               const char* rhs_expression,
-                               const wchar_t* lhs,
-                               const wchar_t* rhs) {
-  if (String::WideCStringEquals(lhs, rhs)) {
-    return AssertionSuccess();
-  }
-
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   PrintToString(lhs),
-                   PrintToString(rhs),
-                   false);
-}
-
-// Helper function for *_STRNE on wide strings.
-AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                               const char* s2_expression,
-                               const wchar_t* s1,
-                               const wchar_t* s2) {
-  if (!String::WideCStringEquals(s1, s2)) {
-    return AssertionSuccess();
-  }
-
-  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
-                            << s2_expression << "), actual: "
-                            << PrintToString(s1)
-                            << " vs " << PrintToString(s2);
-}
-
-// Compares two C strings, ignoring case.  Returns true iff 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 == NULL)
-    return rhs == NULL;
-  if (rhs == NULL)
-    return false;
-  return posix::StrCaseCmp(lhs, rhs) == 0;
-}
-
-  // Compares two wide C strings, ignoring case.  Returns true iff 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 == NULL) return rhs == NULL;
-
-  if (rhs == NULL) return false;
-
-#if GTEST_OS_WINDOWS
-  return _wcsicmp(lhs, rhs) == 0;
-#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
-  return wcscasecmp(lhs, rhs) == 0;
-#else
-  // Android, Mac OS X and Cygwin don't define wcscasecmp.
-  // Other unknown OSes may not define it either.
-  wint_t left, right;
-  do {
-    left = towlower(*lhs++);
-    right = towlower(*rhs++);
-  } while (left && left == right);
-  return left == right;
-#endif  // OS selector
-}
-
-// Returns true iff 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) {
-  const size_t str_len = str.length();
-  const size_t suffix_len = suffix.length();
-  return (str_len >= suffix_len) &&
-         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
-                                      suffix.c_str());
-}
-
-// Formats an int value as "%02d".
-std::string String::FormatIntWidth2(int value) {
-  std::stringstream ss;
-  ss << std::setfill('0') << std::setw(2) << value;
-  return ss.str();
-}
-
-// Formats an int value as "%X".
-std::string String::FormatHexInt(int value) {
-  std::stringstream ss;
-  ss << std::hex << std::uppercase << value;
-  return ss.str();
-}
-
-// Formats a byte as "%02X".
-std::string String::FormatByte(unsigned char value) {
-  std::stringstream ss;
-  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
-     << static_cast<unsigned int>(value);
-  return ss.str();
-}
-
-// Converts the buffer in a stringstream to an std::string, converting NUL
-// bytes to "\\0" along the way.
-std::string StringStreamToString(::std::stringstream* ss) {
-  const ::std::string& str = ss->str();
-  const char* const start = str.c_str();
-  const char* const end = start + str.length();
-
-  std::string result;
-  result.reserve(2 * (end - start));
-  for (const char* ch = start; ch != end; ++ch) {
-    if (*ch == '\0') {
-      result += "\\0";  // Replaces NUL with "\\0";
-    } else {
-      result += *ch;
-    }
-  }
-
-  return result;
-}
-
-// Appends the user-supplied message to the Google-Test-generated message.
-std::string AppendUserMessage(const std::string& gtest_msg,
-                              const Message& user_msg) {
-  // Appends the user message if it's non-empty.
-  const std::string user_msg_string = user_msg.GetString();
-  if (user_msg_string.empty()) {
-    return gtest_msg;
-  }
-
-  return gtest_msg + "\n" + user_msg_string;
-}
-
-}  // namespace internal
-
-// class TestResult
-
-// Creates an empty TestResult.
-TestResult::TestResult()
-    : death_test_count_(0),
-      elapsed_time_(0) {
-}
-
-// D'tor.
-TestResult::~TestResult() {
-}
-
-// 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& TestResult::GetTestPartResult(int i) const {
-  if (i < 0 || i >= total_part_count())
-    internal::posix::Abort();
-  return test_part_results_.at(i);
-}
-
-// Returns the i-th test property. i can range from 0 to
-// test_property_count() - 1. If i is not in that range, aborts the
-// program.
-const TestProperty& TestResult::GetTestProperty(int i) const {
-  if (i < 0 || i >= test_property_count())
-    internal::posix::Abort();
-  return test_properties_.at(i);
-}
-
-// Clears the test part results.
-void TestResult::ClearTestPartResults() {
-  test_part_results_.clear();
-}
-
-// Adds a test part result to the list.
-void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
-  test_part_results_.push_back(test_part_result);
-}
-
-// Adds a test property to the list. If a property with the same key as the
-// supplied property is already represented, the value of this test_property
-// replaces the old value for that key.
-void TestResult::RecordProperty(const std::string& xml_element,
-                                const TestProperty& test_property) {
-  if (!ValidateTestProperty(xml_element, test_property)) {
-    return;
-  }
-  internal::MutexLock lock(&test_properites_mutex_);
-  const std::vector<TestProperty>::iterator property_with_matching_key =
-      std::find_if(test_properties_.begin(), test_properties_.end(),
-                   internal::TestPropertyKeyIs(test_property.key()));
-  if (property_with_matching_key == test_properties_.end()) {
-    test_properties_.push_back(test_property);
-    return;
-  }
-  property_with_matching_key->SetValue(test_property.value());
-}
-
-// The list of reserved attributes used in the <testsuites> element of XML
-// output.
-static const char* const kReservedTestSuitesAttributes[] = {
-  "disabled",
-  "errors",
-  "failures",
-  "name",
-  "random_seed",
-  "tests",
-  "time",
-  "timestamp"
-};
-
-// The list of reserved attributes used in the <testsuite> element of XML
-// output.
-static const char* const kReservedTestSuiteAttributes[] = {
-  "disabled",
-  "errors",
-  "failures",
-  "name",
-  "tests",
-  "time"
-};
-
-// 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"
-};
-
-template <int kSize>
-std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
-  return std::vector<std::string>(array, array + kSize);
-}
-
-static std::vector<std::string> GetReservedAttributesForElement(
-    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(kReservedTestCaseAttributes);
-  } 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) {
-    if (i > 0 && words.size() > 2) {
-      word_list << ", ";
-    }
-    if (i == words.size() - 1) {
-      word_list << "and ";
-    }
-    word_list << "'" << words[i] << "'";
-  }
-  return word_list.GetString();
-}
-
-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
-                  << " (" << FormatWordList(reserved_names)
-                  << " are reserved by " << GTEST_NAME_ << ")";
-    return false;
-  }
-  return true;
-}
-
-// Adds a failure if the key is a reserved attribute of the element named
-// xml_element.  Returns true if the property is valid.
-bool TestResult::ValidateTestProperty(const std::string& xml_element,
-                                      const TestProperty& test_property) {
-  return ValidateTestPropertyName(test_property.key(),
-                                  GetReservedAttributesForElement(xml_element));
-}
-
-// Clears the object.
-void TestResult::Clear() {
-  test_part_results_.clear();
-  test_properties_.clear();
-  death_test_count_ = 0;
-  elapsed_time_ = 0;
-}
-
-// Returns true iff the test failed.
-bool TestResult::Failed() const {
-  for (int i = 0; i < total_part_count(); ++i) {
-    if (GetTestPartResult(i).failed())
-      return true;
-  }
-  return false;
-}
-
-// Returns true iff the test part fatally failed.
-static bool TestPartFatallyFailed(const TestPartResult& result) {
-  return result.fatally_failed();
-}
-
-// Returns true iff the test fatally failed.
-bool TestResult::HasFatalFailure() const {
-  return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
-}
-
-// Returns true iff the test part non-fatally failed.
-static bool TestPartNonfatallyFailed(const TestPartResult& result) {
-  return result.nonfatally_failed();
-}
-
-// Returns true iff the test has a non-fatal failure.
-bool TestResult::HasNonfatalFailure() const {
-  return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
-}
-
-// Gets the number of all test parts.  This is the sum of the number
-// of successful test parts and the number of failed test parts.
-int TestResult::total_part_count() const {
-  return static_cast<int>(test_part_results_.size());
-}
-
-// Returns the number of the test properties.
-int TestResult::test_property_count() const {
-  return static_cast<int>(test_properties_.size());
-}
-
-// class Test
-
-// Creates a Test object.
-
-// The c'tor saves the states of all flags.
-Test::Test()
-    : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {
-}
-
-// The d'tor restores the states of all flags.  The actual work is
-// done by the d'tor of the gtest_flag_saver_ field, and thus not
-// visible here.
-Test::~Test() {
-}
-
-// Sets up the test fixture.
-//
-// A sub-class may override this.
-void Test::SetUp() {
-}
-
-// Tears down the test fixture.
-//
-// A sub-class may override this.
-void Test::TearDown() {
-}
-
-// Allows user supplied key value pairs to be recorded for later output.
-void Test::RecordProperty(const std::string& key, const std::string& value) {
-  UnitTest::GetInstance()->RecordProperty(key, value);
-}
-
-// Allows user supplied key value pairs to be recorded for later output.
-void Test::RecordProperty(const std::string& key, int value) {
-  Message value_message;
-  value_message << value;
-  RecordProperty(key, value_message.GetString().c_str());
-}
-
-namespace internal {
-
-void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
-                                    const std::string& message) {
-  // This function is a friend of UnitTest and as such has access to
-  // AddTestPartResult.
-  UnitTest::GetInstance()->AddTestPartResult(
-      result_type,
-      NULL,  // 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.
-}
-
-}  // namespace internal
-
-// Google Test requires all tests in the same test case 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 case.  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 TestCase* const test_case = impl->current_test_case();
-
-  // Info about the first test in the current test case.
-  const TestInfo* const first_test_info = test_case->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();
-
-  // Info about the current test.
-  const TestInfo* const this_test_info = impl->current_test_info();
-  const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
-  const char* const this_test_name = this_test_info->name();
-
-  if (this_fixture_id != first_fixture_id) {
-    // Is the first test defined using TEST?
-    const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
-    // Is this test defined using TEST?
-    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 case, which is incorrect.
-      // Tell the user how to fix this.
-
-      // Gets the name of the TEST and the name of the TEST_F.  Note
-      // that first_is_TEST and this_is_TEST cannot both be true, as
-      // the fixture IDs are different for the two tests.
-      const char* const TEST_name =
-          first_is_TEST ? first_test_name : this_test_name;
-      const char* const TEST_F_name =
-          first_is_TEST ? this_test_name : first_test_name;
-
-      ADD_FAILURE()
-          << "All tests in the same test case must use the same test fixture\n"
-          << "class, so mixing TEST_F and TEST in the same test case is\n"
-          << "illegal.  In test case " << this_test_info->test_case_name()
-          << ",\n"
-          << "test " << TEST_F_name << " is defined using TEST_F but\n"
-          << "test " << TEST_name << " is defined using TEST.  You probably\n"
-          << "want to change the TEST to TEST_F or move it to another test\n"
-          << "case.";
-    } else {
-      // 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 case must use the same test fixture\n"
-          << "class.  However, in test case "
-          << this_test_info->test_case_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 cases.";
-    }
-    return false;
-  }
-
-  return true;
-}
-
-#if GTEST_HAS_SEH
-
-// Adds an "exception thrown" fatal failure to the current test.  This
-// function returns its result via an output parameter pointer because VC++
-// prohibits creation of objects with destructors on stack in functions
-// using __try (see error C2712).
-static std::string* FormatSehExceptionMessage(DWORD exception_code,
-                                              const char* location) {
-  Message message;
-  message << "SEH exception with code 0x" << std::setbase(16) <<
-    exception_code << std::setbase(10) << " thrown in " << location << ".";
-
-  return new std::string(message.GetString());
-}
-
-#endif  // GTEST_HAS_SEH
-
-namespace internal {
-
-#if GTEST_HAS_EXCEPTIONS
-
-// Adds an "exception thrown" fatal failure to the current test.
-static std::string FormatCxxExceptionMessage(const char* description,
-                                             const char* location) {
-  Message message;
-  if (description != NULL) {
-    message << "C++ exception with description \"" << description << "\"";
-  } else {
-    message << "Unknown C++ exception";
-  }
-  message << " thrown in " << location << ".";
-
-  return message.GetString();
-}
-
-static std::string PrintTestPartResultToString(
-    const TestPartResult& test_part_result);
-
-GoogleTestFailureException::GoogleTestFailureException(
-    const TestPartResult& failure)
-    : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// We put these helper functions in the internal namespace as IBM's xlC
-// compiler rejects the code if they were declared static.
-
-// Runs the given method and handles SEH exceptions it throws, when
-// SEH is supported; returns the 0-value for type Result in case of an
-// SEH exception.  (Microsoft compilers cannot handle SEH and C++
-// exceptions in the same function.  Therefore, we provide a separate
-// wrapper function for handling SEH exceptions.)
-template <class T, typename Result>
-Result HandleSehExceptionsInMethodIfSupported(
-    T* object, Result (T::*method)(), const char* location) {
-#if GTEST_HAS_SEH
-  __try {
-    return (object->*method)();
-  } __except (internal::UnitTestOptions::GTestShouldProcessSEH(  // NOLINT
-      GetExceptionCode())) {
-    // We create the exception message on the heap because VC++ prohibits
-    // creation of objects with destructors on stack in functions using __try
-    // (see error C2712).
-    std::string* exception_message = FormatSehExceptionMessage(
-        GetExceptionCode(), location);
-    internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
-                                             *exception_message);
-    delete exception_message;
-    return static_cast<Result>(0);
-  }
-#else
-  (void)location;
-  return (object->*method)();
-#endif  // GTEST_HAS_SEH
-}
-
-// Runs the given method and catches and reports C++ and/or SEH-style
-// exceptions, if they are supported; returns the 0-value for type
-// Result in case of an SEH exception.
-template <class T, typename Result>
-Result HandleExceptionsInMethodIfSupported(
-    T* object, Result (T::*method)(), const char* location) {
-  // NOTE: The user code can affect the way in which Google Test handles
-  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
-  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
-  // after the exception is caught and either report or re-throw the
-  // exception based on the flag's value:
-  //
-  // try {
-  //   // Perform the test method.
-  // } catch (...) {
-  //   if (GTEST_FLAG(catch_exceptions))
-  //     // Report the exception as failure.
-  //   else
-  //     throw;  // Re-throws the original exception.
-  // }
-  //
-  // However, the purpose of this flag is to allow the program to drop into
-  // the debugger when the exception is thrown. On most platforms, once the
-  // control enters the catch block, the exception origin information is
-  // lost and the debugger will stop the program at the point of the
-  // re-throw in this function -- instead of at the point of the original
-  // throw statement in the code under test.  For this reason, we perform
-  // the check early, sacrificing the ability to affect Google Test's
-  // exception handling in the method where the exception is thrown.
-  if (internal::GetUnitTestImpl()->catch_exceptions()) {
-#if GTEST_HAS_EXCEPTIONS
-    try {
-      return HandleSehExceptionsInMethodIfSupported(object, method, location);
-    } 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
-      // framework catch it.  Therefore we just re-throw it.
-      throw;
-    } catch (const std::exception& e) {  // NOLINT
-      internal::ReportFailureInUnknownLocation(
-          TestPartResult::kFatalFailure,
-          FormatCxxExceptionMessage(e.what(), location));
-    } catch (...) {  // NOLINT
-      internal::ReportFailureInUnknownLocation(
-          TestPartResult::kFatalFailure,
-          FormatCxxExceptionMessage(NULL, location));
-    }
-    return static_cast<Result>(0);
-#else
-    return HandleSehExceptionsInMethodIfSupported(object, method, location);
-#endif  // GTEST_HAS_EXCEPTIONS
-  } else {
-    return (object->*method)();
-  }
-}
-
-}  // namespace internal
-
-// Runs the test and updates the test result.
-void Test::Run() {
-  if (!HasSameFixtureClass()) return;
-
-  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.
-  if (!HasFatalFailure()) {
-    impl->os_stack_trace_getter()->UponLeavingGTest();
-    internal::HandleExceptionsInMethodIfSupported(
-        this, &Test::TestBody, "the test body");
-  }
-
-  // However, we want to clean up as much as possible.  Hence we will
-  // always call TearDown(), even if SetUp() or the test body has
-  // failed.
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(
-      this, &Test::TearDown, "TearDown()");
-}
-
-// Returns true iff the current test has a fatal failure.
-bool Test::HasFatalFailure() {
-  return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
-}
-
-// Returns true iff the current test has a non-fatal failure.
-bool Test::HasNonfatalFailure() {
-  return internal::GetUnitTestImpl()->current_test_result()->
-      HasNonfatalFailure();
-}
-
-// class TestInfo
-
-// Constructs a TestInfo object. It assumes ownership of the test factory
-// object.
-TestInfo::TestInfo(const std::string& a_test_case_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_case_name_(a_test_case_name),
-      name_(a_name),
-      type_param_(a_type_param ? new std::string(a_type_param) : NULL),
-      value_param_(a_value_param ? new std::string(a_value_param) : NULL),
-      location_(a_code_location),
-      fixture_class_id_(fixture_class_id),
-      should_run_(false),
-      is_disabled_(false),
-      matches_filter_(false),
-      factory_(factory),
-      result_() {}
-
-// Destructs a TestInfo object.
-TestInfo::~TestInfo() { delete factory_; }
-
-namespace internal {
-
-// Creates a new TestInfo object and registers it with Google Test;
-// returns the created object.
-//
-// Arguments:
-//
-//   test_case_name:   name of the test case
-//   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.
-//   value_param:      text representation of the test's value parameter,
-//                     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 case
-//   tear_down_tc:     pointer to the function that tears down the test case
-//   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_case_name,
-    const char* name,
-    const char* type_param,
-    const char* value_param,
-    CodeLocation code_location,
-    TypeId fixture_class_id,
-    SetUpTestCaseFunc set_up_tc,
-    TearDownTestCaseFunc tear_down_tc,
-    TestFactoryBase* factory) {
-  TestInfo* const test_info =
-      new TestInfo(test_case_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;
-}
-
-#if GTEST_HAS_PARAM_TEST
-void ReportInvalidTestCaseType(const char* test_case_name,
-                               CodeLocation code_location) {
-  Message errors;
-  errors
-      << "Attempted redefinition of test case " << test_case_name << ".\n"
-      << "All tests in the same test case must use the same test fixture\n"
-      << "class.  However, in test case " << test_case_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 cases.";
-
-  fprintf(stderr, "%s %s",
-          FormatFileLocation(code_location.file.c_str(),
-                             code_location.line).c_str(),
-          errors.GetString().c_str());
-}
-#endif  // GTEST_HAS_PARAM_TEST
-
-}  // namespace internal
-
-namespace {
-
-// A predicate that checks the test name of a TestInfo against a known
-// value.
-//
-// This is used for implementation of the TestCase class only.  We put
-// it in the anonymous namespace to prevent polluting the outer
-// namespace.
-//
-// TestNameIs is copyable.
-class TestNameIs {
- public:
-  // Constructor.
-  //
-  // TestNameIs has NO default constructor.
-  explicit TestNameIs(const char* name)
-      : name_(name) {}
-
-  // Returns true iff the test name of test_info matches name_.
-  bool operator()(const TestInfo * test_info) const {
-    return test_info && test_info->name() == name_;
-  }
-
- private:
-  std::string name_;
-};
-
-}  // namespace
-
-namespace internal {
-
-// This method expands all parameterized tests registered with macros TEST_P
-// and INSTANTIATE_TEST_CASE_P into regular tests and registers those.
-// This will be done just once during the program runtime.
-void UnitTestImpl::RegisterParameterizedTests() {
-#if GTEST_HAS_PARAM_TEST
-  if (!parameterized_tests_registered_) {
-    parameterized_test_registry_.RegisterTests();
-    parameterized_tests_registered_ = true;
-  }
-#endif
-}
-
-}  // namespace internal
-
-// Creates the test object, runs it, records its result, and then
-// deletes it.
-void TestInfo::Run() {
-  if (!should_run_) return;
-
-  // Tells UnitTest where to store test result.
-  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 TimeInMillis start = internal::GetTimeInMillis();
-
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-
-  // Creates the test object.
-  Test* const test = internal::HandleExceptionsInMethodIfSupported(
-      factory_, &internal::TestFactoryBase::CreateTest,
-      "the test fixture's constructor");
-
-  // Runs the test only if the test object was created and its
-  // constructor didn't generate a fatal failure.
-  if ((test != NULL) && !Test::HasFatalFailure()) {
-    // This doesn't throw as all user code that can throw are wrapped into
-    // exception handling code.
-    test->Run();
-  }
-
-  // Deletes the test object.
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(
-      test, &Test::DeleteSelf_, "the test fixture's destructor");
-
-  result_.set_elapsed_time(internal::GetTimeInMillis() - start);
-
-  // 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(NULL);
-}
-
-// class TestCase
-
-// Gets the number of successful tests in this test case.
-int TestCase::successful_test_count() const {
-  return CountIf(test_info_list_, TestPassed);
-}
-
-// Gets the number of failed tests in this test case.
-int TestCase::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 TestCase::reportable_disabled_test_count() const {
-  return CountIf(test_info_list_, TestReportableDisabled);
-}
-
-// Gets the number of disabled tests in this test case.
-int TestCase::disabled_test_count() const {
-  return CountIf(test_info_list_, TestDisabled);
-}
-
-// Gets the number of tests to be printed in the XML report.
-int TestCase::reportable_test_count() const {
-  return CountIf(test_info_list_, TestReportable);
-}
-
-// Get the number of tests in this test case that should run.
-int TestCase::test_to_run_count() const {
-  return CountIf(test_info_list_, ShouldRunTest);
-}
-
-// Gets the number of all tests.
-int TestCase::total_test_count() const {
-  return static_cast<int>(test_info_list_.size());
-}
-
-// Creates a TestCase with the given name.
-//
-// Arguments:
-//
-//   name:         name of the test case
-//   a_type_param: the name of the test case's type parameter, or NULL if
-//                 this is not a typed or a type-parameterized test case.
-//   set_up_tc:    pointer to the function that sets up the test case
-//   tear_down_tc: pointer to the function that tears down the test case
-TestCase::TestCase(const char* a_name, const char* a_type_param,
-                   Test::SetUpTestCaseFunc set_up_tc,
-                   Test::TearDownTestCaseFunc tear_down_tc)
-    : name_(a_name),
-      type_param_(a_type_param ? new std::string(a_type_param) : NULL),
-      set_up_tc_(set_up_tc),
-      tear_down_tc_(tear_down_tc),
-      should_run_(false),
-      elapsed_time_(0) {
-}
-
-// Destructor of TestCase.
-TestCase::~TestCase() {
-  // 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* TestCase::GetTestInfo(int i) const {
-  const int index = GetElementOr(test_indices_, i, -1);
-  return index < 0 ? NULL : test_info_list_[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* TestCase::GetMutableTestInfo(int i) {
-  const int index = GetElementOr(test_indices_, i, -1);
-  return index < 0 ? NULL : test_info_list_[index];
-}
-
-// Adds a test to this test case.  Will delete the test upon
-// destruction of the TestCase object.
-void TestCase::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 TestCase.
-void TestCase::Run() {
-  if (!should_run_) return;
-
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  impl->set_current_test_case(this);
-
-  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
-
-  repeater->OnTestCaseStart(*this);
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(
-      this, &TestCase::RunSetUpTestCase, "SetUpTestCase()");
-
-  const internal::TimeInMillis start = internal::GetTimeInMillis();
-  for (int i = 0; i < total_test_count(); i++) {
-    GetMutableTestInfo(i)->Run();
-  }
-  elapsed_time_ = internal::GetTimeInMillis() - start;
-
-  impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(
-      this, &TestCase::RunTearDownTestCase, "TearDownTestCase()");
-
-  repeater->OnTestCaseEnd(*this);
-  impl->set_current_test_case(NULL);
-}
-
-// Clears the results of all tests in this test case.
-void TestCase::ClearResult() {
-  ad_hoc_test_result_.Clear();
-  ForEach(test_info_list_, TestInfo::ClearTestResult);
-}
-
-// Shuffles the tests in this test case.
-void TestCase::ShuffleTests(internal::Random* random) {
-  Shuffle(random, &test_indices_);
-}
-
-// Restores the test order to before the first shuffle.
-void TestCase::UnshuffleTests() {
-  for (size_t i = 0; i < test_indices_.size(); i++) {
-    test_indices_[i] = static_cast<int>(i);
-  }
-}
-
-// Formats a countable noun.  Depending on its quantity, either the
-// singular form or the plural form is used. e.g.
-//
-// FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
-// FormatCountableNoun(5, "book", "books") returns "5 books".
-static std::string FormatCountableNoun(int count,
-                                       const char * singular_form,
-                                       const char * plural_form) {
-  return internal::StreamableToString(count) + " " +
-      (count == 1 ? singular_form : plural_form);
-}
-
-// Formats the count of tests.
-static std::string FormatTestCount(int test_count) {
-  return FormatCountableNoun(test_count, "test", "tests");
-}
-
-// Formats the count of test cases.
-static std::string FormatTestCaseCount(int test_case_count) {
-  return FormatCountableNoun(test_case_count, "test case", "test cases");
-}
-
-// Converts a TestPartResult::Type enum to human-friendly string
-// representation.  Both kNonFatalFailure and kFatalFailure are translated
-// to "Failure", as the user usually doesn't care about the difference
-// between the two when viewing the test result.
-static const char * TestPartResultTypeToString(TestPartResult::Type type) {
-  switch (type) {
-    case TestPartResult::kSuccess:
-      return "Success";
-
-    case TestPartResult::kNonFatalFailure:
-    case TestPartResult::kFatalFailure:
-#ifdef _MSC_VER
-      return "error: ";
-#else
-      return "Failure\n";
-#endif
-    default:
-      return "Unknown result type";
-  }
-}
-
-namespace internal {
-
-// Prints a TestPartResult to an std::string.
-static std::string PrintTestPartResultToString(
-    const TestPartResult& test_part_result) {
-  return (Message()
-          << internal::FormatFileLocation(test_part_result.file_name(),
-                                          test_part_result.line_number())
-          << " " << TestPartResultTypeToString(test_part_result.type())
-          << test_part_result.message()).GetString();
-}
-
-// Prints a TestPartResult.
-static void PrintTestPartResult(const TestPartResult& test_part_result) {
-  const std::string& result =
-      PrintTestPartResultToString(test_part_result);
-  printf("%s\n", result.c_str());
-  fflush(stdout);
-  // If the test program runs in Visual Studio or a debugger, the
-  // following statements add the test part result message to the Output
-  // window such that the user can double-click on it to jump to the
-  // corresponding source code location; otherwise they do nothing.
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
-  // We don't call OutputDebugString*() on Windows Mobile, as printing
-  // to stdout is done by OutputDebugString() there already - we don't
-  // want the same message printed twice.
-  ::OutputDebugStringA(result.c_str());
-  ::OutputDebugStringA("\n");
-#endif
-}
-
-// class PrettyUnitTestResultPrinter
-
-enum GTestColor {
-  COLOR_DEFAULT,
-  COLOR_RED,
-  COLOR_GREEN,
-  COLOR_YELLOW
-};
-
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
-    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-
-// Returns the character attribute for the given color.
-WORD GetColorAttribute(GTestColor color) {
-  switch (color) {
-    case COLOR_RED:    return FOREGROUND_RED;
-    case COLOR_GREEN:  return FOREGROUND_GREEN;
-    case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN;
-    default:           return 0;
-  }
-}
-
-#else
-
-// Returns the ANSI color code for the given color.  COLOR_DEFAULT is
-// an invalid input.
-const char* GetAnsiColorCode(GTestColor color) {
-  switch (color) {
-    case COLOR_RED:     return "1";
-    case COLOR_GREEN:   return "2";
-    case COLOR_YELLOW:  return "3";
-    default:            return NULL;
-  };
-}
-
-#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
-
-// Returns true iff 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
-    // On Windows the TERM variable is usually not set, but the
-    // console there does support colors.
-    return stdout_is_tty;
-#else
-    // On non-Windows platforms, we rely on the TERM variable.
-    const char* const term = posix::GetEnv("TERM");
-    const bool term_supports_color =
-        String::CStringEquals(term, "xterm") ||
-        String::CStringEquals(term, "xterm-color") ||
-        String::CStringEquals(term, "xterm-256color") ||
-        String::CStringEquals(term, "screen") ||
-        String::CStringEquals(term, "screen-256color") ||
-        String::CStringEquals(term, "tmux") ||
-        String::CStringEquals(term, "tmux-256color") ||
-        String::CStringEquals(term, "rxvt-unicode") ||
-        String::CStringEquals(term, "rxvt-unicode-256color") ||
-        String::CStringEquals(term, "linux") ||
-        String::CStringEquals(term, "cygwin");
-    return stdout_is_tty && term_supports_color;
-#endif  // GTEST_OS_WINDOWS
-  }
-
-  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
-      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
-      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
-      String::CStringEquals(gtest_color, "1");
-  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
-  // value is neither one of these nor "auto", we treat it as "no" to
-  // be conservative.
-}
-
-// Helpers for printing colored strings to stdout. Note that on Windows, we
-// 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.
-void ColoredPrintf(GTestColor color, const char* fmt, ...) {
-  va_list args;
-  va_start(args, fmt);
-
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || \
-    GTEST_OS_IOS || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
-  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 != COLOR_DEFAULT);
-#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
-  // The '!= 0' comparison is necessary to satisfy MSVC 7.1.
-
-  if (!use_color) {
-    vprintf(fmt, args);
-    va_end(args);
-    return;
-  }
-
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
-    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-  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;
-
-  // 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,
-                          GetColorAttribute(color) | FOREGROUND_INTENSITY);
-  vprintf(fmt, args);
-
-  fflush(stdout);
-  // Restores the text color.
-  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
-#else
-  printf("\033[0;3%sm", GetAnsiColorCode(color));
-  vprintf(fmt, args);
-  printf("\033[m");  // Resets the terminal to default.
-#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
-  va_end(args);
-}
-
-// Text printed in Google Test's text output and --gunit_list_tests
-// output to label the type parameter and value parameter for a test.
-static const char kTypeParamLabel[] = "TypeParam";
-static const char kValueParamLabel[] = "GetParam()";
-
-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 != NULL || value_param != NULL) {
-    printf(", where ");
-    if (type_param != NULL) {
-      printf("%s = %s", kTypeParamLabel, type_param);
-      if (value_param != NULL)
-        printf(" and ");
-    }
-    if (value_param != NULL) {
-      printf("%s = %s", kValueParamLabel, value_param);
-    }
-  }
-}
-
-// This class implements the TestEventListener interface.
-//
-// Class PrettyUnitTestResultPrinter is copyable.
-class PrettyUnitTestResultPrinter : public TestEventListener {
- public:
-  PrettyUnitTestResultPrinter() {}
-  static void PrintTestName(const char * test_case, const char * test) {
-    printf("%s.%s", test_case, test);
-  }
-
-  // The following methods override what's in the TestEventListener class.
-  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration);
-  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
-  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestCaseStart(const TestCase& test_case);
-  virtual void OnTestStart(const TestInfo& test_info);
-  virtual void OnTestPartResult(const TestPartResult& result);
-  virtual void OnTestEnd(const TestInfo& test_info);
-  virtual void OnTestCaseEnd(const TestCase& test_case);
-  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
-  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
-  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
-  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
-
- private:
-  static void PrintFailedTests(const UnitTest& unit_test);
-};
-
-  // Fired before each iteration of tests starts.
-void PrettyUnitTestResultPrinter::OnTestIterationStart(
-    const UnitTest& unit_test, int iteration) {
-  if (GTEST_FLAG(repeat) != 1)
-    printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
-
-  const char* const filter = GTEST_FLAG(filter).c_str();
-
-  // Prints the filter if it's not *.  This reminds the user that some
-  // tests may be skipped.
-  if (!String::CStringEquals(filter, kUniversalFilter)) {
-    ColoredPrintf(COLOR_YELLOW,
-                  "Note: %s filter = %s\n", GTEST_NAME_, filter);
-  }
-
-  if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
-    const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
-    ColoredPrintf(COLOR_YELLOW,
-                  "Note: This is test shard %d of %s.\n",
-                  static_cast<int>(shard_index) + 1,
-                  internal::posix::GetEnv(kTestTotalShards));
-  }
-
-  if (GTEST_FLAG(shuffle)) {
-    ColoredPrintf(COLOR_YELLOW,
-                  "Note: Randomizing tests' orders with a seed of %d .\n",
-                  unit_test.random_seed());
-  }
-
-  ColoredPrintf(COLOR_GREEN,  "[==========] ");
-  printf("Running %s from %s.\n",
-         FormatTestCount(unit_test.test_to_run_count()).c_str(),
-         FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str());
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
-    const UnitTest& /*unit_test*/) {
-  ColoredPrintf(COLOR_GREEN,  "[----------] ");
-  printf("Global test environment set-up.\n");
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
-  const std::string counts =
-      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
-  ColoredPrintf(COLOR_GREEN, "[----------] ");
-  printf("%s from %s", counts.c_str(), test_case.name());
-  if (test_case.type_param() == NULL) {
-    printf("\n");
-  } else {
-    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
-  }
-  fflush(stdout);
-}
-
-void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
-  ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
-  PrintTestName(test_info.test_case_name(), test_info.name());
-  printf("\n");
-  fflush(stdout);
-}
-
-// Called after an assertion failure.
-void PrettyUnitTestResultPrinter::OnTestPartResult(
-    const TestPartResult& result) {
-  // If the test part succeeded, we don't need to do anything.
-  if (result.type() == TestPartResult::kSuccess)
-    return;
-
-  // 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(COLOR_GREEN, "[       OK ] ");
-  } else {
-    ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
-  }
-  PrintTestName(test_info.test_case_name(), test_info.name());
-  if (test_info.result()->Failed())
-    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 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(COLOR_GREEN, "[----------] ");
-  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);
-}
-
-void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
-    const UnitTest& /*unit_test*/) {
-  ColoredPrintf(COLOR_GREEN,  "[----------] ");
-  printf("Global test environment tear-down\n");
-  fflush(stdout);
-}
-
-// 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();
-  if (failed_test_count == 0) {
-    return;
-  }
-
-  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
-    const TestCase& test_case = *unit_test.GetTestCase(i);
-    if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
-      continue;
-    }
-    for (int j = 0; j < test_case.total_test_count(); ++j) {
-      const TestInfo& test_info = *test_case.GetTestInfo(j);
-      if (!test_info.should_run() || test_info.result()->Passed()) {
-        continue;
-      }
-      ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
-      printf("%s.%s", test_case.name(), test_info.name());
-      PrintFullTestCommentIfPresent(test_info);
-      printf("\n");
-    }
-  }
-}
-
-void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
-                                                     int /*iteration*/) {
-  ColoredPrintf(COLOR_GREEN,  "[==========] ");
-  printf("%s from %s ran.",
-         FormatTestCount(unit_test.test_to_run_count()).c_str(),
-         FormatTestCaseCount(unit_test.test_case_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(COLOR_GREEN,  "[  PASSED  ] ");
-  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
-
-  int num_failures = unit_test.failed_test_count();
-  if (!unit_test.Passed()) {
-    const int failed_test_count = unit_test.failed_test_count();
-    ColoredPrintf(COLOR_RED,  "[  FAILED  ] ");
-    printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
-    PrintFailedTests(unit_test);
-    printf("\n%2d FAILED %s\n", num_failures,
-                        num_failures == 1 ? "TEST" : "TESTS");
-  }
-
-  int num_disabled = unit_test.reportable_disabled_test_count();
-  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
-    if (!num_failures) {
-      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
-    }
-    ColoredPrintf(COLOR_YELLOW,
-                  "  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 PrettyUnitTestResultPrinter
-
-// class TestEventRepeater
-//
-// This class forwards events to other event listeners.
-class TestEventRepeater : public TestEventListener {
- public:
-  TestEventRepeater() : forwarding_enabled_(true) {}
-  virtual ~TestEventRepeater();
-  void Append(TestEventListener *listener);
-  TestEventListener* Release(TestEventListener* listener);
-
-  // Controls whether events will be forwarded to listeners_. Set to false
-  // in death test child processes.
-  bool forwarding_enabled() const { return forwarding_enabled_; }
-  void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }
-
-  virtual void OnTestProgramStart(const UnitTest& unit_test);
-  virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration);
-  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test);
-  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test);
-  virtual void OnTestCaseStart(const TestCase& test_case);
-  virtual void OnTestStart(const TestInfo& test_info);
-  virtual void OnTestPartResult(const TestPartResult& result);
-  virtual void OnTestEnd(const TestInfo& test_info);
-  virtual void OnTestCaseEnd(const TestCase& test_case);
-  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test);
-  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test);
-  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
-  virtual void OnTestProgramEnd(const UnitTest& unit_test);
-
- private:
-  // Controls whether events will be forwarded to listeners_. Set to false
-  // in death test child processes.
-  bool forwarding_enabled_;
-  // The list of listeners that receive events.
-  std::vector<TestEventListener*> listeners_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
-};
-
-TestEventRepeater::~TestEventRepeater() {
-  ForEach(listeners_, Delete<TestEventListener>);
-}
-
-void TestEventRepeater::Append(TestEventListener *listener) {
-  listeners_.push_back(listener);
-}
-
-// TODO(vladl@google.com): Factor the search functionality into Vector::Find.
-TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
-  for (size_t i = 0; i < listeners_.size(); ++i) {
-    if (listeners_[i] == listener) {
-      listeners_.erase(listeners_.begin() + i);
-      return listener;
-    }
-  }
-
-  return NULL;
-}
-
-// Since most methods are very similar, use macros to reduce boilerplate.
-// This defines a member that forwards the call to all listeners.
-#define GTEST_REPEATER_METHOD_(Name, Type) \
-void TestEventRepeater::Name(const Type& parameter) { \
-  if (forwarding_enabled_) { \
-    for (size_t i = 0; i < listeners_.size(); i++) { \
-      listeners_[i]->Name(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 (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \
-      listeners_[i]->Name(parameter); \
-    } \
-  } \
-}
-
-GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
-GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
-GTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase)
-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)
-GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase)
-GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
-
-#undef GTEST_REPEATER_METHOD_
-#undef GTEST_REVERSE_REPEATER_METHOD_
-
-void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
-                                             int iteration) {
-  if (forwarding_enabled_) {
-    for (size_t i = 0; i < listeners_.size(); i++) {
-      listeners_[i]->OnTestIterationStart(unit_test, iteration);
-    }
-  }
-}
-
-void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
-                                           int iteration) {
-  if (forwarding_enabled_) {
-    for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) {
-      listeners_[i]->OnTestIterationEnd(unit_test, iteration);
-    }
-  }
-}
-
-// End TestEventRepeater
-
-// This class generates an XML output file.
-class XmlUnitTestResultPrinter : public EmptyTestEventListener {
- public:
-  explicit XmlUnitTestResultPrinter(const char* output_file);
-
-  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
-
- private:
-  // Is c a whitespace character that is normalized to a space character
-  // when it appears in an XML attribute value?
-  static bool IsNormalizableWhitespace(char c) {
-    return c == 0x9 || c == 0xA || c == 0xD;
-  }
-
-  // May c appear in a well-formed XML document?
-  static bool IsValidXmlCharacter(char c) {
-    return IsNormalizableWhitespace(c) || c >= 0x20;
-  }
-
-  // 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 references.
-  static std::string EscapeXml(const std::string& str, bool is_attribute);
-
-  // Returns the given string with all characters invalid in XML removed.
-  static std::string RemoveInvalidXmlCharacters(const std::string& str);
-
-  // Convenience wrapper around EscapeXml when str is an attribute value.
-  static std::string EscapeXmlAttribute(const std::string& str) {
-    return EscapeXml(str, true);
-  }
-
-  // Convenience wrapper around EscapeXml when str is not an attribute value.
-  static std::string EscapeXmlText(const char* str) {
-    return EscapeXml(str, false);
-  }
-
-  // Verifies that the given attribute belongs to the given element and
-  // streams the attribute as XML.
-  static void OutputXmlAttribute(std::ostream* stream,
-                                 const std::string& element_name,
-                                 const std::string& name,
-                                 const std::string& value);
-
-  // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
-  static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
-
-  // Streams an XML representation of a TestInfo object.
-  static void OutputXmlTestInfo(::std::ostream* stream,
-                                const char* test_case_name,
-                                const TestInfo& test_info);
-
-  // Prints an XML representation of a TestCase object
-  static void PrintXmlTestCase(::std::ostream* stream,
-                               const TestCase& test_case);
-
-  // Prints an XML summary of unit_test to output stream out.
-  static void PrintXmlUnitTest(::std::ostream* stream,
-                               const UnitTest& unit_test);
-
-  // Produces a string representing the test properties in a result as space
-  // delimited XML attributes based on the property key="value" pairs.
-  // When the std::string is not empty, it includes a space at the beginning,
-  // to delimit this attribute from prior attributes.
-  static std::string TestPropertiesAsXmlAttributes(const TestResult& result);
-
-  // The output file.
-  const std::string output_file_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
-};
-
-// Creates a new XmlUnitTestResultPrinter.
-XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
-    : output_file_(output_file) {
-  if (output_file_.c_str() == NULL || output_file_.empty()) {
-    fprintf(stderr, "XML output file may not be null\n");
-    fflush(stderr);
-    exit(EXIT_FAILURE);
-  }
-}
-
-// Called after the unit test ends.
-void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
-                                                  int /*iteration*/) {
-  FILE* xmlout = NULL;
-  FilePath output_file(output_file_);
-  FilePath output_dir(output_file.RemoveFileName());
-
-  if (output_dir.CreateDirectoriesRecursively()) {
-    xmlout = posix::FOpen(output_file_.c_str(), "w");
-  }
-  if (xmlout == NULL) {
-    // TODO(wan): report the reason of the failure.
-    //
-    // We don't do it for now as:
-    //
-    //   1. There is no urgent need for it.
-    //   2. It's a bit involved to make the errno variable thread-safe on
-    //      all three operating systems (Linux, Windows, and Mac OS).
-    //   3. To interpret the meaning of errno in a thread-safe way,
-    //      we need the strerror_r() function, which is not available on
-    //      Windows.
-    fprintf(stderr,
-            "Unable to open file \"%s\"\n",
-            output_file_.c_str());
-    fflush(stderr);
-    exit(EXIT_FAILURE);
-  }
-  std::stringstream stream;
-  PrintXmlUnitTest(&stream, unit_test);
-  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
-// references.
-//
-// Invalid XML characters in str, if any, are stripped from the output.
-// It is expected that most, if not all, of the text processed by this
-// module will consist of ordinary English text.
-// If this module is ever modified to produce version 1.1 XML output,
-// most invalid characters can be retained using character references.
-// TODO(wan): It might be nice to have a minimally invasive, human-readable
-// escaping scheme for invalid characters, rather than dropping them.
-std::string XmlUnitTestResultPrinter::EscapeXml(
-    const std::string& str, bool is_attribute) {
-  Message m;
-
-  for (size_t i = 0; i < str.size(); ++i) {
-    const char ch = str[i];
-    switch (ch) {
-      case '<':
-        m << "&lt;";
-        break;
-      case '>':
-        m << "&gt;";
-        break;
-      case '&':
-        m << "&amp;";
-        break;
-      case '\'':
-        if (is_attribute)
-          m << "&apos;";
-        else
-          m << '\'';
-        break;
-      case '"':
-        if (is_attribute)
-          m << "&quot;";
-        else
-          m << '"';
-        break;
-      default:
-        if (IsValidXmlCharacter(ch)) {
-          if (is_attribute && IsNormalizableWhitespace(ch))
-            m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
-              << ";";
-          else
-            m << ch;
-        }
-        break;
-    }
-  }
-
-  return m.GetString();
-}
-
-// Returns the given string with all characters invalid in XML removed.
-// Currently invalid characters are dropped from the string. An
-// alternative is to replace them with certain characters such as . or ?.
-std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
-    const std::string& str) {
-  std::string output;
-  output.reserve(str.size());
-  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
-    if (IsValidXmlCharacter(*it))
-      output.push_back(*it);
-
-  return output;
-}
-
-// The following routines generate an XML representation of a UnitTest
-// object.
-//
-// 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 TestCase object
-//     <testcase name="test-name">     <-- corresponds to a TestInfo object
-//       <failure message="...">...</failure>
-//       <failure message="...">...</failure>
-//       <failure message="...">...</failure>
-//                                     <-- individual assertion failures
-//     </testcase>
-//   </testsuite>
-// </testsuites>
-
-// Formats the given time in milliseconds as seconds.
-std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
-  ::std::stringstream ss;
-  ss << (static_cast<double>(ms) * 1e-3);
-  return ss.str();
-}
-
-static bool PortableLocaltime(time_t seconds, struct tm* out) {
-#if defined(_MSC_VER)
-  return localtime_s(out, &seconds) == 0;
-#elif defined(__MINGW32__) || defined(__MINGW64__)
-  // 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 == NULL)
-    return false;
-  *out = *tm_ptr;
-  return true;
-#else
-  return localtime_r(&seconds, out) != NULL;
-#endif
-}
-
-// Converts the given epoch time in milliseconds to a date string in the ISO
-// 8601 format, without the timezone information.
-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
-  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);
-}
-
-// Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
-void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
-                                                     const char* data) {
-  const char* segment = data;
-  *stream << "<![CDATA[";
-  for (;;) {
-    const char* const next_segment = strstr(segment, "]]>");
-    if (next_segment != NULL) {
-      stream->write(
-          segment, static_cast<std::streamsize>(next_segment - segment));
-      *stream << "]]>]]&gt;<![CDATA[";
-      segment = next_segment + strlen("]]>");
-    } else {
-      *stream << segment;
-      break;
-    }
-  }
-  *stream << "]]>";
-}
-
-void XmlUnitTestResultPrinter::OutputXmlAttribute(
-    std::ostream* stream,
-    const std::string& element_name,
-    const std::string& name,
-    const std::string& value) {
-  const std::vector<std::string>& allowed_names =
-      GetReservedAttributesForElement(element_name);
-
-  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
-                   allowed_names.end())
-      << "Attribute " << name << " is not allowed for element <" << element_name
-      << ">.";
-
-  *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
-}
-
-// Prints an XML representation of a TestInfo object.
-// TODO(wan): There is also value in printing properties with the plain printer.
-void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
-                                                 const char* test_case_name,
-                                                 const TestInfo& test_info) {
-  const TestResult& result = *test_info.result();
-  const std::string kTestcase = "testcase";
-
-  *stream << "    <testcase";
-  OutputXmlAttribute(stream, kTestcase, "name", test_info.name());
-
-  if (test_info.value_param() != NULL) {
-    OutputXmlAttribute(stream, kTestcase, "value_param",
-                       test_info.value_param());
-  }
-  if (test_info.type_param() != NULL) {
-    OutputXmlAttribute(stream, kTestcase, "type_param", test_info.type_param());
-  }
-
-  OutputXmlAttribute(stream, kTestcase, "status",
-                     test_info.should_run() ? "run" : "notrun");
-  OutputXmlAttribute(stream, kTestcase, "time",
-                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
-  OutputXmlAttribute(stream, kTestcase, "classname", test_case_name);
-  *stream << TestPropertiesAsXmlAttributes(result);
-
-  int failures = 0;
-  for (int i = 0; i < result.total_part_count(); ++i) {
-    const TestPartResult& part = result.GetTestPartResult(i);
-    if (part.failed()) {
-      if (++failures == 1) {
-        *stream << ">\n";
-      }
-      const string location = internal::FormatCompilerIndependentFileLocation(
-          part.file_name(), part.line_number());
-      const string summary = location + "\n" + part.summary();
-      *stream << "      <failure message=\""
-              << EscapeXmlAttribute(summary.c_str())
-              << "\" type=\"\">";
-      const string detail = location + "\n" + part.message();
-      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
-      *stream << "</failure>\n";
-    }
-  }
-
-  if (failures == 0)
-    *stream << " />\n";
-  else
-    *stream << "    </testcase>\n";
-}
-
-// Prints an XML representation of a TestCase object
-void XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream,
-                                                const TestCase& test_case) {
-  const std::string kTestsuite = "testsuite";
-  *stream << "  <" << kTestsuite;
-  OutputXmlAttribute(stream, kTestsuite, "name", test_case.name());
-  OutputXmlAttribute(stream, kTestsuite, "tests",
-                     StreamableToString(test_case.reportable_test_count()));
-  OutputXmlAttribute(stream, kTestsuite, "failures",
-                     StreamableToString(test_case.failed_test_count()));
-  OutputXmlAttribute(
-      stream, kTestsuite, "disabled",
-      StreamableToString(test_case.reportable_disabled_test_count()));
-  OutputXmlAttribute(stream, kTestsuite, "errors", "0");
-  OutputXmlAttribute(stream, kTestsuite, "time",
-                     FormatTimeInMillisAsSeconds(test_case.elapsed_time()));
-  *stream << TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result())
-          << ">\n";
-
-  for (int i = 0; i < test_case.total_test_count(); ++i) {
-    if (test_case.GetTestInfo(i)->is_reportable())
-      OutputXmlTestInfo(stream, test_case.name(), *test_case.GetTestInfo(i));
-  }
-  *stream << "  </" << kTestsuite << ">\n";
-}
-
-// Prints an XML summary of unit_test to output stream out.
-void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
-                                                const UnitTest& unit_test) {
-  const std::string kTestsuites = "testsuites";
-
-  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-  *stream << "<" << kTestsuites;
-
-  OutputXmlAttribute(stream, kTestsuites, "tests",
-                     StreamableToString(unit_test.reportable_test_count()));
-  OutputXmlAttribute(stream, kTestsuites, "failures",
-                     StreamableToString(unit_test.failed_test_count()));
-  OutputXmlAttribute(
-      stream, kTestsuites, "disabled",
-      StreamableToString(unit_test.reportable_disabled_test_count()));
-  OutputXmlAttribute(stream, kTestsuites, "errors", "0");
-  OutputXmlAttribute(
-      stream, kTestsuites, "timestamp",
-      FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
-  OutputXmlAttribute(stream, kTestsuites, "time",
-                     FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
-
-  if (GTEST_FLAG(shuffle)) {
-    OutputXmlAttribute(stream, kTestsuites, "random_seed",
-                       StreamableToString(unit_test.random_seed()));
-  }
-
-  *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
-
-  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
-  *stream << ">\n";
-
-  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
-    if (unit_test.GetTestCase(i)->reportable_test_count() > 0)
-      PrintXmlTestCase(stream, *unit_test.GetTestCase(i));
-  }
-  *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(
-    const TestResult& result) {
-  Message attributes;
-  for (int i = 0; i < result.test_property_count(); ++i) {
-    const TestProperty& property = result.GetTestProperty(i);
-    attributes << " " << property.key() << "="
-        << "\"" << EscapeXmlAttribute(property.value()) << "\"";
-  }
-  return attributes.GetString();
-}
-
-// End XmlUnitTestResultPrinter
-
-#if GTEST_CAN_STREAM_RESULTS_
-
-// Checks if str contains '=', '&', '%' or '\n' characters. If yes,
-// replaces them by "%xx" where xx is their hexadecimal value. For
-// 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.
-string StreamingListener::UrlEncode(const char* str) {
-  string result;
-  result.reserve(strlen(str) + 1);
-  for (char ch = *str; ch != '\0'; ch = *++str) {
-    switch (ch) {
-      case '%':
-      case '=':
-      case '&':
-      case '\n':
-        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
-        break;
-      default:
-        result.push_back(ch);
-        break;
-    }
-  }
-  return result;
-}
-
-void StreamingListener::SocketWriter::MakeConnection() {
-  GTEST_CHECK_(sockfd_ == -1)
-      << "MakeConnection() can't be called when there is already a connection.";
-
-  addrinfo hints;
-  memset(&hints, 0, sizeof(hints));
-  hints.ai_family = AF_UNSPEC;    // To allow both IPv4 and IPv6 addresses.
-  hints.ai_socktype = SOCK_STREAM;
-  addrinfo* servinfo = NULL;
-
-  // Use the getaddrinfo() to get a linked list of IP addresses for
-  // the given host name.
-  const int error_num = getaddrinfo(
-      host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
-  if (error_num != 0) {
-    GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
-                        << gai_strerror(error_num);
-  }
-
-  // Loop through all the results and connect to the first we can.
-  for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL;
-       cur_addr = cur_addr->ai_next) {
-    sockfd_ = socket(
-        cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
-    if (sockfd_ != -1) {
-      // Connect the client socket to the server socket.
-      if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
-        close(sockfd_);
-        sockfd_ = -1;
-      }
-    }
-  }
-
-  freeaddrinfo(servinfo);  // all done with this structure
-
-  if (sockfd_ == -1) {
-    GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
-                        << host_name_ << ":" << port_num_;
-  }
-}
-
-// End of class Streaming Listener
-#endif  // GTEST_CAN_STREAM_RESULTS__
-
-// Class ScopedTrace
-
-// Pushes the given source file location and message onto a per-thread
-// trace stack maintained by Google Test.
-ScopedTrace::ScopedTrace(const char* file, int line, const Message& message)
-    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
-  TraceInfo trace;
-  trace.file = file;
-  trace.line = line;
-  trace.message = message.GetString();
-
-  UnitTest::GetInstance()->PushGTestTrace(trace);
-}
-
-// Pops the info pushed by the c'tor.
-ScopedTrace::~ScopedTrace()
-    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
-  UnitTest::GetInstance()->PopGTestTrace();
-}
-
-
-// class OsStackTraceGetter
-
-const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
-    "... " GTEST_NAME_ " internal frames ...";
-
-string OsStackTraceGetter::CurrentStackTrace(int /*max_depth*/,
-                                             int /*skip_count*/) {
-  return "";
-}
-
-void OsStackTraceGetter::UponLeavingGTest() {}
-
-// 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) {
-    // If a path to the premature-exit file is specified...
-    if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
-      // 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.
-      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
-      fwrite("0", 1, 1, pfile);
-      fclose(pfile);
-    }
-  }
-
-  ~ScopedPrematureExitFile() {
-    if (premature_exit_filepath_ != NULL && *premature_exit_filepath_ != '\0') {
-      remove(premature_exit_filepath_);
-    }
-  }
-
- private:
-  const char* const premature_exit_filepath_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
-};
-
-}  // namespace internal
-
-// class TestEventListeners
-
-TestEventListeners::TestEventListeners()
-    : repeater_(new internal::TestEventRepeater()),
-      default_result_printer_(NULL),
-      default_xml_generator_(NULL) {
-}
-
-TestEventListeners::~TestEventListeners() { delete repeater_; }
-
-// Returns the standard listener responsible for the default console
-// output.  Can be removed from the listeners list to shut down default
-// console output.  Note that removing this object from the listener list
-// with Release transfers its ownership to the user.
-void TestEventListeners::Append(TestEventListener* listener) {
-  repeater_->Append(listener);
-}
-
-// Removes the given event listener from the list and returns it.  It then
-// becomes the caller's responsibility to delete the listener. Returns
-// NULL if the listener is not found in the list.
-TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
-  if (listener == default_result_printer_)
-    default_result_printer_ = NULL;
-  else if (listener == default_xml_generator_)
-    default_xml_generator_ = NULL;
-  return repeater_->Release(listener);
-}
-
-// Returns repeater that broadcasts the TestEventListener events to all
-// subscribers.
-TestEventListener* TestEventListeners::repeater() { return repeater_; }
-
-// Sets the default_result_printer attribute to the provided listener.
-// The listener is also added to the listener list and previous
-// default_result_printer is removed from it and deleted. The listener can
-// also be NULL in which case it will not be added to the list. Does
-// nothing if the previous and the current listener objects are the same.
-void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
-  if (default_result_printer_ != listener) {
-    // It is an error to pass this method a listener that is already in the
-    // list.
-    delete Release(default_result_printer_);
-    default_result_printer_ = listener;
-    if (listener != NULL)
-      Append(listener);
-  }
-}
-
-// Sets the default_xml_generator attribute to the provided listener.  The
-// listener is also added to the listener list and previous
-// default_xml_generator is removed from it and deleted. The listener can
-// also be NULL in which case it will not be added to the list. Does
-// nothing if the previous and the current listener objects are the same.
-void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
-  if (default_xml_generator_ != listener) {
-    // It is an error to pass this method a listener that is already in the
-    // list.
-    delete Release(default_xml_generator_);
-    default_xml_generator_ = listener;
-    if (listener != NULL)
-      Append(listener);
-  }
-}
-
-// Controls whether events will be forwarded by the repeater to the
-// listeners in the list.
-bool TestEventListeners::EventForwardingEnabled() const {
-  return repeater_->forwarding_enabled();
-}
-
-void TestEventListeners::SuppressEventForwarding() {
-  repeater_->set_forwarding_enabled(false);
-}
-
-// class UnitTest
-
-// Gets the singleton UnitTest object.  The first time this method is
-// called, a UnitTest object is constructed and returned.  Consecutive
-// calls will return the same object.
-//
-// We don't protect this under mutex_ as a user is not supposed to
-// call this before main() starts, from which point on the return
-// value will never change.
-UnitTest* UnitTest::GetInstance() {
-  // When compiled with MSVC 7.1 in optimized mode, destroying the
-  // UnitTest object upon exiting the program messes up the exit code,
-  // causing successful tests to appear failed.  We have to use a
-  // different implementation in this case to bypass the compiler bug.
-  // This implementation makes the compiler happy, at the cost of
-  // leaking the UnitTest object.
-
-  // CodeGear C++Builder insists on a public destructor for the
-  // default implementation.  Use this implementation to keep good OO
-  // design with private destructor.
-
-#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
-  static UnitTest* const instance = new UnitTest;
-  return instance;
-#else
-  static UnitTest instance;
-  return &instance;
-#endif  // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
-}
-
-// Gets the number of successful test cases.
-int UnitTest::successful_test_case_count() const {
-  return impl()->successful_test_case_count();
-}
-
-// Gets the number of failed test cases.
-int UnitTest::failed_test_case_count() const {
-  return impl()->failed_test_case_count();
-}
-
-// Gets the number of all test cases.
-int UnitTest::total_test_case_count() const {
-  return impl()->total_test_case_count();
-}
-
-// Gets the number of all test cases that contain at least one test
-// that should run.
-int UnitTest::test_case_to_run_count() const {
-  return impl()->test_case_to_run_count();
-}
-
-// Gets the number of successful tests.
-int UnitTest::successful_test_count() const {
-  return impl()->successful_test_count();
-}
-
-// Gets the number of failed tests.
-int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
-
-// Gets the number of disabled tests that will be reported in the XML report.
-int UnitTest::reportable_disabled_test_count() const {
-  return impl()->reportable_disabled_test_count();
-}
-
-// Gets the number of disabled tests.
-int UnitTest::disabled_test_count() const {
-  return impl()->disabled_test_count();
-}
-
-// Gets the number of tests to be printed in the XML report.
-int UnitTest::reportable_test_count() const {
-  return impl()->reportable_test_count();
-}
-
-// Gets the number of all tests.
-int UnitTest::total_test_count() const { return impl()->total_test_count(); }
-
-// Gets the number of tests that should run.
-int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
-
-// Gets the time of the test program start, in ms from the start of the
-// UNIX epoch.
-internal::TimeInMillis UnitTest::start_timestamp() const {
-    return impl()->start_timestamp();
-}
-
-// Gets the elapsed time, in milliseconds.
-internal::TimeInMillis UnitTest::elapsed_time() const {
-  return impl()->elapsed_time();
-}
-
-// Returns true iff the unit test passed (i.e. all test cases passed).
-bool UnitTest::Passed() const { return impl()->Passed(); }
-
-// Returns true iff the unit test failed (i.e. some test case failed
-// or something outside of all tests failed).
-bool UnitTest::Failed() const { return impl()->Failed(); }
-
-// Gets the i-th test case among all the test cases. i can range from 0 to
-// total_test_case_count() - 1. If i is not in that range, returns NULL.
-const TestCase* UnitTest::GetTestCase(int i) const {
-  return impl()->GetTestCase(i);
-}
-
-// Returns the TestResult containing information on test failures and
-// properties logged outside of individual test cases.
-const TestResult& UnitTest::ad_hoc_test_result() const {
-  return *impl()->ad_hoc_test_result();
-}
-
-// Gets the i-th test case among all the test cases. i can range from 0 to
-// total_test_case_count() - 1. If i is not in that range, returns NULL.
-TestCase* UnitTest::GetMutableTestCase(int i) {
-  return impl()->GetMutableTestCase(i);
-}
-
-// Returns the list of event listeners that can be used to track events
-// inside Google Test.
-TestEventListeners& UnitTest::listeners() {
-  return *impl()->listeners();
-}
-
-// Registers and returns a global test environment.  When a test
-// program is run, all global test environments will be set-up in the
-// order they were registered.  After all tests in the program have
-// finished, all global test environments will be torn-down in the
-// *reverse* order they were registered.
-//
-// The UnitTest object takes ownership of the given environment.
-//
-// We don't protect this under mutex_, as we only support calling it
-// from the main thread.
-Environment* UnitTest::AddEnvironment(Environment* env) {
-  if (env == NULL) {
-    return NULL;
-  }
-
-  impl_->environments().push_back(env);
-  return env;
-}
-
-// Adds a TestPartResult to the current TestResult object.  All Google Test
-// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
-// this to report their results.  The user code should use the
-// assertion macros instead of calling this directly.
-void UnitTest::AddTestPartResult(
-    TestPartResult::Type result_type,
-    const char* file_name,
-    int line_number,
-    const std::string& message,
-    const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
-  Message msg;
-  msg << message;
-
-  internal::MutexLock lock(&mutex_);
-  if (impl_->gtest_trace_stack().size() > 0) {
-    msg << "\n" << GTEST_NAME_ << " trace:";
-
-    for (int i = static_cast<int>(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() != NULL && !os_stack_trace.empty()) {
-    msg << internal::kStackTraceMarker << os_stack_trace;
-  }
-
-  const TestPartResult result =
-    TestPartResult(result_type, file_name, line_number,
-                   msg.GetString().c_str());
-  impl_->GetTestPartResultReporterForCurrentThread()->
-      ReportTestPartResult(result);
-
-  if (result_type != TestPartResult::kSuccess) {
-    // 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
-    // with another testing framework) and specify the former on the
-    // command line for debugging.
-    if (GTEST_FLAG(break_on_failure)) {
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-      // Using DebugBreak on Windows allows gtest to still break into a debugger
-      // when a failure happens and both the --gtest_break_on_failure and
-      // the --gtest_catch_exceptions flags are specified.
-      DebugBreak();
-#else
-      // Dereference NULL through a volatile pointer to prevent the compiler
-      // from removing. We use this rather than abort() or __builtin_trap() for
-      // portability: Symbian doesn't implement abort() well, and some debuggers
-      // don't correctly trap abort().
-      *static_cast<volatile int*>(NULL) = 1;
-#endif  // GTEST_OS_WINDOWS
-    } else if (GTEST_FLAG(throw_on_failure)) {
-#if GTEST_HAS_EXCEPTIONS
-      throw internal::GoogleTestFailureException(result);
-#else
-      // We cannot call abort() as it generates a pop-up in debug mode
-      // that cannot be suppressed in VC 7.1 or below.
-      exit(1);
-#endif
-    }
-  }
-}
-
-// Adds a TestProperty to the current TestResult object when invoked from
-// inside a test, to current TestCase's ad_hoc_test_result_ when invoked
-// from SetUpTestCase or TearDownTestCase, 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,
-                              const std::string& value) {
-  impl_->RecordProperty(TestProperty(key, value));
-}
-
-// Runs all tests in this UnitTest object and prints the result.
-// Returns 0 if successful, or 1 otherwise.
-//
-// We don't protect this under mutex_, as we only support calling it
-// from the main thread.
-int UnitTest::Run() {
-  const bool in_death_test_child_process =
-      internal::GTEST_FLAG(internal_run_death_test).length() > 0;
-
-  // Google Test implements this protocol for catching that a test
-  // program exits before returning control to Google Test:
-  //
-  //   1. Upon start, Google Test creates a file whose absolute path
-  //      is specified by the environment variable
-  //      TEST_PREMATURE_EXIT_FILE.
-  //   2. When Google Test has finished its work, it deletes the file.
-  //
-  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
-  // running a Google-Test-based test program and check the existence
-  // of the file at the end of the test execution to see if it has
-  // exited prematurely.
-
-  // If we are in the child process of a death test, don't
-  // create/delete the premature exit file, as doing so is unnecessary
-  // and will confuse the parent process.  Otherwise, create/delete
-  // the file upon entering/leaving this function.  If the program
-  // somehow exits before this function has a chance to return, the
-  // premature-exit file will be left undeleted, causing a test runner
-  // 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 ?
-      NULL : 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_HAS_SEH
-  // 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
-  // about crashes - they are expected.
-  if (impl()->catch_exceptions() || in_death_test_child_process) {
-# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-    // SetErrorMode doesn't exist on CE.
-    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
-                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
-# endif  // !GTEST_OS_WINDOWS_MOBILE
-
-# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
-    // Death test children can be terminated with _abort().  On Windows,
-    // _abort() can show a dialog with a warning message.  This forces the
-    // abort message to go to stderr instead.
-    _set_error_mode(_OUT_TO_STDERR);
-# endif
-
-# if _MSC_VER >= 1400 && !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
-    // executed. Google Test will notify the user of any unexpected
-    // failure via stderr.
-    //
-    // VC++ doesn't define _set_abort_behavior() prior to the version 8.0.
-    // Users of prior VC versions shall suffer the agony and pain of
-    // clicking through the countless debug dialogs.
-    // TODO(vladl@google.com): find a way to suppress the abort dialog() in the
-    // debug mode when compiled with VC 7.1 or lower.
-    if (!GTEST_FLAG(break_on_failure))
-      _set_abort_behavior(
-          0x0,                                    // Clear the following flags:
-          _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
-# endif
-  }
-#endif  // GTEST_HAS_SEH
-
-  return internal::HandleExceptionsInMethodIfSupported(
-      impl(),
-      &internal::UnitTestImpl::RunAllTests,
-      "auxiliary test code (environments or event listeners)") ? 0 : 1;
-}
-
-// Returns the working directory when the first TEST() or TEST_F() was
-// executed.
-const char* UnitTest::original_working_dir() const {
-  return impl_->original_working_dir_.c_str();
-}
-
-// Returns the TestCase object for the test that's currently running,
-// or NULL if no test is running.
-const TestCase* UnitTest::current_test_case() const
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  return impl_->current_test_case();
-}
-
-// Returns the TestInfo object for the test that's currently running,
-// or NULL if no test is running.
-const TestInfo* UnitTest::current_test_info() const
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  return impl_->current_test_info();
-}
-
-// Returns the random seed used at the start of the current test run.
-int UnitTest::random_seed() const { return impl_->random_seed(); }
-
-#if GTEST_HAS_PARAM_TEST
-// Returns ParameterizedTestCaseRegistry object used to keep track of
-// value-parameterized tests and instantiate and register them.
-internal::ParameterizedTestCaseRegistry&
-    UnitTest::parameterized_test_registry()
-        GTEST_LOCK_EXCLUDED_(mutex_) {
-  return impl_->parameterized_test_registry();
-}
-#endif  // GTEST_HAS_PARAM_TEST
-
-// Creates an empty UnitTest.
-UnitTest::UnitTest() {
-  impl_ = new internal::UnitTestImpl(this);
-}
-
-// Destructor of UnitTest.
-UnitTest::~UnitTest() {
-  delete impl_;
-}
-
-// Pushes a trace defined by SCOPED_TRACE() on to the per-thread
-// Google Test trace stack.
-void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  impl_->gtest_trace_stack().push_back(trace);
-}
-
-// Pops a trace from the per-thread Google Test trace stack.
-void UnitTest::PopGTestTrace()
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  impl_->gtest_trace_stack().pop_back();
-}
-
-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_per_thread_test_part_result_reporter_(this),
-      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_),
-#if GTEST_HAS_PARAM_TEST
-      parameterized_test_registry_(),
-      parameterized_tests_registered_(false),
-#endif  // GTEST_HAS_PARAM_TEST
-      last_death_test_case_(-1),
-      current_test_case_(NULL),
-      current_test_info_(NULL),
-      ad_hoc_test_result_(),
-      os_stack_trace_getter_(NULL),
-      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.
-      start_timestamp_(0),
-      elapsed_time_(0),
-#if GTEST_HAS_DEATH_TEST
-      death_test_factory_(new DefaultDeathTestFactory),
-#endif
-      // Will be overridden by the flag before first use.
-      catch_exceptions_(false) {
-  listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
-}
-
-UnitTestImpl::~UnitTestImpl() {
-  // Deletes every TestCase.
-  ForEach(test_cases_, internal::Delete<TestCase>);
-
-  // Deletes every Environment.
-  ForEach(environments_, internal::Delete<Environment>);
-
-  delete os_stack_trace_getter_;
-}
-
-// Adds a TestProperty to the current TestResult object when invoked in a
-// context of a test, to current test case's ad_hoc_test_result when invoke
-// from SetUpTestCase/TearDownTestCase, 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_ != NULL) {
-    xml_element = "testcase";
-    test_result = &(current_test_info_->result_);
-  } else if (current_test_case_ != NULL) {
-    xml_element = "testsuite";
-    test_result = &(current_test_case_->ad_hoc_test_result_);
-  } else {
-    xml_element = "testsuites";
-    test_result = &ad_hoc_test_result_;
-  }
-  test_result->RecordProperty(xml_element, test_property);
-}
-
-#if GTEST_HAS_DEATH_TEST
-// 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() != NULL)
-    listeners()->SuppressEventForwarding();
-}
-#endif  // GTEST_HAS_DEATH_TEST
-
-// Initializes event listeners performing XML output as specified by
-// UnitTestOptions. Must not be called before InitGoogleTest.
-void UnitTestImpl::ConfigureXmlOutput() {
-  const std::string& output_format = UnitTestOptions::GetOutputFormat();
-  if (output_format == "xml") {
-    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
-        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
-  } else if (output_format != "") {
-    printf("WARNING: unrecognized output format \"%s\" ignored.\n",
-           output_format.c_str());
-    fflush(stdout);
-  }
-}
-
-#if GTEST_CAN_STREAM_RESULTS_
-// Initializes event listeners for streaming test results in string form.
-// Must not be called before InitGoogleTest.
-void UnitTestImpl::ConfigureStreamingOutput() {
-  const std::string& target = GTEST_FLAG(stream_result_to);
-  if (!target.empty()) {
-    const size_t pos = target.find(':');
-    if (pos != std::string::npos) {
-      listeners()->Append(new StreamingListener(target.substr(0, pos),
-                                                target.substr(pos+1)));
-    } else {
-      printf("WARNING: unrecognized streaming target \"%s\" ignored.\n",
-             target.c_str());
-      fflush(stdout);
-    }
-  }
-}
-#endif  // GTEST_CAN_STREAM_RESULTS_
-
-// Performs initialization dependent upon flag values obtained in
-// ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
-// ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
-// this function is also called from RunAllTests.  Since this function can be
-// called more than once, it has to be idempotent.
-void UnitTestImpl::PostFlagParsingInit() {
-  // Ensures that this function does not execute more than once.
-  if (!post_flag_parse_init_performed_) {
-    post_flag_parse_init_performed_ = true;
-
-#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
-    // Register to send notifications about key process state changes.
-    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
-#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
-
-#if GTEST_HAS_DEATH_TEST
-    InitDeathTestSubprocessControlInfo();
-    SuppressTestEventsIfInSubprocess();
-#endif  // GTEST_HAS_DEATH_TEST
-
-    // Registers parameterized tests. This makes parameterized tests
-    // available to the UnitTest reflection API without running
-    // RUN_ALL_TESTS.
-    RegisterParameterizedTests();
-
-    // Configures listeners for XML output. This makes it possible for users
-    // to shut down the default XML output before invoking RUN_ALL_TESTS.
-    ConfigureXmlOutput();
-
-#if GTEST_CAN_STREAM_RESULTS_
-    // Configures listeners for streaming test results to the specified server.
-    ConfigureStreamingOutput();
-#endif  // GTEST_CAN_STREAM_RESULTS_
-  }
-}
-
-// A predicate that checks the name of a TestCase 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.
-//
-// TestCaseNameIs is copyable.
-class TestCaseNameIs {
- public:
-  // Constructor.
-  explicit TestCaseNameIs(const std::string& name)
-      : name_(name) {}
-
-  // Returns true iff the name of test_case matches name_.
-  bool operator()(const TestCase* test_case) const {
-    return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0;
-  }
-
- private:
-  std::string name_;
-};
-
-// Finds and returns a TestCase 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_case_name: name of the test case
-//   type_param:     the name of the test case's type parameter, or NULL if
-//                   this is not a typed or a type-parameterized test case.
-//   set_up_tc:      pointer to the function that sets up the test case
-//   tear_down_tc:   pointer to the function that tears down the test case
-TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
-                                    const char* type_param,
-                                    Test::SetUpTestCaseFunc set_up_tc,
-                                    Test::TearDownTestCaseFunc tear_down_tc) {
-  // Can we find a TestCase with the given name?
-  const std::vector<TestCase*>::const_iterator test_case =
-      std::find_if(test_cases_.begin(), test_cases_.end(),
-                   TestCaseNameIs(test_case_name));
-
-  if (test_case != test_cases_.end())
-    return *test_case;
-
-  // No.  Let's create one.
-  TestCase* const new_test_case =
-      new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc);
-
-  // Is this a death test case?
-  if (internal::UnitTestOptions::MatchesFilter(test_case_name,
-                                               kDeathTestCaseFilter)) {
-    // Yes.  Inserts the test case after the last death test case
-    // defined so far.  This only works when the test cases haven't
-    // been shuffled.  Otherwise we may end up running a death test
-    // after a non-death test.
-    ++last_death_test_case_;
-    test_cases_.insert(test_cases_.begin() + last_death_test_case_,
-                       new_test_case);
-  } else {
-    // No.  Appends to the end of the list.
-    test_cases_.push_back(new_test_case);
-  }
-
-  test_case_indices_.push_back(static_cast<int>(test_case_indices_.size()));
-  return new_test_case;
-}
-
-// Helpers for setting up / tearing down the given environment.  They
-// are for use in the ForEach() function.
-static void SetUpEnvironment(Environment* env) { env->SetUp(); }
-static void TearDownEnvironment(Environment* env) { env->TearDown(); }
-
-// Runs all tests in this UnitTest object, prints the result, and
-// returns true if all tests are successful.  If any exception is
-// thrown during a test, the test is considered to be failed, but the
-// rest of the tests will still be run.
-//
-// When parameterized tests are enabled, it expands and registers
-// parameterized tests first in RegisterParameterizedTests().
-// All other functions called from RunAllTests() may safely assume that
-// parameterized tests are ready to be counted and run.
-bool UnitTestImpl::RunAllTests() {
-  // Makes sure InitGoogleTest() was called.
-  if (!GTestIsInitialized()) {
-    printf("%s",
-           "\nThis test program did NOT call ::testing::InitGoogleTest "
-           "before calling RUN_ALL_TESTS().  Please fix it.\n");
-    return false;
-  }
-
-  // Do not run any test if the --help flag was specified.
-  if (g_help_flag)
-    return true;
-
-  // Repeats the call to the post-flag parsing initialization in case the
-  // user didn't call InitGoogleTest.
-  PostFlagParsingInit();
-
-  // Even if sharding is not on, test runners may want to use the
-  // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
-  // protocol.
-  internal::WriteToShardStatusFileIfNeeded();
-
-  // True iff 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() != NULL);
-# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
-  if (in_subprocess_for_death_test) {
-    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
-  }
-# endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
-#endif  // GTEST_HAS_DEATH_TEST
-
-  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
-                                        in_subprocess_for_death_test);
-
-  // Compares the full test names with the filter to decide which
-  // tests to run.
-  const bool has_tests_to_run = FilterTests(should_shard
-                                              ? HONOR_SHARDING_PROTOCOL
-                                              : IGNORE_SHARDING_PROTOCOL) > 0;
-
-  // Lists the tests and exits if the --gtest_list_tests flag was specified.
-  if (GTEST_FLAG(list_tests)) {
-    // This must be called *after* FilterTests() has been called.
-    ListTestsMatchingFilter();
-    return true;
-  }
-
-  random_seed_ = GTEST_FLAG(shuffle) ?
-      GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
-
-  // True iff at least one test has failed.
-  bool failed = false;
-
-  TestEventListener* repeater = listeners()->repeater();
-
-  start_timestamp_ = GetTimeInMillis();
-  repeater->OnTestProgramStart(*parent_);
-
-  // How many times to repeat the tests?  We don't want to repeat them
-  // 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 forever = repeat < 0;
-  for (int i = 0; forever || i != repeat; i++) {
-    // We want to preserve failures generated by ad-hoc test
-    // assertions executed before RUN_ALL_TESTS().
-    ClearNonAdHocTestResult();
-
-    const TimeInMillis start = GetTimeInMillis();
-
-    // Shuffles test cases and tests if requested.
-    if (has_tests_to_run && GTEST_FLAG(shuffle)) {
-      random()->Reseed(random_seed_);
-      // This should be done before calling OnTestIterationStart(),
-      // such that a test event listener can see the actual test order
-      // in the event.
-      ShuffleTests();
-    }
-
-    // Tells the unit test event listeners that the tests are about to start.
-    repeater->OnTestIterationStart(*parent_, i);
-
-    // Runs each test case 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 during global
-      // set-up.
-      if (!Test::HasFatalFailure()) {
-        for (int test_index = 0; test_index < total_test_case_count();
-             test_index++) {
-          GetMutableTestCase(test_index)->Run();
-        }
-      }
-
-      // Tears down all environments in reverse order afterwards.
-      repeater->OnEnvironmentsTearDownStart(*parent_);
-      std::for_each(environments_.rbegin(), environments_.rend(),
-                    TearDownEnvironment);
-      repeater->OnEnvironmentsTearDownEnd(*parent_);
-    }
-
-    elapsed_time_ = GetTimeInMillis() - start;
-
-    // Tells the unit test event listener that the tests have just finished.
-    repeater->OnTestIterationEnd(*parent_, i);
-
-    // Gets the result and clears it.
-    if (!Passed()) {
-      failed = true;
-    }
-
-    // Restores the original test order after the iteration.  This
-    // allows the user to quickly repro a failure that happens in the
-    // N-th iteration without repeating the first (N - 1) iterations.
-    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
-    // case the user somehow changes the value of the flag somewhere
-    // (it's always safe to unshuffle the tests).
-    UnshuffleTests();
-
-    if (GTEST_FLAG(shuffle)) {
-      // Picks a new random seed for each iteration.
-      random_seed_ = GetNextRandomSeed(random_seed_);
-    }
-  }
-
-  repeater->OnTestProgramEnd(*parent_);
-
-  return !failed;
-}
-
-// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
-// if the variable is present. If a file already exists at this location, this
-// function will write over it. If the variable is present, but the file cannot
-// be created, prints an error and exits.
-void WriteToShardStatusFileIfNeeded() {
-  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
-  if (test_shard_file != NULL) {
-    FILE* const file = posix::FOpen(test_shard_file, "w");
-    if (file == NULL) {
-      ColoredPrintf(COLOR_RED,
-                    "Could not write to the test shard status file \"%s\" "
-                    "specified by the %s environment variable.\n",
-                    test_shard_file, kTestShardStatusFile);
-      fflush(stdout);
-      exit(EXIT_FAILURE);
-    }
-    fclose(file);
-  }
-}
-
-// Checks whether sharding is enabled by examining the relevant
-// environment variable values. If the variables are present,
-// but inconsistent (i.e., shard_index >= total_shards), prints
-// an error and exits. If in_subprocess_for_death_test, sharding is
-// disabled because it must only be applied to the original test
-// process. Otherwise, we could filter out death tests we intended to execute.
-bool ShouldShard(const char* total_shards_env,
-                 const char* shard_index_env,
-                 bool in_subprocess_for_death_test) {
-  if (in_subprocess_for_death_test) {
-    return false;
-  }
-
-  const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1);
-  const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1);
-
-  if (total_shards == -1 && shard_index == -1) {
-    return false;
-  } else if (total_shards == -1 && shard_index != -1) {
-    const Message msg = Message()
-      << "Invalid environment variables: you have "
-      << kTestShardIndex << " = " << shard_index
-      << ", but have left " << kTestTotalShards << " unset.\n";
-    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
-    fflush(stdout);
-    exit(EXIT_FAILURE);
-  } else if (total_shards != -1 && shard_index == -1) {
-    const Message msg = Message()
-      << "Invalid environment variables: you have "
-      << kTestTotalShards << " = " << total_shards
-      << ", but have left " << kTestShardIndex << " unset.\n";
-    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
-    fflush(stdout);
-    exit(EXIT_FAILURE);
-  } else if (shard_index < 0 || shard_index >= total_shards) {
-    const Message msg = Message()
-      << "Invalid environment variables: we require 0 <= "
-      << kTestShardIndex << " < " << kTestTotalShards
-      << ", but you have " << kTestShardIndex << "=" << shard_index
-      << ", " << kTestTotalShards << "=" << total_shards << ".\n";
-    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
-    fflush(stdout);
-    exit(EXIT_FAILURE);
-  }
-
-  return total_shards > 1;
-}
-
-// 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 Int32FromEnvOrDie(const char* var, Int32 default_val) {
-  const char* str_val = posix::GetEnv(var);
-  if (str_val == NULL) {
-    return default_val;
-  }
-
-  Int32 result;
-  if (!ParseInt32(Message() << "The value of environment variable " << var,
-                  str_val, &result)) {
-    exit(EXIT_FAILURE);
-  }
-  return result;
-}
-
-// Given the total number of shards, the shard index, and the test id,
-// returns true iff 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;
-}
-
-// 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 TestCase and TestInfo object.
-// If shard_tests == true, further filters tests based on sharding
-// variables in the environment - see
-// http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide.
-// Returns the number of tests that should run.
-int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
-  const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
-      Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
-  const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
-      Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
-
-  // num_runnable_tests are the number of tests that will
-  // run across all shards (i.e., match filter and are not disabled).
-  // num_selected_tests are the number of tests to be run on
-  // this shard.
-  int num_runnable_tests = 0;
-  int num_selected_tests = 0;
-  for (size_t i = 0; i < test_cases_.size(); i++) {
-    TestCase* const test_case = test_cases_[i];
-    const std::string &test_case_name = test_case->name();
-    test_case->set_should_run(false);
-
-    for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
-      TestInfo* const test_info = test_case->test_info_list()[j];
-      const std::string test_name(test_info->name());
-      // A test is disabled if test case name or test name matches
-      // kDisableTestFilter.
-      const bool is_disabled =
-          internal::UnitTestOptions::MatchesFilter(test_case_name,
-                                                   kDisableTestFilter) ||
-          internal::UnitTestOptions::MatchesFilter(test_name,
-                                                   kDisableTestFilter);
-      test_info->is_disabled_ = is_disabled;
-
-      const bool matches_filter =
-          internal::UnitTestOptions::FilterMatchesTest(test_case_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_selected = is_runnable &&
-          (shard_tests == IGNORE_SHARDING_PROTOCOL ||
-           ShouldRunTestOnShard(total_shards, shard_index,
-                                num_runnable_tests));
-
-      num_runnable_tests += is_runnable;
-      num_selected_tests += is_selected;
-
-      test_info->should_run_ = is_selected;
-      test_case->set_should_run(test_case->should_run() || is_selected);
-    }
-  }
-  return num_selected_tests;
-}
-
-// Prints the given C-string on a single line by replacing all '\n'
-// characters with string "\\n".  If the output takes more than
-// max_length characters, only prints the first max_length characters
-// and "...".
-static void PrintOnOneLine(const char* str, int max_length) {
-  if (str != NULL) {
-    for (int i = 0; *str != '\0'; ++str) {
-      if (i >= max_length) {
-        printf("...");
-        break;
-      }
-      if (*str == '\n') {
-        printf("\\n");
-        i += 2;
-      } else {
-        printf("%c", *str);
-        ++i;
-      }
-    }
-  }
-}
-
-// Prints the names of the tests matching the user-specified filter flag.
-void UnitTestImpl::ListTestsMatchingFilter() {
-  // Print at most this many characters for each type/value parameter.
-  const int kMaxParamLength = 250;
-
-  for (size_t i = 0; i < test_cases_.size(); i++) {
-    const TestCase* const test_case = test_cases_[i];
-    bool printed_test_case_name = false;
-
-    for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
-      const TestInfo* const test_info =
-          test_case->test_info_list()[j];
-      if (test_info->matches_filter_) {
-        if (!printed_test_case_name) {
-          printed_test_case_name = true;
-          printf("%s.", test_case->name());
-          if (test_case->type_param() != NULL) {
-            printf("  # %s = ", kTypeParamLabel);
-            // We print the type parameter on a single line to make
-            // the output easy to parse by a program.
-            PrintOnOneLine(test_case->type_param(), kMaxParamLength);
-          }
-          printf("\n");
-        }
-        printf("  %s", test_info->name());
-        if (test_info->value_param() != NULL) {
-          printf("  # %s = ", kValueParamLabel);
-          // We print the value parameter on a single line to make the
-          // output easy to parse by a program.
-          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
-        }
-        printf("\n");
-      }
-    }
-  }
-  fflush(stdout);
-}
-
-// Sets the OS stack trace getter.
-//
-// Does nothing if the input and the current OS stack trace getter are
-// the same; otherwise, deletes the old getter and makes the input the
-// current getter.
-void UnitTestImpl::set_os_stack_trace_getter(
-    OsStackTraceGetterInterface* getter) {
-  if (os_stack_trace_getter_ != getter) {
-    delete os_stack_trace_getter_;
-    os_stack_trace_getter_ = getter;
-  }
-}
-
-// Returns the current OS stack trace getter if it is not NULL;
-// otherwise, creates an OsStackTraceGetter, makes it the current
-// getter, and returns it.
-OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
-  if (os_stack_trace_getter_ == NULL) {
-#ifdef GTEST_OS_STACK_TRACE_GETTER_
-    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
-#else
-    os_stack_trace_getter_ = new OsStackTraceGetter;
-#endif  // GTEST_OS_STACK_TRACE_GETTER_
-  }
-
-  return os_stack_trace_getter_;
-}
-
-// Returns the TestResult for the test that's currently running, or
-// the TestResult for the ad hoc test if no test is running.
-TestResult* UnitTestImpl::current_test_result() {
-  return current_test_info_ ?
-      &(current_test_info_->result_) : &ad_hoc_test_result_;
-}
-
-// Shuffles all test cases, and the tests within each test case,
-// making sure that death tests are still run first.
-void UnitTestImpl::ShuffleTests() {
-  // Shuffles the death test cases.
-  ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_);
-
-  // Shuffles the non-death test cases.
-  ShuffleRange(random(), last_death_test_case_ + 1,
-               static_cast<int>(test_cases_.size()), &test_case_indices_);
-
-  // Shuffles the tests inside each test case.
-  for (size_t i = 0; i < test_cases_.size(); i++) {
-    test_cases_[i]->ShuffleTests(random());
-  }
-}
-
-// Restores the test cases and tests to their order before the first shuffle.
-void UnitTestImpl::UnshuffleTests() {
-  for (size_t i = 0; i < test_cases_.size(); i++) {
-    // Unshuffles the tests in each test case.
-    test_cases_[i]->UnshuffleTests();
-    // Resets the index of each test case.
-    test_case_indices_[i] = static_cast<int>(i);
-  }
-}
-
-// Returns the current OS stack trace as an std::string.
-//
-// The maximum number of stack frames to be included is specified by
-// the gtest_stack_trace_depth flag.  The skip_count parameter
-// specifies the number of top frames to be skipped, which doesn't
-// count against the number of frames to be included.
-//
-// For example, if Foo() calls Bar(), which in turn calls
-// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
-// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
-std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
-                                            int skip_count) {
-  // We pass skip_count + 1 to skip this wrapper function in addition
-  // to what the user really wants to skip.
-  return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
-}
-
-// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to
-// suppress unreachable code warnings.
-namespace {
-class ClassUniqueToAlwaysTrue {};
-}
-
-bool IsTrue(bool condition) { return condition; }
-
-bool AlwaysTrue() {
-#if GTEST_HAS_EXCEPTIONS
-  // This condition is always false so AlwaysTrue() never actually throws,
-  // but it makes the compiler think that it may throw.
-  if (IsTrue(false))
-    throw ClassUniqueToAlwaysTrue();
-#endif  // GTEST_HAS_EXCEPTIONS
-  return true;
-}
-
-// 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.
-bool SkipPrefix(const char* prefix, const char** pstr) {
-  const size_t prefix_len = strlen(prefix);
-  if (strncmp(*pstr, prefix, prefix_len) == 0) {
-    *pstr += prefix_len;
-    return true;
-  }
-  return false;
-}
-
-// Parses a string as a command line flag.  The string should have
-// the format "--flag=value".  When def_optional is true, the "=value"
-// part can be omitted.
-//
-// Returns the value of the flag, or NULL if the parsing failed.
-const char* ParseFlagValue(const char* str,
-                           const char* flag,
-                           bool def_optional) {
-  // str and flag must not be NULL.
-  if (str == NULL || flag == NULL) return NULL;
-
-  // 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 NULL;
-
-  // Skips the flag name.
-  const char* flag_end = str + flag_len;
-
-  // When def_optional is true, it's OK to not have a "=value" part.
-  if (def_optional && (flag_end[0] == '\0')) {
-    return flag_end;
-  }
-
-  // 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 NULL;
-
-  // Returns the string after "=".
-  return flag_end + 1;
-}
-
-// Parses a string for a bool flag, in the form of either
-// "--flag=value" or "--flag".
-//
-// In the former case, the value is taken as true as long as it does
-// not start with '0', 'f', or 'F'.
-//
-// In the latter case, the value is taken as true.
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-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 == NULL) 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 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* 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 == NULL) 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".
-//
-// On success, stores the value of the flag in *value, and returns
-// true.  On failure, returns false without changing *value.
-bool ParseStringFlag(const char* str, const char* flag, std::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 == NULL) return false;
-
-  // Sets *value to the value of the flag.
-  *value = value_str;
-  return true;
-}
-
-// Determines whether a string has a prefix that Google Test uses for its
-// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_.
-// If Google Test detects that a command line flag has its prefix but is not
-// recognized, it will print its help message. Flags starting with
-// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test
-// internal flags and do not trigger the help message.
-static bool HasGoogleTestFlagPrefix(const char* str) {
-  return (SkipPrefix("--", &str) ||
-          SkipPrefix("-", &str) ||
-          SkipPrefix("/", &str)) &&
-         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
-         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
-          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
-}
-
-// Prints a string containing code-encoded text.  The following escape
-// sequences can be used in the string to control the text color:
-//
-//   @@    prints a single '@' character.
-//   @R    changes the color to red.
-//   @G    changes the color to green.
-//   @Y    changes the color to yellow.
-//   @D    changes to the default terminal text color.
-//
-// TODO(wan@google.com): Write tests for this once we add stdout
-// capturing to Google Test.
-static void PrintColorEncoded(const char* str) {
-  GTestColor color = COLOR_DEFAULT;  // 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
-  // each iteration, the str pointer advances to the beginning of the
-  // next segment.
-  for (;;) {
-    const char* p = strchr(str, '@');
-    if (p == NULL) {
-      ColoredPrintf(color, "%s", str);
-      return;
-    }
-
-    ColoredPrintf(color, "%s", std::string(str, p).c_str());
-
-    const char ch = p[1];
-    str = p + 2;
-    if (ch == '@') {
-      ColoredPrintf(color, "@");
-    } else if (ch == 'D') {
-      color = COLOR_DEFAULT;
-    } else if (ch == 'R') {
-      color = COLOR_RED;
-    } else if (ch == 'G') {
-      color = COLOR_GREEN;
-    } else if (ch == 'Y') {
-      color = COLOR_YELLOW;
-    } else {
-      --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=@YPOSTIVE_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_ "print_time=0@D\n"
-"      Don't print the elapsed time of each test.\n"
-"  @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G"
-    GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n"
-"      Generate an XML report in the given directory or with the given file\n"
-"      name. @YFILE_PATH@D defaults to @Gtest_details.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.\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_
-    "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";
-
-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)) ||
-      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, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
-      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_
-void LoadFlagsFromFile(const std::string& path) {
-  FILE* flagfile = posix::FOpen(path.c_str(), "r");
-  if (!flagfile) {
-    fprintf(stderr,
-            "Unable to open file \"%s\"\n",
-            GTEST_FLAG(flagfile).c_str());
-    fflush(stderr);
-    exit(EXIT_FAILURE);
-  }
-  std::string contents(ReadEntireFile(flagfile));
-  posix::FClose(flagfile);
-  std::vector<std::string> lines;
-  SplitString(contents, '\n', &lines);
-  for (size_t i = 0; i < lines.size(); ++i) {
-    if (lines[i].empty())
-      continue;
-    if (!ParseGoogleTestFlag(lines[i].c_str()))
-      g_help_flag = true;
-  }
-}
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
-
-// Parses the command line for Google Test flags, without initializing
-// other parts of Google Test.  The type parameter CharType can be
-// instantiated to either char or wchar_t.
-template <typename CharType>
-void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
-  for (int i = 1; i < *argc; i++) {
-    const std::string arg_string = StreamableToString(argv[i]);
-    const char* const arg = arg_string.c_str();
-
-    using internal::ParseBoolFlag;
-    using internal::ParseInt32Flag;
-    using internal::ParseStringFlag;
-
-    bool remove_flag = false;
-    if (ParseGoogleTestFlag(arg)) {
-      remove_flag = true;
-#if GTEST_USE_OWN_FLAGFILE_FLAG_
-    } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) {
-      LoadFlagsFromFile(GTEST_FLAG(flagfile));
-      remove_flag = true;
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
-    } else if (arg_string == "--help" || arg_string == "-h" ||
-               arg_string == "-?" || arg_string == "/?" ||
-               HasGoogleTestFlagPrefix(arg)) {
-      // Both help flag and unrecognized Google Test flags (excluding
-      // internal ones) trigger help display.
-      g_help_flag = true;
-    }
-
-    if (remove_flag) {
-      // 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
-      // well.
-      for (int j = i; j != *argc; j++) {
-        argv[j] = argv[j + 1];
-      }
-
-      // Decrements the argument count.
-      (*argc)--;
-
-      // We also need to decrement the iterator as we just removed
-      // an element.
-      i--;
-    }
-  }
-
-  if (g_help_flag) {
-    // We print the help here instead of in RUN_ALL_TESTS(), as the
-    // latter may not be called at all if the user is using Google
-    // Test with another testing framework.
-    PrintColorEncoded(kColorEncodedHelpMessage);
-  }
-}
-
-// Parses the command line for Google Test flags, without initializing
-// other parts of Google Test.
-void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
-  ParseGoogleTestFlagsOnlyImpl(argc, argv);
-}
-void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
-  ParseGoogleTestFlagsOnlyImpl(argc, argv);
-}
-
-// The internal implementation of InitGoogleTest().
-//
-// The type parameter CharType can be instantiated to either char or
-// wchar_t.
-template <typename CharType>
-void InitGoogleTestImpl(int* argc, CharType** argv) {
-  // We don't want to run the initialization code twice.
-  if (GTestIsInitialized()) return;
-
-  if (*argc <= 0) return;
-
-  g_argvs.clear();
-  for (int i = 0; i != *argc; i++) {
-    g_argvs.push_back(StreamableToString(argv[i]));
-  }
-
-  ParseGoogleTestFlagsOnly(argc, argv);
-  GetUnitTestImpl()->PostFlagParsingInit();
-}
-
-}  // namespace internal
-
-// Initializes Google Test.  This must be called before calling
-// RUN_ALL_TESTS().  In particular, it parses a command line for the
-// flags that Google Test recognizes.  Whenever a Google Test flag is
-// seen, it is removed from argv, and *argc is decremented.
-//
-// No value is returned.  Instead, the Google Test flag variables are
-// updated.
-//
-// Calling the function for the second time has no user-visible effect.
-void InitGoogleTest(int* argc, char** argv) {
-#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_)
-}
-
-// This overloaded version can be used in Windows programs compiled in
-// UNICODE mode.
-void InitGoogleTest(int* argc, wchar_t** argv) {
-#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_)
-}
-
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest_main.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest_main.cc
deleted file mode 100644
index f3028225..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/src/gtest_main.cc
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2006, 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.
-
-#include <stdio.h>
-
-#include "gtest/gtest.h"
-
-GTEST_API_ int main(int argc, char **argv) {
-  printf("Running main() from gtest_main.cc\n");
-  testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_ex_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_ex_test.cc
deleted file mode 100644
index b50a13d5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_ex_test.cc
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2010, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: vladl@google.com (Vlad Losev)
-//
-// Tests that verify interaction of exceptions and death tests.
-
-#include "gtest/gtest-death-test.h"
-#include "gtest/gtest.h"
-
-#if GTEST_HAS_DEATH_TEST
-
-# if GTEST_HAS_SEH
-#  include <windows.h>          // For RaiseException().
-# endif
-
-# include "gtest/gtest-spi.h"
-
-# if GTEST_HAS_EXCEPTIONS
-
-#  include <exception>  // For std::exception.
-
-// Tests that death tests report thrown exceptions as failures and that the
-// exceptions do not escape death test macros.
-TEST(CxxExceptionDeathTest, ExceptionIsFailure) {
-  try {
-    EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(throw 1, ""), "threw an exception");
-  } catch (...) {  // NOLINT
-    FAIL() << "An exception escaped a death test macro invocation "
-           << "with catch_exceptions "
-           << (testing::GTEST_FLAG(catch_exceptions) ? "enabled" : "disabled");
-  }
-}
-
-class TestException : public std::exception {
- public:
-  virtual const char* what() const throw() { return "exceptional message"; }
-};
-
-TEST(CxxExceptionDeathTest, PrintsMessageForStdExceptions) {
-  // Verifies that the exception message is quoted in the failure text.
-  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(throw TestException(), ""),
-                          "exceptional message");
-  // Verifies that the location is mentioned in the failure text.
-  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(throw TestException(), ""),
-                          "gtest-death-test_ex_test.cc");
-}
-# endif  // GTEST_HAS_EXCEPTIONS
-
-# if GTEST_HAS_SEH
-// Tests that enabling interception of SEH exceptions with the
-// catch_exceptions flag does not interfere with SEH exceptions being
-// treated as death by death tests.
-TEST(SehExceptionDeasTest, CatchExceptionsDoesNotInterfere) {
-  EXPECT_DEATH(RaiseException(42, 0x0, 0, NULL), "")
-      << "with catch_exceptions "
-      << (testing::GTEST_FLAG(catch_exceptions) ? "enabled" : "disabled");
-}
-# endif
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-int main(int argc, char** argv) {
-  testing::InitGoogleTest(&argc, argv);
-  testing::GTEST_FLAG(catch_exceptions) = GTEST_ENABLE_CATCH_EXCEPTIONS_ != 0;
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_test.cc
deleted file mode 100644
index bb4a3d1b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-death-test_test.cc
+++ /dev/null
@@ -1,1427 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Tests for death tests.
-
-#include "gtest/gtest-death-test.h"
-#include "gtest/gtest.h"
-#include "gtest/internal/gtest-filepath.h"
-
-using testing::internal::AlwaysFalse;
-using testing::internal::AlwaysTrue;
-
-#if GTEST_HAS_DEATH_TEST
-
-# if GTEST_OS_WINDOWS
-#  include <direct.h>          // For chdir().
-# else
-#  include <unistd.h>
-#  include <sys/wait.h>        // For waitpid.
-# endif  // GTEST_OS_WINDOWS
-
-# include <limits.h>
-# include <signal.h>
-# include <stdio.h>
-
-# if GTEST_OS_LINUX
-#  include <sys/time.h>
-# endif  // GTEST_OS_LINUX
-
-# include "gtest/gtest-spi.h"
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick is to
-// prevent a user from accidentally including gtest-internal-inl.h in
-// his code.
-# define GTEST_IMPLEMENTATION_ 1
-# include "src/gtest-internal-inl.h"
-# undef GTEST_IMPLEMENTATION_
-
-namespace posix = ::testing::internal::posix;
-
-using testing::Message;
-using testing::internal::DeathTest;
-using testing::internal::DeathTestFactory;
-using testing::internal::FilePath;
-using testing::internal::GetLastErrnoDescription;
-using testing::internal::GetUnitTestImpl;
-using testing::internal::InDeathTestChild;
-using testing::internal::ParseNaturalNumber;
-
-namespace testing {
-namespace internal {
-
-// A helper class whose objects replace the death test factory for a
-// single UnitTest object during their lifetimes.
-class ReplaceDeathTestFactory {
- public:
-  explicit ReplaceDeathTestFactory(DeathTestFactory* new_factory)
-      : unit_test_impl_(GetUnitTestImpl()) {
-    old_factory_ = unit_test_impl_->death_test_factory_.release();
-    unit_test_impl_->death_test_factory_.reset(new_factory);
-  }
-
-  ~ReplaceDeathTestFactory() {
-    unit_test_impl_->death_test_factory_.release();
-    unit_test_impl_->death_test_factory_.reset(old_factory_);
-  }
- private:
-  // Prevents copying ReplaceDeathTestFactory objects.
-  ReplaceDeathTestFactory(const ReplaceDeathTestFactory&);
-  void operator=(const ReplaceDeathTestFactory&);
-
-  UnitTestImpl* unit_test_impl_;
-  DeathTestFactory* old_factory_;
-};
-
-}  // namespace internal
-}  // namespace testing
-
-void DieWithMessage(const ::std::string& message) {
-  fprintf(stderr, "%s", message.c_str());
-  fflush(stderr);  // Make sure the text is printed before the process exits.
-
-  // We call _exit() instead of exit(), as the former is a direct
-  // system call and thus safer in the presence of threads.  exit()
-  // will invoke user-defined exit-hooks, which may do dangerous
-  // things that conflict with death tests.
-  //
-  // Some compilers can recognize that _exit() never returns and issue the
-  // 'unreachable code' warning for code following this function, unless
-  // fooled by a fake condition.
-  if (AlwaysTrue())
-    _exit(1);
-}
-
-void DieInside(const ::std::string& function) {
-  DieWithMessage("death inside " + function + "().");
-}
-
-// Tests that death tests work.
-
-class TestForDeathTest : public testing::Test {
- protected:
-  TestForDeathTest() : original_dir_(FilePath::GetCurrentDir()) {}
-
-  virtual ~TestForDeathTest() {
-    posix::ChDir(original_dir_.c_str());
-  }
-
-  // A static member function that's expected to die.
-  static void StaticMemberFunction() { DieInside("StaticMemberFunction"); }
-
-  // A method of the test fixture that may die.
-  void MemberFunction() {
-    if (should_die_)
-      DieInside("MemberFunction");
-  }
-
-  // True iff MemberFunction() should die.
-  bool should_die_;
-  const FilePath original_dir_;
-};
-
-// A class with a member function that may die.
-class MayDie {
- public:
-  explicit MayDie(bool should_die) : should_die_(should_die) {}
-
-  // A member function that may die.
-  void MemberFunction() const {
-    if (should_die_)
-      DieInside("MayDie::MemberFunction");
-  }
-
- private:
-  // True iff MemberFunction() should die.
-  bool should_die_;
-};
-
-// A global function that's expected to die.
-void GlobalFunction() { DieInside("GlobalFunction"); }
-
-// A non-void function that's expected to die.
-int NonVoidFunction() {
-  DieInside("NonVoidFunction");
-  return 1;
-}
-
-// A unary function that may die.
-void DieIf(bool should_die) {
-  if (should_die)
-    DieInside("DieIf");
-}
-
-// A binary function that may die.
-bool DieIfLessThan(int x, int y) {
-  if (x < y) {
-    DieInside("DieIfLessThan");
-  }
-  return true;
-}
-
-// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.
-void DeathTestSubroutine() {
-  EXPECT_DEATH(GlobalFunction(), "death.*GlobalFunction");
-  ASSERT_DEATH(GlobalFunction(), "death.*GlobalFunction");
-}
-
-// Death in dbg, not opt.
-int DieInDebugElse12(int* sideeffect) {
-  if (sideeffect) *sideeffect = 12;
-
-# ifndef NDEBUG
-
-  DieInside("DieInDebugElse12");
-
-# endif  // NDEBUG
-
-  return 12;
-}
-
-# if GTEST_OS_WINDOWS
-
-// Tests the ExitedWithCode predicate.
-TEST(ExitStatusPredicateTest, ExitedWithCode) {
-  // On Windows, the process's exit code is the same as its exit status,
-  // so the predicate just compares the its input with its parameter.
-  EXPECT_TRUE(testing::ExitedWithCode(0)(0));
-  EXPECT_TRUE(testing::ExitedWithCode(1)(1));
-  EXPECT_TRUE(testing::ExitedWithCode(42)(42));
-  EXPECT_FALSE(testing::ExitedWithCode(0)(1));
-  EXPECT_FALSE(testing::ExitedWithCode(1)(0));
-}
-
-# else
-
-// Returns the exit status of a process that calls _exit(2) with a
-// given exit code.  This is a helper function for the
-// ExitStatusPredicateTest test suite.
-static int NormalExitStatus(int exit_code) {
-  pid_t child_pid = fork();
-  if (child_pid == 0) {
-    _exit(exit_code);
-  }
-  int status;
-  waitpid(child_pid, &status, 0);
-  return status;
-}
-
-// Returns the exit status of a process that raises a given signal.
-// If the signal does not cause the process to die, then it returns
-// instead the exit status of a process that exits normally with exit
-// code 1.  This is a helper function for the ExitStatusPredicateTest
-// test suite.
-static int KilledExitStatus(int signum) {
-  pid_t child_pid = fork();
-  if (child_pid == 0) {
-    raise(signum);
-    _exit(1);
-  }
-  int status;
-  waitpid(child_pid, &status, 0);
-  return status;
-}
-
-// Tests the ExitedWithCode predicate.
-TEST(ExitStatusPredicateTest, ExitedWithCode) {
-  const int status0  = NormalExitStatus(0);
-  const int status1  = NormalExitStatus(1);
-  const int status42 = NormalExitStatus(42);
-  const testing::ExitedWithCode pred0(0);
-  const testing::ExitedWithCode pred1(1);
-  const testing::ExitedWithCode pred42(42);
-  EXPECT_PRED1(pred0,  status0);
-  EXPECT_PRED1(pred1,  status1);
-  EXPECT_PRED1(pred42, status42);
-  EXPECT_FALSE(pred0(status1));
-  EXPECT_FALSE(pred42(status0));
-  EXPECT_FALSE(pred1(status42));
-}
-
-// Tests the KilledBySignal predicate.
-TEST(ExitStatusPredicateTest, KilledBySignal) {
-  const int status_segv = KilledExitStatus(SIGSEGV);
-  const int status_kill = KilledExitStatus(SIGKILL);
-  const testing::KilledBySignal pred_segv(SIGSEGV);
-  const testing::KilledBySignal pred_kill(SIGKILL);
-  EXPECT_PRED1(pred_segv, status_segv);
-  EXPECT_PRED1(pred_kill, status_kill);
-  EXPECT_FALSE(pred_segv(status_kill));
-  EXPECT_FALSE(pred_kill(status_segv));
-}
-
-# endif  // GTEST_OS_WINDOWS
-
-// Tests that the death test macros expand to code which may or may not
-// be followed by operator<<, and that in either case the complete text
-// comprises only a single C++ statement.
-TEST_F(TestForDeathTest, SingleStatement) {
-  if (AlwaysFalse())
-    // This would fail if executed; this is a compilation test only
-    ASSERT_DEATH(return, "");
-
-  if (AlwaysTrue())
-    EXPECT_DEATH(_exit(1), "");
-  else
-    // This empty "else" branch is meant to ensure that EXPECT_DEATH
-    // doesn't expand into an "if" statement without an "else"
-    ;
-
-  if (AlwaysFalse())
-    ASSERT_DEATH(return, "") << "did not die";
-
-  if (AlwaysFalse())
-    ;
-  else
-    EXPECT_DEATH(_exit(1), "") << 1 << 2 << 3;
-}
-
-void DieWithEmbeddedNul() {
-  fprintf(stderr, "Hello%cmy null world.\n", '\0');
-  fflush(stderr);
-  _exit(1);
-}
-
-# if GTEST_USES_PCRE
-// Tests that EXPECT_DEATH and ASSERT_DEATH work when the error
-// message has a NUL character in it.
-TEST_F(TestForDeathTest, EmbeddedNulInMessage) {
-  // TODO(wan@google.com): <regex.h> doesn't support matching strings
-  // with embedded NUL characters - find a way to workaround it.
-  EXPECT_DEATH(DieWithEmbeddedNul(), "my null world");
-  ASSERT_DEATH(DieWithEmbeddedNul(), "my null world");
-}
-# endif  // GTEST_USES_PCRE
-
-// Tests that death test macros expand to code which interacts well with switch
-// statements.
-TEST_F(TestForDeathTest, SwitchStatement) {
-  // Microsoft compiler usually complains about switch statements without
-  // case labels. We suppress that warning for this test.
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4065)
-
-  switch (0)
-    default:
-      ASSERT_DEATH(_exit(1), "") << "exit in default switch handler";
-
-  switch (0)
-    case 0:
-      EXPECT_DEATH(_exit(1), "") << "exit in switch case";
-
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-}
-
-// Tests that a static member function can be used in a "fast" style
-// death test.
-TEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
-  ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");
-}
-
-// Tests that a method of the test fixture can be used in a "fast"
-// style death test.
-TEST_F(TestForDeathTest, MemberFunctionFastStyle) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
-  should_die_ = true;
-  EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
-}
-
-void ChangeToRootDir() { posix::ChDir(GTEST_PATH_SEP_); }
-
-// Tests that death tests work even if the current directory has been
-// changed.
-TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
-
-  ChangeToRootDir();
-  EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
-
-  ChangeToRootDir();
-  ASSERT_DEATH(_exit(1), "");
-}
-
-# if GTEST_OS_LINUX
-void SigprofAction(int, siginfo_t*, void*) { /* no op */ }
-
-// Sets SIGPROF action and ITIMER_PROF timer (interval: 1ms).
-void SetSigprofActionAndTimer() {
-  struct itimerval timer;
-  timer.it_interval.tv_sec = 0;
-  timer.it_interval.tv_usec = 1;
-  timer.it_value = timer.it_interval;
-  ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL));
-  struct sigaction signal_action;
-  memset(&signal_action, 0, sizeof(signal_action));
-  sigemptyset(&signal_action.sa_mask);
-  signal_action.sa_sigaction = SigprofAction;
-  signal_action.sa_flags = SA_RESTART | SA_SIGINFO;
-  ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, NULL));
-}
-
-// Disables ITIMER_PROF timer and ignores SIGPROF signal.
-void DisableSigprofActionAndTimer(struct sigaction* old_signal_action) {
-  struct itimerval timer;
-  timer.it_interval.tv_sec = 0;
-  timer.it_interval.tv_usec = 0;
-  timer.it_value = timer.it_interval;
-  ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL));
-  struct sigaction signal_action;
-  memset(&signal_action, 0, sizeof(signal_action));
-  sigemptyset(&signal_action.sa_mask);
-  signal_action.sa_handler = SIG_IGN;
-  ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, old_signal_action));
-}
-
-// Tests that death tests work when SIGPROF handler and timer are set.
-TEST_F(TestForDeathTest, FastSigprofActionSet) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
-  SetSigprofActionAndTimer();
-  EXPECT_DEATH(_exit(1), "");
-  struct sigaction old_signal_action;
-  DisableSigprofActionAndTimer(&old_signal_action);
-  EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
-}
-
-TEST_F(TestForDeathTest, ThreadSafeSigprofActionSet) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
-  SetSigprofActionAndTimer();
-  EXPECT_DEATH(_exit(1), "");
-  struct sigaction old_signal_action;
-  DisableSigprofActionAndTimer(&old_signal_action);
-  EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
-}
-# endif  // GTEST_OS_LINUX
-
-// Repeats a representative sample of death tests in the "threadsafe" style:
-
-TEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
-  ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");
-}
-
-TEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
-  should_die_ = true;
-  EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
-}
-
-TEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
-
-  for (int i = 0; i < 3; ++i)
-    EXPECT_EXIT(_exit(i), testing::ExitedWithCode(i), "") << ": i = " << i;
-}
-
-TEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
-
-  ChangeToRootDir();
-  EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
-
-  ChangeToRootDir();
-  ASSERT_DEATH(_exit(1), "");
-}
-
-TEST_F(TestForDeathTest, MixedStyles) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
-  EXPECT_DEATH(_exit(1), "");
-  testing::GTEST_FLAG(death_test_style) = "fast";
-  EXPECT_DEATH(_exit(1), "");
-}
-
-# if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
-
-namespace {
-
-bool pthread_flag;
-
-void SetPthreadFlag() {
-  pthread_flag = true;
-}
-
-}  // namespace
-
-TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
-  if (!testing::GTEST_FLAG(death_test_use_fork)) {
-    testing::GTEST_FLAG(death_test_style) = "threadsafe";
-    pthread_flag = false;
-    ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, NULL, NULL));
-    ASSERT_DEATH(_exit(1), "");
-    ASSERT_FALSE(pthread_flag);
-  }
-}
-
-# endif  // GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
-
-// Tests that a method of another class can be used in a death test.
-TEST_F(TestForDeathTest, MethodOfAnotherClass) {
-  const MayDie x(true);
-  ASSERT_DEATH(x.MemberFunction(), "MayDie\\:\\:MemberFunction");
-}
-
-// Tests that a global function can be used in a death test.
-TEST_F(TestForDeathTest, GlobalFunction) {
-  EXPECT_DEATH(GlobalFunction(), "GlobalFunction");
-}
-
-// Tests that any value convertible to an RE works as a second
-// argument to EXPECT_DEATH.
-TEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) {
-  static const char regex_c_str[] = "GlobalFunction";
-  EXPECT_DEATH(GlobalFunction(), regex_c_str);
-
-  const testing::internal::RE regex(regex_c_str);
-  EXPECT_DEATH(GlobalFunction(), regex);
-
-# if GTEST_HAS_GLOBAL_STRING
-
-  const string regex_str(regex_c_str);
-  EXPECT_DEATH(GlobalFunction(), regex_str);
-
-# endif  // GTEST_HAS_GLOBAL_STRING
-
-# if !GTEST_USES_PCRE
-
-  const ::std::string regex_std_str(regex_c_str);
-  EXPECT_DEATH(GlobalFunction(), regex_std_str);
-
-# endif  // !GTEST_USES_PCRE
-}
-
-// Tests that a non-void function can be used in a death test.
-TEST_F(TestForDeathTest, NonVoidFunction) {
-  ASSERT_DEATH(NonVoidFunction(), "NonVoidFunction");
-}
-
-// Tests that functions that take parameter(s) can be used in a death test.
-TEST_F(TestForDeathTest, FunctionWithParameter) {
-  EXPECT_DEATH(DieIf(true), "DieIf\\(\\)");
-  EXPECT_DEATH(DieIfLessThan(2, 3), "DieIfLessThan");
-}
-
-// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.
-TEST_F(TestForDeathTest, OutsideFixture) {
-  DeathTestSubroutine();
-}
-
-// Tests that death tests can be done inside a loop.
-TEST_F(TestForDeathTest, InsideLoop) {
-  for (int i = 0; i < 5; i++) {
-    EXPECT_DEATH(DieIfLessThan(-1, i), "DieIfLessThan") << "where i == " << i;
-  }
-}
-
-// Tests that a compound statement can be used in a death test.
-TEST_F(TestForDeathTest, CompoundStatement) {
-  EXPECT_DEATH({  // NOLINT
-    const int x = 2;
-    const int y = x + 1;
-    DieIfLessThan(x, y);
-  },
-  "DieIfLessThan");
-}
-
-// Tests that code that doesn't die causes a death test to fail.
-TEST_F(TestForDeathTest, DoesNotDie) {
-  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(DieIf(false), "DieIf"),
-                          "failed to die");
-}
-
-// Tests that a death test fails when the error message isn't expected.
-TEST_F(TestForDeathTest, ErrorMessageMismatch) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_DEATH(DieIf(true), "DieIfLessThan") << "End of death test message.";
-  }, "died but not with expected error");
-}
-
-// On exit, *aborted will be true iff the EXPECT_DEATH() statement
-// aborted the function.
-void ExpectDeathTestHelper(bool* aborted) {
-  *aborted = true;
-  EXPECT_DEATH(DieIf(false), "DieIf");  // This assertion should fail.
-  *aborted = false;
-}
-
-// Tests that EXPECT_DEATH doesn't abort the test on failure.
-TEST_F(TestForDeathTest, EXPECT_DEATH) {
-  bool aborted = true;
-  EXPECT_NONFATAL_FAILURE(ExpectDeathTestHelper(&aborted),
-                          "failed to die");
-  EXPECT_FALSE(aborted);
-}
-
-// Tests that ASSERT_DEATH does abort the test on failure.
-TEST_F(TestForDeathTest, ASSERT_DEATH) {
-  static bool aborted;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    aborted = true;
-    ASSERT_DEATH(DieIf(false), "DieIf");  // This assertion should fail.
-    aborted = false;
-  }, "failed to die");
-  EXPECT_TRUE(aborted);
-}
-
-// Tests that EXPECT_DEATH evaluates the arguments exactly once.
-TEST_F(TestForDeathTest, SingleEvaluation) {
-  int x = 3;
-  EXPECT_DEATH(DieIf((++x) == 4), "DieIf");
-
-  const char* regex = "DieIf";
-  const char* regex_save = regex;
-  EXPECT_DEATH(DieIfLessThan(3, 4), regex++);
-  EXPECT_EQ(regex_save + 1, regex);
-}
-
-// Tests that run-away death tests are reported as failures.
-TEST_F(TestForDeathTest, RunawayIsFailure) {
-  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(static_cast<void>(0), "Foo"),
-                          "failed to die.");
-}
-
-// Tests that death tests report executing 'return' in the statement as
-// failure.
-TEST_F(TestForDeathTest, ReturnIsFailure) {
-  EXPECT_FATAL_FAILURE(ASSERT_DEATH(return, "Bar"),
-                       "illegal return in test statement.");
-}
-
-// Tests that EXPECT_DEBUG_DEATH works as expected, that is, you can stream a
-// message to it, and in debug mode it:
-// 1. Asserts on death.
-// 2. Has no side effect.
-//
-// And in opt mode, it:
-// 1.  Has side effects but does not assert.
-TEST_F(TestForDeathTest, TestExpectDebugDeath) {
-  int sideeffect = 0;
-
-  EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12")
-      << "Must accept a streamed message";
-
-# ifdef NDEBUG
-
-  // Checks that the assignment occurs in opt mode (sideeffect).
-  EXPECT_EQ(12, sideeffect);
-
-# else
-
-  // Checks that the assignment does not occur in dbg mode (no sideeffect).
-  EXPECT_EQ(0, sideeffect);
-
-# endif
-}
-
-// Tests that ASSERT_DEBUG_DEATH works as expected, that is, you can stream a
-// message to it, and in debug mode it:
-// 1. Asserts on death.
-// 2. Has no side effect.
-//
-// And in opt mode, it:
-// 1.  Has side effects but does not assert.
-TEST_F(TestForDeathTest, TestAssertDebugDeath) {
-  int sideeffect = 0;
-
-  ASSERT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12")
-      << "Must accept a streamed message";
-
-# ifdef NDEBUG
-
-  // Checks that the assignment occurs in opt mode (sideeffect).
-  EXPECT_EQ(12, sideeffect);
-
-# else
-
-  // Checks that the assignment does not occur in dbg mode (no sideeffect).
-  EXPECT_EQ(0, sideeffect);
-
-# endif
-}
-
-# ifndef NDEBUG
-
-void ExpectDebugDeathHelper(bool* aborted) {
-  *aborted = true;
-  EXPECT_DEBUG_DEATH(return, "") << "This is expected to fail.";
-  *aborted = false;
-}
-
-#  if GTEST_OS_WINDOWS
-TEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) {
-  printf("This test should be considered failing if it shows "
-         "any pop-up dialogs.\n");
-  fflush(stdout);
-
-  EXPECT_DEATH({
-    testing::GTEST_FLAG(catch_exceptions) = false;
-    abort();
-  }, "");
-}
-#  endif  // GTEST_OS_WINDOWS
-
-// Tests that EXPECT_DEBUG_DEATH in debug mode does not abort
-// the function.
-TEST_F(TestForDeathTest, ExpectDebugDeathDoesNotAbort) {
-  bool aborted = true;
-  EXPECT_NONFATAL_FAILURE(ExpectDebugDeathHelper(&aborted), "");
-  EXPECT_FALSE(aborted);
-}
-
-void AssertDebugDeathHelper(bool* aborted) {
-  *aborted = true;
-  GTEST_LOG_(INFO) << "Before ASSERT_DEBUG_DEATH";
-  ASSERT_DEBUG_DEATH(GTEST_LOG_(INFO) << "In ASSERT_DEBUG_DEATH"; return, "")
-      << "This is expected to fail.";
-  GTEST_LOG_(INFO) << "After ASSERT_DEBUG_DEATH";
-  *aborted = false;
-}
-
-// Tests that ASSERT_DEBUG_DEATH in debug mode aborts the function on
-// failure.
-TEST_F(TestForDeathTest, AssertDebugDeathAborts) {
-  static bool aborted;
-  aborted = false;
-  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
-  EXPECT_TRUE(aborted);
-}
-
-TEST_F(TestForDeathTest, AssertDebugDeathAborts2) {
-  static bool aborted;
-  aborted = false;
-  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
-  EXPECT_TRUE(aborted);
-}
-
-TEST_F(TestForDeathTest, AssertDebugDeathAborts3) {
-  static bool aborted;
-  aborted = false;
-  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
-  EXPECT_TRUE(aborted);
-}
-
-TEST_F(TestForDeathTest, AssertDebugDeathAborts4) {
-  static bool aborted;
-  aborted = false;
-  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
-  EXPECT_TRUE(aborted);
-}
-
-TEST_F(TestForDeathTest, AssertDebugDeathAborts5) {
-  static bool aborted;
-  aborted = false;
-  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
-  EXPECT_TRUE(aborted);
-}
-
-TEST_F(TestForDeathTest, AssertDebugDeathAborts6) {
-  static bool aborted;
-  aborted = false;
-  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
-  EXPECT_TRUE(aborted);
-}
-
-TEST_F(TestForDeathTest, AssertDebugDeathAborts7) {
-  static bool aborted;
-  aborted = false;
-  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
-  EXPECT_TRUE(aborted);
-}
-
-TEST_F(TestForDeathTest, AssertDebugDeathAborts8) {
-  static bool aborted;
-  aborted = false;
-  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
-  EXPECT_TRUE(aborted);
-}
-
-TEST_F(TestForDeathTest, AssertDebugDeathAborts9) {
-  static bool aborted;
-  aborted = false;
-  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
-  EXPECT_TRUE(aborted);
-}
-
-TEST_F(TestForDeathTest, AssertDebugDeathAborts10) {
-  static bool aborted;
-  aborted = false;
-  EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
-  EXPECT_TRUE(aborted);
-}
-
-# endif  // _NDEBUG
-
-// Tests the *_EXIT family of macros, using a variety of predicates.
-static void TestExitMacros() {
-  EXPECT_EXIT(_exit(1),  testing::ExitedWithCode(1),  "");
-  ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), "");
-
-# if GTEST_OS_WINDOWS
-
-  // Of all signals effects on the process exit code, only those of SIGABRT
-  // are documented on Windows.
-  // See http://msdn.microsoft.com/en-us/library/dwwzkt4c(VS.71).aspx.
-  EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "") << "b_ar";
-
-# else
-
-  EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo";
-  ASSERT_EXIT(raise(SIGUSR2), testing::KilledBySignal(SIGUSR2), "") << "bar";
-
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "")
-      << "This failure is expected, too.";
-  }, "This failure is expected, too.");
-
-# endif  // GTEST_OS_WINDOWS
-
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "")
-      << "This failure is expected.";
-  }, "This failure is expected.");
-}
-
-TEST_F(TestForDeathTest, ExitMacros) {
-  TestExitMacros();
-}
-
-TEST_F(TestForDeathTest, ExitMacrosUsingFork) {
-  testing::GTEST_FLAG(death_test_use_fork) = true;
-  TestExitMacros();
-}
-
-TEST_F(TestForDeathTest, InvalidStyle) {
-  testing::GTEST_FLAG(death_test_style) = "rococo";
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_DEATH(_exit(0), "") << "This failure is expected.";
-  }, "This failure is expected.");
-}
-
-TEST_F(TestForDeathTest, DeathTestFailedOutput) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_DEATH(DieWithMessage("death\n"),
-                   "expected message"),
-      "Actual msg:\n"
-      "[  DEATH   ] death\n");
-}
-
-TEST_F(TestForDeathTest, DeathTestUnexpectedReturnOutput) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_DEATH({
-          fprintf(stderr, "returning\n");
-          fflush(stderr);
-          return;
-        }, ""),
-      "    Result: illegal return in test statement.\n"
-      " Error msg:\n"
-      "[  DEATH   ] returning\n");
-}
-
-TEST_F(TestForDeathTest, DeathTestBadExitCodeOutput) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_EXIT(DieWithMessage("exiting with rc 1\n"),
-                  testing::ExitedWithCode(3),
-                  "expected message"),
-      "    Result: died but not with expected exit code:\n"
-      "            Exited with exit status 1\n"
-      "Actual msg:\n"
-      "[  DEATH   ] exiting with rc 1\n");
-}
-
-TEST_F(TestForDeathTest, DeathTestMultiLineMatchFail) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"),
-                   "line 1\nxyz\nline 3\n"),
-      "Actual msg:\n"
-      "[  DEATH   ] line 1\n"
-      "[  DEATH   ] line 2\n"
-      "[  DEATH   ] line 3\n");
-}
-
-TEST_F(TestForDeathTest, DeathTestMultiLineMatchPass) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
-  EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"),
-               "line 1\nline 2\nline 3\n");
-}
-
-// A DeathTestFactory that returns MockDeathTests.
-class MockDeathTestFactory : public DeathTestFactory {
- public:
-  MockDeathTestFactory();
-  virtual bool Create(const char* statement,
-                      const ::testing::internal::RE* regex,
-                      const char* file, int line, DeathTest** test);
-
-  // Sets the parameters for subsequent calls to Create.
-  void SetParameters(bool create, DeathTest::TestRole role,
-                     int status, bool passed);
-
-  // Accessors.
-  int AssumeRoleCalls() const { return assume_role_calls_; }
-  int WaitCalls() const { return wait_calls_; }
-  size_t PassedCalls() const { return passed_args_.size(); }
-  bool PassedArgument(int n) const { return passed_args_[n]; }
-  size_t AbortCalls() const { return abort_args_.size(); }
-  DeathTest::AbortReason AbortArgument(int n) const {
-    return abort_args_[n];
-  }
-  bool TestDeleted() const { return test_deleted_; }
-
- private:
-  friend class MockDeathTest;
-  // If true, Create will return a MockDeathTest; otherwise it returns
-  // NULL.
-  bool create_;
-  // The value a MockDeathTest will return from its AssumeRole method.
-  DeathTest::TestRole role_;
-  // The value a MockDeathTest will return from its Wait method.
-  int status_;
-  // The value a MockDeathTest will return from its Passed method.
-  bool passed_;
-
-  // Number of times AssumeRole was called.
-  int assume_role_calls_;
-  // Number of times Wait was called.
-  int wait_calls_;
-  // The arguments to the calls to Passed since the last call to
-  // SetParameters.
-  std::vector<bool> passed_args_;
-  // The arguments to the calls to Abort since the last call to
-  // SetParameters.
-  std::vector<DeathTest::AbortReason> abort_args_;
-  // True if the last MockDeathTest returned by Create has been
-  // deleted.
-  bool test_deleted_;
-};
-
-
-// A DeathTest implementation useful in testing.  It returns values set
-// at its creation from its various inherited DeathTest methods, and
-// reports calls to those methods to its parent MockDeathTestFactory
-// object.
-class MockDeathTest : public DeathTest {
- public:
-  MockDeathTest(MockDeathTestFactory *parent,
-                TestRole role, int status, bool passed) :
-      parent_(parent), role_(role), status_(status), passed_(passed) {
-  }
-  virtual ~MockDeathTest() {
-    parent_->test_deleted_ = true;
-  }
-  virtual TestRole AssumeRole() {
-    ++parent_->assume_role_calls_;
-    return role_;
-  }
-  virtual int Wait() {
-    ++parent_->wait_calls_;
-    return status_;
-  }
-  virtual bool Passed(bool exit_status_ok) {
-    parent_->passed_args_.push_back(exit_status_ok);
-    return passed_;
-  }
-  virtual void Abort(AbortReason reason) {
-    parent_->abort_args_.push_back(reason);
-  }
-
- private:
-  MockDeathTestFactory* const parent_;
-  const TestRole role_;
-  const int status_;
-  const bool passed_;
-};
-
-
-// MockDeathTestFactory constructor.
-MockDeathTestFactory::MockDeathTestFactory()
-    : create_(true),
-      role_(DeathTest::OVERSEE_TEST),
-      status_(0),
-      passed_(true),
-      assume_role_calls_(0),
-      wait_calls_(0),
-      passed_args_(),
-      abort_args_() {
-}
-
-
-// Sets the parameters for subsequent calls to Create.
-void MockDeathTestFactory::SetParameters(bool create,
-                                         DeathTest::TestRole role,
-                                         int status, bool passed) {
-  create_ = create;
-  role_ = role;
-  status_ = status;
-  passed_ = passed;
-
-  assume_role_calls_ = 0;
-  wait_calls_ = 0;
-  passed_args_.clear();
-  abort_args_.clear();
-}
-
-
-// Sets test to NULL (if create_ is false) or to the address of a new
-// MockDeathTest object with parameters taken from the last call
-// to SetParameters (if create_ is true).  Always returns true.
-bool MockDeathTestFactory::Create(const char* /*statement*/,
-                                  const ::testing::internal::RE* /*regex*/,
-                                  const char* /*file*/,
-                                  int /*line*/,
-                                  DeathTest** test) {
-  test_deleted_ = false;
-  if (create_) {
-    *test = new MockDeathTest(this, role_, status_, passed_);
-  } else {
-    *test = NULL;
-  }
-  return true;
-}
-
-// A test fixture for testing the logic of the GTEST_DEATH_TEST_ macro.
-// It installs a MockDeathTestFactory that is used for the duration
-// of the test case.
-class MacroLogicDeathTest : public testing::Test {
- protected:
-  static testing::internal::ReplaceDeathTestFactory* replacer_;
-  static MockDeathTestFactory* factory_;
-
-  static void SetUpTestCase() {
-    factory_ = new MockDeathTestFactory;
-    replacer_ = new testing::internal::ReplaceDeathTestFactory(factory_);
-  }
-
-  static void TearDownTestCase() {
-    delete replacer_;
-    replacer_ = NULL;
-    delete factory_;
-    factory_ = NULL;
-  }
-
-  // Runs a death test that breaks the rules by returning.  Such a death
-  // test cannot be run directly from a test routine that uses a
-  // MockDeathTest, or the remainder of the routine will not be executed.
-  static void RunReturningDeathTest(bool* flag) {
-    ASSERT_DEATH({  // NOLINT
-      *flag = true;
-      return;
-    }, "");
-  }
-};
-
-testing::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_
-    = NULL;
-MockDeathTestFactory* MacroLogicDeathTest::factory_ = NULL;
-
-
-// Test that nothing happens when the factory doesn't return a DeathTest:
-TEST_F(MacroLogicDeathTest, NothingHappens) {
-  bool flag = false;
-  factory_->SetParameters(false, DeathTest::OVERSEE_TEST, 0, true);
-  EXPECT_DEATH(flag = true, "");
-  EXPECT_FALSE(flag);
-  EXPECT_EQ(0, factory_->AssumeRoleCalls());
-  EXPECT_EQ(0, factory_->WaitCalls());
-  EXPECT_EQ(0U, factory_->PassedCalls());
-  EXPECT_EQ(0U, factory_->AbortCalls());
-  EXPECT_FALSE(factory_->TestDeleted());
-}
-
-// Test that the parent process doesn't run the death test code,
-// and that the Passed method returns false when the (simulated)
-// child process exits with status 0:
-TEST_F(MacroLogicDeathTest, ChildExitsSuccessfully) {
-  bool flag = false;
-  factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 0, true);
-  EXPECT_DEATH(flag = true, "");
-  EXPECT_FALSE(flag);
-  EXPECT_EQ(1, factory_->AssumeRoleCalls());
-  EXPECT_EQ(1, factory_->WaitCalls());
-  ASSERT_EQ(1U, factory_->PassedCalls());
-  EXPECT_FALSE(factory_->PassedArgument(0));
-  EXPECT_EQ(0U, factory_->AbortCalls());
-  EXPECT_TRUE(factory_->TestDeleted());
-}
-
-// Tests that the Passed method was given the argument "true" when
-// the (simulated) child process exits with status 1:
-TEST_F(MacroLogicDeathTest, ChildExitsUnsuccessfully) {
-  bool flag = false;
-  factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 1, true);
-  EXPECT_DEATH(flag = true, "");
-  EXPECT_FALSE(flag);
-  EXPECT_EQ(1, factory_->AssumeRoleCalls());
-  EXPECT_EQ(1, factory_->WaitCalls());
-  ASSERT_EQ(1U, factory_->PassedCalls());
-  EXPECT_TRUE(factory_->PassedArgument(0));
-  EXPECT_EQ(0U, factory_->AbortCalls());
-  EXPECT_TRUE(factory_->TestDeleted());
-}
-
-// Tests that the (simulated) child process executes the death test
-// code, and is aborted with the correct AbortReason if it
-// executes a return statement.
-TEST_F(MacroLogicDeathTest, ChildPerformsReturn) {
-  bool flag = false;
-  factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true);
-  RunReturningDeathTest(&flag);
-  EXPECT_TRUE(flag);
-  EXPECT_EQ(1, factory_->AssumeRoleCalls());
-  EXPECT_EQ(0, factory_->WaitCalls());
-  EXPECT_EQ(0U, factory_->PassedCalls());
-  EXPECT_EQ(1U, factory_->AbortCalls());
-  EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
-            factory_->AbortArgument(0));
-  EXPECT_TRUE(factory_->TestDeleted());
-}
-
-// Tests that the (simulated) child process is aborted with the
-// correct AbortReason if it does not die.
-TEST_F(MacroLogicDeathTest, ChildDoesNotDie) {
-  bool flag = false;
-  factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true);
-  EXPECT_DEATH(flag = true, "");
-  EXPECT_TRUE(flag);
-  EXPECT_EQ(1, factory_->AssumeRoleCalls());
-  EXPECT_EQ(0, factory_->WaitCalls());
-  EXPECT_EQ(0U, factory_->PassedCalls());
-  // This time there are two calls to Abort: one since the test didn't
-  // die, and another from the ReturnSentinel when it's destroyed.  The
-  // sentinel normally isn't destroyed if a test doesn't die, since
-  // _exit(2) is called in that case by ForkingDeathTest, but not by
-  // our MockDeathTest.
-  ASSERT_EQ(2U, factory_->AbortCalls());
-  EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE,
-            factory_->AbortArgument(0));
-  EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
-            factory_->AbortArgument(1));
-  EXPECT_TRUE(factory_->TestDeleted());
-}
-
-// Tests that a successful death test does not register a successful
-// test part.
-TEST(SuccessRegistrationDeathTest, NoSuccessPart) {
-  EXPECT_DEATH(_exit(1), "");
-  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
-}
-
-TEST(StreamingAssertionsDeathTest, DeathTest) {
-  EXPECT_DEATH(_exit(1), "") << "unexpected failure";
-  ASSERT_DEATH(_exit(1), "") << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_DEATH(_exit(0), "") << "expected failure";
-  }, "expected failure");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_DEATH(_exit(0), "") << "expected failure";
-  }, "expected failure");
-}
-
-// Tests that GetLastErrnoDescription returns an empty string when the
-// last error is 0 and non-empty string when it is non-zero.
-TEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) {
-  errno = ENOENT;
-  EXPECT_STRNE("", GetLastErrnoDescription().c_str());
-  errno = 0;
-  EXPECT_STREQ("", GetLastErrnoDescription().c_str());
-}
-
-# if GTEST_OS_WINDOWS
-TEST(AutoHandleTest, AutoHandleWorks) {
-  HANDLE handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
-  ASSERT_NE(INVALID_HANDLE_VALUE, handle);
-
-  // Tests that the AutoHandle is correctly initialized with a handle.
-  testing::internal::AutoHandle auto_handle(handle);
-  EXPECT_EQ(handle, auto_handle.Get());
-
-  // Tests that Reset assigns INVALID_HANDLE_VALUE.
-  // Note that this cannot verify whether the original handle is closed.
-  auto_handle.Reset();
-  EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle.Get());
-
-  // Tests that Reset assigns the new handle.
-  // Note that this cannot verify whether the original handle is closed.
-  handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
-  ASSERT_NE(INVALID_HANDLE_VALUE, handle);
-  auto_handle.Reset(handle);
-  EXPECT_EQ(handle, auto_handle.Get());
-
-  // Tests that AutoHandle contains INVALID_HANDLE_VALUE by default.
-  testing::internal::AutoHandle auto_handle2;
-  EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle2.Get());
-}
-# endif  // GTEST_OS_WINDOWS
-
-# if GTEST_OS_WINDOWS
-typedef unsigned __int64 BiggestParsable;
-typedef signed __int64 BiggestSignedParsable;
-# else
-typedef unsigned long long BiggestParsable;
-typedef signed long long BiggestSignedParsable;
-# endif  // GTEST_OS_WINDOWS
-
-// We cannot use std::numeric_limits<T>::max() as it clashes with the
-// max() macro defined by <windows.h>.
-const BiggestParsable kBiggestParsableMax = ULLONG_MAX;
-const BiggestSignedParsable kBiggestSignedParsableMax = LLONG_MAX;
-
-TEST(ParseNaturalNumberTest, RejectsInvalidFormat) {
-  BiggestParsable result = 0;
-
-  // Rejects non-numbers.
-  EXPECT_FALSE(ParseNaturalNumber("non-number string", &result));
-
-  // Rejects numbers with whitespace prefix.
-  EXPECT_FALSE(ParseNaturalNumber(" 123", &result));
-
-  // Rejects negative numbers.
-  EXPECT_FALSE(ParseNaturalNumber("-123", &result));
-
-  // Rejects numbers starting with a plus sign.
-  EXPECT_FALSE(ParseNaturalNumber("+123", &result));
-  errno = 0;
-}
-
-TEST(ParseNaturalNumberTest, RejectsOverflownNumbers) {
-  BiggestParsable result = 0;
-
-  EXPECT_FALSE(ParseNaturalNumber("99999999999999999999999", &result));
-
-  signed char char_result = 0;
-  EXPECT_FALSE(ParseNaturalNumber("200", &char_result));
-  errno = 0;
-}
-
-TEST(ParseNaturalNumberTest, AcceptsValidNumbers) {
-  BiggestParsable result = 0;
-
-  result = 0;
-  ASSERT_TRUE(ParseNaturalNumber("123", &result));
-  EXPECT_EQ(123U, result);
-
-  // Check 0 as an edge case.
-  result = 1;
-  ASSERT_TRUE(ParseNaturalNumber("0", &result));
-  EXPECT_EQ(0U, result);
-
-  result = 1;
-  ASSERT_TRUE(ParseNaturalNumber("00000", &result));
-  EXPECT_EQ(0U, result);
-}
-
-TEST(ParseNaturalNumberTest, AcceptsTypeLimits) {
-  Message msg;
-  msg << kBiggestParsableMax;
-
-  BiggestParsable result = 0;
-  EXPECT_TRUE(ParseNaturalNumber(msg.GetString(), &result));
-  EXPECT_EQ(kBiggestParsableMax, result);
-
-  Message msg2;
-  msg2 << kBiggestSignedParsableMax;
-
-  BiggestSignedParsable signed_result = 0;
-  EXPECT_TRUE(ParseNaturalNumber(msg2.GetString(), &signed_result));
-  EXPECT_EQ(kBiggestSignedParsableMax, signed_result);
-
-  Message msg3;
-  msg3 << INT_MAX;
-
-  int int_result = 0;
-  EXPECT_TRUE(ParseNaturalNumber(msg3.GetString(), &int_result));
-  EXPECT_EQ(INT_MAX, int_result);
-
-  Message msg4;
-  msg4 << UINT_MAX;
-
-  unsigned int uint_result = 0;
-  EXPECT_TRUE(ParseNaturalNumber(msg4.GetString(), &uint_result));
-  EXPECT_EQ(UINT_MAX, uint_result);
-}
-
-TEST(ParseNaturalNumberTest, WorksForShorterIntegers) {
-  short short_result = 0;
-  ASSERT_TRUE(ParseNaturalNumber("123", &short_result));
-  EXPECT_EQ(123, short_result);
-
-  signed char char_result = 0;
-  ASSERT_TRUE(ParseNaturalNumber("123", &char_result));
-  EXPECT_EQ(123, char_result);
-}
-
-# if GTEST_OS_WINDOWS
-TEST(EnvironmentTest, HandleFitsIntoSizeT) {
-  // TODO(vladl@google.com): Remove this test after this condition is verified
-  // in a static assertion in gtest-death-test.cc in the function
-  // GetStatusFileDescriptor.
-  ASSERT_TRUE(sizeof(HANDLE) <= sizeof(size_t));
-}
-# endif  // GTEST_OS_WINDOWS
-
-// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED trigger
-// failures when death tests are available on the system.
-TEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) {
-  EXPECT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestExpectMacro"),
-                            "death inside CondDeathTestExpectMacro");
-  ASSERT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestAssertMacro"),
-                            "death inside CondDeathTestAssertMacro");
-
-  // Empty statement will not crash, which must trigger a failure.
-  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH_IF_SUPPORTED(;, ""), "");
-  EXPECT_FATAL_FAILURE(ASSERT_DEATH_IF_SUPPORTED(;, ""), "");
-}
-
-TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInFastStyle) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
-  EXPECT_FALSE(InDeathTestChild());
-  EXPECT_DEATH({
-    fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
-    fflush(stderr);
-    _exit(1);
-  }, "Inside");
-}
-
-TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeStyle) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
-  EXPECT_FALSE(InDeathTestChild());
-  EXPECT_DEATH({
-    fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
-    fflush(stderr);
-    _exit(1);
-  }, "Inside");
-}
-
-#else  // !GTEST_HAS_DEATH_TEST follows
-
-using testing::internal::CaptureStderr;
-using testing::internal::GetCapturedStderr;
-
-// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED are still
-// defined but do not trigger failures when death tests are not available on
-// the system.
-TEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) {
-  // Empty statement will not crash, but that should not trigger a failure
-  // when death tests are not supported.
-  CaptureStderr();
-  EXPECT_DEATH_IF_SUPPORTED(;, "");
-  std::string output = GetCapturedStderr();
-  ASSERT_TRUE(NULL != strstr(output.c_str(),
-                             "Death tests are not supported on this platform"));
-  ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));
-
-  // The streamed message should not be printed as there is no test failure.
-  CaptureStderr();
-  EXPECT_DEATH_IF_SUPPORTED(;, "") << "streamed message";
-  output = GetCapturedStderr();
-  ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message"));
-
-  CaptureStderr();
-  ASSERT_DEATH_IF_SUPPORTED(;, "");  // NOLINT
-  output = GetCapturedStderr();
-  ASSERT_TRUE(NULL != strstr(output.c_str(),
-                             "Death tests are not supported on this platform"));
-  ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));
-
-  CaptureStderr();
-  ASSERT_DEATH_IF_SUPPORTED(;, "") << "streamed message";  // NOLINT
-  output = GetCapturedStderr();
-  ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message"));
-}
-
-void FuncWithAssert(int* n) {
-  ASSERT_DEATH_IF_SUPPORTED(return;, "");
-  (*n)++;
-}
-
-// Tests that ASSERT_DEATH_IF_SUPPORTED does not return from the current
-// function (as ASSERT_DEATH does) if death tests are not supported.
-TEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) {
-  int n = 0;
-  FuncWithAssert(&n);
-  EXPECT_EQ(1, n);
-}
-
-#endif  // !GTEST_HAS_DEATH_TEST
-
-// Tests that the death test macros expand to code which may or may not
-// be followed by operator<<, and that in either case the complete text
-// comprises only a single C++ statement.
-//
-// The syntax should work whether death tests are available or not.
-TEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) {
-  if (AlwaysFalse())
-    // This would fail if executed; this is a compilation test only
-    ASSERT_DEATH_IF_SUPPORTED(return, "");
-
-  if (AlwaysTrue())
-    EXPECT_DEATH_IF_SUPPORTED(_exit(1), "");
-  else
-    // This empty "else" branch is meant to ensure that EXPECT_DEATH
-    // doesn't expand into an "if" statement without an "else"
-    ;  // NOLINT
-
-  if (AlwaysFalse())
-    ASSERT_DEATH_IF_SUPPORTED(return, "") << "did not die";
-
-  if (AlwaysFalse())
-    ;  // NOLINT
-  else
-    EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << 1 << 2 << 3;
-}
-
-// Tests that conditional death test macros expand to code which interacts
-// well with switch statements.
-TEST(ConditionalDeathMacrosSyntaxDeathTest, SwitchStatement) {
-  // Microsoft compiler usually complains about switch statements without
-  // case labels. We suppress that warning for this test.
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4065)
-
-  switch (0)
-    default:
-      ASSERT_DEATH_IF_SUPPORTED(_exit(1), "")
-          << "exit in default switch handler";
-
-  switch (0)
-    case 0:
-      EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case";
-
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-}
-
-// Tests that a test case whose name ends with "DeathTest" works fine
-// on Windows.
-TEST(NotADeathTest, Test) {
-  SUCCEED();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-filepath_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-filepath_test.cc
deleted file mode 100644
index da729869..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-filepath_test.cc
+++ /dev/null
@@ -1,662 +0,0 @@
-// 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.
-//
-// Authors: keith.ray@gmail.com (Keith Ray)
-//
-// Google Test filepath utilities
-//
-// This file tests classes and functions used internally by
-// Google Test.  They are subject to change without notice.
-//
-// This file is #included from gtest_unittest.cc, to avoid changing
-// build or make-files for some existing Google Test clients. Do not
-// #include this file anywhere else!
-
-#include "gtest/internal/gtest-filepath.h"
-#include "gtest/gtest.h"
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick is to
-// prevent a user from accidentally including gtest-internal-inl.h in
-// his code.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-#if GTEST_OS_WINDOWS_MOBILE
-# include <windows.h>  // NOLINT
-#elif GTEST_OS_WINDOWS
-# include <direct.h>  // NOLINT
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-namespace testing {
-namespace internal {
-namespace {
-
-#if GTEST_OS_WINDOWS_MOBILE
-// TODO(wan@google.com): Move these to the POSIX adapter section in
-// gtest-port.h.
-
-// Windows CE doesn't have the remove C function.
-int remove(const char* path) {
-  LPCWSTR wpath = String::AnsiToUtf16(path);
-  int ret = DeleteFile(wpath) ? 0 : -1;
-  delete [] wpath;
-  return ret;
-}
-// Windows CE doesn't have the _rmdir C function.
-int _rmdir(const char* path) {
-  FilePath filepath(path);
-  LPCWSTR wpath = String::AnsiToUtf16(
-      filepath.RemoveTrailingPathSeparator().c_str());
-  int ret = RemoveDirectory(wpath) ? 0 : -1;
-  delete [] wpath;
-  return ret;
-}
-
-#else
-
-TEST(GetCurrentDirTest, ReturnsCurrentDir) {
-  const FilePath original_dir = FilePath::GetCurrentDir();
-  EXPECT_FALSE(original_dir.IsEmpty());
-
-  posix::ChDir(GTEST_PATH_SEP_);
-  const FilePath cwd = FilePath::GetCurrentDir();
-  posix::ChDir(original_dir.c_str());
-
-# if GTEST_OS_WINDOWS
-
-  // Skips the ":".
-  const char* const cwd_without_drive = strchr(cwd.c_str(), ':');
-  ASSERT_TRUE(cwd_without_drive != NULL);
-  EXPECT_STREQ(GTEST_PATH_SEP_, cwd_without_drive + 1);
-
-# else
-
-  EXPECT_EQ(GTEST_PATH_SEP_, cwd.string());
-
-# endif
-}
-
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-TEST(IsEmptyTest, ReturnsTrueForEmptyPath) {
-  EXPECT_TRUE(FilePath("").IsEmpty());
-}
-
-TEST(IsEmptyTest, ReturnsFalseForNonEmptyPath) {
-  EXPECT_FALSE(FilePath("a").IsEmpty());
-  EXPECT_FALSE(FilePath(".").IsEmpty());
-  EXPECT_FALSE(FilePath("a/b").IsEmpty());
-  EXPECT_FALSE(FilePath("a\\b\\").IsEmpty());
-}
-
-// RemoveDirectoryName "" -> ""
-TEST(RemoveDirectoryNameTest, WhenEmptyName) {
-  EXPECT_EQ("", FilePath("").RemoveDirectoryName().string());
-}
-
-// RemoveDirectoryName "afile" -> "afile"
-TEST(RemoveDirectoryNameTest, ButNoDirectory) {
-  EXPECT_EQ("afile",
-      FilePath("afile").RemoveDirectoryName().string());
-}
-
-// RemoveDirectoryName "/afile" -> "afile"
-TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileName) {
-  EXPECT_EQ("afile",
-      FilePath(GTEST_PATH_SEP_ "afile").RemoveDirectoryName().string());
-}
-
-// RemoveDirectoryName "adir/" -> ""
-TEST(RemoveDirectoryNameTest, WhereThereIsNoFileName) {
-  EXPECT_EQ("",
-      FilePath("adir" GTEST_PATH_SEP_).RemoveDirectoryName().string());
-}
-
-// RemoveDirectoryName "adir/afile" -> "afile"
-TEST(RemoveDirectoryNameTest, ShouldGiveFileName) {
-  EXPECT_EQ("afile",
-      FilePath("adir" GTEST_PATH_SEP_ "afile").RemoveDirectoryName().string());
-}
-
-// RemoveDirectoryName "adir/subdir/afile" -> "afile"
-TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileName) {
-  EXPECT_EQ("afile",
-      FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
-      .RemoveDirectoryName().string());
-}
-
-#if GTEST_HAS_ALT_PATH_SEP_
-
-// Tests that RemoveDirectoryName() works with the alternate separator
-// on Windows.
-
-// RemoveDirectoryName("/afile") -> "afile"
-TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileNameForAlternateSeparator) {
-  EXPECT_EQ("afile", FilePath("/afile").RemoveDirectoryName().string());
-}
-
-// RemoveDirectoryName("adir/") -> ""
-TEST(RemoveDirectoryNameTest, WhereThereIsNoFileNameForAlternateSeparator) {
-  EXPECT_EQ("", FilePath("adir/").RemoveDirectoryName().string());
-}
-
-// RemoveDirectoryName("adir/afile") -> "afile"
-TEST(RemoveDirectoryNameTest, ShouldGiveFileNameForAlternateSeparator) {
-  EXPECT_EQ("afile", FilePath("adir/afile").RemoveDirectoryName().string());
-}
-
-// RemoveDirectoryName("adir/subdir/afile") -> "afile"
-TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileNameForAlternateSeparator) {
-  EXPECT_EQ("afile",
-            FilePath("adir/subdir/afile").RemoveDirectoryName().string());
-}
-
-#endif
-
-// RemoveFileName "" -> "./"
-TEST(RemoveFileNameTest, EmptyName) {
-#if GTEST_OS_WINDOWS_MOBILE
-  // On Windows CE, we use the root as the current directory.
-  EXPECT_EQ(GTEST_PATH_SEP_, FilePath("").RemoveFileName().string());
-#else
-  EXPECT_EQ("." GTEST_PATH_SEP_, FilePath("").RemoveFileName().string());
-#endif
-}
-
-// RemoveFileName "adir/" -> "adir/"
-TEST(RemoveFileNameTest, ButNoFile) {
-  EXPECT_EQ("adir" GTEST_PATH_SEP_,
-      FilePath("adir" GTEST_PATH_SEP_).RemoveFileName().string());
-}
-
-// RemoveFileName "adir/afile" -> "adir/"
-TEST(RemoveFileNameTest, GivesDirName) {
-  EXPECT_EQ("adir" GTEST_PATH_SEP_,
-            FilePath("adir" GTEST_PATH_SEP_ "afile").RemoveFileName().string());
-}
-
-// RemoveFileName "adir/subdir/afile" -> "adir/subdir/"
-TEST(RemoveFileNameTest, GivesDirAndSubDirName) {
-  EXPECT_EQ("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_,
-      FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
-      .RemoveFileName().string());
-}
-
-// RemoveFileName "/afile" -> "/"
-TEST(RemoveFileNameTest, GivesRootDir) {
-  EXPECT_EQ(GTEST_PATH_SEP_,
-      FilePath(GTEST_PATH_SEP_ "afile").RemoveFileName().string());
-}
-
-#if GTEST_HAS_ALT_PATH_SEP_
-
-// Tests that RemoveFileName() works with the alternate separator on
-// Windows.
-
-// RemoveFileName("adir/") -> "adir/"
-TEST(RemoveFileNameTest, ButNoFileForAlternateSeparator) {
-  EXPECT_EQ("adir" GTEST_PATH_SEP_,
-            FilePath("adir/").RemoveFileName().string());
-}
-
-// RemoveFileName("adir/afile") -> "adir/"
-TEST(RemoveFileNameTest, GivesDirNameForAlternateSeparator) {
-  EXPECT_EQ("adir" GTEST_PATH_SEP_,
-            FilePath("adir/afile").RemoveFileName().string());
-}
-
-// RemoveFileName("adir/subdir/afile") -> "adir/subdir/"
-TEST(RemoveFileNameTest, GivesDirAndSubDirNameForAlternateSeparator) {
-  EXPECT_EQ("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_,
-            FilePath("adir/subdir/afile").RemoveFileName().string());
-}
-
-// RemoveFileName("/afile") -> "\"
-TEST(RemoveFileNameTest, GivesRootDirForAlternateSeparator) {
-  EXPECT_EQ(GTEST_PATH_SEP_, FilePath("/afile").RemoveFileName().string());
-}
-
-#endif
-
-TEST(MakeFileNameTest, GenerateWhenNumberIsZero) {
-  FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
-      0, "xml");
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
-}
-
-TEST(MakeFileNameTest, GenerateFileNameNumberGtZero) {
-  FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
-      12, "xml");
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.string());
-}
-
-TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberIsZero) {
-  FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
-      FilePath("bar"), 0, "xml");
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
-}
-
-TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberGtZero) {
-  FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
-      FilePath("bar"), 12, "xml");
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.string());
-}
-
-TEST(MakeFileNameTest, GenerateWhenNumberIsZeroAndDirIsEmpty) {
-  FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),
-      0, "xml");
-  EXPECT_EQ("bar.xml", actual.string());
-}
-
-TEST(MakeFileNameTest, GenerateWhenNumberIsNotZeroAndDirIsEmpty) {
-  FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),
-      14, "xml");
-  EXPECT_EQ("bar_14.xml", actual.string());
-}
-
-TEST(ConcatPathsTest, WorksWhenDirDoesNotEndWithPathSep) {
-  FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
-                                          FilePath("bar.xml"));
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
-}
-
-TEST(ConcatPathsTest, WorksWhenPath1EndsWithPathSep) {
-  FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_),
-                                          FilePath("bar.xml"));
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
-}
-
-TEST(ConcatPathsTest, Path1BeingEmpty) {
-  FilePath actual = FilePath::ConcatPaths(FilePath(""),
-                                          FilePath("bar.xml"));
-  EXPECT_EQ("bar.xml", actual.string());
-}
-
-TEST(ConcatPathsTest, Path2BeingEmpty) {
-  FilePath actual = FilePath::ConcatPaths(FilePath("foo"), FilePath(""));
-  EXPECT_EQ("foo" GTEST_PATH_SEP_, actual.string());
-}
-
-TEST(ConcatPathsTest, BothPathBeingEmpty) {
-  FilePath actual = FilePath::ConcatPaths(FilePath(""),
-                                          FilePath(""));
-  EXPECT_EQ("", actual.string());
-}
-
-TEST(ConcatPathsTest, Path1ContainsPathSep) {
-  FilePath actual = FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_ "bar"),
-                                          FilePath("foobar.xml"));
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "foobar.xml",
-            actual.string());
-}
-
-TEST(ConcatPathsTest, Path2ContainsPathSep) {
-  FilePath actual = FilePath::ConcatPaths(
-      FilePath("foo" GTEST_PATH_SEP_),
-      FilePath("bar" GTEST_PATH_SEP_ "bar.xml"));
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "bar.xml",
-            actual.string());
-}
-
-TEST(ConcatPathsTest, Path2EndsWithPathSep) {
-  FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
-                                          FilePath("bar" GTEST_PATH_SEP_));
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_, actual.string());
-}
-
-// RemoveTrailingPathSeparator "" -> ""
-TEST(RemoveTrailingPathSeparatorTest, EmptyString) {
-  EXPECT_EQ("", FilePath("").RemoveTrailingPathSeparator().string());
-}
-
-// RemoveTrailingPathSeparator "foo" -> "foo"
-TEST(RemoveTrailingPathSeparatorTest, FileNoSlashString) {
-  EXPECT_EQ("foo", FilePath("foo").RemoveTrailingPathSeparator().string());
-}
-
-// RemoveTrailingPathSeparator "foo/" -> "foo"
-TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveTrailingSeparator) {
-  EXPECT_EQ("foo",
-      FilePath("foo" GTEST_PATH_SEP_).RemoveTrailingPathSeparator().string());
-#if GTEST_HAS_ALT_PATH_SEP_
-  EXPECT_EQ("foo", FilePath("foo/").RemoveTrailingPathSeparator().string());
-#endif
-}
-
-// RemoveTrailingPathSeparator "foo/bar/" -> "foo/bar/"
-TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveLastSeparator) {
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
-            FilePath("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_)
-                .RemoveTrailingPathSeparator().string());
-}
-
-// RemoveTrailingPathSeparator "foo/bar" -> "foo/bar"
-TEST(RemoveTrailingPathSeparatorTest, ShouldReturnUnmodified) {
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
-            FilePath("foo" GTEST_PATH_SEP_ "bar")
-                .RemoveTrailingPathSeparator().string());
-}
-
-TEST(DirectoryTest, RootDirectoryExists) {
-#if GTEST_OS_WINDOWS  // We are on Windows.
-  char current_drive[_MAX_PATH];  // NOLINT
-  current_drive[0] = static_cast<char>(_getdrive() + 'A' - 1);
-  current_drive[1] = ':';
-  current_drive[2] = '\\';
-  current_drive[3] = '\0';
-  EXPECT_TRUE(FilePath(current_drive).DirectoryExists());
-#else
-  EXPECT_TRUE(FilePath("/").DirectoryExists());
-#endif  // GTEST_OS_WINDOWS
-}
-
-#if GTEST_OS_WINDOWS
-TEST(DirectoryTest, RootOfWrongDriveDoesNotExists) {
-  const int saved_drive_ = _getdrive();
-  // Find a drive that doesn't exist. Start with 'Z' to avoid common ones.
-  for (char drive = 'Z'; drive >= 'A'; drive--)
-    if (_chdrive(drive - 'A' + 1) == -1) {
-      char non_drive[_MAX_PATH];  // NOLINT
-      non_drive[0] = drive;
-      non_drive[1] = ':';
-      non_drive[2] = '\\';
-      non_drive[3] = '\0';
-      EXPECT_FALSE(FilePath(non_drive).DirectoryExists());
-      break;
-    }
-  _chdrive(saved_drive_);
-}
-#endif  // GTEST_OS_WINDOWS
-
-#if !GTEST_OS_WINDOWS_MOBILE
-// Windows CE _does_ consider an empty directory to exist.
-TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) {
-  EXPECT_FALSE(FilePath("").DirectoryExists());
-}
-#endif  // !GTEST_OS_WINDOWS_MOBILE
-
-TEST(DirectoryTest, CurrentDirectoryExists) {
-#if GTEST_OS_WINDOWS  // We are on Windows.
-# ifndef _WIN32_CE  // Windows CE doesn't have a current directory.
-
-  EXPECT_TRUE(FilePath(".").DirectoryExists());
-  EXPECT_TRUE(FilePath(".\\").DirectoryExists());
-
-# endif  // _WIN32_CE
-#else
-  EXPECT_TRUE(FilePath(".").DirectoryExists());
-  EXPECT_TRUE(FilePath("./").DirectoryExists());
-#endif  // GTEST_OS_WINDOWS
-}
-
-// "foo/bar" == foo//bar" == "foo///bar"
-TEST(NormalizeTest, MultipleConsecutiveSepaparatorsInMidstring) {
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
-            FilePath("foo" GTEST_PATH_SEP_ "bar").string());
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
-            FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
-            FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_
-                     GTEST_PATH_SEP_ "bar").string());
-}
-
-// "/bar" == //bar" == "///bar"
-TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringStart) {
-  EXPECT_EQ(GTEST_PATH_SEP_ "bar",
-    FilePath(GTEST_PATH_SEP_ "bar").string());
-  EXPECT_EQ(GTEST_PATH_SEP_ "bar",
-    FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
-  EXPECT_EQ(GTEST_PATH_SEP_ "bar",
-    FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
-}
-
-// "foo/" == foo//" == "foo///"
-TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringEnd) {
-  EXPECT_EQ("foo" GTEST_PATH_SEP_,
-    FilePath("foo" GTEST_PATH_SEP_).string());
-  EXPECT_EQ("foo" GTEST_PATH_SEP_,
-    FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_).string());
-  EXPECT_EQ("foo" GTEST_PATH_SEP_,
-    FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_).string());
-}
-
-#if GTEST_HAS_ALT_PATH_SEP_
-
-// Tests that separators at the end of the string are normalized
-// regardless of their combination (e.g. "foo\" =="foo/\" ==
-// "foo\\/").
-TEST(NormalizeTest, MixAlternateSeparatorAtStringEnd) {
-  EXPECT_EQ("foo" GTEST_PATH_SEP_,
-            FilePath("foo/").string());
-  EXPECT_EQ("foo" GTEST_PATH_SEP_,
-            FilePath("foo" GTEST_PATH_SEP_ "/").string());
-  EXPECT_EQ("foo" GTEST_PATH_SEP_,
-            FilePath("foo//" GTEST_PATH_SEP_).string());
-}
-
-#endif
-
-TEST(AssignmentOperatorTest, DefaultAssignedToNonDefault) {
-  FilePath default_path;
-  FilePath non_default_path("path");
-  non_default_path = default_path;
-  EXPECT_EQ("", non_default_path.string());
-  EXPECT_EQ("", default_path.string());  // RHS var is unchanged.
-}
-
-TEST(AssignmentOperatorTest, NonDefaultAssignedToDefault) {
-  FilePath non_default_path("path");
-  FilePath default_path;
-  default_path = non_default_path;
-  EXPECT_EQ("path", default_path.string());
-  EXPECT_EQ("path", non_default_path.string());  // RHS var is unchanged.
-}
-
-TEST(AssignmentOperatorTest, ConstAssignedToNonConst) {
-  const FilePath const_default_path("const_path");
-  FilePath non_default_path("path");
-  non_default_path = const_default_path;
-  EXPECT_EQ("const_path", non_default_path.string());
-}
-
-class DirectoryCreationTest : public Test {
- protected:
-  virtual void SetUp() {
-    testdata_path_.Set(FilePath(
-        TempDir() + GetCurrentExecutableName().string() +
-        "_directory_creation" GTEST_PATH_SEP_ "test" GTEST_PATH_SEP_));
-    testdata_file_.Set(testdata_path_.RemoveTrailingPathSeparator());
-
-    unique_file0_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
-        0, "txt"));
-    unique_file1_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
-        1, "txt"));
-
-    remove(testdata_file_.c_str());
-    remove(unique_file0_.c_str());
-    remove(unique_file1_.c_str());
-    posix::RmDir(testdata_path_.c_str());
-  }
-
-  virtual void TearDown() {
-    remove(testdata_file_.c_str());
-    remove(unique_file0_.c_str());
-    remove(unique_file1_.c_str());
-    posix::RmDir(testdata_path_.c_str());
-  }
-
-  void CreateTextFile(const char* filename) {
-    FILE* f = posix::FOpen(filename, "w");
-    fprintf(f, "text\n");
-    fclose(f);
-  }
-
-  // Strings representing a directory and a file, with identical paths
-  // except for the trailing separator character that distinquishes
-  // a directory named 'test' from a file named 'test'. Example names:
-  FilePath testdata_path_;  // "/tmp/directory_creation/test/"
-  FilePath testdata_file_;  // "/tmp/directory_creation/test"
-  FilePath unique_file0_;  // "/tmp/directory_creation/test/unique.txt"
-  FilePath unique_file1_;  // "/tmp/directory_creation/test/unique_1.txt"
-};
-
-TEST_F(DirectoryCreationTest, CreateDirectoriesRecursively) {
-  EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.string();
-  EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
-  EXPECT_TRUE(testdata_path_.DirectoryExists());
-}
-
-TEST_F(DirectoryCreationTest, CreateDirectoriesForAlreadyExistingPath) {
-  EXPECT_FALSE(testdata_path_.DirectoryExists()) << testdata_path_.string();
-  EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
-  // Call 'create' again... should still succeed.
-  EXPECT_TRUE(testdata_path_.CreateDirectoriesRecursively());
-}
-
-TEST_F(DirectoryCreationTest, CreateDirectoriesAndUniqueFilename) {
-  FilePath file_path(FilePath::GenerateUniqueFileName(testdata_path_,
-      FilePath("unique"), "txt"));
-  EXPECT_EQ(unique_file0_.string(), file_path.string());
-  EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file not there
-
-  testdata_path_.CreateDirectoriesRecursively();
-  EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file still not there
-  CreateTextFile(file_path.c_str());
-  EXPECT_TRUE(file_path.FileOrDirectoryExists());
-
-  FilePath file_path2(FilePath::GenerateUniqueFileName(testdata_path_,
-      FilePath("unique"), "txt"));
-  EXPECT_EQ(unique_file1_.string(), file_path2.string());
-  EXPECT_FALSE(file_path2.FileOrDirectoryExists());  // file not there
-  CreateTextFile(file_path2.c_str());
-  EXPECT_TRUE(file_path2.FileOrDirectoryExists());
-}
-
-TEST_F(DirectoryCreationTest, CreateDirectoriesFail) {
-  // force a failure by putting a file where we will try to create a directory.
-  CreateTextFile(testdata_file_.c_str());
-  EXPECT_TRUE(testdata_file_.FileOrDirectoryExists());
-  EXPECT_FALSE(testdata_file_.DirectoryExists());
-  EXPECT_FALSE(testdata_file_.CreateDirectoriesRecursively());
-}
-
-TEST(NoDirectoryCreationTest, CreateNoDirectoriesForDefaultXmlFile) {
-  const FilePath test_detail_xml("test_detail.xml");
-  EXPECT_FALSE(test_detail_xml.CreateDirectoriesRecursively());
-}
-
-TEST(FilePathTest, DefaultConstructor) {
-  FilePath fp;
-  EXPECT_EQ("", fp.string());
-}
-
-TEST(FilePathTest, CharAndCopyConstructors) {
-  const FilePath fp("spicy");
-  EXPECT_EQ("spicy", fp.string());
-
-  const FilePath fp_copy(fp);
-  EXPECT_EQ("spicy", fp_copy.string());
-}
-
-TEST(FilePathTest, StringConstructor) {
-  const FilePath fp(std::string("cider"));
-  EXPECT_EQ("cider", fp.string());
-}
-
-TEST(FilePathTest, Set) {
-  const FilePath apple("apple");
-  FilePath mac("mac");
-  mac.Set(apple);  // Implement Set() since overloading operator= is forbidden.
-  EXPECT_EQ("apple", mac.string());
-  EXPECT_EQ("apple", apple.string());
-}
-
-TEST(FilePathTest, ToString) {
-  const FilePath file("drink");
-  EXPECT_EQ("drink", file.string());
-}
-
-TEST(FilePathTest, RemoveExtension) {
-  EXPECT_EQ("app", FilePath("app.cc").RemoveExtension("cc").string());
-  EXPECT_EQ("app", FilePath("app.exe").RemoveExtension("exe").string());
-  EXPECT_EQ("APP", FilePath("APP.EXE").RemoveExtension("exe").string());
-}
-
-TEST(FilePathTest, RemoveExtensionWhenThereIsNoExtension) {
-  EXPECT_EQ("app", FilePath("app").RemoveExtension("exe").string());
-}
-
-TEST(FilePathTest, IsDirectory) {
-  EXPECT_FALSE(FilePath("cola").IsDirectory());
-  EXPECT_TRUE(FilePath("koala" GTEST_PATH_SEP_).IsDirectory());
-#if GTEST_HAS_ALT_PATH_SEP_
-  EXPECT_TRUE(FilePath("koala/").IsDirectory());
-#endif
-}
-
-TEST(FilePathTest, IsAbsolutePath) {
-  EXPECT_FALSE(FilePath("is" GTEST_PATH_SEP_ "relative").IsAbsolutePath());
-  EXPECT_FALSE(FilePath("").IsAbsolutePath());
-#if GTEST_OS_WINDOWS
-  EXPECT_TRUE(FilePath("c:\\" GTEST_PATH_SEP_ "is_not"
-                       GTEST_PATH_SEP_ "relative").IsAbsolutePath());
-  EXPECT_FALSE(FilePath("c:foo" GTEST_PATH_SEP_ "bar").IsAbsolutePath());
-  EXPECT_TRUE(FilePath("c:/" GTEST_PATH_SEP_ "is_not"
-                       GTEST_PATH_SEP_ "relative").IsAbsolutePath());
-#else
-  EXPECT_TRUE(FilePath(GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative")
-              .IsAbsolutePath());
-#endif  // GTEST_OS_WINDOWS
-}
-
-TEST(FilePathTest, IsRootDirectory) {
-#if GTEST_OS_WINDOWS
-  EXPECT_TRUE(FilePath("a:\\").IsRootDirectory());
-  EXPECT_TRUE(FilePath("Z:/").IsRootDirectory());
-  EXPECT_TRUE(FilePath("e://").IsRootDirectory());
-  EXPECT_FALSE(FilePath("").IsRootDirectory());
-  EXPECT_FALSE(FilePath("b:").IsRootDirectory());
-  EXPECT_FALSE(FilePath("b:a").IsRootDirectory());
-  EXPECT_FALSE(FilePath("8:/").IsRootDirectory());
-  EXPECT_FALSE(FilePath("c|/").IsRootDirectory());
-#else
-  EXPECT_TRUE(FilePath("/").IsRootDirectory());
-  EXPECT_TRUE(FilePath("//").IsRootDirectory());
-  EXPECT_FALSE(FilePath("").IsRootDirectory());
-  EXPECT_FALSE(FilePath("\\").IsRootDirectory());
-  EXPECT_FALSE(FilePath("/x").IsRootDirectory());
-#endif
-}
-
-}  // namespace
-}  // namespace internal
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-linked_ptr_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-linked_ptr_test.cc
deleted file mode 100644
index 6fcf5124..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-linked_ptr_test.cc
+++ /dev/null
@@ -1,154 +0,0 @@
-// Copyright 2003, 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.
-//
-// Authors: Dan Egnor (egnor@google.com)
-// Ported to Windows: Vadim Berman (vadimb@google.com)
-
-#include "gtest/internal/gtest-linked_ptr.h"
-
-#include <stdlib.h>
-#include "gtest/gtest.h"
-
-namespace {
-
-using testing::Message;
-using testing::internal::linked_ptr;
-
-int num;
-Message* history = NULL;
-
-// Class which tracks allocation/deallocation
-class A {
- public:
-  A(): mynum(num++) { *history << "A" << mynum << " ctor\n"; }
-  virtual ~A() { *history << "A" << mynum << " dtor\n"; }
-  virtual void Use() { *history << "A" << mynum << " use\n"; }
- protected:
-  int mynum;
-};
-
-// Subclass
-class B : public A {
- public:
-  B() { *history << "B" << mynum << " ctor\n"; }
-  ~B() { *history << "B" << mynum << " dtor\n"; }
-  virtual void Use() { *history << "B" << mynum << " use\n"; }
-};
-
-class LinkedPtrTest : public testing::Test {
- public:
-  LinkedPtrTest() {
-    num = 0;
-    history = new Message;
-  }
-
-  virtual ~LinkedPtrTest() {
-    delete history;
-    history = NULL;
-  }
-};
-
-TEST_F(LinkedPtrTest, GeneralTest) {
-  {
-    linked_ptr<A> a0, a1, a2;
-    // Use explicit function call notation here to suppress self-assign warning.
-    a0.operator=(a0);
-    a1 = a2;
-    ASSERT_EQ(a0.get(), static_cast<A*>(NULL));
-    ASSERT_EQ(a1.get(), static_cast<A*>(NULL));
-    ASSERT_EQ(a2.get(), static_cast<A*>(NULL));
-    ASSERT_TRUE(a0 == NULL);
-    ASSERT_TRUE(a1 == NULL);
-    ASSERT_TRUE(a2 == NULL);
-
-    {
-      linked_ptr<A> a3(new A);
-      a0 = a3;
-      ASSERT_TRUE(a0 == a3);
-      ASSERT_TRUE(a0 != NULL);
-      ASSERT_TRUE(a0.get() == a3);
-      ASSERT_TRUE(a0 == a3.get());
-      linked_ptr<A> a4(a0);
-      a1 = a4;
-      linked_ptr<A> a5(new A);
-      ASSERT_TRUE(a5.get() != a3);
-      ASSERT_TRUE(a5 != a3.get());
-      a2 = a5;
-      linked_ptr<B> b0(new B);
-      linked_ptr<A> a6(b0);
-      ASSERT_TRUE(b0 == a6);
-      ASSERT_TRUE(a6 == b0);
-      ASSERT_TRUE(b0 != NULL);
-      a5 = b0;
-      a5 = b0;
-      a3->Use();
-      a4->Use();
-      a5->Use();
-      a6->Use();
-      b0->Use();
-      (*b0).Use();
-      b0.get()->Use();
-    }
-
-    a0->Use();
-    a1->Use();
-    a2->Use();
-
-    a1 = a2;
-    a2.reset(new A);
-    a0.reset();
-
-    linked_ptr<A> a7;
-  }
-
-  ASSERT_STREQ(
-    "A0 ctor\n"
-    "A1 ctor\n"
-    "A2 ctor\n"
-    "B2 ctor\n"
-    "A0 use\n"
-    "A0 use\n"
-    "B2 use\n"
-    "B2 use\n"
-    "B2 use\n"
-    "B2 use\n"
-    "B2 use\n"
-    "B2 dtor\n"
-    "A2 dtor\n"
-    "A0 use\n"
-    "A0 use\n"
-    "A1 use\n"
-    "A3 ctor\n"
-    "A0 dtor\n"
-    "A3 dtor\n"
-    "A1 dtor\n",
-    history->GetString().c_str());
-}
-
-}  // Unnamed namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-listener_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-listener_test.cc
deleted file mode 100644
index 90747685..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-listener_test.cc
+++ /dev/null
@@ -1,311 +0,0 @@
-// Copyright 2009 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This file verifies Google Test event listeners receive events at the
-// right times.
-
-#include "gtest/gtest.h"
-#include <vector>
-
-using ::testing::AddGlobalTestEnvironment;
-using ::testing::Environment;
-using ::testing::InitGoogleTest;
-using ::testing::Test;
-using ::testing::TestCase;
-using ::testing::TestEventListener;
-using ::testing::TestInfo;
-using ::testing::TestPartResult;
-using ::testing::UnitTest;
-
-// Used by tests to register their events.
-std::vector<std::string>* g_events = NULL;
-
-namespace testing {
-namespace internal {
-
-class EventRecordingListener : public TestEventListener {
- public:
-  explicit EventRecordingListener(const char* name) : name_(name) {}
-
- protected:
-  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
-    g_events->push_back(GetFullMethodName("OnTestProgramStart"));
-  }
-
-  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
-                                    int iteration) {
-    Message message;
-    message << GetFullMethodName("OnTestIterationStart")
-            << "(" << iteration << ")";
-    g_events->push_back(message.GetString());
-  }
-
-  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {
-    g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpStart"));
-  }
-
-  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {
-    g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpEnd"));
-  }
-
-  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {
-    g_events->push_back(GetFullMethodName("OnTestCaseStart"));
-  }
-
-  virtual void OnTestStart(const TestInfo& /*test_info*/) {
-    g_events->push_back(GetFullMethodName("OnTestStart"));
-  }
-
-  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {
-    g_events->push_back(GetFullMethodName("OnTestPartResult"));
-  }
-
-  virtual void OnTestEnd(const TestInfo& /*test_info*/) {
-    g_events->push_back(GetFullMethodName("OnTestEnd"));
-  }
-
-  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {
-    g_events->push_back(GetFullMethodName("OnTestCaseEnd"));
-  }
-
-  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {
-    g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownStart"));
-  }
-
-  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {
-    g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownEnd"));
-  }
-
-  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
-                                  int iteration) {
-    Message message;
-    message << GetFullMethodName("OnTestIterationEnd")
-            << "("  << iteration << ")";
-    g_events->push_back(message.GetString());
-  }
-
-  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
-    g_events->push_back(GetFullMethodName("OnTestProgramEnd"));
-  }
-
- private:
-  std::string GetFullMethodName(const char* name) {
-    return name_ + "." + name;
-  }
-
-  std::string name_;
-};
-
-class EnvironmentInvocationCatcher : public Environment {
- protected:
-  virtual void SetUp() {
-    g_events->push_back("Environment::SetUp");
-  }
-
-  virtual void TearDown() {
-    g_events->push_back("Environment::TearDown");
-  }
-};
-
-class ListenerTest : public Test {
- protected:
-  static void SetUpTestCase() {
-    g_events->push_back("ListenerTest::SetUpTestCase");
-  }
-
-  static void TearDownTestCase() {
-    g_events->push_back("ListenerTest::TearDownTestCase");
-  }
-
-  virtual void SetUp() {
-    g_events->push_back("ListenerTest::SetUp");
-  }
-
-  virtual void TearDown() {
-    g_events->push_back("ListenerTest::TearDown");
-  }
-};
-
-TEST_F(ListenerTest, DoesFoo) {
-  // Test execution order within a test case is not guaranteed so we are not
-  // recording the test name.
-  g_events->push_back("ListenerTest::* Test Body");
-  SUCCEED();  // Triggers OnTestPartResult.
-}
-
-TEST_F(ListenerTest, DoesBar) {
-  g_events->push_back("ListenerTest::* Test Body");
-  SUCCEED();  // Triggers OnTestPartResult.
-}
-
-}  // namespace internal
-
-}  // namespace testing
-
-using ::testing::internal::EnvironmentInvocationCatcher;
-using ::testing::internal::EventRecordingListener;
-
-void VerifyResults(const std::vector<std::string>& data,
-                   const char* const* expected_data,
-                   size_t expected_data_size) {
-  const size_t actual_size = data.size();
-  // If the following assertion fails, a new entry will be appended to
-  // data.  Hence we save data.size() first.
-  EXPECT_EQ(expected_data_size, actual_size);
-
-  // Compares the common prefix.
-  const size_t shorter_size = expected_data_size <= actual_size ?
-      expected_data_size : actual_size;
-  size_t i = 0;
-  for (; i < shorter_size; ++i) {
-    ASSERT_STREQ(expected_data[i], data[i].c_str())
-        << "at position " << i;
-  }
-
-  // Prints extra elements in the actual data.
-  for (; i < actual_size; ++i) {
-    printf("  Actual event #%lu: %s\n",
-        static_cast<unsigned long>(i), data[i].c_str());
-  }
-}
-
-int main(int argc, char **argv) {
-  std::vector<std::string> events;
-  g_events = &events;
-  InitGoogleTest(&argc, argv);
-
-  UnitTest::GetInstance()->listeners().Append(
-      new EventRecordingListener("1st"));
-  UnitTest::GetInstance()->listeners().Append(
-      new EventRecordingListener("2nd"));
-
-  AddGlobalTestEnvironment(new EnvironmentInvocationCatcher);
-
-  GTEST_CHECK_(events.size() == 0)
-      << "AddGlobalTestEnvironment should not generate any events itself.";
-
-  ::testing::GTEST_FLAG(repeat) = 2;
-  int ret_val = RUN_ALL_TESTS();
-
-  const char* const expected_events[] = {
-    "1st.OnTestProgramStart",
-    "2nd.OnTestProgramStart",
-    "1st.OnTestIterationStart(0)",
-    "2nd.OnTestIterationStart(0)",
-    "1st.OnEnvironmentsSetUpStart",
-    "2nd.OnEnvironmentsSetUpStart",
-    "Environment::SetUp",
-    "2nd.OnEnvironmentsSetUpEnd",
-    "1st.OnEnvironmentsSetUpEnd",
-    "1st.OnTestCaseStart",
-    "2nd.OnTestCaseStart",
-    "ListenerTest::SetUpTestCase",
-    "1st.OnTestStart",
-    "2nd.OnTestStart",
-    "ListenerTest::SetUp",
-    "ListenerTest::* Test Body",
-    "1st.OnTestPartResult",
-    "2nd.OnTestPartResult",
-    "ListenerTest::TearDown",
-    "2nd.OnTestEnd",
-    "1st.OnTestEnd",
-    "1st.OnTestStart",
-    "2nd.OnTestStart",
-    "ListenerTest::SetUp",
-    "ListenerTest::* Test Body",
-    "1st.OnTestPartResult",
-    "2nd.OnTestPartResult",
-    "ListenerTest::TearDown",
-    "2nd.OnTestEnd",
-    "1st.OnTestEnd",
-    "ListenerTest::TearDownTestCase",
-    "2nd.OnTestCaseEnd",
-    "1st.OnTestCaseEnd",
-    "1st.OnEnvironmentsTearDownStart",
-    "2nd.OnEnvironmentsTearDownStart",
-    "Environment::TearDown",
-    "2nd.OnEnvironmentsTearDownEnd",
-    "1st.OnEnvironmentsTearDownEnd",
-    "2nd.OnTestIterationEnd(0)",
-    "1st.OnTestIterationEnd(0)",
-    "1st.OnTestIterationStart(1)",
-    "2nd.OnTestIterationStart(1)",
-    "1st.OnEnvironmentsSetUpStart",
-    "2nd.OnEnvironmentsSetUpStart",
-    "Environment::SetUp",
-    "2nd.OnEnvironmentsSetUpEnd",
-    "1st.OnEnvironmentsSetUpEnd",
-    "1st.OnTestCaseStart",
-    "2nd.OnTestCaseStart",
-    "ListenerTest::SetUpTestCase",
-    "1st.OnTestStart",
-    "2nd.OnTestStart",
-    "ListenerTest::SetUp",
-    "ListenerTest::* Test Body",
-    "1st.OnTestPartResult",
-    "2nd.OnTestPartResult",
-    "ListenerTest::TearDown",
-    "2nd.OnTestEnd",
-    "1st.OnTestEnd",
-    "1st.OnTestStart",
-    "2nd.OnTestStart",
-    "ListenerTest::SetUp",
-    "ListenerTest::* Test Body",
-    "1st.OnTestPartResult",
-    "2nd.OnTestPartResult",
-    "ListenerTest::TearDown",
-    "2nd.OnTestEnd",
-    "1st.OnTestEnd",
-    "ListenerTest::TearDownTestCase",
-    "2nd.OnTestCaseEnd",
-    "1st.OnTestCaseEnd",
-    "1st.OnEnvironmentsTearDownStart",
-    "2nd.OnEnvironmentsTearDownStart",
-    "Environment::TearDown",
-    "2nd.OnEnvironmentsTearDownEnd",
-    "1st.OnEnvironmentsTearDownEnd",
-    "2nd.OnTestIterationEnd(1)",
-    "1st.OnTestIterationEnd(1)",
-    "2nd.OnTestProgramEnd",
-    "1st.OnTestProgramEnd"
-  };
-  VerifyResults(events,
-                expected_events,
-                sizeof(expected_events)/sizeof(expected_events[0]));
-
-  // We need to check manually for ad hoc test failures that happen after
-  // RUN_ALL_TESTS finishes.
-  if (UnitTest::GetInstance()->Failed())
-    ret_val = 1;
-
-  return ret_val;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-message_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-message_test.cc
deleted file mode 100644
index 175238ef..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-message_test.cc
+++ /dev/null
@@ -1,159 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Tests for the Message class.
-
-#include "gtest/gtest-message.h"
-
-#include "gtest/gtest.h"
-
-namespace {
-
-using ::testing::Message;
-
-// Tests the testing::Message class
-
-// Tests the default constructor.
-TEST(MessageTest, DefaultConstructor) {
-  const Message msg;
-  EXPECT_EQ("", msg.GetString());
-}
-
-// Tests the copy constructor.
-TEST(MessageTest, CopyConstructor) {
-  const Message msg1("Hello");
-  const Message msg2(msg1);
-  EXPECT_EQ("Hello", msg2.GetString());
-}
-
-// Tests constructing a Message from a C-string.
-TEST(MessageTest, ConstructsFromCString) {
-  Message msg("Hello");
-  EXPECT_EQ("Hello", msg.GetString());
-}
-
-// Tests streaming a float.
-TEST(MessageTest, StreamsFloat) {
-  const std::string s = (Message() << 1.23456F << " " << 2.34567F).GetString();
-  // Both numbers should be printed with enough precision.
-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "1.234560", s.c_str());
-  EXPECT_PRED_FORMAT2(testing::IsSubstring, " 2.345669", s.c_str());
-}
-
-// Tests streaming a double.
-TEST(MessageTest, StreamsDouble) {
-  const std::string s = (Message() << 1260570880.4555497 << " "
-                                  << 1260572265.1954534).GetString();
-  // Both numbers should be printed with enough precision.
-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "1260570880.45", s.c_str());
-  EXPECT_PRED_FORMAT2(testing::IsSubstring, " 1260572265.19", s.c_str());
-}
-
-// Tests streaming a non-char pointer.
-TEST(MessageTest, StreamsPointer) {
-  int n = 0;
-  int* p = &n;
-  EXPECT_NE("(null)", (Message() << p).GetString());
-}
-
-// Tests streaming a NULL non-char pointer.
-TEST(MessageTest, StreamsNullPointer) {
-  int* p = NULL;
-  EXPECT_EQ("(null)", (Message() << p).GetString());
-}
-
-// Tests streaming a C string.
-TEST(MessageTest, StreamsCString) {
-  EXPECT_EQ("Foo", (Message() << "Foo").GetString());
-}
-
-// Tests streaming a NULL C string.
-TEST(MessageTest, StreamsNullCString) {
-  char* p = NULL;
-  EXPECT_EQ("(null)", (Message() << p).GetString());
-}
-
-// Tests streaming std::string.
-TEST(MessageTest, StreamsString) {
-  const ::std::string str("Hello");
-  EXPECT_EQ("Hello", (Message() << str).GetString());
-}
-
-// Tests that we can output strings containing embedded NULs.
-TEST(MessageTest, StreamsStringWithEmbeddedNUL) {
-  const char char_array_with_nul[] =
-      "Here's a NUL\0 and some more string";
-  const ::std::string string_with_nul(char_array_with_nul,
-                                      sizeof(char_array_with_nul) - 1);
-  EXPECT_EQ("Here's a NUL\\0 and some more string",
-            (Message() << string_with_nul).GetString());
-}
-
-// Tests streaming a NUL char.
-TEST(MessageTest, StreamsNULChar) {
-  EXPECT_EQ("\\0", (Message() << '\0').GetString());
-}
-
-// Tests streaming int.
-TEST(MessageTest, StreamsInt) {
-  EXPECT_EQ("123", (Message() << 123).GetString());
-}
-
-// Tests that basic IO manipulators (endl, ends, and flush) can be
-// streamed to Message.
-TEST(MessageTest, StreamsBasicIoManip) {
-  EXPECT_EQ("Line 1.\nA NUL char \\0 in line 2.",
-               (Message() << "Line 1." << std::endl
-                         << "A NUL char " << std::ends << std::flush
-                         << " in line 2.").GetString());
-}
-
-// Tests Message::GetString()
-TEST(MessageTest, GetString) {
-  Message msg;
-  msg << 1 << " lamb";
-  EXPECT_EQ("1 lamb", msg.GetString());
-}
-
-// Tests streaming a Message object to an ostream.
-TEST(MessageTest, StreamsToOStream) {
-  Message msg("Hello");
-  ::std::stringstream ss;
-  ss << msg;
-  EXPECT_EQ("Hello", testing::internal::StringStreamToString(&ss));
-}
-
-// Tests that a Message object doesn't take up too much stack space.
-TEST(MessageTest, DoesNotTakeUpMuchStackSpace) {
-  EXPECT_LE(sizeof(Message), 16U);
-}
-
-}  // namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-options_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-options_test.cc
deleted file mode 100644
index 5586dc3b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-options_test.cc
+++ /dev/null
@@ -1,215 +0,0 @@
-// 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.
-//
-// Authors: keith.ray@gmail.com (Keith Ray)
-//
-// Google Test UnitTestOptions tests
-//
-// This file tests classes and functions used internally by
-// Google Test.  They are subject to change without notice.
-//
-// This file is #included from gtest.cc, to avoid changing build or
-// make-files on Windows and other platforms. Do not #include this file
-// anywhere else!
-
-#include "gtest/gtest.h"
-
-#if GTEST_OS_WINDOWS_MOBILE
-# include <windows.h>
-#elif GTEST_OS_WINDOWS
-# include <direct.h>
-#endif  // GTEST_OS_WINDOWS_MOBILE
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick is to
-// prevent a user from accidentally including gtest-internal-inl.h in
-// his code.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-namespace testing {
-namespace internal {
-namespace {
-
-// Turns the given relative path into an absolute path.
-FilePath GetAbsolutePathOf(const FilePath& relative_path) {
-  return FilePath::ConcatPaths(FilePath::GetCurrentDir(), relative_path);
-}
-
-// Testing UnitTestOptions::GetOutputFormat/GetOutputFile.
-
-TEST(XmlOutputTest, GetOutputFormatDefault) {
-  GTEST_FLAG(output) = "";
-  EXPECT_STREQ("", UnitTestOptions::GetOutputFormat().c_str());
-}
-
-TEST(XmlOutputTest, GetOutputFormat) {
-  GTEST_FLAG(output) = "xml:filename";
-  EXPECT_STREQ("xml", UnitTestOptions::GetOutputFormat().c_str());
-}
-
-TEST(XmlOutputTest, GetOutputFileDefault) {
-  GTEST_FLAG(output) = "";
-  EXPECT_EQ(GetAbsolutePathOf(FilePath("test_detail.xml")).string(),
-            UnitTestOptions::GetAbsolutePathToOutputFile());
-}
-
-TEST(XmlOutputTest, GetOutputFileSingleFile) {
-  GTEST_FLAG(output) = "xml:filename.abc";
-  EXPECT_EQ(GetAbsolutePathOf(FilePath("filename.abc")).string(),
-            UnitTestOptions::GetAbsolutePathToOutputFile());
-}
-
-TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) {
-  GTEST_FLAG(output) = "xml:path" GTEST_PATH_SEP_;
-  const std::string expected_output_file =
-      GetAbsolutePathOf(
-          FilePath(std::string("path") + GTEST_PATH_SEP_ +
-                   GetCurrentExecutableName().string() + ".xml")).string();
-  const std::string& output_file =
-      UnitTestOptions::GetAbsolutePathToOutputFile();
-#if GTEST_OS_WINDOWS
-  EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
-#else
-  EXPECT_EQ(expected_output_file, output_file.c_str());
-#endif
-}
-
-TEST(OutputFileHelpersTest, GetCurrentExecutableName) {
-  const std::string exe_str = GetCurrentExecutableName().string();
-#if GTEST_OS_WINDOWS
-  const bool success =
-      _strcmpi("gtest-options_test", exe_str.c_str()) == 0 ||
-      _strcmpi("gtest-options-ex_test", exe_str.c_str()) == 0 ||
-      _strcmpi("gtest_all_test", exe_str.c_str()) == 0 ||
-      _strcmpi("gtest_dll_test", exe_str.c_str()) == 0;
-#else
-  // TODO(wan@google.com): remove the hard-coded "lt-" prefix when
-  //   Chandler Carruth's libtool replacement is ready.
-  const bool success =
-      exe_str == "gtest-options_test" ||
-      exe_str == "gtest_all_test" ||
-      exe_str == "lt-gtest_all_test" ||
-      exe_str == "gtest_dll_test";
-#endif  // GTEST_OS_WINDOWS
-  if (!success)
-    FAIL() << "GetCurrentExecutableName() returns " << exe_str;
-}
-
-class XmlOutputChangeDirTest : public Test {
- protected:
-  virtual void SetUp() {
-    original_working_dir_ = FilePath::GetCurrentDir();
-    posix::ChDir("..");
-    // This will make the test fail if run from the root directory.
-    EXPECT_NE(original_working_dir_.string(),
-              FilePath::GetCurrentDir().string());
-  }
-
-  virtual void TearDown() {
-    posix::ChDir(original_working_dir_.string().c_str());
-  }
-
-  FilePath original_working_dir_;
-};
-
-TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefault) {
-  GTEST_FLAG(output) = "";
-  EXPECT_EQ(FilePath::ConcatPaths(original_working_dir_,
-                                  FilePath("test_detail.xml")).string(),
-            UnitTestOptions::GetAbsolutePathToOutputFile());
-}
-
-TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefaultXML) {
-  GTEST_FLAG(output) = "xml";
-  EXPECT_EQ(FilePath::ConcatPaths(original_working_dir_,
-                                  FilePath("test_detail.xml")).string(),
-            UnitTestOptions::GetAbsolutePathToOutputFile());
-}
-
-TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativeFile) {
-  GTEST_FLAG(output) = "xml:filename.abc";
-  EXPECT_EQ(FilePath::ConcatPaths(original_working_dir_,
-                                  FilePath("filename.abc")).string(),
-            UnitTestOptions::GetAbsolutePathToOutputFile());
-}
-
-TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) {
-  GTEST_FLAG(output) = "xml:path" GTEST_PATH_SEP_;
-  const std::string expected_output_file =
-      FilePath::ConcatPaths(
-          original_working_dir_,
-          FilePath(std::string("path") + GTEST_PATH_SEP_ +
-                   GetCurrentExecutableName().string() + ".xml")).string();
-  const std::string& output_file =
-      UnitTestOptions::GetAbsolutePathToOutputFile();
-#if GTEST_OS_WINDOWS
-  EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
-#else
-  EXPECT_EQ(expected_output_file, output_file.c_str());
-#endif
-}
-
-TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) {
-#if GTEST_OS_WINDOWS
-  GTEST_FLAG(output) = "xml:c:\\tmp\\filename.abc";
-  EXPECT_EQ(FilePath("c:\\tmp\\filename.abc").string(),
-            UnitTestOptions::GetAbsolutePathToOutputFile());
-#else
-  GTEST_FLAG(output) ="xml:/tmp/filename.abc";
-  EXPECT_EQ(FilePath("/tmp/filename.abc").string(),
-            UnitTestOptions::GetAbsolutePathToOutputFile());
-#endif
-}
-
-TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsolutePath) {
-#if GTEST_OS_WINDOWS
-  const std::string path = "c:\\tmp\\";
-#else
-  const std::string path = "/tmp/";
-#endif
-
-  GTEST_FLAG(output) = "xml:" + path;
-  const std::string expected_output_file =
-      path + GetCurrentExecutableName().string() + ".xml";
-  const std::string& output_file =
-      UnitTestOptions::GetAbsolutePathToOutputFile();
-
-#if GTEST_OS_WINDOWS
-  EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
-#else
-  EXPECT_EQ(expected_output_file, output_file.c_str());
-#endif
-}
-
-}  // namespace
-}  // namespace internal
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test2_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test2_test.cc
deleted file mode 100644
index 4a782fe7..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test2_test.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-// 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-//
-// Tests for Google Test itself.  This verifies that the basic constructs of
-// Google Test work.
-
-#include "gtest/gtest.h"
-
-#include "test/gtest-param-test_test.h"
-
-#if GTEST_HAS_PARAM_TEST
-
-using ::testing::Values;
-using ::testing::internal::ParamGenerator;
-
-// Tests that generators defined in a different translation unit
-// are functional. The test using extern_gen is defined
-// in gtest-param-test_test.cc.
-ParamGenerator<int> extern_gen = Values(33);
-
-// Tests that a parameterized test case can be defined in one translation unit
-// and instantiated in another. The test is defined in gtest-param-test_test.cc
-// and ExternalInstantiationTest fixture class is defined in
-// gtest-param-test_test.h.
-INSTANTIATE_TEST_CASE_P(MultiplesOf33,
-                        ExternalInstantiationTest,
-                        Values(33, 66));
-
-// Tests that a parameterized test case can be instantiated
-// in multiple translation units. Another instantiation is defined
-// in gtest-param-test_test.cc and InstantiationInMultipleTranslaionUnitsTest
-// fixture is defined in gtest-param-test_test.h
-INSTANTIATE_TEST_CASE_P(Sequence2,
-                        InstantiationInMultipleTranslaionUnitsTest,
-                        Values(42*3, 42*4, 42*5));
-
-#endif  // GTEST_HAS_PARAM_TEST
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.cc
deleted file mode 100644
index 8b278bb9..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.cc
+++ /dev/null
@@ -1,1055 +0,0 @@
-// 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-//
-// Tests for Google Test itself. This file verifies that the parameter
-// generators objects produce correct parameter sequences and that
-// Google Test runtime instantiates correct tests from those sequences.
-
-#include "gtest/gtest.h"
-
-#if GTEST_HAS_PARAM_TEST
-
-# include <algorithm>
-# include <iostream>
-# include <list>
-# include <sstream>
-# include <string>
-# include <vector>
-
-// To include gtest-internal-inl.h.
-# define GTEST_IMPLEMENTATION_ 1
-# include "src/gtest-internal-inl.h"  // for UnitTestOptions
-# undef GTEST_IMPLEMENTATION_
-
-# include "test/gtest-param-test_test.h"
-
-using ::std::vector;
-using ::std::sort;
-
-using ::testing::AddGlobalTestEnvironment;
-using ::testing::Bool;
-using ::testing::Message;
-using ::testing::Range;
-using ::testing::TestWithParam;
-using ::testing::Values;
-using ::testing::ValuesIn;
-
-# if GTEST_HAS_COMBINE
-using ::testing::Combine;
-using ::testing::get;
-using ::testing::make_tuple;
-using ::testing::tuple;
-# endif  // GTEST_HAS_COMBINE
-
-using ::testing::internal::ParamGenerator;
-using ::testing::internal::UnitTestOptions;
-
-// Prints a value to a string.
-//
-// TODO(wan@google.com): remove PrintValue() when we move matchers and
-// EXPECT_THAT() from Google Mock to Google Test.  At that time, we
-// can write EXPECT_THAT(x, Eq(y)) to compare two tuples x and y, as
-// EXPECT_THAT() and the matchers know how to print tuples.
-template <typename T>
-::std::string PrintValue(const T& value) {
-  ::std::stringstream stream;
-  stream << value;
-  return stream.str();
-}
-
-# if GTEST_HAS_COMBINE
-
-// These overloads allow printing tuples in our tests.  We cannot
-// define an operator<< for tuples, as that definition needs to be in
-// the std namespace in order to be picked up by Google Test via
-// Argument-Dependent Lookup, yet defining anything in the std
-// namespace in non-STL code is undefined behavior.
-
-template <typename T1, typename T2>
-::std::string PrintValue(const tuple<T1, T2>& value) {
-  ::std::stringstream stream;
-  stream << "(" << get<0>(value) << ", " << get<1>(value) << ")";
-  return stream.str();
-}
-
-template <typename T1, typename T2, typename T3>
-::std::string PrintValue(const tuple<T1, T2, T3>& value) {
-  ::std::stringstream stream;
-  stream << "(" << get<0>(value) << ", " << get<1>(value)
-         << ", "<< get<2>(value) << ")";
-  return stream.str();
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5,
-          typename T6, typename T7, typename T8, typename T9, typename T10>
-::std::string PrintValue(
-    const tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& value) {
-  ::std::stringstream stream;
-  stream << "(" << get<0>(value) << ", " << get<1>(value)
-         << ", "<< get<2>(value) << ", " << get<3>(value)
-         << ", "<< get<4>(value) << ", " << get<5>(value)
-         << ", "<< get<6>(value) << ", " << get<7>(value)
-         << ", "<< get<8>(value) << ", " << get<9>(value) << ")";
-  return stream.str();
-}
-
-# endif  // GTEST_HAS_COMBINE
-
-// Verifies that a sequence generated by the generator and accessed
-// via the iterator object matches the expected one using Google Test
-// assertions.
-template <typename T, size_t N>
-void VerifyGenerator(const ParamGenerator<T>& generator,
-                     const T (&expected_values)[N]) {
-  typename ParamGenerator<T>::iterator it = generator.begin();
-  for (size_t i = 0; i < N; ++i) {
-    ASSERT_FALSE(it == generator.end())
-        << "At element " << i << " when accessing via an iterator "
-        << "created with the copy constructor.\n";
-    // We cannot use EXPECT_EQ() here as the values may be tuples,
-    // which don't support <<.
-    EXPECT_TRUE(expected_values[i] == *it)
-        << "where i is " << i
-        << ", expected_values[i] is " << PrintValue(expected_values[i])
-        << ", *it is " << PrintValue(*it)
-        << ", and 'it' is an iterator created with the copy constructor.\n";
-    it++;
-  }
-  EXPECT_TRUE(it == generator.end())
-        << "At the presumed end of sequence when accessing via an iterator "
-        << "created with the copy constructor.\n";
-
-  // Test the iterator assignment. The following lines verify that
-  // the sequence accessed via an iterator initialized via the
-  // assignment operator (as opposed to a copy constructor) matches
-  // just the same.
-  it = generator.begin();
-  for (size_t i = 0; i < N; ++i) {
-    ASSERT_FALSE(it == generator.end())
-        << "At element " << i << " when accessing via an iterator "
-        << "created with the assignment operator.\n";
-    EXPECT_TRUE(expected_values[i] == *it)
-        << "where i is " << i
-        << ", expected_values[i] is " << PrintValue(expected_values[i])
-        << ", *it is " << PrintValue(*it)
-        << ", and 'it' is an iterator created with the copy constructor.\n";
-    it++;
-  }
-  EXPECT_TRUE(it == generator.end())
-        << "At the presumed end of sequence when accessing via an iterator "
-        << "created with the assignment operator.\n";
-}
-
-template <typename T>
-void VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) {
-  typename ParamGenerator<T>::iterator it = generator.begin();
-  EXPECT_TRUE(it == generator.end());
-
-  it = generator.begin();
-  EXPECT_TRUE(it == generator.end());
-}
-
-// Generator tests. They test that each of the provided generator functions
-// generates an expected sequence of values. The general test pattern
-// instantiates a generator using one of the generator functions,
-// checks the sequence produced by the generator using its iterator API,
-// and then resets the iterator back to the beginning of the sequence
-// and checks the sequence again.
-
-// Tests that iterators produced by generator functions conform to the
-// ForwardIterator concept.
-TEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) {
-  const ParamGenerator<int> gen = Range(0, 10);
-  ParamGenerator<int>::iterator it = gen.begin();
-
-  // Verifies that iterator initialization works as expected.
-  ParamGenerator<int>::iterator it2 = it;
-  EXPECT_TRUE(*it == *it2) << "Initialized iterators must point to the "
-                           << "element same as its source points to";
-
-  // Verifies that iterator assignment works as expected.
-  it++;
-  EXPECT_FALSE(*it == *it2);
-  it2 = it;
-  EXPECT_TRUE(*it == *it2) << "Assigned iterators must point to the "
-                           << "element same as its source points to";
-
-  // Verifies that prefix operator++() returns *this.
-  EXPECT_EQ(&it, &(++it)) << "Result of the prefix operator++ must be "
-                          << "refer to the original object";
-
-  // Verifies that the result of the postfix operator++ points to the value
-  // pointed to by the original iterator.
-  int original_value = *it;  // Have to compute it outside of macro call to be
-                             // unaffected by the parameter evaluation order.
-  EXPECT_EQ(original_value, *(it++));
-
-  // Verifies that prefix and postfix operator++() advance an iterator
-  // all the same.
-  it2 = it;
-  it++;
-  ++it2;
-  EXPECT_TRUE(*it == *it2);
-}
-
-// Tests that Range() generates the expected sequence.
-TEST(RangeTest, IntRangeWithDefaultStep) {
-  const ParamGenerator<int> gen = Range(0, 3);
-  const int expected_values[] = {0, 1, 2};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Edge case. Tests that Range() generates the single element sequence
-// as expected when provided with range limits that are equal.
-TEST(RangeTest, IntRangeSingleValue) {
-  const ParamGenerator<int> gen = Range(0, 1);
-  const int expected_values[] = {0};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Edge case. Tests that Range() with generates empty sequence when
-// supplied with an empty range.
-TEST(RangeTest, IntRangeEmpty) {
-  const ParamGenerator<int> gen = Range(0, 0);
-  VerifyGeneratorIsEmpty(gen);
-}
-
-// Tests that Range() with custom step (greater then one) generates
-// the expected sequence.
-TEST(RangeTest, IntRangeWithCustomStep) {
-  const ParamGenerator<int> gen = Range(0, 9, 3);
-  const int expected_values[] = {0, 3, 6};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Tests that Range() with custom step (greater then one) generates
-// the expected sequence when the last element does not fall on the
-// upper range limit. Sequences generated by Range() must not have
-// elements beyond the range limits.
-TEST(RangeTest, IntRangeWithCustomStepOverUpperBound) {
-  const ParamGenerator<int> gen = Range(0, 4, 3);
-  const int expected_values[] = {0, 3};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Verifies that Range works with user-defined types that define
-// copy constructor, operator=(), operator+(), and operator<().
-class DogAdder {
- public:
-  explicit DogAdder(const char* a_value) : value_(a_value) {}
-  DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {}
-
-  DogAdder operator=(const DogAdder& other) {
-    if (this != &other)
-      value_ = other.value_;
-    return *this;
-  }
-  DogAdder operator+(const DogAdder& other) const {
-    Message msg;
-    msg << value_.c_str() << other.value_.c_str();
-    return DogAdder(msg.GetString().c_str());
-  }
-  bool operator<(const DogAdder& other) const {
-    return value_ < other.value_;
-  }
-  const std::string& value() const { return value_; }
-
- private:
-  std::string value_;
-};
-
-TEST(RangeTest, WorksWithACustomType) {
-  const ParamGenerator<DogAdder> gen =
-      Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog"));
-  ParamGenerator<DogAdder>::iterator it = gen.begin();
-
-  ASSERT_FALSE(it == gen.end());
-  EXPECT_STREQ("cat", it->value().c_str());
-
-  ASSERT_FALSE(++it == gen.end());
-  EXPECT_STREQ("catdog", it->value().c_str());
-
-  EXPECT_TRUE(++it == gen.end());
-}
-
-class IntWrapper {
- public:
-  explicit IntWrapper(int a_value) : value_(a_value) {}
-  IntWrapper(const IntWrapper& other) : value_(other.value_) {}
-
-  IntWrapper operator=(const IntWrapper& other) {
-    value_ = other.value_;
-    return *this;
-  }
-  // operator+() adds a different type.
-  IntWrapper operator+(int other) const { return IntWrapper(value_ + other); }
-  bool operator<(const IntWrapper& other) const {
-    return value_ < other.value_;
-  }
-  int value() const { return value_; }
-
- private:
-  int value_;
-};
-
-TEST(RangeTest, WorksWithACustomTypeWithDifferentIncrementType) {
-  const ParamGenerator<IntWrapper> gen = Range(IntWrapper(0), IntWrapper(2));
-  ParamGenerator<IntWrapper>::iterator it = gen.begin();
-
-  ASSERT_FALSE(it == gen.end());
-  EXPECT_EQ(0, it->value());
-
-  ASSERT_FALSE(++it == gen.end());
-  EXPECT_EQ(1, it->value());
-
-  EXPECT_TRUE(++it == gen.end());
-}
-
-// Tests that ValuesIn() with an array parameter generates
-// the expected sequence.
-TEST(ValuesInTest, ValuesInArray) {
-  int array[] = {3, 5, 8};
-  const ParamGenerator<int> gen = ValuesIn(array);
-  VerifyGenerator(gen, array);
-}
-
-// Tests that ValuesIn() with a const array parameter generates
-// the expected sequence.
-TEST(ValuesInTest, ValuesInConstArray) {
-  const int array[] = {3, 5, 8};
-  const ParamGenerator<int> gen = ValuesIn(array);
-  VerifyGenerator(gen, array);
-}
-
-// Edge case. Tests that ValuesIn() with an array parameter containing a
-// single element generates the single element sequence.
-TEST(ValuesInTest, ValuesInSingleElementArray) {
-  int array[] = {42};
-  const ParamGenerator<int> gen = ValuesIn(array);
-  VerifyGenerator(gen, array);
-}
-
-// Tests that ValuesIn() generates the expected sequence for an STL
-// container (vector).
-TEST(ValuesInTest, ValuesInVector) {
-  typedef ::std::vector<int> ContainerType;
-  ContainerType values;
-  values.push_back(3);
-  values.push_back(5);
-  values.push_back(8);
-  const ParamGenerator<int> gen = ValuesIn(values);
-
-  const int expected_values[] = {3, 5, 8};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Tests that ValuesIn() generates the expected sequence.
-TEST(ValuesInTest, ValuesInIteratorRange) {
-  typedef ::std::vector<int> ContainerType;
-  ContainerType values;
-  values.push_back(3);
-  values.push_back(5);
-  values.push_back(8);
-  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
-
-  const int expected_values[] = {3, 5, 8};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Edge case. Tests that ValuesIn() provided with an iterator range specifying a
-// single value generates a single-element sequence.
-TEST(ValuesInTest, ValuesInSingleElementIteratorRange) {
-  typedef ::std::vector<int> ContainerType;
-  ContainerType values;
-  values.push_back(42);
-  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
-
-  const int expected_values[] = {42};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Edge case. Tests that ValuesIn() provided with an empty iterator range
-// generates an empty sequence.
-TEST(ValuesInTest, ValuesInEmptyIteratorRange) {
-  typedef ::std::vector<int> ContainerType;
-  ContainerType values;
-  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
-
-  VerifyGeneratorIsEmpty(gen);
-}
-
-// Tests that the Values() generates the expected sequence.
-TEST(ValuesTest, ValuesWorks) {
-  const ParamGenerator<int> gen = Values(3, 5, 8);
-
-  const int expected_values[] = {3, 5, 8};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Tests that Values() generates the expected sequences from elements of
-// different types convertible to ParamGenerator's parameter type.
-TEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) {
-  const ParamGenerator<double> gen = Values(3, 5.0f, 8.0);
-
-  const double expected_values[] = {3.0, 5.0, 8.0};
-  VerifyGenerator(gen, expected_values);
-}
-
-TEST(ValuesTest, ValuesWorksForMaxLengthList) {
-  const ParamGenerator<int> gen = Values(
-      10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
-      110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
-      210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
-      310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
-      410, 420, 430, 440, 450, 460, 470, 480, 490, 500);
-
-  const int expected_values[] = {
-      10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
-      110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
-      210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
-      310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
-      410, 420, 430, 440, 450, 460, 470, 480, 490, 500};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Edge case test. Tests that single-parameter Values() generates the sequence
-// with the single value.
-TEST(ValuesTest, ValuesWithSingleParameter) {
-  const ParamGenerator<int> gen = Values(42);
-
-  const int expected_values[] = {42};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Tests that Bool() generates sequence (false, true).
-TEST(BoolTest, BoolWorks) {
-  const ParamGenerator<bool> gen = Bool();
-
-  const bool expected_values[] = {false, true};
-  VerifyGenerator(gen, expected_values);
-}
-
-# if GTEST_HAS_COMBINE
-
-// Tests that Combine() with two parameters generates the expected sequence.
-TEST(CombineTest, CombineWithTwoParameters) {
-  const char* foo = "foo";
-  const char* bar = "bar";
-  const ParamGenerator<tuple<const char*, int> > gen =
-      Combine(Values(foo, bar), Values(3, 4));
-
-  tuple<const char*, int> expected_values[] = {
-    make_tuple(foo, 3), make_tuple(foo, 4),
-    make_tuple(bar, 3), make_tuple(bar, 4)};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Tests that Combine() with three parameters generates the expected sequence.
-TEST(CombineTest, CombineWithThreeParameters) {
-  const ParamGenerator<tuple<int, int, int> > gen = Combine(Values(0, 1),
-                                                            Values(3, 4),
-                                                            Values(5, 6));
-  tuple<int, int, int> expected_values[] = {
-    make_tuple(0, 3, 5), make_tuple(0, 3, 6),
-    make_tuple(0, 4, 5), make_tuple(0, 4, 6),
-    make_tuple(1, 3, 5), make_tuple(1, 3, 6),
-    make_tuple(1, 4, 5), make_tuple(1, 4, 6)};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Tests that the Combine() with the first parameter generating a single value
-// sequence generates a sequence with the number of elements equal to the
-// number of elements in the sequence generated by the second parameter.
-TEST(CombineTest, CombineWithFirstParameterSingleValue) {
-  const ParamGenerator<tuple<int, int> > gen = Combine(Values(42),
-                                                       Values(0, 1));
-
-  tuple<int, int> expected_values[] = {make_tuple(42, 0), make_tuple(42, 1)};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Tests that the Combine() with the second parameter generating a single value
-// sequence generates a sequence with the number of elements equal to the
-// number of elements in the sequence generated by the first parameter.
-TEST(CombineTest, CombineWithSecondParameterSingleValue) {
-  const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),
-                                                       Values(42));
-
-  tuple<int, int> expected_values[] = {make_tuple(0, 42), make_tuple(1, 42)};
-  VerifyGenerator(gen, expected_values);
-}
-
-// Tests that when the first parameter produces an empty sequence,
-// Combine() produces an empty sequence, too.
-TEST(CombineTest, CombineWithFirstParameterEmptyRange) {
-  const ParamGenerator<tuple<int, int> > gen = Combine(Range(0, 0),
-                                                       Values(0, 1));
-  VerifyGeneratorIsEmpty(gen);
-}
-
-// Tests that when the second parameter produces an empty sequence,
-// Combine() produces an empty sequence, too.
-TEST(CombineTest, CombineWithSecondParameterEmptyRange) {
-  const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),
-                                                       Range(1, 1));
-  VerifyGeneratorIsEmpty(gen);
-}
-
-// Edge case. Tests that combine works with the maximum number
-// of parameters supported by Google Test (currently 10).
-TEST(CombineTest, CombineWithMaxNumberOfParameters) {
-  const char* foo = "foo";
-  const char* bar = "bar";
-  const ParamGenerator<tuple<const char*, int, int, int, int, int, int, int,
-                             int, int> > gen = Combine(Values(foo, bar),
-                                                       Values(1), Values(2),
-                                                       Values(3), Values(4),
-                                                       Values(5), Values(6),
-                                                       Values(7), Values(8),
-                                                       Values(9));
-
-  tuple<const char*, int, int, int, int, int, int, int, int, int>
-      expected_values[] = {make_tuple(foo, 1, 2, 3, 4, 5, 6, 7, 8, 9),
-                           make_tuple(bar, 1, 2, 3, 4, 5, 6, 7, 8, 9)};
-  VerifyGenerator(gen, expected_values);
-}
-
-# endif  // GTEST_HAS_COMBINE
-
-// Tests that an generator produces correct sequence after being
-// assigned from another generator.
-TEST(ParamGeneratorTest, AssignmentWorks) {
-  ParamGenerator<int> gen = Values(1, 2);
-  const ParamGenerator<int> gen2 = Values(3, 4);
-  gen = gen2;
-
-  const int expected_values[] = {3, 4};
-  VerifyGenerator(gen, expected_values);
-}
-
-// This test verifies that the tests are expanded and run as specified:
-// one test per element from the sequence produced by the generator
-// specified in INSTANTIATE_TEST_CASE_P. It also verifies that the test's
-// fixture constructor, SetUp(), and TearDown() have run and have been
-// supplied with the correct parameters.
-
-// The use of environment object allows detection of the case where no test
-// case functionality is run at all. In this case TestCaseTearDown will not
-// be able to detect missing tests, naturally.
-template <int kExpectedCalls>
-class TestGenerationEnvironment : public ::testing::Environment {
- public:
-  static TestGenerationEnvironment* Instance() {
-    static TestGenerationEnvironment* instance = new TestGenerationEnvironment;
-    return instance;
-  }
-
-  void FixtureConstructorExecuted() { fixture_constructor_count_++; }
-  void SetUpExecuted() { set_up_count_++; }
-  void TearDownExecuted() { tear_down_count_++; }
-  void TestBodyExecuted() { test_body_count_++; }
-
-  virtual void TearDown() {
-    // If all MultipleTestGenerationTest tests have been de-selected
-    // by the filter flag, the following checks make no sense.
-    bool perform_check = false;
-
-    for (int i = 0; i < kExpectedCalls; ++i) {
-      Message msg;
-      msg << "TestsExpandedAndRun/" << i;
-      if (UnitTestOptions::FilterMatchesTest(
-             "TestExpansionModule/MultipleTestGenerationTest",
-              msg.GetString().c_str())) {
-        perform_check = true;
-      }
-    }
-    if (perform_check) {
-      EXPECT_EQ(kExpectedCalls, fixture_constructor_count_)
-          << "Fixture constructor of ParamTestGenerationTest test case "
-          << "has not been run as expected.";
-      EXPECT_EQ(kExpectedCalls, set_up_count_)
-          << "Fixture SetUp method of ParamTestGenerationTest test case "
-          << "has not been run as expected.";
-      EXPECT_EQ(kExpectedCalls, tear_down_count_)
-          << "Fixture TearDown method of ParamTestGenerationTest test case "
-          << "has not been run as expected.";
-      EXPECT_EQ(kExpectedCalls, test_body_count_)
-          << "Test in ParamTestGenerationTest test case "
-          << "has not been run as expected.";
-    }
-  }
-
- private:
-  TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0),
-                                tear_down_count_(0), test_body_count_(0) {}
-
-  int fixture_constructor_count_;
-  int set_up_count_;
-  int tear_down_count_;
-  int test_body_count_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment);
-};
-
-const int test_generation_params[] = {36, 42, 72};
-
-class TestGenerationTest : public TestWithParam<int> {
- public:
-  enum {
-    PARAMETER_COUNT =
-        sizeof(test_generation_params)/sizeof(test_generation_params[0])
-  };
-
-  typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment;
-
-  TestGenerationTest() {
-    Environment::Instance()->FixtureConstructorExecuted();
-    current_parameter_ = GetParam();
-  }
-  virtual void SetUp() {
-    Environment::Instance()->SetUpExecuted();
-    EXPECT_EQ(current_parameter_, GetParam());
-  }
-  virtual void TearDown() {
-    Environment::Instance()->TearDownExecuted();
-    EXPECT_EQ(current_parameter_, GetParam());
-  }
-
-  static void SetUpTestCase() {
-    bool all_tests_in_test_case_selected = true;
-
-    for (int i = 0; i < PARAMETER_COUNT; ++i) {
-      Message test_name;
-      test_name << "TestsExpandedAndRun/" << i;
-      if ( !UnitTestOptions::FilterMatchesTest(
-                "TestExpansionModule/MultipleTestGenerationTest",
-                test_name.GetString())) {
-        all_tests_in_test_case_selected = false;
-      }
-    }
-    EXPECT_TRUE(all_tests_in_test_case_selected)
-        << "When running the TestGenerationTest test case all of its tests\n"
-        << "must be selected by the filter flag for the test case to pass.\n"
-        << "If not all of them are enabled, we can't reliably conclude\n"
-        << "that the correct number of tests have been generated.";
-
-    collected_parameters_.clear();
-  }
-
-  static void TearDownTestCase() {
-    vector<int> expected_values(test_generation_params,
-                                test_generation_params + PARAMETER_COUNT);
-    // Test execution order is not guaranteed by Google Test,
-    // so the order of values in collected_parameters_ can be
-    // different and we have to sort to compare.
-    sort(expected_values.begin(), expected_values.end());
-    sort(collected_parameters_.begin(), collected_parameters_.end());
-
-    EXPECT_TRUE(collected_parameters_ == expected_values);
-  }
-
- protected:
-  int current_parameter_;
-  static vector<int> collected_parameters_;
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest);
-};
-vector<int> TestGenerationTest::collected_parameters_;
-
-TEST_P(TestGenerationTest, TestsExpandedAndRun) {
-  Environment::Instance()->TestBodyExecuted();
-  EXPECT_EQ(current_parameter_, GetParam());
-  collected_parameters_.push_back(GetParam());
-}
-INSTANTIATE_TEST_CASE_P(TestExpansionModule, TestGenerationTest,
-                        ValuesIn(test_generation_params));
-
-// This test verifies that the element sequence (third parameter of
-// INSTANTIATE_TEST_CASE_P) is evaluated in InitGoogleTest() and neither at
-// the call site of INSTANTIATE_TEST_CASE_P nor in RUN_ALL_TESTS().  For
-// that, we declare param_value_ to be a static member of
-// GeneratorEvaluationTest and initialize it to 0.  We set it to 1 in
-// main(), just before invocation of InitGoogleTest().  After calling
-// InitGoogleTest(), we set the value to 2.  If the sequence is evaluated
-// before or after InitGoogleTest, INSTANTIATE_TEST_CASE_P will create a
-// test with parameter other than 1, and the test body will fail the
-// assertion.
-class GeneratorEvaluationTest : public TestWithParam<int> {
- public:
-  static int param_value() { return param_value_; }
-  static void set_param_value(int param_value) { param_value_ = param_value; }
-
- private:
-  static int param_value_;
-};
-int GeneratorEvaluationTest::param_value_ = 0;
-
-TEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) {
-  EXPECT_EQ(1, GetParam());
-}
-INSTANTIATE_TEST_CASE_P(GenEvalModule,
-                        GeneratorEvaluationTest,
-                        Values(GeneratorEvaluationTest::param_value()));
-
-// Tests that generators defined in a different translation unit are
-// functional. Generator extern_gen is defined in gtest-param-test_test2.cc.
-extern ParamGenerator<int> extern_gen;
-class ExternalGeneratorTest : public TestWithParam<int> {};
-TEST_P(ExternalGeneratorTest, ExternalGenerator) {
-  // Sequence produced by extern_gen contains only a single value
-  // which we verify here.
-  EXPECT_EQ(GetParam(), 33);
-}
-INSTANTIATE_TEST_CASE_P(ExternalGeneratorModule,
-                        ExternalGeneratorTest,
-                        extern_gen);
-
-// Tests that a parameterized test case can be defined in one translation
-// unit and instantiated in another. This test will be instantiated in
-// gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is
-// defined in gtest-param-test_test.h.
-TEST_P(ExternalInstantiationTest, IsMultipleOf33) {
-  EXPECT_EQ(0, GetParam() % 33);
-}
-
-// Tests that a parameterized test case can be instantiated with multiple
-// generators.
-class MultipleInstantiationTest : public TestWithParam<int> {};
-TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {
-}
-INSTANTIATE_TEST_CASE_P(Sequence1, MultipleInstantiationTest, Values(1, 2));
-INSTANTIATE_TEST_CASE_P(Sequence2, MultipleInstantiationTest, Range(3, 5));
-
-// Tests that a parameterized test case can be instantiated
-// in multiple translation units. This test will be instantiated
-// here and in gtest-param-test_test2.cc.
-// InstantiationInMultipleTranslationUnitsTest fixture class
-// is defined in gtest-param-test_test.h.
-TEST_P(InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42) {
-  EXPECT_EQ(0, GetParam() % 42);
-}
-INSTANTIATE_TEST_CASE_P(Sequence1,
-                        InstantiationInMultipleTranslaionUnitsTest,
-                        Values(42, 42*2));
-
-// Tests that each iteration of parameterized test runs in a separate test
-// object.
-class SeparateInstanceTest : public TestWithParam<int> {
- public:
-  SeparateInstanceTest() : count_(0) {}
-
-  static void TearDownTestCase() {
-    EXPECT_GE(global_count_, 2)
-        << "If some (but not all) SeparateInstanceTest tests have been "
-        << "filtered out this test will fail. Make sure that all "
-        << "GeneratorEvaluationTest are selected or de-selected together "
-        << "by the test filter.";
-  }
-
- protected:
-  int count_;
-  static int global_count_;
-};
-int SeparateInstanceTest::global_count_ = 0;
-
-TEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) {
-  EXPECT_EQ(0, count_++);
-  global_count_++;
-}
-INSTANTIATE_TEST_CASE_P(FourElemSequence, SeparateInstanceTest, Range(1, 4));
-
-// Tests that all instantiations of a test have named appropriately. Test
-// defined with TEST_P(TestCaseName, TestName) and instantiated with
-// INSTANTIATE_TEST_CASE_P(SequenceName, TestCaseName, generator) must be named
-// SequenceName/TestCaseName.TestName/i, where i is the 0-based index of the
-// sequence element used to instantiate the test.
-class NamingTest : public TestWithParam<int> {};
-
-TEST_P(NamingTest, TestsReportCorrectNamesAndParameters) {
-  const ::testing::TestInfo* const test_info =
-     ::testing::UnitTest::GetInstance()->current_test_info();
-
-  EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_case_name());
-
-  Message index_stream;
-  index_stream << "TestsReportCorrectNamesAndParameters/" << GetParam();
-  EXPECT_STREQ(index_stream.GetString().c_str(), test_info->name());
-
-  EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
-}
-
-INSTANTIATE_TEST_CASE_P(ZeroToFiveSequence, NamingTest, Range(0, 5));
-
-// Tests that user supplied custom parameter names are working correctly.
-// Runs the test with a builtin helper method which uses PrintToString,
-// as well as a custom function and custom functor to ensure all possible
-// uses work correctly.
-class CustomFunctorNamingTest : public TestWithParam<std::string> {};
-TEST_P(CustomFunctorNamingTest, CustomTestNames) {}
-
-struct CustomParamNameFunctor {
-  std::string operator()(const ::testing::TestParamInfo<std::string>& info) {
-    return info.param;
-  }
-};
-
-INSTANTIATE_TEST_CASE_P(CustomParamNameFunctor,
-                        CustomFunctorNamingTest,
-                        Values(std::string("FunctorName")),
-                        CustomParamNameFunctor());
-
-INSTANTIATE_TEST_CASE_P(AllAllowedCharacters,
-                        CustomFunctorNamingTest,
-                        Values("abcdefghijklmnopqrstuvwxyz",
-                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
-                               "01234567890_"),
-                        CustomParamNameFunctor());
-
-inline std::string CustomParamNameFunction(
-    const ::testing::TestParamInfo<std::string>& info) {
-  return info.param;
-}
-
-class CustomFunctionNamingTest : public TestWithParam<std::string> {};
-TEST_P(CustomFunctionNamingTest, CustomTestNames) {}
-
-INSTANTIATE_TEST_CASE_P(CustomParamNameFunction,
-                        CustomFunctionNamingTest,
-                        Values(std::string("FunctionName")),
-                        CustomParamNameFunction);
-
-#if GTEST_LANG_CXX11
-
-// Test custom naming with a lambda
-
-class CustomLambdaNamingTest : public TestWithParam<std::string> {};
-TEST_P(CustomLambdaNamingTest, CustomTestNames) {}
-
-INSTANTIATE_TEST_CASE_P(CustomParamNameLambda,
-                        CustomLambdaNamingTest,
-                        Values(std::string("LambdaName")),
-                        [](const ::testing::TestParamInfo<std::string>& info) {
-                          return info.param;
-                        });
-
-#endif  // GTEST_LANG_CXX11
-
-TEST(CustomNamingTest, CheckNameRegistry) {
-  ::testing::UnitTest* unit_test = ::testing::UnitTest::GetInstance();
-  std::set<std::string> test_names;
-  for (int case_num = 0;
-       case_num < unit_test->total_test_case_count();
-       ++case_num) {
-    const ::testing::TestCase* test_case = unit_test->GetTestCase(case_num);
-    for (int test_num = 0;
-         test_num < test_case->total_test_count();
-         ++test_num) {
-      const ::testing::TestInfo* test_info = test_case->GetTestInfo(test_num);
-      test_names.insert(std::string(test_info->name()));
-    }
-  }
-  EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctorName"));
-  EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctionName"));
-#if GTEST_LANG_CXX11
-  EXPECT_EQ(1u, test_names.count("CustomTestNames/LambdaName"));
-#endif  // GTEST_LANG_CXX11
-}
-
-// Test a numeric name to ensure PrintToStringParamName works correctly.
-
-class CustomIntegerNamingTest : public TestWithParam<int> {};
-
-TEST_P(CustomIntegerNamingTest, TestsReportCorrectNames) {
-  const ::testing::TestInfo* const test_info =
-     ::testing::UnitTest::GetInstance()->current_test_info();
-  Message test_name_stream;
-  test_name_stream << "TestsReportCorrectNames/" << GetParam();
-  EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
-}
-
-INSTANTIATE_TEST_CASE_P(PrintToString,
-                        CustomIntegerNamingTest,
-                        Range(0, 5),
-                        ::testing::PrintToStringParamName());
-
-// Test a custom struct with PrintToString.
-
-struct CustomStruct {
-  explicit CustomStruct(int value) : x(value) {}
-  int x;
-};
-
-std::ostream& operator<<(std::ostream& stream, const CustomStruct& val) {
-  stream << val.x;
-  return stream;
-}
-
-class CustomStructNamingTest : public TestWithParam<CustomStruct> {};
-
-TEST_P(CustomStructNamingTest, TestsReportCorrectNames) {
-  const ::testing::TestInfo* const test_info =
-     ::testing::UnitTest::GetInstance()->current_test_info();
-  Message test_name_stream;
-  test_name_stream << "TestsReportCorrectNames/" << GetParam();
-  EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
-}
-
-INSTANTIATE_TEST_CASE_P(PrintToString,
-                        CustomStructNamingTest,
-                        Values(CustomStruct(0), CustomStruct(1)),
-                        ::testing::PrintToStringParamName());
-
-// Test that using a stateful parameter naming function works as expected.
-
-struct StatefulNamingFunctor {
-  StatefulNamingFunctor() : sum(0) {}
-  std::string operator()(const ::testing::TestParamInfo<int>& info) {
-    int value = info.param + sum;
-    sum += info.param;
-    return ::testing::PrintToString(value);
-  }
-  int sum;
-};
-
-class StatefulNamingTest : public ::testing::TestWithParam<int> {
- protected:
-  StatefulNamingTest() : sum_(0) {}
-  int sum_;
-};
-
-TEST_P(StatefulNamingTest, TestsReportCorrectNames) {
-  const ::testing::TestInfo* const test_info =
-     ::testing::UnitTest::GetInstance()->current_test_info();
-  sum_ += GetParam();
-  Message test_name_stream;
-  test_name_stream << "TestsReportCorrectNames/" << sum_;
-  EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
-}
-
-INSTANTIATE_TEST_CASE_P(StatefulNamingFunctor,
-                        StatefulNamingTest,
-                        Range(0, 5),
-                        StatefulNamingFunctor());
-
-// Class that cannot be streamed into an ostream.  It needs to be copyable
-// (and, in case of MSVC, also assignable) in order to be a test parameter
-// type.  Its default copy constructor and assignment operator do exactly
-// what we need.
-class Unstreamable {
- public:
-  explicit Unstreamable(int value) : value_(value) {}
-
- private:
-  int value_;
-};
-
-class CommentTest : public TestWithParam<Unstreamable> {};
-
-TEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) {
-  const ::testing::TestInfo* const test_info =
-     ::testing::UnitTest::GetInstance()->current_test_info();
-
-  EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
-}
-
-INSTANTIATE_TEST_CASE_P(InstantiationWithComments,
-                        CommentTest,
-                        Values(Unstreamable(1)));
-
-// Verify that we can create a hierarchy of test fixtures, where the base
-// class fixture is not parameterized and the derived class is. In this case
-// ParameterizedDerivedTest inherits from NonParameterizedBaseTest.  We
-// perform simple tests on both.
-class NonParameterizedBaseTest : public ::testing::Test {
- public:
-  NonParameterizedBaseTest() : n_(17) { }
- protected:
-  int n_;
-};
-
-class ParameterizedDerivedTest : public NonParameterizedBaseTest,
-                                 public ::testing::WithParamInterface<int> {
- protected:
-  ParameterizedDerivedTest() : count_(0) { }
-  int count_;
-  static int global_count_;
-};
-
-int ParameterizedDerivedTest::global_count_ = 0;
-
-TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) {
-  EXPECT_EQ(17, n_);
-}
-
-TEST_P(ParameterizedDerivedTest, SeesSequence) {
-  EXPECT_EQ(17, n_);
-  EXPECT_EQ(0, count_++);
-  EXPECT_EQ(GetParam(), global_count_++);
-}
-
-class ParameterizedDeathTest : public ::testing::TestWithParam<int> { };
-
-TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) {
-  EXPECT_DEATH_IF_SUPPORTED(GetParam(),
-                            ".* value-parameterized test .*");
-}
-
-INSTANTIATE_TEST_CASE_P(RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5));
-
-#endif  // GTEST_HAS_PARAM_TEST
-
-TEST(CompileTest, CombineIsDefinedOnlyWhenGtestHasParamTestIsDefined) {
-#if GTEST_HAS_COMBINE && !GTEST_HAS_PARAM_TEST
-  FAIL() << "GTEST_HAS_COMBINE is defined while GTEST_HAS_PARAM_TEST is not\n"
-#endif
-}
-
-int main(int argc, char **argv) {
-#if GTEST_HAS_PARAM_TEST
-  // Used in TestGenerationTest test case.
-  AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
-  // Used in GeneratorEvaluationTest test case. Tests that the updated value
-  // will be picked up for instantiating tests in GeneratorEvaluationTest.
-  GeneratorEvaluationTest::set_param_value(1);
-#endif  // GTEST_HAS_PARAM_TEST
-
-  ::testing::InitGoogleTest(&argc, argv);
-
-#if GTEST_HAS_PARAM_TEST
-  // Used in GeneratorEvaluationTest test case. Tests that value updated
-  // here will NOT be used for instantiating tests in
-  // GeneratorEvaluationTest.
-  GeneratorEvaluationTest::set_param_value(2);
-#endif  // GTEST_HAS_PARAM_TEST
-
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.h b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.h
deleted file mode 100644
index 26ea122b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-param-test_test.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// 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.
-//
-// Authors: vladl@google.com (Vlad Losev)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This header file provides classes and functions used internally
-// for testing Google Test itself.
-
-#ifndef GTEST_TEST_GTEST_PARAM_TEST_TEST_H_
-#define GTEST_TEST_GTEST_PARAM_TEST_TEST_H_
-
-#include "gtest/gtest.h"
-
-#if GTEST_HAS_PARAM_TEST
-
-// Test fixture for testing definition and instantiation of a test
-// in separate translation units.
-class ExternalInstantiationTest : public ::testing::TestWithParam<int> {
-};
-
-// Test fixture for testing instantiation of a test in multiple
-// translation units.
-class InstantiationInMultipleTranslaionUnitsTest
-    : public ::testing::TestWithParam<int> {
-};
-
-#endif  // GTEST_HAS_PARAM_TEST
-
-#endif  // GTEST_TEST_GTEST_PARAM_TEST_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-port_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-port_test.cc
deleted file mode 100644
index c5067a40..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-port_test.cc
+++ /dev/null
@@ -1,1311 +0,0 @@
-// 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.
-//
-// Authors: vladl@google.com (Vlad Losev), wan@google.com (Zhanyong Wan)
-//
-// This file tests the internal cross-platform support utilities.
-
-#include "gtest/internal/gtest-port.h"
-
-#include <stdio.h>
-
-#if GTEST_OS_MAC
-# include <time.h>
-#endif  // GTEST_OS_MAC
-
-#include <list>
-#include <utility>  // For std::pair and std::make_pair.
-#include <vector>
-
-#include "gtest/gtest.h"
-#include "gtest/gtest-spi.h"
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick is to
-// prevent a user from accidentally including gtest-internal-inl.h in
-// his code.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-using std::make_pair;
-using std::pair;
-
-namespace testing {
-namespace internal {
-
-TEST(IsXDigitTest, WorksForNarrowAscii) {
-  EXPECT_TRUE(IsXDigit('0'));
-  EXPECT_TRUE(IsXDigit('9'));
-  EXPECT_TRUE(IsXDigit('A'));
-  EXPECT_TRUE(IsXDigit('F'));
-  EXPECT_TRUE(IsXDigit('a'));
-  EXPECT_TRUE(IsXDigit('f'));
-
-  EXPECT_FALSE(IsXDigit('-'));
-  EXPECT_FALSE(IsXDigit('g'));
-  EXPECT_FALSE(IsXDigit('G'));
-}
-
-TEST(IsXDigitTest, ReturnsFalseForNarrowNonAscii) {
-  EXPECT_FALSE(IsXDigit('\x80'));
-  EXPECT_FALSE(IsXDigit(static_cast<char>('0' | '\x80')));
-}
-
-TEST(IsXDigitTest, WorksForWideAscii) {
-  EXPECT_TRUE(IsXDigit(L'0'));
-  EXPECT_TRUE(IsXDigit(L'9'));
-  EXPECT_TRUE(IsXDigit(L'A'));
-  EXPECT_TRUE(IsXDigit(L'F'));
-  EXPECT_TRUE(IsXDigit(L'a'));
-  EXPECT_TRUE(IsXDigit(L'f'));
-
-  EXPECT_FALSE(IsXDigit(L'-'));
-  EXPECT_FALSE(IsXDigit(L'g'));
-  EXPECT_FALSE(IsXDigit(L'G'));
-}
-
-TEST(IsXDigitTest, ReturnsFalseForWideNonAscii) {
-  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(0x80)));
-  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x80)));
-  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x100)));
-}
-
-class Base {
- public:
-  // Copy constructor and assignment operator do exactly what we need, so we
-  // use them.
-  Base() : member_(0) {}
-  explicit Base(int n) : member_(n) {}
-  virtual ~Base() {}
-  int member() { return member_; }
-
- private:
-  int member_;
-};
-
-class Derived : public Base {
- public:
-  explicit Derived(int n) : Base(n) {}
-};
-
-TEST(ImplicitCastTest, ConvertsPointers) {
-  Derived derived(0);
-  EXPECT_TRUE(&derived == ::testing::internal::ImplicitCast_<Base*>(&derived));
-}
-
-TEST(ImplicitCastTest, CanUseInheritance) {
-  Derived derived(1);
-  Base base = ::testing::internal::ImplicitCast_<Base>(derived);
-  EXPECT_EQ(derived.member(), base.member());
-}
-
-class Castable {
- public:
-  explicit Castable(bool* converted) : converted_(converted) {}
-  operator Base() {
-    *converted_ = true;
-    return Base();
-  }
-
- private:
-  bool* converted_;
-};
-
-TEST(ImplicitCastTest, CanUseNonConstCastOperator) {
-  bool converted = false;
-  Castable castable(&converted);
-  Base base = ::testing::internal::ImplicitCast_<Base>(castable);
-  EXPECT_TRUE(converted);
-}
-
-class ConstCastable {
- public:
-  explicit ConstCastable(bool* converted) : converted_(converted) {}
-  operator Base() const {
-    *converted_ = true;
-    return Base();
-  }
-
- private:
-  bool* converted_;
-};
-
-TEST(ImplicitCastTest, CanUseConstCastOperatorOnConstValues) {
-  bool converted = false;
-  const ConstCastable const_castable(&converted);
-  Base base = ::testing::internal::ImplicitCast_<Base>(const_castable);
-  EXPECT_TRUE(converted);
-}
-
-class ConstAndNonConstCastable {
- public:
-  ConstAndNonConstCastable(bool* converted, bool* const_converted)
-      : converted_(converted), const_converted_(const_converted) {}
-  operator Base() {
-    *converted_ = true;
-    return Base();
-  }
-  operator Base() const {
-    *const_converted_ = true;
-    return Base();
-  }
-
- private:
-  bool* converted_;
-  bool* const_converted_;
-};
-
-TEST(ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately) {
-  bool converted = false;
-  bool const_converted = false;
-  ConstAndNonConstCastable castable(&converted, &const_converted);
-  Base base = ::testing::internal::ImplicitCast_<Base>(castable);
-  EXPECT_TRUE(converted);
-  EXPECT_FALSE(const_converted);
-
-  converted = false;
-  const_converted = false;
-  const ConstAndNonConstCastable const_castable(&converted, &const_converted);
-  base = ::testing::internal::ImplicitCast_<Base>(const_castable);
-  EXPECT_FALSE(converted);
-  EXPECT_TRUE(const_converted);
-}
-
-class To {
- public:
-  To(bool* converted) { *converted = true; }  // NOLINT
-};
-
-TEST(ImplicitCastTest, CanUseImplicitConstructor) {
-  bool converted = false;
-  To to = ::testing::internal::ImplicitCast_<To>(&converted);
-  (void)to;
-  EXPECT_TRUE(converted);
-}
-
-TEST(IteratorTraitsTest, WorksForSTLContainerIterators) {
-  StaticAssertTypeEq<int,
-      IteratorTraits< ::std::vector<int>::const_iterator>::value_type>();
-  StaticAssertTypeEq<bool,
-      IteratorTraits< ::std::list<bool>::iterator>::value_type>();
-}
-
-TEST(IteratorTraitsTest, WorksForPointerToNonConst) {
-  StaticAssertTypeEq<char, IteratorTraits<char*>::value_type>();
-  StaticAssertTypeEq<const void*, IteratorTraits<const void**>::value_type>();
-}
-
-TEST(IteratorTraitsTest, WorksForPointerToConst) {
-  StaticAssertTypeEq<char, IteratorTraits<const char*>::value_type>();
-  StaticAssertTypeEq<const void*,
-      IteratorTraits<const void* const*>::value_type>();
-}
-
-// Tests that the element_type typedef is available in scoped_ptr and refers
-// to the parameter type.
-TEST(ScopedPtrTest, DefinesElementType) {
-  StaticAssertTypeEq<int, ::testing::internal::scoped_ptr<int>::element_type>();
-}
-
-// TODO(vladl@google.com): Implement THE REST of scoped_ptr tests.
-
-TEST(GtestCheckSyntaxTest, BehavesLikeASingleStatement) {
-  if (AlwaysFalse())
-    GTEST_CHECK_(false) << "This should never be executed; "
-                           "It's a compilation test only.";
-
-  if (AlwaysTrue())
-    GTEST_CHECK_(true);
-  else
-    ;  // NOLINT
-
-  if (AlwaysFalse())
-    ;  // NOLINT
-  else
-    GTEST_CHECK_(true) << "";
-}
-
-TEST(GtestCheckSyntaxTest, WorksWithSwitch) {
-  switch (0) {
-    case 1:
-      break;
-    default:
-      GTEST_CHECK_(true);
-  }
-
-  switch (0)
-    case 0:
-      GTEST_CHECK_(true) << "Check failed in switch case";
-}
-
-// Verifies behavior of FormatFileLocation.
-TEST(FormatFileLocationTest, FormatsFileLocation) {
-  EXPECT_PRED_FORMAT2(IsSubstring, "foo.cc", FormatFileLocation("foo.cc", 42));
-  EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation("foo.cc", 42));
-}
-
-TEST(FormatFileLocationTest, FormatsUnknownFile) {
-  EXPECT_PRED_FORMAT2(
-      IsSubstring, "unknown file", FormatFileLocation(NULL, 42));
-  EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation(NULL, 42));
-}
-
-TEST(FormatFileLocationTest, FormatsUknownLine) {
-  EXPECT_EQ("foo.cc:", FormatFileLocation("foo.cc", -1));
-}
-
-TEST(FormatFileLocationTest, FormatsUknownFileAndLine) {
-  EXPECT_EQ("unknown file:", FormatFileLocation(NULL, -1));
-}
-
-// Verifies behavior of FormatCompilerIndependentFileLocation.
-TEST(FormatCompilerIndependentFileLocationTest, FormatsFileLocation) {
-  EXPECT_EQ("foo.cc:42", FormatCompilerIndependentFileLocation("foo.cc", 42));
-}
-
-TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFile) {
-  EXPECT_EQ("unknown file:42",
-            FormatCompilerIndependentFileLocation(NULL, 42));
-}
-
-TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownLine) {
-  EXPECT_EQ("foo.cc", FormatCompilerIndependentFileLocation("foo.cc", -1));
-}
-
-TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine) {
-  EXPECT_EQ("unknown file", FormatCompilerIndependentFileLocation(NULL, -1));
-}
-
-#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX
-void* ThreadFunc(void* data) {
-  internal::Mutex* mutex = static_cast<internal::Mutex*>(data);
-  mutex->Lock();
-  mutex->Unlock();
-  return NULL;
-}
-
-TEST(GetThreadCountTest, ReturnsCorrectValue) {
-  const size_t starting_count = GetThreadCount();
-  pthread_t       thread_id;
-
-  internal::Mutex mutex;
-  {
-    internal::MutexLock lock(&mutex);
-    pthread_attr_t  attr;
-    ASSERT_EQ(0, pthread_attr_init(&attr));
-    ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));
-
-    const int status = pthread_create(&thread_id, &attr, &ThreadFunc, &mutex);
-    ASSERT_EQ(0, pthread_attr_destroy(&attr));
-    ASSERT_EQ(0, status);
-    EXPECT_EQ(starting_count + 1, GetThreadCount());
-  }
-
-  void* dummy;
-  ASSERT_EQ(0, pthread_join(thread_id, &dummy));
-
-  // The OS may not immediately report the updated thread count after
-  // joining a thread, causing flakiness in this test. To counter that, we
-  // wait for up to .5 seconds for the OS to report the correct value.
-  for (int i = 0; i < 5; ++i) {
-    if (GetThreadCount() == starting_count)
-      break;
-
-    SleepMilliseconds(100);
-  }
-
-  EXPECT_EQ(starting_count, GetThreadCount());
-}
-#else
-TEST(GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads) {
-  EXPECT_EQ(0U, GetThreadCount());
-}
-#endif  // GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX
-
-TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
-  const bool a_false_condition = false;
-  const char regex[] =
-#ifdef _MSC_VER
-     "gtest-port_test\\.cc\\(\\d+\\):"
-#elif GTEST_USES_POSIX_RE
-     "gtest-port_test\\.cc:[0-9]+"
-#else
-     "gtest-port_test\\.cc:\\d+"
-#endif  // _MSC_VER
-     ".*a_false_condition.*Extra info.*";
-
-  EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(a_false_condition) << "Extra info",
-                            regex);
-}
-
-#if GTEST_HAS_DEATH_TEST
-
-TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {
-  EXPECT_EXIT({
-      GTEST_CHECK_(true) << "Extra info";
-      ::std::cerr << "Success\n";
-      exit(0); },
-      ::testing::ExitedWithCode(0), "Success");
-}
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-// Verifies that Google Test choose regular expression engine appropriate to
-// the platform. The test will produce compiler errors in case of failure.
-// For simplicity, we only cover the most important platforms here.
-TEST(RegexEngineSelectionTest, SelectsCorrectRegexEngine) {
-#if !GTEST_USES_PCRE
-# if GTEST_HAS_POSIX_RE
-
-  EXPECT_TRUE(GTEST_USES_POSIX_RE);
-
-# else
-
-  EXPECT_TRUE(GTEST_USES_SIMPLE_RE);
-
-# endif
-#endif  // !GTEST_USES_PCRE
-}
-
-#if GTEST_USES_POSIX_RE
-
-# if GTEST_HAS_TYPED_TEST
-
-template <typename Str>
-class RETest : public ::testing::Test {};
-
-// Defines StringTypes as the list of all string types that class RE
-// supports.
-typedef testing::Types<
-    ::std::string,
-#  if GTEST_HAS_GLOBAL_STRING
-    ::string,
-#  endif  // GTEST_HAS_GLOBAL_STRING
-    const char*> StringTypes;
-
-TYPED_TEST_CASE(RETest, StringTypes);
-
-// Tests RE's implicit constructors.
-TYPED_TEST(RETest, ImplicitConstructorWorks) {
-  const RE empty(TypeParam(""));
-  EXPECT_STREQ("", empty.pattern());
-
-  const RE simple(TypeParam("hello"));
-  EXPECT_STREQ("hello", simple.pattern());
-
-  const RE normal(TypeParam(".*(\\w+)"));
-  EXPECT_STREQ(".*(\\w+)", normal.pattern());
-}
-
-// Tests that RE's constructors reject invalid regular expressions.
-TYPED_TEST(RETest, RejectsInvalidRegex) {
-  EXPECT_NONFATAL_FAILURE({
-    const RE invalid(TypeParam("?"));
-  }, "\"?\" is not a valid POSIX Extended regular expression.");
-}
-
-// Tests RE::FullMatch().
-TYPED_TEST(RETest, FullMatchWorks) {
-  const RE empty(TypeParam(""));
-  EXPECT_TRUE(RE::FullMatch(TypeParam(""), empty));
-  EXPECT_FALSE(RE::FullMatch(TypeParam("a"), empty));
-
-  const RE re(TypeParam("a.*z"));
-  EXPECT_TRUE(RE::FullMatch(TypeParam("az"), re));
-  EXPECT_TRUE(RE::FullMatch(TypeParam("axyz"), re));
-  EXPECT_FALSE(RE::FullMatch(TypeParam("baz"), re));
-  EXPECT_FALSE(RE::FullMatch(TypeParam("azy"), re));
-}
-
-// Tests RE::PartialMatch().
-TYPED_TEST(RETest, PartialMatchWorks) {
-  const RE empty(TypeParam(""));
-  EXPECT_TRUE(RE::PartialMatch(TypeParam(""), empty));
-  EXPECT_TRUE(RE::PartialMatch(TypeParam("a"), empty));
-
-  const RE re(TypeParam("a.*z"));
-  EXPECT_TRUE(RE::PartialMatch(TypeParam("az"), re));
-  EXPECT_TRUE(RE::PartialMatch(TypeParam("axyz"), re));
-  EXPECT_TRUE(RE::PartialMatch(TypeParam("baz"), re));
-  EXPECT_TRUE(RE::PartialMatch(TypeParam("azy"), re));
-  EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re));
-}
-
-# endif  // GTEST_HAS_TYPED_TEST
-
-#elif GTEST_USES_SIMPLE_RE
-
-TEST(IsInSetTest, NulCharIsNotInAnySet) {
-  EXPECT_FALSE(IsInSet('\0', ""));
-  EXPECT_FALSE(IsInSet('\0', "\0"));
-  EXPECT_FALSE(IsInSet('\0', "a"));
-}
-
-TEST(IsInSetTest, WorksForNonNulChars) {
-  EXPECT_FALSE(IsInSet('a', "Ab"));
-  EXPECT_FALSE(IsInSet('c', ""));
-
-  EXPECT_TRUE(IsInSet('b', "bcd"));
-  EXPECT_TRUE(IsInSet('b', "ab"));
-}
-
-TEST(IsAsciiDigitTest, IsFalseForNonDigit) {
-  EXPECT_FALSE(IsAsciiDigit('\0'));
-  EXPECT_FALSE(IsAsciiDigit(' '));
-  EXPECT_FALSE(IsAsciiDigit('+'));
-  EXPECT_FALSE(IsAsciiDigit('-'));
-  EXPECT_FALSE(IsAsciiDigit('.'));
-  EXPECT_FALSE(IsAsciiDigit('a'));
-}
-
-TEST(IsAsciiDigitTest, IsTrueForDigit) {
-  EXPECT_TRUE(IsAsciiDigit('0'));
-  EXPECT_TRUE(IsAsciiDigit('1'));
-  EXPECT_TRUE(IsAsciiDigit('5'));
-  EXPECT_TRUE(IsAsciiDigit('9'));
-}
-
-TEST(IsAsciiPunctTest, IsFalseForNonPunct) {
-  EXPECT_FALSE(IsAsciiPunct('\0'));
-  EXPECT_FALSE(IsAsciiPunct(' '));
-  EXPECT_FALSE(IsAsciiPunct('\n'));
-  EXPECT_FALSE(IsAsciiPunct('a'));
-  EXPECT_FALSE(IsAsciiPunct('0'));
-}
-
-TEST(IsAsciiPunctTest, IsTrueForPunct) {
-  for (const char* p = "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"; *p; p++) {
-    EXPECT_PRED1(IsAsciiPunct, *p);
-  }
-}
-
-TEST(IsRepeatTest, IsFalseForNonRepeatChar) {
-  EXPECT_FALSE(IsRepeat('\0'));
-  EXPECT_FALSE(IsRepeat(' '));
-  EXPECT_FALSE(IsRepeat('a'));
-  EXPECT_FALSE(IsRepeat('1'));
-  EXPECT_FALSE(IsRepeat('-'));
-}
-
-TEST(IsRepeatTest, IsTrueForRepeatChar) {
-  EXPECT_TRUE(IsRepeat('?'));
-  EXPECT_TRUE(IsRepeat('*'));
-  EXPECT_TRUE(IsRepeat('+'));
-}
-
-TEST(IsAsciiWhiteSpaceTest, IsFalseForNonWhiteSpace) {
-  EXPECT_FALSE(IsAsciiWhiteSpace('\0'));
-  EXPECT_FALSE(IsAsciiWhiteSpace('a'));
-  EXPECT_FALSE(IsAsciiWhiteSpace('1'));
-  EXPECT_FALSE(IsAsciiWhiteSpace('+'));
-  EXPECT_FALSE(IsAsciiWhiteSpace('_'));
-}
-
-TEST(IsAsciiWhiteSpaceTest, IsTrueForWhiteSpace) {
-  EXPECT_TRUE(IsAsciiWhiteSpace(' '));
-  EXPECT_TRUE(IsAsciiWhiteSpace('\n'));
-  EXPECT_TRUE(IsAsciiWhiteSpace('\r'));
-  EXPECT_TRUE(IsAsciiWhiteSpace('\t'));
-  EXPECT_TRUE(IsAsciiWhiteSpace('\v'));
-  EXPECT_TRUE(IsAsciiWhiteSpace('\f'));
-}
-
-TEST(IsAsciiWordCharTest, IsFalseForNonWordChar) {
-  EXPECT_FALSE(IsAsciiWordChar('\0'));
-  EXPECT_FALSE(IsAsciiWordChar('+'));
-  EXPECT_FALSE(IsAsciiWordChar('.'));
-  EXPECT_FALSE(IsAsciiWordChar(' '));
-  EXPECT_FALSE(IsAsciiWordChar('\n'));
-}
-
-TEST(IsAsciiWordCharTest, IsTrueForLetter) {
-  EXPECT_TRUE(IsAsciiWordChar('a'));
-  EXPECT_TRUE(IsAsciiWordChar('b'));
-  EXPECT_TRUE(IsAsciiWordChar('A'));
-  EXPECT_TRUE(IsAsciiWordChar('Z'));
-}
-
-TEST(IsAsciiWordCharTest, IsTrueForDigit) {
-  EXPECT_TRUE(IsAsciiWordChar('0'));
-  EXPECT_TRUE(IsAsciiWordChar('1'));
-  EXPECT_TRUE(IsAsciiWordChar('7'));
-  EXPECT_TRUE(IsAsciiWordChar('9'));
-}
-
-TEST(IsAsciiWordCharTest, IsTrueForUnderscore) {
-  EXPECT_TRUE(IsAsciiWordChar('_'));
-}
-
-TEST(IsValidEscapeTest, IsFalseForNonPrintable) {
-  EXPECT_FALSE(IsValidEscape('\0'));
-  EXPECT_FALSE(IsValidEscape('\007'));
-}
-
-TEST(IsValidEscapeTest, IsFalseForDigit) {
-  EXPECT_FALSE(IsValidEscape('0'));
-  EXPECT_FALSE(IsValidEscape('9'));
-}
-
-TEST(IsValidEscapeTest, IsFalseForWhiteSpace) {
-  EXPECT_FALSE(IsValidEscape(' '));
-  EXPECT_FALSE(IsValidEscape('\n'));
-}
-
-TEST(IsValidEscapeTest, IsFalseForSomeLetter) {
-  EXPECT_FALSE(IsValidEscape('a'));
-  EXPECT_FALSE(IsValidEscape('Z'));
-}
-
-TEST(IsValidEscapeTest, IsTrueForPunct) {
-  EXPECT_TRUE(IsValidEscape('.'));
-  EXPECT_TRUE(IsValidEscape('-'));
-  EXPECT_TRUE(IsValidEscape('^'));
-  EXPECT_TRUE(IsValidEscape('$'));
-  EXPECT_TRUE(IsValidEscape('('));
-  EXPECT_TRUE(IsValidEscape(']'));
-  EXPECT_TRUE(IsValidEscape('{'));
-  EXPECT_TRUE(IsValidEscape('|'));
-}
-
-TEST(IsValidEscapeTest, IsTrueForSomeLetter) {
-  EXPECT_TRUE(IsValidEscape('d'));
-  EXPECT_TRUE(IsValidEscape('D'));
-  EXPECT_TRUE(IsValidEscape('s'));
-  EXPECT_TRUE(IsValidEscape('S'));
-  EXPECT_TRUE(IsValidEscape('w'));
-  EXPECT_TRUE(IsValidEscape('W'));
-}
-
-TEST(AtomMatchesCharTest, EscapedPunct) {
-  EXPECT_FALSE(AtomMatchesChar(true, '\\', '\0'));
-  EXPECT_FALSE(AtomMatchesChar(true, '\\', ' '));
-  EXPECT_FALSE(AtomMatchesChar(true, '_', '.'));
-  EXPECT_FALSE(AtomMatchesChar(true, '.', 'a'));
-
-  EXPECT_TRUE(AtomMatchesChar(true, '\\', '\\'));
-  EXPECT_TRUE(AtomMatchesChar(true, '_', '_'));
-  EXPECT_TRUE(AtomMatchesChar(true, '+', '+'));
-  EXPECT_TRUE(AtomMatchesChar(true, '.', '.'));
-}
-
-TEST(AtomMatchesCharTest, Escaped_d) {
-  EXPECT_FALSE(AtomMatchesChar(true, 'd', '\0'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'd', 'a'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'd', '.'));
-
-  EXPECT_TRUE(AtomMatchesChar(true, 'd', '0'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'd', '9'));
-}
-
-TEST(AtomMatchesCharTest, Escaped_D) {
-  EXPECT_FALSE(AtomMatchesChar(true, 'D', '0'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'D', '9'));
-
-  EXPECT_TRUE(AtomMatchesChar(true, 'D', '\0'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'D', 'a'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'D', '-'));
-}
-
-TEST(AtomMatchesCharTest, Escaped_s) {
-  EXPECT_FALSE(AtomMatchesChar(true, 's', '\0'));
-  EXPECT_FALSE(AtomMatchesChar(true, 's', 'a'));
-  EXPECT_FALSE(AtomMatchesChar(true, 's', '.'));
-  EXPECT_FALSE(AtomMatchesChar(true, 's', '9'));
-
-  EXPECT_TRUE(AtomMatchesChar(true, 's', ' '));
-  EXPECT_TRUE(AtomMatchesChar(true, 's', '\n'));
-  EXPECT_TRUE(AtomMatchesChar(true, 's', '\t'));
-}
-
-TEST(AtomMatchesCharTest, Escaped_S) {
-  EXPECT_FALSE(AtomMatchesChar(true, 'S', ' '));
-  EXPECT_FALSE(AtomMatchesChar(true, 'S', '\r'));
-
-  EXPECT_TRUE(AtomMatchesChar(true, 'S', '\0'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'S', 'a'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'S', '9'));
-}
-
-TEST(AtomMatchesCharTest, Escaped_w) {
-  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\0'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'w', '+'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'w', ' '));
-  EXPECT_FALSE(AtomMatchesChar(true, 'w', '\n'));
-
-  EXPECT_TRUE(AtomMatchesChar(true, 'w', '0'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'b'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'w', 'C'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'w', '_'));
-}
-
-TEST(AtomMatchesCharTest, Escaped_W) {
-  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'A'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'W', 'b'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'W', '9'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'W', '_'));
-
-  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\0'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'W', '*'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'W', '\n'));
-}
-
-TEST(AtomMatchesCharTest, EscapedWhiteSpace) {
-  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\0'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'f', '\n'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\0'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'n', '\r'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'r', '\0'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'r', 'a'));
-  EXPECT_FALSE(AtomMatchesChar(true, 't', '\0'));
-  EXPECT_FALSE(AtomMatchesChar(true, 't', 't'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\0'));
-  EXPECT_FALSE(AtomMatchesChar(true, 'v', '\f'));
-
-  EXPECT_TRUE(AtomMatchesChar(true, 'f', '\f'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'n', '\n'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'r', '\r'));
-  EXPECT_TRUE(AtomMatchesChar(true, 't', '\t'));
-  EXPECT_TRUE(AtomMatchesChar(true, 'v', '\v'));
-}
-
-TEST(AtomMatchesCharTest, UnescapedDot) {
-  EXPECT_FALSE(AtomMatchesChar(false, '.', '\n'));
-
-  EXPECT_TRUE(AtomMatchesChar(false, '.', '\0'));
-  EXPECT_TRUE(AtomMatchesChar(false, '.', '.'));
-  EXPECT_TRUE(AtomMatchesChar(false, '.', 'a'));
-  EXPECT_TRUE(AtomMatchesChar(false, '.', ' '));
-}
-
-TEST(AtomMatchesCharTest, UnescapedChar) {
-  EXPECT_FALSE(AtomMatchesChar(false, 'a', '\0'));
-  EXPECT_FALSE(AtomMatchesChar(false, 'a', 'b'));
-  EXPECT_FALSE(AtomMatchesChar(false, '$', 'a'));
-
-  EXPECT_TRUE(AtomMatchesChar(false, '$', '$'));
-  EXPECT_TRUE(AtomMatchesChar(false, '5', '5'));
-  EXPECT_TRUE(AtomMatchesChar(false, 'Z', 'Z'));
-}
-
-TEST(ValidateRegexTest, GeneratesFailureAndReturnsFalseForInvalid) {
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(NULL)),
-                          "NULL is not a valid simple regular expression");
-  EXPECT_NONFATAL_FAILURE(
-      ASSERT_FALSE(ValidateRegex("a\\")),
-      "Syntax error at index 1 in simple regular expression \"a\\\": ");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a\\")),
-                          "'\\' cannot appear at the end");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\n\\")),
-                          "'\\' cannot appear at the end");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\s\\hb")),
-                          "invalid escape sequence \"\\h\"");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^^")),
-                          "'^' can only appear at the beginning");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(".*^b")),
-                          "'^' can only appear at the beginning");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("$$")),
-                          "'$' can only appear at the end");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^$a")),
-                          "'$' can only appear at the end");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a(b")),
-                          "'(' is unsupported");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("ab)")),
-                          "')' is unsupported");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("[ab")),
-                          "'[' is unsupported");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a{2")),
-                          "'{' is unsupported");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("?")),
-                          "'?' can only follow a repeatable token");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^*")),
-                          "'*' can only follow a repeatable token");
-  EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("5*+")),
-                          "'+' can only follow a repeatable token");
-}
-
-TEST(ValidateRegexTest, ReturnsTrueForValid) {
-  EXPECT_TRUE(ValidateRegex(""));
-  EXPECT_TRUE(ValidateRegex("a"));
-  EXPECT_TRUE(ValidateRegex(".*"));
-  EXPECT_TRUE(ValidateRegex("^a_+"));
-  EXPECT_TRUE(ValidateRegex("^a\\t\\&?"));
-  EXPECT_TRUE(ValidateRegex("09*$"));
-  EXPECT_TRUE(ValidateRegex("^Z$"));
-  EXPECT_TRUE(ValidateRegex("a\\^Z\\$\\(\\)\\|\\[\\]\\{\\}"));
-}
-
-TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrOne) {
-  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "a", "ba"));
-  // Repeating more than once.
-  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "aab"));
-
-  // Repeating zero times.
-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ba"));
-  // Repeating once.
-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ab"));
-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '#', '?', ".", "##"));
-}
-
-TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrMany) {
-  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '*', "a$", "baab"));
-
-  // Repeating zero times.
-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "bc"));
-  // Repeating once.
-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "abc"));
-  // Repeating more than once.
-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '*', "-", "ab_1-g"));
-}
-
-TEST(MatchRepetitionAndRegexAtHeadTest, WorksForOneOrMany) {
-  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "a$", "baab"));
-  // Repeating zero times.
-  EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "bc"));
-
-  // Repeating once.
-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "abc"));
-  // Repeating more than once.
-  EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '+', "-", "ab_1-g"));
-}
-
-TEST(MatchRegexAtHeadTest, ReturnsTrueForEmptyRegex) {
-  EXPECT_TRUE(MatchRegexAtHead("", ""));
-  EXPECT_TRUE(MatchRegexAtHead("", "ab"));
-}
-
-TEST(MatchRegexAtHeadTest, WorksWhenDollarIsInRegex) {
-  EXPECT_FALSE(MatchRegexAtHead("$", "a"));
-
-  EXPECT_TRUE(MatchRegexAtHead("$", ""));
-  EXPECT_TRUE(MatchRegexAtHead("a$", "a"));
-}
-
-TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithEscapeSequence) {
-  EXPECT_FALSE(MatchRegexAtHead("\\w", "+"));
-  EXPECT_FALSE(MatchRegexAtHead("\\W", "ab"));
-
-  EXPECT_TRUE(MatchRegexAtHead("\\sa", "\nab"));
-  EXPECT_TRUE(MatchRegexAtHead("\\d", "1a"));
-}
-
-TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetition) {
-  EXPECT_FALSE(MatchRegexAtHead(".+a", "abc"));
-  EXPECT_FALSE(MatchRegexAtHead("a?b", "aab"));
-
-  EXPECT_TRUE(MatchRegexAtHead(".*a", "bc12-ab"));
-  EXPECT_TRUE(MatchRegexAtHead("a?b", "b"));
-  EXPECT_TRUE(MatchRegexAtHead("a?b", "ab"));
-}
-
-TEST(MatchRegexAtHeadTest,
-     WorksWhenRegexStartsWithRepetionOfEscapeSequence) {
-  EXPECT_FALSE(MatchRegexAtHead("\\.+a", "abc"));
-  EXPECT_FALSE(MatchRegexAtHead("\\s?b", "  b"));
-
-  EXPECT_TRUE(MatchRegexAtHead("\\(*a", "((((ab"));
-  EXPECT_TRUE(MatchRegexAtHead("\\^?b", "^b"));
-  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "b"));
-  EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "\\b"));
-}
-
-TEST(MatchRegexAtHeadTest, MatchesSequentially) {
-  EXPECT_FALSE(MatchRegexAtHead("ab.*c", "acabc"));
-
-  EXPECT_TRUE(MatchRegexAtHead("ab.*c", "ab-fsc"));
-}
-
-TEST(MatchRegexAnywhereTest, ReturnsFalseWhenStringIsNull) {
-  EXPECT_FALSE(MatchRegexAnywhere("", NULL));
-}
-
-TEST(MatchRegexAnywhereTest, WorksWhenRegexStartsWithCaret) {
-  EXPECT_FALSE(MatchRegexAnywhere("^a", "ba"));
-  EXPECT_FALSE(MatchRegexAnywhere("^$", "a"));
-
-  EXPECT_TRUE(MatchRegexAnywhere("^a", "ab"));
-  EXPECT_TRUE(MatchRegexAnywhere("^", "ab"));
-  EXPECT_TRUE(MatchRegexAnywhere("^$", ""));
-}
-
-TEST(MatchRegexAnywhereTest, ReturnsFalseWhenNoMatch) {
-  EXPECT_FALSE(MatchRegexAnywhere("a", "bcde123"));
-  EXPECT_FALSE(MatchRegexAnywhere("a.+a", "--aa88888888"));
-}
-
-TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingPrefix) {
-  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "ab1_ - 5"));
-  EXPECT_TRUE(MatchRegexAnywhere(".*=", "="));
-  EXPECT_TRUE(MatchRegexAnywhere("x.*ab?.*bc", "xaaabc"));
-}
-
-TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingNonPrefix) {
-  EXPECT_TRUE(MatchRegexAnywhere("\\w+", "$$$ ab1_ - 5"));
-  EXPECT_TRUE(MatchRegexAnywhere("\\.+=", "=  ...="));
-}
-
-// Tests RE's implicit constructors.
-TEST(RETest, ImplicitConstructorWorks) {
-  const RE empty("");
-  EXPECT_STREQ("", empty.pattern());
-
-  const RE simple("hello");
-  EXPECT_STREQ("hello", simple.pattern());
-}
-
-// Tests that RE's constructors reject invalid regular expressions.
-TEST(RETest, RejectsInvalidRegex) {
-  EXPECT_NONFATAL_FAILURE({
-    const RE normal(NULL);
-  }, "NULL is not a valid simple regular expression");
-
-  EXPECT_NONFATAL_FAILURE({
-    const RE normal(".*(\\w+");
-  }, "'(' is unsupported");
-
-  EXPECT_NONFATAL_FAILURE({
-    const RE invalid("^?");
-  }, "'?' can only follow a repeatable token");
-}
-
-// Tests RE::FullMatch().
-TEST(RETest, FullMatchWorks) {
-  const RE empty("");
-  EXPECT_TRUE(RE::FullMatch("", empty));
-  EXPECT_FALSE(RE::FullMatch("a", empty));
-
-  const RE re1("a");
-  EXPECT_TRUE(RE::FullMatch("a", re1));
-
-  const RE re("a.*z");
-  EXPECT_TRUE(RE::FullMatch("az", re));
-  EXPECT_TRUE(RE::FullMatch("axyz", re));
-  EXPECT_FALSE(RE::FullMatch("baz", re));
-  EXPECT_FALSE(RE::FullMatch("azy", re));
-}
-
-// Tests RE::PartialMatch().
-TEST(RETest, PartialMatchWorks) {
-  const RE empty("");
-  EXPECT_TRUE(RE::PartialMatch("", empty));
-  EXPECT_TRUE(RE::PartialMatch("a", empty));
-
-  const RE re("a.*z");
-  EXPECT_TRUE(RE::PartialMatch("az", re));
-  EXPECT_TRUE(RE::PartialMatch("axyz", re));
-  EXPECT_TRUE(RE::PartialMatch("baz", re));
-  EXPECT_TRUE(RE::PartialMatch("azy", re));
-  EXPECT_FALSE(RE::PartialMatch("zza", re));
-}
-
-#endif  // GTEST_USES_POSIX_RE
-
-#if !GTEST_OS_WINDOWS_MOBILE
-
-TEST(CaptureTest, CapturesStdout) {
-  CaptureStdout();
-  fprintf(stdout, "abc");
-  EXPECT_STREQ("abc", GetCapturedStdout().c_str());
-
-  CaptureStdout();
-  fprintf(stdout, "def%cghi", '\0');
-  EXPECT_EQ(::std::string("def\0ghi", 7), ::std::string(GetCapturedStdout()));
-}
-
-TEST(CaptureTest, CapturesStderr) {
-  CaptureStderr();
-  fprintf(stderr, "jkl");
-  EXPECT_STREQ("jkl", GetCapturedStderr().c_str());
-
-  CaptureStderr();
-  fprintf(stderr, "jkl%cmno", '\0');
-  EXPECT_EQ(::std::string("jkl\0mno", 7), ::std::string(GetCapturedStderr()));
-}
-
-// Tests that stdout and stderr capture don't interfere with each other.
-TEST(CaptureTest, CapturesStdoutAndStderr) {
-  CaptureStdout();
-  CaptureStderr();
-  fprintf(stdout, "pqr");
-  fprintf(stderr, "stu");
-  EXPECT_STREQ("pqr", GetCapturedStdout().c_str());
-  EXPECT_STREQ("stu", GetCapturedStderr().c_str());
-}
-
-TEST(CaptureDeathTest, CannotReenterStdoutCapture) {
-  CaptureStdout();
-  EXPECT_DEATH_IF_SUPPORTED(CaptureStdout(),
-                            "Only one stdout capturer can exist at a time");
-  GetCapturedStdout();
-
-  // We cannot test stderr capturing using death tests as they use it
-  // themselves.
-}
-
-#endif  // !GTEST_OS_WINDOWS_MOBILE
-
-TEST(ThreadLocalTest, DefaultConstructorInitializesToDefaultValues) {
-  ThreadLocal<int> t1;
-  EXPECT_EQ(0, t1.get());
-
-  ThreadLocal<void*> t2;
-  EXPECT_TRUE(t2.get() == NULL);
-}
-
-TEST(ThreadLocalTest, SingleParamConstructorInitializesToParam) {
-  ThreadLocal<int> t1(123);
-  EXPECT_EQ(123, t1.get());
-
-  int i = 0;
-  ThreadLocal<int*> t2(&i);
-  EXPECT_EQ(&i, t2.get());
-}
-
-class NoDefaultContructor {
- public:
-  explicit NoDefaultContructor(const char*) {}
-  NoDefaultContructor(const NoDefaultContructor&) {}
-};
-
-TEST(ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVersion) {
-  ThreadLocal<NoDefaultContructor> bar(NoDefaultContructor("foo"));
-  bar.pointer();
-}
-
-TEST(ThreadLocalTest, GetAndPointerReturnSameValue) {
-  ThreadLocal<std::string> thread_local_string;
-
-  EXPECT_EQ(thread_local_string.pointer(), &(thread_local_string.get()));
-
-  // Verifies the condition still holds after calling set.
-  thread_local_string.set("foo");
-  EXPECT_EQ(thread_local_string.pointer(), &(thread_local_string.get()));
-}
-
-TEST(ThreadLocalTest, PointerAndConstPointerReturnSameValue) {
-  ThreadLocal<std::string> thread_local_string;
-  const ThreadLocal<std::string>& const_thread_local_string =
-      thread_local_string;
-
-  EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer());
-
-  thread_local_string.set("foo");
-  EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer());
-}
-
-#if GTEST_IS_THREADSAFE
-
-void AddTwo(int* param) { *param += 2; }
-
-TEST(ThreadWithParamTest, ConstructorExecutesThreadFunc) {
-  int i = 40;
-  ThreadWithParam<int*> thread(&AddTwo, &i, NULL);
-  thread.Join();
-  EXPECT_EQ(42, i);
-}
-
-TEST(MutexDeathTest, AssertHeldShouldAssertWhenNotLocked) {
-  // AssertHeld() is flaky only in the presence of multiple threads accessing
-  // the lock. In this case, the test is robust.
-  EXPECT_DEATH_IF_SUPPORTED({
-    Mutex m;
-    { MutexLock lock(&m); }
-    m.AssertHeld();
-  },
-  "thread .*hold");
-}
-
-TEST(MutexTest, AssertHeldShouldNotAssertWhenLocked) {
-  Mutex m;
-  MutexLock lock(&m);
-  m.AssertHeld();
-}
-
-class AtomicCounterWithMutex {
- public:
-  explicit AtomicCounterWithMutex(Mutex* mutex) :
-    value_(0), mutex_(mutex), random_(42) {}
-
-  void Increment() {
-    MutexLock lock(mutex_);
-    int temp = value_;
-    {
-      // We need to put up a memory barrier to prevent reads and writes to
-      // value_ rearranged with the call to SleepMilliseconds when observed
-      // from other threads.
-#if GTEST_HAS_PTHREAD
-      // On POSIX, locking a mutex puts up a memory barrier.  We cannot use
-      // Mutex and MutexLock here or rely on their memory barrier
-      // functionality as we are testing them here.
-      pthread_mutex_t memory_barrier_mutex;
-      GTEST_CHECK_POSIX_SUCCESS_(
-          pthread_mutex_init(&memory_barrier_mutex, NULL));
-      GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&memory_barrier_mutex));
-
-      SleepMilliseconds(random_.Generate(30));
-
-      GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&memory_barrier_mutex));
-      GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&memory_barrier_mutex));
-#elif GTEST_OS_WINDOWS
-      // On Windows, performing an interlocked access puts up a memory barrier.
-      volatile LONG dummy = 0;
-      ::InterlockedIncrement(&dummy);
-      SleepMilliseconds(random_.Generate(30));
-      ::InterlockedIncrement(&dummy);
-#else
-# error "Memory barrier not implemented on this platform."
-#endif  // GTEST_HAS_PTHREAD
-    }
-    value_ = temp + 1;
-  }
-  int value() const { return value_; }
-
- private:
-  volatile int value_;
-  Mutex* const mutex_;  // Protects value_.
-  Random       random_;
-};
-
-void CountingThreadFunc(pair<AtomicCounterWithMutex*, int> param) {
-  for (int i = 0; i < param.second; ++i)
-      param.first->Increment();
-}
-
-// Tests that the mutex only lets one thread at a time to lock it.
-TEST(MutexTest, OnlyOneThreadCanLockAtATime) {
-  Mutex mutex;
-  AtomicCounterWithMutex locked_counter(&mutex);
-
-  typedef ThreadWithParam<pair<AtomicCounterWithMutex*, int> > ThreadType;
-  const int kCycleCount = 20;
-  const int kThreadCount = 7;
-  scoped_ptr<ThreadType> counting_threads[kThreadCount];
-  Notification threads_can_start;
-  // Creates and runs kThreadCount threads that increment locked_counter
-  // kCycleCount times each.
-  for (int i = 0; i < kThreadCount; ++i) {
-    counting_threads[i].reset(new ThreadType(&CountingThreadFunc,
-                                             make_pair(&locked_counter,
-                                                       kCycleCount),
-                                             &threads_can_start));
-  }
-  threads_can_start.Notify();
-  for (int i = 0; i < kThreadCount; ++i)
-    counting_threads[i]->Join();
-
-  // If the mutex lets more than one thread to increment the counter at a
-  // time, they are likely to encounter a race condition and have some
-  // increments overwritten, resulting in the lower then expected counter
-  // value.
-  EXPECT_EQ(kCycleCount * kThreadCount, locked_counter.value());
-}
-
-template <typename T>
-void RunFromThread(void (func)(T), T param) {
-  ThreadWithParam<T> thread(func, param, NULL);
-  thread.Join();
-}
-
-void RetrieveThreadLocalValue(
-    pair<ThreadLocal<std::string>*, std::string*> param) {
-  *param.second = param.first->get();
-}
-
-TEST(ThreadLocalTest, ParameterizedConstructorSetsDefault) {
-  ThreadLocal<std::string> thread_local_string("foo");
-  EXPECT_STREQ("foo", thread_local_string.get().c_str());
-
-  thread_local_string.set("bar");
-  EXPECT_STREQ("bar", thread_local_string.get().c_str());
-
-  std::string result;
-  RunFromThread(&RetrieveThreadLocalValue,
-                make_pair(&thread_local_string, &result));
-  EXPECT_STREQ("foo", result.c_str());
-}
-
-// Keeps track of whether of destructors being called on instances of
-// DestructorTracker.  On Windows, waits for the destructor call reports.
-class DestructorCall {
- public:
-  DestructorCall() {
-    invoked_ = false;
-#if GTEST_OS_WINDOWS
-    wait_event_.Reset(::CreateEvent(NULL, TRUE, FALSE, NULL));
-    GTEST_CHECK_(wait_event_.Get() != NULL);
-#endif
-  }
-
-  bool CheckDestroyed() const {
-#if GTEST_OS_WINDOWS
-    if (::WaitForSingleObject(wait_event_.Get(), 1000) != WAIT_OBJECT_0)
-      return false;
-#endif
-    return invoked_;
-  }
-
-  void ReportDestroyed() {
-    invoked_ = true;
-#if GTEST_OS_WINDOWS
-    ::SetEvent(wait_event_.Get());
-#endif
-  }
-
-  static std::vector<DestructorCall*>& List() { return *list_; }
-
-  static void ResetList() {
-    for (size_t i = 0; i < list_->size(); ++i) {
-      delete list_->at(i);
-    }
-    list_->clear();
-  }
-
- private:
-  bool invoked_;
-#if GTEST_OS_WINDOWS
-  AutoHandle wait_event_;
-#endif
-  static std::vector<DestructorCall*>* const list_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DestructorCall);
-};
-
-std::vector<DestructorCall*>* const DestructorCall::list_ =
-    new std::vector<DestructorCall*>;
-
-// DestructorTracker keeps track of whether its instances have been
-// destroyed.
-class DestructorTracker {
- public:
-  DestructorTracker() : index_(GetNewIndex()) {}
-  DestructorTracker(const DestructorTracker& /* rhs */)
-      : index_(GetNewIndex()) {}
-  ~DestructorTracker() {
-    // We never access DestructorCall::List() concurrently, so we don't need
-    // to protect this acccess with a mutex.
-    DestructorCall::List()[index_]->ReportDestroyed();
-  }
-
- private:
-  static size_t GetNewIndex() {
-    DestructorCall::List().push_back(new DestructorCall);
-    return DestructorCall::List().size() - 1;
-  }
-  const size_t index_;
-
-  GTEST_DISALLOW_ASSIGN_(DestructorTracker);
-};
-
-typedef ThreadLocal<DestructorTracker>* ThreadParam;
-
-void CallThreadLocalGet(ThreadParam thread_local_param) {
-  thread_local_param->get();
-}
-
-// Tests that when a ThreadLocal object dies in a thread, it destroys
-// the managed object for that thread.
-TEST(ThreadLocalTest, DestroysManagedObjectForOwnThreadWhenDying) {
-  DestructorCall::ResetList();
-
-  {
-    ThreadLocal<DestructorTracker> thread_local_tracker;
-    ASSERT_EQ(0U, DestructorCall::List().size());
-
-    // This creates another DestructorTracker object for the main thread.
-    thread_local_tracker.get();
-    ASSERT_EQ(1U, DestructorCall::List().size());
-    ASSERT_FALSE(DestructorCall::List()[0]->CheckDestroyed());
-  }
-
-  // Now thread_local_tracker has died.
-  ASSERT_EQ(1U, DestructorCall::List().size());
-  EXPECT_TRUE(DestructorCall::List()[0]->CheckDestroyed());
-
-  DestructorCall::ResetList();
-}
-
-// Tests that when a thread exits, the thread-local object for that
-// thread is destroyed.
-TEST(ThreadLocalTest, DestroysManagedObjectAtThreadExit) {
-  DestructorCall::ResetList();
-
-  {
-    ThreadLocal<DestructorTracker> thread_local_tracker;
-    ASSERT_EQ(0U, DestructorCall::List().size());
-
-    // This creates another DestructorTracker object in the new thread.
-    ThreadWithParam<ThreadParam> thread(
-        &CallThreadLocalGet, &thread_local_tracker, NULL);
-    thread.Join();
-
-    // The thread has exited, and we should have a DestroyedTracker
-    // instance created for it. But it may not have been destroyed yet.
-    ASSERT_EQ(1U, DestructorCall::List().size());
-  }
-
-  // The thread has exited and thread_local_tracker has died.
-  ASSERT_EQ(1U, DestructorCall::List().size());
-  EXPECT_TRUE(DestructorCall::List()[0]->CheckDestroyed());
-
-  DestructorCall::ResetList();
-}
-
-TEST(ThreadLocalTest, ThreadLocalMutationsAffectOnlyCurrentThread) {
-  ThreadLocal<std::string> thread_local_string;
-  thread_local_string.set("Foo");
-  EXPECT_STREQ("Foo", thread_local_string.get().c_str());
-
-  std::string result;
-  RunFromThread(&RetrieveThreadLocalValue,
-                make_pair(&thread_local_string, &result));
-  EXPECT_TRUE(result.empty());
-}
-
-#endif  // GTEST_IS_THREADSAFE
-
-#if GTEST_OS_WINDOWS
-TEST(WindowsTypesTest, HANDLEIsVoidStar) {
-  StaticAssertTypeEq<HANDLE, void*>();
-}
-
-#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR)
-TEST(WindowsTypesTest, _CRITICAL_SECTIONIs_CRITICAL_SECTION) {
-  StaticAssertTypeEq<CRITICAL_SECTION, _CRITICAL_SECTION>();
-}
-#else
-TEST(WindowsTypesTest, CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION) {
-  StaticAssertTypeEq<CRITICAL_SECTION, _RTL_CRITICAL_SECTION>();
-}
-#endif
-
-#endif  // GTEST_OS_WINDOWS
-
-}  // namespace internal
-}  // namespace testing
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-printers_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-printers_test.cc
deleted file mode 100644
index 3e97cc24..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-printers_test.cc
+++ /dev/null
@@ -1,1635 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Google Test - The Google C++ Testing Framework
-//
-// This file tests the universal value printer.
-
-#include "gtest/gtest-printers.h"
-
-#include <ctype.h>
-#include <limits.h>
-#include <string.h>
-#include <algorithm>
-#include <deque>
-#include <list>
-#include <map>
-#include <set>
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "gtest/gtest.h"
-
-// hash_map and hash_set are available under Visual C++, or on Linux.
-#if GTEST_HAS_HASH_MAP_
-# include <hash_map>            // NOLINT
-#endif  // GTEST_HAS_HASH_MAP_
-#if GTEST_HAS_HASH_SET_
-# include <hash_set>            // NOLINT
-#endif  // GTEST_HAS_HASH_SET_
-
-#if GTEST_HAS_STD_FORWARD_LIST_
-# include <forward_list> // NOLINT
-#endif  // GTEST_HAS_STD_FORWARD_LIST_
-
-// Some user-defined types for testing the universal value printer.
-
-// An anonymous enum type.
-enum AnonymousEnum {
-  kAE1 = -1,
-  kAE2 = 1
-};
-
-// An enum without a user-defined printer.
-enum EnumWithoutPrinter {
-  kEWP1 = -2,
-  kEWP2 = 42
-};
-
-// An enum with a << operator.
-enum EnumWithStreaming {
-  kEWS1 = 10
-};
-
-std::ostream& operator<<(std::ostream& os, EnumWithStreaming e) {
-  return os << (e == kEWS1 ? "kEWS1" : "invalid");
-}
-
-// An enum with a PrintTo() function.
-enum EnumWithPrintTo {
-  kEWPT1 = 1
-};
-
-void PrintTo(EnumWithPrintTo e, std::ostream* os) {
-  *os << (e == kEWPT1 ? "kEWPT1" : "invalid");
-}
-
-// A class implicitly convertible to BiggestInt.
-class BiggestIntConvertible {
- public:
-  operator ::testing::internal::BiggestInt() const { return 42; }
-};
-
-// A user-defined unprintable class template in the global namespace.
-template <typename T>
-class UnprintableTemplateInGlobal {
- public:
-  UnprintableTemplateInGlobal() : value_() {}
- private:
-  T value_;
-};
-
-// A user-defined streamable type in the global namespace.
-class StreamableInGlobal {
- public:
-  virtual ~StreamableInGlobal() {}
-};
-
-inline void operator<<(::std::ostream& os, const StreamableInGlobal& /* x */) {
-  os << "StreamableInGlobal";
-}
-
-void operator<<(::std::ostream& os, const StreamableInGlobal* /* x */) {
-  os << "StreamableInGlobal*";
-}
-
-namespace foo {
-
-// A user-defined unprintable type in a user namespace.
-class UnprintableInFoo {
- public:
-  UnprintableInFoo() : z_(0) { memcpy(xy_, "\xEF\x12\x0\x0\x34\xAB\x0\x0", 8); }
-  double z() const { return z_; }
- private:
-  char xy_[8];
-  double z_;
-};
-
-// A user-defined printable type in a user-chosen namespace.
-struct PrintableViaPrintTo {
-  PrintableViaPrintTo() : value() {}
-  int value;
-};
-
-void PrintTo(const PrintableViaPrintTo& x, ::std::ostream* os) {
-  *os << "PrintableViaPrintTo: " << x.value;
-}
-
-// A type with a user-defined << for printing its pointer.
-struct PointerPrintable {
-};
-
-::std::ostream& operator<<(::std::ostream& os,
-                           const PointerPrintable* /* x */) {
-  return os << "PointerPrintable*";
-}
-
-// A user-defined printable class template in a user-chosen namespace.
-template <typename T>
-class PrintableViaPrintToTemplate {
- public:
-  explicit PrintableViaPrintToTemplate(const T& a_value) : value_(a_value) {}
-
-  const T& value() const { return value_; }
- private:
-  T value_;
-};
-
-template <typename T>
-void PrintTo(const PrintableViaPrintToTemplate<T>& x, ::std::ostream* os) {
-  *os << "PrintableViaPrintToTemplate: " << x.value();
-}
-
-// A user-defined streamable class template in a user namespace.
-template <typename T>
-class StreamableTemplateInFoo {
- public:
-  StreamableTemplateInFoo() : value_() {}
-
-  const T& value() const { return value_; }
- private:
-  T value_;
-};
-
-template <typename T>
-inline ::std::ostream& operator<<(::std::ostream& os,
-                                  const StreamableTemplateInFoo<T>& x) {
-  return os << "StreamableTemplateInFoo: " << x.value();
-}
-
-}  // namespace foo
-
-namespace testing {
-namespace gtest_printers_test {
-
-using ::std::deque;
-using ::std::list;
-using ::std::make_pair;
-using ::std::map;
-using ::std::multimap;
-using ::std::multiset;
-using ::std::pair;
-using ::std::set;
-using ::std::vector;
-using ::testing::PrintToString;
-using ::testing::internal::FormatForComparisonFailureMessage;
-using ::testing::internal::ImplicitCast_;
-using ::testing::internal::NativeArray;
-using ::testing::internal::RE;
-using ::testing::internal::RelationToSourceReference;
-using ::testing::internal::Strings;
-using ::testing::internal::UniversalPrint;
-using ::testing::internal::UniversalPrinter;
-using ::testing::internal::UniversalTersePrint;
-using ::testing::internal::UniversalTersePrintTupleFieldsToStrings;
-using ::testing::internal::string;
-
-// The hash_* classes are not part of the C++ standard.  STLport
-// defines them in namespace std.  MSVC defines them in ::stdext.  GCC
-// defines them in ::.
-#ifdef _STLP_HASH_MAP  // We got <hash_map> from STLport.
-using ::std::hash_map;
-using ::std::hash_set;
-using ::std::hash_multimap;
-using ::std::hash_multiset;
-#elif _MSC_VER
-using ::stdext::hash_map;
-using ::stdext::hash_set;
-using ::stdext::hash_multimap;
-using ::stdext::hash_multiset;
-#endif
-
-// Prints a value to a string using the universal value printer.  This
-// is a helper for testing UniversalPrinter<T>::Print() for various types.
-template <typename T>
-string Print(const T& value) {
-  ::std::stringstream ss;
-  UniversalPrinter<T>::Print(value, &ss);
-  return ss.str();
-}
-
-// Prints a value passed by reference to a string, using the universal
-// value printer.  This is a helper for testing
-// UniversalPrinter<T&>::Print() for various types.
-template <typename T>
-string PrintByRef(const T& value) {
-  ::std::stringstream ss;
-  UniversalPrinter<T&>::Print(value, &ss);
-  return ss.str();
-}
-
-// Tests printing various enum types.
-
-TEST(PrintEnumTest, AnonymousEnum) {
-  EXPECT_EQ("-1", Print(kAE1));
-  EXPECT_EQ("1", Print(kAE2));
-}
-
-TEST(PrintEnumTest, EnumWithoutPrinter) {
-  EXPECT_EQ("-2", Print(kEWP1));
-  EXPECT_EQ("42", Print(kEWP2));
-}
-
-TEST(PrintEnumTest, EnumWithStreaming) {
-  EXPECT_EQ("kEWS1", Print(kEWS1));
-  EXPECT_EQ("invalid", Print(static_cast<EnumWithStreaming>(0)));
-}
-
-TEST(PrintEnumTest, EnumWithPrintTo) {
-  EXPECT_EQ("kEWPT1", Print(kEWPT1));
-  EXPECT_EQ("invalid", Print(static_cast<EnumWithPrintTo>(0)));
-}
-
-// Tests printing a class implicitly convertible to BiggestInt.
-
-TEST(PrintClassTest, BiggestIntConvertible) {
-  EXPECT_EQ("42", Print(BiggestIntConvertible()));
-}
-
-// Tests printing various char types.
-
-// char.
-TEST(PrintCharTest, PlainChar) {
-  EXPECT_EQ("'\\0'", Print('\0'));
-  EXPECT_EQ("'\\'' (39, 0x27)", Print('\''));
-  EXPECT_EQ("'\"' (34, 0x22)", Print('"'));
-  EXPECT_EQ("'?' (63, 0x3F)", Print('?'));
-  EXPECT_EQ("'\\\\' (92, 0x5C)", Print('\\'));
-  EXPECT_EQ("'\\a' (7)", Print('\a'));
-  EXPECT_EQ("'\\b' (8)", Print('\b'));
-  EXPECT_EQ("'\\f' (12, 0xC)", Print('\f'));
-  EXPECT_EQ("'\\n' (10, 0xA)", Print('\n'));
-  EXPECT_EQ("'\\r' (13, 0xD)", Print('\r'));
-  EXPECT_EQ("'\\t' (9)", Print('\t'));
-  EXPECT_EQ("'\\v' (11, 0xB)", Print('\v'));
-  EXPECT_EQ("'\\x7F' (127)", Print('\x7F'));
-  EXPECT_EQ("'\\xFF' (255)", Print('\xFF'));
-  EXPECT_EQ("' ' (32, 0x20)", Print(' '));
-  EXPECT_EQ("'a' (97, 0x61)", Print('a'));
-}
-
-// signed char.
-TEST(PrintCharTest, SignedChar) {
-  EXPECT_EQ("'\\0'", Print(static_cast<signed char>('\0')));
-  EXPECT_EQ("'\\xCE' (-50)",
-            Print(static_cast<signed char>(-50)));
-}
-
-// unsigned char.
-TEST(PrintCharTest, UnsignedChar) {
-  EXPECT_EQ("'\\0'", Print(static_cast<unsigned char>('\0')));
-  EXPECT_EQ("'b' (98, 0x62)",
-            Print(static_cast<unsigned char>('b')));
-}
-
-// Tests printing other simple, built-in types.
-
-// bool.
-TEST(PrintBuiltInTypeTest, Bool) {
-  EXPECT_EQ("false", Print(false));
-  EXPECT_EQ("true", Print(true));
-}
-
-// wchar_t.
-TEST(PrintBuiltInTypeTest, Wchar_t) {
-  EXPECT_EQ("L'\\0'", Print(L'\0'));
-  EXPECT_EQ("L'\\'' (39, 0x27)", Print(L'\''));
-  EXPECT_EQ("L'\"' (34, 0x22)", Print(L'"'));
-  EXPECT_EQ("L'?' (63, 0x3F)", Print(L'?'));
-  EXPECT_EQ("L'\\\\' (92, 0x5C)", Print(L'\\'));
-  EXPECT_EQ("L'\\a' (7)", Print(L'\a'));
-  EXPECT_EQ("L'\\b' (8)", Print(L'\b'));
-  EXPECT_EQ("L'\\f' (12, 0xC)", Print(L'\f'));
-  EXPECT_EQ("L'\\n' (10, 0xA)", Print(L'\n'));
-  EXPECT_EQ("L'\\r' (13, 0xD)", Print(L'\r'));
-  EXPECT_EQ("L'\\t' (9)", Print(L'\t'));
-  EXPECT_EQ("L'\\v' (11, 0xB)", Print(L'\v'));
-  EXPECT_EQ("L'\\x7F' (127)", Print(L'\x7F'));
-  EXPECT_EQ("L'\\xFF' (255)", Print(L'\xFF'));
-  EXPECT_EQ("L' ' (32, 0x20)", Print(L' '));
-  EXPECT_EQ("L'a' (97, 0x61)", Print(L'a'));
-  EXPECT_EQ("L'\\x576' (1398)", Print(static_cast<wchar_t>(0x576)));
-  EXPECT_EQ("L'\\xC74D' (51021)", Print(static_cast<wchar_t>(0xC74D)));
-}
-
-// Test that Int64 provides more storage than wchar_t.
-TEST(PrintTypeSizeTest, Wchar_t) {
-  EXPECT_LT(sizeof(wchar_t), sizeof(testing::internal::Int64));
-}
-
-// Various integer types.
-TEST(PrintBuiltInTypeTest, Integer) {
-  EXPECT_EQ("'\\xFF' (255)", Print(static_cast<unsigned char>(255)));  // uint8
-  EXPECT_EQ("'\\x80' (-128)", Print(static_cast<signed char>(-128)));  // int8
-  EXPECT_EQ("65535", Print(USHRT_MAX));  // uint16
-  EXPECT_EQ("-32768", Print(SHRT_MIN));  // int16
-  EXPECT_EQ("4294967295", Print(UINT_MAX));  // uint32
-  EXPECT_EQ("-2147483648", Print(INT_MIN));  // int32
-  EXPECT_EQ("18446744073709551615",
-            Print(static_cast<testing::internal::UInt64>(-1)));  // uint64
-  EXPECT_EQ("-9223372036854775808",
-            Print(static_cast<testing::internal::Int64>(1) << 63));  // int64
-}
-
-// Size types.
-TEST(PrintBuiltInTypeTest, Size_t) {
-  EXPECT_EQ("1", Print(sizeof('a')));  // size_t.
-#if !GTEST_OS_WINDOWS
-  // Windows has no ssize_t type.
-  EXPECT_EQ("-2", Print(static_cast<ssize_t>(-2)));  // ssize_t.
-#endif  // !GTEST_OS_WINDOWS
-}
-
-// Floating-points.
-TEST(PrintBuiltInTypeTest, FloatingPoints) {
-  EXPECT_EQ("1.5", Print(1.5f));   // float
-  EXPECT_EQ("-2.5", Print(-2.5));  // double
-}
-
-// Since ::std::stringstream::operator<<(const void *) formats the pointer
-// output differently with different compilers, we have to create the expected
-// output first and use it as our expectation.
-static string PrintPointer(const void *p) {
-  ::std::stringstream expected_result_stream;
-  expected_result_stream << p;
-  return expected_result_stream.str();
-}
-
-// Tests printing C strings.
-
-// const char*.
-TEST(PrintCStringTest, Const) {
-  const char* p = "World";
-  EXPECT_EQ(PrintPointer(p) + " pointing to \"World\"", Print(p));
-}
-
-// char*.
-TEST(PrintCStringTest, NonConst) {
-  char p[] = "Hi";
-  EXPECT_EQ(PrintPointer(p) + " pointing to \"Hi\"",
-            Print(static_cast<char*>(p)));
-}
-
-// NULL C string.
-TEST(PrintCStringTest, Null) {
-  const char* p = NULL;
-  EXPECT_EQ("NULL", Print(p));
-}
-
-// Tests that C strings are escaped properly.
-TEST(PrintCStringTest, EscapesProperly) {
-  const char* p = "'\"?\\\a\b\f\n\r\t\v\x7F\xFF a";
-  EXPECT_EQ(PrintPointer(p) + " pointing to \"'\\\"?\\\\\\a\\b\\f"
-            "\\n\\r\\t\\v\\x7F\\xFF a\"",
-            Print(p));
-}
-
-// 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,
-// possibly accessing more memory than intended and causing invalid
-// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
-// wchar_t is implemented as a native type.
-#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
-
-// const wchar_t*.
-TEST(PrintWideCStringTest, Const) {
-  const wchar_t* p = L"World";
-  EXPECT_EQ(PrintPointer(p) + " pointing to L\"World\"", Print(p));
-}
-
-// wchar_t*.
-TEST(PrintWideCStringTest, NonConst) {
-  wchar_t p[] = L"Hi";
-  EXPECT_EQ(PrintPointer(p) + " pointing to L\"Hi\"",
-            Print(static_cast<wchar_t*>(p)));
-}
-
-// NULL wide C string.
-TEST(PrintWideCStringTest, Null) {
-  const wchar_t* p = NULL;
-  EXPECT_EQ("NULL", Print(p));
-}
-
-// Tests that wide C strings are escaped properly.
-TEST(PrintWideCStringTest, EscapesProperly) {
-  const wchar_t s[] = {'\'', '"', '?', '\\', '\a', '\b', '\f', '\n', '\r',
-                       '\t', '\v', 0xD3, 0x576, 0x8D3, 0xC74D, ' ', 'a', '\0'};
-  EXPECT_EQ(PrintPointer(s) + " pointing to L\"'\\\"?\\\\\\a\\b\\f"
-            "\\n\\r\\t\\v\\xD3\\x576\\x8D3\\xC74D a\"",
-            Print(static_cast<const wchar_t*>(s)));
-}
-#endif  // native wchar_t
-
-// Tests printing pointers to other char types.
-
-// signed char*.
-TEST(PrintCharPointerTest, SignedChar) {
-  signed char* p = reinterpret_cast<signed char*>(0x1234);
-  EXPECT_EQ(PrintPointer(p), Print(p));
-  p = NULL;
-  EXPECT_EQ("NULL", Print(p));
-}
-
-// const signed char*.
-TEST(PrintCharPointerTest, ConstSignedChar) {
-  signed char* p = reinterpret_cast<signed char*>(0x1234);
-  EXPECT_EQ(PrintPointer(p), Print(p));
-  p = NULL;
-  EXPECT_EQ("NULL", Print(p));
-}
-
-// unsigned char*.
-TEST(PrintCharPointerTest, UnsignedChar) {
-  unsigned char* p = reinterpret_cast<unsigned char*>(0x1234);
-  EXPECT_EQ(PrintPointer(p), Print(p));
-  p = NULL;
-  EXPECT_EQ("NULL", Print(p));
-}
-
-// const unsigned char*.
-TEST(PrintCharPointerTest, ConstUnsignedChar) {
-  const unsigned char* p = reinterpret_cast<const unsigned char*>(0x1234);
-  EXPECT_EQ(PrintPointer(p), Print(p));
-  p = NULL;
-  EXPECT_EQ("NULL", Print(p));
-}
-
-// Tests printing pointers to simple, built-in types.
-
-// bool*.
-TEST(PrintPointerToBuiltInTypeTest, Bool) {
-  bool* p = reinterpret_cast<bool*>(0xABCD);
-  EXPECT_EQ(PrintPointer(p), Print(p));
-  p = NULL;
-  EXPECT_EQ("NULL", Print(p));
-}
-
-// void*.
-TEST(PrintPointerToBuiltInTypeTest, Void) {
-  void* p = reinterpret_cast<void*>(0xABCD);
-  EXPECT_EQ(PrintPointer(p), Print(p));
-  p = NULL;
-  EXPECT_EQ("NULL", Print(p));
-}
-
-// const void*.
-TEST(PrintPointerToBuiltInTypeTest, ConstVoid) {
-  const void* p = reinterpret_cast<const void*>(0xABCD);
-  EXPECT_EQ(PrintPointer(p), Print(p));
-  p = NULL;
-  EXPECT_EQ("NULL", Print(p));
-}
-
-// Tests printing pointers to pointers.
-TEST(PrintPointerToPointerTest, IntPointerPointer) {
-  int** p = reinterpret_cast<int**>(0xABCD);
-  EXPECT_EQ(PrintPointer(p), Print(p));
-  p = NULL;
-  EXPECT_EQ("NULL", Print(p));
-}
-
-// Tests printing (non-member) function pointers.
-
-void MyFunction(int /* n */) {}
-
-TEST(PrintPointerTest, NonMemberFunctionPointer) {
-  // We cannot directly cast &MyFunction to const void* because the
-  // standard disallows casting between pointers to functions and
-  // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
-  // this limitation.
-  EXPECT_EQ(
-      PrintPointer(reinterpret_cast<const void*>(
-          reinterpret_cast<internal::BiggestInt>(&MyFunction))),
-      Print(&MyFunction));
-  int (*p)(bool) = NULL;  // NOLINT
-  EXPECT_EQ("NULL", Print(p));
-}
-
-// An assertion predicate determining whether a one string is a prefix for
-// another.
-template <typename StringType>
-AssertionResult HasPrefix(const StringType& str, const StringType& prefix) {
-  if (str.find(prefix, 0) == 0)
-    return AssertionSuccess();
-
-  const bool is_wide_string = sizeof(prefix[0]) > 1;
-  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
-  return AssertionFailure()
-      << begin_string_quote << prefix << "\" is not a prefix of "
-      << begin_string_quote << str << "\"\n";
-}
-
-// Tests printing member variable pointers.  Although they are called
-// pointers, they don't point to a location in the address space.
-// Their representation is implementation-defined.  Thus they will be
-// printed as raw bytes.
-
-struct Foo {
- public:
-  virtual ~Foo() {}
-  int MyMethod(char x) { return x + 1; }
-  virtual char MyVirtualMethod(int /* n */) { return 'a'; }
-
-  int value;
-};
-
-TEST(PrintPointerTest, MemberVariablePointer) {
-  EXPECT_TRUE(HasPrefix(Print(&Foo::value),
-                        Print(sizeof(&Foo::value)) + "-byte object "));
-  int (Foo::*p) = NULL;  // NOLINT
-  EXPECT_TRUE(HasPrefix(Print(p),
-                        Print(sizeof(p)) + "-byte object "));
-}
-
-// Tests printing member function pointers.  Although they are called
-// pointers, they don't point to a location in the address space.
-// Their representation is implementation-defined.  Thus they will be
-// printed as raw bytes.
-TEST(PrintPointerTest, MemberFunctionPointer) {
-  EXPECT_TRUE(HasPrefix(Print(&Foo::MyMethod),
-                        Print(sizeof(&Foo::MyMethod)) + "-byte object "));
-  EXPECT_TRUE(
-      HasPrefix(Print(&Foo::MyVirtualMethod),
-                Print(sizeof((&Foo::MyVirtualMethod))) + "-byte object "));
-  int (Foo::*p)(char) = NULL;  // NOLINT
-  EXPECT_TRUE(HasPrefix(Print(p),
-                        Print(sizeof(p)) + "-byte object "));
-}
-
-// Tests printing C arrays.
-
-// The difference between this and Print() is that it ensures that the
-// argument is a reference to an array.
-template <typename T, size_t N>
-string PrintArrayHelper(T (&a)[N]) {
-  return Print(a);
-}
-
-// One-dimensional array.
-TEST(PrintArrayTest, OneDimensionalArray) {
-  int a[5] = { 1, 2, 3, 4, 5 };
-  EXPECT_EQ("{ 1, 2, 3, 4, 5 }", PrintArrayHelper(a));
-}
-
-// Two-dimensional array.
-TEST(PrintArrayTest, TwoDimensionalArray) {
-  int a[2][5] = {
-    { 1, 2, 3, 4, 5 },
-    { 6, 7, 8, 9, 0 }
-  };
-  EXPECT_EQ("{ { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 0 } }", PrintArrayHelper(a));
-}
-
-// Array of const elements.
-TEST(PrintArrayTest, ConstArray) {
-  const bool a[1] = { false };
-  EXPECT_EQ("{ false }", PrintArrayHelper(a));
-}
-
-// char array without terminating NUL.
-TEST(PrintArrayTest, CharArrayWithNoTerminatingNul) {
-  // Array a contains '\0' in the middle and doesn't end with '\0'.
-  char a[] = { 'H', '\0', 'i' };
-  EXPECT_EQ("\"H\\0i\" (no terminating NUL)", PrintArrayHelper(a));
-}
-
-// const char array with terminating NUL.
-TEST(PrintArrayTest, ConstCharArrayWithTerminatingNul) {
-  const char a[] = "\0Hi";
-  EXPECT_EQ("\"\\0Hi\"", PrintArrayHelper(a));
-}
-
-// const wchar_t array without terminating NUL.
-TEST(PrintArrayTest, WCharArrayWithNoTerminatingNul) {
-  // Array a contains '\0' in the middle and doesn't end with '\0'.
-  const wchar_t a[] = { L'H', L'\0', L'i' };
-  EXPECT_EQ("L\"H\\0i\" (no terminating NUL)", PrintArrayHelper(a));
-}
-
-// wchar_t array with terminating NUL.
-TEST(PrintArrayTest, WConstCharArrayWithTerminatingNul) {
-  const wchar_t a[] = L"\0Hi";
-  EXPECT_EQ("L\"\\0Hi\"", PrintArrayHelper(a));
-}
-
-// Array of objects.
-TEST(PrintArrayTest, ObjectArray) {
-  string a[3] = { "Hi", "Hello", "Ni hao" };
-  EXPECT_EQ("{ \"Hi\", \"Hello\", \"Ni hao\" }", PrintArrayHelper(a));
-}
-
-// Array with many elements.
-TEST(PrintArrayTest, BigArray) {
-  int a[100] = { 1, 2, 3 };
-  EXPECT_EQ("{ 1, 2, 3, 0, 0, 0, 0, 0, ..., 0, 0, 0, 0, 0, 0, 0, 0 }",
-            PrintArrayHelper(a));
-}
-
-// Tests printing ::string and ::std::string.
-
-#if GTEST_HAS_GLOBAL_STRING
-// ::string.
-TEST(PrintStringTest, StringInGlobalNamespace) {
-  const char s[] = "'\"?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
-  const ::string str(s, sizeof(s));
-  EXPECT_EQ("\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
-            Print(str));
-}
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-// ::std::string.
-TEST(PrintStringTest, StringInStdNamespace) {
-  const char s[] = "'\"?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
-  const ::std::string str(s, sizeof(s));
-  EXPECT_EQ("\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
-            Print(str));
-}
-
-TEST(PrintStringTest, StringAmbiguousHex) {
-  // "\x6BANANA" is ambiguous, it can be interpreted as starting with either of:
-  // '\x6', '\x6B', or '\x6BA'.
-
-  // a hex escaping sequence following by a decimal digit
-  EXPECT_EQ("\"0\\x12\" \"3\"", Print(::std::string("0\x12" "3")));
-  // a hex escaping sequence following by a hex digit (lower-case)
-  EXPECT_EQ("\"mm\\x6\" \"bananas\"", Print(::std::string("mm\x6" "bananas")));
-  // a hex escaping sequence following by a hex digit (upper-case)
-  EXPECT_EQ("\"NOM\\x6\" \"BANANA\"", Print(::std::string("NOM\x6" "BANANA")));
-  // a hex escaping sequence following by a non-xdigit
-  EXPECT_EQ("\"!\\x5-!\"", Print(::std::string("!\x5-!")));
-}
-
-// Tests printing ::wstring and ::std::wstring.
-
-#if GTEST_HAS_GLOBAL_WSTRING
-// ::wstring.
-TEST(PrintWideStringTest, StringInGlobalNamespace) {
-  const wchar_t s[] = L"'\"?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
-  const ::wstring str(s, sizeof(s)/sizeof(wchar_t));
-  EXPECT_EQ("L\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v"
-            "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
-            Print(str));
-}
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-#if GTEST_HAS_STD_WSTRING
-// ::std::wstring.
-TEST(PrintWideStringTest, StringInStdNamespace) {
-  const wchar_t s[] = L"'\"?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
-  const ::std::wstring str(s, sizeof(s)/sizeof(wchar_t));
-  EXPECT_EQ("L\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v"
-            "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
-            Print(str));
-}
-
-TEST(PrintWideStringTest, StringAmbiguousHex) {
-  // same for wide strings.
-  EXPECT_EQ("L\"0\\x12\" L\"3\"", Print(::std::wstring(L"0\x12" L"3")));
-  EXPECT_EQ("L\"mm\\x6\" L\"bananas\"",
-            Print(::std::wstring(L"mm\x6" L"bananas")));
-  EXPECT_EQ("L\"NOM\\x6\" L\"BANANA\"",
-            Print(::std::wstring(L"NOM\x6" L"BANANA")));
-  EXPECT_EQ("L\"!\\x5-!\"", Print(::std::wstring(L"!\x5-!")));
-}
-#endif  // GTEST_HAS_STD_WSTRING
-
-// Tests printing types that support generic streaming (i.e. streaming
-// to std::basic_ostream<Char, CharTraits> for any valid Char and
-// CharTraits types).
-
-// Tests printing a non-template type that supports generic streaming.
-
-class AllowsGenericStreaming {};
-
-template <typename Char, typename CharTraits>
-std::basic_ostream<Char, CharTraits>& operator<<(
-    std::basic_ostream<Char, CharTraits>& os,
-    const AllowsGenericStreaming& /* a */) {
-  return os << "AllowsGenericStreaming";
-}
-
-TEST(PrintTypeWithGenericStreamingTest, NonTemplateType) {
-  AllowsGenericStreaming a;
-  EXPECT_EQ("AllowsGenericStreaming", Print(a));
-}
-
-// Tests printing a template type that supports generic streaming.
-
-template <typename T>
-class AllowsGenericStreamingTemplate {};
-
-template <typename Char, typename CharTraits, typename T>
-std::basic_ostream<Char, CharTraits>& operator<<(
-    std::basic_ostream<Char, CharTraits>& os,
-    const AllowsGenericStreamingTemplate<T>& /* a */) {
-  return os << "AllowsGenericStreamingTemplate";
-}
-
-TEST(PrintTypeWithGenericStreamingTest, TemplateType) {
-  AllowsGenericStreamingTemplate<int> a;
-  EXPECT_EQ("AllowsGenericStreamingTemplate", Print(a));
-}
-
-// Tests printing a type that supports generic streaming and can be
-// implicitly converted to another printable type.
-
-template <typename T>
-class AllowsGenericStreamingAndImplicitConversionTemplate {
- public:
-  operator bool() const { return false; }
-};
-
-template <typename Char, typename CharTraits, typename T>
-std::basic_ostream<Char, CharTraits>& operator<<(
-    std::basic_ostream<Char, CharTraits>& os,
-    const AllowsGenericStreamingAndImplicitConversionTemplate<T>& /* a */) {
-  return os << "AllowsGenericStreamingAndImplicitConversionTemplate";
-}
-
-TEST(PrintTypeWithGenericStreamingTest, TypeImplicitlyConvertible) {
-  AllowsGenericStreamingAndImplicitConversionTemplate<int> a;
-  EXPECT_EQ("AllowsGenericStreamingAndImplicitConversionTemplate", Print(a));
-}
-
-#if GTEST_HAS_STRING_PIECE_
-
-// Tests printing StringPiece.
-
-TEST(PrintStringPieceTest, SimpleStringPiece) {
-  const StringPiece sp = "Hello";
-  EXPECT_EQ("\"Hello\"", Print(sp));
-}
-
-TEST(PrintStringPieceTest, UnprintableCharacters) {
-  const char str[] = "NUL (\0) and \r\t";
-  const StringPiece sp(str, sizeof(str) - 1);
-  EXPECT_EQ("\"NUL (\\0) and \\r\\t\"", Print(sp));
-}
-
-#endif  // GTEST_HAS_STRING_PIECE_
-
-// Tests printing STL containers.
-
-TEST(PrintStlContainerTest, EmptyDeque) {
-  deque<char> empty;
-  EXPECT_EQ("{}", Print(empty));
-}
-
-TEST(PrintStlContainerTest, NonEmptyDeque) {
-  deque<int> non_empty;
-  non_empty.push_back(1);
-  non_empty.push_back(3);
-  EXPECT_EQ("{ 1, 3 }", Print(non_empty));
-}
-
-#if GTEST_HAS_HASH_MAP_
-
-TEST(PrintStlContainerTest, OneElementHashMap) {
-  hash_map<int, char> map1;
-  map1[1] = 'a';
-  EXPECT_EQ("{ (1, 'a' (97, 0x61)) }", Print(map1));
-}
-
-TEST(PrintStlContainerTest, HashMultiMap) {
-  hash_multimap<int, bool> map1;
-  map1.insert(make_pair(5, true));
-  map1.insert(make_pair(5, false));
-
-  // Elements of hash_multimap can be printed in any order.
-  const string result = Print(map1);
-  EXPECT_TRUE(result == "{ (5, true), (5, false) }" ||
-              result == "{ (5, false), (5, true) }")
-                  << " where Print(map1) returns \"" << result << "\".";
-}
-
-#endif  // GTEST_HAS_HASH_MAP_
-
-#if GTEST_HAS_HASH_SET_
-
-TEST(PrintStlContainerTest, HashSet) {
-  hash_set<string> set1;
-  set1.insert("hello");
-  EXPECT_EQ("{ \"hello\" }", Print(set1));
-}
-
-TEST(PrintStlContainerTest, HashMultiSet) {
-  const int kSize = 5;
-  int a[kSize] = { 1, 1, 2, 5, 1 };
-  hash_multiset<int> set1(a, a + kSize);
-
-  // Elements of hash_multiset can be printed in any order.
-  const string result = Print(set1);
-  const string expected_pattern = "{ d, d, d, d, d }";  // d means a digit.
-
-  // Verifies the result matches the expected pattern; also extracts
-  // the numbers in the result.
-  ASSERT_EQ(expected_pattern.length(), result.length());
-  std::vector<int> numbers;
-  for (size_t i = 0; i != result.length(); i++) {
-    if (expected_pattern[i] == 'd') {
-      ASSERT_NE(isdigit(static_cast<unsigned char>(result[i])), 0);
-      numbers.push_back(result[i] - '0');
-    } else {
-      EXPECT_EQ(expected_pattern[i], result[i]) << " where result is "
-                                                << result;
-    }
-  }
-
-  // Makes sure the result contains the right numbers.
-  std::sort(numbers.begin(), numbers.end());
-  std::sort(a, a + kSize);
-  EXPECT_TRUE(std::equal(a, a + kSize, numbers.begin()));
-}
-
-#endif  // GTEST_HAS_HASH_SET_
-
-TEST(PrintStlContainerTest, List) {
-  const string a[] = {
-    "hello",
-    "world"
-  };
-  const list<string> strings(a, a + 2);
-  EXPECT_EQ("{ \"hello\", \"world\" }", Print(strings));
-}
-
-TEST(PrintStlContainerTest, Map) {
-  map<int, bool> map1;
-  map1[1] = true;
-  map1[5] = false;
-  map1[3] = true;
-  EXPECT_EQ("{ (1, true), (3, true), (5, false) }", Print(map1));
-}
-
-TEST(PrintStlContainerTest, MultiMap) {
-  multimap<bool, int> map1;
-  // The make_pair template function would deduce the type as
-  // pair<bool, int> here, and since the key part in a multimap has to
-  // be constant, without a templated ctor in the pair class (as in
-  // libCstd on Solaris), make_pair call would fail to compile as no
-  // implicit conversion is found.  Thus explicit typename is used
-  // here instead.
-  map1.insert(pair<const bool, int>(true, 0));
-  map1.insert(pair<const bool, int>(true, 1));
-  map1.insert(pair<const bool, int>(false, 2));
-  EXPECT_EQ("{ (false, 2), (true, 0), (true, 1) }", Print(map1));
-}
-
-TEST(PrintStlContainerTest, Set) {
-  const unsigned int a[] = { 3, 0, 5 };
-  set<unsigned int> set1(a, a + 3);
-  EXPECT_EQ("{ 0, 3, 5 }", Print(set1));
-}
-
-TEST(PrintStlContainerTest, MultiSet) {
-  const int a[] = { 1, 1, 2, 5, 1 };
-  multiset<int> set1(a, a + 5);
-  EXPECT_EQ("{ 1, 1, 1, 2, 5 }", Print(set1));
-}
-
-#if GTEST_HAS_STD_FORWARD_LIST_
-// <slist> is available on Linux in the google3 mode, but not on
-// Windows or Mac OS X.
-
-TEST(PrintStlContainerTest, SinglyLinkedList) {
-  int a[] = { 9, 2, 8 };
-  const std::forward_list<int> ints(a, a + 3);
-  EXPECT_EQ("{ 9, 2, 8 }", Print(ints));
-}
-#endif  // GTEST_HAS_STD_FORWARD_LIST_
-
-TEST(PrintStlContainerTest, Pair) {
-  pair<const bool, int> p(true, 5);
-  EXPECT_EQ("(true, 5)", Print(p));
-}
-
-TEST(PrintStlContainerTest, Vector) {
-  vector<int> v;
-  v.push_back(1);
-  v.push_back(2);
-  EXPECT_EQ("{ 1, 2 }", Print(v));
-}
-
-TEST(PrintStlContainerTest, LongSequence) {
-  const int a[100] = { 1, 2, 3 };
-  const vector<int> v(a, a + 100);
-  EXPECT_EQ("{ 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
-            "0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... }", Print(v));
-}
-
-TEST(PrintStlContainerTest, NestedContainer) {
-  const int a1[] = { 1, 2 };
-  const int a2[] = { 3, 4, 5 };
-  const list<int> l1(a1, a1 + 2);
-  const list<int> l2(a2, a2 + 3);
-
-  vector<list<int> > v;
-  v.push_back(l1);
-  v.push_back(l2);
-  EXPECT_EQ("{ { 1, 2 }, { 3, 4, 5 } }", Print(v));
-}
-
-TEST(PrintStlContainerTest, OneDimensionalNativeArray) {
-  const int a[3] = { 1, 2, 3 };
-  NativeArray<int> b(a, 3, RelationToSourceReference());
-  EXPECT_EQ("{ 1, 2, 3 }", Print(b));
-}
-
-TEST(PrintStlContainerTest, TwoDimensionalNativeArray) {
-  const int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
-  NativeArray<int[3]> b(a, 2, RelationToSourceReference());
-  EXPECT_EQ("{ { 1, 2, 3 }, { 4, 5, 6 } }", Print(b));
-}
-
-// Tests that a class named iterator isn't treated as a container.
-
-struct iterator {
-  char x;
-};
-
-TEST(PrintStlContainerTest, Iterator) {
-  iterator it = {};
-  EXPECT_EQ("1-byte object <00>", Print(it));
-}
-
-// Tests that a class named const_iterator isn't treated as a container.
-
-struct const_iterator {
-  char x;
-};
-
-TEST(PrintStlContainerTest, ConstIterator) {
-  const_iterator it = {};
-  EXPECT_EQ("1-byte object <00>", Print(it));
-}
-
-#if GTEST_HAS_TR1_TUPLE
-// Tests printing ::std::tr1::tuples.
-
-// Tuples of various arities.
-TEST(PrintTr1TupleTest, VariousSizes) {
-  ::std::tr1::tuple<> t0;
-  EXPECT_EQ("()", Print(t0));
-
-  ::std::tr1::tuple<int> t1(5);
-  EXPECT_EQ("(5)", Print(t1));
-
-  ::std::tr1::tuple<char, bool> t2('a', true);
-  EXPECT_EQ("('a' (97, 0x61), true)", Print(t2));
-
-  ::std::tr1::tuple<bool, int, int> t3(false, 2, 3);
-  EXPECT_EQ("(false, 2, 3)", Print(t3));
-
-  ::std::tr1::tuple<bool, int, int, int> t4(false, 2, 3, 4);
-  EXPECT_EQ("(false, 2, 3, 4)", Print(t4));
-
-  ::std::tr1::tuple<bool, int, int, int, bool> t5(false, 2, 3, 4, true);
-  EXPECT_EQ("(false, 2, 3, 4, true)", Print(t5));
-
-  ::std::tr1::tuple<bool, int, int, int, bool, int> t6(false, 2, 3, 4, true, 6);
-  EXPECT_EQ("(false, 2, 3, 4, true, 6)", Print(t6));
-
-  ::std::tr1::tuple<bool, int, int, int, bool, int, int> t7(
-      false, 2, 3, 4, true, 6, 7);
-  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7)", Print(t7));
-
-  ::std::tr1::tuple<bool, int, int, int, bool, int, int, bool> t8(
-      false, 2, 3, 4, true, 6, 7, true);
-  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7, true)", Print(t8));
-
-  ::std::tr1::tuple<bool, int, int, int, bool, int, int, bool, int> t9(
-      false, 2, 3, 4, true, 6, 7, true, 9);
-  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7, true, 9)", Print(t9));
-
-  const char* const str = "8";
-  // VC++ 2010's implementation of tuple of C++0x is deficient, requiring
-  // an explicit type cast of NULL to be used.
-  ::std::tr1::tuple<bool, char, short, testing::internal::Int32,  // NOLINT
-      testing::internal::Int64, float, double, const char*, void*, string>
-      t10(false, 'a', 3, 4, 5, 1.5F, -2.5, str,
-          ImplicitCast_<void*>(NULL), "10");
-  EXPECT_EQ("(false, 'a' (97, 0x61), 3, 4, 5, 1.5, -2.5, " + PrintPointer(str) +
-            " pointing to \"8\", NULL, \"10\")",
-            Print(t10));
-}
-
-// Nested tuples.
-TEST(PrintTr1TupleTest, NestedTuple) {
-  ::std::tr1::tuple< ::std::tr1::tuple<int, bool>, char> nested(
-      ::std::tr1::make_tuple(5, true), 'a');
-  EXPECT_EQ("((5, true), 'a' (97, 0x61))", Print(nested));
-}
-
-#endif  // GTEST_HAS_TR1_TUPLE
-
-#if GTEST_HAS_STD_TUPLE_
-// Tests printing ::std::tuples.
-
-// Tuples of various arities.
-TEST(PrintStdTupleTest, VariousSizes) {
-  ::std::tuple<> t0;
-  EXPECT_EQ("()", Print(t0));
-
-  ::std::tuple<int> t1(5);
-  EXPECT_EQ("(5)", Print(t1));
-
-  ::std::tuple<char, bool> t2('a', true);
-  EXPECT_EQ("('a' (97, 0x61), true)", Print(t2));
-
-  ::std::tuple<bool, int, int> t3(false, 2, 3);
-  EXPECT_EQ("(false, 2, 3)", Print(t3));
-
-  ::std::tuple<bool, int, int, int> t4(false, 2, 3, 4);
-  EXPECT_EQ("(false, 2, 3, 4)", Print(t4));
-
-  ::std::tuple<bool, int, int, int, bool> t5(false, 2, 3, 4, true);
-  EXPECT_EQ("(false, 2, 3, 4, true)", Print(t5));
-
-  ::std::tuple<bool, int, int, int, bool, int> t6(false, 2, 3, 4, true, 6);
-  EXPECT_EQ("(false, 2, 3, 4, true, 6)", Print(t6));
-
-  ::std::tuple<bool, int, int, int, bool, int, int> t7(
-      false, 2, 3, 4, true, 6, 7);
-  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7)", Print(t7));
-
-  ::std::tuple<bool, int, int, int, bool, int, int, bool> t8(
-      false, 2, 3, 4, true, 6, 7, true);
-  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7, true)", Print(t8));
-
-  ::std::tuple<bool, int, int, int, bool, int, int, bool, int> t9(
-      false, 2, 3, 4, true, 6, 7, true, 9);
-  EXPECT_EQ("(false, 2, 3, 4, true, 6, 7, true, 9)", Print(t9));
-
-  const char* const str = "8";
-  // VC++ 2010's implementation of tuple of C++0x is deficient, requiring
-  // an explicit type cast of NULL to be used.
-  ::std::tuple<bool, char, short, testing::internal::Int32,  // NOLINT
-      testing::internal::Int64, float, double, const char*, void*, string>
-      t10(false, 'a', 3, 4, 5, 1.5F, -2.5, str,
-          ImplicitCast_<void*>(NULL), "10");
-  EXPECT_EQ("(false, 'a' (97, 0x61), 3, 4, 5, 1.5, -2.5, " + PrintPointer(str) +
-            " pointing to \"8\", NULL, \"10\")",
-            Print(t10));
-}
-
-// Nested tuples.
-TEST(PrintStdTupleTest, NestedTuple) {
-  ::std::tuple< ::std::tuple<int, bool>, char> nested(
-      ::std::make_tuple(5, true), 'a');
-  EXPECT_EQ("((5, true), 'a' (97, 0x61))", Print(nested));
-}
-
-#endif  // GTEST_LANG_CXX11
-
-// Tests printing user-defined unprintable types.
-
-// Unprintable types in the global namespace.
-TEST(PrintUnprintableTypeTest, InGlobalNamespace) {
-  EXPECT_EQ("1-byte object <00>",
-            Print(UnprintableTemplateInGlobal<char>()));
-}
-
-// Unprintable types in a user namespace.
-TEST(PrintUnprintableTypeTest, InUserNamespace) {
-  EXPECT_EQ("16-byte object <EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
-            Print(::foo::UnprintableInFoo()));
-}
-
-// Unprintable types are that too big to be printed completely.
-
-struct Big {
-  Big() { memset(array, 0, sizeof(array)); }
-  char array[257];
-};
-
-TEST(PrintUnpritableTypeTest, BigObject) {
-  EXPECT_EQ("257-byte object <00-00 00-00 00-00 00-00 00-00 00-00 "
-            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
-            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
-            "00-00 00-00 00-00 00-00 00-00 00-00 ... 00-00 00-00 00-00 "
-            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
-            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
-            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00>",
-            Print(Big()));
-}
-
-// Tests printing user-defined streamable types.
-
-// Streamable types in the global namespace.
-TEST(PrintStreamableTypeTest, InGlobalNamespace) {
-  StreamableInGlobal x;
-  EXPECT_EQ("StreamableInGlobal", Print(x));
-  EXPECT_EQ("StreamableInGlobal*", Print(&x));
-}
-
-// Printable template types in a user namespace.
-TEST(PrintStreamableTypeTest, TemplateTypeInUserNamespace) {
-  EXPECT_EQ("StreamableTemplateInFoo: 0",
-            Print(::foo::StreamableTemplateInFoo<int>()));
-}
-
-// Tests printing user-defined types that have a PrintTo() function.
-TEST(PrintPrintableTypeTest, InUserNamespace) {
-  EXPECT_EQ("PrintableViaPrintTo: 0",
-            Print(::foo::PrintableViaPrintTo()));
-}
-
-// Tests printing a pointer to a user-defined type that has a <<
-// operator for its pointer.
-TEST(PrintPrintableTypeTest, PointerInUserNamespace) {
-  ::foo::PointerPrintable x;
-  EXPECT_EQ("PointerPrintable*", Print(&x));
-}
-
-// Tests printing user-defined class template that have a PrintTo() function.
-TEST(PrintPrintableTypeTest, TemplateInUserNamespace) {
-  EXPECT_EQ("PrintableViaPrintToTemplate: 5",
-            Print(::foo::PrintableViaPrintToTemplate<int>(5)));
-}
-
-// Tests that the universal printer prints both the address and the
-// value of a reference.
-TEST(PrintReferenceTest, PrintsAddressAndValue) {
-  int n = 5;
-  EXPECT_EQ("@" + PrintPointer(&n) + " 5", PrintByRef(n));
-
-  int a[2][3] = {
-    { 0, 1, 2 },
-    { 3, 4, 5 }
-  };
-  EXPECT_EQ("@" + PrintPointer(a) + " { { 0, 1, 2 }, { 3, 4, 5 } }",
-            PrintByRef(a));
-
-  const ::foo::UnprintableInFoo x;
-  EXPECT_EQ("@" + PrintPointer(&x) + " 16-byte object "
-            "<EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
-            PrintByRef(x));
-}
-
-// Tests that the universal printer prints a function pointer passed by
-// reference.
-TEST(PrintReferenceTest, HandlesFunctionPointer) {
-  void (*fp)(int n) = &MyFunction;
-  const string fp_pointer_string =
-      PrintPointer(reinterpret_cast<const void*>(&fp));
-  // We cannot directly cast &MyFunction to const void* because the
-  // standard disallows casting between pointers to functions and
-  // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
-  // this limitation.
-  const string fp_string = PrintPointer(reinterpret_cast<const void*>(
-      reinterpret_cast<internal::BiggestInt>(fp)));
-  EXPECT_EQ("@" + fp_pointer_string + " " + fp_string,
-            PrintByRef(fp));
-}
-
-// Tests that the universal printer prints a member function pointer
-// passed by reference.
-TEST(PrintReferenceTest, HandlesMemberFunctionPointer) {
-  int (Foo::*p)(char ch) = &Foo::MyMethod;
-  EXPECT_TRUE(HasPrefix(
-      PrintByRef(p),
-      "@" + PrintPointer(reinterpret_cast<const void*>(&p)) + " " +
-          Print(sizeof(p)) + "-byte object "));
-
-  char (Foo::*p2)(int n) = &Foo::MyVirtualMethod;
-  EXPECT_TRUE(HasPrefix(
-      PrintByRef(p2),
-      "@" + PrintPointer(reinterpret_cast<const void*>(&p2)) + " " +
-          Print(sizeof(p2)) + "-byte object "));
-}
-
-// Tests that the universal printer prints a member variable pointer
-// passed by reference.
-TEST(PrintReferenceTest, HandlesMemberVariablePointer) {
-  int (Foo::*p) = &Foo::value;  // NOLINT
-  EXPECT_TRUE(HasPrefix(
-      PrintByRef(p),
-      "@" + PrintPointer(&p) + " " + Print(sizeof(p)) + "-byte object "));
-}
-
-// Tests that FormatForComparisonFailureMessage(), which is used to print
-// an operand in a comparison assertion (e.g. ASSERT_EQ) when the assertion
-// fails, formats the operand in the desired way.
-
-// scalar
-TEST(FormatForComparisonFailureMessageTest, WorksForScalar) {
-  EXPECT_STREQ("123",
-               FormatForComparisonFailureMessage(123, 124).c_str());
-}
-
-// non-char pointer
-TEST(FormatForComparisonFailureMessageTest, WorksForNonCharPointer) {
-  int n = 0;
-  EXPECT_EQ(PrintPointer(&n),
-            FormatForComparisonFailureMessage(&n, &n).c_str());
-}
-
-// non-char array
-TEST(FormatForComparisonFailureMessageTest, FormatsNonCharArrayAsPointer) {
-  // In expression 'array == x', 'array' is compared by pointer.
-  // Therefore we want to print an array operand as a pointer.
-  int n[] = { 1, 2, 3 };
-  EXPECT_EQ(PrintPointer(n),
-            FormatForComparisonFailureMessage(n, n).c_str());
-}
-
-// Tests formatting a char pointer when it's compared with another pointer.
-// In this case we want to print it as a raw pointer, as the comparision is by
-// pointer.
-
-// char pointer vs pointer
-TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsPointer) {
-  // In expression 'p == x', where 'p' and 'x' are (const or not) char
-  // pointers, the operands are compared by pointer.  Therefore we
-  // want to print 'p' as a pointer instead of a C string (we don't
-  // even know if it's supposed to point to a valid C string).
-
-  // const char*
-  const char* s = "hello";
-  EXPECT_EQ(PrintPointer(s),
-            FormatForComparisonFailureMessage(s, s).c_str());
-
-  // char*
-  char ch = 'a';
-  EXPECT_EQ(PrintPointer(&ch),
-            FormatForComparisonFailureMessage(&ch, &ch).c_str());
-}
-
-// wchar_t pointer vs pointer
-TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsPointer) {
-  // In expression 'p == x', where 'p' and 'x' are (const or not) char
-  // pointers, the operands are compared by pointer.  Therefore we
-  // want to print 'p' as a pointer instead of a wide C string (we don't
-  // even know if it's supposed to point to a valid wide C string).
-
-  // const wchar_t*
-  const wchar_t* s = L"hello";
-  EXPECT_EQ(PrintPointer(s),
-            FormatForComparisonFailureMessage(s, s).c_str());
-
-  // wchar_t*
-  wchar_t ch = L'a';
-  EXPECT_EQ(PrintPointer(&ch),
-            FormatForComparisonFailureMessage(&ch, &ch).c_str());
-}
-
-// Tests formatting a char pointer when it's compared to a string object.
-// In this case we want to print the char pointer as a C string.
-
-#if GTEST_HAS_GLOBAL_STRING
-// char pointer vs ::string
-TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsString) {
-  const char* s = "hello \"world";
-  EXPECT_STREQ("\"hello \\\"world\"",  // The string content should be escaped.
-               FormatForComparisonFailureMessage(s, ::string()).c_str());
-
-  // char*
-  char str[] = "hi\1";
-  char* p = str;
-  EXPECT_STREQ("\"hi\\x1\"",  // The string content should be escaped.
-               FormatForComparisonFailureMessage(p, ::string()).c_str());
-}
-#endif
-
-// char pointer vs std::string
-TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsStdString) {
-  const char* s = "hello \"world";
-  EXPECT_STREQ("\"hello \\\"world\"",  // The string content should be escaped.
-               FormatForComparisonFailureMessage(s, ::std::string()).c_str());
-
-  // char*
-  char str[] = "hi\1";
-  char* p = str;
-  EXPECT_STREQ("\"hi\\x1\"",  // The string content should be escaped.
-               FormatForComparisonFailureMessage(p, ::std::string()).c_str());
-}
-
-#if GTEST_HAS_GLOBAL_WSTRING
-// wchar_t pointer vs ::wstring
-TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsWString) {
-  const wchar_t* s = L"hi \"world";
-  EXPECT_STREQ("L\"hi \\\"world\"",  // The string content should be escaped.
-               FormatForComparisonFailureMessage(s, ::wstring()).c_str());
-
-  // wchar_t*
-  wchar_t str[] = L"hi\1";
-  wchar_t* p = str;
-  EXPECT_STREQ("L\"hi\\x1\"",  // The string content should be escaped.
-               FormatForComparisonFailureMessage(p, ::wstring()).c_str());
-}
-#endif
-
-#if GTEST_HAS_STD_WSTRING
-// wchar_t pointer vs std::wstring
-TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsStdWString) {
-  const wchar_t* s = L"hi \"world";
-  EXPECT_STREQ("L\"hi \\\"world\"",  // The string content should be escaped.
-               FormatForComparisonFailureMessage(s, ::std::wstring()).c_str());
-
-  // wchar_t*
-  wchar_t str[] = L"hi\1";
-  wchar_t* p = str;
-  EXPECT_STREQ("L\"hi\\x1\"",  // The string content should be escaped.
-               FormatForComparisonFailureMessage(p, ::std::wstring()).c_str());
-}
-#endif
-
-// Tests formatting a char array when it's compared with a pointer or array.
-// In this case we want to print the array as a row pointer, as the comparison
-// is by pointer.
-
-// char array vs pointer
-TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsPointer) {
-  char str[] = "hi \"world\"";
-  char* p = NULL;
-  EXPECT_EQ(PrintPointer(str),
-            FormatForComparisonFailureMessage(str, p).c_str());
-}
-
-// char array vs char array
-TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsCharArray) {
-  const char str[] = "hi \"world\"";
-  EXPECT_EQ(PrintPointer(str),
-            FormatForComparisonFailureMessage(str, str).c_str());
-}
-
-// wchar_t array vs pointer
-TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsPointer) {
-  wchar_t str[] = L"hi \"world\"";
-  wchar_t* p = NULL;
-  EXPECT_EQ(PrintPointer(str),
-            FormatForComparisonFailureMessage(str, p).c_str());
-}
-
-// wchar_t array vs wchar_t array
-TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsWCharArray) {
-  const wchar_t str[] = L"hi \"world\"";
-  EXPECT_EQ(PrintPointer(str),
-            FormatForComparisonFailureMessage(str, str).c_str());
-}
-
-// Tests formatting a char array when it's compared with a string object.
-// In this case we want to print the array as a C string.
-
-#if GTEST_HAS_GLOBAL_STRING
-// char array vs string
-TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsString) {
-  const char str[] = "hi \"w\0rld\"";
-  EXPECT_STREQ("\"hi \\\"w\"",  // The content should be escaped.
-                                // Embedded NUL terminates the string.
-               FormatForComparisonFailureMessage(str, ::string()).c_str());
-}
-#endif
-
-// char array vs std::string
-TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsStdString) {
-  const char str[] = "hi \"world\"";
-  EXPECT_STREQ("\"hi \\\"world\\\"\"",  // The content should be escaped.
-               FormatForComparisonFailureMessage(str, ::std::string()).c_str());
-}
-
-#if GTEST_HAS_GLOBAL_WSTRING
-// wchar_t array vs wstring
-TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsWString) {
-  const wchar_t str[] = L"hi \"world\"";
-  EXPECT_STREQ("L\"hi \\\"world\\\"\"",  // The content should be escaped.
-               FormatForComparisonFailureMessage(str, ::wstring()).c_str());
-}
-#endif
-
-#if GTEST_HAS_STD_WSTRING
-// wchar_t array vs std::wstring
-TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsStdWString) {
-  const wchar_t str[] = L"hi \"w\0rld\"";
-  EXPECT_STREQ(
-      "L\"hi \\\"w\"",  // The content should be escaped.
-                        // Embedded NUL terminates the string.
-      FormatForComparisonFailureMessage(str, ::std::wstring()).c_str());
-}
-#endif
-
-// Useful for testing PrintToString().  We cannot use EXPECT_EQ()
-// there as its implementation uses PrintToString().  The caller must
-// ensure that 'value' has no side effect.
-#define EXPECT_PRINT_TO_STRING_(value, expected_string)         \
-  EXPECT_TRUE(PrintToString(value) == (expected_string))        \
-      << " where " #value " prints as " << (PrintToString(value))
-
-TEST(PrintToStringTest, WorksForScalar) {
-  EXPECT_PRINT_TO_STRING_(123, "123");
-}
-
-TEST(PrintToStringTest, WorksForPointerToConstChar) {
-  const char* p = "hello";
-  EXPECT_PRINT_TO_STRING_(p, "\"hello\"");
-}
-
-TEST(PrintToStringTest, WorksForPointerToNonConstChar) {
-  char s[] = "hello";
-  char* p = s;
-  EXPECT_PRINT_TO_STRING_(p, "\"hello\"");
-}
-
-TEST(PrintToStringTest, EscapesForPointerToConstChar) {
-  const char* p = "hello\n";
-  EXPECT_PRINT_TO_STRING_(p, "\"hello\\n\"");
-}
-
-TEST(PrintToStringTest, EscapesForPointerToNonConstChar) {
-  char s[] = "hello\1";
-  char* p = s;
-  EXPECT_PRINT_TO_STRING_(p, "\"hello\\x1\"");
-}
-
-TEST(PrintToStringTest, WorksForArray) {
-  int n[3] = { 1, 2, 3 };
-  EXPECT_PRINT_TO_STRING_(n, "{ 1, 2, 3 }");
-}
-
-TEST(PrintToStringTest, WorksForCharArray) {
-  char s[] = "hello";
-  EXPECT_PRINT_TO_STRING_(s, "\"hello\"");
-}
-
-TEST(PrintToStringTest, WorksForCharArrayWithEmbeddedNul) {
-  const char str_with_nul[] = "hello\0 world";
-  EXPECT_PRINT_TO_STRING_(str_with_nul, "\"hello\\0 world\"");
-
-  char mutable_str_with_nul[] = "hello\0 world";
-  EXPECT_PRINT_TO_STRING_(mutable_str_with_nul, "\"hello\\0 world\"");
-}
-
-#undef EXPECT_PRINT_TO_STRING_
-
-TEST(UniversalTersePrintTest, WorksForNonReference) {
-  ::std::stringstream ss;
-  UniversalTersePrint(123, &ss);
-  EXPECT_EQ("123", ss.str());
-}
-
-TEST(UniversalTersePrintTest, WorksForReference) {
-  const int& n = 123;
-  ::std::stringstream ss;
-  UniversalTersePrint(n, &ss);
-  EXPECT_EQ("123", ss.str());
-}
-
-TEST(UniversalTersePrintTest, WorksForCString) {
-  const char* s1 = "abc";
-  ::std::stringstream ss1;
-  UniversalTersePrint(s1, &ss1);
-  EXPECT_EQ("\"abc\"", ss1.str());
-
-  char* s2 = const_cast<char*>(s1);
-  ::std::stringstream ss2;
-  UniversalTersePrint(s2, &ss2);
-  EXPECT_EQ("\"abc\"", ss2.str());
-
-  const char* s3 = NULL;
-  ::std::stringstream ss3;
-  UniversalTersePrint(s3, &ss3);
-  EXPECT_EQ("NULL", ss3.str());
-}
-
-TEST(UniversalPrintTest, WorksForNonReference) {
-  ::std::stringstream ss;
-  UniversalPrint(123, &ss);
-  EXPECT_EQ("123", ss.str());
-}
-
-TEST(UniversalPrintTest, WorksForReference) {
-  const int& n = 123;
-  ::std::stringstream ss;
-  UniversalPrint(n, &ss);
-  EXPECT_EQ("123", ss.str());
-}
-
-TEST(UniversalPrintTest, WorksForCString) {
-  const char* s1 = "abc";
-  ::std::stringstream ss1;
-  UniversalPrint(s1, &ss1);
-  EXPECT_EQ(PrintPointer(s1) + " pointing to \"abc\"", string(ss1.str()));
-
-  char* s2 = const_cast<char*>(s1);
-  ::std::stringstream ss2;
-  UniversalPrint(s2, &ss2);
-  EXPECT_EQ(PrintPointer(s2) + " pointing to \"abc\"", string(ss2.str()));
-
-  const char* s3 = NULL;
-  ::std::stringstream ss3;
-  UniversalPrint(s3, &ss3);
-  EXPECT_EQ("NULL", ss3.str());
-}
-
-TEST(UniversalPrintTest, WorksForCharArray) {
-  const char str[] = "\"Line\0 1\"\nLine 2";
-  ::std::stringstream ss1;
-  UniversalPrint(str, &ss1);
-  EXPECT_EQ("\"\\\"Line\\0 1\\\"\\nLine 2\"", ss1.str());
-
-  const char mutable_str[] = "\"Line\0 1\"\nLine 2";
-  ::std::stringstream ss2;
-  UniversalPrint(mutable_str, &ss2);
-  EXPECT_EQ("\"\\\"Line\\0 1\\\"\\nLine 2\"", ss2.str());
-}
-
-#if GTEST_HAS_TR1_TUPLE
-
-TEST(UniversalTersePrintTupleFieldsToStringsTestWithTr1, PrintsEmptyTuple) {
-  Strings result = UniversalTersePrintTupleFieldsToStrings(
-      ::std::tr1::make_tuple());
-  EXPECT_EQ(0u, result.size());
-}
-
-TEST(UniversalTersePrintTupleFieldsToStringsTestWithTr1, PrintsOneTuple) {
-  Strings result = UniversalTersePrintTupleFieldsToStrings(
-      ::std::tr1::make_tuple(1));
-  ASSERT_EQ(1u, result.size());
-  EXPECT_EQ("1", result[0]);
-}
-
-TEST(UniversalTersePrintTupleFieldsToStringsTestWithTr1, PrintsTwoTuple) {
-  Strings result = UniversalTersePrintTupleFieldsToStrings(
-      ::std::tr1::make_tuple(1, 'a'));
-  ASSERT_EQ(2u, result.size());
-  EXPECT_EQ("1", result[0]);
-  EXPECT_EQ("'a' (97, 0x61)", result[1]);
-}
-
-TEST(UniversalTersePrintTupleFieldsToStringsTestWithTr1, PrintsTersely) {
-  const int n = 1;
-  Strings result = UniversalTersePrintTupleFieldsToStrings(
-      ::std::tr1::tuple<const int&, const char*>(n, "a"));
-  ASSERT_EQ(2u, result.size());
-  EXPECT_EQ("1", result[0]);
-  EXPECT_EQ("\"a\"", result[1]);
-}
-
-#endif  // GTEST_HAS_TR1_TUPLE
-
-#if GTEST_HAS_STD_TUPLE_
-
-TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsEmptyTuple) {
-  Strings result = UniversalTersePrintTupleFieldsToStrings(::std::make_tuple());
-  EXPECT_EQ(0u, result.size());
-}
-
-TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsOneTuple) {
-  Strings result = UniversalTersePrintTupleFieldsToStrings(
-      ::std::make_tuple(1));
-  ASSERT_EQ(1u, result.size());
-  EXPECT_EQ("1", result[0]);
-}
-
-TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTwoTuple) {
-  Strings result = UniversalTersePrintTupleFieldsToStrings(
-      ::std::make_tuple(1, 'a'));
-  ASSERT_EQ(2u, result.size());
-  EXPECT_EQ("1", result[0]);
-  EXPECT_EQ("'a' (97, 0x61)", result[1]);
-}
-
-TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTersely) {
-  const int n = 1;
-  Strings result = UniversalTersePrintTupleFieldsToStrings(
-      ::std::tuple<const int&, const char*>(n, "a"));
-  ASSERT_EQ(2u, result.size());
-  EXPECT_EQ("1", result[0]);
-  EXPECT_EQ("\"a\"", result[1]);
-}
-
-#endif  // GTEST_HAS_STD_TUPLE_
-
-}  // namespace gtest_printers_test
-}  // namespace testing
-
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-test-part_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-test-part_test.cc
deleted file mode 100644
index ca8ba933..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-test-part_test.cc
+++ /dev/null
@@ -1,208 +0,0 @@
-// 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.
-//
-// Author: mheule@google.com (Markus Heule)
-//
-
-#include "gtest/gtest-test-part.h"
-
-#include "gtest/gtest.h"
-
-using testing::Message;
-using testing::Test;
-using testing::TestPartResult;
-using testing::TestPartResultArray;
-
-namespace {
-
-// Tests the TestPartResult class.
-
-// The test fixture for testing TestPartResult.
-class TestPartResultTest : public Test {
- protected:
-  TestPartResultTest()
-      : r1_(TestPartResult::kSuccess, "foo/bar.cc", 10, "Success!"),
-        r2_(TestPartResult::kNonFatalFailure, "foo/bar.cc", -1, "Failure!"),
-        r3_(TestPartResult::kFatalFailure, NULL, -1, "Failure!") {}
-
-  TestPartResult r1_, r2_, r3_;
-};
-
-
-TEST_F(TestPartResultTest, ConstructorWorks) {
-  Message message;
-  message << "something is terribly wrong";
-  message << static_cast<const char*>(testing::internal::kStackTraceMarker);
-  message << "some unimportant stack trace";
-
-  const TestPartResult result(TestPartResult::kNonFatalFailure,
-                              "some_file.cc",
-                              42,
-                              message.GetString().c_str());
-
-  EXPECT_EQ(TestPartResult::kNonFatalFailure, result.type());
-  EXPECT_STREQ("some_file.cc", result.file_name());
-  EXPECT_EQ(42, result.line_number());
-  EXPECT_STREQ(message.GetString().c_str(), result.message());
-  EXPECT_STREQ("something is terribly wrong", result.summary());
-}
-
-TEST_F(TestPartResultTest, ResultAccessorsWork) {
-  const TestPartResult success(TestPartResult::kSuccess,
-                               "file.cc",
-                               42,
-                               "message");
-  EXPECT_TRUE(success.passed());
-  EXPECT_FALSE(success.failed());
-  EXPECT_FALSE(success.nonfatally_failed());
-  EXPECT_FALSE(success.fatally_failed());
-
-  const TestPartResult nonfatal_failure(TestPartResult::kNonFatalFailure,
-                                        "file.cc",
-                                        42,
-                                        "message");
-  EXPECT_FALSE(nonfatal_failure.passed());
-  EXPECT_TRUE(nonfatal_failure.failed());
-  EXPECT_TRUE(nonfatal_failure.nonfatally_failed());
-  EXPECT_FALSE(nonfatal_failure.fatally_failed());
-
-  const TestPartResult fatal_failure(TestPartResult::kFatalFailure,
-                                     "file.cc",
-                                     42,
-                                     "message");
-  EXPECT_FALSE(fatal_failure.passed());
-  EXPECT_TRUE(fatal_failure.failed());
-  EXPECT_FALSE(fatal_failure.nonfatally_failed());
-  EXPECT_TRUE(fatal_failure.fatally_failed());
-}
-
-// Tests TestPartResult::type().
-TEST_F(TestPartResultTest, type) {
-  EXPECT_EQ(TestPartResult::kSuccess, r1_.type());
-  EXPECT_EQ(TestPartResult::kNonFatalFailure, r2_.type());
-  EXPECT_EQ(TestPartResult::kFatalFailure, r3_.type());
-}
-
-// Tests TestPartResult::file_name().
-TEST_F(TestPartResultTest, file_name) {
-  EXPECT_STREQ("foo/bar.cc", r1_.file_name());
-  EXPECT_STREQ(NULL, r3_.file_name());
-}
-
-// Tests TestPartResult::line_number().
-TEST_F(TestPartResultTest, line_number) {
-  EXPECT_EQ(10, r1_.line_number());
-  EXPECT_EQ(-1, r2_.line_number());
-}
-
-// Tests TestPartResult::message().
-TEST_F(TestPartResultTest, message) {
-  EXPECT_STREQ("Success!", r1_.message());
-}
-
-// Tests TestPartResult::passed().
-TEST_F(TestPartResultTest, Passed) {
-  EXPECT_TRUE(r1_.passed());
-  EXPECT_FALSE(r2_.passed());
-  EXPECT_FALSE(r3_.passed());
-}
-
-// Tests TestPartResult::failed().
-TEST_F(TestPartResultTest, Failed) {
-  EXPECT_FALSE(r1_.failed());
-  EXPECT_TRUE(r2_.failed());
-  EXPECT_TRUE(r3_.failed());
-}
-
-// Tests TestPartResult::fatally_failed().
-TEST_F(TestPartResultTest, FatallyFailed) {
-  EXPECT_FALSE(r1_.fatally_failed());
-  EXPECT_FALSE(r2_.fatally_failed());
-  EXPECT_TRUE(r3_.fatally_failed());
-}
-
-// Tests TestPartResult::nonfatally_failed().
-TEST_F(TestPartResultTest, NonfatallyFailed) {
-  EXPECT_FALSE(r1_.nonfatally_failed());
-  EXPECT_TRUE(r2_.nonfatally_failed());
-  EXPECT_FALSE(r3_.nonfatally_failed());
-}
-
-// Tests the TestPartResultArray class.
-
-class TestPartResultArrayTest : public Test {
- protected:
-  TestPartResultArrayTest()
-      : r1_(TestPartResult::kNonFatalFailure, "foo/bar.cc", -1, "Failure 1"),
-        r2_(TestPartResult::kFatalFailure, "foo/bar.cc", -1, "Failure 2") {}
-
-  const TestPartResult r1_, r2_;
-};
-
-// Tests that TestPartResultArray initially has size 0.
-TEST_F(TestPartResultArrayTest, InitialSizeIsZero) {
-  TestPartResultArray results;
-  EXPECT_EQ(0, results.size());
-}
-
-// Tests that TestPartResultArray contains the given TestPartResult
-// after one Append() operation.
-TEST_F(TestPartResultArrayTest, ContainsGivenResultAfterAppend) {
-  TestPartResultArray results;
-  results.Append(r1_);
-  EXPECT_EQ(1, results.size());
-  EXPECT_STREQ("Failure 1", results.GetTestPartResult(0).message());
-}
-
-// Tests that TestPartResultArray contains the given TestPartResults
-// after two Append() operations.
-TEST_F(TestPartResultArrayTest, ContainsGivenResultsAfterTwoAppends) {
-  TestPartResultArray results;
-  results.Append(r1_);
-  results.Append(r2_);
-  EXPECT_EQ(2, results.size());
-  EXPECT_STREQ("Failure 1", results.GetTestPartResult(0).message());
-  EXPECT_STREQ("Failure 2", results.GetTestPartResult(1).message());
-}
-
-typedef TestPartResultArrayTest TestPartResultArrayDeathTest;
-
-// Tests that the program dies when GetTestPartResult() is called with
-// an invalid index.
-TEST_F(TestPartResultArrayDeathTest, DiesWhenIndexIsOutOfBound) {
-  TestPartResultArray results;
-  results.Append(r1_);
-
-  EXPECT_DEATH_IF_SUPPORTED(results.GetTestPartResult(-1), "");
-  EXPECT_DEATH_IF_SUPPORTED(results.GetTestPartResult(1), "");
-}
-
-// TODO(mheule@google.com): Add a test for the class HasNewFatalFailureHelper.
-
-}  // namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-tuple_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-tuple_test.cc
deleted file mode 100644
index bfaa3e0a..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-tuple_test.cc
+++ /dev/null
@@ -1,320 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "gtest/internal/gtest-tuple.h"
-#include <utility>
-#include "gtest/gtest.h"
-
-namespace {
-
-using ::std::tr1::get;
-using ::std::tr1::make_tuple;
-using ::std::tr1::tuple;
-using ::std::tr1::tuple_element;
-using ::std::tr1::tuple_size;
-using ::testing::StaticAssertTypeEq;
-
-// Tests that tuple_element<K, tuple<T0, T1, ..., TN> >::type returns TK.
-TEST(tuple_element_Test, ReturnsElementType) {
-  StaticAssertTypeEq<int, tuple_element<0, tuple<int, char> >::type>();
-  StaticAssertTypeEq<int&, tuple_element<1, tuple<double, int&> >::type>();
-  StaticAssertTypeEq<bool, tuple_element<2, tuple<double, int, bool> >::type>();
-}
-
-// Tests that tuple_size<T>::value gives the number of fields in tuple
-// type T.
-TEST(tuple_size_Test, ReturnsNumberOfFields) {
-  EXPECT_EQ(0, +tuple_size<tuple<> >::value);
-  EXPECT_EQ(1, +tuple_size<tuple<void*> >::value);
-  EXPECT_EQ(1, +tuple_size<tuple<char> >::value);
-  EXPECT_EQ(1, +(tuple_size<tuple<tuple<int, double> > >::value));
-  EXPECT_EQ(2, +(tuple_size<tuple<int&, const char> >::value));
-  EXPECT_EQ(3, +(tuple_size<tuple<char*, void, const bool&> >::value));
-}
-
-// Tests comparing a tuple with itself.
-TEST(ComparisonTest, ComparesWithSelf) {
-  const tuple<int, char, bool> a(5, 'a', false);
-
-  EXPECT_TRUE(a == a);
-  EXPECT_FALSE(a != a);
-}
-
-// Tests comparing two tuples with the same value.
-TEST(ComparisonTest, ComparesEqualTuples) {
-  const tuple<int, bool> a(5, true), b(5, true);
-
-  EXPECT_TRUE(a == b);
-  EXPECT_FALSE(a != b);
-}
-
-// Tests comparing two different tuples that have no reference fields.
-TEST(ComparisonTest, ComparesUnequalTuplesWithoutReferenceFields) {
-  typedef tuple<const int, char> FooTuple;
-
-  const FooTuple a(0, 'x');
-  const FooTuple b(1, 'a');
-
-  EXPECT_TRUE(a != b);
-  EXPECT_FALSE(a == b);
-
-  const FooTuple c(1, 'b');
-
-  EXPECT_TRUE(b != c);
-  EXPECT_FALSE(b == c);
-}
-
-// Tests comparing two different tuples that have reference fields.
-TEST(ComparisonTest, ComparesUnequalTuplesWithReferenceFields) {
-  typedef tuple<int&, const char&> FooTuple;
-
-  int i = 5;
-  const char ch = 'a';
-  const FooTuple a(i, ch);
-
-  int j = 6;
-  const FooTuple b(j, ch);
-
-  EXPECT_TRUE(a != b);
-  EXPECT_FALSE(a == b);
-
-  j = 5;
-  const char ch2 = 'b';
-  const FooTuple c(j, ch2);
-
-  EXPECT_TRUE(b != c);
-  EXPECT_FALSE(b == c);
-}
-
-// Tests that a tuple field with a reference type is an alias of the
-// variable it's supposed to reference.
-TEST(ReferenceFieldTest, IsAliasOfReferencedVariable) {
-  int n = 0;
-  tuple<bool, int&> t(true, n);
-
-  n = 1;
-  EXPECT_EQ(n, get<1>(t))
-      << "Changing a underlying variable should update the reference field.";
-
-  // Makes sure that the implementation doesn't do anything funny with
-  // the & operator for the return type of get<>().
-  EXPECT_EQ(&n, &(get<1>(t)))
-      << "The address of a reference field should equal the address of "
-      << "the underlying variable.";
-
-  get<1>(t) = 2;
-  EXPECT_EQ(2, n)
-      << "Changing a reference field should update the underlying variable.";
-}
-
-// Tests that tuple's default constructor default initializes each field.
-// This test needs to compile without generating warnings.
-TEST(TupleConstructorTest, DefaultConstructorDefaultInitializesEachField) {
-  // The TR1 report requires that tuple's default constructor default
-  // initializes each field, even if it's a primitive type.  If the
-  // implementation forgets to do this, this test will catch it by
-  // generating warnings about using uninitialized variables (assuming
-  // a decent compiler).
-
-  tuple<> empty;
-
-  tuple<int> a1, b1;
-  b1 = a1;
-  EXPECT_EQ(0, get<0>(b1));
-
-  tuple<int, double> a2, b2;
-  b2 = a2;
-  EXPECT_EQ(0, get<0>(b2));
-  EXPECT_EQ(0.0, get<1>(b2));
-
-  tuple<double, char, bool*> a3, b3;
-  b3 = a3;
-  EXPECT_EQ(0.0, get<0>(b3));
-  EXPECT_EQ('\0', get<1>(b3));
-  EXPECT_TRUE(get<2>(b3) == NULL);
-
-  tuple<int, int, int, int, int, int, int, int, int, int> a10, b10;
-  b10 = a10;
-  EXPECT_EQ(0, get<0>(b10));
-  EXPECT_EQ(0, get<1>(b10));
-  EXPECT_EQ(0, get<2>(b10));
-  EXPECT_EQ(0, get<3>(b10));
-  EXPECT_EQ(0, get<4>(b10));
-  EXPECT_EQ(0, get<5>(b10));
-  EXPECT_EQ(0, get<6>(b10));
-  EXPECT_EQ(0, get<7>(b10));
-  EXPECT_EQ(0, get<8>(b10));
-  EXPECT_EQ(0, get<9>(b10));
-}
-
-// Tests constructing a tuple from its fields.
-TEST(TupleConstructorTest, ConstructsFromFields) {
-  int n = 1;
-  // Reference field.
-  tuple<int&> a(n);
-  EXPECT_EQ(&n, &(get<0>(a)));
-
-  // Non-reference fields.
-  tuple<int, char> b(5, 'a');
-  EXPECT_EQ(5, get<0>(b));
-  EXPECT_EQ('a', get<1>(b));
-
-  // Const reference field.
-  const int m = 2;
-  tuple<bool, const int&> c(true, m);
-  EXPECT_TRUE(get<0>(c));
-  EXPECT_EQ(&m, &(get<1>(c)));
-}
-
-// Tests tuple's copy constructor.
-TEST(TupleConstructorTest, CopyConstructor) {
-  tuple<double, bool> a(0.0, true);
-  tuple<double, bool> b(a);
-
-  EXPECT_DOUBLE_EQ(0.0, get<0>(b));
-  EXPECT_TRUE(get<1>(b));
-}
-
-// Tests constructing a tuple from another tuple that has a compatible
-// but different type.
-TEST(TupleConstructorTest, ConstructsFromDifferentTupleType) {
-  tuple<int, int, char> a(0, 1, 'a');
-  tuple<double, long, int> b(a);
-
-  EXPECT_DOUBLE_EQ(0.0, get<0>(b));
-  EXPECT_EQ(1, get<1>(b));
-  EXPECT_EQ('a', get<2>(b));
-}
-
-// Tests constructing a 2-tuple from an std::pair.
-TEST(TupleConstructorTest, ConstructsFromPair) {
-  ::std::pair<int, char> a(1, 'a');
-  tuple<int, char> b(a);
-  tuple<int, const char&> c(a);
-}
-
-// Tests assigning a tuple to another tuple with the same type.
-TEST(TupleAssignmentTest, AssignsToSameTupleType) {
-  const tuple<int, long> a(5, 7L);
-  tuple<int, long> b;
-  b = a;
-  EXPECT_EQ(5, get<0>(b));
-  EXPECT_EQ(7L, get<1>(b));
-}
-
-// Tests assigning a tuple to another tuple with a different but
-// compatible type.
-TEST(TupleAssignmentTest, AssignsToDifferentTupleType) {
-  const tuple<int, long, bool> a(1, 7L, true);
-  tuple<long, int, bool> b;
-  b = a;
-  EXPECT_EQ(1L, get<0>(b));
-  EXPECT_EQ(7, get<1>(b));
-  EXPECT_TRUE(get<2>(b));
-}
-
-// Tests assigning an std::pair to a 2-tuple.
-TEST(TupleAssignmentTest, AssignsFromPair) {
-  const ::std::pair<int, bool> a(5, true);
-  tuple<int, bool> b;
-  b = a;
-  EXPECT_EQ(5, get<0>(b));
-  EXPECT_TRUE(get<1>(b));
-
-  tuple<long, bool> c;
-  c = a;
-  EXPECT_EQ(5L, get<0>(c));
-  EXPECT_TRUE(get<1>(c));
-}
-
-// A fixture for testing big tuples.
-class BigTupleTest : public testing::Test {
- protected:
-  typedef tuple<int, int, int, int, int, int, int, int, int, int> BigTuple;
-
-  BigTupleTest() :
-      a_(1, 0, 0, 0, 0, 0, 0, 0, 0, 2),
-      b_(1, 0, 0, 0, 0, 0, 0, 0, 0, 3) {}
-
-  BigTuple a_, b_;
-};
-
-// Tests constructing big tuples.
-TEST_F(BigTupleTest, Construction) {
-  BigTuple a;
-  BigTuple b(b_);
-}
-
-// Tests that get<N>(t) returns the N-th (0-based) field of tuple t.
-TEST_F(BigTupleTest, get) {
-  EXPECT_EQ(1, get<0>(a_));
-  EXPECT_EQ(2, get<9>(a_));
-
-  // Tests that get() works on a const tuple too.
-  const BigTuple a(a_);
-  EXPECT_EQ(1, get<0>(a));
-  EXPECT_EQ(2, get<9>(a));
-}
-
-// Tests comparing big tuples.
-TEST_F(BigTupleTest, Comparisons) {
-  EXPECT_TRUE(a_ == a_);
-  EXPECT_FALSE(a_ != a_);
-
-  EXPECT_TRUE(a_ != b_);
-  EXPECT_FALSE(a_ == b_);
-}
-
-TEST(MakeTupleTest, WorksForScalarTypes) {
-  tuple<bool, int> a;
-  a = make_tuple(true, 5);
-  EXPECT_TRUE(get<0>(a));
-  EXPECT_EQ(5, get<1>(a));
-
-  tuple<char, int, long> b;
-  b = make_tuple('a', 'b', 5);
-  EXPECT_EQ('a', get<0>(b));
-  EXPECT_EQ('b', get<1>(b));
-  EXPECT_EQ(5, get<2>(b));
-}
-
-TEST(MakeTupleTest, WorksForPointers) {
-  int a[] = { 1, 2, 3, 4 };
-  const char* const str = "hi";
-  int* const p = a;
-
-  tuple<const char*, int*> t;
-  t = make_tuple(str, p);
-  EXPECT_EQ(str, get<0>(t));
-  EXPECT_EQ(p, get<1>(t));
-}
-
-}  // namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test2_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test2_test.cc
deleted file mode 100644
index c284700b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test2_test.cc
+++ /dev/null
@@ -1,45 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include <vector>
-
-#include "test/gtest-typed-test_test.h"
-#include "gtest/gtest.h"
-
-#if GTEST_HAS_TYPED_TEST_P
-
-// Tests that the same type-parameterized test case can be
-// instantiated in different translation units linked together.
-// (ContainerTest is also instantiated in gtest-typed-test_test.cc.)
-INSTANTIATE_TYPED_TEST_CASE_P(Vector, ContainerTest,
-                              testing::Types<std::vector<int> >);
-
-#endif  // GTEST_HAS_TYPED_TEST_P
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.cc
deleted file mode 100644
index 93628ba0..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.cc
+++ /dev/null
@@ -1,380 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "test/gtest-typed-test_test.h"
-
-#include <set>
-#include <vector>
-
-#include "gtest/gtest.h"
-
-using testing::Test;
-
-// Used for testing that SetUpTestCase()/TearDownTestCase(), fixture
-// ctor/dtor, and SetUp()/TearDown() work correctly in typed tests and
-// type-parameterized test.
-template <typename T>
-class CommonTest : public Test {
-  // For some technical reason, SetUpTestCase() and TearDownTestCase()
-  // must be public.
- public:
-  static void SetUpTestCase() {
-    shared_ = new T(5);
-  }
-
-  static void TearDownTestCase() {
-    delete shared_;
-    shared_ = NULL;
-  }
-
-  // This 'protected:' is optional.  There's no harm in making all
-  // members of this fixture class template public.
- protected:
-  // We used to use std::list here, but switched to std::vector since
-  // MSVC's <list> doesn't compile cleanly with /W4.
-  typedef std::vector<T> Vector;
-  typedef std::set<int> IntSet;
-
-  CommonTest() : value_(1) {}
-
-  virtual ~CommonTest() { EXPECT_EQ(3, value_); }
-
-  virtual void SetUp() {
-    EXPECT_EQ(1, value_);
-    value_++;
-  }
-
-  virtual void TearDown() {
-    EXPECT_EQ(2, value_);
-    value_++;
-  }
-
-  T value_;
-  static T* shared_;
-};
-
-template <typename T>
-T* CommonTest<T>::shared_ = NULL;
-
-// This #ifdef block tests typed tests.
-#if GTEST_HAS_TYPED_TEST
-
-using testing::Types;
-
-// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor,
-// and SetUp()/TearDown() work correctly in typed tests
-
-typedef Types<char, int> TwoTypes;
-TYPED_TEST_CASE(CommonTest, TwoTypes);
-
-TYPED_TEST(CommonTest, ValuesAreCorrect) {
-  // Static members of the fixture class template can be visited via
-  // the TestFixture:: prefix.
-  EXPECT_EQ(5, *TestFixture::shared_);
-
-  // Typedefs in the fixture class template can be visited via the
-  // "typename TestFixture::" prefix.
-  typename TestFixture::Vector empty;
-  EXPECT_EQ(0U, empty.size());
-
-  typename TestFixture::IntSet empty2;
-  EXPECT_EQ(0U, empty2.size());
-
-  // Non-static members of the fixture class must be visited via
-  // 'this', as required by C++ for class templates.
-  EXPECT_EQ(2, this->value_);
-}
-
-// The second test makes sure shared_ is not deleted after the first
-// test.
-TYPED_TEST(CommonTest, ValuesAreStillCorrect) {
-  // Static members of the fixture class template can also be visited
-  // via 'this'.
-  ASSERT_TRUE(this->shared_ != NULL);
-  EXPECT_EQ(5, *this->shared_);
-
-  // TypeParam can be used to refer to the type parameter.
-  EXPECT_EQ(static_cast<TypeParam>(2), this->value_);
-}
-
-// Tests that multiple TYPED_TEST_CASE's can be defined in the same
-// translation unit.
-
-template <typename T>
-class TypedTest1 : public Test {
-};
-
-// Verifies that the second argument of TYPED_TEST_CASE can be a
-// single type.
-TYPED_TEST_CASE(TypedTest1, int);
-TYPED_TEST(TypedTest1, A) {}
-
-template <typename T>
-class TypedTest2 : public Test {
-};
-
-// Verifies that the second argument of TYPED_TEST_CASE can be a
-// Types<...> type list.
-TYPED_TEST_CASE(TypedTest2, Types<int>);
-
-// This also verifies that tests from different typed test cases can
-// share the same name.
-TYPED_TEST(TypedTest2, A) {}
-
-// Tests that a typed test case can be defined in a namespace.
-
-namespace library1 {
-
-template <typename T>
-class NumericTest : public Test {
-};
-
-typedef Types<int, long> NumericTypes;
-TYPED_TEST_CASE(NumericTest, NumericTypes);
-
-TYPED_TEST(NumericTest, DefaultIsZero) {
-  EXPECT_EQ(0, TypeParam());
-}
-
-}  // namespace library1
-
-#endif  // GTEST_HAS_TYPED_TEST
-
-// This #ifdef block tests type-parameterized tests.
-#if GTEST_HAS_TYPED_TEST_P
-
-using testing::Types;
-using testing::internal::TypedTestCasePState;
-
-// Tests TypedTestCasePState.
-
-class TypedTestCasePStateTest : public Test {
- protected:
-  virtual void SetUp() {
-    state_.AddTestName("foo.cc", 0, "FooTest", "A");
-    state_.AddTestName("foo.cc", 0, "FooTest", "B");
-    state_.AddTestName("foo.cc", 0, "FooTest", "C");
-  }
-
-  TypedTestCasePState state_;
-};
-
-TEST_F(TypedTestCasePStateTest, SucceedsForMatchingList) {
-  const char* tests = "A, B, C";
-  EXPECT_EQ(tests,
-            state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
-}
-
-// Makes sure that the order of the tests and spaces around the names
-// don't matter.
-TEST_F(TypedTestCasePStateTest, IgnoresOrderAndSpaces) {
-  const char* tests = "A,C,   B";
-  EXPECT_EQ(tests,
-            state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
-}
-
-typedef TypedTestCasePStateTest TypedTestCasePStateDeathTest;
-
-TEST_F(TypedTestCasePStateDeathTest, DetectsDuplicates) {
-  EXPECT_DEATH_IF_SUPPORTED(
-      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, A, C"),
-      "foo\\.cc.1.?: Test A is listed more than once\\.");
-}
-
-TEST_F(TypedTestCasePStateDeathTest, DetectsExtraTest) {
-  EXPECT_DEATH_IF_SUPPORTED(
-      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C, D"),
-      "foo\\.cc.1.?: No test named D can be found in this test case\\.");
-}
-
-TEST_F(TypedTestCasePStateDeathTest, DetectsMissedTest) {
-  EXPECT_DEATH_IF_SUPPORTED(
-      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, C"),
-      "foo\\.cc.1.?: You forgot to list test B\\.");
-}
-
-// Tests that defining a test for a parameterized test case generates
-// a run-time error if the test case has been registered.
-TEST_F(TypedTestCasePStateDeathTest, DetectsTestAfterRegistration) {
-  state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C");
-  EXPECT_DEATH_IF_SUPPORTED(
-      state_.AddTestName("foo.cc", 2, "FooTest", "D"),
-      "foo\\.cc.2.?: Test D must be defined before REGISTER_TYPED_TEST_CASE_P"
-      "\\(FooTest, \\.\\.\\.\\)\\.");
-}
-
-// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor,
-// and SetUp()/TearDown() work correctly in type-parameterized tests.
-
-template <typename T>
-class DerivedTest : public CommonTest<T> {
-};
-
-TYPED_TEST_CASE_P(DerivedTest);
-
-TYPED_TEST_P(DerivedTest, ValuesAreCorrect) {
-  // Static members of the fixture class template can be visited via
-  // the TestFixture:: prefix.
-  EXPECT_EQ(5, *TestFixture::shared_);
-
-  // Non-static members of the fixture class must be visited via
-  // 'this', as required by C++ for class templates.
-  EXPECT_EQ(2, this->value_);
-}
-
-// The second test makes sure shared_ is not deleted after the first
-// test.
-TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) {
-  // Static members of the fixture class template can also be visited
-  // via 'this'.
-  ASSERT_TRUE(this->shared_ != NULL);
-  EXPECT_EQ(5, *this->shared_);
-  EXPECT_EQ(2, this->value_);
-}
-
-REGISTER_TYPED_TEST_CASE_P(DerivedTest,
-                           ValuesAreCorrect, ValuesAreStillCorrect);
-
-typedef Types<short, long> MyTwoTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(My, DerivedTest, MyTwoTypes);
-
-// Tests that multiple TYPED_TEST_CASE_P's can be defined in the same
-// translation unit.
-
-template <typename T>
-class TypedTestP1 : public Test {
-};
-
-TYPED_TEST_CASE_P(TypedTestP1);
-
-// For testing that the code between TYPED_TEST_CASE_P() and
-// TYPED_TEST_P() is not enclosed in a namespace.
-typedef int IntAfterTypedTestCaseP;
-
-TYPED_TEST_P(TypedTestP1, A) {}
-TYPED_TEST_P(TypedTestP1, B) {}
-
-// For testing that the code between TYPED_TEST_P() and
-// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace.
-typedef int IntBeforeRegisterTypedTestCaseP;
-
-REGISTER_TYPED_TEST_CASE_P(TypedTestP1, A, B);
-
-template <typename T>
-class TypedTestP2 : public Test {
-};
-
-TYPED_TEST_CASE_P(TypedTestP2);
-
-// This also verifies that tests from different type-parameterized
-// test cases can share the same name.
-TYPED_TEST_P(TypedTestP2, A) {}
-
-REGISTER_TYPED_TEST_CASE_P(TypedTestP2, A);
-
-// Verifies that the code between TYPED_TEST_CASE_P() and
-// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace.
-IntAfterTypedTestCaseP after = 0;
-IntBeforeRegisterTypedTestCaseP before = 0;
-
-// Verifies that the last argument of INSTANTIATE_TYPED_TEST_CASE_P()
-// can be either a single type or a Types<...> type list.
-INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP1, int);
-INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP2, Types<int>);
-
-// Tests that the same type-parameterized test case can be
-// instantiated more than once in the same translation unit.
-INSTANTIATE_TYPED_TEST_CASE_P(Double, TypedTestP2, Types<double>);
-
-// Tests that the same type-parameterized test case can be
-// instantiated in different translation units linked together.
-// (ContainerTest is also instantiated in gtest-typed-test_test.cc.)
-typedef Types<std::vector<double>, std::set<char> > MyContainers;
-INSTANTIATE_TYPED_TEST_CASE_P(My, ContainerTest, MyContainers);
-
-// Tests that a type-parameterized test case can be defined and
-// instantiated in a namespace.
-
-namespace library2 {
-
-template <typename T>
-class NumericTest : public Test {
-};
-
-TYPED_TEST_CASE_P(NumericTest);
-
-TYPED_TEST_P(NumericTest, DefaultIsZero) {
-  EXPECT_EQ(0, TypeParam());
-}
-
-TYPED_TEST_P(NumericTest, ZeroIsLessThanOne) {
-  EXPECT_LT(TypeParam(0), TypeParam(1));
-}
-
-REGISTER_TYPED_TEST_CASE_P(NumericTest,
-                           DefaultIsZero, ZeroIsLessThanOne);
-typedef Types<int, double> NumericTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(My, NumericTest, NumericTypes);
-
-static const char* GetTestName() {
-  return testing::UnitTest::GetInstance()->current_test_info()->name();
-}
-// Test the stripping of space from test names
-template <typename T> class TrimmedTest : public Test { };
-TYPED_TEST_CASE_P(TrimmedTest);
-TYPED_TEST_P(TrimmedTest, Test1) { EXPECT_STREQ("Test1", GetTestName()); }
-TYPED_TEST_P(TrimmedTest, Test2) { EXPECT_STREQ("Test2", GetTestName()); }
-TYPED_TEST_P(TrimmedTest, Test3) { EXPECT_STREQ("Test3", GetTestName()); }
-TYPED_TEST_P(TrimmedTest, Test4) { EXPECT_STREQ("Test4", GetTestName()); }
-TYPED_TEST_P(TrimmedTest, Test5) { EXPECT_STREQ("Test5", GetTestName()); }
-REGISTER_TYPED_TEST_CASE_P(
-    TrimmedTest,
-    Test1, Test2,Test3 , Test4 ,Test5 );  // NOLINT
-template <typename T1, typename T2> struct MyPair {};
-// Be sure to try a type with a comma in its name just in case it matters.
-typedef Types<int, double, MyPair<int, int> > TrimTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(My, TrimmedTest, TrimTypes);
-
-}  // namespace library2
-
-#endif  // GTEST_HAS_TYPED_TEST_P
-
-#if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)
-
-// Google Test may not support type-parameterized tests with some
-// compilers. If we use conditional compilation to compile out all
-// code referring to the gtest_main library, MSVC linker will not link
-// that library at all and consequently complain about missing entry
-// point defined in that library (fatal error LNK1561: entry point
-// must be defined). This dummy test keeps gtest_main linked in.
-TEST(DummyTest, TypedTestsAreNotSupportedOnThisPlatform) {}
-
-#endif  // #if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.h b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.h
deleted file mode 100644
index 41d75704..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-typed-test_test.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#ifndef GTEST_TEST_GTEST_TYPED_TEST_TEST_H_
-#define GTEST_TEST_GTEST_TYPED_TEST_TEST_H_
-
-#include "gtest/gtest.h"
-
-#if GTEST_HAS_TYPED_TEST_P
-
-using testing::Test;
-
-// For testing that the same type-parameterized test case can be
-// instantiated in different translation units linked together.
-// ContainerTest will be instantiated in both gtest-typed-test_test.cc
-// and gtest-typed-test2_test.cc.
-
-template <typename T>
-class ContainerTest : public Test {
-};
-
-TYPED_TEST_CASE_P(ContainerTest);
-
-TYPED_TEST_P(ContainerTest, CanBeDefaultConstructed) {
-  TypeParam container;
-}
-
-TYPED_TEST_P(ContainerTest, InitialSizeIsZero) {
-  TypeParam container;
-  EXPECT_EQ(0U, container.size());
-}
-
-REGISTER_TYPED_TEST_CASE_P(ContainerTest,
-                           CanBeDefaultConstructed, InitialSizeIsZero);
-
-#endif  // GTEST_HAS_TYPED_TEST_P
-
-#endif  // GTEST_TEST_GTEST_TYPED_TEST_TEST_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-unittest-api_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-unittest-api_test.cc
deleted file mode 100644
index b1f51688..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest-unittest-api_test.cc
+++ /dev/null
@@ -1,341 +0,0 @@
-// Copyright 2009 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.
-//
-// Author: vladl@google.com (Vlad Losev)
-//
-// The Google C++ Testing Framework (Google Test)
-//
-// This file contains tests verifying correctness of data provided via
-// UnitTest's public methods.
-
-#include "gtest/gtest.h"
-
-#include <string.h>  // For strcmp.
-#include <algorithm>
-
-using ::testing::InitGoogleTest;
-
-namespace testing {
-namespace internal {
-
-template <typename T>
-struct LessByName {
-  bool operator()(const T* a, const T* b) {
-    return strcmp(a->name(), b->name()) < 0;
-  }
-};
-
-class UnitTestHelper {
- public:
-  // Returns the array of pointers to all test cases sorted by the test case
-  // name.  The caller is responsible for deleting the array.
-  static TestCase const** GetSortedTestCases() {
-    UnitTest& unit_test = *UnitTest::GetInstance();
-    TestCase const** const test_cases =
-        new const TestCase*[unit_test.total_test_case_count()];
-
-    for (int i = 0; i < unit_test.total_test_case_count(); ++i)
-      test_cases[i] = unit_test.GetTestCase(i);
-
-    std::sort(test_cases,
-              test_cases + unit_test.total_test_case_count(),
-              LessByName<TestCase>());
-    return test_cases;
-  }
-
-  // Returns the test case by its name.  The caller doesn't own the returned
-  // pointer.
-  static const TestCase* FindTestCase(const char* name) {
-    UnitTest& unit_test = *UnitTest::GetInstance();
-    for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
-      const TestCase* test_case = unit_test.GetTestCase(i);
-      if (0 == strcmp(test_case->name(), name))
-        return test_case;
-    }
-    return NULL;
-  }
-
-  // Returns the array of pointers to all tests in a particular test case
-  // sorted by the test name.  The caller is responsible for deleting the
-  // array.
-  static TestInfo const** GetSortedTests(const TestCase* test_case) {
-    TestInfo const** const tests =
-        new const TestInfo*[test_case->total_test_count()];
-
-    for (int i = 0; i < test_case->total_test_count(); ++i)
-      tests[i] = test_case->GetTestInfo(i);
-
-    std::sort(tests, tests + test_case->total_test_count(),
-              LessByName<TestInfo>());
-    return tests;
-  }
-};
-
-#if GTEST_HAS_TYPED_TEST
-template <typename T> class TestCaseWithCommentTest : public Test {};
-TYPED_TEST_CASE(TestCaseWithCommentTest, Types<int>);
-TYPED_TEST(TestCaseWithCommentTest, Dummy) {}
-
-const int kTypedTestCases = 1;
-const int kTypedTests = 1;
-#else
-const int kTypedTestCases = 0;
-const int kTypedTests = 0;
-#endif  // GTEST_HAS_TYPED_TEST
-
-// We can only test the accessors that do not change value while tests run.
-// Since tests can be run in any order, the values the accessors that track
-// test execution (such as failed_test_count) can not be predicted.
-TEST(ApiTest, UnitTestImmutableAccessorsWork) {
-  UnitTest* unit_test = UnitTest::GetInstance();
-
-  ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
-  EXPECT_EQ(1 + kTypedTestCases, unit_test->test_case_to_run_count());
-  EXPECT_EQ(2, unit_test->disabled_test_count());
-  EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count());
-  EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count());
-
-  const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();
-
-  EXPECT_STREQ("ApiTest", test_cases[0]->name());
-  EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
-#if GTEST_HAS_TYPED_TEST
-  EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
-#endif  // GTEST_HAS_TYPED_TEST
-
-  delete[] test_cases;
-
-  // The following lines initiate actions to verify certain methods in
-  // FinalSuccessChecker::TearDown.
-
-  // Records a test property to verify TestResult::GetTestProperty().
-  RecordProperty("key", "value");
-}
-
-AssertionResult IsNull(const char* str) {
-  if (str != NULL) {
-    return testing::AssertionFailure() << "argument is " << str;
-  }
-  return AssertionSuccess();
-}
-
-TEST(ApiTest, TestCaseImmutableAccessorsWork) {
-  const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
-  ASSERT_TRUE(test_case != NULL);
-
-  EXPECT_STREQ("ApiTest", test_case->name());
-  EXPECT_TRUE(IsNull(test_case->type_param()));
-  EXPECT_TRUE(test_case->should_run());
-  EXPECT_EQ(1, test_case->disabled_test_count());
-  EXPECT_EQ(3, test_case->test_to_run_count());
-  ASSERT_EQ(4, test_case->total_test_count());
-
-  const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
-
-  EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
-  EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
-  EXPECT_TRUE(IsNull(tests[0]->value_param()));
-  EXPECT_TRUE(IsNull(tests[0]->type_param()));
-  EXPECT_FALSE(tests[0]->should_run());
-
-  EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
-  EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
-  EXPECT_TRUE(IsNull(tests[1]->value_param()));
-  EXPECT_TRUE(IsNull(tests[1]->type_param()));
-  EXPECT_TRUE(tests[1]->should_run());
-
-  EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
-  EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
-  EXPECT_TRUE(IsNull(tests[2]->value_param()));
-  EXPECT_TRUE(IsNull(tests[2]->type_param()));
-  EXPECT_TRUE(tests[2]->should_run());
-
-  EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
-  EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
-  EXPECT_TRUE(IsNull(tests[3]->value_param()));
-  EXPECT_TRUE(IsNull(tests[3]->type_param()));
-  EXPECT_TRUE(tests[3]->should_run());
-
-  delete[] tests;
-  tests = NULL;
-
-#if GTEST_HAS_TYPED_TEST
-  test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
-  ASSERT_TRUE(test_case != NULL);
-
-  EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name());
-  EXPECT_STREQ(GetTypeName<int>().c_str(), test_case->type_param());
-  EXPECT_TRUE(test_case->should_run());
-  EXPECT_EQ(0, test_case->disabled_test_count());
-  EXPECT_EQ(1, test_case->test_to_run_count());
-  ASSERT_EQ(1, test_case->total_test_count());
-
-  tests = UnitTestHelper::GetSortedTests(test_case);
-
-  EXPECT_STREQ("Dummy", tests[0]->name());
-  EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
-  EXPECT_TRUE(IsNull(tests[0]->value_param()));
-  EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
-  EXPECT_TRUE(tests[0]->should_run());
-
-  delete[] tests;
-#endif  // GTEST_HAS_TYPED_TEST
-}
-
-TEST(ApiTest, TestCaseDisabledAccessorsWork) {
-  const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test");
-  ASSERT_TRUE(test_case != NULL);
-
-  EXPECT_STREQ("DISABLED_Test", test_case->name());
-  EXPECT_TRUE(IsNull(test_case->type_param()));
-  EXPECT_FALSE(test_case->should_run());
-  EXPECT_EQ(1, test_case->disabled_test_count());
-  EXPECT_EQ(0, test_case->test_to_run_count());
-  ASSERT_EQ(1, test_case->total_test_count());
-
-  const TestInfo* const test_info = test_case->GetTestInfo(0);
-  EXPECT_STREQ("Dummy2", test_info->name());
-  EXPECT_STREQ("DISABLED_Test", test_info->test_case_name());
-  EXPECT_TRUE(IsNull(test_info->value_param()));
-  EXPECT_TRUE(IsNull(test_info->type_param()));
-  EXPECT_FALSE(test_info->should_run());
-}
-
-// These two tests are here to provide support for testing
-// test_case_to_run_count, disabled_test_count, and test_to_run_count.
-TEST(ApiTest, DISABLED_Dummy1) {}
-TEST(DISABLED_Test, Dummy2) {}
-
-class FinalSuccessChecker : public Environment {
- protected:
-  virtual void TearDown() {
-    UnitTest* unit_test = UnitTest::GetInstance();
-
-    EXPECT_EQ(1 + kTypedTestCases, unit_test->successful_test_case_count());
-    EXPECT_EQ(3 + kTypedTests, unit_test->successful_test_count());
-    EXPECT_EQ(0, unit_test->failed_test_case_count());
-    EXPECT_EQ(0, unit_test->failed_test_count());
-    EXPECT_TRUE(unit_test->Passed());
-    EXPECT_FALSE(unit_test->Failed());
-    ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
-
-    const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();
-
-    EXPECT_STREQ("ApiTest", test_cases[0]->name());
-    EXPECT_TRUE(IsNull(test_cases[0]->type_param()));
-    EXPECT_TRUE(test_cases[0]->should_run());
-    EXPECT_EQ(1, test_cases[0]->disabled_test_count());
-    ASSERT_EQ(4, test_cases[0]->total_test_count());
-    EXPECT_EQ(3, test_cases[0]->successful_test_count());
-    EXPECT_EQ(0, test_cases[0]->failed_test_count());
-    EXPECT_TRUE(test_cases[0]->Passed());
-    EXPECT_FALSE(test_cases[0]->Failed());
-
-    EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
-    EXPECT_TRUE(IsNull(test_cases[1]->type_param()));
-    EXPECT_FALSE(test_cases[1]->should_run());
-    EXPECT_EQ(1, test_cases[1]->disabled_test_count());
-    ASSERT_EQ(1, test_cases[1]->total_test_count());
-    EXPECT_EQ(0, test_cases[1]->successful_test_count());
-    EXPECT_EQ(0, test_cases[1]->failed_test_count());
-
-#if GTEST_HAS_TYPED_TEST
-    EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
-    EXPECT_STREQ(GetTypeName<int>().c_str(), test_cases[2]->type_param());
-    EXPECT_TRUE(test_cases[2]->should_run());
-    EXPECT_EQ(0, test_cases[2]->disabled_test_count());
-    ASSERT_EQ(1, test_cases[2]->total_test_count());
-    EXPECT_EQ(1, test_cases[2]->successful_test_count());
-    EXPECT_EQ(0, test_cases[2]->failed_test_count());
-    EXPECT_TRUE(test_cases[2]->Passed());
-    EXPECT_FALSE(test_cases[2]->Failed());
-#endif  // GTEST_HAS_TYPED_TEST
-
-    const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
-    const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
-    EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
-    EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
-    EXPECT_FALSE(tests[0]->should_run());
-
-    EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
-    EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
-    EXPECT_TRUE(IsNull(tests[1]->value_param()));
-    EXPECT_TRUE(IsNull(tests[1]->type_param()));
-    EXPECT_TRUE(tests[1]->should_run());
-    EXPECT_TRUE(tests[1]->result()->Passed());
-    EXPECT_EQ(0, tests[1]->result()->test_property_count());
-
-    EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
-    EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
-    EXPECT_TRUE(IsNull(tests[2]->value_param()));
-    EXPECT_TRUE(IsNull(tests[2]->type_param()));
-    EXPECT_TRUE(tests[2]->should_run());
-    EXPECT_TRUE(tests[2]->result()->Passed());
-    EXPECT_EQ(0, tests[2]->result()->test_property_count());
-
-    EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
-    EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
-    EXPECT_TRUE(IsNull(tests[3]->value_param()));
-    EXPECT_TRUE(IsNull(tests[3]->type_param()));
-    EXPECT_TRUE(tests[3]->should_run());
-    EXPECT_TRUE(tests[3]->result()->Passed());
-    EXPECT_EQ(1, tests[3]->result()->test_property_count());
-    const TestProperty& property = tests[3]->result()->GetTestProperty(0);
-    EXPECT_STREQ("key", property.key());
-    EXPECT_STREQ("value", property.value());
-
-    delete[] tests;
-
-#if GTEST_HAS_TYPED_TEST
-    test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
-    tests = UnitTestHelper::GetSortedTests(test_case);
-
-    EXPECT_STREQ("Dummy", tests[0]->name());
-    EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
-    EXPECT_TRUE(IsNull(tests[0]->value_param()));
-    EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
-    EXPECT_TRUE(tests[0]->should_run());
-    EXPECT_TRUE(tests[0]->result()->Passed());
-    EXPECT_EQ(0, tests[0]->result()->test_property_count());
-
-    delete[] tests;
-#endif  // GTEST_HAS_TYPED_TEST
-    delete[] test_cases;
-  }
-};
-
-}  // namespace internal
-}  // namespace testing
-
-int main(int argc, char **argv) {
-  InitGoogleTest(&argc, argv);
-
-  AddGlobalTestEnvironment(new testing::internal::FinalSuccessChecker());
-
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_all_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_all_test.cc
deleted file mode 100644
index 955aa628..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_all_test.cc
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2009, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Tests for Google C++ Testing Framework (Google Test)
-//
-// Sometimes it's desirable to build most of Google Test's own tests
-// by compiling a single file.  This file serves this purpose.
-#include "test/gtest-filepath_test.cc"
-#include "test/gtest-linked_ptr_test.cc"
-#include "test/gtest-message_test.cc"
-#include "test/gtest-options_test.cc"
-#include "test/gtest-port_test.cc"
-#include "test/gtest_pred_impl_unittest.cc"
-#include "test/gtest_prod_test.cc"
-#include "test/gtest-test-part_test.cc"
-#include "test/gtest-typed-test_test.cc"
-#include "test/gtest-typed-test2_test.cc"
-#include "test/gtest_unittest.cc"
-#include "test/production.cc"
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest.py
deleted file mode 100755
index 78f3e0f5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest.py
+++ /dev/null
@@ -1,212 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2006, 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.
-
-"""Unit test for Google Test's break-on-failure mode.
-
-A user can ask Google Test to seg-fault when an assertion fails, using
-either the GTEST_BREAK_ON_FAILURE environment variable or the
---gtest_break_on_failure flag.  This script tests such functionality
-by invoking gtest_break_on_failure_unittest_ (a program written with
-Google Test) with different environments and command line flags.
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import gtest_test_utils
-import os
-import sys
-
-
-# Constants.
-
-IS_WINDOWS = os.name == 'nt'
-
-# The environment variable for enabling/disabling the break-on-failure mode.
-BREAK_ON_FAILURE_ENV_VAR = 'GTEST_BREAK_ON_FAILURE'
-
-# The command line flag for enabling/disabling the break-on-failure mode.
-BREAK_ON_FAILURE_FLAG = 'gtest_break_on_failure'
-
-# The environment variable for enabling/disabling the throw-on-failure mode.
-THROW_ON_FAILURE_ENV_VAR = 'GTEST_THROW_ON_FAILURE'
-
-# The environment variable for enabling/disabling the catch-exceptions mode.
-CATCH_EXCEPTIONS_ENV_VAR = 'GTEST_CATCH_EXCEPTIONS'
-
-# Path to the gtest_break_on_failure_unittest_ program.
-EXE_PATH = gtest_test_utils.GetTestExecutablePath(
-    'gtest_break_on_failure_unittest_')
-
-
-environ = gtest_test_utils.environ
-SetEnvVar = gtest_test_utils.SetEnvVar
-
-# Tests in this file run a Google-Test-based test program and expect it
-# to terminate prematurely.  Therefore they are incompatible with
-# the premature-exit-file protocol by design.  Unset the
-# premature-exit filepath to prevent Google Test from creating
-# the file.
-SetEnvVar(gtest_test_utils.PREMATURE_EXIT_FILE_ENV_VAR, None)
-
-
-def Run(command):
-  """Runs a command; returns 1 if it was killed by a signal, or 0 otherwise."""
-
-  p = gtest_test_utils.Subprocess(command, env=environ)
-  if p.terminated_by_signal:
-    return 1
-  else:
-    return 0
-
-
-# The tests.
-
-
-class GTestBreakOnFailureUnitTest(gtest_test_utils.TestCase):
-  """Tests using the GTEST_BREAK_ON_FAILURE environment variable or
-  the --gtest_break_on_failure flag to turn assertion failures into
-  segmentation faults.
-  """
-
-  def RunAndVerify(self, env_var_value, flag_value, expect_seg_fault):
-    """Runs gtest_break_on_failure_unittest_ and verifies that it does
-    (or does not) have a seg-fault.
-
-    Args:
-      env_var_value:    value of the GTEST_BREAK_ON_FAILURE environment
-                        variable; None if the variable should be unset.
-      flag_value:       value of the --gtest_break_on_failure flag;
-                        None if the flag should not be present.
-      expect_seg_fault: 1 if the program is expected to generate a seg-fault;
-                        0 otherwise.
-    """
-
-    SetEnvVar(BREAK_ON_FAILURE_ENV_VAR, env_var_value)
-
-    if env_var_value is None:
-      env_var_value_msg = ' is not set'
-    else:
-      env_var_value_msg = '=' + env_var_value
-
-    if flag_value is None:
-      flag = ''
-    elif flag_value == '0':
-      flag = '--%s=0' % BREAK_ON_FAILURE_FLAG
-    else:
-      flag = '--%s' % BREAK_ON_FAILURE_FLAG
-
-    command = [EXE_PATH]
-    if flag:
-      command.append(flag)
-
-    if expect_seg_fault:
-      should_or_not = 'should'
-    else:
-      should_or_not = 'should not'
-
-    has_seg_fault = Run(command)
-
-    SetEnvVar(BREAK_ON_FAILURE_ENV_VAR, None)
-
-    msg = ('when %s%s, an assertion failure in "%s" %s cause a seg-fault.' %
-           (BREAK_ON_FAILURE_ENV_VAR, env_var_value_msg, ' '.join(command),
-            should_or_not))
-    self.assert_(has_seg_fault == expect_seg_fault, msg)
-
-  def testDefaultBehavior(self):
-    """Tests the behavior of the default mode."""
-
-    self.RunAndVerify(env_var_value=None,
-                      flag_value=None,
-                      expect_seg_fault=0)
-
-  def testEnvVar(self):
-    """Tests using the GTEST_BREAK_ON_FAILURE environment variable."""
-
-    self.RunAndVerify(env_var_value='0',
-                      flag_value=None,
-                      expect_seg_fault=0)
-    self.RunAndVerify(env_var_value='1',
-                      flag_value=None,
-                      expect_seg_fault=1)
-
-  def testFlag(self):
-    """Tests using the --gtest_break_on_failure flag."""
-
-    self.RunAndVerify(env_var_value=None,
-                      flag_value='0',
-                      expect_seg_fault=0)
-    self.RunAndVerify(env_var_value=None,
-                      flag_value='1',
-                      expect_seg_fault=1)
-
-  def testFlagOverridesEnvVar(self):
-    """Tests that the flag overrides the environment variable."""
-
-    self.RunAndVerify(env_var_value='0',
-                      flag_value='0',
-                      expect_seg_fault=0)
-    self.RunAndVerify(env_var_value='0',
-                      flag_value='1',
-                      expect_seg_fault=1)
-    self.RunAndVerify(env_var_value='1',
-                      flag_value='0',
-                      expect_seg_fault=0)
-    self.RunAndVerify(env_var_value='1',
-                      flag_value='1',
-                      expect_seg_fault=1)
-
-  def testBreakOnFailureOverridesThrowOnFailure(self):
-    """Tests that gtest_break_on_failure overrides gtest_throw_on_failure."""
-
-    SetEnvVar(THROW_ON_FAILURE_ENV_VAR, '1')
-    try:
-      self.RunAndVerify(env_var_value=None,
-                        flag_value='1',
-                        expect_seg_fault=1)
-    finally:
-      SetEnvVar(THROW_ON_FAILURE_ENV_VAR, None)
-
-  if IS_WINDOWS:
-    def testCatchExceptionsDoesNotInterfere(self):
-      """Tests that gtest_catch_exceptions doesn't interfere."""
-
-      SetEnvVar(CATCH_EXCEPTIONS_ENV_VAR, '1')
-      try:
-        self.RunAndVerify(env_var_value='1',
-                          flag_value='1',
-                          expect_seg_fault=1)
-      finally:
-        SetEnvVar(CATCH_EXCEPTIONS_ENV_VAR, None)
-
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest_.cc
deleted file mode 100644
index dd07478c..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_break_on_failure_unittest_.cc
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2006, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Unit test for Google Test's break-on-failure mode.
-//
-// A user can ask Google Test to seg-fault when an assertion fails, using
-// either the GTEST_BREAK_ON_FAILURE environment variable or the
-// --gtest_break_on_failure flag.  This file is used for testing such
-// functionality.
-//
-// This program will be invoked from a Python unit test.  It is
-// expected to fail.  Don't run it directly.
-
-#include "gtest/gtest.h"
-
-#if GTEST_OS_WINDOWS
-# include <windows.h>
-# include <stdlib.h>
-#endif
-
-namespace {
-
-// A test that's expected to fail.
-TEST(Foo, Bar) {
-  EXPECT_EQ(2, 3);
-}
-
-#if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE
-// On Windows Mobile global exception handlers are not supported.
-LONG WINAPI ExitWithExceptionCode(
-    struct _EXCEPTION_POINTERS* exception_pointers) {
-  exit(exception_pointers->ExceptionRecord->ExceptionCode);
-}
-#endif
-
-}  // namespace
-
-int main(int argc, char **argv) {
-#if GTEST_OS_WINDOWS
-  // Suppresses display of the Windows error dialog upon encountering
-  // a general protection fault (segment violation).
-  SetErrorMode(SEM_NOGPFAULTERRORBOX | SEM_FAILCRITICALERRORS);
-
-# if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE
-
-  // The default unhandled exception filter does not always exit
-  // with the exception code as exit code - for example it exits with
-  // 0 for EXCEPTION_ACCESS_VIOLATION and 1 for EXCEPTION_BREAKPOINT
-  // if the application is compiled in debug mode. Thus we use our own
-  // filter which always exits with the exception code for unhandled
-  // exceptions.
-  SetUnhandledExceptionFilter(ExitWithExceptionCode);
-
-# endif
-#endif
-
-  testing::InitGoogleTest(&argc, argv);
-
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test.py
deleted file mode 100755
index e6fc22fd..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test.py
+++ /dev/null
@@ -1,237 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2010 Google Inc.  All Rights Reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-"""Tests Google Test's exception catching behavior.
-
-This script invokes gtest_catch_exceptions_test_ and
-gtest_catch_exceptions_ex_test_ (programs written with
-Google Test) and verifies their output.
-"""
-
-__author__ = 'vladl@google.com (Vlad Losev)'
-
-import os
-
-import gtest_test_utils
-
-# Constants.
-FLAG_PREFIX = '--gtest_'
-LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'
-NO_CATCH_EXCEPTIONS_FLAG = FLAG_PREFIX + 'catch_exceptions=0'
-FILTER_FLAG = FLAG_PREFIX + 'filter'
-
-# Path to the gtest_catch_exceptions_ex_test_ binary, compiled with
-# exceptions enabled.
-EX_EXE_PATH = gtest_test_utils.GetTestExecutablePath(
-    'gtest_catch_exceptions_ex_test_')
-
-# Path to the gtest_catch_exceptions_test_ binary, compiled with
-# exceptions disabled.
-EXE_PATH = gtest_test_utils.GetTestExecutablePath(
-    'gtest_catch_exceptions_no_ex_test_')
-
-environ = gtest_test_utils.environ
-SetEnvVar = gtest_test_utils.SetEnvVar
-
-# Tests in this file run a Google-Test-based test program and expect it
-# to terminate prematurely.  Therefore they are incompatible with
-# the premature-exit-file protocol by design.  Unset the
-# premature-exit filepath to prevent Google Test from creating
-# the file.
-SetEnvVar(gtest_test_utils.PREMATURE_EXIT_FILE_ENV_VAR, None)
-
-TEST_LIST = gtest_test_utils.Subprocess(
-    [EXE_PATH, LIST_TESTS_FLAG], env=environ).output
-
-SUPPORTS_SEH_EXCEPTIONS = 'ThrowsSehException' in TEST_LIST
-
-if SUPPORTS_SEH_EXCEPTIONS:
-  BINARY_OUTPUT = gtest_test_utils.Subprocess([EXE_PATH], env=environ).output
-
-EX_BINARY_OUTPUT = gtest_test_utils.Subprocess(
-    [EX_EXE_PATH], env=environ).output
-
-
-# The tests.
-if SUPPORTS_SEH_EXCEPTIONS:
-  # pylint:disable-msg=C6302
-  class CatchSehExceptionsTest(gtest_test_utils.TestCase):
-    """Tests exception-catching behavior."""
-
-
-    def TestSehExceptions(self, test_output):
-      self.assert_('SEH exception with code 0x2a thrown '
-                   'in the test fixture\'s constructor'
-                   in test_output)
-      self.assert_('SEH exception with code 0x2a thrown '
-                   'in the test fixture\'s destructor'
-                   in test_output)
-      self.assert_('SEH exception with code 0x2a thrown in SetUpTestCase()'
-                   in test_output)
-      self.assert_('SEH exception with code 0x2a thrown in TearDownTestCase()'
-                   in test_output)
-      self.assert_('SEH exception with code 0x2a thrown in SetUp()'
-                   in test_output)
-      self.assert_('SEH exception with code 0x2a thrown in TearDown()'
-                   in test_output)
-      self.assert_('SEH exception with code 0x2a thrown in the test body'
-                   in test_output)
-
-    def testCatchesSehExceptionsWithCxxExceptionsEnabled(self):
-      self.TestSehExceptions(EX_BINARY_OUTPUT)
-
-    def testCatchesSehExceptionsWithCxxExceptionsDisabled(self):
-      self.TestSehExceptions(BINARY_OUTPUT)
-
-
-class CatchCxxExceptionsTest(gtest_test_utils.TestCase):
-  """Tests C++ exception-catching behavior.
-
-     Tests in this test case verify that:
-     * C++ exceptions are caught and logged as C++ (not SEH) exceptions
-     * Exception thrown affect the remainder of the test work flow in the
-       expected manner.
-  """
-
-  def testCatchesCxxExceptionsInFixtureConstructor(self):
-    self.assert_('C++ exception with description '
-                 '"Standard C++ exception" thrown '
-                 'in the test fixture\'s constructor'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('unexpected' not in EX_BINARY_OUTPUT,
-                 'This failure belongs in this test only if '
-                 '"CxxExceptionInConstructorTest" (no quotes) '
-                 'appears on the same line as words "called unexpectedly"')
-
-  if ('CxxExceptionInDestructorTest.ThrowsExceptionInDestructor' in
-      EX_BINARY_OUTPUT):
-
-    def testCatchesCxxExceptionsInFixtureDestructor(self):
-      self.assert_('C++ exception with description '
-                   '"Standard C++ exception" thrown '
-                   'in the test fixture\'s destructor'
-                   in EX_BINARY_OUTPUT)
-      self.assert_('CxxExceptionInDestructorTest::TearDownTestCase() '
-                   'called as expected.'
-                   in EX_BINARY_OUTPUT)
-
-  def testCatchesCxxExceptionsInSetUpTestCase(self):
-    self.assert_('C++ exception with description "Standard C++ exception"'
-                 ' thrown in SetUpTestCase()'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInConstructorTest::TearDownTestCase() '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInSetUpTestCaseTest constructor '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInSetUpTestCaseTest destructor '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInSetUpTestCaseTest::SetUp() '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInSetUpTestCaseTest::TearDown() '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInSetUpTestCaseTest test body '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-
-  def testCatchesCxxExceptionsInTearDownTestCase(self):
-    self.assert_('C++ exception with description "Standard C++ exception"'
-                 ' thrown in TearDownTestCase()'
-                 in EX_BINARY_OUTPUT)
-
-  def testCatchesCxxExceptionsInSetUp(self):
-    self.assert_('C++ exception with description "Standard C++ exception"'
-                 ' thrown in SetUp()'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInSetUpTest::TearDownTestCase() '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInSetUpTest destructor '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInSetUpTest::TearDown() '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('unexpected' not in EX_BINARY_OUTPUT,
-                 'This failure belongs in this test only if '
-                 '"CxxExceptionInSetUpTest" (no quotes) '
-                 'appears on the same line as words "called unexpectedly"')
-
-  def testCatchesCxxExceptionsInTearDown(self):
-    self.assert_('C++ exception with description "Standard C++ exception"'
-                 ' thrown in TearDown()'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInTearDownTest::TearDownTestCase() '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInTearDownTest destructor '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-
-  def testCatchesCxxExceptionsInTestBody(self):
-    self.assert_('C++ exception with description "Standard C++ exception"'
-                 ' thrown in the test body'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInTestBodyTest::TearDownTestCase() '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInTestBodyTest destructor '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-    self.assert_('CxxExceptionInTestBodyTest::TearDown() '
-                 'called as expected.'
-                 in EX_BINARY_OUTPUT)
-
-  def testCatchesNonStdCxxExceptions(self):
-    self.assert_('Unknown C++ exception thrown in the test body'
-                 in EX_BINARY_OUTPUT)
-
-  def testUnhandledCxxExceptionsAbortTheProgram(self):
-    # Filters out SEH exception tests on Windows. Unhandled SEH exceptions
-    # cause tests to show pop-up windows there.
-    FITLER_OUT_SEH_TESTS_FLAG = FILTER_FLAG + '=-*Seh*'
-    # By default, Google Test doesn't catch the exceptions.
-    uncaught_exceptions_ex_binary_output = gtest_test_utils.Subprocess(
-        [EX_EXE_PATH,
-         NO_CATCH_EXCEPTIONS_FLAG,
-         FITLER_OUT_SEH_TESTS_FLAG],
-        env=environ).output
-
-    self.assert_('Unhandled C++ exception terminating the program'
-                 in uncaught_exceptions_ex_binary_output)
-    self.assert_('unexpected' not in uncaught_exceptions_ex_binary_output)
-
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test_.cc
deleted file mode 100644
index d0fc82c9..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_catch_exceptions_test_.cc
+++ /dev/null
@@ -1,311 +0,0 @@
-// Copyright 2010, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: vladl@google.com (Vlad Losev)
-//
-// Tests for Google Test itself. Tests in this file throw C++ or SEH
-// exceptions, and the output is verified by gtest_catch_exceptions_test.py.
-
-#include "gtest/gtest.h"
-
-#include <stdio.h>  // NOLINT
-#include <stdlib.h>  // For exit().
-
-#if GTEST_HAS_SEH
-# include <windows.h>
-#endif
-
-#if GTEST_HAS_EXCEPTIONS
-# include <exception>  // For set_terminate().
-# include <stdexcept>
-#endif
-
-using testing::Test;
-
-#if GTEST_HAS_SEH
-
-class SehExceptionInConstructorTest : public Test {
- public:
-  SehExceptionInConstructorTest() { RaiseException(42, 0, 0, NULL); }
-};
-
-TEST_F(SehExceptionInConstructorTest, ThrowsExceptionInConstructor) {}
-
-class SehExceptionInDestructorTest : public Test {
- public:
-  ~SehExceptionInDestructorTest() { RaiseException(42, 0, 0, NULL); }
-};
-
-TEST_F(SehExceptionInDestructorTest, ThrowsExceptionInDestructor) {}
-
-class SehExceptionInSetUpTestCaseTest : public Test {
- public:
-  static void SetUpTestCase() { RaiseException(42, 0, 0, NULL); }
-};
-
-TEST_F(SehExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) {}
-
-class SehExceptionInTearDownTestCaseTest : public Test {
- public:
-  static void TearDownTestCase() { RaiseException(42, 0, 0, NULL); }
-};
-
-TEST_F(SehExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {}
-
-class SehExceptionInSetUpTest : public Test {
- protected:
-  virtual void SetUp() { RaiseException(42, 0, 0, NULL); }
-};
-
-TEST_F(SehExceptionInSetUpTest, ThrowsExceptionInSetUp) {}
-
-class SehExceptionInTearDownTest : public Test {
- protected:
-  virtual void TearDown() { RaiseException(42, 0, 0, NULL); }
-};
-
-TEST_F(SehExceptionInTearDownTest, ThrowsExceptionInTearDown) {}
-
-TEST(SehExceptionTest, ThrowsSehException) {
-  RaiseException(42, 0, 0, NULL);
-}
-
-#endif  // GTEST_HAS_SEH
-
-#if GTEST_HAS_EXCEPTIONS
-
-class CxxExceptionInConstructorTest : public Test {
- public:
-  CxxExceptionInConstructorTest() {
-    // Without this macro VC++ complains about unreachable code at the end of
-    // the constructor.
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
-        throw std::runtime_error("Standard C++ exception"));
-  }
-
-  static void TearDownTestCase() {
-    printf("%s",
-           "CxxExceptionInConstructorTest::TearDownTestCase() "
-           "called as expected.\n");
-  }
-
- protected:
-  ~CxxExceptionInConstructorTest() {
-    ADD_FAILURE() << "CxxExceptionInConstructorTest destructor "
-                  << "called unexpectedly.";
-  }
-
-  virtual void SetUp() {
-    ADD_FAILURE() << "CxxExceptionInConstructorTest::SetUp() "
-                  << "called unexpectedly.";
-  }
-
-  virtual void TearDown() {
-    ADD_FAILURE() << "CxxExceptionInConstructorTest::TearDown() "
-                  << "called unexpectedly.";
-  }
-};
-
-TEST_F(CxxExceptionInConstructorTest, ThrowsExceptionInConstructor) {
-  ADD_FAILURE() << "CxxExceptionInConstructorTest test body "
-                << "called unexpectedly.";
-}
-
-// Exceptions in destructors are not supported in C++11.
-#if !defined(__GXX_EXPERIMENTAL_CXX0X__) &&  __cplusplus < 201103L
-class CxxExceptionInDestructorTest : public Test {
- public:
-  static void TearDownTestCase() {
-    printf("%s",
-           "CxxExceptionInDestructorTest::TearDownTestCase() "
-           "called as expected.\n");
-  }
-
- protected:
-  ~CxxExceptionInDestructorTest() {
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
-        throw std::runtime_error("Standard C++ exception"));
-  }
-};
-
-TEST_F(CxxExceptionInDestructorTest, ThrowsExceptionInDestructor) {}
-#endif  // C++11 mode
-
-class CxxExceptionInSetUpTestCaseTest : public Test {
- public:
-  CxxExceptionInSetUpTestCaseTest() {
-    printf("%s",
-           "CxxExceptionInSetUpTestCaseTest constructor "
-           "called as expected.\n");
-  }
-
-  static void SetUpTestCase() {
-    throw std::runtime_error("Standard C++ exception");
-  }
-
-  static void TearDownTestCase() {
-    printf("%s",
-           "CxxExceptionInSetUpTestCaseTest::TearDownTestCase() "
-           "called as expected.\n");
-  }
-
- protected:
-  ~CxxExceptionInSetUpTestCaseTest() {
-    printf("%s",
-           "CxxExceptionInSetUpTestCaseTest destructor "
-           "called as expected.\n");
-  }
-
-  virtual void SetUp() {
-    printf("%s",
-           "CxxExceptionInSetUpTestCaseTest::SetUp() "
-           "called as expected.\n");
-  }
-
-  virtual void TearDown() {
-    printf("%s",
-           "CxxExceptionInSetUpTestCaseTest::TearDown() "
-           "called as expected.\n");
-  }
-};
-
-TEST_F(CxxExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) {
-  printf("%s",
-         "CxxExceptionInSetUpTestCaseTest test body "
-         "called as expected.\n");
-}
-
-class CxxExceptionInTearDownTestCaseTest : public Test {
- public:
-  static void TearDownTestCase() {
-    throw std::runtime_error("Standard C++ exception");
-  }
-};
-
-TEST_F(CxxExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {}
-
-class CxxExceptionInSetUpTest : public Test {
- public:
-  static void TearDownTestCase() {
-    printf("%s",
-           "CxxExceptionInSetUpTest::TearDownTestCase() "
-           "called as expected.\n");
-  }
-
- protected:
-  ~CxxExceptionInSetUpTest() {
-    printf("%s",
-           "CxxExceptionInSetUpTest destructor "
-           "called as expected.\n");
-  }
-
-  virtual void SetUp() { throw std::runtime_error("Standard C++ exception"); }
-
-  virtual void TearDown() {
-    printf("%s",
-           "CxxExceptionInSetUpTest::TearDown() "
-           "called as expected.\n");
-  }
-};
-
-TEST_F(CxxExceptionInSetUpTest, ThrowsExceptionInSetUp) {
-  ADD_FAILURE() << "CxxExceptionInSetUpTest test body "
-                << "called unexpectedly.";
-}
-
-class CxxExceptionInTearDownTest : public Test {
- public:
-  static void TearDownTestCase() {
-    printf("%s",
-           "CxxExceptionInTearDownTest::TearDownTestCase() "
-           "called as expected.\n");
-  }
-
- protected:
-  ~CxxExceptionInTearDownTest() {
-    printf("%s",
-           "CxxExceptionInTearDownTest destructor "
-           "called as expected.\n");
-  }
-
-  virtual void TearDown() {
-    throw std::runtime_error("Standard C++ exception");
-  }
-};
-
-TEST_F(CxxExceptionInTearDownTest, ThrowsExceptionInTearDown) {}
-
-class CxxExceptionInTestBodyTest : public Test {
- public:
-  static void TearDownTestCase() {
-    printf("%s",
-           "CxxExceptionInTestBodyTest::TearDownTestCase() "
-           "called as expected.\n");
-  }
-
- protected:
-  ~CxxExceptionInTestBodyTest() {
-    printf("%s",
-           "CxxExceptionInTestBodyTest destructor "
-           "called as expected.\n");
-  }
-
-  virtual void TearDown() {
-    printf("%s",
-           "CxxExceptionInTestBodyTest::TearDown() "
-           "called as expected.\n");
-  }
-};
-
-TEST_F(CxxExceptionInTestBodyTest, ThrowsStdCxxException) {
-  throw std::runtime_error("Standard C++ exception");
-}
-
-TEST(CxxExceptionTest, ThrowsNonStdCxxException) {
-  throw "C-string";
-}
-
-// This terminate handler aborts the program using exit() rather than abort().
-// This avoids showing pop-ups on Windows systems and core dumps on Unix-like
-// ones.
-void TerminateHandler() {
-  fprintf(stderr, "%s\n", "Unhandled C++ exception terminating the program.");
-  fflush(NULL);
-  exit(3);
-}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-int main(int argc, char** argv) {
-#if GTEST_HAS_EXCEPTIONS
-  std::set_terminate(&TerminateHandler);
-#endif
-  testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test.py
deleted file mode 100755
index d02a53ed..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test.py
+++ /dev/null
@@ -1,130 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-
-"""Verifies that Google Test correctly determines whether to use colors."""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import gtest_test_utils
-
-
-IS_WINDOWS = os.name = 'nt'
-
-COLOR_ENV_VAR = 'GTEST_COLOR'
-COLOR_FLAG = 'gtest_color'
-COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_color_test_')
-
-
-def SetEnvVar(env_var, value):
-  """Sets the env variable to 'value'; unsets it when 'value' is None."""
-
-  if value is not None:
-    os.environ[env_var] = value
-  elif env_var in os.environ:
-    del os.environ[env_var]
-
-
-def UsesColor(term, color_env_var, color_flag):
-  """Runs gtest_color_test_ and returns its exit code."""
-
-  SetEnvVar('TERM', term)
-  SetEnvVar(COLOR_ENV_VAR, color_env_var)
-
-  if color_flag is None:
-    args = []
-  else:
-    args = ['--%s=%s' % (COLOR_FLAG, color_flag)]
-  p = gtest_test_utils.Subprocess([COMMAND] + args)
-  return not p.exited or p.exit_code
-
-
-class GTestColorTest(gtest_test_utils.TestCase):
-  def testNoEnvVarNoFlag(self):
-    """Tests the case when there's neither GTEST_COLOR nor --gtest_color."""
-
-    if not IS_WINDOWS:
-      self.assert_(not UsesColor('dumb', None, None))
-      self.assert_(not UsesColor('emacs', None, None))
-      self.assert_(not UsesColor('xterm-mono', None, None))
-      self.assert_(not UsesColor('unknown', None, None))
-      self.assert_(not UsesColor(None, None, None))
-    self.assert_(UsesColor('linux', None, None))
-    self.assert_(UsesColor('cygwin', None, None))
-    self.assert_(UsesColor('xterm', None, None))
-    self.assert_(UsesColor('xterm-color', None, None))
-    self.assert_(UsesColor('xterm-256color', None, None))
-
-  def testFlagOnly(self):
-    """Tests the case when there's --gtest_color but not GTEST_COLOR."""
-
-    self.assert_(not UsesColor('dumb', None, 'no'))
-    self.assert_(not UsesColor('xterm-color', None, 'no'))
-    if not IS_WINDOWS:
-      self.assert_(not UsesColor('emacs', None, 'auto'))
-    self.assert_(UsesColor('xterm', None, 'auto'))
-    self.assert_(UsesColor('dumb', None, 'yes'))
-    self.assert_(UsesColor('xterm', None, 'yes'))
-
-  def testEnvVarOnly(self):
-    """Tests the case when there's GTEST_COLOR but not --gtest_color."""
-
-    self.assert_(not UsesColor('dumb', 'no', None))
-    self.assert_(not UsesColor('xterm-color', 'no', None))
-    if not IS_WINDOWS:
-      self.assert_(not UsesColor('dumb', 'auto', None))
-    self.assert_(UsesColor('xterm-color', 'auto', None))
-    self.assert_(UsesColor('dumb', 'yes', None))
-    self.assert_(UsesColor('xterm-color', 'yes', None))
-
-  def testEnvVarAndFlag(self):
-    """Tests the case when there are both GTEST_COLOR and --gtest_color."""
-
-    self.assert_(not UsesColor('xterm-color', 'no', 'no'))
-    self.assert_(UsesColor('dumb', 'no', 'yes'))
-    self.assert_(UsesColor('xterm-color', 'no', 'auto'))
-
-  def testAliasesOfYesAndNo(self):
-    """Tests using aliases in specifying --gtest_color."""
-
-    self.assert_(UsesColor('dumb', None, 'true'))
-    self.assert_(UsesColor('dumb', None, 'YES'))
-    self.assert_(UsesColor('dumb', None, 'T'))
-    self.assert_(UsesColor('dumb', None, '1'))
-
-    self.assert_(not UsesColor('xterm', None, 'f'))
-    self.assert_(not UsesColor('xterm', None, 'false'))
-    self.assert_(not UsesColor('xterm', None, '0'))
-    self.assert_(not UsesColor('xterm', None, 'unknown'))
-
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test_.cc
deleted file mode 100644
index f61ebb89..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_color_test_.cc
+++ /dev/null
@@ -1,71 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// A helper program for testing how Google Test determines whether to use
-// colors in the output.  It prints "YES" and returns 1 if Google Test
-// decides to use colors, and prints "NO" and returns 0 otherwise.
-
-#include <stdio.h>
-
-#include "gtest/gtest.h"
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick is to
-// prevent a user from accidentally including gtest-internal-inl.h in
-// his code.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-using testing::internal::ShouldUseColor;
-
-// The purpose of this is to ensure that the UnitTest singleton is
-// created before main() is entered, and thus that ShouldUseColor()
-// works the same way as in a real Google-Test-based test.  We don't actual
-// run the TEST itself.
-TEST(GTestColorTest, Dummy) {
-}
-
-int main(int argc, char** argv) {
-  testing::InitGoogleTest(&argc, argv);
-
-  if (ShouldUseColor(true)) {
-    // Google Test decides to use colors in the output (assuming it
-    // goes to a TTY).
-    printf("YES\n");
-    return 1;
-  } else {
-    // Google Test decides not to use colors in the output.
-    printf("NO\n");
-    return 0;
-  }
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test.py
deleted file mode 100755
index 424075cf..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test.py
+++ /dev/null
@@ -1,117 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-
-"""Verifies that Google Test correctly parses environment variables."""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import gtest_test_utils
-
-
-IS_WINDOWS = os.name == 'nt'
-IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'
-
-COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_env_var_test_')
-
-environ = os.environ.copy()
-
-
-def AssertEq(expected, actual):
-  if expected != actual:
-    print('Expected: %s' % (expected,))
-    print('  Actual: %s' % (actual,))
-    raise AssertionError
-
-
-def SetEnvVar(env_var, value):
-  """Sets the env variable to 'value'; unsets it when 'value' is None."""
-
-  if value is not None:
-    environ[env_var] = value
-  elif env_var in environ:
-    del environ[env_var]
-
-
-def GetFlag(flag):
-  """Runs gtest_env_var_test_ and returns its output."""
-
-  args = [COMMAND]
-  if flag is not None:
-    args += [flag]
-  return gtest_test_utils.Subprocess(args, env=environ).output
-
-
-def TestFlag(flag, test_val, default_val):
-  """Verifies that the given flag is affected by the corresponding env var."""
-
-  env_var = 'GTEST_' + flag.upper()
-  SetEnvVar(env_var, test_val)
-  AssertEq(test_val, GetFlag(flag))
-  SetEnvVar(env_var, None)
-  AssertEq(default_val, GetFlag(flag))
-
-
-class GTestEnvVarTest(gtest_test_utils.TestCase):
-  def testEnvVarAffectsFlag(self):
-    """Tests that environment variable should affect the corresponding flag."""
-
-    TestFlag('break_on_failure', '1', '0')
-    TestFlag('color', 'yes', 'auto')
-    TestFlag('filter', 'FooTest.Bar', '*')
-    SetEnvVar('XML_OUTPUT_FILE', None) # For 'output' test
-    TestFlag('output', 'xml:tmp/foo.xml', '')
-    TestFlag('print_time', '0', '1')
-    TestFlag('repeat', '999', '1')
-    TestFlag('throw_on_failure', '1', '0')
-    TestFlag('death_test_style', 'threadsafe', 'fast')
-    TestFlag('catch_exceptions', '0', '1')
-
-    if IS_LINUX:
-      TestFlag('death_test_use_fork', '1', '0')
-      TestFlag('stack_trace_depth', '0', '100')
-
-  def testXmlOutputFile(self):
-    """Tests that $XML_OUTPUT_FILE affects the output flag."""
-
-    SetEnvVar('GTEST_OUTPUT', None)
-    SetEnvVar('XML_OUTPUT_FILE', 'tmp/bar.xml')
-    AssertEq('xml:tmp/bar.xml', GetFlag('output'))
-
-  def testXmlOutputFileOverride(self):
-    """Tests that $XML_OUTPUT_FILE is overridden by $GTEST_OUTPUT"""
-
-    SetEnvVar('GTEST_OUTPUT', 'xml:tmp/foo.xml')
-    SetEnvVar('XML_OUTPUT_FILE', 'tmp/bar.xml')
-    AssertEq('xml:tmp/foo.xml', GetFlag('output'))
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test_.cc
deleted file mode 100644
index 539afc96..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_env_var_test_.cc
+++ /dev/null
@@ -1,126 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// A helper program for testing that Google Test parses the environment
-// variables correctly.
-
-#include "gtest/gtest.h"
-
-#include <iostream>
-
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-using ::std::cout;
-
-namespace testing {
-
-// The purpose of this is to make the test more realistic by ensuring
-// that the UnitTest singleton is created before main() is entered.
-// We don't actual run the TEST itself.
-TEST(GTestEnvVarTest, Dummy) {
-}
-
-void PrintFlag(const char* flag) {
-  if (strcmp(flag, "break_on_failure") == 0) {
-    cout << GTEST_FLAG(break_on_failure);
-    return;
-  }
-
-  if (strcmp(flag, "catch_exceptions") == 0) {
-    cout << GTEST_FLAG(catch_exceptions);
-    return;
-  }
-
-  if (strcmp(flag, "color") == 0) {
-    cout << GTEST_FLAG(color);
-    return;
-  }
-
-  if (strcmp(flag, "death_test_style") == 0) {
-    cout << GTEST_FLAG(death_test_style);
-    return;
-  }
-
-  if (strcmp(flag, "death_test_use_fork") == 0) {
-    cout << GTEST_FLAG(death_test_use_fork);
-    return;
-  }
-
-  if (strcmp(flag, "filter") == 0) {
-    cout << GTEST_FLAG(filter);
-    return;
-  }
-
-  if (strcmp(flag, "output") == 0) {
-    cout << GTEST_FLAG(output);
-    return;
-  }
-
-  if (strcmp(flag, "print_time") == 0) {
-    cout << GTEST_FLAG(print_time);
-    return;
-  }
-
-  if (strcmp(flag, "repeat") == 0) {
-    cout << GTEST_FLAG(repeat);
-    return;
-  }
-
-  if (strcmp(flag, "stack_trace_depth") == 0) {
-    cout << GTEST_FLAG(stack_trace_depth);
-    return;
-  }
-
-  if (strcmp(flag, "throw_on_failure") == 0) {
-    cout << GTEST_FLAG(throw_on_failure);
-    return;
-  }
-
-  cout << "Invalid flag name " << flag
-       << ".  Valid names are break_on_failure, color, filter, etc.\n";
-  exit(1);
-}
-
-}  // namespace testing
-
-int main(int argc, char** argv) {
-  testing::InitGoogleTest(&argc, argv);
-
-  if (argc != 2) {
-    cout << "Usage: gtest_env_var_test_ NAME_OF_FLAG\n";
-    return 1;
-  }
-
-  testing::PrintFlag(argv[1]);
-  return 0;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_environment_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_environment_test.cc
deleted file mode 100644
index 3cff19e7..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_environment_test.cc
+++ /dev/null
@@ -1,192 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Tests using global test environments.
-
-#include <stdlib.h>
-#include <stdio.h>
-#include "gtest/gtest.h"
-
-#define GTEST_IMPLEMENTATION_ 1  // Required for the next #include.
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-namespace testing {
-GTEST_DECLARE_string_(filter);
-}
-
-namespace {
-
-enum FailureType {
-  NO_FAILURE, NON_FATAL_FAILURE, FATAL_FAILURE
-};
-
-// For testing using global test environments.
-class MyEnvironment : public testing::Environment {
- public:
-  MyEnvironment() { Reset(); }
-
-  // Depending on the value of failure_in_set_up_, SetUp() will
-  // generate a non-fatal failure, generate a fatal failure, or
-  // succeed.
-  virtual void SetUp() {
-    set_up_was_run_ = true;
-
-    switch (failure_in_set_up_) {
-      case NON_FATAL_FAILURE:
-        ADD_FAILURE() << "Expected non-fatal failure in global set-up.";
-        break;
-      case FATAL_FAILURE:
-        FAIL() << "Expected fatal failure in global set-up.";
-        break;
-      default:
-        break;
-    }
-  }
-
-  // Generates a non-fatal failure.
-  virtual void TearDown() {
-    tear_down_was_run_ = true;
-    ADD_FAILURE() << "Expected non-fatal failure in global tear-down.";
-  }
-
-  // Resets the state of the environment s.t. it can be reused.
-  void Reset() {
-    failure_in_set_up_ = NO_FAILURE;
-    set_up_was_run_ = false;
-    tear_down_was_run_ = false;
-  }
-
-  // We call this function to set the type of failure SetUp() should
-  // generate.
-  void set_failure_in_set_up(FailureType type) {
-    failure_in_set_up_ = type;
-  }
-
-  // Was SetUp() run?
-  bool set_up_was_run() const { return set_up_was_run_; }
-
-  // Was TearDown() run?
-  bool tear_down_was_run() const { return tear_down_was_run_; }
-
- private:
-  FailureType failure_in_set_up_;
-  bool set_up_was_run_;
-  bool tear_down_was_run_;
-};
-
-// Was the TEST run?
-bool test_was_run;
-
-// The sole purpose of this TEST is to enable us to check whether it
-// was run.
-TEST(FooTest, Bar) {
-  test_was_run = true;
-}
-
-// Prints the message and aborts the program if condition is false.
-void Check(bool condition, const char* msg) {
-  if (!condition) {
-    printf("FAILED: %s\n", msg);
-    testing::internal::posix::Abort();
-  }
-}
-
-// Runs the tests.  Return true iff successful.
-//
-// The 'failure' parameter specifies the type of failure that should
-// be generated by the global set-up.
-int RunAllTests(MyEnvironment* env, FailureType failure) {
-  env->Reset();
-  env->set_failure_in_set_up(failure);
-  test_was_run = false;
-  testing::internal::GetUnitTestImpl()->ClearAdHocTestResult();
-  return RUN_ALL_TESTS();
-}
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  testing::InitGoogleTest(&argc, argv);
-
-  // Registers a global test environment, and verifies that the
-  // registration function returns its argument.
-  MyEnvironment* const env = new MyEnvironment;
-  Check(testing::AddGlobalTestEnvironment(env) == env,
-        "AddGlobalTestEnvironment() should return its argument.");
-
-  // Verifies that RUN_ALL_TESTS() runs the tests when the global
-  // set-up is successful.
-  Check(RunAllTests(env, NO_FAILURE) != 0,
-        "RUN_ALL_TESTS() should return non-zero, as the global tear-down "
-        "should generate a failure.");
-  Check(test_was_run,
-        "The tests should run, as the global set-up should generate no "
-        "failure");
-  Check(env->tear_down_was_run(),
-        "The global tear-down should run, as the global set-up was run.");
-
-  // Verifies that RUN_ALL_TESTS() runs the tests when the global
-  // set-up generates no fatal failure.
-  Check(RunAllTests(env, NON_FATAL_FAILURE) != 0,
-        "RUN_ALL_TESTS() should return non-zero, as both the global set-up "
-        "and the global tear-down should generate a non-fatal failure.");
-  Check(test_was_run,
-        "The tests should run, as the global set-up should generate no "
-        "fatal failure.");
-  Check(env->tear_down_was_run(),
-        "The global tear-down should run, as the global set-up was run.");
-
-  // Verifies that RUN_ALL_TESTS() runs no test when the global set-up
-  // generates a fatal failure.
-  Check(RunAllTests(env, FATAL_FAILURE) != 0,
-        "RUN_ALL_TESTS() should return non-zero, as the global set-up "
-        "should generate a fatal failure.");
-  Check(!test_was_run,
-        "The tests should not run, as the global set-up should generate "
-        "a fatal failure.");
-  Check(env->tear_down_was_run(),
-        "The global tear-down should run, as the global set-up was run.");
-
-  // Verifies that RUN_ALL_TESTS() doesn't do global set-up or
-  // tear-down when there is no test to run.
-  testing::GTEST_FLAG(filter) = "-*";
-  Check(RunAllTests(env, NO_FAILURE) == 0,
-        "RUN_ALL_TESTS() should return zero, as there is no test to run.");
-  Check(!env->set_up_was_run(),
-        "The global set-up should not run, as there is no test to run.");
-  Check(!env->tear_down_was_run(),
-        "The global tear-down should not run, "
-        "as the global set-up was not run.");
-
-  printf("PASS\n");
-  return 0;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest.py
deleted file mode 100755
index ec0b151b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest.py
+++ /dev/null
@@ -1,636 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2005 Google Inc. All Rights Reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-"""Unit test for Google Test test filters.
-
-A user can specify which test(s) in a Google Test program to run via either
-the GTEST_FILTER environment variable or the --gtest_filter flag.
-This script tests such functionality by invoking
-gtest_filter_unittest_ (a program written with Google Test) with different
-environments and command line flags.
-
-Note that test sharding may also influence which tests are filtered. Therefore,
-we test that here also.
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import re
-try:
-  from sets import Set as set  # For Python 2.3 compatibility
-except ImportError:
-  pass
-import sys
-
-import gtest_test_utils
-
-# Constants.
-
-# Checks if this platform can pass empty environment variables to child
-# processes.  We set an env variable to an empty string and invoke a python
-# script in a subprocess to print whether the variable is STILL in
-# os.environ.  We then use 'eval' to parse the child's output so that an
-# exception is thrown if the input is anything other than 'True' nor 'False'.
-os.environ['EMPTY_VAR'] = ''
-child = gtest_test_utils.Subprocess(
-    [sys.executable, '-c', 'import os; print(\'EMPTY_VAR\' in os.environ)'])
-CAN_PASS_EMPTY_ENV = eval(child.output)
-
-
-# Check if this platform can unset environment variables in child processes.
-# We set an env variable to a non-empty string, unset it, and invoke
-# a python script in a subprocess to print whether the variable
-# is NO LONGER in os.environ.
-# We use 'eval' to parse the child's output so that an exception
-# is thrown if the input is neither 'True' nor 'False'.
-os.environ['UNSET_VAR'] = 'X'
-del os.environ['UNSET_VAR']
-child = gtest_test_utils.Subprocess(
-    [sys.executable, '-c', 'import os; print(\'UNSET_VAR\' not in os.environ)'])
-CAN_UNSET_ENV = eval(child.output)
-
-
-# Checks if we should test with an empty filter. This doesn't
-# make sense on platforms that cannot pass empty env variables (Win32)
-# and on platforms that cannot unset variables (since we cannot tell
-# the difference between "" and NULL -- Borland and Solaris < 5.10)
-CAN_TEST_EMPTY_FILTER = (CAN_PASS_EMPTY_ENV and CAN_UNSET_ENV)
-
-
-# The environment variable for specifying the test filters.
-FILTER_ENV_VAR = 'GTEST_FILTER'
-
-# The environment variables for test sharding.
-TOTAL_SHARDS_ENV_VAR = 'GTEST_TOTAL_SHARDS'
-SHARD_INDEX_ENV_VAR = 'GTEST_SHARD_INDEX'
-SHARD_STATUS_FILE_ENV_VAR = 'GTEST_SHARD_STATUS_FILE'
-
-# The command line flag for specifying the test filters.
-FILTER_FLAG = 'gtest_filter'
-
-# The command line flag for including disabled tests.
-ALSO_RUN_DISABED_TESTS_FLAG = 'gtest_also_run_disabled_tests'
-
-# Command to run the gtest_filter_unittest_ program.
-COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_filter_unittest_')
-
-# Regex for determining whether parameterized tests are enabled in the binary.
-PARAM_TEST_REGEX = re.compile(r'/ParamTest')
-
-# Regex for parsing test case names from Google Test's output.
-TEST_CASE_REGEX = re.compile(r'^\[\-+\] \d+ tests? from (\w+(/\w+)?)')
-
-# Regex for parsing test names from Google Test's output.
-TEST_REGEX = re.compile(r'^\[\s*RUN\s*\].*\.(\w+(/\w+)?)')
-
-# The command line flag to tell Google Test to output the list of tests it
-# will run.
-LIST_TESTS_FLAG = '--gtest_list_tests'
-
-# Indicates whether Google Test supports death tests.
-SUPPORTS_DEATH_TESTS = 'HasDeathTest' in gtest_test_utils.Subprocess(
-    [COMMAND, LIST_TESTS_FLAG]).output
-
-# Full names of all tests in gtest_filter_unittests_.
-PARAM_TESTS = [
-    'SeqP/ParamTest.TestX/0',
-    'SeqP/ParamTest.TestX/1',
-    'SeqP/ParamTest.TestY/0',
-    'SeqP/ParamTest.TestY/1',
-    'SeqQ/ParamTest.TestX/0',
-    'SeqQ/ParamTest.TestX/1',
-    'SeqQ/ParamTest.TestY/0',
-    'SeqQ/ParamTest.TestY/1',
-    ]
-
-DISABLED_TESTS = [
-    'BarTest.DISABLED_TestFour',
-    'BarTest.DISABLED_TestFive',
-    'BazTest.DISABLED_TestC',
-    'DISABLED_FoobarTest.Test1',
-    'DISABLED_FoobarTest.DISABLED_Test2',
-    'DISABLED_FoobarbazTest.TestA',
-    ]
-
-if SUPPORTS_DEATH_TESTS:
-  DEATH_TESTS = [
-    'HasDeathTest.Test1',
-    'HasDeathTest.Test2',
-    ]
-else:
-  DEATH_TESTS = []
-
-# All the non-disabled tests.
-ACTIVE_TESTS = [
-    'FooTest.Abc',
-    'FooTest.Xyz',
-
-    'BarTest.TestOne',
-    'BarTest.TestTwo',
-    'BarTest.TestThree',
-
-    'BazTest.TestOne',
-    'BazTest.TestA',
-    'BazTest.TestB',
-    ] + DEATH_TESTS + PARAM_TESTS
-
-param_tests_present = None
-
-# Utilities.
-
-environ = os.environ.copy()
-
-
-def SetEnvVar(env_var, value):
-  """Sets the env variable to 'value'; unsets it when 'value' is None."""
-
-  if value is not None:
-    environ[env_var] = value
-  elif env_var in environ:
-    del environ[env_var]
-
-
-def RunAndReturnOutput(args = None):
-  """Runs the test program and returns its output."""
-
-  return gtest_test_utils.Subprocess([COMMAND] + (args or []),
-                                     env=environ).output
-
-
-def RunAndExtractTestList(args = None):
-  """Runs the test program and returns its exit code and a list of tests run."""
-
-  p = gtest_test_utils.Subprocess([COMMAND] + (args or []), env=environ)
-  tests_run = []
-  test_case = ''
-  test = ''
-  for line in p.output.split('\n'):
-    match = TEST_CASE_REGEX.match(line)
-    if match is not None:
-      test_case = match.group(1)
-    else:
-      match = TEST_REGEX.match(line)
-      if match is not None:
-        test = match.group(1)
-        tests_run.append(test_case + '.' + test)
-  return (tests_run, p.exit_code)
-
-
-def InvokeWithModifiedEnv(extra_env, function, *args, **kwargs):
-  """Runs the given function and arguments in a modified environment."""
-  try:
-    original_env = environ.copy()
-    environ.update(extra_env)
-    return function(*args, **kwargs)
-  finally:
-    environ.clear()
-    environ.update(original_env)
-
-
-def RunWithSharding(total_shards, shard_index, command):
-  """Runs a test program shard and returns exit code and a list of tests run."""
-
-  extra_env = {SHARD_INDEX_ENV_VAR: str(shard_index),
-               TOTAL_SHARDS_ENV_VAR: str(total_shards)}
-  return InvokeWithModifiedEnv(extra_env, RunAndExtractTestList, command)
-
-# The unit test.
-
-
-class GTestFilterUnitTest(gtest_test_utils.TestCase):
-  """Tests the env variable or the command line flag to filter tests."""
-
-  # Utilities.
-
-  def AssertSetEqual(self, lhs, rhs):
-    """Asserts that two sets are equal."""
-
-    for elem in lhs:
-      self.assert_(elem in rhs, '%s in %s' % (elem, rhs))
-
-    for elem in rhs:
-      self.assert_(elem in lhs, '%s in %s' % (elem, lhs))
-
-  def AssertPartitionIsValid(self, set_var, list_of_sets):
-    """Asserts that list_of_sets is a valid partition of set_var."""
-
-    full_partition = []
-    for slice_var in list_of_sets:
-      full_partition.extend(slice_var)
-    self.assertEqual(len(set_var), len(full_partition))
-    self.assertEqual(set(set_var), set(full_partition))
-
-  def AdjustForParameterizedTests(self, tests_to_run):
-    """Adjust tests_to_run in case value parameterized tests are disabled."""
-
-    global param_tests_present
-    if not param_tests_present:
-      return list(set(tests_to_run) - set(PARAM_TESTS))
-    else:
-      return tests_to_run
-
-  def RunAndVerify(self, gtest_filter, tests_to_run):
-    """Checks that the binary runs correct set of tests for a given filter."""
-
-    tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
-
-    # First, tests using the environment variable.
-
-    # Windows removes empty variables from the environment when passing it
-    # to a new process.  This means it is impossible to pass an empty filter
-    # into a process using the environment variable.  However, we can still
-    # test the case when the variable is not supplied (i.e., gtest_filter is
-    # None).
-    # pylint: disable-msg=C6403
-    if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
-      SetEnvVar(FILTER_ENV_VAR, gtest_filter)
-      tests_run = RunAndExtractTestList()[0]
-      SetEnvVar(FILTER_ENV_VAR, None)
-      self.AssertSetEqual(tests_run, tests_to_run)
-    # pylint: enable-msg=C6403
-
-    # Next, tests using the command line flag.
-
-    if gtest_filter is None:
-      args = []
-    else:
-      args = ['--%s=%s' % (FILTER_FLAG, gtest_filter)]
-
-    tests_run = RunAndExtractTestList(args)[0]
-    self.AssertSetEqual(tests_run, tests_to_run)
-
-  def RunAndVerifyWithSharding(self, gtest_filter, total_shards, tests_to_run,
-                               args=None, check_exit_0=False):
-    """Checks that binary runs correct tests for the given filter and shard.
-
-    Runs all shards of gtest_filter_unittest_ with the given filter, and
-    verifies that the right set of tests were run. The union of tests run
-    on each shard should be identical to tests_to_run, without duplicates.
-
-    Args:
-      gtest_filter: A filter to apply to the tests.
-      total_shards: A total number of shards to split test run into.
-      tests_to_run: A set of tests expected to run.
-      args   :      Arguments to pass to the to the test binary.
-      check_exit_0: When set to a true value, make sure that all shards
-                    return 0.
-    """
-
-    tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
-
-    # Windows removes empty variables from the environment when passing it
-    # to a new process.  This means it is impossible to pass an empty filter
-    # into a process using the environment variable.  However, we can still
-    # test the case when the variable is not supplied (i.e., gtest_filter is
-    # None).
-    # pylint: disable-msg=C6403
-    if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
-      SetEnvVar(FILTER_ENV_VAR, gtest_filter)
-      partition = []
-      for i in range(0, total_shards):
-        (tests_run, exit_code) = RunWithSharding(total_shards, i, args)
-        if check_exit_0:
-          self.assertEqual(0, exit_code)
-        partition.append(tests_run)
-
-      self.AssertPartitionIsValid(tests_to_run, partition)
-      SetEnvVar(FILTER_ENV_VAR, None)
-    # pylint: enable-msg=C6403
-
-  def RunAndVerifyAllowingDisabled(self, gtest_filter, tests_to_run):
-    """Checks that the binary runs correct set of tests for the given filter.
-
-    Runs gtest_filter_unittest_ with the given filter, and enables
-    disabled tests. Verifies that the right set of tests were run.
-
-    Args:
-      gtest_filter: A filter to apply to the tests.
-      tests_to_run: A set of tests expected to run.
-    """
-
-    tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
-
-    # Construct the command line.
-    args = ['--%s' % ALSO_RUN_DISABED_TESTS_FLAG]
-    if gtest_filter is not None:
-      args.append('--%s=%s' % (FILTER_FLAG, gtest_filter))
-
-    tests_run = RunAndExtractTestList(args)[0]
-    self.AssertSetEqual(tests_run, tests_to_run)
-
-  def setUp(self):
-    """Sets up test case.
-
-    Determines whether value-parameterized tests are enabled in the binary and
-    sets the flags accordingly.
-    """
-
-    global param_tests_present
-    if param_tests_present is None:
-      param_tests_present = PARAM_TEST_REGEX.search(
-          RunAndReturnOutput()) is not None
-
-  def testDefaultBehavior(self):
-    """Tests the behavior of not specifying the filter."""
-
-    self.RunAndVerify(None, ACTIVE_TESTS)
-
-  def testDefaultBehaviorWithShards(self):
-    """Tests the behavior without the filter, with sharding enabled."""
-
-    self.RunAndVerifyWithSharding(None, 1, ACTIVE_TESTS)
-    self.RunAndVerifyWithSharding(None, 2, ACTIVE_TESTS)
-    self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) - 1, ACTIVE_TESTS)
-    self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS), ACTIVE_TESTS)
-    self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) + 1, ACTIVE_TESTS)
-
-  def testEmptyFilter(self):
-    """Tests an empty filter."""
-
-    self.RunAndVerify('', [])
-    self.RunAndVerifyWithSharding('', 1, [])
-    self.RunAndVerifyWithSharding('', 2, [])
-
-  def testBadFilter(self):
-    """Tests a filter that matches nothing."""
-
-    self.RunAndVerify('BadFilter', [])
-    self.RunAndVerifyAllowingDisabled('BadFilter', [])
-
-  def testFullName(self):
-    """Tests filtering by full name."""
-
-    self.RunAndVerify('FooTest.Xyz', ['FooTest.Xyz'])
-    self.RunAndVerifyAllowingDisabled('FooTest.Xyz', ['FooTest.Xyz'])
-    self.RunAndVerifyWithSharding('FooTest.Xyz', 5, ['FooTest.Xyz'])
-
-  def testUniversalFilters(self):
-    """Tests filters that match everything."""
-
-    self.RunAndVerify('*', ACTIVE_TESTS)
-    self.RunAndVerify('*.*', ACTIVE_TESTS)
-    self.RunAndVerifyWithSharding('*.*', len(ACTIVE_TESTS) - 3, ACTIVE_TESTS)
-    self.RunAndVerifyAllowingDisabled('*', ACTIVE_TESTS + DISABLED_TESTS)
-    self.RunAndVerifyAllowingDisabled('*.*', ACTIVE_TESTS + DISABLED_TESTS)
-
-  def testFilterByTestCase(self):
-    """Tests filtering by test case name."""
-
-    self.RunAndVerify('FooTest.*', ['FooTest.Abc', 'FooTest.Xyz'])
-
-    BAZ_TESTS = ['BazTest.TestOne', 'BazTest.TestA', 'BazTest.TestB']
-    self.RunAndVerify('BazTest.*', BAZ_TESTS)
-    self.RunAndVerifyAllowingDisabled('BazTest.*',
-                                      BAZ_TESTS + ['BazTest.DISABLED_TestC'])
-
-  def testFilterByTest(self):
-    """Tests filtering by test name."""
-
-    self.RunAndVerify('*.TestOne', ['BarTest.TestOne', 'BazTest.TestOne'])
-
-  def testFilterDisabledTests(self):
-    """Select only the disabled tests to run."""
-
-    self.RunAndVerify('DISABLED_FoobarTest.Test1', [])
-    self.RunAndVerifyAllowingDisabled('DISABLED_FoobarTest.Test1',
-                                      ['DISABLED_FoobarTest.Test1'])
-
-    self.RunAndVerify('*DISABLED_*', [])
-    self.RunAndVerifyAllowingDisabled('*DISABLED_*', DISABLED_TESTS)
-
-    self.RunAndVerify('*.DISABLED_*', [])
-    self.RunAndVerifyAllowingDisabled('*.DISABLED_*', [
-        'BarTest.DISABLED_TestFour',
-        'BarTest.DISABLED_TestFive',
-        'BazTest.DISABLED_TestC',
-        'DISABLED_FoobarTest.DISABLED_Test2',
-        ])
-
-    self.RunAndVerify('DISABLED_*', [])
-    self.RunAndVerifyAllowingDisabled('DISABLED_*', [
-        'DISABLED_FoobarTest.Test1',
-        'DISABLED_FoobarTest.DISABLED_Test2',
-        'DISABLED_FoobarbazTest.TestA',
-        ])
-
-  def testWildcardInTestCaseName(self):
-    """Tests using wildcard in the test case name."""
-
-    self.RunAndVerify('*a*.*', [
-        'BarTest.TestOne',
-        'BarTest.TestTwo',
-        'BarTest.TestThree',
-
-        'BazTest.TestOne',
-        'BazTest.TestA',
-        'BazTest.TestB', ] + DEATH_TESTS + PARAM_TESTS)
-
-  def testWildcardInTestName(self):
-    """Tests using wildcard in the test name."""
-
-    self.RunAndVerify('*.*A*', ['FooTest.Abc', 'BazTest.TestA'])
-
-  def testFilterWithoutDot(self):
-    """Tests a filter that has no '.' in it."""
-
-    self.RunAndVerify('*z*', [
-        'FooTest.Xyz',
-
-        'BazTest.TestOne',
-        'BazTest.TestA',
-        'BazTest.TestB',
-        ])
-
-  def testTwoPatterns(self):
-    """Tests filters that consist of two patterns."""
-
-    self.RunAndVerify('Foo*.*:*A*', [
-        'FooTest.Abc',
-        'FooTest.Xyz',
-
-        'BazTest.TestA',
-        ])
-
-    # An empty pattern + a non-empty one
-    self.RunAndVerify(':*A*', ['FooTest.Abc', 'BazTest.TestA'])
-
-  def testThreePatterns(self):
-    """Tests filters that consist of three patterns."""
-
-    self.RunAndVerify('*oo*:*A*:*One', [
-        'FooTest.Abc',
-        'FooTest.Xyz',
-
-        'BarTest.TestOne',
-
-        'BazTest.TestOne',
-        'BazTest.TestA',
-        ])
-
-    # The 2nd pattern is empty.
-    self.RunAndVerify('*oo*::*One', [
-        'FooTest.Abc',
-        'FooTest.Xyz',
-
-        'BarTest.TestOne',
-
-        'BazTest.TestOne',
-        ])
-
-    # The last 2 patterns are empty.
-    self.RunAndVerify('*oo*::', [
-        'FooTest.Abc',
-        'FooTest.Xyz',
-        ])
-
-  def testNegativeFilters(self):
-    self.RunAndVerify('*-BazTest.TestOne', [
-        'FooTest.Abc',
-        'FooTest.Xyz',
-
-        'BarTest.TestOne',
-        'BarTest.TestTwo',
-        'BarTest.TestThree',
-
-        'BazTest.TestA',
-        'BazTest.TestB',
-        ] + DEATH_TESTS + PARAM_TESTS)
-
-    self.RunAndVerify('*-FooTest.Abc:BazTest.*', [
-        'FooTest.Xyz',
-
-        'BarTest.TestOne',
-        'BarTest.TestTwo',
-        'BarTest.TestThree',
-        ] + DEATH_TESTS + PARAM_TESTS)
-
-    self.RunAndVerify('BarTest.*-BarTest.TestOne', [
-        'BarTest.TestTwo',
-        'BarTest.TestThree',
-        ])
-
-    # Tests without leading '*'.
-    self.RunAndVerify('-FooTest.Abc:FooTest.Xyz:BazTest.*', [
-        'BarTest.TestOne',
-        'BarTest.TestTwo',
-        'BarTest.TestThree',
-        ] + DEATH_TESTS + PARAM_TESTS)
-
-    # Value parameterized tests.
-    self.RunAndVerify('*/*', PARAM_TESTS)
-
-    # Value parameterized tests filtering by the sequence name.
-    self.RunAndVerify('SeqP/*', [
-        'SeqP/ParamTest.TestX/0',
-        'SeqP/ParamTest.TestX/1',
-        'SeqP/ParamTest.TestY/0',
-        'SeqP/ParamTest.TestY/1',
-        ])
-
-    # Value parameterized tests filtering by the test name.
-    self.RunAndVerify('*/0', [
-        'SeqP/ParamTest.TestX/0',
-        'SeqP/ParamTest.TestY/0',
-        'SeqQ/ParamTest.TestX/0',
-        'SeqQ/ParamTest.TestY/0',
-        ])
-
-  def testFlagOverridesEnvVar(self):
-    """Tests that the filter flag overrides the filtering env. variable."""
-
-    SetEnvVar(FILTER_ENV_VAR, 'Foo*')
-    args = ['--%s=%s' % (FILTER_FLAG, '*One')]
-    tests_run = RunAndExtractTestList(args)[0]
-    SetEnvVar(FILTER_ENV_VAR, None)
-
-    self.AssertSetEqual(tests_run, ['BarTest.TestOne', 'BazTest.TestOne'])
-
-  def testShardStatusFileIsCreated(self):
-    """Tests that the shard file is created if specified in the environment."""
-
-    shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
-                                     'shard_status_file')
-    self.assert_(not os.path.exists(shard_status_file))
-
-    extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
-    try:
-      InvokeWithModifiedEnv(extra_env, RunAndReturnOutput)
-    finally:
-      self.assert_(os.path.exists(shard_status_file))
-      os.remove(shard_status_file)
-
-  def testShardStatusFileIsCreatedWithListTests(self):
-    """Tests that the shard file is created with the "list_tests" flag."""
-
-    shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
-                                     'shard_status_file2')
-    self.assert_(not os.path.exists(shard_status_file))
-
-    extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
-    try:
-      output = InvokeWithModifiedEnv(extra_env,
-                                     RunAndReturnOutput,
-                                     [LIST_TESTS_FLAG])
-    finally:
-      # This assertion ensures that Google Test enumerated the tests as
-      # opposed to running them.
-      self.assert_('[==========]' not in output,
-                   'Unexpected output during test enumeration.\n'
-                   'Please ensure that LIST_TESTS_FLAG is assigned the\n'
-                   'correct flag value for listing Google Test tests.')
-
-      self.assert_(os.path.exists(shard_status_file))
-      os.remove(shard_status_file)
-
-  if SUPPORTS_DEATH_TESTS:
-    def testShardingWorksWithDeathTests(self):
-      """Tests integration with death tests and sharding."""
-
-      gtest_filter = 'HasDeathTest.*:SeqP/*'
-      expected_tests = [
-          'HasDeathTest.Test1',
-          'HasDeathTest.Test2',
-
-          'SeqP/ParamTest.TestX/0',
-          'SeqP/ParamTest.TestX/1',
-          'SeqP/ParamTest.TestY/0',
-          'SeqP/ParamTest.TestY/1',
-          ]
-
-      for flag in ['--gtest_death_test_style=threadsafe',
-                   '--gtest_death_test_style=fast']:
-        self.RunAndVerifyWithSharding(gtest_filter, 3, expected_tests,
-                                      check_exit_0=True, args=[flag])
-        self.RunAndVerifyWithSharding(gtest_filter, 5, expected_tests,
-                                      check_exit_0=True, args=[flag])
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest_.cc
deleted file mode 100644
index 77deffc3..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_filter_unittest_.cc
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Unit test for Google Test test filters.
-//
-// A user can specify which test(s) in a Google Test program to run via
-// either the GTEST_FILTER environment variable or the --gtest_filter
-// flag.  This is used for testing such functionality.
-//
-// The program will be invoked from a Python unit test.  Don't run it
-// directly.
-
-#include "gtest/gtest.h"
-
-namespace {
-
-// Test case FooTest.
-
-class FooTest : public testing::Test {
-};
-
-TEST_F(FooTest, Abc) {
-}
-
-TEST_F(FooTest, Xyz) {
-  FAIL() << "Expected failure.";
-}
-
-// Test case BarTest.
-
-TEST(BarTest, TestOne) {
-}
-
-TEST(BarTest, TestTwo) {
-}
-
-TEST(BarTest, TestThree) {
-}
-
-TEST(BarTest, DISABLED_TestFour) {
-  FAIL() << "Expected failure.";
-}
-
-TEST(BarTest, DISABLED_TestFive) {
-  FAIL() << "Expected failure.";
-}
-
-// Test case BazTest.
-
-TEST(BazTest, TestOne) {
-  FAIL() << "Expected failure.";
-}
-
-TEST(BazTest, TestA) {
-}
-
-TEST(BazTest, TestB) {
-}
-
-TEST(BazTest, DISABLED_TestC) {
-  FAIL() << "Expected failure.";
-}
-
-// Test case HasDeathTest
-
-TEST(HasDeathTest, Test1) {
-  EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*");
-}
-
-// We need at least two death tests to make sure that the all death tests
-// aren't on the first shard.
-TEST(HasDeathTest, Test2) {
-  EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*");
-}
-
-// Test case FoobarTest
-
-TEST(DISABLED_FoobarTest, Test1) {
-  FAIL() << "Expected failure.";
-}
-
-TEST(DISABLED_FoobarTest, DISABLED_Test2) {
-  FAIL() << "Expected failure.";
-}
-
-// Test case FoobarbazTest
-
-TEST(DISABLED_FoobarbazTest, TestA) {
-  FAIL() << "Expected failure.";
-}
-
-#if GTEST_HAS_PARAM_TEST
-class ParamTest : public testing::TestWithParam<int> {
-};
-
-TEST_P(ParamTest, TestX) {
-}
-
-TEST_P(ParamTest, TestY) {
-}
-
-INSTANTIATE_TEST_CASE_P(SeqP, ParamTest, testing::Values(1, 2));
-INSTANTIATE_TEST_CASE_P(SeqQ, ParamTest, testing::Values(5, 6));
-#endif  // GTEST_HAS_PARAM_TEST
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test.py
deleted file mode 100755
index 093c838d..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test.py
+++ /dev/null
@@ -1,172 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2009, 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.
-
-"""Tests the --help flag of Google C++ Testing Framework.
-
-SYNOPSIS
-       gtest_help_test.py --build_dir=BUILD/DIR
-         # where BUILD/DIR contains the built gtest_help_test_ file.
-       gtest_help_test.py
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import re
-import gtest_test_utils
-
-
-IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'
-IS_WINDOWS = os.name == 'nt'
-
-PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_help_test_')
-FLAG_PREFIX = '--gtest_'
-DEATH_TEST_STYLE_FLAG = FLAG_PREFIX + 'death_test_style'
-STREAM_RESULT_TO_FLAG = FLAG_PREFIX + 'stream_result_to'
-UNKNOWN_FLAG = FLAG_PREFIX + 'unknown_flag_for_testing'
-LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'
-INCORRECT_FLAG_VARIANTS = [re.sub('^--', '-', LIST_TESTS_FLAG),
-                           re.sub('^--', '/', LIST_TESTS_FLAG),
-                           re.sub('_', '-', LIST_TESTS_FLAG)]
-INTERNAL_FLAG_FOR_TESTING = FLAG_PREFIX + 'internal_flag_for_testing'
-
-SUPPORTS_DEATH_TESTS = "DeathTest" in gtest_test_utils.Subprocess(
-    [PROGRAM_PATH, LIST_TESTS_FLAG]).output
-
-# The help message must match this regex.
-HELP_REGEX = re.compile(
-    FLAG_PREFIX + r'list_tests.*' +
-    FLAG_PREFIX + r'filter=.*' +
-    FLAG_PREFIX + r'also_run_disabled_tests.*' +
-    FLAG_PREFIX + r'repeat=.*' +
-    FLAG_PREFIX + r'shuffle.*' +
-    FLAG_PREFIX + r'random_seed=.*' +
-    FLAG_PREFIX + r'color=.*' +
-    FLAG_PREFIX + r'print_time.*' +
-    FLAG_PREFIX + r'output=.*' +
-    FLAG_PREFIX + r'break_on_failure.*' +
-    FLAG_PREFIX + r'throw_on_failure.*' +
-    FLAG_PREFIX + r'catch_exceptions=0.*',
-    re.DOTALL)
-
-
-def RunWithFlag(flag):
-  """Runs gtest_help_test_ with the given flag.
-
-  Returns:
-    the exit code and the text output as a tuple.
-  Args:
-    flag: the command-line flag to pass to gtest_help_test_, or None.
-  """
-
-  if flag is None:
-    command = [PROGRAM_PATH]
-  else:
-    command = [PROGRAM_PATH, flag]
-  child = gtest_test_utils.Subprocess(command)
-  return child.exit_code, child.output
-
-
-class GTestHelpTest(gtest_test_utils.TestCase):
-  """Tests the --help flag and its equivalent forms."""
-
-  def TestHelpFlag(self, flag):
-    """Verifies correct behavior when help flag is specified.
-
-    The right message must be printed and the tests must
-    skipped when the given flag is specified.
-
-    Args:
-      flag:  A flag to pass to the binary or None.
-    """
-
-    exit_code, output = RunWithFlag(flag)
-    self.assertEquals(0, exit_code)
-    self.assert_(HELP_REGEX.search(output), output)
-
-    if IS_LINUX:
-      self.assert_(STREAM_RESULT_TO_FLAG in output, output)
-    else:
-      self.assert_(STREAM_RESULT_TO_FLAG not in output, output)
-
-    if SUPPORTS_DEATH_TESTS and not IS_WINDOWS:
-      self.assert_(DEATH_TEST_STYLE_FLAG in output, output)
-    else:
-      self.assert_(DEATH_TEST_STYLE_FLAG not in output, output)
-
-  def TestNonHelpFlag(self, flag):
-    """Verifies correct behavior when no help flag is specified.
-
-    Verifies that when no help flag is specified, the tests are run
-    and the help message is not printed.
-
-    Args:
-      flag:  A flag to pass to the binary or None.
-    """
-
-    exit_code, output = RunWithFlag(flag)
-    self.assert_(exit_code != 0)
-    self.assert_(not HELP_REGEX.search(output), output)
-
-  def testPrintsHelpWithFullFlag(self):
-    self.TestHelpFlag('--help')
-
-  def testPrintsHelpWithShortFlag(self):
-    self.TestHelpFlag('-h')
-
-  def testPrintsHelpWithQuestionFlag(self):
-    self.TestHelpFlag('-?')
-
-  def testPrintsHelpWithWindowsStyleQuestionFlag(self):
-    self.TestHelpFlag('/?')
-
-  def testPrintsHelpWithUnrecognizedGoogleTestFlag(self):
-    self.TestHelpFlag(UNKNOWN_FLAG)
-
-  def testPrintsHelpWithIncorrectFlagStyle(self):
-    for incorrect_flag in INCORRECT_FLAG_VARIANTS:
-      self.TestHelpFlag(incorrect_flag)
-
-  def testRunsTestsWithoutHelpFlag(self):
-    """Verifies that when no help flag is specified, the tests are run
-    and the help message is not printed."""
-
-    self.TestNonHelpFlag(None)
-
-  def testRunsTestsWithGtestInternalFlag(self):
-    """Verifies that the tests are run and no help message is printed when
-    a flag starting with Google Test prefix and 'internal_' is supplied."""
-
-    self.TestNonHelpFlag(INTERNAL_FLAG_FOR_TESTING)
-
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test_.cc
deleted file mode 100644
index 31f78c24..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_help_test_.cc
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2009, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// This program is meant to be run by gtest_help_test.py.  Do not run
-// it directly.
-
-#include "gtest/gtest.h"
-
-// When a help flag is specified, this program should skip the tests
-// and exit with 0; otherwise the following test will be executed,
-// causing this program to exit with a non-zero code.
-TEST(HelpFlagTest, ShouldNotBeRun) {
-  ASSERT_TRUE(false) << "Tests shouldn't be run when --help is specified.";
-}
-
-#if GTEST_HAS_DEATH_TEST
-TEST(DeathTest, UsedByPythonScriptToDetectSupportForDeathTestsInThisBinary) {}
-#endif
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest.py
deleted file mode 100755
index f2d2fd1b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest.py
+++ /dev/null
@@ -1,207 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2006, 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.
-
-"""Unit test for Google Test's --gtest_list_tests flag.
-
-A user can ask Google Test to list all tests by specifying the
---gtest_list_tests flag.  This script tests such functionality
-by invoking gtest_list_tests_unittest_ (a program written with
-Google Test) the command line flags.
-"""
-
-__author__ = 'phanna@google.com (Patrick Hanna)'
-
-import gtest_test_utils
-import re
-
-
-# Constants.
-
-# The command line flag for enabling/disabling listing all tests.
-LIST_TESTS_FLAG = 'gtest_list_tests'
-
-# Path to the gtest_list_tests_unittest_ program.
-EXE_PATH = gtest_test_utils.GetTestExecutablePath('gtest_list_tests_unittest_')
-
-# The expected output when running gtest_list_tests_unittest_ with
-# --gtest_list_tests
-EXPECTED_OUTPUT_NO_FILTER_RE = re.compile(r"""FooDeathTest\.
-  Test1
-Foo\.
-  Bar1
-  Bar2
-  DISABLED_Bar3
-Abc\.
-  Xyz
-  Def
-FooBar\.
-  Baz
-FooTest\.
-  Test1
-  DISABLED_Test2
-  Test3
-TypedTest/0\.  # TypeParam = (VeryLo{245}|class VeryLo{239})\.\.\.
-  TestA
-  TestB
-TypedTest/1\.  # TypeParam = int\s*\*( __ptr64)?
-  TestA
-  TestB
-TypedTest/2\.  # TypeParam = .*MyArray<bool,\s*42>
-  TestA
-  TestB
-My/TypeParamTest/0\.  # TypeParam = (VeryLo{245}|class VeryLo{239})\.\.\.
-  TestA
-  TestB
-My/TypeParamTest/1\.  # TypeParam = int\s*\*( __ptr64)?
-  TestA
-  TestB
-My/TypeParamTest/2\.  # TypeParam = .*MyArray<bool,\s*42>
-  TestA
-  TestB
-MyInstantiation/ValueParamTest\.
-  TestA/0  # GetParam\(\) = one line
-  TestA/1  # GetParam\(\) = two\\nlines
-  TestA/2  # GetParam\(\) = a very\\nlo{241}\.\.\.
-  TestB/0  # GetParam\(\) = one line
-  TestB/1  # GetParam\(\) = two\\nlines
-  TestB/2  # GetParam\(\) = a very\\nlo{241}\.\.\.
-""")
-
-# The expected output when running gtest_list_tests_unittest_ with
-# --gtest_list_tests and --gtest_filter=Foo*.
-EXPECTED_OUTPUT_FILTER_FOO_RE = re.compile(r"""FooDeathTest\.
-  Test1
-Foo\.
-  Bar1
-  Bar2
-  DISABLED_Bar3
-FooBar\.
-  Baz
-FooTest\.
-  Test1
-  DISABLED_Test2
-  Test3
-""")
-
-# Utilities.
-
-
-def Run(args):
-  """Runs gtest_list_tests_unittest_ and returns the list of tests printed."""
-
-  return gtest_test_utils.Subprocess([EXE_PATH] + args,
-                                     capture_stderr=False).output
-
-
-# The unit test.
-
-class GTestListTestsUnitTest(gtest_test_utils.TestCase):
-  """Tests using the --gtest_list_tests flag to list all tests."""
-
-  def RunAndVerify(self, flag_value, expected_output_re, other_flag):
-    """Runs gtest_list_tests_unittest_ and verifies that it prints
-    the correct tests.
-
-    Args:
-      flag_value:         value of the --gtest_list_tests flag;
-                          None if the flag should not be present.
-      expected_output_re: regular expression that matches the expected
-                          output after running command;
-      other_flag:         a different flag to be passed to command
-                          along with gtest_list_tests;
-                          None if the flag should not be present.
-    """
-
-    if flag_value is None:
-      flag = ''
-      flag_expression = 'not set'
-    elif flag_value == '0':
-      flag = '--%s=0' % LIST_TESTS_FLAG
-      flag_expression = '0'
-    else:
-      flag = '--%s' % LIST_TESTS_FLAG
-      flag_expression = '1'
-
-    args = [flag]
-
-    if other_flag is not None:
-      args += [other_flag]
-
-    output = Run(args)
-
-    if expected_output_re:
-      self.assert_(
-          expected_output_re.match(output),
-          ('when %s is %s, the output of "%s" is "%s",\n'
-           'which does not match regex "%s"' %
-           (LIST_TESTS_FLAG, flag_expression, ' '.join(args), output,
-            expected_output_re.pattern)))
-    else:
-      self.assert_(
-          not EXPECTED_OUTPUT_NO_FILTER_RE.match(output),
-          ('when %s is %s, the output of "%s" is "%s"'%
-           (LIST_TESTS_FLAG, flag_expression, ' '.join(args), output)))
-
-  def testDefaultBehavior(self):
-    """Tests the behavior of the default mode."""
-
-    self.RunAndVerify(flag_value=None,
-                      expected_output_re=None,
-                      other_flag=None)
-
-  def testFlag(self):
-    """Tests using the --gtest_list_tests flag."""
-
-    self.RunAndVerify(flag_value='0',
-                      expected_output_re=None,
-                      other_flag=None)
-    self.RunAndVerify(flag_value='1',
-                      expected_output_re=EXPECTED_OUTPUT_NO_FILTER_RE,
-                      other_flag=None)
-
-  def testOverrideNonFilterFlags(self):
-    """Tests that --gtest_list_tests overrides the non-filter flags."""
-
-    self.RunAndVerify(flag_value='1',
-                      expected_output_re=EXPECTED_OUTPUT_NO_FILTER_RE,
-                      other_flag='--gtest_break_on_failure')
-
-  def testWithFilterFlags(self):
-    """Tests that --gtest_list_tests takes into account the
-    --gtest_filter flag."""
-
-    self.RunAndVerify(flag_value='1',
-                      expected_output_re=EXPECTED_OUTPUT_FILTER_FOO_RE,
-                      other_flag='--gtest_filter=Foo*')
-
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest_.cc
deleted file mode 100644
index 907c176b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_list_tests_unittest_.cc
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright 2006, 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.
-//
-// Author: phanna@google.com (Patrick Hanna)
-
-// Unit test for Google Test's --gtest_list_tests flag.
-//
-// A user can ask Google Test to list all tests that will run
-// so that when using a filter, a user will know what
-// tests to look for. The tests will not be run after listing.
-//
-// This program will be invoked from a Python unit test.
-// Don't run it directly.
-
-#include "gtest/gtest.h"
-
-// Several different test cases and tests that will be listed.
-TEST(Foo, Bar1) {
-}
-
-TEST(Foo, Bar2) {
-}
-
-TEST(Foo, DISABLED_Bar3) {
-}
-
-TEST(Abc, Xyz) {
-}
-
-TEST(Abc, Def) {
-}
-
-TEST(FooBar, Baz) {
-}
-
-class FooTest : public testing::Test {
-};
-
-TEST_F(FooTest, Test1) {
-}
-
-TEST_F(FooTest, DISABLED_Test2) {
-}
-
-TEST_F(FooTest, Test3) {
-}
-
-TEST(FooDeathTest, Test1) {
-}
-
-// A group of value-parameterized tests.
-
-class MyType {
- public:
-  explicit MyType(const std::string& a_value) : value_(a_value) {}
-
-  const std::string& value() const { return value_; }
-
- private:
-  std::string value_;
-};
-
-// Teaches Google Test how to print a MyType.
-void PrintTo(const MyType& x, std::ostream* os) {
-  *os << x.value();
-}
-
-class ValueParamTest : public testing::TestWithParam<MyType> {
-};
-
-TEST_P(ValueParamTest, TestA) {
-}
-
-TEST_P(ValueParamTest, TestB) {
-}
-
-INSTANTIATE_TEST_CASE_P(
-    MyInstantiation, ValueParamTest,
-    testing::Values(MyType("one line"),
-                    MyType("two\nlines"),
-                    MyType("a very\nloooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong line")));  // NOLINT
-
-// A group of typed tests.
-
-// A deliberately long type name for testing the line-truncating
-// behavior when printing a type parameter.
-class VeryLoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooogName {  // NOLINT
-};
-
-template <typename T>
-class TypedTest : public testing::Test {
-};
-
-template <typename T, int kSize>
-class MyArray {
-};
-
-typedef testing::Types<VeryLoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooogName,  // NOLINT
-                       int*, MyArray<bool, 42> > MyTypes;
-
-TYPED_TEST_CASE(TypedTest, MyTypes);
-
-TYPED_TEST(TypedTest, TestA) {
-}
-
-TYPED_TEST(TypedTest, TestB) {
-}
-
-// A group of type-parameterized tests.
-
-template <typename T>
-class TypeParamTest : public testing::Test {
-};
-
-TYPED_TEST_CASE_P(TypeParamTest);
-
-TYPED_TEST_P(TypeParamTest, TestA) {
-}
-
-TYPED_TEST_P(TypeParamTest, TestB) {
-}
-
-REGISTER_TYPED_TEST_CASE_P(TypeParamTest, TestA, TestB);
-
-INSTANTIATE_TYPED_TEST_CASE_P(My, TypeParamTest, MyTypes);
-
-int main(int argc, char **argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_main_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_main_unittest.cc
deleted file mode 100644
index ecd9bb87..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_main_unittest.cc
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2006, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "gtest/gtest.h"
-
-// Tests that we don't have to define main() when we link to
-// gtest_main instead of gtest.
-
-namespace {
-
-TEST(GTestMainTest, ShouldSucceed) {
-}
-
-}  // namespace
-
-// We are using the main() function defined in src/gtest_main.cc, so
-// we don't define it here.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_no_test_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_no_test_unittest.cc
deleted file mode 100644
index 292599af..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_no_test_unittest.cc
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2006, 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.
-
-// Tests that a Google Test program that has no test defined can run
-// successfully.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "gtest/gtest.h"
-
-int main(int argc, char **argv) {
-  testing::InitGoogleTest(&argc, argv);
-
-  // An ad-hoc assertion outside of all tests.
-  //
-  // This serves three purposes:
-  //
-  // 1. It verifies that an ad-hoc assertion can be executed even if
-  //    no test is defined.
-  // 2. It verifies that a failed ad-hoc assertion causes the test
-  //    program to fail.
-  // 3. We had a bug where the XML output won't be generated if an
-  //    assertion is executed before RUN_ALL_TESTS() is called, even
-  //    though --gtest_output=xml is specified.  This makes sure the
-  //    bug is fixed and doesn't regress.
-  EXPECT_EQ(1, 2);
-
-  // The above EXPECT_EQ() should cause RUN_ALL_TESTS() to return non-zero.
-  return RUN_ALL_TESTS() ? 0 : 1;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test.py
deleted file mode 100755
index 06dbee09..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test.py
+++ /dev/null
@@ -1,340 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-
-"""Tests the text output of Google C++ Testing Framework.
-
-SYNOPSIS
-       gtest_output_test.py --build_dir=BUILD/DIR --gengolden
-         # where BUILD/DIR contains the built gtest_output_test_ file.
-       gtest_output_test.py --gengolden
-       gtest_output_test.py
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import difflib
-import os
-import re
-import sys
-import gtest_test_utils
-
-
-# The flag for generating the golden file
-GENGOLDEN_FLAG = '--gengolden'
-CATCH_EXCEPTIONS_ENV_VAR_NAME = 'GTEST_CATCH_EXCEPTIONS'
-
-IS_WINDOWS = os.name == 'nt'
-
-# TODO(vladl@google.com): remove the _lin suffix.
-GOLDEN_NAME = 'gtest_output_test_golden_lin.txt'
-
-PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_output_test_')
-
-# At least one command we exercise must not have the
-# 'internal_skip_environment_and_ad_hoc_tests' argument.
-COMMAND_LIST_TESTS = ({}, [PROGRAM_PATH, '--gtest_list_tests'])
-COMMAND_WITH_COLOR = ({}, [PROGRAM_PATH, '--gtest_color=yes'])
-COMMAND_WITH_TIME = ({}, [PROGRAM_PATH,
-                          '--gtest_print_time',
-                          'internal_skip_environment_and_ad_hoc_tests',
-                          '--gtest_filter=FatalFailureTest.*:LoggingTest.*'])
-COMMAND_WITH_DISABLED = (
-    {}, [PROGRAM_PATH,
-         '--gtest_also_run_disabled_tests',
-         'internal_skip_environment_and_ad_hoc_tests',
-         '--gtest_filter=*DISABLED_*'])
-COMMAND_WITH_SHARDING = (
-    {'GTEST_SHARD_INDEX': '1', 'GTEST_TOTAL_SHARDS': '2'},
-    [PROGRAM_PATH,
-     'internal_skip_environment_and_ad_hoc_tests',
-     '--gtest_filter=PassingTest.*'])
-
-GOLDEN_PATH = os.path.join(gtest_test_utils.GetSourceDir(), GOLDEN_NAME)
-
-
-def ToUnixLineEnding(s):
-  """Changes all Windows/Mac line endings in s to UNIX line endings."""
-
-  return s.replace('\r\n', '\n').replace('\r', '\n')
-
-
-def RemoveLocations(test_output):
-  """Removes all file location info from a Google Test program's output.
-
-  Args:
-       test_output:  the output of a Google Test program.
-
-  Returns:
-       output with all file location info (in the form of
-       'DIRECTORY/FILE_NAME:LINE_NUMBER: 'or
-       'DIRECTORY\\FILE_NAME(LINE_NUMBER): ') replaced by
-       'FILE_NAME:#: '.
-  """
-
-  return re.sub(r'.*[/\\](.+)(\:\d+|\(\d+\))\: ', r'\1:#: ', test_output)
-
-
-def RemoveStackTraceDetails(output):
-  """Removes all stack traces from a Google Test program's output."""
-
-  # *? means "find the shortest string that matches".
-  return re.sub(r'Stack trace:(.|\n)*?\n\n',
-                'Stack trace: (omitted)\n\n', output)
-
-
-def RemoveStackTraces(output):
-  """Removes all traces of stack traces from a Google Test program's output."""
-
-  # *? means "find the shortest string that matches".
-  return re.sub(r'Stack trace:(.|\n)*?\n\n', '', output)
-
-
-def RemoveTime(output):
-  """Removes all time information from a Google Test program's output."""
-
-  return re.sub(r'\(\d+ ms', '(? ms', output)
-
-
-def RemoveTypeInfoDetails(test_output):
-  """Removes compiler-specific type info from Google Test program's output.
-
-  Args:
-       test_output:  the output of a Google Test program.
-
-  Returns:
-       output with type information normalized to canonical form.
-  """
-
-  # some compilers output the name of type 'unsigned int' as 'unsigned'
-  return re.sub(r'unsigned int', 'unsigned', test_output)
-
-
-def NormalizeToCurrentPlatform(test_output):
-  """Normalizes platform specific output details for easier comparison."""
-
-  if IS_WINDOWS:
-    # Removes the color information that is not present on Windows.
-    test_output = re.sub('\x1b\\[(0;3\d)?m', '', test_output)
-    # Changes failure message headers into the Windows format.
-    test_output = re.sub(r': Failure\n', r': error: ', test_output)
-    # Changes file(line_number) to file:line_number.
-    test_output = re.sub(r'((\w|\.)+)\((\d+)\):', r'\1:\3:', test_output)
-
-  return test_output
-
-
-def RemoveTestCounts(output):
-  """Removes test counts from a Google Test program's output."""
-
-  output = re.sub(r'\d+ tests?, listed below',
-                  '? tests, listed below', output)
-  output = re.sub(r'\d+ FAILED TESTS',
-                  '? FAILED TESTS', output)
-  output = re.sub(r'\d+ tests? from \d+ test cases?',
-                  '? tests from ? test cases', output)
-  output = re.sub(r'\d+ tests? from ([a-zA-Z_])',
-                  r'? tests from \1', output)
-  return re.sub(r'\d+ tests?\.', '? tests.', output)
-
-
-def RemoveMatchingTests(test_output, pattern):
-  """Removes output of specified tests from a Google Test program's output.
-
-  This function strips not only the beginning and the end of a test but also
-  all output in between.
-
-  Args:
-    test_output:       A string containing the test output.
-    pattern:           A regex string that matches names of test cases or
-                       tests to remove.
-
-  Returns:
-    Contents of test_output with tests whose names match pattern removed.
-  """
-
-  test_output = re.sub(
-      r'.*\[ RUN      \] .*%s(.|\n)*?\[(  FAILED  |       OK )\] .*%s.*\n' % (
-          pattern, pattern),
-      '',
-      test_output)
-  return re.sub(r'.*%s.*\n' % pattern, '', test_output)
-
-
-def NormalizeOutput(output):
-  """Normalizes output (the output of gtest_output_test_.exe)."""
-
-  output = ToUnixLineEnding(output)
-  output = RemoveLocations(output)
-  output = RemoveStackTraceDetails(output)
-  output = RemoveTime(output)
-  return output
-
-
-def GetShellCommandOutput(env_cmd):
-  """Runs a command in a sub-process, and returns its output in a string.
-
-  Args:
-    env_cmd: The shell command. A 2-tuple where element 0 is a dict of extra
-             environment variables to set, and element 1 is a string with
-             the command and any flags.
-
-  Returns:
-    A string with the command's combined standard and diagnostic output.
-  """
-
-  # Spawns cmd in a sub-process, and gets its standard I/O file objects.
-  # Set and save the environment properly.
-  environ = os.environ.copy()
-  environ.update(env_cmd[0])
-  p = gtest_test_utils.Subprocess(env_cmd[1], env=environ)
-
-  return p.output
-
-
-def GetCommandOutput(env_cmd):
-  """Runs a command and returns its output with all file location
-  info stripped off.
-
-  Args:
-    env_cmd:  The shell command. A 2-tuple where element 0 is a dict of extra
-              environment variables to set, and element 1 is a string with
-              the command and any flags.
-  """
-
-  # Disables exception pop-ups on Windows.
-  environ, cmdline = env_cmd
-  environ = dict(environ)  # Ensures we are modifying a copy.
-  environ[CATCH_EXCEPTIONS_ENV_VAR_NAME] = '1'
-  return NormalizeOutput(GetShellCommandOutput((environ, cmdline)))
-
-
-def GetOutputOfAllCommands():
-  """Returns concatenated output from several representative commands."""
-
-  return (GetCommandOutput(COMMAND_WITH_COLOR) +
-          GetCommandOutput(COMMAND_WITH_TIME) +
-          GetCommandOutput(COMMAND_WITH_DISABLED) +
-          GetCommandOutput(COMMAND_WITH_SHARDING))
-
-
-test_list = GetShellCommandOutput(COMMAND_LIST_TESTS)
-SUPPORTS_DEATH_TESTS = 'DeathTest' in test_list
-SUPPORTS_TYPED_TESTS = 'TypedTest' in test_list
-SUPPORTS_THREADS = 'ExpectFailureWithThreadsTest' in test_list
-SUPPORTS_STACK_TRACES = False
-
-CAN_GENERATE_GOLDEN_FILE = (SUPPORTS_DEATH_TESTS and
-                            SUPPORTS_TYPED_TESTS and
-                            SUPPORTS_THREADS and
-                            not IS_WINDOWS)
-
-class GTestOutputTest(gtest_test_utils.TestCase):
-  def RemoveUnsupportedTests(self, test_output):
-    if not SUPPORTS_DEATH_TESTS:
-      test_output = RemoveMatchingTests(test_output, 'DeathTest')
-    if not SUPPORTS_TYPED_TESTS:
-      test_output = RemoveMatchingTests(test_output, 'TypedTest')
-      test_output = RemoveMatchingTests(test_output, 'TypedDeathTest')
-      test_output = RemoveMatchingTests(test_output, 'TypeParamDeathTest')
-    if not SUPPORTS_THREADS:
-      test_output = RemoveMatchingTests(test_output,
-                                        'ExpectFailureWithThreadsTest')
-      test_output = RemoveMatchingTests(test_output,
-                                        'ScopedFakeTestPartResultReporterTest')
-      test_output = RemoveMatchingTests(test_output,
-                                        'WorksConcurrently')
-    if not SUPPORTS_STACK_TRACES:
-      test_output = RemoveStackTraces(test_output)
-
-    return test_output
-
-  def testOutput(self):
-    output = GetOutputOfAllCommands()
-
-    golden_file = open(GOLDEN_PATH, 'r')
-    # A mis-configured source control system can cause \r appear in EOL
-    # sequences when we read the golden file irrespective of an operating
-    # system used. Therefore, we need to strip those \r's from newlines
-    # unconditionally.
-    golden = ToUnixLineEnding(golden_file.read())
-    golden_file.close()
-
-    # We want the test to pass regardless of certain features being
-    # supported or not.
-
-    # We still have to remove type name specifics in all cases.
-    normalized_actual = RemoveTypeInfoDetails(output)
-    normalized_golden = RemoveTypeInfoDetails(golden)
-
-    if CAN_GENERATE_GOLDEN_FILE:
-      self.assertEqual(normalized_golden, normalized_actual,
-                       '\n'.join(difflib.unified_diff(
-                           normalized_golden.split('\n'),
-                           normalized_actual.split('\n'),
-                           'golden', 'actual')))
-    else:
-      normalized_actual = NormalizeToCurrentPlatform(
-          RemoveTestCounts(normalized_actual))
-      normalized_golden = NormalizeToCurrentPlatform(
-          RemoveTestCounts(self.RemoveUnsupportedTests(normalized_golden)))
-
-      # This code is very handy when debugging golden file differences:
-      if os.getenv('DEBUG_GTEST_OUTPUT_TEST'):
-        open(os.path.join(
-            gtest_test_utils.GetSourceDir(),
-            '_gtest_output_test_normalized_actual.txt'), 'wb').write(
-                normalized_actual)
-        open(os.path.join(
-            gtest_test_utils.GetSourceDir(),
-            '_gtest_output_test_normalized_golden.txt'), 'wb').write(
-                normalized_golden)
-
-      self.assertEqual(normalized_golden, normalized_actual)
-
-
-if __name__ == '__main__':
-  if sys.argv[1:] == [GENGOLDEN_FLAG]:
-    if CAN_GENERATE_GOLDEN_FILE:
-      output = GetOutputOfAllCommands()
-      golden_file = open(GOLDEN_PATH, 'wb')
-      golden_file.write(output)
-      golden_file.close()
-    else:
-      message = (
-          """Unable to write a golden file when compiled in an environment
-that does not support all the required features (death tests, typed tests,
-and multiple threads).  Please generate the golden file using a binary built
-with those features enabled.""")
-
-      sys.stderr.write(message)
-      sys.exit(1)
-  else:
-    gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_.cc
deleted file mode 100644
index 1070a9f2..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_.cc
+++ /dev/null
@@ -1,1062 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// The purpose of this file is to generate Google Test output under
-// various conditions.  The output will then be verified by
-// gtest_output_test.py to ensure that Google Test generates the
-// desired messages.  Therefore, most tests in this file are MEANT TO
-// FAIL.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "gtest/gtest-spi.h"
-#include "gtest/gtest.h"
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick is to
-// prevent a user from accidentally including gtest-internal-inl.h in
-// his code.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-#include <stdlib.h>
-
-#if GTEST_IS_THREADSAFE
-using testing::ScopedFakeTestPartResultReporter;
-using testing::TestPartResultArray;
-
-using testing::internal::Notification;
-using testing::internal::ThreadWithParam;
-#endif
-
-namespace posix = ::testing::internal::posix;
-
-// Tests catching fatal failures.
-
-// A subroutine used by the following test.
-void TestEq1(int x) {
-  ASSERT_EQ(1, x);
-}
-
-// This function calls a test subroutine, catches the fatal failure it
-// generates, and then returns early.
-void TryTestSubroutine() {
-  // Calls a subrountine that yields a fatal failure.
-  TestEq1(2);
-
-  // Catches the fatal failure and aborts the test.
-  //
-  // The testing::Test:: prefix is necessary when calling
-  // HasFatalFailure() outside of a TEST, TEST_F, or test fixture.
-  if (testing::Test::HasFatalFailure()) return;
-
-  // If we get here, something is wrong.
-  FAIL() << "This should never be reached.";
-}
-
-TEST(PassingTest, PassingTest1) {
-}
-
-TEST(PassingTest, PassingTest2) {
-}
-
-// Tests that parameters of failing parameterized tests are printed in the
-// failing test summary.
-class FailingParamTest : public testing::TestWithParam<int> {};
-
-TEST_P(FailingParamTest, Fails) {
-  EXPECT_EQ(1, GetParam());
-}
-
-// This generates a test which will fail. Google Test is expected to print
-// its parameter when it outputs the list of all failed tests.
-INSTANTIATE_TEST_CASE_P(PrintingFailingParams,
-                        FailingParamTest,
-                        testing::Values(2));
-
-static const char kGoldenString[] = "\"Line\0 1\"\nLine 2";
-
-TEST(NonfatalFailureTest, EscapesStringOperands) {
-  std::string actual = "actual \"string\"";
-  EXPECT_EQ(kGoldenString, actual);
-
-  const char* golden = kGoldenString;
-  EXPECT_EQ(golden, actual);
-}
-
-TEST(NonfatalFailureTest, DiffForLongStrings) {
-  std::string golden_str(kGoldenString, sizeof(kGoldenString) - 1);
-  EXPECT_EQ(golden_str, "Line 2");
-}
-
-// Tests catching a fatal failure in a subroutine.
-TEST(FatalFailureTest, FatalFailureInSubroutine) {
-  printf("(expecting a failure that x should be 1)\n");
-
-  TryTestSubroutine();
-}
-
-// Tests catching a fatal failure in a nested subroutine.
-TEST(FatalFailureTest, FatalFailureInNestedSubroutine) {
-  printf("(expecting a failure that x should be 1)\n");
-
-  // Calls a subrountine that yields a fatal failure.
-  TryTestSubroutine();
-
-  // Catches the fatal failure and aborts the test.
-  //
-  // When calling HasFatalFailure() inside a TEST, TEST_F, or test
-  // fixture, the testing::Test:: prefix is not needed.
-  if (HasFatalFailure()) return;
-
-  // If we get here, something is wrong.
-  FAIL() << "This should never be reached.";
-}
-
-// Tests HasFatalFailure() after a failed EXPECT check.
-TEST(FatalFailureTest, NonfatalFailureInSubroutine) {
-  printf("(expecting a failure on false)\n");
-  EXPECT_TRUE(false);  // Generates a nonfatal failure
-  ASSERT_FALSE(HasFatalFailure());  // This should succeed.
-}
-
-// Tests interleaving user logging and Google Test assertions.
-TEST(LoggingTest, InterleavingLoggingAndAssertions) {
-  static const int a[4] = {
-    3, 9, 2, 6
-  };
-
-  printf("(expecting 2 failures on (3) >= (a[i]))\n");
-  for (int i = 0; i < static_cast<int>(sizeof(a)/sizeof(*a)); i++) {
-    printf("i == %d\n", i);
-    EXPECT_GE(3, a[i]);
-  }
-}
-
-// Tests the SCOPED_TRACE macro.
-
-// A helper function for testing SCOPED_TRACE.
-void SubWithoutTrace(int n) {
-  EXPECT_EQ(1, n);
-  ASSERT_EQ(2, n);
-}
-
-// Another helper function for testing SCOPED_TRACE.
-void SubWithTrace(int n) {
-  SCOPED_TRACE(testing::Message() << "n = " << n);
-
-  SubWithoutTrace(n);
-}
-
-// Tests that SCOPED_TRACE() obeys lexical scopes.
-TEST(SCOPED_TRACETest, ObeysScopes) {
-  printf("(expected to fail)\n");
-
-  // There should be no trace before SCOPED_TRACE() is invoked.
-  ADD_FAILURE() << "This failure is expected, and shouldn't have a trace.";
-
-  {
-    SCOPED_TRACE("Expected trace");
-    // After SCOPED_TRACE(), a failure in the current scope should contain
-    // the trace.
-    ADD_FAILURE() << "This failure is expected, and should have a trace.";
-  }
-
-  // Once the control leaves the scope of the SCOPED_TRACE(), there
-  // should be no trace again.
-  ADD_FAILURE() << "This failure is expected, and shouldn't have a trace.";
-}
-
-// Tests that SCOPED_TRACE works inside a loop.
-TEST(SCOPED_TRACETest, WorksInLoop) {
-  printf("(expected to fail)\n");
-
-  for (int i = 1; i <= 2; i++) {
-    SCOPED_TRACE(testing::Message() << "i = " << i);
-
-    SubWithoutTrace(i);
-  }
-}
-
-// Tests that SCOPED_TRACE works in a subroutine.
-TEST(SCOPED_TRACETest, WorksInSubroutine) {
-  printf("(expected to fail)\n");
-
-  SubWithTrace(1);
-  SubWithTrace(2);
-}
-
-// Tests that SCOPED_TRACE can be nested.
-TEST(SCOPED_TRACETest, CanBeNested) {
-  printf("(expected to fail)\n");
-
-  SCOPED_TRACE("");  // A trace without a message.
-
-  SubWithTrace(2);
-}
-
-// Tests that multiple SCOPED_TRACEs can be used in the same scope.
-TEST(SCOPED_TRACETest, CanBeRepeated) {
-  printf("(expected to fail)\n");
-
-  SCOPED_TRACE("A");
-  ADD_FAILURE()
-      << "This failure is expected, and should contain trace point A.";
-
-  SCOPED_TRACE("B");
-  ADD_FAILURE()
-      << "This failure is expected, and should contain trace point A and B.";
-
-  {
-    SCOPED_TRACE("C");
-    ADD_FAILURE() << "This failure is expected, and should "
-                  << "contain trace point A, B, and C.";
-  }
-
-  SCOPED_TRACE("D");
-  ADD_FAILURE() << "This failure is expected, and should "
-                << "contain trace point A, B, and D.";
-}
-
-#if GTEST_IS_THREADSAFE
-// Tests that SCOPED_TRACE()s can be used concurrently from multiple
-// threads.  Namely, an assertion should be affected by
-// SCOPED_TRACE()s in its own thread only.
-
-// Here's the sequence of actions that happen in the test:
-//
-//   Thread A (main)                | Thread B (spawned)
-//   ===============================|================================
-//   spawns thread B                |
-//   -------------------------------+--------------------------------
-//   waits for n1                   | SCOPED_TRACE("Trace B");
-//                                  | generates failure #1
-//                                  | notifies n1
-//   -------------------------------+--------------------------------
-//   SCOPED_TRACE("Trace A");       | waits for n2
-//   generates failure #2           |
-//   notifies n2                    |
-//   -------------------------------|--------------------------------
-//   waits for n3                   | generates failure #3
-//                                  | trace B dies
-//                                  | generates failure #4
-//                                  | notifies n3
-//   -------------------------------|--------------------------------
-//   generates failure #5           | finishes
-//   trace A dies                   |
-//   generates failure #6           |
-//   -------------------------------|--------------------------------
-//   waits for thread B to finish   |
-
-struct CheckPoints {
-  Notification n1;
-  Notification n2;
-  Notification n3;
-};
-
-static void ThreadWithScopedTrace(CheckPoints* check_points) {
-  {
-    SCOPED_TRACE("Trace B");
-    ADD_FAILURE()
-        << "Expected failure #1 (in thread B, only trace B alive).";
-    check_points->n1.Notify();
-    check_points->n2.WaitForNotification();
-
-    ADD_FAILURE()
-        << "Expected failure #3 (in thread B, trace A & B both alive).";
-  }  // Trace B dies here.
-  ADD_FAILURE()
-      << "Expected failure #4 (in thread B, only trace A alive).";
-  check_points->n3.Notify();
-}
-
-TEST(SCOPED_TRACETest, WorksConcurrently) {
-  printf("(expecting 6 failures)\n");
-
-  CheckPoints check_points;
-  ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace,
-                                       &check_points,
-                                       NULL);
-  check_points.n1.WaitForNotification();
-
-  {
-    SCOPED_TRACE("Trace A");
-    ADD_FAILURE()
-        << "Expected failure #2 (in thread A, trace A & B both alive).";
-    check_points.n2.Notify();
-    check_points.n3.WaitForNotification();
-
-    ADD_FAILURE()
-        << "Expected failure #5 (in thread A, only trace A alive).";
-  }  // Trace A dies here.
-  ADD_FAILURE()
-      << "Expected failure #6 (in thread A, no trace alive).";
-  thread.Join();
-}
-#endif  // GTEST_IS_THREADSAFE
-
-TEST(DisabledTestsWarningTest,
-     DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning) {
-  // This test body is intentionally empty.  Its sole purpose is for
-  // verifying that the --gtest_also_run_disabled_tests flag
-  // suppresses the "YOU HAVE 12 DISABLED TESTS" warning at the end of
-  // the test output.
-}
-
-// Tests using assertions outside of TEST and TEST_F.
-//
-// This function creates two failures intentionally.
-void AdHocTest() {
-  printf("The non-test part of the code is expected to have 2 failures.\n\n");
-  EXPECT_TRUE(false);
-  EXPECT_EQ(2, 3);
-}
-
-// Runs all TESTs, all TEST_Fs, and the ad hoc test.
-int RunAllTests() {
-  AdHocTest();
-  return RUN_ALL_TESTS();
-}
-
-// Tests non-fatal failures in the fixture constructor.
-class NonFatalFailureInFixtureConstructorTest : public testing::Test {
- protected:
-  NonFatalFailureInFixtureConstructorTest() {
-    printf("(expecting 5 failures)\n");
-    ADD_FAILURE() << "Expected failure #1, in the test fixture c'tor.";
-  }
-
-  ~NonFatalFailureInFixtureConstructorTest() {
-    ADD_FAILURE() << "Expected failure #5, in the test fixture d'tor.";
-  }
-
-  virtual void SetUp() {
-    ADD_FAILURE() << "Expected failure #2, in SetUp().";
-  }
-
-  virtual void TearDown() {
-    ADD_FAILURE() << "Expected failure #4, in TearDown.";
-  }
-};
-
-TEST_F(NonFatalFailureInFixtureConstructorTest, FailureInConstructor) {
-  ADD_FAILURE() << "Expected failure #3, in the test body.";
-}
-
-// Tests fatal failures in the fixture constructor.
-class FatalFailureInFixtureConstructorTest : public testing::Test {
- protected:
-  FatalFailureInFixtureConstructorTest() {
-    printf("(expecting 2 failures)\n");
-    Init();
-  }
-
-  ~FatalFailureInFixtureConstructorTest() {
-    ADD_FAILURE() << "Expected failure #2, in the test fixture d'tor.";
-  }
-
-  virtual void SetUp() {
-    ADD_FAILURE() << "UNEXPECTED failure in SetUp().  "
-                  << "We should never get here, as the test fixture c'tor "
-                  << "had a fatal failure.";
-  }
-
-  virtual void TearDown() {
-    ADD_FAILURE() << "UNEXPECTED failure in TearDown().  "
-                  << "We should never get here, as the test fixture c'tor "
-                  << "had a fatal failure.";
-  }
-
- private:
-  void Init() {
-    FAIL() << "Expected failure #1, in the test fixture c'tor.";
-  }
-};
-
-TEST_F(FatalFailureInFixtureConstructorTest, FailureInConstructor) {
-  ADD_FAILURE() << "UNEXPECTED failure in the test body.  "
-                << "We should never get here, as the test fixture c'tor "
-                << "had a fatal failure.";
-}
-
-// Tests non-fatal failures in SetUp().
-class NonFatalFailureInSetUpTest : public testing::Test {
- protected:
-  virtual ~NonFatalFailureInSetUpTest() {
-    Deinit();
-  }
-
-  virtual void SetUp() {
-    printf("(expecting 4 failures)\n");
-    ADD_FAILURE() << "Expected failure #1, in SetUp().";
-  }
-
-  virtual void TearDown() {
-    FAIL() << "Expected failure #3, in TearDown().";
-  }
- private:
-  void Deinit() {
-    FAIL() << "Expected failure #4, in the test fixture d'tor.";
-  }
-};
-
-TEST_F(NonFatalFailureInSetUpTest, FailureInSetUp) {
-  FAIL() << "Expected failure #2, in the test function.";
-}
-
-// Tests fatal failures in SetUp().
-class FatalFailureInSetUpTest : public testing::Test {
- protected:
-  virtual ~FatalFailureInSetUpTest() {
-    Deinit();
-  }
-
-  virtual void SetUp() {
-    printf("(expecting 3 failures)\n");
-    FAIL() << "Expected failure #1, in SetUp().";
-  }
-
-  virtual void TearDown() {
-    FAIL() << "Expected failure #2, in TearDown().";
-  }
- private:
-  void Deinit() {
-    FAIL() << "Expected failure #3, in the test fixture d'tor.";
-  }
-};
-
-TEST_F(FatalFailureInSetUpTest, FailureInSetUp) {
-  FAIL() << "UNEXPECTED failure in the test function.  "
-         << "We should never get here, as SetUp() failed.";
-}
-
-TEST(AddFailureAtTest, MessageContainsSpecifiedFileAndLineNumber) {
-  ADD_FAILURE_AT("foo.cc", 42) << "Expected failure in foo.cc";
-}
-
-#if GTEST_IS_THREADSAFE
-
-// A unary function that may die.
-void DieIf(bool should_die) {
-  GTEST_CHECK_(!should_die) << " - death inside DieIf().";
-}
-
-// Tests running death tests in a multi-threaded context.
-
-// Used for coordination between the main and the spawn thread.
-struct SpawnThreadNotifications {
-  SpawnThreadNotifications() {}
-
-  Notification spawn_thread_started;
-  Notification spawn_thread_ok_to_terminate;
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(SpawnThreadNotifications);
-};
-
-// The function to be executed in the thread spawn by the
-// MultipleThreads test (below).
-static void ThreadRoutine(SpawnThreadNotifications* notifications) {
-  // Signals the main thread that this thread has started.
-  notifications->spawn_thread_started.Notify();
-
-  // Waits for permission to finish from the main thread.
-  notifications->spawn_thread_ok_to_terminate.WaitForNotification();
-}
-
-// This is a death-test test, but it's not named with a DeathTest
-// suffix.  It starts threads which might interfere with later
-// death tests, so it must run after all other death tests.
-class DeathTestAndMultiThreadsTest : public testing::Test {
- protected:
-  // Starts a thread and waits for it to begin.
-  virtual void SetUp() {
-    thread_.reset(new ThreadWithParam<SpawnThreadNotifications*>(
-        &ThreadRoutine, &notifications_, NULL));
-    notifications_.spawn_thread_started.WaitForNotification();
-  }
-  // Tells the thread to finish, and reaps it.
-  // Depending on the version of the thread library in use,
-  // a manager thread might still be left running that will interfere
-  // with later death tests.  This is unfortunate, but this class
-  // cleans up after itself as best it can.
-  virtual void TearDown() {
-    notifications_.spawn_thread_ok_to_terminate.Notify();
-  }
-
- private:
-  SpawnThreadNotifications notifications_;
-  testing::internal::scoped_ptr<ThreadWithParam<SpawnThreadNotifications*> >
-      thread_;
-};
-
-#endif  // GTEST_IS_THREADSAFE
-
-// The MixedUpTestCaseTest test case verifies that Google Test will fail a
-// test if it uses a different fixture class than what other tests in
-// the same test case use.  It deliberately contains two fixture
-// classes with the same name but defined in different namespaces.
-
-// The MixedUpTestCaseWithSameTestNameTest test case verifies that
-// when the user defines two tests with the same test case name AND
-// same test name (but in different namespaces), the second test will
-// fail.
-
-namespace foo {
-
-class MixedUpTestCaseTest : public testing::Test {
-};
-
-TEST_F(MixedUpTestCaseTest, FirstTestFromNamespaceFoo) {}
-TEST_F(MixedUpTestCaseTest, SecondTestFromNamespaceFoo) {}
-
-class MixedUpTestCaseWithSameTestNameTest : public testing::Test {
-};
-
-TEST_F(MixedUpTestCaseWithSameTestNameTest,
-       TheSecondTestWithThisNameShouldFail) {}
-
-}  // namespace foo
-
-namespace bar {
-
-class MixedUpTestCaseTest : public testing::Test {
-};
-
-// The following two tests are expected to fail.  We rely on the
-// golden file to check that Google Test generates the right error message.
-TEST_F(MixedUpTestCaseTest, ThisShouldFail) {}
-TEST_F(MixedUpTestCaseTest, ThisShouldFailToo) {}
-
-class MixedUpTestCaseWithSameTestNameTest : public testing::Test {
-};
-
-// Expected to fail.  We rely on the golden file to check that Google Test
-// generates the right error message.
-TEST_F(MixedUpTestCaseWithSameTestNameTest,
-       TheSecondTestWithThisNameShouldFail) {}
-
-}  // namespace bar
-
-// The following two test cases verify that Google Test catches the user
-// error of mixing TEST and TEST_F in the same test case.  The first
-// test case checks the scenario where TEST_F appears before TEST, and
-// the second one checks where TEST appears before TEST_F.
-
-class TEST_F_before_TEST_in_same_test_case : public testing::Test {
-};
-
-TEST_F(TEST_F_before_TEST_in_same_test_case, DefinedUsingTEST_F) {}
-
-// Expected to fail.  We rely on the golden file to check that Google Test
-// generates the right error message.
-TEST(TEST_F_before_TEST_in_same_test_case, DefinedUsingTESTAndShouldFail) {}
-
-class TEST_before_TEST_F_in_same_test_case : public testing::Test {
-};
-
-TEST(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST) {}
-
-// Expected to fail.  We rely on the golden file to check that Google Test
-// generates the right error message.
-TEST_F(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShouldFail) {
-}
-
-// Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE().
-int global_integer = 0;
-
-// Tests that EXPECT_NONFATAL_FAILURE() can reference global variables.
-TEST(ExpectNonfatalFailureTest, CanReferenceGlobalVariables) {
-  global_integer = 0;
-  EXPECT_NONFATAL_FAILURE({
-    EXPECT_EQ(1, global_integer) << "Expected non-fatal failure.";
-  }, "Expected non-fatal failure.");
-}
-
-// Tests that EXPECT_NONFATAL_FAILURE() can reference local variables
-// (static or not).
-TEST(ExpectNonfatalFailureTest, CanReferenceLocalVariables) {
-  int m = 0;
-  static int n;
-  n = 1;
-  EXPECT_NONFATAL_FAILURE({
-    EXPECT_EQ(m, n) << "Expected non-fatal failure.";
-  }, "Expected non-fatal failure.");
-}
-
-// Tests that EXPECT_NONFATAL_FAILURE() succeeds when there is exactly
-// one non-fatal failure and no fatal failure.
-TEST(ExpectNonfatalFailureTest, SucceedsWhenThereIsOneNonfatalFailure) {
-  EXPECT_NONFATAL_FAILURE({
-    ADD_FAILURE() << "Expected non-fatal failure.";
-  }, "Expected non-fatal failure.");
-}
-
-// Tests that EXPECT_NONFATAL_FAILURE() fails when there is no
-// non-fatal failure.
-TEST(ExpectNonfatalFailureTest, FailsWhenThereIsNoNonfatalFailure) {
-  printf("(expecting a failure)\n");
-  EXPECT_NONFATAL_FAILURE({
-  }, "");
-}
-
-// Tests that EXPECT_NONFATAL_FAILURE() fails when there are two
-// non-fatal failures.
-TEST(ExpectNonfatalFailureTest, FailsWhenThereAreTwoNonfatalFailures) {
-  printf("(expecting a failure)\n");
-  EXPECT_NONFATAL_FAILURE({
-    ADD_FAILURE() << "Expected non-fatal failure 1.";
-    ADD_FAILURE() << "Expected non-fatal failure 2.";
-  }, "");
-}
-
-// Tests that EXPECT_NONFATAL_FAILURE() fails when there is one fatal
-// failure.
-TEST(ExpectNonfatalFailureTest, FailsWhenThereIsOneFatalFailure) {
-  printf("(expecting a failure)\n");
-  EXPECT_NONFATAL_FAILURE({
-    FAIL() << "Expected fatal failure.";
-  }, "");
-}
-
-// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
-// tested returns.
-TEST(ExpectNonfatalFailureTest, FailsWhenStatementReturns) {
-  printf("(expecting a failure)\n");
-  EXPECT_NONFATAL_FAILURE({
-    return;
-  }, "");
-}
-
-#if GTEST_HAS_EXCEPTIONS
-
-// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
-// tested throws.
-TEST(ExpectNonfatalFailureTest, FailsWhenStatementThrows) {
-  printf("(expecting a failure)\n");
-  try {
-    EXPECT_NONFATAL_FAILURE({
-      throw 0;
-    }, "");
-  } catch(int) {  // NOLINT
-  }
-}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// Tests that EXPECT_FATAL_FAILURE() can reference global variables.
-TEST(ExpectFatalFailureTest, CanReferenceGlobalVariables) {
-  global_integer = 0;
-  EXPECT_FATAL_FAILURE({
-    ASSERT_EQ(1, global_integer) << "Expected fatal failure.";
-  }, "Expected fatal failure.");
-}
-
-// Tests that EXPECT_FATAL_FAILURE() can reference local static
-// variables.
-TEST(ExpectFatalFailureTest, CanReferenceLocalStaticVariables) {
-  static int n;
-  n = 1;
-  EXPECT_FATAL_FAILURE({
-    ASSERT_EQ(0, n) << "Expected fatal failure.";
-  }, "Expected fatal failure.");
-}
-
-// Tests that EXPECT_FATAL_FAILURE() succeeds when there is exactly
-// one fatal failure and no non-fatal failure.
-TEST(ExpectFatalFailureTest, SucceedsWhenThereIsOneFatalFailure) {
-  EXPECT_FATAL_FAILURE({
-    FAIL() << "Expected fatal failure.";
-  }, "Expected fatal failure.");
-}
-
-// Tests that EXPECT_FATAL_FAILURE() fails when there is no fatal
-// failure.
-TEST(ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure) {
-  printf("(expecting a failure)\n");
-  EXPECT_FATAL_FAILURE({
-  }, "");
-}
-
-// A helper for generating a fatal failure.
-void FatalFailure() {
-  FAIL() << "Expected fatal failure.";
-}
-
-// Tests that EXPECT_FATAL_FAILURE() fails when there are two
-// fatal failures.
-TEST(ExpectFatalFailureTest, FailsWhenThereAreTwoFatalFailures) {
-  printf("(expecting a failure)\n");
-  EXPECT_FATAL_FAILURE({
-    FatalFailure();
-    FatalFailure();
-  }, "");
-}
-
-// Tests that EXPECT_FATAL_FAILURE() fails when there is one non-fatal
-// failure.
-TEST(ExpectFatalFailureTest, FailsWhenThereIsOneNonfatalFailure) {
-  printf("(expecting a failure)\n");
-  EXPECT_FATAL_FAILURE({
-    ADD_FAILURE() << "Expected non-fatal failure.";
-  }, "");
-}
-
-// Tests that EXPECT_FATAL_FAILURE() fails when the statement being
-// tested returns.
-TEST(ExpectFatalFailureTest, FailsWhenStatementReturns) {
-  printf("(expecting a failure)\n");
-  EXPECT_FATAL_FAILURE({
-    return;
-  }, "");
-}
-
-#if GTEST_HAS_EXCEPTIONS
-
-// Tests that EXPECT_FATAL_FAILURE() fails when the statement being
-// tested throws.
-TEST(ExpectFatalFailureTest, FailsWhenStatementThrows) {
-  printf("(expecting a failure)\n");
-  try {
-    EXPECT_FATAL_FAILURE({
-      throw 0;
-    }, "");
-  } catch(int) {  // NOLINT
-  }
-}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// This #ifdef block tests the output of value-parameterized tests.
-
-#if GTEST_HAS_PARAM_TEST
-
-std::string ParamNameFunc(const testing::TestParamInfo<std::string>& info) {
-  return info.param;
-}
-
-class ParamTest : public testing::TestWithParam<std::string> {
-};
-
-TEST_P(ParamTest, Success) {
-  EXPECT_EQ("a", GetParam());
-}
-
-TEST_P(ParamTest, Failure) {
-  EXPECT_EQ("b", GetParam()) << "Expected failure";
-}
-
-INSTANTIATE_TEST_CASE_P(PrintingStrings,
-                        ParamTest,
-                        testing::Values(std::string("a")),
-                        ParamNameFunc);
-
-#endif  // GTEST_HAS_PARAM_TEST
-
-// This #ifdef block tests the output of typed tests.
-#if GTEST_HAS_TYPED_TEST
-
-template <typename T>
-class TypedTest : public testing::Test {
-};
-
-TYPED_TEST_CASE(TypedTest, testing::Types<int>);
-
-TYPED_TEST(TypedTest, Success) {
-  EXPECT_EQ(0, TypeParam());
-}
-
-TYPED_TEST(TypedTest, Failure) {
-  EXPECT_EQ(1, TypeParam()) << "Expected failure";
-}
-
-#endif  // GTEST_HAS_TYPED_TEST
-
-// This #ifdef block tests the output of type-parameterized tests.
-#if GTEST_HAS_TYPED_TEST_P
-
-template <typename T>
-class TypedTestP : public testing::Test {
-};
-
-TYPED_TEST_CASE_P(TypedTestP);
-
-TYPED_TEST_P(TypedTestP, Success) {
-  EXPECT_EQ(0U, TypeParam());
-}
-
-TYPED_TEST_P(TypedTestP, Failure) {
-  EXPECT_EQ(1U, TypeParam()) << "Expected failure";
-}
-
-REGISTER_TYPED_TEST_CASE_P(TypedTestP, Success, Failure);
-
-typedef testing::Types<unsigned char, unsigned int> UnsignedTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(Unsigned, TypedTestP, UnsignedTypes);
-
-#endif  // GTEST_HAS_TYPED_TEST_P
-
-#if GTEST_HAS_DEATH_TEST
-
-// We rely on the golden file to verify that tests whose test case
-// name ends with DeathTest are run first.
-
-TEST(ADeathTest, ShouldRunFirst) {
-}
-
-# if GTEST_HAS_TYPED_TEST
-
-// We rely on the golden file to verify that typed tests whose test
-// case name ends with DeathTest are run first.
-
-template <typename T>
-class ATypedDeathTest : public testing::Test {
-};
-
-typedef testing::Types<int, double> NumericTypes;
-TYPED_TEST_CASE(ATypedDeathTest, NumericTypes);
-
-TYPED_TEST(ATypedDeathTest, ShouldRunFirst) {
-}
-
-# endif  // GTEST_HAS_TYPED_TEST
-
-# if GTEST_HAS_TYPED_TEST_P
-
-
-// We rely on the golden file to verify that type-parameterized tests
-// whose test case name ends with DeathTest are run first.
-
-template <typename T>
-class ATypeParamDeathTest : public testing::Test {
-};
-
-TYPED_TEST_CASE_P(ATypeParamDeathTest);
-
-TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) {
-}
-
-REGISTER_TYPED_TEST_CASE_P(ATypeParamDeathTest, ShouldRunFirst);
-
-INSTANTIATE_TYPED_TEST_CASE_P(My, ATypeParamDeathTest, NumericTypes);
-
-# endif  // GTEST_HAS_TYPED_TEST_P
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-// Tests various failure conditions of
-// EXPECT_{,NON}FATAL_FAILURE{,_ON_ALL_THREADS}.
-class ExpectFailureTest : public testing::Test {
- public:  // Must be public and not protected due to a bug in g++ 3.4.2.
-  enum FailureMode {
-    FATAL_FAILURE,
-    NONFATAL_FAILURE
-  };
-  static void AddFailure(FailureMode failure) {
-    if (failure == FATAL_FAILURE) {
-      FAIL() << "Expected fatal failure.";
-    } else {
-      ADD_FAILURE() << "Expected non-fatal failure.";
-    }
-  }
-};
-
-TEST_F(ExpectFailureTest, ExpectFatalFailure) {
-  // Expected fatal failure, but succeeds.
-  printf("(expecting 1 failure)\n");
-  EXPECT_FATAL_FAILURE(SUCCEED(), "Expected fatal failure.");
-  // Expected fatal failure, but got a non-fatal failure.
-  printf("(expecting 1 failure)\n");
-  EXPECT_FATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Expected non-fatal "
-                       "failure.");
-  // Wrong message.
-  printf("(expecting 1 failure)\n");
-  EXPECT_FATAL_FAILURE(AddFailure(FATAL_FAILURE), "Some other fatal failure "
-                       "expected.");
-}
-
-TEST_F(ExpectFailureTest, ExpectNonFatalFailure) {
-  // Expected non-fatal failure, but succeeds.
-  printf("(expecting 1 failure)\n");
-  EXPECT_NONFATAL_FAILURE(SUCCEED(), "Expected non-fatal failure.");
-  // Expected non-fatal failure, but got a fatal failure.
-  printf("(expecting 1 failure)\n");
-  EXPECT_NONFATAL_FAILURE(AddFailure(FATAL_FAILURE), "Expected fatal failure.");
-  // Wrong message.
-  printf("(expecting 1 failure)\n");
-  EXPECT_NONFATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Some other non-fatal "
-                          "failure.");
-}
-
-#if GTEST_IS_THREADSAFE
-
-class ExpectFailureWithThreadsTest : public ExpectFailureTest {
- protected:
-  static void AddFailureInOtherThread(FailureMode failure) {
-    ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL);
-    thread.Join();
-  }
-};
-
-TEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailure) {
-  // We only intercept the current thread.
-  printf("(expecting 2 failures)\n");
-  EXPECT_FATAL_FAILURE(AddFailureInOtherThread(FATAL_FAILURE),
-                       "Expected fatal failure.");
-}
-
-TEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailure) {
-  // We only intercept the current thread.
-  printf("(expecting 2 failures)\n");
-  EXPECT_NONFATAL_FAILURE(AddFailureInOtherThread(NONFATAL_FAILURE),
-                          "Expected non-fatal failure.");
-}
-
-typedef ExpectFailureWithThreadsTest ScopedFakeTestPartResultReporterTest;
-
-// Tests that the ScopedFakeTestPartResultReporter only catches failures from
-// the current thread if it is instantiated with INTERCEPT_ONLY_CURRENT_THREAD.
-TEST_F(ScopedFakeTestPartResultReporterTest, InterceptOnlyCurrentThread) {
-  printf("(expecting 2 failures)\n");
-  TestPartResultArray results;
-  {
-    ScopedFakeTestPartResultReporter reporter(
-        ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD,
-        &results);
-    AddFailureInOtherThread(FATAL_FAILURE);
-    AddFailureInOtherThread(NONFATAL_FAILURE);
-  }
-  // The two failures should not have been intercepted.
-  EXPECT_EQ(0, results.size()) << "This shouldn't fail.";
-}
-
-#endif  // GTEST_IS_THREADSAFE
-
-TEST_F(ExpectFailureTest, ExpectFatalFailureOnAllThreads) {
-  // Expected fatal failure, but succeeds.
-  printf("(expecting 1 failure)\n");
-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected fatal failure.");
-  // Expected fatal failure, but got a non-fatal failure.
-  printf("(expecting 1 failure)\n");
-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE),
-                                      "Expected non-fatal failure.");
-  // Wrong message.
-  printf("(expecting 1 failure)\n");
-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),
-                                      "Some other fatal failure expected.");
-}
-
-TEST_F(ExpectFailureTest, ExpectNonFatalFailureOnAllThreads) {
-  // Expected non-fatal failure, but succeeds.
-  printf("(expecting 1 failure)\n");
-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected non-fatal "
-                                         "failure.");
-  // Expected non-fatal failure, but got a fatal failure.
-  printf("(expecting 1 failure)\n");
-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),
-                                         "Expected fatal failure.");
-  // Wrong message.
-  printf("(expecting 1 failure)\n");
-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE),
-                                         "Some other non-fatal failure.");
-}
-
-
-// Two test environments for testing testing::AddGlobalTestEnvironment().
-
-class FooEnvironment : public testing::Environment {
- public:
-  virtual void SetUp() {
-    printf("%s", "FooEnvironment::SetUp() called.\n");
-  }
-
-  virtual void TearDown() {
-    printf("%s", "FooEnvironment::TearDown() called.\n");
-    FAIL() << "Expected fatal failure.";
-  }
-};
-
-class BarEnvironment : public testing::Environment {
- public:
-  virtual void SetUp() {
-    printf("%s", "BarEnvironment::SetUp() called.\n");
-  }
-
-  virtual void TearDown() {
-    printf("%s", "BarEnvironment::TearDown() called.\n");
-    ADD_FAILURE() << "Expected non-fatal failure.";
-  }
-};
-
-// The main function.
-//
-// The idea is to use Google Test to run all the tests we have defined (some
-// of them are intended to fail), and then compare the test results
-// with the "golden" file.
-int main(int argc, char **argv) {
-  testing::GTEST_FLAG(print_time) = false;
-
-  // We just run the tests, knowing some of them are intended to fail.
-  // We will use a separate Python script to compare the output of
-  // this program with the golden file.
-
-  // It's hard to test InitGoogleTest() directly, as it has many
-  // global side effects.  The following line serves as a sanity test
-  // for it.
-  testing::InitGoogleTest(&argc, argv);
-  bool internal_skip_environment_and_ad_hoc_tests =
-      std::count(argv, argv + argc,
-                 std::string("internal_skip_environment_and_ad_hoc_tests")) > 0;
-
-#if GTEST_HAS_DEATH_TEST
-  if (testing::internal::GTEST_FLAG(internal_run_death_test) != "") {
-    // Skip the usual output capturing if we're running as the child
-    // process of an threadsafe-style death test.
-# if GTEST_OS_WINDOWS
-    posix::FReopen("nul:", "w", stdout);
-# else
-    posix::FReopen("/dev/null", "w", stdout);
-# endif  // GTEST_OS_WINDOWS
-    return RUN_ALL_TESTS();
-  }
-#endif  // GTEST_HAS_DEATH_TEST
-
-  if (internal_skip_environment_and_ad_hoc_tests)
-    return RUN_ALL_TESTS();
-
-  // Registers two global test environments.
-  // The golden file verifies that they are set up in the order they
-  // are registered, and torn down in the reverse order.
-  testing::AddGlobalTestEnvironment(new FooEnvironment);
-  testing::AddGlobalTestEnvironment(new BarEnvironment);
-
-  return RunAllTests();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_golden_lin.txt b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_golden_lin.txt
deleted file mode 100644
index 2223d560..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_output_test_golden_lin.txt
+++ /dev/null
@@ -1,743 +0,0 @@
-The non-test part of the code is expected to have 2 failures.
-
-gtest_output_test_.cc:#: Failure
-Value of: false
-  Actual: false
-Expected: true
-gtest_output_test_.cc:#: Failure
-      Expected: 2
-To be equal to: 3
-[==========] Running 66 tests from 29 test cases.
-[----------] Global test environment set-up.
-FooEnvironment::SetUp() called.
-BarEnvironment::SetUp() called.
-[----------] 1 test from ADeathTest
-[ RUN      ] ADeathTest.ShouldRunFirst
-[       OK ] ADeathTest.ShouldRunFirst
-[----------] 1 test from ATypedDeathTest/0, where TypeParam = int
-[ RUN      ] ATypedDeathTest/0.ShouldRunFirst
-[       OK ] ATypedDeathTest/0.ShouldRunFirst
-[----------] 1 test from ATypedDeathTest/1, where TypeParam = double
-[ RUN      ] ATypedDeathTest/1.ShouldRunFirst
-[       OK ] ATypedDeathTest/1.ShouldRunFirst
-[----------] 1 test from My/ATypeParamDeathTest/0, where TypeParam = int
-[ RUN      ] My/ATypeParamDeathTest/0.ShouldRunFirst
-[       OK ] My/ATypeParamDeathTest/0.ShouldRunFirst
-[----------] 1 test from My/ATypeParamDeathTest/1, where TypeParam = double
-[ RUN      ] My/ATypeParamDeathTest/1.ShouldRunFirst
-[       OK ] My/ATypeParamDeathTest/1.ShouldRunFirst
-[----------] 2 tests from PassingTest
-[ RUN      ] PassingTest.PassingTest1
-[       OK ] PassingTest.PassingTest1
-[ RUN      ] PassingTest.PassingTest2
-[       OK ] PassingTest.PassingTest2
-[----------] 2 tests from NonfatalFailureTest
-[ RUN      ] NonfatalFailureTest.EscapesStringOperands
-gtest_output_test_.cc:#: Failure
-      Expected: kGoldenString
-      Which is: "\"Line"
-To be equal to: actual
-      Which is: "actual \"string\""
-gtest_output_test_.cc:#: Failure
-      Expected: golden
-      Which is: "\"Line"
-To be equal to: actual
-      Which is: "actual \"string\""
-[  FAILED  ] NonfatalFailureTest.EscapesStringOperands
-[ RUN      ] NonfatalFailureTest.DiffForLongStrings
-gtest_output_test_.cc:#: Failure
-      Expected: golden_str
-      Which is: "\"Line\0 1\"\nLine 2"
-To be equal to: "Line 2"
-With diff:
-@@ -1,2 @@
--\"Line\0 1\"
- Line 2
-
-[  FAILED  ] NonfatalFailureTest.DiffForLongStrings
-[----------] 3 tests from FatalFailureTest
-[ RUN      ] FatalFailureTest.FatalFailureInSubroutine
-(expecting a failure that x should be 1)
-gtest_output_test_.cc:#: Failure
-      Expected: 1
-To be equal to: x
-      Which is: 2
-[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine
-[ RUN      ] FatalFailureTest.FatalFailureInNestedSubroutine
-(expecting a failure that x should be 1)
-gtest_output_test_.cc:#: Failure
-      Expected: 1
-To be equal to: x
-      Which is: 2
-[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine
-[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine
-(expecting a failure on false)
-gtest_output_test_.cc:#: Failure
-Value of: false
-  Actual: false
-Expected: true
-[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine
-[----------] 1 test from LoggingTest
-[ RUN      ] LoggingTest.InterleavingLoggingAndAssertions
-(expecting 2 failures on (3) >= (a[i]))
-i == 0
-i == 1
-gtest_output_test_.cc:#: Failure
-Expected: (3) >= (a[i]), actual: 3 vs 9
-i == 2
-i == 3
-gtest_output_test_.cc:#: Failure
-Expected: (3) >= (a[i]), actual: 3 vs 6
-[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions
-[----------] 6 tests from SCOPED_TRACETest
-[ RUN      ] SCOPED_TRACETest.ObeysScopes
-(expected to fail)
-gtest_output_test_.cc:#: Failure
-Failed
-This failure is expected, and shouldn't have a trace.
-gtest_output_test_.cc:#: Failure
-Failed
-This failure is expected, and should have a trace.
-Google Test trace:
-gtest_output_test_.cc:#: Expected trace
-gtest_output_test_.cc:#: Failure
-Failed
-This failure is expected, and shouldn't have a trace.
-[  FAILED  ] SCOPED_TRACETest.ObeysScopes
-[ RUN      ] SCOPED_TRACETest.WorksInLoop
-(expected to fail)
-gtest_output_test_.cc:#: Failure
-      Expected: 2
-To be equal to: n
-      Which is: 1
-Google Test trace:
-gtest_output_test_.cc:#: i = 1
-gtest_output_test_.cc:#: Failure
-      Expected: 1
-To be equal to: n
-      Which is: 2
-Google Test trace:
-gtest_output_test_.cc:#: i = 2
-[  FAILED  ] SCOPED_TRACETest.WorksInLoop
-[ RUN      ] SCOPED_TRACETest.WorksInSubroutine
-(expected to fail)
-gtest_output_test_.cc:#: Failure
-      Expected: 2
-To be equal to: n
-      Which is: 1
-Google Test trace:
-gtest_output_test_.cc:#: n = 1
-gtest_output_test_.cc:#: Failure
-      Expected: 1
-To be equal to: n
-      Which is: 2
-Google Test trace:
-gtest_output_test_.cc:#: n = 2
-[  FAILED  ] SCOPED_TRACETest.WorksInSubroutine
-[ RUN      ] SCOPED_TRACETest.CanBeNested
-(expected to fail)
-gtest_output_test_.cc:#: Failure
-      Expected: 1
-To be equal to: n
-      Which is: 2
-Google Test trace:
-gtest_output_test_.cc:#: n = 2
-gtest_output_test_.cc:#: 
-[  FAILED  ] SCOPED_TRACETest.CanBeNested
-[ RUN      ] SCOPED_TRACETest.CanBeRepeated
-(expected to fail)
-gtest_output_test_.cc:#: Failure
-Failed
-This failure is expected, and should contain trace point A.
-Google Test trace:
-gtest_output_test_.cc:#: A
-gtest_output_test_.cc:#: Failure
-Failed
-This failure is expected, and should contain trace point A and B.
-Google Test trace:
-gtest_output_test_.cc:#: B
-gtest_output_test_.cc:#: A
-gtest_output_test_.cc:#: Failure
-Failed
-This failure is expected, and should contain trace point A, B, and C.
-Google Test trace:
-gtest_output_test_.cc:#: C
-gtest_output_test_.cc:#: B
-gtest_output_test_.cc:#: A
-gtest_output_test_.cc:#: Failure
-Failed
-This failure is expected, and should contain trace point A, B, and D.
-Google Test trace:
-gtest_output_test_.cc:#: D
-gtest_output_test_.cc:#: B
-gtest_output_test_.cc:#: A
-[  FAILED  ] SCOPED_TRACETest.CanBeRepeated
-[ RUN      ] SCOPED_TRACETest.WorksConcurrently
-(expecting 6 failures)
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #1 (in thread B, only trace B alive).
-Google Test trace:
-gtest_output_test_.cc:#: Trace B
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #2 (in thread A, trace A & B both alive).
-Google Test trace:
-gtest_output_test_.cc:#: Trace A
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #3 (in thread B, trace A & B both alive).
-Google Test trace:
-gtest_output_test_.cc:#: Trace B
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #4 (in thread B, only trace A alive).
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #5 (in thread A, only trace A alive).
-Google Test trace:
-gtest_output_test_.cc:#: Trace A
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #6 (in thread A, no trace alive).
-[  FAILED  ] SCOPED_TRACETest.WorksConcurrently
-[----------] 1 test from NonFatalFailureInFixtureConstructorTest
-[ RUN      ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor
-(expecting 5 failures)
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #1, in the test fixture c'tor.
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #2, in SetUp().
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #3, in the test body.
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #4, in TearDown.
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #5, in the test fixture d'tor.
-[  FAILED  ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor
-[----------] 1 test from FatalFailureInFixtureConstructorTest
-[ RUN      ] FatalFailureInFixtureConstructorTest.FailureInConstructor
-(expecting 2 failures)
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #1, in the test fixture c'tor.
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #2, in the test fixture d'tor.
-[  FAILED  ] FatalFailureInFixtureConstructorTest.FailureInConstructor
-[----------] 1 test from NonFatalFailureInSetUpTest
-[ RUN      ] NonFatalFailureInSetUpTest.FailureInSetUp
-(expecting 4 failures)
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #1, in SetUp().
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #2, in the test function.
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #3, in TearDown().
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #4, in the test fixture d'tor.
-[  FAILED  ] NonFatalFailureInSetUpTest.FailureInSetUp
-[----------] 1 test from FatalFailureInSetUpTest
-[ RUN      ] FatalFailureInSetUpTest.FailureInSetUp
-(expecting 3 failures)
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #1, in SetUp().
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #2, in TearDown().
-gtest_output_test_.cc:#: Failure
-Failed
-Expected failure #3, in the test fixture d'tor.
-[  FAILED  ] FatalFailureInSetUpTest.FailureInSetUp
-[----------] 1 test from AddFailureAtTest
-[ RUN      ] AddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
-foo.cc:42: Failure
-Failed
-Expected failure in foo.cc
-[  FAILED  ] AddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
-[----------] 4 tests from MixedUpTestCaseTest
-[ RUN      ] MixedUpTestCaseTest.FirstTestFromNamespaceFoo
-[       OK ] MixedUpTestCaseTest.FirstTestFromNamespaceFoo
-[ RUN      ] MixedUpTestCaseTest.SecondTestFromNamespaceFoo
-[       OK ] MixedUpTestCaseTest.SecondTestFromNamespaceFoo
-[ RUN      ] MixedUpTestCaseTest.ThisShouldFail
-gtest.cc:#: Failure
-Failed
-All tests in the same test case must use the same test fixture
-class.  However, in test case MixedUpTestCaseTest,
-you defined test FirstTestFromNamespaceFoo and test ThisShouldFail
-using two different test fixture classes.  This can happen if
-the two classes are from different namespaces or translation
-units and have the same name.  You should probably rename one
-of the classes to put the tests into different test cases.
-[  FAILED  ] MixedUpTestCaseTest.ThisShouldFail
-[ RUN      ] MixedUpTestCaseTest.ThisShouldFailToo
-gtest.cc:#: Failure
-Failed
-All tests in the same test case must use the same test fixture
-class.  However, in test case MixedUpTestCaseTest,
-you defined test FirstTestFromNamespaceFoo and test ThisShouldFailToo
-using two different test fixture classes.  This can happen if
-the two classes are from different namespaces or translation
-units and have the same name.  You should probably rename one
-of the classes to put the tests into different test cases.
-[  FAILED  ] MixedUpTestCaseTest.ThisShouldFailToo
-[----------] 2 tests from MixedUpTestCaseWithSameTestNameTest
-[ RUN      ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
-[       OK ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
-[ RUN      ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
-gtest.cc:#: Failure
-Failed
-All tests in the same test case must use the same test fixture
-class.  However, in test case MixedUpTestCaseWithSameTestNameTest,
-you defined test TheSecondTestWithThisNameShouldFail and test TheSecondTestWithThisNameShouldFail
-using two different test fixture classes.  This can happen if
-the two classes are from different namespaces or translation
-units and have the same name.  You should probably rename one
-of the classes to put the tests into different test cases.
-[  FAILED  ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
-[----------] 2 tests from TEST_F_before_TEST_in_same_test_case
-[ RUN      ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F
-[       OK ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F
-[ RUN      ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
-gtest.cc:#: Failure
-Failed
-All tests in the same test case must use the same test fixture
-class, so mixing TEST_F and TEST in the same test case is
-illegal.  In test case TEST_F_before_TEST_in_same_test_case,
-test DefinedUsingTEST_F is defined using TEST_F but
-test DefinedUsingTESTAndShouldFail is defined using TEST.  You probably
-want to change the TEST to TEST_F or move it to another test
-case.
-[  FAILED  ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
-[----------] 2 tests from TEST_before_TEST_F_in_same_test_case
-[ RUN      ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST
-[       OK ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST
-[ RUN      ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
-gtest.cc:#: Failure
-Failed
-All tests in the same test case must use the same test fixture
-class, so mixing TEST_F and TEST in the same test case is
-illegal.  In test case TEST_before_TEST_F_in_same_test_case,
-test DefinedUsingTEST_FAndShouldFail is defined using TEST_F but
-test DefinedUsingTEST is defined using TEST.  You probably
-want to change the TEST to TEST_F or move it to another test
-case.
-[  FAILED  ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
-[----------] 8 tests from ExpectNonfatalFailureTest
-[ RUN      ] ExpectNonfatalFailureTest.CanReferenceGlobalVariables
-[       OK ] ExpectNonfatalFailureTest.CanReferenceGlobalVariables
-[ RUN      ] ExpectNonfatalFailureTest.CanReferenceLocalVariables
-[       OK ] ExpectNonfatalFailureTest.CanReferenceLocalVariables
-[ RUN      ] ExpectNonfatalFailureTest.SucceedsWhenThereIsOneNonfatalFailure
-[       OK ] ExpectNonfatalFailureTest.SucceedsWhenThereIsOneNonfatalFailure
-[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
-(expecting a failure)
-gtest.cc:#: Failure
-Expected: 1 non-fatal failure
-  Actual: 0 failures
-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
-[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
-(expecting a failure)
-gtest.cc:#: Failure
-Expected: 1 non-fatal failure
-  Actual: 2 failures
-gtest_output_test_.cc:#: Non-fatal failure:
-Failed
-Expected non-fatal failure 1.
-
-gtest_output_test_.cc:#: Non-fatal failure:
-Failed
-Expected non-fatal failure 2.
-
-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
-[ RUN      ] ExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
-(expecting a failure)
-gtest.cc:#: Failure
-Expected: 1 non-fatal failure
-  Actual:
-gtest_output_test_.cc:#: Fatal failure:
-Failed
-Expected fatal failure.
-
-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
-[ RUN      ] ExpectNonfatalFailureTest.FailsWhenStatementReturns
-(expecting a failure)
-gtest.cc:#: Failure
-Expected: 1 non-fatal failure
-  Actual: 0 failures
-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementReturns
-[ RUN      ] ExpectNonfatalFailureTest.FailsWhenStatementThrows
-(expecting a failure)
-gtest.cc:#: Failure
-Expected: 1 non-fatal failure
-  Actual: 0 failures
-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementThrows
-[----------] 8 tests from ExpectFatalFailureTest
-[ RUN      ] ExpectFatalFailureTest.CanReferenceGlobalVariables
-[       OK ] ExpectFatalFailureTest.CanReferenceGlobalVariables
-[ RUN      ] ExpectFatalFailureTest.CanReferenceLocalStaticVariables
-[       OK ] ExpectFatalFailureTest.CanReferenceLocalStaticVariables
-[ RUN      ] ExpectFatalFailureTest.SucceedsWhenThereIsOneFatalFailure
-[       OK ] ExpectFatalFailureTest.SucceedsWhenThereIsOneFatalFailure
-[ RUN      ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
-(expecting a failure)
-gtest.cc:#: Failure
-Expected: 1 fatal failure
-  Actual: 0 failures
-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
-[ RUN      ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
-(expecting a failure)
-gtest.cc:#: Failure
-Expected: 1 fatal failure
-  Actual: 2 failures
-gtest_output_test_.cc:#: Fatal failure:
-Failed
-Expected fatal failure.
-
-gtest_output_test_.cc:#: Fatal failure:
-Failed
-Expected fatal failure.
-
-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
-[ RUN      ] ExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
-(expecting a failure)
-gtest.cc:#: Failure
-Expected: 1 fatal failure
-  Actual:
-gtest_output_test_.cc:#: Non-fatal failure:
-Failed
-Expected non-fatal failure.
-
-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
-[ RUN      ] ExpectFatalFailureTest.FailsWhenStatementReturns
-(expecting a failure)
-gtest.cc:#: Failure
-Expected: 1 fatal failure
-  Actual: 0 failures
-[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementReturns
-[ RUN      ] ExpectFatalFailureTest.FailsWhenStatementThrows
-(expecting a failure)
-gtest.cc:#: Failure
-Expected: 1 fatal failure
-  Actual: 0 failures
-[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementThrows
-[----------] 2 tests from TypedTest/0, where TypeParam = int
-[ RUN      ] TypedTest/0.Success
-[       OK ] TypedTest/0.Success
-[ RUN      ] TypedTest/0.Failure
-gtest_output_test_.cc:#: Failure
-      Expected: 1
-To be equal to: TypeParam()
-      Which is: 0
-Expected failure
-[  FAILED  ] TypedTest/0.Failure, where TypeParam = int
-[----------] 2 tests from Unsigned/TypedTestP/0, where TypeParam = unsigned char
-[ RUN      ] Unsigned/TypedTestP/0.Success
-[       OK ] Unsigned/TypedTestP/0.Success
-[ RUN      ] Unsigned/TypedTestP/0.Failure
-gtest_output_test_.cc:#: Failure
-      Expected: 1U
-      Which is: 1
-To be equal to: TypeParam()
-      Which is: '\0'
-Expected failure
-[  FAILED  ] Unsigned/TypedTestP/0.Failure, where TypeParam = unsigned char
-[----------] 2 tests from Unsigned/TypedTestP/1, where TypeParam = unsigned int
-[ RUN      ] Unsigned/TypedTestP/1.Success
-[       OK ] Unsigned/TypedTestP/1.Success
-[ RUN      ] Unsigned/TypedTestP/1.Failure
-gtest_output_test_.cc:#: Failure
-      Expected: 1U
-      Which is: 1
-To be equal to: TypeParam()
-      Which is: 0
-Expected failure
-[  FAILED  ] Unsigned/TypedTestP/1.Failure, where TypeParam = unsigned int
-[----------] 4 tests from ExpectFailureTest
-[ RUN      ] ExpectFailureTest.ExpectFatalFailure
-(expecting 1 failure)
-gtest.cc:#: Failure
-Expected: 1 fatal failure
-  Actual:
-gtest_output_test_.cc:#: Success:
-Succeeded
-
-(expecting 1 failure)
-gtest.cc:#: Failure
-Expected: 1 fatal failure
-  Actual:
-gtest_output_test_.cc:#: Non-fatal failure:
-Failed
-Expected non-fatal failure.
-
-(expecting 1 failure)
-gtest.cc:#: Failure
-Expected: 1 fatal failure containing "Some other fatal failure expected."
-  Actual:
-gtest_output_test_.cc:#: Fatal failure:
-Failed
-Expected fatal failure.
-
-[  FAILED  ] ExpectFailureTest.ExpectFatalFailure
-[ RUN      ] ExpectFailureTest.ExpectNonFatalFailure
-(expecting 1 failure)
-gtest.cc:#: Failure
-Expected: 1 non-fatal failure
-  Actual:
-gtest_output_test_.cc:#: Success:
-Succeeded
-
-(expecting 1 failure)
-gtest.cc:#: Failure
-Expected: 1 non-fatal failure
-  Actual:
-gtest_output_test_.cc:#: Fatal failure:
-Failed
-Expected fatal failure.
-
-(expecting 1 failure)
-gtest.cc:#: Failure
-Expected: 1 non-fatal failure containing "Some other non-fatal failure."
-  Actual:
-gtest_output_test_.cc:#: Non-fatal failure:
-Failed
-Expected non-fatal failure.
-
-[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailure
-[ RUN      ] ExpectFailureTest.ExpectFatalFailureOnAllThreads
-(expecting 1 failure)
-gtest.cc:#: Failure
-Expected: 1 fatal failure
-  Actual:
-gtest_output_test_.cc:#: Success:
-Succeeded
-
-(expecting 1 failure)
-gtest.cc:#: Failure
-Expected: 1 fatal failure
-  Actual:
-gtest_output_test_.cc:#: Non-fatal failure:
-Failed
-Expected non-fatal failure.
-
-(expecting 1 failure)
-gtest.cc:#: Failure
-Expected: 1 fatal failure containing "Some other fatal failure expected."
-  Actual:
-gtest_output_test_.cc:#: Fatal failure:
-Failed
-Expected fatal failure.
-
-[  FAILED  ] ExpectFailureTest.ExpectFatalFailureOnAllThreads
-[ RUN      ] ExpectFailureTest.ExpectNonFatalFailureOnAllThreads
-(expecting 1 failure)
-gtest.cc:#: Failure
-Expected: 1 non-fatal failure
-  Actual:
-gtest_output_test_.cc:#: Success:
-Succeeded
-
-(expecting 1 failure)
-gtest.cc:#: Failure
-Expected: 1 non-fatal failure
-  Actual:
-gtest_output_test_.cc:#: Fatal failure:
-Failed
-Expected fatal failure.
-
-(expecting 1 failure)
-gtest.cc:#: Failure
-Expected: 1 non-fatal failure containing "Some other non-fatal failure."
-  Actual:
-gtest_output_test_.cc:#: Non-fatal failure:
-Failed
-Expected non-fatal failure.
-
-[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailureOnAllThreads
-[----------] 2 tests from ExpectFailureWithThreadsTest
-[ RUN      ] ExpectFailureWithThreadsTest.ExpectFatalFailure
-(expecting 2 failures)
-gtest_output_test_.cc:#: Failure
-Failed
-Expected fatal failure.
-gtest.cc:#: Failure
-Expected: 1 fatal failure
-  Actual: 0 failures
-[  FAILED  ] ExpectFailureWithThreadsTest.ExpectFatalFailure
-[ RUN      ] ExpectFailureWithThreadsTest.ExpectNonFatalFailure
-(expecting 2 failures)
-gtest_output_test_.cc:#: Failure
-Failed
-Expected non-fatal failure.
-gtest.cc:#: Failure
-Expected: 1 non-fatal failure
-  Actual: 0 failures
-[  FAILED  ] ExpectFailureWithThreadsTest.ExpectNonFatalFailure
-[----------] 1 test from ScopedFakeTestPartResultReporterTest
-[ RUN      ] ScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
-(expecting 2 failures)
-gtest_output_test_.cc:#: Failure
-Failed
-Expected fatal failure.
-gtest_output_test_.cc:#: Failure
-Failed
-Expected non-fatal failure.
-[  FAILED  ] ScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
-[----------] 1 test from PrintingFailingParams/FailingParamTest
-[ RUN      ] PrintingFailingParams/FailingParamTest.Fails/0
-gtest_output_test_.cc:#: Failure
-      Expected: 1
-To be equal to: GetParam()
-      Which is: 2
-[  FAILED  ] PrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2
-[----------] 2 tests from PrintingStrings/ParamTest
-[ RUN      ] PrintingStrings/ParamTest.Success/a
-[       OK ] PrintingStrings/ParamTest.Success/a
-[ RUN      ] PrintingStrings/ParamTest.Failure/a
-gtest_output_test_.cc:#: Failure
-      Expected: "b"
-To be equal to: GetParam()
-      Which is: "a"
-Expected failure
-[  FAILED  ] PrintingStrings/ParamTest.Failure/a, where GetParam() = "a"
-[----------] Global test environment tear-down
-BarEnvironment::TearDown() called.
-gtest_output_test_.cc:#: Failure
-Failed
-Expected non-fatal failure.
-FooEnvironment::TearDown() called.
-gtest_output_test_.cc:#: Failure
-Failed
-Expected fatal failure.
-[==========] 66 tests from 29 test cases ran.
-[  PASSED  ] 22 tests.
-[  FAILED  ] 44 tests, listed below:
-[  FAILED  ] NonfatalFailureTest.EscapesStringOperands
-[  FAILED  ] NonfatalFailureTest.DiffForLongStrings
-[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine
-[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine
-[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine
-[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions
-[  FAILED  ] SCOPED_TRACETest.ObeysScopes
-[  FAILED  ] SCOPED_TRACETest.WorksInLoop
-[  FAILED  ] SCOPED_TRACETest.WorksInSubroutine
-[  FAILED  ] SCOPED_TRACETest.CanBeNested
-[  FAILED  ] SCOPED_TRACETest.CanBeRepeated
-[  FAILED  ] SCOPED_TRACETest.WorksConcurrently
-[  FAILED  ] NonFatalFailureInFixtureConstructorTest.FailureInConstructor
-[  FAILED  ] FatalFailureInFixtureConstructorTest.FailureInConstructor
-[  FAILED  ] NonFatalFailureInSetUpTest.FailureInSetUp
-[  FAILED  ] FatalFailureInSetUpTest.FailureInSetUp
-[  FAILED  ] AddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
-[  FAILED  ] MixedUpTestCaseTest.ThisShouldFail
-[  FAILED  ] MixedUpTestCaseTest.ThisShouldFailToo
-[  FAILED  ] MixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
-[  FAILED  ] TEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
-[  FAILED  ] TEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementReturns
-[  FAILED  ] ExpectNonfatalFailureTest.FailsWhenStatementThrows
-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
-[  FAILED  ] ExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
-[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementReturns
-[  FAILED  ] ExpectFatalFailureTest.FailsWhenStatementThrows
-[  FAILED  ] TypedTest/0.Failure, where TypeParam = int
-[  FAILED  ] Unsigned/TypedTestP/0.Failure, where TypeParam = unsigned char
-[  FAILED  ] Unsigned/TypedTestP/1.Failure, where TypeParam = unsigned int
-[  FAILED  ] ExpectFailureTest.ExpectFatalFailure
-[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailure
-[  FAILED  ] ExpectFailureTest.ExpectFatalFailureOnAllThreads
-[  FAILED  ] ExpectFailureTest.ExpectNonFatalFailureOnAllThreads
-[  FAILED  ] ExpectFailureWithThreadsTest.ExpectFatalFailure
-[  FAILED  ] ExpectFailureWithThreadsTest.ExpectNonFatalFailure
-[  FAILED  ] ScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
-[  FAILED  ] PrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2
-[  FAILED  ] PrintingStrings/ParamTest.Failure/a, where GetParam() = "a"
-
-44 FAILED TESTS
-  YOU HAVE 1 DISABLED TEST
-
-Note: Google Test filter = FatalFailureTest.*:LoggingTest.*
-[==========] Running 4 tests from 2 test cases.
-[----------] Global test environment set-up.
-[----------] 3 tests from FatalFailureTest
-[ RUN      ] FatalFailureTest.FatalFailureInSubroutine
-(expecting a failure that x should be 1)
-gtest_output_test_.cc:#: Failure
-      Expected: 1
-To be equal to: x
-      Which is: 2
-[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine (? ms)
-[ RUN      ] FatalFailureTest.FatalFailureInNestedSubroutine
-(expecting a failure that x should be 1)
-gtest_output_test_.cc:#: Failure
-      Expected: 1
-To be equal to: x
-      Which is: 2
-[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine (? ms)
-[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine
-(expecting a failure on false)
-gtest_output_test_.cc:#: Failure
-Value of: false
-  Actual: false
-Expected: true
-[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine (? ms)
-[----------] 3 tests from FatalFailureTest (? ms total)
-
-[----------] 1 test from LoggingTest
-[ RUN      ] LoggingTest.InterleavingLoggingAndAssertions
-(expecting 2 failures on (3) >= (a[i]))
-i == 0
-i == 1
-gtest_output_test_.cc:#: Failure
-Expected: (3) >= (a[i]), actual: 3 vs 9
-i == 2
-i == 3
-gtest_output_test_.cc:#: Failure
-Expected: (3) >= (a[i]), actual: 3 vs 6
-[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions (? ms)
-[----------] 1 test from LoggingTest (? ms total)
-
-[----------] Global test environment tear-down
-[==========] 4 tests from 2 test cases ran. (? ms total)
-[  PASSED  ] 0 tests.
-[  FAILED  ] 4 tests, listed below:
-[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine
-[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine
-[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine
-[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions
-
- 4 FAILED TESTS
-Note: Google Test filter = *DISABLED_*
-[==========] Running 1 test from 1 test case.
-[----------] Global test environment set-up.
-[----------] 1 test from DisabledTestsWarningTest
-[ RUN      ] DisabledTestsWarningTest.DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
-[       OK ] DisabledTestsWarningTest.DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
-[----------] Global test environment tear-down
-[==========] 1 test from 1 test case ran.
-[  PASSED  ] 1 test.
-Note: Google Test filter = PassingTest.*
-Note: This is test shard 2 of 2.
-[==========] Running 1 test from 1 test case.
-[----------] Global test environment set-up.
-[----------] 1 test from PassingTest
-[ RUN      ] PassingTest.PassingTest2
-[       OK ] PassingTest.PassingTest2
-[----------] Global test environment tear-down
-[==========] 1 test from 1 test case ran.
-[  PASSED  ] 1 test.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_pred_impl_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_pred_impl_unittest.cc
deleted file mode 100644
index a84eff86..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_pred_impl_unittest.cc
+++ /dev/null
@@ -1,2427 +0,0 @@
-// Copyright 2006, 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.
-
-// This file is AUTOMATICALLY GENERATED on 10/31/2011 by command
-// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
-
-// Regression test for gtest_pred_impl.h
-//
-// This file is generated by a script and quite long.  If you intend to
-// learn how Google Test works by reading its unit tests, read
-// gtest_unittest.cc instead.
-//
-// This is intended as a regression test for the Google Test predicate
-// assertions.  We compile it as part of the gtest_unittest target
-// only to keep the implementation tidy and compact, as it is quite
-// involved to set up the stage for testing Google Test using Google
-// Test itself.
-//
-// Currently, gtest_unittest takes ~11 seconds to run in the testing
-// daemon.  In the future, if it grows too large and needs much more
-// time to finish, we should consider separating this file into a
-// stand-alone regression test.
-
-#include <iostream>
-
-#include "gtest/gtest.h"
-#include "gtest/gtest-spi.h"
-
-// A user-defined data type.
-struct Bool {
-  explicit Bool(int val) : value(val != 0) {}
-
-  bool operator>(int n) const { return value > Bool(n).value; }
-
-  Bool operator+(const Bool& rhs) const { return Bool(value + rhs.value); }
-
-  bool operator==(const Bool& rhs) const { return value == rhs.value; }
-
-  bool value;
-};
-
-// Enables Bool to be used in assertions.
-std::ostream& operator<<(std::ostream& os, const Bool& x) {
-  return os << (x.value ? "true" : "false");
-}
-
-// Sample functions/functors for testing unary predicate assertions.
-
-// A unary predicate function.
-template <typename T1>
-bool PredFunction1(T1 v1) {
-  return v1 > 0;
-}
-
-// The following two functions are needed to circumvent a bug in
-// gcc 2.95.3, which sometimes has problem with the above template
-// function.
-bool PredFunction1Int(int v1) {
-  return v1 > 0;
-}
-bool PredFunction1Bool(Bool v1) {
-  return v1 > 0;
-}
-
-// A unary predicate functor.
-struct PredFunctor1 {
-  template <typename T1>
-  bool operator()(const T1& v1) {
-    return v1 > 0;
-  }
-};
-
-// A unary predicate-formatter function.
-template <typename T1>
-testing::AssertionResult PredFormatFunction1(const char* e1,
-                                             const T1& v1) {
-  if (PredFunction1(v1))
-    return testing::AssertionSuccess();
-
-  return testing::AssertionFailure()
-      << e1
-      << " is expected to be positive, but evaluates to "
-      << v1 << ".";
-}
-
-// A unary predicate-formatter functor.
-struct PredFormatFunctor1 {
-  template <typename T1>
-  testing::AssertionResult operator()(const char* e1,
-                                      const T1& v1) const {
-    return PredFormatFunction1(e1, v1);
-  }
-};
-
-// Tests for {EXPECT|ASSERT}_PRED_FORMAT1.
-
-class Predicate1Test : public testing::Test {
- protected:
-  virtual void SetUp() {
-    expected_to_finish_ = true;
-    finished_ = false;
-    n1_ = 0;
-  }
-
-  virtual void TearDown() {
-    // Verifies that each of the predicate's arguments was evaluated
-    // exactly once.
-    EXPECT_EQ(1, n1_) <<
-        "The predicate assertion didn't evaluate argument 2 "
-        "exactly once.";
-
-    // Verifies that the control flow in the test function is expected.
-    if (expected_to_finish_ && !finished_) {
-      FAIL() << "The predicate assertion unexpactedly aborted the test.";
-    } else if (!expected_to_finish_ && finished_) {
-      FAIL() << "The failed predicate assertion didn't abort the test "
-                "as expected.";
-    }
-  }
-
-  // true iff the test function is expected to run to finish.
-  static bool expected_to_finish_;
-
-  // true iff the test function did run to finish.
-  static bool finished_;
-
-  static int n1_;
-};
-
-bool Predicate1Test::expected_to_finish_;
-bool Predicate1Test::finished_;
-int Predicate1Test::n1_;
-
-typedef Predicate1Test EXPECT_PRED_FORMAT1Test;
-typedef Predicate1Test ASSERT_PRED_FORMAT1Test;
-typedef Predicate1Test EXPECT_PRED1Test;
-typedef Predicate1Test ASSERT_PRED1Test;
-
-// Tests a successful EXPECT_PRED1 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED1(PredFunction1Int,
-               ++n1_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED1 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED1(PredFunction1Bool,
-               Bool(++n1_));
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED1 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED1(PredFunctor1(),
-               ++n1_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED1 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED1(PredFunctor1(),
-               Bool(++n1_));
-  finished_ = true;
-}
-
-// Tests a failed EXPECT_PRED1 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED1(PredFunction1Int,
-                 n1_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED1 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED1(PredFunction1Bool,
-                 Bool(n1_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED1 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED1(PredFunctor1(),
-                 n1_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED1 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED1(PredFunctor1(),
-                 Bool(n1_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful ASSERT_PRED1 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED1(PredFunction1Int,
-               ++n1_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED1 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED1(PredFunction1Bool,
-               Bool(++n1_));
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED1 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED1(PredFunctor1(),
-               ++n1_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED1 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED1(PredFunctor1(),
-               Bool(++n1_));
-  finished_ = true;
-}
-
-// Tests a failed ASSERT_PRED1 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED1(PredFunction1Int,
-                 n1_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED1 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED1(PredFunction1Bool,
-                 Bool(n1_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED1 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED1(PredFunctor1(),
-                 n1_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED1 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED1(PredFunctor1(),
-                 Bool(n1_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful EXPECT_PRED_FORMAT1 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT1(PredFormatFunction1,
-                      ++n1_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT1 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT1(PredFormatFunction1,
-                      Bool(++n1_));
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT1 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
-                      ++n1_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT1 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
-                      Bool(++n1_));
-  finished_ = true;
-}
-
-// Tests a failed EXPECT_PRED_FORMAT1 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT1(PredFormatFunction1,
-                        n1_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT1 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT1(PredFormatFunction1,
-                        Bool(n1_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT1 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
-                        n1_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT1 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
-                        Bool(n1_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful ASSERT_PRED_FORMAT1 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT1(PredFormatFunction1,
-                      ++n1_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT1 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT1(PredFormatFunction1,
-                      Bool(++n1_));
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT1 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
-                      ++n1_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT1 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
-                      Bool(++n1_));
-  finished_ = true;
-}
-
-// Tests a failed ASSERT_PRED_FORMAT1 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT1(PredFormatFunction1,
-                        n1_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT1 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT1(PredFormatFunction1,
-                        Bool(n1_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT1 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
-                        n1_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT1 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
-                        Bool(n1_++));
-    finished_ = true;
-  }, "");
-}
-// Sample functions/functors for testing binary predicate assertions.
-
-// A binary predicate function.
-template <typename T1, typename T2>
-bool PredFunction2(T1 v1, T2 v2) {
-  return v1 + v2 > 0;
-}
-
-// The following two functions are needed to circumvent a bug in
-// gcc 2.95.3, which sometimes has problem with the above template
-// function.
-bool PredFunction2Int(int v1, int v2) {
-  return v1 + v2 > 0;
-}
-bool PredFunction2Bool(Bool v1, Bool v2) {
-  return v1 + v2 > 0;
-}
-
-// A binary predicate functor.
-struct PredFunctor2 {
-  template <typename T1, typename T2>
-  bool operator()(const T1& v1,
-                  const T2& v2) {
-    return v1 + v2 > 0;
-  }
-};
-
-// A binary predicate-formatter function.
-template <typename T1, typename T2>
-testing::AssertionResult PredFormatFunction2(const char* e1,
-                                             const char* e2,
-                                             const T1& v1,
-                                             const T2& v2) {
-  if (PredFunction2(v1, v2))
-    return testing::AssertionSuccess();
-
-  return testing::AssertionFailure()
-      << e1 << " + " << e2
-      << " is expected to be positive, but evaluates to "
-      << v1 + v2 << ".";
-}
-
-// A binary predicate-formatter functor.
-struct PredFormatFunctor2 {
-  template <typename T1, typename T2>
-  testing::AssertionResult operator()(const char* e1,
-                                      const char* e2,
-                                      const T1& v1,
-                                      const T2& v2) const {
-    return PredFormatFunction2(e1, e2, v1, v2);
-  }
-};
-
-// Tests for {EXPECT|ASSERT}_PRED_FORMAT2.
-
-class Predicate2Test : public testing::Test {
- protected:
-  virtual void SetUp() {
-    expected_to_finish_ = true;
-    finished_ = false;
-    n1_ = n2_ = 0;
-  }
-
-  virtual void TearDown() {
-    // Verifies that each of the predicate's arguments was evaluated
-    // exactly once.
-    EXPECT_EQ(1, n1_) <<
-        "The predicate assertion didn't evaluate argument 2 "
-        "exactly once.";
-    EXPECT_EQ(1, n2_) <<
-        "The predicate assertion didn't evaluate argument 3 "
-        "exactly once.";
-
-    // Verifies that the control flow in the test function is expected.
-    if (expected_to_finish_ && !finished_) {
-      FAIL() << "The predicate assertion unexpactedly aborted the test.";
-    } else if (!expected_to_finish_ && finished_) {
-      FAIL() << "The failed predicate assertion didn't abort the test "
-                "as expected.";
-    }
-  }
-
-  // true iff the test function is expected to run to finish.
-  static bool expected_to_finish_;
-
-  // true iff the test function did run to finish.
-  static bool finished_;
-
-  static int n1_;
-  static int n2_;
-};
-
-bool Predicate2Test::expected_to_finish_;
-bool Predicate2Test::finished_;
-int Predicate2Test::n1_;
-int Predicate2Test::n2_;
-
-typedef Predicate2Test EXPECT_PRED_FORMAT2Test;
-typedef Predicate2Test ASSERT_PRED_FORMAT2Test;
-typedef Predicate2Test EXPECT_PRED2Test;
-typedef Predicate2Test ASSERT_PRED2Test;
-
-// Tests a successful EXPECT_PRED2 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED2(PredFunction2Int,
-               ++n1_,
-               ++n2_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED2 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED2(PredFunction2Bool,
-               Bool(++n1_),
-               Bool(++n2_));
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED2 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED2(PredFunctor2(),
-               ++n1_,
-               ++n2_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED2 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED2(PredFunctor2(),
-               Bool(++n1_),
-               Bool(++n2_));
-  finished_ = true;
-}
-
-// Tests a failed EXPECT_PRED2 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED2(PredFunction2Int,
-                 n1_++,
-                 n2_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED2 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED2(PredFunction2Bool,
-                 Bool(n1_++),
-                 Bool(n2_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED2 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED2(PredFunctor2(),
-                 n1_++,
-                 n2_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED2 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED2(PredFunctor2(),
-                 Bool(n1_++),
-                 Bool(n2_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful ASSERT_PRED2 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED2(PredFunction2Int,
-               ++n1_,
-               ++n2_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED2 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED2(PredFunction2Bool,
-               Bool(++n1_),
-               Bool(++n2_));
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED2 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED2(PredFunctor2(),
-               ++n1_,
-               ++n2_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED2 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED2(PredFunctor2(),
-               Bool(++n1_),
-               Bool(++n2_));
-  finished_ = true;
-}
-
-// Tests a failed ASSERT_PRED2 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED2(PredFunction2Int,
-                 n1_++,
-                 n2_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED2 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED2(PredFunction2Bool,
-                 Bool(n1_++),
-                 Bool(n2_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED2 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED2(PredFunctor2(),
-                 n1_++,
-                 n2_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED2 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED2(PredFunctor2(),
-                 Bool(n1_++),
-                 Bool(n2_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful EXPECT_PRED_FORMAT2 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT2(PredFormatFunction2,
-                      ++n1_,
-                      ++n2_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT2 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT2(PredFormatFunction2,
-                      Bool(++n1_),
-                      Bool(++n2_));
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT2 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
-                      ++n1_,
-                      ++n2_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT2 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
-                      Bool(++n1_),
-                      Bool(++n2_));
-  finished_ = true;
-}
-
-// Tests a failed EXPECT_PRED_FORMAT2 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(PredFormatFunction2,
-                        n1_++,
-                        n2_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT2 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(PredFormatFunction2,
-                        Bool(n1_++),
-                        Bool(n2_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT2 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
-                        n1_++,
-                        n2_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT2 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
-                        Bool(n1_++),
-                        Bool(n2_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful ASSERT_PRED_FORMAT2 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT2(PredFormatFunction2,
-                      ++n1_,
-                      ++n2_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT2 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT2(PredFormatFunction2,
-                      Bool(++n1_),
-                      Bool(++n2_));
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT2 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
-                      ++n1_,
-                      ++n2_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT2 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
-                      Bool(++n1_),
-                      Bool(++n2_));
-  finished_ = true;
-}
-
-// Tests a failed ASSERT_PRED_FORMAT2 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT2(PredFormatFunction2,
-                        n1_++,
-                        n2_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT2 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT2(PredFormatFunction2,
-                        Bool(n1_++),
-                        Bool(n2_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT2 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
-                        n1_++,
-                        n2_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT2 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
-                        Bool(n1_++),
-                        Bool(n2_++));
-    finished_ = true;
-  }, "");
-}
-// Sample functions/functors for testing ternary predicate assertions.
-
-// A ternary predicate function.
-template <typename T1, typename T2, typename T3>
-bool PredFunction3(T1 v1, T2 v2, T3 v3) {
-  return v1 + v2 + v3 > 0;
-}
-
-// The following two functions are needed to circumvent a bug in
-// gcc 2.95.3, which sometimes has problem with the above template
-// function.
-bool PredFunction3Int(int v1, int v2, int v3) {
-  return v1 + v2 + v3 > 0;
-}
-bool PredFunction3Bool(Bool v1, Bool v2, Bool v3) {
-  return v1 + v2 + v3 > 0;
-}
-
-// A ternary predicate functor.
-struct PredFunctor3 {
-  template <typename T1, typename T2, typename T3>
-  bool operator()(const T1& v1,
-                  const T2& v2,
-                  const T3& v3) {
-    return v1 + v2 + v3 > 0;
-  }
-};
-
-// A ternary predicate-formatter function.
-template <typename T1, typename T2, typename T3>
-testing::AssertionResult PredFormatFunction3(const char* e1,
-                                             const char* e2,
-                                             const char* e3,
-                                             const T1& v1,
-                                             const T2& v2,
-                                             const T3& v3) {
-  if (PredFunction3(v1, v2, v3))
-    return testing::AssertionSuccess();
-
-  return testing::AssertionFailure()
-      << e1 << " + " << e2 << " + " << e3
-      << " is expected to be positive, but evaluates to "
-      << v1 + v2 + v3 << ".";
-}
-
-// A ternary predicate-formatter functor.
-struct PredFormatFunctor3 {
-  template <typename T1, typename T2, typename T3>
-  testing::AssertionResult operator()(const char* e1,
-                                      const char* e2,
-                                      const char* e3,
-                                      const T1& v1,
-                                      const T2& v2,
-                                      const T3& v3) const {
-    return PredFormatFunction3(e1, e2, e3, v1, v2, v3);
-  }
-};
-
-// Tests for {EXPECT|ASSERT}_PRED_FORMAT3.
-
-class Predicate3Test : public testing::Test {
- protected:
-  virtual void SetUp() {
-    expected_to_finish_ = true;
-    finished_ = false;
-    n1_ = n2_ = n3_ = 0;
-  }
-
-  virtual void TearDown() {
-    // Verifies that each of the predicate's arguments was evaluated
-    // exactly once.
-    EXPECT_EQ(1, n1_) <<
-        "The predicate assertion didn't evaluate argument 2 "
-        "exactly once.";
-    EXPECT_EQ(1, n2_) <<
-        "The predicate assertion didn't evaluate argument 3 "
-        "exactly once.";
-    EXPECT_EQ(1, n3_) <<
-        "The predicate assertion didn't evaluate argument 4 "
-        "exactly once.";
-
-    // Verifies that the control flow in the test function is expected.
-    if (expected_to_finish_ && !finished_) {
-      FAIL() << "The predicate assertion unexpactedly aborted the test.";
-    } else if (!expected_to_finish_ && finished_) {
-      FAIL() << "The failed predicate assertion didn't abort the test "
-                "as expected.";
-    }
-  }
-
-  // true iff the test function is expected to run to finish.
-  static bool expected_to_finish_;
-
-  // true iff the test function did run to finish.
-  static bool finished_;
-
-  static int n1_;
-  static int n2_;
-  static int n3_;
-};
-
-bool Predicate3Test::expected_to_finish_;
-bool Predicate3Test::finished_;
-int Predicate3Test::n1_;
-int Predicate3Test::n2_;
-int Predicate3Test::n3_;
-
-typedef Predicate3Test EXPECT_PRED_FORMAT3Test;
-typedef Predicate3Test ASSERT_PRED_FORMAT3Test;
-typedef Predicate3Test EXPECT_PRED3Test;
-typedef Predicate3Test ASSERT_PRED3Test;
-
-// Tests a successful EXPECT_PRED3 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED3(PredFunction3Int,
-               ++n1_,
-               ++n2_,
-               ++n3_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED3 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED3(PredFunction3Bool,
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_));
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED3 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED3(PredFunctor3(),
-               ++n1_,
-               ++n2_,
-               ++n3_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED3 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED3(PredFunctor3(),
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_));
-  finished_ = true;
-}
-
-// Tests a failed EXPECT_PRED3 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED3(PredFunction3Int,
-                 n1_++,
-                 n2_++,
-                 n3_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED3 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED3(PredFunction3Bool,
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED3 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED3(PredFunctor3(),
-                 n1_++,
-                 n2_++,
-                 n3_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED3 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED3(PredFunctor3(),
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful ASSERT_PRED3 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED3(PredFunction3Int,
-               ++n1_,
-               ++n2_,
-               ++n3_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED3 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED3(PredFunction3Bool,
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_));
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED3 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED3(PredFunctor3(),
-               ++n1_,
-               ++n2_,
-               ++n3_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED3 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED3(PredFunctor3(),
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_));
-  finished_ = true;
-}
-
-// Tests a failed ASSERT_PRED3 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED3(PredFunction3Int,
-                 n1_++,
-                 n2_++,
-                 n3_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED3 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED3(PredFunction3Bool,
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED3 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED3(PredFunctor3(),
-                 n1_++,
-                 n2_++,
-                 n3_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED3 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED3(PredFunctor3(),
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful EXPECT_PRED_FORMAT3 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT3(PredFormatFunction3,
-                      ++n1_,
-                      ++n2_,
-                      ++n3_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT3 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT3(PredFormatFunction3,
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_));
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT3 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
-                      ++n1_,
-                      ++n2_,
-                      ++n3_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT3 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_));
-  finished_ = true;
-}
-
-// Tests a failed EXPECT_PRED_FORMAT3 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT3(PredFormatFunction3,
-                        n1_++,
-                        n2_++,
-                        n3_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT3 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT3(PredFormatFunction3,
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT3 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
-                        n1_++,
-                        n2_++,
-                        n3_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT3 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful ASSERT_PRED_FORMAT3 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT3(PredFormatFunction3,
-                      ++n1_,
-                      ++n2_,
-                      ++n3_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT3 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT3(PredFormatFunction3,
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_));
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT3 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
-                      ++n1_,
-                      ++n2_,
-                      ++n3_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT3 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_));
-  finished_ = true;
-}
-
-// Tests a failed ASSERT_PRED_FORMAT3 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT3(PredFormatFunction3,
-                        n1_++,
-                        n2_++,
-                        n3_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT3 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT3(PredFormatFunction3,
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT3 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
-                        n1_++,
-                        n2_++,
-                        n3_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT3 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++));
-    finished_ = true;
-  }, "");
-}
-// Sample functions/functors for testing 4-ary predicate assertions.
-
-// A 4-ary predicate function.
-template <typename T1, typename T2, typename T3, typename T4>
-bool PredFunction4(T1 v1, T2 v2, T3 v3, T4 v4) {
-  return v1 + v2 + v3 + v4 > 0;
-}
-
-// The following two functions are needed to circumvent a bug in
-// gcc 2.95.3, which sometimes has problem with the above template
-// function.
-bool PredFunction4Int(int v1, int v2, int v3, int v4) {
-  return v1 + v2 + v3 + v4 > 0;
-}
-bool PredFunction4Bool(Bool v1, Bool v2, Bool v3, Bool v4) {
-  return v1 + v2 + v3 + v4 > 0;
-}
-
-// A 4-ary predicate functor.
-struct PredFunctor4 {
-  template <typename T1, typename T2, typename T3, typename T4>
-  bool operator()(const T1& v1,
-                  const T2& v2,
-                  const T3& v3,
-                  const T4& v4) {
-    return v1 + v2 + v3 + v4 > 0;
-  }
-};
-
-// A 4-ary predicate-formatter function.
-template <typename T1, typename T2, typename T3, typename T4>
-testing::AssertionResult PredFormatFunction4(const char* e1,
-                                             const char* e2,
-                                             const char* e3,
-                                             const char* e4,
-                                             const T1& v1,
-                                             const T2& v2,
-                                             const T3& v3,
-                                             const T4& v4) {
-  if (PredFunction4(v1, v2, v3, v4))
-    return testing::AssertionSuccess();
-
-  return testing::AssertionFailure()
-      << e1 << " + " << e2 << " + " << e3 << " + " << e4
-      << " is expected to be positive, but evaluates to "
-      << v1 + v2 + v3 + v4 << ".";
-}
-
-// A 4-ary predicate-formatter functor.
-struct PredFormatFunctor4 {
-  template <typename T1, typename T2, typename T3, typename T4>
-  testing::AssertionResult operator()(const char* e1,
-                                      const char* e2,
-                                      const char* e3,
-                                      const char* e4,
-                                      const T1& v1,
-                                      const T2& v2,
-                                      const T3& v3,
-                                      const T4& v4) const {
-    return PredFormatFunction4(e1, e2, e3, e4, v1, v2, v3, v4);
-  }
-};
-
-// Tests for {EXPECT|ASSERT}_PRED_FORMAT4.
-
-class Predicate4Test : public testing::Test {
- protected:
-  virtual void SetUp() {
-    expected_to_finish_ = true;
-    finished_ = false;
-    n1_ = n2_ = n3_ = n4_ = 0;
-  }
-
-  virtual void TearDown() {
-    // Verifies that each of the predicate's arguments was evaluated
-    // exactly once.
-    EXPECT_EQ(1, n1_) <<
-        "The predicate assertion didn't evaluate argument 2 "
-        "exactly once.";
-    EXPECT_EQ(1, n2_) <<
-        "The predicate assertion didn't evaluate argument 3 "
-        "exactly once.";
-    EXPECT_EQ(1, n3_) <<
-        "The predicate assertion didn't evaluate argument 4 "
-        "exactly once.";
-    EXPECT_EQ(1, n4_) <<
-        "The predicate assertion didn't evaluate argument 5 "
-        "exactly once.";
-
-    // Verifies that the control flow in the test function is expected.
-    if (expected_to_finish_ && !finished_) {
-      FAIL() << "The predicate assertion unexpactedly aborted the test.";
-    } else if (!expected_to_finish_ && finished_) {
-      FAIL() << "The failed predicate assertion didn't abort the test "
-                "as expected.";
-    }
-  }
-
-  // true iff the test function is expected to run to finish.
-  static bool expected_to_finish_;
-
-  // true iff the test function did run to finish.
-  static bool finished_;
-
-  static int n1_;
-  static int n2_;
-  static int n3_;
-  static int n4_;
-};
-
-bool Predicate4Test::expected_to_finish_;
-bool Predicate4Test::finished_;
-int Predicate4Test::n1_;
-int Predicate4Test::n2_;
-int Predicate4Test::n3_;
-int Predicate4Test::n4_;
-
-typedef Predicate4Test EXPECT_PRED_FORMAT4Test;
-typedef Predicate4Test ASSERT_PRED_FORMAT4Test;
-typedef Predicate4Test EXPECT_PRED4Test;
-typedef Predicate4Test ASSERT_PRED4Test;
-
-// Tests a successful EXPECT_PRED4 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED4(PredFunction4Int,
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED4 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED4(PredFunction4Bool,
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
-               Bool(++n4_));
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED4 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED4(PredFunctor4(),
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED4 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED4(PredFunctor4(),
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
-               Bool(++n4_));
-  finished_ = true;
-}
-
-// Tests a failed EXPECT_PRED4 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED4(PredFunction4Int,
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED4 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED4(PredFunction4Bool,
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED4 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED4(PredFunctor4(),
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED4 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED4(PredFunctor4(),
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful ASSERT_PRED4 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED4(PredFunction4Int,
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED4 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED4(PredFunction4Bool,
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
-               Bool(++n4_));
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED4 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED4(PredFunctor4(),
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED4 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED4(PredFunctor4(),
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
-               Bool(++n4_));
-  finished_ = true;
-}
-
-// Tests a failed ASSERT_PRED4 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED4(PredFunction4Int,
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED4 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED4(PredFunction4Bool,
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED4 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED4(PredFunctor4(),
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED4 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED4(PredFunctor4(),
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful EXPECT_PRED_FORMAT4 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT4(PredFormatFunction4,
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT4 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT4(PredFormatFunction4,
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_));
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT4 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT4 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_));
-  finished_ = true;
-}
-
-// Tests a failed EXPECT_PRED_FORMAT4 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT4(PredFormatFunction4,
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT4 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT4(PredFormatFunction4,
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT4 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT4 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful ASSERT_PRED_FORMAT4 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT4(PredFormatFunction4,
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT4 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT4(PredFormatFunction4,
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_));
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT4 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT4 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_));
-  finished_ = true;
-}
-
-// Tests a failed ASSERT_PRED_FORMAT4 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT4(PredFormatFunction4,
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT4 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT4(PredFormatFunction4,
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT4 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT4 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++));
-    finished_ = true;
-  }, "");
-}
-// Sample functions/functors for testing 5-ary predicate assertions.
-
-// A 5-ary predicate function.
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-bool PredFunction5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
-  return v1 + v2 + v3 + v4 + v5 > 0;
-}
-
-// The following two functions are needed to circumvent a bug in
-// gcc 2.95.3, which sometimes has problem with the above template
-// function.
-bool PredFunction5Int(int v1, int v2, int v3, int v4, int v5) {
-  return v1 + v2 + v3 + v4 + v5 > 0;
-}
-bool PredFunction5Bool(Bool v1, Bool v2, Bool v3, Bool v4, Bool v5) {
-  return v1 + v2 + v3 + v4 + v5 > 0;
-}
-
-// A 5-ary predicate functor.
-struct PredFunctor5 {
-  template <typename T1, typename T2, typename T3, typename T4, typename T5>
-  bool operator()(const T1& v1,
-                  const T2& v2,
-                  const T3& v3,
-                  const T4& v4,
-                  const T5& v5) {
-    return v1 + v2 + v3 + v4 + v5 > 0;
-  }
-};
-
-// A 5-ary predicate-formatter function.
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-testing::AssertionResult PredFormatFunction5(const char* e1,
-                                             const char* e2,
-                                             const char* e3,
-                                             const char* e4,
-                                             const char* e5,
-                                             const T1& v1,
-                                             const T2& v2,
-                                             const T3& v3,
-                                             const T4& v4,
-                                             const T5& v5) {
-  if (PredFunction5(v1, v2, v3, v4, v5))
-    return testing::AssertionSuccess();
-
-  return testing::AssertionFailure()
-      << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
-      << " is expected to be positive, but evaluates to "
-      << v1 + v2 + v3 + v4 + v5 << ".";
-}
-
-// A 5-ary predicate-formatter functor.
-struct PredFormatFunctor5 {
-  template <typename T1, typename T2, typename T3, typename T4, typename T5>
-  testing::AssertionResult operator()(const char* e1,
-                                      const char* e2,
-                                      const char* e3,
-                                      const char* e4,
-                                      const char* e5,
-                                      const T1& v1,
-                                      const T2& v2,
-                                      const T3& v3,
-                                      const T4& v4,
-                                      const T5& v5) const {
-    return PredFormatFunction5(e1, e2, e3, e4, e5, v1, v2, v3, v4, v5);
-  }
-};
-
-// Tests for {EXPECT|ASSERT}_PRED_FORMAT5.
-
-class Predicate5Test : public testing::Test {
- protected:
-  virtual void SetUp() {
-    expected_to_finish_ = true;
-    finished_ = false;
-    n1_ = n2_ = n3_ = n4_ = n5_ = 0;
-  }
-
-  virtual void TearDown() {
-    // Verifies that each of the predicate's arguments was evaluated
-    // exactly once.
-    EXPECT_EQ(1, n1_) <<
-        "The predicate assertion didn't evaluate argument 2 "
-        "exactly once.";
-    EXPECT_EQ(1, n2_) <<
-        "The predicate assertion didn't evaluate argument 3 "
-        "exactly once.";
-    EXPECT_EQ(1, n3_) <<
-        "The predicate assertion didn't evaluate argument 4 "
-        "exactly once.";
-    EXPECT_EQ(1, n4_) <<
-        "The predicate assertion didn't evaluate argument 5 "
-        "exactly once.";
-    EXPECT_EQ(1, n5_) <<
-        "The predicate assertion didn't evaluate argument 6 "
-        "exactly once.";
-
-    // Verifies that the control flow in the test function is expected.
-    if (expected_to_finish_ && !finished_) {
-      FAIL() << "The predicate assertion unexpactedly aborted the test.";
-    } else if (!expected_to_finish_ && finished_) {
-      FAIL() << "The failed predicate assertion didn't abort the test "
-                "as expected.";
-    }
-  }
-
-  // true iff the test function is expected to run to finish.
-  static bool expected_to_finish_;
-
-  // true iff the test function did run to finish.
-  static bool finished_;
-
-  static int n1_;
-  static int n2_;
-  static int n3_;
-  static int n4_;
-  static int n5_;
-};
-
-bool Predicate5Test::expected_to_finish_;
-bool Predicate5Test::finished_;
-int Predicate5Test::n1_;
-int Predicate5Test::n2_;
-int Predicate5Test::n3_;
-int Predicate5Test::n4_;
-int Predicate5Test::n5_;
-
-typedef Predicate5Test EXPECT_PRED_FORMAT5Test;
-typedef Predicate5Test ASSERT_PRED_FORMAT5Test;
-typedef Predicate5Test EXPECT_PRED5Test;
-typedef Predicate5Test ASSERT_PRED5Test;
-
-// Tests a successful EXPECT_PRED5 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED5(PredFunction5Int,
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_,
-               ++n5_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED5 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED5(PredFunction5Bool,
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
-               Bool(++n4_),
-               Bool(++n5_));
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED5 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED5(PredFunctor5(),
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_,
-               ++n5_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED5 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED5(PredFunctor5(),
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
-               Bool(++n4_),
-               Bool(++n5_));
-  finished_ = true;
-}
-
-// Tests a failed EXPECT_PRED5 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED5(PredFunction5Int,
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++,
-                 n5_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED5 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED5(PredFunction5Bool,
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++),
-                 Bool(n5_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED5 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED5(PredFunctor5(),
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++,
-                 n5_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED5 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED5(PredFunctor5(),
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++),
-                 Bool(n5_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful ASSERT_PRED5 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED5(PredFunction5Int,
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_,
-               ++n5_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED5 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED5(PredFunction5Bool,
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
-               Bool(++n4_),
-               Bool(++n5_));
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED5 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED5(PredFunctor5(),
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_,
-               ++n5_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED5 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED5(PredFunctor5(),
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
-               Bool(++n4_),
-               Bool(++n5_));
-  finished_ = true;
-}
-
-// Tests a failed ASSERT_PRED5 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED5(PredFunction5Int,
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++,
-                 n5_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED5 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED5(PredFunction5Bool,
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++),
-                 Bool(n5_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED5 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED5(PredFunctor5(),
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++,
-                 n5_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED5 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED5(PredFunctor5(),
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++),
-                 Bool(n5_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful EXPECT_PRED_FORMAT5 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT5(PredFormatFunction5,
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_,
-                      ++n5_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT5 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT5(PredFormatFunction5,
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_),
-                      Bool(++n5_));
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT5 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_,
-                      ++n5_);
-  finished_ = true;
-}
-
-// Tests a successful EXPECT_PRED_FORMAT5 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_),
-                      Bool(++n5_));
-  finished_ = true;
-}
-
-// Tests a failed EXPECT_PRED_FORMAT5 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT5(PredFormatFunction5,
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++,
-                        n5_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT5 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT5(PredFormatFunction5,
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++),
-                        Bool(n5_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT5 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++,
-                        n5_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed EXPECT_PRED_FORMAT5 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++),
-                        Bool(n5_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a successful ASSERT_PRED_FORMAT5 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT5(PredFormatFunction5,
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_,
-                      ++n5_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT5 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT5(PredFormatFunction5,
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_),
-                      Bool(++n5_));
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT5 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_,
-                      ++n5_);
-  finished_ = true;
-}
-
-// Tests a successful ASSERT_PRED_FORMAT5 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_),
-                      Bool(++n5_));
-  finished_ = true;
-}
-
-// Tests a failed ASSERT_PRED_FORMAT5 where the
-// predicate-formatter is a function on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT5(PredFormatFunction5,
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++,
-                        n5_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT5 where the
-// predicate-formatter is a function on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT5(PredFormatFunction5,
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++),
-                        Bool(n5_++));
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT5 where the
-// predicate-formatter is a functor on a built-in type (int).
-TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++,
-                        n5_++);
-    finished_ = true;
-  }, "");
-}
-
-// Tests a failed ASSERT_PRED_FORMAT5 where the
-// predicate-formatter is a functor on a user-defined type (Bool).
-TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
-  expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++),
-                        Bool(n5_++));
-    finished_ = true;
-  }, "");
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_premature_exit_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_premature_exit_test.cc
deleted file mode 100644
index 3b4dc7d4..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_premature_exit_test.cc
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright 2013, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Tests that Google Test manipulates the premature-exit-detection
-// file correctly.
-
-#include <stdio.h>
-
-#include "gtest/gtest.h"
-
-using ::testing::InitGoogleTest;
-using ::testing::Test;
-using ::testing::internal::posix::GetEnv;
-using ::testing::internal::posix::Stat;
-using ::testing::internal::posix::StatStruct;
-
-namespace {
-
-class PrematureExitTest : public Test {
- public:
-  // Returns true iff the given file exists.
-  static bool FileExists(const char* filepath) {
-    StatStruct stat;
-    return Stat(filepath, &stat) == 0;
-  }
-
- protected:
-  PrematureExitTest() {
-    premature_exit_file_path_ = GetEnv("TEST_PREMATURE_EXIT_FILE");
-
-    // Normalize NULL to "" for ease of handling.
-    if (premature_exit_file_path_ == NULL) {
-      premature_exit_file_path_ = "";
-    }
-  }
-
-  // Returns true iff the premature-exit file exists.
-  bool PrematureExitFileExists() const {
-    return FileExists(premature_exit_file_path_);
-  }
-
-  const char* premature_exit_file_path_;
-};
-
-typedef PrematureExitTest PrematureExitDeathTest;
-
-// Tests that:
-//   - the premature-exit file exists during the execution of a
-//     death test (EXPECT_DEATH*), and
-//   - a death test doesn't interfere with the main test process's
-//     handling of the premature-exit file.
-TEST_F(PrematureExitDeathTest, FileExistsDuringExecutionOfDeathTest) {
-  if (*premature_exit_file_path_ == '\0') {
-    return;
-  }
-
-  EXPECT_DEATH_IF_SUPPORTED({
-      // If the file exists, crash the process such that the main test
-      // process will catch the (expected) crash and report a success;
-      // otherwise don't crash, which will cause the main test process
-      // to report that the death test has failed.
-      if (PrematureExitFileExists()) {
-        exit(1);
-      }
-    }, "");
-}
-
-// Tests that the premature-exit file exists during the execution of a
-// normal (non-death) test.
-TEST_F(PrematureExitTest, PrematureExitFileExistsDuringTestExecution) {
-  if (*premature_exit_file_path_ == '\0') {
-    return;
-  }
-
-  EXPECT_TRUE(PrematureExitFileExists())
-      << " file " << premature_exit_file_path_
-      << " should exist during test execution, but doesn't.";
-}
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  InitGoogleTest(&argc, argv);
-  const int exit_code = RUN_ALL_TESTS();
-
-  // Test that the premature-exit file is deleted upon return from
-  // RUN_ALL_TESTS().
-  const char* const filepath = GetEnv("TEST_PREMATURE_EXIT_FILE");
-  if (filepath != NULL && *filepath != '\0') {
-    if (PrematureExitTest::FileExists(filepath)) {
-      printf(
-          "File %s shouldn't exist after the test program finishes, but does.",
-          filepath);
-      return 1;
-    }
-  }
-
-  return exit_code;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_prod_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_prod_test.cc
deleted file mode 100644
index 060abce1..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_prod_test.cc
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2006, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Unit test for include/gtest/gtest_prod.h.
-
-#include "gtest/gtest.h"
-#include "test/production.h"
-
-// Tests that private members can be accessed from a TEST declared as
-// a friend of the class.
-TEST(PrivateCodeTest, CanAccessPrivateMembers) {
-  PrivateCode a;
-  EXPECT_EQ(0, a.x_);
-
-  a.set_x(1);
-  EXPECT_EQ(1, a.x_);
-}
-
-typedef testing::Test PrivateCodeFixtureTest;
-
-// Tests that private members can be accessed from a TEST_F declared
-// as a friend of the class.
-TEST_F(PrivateCodeFixtureTest, CanAccessPrivateMembers) {
-  PrivateCode a;
-  EXPECT_EQ(0, a.x_);
-
-  a.set_x(2);
-  EXPECT_EQ(2, a.x_);
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_repeat_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_repeat_test.cc
deleted file mode 100644
index 481012ad..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_repeat_test.cc
+++ /dev/null
@@ -1,253 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Tests the --gtest_repeat=number flag.
-
-#include <stdlib.h>
-#include <iostream>
-#include "gtest/gtest.h"
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick is to
-// prevent a user from accidentally including gtest-internal-inl.h in
-// his code.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-namespace testing {
-
-GTEST_DECLARE_string_(death_test_style);
-GTEST_DECLARE_string_(filter);
-GTEST_DECLARE_int32_(repeat);
-
-}  // namespace testing
-
-using testing::GTEST_FLAG(death_test_style);
-using testing::GTEST_FLAG(filter);
-using testing::GTEST_FLAG(repeat);
-
-namespace {
-
-// We need this when we are testing Google Test itself and therefore
-// cannot use Google Test assertions.
-#define GTEST_CHECK_INT_EQ_(expected, actual) \
-  do {\
-    const int expected_val = (expected);\
-    const int actual_val = (actual);\
-    if (::testing::internal::IsTrue(expected_val != actual_val)) {\
-      ::std::cout << "Value of: " #actual "\n"\
-                  << "  Actual: " << actual_val << "\n"\
-                  << "Expected: " #expected "\n"\
-                  << "Which is: " << expected_val << "\n";\
-      ::testing::internal::posix::Abort();\
-    }\
-  } while (::testing::internal::AlwaysFalse())
-
-
-// Used for verifying that global environment set-up and tear-down are
-// inside the gtest_repeat loop.
-
-int g_environment_set_up_count = 0;
-int g_environment_tear_down_count = 0;
-
-class MyEnvironment : public testing::Environment {
- public:
-  MyEnvironment() {}
-  virtual void SetUp() { g_environment_set_up_count++; }
-  virtual void TearDown() { g_environment_tear_down_count++; }
-};
-
-// A test that should fail.
-
-int g_should_fail_count = 0;
-
-TEST(FooTest, ShouldFail) {
-  g_should_fail_count++;
-  EXPECT_EQ(0, 1) << "Expected failure.";
-}
-
-// A test that should pass.
-
-int g_should_pass_count = 0;
-
-TEST(FooTest, ShouldPass) {
-  g_should_pass_count++;
-}
-
-// A test that contains a thread-safe death test and a fast death
-// test.  It should pass.
-
-int g_death_test_count = 0;
-
-TEST(BarDeathTest, ThreadSafeAndFast) {
-  g_death_test_count++;
-
-  GTEST_FLAG(death_test_style) = "threadsafe";
-  EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::Abort(), "");
-
-  GTEST_FLAG(death_test_style) = "fast";
-  EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::Abort(), "");
-}
-
-#if GTEST_HAS_PARAM_TEST
-int g_param_test_count = 0;
-
-const int kNumberOfParamTests = 10;
-
-class MyParamTest : public testing::TestWithParam<int> {};
-
-TEST_P(MyParamTest, ShouldPass) {
-  // TODO(vladl@google.com): Make parameter value checking robust
-  //                         WRT order of tests.
-  GTEST_CHECK_INT_EQ_(g_param_test_count % kNumberOfParamTests, GetParam());
-  g_param_test_count++;
-}
-INSTANTIATE_TEST_CASE_P(MyParamSequence,
-                        MyParamTest,
-                        testing::Range(0, kNumberOfParamTests));
-#endif  // GTEST_HAS_PARAM_TEST
-
-// Resets the count for each test.
-void ResetCounts() {
-  g_environment_set_up_count = 0;
-  g_environment_tear_down_count = 0;
-  g_should_fail_count = 0;
-  g_should_pass_count = 0;
-  g_death_test_count = 0;
-#if GTEST_HAS_PARAM_TEST
-  g_param_test_count = 0;
-#endif  // GTEST_HAS_PARAM_TEST
-}
-
-// Checks that the count for each test is expected.
-void CheckCounts(int expected) {
-  GTEST_CHECK_INT_EQ_(expected, g_environment_set_up_count);
-  GTEST_CHECK_INT_EQ_(expected, g_environment_tear_down_count);
-  GTEST_CHECK_INT_EQ_(expected, g_should_fail_count);
-  GTEST_CHECK_INT_EQ_(expected, g_should_pass_count);
-  GTEST_CHECK_INT_EQ_(expected, g_death_test_count);
-#if GTEST_HAS_PARAM_TEST
-  GTEST_CHECK_INT_EQ_(expected * kNumberOfParamTests, g_param_test_count);
-#endif  // GTEST_HAS_PARAM_TEST
-}
-
-// Tests the behavior of Google Test when --gtest_repeat is not specified.
-void TestRepeatUnspecified() {
-  ResetCounts();
-  GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
-  CheckCounts(1);
-}
-
-// Tests the behavior of Google Test when --gtest_repeat has the given value.
-void TestRepeat(int repeat) {
-  GTEST_FLAG(repeat) = repeat;
-
-  ResetCounts();
-  GTEST_CHECK_INT_EQ_(repeat > 0 ? 1 : 0, RUN_ALL_TESTS());
-  CheckCounts(repeat);
-}
-
-// Tests using --gtest_repeat when --gtest_filter specifies an empty
-// set of tests.
-void TestRepeatWithEmptyFilter(int repeat) {
-  GTEST_FLAG(repeat) = repeat;
-  GTEST_FLAG(filter) = "None";
-
-  ResetCounts();
-  GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
-  CheckCounts(0);
-}
-
-// Tests using --gtest_repeat when --gtest_filter specifies a set of
-// successful tests.
-void TestRepeatWithFilterForSuccessfulTests(int repeat) {
-  GTEST_FLAG(repeat) = repeat;
-  GTEST_FLAG(filter) = "*-*ShouldFail";
-
-  ResetCounts();
-  GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
-  GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);
-  GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);
-  GTEST_CHECK_INT_EQ_(0, g_should_fail_count);
-  GTEST_CHECK_INT_EQ_(repeat, g_should_pass_count);
-  GTEST_CHECK_INT_EQ_(repeat, g_death_test_count);
-#if GTEST_HAS_PARAM_TEST
-  GTEST_CHECK_INT_EQ_(repeat * kNumberOfParamTests, g_param_test_count);
-#endif  // GTEST_HAS_PARAM_TEST
-}
-
-// Tests using --gtest_repeat when --gtest_filter specifies a set of
-// failed tests.
-void TestRepeatWithFilterForFailedTests(int repeat) {
-  GTEST_FLAG(repeat) = repeat;
-  GTEST_FLAG(filter) = "*ShouldFail";
-
-  ResetCounts();
-  GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
-  GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);
-  GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);
-  GTEST_CHECK_INT_EQ_(repeat, g_should_fail_count);
-  GTEST_CHECK_INT_EQ_(0, g_should_pass_count);
-  GTEST_CHECK_INT_EQ_(0, g_death_test_count);
-#if GTEST_HAS_PARAM_TEST
-  GTEST_CHECK_INT_EQ_(0, g_param_test_count);
-#endif  // GTEST_HAS_PARAM_TEST
-}
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  testing::InitGoogleTest(&argc, argv);
-  testing::AddGlobalTestEnvironment(new MyEnvironment);
-
-  TestRepeatUnspecified();
-  TestRepeat(0);
-  TestRepeat(1);
-  TestRepeat(5);
-
-  TestRepeatWithEmptyFilter(2);
-  TestRepeatWithEmptyFilter(3);
-
-  TestRepeatWithFilterForSuccessfulTests(3);
-
-  TestRepeatWithFilterForFailedTests(4);
-
-  // It would be nice to verify that the tests indeed loop forever
-  // when GTEST_FLAG(repeat) is negative, but this test will be quite
-  // complicated to write.  Since this flag is for interactive
-  // debugging only and doesn't affect the normal test result, such a
-  // test would be an overkill.
-
-  printf("PASS\n");
-  return 0;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test.py
deleted file mode 100755
index 30d0303d..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test.py
+++ /dev/null
@@ -1,325 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2009 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.
-
-"""Verifies that test shuffling works."""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import gtest_test_utils
-
-# Command to run the gtest_shuffle_test_ program.
-COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_shuffle_test_')
-
-# The environment variables for test sharding.
-TOTAL_SHARDS_ENV_VAR = 'GTEST_TOTAL_SHARDS'
-SHARD_INDEX_ENV_VAR = 'GTEST_SHARD_INDEX'
-
-TEST_FILTER = 'A*.A:A*.B:C*'
-
-ALL_TESTS = []
-ACTIVE_TESTS = []
-FILTERED_TESTS = []
-SHARDED_TESTS = []
-
-SHUFFLED_ALL_TESTS = []
-SHUFFLED_ACTIVE_TESTS = []
-SHUFFLED_FILTERED_TESTS = []
-SHUFFLED_SHARDED_TESTS = []
-
-
-def AlsoRunDisabledTestsFlag():
-  return '--gtest_also_run_disabled_tests'
-
-
-def FilterFlag(test_filter):
-  return '--gtest_filter=%s' % (test_filter,)
-
-
-def RepeatFlag(n):
-  return '--gtest_repeat=%s' % (n,)
-
-
-def ShuffleFlag():
-  return '--gtest_shuffle'
-
-
-def RandomSeedFlag(n):
-  return '--gtest_random_seed=%s' % (n,)
-
-
-def RunAndReturnOutput(extra_env, args):
-  """Runs the test program and returns its output."""
-
-  environ_copy = os.environ.copy()
-  environ_copy.update(extra_env)
-
-  return gtest_test_utils.Subprocess([COMMAND] + args, env=environ_copy).output
-
-
-def GetTestsForAllIterations(extra_env, args):
-  """Runs the test program and returns a list of test lists.
-
-  Args:
-    extra_env: a map from environment variables to their values
-    args: command line flags to pass to gtest_shuffle_test_
-
-  Returns:
-    A list where the i-th element is the list of tests run in the i-th
-    test iteration.
-  """
-
-  test_iterations = []
-  for line in RunAndReturnOutput(extra_env, args).split('\n'):
-    if line.startswith('----'):
-      tests = []
-      test_iterations.append(tests)
-    elif line.strip():
-      tests.append(line.strip())  # 'TestCaseName.TestName'
-
-  return test_iterations
-
-
-def GetTestCases(tests):
-  """Returns a list of test cases in the given full test names.
-
-  Args:
-    tests: a list of full test names
-
-  Returns:
-    A list of test cases from 'tests', in their original order.
-    Consecutive duplicates are removed.
-  """
-
-  test_cases = []
-  for test in tests:
-    test_case = test.split('.')[0]
-    if not test_case in test_cases:
-      test_cases.append(test_case)
-
-  return test_cases
-
-
-def CalculateTestLists():
-  """Calculates the list of tests run under different flags."""
-
-  if not ALL_TESTS:
-    ALL_TESTS.extend(
-        GetTestsForAllIterations({}, [AlsoRunDisabledTestsFlag()])[0])
-
-  if not ACTIVE_TESTS:
-    ACTIVE_TESTS.extend(GetTestsForAllIterations({}, [])[0])
-
-  if not FILTERED_TESTS:
-    FILTERED_TESTS.extend(
-        GetTestsForAllIterations({}, [FilterFlag(TEST_FILTER)])[0])
-
-  if not SHARDED_TESTS:
-    SHARDED_TESTS.extend(
-        GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
-                                  SHARD_INDEX_ENV_VAR: '1'},
-                                 [])[0])
-
-  if not SHUFFLED_ALL_TESTS:
-    SHUFFLED_ALL_TESTS.extend(GetTestsForAllIterations(
-        {}, [AlsoRunDisabledTestsFlag(), ShuffleFlag(), RandomSeedFlag(1)])[0])
-
-  if not SHUFFLED_ACTIVE_TESTS:
-    SHUFFLED_ACTIVE_TESTS.extend(GetTestsForAllIterations(
-        {}, [ShuffleFlag(), RandomSeedFlag(1)])[0])
-
-  if not SHUFFLED_FILTERED_TESTS:
-    SHUFFLED_FILTERED_TESTS.extend(GetTestsForAllIterations(
-        {}, [ShuffleFlag(), RandomSeedFlag(1), FilterFlag(TEST_FILTER)])[0])
-
-  if not SHUFFLED_SHARDED_TESTS:
-    SHUFFLED_SHARDED_TESTS.extend(
-        GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
-                                  SHARD_INDEX_ENV_VAR: '1'},
-                                 [ShuffleFlag(), RandomSeedFlag(1)])[0])
-
-
-class GTestShuffleUnitTest(gtest_test_utils.TestCase):
-  """Tests test shuffling."""
-
-  def setUp(self):
-    CalculateTestLists()
-
-  def testShufflePreservesNumberOfTests(self):
-    self.assertEqual(len(ALL_TESTS), len(SHUFFLED_ALL_TESTS))
-    self.assertEqual(len(ACTIVE_TESTS), len(SHUFFLED_ACTIVE_TESTS))
-    self.assertEqual(len(FILTERED_TESTS), len(SHUFFLED_FILTERED_TESTS))
-    self.assertEqual(len(SHARDED_TESTS), len(SHUFFLED_SHARDED_TESTS))
-
-  def testShuffleChangesTestOrder(self):
-    self.assert_(SHUFFLED_ALL_TESTS != ALL_TESTS, SHUFFLED_ALL_TESTS)
-    self.assert_(SHUFFLED_ACTIVE_TESTS != ACTIVE_TESTS, SHUFFLED_ACTIVE_TESTS)
-    self.assert_(SHUFFLED_FILTERED_TESTS != FILTERED_TESTS,
-                 SHUFFLED_FILTERED_TESTS)
-    self.assert_(SHUFFLED_SHARDED_TESTS != SHARDED_TESTS,
-                 SHUFFLED_SHARDED_TESTS)
-
-  def testShuffleChangesTestCaseOrder(self):
-    self.assert_(GetTestCases(SHUFFLED_ALL_TESTS) != GetTestCases(ALL_TESTS),
-                 GetTestCases(SHUFFLED_ALL_TESTS))
-    self.assert_(
-        GetTestCases(SHUFFLED_ACTIVE_TESTS) != GetTestCases(ACTIVE_TESTS),
-        GetTestCases(SHUFFLED_ACTIVE_TESTS))
-    self.assert_(
-        GetTestCases(SHUFFLED_FILTERED_TESTS) != GetTestCases(FILTERED_TESTS),
-        GetTestCases(SHUFFLED_FILTERED_TESTS))
-    self.assert_(
-        GetTestCases(SHUFFLED_SHARDED_TESTS) != GetTestCases(SHARDED_TESTS),
-        GetTestCases(SHUFFLED_SHARDED_TESTS))
-
-  def testShuffleDoesNotRepeatTest(self):
-    for test in SHUFFLED_ALL_TESTS:
-      self.assertEqual(1, SHUFFLED_ALL_TESTS.count(test),
-                       '%s appears more than once' % (test,))
-    for test in SHUFFLED_ACTIVE_TESTS:
-      self.assertEqual(1, SHUFFLED_ACTIVE_TESTS.count(test),
-                       '%s appears more than once' % (test,))
-    for test in SHUFFLED_FILTERED_TESTS:
-      self.assertEqual(1, SHUFFLED_FILTERED_TESTS.count(test),
-                       '%s appears more than once' % (test,))
-    for test in SHUFFLED_SHARDED_TESTS:
-      self.assertEqual(1, SHUFFLED_SHARDED_TESTS.count(test),
-                       '%s appears more than once' % (test,))
-
-  def testShuffleDoesNotCreateNewTest(self):
-    for test in SHUFFLED_ALL_TESTS:
-      self.assert_(test in ALL_TESTS, '%s is an invalid test' % (test,))
-    for test in SHUFFLED_ACTIVE_TESTS:
-      self.assert_(test in ACTIVE_TESTS, '%s is an invalid test' % (test,))
-    for test in SHUFFLED_FILTERED_TESTS:
-      self.assert_(test in FILTERED_TESTS, '%s is an invalid test' % (test,))
-    for test in SHUFFLED_SHARDED_TESTS:
-      self.assert_(test in SHARDED_TESTS, '%s is an invalid test' % (test,))
-
-  def testShuffleIncludesAllTests(self):
-    for test in ALL_TESTS:
-      self.assert_(test in SHUFFLED_ALL_TESTS, '%s is missing' % (test,))
-    for test in ACTIVE_TESTS:
-      self.assert_(test in SHUFFLED_ACTIVE_TESTS, '%s is missing' % (test,))
-    for test in FILTERED_TESTS:
-      self.assert_(test in SHUFFLED_FILTERED_TESTS, '%s is missing' % (test,))
-    for test in SHARDED_TESTS:
-      self.assert_(test in SHUFFLED_SHARDED_TESTS, '%s is missing' % (test,))
-
-  def testShuffleLeavesDeathTestsAtFront(self):
-    non_death_test_found = False
-    for test in SHUFFLED_ACTIVE_TESTS:
-      if 'DeathTest.' in test:
-        self.assert_(not non_death_test_found,
-                     '%s appears after a non-death test' % (test,))
-      else:
-        non_death_test_found = True
-
-  def _VerifyTestCasesDoNotInterleave(self, tests):
-    test_cases = []
-    for test in tests:
-      [test_case, _] = test.split('.')
-      if test_cases and test_cases[-1] != test_case:
-        test_cases.append(test_case)
-        self.assertEqual(1, test_cases.count(test_case),
-                         'Test case %s is not grouped together in %s' %
-                         (test_case, tests))
-
-  def testShuffleDoesNotInterleaveTestCases(self):
-    self._VerifyTestCasesDoNotInterleave(SHUFFLED_ALL_TESTS)
-    self._VerifyTestCasesDoNotInterleave(SHUFFLED_ACTIVE_TESTS)
-    self._VerifyTestCasesDoNotInterleave(SHUFFLED_FILTERED_TESTS)
-    self._VerifyTestCasesDoNotInterleave(SHUFFLED_SHARDED_TESTS)
-
-  def testShuffleRestoresOrderAfterEachIteration(self):
-    # Get the test lists in all 3 iterations, using random seed 1, 2,
-    # and 3 respectively.  Google Test picks a different seed in each
-    # iteration, and this test depends on the current implementation
-    # picking successive numbers.  This dependency is not ideal, but
-    # makes the test much easier to write.
-    [tests_in_iteration1, tests_in_iteration2, tests_in_iteration3] = (
-        GetTestsForAllIterations(
-            {}, [ShuffleFlag(), RandomSeedFlag(1), RepeatFlag(3)]))
-
-    # Make sure running the tests with random seed 1 gets the same
-    # order as in iteration 1 above.
-    [tests_with_seed1] = GetTestsForAllIterations(
-        {}, [ShuffleFlag(), RandomSeedFlag(1)])
-    self.assertEqual(tests_in_iteration1, tests_with_seed1)
-
-    # Make sure running the tests with random seed 2 gets the same
-    # order as in iteration 2 above.  Success means that Google Test
-    # correctly restores the test order before re-shuffling at the
-    # beginning of iteration 2.
-    [tests_with_seed2] = GetTestsForAllIterations(
-        {}, [ShuffleFlag(), RandomSeedFlag(2)])
-    self.assertEqual(tests_in_iteration2, tests_with_seed2)
-
-    # Make sure running the tests with random seed 3 gets the same
-    # order as in iteration 3 above.  Success means that Google Test
-    # correctly restores the test order before re-shuffling at the
-    # beginning of iteration 3.
-    [tests_with_seed3] = GetTestsForAllIterations(
-        {}, [ShuffleFlag(), RandomSeedFlag(3)])
-    self.assertEqual(tests_in_iteration3, tests_with_seed3)
-
-  def testShuffleGeneratesNewOrderInEachIteration(self):
-    [tests_in_iteration1, tests_in_iteration2, tests_in_iteration3] = (
-        GetTestsForAllIterations(
-            {}, [ShuffleFlag(), RandomSeedFlag(1), RepeatFlag(3)]))
-
-    self.assert_(tests_in_iteration1 != tests_in_iteration2,
-                 tests_in_iteration1)
-    self.assert_(tests_in_iteration1 != tests_in_iteration3,
-                 tests_in_iteration1)
-    self.assert_(tests_in_iteration2 != tests_in_iteration3,
-                 tests_in_iteration2)
-
-  def testShuffleShardedTestsPreservesPartition(self):
-    # If we run M tests on N shards, the same M tests should be run in
-    # total, regardless of the random seeds used by the shards.
-    [tests1] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
-                                         SHARD_INDEX_ENV_VAR: '0'},
-                                        [ShuffleFlag(), RandomSeedFlag(1)])
-    [tests2] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
-                                         SHARD_INDEX_ENV_VAR: '1'},
-                                        [ShuffleFlag(), RandomSeedFlag(20)])
-    [tests3] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
-                                         SHARD_INDEX_ENV_VAR: '2'},
-                                        [ShuffleFlag(), RandomSeedFlag(25)])
-    sorted_sharded_tests = tests1 + tests2 + tests3
-    sorted_sharded_tests.sort()
-    sorted_active_tests = []
-    sorted_active_tests.extend(ACTIVE_TESTS)
-    sorted_active_tests.sort()
-    self.assertEqual(sorted_active_tests, sorted_sharded_tests)
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test_.cc
deleted file mode 100644
index 6fb441bd..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_shuffle_test_.cc
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright 2009, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Verifies that test shuffling works.
-
-#include "gtest/gtest.h"
-
-namespace {
-
-using ::testing::EmptyTestEventListener;
-using ::testing::InitGoogleTest;
-using ::testing::Message;
-using ::testing::Test;
-using ::testing::TestEventListeners;
-using ::testing::TestInfo;
-using ::testing::UnitTest;
-using ::testing::internal::scoped_ptr;
-
-// The test methods are empty, as the sole purpose of this program is
-// to print the test names before/after shuffling.
-
-class A : public Test {};
-TEST_F(A, A) {}
-TEST_F(A, B) {}
-
-TEST(ADeathTest, A) {}
-TEST(ADeathTest, B) {}
-TEST(ADeathTest, C) {}
-
-TEST(B, A) {}
-TEST(B, B) {}
-TEST(B, C) {}
-TEST(B, DISABLED_D) {}
-TEST(B, DISABLED_E) {}
-
-TEST(BDeathTest, A) {}
-TEST(BDeathTest, B) {}
-
-TEST(C, A) {}
-TEST(C, B) {}
-TEST(C, C) {}
-TEST(C, DISABLED_D) {}
-
-TEST(CDeathTest, A) {}
-
-TEST(DISABLED_D, A) {}
-TEST(DISABLED_D, DISABLED_B) {}
-
-// This printer prints the full test names only, starting each test
-// iteration with a "----" marker.
-class TestNamePrinter : public EmptyTestEventListener {
- public:
-  virtual void OnTestIterationStart(const UnitTest& /* unit_test */,
-                                    int /* iteration */) {
-    printf("----\n");
-  }
-
-  virtual void OnTestStart(const TestInfo& test_info) {
-    printf("%s.%s\n", test_info.test_case_name(), test_info.name());
-  }
-};
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  InitGoogleTest(&argc, argv);
-
-  // Replaces the default printer with TestNamePrinter, which prints
-  // the test name only.
-  TestEventListeners& listeners = UnitTest::GetInstance()->listeners();
-  delete listeners.Release(listeners.default_result_printer());
-  listeners.Append(new TestNamePrinter);
-
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_sole_header_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_sole_header_test.cc
deleted file mode 100644
index ccd091a2..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_sole_header_test.cc
+++ /dev/null
@@ -1,57 +0,0 @@
-// 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.
-//
-// Author: mheule@google.com (Markus Heule)
-//
-// This test verifies that it's possible to use Google Test by including
-// the gtest.h header file alone.
-
-#include "gtest/gtest.h"
-
-namespace {
-
-void Subroutine() {
-  EXPECT_EQ(42, 42);
-}
-
-TEST(NoFatalFailureTest, ExpectNoFatalFailure) {
-  EXPECT_NO_FATAL_FAILURE(;);
-  EXPECT_NO_FATAL_FAILURE(SUCCEED());
-  EXPECT_NO_FATAL_FAILURE(Subroutine());
-  EXPECT_NO_FATAL_FAILURE({ SUCCEED(); });
-}
-
-TEST(NoFatalFailureTest, AssertNoFatalFailure) {
-  ASSERT_NO_FATAL_FAILURE(;);
-  ASSERT_NO_FATAL_FAILURE(SUCCEED());
-  ASSERT_NO_FATAL_FAILURE(Subroutine());
-  ASSERT_NO_FATAL_FAILURE({ SUCCEED(); });
-}
-
-}  // namespace
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_stress_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_stress_test.cc
deleted file mode 100644
index e7daa430..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_stress_test.cc
+++ /dev/null
@@ -1,256 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Tests that SCOPED_TRACE() and various Google Test assertions can be
-// used in a large number of threads concurrently.
-
-#include "gtest/gtest.h"
-
-#include <iostream>
-#include <vector>
-
-// We must define this macro in order to #include
-// gtest-internal-inl.h.  This is how Google Test prevents a user from
-// accidentally depending on its internal implementation.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-#if GTEST_IS_THREADSAFE
-
-namespace testing {
-namespace {
-
-using internal::Notification;
-using internal::TestPropertyKeyIs;
-using internal::ThreadWithParam;
-using internal::scoped_ptr;
-
-// In order to run tests in this file, for platforms where Google Test is
-// thread safe, implement ThreadWithParam. See the description of its API
-// in gtest-port.h, where it is defined for already supported platforms.
-
-// How many threads to create?
-const int kThreadCount = 50;
-
-std::string IdToKey(int id, const char* suffix) {
-  Message key;
-  key << "key_" << id << "_" << suffix;
-  return key.GetString();
-}
-
-std::string IdToString(int id) {
-  Message id_message;
-  id_message << id;
-  return id_message.GetString();
-}
-
-void ExpectKeyAndValueWereRecordedForId(
-    const std::vector<TestProperty>& properties,
-    int id, const char* suffix) {
-  TestPropertyKeyIs matches_key(IdToKey(id, suffix).c_str());
-  const std::vector<TestProperty>::const_iterator property =
-      std::find_if(properties.begin(), properties.end(), matches_key);
-  ASSERT_TRUE(property != properties.end())
-      << "expecting " << suffix << " value for id " << id;
-  EXPECT_STREQ(IdToString(id).c_str(), property->value());
-}
-
-// Calls a large number of Google Test assertions, where exactly one of them
-// will fail.
-void ManyAsserts(int id) {
-  GTEST_LOG_(INFO) << "Thread #" << id << " running...";
-
-  SCOPED_TRACE(Message() << "Thread #" << id);
-
-  for (int i = 0; i < kThreadCount; i++) {
-    SCOPED_TRACE(Message() << "Iteration #" << i);
-
-    // A bunch of assertions that should succeed.
-    EXPECT_TRUE(true);
-    ASSERT_FALSE(false) << "This shouldn't fail.";
-    EXPECT_STREQ("a", "a");
-    ASSERT_LE(5, 6);
-    EXPECT_EQ(i, i) << "This shouldn't fail.";
-
-    // RecordProperty() should interact safely with other threads as well.
-    // The shared_key forces property updates.
-    Test::RecordProperty(IdToKey(id, "string").c_str(), IdToString(id).c_str());
-    Test::RecordProperty(IdToKey(id, "int").c_str(), id);
-    Test::RecordProperty("shared_key", IdToString(id).c_str());
-
-    // This assertion should fail kThreadCount times per thread.  It
-    // is for testing whether Google Test can handle failed assertions in a
-    // multi-threaded context.
-    EXPECT_LT(i, 0) << "This should always fail.";
-  }
-}
-
-void CheckTestFailureCount(int expected_failures) {
-  const TestInfo* const info = UnitTest::GetInstance()->current_test_info();
-  const TestResult* const result = info->result();
-  GTEST_CHECK_(expected_failures == result->total_part_count())
-      << "Logged " << result->total_part_count() << " failures "
-      << " vs. " << expected_failures << " expected";
-}
-
-// Tests using SCOPED_TRACE() and Google Test assertions in many threads
-// concurrently.
-TEST(StressTest, CanUseScopedTraceAndAssertionsInManyThreads) {
-  {
-    scoped_ptr<ThreadWithParam<int> > threads[kThreadCount];
-    Notification threads_can_start;
-    for (int i = 0; i != kThreadCount; i++)
-      threads[i].reset(new ThreadWithParam<int>(&ManyAsserts,
-                                                i,
-                                                &threads_can_start));
-
-    threads_can_start.Notify();
-
-    // Blocks until all the threads are done.
-    for (int i = 0; i != kThreadCount; i++)
-      threads[i]->Join();
-  }
-
-  // Ensures that kThreadCount*kThreadCount failures have been reported.
-  const TestInfo* const info = UnitTest::GetInstance()->current_test_info();
-  const TestResult* const result = info->result();
-
-  std::vector<TestProperty> properties;
-  // We have no access to the TestResult's list of properties but we can
-  // copy them one by one.
-  for (int i = 0; i < result->test_property_count(); ++i)
-    properties.push_back(result->GetTestProperty(i));
-
-  EXPECT_EQ(kThreadCount * 2 + 1, result->test_property_count())
-      << "String and int values recorded on each thread, "
-      << "as well as one shared_key";
-  for (int i = 0; i < kThreadCount; ++i) {
-    ExpectKeyAndValueWereRecordedForId(properties, i, "string");
-    ExpectKeyAndValueWereRecordedForId(properties, i, "int");
-  }
-  CheckTestFailureCount(kThreadCount*kThreadCount);
-}
-
-void FailingThread(bool is_fatal) {
-  if (is_fatal)
-    FAIL() << "Fatal failure in some other thread. "
-           << "(This failure is expected.)";
-  else
-    ADD_FAILURE() << "Non-fatal failure in some other thread. "
-                  << "(This failure is expected.)";
-}
-
-void GenerateFatalFailureInAnotherThread(bool is_fatal) {
-  ThreadWithParam<bool> thread(&FailingThread, is_fatal, NULL);
-  thread.Join();
-}
-
-TEST(NoFatalFailureTest, ExpectNoFatalFailureIgnoresFailuresInOtherThreads) {
-  EXPECT_NO_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true));
-  // We should only have one failure (the one from
-  // GenerateFatalFailureInAnotherThread()), since the EXPECT_NO_FATAL_FAILURE
-  // should succeed.
-  CheckTestFailureCount(1);
-}
-
-void AssertNoFatalFailureIgnoresFailuresInOtherThreads() {
-  ASSERT_NO_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true));
-}
-TEST(NoFatalFailureTest, AssertNoFatalFailureIgnoresFailuresInOtherThreads) {
-  // Using a subroutine, to make sure, that the test continues.
-  AssertNoFatalFailureIgnoresFailuresInOtherThreads();
-  // We should only have one failure (the one from
-  // GenerateFatalFailureInAnotherThread()), since the EXPECT_NO_FATAL_FAILURE
-  // should succeed.
-  CheckTestFailureCount(1);
-}
-
-TEST(FatalFailureTest, ExpectFatalFailureIgnoresFailuresInOtherThreads) {
-  // This statement should fail, since the current thread doesn't generate a
-  // fatal failure, only another one does.
-  EXPECT_FATAL_FAILURE(GenerateFatalFailureInAnotherThread(true), "expected");
-  CheckTestFailureCount(2);
-}
-
-TEST(FatalFailureOnAllThreadsTest, ExpectFatalFailureOnAllThreads) {
-  // This statement should succeed, because failures in all threads are
-  // considered.
-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(
-      GenerateFatalFailureInAnotherThread(true), "expected");
-  CheckTestFailureCount(0);
-  // We need to add a failure, because main() checks that there are failures.
-  // But when only this test is run, we shouldn't have any failures.
-  ADD_FAILURE() << "This is an expected non-fatal failure.";
-}
-
-TEST(NonFatalFailureTest, ExpectNonFatalFailureIgnoresFailuresInOtherThreads) {
-  // This statement should fail, since the current thread doesn't generate a
-  // fatal failure, only another one does.
-  EXPECT_NONFATAL_FAILURE(GenerateFatalFailureInAnotherThread(false),
-                          "expected");
-  CheckTestFailureCount(2);
-}
-
-TEST(NonFatalFailureOnAllThreadsTest, ExpectNonFatalFailureOnAllThreads) {
-  // This statement should succeed, because failures in all threads are
-  // considered.
-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(
-      GenerateFatalFailureInAnotherThread(false), "expected");
-  CheckTestFailureCount(0);
-  // We need to add a failure, because main() checks that there are failures,
-  // But when only this test is run, we shouldn't have any failures.
-  ADD_FAILURE() << "This is an expected non-fatal failure.";
-}
-
-}  // namespace
-}  // namespace testing
-
-int main(int argc, char **argv) {
-  testing::InitGoogleTest(&argc, argv);
-
-  const int result = RUN_ALL_TESTS();  // Expected to fail.
-  GTEST_CHECK_(result == 1) << "RUN_ALL_TESTS() did not fail as expected";
-
-  printf("\nPASS\n");
-  return 0;
-}
-
-#else
-TEST(StressTest,
-     DISABLED_ThreadSafetyTestsAreSkippedWhenGoogleTestIsNotThreadSafe) {
-}
-
-int main(int argc, char **argv) {
-  testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
-#endif  // GTEST_IS_THREADSAFE
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_test_utils.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_test_utils.py
deleted file mode 100755
index 4acd36c9..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_test_utils.py
+++ /dev/null
@@ -1,320 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2006, 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.
-
-"""Unit test utilities for Google C++ Testing Framework."""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import atexit
-import os
-import shutil
-import sys
-import tempfile
-import unittest
-_test_module = unittest
-
-# Suppresses the 'Import not at the top of the file' lint complaint.
-# pylint: disable-msg=C6204
-try:
-  import subprocess
-  _SUBPROCESS_MODULE_AVAILABLE = True
-except:
-  import popen2
-  _SUBPROCESS_MODULE_AVAILABLE = False
-# pylint: enable-msg=C6204
-
-GTEST_OUTPUT_VAR_NAME = 'GTEST_OUTPUT'
-
-IS_WINDOWS = os.name == 'nt'
-IS_CYGWIN = os.name == 'posix' and 'CYGWIN' in os.uname()[0]
-
-# The environment variable for specifying the path to the premature-exit file.
-PREMATURE_EXIT_FILE_ENV_VAR = 'TEST_PREMATURE_EXIT_FILE'
-
-environ = os.environ.copy()
-
-
-def SetEnvVar(env_var, value):
-  """Sets/unsets an environment variable to a given value."""
-
-  if value is not None:
-    environ[env_var] = value
-  elif env_var in environ:
-    del environ[env_var]
-
-
-# Here we expose a class from a particular module, depending on the
-# environment. The comment suppresses the 'Invalid variable name' lint
-# complaint.
-TestCase = _test_module.TestCase  # pylint: disable-msg=C6409
-
-# Initially maps a flag to its default value. After
-# _ParseAndStripGTestFlags() is called, maps a flag to its actual value.
-_flag_map = {'source_dir': os.path.dirname(sys.argv[0]),
-             'build_dir': os.path.dirname(sys.argv[0])}
-_gtest_flags_are_parsed = False
-
-
-def _ParseAndStripGTestFlags(argv):
-  """Parses and strips Google Test flags from argv.  This is idempotent."""
-
-  # Suppresses the lint complaint about a global variable since we need it
-  # here to maintain module-wide state.
-  global _gtest_flags_are_parsed  # pylint: disable-msg=W0603
-  if _gtest_flags_are_parsed:
-    return
-
-  _gtest_flags_are_parsed = True
-  for flag in _flag_map:
-    # The environment variable overrides the default value.
-    if flag.upper() in os.environ:
-      _flag_map[flag] = os.environ[flag.upper()]
-
-    # The command line flag overrides the environment variable.
-    i = 1  # Skips the program name.
-    while i < len(argv):
-      prefix = '--' + flag + '='
-      if argv[i].startswith(prefix):
-        _flag_map[flag] = argv[i][len(prefix):]
-        del argv[i]
-        break
-      else:
-        # We don't increment i in case we just found a --gtest_* flag
-        # and removed it from argv.
-        i += 1
-
-
-def GetFlag(flag):
-  """Returns the value of the given flag."""
-
-  # In case GetFlag() is called before Main(), we always call
-  # _ParseAndStripGTestFlags() here to make sure the --gtest_* flags
-  # are parsed.
-  _ParseAndStripGTestFlags(sys.argv)
-
-  return _flag_map[flag]
-
-
-def GetSourceDir():
-  """Returns the absolute path of the directory where the .py files are."""
-
-  return os.path.abspath(GetFlag('source_dir'))
-
-
-def GetBuildDir():
-  """Returns the absolute path of the directory where the test binaries are."""
-
-  return os.path.abspath(GetFlag('build_dir'))
-
-
-_temp_dir = None
-
-def _RemoveTempDir():
-  if _temp_dir:
-    shutil.rmtree(_temp_dir, ignore_errors=True)
-
-atexit.register(_RemoveTempDir)
-
-
-def GetTempDir():
-  """Returns a directory for temporary files."""
-
-  global _temp_dir
-  if not _temp_dir:
-    _temp_dir = tempfile.mkdtemp()
-  return _temp_dir
-
-
-def GetTestExecutablePath(executable_name, build_dir=None):
-  """Returns the absolute path of the test binary given its name.
-
-  The function will print a message and abort the program if the resulting file
-  doesn't exist.
-
-  Args:
-    executable_name: name of the test binary that the test script runs.
-    build_dir:       directory where to look for executables, by default
-                     the result of GetBuildDir().
-
-  Returns:
-    The absolute path of the test binary.
-  """
-
-  path = os.path.abspath(os.path.join(build_dir or GetBuildDir(),
-                                      executable_name))
-  if (IS_WINDOWS or IS_CYGWIN) and not path.endswith('.exe'):
-    path += '.exe'
-
-  if not os.path.exists(path):
-    message = (
-        'Unable to find the test binary "%s". Please make sure to provide\n'
-        'a path to the binary via the --build_dir flag or the BUILD_DIR\n'
-        'environment variable.' % path)
-    sys.stdout.write(message)
-    sys.exit(1)
-
-  return path
-
-
-def GetExitStatus(exit_code):
-  """Returns the argument to exit(), or -1 if exit() wasn't called.
-
-  Args:
-    exit_code: the result value of os.system(command).
-  """
-
-  if os.name == 'nt':
-    # On Windows, os.WEXITSTATUS() doesn't work and os.system() returns
-    # the argument to exit() directly.
-    return exit_code
-  else:
-    # On Unix, os.WEXITSTATUS() must be used to extract the exit status
-    # from the result of os.system().
-    if os.WIFEXITED(exit_code):
-      return os.WEXITSTATUS(exit_code)
-    else:
-      return -1
-
-
-class Subprocess:
-  def __init__(self, command, working_dir=None, capture_stderr=True, env=None):
-    """Changes into a specified directory, if provided, and executes a command.
-
-    Restores the old directory afterwards.
-
-    Args:
-      command:        The command to run, in the form of sys.argv.
-      working_dir:    The directory to change into.
-      capture_stderr: Determines whether to capture stderr in the output member
-                      or to discard it.
-      env:            Dictionary with environment to pass to the subprocess.
-
-    Returns:
-      An object that represents outcome of the executed process. It has the
-      following attributes:
-        terminated_by_signal   True iff the child process has been terminated
-                               by a signal.
-        signal                 Sygnal that terminated the child process.
-        exited                 True iff the child process exited normally.
-        exit_code              The code with which the child process exited.
-        output                 Child process's stdout and stderr output
-                               combined in a string.
-    """
-
-    # The subprocess module is the preferrable way of running programs
-    # since it is available and behaves consistently on all platforms,
-    # including Windows. But it is only available starting in python 2.4.
-    # In earlier python versions, we revert to the popen2 module, which is
-    # available in python 2.0 and later but doesn't provide required
-    # functionality (Popen4) under Windows. This allows us to support Mac
-    # OS X 10.4 Tiger, which has python 2.3 installed.
-    if _SUBPROCESS_MODULE_AVAILABLE:
-      if capture_stderr:
-        stderr = subprocess.STDOUT
-      else:
-        stderr = subprocess.PIPE
-
-      p = subprocess.Popen(command,
-                           stdout=subprocess.PIPE, stderr=stderr,
-                           cwd=working_dir, universal_newlines=True, env=env)
-      # communicate returns a tuple with the file obect for the child's
-      # output.
-      self.output = p.communicate()[0]
-      self._return_code = p.returncode
-    else:
-      old_dir = os.getcwd()
-
-      def _ReplaceEnvDict(dest, src):
-        # Changes made by os.environ.clear are not inheritable by child
-        # processes until Python 2.6. To produce inheritable changes we have
-        # to delete environment items with the del statement.
-        for key in dest.keys():
-          del dest[key]
-        dest.update(src)
-
-      # When 'env' is not None, backup the environment variables and replace
-      # them with the passed 'env'. When 'env' is None, we simply use the
-      # current 'os.environ' for compatibility with the subprocess.Popen
-      # semantics used above.
-      if env is not None:
-        old_environ = os.environ.copy()
-        _ReplaceEnvDict(os.environ, env)
-
-      try:
-        if working_dir is not None:
-          os.chdir(working_dir)
-        if capture_stderr:
-          p = popen2.Popen4(command)
-        else:
-          p = popen2.Popen3(command)
-        p.tochild.close()
-        self.output = p.fromchild.read()
-        ret_code = p.wait()
-      finally:
-        os.chdir(old_dir)
-
-        # Restore the old environment variables
-        # if they were replaced.
-        if env is not None:
-          _ReplaceEnvDict(os.environ, old_environ)
-
-      # Converts ret_code to match the semantics of
-      # subprocess.Popen.returncode.
-      if os.WIFSIGNALED(ret_code):
-        self._return_code = -os.WTERMSIG(ret_code)
-      else:  # os.WIFEXITED(ret_code) should return True here.
-        self._return_code = os.WEXITSTATUS(ret_code)
-
-    if self._return_code < 0:
-      self.terminated_by_signal = True
-      self.exited = False
-      self.signal = -self._return_code
-    else:
-      self.terminated_by_signal = False
-      self.exited = True
-      self.exit_code = self._return_code
-
-
-def Main():
-  """Runs the unit test."""
-
-  # We must call _ParseAndStripGTestFlags() before calling
-  # unittest.main().  Otherwise the latter will be confused by the
-  # --gtest_* flags.
-  _ParseAndStripGTestFlags(sys.argv)
-  # The tested binaries should not be writing XML output files unless the
-  # script explicitly instructs them to.
-  # TODO(vladl@google.com): Move this into Subprocess when we implement
-  # passing environment into it as a parameter.
-  if GTEST_OUTPUT_VAR_NAME in os.environ:
-    del os.environ[GTEST_OUTPUT_VAR_NAME]
-
-  _test_module.main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc
deleted file mode 100644
index 8d46c76f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright 2009, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Tests Google Test's throw-on-failure mode with exceptions enabled.
-
-#include "gtest/gtest.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdexcept>
-
-// Prints the given failure message and exits the program with
-// non-zero.  We use this instead of a Google Test assertion to
-// indicate a failure, as the latter is been tested and cannot be
-// relied on.
-void Fail(const char* msg) {
-  printf("FAILURE: %s\n", msg);
-  fflush(stdout);
-  exit(1);
-}
-
-// Tests that an assertion failure throws a subclass of
-// std::runtime_error.
-void TestFailureThrowsRuntimeError() {
-  testing::GTEST_FLAG(throw_on_failure) = true;
-
-  // A successful assertion shouldn't throw.
-  try {
-    EXPECT_EQ(3, 3);
-  } catch(...) {
-    Fail("A successful assertion wrongfully threw.");
-  }
-
-  // A failed assertion should throw a subclass of std::runtime_error.
-  try {
-    EXPECT_EQ(2, 3) << "Expected failure";
-  } catch(const std::runtime_error& e) {
-    if (strstr(e.what(), "Expected failure") != NULL)
-      return;
-
-    printf("%s",
-           "A failed assertion did throw an exception of the right type, "
-           "but the message is incorrect.  Instead of containing \"Expected "
-           "failure\", it is:\n");
-    Fail(e.what());
-  } catch(...) {
-    Fail("A failed assertion threw the wrong type of exception.");
-  }
-  Fail("A failed assertion should've thrown but didn't.");
-}
-
-int main(int argc, char** argv) {
-  testing::InitGoogleTest(&argc, argv);
-
-  // We want to ensure that people can use Google Test assertions in
-  // other testing frameworks, as long as they initialize Google Test
-  // properly and set the thrown-on-failure mode.  Therefore, we don't
-  // use Google Test's constructs for defining and running tests
-  // (e.g. TEST and RUN_ALL_TESTS) here.
-
-  TestFailureThrowsRuntimeError();
-  return 0;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test.py
deleted file mode 100755
index 3e7740ca..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test.py
+++ /dev/null
@@ -1,171 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2009, 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.
-
-"""Tests Google Test's throw-on-failure mode with exceptions disabled.
-
-This script invokes gtest_throw_on_failure_test_ (a program written with
-Google Test) with different environments and command line flags.
-"""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import os
-import gtest_test_utils
-
-
-# Constants.
-
-# The command line flag for enabling/disabling the throw-on-failure mode.
-THROW_ON_FAILURE = 'gtest_throw_on_failure'
-
-# Path to the gtest_throw_on_failure_test_ program, compiled with
-# exceptions disabled.
-EXE_PATH = gtest_test_utils.GetTestExecutablePath(
-    'gtest_throw_on_failure_test_')
-
-
-# Utilities.
-
-
-def SetEnvVar(env_var, value):
-  """Sets an environment variable to a given value; unsets it when the
-  given value is None.
-  """
-
-  env_var = env_var.upper()
-  if value is not None:
-    os.environ[env_var] = value
-  elif env_var in os.environ:
-    del os.environ[env_var]
-
-
-def Run(command):
-  """Runs a command; returns True/False if its exit code is/isn't 0."""
-
-  print('Running "%s". . .' % ' '.join(command))
-  p = gtest_test_utils.Subprocess(command)
-  return p.exited and p.exit_code == 0
-
-
-# The tests.  TODO(wan@google.com): refactor the class to share common
-# logic with code in gtest_break_on_failure_unittest.py.
-class ThrowOnFailureTest(gtest_test_utils.TestCase):
-  """Tests the throw-on-failure mode."""
-
-  def RunAndVerify(self, env_var_value, flag_value, should_fail):
-    """Runs gtest_throw_on_failure_test_ and verifies that it does
-    (or does not) exit with a non-zero code.
-
-    Args:
-      env_var_value:    value of the GTEST_BREAK_ON_FAILURE environment
-                        variable; None if the variable should be unset.
-      flag_value:       value of the --gtest_break_on_failure flag;
-                        None if the flag should not be present.
-      should_fail:      True iff the program is expected to fail.
-    """
-
-    SetEnvVar(THROW_ON_FAILURE, env_var_value)
-
-    if env_var_value is None:
-      env_var_value_msg = ' is not set'
-    else:
-      env_var_value_msg = '=' + env_var_value
-
-    if flag_value is None:
-      flag = ''
-    elif flag_value == '0':
-      flag = '--%s=0' % THROW_ON_FAILURE
-    else:
-      flag = '--%s' % THROW_ON_FAILURE
-
-    command = [EXE_PATH]
-    if flag:
-      command.append(flag)
-
-    if should_fail:
-      should_or_not = 'should'
-    else:
-      should_or_not = 'should not'
-
-    failed = not Run(command)
-
-    SetEnvVar(THROW_ON_FAILURE, None)
-
-    msg = ('when %s%s, an assertion failure in "%s" %s cause a non-zero '
-           'exit code.' %
-           (THROW_ON_FAILURE, env_var_value_msg, ' '.join(command),
-            should_or_not))
-    self.assert_(failed == should_fail, msg)
-
-  def testDefaultBehavior(self):
-    """Tests the behavior of the default mode."""
-
-    self.RunAndVerify(env_var_value=None, flag_value=None, should_fail=False)
-
-  def testThrowOnFailureEnvVar(self):
-    """Tests using the GTEST_THROW_ON_FAILURE environment variable."""
-
-    self.RunAndVerify(env_var_value='0',
-                      flag_value=None,
-                      should_fail=False)
-    self.RunAndVerify(env_var_value='1',
-                      flag_value=None,
-                      should_fail=True)
-
-  def testThrowOnFailureFlag(self):
-    """Tests using the --gtest_throw_on_failure flag."""
-
-    self.RunAndVerify(env_var_value=None,
-                      flag_value='0',
-                      should_fail=False)
-    self.RunAndVerify(env_var_value=None,
-                      flag_value='1',
-                      should_fail=True)
-
-  def testThrowOnFailureFlagOverridesEnvVar(self):
-    """Tests that --gtest_throw_on_failure overrides GTEST_THROW_ON_FAILURE."""
-
-    self.RunAndVerify(env_var_value='0',
-                      flag_value='0',
-                      should_fail=False)
-    self.RunAndVerify(env_var_value='0',
-                      flag_value='1',
-                      should_fail=True)
-    self.RunAndVerify(env_var_value='1',
-                      flag_value='0',
-                      should_fail=False)
-    self.RunAndVerify(env_var_value='1',
-                      flag_value='1',
-                      should_fail=True)
-
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test_.cc
deleted file mode 100644
index 2b88fe3d..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_throw_on_failure_test_.cc
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2009, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-// Tests Google Test's throw-on-failure mode with exceptions disabled.
-//
-// This program must be compiled with exceptions disabled.  It will be
-// invoked by gtest_throw_on_failure_test.py, and is expected to exit
-// with non-zero in the throw-on-failure mode or 0 otherwise.
-
-#include "gtest/gtest.h"
-
-#include <stdio.h>                      // for fflush, fprintf, NULL, etc.
-#include <stdlib.h>                     // for exit
-#include <exception>                    // for set_terminate
-
-// This terminate handler aborts the program using exit() rather than abort().
-// This avoids showing pop-ups on Windows systems and core dumps on Unix-like
-// ones.
-void TerminateHandler() {
-  fprintf(stderr, "%s\n", "Unhandled C++ exception terminating the program.");
-  fflush(NULL);
-  exit(1);
-}
-
-int main(int argc, char** argv) {
-#if GTEST_HAS_EXCEPTIONS
-  std::set_terminate(&TerminateHandler);
-#endif
-  testing::InitGoogleTest(&argc, argv);
-
-  // We want to ensure that people can use Google Test assertions in
-  // other testing frameworks, as long as they initialize Google Test
-  // properly and set the throw-on-failure mode.  Therefore, we don't
-  // use Google Test's constructs for defining and running tests
-  // (e.g. TEST and RUN_ALL_TESTS) here.
-
-  // In the throw-on-failure mode with exceptions disabled, this
-  // assertion will cause the program to exit with a non-zero code.
-  EXPECT_EQ(2, 3);
-
-  // When not in the throw-on-failure mode, the control will reach
-  // here.
-  return 0;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test.py
deleted file mode 100755
index 43583700..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test.py
+++ /dev/null
@@ -1,70 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-
-"""Verifies that Google Test warns the user when not initialized properly."""
-
-__author__ = 'wan@google.com (Zhanyong Wan)'
-
-import gtest_test_utils
-
-
-COMMAND = gtest_test_utils.GetTestExecutablePath('gtest_uninitialized_test_')
-
-
-def Assert(condition):
-  if not condition:
-    raise AssertionError
-
-
-def AssertEq(expected, actual):
-  if expected != actual:
-    print('Expected: %s' % (expected,))
-    print('  Actual: %s' % (actual,))
-    raise AssertionError
-
-
-def TestExitCodeAndOutput(command):
-  """Runs the given command and verifies its exit code and output."""
-
-  # Verifies that 'command' exits with code 1.
-  p = gtest_test_utils.Subprocess(command)
-  Assert(p.exited)
-  AssertEq(1, p.exit_code)
-  Assert('InitGoogleTest' in p.output)
-
-
-class GTestUninitializedTest(gtest_test_utils.TestCase):
-  def testExitCodeAndOutput(self):
-    TestExitCodeAndOutput(COMMAND)
-
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test_.cc
deleted file mode 100644
index 44316987..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_uninitialized_test_.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-// 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-
-#include "gtest/gtest.h"
-
-TEST(DummyTest, Dummy) {
-  // This test doesn't verify anything.  We just need it to create a
-  // realistic stage for testing the behavior of Google Test when
-  // RUN_ALL_TESTS() is called without testing::InitGoogleTest() being
-  // called first.
-}
-
-int main() {
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_unittest.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_unittest.cc
deleted file mode 100644
index 97fcd5a8..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_unittest.cc
+++ /dev/null
@@ -1,7706 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// Tests for Google Test itself.  This verifies that the basic constructs of
-// Google Test work.
-
-#include "gtest/gtest.h"
-
-// Verifies that the command line flag variables can be accessed
-// in code once <gtest/gtest.h> has been #included.
-// Do not move it after other #includes.
-TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
-  bool dummy = testing::GTEST_FLAG(also_run_disabled_tests)
-      || testing::GTEST_FLAG(break_on_failure)
-      || testing::GTEST_FLAG(catch_exceptions)
-      || testing::GTEST_FLAG(color) != "unknown"
-      || testing::GTEST_FLAG(filter) != "unknown"
-      || testing::GTEST_FLAG(list_tests)
-      || testing::GTEST_FLAG(output) != "unknown"
-      || testing::GTEST_FLAG(print_time)
-      || testing::GTEST_FLAG(random_seed)
-      || testing::GTEST_FLAG(repeat) > 0
-      || testing::GTEST_FLAG(show_internal_stack_frames)
-      || testing::GTEST_FLAG(shuffle)
-      || testing::GTEST_FLAG(stack_trace_depth) > 0
-      || testing::GTEST_FLAG(stream_result_to) != "unknown"
-      || testing::GTEST_FLAG(throw_on_failure);
-  EXPECT_TRUE(dummy || !dummy);  // Suppresses warning that dummy is unused.
-}
-
-#include <limits.h>  // For INT_MAX.
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#include <map>
-#include <vector>
-#include <ostream>
-
-#include "gtest/gtest-spi.h"
-
-// Indicates that this translation unit is part of Google Test's
-// implementation.  It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error.  This trick is to
-// prevent a user from accidentally including gtest-internal-inl.h in
-// his code.
-#define GTEST_IMPLEMENTATION_ 1
-#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
-
-namespace testing {
-namespace internal {
-
-#if GTEST_CAN_STREAM_RESULTS_
-
-class StreamingListenerTest : public Test {
- public:
-  class FakeSocketWriter : public StreamingListener::AbstractSocketWriter {
-   public:
-    // Sends a string to the socket.
-    virtual void Send(const string& message) { output_ += message; }
-
-    string output_;
-  };
-
-  StreamingListenerTest()
-      : fake_sock_writer_(new FakeSocketWriter),
-        streamer_(fake_sock_writer_),
-        test_info_obj_("FooTest", "Bar", NULL, NULL,
-                       CodeLocation(__FILE__, __LINE__), 0, NULL) {}
-
- protected:
-  string* output() { return &(fake_sock_writer_->output_); }
-
-  FakeSocketWriter* const fake_sock_writer_;
-  StreamingListener streamer_;
-  UnitTest unit_test_;
-  TestInfo test_info_obj_;  // The name test_info_ was taken by testing::Test.
-};
-
-TEST_F(StreamingListenerTest, OnTestProgramEnd) {
-  *output() = "";
-  streamer_.OnTestProgramEnd(unit_test_);
-  EXPECT_EQ("event=TestProgramEnd&passed=1\n", *output());
-}
-
-TEST_F(StreamingListenerTest, OnTestIterationEnd) {
-  *output() = "";
-  streamer_.OnTestIterationEnd(unit_test_, 42);
-  EXPECT_EQ("event=TestIterationEnd&passed=1&elapsed_time=0ms\n", *output());
-}
-
-TEST_F(StreamingListenerTest, OnTestCaseStart) {
-  *output() = "";
-  streamer_.OnTestCaseStart(TestCase("FooTest", "Bar", NULL, NULL));
-  EXPECT_EQ("event=TestCaseStart&name=FooTest\n", *output());
-}
-
-TEST_F(StreamingListenerTest, OnTestCaseEnd) {
-  *output() = "";
-  streamer_.OnTestCaseEnd(TestCase("FooTest", "Bar", NULL, NULL));
-  EXPECT_EQ("event=TestCaseEnd&passed=1&elapsed_time=0ms\n", *output());
-}
-
-TEST_F(StreamingListenerTest, OnTestStart) {
-  *output() = "";
-  streamer_.OnTestStart(test_info_obj_);
-  EXPECT_EQ("event=TestStart&name=Bar\n", *output());
-}
-
-TEST_F(StreamingListenerTest, OnTestEnd) {
-  *output() = "";
-  streamer_.OnTestEnd(test_info_obj_);
-  EXPECT_EQ("event=TestEnd&passed=1&elapsed_time=0ms\n", *output());
-}
-
-TEST_F(StreamingListenerTest, OnTestPartResult) {
-  *output() = "";
-  streamer_.OnTestPartResult(TestPartResult(
-      TestPartResult::kFatalFailure, "foo.cc", 42, "failed=\n&%"));
-
-  // Meta characters in the failure message should be properly escaped.
-  EXPECT_EQ(
-      "event=TestPartResult&file=foo.cc&line=42&message=failed%3D%0A%26%25\n",
-      *output());
-}
-
-#endif  // GTEST_CAN_STREAM_RESULTS_
-
-// Provides access to otherwise private parts of the TestEventListeners class
-// that are needed to test it.
-class TestEventListenersAccessor {
- public:
-  static TestEventListener* GetRepeater(TestEventListeners* listeners) {
-    return listeners->repeater();
-  }
-
-  static void SetDefaultResultPrinter(TestEventListeners* listeners,
-                                      TestEventListener* listener) {
-    listeners->SetDefaultResultPrinter(listener);
-  }
-  static void SetDefaultXmlGenerator(TestEventListeners* listeners,
-                                     TestEventListener* listener) {
-    listeners->SetDefaultXmlGenerator(listener);
-  }
-
-  static bool EventForwardingEnabled(const TestEventListeners& listeners) {
-    return listeners.EventForwardingEnabled();
-  }
-
-  static void SuppressEventForwarding(TestEventListeners* listeners) {
-    listeners->SuppressEventForwarding();
-  }
-};
-
-class UnitTestRecordPropertyTestHelper : public Test {
- protected:
-  UnitTestRecordPropertyTestHelper() {}
-
-  // Forwards to UnitTest::RecordProperty() to bypass access controls.
-  void UnitTestRecordProperty(const char* key, const std::string& value) {
-    unit_test_.RecordProperty(key, value);
-  }
-
-  UnitTest unit_test_;
-};
-
-}  // namespace internal
-}  // namespace testing
-
-using testing::AssertionFailure;
-using testing::AssertionResult;
-using testing::AssertionSuccess;
-using testing::DoubleLE;
-using testing::EmptyTestEventListener;
-using testing::Environment;
-using testing::FloatLE;
-using testing::GTEST_FLAG(also_run_disabled_tests);
-using testing::GTEST_FLAG(break_on_failure);
-using testing::GTEST_FLAG(catch_exceptions);
-using testing::GTEST_FLAG(color);
-using testing::GTEST_FLAG(death_test_use_fork);
-using testing::GTEST_FLAG(filter);
-using testing::GTEST_FLAG(list_tests);
-using testing::GTEST_FLAG(output);
-using testing::GTEST_FLAG(print_time);
-using testing::GTEST_FLAG(random_seed);
-using testing::GTEST_FLAG(repeat);
-using testing::GTEST_FLAG(show_internal_stack_frames);
-using testing::GTEST_FLAG(shuffle);
-using testing::GTEST_FLAG(stack_trace_depth);
-using testing::GTEST_FLAG(stream_result_to);
-using testing::GTEST_FLAG(throw_on_failure);
-using testing::IsNotSubstring;
-using testing::IsSubstring;
-using testing::Message;
-using testing::ScopedFakeTestPartResultReporter;
-using testing::StaticAssertTypeEq;
-using testing::Test;
-using testing::TestCase;
-using testing::TestEventListeners;
-using testing::TestInfo;
-using testing::TestPartResult;
-using testing::TestPartResultArray;
-using testing::TestProperty;
-using testing::TestResult;
-using testing::TimeInMillis;
-using testing::UnitTest;
-using testing::internal::AddReference;
-using testing::internal::AlwaysFalse;
-using testing::internal::AlwaysTrue;
-using testing::internal::AppendUserMessage;
-using testing::internal::ArrayAwareFind;
-using testing::internal::ArrayEq;
-using testing::internal::CodePointToUtf8;
-using testing::internal::CompileAssertTypesEqual;
-using testing::internal::CopyArray;
-using testing::internal::CountIf;
-using testing::internal::EqFailure;
-using testing::internal::FloatingPoint;
-using testing::internal::ForEach;
-using testing::internal::FormatEpochTimeInMillisAsIso8601;
-using testing::internal::FormatTimeInMillisAsSeconds;
-using testing::internal::GTestFlagSaver;
-using testing::internal::GetCurrentOsStackTraceExceptTop;
-using testing::internal::GetElementOr;
-using testing::internal::GetNextRandomSeed;
-using testing::internal::GetRandomSeedFromFlag;
-using testing::internal::GetTestTypeId;
-using testing::internal::GetTimeInMillis;
-using testing::internal::GetTypeId;
-using testing::internal::GetUnitTestImpl;
-using testing::internal::ImplicitlyConvertible;
-using testing::internal::Int32;
-using testing::internal::Int32FromEnvOrDie;
-using testing::internal::IsAProtocolMessage;
-using testing::internal::IsContainer;
-using testing::internal::IsContainerTest;
-using testing::internal::IsNotContainer;
-using testing::internal::NativeArray;
-using testing::internal::ParseInt32Flag;
-using testing::internal::RelationToSourceCopy;
-using testing::internal::RelationToSourceReference;
-using testing::internal::RemoveConst;
-using testing::internal::RemoveReference;
-using testing::internal::ShouldRunTestOnShard;
-using testing::internal::ShouldShard;
-using testing::internal::ShouldUseColor;
-using testing::internal::Shuffle;
-using testing::internal::ShuffleRange;
-using testing::internal::SkipPrefix;
-using testing::internal::StreamableToString;
-using testing::internal::String;
-using testing::internal::TestEventListenersAccessor;
-using testing::internal::TestResultAccessor;
-using testing::internal::UInt32;
-using testing::internal::WideStringToUtf8;
-using testing::internal::edit_distance::CalculateOptimalEdits;
-using testing::internal::edit_distance::CreateUnifiedDiff;
-using testing::internal::edit_distance::EditType;
-using testing::internal::kMaxRandomSeed;
-using testing::internal::kTestTypeIdInGoogleTest;
-using testing::kMaxStackTraceDepth;
-
-#if GTEST_HAS_STREAM_REDIRECTION
-using testing::internal::CaptureStdout;
-using testing::internal::GetCapturedStdout;
-#endif
-
-#if GTEST_IS_THREADSAFE
-using testing::internal::ThreadWithParam;
-#endif
-
-class TestingVector : public std::vector<int> {
-};
-
-::std::ostream& operator<<(::std::ostream& os,
-                           const TestingVector& vector) {
-  os << "{ ";
-  for (size_t i = 0; i < vector.size(); i++) {
-    os << vector[i] << " ";
-  }
-  os << "}";
-  return os;
-}
-
-// This line tests that we can define tests in an unnamed namespace.
-namespace {
-
-TEST(GetRandomSeedFromFlagTest, HandlesZero) {
-  const int seed = GetRandomSeedFromFlag(0);
-  EXPECT_LE(1, seed);
-  EXPECT_LE(seed, static_cast<int>(kMaxRandomSeed));
-}
-
-TEST(GetRandomSeedFromFlagTest, PreservesValidSeed) {
-  EXPECT_EQ(1, GetRandomSeedFromFlag(1));
-  EXPECT_EQ(2, GetRandomSeedFromFlag(2));
-  EXPECT_EQ(kMaxRandomSeed - 1, GetRandomSeedFromFlag(kMaxRandomSeed - 1));
-  EXPECT_EQ(static_cast<int>(kMaxRandomSeed),
-            GetRandomSeedFromFlag(kMaxRandomSeed));
-}
-
-TEST(GetRandomSeedFromFlagTest, NormalizesInvalidSeed) {
-  const int seed1 = GetRandomSeedFromFlag(-1);
-  EXPECT_LE(1, seed1);
-  EXPECT_LE(seed1, static_cast<int>(kMaxRandomSeed));
-
-  const int seed2 = GetRandomSeedFromFlag(kMaxRandomSeed + 1);
-  EXPECT_LE(1, seed2);
-  EXPECT_LE(seed2, static_cast<int>(kMaxRandomSeed));
-}
-
-TEST(GetNextRandomSeedTest, WorksForValidInput) {
-  EXPECT_EQ(2, GetNextRandomSeed(1));
-  EXPECT_EQ(3, GetNextRandomSeed(2));
-  EXPECT_EQ(static_cast<int>(kMaxRandomSeed),
-            GetNextRandomSeed(kMaxRandomSeed - 1));
-  EXPECT_EQ(1, GetNextRandomSeed(kMaxRandomSeed));
-
-  // We deliberately don't test GetNextRandomSeed() with invalid
-  // inputs, as that requires death tests, which are expensive.  This
-  // is fine as GetNextRandomSeed() is internal and has a
-  // straightforward definition.
-}
-
-static void ClearCurrentTestPartResults() {
-  TestResultAccessor::ClearTestPartResults(
-      GetUnitTestImpl()->current_test_result());
-}
-
-// Tests GetTypeId.
-
-TEST(GetTypeIdTest, ReturnsSameValueForSameType) {
-  EXPECT_EQ(GetTypeId<int>(), GetTypeId<int>());
-  EXPECT_EQ(GetTypeId<Test>(), GetTypeId<Test>());
-}
-
-class SubClassOfTest : public Test {};
-class AnotherSubClassOfTest : public Test {};
-
-TEST(GetTypeIdTest, ReturnsDifferentValuesForDifferentTypes) {
-  EXPECT_NE(GetTypeId<int>(), GetTypeId<const int>());
-  EXPECT_NE(GetTypeId<int>(), GetTypeId<char>());
-  EXPECT_NE(GetTypeId<int>(), GetTestTypeId());
-  EXPECT_NE(GetTypeId<SubClassOfTest>(), GetTestTypeId());
-  EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTestTypeId());
-  EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTypeId<SubClassOfTest>());
-}
-
-// Verifies that GetTestTypeId() returns the same value, no matter it
-// is called from inside Google Test or outside of it.
-TEST(GetTestTypeIdTest, ReturnsTheSameValueInsideOrOutsideOfGoogleTest) {
-  EXPECT_EQ(kTestTypeIdInGoogleTest, GetTestTypeId());
-}
-
-// Tests FormatTimeInMillisAsSeconds().
-
-TEST(FormatTimeInMillisAsSecondsTest, FormatsZero) {
-  EXPECT_EQ("0", FormatTimeInMillisAsSeconds(0));
-}
-
-TEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) {
-  EXPECT_EQ("0.003", FormatTimeInMillisAsSeconds(3));
-  EXPECT_EQ("0.01", FormatTimeInMillisAsSeconds(10));
-  EXPECT_EQ("0.2", FormatTimeInMillisAsSeconds(200));
-  EXPECT_EQ("1.2", FormatTimeInMillisAsSeconds(1200));
-  EXPECT_EQ("3", FormatTimeInMillisAsSeconds(3000));
-}
-
-TEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) {
-  EXPECT_EQ("-0.003", FormatTimeInMillisAsSeconds(-3));
-  EXPECT_EQ("-0.01", FormatTimeInMillisAsSeconds(-10));
-  EXPECT_EQ("-0.2", FormatTimeInMillisAsSeconds(-200));
-  EXPECT_EQ("-1.2", FormatTimeInMillisAsSeconds(-1200));
-  EXPECT_EQ("-3", FormatTimeInMillisAsSeconds(-3000));
-}
-
-// Tests FormatEpochTimeInMillisAsIso8601().  The correctness of conversion
-// for particular dates below was verified in Python using
-// datetime.datetime.fromutctimestamp(<timetamp>/1000).
-
-// FormatEpochTimeInMillisAsIso8601 depends on the current timezone, so we
-// have to set up a particular timezone to obtain predictable results.
-class FormatEpochTimeInMillisAsIso8601Test : public Test {
- public:
-  // On Cygwin, GCC doesn't allow unqualified integer literals to exceed
-  // 32 bits, even when 64-bit integer types are available.  We have to
-  // force the constants to have a 64-bit type here.
-  static const TimeInMillis kMillisPerSec = 1000;
-
- private:
-  virtual void SetUp() {
-    saved_tz_ = NULL;
-
-    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* getenv, strdup: deprecated */)
-    if (getenv("TZ"))
-      saved_tz_ = strdup(getenv("TZ"));
-    GTEST_DISABLE_MSC_WARNINGS_POP_()
-
-    // Set up the time zone for FormatEpochTimeInMillisAsIso8601 to use.  We
-    // cannot use the local time zone because the function's output depends
-    // on the time zone.
-    SetTimeZone("UTC+00");
-  }
-
-  virtual void TearDown() {
-    SetTimeZone(saved_tz_);
-    free(const_cast<char*>(saved_tz_));
-    saved_tz_ = NULL;
-  }
-
-  static void SetTimeZone(const char* time_zone) {
-    // tzset() distinguishes between the TZ variable being present and empty
-    // and not being present, so we have to consider the case of time_zone
-    // being NULL.
-#if _MSC_VER || GTEST_OS_WINDOWS_MINGW
-    // ...Unless it's MSVC, whose standard library's _putenv doesn't
-    // distinguish between an empty and a missing variable.
-    const std::string env_var =
-        std::string("TZ=") + (time_zone ? time_zone : "");
-    _putenv(env_var.c_str());
-    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */)
-    tzset();
-    GTEST_DISABLE_MSC_WARNINGS_POP_()
-#else
-    if (time_zone) {
-      setenv(("TZ"), time_zone, 1);
-    } else {
-      unsetenv("TZ");
-    }
-    tzset();
-#endif
-  }
-
-  const char* saved_tz_;
-};
-
-const TimeInMillis FormatEpochTimeInMillisAsIso8601Test::kMillisPerSec;
-
-TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsTwoDigitSegments) {
-  EXPECT_EQ("2011-10-31T18:52:42",
-            FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec));
-}
-
-TEST_F(FormatEpochTimeInMillisAsIso8601Test, MillisecondsDoNotAffectResult) {
-  EXPECT_EQ(
-      "2011-10-31T18:52:42",
-      FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec + 234));
-}
-
-TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsLeadingZeroes) {
-  EXPECT_EQ("2011-09-03T05:07:02",
-            FormatEpochTimeInMillisAsIso8601(1315026422 * kMillisPerSec));
-}
-
-TEST_F(FormatEpochTimeInMillisAsIso8601Test, Prints24HourTime) {
-  EXPECT_EQ("2011-09-28T17:08:22",
-            FormatEpochTimeInMillisAsIso8601(1317229702 * kMillisPerSec));
-}
-
-TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsEpochStart) {
-  EXPECT_EQ("1970-01-01T00:00:00", FormatEpochTimeInMillisAsIso8601(0));
-}
-
-#if GTEST_CAN_COMPARE_NULL
-
-# ifdef __BORLANDC__
-// Silences warnings: "Condition is always true", "Unreachable code"
-#  pragma option push -w-ccc -w-rch
-# endif
-
-// Tests that GTEST_IS_NULL_LITERAL_(x) is true when x is a null
-// pointer literal.
-TEST(NullLiteralTest, IsTrueForNullLiterals) {
-  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(NULL));
-  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0));
-  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0U));
-  EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0L));
-}
-
-// Tests that GTEST_IS_NULL_LITERAL_(x) is false when x is not a null
-// pointer literal.
-TEST(NullLiteralTest, IsFalseForNonNullLiterals) {
-  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(1));
-  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(0.0));
-  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_('a'));
-  EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(static_cast<void*>(NULL)));
-}
-
-# ifdef __BORLANDC__
-// Restores warnings after previous "#pragma option push" suppressed them.
-#  pragma option pop
-# endif
-
-#endif  // GTEST_CAN_COMPARE_NULL
-//
-// Tests CodePointToUtf8().
-
-// Tests that the NUL character L'\0' is encoded correctly.
-TEST(CodePointToUtf8Test, CanEncodeNul) {
-  EXPECT_EQ("", CodePointToUtf8(L'\0'));
-}
-
-// Tests that ASCII characters are encoded correctly.
-TEST(CodePointToUtf8Test, CanEncodeAscii) {
-  EXPECT_EQ("a", CodePointToUtf8(L'a'));
-  EXPECT_EQ("Z", CodePointToUtf8(L'Z'));
-  EXPECT_EQ("&", CodePointToUtf8(L'&'));
-  EXPECT_EQ("\x7F", CodePointToUtf8(L'\x7F'));
-}
-
-// Tests that Unicode code-points that have 8 to 11 bits are encoded
-// as 110xxxxx 10xxxxxx.
-TEST(CodePointToUtf8Test, CanEncode8To11Bits) {
-  // 000 1101 0011 => 110-00011 10-010011
-  EXPECT_EQ("\xC3\x93", CodePointToUtf8(L'\xD3'));
-
-  // 101 0111 0110 => 110-10101 10-110110
-  // Some compilers (e.g., GCC on MinGW) cannot handle non-ASCII codepoints
-  // in wide strings and wide chars. In order to accomodate them, we have to
-  // introduce such character constants as integers.
-  EXPECT_EQ("\xD5\xB6",
-            CodePointToUtf8(static_cast<wchar_t>(0x576)));
-}
-
-// Tests that Unicode code-points that have 12 to 16 bits are encoded
-// as 1110xxxx 10xxxxxx 10xxxxxx.
-TEST(CodePointToUtf8Test, CanEncode12To16Bits) {
-  // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
-  EXPECT_EQ("\xE0\xA3\x93",
-            CodePointToUtf8(static_cast<wchar_t>(0x8D3)));
-
-  // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
-  EXPECT_EQ("\xEC\x9D\x8D",
-            CodePointToUtf8(static_cast<wchar_t>(0xC74D)));
-}
-
-#if !GTEST_WIDE_STRING_USES_UTF16_
-// Tests in this group require a wchar_t to hold > 16 bits, and thus
-// are skipped on Windows, Cygwin, and Symbian, where a wchar_t is
-// 16-bit wide. This code may not compile on those systems.
-
-// Tests that Unicode code-points that have 17 to 21 bits are encoded
-// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx.
-TEST(CodePointToUtf8Test, CanEncode17To21Bits) {
-  // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011
-  EXPECT_EQ("\xF0\x90\xA3\x93", CodePointToUtf8(L'\x108D3'));
-
-  // 0 0001 0000 0100 0000 0000 => 11110-000 10-010000 10-010000 10-000000
-  EXPECT_EQ("\xF0\x90\x90\x80", CodePointToUtf8(L'\x10400'));
-
-  // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100
-  EXPECT_EQ("\xF4\x88\x98\xB4", CodePointToUtf8(L'\x108634'));
-}
-
-// Tests that encoding an invalid code-point generates the expected result.
-TEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) {
-  EXPECT_EQ("(Invalid Unicode 0x1234ABCD)", CodePointToUtf8(L'\x1234ABCD'));
-}
-
-#endif  // !GTEST_WIDE_STRING_USES_UTF16_
-
-// Tests WideStringToUtf8().
-
-// Tests that the NUL character L'\0' is encoded correctly.
-TEST(WideStringToUtf8Test, CanEncodeNul) {
-  EXPECT_STREQ("", WideStringToUtf8(L"", 0).c_str());
-  EXPECT_STREQ("", WideStringToUtf8(L"", -1).c_str());
-}
-
-// Tests that ASCII strings are encoded correctly.
-TEST(WideStringToUtf8Test, CanEncodeAscii) {
-  EXPECT_STREQ("a", WideStringToUtf8(L"a", 1).c_str());
-  EXPECT_STREQ("ab", WideStringToUtf8(L"ab", 2).c_str());
-  EXPECT_STREQ("a", WideStringToUtf8(L"a", -1).c_str());
-  EXPECT_STREQ("ab", WideStringToUtf8(L"ab", -1).c_str());
-}
-
-// Tests that Unicode code-points that have 8 to 11 bits are encoded
-// as 110xxxxx 10xxxxxx.
-TEST(WideStringToUtf8Test, CanEncode8To11Bits) {
-  // 000 1101 0011 => 110-00011 10-010011
-  EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", 1).c_str());
-  EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str());
-
-  // 101 0111 0110 => 110-10101 10-110110
-  const wchar_t s[] = { 0x576, '\0' };
-  EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, 1).c_str());
-  EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, -1).c_str());
-}
-
-// Tests that Unicode code-points that have 12 to 16 bits are encoded
-// as 1110xxxx 10xxxxxx 10xxxxxx.
-TEST(WideStringToUtf8Test, CanEncode12To16Bits) {
-  // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
-  const wchar_t s1[] = { 0x8D3, '\0' };
-  EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, 1).c_str());
-  EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, -1).c_str());
-
-  // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
-  const wchar_t s2[] = { 0xC74D, '\0' };
-  EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, 1).c_str());
-  EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, -1).c_str());
-}
-
-// Tests that the conversion stops when the function encounters \0 character.
-TEST(WideStringToUtf8Test, StopsOnNulCharacter) {
-  EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str());
-}
-
-// Tests that the conversion stops when the function reaches the limit
-// specified by the 'length' parameter.
-TEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) {
-  EXPECT_STREQ("ABC", WideStringToUtf8(L"ABCDEF", 3).c_str());
-}
-
-#if !GTEST_WIDE_STRING_USES_UTF16_
-// Tests that Unicode code-points that have 17 to 21 bits are encoded
-// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. This code may not compile
-// on the systems using UTF-16 encoding.
-TEST(WideStringToUtf8Test, CanEncode17To21Bits) {
-  // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011
-  EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", 1).c_str());
-  EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", -1).c_str());
-
-  // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100
-  EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", 1).c_str());
-  EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", -1).c_str());
-}
-
-// Tests that encoding an invalid code-point generates the expected result.
-TEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) {
-  EXPECT_STREQ("(Invalid Unicode 0xABCDFF)",
-               WideStringToUtf8(L"\xABCDFF", -1).c_str());
-}
-#else  // !GTEST_WIDE_STRING_USES_UTF16_
-// Tests that surrogate pairs are encoded correctly on the systems using
-// UTF-16 encoding in the wide strings.
-TEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) {
-  const wchar_t s[] = { 0xD801, 0xDC00, '\0' };
-  EXPECT_STREQ("\xF0\x90\x90\x80", WideStringToUtf8(s, -1).c_str());
-}
-
-// Tests that encoding an invalid UTF-16 surrogate pair
-// generates the expected result.
-TEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) {
-  // Leading surrogate is at the end of the string.
-  const wchar_t s1[] = { 0xD800, '\0' };
-  EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(s1, -1).c_str());
-  // Leading surrogate is not followed by the trailing surrogate.
-  const wchar_t s2[] = { 0xD800, 'M', '\0' };
-  EXPECT_STREQ("\xED\xA0\x80M", WideStringToUtf8(s2, -1).c_str());
-  // Trailing surrogate appearas without a leading surrogate.
-  const wchar_t s3[] = { 0xDC00, 'P', 'Q', 'R', '\0' };
-  EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(s3, -1).c_str());
-}
-#endif  // !GTEST_WIDE_STRING_USES_UTF16_
-
-// Tests that codepoint concatenation works correctly.
-#if !GTEST_WIDE_STRING_USES_UTF16_
-TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
-  const wchar_t s[] = { 0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'};
-  EXPECT_STREQ(
-      "\xF4\x88\x98\xB4"
-          "\xEC\x9D\x8D"
-          "\n"
-          "\xD5\xB6"
-          "\xE0\xA3\x93"
-          "\xF4\x88\x98\xB4",
-      WideStringToUtf8(s, -1).c_str());
-}
-#else
-TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
-  const wchar_t s[] = { 0xC74D, '\n', 0x576, 0x8D3, '\0'};
-  EXPECT_STREQ(
-      "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93",
-      WideStringToUtf8(s, -1).c_str());
-}
-#endif  // !GTEST_WIDE_STRING_USES_UTF16_
-
-// Tests the Random class.
-
-TEST(RandomDeathTest, GeneratesCrashesOnInvalidRange) {
-  testing::internal::Random random(42);
-  EXPECT_DEATH_IF_SUPPORTED(
-      random.Generate(0),
-      "Cannot generate a number in the range \\[0, 0\\)");
-  EXPECT_DEATH_IF_SUPPORTED(
-      random.Generate(testing::internal::Random::kMaxRange + 1),
-      "Generation of a number in \\[0, 2147483649\\) was requested, "
-      "but this can only generate numbers in \\[0, 2147483648\\)");
-}
-
-TEST(RandomTest, GeneratesNumbersWithinRange) {
-  const UInt32 kRange = 10000;
-  testing::internal::Random random(12345);
-  for (int i = 0; i < 10; i++) {
-    EXPECT_LT(random.Generate(kRange), kRange) << " for iteration " << i;
-  }
-
-  testing::internal::Random random2(testing::internal::Random::kMaxRange);
-  for (int i = 0; i < 10; i++) {
-    EXPECT_LT(random2.Generate(kRange), kRange) << " for iteration " << i;
-  }
-}
-
-TEST(RandomTest, RepeatsWhenReseeded) {
-  const int kSeed = 123;
-  const int kArraySize = 10;
-  const UInt32 kRange = 10000;
-  UInt32 values[kArraySize];
-
-  testing::internal::Random random(kSeed);
-  for (int i = 0; i < kArraySize; i++) {
-    values[i] = random.Generate(kRange);
-  }
-
-  random.Reseed(kSeed);
-  for (int i = 0; i < kArraySize; i++) {
-    EXPECT_EQ(values[i], random.Generate(kRange)) << " for iteration " << i;
-  }
-}
-
-// Tests STL container utilities.
-
-// Tests CountIf().
-
-static bool IsPositive(int n) { return n > 0; }
-
-TEST(ContainerUtilityTest, CountIf) {
-  std::vector<int> v;
-  EXPECT_EQ(0, CountIf(v, IsPositive));  // Works for an empty container.
-
-  v.push_back(-1);
-  v.push_back(0);
-  EXPECT_EQ(0, CountIf(v, IsPositive));  // Works when no value satisfies.
-
-  v.push_back(2);
-  v.push_back(-10);
-  v.push_back(10);
-  EXPECT_EQ(2, CountIf(v, IsPositive));
-}
-
-// Tests ForEach().
-
-static int g_sum = 0;
-static void Accumulate(int n) { g_sum += n; }
-
-TEST(ContainerUtilityTest, ForEach) {
-  std::vector<int> v;
-  g_sum = 0;
-  ForEach(v, Accumulate);
-  EXPECT_EQ(0, g_sum);  // Works for an empty container;
-
-  g_sum = 0;
-  v.push_back(1);
-  ForEach(v, Accumulate);
-  EXPECT_EQ(1, g_sum);  // Works for a container with one element.
-
-  g_sum = 0;
-  v.push_back(20);
-  v.push_back(300);
-  ForEach(v, Accumulate);
-  EXPECT_EQ(321, g_sum);
-}
-
-// Tests GetElementOr().
-TEST(ContainerUtilityTest, GetElementOr) {
-  std::vector<char> a;
-  EXPECT_EQ('x', GetElementOr(a, 0, 'x'));
-
-  a.push_back('a');
-  a.push_back('b');
-  EXPECT_EQ('a', GetElementOr(a, 0, 'x'));
-  EXPECT_EQ('b', GetElementOr(a, 1, 'x'));
-  EXPECT_EQ('x', GetElementOr(a, -2, 'x'));
-  EXPECT_EQ('x', GetElementOr(a, 2, 'x'));
-}
-
-TEST(ContainerUtilityDeathTest, ShuffleRange) {
-  std::vector<int> a;
-  a.push_back(0);
-  a.push_back(1);
-  a.push_back(2);
-  testing::internal::Random random(1);
-
-  EXPECT_DEATH_IF_SUPPORTED(
-      ShuffleRange(&random, -1, 1, &a),
-      "Invalid shuffle range start -1: must be in range \\[0, 3\\]");
-  EXPECT_DEATH_IF_SUPPORTED(
-      ShuffleRange(&random, 4, 4, &a),
-      "Invalid shuffle range start 4: must be in range \\[0, 3\\]");
-  EXPECT_DEATH_IF_SUPPORTED(
-      ShuffleRange(&random, 3, 2, &a),
-      "Invalid shuffle range finish 2: must be in range \\[3, 3\\]");
-  EXPECT_DEATH_IF_SUPPORTED(
-      ShuffleRange(&random, 3, 4, &a),
-      "Invalid shuffle range finish 4: must be in range \\[3, 3\\]");
-}
-
-class VectorShuffleTest : public Test {
- protected:
-  static const int kVectorSize = 20;
-
-  VectorShuffleTest() : random_(1) {
-    for (int i = 0; i < kVectorSize; i++) {
-      vector_.push_back(i);
-    }
-  }
-
-  static bool VectorIsCorrupt(const TestingVector& vector) {
-    if (kVectorSize != static_cast<int>(vector.size())) {
-      return true;
-    }
-
-    bool found_in_vector[kVectorSize] = { false };
-    for (size_t i = 0; i < vector.size(); i++) {
-      const int e = vector[i];
-      if (e < 0 || e >= kVectorSize || found_in_vector[e]) {
-        return true;
-      }
-      found_in_vector[e] = true;
-    }
-
-    // Vector size is correct, elements' range is correct, no
-    // duplicate elements.  Therefore no corruption has occurred.
-    return false;
-  }
-
-  static bool VectorIsNotCorrupt(const TestingVector& vector) {
-    return !VectorIsCorrupt(vector);
-  }
-
-  static bool RangeIsShuffled(const TestingVector& vector, int begin, int end) {
-    for (int i = begin; i < end; i++) {
-      if (i != vector[i]) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  static bool RangeIsUnshuffled(
-      const TestingVector& vector, int begin, int end) {
-    return !RangeIsShuffled(vector, begin, end);
-  }
-
-  static bool VectorIsShuffled(const TestingVector& vector) {
-    return RangeIsShuffled(vector, 0, static_cast<int>(vector.size()));
-  }
-
-  static bool VectorIsUnshuffled(const TestingVector& vector) {
-    return !VectorIsShuffled(vector);
-  }
-
-  testing::internal::Random random_;
-  TestingVector vector_;
-};  // class VectorShuffleTest
-
-const int VectorShuffleTest::kVectorSize;
-
-TEST_F(VectorShuffleTest, HandlesEmptyRange) {
-  // Tests an empty range at the beginning...
-  ShuffleRange(&random_, 0, 0, &vector_);
-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
-  ASSERT_PRED1(VectorIsUnshuffled, vector_);
-
-  // ...in the middle...
-  ShuffleRange(&random_, kVectorSize/2, kVectorSize/2, &vector_);
-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
-  ASSERT_PRED1(VectorIsUnshuffled, vector_);
-
-  // ...at the end...
-  ShuffleRange(&random_, kVectorSize - 1, kVectorSize - 1, &vector_);
-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
-  ASSERT_PRED1(VectorIsUnshuffled, vector_);
-
-  // ...and past the end.
-  ShuffleRange(&random_, kVectorSize, kVectorSize, &vector_);
-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
-  ASSERT_PRED1(VectorIsUnshuffled, vector_);
-}
-
-TEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) {
-  // Tests a size one range at the beginning...
-  ShuffleRange(&random_, 0, 1, &vector_);
-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
-  ASSERT_PRED1(VectorIsUnshuffled, vector_);
-
-  // ...in the middle...
-  ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1, &vector_);
-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
-  ASSERT_PRED1(VectorIsUnshuffled, vector_);
-
-  // ...and at the end.
-  ShuffleRange(&random_, kVectorSize - 1, kVectorSize, &vector_);
-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
-  ASSERT_PRED1(VectorIsUnshuffled, vector_);
-}
-
-// Because we use our own random number generator and a fixed seed,
-// we can guarantee that the following "random" tests will succeed.
-
-TEST_F(VectorShuffleTest, ShufflesEntireVector) {
-  Shuffle(&random_, &vector_);
-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
-  EXPECT_FALSE(VectorIsUnshuffled(vector_)) << vector_;
-
-  // Tests the first and last elements in particular to ensure that
-  // there are no off-by-one problems in our shuffle algorithm.
-  EXPECT_NE(0, vector_[0]);
-  EXPECT_NE(kVectorSize - 1, vector_[kVectorSize - 1]);
-}
-
-TEST_F(VectorShuffleTest, ShufflesStartOfVector) {
-  const int kRangeSize = kVectorSize/2;
-
-  ShuffleRange(&random_, 0, kRangeSize, &vector_);
-
-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
-  EXPECT_PRED3(RangeIsShuffled, vector_, 0, kRangeSize);
-  EXPECT_PRED3(RangeIsUnshuffled, vector_, kRangeSize, kVectorSize);
-}
-
-TEST_F(VectorShuffleTest, ShufflesEndOfVector) {
-  const int kRangeSize = kVectorSize / 2;
-  ShuffleRange(&random_, kRangeSize, kVectorSize, &vector_);
-
-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
-  EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
-  EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, kVectorSize);
-}
-
-TEST_F(VectorShuffleTest, ShufflesMiddleOfVector) {
-  int kRangeSize = kVectorSize/3;
-  ShuffleRange(&random_, kRangeSize, 2*kRangeSize, &vector_);
-
-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
-  EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
-  EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2*kRangeSize);
-  EXPECT_PRED3(RangeIsUnshuffled, vector_, 2*kRangeSize, kVectorSize);
-}
-
-TEST_F(VectorShuffleTest, ShufflesRepeatably) {
-  TestingVector vector2;
-  for (int i = 0; i < kVectorSize; i++) {
-    vector2.push_back(i);
-  }
-
-  random_.Reseed(1234);
-  Shuffle(&random_, &vector_);
-  random_.Reseed(1234);
-  Shuffle(&random_, &vector2);
-
-  ASSERT_PRED1(VectorIsNotCorrupt, vector_);
-  ASSERT_PRED1(VectorIsNotCorrupt, vector2);
-
-  for (int i = 0; i < kVectorSize; i++) {
-    EXPECT_EQ(vector_[i], vector2[i]) << " where i is " << i;
-  }
-}
-
-// Tests the size of the AssertHelper class.
-
-TEST(AssertHelperTest, AssertHelperIsSmall) {
-  // To avoid breaking clients that use lots of assertions in one
-  // function, we cannot grow the size of AssertHelper.
-  EXPECT_LE(sizeof(testing::internal::AssertHelper), sizeof(void*));
-}
-
-// Tests String::EndsWithCaseInsensitive().
-TEST(StringTest, EndsWithCaseInsensitive) {
-  EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", "BAR"));
-  EXPECT_TRUE(String::EndsWithCaseInsensitive("foobaR", "bar"));
-  EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", ""));
-  EXPECT_TRUE(String::EndsWithCaseInsensitive("", ""));
-
-  EXPECT_FALSE(String::EndsWithCaseInsensitive("Foobar", "foo"));
-  EXPECT_FALSE(String::EndsWithCaseInsensitive("foobar", "Foo"));
-  EXPECT_FALSE(String::EndsWithCaseInsensitive("", "foo"));
-}
-
-// C++Builder's preprocessor is buggy; it fails to expand macros that
-// appear in macro parameters after wide char literals.  Provide an alias
-// for NULL as a workaround.
-static const wchar_t* const kNull = NULL;
-
-// Tests String::CaseInsensitiveWideCStringEquals
-TEST(StringTest, CaseInsensitiveWideCStringEquals) {
-  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(NULL, NULL));
-  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L""));
-  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"", kNull));
-  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"foobar"));
-  EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"foobar", kNull));
-  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"foobar"));
-  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"FOOBAR"));
-  EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar"));
-}
-
-#if GTEST_OS_WINDOWS
-
-// Tests String::ShowWideCString().
-TEST(StringTest, ShowWideCString) {
-  EXPECT_STREQ("(null)",
-               String::ShowWideCString(NULL).c_str());
-  EXPECT_STREQ("", String::ShowWideCString(L"").c_str());
-  EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str());
-}
-
-# if GTEST_OS_WINDOWS_MOBILE
-TEST(StringTest, AnsiAndUtf16Null) {
-  EXPECT_EQ(NULL, String::AnsiToUtf16(NULL));
-  EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL));
-}
-
-TEST(StringTest, AnsiAndUtf16ConvertBasic) {
-  const char* ansi = String::Utf16ToAnsi(L"str");
-  EXPECT_STREQ("str", ansi);
-  delete [] ansi;
-  const WCHAR* utf16 = String::AnsiToUtf16("str");
-  EXPECT_EQ(0, wcsncmp(L"str", utf16, 3));
-  delete [] utf16;
-}
-
-TEST(StringTest, AnsiAndUtf16ConvertPathChars) {
-  const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?");
-  EXPECT_STREQ(".:\\ \"*?", ansi);
-  delete [] ansi;
-  const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?");
-  EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3));
-  delete [] utf16;
-}
-# endif  // GTEST_OS_WINDOWS_MOBILE
-
-#endif  // GTEST_OS_WINDOWS
-
-// Tests TestProperty construction.
-TEST(TestPropertyTest, StringValue) {
-  TestProperty property("key", "1");
-  EXPECT_STREQ("key", property.key());
-  EXPECT_STREQ("1", property.value());
-}
-
-// Tests TestProperty replacing a value.
-TEST(TestPropertyTest, ReplaceStringValue) {
-  TestProperty property("key", "1");
-  EXPECT_STREQ("1", property.value());
-  property.SetValue("2");
-  EXPECT_STREQ("2", property.value());
-}
-
-// AddFatalFailure() and AddNonfatalFailure() must be stand-alone
-// functions (i.e. their definitions cannot be inlined at the call
-// sites), or C++Builder won't compile the code.
-static void AddFatalFailure() {
-  FAIL() << "Expected fatal failure.";
-}
-
-static void AddNonfatalFailure() {
-  ADD_FAILURE() << "Expected non-fatal failure.";
-}
-
-class ScopedFakeTestPartResultReporterTest : public Test {
- public:  // Must be public and not protected due to a bug in g++ 3.4.2.
-  enum FailureMode {
-    FATAL_FAILURE,
-    NONFATAL_FAILURE
-  };
-  static void AddFailure(FailureMode failure) {
-    if (failure == FATAL_FAILURE) {
-      AddFatalFailure();
-    } else {
-      AddNonfatalFailure();
-    }
-  }
-};
-
-// Tests that ScopedFakeTestPartResultReporter intercepts test
-// failures.
-TEST_F(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) {
-  TestPartResultArray results;
-  {
-    ScopedFakeTestPartResultReporter reporter(
-        ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD,
-        &results);
-    AddFailure(NONFATAL_FAILURE);
-    AddFailure(FATAL_FAILURE);
-  }
-
-  EXPECT_EQ(2, results.size());
-  EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed());
-  EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed());
-}
-
-TEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) {
-  TestPartResultArray results;
-  {
-    // Tests, that the deprecated constructor still works.
-    ScopedFakeTestPartResultReporter reporter(&results);
-    AddFailure(NONFATAL_FAILURE);
-  }
-  EXPECT_EQ(1, results.size());
-}
-
-#if GTEST_IS_THREADSAFE
-
-class ScopedFakeTestPartResultReporterWithThreadsTest
-  : public ScopedFakeTestPartResultReporterTest {
- protected:
-  static void AddFailureInOtherThread(FailureMode failure) {
-    ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL);
-    thread.Join();
-  }
-};
-
-TEST_F(ScopedFakeTestPartResultReporterWithThreadsTest,
-       InterceptsTestFailuresInAllThreads) {
-  TestPartResultArray results;
-  {
-    ScopedFakeTestPartResultReporter reporter(
-        ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, &results);
-    AddFailure(NONFATAL_FAILURE);
-    AddFailure(FATAL_FAILURE);
-    AddFailureInOtherThread(NONFATAL_FAILURE);
-    AddFailureInOtherThread(FATAL_FAILURE);
-  }
-
-  EXPECT_EQ(4, results.size());
-  EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed());
-  EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed());
-  EXPECT_TRUE(results.GetTestPartResult(2).nonfatally_failed());
-  EXPECT_TRUE(results.GetTestPartResult(3).fatally_failed());
-}
-
-#endif  // GTEST_IS_THREADSAFE
-
-// Tests EXPECT_FATAL_FAILURE{,ON_ALL_THREADS}.  Makes sure that they
-// work even if the failure is generated in a called function rather than
-// the current context.
-
-typedef ScopedFakeTestPartResultReporterTest ExpectFatalFailureTest;
-
-TEST_F(ExpectFatalFailureTest, CatchesFatalFaliure) {
-  EXPECT_FATAL_FAILURE(AddFatalFailure(), "Expected fatal failure.");
-}
-
-#if GTEST_HAS_GLOBAL_STRING
-TEST_F(ExpectFatalFailureTest, AcceptsStringObject) {
-  EXPECT_FATAL_FAILURE(AddFatalFailure(), ::string("Expected fatal failure."));
-}
-#endif
-
-TEST_F(ExpectFatalFailureTest, AcceptsStdStringObject) {
-  EXPECT_FATAL_FAILURE(AddFatalFailure(),
-                       ::std::string("Expected fatal failure."));
-}
-
-TEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) {
-  // We have another test below to verify that the macro catches fatal
-  // failures generated on another thread.
-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFatalFailure(),
-                                      "Expected fatal failure.");
-}
-
-#ifdef __BORLANDC__
-// Silences warnings: "Condition is always true"
-# pragma option push -w-ccc
-#endif
-
-// Tests that EXPECT_FATAL_FAILURE() can be used in a non-void
-// function even when the statement in it contains ASSERT_*.
-
-int NonVoidFunction() {
-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), "");
-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), "");
-  return 0;
-}
-
-TEST_F(ExpectFatalFailureTest, CanBeUsedInNonVoidFunction) {
-  NonVoidFunction();
-}
-
-// Tests that EXPECT_FATAL_FAILURE(statement, ...) doesn't abort the
-// current function even though 'statement' generates a fatal failure.
-
-void DoesNotAbortHelper(bool* aborted) {
-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), "");
-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), "");
-
-  *aborted = false;
-}
-
-#ifdef __BORLANDC__
-// Restores warnings after previous "#pragma option push" suppressed them.
-# pragma option pop
-#endif
-
-TEST_F(ExpectFatalFailureTest, DoesNotAbort) {
-  bool aborted = true;
-  DoesNotAbortHelper(&aborted);
-  EXPECT_FALSE(aborted);
-}
-
-// Tests that the EXPECT_FATAL_FAILURE{,_ON_ALL_THREADS} accepts a
-// statement that contains a macro which expands to code containing an
-// unprotected comma.
-
-static int global_var = 0;
-#define GTEST_USE_UNPROTECTED_COMMA_ global_var++, global_var++
-
-TEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
-#ifndef __BORLANDC__
-  // ICE's in C++Builder.
-  EXPECT_FATAL_FAILURE({
-    GTEST_USE_UNPROTECTED_COMMA_;
-    AddFatalFailure();
-  }, "");
-#endif
-
-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS({
-    GTEST_USE_UNPROTECTED_COMMA_;
-    AddFatalFailure();
-  }, "");
-}
-
-// Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}.
-
-typedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest;
-
-TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) {
-  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
-                          "Expected non-fatal failure.");
-}
-
-#if GTEST_HAS_GLOBAL_STRING
-TEST_F(ExpectNonfatalFailureTest, AcceptsStringObject) {
-  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
-                          ::string("Expected non-fatal failure."));
-}
-#endif
-
-TEST_F(ExpectNonfatalFailureTest, AcceptsStdStringObject) {
-  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
-                          ::std::string("Expected non-fatal failure."));
-}
-
-TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) {
-  // We have another test below to verify that the macro catches
-  // non-fatal failures generated on another thread.
-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddNonfatalFailure(),
-                                         "Expected non-fatal failure.");
-}
-
-// Tests that the EXPECT_NONFATAL_FAILURE{,_ON_ALL_THREADS} accepts a
-// statement that contains a macro which expands to code containing an
-// unprotected comma.
-TEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
-  EXPECT_NONFATAL_FAILURE({
-    GTEST_USE_UNPROTECTED_COMMA_;
-    AddNonfatalFailure();
-  }, "");
-
-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({
-    GTEST_USE_UNPROTECTED_COMMA_;
-    AddNonfatalFailure();
-  }, "");
-}
-
-#if GTEST_IS_THREADSAFE
-
-typedef ScopedFakeTestPartResultReporterWithThreadsTest
-    ExpectFailureWithThreadsTest;
-
-TEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailureOnAllThreads) {
-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailureInOtherThread(FATAL_FAILURE),
-                                      "Expected fatal failure.");
-}
-
-TEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailureOnAllThreads) {
-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(
-      AddFailureInOtherThread(NONFATAL_FAILURE), "Expected non-fatal failure.");
-}
-
-#endif  // GTEST_IS_THREADSAFE
-
-// Tests the TestProperty class.
-
-TEST(TestPropertyTest, ConstructorWorks) {
-  const TestProperty property("key", "value");
-  EXPECT_STREQ("key", property.key());
-  EXPECT_STREQ("value", property.value());
-}
-
-TEST(TestPropertyTest, SetValue) {
-  TestProperty property("key", "value_1");
-  EXPECT_STREQ("key", property.key());
-  property.SetValue("value_2");
-  EXPECT_STREQ("key", property.key());
-  EXPECT_STREQ("value_2", property.value());
-}
-
-// Tests the TestResult class
-
-// The test fixture for testing TestResult.
-class TestResultTest : public Test {
- protected:
-  typedef std::vector<TestPartResult> TPRVector;
-
-  // We make use of 2 TestPartResult objects,
-  TestPartResult * pr1, * pr2;
-
-  // ... and 3 TestResult objects.
-  TestResult * r0, * r1, * r2;
-
-  virtual void SetUp() {
-    // pr1 is for success.
-    pr1 = new TestPartResult(TestPartResult::kSuccess,
-                             "foo/bar.cc",
-                             10,
-                             "Success!");
-
-    // pr2 is for fatal failure.
-    pr2 = new TestPartResult(TestPartResult::kFatalFailure,
-                             "foo/bar.cc",
-                             -1,  // This line number means "unknown"
-                             "Failure!");
-
-    // Creates the TestResult objects.
-    r0 = new TestResult();
-    r1 = new TestResult();
-    r2 = new TestResult();
-
-    // In order to test TestResult, we need to modify its internal
-    // state, in particular the TestPartResult vector it holds.
-    // test_part_results() returns a const reference to this vector.
-    // We cast it to a non-const object s.t. it can be modified (yes,
-    // this is a hack).
-    TPRVector* results1 = const_cast<TPRVector*>(
-        &TestResultAccessor::test_part_results(*r1));
-    TPRVector* results2 = const_cast<TPRVector*>(
-        &TestResultAccessor::test_part_results(*r2));
-
-    // r0 is an empty TestResult.
-
-    // r1 contains a single SUCCESS TestPartResult.
-    results1->push_back(*pr1);
-
-    // r2 contains a SUCCESS, and a FAILURE.
-    results2->push_back(*pr1);
-    results2->push_back(*pr2);
-  }
-
-  virtual void TearDown() {
-    delete pr1;
-    delete pr2;
-
-    delete r0;
-    delete r1;
-    delete r2;
-  }
-
-  // Helper that compares two two TestPartResults.
-  static void CompareTestPartResult(const TestPartResult& expected,
-                                    const TestPartResult& actual) {
-    EXPECT_EQ(expected.type(), actual.type());
-    EXPECT_STREQ(expected.file_name(), actual.file_name());
-    EXPECT_EQ(expected.line_number(), actual.line_number());
-    EXPECT_STREQ(expected.summary(), actual.summary());
-    EXPECT_STREQ(expected.message(), actual.message());
-    EXPECT_EQ(expected.passed(), actual.passed());
-    EXPECT_EQ(expected.failed(), actual.failed());
-    EXPECT_EQ(expected.nonfatally_failed(), actual.nonfatally_failed());
-    EXPECT_EQ(expected.fatally_failed(), actual.fatally_failed());
-  }
-};
-
-// Tests TestResult::total_part_count().
-TEST_F(TestResultTest, total_part_count) {
-  ASSERT_EQ(0, r0->total_part_count());
-  ASSERT_EQ(1, r1->total_part_count());
-  ASSERT_EQ(2, r2->total_part_count());
-}
-
-// Tests TestResult::Passed().
-TEST_F(TestResultTest, Passed) {
-  ASSERT_TRUE(r0->Passed());
-  ASSERT_TRUE(r1->Passed());
-  ASSERT_FALSE(r2->Passed());
-}
-
-// Tests TestResult::Failed().
-TEST_F(TestResultTest, Failed) {
-  ASSERT_FALSE(r0->Failed());
-  ASSERT_FALSE(r1->Failed());
-  ASSERT_TRUE(r2->Failed());
-}
-
-// Tests TestResult::GetTestPartResult().
-
-typedef TestResultTest TestResultDeathTest;
-
-TEST_F(TestResultDeathTest, GetTestPartResult) {
-  CompareTestPartResult(*pr1, r2->GetTestPartResult(0));
-  CompareTestPartResult(*pr2, r2->GetTestPartResult(1));
-  EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(2), "");
-  EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(-1), "");
-}
-
-// Tests TestResult has no properties when none are added.
-TEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) {
-  TestResult test_result;
-  ASSERT_EQ(0, test_result.test_property_count());
-}
-
-// Tests TestResult has the expected property when added.
-TEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) {
-  TestResult test_result;
-  TestProperty property("key_1", "1");
-  TestResultAccessor::RecordProperty(&test_result, "testcase", property);
-  ASSERT_EQ(1, test_result.test_property_count());
-  const TestProperty& actual_property = test_result.GetTestProperty(0);
-  EXPECT_STREQ("key_1", actual_property.key());
-  EXPECT_STREQ("1", actual_property.value());
-}
-
-// Tests TestResult has multiple properties when added.
-TEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) {
-  TestResult test_result;
-  TestProperty property_1("key_1", "1");
-  TestProperty property_2("key_2", "2");
-  TestResultAccessor::RecordProperty(&test_result, "testcase", property_1);
-  TestResultAccessor::RecordProperty(&test_result, "testcase", property_2);
-  ASSERT_EQ(2, test_result.test_property_count());
-  const TestProperty& actual_property_1 = test_result.GetTestProperty(0);
-  EXPECT_STREQ("key_1", actual_property_1.key());
-  EXPECT_STREQ("1", actual_property_1.value());
-
-  const TestProperty& actual_property_2 = test_result.GetTestProperty(1);
-  EXPECT_STREQ("key_2", actual_property_2.key());
-  EXPECT_STREQ("2", actual_property_2.value());
-}
-
-// Tests TestResult::RecordProperty() overrides values for duplicate keys.
-TEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) {
-  TestResult test_result;
-  TestProperty property_1_1("key_1", "1");
-  TestProperty property_2_1("key_2", "2");
-  TestProperty property_1_2("key_1", "12");
-  TestProperty property_2_2("key_2", "22");
-  TestResultAccessor::RecordProperty(&test_result, "testcase", property_1_1);
-  TestResultAccessor::RecordProperty(&test_result, "testcase", property_2_1);
-  TestResultAccessor::RecordProperty(&test_result, "testcase", property_1_2);
-  TestResultAccessor::RecordProperty(&test_result, "testcase", property_2_2);
-
-  ASSERT_EQ(2, test_result.test_property_count());
-  const TestProperty& actual_property_1 = test_result.GetTestProperty(0);
-  EXPECT_STREQ("key_1", actual_property_1.key());
-  EXPECT_STREQ("12", actual_property_1.value());
-
-  const TestProperty& actual_property_2 = test_result.GetTestProperty(1);
-  EXPECT_STREQ("key_2", actual_property_2.key());
-  EXPECT_STREQ("22", actual_property_2.value());
-}
-
-// Tests TestResult::GetTestProperty().
-TEST(TestResultPropertyTest, GetTestProperty) {
-  TestResult test_result;
-  TestProperty property_1("key_1", "1");
-  TestProperty property_2("key_2", "2");
-  TestProperty property_3("key_3", "3");
-  TestResultAccessor::RecordProperty(&test_result, "testcase", property_1);
-  TestResultAccessor::RecordProperty(&test_result, "testcase", property_2);
-  TestResultAccessor::RecordProperty(&test_result, "testcase", property_3);
-
-  const TestProperty& fetched_property_1 = test_result.GetTestProperty(0);
-  const TestProperty& fetched_property_2 = test_result.GetTestProperty(1);
-  const TestProperty& fetched_property_3 = test_result.GetTestProperty(2);
-
-  EXPECT_STREQ("key_1", fetched_property_1.key());
-  EXPECT_STREQ("1", fetched_property_1.value());
-
-  EXPECT_STREQ("key_2", fetched_property_2.key());
-  EXPECT_STREQ("2", fetched_property_2.value());
-
-  EXPECT_STREQ("key_3", fetched_property_3.key());
-  EXPECT_STREQ("3", fetched_property_3.value());
-
-  EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(3), "");
-  EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(-1), "");
-}
-
-// Tests the Test class.
-//
-// It's difficult to test every public method of this class (we are
-// already stretching the limit of Google Test by using it to test itself!).
-// Fortunately, we don't have to do that, as we are already testing
-// the functionalities of the Test class extensively by using Google Test
-// alone.
-//
-// Therefore, this section only contains one test.
-
-// Tests that GTestFlagSaver works on Windows and Mac.
-
-class GTestFlagSaverTest : public Test {
- protected:
-  // Saves the Google Test flags such that we can restore them later, and
-  // then sets them to their default values.  This will be called
-  // before the first test in this test case is run.
-  static void SetUpTestCase() {
-    saver_ = new GTestFlagSaver;
-
-    GTEST_FLAG(also_run_disabled_tests) = false;
-    GTEST_FLAG(break_on_failure) = false;
-    GTEST_FLAG(catch_exceptions) = false;
-    GTEST_FLAG(death_test_use_fork) = false;
-    GTEST_FLAG(color) = "auto";
-    GTEST_FLAG(filter) = "";
-    GTEST_FLAG(list_tests) = false;
-    GTEST_FLAG(output) = "";
-    GTEST_FLAG(print_time) = true;
-    GTEST_FLAG(random_seed) = 0;
-    GTEST_FLAG(repeat) = 1;
-    GTEST_FLAG(shuffle) = false;
-    GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
-    GTEST_FLAG(stream_result_to) = "";
-    GTEST_FLAG(throw_on_failure) = false;
-  }
-
-  // Restores the Google Test flags that the tests have modified.  This will
-  // be called after the last test in this test case is run.
-  static void TearDownTestCase() {
-    delete saver_;
-    saver_ = NULL;
-  }
-
-  // Verifies that the Google Test flags have their default values, and then
-  // modifies each of them.
-  void VerifyAndModifyFlags() {
-    EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests));
-    EXPECT_FALSE(GTEST_FLAG(break_on_failure));
-    EXPECT_FALSE(GTEST_FLAG(catch_exceptions));
-    EXPECT_STREQ("auto", GTEST_FLAG(color).c_str());
-    EXPECT_FALSE(GTEST_FLAG(death_test_use_fork));
-    EXPECT_STREQ("", GTEST_FLAG(filter).c_str());
-    EXPECT_FALSE(GTEST_FLAG(list_tests));
-    EXPECT_STREQ("", GTEST_FLAG(output).c_str());
-    EXPECT_TRUE(GTEST_FLAG(print_time));
-    EXPECT_EQ(0, GTEST_FLAG(random_seed));
-    EXPECT_EQ(1, GTEST_FLAG(repeat));
-    EXPECT_FALSE(GTEST_FLAG(shuffle));
-    EXPECT_EQ(kMaxStackTraceDepth, GTEST_FLAG(stack_trace_depth));
-    EXPECT_STREQ("", GTEST_FLAG(stream_result_to).c_str());
-    EXPECT_FALSE(GTEST_FLAG(throw_on_failure));
-
-    GTEST_FLAG(also_run_disabled_tests) = true;
-    GTEST_FLAG(break_on_failure) = true;
-    GTEST_FLAG(catch_exceptions) = true;
-    GTEST_FLAG(color) = "no";
-    GTEST_FLAG(death_test_use_fork) = true;
-    GTEST_FLAG(filter) = "abc";
-    GTEST_FLAG(list_tests) = true;
-    GTEST_FLAG(output) = "xml:foo.xml";
-    GTEST_FLAG(print_time) = false;
-    GTEST_FLAG(random_seed) = 1;
-    GTEST_FLAG(repeat) = 100;
-    GTEST_FLAG(shuffle) = true;
-    GTEST_FLAG(stack_trace_depth) = 1;
-    GTEST_FLAG(stream_result_to) = "localhost:1234";
-    GTEST_FLAG(throw_on_failure) = true;
-  }
-
- private:
-  // For saving Google Test flags during this test case.
-  static GTestFlagSaver* saver_;
-};
-
-GTestFlagSaver* GTestFlagSaverTest::saver_ = NULL;
-
-// Google Test doesn't guarantee the order of tests.  The following two
-// tests are designed to work regardless of their order.
-
-// Modifies the Google Test flags in the test body.
-TEST_F(GTestFlagSaverTest, ModifyGTestFlags) {
-  VerifyAndModifyFlags();
-}
-
-// Verifies that the Google Test flags in the body of the previous test were
-// restored to their original values.
-TEST_F(GTestFlagSaverTest, VerifyGTestFlags) {
-  VerifyAndModifyFlags();
-}
-
-// Sets an environment variable with the given name to the given
-// value.  If the value argument is "", unsets the environment
-// variable.  The caller must ensure that both arguments are not NULL.
-static void SetEnv(const char* name, const char* value) {
-#if GTEST_OS_WINDOWS_MOBILE
-  // Environment variables are not supported on Windows CE.
-  return;
-#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
-  // C++Builder's putenv only stores a pointer to its parameter; we have to
-  // ensure that the string remains valid as long as it might be needed.
-  // We use an std::map to do so.
-  static std::map<std::string, std::string*> added_env;
-
-  // Because putenv stores a pointer to the string buffer, we can't delete the
-  // previous string (if present) until after it's replaced.
-  std::string *prev_env = NULL;
-  if (added_env.find(name) != added_env.end()) {
-    prev_env = added_env[name];
-  }
-  added_env[name] = new std::string(
-      (Message() << name << "=" << value).GetString());
-
-  // The standard signature of putenv accepts a 'char*' argument. Other
-  // implementations, like C++Builder's, accept a 'const char*'.
-  // We cast away the 'const' since that would work for both variants.
-  putenv(const_cast<char*>(added_env[name]->c_str()));
-  delete prev_env;
-#elif GTEST_OS_WINDOWS  // If we are on Windows proper.
-  _putenv((Message() << name << "=" << value).GetString().c_str());
-#else
-  if (*value == '\0') {
-    unsetenv(name);
-  } else {
-    setenv(name, value, 1);
-  }
-#endif  // GTEST_OS_WINDOWS_MOBILE
-}
-
-#if !GTEST_OS_WINDOWS_MOBILE
-// Environment variables are not supported on Windows CE.
-
-using testing::internal::Int32FromGTestEnv;
-
-// Tests Int32FromGTestEnv().
-
-// Tests that Int32FromGTestEnv() returns the default value when the
-// environment variable is not set.
-TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) {
-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "");
-  EXPECT_EQ(10, Int32FromGTestEnv("temp", 10));
-}
-
-# if !defined(GTEST_GET_INT32_FROM_ENV_)
-
-// Tests that Int32FromGTestEnv() returns the default value when the
-// environment variable overflows as an Int32.
-TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) {
-  printf("(expecting 2 warnings)\n");
-
-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12345678987654321");
-  EXPECT_EQ(20, Int32FromGTestEnv("temp", 20));
-
-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-12345678987654321");
-  EXPECT_EQ(30, Int32FromGTestEnv("temp", 30));
-}
-
-// Tests that Int32FromGTestEnv() returns the default value when the
-// environment variable does not represent a valid decimal integer.
-TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) {
-  printf("(expecting 2 warnings)\n");
-
-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "A1");
-  EXPECT_EQ(40, Int32FromGTestEnv("temp", 40));
-
-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12X");
-  EXPECT_EQ(50, Int32FromGTestEnv("temp", 50));
-}
-
-# endif  // !defined(GTEST_GET_INT32_FROM_ENV_)
-
-// Tests that Int32FromGTestEnv() parses and returns the value of the
-// environment variable when it represents a valid decimal integer in
-// the range of an Int32.
-TEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) {
-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "123");
-  EXPECT_EQ(123, Int32FromGTestEnv("temp", 0));
-
-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-321");
-  EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0));
-}
-#endif  // !GTEST_OS_WINDOWS_MOBILE
-
-// Tests ParseInt32Flag().
-
-// Tests that ParseInt32Flag() returns false and doesn't change the
-// output value when the flag has wrong format
-TEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) {
-  Int32 value = 123;
-  EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value));
-  EXPECT_EQ(123, value);
-
-  EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value));
-  EXPECT_EQ(123, value);
-}
-
-// Tests that ParseInt32Flag() returns false and doesn't change the
-// output value when the flag overflows as an Int32.
-TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) {
-  printf("(expecting 2 warnings)\n");
-
-  Int32 value = 123;
-  EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value));
-  EXPECT_EQ(123, value);
-
-  EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value));
-  EXPECT_EQ(123, value);
-}
-
-// Tests that ParseInt32Flag() returns false and doesn't change the
-// output value when the flag does not represent a valid decimal
-// integer.
-TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) {
-  printf("(expecting 2 warnings)\n");
-
-  Int32 value = 123;
-  EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value));
-  EXPECT_EQ(123, value);
-
-  EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value));
-  EXPECT_EQ(123, value);
-}
-
-// Tests that ParseInt32Flag() parses the value of the flag and
-// returns true when the flag represents a valid decimal integer in
-// the range of an Int32.
-TEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) {
-  Int32 value = 123;
-  EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value));
-  EXPECT_EQ(456, value);
-
-  EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=-789",
-                             "abc", &value));
-  EXPECT_EQ(-789, value);
-}
-
-// Tests that Int32FromEnvOrDie() parses the value of the var or
-// returns the correct default.
-// Environment variables are not supported on Windows CE.
-#if !GTEST_OS_WINDOWS_MOBILE
-TEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) {
-  EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "123");
-  EXPECT_EQ(123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "-123");
-  EXPECT_EQ(-123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
-}
-#endif  // !GTEST_OS_WINDOWS_MOBILE
-
-// Tests that Int32FromEnvOrDie() aborts with an error message
-// if the variable is not an Int32.
-TEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) {
-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "xxx");
-  EXPECT_DEATH_IF_SUPPORTED(
-      Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
-      ".*");
-}
-
-// Tests that Int32FromEnvOrDie() aborts with an error message
-// if the variable cannot be represnted by an Int32.
-TEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) {
-  SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234");
-  EXPECT_DEATH_IF_SUPPORTED(
-      Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
-      ".*");
-}
-
-// Tests that ShouldRunTestOnShard() selects all tests
-// where there is 1 shard.
-TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) {
-  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 0));
-  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 1));
-  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 2));
-  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 3));
-  EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 4));
-}
-
-class ShouldShardTest : public testing::Test {
- protected:
-  virtual void SetUp() {
-    index_var_ = GTEST_FLAG_PREFIX_UPPER_ "INDEX";
-    total_var_ = GTEST_FLAG_PREFIX_UPPER_ "TOTAL";
-  }
-
-  virtual void TearDown() {
-    SetEnv(index_var_, "");
-    SetEnv(total_var_, "");
-  }
-
-  const char* index_var_;
-  const char* total_var_;
-};
-
-// Tests that sharding is disabled if neither of the environment variables
-// are set.
-TEST_F(ShouldShardTest, ReturnsFalseWhenNeitherEnvVarIsSet) {
-  SetEnv(index_var_, "");
-  SetEnv(total_var_, "");
-
-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, false));
-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
-}
-
-// Tests that sharding is not enabled if total_shards  == 1.
-TEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) {
-  SetEnv(index_var_, "0");
-  SetEnv(total_var_, "1");
-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, false));
-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
-}
-
-// Tests that sharding is enabled if total_shards > 1 and
-// we are not in a death test subprocess.
-// Environment variables are not supported on Windows CE.
-#if !GTEST_OS_WINDOWS_MOBILE
-TEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) {
-  SetEnv(index_var_, "4");
-  SetEnv(total_var_, "22");
-  EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
-
-  SetEnv(index_var_, "8");
-  SetEnv(total_var_, "9");
-  EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
-
-  SetEnv(index_var_, "0");
-  SetEnv(total_var_, "9");
-  EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
-  EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
-}
-#endif  // !GTEST_OS_WINDOWS_MOBILE
-
-// Tests that we exit in error if the sharding values are not valid.
-
-typedef ShouldShardTest ShouldShardDeathTest;
-
-TEST_F(ShouldShardDeathTest, AbortsWhenShardingEnvVarsAreInvalid) {
-  SetEnv(index_var_, "4");
-  SetEnv(total_var_, "4");
-  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
-
-  SetEnv(index_var_, "4");
-  SetEnv(total_var_, "-2");
-  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
-
-  SetEnv(index_var_, "5");
-  SetEnv(total_var_, "");
-  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
-
-  SetEnv(index_var_, "");
-  SetEnv(total_var_, "5");
-  EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
-}
-
-// Tests that ShouldRunTestOnShard is a partition when 5
-// shards are used.
-TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) {
-  // Choose an arbitrary number of tests and shards.
-  const int num_tests = 17;
-  const int num_shards = 5;
-
-  // Check partitioning: each test should be on exactly 1 shard.
-  for (int test_id = 0; test_id < num_tests; test_id++) {
-    int prev_selected_shard_index = -1;
-    for (int shard_index = 0; shard_index < num_shards; shard_index++) {
-      if (ShouldRunTestOnShard(num_shards, shard_index, test_id)) {
-        if (prev_selected_shard_index < 0) {
-          prev_selected_shard_index = shard_index;
-        } else {
-          ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and "
-            << shard_index << " are both selected to run test " << test_id;
-        }
-      }
-    }
-  }
-
-  // Check balance: This is not required by the sharding protocol, but is a
-  // desirable property for performance.
-  for (int shard_index = 0; shard_index < num_shards; shard_index++) {
-    int num_tests_on_shard = 0;
-    for (int test_id = 0; test_id < num_tests; test_id++) {
-      num_tests_on_shard +=
-        ShouldRunTestOnShard(num_shards, shard_index, test_id);
-    }
-    EXPECT_GE(num_tests_on_shard, num_tests / num_shards);
-  }
-}
-
-// For the same reason we are not explicitly testing everything in the
-// Test class, there are no separate tests for the following classes
-// (except for some trivial cases):
-//
-//   TestCase, UnitTest, UnitTestResultPrinter.
-//
-// Similarly, there are no separate tests for the following macros:
-//
-//   TEST, TEST_F, RUN_ALL_TESTS
-
-TEST(UnitTestTest, CanGetOriginalWorkingDir) {
-  ASSERT_TRUE(UnitTest::GetInstance()->original_working_dir() != NULL);
-  EXPECT_STRNE(UnitTest::GetInstance()->original_working_dir(), "");
-}
-
-TEST(UnitTestTest, ReturnsPlausibleTimestamp) {
-  EXPECT_LT(0, UnitTest::GetInstance()->start_timestamp());
-  EXPECT_LE(UnitTest::GetInstance()->start_timestamp(), GetTimeInMillis());
-}
-
-// When a property using a reserved key is supplied to this function, it
-// tests that a non-fatal failure is added, a fatal failure is not added,
-// and that the property is not recorded.
-void ExpectNonFatalFailureRecordingPropertyWithReservedKey(
-    const TestResult& test_result, const char* key) {
-  EXPECT_NONFATAL_FAILURE(Test::RecordProperty(key, "1"), "Reserved key");
-  ASSERT_EQ(0, test_result.test_property_count()) << "Property for key '" << key
-                                                  << "' recorded unexpectedly.";
-}
-
-void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
-    const char* key) {
-  const TestInfo* test_info = UnitTest::GetInstance()->current_test_info();
-  ASSERT_TRUE(test_info != NULL);
-  ExpectNonFatalFailureRecordingPropertyWithReservedKey(*test_info->result(),
-                                                        key);
-}
-
-void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
-    const char* key) {
-  const TestCase* test_case = UnitTest::GetInstance()->current_test_case();
-  ASSERT_TRUE(test_case != NULL);
-  ExpectNonFatalFailureRecordingPropertyWithReservedKey(
-      test_case->ad_hoc_test_result(), key);
-}
-
-void ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
-    const char* key) {
-  ExpectNonFatalFailureRecordingPropertyWithReservedKey(
-      UnitTest::GetInstance()->ad_hoc_test_result(), key);
-}
-
-// Tests that property recording functions in UnitTest outside of tests
-// functions correcly.  Creating a separate instance of UnitTest ensures it
-// is in a state similar to the UnitTest's singleton's between tests.
-class UnitTestRecordPropertyTest :
-    public testing::internal::UnitTestRecordPropertyTestHelper {
- public:
-  static void SetUpTestCase() {
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
-        "disabled");
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
-        "errors");
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
-        "failures");
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
-        "name");
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
-        "tests");
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase(
-        "time");
-
-    Test::RecordProperty("test_case_key_1", "1");
-    const TestCase* test_case = UnitTest::GetInstance()->current_test_case();
-    ASSERT_TRUE(test_case != NULL);
-
-    ASSERT_EQ(1, test_case->ad_hoc_test_result().test_property_count());
-    EXPECT_STREQ("test_case_key_1",
-                 test_case->ad_hoc_test_result().GetTestProperty(0).key());
-    EXPECT_STREQ("1",
-                 test_case->ad_hoc_test_result().GetTestProperty(0).value());
-  }
-};
-
-// Tests TestResult has the expected property when added.
-TEST_F(UnitTestRecordPropertyTest, OnePropertyFoundWhenAdded) {
-  UnitTestRecordProperty("key_1", "1");
-
-  ASSERT_EQ(1, unit_test_.ad_hoc_test_result().test_property_count());
-
-  EXPECT_STREQ("key_1",
-               unit_test_.ad_hoc_test_result().GetTestProperty(0).key());
-  EXPECT_STREQ("1",
-               unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
-}
-
-// Tests TestResult has multiple properties when added.
-TEST_F(UnitTestRecordPropertyTest, MultiplePropertiesFoundWhenAdded) {
-  UnitTestRecordProperty("key_1", "1");
-  UnitTestRecordProperty("key_2", "2");
-
-  ASSERT_EQ(2, unit_test_.ad_hoc_test_result().test_property_count());
-
-  EXPECT_STREQ("key_1",
-               unit_test_.ad_hoc_test_result().GetTestProperty(0).key());
-  EXPECT_STREQ("1", unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
-
-  EXPECT_STREQ("key_2",
-               unit_test_.ad_hoc_test_result().GetTestProperty(1).key());
-  EXPECT_STREQ("2", unit_test_.ad_hoc_test_result().GetTestProperty(1).value());
-}
-
-// Tests TestResult::RecordProperty() overrides values for duplicate keys.
-TEST_F(UnitTestRecordPropertyTest, OverridesValuesForDuplicateKeys) {
-  UnitTestRecordProperty("key_1", "1");
-  UnitTestRecordProperty("key_2", "2");
-  UnitTestRecordProperty("key_1", "12");
-  UnitTestRecordProperty("key_2", "22");
-
-  ASSERT_EQ(2, unit_test_.ad_hoc_test_result().test_property_count());
-
-  EXPECT_STREQ("key_1",
-               unit_test_.ad_hoc_test_result().GetTestProperty(0).key());
-  EXPECT_STREQ("12",
-               unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
-
-  EXPECT_STREQ("key_2",
-               unit_test_.ad_hoc_test_result().GetTestProperty(1).key());
-  EXPECT_STREQ("22",
-               unit_test_.ad_hoc_test_result().GetTestProperty(1).value());
-}
-
-TEST_F(UnitTestRecordPropertyTest,
-       AddFailureInsideTestsWhenUsingTestCaseReservedKeys) {
-  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
-      "name");
-  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
-      "value_param");
-  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
-      "type_param");
-  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
-      "status");
-  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
-      "time");
-  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
-      "classname");
-}
-
-TEST_F(UnitTestRecordPropertyTest,
-       AddRecordWithReservedKeysGeneratesCorrectPropertyList) {
-  EXPECT_NONFATAL_FAILURE(
-      Test::RecordProperty("name", "1"),
-      "'classname', 'name', 'status', 'time', 'type_param', and 'value_param'"
-      " are reserved");
-}
-
-class UnitTestRecordPropertyTestEnvironment : public Environment {
- public:
-  virtual void TearDown() {
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
-        "tests");
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
-        "failures");
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
-        "disabled");
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
-        "errors");
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
-        "name");
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
-        "timestamp");
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
-        "time");
-    ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase(
-        "random_seed");
-  }
-};
-
-// This will test property recording outside of any test or test case.
-static Environment* record_property_env =
-    AddGlobalTestEnvironment(new UnitTestRecordPropertyTestEnvironment);
-
-// This group of tests is for predicate assertions (ASSERT_PRED*, etc)
-// of various arities.  They do not attempt to be exhaustive.  Rather,
-// view them as smoke tests that can be easily reviewed and verified.
-// A more complete set of tests for predicate assertions can be found
-// in gtest_pred_impl_unittest.cc.
-
-// First, some predicates and predicate-formatters needed by the tests.
-
-// Returns true iff the argument is an even number.
-bool IsEven(int n) {
-  return (n % 2) == 0;
-}
-
-// A functor that returns true iff the argument is an even number.
-struct IsEvenFunctor {
-  bool operator()(int n) { return IsEven(n); }
-};
-
-// A predicate-formatter function that asserts the argument is an even
-// number.
-AssertionResult AssertIsEven(const char* expr, int n) {
-  if (IsEven(n)) {
-    return AssertionSuccess();
-  }
-
-  Message msg;
-  msg << expr << " evaluates to " << n << ", which is not even.";
-  return AssertionFailure(msg);
-}
-
-// A predicate function that returns AssertionResult for use in
-// EXPECT/ASSERT_TRUE/FALSE.
-AssertionResult ResultIsEven(int n) {
-  if (IsEven(n))
-    return AssertionSuccess() << n << " is even";
-  else
-    return AssertionFailure() << n << " is odd";
-}
-
-// A predicate function that returns AssertionResult but gives no
-// explanation why it succeeds. Needed for testing that
-// EXPECT/ASSERT_FALSE handles such functions correctly.
-AssertionResult ResultIsEvenNoExplanation(int n) {
-  if (IsEven(n))
-    return AssertionSuccess();
-  else
-    return AssertionFailure() << n << " is odd";
-}
-
-// A predicate-formatter functor that asserts the argument is an even
-// number.
-struct AssertIsEvenFunctor {
-  AssertionResult operator()(const char* expr, int n) {
-    return AssertIsEven(expr, n);
-  }
-};
-
-// Returns true iff the sum of the arguments is an even number.
-bool SumIsEven2(int n1, int n2) {
-  return IsEven(n1 + n2);
-}
-
-// A functor that returns true iff the sum of the arguments is an even
-// number.
-struct SumIsEven3Functor {
-  bool operator()(int n1, int n2, int n3) {
-    return IsEven(n1 + n2 + n3);
-  }
-};
-
-// A predicate-formatter function that asserts the sum of the
-// arguments is an even number.
-AssertionResult AssertSumIsEven4(
-    const char* e1, const char* e2, const char* e3, const char* e4,
-    int n1, int n2, int n3, int n4) {
-  const int sum = n1 + n2 + n3 + n4;
-  if (IsEven(sum)) {
-    return AssertionSuccess();
-  }
-
-  Message msg;
-  msg << e1 << " + " << e2 << " + " << e3 << " + " << e4
-      << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4
-      << ") evaluates to " << sum << ", which is not even.";
-  return AssertionFailure(msg);
-}
-
-// A predicate-formatter functor that asserts the sum of the arguments
-// is an even number.
-struct AssertSumIsEven5Functor {
-  AssertionResult operator()(
-      const char* e1, const char* e2, const char* e3, const char* e4,
-      const char* e5, int n1, int n2, int n3, int n4, int n5) {
-    const int sum = n1 + n2 + n3 + n4 + n5;
-    if (IsEven(sum)) {
-      return AssertionSuccess();
-    }
-
-    Message msg;
-    msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
-        << " ("
-        << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5
-        << ") evaluates to " << sum << ", which is not even.";
-    return AssertionFailure(msg);
-  }
-};
-
-
-// Tests unary predicate assertions.
-
-// Tests unary predicate assertions that don't use a custom formatter.
-TEST(Pred1Test, WithoutFormat) {
-  // Success cases.
-  EXPECT_PRED1(IsEvenFunctor(), 2) << "This failure is UNEXPECTED!";
-  ASSERT_PRED1(IsEven, 4);
-
-  // Failure cases.
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED1(IsEven, 5) << "This failure is expected.";
-  }, "This failure is expected.");
-  EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5),
-                       "evaluates to false");
-}
-
-// Tests unary predicate assertions that use a custom formatter.
-TEST(Pred1Test, WithFormat) {
-  // Success cases.
-  EXPECT_PRED_FORMAT1(AssertIsEven, 2);
-  ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4)
-    << "This failure is UNEXPECTED!";
-
-  // Failure cases.
-  const int n = 5;
-  EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n),
-                          "n evaluates to 5, which is not even.");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected.";
-  }, "This failure is expected.");
-}
-
-// Tests that unary predicate assertions evaluates their arguments
-// exactly once.
-TEST(Pred1Test, SingleEvaluationOnFailure) {
-  // A success case.
-  static int n = 0;
-  EXPECT_PRED1(IsEven, n++);
-  EXPECT_EQ(1, n) << "The argument is not evaluated exactly once.";
-
-  // A failure case.
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++)
-        << "This failure is expected.";
-  }, "This failure is expected.");
-  EXPECT_EQ(2, n) << "The argument is not evaluated exactly once.";
-}
-
-
-// Tests predicate assertions whose arity is >= 2.
-
-// Tests predicate assertions that don't use a custom formatter.
-TEST(PredTest, WithoutFormat) {
-  // Success cases.
-  ASSERT_PRED2(SumIsEven2, 2, 4) << "This failure is UNEXPECTED!";
-  EXPECT_PRED3(SumIsEven3Functor(), 4, 6, 8);
-
-  // Failure cases.
-  const int n1 = 1;
-  const int n2 = 2;
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected.";
-  }, "This failure is expected.");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4);
-  }, "evaluates to false");
-}
-
-// Tests predicate assertions that use a custom formatter.
-TEST(PredTest, WithFormat) {
-  // Success cases.
-  ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) <<
-    "This failure is UNEXPECTED!";
-  EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10);
-
-  // Failure cases.
-  const int n1 = 1;
-  const int n2 = 2;
-  const int n3 = 4;
-  const int n4 = 6;
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4);
-  }, "evaluates to 13, which is not even.");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8)
-        << "This failure is expected.";
-  }, "This failure is expected.");
-}
-
-// Tests that predicate assertions evaluates their arguments
-// exactly once.
-TEST(PredTest, SingleEvaluationOnFailure) {
-  // A success case.
-  int n1 = 0;
-  int n2 = 0;
-  EXPECT_PRED2(SumIsEven2, n1++, n2++);
-  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
-  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
-
-  // Another success case.
-  n1 = n2 = 0;
-  int n3 = 0;
-  int n4 = 0;
-  int n5 = 0;
-  ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(),
-                      n1++, n2++, n3++, n4++, n5++)
-                        << "This failure is UNEXPECTED!";
-  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
-  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
-  EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
-  EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once.";
-  EXPECT_EQ(1, n5) << "Argument 5 is not evaluated exactly once.";
-
-  // A failure case.
-  n1 = n2 = n3 = 0;
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++)
-        << "This failure is expected.";
-  }, "This failure is expected.");
-  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
-  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
-  EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
-
-  // Another failure case.
-  n1 = n2 = n3 = n4 = 0;
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++);
-  }, "evaluates to 1, which is not even.");
-  EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
-  EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
-  EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
-  EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once.";
-}
-
-
-// Some helper functions for testing using overloaded/template
-// functions with ASSERT_PREDn and EXPECT_PREDn.
-
-bool IsPositive(double x) {
-  return x > 0;
-}
-
-template <typename T>
-bool IsNegative(T x) {
-  return x < 0;
-}
-
-template <typename T1, typename T2>
-bool GreaterThan(T1 x1, T2 x2) {
-  return x1 > x2;
-}
-
-// Tests that overloaded functions can be used in *_PRED* as long as
-// their types are explicitly specified.
-TEST(PredicateAssertionTest, AcceptsOverloadedFunction) {
-  // C++Builder requires C-style casts rather than static_cast.
-  EXPECT_PRED1((bool (*)(int))(IsPositive), 5);  // NOLINT
-  ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0);  // NOLINT
-}
-
-// Tests that template functions can be used in *_PRED* as long as
-// their types are explicitly specified.
-TEST(PredicateAssertionTest, AcceptsTemplateFunction) {
-  EXPECT_PRED1(IsNegative<int>, -5);
-  // Makes sure that we can handle templates with more than one
-  // parameter.
-  ASSERT_PRED2((GreaterThan<int, int>), 5, 0);
-}
-
-
-// Some helper functions for testing using overloaded/template
-// functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn.
-
-AssertionResult IsPositiveFormat(const char* /* expr */, int n) {
-  return n > 0 ? AssertionSuccess() :
-      AssertionFailure(Message() << "Failure");
-}
-
-AssertionResult IsPositiveFormat(const char* /* expr */, double x) {
-  return x > 0 ? AssertionSuccess() :
-      AssertionFailure(Message() << "Failure");
-}
-
-template <typename T>
-AssertionResult IsNegativeFormat(const char* /* expr */, T x) {
-  return x < 0 ? AssertionSuccess() :
-      AssertionFailure(Message() << "Failure");
-}
-
-template <typename T1, typename T2>
-AssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */,
-                             const T1& x1, const T2& x2) {
-  return x1 == x2 ? AssertionSuccess() :
-      AssertionFailure(Message() << "Failure");
-}
-
-// Tests that overloaded functions can be used in *_PRED_FORMAT*
-// without explicitly specifying their types.
-TEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) {
-  EXPECT_PRED_FORMAT1(IsPositiveFormat, 5);
-  ASSERT_PRED_FORMAT1(IsPositiveFormat, 6.0);
-}
-
-// Tests that template functions can be used in *_PRED_FORMAT* without
-// explicitly specifying their types.
-TEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) {
-  EXPECT_PRED_FORMAT1(IsNegativeFormat, -5);
-  ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3);
-}
-
-
-// Tests string assertions.
-
-// Tests ASSERT_STREQ with non-NULL arguments.
-TEST(StringAssertionTest, ASSERT_STREQ) {
-  const char * const p1 = "good";
-  ASSERT_STREQ(p1, p1);
-
-  // Let p2 have the same content as p1, but be at a different address.
-  const char p2[] = "good";
-  ASSERT_STREQ(p1, p2);
-
-  EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"),
-                       "Expected: \"bad\"");
-}
-
-// Tests ASSERT_STREQ with NULL arguments.
-TEST(StringAssertionTest, ASSERT_STREQ_Null) {
-  ASSERT_STREQ(static_cast<const char *>(NULL), NULL);
-  EXPECT_FATAL_FAILURE(ASSERT_STREQ(NULL, "non-null"),
-                       "non-null");
-}
-
-// Tests ASSERT_STREQ with NULL arguments.
-TEST(StringAssertionTest, ASSERT_STREQ_Null2) {
-  EXPECT_FATAL_FAILURE(ASSERT_STREQ("non-null", NULL),
-                       "non-null");
-}
-
-// Tests ASSERT_STRNE.
-TEST(StringAssertionTest, ASSERT_STRNE) {
-  ASSERT_STRNE("hi", "Hi");
-  ASSERT_STRNE("Hi", NULL);
-  ASSERT_STRNE(NULL, "Hi");
-  ASSERT_STRNE("", NULL);
-  ASSERT_STRNE(NULL, "");
-  ASSERT_STRNE("", "Hi");
-  ASSERT_STRNE("Hi", "");
-  EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"),
-                       "\"Hi\" vs \"Hi\"");
-}
-
-// Tests ASSERT_STRCASEEQ.
-TEST(StringAssertionTest, ASSERT_STRCASEEQ) {
-  ASSERT_STRCASEEQ("hi", "Hi");
-  ASSERT_STRCASEEQ(static_cast<const char *>(NULL), NULL);
-
-  ASSERT_STRCASEEQ("", "");
-  EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"),
-                       "Ignoring case");
-}
-
-// Tests ASSERT_STRCASENE.
-TEST(StringAssertionTest, ASSERT_STRCASENE) {
-  ASSERT_STRCASENE("hi1", "Hi2");
-  ASSERT_STRCASENE("Hi", NULL);
-  ASSERT_STRCASENE(NULL, "Hi");
-  ASSERT_STRCASENE("", NULL);
-  ASSERT_STRCASENE(NULL, "");
-  ASSERT_STRCASENE("", "Hi");
-  ASSERT_STRCASENE("Hi", "");
-  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"),
-                       "(ignoring case)");
-}
-
-// Tests *_STREQ on wide strings.
-TEST(StringAssertionTest, STREQ_Wide) {
-  // NULL strings.
-  ASSERT_STREQ(static_cast<const wchar_t *>(NULL), NULL);
-
-  // Empty strings.
-  ASSERT_STREQ(L"", L"");
-
-  // Non-null vs NULL.
-  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"non-null", NULL),
-                          "non-null");
-
-  // Equal strings.
-  EXPECT_STREQ(L"Hi", L"Hi");
-
-  // Unequal strings.
-  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"),
-                          "Abc");
-
-  // Strings containing wide characters.
-  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"),
-                          "abc");
-
-  // The streaming variation.
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_STREQ(L"abc\x8119", L"abc\x8121") << "Expected failure";
-  }, "Expected failure");
-}
-
-// Tests *_STRNE on wide strings.
-TEST(StringAssertionTest, STRNE_Wide) {
-  // NULL strings.
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_STRNE(static_cast<const wchar_t *>(NULL), NULL);
-  }, "");
-
-  // Empty strings.
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""),
-                          "L\"\"");
-
-  // Non-null vs NULL.
-  ASSERT_STRNE(L"non-null", NULL);
-
-  // Equal strings.
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"),
-                          "L\"Hi\"");
-
-  // Unequal strings.
-  EXPECT_STRNE(L"abc", L"Abc");
-
-  // Strings containing wide characters.
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"),
-                          "abc");
-
-  // The streaming variation.
-  ASSERT_STRNE(L"abc\x8119", L"abc\x8120") << "This shouldn't happen";
-}
-
-// Tests for ::testing::IsSubstring().
-
-// Tests that IsSubstring() returns the correct result when the input
-// argument type is const char*.
-TEST(IsSubstringTest, ReturnsCorrectResultForCString) {
-  EXPECT_FALSE(IsSubstring("", "", NULL, "a"));
-  EXPECT_FALSE(IsSubstring("", "", "b", NULL));
-  EXPECT_FALSE(IsSubstring("", "", "needle", "haystack"));
-
-  EXPECT_TRUE(IsSubstring("", "", static_cast<const char*>(NULL), NULL));
-  EXPECT_TRUE(IsSubstring("", "", "needle", "two needles"));
-}
-
-// Tests that IsSubstring() returns the correct result when the input
-// argument type is const wchar_t*.
-TEST(IsSubstringTest, ReturnsCorrectResultForWideCString) {
-  EXPECT_FALSE(IsSubstring("", "", kNull, L"a"));
-  EXPECT_FALSE(IsSubstring("", "", L"b", kNull));
-  EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack"));
-
-  EXPECT_TRUE(IsSubstring("", "", static_cast<const wchar_t*>(NULL), NULL));
-  EXPECT_TRUE(IsSubstring("", "", L"needle", L"two needles"));
-}
-
-// Tests that IsSubstring() generates the correct message when the input
-// argument type is const char*.
-TEST(IsSubstringTest, GeneratesCorrectMessageForCString) {
-  EXPECT_STREQ("Value of: needle_expr\n"
-               "  Actual: \"needle\"\n"
-               "Expected: a substring of haystack_expr\n"
-               "Which is: \"haystack\"",
-               IsSubstring("needle_expr", "haystack_expr",
-                           "needle", "haystack").failure_message());
-}
-
-// Tests that IsSubstring returns the correct result when the input
-// argument type is ::std::string.
-TEST(IsSubstringTest, ReturnsCorrectResultsForStdString) {
-  EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob"));
-  EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world")));
-}
-
-#if GTEST_HAS_STD_WSTRING
-// Tests that IsSubstring returns the correct result when the input
-// argument type is ::std::wstring.
-TEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) {
-  EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles"));
-  EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack")));
-}
-
-// Tests that IsSubstring() generates the correct message when the input
-// argument type is ::std::wstring.
-TEST(IsSubstringTest, GeneratesCorrectMessageForWstring) {
-  EXPECT_STREQ("Value of: needle_expr\n"
-               "  Actual: L\"needle\"\n"
-               "Expected: a substring of haystack_expr\n"
-               "Which is: L\"haystack\"",
-               IsSubstring(
-                   "needle_expr", "haystack_expr",
-                   ::std::wstring(L"needle"), L"haystack").failure_message());
-}
-
-#endif  // GTEST_HAS_STD_WSTRING
-
-// Tests for ::testing::IsNotSubstring().
-
-// Tests that IsNotSubstring() returns the correct result when the input
-// argument type is const char*.
-TEST(IsNotSubstringTest, ReturnsCorrectResultForCString) {
-  EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack"));
-  EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles"));
-}
-
-// Tests that IsNotSubstring() returns the correct result when the input
-// argument type is const wchar_t*.
-TEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) {
-  EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack"));
-  EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles"));
-}
-
-// Tests that IsNotSubstring() generates the correct message when the input
-// argument type is const wchar_t*.
-TEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) {
-  EXPECT_STREQ("Value of: needle_expr\n"
-               "  Actual: L\"needle\"\n"
-               "Expected: not a substring of haystack_expr\n"
-               "Which is: L\"two needles\"",
-               IsNotSubstring(
-                   "needle_expr", "haystack_expr",
-                   L"needle", L"two needles").failure_message());
-}
-
-// Tests that IsNotSubstring returns the correct result when the input
-// argument type is ::std::string.
-TEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) {
-  EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob"));
-  EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world")));
-}
-
-// Tests that IsNotSubstring() generates the correct message when the input
-// argument type is ::std::string.
-TEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) {
-  EXPECT_STREQ("Value of: needle_expr\n"
-               "  Actual: \"needle\"\n"
-               "Expected: not a substring of haystack_expr\n"
-               "Which is: \"two needles\"",
-               IsNotSubstring(
-                   "needle_expr", "haystack_expr",
-                   ::std::string("needle"), "two needles").failure_message());
-}
-
-#if GTEST_HAS_STD_WSTRING
-
-// Tests that IsNotSubstring returns the correct result when the input
-// argument type is ::std::wstring.
-TEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) {
-  EXPECT_FALSE(
-      IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles"));
-  EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack")));
-}
-
-#endif  // GTEST_HAS_STD_WSTRING
-
-// Tests floating-point assertions.
-
-template <typename RawType>
-class FloatingPointTest : public Test {
- protected:
-  // Pre-calculated numbers to be used by the tests.
-  struct TestValues {
-    RawType close_to_positive_zero;
-    RawType close_to_negative_zero;
-    RawType further_from_negative_zero;
-
-    RawType close_to_one;
-    RawType further_from_one;
-
-    RawType infinity;
-    RawType close_to_infinity;
-    RawType further_from_infinity;
-
-    RawType nan1;
-    RawType nan2;
-  };
-
-  typedef typename testing::internal::FloatingPoint<RawType> Floating;
-  typedef typename Floating::Bits Bits;
-
-  virtual void SetUp() {
-    const size_t max_ulps = Floating::kMaxUlps;
-
-    // The bits that represent 0.0.
-    const Bits zero_bits = Floating(0).bits();
-
-    // Makes some numbers close to 0.0.
-    values_.close_to_positive_zero = Floating::ReinterpretBits(
-        zero_bits + max_ulps/2);
-    values_.close_to_negative_zero = -Floating::ReinterpretBits(
-        zero_bits + max_ulps - max_ulps/2);
-    values_.further_from_negative_zero = -Floating::ReinterpretBits(
-        zero_bits + max_ulps + 1 - max_ulps/2);
-
-    // The bits that represent 1.0.
-    const Bits one_bits = Floating(1).bits();
-
-    // Makes some numbers close to 1.0.
-    values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps);
-    values_.further_from_one = Floating::ReinterpretBits(
-        one_bits + max_ulps + 1);
-
-    // +infinity.
-    values_.infinity = Floating::Infinity();
-
-    // The bits that represent +infinity.
-    const Bits infinity_bits = Floating(values_.infinity).bits();
-
-    // Makes some numbers close to infinity.
-    values_.close_to_infinity = Floating::ReinterpretBits(
-        infinity_bits - max_ulps);
-    values_.further_from_infinity = Floating::ReinterpretBits(
-        infinity_bits - max_ulps - 1);
-
-    // Makes some NAN's.  Sets the most significant bit of the fraction so that
-    // our NaN's are quiet; trying to process a signaling NaN would raise an
-    // exception if our environment enables floating point exceptions.
-    values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask
-        | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1);
-    values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask
-        | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200);
-  }
-
-  void TestSize() {
-    EXPECT_EQ(sizeof(RawType), sizeof(Bits));
-  }
-
-  static TestValues values_;
-};
-
-template <typename RawType>
-typename FloatingPointTest<RawType>::TestValues
-    FloatingPointTest<RawType>::values_;
-
-// Instantiates FloatingPointTest for testing *_FLOAT_EQ.
-typedef FloatingPointTest<float> FloatTest;
-
-// Tests that the size of Float::Bits matches the size of float.
-TEST_F(FloatTest, Size) {
-  TestSize();
-}
-
-// Tests comparing with +0 and -0.
-TEST_F(FloatTest, Zeros) {
-  EXPECT_FLOAT_EQ(0.0, -0.0);
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0),
-                          "1.0");
-  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5),
-                       "1.5");
-}
-
-// Tests comparing numbers close to 0.
-//
-// This ensures that *_FLOAT_EQ handles the sign correctly and no
-// overflow occurs when comparing numbers whose absolute value is very
-// small.
-TEST_F(FloatTest, AlmostZeros) {
-  // In C++Builder, names within local classes (such as used by
-  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
-  // scoping class.  Use a static local alias as a workaround.
-  // We use the assignment syntax since some compilers, like Sun Studio,
-  // don't allow initializing references using construction syntax
-  // (parentheses).
-  static const FloatTest::TestValues& v = this->values_;
-
-  EXPECT_FLOAT_EQ(0.0, v.close_to_positive_zero);
-  EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero);
-  EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
-
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_FLOAT_EQ(v.close_to_positive_zero,
-                    v.further_from_negative_zero);
-  }, "v.further_from_negative_zero");
-}
-
-// Tests comparing numbers close to each other.
-TEST_F(FloatTest, SmallDiff) {
-  EXPECT_FLOAT_EQ(1.0, values_.close_to_one);
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, values_.further_from_one),
-                          "values_.further_from_one");
-}
-
-// Tests comparing numbers far apart.
-TEST_F(FloatTest, LargeDiff) {
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0),
-                          "3.0");
-}
-
-// Tests comparing with infinity.
-//
-// This ensures that no overflow occurs when comparing numbers whose
-// absolute value is very large.
-TEST_F(FloatTest, Infinity) {
-  EXPECT_FLOAT_EQ(values_.infinity, values_.close_to_infinity);
-  EXPECT_FLOAT_EQ(-values_.infinity, -values_.close_to_infinity);
-#if !GTEST_OS_SYMBIAN
-  // Nokia's STLport crashes if we try to output infinity or NaN.
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, -values_.infinity),
-                          "-values_.infinity");
-
-  // This is interesting as the representations of infinity and nan1
-  // are only 1 DLP apart.
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, values_.nan1),
-                          "values_.nan1");
-#endif  // !GTEST_OS_SYMBIAN
-}
-
-// Tests that comparing with NAN always returns false.
-TEST_F(FloatTest, NaN) {
-#if !GTEST_OS_SYMBIAN
-// Nokia's STLport crashes if we try to output infinity or NaN.
-
-  // In C++Builder, names within local classes (such as used by
-  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
-  // scoping class.  Use a static local alias as a workaround.
-  // We use the assignment syntax since some compilers, like Sun Studio,
-  // don't allow initializing references using construction syntax
-  // (parentheses).
-  static const FloatTest::TestValues& v = this->values_;
-
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1),
-                          "v.nan1");
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2),
-                          "v.nan2");
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1),
-                          "v.nan1");
-
-  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity),
-                       "v.infinity");
-#endif  // !GTEST_OS_SYMBIAN
-}
-
-// Tests that *_FLOAT_EQ are reflexive.
-TEST_F(FloatTest, Reflexive) {
-  EXPECT_FLOAT_EQ(0.0, 0.0);
-  EXPECT_FLOAT_EQ(1.0, 1.0);
-  ASSERT_FLOAT_EQ(values_.infinity, values_.infinity);
-}
-
-// Tests that *_FLOAT_EQ are commutative.
-TEST_F(FloatTest, Commutative) {
-  // We already tested EXPECT_FLOAT_EQ(1.0, values_.close_to_one).
-  EXPECT_FLOAT_EQ(values_.close_to_one, 1.0);
-
-  // We already tested EXPECT_FLOAT_EQ(1.0, values_.further_from_one).
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.further_from_one, 1.0),
-                          "1.0");
-}
-
-// Tests EXPECT_NEAR.
-TEST_F(FloatTest, EXPECT_NEAR) {
-  EXPECT_NEAR(-1.0f, -1.1f, 0.2f);
-  EXPECT_NEAR(2.0f, 3.0f, 1.0f);
-  EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f,1.5f, 0.25f),  // NOLINT
-                          "The difference between 1.0f and 1.5f is 0.5, "
-                          "which exceeds 0.25f");
-  // To work around a bug in gcc 2.95.0, there is intentionally no
-  // space after the first comma in the previous line.
-}
-
-// Tests ASSERT_NEAR.
-TEST_F(FloatTest, ASSERT_NEAR) {
-  ASSERT_NEAR(-1.0f, -1.1f, 0.2f);
-  ASSERT_NEAR(2.0f, 3.0f, 1.0f);
-  EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0f,1.5f, 0.25f),  // NOLINT
-                       "The difference between 1.0f and 1.5f is 0.5, "
-                       "which exceeds 0.25f");
-  // To work around a bug in gcc 2.95.0, there is intentionally no
-  // space after the first comma in the previous line.
-}
-
-// Tests the cases where FloatLE() should succeed.
-TEST_F(FloatTest, FloatLESucceeds) {
-  EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f);  // When val1 < val2,
-  ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f);  // val1 == val2,
-
-  // or when val1 is greater than, but almost equals to, val2.
-  EXPECT_PRED_FORMAT2(FloatLE, values_.close_to_positive_zero, 0.0f);
-}
-
-// Tests the cases where FloatLE() should fail.
-TEST_F(FloatTest, FloatLEFails) {
-  // When val1 is greater than val2 by a large margin,
-  EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f),
-                          "(2.0f) <= (1.0f)");
-
-  // or by a small yet non-negligible margin,
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f);
-  }, "(values_.further_from_one) <= (1.0f)");
-
-#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
-  // Nokia's STLport crashes if we try to output infinity or NaN.
-  // C++Builder gives bad results for ordered comparisons involving NaNs
-  // due to compiler bugs.
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity);
-  }, "(values_.nan1) <= (values_.infinity)");
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1);
-  }, "(-values_.infinity) <= (values_.nan1)");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1);
-  }, "(values_.nan1) <= (values_.nan1)");
-#endif  // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
-}
-
-// Instantiates FloatingPointTest for testing *_DOUBLE_EQ.
-typedef FloatingPointTest<double> DoubleTest;
-
-// Tests that the size of Double::Bits matches the size of double.
-TEST_F(DoubleTest, Size) {
-  TestSize();
-}
-
-// Tests comparing with +0 and -0.
-TEST_F(DoubleTest, Zeros) {
-  EXPECT_DOUBLE_EQ(0.0, -0.0);
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0),
-                          "1.0");
-  EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0),
-                       "1.0");
-}
-
-// Tests comparing numbers close to 0.
-//
-// This ensures that *_DOUBLE_EQ handles the sign correctly and no
-// overflow occurs when comparing numbers whose absolute value is very
-// small.
-TEST_F(DoubleTest, AlmostZeros) {
-  // In C++Builder, names within local classes (such as used by
-  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
-  // scoping class.  Use a static local alias as a workaround.
-  // We use the assignment syntax since some compilers, like Sun Studio,
-  // don't allow initializing references using construction syntax
-  // (parentheses).
-  static const DoubleTest::TestValues& v = this->values_;
-
-  EXPECT_DOUBLE_EQ(0.0, v.close_to_positive_zero);
-  EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero);
-  EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
-
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_DOUBLE_EQ(v.close_to_positive_zero,
-                     v.further_from_negative_zero);
-  }, "v.further_from_negative_zero");
-}
-
-// Tests comparing numbers close to each other.
-TEST_F(DoubleTest, SmallDiff) {
-  EXPECT_DOUBLE_EQ(1.0, values_.close_to_one);
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, values_.further_from_one),
-                          "values_.further_from_one");
-}
-
-// Tests comparing numbers far apart.
-TEST_F(DoubleTest, LargeDiff) {
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0),
-                          "3.0");
-}
-
-// Tests comparing with infinity.
-//
-// This ensures that no overflow occurs when comparing numbers whose
-// absolute value is very large.
-TEST_F(DoubleTest, Infinity) {
-  EXPECT_DOUBLE_EQ(values_.infinity, values_.close_to_infinity);
-  EXPECT_DOUBLE_EQ(-values_.infinity, -values_.close_to_infinity);
-#if !GTEST_OS_SYMBIAN
-  // Nokia's STLport crashes if we try to output infinity or NaN.
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, -values_.infinity),
-                          "-values_.infinity");
-
-  // This is interesting as the representations of infinity_ and nan1_
-  // are only 1 DLP apart.
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, values_.nan1),
-                          "values_.nan1");
-#endif  // !GTEST_OS_SYMBIAN
-}
-
-// Tests that comparing with NAN always returns false.
-TEST_F(DoubleTest, NaN) {
-#if !GTEST_OS_SYMBIAN
-  // In C++Builder, names within local classes (such as used by
-  // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
-  // scoping class.  Use a static local alias as a workaround.
-  // We use the assignment syntax since some compilers, like Sun Studio,
-  // don't allow initializing references using construction syntax
-  // (parentheses).
-  static const DoubleTest::TestValues& v = this->values_;
-
-  // Nokia's STLport crashes if we try to output infinity or NaN.
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1),
-                          "v.nan1");
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2");
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1");
-  EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity),
-                       "v.infinity");
-#endif  // !GTEST_OS_SYMBIAN
-}
-
-// Tests that *_DOUBLE_EQ are reflexive.
-TEST_F(DoubleTest, Reflexive) {
-  EXPECT_DOUBLE_EQ(0.0, 0.0);
-  EXPECT_DOUBLE_EQ(1.0, 1.0);
-#if !GTEST_OS_SYMBIAN
-  // Nokia's STLport crashes if we try to output infinity or NaN.
-  ASSERT_DOUBLE_EQ(values_.infinity, values_.infinity);
-#endif  // !GTEST_OS_SYMBIAN
-}
-
-// Tests that *_DOUBLE_EQ are commutative.
-TEST_F(DoubleTest, Commutative) {
-  // We already tested EXPECT_DOUBLE_EQ(1.0, values_.close_to_one).
-  EXPECT_DOUBLE_EQ(values_.close_to_one, 1.0);
-
-  // We already tested EXPECT_DOUBLE_EQ(1.0, values_.further_from_one).
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.further_from_one, 1.0),
-                          "1.0");
-}
-
-// Tests EXPECT_NEAR.
-TEST_F(DoubleTest, EXPECT_NEAR) {
-  EXPECT_NEAR(-1.0, -1.1, 0.2);
-  EXPECT_NEAR(2.0, 3.0, 1.0);
-  EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.5, 0.25),  // NOLINT
-                          "The difference between 1.0 and 1.5 is 0.5, "
-                          "which exceeds 0.25");
-  // To work around a bug in gcc 2.95.0, there is intentionally no
-  // space after the first comma in the previous statement.
-}
-
-// Tests ASSERT_NEAR.
-TEST_F(DoubleTest, ASSERT_NEAR) {
-  ASSERT_NEAR(-1.0, -1.1, 0.2);
-  ASSERT_NEAR(2.0, 3.0, 1.0);
-  EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.5, 0.25),  // NOLINT
-                       "The difference between 1.0 and 1.5 is 0.5, "
-                       "which exceeds 0.25");
-  // To work around a bug in gcc 2.95.0, there is intentionally no
-  // space after the first comma in the previous statement.
-}
-
-// Tests the cases where DoubleLE() should succeed.
-TEST_F(DoubleTest, DoubleLESucceeds) {
-  EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0);  // When val1 < val2,
-  ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0);  // val1 == val2,
-
-  // or when val1 is greater than, but almost equals to, val2.
-  EXPECT_PRED_FORMAT2(DoubleLE, values_.close_to_positive_zero, 0.0);
-}
-
-// Tests the cases where DoubleLE() should fail.
-TEST_F(DoubleTest, DoubleLEFails) {
-  // When val1 is greater than val2 by a large margin,
-  EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0),
-                          "(2.0) <= (1.0)");
-
-  // or by a small yet non-negligible margin,
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0);
-  }, "(values_.further_from_one) <= (1.0)");
-
-#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
-  // Nokia's STLport crashes if we try to output infinity or NaN.
-  // C++Builder gives bad results for ordered comparisons involving NaNs
-  // due to compiler bugs.
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity);
-  }, "(values_.nan1) <= (values_.infinity)");
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1);
-  }, " (-values_.infinity) <= (values_.nan1)");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1);
-  }, "(values_.nan1) <= (values_.nan1)");
-#endif  // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
-}
-
-
-// Verifies that a test or test case whose name starts with DISABLED_ is
-// not run.
-
-// A test whose name starts with DISABLED_.
-// Should not run.
-TEST(DisabledTest, DISABLED_TestShouldNotRun) {
-  FAIL() << "Unexpected failure: Disabled test should not be run.";
-}
-
-// A test whose name does not start with DISABLED_.
-// Should run.
-TEST(DisabledTest, NotDISABLED_TestShouldRun) {
-  EXPECT_EQ(1, 1);
-}
-
-// A test case whose name starts with DISABLED_.
-// Should not run.
-TEST(DISABLED_TestCase, TestShouldNotRun) {
-  FAIL() << "Unexpected failure: Test in disabled test case should not be run.";
-}
-
-// A test case and test whose names start with DISABLED_.
-// Should not run.
-TEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) {
-  FAIL() << "Unexpected failure: Test in disabled test case should not be run.";
-}
-
-// Check that when all tests in a test case are disabled, SetupTestCase() and
-// TearDownTestCase() are not called.
-class DisabledTestsTest : public Test {
- protected:
-  static void SetUpTestCase() {
-    FAIL() << "Unexpected failure: All tests disabled in test case. "
-              "SetupTestCase() should not be called.";
-  }
-
-  static void TearDownTestCase() {
-    FAIL() << "Unexpected failure: All tests disabled in test case. "
-              "TearDownTestCase() should not be called.";
-  }
-};
-
-TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) {
-  FAIL() << "Unexpected failure: Disabled test should not be run.";
-}
-
-TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) {
-  FAIL() << "Unexpected failure: Disabled test should not be run.";
-}
-
-// Tests that disabled typed tests aren't run.
-
-#if GTEST_HAS_TYPED_TEST
-
-template <typename T>
-class TypedTest : public Test {
-};
-
-typedef testing::Types<int, double> NumericTypes;
-TYPED_TEST_CASE(TypedTest, NumericTypes);
-
-TYPED_TEST(TypedTest, DISABLED_ShouldNotRun) {
-  FAIL() << "Unexpected failure: Disabled typed test should not run.";
-}
-
-template <typename T>
-class DISABLED_TypedTest : public Test {
-};
-
-TYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes);
-
-TYPED_TEST(DISABLED_TypedTest, ShouldNotRun) {
-  FAIL() << "Unexpected failure: Disabled typed test should not run.";
-}
-
-#endif  // GTEST_HAS_TYPED_TEST
-
-// Tests that disabled type-parameterized tests aren't run.
-
-#if GTEST_HAS_TYPED_TEST_P
-
-template <typename T>
-class TypedTestP : public Test {
-};
-
-TYPED_TEST_CASE_P(TypedTestP);
-
-TYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) {
-  FAIL() << "Unexpected failure: "
-         << "Disabled type-parameterized test should not run.";
-}
-
-REGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun);
-
-INSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes);
-
-template <typename T>
-class DISABLED_TypedTestP : public Test {
-};
-
-TYPED_TEST_CASE_P(DISABLED_TypedTestP);
-
-TYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) {
-  FAIL() << "Unexpected failure: "
-         << "Disabled type-parameterized test should not run.";
-}
-
-REGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun);
-
-INSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes);
-
-#endif  // GTEST_HAS_TYPED_TEST_P
-
-// Tests that assertion macros evaluate their arguments exactly once.
-
-class SingleEvaluationTest : public Test {
- public:  // Must be public and not protected due to a bug in g++ 3.4.2.
-  // This helper function is needed by the FailedASSERT_STREQ test
-  // below.  It's public to work around C++Builder's bug with scoping local
-  // classes.
-  static void CompareAndIncrementCharPtrs() {
-    ASSERT_STREQ(p1_++, p2_++);
-  }
-
-  // This helper function is needed by the FailedASSERT_NE test below.  It's
-  // public to work around C++Builder's bug with scoping local classes.
-  static void CompareAndIncrementInts() {
-    ASSERT_NE(a_++, b_++);
-  }
-
- protected:
-  SingleEvaluationTest() {
-    p1_ = s1_;
-    p2_ = s2_;
-    a_ = 0;
-    b_ = 0;
-  }
-
-  static const char* const s1_;
-  static const char* const s2_;
-  static const char* p1_;
-  static const char* p2_;
-
-  static int a_;
-  static int b_;
-};
-
-const char* const SingleEvaluationTest::s1_ = "01234";
-const char* const SingleEvaluationTest::s2_ = "abcde";
-const char* SingleEvaluationTest::p1_;
-const char* SingleEvaluationTest::p2_;
-int SingleEvaluationTest::a_;
-int SingleEvaluationTest::b_;
-
-// Tests that when ASSERT_STREQ fails, it evaluates its arguments
-// exactly once.
-TEST_F(SingleEvaluationTest, FailedASSERT_STREQ) {
-  EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementCharPtrs(),
-                       "p2_++");
-  EXPECT_EQ(s1_ + 1, p1_);
-  EXPECT_EQ(s2_ + 1, p2_);
-}
-
-// Tests that string assertion arguments are evaluated exactly once.
-TEST_F(SingleEvaluationTest, ASSERT_STR) {
-  // successful EXPECT_STRNE
-  EXPECT_STRNE(p1_++, p2_++);
-  EXPECT_EQ(s1_ + 1, p1_);
-  EXPECT_EQ(s2_ + 1, p2_);
-
-  // failed EXPECT_STRCASEEQ
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++),
-                          "Ignoring case");
-  EXPECT_EQ(s1_ + 2, p1_);
-  EXPECT_EQ(s2_ + 2, p2_);
-}
-
-// Tests that when ASSERT_NE fails, it evaluates its arguments exactly
-// once.
-TEST_F(SingleEvaluationTest, FailedASSERT_NE) {
-  EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementInts(),
-                       "(a_++) != (b_++)");
-  EXPECT_EQ(1, a_);
-  EXPECT_EQ(1, b_);
-}
-
-// Tests that assertion arguments are evaluated exactly once.
-TEST_F(SingleEvaluationTest, OtherCases) {
-  // successful EXPECT_TRUE
-  EXPECT_TRUE(0 == a_++);  // NOLINT
-  EXPECT_EQ(1, a_);
-
-  // failed EXPECT_TRUE
-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(-1 == a_++), "-1 == a_++");
-  EXPECT_EQ(2, a_);
-
-  // successful EXPECT_GT
-  EXPECT_GT(a_++, b_++);
-  EXPECT_EQ(3, a_);
-  EXPECT_EQ(1, b_);
-
-  // failed EXPECT_LT
-  EXPECT_NONFATAL_FAILURE(EXPECT_LT(a_++, b_++), "(a_++) < (b_++)");
-  EXPECT_EQ(4, a_);
-  EXPECT_EQ(2, b_);
-
-  // successful ASSERT_TRUE
-  ASSERT_TRUE(0 < a_++);  // NOLINT
-  EXPECT_EQ(5, a_);
-
-  // successful ASSERT_GT
-  ASSERT_GT(a_++, b_++);
-  EXPECT_EQ(6, a_);
-  EXPECT_EQ(3, b_);
-}
-
-#if GTEST_HAS_EXCEPTIONS
-
-void ThrowAnInteger() {
-  throw 1;
-}
-
-// Tests that assertion arguments are evaluated exactly once.
-TEST_F(SingleEvaluationTest, ExceptionTests) {
-  // successful EXPECT_THROW
-  EXPECT_THROW({  // NOLINT
-    a_++;
-    ThrowAnInteger();
-  }, int);
-  EXPECT_EQ(1, a_);
-
-  // failed EXPECT_THROW, throws different
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW({  // NOLINT
-    a_++;
-    ThrowAnInteger();
-  }, bool), "throws a different type");
-  EXPECT_EQ(2, a_);
-
-  // failed EXPECT_THROW, throws nothing
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing");
-  EXPECT_EQ(3, a_);
-
-  // successful EXPECT_NO_THROW
-  EXPECT_NO_THROW(a_++);
-  EXPECT_EQ(4, a_);
-
-  // failed EXPECT_NO_THROW
-  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({  // NOLINT
-    a_++;
-    ThrowAnInteger();
-  }), "it throws");
-  EXPECT_EQ(5, a_);
-
-  // successful EXPECT_ANY_THROW
-  EXPECT_ANY_THROW({  // NOLINT
-    a_++;
-    ThrowAnInteger();
-  });
-  EXPECT_EQ(6, a_);
-
-  // failed EXPECT_ANY_THROW
-  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't");
-  EXPECT_EQ(7, a_);
-}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// Tests {ASSERT|EXPECT}_NO_FATAL_FAILURE.
-class NoFatalFailureTest : public Test {
- protected:
-  void Succeeds() {}
-  void FailsNonFatal() {
-    ADD_FAILURE() << "some non-fatal failure";
-  }
-  void Fails() {
-    FAIL() << "some fatal failure";
-  }
-
-  void DoAssertNoFatalFailureOnFails() {
-    ASSERT_NO_FATAL_FAILURE(Fails());
-    ADD_FAILURE() << "shold not reach here.";
-  }
-
-  void DoExpectNoFatalFailureOnFails() {
-    EXPECT_NO_FATAL_FAILURE(Fails());
-    ADD_FAILURE() << "other failure";
-  }
-};
-
-TEST_F(NoFatalFailureTest, NoFailure) {
-  EXPECT_NO_FATAL_FAILURE(Succeeds());
-  ASSERT_NO_FATAL_FAILURE(Succeeds());
-}
-
-TEST_F(NoFatalFailureTest, NonFatalIsNoFailure) {
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_NO_FATAL_FAILURE(FailsNonFatal()),
-      "some non-fatal failure");
-  EXPECT_NONFATAL_FAILURE(
-      ASSERT_NO_FATAL_FAILURE(FailsNonFatal()),
-      "some non-fatal failure");
-}
-
-TEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) {
-  TestPartResultArray gtest_failures;
-  {
-    ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
-    DoAssertNoFatalFailureOnFails();
-  }
-  ASSERT_EQ(2, gtest_failures.size());
-  EXPECT_EQ(TestPartResult::kFatalFailure,
-            gtest_failures.GetTestPartResult(0).type());
-  EXPECT_EQ(TestPartResult::kFatalFailure,
-            gtest_failures.GetTestPartResult(1).type());
-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure",
-                      gtest_failures.GetTestPartResult(0).message());
-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does",
-                      gtest_failures.GetTestPartResult(1).message());
-}
-
-TEST_F(NoFatalFailureTest, ExpectNoFatalFailureOnFatalFailure) {
-  TestPartResultArray gtest_failures;
-  {
-    ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
-    DoExpectNoFatalFailureOnFails();
-  }
-  ASSERT_EQ(3, gtest_failures.size());
-  EXPECT_EQ(TestPartResult::kFatalFailure,
-            gtest_failures.GetTestPartResult(0).type());
-  EXPECT_EQ(TestPartResult::kNonFatalFailure,
-            gtest_failures.GetTestPartResult(1).type());
-  EXPECT_EQ(TestPartResult::kNonFatalFailure,
-            gtest_failures.GetTestPartResult(2).type());
-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure",
-                      gtest_failures.GetTestPartResult(0).message());
-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does",
-                      gtest_failures.GetTestPartResult(1).message());
-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "other failure",
-                      gtest_failures.GetTestPartResult(2).message());
-}
-
-TEST_F(NoFatalFailureTest, MessageIsStreamable) {
-  TestPartResultArray gtest_failures;
-  {
-    ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
-    EXPECT_NO_FATAL_FAILURE(FAIL() << "foo") << "my message";
-  }
-  ASSERT_EQ(2, gtest_failures.size());
-  EXPECT_EQ(TestPartResult::kNonFatalFailure,
-            gtest_failures.GetTestPartResult(0).type());
-  EXPECT_EQ(TestPartResult::kNonFatalFailure,
-            gtest_failures.GetTestPartResult(1).type());
-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "foo",
-                      gtest_failures.GetTestPartResult(0).message());
-  EXPECT_PRED_FORMAT2(testing::IsSubstring, "my message",
-                      gtest_failures.GetTestPartResult(1).message());
-}
-
-// Tests non-string assertions.
-
-std::string EditsToString(const std::vector<EditType>& edits) {
-  std::string out;
-  for (size_t i = 0; i < edits.size(); ++i) {
-    static const char kEdits[] = " +-/";
-    out.append(1, kEdits[edits[i]]);
-  }
-  return out;
-}
-
-std::vector<size_t> CharsToIndices(const std::string& str) {
-  std::vector<size_t> out;
-  for (size_t i = 0; i < str.size(); ++i) {
-    out.push_back(str[i]);
-  }
-  return out;
-}
-
-std::vector<std::string> CharsToLines(const std::string& str) {
-  std::vector<std::string> out;
-  for (size_t i = 0; i < str.size(); ++i) {
-    out.push_back(str.substr(i, 1));
-  }
-  return out;
-}
-
-TEST(EditDistance, TestCases) {
-  struct Case {
-    int line;
-    const char* left;
-    const char* right;
-    const char* expected_edits;
-    const char* expected_diff;
-  };
-  static const Case kCases[] = {
-      // No change.
-      {__LINE__, "A", "A", " ", ""},
-      {__LINE__, "ABCDE", "ABCDE", "     ", ""},
-      // Simple adds.
-      {__LINE__, "X", "XA", " +", "@@ +1,2 @@\n X\n+A\n"},
-      {__LINE__, "X", "XABCD", " ++++", "@@ +1,5 @@\n X\n+A\n+B\n+C\n+D\n"},
-      // Simple removes.
-      {__LINE__, "XA", "X", " -", "@@ -1,2 @@\n X\n-A\n"},
-      {__LINE__, "XABCD", "X", " ----", "@@ -1,5 @@\n X\n-A\n-B\n-C\n-D\n"},
-      // Simple replaces.
-      {__LINE__, "A", "a", "/", "@@ -1,1 +1,1 @@\n-A\n+a\n"},
-      {__LINE__, "ABCD", "abcd", "////",
-       "@@ -1,4 +1,4 @@\n-A\n-B\n-C\n-D\n+a\n+b\n+c\n+d\n"},
-      // Path finding.
-      {__LINE__, "ABCDEFGH", "ABXEGH1", "  -/ -  +",
-       "@@ -1,8 +1,7 @@\n A\n B\n-C\n-D\n+X\n E\n-F\n G\n H\n+1\n"},
-      {__LINE__, "AAAABCCCC", "ABABCDCDC", "- /   + / ",
-       "@@ -1,9 +1,9 @@\n-A\n A\n-A\n+B\n A\n B\n C\n+D\n C\n-C\n+D\n C\n"},
-      {__LINE__, "ABCDE", "BCDCD", "-   +/",
-       "@@ -1,5 +1,5 @@\n-A\n B\n C\n D\n-E\n+C\n+D\n"},
-      {__LINE__, "ABCDEFGHIJKL", "BCDCDEFGJKLJK", "- ++     --   ++",
-       "@@ -1,4 +1,5 @@\n-A\n B\n+C\n+D\n C\n D\n"
-       "@@ -6,7 +7,7 @@\n F\n G\n-H\n-I\n J\n K\n L\n+J\n+K\n"},
-      {}};
-  for (const Case* c = kCases; c->left; ++c) {
-    EXPECT_TRUE(c->expected_edits ==
-                EditsToString(CalculateOptimalEdits(CharsToIndices(c->left),
-                                                    CharsToIndices(c->right))))
-        << "Left <" << c->left << "> Right <" << c->right << "> Edits <"
-        << EditsToString(CalculateOptimalEdits(
-               CharsToIndices(c->left), CharsToIndices(c->right))) << ">";
-    EXPECT_TRUE(c->expected_diff == CreateUnifiedDiff(CharsToLines(c->left),
-                                                      CharsToLines(c->right)))
-        << "Left <" << c->left << "> Right <" << c->right << "> Diff <"
-        << CreateUnifiedDiff(CharsToLines(c->left), CharsToLines(c->right))
-        << ">";
-  }
-}
-
-// Tests EqFailure(), used for implementing *EQ* assertions.
-TEST(AssertionTest, EqFailure) {
-  const std::string foo_val("5"), bar_val("6");
-  const std::string msg1(
-      EqFailure("foo", "bar", foo_val, bar_val, false)
-      .failure_message());
-  EXPECT_STREQ(
-      "      Expected: foo\n"
-      "      Which is: 5\n"
-      "To be equal to: bar\n"
-      "      Which is: 6",
-      msg1.c_str());
-
-  const std::string msg2(
-      EqFailure("foo", "6", foo_val, bar_val, false)
-      .failure_message());
-  EXPECT_STREQ(
-      "      Expected: foo\n"
-      "      Which is: 5\n"
-      "To be equal to: 6",
-      msg2.c_str());
-
-  const std::string msg3(
-      EqFailure("5", "bar", foo_val, bar_val, false)
-      .failure_message());
-  EXPECT_STREQ(
-      "      Expected: 5\n"
-      "To be equal to: bar\n"
-      "      Which is: 6",
-      msg3.c_str());
-
-  const std::string msg4(
-      EqFailure("5", "6", foo_val, bar_val, false).failure_message());
-  EXPECT_STREQ(
-      "      Expected: 5\n"
-      "To be equal to: 6",
-      msg4.c_str());
-
-  const std::string msg5(
-      EqFailure("foo", "bar",
-                std::string("\"x\""), std::string("\"y\""),
-                true).failure_message());
-  EXPECT_STREQ(
-      "      Expected: foo\n"
-      "      Which is: \"x\"\n"
-      "To be equal to: bar\n"
-      "      Which is: \"y\"\n"
-      "Ignoring case",
-      msg5.c_str());
-}
-
-TEST(AssertionTest, EqFailureWithDiff) {
-  const std::string left(
-      "1\\n2XXX\\n3\\n5\\n6\\n7\\n8\\n9\\n10\\n11\\n12XXX\\n13\\n14\\n15");
-  const std::string right(
-      "1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14");
-  const std::string msg1(
-      EqFailure("left", "right", left, right, false).failure_message());
-  EXPECT_STREQ(
-      "      Expected: left\n"
-      "      Which is: "
-      "1\\n2XXX\\n3\\n5\\n6\\n7\\n8\\n9\\n10\\n11\\n12XXX\\n13\\n14\\n15\n"
-      "To be equal to: right\n"
-      "      Which is: 1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14\n"
-      "With diff:\n@@ -1,5 +1,6 @@\n 1\n-2XXX\n+2\n 3\n+4\n 5\n 6\n"
-      "@@ -7,8 +8,6 @@\n 8\n 9\n-10\n 11\n-12XXX\n+12\n 13\n 14\n-15\n",
-      msg1.c_str());
-}
-
-// Tests AppendUserMessage(), used for implementing the *EQ* macros.
-TEST(AssertionTest, AppendUserMessage) {
-  const std::string foo("foo");
-
-  Message msg;
-  EXPECT_STREQ("foo",
-               AppendUserMessage(foo, msg).c_str());
-
-  msg << "bar";
-  EXPECT_STREQ("foo\nbar",
-               AppendUserMessage(foo, msg).c_str());
-}
-
-#ifdef __BORLANDC__
-// Silences warnings: "Condition is always true", "Unreachable code"
-# pragma option push -w-ccc -w-rch
-#endif
-
-// Tests ASSERT_TRUE.
-TEST(AssertionTest, ASSERT_TRUE) {
-  ASSERT_TRUE(2 > 1);  // NOLINT
-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1),
-                       "2 < 1");
-}
-
-// Tests ASSERT_TRUE(predicate) for predicates returning AssertionResult.
-TEST(AssertionTest, AssertTrueWithAssertionResult) {
-  ASSERT_TRUE(ResultIsEven(2));
-#ifndef __BORLANDC__
-  // ICE's in C++Builder.
-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEven(3)),
-                       "Value of: ResultIsEven(3)\n"
-                       "  Actual: false (3 is odd)\n"
-                       "Expected: true");
-#endif
-  ASSERT_TRUE(ResultIsEvenNoExplanation(2));
-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEvenNoExplanation(3)),
-                       "Value of: ResultIsEvenNoExplanation(3)\n"
-                       "  Actual: false (3 is odd)\n"
-                       "Expected: true");
-}
-
-// Tests ASSERT_FALSE.
-TEST(AssertionTest, ASSERT_FALSE) {
-  ASSERT_FALSE(2 < 1);  // NOLINT
-  EXPECT_FATAL_FAILURE(ASSERT_FALSE(2 > 1),
-                       "Value of: 2 > 1\n"
-                       "  Actual: true\n"
-                       "Expected: false");
-}
-
-// Tests ASSERT_FALSE(predicate) for predicates returning AssertionResult.
-TEST(AssertionTest, AssertFalseWithAssertionResult) {
-  ASSERT_FALSE(ResultIsEven(3));
-#ifndef __BORLANDC__
-  // ICE's in C++Builder.
-  EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEven(2)),
-                       "Value of: ResultIsEven(2)\n"
-                       "  Actual: true (2 is even)\n"
-                       "Expected: false");
-#endif
-  ASSERT_FALSE(ResultIsEvenNoExplanation(3));
-  EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEvenNoExplanation(2)),
-                       "Value of: ResultIsEvenNoExplanation(2)\n"
-                       "  Actual: true\n"
-                       "Expected: false");
-}
-
-#ifdef __BORLANDC__
-// Restores warnings after previous "#pragma option push" supressed them
-# pragma option pop
-#endif
-
-// Tests using ASSERT_EQ on double values.  The purpose is to make
-// sure that the specialization we did for integer and anonymous enums
-// isn't used for double arguments.
-TEST(ExpectTest, ASSERT_EQ_Double) {
-  // A success.
-  ASSERT_EQ(5.6, 5.6);
-
-  // A failure.
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2),
-                       "5.1");
-}
-
-// Tests ASSERT_EQ.
-TEST(AssertionTest, ASSERT_EQ) {
-  ASSERT_EQ(5, 2 + 3);
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3),
-                       "      Expected: 5\n"
-                       "To be equal to: 2*3\n"
-                       "      Which is: 6");
-}
-
-// Tests ASSERT_EQ(NULL, pointer).
-#if GTEST_CAN_COMPARE_NULL
-TEST(AssertionTest, ASSERT_EQ_NULL) {
-  // A success.
-  const char* p = NULL;
-  // Some older GCC versions may issue a spurious waring in this or the next
-  // assertion statement. This warning should not be suppressed with
-  // static_cast since the test verifies the ability to use bare NULL as the
-  // expected parameter to the macro.
-  ASSERT_EQ(NULL, p);
-
-  // A failure.
-  static int n = 0;
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n),
-                       "To be equal to: &n\n");
-}
-#endif  // GTEST_CAN_COMPARE_NULL
-
-// Tests ASSERT_EQ(0, non_pointer).  Since the literal 0 can be
-// treated as a null pointer by the compiler, we need to make sure
-// that ASSERT_EQ(0, non_pointer) isn't interpreted by Google Test as
-// ASSERT_EQ(static_cast<void*>(NULL), non_pointer).
-TEST(ExpectTest, ASSERT_EQ_0) {
-  int n = 0;
-
-  // A success.
-  ASSERT_EQ(0, n);
-
-  // A failure.
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6),
-                       "Expected: 0");
-}
-
-// Tests ASSERT_NE.
-TEST(AssertionTest, ASSERT_NE) {
-  ASSERT_NE(6, 7);
-  EXPECT_FATAL_FAILURE(ASSERT_NE('a', 'a'),
-                       "Expected: ('a') != ('a'), "
-                       "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");
-}
-
-// Tests ASSERT_LE.
-TEST(AssertionTest, ASSERT_LE) {
-  ASSERT_LE(2, 3);
-  ASSERT_LE(2, 2);
-  EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0),
-                       "Expected: (2) <= (0), actual: 2 vs 0");
-}
-
-// Tests ASSERT_LT.
-TEST(AssertionTest, ASSERT_LT) {
-  ASSERT_LT(2, 3);
-  EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2),
-                       "Expected: (2) < (2), actual: 2 vs 2");
-}
-
-// Tests ASSERT_GE.
-TEST(AssertionTest, ASSERT_GE) {
-  ASSERT_GE(2, 1);
-  ASSERT_GE(2, 2);
-  EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3),
-                       "Expected: (2) >= (3), actual: 2 vs 3");
-}
-
-// Tests ASSERT_GT.
-TEST(AssertionTest, ASSERT_GT) {
-  ASSERT_GT(2, 1);
-  EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2),
-                       "Expected: (2) > (2), actual: 2 vs 2");
-}
-
-#if GTEST_HAS_EXCEPTIONS
-
-void ThrowNothing() {}
-
-// Tests ASSERT_THROW.
-TEST(AssertionTest, ASSERT_THROW) {
-  ASSERT_THROW(ThrowAnInteger(), int);
-
-# ifndef __BORLANDC__
-
-  // ICE's in C++Builder 2007 and 2009.
-  EXPECT_FATAL_FAILURE(
-      ASSERT_THROW(ThrowAnInteger(), bool),
-      "Expected: ThrowAnInteger() throws an exception of type bool.\n"
-      "  Actual: it throws a different type.");
-# endif
-
-  EXPECT_FATAL_FAILURE(
-      ASSERT_THROW(ThrowNothing(), bool),
-      "Expected: ThrowNothing() throws an exception of type bool.\n"
-      "  Actual: it throws nothing.");
-}
-
-// Tests ASSERT_NO_THROW.
-TEST(AssertionTest, ASSERT_NO_THROW) {
-  ASSERT_NO_THROW(ThrowNothing());
-  EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()),
-                       "Expected: ThrowAnInteger() doesn't throw an exception."
-                       "\n  Actual: it throws.");
-}
-
-// Tests ASSERT_ANY_THROW.
-TEST(AssertionTest, ASSERT_ANY_THROW) {
-  ASSERT_ANY_THROW(ThrowAnInteger());
-  EXPECT_FATAL_FAILURE(
-      ASSERT_ANY_THROW(ThrowNothing()),
-      "Expected: ThrowNothing() throws an exception.\n"
-      "  Actual: it doesn't.");
-}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// Makes sure we deal with the precedence of <<.  This test should
-// compile.
-TEST(AssertionTest, AssertPrecedence) {
-  ASSERT_EQ(1 < 2, true);
-  bool false_value = false;
-  ASSERT_EQ(true && false_value, false);
-}
-
-// A subroutine used by the following test.
-void TestEq1(int x) {
-  ASSERT_EQ(1, x);
-}
-
-// Tests calling a test subroutine that's not part of a fixture.
-TEST(AssertionTest, NonFixtureSubroutine) {
-  EXPECT_FATAL_FAILURE(TestEq1(2),
-                       "To be equal to: x");
-}
-
-// An uncopyable class.
-class Uncopyable {
- public:
-  explicit Uncopyable(int a_value) : value_(a_value) {}
-
-  int value() const { return value_; }
-  bool operator==(const Uncopyable& rhs) const {
-    return value() == rhs.value();
-  }
- private:
-  // This constructor deliberately has no implementation, as we don't
-  // want this class to be copyable.
-  Uncopyable(const Uncopyable&);  // NOLINT
-
-  int value_;
-};
-
-::std::ostream& operator<<(::std::ostream& os, const Uncopyable& value) {
-  return os << value.value();
-}
-
-
-bool IsPositiveUncopyable(const Uncopyable& x) {
-  return x.value() > 0;
-}
-
-// A subroutine used by the following test.
-void TestAssertNonPositive() {
-  Uncopyable y(-1);
-  ASSERT_PRED1(IsPositiveUncopyable, y);
-}
-// A subroutine used by the following test.
-void TestAssertEqualsUncopyable() {
-  Uncopyable x(5);
-  Uncopyable y(-1);
-  ASSERT_EQ(x, y);
-}
-
-// Tests that uncopyable objects can be used in assertions.
-TEST(AssertionTest, AssertWorksWithUncopyableObject) {
-  Uncopyable x(5);
-  ASSERT_PRED1(IsPositiveUncopyable, x);
-  ASSERT_EQ(x, x);
-  EXPECT_FATAL_FAILURE(TestAssertNonPositive(),
-    "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
-  EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(),
-    "Expected: x\n      Which is: 5\nTo be equal to: y\n      Which is: -1");
-}
-
-// Tests that uncopyable objects can be used in expects.
-TEST(AssertionTest, ExpectWorksWithUncopyableObject) {
-  Uncopyable x(5);
-  EXPECT_PRED1(IsPositiveUncopyable, x);
-  Uncopyable y(-1);
-  EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y),
-    "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
-  EXPECT_EQ(x, x);
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y),
-    "Expected: x\n      Which is: 5\nTo be equal to: y\n      Which is: -1");
-}
-
-enum NamedEnum {
-  kE1 = 0,
-  kE2 = 1
-};
-
-TEST(AssertionTest, NamedEnum) {
-  EXPECT_EQ(kE1, kE1);
-  EXPECT_LT(kE1, kE2);
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Which is: 0");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Which is: 1");
-}
-
-// The version of gcc used in XCode 2.2 has a bug and doesn't allow
-// anonymous enums in assertions.  Therefore the following test is not
-// done on Mac.
-// Sun Studio and HP aCC also reject this code.
-#if !GTEST_OS_MAC && !defined(__SUNPRO_CC) && !defined(__HP_aCC)
-
-// Tests using assertions with anonymous enums.
-enum {
-  kCaseA = -1,
-
-# if GTEST_OS_LINUX
-
-  // We want to test the case where the size of the anonymous enum is
-  // larger than sizeof(int), to make sure our implementation of the
-  // assertions doesn't truncate the enums.  However, MSVC
-  // (incorrectly) doesn't allow an enum value to exceed the range of
-  // an int, so this has to be conditionally compiled.
-  //
-  // On Linux, kCaseB and kCaseA have the same value when truncated to
-  // int size.  We want to test whether this will confuse the
-  // assertions.
-  kCaseB = testing::internal::kMaxBiggestInt,
-
-# else
-
-  kCaseB = INT_MAX,
-
-# endif  // GTEST_OS_LINUX
-
-  kCaseC = 42
-};
-
-TEST(AssertionTest, AnonymousEnum) {
-# if GTEST_OS_LINUX
-
-  EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB));
-
-# endif  // GTEST_OS_LINUX
-
-  EXPECT_EQ(kCaseA, kCaseA);
-  EXPECT_NE(kCaseA, kCaseB);
-  EXPECT_LT(kCaseA, kCaseB);
-  EXPECT_LE(kCaseA, kCaseB);
-  EXPECT_GT(kCaseB, kCaseA);
-  EXPECT_GE(kCaseA, kCaseA);
-  EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB),
-                          "(kCaseA) >= (kCaseB)");
-  EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC),
-                          "-1 vs 42");
-
-  ASSERT_EQ(kCaseA, kCaseA);
-  ASSERT_NE(kCaseA, kCaseB);
-  ASSERT_LT(kCaseA, kCaseB);
-  ASSERT_LE(kCaseA, kCaseB);
-  ASSERT_GT(kCaseB, kCaseA);
-  ASSERT_GE(kCaseA, kCaseA);
-
-# ifndef __BORLANDC__
-
-  // ICE's in C++Builder.
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB),
-                       "To be equal to: kCaseB");
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
-                       "Which is: 42");
-# endif
-
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
-                       "Which is: -1");
-}
-
-#endif  // !GTEST_OS_MAC && !defined(__SUNPRO_CC)
-
-#if GTEST_OS_WINDOWS
-
-static HRESULT UnexpectedHRESULTFailure() {
-  return E_UNEXPECTED;
-}
-
-static HRESULT OkHRESULTSuccess() {
-  return S_OK;
-}
-
-static HRESULT FalseHRESULTSuccess() {
-  return S_FALSE;
-}
-
-// HRESULT assertion tests test both zero and non-zero
-// success codes as well as failure message for each.
-//
-// Windows CE doesn't support message texts.
-TEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) {
-  EXPECT_HRESULT_SUCCEEDED(S_OK);
-  EXPECT_HRESULT_SUCCEEDED(S_FALSE);
-
-  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
-    "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
-    "  Actual: 0x8000FFFF");
-}
-
-TEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) {
-  ASSERT_HRESULT_SUCCEEDED(S_OK);
-  ASSERT_HRESULT_SUCCEEDED(S_FALSE);
-
-  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
-    "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
-    "  Actual: 0x8000FFFF");
-}
-
-TEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) {
-  EXPECT_HRESULT_FAILED(E_UNEXPECTED);
-
-  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()),
-    "Expected: (OkHRESULTSuccess()) fails.\n"
-    "  Actual: 0x0");
-  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()),
-    "Expected: (FalseHRESULTSuccess()) fails.\n"
-    "  Actual: 0x1");
-}
-
-TEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) {
-  ASSERT_HRESULT_FAILED(E_UNEXPECTED);
-
-# ifndef __BORLANDC__
-
-  // ICE's in C++Builder 2007 and 2009.
-  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()),
-    "Expected: (OkHRESULTSuccess()) fails.\n"
-    "  Actual: 0x0");
-# endif
-
-  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()),
-    "Expected: (FalseHRESULTSuccess()) fails.\n"
-    "  Actual: 0x1");
-}
-
-// Tests that streaming to the HRESULT macros works.
-TEST(HRESULTAssertionTest, Streaming) {
-  EXPECT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure";
-  ASSERT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure";
-  EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
-  ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
-
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
-      "expected failure");
-
-# ifndef __BORLANDC__
-
-  // ICE's in C++Builder 2007 and 2009.
-  EXPECT_FATAL_FAILURE(
-      ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
-      "expected failure");
-# endif
-
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_HRESULT_FAILED(S_OK) << "expected failure",
-      "expected failure");
-
-  EXPECT_FATAL_FAILURE(
-      ASSERT_HRESULT_FAILED(S_OK) << "expected failure",
-      "expected failure");
-}
-
-#endif  // GTEST_OS_WINDOWS
-
-#ifdef __BORLANDC__
-// Silences warnings: "Condition is always true", "Unreachable code"
-# pragma option push -w-ccc -w-rch
-#endif
-
-// Tests that the assertion macros behave like single statements.
-TEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) {
-  if (AlwaysFalse())
-    ASSERT_TRUE(false) << "This should never be executed; "
-                          "It's a compilation test only.";
-
-  if (AlwaysTrue())
-    EXPECT_FALSE(false);
-  else
-    ;  // NOLINT
-
-  if (AlwaysFalse())
-    ASSERT_LT(1, 3);
-
-  if (AlwaysFalse())
-    ;  // NOLINT
-  else
-    EXPECT_GT(3, 2) << "";
-}
-
-#if GTEST_HAS_EXCEPTIONS
-// Tests that the compiler will not complain about unreachable code in the
-// EXPECT_THROW/EXPECT_ANY_THROW/EXPECT_NO_THROW macros.
-TEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) {
-  int n = 0;
-
-  EXPECT_THROW(throw 1, int);
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(n++, int), "");
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(throw 1, const char*), "");
-  EXPECT_NO_THROW(n++);
-  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(throw 1), "");
-  EXPECT_ANY_THROW(throw 1);
-  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(n++), "");
-}
-
-TEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) {
-  if (AlwaysFalse())
-    EXPECT_THROW(ThrowNothing(), bool);
-
-  if (AlwaysTrue())
-    EXPECT_THROW(ThrowAnInteger(), int);
-  else
-    ;  // NOLINT
-
-  if (AlwaysFalse())
-    EXPECT_NO_THROW(ThrowAnInteger());
-
-  if (AlwaysTrue())
-    EXPECT_NO_THROW(ThrowNothing());
-  else
-    ;  // NOLINT
-
-  if (AlwaysFalse())
-    EXPECT_ANY_THROW(ThrowNothing());
-
-  if (AlwaysTrue())
-    EXPECT_ANY_THROW(ThrowAnInteger());
-  else
-    ;  // NOLINT
-}
-#endif  // GTEST_HAS_EXCEPTIONS
-
-TEST(AssertionSyntaxTest, NoFatalFailureAssertionsBehavesLikeSingleStatement) {
-  if (AlwaysFalse())
-    EXPECT_NO_FATAL_FAILURE(FAIL()) << "This should never be executed. "
-                                    << "It's a compilation test only.";
-  else
-    ;  // NOLINT
-
-  if (AlwaysFalse())
-    ASSERT_NO_FATAL_FAILURE(FAIL()) << "";
-  else
-    ;  // NOLINT
-
-  if (AlwaysTrue())
-    EXPECT_NO_FATAL_FAILURE(SUCCEED());
-  else
-    ;  // NOLINT
-
-  if (AlwaysFalse())
-    ;  // NOLINT
-  else
-    ASSERT_NO_FATAL_FAILURE(SUCCEED());
-}
-
-// Tests that the assertion macros work well with switch statements.
-TEST(AssertionSyntaxTest, WorksWithSwitch) {
-  switch (0) {
-    case 1:
-      break;
-    default:
-      ASSERT_TRUE(true);
-  }
-
-  switch (0)
-    case 0:
-      EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case";
-
-  // Binary assertions are implemented using a different code path
-  // than the Boolean assertions.  Hence we test them separately.
-  switch (0) {
-    case 1:
-    default:
-      ASSERT_EQ(1, 1) << "ASSERT_EQ failed in default switch handler";
-  }
-
-  switch (0)
-    case 0:
-      EXPECT_NE(1, 2);
-}
-
-#if GTEST_HAS_EXCEPTIONS
-
-void ThrowAString() {
-    throw "std::string";
-}
-
-// Test that the exception assertion macros compile and work with const
-// type qualifier.
-TEST(AssertionSyntaxTest, WorksWithConst) {
-    ASSERT_THROW(ThrowAString(), const char*);
-
-    EXPECT_THROW(ThrowAString(), const char*);
-}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-}  // namespace
-
-namespace testing {
-
-// Tests that Google Test tracks SUCCEED*.
-TEST(SuccessfulAssertionTest, SUCCEED) {
-  SUCCEED();
-  SUCCEED() << "OK";
-  EXPECT_EQ(2, GetUnitTestImpl()->current_test_result()->total_part_count());
-}
-
-// Tests that Google Test doesn't track successful EXPECT_*.
-TEST(SuccessfulAssertionTest, EXPECT) {
-  EXPECT_TRUE(true);
-  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
-}
-
-// Tests that Google Test doesn't track successful EXPECT_STR*.
-TEST(SuccessfulAssertionTest, EXPECT_STR) {
-  EXPECT_STREQ("", "");
-  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
-}
-
-// Tests that Google Test doesn't track successful ASSERT_*.
-TEST(SuccessfulAssertionTest, ASSERT) {
-  ASSERT_TRUE(true);
-  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
-}
-
-// Tests that Google Test doesn't track successful ASSERT_STR*.
-TEST(SuccessfulAssertionTest, ASSERT_STR) {
-  ASSERT_STREQ("", "");
-  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
-}
-
-}  // namespace testing
-
-namespace {
-
-// Tests the message streaming variation of assertions.
-
-TEST(AssertionWithMessageTest, EXPECT) {
-  EXPECT_EQ(1, 1) << "This should succeed.";
-  EXPECT_NONFATAL_FAILURE(EXPECT_NE(1, 1) << "Expected failure #1.",
-                          "Expected failure #1");
-  EXPECT_LE(1, 2) << "This should succeed.";
-  EXPECT_NONFATAL_FAILURE(EXPECT_LT(1, 0) << "Expected failure #2.",
-                          "Expected failure #2.");
-  EXPECT_GE(1, 0) << "This should succeed.";
-  EXPECT_NONFATAL_FAILURE(EXPECT_GT(1, 2) << "Expected failure #3.",
-                          "Expected failure #3.");
-
-  EXPECT_STREQ("1", "1") << "This should succeed.";
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("1", "1") << "Expected failure #4.",
-                          "Expected failure #4.");
-  EXPECT_STRCASEEQ("a", "A") << "This should succeed.";
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("a", "A") << "Expected failure #5.",
-                          "Expected failure #5.");
-
-  EXPECT_FLOAT_EQ(1, 1) << "This should succeed.";
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1, 1.2) << "Expected failure #6.",
-                          "Expected failure #6.");
-  EXPECT_NEAR(1, 1.1, 0.2) << "This should succeed.";
-}
-
-TEST(AssertionWithMessageTest, ASSERT) {
-  ASSERT_EQ(1, 1) << "This should succeed.";
-  ASSERT_NE(1, 2) << "This should succeed.";
-  ASSERT_LE(1, 2) << "This should succeed.";
-  ASSERT_LT(1, 2) << "This should succeed.";
-  ASSERT_GE(1, 0) << "This should succeed.";
-  EXPECT_FATAL_FAILURE(ASSERT_GT(1, 2) << "Expected failure.",
-                       "Expected failure.");
-}
-
-TEST(AssertionWithMessageTest, ASSERT_STR) {
-  ASSERT_STREQ("1", "1") << "This should succeed.";
-  ASSERT_STRNE("1", "2") << "This should succeed.";
-  ASSERT_STRCASEEQ("a", "A") << "This should succeed.";
-  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("a", "A") << "Expected failure.",
-                       "Expected failure.");
-}
-
-TEST(AssertionWithMessageTest, ASSERT_FLOATING) {
-  ASSERT_FLOAT_EQ(1, 1) << "This should succeed.";
-  ASSERT_DOUBLE_EQ(1, 1) << "This should succeed.";
-  EXPECT_FATAL_FAILURE(ASSERT_NEAR(1,1.2, 0.1) << "Expect failure.",  // NOLINT
-                       "Expect failure.");
-  // To work around a bug in gcc 2.95.0, there is intentionally no
-  // space after the first comma in the previous statement.
-}
-
-// Tests using ASSERT_FALSE with a streamed message.
-TEST(AssertionWithMessageTest, ASSERT_FALSE) {
-  ASSERT_FALSE(false) << "This shouldn't fail.";
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_FALSE(true) << "Expected failure: " << 2 << " > " << 1
-                       << " evaluates to " << true;
-  }, "Expected failure");
-}
-
-// Tests using FAIL with a streamed message.
-TEST(AssertionWithMessageTest, FAIL) {
-  EXPECT_FATAL_FAILURE(FAIL() << 0,
-                       "0");
-}
-
-// Tests using SUCCEED with a streamed message.
-TEST(AssertionWithMessageTest, SUCCEED) {
-  SUCCEED() << "Success == " << 1;
-}
-
-// Tests using ASSERT_TRUE with a streamed message.
-TEST(AssertionWithMessageTest, ASSERT_TRUE) {
-  ASSERT_TRUE(true) << "This should succeed.";
-  ASSERT_TRUE(true) << true;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_TRUE(false) << static_cast<const char *>(NULL)
-                       << static_cast<char *>(NULL);
-  }, "(null)(null)");
-}
-
-#if GTEST_OS_WINDOWS
-// Tests using wide strings in assertion messages.
-TEST(AssertionWithMessageTest, WideStringMessage) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_TRUE(false) << L"This failure is expected.\x8119";
-  }, "This failure is expected.");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_EQ(1, 2) << "This failure is "
-                    << L"expected too.\x8120";
-  }, "This failure is expected too.");
-}
-#endif  // GTEST_OS_WINDOWS
-
-// Tests EXPECT_TRUE.
-TEST(ExpectTest, EXPECT_TRUE) {
-  EXPECT_TRUE(true) << "Intentional success";
-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "Intentional failure #1.",
-                          "Intentional failure #1.");
-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "Intentional failure #2.",
-                          "Intentional failure #2.");
-  EXPECT_TRUE(2 > 1);  // NOLINT
-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 < 1),
-                          "Value of: 2 < 1\n"
-                          "  Actual: false\n"
-                          "Expected: true");
-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3),
-                          "2 > 3");
-}
-
-// Tests EXPECT_TRUE(predicate) for predicates returning AssertionResult.
-TEST(ExpectTest, ExpectTrueWithAssertionResult) {
-  EXPECT_TRUE(ResultIsEven(2));
-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEven(3)),
-                          "Value of: ResultIsEven(3)\n"
-                          "  Actual: false (3 is odd)\n"
-                          "Expected: true");
-  EXPECT_TRUE(ResultIsEvenNoExplanation(2));
-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEvenNoExplanation(3)),
-                          "Value of: ResultIsEvenNoExplanation(3)\n"
-                          "  Actual: false (3 is odd)\n"
-                          "Expected: true");
-}
-
-// Tests EXPECT_FALSE with a streamed message.
-TEST(ExpectTest, EXPECT_FALSE) {
-  EXPECT_FALSE(2 < 1);  // NOLINT
-  EXPECT_FALSE(false) << "Intentional success";
-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "Intentional failure #1.",
-                          "Intentional failure #1.");
-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "Intentional failure #2.",
-                          "Intentional failure #2.");
-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 > 1),
-                          "Value of: 2 > 1\n"
-                          "  Actual: true\n"
-                          "Expected: false");
-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3),
-                          "2 < 3");
-}
-
-// Tests EXPECT_FALSE(predicate) for predicates returning AssertionResult.
-TEST(ExpectTest, ExpectFalseWithAssertionResult) {
-  EXPECT_FALSE(ResultIsEven(3));
-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEven(2)),
-                          "Value of: ResultIsEven(2)\n"
-                          "  Actual: true (2 is even)\n"
-                          "Expected: false");
-  EXPECT_FALSE(ResultIsEvenNoExplanation(3));
-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEvenNoExplanation(2)),
-                          "Value of: ResultIsEvenNoExplanation(2)\n"
-                          "  Actual: true\n"
-                          "Expected: false");
-}
-
-#ifdef __BORLANDC__
-// Restores warnings after previous "#pragma option push" supressed them
-# pragma option pop
-#endif
-
-// Tests EXPECT_EQ.
-TEST(ExpectTest, EXPECT_EQ) {
-  EXPECT_EQ(5, 2 + 3);
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3),
-                          "      Expected: 5\n"
-                          "To be equal to: 2*3\n"
-                          "      Which is: 6");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3),
-                          "2 - 3");
-}
-
-// Tests using EXPECT_EQ on double values.  The purpose is to make
-// sure that the specialization we did for integer and anonymous enums
-// isn't used for double arguments.
-TEST(ExpectTest, EXPECT_EQ_Double) {
-  // A success.
-  EXPECT_EQ(5.6, 5.6);
-
-  // A failure.
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2),
-                          "5.1");
-}
-
-#if GTEST_CAN_COMPARE_NULL
-// Tests EXPECT_EQ(NULL, pointer).
-TEST(ExpectTest, EXPECT_EQ_NULL) {
-  // A success.
-  const char* p = NULL;
-  // Some older GCC versions may issue a spurious warning in this or the next
-  // assertion statement. This warning should not be suppressed with
-  // static_cast since the test verifies the ability to use bare NULL as the
-  // expected parameter to the macro.
-  EXPECT_EQ(NULL, p);
-
-  // A failure.
-  int n = 0;
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n),
-                          "To be equal to: &n\n");
-}
-#endif  // GTEST_CAN_COMPARE_NULL
-
-// Tests EXPECT_EQ(0, non_pointer).  Since the literal 0 can be
-// treated as a null pointer by the compiler, we need to make sure
-// that EXPECT_EQ(0, non_pointer) isn't interpreted by Google Test as
-// EXPECT_EQ(static_cast<void*>(NULL), non_pointer).
-TEST(ExpectTest, EXPECT_EQ_0) {
-  int n = 0;
-
-  // A success.
-  EXPECT_EQ(0, n);
-
-  // A failure.
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6),
-                          "Expected: 0");
-}
-
-// Tests EXPECT_NE.
-TEST(ExpectTest, EXPECT_NE) {
-  EXPECT_NE(6, 7);
-
-  EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'),
-                          "Expected: ('a') != ('a'), "
-                          "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");
-  EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2),
-                          "2");
-  char* const p0 = NULL;
-  EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0),
-                          "p0");
-  // Only way to get the Nokia compiler to compile the cast
-  // is to have a separate void* variable first. Putting
-  // the two casts on the same line doesn't work, neither does
-  // a direct C-style to char*.
-  void* pv1 = (void*)0x1234;  // NOLINT
-  char* const p1 = reinterpret_cast<char*>(pv1);
-  EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1),
-                          "p1");
-}
-
-// Tests EXPECT_LE.
-TEST(ExpectTest, EXPECT_LE) {
-  EXPECT_LE(2, 3);
-  EXPECT_LE(2, 2);
-  EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0),
-                          "Expected: (2) <= (0), actual: 2 vs 0");
-  EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9),
-                          "(1.1) <= (0.9)");
-}
-
-// Tests EXPECT_LT.
-TEST(ExpectTest, EXPECT_LT) {
-  EXPECT_LT(2, 3);
-  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2),
-                          "Expected: (2) < (2), actual: 2 vs 2");
-  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1),
-                          "(2) < (1)");
-}
-
-// Tests EXPECT_GE.
-TEST(ExpectTest, EXPECT_GE) {
-  EXPECT_GE(2, 1);
-  EXPECT_GE(2, 2);
-  EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3),
-                          "Expected: (2) >= (3), actual: 2 vs 3");
-  EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1),
-                          "(0.9) >= (1.1)");
-}
-
-// Tests EXPECT_GT.
-TEST(ExpectTest, EXPECT_GT) {
-  EXPECT_GT(2, 1);
-  EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2),
-                          "Expected: (2) > (2), actual: 2 vs 2");
-  EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3),
-                          "(2) > (3)");
-}
-
-#if GTEST_HAS_EXCEPTIONS
-
-// Tests EXPECT_THROW.
-TEST(ExpectTest, EXPECT_THROW) {
-  EXPECT_THROW(ThrowAnInteger(), int);
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool),
-                          "Expected: ThrowAnInteger() throws an exception of "
-                          "type bool.\n  Actual: it throws a different type.");
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_THROW(ThrowNothing(), bool),
-      "Expected: ThrowNothing() throws an exception of type bool.\n"
-      "  Actual: it throws nothing.");
-}
-
-// Tests EXPECT_NO_THROW.
-TEST(ExpectTest, EXPECT_NO_THROW) {
-  EXPECT_NO_THROW(ThrowNothing());
-  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()),
-                          "Expected: ThrowAnInteger() doesn't throw an "
-                          "exception.\n  Actual: it throws.");
-}
-
-// Tests EXPECT_ANY_THROW.
-TEST(ExpectTest, EXPECT_ANY_THROW) {
-  EXPECT_ANY_THROW(ThrowAnInteger());
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_ANY_THROW(ThrowNothing()),
-      "Expected: ThrowNothing() throws an exception.\n"
-      "  Actual: it doesn't.");
-}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// Make sure we deal with the precedence of <<.
-TEST(ExpectTest, ExpectPrecedence) {
-  EXPECT_EQ(1 < 2, true);
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false),
-                          "To be equal to: true && false");
-}
-
-
-// Tests the StreamableToString() function.
-
-// Tests using StreamableToString() on a scalar.
-TEST(StreamableToStringTest, Scalar) {
-  EXPECT_STREQ("5", StreamableToString(5).c_str());
-}
-
-// Tests using StreamableToString() on a non-char pointer.
-TEST(StreamableToStringTest, Pointer) {
-  int n = 0;
-  int* p = &n;
-  EXPECT_STRNE("(null)", StreamableToString(p).c_str());
-}
-
-// Tests using StreamableToString() on a NULL non-char pointer.
-TEST(StreamableToStringTest, NullPointer) {
-  int* p = NULL;
-  EXPECT_STREQ("(null)", StreamableToString(p).c_str());
-}
-
-// Tests using StreamableToString() on a C string.
-TEST(StreamableToStringTest, CString) {
-  EXPECT_STREQ("Foo", StreamableToString("Foo").c_str());
-}
-
-// Tests using StreamableToString() on a NULL C string.
-TEST(StreamableToStringTest, NullCString) {
-  char* p = NULL;
-  EXPECT_STREQ("(null)", StreamableToString(p).c_str());
-}
-
-// Tests using streamable values as assertion messages.
-
-// Tests using std::string as an assertion message.
-TEST(StreamableTest, string) {
-  static const std::string str(
-      "This failure message is a std::string, and is expected.");
-  EXPECT_FATAL_FAILURE(FAIL() << str,
-                       str.c_str());
-}
-
-// Tests that we can output strings containing embedded NULs.
-// Limited to Linux because we can only do this with std::string's.
-TEST(StreamableTest, stringWithEmbeddedNUL) {
-  static const char char_array_with_nul[] =
-      "Here's a NUL\0 and some more string";
-  static const std::string string_with_nul(char_array_with_nul,
-                                           sizeof(char_array_with_nul)
-                                           - 1);  // drops the trailing NUL
-  EXPECT_FATAL_FAILURE(FAIL() << string_with_nul,
-                       "Here's a NUL\\0 and some more string");
-}
-
-// Tests that we can output a NUL char.
-TEST(StreamableTest, NULChar) {
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    FAIL() << "A NUL" << '\0' << " and some more string";
-  }, "A NUL\\0 and some more string");
-}
-
-// Tests using int as an assertion message.
-TEST(StreamableTest, int) {
-  EXPECT_FATAL_FAILURE(FAIL() << 900913,
-                       "900913");
-}
-
-// Tests using NULL char pointer as an assertion message.
-//
-// In MSVC, streaming a NULL char * causes access violation.  Google Test
-// implemented a workaround (substituting "(null)" for NULL).  This
-// tests whether the workaround works.
-TEST(StreamableTest, NullCharPtr) {
-  EXPECT_FATAL_FAILURE(FAIL() << static_cast<const char*>(NULL),
-                       "(null)");
-}
-
-// Tests that basic IO manipulators (endl, ends, and flush) can be
-// streamed to testing::Message.
-TEST(StreamableTest, BasicIoManip) {
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    FAIL() << "Line 1." << std::endl
-           << "A NUL char " << std::ends << std::flush << " in line 2.";
-  }, "Line 1.\nA NUL char \\0 in line 2.");
-}
-
-// Tests the macros that haven't been covered so far.
-
-void AddFailureHelper(bool* aborted) {
-  *aborted = true;
-  ADD_FAILURE() << "Intentional failure.";
-  *aborted = false;
-}
-
-// Tests ADD_FAILURE.
-TEST(MacroTest, ADD_FAILURE) {
-  bool aborted = true;
-  EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted),
-                          "Intentional failure.");
-  EXPECT_FALSE(aborted);
-}
-
-// Tests ADD_FAILURE_AT.
-TEST(MacroTest, ADD_FAILURE_AT) {
-  // Verifies that ADD_FAILURE_AT does generate a nonfatal failure and
-  // the failure message contains the user-streamed part.
-  EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42) << "Wrong!", "Wrong!");
-
-  // Verifies that the user-streamed part is optional.
-  EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42), "Failed");
-
-  // Unfortunately, we cannot verify that the failure message contains
-  // the right file path and line number the same way, as
-  // EXPECT_NONFATAL_FAILURE() doesn't get to see the file path and
-  // line number.  Instead, we do that in gtest_output_test_.cc.
-}
-
-// Tests FAIL.
-TEST(MacroTest, FAIL) {
-  EXPECT_FATAL_FAILURE(FAIL(),
-                       "Failed");
-  EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.",
-                       "Intentional failure.");
-}
-
-// Tests SUCCEED
-TEST(MacroTest, SUCCEED) {
-  SUCCEED();
-  SUCCEED() << "Explicit success.";
-}
-
-// Tests for EXPECT_EQ() and ASSERT_EQ().
-//
-// These tests fail *intentionally*, s.t. the failure messages can be
-// generated and tested.
-//
-// We have different tests for different argument types.
-
-// Tests using bool values in {EXPECT|ASSERT}_EQ.
-TEST(EqAssertionTest, Bool) {
-  EXPECT_EQ(true,  true);
-  EXPECT_FATAL_FAILURE({
-      bool false_value = false;
-      ASSERT_EQ(false_value, true);
-    }, "To be equal to: true");
-}
-
-// Tests using int values in {EXPECT|ASSERT}_EQ.
-TEST(EqAssertionTest, Int) {
-  ASSERT_EQ(32, 32);
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33),
-                          "33");
-}
-
-// Tests using time_t values in {EXPECT|ASSERT}_EQ.
-TEST(EqAssertionTest, Time_T) {
-  EXPECT_EQ(static_cast<time_t>(0),
-            static_cast<time_t>(0));
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0),
-                                 static_cast<time_t>(1234)),
-                       "1234");
-}
-
-// Tests using char values in {EXPECT|ASSERT}_EQ.
-TEST(EqAssertionTest, Char) {
-  ASSERT_EQ('z', 'z');
-  const char ch = 'b';
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch),
-                          "ch");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch),
-                          "ch");
-}
-
-// Tests using wchar_t values in {EXPECT|ASSERT}_EQ.
-TEST(EqAssertionTest, WideChar) {
-  EXPECT_EQ(L'b', L'b');
-
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'),
-                          "      Expected: L'\0'\n"
-                          "      Which is: L'\0' (0, 0x0)\n"
-                          "To be equal to: L'x'\n"
-                          "      Which is: L'x' (120, 0x78)");
-
-  static wchar_t wchar;
-  wchar = L'b';
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar),
-                          "wchar");
-  wchar = 0x8119;
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar),
-                       "To be equal to: wchar");
-}
-
-// Tests using ::std::string values in {EXPECT|ASSERT}_EQ.
-TEST(EqAssertionTest, StdString) {
-  // Compares a const char* to an std::string that has identical
-  // content.
-  ASSERT_EQ("Test", ::std::string("Test"));
-
-  // Compares two identical std::strings.
-  static const ::std::string str1("A * in the middle");
-  static const ::std::string str2(str1);
-  EXPECT_EQ(str1, str2);
-
-  // Compares a const char* to an std::string that has different
-  // content
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")),
-                          "\"test\"");
-
-  // Compares an std::string to a char* that has different content.
-  char* const p1 = const_cast<char*>("foo");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1),
-                          "p1");
-
-  // Compares two std::strings that have different contents, one of
-  // which having a NUL character in the middle.  This should fail.
-  static ::std::string str3(str1);
-  str3.at(2) = '\0';
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3),
-                       "To be equal to: str3\n"
-                       "      Which is: \"A \\0 in the middle\"");
-}
-
-#if GTEST_HAS_STD_WSTRING
-
-// Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ.
-TEST(EqAssertionTest, StdWideString) {
-  // Compares two identical std::wstrings.
-  const ::std::wstring wstr1(L"A * in the middle");
-  const ::std::wstring wstr2(wstr1);
-  ASSERT_EQ(wstr1, wstr2);
-
-  // Compares an std::wstring to a const wchar_t* that has identical
-  // content.
-  const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };
-  EXPECT_EQ(::std::wstring(kTestX8119), kTestX8119);
-
-  // Compares an std::wstring to a const wchar_t* that has different
-  // content.
-  const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120);
-  }, "kTestX8120");
-
-  // Compares two std::wstrings that have different contents, one of
-  // which having a NUL character in the middle.
-  ::std::wstring wstr3(wstr1);
-  wstr3.at(2) = L'\0';
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3),
-                          "wstr3");
-
-  // Compares a wchar_t* to an std::wstring that has different
-  // content.
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar"));
-  }, "");
-}
-
-#endif  // GTEST_HAS_STD_WSTRING
-
-#if GTEST_HAS_GLOBAL_STRING
-// Tests using ::string values in {EXPECT|ASSERT}_EQ.
-TEST(EqAssertionTest, GlobalString) {
-  // Compares a const char* to a ::string that has identical content.
-  EXPECT_EQ("Test", ::string("Test"));
-
-  // Compares two identical ::strings.
-  const ::string str1("A * in the middle");
-  const ::string str2(str1);
-  ASSERT_EQ(str1, str2);
-
-  // Compares a ::string to a const char* that has different content.
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::string("Test"), "test"),
-                          "test");
-
-  // Compares two ::strings that have different contents, one of which
-  // having a NUL character in the middle.
-  ::string str3(str1);
-  str3.at(2) = '\0';
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(str1, str3),
-                          "str3");
-
-  // Compares a ::string to a char* that has different content.
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_EQ(::string("bar"), const_cast<char*>("foo"));
-  }, "");
-}
-
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-#if GTEST_HAS_GLOBAL_WSTRING
-
-// Tests using ::wstring values in {EXPECT|ASSERT}_EQ.
-TEST(EqAssertionTest, GlobalWideString) {
-  // Compares two identical ::wstrings.
-  static const ::wstring wstr1(L"A * in the middle");
-  static const ::wstring wstr2(wstr1);
-  EXPECT_EQ(wstr1, wstr2);
-
-  // Compares a const wchar_t* to a ::wstring that has identical content.
-  const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };
-  ASSERT_EQ(kTestX8119, ::wstring(kTestX8119));
-
-  // Compares a const wchar_t* to a ::wstring that has different
-  // content.
-  const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_EQ(kTestX8120, ::wstring(kTestX8119));
-  }, "Test\\x8119");
-
-  // Compares a wchar_t* to a ::wstring that has different content.
-  wchar_t* const p1 = const_cast<wchar_t*>(L"foo");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, ::wstring(L"bar")),
-                          "bar");
-
-  // Compares two ::wstrings that have different contents, one of which
-  // having a NUL character in the middle.
-  static ::wstring wstr3;
-  wstr3 = wstr1;
-  wstr3.at(2) = L'\0';
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(wstr1, wstr3),
-                       "wstr3");
-}
-
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-// Tests using char pointers in {EXPECT|ASSERT}_EQ.
-TEST(EqAssertionTest, CharPointer) {
-  char* const p0 = NULL;
-  // Only way to get the Nokia compiler to compile the cast
-  // is to have a separate void* variable first. Putting
-  // the two casts on the same line doesn't work, neither does
-  // a direct C-style to char*.
-  void* pv1 = (void*)0x1234;  // NOLINT
-  void* pv2 = (void*)0xABC0;  // NOLINT
-  char* const p1 = reinterpret_cast<char*>(pv1);
-  char* const p2 = reinterpret_cast<char*>(pv2);
-  ASSERT_EQ(p1, p1);
-
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
-                          "To be equal to: p2");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
-                          "p2");
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234),
-                                 reinterpret_cast<char*>(0xABC0)),
-                       "ABC0");
-}
-
-// Tests using wchar_t pointers in {EXPECT|ASSERT}_EQ.
-TEST(EqAssertionTest, WideCharPointer) {
-  wchar_t* const p0 = NULL;
-  // Only way to get the Nokia compiler to compile the cast
-  // is to have a separate void* variable first. Putting
-  // the two casts on the same line doesn't work, neither does
-  // a direct C-style to char*.
-  void* pv1 = (void*)0x1234;  // NOLINT
-  void* pv2 = (void*)0xABC0;  // NOLINT
-  wchar_t* const p1 = reinterpret_cast<wchar_t*>(pv1);
-  wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2);
-  EXPECT_EQ(p0, p0);
-
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
-                          "To be equal to: p2");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
-                          "p2");
-  void* pv3 = (void*)0x1234;  // NOLINT
-  void* pv4 = (void*)0xABC0;  // NOLINT
-  const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3);
-  const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4);
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4),
-                          "p4");
-}
-
-// Tests using other types of pointers in {EXPECT|ASSERT}_EQ.
-TEST(EqAssertionTest, OtherPointer) {
-  ASSERT_EQ(static_cast<const int*>(NULL),
-            static_cast<const int*>(NULL));
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<const int*>(NULL),
-                                 reinterpret_cast<const int*>(0x1234)),
-                       "0x1234");
-}
-
-// A class that supports binary comparison operators but not streaming.
-class UnprintableChar {
- public:
-  explicit UnprintableChar(char ch) : char_(ch) {}
-
-  bool operator==(const UnprintableChar& rhs) const {
-    return char_ == rhs.char_;
-  }
-  bool operator!=(const UnprintableChar& rhs) const {
-    return char_ != rhs.char_;
-  }
-  bool operator<(const UnprintableChar& rhs) const {
-    return char_ < rhs.char_;
-  }
-  bool operator<=(const UnprintableChar& rhs) const {
-    return char_ <= rhs.char_;
-  }
-  bool operator>(const UnprintableChar& rhs) const {
-    return char_ > rhs.char_;
-  }
-  bool operator>=(const UnprintableChar& rhs) const {
-    return char_ >= rhs.char_;
-  }
-
- private:
-  char char_;
-};
-
-// Tests that ASSERT_EQ() and friends don't require the arguments to
-// be printable.
-TEST(ComparisonAssertionTest, AcceptsUnprintableArgs) {
-  const UnprintableChar x('x'), y('y');
-  ASSERT_EQ(x, x);
-  EXPECT_NE(x, y);
-  ASSERT_LT(x, y);
-  EXPECT_LE(x, y);
-  ASSERT_GT(y, x);
-  EXPECT_GE(x, x);
-
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <78>");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <79>");
-  EXPECT_NONFATAL_FAILURE(EXPECT_LT(y, y), "1-byte object <79>");
-  EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <78>");
-  EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <79>");
-
-  // Code tested by EXPECT_FATAL_FAILURE cannot reference local
-  // variables, so we have to write UnprintableChar('x') instead of x.
-#ifndef __BORLANDC__
-  // ICE's in C++Builder.
-  EXPECT_FATAL_FAILURE(ASSERT_NE(UnprintableChar('x'), UnprintableChar('x')),
-                       "1-byte object <78>");
-  EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')),
-                       "1-byte object <78>");
-#endif
-  EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')),
-                       "1-byte object <79>");
-  EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')),
-                       "1-byte object <78>");
-  EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')),
-                       "1-byte object <79>");
-}
-
-// Tests the FRIEND_TEST macro.
-
-// This class has a private member we want to test.  We will test it
-// both in a TEST and in a TEST_F.
-class Foo {
- public:
-  Foo() {}
-
- private:
-  int Bar() const { return 1; }
-
-  // Declares the friend tests that can access the private member
-  // Bar().
-  FRIEND_TEST(FRIEND_TEST_Test, TEST);
-  FRIEND_TEST(FRIEND_TEST_Test2, TEST_F);
-};
-
-// Tests that the FRIEND_TEST declaration allows a TEST to access a
-// class's private members.  This should compile.
-TEST(FRIEND_TEST_Test, TEST) {
-  ASSERT_EQ(1, Foo().Bar());
-}
-
-// The fixture needed to test using FRIEND_TEST with TEST_F.
-class FRIEND_TEST_Test2 : public Test {
- protected:
-  Foo foo;
-};
-
-// Tests that the FRIEND_TEST declaration allows a TEST_F to access a
-// class's private members.  This should compile.
-TEST_F(FRIEND_TEST_Test2, TEST_F) {
-  ASSERT_EQ(1, foo.Bar());
-}
-
-// Tests the life cycle of Test objects.
-
-// The test fixture for testing the life cycle of Test objects.
-//
-// This class counts the number of live test objects that uses this
-// fixture.
-class TestLifeCycleTest : public Test {
- protected:
-  // Constructor.  Increments the number of test objects that uses
-  // this fixture.
-  TestLifeCycleTest() { count_++; }
-
-  // Destructor.  Decrements the number of test objects that uses this
-  // fixture.
-  ~TestLifeCycleTest() { count_--; }
-
-  // Returns the number of live test objects that uses this fixture.
-  int count() const { return count_; }
-
- private:
-  static int count_;
-};
-
-int TestLifeCycleTest::count_ = 0;
-
-// Tests the life cycle of test objects.
-TEST_F(TestLifeCycleTest, Test1) {
-  // There should be only one test object in this test case that's
-  // currently alive.
-  ASSERT_EQ(1, count());
-}
-
-// Tests the life cycle of test objects.
-TEST_F(TestLifeCycleTest, Test2) {
-  // After Test1 is done and Test2 is started, there should still be
-  // only one live test object, as the object for Test1 should've been
-  // deleted.
-  ASSERT_EQ(1, count());
-}
-
-}  // namespace
-
-// Tests that the copy constructor works when it is NOT optimized away by
-// the compiler.
-TEST(AssertionResultTest, CopyConstructorWorksWhenNotOptimied) {
-  // Checks that the copy constructor doesn't try to dereference NULL pointers
-  // in the source object.
-  AssertionResult r1 = AssertionSuccess();
-  AssertionResult r2 = r1;
-  // The following line is added to prevent the compiler from optimizing
-  // away the constructor call.
-  r1 << "abc";
-
-  AssertionResult r3 = r1;
-  EXPECT_EQ(static_cast<bool>(r3), static_cast<bool>(r1));
-  EXPECT_STREQ("abc", r1.message());
-}
-
-// Tests that AssertionSuccess and AssertionFailure construct
-// AssertionResult objects as expected.
-TEST(AssertionResultTest, ConstructionWorks) {
-  AssertionResult r1 = AssertionSuccess();
-  EXPECT_TRUE(r1);
-  EXPECT_STREQ("", r1.message());
-
-  AssertionResult r2 = AssertionSuccess() << "abc";
-  EXPECT_TRUE(r2);
-  EXPECT_STREQ("abc", r2.message());
-
-  AssertionResult r3 = AssertionFailure();
-  EXPECT_FALSE(r3);
-  EXPECT_STREQ("", r3.message());
-
-  AssertionResult r4 = AssertionFailure() << "def";
-  EXPECT_FALSE(r4);
-  EXPECT_STREQ("def", r4.message());
-
-  AssertionResult r5 = AssertionFailure(Message() << "ghi");
-  EXPECT_FALSE(r5);
-  EXPECT_STREQ("ghi", r5.message());
-}
-
-// Tests that the negation flips the predicate result but keeps the message.
-TEST(AssertionResultTest, NegationWorks) {
-  AssertionResult r1 = AssertionSuccess() << "abc";
-  EXPECT_FALSE(!r1);
-  EXPECT_STREQ("abc", (!r1).message());
-
-  AssertionResult r2 = AssertionFailure() << "def";
-  EXPECT_TRUE(!r2);
-  EXPECT_STREQ("def", (!r2).message());
-}
-
-TEST(AssertionResultTest, StreamingWorks) {
-  AssertionResult r = AssertionSuccess();
-  r << "abc" << 'd' << 0 << true;
-  EXPECT_STREQ("abcd0true", r.message());
-}
-
-TEST(AssertionResultTest, CanStreamOstreamManipulators) {
-  AssertionResult r = AssertionSuccess();
-  r << "Data" << std::endl << std::flush << std::ends << "Will be visible";
-  EXPECT_STREQ("Data\n\\0Will be visible", r.message());
-}
-
-// The next test uses explicit conversion operators -- a C++11 feature.
-#if GTEST_LANG_CXX11
-
-TEST(AssertionResultTest, ConstructibleFromContextuallyConvertibleToBool) {
-  struct ExplicitlyConvertibleToBool {
-    explicit operator bool() const { return value; }
-    bool value;
-  };
-  ExplicitlyConvertibleToBool v1 = {false};
-  ExplicitlyConvertibleToBool v2 = {true};
-  EXPECT_FALSE(v1);
-  EXPECT_TRUE(v2);
-}
-
-#endif  // GTEST_LANG_CXX11
-
-struct ConvertibleToAssertionResult {
-  operator AssertionResult() const { return AssertionResult(true); }
-};
-
-TEST(AssertionResultTest, ConstructibleFromImplicitlyConvertible) {
-  ConvertibleToAssertionResult obj;
-  EXPECT_TRUE(obj);
-}
-
-// Tests streaming a user type whose definition and operator << are
-// both in the global namespace.
-class Base {
- public:
-  explicit Base(int an_x) : x_(an_x) {}
-  int x() const { return x_; }
- private:
-  int x_;
-};
-std::ostream& operator<<(std::ostream& os,
-                         const Base& val) {
-  return os << val.x();
-}
-std::ostream& operator<<(std::ostream& os,
-                         const Base* pointer) {
-  return os << "(" << pointer->x() << ")";
-}
-
-TEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) {
-  Message msg;
-  Base a(1);
-
-  msg << a << &a;  // Uses ::operator<<.
-  EXPECT_STREQ("1(1)", msg.GetString().c_str());
-}
-
-// Tests streaming a user type whose definition and operator<< are
-// both in an unnamed namespace.
-namespace {
-class MyTypeInUnnamedNameSpace : public Base {
- public:
-  explicit MyTypeInUnnamedNameSpace(int an_x): Base(an_x) {}
-};
-std::ostream& operator<<(std::ostream& os,
-                         const MyTypeInUnnamedNameSpace& val) {
-  return os << val.x();
-}
-std::ostream& operator<<(std::ostream& os,
-                         const MyTypeInUnnamedNameSpace* pointer) {
-  return os << "(" << pointer->x() << ")";
-}
-}  // namespace
-
-TEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) {
-  Message msg;
-  MyTypeInUnnamedNameSpace a(1);
-
-  msg << a << &a;  // Uses <unnamed_namespace>::operator<<.
-  EXPECT_STREQ("1(1)", msg.GetString().c_str());
-}
-
-// Tests streaming a user type whose definition and operator<< are
-// both in a user namespace.
-namespace namespace1 {
-class MyTypeInNameSpace1 : public Base {
- public:
-  explicit MyTypeInNameSpace1(int an_x): Base(an_x) {}
-};
-std::ostream& operator<<(std::ostream& os,
-                         const MyTypeInNameSpace1& val) {
-  return os << val.x();
-}
-std::ostream& operator<<(std::ostream& os,
-                         const MyTypeInNameSpace1* pointer) {
-  return os << "(" << pointer->x() << ")";
-}
-}  // namespace namespace1
-
-TEST(MessageTest, CanStreamUserTypeInUserNameSpace) {
-  Message msg;
-  namespace1::MyTypeInNameSpace1 a(1);
-
-  msg << a << &a;  // Uses namespace1::operator<<.
-  EXPECT_STREQ("1(1)", msg.GetString().c_str());
-}
-
-// Tests streaming a user type whose definition is in a user namespace
-// but whose operator<< is in the global namespace.
-namespace namespace2 {
-class MyTypeInNameSpace2 : public ::Base {
- public:
-  explicit MyTypeInNameSpace2(int an_x): Base(an_x) {}
-};
-}  // namespace namespace2
-std::ostream& operator<<(std::ostream& os,
-                         const namespace2::MyTypeInNameSpace2& val) {
-  return os << val.x();
-}
-std::ostream& operator<<(std::ostream& os,
-                         const namespace2::MyTypeInNameSpace2* pointer) {
-  return os << "(" << pointer->x() << ")";
-}
-
-TEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) {
-  Message msg;
-  namespace2::MyTypeInNameSpace2 a(1);
-
-  msg << a << &a;  // Uses ::operator<<.
-  EXPECT_STREQ("1(1)", msg.GetString().c_str());
-}
-
-// Tests streaming NULL pointers to testing::Message.
-TEST(MessageTest, NullPointers) {
-  Message msg;
-  char* const p1 = NULL;
-  unsigned char* const p2 = NULL;
-  int* p3 = NULL;
-  double* p4 = NULL;
-  bool* p5 = NULL;
-  Message* p6 = NULL;
-
-  msg << p1 << p2 << p3 << p4 << p5 << p6;
-  ASSERT_STREQ("(null)(null)(null)(null)(null)(null)",
-               msg.GetString().c_str());
-}
-
-// Tests streaming wide strings to testing::Message.
-TEST(MessageTest, WideStrings) {
-  // Streams a NULL of type const wchar_t*.
-  const wchar_t* const_wstr = NULL;
-  EXPECT_STREQ("(null)",
-               (Message() << const_wstr).GetString().c_str());
-
-  // Streams a NULL of type wchar_t*.
-  wchar_t* wstr = NULL;
-  EXPECT_STREQ("(null)",
-               (Message() << wstr).GetString().c_str());
-
-  // Streams a non-NULL of type const wchar_t*.
-  const_wstr = L"abc\x8119";
-  EXPECT_STREQ("abc\xe8\x84\x99",
-               (Message() << const_wstr).GetString().c_str());
-
-  // Streams a non-NULL of type wchar_t*.
-  wstr = const_cast<wchar_t*>(const_wstr);
-  EXPECT_STREQ("abc\xe8\x84\x99",
-               (Message() << wstr).GetString().c_str());
-}
-
-
-// This line tests that we can define tests in the testing namespace.
-namespace testing {
-
-// Tests the TestInfo class.
-
-class TestInfoTest : public Test {
- protected:
-  static const TestInfo* GetTestInfo(const char* test_name) {
-    const TestCase* const test_case = GetUnitTestImpl()->
-        GetTestCase("TestInfoTest", "", NULL, NULL);
-
-    for (int i = 0; i < test_case->total_test_count(); ++i) {
-      const TestInfo* const test_info = test_case->GetTestInfo(i);
-      if (strcmp(test_name, test_info->name()) == 0)
-        return test_info;
-    }
-    return NULL;
-  }
-
-  static const TestResult* GetTestResult(
-      const TestInfo* test_info) {
-    return test_info->result();
-  }
-};
-
-// Tests TestInfo::test_case_name() and TestInfo::name().
-TEST_F(TestInfoTest, Names) {
-  const TestInfo* const test_info = GetTestInfo("Names");
-
-  ASSERT_STREQ("TestInfoTest", test_info->test_case_name());
-  ASSERT_STREQ("Names", test_info->name());
-}
-
-// Tests TestInfo::result().
-TEST_F(TestInfoTest, result) {
-  const TestInfo* const test_info = GetTestInfo("result");
-
-  // Initially, there is no TestPartResult for this test.
-  ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
-
-  // After the previous assertion, there is still none.
-  ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
-}
-
-#define VERIFY_CODE_LOCATION \
-  const int expected_line = __LINE__ - 1; \
-  const TestInfo* const test_info = GetUnitTestImpl()->current_test_info(); \
-  ASSERT_TRUE(test_info); \
-  EXPECT_STREQ(__FILE__, test_info->file()); \
-  EXPECT_EQ(expected_line, test_info->line())
-
-TEST(CodeLocationForTEST, Verify) {
-  VERIFY_CODE_LOCATION;
-}
-
-class CodeLocationForTESTF : public Test {
-};
-
-TEST_F(CodeLocationForTESTF, Verify) {
-  VERIFY_CODE_LOCATION;
-}
-
-class CodeLocationForTESTP : public TestWithParam<int> {
-};
-
-TEST_P(CodeLocationForTESTP, Verify) {
-  VERIFY_CODE_LOCATION;
-}
-
-INSTANTIATE_TEST_CASE_P(, CodeLocationForTESTP, Values(0));
-
-template <typename T>
-class CodeLocationForTYPEDTEST : public Test {
-};
-
-TYPED_TEST_CASE(CodeLocationForTYPEDTEST, int);
-
-TYPED_TEST(CodeLocationForTYPEDTEST, Verify) {
-  VERIFY_CODE_LOCATION;
-}
-
-template <typename T>
-class CodeLocationForTYPEDTESTP : public Test {
-};
-
-TYPED_TEST_CASE_P(CodeLocationForTYPEDTESTP);
-
-TYPED_TEST_P(CodeLocationForTYPEDTESTP, Verify) {
-  VERIFY_CODE_LOCATION;
-}
-
-REGISTER_TYPED_TEST_CASE_P(CodeLocationForTYPEDTESTP, Verify);
-
-INSTANTIATE_TYPED_TEST_CASE_P(My, CodeLocationForTYPEDTESTP, int);
-
-#undef VERIFY_CODE_LOCATION
-
-// Tests setting up and tearing down a test case.
-
-class SetUpTestCaseTest : public Test {
- protected:
-  // This will be called once before the first test in this test case
-  // is run.
-  static void SetUpTestCase() {
-    printf("Setting up the test case . . .\n");
-
-    // Initializes some shared resource.  In this simple example, we
-    // just create a C string.  More complex stuff can be done if
-    // desired.
-    shared_resource_ = "123";
-
-    // Increments the number of test cases that have been set up.
-    counter_++;
-
-    // SetUpTestCase() should be called only once.
-    EXPECT_EQ(1, counter_);
-  }
-
-  // This will be called once after the last test in this test case is
-  // run.
-  static void TearDownTestCase() {
-    printf("Tearing down the test case . . .\n");
-
-    // Decrements the number of test cases that have been set up.
-    counter_--;
-
-    // TearDownTestCase() should be called only once.
-    EXPECT_EQ(0, counter_);
-
-    // Cleans up the shared resource.
-    shared_resource_ = NULL;
-  }
-
-  // This will be called before each test in this test case.
-  virtual void SetUp() {
-    // SetUpTestCase() should be called only once, so counter_ should
-    // always be 1.
-    EXPECT_EQ(1, counter_);
-  }
-
-  // Number of test cases that have been set up.
-  static int counter_;
-
-  // Some resource to be shared by all tests in this test case.
-  static const char* shared_resource_;
-};
-
-int SetUpTestCaseTest::counter_ = 0;
-const char* SetUpTestCaseTest::shared_resource_ = NULL;
-
-// A test that uses the shared resource.
-TEST_F(SetUpTestCaseTest, Test1) {
-  EXPECT_STRNE(NULL, shared_resource_);
-}
-
-// Another test that uses the shared resource.
-TEST_F(SetUpTestCaseTest, Test2) {
-  EXPECT_STREQ("123", shared_resource_);
-}
-
-// The InitGoogleTestTest test case tests testing::InitGoogleTest().
-
-// The Flags struct stores a copy of all Google Test flags.
-struct Flags {
-  // Constructs a Flags struct where each flag has its default value.
-  Flags() : also_run_disabled_tests(false),
-            break_on_failure(false),
-            catch_exceptions(false),
-            death_test_use_fork(false),
-            filter(""),
-            list_tests(false),
-            output(""),
-            print_time(true),
-            random_seed(0),
-            repeat(1),
-            shuffle(false),
-            stack_trace_depth(kMaxStackTraceDepth),
-            stream_result_to(""),
-            throw_on_failure(false) {}
-
-  // Factory methods.
-
-  // Creates a Flags struct where the gtest_also_run_disabled_tests flag has
-  // the given value.
-  static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) {
-    Flags flags;
-    flags.also_run_disabled_tests = also_run_disabled_tests;
-    return flags;
-  }
-
-  // Creates a Flags struct where the gtest_break_on_failure flag has
-  // the given value.
-  static Flags BreakOnFailure(bool break_on_failure) {
-    Flags flags;
-    flags.break_on_failure = break_on_failure;
-    return flags;
-  }
-
-  // Creates a Flags struct where the gtest_catch_exceptions flag has
-  // the given value.
-  static Flags CatchExceptions(bool catch_exceptions) {
-    Flags flags;
-    flags.catch_exceptions = catch_exceptions;
-    return flags;
-  }
-
-  // Creates a Flags struct where the gtest_death_test_use_fork flag has
-  // the given value.
-  static Flags DeathTestUseFork(bool death_test_use_fork) {
-    Flags flags;
-    flags.death_test_use_fork = death_test_use_fork;
-    return flags;
-  }
-
-  // Creates a Flags struct where the gtest_filter flag has the given
-  // value.
-  static Flags Filter(const char* filter) {
-    Flags flags;
-    flags.filter = filter;
-    return flags;
-  }
-
-  // Creates a Flags struct where the gtest_list_tests flag has the
-  // given value.
-  static Flags ListTests(bool list_tests) {
-    Flags flags;
-    flags.list_tests = list_tests;
-    return flags;
-  }
-
-  // Creates a Flags struct where the gtest_output flag has the given
-  // value.
-  static Flags Output(const char* output) {
-    Flags flags;
-    flags.output = output;
-    return flags;
-  }
-
-  // Creates a Flags struct where the gtest_print_time flag has the given
-  // value.
-  static Flags PrintTime(bool print_time) {
-    Flags flags;
-    flags.print_time = print_time;
-    return flags;
-  }
-
-  // Creates a Flags struct where the gtest_random_seed flag has
-  // the given value.
-  static Flags RandomSeed(Int32 random_seed) {
-    Flags flags;
-    flags.random_seed = random_seed;
-    return flags;
-  }
-
-  // Creates a Flags struct where the gtest_repeat flag has the given
-  // value.
-  static Flags Repeat(Int32 repeat) {
-    Flags flags;
-    flags.repeat = repeat;
-    return flags;
-  }
-
-  // Creates a Flags struct where the gtest_shuffle flag has
-  // the given value.
-  static Flags Shuffle(bool shuffle) {
-    Flags flags;
-    flags.shuffle = shuffle;
-    return flags;
-  }
-
-  // Creates a Flags struct where the GTEST_FLAG(stack_trace_depth) flag has
-  // the given value.
-  static Flags StackTraceDepth(Int32 stack_trace_depth) {
-    Flags flags;
-    flags.stack_trace_depth = stack_trace_depth;
-    return flags;
-  }
-
-  // Creates a Flags struct where the GTEST_FLAG(stream_result_to) flag has
-  // the given value.
-  static Flags StreamResultTo(const char* stream_result_to) {
-    Flags flags;
-    flags.stream_result_to = stream_result_to;
-    return flags;
-  }
-
-  // Creates a Flags struct where the gtest_throw_on_failure flag has
-  // the given value.
-  static Flags ThrowOnFailure(bool throw_on_failure) {
-    Flags flags;
-    flags.throw_on_failure = throw_on_failure;
-    return flags;
-  }
-
-  // These fields store the flag values.
-  bool also_run_disabled_tests;
-  bool break_on_failure;
-  bool catch_exceptions;
-  bool death_test_use_fork;
-  const char* filter;
-  bool list_tests;
-  const char* output;
-  bool print_time;
-  Int32 random_seed;
-  Int32 repeat;
-  bool shuffle;
-  Int32 stack_trace_depth;
-  const char* stream_result_to;
-  bool throw_on_failure;
-};
-
-// Fixture for testing InitGoogleTest().
-class InitGoogleTestTest : public Test {
- protected:
-  // Clears the flags before each test.
-  virtual void SetUp() {
-    GTEST_FLAG(also_run_disabled_tests) = false;
-    GTEST_FLAG(break_on_failure) = false;
-    GTEST_FLAG(catch_exceptions) = false;
-    GTEST_FLAG(death_test_use_fork) = false;
-    GTEST_FLAG(filter) = "";
-    GTEST_FLAG(list_tests) = false;
-    GTEST_FLAG(output) = "";
-    GTEST_FLAG(print_time) = true;
-    GTEST_FLAG(random_seed) = 0;
-    GTEST_FLAG(repeat) = 1;
-    GTEST_FLAG(shuffle) = false;
-    GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
-    GTEST_FLAG(stream_result_to) = "";
-    GTEST_FLAG(throw_on_failure) = false;
-  }
-
-  // Asserts that two narrow or wide string arrays are equal.
-  template <typename CharType>
-  static void AssertStringArrayEq(size_t size1, CharType** array1,
-                                  size_t size2, CharType** array2) {
-    ASSERT_EQ(size1, size2) << " Array sizes different.";
-
-    for (size_t i = 0; i != size1; i++) {
-      ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i;
-    }
-  }
-
-  // Verifies that the flag values match the expected values.
-  static void CheckFlags(const Flags& expected) {
-    EXPECT_EQ(expected.also_run_disabled_tests,
-              GTEST_FLAG(also_run_disabled_tests));
-    EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure));
-    EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions));
-    EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork));
-    EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str());
-    EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests));
-    EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str());
-    EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time));
-    EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed));
-    EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat));
-    EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle));
-    EXPECT_EQ(expected.stack_trace_depth, GTEST_FLAG(stack_trace_depth));
-    EXPECT_STREQ(expected.stream_result_to,
-                 GTEST_FLAG(stream_result_to).c_str());
-    EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure));
-  }
-
-  // Parses a command line (specified by argc1 and argv1), then
-  // verifies that the flag values are expected and that the
-  // recognized flags are removed from the command line.
-  template <typename CharType>
-  static void TestParsingFlags(int argc1, const CharType** argv1,
-                               int argc2, const CharType** argv2,
-                               const Flags& expected, bool should_print_help) {
-    const bool saved_help_flag = ::testing::internal::g_help_flag;
-    ::testing::internal::g_help_flag = false;
-
-#if GTEST_HAS_STREAM_REDIRECTION
-    CaptureStdout();
-#endif
-
-    // Parses the command line.
-    internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));
-
-#if GTEST_HAS_STREAM_REDIRECTION
-    const std::string captured_stdout = GetCapturedStdout();
-#endif
-
-    // Verifies the flag values.
-    CheckFlags(expected);
-
-    // Verifies that the recognized flags are removed from the command
-    // line.
-    AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2);
-
-    // ParseGoogleTestFlagsOnly should neither set g_help_flag nor print the
-    // help message for the flags it recognizes.
-    EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag);
-
-#if GTEST_HAS_STREAM_REDIRECTION
-    const char* const expected_help_fragment =
-        "This program contains tests written using";
-    if (should_print_help) {
-      EXPECT_PRED_FORMAT2(IsSubstring, expected_help_fragment, captured_stdout);
-    } else {
-      EXPECT_PRED_FORMAT2(IsNotSubstring,
-                          expected_help_fragment, captured_stdout);
-    }
-#endif  // GTEST_HAS_STREAM_REDIRECTION
-
-    ::testing::internal::g_help_flag = saved_help_flag;
-  }
-
-  // This macro wraps TestParsingFlags s.t. the user doesn't need
-  // to specify the array sizes.
-
-#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \
-  TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \
-                   sizeof(argv2)/sizeof(*argv2) - 1, argv2, \
-                   expected, should_print_help)
-};
-
-// Tests parsing an empty command line.
-TEST_F(InitGoogleTestTest, Empty) {
-  const char* argv[] = {
-    NULL
-  };
-
-  const char* argv2[] = {
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
-}
-
-// Tests parsing a command line that has no flag.
-TEST_F(InitGoogleTestTest, NoFlag) {
-  const char* argv[] = {
-    "foo.exe",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
-}
-
-// Tests parsing a bad --gtest_filter flag.
-TEST_F(InitGoogleTestTest, FilterBad) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_filter",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    "--gtest_filter",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true);
-}
-
-// Tests parsing an empty --gtest_filter flag.
-TEST_F(InitGoogleTestTest, FilterEmpty) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_filter=",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), false);
-}
-
-// Tests parsing a non-empty --gtest_filter flag.
-TEST_F(InitGoogleTestTest, FilterNonEmpty) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_filter=abc",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
-}
-
-// Tests parsing --gtest_break_on_failure.
-TEST_F(InitGoogleTestTest, BreakOnFailureWithoutValue) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_break_on_failure",
-    NULL
-};
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
-}
-
-// Tests parsing --gtest_break_on_failure=0.
-TEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_break_on_failure=0",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
-}
-
-// Tests parsing --gtest_break_on_failure=f.
-TEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_break_on_failure=f",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
-}
-
-// Tests parsing --gtest_break_on_failure=F.
-TEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_break_on_failure=F",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
-}
-
-// Tests parsing a --gtest_break_on_failure flag that has a "true"
-// definition.
-TEST_F(InitGoogleTestTest, BreakOnFailureTrue) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_break_on_failure=1",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
-}
-
-// Tests parsing --gtest_catch_exceptions.
-TEST_F(InitGoogleTestTest, CatchExceptions) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_catch_exceptions",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true), false);
-}
-
-// Tests parsing --gtest_death_test_use_fork.
-TEST_F(InitGoogleTestTest, DeathTestUseFork) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_death_test_use_fork",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true), false);
-}
-
-// Tests having the same flag twice with different values.  The
-// expected behavior is that the one coming last takes precedence.
-TEST_F(InitGoogleTestTest, DuplicatedFlags) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_filter=a",
-    "--gtest_filter=b",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b"), false);
-}
-
-// Tests having an unrecognized flag on the command line.
-TEST_F(InitGoogleTestTest, UnrecognizedFlag) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_break_on_failure",
-    "bar",  // Unrecognized by Google Test.
-    "--gtest_filter=b",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    "bar",
-    NULL
-  };
-
-  Flags flags;
-  flags.break_on_failure = true;
-  flags.filter = "b";
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags, false);
-}
-
-// Tests having a --gtest_list_tests flag
-TEST_F(InitGoogleTestTest, ListTestsFlag) {
-    const char* argv[] = {
-      "foo.exe",
-      "--gtest_list_tests",
-      NULL
-    };
-
-    const char* argv2[] = {
-      "foo.exe",
-      NULL
-    };
-
-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
-}
-
-// Tests having a --gtest_list_tests flag with a "true" value
-TEST_F(InitGoogleTestTest, ListTestsTrue) {
-    const char* argv[] = {
-      "foo.exe",
-      "--gtest_list_tests=1",
-      NULL
-    };
-
-    const char* argv2[] = {
-      "foo.exe",
-      NULL
-    };
-
-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
-}
-
-// Tests having a --gtest_list_tests flag with a "false" value
-TEST_F(InitGoogleTestTest, ListTestsFalse) {
-    const char* argv[] = {
-      "foo.exe",
-      "--gtest_list_tests=0",
-      NULL
-    };
-
-    const char* argv2[] = {
-      "foo.exe",
-      NULL
-    };
-
-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
-}
-
-// Tests parsing --gtest_list_tests=f.
-TEST_F(InitGoogleTestTest, ListTestsFalse_f) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_list_tests=f",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
-}
-
-// Tests parsing --gtest_list_tests=F.
-TEST_F(InitGoogleTestTest, ListTestsFalse_F) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_list_tests=F",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
-}
-
-// Tests parsing --gtest_output (invalid).
-TEST_F(InitGoogleTestTest, OutputEmpty) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_output",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    "--gtest_output",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true);
-}
-
-// Tests parsing --gtest_output=xml
-TEST_F(InitGoogleTestTest, OutputXml) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_output=xml",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"), false);
-}
-
-// Tests parsing --gtest_output=xml:file
-TEST_F(InitGoogleTestTest, OutputXmlFile) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_output=xml:file",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"), false);
-}
-
-// Tests parsing --gtest_output=xml:directory/path/
-TEST_F(InitGoogleTestTest, OutputXmlDirectory) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_output=xml:directory/path/",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2,
-                            Flags::Output("xml:directory/path/"), false);
-}
-
-// Tests having a --gtest_print_time flag
-TEST_F(InitGoogleTestTest, PrintTimeFlag) {
-    const char* argv[] = {
-      "foo.exe",
-      "--gtest_print_time",
-      NULL
-    };
-
-    const char* argv2[] = {
-      "foo.exe",
-      NULL
-    };
-
-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
-}
-
-// Tests having a --gtest_print_time flag with a "true" value
-TEST_F(InitGoogleTestTest, PrintTimeTrue) {
-    const char* argv[] = {
-      "foo.exe",
-      "--gtest_print_time=1",
-      NULL
-    };
-
-    const char* argv2[] = {
-      "foo.exe",
-      NULL
-    };
-
-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
-}
-
-// Tests having a --gtest_print_time flag with a "false" value
-TEST_F(InitGoogleTestTest, PrintTimeFalse) {
-    const char* argv[] = {
-      "foo.exe",
-      "--gtest_print_time=0",
-      NULL
-    };
-
-    const char* argv2[] = {
-      "foo.exe",
-      NULL
-    };
-
-    GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
-}
-
-// Tests parsing --gtest_print_time=f.
-TEST_F(InitGoogleTestTest, PrintTimeFalse_f) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_print_time=f",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
-}
-
-// Tests parsing --gtest_print_time=F.
-TEST_F(InitGoogleTestTest, PrintTimeFalse_F) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_print_time=F",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
-}
-
-// Tests parsing --gtest_random_seed=number
-TEST_F(InitGoogleTestTest, RandomSeed) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_random_seed=1000",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000), false);
-}
-
-// Tests parsing --gtest_repeat=number
-TEST_F(InitGoogleTestTest, Repeat) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_repeat=1000",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false);
-}
-
-// Tests having a --gtest_also_run_disabled_tests flag
-TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) {
-    const char* argv[] = {
-      "foo.exe",
-      "--gtest_also_run_disabled_tests",
-      NULL
-    };
-
-    const char* argv2[] = {
-      "foo.exe",
-      NULL
-    };
-
-    GTEST_TEST_PARSING_FLAGS_(argv, argv2,
-                              Flags::AlsoRunDisabledTests(true), false);
-}
-
-// Tests having a --gtest_also_run_disabled_tests flag with a "true" value
-TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) {
-    const char* argv[] = {
-      "foo.exe",
-      "--gtest_also_run_disabled_tests=1",
-      NULL
-    };
-
-    const char* argv2[] = {
-      "foo.exe",
-      NULL
-    };
-
-    GTEST_TEST_PARSING_FLAGS_(argv, argv2,
-                              Flags::AlsoRunDisabledTests(true), false);
-}
-
-// Tests having a --gtest_also_run_disabled_tests flag with a "false" value
-TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) {
-    const char* argv[] = {
-      "foo.exe",
-      "--gtest_also_run_disabled_tests=0",
-      NULL
-    };
-
-    const char* argv2[] = {
-      "foo.exe",
-      NULL
-    };
-
-    GTEST_TEST_PARSING_FLAGS_(argv, argv2,
-                              Flags::AlsoRunDisabledTests(false), false);
-}
-
-// Tests parsing --gtest_shuffle.
-TEST_F(InitGoogleTestTest, ShuffleWithoutValue) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_shuffle",
-    NULL
-};
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
-}
-
-// Tests parsing --gtest_shuffle=0.
-TEST_F(InitGoogleTestTest, ShuffleFalse_0) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_shuffle=0",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false);
-}
-
-// Tests parsing a --gtest_shuffle flag that has a "true"
-// definition.
-TEST_F(InitGoogleTestTest, ShuffleTrue) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_shuffle=1",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
-}
-
-// Tests parsing --gtest_stack_trace_depth=number.
-TEST_F(InitGoogleTestTest, StackTraceDepth) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_stack_trace_depth=5",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false);
-}
-
-TEST_F(InitGoogleTestTest, StreamResultTo) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_stream_result_to=localhost:1234",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(
-      argv, argv2, Flags::StreamResultTo("localhost:1234"), false);
-}
-
-// Tests parsing --gtest_throw_on_failure.
-TEST_F(InitGoogleTestTest, ThrowOnFailureWithoutValue) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_throw_on_failure",
-    NULL
-};
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
-}
-
-// Tests parsing --gtest_throw_on_failure=0.
-TEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_throw_on_failure=0",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false), false);
-}
-
-// Tests parsing a --gtest_throw_on_failure flag that has a "true"
-// definition.
-TEST_F(InitGoogleTestTest, ThrowOnFailureTrue) {
-  const char* argv[] = {
-    "foo.exe",
-    "--gtest_throw_on_failure=1",
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
-}
-
-#if GTEST_OS_WINDOWS
-// Tests parsing wide strings.
-TEST_F(InitGoogleTestTest, WideStrings) {
-  const wchar_t* argv[] = {
-    L"foo.exe",
-    L"--gtest_filter=Foo*",
-    L"--gtest_list_tests=1",
-    L"--gtest_break_on_failure",
-    L"--non_gtest_flag",
-    NULL
-  };
-
-  const wchar_t* argv2[] = {
-    L"foo.exe",
-    L"--non_gtest_flag",
-    NULL
-  };
-
-  Flags expected_flags;
-  expected_flags.break_on_failure = true;
-  expected_flags.filter = "Foo*";
-  expected_flags.list_tests = true;
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false);
-}
-# endif  // GTEST_OS_WINDOWS
-
-#if GTEST_USE_OWN_FLAGFILE_FLAG_
-class FlagfileTest : public InitGoogleTestTest {
- public:
-  virtual void SetUp() {
-    InitGoogleTestTest::SetUp();
-
-    testdata_path_.Set(internal::FilePath(
-        internal::TempDir() + internal::GetCurrentExecutableName().string() +
-        "_flagfile_test"));
-    testing::internal::posix::RmDir(testdata_path_.c_str());
-    EXPECT_TRUE(testdata_path_.CreateFolder());
-  }
-
-  virtual void TearDown() {
-    testing::internal::posix::RmDir(testdata_path_.c_str());
-    InitGoogleTestTest::TearDown();
-  }
-
-  internal::FilePath CreateFlagfile(const char* contents) {
-    internal::FilePath file_path(internal::FilePath::GenerateUniqueFileName(
-        testdata_path_, internal::FilePath("unique"), "txt"));
-    FILE* f = testing::internal::posix::FOpen(file_path.c_str(), "w");
-    fprintf(f, "%s", contents);
-    fclose(f);
-    return file_path;
-  }
-
- private:
-  internal::FilePath testdata_path_;
-};
-
-// Tests an empty flagfile.
-TEST_F(FlagfileTest, Empty) {
-  internal::FilePath flagfile_path(CreateFlagfile(""));
-  std::string flagfile_flag =
-      std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
-
-  const char* argv[] = {
-    "foo.exe",
-    flagfile_flag.c_str(),
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
-}
-
-// Tests passing a non-empty --gtest_filter flag via --gtest_flagfile.
-TEST_F(FlagfileTest, FilterNonEmpty) {
-  internal::FilePath flagfile_path(CreateFlagfile(
-      "--"  GTEST_FLAG_PREFIX_  "filter=abc"));
-  std::string flagfile_flag =
-      std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
-
-  const char* argv[] = {
-    "foo.exe",
-    flagfile_flag.c_str(),
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
-}
-
-// Tests passing several flags via --gtest_flagfile.
-TEST_F(FlagfileTest, SeveralFlags) {
-  internal::FilePath flagfile_path(CreateFlagfile(
-      "--"  GTEST_FLAG_PREFIX_  "filter=abc\n"
-      "--"  GTEST_FLAG_PREFIX_  "break_on_failure\n"
-      "--"  GTEST_FLAG_PREFIX_  "list_tests"));
-  std::string flagfile_flag =
-      std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
-
-  const char* argv[] = {
-    "foo.exe",
-    flagfile_flag.c_str(),
-    NULL
-  };
-
-  const char* argv2[] = {
-    "foo.exe",
-    NULL
-  };
-
-  Flags expected_flags;
-  expected_flags.break_on_failure = true;
-  expected_flags.filter = "abc";
-  expected_flags.list_tests = true;
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false);
-}
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
-
-// Tests current_test_info() in UnitTest.
-class CurrentTestInfoTest : public Test {
- protected:
-  // Tests that current_test_info() returns NULL before the first test in
-  // the test case is run.
-  static void SetUpTestCase() {
-    // There should be no tests running at this point.
-    const TestInfo* test_info =
-      UnitTest::GetInstance()->current_test_info();
-    EXPECT_TRUE(test_info == NULL)
-        << "There should be no tests running at this point.";
-  }
-
-  // Tests that current_test_info() returns NULL after the last test in
-  // the test case has run.
-  static void TearDownTestCase() {
-    const TestInfo* test_info =
-      UnitTest::GetInstance()->current_test_info();
-    EXPECT_TRUE(test_info == NULL)
-        << "There should be no tests running at this point.";
-  }
-};
-
-// Tests that current_test_info() returns TestInfo for currently running
-// test by checking the expected test name against the actual one.
-TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) {
-  const TestInfo* test_info =
-    UnitTest::GetInstance()->current_test_info();
-  ASSERT_TRUE(NULL != test_info)
-      << "There is a test running so we should have a valid TestInfo.";
-  EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())
-      << "Expected the name of the currently running test case.";
-  EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name())
-      << "Expected the name of the currently running test.";
-}
-
-// Tests that current_test_info() returns TestInfo for currently running
-// test by checking the expected test name against the actual one.  We
-// use this test to see that the TestInfo object actually changed from
-// the previous invocation.
-TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) {
-  const TestInfo* test_info =
-    UnitTest::GetInstance()->current_test_info();
-  ASSERT_TRUE(NULL != test_info)
-      << "There is a test running so we should have a valid TestInfo.";
-  EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())
-      << "Expected the name of the currently running test case.";
-  EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name())
-      << "Expected the name of the currently running test.";
-}
-
-}  // namespace testing
-
-// These two lines test that we can define tests in a namespace that
-// has the name "testing" and is nested in another namespace.
-namespace my_namespace {
-namespace testing {
-
-// Makes sure that TEST knows to use ::testing::Test instead of
-// ::my_namespace::testing::Test.
-class Test {};
-
-// Makes sure that an assertion knows to use ::testing::Message instead of
-// ::my_namespace::testing::Message.
-class Message {};
-
-// Makes sure that an assertion knows to use
-// ::testing::AssertionResult instead of
-// ::my_namespace::testing::AssertionResult.
-class AssertionResult {};
-
-// Tests that an assertion that should succeed works as expected.
-TEST(NestedTestingNamespaceTest, Success) {
-  EXPECT_EQ(1, 1) << "This shouldn't fail.";
-}
-
-// Tests that an assertion that should fail works as expected.
-TEST(NestedTestingNamespaceTest, Failure) {
-  EXPECT_FATAL_FAILURE(FAIL() << "This failure is expected.",
-                       "This failure is expected.");
-}
-
-}  // namespace testing
-}  // namespace my_namespace
-
-// Tests that one can call superclass SetUp and TearDown methods--
-// that is, that they are not private.
-// No tests are based on this fixture; the test "passes" if it compiles
-// successfully.
-class ProtectedFixtureMethodsTest : public Test {
- protected:
-  virtual void SetUp() {
-    Test::SetUp();
-  }
-  virtual void TearDown() {
-    Test::TearDown();
-  }
-};
-
-// StreamingAssertionsTest tests the streaming versions of a representative
-// sample of assertions.
-TEST(StreamingAssertionsTest, Unconditional) {
-  SUCCEED() << "expected success";
-  EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure",
-                          "expected failure");
-  EXPECT_FATAL_FAILURE(FAIL() << "expected failure",
-                       "expected failure");
-}
-
-#ifdef __BORLANDC__
-// Silences warnings: "Condition is always true", "Unreachable code"
-# pragma option push -w-ccc -w-rch
-#endif
-
-TEST(StreamingAssertionsTest, Truth) {
-  EXPECT_TRUE(true) << "unexpected failure";
-  ASSERT_TRUE(true) << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure",
-                          "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure",
-                       "expected failure");
-}
-
-TEST(StreamingAssertionsTest, Truth2) {
-  EXPECT_FALSE(false) << "unexpected failure";
-  ASSERT_FALSE(false) << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure",
-                          "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure",
-                       "expected failure");
-}
-
-#ifdef __BORLANDC__
-// Restores warnings after previous "#pragma option push" supressed them
-# pragma option pop
-#endif
-
-TEST(StreamingAssertionsTest, IntegerEquals) {
-  EXPECT_EQ(1, 1) << "unexpected failure";
-  ASSERT_EQ(1, 1) << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure",
-                          "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure",
-                       "expected failure");
-}
-
-TEST(StreamingAssertionsTest, IntegerLessThan) {
-  EXPECT_LT(1, 2) << "unexpected failure";
-  ASSERT_LT(1, 2) << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure",
-                          "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure",
-                       "expected failure");
-}
-
-TEST(StreamingAssertionsTest, StringsEqual) {
-  EXPECT_STREQ("foo", "foo") << "unexpected failure";
-  ASSERT_STREQ("foo", "foo") << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure",
-                          "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure",
-                       "expected failure");
-}
-
-TEST(StreamingAssertionsTest, StringsNotEqual) {
-  EXPECT_STRNE("foo", "bar") << "unexpected failure";
-  ASSERT_STRNE("foo", "bar") << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure",
-                          "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure",
-                       "expected failure");
-}
-
-TEST(StreamingAssertionsTest, StringsEqualIgnoringCase) {
-  EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure";
-  ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure",
-                          "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure",
-                       "expected failure");
-}
-
-TEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) {
-  EXPECT_STRCASENE("foo", "bar") << "unexpected failure";
-  ASSERT_STRCASENE("foo", "bar") << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure",
-                          "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure",
-                       "expected failure");
-}
-
-TEST(StreamingAssertionsTest, FloatingPointEquals) {
-  EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";
-  ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure",
-                          "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure",
-                       "expected failure");
-}
-
-#if GTEST_HAS_EXCEPTIONS
-
-TEST(StreamingAssertionsTest, Throw) {
-  EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure";
-  ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) <<
-                          "expected failure", "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) <<
-                       "expected failure", "expected failure");
-}
-
-TEST(StreamingAssertionsTest, NoThrow) {
-  EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure";
-  ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) <<
-                          "expected failure", "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) <<
-                       "expected failure", "expected failure");
-}
-
-TEST(StreamingAssertionsTest, AnyThrow) {
-  EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
-  ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) <<
-                          "expected failure", "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) <<
-                       "expected failure", "expected failure");
-}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-// Tests that Google Test correctly decides whether to use colors in the output.
-
-TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) {
-  GTEST_FLAG(color) = "yes";
-
-  SetEnv("TERM", "xterm");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
-
-  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
-}
-
-TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) {
-  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
-
-  GTEST_FLAG(color) = "True";
-  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
-
-  GTEST_FLAG(color) = "t";
-  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
-
-  GTEST_FLAG(color) = "1";
-  EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
-}
-
-TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) {
-  GTEST_FLAG(color) = "no";
-
-  SetEnv("TERM", "xterm");  // TERM supports colors.
-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
-  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
-
-  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
-  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
-}
-
-TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) {
-  SetEnv("TERM", "xterm");  // TERM supports colors.
-
-  GTEST_FLAG(color) = "F";
-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  GTEST_FLAG(color) = "0";
-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  GTEST_FLAG(color) = "unknown";
-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
-}
-
-TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {
-  GTEST_FLAG(color) = "auto";
-
-  SetEnv("TERM", "xterm");  // TERM supports colors.
-  EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
-  EXPECT_TRUE(ShouldUseColor(true));    // Stdout is a TTY.
-}
-
-TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
-  GTEST_FLAG(color) = "auto";
-
-#if GTEST_OS_WINDOWS
-  // On Windows, we ignore the TERM variable as it's usually not set.
-
-  SetEnv("TERM", "dumb");
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "");
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "xterm");
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-#else
-  // On non-Windows platforms, we rely on TERM to determine if the
-  // terminal supports colors.
-
-  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "emacs");  // TERM doesn't support colors.
-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "vt100");  // TERM doesn't support colors.
-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "xterm-mono");  // TERM doesn't support colors.
-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "xterm");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "xterm-color");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "xterm-256color");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "screen");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "screen-256color");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "tmux");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "tmux-256color");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "rxvt-unicode");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "rxvt-unicode-256color");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "linux");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-
-  SetEnv("TERM", "cygwin");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
-#endif  // GTEST_OS_WINDOWS
-}
-
-// Verifies that StaticAssertTypeEq works in a namespace scope.
-
-static bool dummy1 GTEST_ATTRIBUTE_UNUSED_ = StaticAssertTypeEq<bool, bool>();
-static bool dummy2 GTEST_ATTRIBUTE_UNUSED_ =
-    StaticAssertTypeEq<const int, const int>();
-
-// Verifies that StaticAssertTypeEq works in a class.
-
-template <typename T>
-class StaticAssertTypeEqTestHelper {
- public:
-  StaticAssertTypeEqTestHelper() { StaticAssertTypeEq<bool, T>(); }
-};
-
-TEST(StaticAssertTypeEqTest, WorksInClass) {
-  StaticAssertTypeEqTestHelper<bool>();
-}
-
-// Verifies that StaticAssertTypeEq works inside a function.
-
-typedef int IntAlias;
-
-TEST(StaticAssertTypeEqTest, CompilesForEqualTypes) {
-  StaticAssertTypeEq<int, IntAlias>();
-  StaticAssertTypeEq<int*, IntAlias*>();
-}
-
-TEST(GetCurrentOsStackTraceExceptTopTest, ReturnsTheStackTrace) {
-  testing::UnitTest* const unit_test = testing::UnitTest::GetInstance();
-
-  // We don't have a stack walker in Google Test yet.
-  EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 0).c_str());
-  EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 1).c_str());
-}
-
-TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) {
-  EXPECT_FALSE(HasNonfatalFailure());
-}
-
-static void FailFatally() { FAIL(); }
-
-TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure) {
-  FailFatally();
-  const bool has_nonfatal_failure = HasNonfatalFailure();
-  ClearCurrentTestPartResults();
-  EXPECT_FALSE(has_nonfatal_failure);
-}
-
-TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {
-  ADD_FAILURE();
-  const bool has_nonfatal_failure = HasNonfatalFailure();
-  ClearCurrentTestPartResults();
-  EXPECT_TRUE(has_nonfatal_failure);
-}
-
-TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {
-  FailFatally();
-  ADD_FAILURE();
-  const bool has_nonfatal_failure = HasNonfatalFailure();
-  ClearCurrentTestPartResults();
-  EXPECT_TRUE(has_nonfatal_failure);
-}
-
-// A wrapper for calling HasNonfatalFailure outside of a test body.
-static bool HasNonfatalFailureHelper() {
-  return testing::Test::HasNonfatalFailure();
-}
-
-TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody) {
-  EXPECT_FALSE(HasNonfatalFailureHelper());
-}
-
-TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody2) {
-  ADD_FAILURE();
-  const bool has_nonfatal_failure = HasNonfatalFailureHelper();
-  ClearCurrentTestPartResults();
-  EXPECT_TRUE(has_nonfatal_failure);
-}
-
-TEST(HasFailureTest, ReturnsFalseWhenThereIsNoFailure) {
-  EXPECT_FALSE(HasFailure());
-}
-
-TEST(HasFailureTest, ReturnsTrueWhenThereIsFatalFailure) {
-  FailFatally();
-  const bool has_failure = HasFailure();
-  ClearCurrentTestPartResults();
-  EXPECT_TRUE(has_failure);
-}
-
-TEST(HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {
-  ADD_FAILURE();
-  const bool has_failure = HasFailure();
-  ClearCurrentTestPartResults();
-  EXPECT_TRUE(has_failure);
-}
-
-TEST(HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {
-  FailFatally();
-  ADD_FAILURE();
-  const bool has_failure = HasFailure();
-  ClearCurrentTestPartResults();
-  EXPECT_TRUE(has_failure);
-}
-
-// A wrapper for calling HasFailure outside of a test body.
-static bool HasFailureHelper() { return testing::Test::HasFailure(); }
-
-TEST(HasFailureTest, WorksOutsideOfTestBody) {
-  EXPECT_FALSE(HasFailureHelper());
-}
-
-TEST(HasFailureTest, WorksOutsideOfTestBody2) {
-  ADD_FAILURE();
-  const bool has_failure = HasFailureHelper();
-  ClearCurrentTestPartResults();
-  EXPECT_TRUE(has_failure);
-}
-
-class TestListener : public EmptyTestEventListener {
- public:
-  TestListener() : on_start_counter_(NULL), is_destroyed_(NULL) {}
-  TestListener(int* on_start_counter, bool* is_destroyed)
-      : on_start_counter_(on_start_counter),
-        is_destroyed_(is_destroyed) {}
-
-  virtual ~TestListener() {
-    if (is_destroyed_)
-      *is_destroyed_ = true;
-  }
-
- protected:
-  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
-    if (on_start_counter_ != NULL)
-      (*on_start_counter_)++;
-  }
-
- private:
-  int* on_start_counter_;
-  bool* is_destroyed_;
-};
-
-// Tests the constructor.
-TEST(TestEventListenersTest, ConstructionWorks) {
-  TestEventListeners listeners;
-
-  EXPECT_TRUE(TestEventListenersAccessor::GetRepeater(&listeners) != NULL);
-  EXPECT_TRUE(listeners.default_result_printer() == NULL);
-  EXPECT_TRUE(listeners.default_xml_generator() == NULL);
-}
-
-// Tests that the TestEventListeners destructor deletes all the listeners it
-// owns.
-TEST(TestEventListenersTest, DestructionWorks) {
-  bool default_result_printer_is_destroyed = false;
-  bool default_xml_printer_is_destroyed = false;
-  bool extra_listener_is_destroyed = false;
-  TestListener* default_result_printer = new TestListener(
-      NULL, &default_result_printer_is_destroyed);
-  TestListener* default_xml_printer = new TestListener(
-      NULL, &default_xml_printer_is_destroyed);
-  TestListener* extra_listener = new TestListener(
-      NULL, &extra_listener_is_destroyed);
-
-  {
-    TestEventListeners listeners;
-    TestEventListenersAccessor::SetDefaultResultPrinter(&listeners,
-                                                        default_result_printer);
-    TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners,
-                                                       default_xml_printer);
-    listeners.Append(extra_listener);
-  }
-  EXPECT_TRUE(default_result_printer_is_destroyed);
-  EXPECT_TRUE(default_xml_printer_is_destroyed);
-  EXPECT_TRUE(extra_listener_is_destroyed);
-}
-
-// Tests that a listener Append'ed to a TestEventListeners list starts
-// receiving events.
-TEST(TestEventListenersTest, Append) {
-  int on_start_counter = 0;
-  bool is_destroyed = false;
-  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
-  {
-    TestEventListeners listeners;
-    listeners.Append(listener);
-    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-        *UnitTest::GetInstance());
-    EXPECT_EQ(1, on_start_counter);
-  }
-  EXPECT_TRUE(is_destroyed);
-}
-
-// Tests that listeners receive events in the order they were appended to
-// the list, except for *End requests, which must be received in the reverse
-// order.
-class SequenceTestingListener : public EmptyTestEventListener {
- public:
-  SequenceTestingListener(std::vector<std::string>* vector, const char* id)
-      : vector_(vector), id_(id) {}
-
- protected:
-  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
-    vector_->push_back(GetEventDescription("OnTestProgramStart"));
-  }
-
-  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
-    vector_->push_back(GetEventDescription("OnTestProgramEnd"));
-  }
-
-  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
-                                    int /*iteration*/) {
-    vector_->push_back(GetEventDescription("OnTestIterationStart"));
-  }
-
-  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
-                                  int /*iteration*/) {
-    vector_->push_back(GetEventDescription("OnTestIterationEnd"));
-  }
-
- private:
-  std::string GetEventDescription(const char* method) {
-    Message message;
-    message << id_ << "." << method;
-    return message.GetString();
-  }
-
-  std::vector<std::string>* vector_;
-  const char* const id_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener);
-};
-
-TEST(EventListenerTest, AppendKeepsOrder) {
-  std::vector<std::string> vec;
-  TestEventListeners listeners;
-  listeners.Append(new SequenceTestingListener(&vec, "1st"));
-  listeners.Append(new SequenceTestingListener(&vec, "2nd"));
-  listeners.Append(new SequenceTestingListener(&vec, "3rd"));
-
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-      *UnitTest::GetInstance());
-  ASSERT_EQ(3U, vec.size());
-  EXPECT_STREQ("1st.OnTestProgramStart", vec[0].c_str());
-  EXPECT_STREQ("2nd.OnTestProgramStart", vec[1].c_str());
-  EXPECT_STREQ("3rd.OnTestProgramStart", vec[2].c_str());
-
-  vec.clear();
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd(
-      *UnitTest::GetInstance());
-  ASSERT_EQ(3U, vec.size());
-  EXPECT_STREQ("3rd.OnTestProgramEnd", vec[0].c_str());
-  EXPECT_STREQ("2nd.OnTestProgramEnd", vec[1].c_str());
-  EXPECT_STREQ("1st.OnTestProgramEnd", vec[2].c_str());
-
-  vec.clear();
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart(
-      *UnitTest::GetInstance(), 0);
-  ASSERT_EQ(3U, vec.size());
-  EXPECT_STREQ("1st.OnTestIterationStart", vec[0].c_str());
-  EXPECT_STREQ("2nd.OnTestIterationStart", vec[1].c_str());
-  EXPECT_STREQ("3rd.OnTestIterationStart", vec[2].c_str());
-
-  vec.clear();
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd(
-      *UnitTest::GetInstance(), 0);
-  ASSERT_EQ(3U, vec.size());
-  EXPECT_STREQ("3rd.OnTestIterationEnd", vec[0].c_str());
-  EXPECT_STREQ("2nd.OnTestIterationEnd", vec[1].c_str());
-  EXPECT_STREQ("1st.OnTestIterationEnd", vec[2].c_str());
-}
-
-// Tests that a listener removed from a TestEventListeners list stops receiving
-// events and is not deleted when the list is destroyed.
-TEST(TestEventListenersTest, Release) {
-  int on_start_counter = 0;
-  bool is_destroyed = false;
-  // Although Append passes the ownership of this object to the list,
-  // the following calls release it, and we need to delete it before the
-  // test ends.
-  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
-  {
-    TestEventListeners listeners;
-    listeners.Append(listener);
-    EXPECT_EQ(listener, listeners.Release(listener));
-    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-        *UnitTest::GetInstance());
-    EXPECT_TRUE(listeners.Release(listener) == NULL);
-  }
-  EXPECT_EQ(0, on_start_counter);
-  EXPECT_FALSE(is_destroyed);
-  delete listener;
-}
-
-// Tests that no events are forwarded when event forwarding is disabled.
-TEST(EventListenerTest, SuppressEventForwarding) {
-  int on_start_counter = 0;
-  TestListener* listener = new TestListener(&on_start_counter, NULL);
-
-  TestEventListeners listeners;
-  listeners.Append(listener);
-  ASSERT_TRUE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
-  TestEventListenersAccessor::SuppressEventForwarding(&listeners);
-  ASSERT_FALSE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-      *UnitTest::GetInstance());
-  EXPECT_EQ(0, on_start_counter);
-}
-
-// Tests that events generated by Google Test are not forwarded in
-// death test subprocesses.
-TEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses) {
-  EXPECT_DEATH_IF_SUPPORTED({
-      GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled(
-          *GetUnitTestImpl()->listeners())) << "expected failure";},
-      "expected failure");
-}
-
-// Tests that a listener installed via SetDefaultResultPrinter() starts
-// receiving events and is returned via default_result_printer() and that
-// the previous default_result_printer is removed from the list and deleted.
-TEST(EventListenerTest, default_result_printer) {
-  int on_start_counter = 0;
-  bool is_destroyed = false;
-  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
-
-  TestEventListeners listeners;
-  TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);
-
-  EXPECT_EQ(listener, listeners.default_result_printer());
-
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-      *UnitTest::GetInstance());
-
-  EXPECT_EQ(1, on_start_counter);
-
-  // Replacing default_result_printer with something else should remove it
-  // from the list and destroy it.
-  TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, NULL);
-
-  EXPECT_TRUE(listeners.default_result_printer() == NULL);
-  EXPECT_TRUE(is_destroyed);
-
-  // After broadcasting an event the counter is still the same, indicating
-  // the listener is not in the list anymore.
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-      *UnitTest::GetInstance());
-  EXPECT_EQ(1, on_start_counter);
-}
-
-// Tests that the default_result_printer listener stops receiving events
-// when removed via Release and that is not owned by the list anymore.
-TEST(EventListenerTest, RemovingDefaultResultPrinterWorks) {
-  int on_start_counter = 0;
-  bool is_destroyed = false;
-  // Although Append passes the ownership of this object to the list,
-  // the following calls release it, and we need to delete it before the
-  // test ends.
-  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
-  {
-    TestEventListeners listeners;
-    TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);
-
-    EXPECT_EQ(listener, listeners.Release(listener));
-    EXPECT_TRUE(listeners.default_result_printer() == NULL);
-    EXPECT_FALSE(is_destroyed);
-
-    // Broadcasting events now should not affect default_result_printer.
-    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-        *UnitTest::GetInstance());
-    EXPECT_EQ(0, on_start_counter);
-  }
-  // Destroying the list should not affect the listener now, too.
-  EXPECT_FALSE(is_destroyed);
-  delete listener;
-}
-
-// Tests that a listener installed via SetDefaultXmlGenerator() starts
-// receiving events and is returned via default_xml_generator() and that
-// the previous default_xml_generator is removed from the list and deleted.
-TEST(EventListenerTest, default_xml_generator) {
-  int on_start_counter = 0;
-  bool is_destroyed = false;
-  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
-
-  TestEventListeners listeners;
-  TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);
-
-  EXPECT_EQ(listener, listeners.default_xml_generator());
-
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-      *UnitTest::GetInstance());
-
-  EXPECT_EQ(1, on_start_counter);
-
-  // Replacing default_xml_generator with something else should remove it
-  // from the list and destroy it.
-  TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, NULL);
-
-  EXPECT_TRUE(listeners.default_xml_generator() == NULL);
-  EXPECT_TRUE(is_destroyed);
-
-  // After broadcasting an event the counter is still the same, indicating
-  // the listener is not in the list anymore.
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-      *UnitTest::GetInstance());
-  EXPECT_EQ(1, on_start_counter);
-}
-
-// Tests that the default_xml_generator listener stops receiving events
-// when removed via Release and that is not owned by the list anymore.
-TEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) {
-  int on_start_counter = 0;
-  bool is_destroyed = false;
-  // Although Append passes the ownership of this object to the list,
-  // the following calls release it, and we need to delete it before the
-  // test ends.
-  TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
-  {
-    TestEventListeners listeners;
-    TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);
-
-    EXPECT_EQ(listener, listeners.Release(listener));
-    EXPECT_TRUE(listeners.default_xml_generator() == NULL);
-    EXPECT_FALSE(is_destroyed);
-
-    // Broadcasting events now should not affect default_xml_generator.
-    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-        *UnitTest::GetInstance());
-    EXPECT_EQ(0, on_start_counter);
-  }
-  // Destroying the list should not affect the listener now, too.
-  EXPECT_FALSE(is_destroyed);
-  delete listener;
-}
-
-// Sanity tests to ensure that the alternative, verbose spellings of
-// some of the macros work.  We don't test them thoroughly as that
-// would be quite involved.  Since their implementations are
-// straightforward, and they are rarely used, we'll just rely on the
-// users to tell us when they are broken.
-GTEST_TEST(AlternativeNameTest, Works) {  // GTEST_TEST is the same as TEST.
-  GTEST_SUCCEED() << "OK";  // GTEST_SUCCEED is the same as SUCCEED.
-
-  // GTEST_FAIL is the same as FAIL.
-  EXPECT_FATAL_FAILURE(GTEST_FAIL() << "An expected failure",
-                       "An expected failure");
-
-  // GTEST_ASSERT_XY is the same as ASSERT_XY.
-
-  GTEST_ASSERT_EQ(0, 0);
-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(0, 1) << "An expected failure",
-                       "An expected failure");
-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(1, 0) << "An expected failure",
-                       "An expected failure");
-
-  GTEST_ASSERT_NE(0, 1);
-  GTEST_ASSERT_NE(1, 0);
-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_NE(0, 0) << "An expected failure",
-                       "An expected failure");
-
-  GTEST_ASSERT_LE(0, 0);
-  GTEST_ASSERT_LE(0, 1);
-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LE(1, 0) << "An expected failure",
-                       "An expected failure");
-
-  GTEST_ASSERT_LT(0, 1);
-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(0, 0) << "An expected failure",
-                       "An expected failure");
-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(1, 0) << "An expected failure",
-                       "An expected failure");
-
-  GTEST_ASSERT_GE(0, 0);
-  GTEST_ASSERT_GE(1, 0);
-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GE(0, 1) << "An expected failure",
-                       "An expected failure");
-
-  GTEST_ASSERT_GT(1, 0);
-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(0, 1) << "An expected failure",
-                       "An expected failure");
-  EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(1, 1) << "An expected failure",
-                       "An expected failure");
-}
-
-// Tests for internal utilities necessary for implementation of the universal
-// printing.
-// TODO(vladl@google.com): Find a better home for them.
-
-class ConversionHelperBase {};
-class ConversionHelperDerived : public ConversionHelperBase {};
-
-// Tests that IsAProtocolMessage<T>::value is a compile-time constant.
-TEST(IsAProtocolMessageTest, ValueIsCompileTimeConstant) {
-  GTEST_COMPILE_ASSERT_(IsAProtocolMessage<ProtocolMessage>::value,
-                        const_true);
-  GTEST_COMPILE_ASSERT_(!IsAProtocolMessage<int>::value, const_false);
-}
-
-// Tests that IsAProtocolMessage<T>::value is true when T is
-// proto2::Message or a sub-class of it.
-TEST(IsAProtocolMessageTest, ValueIsTrueWhenTypeIsAProtocolMessage) {
-  EXPECT_TRUE(IsAProtocolMessage< ::proto2::Message>::value);
-  EXPECT_TRUE(IsAProtocolMessage<ProtocolMessage>::value);
-}
-
-// Tests that IsAProtocolMessage<T>::value is false when T is neither
-// ProtocolMessage nor a sub-class of it.
-TEST(IsAProtocolMessageTest, ValueIsFalseWhenTypeIsNotAProtocolMessage) {
-  EXPECT_FALSE(IsAProtocolMessage<int>::value);
-  EXPECT_FALSE(IsAProtocolMessage<const ConversionHelperBase>::value);
-}
-
-// Tests that CompileAssertTypesEqual compiles when the type arguments are
-// equal.
-TEST(CompileAssertTypesEqual, CompilesWhenTypesAreEqual) {
-  CompileAssertTypesEqual<void, void>();
-  CompileAssertTypesEqual<int*, int*>();
-}
-
-// Tests that RemoveReference does not affect non-reference types.
-TEST(RemoveReferenceTest, DoesNotAffectNonReferenceType) {
-  CompileAssertTypesEqual<int, RemoveReference<int>::type>();
-  CompileAssertTypesEqual<const char, RemoveReference<const char>::type>();
-}
-
-// Tests that RemoveReference removes reference from reference types.
-TEST(RemoveReferenceTest, RemovesReference) {
-  CompileAssertTypesEqual<int, RemoveReference<int&>::type>();
-  CompileAssertTypesEqual<const char, RemoveReference<const char&>::type>();
-}
-
-// Tests GTEST_REMOVE_REFERENCE_.
-
-template <typename T1, typename T2>
-void TestGTestRemoveReference() {
-  CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_(T2)>();
-}
-
-TEST(RemoveReferenceTest, MacroVersion) {
-  TestGTestRemoveReference<int, int>();
-  TestGTestRemoveReference<const char, const char&>();
-}
-
-
-// Tests that RemoveConst does not affect non-const types.
-TEST(RemoveConstTest, DoesNotAffectNonConstType) {
-  CompileAssertTypesEqual<int, RemoveConst<int>::type>();
-  CompileAssertTypesEqual<char&, RemoveConst<char&>::type>();
-}
-
-// Tests that RemoveConst removes const from const types.
-TEST(RemoveConstTest, RemovesConst) {
-  CompileAssertTypesEqual<int, RemoveConst<const int>::type>();
-  CompileAssertTypesEqual<char[2], RemoveConst<const char[2]>::type>();
-  CompileAssertTypesEqual<char[2][3], RemoveConst<const char[2][3]>::type>();
-}
-
-// Tests GTEST_REMOVE_CONST_.
-
-template <typename T1, typename T2>
-void TestGTestRemoveConst() {
-  CompileAssertTypesEqual<T1, GTEST_REMOVE_CONST_(T2)>();
-}
-
-TEST(RemoveConstTest, MacroVersion) {
-  TestGTestRemoveConst<int, int>();
-  TestGTestRemoveConst<double&, double&>();
-  TestGTestRemoveConst<char, const char>();
-}
-
-// Tests GTEST_REMOVE_REFERENCE_AND_CONST_.
-
-template <typename T1, typename T2>
-void TestGTestRemoveReferenceAndConst() {
-  CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_AND_CONST_(T2)>();
-}
-
-TEST(RemoveReferenceToConstTest, Works) {
-  TestGTestRemoveReferenceAndConst<int, int>();
-  TestGTestRemoveReferenceAndConst<double, double&>();
-  TestGTestRemoveReferenceAndConst<char, const char>();
-  TestGTestRemoveReferenceAndConst<char, const char&>();
-  TestGTestRemoveReferenceAndConst<const char*, const char*>();
-}
-
-// Tests that AddReference does not affect reference types.
-TEST(AddReferenceTest, DoesNotAffectReferenceType) {
-  CompileAssertTypesEqual<int&, AddReference<int&>::type>();
-  CompileAssertTypesEqual<const char&, AddReference<const char&>::type>();
-}
-
-// Tests that AddReference adds reference to non-reference types.
-TEST(AddReferenceTest, AddsReference) {
-  CompileAssertTypesEqual<int&, AddReference<int>::type>();
-  CompileAssertTypesEqual<const char&, AddReference<const char>::type>();
-}
-
-// Tests GTEST_ADD_REFERENCE_.
-
-template <typename T1, typename T2>
-void TestGTestAddReference() {
-  CompileAssertTypesEqual<T1, GTEST_ADD_REFERENCE_(T2)>();
-}
-
-TEST(AddReferenceTest, MacroVersion) {
-  TestGTestAddReference<int&, int>();
-  TestGTestAddReference<const char&, const char&>();
-}
-
-// Tests GTEST_REFERENCE_TO_CONST_.
-
-template <typename T1, typename T2>
-void TestGTestReferenceToConst() {
-  CompileAssertTypesEqual<T1, GTEST_REFERENCE_TO_CONST_(T2)>();
-}
-
-TEST(GTestReferenceToConstTest, Works) {
-  TestGTestReferenceToConst<const char&, char>();
-  TestGTestReferenceToConst<const int&, const int>();
-  TestGTestReferenceToConst<const double&, double>();
-  TestGTestReferenceToConst<const std::string&, const std::string&>();
-}
-
-// Tests that ImplicitlyConvertible<T1, T2>::value is a compile-time constant.
-TEST(ImplicitlyConvertibleTest, ValueIsCompileTimeConstant) {
-  GTEST_COMPILE_ASSERT_((ImplicitlyConvertible<int, int>::value), const_true);
-  GTEST_COMPILE_ASSERT_((!ImplicitlyConvertible<void*, int*>::value),
-                        const_false);
-}
-
-// Tests that ImplicitlyConvertible<T1, T2>::value is true when T1 can
-// be implicitly converted to T2.
-TEST(ImplicitlyConvertibleTest, ValueIsTrueWhenConvertible) {
-  EXPECT_TRUE((ImplicitlyConvertible<int, double>::value));
-  EXPECT_TRUE((ImplicitlyConvertible<double, int>::value));
-  EXPECT_TRUE((ImplicitlyConvertible<int*, void*>::value));
-  EXPECT_TRUE((ImplicitlyConvertible<int*, const int*>::value));
-  EXPECT_TRUE((ImplicitlyConvertible<ConversionHelperDerived&,
-                                     const ConversionHelperBase&>::value));
-  EXPECT_TRUE((ImplicitlyConvertible<const ConversionHelperBase,
-                                     ConversionHelperBase>::value));
-}
-
-// Tests that ImplicitlyConvertible<T1, T2>::value is false when T1
-// cannot be implicitly converted to T2.
-TEST(ImplicitlyConvertibleTest, ValueIsFalseWhenNotConvertible) {
-  EXPECT_FALSE((ImplicitlyConvertible<double, int*>::value));
-  EXPECT_FALSE((ImplicitlyConvertible<void*, int*>::value));
-  EXPECT_FALSE((ImplicitlyConvertible<const int*, int*>::value));
-  EXPECT_FALSE((ImplicitlyConvertible<ConversionHelperBase&,
-                                      ConversionHelperDerived&>::value));
-}
-
-// Tests IsContainerTest.
-
-class NonContainer {};
-
-TEST(IsContainerTestTest, WorksForNonContainer) {
-  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<int>(0)));
-  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<char[5]>(0)));
-  EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<NonContainer>(0)));
-}
-
-TEST(IsContainerTestTest, WorksForContainer) {
-  EXPECT_EQ(sizeof(IsContainer),
-            sizeof(IsContainerTest<std::vector<bool> >(0)));
-  EXPECT_EQ(sizeof(IsContainer),
-            sizeof(IsContainerTest<std::map<int, double> >(0)));
-}
-
-// Tests ArrayEq().
-
-TEST(ArrayEqTest, WorksForDegeneratedArrays) {
-  EXPECT_TRUE(ArrayEq(5, 5L));
-  EXPECT_FALSE(ArrayEq('a', 0));
-}
-
-TEST(ArrayEqTest, WorksForOneDimensionalArrays) {
-  // Note that a and b are distinct but compatible types.
-  const int a[] = { 0, 1 };
-  long b[] = { 0, 1 };
-  EXPECT_TRUE(ArrayEq(a, b));
-  EXPECT_TRUE(ArrayEq(a, 2, b));
-
-  b[0] = 2;
-  EXPECT_FALSE(ArrayEq(a, b));
-  EXPECT_FALSE(ArrayEq(a, 1, b));
-}
-
-TEST(ArrayEqTest, WorksForTwoDimensionalArrays) {
-  const char a[][3] = { "hi", "lo" };
-  const char b[][3] = { "hi", "lo" };
-  const char c[][3] = { "hi", "li" };
-
-  EXPECT_TRUE(ArrayEq(a, b));
-  EXPECT_TRUE(ArrayEq(a, 2, b));
-
-  EXPECT_FALSE(ArrayEq(a, c));
-  EXPECT_FALSE(ArrayEq(a, 2, c));
-}
-
-// Tests ArrayAwareFind().
-
-TEST(ArrayAwareFindTest, WorksForOneDimensionalArray) {
-  const char a[] = "hello";
-  EXPECT_EQ(a + 4, ArrayAwareFind(a, a + 5, 'o'));
-  EXPECT_EQ(a + 5, ArrayAwareFind(a, a + 5, 'x'));
-}
-
-TEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) {
-  int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };
-  const int b[2] = { 2, 3 };
-  EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b));
-
-  const int c[2] = { 6, 7 };
-  EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c));
-}
-
-// Tests CopyArray().
-
-TEST(CopyArrayTest, WorksForDegeneratedArrays) {
-  int n = 0;
-  CopyArray('a', &n);
-  EXPECT_EQ('a', n);
-}
-
-TEST(CopyArrayTest, WorksForOneDimensionalArrays) {
-  const char a[3] = "hi";
-  int b[3];
-#ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.
-  CopyArray(a, &b);
-  EXPECT_TRUE(ArrayEq(a, b));
-#endif
-
-  int c[3];
-  CopyArray(a, 3, c);
-  EXPECT_TRUE(ArrayEq(a, c));
-}
-
-TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {
-  const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } };
-  int b[2][3];
-#ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.
-  CopyArray(a, &b);
-  EXPECT_TRUE(ArrayEq(a, b));
-#endif
-
-  int c[2][3];
-  CopyArray(a, 2, c);
-  EXPECT_TRUE(ArrayEq(a, c));
-}
-
-// Tests NativeArray.
-
-TEST(NativeArrayTest, ConstructorFromArrayWorks) {
-  const int a[3] = { 0, 1, 2 };
-  NativeArray<int> na(a, 3, RelationToSourceReference());
-  EXPECT_EQ(3U, na.size());
-  EXPECT_EQ(a, na.begin());
-}
-
-TEST(NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo) {
-  typedef int Array[2];
-  Array* a = new Array[1];
-  (*a)[0] = 0;
-  (*a)[1] = 1;
-  NativeArray<int> na(*a, 2, RelationToSourceCopy());
-  EXPECT_NE(*a, na.begin());
-  delete[] a;
-  EXPECT_EQ(0, na.begin()[0]);
-  EXPECT_EQ(1, na.begin()[1]);
-
-  // We rely on the heap checker to verify that na deletes the copy of
-  // array.
-}
-
-TEST(NativeArrayTest, TypeMembersAreCorrect) {
-  StaticAssertTypeEq<char, NativeArray<char>::value_type>();
-  StaticAssertTypeEq<int[2], NativeArray<int[2]>::value_type>();
-
-  StaticAssertTypeEq<const char*, NativeArray<char>::const_iterator>();
-  StaticAssertTypeEq<const bool(*)[2], NativeArray<bool[2]>::const_iterator>();
-}
-
-TEST(NativeArrayTest, MethodsWork) {
-  const int a[3] = { 0, 1, 2 };
-  NativeArray<int> na(a, 3, RelationToSourceCopy());
-  ASSERT_EQ(3U, na.size());
-  EXPECT_EQ(3, na.end() - na.begin());
-
-  NativeArray<int>::const_iterator it = na.begin();
-  EXPECT_EQ(0, *it);
-  ++it;
-  EXPECT_EQ(1, *it);
-  it++;
-  EXPECT_EQ(2, *it);
-  ++it;
-  EXPECT_EQ(na.end(), it);
-
-  EXPECT_TRUE(na == na);
-
-  NativeArray<int> na2(a, 3, RelationToSourceReference());
-  EXPECT_TRUE(na == na2);
-
-  const int b1[3] = { 0, 1, 1 };
-  const int b2[4] = { 0, 1, 2, 3 };
-  EXPECT_FALSE(na == NativeArray<int>(b1, 3, RelationToSourceReference()));
-  EXPECT_FALSE(na == NativeArray<int>(b2, 4, RelationToSourceCopy()));
-}
-
-TEST(NativeArrayTest, WorksForTwoDimensionalArray) {
-  const char a[2][3] = { "hi", "lo" };
-  NativeArray<char[3]> na(a, 2, RelationToSourceReference());
-  ASSERT_EQ(2U, na.size());
-  EXPECT_EQ(a, na.begin());
-}
-
-// Tests SkipPrefix().
-
-TEST(SkipPrefixTest, SkipsWhenPrefixMatches) {
-  const char* const str = "hello";
-
-  const char* p = str;
-  EXPECT_TRUE(SkipPrefix("", &p));
-  EXPECT_EQ(str, p);
-
-  p = str;
-  EXPECT_TRUE(SkipPrefix("hell", &p));
-  EXPECT_EQ(str + 4, p);
-}
-
-TEST(SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch) {
-  const char* const str = "world";
-
-  const char* p = str;
-  EXPECT_FALSE(SkipPrefix("W", &p));
-  EXPECT_EQ(str, p);
-
-  p = str;
-  EXPECT_FALSE(SkipPrefix("world!", &p));
-  EXPECT_EQ(str, p);
-}
-
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile1_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile1_test_.cc
deleted file mode 100644
index 531ced49..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile1_test_.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-// 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.
-//
-// Author: keith.ray@gmail.com (Keith Ray)
-//
-// gtest_xml_outfile1_test_ writes some xml via TestProperty used by
-// gtest_xml_outfiles_test.py
-
-#include "gtest/gtest.h"
-
-class PropertyOne : public testing::Test {
- protected:
-  virtual void SetUp() {
-    RecordProperty("SetUpProp", 1);
-  }
-  virtual void TearDown() {
-    RecordProperty("TearDownProp", 1);
-  }
-};
-
-TEST_F(PropertyOne, TestSomeProperties) {
-  RecordProperty("TestSomeProperty", 1);
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile2_test_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile2_test_.cc
deleted file mode 100644
index 7b400b27..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfile2_test_.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-// 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.
-//
-// Author: keith.ray@gmail.com (Keith Ray)
-//
-// gtest_xml_outfile2_test_ writes some xml via TestProperty used by
-// gtest_xml_outfiles_test.py
-
-#include "gtest/gtest.h"
-
-class PropertyTwo : public testing::Test {
- protected:
-  virtual void SetUp() {
-    RecordProperty("SetUpProp", 2);
-  }
-  virtual void TearDown() {
-    RecordProperty("TearDownProp", 2);
-  }
-};
-
-TEST_F(PropertyTwo, TestSomeProperties) {
-  RecordProperty("TestSomeProperty", 2);
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfiles_test.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfiles_test.py
deleted file mode 100755
index 524e437e..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_outfiles_test.py
+++ /dev/null
@@ -1,132 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-
-"""Unit test for the gtest_xml_output module."""
-
-__author__ = "keith.ray@gmail.com (Keith Ray)"
-
-import os
-from xml.dom import minidom, Node
-
-import gtest_test_utils
-import gtest_xml_test_utils
-
-
-GTEST_OUTPUT_SUBDIR = "xml_outfiles"
-GTEST_OUTPUT_1_TEST = "gtest_xml_outfile1_test_"
-GTEST_OUTPUT_2_TEST = "gtest_xml_outfile2_test_"
-
-EXPECTED_XML_1 = """<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="1" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests">
-  <testsuite name="PropertyOne" tests="1" failures="0" disabled="0" errors="0" time="*">
-    <testcase name="TestSomeProperties" status="run" time="*" classname="PropertyOne" SetUpProp="1" TestSomeProperty="1" TearDownProp="1" />
-  </testsuite>
-</testsuites>
-"""
-
-EXPECTED_XML_2 = """<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="1" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests">
-  <testsuite name="PropertyTwo" tests="1" failures="0" disabled="0" errors="0" time="*">
-    <testcase name="TestSomeProperties" status="run" time="*" classname="PropertyTwo" SetUpProp="2" TestSomeProperty="2" TearDownProp="2" />
-  </testsuite>
-</testsuites>
-"""
-
-
-class GTestXMLOutFilesTest(gtest_xml_test_utils.GTestXMLTestCase):
-  """Unit test for Google Test's XML output functionality."""
-
-  def setUp(self):
-    # We want the trailing '/' that the last "" provides in os.path.join, for
-    # telling Google Test to create an output directory instead of a single file
-    # for xml output.
-    self.output_dir_ = os.path.join(gtest_test_utils.GetTempDir(),
-                                    GTEST_OUTPUT_SUBDIR, "")
-    self.DeleteFilesAndDir()
-
-  def tearDown(self):
-    self.DeleteFilesAndDir()
-
-  def DeleteFilesAndDir(self):
-    try:
-      os.remove(os.path.join(self.output_dir_, GTEST_OUTPUT_1_TEST + ".xml"))
-    except os.error:
-      pass
-    try:
-      os.remove(os.path.join(self.output_dir_, GTEST_OUTPUT_2_TEST + ".xml"))
-    except os.error:
-      pass
-    try:
-      os.rmdir(self.output_dir_)
-    except os.error:
-      pass
-
-  def testOutfile1(self):
-    self._TestOutFile(GTEST_OUTPUT_1_TEST, EXPECTED_XML_1)
-
-  def testOutfile2(self):
-    self._TestOutFile(GTEST_OUTPUT_2_TEST, EXPECTED_XML_2)
-
-  def _TestOutFile(self, test_name, expected_xml):
-    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(test_name)
-    command = [gtest_prog_path, "--gtest_output=xml:%s" % self.output_dir_]
-    p = gtest_test_utils.Subprocess(command,
-                                    working_dir=gtest_test_utils.GetTempDir())
-    self.assert_(p.exited)
-    self.assertEquals(0, p.exit_code)
-
-    # TODO(wan@google.com): libtool causes the built test binary to be
-    #   named lt-gtest_xml_outfiles_test_ instead of
-    #   gtest_xml_outfiles_test_.  To account for this possibillity, we
-    #   allow both names in the following code.  We should remove this
-    #   hack when Chandler Carruth's libtool replacement tool is ready.
-    output_file_name1 = test_name + ".xml"
-    output_file1 = os.path.join(self.output_dir_, output_file_name1)
-    output_file_name2 = 'lt-' + output_file_name1
-    output_file2 = os.path.join(self.output_dir_, output_file_name2)
-    self.assert_(os.path.isfile(output_file1) or os.path.isfile(output_file2),
-                 output_file1)
-
-    expected = minidom.parseString(expected_xml)
-    if os.path.isfile(output_file1):
-      actual = minidom.parse(output_file1)
-    else:
-      actual = minidom.parse(output_file2)
-    self.NormalizeXml(actual.documentElement)
-    self.AssertEquivalentNodes(expected.documentElement,
-                               actual.documentElement)
-    expected.unlink()
-    actual.unlink()
-
-
-if __name__ == "__main__":
-  os.environ["GTEST_STACK_TRACE_DEPTH"] = "0"
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest.py
deleted file mode 100755
index bcd59759..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest.py
+++ /dev/null
@@ -1,308 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2006, 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.
-
-"""Unit test for the gtest_xml_output module"""
-
-__author__ = 'eefacm@gmail.com (Sean Mcafee)'
-
-import datetime
-import errno
-import os
-import re
-import sys
-from xml.dom import minidom, Node
-
-import gtest_test_utils
-import gtest_xml_test_utils
-
-
-GTEST_FILTER_FLAG = '--gtest_filter'
-GTEST_LIST_TESTS_FLAG = '--gtest_list_tests'
-GTEST_OUTPUT_FLAG         = "--gtest_output"
-GTEST_DEFAULT_OUTPUT_FILE = "test_detail.xml"
-GTEST_PROGRAM_NAME = "gtest_xml_output_unittest_"
-
-SUPPORTS_STACK_TRACES = False
-
-if SUPPORTS_STACK_TRACES:
-  STACK_TRACE_TEMPLATE = '\nStack trace:\n*'
-else:
-  STACK_TRACE_TEMPLATE = ''
-
-EXPECTED_NON_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="23" failures="4" disabled="2" errors="0" time="*" timestamp="*" name="AllTests" ad_hoc_property="42">
-  <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" errors="0" time="*">
-    <testcase name="Succeeds" status="run" time="*" classname="SuccessfulTest"/>
-  </testsuite>
-  <testsuite name="FailedTest" tests="1" failures="1" disabled="0" errors="0" time="*">
-    <testcase name="Fails" status="run" time="*" classname="FailedTest">
-      <failure message="gtest_xml_output_unittest_.cc:*&#x0A;      Expected: 1&#x0A;To be equal to: 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
-      Expected: 1
-To be equal to: 2%(stack)s]]></failure>
-    </testcase>
-  </testsuite>
-  <testsuite name="MixedResultTest" tests="3" failures="1" disabled="1" errors="0" time="*">
-    <testcase name="Succeeds" status="run" time="*" classname="MixedResultTest"/>
-    <testcase name="Fails" status="run" time="*" classname="MixedResultTest">
-      <failure message="gtest_xml_output_unittest_.cc:*&#x0A;      Expected: 1&#x0A;To be equal to: 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
-      Expected: 1
-To be equal to: 2%(stack)s]]></failure>
-      <failure message="gtest_xml_output_unittest_.cc:*&#x0A;      Expected: 2&#x0A;To be equal to: 3" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
-      Expected: 2
-To be equal to: 3%(stack)s]]></failure>
-    </testcase>
-    <testcase name="DISABLED_test" status="notrun" time="*" classname="MixedResultTest"/>
-  </testsuite>
-  <testsuite name="XmlQuotingTest" tests="1" failures="1" disabled="0" errors="0" time="*">
-    <testcase name="OutputsCData" status="run" time="*" classname="XmlQuotingTest">
-      <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Failed&#x0A;XML output: &lt;?xml encoding=&quot;utf-8&quot;&gt;&lt;top&gt;&lt;![CDATA[cdata text]]&gt;&lt;/top&gt;" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
-Failed
-XML output: <?xml encoding="utf-8"><top><![CDATA[cdata text]]>]]&gt;<![CDATA[</top>%(stack)s]]></failure>
-    </testcase>
-  </testsuite>
-  <testsuite name="InvalidCharactersTest" tests="1" failures="1" disabled="0" errors="0" time="*">
-    <testcase name="InvalidCharactersInMessage" status="run" time="*" classname="InvalidCharactersTest">
-      <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Failed&#x0A;Invalid characters in brackets []" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
-Failed
-Invalid characters in brackets []%(stack)s]]></failure>
-    </testcase>
-  </testsuite>
-  <testsuite name="DisabledTest" tests="1" failures="0" disabled="1" errors="0" time="*">
-    <testcase name="DISABLED_test_not_run" status="notrun" time="*" classname="DisabledTest"/>
-  </testsuite>
-  <testsuite name="PropertyRecordingTest" tests="4" failures="0" disabled="0" errors="0" time="*" SetUpTestCase="yes" TearDownTestCase="aye">
-    <testcase name="OneProperty" status="run" time="*" classname="PropertyRecordingTest" key_1="1"/>
-    <testcase name="IntValuedProperty" status="run" time="*" classname="PropertyRecordingTest" key_int="1"/>
-    <testcase name="ThreeProperties" status="run" time="*" classname="PropertyRecordingTest" key_1="1" key_2="2" key_3="3"/>
-    <testcase name="TwoValuesForOneKeyUsesLastValue" status="run" time="*" classname="PropertyRecordingTest" key_1="2"/>
-  </testsuite>
-  <testsuite name="NoFixtureTest" tests="3" failures="0" disabled="0" errors="0" time="*">
-     <testcase name="RecordProperty" status="run" time="*" classname="NoFixtureTest" key="1"/>
-     <testcase name="ExternalUtilityThatCallsRecordIntValuedProperty" status="run" time="*" classname="NoFixtureTest" key_for_utility_int="1"/>
-     <testcase name="ExternalUtilityThatCallsRecordStringValuedProperty" status="run" time="*" classname="NoFixtureTest" key_for_utility_string="1"/>
-  </testsuite>
-  <testsuite name="Single/ValueParamTest" tests="4" failures="0" disabled="0" errors="0" time="*">
-    <testcase name="HasValueParamAttribute/0" value_param="33" status="run" time="*" classname="Single/ValueParamTest" />
-    <testcase name="HasValueParamAttribute/1" value_param="42" status="run" time="*" classname="Single/ValueParamTest" />
-    <testcase name="AnotherTestThatHasValueParamAttribute/0" value_param="33" status="run" time="*" classname="Single/ValueParamTest" />
-    <testcase name="AnotherTestThatHasValueParamAttribute/1" value_param="42" status="run" time="*" classname="Single/ValueParamTest" />
-  </testsuite>
-  <testsuite name="TypedTest/0" tests="1" failures="0" disabled="0" errors="0" time="*">
-    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="TypedTest/0" />
-  </testsuite>
-  <testsuite name="TypedTest/1" tests="1" failures="0" disabled="0" errors="0" time="*">
-    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="TypedTest/1" />
-  </testsuite>
-  <testsuite name="Single/TypeParameterizedTestCase/0" tests="1" failures="0" disabled="0" errors="0" time="*">
-    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestCase/0" />
-  </testsuite>
-  <testsuite name="Single/TypeParameterizedTestCase/1" tests="1" failures="0" disabled="0" errors="0" time="*">
-    <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestCase/1" />
-  </testsuite>
-</testsuites>""" % {'stack': STACK_TRACE_TEMPLATE}
-
-EXPECTED_FILTERED_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="1" failures="0" disabled="0" errors="0" time="*"
-            timestamp="*" name="AllTests" ad_hoc_property="42">
-  <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0"
-             errors="0" time="*">
-    <testcase name="Succeeds" status="run" time="*" classname="SuccessfulTest"/>
-  </testsuite>
-</testsuites>"""
-
-EXPECTED_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="0" failures="0" disabled="0" errors="0" time="*"
-            timestamp="*" name="AllTests">
-</testsuites>"""
-
-GTEST_PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath(GTEST_PROGRAM_NAME)
-
-SUPPORTS_TYPED_TESTS = 'TypedTest' in gtest_test_utils.Subprocess(
-    [GTEST_PROGRAM_PATH, GTEST_LIST_TESTS_FLAG], capture_stderr=False).output
-
-
-class GTestXMLOutputUnitTest(gtest_xml_test_utils.GTestXMLTestCase):
-  """
-  Unit test for Google Test's XML output functionality.
-  """
-
-  # This test currently breaks on platforms that do not support typed and
-  # type-parameterized tests, so we don't run it under them.
-  if SUPPORTS_TYPED_TESTS:
-    def testNonEmptyXmlOutput(self):
-      """
-      Runs a test program that generates a non-empty XML output, and
-      tests that the XML output is expected.
-      """
-      self._TestXmlOutput(GTEST_PROGRAM_NAME, EXPECTED_NON_EMPTY_XML, 1)
-
-  def testEmptyXmlOutput(self):
-    """Verifies XML output for a Google Test binary without actual tests.
-
-    Runs a test program that generates an empty XML output, and
-    tests that the XML output is expected.
-    """
-
-    self._TestXmlOutput('gtest_no_test_unittest', EXPECTED_EMPTY_XML, 0)
-
-  def testTimestampValue(self):
-    """Checks whether the timestamp attribute in the XML output is valid.
-
-    Runs a test program that generates an empty XML output, and checks if
-    the timestamp attribute in the testsuites tag is valid.
-    """
-    actual = self._GetXmlOutput('gtest_no_test_unittest', [], 0)
-    date_time_str = actual.documentElement.getAttributeNode('timestamp').value
-    # datetime.strptime() is only available in Python 2.5+ so we have to
-    # parse the expected datetime manually.
-    match = re.match(r'(\d+)-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)', date_time_str)
-    self.assertTrue(
-        re.match,
-        'XML datettime string %s has incorrect format' % date_time_str)
-    date_time_from_xml = datetime.datetime(
-        year=int(match.group(1)), month=int(match.group(2)),
-        day=int(match.group(3)), hour=int(match.group(4)),
-        minute=int(match.group(5)), second=int(match.group(6)))
-
-    time_delta = abs(datetime.datetime.now() - date_time_from_xml)
-    # timestamp value should be near the current local time
-    self.assertTrue(time_delta < datetime.timedelta(seconds=600),
-                    'time_delta is %s' % time_delta)
-    actual.unlink()
-
-  def testDefaultOutputFile(self):
-    """
-    Confirms that Google Test produces an XML output file with the expected
-    default name if no name is explicitly specified.
-    """
-    output_file = os.path.join(gtest_test_utils.GetTempDir(),
-                               GTEST_DEFAULT_OUTPUT_FILE)
-    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(
-        'gtest_no_test_unittest')
-    try:
-      os.remove(output_file)
-    except OSError:
-      e = sys.exc_info()[1]
-      if e.errno != errno.ENOENT:
-        raise
-
-    p = gtest_test_utils.Subprocess(
-        [gtest_prog_path, '%s=xml' % GTEST_OUTPUT_FLAG],
-        working_dir=gtest_test_utils.GetTempDir())
-    self.assert_(p.exited)
-    self.assertEquals(0, p.exit_code)
-    self.assert_(os.path.isfile(output_file))
-
-  def testSuppressedXmlOutput(self):
-    """
-    Tests that no XML file is generated if the default XML listener is
-    shut down before RUN_ALL_TESTS is invoked.
-    """
-
-    xml_path = os.path.join(gtest_test_utils.GetTempDir(),
-                            GTEST_PROGRAM_NAME + 'out.xml')
-    if os.path.isfile(xml_path):
-      os.remove(xml_path)
-
-    command = [GTEST_PROGRAM_PATH,
-               '%s=xml:%s' % (GTEST_OUTPUT_FLAG, xml_path),
-               '--shut_down_xml']
-    p = gtest_test_utils.Subprocess(command)
-    if p.terminated_by_signal:
-      # p.signal is avalable only if p.terminated_by_signal is True.
-      self.assertFalse(
-          p.terminated_by_signal,
-          '%s was killed by signal %d' % (GTEST_PROGRAM_NAME, p.signal))
-    else:
-      self.assert_(p.exited)
-      self.assertEquals(1, p.exit_code,
-                        "'%s' exited with code %s, which doesn't match "
-                        'the expected exit code %s.'
-                        % (command, p.exit_code, 1))
-
-    self.assert_(not os.path.isfile(xml_path))
-
-  def testFilteredTestXmlOutput(self):
-    """Verifies XML output when a filter is applied.
-
-    Runs a test program that executes only some tests and verifies that
-    non-selected tests do not show up in the XML output.
-    """
-
-    self._TestXmlOutput(GTEST_PROGRAM_NAME, EXPECTED_FILTERED_TEST_XML, 0,
-                        extra_args=['%s=SuccessfulTest.*' % GTEST_FILTER_FLAG])
-
-  def _GetXmlOutput(self, gtest_prog_name, extra_args, expected_exit_code):
-    """
-    Returns the xml output generated by running the program gtest_prog_name.
-    Furthermore, the program's exit code must be expected_exit_code.
-    """
-    xml_path = os.path.join(gtest_test_utils.GetTempDir(),
-                            gtest_prog_name + 'out.xml')
-    gtest_prog_path = gtest_test_utils.GetTestExecutablePath(gtest_prog_name)
-
-    command = ([gtest_prog_path, '%s=xml:%s' % (GTEST_OUTPUT_FLAG, xml_path)] +
-               extra_args)
-    p = gtest_test_utils.Subprocess(command)
-    if p.terminated_by_signal:
-      self.assert_(False,
-                   '%s was killed by signal %d' % (gtest_prog_name, p.signal))
-    else:
-      self.assert_(p.exited)
-      self.assertEquals(expected_exit_code, p.exit_code,
-                        "'%s' exited with code %s, which doesn't match "
-                        'the expected exit code %s.'
-                        % (command, p.exit_code, expected_exit_code))
-    actual = minidom.parse(xml_path)
-    return actual
-
-  def _TestXmlOutput(self, gtest_prog_name, expected_xml,
-                     expected_exit_code, extra_args=None):
-    """
-    Asserts that the XML document generated by running the program
-    gtest_prog_name matches expected_xml, a string containing another
-    XML document.  Furthermore, the program's exit code must be
-    expected_exit_code.
-    """
-
-    actual = self._GetXmlOutput(gtest_prog_name, extra_args or [],
-                                expected_exit_code)
-    expected = minidom.parseString(expected_xml)
-    self.NormalizeXml(actual.documentElement)
-    self.AssertEquivalentNodes(expected.documentElement,
-                               actual.documentElement)
-    expected.unlink()
-    actual.unlink()
-
-
-if __name__ == '__main__':
-  os.environ['GTEST_STACK_TRACE_DEPTH'] = '1'
-  gtest_test_utils.Main()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest_.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest_.cc
deleted file mode 100644
index 48b8771b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_output_unittest_.cc
+++ /dev/null
@@ -1,181 +0,0 @@
-// Copyright 2006, 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.
-
-// Author: eefacm@gmail.com (Sean Mcafee)
-
-// Unit test for Google Test XML output.
-//
-// A user can specify XML output in a Google Test program to run via
-// either the GTEST_OUTPUT environment variable or the --gtest_output
-// flag.  This is used for testing such functionality.
-//
-// This program will be invoked from a Python unit test.  Don't run it
-// directly.
-
-#include "gtest/gtest.h"
-
-using ::testing::InitGoogleTest;
-using ::testing::TestEventListeners;
-using ::testing::TestWithParam;
-using ::testing::UnitTest;
-using ::testing::Test;
-using ::testing::Values;
-
-class SuccessfulTest : public Test {
-};
-
-TEST_F(SuccessfulTest, Succeeds) {
-  SUCCEED() << "This is a success.";
-  ASSERT_EQ(1, 1);
-}
-
-class FailedTest : public Test {
-};
-
-TEST_F(FailedTest, Fails) {
-  ASSERT_EQ(1, 2);
-}
-
-class DisabledTest : public Test {
-};
-
-TEST_F(DisabledTest, DISABLED_test_not_run) {
-  FAIL() << "Unexpected failure: Disabled test should not be run";
-}
-
-TEST(MixedResultTest, Succeeds) {
-  EXPECT_EQ(1, 1);
-  ASSERT_EQ(1, 1);
-}
-
-TEST(MixedResultTest, Fails) {
-  EXPECT_EQ(1, 2);
-  ASSERT_EQ(2, 3);
-}
-
-TEST(MixedResultTest, DISABLED_test) {
-  FAIL() << "Unexpected failure: Disabled test should not be run";
-}
-
-TEST(XmlQuotingTest, OutputsCData) {
-  FAIL() << "XML output: "
-            "<?xml encoding=\"utf-8\"><top><![CDATA[cdata text]]></top>";
-}
-
-// Helps to test that invalid characters produced by test code do not make
-// it into the XML file.
-TEST(InvalidCharactersTest, InvalidCharactersInMessage) {
-  FAIL() << "Invalid characters in brackets [\x1\x2]";
-}
-
-class PropertyRecordingTest : public Test {
- public:
-  static void SetUpTestCase() { RecordProperty("SetUpTestCase", "yes"); }
-  static void TearDownTestCase() { RecordProperty("TearDownTestCase", "aye"); }
-};
-
-TEST_F(PropertyRecordingTest, OneProperty) {
-  RecordProperty("key_1", "1");
-}
-
-TEST_F(PropertyRecordingTest, IntValuedProperty) {
-  RecordProperty("key_int", 1);
-}
-
-TEST_F(PropertyRecordingTest, ThreeProperties) {
-  RecordProperty("key_1", "1");
-  RecordProperty("key_2", "2");
-  RecordProperty("key_3", "3");
-}
-
-TEST_F(PropertyRecordingTest, TwoValuesForOneKeyUsesLastValue) {
-  RecordProperty("key_1", "1");
-  RecordProperty("key_1", "2");
-}
-
-TEST(NoFixtureTest, RecordProperty) {
-  RecordProperty("key", "1");
-}
-
-void ExternalUtilityThatCallsRecordProperty(const std::string& key, int value) {
-  testing::Test::RecordProperty(key, value);
-}
-
-void ExternalUtilityThatCallsRecordProperty(const std::string& key,
-                                            const std::string& value) {
-  testing::Test::RecordProperty(key, value);
-}
-
-TEST(NoFixtureTest, ExternalUtilityThatCallsRecordIntValuedProperty) {
-  ExternalUtilityThatCallsRecordProperty("key_for_utility_int", 1);
-}
-
-TEST(NoFixtureTest, ExternalUtilityThatCallsRecordStringValuedProperty) {
-  ExternalUtilityThatCallsRecordProperty("key_for_utility_string", "1");
-}
-
-// Verifies that the test parameter value is output in the 'value_param'
-// XML attribute for value-parameterized tests.
-class ValueParamTest : public TestWithParam<int> {};
-TEST_P(ValueParamTest, HasValueParamAttribute) {}
-TEST_P(ValueParamTest, AnotherTestThatHasValueParamAttribute) {}
-INSTANTIATE_TEST_CASE_P(Single, ValueParamTest, Values(33, 42));
-
-#if GTEST_HAS_TYPED_TEST
-// Verifies that the type parameter name is output in the 'type_param'
-// XML attribute for typed tests.
-template <typename T> class TypedTest : public Test {};
-typedef testing::Types<int, long> TypedTestTypes;
-TYPED_TEST_CASE(TypedTest, TypedTestTypes);
-TYPED_TEST(TypedTest, HasTypeParamAttribute) {}
-#endif
-
-#if GTEST_HAS_TYPED_TEST_P
-// Verifies that the type parameter name is output in the 'type_param'
-// XML attribute for type-parameterized tests.
-template <typename T> class TypeParameterizedTestCase : public Test {};
-TYPED_TEST_CASE_P(TypeParameterizedTestCase);
-TYPED_TEST_P(TypeParameterizedTestCase, HasTypeParamAttribute) {}
-REGISTER_TYPED_TEST_CASE_P(TypeParameterizedTestCase, HasTypeParamAttribute);
-typedef testing::Types<int, long> TypeParameterizedTestCaseTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(Single,
-                              TypeParameterizedTestCase,
-                              TypeParameterizedTestCaseTypes);
-#endif
-
-int main(int argc, char** argv) {
-  InitGoogleTest(&argc, argv);
-
-  if (argc > 1 && strcmp(argv[1], "--shut_down_xml") == 0) {
-    TestEventListeners& listeners = UnitTest::GetInstance()->listeners();
-    delete listeners.Release(listeners.default_xml_generator());
-  }
-  testing::Test::RecordProperty("ad_hoc_property", "42");
-  return RUN_ALL_TESTS();
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_test_utils.py b/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_test_utils.py
deleted file mode 100755
index 341956b5..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/gtest_xml_test_utils.py
+++ /dev/null
@@ -1,194 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2006, 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.
-
-"""Unit test utilities for gtest_xml_output"""
-
-__author__ = 'eefacm@gmail.com (Sean Mcafee)'
-
-import re
-from xml.dom import minidom, Node
-
-import gtest_test_utils
-
-
-GTEST_OUTPUT_FLAG         = '--gtest_output'
-GTEST_DEFAULT_OUTPUT_FILE = 'test_detail.xml'
-
-class GTestXMLTestCase(gtest_test_utils.TestCase):
-  """
-  Base class for tests of Google Test's XML output functionality.
-  """
-
-
-  def AssertEquivalentNodes(self, expected_node, actual_node):
-    """
-    Asserts that actual_node (a DOM node object) is equivalent to
-    expected_node (another DOM node object), in that either both of
-    them are CDATA nodes and have the same value, or both are DOM
-    elements and actual_node meets all of the following conditions:
-
-    *  It has the same tag name as expected_node.
-    *  It has the same set of attributes as expected_node, each with
-       the same value as the corresponding attribute of expected_node.
-       Exceptions are any attribute named "time", which needs only be
-       convertible to a floating-point number and any attribute named
-       "type_param" which only has to be non-empty.
-    *  It has an equivalent set of child nodes (including elements and
-       CDATA sections) as expected_node.  Note that we ignore the
-       order of the children as they are not guaranteed to be in any
-       particular order.
-    """
-
-    if expected_node.nodeType == Node.CDATA_SECTION_NODE:
-      self.assertEquals(Node.CDATA_SECTION_NODE, actual_node.nodeType)
-      self.assertEquals(expected_node.nodeValue, actual_node.nodeValue)
-      return
-
-    self.assertEquals(Node.ELEMENT_NODE, actual_node.nodeType)
-    self.assertEquals(Node.ELEMENT_NODE, expected_node.nodeType)
-    self.assertEquals(expected_node.tagName, actual_node.tagName)
-
-    expected_attributes = expected_node.attributes
-    actual_attributes   = actual_node  .attributes
-    self.assertEquals(
-        expected_attributes.length, actual_attributes.length,
-        'attribute numbers differ in element %s:\nExpected: %r\nActual: %r' % (
-            actual_node.tagName, expected_attributes.keys(),
-            actual_attributes.keys()))
-    for i in range(expected_attributes.length):
-      expected_attr = expected_attributes.item(i)
-      actual_attr   = actual_attributes.get(expected_attr.name)
-      self.assert_(
-          actual_attr is not None,
-          'expected attribute %s not found in element %s' %
-          (expected_attr.name, actual_node.tagName))
-      self.assertEquals(
-          expected_attr.value, actual_attr.value,
-          ' values of attribute %s in element %s differ: %s vs %s' %
-          (expected_attr.name, actual_node.tagName,
-           expected_attr.value, actual_attr.value))
-
-    expected_children = self._GetChildren(expected_node)
-    actual_children = self._GetChildren(actual_node)
-    self.assertEquals(
-        len(expected_children), len(actual_children),
-        'number of child elements differ in element ' + actual_node.tagName)
-    for child_id, child in expected_children.items():
-      self.assert_(child_id in actual_children,
-                   '<%s> is not in <%s> (in element %s)' %
-                   (child_id, actual_children, actual_node.tagName))
-      self.AssertEquivalentNodes(child, actual_children[child_id])
-
-  identifying_attribute = {
-    'testsuites': 'name',
-    'testsuite': 'name',
-    'testcase':  'name',
-    'failure':   'message',
-    }
-
-  def _GetChildren(self, element):
-    """
-    Fetches all of the child nodes of element, a DOM Element object.
-    Returns them as the values of a dictionary keyed by the IDs of the
-    children.  For <testsuites>, <testsuite> and <testcase> elements, the ID
-    is the value of their "name" attribute; for <failure> elements, it is
-    the value of the "message" attribute; CDATA sections and non-whitespace
-    text nodes are concatenated into a single CDATA section with ID
-    "detail".  An exception is raised if any element other than the above
-    four is encountered, if two child elements with the same identifying
-    attributes are encountered, or if any other type of node is encountered.
-    """
-
-    children = {}
-    for child in element.childNodes:
-      if child.nodeType == Node.ELEMENT_NODE:
-        self.assert_(child.tagName in self.identifying_attribute,
-                     'Encountered unknown element <%s>' % child.tagName)
-        childID = child.getAttribute(self.identifying_attribute[child.tagName])
-        self.assert_(childID not in children)
-        children[childID] = child
-      elif child.nodeType in [Node.TEXT_NODE, Node.CDATA_SECTION_NODE]:
-        if 'detail' not in children:
-          if (child.nodeType == Node.CDATA_SECTION_NODE or
-              not child.nodeValue.isspace()):
-            children['detail'] = child.ownerDocument.createCDATASection(
-                child.nodeValue)
-        else:
-          children['detail'].nodeValue += child.nodeValue
-      else:
-        self.fail('Encountered unexpected node type %d' % child.nodeType)
-    return children
-
-  def NormalizeXml(self, element):
-    """
-    Normalizes Google Test's XML output to eliminate references to transient
-    information that may change from run to run.
-
-    *  The "time" attribute of <testsuites>, <testsuite> and <testcase>
-       elements is replaced with a single asterisk, if it contains
-       only digit characters.
-    *  The "timestamp" attribute of <testsuites> elements is replaced with a
-       single asterisk, if it contains a valid ISO8601 datetime value.
-    *  The "type_param" attribute of <testcase> elements is replaced with a
-       single asterisk (if it sn non-empty) as it is the type name returned
-       by the compiler and is platform dependent.
-    *  The line info reported in the first line of the "message"
-       attribute and CDATA section of <failure> elements is replaced with the
-       file's basename and a single asterisk for the line number.
-    *  The directory names in file paths are removed.
-    *  The stack traces are removed.
-    """
-
-    if element.tagName == 'testsuites':
-      timestamp = element.getAttributeNode('timestamp')
-      timestamp.value = re.sub(r'^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d$',
-                               '*', timestamp.value)
-    if element.tagName in ('testsuites', 'testsuite', 'testcase'):
-      time = element.getAttributeNode('time')
-      time.value = re.sub(r'^\d+(\.\d+)?$', '*', time.value)
-      type_param = element.getAttributeNode('type_param')
-      if type_param and type_param.value:
-        type_param.value = '*'
-    elif element.tagName == 'failure':
-      source_line_pat = r'^.*[/\\](.*:)\d+\n'
-      # Replaces the source line information with a normalized form.
-      message = element.getAttributeNode('message')
-      message.value = re.sub(source_line_pat, '\\1*\n', message.value)
-      for child in element.childNodes:
-        if child.nodeType == Node.CDATA_SECTION_NODE:
-          # Replaces the source line information with a normalized form.
-          cdata = re.sub(source_line_pat, '\\1*\n', child.nodeValue)
-          # Removes the actual stack trace.
-          child.nodeValue = re.sub(r'\nStack trace:\n(.|\n)*',
-                                   '', cdata)
-    for child in element.childNodes:
-      if child.nodeType == Node.ELEMENT_NODE:
-        self.NormalizeXml(child)
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/production.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/test/production.cc
deleted file mode 100644
index 8b8a40b4..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/production.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2006, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// This is part of the unit test for include/gtest/gtest_prod.h.
-
-#include "production.h"
-
-PrivateCode::PrivateCode() : x_(0) {}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/test/production.h b/week4/softwareEng_9_4/vendor/googletest/googletest/test/production.h
deleted file mode 100644
index 98fd5e47..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/test/production.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2006, 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.
-//
-// Author: wan@google.com (Zhanyong Wan)
-//
-// This is part of the unit test for include/gtest/gtest_prod.h.
-
-#ifndef GTEST_TEST_PRODUCTION_H_
-#define GTEST_TEST_PRODUCTION_H_
-
-#include "gtest/gtest_prod.h"
-
-class PrivateCode {
- public:
-  // Declares a friend test that does not use a fixture.
-  FRIEND_TEST(PrivateCodeTest, CanAccessPrivateMembers);
-
-  // Declares a friend test that uses a fixture.
-  FRIEND_TEST(PrivateCodeFixtureTest, CanAccessPrivateMembers);
-
-  PrivateCode();
-
-  int x() const { return x_; }
- private:
-  void set_x(int an_x) { x_ = an_x; }
-  int x_;
-};
-
-#endif  // GTEST_TEST_PRODUCTION_H_
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/DebugProject.xcconfig b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/DebugProject.xcconfig
deleted file mode 100644
index 3d68157d..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/DebugProject.xcconfig
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-//  DebugProject.xcconfig
-//
-//  These are Debug Configuration project settings for the gtest framework and
-//  examples. It is set in the "Based On:" dropdown in the "Project" info
-//  dialog.
-//  This file is based on the Xcode Configuration files in:
-//  http://code.google.com/p/google-toolbox-for-mac/
-// 
-
-#include "General.xcconfig"
-
-// No optimization
-GCC_OPTIMIZATION_LEVEL = 0
-
-// Deployment postprocessing is what triggers Xcode to strip, turn it off
-DEPLOYMENT_POSTPROCESSING = NO
-
-// Dead code stripping off
-DEAD_CODE_STRIPPING = NO
-
-// Debug symbols should be on obviously
-GCC_GENERATE_DEBUGGING_SYMBOLS = YES
-
-// Define the DEBUG macro in all debug builds
-OTHER_CFLAGS = $(OTHER_CFLAGS) -DDEBUG=1
-
-// These are turned off to avoid STL incompatibilities with client code
-// // Turns on special C++ STL checks to "encourage" good STL use
-// GCC_PREPROCESSOR_DEFINITIONS = $(GCC_PREPROCESSOR_DEFINITIONS) _GLIBCXX_DEBUG_PEDANTIC _GLIBCXX_DEBUG _GLIBCPP_CONCEPT_CHECKS
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/FrameworkTarget.xcconfig b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/FrameworkTarget.xcconfig
deleted file mode 100644
index 357b1c8f..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/FrameworkTarget.xcconfig
+++ /dev/null
@@ -1,17 +0,0 @@
-//
-//  FrameworkTarget.xcconfig
-//
-//  These are Framework target settings for the gtest framework and examples. It
-//  is set in the "Based On:" dropdown in the "Target" info dialog.
-//  This file is based on the Xcode Configuration files in:
-//  http://code.google.com/p/google-toolbox-for-mac/
-// 
-
-// Dynamic libs need to be position independent
-GCC_DYNAMIC_NO_PIC = NO
-
-// Dynamic libs should not have their external symbols stripped.
-STRIP_STYLE = non-global
-
-// Let the user install by specifying the $DSTROOT with xcodebuild
-SKIP_INSTALL = NO
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/General.xcconfig b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/General.xcconfig
deleted file mode 100644
index f23e3222..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/General.xcconfig
+++ /dev/null
@@ -1,41 +0,0 @@
-//
-//  General.xcconfig
-//
-//  These are General configuration settings for the gtest framework and
-//  examples.
-//  This file is based on the Xcode Configuration files in:
-//  http://code.google.com/p/google-toolbox-for-mac/
-// 
-
-// Build for PPC and Intel, 32- and 64-bit
-ARCHS = i386 x86_64 ppc ppc64
-
-// Zerolink prevents link warnings so turn it off
-ZERO_LINK = NO
-
-// Prebinding considered unhelpful in 10.3 and later
-PREBINDING = NO
-
-// Strictest warning policy
-WARNING_CFLAGS = -Wall -Werror -Wendif-labels -Wnewline-eof -Wno-sign-compare -Wshadow
-
-// Work around Xcode bugs by using external strip. See:
-// http://lists.apple.com/archives/Xcode-users/2006/Feb/msg00050.html
-SEPARATE_STRIP = YES
-
-// Force C99 dialect
-GCC_C_LANGUAGE_STANDARD = c99
-
-// not sure why apple defaults this on, but it's pretty risky
-ALWAYS_SEARCH_USER_PATHS = NO
-
-// Turn on position dependent code for most cases (overridden where appropriate)
-GCC_DYNAMIC_NO_PIC = YES
-
-// Default SDK and minimum OS version is 10.4
-SDKROOT = $(DEVELOPER_SDK_DIR)/MacOSX10.4u.sdk
-MACOSX_DEPLOYMENT_TARGET = 10.4
-GCC_VERSION = 4.0
-
-// VERSIONING BUILD SETTINGS (used in Info.plist)
-GTEST_VERSIONINFO_ABOUT =  © 2008 Google Inc.
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/ReleaseProject.xcconfig b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/ReleaseProject.xcconfig
deleted file mode 100644
index 5349f0a0..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/ReleaseProject.xcconfig
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-//  ReleaseProject.xcconfig
-//
-//  These are Release Configuration project settings for the gtest framework
-//  and examples. It is set in the "Based On:" dropdown in the "Project" info
-//  dialog.
-//  This file is based on the Xcode Configuration files in:
-//  http://code.google.com/p/google-toolbox-for-mac/
-// 
-
-#include "General.xcconfig"
-
-// subconfig/Release.xcconfig
-
-// Optimize for space and size (Apple recommendation)
-GCC_OPTIMIZATION_LEVEL = s
-
-// Deploment postprocessing is what triggers Xcode to strip
-DEPLOYMENT_POSTPROCESSING = YES
-
-// No symbols
-GCC_GENERATE_DEBUGGING_SYMBOLS = NO
-
-// Dead code strip does not affect ObjC code but can help for C
-DEAD_CODE_STRIPPING = YES
-
-// NDEBUG is used by things like assert.h, so define it for general compat.
-// ASSERT going away in release tends to create unused vars.
-OTHER_CFLAGS = $(OTHER_CFLAGS) -DNDEBUG=1 -Wno-unused-variable
-
-// When we strip we want to strip all symbols in release, but save externals.
-STRIP_STYLE = all
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/StaticLibraryTarget.xcconfig b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/StaticLibraryTarget.xcconfig
deleted file mode 100644
index 3922fa51..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/StaticLibraryTarget.xcconfig
+++ /dev/null
@@ -1,18 +0,0 @@
-//
-//  StaticLibraryTarget.xcconfig
-//
-//  These are static library target settings for libgtest.a. It
-//  is set in the "Based On:" dropdown in the "Target" info dialog.
-//  This file is based on the Xcode Configuration files in:
-//  http://code.google.com/p/google-toolbox-for-mac/
-// 
-
-// Static libs can be included in bundles so make them position independent
-GCC_DYNAMIC_NO_PIC = NO
-
-// Static libs should not have their internal globals or external symbols
-// stripped.
-STRIP_STYLE = debugging
-
-// Let the user install by specifying the $DSTROOT with xcodebuild
-SKIP_INSTALL = NO
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/TestTarget.xcconfig b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/TestTarget.xcconfig
deleted file mode 100644
index e6652ba8..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Config/TestTarget.xcconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-//
-//  TestTarget.xcconfig
-//
-//  These are Test target settings for the gtest framework and examples. It
-//  is set in the "Based On:" dropdown in the "Target" info dialog.
-
-PRODUCT_NAME = $(TARGET_NAME)
-HEADER_SEARCH_PATHS = ../include
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Resources/Info.plist b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Resources/Info.plist
deleted file mode 100644
index 9dd28ea1..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Resources/Info.plist
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>${EXECUTABLE_NAME}</string>
-	<key>CFBundleIconFile</key>
-	<string></string>
-	<key>CFBundleIdentifier</key>
-	<string>com.google.${PRODUCT_NAME}</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundlePackageType</key>
-	<string>FMWK</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>GTEST_VERSIONINFO_LONG</string>
-	<key>CFBundleShortVersionString</key>
-	<string>GTEST_VERSIONINFO_SHORT</string>
-	<key>CFBundleGetInfoString</key>
-	<string>${PRODUCT_NAME} GTEST_VERSIONINFO_LONG, ${GTEST_VERSIONINFO_ABOUT}</string>
-	<key>NSHumanReadableCopyright</key>
-	<string>${GTEST_VERSIONINFO_ABOUT}</string>
-	<key>CSResourcesFileMapped</key>
-	<true/>
-</dict>
-</plist>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/Info.plist b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/Info.plist
deleted file mode 100644
index f3852ede..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/Info.plist
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>${EXECUTABLE_NAME}</string>
-	<key>CFBundleIconFile</key>
-	<string></string>
-	<key>CFBundleIdentifier</key>
-	<string>com.google.gtest.${PRODUCT_NAME:identifier}</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>${PRODUCT_NAME}</string>
-	<key>CFBundlePackageType</key>
-	<string>FMWK</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1.0</string>
-	<key>CSResourcesFileMapped</key>
-	<true/>
-</dict>
-</plist>
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj
deleted file mode 100644
index 497617eb..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/WidgetFramework.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,457 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXAggregateTarget section */
-		4024D162113D7D2400C7059E /* Test */ = {
-			isa = PBXAggregateTarget;
-			buildConfigurationList = 4024D169113D7D4600C7059E /* Build configuration list for PBXAggregateTarget "Test" */;
-			buildPhases = (
-				4024D161113D7D2400C7059E /* ShellScript */,
-			);
-			dependencies = (
-				4024D166113D7D3100C7059E /* PBXTargetDependency */,
-			);
-			name = Test;
-			productName = TestAndBuild;
-		};
-		4024D1E9113D83FF00C7059E /* TestAndBuild */ = {
-			isa = PBXAggregateTarget;
-			buildConfigurationList = 4024D1F0113D842B00C7059E /* Build configuration list for PBXAggregateTarget "TestAndBuild" */;
-			buildPhases = (
-			);
-			dependencies = (
-				4024D1ED113D840900C7059E /* PBXTargetDependency */,
-				4024D1EF113D840D00C7059E /* PBXTargetDependency */,
-			);
-			name = TestAndBuild;
-			productName = TestAndBuild;
-		};
-/* End PBXAggregateTarget section */
-
-/* Begin PBXBuildFile section */
-		3B7EB1250E5AEE3500C7F239 /* widget.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B7EB1230E5AEE3500C7F239 /* widget.cc */; };
-		3B7EB1260E5AEE3500C7F239 /* widget.h in Headers */ = {isa = PBXBuildFile; fileRef = 3B7EB1240E5AEE3500C7F239 /* widget.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		3B7EB1280E5AEE4600C7F239 /* widget_test.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B7EB1270E5AEE4600C7F239 /* widget_test.cc */; };
-		3B7EB1480E5AF3B400C7F239 /* Widget.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8D07F2C80486CC7A007CD1D0 /* Widget.framework */; };
-		4024D188113D7D7800C7059E /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 4024D185113D7D5500C7059E /* libgtest.a */; };
-		4024D189113D7D7A00C7059E /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 4024D183113D7D5500C7059E /* libgtest_main.a */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXContainerItemProxy section */
-		3B07BDF00E3F3FAE00647869 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
-			remoteInfo = gTestExample;
-		};
-		4024D165113D7D3100C7059E /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 3B07BDE90E3F3F9E00647869;
-			remoteInfo = WidgetFrameworkTest;
-		};
-		4024D1EC113D840900C7059E /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
-			remoteInfo = WidgetFramework;
-		};
-		4024D1EE113D840D00C7059E /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 4024D162113D7D2400C7059E;
-			remoteInfo = Test;
-		};
-/* End PBXContainerItemProxy section */
-
-/* Begin PBXFileReference section */
-		3B07BDEA0E3F3F9E00647869 /* WidgetFrameworkTest */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = WidgetFrameworkTest; sourceTree = BUILT_PRODUCTS_DIR; };
-		3B7EB1230E5AEE3500C7F239 /* widget.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = widget.cc; sourceTree = "<group>"; };
-		3B7EB1240E5AEE3500C7F239 /* widget.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = widget.h; sourceTree = "<group>"; };
-		3B7EB1270E5AEE4600C7F239 /* widget_test.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = widget_test.cc; sourceTree = "<group>"; };
-		4024D183113D7D5500C7059E /* libgtest_main.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libgtest_main.a; path = /usr/local/lib/libgtest_main.a; sourceTree = "<absolute>"; };
-		4024D185113D7D5500C7059E /* libgtest.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libgtest.a; path = /usr/local/lib/libgtest.a; sourceTree = "<absolute>"; };
-		4024D1E2113D838200C7059E /* runtests.sh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.sh; path = runtests.sh; sourceTree = "<group>"; };
-		8D07F2C70486CC7A007CD1D0 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist; path = Info.plist; sourceTree = "<group>"; };
-		8D07F2C80486CC7A007CD1D0 /* Widget.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Widget.framework; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		3B07BDE80E3F3F9E00647869 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				4024D189113D7D7A00C7059E /* libgtest_main.a in Frameworks */,
-				4024D188113D7D7800C7059E /* libgtest.a in Frameworks */,
-				3B7EB1480E5AF3B400C7F239 /* Widget.framework in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		8D07F2C30486CC7A007CD1D0 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		034768DDFF38A45A11DB9C8B /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				8D07F2C80486CC7A007CD1D0 /* Widget.framework */,
-				3B07BDEA0E3F3F9E00647869 /* WidgetFrameworkTest */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		0867D691FE84028FC02AAC07 /* gTestExample */ = {
-			isa = PBXGroup;
-			children = (
-				4024D1E1113D836C00C7059E /* Scripts */,
-				08FB77ACFE841707C02AAC07 /* Source */,
-				089C1665FE841158C02AAC07 /* Resources */,
-				3B07BE350E4094E400647869 /* Test */,
-				0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */,
-				034768DDFF38A45A11DB9C8B /* Products */,
-			);
-			name = gTestExample;
-			sourceTree = "<group>";
-		};
-		0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */ = {
-			isa = PBXGroup;
-			children = (
-				4024D183113D7D5500C7059E /* libgtest_main.a */,
-				4024D185113D7D5500C7059E /* libgtest.a */,
-			);
-			name = "External Frameworks and Libraries";
-			sourceTree = "<group>";
-		};
-		089C1665FE841158C02AAC07 /* Resources */ = {
-			isa = PBXGroup;
-			children = (
-				8D07F2C70486CC7A007CD1D0 /* Info.plist */,
-			);
-			name = Resources;
-			sourceTree = "<group>";
-		};
-		08FB77ACFE841707C02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				3B7EB1230E5AEE3500C7F239 /* widget.cc */,
-				3B7EB1240E5AEE3500C7F239 /* widget.h */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		3B07BE350E4094E400647869 /* Test */ = {
-			isa = PBXGroup;
-			children = (
-				3B7EB1270E5AEE4600C7F239 /* widget_test.cc */,
-			);
-			name = Test;
-			sourceTree = "<group>";
-		};
-		4024D1E1113D836C00C7059E /* Scripts */ = {
-			isa = PBXGroup;
-			children = (
-				4024D1E2113D838200C7059E /* runtests.sh */,
-			);
-			name = Scripts;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		8D07F2BD0486CC7A007CD1D0 /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				3B7EB1260E5AEE3500C7F239 /* widget.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		3B07BDE90E3F3F9E00647869 /* WidgetFrameworkTest */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 3B07BDF40E3F3FB600647869 /* Build configuration list for PBXNativeTarget "WidgetFrameworkTest" */;
-			buildPhases = (
-				3B07BDE70E3F3F9E00647869 /* Sources */,
-				3B07BDE80E3F3F9E00647869 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				3B07BDF10E3F3FAE00647869 /* PBXTargetDependency */,
-			);
-			name = WidgetFrameworkTest;
-			productName = gTestExampleTest;
-			productReference = 3B07BDEA0E3F3F9E00647869 /* WidgetFrameworkTest */;
-			productType = "com.apple.product-type.tool";
-		};
-		8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "WidgetFramework" */;
-			buildPhases = (
-				8D07F2C10486CC7A007CD1D0 /* Sources */,
-				8D07F2C30486CC7A007CD1D0 /* Frameworks */,
-				8D07F2BD0486CC7A007CD1D0 /* Headers */,
-				8D07F2BF0486CC7A007CD1D0 /* Resources */,
-				8D07F2C50486CC7A007CD1D0 /* Rez */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = WidgetFramework;
-			productInstallPath = "$(HOME)/Library/Frameworks";
-			productName = gTestExample;
-			productReference = 8D07F2C80486CC7A007CD1D0 /* Widget.framework */;
-			productType = "com.apple.product-type.framework";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		0867D690FE84028FC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "WidgetFramework" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 0867D691FE84028FC02AAC07 /* gTestExample */;
-			productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */,
-				3B07BDE90E3F3F9E00647869 /* WidgetFrameworkTest */,
-				4024D162113D7D2400C7059E /* Test */,
-				4024D1E9113D83FF00C7059E /* TestAndBuild */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXResourcesBuildPhase section */
-		8D07F2BF0486CC7A007CD1D0 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXRezBuildPhase section */
-		8D07F2C50486CC7A007CD1D0 /* Rez */ = {
-			isa = PBXRezBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXRezBuildPhase section */
-
-/* Begin PBXShellScriptBuildPhase section */
-		4024D161113D7D2400C7059E /* ShellScript */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputPaths = (
-			);
-			outputPaths = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "/bin/bash $SRCROOT/runtests.sh $BUILT_PRODUCTS_DIR/WidgetFrameworkTest\n";
-		};
-/* End PBXShellScriptBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		3B07BDE70E3F3F9E00647869 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				3B7EB1280E5AEE4600C7F239 /* widget_test.cc in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		8D07F2C10486CC7A007CD1D0 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				3B7EB1250E5AEE3500C7F239 /* widget.cc in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXTargetDependency section */
-		3B07BDF10E3F3FAE00647869 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */;
-			targetProxy = 3B07BDF00E3F3FAE00647869 /* PBXContainerItemProxy */;
-		};
-		4024D166113D7D3100C7059E /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 3B07BDE90E3F3F9E00647869 /* WidgetFrameworkTest */;
-			targetProxy = 4024D165113D7D3100C7059E /* PBXContainerItemProxy */;
-		};
-		4024D1ED113D840900C7059E /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 8D07F2BC0486CC7A007CD1D0 /* WidgetFramework */;
-			targetProxy = 4024D1EC113D840900C7059E /* PBXContainerItemProxy */;
-		};
-		4024D1EF113D840D00C7059E /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 4024D162113D7D2400C7059E /* Test */;
-			targetProxy = 4024D1EE113D840D00C7059E /* PBXContainerItemProxy */;
-		};
-/* End PBXTargetDependency section */
-
-/* Begin XCBuildConfiguration section */
-		3B07BDEC0E3F3F9F00647869 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				PRODUCT_NAME = WidgetFrameworkTest;
-			};
-			name = Debug;
-		};
-		3B07BDED0E3F3F9F00647869 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				PRODUCT_NAME = WidgetFrameworkTest;
-			};
-			name = Release;
-		};
-		4024D163113D7D2400C7059E /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				PRODUCT_NAME = TestAndBuild;
-			};
-			name = Debug;
-		};
-		4024D164113D7D2400C7059E /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				PRODUCT_NAME = TestAndBuild;
-			};
-			name = Release;
-		};
-		4024D1EA113D83FF00C7059E /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				PRODUCT_NAME = TestAndBuild;
-			};
-			name = Debug;
-		};
-		4024D1EB113D83FF00C7059E /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				PRODUCT_NAME = TestAndBuild;
-			};
-			name = Release;
-		};
-		4FADC24308B4156D00ABE55E /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				FRAMEWORK_VERSION = A;
-				INFOPLIST_FILE = Info.plist;
-				INSTALL_PATH = "@loader_path/../Frameworks";
-				PRODUCT_NAME = Widget;
-			};
-			name = Debug;
-		};
-		4FADC24408B4156D00ABE55E /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				FRAMEWORK_VERSION = A;
-				INFOPLIST_FILE = Info.plist;
-				INSTALL_PATH = "@loader_path/../Frameworks";
-				PRODUCT_NAME = Widget;
-			};
-			name = Release;
-		};
-		4FADC24708B4156D00ABE55E /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_VERSION = 4.0;
-				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
-			};
-			name = Debug;
-		};
-		4FADC24808B4156D00ABE55E /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_VERSION = 4.0;
-				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		3B07BDF40E3F3FB600647869 /* Build configuration list for PBXNativeTarget "WidgetFrameworkTest" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				3B07BDEC0E3F3F9F00647869 /* Debug */,
-				3B07BDED0E3F3F9F00647869 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		4024D169113D7D4600C7059E /* Build configuration list for PBXAggregateTarget "Test" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4024D163113D7D2400C7059E /* Debug */,
-				4024D164113D7D2400C7059E /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		4024D1F0113D842B00C7059E /* Build configuration list for PBXAggregateTarget "TestAndBuild" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4024D1EA113D83FF00C7059E /* Debug */,
-				4024D1EB113D83FF00C7059E /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "WidgetFramework" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4FADC24308B4156D00ABE55E /* Debug */,
-				4FADC24408B4156D00ABE55E /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "WidgetFramework" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4FADC24708B4156D00ABE55E /* Debug */,
-				4FADC24808B4156D00ABE55E /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 0867D690FE84028FC02AAC07 /* Project object */;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/runtests.sh b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/runtests.sh
deleted file mode 100644
index 4a0d413e..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/runtests.sh
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/bin/bash
-#
-# 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.
-
-# Executes the samples and tests for the Google Test Framework.
-
-# Help the dynamic linker find the path to the libraries.
-export DYLD_FRAMEWORK_PATH=$BUILT_PRODUCTS_DIR
-export DYLD_LIBRARY_PATH=$BUILT_PRODUCTS_DIR
-
-# Create some executables.
-test_executables=$@
-
-# Now execute each one in turn keeping track of how many succeeded and failed.
-succeeded=0
-failed=0
-failed_list=()
-for test in ${test_executables[*]}; do
-  "$test"
-  result=$?
-  if [ $result -eq 0 ]; then
-    succeeded=$(( $succeeded + 1 ))
-  else
-    failed=$(( failed + 1 ))
-    failed_list="$failed_list $test"
-  fi
-done
-
-# Report the successes and failures to the console.
-echo "Tests complete with $succeeded successes and $failed failures."
-if [ $failed -ne 0 ]; then
-  echo "The following tests failed:"
-  echo $failed_list
-fi
-exit $failed
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.cc
deleted file mode 100644
index bfc4e7fc..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.cc
+++ /dev/null
@@ -1,63 +0,0 @@
-// 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.
-//
-// Author: preston.a.jackson@gmail.com (Preston Jackson)
-//
-// Google Test - FrameworkSample
-// widget.cc
-//
-
-// Widget is a very simple class used for demonstrating the use of gtest
-
-#include "widget.h"
-
-Widget::Widget(int number, const std::string& name)
-    : number_(number),
-      name_(name) {}
-
-Widget::~Widget() {}
-
-float Widget::GetFloatValue() const {
-  return number_;
-}
-
-int Widget::GetIntValue() const {
-  return static_cast<int>(number_);
-}
-
-std::string Widget::GetStringValue() const {
-  return name_;
-}
-
-void Widget::GetCharPtrValue(char* buffer, size_t max_size) const {
-  // Copy the char* representation of name_ into buffer, up to max_size.
-  strncpy(buffer, name_.c_str(), max_size-1);
-  buffer[max_size-1] = '\0';
-  return;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.h b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.h
deleted file mode 100644
index 0c55cdc8..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// 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.
-//
-// Author: preston.a.jackson@gmail.com (Preston Jackson)
-//
-// Google Test - FrameworkSample
-// widget.h
-//
-
-// Widget is a very simple class used for demonstrating the use of gtest. It
-// simply stores two values a string and an integer, which are returned via
-// public accessors in multiple forms.
-
-#import <string>
-
-class Widget {
- public:
-  Widget(int number, const std::string& name);
-  ~Widget();
-
-  // Public accessors to number data
-  float GetFloatValue() const;
-  int GetIntValue() const;
-
-  // Public accessors to the string data
-  std::string GetStringValue() const;
-  void GetCharPtrValue(char* buffer, size_t max_size) const;
-
- private:
-  // Data members
-  float number_;
-  std::string name_;
-};
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget_test.cc b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget_test.cc
deleted file mode 100644
index 87259942..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Samples/FrameworkSample/widget_test.cc
+++ /dev/null
@@ -1,68 +0,0 @@
-// 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.
-//
-// Author: preston.a.jackson@gmail.com (Preston Jackson)
-//
-// Google Test - FrameworkSample
-// widget_test.cc
-//
-
-// This is a simple test file for the Widget class in the Widget.framework
-
-#include <string>
-#include "gtest/gtest.h"
-
-#include <Widget/widget.h>
-
-// This test verifies that the constructor sets the internal state of the
-// Widget class correctly.
-TEST(WidgetInitializerTest, TestConstructor) {
-  Widget widget(1.0f, "name");
-  EXPECT_FLOAT_EQ(1.0f, widget.GetFloatValue());
-  EXPECT_EQ(std::string("name"), widget.GetStringValue());
-}
-
-// This test verifies the conversion of the float and string values to int and
-// char*, respectively.
-TEST(WidgetInitializerTest, TestConversion) {
-  Widget widget(1.0f, "name");
-  EXPECT_EQ(1, widget.GetIntValue());
-
-  size_t max_size = 128;
-  char buffer[max_size];
-  widget.GetCharPtrValue(buffer, max_size);
-  EXPECT_STREQ("name", buffer);
-}
-
-// Use the Google Test main that is linked into the framework. It does something
-// like this:
-// int main(int argc, char** argv) {
-//   testing::InitGoogleTest(&argc, argv);
-//   return RUN_ALL_TESTS();
-// }
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/runtests.sh b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/runtests.sh
deleted file mode 100644
index 3fc229f1..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/runtests.sh
+++ /dev/null
@@ -1,65 +0,0 @@
-#!/bin/bash
-#
-# 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.
-
-# Executes the samples and tests for the Google Test Framework.
-
-# Help the dynamic linker find the path to the libraries.
-export DYLD_FRAMEWORK_PATH=$BUILT_PRODUCTS_DIR
-export DYLD_LIBRARY_PATH=$BUILT_PRODUCTS_DIR
-
-# Create some executables.
-test_executables=("$BUILT_PRODUCTS_DIR/gtest_unittest-framework"
-                  "$BUILT_PRODUCTS_DIR/gtest_unittest"
-                  "$BUILT_PRODUCTS_DIR/sample1_unittest-framework"
-                  "$BUILT_PRODUCTS_DIR/sample1_unittest-static")
-
-# Now execute each one in turn keeping track of how many succeeded and failed. 
-succeeded=0
-failed=0
-failed_list=()
-for test in ${test_executables[*]}; do
-  "$test"
-  result=$?
-  if [ $result -eq 0 ]; then
-    succeeded=$(( $succeeded + 1 ))
-  else
-    failed=$(( failed + 1 ))
-    failed_list="$failed_list $test"
-  fi
-done
-
-# Report the successes and failures to the console.
-echo "Tests complete with $succeeded successes and $failed failures."
-if [ $failed -ne 0 ]; then
-  echo "The following tests failed:"
-  echo $failed_list
-fi
-exit $failed
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/versiongenerate.py b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/versiongenerate.py
deleted file mode 100755
index 81de8c96..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/Scripts/versiongenerate.py
+++ /dev/null
@@ -1,100 +0,0 @@
-#!/usr/bin/env python
-#
-# 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.
-
-"""A script to prepare version informtion for use the gtest Info.plist file.
-
-  This script extracts the version information from the configure.ac file and
-  uses it to generate a header file containing the same information. The
-  #defines in this header file will be included in during the generation of
-  the Info.plist of the framework, giving the correct value to the version
-  shown in the Finder.
-
-  This script makes the following assumptions (these are faults of the script,
-  not problems with the Autoconf):
-    1. The AC_INIT macro will be contained within the first 1024 characters
-       of configure.ac
-    2. The version string will be 3 integers separated by periods and will be
-       surrounded by squre brackets, "[" and "]" (e.g. [1.0.1]). The first
-       segment represents the major version, the second represents the minor
-       version and the third represents the fix version.
-    3. No ")" character exists between the opening "(" and closing ")" of
-       AC_INIT, including in comments and character strings.
-"""
-
-import sys
-import re
-
-# Read the command line argument (the output directory for Version.h)
-if (len(sys.argv) < 3):
-  print "Usage: versiongenerate.py input_dir output_dir"
-  sys.exit(1)
-else:
-  input_dir = sys.argv[1]
-  output_dir = sys.argv[2]
-
-# Read the first 1024 characters of the configure.ac file
-config_file = open("%s/configure.ac" % input_dir, 'r')
-buffer_size = 1024
-opening_string = config_file.read(buffer_size)
-config_file.close()
-
-# Extract the version string from the AC_INIT macro
-#   The following init_expression means:
-#     Extract three integers separated by periods and surrounded by squre
-#     brackets(e.g. "[1.0.1]") between "AC_INIT(" and ")". Do not be greedy
-#     (*? is the non-greedy flag) since that would pull in everything between
-#     the first "(" and the last ")" in the file.
-version_expression = re.compile(r"AC_INIT\(.*?\[(\d+)\.(\d+)\.(\d+)\].*?\)",
-                                re.DOTALL)
-version_values = version_expression.search(opening_string)
-major_version = version_values.group(1)
-minor_version = version_values.group(2)
-fix_version = version_values.group(3)
-
-# Write the version information to a header file to be included in the
-# Info.plist file.
-file_data = """//
-// DO NOT MODIFY THIS FILE (but you can delete it)
-//
-// This file is autogenerated by the versiongenerate.py script. This script
-// is executed in a "Run Script" build phase when creating gtest.framework. This
-// header file is not used during compilation of C-source. Rather, it simply
-// defines some version strings for substitution in the Info.plist. Because of
-// this, we are not not restricted to C-syntax nor are we using include guards.
-//
-
-#define GTEST_VERSIONINFO_SHORT %s.%s
-#define GTEST_VERSIONINFO_LONG %s.%s.%s
-
-""" % (major_version, minor_version, major_version, minor_version, fix_version)
-version_file = open("%s/Version.h" % output_dir, 'w')
-version_file.write(file_data)
-version_file.close()
diff --git a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/gtest.xcodeproj/project.pbxproj b/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/gtest.xcodeproj/project.pbxproj
deleted file mode 100644
index aefaa88b..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/googletest/xcode/gtest.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,1135 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 46;
-	objects = {
-
-/* Begin PBXAggregateTarget section */
-		3B238F5F0E828B5400846E11 /* Check */ = {
-			isa = PBXAggregateTarget;
-			buildConfigurationList = 3B238FA30E828BB600846E11 /* Build configuration list for PBXAggregateTarget "Check" */;
-			buildPhases = (
-				3B238F5E0E828B5400846E11 /* ShellScript */,
-			);
-			dependencies = (
-				40899F9D0FFA740F000B29AE /* PBXTargetDependency */,
-				40C849F7101A43440083642A /* PBXTargetDependency */,
-				4089A0980FFAD34A000B29AE /* PBXTargetDependency */,
-				40C849F9101A43490083642A /* PBXTargetDependency */,
-			);
-			name = Check;
-			productName = Check;
-		};
-		40C44ADC0E3798F4008FCC51 /* Version Info */ = {
-			isa = PBXAggregateTarget;
-			buildConfigurationList = 40C44AE40E379905008FCC51 /* Build configuration list for PBXAggregateTarget "Version Info" */;
-			buildPhases = (
-				40C44ADB0E3798F4008FCC51 /* Generate Version.h */,
-			);
-			comments = "The generation of Version.h must be performed in its own target. Since the Info.plist is preprocessed before any of the other build phases in gtest, the Version.h file would not be ready if included as a build phase of that target.";
-			dependencies = (
-			);
-			name = "Version Info";
-			productName = Version.h;
-		};
-/* End PBXAggregateTarget section */
-
-/* Begin PBXBuildFile section */
-		224A12A30E9EADCC00BD17FD /* gtest-test-part.h in Headers */ = {isa = PBXBuildFile; fileRef = 224A12A20E9EADCC00BD17FD /* gtest-test-part.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		3BF6F2A00E79B5AD000F2EEE /* gtest-type-util.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */; };
-		3BF6F2A50E79B616000F2EEE /* gtest-typed-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		404884380E2F799B00CF7658 /* gtest-death-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DB0E2F799B00CF7658 /* gtest-death-test.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		404884390E2F799B00CF7658 /* gtest-message.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DC0E2F799B00CF7658 /* gtest-message.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		4048843A0E2F799B00CF7658 /* gtest-spi.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DD0E2F799B00CF7658 /* gtest-spi.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		4048843B0E2F799B00CF7658 /* gtest.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DE0E2F799B00CF7658 /* gtest.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		4048843C0E2F799B00CF7658 /* gtest_pred_impl.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		4048843D0E2F799B00CF7658 /* gtest_prod.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883E00E2F799B00CF7658 /* gtest_prod.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		404884500E2F799B00CF7658 /* README.md in Resources */ = {isa = PBXBuildFile; fileRef = 404883F60E2F799B00CF7658 /* README.md */; };
-		404884A00E2F7BE600CF7658 /* gtest-death-test-internal.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */; };
-		404884A10E2F7BE600CF7658 /* gtest-filepath.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E30E2F799B00CF7658 /* gtest-filepath.h */; };
-		404884A20E2F7BE600CF7658 /* gtest-internal.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E40E2F799B00CF7658 /* gtest-internal.h */; };
-		404884A30E2F7BE600CF7658 /* gtest-port.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E50E2F799B00CF7658 /* gtest-port.h */; };
-		404884A40E2F7BE600CF7658 /* gtest-string.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E60E2F799B00CF7658 /* gtest-string.h */; };
-		404884AC0E2F7CD900CF7658 /* CHANGES in Resources */ = {isa = PBXBuildFile; fileRef = 404884A90E2F7CD900CF7658 /* CHANGES */; };
-		404884AD0E2F7CD900CF7658 /* CONTRIBUTORS in Resources */ = {isa = PBXBuildFile; fileRef = 404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */; };
-		404884AE0E2F7CD900CF7658 /* LICENSE in Resources */ = {isa = PBXBuildFile; fileRef = 404884AB0E2F7CD900CF7658 /* LICENSE */; };
-		40899F3A0FFA70D4000B29AE /* gtest-all.cc in Sources */ = {isa = PBXBuildFile; fileRef = 224A12A10E9EADA700BD17FD /* gtest-all.cc */; };
-		40899F500FFA7281000B29AE /* gtest-tuple.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 40899F4D0FFA7271000B29AE /* gtest-tuple.h */; };
-		40899F530FFA72A0000B29AE /* gtest_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B238C120E7FE13C00846E11 /* gtest_unittest.cc */; };
-		4089A0440FFAD1BE000B29AE /* sample1.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02C0FFACF7F000B29AE /* sample1.cc */; };
-		4089A0460FFAD1BE000B29AE /* sample1_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */; };
-		40C848FF101A21150083642A /* gtest-all.cc in Sources */ = {isa = PBXBuildFile; fileRef = 224A12A10E9EADA700BD17FD /* gtest-all.cc */; };
-		40C84915101A21DF0083642A /* gtest_main.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4048840D0E2F799B00CF7658 /* gtest_main.cc */; };
-		40C84916101A235B0083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
-		40C84921101A23AD0083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
-		40C84978101A36540083642A /* libgtest_main.a in Resources */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
-		40C84980101A36850083642A /* gtest_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B238C120E7FE13C00846E11 /* gtest_unittest.cc */; };
-		40C84982101A36850083642A /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C848FA101A209C0083642A /* libgtest.a */; };
-		40C84983101A36850083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
-		40C8498F101A36A60083642A /* sample1.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02C0FFACF7F000B29AE /* sample1.cc */; };
-		40C84990101A36A60083642A /* sample1_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */; };
-		40C84992101A36A60083642A /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C848FA101A209C0083642A /* libgtest.a */; };
-		40C84993101A36A60083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
-		40C849A2101A37050083642A /* gtest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4539C8FF0EC27F6400A70F4C /* gtest.framework */; };
-		40C849A4101A37150083642A /* gtest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4539C8FF0EC27F6400A70F4C /* gtest.framework */; };
-		4539C9340EC280AE00A70F4C /* gtest-param-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 4539C9330EC280AE00A70F4C /* gtest-param-test.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		4539C9380EC280E200A70F4C /* gtest-linked_ptr.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */; };
-		4539C9390EC280E200A70F4C /* gtest-param-util-generated.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */; };
-		4539C93A0EC280E200A70F4C /* gtest-param-util.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9370EC280E200A70F4C /* gtest-param-util.h */; };
-		4567C8181264FF71007740BE /* gtest-printers.h in Headers */ = {isa = PBXBuildFile; fileRef = 4567C8171264FF71007740BE /* gtest-printers.h */; settings = {ATTRIBUTES = (Public, ); }; };
-/* End PBXBuildFile section */
-
-/* Begin PBXContainerItemProxy section */
-		40899F9C0FFA740F000B29AE /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 40899F420FFA7184000B29AE;
-			remoteInfo = gtest_unittest;
-		};
-		4089A0970FFAD34A000B29AE /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 4089A0120FFACEFC000B29AE;
-			remoteInfo = sample1_unittest;
-		};
-		408BEC0F1046CFE900DEF522 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 40C848F9101A209C0083642A;
-			remoteInfo = "gtest-static";
-		};
-		40C44AE50E379922008FCC51 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 40C44ADC0E3798F4008FCC51;
-			remoteInfo = Version.h;
-		};
-		40C8497C101A36850083642A /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 40C848F9101A209C0083642A;
-			remoteInfo = "gtest-static";
-		};
-		40C8497E101A36850083642A /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 40C8490A101A217E0083642A;
-			remoteInfo = "gtest_main-static";
-		};
-		40C8498B101A36A60083642A /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 40C848F9101A209C0083642A;
-			remoteInfo = "gtest-static";
-		};
-		40C8498D101A36A60083642A /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 40C8490A101A217E0083642A;
-			remoteInfo = "gtest_main-static";
-		};
-		40C8499B101A36DC0083642A /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 40C8490A101A217E0083642A;
-			remoteInfo = "gtest_main-static";
-		};
-		40C8499D101A36E50083642A /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
-			remoteInfo = "gtest-framework";
-		};
-		40C8499F101A36F10083642A /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
-			remoteInfo = "gtest-framework";
-		};
-		40C849F6101A43440083642A /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 40C8497A101A36850083642A;
-			remoteInfo = "gtest_unittest-static";
-		};
-		40C849F8101A43490083642A /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 40C84989101A36A60083642A;
-			remoteInfo = "sample1_unittest-static";
-		};
-/* End PBXContainerItemProxy section */
-
-/* Begin PBXCopyFilesBuildPhase section */
-		404884A50E2F7C0400CF7658 /* Copy Headers Internal */ = {
-			isa = PBXCopyFilesBuildPhase;
-			buildActionMask = 2147483647;
-			dstPath = Headers/internal;
-			dstSubfolderSpec = 6;
-			files = (
-				404884A00E2F7BE600CF7658 /* gtest-death-test-internal.h in Copy Headers Internal */,
-				404884A10E2F7BE600CF7658 /* gtest-filepath.h in Copy Headers Internal */,
-				404884A20E2F7BE600CF7658 /* gtest-internal.h in Copy Headers Internal */,
-				4539C9380EC280E200A70F4C /* gtest-linked_ptr.h in Copy Headers Internal */,
-				4539C9390EC280E200A70F4C /* gtest-param-util-generated.h in Copy Headers Internal */,
-				4539C93A0EC280E200A70F4C /* gtest-param-util.h in Copy Headers Internal */,
-				404884A30E2F7BE600CF7658 /* gtest-port.h in Copy Headers Internal */,
-				404884A40E2F7BE600CF7658 /* gtest-string.h in Copy Headers Internal */,
-				40899F500FFA7281000B29AE /* gtest-tuple.h in Copy Headers Internal */,
-				3BF6F2A00E79B5AD000F2EEE /* gtest-type-util.h in Copy Headers Internal */,
-			);
-			name = "Copy Headers Internal";
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXCopyFilesBuildPhase section */
-
-/* Begin PBXFileReference section */
-		224A12A10E9EADA700BD17FD /* gtest-all.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = "gtest-all.cc"; sourceTree = "<group>"; };
-		224A12A20E9EADCC00BD17FD /* gtest-test-part.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = "gtest-test-part.h"; sourceTree = "<group>"; };
-		3B238C120E7FE13C00846E11 /* gtest_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gtest_unittest.cc; sourceTree = "<group>"; };
-		3B87D2100E96B92E000D1852 /* runtests.sh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.sh; path = runtests.sh; sourceTree = "<group>"; };
-		3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-type-util.h"; sourceTree = "<group>"; };
-		3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-typed-test.h"; sourceTree = "<group>"; };
-		403EE37C0E377822004BD1E2 /* versiongenerate.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = versiongenerate.py; sourceTree = "<group>"; };
-		404883DB0E2F799B00CF7658 /* gtest-death-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-death-test.h"; sourceTree = "<group>"; };
-		404883DC0E2F799B00CF7658 /* gtest-message.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-message.h"; sourceTree = "<group>"; };
-		404883DD0E2F799B00CF7658 /* gtest-spi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-spi.h"; sourceTree = "<group>"; };
-		404883DE0E2F799B00CF7658 /* gtest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest.h; sourceTree = "<group>"; };
-		404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest_pred_impl.h; sourceTree = "<group>"; };
-		404883E00E2F799B00CF7658 /* gtest_prod.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest_prod.h; sourceTree = "<group>"; };
-		404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-death-test-internal.h"; sourceTree = "<group>"; };
-		404883E30E2F799B00CF7658 /* gtest-filepath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-filepath.h"; sourceTree = "<group>"; };
-		404883E40E2F799B00CF7658 /* gtest-internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-internal.h"; sourceTree = "<group>"; };
-		404883E50E2F799B00CF7658 /* gtest-port.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-port.h"; sourceTree = "<group>"; };
-		404883E60E2F799B00CF7658 /* gtest-string.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-string.h"; sourceTree = "<group>"; };
-		404883F60E2F799B00CF7658 /* README.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = README.md; path = ../README.md; sourceTree = SOURCE_ROOT; };
-		4048840D0E2F799B00CF7658 /* gtest_main.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gtest_main.cc; sourceTree = "<group>"; };
-		404884A90E2F7CD900CF7658 /* CHANGES */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CHANGES; path = ../CHANGES; sourceTree = SOURCE_ROOT; };
-		404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CONTRIBUTORS; path = ../CONTRIBUTORS; sourceTree = SOURCE_ROOT; };
-		404884AB0E2F7CD900CF7658 /* LICENSE */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = LICENSE; path = ../LICENSE; sourceTree = SOURCE_ROOT; };
-		40899F430FFA7184000B29AE /* gtest_unittest-framework */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "gtest_unittest-framework"; sourceTree = BUILT_PRODUCTS_DIR; };
-		40899F4D0FFA7271000B29AE /* gtest-tuple.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-tuple.h"; sourceTree = "<group>"; };
-		40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = StaticLibraryTarget.xcconfig; sourceTree = "<group>"; };
-		4089A0130FFACEFC000B29AE /* sample1_unittest-framework */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "sample1_unittest-framework"; sourceTree = BUILT_PRODUCTS_DIR; };
-		4089A02C0FFACF7F000B29AE /* sample1.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sample1.cc; sourceTree = "<group>"; };
-		4089A02D0FFACF7F000B29AE /* sample1.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sample1.h; sourceTree = "<group>"; };
-		4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sample1_unittest.cc; sourceTree = "<group>"; };
-		40C848FA101A209C0083642A /* libgtest.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgtest.a; sourceTree = BUILT_PRODUCTS_DIR; };
-		40C8490B101A217E0083642A /* libgtest_main.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgtest_main.a; sourceTree = BUILT_PRODUCTS_DIR; };
-		40C84987101A36850083642A /* gtest_unittest */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = gtest_unittest; sourceTree = BUILT_PRODUCTS_DIR; };
-		40C84997101A36A60083642A /* sample1_unittest-static */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "sample1_unittest-static"; sourceTree = BUILT_PRODUCTS_DIR; };
-		40D4CDF10E30E07400294801 /* DebugProject.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = DebugProject.xcconfig; sourceTree = "<group>"; };
-		40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = FrameworkTarget.xcconfig; sourceTree = "<group>"; };
-		40D4CDF30E30E07400294801 /* General.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = General.xcconfig; sourceTree = "<group>"; };
-		40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = ReleaseProject.xcconfig; sourceTree = "<group>"; };
-		40D4CF510E30F5E200294801 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		4539C8FF0EC27F6400A70F4C /* gtest.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = gtest.framework; sourceTree = BUILT_PRODUCTS_DIR; };
-		4539C9330EC280AE00A70F4C /* gtest-param-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-test.h"; sourceTree = "<group>"; };
-		4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-linked_ptr.h"; sourceTree = "<group>"; };
-		4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-util-generated.h"; sourceTree = "<group>"; };
-		4539C9370EC280E200A70F4C /* gtest-param-util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-util.h"; sourceTree = "<group>"; };
-		4567C8171264FF71007740BE /* gtest-printers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-printers.h"; sourceTree = "<group>"; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		40899F410FFA7184000B29AE /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				40C849A4101A37150083642A /* gtest.framework in Frameworks */,
-				40C84916101A235B0083642A /* libgtest_main.a in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		4089A0110FFACEFC000B29AE /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				40C849A2101A37050083642A /* gtest.framework in Frameworks */,
-				40C84921101A23AD0083642A /* libgtest_main.a in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		40C84981101A36850083642A /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				40C84982101A36850083642A /* libgtest.a in Frameworks */,
-				40C84983101A36850083642A /* libgtest_main.a in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		40C84991101A36A60083642A /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				40C84992101A36A60083642A /* libgtest.a in Frameworks */,
-				40C84993101A36A60083642A /* libgtest_main.a in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		034768DDFF38A45A11DB9C8B /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				4539C8FF0EC27F6400A70F4C /* gtest.framework */,
-				40C848FA101A209C0083642A /* libgtest.a */,
-				40C8490B101A217E0083642A /* libgtest_main.a */,
-				40899F430FFA7184000B29AE /* gtest_unittest-framework */,
-				40C84987101A36850083642A /* gtest_unittest */,
-				4089A0130FFACEFC000B29AE /* sample1_unittest-framework */,
-				40C84997101A36A60083642A /* sample1_unittest-static */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		0867D691FE84028FC02AAC07 /* gtest */ = {
-			isa = PBXGroup;
-			children = (
-				40D4CDF00E30E07400294801 /* Config */,
-				08FB77ACFE841707C02AAC07 /* Source */,
-				40D4CF4E0E30F5E200294801 /* Resources */,
-				403EE37B0E377822004BD1E2 /* Scripts */,
-				034768DDFF38A45A11DB9C8B /* Products */,
-			);
-			name = gtest;
-			sourceTree = "<group>";
-		};
-		08FB77ACFE841707C02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				404884A90E2F7CD900CF7658 /* CHANGES */,
-				404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */,
-				404884AB0E2F7CD900CF7658 /* LICENSE */,
-				404883F60E2F799B00CF7658 /* README.md */,
-				404883D90E2F799B00CF7658 /* include */,
-				4089A02F0FFACF84000B29AE /* samples */,
-				404884070E2F799B00CF7658 /* src */,
-				3B238BF00E7FE13B00846E11 /* test */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		3B238BF00E7FE13B00846E11 /* test */ = {
-			isa = PBXGroup;
-			children = (
-				3B238C120E7FE13C00846E11 /* gtest_unittest.cc */,
-			);
-			name = test;
-			path = ../test;
-			sourceTree = SOURCE_ROOT;
-		};
-		403EE37B0E377822004BD1E2 /* Scripts */ = {
-			isa = PBXGroup;
-			children = (
-				403EE37C0E377822004BD1E2 /* versiongenerate.py */,
-				3B87D2100E96B92E000D1852 /* runtests.sh */,
-			);
-			path = Scripts;
-			sourceTree = "<group>";
-		};
-		404883D90E2F799B00CF7658 /* include */ = {
-			isa = PBXGroup;
-			children = (
-				404883DA0E2F799B00CF7658 /* gtest */,
-			);
-			name = include;
-			path = ../include;
-			sourceTree = SOURCE_ROOT;
-		};
-		404883DA0E2F799B00CF7658 /* gtest */ = {
-			isa = PBXGroup;
-			children = (
-				404883E10E2F799B00CF7658 /* internal */,
-				224A12A20E9EADCC00BD17FD /* gtest-test-part.h */,
-				404883DB0E2F799B00CF7658 /* gtest-death-test.h */,
-				404883DC0E2F799B00CF7658 /* gtest-message.h */,
-				4539C9330EC280AE00A70F4C /* gtest-param-test.h */,
-				4567C8171264FF71007740BE /* gtest-printers.h */,
-				404883DD0E2F799B00CF7658 /* gtest-spi.h */,
-				404883DE0E2F799B00CF7658 /* gtest.h */,
-				404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */,
-				404883E00E2F799B00CF7658 /* gtest_prod.h */,
-				3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */,
-			);
-			path = gtest;
-			sourceTree = "<group>";
-		};
-		404883E10E2F799B00CF7658 /* internal */ = {
-			isa = PBXGroup;
-			children = (
-				404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */,
-				404883E30E2F799B00CF7658 /* gtest-filepath.h */,
-				404883E40E2F799B00CF7658 /* gtest-internal.h */,
-				4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */,
-				4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */,
-				4539C9370EC280E200A70F4C /* gtest-param-util.h */,
-				404883E50E2F799B00CF7658 /* gtest-port.h */,
-				404883E60E2F799B00CF7658 /* gtest-string.h */,
-				40899F4D0FFA7271000B29AE /* gtest-tuple.h */,
-				3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */,
-			);
-			path = internal;
-			sourceTree = "<group>";
-		};
-		404884070E2F799B00CF7658 /* src */ = {
-			isa = PBXGroup;
-			children = (
-				224A12A10E9EADA700BD17FD /* gtest-all.cc */,
-				4048840D0E2F799B00CF7658 /* gtest_main.cc */,
-			);
-			name = src;
-			path = ../src;
-			sourceTree = SOURCE_ROOT;
-		};
-		4089A02F0FFACF84000B29AE /* samples */ = {
-			isa = PBXGroup;
-			children = (
-				4089A02C0FFACF7F000B29AE /* sample1.cc */,
-				4089A02D0FFACF7F000B29AE /* sample1.h */,
-				4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */,
-			);
-			name = samples;
-			path = ../samples;
-			sourceTree = SOURCE_ROOT;
-		};
-		40D4CDF00E30E07400294801 /* Config */ = {
-			isa = PBXGroup;
-			children = (
-				40D4CDF10E30E07400294801 /* DebugProject.xcconfig */,
-				40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */,
-				40D4CDF30E30E07400294801 /* General.xcconfig */,
-				40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */,
-				40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */,
-			);
-			path = Config;
-			sourceTree = "<group>";
-		};
-		40D4CF4E0E30F5E200294801 /* Resources */ = {
-			isa = PBXGroup;
-			children = (
-				40D4CF510E30F5E200294801 /* Info.plist */,
-			);
-			path = Resources;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		8D07F2BD0486CC7A007CD1D0 /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				404884380E2F799B00CF7658 /* gtest-death-test.h in Headers */,
-				404884390E2F799B00CF7658 /* gtest-message.h in Headers */,
-				4539C9340EC280AE00A70F4C /* gtest-param-test.h in Headers */,
-				4567C8181264FF71007740BE /* gtest-printers.h in Headers */,
-				3BF6F2A50E79B616000F2EEE /* gtest-typed-test.h in Headers */,
-				4048843A0E2F799B00CF7658 /* gtest-spi.h in Headers */,
-				4048843B0E2F799B00CF7658 /* gtest.h in Headers */,
-				4048843C0E2F799B00CF7658 /* gtest_pred_impl.h in Headers */,
-				4048843D0E2F799B00CF7658 /* gtest_prod.h in Headers */,
-				224A12A30E9EADCC00BD17FD /* gtest-test-part.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		40899F420FFA7184000B29AE /* gtest_unittest-framework */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 40899F4A0FFA71BC000B29AE /* Build configuration list for PBXNativeTarget "gtest_unittest-framework" */;
-			buildPhases = (
-				40899F400FFA7184000B29AE /* Sources */,
-				40899F410FFA7184000B29AE /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				40C849A0101A36F10083642A /* PBXTargetDependency */,
-			);
-			name = "gtest_unittest-framework";
-			productName = gtest_unittest;
-			productReference = 40899F430FFA7184000B29AE /* gtest_unittest-framework */;
-			productType = "com.apple.product-type.tool";
-		};
-		4089A0120FFACEFC000B29AE /* sample1_unittest-framework */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 4089A0240FFACF01000B29AE /* Build configuration list for PBXNativeTarget "sample1_unittest-framework" */;
-			buildPhases = (
-				4089A0100FFACEFC000B29AE /* Sources */,
-				4089A0110FFACEFC000B29AE /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				40C8499E101A36E50083642A /* PBXTargetDependency */,
-			);
-			name = "sample1_unittest-framework";
-			productName = sample1_unittest;
-			productReference = 4089A0130FFACEFC000B29AE /* sample1_unittest-framework */;
-			productType = "com.apple.product-type.tool";
-		};
-		40C848F9101A209C0083642A /* gtest-static */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 40C84902101A212E0083642A /* Build configuration list for PBXNativeTarget "gtest-static" */;
-			buildPhases = (
-				40C848F7101A209C0083642A /* Sources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = "gtest-static";
-			productName = "gtest-static";
-			productReference = 40C848FA101A209C0083642A /* libgtest.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-		40C8490A101A217E0083642A /* gtest_main-static */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 40C84912101A21D20083642A /* Build configuration list for PBXNativeTarget "gtest_main-static" */;
-			buildPhases = (
-				40C84908101A217E0083642A /* Sources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = "gtest_main-static";
-			productName = "gtest_main-static";
-			productReference = 40C8490B101A217E0083642A /* libgtest_main.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-		40C8497A101A36850083642A /* gtest_unittest-static */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 40C84984101A36850083642A /* Build configuration list for PBXNativeTarget "gtest_unittest-static" */;
-			buildPhases = (
-				40C8497F101A36850083642A /* Sources */,
-				40C84981101A36850083642A /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				40C8497B101A36850083642A /* PBXTargetDependency */,
-				40C8497D101A36850083642A /* PBXTargetDependency */,
-			);
-			name = "gtest_unittest-static";
-			productName = gtest_unittest;
-			productReference = 40C84987101A36850083642A /* gtest_unittest */;
-			productType = "com.apple.product-type.tool";
-		};
-		40C84989101A36A60083642A /* sample1_unittest-static */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 40C84994101A36A60083642A /* Build configuration list for PBXNativeTarget "sample1_unittest-static" */;
-			buildPhases = (
-				40C8498E101A36A60083642A /* Sources */,
-				40C84991101A36A60083642A /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				40C8498A101A36A60083642A /* PBXTargetDependency */,
-				40C8498C101A36A60083642A /* PBXTargetDependency */,
-			);
-			name = "sample1_unittest-static";
-			productName = sample1_unittest;
-			productReference = 40C84997101A36A60083642A /* sample1_unittest-static */;
-			productType = "com.apple.product-type.tool";
-		};
-		8D07F2BC0486CC7A007CD1D0 /* gtest-framework */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "gtest-framework" */;
-			buildPhases = (
-				8D07F2C10486CC7A007CD1D0 /* Sources */,
-				8D07F2BD0486CC7A007CD1D0 /* Headers */,
-				404884A50E2F7C0400CF7658 /* Copy Headers Internal */,
-				8D07F2BF0486CC7A007CD1D0 /* Resources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				40C44AE60E379922008FCC51 /* PBXTargetDependency */,
-				408BEC101046CFE900DEF522 /* PBXTargetDependency */,
-				40C8499C101A36DC0083642A /* PBXTargetDependency */,
-			);
-			name = "gtest-framework";
-			productInstallPath = "$(HOME)/Library/Frameworks";
-			productName = gtest;
-			productReference = 4539C8FF0EC27F6400A70F4C /* gtest.framework */;
-			productType = "com.apple.product-type.framework";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		0867D690FE84028FC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			attributes = {
-				LastUpgradeCheck = 0460;
-			};
-			buildConfigurationList = 4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "gtest" */;
-			compatibilityVersion = "Xcode 3.2";
-			developmentRegion = English;
-			hasScannedForEncodings = 1;
-			knownRegions = (
-				English,
-				Japanese,
-				French,
-				German,
-				en,
-			);
-			mainGroup = 0867D691FE84028FC02AAC07 /* gtest */;
-			productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				8D07F2BC0486CC7A007CD1D0 /* gtest-framework */,
-				40C848F9101A209C0083642A /* gtest-static */,
-				40C8490A101A217E0083642A /* gtest_main-static */,
-				40899F420FFA7184000B29AE /* gtest_unittest-framework */,
-				40C8497A101A36850083642A /* gtest_unittest-static */,
-				4089A0120FFACEFC000B29AE /* sample1_unittest-framework */,
-				40C84989101A36A60083642A /* sample1_unittest-static */,
-				3B238F5F0E828B5400846E11 /* Check */,
-				40C44ADC0E3798F4008FCC51 /* Version Info */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXResourcesBuildPhase section */
-		8D07F2BF0486CC7A007CD1D0 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				404884500E2F799B00CF7658 /* README.md in Resources */,
-				404884AC0E2F7CD900CF7658 /* CHANGES in Resources */,
-				404884AD0E2F7CD900CF7658 /* CONTRIBUTORS in Resources */,
-				404884AE0E2F7CD900CF7658 /* LICENSE in Resources */,
-				40C84978101A36540083642A /* libgtest_main.a in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXShellScriptBuildPhase section */
-		3B238F5E0E828B5400846E11 /* ShellScript */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputPaths = (
-			);
-			outputPaths = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "# Remember, this \"Run Script\" build phase will be executed from $SRCROOT\n/bin/bash Scripts/runtests.sh";
-		};
-		40C44ADB0E3798F4008FCC51 /* Generate Version.h */ = {
-			isa = PBXShellScriptBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			inputPaths = (
-				"$(SRCROOT)/Scripts/versiongenerate.py",
-				"$(SRCROOT)/../configure.ac",
-			);
-			name = "Generate Version.h";
-			outputPaths = (
-				"$(PROJECT_TEMP_DIR)/Version.h",
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-			shellPath = /bin/sh;
-			shellScript = "# Remember, this \"Run Script\" build phase will be executed from $SRCROOT\n/usr/bin/python Scripts/versiongenerate.py ../ $PROJECT_TEMP_DIR";
-		};
-/* End PBXShellScriptBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		40899F400FFA7184000B29AE /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				40899F530FFA72A0000B29AE /* gtest_unittest.cc in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		4089A0100FFACEFC000B29AE /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				4089A0440FFAD1BE000B29AE /* sample1.cc in Sources */,
-				4089A0460FFAD1BE000B29AE /* sample1_unittest.cc in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		40C848F7101A209C0083642A /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				40C848FF101A21150083642A /* gtest-all.cc in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		40C84908101A217E0083642A /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				40C84915101A21DF0083642A /* gtest_main.cc in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		40C8497F101A36850083642A /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				40C84980101A36850083642A /* gtest_unittest.cc in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		40C8498E101A36A60083642A /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				40C8498F101A36A60083642A /* sample1.cc in Sources */,
-				40C84990101A36A60083642A /* sample1_unittest.cc in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		8D07F2C10486CC7A007CD1D0 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				40899F3A0FFA70D4000B29AE /* gtest-all.cc in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXTargetDependency section */
-		40899F9D0FFA740F000B29AE /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 40899F420FFA7184000B29AE /* gtest_unittest-framework */;
-			targetProxy = 40899F9C0FFA740F000B29AE /* PBXContainerItemProxy */;
-		};
-		4089A0980FFAD34A000B29AE /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 4089A0120FFACEFC000B29AE /* sample1_unittest-framework */;
-			targetProxy = 4089A0970FFAD34A000B29AE /* PBXContainerItemProxy */;
-		};
-		408BEC101046CFE900DEF522 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 40C848F9101A209C0083642A /* gtest-static */;
-			targetProxy = 408BEC0F1046CFE900DEF522 /* PBXContainerItemProxy */;
-		};
-		40C44AE60E379922008FCC51 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 40C44ADC0E3798F4008FCC51 /* Version Info */;
-			targetProxy = 40C44AE50E379922008FCC51 /* PBXContainerItemProxy */;
-		};
-		40C8497B101A36850083642A /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 40C848F9101A209C0083642A /* gtest-static */;
-			targetProxy = 40C8497C101A36850083642A /* PBXContainerItemProxy */;
-		};
-		40C8497D101A36850083642A /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 40C8490A101A217E0083642A /* gtest_main-static */;
-			targetProxy = 40C8497E101A36850083642A /* PBXContainerItemProxy */;
-		};
-		40C8498A101A36A60083642A /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 40C848F9101A209C0083642A /* gtest-static */;
-			targetProxy = 40C8498B101A36A60083642A /* PBXContainerItemProxy */;
-		};
-		40C8498C101A36A60083642A /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 40C8490A101A217E0083642A /* gtest_main-static */;
-			targetProxy = 40C8498D101A36A60083642A /* PBXContainerItemProxy */;
-		};
-		40C8499C101A36DC0083642A /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 40C8490A101A217E0083642A /* gtest_main-static */;
-			targetProxy = 40C8499B101A36DC0083642A /* PBXContainerItemProxy */;
-		};
-		40C8499E101A36E50083642A /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 8D07F2BC0486CC7A007CD1D0 /* gtest-framework */;
-			targetProxy = 40C8499D101A36E50083642A /* PBXContainerItemProxy */;
-		};
-		40C849A0101A36F10083642A /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 8D07F2BC0486CC7A007CD1D0 /* gtest-framework */;
-			targetProxy = 40C8499F101A36F10083642A /* PBXContainerItemProxy */;
-		};
-		40C849F7101A43440083642A /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 40C8497A101A36850083642A /* gtest_unittest-static */;
-			targetProxy = 40C849F6101A43440083642A /* PBXContainerItemProxy */;
-		};
-		40C849F9101A43490083642A /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 40C84989101A36A60083642A /* sample1_unittest-static */;
-			targetProxy = 40C849F8101A43490083642A /* PBXContainerItemProxy */;
-		};
-/* End PBXTargetDependency section */
-
-/* Begin XCBuildConfiguration section */
-		3B238F600E828B5400846E11 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COMBINE_HIDPI_IMAGES = YES;
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				PRODUCT_NAME = Check;
-				SDKROOT = macosx;
-			};
-			name = Debug;
-		};
-		3B238F610E828B5400846E11 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COMBINE_HIDPI_IMAGES = YES;
-				COPY_PHASE_STRIP = YES;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				PRODUCT_NAME = Check;
-				SDKROOT = macosx;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		40899F450FFA7185000B29AE /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				HEADER_SEARCH_PATHS = ../;
-				PRODUCT_NAME = "gtest_unittest-framework";
-				SDKROOT = macosx;
-			};
-			name = Debug;
-		};
-		40899F460FFA7185000B29AE /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				HEADER_SEARCH_PATHS = ../;
-				PRODUCT_NAME = "gtest_unittest-framework";
-				SDKROOT = macosx;
-			};
-			name = Release;
-		};
-		4089A0150FFACEFD000B29AE /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				PRODUCT_NAME = "sample1_unittest-framework";
-				SDKROOT = macosx;
-			};
-			name = Debug;
-		};
-		4089A0160FFACEFD000B29AE /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				PRODUCT_NAME = "sample1_unittest-framework";
-				SDKROOT = macosx;
-			};
-			name = Release;
-		};
-		40C44ADF0E3798F4008FCC51 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COMBINE_HIDPI_IMAGES = YES;
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				MACOSX_DEPLOYMENT_TARGET = 10.7;
-				PRODUCT_NAME = gtest;
-				SDKROOT = macosx;
-				TARGET_NAME = gtest;
-			};
-			name = Debug;
-		};
-		40C44AE00E3798F4008FCC51 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COMBINE_HIDPI_IMAGES = YES;
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				MACOSX_DEPLOYMENT_TARGET = 10.7;
-				PRODUCT_NAME = gtest;
-				SDKROOT = macosx;
-				TARGET_NAME = gtest;
-			};
-			name = Release;
-		};
-		40C848FB101A209D0083642A /* Debug */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
-			buildSettings = {
-				COMBINE_HIDPI_IMAGES = YES;
-				GCC_INLINES_ARE_PRIVATE_EXTERN = YES;
-				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				HEADER_SEARCH_PATHS = (
-					../,
-					../include/,
-				);
-				PRODUCT_NAME = gtest;
-				SDKROOT = macosx;
-			};
-			name = Debug;
-		};
-		40C848FC101A209D0083642A /* Release */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
-			buildSettings = {
-				COMBINE_HIDPI_IMAGES = YES;
-				GCC_INLINES_ARE_PRIVATE_EXTERN = YES;
-				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				HEADER_SEARCH_PATHS = (
-					../,
-					../include/,
-				);
-				PRODUCT_NAME = gtest;
-				SDKROOT = macosx;
-			};
-			name = Release;
-		};
-		40C8490E101A217F0083642A /* Debug */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
-			buildSettings = {
-				COMBINE_HIDPI_IMAGES = YES;
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				HEADER_SEARCH_PATHS = (
-					../,
-					../include/,
-				);
-				PRODUCT_NAME = gtest_main;
-				SDKROOT = macosx;
-			};
-			name = Debug;
-		};
-		40C8490F101A217F0083642A /* Release */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
-			buildSettings = {
-				COMBINE_HIDPI_IMAGES = YES;
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				HEADER_SEARCH_PATHS = (
-					../,
-					../include/,
-				);
-				PRODUCT_NAME = gtest_main;
-				SDKROOT = macosx;
-			};
-			name = Release;
-		};
-		40C84985101A36850083642A /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				HEADER_SEARCH_PATHS = ../;
-				PRODUCT_NAME = gtest_unittest;
-				SDKROOT = macosx;
-			};
-			name = Debug;
-		};
-		40C84986101A36850083642A /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				HEADER_SEARCH_PATHS = ../;
-				PRODUCT_NAME = gtest_unittest;
-				SDKROOT = macosx;
-			};
-			name = Release;
-		};
-		40C84995101A36A60083642A /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				PRODUCT_NAME = "sample1_unittest-static";
-				SDKROOT = macosx;
-			};
-			name = Debug;
-		};
-		40C84996101A36A60083642A /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				PRODUCT_NAME = "sample1_unittest-static";
-				SDKROOT = macosx;
-			};
-			name = Release;
-		};
-		4FADC24308B4156D00ABE55E /* Debug */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */;
-			buildSettings = {
-				COMBINE_HIDPI_IMAGES = YES;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				HEADER_SEARCH_PATHS = (
-					../,
-					../include/,
-				);
-				INFOPLIST_FILE = Resources/Info.plist;
-				INFOPLIST_PREFIX_HEADER = "$(PROJECT_TEMP_DIR)/Version.h";
-				INFOPLIST_PREPROCESS = YES;
-				PRODUCT_NAME = gtest;
-				SDKROOT = macosx;
-				VERSIONING_SYSTEM = "apple-generic";
-			};
-			name = Debug;
-		};
-		4FADC24408B4156D00ABE55E /* Release */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */;
-			buildSettings = {
-				COMBINE_HIDPI_IMAGES = YES;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
-				HEADER_SEARCH_PATHS = (
-					../,
-					../include/,
-				);
-				INFOPLIST_FILE = Resources/Info.plist;
-				INFOPLIST_PREFIX_HEADER = "$(PROJECT_TEMP_DIR)/Version.h";
-				INFOPLIST_PREPROCESS = YES;
-				PRODUCT_NAME = gtest;
-				SDKROOT = macosx;
-				VERSIONING_SYSTEM = "apple-generic";
-			};
-			name = Release;
-		};
-		4FADC24708B4156D00ABE55E /* Debug */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 40D4CDF10E30E07400294801 /* DebugProject.xcconfig */;
-			buildSettings = {
-			};
-			name = Debug;
-		};
-		4FADC24808B4156D00ABE55E /* Release */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */;
-			buildSettings = {
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		3B238FA30E828BB600846E11 /* Build configuration list for PBXAggregateTarget "Check" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				3B238F600E828B5400846E11 /* Debug */,
-				3B238F610E828B5400846E11 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		40899F4A0FFA71BC000B29AE /* Build configuration list for PBXNativeTarget "gtest_unittest-framework" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				40899F450FFA7185000B29AE /* Debug */,
-				40899F460FFA7185000B29AE /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		4089A0240FFACF01000B29AE /* Build configuration list for PBXNativeTarget "sample1_unittest-framework" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4089A0150FFACEFD000B29AE /* Debug */,
-				4089A0160FFACEFD000B29AE /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		40C44AE40E379905008FCC51 /* Build configuration list for PBXAggregateTarget "Version Info" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				40C44ADF0E3798F4008FCC51 /* Debug */,
-				40C44AE00E3798F4008FCC51 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		40C84902101A212E0083642A /* Build configuration list for PBXNativeTarget "gtest-static" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				40C848FB101A209D0083642A /* Debug */,
-				40C848FC101A209D0083642A /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		40C84912101A21D20083642A /* Build configuration list for PBXNativeTarget "gtest_main-static" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				40C8490E101A217F0083642A /* Debug */,
-				40C8490F101A217F0083642A /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		40C84984101A36850083642A /* Build configuration list for PBXNativeTarget "gtest_unittest-static" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				40C84985101A36850083642A /* Debug */,
-				40C84986101A36850083642A /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		40C84994101A36A60083642A /* Build configuration list for PBXNativeTarget "sample1_unittest-static" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				40C84995101A36A60083642A /* Debug */,
-				40C84996101A36A60083642A /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "gtest-framework" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4FADC24308B4156D00ABE55E /* Debug */,
-				4FADC24408B4156D00ABE55E /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "gtest" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4FADC24708B4156D00ABE55E /* Debug */,
-				4FADC24808B4156D00ABE55E /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 0867D690FE84028FC02AAC07 /* Project object */;
-}
diff --git a/week4/softwareEng_9_4/vendor/googletest/travis.sh b/week4/softwareEng_9_4/vendor/googletest/travis.sh
deleted file mode 100755
index bdecbd96..00000000
--- a/week4/softwareEng_9_4/vendor/googletest/travis.sh
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/usr/bin/env sh
-set -evx
-env | sort
-
-mkdir build || true
-mkdir build/$GTEST_TARGET || true
-cd build/$GTEST_TARGET
-cmake -Dgtest_build_samples=ON \
-      -Dgmock_build_samples=ON \
-      -Dgtest_build_tests=ON \
-      -Dgmock_build_tests=ON \
-      -DCMAKE_CXX_FLAGS=$CXX_FLAGS \
-      ../../$GTEST_TARGET
-make
-CTEST_OUTPUT_ON_FAILURE=1 make test

From 2a24f60ea5c9aca2aeb4db3ce333ca7ed46c54b3 Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Sun, 26 Sep 2021 00:03:28 -0400
Subject: [PATCH 09/15] committing output screen for week 4

---
 readme.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/readme.md b/readme.md
index 95d55d1f..b14b519c 100644
--- a/readme.md
+++ b/readme.md
@@ -19,6 +19,7 @@ Please find the wrting assignment .pdf and output screenshots in the root folder
 
 ## Sample Outputs for week4
 
+![week4](https://user-images.githubusercontent.com/24978535/134793190-87df4081-0227-41d6-b385-bf45234f1c9a.png)
 
 ## Week 3 Assignment
 

From a8c8638a97981931e4954cfb3abaa060a6d7830d Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Sun, 26 Sep 2021 11:17:57 -0400
Subject: [PATCH 10/15] commiting complete week4 assignment with written
 responses, UML and output screens

---
 readme.md                                 |   2 +-
 week4/Output Screens/week4.png            | Bin 0 -> 837007 bytes
 week4/UML Diagram/UML.png                 | Bin 0 -> 26445 bytes
 week4/Written_Software Engineering.pdf    | Bin 0 -> 99767 bytes
 week4/softwareEng_9_4/UML Diagram/UML.png | Bin 0 -> 26445 bytes
 week4/softwareEng_9_4/readme.md           |   4 +++-
 6 files changed, 4 insertions(+), 2 deletions(-)
 create mode 100644 week4/Output Screens/week4.png
 create mode 100644 week4/UML Diagram/UML.png
 create mode 100644 week4/Written_Software Engineering.pdf
 create mode 100644 week4/softwareEng_9_4/UML Diagram/UML.png

diff --git a/readme.md b/readme.md
index b14b519c..2ef8b2d2 100644
--- a/readme.md
+++ b/readme.md
@@ -15,7 +15,7 @@ In week4 directory please find invidual folder with programming assignment exerc
 5. cd app
 6. ./shell-app
 
-Please find the wrting assignment .pdf and output screenshots in the root folder.
+Please find the written_SoftwareEngineering.pdf assignment and output screenshots in the week4 root folder.
 
 ## Sample Outputs for week4
 
diff --git a/week4/Output Screens/week4.png b/week4/Output Screens/week4.png
new file mode 100644
index 0000000000000000000000000000000000000000..9aa269eacde1d3c249f4a55c58fd59bcad622743
GIT binary patch
literal 837007
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%0A|W;MYAf=q#Xt+@KfxCA+7fU8K?;mh
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

literal 0
HcmV?d00001

diff --git a/week4/UML Diagram/UML.png b/week4/UML Diagram/UML.png
new file mode 100644
index 0000000000000000000000000000000000000000..0af1abd97e61cc8d95f49ca060218e78ed92b5b2
GIT binary patch
literal 26445
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

literal 0
HcmV?d00001

diff --git a/week4/Written_Software Engineering.pdf b/week4/Written_Software Engineering.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..f55791f120d962a024d89a52f6db799fae686f02
GIT binary patch
literal 99767
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

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/UML Diagram/UML.png b/week4/softwareEng_9_4/UML Diagram/UML.png
new file mode 100644
index 0000000000000000000000000000000000000000..0af1abd97e61cc8d95f49ca060218e78ed92b5b2
GIT binary patch
literal 26445
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

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/readme.md b/week4/softwareEng_9_4/readme.md
index e9656524..45926055 100644
--- a/week4/softwareEng_9_4/readme.md
+++ b/week4/softwareEng_9_4/readme.md
@@ -15,10 +15,12 @@ In week4 directory please find invidual folder with programming assignment exerc
 5. cd app
 6. ./shell-app
 
-Please find the wrting assignment .pdf and output screenshots in the root folder.
+Please find the written_SoftwareEngineering.pdf assignment and output screenshots in the week4 root folder.
 
 ## Sample Outputs for week4
 
+![week4](https://user-images.githubusercontent.com/24978535/134793190-87df4081-0227-41d6-b385-bf45234f1c9a.png)
+
 
 ## Plugins
 

From 3404dccbbdd96699ba2ca97f47b193fdb0cd87e0 Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Sun, 26 Sep 2021 11:32:13 -0400
Subject: [PATCH 11/15] renamed few files

---
 .../{UML.png => SumedhKoppula_117386066_UML.png}    | Bin
 ...itten_Software Engineering_Sumedh_117386066.pdf} | Bin
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename week4/UML Diagram/{UML.png => SumedhKoppula_117386066_UML.png} (100%)
 rename week4/{Written_Software Engineering.pdf => Written_Software Engineering_Sumedh_117386066.pdf} (100%)

diff --git a/week4/UML Diagram/UML.png b/week4/UML Diagram/SumedhKoppula_117386066_UML.png
similarity index 100%
rename from week4/UML Diagram/UML.png
rename to week4/UML Diagram/SumedhKoppula_117386066_UML.png
diff --git a/week4/Written_Software Engineering.pdf b/week4/Written_Software Engineering_Sumedh_117386066.pdf
similarity index 100%
rename from week4/Written_Software Engineering.pdf
rename to week4/Written_Software Engineering_Sumedh_117386066.pdf

From 09446d6b1d327fc7553381b8a661cb0a98a936e6 Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Sun, 26 Sep 2021 19:36:49 -0400
Subject: [PATCH 12/15] Spelling correction in readme.md

---
 readme.md                       | 4 ++--
 week3/readme.md                 | 2 +-
 week4/softwareEng_9_4/readme.md | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/readme.md b/readme.md
index 2ef8b2d2..d942a3f5 100644
--- a/readme.md
+++ b/readme.md
@@ -7,7 +7,7 @@
 Name: Sumedh Reddy Koppula
 UID: 117386066
 
-In week4 directory please find invidual folder with programming assignment exercise names with UML diagram. On each folder please perform below executions in command-line to get the ouput.
+In week4 directory please find individual folder with programming assignment exercise names with UML diagram. On each folder please perform below executions in command-line to get the ouput.
 1. mkdir build
 2. cd build
 3. cmake ..
@@ -26,7 +26,7 @@ Please find the written_SoftwareEngineering.pdf assignment and output screenshot
 Name: Sumedh Reddy Koppula
 UID: 117386066
 
-In week3 directory please find invidual folders with programming assignment exercise names with UML diagram. On each folder please perform below executions in command-line to get the ouput.
+In week3 directory please find individual folders with programming assignment exercise names with UML diagram. On each folder please perform below executions in command-line to get the ouput.
 1. mkdir build
 2. cd build
 3. cmake ..
diff --git a/week3/readme.md b/week3/readme.md
index 0cf285c8..58994b7a 100644
--- a/week3/readme.md
+++ b/week3/readme.md
@@ -7,7 +7,7 @@
 Name: Sumedh Reddy Koppula
 UID: 117386066
 
-In week3 directory please find invidual folders with programming assignment exercise names with UML diagram. On each folder please perform below executions in command-line to get the ouput.
+In week3 directory please find individual folders with programming assignment exercise names with UML diagram. On each folder please perform below executions in command-line to get the ouput.
 1. mkdir build
 2. cd build
 3. cmake ..
diff --git a/week4/softwareEng_9_4/readme.md b/week4/softwareEng_9_4/readme.md
index 45926055..76c12647 100644
--- a/week4/softwareEng_9_4/readme.md
+++ b/week4/softwareEng_9_4/readme.md
@@ -7,7 +7,7 @@
 Name: Sumedh Reddy Koppula
 UID: 117386066
 
-In week4 directory please find invidual folder with programming assignment exercise names with UML diagram. On each folder please perform below executions in command-line to get the ouput.
+In week4 directory please find individual folder with programming assignment exercise names with UML diagram. On each folder please perform below executions in command-line to get the ouput.
 1. mkdir build
 2. cd build
 3. cmake ..

From 449c053d8d9ab2b3436e0f9d2dedf1cb128e22cf Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Mon, 27 Sep 2021 12:31:43 -0400
Subject: [PATCH 13/15] converting UML into PDF

---
 ...k4.png => sumedhKoppula_117386066_week4.png} | Bin
 .../UML Diagram/SumedhKoppula_117386066_UML.pdf | Bin 0 -> 24951 bytes
 .../UML Diagram/SumedhKoppula_117386066_UML.png | Bin 26445 -> 0 bytes
 3 files changed, 0 insertions(+), 0 deletions(-)
 rename week4/Output Screens/{week4.png => sumedhKoppula_117386066_week4.png} (100%)
 create mode 100644 week4/UML Diagram/SumedhKoppula_117386066_UML.pdf
 delete mode 100644 week4/UML Diagram/SumedhKoppula_117386066_UML.png

diff --git a/week4/Output Screens/week4.png b/week4/Output Screens/sumedhKoppula_117386066_week4.png
similarity index 100%
rename from week4/Output Screens/week4.png
rename to week4/Output Screens/sumedhKoppula_117386066_week4.png
diff --git a/week4/UML Diagram/SumedhKoppula_117386066_UML.pdf b/week4/UML Diagram/SumedhKoppula_117386066_UML.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..75fec324b91076c576c22ee31ddef6fd620de515
GIT binary patch
literal 24951
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
L(>kh6L;3#zj+x~k

literal 0
HcmV?d00001

diff --git a/week4/UML Diagram/SumedhKoppula_117386066_UML.png b/week4/UML Diagram/SumedhKoppula_117386066_UML.png
deleted file mode 100644
index 0af1abd97e61cc8d95f49ca060218e78ed92b5b2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 26445
zcmdSA1yEg0(=Lj;dxE>WdvJGmHUtZ9!QFy~;O>$@a19Otf+r9hg1fuJS^G`${@?xY
zt$XTJojP@Is&?3Wt(i45-96n;KhrBxRapiV=_L{b1O%#_tfV>w1Qa0z1Y|4%9B`%i
zq|P4#0%_SsLPAweLV`@y#nIBn&H@5LHZnOCUK4v4FYr12LRz6rUEDF)4N4YK_~Mr&
zHC0e3mYMjg8p<`ON?1%xRUJ1i$?mD*Z~7R>czAur-(mG|lD5sd!!vlhC=ZSVkK50W
z_@5V9J&po~vu<6FAYLJYq9ygJu^{Gp44pLtd4<W@BjX66VDb=uCTxyu$x4pAdxsJD
zE#|4btrIy<&Tse)$8_iNb5%jlrW_x{t3iZP7wRm#P{H@y{g{!ikgtd(4#IC+3gkLs
z*_2{%-kqFKm8zVl$|+}?)lVd;C?=uzNJFd)+BNbKL)4<0m2NvvB=Bt@gxZH124Spn
zBltMo*s=7;8nf{V3R-=T!Q_#6kb+RPM&ML`#^HQqJ=NGeojY*jSGne<_B08SOzJbf
z3J}S7W}efVNGGECMseO3r1oz5RnGF`NR}x-vPN%@m2Ow|S*}?J7u(x#eyrT07hAP{
zA)7vRJ>r&pN-N_Z1_mwqM%Yx=@P&KVvgo`jxoXf|!{^rK+9pPHTe8Q^2iNgW%-5{=
zR50*)dOwWptmu)Fwiq$RewZ1@hVvZXx=g*!VZPPqgi7&sWD%uN{Uzwr=%4eRpHSli
zSyk-t`DNy1Wb%EqOZ#Svq#mYAfU$PqBFkWO%JHa_@z`8D=9yJmH(FF02m=ZVg7_<i
z0GuQw&Dk(|i}dDM%9b+EdLpGh4PMc?>#pL)*V7#)@&Rv_rLq1oyuiV8!AJSF*erq6
z_xjfrhwmT)1BucV8{bY_2F=EyKm`g4*cKK-kP*YK%=5-+X7Sofs2H;aBH%!x-dcT!
z4evtHg%n(YSq#Ki2Vo${>?y%SL%^Si@nD4bRzp?5_T{12K`w}K&q7}XNvzQEq3L(i
zJE0ju&2*tU!3#k>nj*Bpn6C(@1(G4atC2AjA?}Lxzo&i;&rXK^4IL?{AWxDGRz4#1
zJ&r!)=a8X1m$H}h$Ws!cVzl|L-*L<Ey&+IvQGO@f;fx6$WJ8?}Qd;q1gSPDHc0y^x
zP>x9Lf_1`dL#zzmU!inD_C@P}TMoKkO+Dd5%9EwzP7)bH>U(vY*P|v^#+5|SfTR`m
zNpdRxrP^T`%TH!a(Kk4kh_O-{KiukZ=TV8@#Ywq-SNLB3o$$xhj>Hb$1?&a$1%x-s
zBdSEVwK)@eB>^4{WMbUl0FF5WJ3QNHT6CIV8u^G16JB{Zcb|YcbWP+e%7M#)^Z|<<
zb|dscH1XHCbtgWhEb1|0{5bP<7w5j_>}Ja5y5`Jg@<kaT#Hxs<-uv~$6LDYi4y*uz
z0Js3`XChHCRSE)ZL&Q}W7SIb2CrC6u+bNq(GL4J@TPgDBD}foDGjmPUtZbX?0c8hu
zf-D>rzB-lMD}9Mi6vUK9G^p=I612YIy(V?x(3AfqDI$ABCQ8;>tV&0N!zzzOomv~I
zuEMY4C4O7>N~>Dil->zfoAD=IJ>8<FXR)j*m-cH07Ih}o3QeJWPa|i|$h_AD8--uB
z^@}wN-PCt;CYm|4=Ct_@`3<}Z&p?}uL%j@qxY)R&xRvq=Ln6uN3?Z60Q}6dAHdSZT
zt~FTIBdm2Z=wqdZ^OAqWO?X?Ie`5HA_R0B^f|jkOO8HfJ{!hi9x^MK}WKPAEFKOLZ
zR2GhDZhuTI<NdU(`JBft)2k3ts`lwek+aNt9gWeX3a5r^xn=p5IdgqVn0AqN$F#%e
zX#GN0YuCjsr>&$hev$2bo(lVX;^KBgpWL@iSIu#i%7JmRR;6QJ*=k1IMyyLHOGrzc
zUnspbh0%qBjKhBEwd1>K2_)u7RTY@z#qZkg!|y3vUhiG+s1T&R{Q45-CD#if9;%ld
zD3d6RD1xX1F&8o7vDyUO1j1Z21e`Iq{em&AF`{W{8DBH)*lf68@Jz8;q~oRWq+O+}
zjR=jVq)nwS@eE{ej&P28q%T(oG7~Z1;Bn*4FoP6m6@oTdhJUrBwXnE`x$bZMs-rMq
z|9n>QvI4GRszRay`Ln@ilTpr$R4&K;wo0#MJ0km9yQ>AETCEz?TIPEDCO>m4&_GRj
zO{=|1&2^KB{j%lreD_4qcJ;z)2jvv|Pv;Qx(sdnLE7}^3!pV1a39eDDpU;KiVllgC
zzcn8OJD<MQJ9HV^Oe{~dt=xB>5nZfU<XA#$MIGnO9?$Fyc*<)H5?t`B^67+MqU>9T
zkM~#cQ)#ry-qv81V6B{itlCy|wS+rII8SbhZJKSJyAO#kAD7QXGf8p`bo}TTpBrUT
zVbZXS9RU68_6+x212GV|2}vB3*0s|0Ip|tffC;TUhZ}E$sGeg-oQ<DPpjqI?=AG0#
zz9L~9G*qM|ym@>}A{rE1RQT136Z_S8N=3>P$p@^+*qC<}k-m5qgbfs*7&BhB^W8aJ
z+!Gw9jk3p^jhYqLWIIPW4?15uldk!#53k>2Z&6n$Hm8&&)5+Q?^icOv6U)9dS!pu8
z56*u*u(7t$imZgsV&rL&FkMg~Rf^BZV#z9!5G)s|!k={(Mm$z&9$#9kZmTiCCz3^+
zm1@Z90P7LDJ;t~#tm3M|s6wdhp|YGJ(sR9`b0z~T68xrnKc*{2_ys9PFDJU?Q0-b>
zM(ybw{Tyu=LyzKW7|~KzF@HOSf?7>kK;-_1LxujY-D}WTvbCxcDGCyB#SS0S-P+yA
z#wn|4j?MiIpCXHg6v7l*Q}vh_^{(2wI#&iZcQ&&&vl%aRDva2xKeV_UGgxcweHxnz
zFOSwn|BR^XYR&9yzcp`yY>zaIy!<)ZWX8BiqrSx2$*=1!+$_w@`LrF?f$+*V;z{|$
zNF~y5aO{I)@!~|e1&>9tg$a)fkMZNLtNTyK7MT+~mv(RG+kBAUMmr5Jea<mJPi9QT
zPeOM<UYb@HtD^ht+2nV6#h8qi?DH1GL)PO$Crq>9kZZohVmtMX|7G^e<BSsh!}$;M
z=&jAI4o6q>OU*J?DswsGq6q%YoxG-w3fXc-n<57tZGPid1Bb_V38&_dke{I~;5$fg
zNDf4C+;_y=UHu+GhrOAED{wZw-x4+`dE@R#>}~7cEG`sHYraJxN+j_))fiIoh=(UV
z7V75vaZ`6X-Z1)eYXYy#LT^}?v9qC*x#sir>+geOfIHYSsR-crlz-M7wV9gC9LE^P
z$xg^-<`euyzDFRO>hDnP>bzZej=1e;@~-W>EBnpbrovO|m<N07nDN_A-@T~)<V2kp
zItEqzMz*_e4;-GRPG`1AN^?^7$7U8Bnis8)vzL9gO14K`n|vLOzKnkHJ5-*{{?%IJ
zalEY1F%yvM6L2Fo9WsM{PNFQNKN+#h=vQ&kd=`0?_+@z{z;@4LPgHnC@cSdz-EN`S
z*vjxSb!Wf}25)IE?OVfRugB`8laH9s352Y8Z3N!*-u&$P59pf#KRY;lF3(Ag1Ki@N
zV^G`iI#b%`ZnV!2yFJj31qLYlbKA!KMNjiD3bzI%atU(3hztbyizGb5UKj6`-_Be)
zb}!$(p5sV=$84z*3-!$nVx^u7;un$R*19A_87~AGOIl7<DNM!_O&Y~XuBSI#E*33B
zhA<?80DR!4H^i4yh@Dh2PFZ{iOdJR^LkK%ZR+DEexs3KDHzp2_dr;1|*NzGN1Wl-c
zRR*tXBL&hA_C<<jMIZ!1CtV+lb|{t!ZU-R<R~GS^jG&)rCOMyTy&qcP5^?zgJNE;i
zBB@Cbh|)L40mQ3qp(|&pqy)hLd`EzQjIe=#0lq;3pO?S~0s{I&I0QWK7Yq1E=0W|v
z3q_a*{r5X$EV!YVhJ>6P@K?j!#lphD)!NZ5Rlnr{c+|9wrmmZ=lA?gQqdg1gwWFB@
zi>JL4xC?}krvUKP-ogz;=4o%|;40uLOz}?(0pL6MGAjkyKTX_hg(-BERLLY9T`b6W
zSlC$DC`6FR$jF3TURw&NOG^Lg4*U|Puy%8E5@2QZ@bF;q;AC-hv0`QC=jUf-<6!0B
zU<O(+yLvgefjpTVTq%D)<nMDNEnLlAY@FO|939BO&jpz|y1NNeP=E*e_uub%T6o(0
z*GLYof0hL-kQID~m7Rr+_1|X$U4_6`1ypT3E$s9pZR`Q@0Aq-7^79J))BgW<=f6h$
zkDj{!)svf(|37>F$DRM)Q_I!DMZ(b@7}8DTzcllw^MBs_(@}^Oyz>8$#BVYGa}|)Y
z2$B%%zd92^;yEYpf`E7hAtx!O=?Qt5jr`y+m3HGnl={wf(ZwSpl!DSlspPxrh$>C0
z8qSA%w)8bFmXLfy7n=flB`lgRWwH!%oDMBip)SX!WiNh|IU{#IKe6OoclsY6FCE(-
zU)Kg4U*G!rTOE5GyFXU?U3p*CO?yw%C=}xqKO8?lIo7;A)K`{C5pd>pSk$dB>Ga<a
zid3at*6VBN=;ghvm@iZAXskLkkjfi#<t}d)8Q1#Ua(4I6<w?8c{R+t~TtwMdP+0E+
zVW_?nK_<s;>1KR@p(29>Ulm3uv%3gfqyF0>gEFu72a$rt2cR*yMIJoRfkd^9>YvtF
z?_asXX!2y3+sOa(IH1J^S@ocnj!|+-$5k_LvVz4^-xv4&k`FUNug(0n^Kof(;1)bw
z?6%1*7CcDwK`s{6ezXH`m2RfX>a?4b4PWvOvAyBm-w-Tsp7yxW&e0;A8l1Um@GD37
z=~ZcoJG0&LiCf1w7kt?x<8YsCXvnIc@$b-Fvac)(#nNb~|IDpR9*TjGG2K(@_gcw<
z;1J8~xDY0b{;U;CSMHUCIW>0GztSKB76%8)Nct-cMxaB*>$QL7^^yvZ2AN{wUul?9
z109kT+bI4@BLtAf%TOEjzf-CJI@ElK)cHH2_4~jf=@2$0`M*<220CbSoJRc}5f#fR
z`W6m^mWb1O@Y$frAuX?*BIeQvcT`soaiIxo^iwnFzB0<PqT(yp!VL2kV`l!Hv_a#=
zsI6-0i2K?ZTa{5O59`qPZTGWmEyI05w{yI@H-!SX^Bs+jxIqHrQx$8<=U#6KiuVRj
zzx*9D7DIK;8m2JvuNYLN069j*%uxR}2`uYSVA7NXN|Jvk%>c+%>vbE;-&IqBSKVz*
z@psjln5uJS6zlGPjp!vgAT|VP?1aBY6a_pG_eGV$Un@ia#3;>{@$T=8w15YG`sQi$
zcR*>tD!GDxNd6UL8AV>LnpFS(-vPPAyO_5KyZL-64r;gY&U??_7|1R(*)#L#d)Y7l
z@N8hNKNM`ibB(@bpPimVON*Feo{0!CjySJaoA2mtV9vLkl6F69@UvfLfO5|%*XzsP
zIzM2OpGy2cx&%Pzm@zc}ni4J`69x|B)W0&r1cV-I%7yt?sGk6tXeRuxXt9eX)#&Y<
zIwgJjzk<fv5i?CJR&N$5XLk7GO*&+Lz?o!drSEUp`oTBZhL-huX*=65Teo))=ryQi
z``RyeAHF2tbIQ>&T;SDrJaPWX<3eD;rXlgK`Gf%4MfH?U{xfq^Hee;)F(~AJ%>@-$
z3HQnit-sps2DA;w$r1Wj``p0Feg;};{#_{?w(1<g$Ty6?+WtufXdgO9?XP_jC<5D<
zjq-oz1ngX<v~)(@qHj5#&6d8nbAS3?SvK8dbjbb2#(r5XvVpPfaG~<*WkY@AaoN{!
z^iIpe`3CxnvW31ay`PZ^>(VdIxFYzg5|1m^^p`>USMi|#Zef>Rm2XCqXRN@6mu-13
z5L0`W{-0g|*pV0|a&mt*NcD%np?-N9<9|1h7$8E_9xnR7BGSfEozors`u{CgxM<cP
zmexzv$Kta;{h5$v$1v=6M@BSb2z#J~Au9}6i>0z@`R7J?i&^`orKr}$O%_hpaXwh<
z{d=#hFIZL?mrJid;&6PfQ?k!)CggQsnyxZY!IVxBxE*6~Al$!yy6)^$9VECt<qC$u
zOX&(nC5&45b=BB6-(WjnwsP;~Y3Hu1R41y>>6?tw@(zZj{bC}npyqPg0RO?hZj>kb
zU5^0ZfS?hwy!SrB9>++a@fUe^BO9wOUUys*WArXWivwn*rtdxCeRlRrmE%TV4eWk2
zF;|F#3W9o0vyXjcEDDi+LK%Am??Ca~@oD`sj~DKbv?M~5HSI<?0R{72d@)58&HKVY
z2o1q}X5XQFqXB*bib5A?8YIW8&6gb8_vX09me7RJoYqwGA6@F|0-8l$xX?EIy*t>5
zf!~v>b}U%d#6h`_2UdM`IhPe{uDSPy`$G;v)MP=ofG=b>IRx2IvGKxGx@Pa=G<95l
zjwbwd5>A=C8;s0C2mEx5#Tn?rdf&B21H_{*3p4X_rgl)CU;Hl1O^g=zjjvzQ#{!dY
zycyEz;7})m2INwn8R*ZW?QyR!h=}7E*uJoIl+wnZ<A1l?H>CsgxvcbH)*bT=AzUQG
zyt^nBHF{XX@1$#7aA;lgJN7Yg&b?nO_3VNsQO$B0qVJ0nJkqsm*-Yu1>9}fGTZ?98
z$+`JTi)WSNWqDf6>i2Qhu5L8S$YZIY`F`ox_~CA*lSNtR^y}IO1r~Y-@5xNO&bz6q
zsP?P*^5!G=Duai!)J~=`zV(>3%;g8myY|Dz1-#~lj$fCRsb|mK=>Do%0Z+Gm>m=9B
zYa59w%B#R+w&%Tp<ud?*s7C(f#2eYXsIDI}q}f@uk2eFN%2B;EnRe<#{x_?AUfbC^
zMD9P;U^~Z!uNT*9hglfoM4xVoAo2|Jd@+tvn%XSXc~n{A__xyPiSC9Ns}zw?Bxva1
z>9|7ge_eN^CdK4FKWz7*2i)|o0sl!jk8;o8sQAoJet<eHlM()ObLbdg&~|9=$mm2M
z^EA`>bQygd@O)3ty7qqSYQfP&ix?ahnZZD#N4oAC7C~}XYUjh|>tfSRq|kiKa9NhN
zlb(%D%rNNk-a5b_);_BEy+Jxp%zdCDUMJmhGR<!uRB}*n+taF&PraVA%3Vu{_kHa=
zt!IUMf7}`1+yx0wg$y?xHz4|SN<Y#H$P8+8qbO0CfoIwG-0g5s#oy($h*tO`-(me^
z6s^!IqTK2#91^Ddw+!x%3@p0m1VD%@S+QCZ@3keMv|v=J2=EZ4LY&b3b|f^M!llLi
zuUnUKeU4hJ9t@qSh^ek=hMfjKJGhs>?$gCwRlygz{HTJ9?tc;@7zLN==+U}R49Xby
z-QuLzEP4c-gTB<d%A%00DL1BWZ=5svt(PI;mGvS>?$J47X;p$1onL7ztuy%wJCD*z
zOO8dCHjT9#ZxTT}8nA<{zE}shLZR8(b5(>RrwBo&R^>(DD(`URrfBthL+3tRn>cCz
zY*5DRDgQ*rI`MHD{At@JOv!D>kXpK<a^drBz3%5o=D<O=v3q>`%_RY6ueni*WdVyy
z>?Wm4i?iGbf2bb`*Pjrhpv2SCnC2M`LstnB1<sump*~|xSfartO0`-{D)B0%7Q}=M
zeJ5UCK3B@KKfdB=&n?_sm>}h6d&#_|234K}L43QJYSK~hwk@v`FzK=HaG<o2ITdko
z(_pKn<JhBRF9BU~f`XRi$D>pe<F_O>=nTEJvQGe9*O%zxC;V)~fXondidg;O^?HA7
zHjKzsO?>gWD#Xr#n#i3T9Sj}eQcn~X6%!GY531K!N)k2S(`XaJ#*d^!W0Sd07xjzD
zP6<5nkpRx95P{O?(KgA{r$l6;d?hmmGm787BQ;10H`GHbdOKLJzcJ>~;fkb?CZ-*x
zis1izzs#zTORAutusa{?=(}F8m_l7kM*vUaX<Bpr%LgCd$W5(g+5a9_@Ss{E1OIGp
z+@D8JE3G+7az13}J=A?XkZuS7-t4n22QpL84}|Xtb$9D4A?V6aTuys^pRlvuh8=X=
zAIV|9TPAXRTbGF&LE>%g9PhJ8X(X+-;&E-56M`mC*0o^$EkTAvFU#+0E?cftSNLS+
zG>p|Z{|0axIY}82!UrHZNF)UW<$hV8Xy(RuuZ83RXZ8+=pA2sl%PE44VN`jlrK{&*
za`D<<?|*Jmj_W-08R?z1NHr2jP4oHDjun<kN8YlyhSx-QQkZ~j(fs^)ocnaP@2os`
z*0%OV2Jr6g7*1pTd)6|x<U#UKZWrt$YA?PKg3$>Lkb#&7J1OZyoxl1gw8b@T<uj#-
zL1F1CLZKBhS+*MN!%}qlB7#$rE+$0lxio6O^OWB}i3tM0NwC(h%jtdtr8IDIp*O+n
z_&dmVK>;vbH&D7U>NgGw(gR}t|D}5n_pLu-&C&(mWhFK*Yj2s?%%F$1^Md;F(P*o*
zJz+24SE7~jn2*1-CC}?_3HZ&`@3mS!-d#qzX4}8n|5{w27T(tV2eveR?6|em@2!sj
zfkV~?%>0#u<K#U*-^}iCiJr-$on*Avfr4qS-_@?qa^{~2F+h#|ci0bxwB@1+sDwNf
zPxAT_K>o-Rq`=Zr1okd(O3k6lqXEV2y%~?33O5q_C(Y^wR!I;(VHW00U{N!_Fb`-C
z{P+@OK(c$^Mpb`@#cEvuGvbxEfByU%G@9-Kzf0m4QT|}UXds0#|KHi&6jiW4Y-8Km
zezwp#f?5m59^?)<b`%qO3Gf7WD88q77#Z6QXHD(|h#-}7+s;%feZ-_6yQl3ubI5Mi
zF>;?$Jo~J%CE&cExjf3VU}s_O^N$U@hq3%o$~1J(pOMFW=}thcKT`M?24e%kiXF3p
zhT$)61|)-kMe-N*rh${DNK<aLzZftWfZgv;{us~uE=d4IE5ejV{t+M*1|Xr}P{4eD
z3zP<oZUA;k^S40Bf&fsBNd?|4|7ep9oNi!uzbW{wTS!D0U^KE-wZE++fytyHXk-5c
z`DDOoFo^MgTPubJ8jQq8CTCyuCpUg|kG^#_nDxYZ4*@fORyk}i%(2aNmmA+R#JqK1
zci@HJweFC8fOjsO;0-)qHw>oVPi5L`U^;T4<l0q;#r|VeFWnEb|KBWps9&-=qwKF1
z#a>xZ%6caK&4nmn7R~$>D-P;;E9<E%0U0gy^d|<wkb&*zmwpO=>5pe$9Bl{o<y?#L
zRtOT0{S6*_P}`hk=4C}EK3MfA5~hpSud_YuvYYL_Md6<tf6joCtl9rl^8b?wOe<1p
zVH>%_Tmj%fONW;6H<dF<o@Ze$kTv>;EUB)BskdXYn~c{!1vYOCUiWvvVTofkZ+uXQ
znp76FC*OA{E(h2V&AL-%X;Z+Dj`@3m4K*(VutM%ksrGfYp@PP?%RjzNF%sD4Nv|?v
z|7=$^pexgxVS~TEEeUL_i1l-Sj1w;zX#W4&y<)D}*}U}Vz>~M~XJlq7=;y;fq>=r{
zV<5JQym2Kk1}ybe#4Cee?%7bOwDwG{*&TNJmqvB|k9S{N#&{as*VKQ|N&H&r&HC*n
zHJ42u_jG!>LjG}h7gXOHJ$y2MjYGC6oA8X@3B+K5gZFRq4*H)P|NoN;vR(wGc3c$q
zbw1yBjx#-fis=NvF5bA`k!y67|7Cd}Bs`I-?;3V)8Ir)sUE8#?X*VjMZ`nLZU?-x!
z;)?W!aqt>8z{|96)N7Y~^Ht>WViMWXZToE4<f)eLqzgJ4$f6o=&PAWk&1Q@|n2k@P
zbZ~%#UysCY=iGVkrv2Ej>gH#u2)7#v9M~M$ssM+u)nK7-Tp7*U(R}kG-k(d8`DvB(
zDc^I%oP<+zwgmd|s;QG1P59#b8US<+Q!dyCh%_F6yo(h;s-13+nDL&HHA`<7imQjA
z&~DAM1pF@wNtwq4_AAI;+0p=22i;NwKCIJza_>VsfVk+!1drSD_ngiKY4Pz5oy3st
zm!BV(`%VW)O;(Dw&U2rAPk|`j;kmSL+{E-*^kEg9euO&JP~CT(aGCDcMF}r%mDi|k
z6c|4C9Rom9Imas3@2&Gu%l2D;*I?L?i-3o9Qrc}{$AJ5VXxpmx#;z~UTj^FM)uH^S
zU$LXxuYa{RKV4QWM?S|`2^HP|8H=u=+YhO1+vTULCJk@V`?+y}8Sm^E{Q(UX;f9;|
z=bLz_ed(kooiE0~9;NyY2WZ0Hx>(D&ADk?4l0sD#N09n^I{#FY!FBZ8H;5)&T!Di{
z`X&ZXteGc71|TK+5inM1JFsA71gB<HVUT?r0OUFPe)l~>Bq{0LSlC%;y=?9(M!0-h
zY7iKt?#7?T1IvKLi<c2OOL#c=)(&JmYj2xcjb!Lo;fBz5AAxM^Fm&IY;|=lZs|-Hv
z`&IM+T>$5H?j~2vfP-~?a94(Q(u6n*N{|xI9M#n2gaRw`ug4<~{22i5PaK1>ot*P4
z$aice_wzF!xXl5AgMLKYz&=^PzXH<0p~XVQat0VxaHa|HJ7z!{q^O<zc)i?-y^U;g
zBQB=T+rFzL2;wJSK5Sa<Xg=vd7M$^zw<%p?@n}(SE)`t*=xYC6E~(RmIQKkjo62@<
z>F90K8tL;XDLnPAA2|NFDgm*lGP6`T%-kRD97~*_ByTc4KN1Y$VI>$ts07wJ@5(#(
z=w5zpInO>e^xb4M(Zll_AogGq|FO~!7*SRd>Q;1~ooROSDym~MlQK#)8;%C`^7GTR
zV3dqU8gt`p!Ob@rkq=DtbmAMisriDwRm+7xYjk|8z>JDDArQ+N8)maoJOJ7Tb~@ty
zb=$VEoY*WVf_S1>iFb+1;Zj&y#&<yQm$M!p6Bdx8RZTV^)ZK1nvLc6whkPxOL=kpl
zBm~Ww(v`^j1Ms?{`i-RSUSxsG<&+M7g2^J`6~X4Q&H!kVBMZC>cz|GOEy3837sJ~!
zsFd=V4n*Cz1Q@WzO!!A>x39L-6~0{S`k}kZtT+f;PMUIbOqh)fhFT<At1>MlHZp!^
z&Fz(&*TP^b@VhjWt;;ji?QK~y`_akQ`JTND+sYRm>ZoBcacQ^|OCJpA5eBG+49#xe
z=n7SrY?Nyt3}YZpsLYvG!cE5-_qZpe3;2tLe>SgrXr~F{!L%N3WwCmb?)vg^Tn5wt
zSH~t^#CM$gFx2Y4W_Fe%)!{y5Nb8WfXHY6p+&eJO{z+11(e_emq=`(aXZ0j%iaOuW
z_rRQ#k$|QJaAb+K7CG=U)s}f>Y!M;UpJnL?L9n1H8H95VV8@bv9k-BaeBA-0z6*L-
z!;3iDMM5i(=mcLndZ!b<RGUdByfQ$nKV13+4*J;kyYbrdp9<kfs8vI{%8f5S)tJd_
zFWW*{(IF(Tor~q%j#%L_$@Q(Bq>ua3@UMQE`s|P#{4l!wpmYlC2fk5iP#=Onf6hrL
zEtScO1iW%#RWswW52;0<T;8@-RGU7;%E6igH%3E~yNT3^M>=Rmos-j`)=N-wIcWdg
z_5={(m|GM}7Zn4w{@GFqKvW|Hc1W^UZ#b$H9fB_E$xdYEi6P1J%>b(_eVlvX=0{fF
zRpdkylnVU&qgKbWvlpk;c5G^wK+ff+FC45<DSBTg%IM&lxqx%sJRq!IZLoYd-RC?&
ztmAuCmwTAB3QXJc6xhc6{4fiC*GrTw!NrX?ZFz0vKtlbf?nUn*`l2+h;wV4Mw?!2n
z9HjwqmD$xdY-+2uke<DdaC;NtZVLGO-G{hDRkStUA-HM8q%dDx#l?6^35ti!iR>q%
zWAB;ZP7LjIp(E#bg(xHiC-aFdFa=PrGV}<r5C|DrzN<U7?_)G%m{{Wd4$R@H4}Wi1
zl|1kHr$ziFC>9RLB-AUG^dup`St=U~Ix~f@2oUYd04HFYze*T^cxBoEu>ZRD%wNbZ
zL6v>X4$je$Q+UY8=e#1fgDNG=TcRgH=u|U1Baf<J$;z5?0f|ve|L}KL@jx%UM7)Pk
zNs(Sp(QG#_MU&r)w4SrJ9oBRB4P0L-07#*}D4(h1H<HNv3`DW{d6yJ}-@*Ai7T}|q
zZRny~K6H)yU)8PYjeBdK0><gEIf_}iB8(HC-^^iEIzP<PT5*&6e4AUpI*%|IgOg;x
z9uLqwLwtOQf;)L3497F=L6h}hHz-xnNX~keMVoJLKC|LQH=_WUj5Gmv@|X}?4GI=P
zN+7mm1hqwT3uPd!@`K%mPYH^~H)NJ(vcuVz9o!u^eXMu^&({H+6bwG)EA{)}nYfTO
zQoM>qt|$Vbr(mQ^xiAlXZFh3R17!%UafS*>bdy!J3H5GV0v>|*Q006DUbNZq#A)}}
z;c}5<(b-lQzH!=O7djH}$9vi=C-Iu?93MQeV^_xm1DJtdyS%LH%#L2exH&fG_w8e9
z!K=;dae`N04!IFWgaOCb;#lw&?*z=jIe?RFkLF%t8towW{b^h<3XxHMo;8nWemY})
zuAQurfr=o0t9xb`g^qqjbqg4$UNsVI>JF1%tgtSHZ}vI>S*n@tIv*E0aa#`?4N4XH
zu-6^2f^oOg%;V_M_&46iMPEXr3ps66R126wzAUl>6LU7CnQF<g3CKT9VR&xWy})2&
zQjJG8$EvV$<;7b~5dLQF!v-w_VPP=m!y-7%$Slz{g3V9#{~ki3DFpCG#JV-tozIW3
z{+zS*yBCuxtd$*idp~!NY6eL9P#v5?a7a_v4+3fdV1j$>vwS~cX=~^Ic8I>T2>&F-
zz#)AxvT#G_G*U%z%j1e2<d_KXj@*Yn!3wTCX6ErY9cwQ{<^b#<uqok%xJ>McDW&!W
zOcn_x<p8V}u}ZNW*1+)dzR9z<3sZQ6x{%*irZW3iSAbtDUVR}Hv<7*ZkM3t}1>FQj
zDTDTR0PH$m1M_QO{<$dY5kNd9|Ij4|Ey3!6nOE<ReYXYs__wn(z|mh$&eW0MN!&@O
z-_q6XsWiv?%_+ba3ewAZO7uzjAPjpQyOj#!3Le&L7|L6$yi}Z9jH}h49SW-rgyx=4
z6d+3?C8hcqyGoYSWX!U#Dw%F0*mG*3Y!FL{^5_d-BNaUKJ;dwIr~OXlMOoJQRN>dE
zcxvIZ%i+S7WeSyaro{-xp#zt~<G(0LPTvJLuD6I+Kdcypu_0uxgV{Ox%Ti^g`2J$Q
z1CK-~)SGQExjH@#O?uOXW}B1&MnJGWXI&XS=svT(>hkr}7JZ4#C~EWJr}~0<1iw<c
zG!dKo9@3iUs>}>+6c%ml*#j<q$lx0|w!04~DwaCktVZB(XL}ff@l>&L@K{a@PMaOO
z?Ih^5mX^rU#=p?;q)!=s@a;Jr8%p|#i%dQ_(U$dZzSSl-(U`Df^YA6>r8Vc;QPZ;j
zZuAp?Xx-GqcZy_l^AW?{**pqg|G0hXGkK5-g6cMA)Rp;lJLXY>7LArm{*ouboG&=;
z1ILeq)$nYzoK969)1YhhwLGT;cnQ(wH&y`zFtCtP8-Ow$o$nWxMUppTILGJ!fEG`+
z3EdZ{oRRGWaBHQk`@S_--}4LX-t!pVekjqPQQ4|9eKgI1C+0AD(&er;R@*Xey-=s=
z!AKcP^Rrmtjq3`1uu*9)#Hp1db`KN03?ttx5kl$CBLd)BC!;Zd&q|d2o*%DO^a?}U
z&XTJX?R#CX0Z=YXk3&aLO-;NP-38Uh87g3!Jnw&hIO!_ede%nld(w^hdIfX3xk@HK
zP^tO}AobN(kaD-P__>nq!E7+nIS`e&=<7C2`n*m1IT0|P9s398n|n2Ep&6UfNIQfD
z$!%sI7#m&9-z5U+=VJT%F2)q0;5RT4eZl?0WWcQlCE>db_@G3In6md}GbXw%Vm64y
z&D!_J+9T)N>?Ht~PatQ;rHzHh1)~wz%D8QKy<FOMb3h<$CfAj&X3OI{v4}M#?ndfW
zMaV`oDNTazqh;dM#lKN14HCz40q{OwGGbUD2<PpmLp%XRp3+{dAe~7J9xI=Pg<mOG
z&fQQUAHrQ;E$zO?6yV+)rP3dpQ;b8)9jle^fr4<Pd4DFQWEF4L%kqVeaKu~;a&5T7
zL`J~?l-xtnRW$1i+ZSEsBd}Gym3NWPmCuw1Bh?}b_?6<fQQOz^wpB`-;n0_SYwsvO
zgoS~yLb*JZF>v&l$ms~HUw;eXLF!%$)uIjmX{~@`){{RH%b;e7gQq+2fT3IXwZKkj
zn}1xcLM>;Xji|v+DU|eDSZ|xy0Dw@x#(#(a*{OR$7XWD@AWRZfyeAR`0#Ml57BOdb
zvOb049|4(Qu7%|d+sq_?`1f57P?h{zpV9y+7B=%O1rZe;p6{jkr)O~9AaJA8wuaj$
zeC#zICzmOgj1n1IAeKSLs|#bMh0@Eai?JiLvx5;%r<&s;MY%+<Mmn;ec13zwCc}&z
z%TGLvLQE$9nEo?r0t-t5Pc5J$BjIv?rqsMDAege`aW*v0wy5v>7!wR^Fq#Ms>QEqs
zjFAmC)le)4P88e>Jue>2Jd6TtujDNTRuo1r`!_NL{6nHBxK$h5`Lyi-qDT%-QCb|-
z39$qs-cjcv5D}tcMxZMXjgqI>#5OX`vS0G&B`=Wl_A6Rl>NclVL6Crxafh!BnJzP%
z)$)!s?<e_^$vHO_dFms!5~~g>%%R>HrrkCmj4BhW`8G_borcXZS8SPngXj*%NI}72
zso+W*NauakE{z*5{oX+u1(`g7b+eyC(obSdXb)Yb=aLcr8Z(^6C10bYHz&-rPkeO<
zmwqTHIeb-wN$zndRtmZ}aFv^i^yR9D5NAG-%jZ-#&PX<t_83YvOD2t$F7HLIb2p*X
zt~PKaN=>o$;@@ez!9oL>k<nZ|=r8Vz^dmRj3v?FNQ7NLxT_6oK$kING$5gkq!6TM)
zs-oN>?q1y8ZR&5Rq`%NN{T5--06rd?{DemnT;RK5vh;Ws<)ijiV8n3EBge7o3pVY<
zw{@Lt8SnOqm(<yxE(ThZ)2r#)9yVEzUu0WRZiQSh@FrNNmKk_Z)P$UnSx_<wFP#o-
zVr}jwJ5<>&-QF2M*@KHMQd0E$HaEhe(*^PS$-Pb^1~b^&1#X3u+nR6hj;`8&JPOA1
z4)L4hJzttUH&7sL#^2I7CstW0-aXXRt{gud9e-HszNN!5X-}I{TM;)Klkb=)`cxNl
zSGNX74Qu-<*(6r=#JiYVb~U<|+wbdH*ZY^f_FBX~oi68gs#n!;p!}h*$X?khf$h~#
zNASx+2W;D?BUkbsi(C<dGi+FCJVDQnj@fU=wwgX6=22a6PI>6$BvS!rya$GsM=(9|
z2%)JiRroGnZc78!`j&=&lJ=7QQ0voiA_+)4j{taq!Dl!|c=4T!^kYnU7;LT@yRS1G
ztKv3$#cWcvdRir-jI^a3$AME=UKvc0MbM}+DnCWT6$<Q}QK-qc-k@+^7wG6GpzW$3
zed3Vmz^pua4}nBj?yVby1*O2pdCHS&yxA}R%1aGF%}_T1YaF{gFs(2ol$(4$bT!@3
zyLj|*B^axBV|Dn6i<c&TVP7a`&Um+<Q$Z+a;i&dPe%ux-O$Rtw`Ax0pqH-v5d#<h#
zu1T?atKGTC=ygRvmrJEx2Vs=x$Yht2vL3Zb#ND%RbQz)uI0(>%^GUl~_GLk8OR=pc
zbDUoezCre7KWIJfpci~#sb)$}rmna%HDkO4=}{|yT49S(!h)&0P+HnHs9AT>KBT<q
zSb=4g#db)qj&cv1!m3bycMI?Kekmqc?q}}c=cE^#4h!~8MhWQn6v`g@OF?=KVzj8p
zG*H){2%YIzhlQO*$0SFbvy!_Lv?!|r9``3<jFaH@;$fMZuNgfS3xz6(KsNM;by6(_
z2+^3EW?Blm*rw1b;XU63wHGhE8)Z3f3fMYNV;vP4gJpf*hpJCTyBEp5td{-}e2ER@
zVrD>eCrPTmre@QDsk~PyR;A$DzlrC0gSh{7(;~>mgXkl;VgfjNV48f53-O`qgrM~E
zT_1=9nwY%<{l>euZCqV4%QejOX{(sjWXsUXj^z4R+q>QB^dflyLu6#QRb9lMOQ+{p
zSg2<V=j`qHu`u!|v1j<5dM8t<95=YHo0}@M7$yZMwrpZJ)Pbx4dlG5efD_GTwK}tu
z&HJS2R^sJX6B7zhmw^+nO6Afpda4!E>LqqYR72@lH&=$Us~oheH-_z2<-Jx$bnXBe
zKQSrPSDa<Hmp$BFH(iYXBeZjQxJ9!}`bn&qmjr(lhc>YqQlx?bxo(SYvE)Ke1}-(7
zWfJ77z!1IHh60NX<&cs$f(3{L)4gQ0&`1|+ls_^3BX*+qN9-Z2DCpA_LVIcbk<L|-
z7%!5@=pM2AyjNFP6ZtXKB_!1)elF7+KjPhuJB__Y&h)X5QJ2Sin@owdH4fv4@GU>M
zq<Ck=`Bq>z`JTpRnMjuXk!*44Xz_%K_#N_AB43IKYl{3cW}@somk$PA_B-Ze;$3x{
zgk5KkOA`ja45nlW;$a4T0XPE&X7%C9*!%St<DUKM{EFNT7t;f_YwfG|UN-}IXyrCn
zGH8V;Rj*#Uh{N2dvp(A@(YYrc(sbdAj5UH;J8JZ-TYPtq*^&SgfNdi_&U&1%ETd+U
zdhCgHjc0Yt3Sp<m86M>AIF02RFF=gY^K2+S06o4a_3cmSdIK(?duh;M;cjLUwaB$p
zyVg|OJR;TAjq5O-j?B*7%}IN%4u?o$Oj~T1XT4envu%Ii7p&kd^gf)jMa*K~BNv3f
zbwCG@*DgR}IP7&}3kP#Eq*<a6c#C?_&TbE4K@O<HTMRre1$e1R@|B61T_+y=-??U2
z54fskwxnt85AVB+0Tk!4^Vhw${)1mdS!C7$MhQ6R1y0qn3M|HKE<{Pgk_|?#t>(^I
z0tbw?jaf8a3OZ!_4nzv>k&p<3Vx1F=gyIE{n(O!9+~^WeruP?AKVBRBI!oD@B=_a!
zO1a6R{+i*p_-TEeN~l2j(>p#G!R;*9iIn5Sp%6Fc!0`C@pM*7N(mgb6)(Ox^$qu|@
za#Q67ftrkLo`qgod2Eg&AD66at)wR9Md0LlLE9ukt)Ne63>EV2HBdN!EO=B@YQ&bs
zu}aMqiqE$BqMzI2tIa+pdiu}g&HO|>?Oxy8VUrv;o<UceYh${0j$$DozjUZFXsBGp
zOw|%~he0o_S2#E^p#ALcJVyhe@+k@?1E?wa!KF57D-0=+1+IHw+{3Ia)>+gI!!OaA
zk=qQR)t`SatatJ*N(;K_Y#9LE3<moT=i{s*H{Iykzeun9c{^`M>-UeFPtQFQ*TMw-
z9^zKSQac$dn<)-S6SogrVD>Pac5R8h`;Ei`9~nGt&MjibA+LtJ4qc79=f$>zrh>+x
zn||C#y-Q_{OTUq~j7Mv1vN}e;5(9ZrRu)RI$<!g@6GJ#uIQNc~yuJzO^5gYd2?%l;
zAPsonSVrCm>x0HWYA&`+gG`+$L@+7)TI#DS?*MSfrEarCOrfYfWzelzSR~i`d{IN$
zj-a3w#w3A6G?rGx#M0gwE{EB<u9#|Yg@?NTMo6nmc)4tD?BYr~vU`}#u05yyQ@GEe
z^T;({O94y0K@vOZOG?s?hq>#*3!(G}la&-<!}l6AN0XLG5w44Vb*XYUmO-#A#~)>O
zG1=*Hi^Q_yh0ea!_c9+H%ei(wUNN5RPcSDXkP{Cnv?k(7Sn_2SQd$-Y<KW-)q=R0-
zz=nTeKfqx*i*%ikqowxPK%sO}&irsRZQ!_c{R};gJW-^4&_4MX0B?-4zp9_jWrNT2
zaX8E>^NaZ?i0&c?-FKzd&vq93-J>Z9z$oDW_|oS?xqF2G3NA-XKk0Ks<bd(3+YSyd
zksJk693aL?=UdEn!0e>S>x}M7^&4Z+AsoDLS&O8-isjv*8G>LvpHvYQZtqfqnU%2s
zh%@5xLeCN~t*X|x#a$&wj2#6-e8-u4JM#0zd-!aK%=T6O#JC{k3}+`I!S?I+W2L^8
zXfzFO;$g5=SxC^jS+`})MZj)`#`b;lzyUE9fD@9BocVPRBUU1bS4xp?JBo6t_@eT-
zUhDxD$L-fF1S)7Cb2cJ1HS{*E2{B=Sfl@Xp#SD*Knx(%23Xg2m%gR`XU=L1G<gCId
zdf*%#f&79(Utof~Cf(SH;sKF1tD0#fkJQb3g#Bjx`C+^$>j&gSTurv%>8=nxX*QEj
zNtVYiFB_Arv@At0uW+`*Lc7&K<UaGN_NzS<`tR)P<za7&9@7hh%(}U8m~eWD-_DZT
z!wuA=e&0$p@xP6F`@9|Sv|VpQcrZH*Q;vVX=(}&QEI-&q5*BVn2@`fX>geyv0BzrY
zK3q3&p40>i-TwBd0~A9=!j41So>q{&odtPSU$nKa;a15mB3##|wlfJQVj@hdcnxVp
zfsa9Kj`1fz=)^f;7)eGrq)*Q)rm;qjw*ftMv6S37tsWic*|4`|)-c@h4TwqTULVdx
z#ePSP2do$To$vmsD!140lUZ8N^F3uw&Nk&z5dd>q#tfYtsYZksg%58G7&>QDhT=LC
zrCXe*)#upX7Ni)ou_hC`x?f$>nOxB;w=i1MD&8i4xyXYTw*Gj4GSL7&^P*Rr+jZ|z
zm6@RTNINuSG?`XN5-jp1FZJA1u2cYC`C)No5}YVjcYbFI9bXJpr>T#jeK4%{HcH`O
zCMaq8on}sL;Zc!}vZsMJaOTvm$pEvf|M4p@!z*<g)Sb{EB^xPy2Eo#?hKaLUP5*q>
zWC{3e+v2l?3D)G|G43nGAl@0-i1P`TYE3jLx1J=VA$1$ry$2FEbp{A}-<EO*TI)If
z5-Z3!ghO#-3)&e(4gIfJg=GdG(~27DndP(Dgz)S2=0GL3o2j1irS)x0$w(5kL?|9}
z7OBN&jQ$_ps2Vl(D+I2+vk!pceuZ(bF;{^md04h$0|s<p9tEwM3?aik-SwJgDe}kz
z6UjQpEt>j^DMLnKg3eEyCQlY0>nYs)uLbCFcQt9RJ|mJF-6Tczs{c&bCVLK0WzhNf
znF4J*fWMp9zr_3_R|!X7AGqjm_ZfEFh-I_nt-@l6pADiuL-LP@tMA)|9lYMu2lp-b
z$-idysxvGDHrV9t-A7@9Axx6VHv^(CHe<q|u`il?bQrh%J6@lIVBQYCj!<EOzMXl~
zA;_!^IkM!dM}fkBQk>!#7N>Xb0F-TUAWLiMu`dmzlE^6TZ3aw#T4Ag_?|a7`LJqCC
zfs#+Aizj}w_j)!WKM^Cmkf65PyIUSJocs(i!uQcUXvJ0}cQ$egNbmW=vfQWjK6cbA
zARINYr}jp-pdm=m=)#DXG2+2i$R7|1%60&!FSJJ%+e?T;ZHOIZ=WZ>7XcgoY!7Khw
z7TZ4;Ir`7LzQZUMRQ|;7K8Png19&l7=YH>CYEzuZRgT%vuJmn)a`ax*dU_Hy8$zL4
zb^qBT08V3Clu;gv3vQNYe=F5YQExR36TiuR7R@uNzER_?z=9`sQ>E>EcqZ$Wzznxa
zJy-8O3JqfvTrrC@8-tTz3w=@YSuoO*B1i-Vu9N#t@+t+!1uAWTy>sGYs)^^|>+$H%
zV<h+}eJARyogF%g^Isnb35}&9u!%jBqW9alFoz@~=8Z@u@?43i(oR~#R#VhM$#KHf
zcUIKs($4=W6XdMg0M6;;=If}AS7bXMGL(>{Hp2KxY0`$xzd=rWS@j*SV4s?HP4BgI
z6=uru%JdZeL|K6R;UGIwE-N||po--JQWm@BKH4@^5x)HSGylvtA4QE-K>Z2BpVF<Z
zrHeO-r?He&i$HsI&OA<<#V`bxX+7PPFN9xI=$<y$_pG*YXk9xyQM;)i)MdKekoRnO
zG6=fOT4KwL?R8Hz4ifZru*z7p+xdfP!7L|DC<s>yN(n$q)*rT@N~NrHGx9YCx^<{b
z<VG@A`UZ6Gnz2~rX}qs8@?=S5L-+mpUE}d>L|4n>Sg*u5l;@XhQhEh!Tu2i|(@VRB
z@H-Z787vD(FHND$9S+}d6_Dt<n#MGQcp(}jnM}CNE5;q-b*Q^`GjJ#xm3LSdqIhMr
zkC|i9WxI&JNJ8)6GYxT(&Q=RfyBWs!m#z2nFk1J|ru1S@El6b>pbF(DdLUhSA-1}s
zeMVt8m9U+*?et#rbWLCyok@-kcT-g>=rZ2Tt7B+2L3!e&hXQ+1fLAD?3kEo9QN%c+
zpdOVEayejAVi=B~AM%1|U^@{Xu!{*RSe~(I<MUd5%Lv=1i`h|I19jq_m02+Ce0EVl
zqWQi0{l+TA;lq5M>yQV)NDDr)pC*cS{8HoDQB0Set*S&}JjET}=&P1JX^7RLGO>ZI
zJ3@<LeLMm&3&?5DRZ~zCwS>)yR3Yz5`QKg|ZzqME{0y^Sl+gVgDwjJ&B3tF#Ok${3
zL4af){HC70m-a>kF>*fyClf*R08;_cj$nEyH}&Y|X9Ng0{LZsKEzoeRVMkZ^OYimF
zsH*YNLKvG+>2_+lxGZB*lYg6MoEKagL>8m@(lh+(6j!;i`&kBH+?CRUHl89pK|7&6
zMJnQMI7~G~z57QO;iK=+qVcVmHlsb=%-kk)5#H}O?YOm4cX;k9dJUd65cN0#VeO1n
z`s_7cK+{hxp0wL|xt!t;<a8vrI?PD$*XgVn;@Q=1q38%}s_}G`+cHGXl1Mo-q%=#}
z*i7lY>dGmx8;QkXXbhxZzD-63);l}(o51$+u^VE6)?~Lw3|}Ud(Lrw(YgopKf#rZd
z1n1QwJhAd^=mmkKk7PQ9Vv+D(!rSo|T}X^#4(aQ><$=2PSS~yH5j3{L;PTn}`S2Ee
zlw_$0<uAI4XJ@BOU96#Po@nX!m_06r^RQvGMfj{aMoh}>Pw4&XZfi1&#^X{&$7)cC
z6hOI*`fGfqC7)mCIlIW!S*W=kS$g6_!?DyEzR70OoAHPNg-D4MdeVbzVv2CZoR%HX
z*g^?APHV8a+nDB4p{!QtrEyT3)W+YzbiTaknkqhxso4k1GZU1l3-vUL!*>hEvQHx)
zO(PjDO*zP2rC1ng)1|lj3{i3FUAPsIdhwZuRd=fig2mGKzO_N5xSKI_-mFDOXM6l=
znRTBrnyg02CSL?ij6yR)yB9E%oCLxb@lZULiazcR21qGl5Nqm$2mZS0=Pf}jyLA#b
z4mdMC$la{;ZP8E`Sn_>WrX%9@GAX%nzA4KovLTc_3Vh0=l!7W?zU5QRmGUKS0?&)Y
zS-F+e=b*-Bmpw)eMbAIVCB!8#0NvLx4@c4`8z|7U;b%H6sIwZRvmbGJvnBRjnojx#
zpfA{lKc{0vO$<{h&8M(2eY8ktI1D!Haed{Rldf9vWg)RvroD+SVls^?dM&aTQ|i6w
zki-|o6u(tuliBkY1mH}VjUFm93H?omh1Ni>Z+5e9pSy}KVPh@$rKd%nsZ{)Z@(7|2
z8SCIP_AblSatsAXv|u)|^M-!pw81w&326;MXh*38C8h$PEVMp+mTW8}IFp}kS$Y;h
z#S}>>H2rGE;ZAGCDkQo(s(5J<Si#&d!wA?Lst^QmUE|^{lI*anQYuzmFq$}+G|6jq
zA^EYsRqz5LJy(Qh?}XOB1@KO+#j|SDJg{Fwk)pMzO80c(z{YyRBKLIfVCUXQ%0qJs
z%EJ(2&6xHTX=JG-9D#`h+UzkK><;f$co|QMuhgjF20MllX<3o{PvCRmFEEY|T&5qt
z(H2YJ@Ns+%JVv2m?8*GngH5i4!(6#3{<J|{ZjBJ~jDUkHpfQhC{LV>N)w9y+D_p6+
z#o+mlyYiA6i6<VxR^&qs%qfvt>cZj{&qro)$UgDV38Y@bq2f8%<1_;G*E`YMiR3Sc
z-1AZLR14TPKQtlRM_~o$z3w^%YCDE&uc_^BM7y84L$@*UlG1C<=zD8r3^>!%o;7qy
zeVkPgxlYE*j$@7W?);CWimw|4DoW-^KiXY505Nc3qS=eOpWYRlHMR|<PNcN1E0c0a
ztnKTr=?#*_8T~Kn<W+?4A3-%;P)Up)y?s15)0o;cAWS{`iLXB9KtAhKf$foz?U<Bm
zp3N~6DL8spNnVFRa}&$xzP4pS!2SHsOCbh(!xNn}VKv?Y*Z#p(?+93S@Ex*zDwtNv
z<7-^PQEz(s7bx*iQkdfy>uF7jLSV4HI~JW(Z@fCj>rNlGMNOp4N2GfudND@dq&Bwg
zpS`s<Pv5_=nEZ5{LC{lHNIVs(AO%F55Oh~#@Y|LEE;ff+W3y*hB<RnBXKsCs)?bu_
zI<oY9SM{7h^8iY*nuV<6GN127Io6y?hzntV6bnZ5YoH@!IwW%U+9nf;cFUcTjV81A
zX=>ViBpO!%D%3JA-Gi;`(*`23O&z{ggdv7iytGy)NO@uLOFGdjGv#+N36KjD>JM`K
zDb>^m-hL|Vi?#akr!dqWDCGPRu3a1RhqS;0-k!2{Ue|L&<dT9Iu-()?mY^L#B6;{2
z!+7BO!DowzH(RgI+{L+N%J+;>Lko^5VAJP=W*Fh7z!SfdS$HnC6qG&iiph_X>Dmfx
z%0P6qMt>8{?pE5kF*ro!!4s|E2ql39XILxq8ua06n-v%)k985dHo4H=7cUv3&xAFc
zU<QVYFo*)C^fqyJH)M!1Y68$m#CprE{g+)4M;L(<X)pU1!`xa>&C4Q3&Fdu@+ie!%
zR@44H>ehzu*Ohp#zs<8MPYDYQ4+w3sYc=^84=m6S-w7f3)KwGOHIK_6`t%b1dT*F6
zb9=HG9DP;-d;Mr9%^OAiX_q4{2S%D2pmfwCUv#hr&E7<&k`F67&&2p_Ven-1L<MG^
z07<6b;3$ue82B}n!A%a9FS|D;K%EFxgc@JG!1)Mg;=P6O$$?1_qXSQF5B2%&W@Vb4
z=<;D_Fkfi5(K*?wZTiEU+{Mj$yov=fdg0CZiiqvp?aP5l>w^Ifx}^t^%F&NLMIj42
zi?Mv!xE-QS0kP38zPi=C@U8E*f*0%zO%l<3KB#uKtq&~mj18}dWjB+yR@R~luv9tg
zpav|4ZX>~Mdp5rQAJv?BIFx_C#}Of8-v-&2M#R`<Bun-^VGw3WDr7B5{H!C(Sbo_V
zYo)AXNo3!}FqX1}7(#X#m90AWsGjF{o$EZ;Ip;d(JlA>tzh|!ReP7?tclo^E?^lP?
zNKp>3((3y37;||o7-!{pwbORNfM&`E*$dKBkmdD_FvGy<1ZR5nXn;=>NASS}68f^~
zXC~NF6rZ5I@aU4Sx7!NE53zGrd}n-W#LLH@>uzphToar0v8iUB;3`iOzLSQGhgI7k
zr^ry@J}QE@Ne?kL%cqnR-lg~G{@fVmg8dD;_8nZr+!6Y2H!W-6!rXV>9}<Gev`Pzg
z4n>1C)XitN#|#>Tlnb5t*}pin9d10$y3IX&!2ofacK1he#*~vCHb7(>5Fj7l>z2z&
z>V7oI7Gs<Tc2on*d9W^*Ew*5OuU7J#Ehimb`2~}Vb)U-pn<UWQa-1Q9oGxJl;~yV<
zgx`B!74#J_*d>p27zL4p;xwN#;X4rwCv*Ag^<gcuK_=$|o-cUCF^JVlU)<>x9(`()
zoHUqg5`nJ#cu9v@MHh9tym6=RO%j$}*|Bkdv*^dJ>5nVW1ad$KLaBa4(C}zdC%BM1
zY%lWhBo7Bf<{^gkD+wIDN=W8X#X9FA5QrSROz)8x=oblFsdlB4>YWUUGoH~jW7x|~
zXfmEZP}ZIH8!e~7oZm3DlkEv*$gM5JgexG;5S8UaI+fu!{om{I2l-u&D7gJ5rDpO7
z?RpC7$dx0Jd^Y(!8)Ro`676SxpOEmU-ZCSr;>*JCH2701KDo;4u&}&DbE}Bmo3Tu*
zaS5EOZNy6#ZnQk$bYcUu$+RailvavVCKyOTrd5m9|0vYUqX+!EHTfyFm%B-3lpy_<
zFE1)KlGD9i#3*(|QQJGN)YcA9{igLGRB+~d!`))mNADjH2k2B1_wGA~OV#dP4?B(F
zcSONuKH~Iw@>vU=35IvTgxE}za0XQLpESJWeT;o94J9bAAJ`5C!~LC<3vt_T4<~xm
z6z^Cu^F`8$QWM-bwdtv%F?LCSdGO+fieZ##5ef@ia|qn9MCj-~6K>hhOrUQ;ge-=e
z$S5wizuP4V+Zp?lH6Vf>A2!BoTgRr&MKvs}XUPu~(3)GZtFKqX6L@Q=(y2{z@0PA$
zhffznBisdRdx^&~C9)Q`=3NmuBk?IjE|sRSw?Hz{8e)ReAaH4)S7$!I5GOZ6WM6+B
z>$;KcJ7`mDsXG1=!roG(x+t!{vM|vPgW&H$<m)ZYzgq#!GlsYP*;L^}V*6(7sq}X(
zbhton40tsICVVG!4A%Et50OeKM*NcQg2tsm;1*<LT$3agK;U&s2V&+pTmFq9=7JmB
zLQ95HoDRFBEL5;KW~-4n$g3Sr7m;tlpdG&JbY?`4m8dL@R7q!QMy)(pGa7VO4#y}q
zuyd$fPmb986Rmp4y8;GNAkIuNsnnV|fuFWr%JJuh$ohpq$lULvhHN4WG$!j9981{+
z{jAcDoc*oJo!|A?wldTT`aJ|OcS5PgKZS9}oNN(SN@ZlL&^LhafOvr41h2nRSuLg;
zajFxp(1pO)AIIj!$;7b(+Ag@Z_0ENjctilg^$OeM#2ALqn%1=L(%+X(!T5=BrJW`A
zk`$;Ck^j&&d<O_sGNKn7@Jrq|1N)wlrW@)|-c8F`asfvR{f>T~8=uRNm?kfce_(Ca
z9G~HqhzE{D*B!R&p_Cz(;e+5v3Q<v&r_gA*uOVqt7z$oU3|S!djlEBA8f0-bM~=Bg
zCT-bQYRAVvx0=AAMFGO(Nty%7iQ;uF=$f4BP}u|`r)cm^^m(wmUHps4_~?9IaBKKM
zlo{~t<~r}ZqgZOoaGTz;>V_{48G_$sJicVpFqPZnt}~ET^J;l3?@C^0D~Rgcy}RSl
z1c`U-NSerct@W&q>PuO}4uF$ss%p6&hAy5(HmynV1PB3&^44u?Wr3LzQ}FlKQInSi
zfEZjhDSk7Gx@lJl9_^OI(<RnZKgf_d9afciXffxKY1&?xGd$_%xU7v&yWmK4AJow`
z)y<Nw7m*r6JI9}YN^)$Ej;m-%8%dQ4H_ol#3bhhy<|UN+PLCh*zMS^yzm|_=pyCB{
zP%T}7>V^==M+&s!_Q_^$=CeVIBCsG~=ybcaaw+nShfDpj36^$#*;g)g1{ZvVp3c%9
zUofUZpW3vua;MDkdXiNI6k=B+fz-4a=!o>eDI_CNW@bKI!5V}}Scg44T_?p1Jii~k
zXC4nx>Y0AUN>J9}_AV>t^PVlFT#9bxzK)6dd-mmV#`lgW2R@(7Y-b<B4$JQM$ZEmn
z(<?_#-^m0su4K?j_il3DZoENU%XZ$>NqV@?_jt75Jx)91JT1r)`gHJg+>wMD{*MXY
z=BgE%kM3Buh|Ui!(?<MX4|v5Hm%P8HvxYczQfji%G+#3xgWnu2gIvmt8z8#Ga$Ur&
zPOmMI8<q;zW4XiYY2c<#dNGHRqS^r(T$)aGV&8hduUJu3+o7{{4!`!b#OPXfKW6t}
zL+)MFdI!m`InikT{uLFS#bD|oE@>`7@SK>ZY)cqMR@dVP`1?XYA5j3`8zsEB))g8!
zv(dWBX*GkZHX;V4_(Es1b$$?UR@$;MN^o@t{3s}Ev^yik`$qC_i5~N8sV+19@;t23
zBSHG+;{Di)zRk3o6@w_Z2ZY5Hd%)P$MXk0Sx=YqwOdgETn5@s<YAa?G%iW<;Dc=6G
z=Nf-1C{=kxrl*f<M2p<1>I|>$d*p6^>|lhY0FR<O<nFY04_opp<P%!A6ANFGG0{1P
zsU@sTeHs_A4hX8~ikWQczEebTun_IaTbul&%9yBaBZ&5%?H?p9M+}XsN|HnGD&O_@
z*>7@KhK3Jg$DZ8y;jrK1tF5Mb5on=H2fEa+bF&5!%c?6y1S{pFiB}Mzm)k`QMdnqB
z8F-_XPf2apE{oAbbu!tOv-Mo46NdOTMJ&$X`U(3kmUNmbMj_hX(SqmUyYuRMn|IZR
zMP>q0Yn!H~c7x;ZdK!}Yjlh}KmU8cGk0V+2l1)mOQ>)=4PKgp~_~qC9(xaPccl;Fh
z@082j4hG)zNky>3QrcA?{i<xN3WfC$ZZ&~6eotXeiFf*$Bj!r>PNCk=q+D)TiY$m)
zW`(_k9&={jLfY!#r3`9~LP;aDYvN)U-jyL{r{@Aelxyuktl$Xn^29^ThG?{M{7^Dq
zDI-Ir-6e$}nz#gHBY!`Qq#oU@NV0?x(Oj`zhD}=;b;7LRhH&2t-{+4bKO8M^_vj_;
z3(1J+6eWy+)kNkPBqAQ9>%mH^n0fD190_}lbbY1uh@c30At4R>%Djr7KDG23njEF@
za510c<cFOSilIER+0cZyw?^)ROCM;^;ISOd=J(1gg|MCJ`lS%pnN#GfM&^Uj)o-or
zp41xAep}&Zqc6Q&0T|y$v77|+xJqoR1ei%Rc}P`l`8-_?J=^4V{s`~bEK9l)plTAw
zgwCB~ls4?H`cxSDJUt%85G8G)0#kuYG69{=z@9ayD=C~Z{We@qy^DaN<B+-gT9tlD
zekgyQhSpUFZnQ(7N1cM4Ff{66Mmb=G%uK{i2!ZfeciGcPGUO@jyb(Ow?RH`vn(N{e
zJZvXY<xzRliHdzEOISa`SB!+ERb*EOtW{XmX#4pw5~u4>EN!RKHj!*Qh>xiFXiH|l
z<kDRvpAp13xhSw5f>GFDNo8fr+0@TA|DOJ_*RxMO;D9zY2g{b1n1m<g$0bkksyTWH
zdOcoPwoP$~KFCYX|F9$3{^zSD4l;Owa()D~jirQ{BiHMLPB4TI$e{#z2d~J-FJ~O&
z&s|zJIo*fzjT$n6bVEdt%-0w!wnafPT#LGu1iH*+(9_B{Sx^XOh69wty3;o)N7>!T
zl0yz$a0IaW&(BGl52-v&SMm1sU4GWON@CD>6iWv)dVP<;ZvK(8$h&n<H#4o3vUz$}
z4e#Pm=Hgr>h4EAyzixX+Tfg;PB-M=<r>sOJ10cQoP<-Q?m(gEQTgwEy>SKZ2RuScC
zp*1K-E*4SshQk$+{@hpl1molMernp(lg%hy=2X+2w=lgu+k}c)4WxB{kfdNeKJn%l
zouQ`MG<2Y`D1|dd!3w=SDqHqoK$qeU;DUaW?>e2q+M12Sl06b{fGHd8OJaCMK(leh
z?%4a+(rdWB*vPwtS8UqQ5=EWvUAJ;czt)UfL`FG?9W6=3ie(htG|Zy~rjN0iJUW9J
zA?}m{?Fnnqr&(BzE0iE=3;0W`If}YHmB$rkd=(tHe(ToR5_Bv7xLaARtquQAg*=3E
z2?ZpzrsX54exWH!O@MzaskSdm`RUI_+y+L9Gq!*yn$u#1B7!bE6%Cp%C~@(<T$j|k
zR$ar{ve)&xN9)nbugfjzvg*5b?%t&Le3w*a;bv~=S0hDjHv=!<ct>ih7ju+x9-W`q
zqSH)&=G6Lv{)i9=)n`HkyiWkaNBSZ&`mFfax~Qk&{MzvszD!&T1&f-rU?2DFOiiFU
z{Fh0-;aHNZ`&&VPDc~4yZ3mR)wRZW>eiAVYK(}lG6_|)6=Q<3>-el#mAUJW)vaRoN
zmuGdjC`;u`2C=>zuFF$fOtu&~>AG(H=|x4*xqShIX^I?PRnDV4a_!@>m-taARhV)6
z!~!K_ntNts*6PIE8sHYyJG9*9alLx4Fphr6iwVUl{XlO{9V8tO$}+R+!v`d%98~={
zX_Dr3wj1R@!U2V9i_LKmoom&koO*x^<$yn!_horUC+y&3;V2Vjpcz)~tb@R(G_Uso
z%TK;p?G31LuKT>+d<G$daJt89D}O1QQ-b-=pXKp?t-PxlitMFaB#R930(s<J!|Kw)
zo>uL1e!e859*UreK-W*Wqdg`kx2P%}<6a8@Bm%L+>jKHlqGF2MF$YzZJk82x_kr+e
zOpmtkaZXX{ALJBI^B8=N7~0mp8t?q%A+H@5H}YXb+0aU<x$=bQBaD5AZF_lIJv8b>
zWT^2J5b3afVt2S+ZF-rKlo$&`S55@617rdQ#RJWWWV*jV3DCS6lZ|oqI+F|GN6c(O
z$%zVX-*2#W`c!st*p*In#$h2M9rw6IONBz;>isnw*+U#jJy3BKw#7N0qrl<weB&?P
zz2#CT9Q<_(8WW$5Ofr*)&`jkDgU}J!EOFR9D<C}&YKeee4LiIg$zs_qmF=#;2RIwO
z90#HF4OpQhMOYiEpzV$%AB3kV!lTpt;j5RzTkK<Qq)v;K9Qm?)>Cza+X=X31jhksF
z=WF8`j}y%u46w(B-@bVNCKiCD2!<!xZnd3sbXT_&&1d>xhu57B=2bh@#%_HzY3as?
zn{r01Q?0u1_7!I%L_sBH_i1Aovcf(sCP~OPwcj@;P1;)|ibtlMf6N`N^N9X6CPh7G
z{-|R!qK@wSAj~X;iw3zvo4(>Self|!Xcgxvw^D8JuqTlkKop23Kh|ro=9+i#pDtdT
zAsn4Mj%)yB2j4h19d<A*4#?7r{RS}#bAS_e15QcPacwY|1p{MMZ3y!8`!P7$#?sC-
zK(Z$v?Nkx<8X7=wY3%J?mU31`Z6nemfbFHsuCDAYyV&+h&K+uSrr+RCG>_6<gWbx6
zAW2LVg?bTsXBeOzs84?6uu2v{5)j%3G<KtM!;dThk1b5n(WPF3<z`{>hju7kzf&M>
ziR&EGSds&>QH(TFW||w5@Cd6M4PIx3UZ~AzlAH#S<gDYquVJ$XNM;#UvD1LV#6+Lz
z=~VF$<}QR1sQ9f0&nNY)R~rFmT6XH|s!JSHC-Av}TTTAn!`htehZ`>)+fK7CMUsLz
z#xWGE)=8w-0=49UkzK8QNpz>KNG1(b1d?!9h+$wkleCS+BZF3YZN7PLw^5(@gIl@J
z=`C%EhUVSbps$Z<Iz8i+8YTx~v=}ec07;+CB&kBkc0=InO;Rjy&O`n~uW*9opxWX3
z;A4wYzP+KncFtxqY|P2Xc_d>X{BlS;OV}fsk@p2|i?r`G83CBW{PB(T@<|EWRQfOa
z#}pb#6`*gX{RhQT-ggKOTo~>VW*Y0z9+R+X$^VOG(3bI&Wl$+3M)4ki8Nh3OP;1HL
zoC`;vS^83!*^%(baHme$*&cu&!JAN62XzfwCpr0PR!K2e!1@Fr4%!vJ9bL(e&k-%~
zV9$=smn579wY^YjhGE~BDIKTR3rO>3_Y8tzwFNl3i1yg|nk84pw5leO%v`U@!FIS@
zQlAPy^H{;1x(%lFjw^+nJj&ckL%6o-6fW&X1D3HLNI|6)dv`MH)-<W49;bc^f$oKT
z%xLFvM2HlyCwYvFJ7<6PG|6e@4FKR*PiORKk@u5x-bF9Ej_OXM&ydsNltO{dtxwE9
zSfHjiDhkekq)DCAX9Cd8z^Xx5?XgelM1bAu8tIh!&&$XEM-kz_#Kf;CiiN$s^gHZN
z1MI3A?f-Q&K&S%AOe=zm_g^r;)CF+q478XuSI11H9ykEyU8opEApNr+P0gbHxVTrq
zNVhBr>|i;our^*{n!V<30bFp{(Xt=t)o=lr2d?Y@0p;7<ieLpJIj{~eJ=9Gpes!%|
zNe%MSfBk^|y5SrUlim0$%))I#MoQ#jf?Ee48YcO?;09d@2`_~)u=jZ_+C{Qd?QcYr
z_UT~C+IP1~#sI<Ke$C>y=~~$en})j{XXQc`R4Y26%Xj7-?!2{>d;QWRW3AJ}F32BP
zB<5>IO(bgELBxw~P@veJ7v;PQg~qD6B)!Ln+%^mv_scnDDl!yB*4GUPS(n#=V3T;V
zRlFLuQ8biFxb={H?M%-ebP~vWbHs(c-OvRD0Dj&r(ZzYdNN4<s6y$EYWTwnUI-`A~
zai75E_eLQPBR{`)0zB;SxVz<+hRtTAqqY#P@YCXD33Fi*?<t<FqkPJ}+BkDIGQcrO
z9e5OgO&qcyCL$`>ud%r-?DR`Zlj4iJ#to}W3gcHT+-oPVTfRI5XpC3are4~l&Sd|j
zHQJ9w^am@~yaGjCd<CqQe&nB)5fp`uR}^RbMx6lMNI2^TbHQL|5s6oMfxBvc<R`Jx
zQ``Bz4S?hN=;}-+;0cWAxYo@QfaK+c;O<`>0X+l>l0qKRNZPhYkEmY&D&zAW*RS}W
zKqxto2Ruo(Q~UGysZQ~kbW&b$b^m=}Jqf%Rn5=i|_e$~x09=|U<W~N!G_X42kq_s{
z6LO^3{VaR4@iIH5VbvvZ?=_fd+3*7!_t~Y4L5rB$E!7t~M3>5-ELU#vS6vSh!322E
z2|-5RsapHm=8lV}Yqz#bS5>X6W84nkHCs|%|7<h{5G(Q39S}>?_<t#~;(v-I1Yi|3
z-2_%-S`!c=r036H6fE=X=kZei<S|PgVjDd5#UtPZ1LXTLuaa6`r(()uazsfwkfh`F
zcQoGJc-IKg$~}fKlx+<S*x`!Ns~>)Twc`&68(5x1CKsRS`3vpwKONKm6qN`}y8m0?
zWvH=K!+O;doy)R+13HQfg|`BbSFa!|yXo80b(Qdz;Gl#8`eykO+40xo2Mo8zY0Q5j
zD~IogC;Y;ChEFMIz9FcV)YW>{yq{Zm=J5gAhj@wt4y4ChXWmJmT)4O6eluiR5kR?w
zb8%_@tS*62ZlGLlwaOL$E|+k?=mNTajplc`+yctw89Dyh?{WbF8?j7!lHl)+`5C}B
zDLkoK_)Clwfu;lZL4?l#<^U!>6ql4|u5b{4vSe>v$+tHz^K5wM_GaW=b0LeH^}VUT
zlNssxg9iWrpv6b?m$3uY&sfvCfnDq-!%xK);N#Y;^LPCF8Ma2e`ZiOd0#BNFuz@dk
zz%Gk&3;$H+D{$%kKc+p_bv+1&M(M}ce;ET-G@~I)=I(=Ij%>t+UG#O!X>5?Sww#rf
z69CoaAf^nM1r?sNJ6KY9MnV<^q>q=|XK}iGB$8D2^3S}l0%CunKpm%E#;9YKZ&`U4
q?W@A#E`R>;-(j}?|F7chA7suNj(0)*Pj8dJ-TK-lm&!E}VgCl|*mTGM


From 2b0ada132199c295b1ef9ec6733d17128f57fde2 Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Mon, 27 Sep 2021 13:05:13 -0400
Subject: [PATCH 14/15] clearing cpp lint warnings

---
 week4/softwareEng_9_4/app/softwareEng_9_4.cpp     | 6 ++++--
 week4/softwareEng_9_4/include/softwareEng_9_4.hpp | 3 ++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/week4/softwareEng_9_4/app/softwareEng_9_4.cpp b/week4/softwareEng_9_4/app/softwareEng_9_4.cpp
index 3c5aa520..72a91a25 100644
--- a/week4/softwareEng_9_4/app/softwareEng_9_4.cpp
+++ b/week4/softwareEng_9_4/app/softwareEng_9_4.cpp
@@ -13,7 +13,8 @@
  * printPostion method enable code resuablity and extraction mechanism 
  * this extracted method is used to find and print position
  */
-void printer::printPosition(int text_length, int array_to_search1_length, char* text, char* array_to_search1, int position1) {
+void printer::printPosition(int text_length, int array_to_search1_length,
+char* text, char* array_to_search1, int position1) {
 int i, j;
 for (i = 0; i < text_length - array_to_search1_length + 1; i++) {
   bool found = true;
@@ -45,7 +46,8 @@ int printer::input() {
     std::cout<< "Enter the length of search element: ";
     std::cin>> array_to_search1_length;
     int position1 = -1;
-    printPosition(text_length, array_to_search1_length, text, array_to_search1, position1);
+    printPosition(text_length, array_to_search1_length,
+    text, array_to_search1, position1);
     return position1;
 }
 
diff --git a/week4/softwareEng_9_4/include/softwareEng_9_4.hpp b/week4/softwareEng_9_4/include/softwareEng_9_4.hpp
index 7a11c7fc..b0f80120 100644
--- a/week4/softwareEng_9_4/include/softwareEng_9_4.hpp
+++ b/week4/softwareEng_9_4/include/softwareEng_9_4.hpp
@@ -27,7 +27,8 @@
 class printer {
  public:
     int input();
-    void printPosition(int t_length, int a_length_search, char* text,char* array_to_search1, int position);
+    void printPosition(int t_length, int a_length_search, char* text,
+    char* array_to_search1, int position);
     printer();
 };
 

From 30089e8daf0efb3604fd73376d593985415cd7a8 Mon Sep 17 00:00:00 2001
From: Sumedh Reddy <sumedhreddykoppula@gmail.com>
Date: Mon, 27 Sep 2021 14:45:47 -0400
Subject: [PATCH 15/15] Adding Doxygen files

---
 week4/Doxy_SumedhKoppula_117386066pdf.pdf     |  Bin 0 -> 93018 bytes
 week4/softwareEng_9_4/app/Doxyfile            | 2579 +++++++++++++++++
 week4/softwareEng_9_4/app/doxygen_log.txt     |  130 +
 week4/softwareEng_9_4/app/html/annotated.html |   82 +
 week4/softwareEng_9_4/app/html/bc_s.png       |  Bin 0 -> 676 bytes
 week4/softwareEng_9_4/app/html/bdwn.png       |  Bin 0 -> 147 bytes
 week4/softwareEng_9_4/app/html/classes.html   |   88 +
 .../app/html/classprinter-members.html        |   83 +
 .../app/html/classprinter.html                |  189 ++
 week4/softwareEng_9_4/app/html/closed.png     |  Bin 0 -> 132 bytes
 week4/softwareEng_9_4/app/html/doc.png        |  Bin 0 -> 746 bytes
 week4/softwareEng_9_4/app/html/doxygen.css    | 1771 +++++++++++
 week4/softwareEng_9_4/app/html/doxygen.png    |  Bin 0 -> 3779 bytes
 week4/softwareEng_9_4/app/html/dynsections.js |  120 +
 week4/softwareEng_9_4/app/html/files.html     |   83 +
 .../softwareEng_9_4/app/html/folderclosed.png |  Bin 0 -> 616 bytes
 week4/softwareEng_9_4/app/html/folderopen.png |  Bin 0 -> 597 bytes
 week4/softwareEng_9_4/app/html/functions.html |   84 +
 .../app/html/functions_func.html              |   84 +
 week4/softwareEng_9_4/app/html/globals.html   |   78 +
 .../app/html/globals_func.html                |   78 +
 .../softwareEng_9_4/app/html/graph_legend.dot |   23 +
 .../app/html/graph_legend.html                |  137 +
 week4/softwareEng_9_4/app/html/index.html     |   77 +
 week4/softwareEng_9_4/app/html/jquery.js      |   35 +
 week4/softwareEng_9_4/app/html/menu.js        |   50 +
 week4/softwareEng_9_4/app/html/menudata.js    |   35 +
 week4/softwareEng_9_4/app/html/nav_f.png      |  Bin 0 -> 153 bytes
 week4/softwareEng_9_4/app/html/nav_g.png      |  Bin 0 -> 95 bytes
 week4/softwareEng_9_4/app/html/nav_h.png      |  Bin 0 -> 98 bytes
 week4/softwareEng_9_4/app/html/open.png       |  Bin 0 -> 123 bytes
 .../app/html/search/all_0.html                |   30 +
 .../softwareEng_9_4/app/html/search/all_0.js  |    4 +
 .../app/html/search/all_1.html                |   30 +
 .../softwareEng_9_4/app/html/search/all_1.js  |    4 +
 .../app/html/search/all_2.html                |   30 +
 .../softwareEng_9_4/app/html/search/all_2.js  |    5 +
 .../app/html/search/all_3.html                |   30 +
 .../softwareEng_9_4/app/html/search/all_3.js  |    5 +
 .../app/html/search/classes_0.html            |   30 +
 .../app/html/search/classes_0.js              |    4 +
 .../softwareEng_9_4/app/html/search/close.png |  Bin 0 -> 273 bytes
 .../app/html/search/files_0.html              |   30 +
 .../app/html/search/files_0.js                |    5 +
 .../app/html/search/functions_0.html          |   30 +
 .../app/html/search/functions_0.js            |    4 +
 .../app/html/search/functions_1.html          |   30 +
 .../app/html/search/functions_1.js            |    4 +
 .../app/html/search/functions_2.html          |   30 +
 .../app/html/search/functions_2.js            |    5 +
 .../app/html/search/mag_sel.png               |  Bin 0 -> 465 bytes
 .../app/html/search/nomatches.html            |   12 +
 .../app/html/search/search.css                |  271 ++
 .../softwareEng_9_4/app/html/search/search.js |  814 ++++++
 .../app/html/search/search_l.png              |  Bin 0 -> 567 bytes
 .../app/html/search/search_m.png              |  Bin 0 -> 158 bytes
 .../app/html/search/search_r.png              |  Bin 0 -> 553 bytes
 .../app/html/search/searchdata.js             |   24 +
 .../app/html/software_eng__9__4_8cpp.html     |  109 +
 .../html/software_eng__9__4_8cpp__incl.dot    |   17 +
 .../app/html/software_eng__9__4_8hpp.html     |  104 +
 .../software_eng__9__4_8hpp__dep__incl.dot    |    9 +
 .../html/software_eng__9__4_8hpp__incl.dot    |   15 +
 .../html/software_eng__9__4_8hpp_source.html  |  102 +
 week4/softwareEng_9_4/app/html/splitbar.png   |  Bin 0 -> 314 bytes
 week4/softwareEng_9_4/app/html/sync_off.png   |  Bin 0 -> 853 bytes
 week4/softwareEng_9_4/app/html/sync_on.png    |  Bin 0 -> 845 bytes
 week4/softwareEng_9_4/app/html/tab_a.png      |  Bin 0 -> 142 bytes
 week4/softwareEng_9_4/app/html/tab_b.png      |  Bin 0 -> 169 bytes
 week4/softwareEng_9_4/app/html/tab_h.png      |  Bin 0 -> 177 bytes
 week4/softwareEng_9_4/app/html/tab_s.png      |  Bin 0 -> 184 bytes
 week4/softwareEng_9_4/app/html/tabs.css       |    1 +
 week4/softwareEng_9_4/app/latex/Makefile      |   23 +
 week4/softwareEng_9_4/app/latex/annotated.tex |    4 +
 .../app/latex/classprinter.tex                |   61 +
 week4/softwareEng_9_4/app/latex/doxygen.sty   |  576 ++++
 week4/softwareEng_9_4/app/latex/files.tex     |    5 +
 .../app/latex/longtable_doxygen.sty           |  448 +++
 week4/softwareEng_9_4/app/latex/refman.tex    |  193 ++
 week4/softwareEng_9_4/app/latex/result.zip    |  Bin 0 -> 41464 bytes
 .../app/latex/software_eng__9__4_8cpp.tex     |    4 +
 .../app/latex/software_eng__9__4_8cpp.tex.tmp |   19 +
 .../latex/software_eng__9__4_8cpp__incl.dot   |   17 +
 .../app/latex/software_eng__9__4_8hpp.tex     |   15 +
 .../software_eng__9__4_8hpp__dep__incl.dot    |    9 +
 .../latex/software_eng__9__4_8hpp__incl.dot   |   15 +
 .../app/latex/tabu_doxygen.sty                | 2557 ++++++++++++++++
 87 files changed, 11540 insertions(+)
 create mode 100644 week4/Doxy_SumedhKoppula_117386066pdf.pdf
 create mode 100644 week4/softwareEng_9_4/app/Doxyfile
 create mode 100644 week4/softwareEng_9_4/app/doxygen_log.txt
 create mode 100644 week4/softwareEng_9_4/app/html/annotated.html
 create mode 100644 week4/softwareEng_9_4/app/html/bc_s.png
 create mode 100644 week4/softwareEng_9_4/app/html/bdwn.png
 create mode 100644 week4/softwareEng_9_4/app/html/classes.html
 create mode 100644 week4/softwareEng_9_4/app/html/classprinter-members.html
 create mode 100644 week4/softwareEng_9_4/app/html/classprinter.html
 create mode 100644 week4/softwareEng_9_4/app/html/closed.png
 create mode 100644 week4/softwareEng_9_4/app/html/doc.png
 create mode 100644 week4/softwareEng_9_4/app/html/doxygen.css
 create mode 100644 week4/softwareEng_9_4/app/html/doxygen.png
 create mode 100644 week4/softwareEng_9_4/app/html/dynsections.js
 create mode 100644 week4/softwareEng_9_4/app/html/files.html
 create mode 100644 week4/softwareEng_9_4/app/html/folderclosed.png
 create mode 100644 week4/softwareEng_9_4/app/html/folderopen.png
 create mode 100644 week4/softwareEng_9_4/app/html/functions.html
 create mode 100644 week4/softwareEng_9_4/app/html/functions_func.html
 create mode 100644 week4/softwareEng_9_4/app/html/globals.html
 create mode 100644 week4/softwareEng_9_4/app/html/globals_func.html
 create mode 100644 week4/softwareEng_9_4/app/html/graph_legend.dot
 create mode 100644 week4/softwareEng_9_4/app/html/graph_legend.html
 create mode 100644 week4/softwareEng_9_4/app/html/index.html
 create mode 100644 week4/softwareEng_9_4/app/html/jquery.js
 create mode 100644 week4/softwareEng_9_4/app/html/menu.js
 create mode 100644 week4/softwareEng_9_4/app/html/menudata.js
 create mode 100644 week4/softwareEng_9_4/app/html/nav_f.png
 create mode 100644 week4/softwareEng_9_4/app/html/nav_g.png
 create mode 100644 week4/softwareEng_9_4/app/html/nav_h.png
 create mode 100644 week4/softwareEng_9_4/app/html/open.png
 create mode 100644 week4/softwareEng_9_4/app/html/search/all_0.html
 create mode 100644 week4/softwareEng_9_4/app/html/search/all_0.js
 create mode 100644 week4/softwareEng_9_4/app/html/search/all_1.html
 create mode 100644 week4/softwareEng_9_4/app/html/search/all_1.js
 create mode 100644 week4/softwareEng_9_4/app/html/search/all_2.html
 create mode 100644 week4/softwareEng_9_4/app/html/search/all_2.js
 create mode 100644 week4/softwareEng_9_4/app/html/search/all_3.html
 create mode 100644 week4/softwareEng_9_4/app/html/search/all_3.js
 create mode 100644 week4/softwareEng_9_4/app/html/search/classes_0.html
 create mode 100644 week4/softwareEng_9_4/app/html/search/classes_0.js
 create mode 100644 week4/softwareEng_9_4/app/html/search/close.png
 create mode 100644 week4/softwareEng_9_4/app/html/search/files_0.html
 create mode 100644 week4/softwareEng_9_4/app/html/search/files_0.js
 create mode 100644 week4/softwareEng_9_4/app/html/search/functions_0.html
 create mode 100644 week4/softwareEng_9_4/app/html/search/functions_0.js
 create mode 100644 week4/softwareEng_9_4/app/html/search/functions_1.html
 create mode 100644 week4/softwareEng_9_4/app/html/search/functions_1.js
 create mode 100644 week4/softwareEng_9_4/app/html/search/functions_2.html
 create mode 100644 week4/softwareEng_9_4/app/html/search/functions_2.js
 create mode 100644 week4/softwareEng_9_4/app/html/search/mag_sel.png
 create mode 100644 week4/softwareEng_9_4/app/html/search/nomatches.html
 create mode 100644 week4/softwareEng_9_4/app/html/search/search.css
 create mode 100644 week4/softwareEng_9_4/app/html/search/search.js
 create mode 100644 week4/softwareEng_9_4/app/html/search/search_l.png
 create mode 100644 week4/softwareEng_9_4/app/html/search/search_m.png
 create mode 100644 week4/softwareEng_9_4/app/html/search/search_r.png
 create mode 100644 week4/softwareEng_9_4/app/html/search/searchdata.js
 create mode 100644 week4/softwareEng_9_4/app/html/software_eng__9__4_8cpp.html
 create mode 100644 week4/softwareEng_9_4/app/html/software_eng__9__4_8cpp__incl.dot
 create mode 100644 week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp.html
 create mode 100644 week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp__dep__incl.dot
 create mode 100644 week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp__incl.dot
 create mode 100644 week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp_source.html
 create mode 100644 week4/softwareEng_9_4/app/html/splitbar.png
 create mode 100644 week4/softwareEng_9_4/app/html/sync_off.png
 create mode 100644 week4/softwareEng_9_4/app/html/sync_on.png
 create mode 100644 week4/softwareEng_9_4/app/html/tab_a.png
 create mode 100644 week4/softwareEng_9_4/app/html/tab_b.png
 create mode 100644 week4/softwareEng_9_4/app/html/tab_h.png
 create mode 100644 week4/softwareEng_9_4/app/html/tab_s.png
 create mode 100644 week4/softwareEng_9_4/app/html/tabs.css
 create mode 100644 week4/softwareEng_9_4/app/latex/Makefile
 create mode 100644 week4/softwareEng_9_4/app/latex/annotated.tex
 create mode 100644 week4/softwareEng_9_4/app/latex/classprinter.tex
 create mode 100644 week4/softwareEng_9_4/app/latex/doxygen.sty
 create mode 100644 week4/softwareEng_9_4/app/latex/files.tex
 create mode 100644 week4/softwareEng_9_4/app/latex/longtable_doxygen.sty
 create mode 100644 week4/softwareEng_9_4/app/latex/refman.tex
 create mode 100644 week4/softwareEng_9_4/app/latex/result.zip
 create mode 100644 week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp.tex
 create mode 100644 week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp.tex.tmp
 create mode 100644 week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp__incl.dot
 create mode 100644 week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp.tex
 create mode 100644 week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp__dep__incl.dot
 create mode 100644 week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp__incl.dot
 create mode 100644 week4/softwareEng_9_4/app/latex/tabu_doxygen.sty

diff --git a/week4/Doxy_SumedhKoppula_117386066pdf.pdf b/week4/Doxy_SumedhKoppula_117386066pdf.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..dc06cbb14cc0199da8bf36390433d11dee1e799f
GIT binary patch
literal 93018
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

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/Doxyfile b/week4/softwareEng_9_4/app/Doxyfile
new file mode 100644
index 00000000..3eba6c4d
--- /dev/null
+++ b/week4/softwareEng_9_4/app/Doxyfile
@@ -0,0 +1,2579 @@
+# Doxyfile 1.8.17
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the configuration
+# file that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
+# The default value is: UTF-8.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+# double-quotes, unless you are using Doxywizard) that should identify the
+# project for which the documentation is generated. This name is used in the
+# title of most generated pages and in a few other places.
+# The default value is: My Project.
+
+PROJECT_NAME           = PrintPosition
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+# could be handy for archiving the generated documentation or if some version
+# control system is used.
+
+PROJECT_NUMBER         =
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer a
+# quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          = "Extract Position"
+
+# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
+# in the documentation. The maximum height of the logo should not exceed 55
+# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
+# the logo to the output directory.
+
+PROJECT_LOGO           =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+# into which the generated documentation will be written. If a relative path is
+# entered, it will be relative to the location where doxygen was started. If
+# left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = /home/ubu/Downloads/week4/week4/softwareEng_9_4/app
+
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
+# directories (in 2 levels) under the output directory of each output format and
+# will distribute the generated files over these directories. Enabling this
+# option can be useful when feeding doxygen a huge amount of source files, where
+# putting all generated files in the same directory would otherwise causes
+# performance problems for the file system.
+# The default value is: NO.
+
+CREATE_SUBDIRS         = NO
+
+# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
+# characters to appear in the names of generated files. If set to NO, non-ASCII
+# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
+# U+3044.
+# The default value is: NO.
+
+ALLOW_UNICODE_NAMES    = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
+# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
+# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
+# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
+# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
+# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
+# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
+# Ukrainian and Vietnamese.
+# The default value is: English.
+
+OUTPUT_LANGUAGE        = English
+
+# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all generated output in the proper direction.
+# Possible values are: None, LTR, RTL and Context.
+# The default value is: None.
+
+OUTPUT_TEXT_DIRECTION  = None
+
+# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
+# descriptions after the members that are listed in the file and class
+# documentation (similar to Javadoc). Set to NO to disable this.
+# The default value is: YES.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
+# description of a member or function before the detailed description
+#
+# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+# The default value is: YES.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator that is
+# used to form the text in various listings. Each string in this list, if found
+# as the leading text of the brief description, will be stripped from the text
+# and the result, after processing the whole list, is used as the annotated
+# text. Otherwise, the brief description is used as-is. If left blank, the
+# following values are used ($name is automatically replaced with the name of
+# the entity):The $name class, The $name widget, The $name file, is, provides,
+# specifies, contains, represents, a, an and the.
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# doxygen will generate a detailed section even if there is only a brief
+# description.
+# The default value is: NO.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+# The default value is: NO.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
+# before files name in the file list and in the header files. If set to NO the
+# shortest path that makes the file name unique will be used
+# The default value is: YES.
+
+FULL_PATH_NAMES        = YES
+
+# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+# Stripping is only done if one of the specified strings matches the left-hand
+# part of the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the path to
+# strip.
+#
+# Note that you can specify absolute paths here, but also relative paths, which
+# will be relative from the directory where doxygen is started.
+# This tag requires that the tag FULL_PATH_NAMES is set to YES.
+
+STRIP_FROM_PATH        =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+# path mentioned in the documentation of a class, which tells the reader which
+# header file to include in order to use a class. If left blank only the name of
+# the header file containing the class definition is used. Otherwise one should
+# specify the list of include paths that are normally passed to the compiler
+# using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+# less readable) file names. This can be useful is your file systems doesn't
+# support long names like on DOS, Mac, or CD-ROM.
+# The default value is: NO.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+# first line (until the first dot) of a Javadoc-style comment as the brief
+# description. If set to NO, the Javadoc-style will behave just like regular Qt-
+# style comments (thus requiring an explicit @brief command for a brief
+# description.)
+# The default value is: NO.
+
+JAVADOC_AUTOBRIEF      = YES
+
+# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
+# such as
+# /***************
+# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
+# Javadoc-style will behave just like regular comments and it will not be
+# interpreted by doxygen.
+# The default value is: NO.
+
+JAVADOC_BANNER         = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+# line (until the first dot) of a Qt-style comment as the brief description. If
+# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+# requiring an explicit \brief command for a brief description.)
+# The default value is: NO.
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
+# a brief description. This used to be the default behavior. The new default is
+# to treat a multi-line C++ comment block as a detailed description. Set this
+# tag to YES if you prefer the old behavior instead.
+#
+# Note that setting this tag to YES also means that rational rose comments are
+# not recognized any more.
+# The default value is: NO.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+# documentation from any documented member that it re-implements.
+# The default value is: YES.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
+# page for each member. If set to NO, the documentation of a member will be part
+# of the file/class/namespace that contains it.
+# The default value is: NO.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+# uses this value to replace tabs by spaces in code fragments.
+# Minimum value: 1, maximum value: 16, default value: 4.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that act as commands in
+# the documentation. An alias has the form:
+# name=value
+# For example adding
+# "sideeffect=@par Side Effects:\n"
+# will allow you to put the command \sideeffect (or @sideeffect) in the
+# documentation, which will result in a user-defined paragraph with heading
+# "Side Effects:". You can put \n's in the value part of an alias to insert
+# newlines (in the resulting output). You can put ^^ in the value part of an
+# alias to insert a newline as if a physical newline was in the original file.
+# When you need a literal { or } or , in the value part of an alias you have to
+# escape them by means of a backslash (\), this can lead to conflicts with the
+# commands \{ and \} for these it is advised to use the version @{ and @} or use
+# a double escape (\\{ and \\})
+
+ALIASES                =
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding "class=itcl::class"
+# will allow you to use the command class in the itcl::class meaning.
+
+TCL_SUBST              =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+# only. Doxygen will then generate output that is more tailored for C. For
+# instance, some of the names that are used will be different. The list of all
+# members will be omitted, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+# Python sources only. Doxygen will then generate output that is more tailored
+# for that language. For instance, namespaces will be presented as packages,
+# qualified scopes will look different, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources. Doxygen will then generate output that is tailored for Fortran.
+# The default value is: NO.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for VHDL.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
+# sources only. Doxygen will then generate output that is more tailored for that
+# language. For instance, namespaces will be presented as modules, types will be
+# separated into more groups, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_SLICE  = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension, and
+# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
+# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice,
+# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
+# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
+# tries to guess whether the code is fixed or free formatted code, this is the
+# default for Fortran type files), VHDL, tcl. For instance to make doxygen treat
+# .inc files as Fortran files (default is PHP), and .f files as C (default is
+# Fortran), use: inc=Fortran f=C.
+#
+# Note: For files without extension you can use no_extension as a placeholder.
+#
+# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+# the files are not read by doxygen.
+
+EXTENSION_MAPPING      =
+
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
+# documentation. See https://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
+
+MARKDOWN_SUPPORT       = YES
+
+# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
+# to that level are automatically included in the table of contents, even if
+# they do not have an id attribute.
+# Note: This feature currently applies only to Markdown headings.
+# Minimum value: 0, maximum value: 99, default value: 5.
+# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
+
+TOC_INCLUDE_HEADINGS   = 5
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should set this
+# tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string);
+# versus func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+# The default value is: NO.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+# The default value is: NO.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
+# will parse them like normal C++ but will assume all classes use public instead
+# of private inheritance when no explicit protection keyword is present.
+# The default value is: NO.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES will make
+# doxygen to replace the get and set methods by a property in the documentation.
+# This will only work if the methods are indeed getting or setting a simple
+# type. If this is not the case, or you want to show the methods anyway, you
+# should set this option to NO.
+# The default value is: YES.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+# The default value is: NO.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# If one adds a struct or class to a group and this option is enabled, then also
+# any nested class or struct is added to the same group. By default this option
+# is disabled and one has to add nested compounds explicitly via \ingroup.
+# The default value is: NO.
+
+GROUP_NESTED_COMPOUNDS = NO
+
+# Set the SUBGROUPING tag to YES to allow class member groups of the same type
+# (for instance a group of public functions) to be put as a subgroup of that
+# type (e.g. under the Public Functions section). Set it to NO to prevent
+# subgrouping. Alternatively, this can be done per class using the
+# \nosubgrouping command.
+# The default value is: YES.
+
+SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+# are shown inside the group in which they are included (e.g. using \ingroup)
+# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+# and RTF).
+#
+# Note that this feature does not work in combination with
+# SEPARATE_MEMBER_PAGES.
+# The default value is: NO.
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+# with only public data fields or simple typedef fields will be shown inline in
+# the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO, structs, classes, and unions are shown on a separate page (for HTML and
+# Man pages) or section (for LaTeX and RTF).
+# The default value is: NO.
+
+INLINE_SIMPLE_STRUCTS  = NO
+
+# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+# enum is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically be
+# useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+# The default value is: NO.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can be
+# an expensive process and often the same symbol appears multiple times in the
+# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+# doxygen will become slower. If the cache is too large, memory is wasted. The
+# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+# symbols. At the end of a run doxygen will report the cache usage and suggest
+# the optimal cache size from a speed point of view.
+# Minimum value: 0, maximum value: 9, default value: 0.
+
+LOOKUP_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
+# documentation are documented, even if no documentation was available. Private
+# class members and static file members will be hidden unless the
+# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+# Note: This will also disable the warnings about undocumented members that are
+# normally produced when WARNINGS is set to YES.
+# The default value is: NO.
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
+# be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
+# methods of a class will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIV_VIRTUAL   = NO
+
+# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
+# scope will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PACKAGE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
+# included in the documentation.
+# The default value is: NO.
+
+EXTRACT_STATIC         = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO,
+# only classes defined in header files are included. Does not have any effect
+# for Java sources.
+# The default value is: YES.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. If set to YES, local methods,
+# which are defined in the implementation section but not in the interface are
+# included in the documentation. If set to NO, only methods in the interface are
+# included.
+# The default value is: NO.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base name of
+# the file that contains the anonymous namespace. By default anonymous namespace
+# are hidden.
+# The default value is: NO.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+# undocumented members inside documented classes or files. If set to NO these
+# members will be included in the various overviews, but no documentation
+# section is generated. This option has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy. If set
+# to NO, these classes will be included in the various overviews. This option
+# has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# declarations. If set to NO, these declarations will be included in the
+# documentation.
+# The default value is: NO.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+# documentation blocks found inside the body of a function. If set to NO, these
+# blocks will be appended to the function's detailed documentation block.
+# The default value is: NO.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation that is typed after a
+# \internal command is included. If the tag is set to NO then the documentation
+# will be excluded. Set it to YES to include the internal documentation.
+# The default value is: NO.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+# names in lower-case letters. If set to YES, upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# (including Cygwin) ands Mac users are advised to set this option to NO.
+# The default value is: system dependent.
+
+CASE_SENSE_NAMES       = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+# their full class and namespace scopes in the documentation. If set to YES, the
+# scope will be hidden.
+# The default value is: NO.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
+# append additional text to a page's title, such as Class Reference. If set to
+# YES the compound reference will be hidden.
+# The default value is: NO.
+
+HIDE_COMPOUND_REFERENCE= NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+# the files that are included by a file in the documentation of that file.
+# The default value is: YES.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+# grouped member an include statement to the documentation, telling the reader
+# which file to include in order to use the member.
+# The default value is: NO.
+
+SHOW_GROUPED_MEMB_INC  = NO
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+# files with double quotes in the documentation rather than with sharp brackets.
+# The default value is: NO.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+# documentation for inline members.
+# The default value is: YES.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+# (detailed) documentation of file and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order.
+# The default value is: YES.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+# descriptions of file, namespace and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order. Note that
+# this will also influence the order of the classes in the class list.
+# The default value is: NO.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+# (brief and detailed) documentation of class members so that constructors and
+# destructors are listed first. If set to NO the constructors will appear in the
+# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+# member documentation.
+# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+# detailed member documentation.
+# The default value is: NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+# of group names into alphabetical order. If set to NO the group names will
+# appear in their defined order.
+# The default value is: NO.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+# fully-qualified names, including namespaces. If set to NO, the class list will
+# be sorted only by class name, not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the alphabetical
+# list.
+# The default value is: NO.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+# type resolution of all parameters of a function it will reject a match between
+# the prototype and the implementation of a member function even if there is
+# only one candidate or it is obvious which candidate to choose by doing a
+# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+# accept a match between prototype and implementation in such cases.
+# The default value is: NO.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
+# list. This list is created by putting \todo commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
+# list. This list is created by putting \test commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
+# list. This list is created by putting \bug commands in the documentation.
+# The default value is: YES.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
+# the deprecated list. This list is created by putting \deprecated commands in
+# the documentation.
+# The default value is: YES.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional documentation
+# sections, marked by \if <section_label> ... \endif and \cond <section_label>
+# ... \endcond blocks.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+# initial value of a variable or macro / define can have for it to appear in the
+# documentation. If the initializer consists of more lines than specified here
+# it will be hidden. Use a value of 0 to hide initializers completely. The
+# appearance of the value of individual variables and macros / defines can be
+# controlled using \showinitializer or \hideinitializer command in the
+# documentation regardless of this setting.
+# Minimum value: 0, maximum value: 10000, default value: 30.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+# the bottom of the documentation of classes and structs. If set to YES, the
+# list will mention the files that were used to generate the documentation.
+# The default value is: YES.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+# will remove the Files entry from the Quick Index and from the Folder Tree View
+# (if specified).
+# The default value is: YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+# page. This will remove the Namespaces entry from the Quick Index and from the
+# Folder Tree View (if specified).
+# The default value is: YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command command input-file, where command is the value of the
+# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+# by doxygen. Whatever the program writes to standard output is used as the file
+# version. For an example see the documentation.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option. You can
+# optionally specify a file name after the option, if omitted DoxygenLayout.xml
+# will be used as the name of the layout file.
+#
+# Note that if you run doxygen from a directory containing a file called
+# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+# tag is left empty.
+
+LAYOUT_FILE            =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+# the reference definitions. This must be a list of .bib files. The .bib
+# extension is automatically appended if omitted. This requires the bibtex tool
+# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
+# For LaTeX the style of the bibliography can be controlled using
+# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+# search path. See also \cite for info how to create references.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated to
+# standard output by doxygen. If QUIET is set to YES this implies that the
+# messages are off.
+# The default value is: NO.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
+# this implies that the warnings are on.
+#
+# Tip: Turn warnings on while writing the documentation.
+# The default value is: YES.
+
+WARNINGS               = YES
+
+# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
+# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: YES.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some parameters
+# in a documented function, or documenting parameters that don't exist or using
+# markup commands wrongly.
+# The default value is: YES.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+# are documented, but have no documentation for their parameters or return
+# value. If set to NO, doxygen will only warn about wrong or incomplete
+# parameter documentation, but not about the absence of documentation. If
+# EXTRACT_ALL is set to YES then this flag will automatically be disabled.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = NO
+
+# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
+# a warning is encountered.
+# The default value is: NO.
+
+WARN_AS_ERROR          = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that doxygen
+# can produce. The string should contain the $file, $line, and $text tags, which
+# will be replaced by the file and line number from which the warning originated
+# and the warning text. Optionally the format may contain $version, which will
+# be replaced by the version of the file (if it could be obtained via
+# FILE_VERSION_FILTER)
+# The default value is: $file:$line: $text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning and error
+# messages should be written. If left blank the output is written to standard
+# error (stderr).
+
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag is used to specify the files and/or directories that contain
+# documented source files. You may enter file names like myfile.cpp or
+# directories like /usr/src/myproject. Separate the files or directories with
+# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = /home/ubu/Downloads/week4/week4/softwareEng_9_4/app
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+# documentation (see: https://www.gnu.org/software/libiconv/) for the list of
+# possible encodings.
+# The default value is: UTF-8.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+# *.h) to filter out the source-files in the directories.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# read by doxygen.
+#
+# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
+# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
+# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
+# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment),
+# *.doc (to be provided as doxygen C comment), *.txt (to be provided as doxygen
+# C comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f, *.for, *.tcl, *.vhd,
+# *.vhdl, *.ucf, *.qsf and *.ice.
+
+FILE_PATTERNS          = *.c \
+                         *.cc \
+                         *.cxx \
+                         *.cpp \
+                         *.c++ \
+                         *.java \
+                         *.ii \
+                         *.ixx \
+                         *.ipp \
+                         *.i++ \
+                         *.inl \
+                         *.idl \
+                         *.ddl \
+                         *.odl \
+                         *.h \
+                         *.hh \
+                         *.hxx \
+                         *.hpp \
+                         *.h++ \
+                         *.cs \
+                         *.d \
+                         *.php \
+                         *.php4 \
+                         *.php5 \
+                         *.phtml \
+                         *.inc \
+                         *.m \
+                         *.markdown \
+                         *.md \
+                         *.mm \
+                         *.dox \
+                         *.doc \
+                         *.txt \
+                         *.py \
+                         *.pyw \
+                         *.f90 \
+                         *.f95 \
+                         *.f03 \
+                         *.f08 \
+                         *.f \
+                         *.for \
+                         *.tcl \
+                         *.vhd \
+                         *.vhdl \
+                         *.ucf \
+                         *.qsf \
+                         *.ice
+
+# The RECURSIVE tag can be used to specify whether or not subdirectories should
+# be searched for input files as well.
+# The default value is: NO.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+#
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE                =
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+# The default value is: NO.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories.
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories use the pattern */test/*
+
+EXCLUDE_SYMBOLS        =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or directories
+# that contain example code fragments that are included (see the \include
+# command).
+
+EXAMPLE_PATH           =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank all
+# files are included.
+
+EXAMPLE_PATTERNS       = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude commands
+# irrespective of the value of the RECURSIVE tag.
+# The default value is: NO.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or directories
+# that contain images that are to be included in the documentation (see the
+# \image command).
+
+IMAGE_PATH             =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command:
+#
+# <filter> <input-file>
+#
+# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+# name of an input file. Doxygen will then use the output that the filter
+# program writes to standard output. If FILTER_PATTERNS is specified, this tag
+# will be ignored.
+#
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+INPUT_FILTER           =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form: pattern=filter
+# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+# patterns match the file name, INPUT_FILTER is applied.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+FILTER_PATTERNS        =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will also be used to filter the input files that are used for
+# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# The default value is: NO.
+
+FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+# it is also possible to disable source filtering for a specific pattern using
+# *.ext= (so without naming a filter).
+# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want to reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE =
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+# generated. Documented entities will be cross-referenced with these sources.
+#
+# Note: To get rid of all source code in the generated output, make sure that
+# also VERBATIM_HEADERS is set to NO.
+# The default value is: NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body of functions,
+# classes and enums directly into the documentation.
+# The default value is: NO.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+# special comment blocks from generated source code fragments. Normal C, C++ and
+# Fortran comments will always remain visible.
+# The default value is: YES.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+# entity all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES then for each documented function
+# all documented entities called/used by that function will be listed.
+# The default value is: NO.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+# to YES then the hyperlinks from functions in REFERENCES_RELATION and
+# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+# link to the documentation.
+# The default value is: YES.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+# source code will show a tooltip with additional information such as prototype,
+# brief description and links to the definition and documentation. Since this
+# will make the HTML file larger and loading of large files a bit slower, you
+# can opt to disable this feature.
+# The default value is: YES.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+SOURCE_TOOLTIPS        = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code will
+# point to the HTML generated by the htags(1) tool instead of doxygen built-in
+# source browser. The htags tool is part of GNU's global source tagging system
+# (see https://www.gnu.org/software/global/global.html). You will need version
+# 4.8.6 or higher.
+#
+# To use it do the following:
+# - Install the latest version of global
+# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
+# - Make sure the INPUT points to the root of the source tree
+# - Run doxygen as normal
+#
+# Doxygen will invoke htags (and that will in turn invoke gtags), so these
+# tools must be available from the command line (i.e. in the search path).
+#
+# The result: instead of the source browser generated by doxygen, the links to
+# source code will now point to the output of htags.
+# The default value is: NO.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+# verbatim copy of the header file for each class for which an include is
+# specified. Set to NO to disable this.
+# See also: Section \class.
+# The default value is: YES.
+
+VERBATIM_HEADERS       = YES
+
+# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
+# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
+# cost of reduced performance. This can be particularly helpful with template
+# rich C++ code for which doxygen's built-in parser lacks the necessary type
+# information.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+# The default value is: NO.
+
+CLANG_ASSISTED_PARSING = NO
+
+# If clang assisted parsing is enabled you can provide the compiler with command
+# line options that you would normally use when invoking the compiler. Note that
+# the include paths will already be set by doxygen for the files and directories
+# specified with INPUT and INCLUDE_PATH.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_OPTIONS          =
+
+# If clang assisted parsing is enabled you can provide the clang parser with the
+# path to the compilation database (see:
+# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) used when the files
+# were built. This is equivalent to specifying the "-p" option to a clang tool,
+# such as clang-check. These options will then be passed to the parser.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+
+CLANG_DATABASE_PATH    =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+# compounds will be generated. Enable this if the project contains a lot of
+# classes, structs, unions or interfaces.
+# The default value is: YES.
+
+ALPHABETICAL_INDEX     = YES
+
+# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
+# which the alphabetical index list will be split.
+# Minimum value: 1, maximum value: 20, default value: 5.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
+# The default value is: YES.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+# generated HTML page (for example: .htm, .php, .asp).
+# The default value is: .html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+# each generated HTML page. If the tag is left blank doxygen will generate a
+# standard header.
+#
+# To get valid HTML the header file that includes any scripts and style sheets
+# that doxygen needs, which is dependent on the configuration options used (e.g.
+# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+# default header using
+# doxygen -w html new_header.html new_footer.html new_stylesheet.css
+# YourConfigFile
+# and then modify the file new_header.html. See also section "Doxygen usage"
+# for information on how to generate the default header that doxygen normally
+# uses.
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. For a description
+# of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+# generated HTML page. If the tag is left blank doxygen will generate a standard
+# footer. See HTML_HEADER for more information on how to generate a default
+# footer and what special commands can be used inside the footer. See also
+# section "Doxygen usage" for information on how to generate the default footer
+# that doxygen normally uses.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+# sheet that is used by each HTML page. It can be used to fine-tune the look of
+# the HTML output. If left blank doxygen will generate a default style sheet.
+# See also section "Doxygen usage" for information on how to generate the style
+# sheet that doxygen normally uses.
+# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+# it is more robust and this tag (HTML_STYLESHEET) will in the future become
+# obsolete.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# cascading style sheets that are included after the standard style sheets
+# created by doxygen. Using this option one can overrule certain style aspects.
+# This is preferred over using HTML_STYLESHEET since it does not replace the
+# standard style sheet and is therefore more robust against future updates.
+# Doxygen will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list). For an example see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+# files will be copied as-is; there are no commands or markers available.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+# will adjust the colors in the style sheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+# purple, and 360 is red again.
+# Minimum value: 0, maximum value: 359, default value: 220.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+# in the HTML output. For a value of 0 the output will use grayscales only. A
+# value of 255 will produce the most vivid colors.
+# Minimum value: 0, maximum value: 255, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+# luminance component of the colors in the HTML output. Values below 100
+# gradually make the output lighter, whereas values above 100 make the output
+# darker. The value divided by 100 is the actual gamma applied, so 80 represents
+# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+# change the gamma.
+# Minimum value: 40, maximum value: 240, default value: 80.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to YES can help to show when doxygen was last run and thus if the
+# documentation is up to date.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = NO
+
+# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
+# documentation will contain a main index with vertical navigation menus that
+# are dynamically created via JavaScript. If disabled, the navigation index will
+# consists of multiple levels of tabs that are statically embedded in every HTML
+# page. Disable this option to support browsers that do not have JavaScript,
+# like the Qt help browser.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_MENUS     = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+# shown in the various tree structured indices initially; the user can expand
+# and collapse entries dynamically later on. Doxygen will expand the tree to
+# such a level that at most the specified number of entries are visible (unless
+# a fully collapsed tree already exceeds this amount). So setting the number of
+# entries 1 will produce a full collapsed tree by default. 0 is a special value
+# representing an infinite number of entries and will result in a full expanded
+# tree by default.
+# Minimum value: 0, maximum value: 9999, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_INDEX_NUM_ENTRIES = 100
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files will be
+# generated that can be used as input for Apple's Xcode 3 integrated development
+# environment (see: https://developer.apple.com/xcode/), introduced with OSX
+# 10.5 (Leopard). To create a documentation set, doxygen will generate a
+# Makefile in the HTML output directory. Running make will produce the docset in
+# that directory and running make install will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
+# genXcode/_index.html for more information.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_DOCSET        = NO
+
+# This tag determines the name of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# The default value is: Doxygen generated docs.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# This tag specifies a string that should uniquely identify the documentation
+# set bundle. This should be a reverse domain-name style string, e.g.
+# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+# The default value is: org.doxygen.Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+# The default value is: Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+# (see: https://www.microsoft.com/en-us/download/details.aspx?id=21138) on
+# Windows.
+#
+# The HTML Help Workshop contains a compiler that can convert all HTML output
+# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+# files are now used as the Windows 98 help format, and will replace the old
+# Windows help format (.hlp) on all Windows platforms in the future. Compressed
+# HTML files also contain an index, a table of contents, and you can search for
+# words in the documentation. The HTML workshop also contains a viewer for
+# compressed HTML files.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_HTMLHELP      = NO
+
+# The CHM_FILE tag can be used to specify the file name of the resulting .chm
+# file. You can add a path in front of the file if the result should not be
+# written to the html output directory.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_FILE               =
+
+# The HHC_LOCATION tag can be used to specify the location (absolute path
+# including file name) of the HTML help compiler (hhc.exe). If non-empty,
+# doxygen will try to run the HTML help compiler on the generated index.hhp.
+# The file has to be specified with full path.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+HHC_LOCATION           =
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated
+# (YES) or that it should be included in the master .chm file (NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = NO
+
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
+# and project file content.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_INDEX_ENCODING     =
+
+# The BINARY_TOC flag controls whether a binary table of contents is generated
+# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
+# enables the Previous and Next buttons.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members to
+# the table of contents of the HTML help documentation and to the tree view.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+# (.qch) of the generated HTML documentation.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+# the file name of the resulting .qch file. The path specified is relative to
+# the HTML output folder.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+# Project output. For more information please see Qt Help Project / Namespace
+# (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+# Help Project output. For more information please see Qt Help Project / Virtual
+# Folders (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-
+# folders).
+# The default value is: doc.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+# filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see Qt Help Project / Custom
+# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
+# filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# The QHG_LOCATION tag can be used to specify the location of Qt's
+# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
+# generated .qhp file.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHG_LOCATION           =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+# generated, together with the HTML files, they form an Eclipse help plugin. To
+# install this plugin and make it available under the help contents menu in
+# Eclipse, the contents of the directory containing the HTML and XML files needs
+# to be copied into the plugins directory of eclipse. The name of the directory
+# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+# After copying Eclipse needs to be restarted before the help appears.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the Eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have this
+# name. Each documentation set should have its own identifier.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# If you want full control over the layout of the generated HTML pages it might
+# be necessary to disable the index and replace it with your own. The
+# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+# of each HTML page. A value of NO enables the index and the value YES disables
+# it. Since the tabs in the index contain the same information as the navigation
+# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+DISABLE_INDEX          = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information. If the tag
+# value is set to YES, a side panel will be generated containing a tree-like
+# index structure (just like the one that is generated for HTML Help). For this
+# to work a browser that supports JavaScript, DHTML, CSS and frames is required
+# (i.e. any modern browser). Windows users are probably better off using the
+# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
+# further fine-tune the look of the index. As an example, the default style
+# sheet generated by doxygen has an example that shows how to put an image at
+# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
+# the same information as the tab index, you could consider setting
+# DISABLE_INDEX to YES when enabling this option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_TREEVIEW      = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+# doxygen will group on one line in the generated HTML documentation.
+#
+# Note that a value of 0 will completely suppress the enum values from appearing
+# in the overview section.
+# Minimum value: 0, maximum value: 20, default value: 4.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+# to set the initial width (in pixels) of the frame in which the tree is shown.
+# Minimum value: 0, maximum value: 1500, default value: 250.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+TREEVIEW_WIDTH         = 250
+
+# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
+# external symbols imported via tag files in a separate window.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# Use this tag to change the font size of LaTeX formulas included as images in
+# the HTML documentation. When you change the font size after a successful
+# doxygen run you need to manually remove any form_*.png images from the HTML
+# output directory to force them to be regenerated.
+# Minimum value: 8, maximum value: 50, default value: 10.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
+# to create new LaTeX commands to be used in formulas as building blocks. See
+# the section "Including formulas" for details.
+
+FORMULA_MACROFILE      =
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# https://www.mathjax.org) which uses client side JavaScript for the rendering
+# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
+# installed or if you want to formulas look prettier in the HTML output. When
+# enabled you may also need to install MathJax separately and configure the path
+# to it using the MATHJAX_RELPATH option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. See the MathJax site (see:
+# http://docs.mathjax.org/en/latest/output.html) for more details.
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility), NativeMML (i.e. MathML) and SVG.
+# The default value is: HTML-CSS.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the HTML
+# output directory using the MATHJAX_RELPATH option. The destination directory
+# should contain the MathJax.js script. For instance, if the mathjax directory
+# is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
+# Content Delivery Network so you can quickly see the result without installing
+# MathJax. However, it is strongly recommended to install a local copy of
+# MathJax from https://www.mathjax.org before deployment.
+# The default value is: https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+# of code that will be used on startup of the MathJax code. See the MathJax site
+# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# example see the documentation.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+# the HTML output. The underlying search engine uses javascript and DHTML and
+# should work on any modern browser. Note that when using HTML help
+# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+# there is already a search function so this one should typically be disabled.
+# For large projects the javascript based search engine can be slow, then
+# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+# search using the keyboard; to jump to the search box use <access key> + S
+# (what the <access key> is depends on the OS and browser, but it is typically
+# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+# key> to jump into the search results window, the results can be navigated
+# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+# the search. The filter options can be selected when the cursor is inside the
+# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+# to select a filter and <Enter> or <escape> to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using JavaScript. There
+# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+# setting. When disabled, doxygen will generate a PHP script for searching and
+# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+# and searching needs to be provided by external tools. See the section
+# "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SERVER_BASED_SEARCH    = NO
+
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: https://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see: https://xapian.org/). See the section "External Indexing and
+# Searching" for details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
+# The default value is: YES.
+
+GENERATE_LATEX         = YES
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked.
+#
+# Note that when not enabling USE_PDFLATEX the default is latex when enabling
+# USE_PDFLATEX the default is pdflatex and when in the later case latex is
+# chosen this is overwritten by pdflatex. For specific output languages the
+# default can have been set differently, this depends on the implementation of
+# the output language.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         =
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# Note: This tag is used in the Makefile / make.bat.
+# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
+# (.tex).
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
+# generate index for LaTeX. In case there is no backslash (\) as first character
+# it will be automatically added in the LaTeX code.
+# Note: This tag is used in the generated output file (.tex).
+# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
+# The default value is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_MAKEINDEX_CMD    = makeindex
+
+# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE             = a4
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. The package can be specified just
+# by its name or with the correct syntax as to be used with the LaTeX
+# \usepackage command. To get the times font for instance you can specify :
+# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+# To use the option intlimits with the amsmath package you can specify:
+# EXTRA_PACKAGES=[intlimits]{amsmath}
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+EXTRA_PACKAGES         =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+# generated LaTeX document. The header should contain everything until the first
+# chapter. If it is left blank doxygen will generate a standard header. See
+# section "Doxygen usage" for information on how to let doxygen write the
+# default header to a separate file.
+#
+# Note: Only use a user-defined header if you know what you are doing! The
+# following commands have a special meaning inside the header: $title,
+# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
+# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
+# string, for the replacement values of the other commands the user is referred
+# to HTML_HEADER.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+# generated LaTeX document. The footer should contain everything after the last
+# chapter. If it is left blank doxygen will generate a standard footer. See
+# LATEX_HEADER for more information on how to generate a default footer and what
+# special commands can be used inside the footer.
+#
+# Note: Only use a user-defined footer if you know what you are doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# LaTeX style sheets that are included after the standard style sheets created
+# by doxygen. Using this option one can overrule certain style aspects. Doxygen
+# will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list).
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_STYLESHEET =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_FILES      =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
+# the PDF file directly from the LaTeX files. Set this option to YES, to get a
+# higher quality PDF documentation.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help. This option is also used
+# when generating formulas in HTML.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BATCHMODE        = NO
+
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HIDE_INDICES     = NO
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BIB_STYLE        = plain
+
+# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_TIMESTAMP        = NO
+
+# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
+# path from which the emoji images will be read. If a relative path is entered,
+# it will be relative to the LATEX_OUTPUT directory. If left blank the
+# LATEX_OUTPUT directory will be used.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EMOJI_DIRECTORY  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# configuration file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's configuration file. A template extensions file can be
+# generated using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_EXTENSIONS_FILE    =
+
+# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
+# with syntax highlighting in the RTF output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_SOURCE_CODE        = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_EXTENSION          = .3
+
+# The MAN_SUBDIR tag determines the name of the directory created within
+# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+# MAN_EXTENSION with the initial . removed.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_SUBDIR             =
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: xml.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_OUTPUT             = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
+# listings (including syntax highlighting and cross-referencing information) to
+# the XML output. Note that enabling this will significantly increase the size
+# of the XML output.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_PROGRAMLISTING     = YES
+
+# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
+# namespace members in file scope as well, matching the HTML output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_NS_MEMB_FILE_SCOPE = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
+# that can be used to generate PDF.
+# The default value is: NO.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it.
+# The default directory is: docbook.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_OUTPUT         = docbook
+
+# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
+# program listings (including syntax highlighting and cross-referencing
+# information) to the DOCBOOK output. Note that enabling this will significantly
+# increase the size of the DOCBOOK output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_PROGRAMLISTING = NO
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
+# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
+# the structure of the code including all documentation. Note that this feature
+# is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
+# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+# output from the Perl module output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
+# formatted so it can be parsed by a human reader. This is useful if you want to
+# understand what is going on. On the other hand, if this tag is set to NO, the
+# size of the Perl module output will be much smaller and Perl will parse it
+# just the same.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file are
+# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+# so different doxyrules.make files included by the same Makefile don't
+# overwrite each other's variables.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
+# in the source code. If set to NO, only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES, the include files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by the
+# preprocessor.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
+INCLUDE_PATH           =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+PREDEFINED             =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have
+# an all uppercase name, and do not end with a semicolon. Such function macros
+# are typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have a unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
+# the class index. If set to NO, only the inherited external classes will be
+# listed.
+# The default value is: NO.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
+
+EXTERNAL_GROUPS        = YES
+
+# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
+
+EXTERNAL_PAGES         = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = YES
+
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
+# If set to YES the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz (see:
+# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: YES.
+
+HAVE_DOT               = YES
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NUM_THREADS        = 0
+
+# When you want a differently looking font in the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+# each documented class showing the direct and indirect inheritance relations.
+# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LOOK               = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDE_GRAPH          = YES
+
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command. Disabling a call graph can be
+# accomplished by means of the command \hidecallgraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command. Disabling a caller graph can be
+# accomplished by means of the command \hidecallergraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. For an explanation of the image formats see the section
+# output formats in the documentation of the dot tool (Graphviz (see:
+# http://www.graphviz.org/)).
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd,
+# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo,
+# gif:cairo:gd, gif:gd, gif:gd:gd, svg, png:gd, png:gd:gd, png:cairo,
+# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# png:gdiplus:gdiplus.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_IMAGE_FORMAT       = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG        = NO
+
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
+
+MSCFILE_DIRS           =
+
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS           =
+
+# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+# path where java can find the plantuml.jar file. If left blank, it is assumed
+# PlantUML is not used or called during a preprocessing step. Doxygen will
+# generate a warning when it encounters a \startuml command in this case and
+# will not generate output for the diagram.
+
+PLANTUML_JAR_PATH      =
+
+# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
+# configuration file for plantuml.
+
+PLANTUML_CFG_FILE      =
+
+# When using plantuml, the specified paths are searched for files specified by
+# the !include statement in a plantuml block.
+
+PLANTUML_INCLUDE_PATH  =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+# files that are used to generate the various graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_CLEANUP            = YES
diff --git a/week4/softwareEng_9_4/app/doxygen_log.txt b/week4/softwareEng_9_4/app/doxygen_log.txt
new file mode 100644
index 00000000..108cae6a
--- /dev/null
+++ b/week4/softwareEng_9_4/app/doxygen_log.txt
@@ -0,0 +1,130 @@
+Searching for include files...
+Searching for example files...
+Searching for images...
+Searching for dot files...
+Searching for msc files...
+Searching for dia files...
+Searching for files to exclude
+Searching INPUT for files to process...
+Searching for files in directory /home/ubu/Downloads/week4/week4/softwareEng_9_4/app
+Reading and parsing tag files
+Parsing files
+Preprocessing /home/ubu/Downloads/week4/week4/softwareEng_9_4/app/softwareEng_9_4.cpp...
+Parsing file /home/ubu/Downloads/week4/week4/softwareEng_9_4/app/softwareEng_9_4.cpp...
+Preprocessing /home/ubu/Downloads/week4/week4/softwareEng_9_4/app/softwareEng_9_4.hpp...
+Parsing file /home/ubu/Downloads/week4/week4/softwareEng_9_4/app/softwareEng_9_4.hpp...
+Building group list...
+Building directory list...
+Building namespace list...
+Building file list...
+/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/softwareEng_9_4.cpp:2: warning: the name 'softwareEngineering_9_4.cpp' supplied as the argument in the \file statement is not an input file
+/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/softwareEng_9_4.hpp:2: warning: the name 'SoftwareEngineering9-4.hpp' supplied as the argument in the \file statement is not an input file
+Building class list...
+Computing nesting relations for classes...
+Associating documentation with classes...
+Building example list...
+Searching for enumerations...
+Searching for documented typedefs...
+Searching for members imported via using declarations...
+Searching for included using directives...
+Searching for documented variables...
+Building interface member list...
+Building member list...
+Searching for friends...
+Searching for documented defines...
+Computing class inheritance relations...
+Computing class usage relations...
+Flushing cached template relations that have become invalid...
+Computing class relations...
+Add enum values to enums...
+Searching for member function documentation...
+Creating members for template instances...
+Building page list...
+Search for main page...
+Computing page relations...
+Determining the scope of groups...
+Sorting lists...
+Determining which enums are documented
+Computing member relations...
+Building full member lists recursively...
+Adding members to member groups.
+Computing member references...
+Inheriting documentation...
+Generating disk names...
+Adding source references...
+Adding xrefitems...
+Sorting member lists...
+Setting anonymous enum type...
+Computing dependencies between directories...
+Generating citations page...
+Counting members...
+Counting data structures...
+Resolving user defined references...
+Finding anchors and sections in the documentation...
+Transferring function references...
+Combining using relations...
+Adding members to index pages...
+Correcting members for VHDL...
+Generating style sheet...
+Generating search indices...
+Generating example documentation...
+Generating file sources...
+Generating code for file softwareEng_9_4.hpp...
+Generating file documentation...
+Generating docs for file softwareEng_9_4.cpp...
+Generating docs for file softwareEng_9_4.hpp...
+Generating page documentation...
+Generating group documentation...
+Generating class documentation...
+Generating docs for compound printer...
+Generating namespace index...
+Generating graph info page...
+Generating directory documentation...
+Generating index page...
+Generating page index...
+Generating module index...
+Generating namespace index...
+Generating namespace member index...
+Generating annotated compound index...
+Generating alphabetical compound index...
+Generating hierarchical class index...
+Generating graphical class hierarchy...
+Generating member index...
+Generating file index...
+Generating file member index...
+Generating example index...
+finalizing index lists...
+writing tag file...
+Running plantuml with JAVA...
+Running dot...
+Generating dot graphs using 9 parallel threads...
+Running dot for graph 1/7
+sh: 1: dot: not found
+error: Problems running dot: exit code=127, command='dot', arguments='"/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp__incl.dot" -Tpdf -o "/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp__incl.pdf"'
+sh: 1: dot: not found
+sh: 1: dot: not found
+error: Problems running dot: exit code=127, command='dot', arguments='"/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/html/graph_legend.dot" -Tpng -o "/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/html/graph_legend.png"'
+sh: 1: dot: not found
+error: Problems running dot: exit code=127, command='dot', arguments='"/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp__dep__incl.dot" -Tpng -o "/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp__dep__incl.png"'
+sh: 1: dot: not found
+error: Problems running dot: exit code=127, command='dot', arguments='"/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/html/software_eng__9__4_8cpp__incl.dot" -Tpng -o "/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/html/software_eng__9__4_8cpp__incl.png"'
+error: Problems running dot: exit code=127, command='dot', arguments='"/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp__dep__incl.dot" -Tpdf -o "/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp__dep__incl.pdf"'
+sh: 1: dot: not found
+error: Problems running dot: exit code=127, command='dot', arguments='"/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp__incl.dot" -Tpng -o "/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp__incl.png"'
+sh: 1: dot: not found
+error: Problems running dot: exit code=127, command='dot', arguments='"/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp__incl.dot" -Tpdf -o "/home/ubu/Downloads/week4/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp__incl.pdf"'
+Running dot for graph 2/7
+Running dot for graph 3/7
+Running dot for graph 4/7
+Running dot for graph 5/7
+Running dot for graph 6/7
+Running dot for graph 7/7
+Patching output file 1/4
+error: problems opening map file /home/ubu/Downloads/week4/week4/softwareEng_9_4/app/html/software_eng__9__4_8cpp__incl.map for inclusion in the docs!
+If you installed Graphviz/dot after a previous failing run, 
+try deleting the output directory and rerun doxygen.
+Patching output file 2/4
+error: problem writing FIG 0 figure!
+lookup cache used 6/65536 hits=23 misses=6
+finished...
+*** Doxygen has finished
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/app/html/annotated.html b/week4/softwareEng_9_4/app/html/annotated.html
new file mode 100644
index 00000000..de489cad
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/annotated.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: Class List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="headertitle">
+<div class="title">Class List</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">Here are the classes, structs, unions and interfaces with brief descriptions:</div><div class="directory">
+<table class="directory">
+<tr id="row_0_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classprinter.html" target="_self">printer</a></td><td class="desc">Printer is a class to extract a new method from printposition, The motivation behind solving this problem is to implement method extraction for code refractory using input method </td></tr>
+</table>
+</div><!-- directory -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/bc_s.png b/week4/softwareEng_9_4/app/html/bc_s.png
new file mode 100644
index 0000000000000000000000000000000000000000..224b29aa9847d5a4b3902efd602b7ddf7d33e6c2
GIT binary patch
literal 676
zcmV;V0$crwP)<h;3K|Lk000e1NJLTq000O80015c1^@s65rAI}0007ONkl<ZcmeI5
z%WD%+6voe;xyj6=NhXt~4{e$zF*P<SZp4L@2Hd!iQY<tJD@e5{RU55hl&Talf{KWb
zN*6A=C`Gqz5#NvcXzNOCOH(I9n<#?l<k5ws2omoMCgj%s3y1G=&gJ~>y__>=_9%My
z{n931IS})GlGUF8K#6VIbs%684A^L3@%PlP2>_sk`UWPq@f;rU*V%rPy_ekbhXT&s
z(GN{DxFv}*vZp`F>S!r||M`I*nOwwKX+BC~3P5N3-)Y{65c;ywYiAh-1*hZcToLHK
ztpl1xomJ+Yb}K(cfbJr2=GNOnT!UFA7Vy~fBz8?J>XHsbZoDad^8PxfSa0GDgENZS
zuLCEqzb*xWX2CG*b&5IiO#NzrW*;`VC9455M`o1NBh+(k8~`XCEEoC1Ybwf;vr4K3
zg|EB<07?SOqHp9DhLpS&bzgo70I+ghB_#)K7H%AMU3v}xuyQq9&Bm~++VYhF09a+U
zl7>n7Jjm$K#b*FONz~fj;I->Bf;ule1prFN9FovcDGBkpg>)O*-}eLnC{6oZHZ$o%
zXKW$;0_{8hxHQ>l;_*HATI(`7t#^{$(zLe}h*mqwOc*nRY9=?Sx4OOeVIfI|0V(V2
zBrW#G7Ss9wvzr@>H*`r>zE<Gz)cj&*s5lRy$b&*W@2j<GZEpXZ$P|Z!4Q$_|`5gj>
z+e8bOBgqIgldUJlG(YUDviMB`9+DH8n-s9SXRLyJHO1!=wY^79WYZMTa(wiZ!zP66
zA~!21vmF3H2{ngD;+`6j#~6j;$*f*G_2ZD1E;9(yaw7d-QnSCpK(cR1zU3qU0000<
KMNUMnLSTYoA~SLT

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/bdwn.png b/week4/softwareEng_9_4/app/html/bdwn.png
new file mode 100644
index 0000000000000000000000000000000000000000..940a0b950443a0bb1b216ac03c45b8a16c955452
GIT binary patch
literal 147
zcmeAS@N?(olHy`uVBq!ia0vp^>_E)H!3HEvS)PKZC{Gv1kP61Pb5HX&C<wUB513~7
zF-Lk{?g8$ijf`2F^ip|Vw7EpzIJxiU`6~>2wk~_T<sM_r%les%%^JdHy*A#$ew5wb
vr&wL1c8#4j*F5jfGT)c(PZrEb5O3m+yDrVre6KeTXbXd<tDnm{r-UW|3$!!q

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/classes.html b/week4/softwareEng_9_4/app/html/classes.html
new file mode 100644
index 00000000..c990951d
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/classes.html
@@ -0,0 +1,88 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: Class Index</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="headertitle">
+<div class="title">Class Index</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="qindex"><a class="qindex" href="#letter_p">p</a></div>
+<table class="classindex">
+<tr><td rowspan="2" valign="bottom"><a name="letter_p"></a><table border="0" cellspacing="0" cellpadding="0"><tr><td><div class="ah">&#160;&#160;p&#160;&#160;</div></td></tr></table>
+</td>
+<td></td></tr>
+<tr><td></td></tr>
+<tr><td valign="top"><a class="el" href="classprinter.html">printer</a>&#160;&#160;&#160;</td>
+<td></td></tr>
+<tr><td></td><td></td></tr>
+</table>
+<div class="qindex"><a class="qindex" href="#letter_p">p</a></div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/classprinter-members.html b/week4/softwareEng_9_4/app/html/classprinter-members.html
new file mode 100644
index 00000000..caee6648
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/classprinter-members.html
@@ -0,0 +1,83 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: Member List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+</div><!-- top -->
+<div class="header">
+  <div class="headertitle">
+<div class="title">printer Member List</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p>This is the complete list of members for <a class="el" href="classprinter.html">printer</a>, including all inherited members.</p>
+<table class="directory">
+  <tr class="even"><td class="entry"><a class="el" href="classprinter.html#a10b05212f6167b64ebfb1b7c1cdc9ef2">input</a>()</td><td class="entry"><a class="el" href="classprinter.html">printer</a></td><td class="entry"></td></tr>
+  <tr><td class="entry"><a class="el" href="classprinter.html#adfbc169c8c36ac791744c8dc01647432">printer</a>()</td><td class="entry"><a class="el" href="classprinter.html">printer</a></td><td class="entry"></td></tr>
+  <tr class="even"><td class="entry"><a class="el" href="classprinter.html#ae7da213aa9062bea77998b0340163c17">printPosition</a>(int t_length, int a_length_search, char *text, char *array_to_search1, int position)</td><td class="entry"><a class="el" href="classprinter.html">printer</a></td><td class="entry"></td></tr>
+</table></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/classprinter.html b/week4/softwareEng_9_4/app/html/classprinter.html
new file mode 100644
index 00000000..e7a33566
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/classprinter.html
@@ -0,0 +1,189 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: printer Class Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-methods">Public Member Functions</a> &#124;
+<a href="classprinter-members.html">List of all members</a>  </div>
+  <div class="headertitle">
+<div class="title">printer Class Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p>printer is a class to extract a new method from printposition, The motivation behind solving this problem is to implement method extraction for code refractory using input method  
+ <a href="classprinter.html#details">More...</a></p>
+
+<p><code>#include &lt;<a class="el" href="software_eng__9__4_8hpp_source.html">softwareEng_9_4.hpp</a>&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
+Public Member Functions</h2></td></tr>
+<tr class="memitem:a10b05212f6167b64ebfb1b7c1cdc9ef2"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classprinter.html#a10b05212f6167b64ebfb1b7c1cdc9ef2">input</a> ()</td></tr>
+<tr class="memdesc:a10b05212f6167b64ebfb1b7c1cdc9ef2"><td class="mdescLeft">&#160;</td><td class="mdescRight"><a class="el" href="classprinter.html#a10b05212f6167b64ebfb1b7c1cdc9ef2" title="input() method makes sure that all the inputs for printing the positon are fed and passed by value to...">input()</a> method makes sure that all the inputs for printing the positon are fed and passed by value to <a class="el" href="classprinter.html#ae7da213aa9062bea77998b0340163c17" title="printPostion method enable code resuablity and extraction mechanism this extracted method is used to ...">printPosition()</a> method  <a href="classprinter.html#a10b05212f6167b64ebfb1b7c1cdc9ef2">More...</a><br /></td></tr>
+<tr class="separator:a10b05212f6167b64ebfb1b7c1cdc9ef2"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ae7da213aa9062bea77998b0340163c17"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classprinter.html#ae7da213aa9062bea77998b0340163c17">printPosition</a> (int t_length, int a_length_search, char *text, char *array_to_search1, int position)</td></tr>
+<tr class="memdesc:ae7da213aa9062bea77998b0340163c17"><td class="mdescLeft">&#160;</td><td class="mdescRight">printPostion method enable code resuablity and extraction mechanism this extracted method is used to find and print position  <a href="classprinter.html#ae7da213aa9062bea77998b0340163c17">More...</a><br /></td></tr>
+<tr class="separator:ae7da213aa9062bea77998b0340163c17"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:adfbc169c8c36ac791744c8dc01647432"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classprinter.html#adfbc169c8c36ac791744c8dc01647432">printer</a> ()</td></tr>
+<tr class="separator:adfbc169c8c36ac791744c8dc01647432"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>printer is a class to extract a new method from printposition, The motivation behind solving this problem is to implement method extraction for code refractory using input method </p>
+</div><h2 class="groupheader">Constructor &amp; Destructor Documentation</h2>
+<a id="adfbc169c8c36ac791744c8dc01647432"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#adfbc169c8c36ac791744c8dc01647432">&#9670;&nbsp;</a></span>printer()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">printer::printer </td>
+          <td>(</td>
+          <td class="paramname"></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+<h2 class="groupheader">Member Function Documentation</h2>
+<a id="a10b05212f6167b64ebfb1b7c1cdc9ef2"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#a10b05212f6167b64ebfb1b7c1cdc9ef2">&#9670;&nbsp;</a></span>input()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int printer::input </td>
+          <td>(</td>
+          <td class="paramname"></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p><a class="el" href="classprinter.html#a10b05212f6167b64ebfb1b7c1cdc9ef2" title="input() method makes sure that all the inputs for printing the positon are fed and passed by value to...">input()</a> method makes sure that all the inputs for printing the positon are fed and passed by value to <a class="el" href="classprinter.html#ae7da213aa9062bea77998b0340163c17" title="printPostion method enable code resuablity and extraction mechanism this extracted method is used to ...">printPosition()</a> method </p>
+
+</div>
+</div>
+<a id="ae7da213aa9062bea77998b0340163c17"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae7da213aa9062bea77998b0340163c17">&#9670;&nbsp;</a></span>printPosition()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void printer::printPosition </td>
+          <td>(</td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>t_length</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>a_length_search</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">char *&#160;</td>
+          <td class="paramname"><em>text</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">char *&#160;</td>
+          <td class="paramname"><em>array_to_search1</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>position</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+<p>printPostion method enable code resuablity and extraction mechanism this extracted method is used to find and print position </p>
+
+</div>
+</div>
+<hr/>The documentation for this class was generated from the following files:<ul>
+<li><a class="el" href="software_eng__9__4_8hpp_source.html">softwareEng_9_4.hpp</a></li>
+<li><a class="el" href="software_eng__9__4_8cpp.html">softwareEng_9_4.cpp</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/closed.png b/week4/softwareEng_9_4/app/html/closed.png
new file mode 100644
index 0000000000000000000000000000000000000000..98cc2c909da37a6df914fbf67780eebd99c597f5
GIT binary patch
literal 132
zcmeAS@N?(olHy`uVBq!ia0vp^oFL4>1|%O$WD@{V-kvUwAr*{o@8<G4C~~x2bkCl7
zlF9slZh~6z%aUT|WfKm3{P*dDAfv<6>{^CZMh(5KoB^r_<4^zF@3)Cp&&t3hdujKf
f*?bjBoY!V+E))@{xMcbjXe@)LtDnm{r-UW|*e5JT

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/doc.png b/week4/softwareEng_9_4/app/html/doc.png
new file mode 100644
index 0000000000000000000000000000000000000000..17edabff95f7b8da13c9516a04efe05493c29501
GIT binary patch
literal 746
zcmV<G0u}v<P)<h;3K|Lk000e1NJLTq000;O000&U1^@s6+I?Jz00089Nkl<ZcmeI5
zO;1x>7=@pnbNXRFEm&G8P!&WHG=d)>K?YZ1bzou)2{$))<VZ%w8AHp|fq%mP;4ffy
zZ-fC6h(S;T@^On$pg;?)``rZ-=s7qr4DR5hE4!!NdDmX=TJJeiSGimUI5QXkXNfZ>
zumDct!>4SyxL;zgaG>wy`^Hv*+}0kUfCrz~BCOViSb$_*&;{TGGn2^x9K*!Sf0=lV
zpP=7O;GA0*Jm*tTYj$IoXvimpnV4S1Z5f$p*f$Db2iq2zrVGQUz~yq`ahn7ck(|CE
z7Gz;%OP~J6)tEZWDzjhL9h2hdfoU2)Nd%T<5Kt;Y0XLt&<@6pQx!n<GayH9yHg8K}
z>w*5`@bq#?l*?3z{Hlzoc=Pr>oB5(9i6~_&-}A(4{Q$>c>%rV&E|a(r&;?i5cQB=}
zYSDU5nXG)NS4HEs0it2AHe2>shCyr7`6@4*6{r@8fXR<pt)Tx_l7FX`b+T&0J~3Ac
zDisC2f48s?Pz6U1j(Y#7FGXj244=p1VQ-4TfmZrD8|c58q%jdB67*815?3si0IJ}q
zK#I#XHom~r+!`&75xy*K>bTA?=IFVWAQJL&H5H{)DpM#{W(GL+Idzf^)uRV@oB8u$
z8v{MfJbTiiRg4bza<41N<zz(9MkMF~u!W-n>Azrl{=3fl_D+$t+^!xlQ8S}{UtY`e
z;;&9UhyZqQRN%2pot{*Ei0*4~hSF_3AH2@fKU!$NSflS>{@tZpDT4`M2WRTTVH+D?
z)GFlEGGHe?koB}i|1w45!BF}N_q&^HJ&-tyR{(afC6H7|aml|tBBbv}55C5DNP8p3
z)~jLEO4Z&2hZmP^i-e%(@d!(E|KRafiU8Q5u(wU((j8un3<FfbmLT1ma;4wB2Ka6K
c|6iFu0IFBSu=gW%4*&oF07*qoM6N<$f>OR*Hvj+t

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/doxygen.css b/week4/softwareEng_9_4/app/html/doxygen.css
new file mode 100644
index 00000000..73ecbb2c
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/doxygen.css
@@ -0,0 +1,1771 @@
+/* The standard CSS for doxygen 1.8.17 */
+
+body, table, div, p, dl {
+	font: 400 14px/22px Roboto,sans-serif;
+}
+
+p.reference, p.definition {
+	font: 400 14px/22px Roboto,sans-serif;
+}
+
+/* @group Heading Levels */
+
+h1.groupheader {
+	font-size: 150%;
+}
+
+.title {
+	font: 400 14px/28px Roboto,sans-serif;
+	font-size: 150%;
+	font-weight: bold;
+	margin: 10px 2px;
+}
+
+h2.groupheader {
+	border-bottom: 1px solid #879ECB;
+	color: #354C7B;
+	font-size: 150%;
+	font-weight: normal;
+	margin-top: 1.75em;
+	padding-top: 8px;
+	padding-bottom: 4px;
+	width: 100%;
+}
+
+h3.groupheader {
+	font-size: 100%;
+}
+
+h1, h2, h3, h4, h5, h6 {
+	-webkit-transition: text-shadow 0.5s linear;
+	-moz-transition: text-shadow 0.5s linear;
+	-ms-transition: text-shadow 0.5s linear;
+	-o-transition: text-shadow 0.5s linear;
+	transition: text-shadow 0.5s linear;
+	margin-right: 15px;
+}
+
+h1.glow, h2.glow, h3.glow, h4.glow, h5.glow, h6.glow {
+	text-shadow: 0 0 15px cyan;
+}
+
+dt {
+	font-weight: bold;
+}
+
+ul.multicol {
+	-moz-column-gap: 1em;
+	-webkit-column-gap: 1em;
+	column-gap: 1em;
+	-moz-column-count: 3;
+	-webkit-column-count: 3;
+	column-count: 3;
+}
+
+p.startli, p.startdd {
+	margin-top: 2px;
+}
+
+th p.starttd, p.intertd, p.endtd {
+        font-size: 100%;
+        font-weight: 700;
+}
+
+p.starttd {
+	margin-top: 0px;
+}
+
+p.endli {
+	margin-bottom: 0px;
+}
+
+p.enddd {
+	margin-bottom: 4px;
+}
+
+p.endtd {
+	margin-bottom: 2px;
+}
+
+p.interli {
+}
+
+p.interdd {
+}
+
+p.intertd {
+}
+
+/* @end */
+
+caption {
+	font-weight: bold;
+}
+
+span.legend {
+        font-size: 70%;
+        text-align: center;
+}
+
+h3.version {
+        font-size: 90%;
+        text-align: center;
+}
+
+div.qindex, div.navtab{
+	background-color: #EBEFF6;
+	border: 1px solid #A3B4D7;
+	text-align: center;
+}
+
+div.qindex, div.navpath {
+	width: 100%;
+	line-height: 140%;
+}
+
+div.navtab {
+	margin-right: 15px;
+}
+
+/* @group Link Styling */
+
+a {
+	color: #3D578C;
+	font-weight: normal;
+	text-decoration: none;
+}
+
+.contents a:visited {
+	color: #4665A2;
+}
+
+a:hover {
+	text-decoration: underline;
+}
+
+a.qindex {
+	font-weight: bold;
+}
+
+a.qindexHL {
+	font-weight: bold;
+	background-color: #9CAFD4;
+	color: #FFFFFF;
+	border: 1px double #869DCA;
+}
+
+.contents a.qindexHL:visited {
+        color: #FFFFFF;
+}
+
+a.el {
+	font-weight: bold;
+}
+
+a.elRef {
+}
+
+a.code, a.code:visited, a.line, a.line:visited {
+	color: #4665A2; 
+}
+
+a.codeRef, a.codeRef:visited, a.lineRef, a.lineRef:visited {
+	color: #4665A2; 
+}
+
+/* @end */
+
+dl.el {
+	margin-left: -1cm;
+}
+
+ul {
+  overflow: hidden; /*Fixed: list item bullets overlap floating elements*/
+}
+
+#side-nav ul {
+  overflow: visible; /* reset ul rule for scroll bar in GENERATE_TREEVIEW window */
+}
+
+#main-nav ul {
+  overflow: visible; /* reset ul rule for the navigation bar drop down lists */
+}
+
+.fragment {
+  text-align: left;
+  direction: ltr;
+  overflow-x: auto; /*Fixed: fragment lines overlap floating elements*/
+  overflow-y: hidden;
+}
+
+pre.fragment {
+        border: 1px solid #C4CFE5;
+        background-color: #FBFCFD;
+        padding: 4px 6px;
+        margin: 4px 8px 4px 2px;
+        overflow: auto;
+        word-wrap: break-word;
+        font-size:  9pt;
+        line-height: 125%;
+        font-family: monospace, fixed;
+        font-size: 105%;
+}
+
+div.fragment {
+  padding: 0 0 1px 0; /*Fixed: last line underline overlap border*/
+  margin: 4px 8px 4px 2px;
+	background-color: #FBFCFD;
+	border: 1px solid #C4CFE5;
+}
+
+div.line {
+	font-family: monospace, fixed;
+        font-size: 13px;
+	min-height: 13px;
+	line-height: 1.0;
+	text-wrap: unrestricted;
+	white-space: -moz-pre-wrap; /* Moz */
+	white-space: -pre-wrap;     /* Opera 4-6 */
+	white-space: -o-pre-wrap;   /* Opera 7 */
+	white-space: pre-wrap;      /* CSS3  */
+	word-wrap: break-word;      /* IE 5.5+ */
+	text-indent: -53px;
+	padding-left: 53px;
+	padding-bottom: 0px;
+	margin: 0px;
+	-webkit-transition-property: background-color, box-shadow;
+	-webkit-transition-duration: 0.5s;
+	-moz-transition-property: background-color, box-shadow;
+	-moz-transition-duration: 0.5s;
+	-ms-transition-property: background-color, box-shadow;
+	-ms-transition-duration: 0.5s;
+	-o-transition-property: background-color, box-shadow;
+	-o-transition-duration: 0.5s;
+	transition-property: background-color, box-shadow;
+	transition-duration: 0.5s;
+}
+
+div.line:after {
+    content:"\000A";
+    white-space: pre;
+}
+
+div.line.glow {
+	background-color: cyan;
+	box-shadow: 0 0 10px cyan;
+}
+
+
+span.lineno {
+	padding-right: 4px;
+	text-align: right;
+	border-right: 2px solid #0F0;
+	background-color: #E8E8E8;
+        white-space: pre;
+}
+span.lineno a {
+	background-color: #D8D8D8;
+}
+
+span.lineno a:hover {
+	background-color: #C8C8C8;
+}
+
+.lineno {
+	-webkit-touch-callout: none;
+	-webkit-user-select: none;
+	-khtml-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+}
+
+div.ah, span.ah {
+	background-color: black;
+	font-weight: bold;
+	color: #FFFFFF;
+	margin-bottom: 3px;
+	margin-top: 3px;
+	padding: 0.2em;
+	border: solid thin #333;
+	border-radius: 0.5em;
+	-webkit-border-radius: .5em;
+	-moz-border-radius: .5em;
+	box-shadow: 2px 2px 3px #999;
+	-webkit-box-shadow: 2px 2px 3px #999;
+	-moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
+	background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444));
+	background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000 110%);
+}
+
+div.classindex ul {
+        list-style: none;
+        padding-left: 0;
+}
+
+div.classindex span.ai {
+        display: inline-block;
+}
+
+div.groupHeader {
+	margin-left: 16px;
+	margin-top: 12px;
+	font-weight: bold;
+}
+
+div.groupText {
+	margin-left: 16px;
+	font-style: italic;
+}
+
+body {
+	background-color: white;
+	color: black;
+        margin: 0;
+}
+
+div.contents {
+	margin-top: 10px;
+	margin-left: 12px;
+	margin-right: 8px;
+}
+
+td.indexkey {
+	background-color: #EBEFF6;
+	font-weight: bold;
+	border: 1px solid #C4CFE5;
+	margin: 2px 0px 2px 0;
+	padding: 2px 10px;
+        white-space: nowrap;
+        vertical-align: top;
+}
+
+td.indexvalue {
+	background-color: #EBEFF6;
+	border: 1px solid #C4CFE5;
+	padding: 2px 10px;
+	margin: 2px 0px;
+}
+
+tr.memlist {
+	background-color: #EEF1F7;
+}
+
+p.formulaDsp {
+	text-align: center;
+}
+
+img.formulaDsp {
+	
+}
+
+img.formulaInl, img.inline {
+	vertical-align: middle;
+}
+
+div.center {
+	text-align: center;
+        margin-top: 0px;
+        margin-bottom: 0px;
+        padding: 0px;
+}
+
+div.center img {
+	border: 0px;
+}
+
+address.footer {
+	text-align: right;
+	padding-right: 12px;
+}
+
+img.footer {
+	border: 0px;
+	vertical-align: middle;
+}
+
+/* @group Code Colorization */
+
+span.keyword {
+	color: #008000
+}
+
+span.keywordtype {
+	color: #604020
+}
+
+span.keywordflow {
+	color: #e08000
+}
+
+span.comment {
+	color: #800000
+}
+
+span.preprocessor {
+	color: #806020
+}
+
+span.stringliteral {
+	color: #002080
+}
+
+span.charliteral {
+	color: #008080
+}
+
+span.vhdldigit { 
+	color: #ff00ff 
+}
+
+span.vhdlchar { 
+	color: #000000 
+}
+
+span.vhdlkeyword { 
+	color: #700070 
+}
+
+span.vhdllogic { 
+	color: #ff0000 
+}
+
+blockquote {
+        background-color: #F7F8FB;
+        border-left: 2px solid #9CAFD4;
+        margin: 0 24px 0 4px;
+        padding: 0 12px 0 16px;
+}
+
+blockquote.DocNodeRTL {
+   border-left: 0;
+   border-right: 2px solid #9CAFD4;
+   margin: 0 4px 0 24px;
+   padding: 0 16px 0 12px;
+}
+
+/* @end */
+
+/*
+.search {
+	color: #003399;
+	font-weight: bold;
+}
+
+form.search {
+	margin-bottom: 0px;
+	margin-top: 0px;
+}
+
+input.search {
+	font-size: 75%;
+	color: #000080;
+	font-weight: normal;
+	background-color: #e8eef2;
+}
+*/
+
+td.tiny {
+	font-size: 75%;
+}
+
+.dirtab {
+	padding: 4px;
+	border-collapse: collapse;
+	border: 1px solid #A3B4D7;
+}
+
+th.dirtab {
+	background: #EBEFF6;
+	font-weight: bold;
+}
+
+hr {
+	height: 0px;
+	border: none;
+	border-top: 1px solid #4A6AAA;
+}
+
+hr.footer {
+	height: 1px;
+}
+
+/* @group Member Descriptions */
+
+table.memberdecls {
+	border-spacing: 0px;
+	padding: 0px;
+}
+
+.memberdecls td, .fieldtable tr {
+	-webkit-transition-property: background-color, box-shadow;
+	-webkit-transition-duration: 0.5s;
+	-moz-transition-property: background-color, box-shadow;
+	-moz-transition-duration: 0.5s;
+	-ms-transition-property: background-color, box-shadow;
+	-ms-transition-duration: 0.5s;
+	-o-transition-property: background-color, box-shadow;
+	-o-transition-duration: 0.5s;
+	transition-property: background-color, box-shadow;
+	transition-duration: 0.5s;
+}
+
+.memberdecls td.glow, .fieldtable tr.glow {
+	background-color: cyan;
+	box-shadow: 0 0 15px cyan;
+}
+
+.mdescLeft, .mdescRight,
+.memItemLeft, .memItemRight,
+.memTemplItemLeft, .memTemplItemRight, .memTemplParams {
+	background-color: #F9FAFC;
+	border: none;
+	margin: 4px;
+	padding: 1px 0 0 8px;
+}
+
+.mdescLeft, .mdescRight {
+	padding: 0px 8px 4px 8px;
+	color: #555;
+}
+
+.memSeparator {
+        border-bottom: 1px solid #DEE4F0;
+        line-height: 1px;
+        margin: 0px;
+        padding: 0px;
+}
+
+.memItemLeft, .memTemplItemLeft {
+        white-space: nowrap;
+}
+
+.memItemRight, .memTemplItemRight {
+	width: 100%;
+}
+
+.memTemplParams {
+	color: #4665A2;
+        white-space: nowrap;
+	font-size: 80%;
+}
+
+/* @end */
+
+/* @group Member Details */
+
+/* Styles for detailed member documentation */
+
+.memtitle {
+	padding: 8px;
+	border-top: 1px solid #A8B8D9;
+	border-left: 1px solid #A8B8D9;
+	border-right: 1px solid #A8B8D9;
+	border-top-right-radius: 4px;
+	border-top-left-radius: 4px;
+	margin-bottom: -1px;
+	background-image: url('nav_f.png');
+	background-repeat: repeat-x;
+	background-color: #E2E8F2;
+	line-height: 1.25;
+	font-weight: 300;
+	float:left;
+}
+
+.permalink
+{
+        font-size: 65%;
+        display: inline-block;
+        vertical-align: middle;
+}
+
+.memtemplate {
+	font-size: 80%;
+	color: #4665A2;
+	font-weight: normal;
+	margin-left: 9px;
+}
+
+.memnav {
+	background-color: #EBEFF6;
+	border: 1px solid #A3B4D7;
+	text-align: center;
+	margin: 2px;
+	margin-right: 15px;
+	padding: 2px;
+}
+
+.mempage {
+	width: 100%;
+}
+
+.memitem {
+	padding: 0;
+	margin-bottom: 10px;
+	margin-right: 5px;
+        -webkit-transition: box-shadow 0.5s linear;
+        -moz-transition: box-shadow 0.5s linear;
+        -ms-transition: box-shadow 0.5s linear;
+        -o-transition: box-shadow 0.5s linear;
+        transition: box-shadow 0.5s linear;
+        display: table !important;
+        width: 100%;
+}
+
+.memitem.glow {
+         box-shadow: 0 0 15px cyan;
+}
+
+.memname {
+        font-weight: 400;
+        margin-left: 6px;
+}
+
+.memname td {
+	vertical-align: bottom;
+}
+
+.memproto, dl.reflist dt {
+        border-top: 1px solid #A8B8D9;
+        border-left: 1px solid #A8B8D9;
+        border-right: 1px solid #A8B8D9;
+        padding: 6px 0px 6px 0px;
+        color: #253555;
+        font-weight: bold;
+        text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+        background-color: #DFE5F1;
+        /* opera specific markup */
+        box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        border-top-right-radius: 4px;
+        /* firefox specific markup */
+        -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
+        -moz-border-radius-topright: 4px;
+        /* webkit specific markup */
+        -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        -webkit-border-top-right-radius: 4px;
+
+}
+
+.overload {
+        font-family: "courier new",courier,monospace;
+	font-size: 65%;
+}
+
+.memdoc, dl.reflist dd {
+        border-bottom: 1px solid #A8B8D9;      
+        border-left: 1px solid #A8B8D9;      
+        border-right: 1px solid #A8B8D9; 
+        padding: 6px 10px 2px 10px;
+        background-color: #FBFCFD;
+        border-top-width: 0;
+        background-image:url('nav_g.png');
+        background-repeat:repeat-x;
+        background-color: #FFFFFF;
+        /* opera specific markup */
+        border-bottom-left-radius: 4px;
+        border-bottom-right-radius: 4px;
+        box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        /* firefox specific markup */
+        -moz-border-radius-bottomleft: 4px;
+        -moz-border-radius-bottomright: 4px;
+        -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
+        /* webkit specific markup */
+        -webkit-border-bottom-left-radius: 4px;
+        -webkit-border-bottom-right-radius: 4px;
+        -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+}
+
+dl.reflist dt {
+        padding: 5px;
+}
+
+dl.reflist dd {
+        margin: 0px 0px 10px 0px;
+        padding: 5px;
+}
+
+.paramkey {
+	text-align: right;
+}
+
+.paramtype {
+	white-space: nowrap;
+}
+
+.paramname {
+	color: #602020;
+	white-space: nowrap;
+}
+.paramname em {
+	font-style: normal;
+}
+.paramname code {
+        line-height: 14px;
+}
+
+.params, .retval, .exception, .tparams {
+        margin-left: 0px;
+        padding-left: 0px;
+}       
+
+.params .paramname, .retval .paramname, .tparams .paramname, .exception .paramname {
+        font-weight: bold;
+        vertical-align: top;
+}
+        
+.params .paramtype, .tparams .paramtype {
+        font-style: italic;
+        vertical-align: top;
+}       
+        
+.params .paramdir, .tparams .paramdir {
+        font-family: "courier new",courier,monospace;
+        vertical-align: top;
+}
+
+table.mlabels {
+	border-spacing: 0px;
+}
+
+td.mlabels-left {
+	width: 100%;
+	padding: 0px;
+}
+
+td.mlabels-right {
+	vertical-align: bottom;
+	padding: 0px;
+	white-space: nowrap;
+}
+
+span.mlabels {
+        margin-left: 8px;
+}
+
+span.mlabel {
+        background-color: #728DC1;
+        border-top:1px solid #5373B4;
+        border-left:1px solid #5373B4;
+        border-right:1px solid #C4CFE5;
+        border-bottom:1px solid #C4CFE5;
+	text-shadow: none;
+	color: white;
+	margin-right: 4px;
+	padding: 2px 3px;
+	border-radius: 3px;
+	font-size: 7pt;
+	white-space: nowrap;
+	vertical-align: middle;
+}
+
+
+
+/* @end */
+
+/* these are for tree view inside a (index) page */
+
+div.directory {
+        margin: 10px 0px;
+        border-top: 1px solid #9CAFD4;
+        border-bottom: 1px solid #9CAFD4;
+        width: 100%;
+}
+
+.directory table {
+        border-collapse:collapse;
+}
+
+.directory td {
+        margin: 0px;
+        padding: 0px;
+	vertical-align: top;
+}
+
+.directory td.entry {
+        white-space: nowrap;
+        padding-right: 6px;
+	padding-top: 3px;
+}
+
+.directory td.entry a {
+        outline:none;
+}
+
+.directory td.entry a img {
+        border: none;
+}
+
+.directory td.desc {
+        width: 100%;
+        padding-left: 6px;
+	padding-right: 6px;
+	padding-top: 3px;
+	border-left: 1px solid rgba(0,0,0,0.05);
+}
+
+.directory tr.even {
+	padding-left: 6px;
+	background-color: #F7F8FB;
+}
+
+.directory img {
+	vertical-align: -30%;
+}
+
+.directory .levels {
+        white-space: nowrap;
+        width: 100%;
+        text-align: right;
+        font-size: 9pt;
+}
+
+.directory .levels span {
+        cursor: pointer;
+        padding-left: 2px;
+        padding-right: 2px;
+	color: #3D578C;
+}
+
+.arrow {
+    color: #9CAFD4;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+    cursor: pointer;
+    font-size: 80%;
+    display: inline-block;
+    width: 16px;
+    height: 22px;
+}
+
+.icon {
+    font-family: Arial, Helvetica;
+    font-weight: bold;
+    font-size: 12px;
+    height: 14px;
+    width: 16px;
+    display: inline-block;
+    background-color: #728DC1;
+    color: white;
+    text-align: center;
+    border-radius: 4px;
+    margin-left: 2px;
+    margin-right: 2px;
+}
+
+.icona {
+    width: 24px;
+    height: 22px;
+    display: inline-block;
+}
+
+.iconfopen {
+    width: 24px;
+    height: 18px;
+    margin-bottom: 4px;
+    background-image:url('folderopen.png');
+    background-position: 0px -4px;
+    background-repeat: repeat-y;
+    vertical-align:top;
+    display: inline-block;
+}
+
+.iconfclosed {
+    width: 24px;
+    height: 18px;
+    margin-bottom: 4px;
+    background-image:url('folderclosed.png');
+    background-position: 0px -4px;
+    background-repeat: repeat-y;
+    vertical-align:top;
+    display: inline-block;
+}
+
+.icondoc {
+    width: 24px;
+    height: 18px;
+    margin-bottom: 4px;
+    background-image:url('doc.png');
+    background-position: 0px -4px;
+    background-repeat: repeat-y;
+    vertical-align:top;
+    display: inline-block;
+}
+
+table.directory {
+    font: 400 14px Roboto,sans-serif;
+}
+
+/* @end */
+
+div.dynheader {
+        margin-top: 8px;
+	-webkit-touch-callout: none;
+	-webkit-user-select: none;
+	-khtml-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+}
+
+address {
+	font-style: normal;
+	color: #2A3D61;
+}
+
+table.doxtable caption {
+	caption-side: top;
+}
+
+table.doxtable {
+	border-collapse:collapse;
+        margin-top: 4px;
+        margin-bottom: 4px;
+}
+
+table.doxtable td, table.doxtable th {
+	border: 1px solid #2D4068;
+	padding: 3px 7px 2px;
+}
+
+table.doxtable th {
+	background-color: #374F7F;
+	color: #FFFFFF;
+	font-size: 110%;
+	padding-bottom: 4px;
+	padding-top: 5px;
+}
+
+table.fieldtable {
+        /*width: 100%;*/
+        margin-bottom: 10px;
+        border: 1px solid #A8B8D9;
+        border-spacing: 0px;
+        -moz-border-radius: 4px;
+        -webkit-border-radius: 4px;
+        border-radius: 4px;
+        -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
+        -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15);
+        box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15);
+}
+
+.fieldtable td, .fieldtable th {
+        padding: 3px 7px 2px;
+}
+
+.fieldtable td.fieldtype, .fieldtable td.fieldname {
+        white-space: nowrap;
+        border-right: 1px solid #A8B8D9;
+        border-bottom: 1px solid #A8B8D9;
+        vertical-align: top;
+}
+
+.fieldtable td.fieldname {
+        padding-top: 3px;
+}
+
+.fieldtable td.fielddoc {
+        border-bottom: 1px solid #A8B8D9;
+        /*width: 100%;*/
+}
+
+.fieldtable td.fielddoc p:first-child {
+        margin-top: 0px;
+}       
+        
+.fieldtable td.fielddoc p:last-child {
+        margin-bottom: 2px;
+}
+
+.fieldtable tr:last-child td {
+        border-bottom: none;
+}
+
+.fieldtable th {
+        background-image:url('nav_f.png');
+        background-repeat:repeat-x;
+        background-color: #E2E8F2;
+        font-size: 90%;
+        color: #253555;
+        padding-bottom: 4px;
+        padding-top: 5px;
+        text-align:left;
+        font-weight: 400;
+        -moz-border-radius-topleft: 4px;
+        -moz-border-radius-topright: 4px;
+        -webkit-border-top-left-radius: 4px;
+        -webkit-border-top-right-radius: 4px;
+        border-top-left-radius: 4px;
+        border-top-right-radius: 4px;
+        border-bottom: 1px solid #A8B8D9;
+}
+
+
+.tabsearch {
+	top: 0px;
+	left: 10px;
+	height: 36px;
+	background-image: url('tab_b.png');
+	z-index: 101;
+	overflow: hidden;
+	font-size: 13px;
+}
+
+.navpath ul
+{
+	font-size: 11px;
+	background-image:url('tab_b.png');
+	background-repeat:repeat-x;
+	background-position: 0 -5px;
+	height:30px;
+	line-height:30px;
+	color:#8AA0CC;
+	border:solid 1px #C2CDE4;
+	overflow:hidden;
+	margin:0px;
+	padding:0px;
+}
+
+.navpath li
+{
+	list-style-type:none;
+	float:left;
+	padding-left:10px;
+	padding-right:15px;
+	background-image:url('bc_s.png');
+	background-repeat:no-repeat;
+	background-position:right;
+	color:#364D7C;
+}
+
+.navpath li.navelem a
+{
+	height:32px;
+	display:block;
+	text-decoration: none;
+	outline: none;
+	color: #283A5D;
+	font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif;
+	text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+	text-decoration: none;        
+}
+
+.navpath li.navelem a:hover
+{
+	color:#6884BD;
+}
+
+.navpath li.footer
+{
+        list-style-type:none;
+        float:right;
+        padding-left:10px;
+        padding-right:15px;
+        background-image:none;
+        background-repeat:no-repeat;
+        background-position:right;
+        color:#364D7C;
+        font-size: 8pt;
+}
+
+
+div.summary
+{
+	float: right;
+	font-size: 8pt;
+	padding-right: 5px;
+	width: 50%;
+	text-align: right;
+}       
+
+div.summary a
+{
+	white-space: nowrap;
+}
+
+table.classindex
+{
+        margin: 10px;
+        white-space: nowrap;
+        margin-left: 3%;
+        margin-right: 3%;
+        width: 94%;
+        border: 0;
+        border-spacing: 0; 
+        padding: 0;
+}
+
+div.ingroups
+{
+	font-size: 8pt;
+	width: 50%;
+	text-align: left;
+}
+
+div.ingroups a
+{
+	white-space: nowrap;
+}
+
+div.header
+{
+        background-image:url('nav_h.png');
+        background-repeat:repeat-x;
+	background-color: #F9FAFC;
+	margin:  0px;
+	border-bottom: 1px solid #C4CFE5;
+}
+
+div.headertitle
+{
+	padding: 5px 5px 5px 10px;
+}
+
+.PageDocRTL-title div.headertitle {
+  text-align: right;
+  direction: rtl;
+}
+
+dl {
+        padding: 0 0 0 0;
+}
+
+/* dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug, dl.examples */
+dl.section {
+	margin-left: 0px;
+	padding-left: 0px;
+}
+
+dl.section.DocNodeRTL {
+  margin-right: 0px;
+  padding-right: 0px;
+}
+
+dl.note {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #D0C000;
+}
+
+dl.note.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #D0C000;
+}
+
+dl.warning, dl.attention {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #FF0000;
+}
+
+dl.warning.DocNodeRTL, dl.attention.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #FF0000;
+}
+
+dl.pre, dl.post, dl.invariant {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #00D000;
+}
+
+dl.pre.DocNodeRTL, dl.post.DocNodeRTL, dl.invariant.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #00D000;
+}
+
+dl.deprecated {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #505050;
+}
+
+dl.deprecated.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #505050;
+}
+
+dl.todo {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #00C0E0;
+}
+
+dl.todo.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #00C0E0;
+}
+
+dl.test {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #3030E0;
+}
+
+dl.test.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #3030E0;
+}
+
+dl.bug {
+  margin-left: -7px;
+  padding-left: 3px;
+  border-left: 4px solid;
+  border-color: #C08050;
+}
+
+dl.bug.DocNodeRTL {
+  margin-left: 0;
+  padding-left: 0;
+  border-left: 0;
+  margin-right: -7px;
+  padding-right: 3px;
+  border-right: 4px solid;
+  border-color: #C08050;
+}
+
+dl.section dd {
+	margin-bottom: 6px;
+}
+
+
+#projectlogo
+{
+	text-align: center;
+	vertical-align: bottom;
+	border-collapse: separate;
+}
+ 
+#projectlogo img
+{ 
+	border: 0px none;
+}
+ 
+#projectalign
+{
+        vertical-align: middle;
+}
+
+#projectname
+{
+	font: 300% Tahoma, Arial,sans-serif;
+	margin: 0px;
+	padding: 2px 0px;
+}
+    
+#projectbrief
+{
+	font: 120% Tahoma, Arial,sans-serif;
+	margin: 0px;
+	padding: 0px;
+}
+
+#projectnumber
+{
+	font: 50% Tahoma, Arial,sans-serif;
+	margin: 0px;
+	padding: 0px;
+}
+
+#titlearea
+{
+	padding: 0px;
+	margin: 0px;
+	width: 100%;
+	border-bottom: 1px solid #5373B4;
+}
+
+.image
+{
+        text-align: center;
+}
+
+.dotgraph
+{
+        text-align: center;
+}
+
+.mscgraph
+{
+        text-align: center;
+}
+
+.plantumlgraph
+{
+        text-align: center;
+}
+
+.diagraph
+{
+        text-align: center;
+}
+
+.caption
+{
+	font-weight: bold;
+}
+
+div.zoom
+{
+	border: 1px solid #90A5CE;
+}
+
+dl.citelist {
+        margin-bottom:50px;
+}
+
+dl.citelist dt {
+        color:#334975;
+        float:left;
+        font-weight:bold;
+        margin-right:10px;
+        padding:5px;
+}
+
+dl.citelist dd {
+        margin:2px 0;
+        padding:5px 0;
+}
+
+div.toc {
+        padding: 14px 25px;
+        background-color: #F4F6FA;
+        border: 1px solid #D8DFEE;
+        border-radius: 7px 7px 7px 7px;
+        float: right;
+        height: auto;
+        margin: 0 8px 10px 10px;
+        width: 200px;
+}
+
+.PageDocRTL-title div.toc {
+  float: left !important;
+  text-align: right;
+}
+
+div.toc li {
+        background: url("bdwn.png") no-repeat scroll 0 5px transparent;
+        font: 10px/1.2 Verdana,DejaVu Sans,Geneva,sans-serif;
+        margin-top: 5px;
+        padding-left: 10px;
+        padding-top: 2px;
+}
+
+.PageDocRTL-title div.toc li {
+  background-position-x: right !important;
+  padding-left: 0 !important;
+  padding-right: 10px;
+}
+
+div.toc h3 {
+        font: bold 12px/1.2 Arial,FreeSans,sans-serif;
+	color: #4665A2;
+        border-bottom: 0 none;
+        margin: 0;
+}
+
+div.toc ul {
+        list-style: none outside none;
+        border: medium none;
+        padding: 0px;
+}       
+
+div.toc li.level1 {
+        margin-left: 0px;
+}
+
+div.toc li.level2 {
+        margin-left: 15px;
+}
+
+div.toc li.level3 {
+        margin-left: 30px;
+}
+
+div.toc li.level4 {
+        margin-left: 45px;
+}
+
+.PageDocRTL-title div.toc li.level1 {
+  margin-left: 0 !important;
+  margin-right: 0;
+}
+
+.PageDocRTL-title div.toc li.level2 {
+  margin-left: 0 !important;
+  margin-right: 15px;
+}
+
+.PageDocRTL-title div.toc li.level3 {
+  margin-left: 0 !important;
+  margin-right: 30px;
+}
+
+.PageDocRTL-title div.toc li.level4 {
+  margin-left: 0 !important;
+  margin-right: 45px;
+}
+
+.inherit_header {
+        font-weight: bold;
+        color: gray;
+        cursor: pointer;
+	-webkit-touch-callout: none;
+	-webkit-user-select: none;
+	-khtml-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+}
+
+.inherit_header td {
+        padding: 6px 0px 2px 5px;
+}
+
+.inherit {
+        display: none;
+}
+
+tr.heading h2 {
+        margin-top: 12px;
+        margin-bottom: 4px;
+}
+
+/* tooltip related style info */
+
+.ttc {
+        position: absolute;
+        display: none;
+}
+
+#powerTip {
+	cursor: default;
+	white-space: nowrap;
+	background-color: white;
+	border: 1px solid gray;
+	border-radius: 4px 4px 4px 4px;
+	box-shadow: 1px 1px 7px gray;
+	display: none;
+	font-size: smaller;
+	max-width: 80%;
+	opacity: 0.9;
+	padding: 1ex 1em 1em;
+	position: absolute;
+	z-index: 2147483647;
+}
+
+#powerTip div.ttdoc {
+        color: grey;
+	font-style: italic;
+}
+
+#powerTip div.ttname a {
+        font-weight: bold;
+}
+
+#powerTip div.ttname {
+        font-weight: bold;
+}
+
+#powerTip div.ttdeci {
+        color: #006318;
+}
+
+#powerTip div {
+        margin: 0px;
+        padding: 0px;
+        font: 12px/16px Roboto,sans-serif;
+}
+
+#powerTip:before, #powerTip:after {
+	content: "";
+	position: absolute;
+	margin: 0px;
+}
+
+#powerTip.n:after,  #powerTip.n:before,
+#powerTip.s:after,  #powerTip.s:before,
+#powerTip.w:after,  #powerTip.w:before,
+#powerTip.e:after,  #powerTip.e:before,
+#powerTip.ne:after, #powerTip.ne:before,
+#powerTip.se:after, #powerTip.se:before,
+#powerTip.nw:after, #powerTip.nw:before,
+#powerTip.sw:after, #powerTip.sw:before {
+	border: solid transparent;
+	content: " ";
+	height: 0;
+	width: 0;
+	position: absolute;
+}
+
+#powerTip.n:after,  #powerTip.s:after,
+#powerTip.w:after,  #powerTip.e:after,
+#powerTip.nw:after, #powerTip.ne:after,
+#powerTip.sw:after, #powerTip.se:after {
+	border-color: rgba(255, 255, 255, 0);
+}
+
+#powerTip.n:before,  #powerTip.s:before,
+#powerTip.w:before,  #powerTip.e:before,
+#powerTip.nw:before, #powerTip.ne:before,
+#powerTip.sw:before, #powerTip.se:before {
+	border-color: rgba(128, 128, 128, 0);
+}
+
+#powerTip.n:after,  #powerTip.n:before,
+#powerTip.ne:after, #powerTip.ne:before,
+#powerTip.nw:after, #powerTip.nw:before {
+	top: 100%;
+}
+
+#powerTip.n:after, #powerTip.ne:after, #powerTip.nw:after {
+	border-top-color: #FFFFFF;
+	border-width: 10px;
+	margin: 0px -10px;
+}
+#powerTip.n:before {
+	border-top-color: #808080;
+	border-width: 11px;
+	margin: 0px -11px;
+}
+#powerTip.n:after, #powerTip.n:before {
+	left: 50%;
+}
+
+#powerTip.nw:after, #powerTip.nw:before {
+	right: 14px;
+}
+
+#powerTip.ne:after, #powerTip.ne:before {
+	left: 14px;
+}
+
+#powerTip.s:after,  #powerTip.s:before,
+#powerTip.se:after, #powerTip.se:before,
+#powerTip.sw:after, #powerTip.sw:before {
+	bottom: 100%;
+}
+
+#powerTip.s:after, #powerTip.se:after, #powerTip.sw:after {
+	border-bottom-color: #FFFFFF;
+	border-width: 10px;
+	margin: 0px -10px;
+}
+
+#powerTip.s:before, #powerTip.se:before, #powerTip.sw:before {
+	border-bottom-color: #808080;
+	border-width: 11px;
+	margin: 0px -11px;
+}
+
+#powerTip.s:after, #powerTip.s:before {
+	left: 50%;
+}
+
+#powerTip.sw:after, #powerTip.sw:before {
+	right: 14px;
+}
+
+#powerTip.se:after, #powerTip.se:before {
+	left: 14px;
+}
+
+#powerTip.e:after, #powerTip.e:before {
+	left: 100%;
+}
+#powerTip.e:after {
+	border-left-color: #FFFFFF;
+	border-width: 10px;
+	top: 50%;
+	margin-top: -10px;
+}
+#powerTip.e:before {
+	border-left-color: #808080;
+	border-width: 11px;
+	top: 50%;
+	margin-top: -11px;
+}
+
+#powerTip.w:after, #powerTip.w:before {
+	right: 100%;
+}
+#powerTip.w:after {
+	border-right-color: #FFFFFF;
+	border-width: 10px;
+	top: 50%;
+	margin-top: -10px;
+}
+#powerTip.w:before {
+	border-right-color: #808080;
+	border-width: 11px;
+	top: 50%;
+	margin-top: -11px;
+}
+
+@media print
+{
+  #top { display: none; }
+  #side-nav { display: none; }
+  #nav-path { display: none; }
+  body { overflow:visible; }
+  h1, h2, h3, h4, h5, h6 { page-break-after: avoid; }
+  .summary { display: none; }
+  .memitem { page-break-inside: avoid; }
+  #doc-content
+  {
+    margin-left:0 !important;
+    height:auto !important;
+    width:auto !important;
+    overflow:inherit;
+    display:inline;
+  }
+}
+
+/* @group Markdown */
+
+/*
+table.markdownTable {
+	border-collapse:collapse;
+        margin-top: 4px;
+        margin-bottom: 4px;
+}
+
+table.markdownTable td, table.markdownTable th {
+	border: 1px solid #2D4068;
+	padding: 3px 7px 2px;
+}
+
+table.markdownTableHead tr {
+}
+
+table.markdownTableBodyLeft td, table.markdownTable th {
+	border: 1px solid #2D4068;
+	padding: 3px 7px 2px;
+}
+
+th.markdownTableHeadLeft th.markdownTableHeadRight th.markdownTableHeadCenter th.markdownTableHeadNone {
+	background-color: #374F7F;
+	color: #FFFFFF;
+	font-size: 110%;
+	padding-bottom: 4px;
+	padding-top: 5px;
+}
+
+th.markdownTableHeadLeft {
+	text-align: left
+}
+
+th.markdownTableHeadRight {
+	text-align: right
+}
+
+th.markdownTableHeadCenter {
+	text-align: center
+}
+*/
+
+table.markdownTable {
+	border-collapse:collapse;
+        margin-top: 4px;
+        margin-bottom: 4px;
+}
+
+table.markdownTable td, table.markdownTable th {
+	border: 1px solid #2D4068;
+	padding: 3px 7px 2px;
+}
+
+table.markdownTable tr {
+}
+
+th.markdownTableHeadLeft, th.markdownTableHeadRight, th.markdownTableHeadCenter, th.markdownTableHeadNone {
+	background-color: #374F7F;
+	color: #FFFFFF;
+	font-size: 110%;
+	padding-bottom: 4px;
+	padding-top: 5px;
+}
+
+th.markdownTableHeadLeft, td.markdownTableBodyLeft {
+	text-align: left
+}
+
+th.markdownTableHeadRight, td.markdownTableBodyRight {
+	text-align: right
+}
+
+th.markdownTableHeadCenter, td.markdownTableBodyCenter {
+	text-align: center
+}
+
+.DocNodeRTL {
+  text-align: right;
+  direction: rtl;
+}
+
+.DocNodeLTR {
+  text-align: left;
+  direction: ltr;
+}
+
+table.DocNodeRTL {
+   width: auto;
+   margin-right: 0;
+   margin-left: auto;
+}
+
+table.DocNodeLTR {
+   width: auto;
+   margin-right: auto;
+   margin-left: 0;
+}
+
+tt, code, kbd, samp
+{
+  display: inline-block;
+  direction:ltr; 
+}
+/* @end */
+
+u {
+	text-decoration: underline;
+}
+
diff --git a/week4/softwareEng_9_4/app/html/doxygen.png b/week4/softwareEng_9_4/app/html/doxygen.png
new file mode 100644
index 0000000000000000000000000000000000000000..3ff17d807fd8aa003bed8bb2a69e8f0909592fd1
GIT binary patch
literal 3779
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

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/dynsections.js b/week4/softwareEng_9_4/app/html/dynsections.js
new file mode 100644
index 00000000..ea0a7b39
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/dynsections.js
@@ -0,0 +1,120 @@
+/*
+ @licstart  The following is the entire license notice for the
+ JavaScript code in this file.
+
+ Copyright (C) 1997-2017 by Dimitri van Heesch
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+ @licend  The above is the entire license notice
+ for the JavaScript code in this file
+ */
+function toggleVisibility(linkObj)
+{
+ var base = $(linkObj).attr('id');
+ var summary = $('#'+base+'-summary');
+ var content = $('#'+base+'-content');
+ var trigger = $('#'+base+'-trigger');
+ var src=$(trigger).attr('src');
+ if (content.is(':visible')===true) {
+   content.hide();
+   summary.show();
+   $(linkObj).addClass('closed').removeClass('opened');
+   $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png');
+ } else {
+   content.show();
+   summary.hide();
+   $(linkObj).removeClass('closed').addClass('opened');
+   $(trigger).attr('src',src.substring(0,src.length-10)+'open.png');
+ }
+ return false;
+}
+
+function updateStripes()
+{
+  $('table.directory tr').
+       removeClass('even').filter(':visible:even').addClass('even');
+}
+
+function toggleLevel(level)
+{
+  $('table.directory tr').each(function() {
+    var l = this.id.split('_').length-1;
+    var i = $('#img'+this.id.substring(3));
+    var a = $('#arr'+this.id.substring(3));
+    if (l<level+1) {
+      i.removeClass('iconfopen iconfclosed').addClass('iconfopen');
+      a.html('&#9660;');
+      $(this).show();
+    } else if (l==level+1) {
+      i.removeClass('iconfclosed iconfopen').addClass('iconfclosed');
+      a.html('&#9658;');
+      $(this).show();
+    } else {
+      $(this).hide();
+    }
+  });
+  updateStripes();
+}
+
+function toggleFolder(id)
+{
+  // the clicked row
+  var currentRow = $('#row_'+id);
+
+  // all rows after the clicked row
+  var rows = currentRow.nextAll("tr");
+
+  var re = new RegExp('^row_'+id+'\\d+_$', "i"); //only one sub
+
+  // only match elements AFTER this one (can't hide elements before)
+  var childRows = rows.filter(function() { return this.id.match(re); });
+
+  // first row is visible we are HIDING
+  if (childRows.filter(':first').is(':visible')===true) {
+    // replace down arrow by right arrow for current row
+    var currentRowSpans = currentRow.find("span");
+    currentRowSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
+    currentRowSpans.filter(".arrow").html('&#9658;');
+    rows.filter("[id^=row_"+id+"]").hide(); // hide all children
+  } else { // we are SHOWING
+    // replace right arrow by down arrow for current row
+    var currentRowSpans = currentRow.find("span");
+    currentRowSpans.filter(".iconfclosed").removeClass("iconfclosed").addClass("iconfopen");
+    currentRowSpans.filter(".arrow").html('&#9660;');
+    // replace down arrows by right arrows for child rows
+    var childRowsSpans = childRows.find("span");
+    childRowsSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
+    childRowsSpans.filter(".arrow").html('&#9658;');
+    childRows.show(); //show all children
+  }
+  updateStripes();
+}
+
+
+function toggleInherit(id)
+{
+  var rows = $('tr.inherit.'+id);
+  var img = $('tr.inherit_header.'+id+' img');
+  var src = $(img).attr('src');
+  if (rows.filter(':first').is(':visible')===true) {
+    rows.css('display','none');
+    $(img).attr('src',src.substring(0,src.length-8)+'closed.png');
+  } else {
+    rows.css('display','table-row'); // using show() causes jump in firefox
+    $(img).attr('src',src.substring(0,src.length-10)+'open.png');
+  }
+}
+/* @license-end */
diff --git a/week4/softwareEng_9_4/app/html/files.html b/week4/softwareEng_9_4/app/html/files.html
new file mode 100644
index 00000000..efcf90c9
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/files.html
@@ -0,0 +1,83 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: File List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="headertitle">
+<div class="title">File List</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">Here is a list of all files with brief descriptions:</div><div class="directory">
+<table class="directory">
+<tr id="row_0_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icondoc"></span><a class="el" href="software_eng__9__4_8cpp.html" target="_self">softwareEng_9_4.cpp</a></td><td class="desc"></td></tr>
+<tr id="row_1_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><a href="software_eng__9__4_8hpp_source.html"><span class="icondoc"></span></a><a class="el" href="software_eng__9__4_8hpp.html" target="_self">softwareEng_9_4.hpp</a></td><td class="desc"></td></tr>
+</table>
+</div><!-- directory -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/folderclosed.png b/week4/softwareEng_9_4/app/html/folderclosed.png
new file mode 100644
index 0000000000000000000000000000000000000000..bb8ab35edce8e97554e360005ee9fc5bffb36e66
GIT binary patch
literal 616
zcmV-u0+;=XP)<h;3K|Lk000e1NJLTq000;O000&U1^@s6+I?Jz0006nNkl<ZcmeHQ
zO;6N77=GINb=Z(>a9#ETzayK)T~Jw&MMH>OIr#&;dC}is*2Mqdf&akCc=O@`qC+4i
z5Iu3w#1M@KqXCz8TIZd1wli&kkl2HVcAiZ8PUn5z_kG@-y;?yK06=cA0U%H0PH+kU
zl6dp}OR(|r8-RG+YLu`zbI}5TlOU6ToR41{9=uz^?dGTNL;wIMf|V3`d1Wj3y!#6`
zBLZ?xpKR~^2x}?~zA(_NUu3IaDB$tKma*XUdOZN~c=dLt_h_k!dbxm_*ibDM<n!c>
zlFX`g{k$X}yIe%$N)cn1LNu=q<K5OS7CNKPk1f&9-+dXiicCfAy8a*|m;2$mAHWmO
zXHGi+kV1-pHt+rM<gA>9_CS)*<?(PP8<}W6a5(^^keLBRMb50K&dQM@pmn94ZU=xQ
zQX)TlxfVQ_9);_LB~VUu;v|U_-?p*(;VWJ|=^7%ZGN6sBL~)dHv|OyK(wPKdmH>>A
zsX_mM4<gjHpqc8Q=uo450T?4i;CdW;`z|<XAntIp>L@`(cSNQKMFc$RtYbx{79<Tw
zWXi-A43v#7I@t_Ijx7TKV2n(H{k|uniNrjlLmWw}y*t^*R9a-QX?;6B==9%$de=Kk
z*QYpi761&SjtX%clomR5cK>#j-J7hk*>*+ZZhM4Hw?<fJyv$}=71o`ou(^pUn-ky6
z->I?rsXCi#mRWJ=-0LGV5a-WR0Qgt<|Nqf)C-@80`5gIz45^_20000<MNUMnLSTaR
CZX#j;

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/folderopen.png b/week4/softwareEng_9_4/app/html/folderopen.png
new file mode 100644
index 0000000000000000000000000000000000000000..d6c7f676a3b3ef8c2c307d319dff3c6a604eb227
GIT binary patch
literal 597
zcmV-b0;>IqP)<h;3K|Lk000e1NJLTq000;O000&U1^@s6+I?Jz0006UNkl<ZcmeHQ
zKX21e5dS%8nlx#!9XpK>X=#(TiCT&PiIIVc55T}TU}EUh*{q$|`3@{d>{Tc9Bo>e=
zfmF3!f>fbI9#GoEHh0f`i5)wkLpva0ztf%HpZneK?w-7AK@b4Itw{y|Zd3k!fH?q2
zlhckHd_V2M_X7+)U&_Xcfvtw60l;--DgZmLSw-Y?S>)zIqMyJ1#FwLU*%bl38ok+!
zh78H87n`ZTS;uhzAR$M`zZ`bVhq=+%u9^$5jDplgxd44}9;IRqUH1YHH|@6oFe%z(
zo4)_>E$F&^P-f(#)>(TrnbE>Pefs9~@iN=|)Rz|V`sGfHNrJ)0gJb8xx+SBmRf@1l
zvuzt=vGfI)<-F9!o&3l?>9~0QbUDT(wFdnQPv%xdD)m*g%!20>Bc9iYmGAp<9YAa(
z0QgY<a!3GSVHw98r3tc|WLmCr=#k@b07--d0B^h;_*7huEOe@B5HbiIMnQNV2X-w6
zOrIHW*Nh!-3RJ{NFA7|xb7mLqy*mtQR%uj&==!8@USn{@{Ji@c`@7F#U6jIrqNF?z
zhGG8IoU)VO(*u}!lcNr&IgdJw?)fXgkFy?t@!%{)3!Y}PHt9|Ph>gTWqf1qN++Gqp
z8@AYPTB3E|6s=WLG?xw0tm|U!o=&zd+H0oRYE;Dbx+Na9s^STqX|Gnq%H8s(nGDGJ
j8vwW|`Ts`)fSK|Kx=IK@RG@g200000NkvXXu0mjfauFEA

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/functions.html b/week4/softwareEng_9_4/app/html/functions.html
new file mode 100644
index 00000000..7ddae9ef
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/functions.html
@@ -0,0 +1,84 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: Class Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="contents">
+<div class="textblock">Here is a list of all class members with links to the classes they belong to:</div><ul>
+<li>input()
+: <a class="el" href="classprinter.html#a10b05212f6167b64ebfb1b7c1cdc9ef2">printer</a>
+</li>
+<li>printer()
+: <a class="el" href="classprinter.html#adfbc169c8c36ac791744c8dc01647432">printer</a>
+</li>
+<li>printPosition()
+: <a class="el" href="classprinter.html#ae7da213aa9062bea77998b0340163c17">printer</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/functions_func.html b/week4/softwareEng_9_4/app/html/functions_func.html
new file mode 100644
index 00000000..37b30207
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/functions_func.html
@@ -0,0 +1,84 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: Class Members - Functions</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="contents">
+&#160;<ul>
+<li>input()
+: <a class="el" href="classprinter.html#a10b05212f6167b64ebfb1b7c1cdc9ef2">printer</a>
+</li>
+<li>printer()
+: <a class="el" href="classprinter.html#adfbc169c8c36ac791744c8dc01647432">printer</a>
+</li>
+<li>printPosition()
+: <a class="el" href="classprinter.html#ae7da213aa9062bea77998b0340163c17">printer</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/globals.html b/week4/softwareEng_9_4/app/html/globals.html
new file mode 100644
index 00000000..972696e4
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/globals.html
@@ -0,0 +1,78 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: File Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="contents">
+<div class="textblock">Here is a list of all file members with links to the files they belong to:</div><ul>
+<li>main()
+: <a class="el" href="software_eng__9__4_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4">softwareEng_9_4.cpp</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/globals_func.html b/week4/softwareEng_9_4/app/html/globals_func.html
new file mode 100644
index 00000000..879f76b5
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/globals_func.html
@@ -0,0 +1,78 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: File Members</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="contents">
+&#160;<ul>
+<li>main()
+: <a class="el" href="software_eng__9__4_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4">softwareEng_9_4.cpp</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/graph_legend.dot b/week4/softwareEng_9_4/app/html/graph_legend.dot
new file mode 100644
index 00000000..4d6ac8c6
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/graph_legend.dot
@@ -0,0 +1,23 @@
+digraph "Graph Legend"
+{
+ // LATEX_PDF_SIZE
+  edge [fontname="Helvetica",fontsize="10",labelfontname="Helvetica",labelfontsize="10"];
+  node [fontname="Helvetica",fontsize="10",shape=record];
+  Node9 [shape="box",label="Inherited",fontsize="10",height=0.2,width=0.4,fontname="Helvetica",fillcolor="grey75",style="filled" fontcolor="black"];
+  Node10 -> Node9 [dir="back",color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node10 [shape="box",label="PublicBase",fontsize="10",height=0.2,width=0.4,fontname="Helvetica",color="black"];
+  Node11 -> Node10 [dir="back",color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node11 [shape="box",label="Truncated",fontsize="10",height=0.2,width=0.4,fontname="Helvetica",color="red"];
+  Node13 -> Node9 [dir="back",color="darkgreen",fontsize="10",style="solid",fontname="Helvetica"];
+  Node13 [shape="box",label="ProtectedBase",fontsize="10",height=0.2,width=0.4,fontname="Helvetica",color="black"];
+  Node14 -> Node9 [dir="back",color="firebrick4",fontsize="10",style="solid",fontname="Helvetica"];
+  Node14 [shape="box",label="PrivateBase",fontsize="10",height=0.2,width=0.4,fontname="Helvetica",color="black"];
+  Node15 -> Node9 [dir="back",color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node15 [shape="box",label="Undocumented",fontsize="10",height=0.2,width=0.4,fontname="Helvetica",color="grey75"];
+  Node16 -> Node9 [dir="back",color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node16 [shape="box",label="Templ< int >",fontsize="10",height=0.2,width=0.4,fontname="Helvetica",color="black"];
+  Node17 -> Node16 [dir="back",color="orange",fontsize="10",style="dashed",label="< int >",fontname="Helvetica"];
+  Node17 [shape="box",label="Templ< T >",fontsize="10",height=0.2,width=0.4,fontname="Helvetica",color="black"];
+  Node18 -> Node9 [dir="back",color="darkorchid3",fontsize="10",style="dashed",label="m_usedClass",fontname="Helvetica"];
+  Node18 [shape="box",label="Used",fontsize="10",height=0.2,width=0.4,fontname="Helvetica",color="black"];
+}
diff --git a/week4/softwareEng_9_4/app/html/graph_legend.html b/week4/softwareEng_9_4/app/html/graph_legend.html
new file mode 100644
index 00000000..eb3a3101
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/graph_legend.html
@@ -0,0 +1,137 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: Graph Legend</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="headertitle">
+<div class="title">Graph Legend</div>  </div>
+</div><!--header-->
+<div class="contents">
+<p>This page explains how to interpret the graphs that are generated by doxygen.</p>
+<p>Consider the following example: </p><div class="fragment"><div class="line"><span class="comment">/*! Invisible class because of truncation */</span></div>
+<div class="line"><span class="keyword">class </span>Invisible { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! Truncated class, inheritance relation is hidden */</span></div>
+<div class="line"><span class="keyword">class </span>Truncated : <span class="keyword">public</span> Invisible { };</div>
+<div class="line"> </div>
+<div class="line"><span class="comment">/* Class not documented with doxygen comments */</span></div>
+<div class="line"><span class="keyword">class </span>Undocumented { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! Class that is inherited using public inheritance */</span></div>
+<div class="line"><span class="keyword">class </span>PublicBase : <span class="keyword">public</span> Truncated { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! A template class */</span></div>
+<div class="line"><span class="keyword">template</span>&lt;<span class="keyword">class</span> T&gt; <span class="keyword">class </span>Templ { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! Class that is inherited using protected inheritance */</span></div>
+<div class="line"><span class="keyword">class </span>ProtectedBase { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! Class that is inherited using private inheritance */</span></div>
+<div class="line"><span class="keyword">class </span>PrivateBase { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! Class that is used by the Inherited class */</span></div>
+<div class="line"><span class="keyword">class </span>Used { };</div>
+<div class="line"><span class="comment"></span> </div>
+<div class="line"><span class="comment">/*! Super class that inherits a number of other classes */</span></div>
+<div class="line"><span class="keyword">class </span>Inherited : <span class="keyword">public</span> PublicBase,</div>
+<div class="line">                  <span class="keyword">protected</span> ProtectedBase,</div>
+<div class="line">                  <span class="keyword">private</span> PrivateBase,</div>
+<div class="line">                  <span class="keyword">public</span> Undocumented,</div>
+<div class="line">                  <span class="keyword">public</span> Templ&lt;int&gt;</div>
+<div class="line">{</div>
+<div class="line">  <span class="keyword">private</span>:</div>
+<div class="line">    Used *m_usedClass;</div>
+<div class="line">};</div>
+</div><!-- fragment --><p> This will result in the following graph:</p>
+<center><img src="graph_legend.png" alt="" class="inline"/></center><p>The boxes in the above graph have the following meaning: </p>
+<ul>
+<li>
+A filled gray box represents the struct or class for which the graph is generated. </li>
+<li>
+A box with a black border denotes a documented struct or class. </li>
+<li>
+A box with a gray border denotes an undocumented struct or class. </li>
+<li>
+A box with a red border denotes a documented struct or class forwhich not all inheritance/containment relations are shown. A graph is truncated if it does not fit within the specified boundaries. </li>
+</ul>
+<p>The arrows have the following meaning: </p>
+<ul>
+<li>
+A dark blue arrow is used to visualize a public inheritance relation between two classes. </li>
+<li>
+A dark green arrow is used for protected inheritance. </li>
+<li>
+A dark red arrow is used for private inheritance. </li>
+<li>
+A purple dashed arrow is used if a class is contained or used by another class. The arrow is labelled with the variable(s) through which the pointed class or struct is accessible. </li>
+<li>
+A yellow dashed arrow denotes a relation between a template instance and the template class it was instantiated from. The arrow is labelled with the template parameters of the instance. </li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/index.html b/week4/softwareEng_9_4/app/html/index.html
new file mode 100644
index 00000000..80408a10
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/index.html
@@ -0,0 +1,77 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: Main Page</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="headertitle">
+<div class="title">PrintPosition Documentation</div>  </div>
+</div><!--header-->
+<div class="contents">
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/jquery.js b/week4/softwareEng_9_4/app/html/jquery.js
new file mode 100644
index 00000000..103c32d7
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/jquery.js
@@ -0,0 +1,35 @@
+/*! jQuery v3.4.1 | (c) JS Foundation and other contributors | jquery.org/license */
+!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],E=C.document,r=Object.getPrototypeOf,s=t.slice,g=t.concat,u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType},x=function(e){return null!=e&&e===e.window},c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.4.1",k=function(e,t){return new k.fn.init(e,t)},p=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;function d(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}k.fn=k.prototype={jquery:f,constructor:k,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=k.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return k.each(this,e)},map:function(n){return this.pushStack(k.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:t.sort,splice:t.splice},k.extend=k.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||m(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(k.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||k.isPlainObject(n)?n:{},i=!1,a[t]=k.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},k.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==o.call(e))&&(!(t=r(e))||"function"==typeof(n=v.call(t,"constructor")&&t.constructor)&&a.call(n)===l)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t){b(e,{nonce:t&&t.nonce})},each:function(e,t){var n,r=0;if(d(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},trim:function(e){return null==e?"":(e+"").replace(p,"")},makeArray:function(e,t){var n=t||[];return null!=e&&(d(Object(e))?k.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:i.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(d(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g.apply([],a)},guid:1,support:y}),"function"==typeof Symbol&&(k.fn[Symbol.iterator]=t[Symbol.iterator]),k.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var h=function(n){var e,d,b,o,i,h,f,g,w,u,l,T,C,a,E,v,s,c,y,k="sizzle"+1*new Date,m=n.document,S=0,r=0,p=ue(),x=ue(),N=ue(),A=ue(),D=function(e,t){return e===t&&(l=!0),0},j={}.hasOwnProperty,t=[],q=t.pop,L=t.push,H=t.push,O=t.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",I="(?:\\\\.|[\\w-]|[^\0-\\xa0])+",W="\\["+M+"*("+I+")(?:"+M+"*([*^$|!~]?=)"+M+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+M+"*\\]",$=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",F=new RegExp(M+"+","g"),B=new RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=new RegExp("^"+M+"*,"+M+"*"),z=new RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp($),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+$),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\([\\da-f]{1,6}"+M+"?|("+M+")|.)","ig"),ne=function(e,t,n){var r="0x"+t-65536;return r!=r||n?t:r<0?String.fromCharCode(r+65536):String.fromCharCode(r>>10|55296,1023&r|56320)},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(m.childNodes),m.childNodes),t[m.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&((e?e.ownerDocument||e:m)!==C&&T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!A[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&U.test(t)){(s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=k),o=(l=h(t)).length;while(o--)l[o]="#"+s+" "+xe(l[o]);c=l.join(","),f=ee.test(t)&&ye(e.parentNode)||e}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){A(t,!0)}finally{s===k&&e.removeAttribute("id")}}}return g(t.replace(B,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[k]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:m;return r!==C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),m!==C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=k,!C.getElementsByName||!C.getElementsByName(k).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){a.appendChild(e).innerHTML="<a id='"+k+"'></a><select id='"+k+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+k+"-]").length||v.push("~="),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+k+"+*").length||v.push(".#.+[+~]")}),ce(function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",$)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},D=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)===(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e===C||e.ownerDocument===m&&y(m,e)?-1:t===C||t.ownerDocument===m&&y(m,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e===C?-1:t===C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]===m?-1:s[r]===m?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if((e.ownerDocument||e)!==C&&T(e),d.matchesSelector&&E&&!A[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){A(t,!0)}return 0<se(t,C,null,[e]).length},se.contains=function(e,t){return(e.ownerDocument||e)!==C&&T(e),y(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!==C&&T(e);var n=b.attrHandle[t.toLowerCase()],r=n&&j.call(b.attrHandle,t.toLowerCase())?n(e,t,!E):void 0;return void 0!==r?r:d.attributes||!E?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},se.escape=function(e){return(e+"").replace(re,ie)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,n=[],r=0,i=0;if(l=!d.detectDuplicates,u=!d.sortStable&&e.slice(0),e.sort(D),l){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return u=null,e},o=se.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(1===i||9===i||11===i){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=o(e)}else if(3===i||4===i)return e.nodeValue}else while(t=e[r++])n+=o(t);return n},(b=se.selectors={cacheLength:50,createPseudo:le,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=p[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&p(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1<t.indexOf(i):"$="===r?i&&t.slice(-i.length)===i:"~="===r?-1<(" "+t.replace(F," ")+" ").indexOf(i):"|="===r&&(t===i||t.slice(0,i.length+1)===i+"-"))}},CHILD:function(h,e,t,g,v){var y="nth"!==h.slice(0,3),m="last"!==h.slice(-4),x="of-type"===e;return 1===g&&0===v?function(e){return!!e.parentNode}:function(e,t,n){var r,i,o,a,s,u,l=y!==m?"nextSibling":"previousSibling",c=e.parentNode,f=x&&e.nodeName.toLowerCase(),p=!n&&!x,d=!1;if(c){if(y){while(l){a=e;while(a=a[l])if(x?a.nodeName.toLowerCase()===f:1===a.nodeType)return!1;u=l="only"===h&&!u&&"nextSibling"}return!0}if(u=[m?c.firstChild:c.lastChild],m&&p){d=(s=(r=(i=(o=(a=c)[k]||(a[k]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===S&&r[1])&&r[2],a=s&&c.childNodes[s];while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if(1===a.nodeType&&++d&&a===e){i[h]=[S,s,d];break}}else if(p&&(d=s=(r=(i=(o=(a=e)[k]||(a[k]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===S&&r[1]),!1===d)while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if((x?a.nodeName.toLowerCase()===f:1===a.nodeType)&&++d&&(p&&((i=(o=a[k]||(a[k]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]=[S,d]),a===e))break;return(d-=v)===g||d%g==0&&0<=d/g}}},PSEUDO:function(e,o){var t,a=b.pseudos[e]||b.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return a[k]?a(o):1<a.length?(t=[e,e,"",o],b.setFilters.hasOwnProperty(e.toLowerCase())?le(function(e,t){var n,r=a(e,o),i=r.length;while(i--)e[n=P(e,r[i])]=!(t[n]=r[i])}):function(e){return a(e,0,t)}):a}},pseudos:{not:le(function(e){var r=[],i=[],s=f(e.replace(B,"$1"));return s[k]?le(function(e,t,n,r){var i,o=s(e,null,r,[]),a=e.length;while(a--)(i=o[a])&&(e[a]=!(t[a]=i))}):function(e,t,n){return r[0]=e,s(r,null,n,i),r[0]=null,!i.pop()}}),has:le(function(t){return function(e){return 0<se(t,e).length}}),contains:le(function(t){return t=t.replace(te,ne),function(e){return-1<(e.textContent||o(e)).indexOf(t)}}),lang:le(function(n){return V.test(n||"")||se.error("unsupported lang: "+n),n=n.replace(te,ne).toLowerCase(),function(e){var t;do{if(t=E?e.lang:e.getAttribute("xml:lang")||e.getAttribute("lang"))return(t=t.toLowerCase())===n||0===t.indexOf(n+"-")}while((e=e.parentNode)&&1===e.nodeType);return!1}}),target:function(e){var t=n.location&&n.location.hash;return t&&t.slice(1)===e.id},root:function(e){return e===a},focus:function(e){return e===C.activeElement&&(!C.hasFocus||C.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!b.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return Q.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve(function(){return[0]}),last:ve(function(e,t){return[t-1]}),eq:ve(function(e,t,n){return[n<0?n+t:n]}),even:ve(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:ve(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:ve(function(e,t,n){for(var r=n<0?n+t:t<n?t:n;0<=--r;)e.push(r);return e}),gt:ve(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}}).pseudos.nth=b.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})b.pseudos[e]=de(e);for(e in{submit:!0,reset:!0})b.pseudos[e]=he(e);function me(){}function xe(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(s,e,t){var u=e.dir,l=e.next,c=l||u,f=t&&"parentNode"===c,p=r++;return e.first?function(e,t,n){while(e=e[u])if(1===e.nodeType||f)return s(e,t,n);return!1}:function(e,t,n){var r,i,o,a=[S,p];if(n){while(e=e[u])if((1===e.nodeType||f)&&s(e,t,n))return!0}else while(e=e[u])if(1===e.nodeType||f)if(i=(o=e[k]||(e[k]={}))[e.uniqueID]||(o[e.uniqueID]={}),l&&l===e.nodeName.toLowerCase())e=e[u]||e;else{if((r=i[c])&&r[0]===S&&r[1]===p)return a[2]=r[2];if((i[c]=a)[2]=s(e,t,n))return!0}return!1}}function we(i){return 1<i.length?function(e,t,n){var r=i.length;while(r--)if(!i[r](e,t,n))return!1;return!0}:i[0]}function Te(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s<u;s++)(o=e[s])&&(n&&!n(o,r,i)||(a.push(o),l&&t.push(s)));return a}function Ce(d,h,g,v,y,e){return v&&!v[k]&&(v=Ce(v)),y&&!y[k]&&(y=Ce(y,e)),le(function(e,t,n,r){var i,o,a,s=[],u=[],l=t.length,c=e||function(e,t,n){for(var r=0,i=t.length;r<i;r++)se(e,t[r],n);return n}(h||"*",n.nodeType?[n]:n,[]),f=!d||!e&&h?c:Te(c,s,d,n,r),p=g?y||(e?d:l||v)?[]:t:f;if(g&&g(f,p,n,r),v){i=Te(p,u),v(i,[],n,r),o=i.length;while(o--)(a=i[o])&&(p[u[o]]=!(f[u[o]]=a))}if(e){if(y||d){if(y){i=[],o=p.length;while(o--)(a=p[o])&&i.push(f[o]=a);y(null,p=[],i,r)}o=p.length;while(o--)(a=p[o])&&-1<(i=y?P(e,a):s[o])&&(e[i]=!(t[i]=a))}}else p=Te(p===t?p.splice(l,p.length):p),y?y(null,t,p,r):H.apply(t,p)})}function Ee(e){for(var i,t,n,r=e.length,o=b.relative[e[0].type],a=o||b.relative[" "],s=o?1:0,u=be(function(e){return e===i},a,!0),l=be(function(e){return-1<P(i,e)},a,!0),c=[function(e,t,n){var r=!o&&(n||t!==w)||((i=t).nodeType?u(e,t,n):l(e,t,n));return i=null,r}];s<r;s++)if(t=b.relative[e[s].type])c=[be(we(c),t)];else{if((t=b.filter[e[s].type].apply(null,e[s].matches))[k]){for(n=++s;n<r;n++)if(b.relative[e[n].type])break;return Ce(1<s&&we(c),1<s&&xe(e.slice(0,s-1).concat({value:" "===e[s-2].type?"*":""})).replace(B,"$1"),t,s<n&&Ee(e.slice(s,n)),n<r&&Ee(e=e.slice(n)),n<r&&xe(e))}c.push(t)}return we(c)}return me.prototype=b.filters=b.pseudos,b.setFilters=new me,h=se.tokenize=function(e,t){var n,r,i,o,a,s,u,l=x[e+" "];if(l)return t?0:l.slice(0);a=e,s=[],u=b.preFilter;while(a){for(o in n&&!(r=_.exec(a))||(r&&(a=a.slice(r[0].length)||a),s.push(i=[])),n=!1,(r=z.exec(a))&&(n=r.shift(),i.push({value:n,type:r[0].replace(B," ")}),a=a.slice(n.length)),b.filter)!(r=G[o].exec(a))||u[o]&&!(r=u[o](r))||(n=r.shift(),i.push({value:n,type:o,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?se.error(e):x(e,s).slice(0)},f=se.compile=function(e,t){var n,v,y,m,x,r,i=[],o=[],a=N[e+" "];if(!a){t||(t=h(e)),n=t.length;while(n--)(a=Ee(t[n]))[k]?i.push(a):o.push(a);(a=N(e,(v=o,m=0<(y=i).length,x=0<v.length,r=function(e,t,n,r,i){var o,a,s,u=0,l="0",c=e&&[],f=[],p=w,d=e||x&&b.find.TAG("*",i),h=S+=null==p?1:Math.random()||.1,g=d.length;for(i&&(w=t===C||t||i);l!==g&&null!=(o=d[l]);l++){if(x&&o){a=0,t||o.ownerDocument===C||(T(o),n=!E);while(s=v[a++])if(s(o,t||C,n)){r.push(o);break}i&&(S=h)}m&&((o=!s&&o)&&u--,e&&c.push(o))}if(u+=l,m&&l!==u){a=0;while(s=y[a++])s(c,f,t,n);if(e){if(0<u)while(l--)c[l]||f[l]||(f[l]=q.call(r));f=Te(f)}H.apply(r,f),i&&!e&&0<f.length&&1<u+y.length&&se.uniqueSort(r)}return i&&(S=h,w=p),c},m?le(r):r))).selector=e}return a},g=se.select=function(e,t,n,r){var i,o,a,s,u,l="function"==typeof e&&e,c=!r&&h(e=l.selector||e);if(n=n||[],1===c.length){if(2<(o=c[0]=c[0].slice(0)).length&&"ID"===(a=o[0]).type&&9===t.nodeType&&E&&b.relative[o[1].type]){if(!(t=(b.find.ID(a.matches[0].replace(te,ne),t)||[])[0]))return n;l&&(t=t.parentNode),e=e.slice(o.shift().value.length)}i=G.needsContext.test(e)?0:o.length;while(i--){if(a=o[i],b.relative[s=a.type])break;if((u=b.find[s])&&(r=u(a.matches[0].replace(te,ne),ee.test(o[0].type)&&ye(t.parentNode)||t))){if(o.splice(i,1),!(e=r.length&&xe(o)))return H.apply(n,r),n;break}}}return(l||f(e,c))(r,t,!E,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},d.sortStable=k.split("").sort(D).join("")===k,d.detectDuplicates=!!l,T(),d.sortDetached=ce(function(e){return 1&e.compareDocumentPosition(C.createElement("fieldset"))}),ce(function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")})||fe("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),d.attributes&&ce(function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||fe("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),ce(function(e){return null==e.getAttribute("disabled")})||fe(R,function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),se}(C);k.find=h,k.expr=h.selectors,k.expr[":"]=k.expr.pseudos,k.uniqueSort=k.unique=h.uniqueSort,k.text=h.getText,k.isXMLDoc=h.isXML,k.contains=h.contains,k.escapeSelector=h.escape;var T=function(e,t,n){var r=[],i=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&k(e).is(n))break;r.push(e)}return r},S=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},N=k.expr.match.needsContext;function A(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var D=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?k.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?k.grep(e,function(e){return e===n!==r}):"string"!=typeof n?k.grep(e,function(e){return-1<i.call(n,e)!==r}):k.filter(n,e,r)}k.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?k.find.matchesSelector(r,e)?[r]:[]:k.find.matches(e,k.grep(t,function(e){return 1===e.nodeType}))},k.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(k(e).filter(function(){for(t=0;t<r;t++)if(k.contains(i[t],this))return!0}));for(n=this.pushStack([]),t=0;t<r;t++)k.find(e,i[t],n);return 1<r?k.uniqueSort(n):n},filter:function(e){return this.pushStack(j(this,e||[],!1))},not:function(e){return this.pushStack(j(this,e||[],!0))},is:function(e){return!!j(this,"string"==typeof e&&N.test(e)?k(e):e||[],!1).length}});var q,L=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(k.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||q,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:L.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof k?t[0]:t,k.merge(this,k.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),D.test(r[1])&&k.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(k):k.makeArray(e,this)}).prototype=k.fn,q=k(E);var H=/^(?:parents|prev(?:Until|All))/,O={children:!0,contents:!0,next:!0,prev:!0};function P(e,t){while((e=e[t])&&1!==e.nodeType);return e}k.fn.extend({has:function(e){var t=k(e,this),n=t.length;return this.filter(function(){for(var e=0;e<n;e++)if(k.contains(this,t[e]))return!0})},closest:function(e,t){var n,r=0,i=this.length,o=[],a="string"!=typeof e&&k(e);if(!N.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?-1<a.index(n):1===n.nodeType&&k.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(1<o.length?k.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?i.call(k(e),this[0]):i.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(k.uniqueSort(k.merge(this.get(),k(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),k.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return T(e,"parentNode")},parentsUntil:function(e,t,n){return T(e,"parentNode",n)},next:function(e){return P(e,"nextSibling")},prev:function(e){return P(e,"previousSibling")},nextAll:function(e){return T(e,"nextSibling")},prevAll:function(e){return T(e,"previousSibling")},nextUntil:function(e,t,n){return T(e,"nextSibling",n)},prevUntil:function(e,t,n){return T(e,"previousSibling",n)},siblings:function(e){return S((e.parentNode||{}).firstChild,e)},children:function(e){return S(e.firstChild)},contents:function(e){return"undefined"!=typeof e.contentDocument?e.contentDocument:(A(e,"template")&&(e=e.content||e),k.merge([],e.childNodes))}},function(r,i){k.fn[r]=function(e,t){var n=k.map(this,i,e);return"Until"!==r.slice(-5)&&(t=e),t&&"string"==typeof t&&(n=k.filter(t,n)),1<this.length&&(O[r]||k.uniqueSort(n),H.test(r)&&n.reverse()),this.pushStack(n)}});var R=/[^\x20\t\r\n\f]+/g;function M(e){return e}function I(e){throw e}function W(e,t,n,r){var i;try{e&&m(i=e.promise)?i.call(e).done(t).fail(n):e&&m(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}k.Callbacks=function(r){var e,n;r="string"==typeof r?(e=r,n={},k.each(e.match(R)||[],function(e,t){n[t]=!0}),n):k.extend({},r);var i,t,o,a,s=[],u=[],l=-1,c=function(){for(a=a||r.once,o=i=!0;u.length;l=-1){t=u.shift();while(++l<s.length)!1===s[l].apply(t[0],t[1])&&r.stopOnFalse&&(l=s.length,t=!1)}r.memory||(t=!1),i=!1,a&&(s=t?[]:"")},f={add:function(){return s&&(t&&!i&&(l=s.length-1,u.push(t)),function n(e){k.each(e,function(e,t){m(t)?r.unique&&f.has(t)||s.push(t):t&&t.length&&"string"!==w(t)&&n(t)})}(arguments),t&&!i&&c()),this},remove:function(){return k.each(arguments,function(e,t){var n;while(-1<(n=k.inArray(t,s,n)))s.splice(n,1),n<=l&&l--}),this},has:function(e){return e?-1<k.inArray(e,s):0<s.length},empty:function(){return s&&(s=[]),this},disable:function(){return a=u=[],s=t="",this},disabled:function(){return!s},lock:function(){return a=u=[],t||i||(s=t=""),this},locked:function(){return!!a},fireWith:function(e,t){return a||(t=[e,(t=t||[]).slice?t.slice():t],u.push(t),i||c()),this},fire:function(){return f.fireWith(this,arguments),this},fired:function(){return!!o}};return f},k.extend({Deferred:function(e){var o=[["notify","progress",k.Callbacks("memory"),k.Callbacks("memory"),2],["resolve","done",k.Callbacks("once memory"),k.Callbacks("once memory"),0,"resolved"],["reject","fail",k.Callbacks("once memory"),k.Callbacks("once memory"),1,"rejected"]],i="pending",a={state:function(){return i},always:function(){return s.done(arguments).fail(arguments),this},"catch":function(e){return a.then(null,e)},pipe:function(){var i=arguments;return k.Deferred(function(r){k.each(o,function(e,t){var n=m(i[t[4]])&&i[t[4]];s[t[1]](function(){var e=n&&n.apply(this,arguments);e&&m(e.promise)?e.promise().progress(r.notify).done(r.resolve).fail(r.reject):r[t[0]+"With"](this,n?[e]:arguments)})}),i=null}).promise()},then:function(t,n,r){var u=0;function l(i,o,a,s){return function(){var n=this,r=arguments,e=function(){var e,t;if(!(i<u)){if((e=a.apply(n,r))===o.promise())throw new TypeError("Thenable self-resolution");t=e&&("object"==typeof e||"function"==typeof e)&&e.then,m(t)?s?t.call(e,l(u,o,M,s),l(u,o,I,s)):(u++,t.call(e,l(u,o,M,s),l(u,o,I,s),l(u,o,M,o.notifyWith))):(a!==M&&(n=void 0,r=[e]),(s||o.resolveWith)(n,r))}},t=s?e:function(){try{e()}catch(e){k.Deferred.exceptionHook&&k.Deferred.exceptionHook(e,t.stackTrace),u<=i+1&&(a!==I&&(n=void 0,r=[e]),o.rejectWith(n,r))}};i?t():(k.Deferred.getStackHook&&(t.stackTrace=k.Deferred.getStackHook()),C.setTimeout(t))}}return k.Deferred(function(e){o[0][3].add(l(0,e,m(r)?r:M,e.notifyWith)),o[1][3].add(l(0,e,m(t)?t:M)),o[2][3].add(l(0,e,m(n)?n:I))}).promise()},promise:function(e){return null!=e?k.extend(e,a):a}},s={};return k.each(o,function(e,t){var n=t[2],r=t[5];a[t[1]]=n.add,r&&n.add(function(){i=r},o[3-e][2].disable,o[3-e][3].disable,o[0][2].lock,o[0][3].lock),n.add(t[3].fire),s[t[0]]=function(){return s[t[0]+"With"](this===s?void 0:this,arguments),this},s[t[0]+"With"]=n.fireWith}),a.promise(s),e&&e.call(s,s),s},when:function(e){var n=arguments.length,t=n,r=Array(t),i=s.call(arguments),o=k.Deferred(),a=function(t){return function(e){r[t]=this,i[t]=1<arguments.length?s.call(arguments):e,--n||o.resolveWith(r,i)}};if(n<=1&&(W(e,o.done(a(t)).resolve,o.reject,!n),"pending"===o.state()||m(i[t]&&i[t].then)))return o.then();while(t--)W(i[t],a(t),o.reject);return o.promise()}});var $=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;k.Deferred.exceptionHook=function(e,t){C.console&&C.console.warn&&e&&$.test(e.name)&&C.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},k.readyException=function(e){C.setTimeout(function(){throw e})};var F=k.Deferred();function B(){E.removeEventListener("DOMContentLoaded",B),C.removeEventListener("load",B),k.ready()}k.fn.ready=function(e){return F.then(e)["catch"](function(e){k.readyException(e)}),this},k.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--k.readyWait:k.isReady)||(k.isReady=!0)!==e&&0<--k.readyWait||F.resolveWith(E,[k])}}),k.ready.then=F.then,"complete"===E.readyState||"loading"!==E.readyState&&!E.documentElement.doScroll?C.setTimeout(k.ready):(E.addEventListener("DOMContentLoaded",B),C.addEventListener("load",B));var _=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if("object"===w(n))for(s in i=!0,n)_(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,m(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(k(e),n)})),t))for(;s<u;s++)t(e[s],n,a?r:r.call(e[s],s,t(e[s],n)));return i?e:l?t.call(e):u?t(e[0],n):o},z=/^-ms-/,U=/-([a-z])/g;function X(e,t){return t.toUpperCase()}function V(e){return e.replace(z,"ms-").replace(U,X)}var G=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function Y(){this.expando=k.expando+Y.uid++}Y.uid=1,Y.prototype={cache:function(e){var t=e[this.expando];return t||(t={},G(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[V(t)]=n;else for(r in t)i[V(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][V(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(V):(t=V(t))in r?[t]:t.match(R)||[]).length;while(n--)delete r[t[n]]}(void 0===t||k.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!k.isEmptyObject(t)}};var Q=new Y,J=new Y,K=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,Z=/[A-Z]/g;function ee(e,t,n){var r,i;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(Z,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n="true"===(i=n)||"false"!==i&&("null"===i?null:i===+i+""?+i:K.test(i)?JSON.parse(i):i)}catch(e){}J.set(e,t,n)}else n=void 0;return n}k.extend({hasData:function(e){return J.hasData(e)||Q.hasData(e)},data:function(e,t,n){return J.access(e,t,n)},removeData:function(e,t){J.remove(e,t)},_data:function(e,t,n){return Q.access(e,t,n)},_removeData:function(e,t){Q.remove(e,t)}}),k.fn.extend({data:function(n,e){var t,r,i,o=this[0],a=o&&o.attributes;if(void 0===n){if(this.length&&(i=J.get(o),1===o.nodeType&&!Q.get(o,"hasDataAttrs"))){t=a.length;while(t--)a[t]&&0===(r=a[t].name).indexOf("data-")&&(r=V(r.slice(5)),ee(o,r,i[r]));Q.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof n?this.each(function(){J.set(this,n)}):_(this,function(e){var t;if(o&&void 0===e)return void 0!==(t=J.get(o,n))?t:void 0!==(t=ee(o,n))?t:void 0;this.each(function(){J.set(this,n,e)})},null,e,1<arguments.length,null,!0)},removeData:function(e){return this.each(function(){J.remove(this,e)})}}),k.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Q.get(e,t),n&&(!r||Array.isArray(n)?r=Q.access(e,t,k.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=k.queue(e,t),r=n.length,i=n.shift(),o=k._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){k.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Q.get(e,n)||Q.access(e,n,{empty:k.Callbacks("once memory").add(function(){Q.remove(e,[t+"queue",n])})})}}),k.fn.extend({queue:function(t,n){var e=2;return"string"!=typeof t&&(n=t,t="fx",e--),arguments.length<e?k.queue(this[0],t):void 0===n?this:this.each(function(){var e=k.queue(this,t,n);k._queueHooks(this,t),"fx"===t&&"inprogress"!==e[0]&&k.dequeue(this,t)})},dequeue:function(e){return this.each(function(){k.dequeue(this,e)})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=k.Deferred(),o=this,a=this.length,s=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=void 0),e=e||"fx";while(a--)(n=Q.get(o[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var te=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,ne=new RegExp("^(?:([+-])=|)("+te+")([a-z%]*)$","i"),re=["Top","Right","Bottom","Left"],ie=E.documentElement,oe=function(e){return k.contains(e.ownerDocument,e)},ae={composed:!0};ie.getRootNode&&(oe=function(e){return k.contains(e.ownerDocument,e)||e.getRootNode(ae)===e.ownerDocument});var se=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&oe(e)&&"none"===k.css(e,"display")},ue=function(e,t,n,r){var i,o,a={};for(o in t)a[o]=e.style[o],e.style[o]=t[o];for(o in i=n.apply(e,r||[]),t)e.style[o]=a[o];return i};function le(e,t,n,r){var i,o,a=20,s=r?function(){return r.cur()}:function(){return k.css(e,t,"")},u=s(),l=n&&n[3]||(k.cssNumber[t]?"":"px"),c=e.nodeType&&(k.cssNumber[t]||"px"!==l&&+u)&&ne.exec(k.css(e,t));if(c&&c[3]!==l){u/=2,l=l||c[3],c=+u||1;while(a--)k.style(e,t,c+l),(1-o)*(1-(o=s()/u||.5))<=0&&(a=0),c/=o;c*=2,k.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ce={};function fe(e,t){for(var n,r,i,o,a,s,u,l=[],c=0,f=e.length;c<f;c++)(r=e[c]).style&&(n=r.style.display,t?("none"===n&&(l[c]=Q.get(r,"display")||null,l[c]||(r.style.display="")),""===r.style.display&&se(r)&&(l[c]=(u=a=o=void 0,a=(i=r).ownerDocument,s=i.nodeName,(u=ce[s])||(o=a.body.appendChild(a.createElement(s)),u=k.css(o,"display"),o.parentNode.removeChild(o),"none"===u&&(u="block"),ce[s]=u)))):"none"!==n&&(l[c]="none",Q.set(r,"display",n)));for(c=0;c<f;c++)null!=l[c]&&(e[c].style.display=l[c]);return e}k.fn.extend({show:function(){return fe(this,!0)},hide:function(){return fe(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){se(this)?k(this).show():k(this).hide()})}});var pe=/^(?:checkbox|radio)$/i,de=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i,ge={option:[1,"<select multiple='multiple'>","</select>"],thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?k.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n<r;n++)Q.set(e[n],"globalEval",!t||Q.get(t[n],"globalEval"))}ge.optgroup=ge.option,ge.tbody=ge.tfoot=ge.colgroup=ge.caption=ge.thead,ge.th=ge.td;var me,xe,be=/<|&#?\w+;/;function we(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===w(o))k.merge(p,o.nodeType?[o]:o);else if(be.test(o)){a=a||f.appendChild(t.createElement("div")),s=(de.exec(o)||["",""])[1].toLowerCase(),u=ge[s]||ge._default,a.innerHTML=u[1]+k.htmlPrefilter(o)+u[2],c=u[0];while(c--)a=a.lastChild;k.merge(p,a.childNodes),(a=f.firstChild).textContent=""}else p.push(t.createTextNode(o));f.textContent="",d=0;while(o=p[d++])if(r&&-1<k.inArray(o,r))i&&i.push(o);else if(l=oe(o),a=ve(f.appendChild(o),"script"),l&&ye(a),n){c=0;while(o=a[c++])he.test(o.type||"")&&n.push(o)}return f}me=E.createDocumentFragment().appendChild(E.createElement("div")),(xe=E.createElement("input")).setAttribute("type","radio"),xe.setAttribute("checked","checked"),xe.setAttribute("name","t"),me.appendChild(xe),y.checkClone=me.cloneNode(!0).cloneNode(!0).lastChild.checked,me.innerHTML="<textarea>x</textarea>",y.noCloneChecked=!!me.cloneNode(!0).lastChild.defaultValue;var Te=/^key/,Ce=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Ee=/^([^.]*)(?:\.(.+)|)/;function ke(){return!0}function Se(){return!1}function Ne(e,t){return e===function(){try{return E.activeElement}catch(e){}}()==("focus"===t)}function Ae(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)Ae(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Se;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return k().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=k.guid++)),e.each(function(){k.event.add(this,t,i,r,n)})}function De(e,i,o){o?(Q.set(e,i,!1),k.event.add(e,i,{namespace:!1,handler:function(e){var t,n,r=Q.get(this,i);if(1&e.isTrigger&&this[i]){if(r.length)(k.event.special[i]||{}).delegateType&&e.stopPropagation();else if(r=s.call(arguments),Q.set(this,i,r),t=o(this,i),this[i](),r!==(n=Q.get(this,i))||t?Q.set(this,i,!1):n={},r!==n)return e.stopImmediatePropagation(),e.preventDefault(),n.value}else r.length&&(Q.set(this,i,{value:k.event.trigger(k.extend(r[0],k.Event.prototype),r.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Q.get(e,i)&&k.event.add(e,i,ke)}k.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Q.get(t);if(v){n.handler&&(n=(o=n).handler,i=o.selector),i&&k.find.matchesSelector(ie,i),n.guid||(n.guid=k.guid++),(u=v.events)||(u=v.events={}),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof k&&k.event.triggered!==e.type?k.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(R)||[""]).length;while(l--)d=g=(s=Ee.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=k.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=k.event.special[d]||{},c=k.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&k.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),k.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Q.hasData(e)&&Q.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(R)||[""]).length;while(l--)if(d=g=(s=Ee.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=k.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||k.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)k.event.remove(e,d+t[l],n,r,!0);k.isEmptyObject(u)&&Q.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=k.event.fix(e),u=new Array(arguments.length),l=(Q.get(this,"events")||{})[s.type]||[],c=k.event.special[s.type]||{};for(u[0]=s,t=1;t<arguments.length;t++)u[t]=arguments[t];if(s.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,s)){a=k.event.handlers.call(this,s,l),t=0;while((i=a[t++])&&!s.isPropagationStopped()){s.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!s.isImmediatePropagationStopped())s.rnamespace&&!1!==o.namespace&&!s.rnamespace.test(o.namespace)||(s.handleObj=o,s.data=o.data,void 0!==(r=((k.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,u))&&!1===(s.result=r)&&(s.preventDefault(),s.stopPropagation()))}return c.postDispatch&&c.postDispatch.call(this,s),s.result}},handlers:function(e,t){var n,r,i,o,a,s=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&1<=e.button))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n<u;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?-1<k(i,this).index(l):k.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u<t.length&&s.push({elem:l,handlers:t.slice(u)}),s},addProp:function(t,e){Object.defineProperty(k.Event.prototype,t,{enumerable:!0,configurable:!0,get:m(e)?function(){if(this.originalEvent)return e(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[t]},set:function(e){Object.defineProperty(this,t,{enumerable:!0,configurable:!0,writable:!0,value:e})}})},fix:function(e){return e[k.expando]?e:new k.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&De(t,"click",ke),!1},trigger:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&De(t,"click"),!0},_default:function(e){var t=e.target;return pe.test(t.type)&&t.click&&A(t,"input")&&Q.get(t,"click")||A(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},k.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},k.Event=function(e,t){if(!(this instanceof k.Event))return new k.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?ke:Se,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&k.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[k.expando]=!0},k.Event.prototype={constructor:k.Event,isDefaultPrevented:Se,isPropagationStopped:Se,isImmediatePropagationStopped:Se,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=ke,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=ke,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=ke,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},k.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(e){var t=e.button;return null==e.which&&Te.test(e.type)?null!=e.charCode?e.charCode:e.keyCode:!e.which&&void 0!==t&&Ce.test(e.type)?1&t?1:2&t?3:4&t?2:0:e.which}},k.event.addProp),k.each({focus:"focusin",blur:"focusout"},function(e,t){k.event.special[e]={setup:function(){return De(this,e,Ne),!1},trigger:function(){return De(this,e),!0},delegateType:t}}),k.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(e,i){k.event.special[e]={delegateType:i,bindType:i,handle:function(e){var t,n=e.relatedTarget,r=e.handleObj;return n&&(n===this||k.contains(this,n))||(e.type=r.origType,t=r.handler.apply(this,arguments),e.type=i),t}}}),k.fn.extend({on:function(e,t,n,r){return Ae(this,e,t,n,r)},one:function(e,t,n,r){return Ae(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,k(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=Se),this.each(function(){k.event.remove(this,e,n,t)})}});var je=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,qe=/<script|<style|<link/i,Le=/checked\s*(?:[^=]|=\s*.checked.)/i,He=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function Oe(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&k(e).children("tbody")[0]||e}function Pe(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function Re(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Me(e,t){var n,r,i,o,a,s,u,l;if(1===t.nodeType){if(Q.hasData(e)&&(o=Q.access(e),a=Q.set(t,o),l=o.events))for(i in delete a.handle,a.events={},l)for(n=0,r=l[i].length;n<r;n++)k.event.add(t,i,l[i][n]);J.hasData(e)&&(s=J.access(e),u=k.extend({},s),J.set(t,u))}}function Ie(n,r,i,o){r=g.apply([],r);var e,t,a,s,u,l,c=0,f=n.length,p=f-1,d=r[0],h=m(d);if(h||1<f&&"string"==typeof d&&!y.checkClone&&Le.test(d))return n.each(function(e){var t=n.eq(e);h&&(r[0]=d.call(this,e,t.html())),Ie(t,r,i,o)});if(f&&(t=(e=we(r,n[0].ownerDocument,!1,n,o)).firstChild,1===e.childNodes.length&&(e=t),t||o)){for(s=(a=k.map(ve(e,"script"),Pe)).length;c<f;c++)u=e,c!==p&&(u=k.clone(u,!0,!0),s&&k.merge(a,ve(u,"script"))),i.call(n[c],u,c);if(s)for(l=a[a.length-1].ownerDocument,k.map(a,Re),c=0;c<s;c++)u=a[c],he.test(u.type||"")&&!Q.access(u,"globalEval")&&k.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?k._evalUrl&&!u.noModule&&k._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")}):b(u.textContent.replace(He,""),u,l))}return n}function We(e,t,n){for(var r,i=t?k.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||k.cleanData(ve(r)),r.parentNode&&(n&&oe(r)&&ye(ve(r,"script")),r.parentNode.removeChild(r));return e}k.extend({htmlPrefilter:function(e){return e.replace(je,"<$1></$2>")},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=oe(e);if(!(y.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||k.isXMLDoc(e)))for(a=ve(c),r=0,i=(o=ve(e)).length;r<i;r++)s=o[r],u=a[r],void 0,"input"===(l=u.nodeName.toLowerCase())&&pe.test(s.type)?u.checked=s.checked:"input"!==l&&"textarea"!==l||(u.defaultValue=s.defaultValue);if(t)if(n)for(o=o||ve(e),a=a||ve(c),r=0,i=o.length;r<i;r++)Me(o[r],a[r]);else Me(e,c);return 0<(a=ve(c,"script")).length&&ye(a,!f&&ve(e,"script")),c},cleanData:function(e){for(var t,n,r,i=k.event.special,o=0;void 0!==(n=e[o]);o++)if(G(n)){if(t=n[Q.expando]){if(t.events)for(r in t.events)i[r]?k.event.remove(n,r):k.removeEvent(n,r,t.handle);n[Q.expando]=void 0}n[J.expando]&&(n[J.expando]=void 0)}}}),k.fn.extend({detach:function(e){return We(this,e,!0)},remove:function(e){return We(this,e)},text:function(e){return _(this,function(e){return void 0===e?k.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return Ie(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||Oe(this,e).appendChild(e)})},prepend:function(){return Ie(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=Oe(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return Ie(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return Ie(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(k.cleanData(ve(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return k.clone(this,e,t)})},html:function(e){return _(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!qe.test(e)&&!ge[(de.exec(e)||["",""])[1].toLowerCase()]){e=k.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(k.cleanData(ve(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var n=[];return Ie(this,arguments,function(e){var t=this.parentNode;k.inArray(this,n)<0&&(k.cleanData(ve(this)),t&&t.replaceChild(e,this))},n)}}),k.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,a){k.fn[e]=function(e){for(var t,n=[],r=k(e),i=r.length-1,o=0;o<=i;o++)t=o===i?this:this.clone(!0),k(r[o])[a](t),u.apply(n,t.get());return this.pushStack(n)}});var $e=new RegExp("^("+te+")(?!px)[a-z%]+$","i"),Fe=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=C),t.getComputedStyle(e)},Be=new RegExp(re.join("|"),"i");function _e(e,t,n){var r,i,o,a,s=e.style;return(n=n||Fe(e))&&(""!==(a=n.getPropertyValue(t)||n[t])||oe(e)||(a=k.style(e,t)),!y.pixelBoxStyles()&&$e.test(a)&&Be.test(t)&&(r=s.width,i=s.minWidth,o=s.maxWidth,s.minWidth=s.maxWidth=s.width=a,a=n.width,s.width=r,s.minWidth=i,s.maxWidth=o)),void 0!==a?a+"":a}function ze(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(u){s.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",u.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",ie.appendChild(s).appendChild(u);var e=C.getComputedStyle(u);n="1%"!==e.top,a=12===t(e.marginLeft),u.style.right="60%",o=36===t(e.right),r=36===t(e.width),u.style.position="absolute",i=12===t(u.offsetWidth/3),ie.removeChild(s),u=null}}function t(e){return Math.round(parseFloat(e))}var n,r,i,o,a,s=E.createElement("div"),u=E.createElement("div");u.style&&(u.style.backgroundClip="content-box",u.cloneNode(!0).style.backgroundClip="",y.clearCloneStyle="content-box"===u.style.backgroundClip,k.extend(y,{boxSizingReliable:function(){return e(),r},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),a},scrollboxSize:function(){return e(),i}}))}();var Ue=["Webkit","Moz","ms"],Xe=E.createElement("div").style,Ve={};function Ge(e){var t=k.cssProps[e]||Ve[e];return t||(e in Xe?e:Ve[e]=function(e){var t=e[0].toUpperCase()+e.slice(1),n=Ue.length;while(n--)if((e=Ue[n]+t)in Xe)return e}(e)||e)}var Ye=/^(none|table(?!-c[ea]).+)/,Qe=/^--/,Je={position:"absolute",visibility:"hidden",display:"block"},Ke={letterSpacing:"0",fontWeight:"400"};function Ze(e,t,n){var r=ne.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function et(e,t,n,r,i,o){var a="width"===t?1:0,s=0,u=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(u+=k.css(e,n+re[a],!0,i)),r?("content"===n&&(u-=k.css(e,"padding"+re[a],!0,i)),"margin"!==n&&(u-=k.css(e,"border"+re[a]+"Width",!0,i))):(u+=k.css(e,"padding"+re[a],!0,i),"padding"!==n?u+=k.css(e,"border"+re[a]+"Width",!0,i):s+=k.css(e,"border"+re[a]+"Width",!0,i));return!r&&0<=o&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u}function tt(e,t,n){var r=Fe(e),i=(!y.boxSizingReliable()||n)&&"border-box"===k.css(e,"boxSizing",!1,r),o=i,a=_e(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if($e.test(a)){if(!n)return a;a="auto"}return(!y.boxSizingReliable()&&i||"auto"===a||!parseFloat(a)&&"inline"===k.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===k.css(e,"boxSizing",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+et(e,t,n||(i?"border":"content"),o,r,a)+"px"}function nt(e,t,n,r,i){return new nt.prototype.init(e,t,n,r,i)}k.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=_e(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,a,s=V(t),u=Qe.test(t),l=e.style;if(u||(t=Ge(s)),a=k.cssHooks[t]||k.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=ne.exec(n))&&i[1]&&(n=le(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(k.cssNumber[s]?"":"px")),y.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=V(t);return Qe.test(t)||(t=Ge(s)),(a=k.cssHooks[t]||k.cssHooks[s])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=_e(e,t,r)),"normal"===i&&t in Ke&&(i=Ke[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),k.each(["height","width"],function(e,u){k.cssHooks[u]={get:function(e,t,n){if(t)return!Ye.test(k.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?tt(e,u,n):ue(e,Je,function(){return tt(e,u,n)})},set:function(e,t,n){var r,i=Fe(e),o=!y.scrollboxSize()&&"absolute"===i.position,a=(o||n)&&"border-box"===k.css(e,"boxSizing",!1,i),s=n?et(e,u,n,a,i):0;return a&&o&&(s-=Math.ceil(e["offset"+u[0].toUpperCase()+u.slice(1)]-parseFloat(i[u])-et(e,u,"border",!1,i)-.5)),s&&(r=ne.exec(t))&&"px"!==(r[3]||"px")&&(e.style[u]=t,t=k.css(e,u)),Ze(0,t,s)}}}),k.cssHooks.marginLeft=ze(y.reliableMarginLeft,function(e,t){if(t)return(parseFloat(_e(e,"marginLeft"))||e.getBoundingClientRect().left-ue(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),k.each({margin:"",padding:"",border:"Width"},function(i,o){k.cssHooks[i+o]={expand:function(e){for(var t=0,n={},r="string"==typeof e?e.split(" "):[e];t<4;t++)n[i+re[t]+o]=r[t]||r[t-2]||r[0];return n}},"margin"!==i&&(k.cssHooks[i+o].set=Ze)}),k.fn.extend({css:function(e,t){return _(this,function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Fe(e),i=t.length;a<i;a++)o[t[a]]=k.css(e,t[a],!1,r);return o}return void 0!==n?k.style(e,t,n):k.css(e,t)},e,t,1<arguments.length)}}),((k.Tween=nt).prototype={constructor:nt,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||k.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(k.cssNumber[n]?"":"px")},cur:function(){var e=nt.propHooks[this.prop];return e&&e.get?e.get(this):nt.propHooks._default.get(this)},run:function(e){var t,n=nt.propHooks[this.prop];return this.options.duration?this.pos=t=k.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):nt.propHooks._default.set(this),this}}).init.prototype=nt.prototype,(nt.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=k.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){k.fx.step[e.prop]?k.fx.step[e.prop](e):1!==e.elem.nodeType||!k.cssHooks[e.prop]&&null==e.elem.style[Ge(e.prop)]?e.elem[e.prop]=e.now:k.style(e.elem,e.prop,e.now+e.unit)}}}).scrollTop=nt.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},k.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},k.fx=nt.prototype.init,k.fx.step={};var rt,it,ot,at,st=/^(?:toggle|show|hide)$/,ut=/queueHooks$/;function lt(){it&&(!1===E.hidden&&C.requestAnimationFrame?C.requestAnimationFrame(lt):C.setTimeout(lt,k.fx.interval),k.fx.tick())}function ct(){return C.setTimeout(function(){rt=void 0}),rt=Date.now()}function ft(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=re[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function pt(e,t,n){for(var r,i=(dt.tweeners[t]||[]).concat(dt.tweeners["*"]),o=0,a=i.length;o<a;o++)if(r=i[o].call(n,t,e))return r}function dt(o,e,t){var n,a,r=0,i=dt.prefilters.length,s=k.Deferred().always(function(){delete u.elem}),u=function(){if(a)return!1;for(var e=rt||ct(),t=Math.max(0,l.startTime+l.duration-e),n=1-(t/l.duration||0),r=0,i=l.tweens.length;r<i;r++)l.tweens[r].run(n);return s.notifyWith(o,[l,n,t]),n<1&&i?t:(i||s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l]),!1)},l=s.promise({elem:o,props:k.extend({},e),opts:k.extend(!0,{specialEasing:{},easing:k.easing._default},t),originalProperties:e,originalOptions:t,startTime:rt||ct(),duration:t.duration,tweens:[],createTween:function(e,t){var n=k.Tween(o,l.opts,e,t,l.opts.specialEasing[e]||l.opts.easing);return l.tweens.push(n),n},stop:function(e){var t=0,n=e?l.tweens.length:0;if(a)return this;for(a=!0;t<n;t++)l.tweens[t].run(1);return e?(s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l,e])):s.rejectWith(o,[l,e]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,a;for(n in e)if(i=t[r=V(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(a=k.cssHooks[r])&&"expand"in a)for(n in o=a.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);r<i;r++)if(n=dt.prefilters[r].call(l,o,c,l.opts))return m(n.stop)&&(k._queueHooks(l.elem,l.opts.queue).stop=n.stop.bind(n)),n;return k.map(c,pt,l),m(l.opts.start)&&l.opts.start.call(o,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),k.fx.timer(k.extend(u,{elem:o,anim:l,queue:l.opts.queue})),l}k.Animation=k.extend(dt,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return le(n.elem,e,ne.exec(t),n),n}]},tweener:function(e,t){m(e)?(t=e,e=["*"]):e=e.match(R);for(var n,r=0,i=e.length;r<i;r++)n=e[r],dt.tweeners[n]=dt.tweeners[n]||[],dt.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,a,s,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&se(e),v=Q.get(e,"fxshow");for(r in n.queue||(null==(a=k._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,s=a.empty.fire,a.empty.fire=function(){a.unqueued||s()}),a.unqueued++,p.always(function(){p.always(function(){a.unqueued--,k.queue(e,"fx").length||a.empty.fire()})})),t)if(i=t[r],st.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||k.style(e,r)}if((u=!k.isEmptyObject(t))||!k.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=Q.get(e,"display")),"none"===(c=k.css(e,"display"))&&(l?c=l:(fe([e],!0),l=e.style.display||l,c=k.css(e,"display"),fe([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===k.css(e,"float")&&(u||(p.done(function(){h.display=l}),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=Q.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&fe([e],!0),p.done(function(){for(r in g||fe([e]),Q.remove(e,"fxshow"),d)k.style(e,r,d[r])})),u=pt(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?dt.prefilters.unshift(e):dt.prefilters.push(e)}}),k.speed=function(e,t,n){var r=e&&"object"==typeof e?k.extend({},e):{complete:n||!n&&t||m(e)&&e,duration:e,easing:n&&t||t&&!m(t)&&t};return k.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in k.fx.speeds?r.duration=k.fx.speeds[r.duration]:r.duration=k.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){m(r.old)&&r.old.call(this),r.queue&&k.dequeue(this,r.queue)},r},k.fn.extend({fadeTo:function(e,t,n,r){return this.filter(se).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(t,e,n,r){var i=k.isEmptyObject(t),o=k.speed(e,n,r),a=function(){var e=dt(this,k.extend({},t),o);(i||Q.get(this,"finish"))&&e.stop(!0)};return a.finish=a,i||!1===o.queue?this.each(a):this.queue(o.queue,a)},stop:function(i,e,o){var a=function(e){var t=e.stop;delete e.stop,t(o)};return"string"!=typeof i&&(o=e,e=i,i=void 0),e&&!1!==i&&this.queue(i||"fx",[]),this.each(function(){var e=!0,t=null!=i&&i+"queueHooks",n=k.timers,r=Q.get(this);if(t)r[t]&&r[t].stop&&a(r[t]);else for(t in r)r[t]&&r[t].stop&&ut.test(t)&&a(r[t]);for(t=n.length;t--;)n[t].elem!==this||null!=i&&n[t].queue!==i||(n[t].anim.stop(o),e=!1,n.splice(t,1));!e&&o||k.dequeue(this,i)})},finish:function(a){return!1!==a&&(a=a||"fx"),this.each(function(){var e,t=Q.get(this),n=t[a+"queue"],r=t[a+"queueHooks"],i=k.timers,o=n?n.length:0;for(t.finish=!0,k.queue(this,a,[]),r&&r.stop&&r.stop.call(this,!0),e=i.length;e--;)i[e].elem===this&&i[e].queue===a&&(i[e].anim.stop(!0),i.splice(e,1));for(e=0;e<o;e++)n[e]&&n[e].finish&&n[e].finish.call(this);delete t.finish})}}),k.each(["toggle","show","hide"],function(e,r){var i=k.fn[r];k.fn[r]=function(e,t,n){return null==e||"boolean"==typeof e?i.apply(this,arguments):this.animate(ft(r,!0),e,t,n)}}),k.each({slideDown:ft("show"),slideUp:ft("hide"),slideToggle:ft("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,r){k.fn[e]=function(e,t,n){return this.animate(r,e,t,n)}}),k.timers=[],k.fx.tick=function(){var e,t=0,n=k.timers;for(rt=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||k.fx.stop(),rt=void 0},k.fx.timer=function(e){k.timers.push(e),k.fx.start()},k.fx.interval=13,k.fx.start=function(){it||(it=!0,lt())},k.fx.stop=function(){it=null},k.fx.speeds={slow:600,fast:200,_default:400},k.fn.delay=function(r,e){return r=k.fx&&k.fx.speeds[r]||r,e=e||"fx",this.queue(e,function(e,t){var n=C.setTimeout(e,r);t.stop=function(){C.clearTimeout(n)}})},ot=E.createElement("input"),at=E.createElement("select").appendChild(E.createElement("option")),ot.type="checkbox",y.checkOn=""!==ot.value,y.optSelected=at.selected,(ot=E.createElement("input")).value="t",ot.type="radio",y.radioValue="t"===ot.value;var ht,gt=k.expr.attrHandle;k.fn.extend({attr:function(e,t){return _(this,k.attr,e,t,1<arguments.length)},removeAttr:function(e){return this.each(function(){k.removeAttr(this,e)})}}),k.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"==typeof e.getAttribute?k.prop(e,t,n):(1===o&&k.isXMLDoc(e)||(i=k.attrHooks[t.toLowerCase()]||(k.expr.match.bool.test(t)?ht:void 0)),void 0!==n?null===n?void k.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=k.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!y.radioValue&&"radio"===t&&A(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(R);if(i&&1===e.nodeType)while(n=i[r++])e.removeAttribute(n)}}),ht={set:function(e,t,n){return!1===t?k.removeAttr(e,n):e.setAttribute(n,n),n}},k.each(k.expr.match.bool.source.match(/\w+/g),function(e,t){var a=gt[t]||k.find.attr;gt[t]=function(e,t,n){var r,i,o=t.toLowerCase();return n||(i=gt[o],gt[o]=r,r=null!=a(e,t,n)?o:null,gt[o]=i),r}});var vt=/^(?:input|select|textarea|button)$/i,yt=/^(?:a|area)$/i;function mt(e){return(e.match(R)||[]).join(" ")}function xt(e){return e.getAttribute&&e.getAttribute("class")||""}function bt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(R)||[]}k.fn.extend({prop:function(e,t){return _(this,k.prop,e,t,1<arguments.length)},removeProp:function(e){return this.each(function(){delete this[k.propFix[e]||e]})}}),k.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&k.isXMLDoc(e)||(t=k.propFix[t]||t,i=k.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=k.find.attr(e,"tabindex");return t?parseInt(t,10):vt.test(e.nodeName)||yt.test(e.nodeName)&&e.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),y.optSelected||(k.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),k.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){k.propFix[this.toLowerCase()]=this}),k.fn.extend({addClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){k(this).addClass(t.call(this,e,xt(this)))});if((e=bt(t)).length)while(n=this[u++])if(i=xt(n),r=1===n.nodeType&&" "+mt(i)+" "){a=0;while(o=e[a++])r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(s=mt(r))&&n.setAttribute("class",s)}return this},removeClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){k(this).removeClass(t.call(this,e,xt(this)))});if(!arguments.length)return this.attr("class","");if((e=bt(t)).length)while(n=this[u++])if(i=xt(n),r=1===n.nodeType&&" "+mt(i)+" "){a=0;while(o=e[a++])while(-1<r.indexOf(" "+o+" "))r=r.replace(" "+o+" "," ");i!==(s=mt(r))&&n.setAttribute("class",s)}return this},toggleClass:function(i,t){var o=typeof i,a="string"===o||Array.isArray(i);return"boolean"==typeof t&&a?t?this.addClass(i):this.removeClass(i):m(i)?this.each(function(e){k(this).toggleClass(i.call(this,e,xt(this),t),t)}):this.each(function(){var e,t,n,r;if(a){t=0,n=k(this),r=bt(i);while(e=r[t++])n.hasClass(e)?n.removeClass(e):n.addClass(e)}else void 0!==i&&"boolean"!==o||((e=xt(this))&&Q.set(this,"__className__",e),this.setAttribute&&this.setAttribute("class",e||!1===i?"":Q.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;t=" "+e+" ";while(n=this[r++])if(1===n.nodeType&&-1<(" "+mt(xt(n))+" ").indexOf(t))return!0;return!1}});var wt=/\r/g;k.fn.extend({val:function(n){var r,e,i,t=this[0];return arguments.length?(i=m(n),this.each(function(e){var t;1===this.nodeType&&(null==(t=i?n.call(this,e,k(this).val()):n)?t="":"number"==typeof t?t+="":Array.isArray(t)&&(t=k.map(t,function(e){return null==e?"":e+""})),(r=k.valHooks[this.type]||k.valHooks[this.nodeName.toLowerCase()])&&"set"in r&&void 0!==r.set(this,t,"value")||(this.value=t))})):t?(r=k.valHooks[t.type]||k.valHooks[t.nodeName.toLowerCase()])&&"get"in r&&void 0!==(e=r.get(t,"value"))?e:"string"==typeof(e=t.value)?e.replace(wt,""):null==e?"":e:void 0}}),k.extend({valHooks:{option:{get:function(e){var t=k.find.attr(e,"value");return null!=t?t:mt(k.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!A(n.parentNode,"optgroup"))){if(t=k(n).val(),a)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=k.makeArray(t),a=i.length;while(a--)((r=i[a]).selected=-1<k.inArray(k.valHooks.option.get(r),o))&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),k.each(["radio","checkbox"],function(){k.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=-1<k.inArray(k(e).val(),t)}},y.checkOn||(k.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})}),y.focusin="onfocusin"in C;var Tt=/^(?:focusinfocus|focusoutblur)$/,Ct=function(e){e.stopPropagation()};k.extend(k.event,{trigger:function(e,t,n,r){var i,o,a,s,u,l,c,f,p=[n||E],d=v.call(e,"type")?e.type:e,h=v.call(e,"namespace")?e.namespace.split("."):[];if(o=f=a=n=n||E,3!==n.nodeType&&8!==n.nodeType&&!Tt.test(d+k.event.triggered)&&(-1<d.indexOf(".")&&(d=(h=d.split(".")).shift(),h.sort()),u=d.indexOf(":")<0&&"on"+d,(e=e[k.expando]?e:new k.Event(d,"object"==typeof e&&e)).isTrigger=r?2:3,e.namespace=h.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:k.makeArray(t,[e]),c=k.event.special[d]||{},r||!c.trigger||!1!==c.trigger.apply(n,t))){if(!r&&!c.noBubble&&!x(n)){for(s=c.delegateType||d,Tt.test(s+d)||(o=o.parentNode);o;o=o.parentNode)p.push(o),a=o;a===(n.ownerDocument||E)&&p.push(a.defaultView||a.parentWindow||C)}i=0;while((o=p[i++])&&!e.isPropagationStopped())f=o,e.type=1<i?s:c.bindType||d,(l=(Q.get(o,"events")||{})[e.type]&&Q.get(o,"handle"))&&l.apply(o,t),(l=u&&o[u])&&l.apply&&G(o)&&(e.result=l.apply(o,t),!1===e.result&&e.preventDefault());return e.type=d,r||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!G(n)||u&&m(n[d])&&!x(n)&&((a=n[u])&&(n[u]=null),k.event.triggered=d,e.isPropagationStopped()&&f.addEventListener(d,Ct),n[d](),e.isPropagationStopped()&&f.removeEventListener(d,Ct),k.event.triggered=void 0,a&&(n[u]=a)),e.result}},simulate:function(e,t,n){var r=k.extend(new k.Event,n,{type:e,isSimulated:!0});k.event.trigger(r,null,t)}}),k.fn.extend({trigger:function(e,t){return this.each(function(){k.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return k.event.trigger(e,t,n,!0)}}),y.focusin||k.each({focus:"focusin",blur:"focusout"},function(n,r){var i=function(e){k.event.simulate(r,e.target,k.event.fix(e))};k.event.special[r]={setup:function(){var e=this.ownerDocument||this,t=Q.access(e,r);t||e.addEventListener(n,i,!0),Q.access(e,r,(t||0)+1)},teardown:function(){var e=this.ownerDocument||this,t=Q.access(e,r)-1;t?Q.access(e,r,t):(e.removeEventListener(n,i,!0),Q.remove(e,r))}}});var Et=C.location,kt=Date.now(),St=/\?/;k.parseXML=function(e){var t;if(!e||"string"!=typeof e)return null;try{t=(new C.DOMParser).parseFromString(e,"text/xml")}catch(e){t=void 0}return t&&!t.getElementsByTagName("parsererror").length||k.error("Invalid XML: "+e),t};var Nt=/\[\]$/,At=/\r?\n/g,Dt=/^(?:submit|button|image|reset|file)$/i,jt=/^(?:input|select|textarea|keygen)/i;function qt(n,e,r,i){var t;if(Array.isArray(e))k.each(e,function(e,t){r||Nt.test(n)?i(n,t):qt(n+"["+("object"==typeof t&&null!=t?e:"")+"]",t,r,i)});else if(r||"object"!==w(e))i(n,e);else for(t in e)qt(n+"["+t+"]",e[t],r,i)}k.param=function(e,t){var n,r=[],i=function(e,t){var n=m(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!k.isPlainObject(e))k.each(e,function(){i(this.name,this.value)});else for(n in e)qt(n,e[n],t,i);return r.join("&")},k.fn.extend({serialize:function(){return k.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=k.prop(this,"elements");return e?k.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!k(this).is(":disabled")&&jt.test(this.nodeName)&&!Dt.test(e)&&(this.checked||!pe.test(e))}).map(function(e,t){var n=k(this).val();return null==n?null:Array.isArray(n)?k.map(n,function(e){return{name:t.name,value:e.replace(At,"\r\n")}}):{name:t.name,value:n.replace(At,"\r\n")}}).get()}});var Lt=/%20/g,Ht=/#.*$/,Ot=/([?&])_=[^&]*/,Pt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Rt=/^(?:GET|HEAD)$/,Mt=/^\/\//,It={},Wt={},$t="*/".concat("*"),Ft=E.createElement("a");function Bt(o){return function(e,t){"string"!=typeof e&&(t=e,e="*");var n,r=0,i=e.toLowerCase().match(R)||[];if(m(t))while(n=i[r++])"+"===n[0]?(n=n.slice(1)||"*",(o[n]=o[n]||[]).unshift(t)):(o[n]=o[n]||[]).push(t)}}function _t(t,i,o,a){var s={},u=t===Wt;function l(e){var r;return s[e]=!0,k.each(t[e]||[],function(e,t){var n=t(i,o,a);return"string"!=typeof n||u||s[n]?u?!(r=n):void 0:(i.dataTypes.unshift(n),l(n),!1)}),r}return l(i.dataTypes[0])||!s["*"]&&l("*")}function zt(e,t){var n,r,i=k.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&k.extend(!0,e,r),e}Ft.href=Et.href,k.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Et.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(Et.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":$t,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":k.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?zt(zt(e,k.ajaxSettings),t):zt(k.ajaxSettings,e)},ajaxPrefilter:Bt(It),ajaxTransport:Bt(Wt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var c,f,p,n,d,r,h,g,i,o,v=k.ajaxSetup({},t),y=v.context||v,m=v.context&&(y.nodeType||y.jquery)?k(y):k.event,x=k.Deferred(),b=k.Callbacks("once memory"),w=v.statusCode||{},a={},s={},u="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(h){if(!n){n={};while(t=Pt.exec(p))n[t[1].toLowerCase()+" "]=(n[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=n[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return h?p:null},setRequestHeader:function(e,t){return null==h&&(e=s[e.toLowerCase()]=s[e.toLowerCase()]||e,a[e]=t),this},overrideMimeType:function(e){return null==h&&(v.mimeType=e),this},statusCode:function(e){var t;if(e)if(h)T.always(e[T.status]);else for(t in e)w[t]=[w[t],e[t]];return this},abort:function(e){var t=e||u;return c&&c.abort(t),l(0,t),this}};if(x.promise(T),v.url=((e||v.url||Et.href)+"").replace(Mt,Et.protocol+"//"),v.type=t.method||t.type||v.method||v.type,v.dataTypes=(v.dataType||"*").toLowerCase().match(R)||[""],null==v.crossDomain){r=E.createElement("a");try{r.href=v.url,r.href=r.href,v.crossDomain=Ft.protocol+"//"+Ft.host!=r.protocol+"//"+r.host}catch(e){v.crossDomain=!0}}if(v.data&&v.processData&&"string"!=typeof v.data&&(v.data=k.param(v.data,v.traditional)),_t(It,v,t,T),h)return T;for(i in(g=k.event&&v.global)&&0==k.active++&&k.event.trigger("ajaxStart"),v.type=v.type.toUpperCase(),v.hasContent=!Rt.test(v.type),f=v.url.replace(Ht,""),v.hasContent?v.data&&v.processData&&0===(v.contentType||"").indexOf("application/x-www-form-urlencoded")&&(v.data=v.data.replace(Lt,"+")):(o=v.url.slice(f.length),v.data&&(v.processData||"string"==typeof v.data)&&(f+=(St.test(f)?"&":"?")+v.data,delete v.data),!1===v.cache&&(f=f.replace(Ot,"$1"),o=(St.test(f)?"&":"?")+"_="+kt+++o),v.url=f+o),v.ifModified&&(k.lastModified[f]&&T.setRequestHeader("If-Modified-Since",k.lastModified[f]),k.etag[f]&&T.setRequestHeader("If-None-Match",k.etag[f])),(v.data&&v.hasContent&&!1!==v.contentType||t.contentType)&&T.setRequestHeader("Content-Type",v.contentType),T.setRequestHeader("Accept",v.dataTypes[0]&&v.accepts[v.dataTypes[0]]?v.accepts[v.dataTypes[0]]+("*"!==v.dataTypes[0]?", "+$t+"; q=0.01":""):v.accepts["*"]),v.headers)T.setRequestHeader(i,v.headers[i]);if(v.beforeSend&&(!1===v.beforeSend.call(y,T,v)||h))return T.abort();if(u="abort",b.add(v.complete),T.done(v.success),T.fail(v.error),c=_t(Wt,v,t,T)){if(T.readyState=1,g&&m.trigger("ajaxSend",[T,v]),h)return T;v.async&&0<v.timeout&&(d=C.setTimeout(function(){T.abort("timeout")},v.timeout));try{h=!1,c.send(a,l)}catch(e){if(h)throw e;l(-1,e)}}else l(-1,"No Transport");function l(e,t,n,r){var i,o,a,s,u,l=t;h||(h=!0,d&&C.clearTimeout(d),c=void 0,p=r||"",T.readyState=0<e?4:0,i=200<=e&&e<300||304===e,n&&(s=function(e,t,n){var r,i,o,a,s=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(v,T,n)),s=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(a=l[u+" "+o]||l["* "+o]))for(i in l)if((s=i.split(" "))[1]===o&&(a=l[u+" "+s[0]]||l["* "+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e["throws"])t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(v,s,T,i),i?(v.ifModified&&((u=T.getResponseHeader("Last-Modified"))&&(k.lastModified[f]=u),(u=T.getResponseHeader("etag"))&&(k.etag[f]=u)),204===e||"HEAD"===v.type?l="nocontent":304===e?l="notmodified":(l=s.state,o=s.data,i=!(a=s.error))):(a=l,!e&&l||(l="error",e<0&&(e=0))),T.status=e,T.statusText=(t||l)+"",i?x.resolveWith(y,[o,l,T]):x.rejectWith(y,[T,l,a]),T.statusCode(w),w=void 0,g&&m.trigger(i?"ajaxSuccess":"ajaxError",[T,v,i?o:a]),b.fireWith(y,[T,l]),g&&(m.trigger("ajaxComplete",[T,v]),--k.active||k.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return k.get(e,t,n,"json")},getScript:function(e,t){return k.get(e,void 0,t,"script")}}),k.each(["get","post"],function(e,i){k[i]=function(e,t,n,r){return m(t)&&(r=r||n,n=t,t=void 0),k.ajax(k.extend({url:e,type:i,dataType:r,data:t,success:n},k.isPlainObject(e)&&e))}}),k._evalUrl=function(e,t){return k.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){k.globalEval(e,t)}})},k.fn.extend({wrapAll:function(e){var t;return this[0]&&(m(e)&&(e=e.call(this[0])),t=k(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(n){return m(n)?this.each(function(e){k(this).wrapInner(n.call(this,e))}):this.each(function(){var e=k(this),t=e.contents();t.length?t.wrapAll(n):e.append(n)})},wrap:function(t){var n=m(t);return this.each(function(e){k(this).wrapAll(n?t.call(this,e):t)})},unwrap:function(e){return this.parent(e).not("body").each(function(){k(this).replaceWith(this.childNodes)}),this}}),k.expr.pseudos.hidden=function(e){return!k.expr.pseudos.visible(e)},k.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},k.ajaxSettings.xhr=function(){try{return new C.XMLHttpRequest}catch(e){}};var Ut={0:200,1223:204},Xt=k.ajaxSettings.xhr();y.cors=!!Xt&&"withCredentials"in Xt,y.ajax=Xt=!!Xt,k.ajaxTransport(function(i){var o,a;if(y.cors||Xt&&!i.crossDomain)return{send:function(e,t){var n,r=i.xhr();if(r.open(i.type,i.url,i.async,i.username,i.password),i.xhrFields)for(n in i.xhrFields)r[n]=i.xhrFields[n];for(n in i.mimeType&&r.overrideMimeType&&r.overrideMimeType(i.mimeType),i.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest"),e)r.setRequestHeader(n,e[n]);o=function(e){return function(){o&&(o=a=r.onload=r.onerror=r.onabort=r.ontimeout=r.onreadystatechange=null,"abort"===e?r.abort():"error"===e?"number"!=typeof r.status?t(0,"error"):t(r.status,r.statusText):t(Ut[r.status]||r.status,r.statusText,"text"!==(r.responseType||"text")||"string"!=typeof r.responseText?{binary:r.response}:{text:r.responseText},r.getAllResponseHeaders()))}},r.onload=o(),a=r.onerror=r.ontimeout=o("error"),void 0!==r.onabort?r.onabort=a:r.onreadystatechange=function(){4===r.readyState&&C.setTimeout(function(){o&&a()})},o=o("abort");try{r.send(i.hasContent&&i.data||null)}catch(e){if(o)throw e}},abort:function(){o&&o()}}}),k.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),k.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return k.globalEval(e),e}}}),k.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),k.ajaxTransport("script",function(n){var r,i;if(n.crossDomain||n.scriptAttrs)return{send:function(e,t){r=k("<script>").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var Vt,Gt=[],Yt=/(=)\?(?=&|$)|\?\?/;k.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Gt.pop()||k.expando+"_"+kt++;return this[e]=!0,e}}),k.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Yt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Yt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Yt,"$1"+r):!1!==e.jsonp&&(e.url+=(St.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||k.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?k(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,Gt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((Vt=E.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===Vt.childNodes.length),k.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=D.exec(e))?[t.createElement(i[1])]:(i=we([e],t,o),o&&o.length&&k(o).remove(),k.merge([],i.childNodes)));var r,i,o},k.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1<s&&(r=mt(e.slice(s)),e=e.slice(0,s)),m(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),0<a.length&&k.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done(function(e){o=arguments,a.html(r?k("<div>").append(k.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},k.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){k.fn[t]=function(e){return this.on(t,e)}}),k.expr.pseudos.animated=function(t){return k.grep(k.timers,function(e){return t===e.elem}).length},k.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=k.css(e,"position"),c=k(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=k.css(e,"top"),u=k.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,k.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},k.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){k.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===k.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===k.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=k(e).offset()).top+=k.css(e,"borderTopWidth",!0),i.left+=k.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-k.css(r,"marginTop",!0),left:t.left-i.left-k.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===k.css(e,"position"))e=e.offsetParent;return e||ie})}}),k.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;k.fn[t]=function(e){return _(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),k.each(["top","left"],function(e,n){k.cssHooks[n]=ze(y.pixelPosition,function(e,t){if(t)return t=_e(e,n),$e.test(t)?k(e).position()[n]+"px":t})}),k.each({Height:"height",Width:"width"},function(a,s){k.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){k.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return _(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?k.css(e,t,i):k.style(e,t,n,i)},s,n?e:void 0,n)}})}),k.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){k.fn[n]=function(e,t){return 0<arguments.length?this.on(n,null,e,t):this.trigger(n)}}),k.fn.extend({hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),k.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)}}),k.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),m(e))return r=s.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(s.call(arguments)))}).guid=e.guid=e.guid||k.guid++,i},k.holdReady=function(e){e?k.readyWait++:k.ready(!0)},k.isArray=Array.isArray,k.parseJSON=JSON.parse,k.nodeName=A,k.isFunction=m,k.isWindow=x,k.camelCase=V,k.type=w,k.now=Date.now,k.isNumeric=function(e){var t=k.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},"function"==typeof define&&define.amd&&define("jquery",[],function(){return k});var Qt=C.jQuery,Jt=C.$;return k.noConflict=function(e){return C.$===k&&(C.$=Jt),e&&C.jQuery===k&&(C.jQuery=Qt),k},e||(C.jQuery=C.$=k),k});
+/*! jQuery UI - v1.12.1 - 2019-01-27
+* http://jqueryui.com
+* Includes: widget.js, position.js, data.js, disable-selection.js, focusable.js, form-reset-mixin.js, jquery-1-7.js, keycode.js, labels.js, scroll-parent.js, tabbable.js, unique-id.js, widgets/resizable.js, widgets/mouse.js
+* Copyright jQuery Foundation and other contributors; Licensed MIT */
+
+(function(t){"function"==typeof define&&define.amd?define(["jquery"],t):t(jQuery)})(function(t){function e(t){for(var e=t.css("visibility");"inherit"===e;)t=t.parent(),e=t.css("visibility");return"hidden"!==e}t.ui=t.ui||{},t.ui.version="1.12.1";var i=0,s=Array.prototype.slice;t.cleanData=function(e){return function(i){var s,n,o;for(o=0;null!=(n=i[o]);o++)try{s=t._data(n,"events"),s&&s.remove&&t(n).triggerHandler("remove")}catch(a){}e(i)}}(t.cleanData),t.widget=function(e,i,s){var n,o,a,r={},h=e.split(".")[0];e=e.split(".")[1];var l=h+"-"+e;return s||(s=i,i=t.Widget),t.isArray(s)&&(s=t.extend.apply(null,[{}].concat(s))),t.expr[":"][l.toLowerCase()]=function(e){return!!t.data(e,l)},t[h]=t[h]||{},n=t[h][e],o=t[h][e]=function(t,e){return this._createWidget?(arguments.length&&this._createWidget(t,e),void 0):new o(t,e)},t.extend(o,n,{version:s.version,_proto:t.extend({},s),_childConstructors:[]}),a=new i,a.options=t.widget.extend({},a.options),t.each(s,function(e,s){return t.isFunction(s)?(r[e]=function(){function t(){return i.prototype[e].apply(this,arguments)}function n(t){return i.prototype[e].apply(this,t)}return function(){var e,i=this._super,o=this._superApply;return this._super=t,this._superApply=n,e=s.apply(this,arguments),this._super=i,this._superApply=o,e}}(),void 0):(r[e]=s,void 0)}),o.prototype=t.widget.extend(a,{widgetEventPrefix:n?a.widgetEventPrefix||e:e},r,{constructor:o,namespace:h,widgetName:e,widgetFullName:l}),n?(t.each(n._childConstructors,function(e,i){var s=i.prototype;t.widget(s.namespace+"."+s.widgetName,o,i._proto)}),delete n._childConstructors):i._childConstructors.push(o),t.widget.bridge(e,o),o},t.widget.extend=function(e){for(var i,n,o=s.call(arguments,1),a=0,r=o.length;r>a;a++)for(i in o[a])n=o[a][i],o[a].hasOwnProperty(i)&&void 0!==n&&(e[i]=t.isPlainObject(n)?t.isPlainObject(e[i])?t.widget.extend({},e[i],n):t.widget.extend({},n):n);return e},t.widget.bridge=function(e,i){var n=i.prototype.widgetFullName||e;t.fn[e]=function(o){var a="string"==typeof o,r=s.call(arguments,1),h=this;return a?this.length||"instance"!==o?this.each(function(){var i,s=t.data(this,n);return"instance"===o?(h=s,!1):s?t.isFunction(s[o])&&"_"!==o.charAt(0)?(i=s[o].apply(s,r),i!==s&&void 0!==i?(h=i&&i.jquery?h.pushStack(i.get()):i,!1):void 0):t.error("no such method '"+o+"' for "+e+" widget instance"):t.error("cannot call methods on "+e+" prior to initialization; "+"attempted to call method '"+o+"'")}):h=void 0:(r.length&&(o=t.widget.extend.apply(null,[o].concat(r))),this.each(function(){var e=t.data(this,n);e?(e.option(o||{}),e._init&&e._init()):t.data(this,n,new i(o,this))})),h}},t.Widget=function(){},t.Widget._childConstructors=[],t.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",defaultElement:"<div>",options:{classes:{},disabled:!1,create:null},_createWidget:function(e,s){s=t(s||this.defaultElement||this)[0],this.element=t(s),this.uuid=i++,this.eventNamespace="."+this.widgetName+this.uuid,this.bindings=t(),this.hoverable=t(),this.focusable=t(),this.classesElementLookup={},s!==this&&(t.data(s,this.widgetFullName,this),this._on(!0,this.element,{remove:function(t){t.target===s&&this.destroy()}}),this.document=t(s.style?s.ownerDocument:s.document||s),this.window=t(this.document[0].defaultView||this.document[0].parentWindow)),this.options=t.widget.extend({},this.options,this._getCreateOptions(),e),this._create(),this.options.disabled&&this._setOptionDisabled(this.options.disabled),this._trigger("create",null,this._getCreateEventData()),this._init()},_getCreateOptions:function(){return{}},_getCreateEventData:t.noop,_create:t.noop,_init:t.noop,destroy:function(){var e=this;this._destroy(),t.each(this.classesElementLookup,function(t,i){e._removeClass(i,t)}),this.element.off(this.eventNamespace).removeData(this.widgetFullName),this.widget().off(this.eventNamespace).removeAttr("aria-disabled"),this.bindings.off(this.eventNamespace)},_destroy:t.noop,widget:function(){return this.element},option:function(e,i){var s,n,o,a=e;if(0===arguments.length)return t.widget.extend({},this.options);if("string"==typeof e)if(a={},s=e.split("."),e=s.shift(),s.length){for(n=a[e]=t.widget.extend({},this.options[e]),o=0;s.length-1>o;o++)n[s[o]]=n[s[o]]||{},n=n[s[o]];if(e=s.pop(),1===arguments.length)return void 0===n[e]?null:n[e];n[e]=i}else{if(1===arguments.length)return void 0===this.options[e]?null:this.options[e];a[e]=i}return this._setOptions(a),this},_setOptions:function(t){var e;for(e in t)this._setOption(e,t[e]);return this},_setOption:function(t,e){return"classes"===t&&this._setOptionClasses(e),this.options[t]=e,"disabled"===t&&this._setOptionDisabled(e),this},_setOptionClasses:function(e){var i,s,n;for(i in e)n=this.classesElementLookup[i],e[i]!==this.options.classes[i]&&n&&n.length&&(s=t(n.get()),this._removeClass(n,i),s.addClass(this._classes({element:s,keys:i,classes:e,add:!0})))},_setOptionDisabled:function(t){this._toggleClass(this.widget(),this.widgetFullName+"-disabled",null,!!t),t&&(this._removeClass(this.hoverable,null,"ui-state-hover"),this._removeClass(this.focusable,null,"ui-state-focus"))},enable:function(){return this._setOptions({disabled:!1})},disable:function(){return this._setOptions({disabled:!0})},_classes:function(e){function i(i,o){var a,r;for(r=0;i.length>r;r++)a=n.classesElementLookup[i[r]]||t(),a=e.add?t(t.unique(a.get().concat(e.element.get()))):t(a.not(e.element).get()),n.classesElementLookup[i[r]]=a,s.push(i[r]),o&&e.classes[i[r]]&&s.push(e.classes[i[r]])}var s=[],n=this;return e=t.extend({element:this.element,classes:this.options.classes||{}},e),this._on(e.element,{remove:"_untrackClassesElement"}),e.keys&&i(e.keys.match(/\S+/g)||[],!0),e.extra&&i(e.extra.match(/\S+/g)||[]),s.join(" ")},_untrackClassesElement:function(e){var i=this;t.each(i.classesElementLookup,function(s,n){-1!==t.inArray(e.target,n)&&(i.classesElementLookup[s]=t(n.not(e.target).get()))})},_removeClass:function(t,e,i){return this._toggleClass(t,e,i,!1)},_addClass:function(t,e,i){return this._toggleClass(t,e,i,!0)},_toggleClass:function(t,e,i,s){s="boolean"==typeof s?s:i;var n="string"==typeof t||null===t,o={extra:n?e:i,keys:n?t:e,element:n?this.element:t,add:s};return o.element.toggleClass(this._classes(o),s),this},_on:function(e,i,s){var n,o=this;"boolean"!=typeof e&&(s=i,i=e,e=!1),s?(i=n=t(i),this.bindings=this.bindings.add(i)):(s=i,i=this.element,n=this.widget()),t.each(s,function(s,a){function r(){return e||o.options.disabled!==!0&&!t(this).hasClass("ui-state-disabled")?("string"==typeof a?o[a]:a).apply(o,arguments):void 0}"string"!=typeof a&&(r.guid=a.guid=a.guid||r.guid||t.guid++);var h=s.match(/^([\w:-]*)\s*(.*)$/),l=h[1]+o.eventNamespace,c=h[2];c?n.on(l,c,r):i.on(l,r)})},_off:function(e,i){i=(i||"").split(" ").join(this.eventNamespace+" ")+this.eventNamespace,e.off(i).off(i),this.bindings=t(this.bindings.not(e).get()),this.focusable=t(this.focusable.not(e).get()),this.hoverable=t(this.hoverable.not(e).get())},_delay:function(t,e){function i(){return("string"==typeof t?s[t]:t).apply(s,arguments)}var s=this;return setTimeout(i,e||0)},_hoverable:function(e){this.hoverable=this.hoverable.add(e),this._on(e,{mouseenter:function(e){this._addClass(t(e.currentTarget),null,"ui-state-hover")},mouseleave:function(e){this._removeClass(t(e.currentTarget),null,"ui-state-hover")}})},_focusable:function(e){this.focusable=this.focusable.add(e),this._on(e,{focusin:function(e){this._addClass(t(e.currentTarget),null,"ui-state-focus")},focusout:function(e){this._removeClass(t(e.currentTarget),null,"ui-state-focus")}})},_trigger:function(e,i,s){var n,o,a=this.options[e];if(s=s||{},i=t.Event(i),i.type=(e===this.widgetEventPrefix?e:this.widgetEventPrefix+e).toLowerCase(),i.target=this.element[0],o=i.originalEvent)for(n in o)n in i||(i[n]=o[n]);return this.element.trigger(i,s),!(t.isFunction(a)&&a.apply(this.element[0],[i].concat(s))===!1||i.isDefaultPrevented())}},t.each({show:"fadeIn",hide:"fadeOut"},function(e,i){t.Widget.prototype["_"+e]=function(s,n,o){"string"==typeof n&&(n={effect:n});var a,r=n?n===!0||"number"==typeof n?i:n.effect||i:e;n=n||{},"number"==typeof n&&(n={duration:n}),a=!t.isEmptyObject(n),n.complete=o,n.delay&&s.delay(n.delay),a&&t.effects&&t.effects.effect[r]?s[e](n):r!==e&&s[r]?s[r](n.duration,n.easing,o):s.queue(function(i){t(this)[e](),o&&o.call(s[0]),i()})}}),t.widget,function(){function e(t,e,i){return[parseFloat(t[0])*(u.test(t[0])?e/100:1),parseFloat(t[1])*(u.test(t[1])?i/100:1)]}function i(e,i){return parseInt(t.css(e,i),10)||0}function s(e){var i=e[0];return 9===i.nodeType?{width:e.width(),height:e.height(),offset:{top:0,left:0}}:t.isWindow(i)?{width:e.width(),height:e.height(),offset:{top:e.scrollTop(),left:e.scrollLeft()}}:i.preventDefault?{width:0,height:0,offset:{top:i.pageY,left:i.pageX}}:{width:e.outerWidth(),height:e.outerHeight(),offset:e.offset()}}var n,o=Math.max,a=Math.abs,r=/left|center|right/,h=/top|center|bottom/,l=/[\+\-]\d+(\.[\d]+)?%?/,c=/^\w+/,u=/%$/,d=t.fn.position;t.position={scrollbarWidth:function(){if(void 0!==n)return n;var e,i,s=t("<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>"),o=s.children()[0];return t("body").append(s),e=o.offsetWidth,s.css("overflow","scroll"),i=o.offsetWidth,e===i&&(i=s[0].clientWidth),s.remove(),n=e-i},getScrollInfo:function(e){var i=e.isWindow||e.isDocument?"":e.element.css("overflow-x"),s=e.isWindow||e.isDocument?"":e.element.css("overflow-y"),n="scroll"===i||"auto"===i&&e.width<e.element[0].scrollWidth,o="scroll"===s||"auto"===s&&e.height<e.element[0].scrollHeight;return{width:o?t.position.scrollbarWidth():0,height:n?t.position.scrollbarWidth():0}},getWithinInfo:function(e){var i=t(e||window),s=t.isWindow(i[0]),n=!!i[0]&&9===i[0].nodeType,o=!s&&!n;return{element:i,isWindow:s,isDocument:n,offset:o?t(e).offset():{left:0,top:0},scrollLeft:i.scrollLeft(),scrollTop:i.scrollTop(),width:i.outerWidth(),height:i.outerHeight()}}},t.fn.position=function(n){if(!n||!n.of)return d.apply(this,arguments);n=t.extend({},n);var u,p,f,m,g,_,v=t(n.of),b=t.position.getWithinInfo(n.within),y=t.position.getScrollInfo(b),w=(n.collision||"flip").split(" "),x={};return _=s(v),v[0].preventDefault&&(n.at="left top"),p=_.width,f=_.height,m=_.offset,g=t.extend({},m),t.each(["my","at"],function(){var t,e,i=(n[this]||"").split(" ");1===i.length&&(i=r.test(i[0])?i.concat(["center"]):h.test(i[0])?["center"].concat(i):["center","center"]),i[0]=r.test(i[0])?i[0]:"center",i[1]=h.test(i[1])?i[1]:"center",t=l.exec(i[0]),e=l.exec(i[1]),x[this]=[t?t[0]:0,e?e[0]:0],n[this]=[c.exec(i[0])[0],c.exec(i[1])[0]]}),1===w.length&&(w[1]=w[0]),"right"===n.at[0]?g.left+=p:"center"===n.at[0]&&(g.left+=p/2),"bottom"===n.at[1]?g.top+=f:"center"===n.at[1]&&(g.top+=f/2),u=e(x.at,p,f),g.left+=u[0],g.top+=u[1],this.each(function(){var s,r,h=t(this),l=h.outerWidth(),c=h.outerHeight(),d=i(this,"marginLeft"),_=i(this,"marginTop"),k=l+d+i(this,"marginRight")+y.width,C=c+_+i(this,"marginBottom")+y.height,D=t.extend({},g),T=e(x.my,h.outerWidth(),h.outerHeight());"right"===n.my[0]?D.left-=l:"center"===n.my[0]&&(D.left-=l/2),"bottom"===n.my[1]?D.top-=c:"center"===n.my[1]&&(D.top-=c/2),D.left+=T[0],D.top+=T[1],s={marginLeft:d,marginTop:_},t.each(["left","top"],function(e,i){t.ui.position[w[e]]&&t.ui.position[w[e]][i](D,{targetWidth:p,targetHeight:f,elemWidth:l,elemHeight:c,collisionPosition:s,collisionWidth:k,collisionHeight:C,offset:[u[0]+T[0],u[1]+T[1]],my:n.my,at:n.at,within:b,elem:h})}),n.using&&(r=function(t){var e=m.left-D.left,i=e+p-l,s=m.top-D.top,r=s+f-c,u={target:{element:v,left:m.left,top:m.top,width:p,height:f},element:{element:h,left:D.left,top:D.top,width:l,height:c},horizontal:0>i?"left":e>0?"right":"center",vertical:0>r?"top":s>0?"bottom":"middle"};l>p&&p>a(e+i)&&(u.horizontal="center"),c>f&&f>a(s+r)&&(u.vertical="middle"),u.important=o(a(e),a(i))>o(a(s),a(r))?"horizontal":"vertical",n.using.call(this,t,u)}),h.offset(t.extend(D,{using:r}))})},t.ui.position={fit:{left:function(t,e){var i,s=e.within,n=s.isWindow?s.scrollLeft:s.offset.left,a=s.width,r=t.left-e.collisionPosition.marginLeft,h=n-r,l=r+e.collisionWidth-a-n;e.collisionWidth>a?h>0&&0>=l?(i=t.left+h+e.collisionWidth-a-n,t.left+=h-i):t.left=l>0&&0>=h?n:h>l?n+a-e.collisionWidth:n:h>0?t.left+=h:l>0?t.left-=l:t.left=o(t.left-r,t.left)},top:function(t,e){var i,s=e.within,n=s.isWindow?s.scrollTop:s.offset.top,a=e.within.height,r=t.top-e.collisionPosition.marginTop,h=n-r,l=r+e.collisionHeight-a-n;e.collisionHeight>a?h>0&&0>=l?(i=t.top+h+e.collisionHeight-a-n,t.top+=h-i):t.top=l>0&&0>=h?n:h>l?n+a-e.collisionHeight:n:h>0?t.top+=h:l>0?t.top-=l:t.top=o(t.top-r,t.top)}},flip:{left:function(t,e){var i,s,n=e.within,o=n.offset.left+n.scrollLeft,r=n.width,h=n.isWindow?n.scrollLeft:n.offset.left,l=t.left-e.collisionPosition.marginLeft,c=l-h,u=l+e.collisionWidth-r-h,d="left"===e.my[0]?-e.elemWidth:"right"===e.my[0]?e.elemWidth:0,p="left"===e.at[0]?e.targetWidth:"right"===e.at[0]?-e.targetWidth:0,f=-2*e.offset[0];0>c?(i=t.left+d+p+f+e.collisionWidth-r-o,(0>i||a(c)>i)&&(t.left+=d+p+f)):u>0&&(s=t.left-e.collisionPosition.marginLeft+d+p+f-h,(s>0||u>a(s))&&(t.left+=d+p+f))},top:function(t,e){var i,s,n=e.within,o=n.offset.top+n.scrollTop,r=n.height,h=n.isWindow?n.scrollTop:n.offset.top,l=t.top-e.collisionPosition.marginTop,c=l-h,u=l+e.collisionHeight-r-h,d="top"===e.my[1],p=d?-e.elemHeight:"bottom"===e.my[1]?e.elemHeight:0,f="top"===e.at[1]?e.targetHeight:"bottom"===e.at[1]?-e.targetHeight:0,m=-2*e.offset[1];0>c?(s=t.top+p+f+m+e.collisionHeight-r-o,(0>s||a(c)>s)&&(t.top+=p+f+m)):u>0&&(i=t.top-e.collisionPosition.marginTop+p+f+m-h,(i>0||u>a(i))&&(t.top+=p+f+m))}},flipfit:{left:function(){t.ui.position.flip.left.apply(this,arguments),t.ui.position.fit.left.apply(this,arguments)},top:function(){t.ui.position.flip.top.apply(this,arguments),t.ui.position.fit.top.apply(this,arguments)}}}}(),t.ui.position,t.extend(t.expr[":"],{data:t.expr.createPseudo?t.expr.createPseudo(function(e){return function(i){return!!t.data(i,e)}}):function(e,i,s){return!!t.data(e,s[3])}}),t.fn.extend({disableSelection:function(){var t="onselectstart"in document.createElement("div")?"selectstart":"mousedown";return function(){return this.on(t+".ui-disableSelection",function(t){t.preventDefault()})}}(),enableSelection:function(){return this.off(".ui-disableSelection")}}),t.ui.focusable=function(i,s){var n,o,a,r,h,l=i.nodeName.toLowerCase();return"area"===l?(n=i.parentNode,o=n.name,i.href&&o&&"map"===n.nodeName.toLowerCase()?(a=t("img[usemap='#"+o+"']"),a.length>0&&a.is(":visible")):!1):(/^(input|select|textarea|button|object)$/.test(l)?(r=!i.disabled,r&&(h=t(i).closest("fieldset")[0],h&&(r=!h.disabled))):r="a"===l?i.href||s:s,r&&t(i).is(":visible")&&e(t(i)))},t.extend(t.expr[":"],{focusable:function(e){return t.ui.focusable(e,null!=t.attr(e,"tabindex"))}}),t.ui.focusable,t.fn.form=function(){return"string"==typeof this[0].form?this.closest("form"):t(this[0].form)},t.ui.formResetMixin={_formResetHandler:function(){var e=t(this);setTimeout(function(){var i=e.data("ui-form-reset-instances");t.each(i,function(){this.refresh()})})},_bindFormResetHandler:function(){if(this.form=this.element.form(),this.form.length){var t=this.form.data("ui-form-reset-instances")||[];t.length||this.form.on("reset.ui-form-reset",this._formResetHandler),t.push(this),this.form.data("ui-form-reset-instances",t)}},_unbindFormResetHandler:function(){if(this.form.length){var e=this.form.data("ui-form-reset-instances");e.splice(t.inArray(this,e),1),e.length?this.form.data("ui-form-reset-instances",e):this.form.removeData("ui-form-reset-instances").off("reset.ui-form-reset")}}},"1.7"===t.fn.jquery.substring(0,3)&&(t.each(["Width","Height"],function(e,i){function s(e,i,s,o){return t.each(n,function(){i-=parseFloat(t.css(e,"padding"+this))||0,s&&(i-=parseFloat(t.css(e,"border"+this+"Width"))||0),o&&(i-=parseFloat(t.css(e,"margin"+this))||0)}),i}var n="Width"===i?["Left","Right"]:["Top","Bottom"],o=i.toLowerCase(),a={innerWidth:t.fn.innerWidth,innerHeight:t.fn.innerHeight,outerWidth:t.fn.outerWidth,outerHeight:t.fn.outerHeight};t.fn["inner"+i]=function(e){return void 0===e?a["inner"+i].call(this):this.each(function(){t(this).css(o,s(this,e)+"px")})},t.fn["outer"+i]=function(e,n){return"number"!=typeof e?a["outer"+i].call(this,e):this.each(function(){t(this).css(o,s(this,e,!0,n)+"px")})}}),t.fn.addBack=function(t){return this.add(null==t?this.prevObject:this.prevObject.filter(t))}),t.ui.keyCode={BACKSPACE:8,COMMA:188,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,LEFT:37,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SPACE:32,TAB:9,UP:38},t.ui.escapeSelector=function(){var t=/([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g;return function(e){return e.replace(t,"\\$1")}}(),t.fn.labels=function(){var e,i,s,n,o;return this[0].labels&&this[0].labels.length?this.pushStack(this[0].labels):(n=this.eq(0).parents("label"),s=this.attr("id"),s&&(e=this.eq(0).parents().last(),o=e.add(e.length?e.siblings():this.siblings()),i="label[for='"+t.ui.escapeSelector(s)+"']",n=n.add(o.find(i).addBack(i))),this.pushStack(n))},t.fn.scrollParent=function(e){var i=this.css("position"),s="absolute"===i,n=e?/(auto|scroll|hidden)/:/(auto|scroll)/,o=this.parents().filter(function(){var e=t(this);return s&&"static"===e.css("position")?!1:n.test(e.css("overflow")+e.css("overflow-y")+e.css("overflow-x"))}).eq(0);return"fixed"!==i&&o.length?o:t(this[0].ownerDocument||document)},t.extend(t.expr[":"],{tabbable:function(e){var i=t.attr(e,"tabindex"),s=null!=i;return(!s||i>=0)&&t.ui.focusable(e,s)}}),t.fn.extend({uniqueId:function(){var t=0;return function(){return this.each(function(){this.id||(this.id="ui-id-"+ ++t)})}}(),removeUniqueId:function(){return this.each(function(){/^ui-id-\d+$/.test(this.id)&&t(this).removeAttr("id")})}}),t.ui.ie=!!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase());var n=!1;t(document).on("mouseup",function(){n=!1}),t.widget("ui.mouse",{version:"1.12.1",options:{cancel:"input, textarea, button, select, option",distance:1,delay:0},_mouseInit:function(){var e=this;this.element.on("mousedown."+this.widgetName,function(t){return e._mouseDown(t)}).on("click."+this.widgetName,function(i){return!0===t.data(i.target,e.widgetName+".preventClickEvent")?(t.removeData(i.target,e.widgetName+".preventClickEvent"),i.stopImmediatePropagation(),!1):void 0}),this.started=!1},_mouseDestroy:function(){this.element.off("."+this.widgetName),this._mouseMoveDelegate&&this.document.off("mousemove."+this.widgetName,this._mouseMoveDelegate).off("mouseup."+this.widgetName,this._mouseUpDelegate)},_mouseDown:function(e){if(!n){this._mouseMoved=!1,this._mouseStarted&&this._mouseUp(e),this._mouseDownEvent=e;var i=this,s=1===e.which,o="string"==typeof this.options.cancel&&e.target.nodeName?t(e.target).closest(this.options.cancel).length:!1;return s&&!o&&this._mouseCapture(e)?(this.mouseDelayMet=!this.options.delay,this.mouseDelayMet||(this._mouseDelayTimer=setTimeout(function(){i.mouseDelayMet=!0},this.options.delay)),this._mouseDistanceMet(e)&&this._mouseDelayMet(e)&&(this._mouseStarted=this._mouseStart(e)!==!1,!this._mouseStarted)?(e.preventDefault(),!0):(!0===t.data(e.target,this.widgetName+".preventClickEvent")&&t.removeData(e.target,this.widgetName+".preventClickEvent"),this._mouseMoveDelegate=function(t){return i._mouseMove(t)},this._mouseUpDelegate=function(t){return i._mouseUp(t)},this.document.on("mousemove."+this.widgetName,this._mouseMoveDelegate).on("mouseup."+this.widgetName,this._mouseUpDelegate),e.preventDefault(),n=!0,!0)):!0}},_mouseMove:function(e){if(this._mouseMoved){if(t.ui.ie&&(!document.documentMode||9>document.documentMode)&&!e.button)return this._mouseUp(e);if(!e.which)if(e.originalEvent.altKey||e.originalEvent.ctrlKey||e.originalEvent.metaKey||e.originalEvent.shiftKey)this.ignoreMissingWhich=!0;else if(!this.ignoreMissingWhich)return this._mouseUp(e)}return(e.which||e.button)&&(this._mouseMoved=!0),this._mouseStarted?(this._mouseDrag(e),e.preventDefault()):(this._mouseDistanceMet(e)&&this._mouseDelayMet(e)&&(this._mouseStarted=this._mouseStart(this._mouseDownEvent,e)!==!1,this._mouseStarted?this._mouseDrag(e):this._mouseUp(e)),!this._mouseStarted)},_mouseUp:function(e){this.document.off("mousemove."+this.widgetName,this._mouseMoveDelegate).off("mouseup."+this.widgetName,this._mouseUpDelegate),this._mouseStarted&&(this._mouseStarted=!1,e.target===this._mouseDownEvent.target&&t.data(e.target,this.widgetName+".preventClickEvent",!0),this._mouseStop(e)),this._mouseDelayTimer&&(clearTimeout(this._mouseDelayTimer),delete this._mouseDelayTimer),this.ignoreMissingWhich=!1,n=!1,e.preventDefault()},_mouseDistanceMet:function(t){return Math.max(Math.abs(this._mouseDownEvent.pageX-t.pageX),Math.abs(this._mouseDownEvent.pageY-t.pageY))>=this.options.distance},_mouseDelayMet:function(){return this.mouseDelayMet},_mouseStart:function(){},_mouseDrag:function(){},_mouseStop:function(){},_mouseCapture:function(){return!0}}),t.ui.plugin={add:function(e,i,s){var n,o=t.ui[e].prototype;for(n in s)o.plugins[n]=o.plugins[n]||[],o.plugins[n].push([i,s[n]])},call:function(t,e,i,s){var n,o=t.plugins[e];if(o&&(s||t.element[0].parentNode&&11!==t.element[0].parentNode.nodeType))for(n=0;o.length>n;n++)t.options[o[n][0]]&&o[n][1].apply(t.element,i)}},t.widget("ui.resizable",t.ui.mouse,{version:"1.12.1",widgetEventPrefix:"resize",options:{alsoResize:!1,animate:!1,animateDuration:"slow",animateEasing:"swing",aspectRatio:!1,autoHide:!1,classes:{"ui-resizable-se":"ui-icon ui-icon-gripsmall-diagonal-se"},containment:!1,ghost:!1,grid:!1,handles:"e,s,se",helper:!1,maxHeight:null,maxWidth:null,minHeight:10,minWidth:10,zIndex:90,resize:null,start:null,stop:null},_num:function(t){return parseFloat(t)||0},_isNumber:function(t){return!isNaN(parseFloat(t))},_hasScroll:function(e,i){if("hidden"===t(e).css("overflow"))return!1;var s=i&&"left"===i?"scrollLeft":"scrollTop",n=!1;return e[s]>0?!0:(e[s]=1,n=e[s]>0,e[s]=0,n)},_create:function(){var e,i=this.options,s=this;this._addClass("ui-resizable"),t.extend(this,{_aspectRatio:!!i.aspectRatio,aspectRatio:i.aspectRatio,originalElement:this.element,_proportionallyResizeElements:[],_helper:i.helper||i.ghost||i.animate?i.helper||"ui-resizable-helper":null}),this.element[0].nodeName.match(/^(canvas|textarea|input|select|button|img)$/i)&&(this.element.wrap(t("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({position:this.element.css("position"),width:this.element.outerWidth(),height:this.element.outerHeight(),top:this.element.css("top"),left:this.element.css("left")})),this.element=this.element.parent().data("ui-resizable",this.element.resizable("instance")),this.elementIsWrapper=!0,e={marginTop:this.originalElement.css("marginTop"),marginRight:this.originalElement.css("marginRight"),marginBottom:this.originalElement.css("marginBottom"),marginLeft:this.originalElement.css("marginLeft")},this.element.css(e),this.originalElement.css("margin",0),this.originalResizeStyle=this.originalElement.css("resize"),this.originalElement.css("resize","none"),this._proportionallyResizeElements.push(this.originalElement.css({position:"static",zoom:1,display:"block"})),this.originalElement.css(e),this._proportionallyResize()),this._setupHandles(),i.autoHide&&t(this.element).on("mouseenter",function(){i.disabled||(s._removeClass("ui-resizable-autohide"),s._handles.show())}).on("mouseleave",function(){i.disabled||s.resizing||(s._addClass("ui-resizable-autohide"),s._handles.hide())}),this._mouseInit()},_destroy:function(){this._mouseDestroy();var e,i=function(e){t(e).removeData("resizable").removeData("ui-resizable").off(".resizable").find(".ui-resizable-handle").remove()};return this.elementIsWrapper&&(i(this.element),e=this.element,this.originalElement.css({position:e.css("position"),width:e.outerWidth(),height:e.outerHeight(),top:e.css("top"),left:e.css("left")}).insertAfter(e),e.remove()),this.originalElement.css("resize",this.originalResizeStyle),i(this.originalElement),this},_setOption:function(t,e){switch(this._super(t,e),t){case"handles":this._removeHandles(),this._setupHandles();break;default:}},_setupHandles:function(){var e,i,s,n,o,a=this.options,r=this;if(this.handles=a.handles||(t(".ui-resizable-handle",this.element).length?{n:".ui-resizable-n",e:".ui-resizable-e",s:".ui-resizable-s",w:".ui-resizable-w",se:".ui-resizable-se",sw:".ui-resizable-sw",ne:".ui-resizable-ne",nw:".ui-resizable-nw"}:"e,s,se"),this._handles=t(),this.handles.constructor===String)for("all"===this.handles&&(this.handles="n,e,s,w,se,sw,ne,nw"),s=this.handles.split(","),this.handles={},i=0;s.length>i;i++)e=t.trim(s[i]),n="ui-resizable-"+e,o=t("<div>"),this._addClass(o,"ui-resizable-handle "+n),o.css({zIndex:a.zIndex}),this.handles[e]=".ui-resizable-"+e,this.element.append(o);this._renderAxis=function(e){var i,s,n,o;e=e||this.element;for(i in this.handles)this.handles[i].constructor===String?this.handles[i]=this.element.children(this.handles[i]).first().show():(this.handles[i].jquery||this.handles[i].nodeType)&&(this.handles[i]=t(this.handles[i]),this._on(this.handles[i],{mousedown:r._mouseDown})),this.elementIsWrapper&&this.originalElement[0].nodeName.match(/^(textarea|input|select|button)$/i)&&(s=t(this.handles[i],this.element),o=/sw|ne|nw|se|n|s/.test(i)?s.outerHeight():s.outerWidth(),n=["padding",/ne|nw|n/.test(i)?"Top":/se|sw|s/.test(i)?"Bottom":/^e$/.test(i)?"Right":"Left"].join(""),e.css(n,o),this._proportionallyResize()),this._handles=this._handles.add(this.handles[i])},this._renderAxis(this.element),this._handles=this._handles.add(this.element.find(".ui-resizable-handle")),this._handles.disableSelection(),this._handles.on("mouseover",function(){r.resizing||(this.className&&(o=this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i)),r.axis=o&&o[1]?o[1]:"se")}),a.autoHide&&(this._handles.hide(),this._addClass("ui-resizable-autohide"))},_removeHandles:function(){this._handles.remove()},_mouseCapture:function(e){var i,s,n=!1;for(i in this.handles)s=t(this.handles[i])[0],(s===e.target||t.contains(s,e.target))&&(n=!0);return!this.options.disabled&&n},_mouseStart:function(e){var i,s,n,o=this.options,a=this.element;return this.resizing=!0,this._renderProxy(),i=this._num(this.helper.css("left")),s=this._num(this.helper.css("top")),o.containment&&(i+=t(o.containment).scrollLeft()||0,s+=t(o.containment).scrollTop()||0),this.offset=this.helper.offset(),this.position={left:i,top:s},this.size=this._helper?{width:this.helper.width(),height:this.helper.height()}:{width:a.width(),height:a.height()},this.originalSize=this._helper?{width:a.outerWidth(),height:a.outerHeight()}:{width:a.width(),height:a.height()},this.sizeDiff={width:a.outerWidth()-a.width(),height:a.outerHeight()-a.height()},this.originalPosition={left:i,top:s},this.originalMousePosition={left:e.pageX,top:e.pageY},this.aspectRatio="number"==typeof o.aspectRatio?o.aspectRatio:this.originalSize.width/this.originalSize.height||1,n=t(".ui-resizable-"+this.axis).css("cursor"),t("body").css("cursor","auto"===n?this.axis+"-resize":n),this._addClass("ui-resizable-resizing"),this._propagate("start",e),!0},_mouseDrag:function(e){var i,s,n=this.originalMousePosition,o=this.axis,a=e.pageX-n.left||0,r=e.pageY-n.top||0,h=this._change[o];return this._updatePrevProperties(),h?(i=h.apply(this,[e,a,r]),this._updateVirtualBoundaries(e.shiftKey),(this._aspectRatio||e.shiftKey)&&(i=this._updateRatio(i,e)),i=this._respectSize(i,e),this._updateCache(i),this._propagate("resize",e),s=this._applyChanges(),!this._helper&&this._proportionallyResizeElements.length&&this._proportionallyResize(),t.isEmptyObject(s)||(this._updatePrevProperties(),this._trigger("resize",e,this.ui()),this._applyChanges()),!1):!1},_mouseStop:function(e){this.resizing=!1;var i,s,n,o,a,r,h,l=this.options,c=this;return this._helper&&(i=this._proportionallyResizeElements,s=i.length&&/textarea/i.test(i[0].nodeName),n=s&&this._hasScroll(i[0],"left")?0:c.sizeDiff.height,o=s?0:c.sizeDiff.width,a={width:c.helper.width()-o,height:c.helper.height()-n},r=parseFloat(c.element.css("left"))+(c.position.left-c.originalPosition.left)||null,h=parseFloat(c.element.css("top"))+(c.position.top-c.originalPosition.top)||null,l.animate||this.element.css(t.extend(a,{top:h,left:r})),c.helper.height(c.size.height),c.helper.width(c.size.width),this._helper&&!l.animate&&this._proportionallyResize()),t("body").css("cursor","auto"),this._removeClass("ui-resizable-resizing"),this._propagate("stop",e),this._helper&&this.helper.remove(),!1},_updatePrevProperties:function(){this.prevPosition={top:this.position.top,left:this.position.left},this.prevSize={width:this.size.width,height:this.size.height}},_applyChanges:function(){var t={};return this.position.top!==this.prevPosition.top&&(t.top=this.position.top+"px"),this.position.left!==this.prevPosition.left&&(t.left=this.position.left+"px"),this.size.width!==this.prevSize.width&&(t.width=this.size.width+"px"),this.size.height!==this.prevSize.height&&(t.height=this.size.height+"px"),this.helper.css(t),t},_updateVirtualBoundaries:function(t){var e,i,s,n,o,a=this.options;o={minWidth:this._isNumber(a.minWidth)?a.minWidth:0,maxWidth:this._isNumber(a.maxWidth)?a.maxWidth:1/0,minHeight:this._isNumber(a.minHeight)?a.minHeight:0,maxHeight:this._isNumber(a.maxHeight)?a.maxHeight:1/0},(this._aspectRatio||t)&&(e=o.minHeight*this.aspectRatio,s=o.minWidth/this.aspectRatio,i=o.maxHeight*this.aspectRatio,n=o.maxWidth/this.aspectRatio,e>o.minWidth&&(o.minWidth=e),s>o.minHeight&&(o.minHeight=s),o.maxWidth>i&&(o.maxWidth=i),o.maxHeight>n&&(o.maxHeight=n)),this._vBoundaries=o},_updateCache:function(t){this.offset=this.helper.offset(),this._isNumber(t.left)&&(this.position.left=t.left),this._isNumber(t.top)&&(this.position.top=t.top),this._isNumber(t.height)&&(this.size.height=t.height),this._isNumber(t.width)&&(this.size.width=t.width)},_updateRatio:function(t){var e=this.position,i=this.size,s=this.axis;return this._isNumber(t.height)?t.width=t.height*this.aspectRatio:this._isNumber(t.width)&&(t.height=t.width/this.aspectRatio),"sw"===s&&(t.left=e.left+(i.width-t.width),t.top=null),"nw"===s&&(t.top=e.top+(i.height-t.height),t.left=e.left+(i.width-t.width)),t},_respectSize:function(t){var e=this._vBoundaries,i=this.axis,s=this._isNumber(t.width)&&e.maxWidth&&e.maxWidth<t.width,n=this._isNumber(t.height)&&e.maxHeight&&e.maxHeight<t.height,o=this._isNumber(t.width)&&e.minWidth&&e.minWidth>t.width,a=this._isNumber(t.height)&&e.minHeight&&e.minHeight>t.height,r=this.originalPosition.left+this.originalSize.width,h=this.originalPosition.top+this.originalSize.height,l=/sw|nw|w/.test(i),c=/nw|ne|n/.test(i);return o&&(t.width=e.minWidth),a&&(t.height=e.minHeight),s&&(t.width=e.maxWidth),n&&(t.height=e.maxHeight),o&&l&&(t.left=r-e.minWidth),s&&l&&(t.left=r-e.maxWidth),a&&c&&(t.top=h-e.minHeight),n&&c&&(t.top=h-e.maxHeight),t.width||t.height||t.left||!t.top?t.width||t.height||t.top||!t.left||(t.left=null):t.top=null,t},_getPaddingPlusBorderDimensions:function(t){for(var e=0,i=[],s=[t.css("borderTopWidth"),t.css("borderRightWidth"),t.css("borderBottomWidth"),t.css("borderLeftWidth")],n=[t.css("paddingTop"),t.css("paddingRight"),t.css("paddingBottom"),t.css("paddingLeft")];4>e;e++)i[e]=parseFloat(s[e])||0,i[e]+=parseFloat(n[e])||0;return{height:i[0]+i[2],width:i[1]+i[3]}},_proportionallyResize:function(){if(this._proportionallyResizeElements.length)for(var t,e=0,i=this.helper||this.element;this._proportionallyResizeElements.length>e;e++)t=this._proportionallyResizeElements[e],this.outerDimensions||(this.outerDimensions=this._getPaddingPlusBorderDimensions(t)),t.css({height:i.height()-this.outerDimensions.height||0,width:i.width()-this.outerDimensions.width||0})},_renderProxy:function(){var e=this.element,i=this.options;this.elementOffset=e.offset(),this._helper?(this.helper=this.helper||t("<div style='overflow:hidden;'></div>"),this._addClass(this.helper,this._helper),this.helper.css({width:this.element.outerWidth(),height:this.element.outerHeight(),position:"absolute",left:this.elementOffset.left+"px",top:this.elementOffset.top+"px",zIndex:++i.zIndex}),this.helper.appendTo("body").disableSelection()):this.helper=this.element
+},_change:{e:function(t,e){return{width:this.originalSize.width+e}},w:function(t,e){var i=this.originalSize,s=this.originalPosition;return{left:s.left+e,width:i.width-e}},n:function(t,e,i){var s=this.originalSize,n=this.originalPosition;return{top:n.top+i,height:s.height-i}},s:function(t,e,i){return{height:this.originalSize.height+i}},se:function(e,i,s){return t.extend(this._change.s.apply(this,arguments),this._change.e.apply(this,[e,i,s]))},sw:function(e,i,s){return t.extend(this._change.s.apply(this,arguments),this._change.w.apply(this,[e,i,s]))},ne:function(e,i,s){return t.extend(this._change.n.apply(this,arguments),this._change.e.apply(this,[e,i,s]))},nw:function(e,i,s){return t.extend(this._change.n.apply(this,arguments),this._change.w.apply(this,[e,i,s]))}},_propagate:function(e,i){t.ui.plugin.call(this,e,[i,this.ui()]),"resize"!==e&&this._trigger(e,i,this.ui())},plugins:{},ui:function(){return{originalElement:this.originalElement,element:this.element,helper:this.helper,position:this.position,size:this.size,originalSize:this.originalSize,originalPosition:this.originalPosition}}}),t.ui.plugin.add("resizable","animate",{stop:function(e){var i=t(this).resizable("instance"),s=i.options,n=i._proportionallyResizeElements,o=n.length&&/textarea/i.test(n[0].nodeName),a=o&&i._hasScroll(n[0],"left")?0:i.sizeDiff.height,r=o?0:i.sizeDiff.width,h={width:i.size.width-r,height:i.size.height-a},l=parseFloat(i.element.css("left"))+(i.position.left-i.originalPosition.left)||null,c=parseFloat(i.element.css("top"))+(i.position.top-i.originalPosition.top)||null;i.element.animate(t.extend(h,c&&l?{top:c,left:l}:{}),{duration:s.animateDuration,easing:s.animateEasing,step:function(){var s={width:parseFloat(i.element.css("width")),height:parseFloat(i.element.css("height")),top:parseFloat(i.element.css("top")),left:parseFloat(i.element.css("left"))};n&&n.length&&t(n[0]).css({width:s.width,height:s.height}),i._updateCache(s),i._propagate("resize",e)}})}}),t.ui.plugin.add("resizable","containment",{start:function(){var e,i,s,n,o,a,r,h=t(this).resizable("instance"),l=h.options,c=h.element,u=l.containment,d=u instanceof t?u.get(0):/parent/.test(u)?c.parent().get(0):u;d&&(h.containerElement=t(d),/document/.test(u)||u===document?(h.containerOffset={left:0,top:0},h.containerPosition={left:0,top:0},h.parentData={element:t(document),left:0,top:0,width:t(document).width(),height:t(document).height()||document.body.parentNode.scrollHeight}):(e=t(d),i=[],t(["Top","Right","Left","Bottom"]).each(function(t,s){i[t]=h._num(e.css("padding"+s))}),h.containerOffset=e.offset(),h.containerPosition=e.position(),h.containerSize={height:e.innerHeight()-i[3],width:e.innerWidth()-i[1]},s=h.containerOffset,n=h.containerSize.height,o=h.containerSize.width,a=h._hasScroll(d,"left")?d.scrollWidth:o,r=h._hasScroll(d)?d.scrollHeight:n,h.parentData={element:d,left:s.left,top:s.top,width:a,height:r}))},resize:function(e){var i,s,n,o,a=t(this).resizable("instance"),r=a.options,h=a.containerOffset,l=a.position,c=a._aspectRatio||e.shiftKey,u={top:0,left:0},d=a.containerElement,p=!0;d[0]!==document&&/static/.test(d.css("position"))&&(u=h),l.left<(a._helper?h.left:0)&&(a.size.width=a.size.width+(a._helper?a.position.left-h.left:a.position.left-u.left),c&&(a.size.height=a.size.width/a.aspectRatio,p=!1),a.position.left=r.helper?h.left:0),l.top<(a._helper?h.top:0)&&(a.size.height=a.size.height+(a._helper?a.position.top-h.top:a.position.top),c&&(a.size.width=a.size.height*a.aspectRatio,p=!1),a.position.top=a._helper?h.top:0),n=a.containerElement.get(0)===a.element.parent().get(0),o=/relative|absolute/.test(a.containerElement.css("position")),n&&o?(a.offset.left=a.parentData.left+a.position.left,a.offset.top=a.parentData.top+a.position.top):(a.offset.left=a.element.offset().left,a.offset.top=a.element.offset().top),i=Math.abs(a.sizeDiff.width+(a._helper?a.offset.left-u.left:a.offset.left-h.left)),s=Math.abs(a.sizeDiff.height+(a._helper?a.offset.top-u.top:a.offset.top-h.top)),i+a.size.width>=a.parentData.width&&(a.size.width=a.parentData.width-i,c&&(a.size.height=a.size.width/a.aspectRatio,p=!1)),s+a.size.height>=a.parentData.height&&(a.size.height=a.parentData.height-s,c&&(a.size.width=a.size.height*a.aspectRatio,p=!1)),p||(a.position.left=a.prevPosition.left,a.position.top=a.prevPosition.top,a.size.width=a.prevSize.width,a.size.height=a.prevSize.height)},stop:function(){var e=t(this).resizable("instance"),i=e.options,s=e.containerOffset,n=e.containerPosition,o=e.containerElement,a=t(e.helper),r=a.offset(),h=a.outerWidth()-e.sizeDiff.width,l=a.outerHeight()-e.sizeDiff.height;e._helper&&!i.animate&&/relative/.test(o.css("position"))&&t(this).css({left:r.left-n.left-s.left,width:h,height:l}),e._helper&&!i.animate&&/static/.test(o.css("position"))&&t(this).css({left:r.left-n.left-s.left,width:h,height:l})}}),t.ui.plugin.add("resizable","alsoResize",{start:function(){var e=t(this).resizable("instance"),i=e.options;t(i.alsoResize).each(function(){var e=t(this);e.data("ui-resizable-alsoresize",{width:parseFloat(e.width()),height:parseFloat(e.height()),left:parseFloat(e.css("left")),top:parseFloat(e.css("top"))})})},resize:function(e,i){var s=t(this).resizable("instance"),n=s.options,o=s.originalSize,a=s.originalPosition,r={height:s.size.height-o.height||0,width:s.size.width-o.width||0,top:s.position.top-a.top||0,left:s.position.left-a.left||0};t(n.alsoResize).each(function(){var e=t(this),s=t(this).data("ui-resizable-alsoresize"),n={},o=e.parents(i.originalElement[0]).length?["width","height"]:["width","height","top","left"];t.each(o,function(t,e){var i=(s[e]||0)+(r[e]||0);i&&i>=0&&(n[e]=i||null)}),e.css(n)})},stop:function(){t(this).removeData("ui-resizable-alsoresize")}}),t.ui.plugin.add("resizable","ghost",{start:function(){var e=t(this).resizable("instance"),i=e.size;e.ghost=e.originalElement.clone(),e.ghost.css({opacity:.25,display:"block",position:"relative",height:i.height,width:i.width,margin:0,left:0,top:0}),e._addClass(e.ghost,"ui-resizable-ghost"),t.uiBackCompat!==!1&&"string"==typeof e.options.ghost&&e.ghost.addClass(this.options.ghost),e.ghost.appendTo(e.helper)},resize:function(){var e=t(this).resizable("instance");e.ghost&&e.ghost.css({position:"relative",height:e.size.height,width:e.size.width})},stop:function(){var e=t(this).resizable("instance");e.ghost&&e.helper&&e.helper.get(0).removeChild(e.ghost.get(0))}}),t.ui.plugin.add("resizable","grid",{resize:function(){var e,i=t(this).resizable("instance"),s=i.options,n=i.size,o=i.originalSize,a=i.originalPosition,r=i.axis,h="number"==typeof s.grid?[s.grid,s.grid]:s.grid,l=h[0]||1,c=h[1]||1,u=Math.round((n.width-o.width)/l)*l,d=Math.round((n.height-o.height)/c)*c,p=o.width+u,f=o.height+d,m=s.maxWidth&&p>s.maxWidth,g=s.maxHeight&&f>s.maxHeight,_=s.minWidth&&s.minWidth>p,v=s.minHeight&&s.minHeight>f;s.grid=h,_&&(p+=l),v&&(f+=c),m&&(p-=l),g&&(f-=c),/^(se|s|e)$/.test(r)?(i.size.width=p,i.size.height=f):/^(ne)$/.test(r)?(i.size.width=p,i.size.height=f,i.position.top=a.top-d):/^(sw)$/.test(r)?(i.size.width=p,i.size.height=f,i.position.left=a.left-u):((0>=f-c||0>=p-l)&&(e=i._getPaddingPlusBorderDimensions(this)),f-c>0?(i.size.height=f,i.position.top=a.top-d):(f=c-e.height,i.size.height=f,i.position.top=a.top+o.height-f),p-l>0?(i.size.width=p,i.position.left=a.left-u):(p=l-e.width,i.size.width=p,i.position.left=a.left+o.width-p))}}),t.ui.resizable});/**
+ * Copyright (c) 2007 Ariel Flesler - aflesler ○ gmail • com | https://github.com/flesler
+ * Licensed under MIT
+ * @author Ariel Flesler
+ * @version 2.1.2
+ */
+;(function(f){"use strict";"function"===typeof define&&define.amd?define(["jquery"],f):"undefined"!==typeof module&&module.exports?module.exports=f(require("jquery")):f(jQuery)})(function($){"use strict";function n(a){return!a.nodeName||-1!==$.inArray(a.nodeName.toLowerCase(),["iframe","#document","html","body"])}function h(a){return $.isFunction(a)||$.isPlainObject(a)?a:{top:a,left:a}}var p=$.scrollTo=function(a,d,b){return $(window).scrollTo(a,d,b)};p.defaults={axis:"xy",duration:0,limit:!0};$.fn.scrollTo=function(a,d,b){"object"=== typeof d&&(b=d,d=0);"function"===typeof b&&(b={onAfter:b});"max"===a&&(a=9E9);b=$.extend({},p.defaults,b);d=d||b.duration;var u=b.queue&&1<b.axis.length;u&&(d/=2);b.offset=h(b.offset);b.over=h(b.over);return this.each(function(){function k(a){var k=$.extend({},b,{queue:!0,duration:d,complete:a&&function(){a.call(q,e,b)}});r.animate(f,k)}if(null!==a){var l=n(this),q=l?this.contentWindow||window:this,r=$(q),e=a,f={},t;switch(typeof e){case "number":case "string":if(/^([+-]=?)?\d+(\.\d+)?(px|%)?$/.test(e)){e= h(e);break}e=l?$(e):$(e,q);case "object":if(e.length===0)return;if(e.is||e.style)t=(e=$(e)).offset()}var v=$.isFunction(b.offset)&&b.offset(q,e)||b.offset;$.each(b.axis.split(""),function(a,c){var d="x"===c?"Left":"Top",m=d.toLowerCase(),g="scroll"+d,h=r[g](),n=p.max(q,c);t?(f[g]=t[m]+(l?0:h-r.offset()[m]),b.margin&&(f[g]-=parseInt(e.css("margin"+d),10)||0,f[g]-=parseInt(e.css("border"+d+"Width"),10)||0),f[g]+=v[m]||0,b.over[m]&&(f[g]+=e["x"===c?"width":"height"]()*b.over[m])):(d=e[m],f[g]=d.slice&& "%"===d.slice(-1)?parseFloat(d)/100*n:d);b.limit&&/^\d+$/.test(f[g])&&(f[g]=0>=f[g]?0:Math.min(f[g],n));!a&&1<b.axis.length&&(h===f[g]?f={}:u&&(k(b.onAfterFirst),f={}))});k(b.onAfter)}})};p.max=function(a,d){var b="x"===d?"Width":"Height",h="scroll"+b;if(!n(a))return a[h]-$(a)[b.toLowerCase()]();var b="client"+b,k=a.ownerDocument||a.document,l=k.documentElement,k=k.body;return Math.max(l[h],k[h])-Math.min(l[b],k[b])};$.Tween.propHooks.scrollLeft=$.Tween.propHooks.scrollTop={get:function(a){return $(a.elem)[a.prop]()}, set:function(a){var d=this.get(a);if(a.options.interrupt&&a._last&&a._last!==d)return $(a.elem).stop();var b=Math.round(a.now);d!==b&&($(a.elem)[a.prop](b),a._last=this.get(a))}};return p});
+/*!
+ PowerTip v1.3.1 (2018-04-15)
+ https://stevenbenner.github.io/jquery-powertip/
+ Copyright (c) 2018 Steven Benner (http://stevenbenner.com/).
+ Released under MIT license.
+ https://raw.github.com/stevenbenner/jquery-powertip/master/LICENSE.txt
+*/
+(function(root,factory){if(typeof define==="function"&&define.amd){define(["jquery"],factory)}else if(typeof module==="object"&&module.exports){module.exports=factory(require("jquery"))}else{factory(root.jQuery)}})(this,function($){var $document=$(document),$window=$(window),$body=$("body");var DATA_DISPLAYCONTROLLER="displayController",DATA_HASACTIVEHOVER="hasActiveHover",DATA_FORCEDOPEN="forcedOpen",DATA_HASMOUSEMOVE="hasMouseMove",DATA_MOUSEONTOTIP="mouseOnToPopup",DATA_ORIGINALTITLE="originalTitle",DATA_POWERTIP="powertip",DATA_POWERTIPJQ="powertipjq",DATA_POWERTIPTARGET="powertiptarget",EVENT_NAMESPACE=".powertip",RAD2DEG=180/Math.PI,MOUSE_EVENTS=["click","dblclick","mousedown","mouseup","mousemove","mouseover","mouseout","mouseenter","mouseleave","contextmenu"];var session={tooltips:null,isTipOpen:false,isFixedTipOpen:false,isClosing:false,tipOpenImminent:false,activeHover:null,currentX:0,currentY:0,previousX:0,previousY:0,desyncTimeout:null,closeDelayTimeout:null,mouseTrackingActive:false,delayInProgress:false,windowWidth:0,windowHeight:0,scrollTop:0,scrollLeft:0};var Collision={none:0,top:1,bottom:2,left:4,right:8};$.fn.powerTip=function(opts,arg){var targetElements=this,options,tipController;if(!targetElements.length){return targetElements}if($.type(opts)==="string"&&$.powerTip[opts]){return $.powerTip[opts].call(targetElements,targetElements,arg)}options=$.extend({},$.fn.powerTip.defaults,opts);tipController=new TooltipController(options);initTracking();targetElements.each(function elementSetup(){var $this=$(this),dataPowertip=$this.data(DATA_POWERTIP),dataElem=$this.data(DATA_POWERTIPJQ),dataTarget=$this.data(DATA_POWERTIPTARGET),title=$this.attr("title");if(!dataPowertip&&!dataTarget&&!dataElem&&title){$this.data(DATA_POWERTIP,title);$this.data(DATA_ORIGINALTITLE,title);$this.removeAttr("title")}$this.data(DATA_DISPLAYCONTROLLER,new DisplayController($this,options,tipController))});if(!options.manual){$.each(options.openEvents,function(idx,evt){if($.inArray(evt,options.closeEvents)>-1){targetElements.on(evt+EVENT_NAMESPACE,function elementToggle(event){$.powerTip.toggle(this,event)})}else{targetElements.on(evt+EVENT_NAMESPACE,function elementOpen(event){$.powerTip.show(this,event)})}});$.each(options.closeEvents,function(idx,evt){if($.inArray(evt,options.openEvents)<0){targetElements.on(evt+EVENT_NAMESPACE,function elementClose(event){$.powerTip.hide(this,!isMouseEvent(event))})}});targetElements.on("keydown"+EVENT_NAMESPACE,function elementKeyDown(event){if(event.keyCode===27){$.powerTip.hide(this,true)}})}return targetElements};$.fn.powerTip.defaults={fadeInTime:200,fadeOutTime:100,followMouse:false,popupId:"powerTip",popupClass:null,intentSensitivity:7,intentPollInterval:100,closeDelay:100,placement:"n",smartPlacement:false,offset:10,mouseOnToPopup:false,manual:false,openEvents:["mouseenter","focus"],closeEvents:["mouseleave","blur"]};$.fn.powerTip.smartPlacementLists={n:["n","ne","nw","s"],e:["e","ne","se","w","nw","sw","n","s","e"],s:["s","se","sw","n"],w:["w","nw","sw","e","ne","se","n","s","w"],nw:["nw","w","sw","n","s","se","nw"],ne:["ne","e","se","n","s","sw","ne"],sw:["sw","w","nw","s","n","ne","sw"],se:["se","e","ne","s","n","nw","se"],"nw-alt":["nw-alt","n","ne-alt","sw-alt","s","se-alt","w","e"],"ne-alt":["ne-alt","n","nw-alt","se-alt","s","sw-alt","e","w"],"sw-alt":["sw-alt","s","se-alt","nw-alt","n","ne-alt","w","e"],"se-alt":["se-alt","s","sw-alt","ne-alt","n","nw-alt","e","w"]};$.powerTip={show:function apiShowTip(element,event){if(isMouseEvent(event)){trackMouse(event);session.previousX=event.pageX;session.previousY=event.pageY;$(element).data(DATA_DISPLAYCONTROLLER).show()}else{$(element).first().data(DATA_DISPLAYCONTROLLER).show(true,true)}return element},reposition:function apiResetPosition(element){$(element).first().data(DATA_DISPLAYCONTROLLER).resetPosition();return element},hide:function apiCloseTip(element,immediate){var displayController;immediate=element?immediate:true;if(element){displayController=$(element).first().data(DATA_DISPLAYCONTROLLER)}else if(session.activeHover){displayController=session.activeHover.data(DATA_DISPLAYCONTROLLER)}if(displayController){displayController.hide(immediate)}return element},toggle:function apiToggle(element,event){if(session.activeHover&&session.activeHover.is(element)){$.powerTip.hide(element,!isMouseEvent(event))}else{$.powerTip.show(element,event)}return element}};$.powerTip.showTip=$.powerTip.show;$.powerTip.closeTip=$.powerTip.hide;function CSSCoordinates(){var me=this;me.top="auto";me.left="auto";me.right="auto";me.bottom="auto";me.set=function(property,value){if($.isNumeric(value)){me[property]=Math.round(value)}}}function DisplayController(element,options,tipController){var hoverTimer=null,myCloseDelay=null;function openTooltip(immediate,forceOpen){cancelTimer();if(!element.data(DATA_HASACTIVEHOVER)){if(!immediate){session.tipOpenImminent=true;hoverTimer=setTimeout(function intentDelay(){hoverTimer=null;checkForIntent()},options.intentPollInterval)}else{if(forceOpen){element.data(DATA_FORCEDOPEN,true)}closeAnyDelayed();tipController.showTip(element)}}else{cancelClose()}}function closeTooltip(disableDelay){if(myCloseDelay){myCloseDelay=session.closeDelayTimeout=clearTimeout(myCloseDelay);session.delayInProgress=false}cancelTimer();session.tipOpenImminent=false;if(element.data(DATA_HASACTIVEHOVER)){element.data(DATA_FORCEDOPEN,false);if(!disableDelay){session.delayInProgress=true;session.closeDelayTimeout=setTimeout(function closeDelay(){session.closeDelayTimeout=null;tipController.hideTip(element);session.delayInProgress=false;myCloseDelay=null},options.closeDelay);myCloseDelay=session.closeDelayTimeout}else{tipController.hideTip(element)}}}function checkForIntent(){var xDifference=Math.abs(session.previousX-session.currentX),yDifference=Math.abs(session.previousY-session.currentY),totalDifference=xDifference+yDifference;if(totalDifference<options.intentSensitivity){cancelClose();closeAnyDelayed();tipController.showTip(element)}else{session.previousX=session.currentX;session.previousY=session.currentY;openTooltip()}}function cancelTimer(stopClose){hoverTimer=clearTimeout(hoverTimer);if(session.closeDelayTimeout&&myCloseDelay===session.closeDelayTimeout||stopClose){cancelClose()}}function cancelClose(){session.closeDelayTimeout=clearTimeout(session.closeDelayTimeout);session.delayInProgress=false}function closeAnyDelayed(){if(session.delayInProgress&&session.activeHover&&!session.activeHover.is(element)){session.activeHover.data(DATA_DISPLAYCONTROLLER).hide(true)}}function repositionTooltip(){tipController.resetPosition(element)}this.show=openTooltip;this.hide=closeTooltip;this.cancel=cancelTimer;this.resetPosition=repositionTooltip}function PlacementCalculator(){function computePlacementCoords(element,placement,tipWidth,tipHeight,offset){var placementBase=placement.split("-")[0],coords=new CSSCoordinates,position;if(isSvgElement(element)){position=getSvgPlacement(element,placementBase)}else{position=getHtmlPlacement(element,placementBase)}switch(placement){case"n":coords.set("left",position.left-tipWidth/2);coords.set("bottom",session.windowHeight-position.top+offset);break;case"e":coords.set("left",position.left+offset);coords.set("top",position.top-tipHeight/2);break;case"s":coords.set("left",position.left-tipWidth/2);coords.set("top",position.top+offset);break;case"w":coords.set("top",position.top-tipHeight/2);coords.set("right",session.windowWidth-position.left+offset);break;case"nw":coords.set("bottom",session.windowHeight-position.top+offset);coords.set("right",session.windowWidth-position.left-20);break;case"nw-alt":coords.set("left",position.left);coords.set("bottom",session.windowHeight-position.top+offset);break;case"ne":coords.set("left",position.left-20);coords.set("bottom",session.windowHeight-position.top+offset);break;case"ne-alt":coords.set("bottom",session.windowHeight-position.top+offset);coords.set("right",session.windowWidth-position.left);break;case"sw":coords.set("top",position.top+offset);coords.set("right",session.windowWidth-position.left-20);break;case"sw-alt":coords.set("left",position.left);coords.set("top",position.top+offset);break;case"se":coords.set("left",position.left-20);coords.set("top",position.top+offset);break;case"se-alt":coords.set("top",position.top+offset);coords.set("right",session.windowWidth-position.left);break}return coords}function getHtmlPlacement(element,placement){var objectOffset=element.offset(),objectWidth=element.outerWidth(),objectHeight=element.outerHeight(),left,top;switch(placement){case"n":left=objectOffset.left+objectWidth/2;top=objectOffset.top;break;case"e":left=objectOffset.left+objectWidth;top=objectOffset.top+objectHeight/2;break;case"s":left=objectOffset.left+objectWidth/2;top=objectOffset.top+objectHeight;break;case"w":left=objectOffset.left;top=objectOffset.top+objectHeight/2;break;case"nw":left=objectOffset.left;top=objectOffset.top;break;case"ne":left=objectOffset.left+objectWidth;top=objectOffset.top;break;case"sw":left=objectOffset.left;top=objectOffset.top+objectHeight;break;case"se":left=objectOffset.left+objectWidth;top=objectOffset.top+objectHeight;break}return{top:top,left:left}}function getSvgPlacement(element,placement){var svgElement=element.closest("svg")[0],domElement=element[0],point=svgElement.createSVGPoint(),boundingBox=domElement.getBBox(),matrix=domElement.getScreenCTM(),halfWidth=boundingBox.width/2,halfHeight=boundingBox.height/2,placements=[],placementKeys=["nw","n","ne","e","se","s","sw","w"],coords,rotation,steps,x;function pushPlacement(){placements.push(point.matrixTransform(matrix))}point.x=boundingBox.x;point.y=boundingBox.y;pushPlacement();point.x+=halfWidth;pushPlacement();point.x+=halfWidth;pushPlacement();point.y+=halfHeight;pushPlacement();point.y+=halfHeight;pushPlacement();point.x-=halfWidth;pushPlacement();point.x-=halfWidth;pushPlacement();point.y-=halfHeight;pushPlacement();if(placements[0].y!==placements[1].y||placements[0].x!==placements[7].x){rotation=Math.atan2(matrix.b,matrix.a)*RAD2DEG;steps=Math.ceil((rotation%360-22.5)/45);if(steps<1){steps+=8}while(steps--){placementKeys.push(placementKeys.shift())}}for(x=0;x<placements.length;x++){if(placementKeys[x]===placement){coords=placements[x];break}}return{top:coords.y+session.scrollTop,left:coords.x+session.scrollLeft}}this.compute=computePlacementCoords}function TooltipController(options){var placementCalculator=new PlacementCalculator,tipElement=$("#"+options.popupId);if(tipElement.length===0){tipElement=$("<div/>",{id:options.popupId});if($body.length===0){$body=$("body")}$body.append(tipElement);session.tooltips=session.tooltips?session.tooltips.add(tipElement):tipElement}if(options.followMouse){if(!tipElement.data(DATA_HASMOUSEMOVE)){$document.on("mousemove"+EVENT_NAMESPACE,positionTipOnCursor);$window.on("scroll"+EVENT_NAMESPACE,positionTipOnCursor);tipElement.data(DATA_HASMOUSEMOVE,true)}}function beginShowTip(element){element.data(DATA_HASACTIVEHOVER,true);tipElement.queue(function queueTipInit(next){showTip(element);next()})}function showTip(element){var tipContent;if(!element.data(DATA_HASACTIVEHOVER)){return}if(session.isTipOpen){if(!session.isClosing){hideTip(session.activeHover)}tipElement.delay(100).queue(function queueTipAgain(next){showTip(element);next()});return}element.trigger("powerTipPreRender");tipContent=getTooltipContent(element);if(tipContent){tipElement.empty().append(tipContent)}else{return}element.trigger("powerTipRender");session.activeHover=element;session.isTipOpen=true;tipElement.data(DATA_MOUSEONTOTIP,options.mouseOnToPopup);tipElement.addClass(options.popupClass);if(!options.followMouse||element.data(DATA_FORCEDOPEN)){positionTipOnElement(element);session.isFixedTipOpen=true}else{positionTipOnCursor()}if(!element.data(DATA_FORCEDOPEN)&&!options.followMouse){$document.on("click"+EVENT_NAMESPACE,function documentClick(event){var target=event.target;if(target!==element[0]){if(options.mouseOnToPopup){if(target!==tipElement[0]&&!$.contains(tipElement[0],target)){$.powerTip.hide()}}else{$.powerTip.hide()}}})}if(options.mouseOnToPopup&&!options.manual){tipElement.on("mouseenter"+EVENT_NAMESPACE,function tipMouseEnter(){if(session.activeHover){session.activeHover.data(DATA_DISPLAYCONTROLLER).cancel()}});tipElement.on("mouseleave"+EVENT_NAMESPACE,function tipMouseLeave(){if(session.activeHover){session.activeHover.data(DATA_DISPLAYCONTROLLER).hide()}})}tipElement.fadeIn(options.fadeInTime,function fadeInCallback(){if(!session.desyncTimeout){session.desyncTimeout=setInterval(closeDesyncedTip,500)}element.trigger("powerTipOpen")})}function hideTip(element){session.isClosing=true;session.isTipOpen=false;session.desyncTimeout=clearInterval(session.desyncTimeout);element.data(DATA_HASACTIVEHOVER,false);element.data(DATA_FORCEDOPEN,false);$document.off("click"+EVENT_NAMESPACE);tipElement.off(EVENT_NAMESPACE);tipElement.fadeOut(options.fadeOutTime,function fadeOutCallback(){var coords=new CSSCoordinates;session.activeHover=null;session.isClosing=false;session.isFixedTipOpen=false;tipElement.removeClass();coords.set("top",session.currentY+options.offset);coords.set("left",session.currentX+options.offset);tipElement.css(coords);element.trigger("powerTipClose")})}function positionTipOnCursor(){var tipWidth,tipHeight,coords,collisions,collisionCount;if(!session.isFixedTipOpen&&(session.isTipOpen||session.tipOpenImminent&&tipElement.data(DATA_HASMOUSEMOVE))){tipWidth=tipElement.outerWidth();tipHeight=tipElement.outerHeight();coords=new CSSCoordinates;coords.set("top",session.currentY+options.offset);coords.set("left",session.currentX+options.offset);collisions=getViewportCollisions(coords,tipWidth,tipHeight);if(collisions!==Collision.none){collisionCount=countFlags(collisions);if(collisionCount===1){if(collisions===Collision.right){coords.set("left",session.scrollLeft+session.windowWidth-tipWidth)}else if(collisions===Collision.bottom){coords.set("top",session.scrollTop+session.windowHeight-tipHeight)}}else{coords.set("left",session.currentX-tipWidth-options.offset);coords.set("top",session.currentY-tipHeight-options.offset)}}tipElement.css(coords)}}function positionTipOnElement(element){var priorityList,finalPlacement;if(options.smartPlacement||options.followMouse&&element.data(DATA_FORCEDOPEN)){priorityList=$.fn.powerTip.smartPlacementLists[options.placement];$.each(priorityList,function(idx,pos){var collisions=getViewportCollisions(placeTooltip(element,pos),tipElement.outerWidth(),tipElement.outerHeight());finalPlacement=pos;return collisions!==Collision.none})}else{placeTooltip(element,options.placement);finalPlacement=options.placement}tipElement.removeClass("w nw sw e ne se n s w se-alt sw-alt ne-alt nw-alt");tipElement.addClass(finalPlacement)}function placeTooltip(element,placement){var iterationCount=0,tipWidth,tipHeight,coords=new CSSCoordinates;coords.set("top",0);coords.set("left",0);tipElement.css(coords);do{tipWidth=tipElement.outerWidth();tipHeight=tipElement.outerHeight();coords=placementCalculator.compute(element,placement,tipWidth,tipHeight,options.offset);tipElement.css(coords)}while(++iterationCount<=5&&(tipWidth!==tipElement.outerWidth()||tipHeight!==tipElement.outerHeight()));return coords}function closeDesyncedTip(){var isDesynced=false,hasDesyncableCloseEvent=$.grep(["mouseleave","mouseout","blur","focusout"],function(eventType){return $.inArray(eventType,options.closeEvents)!==-1}).length>0;if(session.isTipOpen&&!session.isClosing&&!session.delayInProgress&&hasDesyncableCloseEvent){if(session.activeHover.data(DATA_HASACTIVEHOVER)===false||session.activeHover.is(":disabled")){isDesynced=true}else if(!isMouseOver(session.activeHover)&&!session.activeHover.is(":focus")&&!session.activeHover.data(DATA_FORCEDOPEN)){if(tipElement.data(DATA_MOUSEONTOTIP)){if(!isMouseOver(tipElement)){isDesynced=true}}else{isDesynced=true}}if(isDesynced){hideTip(session.activeHover)}}}this.showTip=beginShowTip;this.hideTip=hideTip;this.resetPosition=positionTipOnElement}function isSvgElement(element){return Boolean(window.SVGElement&&element[0]instanceof SVGElement)}function isMouseEvent(event){return Boolean(event&&$.inArray(event.type,MOUSE_EVENTS)>-1&&typeof event.pageX==="number")}function initTracking(){if(!session.mouseTrackingActive){session.mouseTrackingActive=true;getViewportDimensions();$(getViewportDimensions);$document.on("mousemove"+EVENT_NAMESPACE,trackMouse);$window.on("resize"+EVENT_NAMESPACE,trackResize);$window.on("scroll"+EVENT_NAMESPACE,trackScroll)}}function getViewportDimensions(){session.scrollLeft=$window.scrollLeft();session.scrollTop=$window.scrollTop();session.windowWidth=$window.width();session.windowHeight=$window.height()}function trackResize(){session.windowWidth=$window.width();session.windowHeight=$window.height()}function trackScroll(){var x=$window.scrollLeft(),y=$window.scrollTop();if(x!==session.scrollLeft){session.currentX+=x-session.scrollLeft;session.scrollLeft=x}if(y!==session.scrollTop){session.currentY+=y-session.scrollTop;session.scrollTop=y}}function trackMouse(event){session.currentX=event.pageX;session.currentY=event.pageY}function isMouseOver(element){var elementPosition=element.offset(),elementBox=element[0].getBoundingClientRect(),elementWidth=elementBox.right-elementBox.left,elementHeight=elementBox.bottom-elementBox.top;return session.currentX>=elementPosition.left&&session.currentX<=elementPosition.left+elementWidth&&session.currentY>=elementPosition.top&&session.currentY<=elementPosition.top+elementHeight}function getTooltipContent(element){var tipText=element.data(DATA_POWERTIP),tipObject=element.data(DATA_POWERTIPJQ),tipTarget=element.data(DATA_POWERTIPTARGET),targetElement,content;if(tipText){if($.isFunction(tipText)){tipText=tipText.call(element[0])}content=tipText}else if(tipObject){if($.isFunction(tipObject)){tipObject=tipObject.call(element[0])}if(tipObject.length>0){content=tipObject.clone(true,true)}}else if(tipTarget){targetElement=$("#"+tipTarget);if(targetElement.length>0){content=targetElement.html()}}return content}function getViewportCollisions(coords,elementWidth,elementHeight){var viewportTop=session.scrollTop,viewportLeft=session.scrollLeft,viewportBottom=viewportTop+session.windowHeight,viewportRight=viewportLeft+session.windowWidth,collisions=Collision.none;if(coords.top<viewportTop||Math.abs(coords.bottom-session.windowHeight)-elementHeight<viewportTop){collisions|=Collision.top}if(coords.top+elementHeight>viewportBottom||Math.abs(coords.bottom-session.windowHeight)>viewportBottom){collisions|=Collision.bottom}if(coords.left<viewportLeft||coords.right+elementWidth>viewportRight){collisions|=Collision.left}if(coords.left+elementWidth>viewportRight||coords.right<viewportLeft){collisions|=Collision.right}return collisions}function countFlags(value){var count=0;while(value){value&=value-1;count++}return count}return $.powerTip});/*!
+ * jQuery UI Touch Punch 0.2.3
+ *
+ * Copyright 2011–2014, Dave Furfero
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ *
+ * Depends:
+ *  jquery.ui.widget.js
+ *  jquery.ui.mouse.js
+ */
+!function(a){function f(a,b){if(!(a.originalEvent.touches.length>1)){a.preventDefault();var c=a.originalEvent.changedTouches[0],d=document.createEvent("MouseEvents");d.initMouseEvent(b,!0,!0,window,1,c.screenX,c.screenY,c.clientX,c.clientY,!1,!1,!1,!1,0,null),a.target.dispatchEvent(d)}}if(a.support.touch="ontouchend"in document,a.support.touch){var e,b=a.ui.mouse.prototype,c=b._mouseInit,d=b._mouseDestroy;b._touchStart=function(a){var b=this;!e&&b._mouseCapture(a.originalEvent.changedTouches[0])&&(e=!0,b._touchMoved=!1,f(a,"mouseover"),f(a,"mousemove"),f(a,"mousedown"))},b._touchMove=function(a){e&&(this._touchMoved=!0,f(a,"mousemove"))},b._touchEnd=function(a){e&&(f(a,"mouseup"),f(a,"mouseout"),this._touchMoved||f(a,"click"),e=!1)},b._mouseInit=function(){var b=this;b.element.bind({touchstart:a.proxy(b,"_touchStart"),touchmove:a.proxy(b,"_touchMove"),touchend:a.proxy(b,"_touchEnd")}),c.call(b)},b._mouseDestroy=function(){var b=this;b.element.unbind({touchstart:a.proxy(b,"_touchStart"),touchmove:a.proxy(b,"_touchMove"),touchend:a.proxy(b,"_touchEnd")}),d.call(b)}}}(jQuery);/*! SmartMenus jQuery Plugin - v1.1.0 - September 17, 2017
+ * http://www.smartmenus.org/
+ * Copyright Vasil Dinkov, Vadikom Web Ltd. http://vadikom.com; Licensed MIT */(function(t){"function"==typeof define&&define.amd?define(["jquery"],t):"object"==typeof module&&"object"==typeof module.exports?module.exports=t(require("jquery")):t(jQuery)})(function($){function initMouseDetection(t){var e=".smartmenus_mouse";if(mouseDetectionEnabled||t)mouseDetectionEnabled&&t&&($(document).off(e),mouseDetectionEnabled=!1);else{var i=!0,s=null,o={mousemove:function(t){var e={x:t.pageX,y:t.pageY,timeStamp:(new Date).getTime()};if(s){var o=Math.abs(s.x-e.x),a=Math.abs(s.y-e.y);if((o>0||a>0)&&2>=o&&2>=a&&300>=e.timeStamp-s.timeStamp&&(mouse=!0,i)){var n=$(t.target).closest("a");n.is("a")&&$.each(menuTrees,function(){return $.contains(this.$root[0],n[0])?(this.itemEnter({currentTarget:n[0]}),!1):void 0}),i=!1}}s=e}};o[touchEvents?"touchstart":"pointerover pointermove pointerout MSPointerOver MSPointerMove MSPointerOut"]=function(t){isTouchEvent(t.originalEvent)&&(mouse=!1)},$(document).on(getEventsNS(o,e)),mouseDetectionEnabled=!0}}function isTouchEvent(t){return!/^(4|mouse)$/.test(t.pointerType)}function getEventsNS(t,e){e||(e="");var i={};for(var s in t)i[s.split(" ").join(e+" ")+e]=t[s];return i}var menuTrees=[],mouse=!1,touchEvents="ontouchstart"in window,mouseDetectionEnabled=!1,requestAnimationFrame=window.requestAnimationFrame||function(t){return setTimeout(t,1e3/60)},cancelAnimationFrame=window.cancelAnimationFrame||function(t){clearTimeout(t)},canAnimate=!!$.fn.animate;return $.SmartMenus=function(t,e){this.$root=$(t),this.opts=e,this.rootId="",this.accessIdPrefix="",this.$subArrow=null,this.activatedItems=[],this.visibleSubMenus=[],this.showTimeout=0,this.hideTimeout=0,this.scrollTimeout=0,this.clickActivated=!1,this.focusActivated=!1,this.zIndexInc=0,this.idInc=0,this.$firstLink=null,this.$firstSub=null,this.disabled=!1,this.$disableOverlay=null,this.$touchScrollingSub=null,this.cssTransforms3d="perspective"in t.style||"webkitPerspective"in t.style,this.wasCollapsible=!1,this.init()},$.extend($.SmartMenus,{hideAll:function(){$.each(menuTrees,function(){this.menuHideAll()})},destroy:function(){for(;menuTrees.length;)menuTrees[0].destroy();initMouseDetection(!0)},prototype:{init:function(t){var e=this;if(!t){menuTrees.push(this),this.rootId=((new Date).getTime()+Math.random()+"").replace(/\D/g,""),this.accessIdPrefix="sm-"+this.rootId+"-",this.$root.hasClass("sm-rtl")&&(this.opts.rightToLeftSubMenus=!0);var i=".smartmenus";this.$root.data("smartmenus",this).attr("data-smartmenus-id",this.rootId).dataSM("level",1).on(getEventsNS({"mouseover focusin":$.proxy(this.rootOver,this),"mouseout focusout":$.proxy(this.rootOut,this),keydown:$.proxy(this.rootKeyDown,this)},i)).on(getEventsNS({mouseenter:$.proxy(this.itemEnter,this),mouseleave:$.proxy(this.itemLeave,this),mousedown:$.proxy(this.itemDown,this),focus:$.proxy(this.itemFocus,this),blur:$.proxy(this.itemBlur,this),click:$.proxy(this.itemClick,this)},i),"a"),i+=this.rootId,this.opts.hideOnClick&&$(document).on(getEventsNS({touchstart:$.proxy(this.docTouchStart,this),touchmove:$.proxy(this.docTouchMove,this),touchend:$.proxy(this.docTouchEnd,this),click:$.proxy(this.docClick,this)},i)),$(window).on(getEventsNS({"resize orientationchange":$.proxy(this.winResize,this)},i)),this.opts.subIndicators&&(this.$subArrow=$("<span/>").addClass("sub-arrow"),this.opts.subIndicatorsText&&this.$subArrow.html(this.opts.subIndicatorsText)),initMouseDetection()}if(this.$firstSub=this.$root.find("ul").each(function(){e.menuInit($(this))}).eq(0),this.$firstLink=this.$root.find("a").eq(0),this.opts.markCurrentItem){var s=/(index|default)\.[^#\?\/]*/i,o=/#.*/,a=window.location.href.replace(s,""),n=a.replace(o,"");this.$root.find("a").each(function(){var t=this.href.replace(s,""),i=$(this);(t==a||t==n)&&(i.addClass("current"),e.opts.markCurrentTree&&i.parentsUntil("[data-smartmenus-id]","ul").each(function(){$(this).dataSM("parent-a").addClass("current")}))})}this.wasCollapsible=this.isCollapsible()},destroy:function(t){if(!t){var e=".smartmenus";this.$root.removeData("smartmenus").removeAttr("data-smartmenus-id").removeDataSM("level").off(e),e+=this.rootId,$(document).off(e),$(window).off(e),this.opts.subIndicators&&(this.$subArrow=null)}this.menuHideAll();var i=this;this.$root.find("ul").each(function(){var t=$(this);t.dataSM("scroll-arrows")&&t.dataSM("scroll-arrows").remove(),t.dataSM("shown-before")&&((i.opts.subMenusMinWidth||i.opts.subMenusMaxWidth)&&t.css({width:"",minWidth:"",maxWidth:""}).removeClass("sm-nowrap"),t.dataSM("scroll-arrows")&&t.dataSM("scroll-arrows").remove(),t.css({zIndex:"",top:"",left:"",marginLeft:"",marginTop:"",display:""})),0==(t.attr("id")||"").indexOf(i.accessIdPrefix)&&t.removeAttr("id")}).removeDataSM("in-mega").removeDataSM("shown-before").removeDataSM("scroll-arrows").removeDataSM("parent-a").removeDataSM("level").removeDataSM("beforefirstshowfired").removeAttr("role").removeAttr("aria-hidden").removeAttr("aria-labelledby").removeAttr("aria-expanded"),this.$root.find("a.has-submenu").each(function(){var t=$(this);0==t.attr("id").indexOf(i.accessIdPrefix)&&t.removeAttr("id")}).removeClass("has-submenu").removeDataSM("sub").removeAttr("aria-haspopup").removeAttr("aria-controls").removeAttr("aria-expanded").closest("li").removeDataSM("sub"),this.opts.subIndicators&&this.$root.find("span.sub-arrow").remove(),this.opts.markCurrentItem&&this.$root.find("a.current").removeClass("current"),t||(this.$root=null,this.$firstLink=null,this.$firstSub=null,this.$disableOverlay&&(this.$disableOverlay.remove(),this.$disableOverlay=null),menuTrees.splice($.inArray(this,menuTrees),1))},disable:function(t){if(!this.disabled){if(this.menuHideAll(),!t&&!this.opts.isPopup&&this.$root.is(":visible")){var e=this.$root.offset();this.$disableOverlay=$('<div class="sm-jquery-disable-overlay"/>').css({position:"absolute",top:e.top,left:e.left,width:this.$root.outerWidth(),height:this.$root.outerHeight(),zIndex:this.getStartZIndex(!0),opacity:0}).appendTo(document.body)}this.disabled=!0}},docClick:function(t){return this.$touchScrollingSub?(this.$touchScrollingSub=null,void 0):((this.visibleSubMenus.length&&!$.contains(this.$root[0],t.target)||$(t.target).closest("a").length)&&this.menuHideAll(),void 0)},docTouchEnd:function(){if(this.lastTouch){if(!(!this.visibleSubMenus.length||void 0!==this.lastTouch.x2&&this.lastTouch.x1!=this.lastTouch.x2||void 0!==this.lastTouch.y2&&this.lastTouch.y1!=this.lastTouch.y2||this.lastTouch.target&&$.contains(this.$root[0],this.lastTouch.target))){this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0);var t=this;this.hideTimeout=setTimeout(function(){t.menuHideAll()},350)}this.lastTouch=null}},docTouchMove:function(t){if(this.lastTouch){var e=t.originalEvent.touches[0];this.lastTouch.x2=e.pageX,this.lastTouch.y2=e.pageY}},docTouchStart:function(t){var e=t.originalEvent.touches[0];this.lastTouch={x1:e.pageX,y1:e.pageY,target:e.target}},enable:function(){this.disabled&&(this.$disableOverlay&&(this.$disableOverlay.remove(),this.$disableOverlay=null),this.disabled=!1)},getClosestMenu:function(t){for(var e=$(t).closest("ul");e.dataSM("in-mega");)e=e.parent().closest("ul");return e[0]||null},getHeight:function(t){return this.getOffset(t,!0)},getOffset:function(t,e){var i;"none"==t.css("display")&&(i={position:t[0].style.position,visibility:t[0].style.visibility},t.css({position:"absolute",visibility:"hidden"}).show());var s=t[0].getBoundingClientRect&&t[0].getBoundingClientRect(),o=s&&(e?s.height||s.bottom-s.top:s.width||s.right-s.left);return o||0===o||(o=e?t[0].offsetHeight:t[0].offsetWidth),i&&t.hide().css(i),o},getStartZIndex:function(t){var e=parseInt(this[t?"$root":"$firstSub"].css("z-index"));return!t&&isNaN(e)&&(e=parseInt(this.$root.css("z-index"))),isNaN(e)?1:e},getTouchPoint:function(t){return t.touches&&t.touches[0]||t.changedTouches&&t.changedTouches[0]||t},getViewport:function(t){var e=t?"Height":"Width",i=document.documentElement["client"+e],s=window["inner"+e];return s&&(i=Math.min(i,s)),i},getViewportHeight:function(){return this.getViewport(!0)},getViewportWidth:function(){return this.getViewport()},getWidth:function(t){return this.getOffset(t)},handleEvents:function(){return!this.disabled&&this.isCSSOn()},handleItemEvents:function(t){return this.handleEvents()&&!this.isLinkInMegaMenu(t)},isCollapsible:function(){return"static"==this.$firstSub.css("position")},isCSSOn:function(){return"inline"!=this.$firstLink.css("display")},isFixed:function(){var t="fixed"==this.$root.css("position");return t||this.$root.parentsUntil("body").each(function(){return"fixed"==$(this).css("position")?(t=!0,!1):void 0}),t},isLinkInMegaMenu:function(t){return $(this.getClosestMenu(t[0])).hasClass("mega-menu")},isTouchMode:function(){return!mouse||this.opts.noMouseOver||this.isCollapsible()},itemActivate:function(t,e){var i=t.closest("ul"),s=i.dataSM("level");if(s>1&&(!this.activatedItems[s-2]||this.activatedItems[s-2][0]!=i.dataSM("parent-a")[0])){var o=this;$(i.parentsUntil("[data-smartmenus-id]","ul").get().reverse()).add(i).each(function(){o.itemActivate($(this).dataSM("parent-a"))})}if((!this.isCollapsible()||e)&&this.menuHideSubMenus(this.activatedItems[s-1]&&this.activatedItems[s-1][0]==t[0]?s:s-1),this.activatedItems[s-1]=t,this.$root.triggerHandler("activate.smapi",t[0])!==!1){var a=t.dataSM("sub");a&&(this.isTouchMode()||!this.opts.showOnClick||this.clickActivated)&&this.menuShow(a)}},itemBlur:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&this.$root.triggerHandler("blur.smapi",e[0])},itemClick:function(t){var e=$(t.currentTarget);if(this.handleItemEvents(e)){if(this.$touchScrollingSub&&this.$touchScrollingSub[0]==e.closest("ul")[0])return this.$touchScrollingSub=null,t.stopPropagation(),!1;if(this.$root.triggerHandler("click.smapi",e[0])===!1)return!1;var i=$(t.target).is(".sub-arrow"),s=e.dataSM("sub"),o=s?2==s.dataSM("level"):!1,a=this.isCollapsible(),n=/toggle$/.test(this.opts.collapsibleBehavior),r=/link$/.test(this.opts.collapsibleBehavior),h=/^accordion/.test(this.opts.collapsibleBehavior);if(s&&!s.is(":visible")){if((!r||!a||i)&&(this.opts.showOnClick&&o&&(this.clickActivated=!0),this.itemActivate(e,h),s.is(":visible")))return this.focusActivated=!0,!1}else if(a&&(n||i))return this.itemActivate(e,h),this.menuHide(s),n&&(this.focusActivated=!1),!1;return this.opts.showOnClick&&o||e.hasClass("disabled")||this.$root.triggerHandler("select.smapi",e[0])===!1?!1:void 0}},itemDown:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&e.dataSM("mousedown",!0)},itemEnter:function(t){var e=$(t.currentTarget);if(this.handleItemEvents(e)){if(!this.isTouchMode()){this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0);var i=this;this.showTimeout=setTimeout(function(){i.itemActivate(e)},this.opts.showOnClick&&1==e.closest("ul").dataSM("level")?1:this.opts.showTimeout)}this.$root.triggerHandler("mouseenter.smapi",e[0])}},itemFocus:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&(!this.focusActivated||this.isTouchMode()&&e.dataSM("mousedown")||this.activatedItems.length&&this.activatedItems[this.activatedItems.length-1][0]==e[0]||this.itemActivate(e,!0),this.$root.triggerHandler("focus.smapi",e[0]))},itemLeave:function(t){var e=$(t.currentTarget);this.handleItemEvents(e)&&(this.isTouchMode()||(e[0].blur(),this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0)),e.removeDataSM("mousedown"),this.$root.triggerHandler("mouseleave.smapi",e[0]))},menuHide:function(t){if(this.$root.triggerHandler("beforehide.smapi",t[0])!==!1&&(canAnimate&&t.stop(!0,!0),"none"!=t.css("display"))){var e=function(){t.css("z-index","")};this.isCollapsible()?canAnimate&&this.opts.collapsibleHideFunction?this.opts.collapsibleHideFunction.call(this,t,e):t.hide(this.opts.collapsibleHideDuration,e):canAnimate&&this.opts.hideFunction?this.opts.hideFunction.call(this,t,e):t.hide(this.opts.hideDuration,e),t.dataSM("scroll")&&(this.menuScrollStop(t),t.css({"touch-action":"","-ms-touch-action":"","-webkit-transform":"",transform:""}).off(".smartmenus_scroll").removeDataSM("scroll").dataSM("scroll-arrows").hide()),t.dataSM("parent-a").removeClass("highlighted").attr("aria-expanded","false"),t.attr({"aria-expanded":"false","aria-hidden":"true"});var i=t.dataSM("level");this.activatedItems.splice(i-1,1),this.visibleSubMenus.splice($.inArray(t,this.visibleSubMenus),1),this.$root.triggerHandler("hide.smapi",t[0])}},menuHideAll:function(){this.showTimeout&&(clearTimeout(this.showTimeout),this.showTimeout=0);for(var t=this.opts.isPopup?1:0,e=this.visibleSubMenus.length-1;e>=t;e--)this.menuHide(this.visibleSubMenus[e]);this.opts.isPopup&&(canAnimate&&this.$root.stop(!0,!0),this.$root.is(":visible")&&(canAnimate&&this.opts.hideFunction?this.opts.hideFunction.call(this,this.$root):this.$root.hide(this.opts.hideDuration))),this.activatedItems=[],this.visibleSubMenus=[],this.clickActivated=!1,this.focusActivated=!1,this.zIndexInc=0,this.$root.triggerHandler("hideAll.smapi")},menuHideSubMenus:function(t){for(var e=this.activatedItems.length-1;e>=t;e--){var i=this.activatedItems[e].dataSM("sub");i&&this.menuHide(i)}},menuInit:function(t){if(!t.dataSM("in-mega")){t.hasClass("mega-menu")&&t.find("ul").dataSM("in-mega",!0);for(var e=2,i=t[0];(i=i.parentNode.parentNode)!=this.$root[0];)e++;var s=t.prevAll("a").eq(-1);s.length||(s=t.prevAll().find("a").eq(-1)),s.addClass("has-submenu").dataSM("sub",t),t.dataSM("parent-a",s).dataSM("level",e).parent().dataSM("sub",t);var o=s.attr("id")||this.accessIdPrefix+ ++this.idInc,a=t.attr("id")||this.accessIdPrefix+ ++this.idInc;s.attr({id:o,"aria-haspopup":"true","aria-controls":a,"aria-expanded":"false"}),t.attr({id:a,role:"group","aria-hidden":"true","aria-labelledby":o,"aria-expanded":"false"}),this.opts.subIndicators&&s[this.opts.subIndicatorsPos](this.$subArrow.clone())}},menuPosition:function(t){var e,i,s=t.dataSM("parent-a"),o=s.closest("li"),a=o.parent(),n=t.dataSM("level"),r=this.getWidth(t),h=this.getHeight(t),u=s.offset(),l=u.left,c=u.top,d=this.getWidth(s),m=this.getHeight(s),p=$(window),f=p.scrollLeft(),v=p.scrollTop(),b=this.getViewportWidth(),S=this.getViewportHeight(),g=a.parent().is("[data-sm-horizontal-sub]")||2==n&&!a.hasClass("sm-vertical"),M=this.opts.rightToLeftSubMenus&&!o.is("[data-sm-reverse]")||!this.opts.rightToLeftSubMenus&&o.is("[data-sm-reverse]"),w=2==n?this.opts.mainMenuSubOffsetX:this.opts.subMenusSubOffsetX,T=2==n?this.opts.mainMenuSubOffsetY:this.opts.subMenusSubOffsetY;if(g?(e=M?d-r-w:w,i=this.opts.bottomToTopSubMenus?-h-T:m+T):(e=M?w-r:d-w,i=this.opts.bottomToTopSubMenus?m-T-h:T),this.opts.keepInViewport){var y=l+e,I=c+i;if(M&&f>y?e=g?f-y+e:d-w:!M&&y+r>f+b&&(e=g?f+b-r-y+e:w-r),g||(S>h&&I+h>v+S?i+=v+S-h-I:(h>=S||v>I)&&(i+=v-I)),g&&(I+h>v+S+.49||v>I)||!g&&h>S+.49){var x=this;t.dataSM("scroll-arrows")||t.dataSM("scroll-arrows",$([$('<span class="scroll-up"><span class="scroll-up-arrow"></span></span>')[0],$('<span class="scroll-down"><span class="scroll-down-arrow"></span></span>')[0]]).on({mouseenter:function(){t.dataSM("scroll").up=$(this).hasClass("scroll-up"),x.menuScroll(t)},mouseleave:function(e){x.menuScrollStop(t),x.menuScrollOut(t,e)},"mousewheel DOMMouseScroll":function(t){t.preventDefault()}}).insertAfter(t));var A=".smartmenus_scroll";if(t.dataSM("scroll",{y:this.cssTransforms3d?0:i-m,step:1,itemH:m,subH:h,arrowDownH:this.getHeight(t.dataSM("scroll-arrows").eq(1))}).on(getEventsNS({mouseover:function(e){x.menuScrollOver(t,e)},mouseout:function(e){x.menuScrollOut(t,e)},"mousewheel DOMMouseScroll":function(e){x.menuScrollMousewheel(t,e)}},A)).dataSM("scroll-arrows").css({top:"auto",left:"0",marginLeft:e+(parseInt(t.css("border-left-width"))||0),width:r-(parseInt(t.css("border-left-width"))||0)-(parseInt(t.css("border-right-width"))||0),zIndex:t.css("z-index")}).eq(g&&this.opts.bottomToTopSubMenus?0:1).show(),this.isFixed()){var C={};C[touchEvents?"touchstart touchmove touchend":"pointerdown pointermove pointerup MSPointerDown MSPointerMove MSPointerUp"]=function(e){x.menuScrollTouch(t,e)},t.css({"touch-action":"none","-ms-touch-action":"none"}).on(getEventsNS(C,A))}}}t.css({top:"auto",left:"0",marginLeft:e,marginTop:i-m})},menuScroll:function(t,e,i){var s,o=t.dataSM("scroll"),a=t.dataSM("scroll-arrows"),n=o.up?o.upEnd:o.downEnd;if(!e&&o.momentum){if(o.momentum*=.92,s=o.momentum,.5>s)return this.menuScrollStop(t),void 0}else s=i||(e||!this.opts.scrollAccelerate?this.opts.scrollStep:Math.floor(o.step));var r=t.dataSM("level");if(this.activatedItems[r-1]&&this.activatedItems[r-1].dataSM("sub")&&this.activatedItems[r-1].dataSM("sub").is(":visible")&&this.menuHideSubMenus(r-1),o.y=o.up&&o.y>=n||!o.up&&n>=o.y?o.y:Math.abs(n-o.y)>s?o.y+(o.up?s:-s):n,t.css(this.cssTransforms3d?{"-webkit-transform":"translate3d(0, "+o.y+"px, 0)",transform:"translate3d(0, "+o.y+"px, 0)"}:{marginTop:o.y}),mouse&&(o.up&&o.y>o.downEnd||!o.up&&o.y<o.upEnd)&&a.eq(o.up?1:0).show(),o.y==n)mouse&&a.eq(o.up?0:1).hide(),this.menuScrollStop(t);else if(!e){this.opts.scrollAccelerate&&o.step<this.opts.scrollStep&&(o.step+=.2);var h=this;this.scrollTimeout=requestAnimationFrame(function(){h.menuScroll(t)})}},menuScrollMousewheel:function(t,e){if(this.getClosestMenu(e.target)==t[0]){e=e.originalEvent;var i=(e.wheelDelta||-e.detail)>0;t.dataSM("scroll-arrows").eq(i?0:1).is(":visible")&&(t.dataSM("scroll").up=i,this.menuScroll(t,!0))}e.preventDefault()},menuScrollOut:function(t,e){mouse&&(/^scroll-(up|down)/.test((e.relatedTarget||"").className)||(t[0]==e.relatedTarget||$.contains(t[0],e.relatedTarget))&&this.getClosestMenu(e.relatedTarget)==t[0]||t.dataSM("scroll-arrows").css("visibility","hidden"))},menuScrollOver:function(t,e){if(mouse&&!/^scroll-(up|down)/.test(e.target.className)&&this.getClosestMenu(e.target)==t[0]){this.menuScrollRefreshData(t);var i=t.dataSM("scroll"),s=$(window).scrollTop()-t.dataSM("parent-a").offset().top-i.itemH;t.dataSM("scroll-arrows").eq(0).css("margin-top",s).end().eq(1).css("margin-top",s+this.getViewportHeight()-i.arrowDownH).end().css("visibility","visible")}},menuScrollRefreshData:function(t){var e=t.dataSM("scroll"),i=$(window).scrollTop()-t.dataSM("parent-a").offset().top-e.itemH;this.cssTransforms3d&&(i=-(parseFloat(t.css("margin-top"))-i)),$.extend(e,{upEnd:i,downEnd:i+this.getViewportHeight()-e.subH})},menuScrollStop:function(t){return this.scrollTimeout?(cancelAnimationFrame(this.scrollTimeout),this.scrollTimeout=0,t.dataSM("scroll").step=1,!0):void 0},menuScrollTouch:function(t,e){if(e=e.originalEvent,isTouchEvent(e)){var i=this.getTouchPoint(e);if(this.getClosestMenu(i.target)==t[0]){var s=t.dataSM("scroll");if(/(start|down)$/i.test(e.type))this.menuScrollStop(t)?(e.preventDefault(),this.$touchScrollingSub=t):this.$touchScrollingSub=null,this.menuScrollRefreshData(t),$.extend(s,{touchStartY:i.pageY,touchStartTime:e.timeStamp});else if(/move$/i.test(e.type)){var o=void 0!==s.touchY?s.touchY:s.touchStartY;if(void 0!==o&&o!=i.pageY){this.$touchScrollingSub=t;var a=i.pageY>o;void 0!==s.up&&s.up!=a&&$.extend(s,{touchStartY:i.pageY,touchStartTime:e.timeStamp}),$.extend(s,{up:a,touchY:i.pageY}),this.menuScroll(t,!0,Math.abs(i.pageY-o))}e.preventDefault()}else void 0!==s.touchY&&((s.momentum=15*Math.pow(Math.abs(i.pageY-s.touchStartY)/(e.timeStamp-s.touchStartTime),2))&&(this.menuScrollStop(t),this.menuScroll(t),e.preventDefault()),delete s.touchY)}}},menuShow:function(t){if((t.dataSM("beforefirstshowfired")||(t.dataSM("beforefirstshowfired",!0),this.$root.triggerHandler("beforefirstshow.smapi",t[0])!==!1))&&this.$root.triggerHandler("beforeshow.smapi",t[0])!==!1&&(t.dataSM("shown-before",!0),canAnimate&&t.stop(!0,!0),!t.is(":visible"))){var e=t.dataSM("parent-a"),i=this.isCollapsible();if((this.opts.keepHighlighted||i)&&e.addClass("highlighted"),i)t.removeClass("sm-nowrap").css({zIndex:"",width:"auto",minWidth:"",maxWidth:"",top:"",left:"",marginLeft:"",marginTop:""});else{if(t.css("z-index",this.zIndexInc=(this.zIndexInc||this.getStartZIndex())+1),(this.opts.subMenusMinWidth||this.opts.subMenusMaxWidth)&&(t.css({width:"auto",minWidth:"",maxWidth:""}).addClass("sm-nowrap"),this.opts.subMenusMinWidth&&t.css("min-width",this.opts.subMenusMinWidth),this.opts.subMenusMaxWidth)){var s=this.getWidth(t);t.css("max-width",this.opts.subMenusMaxWidth),s>this.getWidth(t)&&t.removeClass("sm-nowrap").css("width",this.opts.subMenusMaxWidth)}this.menuPosition(t)}var o=function(){t.css("overflow","")};i?canAnimate&&this.opts.collapsibleShowFunction?this.opts.collapsibleShowFunction.call(this,t,o):t.show(this.opts.collapsibleShowDuration,o):canAnimate&&this.opts.showFunction?this.opts.showFunction.call(this,t,o):t.show(this.opts.showDuration,o),e.attr("aria-expanded","true"),t.attr({"aria-expanded":"true","aria-hidden":"false"}),this.visibleSubMenus.push(t),this.$root.triggerHandler("show.smapi",t[0])}},popupHide:function(t){this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0);var e=this;this.hideTimeout=setTimeout(function(){e.menuHideAll()},t?1:this.opts.hideTimeout)},popupShow:function(t,e){if(!this.opts.isPopup)return alert('SmartMenus jQuery Error:\n\nIf you want to show this menu via the "popupShow" method, set the isPopup:true option.'),void 0;if(this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0),this.$root.dataSM("shown-before",!0),canAnimate&&this.$root.stop(!0,!0),!this.$root.is(":visible")){this.$root.css({left:t,top:e});var i=this,s=function(){i.$root.css("overflow","")};canAnimate&&this.opts.showFunction?this.opts.showFunction.call(this,this.$root,s):this.$root.show(this.opts.showDuration,s),this.visibleSubMenus[0]=this.$root}},refresh:function(){this.destroy(!0),this.init(!0)},rootKeyDown:function(t){if(this.handleEvents())switch(t.keyCode){case 27:var e=this.activatedItems[0];if(e){this.menuHideAll(),e[0].focus();var i=e.dataSM("sub");i&&this.menuHide(i)}break;case 32:var s=$(t.target);if(s.is("a")&&this.handleItemEvents(s)){var i=s.dataSM("sub");i&&!i.is(":visible")&&(this.itemClick({currentTarget:t.target}),t.preventDefault())}}},rootOut:function(t){if(this.handleEvents()&&!this.isTouchMode()&&t.target!=this.$root[0]&&(this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0),!this.opts.showOnClick||!this.opts.hideOnClick)){var e=this;this.hideTimeout=setTimeout(function(){e.menuHideAll()},this.opts.hideTimeout)}},rootOver:function(t){this.handleEvents()&&!this.isTouchMode()&&t.target!=this.$root[0]&&this.hideTimeout&&(clearTimeout(this.hideTimeout),this.hideTimeout=0)},winResize:function(t){if(this.handleEvents()){if(!("onorientationchange"in window)||"orientationchange"==t.type){var e=this.isCollapsible();this.wasCollapsible&&e||(this.activatedItems.length&&this.activatedItems[this.activatedItems.length-1][0].blur(),this.menuHideAll()),this.wasCollapsible=e}}else if(this.$disableOverlay){var i=this.$root.offset();this.$disableOverlay.css({top:i.top,left:i.left,width:this.$root.outerWidth(),height:this.$root.outerHeight()})}}}}),$.fn.dataSM=function(t,e){return e?this.data(t+"_smartmenus",e):this.data(t+"_smartmenus")},$.fn.removeDataSM=function(t){return this.removeData(t+"_smartmenus")},$.fn.smartmenus=function(options){if("string"==typeof options){var args=arguments,method=options;return Array.prototype.shift.call(args),this.each(function(){var t=$(this).data("smartmenus");t&&t[method]&&t[method].apply(t,args)})}return this.each(function(){var dataOpts=$(this).data("sm-options")||null;if(dataOpts)try{dataOpts=eval("("+dataOpts+")")}catch(e){dataOpts=null,alert('ERROR\n\nSmartMenus jQuery init:\nInvalid "data-sm-options" attribute value syntax.')}new $.SmartMenus(this,$.extend({},$.fn.smartmenus.defaults,options,dataOpts))})},$.fn.smartmenus.defaults={isPopup:!1,mainMenuSubOffsetX:0,mainMenuSubOffsetY:0,subMenusSubOffsetX:0,subMenusSubOffsetY:0,subMenusMinWidth:"10em",subMenusMaxWidth:"20em",subIndicators:!0,subIndicatorsPos:"append",subIndicatorsText:"",scrollStep:30,scrollAccelerate:!0,showTimeout:250,hideTimeout:500,showDuration:0,showFunction:null,hideDuration:0,hideFunction:function(t,e){t.fadeOut(200,e)},collapsibleShowDuration:0,collapsibleShowFunction:function(t,e){t.slideDown(200,e)},collapsibleHideDuration:0,collapsibleHideFunction:function(t,e){t.slideUp(200,e)},showOnClick:!1,hideOnClick:!0,noMouseOver:!1,keepInViewport:!0,keepHighlighted:!0,markCurrentItem:!1,markCurrentTree:!0,rightToLeftSubMenus:!1,bottomToTopSubMenus:!1,collapsibleBehavior:"default"},$});
\ No newline at end of file
diff --git a/week4/softwareEng_9_4/app/html/menu.js b/week4/softwareEng_9_4/app/html/menu.js
new file mode 100644
index 00000000..433c15b8
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/menu.js
@@ -0,0 +1,50 @@
+/*
+ @licstart  The following is the entire license notice for the
+ JavaScript code in this file.
+
+ Copyright (C) 1997-2017 by Dimitri van Heesch
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+ @licend  The above is the entire license notice
+ for the JavaScript code in this file
+ */
+function initMenu(relPath,searchEnabled,serverSide,searchPage,search) {
+  function makeTree(data,relPath) {
+    var result='';
+    if ('children' in data) {
+      result+='<ul>';
+      for (var i in data.children) {
+        result+='<li><a href="'+relPath+data.children[i].url+'">'+
+                                data.children[i].text+'</a>'+
+                                makeTree(data.children[i],relPath)+'</li>';
+      }
+      result+='</ul>';
+    }
+    return result;
+  }
+
+  $('#main-nav').append(makeTree(menudata,relPath));
+  $('#main-nav').children(':first').addClass('sm sm-dox').attr('id','main-menu');
+  if (searchEnabled) {
+    if (serverSide) {
+      $('#main-menu').append('<li style="float:right"><div id="MSearchBox" class="MSearchBoxInactive"><div class="left"><form id="FSearchBox" action="'+relPath+searchPage+'" method="get"><img id="MSearchSelect" src="'+relPath+'search/mag.png" alt=""/><input type="text" id="MSearchField" name="query" value="'+search+'" size="20" accesskey="S" onfocus="searchBox.OnSearchFieldFocus(true)" onblur="searchBox.OnSearchFieldFocus(false)"></form></div><div class="right"></div></div></li>');
+    } else {
+      $('#main-menu').append('<li style="float:right"><div id="MSearchBox" class="MSearchBoxInactive"><span class="left"><img id="MSearchSelect" src="'+relPath+'search/mag_sel.png" onmouseover="return searchBox.OnSearchSelectShow()" onmouseout="return searchBox.OnSearchSelectHide()" alt=""/><input type="text" id="MSearchField" value="'+search+'" accesskey="S" onfocus="searchBox.OnSearchFieldFocus(true)" onblur="searchBox.OnSearchFieldFocus(false)" onkeyup="searchBox.OnSearchFieldChange(event)"/></span><span class="right"><a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="'+relPath+'search/close.png" alt=""/></a></span></div></li>');
+    }
+  }
+  $('#main-menu').smartmenus();
+}
+/* @license-end */
diff --git a/week4/softwareEng_9_4/app/html/menudata.js b/week4/softwareEng_9_4/app/html/menudata.js
new file mode 100644
index 00000000..0739ec14
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/menudata.js
@@ -0,0 +1,35 @@
+/*
+@licstart  The following is the entire license notice for the
+JavaScript code in this file.
+
+Copyright (C) 1997-2019 by Dimitri van Heesch
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of version 2 of the GNU General Public License as published by
+the Free Software Foundation
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+@licend  The above is the entire license notice
+for the JavaScript code in this file
+*/
+var menudata={children:[
+{text:"Main Page",url:"index.html"},
+{text:"Classes",url:"annotated.html",children:[
+{text:"Class List",url:"annotated.html"},
+{text:"Class Index",url:"classes.html"},
+{text:"Class Members",url:"functions.html",children:[
+{text:"All",url:"functions.html"},
+{text:"Functions",url:"functions_func.html"}]}]},
+{text:"Files",url:"files.html",children:[
+{text:"File List",url:"files.html"},
+{text:"File Members",url:"globals.html",children:[
+{text:"All",url:"globals.html"},
+{text:"Functions",url:"globals_func.html"}]}]}]}
diff --git a/week4/softwareEng_9_4/app/html/nav_f.png b/week4/softwareEng_9_4/app/html/nav_f.png
new file mode 100644
index 0000000000000000000000000000000000000000..72a58a529ed3a9ed6aa0c51a79cf207e026deee2
GIT binary patch
literal 153
zcmeAS@N?(olHy`uVBq!ia0vp^j6iI`!2~2XGqLUlQVE_ejv*C{Z|{2ZH7M}7UYxc)
zn!W8uqtnIQ>_<lqdB{jiFDSaaN3W^xbJMH7CDK7=Q3_$6tQ&<~Cp4L6ZEndC`8;cO
zrss?`_g+2sGU&M|cu~La_w1Rnf~7w`e!jQgteDwDLg6kW!`DinT@0SCelF{r5}E+Y
CM>z8U

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/nav_g.png b/week4/softwareEng_9_4/app/html/nav_g.png
new file mode 100644
index 0000000000000000000000000000000000000000..2093a237a94f6c83e19ec6e5fd42f7ddabdafa81
GIT binary patch
literal 95
zcmeAS@N?(olHy`uVBq!ia0vp^j6lrB!3HFm1ilyoDK$?Q$B+ufw|5PB85lU25BhtE
tr?otc=hd~V+ws&_A@j8Fiv!K<?EJwDd;c`qumW{3c)I$ztaD0e0syCC7$E=v

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/nav_h.png b/week4/softwareEng_9_4/app/html/nav_h.png
new file mode 100644
index 0000000000000000000000000000000000000000..33389b101d9cd9b4c98ad286b5d9c46a6671f650
GIT binary patch
literal 98
zcmeAS@N?(olHy`uVBq!ia0vp^j6lr8!2~3AUOE6t22D>F$B+ufw|5=67#uj90@pIL
wZ=Q8~_Ju`#59=RjDrmm`tMD@M=!-l18IR?&v<Kx}xDV3h>FVdQ&MBb@0HFXL<NyEw

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/open.png b/week4/softwareEng_9_4/app/html/open.png
new file mode 100644
index 0000000000000000000000000000000000000000..30f75c7efe2dd0c9e956e35b69777a02751f048b
GIT binary patch
literal 123
zcmeAS@N?(olHy`uVBq!ia0vp^oFL4>1|%O$WD@{VPM$7~Ar*{o?;hlAFyLXmaDC0y
znK1_#cQqJWPES%4Uujug^TE?jMft$}Eq^WaR~)%f)vSNs&gek&x%A9X9sM<Rdl=8h
W@EqZ{ytxBt8iS{+pUXO@geCxcDJg#d

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/search/all_0.html b/week4/softwareEng_9_4/app/html/search/all_0.html
new file mode 100644
index 00000000..26dd244f
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/all_0.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/search/all_0.js b/week4/softwareEng_9_4/app/html/search/all_0.js
new file mode 100644
index 00000000..049c800d
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/all_0.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['input_0',['input',['../classprinter.html#a10b05212f6167b64ebfb1b7c1cdc9ef2',1,'printer']]]
+];
diff --git a/week4/softwareEng_9_4/app/html/search/all_1.html b/week4/softwareEng_9_4/app/html/search/all_1.html
new file mode 100644
index 00000000..8eb215b9
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/all_1.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_1.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/search/all_1.js b/week4/softwareEng_9_4/app/html/search/all_1.js
new file mode 100644
index 00000000..1fec3f5b
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/all_1.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['main_1',['main',['../software_eng__9__4_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4',1,'softwareEng_9_4.cpp']]]
+];
diff --git a/week4/softwareEng_9_4/app/html/search/all_2.html b/week4/softwareEng_9_4/app/html/search/all_2.html
new file mode 100644
index 00000000..b26d9165
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/all_2.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_2.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/search/all_2.js b/week4/softwareEng_9_4/app/html/search/all_2.js
new file mode 100644
index 00000000..6a8e8acd
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/all_2.js
@@ -0,0 +1,5 @@
+var searchData=
+[
+  ['printer_2',['printer',['../classprinter.html',1,'printer'],['../classprinter.html#adfbc169c8c36ac791744c8dc01647432',1,'printer::printer()']]],
+  ['printposition_3',['printPosition',['../classprinter.html#ae7da213aa9062bea77998b0340163c17',1,'printer']]]
+];
diff --git a/week4/softwareEng_9_4/app/html/search/all_3.html b/week4/softwareEng_9_4/app/html/search/all_3.html
new file mode 100644
index 00000000..b61b96f8
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/all_3.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_3.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/search/all_3.js b/week4/softwareEng_9_4/app/html/search/all_3.js
new file mode 100644
index 00000000..b0921505
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/all_3.js
@@ -0,0 +1,5 @@
+var searchData=
+[
+  ['softwareeng_5f9_5f4_2ecpp_4',['softwareEng_9_4.cpp',['../software_eng__9__4_8cpp.html',1,'']]],
+  ['softwareeng_5f9_5f4_2ehpp_5',['softwareEng_9_4.hpp',['../software_eng__9__4_8hpp.html',1,'']]]
+];
diff --git a/week4/softwareEng_9_4/app/html/search/classes_0.html b/week4/softwareEng_9_4/app/html/search/classes_0.html
new file mode 100644
index 00000000..f7e4c14e
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/classes_0.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="classes_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/search/classes_0.js b/week4/softwareEng_9_4/app/html/search/classes_0.js
new file mode 100644
index 00000000..9205db65
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/classes_0.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['printer_6',['printer',['../classprinter.html',1,'']]]
+];
diff --git a/week4/softwareEng_9_4/app/html/search/close.png b/week4/softwareEng_9_4/app/html/search/close.png
new file mode 100644
index 0000000000000000000000000000000000000000..9342d3dfeea7b7c4ee610987e717804b5a42ceb9
GIT binary patch
literal 273
zcmV+s0q*{ZP)<h;3K|Lk000e1NJLTq000XB000XJ1^@s6sjPP<0002kNkl<Z7#Vd@
zy%I)14BQwM3KSF?L+drXf2Tud1~Vwo-gkQ=D&H2DpWDkOIl+T{-_5ct*tQMlc_NA;
z#Bq!~&yl97kminQn#?$kxUNgzzBUX)lx2ycD8xIC<1djfsKP>4(RlMby96)VwnbG{
zbe&}^BDn7x>$<{ck4zAK-=nT;=hHG)kmplIF${xqm8db3oX6wT3bvp`TE@m0cg;b)
zBuSL}5?N7O(iZLdAlz@)b)Rd~DnSsSX&P5qC`XwuFwcAYLC+d2>+1(8on;wpt8QIC
X2MT$R4iQDd00000NkvXXu0mjfia~GN

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/search/files_0.html b/week4/softwareEng_9_4/app/html/search/files_0.html
new file mode 100644
index 00000000..737608e1
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/files_0.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="files_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/search/files_0.js b/week4/softwareEng_9_4/app/html/search/files_0.js
new file mode 100644
index 00000000..45634651
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/files_0.js
@@ -0,0 +1,5 @@
+var searchData=
+[
+  ['softwareeng_5f9_5f4_2ecpp_7',['softwareEng_9_4.cpp',['../software_eng__9__4_8cpp.html',1,'']]],
+  ['softwareeng_5f9_5f4_2ehpp_8',['softwareEng_9_4.hpp',['../software_eng__9__4_8hpp.html',1,'']]]
+];
diff --git a/week4/softwareEng_9_4/app/html/search/functions_0.html b/week4/softwareEng_9_4/app/html/search/functions_0.html
new file mode 100644
index 00000000..e17c7111
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/functions_0.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="functions_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/search/functions_0.js b/week4/softwareEng_9_4/app/html/search/functions_0.js
new file mode 100644
index 00000000..c06a43e1
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/functions_0.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['input_9',['input',['../classprinter.html#a10b05212f6167b64ebfb1b7c1cdc9ef2',1,'printer']]]
+];
diff --git a/week4/softwareEng_9_4/app/html/search/functions_1.html b/week4/softwareEng_9_4/app/html/search/functions_1.html
new file mode 100644
index 00000000..0ddac0a4
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/functions_1.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="functions_1.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/search/functions_1.js b/week4/softwareEng_9_4/app/html/search/functions_1.js
new file mode 100644
index 00000000..4b88bd92
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/functions_1.js
@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['main_10',['main',['../software_eng__9__4_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4',1,'softwareEng_9_4.cpp']]]
+];
diff --git a/week4/softwareEng_9_4/app/html/search/functions_2.html b/week4/softwareEng_9_4/app/html/search/functions_2.html
new file mode 100644
index 00000000..2737c5ac
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/functions_2.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="functions_2.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/search/functions_2.js b/week4/softwareEng_9_4/app/html/search/functions_2.js
new file mode 100644
index 00000000..bf32deaa
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/functions_2.js
@@ -0,0 +1,5 @@
+var searchData=
+[
+  ['printer_11',['printer',['../classprinter.html#adfbc169c8c36ac791744c8dc01647432',1,'printer']]],
+  ['printposition_12',['printPosition',['../classprinter.html#ae7da213aa9062bea77998b0340163c17',1,'printer']]]
+];
diff --git a/week4/softwareEng_9_4/app/html/search/mag_sel.png b/week4/softwareEng_9_4/app/html/search/mag_sel.png
new file mode 100644
index 0000000000000000000000000000000000000000..39c0ed52a25dd9d080ee0d42ae6c6042bdfa04d7
GIT binary patch
literal 465
zcmeAS@N?(olHy`uVBq!ia0vp^B0wz6!2%?$TA$hhDVB6cUq=Rpjs4tz5?O(Kg=CK)
zUj~NU84L`?eGCi_EEpJ?t}-xGu`@87+QPtK?83kxQ`TapwHK(CDaqU2h2ejD|C#+j
z9%q3^WHAE+w=f7ZGR&GI0Tg5}@$_|Nf5gMiEhFgvHvB$N=!mC_V~EE2vzPXI9ZnEo
zd+<K({3L0CKXWH-3%}r+E_-Apm;5f#D#1yQ9tm7(D$~3x$L{RO>1zHor@dYLod2Y{
z@R$7$Z!PXTbY$|@#T!bMzm?`b<(R`cb<MP?hu%oYaGp0?(kq_maw@j&T661#vfeNa
z56e`=(|?b6&2UcA3%PHQYAJhwJuxRSJ5lG(M5`)}`##md?Z)$~s|?Qgy^UKLu&Y!n
zrmSSchq?T{<-JpHwHBBzXs*rGoojvZ$H!~Y-s}HeoL$Q(r@Cv?KULeqK>w(gxJHzu
zB$lLFB^RXvDF!10LknF)BV7aY5JN*NBMU1-b8Q0yD+2>vd*|CI8glbfGSez?Ylunu
RoetE%;OXk;vd$@?2>>CYplSdB

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/search/nomatches.html b/week4/softwareEng_9_4/app/html/search/nomatches.html
new file mode 100644
index 00000000..43773208
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/nomatches.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="NoMatches">No Matches</div>
+</div>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/search/search.css b/week4/softwareEng_9_4/app/html/search/search.css
new file mode 100644
index 00000000..3cf9df94
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/search.css
@@ -0,0 +1,271 @@
+/*---------------- Search Box */
+
+#FSearchBox {
+    float: left;
+}
+
+#MSearchBox {
+    white-space : nowrap;
+    float: none;
+    margin-top: 8px;
+    right: 0px;
+    width: 170px;
+    height: 24px;
+    z-index: 102;
+}
+
+#MSearchBox .left
+{
+    display:block;
+    position:absolute;
+    left:10px;
+    width:20px;
+    height:19px;
+    background:url('search_l.png') no-repeat;
+    background-position:right;
+}
+
+#MSearchSelect {
+    display:block;
+    position:absolute;
+    width:20px;
+    height:19px;
+}
+
+.left #MSearchSelect {
+    left:4px;
+}
+
+.right #MSearchSelect {
+    right:5px;
+}
+
+#MSearchField {
+    display:block;
+    position:absolute;
+    height:19px;
+    background:url('search_m.png') repeat-x;
+    border:none;
+    width:115px;
+    margin-left:20px;
+    padding-left:4px;
+    color: #909090;
+    outline: none;
+    font: 9pt Arial, Verdana, sans-serif;
+    -webkit-border-radius: 0px;
+}
+
+#FSearchBox #MSearchField {
+    margin-left:15px;
+}
+
+#MSearchBox .right {
+    display:block;
+    position:absolute;
+    right:10px;
+    top:8px;
+    width:20px;
+    height:19px;
+    background:url('search_r.png') no-repeat;
+    background-position:left;
+}
+
+#MSearchClose {
+    display: none;
+    position: absolute;
+    top: 4px;
+    background : none;
+    border: none;
+    margin: 0px 4px 0px 0px;
+    padding: 0px 0px;
+    outline: none;
+}
+
+.left #MSearchClose {
+    left: 6px;
+}
+
+.right #MSearchClose {
+    right: 2px;
+}
+
+.MSearchBoxActive #MSearchField {
+    color: #000000;
+}
+
+/*---------------- Search filter selection */
+
+#MSearchSelectWindow {
+    display: none;
+    position: absolute;
+    left: 0; top: 0;
+    border: 1px solid #90A5CE;
+    background-color: #F9FAFC;
+    z-index: 10001;
+    padding-top: 4px;
+    padding-bottom: 4px;
+    -moz-border-radius: 4px;
+    -webkit-border-top-left-radius: 4px;
+    -webkit-border-top-right-radius: 4px;
+    -webkit-border-bottom-left-radius: 4px;
+    -webkit-border-bottom-right-radius: 4px;
+    -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+}
+
+.SelectItem {
+    font: 8pt Arial, Verdana, sans-serif;
+    padding-left:  2px;
+    padding-right: 12px;
+    border: 0px;
+}
+
+span.SelectionMark {
+    margin-right: 4px;
+    font-family: monospace;
+    outline-style: none;
+    text-decoration: none;
+}
+
+a.SelectItem {
+    display: block;
+    outline-style: none;
+    color: #000000; 
+    text-decoration: none;
+    padding-left:   6px;
+    padding-right: 12px;
+}
+
+a.SelectItem:focus,
+a.SelectItem:active {
+    color: #000000; 
+    outline-style: none;
+    text-decoration: none;
+}
+
+a.SelectItem:hover {
+    color: #FFFFFF;
+    background-color: #3D578C;
+    outline-style: none;
+    text-decoration: none;
+    cursor: pointer;
+    display: block;
+}
+
+/*---------------- Search results window */
+
+iframe#MSearchResults {
+    width: 60ex;
+    height: 15em;
+}
+
+#MSearchResultsWindow {
+    display: none;
+    position: absolute;
+    left: 0; top: 0;
+    border: 1px solid #000;
+    background-color: #EEF1F7;
+    z-index:10000;
+}
+
+/* ----------------------------------- */
+
+
+#SRIndex {
+    clear:both; 
+    padding-bottom: 15px;
+}
+
+.SREntry {
+    font-size: 10pt;
+    padding-left: 1ex;
+}
+
+.SRPage .SREntry {
+    font-size: 8pt;
+    padding: 1px 5px;
+}
+
+body.SRPage {
+    margin: 5px 2px;
+}
+
+.SRChildren {
+    padding-left: 3ex; padding-bottom: .5em 
+}
+
+.SRPage .SRChildren {
+    display: none;
+}
+
+.SRSymbol {
+    font-weight: bold; 
+    color: #425E97;
+    font-family: Arial, Verdana, sans-serif;
+    text-decoration: none;
+    outline: none;
+}
+
+a.SRScope {
+    display: block;
+    color: #425E97; 
+    font-family: Arial, Verdana, sans-serif;
+    text-decoration: none;
+    outline: none;
+}
+
+a.SRSymbol:focus, a.SRSymbol:active,
+a.SRScope:focus, a.SRScope:active {
+    text-decoration: underline;
+}
+
+span.SRScope {
+    padding-left: 4px;
+}
+
+.SRPage .SRStatus {
+    padding: 2px 5px;
+    font-size: 8pt;
+    font-style: italic;
+}
+
+.SRResult {
+    display: none;
+}
+
+DIV.searchresults {
+    margin-left: 10px;
+    margin-right: 10px;
+}
+
+/*---------------- External search page results */
+
+.searchresult {
+    background-color: #F0F3F8;
+}
+
+.pages b {
+   color: white;
+   padding: 5px 5px 3px 5px;
+   background-image: url("../tab_a.png");
+   background-repeat: repeat-x;
+   text-shadow: 0 1px 1px #000000;
+}
+
+.pages {
+    line-height: 17px;
+    margin-left: 4px;
+    text-decoration: none;
+}
+
+.hl {
+    font-weight: bold;
+}
+
+#searchresults {
+    margin-bottom: 20px;
+}
+
+.searchpages {
+    margin-top: 10px;
+}
+
diff --git a/week4/softwareEng_9_4/app/html/search/search.js b/week4/softwareEng_9_4/app/html/search/search.js
new file mode 100644
index 00000000..a554ab9c
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/search.js
@@ -0,0 +1,814 @@
+/*
+ @licstart  The following is the entire license notice for the
+ JavaScript code in this file.
+
+ Copyright (C) 1997-2017 by Dimitri van Heesch
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+ @licend  The above is the entire license notice
+ for the JavaScript code in this file
+ */
+function convertToId(search)
+{
+  var result = '';
+  for (i=0;i<search.length;i++)
+  {
+    var c = search.charAt(i);
+    var cn = c.charCodeAt(0);
+    if (c.match(/[a-z0-9\u0080-\uFFFF]/))
+    {
+      result+=c;
+    }
+    else if (cn<16)
+    {
+      result+="_0"+cn.toString(16);
+    }
+    else
+    {
+      result+="_"+cn.toString(16);
+    }
+  }
+  return result;
+}
+
+function getXPos(item)
+{
+  var x = 0;
+  if (item.offsetWidth)
+  {
+    while (item && item!=document.body)
+    {
+      x   += item.offsetLeft;
+      item = item.offsetParent;
+    }
+  }
+  return x;
+}
+
+function getYPos(item)
+{
+  var y = 0;
+  if (item.offsetWidth)
+  {
+     while (item && item!=document.body)
+     {
+       y   += item.offsetTop;
+       item = item.offsetParent;
+     }
+  }
+  return y;
+}
+
+/* A class handling everything associated with the search panel.
+
+   Parameters:
+   name - The name of the global variable that will be
+          storing this instance.  Is needed to be able to set timeouts.
+   resultPath - path to use for external files
+*/
+function SearchBox(name, resultsPath, inFrame, label)
+{
+  if (!name || !resultsPath) {  alert("Missing parameters to SearchBox."); }
+
+  // ---------- Instance variables
+  this.name                  = name;
+  this.resultsPath           = resultsPath;
+  this.keyTimeout            = 0;
+  this.keyTimeoutLength      = 500;
+  this.closeSelectionTimeout = 300;
+  this.lastSearchValue       = "";
+  this.lastResultsPage       = "";
+  this.hideTimeout           = 0;
+  this.searchIndex           = 0;
+  this.searchActive          = false;
+  this.insideFrame           = inFrame;
+  this.searchLabel           = label;
+
+  // ----------- DOM Elements
+
+  this.DOMSearchField = function()
+  {  return document.getElementById("MSearchField");  }
+
+  this.DOMSearchSelect = function()
+  {  return document.getElementById("MSearchSelect");  }
+
+  this.DOMSearchSelectWindow = function()
+  {  return document.getElementById("MSearchSelectWindow");  }
+
+  this.DOMPopupSearchResults = function()
+  {  return document.getElementById("MSearchResults");  }
+
+  this.DOMPopupSearchResultsWindow = function()
+  {  return document.getElementById("MSearchResultsWindow");  }
+
+  this.DOMSearchClose = function()
+  {  return document.getElementById("MSearchClose"); }
+
+  this.DOMSearchBox = function()
+  {  return document.getElementById("MSearchBox");  }
+
+  // ------------ Event Handlers
+
+  // Called when focus is added or removed from the search field.
+  this.OnSearchFieldFocus = function(isActive)
+  {
+    this.Activate(isActive);
+  }
+
+  this.OnSearchSelectShow = function()
+  {
+    var searchSelectWindow = this.DOMSearchSelectWindow();
+    var searchField        = this.DOMSearchSelect();
+
+    if (this.insideFrame)
+    {
+      var left = getXPos(searchField);
+      var top  = getYPos(searchField);
+      left += searchField.offsetWidth + 6;
+      top += searchField.offsetHeight;
+
+      // show search selection popup
+      searchSelectWindow.style.display='block';
+      left -= searchSelectWindow.offsetWidth;
+      searchSelectWindow.style.left =  left + 'px';
+      searchSelectWindow.style.top  =  top  + 'px';
+    }
+    else
+    {
+      var left = getXPos(searchField);
+      var top  = getYPos(searchField);
+      top += searchField.offsetHeight;
+
+      // show search selection popup
+      searchSelectWindow.style.display='block';
+      searchSelectWindow.style.left =  left + 'px';
+      searchSelectWindow.style.top  =  top  + 'px';
+    }
+
+    // stop selection hide timer
+    if (this.hideTimeout)
+    {
+      clearTimeout(this.hideTimeout);
+      this.hideTimeout=0;
+    }
+    return false; // to avoid "image drag" default event
+  }
+
+  this.OnSearchSelectHide = function()
+  {
+    this.hideTimeout = setTimeout(this.name +".CloseSelectionWindow()",
+                                  this.closeSelectionTimeout);
+  }
+
+  // Called when the content of the search field is changed.
+  this.OnSearchFieldChange = function(evt)
+  {
+    if (this.keyTimeout) // kill running timer
+    {
+      clearTimeout(this.keyTimeout);
+      this.keyTimeout = 0;
+    }
+
+    var e  = (evt) ? evt : window.event; // for IE
+    if (e.keyCode==40 || e.keyCode==13)
+    {
+      if (e.shiftKey==1)
+      {
+        this.OnSearchSelectShow();
+        var win=this.DOMSearchSelectWindow();
+        for (i=0;i<win.childNodes.length;i++)
+        {
+          var child = win.childNodes[i]; // get span within a
+          if (child.className=='SelectItem')
+          {
+            child.focus();
+            return;
+          }
+        }
+        return;
+      }
+      else if (window.frames.MSearchResults.searchResults)
+      {
+        var elem = window.frames.MSearchResults.searchResults.NavNext(0);
+        if (elem) elem.focus();
+      }
+    }
+    else if (e.keyCode==27) // Escape out of the search field
+    {
+      this.DOMSearchField().blur();
+      this.DOMPopupSearchResultsWindow().style.display = 'none';
+      this.DOMSearchClose().style.display = 'none';
+      this.lastSearchValue = '';
+      this.Activate(false);
+      return;
+    }
+
+    // strip whitespaces
+    var searchValue = this.DOMSearchField().value.replace(/ +/g, "");
+
+    if (searchValue != this.lastSearchValue) // search value has changed
+    {
+      if (searchValue != "") // non-empty search
+      {
+        // set timer for search update
+        this.keyTimeout = setTimeout(this.name + '.Search()',
+                                     this.keyTimeoutLength);
+      }
+      else // empty search field
+      {
+        this.DOMPopupSearchResultsWindow().style.display = 'none';
+        this.DOMSearchClose().style.display = 'none';
+        this.lastSearchValue = '';
+      }
+    }
+  }
+
+  this.SelectItemCount = function(id)
+  {
+    var count=0;
+    var win=this.DOMSearchSelectWindow();
+    for (i=0;i<win.childNodes.length;i++)
+    {
+      var child = win.childNodes[i]; // get span within a
+      if (child.className=='SelectItem')
+      {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  this.SelectItemSet = function(id)
+  {
+    var i,j=0;
+    var win=this.DOMSearchSelectWindow();
+    for (i=0;i<win.childNodes.length;i++)
+    {
+      var child = win.childNodes[i]; // get span within a
+      if (child.className=='SelectItem')
+      {
+        var node = child.firstChild;
+        if (j==id)
+        {
+          node.innerHTML='&#8226;';
+        }
+        else
+        {
+          node.innerHTML='&#160;';
+        }
+        j++;
+      }
+    }
+  }
+
+  // Called when an search filter selection is made.
+  // set item with index id as the active item
+  this.OnSelectItem = function(id)
+  {
+    this.searchIndex = id;
+    this.SelectItemSet(id);
+    var searchValue = this.DOMSearchField().value.replace(/ +/g, "");
+    if (searchValue!="" && this.searchActive) // something was found -> do a search
+    {
+      this.Search();
+    }
+  }
+
+  this.OnSearchSelectKey = function(evt)
+  {
+    var e = (evt) ? evt : window.event; // for IE
+    if (e.keyCode==40 && this.searchIndex<this.SelectItemCount()) // Down
+    {
+      this.searchIndex++;
+      this.OnSelectItem(this.searchIndex);
+    }
+    else if (e.keyCode==38 && this.searchIndex>0) // Up
+    {
+      this.searchIndex--;
+      this.OnSelectItem(this.searchIndex);
+    }
+    else if (e.keyCode==13 || e.keyCode==27)
+    {
+      this.OnSelectItem(this.searchIndex);
+      this.CloseSelectionWindow();
+      this.DOMSearchField().focus();
+    }
+    return false;
+  }
+
+  // --------- Actions
+
+  // Closes the results window.
+  this.CloseResultsWindow = function()
+  {
+    this.DOMPopupSearchResultsWindow().style.display = 'none';
+    this.DOMSearchClose().style.display = 'none';
+    this.Activate(false);
+  }
+
+  this.CloseSelectionWindow = function()
+  {
+    this.DOMSearchSelectWindow().style.display = 'none';
+  }
+
+  // Performs a search.
+  this.Search = function()
+  {
+    this.keyTimeout = 0;
+
+    // strip leading whitespace
+    var searchValue = this.DOMSearchField().value.replace(/^ +/, "");
+
+    var code = searchValue.toLowerCase().charCodeAt(0);
+    var idxChar = searchValue.substr(0, 1).toLowerCase();
+    if ( 0xD800 <= code && code <= 0xDBFF && searchValue > 1) // surrogate pair
+    {
+      idxChar = searchValue.substr(0, 2);
+    }
+
+    var resultsPage;
+    var resultsPageWithSearch;
+    var hasResultsPage;
+
+    var idx = indexSectionsWithContent[this.searchIndex].indexOf(idxChar);
+    if (idx!=-1)
+    {
+       var hexCode=idx.toString(16);
+       resultsPage = this.resultsPath + '/' + indexSectionNames[this.searchIndex] + '_' + hexCode + '.html';
+       resultsPageWithSearch = resultsPage+'?'+escape(searchValue);
+       hasResultsPage = true;
+    }
+    else // nothing available for this search term
+    {
+       resultsPage = this.resultsPath + '/nomatches.html';
+       resultsPageWithSearch = resultsPage;
+       hasResultsPage = false;
+    }
+
+    window.frames.MSearchResults.location = resultsPageWithSearch;
+    var domPopupSearchResultsWindow = this.DOMPopupSearchResultsWindow();
+
+    if (domPopupSearchResultsWindow.style.display!='block')
+    {
+       var domSearchBox = this.DOMSearchBox();
+       this.DOMSearchClose().style.display = 'inline';
+       if (this.insideFrame)
+       {
+         var domPopupSearchResults = this.DOMPopupSearchResults();
+         domPopupSearchResultsWindow.style.position = 'relative';
+         domPopupSearchResultsWindow.style.display  = 'block';
+         var width = document.body.clientWidth - 8; // the -8 is for IE :-(
+         domPopupSearchResultsWindow.style.width    = width + 'px';
+         domPopupSearchResults.style.width          = width + 'px';
+       }
+       else
+       {
+         var domPopupSearchResults = this.DOMPopupSearchResults();
+         var left = getXPos(domSearchBox) + 150; // domSearchBox.offsetWidth;
+         var top  = getYPos(domSearchBox) + 20;  // domSearchBox.offsetHeight + 1;
+         domPopupSearchResultsWindow.style.display = 'block';
+         left -= domPopupSearchResults.offsetWidth;
+         domPopupSearchResultsWindow.style.top     = top  + 'px';
+         domPopupSearchResultsWindow.style.left    = left + 'px';
+       }
+    }
+
+    this.lastSearchValue = searchValue;
+    this.lastResultsPage = resultsPage;
+  }
+
+  // -------- Activation Functions
+
+  // Activates or deactivates the search panel, resetting things to
+  // their default values if necessary.
+  this.Activate = function(isActive)
+  {
+    if (isActive || // open it
+        this.DOMPopupSearchResultsWindow().style.display == 'block'
+       )
+    {
+      this.DOMSearchBox().className = 'MSearchBoxActive';
+
+      var searchField = this.DOMSearchField();
+
+      if (searchField.value == this.searchLabel) // clear "Search" term upon entry
+      {
+        searchField.value = '';
+        this.searchActive = true;
+      }
+    }
+    else if (!isActive) // directly remove the panel
+    {
+      this.DOMSearchBox().className = 'MSearchBoxInactive';
+      this.DOMSearchField().value   = this.searchLabel;
+      this.searchActive             = false;
+      this.lastSearchValue          = ''
+      this.lastResultsPage          = '';
+    }
+  }
+}
+
+// -----------------------------------------------------------------------
+
+// The class that handles everything on the search results page.
+function SearchResults(name)
+{
+    // The number of matches from the last run of <Search()>.
+    this.lastMatchCount = 0;
+    this.lastKey = 0;
+    this.repeatOn = false;
+
+    // Toggles the visibility of the passed element ID.
+    this.FindChildElement = function(id)
+    {
+      var parentElement = document.getElementById(id);
+      var element = parentElement.firstChild;
+
+      while (element && element!=parentElement)
+      {
+        if (element.nodeName == 'DIV' && element.className == 'SRChildren')
+        {
+          return element;
+        }
+
+        if (element.nodeName == 'DIV' && element.hasChildNodes())
+        {
+           element = element.firstChild;
+        }
+        else if (element.nextSibling)
+        {
+           element = element.nextSibling;
+        }
+        else
+        {
+          do
+          {
+            element = element.parentNode;
+          }
+          while (element && element!=parentElement && !element.nextSibling);
+
+          if (element && element!=parentElement)
+          {
+            element = element.nextSibling;
+          }
+        }
+      }
+    }
+
+    this.Toggle = function(id)
+    {
+      var element = this.FindChildElement(id);
+      if (element)
+      {
+        if (element.style.display == 'block')
+        {
+          element.style.display = 'none';
+        }
+        else
+        {
+          element.style.display = 'block';
+        }
+      }
+    }
+
+    // Searches for the passed string.  If there is no parameter,
+    // it takes it from the URL query.
+    //
+    // Always returns true, since other documents may try to call it
+    // and that may or may not be possible.
+    this.Search = function(search)
+    {
+      if (!search) // get search word from URL
+      {
+        search = window.location.search;
+        search = search.substring(1);  // Remove the leading '?'
+        search = unescape(search);
+      }
+
+      search = search.replace(/^ +/, ""); // strip leading spaces
+      search = search.replace(/ +$/, ""); // strip trailing spaces
+      search = search.toLowerCase();
+      search = convertToId(search);
+
+      var resultRows = document.getElementsByTagName("div");
+      var matches = 0;
+
+      var i = 0;
+      while (i < resultRows.length)
+      {
+        var row = resultRows.item(i);
+        if (row.className == "SRResult")
+        {
+          var rowMatchName = row.id.toLowerCase();
+          rowMatchName = rowMatchName.replace(/^sr\d*_/, ''); // strip 'sr123_'
+
+          if (search.length<=rowMatchName.length &&
+             rowMatchName.substr(0, search.length)==search)
+          {
+            row.style.display = 'block';
+            matches++;
+          }
+          else
+          {
+            row.style.display = 'none';
+          }
+        }
+        i++;
+      }
+      document.getElementById("Searching").style.display='none';
+      if (matches == 0) // no results
+      {
+        document.getElementById("NoMatches").style.display='block';
+      }
+      else // at least one result
+      {
+        document.getElementById("NoMatches").style.display='none';
+      }
+      this.lastMatchCount = matches;
+      return true;
+    }
+
+    // return the first item with index index or higher that is visible
+    this.NavNext = function(index)
+    {
+      var focusItem;
+      while (1)
+      {
+        var focusName = 'Item'+index;
+        focusItem = document.getElementById(focusName);
+        if (focusItem && focusItem.parentNode.parentNode.style.display=='block')
+        {
+          break;
+        }
+        else if (!focusItem) // last element
+        {
+          break;
+        }
+        focusItem=null;
+        index++;
+      }
+      return focusItem;
+    }
+
+    this.NavPrev = function(index)
+    {
+      var focusItem;
+      while (1)
+      {
+        var focusName = 'Item'+index;
+        focusItem = document.getElementById(focusName);
+        if (focusItem && focusItem.parentNode.parentNode.style.display=='block')
+        {
+          break;
+        }
+        else if (!focusItem) // last element
+        {
+          break;
+        }
+        focusItem=null;
+        index--;
+      }
+      return focusItem;
+    }
+
+    this.ProcessKeys = function(e)
+    {
+      if (e.type == "keydown")
+      {
+        this.repeatOn = false;
+        this.lastKey = e.keyCode;
+      }
+      else if (e.type == "keypress")
+      {
+        if (!this.repeatOn)
+        {
+          if (this.lastKey) this.repeatOn = true;
+          return false; // ignore first keypress after keydown
+        }
+      }
+      else if (e.type == "keyup")
+      {
+        this.lastKey = 0;
+        this.repeatOn = false;
+      }
+      return this.lastKey!=0;
+    }
+
+    this.Nav = function(evt,itemIndex)
+    {
+      var e  = (evt) ? evt : window.event; // for IE
+      if (e.keyCode==13) return true;
+      if (!this.ProcessKeys(e)) return false;
+
+      if (this.lastKey==38) // Up
+      {
+        var newIndex = itemIndex-1;
+        var focusItem = this.NavPrev(newIndex);
+        if (focusItem)
+        {
+          var child = this.FindChildElement(focusItem.parentNode.parentNode.id);
+          if (child && child.style.display == 'block') // children visible
+          {
+            var n=0;
+            var tmpElem;
+            while (1) // search for last child
+            {
+              tmpElem = document.getElementById('Item'+newIndex+'_c'+n);
+              if (tmpElem)
+              {
+                focusItem = tmpElem;
+              }
+              else // found it!
+              {
+                break;
+              }
+              n++;
+            }
+          }
+        }
+        if (focusItem)
+        {
+          focusItem.focus();
+        }
+        else // return focus to search field
+        {
+           parent.document.getElementById("MSearchField").focus();
+        }
+      }
+      else if (this.lastKey==40) // Down
+      {
+        var newIndex = itemIndex+1;
+        var focusItem;
+        var item = document.getElementById('Item'+itemIndex);
+        var elem = this.FindChildElement(item.parentNode.parentNode.id);
+        if (elem && elem.style.display == 'block') // children visible
+        {
+          focusItem = document.getElementById('Item'+itemIndex+'_c0');
+        }
+        if (!focusItem) focusItem = this.NavNext(newIndex);
+        if (focusItem)  focusItem.focus();
+      }
+      else if (this.lastKey==39) // Right
+      {
+        var item = document.getElementById('Item'+itemIndex);
+        var elem = this.FindChildElement(item.parentNode.parentNode.id);
+        if (elem) elem.style.display = 'block';
+      }
+      else if (this.lastKey==37) // Left
+      {
+        var item = document.getElementById('Item'+itemIndex);
+        var elem = this.FindChildElement(item.parentNode.parentNode.id);
+        if (elem) elem.style.display = 'none';
+      }
+      else if (this.lastKey==27) // Escape
+      {
+        parent.searchBox.CloseResultsWindow();
+        parent.document.getElementById("MSearchField").focus();
+      }
+      else if (this.lastKey==13) // Enter
+      {
+        return true;
+      }
+      return false;
+    }
+
+    this.NavChild = function(evt,itemIndex,childIndex)
+    {
+      var e  = (evt) ? evt : window.event; // for IE
+      if (e.keyCode==13) return true;
+      if (!this.ProcessKeys(e)) return false;
+
+      if (this.lastKey==38) // Up
+      {
+        if (childIndex>0)
+        {
+          var newIndex = childIndex-1;
+          document.getElementById('Item'+itemIndex+'_c'+newIndex).focus();
+        }
+        else // already at first child, jump to parent
+        {
+          document.getElementById('Item'+itemIndex).focus();
+        }
+      }
+      else if (this.lastKey==40) // Down
+      {
+        var newIndex = childIndex+1;
+        var elem = document.getElementById('Item'+itemIndex+'_c'+newIndex);
+        if (!elem) // last child, jump to parent next parent
+        {
+          elem = this.NavNext(itemIndex+1);
+        }
+        if (elem)
+        {
+          elem.focus();
+        }
+      }
+      else if (this.lastKey==27) // Escape
+      {
+        parent.searchBox.CloseResultsWindow();
+        parent.document.getElementById("MSearchField").focus();
+      }
+      else if (this.lastKey==13) // Enter
+      {
+        return true;
+      }
+      return false;
+    }
+}
+
+function setKeyActions(elem,action)
+{
+  elem.setAttribute('onkeydown',action);
+  elem.setAttribute('onkeypress',action);
+  elem.setAttribute('onkeyup',action);
+}
+
+function setClassAttr(elem,attr)
+{
+  elem.setAttribute('class',attr);
+  elem.setAttribute('className',attr);
+}
+
+function createResults()
+{
+  var results = document.getElementById("SRResults");
+  for (var e=0; e<searchData.length; e++)
+  {
+    var id = searchData[e][0];
+    var srResult = document.createElement('div');
+    srResult.setAttribute('id','SR_'+id);
+    setClassAttr(srResult,'SRResult');
+    var srEntry = document.createElement('div');
+    setClassAttr(srEntry,'SREntry');
+    var srLink = document.createElement('a');
+    srLink.setAttribute('id','Item'+e);
+    setKeyActions(srLink,'return searchResults.Nav(event,'+e+')');
+    setClassAttr(srLink,'SRSymbol');
+    srLink.innerHTML = searchData[e][1][0];
+    srEntry.appendChild(srLink);
+    if (searchData[e][1].length==2) // single result
+    {
+      srLink.setAttribute('href',searchData[e][1][1][0]);
+      if (searchData[e][1][1][1])
+      {
+       srLink.setAttribute('target','_parent');
+      }
+      var srScope = document.createElement('span');
+      setClassAttr(srScope,'SRScope');
+      srScope.innerHTML = searchData[e][1][1][2];
+      srEntry.appendChild(srScope);
+    }
+    else // multiple results
+    {
+      srLink.setAttribute('href','javascript:searchResults.Toggle("SR_'+id+'")');
+      var srChildren = document.createElement('div');
+      setClassAttr(srChildren,'SRChildren');
+      for (var c=0; c<searchData[e][1].length-1; c++)
+      {
+        var srChild = document.createElement('a');
+        srChild.setAttribute('id','Item'+e+'_c'+c);
+        setKeyActions(srChild,'return searchResults.NavChild(event,'+e+','+c+')');
+        setClassAttr(srChild,'SRScope');
+        srChild.setAttribute('href',searchData[e][1][c+1][0]);
+        if (searchData[e][1][c+1][1])
+        {
+         srChild.setAttribute('target','_parent');
+        }
+        srChild.innerHTML = searchData[e][1][c+1][2];
+        srChildren.appendChild(srChild);
+      }
+      srEntry.appendChild(srChildren);
+    }
+    srResult.appendChild(srEntry);
+    results.appendChild(srResult);
+  }
+}
+
+function init_search()
+{
+  var results = document.getElementById("MSearchSelectWindow");
+  for (var key in indexSectionLabels)
+  {
+    var link = document.createElement('a');
+    link.setAttribute('class','SelectItem');
+    link.setAttribute('onclick','searchBox.OnSelectItem('+key+')');
+    link.href='javascript:void(0)';
+    link.innerHTML='<span class="SelectionMark">&#160;</span>'+indexSectionLabels[key];
+    results.appendChild(link);
+  }
+  searchBox.OnSelectItem(0);
+}
+/* @license-end */
diff --git a/week4/softwareEng_9_4/app/html/search/search_l.png b/week4/softwareEng_9_4/app/html/search/search_l.png
new file mode 100644
index 0000000000000000000000000000000000000000..fd5f7daa41a4c79b4ae9bea5aa7bdfb94e14084b
GIT binary patch
literal 567
zcmeAS@N?(olHy`uVBq!ia0vp^B0wz6!2%?$TA$hhDVB6cUq=Rpjs4tz5?O(Kg=CK)
zUj~NU84L`?eGCi_EEpJ?t}-xGu`@87+QPtK?83kxQ`TapwHK(CDaqU2h2ejD|C#+j
z9%q3^WHAE+w=f7ZGR&GI0Tg5}@$_|Nf5gMiEhFgvHvB#V1EZFwi(`n!`QAxqy_^C?
z+`jj!^>(R!W8j_r#qQ#gnr4kAxdU#F0+OBry<A_XEfSiTFv~GuLE}}0iFF6&H>$Z+
z_0PMi;P|#{d%mw(dnw=jM%@$onTJa%@6Nm3`;2S#nwtVFJI#`U@2Q@@JCCctagvF-
z8H=anvo~dTmJ2<pSnM=aYQ7mur_Vc=KQ;l29JyWDZCN~fev0|+o3}F2P%CNIx5trL
z8gA}<cc1qPiOH&eRG9J7<ifc}f%_b|eRo%1h+kMg?QxbQD_=Y#XWHp4|L@3Yv6bBq
zd~oOD{y#VJ78Z8RC_Y*B*FLF4Y09bOg^5e_I(Ak>YA%wA6IHRv%{vxvUm|R)kgZeo
zmX%Zb;mpflGZdXCTAgit`||AFzkI#z&(3d4(htA?U2FOL4WF6wY&TB#n3n*I4+hl|
z*NBpo#FA92<f2p{#b9J$XrXIpq-$UvVrXb(WMO4!u5DmoWniFd?|d6YLvDUbW?Cg~
V4KYc-(}5ZoJYD@<);T3K0RU@P%k2OF

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/search/search_m.png b/week4/softwareEng_9_4/app/html/search/search_m.png
new file mode 100644
index 0000000000000000000000000000000000000000..b429a16ba641960da1e52e5da85dc80fd82635c8
GIT binary patch
literal 158
zcmeAS@N?(olHy`uVBq!ia0vp^Oh7Em0U}M~ynTTbOS+@4BLl;=8&~`zjDUQ}64!{5
z;QX|b^2DN42FH~Aq*MjZ+{E<Mpwz^a%EFVWHb6xNo-U3d6}OUf^!3vd5)y3c{#bPU
z`teb@<JbTH_7jql7?`61bOfX$^6u_pUBbY`!?2W{-=^-N>vEu822WQ%mvv4FO#qs`
BFGc_W

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/search/search_r.png b/week4/softwareEng_9_4/app/html/search/search_r.png
new file mode 100644
index 0000000000000000000000000000000000000000..1af5d21ee13e070d7600f1c4657fde843b953a69
GIT binary patch
literal 553
zcmeAS@N?(olHy`uVBq!ia0vp^LO?9c!2%@BXHTsJQY`6?zK#qG8~eHcB(ehe3dtTp
zz6=bxGZ+|(`xqD=STHa&U1eaXVrO7DwS|Gf*oA>XrmV$GYcEhOQ<As43&a2R{xkc5
zJkA1-$YKTtZeb8+WSBKa0w~B{;_2(k{)mU2TSn0TZTNi#21XfA7sn8d^R1H{y_o_<
z+~hsAIakGYPy5?E?QfIV-)Ulw-A&uvc6(^?XfA18cvfYFtH_Fg-3MA$nhAz1;G4nQ
z)c5(>T(QLuS{~ooZ2P@v=Xc@RKW@Irliv8_;wroU0*)0O?temdsA~70jrdux+`@W7
z-N(<(C)L?hOO?KV{>8(jC{h<AlVfGFV&cS)C3al`J({hH{AZi%%{daMX%zO!rQPhj
zO4O~O1uR{5ym@yvujLfdunGzN6vJTAIO%M=m#VrSQ@h&By8@n<o)p=ZT$+AnU5ifM
z=cKe}PAc7}R+@<xE&raDXZb+)aQF4y<?OdioGN6^Ufq9RRdf1xc5a~x>pKsws)#Fh
zvsO>IB+gb@b+rGWaO&!a9Z{!U+fV*s7TS>fdt&j$L%^U@Epd$~Nl7e8wMs5Z1yT$~
z28I^8hDN#u<{^fLRz?<9hUVG^237_Jy7tbuQ8eV{r(~v8;?@w8^gA7>fx*+&&t;uc
GLK6VEQpiUD

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/search/searchdata.js b/week4/softwareEng_9_4/app/html/search/searchdata.js
new file mode 100644
index 00000000..7aa8d982
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/search/searchdata.js
@@ -0,0 +1,24 @@
+var indexSectionsWithContent =
+{
+  0: "imps",
+  1: "p",
+  2: "s",
+  3: "imp"
+};
+
+var indexSectionNames =
+{
+  0: "all",
+  1: "classes",
+  2: "files",
+  3: "functions"
+};
+
+var indexSectionLabels =
+{
+  0: "All",
+  1: "Classes",
+  2: "Files",
+  3: "Functions"
+};
+
diff --git a/week4/softwareEng_9_4/app/html/software_eng__9__4_8cpp.html b/week4/softwareEng_9_4/app/html/software_eng__9__4_8cpp.html
new file mode 100644
index 00000000..f269731a
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/software_eng__9__4_8cpp.html
@@ -0,0 +1,109 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: softwareEng_9_4.cpp File Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#func-members">Functions</a>  </div>
+  <div class="headertitle">
+<div class="title">softwareEng_9_4.cpp File Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock"><code>#include &quot;<a class="el" href="software_eng__9__4_8hpp_source.html">softwareEng_9_4.hpp</a>&quot;</code><br />
+</div><div class="textblock"><div class="dynheader">
+Include dependency graph for softwareEng_9_4.cpp:</div>
+<div class="dyncontent">
+<div class="center"><img src="software_eng__9__4_8cpp__incl.png" border="0" usemap="#software_eng__9__4_8cpp" alt=""/></div>
+</div>
+</div><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:ae66f6b31b5ad750f1fe042a706a4e3d4"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="software_eng__9__4_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4">main</a> ()</td></tr>
+<tr class="separator:ae66f6b31b5ad750f1fe042a706a4e3d4"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<h2 class="groupheader">Function Documentation</h2>
+<a id="ae66f6b31b5ad750f1fe042a706a4e3d4"></a>
+<h2 class="memtitle"><span class="permalink"><a href="#ae66f6b31b5ad750f1fe042a706a4e3d4">&#9670;&nbsp;</a></span>main()</h2>
+
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int main </td>
+          <td>(</td>
+          <td class="paramname"></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/software_eng__9__4_8cpp__incl.dot b/week4/softwareEng_9_4/app/html/software_eng__9__4_8cpp__incl.dot
new file mode 100644
index 00000000..b4177912
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/software_eng__9__4_8cpp__incl.dot
@@ -0,0 +1,17 @@
+digraph "softwareEng_9_4.cpp"
+{
+ // LATEX_PDF_SIZE
+  edge [fontname="Helvetica",fontsize="10",labelfontname="Helvetica",labelfontsize="10"];
+  node [fontname="Helvetica",fontsize="10",shape=record];
+  Node1 [label="softwareEng_9_4.cpp",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled", fontcolor="black",tooltip=" "];
+  Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node2 [label="softwareEng_9_4.hpp",height=0.2,width=0.4,color="black", fillcolor="white", style="filled",URL="$software_eng__9__4_8hpp.html",tooltip=" "];
+  Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node3 [label="iostream",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+  Node2 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node4 [label="string",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+  Node2 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node5 [label="vector",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+  Node2 -> Node6 [color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node6 [label="numeric",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+}
diff --git a/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp.html b/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp.html
new file mode 100644
index 00000000..30f63ae6
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp.html
@@ -0,0 +1,104 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: softwareEng_9_4.hpp File Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#nested-classes">Classes</a>  </div>
+  <div class="headertitle">
+<div class="title">softwareEng_9_4.hpp File Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock"><code>#include &lt;iostream&gt;</code><br />
+<code>#include &lt;string&gt;</code><br />
+<code>#include &lt;vector&gt;</code><br />
+<code>#include &lt;numeric&gt;</code><br />
+</div><div class="textblock"><div class="dynheader">
+Include dependency graph for softwareEng_9_4.hpp:</div>
+<div class="dyncontent">
+<div class="center"><img src="software_eng__9__4_8hpp__incl.png" border="0" usemap="#software_eng__9__4_8hpp" alt=""/></div>
+<!-- MAP 0 -->
+</div>
+</div><div class="textblock"><div class="dynheader">
+This graph shows which files directly or indirectly include this file:</div>
+<div class="dyncontent">
+<div class="center"><img src="software_eng__9__4_8hpp__dep__incl.png" border="0" usemap="#software_eng__9__4_8hppdep" alt=""/></div>
+<!-- MAP 1 -->
+</div>
+</div>
+<p><a href="software_eng__9__4_8hpp_source.html">Go to the source code of this file.</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Classes</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classprinter.html">printer</a></td></tr>
+<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">printer is a class to extract a new method from printposition, The motivation behind solving this problem is to implement method extraction for code refractory using input method  <a href="classprinter.html#details">More...</a><br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp__dep__incl.dot b/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp__dep__incl.dot
new file mode 100644
index 00000000..8377b075
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp__dep__incl.dot
@@ -0,0 +1,9 @@
+digraph "softwareEng_9_4.hpp"
+{
+ // LATEX_PDF_SIZE
+  edge [fontname="Helvetica",fontsize="10",labelfontname="Helvetica",labelfontsize="10"];
+  node [fontname="Helvetica",fontsize="10",shape=record];
+  Node1 [label="softwareEng_9_4.hpp",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled", fontcolor="black",tooltip=" "];
+  Node1 -> Node2 [dir="back",color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node2 [label="softwareEng_9_4.cpp",height=0.2,width=0.4,color="black", fillcolor="white", style="filled",URL="$software_eng__9__4_8cpp.html",tooltip=" "];
+}
diff --git a/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp__incl.dot b/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp__incl.dot
new file mode 100644
index 00000000..5b19d01e
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp__incl.dot
@@ -0,0 +1,15 @@
+digraph "softwareEng_9_4.hpp"
+{
+ // LATEX_PDF_SIZE
+  edge [fontname="Helvetica",fontsize="10",labelfontname="Helvetica",labelfontsize="10"];
+  node [fontname="Helvetica",fontsize="10",shape=record];
+  Node1 [label="softwareEng_9_4.hpp",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled", fontcolor="black",tooltip=" "];
+  Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node2 [label="iostream",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+  Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node3 [label="string",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+  Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node4 [label="vector",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+  Node1 -> Node5 [color="midnightblue",fontsize="10",style="solid",fontname="Helvetica"];
+  Node5 [label="numeric",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+}
diff --git a/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp_source.html b/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp_source.html
new file mode 100644
index 00000000..6d96267b
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/software_eng__9__4_8hpp_source.html
@@ -0,0 +1,102 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.17"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>PrintPosition: softwareEng_9_4.hpp Source File</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">PrintPosition
+   </div>
+   <div id="projectbrief">Extract Position</div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.17 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="headertitle">
+<div class="title">softwareEng_9_4.hpp</div>  </div>
+</div><!--header-->
+<div class="contents">
+<a href="software_eng__9__4_8hpp.html">Go to the documentation of this file.</a><div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno">    1</span>&#160; </div>
+<div class="line"><a name="l00010"></a><span class="lineno">   10</span>&#160;<span class="preprocessor">#pragma once</span></div>
+<div class="line"><a name="l00011"></a><span class="lineno">   11</span>&#160; </div>
+<div class="line"><a name="l00012"></a><span class="lineno">   12</span>&#160;<span class="preprocessor">#include &lt;iostream&gt;</span></div>
+<div class="line"><a name="l00013"></a><span class="lineno">   13</span>&#160; </div>
+<div class="line"><a name="l00014"></a><span class="lineno">   14</span>&#160;<span class="preprocessor">#include &lt;string&gt;</span></div>
+<div class="line"><a name="l00015"></a><span class="lineno">   15</span>&#160; </div>
+<div class="line"><a name="l00016"></a><span class="lineno">   16</span>&#160;<span class="preprocessor">#include &lt;vector&gt;</span></div>
+<div class="line"><a name="l00017"></a><span class="lineno">   17</span>&#160; </div>
+<div class="line"><a name="l00018"></a><span class="lineno">   18</span>&#160;<span class="preprocessor">#include &lt;numeric&gt;</span></div>
+<div class="line"><a name="l00019"></a><span class="lineno">   19</span>&#160; </div>
+<div class="line"><a name="l00027"></a><span class="lineno"><a class="line" href="classprinter.html">   27</a></span>&#160;<span class="keyword">class </span><a class="code" href="classprinter.html">printer</a> {</div>
+<div class="line"><a name="l00028"></a><span class="lineno">   28</span>&#160; <span class="keyword">public</span>:</div>
+<div class="line"><a name="l00029"></a><span class="lineno">   29</span>&#160;    <span class="keywordtype">int</span> <a class="code" href="classprinter.html#a10b05212f6167b64ebfb1b7c1cdc9ef2">input</a>();</div>
+<div class="line"><a name="l00030"></a><span class="lineno">   30</span>&#160;    <span class="keywordtype">void</span> <a class="code" href="classprinter.html#ae7da213aa9062bea77998b0340163c17">printPosition</a>(<span class="keywordtype">int</span> t_length, <span class="keywordtype">int</span> a_length_search, <span class="keywordtype">char</span>* text,</div>
+<div class="line"><a name="l00031"></a><span class="lineno">   31</span>&#160;    <span class="keywordtype">char</span>* array_to_search1, <span class="keywordtype">int</span> position);</div>
+<div class="line"><a name="l00032"></a><span class="lineno">   32</span>&#160;    <a class="code" href="classprinter.html#adfbc169c8c36ac791744c8dc01647432">printer</a>();</div>
+<div class="line"><a name="l00033"></a><span class="lineno">   33</span>&#160;};</div>
+<div class="line"><a name="l00034"></a><span class="lineno">   34</span>&#160; </div>
+<div class="line"><a name="l00035"></a><span class="lineno"><a class="line" href="classprinter.html#adfbc169c8c36ac791744c8dc01647432">   35</a></span>&#160; <a class="code" href="classprinter.html#adfbc169c8c36ac791744c8dc01647432">printer::printer</a>(<span class="keywordtype">void</span>){</div>
+<div class="line"><a name="l00036"></a><span class="lineno">   36</span>&#160;}</div>
+</div><!-- fragment --></div><!-- contents -->
+<div class="ttc" id="aclassprinter_html_ae7da213aa9062bea77998b0340163c17"><div class="ttname"><a href="classprinter.html#ae7da213aa9062bea77998b0340163c17">printer::printPosition</a></div><div class="ttdeci">void printPosition(int t_length, int a_length_search, char *text, char *array_to_search1, int position)</div><div class="ttdoc">printPostion method enable code resuablity and extraction mechanism this extracted method is used to ...</div><div class="ttdef"><b>Definition:</b> softwareEng_9_4.cpp:16</div></div>
+<div class="ttc" id="aclassprinter_html_adfbc169c8c36ac791744c8dc01647432"><div class="ttname"><a href="classprinter.html#adfbc169c8c36ac791744c8dc01647432">printer::printer</a></div><div class="ttdeci">printer()</div><div class="ttdef"><b>Definition:</b> softwareEng_9_4.hpp:35</div></div>
+<div class="ttc" id="aclassprinter_html_a10b05212f6167b64ebfb1b7c1cdc9ef2"><div class="ttname"><a href="classprinter.html#a10b05212f6167b64ebfb1b7c1cdc9ef2">printer::input</a></div><div class="ttdeci">int input()</div><div class="ttdoc">input() method makes sure that all the inputs for printing the positon are fed and passed by value to...</div><div class="ttdef"><b>Definition:</b> softwareEng_9_4.cpp:37</div></div>
+<div class="ttc" id="aclassprinter_html"><div class="ttname"><a href="classprinter.html">printer</a></div><div class="ttdoc">printer is a class to extract a new method from printposition, The motivation behind solving this pro...</div><div class="ttdef"><b>Definition:</b> softwareEng_9_4.hpp:27</div></div>
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.17
+</small></address>
+</body>
+</html>
diff --git a/week4/softwareEng_9_4/app/html/splitbar.png b/week4/softwareEng_9_4/app/html/splitbar.png
new file mode 100644
index 0000000000000000000000000000000000000000..fe895f2c58179b471a22d8320b39a4bd7312ec8e
GIT binary patch
literal 314
zcmeAS@N?(olHy`uVBq!ia0vp^Yzz!63>-{AmhX=Jf(#6djGiuzAr*{o?=JLmPLyc>
z_*`QK&+BH@jW<lVxsx`Ym~nPnqw$O~`M84{XS6<Mm0<Zit<Tk``D^RashfFq{wG<#
zZG2vRxL<$IhkFMSBd@N1`uRtp)t>rYJ7>r6%keRM@)Qyv8R=enp0jiI>aWlGyB58O
zFVR20d+y`K7vDw(hJF3;>dD*3-?v=<8M)@x|E<fHWtM%;-WUJ&>EGLnJsniYK!2U1
Y!`|5biEc?d1`HDhPgg&ebxsLQ02F6;9RL6T

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/sync_off.png b/week4/softwareEng_9_4/app/html/sync_off.png
new file mode 100644
index 0000000000000000000000000000000000000000..3b443fc62892114406e3d399421b2a881b897acc
GIT binary patch
literal 853
zcmV-b1FHOqP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv0009VNkl<ZcmeI*
zOK4PA7{KxW<S|JmGnqI|rb(KahDirA+8B+gVk8A)%pe9yF;+3L5iKZG7xuBS&@L(k
z33MTXOIxMHjirbWgs8M;qhM?(_-v^nS(KzU#%Ih_`hB-^XYSm&39)2*I6vmhow@fr
z=iKj{vvuv-e;!~uA+biR6pf-n<cdGVuox5<#BBg4c>oT|#XixUYy%lpuf3i8{fX!o
zUyDD0jOrAiT^tq>fLSOOABs-#u{dV^F$b{L9&!2=9&RmV;;8s^x&UqB$PCj4FdKbh
zoB1WTskPUPu05XzFbA}=KZ-GP1fPpAfSs>6AHb12UlR%-i&uOlTpFNS7{jm@mkU1V
zh`nrXr~+^lsV-s1dkZOaI|kYyVj3WBpPCY{n~yd%u%e+d=f%`N0FItMPtdgBb@py;
zq@v6NVArhyTC7)ULw-Jy8y42S1~4n(3LkrW8mW(F-4oXUP3E`e#g**YyqI7h-J2zK
zK{m9##m4ri!7N>CqQqCcnI3hqo1I;Yh&QLNY4T`*ptiQGozK>FF$!$+84Z`xwmeMh
zJ0WT+OH$WYFALEaGj2_l+#DC3t7_S`vHpSivNeFbP6+r50cO<q-Bsh$IuZaopT|9E
z-75alp&U9s%(|8uI^NA(#AD;nc=%{ivdZX(QFJ7~-yf%_Adjk`W@NhjJTyZ8*;|!n
z9=K#TJuZz+={YZ#>8iu)`7i%Z4BTPh@_m3Tk!nAm^)5Bqnr%Ov|Baunj#&RPtRuK&
z4RGz|D5HNrW83-#ydk}tVKJrNmyYt-sT<tBHx6XfOFDx2(ijpMiR>xLGlJY5nc&Re
zU4SgHNPx8~Yxwr$bsju?4q&%T1874xxzq+_%?h8_ofw~(bld=o3iC)LUNR*BY%c0y
zWd_jX{Y8`l%z+ol1$@Qa?Cy!(0CVIEeYpKZ`(9{z>3$CIe;pJDQk$m3p}$>xBm4lb
zKo{4S)`wdU9Ba9jJbVJ0C=SOefZe%d$8=2r={nu<_^a3~>c#t_U6dye5)JrR(_a^E
f@}b6j1K9lwFJq@>o)+Ry00000NkvXXu0mjfWa5j*

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/sync_on.png b/week4/softwareEng_9_4/app/html/sync_on.png
new file mode 100644
index 0000000000000000000000000000000000000000..e08320fb64e6fa33b573005ed6d8fe294e19db76
GIT binary patch
literal 845
zcmV-T1G4;yP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv0009NNkl<ZcmeI*
zUr1D09KiAKIOC-Ar)j4&EoU~y1|7@QCTmeCsMH~fFw#|0OWK8m>Y;xxyHF2B5Wzm|
zOOGupOTn@c(JmBOl)e;XMNnZuiTJP>rM8<|Q`7I<ojWskx{8*sm){4kXJ+p2oO6HY
zoL5W7@h*VL_(ZL!7GaSmtl}SWU-XD;q7T4~4ZuW>_))aP?*T)ow&n59{}X4$3Goat
zgjs?*aasfbrokzG5cT4K=uG`E14xZl@z)F<o_Z}1zllSWC8!Z+rkFN>={P0Y^?$4t
z>v!teRnNZym<6h{7sLyF1V0HsfEl+l6TrZpsfr1}luH~F7L}ktXu|*uVX^RG$L0`K
zWs3j|0tIvVe(N%_?2{(iCPFGf#B6Hjy6o&}D$A%W%jfO8_W%ZO#-mh}EM$LMn7joJ
z05dHr!5Y92g+31l<%i1(=L1a1pXX+OYnalY>31V4K}BjyRe3)9n#;-cCVRD_IG1fT
zOKGeNY8q;TL@K{dj@D^scf&VCs*-Jb>8b>|`b*osv52-!A?BpbYtTQBns5EAU**$m
zSnVSm(teh>tQi*S*A>#ySc=n;`BHz`DuG4&g4Kf8lLhca+zvZ7t7RflD6-i-mcK=M
z!=^P$*u2)bkY5asG4gsss!Hn%u~>}kIW`vMs%lJLH+u*9<4PaV_c6U`KqWXQH%+Nu
zTv41O(^ZVi@qhjQdG!fbZw&y+2o!iYymO^?ud3{P*HdoX83YV*Uu_HB=?U&W9%AU#
z80}k1SS-CXTU7dcQlsm<^oYLxVSseqY6NO}dc`Nj?8vrhNuCdm@^{a3AQ_>6myOj+
z`1RsLUXF|dm|3k7s2jD(B{rzE>WI2scH8i1;=O5Cc9xB3^aJk%fQjqsu+kH#0=_5a
z0nCE8@dbQa-|YIuUVvG0L_IwHMEhOj$M<u9&-IHqnYs=DL+lbi3lG2ysF!p!_2H=p
zj-g89hmThki^;JHknVE4V`@zS$(ZbTd?1=dsrXLRiJbUBq7weAmVjEk@rP>j4Uq05
X8=0q~qBNan00000NkvXXu0mjfptF>5

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/tab_a.png b/week4/softwareEng_9_4/app/html/tab_a.png
new file mode 100644
index 0000000000000000000000000000000000000000..3b725c41c5a527a3a3e40097077d0e206a681247
GIT binary patch
literal 142
zcmeAS@N?(olHy`uVBq!ia0vp^j6kfy!2~3aiye;!QlXwMjv*C{Z|8b*H5dputLHD#
z=<0|*y7z(Vor?d;H&?EG&cXR}?!j-Lm&u1OOI7AIF5&c)RFE;&p0MYK>*Kl@eiymD
r@|NpwKX@^z+;{u_Z~trSBfrMKa%3`zocFjEXaR$#tDnm{r-UW|TZ1%4

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/tab_b.png b/week4/softwareEng_9_4/app/html/tab_b.png
new file mode 100644
index 0000000000000000000000000000000000000000..e2b4a8638cb3496a016eaed9e16ffc12846dea18
GIT binary patch
literal 169
zcmeAS@N?(olHy`uVBq!ia0vp^j6kfy!2~3aiye;!QU#tajv*C{Z}0l@H7kg?K0Lnr
z!j&C6_(~HV9oQ0Pa6x{-v0AGV_E?vLn<f<Rf3mJ=+uzfrOMlc%s`x4TZtnrR|B~W{
zyZP0m7vvtXV80W5^J2vvp97)4WrPK1-P<H^B$Ll|TGvzm;+92|BpdT89$b1Qf7x5g
UZ&RH}7SL`6Pgg&ebxsLQ0A}n&iU0rr

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/tab_h.png b/week4/softwareEng_9_4/app/html/tab_h.png
new file mode 100644
index 0000000000000000000000000000000000000000..fd5cb705488e60fcf30f56fcc951dee74f3b095b
GIT binary patch
literal 177
zcmeAS@N?(olHy`uVBq!ia0vp^j6kfy!2~3aiye;!QWc&qjv*C{Z}0jF9dr<AdpNI7
zaOs_6=O($9b?lc?Qk=SJVv5%FA{O^TY1^*qJ@<p}E}!uH_1eoPJ&tpVl={bg{Skd2
zp1FO|;|R90%G3WYZM5AU=A4%H?3qaQhHt%H9G|xYJ)ff*|MmI*zD3`*Z|LP?7d&26
cn!ZiLK0QM$CeyB_80ZEDPgg&ebxsLQ0C?O;!~g&Q

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/tab_s.png b/week4/softwareEng_9_4/app/html/tab_s.png
new file mode 100644
index 0000000000000000000000000000000000000000..ab478c95b67371d700a20869f7de1ddd73522d50
GIT binary patch
literal 184
zcmeAS@N?(olHy`uVBq!ia0vp^j6kfy!2~3aiye;!QuUrLjv*C{Z|^p8HaRdjTwH7)
zC?wLlL}}I{)n%R&r+1}IGmDnq;&J#%V6)9VsYhS`O^BVBQlxOUep0c$RENLq#g8A$
z)z7%K_bI&n@J+X_=x}fJoEKed-$<>=ZI-;YrdjIl`U`uzuDWSP?o#Dmo{%SgM#oan
kX~E1%D-|#H#QbHoIja2U-MgvsK&LQxy85}Sb4q9e0Efg%P5=M^

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/html/tabs.css b/week4/softwareEng_9_4/app/html/tabs.css
new file mode 100644
index 00000000..7d45d36c
--- /dev/null
+++ b/week4/softwareEng_9_4/app/html/tabs.css
@@ -0,0 +1 @@
+.sm{position:relative;z-index:9999}.sm,.sm ul,.sm li{display:block;list-style:none;margin:0;padding:0;line-height:normal;direction:ltr;text-align:left;-webkit-tap-highlight-color:rgba(0,0,0,0)}.sm-rtl,.sm-rtl ul,.sm-rtl li{direction:rtl;text-align:right}.sm>li>h1,.sm>li>h2,.sm>li>h3,.sm>li>h4,.sm>li>h5,.sm>li>h6{margin:0;padding:0}.sm ul{display:none}.sm li,.sm a{position:relative}.sm a{display:block}.sm a.disabled{cursor:not-allowed}.sm:after{content:"\00a0";display:block;height:0;font:0px/0 serif;clear:both;visibility:hidden;overflow:hidden}.sm,.sm *,.sm *:before,.sm *:after{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.sm-dox{background-image:url("tab_b.png")}.sm-dox a,.sm-dox a:focus,.sm-dox a:hover,.sm-dox a:active{padding:0px 12px;padding-right:43px;font-family:"Lucida Grande","Geneva","Helvetica",Arial,sans-serif;font-size:13px;font-weight:bold;line-height:36px;text-decoration:none;text-shadow:0px 1px 1px rgba(255,255,255,0.9);color:#283A5D;outline:none}.sm-dox a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:#fff;text-shadow:0px 1px 1px #000}.sm-dox a.current{color:#D23600}.sm-dox a.disabled{color:#bbb}.sm-dox a span.sub-arrow{position:absolute;top:50%;margin-top:-14px;left:auto;right:3px;width:28px;height:28px;overflow:hidden;font:bold 12px/28px monospace !important;text-align:center;text-shadow:none;background:rgba(255,255,255,0.5);border-radius:5px}.sm-dox a.highlighted span.sub-arrow:before{display:block;content:'-'}.sm-dox>li:first-child>a,.sm-dox>li:first-child>:not(ul) a{border-radius:5px 5px 0 0}.sm-dox>li:last-child>a,.sm-dox>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul{border-radius:0 0 5px 5px}.sm-dox>li:last-child>a.highlighted,.sm-dox>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>a.highlighted,.sm-dox>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>ul>li:last-child>*:not(ul) a.highlighted{border-radius:0}.sm-dox ul{background:rgba(162,162,162,0.1)}.sm-dox ul a,.sm-dox ul a:focus,.sm-dox ul a:hover,.sm-dox ul a:active{font-size:12px;border-left:8px solid transparent;line-height:36px;text-shadow:none;background-color:white;background-image:none}.sm-dox ul a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:#fff;text-shadow:0px 1px 1px #000}.sm-dox ul ul a,.sm-dox ul ul a:hover,.sm-dox ul ul a:focus,.sm-dox ul ul a:active{border-left:16px solid transparent}.sm-dox ul ul ul a,.sm-dox ul ul ul a:hover,.sm-dox ul ul ul a:focus,.sm-dox ul ul ul a:active{border-left:24px solid transparent}.sm-dox ul ul ul ul a,.sm-dox ul ul ul ul a:hover,.sm-dox ul ul ul ul a:focus,.sm-dox ul ul ul ul a:active{border-left:32px solid transparent}.sm-dox ul ul ul ul ul a,.sm-dox ul ul ul ul ul a:hover,.sm-dox ul ul ul ul ul a:focus,.sm-dox ul ul ul ul ul a:active{border-left:40px solid transparent}@media (min-width: 768px){.sm-dox ul{position:absolute;width:12em}.sm-dox li{float:left}.sm-dox.sm-rtl li{float:right}.sm-dox ul li,.sm-dox.sm-rtl ul li,.sm-dox.sm-vertical li{float:none}.sm-dox a{white-space:nowrap}.sm-dox ul a,.sm-dox.sm-vertical a{white-space:normal}.sm-dox .sm-nowrap>li>a,.sm-dox .sm-nowrap>li>:not(ul) a{white-space:nowrap}.sm-dox{padding:0 10px;background-image:url("tab_b.png");line-height:36px}.sm-dox a span.sub-arrow{top:50%;margin-top:-2px;right:12px;width:0;height:0;border-width:4px;border-style:solid dashed dashed dashed;border-color:#283A5D transparent transparent transparent;background:transparent;border-radius:0}.sm-dox a,.sm-dox a:focus,.sm-dox a:active,.sm-dox a:hover,.sm-dox a.highlighted{padding:0px 12px;background-image:url("tab_s.png");background-repeat:no-repeat;background-position:right;border-radius:0 !important}.sm-dox a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:#fff;text-shadow:0px 1px 1px #000}.sm-dox a:hover span.sub-arrow{border-color:#fff transparent transparent transparent}.sm-dox a.has-submenu{padding-right:24px}.sm-dox li{border-top:0}.sm-dox>li>ul:before,.sm-dox>li>ul:after{content:'';position:absolute;top:-18px;left:30px;width:0;height:0;overflow:hidden;border-width:9px;border-style:dashed dashed solid dashed;border-color:transparent transparent #bbb transparent}.sm-dox>li>ul:after{top:-16px;left:31px;border-width:8px;border-color:transparent transparent #fff transparent}.sm-dox ul{border:1px solid #bbb;padding:5px 0;background:#fff;border-radius:5px !important;box-shadow:0 5px 9px rgba(0,0,0,0.2)}.sm-dox ul a span.sub-arrow{right:8px;top:50%;margin-top:-5px;border-width:5px;border-color:transparent transparent transparent #555;border-style:dashed dashed dashed solid}.sm-dox ul a,.sm-dox ul a:hover,.sm-dox ul a:focus,.sm-dox ul a:active,.sm-dox ul a.highlighted{color:#555;background-image:none;border:0 !important;color:#555;background-image:none}.sm-dox ul a:hover{background-image:url("tab_a.png");background-repeat:repeat-x;color:#fff;text-shadow:0px 1px 1px #000}.sm-dox ul a:hover span.sub-arrow{border-color:transparent transparent transparent #fff}.sm-dox span.scroll-up,.sm-dox span.scroll-down{position:absolute;display:none;visibility:hidden;overflow:hidden;background:#fff;height:36px}.sm-dox span.scroll-up:hover,.sm-dox span.scroll-down:hover{background:#eee}.sm-dox span.scroll-up:hover span.scroll-up-arrow,.sm-dox span.scroll-up:hover span.scroll-down-arrow{border-color:transparent transparent #D23600 transparent}.sm-dox span.scroll-down:hover span.scroll-down-arrow{border-color:#D23600 transparent transparent transparent}.sm-dox span.scroll-up-arrow,.sm-dox span.scroll-down-arrow{position:absolute;top:0;left:50%;margin-left:-6px;width:0;height:0;overflow:hidden;border-width:6px;border-style:dashed dashed solid dashed;border-color:transparent transparent #555 transparent}.sm-dox span.scroll-down-arrow{top:8px;border-style:solid dashed dashed dashed;border-color:#555 transparent transparent transparent}.sm-dox.sm-rtl a.has-submenu{padding-right:12px;padding-left:24px}.sm-dox.sm-rtl a span.sub-arrow{right:auto;left:12px}.sm-dox.sm-rtl.sm-vertical a.has-submenu{padding:10px 20px}.sm-dox.sm-rtl.sm-vertical a span.sub-arrow{right:auto;left:8px;border-style:dashed solid dashed dashed;border-color:transparent #555 transparent transparent}.sm-dox.sm-rtl>li>ul:before{left:auto;right:30px}.sm-dox.sm-rtl>li>ul:after{left:auto;right:31px}.sm-dox.sm-rtl ul a.has-submenu{padding:10px 20px !important}.sm-dox.sm-rtl ul a span.sub-arrow{right:auto;left:8px;border-style:dashed solid dashed dashed;border-color:transparent #555 transparent transparent}.sm-dox.sm-vertical{padding:10px 0;border-radius:5px}.sm-dox.sm-vertical a{padding:10px 20px}.sm-dox.sm-vertical a:hover,.sm-dox.sm-vertical a:focus,.sm-dox.sm-vertical a:active,.sm-dox.sm-vertical a.highlighted{background:#fff}.sm-dox.sm-vertical a.disabled{background-image:url("tab_b.png")}.sm-dox.sm-vertical a span.sub-arrow{right:8px;top:50%;margin-top:-5px;border-width:5px;border-style:dashed dashed dashed solid;border-color:transparent transparent transparent #555}.sm-dox.sm-vertical>li>ul:before,.sm-dox.sm-vertical>li>ul:after{display:none}.sm-dox.sm-vertical ul a{padding:10px 20px}.sm-dox.sm-vertical ul a:hover,.sm-dox.sm-vertical ul a:focus,.sm-dox.sm-vertical ul a:active,.sm-dox.sm-vertical ul a.highlighted{background:#eee}.sm-dox.sm-vertical ul a.disabled{background:#fff}}
diff --git a/week4/softwareEng_9_4/app/latex/Makefile b/week4/softwareEng_9_4/app/latex/Makefile
new file mode 100644
index 00000000..877c9ccc
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/Makefile
@@ -0,0 +1,23 @@
+LATEX_CMD=pdflatex
+
+all: refman.pdf
+
+pdf: refman.pdf
+
+refman.pdf: clean refman.tex
+	$(LATEX_CMD) refman
+	makeindex refman.idx
+	$(LATEX_CMD) refman
+	latex_count=8 ; \
+	while egrep -s 'Rerun (LaTeX|to get cross-references right)' refman.log && [ $$latex_count -gt 0 ] ;\
+	    do \
+	      echo "Rerunning latex...." ;\
+	      $(LATEX_CMD) refman ;\
+	      latex_count=`expr $$latex_count - 1` ;\
+	    done
+	makeindex refman.idx
+	$(LATEX_CMD) refman
+
+
+clean:
+	rm -f *.ps *.dvi *.aux *.toc *.idx *.ind *.ilg *.log *.out *.brf *.blg *.bbl refman.pdf
diff --git a/week4/softwareEng_9_4/app/latex/annotated.tex b/week4/softwareEng_9_4/app/latex/annotated.tex
new file mode 100644
index 00000000..6aa36c5a
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/annotated.tex
@@ -0,0 +1,4 @@
+\doxysection{Class List}
+Here are the classes, structs, unions and interfaces with brief descriptions\+:\begin{DoxyCompactList}
+\item\contentsline{section}{\mbox{\hyperlink{classprinter}{printer}} \\*Printer is a class to extract a new method from printposition, The motivation behind solving this problem is to implement method extraction for code refractory using input method }{\pageref{classprinter}}{}
+\end{DoxyCompactList}
diff --git a/week4/softwareEng_9_4/app/latex/classprinter.tex b/week4/softwareEng_9_4/app/latex/classprinter.tex
new file mode 100644
index 00000000..ab9c2fbc
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/classprinter.tex
@@ -0,0 +1,61 @@
+\hypertarget{classprinter}{}\doxysection{printer Class Reference}
+\label{classprinter}\index{printer@{printer}}
+
+
+printer is a class to extract a new method from printposition, The motivation behind solving this problem is to implement method extraction for code refractory using input method  
+
+
+
+
+{\ttfamily \#include $<$software\+Eng\+\_\+9\+\_\+4.\+hpp$>$}
+
+\doxysubsection*{Public Member Functions}
+\begin{DoxyCompactItemize}
+\item 
+int \mbox{\hyperlink{classprinter_a10b05212f6167b64ebfb1b7c1cdc9ef2}{input}} ()
+\begin{DoxyCompactList}\small\item\em \mbox{\hyperlink{classprinter_a10b05212f6167b64ebfb1b7c1cdc9ef2}{input()}} method makes sure that all the inputs for printing the positon are fed and passed by value to \mbox{\hyperlink{classprinter_ae7da213aa9062bea77998b0340163c17}{print\+Position()}} method \end{DoxyCompactList}\item 
+void \mbox{\hyperlink{classprinter_ae7da213aa9062bea77998b0340163c17}{print\+Position}} (int t\+\_\+length, int a\+\_\+length\+\_\+search, char $\ast$text, char $\ast$array\+\_\+to\+\_\+search1, int position)
+\begin{DoxyCompactList}\small\item\em print\+Postion method enable code resuablity and extraction mechanism this extracted method is used to find and print position \end{DoxyCompactList}\item 
+\mbox{\hyperlink{classprinter_adfbc169c8c36ac791744c8dc01647432}{printer}} ()
+\end{DoxyCompactItemize}
+
+
+\doxysubsection{Detailed Description}
+printer is a class to extract a new method from printposition, The motivation behind solving this problem is to implement method extraction for code refractory using input method 
+
+\doxysubsection{Constructor \& Destructor Documentation}
+\mbox{\Hypertarget{classprinter_adfbc169c8c36ac791744c8dc01647432}\label{classprinter_adfbc169c8c36ac791744c8dc01647432}} 
+\index{printer@{printer}!printer@{printer}}
+\index{printer@{printer}!printer@{printer}}
+\doxysubsubsection{\texorpdfstring{printer()}{printer()}}
+{\footnotesize\ttfamily printer\+::printer (\begin{DoxyParamCaption}{ }\end{DoxyParamCaption})}
+
+
+
+\doxysubsection{Member Function Documentation}
+\mbox{\Hypertarget{classprinter_a10b05212f6167b64ebfb1b7c1cdc9ef2}\label{classprinter_a10b05212f6167b64ebfb1b7c1cdc9ef2}} 
+\index{printer@{printer}!input@{input}}
+\index{input@{input}!printer@{printer}}
+\doxysubsubsection{\texorpdfstring{input()}{input()}}
+{\footnotesize\ttfamily int printer\+::input (\begin{DoxyParamCaption}{ }\end{DoxyParamCaption})}
+
+
+
+\mbox{\hyperlink{classprinter_a10b05212f6167b64ebfb1b7c1cdc9ef2}{input()}} method makes sure that all the inputs for printing the positon are fed and passed by value to \mbox{\hyperlink{classprinter_ae7da213aa9062bea77998b0340163c17}{print\+Position()}} method 
+
+\mbox{\Hypertarget{classprinter_ae7da213aa9062bea77998b0340163c17}\label{classprinter_ae7da213aa9062bea77998b0340163c17}} 
+\index{printer@{printer}!printPosition@{printPosition}}
+\index{printPosition@{printPosition}!printer@{printer}}
+\doxysubsubsection{\texorpdfstring{printPosition()}{printPosition()}}
+{\footnotesize\ttfamily void printer\+::print\+Position (\begin{DoxyParamCaption}\item[{int}]{t\+\_\+length,  }\item[{int}]{a\+\_\+length\+\_\+search,  }\item[{char $\ast$}]{text,  }\item[{char $\ast$}]{array\+\_\+to\+\_\+search1,  }\item[{int}]{position }\end{DoxyParamCaption})}
+
+
+
+print\+Postion method enable code resuablity and extraction mechanism this extracted method is used to find and print position 
+
+
+
+The documentation for this class was generated from the following files\+:\begin{DoxyCompactItemize}
+\item 
+\mbox{\hyperlink{software_eng__9__4_8hpp}{software\+Eng\+\_\+9\+\_\+4.\+hpp}}\item 
+\mbox{\hyperlink{software_eng__9__4_8cpp}{software\+Eng\+\_\+9\+\_\+4.\+cpp}}\end{DoxyCompactItemize}
diff --git a/week4/softwareEng_9_4/app/latex/doxygen.sty b/week4/softwareEng_9_4/app/latex/doxygen.sty
new file mode 100644
index 00000000..78a52546
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/doxygen.sty
@@ -0,0 +1,576 @@
+\NeedsTeXFormat{LaTeX2e}
+\ProvidesPackage{doxygen}
+
+% Packages used by this style file
+\RequirePackage{alltt}
+%%\RequirePackage{array} %% moved to refman.tex due to workaround for LaTex 2019 version and unmaintained tabu package
+\RequirePackage{calc}
+\RequirePackage{float}
+%%\RequirePackage{ifthen} %% moved to refman.tex due to workaround for LaTex 2019 version and unmaintained tabu package
+\RequirePackage{verbatim}
+\RequirePackage[table]{xcolor}
+\RequirePackage{longtable_doxygen}
+\RequirePackage{tabu_doxygen}
+\RequirePackage{fancyvrb}
+\RequirePackage{tabularx}
+\RequirePackage{multirow}
+\RequirePackage{hanging}
+\RequirePackage{ifpdf}
+\RequirePackage{adjustbox}
+\RequirePackage{amssymb}
+\RequirePackage{stackengine}
+\RequirePackage[normalem]{ulem} % for strikeout, but don't modify emphasis
+
+%---------- Internal commands used in this style file ----------------
+
+\newcommand{\ensurespace}[1]{%
+  \begingroup%
+    \setlength{\dimen@}{#1}%
+    \vskip\z@\@plus\dimen@%
+    \penalty -100\vskip\z@\@plus -\dimen@%
+    \vskip\dimen@%
+    \penalty 9999%
+    \vskip -\dimen@%
+    \vskip\z@skip% hide the previous |\vskip| from |\addvspace|
+  \endgroup%
+}
+
+\newcommand{\DoxyHorRuler}[1]{%
+  \setlength{\parskip}{0ex plus 0ex minus 0ex}%
+  \ifthenelse{#1=0}%
+  {%
+    \hrule%
+  }%
+  {%
+    \hrulefilll%
+  }%
+}
+\newcommand{\DoxyLabelFont}{}
+\newcommand{\entrylabel}[1]{%
+  {%
+    \parbox[b]{\labelwidth-4pt}{%
+      \makebox[0pt][l]{\DoxyLabelFont#1}%
+      \vspace{1.5\baselineskip}%
+    }%
+  }%
+}
+
+\newenvironment{DoxyDesc}[1]{%
+  \ensurespace{4\baselineskip}%
+  \begin{list}{}{%
+    \settowidth{\labelwidth}{20pt}%
+    %\setlength{\parsep}{0pt}%
+    \setlength{\itemsep}{0pt}%
+    \setlength{\leftmargin}{\labelwidth+\labelsep}%
+    \renewcommand{\makelabel}{\entrylabel}%
+  }%
+  \item[#1]%
+}{%
+  \end{list}%
+}
+
+\newsavebox{\xrefbox}
+\newlength{\xreflength}
+\newcommand{\xreflabel}[1]{%
+  \sbox{\xrefbox}{#1}%
+  \setlength{\xreflength}{\wd\xrefbox}%
+  \ifthenelse{\xreflength>\labelwidth}{%
+    \begin{minipage}{\textwidth}%
+      \setlength{\parindent}{0pt}%
+      \hangindent=15pt\bfseries #1\vspace{1.2\itemsep}%
+    \end{minipage}%
+  }{%
+   \parbox[b]{\labelwidth}{\makebox[0pt][l]{\textbf{#1}}}%
+  }%
+}
+
+%---------- Commands used by doxygen LaTeX output generator ----------
+
+% Used by <pre> ... </pre>
+\newenvironment{DoxyPre}{%
+  \small%
+  \begin{alltt}%
+}{%
+  \end{alltt}%
+  \normalsize%
+}
+% Necessary for redefining not defined characters, i.e. "Replacement Character" in tex output.
+\newlength{\CodeWidthChar}
+\newlength{\CodeHeightChar}
+\settowidth{\CodeWidthChar}{?}
+\settoheight{\CodeHeightChar}{?}
+% Necessary for hanging indent
+\newlength{\DoxyCodeWidth}
+
+\newcommand\DoxyCodeLine[1]{\hangpara{\DoxyCodeWidth}{1}{#1}\par}
+
+\newcommand\NiceSpace{%
+     \discretionary{}{\kern\fontdimen2\font}{\kern\fontdimen2\font}%
+}
+
+% Used by @code ... @endcode
+\newenvironment{DoxyCode}[1]{%
+  \par%
+  \scriptsize%
+  \normalfont\ttfamily%
+  \rightskip0pt plus 1fil%
+  \settowidth{\DoxyCodeWidth}{000000}%
+  \settowidth{\CodeWidthChar}{?}%
+  \settoheight{\CodeHeightChar}{?}%
+  \setlength{\parskip}{0ex plus 0ex minus 0ex}%
+  \ifthenelse{\equal{#1}{0}}
+  {
+    {\lccode`~32 \lowercase{\global\let~}\NiceSpace}\obeyspaces%
+  }
+  {
+    {\lccode`~32 \lowercase{\global\let~}}\obeyspaces%
+  }
+
+}{%
+  \normalfont%
+  \normalsize%
+  \settowidth{\CodeWidthChar}{?}%
+  \settoheight{\CodeHeightChar}{?}%
+}
+
+% Redefining not defined characters, i.e. "Replacement Character" in tex output.
+\def\ucr{\adjustbox{width=\CodeWidthChar,height=\CodeHeightChar}{\stackinset{c}{}{c}{-.2pt}{%
+   \textcolor{white}{\sffamily\bfseries\small ?}}{%
+   \rotatebox{45}{$\blacksquare$}}}}
+
+% Used by @example, @include, @includelineno and @dontinclude
+\newenvironment{DoxyCodeInclude}[1]{%
+	\DoxyCode{#1}%
+}{%
+  \endDoxyCode%
+}
+
+% Used by @verbatim ... @endverbatim
+\newenvironment{DoxyVerb}{%
+  \footnotesize%
+  \verbatim%
+}{%
+  \endverbatim%
+  \normalsize%
+}
+
+% Used by @verbinclude
+\newenvironment{DoxyVerbInclude}{%
+  \DoxyVerb%
+}{%
+  \endDoxyVerb%
+}
+
+% Used by numbered lists (using '-#' or <ol> ... </ol>)
+\newenvironment{DoxyEnumerate}{%
+  \enumerate%
+}{%
+  \endenumerate%
+}
+
+% Used by bullet lists (using '-', @li, @arg, or <ul> ... </ul>)
+\newenvironment{DoxyItemize}{%
+  \itemize%
+}{%
+  \enditemize%
+}
+
+% Used by description lists (using <dl> ... </dl>)
+\newenvironment{DoxyDescription}{%
+  \description%
+}{%
+  \enddescription%
+}
+
+% Used by @image, @dotfile, @dot ... @enddot, and @msc ... @endmsc
+% (only if caption is specified)
+\newenvironment{DoxyImage}{%
+  \begin{figure}[H]%
+    \begin{center}%
+}{%
+    \end{center}%
+  \end{figure}%
+}
+
+% Used by @image, @dotfile, @dot ... @enddot, and @msc ... @endmsc
+% (only if no caption is specified)
+\newenvironment{DoxyImageNoCaption}{%
+  \begin{center}%
+}{%
+  \end{center}%
+}
+
+% Used by @image
+% (only if inline is specified)
+\newenvironment{DoxyInlineImage}{%
+}{%
+}
+
+% Used by @attention
+\newenvironment{DoxyAttention}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @author and @authors
+\newenvironment{DoxyAuthor}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @date
+\newenvironment{DoxyDate}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @invariant
+\newenvironment{DoxyInvariant}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @note
+\newenvironment{DoxyNote}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @post
+\newenvironment{DoxyPostcond}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @pre
+\newenvironment{DoxyPrecond}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @copyright
+\newenvironment{DoxyCopyright}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @remark
+\newenvironment{DoxyRemark}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @return and @returns
+\newenvironment{DoxyReturn}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @since
+\newenvironment{DoxySince}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @see
+\newenvironment{DoxySeeAlso}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @version
+\newenvironment{DoxyVersion}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @warning
+\newenvironment{DoxyWarning}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by @internal
+\newenvironment{DoxyInternal}[1]{%
+  \paragraph*{#1}%
+}{%
+}
+
+% Used by @par and @paragraph
+\newenvironment{DoxyParagraph}[1]{%
+  \begin{DoxyDesc}{#1}%
+}{%
+  \end{DoxyDesc}%
+}
+
+% Used by parameter lists
+\newenvironment{DoxyParams}[2][]{%
+    \tabulinesep=1mm%
+    \par%
+    \ifthenelse{\equal{#1}{}}%
+      {\begin{longtabu*}spread 0pt [l]{|X[-1,l]|X[-1,l]|}}% name + description
+    {\ifthenelse{\equal{#1}{1}}%
+      {\begin{longtabu*}spread 0pt [l]{|X[-1,l]|X[-1,l]|X[-1,l]|}}% in/out + name + desc
+      {\begin{longtabu*}spread 0pt [l]{|X[-1,l]|X[-1,l]|X[-1,l]|X[-1,l]|}}% in/out + type + name + desc
+    }
+    \multicolumn{2}{l}{\hspace{-6pt}\bfseries\fontseries{bc}\selectfont\color{darkgray} #2}\\[1ex]%
+    \hline%
+    \endfirsthead%
+    \multicolumn{2}{l}{\hspace{-6pt}\bfseries\fontseries{bc}\selectfont\color{darkgray} #2}\\[1ex]%
+    \hline%
+    \endhead%
+}{%
+    \end{longtabu*}%
+    \vspace{6pt}%
+}
+
+% Used for fields of simple structs
+\newenvironment{DoxyFields}[1]{%
+    \tabulinesep=1mm%
+    \par%
+    \begin{longtabu*}spread 0pt [l]{|X[-1,r]|X[-1,l]|X[-1,l]|}%
+    \multicolumn{3}{l}{\hspace{-6pt}\bfseries\fontseries{bc}\selectfont\color{darkgray} #1}\\[1ex]%
+    \hline%
+    \endfirsthead%
+    \multicolumn{3}{l}{\hspace{-6pt}\bfseries\fontseries{bc}\selectfont\color{darkgray} #1}\\[1ex]%
+    \hline%
+    \endhead%
+}{%
+    \end{longtabu*}%
+    \vspace{6pt}%
+}
+
+% Used for fields simple class style enums
+\newenvironment{DoxyEnumFields}[1]{%
+    \tabulinesep=1mm%
+    \par%
+    \begin{longtabu*}spread 0pt [l]{|X[-1,r]|X[-1,l]|}%
+    \multicolumn{2}{l}{\hspace{-6pt}\bfseries\fontseries{bc}\selectfont\color{darkgray} #1}\\[1ex]%
+    \hline%
+    \endfirsthead%
+    \multicolumn{2}{l}{\hspace{-6pt}\bfseries\fontseries{bc}\selectfont\color{darkgray} #1}\\[1ex]%
+    \hline%
+    \endhead%
+}{%
+    \end{longtabu*}%
+    \vspace{6pt}%
+}
+
+% Used for parameters within a detailed function description
+\newenvironment{DoxyParamCaption}{%
+  \renewcommand{\item}[2][]{\\ \hspace*{2.0cm} ##1 {\em ##2}}% 
+}{%
+}
+
+% Used by return value lists
+\newenvironment{DoxyRetVals}[1]{%
+    \tabulinesep=1mm%
+    \par%
+    \begin{longtabu*}spread 0pt [l]{|X[-1,r]|X[-1,l]|}%
+    \multicolumn{2}{l}{\hspace{-6pt}\bfseries\fontseries{bc}\selectfont\color{darkgray} #1}\\[1ex]%
+    \hline%
+    \endfirsthead%
+    \multicolumn{2}{l}{\hspace{-6pt}\bfseries\fontseries{bc}\selectfont\color{darkgray} #1}\\[1ex]%
+    \hline%
+    \endhead%
+}{%
+    \end{longtabu*}%
+    \vspace{6pt}%
+}
+
+% Used by exception lists
+\newenvironment{DoxyExceptions}[1]{%
+    \tabulinesep=1mm%
+    \par%
+    \begin{longtabu*}spread 0pt [l]{|X[-1,r]|X[-1,l]|}%
+    \multicolumn{2}{l}{\hspace{-6pt}\bfseries\fontseries{bc}\selectfont\color{darkgray} #1}\\[1ex]%
+    \hline%
+    \endfirsthead%
+    \multicolumn{2}{l}{\hspace{-6pt}\bfseries\fontseries{bc}\selectfont\color{darkgray} #1}\\[1ex]%
+    \hline%
+    \endhead%
+}{%
+    \end{longtabu*}%
+    \vspace{6pt}%
+}
+
+% Used by template parameter lists
+\newenvironment{DoxyTemplParams}[1]{%
+    \tabulinesep=1mm%
+    \par%
+    \begin{longtabu*}spread 0pt [l]{|X[-1,r]|X[-1,l]|}%
+    \multicolumn{2}{l}{\hspace{-6pt}\bfseries\fontseries{bc}\selectfont\color{darkgray} #1}\\[1ex]%
+    \hline%
+    \endfirsthead%
+    \multicolumn{2}{l}{\hspace{-6pt}\bfseries\fontseries{bc}\selectfont\color{darkgray} #1}\\[1ex]%
+    \hline%
+    \endhead%
+}{%
+    \end{longtabu*}%
+    \vspace{6pt}%
+}
+
+% Used for member lists
+\newenvironment{DoxyCompactItemize}{%
+  \begin{itemize}%
+    \setlength{\itemsep}{-3pt}%
+    \setlength{\parsep}{0pt}%
+    \setlength{\topsep}{0pt}%
+    \setlength{\partopsep}{0pt}%
+}{%
+  \end{itemize}%
+}
+
+% Used for member descriptions
+\newenvironment{DoxyCompactList}{%
+  \begin{list}{}{%
+    \setlength{\leftmargin}{0.5cm}%
+    \setlength{\itemsep}{0pt}%
+    \setlength{\parsep}{0pt}%
+    \setlength{\topsep}{0pt}%
+    \renewcommand{\makelabel}{\hfill}%
+  }%
+}{%
+  \end{list}%
+}
+
+% Used for reference lists (@bug, @deprecated, @todo, etc.)
+\newenvironment{DoxyRefList}{%
+  \begin{list}{}{%
+    \setlength{\labelwidth}{10pt}%
+    \setlength{\leftmargin}{\labelwidth}%
+    \addtolength{\leftmargin}{\labelsep}%
+    \renewcommand{\makelabel}{\xreflabel}%
+  }%
+}{%
+  \end{list}%
+}
+
+% Used by @bug, @deprecated, @todo, etc.
+\newenvironment{DoxyRefDesc}[1]{%
+  \begin{list}{}{%
+    \renewcommand\makelabel[1]{\textbf{##1}}%
+    \settowidth\labelwidth{\makelabel{#1}}%
+    \setlength\leftmargin{\labelwidth+\labelsep}%
+  }%
+}{%
+  \end{list}%
+}
+
+% Used by parameter lists and simple sections
+\newenvironment{Desc}
+{\begin{list}{}{%
+    \settowidth{\labelwidth}{20pt}%
+    \setlength{\parsep}{0pt}%
+    \setlength{\itemsep}{0pt}%
+    \setlength{\leftmargin}{\labelwidth+\labelsep}%
+    \renewcommand{\makelabel}{\entrylabel}%
+  }
+}{%
+  \end{list}%
+}
+
+% Used by tables
+\newcommand{\PBS}[1]{\let\temp=\\#1\let\\=\temp}%
+\newenvironment{TabularC}[1]%
+{\tabulinesep=1mm
+\begin{longtabu*}spread 0pt [c]{*#1{|X[-1]}|}}%
+{\end{longtabu*}\par}%
+
+\newenvironment{TabularNC}[1]%
+{\begin{tabu}spread 0pt [l]{*#1{|X[-1]}|}}%
+{\end{tabu}\par}%
+
+% Used for member group headers
+\newenvironment{Indent}{%
+  \begin{list}{}{%
+    \setlength{\leftmargin}{0.5cm}%
+  }%
+  \item[]\ignorespaces%
+}{%
+  \unskip%
+  \end{list}%
+}
+
+% Used when hyperlinks are turned off
+\newcommand{\doxyref}[3]{%
+  \textbf{#1} (\textnormal{#2}\,\pageref{#3})%
+}
+
+% Used to link to a table when hyperlinks are turned on
+\newcommand{\doxytablelink}[2]{%
+  \ref{#1}%
+}
+
+% Used to link to a table when hyperlinks are turned off
+\newcommand{\doxytableref}[3]{%
+  \ref{#3}%
+}
+
+% Used by @addindex
+\newcommand{\lcurly}{\{}
+\newcommand{\rcurly}{\}}
+
+% Colors used for syntax highlighting
+\definecolor{comment}{rgb}{0.5,0.0,0.0}
+\definecolor{keyword}{rgb}{0.0,0.5,0.0}
+\definecolor{keywordtype}{rgb}{0.38,0.25,0.125}
+\definecolor{keywordflow}{rgb}{0.88,0.5,0.0}
+\definecolor{preprocessor}{rgb}{0.5,0.38,0.125}
+\definecolor{stringliteral}{rgb}{0.0,0.125,0.25}
+\definecolor{charliteral}{rgb}{0.0,0.5,0.5}
+\definecolor{vhdldigit}{rgb}{1.0,0.0,1.0}
+\definecolor{vhdlkeyword}{rgb}{0.43,0.0,0.43}
+\definecolor{vhdllogic}{rgb}{1.0,0.0,0.0}
+\definecolor{vhdlchar}{rgb}{0.0,0.0,0.0}
+
+% Color used for table heading
+\newcommand{\tableheadbgcolor}{lightgray}%
+
+% Version of hypertarget with correct landing location
+\newcommand{\Hypertarget}[1]{\Hy@raisedlink{\hypertarget{#1}{}}}
+
+% possibility to have sections etc. be within the margins
+% unfortunately had to copy part of book.cls and add \raggedright
+\makeatletter
+\newcommand\doxysection{\@startsection {section}{1}{\z@}%
+                                   {-3.5ex \@plus -1ex \@minus -.2ex}%
+                                   {2.3ex \@plus.2ex}%
+                                   {\raggedright\normalfont\Large\bfseries}}
+\newcommand\doxysubsection{\@startsection{subsection}{2}{\z@}%
+                                     {-3.25ex\@plus -1ex \@minus -.2ex}%
+                                     {1.5ex \@plus .2ex}%
+                                     {\raggedright\normalfont\large\bfseries}}
+\newcommand\doxysubsubsection{\@startsection{subsubsection}{3}{\z@}%
+                                     {-3.25ex\@plus -1ex \@minus -.2ex}%
+                                     {1.5ex \@plus .2ex}%
+                                     {\raggedright\normalfont\normalsize\bfseries}}
+\newcommand\doxyparagraph{\@startsection{paragraph}{4}{\z@}%
+                                    {3.25ex \@plus1ex \@minus.2ex}%
+                                    {-1em}%
+                                    {\raggedright\normalfont\normalsize\bfseries}}
+\newcommand\doxysubparagraph{\@startsection{subparagraph}{5}{\parindent}%
+                                       {3.25ex \@plus1ex \@minus .2ex}%
+                                       {-1em}%
+                                      {\raggedright\normalfont\normalsize\bfseries}}
+\makeatother
+% Define caption that is also suitable in a table
+\makeatletter
+\def\doxyfigcaption{%
+\refstepcounter{figure}%
+\@dblarg{\@caption{figure}}}
+\makeatother
diff --git a/week4/softwareEng_9_4/app/latex/files.tex b/week4/softwareEng_9_4/app/latex/files.tex
new file mode 100644
index 00000000..518615fa
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/files.tex
@@ -0,0 +1,5 @@
+\doxysection{File List}
+Here is a list of all files with brief descriptions\+:\begin{DoxyCompactList}
+\item\contentsline{section}{\mbox{\hyperlink{software_eng__9__4_8cpp}{software\+Eng\+\_\+9\+\_\+4.\+cpp}} }{\pageref{software_eng__9__4_8cpp}}{}
+\item\contentsline{section}{\mbox{\hyperlink{software_eng__9__4_8hpp}{software\+Eng\+\_\+9\+\_\+4.\+hpp}} }{\pageref{software_eng__9__4_8hpp}}{}
+\end{DoxyCompactList}
diff --git a/week4/softwareEng_9_4/app/latex/longtable_doxygen.sty b/week4/softwareEng_9_4/app/latex/longtable_doxygen.sty
new file mode 100644
index 00000000..a0eb314f
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/longtable_doxygen.sty
@@ -0,0 +1,448 @@
+%%
+%% This is file `longtable.sty',
+%% generated with the docstrip utility.
+%%
+%% The original source files were:
+%%
+%% longtable.dtx  (with options: `package')
+%% 
+%% This is a generated file.
+%% 
+%% The source is maintained by the LaTeX Project team and bug
+%% reports for it can be opened at http://latex-project.org/bugs.html
+%% (but please observe conditions on bug reports sent to that address!)
+%% 
+%% Copyright 1993-2016
+%% The LaTeX3 Project and any individual authors listed elsewhere
+%% in this file.
+%% 
+%% This file was generated from file(s) of the Standard LaTeX `Tools Bundle'.
+%% --------------------------------------------------------------------------
+%% 
+%% It may be distributed and/or modified under the
+%% conditions of the LaTeX Project Public License, either version 1.3c
+%% of this license or (at your option) any later version.
+%% The latest version of this license is in
+%%    http://www.latex-project.org/lppl.txt
+%% and version 1.3c or later is part of all distributions of LaTeX
+%% version 2005/12/01 or later.
+%% 
+%% This file may only be distributed together with a copy of the LaTeX
+%% `Tools Bundle'. You may however distribute the LaTeX `Tools Bundle'
+%% without such generated files.
+%% 
+%% The list of all files belonging to the LaTeX `Tools Bundle' is
+%% given in the file `manifest.txt'.
+%% 
+%% File: longtable.dtx Copyright (C) 1990-2001 David Carlisle
+\NeedsTeXFormat{LaTeX2e}[1995/06/01]
+\ProvidesPackage{longtable_doxygen}
+          [2014/10/28 v4.11 Multi-page Table package (DPC) - frozen version for doxygen]
+\def\LT@err{\PackageError{longtable}}
+\def\LT@warn{\PackageWarning{longtable}}
+\def\LT@final@warn{%
+  \AtEndDocument{%
+    \LT@warn{Table \@width s have changed. Rerun LaTeX.\@gobbletwo}}%
+  \global\let\LT@final@warn\relax}
+\DeclareOption{errorshow}{%
+  \def\LT@warn{\PackageInfo{longtable}}}
+\DeclareOption{pausing}{%
+  \def\LT@warn#1{%
+    \LT@err{#1}{This is not really an error}}}
+\DeclareOption{set}{}
+\DeclareOption{final}{}
+\ProcessOptions
+\newskip\LTleft       \LTleft=\fill
+\newskip\LTright      \LTright=\fill
+\newskip\LTpre        \LTpre=\bigskipamount
+\newskip\LTpost       \LTpost=\bigskipamount
+\newcount\LTchunksize \LTchunksize=20
+\let\c@LTchunksize\LTchunksize
+\newdimen\LTcapwidth  \LTcapwidth=4in
+\newbox\LT@head
+\newbox\LT@firsthead
+\newbox\LT@foot
+\newbox\LT@lastfoot
+\newcount\LT@cols
+\newcount\LT@rows
+\newcounter{LT@tables}
+\newcounter{LT@chunks}[LT@tables]
+\ifx\c@table\undefined
+  \newcounter{table}
+  \def\fnum@table{\tablename~\thetable}
+\fi
+\ifx\tablename\undefined
+  \def\tablename{Table}
+\fi
+\newtoks\LT@p@ftn
+\mathchardef\LT@end@pen=30000
+\def\longtable{%
+  \par
+  \ifx\multicols\@undefined
+  \else
+     \ifnum\col@number>\@ne
+       \@twocolumntrue
+     \fi
+  \fi
+  \if@twocolumn
+    \LT@err{longtable not in 1-column mode}\@ehc
+  \fi
+  \begingroup
+  \@ifnextchar[\LT@array{\LT@array[x]}}
+\def\LT@array[#1]#2{%
+  \refstepcounter{table}\stepcounter{LT@tables}%
+  \if l#1%
+    \LTleft\z@ \LTright\fill
+  \else\if r#1%
+    \LTleft\fill \LTright\z@
+  \else\if c#1%
+    \LTleft\fill \LTright\fill
+  \fi\fi\fi
+  \let\LT@mcol\multicolumn
+  \let\LT@@tabarray\@tabarray
+  \let\LT@@hl\hline
+  \def\@tabarray{%
+    \let\hline\LT@@hl
+    \LT@@tabarray}%
+  \let\\\LT@tabularcr\let\tabularnewline\\%
+  \def\newpage{\noalign{\break}}%
+  \def\pagebreak{\noalign{\ifnum`}=0\fi\@testopt{\LT@no@pgbk-}4}%
+  \def\nopagebreak{\noalign{\ifnum`}=0\fi\@testopt\LT@no@pgbk4}%
+  \let\hline\LT@hline \let\kill\LT@kill\let\caption\LT@caption
+  \@tempdima\ht\strutbox
+  \let\@endpbox\LT@endpbox
+  \ifx\extrarowheight\@undefined
+    \let\@acol\@tabacol
+    \let\@classz\@tabclassz \let\@classiv\@tabclassiv
+    \def\@startpbox{\vtop\LT@startpbox}%
+    \let\@@startpbox\@startpbox
+    \let\@@endpbox\@endpbox
+    \let\LT@LL@FM@cr\@tabularcr
+  \else
+    \advance\@tempdima\extrarowheight
+    \col@sep\tabcolsep
+    \let\@startpbox\LT@startpbox\let\LT@LL@FM@cr\@arraycr
+  \fi
+  \setbox\@arstrutbox\hbox{\vrule
+    \@height \arraystretch \@tempdima
+    \@depth \arraystretch \dp \strutbox
+    \@width \z@}%
+  \let\@sharp##\let\protect\relax
+   \begingroup
+    \@mkpream{#2}%
+    \xdef\LT@bchunk{%
+       \global\advance\c@LT@chunks\@ne
+       \global\LT@rows\z@\setbox\z@\vbox\bgroup
+       \LT@setprevdepth
+       \tabskip\LTleft \noexpand\halign to\hsize\bgroup
+      \tabskip\z@ \@arstrut \@preamble \tabskip\LTright \cr}%
+  \endgroup
+  \expandafter\LT@nofcols\LT@bchunk&\LT@nofcols
+  \LT@make@row
+  \m@th\let\par\@empty
+  \everycr{}\lineskip\z@\baselineskip\z@
+  \LT@bchunk}
+\def\LT@no@pgbk#1[#2]{\penalty #1\@getpen{#2}\ifnum`{=0\fi}}
+\def\LT@start{%
+  \let\LT@start\endgraf
+  \endgraf\penalty\z@\vskip\LTpre
+  \dimen@\pagetotal
+  \advance\dimen@ \ht\ifvoid\LT@firsthead\LT@head\else\LT@firsthead\fi
+  \advance\dimen@ \dp\ifvoid\LT@firsthead\LT@head\else\LT@firsthead\fi
+  \advance\dimen@ \ht\LT@foot
+  \dimen@ii\vfuzz
+  \vfuzz\maxdimen
+    \setbox\tw@\copy\z@
+    \setbox\tw@\vsplit\tw@ to \ht\@arstrutbox
+    \setbox\tw@\vbox{\unvbox\tw@}%
+  \vfuzz\dimen@ii
+  \advance\dimen@ \ht
+        \ifdim\ht\@arstrutbox>\ht\tw@\@arstrutbox\else\tw@\fi
+  \advance\dimen@\dp
+        \ifdim\dp\@arstrutbox>\dp\tw@\@arstrutbox\else\tw@\fi
+  \advance\dimen@ -\pagegoal
+  \ifdim \dimen@>\z@\vfil\break\fi
+      \global\@colroom\@colht
+  \ifvoid\LT@foot\else
+    \advance\vsize-\ht\LT@foot
+    \global\advance\@colroom-\ht\LT@foot
+    \dimen@\pagegoal\advance\dimen@-\ht\LT@foot\pagegoal\dimen@
+    \maxdepth\z@
+  \fi
+  \ifvoid\LT@firsthead\copy\LT@head\else\box\LT@firsthead\fi\nobreak
+  \output{\LT@output}}
+\def\endlongtable{%
+  \crcr
+  \noalign{%
+    \let\LT@entry\LT@entry@chop
+    \xdef\LT@save@row{\LT@save@row}}%
+  \LT@echunk
+  \LT@start
+  \unvbox\z@
+  \LT@get@widths
+  \if@filesw
+    {\let\LT@entry\LT@entry@write\immediate\write\@auxout{%
+      \gdef\expandafter\noexpand
+        \csname LT@\romannumeral\c@LT@tables\endcsname
+          {\LT@save@row}}}%
+  \fi
+  \ifx\LT@save@row\LT@@save@row
+  \else
+    \LT@warn{Column \@width s have changed\MessageBreak
+             in table \thetable}%
+    \LT@final@warn
+  \fi
+  \endgraf\penalty -\LT@end@pen
+  \endgroup
+  \global\@mparbottom\z@
+  \pagegoal\vsize
+  \endgraf\penalty\z@\addvspace\LTpost
+  \ifvoid\footins\else\insert\footins{}\fi}
+\def\LT@nofcols#1&{%
+  \futurelet\@let@token\LT@n@fcols}
+\def\LT@n@fcols{%
+  \advance\LT@cols\@ne
+  \ifx\@let@token\LT@nofcols
+    \expandafter\@gobble
+  \else
+    \expandafter\LT@nofcols
+  \fi}
+\def\LT@tabularcr{%
+  \relax\iffalse{\fi\ifnum0=`}\fi
+  \@ifstar
+    {\def\crcr{\LT@crcr\noalign{\nobreak}}\let\cr\crcr
+     \LT@t@bularcr}%
+    {\LT@t@bularcr}}
+\let\LT@crcr\crcr
+\let\LT@setprevdepth\relax
+\def\LT@t@bularcr{%
+  \global\advance\LT@rows\@ne
+  \ifnum\LT@rows=\LTchunksize
+    \gdef\LT@setprevdepth{%
+      \prevdepth\z@\global
+      \global\let\LT@setprevdepth\relax}%
+    \expandafter\LT@xtabularcr
+  \else
+    \ifnum0=`{}\fi
+    \expandafter\LT@LL@FM@cr
+  \fi}
+\def\LT@xtabularcr{%
+  \@ifnextchar[\LT@argtabularcr\LT@ntabularcr}
+\def\LT@ntabularcr{%
+  \ifnum0=`{}\fi
+  \LT@echunk
+  \LT@start
+  \unvbox\z@
+  \LT@get@widths
+  \LT@bchunk}
+\def\LT@argtabularcr[#1]{%
+  \ifnum0=`{}\fi
+  \ifdim #1>\z@
+    \unskip\@xargarraycr{#1}%
+  \else
+    \@yargarraycr{#1}%
+  \fi
+  \LT@echunk
+  \LT@start
+  \unvbox\z@
+  \LT@get@widths
+  \LT@bchunk}
+\def\LT@echunk{%
+  \crcr\LT@save@row\cr\egroup
+  \global\setbox\@ne\lastbox
+    \unskip
+  \egroup}
+\def\LT@entry#1#2{%
+  \ifhmode\@firstofone{&}\fi\omit
+  \ifnum#1=\c@LT@chunks
+  \else
+    \kern#2\relax
+  \fi}
+\def\LT@entry@chop#1#2{%
+  \noexpand\LT@entry
+    {\ifnum#1>\c@LT@chunks
+       1}{0pt%
+     \else
+       #1}{#2%
+     \fi}}
+\def\LT@entry@write{%
+  \noexpand\LT@entry^^J%
+  \@spaces}
+\def\LT@kill{%
+  \LT@echunk
+  \LT@get@widths
+  \expandafter\LT@rebox\LT@bchunk}
+\def\LT@rebox#1\bgroup{%
+  #1\bgroup
+  \unvbox\z@
+  \unskip
+  \setbox\z@\lastbox}
+\def\LT@blank@row{%
+  \xdef\LT@save@row{\expandafter\LT@build@blank
+    \romannumeral\number\LT@cols 001 }}
+\def\LT@build@blank#1{%
+  \if#1m%
+    \noexpand\LT@entry{1}{0pt}%
+    \expandafter\LT@build@blank
+  \fi}
+\def\LT@make@row{%
+  \global\expandafter\let\expandafter\LT@save@row
+    \csname LT@\romannumeral\c@LT@tables\endcsname
+  \ifx\LT@save@row\relax
+    \LT@blank@row
+  \else
+    {\let\LT@entry\or
+     \if!%
+         \ifcase\expandafter\expandafter\expandafter\LT@cols
+         \expandafter\@gobble\LT@save@row
+         \or
+         \else
+           \relax
+         \fi
+        !%
+     \else
+       \aftergroup\LT@blank@row
+     \fi}%
+  \fi}
+\let\setlongtables\relax
+\def\LT@get@widths{%
+  \setbox\tw@\hbox{%
+    \unhbox\@ne
+    \let\LT@old@row\LT@save@row
+    \global\let\LT@save@row\@empty
+    \count@\LT@cols
+    \loop
+      \unskip
+      \setbox\tw@\lastbox
+    \ifhbox\tw@
+      \LT@def@row
+      \advance\count@\m@ne
+    \repeat}%
+  \ifx\LT@@save@row\@undefined
+    \let\LT@@save@row\LT@save@row
+  \fi}
+\def\LT@def@row{%
+  \let\LT@entry\or
+  \edef\@tempa{%
+    \ifcase\expandafter\count@\LT@old@row
+    \else
+      {1}{0pt}%
+    \fi}%
+  \let\LT@entry\relax
+  \xdef\LT@save@row{%
+    \LT@entry
+    \expandafter\LT@max@sel\@tempa
+    \LT@save@row}}
+\def\LT@max@sel#1#2{%
+  {\ifdim#2=\wd\tw@
+     #1%
+   \else
+     \number\c@LT@chunks
+   \fi}%
+  {\the\wd\tw@}}
+\def\LT@hline{%
+  \noalign{\ifnum0=`}\fi
+    \penalty\@M
+    \futurelet\@let@token\LT@@hline}
+\def\LT@@hline{%
+  \ifx\@let@token\hline
+    \global\let\@gtempa\@gobble
+    \gdef\LT@sep{\penalty-\@medpenalty\vskip\doublerulesep}%
+  \else
+    \global\let\@gtempa\@empty
+    \gdef\LT@sep{\penalty-\@lowpenalty\vskip-\arrayrulewidth}%
+  \fi
+  \ifnum0=`{\fi}%
+  \multispan\LT@cols
+     \unskip\leaders\hrule\@height\arrayrulewidth\hfill\cr
+  \noalign{\LT@sep}%
+  \multispan\LT@cols
+     \unskip\leaders\hrule\@height\arrayrulewidth\hfill\cr
+  \noalign{\penalty\@M}%
+  \@gtempa}
+\def\LT@caption{%
+  \noalign\bgroup
+    \@ifnextchar[{\egroup\LT@c@ption\@firstofone}\LT@capti@n}
+\def\LT@c@ption#1[#2]#3{%
+  \LT@makecaption#1\fnum@table{#3}%
+  \def\@tempa{#2}%
+  \ifx\@tempa\@empty\else
+     {\let\\\space
+     \addcontentsline{lot}{table}{\protect\numberline{\thetable}{#2}}}%
+  \fi}
+\def\LT@capti@n{%
+  \@ifstar
+    {\egroup\LT@c@ption\@gobble[]}%
+    {\egroup\@xdblarg{\LT@c@ption\@firstofone}}}
+\def\LT@makecaption#1#2#3{%
+  \LT@mcol\LT@cols c{\hbox to\z@{\hss\parbox[t]\LTcapwidth{%
+    \sbox\@tempboxa{#1{#2: }#3}%
+    \ifdim\wd\@tempboxa>\hsize
+      #1{#2: }#3%
+    \else
+      \hbox to\hsize{\hfil\box\@tempboxa\hfil}%
+    \fi
+    \endgraf\vskip\baselineskip}%
+  \hss}}}
+\def\LT@output{%
+  \ifnum\outputpenalty <-\@Mi
+    \ifnum\outputpenalty > -\LT@end@pen
+      \LT@err{floats and marginpars not allowed in a longtable}\@ehc
+    \else
+      \setbox\z@\vbox{\unvbox\@cclv}%
+      \ifdim \ht\LT@lastfoot>\ht\LT@foot
+        \dimen@\pagegoal
+        \advance\dimen@-\ht\LT@lastfoot
+        \ifdim\dimen@<\ht\z@
+          \setbox\@cclv\vbox{\unvbox\z@\copy\LT@foot\vss}%
+          \@makecol
+          \@outputpage
+          \setbox\z@\vbox{\box\LT@head}%
+        \fi
+      \fi
+      \global\@colroom\@colht
+      \global\vsize\@colht
+      \vbox
+        {\unvbox\z@\box\ifvoid\LT@lastfoot\LT@foot\else\LT@lastfoot\fi}%
+    \fi
+  \else
+    \setbox\@cclv\vbox{\unvbox\@cclv\copy\LT@foot\vss}%
+    \@makecol
+    \@outputpage
+      \global\vsize\@colroom
+    \copy\LT@head\nobreak
+  \fi}
+\def\LT@end@hd@ft#1{%
+  \LT@echunk
+  \ifx\LT@start\endgraf
+    \LT@err
+     {Longtable head or foot not at start of table}%
+     {Increase LTchunksize}%
+  \fi
+  \setbox#1\box\z@
+  \LT@get@widths
+  \LT@bchunk}
+\def\endfirsthead{\LT@end@hd@ft\LT@firsthead}
+\def\endhead{\LT@end@hd@ft\LT@head}
+\def\endfoot{\LT@end@hd@ft\LT@foot}
+\def\endlastfoot{\LT@end@hd@ft\LT@lastfoot}
+\def\LT@startpbox#1{%
+  \bgroup
+    \let\@footnotetext\LT@p@ftntext
+    \setlength\hsize{#1}%
+    \@arrayparboxrestore
+    \vrule \@height \ht\@arstrutbox \@width \z@}
+\def\LT@endpbox{%
+  \@finalstrut\@arstrutbox
+  \egroup
+  \the\LT@p@ftn
+  \global\LT@p@ftn{}%
+  \hfil}
+\def\LT@p@ftntext#1{%
+  \edef\@tempa{\the\LT@p@ftn\noexpand\footnotetext[\the\c@footnote]}%
+  \global\LT@p@ftn\expandafter{\@tempa{#1}}}%
+
+\@namedef{ver@longtable.sty}{2014/10/28 v4.11 Multi-page Table package (DPC) - frozen version for doxygen}
+\endinput
+%%
+%% End of file `longtable.sty'.
diff --git a/week4/softwareEng_9_4/app/latex/refman.tex b/week4/softwareEng_9_4/app/latex/refman.tex
new file mode 100644
index 00000000..4cef9711
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/refman.tex
@@ -0,0 +1,193 @@
+\let\mypdfximage\pdfximage\def\pdfximage{\immediate\mypdfximage}\documentclass[twoside]{book}
+
+%% moved from doxygen.sty due to workaround for LaTex 2019 version and unmaintained tabu package
+\usepackage{ifthen}
+\ifx\requestedLaTeXdate\undefined
+\usepackage{array}
+\else
+\usepackage{array}[=2016-10-06]
+\fi
+%%
+% Packages required by doxygen
+\usepackage{fixltx2e}
+\usepackage{calc}
+\usepackage{doxygen}
+\usepackage{graphicx}
+\usepackage[utf8]{inputenc}
+\usepackage{makeidx}
+\usepackage{multicol}
+\usepackage{multirow}
+\PassOptionsToPackage{warn}{textcomp}
+\usepackage{textcomp}
+\usepackage[nointegrals]{wasysym}
+\usepackage[table]{xcolor}
+\usepackage{ifpdf,ifxetex}
+
+% Font selection
+\usepackage[T1]{fontenc}
+\usepackage[scaled=.90]{helvet}
+\usepackage{courier}
+\usepackage{amssymb}
+\usepackage{sectsty}
+\renewcommand{\familydefault}{\sfdefault}
+\allsectionsfont{%
+  \fontseries{bc}\selectfont%
+  \color{darkgray}%
+}
+\renewcommand{\DoxyLabelFont}{%
+  \fontseries{bc}\selectfont%
+  \color{darkgray}%
+}
+\newcommand{\+}{\discretionary{\mbox{\scriptsize$\hookleftarrow$}}{}{}}
+
+% Arguments of doxygenemoji:
+% 1) ':<text>:' form of the emoji, already "LaTeX"-escaped
+% 2) file with the name of the emoji without the .png extension
+% in case image exist use this otherwise use the ':<text>:' form
+\newcommand{\doxygenemoji}[2]{%
+  \IfFileExists{./#2.png}{\raisebox{-0.1em}{\includegraphics[height=0.9em]{./#2.png}}}{#1}%
+}
+% Page & text layout
+\usepackage{geometry}
+\geometry{%
+  a4paper,%
+  top=2.5cm,%
+  bottom=2.5cm,%
+  left=2.5cm,%
+  right=2.5cm%
+}
+\tolerance=750
+\hfuzz=15pt
+\hbadness=750
+\setlength{\emergencystretch}{15pt}
+\setlength{\parindent}{0cm}
+\newcommand{\doxynormalparskip}{\setlength{\parskip}{3ex plus 2ex minus 2ex}}
+\newcommand{\doxytocparskip}{\setlength{\parskip}{1ex plus 0ex minus 0ex}}
+\doxynormalparskip
+\makeatletter
+\renewcommand{\paragraph}{%
+  \@startsection{paragraph}{4}{0ex}{-1.0ex}{1.0ex}{%
+    \normalfont\normalsize\bfseries\SS@parafont%
+  }%
+}
+\renewcommand{\subparagraph}{%
+  \@startsection{subparagraph}{5}{0ex}{-1.0ex}{1.0ex}{%
+    \normalfont\normalsize\bfseries\SS@subparafont%
+  }%
+}
+\makeatother
+
+\makeatletter
+\newcommand\hrulefilll{\leavevmode\leaders\hrule\hskip 0pt plus 1filll\kern\z@}
+\makeatother
+
+% Headers & footers
+\usepackage{fancyhdr}
+\pagestyle{fancyplain}
+\fancyhead[LE]{\fancyplain{}{\bfseries\thepage}}
+\fancyhead[CE]{\fancyplain{}{}}
+\fancyhead[RE]{\fancyplain{}{\bfseries\leftmark}}
+\fancyhead[LO]{\fancyplain{}{\bfseries\rightmark}}
+\fancyhead[CO]{\fancyplain{}{}}
+\fancyhead[RO]{\fancyplain{}{\bfseries\thepage}}
+\fancyfoot[LE]{\fancyplain{}{}}
+\fancyfoot[CE]{\fancyplain{}{}}
+\fancyfoot[RE]{\fancyplain{}{\bfseries\scriptsize Generated by Doxygen }}
+\fancyfoot[LO]{\fancyplain{}{\bfseries\scriptsize Generated by Doxygen }}
+\fancyfoot[CO]{\fancyplain{}{}}
+\fancyfoot[RO]{\fancyplain{}{}}
+\renewcommand{\footrulewidth}{0.4pt}
+\renewcommand{\chaptermark}[1]{%
+  \markboth{#1}{}%
+}
+\renewcommand{\sectionmark}[1]{%
+  \markright{\thesection\ #1}%
+}
+
+% Indices & bibliography
+\usepackage{natbib}
+\usepackage[titles]{tocloft}
+\setcounter{tocdepth}{3}
+\setcounter{secnumdepth}{5}
+\makeindex
+
+\usepackage{newunicodechar}
+  \newunicodechar{⁻}{${}^{-}$}% Superscript minus
+  \newunicodechar{²}{${}^{2}$}% Superscript two
+  \newunicodechar{³}{${}^{3}$}% Superscript three
+
+% Hyperlinks (required, but should be loaded last)
+\ifpdf
+  \usepackage[pdftex,pagebackref=true]{hyperref}
+\else
+  \ifxetex
+    \usepackage[pagebackref=true]{hyperref}
+  \else
+    \usepackage[ps2pdf,pagebackref=true]{hyperref}
+  \fi
+\fi
+
+\hypersetup{%
+  colorlinks=true,%
+  linkcolor=blue,%
+  citecolor=blue,%
+  unicode%
+}
+
+% Custom commands
+\newcommand{\clearemptydoublepage}{%
+  \newpage{\pagestyle{empty}\cleardoublepage}%
+}
+
+\usepackage{caption}
+\captionsetup{labelsep=space,justification=centering,font={bf},singlelinecheck=off,skip=4pt,position=top}
+
+\usepackage{etoc}
+\etocsettocstyle{\doxytocparskip}{\doxynormalparskip}
+\renewcommand{\numberline}[1]{#1~}
+%===== C O N T E N T S =====
+
+\begin{document}
+
+% Titlepage & ToC
+\hypersetup{pageanchor=false,
+             bookmarksnumbered=true,
+             pdfencoding=unicode
+            }
+\pagenumbering{alph}
+\begin{titlepage}
+\vspace*{7cm}
+\begin{center}%
+{\Large Print\+Position }\\
+\vspace*{1cm}
+{\large Generated by Doxygen 1.8.17}\\
+\end{center}
+\end{titlepage}
+\clearemptydoublepage
+\pagenumbering{roman}
+\tableofcontents
+\clearemptydoublepage
+\pagenumbering{arabic}
+\hypersetup{pageanchor=true}
+
+%--- Begin generated contents ---
+\chapter{Class Index}
+\input{annotated}
+\chapter{File Index}
+\input{files}
+\chapter{Class Documentation}
+\input{classprinter}
+\chapter{File Documentation}
+\input{software_eng__9__4_8cpp}
+\input{software_eng__9__4_8hpp}
+%--- End generated contents ---
+
+% Index
+\backmatter
+\newpage
+\phantomsection
+\clearemptydoublepage
+\addcontentsline{toc}{chapter}{\indexname}
+\printindex
+
+\end{document}
diff --git a/week4/softwareEng_9_4/app/latex/result.zip b/week4/softwareEng_9_4/app/latex/result.zip
new file mode 100644
index 0000000000000000000000000000000000000000..00dd120f5b30677808e8a6e621ed40022e98c0b2
GIT binary patch
literal 41464
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

literal 0
HcmV?d00001

diff --git a/week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp.tex b/week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp.tex
new file mode 100644
index 00000000..2e4f7383
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp.tex
@@ -0,0 +1,4 @@
+\hypertarget{software_eng__9__4_8cpp}{}\doxysection{software\+Eng\+\_\+9\+\_\+4.\+cpp File Reference}
+\label{software_eng__9__4_8cpp}\index{softwareEng\_9\_4.cpp@{softwareEng\_9\_4.cpp}}
+{\ttfamily \#include \char`\"{}software\+Eng\+\_\+9\+\_\+4.\+hpp\char`\"{}}\newline
+Include dependency graph for software\+Eng\+\_\+9\+\_\+4.\+cpp\+:
diff --git a/week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp.tex.tmp b/week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp.tex.tmp
new file mode 100644
index 00000000..bf6d0497
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp.tex.tmp
@@ -0,0 +1,19 @@
+\hypertarget{software_eng__9__4_8cpp}{}\doxysection{software\+Eng\+\_\+9\+\_\+4.\+cpp File Reference}
+\label{software_eng__9__4_8cpp}\index{softwareEng\_9\_4.cpp@{softwareEng\_9\_4.cpp}}
+{\ttfamily \#include \char`\"{}software\+Eng\+\_\+9\+\_\+4.\+hpp\char`\"{}}\newline
+Include dependency graph for software\+Eng\+\_\+9\+\_\+4.\+cpp\+:
+% FIG 0
+\doxysubsection*{Functions}
+\begin{DoxyCompactItemize}
+\item 
+int \mbox{\hyperlink{software_eng__9__4_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4}{main}} ()
+\end{DoxyCompactItemize}
+
+
+\doxysubsection{Function Documentation}
+\mbox{\Hypertarget{software_eng__9__4_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4}\label{software_eng__9__4_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4}} 
+\index{softwareEng\_9\_4.cpp@{softwareEng\_9\_4.cpp}!main@{main}}
+\index{main@{main}!softwareEng\_9\_4.cpp@{softwareEng\_9\_4.cpp}}
+\doxysubsubsection{\texorpdfstring{main()}{main()}}
+{\footnotesize\ttfamily int main (\begin{DoxyParamCaption}{ }\end{DoxyParamCaption})}
+
diff --git a/week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp__incl.dot b/week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp__incl.dot
new file mode 100644
index 00000000..430ae118
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/software_eng__9__4_8cpp__incl.dot
@@ -0,0 +1,17 @@
+digraph "softwareEng_9_4.cpp"
+{
+ // LATEX_PDF_SIZE
+  edge [fontname="Helvetica",fontsize="10",labelfontname="Helvetica",labelfontsize="10"];
+  node [fontname="Helvetica",fontsize="10",shape=record];
+  Node1 [label="softwareEng_9_4.cpp",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled", fontcolor="black",tooltip=" "];
+  Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid"];
+  Node2 [label="softwareEng_9_4.hpp",height=0.2,width=0.4,color="black", fillcolor="white", style="filled",URL="$software_eng__9__4_8hpp.html",tooltip=" "];
+  Node2 -> Node3 [color="midnightblue",fontsize="10",style="solid"];
+  Node3 [label="iostream",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+  Node2 -> Node4 [color="midnightblue",fontsize="10",style="solid"];
+  Node4 [label="string",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+  Node2 -> Node5 [color="midnightblue",fontsize="10",style="solid"];
+  Node5 [label="vector",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+  Node2 -> Node6 [color="midnightblue",fontsize="10",style="solid"];
+  Node6 [label="numeric",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+}
diff --git a/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp.tex b/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp.tex
new file mode 100644
index 00000000..e7e5d6d9
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp.tex
@@ -0,0 +1,15 @@
+\hypertarget{software_eng__9__4_8hpp}{}\doxysection{software\+Eng\+\_\+9\+\_\+4.\+hpp File Reference}
+\label{software_eng__9__4_8hpp}\index{softwareEng\_9\_4.hpp@{softwareEng\_9\_4.hpp}}
+{\ttfamily \#include $<$iostream$>$}\newline
+{\ttfamily \#include $<$string$>$}\newline
+{\ttfamily \#include $<$vector$>$}\newline
+{\ttfamily \#include $<$numeric$>$}\newline
+Include dependency graph for software\+Eng\+\_\+9\+\_\+4.\+hpp\+:
+% FIG 0
+This graph shows which files directly or indirectly include this file\+:
+% FIG 1
+\doxysubsection*{Classes}
+\begin{DoxyCompactItemize}
+\item 
+class \mbox{\hyperlink{classprinter}{printer}}
+\begin{DoxyCompactList}\small\item\em printer is a class to extract a new method from printposition, The motivation behind solving this problem is to implement method extraction for code refractory using input method \end{DoxyCompactList}\end{DoxyCompactItemize}
diff --git a/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp__dep__incl.dot b/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp__dep__incl.dot
new file mode 100644
index 00000000..5ddd4d12
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp__dep__incl.dot
@@ -0,0 +1,9 @@
+digraph "softwareEng_9_4.hpp"
+{
+ // LATEX_PDF_SIZE
+  edge [fontname="Helvetica",fontsize="10",labelfontname="Helvetica",labelfontsize="10"];
+  node [fontname="Helvetica",fontsize="10",shape=record];
+  Node1 [label="softwareEng_9_4.hpp",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled", fontcolor="black",tooltip=" "];
+  Node1 -> Node2 [dir="back",color="midnightblue",fontsize="10",style="solid"];
+  Node2 [label="softwareEng_9_4.cpp",height=0.2,width=0.4,color="black", fillcolor="white", style="filled",URL="$software_eng__9__4_8cpp.html",tooltip=" "];
+}
diff --git a/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp__incl.dot b/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp__incl.dot
new file mode 100644
index 00000000..fd5505ab
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/software_eng__9__4_8hpp__incl.dot
@@ -0,0 +1,15 @@
+digraph "softwareEng_9_4.hpp"
+{
+ // LATEX_PDF_SIZE
+  edge [fontname="Helvetica",fontsize="10",labelfontname="Helvetica",labelfontsize="10"];
+  node [fontname="Helvetica",fontsize="10",shape=record];
+  Node1 [label="softwareEng_9_4.hpp",height=0.2,width=0.4,color="black", fillcolor="grey75", style="filled", fontcolor="black",tooltip=" "];
+  Node1 -> Node2 [color="midnightblue",fontsize="10",style="solid"];
+  Node2 [label="iostream",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+  Node1 -> Node3 [color="midnightblue",fontsize="10",style="solid"];
+  Node3 [label="string",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+  Node1 -> Node4 [color="midnightblue",fontsize="10",style="solid"];
+  Node4 [label="vector",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+  Node1 -> Node5 [color="midnightblue",fontsize="10",style="solid"];
+  Node5 [label="numeric",height=0.2,width=0.4,color="grey75", fillcolor="white", style="filled",tooltip=" "];
+}
diff --git a/week4/softwareEng_9_4/app/latex/tabu_doxygen.sty b/week4/softwareEng_9_4/app/latex/tabu_doxygen.sty
new file mode 100644
index 00000000..60fd7e8d
--- /dev/null
+++ b/week4/softwareEng_9_4/app/latex/tabu_doxygen.sty
@@ -0,0 +1,2557 @@
+%%
+%% This is file `tabu.sty',
+%% generated with the docstrip utility.
+%%
+%% The original source files were:
+%%
+%% tabu.dtx  (with options: `package')
+%% 
+%% This is a generated file.
+%% Copyright (FC) 2010-2011 - lppl
+%% 
+%% tabu : 2011/02/26 v2.8 - tabu : Flexible LaTeX tabulars
+%% 
+%% **********************************************************************************************
+%% \begin{tabu}               { preamble } => default target: \linewidth or \linegoal
+%% \begin{tabu} to     <dimen>{ preamble } => target specified
+%% \begin{tabu} spread <dimen>{ preamble } => target relative to the ``natural width''
+%% 
+%%  tabu works in text and in math modes.
+%% 
+%%  X columns: automatic width adjustment + horizontal and vertical alignment
+%%  \begin{tabu}   { X[4c] X[1c] X[-2ml]  }
+%% 
+%%  Horizontal lines and / or leaders:
+%%         \hline\hline                          => double horizontal line
+%%         \firsthline\hline                     => for nested tabulars
+%%         \lasthline\hline                      => for nested tabulars
+%%         \tabucline[line spec]{column-column}  => ``funny'' lines (dash/leader)
+%%  Automatic lines / leaders :
+%%         \everyrow{\hline\hline}
+%% 
+%%  Vertical lines and / or leaders:
+%%  \begin{tabu}   { |[3pt red] X[4c] X[1c] X[-2ml] |[3pt blue] }
+%%  \begin{tabu}   { |[3pt red] X[4c] X[1c] X[-2ml] |[3pt on 2pt off 4pt blue] }
+%% 
+%%  Fixed vertical spacing adjustment:
+%%         \extrarowheight=<dimen>     \extrarowdepth=<dimen>
+%%    or:     \extrarowsep=<dimen>               => may be prefixed by \global
+%% 
+%%  Dynamic vertical spacing adjustment:
+%%       \abovetabulinesep=<dimen>  \belowtabulinesep=<dimen>
+%%   or:      \tabulinesep=<dimen>               => may be prefixed by \global
+%% 
+%%  delarray.sty shortcuts: in math and text modes
+%%  \begin{tabu} ....        \({ preamble }\)
+%% 
+%%  Algorithms reports:
+%%            \tracingtabu=1             \tracingtabu=2
+%% 
+%% **********************************************************************************************
+%% 
+%% This work may be distributed and/or modified under the
+%% conditions of the LaTeX Project Public License, either
+%% version 1.3 of this license or (at your option) any later
+%% version. The latest version of this license is in
+%%    http://www.latex-project.org/lppl.txt
+%% 
+%% This work consists of the main source file tabu.dtx
+%% and the derived files
+%%    tabu.sty, tabu.pdf, tabu.ins
+%% 
+%% tabu : Flexible LaTeX tabulars
+%% lppl copyright 2010-2011 by FC <florent.chervet@free.fr>
+%% 
+
+\NeedsTeXFormat{LaTeX2e}[2005/12/01]
+\ProvidesPackage{tabu_doxygen}[2011/02/26 v2.8 - flexible LaTeX tabulars (FC), frozen version for doxygen]
+\RequirePackage{array}[2008/09/09]
+\RequirePackage{varwidth}[2009/03/30]
+\AtEndOfPackage{\tabu@AtEnd \let\tabu@AtEnd \@undefined}
+\let\tabu@AtEnd\@empty
+\def\TMP@EnsureCode#1={%
+    \edef\tabu@AtEnd{\tabu@AtEnd
+                     \catcode#1 \the\catcode#1}%
+    \catcode#1=%
+}% \TMP@EnsureCode
+\TMP@EnsureCode 33 = 12 % !
+\TMP@EnsureCode 58 = 12 % : (for siunitx)
+\TMP@EnsureCode124 = 12 % |
+\TMP@EnsureCode 36 =  3 % $ = math shift
+\TMP@EnsureCode 38 =  4 % & = tab alignment character
+\TMP@EnsureCode 32 = 10 % space
+\TMP@EnsureCode 94 =  7 % ^
+\TMP@EnsureCode 95 =  8 % _
+%% Constants --------------------------------------------------------
+\newcount \c@taburow        \def\thetaburow {\number\c@taburow}
+\newcount \tabu@nbcols
+\newcount \tabu@cnt
+\newcount \tabu@Xcol
+\let\tabu@start \@tempcnta
+\let\tabu@stop  \@tempcntb
+\newcount \tabu@alloc  \tabu@alloc=\m@ne
+\newcount \tabu@nested
+\def\tabu@alloc@{\global\advance\tabu@alloc \@ne \tabu@nested\tabu@alloc}
+\newdimen \tabu@target
+\newdimen \tabu@spreadtarget
+\newdimen \tabu@naturalX
+\newdimen \tabucolX
+\let\tabu@DELTA \@tempdimc
+\let\tabu@thick \@tempdima
+\let\tabu@on    \@tempdimb
+\let\tabu@off   \@tempdimc
+\newdimen \tabu@Xsum
+\newdimen \extrarowdepth
+\newdimen \abovetabulinesep
+\newdimen \belowtabulinesep
+\newdimen \tabustrutrule      \tabustrutrule \z@
+\newtoks \tabu@thebody
+\newtoks \tabu@footnotes
+\newsavebox \tabu@box
+\newsavebox \tabu@arstrutbox
+\newsavebox \tabu@hleads
+\newsavebox \tabu@vleads
+\newif \iftabu@colortbl
+\newif \iftabu@siunitx
+\newif \iftabu@measuring
+\newif \iftabu@spread
+\newif \iftabu@negcoef
+\newif \iftabu@everyrow
+\def\tabu@everyrowtrue {\global\let\iftabu@everyrow \iftrue}
+\def\tabu@everyrowfalse{\global\let\iftabu@everyrow \iffalse}
+\newif \iftabu@long
+\newif \iftabuscantokens
+\def\tabu@rescan {\tabu@verbatim \scantokens  }
+%% Utilities (for internal usage) -----------------------------------
+\def\tabu@gobblespace #1  {#1}
+\def\tabu@gobbletoken #1#2{#1}
+\def\tabu@gobbleX{\futurelet\@let@token \tabu@gobblex}
+\def\tabu@gobblex{\if ^^J\noexpand\@let@token \expandafter\@gobble
+                  \else\ifx \@sptoken\@let@token
+                    \expandafter\tabu@gobblespace\expandafter\tabu@gobbleX
+                  \fi\fi
+}% \tabu@gobblex
+\def\tabu@X{^^J}
+{\obeyspaces
+\global\let\tabu@spxiii= % saves an active space (for \ifx)
+\gdef\tabu@@spxiii{ }}
+\def\tabu@ifenvir {% only for \multicolumn
+    \expandafter\tabu@if@nvir\csname\@currenvir\endcsname
+}% \tabu@ifenvir
+\def\tabu@if@nvir #1{\csname @\ifx\tabu#1first\else
+                              \ifx\longtabu#1first\else
+                              second\fi\fi oftwo\endcsname
+}% \tabu@ifenvir
+\def\tabu@modulo #1#2{\numexpr\ifnum\numexpr#1=\z@ 0\else #1-(#1-(#2-1)/2)/(#2)*(#2)\fi}
+{\catcode`\&=3
+\gdef\tabu@strtrim  #1{% #1 = control sequence to trim
+    \ifodd 1\ifx #1\@empty \else \ifx #1\space \else 0\fi \fi
+            \let\tabu@c@l@r \@empty       \let#1\@empty
+    \else   \expandafter  \tabu@trimspaces  #1&#1\@nnil
+    \fi
+}% \tabu@strtrim
+\gdef\tabu@trimspaces #1&#2\@nnil{\let\tabu@c@l@r=#2\tabu@firstspace .#1& &#2}%
+\gdef\tabu@firstspace #1#2#3 &{\tabu@lastspace #2#3&}
+\gdef\tabu@lastspace #1&#2&#3{\def #3{#1}%
+    \ifx #3\tabu@c@l@r \def\tabu@c@l@r{\protect\color{#1}}\expandafter\remove@to@nnil \fi
+    \tabu@trimspaces #1&#3\@nnil}
+}% \catcode
+\def\tabu@sanitizearg #1#2{{%
+    \csname \ifcsname if@safe@actives\endcsname         % <babel>
+                      @safe@activestrue\else
+                      relax\fi       \endcsname
+    \edef#2{#1}\tabu@strtrim#2\@onelevel@sanitize#2%
+    \expandafter}\expandafter\def\expandafter#2\expandafter{#2}%
+}% \tabu@sanitizearg
+\def\tabu@textbar #1{\begingroup \endlinechar\m@ne \scantokens{\def\:{|}}%
+    \expandafter\endgroup \expandafter#1\:% !!! semi simple group !!!
+}% \tabu@textbar
+\def\tabu@everyrow@bgroup{\iftabu@everyrow \begingroup \else \noalign{\ifnum0=`}\fi \fi}
+\def\tabu@everyrow@egroup{%
+    \iftabu@everyrow \expandafter \endgroup \the\toks@
+    \else            \ifnum0=`{\fi}%
+    \fi
+}% \tabu@everyrow@egroup
+\def\tabu@arstrut {\global\setbox\@arstrutbox \hbox{\vrule
+    height \arraystretch \dimexpr\ht\strutbox+\extrarowheight
+    depth  \arraystretch \dimexpr\dp\strutbox+\extrarowdepth
+    width  \z@}%
+}% \tabu@arstrut
+\def\tabu@rearstrut {%
+    \@tempdima \arraystretch\dimexpr\ht\strutbox+\extrarowheight \relax
+    \@tempdimb \arraystretch\dimexpr\dp\strutbox+\extrarowdepth  \relax
+    \ifodd 1\ifdim \ht\@arstrutbox=\@tempdima
+            \ifdim \dp\@arstrutbox=\@tempdimb 0 \fi\fi
+        \tabu@mkarstrut
+    \fi
+}% \tabu@rearstrut
+\def\tabu@@DBG #1{\ifdim\tabustrutrule>\z@ \color{#1}\fi}
+\def\tabu@DBG@arstrut {\global\setbox\@arstrutbox
+    \hbox to\z@{\hbox to\z@{\hss
+    {\tabu@DBG{cyan}\vrule
+    height \arraystretch \dimexpr\ht\strutbox+\extrarowheight
+    depth  \z@
+    width  \tabustrutrule}\kern-\tabustrutrule
+    {\tabu@DBG{pink}\vrule
+    height \z@
+    depth  \arraystretch \dimexpr\dp\strutbox+\extrarowdepth
+    width \tabustrutrule}}}%
+}% \tabu@DBG@arstrut
+\def\tabu@save@decl{\toks\count@ \expandafter{\the\toks\expandafter\count@
+                                                              \@nextchar}}%
+\def\tabu@savedecl{\ifcat$\d@llarend\else
+       \let\save@decl \tabu@save@decl \fi % no inversion of tokens in text mode
+}% \tabu@savedecl
+\def\tabu@finalstrut #1{\unskip\ifhmode\nobreak\fi\vrule height\z@ depth\z@ width\z@}
+\newcommand*\tabuDisableCommands {\g@addto@macro\tabu@trialh@@k }
+\let\tabu@trialh@@k \@empty
+\def\tabu@nowrite #1#{{\afterassignment}\toks@}
+\let\tabu@write\write
+\let\tabu@immediate\immediate
+\def\tabu@WRITE{\begingroup
+   \def\immediate\write{\aftergroup\endgroup
+                  \tabu@immediate\tabu@write}%
+}% \tabu@WRITE
+\expandafter\def\expandafter\tabu@GenericError\expandafter{%
+                      \expandafter\tabu@WRITE\GenericError}
+\def\tabu@warn{\tabu@WRITE\PackageWarning{tabu}}
+\def\tabu@noxfootnote [#1]{\@gobble}
+\def\tabu@nocolor #1#{\@gobble}
+\newcommand*\tabu@norowcolor[2][]{}
+\def\tabu@maybesiunitx #1{\def\tabu@temp{#1}%
+                          \futurelet\@let@token \tabu@m@ybesiunitx}
+\def\tabu@m@ybesiunitx #1{\def\tabu@m@ybesiunitx {%
+    \ifx #1\@let@token \let\tabu@cellleft \@empty \let\tabu@cellright \@empty \fi
+    \tabu@temp}% \tabu@m@ybesiunitx
+}\expandafter\tabu@m@ybesiunitx \csname siunitx_table_collect_begin:Nn\endcsname
+\def\tabu@celllalign@def #1{\def\tabu@celllalign{\tabu@maybesiunitx{#1}}}%
+%% Fixed vertical spacing adjustment: \extrarowsep ------------------
+\newcommand*\extrarowsep{\edef\tabu@C@extra{\the\numexpr\tabu@C@extra+1}%
+    \iftabu@everyrow    \aftergroup\tabu@Gextra
+    \else               \aftergroup\tabu@n@Gextra
+    \fi
+    \@ifnextchar={\tabu@gobbletoken\tabu@extra} \tabu@extra
+}% \extrarowsep
+\def\tabu@extra {\@ifnextchar_%
+    {\tabu@gobbletoken{\tabu@setextra\extrarowheight \extrarowdepth}}
+    {\ifx ^\@let@token \def\tabu@temp{%
+            \tabu@gobbletoken{\tabu@setextra\extrarowdepth \extrarowheight}}%
+    \else   \let\tabu@temp \@empty
+            \afterassignment \tabu@setextrasep \extrarowdepth
+    \fi \tabu@temp}%
+}% \tabu@extra
+\def\tabu@setextra #1#2{\def\tabu@temp{\tabu@extr@#1#2}\afterassignment\tabu@temp#2}
+\def\tabu@extr@ #1#2{\@ifnextchar^%
+    {\tabu@gobbletoken{\tabu@setextra\extrarowdepth \extrarowheight}}
+    {\ifx _\@let@token \def\tabu@temp{%
+            \tabu@gobbletoken{\tabu@setextra\extrarowheight \extrarowdepth}}%
+    \else   \let\tabu@temp \@empty
+            \tabu@Gsave \tabu@G@extra \tabu@C@extra \extrarowheight \extrarowdepth
+    \fi \tabu@temp}%
+}% \tabu@extr@
+\def\tabu@setextrasep {\extrarowheight=\extrarowdepth
+    \tabu@Gsave \tabu@G@extra \tabu@C@extra \extrarowheight \extrarowdepth
+}% \tabu@setextrasep
+\def\tabu@Gextra{\ifx \tabu@G@extra\@empty \else {\tabu@Rextra}\fi}
+\def\tabu@n@Gextra{\ifx \tabu@G@extra\@empty \else \noalign{\tabu@Rextra}\fi}
+\def\tabu@Rextra{\tabu@Grestore \tabu@G@extra \tabu@C@extra}
+\let\tabu@C@extra \z@
+\let\tabu@G@extra \@empty
+%% Dynamic vertical spacing adjustment: \tabulinesep ----------------
+\newcommand*\tabulinesep{\edef\tabu@C@linesep{\the\numexpr\tabu@C@linesep+1}%
+    \iftabu@everyrow    \aftergroup\tabu@Glinesep
+    \else               \aftergroup\tabu@n@Glinesep
+    \fi
+    \@ifnextchar={\tabu@gobbletoken\tabu@linesep} \tabu@linesep
+}% \tabulinesep
+\def\tabu@linesep {\@ifnextchar_%
+    {\tabu@gobbletoken{\tabu@setsep\abovetabulinesep \belowtabulinesep}}
+    {\ifx ^\@let@token \def\tabu@temp{%
+            \tabu@gobbletoken{\tabu@setsep\belowtabulinesep \abovetabulinesep}}%
+     \else  \let\tabu@temp \@empty
+            \afterassignment \tabu@setlinesep \abovetabulinesep
+     \fi \tabu@temp}%
+}% \tabu@linesep
+\def\tabu@setsep #1#2{\def\tabu@temp{\tabu@sets@p#1#2}\afterassignment\tabu@temp#2}
+\def\tabu@sets@p #1#2{\@ifnextchar^%
+    {\tabu@gobbletoken{\tabu@setsep\belowtabulinesep \abovetabulinesep}}
+    {\ifx _\@let@token \def\tabu@temp{%
+            \tabu@gobbletoken{\tabu@setsep\abovetabulinesep \belowtabulinesep}}%
+    \else   \let\tabu@temp \@empty
+            \tabu@Gsave \tabu@G@linesep \tabu@C@linesep \abovetabulinesep \belowtabulinesep
+    \fi \tabu@temp}%
+}% \tabu@sets@p
+\def\tabu@setlinesep {\belowtabulinesep=\abovetabulinesep
+    \tabu@Gsave \tabu@G@linesep \tabu@C@linesep \abovetabulinesep \belowtabulinesep
+}% \tabu@setlinesep
+\def\tabu@Glinesep{\ifx \tabu@G@linesep\@empty \else {\tabu@Rlinesep}\fi}
+\def\tabu@n@Glinesep{\ifx \tabu@G@linesep\@empty \else \noalign{\tabu@Rlinesep}\fi}
+\def\tabu@Rlinesep{\tabu@Grestore \tabu@G@linesep \tabu@C@linesep}
+\let\tabu@C@linesep \z@
+\let\tabu@G@linesep \@empty
+%% \global\extrarowsep  and  \global\tabulinesep  -------------------
+\def\tabu@Gsave #1#2#3#4{\xdef#1{#1%
+    \toks#2{\toks\the\currentgrouplevel{\global#3\the#3\global#4\the#4}}}%
+}% \tabu@Gsave
+\def\tabu@Grestore#1#2{%
+    \toks#2{}#1\toks\currentgrouplevel\expandafter{\expandafter}\the\toks#2\relax
+    \ifcat$\the\toks\currentgrouplevel$\else
+        \global\let#1\@empty \global\let#2\z@
+        \the\toks\currentgrouplevel
+    \fi
+}% \tabu@Grestore
+%% Setting code for every row ---------------------------------------
+\newcommand*\everyrow{\tabu@everyrow@bgroup
+                      \tabu@start \z@ \tabu@stop \z@ \tabu@evrstartstop
+}% \everyrow
+\def\tabu@evrstartstop {\@ifnextchar^%
+    {\afterassignment \tabu@evrstartstop \tabu@stop=}%
+    {\ifx ^\@let@token
+            \afterassignment\tabu@evrstartstop \tabu@start=%
+     \else  \afterassignment\tabu@everyr@w     \toks@
+     \fi}%
+}% \tabu@evrstartstop
+\def\tabu@everyr@w {%
+    \xdef\tabu@everyrow{%
+        \noexpand\tabu@everyrowfalse
+        \let\noalign \relax
+        \noexpand\tabu@rowfontreset
+        \iftabu@colortbl \noexpand\tabu@rc@ \fi % \taburowcolors
+        \let\noexpand\tabu@docline \noexpand\tabu@docline@evr
+        \the\toks@
+        \noexpand\tabu@evrh@@k
+        \noexpand\tabu@rearstrut
+        \global\advance\c@taburow \@ne}%
+    \iftabu@everyrow \toks@\expandafter
+        {\expandafter\def\expandafter\tabu@evr@L\expandafter{\the\toks@}\ignorespaces}%
+    \else \xdef\tabu@evr@G{\the\toks@}%
+    \fi
+    \tabu@everyrow@egroup
+}% \tabu@everyr@w
+\def\tabu@evr {\def\tabu@evrh@@k}         % for internal use only
+\tabu@evr{}
+%% line style and leaders -------------------------------------------
+\newcommand*\newtabulinestyle [1]{%
+    {\@for \@tempa :=#1\do{\expandafter\tabu@newlinestyle \@tempa==\@nil}}%
+}% \newtabulinestyle
+\def\tabu@newlinestyle #1=#2=#3\@nil{\tabu@getline {#2}%
+    \tabu@sanitizearg {#1}\@tempa
+    \ifodd 1\ifx \@tempa\@empty \ifdefined\tabu@linestyle@ 0 \fi\fi
+    \global\expandafter\let
+        \csname tabu@linestyle@\@tempa \endcsname =\tabu@thestyle \fi
+}% \tabu@newlinestyle
+\newcommand*\tabulinestyle [1]{\tabu@everyrow@bgroup \tabu@getline{#1}%
+    \iftabu@everyrow
+        \toks@\expandafter{\expandafter \def \expandafter
+                    \tabu@ls@L\expandafter{\tabu@thestyle}\ignorespaces}%
+        \gdef\tabu@ls@{\tabu@ls@L}%
+    \else
+        \global\let\tabu@ls@G \tabu@thestyle
+        \gdef\tabu@ls@{\tabu@ls@G}%
+    \fi
+    \tabu@everyrow@egroup
+}% \tabulinestyle
+\newcommand*\taburulecolor{\tabu@everyrow@bgroup \tabu@textbar \tabu@rulecolor}
+\def\tabu@rulecolor #1{\toks@{}%
+    \def\tabu@temp #1##1#1{\tabu@ruledrsc{##1}}\@ifnextchar #1%
+                                                    \tabu@temp
+                                                 \tabu@rulearc
+}% \tabu@rulecolor
+\def\tabu@ruledrsc #1{\edef\tabu@temp{#1}\tabu@strtrim\tabu@temp
+    \ifx \tabu@temp\@empty \def\tabu@temp{\tabu@rule@drsc@ {}{}}%
+    \else \edef\tabu@temp{\noexpand\tabu@rule@drsc@ {}{\tabu@temp}}%
+    \fi
+    \tabu@temp
+}% \tabu@ruledrsc@
+\def\tabu@ruledrsc@   #1#{\tabu@rule@drsc@ {#1}}
+\def\tabu@rule@drsc@ #1#2{%
+    \iftabu@everyrow
+        \ifx \\#1#2\\\toks@{\let\CT@drsc@ \relax}%
+        \else        \toks@{\def\CT@drsc@{\color #1{#2}}}%
+        \fi
+    \else
+        \ifx \\#1#2\\\global\let\CT@drsc@ \relax
+        \else        \gdef\CT@drsc@{\color #1{#2}}%
+        \fi
+    \fi
+    \tabu@rulearc
+}% \tabu@rule@drsc@
+\def\tabu@rulearc    #1#{\tabu@rule@arc@ {#1}}
+\def\tabu@rule@arc@ #1#2{%
+    \iftabu@everyrow
+        \ifx \\#1#2\\\toks@\expandafter{\the\toks@ \def\CT@arc@{}}%
+        \else        \toks@\expandafter{\the\toks@ \def\CT@arc@{\color #1{#2}}}%
+        \fi
+        \toks@\expandafter{\the\toks@
+            \let\tabu@arc@L  \CT@arc@
+            \let\tabu@drsc@L \CT@drsc@
+            \ignorespaces}%
+    \else
+        \ifx \\#1#2\\\gdef\CT@arc@{}%
+        \else        \gdef\CT@arc@{\color #1{#2}}%
+        \fi
+        \global\let\tabu@arc@G  \CT@arc@
+        \global\let\tabu@drsc@G \CT@drsc@
+    \fi
+    \tabu@everyrow@egroup
+}% \tabu@rule@arc@
+\def\taburowcolors {\tabu@everyrow@bgroup \@testopt \tabu@rowcolors 1}
+\def\tabu@rowcolors [#1]#2#{\tabu@rowc@lors{#1}{#2}}
+\def\tabu@rowc@lors #1#2#3{%
+    \toks@{}\@defaultunits \count@      =\number0#2\relax \@nnil
+            \@defaultunits \tabu@start  =\number0#1\relax \@nnil
+    \ifnum \count@<\tw@ \count@=\tw@ \fi
+    \advance\tabu@start \m@ne
+    \ifnum \tabu@start<\z@ \tabu@start \z@ \fi
+    \tabu@rowcolorseries #3\in@..\in@ \@nnil
+}% \tabu@rowcolors
+\def\tabu@rowcolorseries #1..#2\in@ #3\@nnil {%
+    \ifx \in@#1\relax
+        \iftabu@everyrow \toks@{\def\tabu@rc@{}\let\tabu@rc@L \tabu@rc@}%
+        \else   \gdef\tabu@rc@{}\global\let\tabu@rc@G \tabu@rc@
+        \fi
+    \else
+        \ifx \\#2\\\tabu@rowcolorserieserror \fi
+        \tabu@sanitizearg{#1}\tabu@temp
+        \tabu@sanitizearg{#2}\@tempa
+        \advance\count@ \m@ne
+    \iftabu@everyrow
+        \def\tabu@rc@ ##1##2##3##4{\def\tabu@rc@{%
+            \ifnum ##2=\c@taburow
+                \definecolorseries{tabu@rcseries@\the\tabu@nested}{rgb}{last}{##3}{##4}\fi
+            \ifnum \c@taburow<##2 \else
+                \ifnum \tabu@modulo {\c@taburow-##2}{##1+1}=\z@
+                    \resetcolorseries[{##1}]{tabu@rcseries@\the\tabu@nested}\fi
+                \xglobal\colorlet{tabu@rc@\the\tabu@nested}{tabu@rcseries@\the\tabu@nested!!+}%
+                \rowcolor{tabu@rc@\the\tabu@nested}\fi}%
+        }\edef\x{\noexpand\tabu@rc@           {\the\count@}
+                                          {\the\tabu@start}
+                                               {\tabu@temp}
+                                                  {\@tempa}%
+                }\x
+        \toks@\expandafter{\expandafter\def\expandafter\tabu@rc@\expandafter{\tabu@rc@}}%
+        \toks@\expandafter{\the\toks@ \let\tabu@rc@L \tabu@rc@ \ignorespaces}%
+    \else   % inside \noalign
+        \definecolorseries{tabu@rcseries@\the\tabu@nested}{rgb}{last}{\tabu@temp}{\@tempa}%
+        \expandafter\resetcolorseries\expandafter[\the\count@]{tabu@rcseries@\the\tabu@nested}%
+        \xglobal\colorlet{tabu@rc@\the\tabu@nested}{tabu@rcseries@\the\tabu@nested!!+}%
+        \let\noalign \relax \rowcolor{tabu@rc@\the\tabu@nested}%
+        \def\tabu@rc@ ##1##2{\gdef\tabu@rc@{%
+            \ifnum \tabu@modulo {\c@taburow-##2}{##1+1}=\@ne
+                \resetcolorseries[{##1}]{tabu@rcseries@\the\tabu@nested}\fi
+            \xglobal\colorlet{tabu@rc@\the\tabu@nested}{tabu@rcseries@\the\tabu@nested!!+}%
+            \rowcolor{tabu@rc@\the\tabu@nested}}%
+        }\edef\x{\noexpand\tabu@rc@{\the\count@}{\the\c@taburow}}\x
+        \global\let\tabu@rc@G \tabu@rc@
+    \fi
+    \fi
+    \tabu@everyrow@egroup
+}% \tabu@rowcolorseries
+\tabuDisableCommands {\let\tabu@rc@ \@empty }
+\def\tabu@rowcolorserieserror {\PackageError{tabu}
+    {Invalid syntax for \string\taburowcolors
+    \MessageBreak Please look at the documentation!}\@ehd
+}% \tabu@rowcolorserieserror
+\newcommand*\tabureset {%
+    \tabulinesep=\z@ \extrarowsep=\z@ \extratabsurround=\z@
+    \tabulinestyle{}\everyrow{}\taburulecolor||{}\taburowcolors{}%
+}% \tabureset
+%% Parsing the line styles ------------------------------------------
+\def\tabu@getline #1{\begingroup
+    \csname \ifcsname if@safe@actives\endcsname         % <babel>
+                      @safe@activestrue\else
+                      relax\fi       \endcsname
+    \edef\tabu@temp{#1}\tabu@sanitizearg{#1}\@tempa
+    \let\tabu@thestyle \relax
+    \ifcsname tabu@linestyle@\@tempa \endcsname
+            \edef\tabu@thestyle{\endgroup
+                \def\tabu@thestyle{\expandafter\noexpand
+                    \csname tabu@linestyle@\@tempa\endcsname}%
+            }\tabu@thestyle
+    \else   \expandafter\tabu@definestyle \tabu@temp \@nil
+    \fi
+}% \tabu@getline
+\def\tabu@definestyle #1#2\@nil {\endlinechar \m@ne \makeatletter
+    \tabu@thick \maxdimen  \tabu@on \maxdimen   \tabu@off \maxdimen
+    \let\tabu@c@lon \@undefined  \let\tabu@c@loff \@undefined
+    \ifodd 1\ifcat .#1\else\ifcat\relax #1\else 0\fi\fi % catcode 12 or non expandable cs
+            \def\tabu@temp{\tabu@getparam{thick}}%
+    \else   \def\tabu@temp{\tabu@getparam{thick}\maxdimen}%
+    \fi
+    {%
+        \let\tabu@ \relax
+        \def\:{\obeyspaces \tabu@oXIII \tabu@commaXIII \edef\:}% (space active \: happy ;-))
+        \scantokens{\:{\tabu@temp #1#2 \tabu@\tabu@}}%
+                        \expandafter}\expandafter
+                                \def\expandafter\:\expandafter{\:}% line spec rewritten now ;-)
+    \def\;{\def\:}%
+    \scantokens\expandafter{\expandafter\;\expandafter{\:}}% space is now inactive (catcode 10)
+    \let\tabu@ \tabu@getcolor    \:%    all arguments are ready now ;-)
+    \ifdefined\tabu@c@lon \else \let\tabu@c@lon\@empty \fi
+    \ifx \tabu@c@lon\@empty \def\tabu@c@lon{\CT@arc@}\fi
+    \ifdefined\tabu@c@loff \else \let\tabu@c@loff \@empty        \fi
+    \ifdim \tabu@on=\maxdimen \ifdim \tabu@off<\maxdimen
+                                  \tabu@on \tabulineon        \fi\fi
+    \ifdim \tabu@off=\maxdimen \ifdim \tabu@on<\maxdimen
+                                  \tabu@off \tabulineoff      \fi\fi
+    \ifodd 1\ifdim \tabu@off=\maxdimen \ifdim \tabu@on=\maxdimen 0 \fi\fi
+            \in@true    % <leaders>
+    \else   \in@false   % <rule>
+    \fi
+    \ifdim\tabu@thick=\maxdimen \def\tabu@thick{\arrayrulewidth}%
+    \else                       \edef\tabu@thick{\the\tabu@thick}%
+    \fi
+    \edef \tabu@thestyle ##1##2{\endgroup
+        \def\tabu@thestyle{%
+            \ifin@  \noexpand\tabu@leadersstyle {\tabu@thick}
+                                                {\the\tabu@on}{##1}
+                                                {\the\tabu@off}{##2}%
+            \else   \noexpand\tabu@rulesstyle
+                            {##1\vrule width \tabu@thick}%
+                            {##1\leaders \hrule height \tabu@thick \hfil}%
+            \fi}%
+    }\expandafter \expandafter
+        \expandafter \tabu@thestyle \expandafter
+            \expandafter \expandafter
+                {\expandafter\tabu@c@lon\expandafter}\expandafter{\tabu@c@loff}%
+}% \tabu@definestyle
+{\catcode`\O=\active \lccode`\O=`\o \catcode`\,=\active
+    \lowercase{\gdef\tabu@oXIII {\catcode`\o=\active \let O=\tabu@oxiii}}
+    \gdef\tabu@commaXIII {\catcode`\,=\active \let ,=\space}
+}% \catcode
+\def\tabu@oxiii #1{%
+    \ifcase  \ifx n#1\z@ \else
+             \ifx f#1\@ne\else
+             \tw@       \fi\fi
+          \expandafter\tabu@onxiii
+    \or   \expandafter\tabu@ofxiii
+    \else o%
+    \fi#1}%
+\def\tabu@onxiii #1#2{%
+    \ifcase  \ifx  !#2\tw@          \else
+             \ifcat.\noexpand#2\z@  \else
+             \ifx \tabu@spxiii#2\@ne\else
+             \tw@               \fi\fi\fi
+          \tabu@getparam{on}#2\expandafter\@gobble
+    \or   \expandafter\tabu@onxiii    % (space is active)
+    \else o\expandafter\@firstofone
+    \fi{#1#2}}%
+\def\tabu@ofxiii #1#2{%
+    \ifx #2f\expandafter\tabu@offxiii
+    \else   o\expandafter\@firstofone
+    \fi{#1#2}}
+\def\tabu@offxiii #1#2{%
+    \ifcase \ifx  !#2\tw@           \else
+            \ifcat.\noexpand#2\z@   \else
+            \ifx\tabu@spxiii#2\@ne  \else
+            \tw@                \fi\fi\fi
+          \tabu@getparam{off}#2\expandafter\@gobble
+    \or   \expandafter\tabu@offxiii   % (space is active)
+    \else o\expandafter\@firstofone
+    \fi{#1#2}}
+\def\tabu@getparam #1{\tabu@ \csname tabu@#1\endcsname=}
+\def\tabu@getcolor #1{% \tabu@ <- \tabu@getcolor after \edef
+    \ifx \tabu@#1\else   % no more spec
+        \let\tabu@theparam=#1\afterassignment \tabu@getc@l@r #1\fi
+}% \tabu@getcolor
+\def\tabu@getc@l@r #1\tabu@ {%
+    \def\tabu@temp{#1}\tabu@strtrim \tabu@temp
+    \ifx \tabu@temp\@empty
+    \else%\ifcsname \string\color@\tabu@temp \endcsname  % if the color exists
+        \ifx \tabu@theparam \tabu@off   \let\tabu@c@loff \tabu@c@l@r
+        \else                           \let\tabu@c@lon  \tabu@c@l@r
+        \fi
+    %\else \tabu@warncolour{\tabu@temp}%
+    \fi%\fi
+    \tabu@ % next spec
+}% \tabu@getc@l@r
+\def\tabu@warncolour #1{\PackageWarning{tabu}
+    {Color #1 is not defined. Default color used}%
+}% \tabu@warncolour
+\def\tabu@leadersstyle #1#2#3#4#5{\def\tabu@leaders{{#1}{#2}{#3}{#4}{#5}}%
+    \ifx \tabu@leaders\tabu@leaders@G \else
+                \tabu@LEADERS{#1}{#2}{#3}{#4}{#5}\fi
+}% \tabu@leadersstyle
+\def\tabu@rulesstyle #1#2{\let\tabu@leaders \@undefined
+        \gdef\tabu@thevrule{#1}\gdef\tabu@thehrule{#2}%
+}% \tabu@rulesstyle
+%% The leaders boxes ------------------------------------------------
+\def\tabu@LEADERS #1#2#3#4#5{%% width, dash, dash color, gap, gap color
+    {\let\color \tabu@color % => during trials ->  \color = \tabu@nocolor
+    {%                      %    but the leaders boxes should have colors !
+    \def\@therule{\vrule}\def\@thick{height}\def\@length{width}%
+    \def\@box{\hbox}\def\@unbox{\unhbox}\def\@elt{\wd}%
+    \def\@skip{\hskip}\def\@ss{\hss}\def\tabu@leads{\tabu@hleads}%
+    \tabu@l@@d@rs {#1}{#2}{#3}{#4}{#5}%
+    \global\let\tabu@thehleaders \tabu@theleaders
+    }%
+    {%
+    \def\@therule{\hrule}\def\@thick{width}\def\@length{height}%
+    \def\@box{\vbox}\def\@unbox{\unvbox}\def\@elt{\ht}%
+    \def\@skip{\vskip}\def\@ss{\vss}\def\tabu@leads{\tabu@vleads}%
+    \tabu@l@@d@rs {#1}{#2}{#3}{#4}{#5}%
+    \global\let\tabu@thevleaders \tabu@theleaders
+    }%
+    \gdef\tabu@leaders@G{{#1}{#2}{#3}{#4}{#5}}%
+    }%
+}% \tabu@LEADERS
+\def\tabu@therule #1#2{\@therule \@thick#1\@length\dimexpr#2/2 \@depth\z@}
+\def\tabu@l@@d@rs #1#2#3#4#5{%% width, dash, dash color, gap, gap color
+    \global\setbox \tabu@leads=\@box{%
+        {#3\tabu@therule{#1}{#2}}%
+        \ifx\\#5\\\@skip#4\else{#5\tabu@therule{#1}{#4*2}}\fi
+        {#3\tabu@therule{#1}{#2}}}%
+    \global\setbox\tabu@leads=\@box to\@elt\tabu@leads{\@ss
+        {#3\tabu@therule{#1}{#2}}\@unbox\tabu@leads}%
+    \edef\tabu@theleaders ##1{\def\noexpand\tabu@theleaders {%
+        {##1\tabu@therule{#1}{#2}}%
+        \xleaders \copy\tabu@leads \@ss
+        \tabu@therule{0pt}{-#2}{##1\tabu@therule{#1}{#2}}}%
+    }\tabu@theleaders{#3}%
+}% \tabu@l@@d@rs
+%% \tabu \endtabu \tabu* \longtabu \endlongtabu \longtabu* ----------
+\newcommand*\tabu {\tabu@longfalse
+    \ifmmode \def\tabu@ {\array}\def\endtabu {\endarray}%
+    \else  \def\tabu@ {\tabu@tabular}\def\endtabu {\endtabular}\fi
+    \expandafter\let\csname tabu*\endcsname \tabu
+    \expandafter\def\csname endtabu*\endcsname{\endtabu}%
+    \tabu@spreadfalse \tabu@negcoeffalse \tabu@settarget
+}% {tabu}
+\let\tabu@tabular \tabular % <For LyX: some users redefine \tabular...>
+\expandafter\def\csname tabu*\endcsname{\tabuscantokenstrue \tabu}
+\newcommand*\longtabu {\tabu@longtrue
+   \ifmmode\PackageError{tabu}{longtabu not allowed in math mode}\fi
+   \def\tabu@{\longtable}\def\endlongtabu{\endlongtable}%
+   \LTchunksize=\@M
+   \expandafter\let\csname tabu*\endcsname \tabu
+   \expandafter\def\csname endlongtabu*\endcsname{\endlongtabu}%
+   \let\LT@startpbox \tabu@LT@startpbox % \everypar{ array struts }
+   \tabu@spreadfalse \tabu@negcoeffalse \tabu@settarget
+}% {longtabu}
+\expandafter\def\csname longtabu*\endcsname{\tabuscantokenstrue \longtabu}
+\def\tabu@nolongtabu{\PackageError{tabu}
+   {longtabu requires the longtable package}\@ehd}
+%% Read the target and  then : \tabular or \@array ------------------
+\def\tabu@settarget {\futurelet\@let@token \tabu@sett@rget }
+\def\tabu@sett@rget {\tabu@target \z@
+   \ifcase \ifx \bgroup\@let@token   \z@  \else
+           \ifx \@sptoken\@let@token \@ne \else
+           \if t\@let@token          \tw@ \else
+           \if s\@let@token          \thr@@\else
+           \z@\fi\fi\fi\fi
+         \expandafter\tabu@begin
+   \or   \expandafter\tabu@gobblespace\expandafter\tabu@settarget
+   \or   \expandafter\tabu@to
+   \or   \expandafter\tabu@spread
+   \fi
+}% \tabu@sett@rget
+\def\tabu@to to{\def\tabu@halignto{to}\tabu@gettarget}
+\def\tabu@spread spread{\tabu@spreadtrue\def\tabu@halignto{spread}\tabu@gettarget}
+\def\tabu@gettarget {\afterassignment\tabu@linegoaltarget \tabu@target }
+\def\tabu@linegoaltarget {\futurelet\tabu@temp \tabu@linegoalt@rget }
+\def\tabu@linegoalt@rget {%
+   \ifx \tabu@temp\LNGL@setlinegoal
+        \LNGL@setlinegoal \expandafter \@firstoftwo \fi % @gobbles \LNGL@setlinegoal
+   \tabu@begin
+}% \tabu@linegoalt@rget
+\def\tabu@begin #1#{%
+    \iftabu@measuring \expandafter\tabu@nestedmeasure \fi
+    \ifdim \tabu@target=\z@ \let\tabu@halignto \@empty
+    \else                   \edef\tabu@halignto{\tabu@halignto\the\tabu@target}%
+    \fi
+    \@testopt \tabu@tabu@ \tabu@aligndefault #1\@nil
+}% \tabu@begin
+\long\def\tabu@tabu@ [#1]#2\@nil #3{\tabu@setup
+   \def\tabu@align {#1}\def\tabu@savedpream{\NC@find #3}%
+   \tabu@ [\tabu@align ]#2{#3\tabu@rewritefirst }%
+}% \tabu@tabu@
+\def\tabu@nestedmeasure {%
+    \ifodd 1\iftabu@spread \else \ifdim\tabu@target=\z@ \else 0 \fi\fi\relax
+            \tabu@spreadtrue
+    \else   \begingroup \iffalse{\fi \ifnum0=`}\fi
+            \toks@{}\def\tabu@stack{b}%
+            \expandafter\tabu@collectbody\expandafter\tabu@quickrule
+                                         \expandafter\endgroup
+    \fi
+}% \tabu@nestedmeasure
+\def\tabu@quickrule {\indent\vrule height\z@ depth\z@ width\tabu@target}
+%% \tabu@setup  \tabu@init  \tabu@indent
+\def\tabu@setup{\tabu@alloc@
+    \ifcase \tabu@nested
+        \ifmmode \else \iftabu@spread\else \ifdim\tabu@target=\z@
+            \let\tabu@afterendpar \par
+        \fi\fi\fi
+        \def\tabu@aligndefault{c}\tabu@init \tabu@indent
+    \else       % <nested tabu>
+        \def\tabu@aligndefault{t}\let\tabudefaulttarget \linewidth
+    \fi
+    \let\tabu@thetarget \tabudefaulttarget \let\tabu@restored \@undefined
+    \edef\tabu@NC@list{\the\NC@list}\NC@list{\NC@do \tabu@rewritefirst}%
+    \everycr{}\let\@startpbox \tabu@startpbox % for nested tabu inside longtabu...
+              \let\@endpbox   \tabu@endpbox   % idem "    "    "    "    "    "
+              \let\@tabarray  \tabu@tabarray  % idem "    "    "    "    "    "
+    \tabu@setcleanup \tabu@setreset
+}% \tabu@setup
+\def\tabu@init{\tabu@starttimer \tabu@measuringfalse
+    \edef\tabu@hfuzz  {\the\dimexpr\hfuzz+1sp}\global\tabu@footnotes{}%
+    \let\firsthline    \tabu@firsthline   \let\lasthline      \tabu@lasthline
+    \let\firstline     \tabu@firstline    \let\lastline       \tabu@lastline
+    \let\hline         \tabu@hline        \let\@xhline        \tabu@xhline
+    \let\color         \tabu@color        \let\@arstrutbox    \tabu@arstrutbox
+    \iftabu@colortbl\else\let\LT@@hline   \tabu@LT@@hline \fi
+    \tabu@trivlist     %<restore \\=\@normalcr inside lists>
+    \let\@footnotetext \tabu@footnotetext \let\@xfootnotetext \tabu@xfootnotetext
+    \let\@xfootnote    \tabu@xfootnote    \let\centering      \tabu@centering
+    \let\raggedright   \tabu@raggedright  \let\raggedleft     \tabu@raggedleft
+    \let\tabudecimal   \tabu@tabudecimal  \let\Centering      \tabu@Centering
+    \let\RaggedRight   \tabu@RaggedRight  \let\RaggedLeft     \tabu@RaggedLeft
+    \let\justifying    \tabu@justifying   \let\rowfont        \tabu@rowfont
+    \let\fbox          \tabu@fbox         \let\color@b@x      \tabu@color@b@x
+    \let\tabu@@everycr \everycr           \let\tabu@@everypar \everypar
+    \let\tabu@prepnext@tokORI \prepnext@tok\let\prepnext@tok  \tabu@prepnext@tok
+    \let\tabu@multicolumnORI\multicolumn  \let\multicolumn    \tabu@multicolumn
+    \let\tabu@startpbox \@startpbox      % for nested tabu inside longtabu pfff !!!
+    \let\tabu@endpbox   \@endpbox        % idem  "    "    "    "    "    "    "
+    \let\tabu@tabarray  \@tabarray       % idem  "    "    "    "    "    "    "
+    \tabu@adl@fix      \let\endarray      \tabu@endarray % <fix> colortbl & arydshln (delarray)
+    \iftabu@colortbl\CT@everycr\expandafter{\expandafter\iftabu@everyrow \the\CT@everycr \fi}\fi
+}% \tabu@init
+\def\tabu@indent{% correction for indentation
+    \ifdim \parindent>\z@\ifx \linewidth\tabudefaulttarget
+    \everypar\expandafter{%
+        \the\everypar\everypar\expandafter{\the\everypar}%
+            \setbox\z@=\lastbox
+            \ifdim\wd\z@>\z@ \edef\tabu@thetarget
+                {\the\dimexpr -\wd\z@+\tabudefaulttarget}\fi
+            \box\z@}%
+    \fi\fi
+}% \tabu@indent
+\def\tabu@setcleanup {% saves last global assignments
+    \ifodd 1\ifmmode \else \iftabu@long \else 0\fi\fi\relax
+        \def\tabu@aftergroupcleanup{%
+                \def\tabu@aftergroupcleanup{\aftergroup\tabu@cleanup}}%
+    \else
+        \def\tabu@aftergroupcleanup{%
+                \aftergroup\aftergroup\aftergroup\tabu@cleanup
+                \let\tabu@aftergroupcleanup \relax}%
+    \fi
+    \let\tabu@arc@Gsave         \tabu@arc@G
+    \let\tabu@arc@G             \tabu@arc@L   % <init>
+    \let\tabu@drsc@Gsave        \tabu@drsc@G
+    \let\tabu@drsc@G            \tabu@drsc@L  % <init>
+    \let\tabu@ls@Gsave          \tabu@ls@G
+    \let\tabu@ls@G              \tabu@ls@L    % <init>
+    \let\tabu@rc@Gsave          \tabu@rc@G
+    \let\tabu@rc@G              \tabu@rc@L    % <init>
+    \let\tabu@evr@Gsave         \tabu@evr@G
+    \let\tabu@evr@G             \tabu@evr@L   % <init>
+    \let\tabu@celllalign@save   \tabu@celllalign
+    \let\tabu@cellralign@save   \tabu@cellralign
+    \let\tabu@cellleft@save     \tabu@cellleft
+    \let\tabu@cellright@save    \tabu@cellright
+    \let\tabu@@celllalign@save  \tabu@@celllalign
+    \let\tabu@@cellralign@save  \tabu@@cellralign
+    \let\tabu@@cellleft@save    \tabu@@cellleft
+    \let\tabu@@cellright@save   \tabu@@cellright
+    \let\tabu@rowfontreset@save \tabu@rowfontreset
+    \let\tabu@@rowfontreset@save\tabu@@rowfontreset
+    \let\tabu@rowfontreset      \@empty
+    \edef\tabu@alloc@save      {\the\tabu@alloc}%   restore at \tabu@reset
+    \edef\c@taburow@save       {\the\c@taburow}%
+    \edef\tabu@naturalX@save   {\the\tabu@naturalX}%
+    \let\tabu@naturalXmin@save  \tabu@naturalXmin
+    \let\tabu@naturalXmax@save  \tabu@naturalXmax
+    \let\tabu@mkarstrut@save    \tabu@mkarstrut
+    \edef\tabu@clarstrut{%
+        \extrarowheight \the\dimexpr \ht\@arstrutbox-\ht\strutbox \relax
+        \extrarowdepth \the\dimexpr \dp\@arstrutbox-\dp\strutbox \relax
+        \let\noexpand\@arraystretch \@ne \noexpand\tabu@rearstrut}%
+}% \tabu@setcleanup
+\def\tabu@cleanup {\begingroup
+    \globaldefs\@ne         \tabu@everyrowtrue
+    \let\tabu@arc@G         \tabu@arc@Gsave
+    \let\CT@arc@            \tabu@arc@G
+    \let\tabu@drsc@G        \tabu@drsc@Gsave
+    \let\CT@drsc@           \tabu@drsc@G
+    \let\tabu@ls@G          \tabu@ls@Gsave
+    \let\tabu@ls@           \tabu@ls@G
+    \let\tabu@rc@G          \tabu@rc@Gsave
+    \let\tabu@rc@           \tabu@rc@G
+    \let\CT@do@color        \relax
+    \let\tabu@evr@G         \tabu@evr@Gsave
+    \let\tabu@celllalign    \tabu@celllalign@save
+    \let\tabu@cellralign    \tabu@cellralign@save
+    \let\tabu@cellleft      \tabu@cellleft@save
+    \let\tabu@cellright     \tabu@cellright@save
+    \let\tabu@@celllalign   \tabu@@celllalign@save
+    \let\tabu@@cellralign   \tabu@@cellralign@save
+    \let\tabu@@cellleft     \tabu@@cellleft@save
+    \let\tabu@@cellright    \tabu@@cellright@save
+    \let\tabu@rowfontreset  \tabu@rowfontreset@save
+    \let\tabu@@rowfontreset \tabu@@rowfontreset@save
+    \tabu@naturalX         =\tabu@naturalX@save
+    \let\tabu@naturalXmax   \tabu@naturalXmax@save
+    \let\tabu@naturalXmin   \tabu@naturalXmin@save
+    \let\tabu@mkarstrut     \tabu@mkarstrut@save
+    \c@taburow             =\c@taburow@save
+    \ifcase \tabu@nested    \tabu@alloc \m@ne\fi
+    \endgroup               % <end of \globaldefs>
+    \ifcase \tabu@nested
+        \the\tabu@footnotes \global\tabu@footnotes{}%
+        \tabu@afterendpar   \tabu@elapsedtime
+    \fi
+    \tabu@clarstrut
+    \everyrow\expandafter   {\tabu@evr@G}%
+}% \tabu@cleanup
+\let\tabu@afterendpar \relax
+\def\tabu@setreset {%
+    \edef\tabu@savedparams {%         \relax for \tabu@message@save
+        \ifmmode \col@sep \the\arraycolsep
+        \else    \col@sep \the\tabcolsep \fi    \relax
+        \arrayrulewidth   \the\arrayrulewidth   \relax
+        \doublerulesep    \the\doublerulesep    \relax
+        \extratabsurround \the\extratabsurround \relax
+        \extrarowheight   \the\extrarowheight   \relax
+        \extrarowdepth    \the\extrarowdepth    \relax
+        \abovetabulinesep \the\abovetabulinesep \relax
+        \belowtabulinesep \the\belowtabulinesep \relax
+        \def\noexpand\arraystretch{\arraystretch}%
+        \ifdefined\minrowclearance \minrowclearance\the\minrowclearance\relax\fi}%
+    \begingroup
+        \@temptokena\expandafter{\tabu@savedparams}% => only for \savetabu / \usetabu
+        \ifx \tabu@arc@L\relax  \else \tabu@setsave \tabu@arc@L \fi
+        \ifx \tabu@drsc@L\relax \else \tabu@setsave \tabu@drsc@L \fi
+        \tabu@setsave \tabu@ls@L      \tabu@setsave \tabu@evr@L
+        \expandafter \endgroup \expandafter
+            \def\expandafter\tabu@saved@ \expandafter{\the\@temptokena
+                \let\tabu@arc@G  \tabu@arc@L
+                \let\tabu@drsc@G \tabu@drsc@L
+                \let\tabu@ls@G   \tabu@ls@L
+                \let\tabu@rc@G   \tabu@rc@L
+                \let\tabu@evr@G  \tabu@evr@L}%
+    \def\tabu@reset{\tabu@savedparams
+        \tabu@everyrowtrue  \c@taburow \z@
+        \let\CT@arc@        \tabu@arc@L
+        \let\CT@drsc@       \tabu@drsc@L
+        \let\tabu@ls@       \tabu@ls@L
+        \let\tabu@rc@       \tabu@rc@L
+        \global\tabu@alloc  \tabu@alloc@save
+        \everyrow\expandafter{\tabu@evr@L}}%
+}% \tabu@reset
+\def\tabu@setsave #1{\expandafter\tabu@sets@ve #1\@nil{#1}}
+\long\def\tabu@sets@ve #1\@nil #2{\@temptokena\expandafter{\the\@temptokena \def#2{#1}}}
+%% The Rewriting Process -------------------------------------------
+\def\tabu@newcolumntype #1{%
+    \expandafter\tabu@new@columntype
+        \csname NC@find@\string#1\expandafter\endcsname
+        \csname NC@rewrite@\string#1\endcsname
+        {#1}%
+}% \tabu@newcolumntype
+\def\tabu@new@columntype #1#2#3{%
+    \def#1##1#3{\NC@{##1}}%
+    \let#2\relax \newcommand*#2%
+}% \tabu@new@columntype
+\def\tabu@privatecolumntype #1{%
+    \expandafter\tabu@private@columntype
+        \csname NC@find@\string#1\expandafter\endcsname
+        \csname NC@rewrite@\string#1\expandafter\endcsname
+        \csname tabu@NC@find@\string#1\expandafter\endcsname
+        \csname tabu@NC@rewrite@\string#1\endcsname
+        {#1}%
+}% \tabu@privatecolumntype
+\def\tabu@private@columntype#1#2#3#4{%
+    \g@addto@macro\tabu@privatecolumns{\let#1#3\let#2#4}%
+    \tabu@new@columntype#3#4%
+}% \tabu@private@columntype
+\let\tabu@privatecolumns \@empty
+\newcommand*\tabucolumn [1]{\expandafter \def \expandafter
+    \tabu@highprioritycolumns\expandafter{\tabu@highprioritycolumns
+                                          \NC@do #1}}%
+\let\tabu@highprioritycolumns \@empty
+%% The  |  ``column'' : rewriting process --------------------------
+\tabu@privatecolumntype |{\tabu@rewritevline}
+\newcommand*\tabu@rewritevline[1][]{\tabu@vlinearg{#1}%
+                \expandafter \NC@find \tabu@rewritten}
+\def\tabu@lines #1{%
+    \ifx|#1\else \tabu@privatecolumntype #1{\tabu@rewritevline}\fi
+    \NC@list\expandafter{\the\NC@list \NC@do #1}%
+}% \tabu@lines@
+\def\tabu@vlinearg #1{%
+    \ifx\\#1\\\def\tabu@thestyle {\tabu@ls@}%
+    \else\tabu@getline {#1}%
+    \fi
+    \def\tabu@rewritten ##1{\def\tabu@rewritten{!{##1\tabu@thevline}}%
+    }\expandafter\tabu@rewritten\expandafter{\tabu@thestyle}%
+    \expandafter \tabu@keepls \tabu@thestyle \@nil
+}% \tabu@vlinearg
+\def\tabu@keepls #1\@nil{%
+    \ifcat $\@cdr #1\@nil $%
+    \ifx \relax#1\else
+    \ifx \tabu@ls@#1\else
+        \let#1\relax
+        \xdef\tabu@mkpreambuffer{\tabu@mkpreambuffer
+                \tabu@savels\noexpand#1}\fi\fi\fi
+}% \tabu@keepls
+\def\tabu@thevline {\begingroup
+    \ifdefined\tabu@leaders
+        \setbox\@tempboxa=\vtop to\dimexpr
+                      \ht\@arstrutbox+\dp\@arstrutbox{{\tabu@thevleaders}}%
+        \ht\@tempboxa=\ht\@arstrutbox \dp\@tempboxa=\dp\@arstrutbox
+        \box\@tempboxa
+    \else
+                \tabu@thevrule
+    \fi             \endgroup
+}% \tabu@thevline
+\def\tabu@savels #1{%
+    \expandafter\let\csname\string#1\endcsname #1%
+    \expandafter\def\expandafter\tabu@reset\expandafter{\tabu@reset
+                                                    \tabu@resetls#1}}%
+\def\tabu@resetls #1{\expandafter\let\expandafter#1\csname\string#1\endcsname}%
+%% \multicolumn inside tabu environment -----------------------------
+\tabu@newcolumntype \tabu@rewritemulticolumn{%
+    \aftergroup \tabu@endrewritemulticolumn % after \@mkpream group
+    \NC@list{\NC@do *}\tabu@textbar \tabu@lines
+    \tabu@savedecl
+    \tabu@privatecolumns
+    \NC@list\expandafter{\the\expandafter\NC@list \tabu@NC@list}%
+    \let\tabu@savels \relax
+    \NC@find
+}% \tabu@rewritemulticolumn
+\def\tabu@endrewritemulticolumn{\gdef\tabu@mkpreambuffer{}\endgroup}
+\def\tabu@multicolumn{\tabu@ifenvir \tabu@multic@lumn \tabu@multicolumnORI}
+\long\def\tabu@multic@lumn #1#2#3{\multispan{#1}\begingroup
+    \tabu@everyrowtrue
+    \NC@list{\NC@do \tabu@rewritemulticolumn}%
+    \expandafter\@gobbletwo % gobbles \multispan{#1}
+         \tabu@multicolumnORI{#1}{\tabu@rewritemulticolumn #2}%
+                {\iftabuscantokens \tabu@rescan \else \expandafter\@firstofone \fi
+                {#3}}%
+}% \tabu@multic@lumn
+%% The X column(s): rewriting process -----------------------------
+\tabu@privatecolumntype X[1][]{\begingroup \tabu@siunitx{\endgroup \tabu@rewriteX {#1}}}
+\def\tabu@nosiunitx #1{#1{}{}\expandafter \NC@find \tabu@rewritten }
+\def\tabu@siunitx   #1{\@ifnextchar \bgroup
+                     {\tabu@rewriteX@Ss{#1}}
+                      {\tabu@nosiunitx{#1}}}
+\def\tabu@rewriteX@Ss #1#2{\@temptokena{}%
+    \@defaultunits \let\tabu@temp =#2\relax\@nnil
+    \ifodd 1\ifx S\tabu@temp \else \ifx s\tabu@temp \else 0 \fi\fi
+        \def\NC@find{\def\NC@find >####1####2<####3\relax{#1 {####1}{####3}%
+            }\expandafter\NC@find \the\@temptokena \relax
+        }\expandafter\NC@rewrite@S \@gobble #2\relax
+    \else \tabu@siunitxerror
+    \fi
+    \expandafter \NC@find \tabu@rewritten
+}% \tabu@rewriteX@Ss
+\def\tabu@siunitxerror {\PackageError{tabu}{Not a S nor s column !
+        \MessageBreak X column can only embed siunitx S or s columns}\@ehd
+}% \tabu@siunitxerror
+\def\tabu@rewriteX #1#2#3{\tabu@Xarg {#1}{#2}{#3}%
+    \iftabu@measuring
+    \else \tabu@measuringtrue % first X column found in the preamble
+        \let\@halignto \relax   \let\tabu@halignto \relax
+        \iftabu@spread \tabu@spreadtarget \tabu@target \tabu@target \z@
+        \else          \tabu@spreadtarget \z@ \fi
+        \ifdim \tabu@target=\z@
+                \setlength\tabu@target \tabu@thetarget
+                \tabu@message{\tabu@message@defaulttarget}%
+        \else   \tabu@message{\tabu@message@target}\fi
+    \fi
+}% \tabu@rewriteX
+\def\tabu@rewriteXrestore #1#2#3{\let\@halignto \relax
+                                \def\tabu@rewritten{l}}
+\def\tabu@Xarg #1#2#3{%
+   \advance\tabu@Xcol \@ne      \let\tabu@Xlcr  \@empty
+   \let\tabu@Xdisp    \@empty   \let\tabu@Xmath \@empty
+    \ifx\\#1\\%    <shortcut when no option>
+         \def\tabu@rewritten{p}\tabucolX \p@        % <default coef = 1>
+    \else
+         \let\tabu@rewritten \@empty   \let\tabu@temp \@empty  \tabucolX \z@
+         \tabu@Xparse {}#1\relax
+    \fi
+    \tabu@Xrewritten{#2}{#3}%
+}% \tabu@Xarg
+\def\tabu@Xparse #1{\futurelet\@let@token \tabu@Xtest}
+\expandafter\def\expandafter\tabu@Xparsespace\space{\tabu@Xparse{}}
+\def\tabu@Xtest{%
+   \ifcase \ifx \relax\@let@token \z@ \else
+           \if ,\@let@token \m@ne\else
+           \if p\@let@token 1\else
+           \if m\@let@token 2\else
+           \if b\@let@token 3\else
+           \if l\@let@token 4\else
+           \if c\@let@token 5\else
+           \if r\@let@token 6\else
+           \if j\@let@token 7\else
+           \if L\@let@token 8\else
+           \if C\@let@token 9\else
+           \if R\@let@token 10\else
+           \if J\@let@token 11\else
+           \ifx \@sptoken\@let@token 12\else
+           \if .\@let@token 13\else
+           \if -\@let@token 13\else
+           \ifcat $\@let@token 14\else
+           15\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\relax
+   \or \tabu@Xtype {p}%
+   \or \tabu@Xtype {m}%
+   \or \tabu@Xtype {b}%
+   \or \tabu@Xalign \raggedright\relax
+   \or \tabu@Xalign \centering\relax
+   \or \tabu@Xalign \raggedleft\relax
+   \or \tabu@Xalign \tabu@justify\relax
+   \or \tabu@Xalign \RaggedRight\raggedright
+   \or \tabu@Xalign \Centering\centering
+   \or \tabu@Xalign \RaggedLeft\raggedleft
+   \or \tabu@Xalign \justifying\tabu@justify
+   \or \expandafter \tabu@Xparsespace
+   \or \expandafter \tabu@Xcoef
+   \or \expandafter \tabu@Xm@th
+   \or \tabu@Xcoef{}%
+   \else\expandafter \tabu@Xparse
+   \fi
+}% \tabu@Xtest
+\def\tabu@Xalign #1#2{%
+    \ifx \tabu@Xlcr\@empty \else \PackageWarning{tabu}
+       {Duplicate horizontal alignment specification}\fi
+    \ifdefined#1\def\tabu@Xlcr{#1}\let#1\relax
+    \else       \def\tabu@Xlcr{#2}\let#2\relax\fi
+    \expandafter\tabu@Xparse
+}% \tabu@Xalign
+\def\tabu@Xtype #1{%
+    \ifx \tabu@rewritten\@empty \else \PackageWarning{tabu}
+            {Duplicate vertical alignment specification}\fi
+    \def\tabu@rewritten{#1}\expandafter\tabu@Xparse
+}% \tabu@Xtype
+\def\tabu@Xcoef#1{\edef\tabu@temp{\tabu@temp#1}%
+    \afterassignment\tabu@Xc@ef \tabu@cnt\number\if-#10\fi
+}% \tabu@Xcoef
+\def\tabu@Xc@ef{\advance\tabucolX \tabu@temp\the\tabu@cnt\p@
+    \tabu@Xparse{}%
+}% \tabu@Xc@ef
+\def\tabu@Xm@th #1{\futurelet \@let@token \tabu@Xd@sp}
+\def\tabu@Xd@sp{\let\tabu@Xmath=$%
+    \ifx $\@let@token \def\tabu@Xdisp{\displaystyle}%
+            \expandafter\tabu@Xparse
+    \else   \expandafter\tabu@Xparse\expandafter{\expandafter}%
+    \fi
+}% \tabu@Xd@sp
+\def\tabu@Xrewritten {%
+   \ifx  \tabu@rewritten\@empty \def\tabu@rewritten{p}\fi
+   \ifdim \tabucolX<\z@         \tabu@negcoeftrue
+   \else\ifdim \tabucolX=\z@    \tabucolX \p@
+   \fi\fi
+   \edef\tabu@temp{{\the\tabu@Xcol}{\tabu@strippt\tabucolX}}%
+   \edef\tabu@Xcoefs{\tabu@Xcoefs    \tabu@      \tabu@temp}%
+   \edef\tabu@rewritten ##1##2{\def\noexpand\tabu@rewritten{%
+        >{\tabu@Xlcr \ifx$\tabu@Xmath$\tabu@Xdisp\fi ##1}%
+                    \tabu@rewritten {\tabu@hsize \tabu@temp}%
+        <{##2\ifx$\tabu@Xmath$\fi}}%
+   }\tabu@rewritten
+}% \tabu@Xrewritten
+\def\tabu@hsize #1#2{%
+    \ifdim #2\p@<\z@
+        \ifdim \tabucolX=\maxdimen \tabu@wd{#1}\else
+        \ifdim \tabu@wd{#1}<-#2\tabucolX \tabu@wd{#1}\else -#2\tabucolX\fi
+        \fi
+   \else #2\tabucolX
+   \fi
+}% \tabu@hsize
+%% \usetabu  and  \preamble: rewriting process ---------------------
+\tabu@privatecolumntype \usetabu [1]{%
+    \ifx\\#1\\\tabu@saveerr{}\else
+        \@ifundefined{tabu@saved@\string#1}
+            {\tabu@saveerr{#1}}
+            {\let\tabu@rewriteX \tabu@rewriteXrestore
+             \csname tabu@saved@\string#1\expandafter\endcsname\expandafter\@ne}%
+    \fi
+}% \NC@rewrite@\usetabu
+\tabu@privatecolumntype \preamble [1]{%
+    \ifx\\#1\\\tabu@saveerr{}\else
+        \@ifundefined{tabu@saved@\string#1}
+            {\tabu@saveerr{#1}}
+            {\csname tabu@saved@\string#1\expandafter\endcsname\expandafter\z@}%
+    \fi
+}% \NC@rewrite@\preamble
+%% Controlling the rewriting process -------------------------------
+\tabu@newcolumntype \tabu@rewritefirst{%
+    \iftabu@long    \aftergroup \tabu@longpream  % <the whole implementation is here !>
+    \else           \aftergroup \tabu@pream
+    \fi
+    \let\tabu@          \relax      \let\tabu@hsize     \relax
+    \let\tabu@Xcoefs    \@empty     \let\tabu@savels    \relax
+    \tabu@Xcol          \z@         \tabu@cnt           \tw@
+    \gdef\tabu@mkpreambuffer{\tabu@{}}\tabu@measuringfalse
+    \global\setbox\@arstrutbox \box\@arstrutbox
+    \NC@list{\NC@do *}\tabu@textbar \tabu@lines
+    \NC@list\expandafter{\the\NC@list \NC@do X}%
+    \iftabu@siunitx     % <siunitx S and s columns>
+            \NC@list\expandafter{\the\NC@list \NC@do S\NC@do s}\fi
+    \NC@list\expandafter{\the\expandafter\NC@list \tabu@highprioritycolumns}%
+    \expandafter\def\expandafter\tabu@NC@list\expandafter{%
+                    \the\expandafter\NC@list \tabu@NC@list}%    % * | X S <original>
+    \NC@list\expandafter{\expandafter \NC@do \expandafter\usetabu
+                         \expandafter \NC@do \expandafter\preamble
+                         \the\NC@list \NC@do \tabu@rewritemiddle
+                                      \NC@do \tabu@rewritelast}%
+    \tabu@savedecl
+    \tabu@privatecolumns
+    \edef\tabu@prev{\the\@temptokena}\NC@find \tabu@rewritemiddle
+}% NC@rewrite@\tabu@rewritefirst
+\tabu@newcolumntype \tabu@rewritemiddle{%
+    \edef\tabu@temp{\the\@temptokena}\NC@find \tabu@rewritelast
+}% \NC@rewrite@\tabu@rewritemiddle
+\tabu@newcolumntype \tabu@rewritelast{%
+    \ifx \tabu@temp\tabu@prev   \advance\tabu@cnt \m@ne
+            \NC@list\expandafter{\tabu@NC@list \NC@do \tabu@rewritemiddle
+                                               \NC@do \tabu@rewritelast}%
+    \else \let\tabu@prev\tabu@temp
+    \fi
+    \ifcase \tabu@cnt   \expandafter\tabu@endrewrite
+    \else               \expandafter\NC@find \expandafter\tabu@rewritemiddle
+    \fi
+}% \NC@rewrite@\tabu@rewritelast
+%% Choosing the strategy --------------------------------------------
+\def\tabu@endrewrite {%
+    \let\tabu@temp \NC@find
+    \ifx \@arrayright\relax \let\@arrayright \@empty  \fi
+    \count@=%
+        \ifx \@finalstrut\tabu@finalstrut \z@ % outer in mode 0 print
+             \iftabu@measuring
+                \xdef\tabu@mkpreambuffer{\tabu@mkpreambuffer
+                    \tabu@target        \csname tabu@\the\tabu@nested.T\endcsname
+                    \tabucolX           \csname tabu@\the\tabu@nested.X\endcsname
+                    \edef\@halignto {\ifx\@arrayright\@empty to\tabu@target\fi}}%
+             \fi
+        \else\iftabu@measuring        4       % X columns
+                \xdef\tabu@mkpreambuffer{\tabu@{\tabu@mkpreambuffer
+                    \tabu@target        \the\tabu@target
+                    \tabu@spreadtarget  \the\tabu@spreadtarget}%
+                    \def\noexpand\tabu@Xcoefs{\tabu@Xcoefs}%
+                    \edef\tabu@halignto{\ifx \@arrayright\@empty to\tabu@target\fi}}%
+                 \let\tabu@Xcoefs \relax
+             \else\ifcase\tabu@nested \thr@@  % outer, no X
+                                      \global\let\tabu@afterendpar \relax
+                  \else               \@ne    % inner, no X, outer in mode 1 or 2
+                  \fi
+                  \ifdefined\tabu@usetabu
+                  \else \ifdim\tabu@target=\z@
+                  \else \let\tabu@temp \tabu@extracolsep
+                  \fi\fi
+             \fi
+        \fi
+    \xdef\tabu@mkpreambuffer{\count@ \the\count@ \tabu@mkpreambuffer}%
+    \tabu@temp
+}% \tabu@endrewrite
+\def\tabu@extracolsep{\@defaultunits    \expandafter\let
+    \expandafter\tabu@temp \expandafter=\the\@temptokena \relax\@nnil
+    \ifx \tabu@temp\@sptoken
+        \expandafter\tabu@gobblespace \expandafter\tabu@extracolsep
+    \else
+        \edef\tabu@temp{\noexpand\NC@find
+            \if |\noexpand\tabu@temp        @%
+            \else\if !\noexpand\tabu@temp   @%
+            \else                           !%
+            \fi\fi
+            {\noexpand\extracolsep\noexpand\@flushglue}}%
+    \fi
+    \tabu@temp
+}% \tabu@extrac@lsep
+%% Implementing the strategy ----------------------------------------
+\long\def\tabu@pream #1\@preamble {%
+    \let\tabu@ \tabu@@  \tabu@mkpreambuffer     \tabu@aftergroupcleanup
+    \NC@list\expandafter {\tabu@NC@list}%    in case of nesting...
+    \ifdefined\tabu@usetabu \tabu@usetabu \tabu@target \z@ \fi
+    \let\tabu@savedpreamble \@preamble
+    \global\let\tabu@elapsedtime \relax
+    \tabu@thebody ={#1\tabu@aftergroupcleanup}%
+    \tabu@thebody =\expandafter{\the\expandafter\tabu@thebody
+                                                \@preamble}%
+    \edef\tabuthepreamble {\the\tabu@thebody}% ( no @ allowed for \scantokens )
+    \tabu@select
+}% \tabu@pream
+\long\def\tabu@longpream #1\LT@bchunk #2\LT@bchunk{%
+    \let\tabu@ \tabu@@  \tabu@mkpreambuffer     \tabu@aftergroupcleanup
+    \NC@list\expandafter {\tabu@NC@list}%    in case of nesting...
+    \let\tabu@savedpreamble \@preamble
+    \global\let\tabu@elapsedtime \relax
+    \tabu@thebody ={#1\LT@bchunk #2\tabu@aftergroupcleanup \LT@bchunk}%
+    \edef\tabuthepreamble {\the\tabu@thebody}% ( no @ allowed for \scantokens )
+    \tabu@select
+}% \tabu@longpream
+\def\tabu@select {%
+    \ifnum\tabu@nested>\z@ \tabuscantokensfalse \fi
+    \ifnum \count@=\@ne \iftabu@measuring \count@=\tw@ \fi\fi
+    \ifcase \count@
+        \global\let\tabu@elapsedtime \relax
+        \tabu@seteverycr
+        \expandafter \tabuthepreamble       % vertical adjustment (inherited from outer)
+    \or      % exit in vertical measure + struts per cell because no X and outer in mode 3
+        \tabu@evr{\tabu@verticalinit}\tabu@celllalign@def{\tabu@verticalmeasure}%
+        \def\tabu@cellralign{\tabu@verticalspacing}%
+        \tabu@seteverycr
+        \expandafter \tabuthepreamble
+    \or                            % exit without measure because no X and outer in mode 4
+        \tabu@evr{}\tabu@celllalign@def{}\let\tabu@cellralign \@empty
+        \tabu@seteverycr
+        \expandafter \tabuthepreamble
+    \else                                   % needs trials
+        \tabu@evr{}\tabu@celllalign@def{}\let\tabu@cellralign \@empty
+        \tabu@savecounters
+        \expandafter \tabu@setstrategy
+    \fi
+}% \tabu@select
+\def\tabu@@ {\gdef\tabu@mkpreambuffer}
+%% Protections to set up before trials ------------------------------
+\def\tabu@setstrategy {\begingroup  % <trials group>
+    \tabu@trialh@@k    \tabu@cnt    \z@  % number of trials
+    \hbadness          \@M          \let\hbadness          \@tempcnta
+    \hfuzz             \maxdimen    \let\hfuzz             \@tempdima
+    \let\write         \tabu@nowrite\let\GenericError      \tabu@GenericError
+    \let\savetabu      \@gobble     \let\tabudefaulttarget \linewidth
+    \let\@footnotetext \@gobble     \let\@xfootnote        \tabu@xfootnote
+    \let\color         \tabu@nocolor\let\rowcolor          \tabu@norowcolor
+    \let\tabu@aftergroupcleanup \relax % only after the last trial
+    \tabu@mkpreambuffer
+    \ifnum \count@>\thr@@ \let\@halignto \@empty  \tabucolX@init
+                          \def\tabu@lasttry{\m@ne\p@}\fi
+    \begingroup \iffalse{\fi \ifnum0=`}\fi
+        \toks@{}\def\tabu@stack{b}\iftabuscantokens \endlinechar=10 \obeyspaces \fi %
+                                  \tabu@collectbody \tabu@strategy %
+}% \tabu@setstrategy
+\def\tabu@savecounters{%
+    \def\@elt ##1{\csname c@##1\endcsname\the\csname c@##1\endcsname}%
+    \edef\tabu@clckpt {\begingroup \globaldefs=\@ne \cl@@ckpt \endgroup}\let\@elt \relax
+}% \tabu@savecounters
+\def\tabucolX@init {%  \tabucolX <= \tabu@target / (sum coefs > 0)
+    \dimen@ \z@ \tabu@Xsum \z@ \tabucolX \z@ \let\tabu@ \tabu@Xinit \tabu@Xcoefs
+    \ifdim \dimen@>\z@
+        \@tempdima \dimexpr \tabu@target *\p@/\dimen@ + \tabu@hfuzz\relax
+        \ifdim \tabucolX<\@tempdima \tabucolX \@tempdima \fi
+    \fi
+}% \tabucolX@init
+\def\tabu@Xinit #1#2{\tabu@Xcol #1 \advance \tabu@Xsum
+    \ifdim #2\p@>\z@ #2\p@  \advance\dimen@ #2\p@
+    \else           -#2\p@  \tabu@negcoeftrue
+                            \@tempdima \dimexpr \tabu@target*\p@/\dimexpr-#2\p@\relax \relax
+                            \ifdim \tabucolX<\@tempdima \tabucolX \@tempdima \fi
+                            \tabu@wddef{#1}{0pt}%
+    \fi
+}% \tabu@Xinit
+%% Collecting the environment body ----------------------------------
+\long\def\tabu@collectbody #1#2\end #3{%
+    \edef\tabu@stack{\tabu@pushbegins #2\begin\end\expandafter\@gobble\tabu@stack}%
+    \ifx \tabu@stack\@empty
+        \toks@\expandafter{\expandafter\tabu@thebody\expandafter{\the\toks@ #2}%
+                \def\tabu@end@envir{\end{#3}}%
+                \iftabuscantokens
+                    \iftabu@long \def\tabu@endenvir {\end{#3}\tabu@gobbleX}%
+                    \else        \def\tabu@endenvir {\let\endarray \@empty
+                                                     \end{#3}\tabu@gobbleX}%
+                    \fi
+                \else           \def\tabu@endenvir  {\end{#3}}\fi}%
+        \let\tabu@collectbody \tabu@endofcollect
+    \else\def\tabu@temp{#3}%
+        \ifx \tabu@temp\@empty \toks@\expandafter{\the\toks@ #2\end }%
+        \else \ifx\tabu@temp\tabu@@spxiii \toks@\expandafter{\the\toks@ #2\end #3}%
+        \else \ifx\tabu@temp\tabu@X \toks@\expandafter{\the\toks@ #2\end #3}%
+        \else \toks@\expandafter{\the\toks@ #2\end{#3}}%
+        \fi\fi\fi
+    \fi
+    \tabu@collectbody{#1}%
+}% \tabu@collectbody
+\long\def\tabu@pushbegins#1\begin#2{\ifx\end#2\else b\expandafter\tabu@pushbegins\fi}%
+\def\tabu@endofcollect #1{\ifnum0=`{}\fi
+                          \expandafter\endgroup \the\toks@  #1%
+}% \tabu@endofcollect
+%% The trials: switching between strategies -------------------------
+\def\tabu@strategy {\relax  % stops \count@ assignment !
+    \ifcase\count@          % case 0 = print with vertical adjustment (outer is finished)
+        \expandafter \tabu@endoftrials
+    \or                     % case 1 = exit in vertical measure (outer in mode 3)
+        \expandafter\xdef\csname tabu@\the\tabu@nested.T\endcsname{\the\tabu@target}%
+        \expandafter\xdef\csname tabu@\the\tabu@nested.X\endcsname{\the\tabucolX}%
+        \expandafter \tabu@endoftrials
+    \or                     % case 2 = exit with a rule replacing the table (outer in mode 4)
+        \expandafter \tabu@quickend
+    \or                     % case 3 = outer is in mode 3 because of no X
+        \begingroup
+            \tabu@evr{\tabu@verticalinit}\tabu@celllalign@def{\tabu@verticalmeasure}%
+            \def\tabu@cellralign{\tabu@verticalspacing}%
+            \expandafter \tabu@measuring
+    \else                   % case 4 = horizontal measure
+        \begingroup
+            \global\let\tabu@elapsedtime \tabu@message@etime
+            \long\def\multicolumn##1##2##3{\multispan{##1}}%
+            \let\tabu@startpboxORI \@startpbox
+            \iftabu@spread
+                    \def\tabu@naturalXmax {\z@}%
+                    \let\tabu@naturalXmin \tabu@naturalXmax
+                    \tabu@evr{\global\tabu@naturalX \z@}%
+                    \let\@startpbox \tabu@startpboxmeasure
+            \else\iftabu@negcoef
+                    \let\@startpbox \tabu@startpboxmeasure
+            \else   \let\@startpbox \tabu@startpboxquick
+            \fi\fi
+            \expandafter \tabu@measuring
+    \fi
+}% \tabu@strategy
+\def\tabu@measuring{\expandafter \tabu@trial \expandafter
+                                                \count@ \the\count@ \tabu@endtrial
+}% \tabu@measuring
+\def\tabu@trial{\iftabu@long \tabu@longtrial \else \tabu@shorttrial \fi}
+\def\tabu@shorttrial {\setbox\tabu@box \hbox\bgroup \tabu@seteverycr
+    \ifx \tabu@savecounters\relax \else
+                \let\tabu@savecounters \relax \tabu@clckpt \fi
+    $\iftabuscantokens \tabu@rescan \else \expandafter\@secondoftwo \fi
+       \expandafter{\expandafter \tabuthepreamble
+                         \the\tabu@thebody
+                         \csname tabu@adl@endtrial\endcsname
+                         \endarray}$\egroup             % got \tabu@box
+}% \tabu@shorttrial
+\def\tabu@longtrial {\setbox\tabu@box \hbox\bgroup \tabu@seteverycr
+    \ifx \tabu@savecounters\relax \else
+                \let\tabu@savecounters \relax \tabu@clckpt \fi
+    \iftabuscantokens \tabu@rescan \else \expandafter\@secondoftwo \fi
+       \expandafter{\expandafter \tabuthepreamble
+                         \the\tabu@thebody
+                         \tabuendlongtrial}\egroup      % got \tabu@box
+}% \tabu@longtrial
+\def\tabuendlongtrial{% no @ allowed for \scantokens
+    \LT@echunk  \global\setbox\@ne \hbox{\unhbox\@ne}\kern\wd\@ne
+                \LT@get@widths
+}% \tabuendlongtrial
+\def\tabu@adl@endtrial{% <arydshln in nested trials - problem for global column counters!>
+    \crcr \noalign{\global\adl@ncol \tabu@nbcols}}% anything global is crap, junky and fails !
+\def\tabu@seteverycr {\tabu@reset
+    \everycr \expandafter{\the\everycr  \tabu@everycr}%
+    \let\everycr \tabu@noeverycr                      % <for ialign>
+}% \tabu@seteverycr
+\def\tabu@noeverycr{{\aftergroup\tabu@restoreeverycr \afterassignment}\toks@}
+\def\tabu@restoreeverycr {\let\everycr \tabu@@everycr}
+\def\tabu@everycr {\iftabu@everyrow \noalign{\tabu@everyrow}\fi}
+\def\tabu@endoftrials {%
+    \iftabuscantokens   \expandafter\@firstoftwo
+    \else               \expandafter\@secondoftwo
+    \fi
+        {\expandafter \tabu@closetrialsgroup \expandafter
+         \tabu@rescan \expandafter{%
+                    \expandafter\tabuthepreamble
+                        \the\expandafter\tabu@thebody
+                                    \iftabu@long \else \endarray \fi}}
+        {\expandafter\tabu@closetrialsgroup \expandafter
+                    \tabuthepreamble
+                        \the\tabu@thebody}%
+                                        \tabu@endenvir      % Finish !
+}% \tabu@endoftrials
+\def\tabu@closetrialsgroup {%
+    \toks@\expandafter{\tabu@endenvir}%
+    \edef\tabu@bufferX{\endgroup
+        \tabucolX       \the\tabucolX
+        \tabu@target    \the\tabu@target
+        \tabu@cnt       \the\tabu@cnt
+        \def\noexpand\tabu@endenvir{\the\toks@}%
+        %Quid de \@halignto = \tabu@halignto ??
+    }% \tabu@bufferX
+    \tabu@bufferX
+    \ifcase\tabu@nested % print out (outer in mode 0)
+        \global\tabu@cnt \tabu@cnt
+        \tabu@evr{\tabu@verticaldynamicadjustment}%
+        \tabu@celllalign@def{\everypar{}}\let\tabu@cellralign \@empty
+        \let\@finalstrut \tabu@finalstrut
+    \else               % vertical measure of nested tabu
+        \tabu@evr{\tabu@verticalinit}%
+        \tabu@celllalign@def{\tabu@verticalmeasure}%
+        \def\tabu@cellralign{\tabu@verticalspacing}%
+    \fi
+    \tabu@clckpt \let\@halignto \tabu@halignto
+    \let\@halignto \@empty
+    \tabu@seteverycr
+    \ifdim \tabustrutrule>\z@ \ifnum\tabu@nested=\z@
+        \setbox\@arstrutbox \box\voidb@x % force \@arstrutbox to be rebuilt (visible struts)
+    \fi\fi
+}% \tabu@closetrialsgroup
+\def\tabu@quickend {\expandafter \endgroup \expandafter
+                        \tabu@target \the\tabu@target \tabu@quickrule
+                        \let\endarray \relax \tabu@endenvir
+}% \tabu@quickend
+\def\tabu@endtrial {\relax      % stops \count@ assignment !
+    \ifcase \count@ \tabu@err   % case 0 = impossible here
+    \or             \tabu@err   % case 1 = impossible here
+    \or             \tabu@err   % case 2 = impossible here
+    \or                         % case 3 = outer goes into mode 0
+        \def\tabu@bufferX{\endgroup}\count@ \z@
+    \else                       % case 4 = outer goes into mode 3
+        \iftabu@spread  \tabu@spreadarith % inner into mode 1 (outer in mode 3)
+        \else           \tabu@arith       %              or 2 (outer in mode 4)
+        \fi
+        \count@=%
+            \ifcase\tabu@nested     \thr@@  % outer goes into mode 3
+            \else\iftabu@measuring  \tw@    % outer is in mode 4
+            \else                   \@ne    % outer is in mode 3
+            \fi\fi
+        \edef\tabu@bufferX{\endgroup
+                           \tabucolX        \the\tabucolX
+                           \tabu@target     \the\tabu@target}%
+    \fi
+    \expandafter \tabu@bufferX \expandafter
+                                    \count@ \the\count@  \tabu@strategy
+}% \tabu@endtrial
+\def\tabu@err{\errmessage{(tabu) Internal impossible error! (\count@=\the\count@)}}
+%% The algorithms: compute the widths / stop or go on ---------------
+\def\tabu@arithnegcoef {%
+    \@tempdima \z@ \dimen@ \z@ \let\tabu@ \tabu@arith@negcoef \tabu@Xcoefs
+}% \tabu@arithnegcoef
+\def\tabu@arith@negcoef #1#2{%
+    \ifdim #2\p@>\z@    \advance\dimen@     #2\p@       % saturated by definition
+                        \advance\@tempdima  #2\tabucolX
+    \else
+        \ifdim -#2\tabucolX <\tabu@wd{#1}% c_i X < natural width <= \tabu@target-> saturated
+                        \advance\dimen@     -#2\p@
+                        \advance\@tempdima  -#2\tabucolX
+        \else
+                        \advance\@tempdima \tabu@wd{#1}% natural width <= c_i X => neutralised
+                        \ifdim \tabu@wd{#1}<\tabu@target \else % neutralised
+                        \advance\dimen@     -#2\p@ % saturated (natural width = tabu@target)
+                        \fi
+        \fi
+    \fi
+}% \tabu@arith@negcoef
+\def\tabu@givespace #1#2{% here \tabu@DELTA < \z@
+    \ifdim \@tempdima=\z@
+        \tabu@wddef{#1}{\the\dimexpr -\tabu@DELTA*\p@/\tabu@Xsum}%
+    \else
+        \tabu@wddef{#1}{\the\dimexpr \tabu@hsize{#1}{#2}
+                    *(\p@ -\tabu@DELTA*\p@/\@tempdima)/\p@\relax}%
+    \fi
+}% \tabu@givespace
+\def\tabu@arith {\advance\tabu@cnt \@ne
+    \ifnum \tabu@cnt=\@ne \tabu@message{\tabu@titles}\fi
+    \tabu@arithnegcoef
+    \@tempdimb \dimexpr \wd\tabu@box -\@tempdima \relax % <incompressible material>
+    \tabu@DELTA = \dimexpr \wd\tabu@box - \tabu@target \relax
+    \tabu@message{\tabu@message@arith}%
+    \ifdim \tabu@DELTA <\tabu@hfuzz
+        \ifdim \tabu@DELTA<\z@          % wd (tabu)<\tabu@target ?
+            \let\tabu@ \tabu@givespace \tabu@Xcoefs
+            \advance\@tempdima \@tempdimb \advance\@tempdima -\tabu@DELTA % for message
+        \else   % already converged: nothing to do but nearly impossible...
+        \fi
+        \tabucolX \maxdimen
+        \tabu@measuringfalse
+    \else                               % need for narrower X columns
+        \tabucolX =\dimexpr (\@tempdima -\tabu@DELTA) *\p@/\tabu@Xsum \relax
+        \tabu@measuringtrue
+        \@whilesw \iftabu@measuring\fi {%
+            \advance\tabu@cnt \@ne
+            \tabu@arithnegcoef
+            \tabu@DELTA =\dimexpr \@tempdima+\@tempdimb -\tabu@target \relax % always < 0 here
+            \tabu@message{\tabu@header
+                \tabu@msgalign \tabucolX { }{ }{ }{ }{ }\@@
+                \tabu@msgalign \@tempdima+\@tempdimb { }{ }{ }{ }{ }\@@
+                \tabu@msgalign \tabu@target { }{ }{ }{ }{ }\@@
+                \tabu@msgalign@PT \dimen@ { }{}{}{}{}{}{}\@@
+                \ifdim -\tabu@DELTA<\tabu@hfuzz \tabu@spaces target ok\else
+                \tabu@msgalign \dimexpr -\tabu@DELTA *\p@/\dimen@ {}{}{}{}{}\@@
+                \fi}%
+            \ifdim -\tabu@DELTA<\tabu@hfuzz
+                \advance\@tempdima \@tempdimb % for message
+                \tabu@measuringfalse
+            \else
+                \advance\tabucolX \dimexpr -\tabu@DELTA *\p@/\dimen@ \relax
+            \fi
+        }%
+    \fi
+    \tabu@message{\tabu@message@reached}%
+    \edef\tabu@bufferX{\endgroup \tabu@cnt    \the\tabu@cnt
+                                 \tabucolX    \the\tabucolX
+                                 \tabu@target \the\tabu@target}%
+}% \tabu@arith
+\def\tabu@spreadarith {%
+    \dimen@ \z@ \@tempdima \tabu@naturalXmax \let\tabu@ \tabu@spread@arith \tabu@Xcoefs
+    \edef\tabu@naturalXmin {\the\dimexpr\tabu@naturalXmin*\dimen@/\p@}%
+    \@tempdimc =\dimexpr \wd\tabu@box -\tabu@naturalXmax+\tabu@naturalXmin \relax
+    \iftabu@measuring
+        \tabu@target =\dimexpr \@tempdimc+\tabu@spreadtarget \relax
+        \edef\tabu@bufferX{\endgroup \tabucolX \the\tabucolX \tabu@target\the\tabu@target}%
+    \else
+        \tabu@message{\tabu@message@spreadarith}%
+        \ifdim \dimexpr \@tempdimc+\tabu@spreadtarget >\tabu@target
+            \tabu@message{(tabu) spread
+                \ifdim \@tempdimc>\tabu@target useless here: default target used%
+                \else too large: reduced to fit default target\fi.}%
+        \else
+            \tabu@target =\dimexpr \@tempdimc+\tabu@spreadtarget \relax
+            \tabu@message{(tabu) spread: New target set to \the\tabu@target^^J}%
+        \fi
+        \begingroup \let\tabu@wddef \@gobbletwo
+            \@tempdimb \@tempdima
+            \tabucolX@init
+            \tabu@arithnegcoef
+            \wd\tabu@box =\dimexpr \wd\tabu@box +\@tempdima-\@tempdimb \relax
+        \expandafter\endgroup \expandafter\tabucolX \the\tabucolX
+        \tabu@arith
+    \fi
+}% \tabu@spreadarith
+\def\tabu@spread@arith #1#2{%
+    \ifdim #2\p@>\z@ \advance\dimen@ #2\p@
+    \else            \advance\@tempdima \tabu@wd{#1}\relax
+    \fi
+}% \tabu@spread@arith
+%% Reporting in the .log file ---------------------------------------
+\def\tabu@message@defaulttarget{%
+    \ifnum\tabu@nested=\z@^^J(tabu) Default target:
+    \ifx\tabudefaulttarget\linewidth    \string\linewidth
+        \ifdim \tabu@thetarget=\linewidth \else
+            -\the\dimexpr\linewidth-\tabu@thetarget\fi  =
+    \else\ifx\tabudefaulttarget\linegoal\string\linegoal=
+    \fi\fi
+    \else (tabu) Default target (nested): \fi
+    \the\tabu@target \on@line
+    \ifnum\tabu@nested=\z@ , page \the\c@page\fi}
+\def\tabu@message@target {^^J(tabu) Target specified:
+   \the\tabu@target \on@line, page \the\c@page}
+\def\tabu@message@arith {\tabu@header
+    \tabu@msgalign \tabucolX { }{ }{ }{ }{ }\@@
+    \tabu@msgalign \wd\tabu@box { }{ }{ }{ }{ }\@@
+    \tabu@msgalign \tabu@target { }{ }{ }{ }{ }\@@
+    \tabu@msgalign@PT \dimen@ { }{}{}{}{}{}{}\@@
+    \ifdim \tabu@DELTA<\tabu@hfuzz giving space\else
+    \tabu@msgalign \dimexpr (\@tempdima-\tabu@DELTA) *\p@/\tabu@Xsum -\tabucolX {}{}{}{}{}\@@
+    \fi
+}% \tabu@message@arith
+\def\tabu@message@spreadarith {\tabu@spreadheader
+   \tabu@msgalign \tabu@spreadtarget { }{ }{ }{ }{}\@@
+   \tabu@msgalign \wd\tabu@box { }{ }{ }{ }{}\@@
+   \tabu@msgalign -\tabu@naturalXmax { }{}{}{}{}\@@
+   \tabu@msgalign \tabu@naturalXmin { }{ }{ }{ }{}\@@
+   \tabu@msgalign \ifdim \dimexpr\@tempdimc>\tabu@target \tabu@target
+                  \else  \@tempdimc+\tabu@spreadtarget \fi
+                  {}{}{}{}{}\@@}
+\def\tabu@message@negcoef #1#2{
+    \tabu@spaces\tabu@spaces\space * #1. X[\rem@pt#2]:
+    \space width = \tabu@wd {#1}
+        \expandafter\string\csname tabu@\the\tabu@nested.W\number#1\endcsname
+    \ifdim -\tabu@pt#2\tabucolX<\tabu@target
+    < \number-\rem@pt#2 X
+    = \the\dimexpr -\tabu@pt#2\tabucolX \relax
+    \else
+    <= \the\tabu@target\space < \number-\rem@pt#2 X\fi}
+\def\tabu@message@reached{\tabu@header
+     ******* Reached Target:
+            hfuzz = \tabu@hfuzz\on@line\space *******}
+\def\tabu@message@etime{\edef\tabu@stoptime{\the\pdfelapsedtime}%
+    \tabu@message{(tabu)\tabu@spaces Time elapsed during measure:
+    \the\numexpr(\tabu@stoptime-\tabu@starttime-32767)/65536\relax sec
+    \the\numexpr\numexpr(\tabu@stoptime-\tabu@starttime)
+    -\numexpr(\tabu@stoptime-\tabu@starttime-32767)/65536\relax*65536\relax
+    *1000/65536\relax ms \tabu@spaces(\the\tabu@cnt\space
+                                        cycle\ifnum\tabu@cnt>\@ne s\fi)^^J^^J}}
+\def\tabu@message@verticalsp {%
+    \ifdim \@tempdima>\tabu@ht
+        \ifdim \@tempdimb>\tabu@dp
+        \expandafter\expandafter\expandafter\string\tabu@ht =
+            \tabu@msgalign \@tempdima { }{ }{ }{ }{ }\@@
+        \expandafter\expandafter\expandafter\string\tabu@dp =
+            \tabu@msgalign \@tempdimb { }{ }{ }{ }{ }\@@^^J%
+        \else
+        \expandafter\expandafter\expandafter\string\tabu@ht =
+            \tabu@msgalign \@tempdima { }{ }{ }{ }{ }\@@^^J%
+        \fi
+    \else\ifdim \@tempdimb>\tabu@dp
+        \tabu@spaces\tabu@spaces\tabu@spaces
+        \expandafter\expandafter\expandafter\string\tabu@dp =
+            \tabu@msgalign \@tempdimb { }{ }{ }{ }{ }\@@^^J\fi
+    \fi
+}% \tabu@message@verticalsp
+\edef\tabu@spaces{\@spaces}
+\def\tabu@strippt{\expandafter\tabu@pt\the}
+{\@makeother\P \@makeother\T\lowercase{\gdef\tabu@pt #1PT{#1}}}
+\def\tabu@msgalign{\expandafter\tabu@msg@align\the\dimexpr}
+\def\tabu@msgalign@PT{\expandafter\tabu@msg@align\romannumeral-`\0\tabu@strippt}
+\def\do #1{%
+    \def\tabu@msg@align##1.##2##3##4##5##6##7##8##9\@@{%
+    \ifnum##1<10 #1 #1\else
+    \ifnum##1<100 #1 \else
+    \ifnum##1<\@m #1\fi\fi\fi
+    ##1.##2##3##4##5##6##7##8#1}%
+    \def\tabu@header{(tabu) \ifnum\tabu@cnt<10 #1\fi\the\tabu@cnt) }%
+    \def\tabu@titles{\ifnum \tabu@nested=\z@
+      (tabu) Try#1 #1 tabu X #1 #1 #1tabu Width #1 #1 Target
+                  #1 #1 #1 Coefs #1 #1 #1 Update^^J\fi}%
+    \def\tabu@spreadheader{%
+      (tabu) Try#1 #1 Spread #1 #1 tabu Width #1 #1 #1 Nat. X #1 #1 #1 #1Nat. Min.
+                                                      #1 New Target^^J%
+      (tabu) sprd}
+    \def\tabu@message@save {\begingroup
+        \def\x ####1{\tabu@msg@align ####1{ }{ }{ }{ }{}\@@}
+        \def\z ####1{\expandafter\x\expandafter{\romannumeral-`\0\tabu@strippt
+                                                     \dimexpr####1\p@{ }{ }}}%
+        \let\color \relax \def\tabu@rulesstyle ####1####2{\detokenize{####1}}%
+        \let\CT@arc@ \relax \let\@preamble \@gobble
+        \let\tabu@savedpream  \@firstofone
+        \let\tabu@savedparams \@firstofone
+        \def\tabu@target ####1\relax   {(tabu) target #1 #1 #1 #1 #1 = \x{####1}^^J}%
+        \def\tabucolX ####1\relax      {(tabu) X columns width#1 = \x{####1}^^J}%
+        \def\tabu@nbcols ####1\relax   {(tabu) Number of columns: \z{####1}^^J}%
+        \def\tabu@aligndefault    ####1{(tabu) Default alignment: #1 #1 ####1^^J}%
+        \def\col@sep ####1\relax       {(tabu) column sep #1 #1 #1 = \x{####1}^^J}%
+        \def\arrayrulewidth ####1\relax{(tabu) arrayrulewidth #1 = \x{####1}}%
+        \def\doublerulesep ####1\relax { doublerulesep = \x{####1}^^J}%
+        \def\extratabsurround####1\relax{(tabu) extratabsurround = \x{####1}^^J}%
+        \def\extrarowheight ####1\relax{(tabu) extrarowheight #1 = \x{####1}}%
+        \def\extrarowdepth ####1\relax {extrarowdepth = \x{####1}^^J}%
+        \def\abovetabulinesep####1\relax{(tabu) abovetabulinesep=\x{####1} }%
+        \def\belowtabulinesep####1\relax{ belowtabulinesep=\x{####1}^^J}%
+        \def\arraystretch         ####1{(tabu) arraystretch #1 #1 = \z{####1}^^J}%
+        \def\minrowclearance####1\relax{(tabu) minrowclearance #1 = \x{####1}^^J}%
+        \def\tabu@arc@L           ####1{(tabu) taburulecolor #1 #1 = ####1^^J}%
+        \def\tabu@drsc@L          ####1{(tabu) tabudoublerulecolor=  ####1^^J}%
+        \def\tabu@evr@L           ####1{(tabu) everyrow #1 #1 #1 #1 = \detokenize{####1}^^J}%
+        \def\tabu@ls@L            ####1{(tabu) line style = \detokenize{####1}^^J}%
+        \def\NC@find ####1\@nil{(tabu) tabu preamble#1 #1 = \detokenize{####1}^^J}%
+        \def\tabu@wddef####1####2{(tabu) Natural width ####1 = \x{####2}^^J}%
+        \let\edef \@gobbletwo \let\def \@empty \let\let \@gobbletwo
+        \tabu@message{%
+         (tabu) \string\savetabu{\tabu@temp}: \on@line^^J%
+         \tabu@usetabu \@nil^^J}%
+        \endgroup}
+}\do{ }
+%% Measuring the natural width (varwidth) - store the results -------
+\def\tabu@startpboxmeasure #1{\bgroup   % entering \vtop
+    \edef\tabu@temp{\expandafter\@secondoftwo \ifx\tabu@hsize #1\else\relax\fi}%
+    \ifodd 1\ifx \tabu@temp\@empty 0 \else      % starts with \tabu@hsize ?
+            \iftabu@spread           \else      % if spread -> measure
+            \ifdim \tabu@temp\p@>\z@ 0 \fi\fi\fi% if coef>0 -> do not measure
+        \let\@startpbox \tabu@startpboxORI      % restore immediately (nesting)
+        \tabu@measuringtrue                     % for the quick option...
+        \tabu@Xcol =\expandafter\@firstoftwo\ifx\tabu@hsize #1\fi
+        \ifdim \tabu@temp\p@>\z@ \ifdim \tabu@temp\tabucolX<\tabu@target
+                                        \tabu@target=\tabu@temp\tabucolX \fi\fi
+        \setbox\tabu@box  \hbox \bgroup
+            \begin{varwidth}\tabu@target
+                \let\FV@ListProcessLine \tabu@FV@ListProcessLine  % \hbox to natural width...
+                \narrowragged \arraybackslash \parfillskip \@flushglue
+                \ifdefined\pdfadjustspacing \pdfadjustspacing\z@ \fi
+                \bgroup \aftergroup\tabu@endpboxmeasure
+                \ifdefined \cellspacetoplimit \tabu@cellspacepatch \fi
+    \else \expandafter\@gobble
+                            \tabu@startpboxquick{#1}% \@gobble \bgroup
+    \fi
+}% \tabu@startpboxmeasure
+\def\tabu@cellspacepatch{\def\bcolumn##1\@nil{}\let\ecolumn\@empty
+                                          \bgroup\color@begingroup}
+\def\tabu@endpboxmeasure {%
+    \@finalstrut \@arstrutbox
+                    \end{varwidth}\egroup    % <got my \tabu@box>
+    \ifdim \tabu@temp\p@ <\z@   % neg coef
+        \ifdim \tabu@wd\tabu@Xcol <\wd\tabu@box
+            \tabu@wddef\tabu@Xcol {\the\wd\tabu@box}%
+            \tabu@debug{\tabu@message@endpboxmeasure}%
+        \fi
+    \else                       % spread coef>0
+        \global\advance \tabu@naturalX \wd\tabu@box
+        \@tempdima =\dimexpr \wd\tabu@box *\p@/\dimexpr \tabu@temp\p@\relax \relax
+        \ifdim \tabu@naturalXmax <\tabu@naturalX
+            \xdef\tabu@naturalXmax {\the\tabu@naturalX}\fi
+        \ifdim \tabu@naturalXmin <\@tempdima
+            \xdef\tabu@naturalXmin {\the\@tempdima}\fi
+    \fi
+   \box\tabu@box \egroup % end of \vtop (measure) restore \tabu@target
+}% \tabu@endpboxmeasure
+\def\tabu@wddef #1{\expandafter\xdef
+                   \csname tabu@\the\tabu@nested.W\number#1\endcsname}
+\def\tabu@wd    #1{\csname tabu@\the\tabu@nested.W\number#1\endcsname}
+\def\tabu@message@endpboxmeasure{\tabu@spaces\tabu@spaces<-> % <-> save natural wd
+    \the\tabu@Xcol. X[\tabu@temp]:
+    target = \the\tabucolX \space
+    \expandafter\expandafter\expandafter\string\tabu@wd\tabu@Xcol
+    =\tabu@wd\tabu@Xcol
+}% \tabu@message@endpboxmeasure
+\def\tabu@startpboxquick {\bgroup
+    \let\@startpbox \tabu@startpboxORI  % restore immediately
+    \let\tabu \tabu@quick               % \begin is expanded before...
+    \expandafter\@gobble \@startpbox    % gobbles \bgroup
+}% \tabu@startpboxquick
+\def\tabu@quick {\begingroup \iffalse{\fi \ifnum0=`}\fi
+    \toks@{}\def\tabu@stack{b}\tabu@collectbody \tabu@endquick
+}% \tabu@quick
+\def\tabu@endquick {%
+    \ifodd 1\ifx\tabu@end@envir\tabu@endtabu  \else
+            \ifx\tabu@end@envir\tabu@endtabus \else 0\fi\fi\relax
+            \endgroup
+    \else   \let\endtabu \relax
+            \tabu@end@envir
+    \fi
+}% \tabu@quick
+\def\tabu@endtabu   {\end{tabu}}
+\def\tabu@endtabus  {\end{tabu*}}
+%% Measuring the heights and depths - store the results -------------
+\def\tabu@verticalmeasure{\everypar{}%
+    \ifnum \currentgrouptype>12         % 14=semi-simple, 15=math shift group
+        \setbox\tabu@box =\hbox\bgroup
+            \let\tabu@verticalspacing \tabu@verticalsp@lcr
+            \d@llarbegin                % after \hbox ...
+    \else
+        \edef\tabu@temp{\ifnum\currentgrouptype=5\vtop
+                        \else\ifnum\currentgrouptype=12\vcenter
+                        \else\vbox\fi\fi}%
+        \setbox\tabu@box \hbox\bgroup$\tabu@temp \bgroup
+            \let\tabu@verticalspacing \tabu@verticalsp@pmb
+    \fi
+}% \tabu@verticalmeasure
+\def\tabu@verticalsp@lcr{%
+    \d@llarend \egroup       % <got my \tabu@box>
+    \@tempdima \dimexpr \ht\tabu@box+\abovetabulinesep
+    \@tempdimb \dimexpr \dp\tabu@box+\belowtabulinesep \relax
+        \ifdim\tabustrutrule>\z@ \tabu@debug{\tabu@message@verticalsp}\fi
+    \ifdim \tabu@ht<\@tempdima    \tabu@htdef{\the\@tempdima}\fi
+    \ifdim \tabu@dp<\@tempdimb    \tabu@dpdef{\the\@tempdimb}\fi
+    \noindent\vrule height\@tempdima depth\@tempdimb
+}% \tabu@verticalsp@lcr
+\def\tabu@verticalsp@pmb{% inserts struts as needed
+    \par \expandafter\egroup
+            \expandafter$\expandafter
+                    \egroup \expandafter
+                            \@tempdimc \the\prevdepth
+    \@tempdima \dimexpr \ht\tabu@box+\abovetabulinesep
+    \@tempdimb \dimexpr \dp\tabu@box+\belowtabulinesep \relax
+        \ifdim\tabustrutrule>\z@ \tabu@debug{\tabu@message@verticalsp}\fi
+    \ifdim \tabu@ht<\@tempdima    \tabu@htdef{\the\@tempdima}\fi
+    \ifdim \tabu@dp<\@tempdimb    \tabu@dpdef{\the\@tempdimb}\fi
+    \let\@finalstrut \@gobble
+    \hrule height\@tempdima depth\@tempdimb width\hsize
+%%    \box\tabu@box
+}% \tabu@verticalsp@pmb
+
+\def\tabu@verticalinit{%
+    \ifnum \c@taburow=\z@ \tabu@rearstrut \fi       % after \tabu@reset !
+    \advance\c@taburow \@ne
+    \tabu@htdef{\the\ht\@arstrutbox}\tabu@dpdef{\the\dp\@arstrutbox}%
+    \advance\c@taburow \m@ne
+}% \tabu@verticalinit
+\def\tabu@htdef {\expandafter\xdef \csname tabu@\the\tabu@nested.H\the\c@taburow\endcsname}
+\def\tabu@ht                      {\csname tabu@\the\tabu@nested.H\the\c@taburow\endcsname}
+\def\tabu@dpdef {\expandafter\xdef \csname tabu@\the\tabu@nested.D\the\c@taburow\endcsname}
+\def\tabu@dp                      {\csname tabu@\the\tabu@nested.D\the\c@taburow\endcsname}
+\def\tabu@verticaldynamicadjustment {%
+    \advance\c@taburow \@ne
+        \extrarowheight \dimexpr\tabu@ht - \ht\strutbox
+        \extrarowdepth  \dimexpr\tabu@dp - \dp\strutbox
+        \let\arraystretch \@empty
+    \advance\c@taburow \m@ne
+}% \tabu@verticaldynamicadjustment
+\def\tabuphantomline{\crcr \noalign{%
+    {\globaldefs \@ne
+        \setbox\@arstrutbox     \box\voidb@x
+        \let\tabu@@celllalign   \tabu@celllalign
+        \let\tabu@@cellralign   \tabu@cellralign
+        \let\tabu@@cellleft     \tabu@cellleft
+        \let\tabu@@cellright    \tabu@cellright
+        \let\tabu@@thevline     \tabu@thevline
+        \let\tabu@celllalign    \@empty
+        \let\tabu@cellralign    \@empty
+        \let\tabu@cellright     \@empty
+        \let\tabu@cellleft      \@empty
+        \let\tabu@thevline      \relax}%
+    \edef\tabu@temp{\tabu@multispan \tabu@nbcols{\noindent &}}%
+    \toks@\expandafter{\tabu@temp \noindent\tabu@everyrowfalse \cr
+        \noalign{\tabu@rearstrut
+            {\globaldefs\@ne
+                \let\tabu@celllalign \tabu@@celllalign
+                \let\tabu@cellralign \tabu@@cellralign
+                \let\tabu@cellleft   \tabu@@cellleft
+                \let\tabu@cellright  \tabu@@cellright
+                \let\tabu@thevline   \tabu@@thevline}}}%
+    \expandafter}\the\toks@
+}% \tabuphantomline
+%% \firsthline and \lasthline corrections ---------------------------
+\def\tabu@firstline {\tabu@hlineAZ  \tabu@firsthlinecorrection     {}}
+\def\tabu@firsthline{\tabu@hlineAZ  \tabu@firsthlinecorrection \hline}
+\def\tabu@lastline  {\tabu@hlineAZ  \tabu@lasthlinecorrection      {}}
+\def\tabu@lasthline {\tabu@hlineAZ  \tabu@lasthlinecorrection  \hline}
+\def\tabu@hline {% replaces \hline if no colortbl (see \AtBeginDocument)
+    \noalign{\ifnum0=`}\fi
+    {\CT@arc@\hrule height\arrayrulewidth}%
+    \futurelet \tabu@temp \tabu@xhline
+}% \tabu@hline
+\def\tabu@xhline{%
+    \ifx \tabu@temp \hline
+        {\ifx \CT@drsc@\relax \vskip
+         \else\ifx \CT@drsc@\@empty \vskip
+         \else \CT@drsc@\hrule height
+         \fi\fi
+         \doublerulesep}%
+    \fi
+    \ifnum0=`{\fi}%
+}% \tabu@xhline
+\def\tabu@hlineAZ #1#2{\noalign{\ifnum0=`}\fi \dimen@ \z@ \count@ \z@
+    \toks@{}\def\tabu@hlinecorrection{#1}\def\tabu@temp{#2}%
+    \tabu@hlineAZsurround
+}% \tabu@hlineAZ
+\newcommand*\tabu@hlineAZsurround[1][\extratabsurround]{%
+    \extratabsurround #1\let\tabucline \tabucline@scan
+    \let\hline     \tabu@hlinescan \let\firsthline \hline
+    \let\cline     \tabu@clinescan \let\lasthline  \hline
+    \expandafter \futurelet \expandafter \tabu@temp
+                \expandafter \tabu@nexthlineAZ \tabu@temp
+}% \tabu@hlineAZsurround
+\def\tabu@hlinescan   {\tabu@thick \arrayrulewidth \tabu@xhlineAZ \hline}
+\def\tabu@clinescan #1{\tabu@thick \arrayrulewidth \tabu@xhlineAZ {\cline{#1}}}
+\def\tabucline@scan{\@testopt \tabucline@sc@n {}}
+\def\tabucline@sc@n #1[#2]{\tabu@xhlineAZ {\tabucline[{#1}]{#2}}}
+\def\tabu@nexthlineAZ{%
+    \ifx \tabu@temp\hline \else
+    \ifx \tabu@temp\cline \else
+    \ifx \tabu@temp\tabucline \else
+         \tabu@hlinecorrection
+    \fi\fi\fi
+}% \tabu@nexthlineAZ
+\def\tabu@xhlineAZ #1{%
+    \toks@\expandafter{\the\toks@ #1}%
+    \@tempdimc \tabu@thick                  % The last line width
+    \ifcase\count@ \@tempdimb \tabu@thick   % The first line width
+    \else \advance\dimen@ \dimexpr \tabu@thick+\doublerulesep \relax
+    \fi
+    \advance\count@ \@ne    \futurelet \tabu@temp \tabu@nexthlineAZ
+}% \tabu@xhlineAZ
+\def\tabu@firsthlinecorrection{% \count@ = number of \hline -1
+    \@tempdima \dimexpr \ht\@arstrutbox+\dimen@
+    \edef\firsthline{%      <local in \noalign>
+        \omit \hbox to\z@{\hss{\noexpand\tabu@DBG{yellow}\vrule
+                    height \the\dimexpr\@tempdima+\extratabsurround
+                    depth  \dp\@arstrutbox
+                    width  \tabustrutrule}\hss}\cr
+        \noalign{\vskip -\the\dimexpr   \@tempdima+\@tempdimb
+                                        +\dp\@arstrutbox \relax}%
+        \the\toks@
+   }\ifnum0=`{\fi
+            \expandafter}\firsthline % we are then !
+}% \tabu@firsthlinecorrection
+\def\tabu@lasthlinecorrection{%
+    \@tempdima \dimexpr  \dp\@arstrutbox+\dimen@+\@tempdimb+\@tempdimc
+    \edef\lasthline{%   <local in \noalign>
+        \the\toks@
+        \noalign{\vskip -\the\dimexpr\dimen@+\@tempdimb+\dp\@arstrutbox}%
+        \omit \hbox to\z@{\hss{\noexpand\tabu@DBG{yellow}\vrule
+                    depth \the\dimexpr \dp\@arstrutbox+\@tempdimb+\dimen@
+                                       +\extratabsurround-\@tempdimc
+                    height \z@
+                    width \tabustrutrule}\hss}\cr
+    }\ifnum0=`{\fi
+            \expandafter}\lasthline % we are then !
+}% \tabu@lasthlinecorrection
+\def\tabu@LT@@hline{%
+    \ifx\LT@next\hline
+        \global\let\LT@next \@gobble
+        \ifx \CT@drsc@\relax
+            \gdef\CT@LT@sep{%
+                \noalign{\penalty-\@medpenalty\vskip\doublerulesep}}%
+        \else
+            \gdef\CT@LT@sep{%
+                \multispan\LT@cols{%
+                \CT@drsc@\leaders\hrule\@height\doublerulesep\hfill}\cr}%
+        \fi
+    \else
+        \global\let\LT@next\empty
+        \gdef\CT@LT@sep{%
+            \noalign{\penalty-\@lowpenalty\vskip-\arrayrulewidth}}%
+    \fi
+    \ifnum0=`{\fi}%
+    \multispan\LT@cols
+        {\CT@arc@\leaders\hrule\@height\arrayrulewidth\hfill}\cr
+    \CT@LT@sep
+    \multispan\LT@cols
+        {\CT@arc@\leaders\hrule\@height\arrayrulewidth\hfill}\cr
+    \noalign{\penalty\@M}%
+    \LT@next
+}% \tabu@LT@@hline
+%% Horizontal lines : \tabucline ------------------------------------
+\let\tabu@start \@tempcnta
+\let\tabu@stop  \@tempcntb
+\newcommand*\tabucline{\noalign{\ifnum0=`}\fi \tabu@cline}
+\newcommand*\tabu@cline[2][]{\tabu@startstop{#2}%
+   \ifnum \tabu@stop<\z@   \toks@{}%
+   \else \tabu@clinearg{#1}\tabu@thestyle
+        \edef\tabucline{\toks@{%
+            \ifnum \tabu@start>\z@ \omit
+                  \tabu@multispan\tabu@start {\span\omit}&\fi
+            \omit \tabu@multispan\tabu@stop {\span\omit}%
+                                        \tabu@thehline\cr
+        }}\tabucline
+        \tabu@tracinglines{(tabu:tabucline) Style: #1^^J\the\toks@^^J^^J}%
+    \fi
+    \futurelet \tabu@temp \tabu@xcline
+}% \tabu@cline
+\def\tabu@clinearg #1{%
+    \ifx\\#1\\\let\tabu@thestyle \tabu@ls@
+    \else \@defaultunits \expandafter\let\expandafter\@tempa
+                                    \romannumeral-`\0#1\relax \@nnil
+        \ifx \hbox\@tempa           \tabu@clinebox{#1}%
+        \else\ifx \box\@tempa       \tabu@clinebox{#1}%
+        \else\ifx \vbox\@tempa      \tabu@clinebox{#1}%
+        \else\ifx \vtop\@tempa      \tabu@clinebox{#1}%
+        \else\ifx \copy\@tempa      \tabu@clinebox{#1}%
+        \else\ifx \leaders\@tempa   \tabu@clineleads{#1}%
+        \else\ifx \cleaders\@tempa  \tabu@clineleads{#1}%
+        \else\ifx \xleaders\@tempa  \tabu@clineleads{#1}%
+        \else\tabu@getline {#1}%
+        \fi\fi\fi\fi\fi\fi\fi\fi
+    \fi
+}% \tabu@clinearg
+\def\tabu@clinebox #1{\tabu@clineleads{\xleaders#1\hss}}
+\def\tabu@clineleads #1{%
+    \let\tabu@thestyle \relax \let\tabu@leaders \@undefined
+    \gdef\tabu@thehrule{#1}}
+\def\tabu@thehline{\begingroup
+    \ifdefined\tabu@leaders
+            \noexpand\tabu@thehleaders
+    \else   \noexpand\tabu@thehrule
+    \fi            \endgroup
+}% \tabu@thehline
+\def\tabu@xcline{%
+    \ifx \tabu@temp\tabucline
+        \toks@\expandafter{\the\toks@ \noalign
+        {\ifx\CT@drsc@\relax \vskip
+         \else \CT@drsc@\hrule height
+         \fi
+         \doublerulesep}}%
+    \fi
+    \tabu@docline
+}% \tabu@xcline
+\def\tabu@docline {\ifnum0=`{\fi \expandafter}\the\toks@}
+\def\tabu@docline@evr {\xdef\tabu@doclineafter{\the\toks@}%
+              \ifnum0=`{\fi}\aftergroup\tabu@doclineafter}
+\def\tabu@multispan #1#2{%
+    \ifnum\numexpr#1>\@ne #2\expandafter\tabu@multispan
+    \else                   \expandafter\@gobbletwo
+    \fi  {#1-1}{#2}%
+}% \tabu@multispan
+\def\tabu@startstop #1{\tabu@start@stop #1\relax 1-\tabu@nbcols \@nnil}
+\def\tabu@start@stop #1-#2\@nnil{%
+   \@defaultunits   \tabu@start\number 0#1\relax    \@nnil
+   \@defaultunits   \tabu@stop \number 0#2\relax    \@nnil
+   \tabu@stop   \ifnum \tabu@start>\tabu@nbcols     \m@ne
+                \else\ifnum \tabu@stop=\z@          \tabu@nbcols
+                \else\ifnum \tabu@stop>\tabu@nbcols \tabu@nbcols
+                \else                               \tabu@stop
+                \fi\fi\fi
+   \advance\tabu@start \m@ne
+   \ifnum \tabu@start>\z@ \advance\tabu@stop -\tabu@start \fi
+}% \tabu@start@stop
+%% Numbers: siunitx S columns  (and \tabudecimal) -------------------
+\def\tabu@tabudecimal #1{%
+    \def\tabu@decimal{#1}\@temptokena{}%
+    \let\tabu@getdecimal@ \tabu@getdecimal@ignorespaces
+    \tabu@scandecimal
+}% \tabu@tabudecimal
+\def\tabu@scandecimal{\futurelet \tabu@temp \tabu@getdecimal@}
+\def\tabu@skipdecimal#1{#1\tabu@scandecimal}
+\def\tabu@getdecimal@ignorespaces{%
+    \ifcase 0\ifx\tabu@temp\ignorespaces\else
+             \ifx\tabu@temp\@sptoken1\else
+             2\fi\fi\relax
+            \let\tabu@getdecimal@ \tabu@getdecimal
+            \expandafter\tabu@skipdecimal
+    \or     \expandafter\tabu@gobblespace\expandafter\tabu@scandecimal
+    \else   \expandafter\tabu@skipdecimal
+    \fi
+}% \tabu@getdecimal@ignorespaces
+\def\tabu@get@decimal#1{\@temptokena\expandafter{\the\@temptokena #1}%
+                        \tabu@scandecimal}
+\def\do#1{%
+    \def\tabu@get@decimalspace#1{%
+        \@temptokena\expandafter{\the\@temptokena #1}\tabu@scandecimal}%
+}\do{ }
+\let\tabu@@tabudecimal \tabu@tabudecimal
+\def\tabu@getdecimal{%
+   \ifcase    0\ifx 0\tabu@temp\else
+               \ifx 1\tabu@temp\else
+               \ifx 2\tabu@temp\else
+               \ifx 3\tabu@temp\else
+               \ifx 4\tabu@temp\else
+               \ifx 5\tabu@temp\else
+               \ifx 6\tabu@temp\else
+               \ifx 7\tabu@temp\else
+               \ifx 8\tabu@temp\else
+               \ifx 9\tabu@temp\else
+               \ifx .\tabu@temp\else
+               \ifx ,\tabu@temp\else
+               \ifx -\tabu@temp\else
+               \ifx +\tabu@temp\else
+               \ifx e\tabu@temp\else
+               \ifx E\tabu@temp\else
+               \ifx\tabu@cellleft\tabu@temp1\else
+               \ifx\ignorespaces\tabu@temp1\else
+               \ifx\@sptoken\tabu@temp2\else
+            3\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\fi\relax
+       \expandafter\tabu@get@decimal
+   \or \expandafter\tabu@skipdecimal
+   \or \expandafter\tabu@get@decimalspace
+   \else\expandafter\tabu@printdecimal
+   \fi
+}% \tabu@getdecimal
+\def\tabu@printdecimal{%
+    \edef\tabu@temp{\the\@temptokena}%
+    \ifx\tabu@temp\@empty\else
+    \ifx\tabu@temp\space\else
+        \expandafter\tabu@decimal\expandafter{\the\@temptokena}%
+    \fi\fi
+}% \tabu@printdecimal
+%% Verbatim inside X columns ----------------------------------------
+\def\tabu@verbatim{%
+    \let\verb \tabu@verb
+    \let\FV@DefineCheckEnd \tabu@FV@DefineCheckEnd
+}% \tabu@verbatim
+\let\tabu@ltx@verb \verb
+\def\tabu@verb{\@ifstar {\tabu@ltx@verb*} \tabu@ltx@verb}
+\def\tabu@fancyvrb {%
+    \def\tabu@FV@DefineCheckEnd ##1{%
+        \def\tabu@FV@DefineCheckEnd{%
+            ##1% <original definition (if fancyvrb is loaded)>
+            \let\FV@CheckEnd     \tabu@FV@CheckEnd
+            \let\FV@@CheckEnd    \tabu@FV@@CheckEnd
+            \let\FV@@@CheckEnd   \tabu@FV@@@CheckEnd
+            \edef\FV@EndScanning{%
+            \def\noexpand\next{\noexpand\end{\FV@EnvironName}}%
+                \global\let\noexpand\FV@EnvironName\relax
+                \noexpand\next}%
+            \xdef\FV@EnvironName{\detokenize\expandafter{\FV@EnvironName}}}%
+    }\expandafter\tabu@FV@DefineCheckEnd\expandafter{\FV@DefineCheckEnd}
+}% \tabu@fancyvrb
+\def\tabu@FV@CheckEnd  #1{\expandafter\FV@@CheckEnd \detokenize{#1\end{}}\@nil}
+\edef\tabu@FV@@@CheckEnd {\detokenize{\end{}}}
+\begingroup
+\catcode`\[1      \catcode`\]2
+\@makeother\{     \@makeother\}
+   \edef\x[\endgroup
+      \def\noexpand\tabu@FV@@CheckEnd ##1\detokenize[\end{]##2\detokenize[}]##3%
+   ]\x               \@nil{\def\@tempa{#2}\def\@tempb{#3}}
+\def\tabu@FV@ListProcessLine #1{%
+  \hbox {%to \hsize{%
+    \kern\leftmargin
+    \hbox {%to \linewidth{%
+      \FV@LeftListNumber
+      \FV@LeftListFrame
+      \FancyVerbFormatLine{#1}\hss
+%% DG/SR modification begin - Jan. 28, 1998 (for numbers=right add-on)
+%%      \FV@RightListFrame}%
+      \FV@RightListFrame
+      \FV@RightListNumber}%
+%% DG/SR modification end
+    \hss}}
+%% \savetabu --------------------------------------------------------
+\newcommand*\savetabu[1]{\noalign{%
+    \tabu@sanitizearg{#1}\tabu@temp
+    \ifx \tabu@temp\@empty  \tabu@savewarn{}{The tabu will not be saved}\else
+        \@ifundefined{tabu@saved@\tabu@temp}{}{\tabu@savewarn{#1}{Overwriting}}%
+        \ifdefined\tabu@restored \expandafter\let
+            \csname tabu@saved@\tabu@temp \endcsname \tabu@restored
+        \else {\tabu@save}%
+        \fi
+    \fi}%
+}% \savetabu
+\def\tabu@save {%
+    \toks0\expandafter{\tabu@saved@}%
+    \iftabu@negcoef
+        \let\tabu@wddef \relax \let\tabu@ \tabu@savewd \edef\tabu@savewd{\tabu@Xcoefs}%
+        \toks0\expandafter{\the\toks\expandafter0\tabu@savewd}\fi
+    \toks1\expandafter{\tabu@savedpream}%
+    \toks2\expandafter{\tabu@savedpreamble}%
+    \let\@preamble \relax
+    \let\tabu@savedpream \relax \let\tabu@savedparams \relax
+    \edef\tabu@preamble{%
+        \def\noexpand\tabu@aligndefault{\tabu@align}%
+        \def\tabu@savedparams {\noexpand\the\toks0}%
+        \def\tabu@savedpream  {\noexpand\the\toks1}}%
+    \edef\tabu@usetabu{%
+        \def\@preamble {\noexpand\the\toks2}%
+        \tabu@target \the\tabu@target \relax
+        \tabucolX    \the\tabucolX    \relax
+        \tabu@nbcols \the\tabu@nbcols \relax
+        \def\noexpand\tabu@aligndefault{\tabu@align}%
+        \def\tabu@savedparams {\noexpand\the\toks0}%
+        \def\tabu@savedpream  {\noexpand\the\toks1}}%
+    \let\tabu@aligndefault \relax \let\@sharp \relax
+    \edef\@tempa{\noexpand\tabu@s@ved
+                          {\tabu@usetabu}
+                         {\tabu@preamble}
+                            {\the\toks1}}\@tempa
+    \tabu@message@save
+}% \tabu@save
+\long\def\tabu@s@ved #1#2#3{%
+    \def\tabu@usetabu{#1}% <for \tabu@message@save>
+    \expandafter\gdef\csname tabu@saved@\tabu@temp\endcsname ##1{%
+        \ifodd ##1%     \usetabu
+            \tabu@measuringfalse \tabu@spreadfalse  % Just in case...
+            \gdef\tabu@usetabu {%
+                \ifdim \tabu@target>\z@ \tabu@warn@usetabu \fi
+                \global\let\tabu@usetabu \@undefined
+                \def\@halignto {to\tabu@target}%
+                #1%
+                \ifx \tabu@align\tabu@aligndefault@text
+                \ifnum \tabu@nested=\z@
+                       \let\tabu@align \tabu@aligndefault \fi\fi}%
+        \else     %     \preamble
+            \gdef\tabu@preamble {%
+                \global\let\tabu@preamble \@undefined
+                #2%
+                \ifx \tabu@align\tabu@aligndefault@text
+                \ifnum \tabu@nested=\z@
+                       \let\tabu@align \tabu@aligndefault \fi\fi}%
+        \fi
+        #3}%
+}% \tabu@s@ved
+\def\tabu@aligndefault@text {\tabu@aligndefault}%
+\def\tabu@warn@usetabu {\PackageWarning{tabu}
+    {Specifying a target with \string\usetabu\space is useless
+    \MessageBreak The target cannot be changed!}}
+\def\tabu@savewd #1#2{\ifdim #2\p@<\z@ \tabu@wddef{#1}{\tabu@wd{#1}}\fi}
+\def\tabu@savewarn#1#2{\PackageInfo{tabu}
+    {User-name `#1' already used for \string\savetabu
+    \MessageBreak #2}}%
+\def\tabu@saveerr#1{\PackageError{tabu}
+    {User-name `#1' is unknown for \string\usetabu
+    \MessageBreak I cannot restore an unknown preamble!}\@ehd}
+%% \rowfont ---------------------------------------------------------
+\newskip \tabu@cellskip
+\def\tabu@rowfont{\ifdim \baselineskip=\z@\noalign\fi
+                    {\ifnum0=`}\fi    \tabu@row@font}
+\newcommand*\tabu@row@font[2][]{%
+    \ifnum7=\currentgrouptype
+        \global\let\tabu@@cellleft    \tabu@cellleft
+        \global\let\tabu@@cellright   \tabu@cellright
+        \global\let\tabu@@celllalign  \tabu@celllalign
+        \global\let\tabu@@cellralign  \tabu@cellralign
+        \global\let\tabu@@rowfontreset\tabu@rowfontreset
+    \fi
+    \global\let\tabu@rowfontreset \tabu@rowfont@reset
+    \expandafter\gdef\expandafter\tabu@cellleft\expandafter{\tabu@cellleft #2}%
+    \ifcsname tabu@cell@#1\endcsname       % row alignment
+            \csname tabu@cell@#1\endcsname \fi
+    \ifnum0=`{\fi}% end of group / noalign group
+}% \rowfont
+\def\tabu@ifcolorleavevmode #1{\let\color \tabu@leavevmodecolor #1\let\color\tabu@color}%
+\def\tabu@rowfont@reset{%
+    \global\let\tabu@rowfontreset \tabu@@rowfontreset
+    \global\let\tabu@cellleft     \tabu@@cellleft
+    \global\let\tabu@cellright    \tabu@@cellright
+    \global\let\tabu@cellfont     \@empty
+    \global\let\tabu@celllalign   \tabu@@celllalign
+    \global\let\tabu@cellralign   \tabu@@cellralign
+}% \tabu@@rowfontreset
+\let\tabu@rowfontreset \@empty     % overwritten \AtBeginDocument if colortbl
+%% \tabu@prepnext@tok -----------------------------------------------
+\newif \iftabu@cellright
+\def\tabu@prepnext@tok{%
+    \ifnum \count@<\z@   % <first initialisation>
+            \@tempcnta  \@M   % <not initialized by array.sty>
+            \tabu@nbcols\z@
+            \let\tabu@fornoopORI \@fornoop
+            \tabu@cellrightfalse
+    \else
+        \ifcase \numexpr \count@-\@tempcnta \relax % (case 0): prev. token is left
+                \advance \tabu@nbcols \@ne
+                \iftabu@cellright % before-previous token is right and is finished
+                    \tabu@cellrightfalse % <only once>
+                    \tabu@righttok
+                \fi
+                \tabu@lefttok
+        \or                     % (case 1) previous token is right
+                \tabu@cellrighttrue \let\@fornoop \tabu@lastnoop
+        \else % special column: do not change the token
+                \iftabu@cellright    % before-previous token is right
+                    \tabu@cellrightfalse
+                    \tabu@righttok
+                \fi
+        \fi % \ifcase
+    \fi
+    \tabu@prepnext@tokORI
+}% \tabu@prepnext@tok
+\long\def\tabu@lastnoop#1\@@#2#3{\tabu@lastn@@p #2\@nextchar \in@\in@@}
+\def\tabu@lastn@@p #1\@nextchar #2#3\in@@{%
+    \ifx \in@#2\else
+        \let\@fornoop \tabu@fornoopORI
+        \xdef\tabu@mkpreambuffer{\tabu@nbcols\the\tabu@nbcols \tabu@mkpreambuffer}%
+        \toks0\expandafter{\expandafter\tabu@everyrowtrue \the\toks0}%
+        \expandafter\prepnext@tok
+    \fi
+}% \tabu@lastnoop
+\def\tabu@righttok{%
+    \advance \count@ \m@ne
+    \toks\count@\expandafter {\the\toks\count@ \tabu@cellright \tabu@cellralign}%
+    \advance \count@ \@ne
+}% \tabu@righttok
+\def\tabu@lefttok{\toks\count@\expandafter{\expandafter\tabu@celllalign
+                                    \the\toks\count@ \tabu@cellleft}% after because of $
+}% \tabu@lefttok
+%% Neutralisation of glues ------------------------------------------
+\let\tabu@cellleft   \@empty
+\let\tabu@cellright  \@empty
+\tabu@celllalign@def{\tabu@cellleft}%
+\let\tabu@cellralign \@empty
+\def\tabu@cell@align #1#2#3{%
+    \let\tabu@maybesiunitx \toks@ \tabu@celllalign
+    \global \expandafter \tabu@celllalign@def \expandafter {\the\toks@ #1}%
+    \toks@\expandafter{\tabu@cellralign #2}%
+    \xdef\tabu@cellralign{\the\toks@}%
+    \toks@\expandafter{\tabu@cellleft #3}%
+    \xdef\tabu@cellleft{\the\toks@}%
+}% \tabu@cell@align
+\def\tabu@cell@l{% force alignment to left
+   \tabu@cell@align
+      {\tabu@removehfil \raggedright \tabu@cellleft}% left
+      {\tabu@flush1\tabu@ignorehfil}%                 right
+      \raggedright
+}% \tabu@cell@l
+\def\tabu@cell@c{% force alignment to center
+   \tabu@cell@align
+      {\tabu@removehfil \centering \tabu@flush{.5}\tabu@cellleft}
+      {\tabu@flush{.5}\tabu@ignorehfil}
+      \centering
+}% \tabu@cell@c
+\def\tabu@cell@r{% force alignment to right
+   \tabu@cell@align
+      {\tabu@removehfil \raggedleft \tabu@flush1\tabu@cellleft}
+      \tabu@ignorehfil
+      \raggedleft
+}% \tabu@cell@r
+\def\tabu@cell@j{% force justification (for p, m, b columns)
+      \tabu@cell@align
+         {\tabu@justify\tabu@cellleft}
+         {}
+         \tabu@justify
+}% \tabu@cell@j
+\def\tabu@justify{%
+   \leftskip\z@skip \@rightskip\leftskip \rightskip\@rightskip
+   \parfillskip\@flushglue
+}% \tabu@justify
+%% ragged2e settings
+\def\tabu@cell@L{% force alignment to left (ragged2e)
+   \tabu@cell@align
+      {\tabu@removehfil \RaggedRight \tabu@cellleft}
+      {\tabu@flush 1\tabu@ignorehfil}
+      \RaggedRight
+}% \tabu@cell@L
+\def\tabu@cell@C{% force alignment to center (ragged2e)
+   \tabu@cell@align
+      {\tabu@removehfil \Centering \tabu@flush{.5}\tabu@cellleft}
+      {\tabu@flush{.5}\tabu@ignorehfil}
+      \Centering
+}% \tabu@cell@C
+\def\tabu@cell@R{% force alignment to right (ragged2e)
+   \tabu@cell@align
+      {\tabu@removehfil \RaggedLeft \tabu@flush 1\tabu@cellleft}
+      \tabu@ignorehfil
+      \RaggedLeft
+}% \tabu@cell@R
+\def\tabu@cell@J{% force justification (ragged2e)
+   \tabu@cell@align
+      {\justifying \tabu@cellleft}
+      {}
+      \justifying
+}% \tabu@cell@J
+\def\tabu@flush#1{%
+    \iftabu@colortbl      % colortbl uses \hfill rather than \hfil
+        \hskip \ifnum13<\currentgrouptype \stretch{#1}%
+        \else  \ifdim#1pt<\p@ \tabu@cellskip
+        \else  \stretch{#1}
+        \fi\fi \relax
+    \else                % array.sty
+        \ifnum 13<\currentgrouptype
+                \hfil \hskip1sp \relax  \fi
+    \fi
+}% \tabu@flush
+\let\tabu@hfil  \hfil
+\let\tabu@hfill \hfill
+\let\tabu@hskip \hskip
+\def\tabu@removehfil{%
+    \iftabu@colortbl
+        \unkern \tabu@cellskip =\lastskip
+        \ifnum\gluestretchorder\tabu@cellskip =\tw@ \hskip-\tabu@cellskip
+        \else \tabu@cellskip \z@skip
+        \fi
+    \else
+        \ifdim\lastskip=1sp\unskip\fi
+        \ifnum\gluestretchorder\lastskip =\@ne
+            \hfilneg % \hfilneg for array.sty but not for colortbl...
+        \fi
+    \fi
+}% \tabu@removehfil
+\def\tabu@ignorehfil{\aftergroup \tabu@nohfil}
+\def\tabu@nohfil{% \hfil -> do nothing + restore original \hfil
+   \def\hfil{\let\hfil \tabu@hfil}%   local to (alignment template) group
+}% \tabu@nohfil
+\def\tabu@colortblalignments {% if colortbl
+    \def\tabu@nohfil{%
+        \def\hfil  {\let\hfil \tabu@hfil}% local to (alignment template) group
+        \def\hfill {\let\hfill \tabu@hfill}% (colortbl uses \hfill) pfff...
+        \def\hskip ####1\relax{\let\hskip \tabu@hskip}}% local
+}% \tabu@colortblalignments
+%% Taking care of footnotes and hyperfootnotes ----------------------
+\long\def\tabu@footnotetext #1{%
+   \edef\@tempa{\the\tabu@footnotes
+      \noexpand\footnotetext [\the\csname c@\@mpfn\endcsname]}%
+   \global\tabu@footnotes\expandafter{\@tempa {#1}}}%
+\long\def\tabu@xfootnotetext [#1]#2{%
+   \global\tabu@footnotes\expandafter{\the\tabu@footnotes
+                               \footnotetext [{#1}]{#2}}}
+\let\tabu@xfootnote \@xfootnote
+\long\def\tabu@Hy@ftntext{\tabu@Hy@ftntxt {\the \c@footnote }}
+\long\def\tabu@Hy@xfootnote [#1]{%
+   \begingroup
+      \value\@mpfn #1\relax
+      \protected@xdef \@thefnmark  {\thempfn}%
+   \endgroup
+   \@footnotemark \tabu@Hy@ftntxt {#1}%
+}% \tabu@Hy@xfootnote
+\long\def\tabu@Hy@ftntxt #1#2{%
+    \edef\@tempa{%
+        \the\tabu@footnotes
+        \begingroup
+            \value\@mpfn #1\relax
+            \noexpand\protected@xdef\noexpand\@thefnmark {\noexpand\thempfn}%
+            \expandafter \noexpand \expandafter
+                \tabu@Hy@footnotetext \expandafter{\Hy@footnote@currentHref}%
+    }%
+    \global\tabu@footnotes\expandafter{\@tempa {#2}%
+                                         \endgroup}%
+}% \tabu@Hy@ftntxt
+\long\def\tabu@Hy@footnotetext #1#2{%
+    \H@@footnotetext{%
+        \ifHy@nesting
+            \hyper@@anchor {#1}{#2}%
+        \else
+            \Hy@raisedlink{%
+                \hyper@@anchor {#1}{\relax}%
+            }%
+            \def\@currentHref {#1}%
+            \let\@currentlabelname \@empty
+            #2%
+        \fi
+    }%
+}% \tabu@Hy@footnotetext
+%% No need for \arraybackslash ! ------------------------------------
+\def\tabu@latextwoe {%
+\def\tabu@temp##1##2##3{{\toks@\expandafter{##2##3}\xdef##1{\the\toks@}}}
+\tabu@temp \tabu@centering   \centering   \arraybackslash
+\tabu@temp \tabu@raggedleft  \raggedleft  \arraybackslash
+\tabu@temp \tabu@raggedright \raggedright \arraybackslash
+}% \tabu@latextwoe
+\def\tabu@raggedtwoe {%
+\def\tabu@temp ##1##2##3{{\toks@\expandafter{##2##3}\xdef##1{\the\toks@}}}
+\tabu@temp \tabu@Centering   \Centering   \arraybackslash
+\tabu@temp \tabu@RaggedLeft  \RaggedLeft  \arraybackslash
+\tabu@temp \tabu@RaggedRight \RaggedRight \arraybackslash
+\tabu@temp \tabu@justifying  \justifying  \arraybackslash
+}% \tabu@raggedtwoe
+\def\tabu@normalcrbackslash{\let\\\@normalcr}
+\def\tabu@trivlist{\expandafter\def\expandafter\@trivlist\expandafter{%
+                       \expandafter\tabu@normalcrbackslash \@trivlist}}
+%% Utilities: \fbox  \fcolorbox  and \tabudecimal -------------------
+\def\tabu@fbox      {\leavevmode\afterassignment\tabu@beginfbox \setbox\@tempboxa\hbox}
+\def\tabu@beginfbox {\bgroup \kern\fboxsep
+                     \bgroup\aftergroup\tabu@endfbox}
+\def\tabu@endfbox   {\kern\fboxsep\egroup\egroup
+                     \@frameb@x\relax}
+\def\tabu@color@b@x #1#2{\leavevmode \bgroup
+    \def\tabu@docolor@b@x{#1{#2\color@block{\wd\z@}{\ht\z@}{\dp\z@}\box\z@}}%
+    \afterassignment\tabu@begincolor@b@x \setbox\z@ \hbox
+}% \tabu@color@b@x
+\def\tabu@begincolor@b@x {\kern\fboxsep \bgroup
+       \aftergroup\tabu@endcolor@b@x \set@color}
+\def\tabu@endcolor@b@x {\kern\fboxsep \egroup
+    \dimen@\ht\z@ \advance\dimen@ \fboxsep \ht\z@ \dimen@
+    \dimen@\dp\z@ \advance\dimen@ \fboxsep \dp\z@ \dimen@
+    \tabu@docolor@b@x \egroup
+}% \tabu@endcolor@b@x
+%% Corrections (arydshln, delarray, colortbl) -----------------------
+\def\tabu@fix@arrayright {%% \@arrayright is missing from \endarray
+    \iftabu@colortbl
+        \ifdefined\adl@array  % <colortbl + arydshln>
+        \def\tabu@endarray{%
+            \adl@endarray \egroup \adl@arrayrestore \CT@end \egroup %<original>
+            \@arrayright      % <FC>
+            \gdef\@preamble{}}% <FC>
+        \else                 % <colortbl / no arydshln>
+        \def\tabu@endarray{%
+            \crcr \egroup \egroup    %<original>
+            \@arrayright             % <FC>
+            \gdef\@preamble{}\CT@end}%
+        \fi
+    \else
+        \ifdefined\adl@array  % <arydshln / no colortbl>
+        \def\tabu@endarray{%
+            \adl@endarray \egroup \adl@arrayrestore \egroup %<original>
+            \@arrayright      % <FC>
+            \gdef\@preamble{}}% <FC>
+    \else                   % <no arydshln / no colotbl + \@arrayright missing>
+        \PackageWarning{tabu}
+        {\string\@arrayright\space is missing from the
+        \MessageBreak definition of \string\endarray.
+        \MessageBreak Compatibility with delarray.sty is broken.}%
+    \fi\fi
+}% \tabu@fix@arrayright
+\def\tabu@adl@xarraydashrule #1#2#3{%
+     \ifnum\@lastchclass=\adl@class@start\else
+     \ifnum\@lastchclass=\@ne\else
+     \ifnum\@lastchclass=5 \else % <FC> @-arg (class 5) and !-arg (class 1)
+             \adl@leftrulefalse \fi\fi           % must be treated the same
+     \fi
+     \ifadl@zwvrule\else \ifadl@inactive\else
+             \@addtopreamble{\vrule\@width\arrayrulewidth
+                     \@height\z@ \@depth\z@}\fi \fi
+     \ifadl@leftrule
+             \@addtopreamble{\adl@vlineL{\CT@arc@}{\adl@dashgapcolor}%
+                     {\number#1}#3}%
+     \else   \@addtopreamble{\adl@vlineR{\CT@arc@}{\adl@dashgapcolor}%
+                     {\number#2}#3}
+     \fi
+}% \tabu@adl@xarraydashrule
+\def\tabu@adl@act@endpbox {%
+    \unskip \ifhmode \nobreak \fi    \@finalstrut \@arstrutbox
+    \egroup \egroup
+    \adl@colhtdp \box\adl@box \hfil
+}% \tabu@adl@act@endpbox
+\def\tabu@adl@fix {%
+    \let\adl@xarraydashrule \tabu@adl@xarraydashrule % <fix> arydshln
+    \let\adl@act@endpbox    \tabu@adl@act@endpbox    % <fix> arydshln
+    \let\adl@act@@endpbox   \tabu@adl@act@endpbox    % <fix> arydshln
+    \let\@preamerror        \@preamerr               % <fix> arydshln
+}% \tabu@adl@fix
+%% Correction for longtable' \@startbox definition ------------------
+%%    => \everypar is ``missing'' : TeX should be in vertical mode
+\def\tabu@LT@startpbox #1{%
+    \bgroup
+        \let\@footnotetext\LT@p@ftntext
+        \setlength\hsize{#1}%
+        \@arrayparboxrestore
+        \everypar{%
+            \vrule \@height \ht\@arstrutbox \@width \z@
+            \everypar{}}%
+}% \tabu@LT@startpbox
+%% \tracingtabu  and  the package options ------------------
+\DeclareOption{delarray}{\AtEndOfPackage{\RequirePackage{delarray}}}
+\DeclareOption{linegoal}{%
+   \AtEndOfPackage{%
+      \RequirePackage{linegoal}[2010/12/07]%
+      \let\tabudefaulttarget \linegoal% \linegoal is \linewidth if not pdfTeX
+}}
+\DeclareOption{scantokens}{\tabuscantokenstrue}
+\DeclareOption{debugshow}{\AtEndOfPackage{\tracingtabu=\tw@}}
+\def\tracingtabu {\begingroup\@ifnextchar=%
+    {\afterassignment\tabu@tracing\count@}
+    {\afterassignment\tabu@tracing\count@1\relax}}
+\def\tabu@tracing{\expandafter\endgroup
+    \expandafter\tabu@tr@cing \the\count@ \relax
+}% \tabu@tracing
+\def\tabu@tr@cing #1\relax {%
+    \ifnum#1>\thr@@ \let\tabu@tracinglines\message
+    \else           \let\tabu@tracinglines\@gobble
+    \fi
+    \ifnum#1>\tw@   \let\tabu@DBG        \tabu@@DBG
+                    \def\tabu@mkarstrut {\tabu@DBG@arstrut}%
+                    \tabustrutrule      1.5\p@
+    \else           \let\tabu@DBG        \@gobble
+                    \def\tabu@mkarstrut {\tabu@arstrut}%
+                    \tabustrutrule      \z@
+    \fi
+    \ifnum#1>\@ne   \let\tabu@debug      \message
+    \else           \let\tabu@debug      \@gobble
+    \fi
+    \ifnum#1>\z@
+        \let\tabu@message             \message
+        \let\tabu@tracing@save        \tabu@message@save
+        \let\tabu@starttimer          \tabu@pdftimer
+    \else
+        \let\tabu@message             \@gobble
+        \let\tabu@tracing@save        \@gobble
+        \let\tabu@starttimer          \relax
+    \fi
+}% \tabu@tr@cing
+%% Setup \AtBeginDocument
+\AtBeginDocument{\tabu@AtBeginDocument}
+\def\tabu@AtBeginDocument{\let\tabu@AtBeginDocument \@undefined
+    \ifdefined\arrayrulecolor   \tabu@colortbltrue       % <colortbl>
+                                \tabu@colortblalignments % different glues are used
+    \else                       \tabu@colortblfalse \fi
+    \ifdefined\CT@arc@ \else \let\CT@arc@  \relax \fi
+    \ifdefined\CT@drsc@\else \let\CT@drsc@ \relax \fi
+    \let\tabu@arc@L \CT@arc@ \let\tabu@drsc@L \CT@drsc@
+    \ifodd 1\ifcsname siunitx_table_collect_begin:Nn\endcsname   % <siunitx: ok>
+            \expandafter\ifx
+                \csname siunitx_table_collect_begin:Nn\endcsname\relax 0\fi\fi\relax
+            \tabu@siunitxtrue
+    \else   \let\tabu@maybesiunitx   \@firstofone                % <not siunitx: setup>
+            \let\tabu@siunitx        \tabu@nosiunitx
+            \tabu@siunitxfalse
+    \fi
+    \ifdefined\adl@array        % <arydshln>
+    \else     \let\tabu@adl@fix \relax
+              \let\tabu@adl@endtrial \@empty \fi
+    \ifdefined\longtable        % <longtable>
+    \else     \let\longtabu \tabu@nolongtabu \fi
+    \ifdefined\cellspacetoplimit \tabu@warn@cellspace\fi
+    \csname\ifcsname ifHy@hyperfootnotes\endcsname % <hyperfootnotes>
+            ifHy@hyperfootnotes\else iffalse\fi\endcsname
+        \let\tabu@footnotetext \tabu@Hy@ftntext
+        \let\tabu@xfootnote    \tabu@Hy@xfootnote \fi
+    \ifdefined\FV@DefineCheckEnd% <fancyvrb>
+            \tabu@fancyvrb  \fi
+    \ifdefined\color            % <color / xcolor>
+        \let\tabu@color \color
+        \def\tabu@leavevmodecolor ##1{%
+            \def\tabu@leavevmodecolor {\leavevmode ##1}%
+        }\expandafter\tabu@leavevmodecolor\expandafter{\color}%
+    \else
+        \let\tabu@color           \tabu@nocolor
+        \let\tabu@leavevmodecolor \@firstofone \fi
+    \tabu@latextwoe
+    \ifdefined\@raggedtwoe@everyselectfont    % <ragged2e>
+        \tabu@raggedtwoe
+    \else
+        \let\tabu@cell@L \tabu@cell@l
+        \let\tabu@cell@R \tabu@cell@r
+        \let\tabu@cell@C \tabu@cell@c
+        \let\tabu@cell@J \tabu@cell@j   \fi
+    \expandafter\in@ \expandafter\@arrayright \expandafter{\endarray}%
+    \ifin@ \let\tabu@endarray \endarray
+    \else  \tabu@fix@arrayright \fi% <fix for colortbl & arydshln (delarray)>
+    \everyrow{}%
+}% \tabu@AtBeginDocument
+\def\tabu@warn@cellspace{%
+    \PackageWarning{tabu}{%
+                  Package cellspace has some limitations
+    \MessageBreak And redefines some macros of array.sty.
+    \MessageBreak Please use \string\tabulinesep\space to control
+    \MessageBreak vertical spacing of lines inside tabu environment}%
+}% \tabu@warn@cellspace
+%% tabu Package initialisation
+\tabuscantokensfalse
+\let\tabu@arc@G         \relax
+\let\tabu@drsc@G        \relax
+\let\tabu@evr@G         \@empty
+\let\tabu@rc@G          \@empty
+\def\tabu@ls@G          {\tabu@linestyle@}%
+\let\tabu@@rowfontreset \@empty % <init>
+\let\tabu@@celllalign   \@empty
+\let\tabu@@cellralign   \@empty
+\let\tabu@@cellleft     \@empty
+\let\tabu@@cellright    \@empty
+\def\tabu@naturalXmin   {\z@}
+\def\tabu@naturalXmax   {\z@}
+\let\tabu@rowfontreset  \@empty
+\def\tabulineon {4pt}\let\tabulineoff \tabulineon
+\tabu@everyrowtrue
+\ifdefined\pdfelapsedtime                   % <pdfTeX>
+        \def\tabu@pdftimer {\xdef\tabu@starttime{\the\pdfelapsedtime}}%
+\else   \let\tabu@pdftimer \relax \let\tabu@message@etime \relax
+\fi
+\tracingtabu=\z@
+\newtabulinestyle {=\maxdimen}% creates the 'factory' settings \tabu@linestyle@
+\tabulinestyle{}
+\taburowcolors{}
+\let\tabudefaulttarget  \linewidth
+\ProcessOptions*                % \ProcessOptions* is quicker !
+\endinput
+%%
+%% End of file `tabu.sty'.